commit 684d1bcb3b0e12adee29cd3c83f99aca49cd201e
Author: James Monroe <jmonroe@ravensoft.com>
Date:   Thu Apr 4 17:35:38 2013 -0500

    Jedi Academy Release

diff --git a/code/0_compiled_first/0_SH_Leak.cpp b/code/0_compiled_first/0_SH_Leak.cpp
new file mode 100644
index 0000000..adfd5a5
--- /dev/null
+++ b/code/0_compiled_first/0_SH_Leak.cpp
@@ -0,0 +1,774 @@
+// leave this as first line for PCH reasons...
+//
+#pragma warning( disable : 4786) 
+#pragma warning( disable : 4100) 
+#pragma warning( disable : 4663) 
+#include <windows.h>
+
+#include "..\smartheap\smrtheap.h"
+#include "../game/q_shared.h"
+#include "..\qcommon\qcommon.h"
+
+#include <stdio.h>
+#include <map>
+
+using namespace std;
+
+#if MEM_DEBUG
+#include "..\smartheap\heapagnt.h"
+
+static const int maxStack=2048;
+static int TotalMem;
+static int TotalBlocks;
+static int nStack;
+static char StackNames[maxStack][256];
+static int StackSize[maxStack];
+static int StackCount[maxStack];
+static int StackCache[48];
+static int StackCacheAt=0;
+static int CheckpointSize[3000];
+static int CheckpointCount[3000];
+
+//#define _FASTRPT_
+
+
+#ifdef _FASTRPT_
+class CMyStrComparator
+{
+public:
+	bool operator()(const char *s1, const char *s2) const { return(strcmp(s1, s2) < 0); } 
+};
+
+hmap<const char *,int,CMyStrComparator> Lookup;
+#endif
+
+cvar_t	*mem_leakfile;
+cvar_t	*mem_leakreport;
+
+MEM_BOOL MEM_CALLBACK MyMemReporter2(MEM_ERROR_INFO *info)
+{
+	static char buffer[10000];
+	if (!info->objectCreationInfo)
+		return 1;
+	info=info->objectCreationInfo;
+	int idx=info->checkpoint;
+	if (idx<0||idx>=1000)
+	{
+		idx=0;
+	}
+	CheckpointCount[idx]++;
+	CheckpointSize[idx]+=info->argSize;
+	dbgMemFormatCall(info,buffer,9999);
+	if (strstr(buffer,"ntdll"))
+		return 1;
+	if (strstr(buffer,"CLBCATQ"))
+		return 1;
+	int i;
+	TotalBlocks++;
+	if (TotalBlocks%1000==0)
+	{
+		char mess[1000];
+		sprintf(mess,"%d blocks processed\n",TotalBlocks);
+		OutputDebugString(mess);
+	}
+	for (i=strlen(buffer);i>0;i--)
+	{
+		if (buffer[i]=='\n')
+			break;
+	}
+	if (!i)
+		return 1;
+	buffer[i]=0;
+	char *buf=buffer;
+	while (*buf)
+	{
+		if (*buf=='\n')
+		{
+			buf++;
+			break;
+		}
+		buf++;
+	}
+	char *start=0;
+	char *altName=0;
+	while (*buf)
+	{
+		while (*buf==' ')
+			buf++;
+		start=buf;
+		while (*buf!=0&&*buf!='\n')
+			buf++;
+		if (*start)
+		{
+			if (*buf)
+			{
+				*buf=0;
+				buf++;
+			}
+			if (strlen(start)>255)
+				start[255]=0;
+			if (strstr(start,"std::"))
+			{
+				altName="std::??";
+//				start=0;
+				continue;
+			}
+			if (strstr(start,"Malloc"))
+			{
+				altName="Malloc??";
+				start=0;
+				continue;
+			}
+			if (strstr(start,"G_Alloc"))
+			{
+				altName="G_Alloc";
+				start=0;
+				continue;
+			}
+			if (strstr(start,"Hunk_Alloc"))
+			{
+				altName="Hunk_Alloc";
+				start=0;
+				continue;
+			}
+			if (strstr(start,"FS_LoadFile"))
+			{
+				altName="FS_LoadFile";
+				start=0;
+				continue;
+			}
+			if (strstr(start,"CopyString"))
+			{
+				altName="CopyString";
+				start=0;
+				continue;
+			}
+			break;
+		}
+	}
+	if (!start||!*start)
+	{
+		start=altName;
+		if (!start||!*start)
+		{
+			start="UNKNOWN";
+		}
+	}
+#ifdef _FASTRPT_
+	hmap<const char *,int,CMyStrComparator>::iterator f=Lookup.find(start);
+	if(f==Lookup.end())
+	{
+		strcpy(StackNames[nStack++],start);
+		Lookup[(const char *)&StackNames[nStack-1]]=nStack-1;
+		StackSize[nStack-1]=info->argSize;
+		StackCount[nStack-1]=1;
+	}
+	else
+	{
+		StackSize[(*f).second]+=info->argSize;
+		StackCount[(*f).second]++;
+	}
+#else
+	for (i=0;i<48;i++)
+	{
+		if (StackCache[i]<0||StackCache[i]>=nStack)
+			continue;
+		if (!strcmpi(start,StackNames[StackCache[i]]))
+			break;
+	}
+	if (i<48)
+	{
+		StackSize[StackCache[i]]+=info->argSize;
+		StackCount[StackCache[i]]++;
+	}
+	else
+	{
+		for (i=0;i<nStack;i++)
+		{
+			if (!strcmpi(start,StackNames[i]))
+				break;
+		}
+		if (i<nStack)
+		{
+			StackSize[i]+=info->argSize;
+			StackCount[i]++;
+			StackCache[StackCacheAt]=i;
+			StackCacheAt++;
+			if (StackCacheAt>=48)
+				StackCacheAt=0;
+		}
+		else if (i<maxStack)
+		{
+			strcpy(StackNames[i],start);
+			StackSize[i]=info->argSize;
+			StackCount[i]=1;
+			nStack++;
+		}
+		else if (nStack<maxStack)
+		{
+			nStack++;
+			strcpy(StackNames[maxStack-1],"*****OTHER*****");
+			StackSize[maxStack-1]=info->argSize;
+			StackCount[maxStack-1]=1;
+		}
+		else
+		{
+			StackSize[maxStack-1]+=info->argSize;
+			StackCount[maxStack-1]++;
+		}
+	}
+#endif
+	TotalMem+=info->argSize;
+	return 1;
+}
+
+MEM_BOOL MEM_CALLBACK MyMemReporter3(MEM_ERROR_INFO *info)
+{
+	static char buffer[10000];
+	if (!info->objectCreationInfo)
+		return 1;
+	info=info->objectCreationInfo;
+	int idx=info->checkpoint;
+	if (idx<0||idx>=3000)
+	{
+		idx=0;
+	}
+	CheckpointCount[idx]++;
+	CheckpointSize[idx]+=info->argSize;
+	dbgMemFormatCall(info,buffer,9999);
+	int i;
+	TotalBlocks++;
+//	if (TotalBlocks%1000==0)
+//	{
+//		char mess[1000];
+//		sprintf(mess,"%d blocks processed\n",TotalBlocks);
+//		OutputDebugString(mess);
+//	}
+	for (i=strlen(buffer);i>0;i--)
+	{
+		if (buffer[i]=='\n')
+			break;
+	}
+	if (!i)
+		return 1;
+	buffer[i]=0;
+	char *buf=buffer;
+	while (*buf)
+	{
+		if (*buf=='\n')
+		{
+			buf++;
+			break;
+		}
+		buf++;
+	}
+	char *start=0;
+	char *altName=0;
+	while (*buf)
+	{
+		while (*buf==' ')
+			buf++;
+		start=buf;
+		while (*buf!=0&&*buf!='\n')
+			buf++;
+		if (*start)
+		{
+			if (*buf)
+			{
+				*buf=0;
+				buf++;
+			}
+			if (strlen(start)>255)
+				start[255]=0;
+			if (strstr(start,"SV_AreaEntities"))
+			{
+				altName="SV_AreaEntities??";
+				start=0;
+				continue;
+			}
+			if (strstr(start,"SV_Trace"))
+			{
+				altName="SV_Trace??";
+				start=0;
+				continue;
+			}
+			if (strstr(start,"SV_PointContents"))
+			{
+				altName="SV_PointContents??";
+				start=0;
+				continue;
+			}
+			if (strstr(start,"CG_Trace"))
+			{
+				altName="??";
+				start=0;
+				continue;
+			}
+			if (strstr(start,"CG_PointContents"))
+			{
+				altName="??";
+				start=0;
+				continue;
+			}
+/*
+			if (strstr(start,""))
+			{
+				altName="??";
+				start=0;
+				continue;
+			}
+			if (strstr(start,""))
+			{
+				altName="??";
+				start=0;
+				continue;
+			}
+*/
+			break;
+		}
+	}
+	if (!start||!*start)
+	{
+		start=altName;
+		if (!start||!*start)
+		{
+			start="UNKNOWN";
+		}
+	}
+#ifdef _FASTRPT_
+	hmap<const char *,int,CMyStrComparator>::iterator f=Lookup.find(start);
+	if(f==Lookup.end())
+	{
+		strcpy(StackNames[nStack++],start);
+		Lookup[(const char *)&StackNames[nStack-1]]=nStack-1;
+		StackSize[nStack-1]=info->argSize;
+		StackCount[nStack-1]=1;
+	}
+	else
+	{
+		StackSize[(*f).second]+=info->argSize;
+		StackCount[(*f).second]++;
+	}
+#else
+	for (i=0;i<48;i++)
+	{
+		if (StackCache[i]<0||StackCache[i]>=nStack)
+			continue;
+		if (!strcmpi(start,StackNames[StackCache[i]]))
+			break;
+	}
+	if (i<48)
+	{
+		StackSize[StackCache[i]]+=info->argSize;
+		StackCount[StackCache[i]]++;
+	}
+	else
+	{
+		for (i=0;i<nStack;i++)
+		{
+			if (!strcmpi(start,StackNames[i]))
+				break;
+		}
+		if (i<nStack)
+		{
+			StackSize[i]+=info->argSize;
+			StackCount[i]++;
+			StackCache[StackCacheAt]=i;
+			StackCacheAt++;
+			if (StackCacheAt>=48)
+				StackCacheAt=0;
+		}
+		else if (i<maxStack)
+		{
+			strcpy(StackNames[i],start);
+			StackSize[i]=info->argSize;
+			StackCount[i]=1;
+			nStack++;
+		}
+		else if (nStack<maxStack)
+		{
+			nStack++;
+			strcpy(StackNames[maxStack-1],"*****OTHER*****");
+			StackSize[maxStack-1]=info->argSize;
+			StackCount[maxStack-1]=1;
+		}
+		else
+		{
+			StackSize[maxStack-1]+=info->argSize;
+			StackCount[maxStack-1]++;
+		}
+	}
+#endif
+	TotalMem+=info->argSize;
+	return 1;
+}
+
+void SH_Checking_f(void);
+#endif
+
+class Leakage
+{
+	MEM_POOL MyPool;
+
+public:
+	Leakage()
+	{
+		MyPool = MemInitDefaultPool();
+//		MemPoolSetSmallBlockSize(MyPool, 16); 
+		MemPoolSetSmallBlockAllocator(MyPool,MEM_SMALL_BLOCK_SH3);
+#if MEM_DEBUG
+		dbgMemSetGuardSize(2);
+		EnableChecking(100000);
+#endif
+	}
+
+	void LeakReport(void)
+	{
+#if MEM_DEBUG
+
+		// This just makes sure we have map nodes available without allocation
+		// during the heap walk (which could be bad).
+		int i;
+#ifdef _FASTRPT_
+		hlist<int> makeSureWeHaveNodes;
+		for(i=0;i<5000;i++)
+		{
+			makeSureWeHaveNodes.push_back(0);
+		}
+		makeSureWeHaveNodes.clear();
+		Lookup.clear();
+#endif
+		char mess[1000];
+		int blocks=dbgMemTotalCount();
+		int mem=dbgMemTotalSize()/1024;
+		sprintf(mess,"Final Memory Summary %d blocks %d K\n",blocks,mem);
+		OutputDebugString(mess);
+
+		for (i=0;i<3000;i++)
+		{
+			CheckpointSize[i]=0;
+			CheckpointCount[i]=0;
+		}
+
+		TotalMem=0;
+		TotalBlocks=0;
+		nStack=0;
+		MemSetErrorHandler(MyMemReporter2);
+		dbgMemReportLeakage(NULL,1,1000);
+		MemSetErrorHandler(MemDefaultErrorHandler);
+		multimap<int,pair<int,char *> > sortit;
+		multimap<int,pair<int,char *> >::iterator j;
+		if (TotalBlocks)
+		{
+			// Sort by size.
+			Sleep(100);
+			OutputDebugString("**************************************\n");
+			OutputDebugString("**********Memory Leak Report**********\n");
+			OutputDebugString("*************** By Size **************\n");
+			OutputDebugString("**************************************\n");
+			sprintf(mess,"Actual leakage %d blocks %d K\n",TotalBlocks,TotalMem/1024);
+			OutputDebugString(mess);
+			sortit.clear();
+			for (i=0;i<nStack;i++)
+				sortit.insert(pair<int,pair<int,char *> >(-StackSize[i],pair<int,char *>(StackCount[i],StackNames[i])));
+			Sleep(5);
+			for (j=sortit.begin();j!=sortit.end();j++)
+			{
+				sprintf(mess,"%5d KB %6d cnt  %s\n",-(*j).first/1024,(*j).second.first,(*j).second.second);
+	//			if (!(-(*j).first/1024))
+	//				break;
+				Sleep(5);
+				OutputDebugString(mess);
+			}
+
+			// Sort by count.
+			Sleep(100);
+			OutputDebugString("**************************************\n");
+			OutputDebugString("**********Memory Leak Report**********\n");
+			OutputDebugString("************** By Count **************\n");
+			OutputDebugString("**************************************\n");
+			sprintf(mess,"Actual leakage %d blocks %d K\n",TotalBlocks,TotalMem/1024);
+			OutputDebugString(mess);
+			sortit.clear();
+			for (i=0;i<nStack;i++)
+				sortit.insert(pair<int,pair<int,char *> >(-StackCount[i],pair<int,char *>(StackSize[i],StackNames[i])));
+			Sleep(5);
+			for (j=sortit.begin();j!=sortit.end();j++)
+			{
+				sprintf(mess,"%5d KB %6d cnt  %s\n",(*j).second.first/1024,-(*j).first,(*j).second.second);
+	//			if (!(-(*j).first/1024))
+	//				break;
+				Sleep(5);
+				OutputDebugString(mess);
+			}
+		}
+		else
+		{
+			OutputDebugString("No Memory Leaks\n");
+		}
+
+		TotalMem=0;
+		TotalBlocks=0;
+		nStack=0;
+		MemSetErrorHandler(MyMemReporter3);
+		dbgMemReportLeakage(NULL,2001,2001);
+		MemSetErrorHandler(MemDefaultErrorHandler);
+		if (TotalBlocks)
+		{
+			// Sort by count.
+			Sleep(100);
+			OutputDebugString("**************************************\n");
+			OutputDebugString("SV_PointContents     ");
+			sprintf(mess,"%d Calls.\n",TotalBlocks);
+			OutputDebugString(mess);
+			OutputDebugString("**************************************\n");
+			sortit.clear();
+			for (i=0;i<nStack;i++)
+				sortit.insert(pair<int,pair<int,char *> >(-StackCount[i],pair<int,char *>(StackSize[i],StackNames[i])));
+			Sleep(5);
+			for (j=sortit.begin();j!=sortit.end();j++)
+			{
+				sprintf(mess,"%7d cnt  %s\n",-(*j).first,(*j).second.second);
+				Sleep(5);
+				OutputDebugString(mess);
+			}
+		}
+		TotalMem=0;
+		TotalBlocks=0;
+		nStack=0;
+		MemSetErrorHandler(MyMemReporter3);
+		dbgMemReportLeakage(NULL,2002,2002);
+		MemSetErrorHandler(MemDefaultErrorHandler);
+		if (TotalBlocks)
+		{
+			// Sort by count.
+			Sleep(100);
+			OutputDebugString("**************************************\n");
+			OutputDebugString("SV_Trace     ");
+			sprintf(mess,"%d Calls.\n",TotalBlocks);
+			OutputDebugString(mess);
+			OutputDebugString("**************************************\n");
+			sortit.clear();
+			for (i=0;i<nStack;i++)
+				sortit.insert(pair<int,pair<int,char *> >(-StackCount[i],pair<int,char *>(StackSize[i],StackNames[i])));
+			Sleep(5);
+			for (j=sortit.begin();j!=sortit.end();j++)
+			{
+				sprintf(mess,"%7d cnt  %s\n",-(*j).first,(*j).second.second);
+				Sleep(5);
+				OutputDebugString(mess);
+			}
+		}
+		TotalMem=0;
+		TotalBlocks=0;
+		nStack=0;
+		MemSetErrorHandler(MyMemReporter3);
+		dbgMemReportLeakage(NULL,2003,2003);
+		MemSetErrorHandler(MemDefaultErrorHandler);
+		if (TotalBlocks)
+		{
+			// Sort by count.
+			Sleep(100);
+			OutputDebugString("**************************************\n");
+			OutputDebugString("SV_AreaEntities     ");
+			sprintf(mess,"%d Calls.\n",TotalBlocks);
+			OutputDebugString(mess);
+			OutputDebugString("**************************************\n");
+			sortit.clear();
+			for (i=0;i<nStack;i++)
+				sortit.insert(pair<int,pair<int,char *> >(-StackCount[i],pair<int,char *>(StackSize[i],StackNames[i])));
+			Sleep(5);
+			for (j=sortit.begin();j!=sortit.end();j++)
+			{
+				sprintf(mess,"%7d cnt  %s\n",-(*j).first,(*j).second.second);
+				Sleep(5);
+				OutputDebugString(mess);
+			}
+		}
+		TotalMem=0;
+		TotalBlocks=0;
+		nStack=0;
+		MemSetErrorHandler(MyMemReporter3);
+		dbgMemReportLeakage(NULL,2004,2004);
+		MemSetErrorHandler(MemDefaultErrorHandler);
+		if (TotalBlocks)
+		{
+			// Sort by count.
+			Sleep(100);
+			OutputDebugString("**************************************\n");
+			OutputDebugString("CG_Trace     ");
+			sprintf(mess,"%d Calls.\n",TotalBlocks);
+			OutputDebugString(mess);
+			OutputDebugString("**************************************\n");
+			sortit.clear();
+			for (i=0;i<nStack;i++)
+				sortit.insert(pair<int,pair<int,char *> >(-StackCount[i],pair<int,char *>(StackSize[i],StackNames[i])));
+			Sleep(5);
+			for (j=sortit.begin();j!=sortit.end();j++)
+			{
+				sprintf(mess,"%7d cnt  %s\n",-(*j).first,(*j).second.second);
+				Sleep(5);
+				OutputDebugString(mess);
+			}
+		}
+		TotalMem=0;
+		TotalBlocks=0;
+		nStack=0;
+		MemSetErrorHandler(MyMemReporter3);
+		dbgMemReportLeakage(NULL,2005,2005);
+		MemSetErrorHandler(MemDefaultErrorHandler);
+		if (TotalBlocks)
+		{
+			// Sort by count.
+			Sleep(100);
+			OutputDebugString("**************************************\n");
+			OutputDebugString("CG_PointContents     ");
+			sprintf(mess,"%d Calls.\n",TotalBlocks);
+			OutputDebugString(mess);
+			OutputDebugString("**************************************\n");
+			sortit.clear();
+			for (i=0;i<nStack;i++)
+				sortit.insert(pair<int,pair<int,char *> >(-StackCount[i],pair<int,char *>(StackSize[i],StackNames[i])));
+			Sleep(5);
+			for (j=sortit.begin();j!=sortit.end();j++)
+			{
+				sprintf(mess,"%7d cnt  %s\n",-(*j).first,(*j).second.second);
+				Sleep(5);
+				OutputDebugString(mess);
+			}
+		}
+#if 0 //sw doesn't have the tag stuff		
+		// Sort by size.
+		Sleep(5);
+		OutputDebugString("***************************************\n");
+		OutputDebugString("By Tag, sort: size ********************\n");
+		OutputDebugString("size(K)   count  name  \n");
+		OutputDebugString("-----------------------\n");
+		Sleep(5);
+		multimap<int,int> sorted;
+		for (i=0;i<1000;i++)
+		{
+			if (CheckpointCount[i])
+			{
+				sorted.insert(pair<int,int>(-CheckpointSize[i],i));
+			}
+		}
+		multimap<int,int>::iterator k;
+		for (k=sorted.begin();k!=sorted.end();k++)
+		{
+			sprintf(mess,"%8d %8d %s\n",CheckpointSize[(*k).second]/1024,CheckpointCount[(*k).second],(*k).second>=2?tagDefs[(*k).second-2]:"unknown");
+			Sleep(5);
+			OutputDebugString(mess);
+		}
+		
+		// Sort by count.
+		Sleep(5);
+		OutputDebugString("By Tag, sort: count *******************\n");
+		OutputDebugString("size(K)   count  name  \n");
+		OutputDebugString("-----------------------\n");
+		Sleep(5);
+		sorted.clear();
+		for (i=0;i<1000;i++)
+		{
+			if (CheckpointCount[i])
+			{
+				sorted.insert(pair<int,int>(-CheckpointCount[i],i));
+			}
+		}
+		for (k=sorted.begin();k!=sorted.end();k++)
+		{
+			sprintf(mess,"%8d %8d %s\n",CheckpointSize[(*k).second]/1024,CheckpointCount[(*k).second],(*k).second>=2?tagDefs[(*k).second-2]:"unknown");
+			Sleep(5);
+			OutputDebugString(mess);
+		}
+#endif
+#endif
+	}
+
+	~Leakage()
+	{
+#if MEM_DEBUG
+		if (mem_leakfile && mem_leakfile->integer)
+		{
+			dbgMemSetDefaultErrorOutput(DBGMEM_OUTPUT_FILE,"leakage.out");
+			dbgMemReportLeakage(NULL,1,1);
+			dbgMemSetDefaultErrorOutput(DBGMEM_OUTPUT_PROMPT,NULL);
+		}
+		if (mem_leakreport && mem_leakreport->integer)
+		{
+			LeakReport();
+		}
+#endif
+	}
+#if MEM_DEBUG
+
+	void EnableChecking(int x)
+	{
+		if (x)
+		{
+			dbgMemSetSafetyLevel(MEM_SAFETY_DEBUG);
+			dbgMemPoolSetCheckFrequency(MyPool, x);
+			dbgMemSetCheckFrequency(x);
+			dbgMemDeferFreeing(TRUE);
+			dbgMemSetDeferQueueLen(50000);
+		}
+		else
+		{
+			dbgMemSetSafetyLevel(MEM_SAFETY_SOME);
+			dbgMemDeferFreeing(FALSE);
+		}
+
+	}
+#endif
+
+};
+
+static Leakage TheLeakage;
+
+#if MEM_DEBUG
+
+void MEM_Checking_f(void)
+{
+	if (Cmd_Argc() != 2)
+	{
+		Com_Printf ("mem_checking <frequency>\n");
+		return;
+	}
+
+	if (atol(Cmd_Argv(1)) > 0 && atol(Cmd_Argv(1)) < 100)
+	{
+		Com_Printf ("mem_checking frequency is too low ( < 100 )\n");
+		return;
+	}
+
+	TheLeakage.EnableChecking(atol(Cmd_Argv(1)));
+}
+
+void MEM_Report_f(void)
+{
+	if (0)
+	{
+		dbgMemSetDefaultErrorOutput(DBGMEM_OUTPUT_FILE,"leakage.out");
+		dbgMemReportLeakage(NULL,1,1);
+		dbgMemSetDefaultErrorOutput(DBGMEM_OUTPUT_PROMPT,NULL);
+	}
+	TheLeakage.LeakReport();
+}
+
+/*
+void myexit(void)
+{
+	TheLeakage.LeakReport();
+}
+*/
+void SH_Register(void)
+{
+	Cmd_AddCommand ("mem_checking", MEM_Checking_f);
+	Cmd_AddCommand ("mem_report", MEM_Report_f);
+
+	mem_leakfile = Cvar_Get( "mem_leakfile", "0", 0 );
+	mem_leakreport = Cvar_Get( "mem_leakreport", "1", 0 );
+//	atexit(myexit);
+}
+
+#endif
diff --git a/code/0_compiled_first/vssver.scc b/code/0_compiled_first/vssver.scc
new file mode 100644
index 0000000..bbe8e58
Binary files /dev/null and b/code/0_compiled_first/vssver.scc differ
diff --git a/code/ALut.lib b/code/ALut.lib
new file mode 100644
index 0000000..67cde9f
Binary files /dev/null and b/code/ALut.lib differ
diff --git a/code/EaxMan.dll b/code/EaxMan.dll
new file mode 100644
index 0000000..651cbfe
Binary files /dev/null and b/code/EaxMan.dll differ
diff --git a/code/IFC22.dll b/code/IFC22.dll
new file mode 100644
index 0000000..44331c8
Binary files /dev/null and b/code/IFC22.dll differ
diff --git a/code/JediAcademy.sln b/code/JediAcademy.sln
new file mode 100644
index 0000000..7caf775
--- /dev/null
+++ b/code/JediAcademy.sln
@@ -0,0 +1,88 @@
+Microsoft Visual Studio Solution File, Format Version 7.00
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "game", "game\game.vcproj", "{52D48192-6C71-4D4A-BE26-D05C0E02939C}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "exe", "starwars.vcproj", "{1BE1D500-A2DB-4585-B3D8-50B8D60C5685}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "x_game", "x_game\x_game.vcproj", "{E7A12117-F3B0-4C68-9B44-66CEFCA3AEAA}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "x_exe", "x_exe\x_exe.vcproj", "{FD1DA207-0D4A-47A8-A6AD-B81AE1BA28DA}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "goblib", "goblib\goblib.vcproj", "{68A067E3-BB9E-435B-9AA3-DD45DB2AA4DB}"
+EndProject
+Global
+	GlobalSection(SourceCodeControl) = preSolution
+		SccNumberOfProjects = 2
+		SccProjectUniqueName0 = game\\game.vcproj
+		SccProjectName0 = \u0022$/jedi/code\u0022,\u0020ROBAAAAA
+		SccLocalPath0 = .
+		SccProvider0 = MSSCCI:Microsoft\u0020Visual\u0020SourceSafe
+		SccProjectFilePathRelativizedFromConnection0 = game\\
+		SccProjectUniqueName1 = starwars.vcproj
+		SccProjectName1 = \u0022$/jedi/code\u0022,\u0020ROBAAAAA
+		SccLocalPath1 = .
+		SccProvider1 = MSSCCI:Microsoft\u0020Visual\u0020SourceSafe
+	EndGlobalSection
+	GlobalSection(SolutionConfiguration) = preSolution
+		ConfigName.0 = Debug
+		ConfigName.1 = FinalBuild
+		ConfigName.2 = Release
+		ConfigName.3 = SHDebug
+	EndGlobalSection
+	GlobalSection(ProjectDependencies) = postSolution
+		{1BE1D500-A2DB-4585-B3D8-50B8D60C5685}.0 = {52D48192-6C71-4D4A-BE26-D05C0E02939C}
+		{FD1DA207-0D4A-47A8-A6AD-B81AE1BA28DA}.0 = {E7A12117-F3B0-4C68-9B44-66CEFCA3AEAA}
+		{FD1DA207-0D4A-47A8-A6AD-B81AE1BA28DA}.1 = {68A067E3-BB9E-435B-9AA3-DD45DB2AA4DB}
+	EndGlobalSection
+	GlobalSection(ProjectConfiguration) = postSolution
+		{52D48192-6C71-4D4A-BE26-D05C0E02939C}.Debug.ActiveCfg = Debug|Win32
+		{52D48192-6C71-4D4A-BE26-D05C0E02939C}.Debug.Build.0 = Debug|Win32
+		{52D48192-6C71-4D4A-BE26-D05C0E02939C}.FinalBuild.ActiveCfg = FinalBuild|Win32
+		{52D48192-6C71-4D4A-BE26-D05C0E02939C}.FinalBuild.Build.0 = FinalBuild|Win32
+		{52D48192-6C71-4D4A-BE26-D05C0E02939C}.Release.ActiveCfg = Release|Win32
+		{52D48192-6C71-4D4A-BE26-D05C0E02939C}.Release.Build.0 = Release|Win32
+		{52D48192-6C71-4D4A-BE26-D05C0E02939C}.SHDebug.ActiveCfg = SHDebug|Win32
+		{1BE1D500-A2DB-4585-B3D8-50B8D60C5685}.Debug.ActiveCfg = Debug|Win32
+		{1BE1D500-A2DB-4585-B3D8-50B8D60C5685}.Debug.Build.0 = Debug|Win32
+		{1BE1D500-A2DB-4585-B3D8-50B8D60C5685}.FinalBuild.ActiveCfg = FinalBuild|Win32
+		{1BE1D500-A2DB-4585-B3D8-50B8D60C5685}.FinalBuild.Build.0 = FinalBuild|Win32
+		{1BE1D500-A2DB-4585-B3D8-50B8D60C5685}.Release.ActiveCfg = Release|Win32
+		{1BE1D500-A2DB-4585-B3D8-50B8D60C5685}.Release.Build.0 = Release|Win32
+		{1BE1D500-A2DB-4585-B3D8-50B8D60C5685}.SHDebug.ActiveCfg = SHDebug|Win32
+		{E7A12117-F3B0-4C68-9B44-66CEFCA3AEAA}.Debug.ActiveCfg = Debug|Xbox
+		{E7A12117-F3B0-4C68-9B44-66CEFCA3AEAA}.Debug.Build.0 = Debug|Xbox
+		{E7A12117-F3B0-4C68-9B44-66CEFCA3AEAA}.FinalBuild.ActiveCfg = FinalBuild|Xbox
+		{E7A12117-F3B0-4C68-9B44-66CEFCA3AEAA}.FinalBuild.Build.0 = FinalBuild|Xbox
+		{E7A12117-F3B0-4C68-9B44-66CEFCA3AEAA}.Release.ActiveCfg = Release|Xbox
+		{E7A12117-F3B0-4C68-9B44-66CEFCA3AEAA}.Release.Build.0 = Release|Xbox
+		{E7A12117-F3B0-4C68-9B44-66CEFCA3AEAA}.SHDebug.ActiveCfg = Debug|Xbox
+		{E7A12117-F3B0-4C68-9B44-66CEFCA3AEAA}.SHDebug.Build.0 = Debug|Xbox
+		{FD1DA207-0D4A-47A8-A6AD-B81AE1BA28DA}.Debug.ActiveCfg = Debug|Xbox
+		{FD1DA207-0D4A-47A8-A6AD-B81AE1BA28DA}.Debug.Build.0 = Debug|Xbox
+		{FD1DA207-0D4A-47A8-A6AD-B81AE1BA28DA}.FinalBuild.ActiveCfg = FinalBuild|Xbox
+		{FD1DA207-0D4A-47A8-A6AD-B81AE1BA28DA}.FinalBuild.Build.0 = FinalBuild|Xbox
+		{FD1DA207-0D4A-47A8-A6AD-B81AE1BA28DA}.Release.ActiveCfg = Release|Xbox
+		{FD1DA207-0D4A-47A8-A6AD-B81AE1BA28DA}.Release.Build.0 = Release|Xbox
+		{FD1DA207-0D4A-47A8-A6AD-B81AE1BA28DA}.SHDebug.ActiveCfg = Debug|Xbox
+		{FD1DA207-0D4A-47A8-A6AD-B81AE1BA28DA}.SHDebug.Build.0 = Debug|Xbox
+		{68A067E3-BB9E-435B-9AA3-DD45DB2AA4DB}.Debug.ActiveCfg = Debug|Xbox
+		{68A067E3-BB9E-435B-9AA3-DD45DB2AA4DB}.Debug.Build.0 = Debug|Xbox
+		{68A067E3-BB9E-435B-9AA3-DD45DB2AA4DB}.FinalBuild.ActiveCfg = FinalBuild|Xbox
+		{68A067E3-BB9E-435B-9AA3-DD45DB2AA4DB}.FinalBuild.Build.0 = FinalBuild|Xbox
+		{68A067E3-BB9E-435B-9AA3-DD45DB2AA4DB}.Release.ActiveCfg = Release|Xbox
+		{68A067E3-BB9E-435B-9AA3-DD45DB2AA4DB}.Release.Build.0 = Release|Xbox
+		{68A067E3-BB9E-435B-9AA3-DD45DB2AA4DB}.SHDebug.ActiveCfg = Debug|Xbox
+		{68A067E3-BB9E-435B-9AA3-DD45DB2AA4DB}.SHDebug.Build.0 = Debug|Xbox
+	EndGlobalSection
+	GlobalSection(SolutionItems) = postSolution
+		Item:1 = tonet.bat
+		Item:2 = VU.bat
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+	EndGlobalSection
+	GlobalSection(ExtensibilityAddIns) = postSolution
+	EndGlobalSection
+	GlobalSection(DevPartner) = postSolution
+	EndGlobalSection
+	GlobalSection(DevPartner) = postSolution
+	EndGlobalSection
+EndGlobal
diff --git a/code/JediAcademy.vssscc b/code/JediAcademy.vssscc
new file mode 100644
index 0000000..794f014
--- /dev/null
+++ b/code/JediAcademy.vssscc
@@ -0,0 +1,10 @@
+""
+{
+"FILE_VERSION" = "9237"
+"ENLISTMENT_CHOICE" = "NEVER"
+"PROJECT_FILE_RELATIVE_PATH" = ""
+"NUMBER_OF_EXCLUDED_FILES" = "0"
+"ORIGINAL_PROJECT_FILE_PATH" = ""
+"NUMBER_OF_NESTED_PROJECTS" = "0"
+"SOURCE_CONTROL_SETTINGS_PROVIDER" = "PROJECT"
+}
diff --git a/code/OpenAL32.dll b/code/OpenAL32.dll
new file mode 100644
index 0000000..1b2c553
Binary files /dev/null and b/code/OpenAL32.dll differ
diff --git a/code/OpenAL32.lib b/code/OpenAL32.lib
new file mode 100644
index 0000000..86de420
Binary files /dev/null and b/code/OpenAL32.lib differ
diff --git a/code/RMG/RM_Area.cpp b/code/RMG/RM_Area.cpp
new file mode 100644
index 0000000..c4eca5e
--- /dev/null
+++ b/code/RMG/RM_Area.cpp
@@ -0,0 +1,480 @@
+/************************************************************************************************
+ *
+ *	Copyright (C) 2001-2002 Raven Software
+ *
+ *  RM_Area.cpp
+ *
+ ************************************************************************************************/
+
+#include "../server/exe_headers.h"
+
+#include "rm_headers.h"
+
+#ifdef _WIN32
+#pragma optimize("p", on)
+#endif
+
+/************************************************************************************************
+ * CRMArea::CRMArea
+ *	constructor
+ *
+ * inputs:
+ *  none
+ *
+ * return:
+ *	none
+ *
+ ************************************************************************************************/
+CRMArea::CRMArea ( 
+	float	spacingRadius,
+	float	paddingSize,
+	float	confineRadius,
+	vec3_t	confineOrigin,
+	vec3_t	lookAtOrigin,
+	bool	flatten,
+	int		symmetric
+	) 
+{
+	mMoveCount		= 0;
+	mAngle			= 0;
+	mCollision		= true;
+	mConfineRadius	= confineRadius;
+	mPaddingSize    = paddingSize;
+	mSpacingRadius  = spacingRadius;
+	mFlatten		= flatten;
+	mLookAt			= true;
+	mLockOrigin		= false;
+	mSymmetric		= symmetric;
+	mRadius			= spacingRadius;
+
+	VectorCopy ( confineOrigin, mConfineOrigin );
+	VectorCopy ( lookAtOrigin, mLookAtOrigin );
+}
+
+/************************************************************************************************
+ * CRMArea::LookAt
+ *	Angle the area towards the given point
+ *
+ * inputs:
+ *  lookat - the origin to look at
+ *
+ * return:
+ *	the angle in radians that was calculated
+ *
+ ************************************************************************************************/
+float CRMArea::LookAt ( vec3_t lookat )
+{
+	if (mLookAt)
+	{	// this area orients itself towards a point
+		vec3_t a;
+
+		VectorCopy ( lookat, mLookAtOrigin );
+		VectorSubtract ( lookat, mOrigin, a );
+
+		mAngle = atan2 ( a[1], a[0] );
+	}
+
+	return mAngle;
+}
+
+/************************************************************************************************
+ * CRMArea::Mirror
+ *	Mirrors the area to the other side of the map.  This includes mirroring the confine origin
+ *  and lookat origin
+ *
+ * inputs:
+ *  none
+ *
+ * return:
+ *	none
+ *
+ ************************************************************************************************/
+void CRMArea::Mirror ( void )
+{
+	mOrigin[0] = -mOrigin[0];
+	mOrigin[1] = -mOrigin[1];
+
+	mConfineOrigin[0] = -mConfineOrigin[0];
+	mConfineOrigin[1] = -mConfineOrigin[1];
+
+	mLookAtOrigin[0] = -mLookAtOrigin[0];
+	mLookAtOrigin[1] = -mLookAtOrigin[1];
+}
+
+/************************************************************************************************
+ * CRMAreaManager::CRMAreaManager
+ *	constructor
+ *
+ * inputs:
+ *  none
+ *
+ * return:
+ *	none
+ *
+ ************************************************************************************************/
+CRMAreaManager::CRMAreaManager ( const vec3_t mins, const vec3_t maxs)
+{
+	VectorCopy ( mins, mMins );
+	VectorCopy ( maxs, mMaxs );
+
+	mWidth  = mMaxs[0] - mMins[0];
+	mHeight = mMaxs[1] - mMins[1];
+}
+
+/************************************************************************************************
+ * CRMAreaManager::~CRMAreaManager
+ *	Removes all managed areas
+ *
+ * inputs:
+ *  none
+ *
+ * return:
+ *	none
+ *
+ ************************************************************************************************/
+CRMAreaManager::~CRMAreaManager ( )
+{
+	int i;
+
+	for ( i = mAreas.size() - 1; i >=0; i -- )
+	{
+		delete mAreas[i];
+	}
+
+	mAreas.clear();
+}
+
+/************************************************************************************************
+ * CRMAreaManager::MoveArea
+ *	Moves an area within the area manager thus shifting any other areas as needed
+ *
+ * inputs:
+ *  area   - area to be moved
+ *  origin - new origin to attempt to move to
+ *
+ * return:
+ *	none
+ *
+ ************************************************************************************************/
+void CRMAreaManager::MoveArea ( CRMArea* movedArea, vec3_t origin)
+{
+	int	index;
+	int size;
+
+	// Increment the addcount (this is for infinite protection)
+	movedArea->AddMoveCount ();
+	
+	// Infinite recursion prevention
+	if ( movedArea->GetMoveCount() > 250 )
+	{
+//		assert ( 0 );
+		movedArea->EnableCollision ( false );
+		return;
+	}
+
+	// First set the area's origin, This may cause it to be in collision with
+	// another area but that will get fixed later
+	movedArea->SetOrigin ( origin );
+
+	// when symmetric we want to ensure that no instances end up on the "other" side of the imaginary diaganol that cuts the map in two
+	// mSymmetric tells us which side of the map is legal
+	if ( movedArea->GetSymmetric ( ) )
+	{
+		const vec3pair_t& bounds = TheRandomMissionManager->GetLandScape()->GetBounds();
+		
+		vec3_t point;
+		vec3_t dir;
+		vec3_t tang;
+		bool   push;
+		float  len;
+
+		VectorSubtract( movedArea->GetOrigin(), bounds[0], point );
+		VectorSubtract( bounds[1], bounds[0], dir );
+		VectorNormalize(dir);	
+
+		dir[2] = 0;
+		point[2] = 0;
+		VectorMA( bounds[0], DotProduct(point, dir), dir, tang );
+		VectorSubtract ( movedArea->GetOrigin(), tang, dir );
+
+		dir[2] = 0;
+		push   = false;
+		len    = VectorNormalize(dir);
+
+		if ( len < movedArea->GetRadius ( ) )
+		{
+			if ( movedArea->GetLockOrigin ( ) )
+			{
+				movedArea->EnableCollision ( false );
+				return;
+			}
+
+			VectorMA ( point, (movedArea->GetSpacingRadius() - len) + TheRandomMissionManager->GetLandScape()->irand(10,movedArea->GetSpacingRadius()), dir, point );
+			origin[0] = point[0] + bounds[0][0];
+			origin[1] = point[1] + bounds[0][1];
+			movedArea->SetOrigin ( origin );
+		}
+
+		switch ( movedArea->GetSymmetric ( ) )
+		{
+			case SYMMETRY_TOPLEFT:
+				if ( origin[1] > origin[0] )
+				{
+					movedArea->Mirror ( );
+				}
+				break;
+
+			case SYMMETRY_BOTTOMRIGHT:
+				if ( origin[1] < origin[0] )
+				{ 
+					movedArea->Mirror ( );
+				}
+
+				break;
+
+			default:
+				// unknown symmetry type
+				assert ( 0 );
+				break;
+		}
+	}
+
+	// Confine to area unless we are being pushed back by the same guy who pushed us last time (infinite loop)
+	if ( movedArea->GetConfineRadius() )
+	{
+		if ( movedArea->GetMoveCount() < 25 )
+		{
+			vec3_t cdiff;
+			float  cdist;
+
+			VectorSubtract ( movedArea->GetOrigin(), movedArea->GetConfineOrigin(), cdiff );
+			cdiff[2] = 0;
+			cdist = VectorLength ( cdiff );
+
+			if ( cdist + movedArea->GetSpacingRadius() > movedArea->GetConfineRadius() )
+			{
+				cdist = movedArea->GetConfineRadius() - movedArea->GetSpacingRadius();
+				VectorNormalize ( cdiff );
+		
+				VectorMA ( movedArea->GetConfineOrigin(), cdist, cdiff, movedArea->GetOrigin());
+			}	
+		}
+		else
+		{
+			index = 0;
+		}
+	}
+
+	// See if it fell off the world in the x direction
+	if ( movedArea->GetOrigin()[0] + movedArea->GetSpacingRadius() > mMaxs[0] )
+		movedArea->GetOrigin()[0] = mMaxs[0] - movedArea->GetSpacingRadius() - (TheRandomMissionManager->GetLandScape()->irand(10,200));
+	else if ( movedArea->GetOrigin()[0] - movedArea->GetSpacingRadius() < mMins[0] )
+		movedArea->GetOrigin()[0] = mMins[0] + movedArea->GetSpacingRadius() + (TheRandomMissionManager->GetLandScape()->irand(10,200));
+
+	// See if it fell off the world in the y direction
+	if ( movedArea->GetOrigin()[1] + movedArea->GetSpacingRadius() > mMaxs[1] )
+		movedArea->GetOrigin()[1] = mMaxs[1] - movedArea->GetSpacingRadius() - (TheRandomMissionManager->GetLandScape()->irand(10,200));
+	else if ( movedArea->GetOrigin()[1] - movedArea->GetSpacingRadius() < mMins[1] )
+		movedArea->GetOrigin()[1] = mMins[1] + movedArea->GetSpacingRadius() + (TheRandomMissionManager->GetLandScape()->irand(10,200));
+
+	// Look at what we need to look at
+	movedArea->LookAt ( movedArea->GetLookAtOrigin() );
+	
+	// Dont collide against things that have no collision
+//	if ( !movedArea->IsCollisionEnabled ( ) )
+//	{
+//		return;
+//	}
+
+	// See if its colliding
+	for(index = 0, size = mAreas.size(); index < size; index ++ )
+	{
+		CRMArea	*area = mAreas[index];
+		vec3_t	diff;
+		vec3_t	newOrigin;
+		float	dist;
+		float	targetdist;
+
+		// Skip the one that was moved in the first place
+		if ( area == movedArea )
+		{
+			continue;
+		}
+
+		if ( area->GetLockOrigin ( ) && movedArea->GetLockOrigin( ) )
+		{
+			continue;
+		}
+
+		// Dont collide against things that have no collision
+		if ( !area->IsCollisionEnabled ( ) )
+		{
+			continue;
+		}
+
+		// Grab the distance between the two
+		// only want the horizontal distance -- dmv
+		//dist		= Distance ( movedArea->GetOrigin ( ), area->GetOrigin ( ));
+		vec3_t	maOrigin;
+		vec3_t	aOrigin;
+		VectorCopy(movedArea->GetOrigin(), maOrigin);
+		VectorCopy(area->GetOrigin(), aOrigin);
+		maOrigin[2] = aOrigin[2] = 0;
+		dist		= Distance ( maOrigin, aOrigin );
+		targetdist  = movedArea->GetSpacingRadius() + area->GetSpacingRadius() + maximum(movedArea->GetPaddingSize(),area->GetPaddingSize());
+
+		if ( dist == 0 )
+		{
+			area->GetOrigin()[0] += (50 * (float)(TheRandomMissionManager->GetLandScape()->irand(0,99))/100.0f);
+			area->GetOrigin()[1] += (50 * (float)(TheRandomMissionManager->GetLandScape()->irand(0,99))/100.0f);
+
+			VectorCopy(area->GetOrigin(), aOrigin);
+			aOrigin[2] = 0;
+
+			dist = Distance ( maOrigin, aOrigin );
+		}
+
+		// Are they are enough apart?
+		if ( dist >= targetdist )
+		{
+			continue;	
+		}
+
+		// Dont move a step if locked
+		if ( area->GetLockOrigin ( ) )
+		{
+			MoveArea ( area, area->GetOrigin ( ) );			
+			continue;
+		}
+
+		// we got a collision, move the guy we hit
+		VectorSubtract ( area->GetOrigin(), movedArea->GetOrigin(), diff );
+		diff[2] = 0;
+		VectorNormalize ( diff );
+
+		// Push by the difference in the distance and no-collide radius
+		VectorMA ( area->GetOrigin(), targetdist - dist + 1 , diff, newOrigin );
+
+		// Move the area now
+		MoveArea ( area, newOrigin );
+	}
+}
+
+/************************************************************************************************
+ * CRMAreaManager::CreateArea
+ *	Creates an area and adds it to the list of managed areas
+ *
+ * inputs:
+ *  none
+ *
+ * return:
+ *	a pointer to the newly added area class
+ *
+ ************************************************************************************************/
+CRMArea* CRMAreaManager::CreateArea ( 
+	vec3_t	origin, 
+	float	spacingRadius,
+	int		spacingLine,
+	float	paddingSize,
+	float	confineRadius,
+	vec3_t	confineOrigin,
+	vec3_t	lookAtOrigin,
+	bool	flatten,
+	bool	collide,
+	bool	lockorigin,
+	int		symmetric
+	)
+{
+	CRMArea* area = new CRMArea ( spacingRadius, paddingSize, confineRadius, confineOrigin, lookAtOrigin, flatten, symmetric );
+
+	if ( lockorigin || spacingLine )
+	{
+		area->LockOrigin ( );
+	}
+
+	if (origin[0] != lookAtOrigin[0] || origin[1] != lookAtOrigin[1])
+		area->EnableLookAt(true);
+
+	// First add the area to the list
+	mAreas.push_back ( area );
+
+	area->EnableCollision(collide);
+
+	// Set the real radius which is used for center line detection
+	if ( spacingLine )
+	{
+		area->SetRadius ( spacingRadius + (spacingLine - 1) * spacingRadius );
+	}
+
+	// Now move the area around
+	MoveArea ( area, origin );
+
+	if ( (origin[0] != lookAtOrigin[0] || origin[1] != lookAtOrigin[1]) )
+	{
+		int i;
+		vec3_t	 linedir;
+		vec3_t	 dir;
+		vec3_t   up = {0,0,1};
+		vec3_t	 zerodvec;
+
+		VectorClear(zerodvec);
+
+		VectorSubtract ( lookAtOrigin, origin, dir );
+		VectorNormalize ( dir );
+		dir[2] = 0;
+		CrossProduct ( dir, up, linedir );
+
+		for ( i = 0; i < spacingLine - 1; i ++ )
+		{
+			CRMArea* linearea;
+			vec3_t	 lineorigin;
+
+			linearea = new CRMArea ( spacingRadius, paddingSize, 0, zerodvec, zerodvec, false, symmetric );
+			linearea->LockOrigin ( );
+			linearea->EnableCollision(collide);
+
+			VectorMA ( origin, spacingRadius + (spacingRadius * 2 * i), linedir, lineorigin );
+			mAreas.push_back ( linearea );				
+			MoveArea ( linearea, lineorigin );
+
+			linearea = new CRMArea ( spacingRadius, paddingSize, 0, zerodvec, zerodvec, false, symmetric );
+			linearea->LockOrigin ( );
+			linearea->EnableCollision(collide);
+
+			VectorMA ( origin, -spacingRadius - (spacingRadius * 2 * i), linedir, lineorigin );
+			mAreas.push_back ( linearea );				
+			MoveArea ( linearea, lineorigin );
+		}
+	}
+
+	// Return it for convienience
+	return area;
+}
+
+/************************************************************************************************
+ * CRMAreaManager::EnumArea
+ *	Allows for enumeration through the area list. If an invalid index is given then NULL will
+ *  be returned;
+ *
+ * inputs:
+ *  index - current enumeration index
+ *
+ * return:
+ *	requested area class pointer or NULL if the index was invalid
+ *
+ ************************************************************************************************/
+CRMArea* CRMAreaManager::EnumArea ( const int index )
+{
+	// This isnt an assertion case because there is no size method for
+	// the area manager so the areas are enumerated until NULL is returned.
+	if ( index < 0 || index >= mAreas.size ( ) )
+	{
+		return NULL;
+	}
+
+	return mAreas[index];
+}
+
+#ifdef _WIN32
+#pragma optimize("p", off)
+#endif
diff --git a/code/RMG/RM_Area.h b/code/RMG/RM_Area.h
new file mode 100644
index 0000000..b731f47
--- /dev/null
+++ b/code/RMG/RM_Area.h
@@ -0,0 +1,99 @@
+/************************************************************************************************
+ *
+ *	Copyright (C) 2001-2002 Raven Software
+ *
+ *  RM_Area.h
+ *
+ ************************************************************************************************/
+
+#pragma once
+#if !defined(RM_AREA_H_INC)
+#define RM_AREA_H_INC
+
+#ifdef DEBUG_LINKING
+	#pragma message("...including RM_Area.h")
+#endif
+
+class CRMArea
+{
+private:
+
+	float		mPaddingSize;
+	float		mSpacingRadius;
+	float		mConfineRadius;
+	float		mRadius;
+	float		mAngle;
+	int			mMoveCount;
+	vec3_t		mOrigin;
+	vec3_t		mConfineOrigin;
+	vec3_t		mLookAtOrigin;
+	bool		mCollision;
+	bool		mFlatten;
+	bool		mLookAt;
+	bool		mLockOrigin;
+	int			mSymmetric;
+
+public:
+
+	CRMArea ( float spacing, float padding, float confine, vec3_t confineOrigin, vec3_t lookAtOrigin, bool flatten = true, int symmetric = 0 );
+
+	void	Mirror ( void );
+
+	void	SetOrigin(vec3_t origin) { VectorCopy ( origin, mOrigin ); }
+	void	SetAngle(float angle)	 { mAngle = angle; }
+	void	SetSymmetric(int sym)    { mSymmetric = sym; }
+
+	void	EnableCollision(bool e)	 { mCollision = e; }
+	void	EnableLookAt(bool la) {mLookAt = la; }
+
+	float	LookAt(vec3_t lookat);
+	void	LockOrigin( void )	{ mLockOrigin = true; }
+
+	void	AddMoveCount()		{ mMoveCount++; }
+	void	ClearMoveCount()	{ mMoveCount=0; }
+
+	float	GetPaddingSize()	{ return mPaddingSize; }
+	float	GetSpacingRadius()	{ return mSpacingRadius; }
+	float	GetRadius()			{ return mRadius; }
+	float	GetConfineRadius()	{ return mConfineRadius; }
+	float	GetAngle()			{ return mAngle; }
+	int		GetMoveCount()		{ return mMoveCount; }
+	vec_t*	GetOrigin()			{ return mOrigin; }
+	vec_t*	GetConfineOrigin()	{ return mConfineOrigin; }
+	vec_t*	GetLookAtOrigin()	{ return mLookAtOrigin; }
+	bool	GetLookAt()			{ return mLookAt;}
+	bool	GetLockOrigin()		{ return mLockOrigin; }
+	int		GetSymmetric()		{ return mSymmetric; }
+
+	void	SetRadius(float r)	{ mRadius = r; }
+
+	bool	IsCollisionEnabled(){ return mCollision; }
+	bool	IsFlattened		  (){ return mFlatten; }
+};
+
+typedef vector<CRMArea*>			rmAreaVector_t;
+
+class CRMAreaManager
+{
+private:
+
+	rmAreaVector_t	mAreas;
+	vec3_t			mMins;
+	vec3_t			mMaxs;
+	float			mWidth;
+	float			mHeight;
+
+public:
+	
+	CRMAreaManager ( const vec3_t mins, const vec3_t maxs );
+	~CRMAreaManager ( );
+
+	CRMArea*	CreateArea		( vec3_t origin, float spacing, int spacingline, float padding, float confine, vec3_t confineOrigin, vec3_t lookAtOrigin, bool flatten=true, bool collide=true, bool lockorigin=false, int symmetric=0);
+	void		MoveArea		( CRMArea* area, vec3_t origin);
+	CRMArea*	EnumArea		( const int index );
+
+//	void		CreateMap		( void );
+};
+
+#endif
+
diff --git a/code/RMG/RM_Headers.h b/code/RMG/RM_Headers.h
new file mode 100644
index 0000000..3eb821b
--- /dev/null
+++ b/code/RMG/RM_Headers.h
@@ -0,0 +1,71 @@
+#pragma once
+#if !defined(RM_HEADERS_H_INC)
+#define RM_HEADERS_H_INC
+
+#ifdef DEBUG_LINKING
+	#pragma message("...including RM_Headers.h")
+#endif
+
+#pragma warning (push, 3)
+#include <vector>
+#include <list>
+#pragma warning (pop)
+
+using namespace std;
+
+#if !defined(GENERICPARSER2_H_INC)
+#include "../game/genericparser2.h"
+#endif
+
+#if !defined(CM_LOCAL_H_INC)
+#include "../qcommon/cm_local.h"
+#endif
+
+#define MAX_INSTANCE_TRIES			5
+
+// on a symmetric map which corner is the first node
+typedef enum
+{
+	SYMMETRY_NONE,
+	SYMMETRY_TOPLEFT,
+	SYMMETRY_BOTTOMRIGHT
+
+} symmetry_t;
+
+#if !defined(CM_TERRAINMAP_H_INC)
+	#include "../qcommon/cm_terrainmap.h"
+#endif
+
+#if !defined(RM_AREA_H_INC)
+	#include "RM_Area.h"
+#endif
+
+#if !defined(RM_PATH_H_INC)
+	#include "RM_Path.h"
+#endif
+
+#if !defined(RM_OBJECTIVE_H_INC)
+	#include "RM_Objective.h"
+#endif
+
+#if !defined(RM_INSTANCEFILE_H_INC)
+	#include "RM_InstanceFile.h"
+#endif
+
+#if !defined(RM_INSTANCE_H_INC)
+	#include "RM_Instance.h"
+#endif
+
+#if !defined(RM_MISSION_H_INC)
+	#include "RM_Mission.h"
+#endif
+
+#if !defined(RM_MANAGER_H_INC)
+	#include "RM_Manager.h"
+#endif
+
+#if !defined(RM_TERRAIN_H_INC)
+	#include "RM_Terrain.h"
+#endif
+
+#endif
diff --git a/code/RMG/RM_Instance.cpp b/code/RMG/RM_Instance.cpp
new file mode 100644
index 0000000..91495e7
--- /dev/null
+++ b/code/RMG/RM_Instance.cpp
@@ -0,0 +1,191 @@
+#include "../server/exe_headers.h"
+
+#include "rm_headers.h"
+#include "../qcommon/cm_terrainmap.h"
+
+/************************************************************************************************
+ * CRMInstance::CRMInstance
+ *	constructs a instnace object using the given parser group
+ *
+ * inputs:
+ *  instance:  parser group containing information about the instance
+ *
+ * return:
+ *	none
+ *
+ ************************************************************************************************/
+CRMInstance::CRMInstance ( CGPGroup *instGroup, CRMInstanceFile& instFile )
+{
+	mObjective		= NULL;
+	mSpacingRadius	= 0;
+	mFlattenRadius	= 0;
+	mFilter[0]		= mTeamFilter[0] = 0;
+	mArea			= NULL;
+	mAutomapSymbol  = 0;
+	mEntityID       = 0;
+	mSide			= 0;
+	mMirror			= 0;
+	mFlattenHeight	= 66;
+	mSpacingLine	= 0;
+	mSurfaceSprites = true;
+	mLockOrigin		= false;
+}
+
+/************************************************************************************************
+ * CRMInstance::PreSpawn
+ *	Prepares the instance for spawning by flattening the ground under it
+ *
+ * inputs:
+ *  landscape: landscape the instance will be spawned on
+ *
+ * return:
+ *	true: spawn preparation successful
+ *  false: spawn preparation failed
+ *
+ ************************************************************************************************/
+bool CRMInstance::PreSpawn ( CRandomTerrain* terrain, qboolean IsServer )
+{
+	vec3_t		origin;
+	CArea		area;
+
+	VectorCopy(GetOrigin(), origin);
+
+	if (mMirror)
+	{
+		origin[0] = TheRandomMissionManager->GetLandScape()->GetBounds()[0][0] + TheRandomMissionManager->GetLandScape()->GetBounds()[1][0] - origin[0];
+		origin[1] = TheRandomMissionManager->GetLandScape()->GetBounds()[0][1] + TheRandomMissionManager->GetLandScape()->GetBounds()[1][1] - origin[1];
+	}
+
+	const vec3_t&	  terxelSize = terrain->GetLandScape()->GetTerxelSize ( );
+	const vec3pair_t& bounds     = terrain->GetLandScape()->GetBounds();
+
+	// Align the instance to the center of a terxel
+	origin[0] = bounds[0][0] + (int)((origin[0] - bounds[0][0] + terxelSize[0] / 2) / terxelSize[0]) * terxelSize[0];
+	origin[1] = bounds[0][1] + (int)((origin[1] - bounds[0][1] + terxelSize[1] / 2) / terxelSize[1]) * terxelSize[1];
+
+
+	// This is BAD - By copying the mirrored origin back into the instance, you've now mirrored the original instance
+	// so when anything from this point on looks at the instance they'll be looking at a mirrored version but will be expecting the original
+	// so later in the spawn functions the instance will be re-mirrored, because it thinks the mInstances have not been changed
+//	VectorCopy(origin, GetOrigin());
+
+	// Flatten the area below the instance 
+	if ( GetFlattenRadius() )
+	{	
+		area.Init( origin, GetFlattenRadius(), 0.0f, AT_NONE, 0, 0 );
+		terrain->GetLandScape()->FlattenArea( &area, mFlattenHeight | (mSurfaceSprites?0:0x80), false, true, true );
+	}
+
+	return true;
+}
+
+/************************************************************************************************
+ * CRMInstance::PostSpawn
+ *	Finishes the spawn by linking any objectives into the world that are associated with it
+ *
+ * inputs:
+ *  landscape: landscape the instance was spawned on
+ *
+ * return:
+ *	true: post spawn successfull
+ *  false: post spawn failed
+ *
+ ************************************************************************************************/
+bool CRMInstance::PostSpawn ( CRandomTerrain* terrain, qboolean IsServer )
+{
+	if ( mObjective )
+	{
+		return mObjective->Link ( );
+	}
+
+	return true;
+}
+#ifndef DEDICATED
+void CRMInstance::DrawAutomapSymbol()
+{
+	// draw proper symbol on map for instance
+	switch (GetAutomapSymbol())
+	{
+		default:
+		case AUTOMAP_NONE:
+			if (HasObjective())
+				CM_TM_AddObjective(GetOrigin()[0], GetOrigin()[1], GetSide());
+			break;
+		case AUTOMAP_BLD:
+			CM_TM_AddBuilding(GetOrigin()[0], GetOrigin()[1], GetSide());
+			if (HasObjective())
+				CM_TM_AddObjective(GetOrigin()[0], GetOrigin()[1], GetSide());
+			break;
+		case AUTOMAP_OBJ:
+			CM_TM_AddObjective(GetOrigin()[0], GetOrigin()[1], GetSide());
+			break;
+		case AUTOMAP_START:
+			CM_TM_AddStart(GetOrigin()[0], GetOrigin()[1], GetSide());
+			break;
+		case AUTOMAP_END:
+			CM_TM_AddEnd(GetOrigin()[0], GetOrigin()[1], GetSide());
+			break;
+		case AUTOMAP_ENEMY:
+			if (HasObjective())
+				CM_TM_AddObjective(GetOrigin()[0], GetOrigin()[1]);
+			if (1 == Cvar_VariableIntegerValue("rmg_automapshowall"))
+				CM_TM_AddNPC(GetOrigin()[0], GetOrigin()[1], false);
+			break;
+		case AUTOMAP_FRIEND:
+			if (HasObjective())
+				CM_TM_AddObjective(GetOrigin()[0], GetOrigin()[1]);
+			if (1 == Cvar_VariableIntegerValue("rmg_automapshowall"))
+				CM_TM_AddNPC(GetOrigin()[0], GetOrigin()[1], true);
+			break;
+		case AUTOMAP_WALL:
+			CM_TM_AddWallRect(GetOrigin()[0], GetOrigin()[1], GetSide());
+			break;
+	}
+}
+#endif // !DEDICATED
+/************************************************************************************************
+ * CRMInstance::Preview
+ *	Renderings debug information about the instance
+ *
+ * inputs:																   
+ *  none
+ *
+ * return:
+ *	none
+ *
+ ************************************************************************************************/
+void CRMInstance::Preview ( const vec3_t from )
+{
+/*	CEntity				*tent;
+
+	// Add a cylindar for the whole settlement
+	tent = G_TempEntity( GetOrigin(), EV_DEBUG_CYLINDER );
+	VectorCopy( GetOrigin(), tent->s.origin2 );
+	tent->s.pos.trBase[2] += 40;
+	tent->s.origin2[2] += 50;
+	tent->s.time = 1050 + ((int)(GetSpacingRadius())<<16);
+	tent->s.time2 = GetPreviewColor ( );
+	G_AddTempEntity(tent);
+
+	// Origin line
+	tent = G_TempEntity( GetOrigin ( ), EV_DEBUG_LINE );
+	VectorCopy( GetOrigin(), tent->s.origin2 );
+	tent->s.origin2[2] += 400;
+	tent->s.time = 1050;
+	tent->s.weapon = 10;
+	tent->s.time2 = (255<<24) + (255<<16) + (255<<8) + 255;
+	G_AddTempEntity(tent);
+
+	if ( GetFlattenRadius ( ) )
+	{
+		// Add a cylindar for the whole settlement
+		tent = G_TempEntity( GetOrigin(), EV_DEBUG_CYLINDER );
+		VectorCopy( GetOrigin(), tent->s.origin2 );
+		tent->s.pos.trBase[2] += 40;
+		tent->s.origin2[2] += 50;
+		tent->s.time = 1050 + ((int)(GetFlattenRadius ( ))<<16);
+		tent->s.time2 = (255<<24) + (80<<16) +(80<<8) + 80;
+		G_AddTempEntity(tent);
+	}
+*/
+}
diff --git a/code/RMG/RM_Instance.h b/code/RMG/RM_Instance.h
new file mode 100644
index 0000000..5251389
--- /dev/null
+++ b/code/RMG/RM_Instance.h
@@ -0,0 +1,122 @@
+#pragma once
+#if !defined(RM_INSTANCE_H_INC)
+#define RM_INSTANCE_H_INC
+
+#ifdef DEBUG_LINKING
+	#pragma message("...including RM_Instance.h")
+#endif
+
+#if !defined(CM_LANDSCAPE_H_INC)
+#include "../qcommon/cm_landscape.h"
+#endif
+
+enum	CRMAutomapSymbol
+{
+	AUTOMAP_NONE = 0,
+	AUTOMAP_BLD  = 1,
+	AUTOMAP_OBJ  = 2,
+	AUTOMAP_START= 3,
+	AUTOMAP_END  = 4,
+	AUTOMAP_ENEMY= 5,
+	AUTOMAP_FRIEND=6,
+	AUTOMAP_WALL=7
+};
+
+class CRMInstance
+{
+protected:
+	char			mFilter[MAX_QPATH];			// filter of entities inside of this
+	char			mTeamFilter[MAX_QPATH];		// team specific filter
+
+	vec3pair_t		mBounds;		// Bounding box for instance itself
+
+	CRMArea*		mArea;			// Position of the instance
+
+	CRMObjective*	mObjective;		// Objective associated with this instance
+
+	// optional instance specific strings for objective
+	string			mMessage;		// message outputed when objective is completed
+	string			mDescription;	// description of objective
+	string			mInfo;			// more info for objective
+
+	float			mSpacingRadius;	// Radius to space instances with
+	float			mFlattenRadius;	// Radius to flatten under instances
+
+	int				mSpacingLine;	// Line of spacing radius's, forces locket
+	bool			mLockOrigin;	// Origin cant move
+
+	bool			mSurfaceSprites; // allow surface sprites under instance?
+
+	int				mAutomapSymbol; // show which symbol on automap 0=none
+
+	int				mEntityID;		// id of entity spawned
+	int				mSide;			// blue or red side
+	int				mMirror;		// mirror origin, angle
+
+	int				mFlattenHeight;	// height to flatten land
+
+public:
+	
+	CRMInstance ( CGPGroup* instance, CRMInstanceFile& instFile);
+
+	virtual ~CRMInstance ( ) { }
+
+	virtual bool		IsValid				( )	{ return true; }
+
+	virtual bool		PreSpawn			( CRandomTerrain* terrain, qboolean IsServer );
+	virtual bool		Spawn				( CRandomTerrain* terrain, qboolean IsServer ) { return false; }
+	virtual bool		PostSpawn			( CRandomTerrain* terrain, qboolean IsServer );
+
+	virtual void		Preview				( const vec3_t from );
+
+	virtual void		SetArea				( CRMAreaManager* amanager, CRMArea* area ) { mArea = area; }
+	virtual void		SetFilter			( const char *filter ) { strcpy(mFilter, filter); }
+	virtual void		SetTeamFilter		( const char *teamFilter ) { strcpy(mTeamFilter, teamFilter); }
+	void				SetObjective		( CRMObjective* obj ) { mObjective = obj; }
+	CRMObjective*		GetObjective		(void) {return mObjective;}
+	bool				HasObjective		() {return mObjective != NULL;}
+	int					GetAutomapSymbol	() {return mAutomapSymbol;}
+	void				DrawAutomapSymbol	();
+	const char*			GetMessage(void)	{ return mMessage.c_str(); }
+	const char*			GetDescription(void){ return mDescription.c_str(); }
+	const char*			GetInfo(void)		{ return mInfo.c_str(); }
+	void				SetMessage(const char* msg) { mMessage = msg; }
+	void				SetDescription(const char* desc) { mDescription = desc; }
+	void				SetInfo(const char* info) { mInfo = info; }
+	void				SetSide(int side)	{mSide = side;}
+	int					GetSide				( ) {return mSide;}
+
+	// NOTE: should consider making SetMirror also set all other variables that need flipping
+	// like the origin and Side, etc... Otherwise an Instance may have had it's origin flipped
+	// but then later will have mMirror set to false, but the origin is still flipped. So any functions
+	// that look at the instance later will see mMirror set to false, but not realize the origin has ALREADY been flipped
+	virtual void  		SetMirror(int mirror)	{ mMirror = mirror;}
+	int					GetMirror			( ) { return mMirror;}
+
+	virtual bool		GetSurfaceSprites	( )		{ return mSurfaceSprites; }
+
+	virtual bool		GetLockOrigin		( )		{ return mLockOrigin; }
+	virtual int			GetSpacingLine		( )		{ return mSpacingLine; }
+
+	virtual int			GetPreviewColor		( )		{ return 0; }
+	virtual float		GetSpacingRadius	( )		{ return mSpacingRadius; }
+	virtual float		GetFlattenRadius	( )		{ return mFlattenRadius; }
+	const char			*GetFilter			( )		{ return mFilter; }
+	const char			*GetTeamFilter		( )		{ return mTeamFilter; }
+	
+	CRMArea&			GetArea				( )		{ return *mArea; }
+	vec_t*				GetOrigin			( ) 	{return mArea->GetOrigin(); }
+	float				GetAngle			( )		{return mArea->GetAngle();}
+	void				SetAngle(float ang )		{ mArea->SetAngle(ang);}
+	const vec3pair_t&	GetBounds(void) const		{ return(mBounds); }
+
+	void				SetFlattenHeight	( int height ) { mFlattenHeight = height; }
+	int					GetFlattenHeight	( void )	   { return mFlattenHeight; }
+
+	void				SetSpacingRadius	(float spacing) { mSpacingRadius = spacing; }
+};
+
+typedef list<CRMInstance*>::iterator	rmInstanceIter_t;
+typedef list<CRMInstance*>				rmInstanceList_t;
+
+#endif
diff --git a/code/RMG/RM_InstanceFile.cpp b/code/RMG/RM_InstanceFile.cpp
new file mode 100644
index 0000000..28c263e
--- /dev/null
+++ b/code/RMG/RM_InstanceFile.cpp
@@ -0,0 +1,200 @@
+/************************************************************************************************
+ *
+ * RM_InstanceFile.cpp
+ *
+ * implements the CRMInstanceFile class.  This class provides functionality to load
+ * and create instances from an instance file.  First call Open to open the instance file and
+ * then use CreateInstance to create new instances.  When finished call Close to cleanup.
+ *
+ ************************************************************************************************/
+
+#include "../server/exe_headers.h"
+
+#include "rm_headers.h"
+
+//#include "rm_instance_npc.h"
+#include "rm_instance_bsp.h"
+#include "rm_instance_random.h"
+#include "rm_instance_group.h"
+#include "rm_instance_void.h"
+
+/************************************************************************************************
+ * CRMInstanceFile::CRMInstanceFile
+ *	constructor
+ *
+ * inputs:
+ *  none
+ *
+ * return:
+ *	none
+ *
+ ************************************************************************************************/
+CRMInstanceFile::CRMInstanceFile ( )
+{
+	mInstances = NULL;
+}
+
+/************************************************************************************************
+ * CRMInstanceFile::~CRMInstanceFile
+ *	Destroys the instance file by freeing the parser
+ *
+ * inputs:
+ *  none
+ *
+ * return:
+ *	none
+ *
+ ************************************************************************************************/
+CRMInstanceFile::~CRMInstanceFile ( )
+{
+	Close ( );
+}
+
+/************************************************************************************************
+ * CRMInstanceFile::Open
+ *	Opens the given instance file and prepares it for use in instance creation
+ *
+ * inputs:
+ *  instance: Name of instance to open.  Note that the root path will be automatically
+ *			  added and shouldnt be included in the given name
+ *
+ * return:
+ *	true: instance file successfully loaded 
+ *  false: instance file could not be loaded for some reason
+ *
+ ************************************************************************************************/
+bool CRMInstanceFile::Open ( const char* instance )
+{
+	char		instanceDef[MAX_QPATH];
+	CGPGroup	*basegroup;
+
+	// Build the filename
+	Com_sprintf(instanceDef, MAX_QPATH, "ext_data/rmg/%s.instance", instance );
+
+#ifndef FINAL_BUILD
+	// Debug message
+	Com_Printf("CM_Terrain: Loading and parsing instanceDef %s.....\n", instance);
+#endif
+
+	// Parse the text file using the generic parser
+	if(!Com_ParseTextFile(instanceDef, mParser ))
+	{
+		Com_sprintf(instanceDef, MAX_QPATH, "ext_data/arioche/%s.instance", instance );
+		if(!Com_ParseTextFile(instanceDef, mParser ))
+		{
+			Com_Printf(va("CM_Terrain: Could not open instance file '%s'\n", instanceDef));
+			return false;
+		}
+	}
+
+	// The whole file....
+	basegroup = mParser.GetBaseParseGroup();
+
+	// The root { } struct
+	mInstances = basegroup->GetSubGroups();
+
+	// The "instances" { } structure
+	mInstances = mInstances->GetSubGroups ( );
+
+	return true;
+}
+
+/************************************************************************************************
+ * CRMInstanceFile::Close
+ *	Closes an open instance file
+ *
+ * inputs:
+ *  none
+ *
+ * return:
+ *	none
+ *
+ ************************************************************************************************/
+void CRMInstanceFile::Close ( void )
+{
+	// If not open then dont close  it
+	if ( NULL == mInstances )
+	{
+		return;
+	}
+	mParser.Clean();
+		
+	mInstances = NULL;
+}
+
+/************************************************************************************************
+ * CRMInstanceFile::CreateInstance
+ *	Creates an instance (to be freed by caller) using the given instance name.
+ *
+ * inputs:
+ *  name: Name of the instance to read from the instance file
+ *
+ * return:
+ *	NULL: instance could not be read from the instance file
+ *  NON-NULL: instance created and returned for further use
+ *
+ ************************************************************************************************/
+CRMInstance* CRMInstanceFile::CreateInstance ( const char* name )
+{
+	static int instanceID = 0;
+
+	CGPGroup*		group;
+	CRMInstance*	instance;
+
+	// Make sure we were loaded
+	assert ( mInstances );
+
+	// Search through the instances for the one with the given name
+	for ( group = mInstances; group; group = group->GetNext ( ) )
+	{
+		// Skip it if the name doesnt match
+		if ( stricmp ( name, group->FindPairValue ( "name", "" ) ) )
+		{
+			continue;
+		}
+		
+		// Handle the various forms of instance types
+		if ( !stricmp ( group->GetName ( ), "bsp" ) )
+		{
+			instance = new CRMBSPInstance ( group, *this );
+		}
+		else if ( !stricmp ( group->GetName ( ), "npc" ) )
+		{
+//			instance = new CRMNPCInstance ( group, *this );
+			continue;
+		}
+		else if ( !stricmp ( group->GetName ( ), "group" ) )
+		{
+			instance = new CRMGroupInstance ( group, *this );
+		}
+		else if ( !stricmp ( group->GetName ( ), "random" ) )
+		{
+			instance = new CRMRandomInstance ( group, *this );
+		}
+		else if ( !stricmp ( group->GetName ( ), "void" ) )
+		{
+			instance = new CRMVoidInstance ( group, *this );
+		}
+		else
+		{
+			continue;
+		}
+
+		// If the instance isnt valid after being created then delete it
+		if ( !instance->IsValid ( ) )
+		{
+			delete instance;
+			return NULL;
+		}
+
+		// The instance was successfully created so return it
+		return instance;
+	}
+
+#ifndef FINAL_BUILD
+	// The instance wasnt found in the file so report it
+	Com_Printf(va("WARNING:  Instance '%s' was not found in the active instance file\n", name ));
+#endif
+
+	return NULL;
+}
diff --git a/code/RMG/RM_InstanceFile.h b/code/RMG/RM_InstanceFile.h
new file mode 100644
index 0000000..729722e
--- /dev/null
+++ b/code/RMG/RM_InstanceFile.h
@@ -0,0 +1,28 @@
+#pragma once
+#if !defined(RM_INSTANCEFILE_H_INC)
+#define RM_INSTANCEFILE_H_INC
+
+#ifdef DEBUG_LINKING
+	#pragma message("...including RM_InstanceFile.h")
+#endif
+
+class CRMInstance;
+
+class CRMInstanceFile
+{
+public:
+
+	CRMInstanceFile ( );
+	~CRMInstanceFile ( );
+
+	bool			Open			( const char* instance );
+	void			Close			( void );
+	CRMInstance*	CreateInstance	( const char* name );
+
+protected:
+
+	CGenericParser2		mParser;
+	CGPGroup*			mInstances;
+};
+
+#endif
\ No newline at end of file
diff --git a/code/RMG/RM_Instance_BSP.cpp b/code/RMG/RM_Instance_BSP.cpp
new file mode 100644
index 0000000..ae912a6
--- /dev/null
+++ b/code/RMG/RM_Instance_BSP.cpp
@@ -0,0 +1,294 @@
+/************************************************************************************************
+ *
+ * RM_Instance_BSP.cpp
+ *
+ * Implements the CRMBSPInstance class.  This class is reponsible for parsing a 
+ * bsp instance as well as spawning it into a landscape.
+ *
+ ************************************************************************************************/
+
+#include "../server/exe_headers.h"
+
+#include "../qcommon/cm_local.h"
+#include "../server/server.h"
+#include "rm_headers.h"
+
+#include "rm_instance_bsp.h"
+
+#include "../client/vmachine.h"
+
+/************************************************************************************************
+ * CRMBSPInstance::CRMBSPInstance
+ *	constructs a building instance object using the given parser group
+ *
+ * inputs:
+ *  instance:  parser group containing information about the building instance
+ *
+ * return:
+ *	none
+ *
+ ************************************************************************************************/
+CRMBSPInstance::CRMBSPInstance(CGPGroup *instGroup, CRMInstanceFile& instFile)  : CRMInstance ( instGroup, instFile )
+{
+	strcpy(mBsp, instGroup->FindPairValue("file", ""));
+
+	mAngleVariance	= DEG2RAD(atof(instGroup->FindPairValue("anglevariance", "0")));
+	mBaseAngle		= DEG2RAD(atof(instGroup->FindPairValue("baseangle", "0")));
+	mAngleDiff		= DEG2RAD(atof(instGroup->FindPairValue("anglediff", "0")));
+	mSpacingRadius	= atof( instGroup->FindPairValue ( "spacing", "100" ) );
+	mSpacingLine	= atoi( instGroup->FindPairValue ( "spacingline", "0" ) );
+	mSurfaceSprites = (!Q_stricmp ( instGroup->FindPairValue ( "surfacesprites", "no" ), "yes")) ? true : false;
+	mLockOrigin     = (!Q_stricmp ( instGroup->FindPairValue ( "lockorigin", "no" ), "yes")) ? true : false;
+	mFlattenRadius	= atof( instGroup->FindPairValue ( "flatten", "0" ) );
+	mHoleRadius		= atof( instGroup->FindPairValue ( "hole", "0" ) );
+
+	const char * automapSymName = instGroup->FindPairValue ( "automap_symbol", "building" );
+	if (0 == strcmpi(automapSymName, "none"))	   	mAutomapSymbol = AUTOMAP_NONE ;
+	else if (0 == strcmpi(automapSymName, "building"))  	mAutomapSymbol = AUTOMAP_BLD  ;
+	else if (0 == strcmpi(automapSymName, "objective")) 	mAutomapSymbol = AUTOMAP_OBJ  ;
+	else if (0 == strcmpi(automapSymName, "start"))	   	mAutomapSymbol = AUTOMAP_START;
+	else if (0 == strcmpi(automapSymName, "end"))	   	mAutomapSymbol = AUTOMAP_END  ;
+	else if (0 == strcmpi(automapSymName, "enemy"))	   	mAutomapSymbol = AUTOMAP_ENEMY;
+	else if (0 == strcmpi(automapSymName, "friend"))	   	mAutomapSymbol = AUTOMAP_FRIEND;
+	else if (0 == strcmpi(automapSymName, "wall"))	   	mAutomapSymbol = AUTOMAP_WALL;
+	else mAutomapSymbol	= atoi( automapSymName );
+
+	// optional instance objective strings
+	SetMessage(instGroup->FindPairValue("objective_message",""));
+	SetDescription(instGroup->FindPairValue("objective_description",""));
+	SetInfo(instGroup->FindPairValue("objective_info",""));
+
+	mBounds[0][0] = 0;
+	mBounds[0][1] = 0;
+	mBounds[1][0] = 0;
+	mBounds[1][1] = 0;
+
+	mBaseAngle += (TheRandomMissionManager->GetLandScape()->irand(0,mAngleVariance) - mAngleVariance/2);
+}
+
+/************************************************************************************************
+ * CRMBSPInstance::Spawn
+ *	spawns a bsp into the world using the previously aquired origin
+ *
+ * inputs:
+ *  none
+ *
+ * return:
+ *	none
+ *
+ ************************************************************************************************/
+bool CRMBSPInstance::Spawn ( CRandomTerrain* terrain, qboolean IsServer)
+{
+#ifndef PRE_RELEASE_DEMO
+//	TEntity*	ent;
+	float		yaw;
+	char		temp[10000];
+	char		*savePtr;
+	vec3_t		origin;
+	vec3_t		notmirrored;
+	float	water_level = terrain->GetLandScape()->GetWaterHeight();
+
+	const vec3_t&	  terxelSize = terrain->GetLandScape()->GetTerxelSize ( );
+	const vec3pair_t& bounds     = terrain->GetLandScape()->GetBounds();
+
+	// If this entity somehow lost its collision flag then boot it
+	if ( !GetArea().IsCollisionEnabled ( ) )
+	{
+		return false;
+	}
+
+	// copy out the unmirrored version
+	VectorCopy(GetOrigin(), notmirrored);
+
+	// we want to mirror it before determining the Z value just in case the landscape isn't perfectly mirrored
+	if (mMirror)
+	{
+		GetOrigin()[0] = TheRandomMissionManager->GetLandScape()->GetBounds()[0][0] + TheRandomMissionManager->GetLandScape()->GetBounds()[1][0] - GetOrigin()[0];
+		GetOrigin()[1] = TheRandomMissionManager->GetLandScape()->GetBounds()[0][1] + TheRandomMissionManager->GetLandScape()->GetBounds()[1][1] - GetOrigin()[1];
+	}
+
+	// Align the instance to the center of a terxel
+	GetOrigin ( )[0] = bounds[0][0] + (int)((GetOrigin ( )[0] - bounds[0][0] + terxelSize[0] / 2) / terxelSize[0]) * terxelSize[0];
+	GetOrigin ( )[1] = bounds[0][1] + (int)((GetOrigin ( )[1] - bounds[0][1] + terxelSize[1] / 2) / terxelSize[1]) * terxelSize[1];
+
+	// Make sure the bsp is resting on the ground, not below or above it
+	// NOTE: This check is basically saying "is this instance not a bridge", because when instances are created they are all
+	// placed above the world's Z boundary, EXCEPT FOR BRIDGES. So this call to GetWorldHeight will move all other instances down to
+	// ground level except bridges 
+	if ( GetOrigin()[2] > terrain->GetBounds()[1][2] )
+	{
+		if( GetFlattenRadius() )
+		{
+			terrain->GetLandScape()->GetWorldHeight ( GetOrigin(), GetBounds ( ), false );
+			GetOrigin()[2] += 5;
+		}
+		else if (IsServer)
+		{	// if this instance does not flatten the ground around it, do a trace to more accurately determine its Z value
+			trace_t		tr;
+			vec3_t		end;
+			vec3_t		start;
+
+			VectorCopy(GetOrigin(), end);
+			VectorCopy(GetOrigin(), start);
+			// start the trace below the top height of the landscape
+			start[2] = TheRandomMissionManager->GetLandScape()->GetBounds()[1][2] - 1;
+			// end the trace at the bottom of the world
+			end[2] = MIN_WORLD_COORD;
+	
+			memset ( &tr, 0, sizeof ( tr ) );
+			SV_Trace( &tr, start, vec3_origin, vec3_origin, end, ENTITYNUM_NONE, CONTENTS_TERRAIN|CONTENTS_SOLID, G2_NOCOLLIDE, 0); //qfalse, 0, 10 );
+
+			if( !(tr.contents & CONTENTS_TERRAIN) || (tr.fraction == 1.0) )
+			{
+				if ( 0 )
+				assert(0); // this should never happen
+
+				// restore the unmirrored origin
+				VectorCopy( notmirrored, GetOrigin() );
+				// don't spawn
+				return false;
+			}
+			// assign the Z-value to wherever it hit the terrain	
+			GetOrigin()[2] = tr.endpos[2];
+			// lower it a little, otherwise the bottom of the instance might be exposed if on some weird sloped terrain
+			GetOrigin()[2] -= 16; // FIXME: would it be better to use a number related to the instance itself like 1/5 it's height or something...
+		}
+
+	}
+	else
+	{
+		terrain->GetLandScape()->GetWorldHeight ( GetOrigin(), GetBounds ( ), true );
+	}
+	
+	// save away the origin
+	VectorCopy(GetOrigin(), origin);
+	// make sure not to spawn if in water
+	if (!HasObjective() && GetOrigin()[2] < water_level)
+		return false;
+	// restore the origin
+	VectorCopy(origin, GetOrigin());
+
+	if (mMirror)
+	{	// change blue things to red for symmetric maps
+		if (strlen(mFilter) > 0)
+		{
+			char * blue = strstr(mFilter,"blue");
+			if (blue)
+			{
+				blue[0] = (char) 0;
+				strcat(mFilter, "red");
+				SetSide(SIDE_RED);
+			}
+		}
+		if (strlen(mTeamFilter) > 0)
+		{
+			char * blue = strstr(mTeamFilter,"blue");
+			if (blue)
+			{
+				strcpy(mTeamFilter, "red");
+				SetSide(SIDE_RED);
+			}
+		}
+		yaw = RAD2DEG(mArea->GetAngle() + mBaseAngle) + 180;
+	}
+	else
+	{
+		yaw = RAD2DEG(mArea->GetAngle() + mBaseAngle);
+	}
+
+/*
+	if( TheRandomMissionManager->GetMission()->GetSymmetric() )
+	{
+		vec3_t	diagonal;
+		vec3_t	lineToPoint;
+		vec3_t	mins;
+		vec3_t	maxs;
+		vec3_t	point;
+		vec3_t	vProj;
+		vec3_t	vec;
+		float	distance;
+
+		VectorCopy( TheRandomMissionManager->GetLandScape()->GetBounds()[1], maxs );
+		VectorCopy( TheRandomMissionManager->GetLandScape()->GetBounds()[0], mins );
+		VectorCopy( GetOrigin(), point );
+		mins[2] = maxs[2] = point[2] = 0;
+		VectorSubtract( point, mins, lineToPoint );
+		VectorSubtract( maxs, mins, diagonal);
+
+
+		VectorNormalize(diagonal);	
+		VectorMA( mins, DotProduct(lineToPoint, diagonal), diagonal, vProj);
+		VectorSubtract(point, vProj, vec );
+		distance = VectorLength(vec);
+
+		// if an instance is too close to the imaginary diagonal that cuts the world in half, don't spawn it
+		// otherwise you can get overlapping instances
+		if( distance < GetSpacingRadius() )
+		{
+#ifdef _DEBUG
+			mAutomapSymbol = AUTOMAP_END;
+#endif
+			if( !HasObjective() )
+			{
+				return false;
+			}
+		}
+	}
+*/
+
+	// Spawn in the bsp model
+	sprintf(temp, 
+		"{\n"
+		"\"classname\"   \"misc_bsp\"\n"
+		"\"bspmodel\"    \"%s\"\n"
+		"\"origin\"      \"%f %f %f\"\n"
+		"\"angles\"      \"0 %f 0\"\n"
+		"\"filter\"      \"%s\"\n"
+		"\"teamfilter\"  \"%s\"\n"
+		"\"spacing\"	 \"%d\"\n"
+		"\"flatten\"	 \"%d\"\n"
+		"}\n",
+		mBsp,
+		GetOrigin()[0], GetOrigin()[1], GetOrigin()[2],
+		AngleNormalize360(yaw),
+		mFilter,
+		mTeamFilter,
+		(int)GetSpacingRadius(),
+		(int)GetFlattenRadius()
+		);
+
+	if (IsServer)
+	{	// only allow for true spawning on the server
+		savePtr = sv.entityParsePoint;
+		sv.entityParsePoint = temp;
+//		VM_Call( cgvm, GAME_SPAWN_RMG_ENTITY );
+	//	char *s;
+		int bufferSize = 1024;
+		char buffer[1024];
+
+	//	s = COM_Parse( (const char **)&sv.entityParsePoint );
+		Q_strncpyz( buffer, sv.entityParsePoint, bufferSize );
+		if ( sv.entityParsePoint && sv.entityParsePoint[0] ) 
+		{
+			ge->GameSpawnRMGEntity(sv.entityParsePoint);
+		}
+		sv.entityParsePoint = savePtr;
+	}
+
+	
+#ifndef DEDICATED
+	DrawAutomapSymbol();
+#endif
+	Com_DPrintf( "RMG:  Building '%s' spawned at (%f %f %f)\n", mBsp, GetOrigin()[0], GetOrigin()[1], GetOrigin()[2] );
+	// now restore the instances un-mirrored origin
+	// NOTE: all this origin flipping, setting the side etc... should be done when mMirror is set
+	// because right after this function is called, mMirror is set to 0 but all the instance data is STILL MIRRORED -- not good
+	VectorCopy(notmirrored, GetOrigin());
+
+#endif  // PRE_RELEASE_DEMO
+	
+	return true;
+}
+
+
+
diff --git a/code/RMG/RM_Instance_BSP.h b/code/RMG/RM_Instance_BSP.h
new file mode 100644
index 0000000..b1c4be3
--- /dev/null
+++ b/code/RMG/RM_Instance_BSP.h
@@ -0,0 +1,35 @@
+#pragma once
+#if !defined(RM_INSTANCE_BSP_H_INC)
+#define RM_INSTANCE_BSP_H_INC
+
+#ifdef DEBUG_LINKING
+	#pragma message("...including RM_Instance_BSP.h")
+#endif
+
+class CRMBSPInstance : public CRMInstance
+{
+private:
+
+	char		mBsp[MAX_QPATH];
+	float		mAngleVariance;
+	float		mBaseAngle;
+	float		mAngleDiff;
+
+	float		mHoleRadius;
+
+public:
+
+	CRMBSPInstance	 ( CGPGroup *instance, CRMInstanceFile& instFile );
+
+	virtual int			GetPreviewColor		( )		{ return (255<<24)+255; }
+
+	virtual float		GetHoleRadius		( ) { return mHoleRadius; }
+
+	virtual bool		Spawn				( CRandomTerrain* terrain, qboolean IsServer );
+
+	const char*			GetModelName	 (void) const { return(mBsp); }
+	float				GetAngleDiff	 (void) const { return(mAngleDiff); }
+	bool				GetAngularType	 (void) const { return(mAngleDiff != 0.0f); }
+};
+
+#endif
\ No newline at end of file
diff --git a/code/RMG/RM_Instance_Group.cpp b/code/RMG/RM_Instance_Group.cpp
new file mode 100644
index 0000000..382e8b6
--- /dev/null
+++ b/code/RMG/RM_Instance_Group.cpp
@@ -0,0 +1,343 @@
+/************************************************************************************************
+ *
+ * RM_Instance_Group.cpp
+ *
+ * Implements the CRMGroupInstance class.  This class is reponsible for parsing a 
+ * group instance as well as spawning it into a landscape.
+ *
+ ************************************************************************************************/
+
+#include "../server/exe_headers.h"
+
+#include "rm_headers.h"
+
+#include "rm_instance_group.h"
+
+/************************************************************************************************
+ * CRMGroupInstance::CRMGroupInstance
+ *	constructur
+ *
+ * inputs:
+ *  settlementID:  ID of the settlement being created 
+ *
+ * return:
+ *	none
+ *
+ ************************************************************************************************/
+CRMGroupInstance::CRMGroupInstance ( CGPGroup *instGroup, CRMInstanceFile& instFile ) 
+	:  CRMInstance ( instGroup, instFile )
+{
+	// Grab the padding and confine radius
+	mPaddingSize   = atof ( instGroup->FindPairValue ( "padding", va("%i", TheRandomMissionManager->GetMission()->GetDefaultPadding() ) ) );
+	mConfineRadius = atof ( instGroup->FindPairValue ( "confine", "0" ) );
+
+	const char * automapSymName = instGroup->FindPairValue ( "automap_symbol", "none" );
+	if (0 == strcmpi(automapSymName, "none"))	   	mAutomapSymbol = AUTOMAP_NONE ;
+	else if (0 == strcmpi(automapSymName, "building"))  	mAutomapSymbol = AUTOMAP_BLD  ;
+	else if (0 == strcmpi(automapSymName, "objective")) 	mAutomapSymbol = AUTOMAP_OBJ  ;
+	else if (0 == strcmpi(automapSymName, "start"))	   	mAutomapSymbol = AUTOMAP_START;
+	else if (0 == strcmpi(automapSymName, "end"))	   	mAutomapSymbol = AUTOMAP_END  ;
+	else if (0 == strcmpi(automapSymName, "enemy"))	   	mAutomapSymbol = AUTOMAP_ENEMY;
+	else if (0 == strcmpi(automapSymName, "friend"))	   	mAutomapSymbol = AUTOMAP_FRIEND;
+	else mAutomapSymbol	= atoi( automapSymName );
+
+	// optional instance objective strings
+	SetMessage(instGroup->FindPairValue("objective_message",""));
+	SetDescription(instGroup->FindPairValue("objective_description",""));
+	SetInfo(instGroup->FindPairValue("objective_info",""));
+
+	// Iterate through the sub groups to determine the instances which make up the group
+	instGroup = instGroup->GetSubGroups ( );
+
+	while ( instGroup )
+	{
+		CRMInstance* instance;
+		const char*  name;
+		int			 mincount;
+		int			 maxcount;
+		int			 count;
+		float		 minrange;
+		float		 maxrange;
+
+		// Make sure only instances are specified as sub groups
+		assert ( 0 == stricmp ( instGroup->GetName ( ), "instance" ) );
+
+		// Grab the name
+		name     = instGroup->FindPairValue ( "name", "" );
+
+		// Grab the range information
+		minrange = atof(instGroup->FindPairValue ( "minrange", "0" ) );
+		maxrange = atof(instGroup->FindPairValue ( "maxrange", "0" ) );
+
+		// Grab the count information and randomly generate a count value
+		mincount = atoi(instGroup->FindPairValue ( "mincount", "1" ) );
+		maxcount = atoi(instGroup->FindPairValue ( "maxcount", "1" ) );
+		count	 = mincount;
+
+		if ( maxcount > mincount )
+		{
+			count += (TheRandomMissionManager->GetLandScape()->irand(0, maxcount-mincount));
+		}
+
+		// For each count create and add the instance
+		for ( ; count ; count -- )
+		{
+			// Create the instance
+			instance = instFile.CreateInstance ( name );
+
+			// Skip this instance if it couldnt be created for some reason.  The CreateInstance
+			// method will report an error so no need to do so here.
+			if ( NULL == instance )
+			{
+				continue;
+			}
+
+			// Set the min and max range for the instance
+			instance->SetFilter(mFilter);
+			instance->SetTeamFilter(mTeamFilter);
+
+			// Add the instance to the list
+			mInstances.push_back ( instance );
+		}
+
+		// Next sub group
+		instGroup = instGroup->GetNext ( );
+	}
+}
+
+/************************************************************************************************
+ * CRMGroupInstance::~CRMGroupInstance
+ *	Removes all buildings and inhabitants
+ *
+ * inputs:
+ *  none
+ *
+ * return:
+ *	none
+ *
+ ************************************************************************************************/
+CRMGroupInstance::~CRMGroupInstance(void)
+{
+	// Cleanup
+	RemoveInstances ( );
+}
+
+/************************************************************************************************
+ * CRMGroupInstance::SetFilter
+ *	Sets a filter used to exclude instances
+ *
+ * inputs:
+ *  filter: filter name
+ *
+ * return:
+ *	none
+ *
+ ************************************************************************************************/
+void CRMGroupInstance::SetFilter( const char *filter )
+{
+	rmInstanceIter_t it;
+
+	CRMInstance::SetFilter(filter);
+	for(it = mInstances.begin(); it != mInstances.end(); it++)
+	{
+		(*it)->SetFilter(filter);
+	}
+}
+
+/************************************************************************************************
+ * CRMGroupInstance::SetTeamFilter
+ *	Sets the filter used to exclude team based instances
+ *
+ * inputs:
+ *  teamFilter: filter name
+ *
+ * return:
+ *	none
+ *
+ ************************************************************************************************/
+void CRMGroupInstance::SetTeamFilter( const char *teamFilter )
+{
+	rmInstanceIter_t it;
+
+	CRMInstance::SetTeamFilter(teamFilter);
+	for(it = mInstances.begin(); it != mInstances.end(); it++)
+	{
+		(*it)->SetTeamFilter(teamFilter);
+	}
+}
+
+/************************************************************************************************
+ * CRMGroupInstance::SetMirror
+ *	Sets the flag to mirror an instance on map
+ *
+ * inputs:
+ *  mirror 
+ *
+ * return:
+ *	none
+ *
+ ************************************************************************************************/
+void CRMGroupInstance::SetMirror(int mirror)
+{ 
+	rmInstanceIter_t it;
+
+	CRMInstance::SetMirror(mirror);
+	for(it = mInstances.begin(); it != mInstances.end(); it++)
+	{
+		(*it)->SetMirror(mirror);
+	}
+}
+
+
+/************************************************************************************************
+ * CRMGroupInstance::RemoveInstances
+ *	Removes all instances associated with the group
+ *
+ * inputs:
+ *  none
+ *
+ * return:
+ *	none
+ *
+ ************************************************************************************************/
+void CRMGroupInstance::RemoveInstances ( )
+{
+	rmInstanceIter_t it;
+
+	for(it = mInstances.begin(); it != mInstances.end(); it++)
+	{
+		delete *it;
+	}
+
+	mInstances.clear();
+}
+
+/************************************************************************************************
+ * CRMGroupInstance::PreSpawn
+ *	Prepares the group for spawning by 
+ *
+ * inputs:
+ *  landscape: landscape to calculate the position within
+ *  instance: instance to calculate the position for
+ *
+ * return:
+ *	none
+ *
+ ************************************************************************************************/
+bool CRMGroupInstance::PreSpawn ( CRandomTerrain* terrain, qboolean IsServer )
+{
+	rmInstanceIter_t it;
+
+	for(it = mInstances.begin(); it != mInstances.end(); it++ )
+	{
+		CRMInstance* instance = *it;
+
+		instance->SetFlattenHeight ( mFlattenHeight );
+
+		// Add the instance to the landscape now
+		instance->PreSpawn ( terrain, IsServer );		
+	}
+
+	return CRMInstance::PreSpawn ( terrain, IsServer );
+}
+
+/************************************************************************************************
+ * CRMGroupInstance::Spawn
+ *	Adds the group instance to the given landscape using the specified origin.  All sub instances
+ *  will be added to the landscape within their min and max range from the origin.
+ *
+ * inputs:
+ *  landscape: landscape to add the instance group to
+ *  origin: origin of the instance group
+ *
+ * return:
+ *	none
+ *
+ ************************************************************************************************/
+bool CRMGroupInstance::Spawn ( CRandomTerrain* terrain, qboolean IsServer )
+{
+	rmInstanceIter_t it;
+
+	// Spawn all the instances associated with this group
+	for(it = mInstances.begin(); it != mInstances.end(); it++)
+	{
+		CRMInstance* instance = *it;
+		instance->SetSide(GetSide()); // which side owns it?
+
+		// Add the instance to the landscape now
+		instance->Spawn ( terrain, IsServer );
+	}
+#ifndef DEDICATED
+	DrawAutomapSymbol();
+#endif
+	return true;
+}
+
+/************************************************************************************************
+ * CRMGroupInstance::Preview
+ *	Renders debug information for the instance
+ *
+ * inputs:
+ *  from: point to render the preview from
+ *
+ * return:
+ *	none
+ *
+ ************************************************************************************************/
+void CRMGroupInstance::Preview ( const vec3_t from )
+{
+	rmInstanceIter_t it;
+
+	CRMInstance::Preview ( from );
+	
+	// Render all the instances
+	for(it = mInstances.begin(); it != mInstances.end(); it++)
+	{
+		CRMInstance* instance = *it;
+
+		instance->Preview ( from );
+	}
+}
+
+/************************************************************************************************
+ * CRMGroupInstance::SetArea
+ *	Overidden to make sure the groups area doesnt eat up any room.  The collision on the
+ *  groups area will be turned off
+ *
+ * inputs:
+ *  area: area to set
+ *
+ * return:
+ *	none
+ *
+ ************************************************************************************************/
+void CRMGroupInstance::SetArea ( CRMAreaManager* amanager, CRMArea* area )
+{
+	rmInstanceIter_t it;
+
+	bool collide = area->IsCollisionEnabled ( );
+
+	// Disable collision
+	area->EnableCollision ( false );
+
+	// Do what really needs to get done
+	CRMInstance::SetArea ( amanager, area );
+
+	// Prepare for spawn by calculating all the positions of the sub instances
+	// and flattening the ground below them.
+	for(it = mInstances.begin(); it != mInstances.end(); it++ )
+	{
+		CRMInstance  *instance = *it;
+		CRMArea		 *newarea;
+		vec3_t		 origin;
+
+		// Drop it in the center of the group for now
+		origin[0] = GetOrigin()[0];
+		origin[1] = GetOrigin()[1];
+		origin[2] = 2500;
+
+		// Set the area of position
+		newarea = amanager->CreateArea ( origin, instance->GetSpacingRadius(), instance->GetSpacingLine(), mPaddingSize, mConfineRadius, GetOrigin(), GetOrigin(), instance->GetFlattenRadius()?true:false, collide, instance->GetLockOrigin(), area->GetSymmetric ( ) );
+		instance->SetArea ( amanager, newarea );
+	}
+}
diff --git a/code/RMG/RM_Instance_Group.h b/code/RMG/RM_Instance_Group.h
new file mode 100644
index 0000000..50b89c7
--- /dev/null
+++ b/code/RMG/RM_Instance_Group.h
@@ -0,0 +1,41 @@
+#pragma once
+#if !defined(RM_INSTANCE_GROUP_H_INC)
+#define RM_INSTANCE_GROUP_H_INC
+
+#ifdef DEBUG_LINKING
+	#pragma message("...including RM_Instance_Group.h")
+#endif
+
+class CRMGroupInstance : public CRMInstance
+{
+protected:
+
+	rmInstanceList_t	mInstances;
+	float				mConfineRadius;
+	float				mPaddingSize;
+
+public:
+
+	CRMGroupInstance( CGPGroup* instGroup, CRMInstanceFile& instFile);
+	~CRMGroupInstance();
+
+	virtual bool		PreSpawn			( CRandomTerrain* terrain, qboolean IsServer );
+	virtual bool		Spawn				( CRandomTerrain* terrain, qboolean IsServer );
+
+	virtual void		Preview				( const vec3_t from );
+
+	virtual void		SetFilter			( const char *filter );
+	virtual void		SetTeamFilter		( const char *teamFilter );
+	virtual void		SetArea				( CRMAreaManager* amanager, CRMArea* area );
+
+	virtual int			GetPreviewColor		( )		{ return (255<<24)+(255<<8); }
+	virtual float		GetSpacingRadius	( )		{ return 0; }
+	virtual float		GetFlattenRadius	( )		{ return 0; }
+	virtual void  		SetMirror(int mirror);
+
+protected:
+
+	void	RemoveInstances	 ( );
+};
+
+#endif
\ No newline at end of file
diff --git a/code/RMG/RM_Instance_Random.cpp b/code/RMG/RM_Instance_Random.cpp
new file mode 100644
index 0000000..48a5432
--- /dev/null
+++ b/code/RMG/RM_Instance_Random.cpp
@@ -0,0 +1,187 @@
+/************************************************************************************************
+ *
+ * RM_Instance_Random.cpp
+ *
+ * Implements the CRMRandomInstance class.  This class is reponsible for parsing a 
+ * random instance as well as spawning it into a landscape.
+ *
+ ************************************************************************************************/
+
+#include "../server/exe_headers.h"
+
+#include "rm_headers.h"
+
+#include "rm_instance_random.h"
+
+/************************************************************************************************
+ * CRMRandomInstance::CRMRandomInstance
+ *	constructs a random instance by choosing one of the sub instances and creating it
+ *
+ * inputs:
+ *  instGroup:  parser group containing infromation about this instance
+ *  instFile:   reference to an open instance file for creating sub instances
+ *
+ * return:
+ *	none
+ *
+ ************************************************************************************************/
+CRMRandomInstance::CRMRandomInstance ( CGPGroup *instGroup, CRMInstanceFile& instFile ) 
+	: CRMInstance ( instGroup, instFile )
+{
+	CGPGroup* group;
+	CGPGroup* groups[MAX_RANDOM_INSTANCES];
+	int		  numGroups;
+
+	// Build a list of the groups one can be chosen
+	for ( numGroups = 0, group = instGroup->GetSubGroups ( ); 
+		  group; 
+		  group = group->GetNext ( ) )
+	{
+		// If this isnt an instance group then skip it
+		if ( stricmp ( group->GetName ( ), "instance" ) )
+		{
+			continue;
+		}
+
+		int multiplier = atoi(group->FindPairValue ( "multiplier", "1" ));
+		for ( ; multiplier > 0 && numGroups < MAX_RANDOM_INSTANCES; multiplier -- )
+		{ 
+			groups[numGroups++] = group;
+		}
+	}
+
+	// No groups, no instance
+	if ( !numGroups )
+	{
+		// Initialize this now
+		mInstance = NULL;
+
+		Com_Printf ( "WARNING: No sub instances specified for random instance '%s'\n", group->FindPairValue ( "name", "unknown" ) );
+		return;
+	}
+
+	// Now choose a group to parse	
+	instGroup = groups[TheRandomMissionManager->GetLandScape()->irand(0,numGroups-1)];
+
+	// Create the child instance now.  If the instance create fails then the
+	// IsValid routine will return false and this instance wont be added
+	mInstance = instFile.CreateInstance ( instGroup->FindPairValue ( "name", "" ) );
+	mInstance->SetFilter(mFilter);
+	mInstance->SetTeamFilter(mTeamFilter);
+
+	mAutomapSymbol = mInstance->GetAutomapSymbol();
+
+	SetMessage(mInstance->GetMessage());
+	SetDescription(mInstance->GetDescription());
+	SetInfo(mInstance->GetInfo());
+}
+
+/************************************************************************************************
+ * CRMRandomInstance::~CRMRandomInstance
+ *	Deletes the sub instance
+ *
+ * inputs:
+ *  none
+ *
+ * return:
+ *	none
+ *
+ ************************************************************************************************/
+CRMRandomInstance::~CRMRandomInstance(void)
+{
+	if ( mInstance )
+	{
+		delete mInstance;
+	}
+}
+
+void CRMRandomInstance::SetMirror(int mirror)
+{ 
+	CRMInstance::SetMirror(mirror);
+	if (mInstance)
+	{
+		mInstance->SetMirror(mirror);
+	}
+}
+
+void CRMRandomInstance::SetFilter( const char *filter )
+{
+	CRMInstance::SetFilter(filter);
+	if (mInstance)
+	{
+		mInstance->SetFilter(filter);
+	}
+}
+
+void CRMRandomInstance::SetTeamFilter( const char *teamFilter )
+{
+	CRMInstance::SetTeamFilter(teamFilter);
+	if (mInstance)
+	{
+		mInstance->SetTeamFilter(teamFilter);
+	}
+}
+
+/************************************************************************************************
+ * CRMRandomInstance::PreSpawn
+ *	Prepares for the spawn of the random instance
+ *
+ * inputs:
+ *  landscape: landscape object this instance will be spawned on
+ *
+ * return:
+ *	true: preparation successful
+ *  false: preparation failed
+ *
+ ************************************************************************************************/
+bool CRMRandomInstance::PreSpawn ( CRandomTerrain* terrain, qboolean IsServer )
+{
+	assert ( mInstance );
+
+	mInstance->SetFlattenHeight ( GetFlattenHeight( ) );
+
+	return mInstance->PreSpawn ( terrain, IsServer );
+}
+
+/************************************************************************************************
+ * CRMRandomInstance::Spawn
+ *	Spawns the instance onto the landscape
+ *
+ * inputs:
+ *  landscape: landscape object this instance will be spawned on
+ *
+ * return:
+ *	true: spawn successful
+ *  false: spawn failed
+ *
+ ************************************************************************************************/
+bool CRMRandomInstance::Spawn ( CRandomTerrain* terrain, qboolean IsServer )
+{
+	mInstance->SetObjective(GetObjective());
+	mInstance->SetSide(GetSide());
+
+	if ( !mInstance->Spawn ( terrain, IsServer ) )
+	{
+		return false;
+	}
+
+	return true;
+}
+
+/************************************************************************************************
+ * CRMRandomInstance::SetArea
+ *	Forwards the given area off to the internal instance
+ *
+ * inputs:
+ *  area: area to be set
+ *
+ * return:
+ *	none
+ *
+ ************************************************************************************************/
+void CRMRandomInstance::SetArea ( CRMAreaManager* amanager, CRMArea* area )
+{
+	CRMInstance::SetArea ( amanager, area );
+
+	mInstance->SetArea ( amanager, mArea );
+}
diff --git a/code/RMG/RM_Instance_Random.h b/code/RMG/RM_Instance_Random.h
new file mode 100644
index 0000000..20bdad9
--- /dev/null
+++ b/code/RMG/RM_Instance_Random.h
@@ -0,0 +1,40 @@
+#pragma once
+#if !defined(RM_INSTANCE_RANDOM_H_INC)
+#define RM_INSTANCE_RANDOM_H_INC
+
+#ifdef DEBUG_LINKING
+	#pragma message("...including RM_Instance_Random.h")
+#endif
+
+#define	MAX_RANDOM_INSTANCES		64
+
+class CRMRandomInstance : public CRMInstance
+{
+protected:
+
+	CRMInstance*	mInstance;
+
+public:
+
+	CRMRandomInstance ( CGPGroup* instGroup, CRMInstanceFile& instFile );
+	~CRMRandomInstance ( );
+
+	virtual bool		IsValid				( )	{ return mInstance==NULL?false:true; }
+
+	virtual int			GetPreviewColor		( )		{ return mInstance->GetPreviewColor ( ); }
+
+	virtual float		GetSpacingRadius	( )		{ return mInstance->GetSpacingRadius ( ); }
+	virtual int			GetSpacingLine		( )		{ return mInstance->GetSpacingLine ( ); }
+	virtual float		GetFlattenRadius	( )		{ return mInstance->GetFlattenRadius ( ); }
+	virtual bool		GetLockOrigin		( )		{ return mInstance->GetLockOrigin ( ); }
+
+	virtual void		SetFilter			( const char *filter );
+	virtual void		SetTeamFilter		( const char *teamFilter );
+	virtual void		SetArea				( CRMAreaManager* amanager, CRMArea* area );
+	virtual void  		SetMirror			(int mirror);
+
+	virtual bool		PreSpawn			( CRandomTerrain* terrain, qboolean IsServer );
+	virtual bool		Spawn				( CRandomTerrain* terrain, qboolean IsServer );
+};
+
+#endif
\ No newline at end of file
diff --git a/code/RMG/RM_Instance_Void.cpp b/code/RMG/RM_Instance_Void.cpp
new file mode 100644
index 0000000..fd1a303
--- /dev/null
+++ b/code/RMG/RM_Instance_Void.cpp
@@ -0,0 +1,53 @@
+/************************************************************************************************
+ *
+ * RM_Instance_Void.cpp
+ *
+ * Implements the CRMVoidInstance class.  This class just adds a void into the 
+ * area manager to help space things out.
+ *
+ ************************************************************************************************/
+
+#include "../server/exe_headers.h"
+
+#include "rm_headers.h"
+
+#include "rm_instance_void.h"
+
+/************************************************************************************************
+ * CRMVoidInstance::CRMVoidInstance
+ *	constructs a void instance 
+ *
+ * inputs:
+ *  instGroup:  parser group containing infromation about this instance
+ *  instFile:   reference to an open instance file for creating sub instances
+ *
+ * return:
+ *	none
+ *
+ ************************************************************************************************/
+CRMVoidInstance::CRMVoidInstance ( CGPGroup *instGroup, CRMInstanceFile& instFile ) 
+	: CRMInstance ( instGroup, instFile )
+{
+	mSpacingRadius = atof( instGroup->FindPairValue ( "spacing", "0" ) );
+	mFlattenRadius = atof( instGroup->FindPairValue ( "flatten", "0" ) );
+}
+
+/************************************************************************************************
+ * CRMVoidInstance::SetArea
+ *	Overidden to make sure the void area doesnt continually.  
+ *
+ * inputs:
+ *  area: area to set
+ *
+ * return:
+ *	none
+ *
+ ************************************************************************************************/
+void CRMVoidInstance::SetArea ( CRMAreaManager* amanager, CRMArea* area )
+{
+	// Disable collision
+	area->EnableCollision ( false );
+
+	// Do what really needs to get done
+	CRMInstance::SetArea ( amanager, area );
+}
diff --git a/code/RMG/RM_Instance_Void.h b/code/RMG/RM_Instance_Void.h
new file mode 100644
index 0000000..a437d89
--- /dev/null
+++ b/code/RMG/RM_Instance_Void.h
@@ -0,0 +1,18 @@
+#pragma once
+#if !defined(RM_INSTANCE_VOID_H_INC)
+#define RM_INSTANCE_VOID_H_INC
+
+#ifdef DEBUG_LINKING
+	#pragma message("...including RM_Instance_Void.h")
+#endif
+
+class CRMVoidInstance : public CRMInstance
+{
+public:
+
+	CRMVoidInstance ( CGPGroup* instGroup, CRMInstanceFile& instFile );
+
+	virtual void		SetArea		( CRMAreaManager* amanager, CRMArea* area );
+};
+
+#endif
\ No newline at end of file
diff --git a/code/RMG/RM_Manager.cpp b/code/RMG/RM_Manager.cpp
new file mode 100644
index 0000000..bded10b
--- /dev/null
+++ b/code/RMG/RM_Manager.cpp
@@ -0,0 +1,402 @@
+/************************************************************************************************
+ *
+ * RM_Manager.cpp
+ *
+ * Implements the CRMManager class.  The CRMManager class manages the arioche system.
+ *
+ ************************************************************************************************/
+
+#include "../server/exe_headers.h"
+
+#include "rm_headers.h"
+#include "../server/server.h"
+
+CRMObjective *CRMManager::mCurObjective=0;
+
+/************************************************************************************************
+ * TheRandomMissionManager
+ *	Pointer to only active CRMManager class
+ *
+ ************************************************************************************************/
+CRMManager *TheRandomMissionManager;
+
+/************************************************************************************************
+ * CRMManager::CRMManager
+ *	constructor
+ *
+ * inputs:
+ *
+ * return:
+ *
+ ************************************************************************************************/
+CRMManager::CRMManager(void)
+{
+	mLandScape = NULL;
+	mTerrain   = NULL;
+	mMission = NULL;
+	mCurPriority = 1;
+	mUseTimeLimit = false;
+}
+
+/************************************************************************************************
+ * CRMManager::~CRMManager
+ *	destructor
+ *
+ * inputs:
+ *
+ * return:
+ *
+ ************************************************************************************************/
+CRMManager::~CRMManager(void)
+{
+#ifndef FINAL_BUILD
+	Com_Printf ("... Shutting down TheRandomMissionManager\n");
+#endif
+#ifndef DEDICATED
+	CM_TM_Free();
+#endif
+	if (mMission)
+	{
+		delete mMission;
+		mMission = NULL;
+	}
+}
+
+/************************************************************************************************
+ * CRMManager::SetLandscape
+ *	Sets the landscape and terrain object used to load a mission
+ *
+ * inputs:
+ *	landscape - landscape object
+ *
+ * return:
+ *	none
+ *
+ ************************************************************************************************/
+void CRMManager::SetLandScape(CCMLandScape *landscape)
+{
+	mLandScape = landscape;
+	mTerrain = landscape->GetRandomTerrain();
+}
+
+/************************************************************************************************
+ * CRMManager::LoadMission
+ *	Loads the mission using the mission name stored in the ar_mission cvar
+ *
+ * inputs:
+ *	none
+ *
+ * return:
+ *	none
+ *
+ ************************************************************************************************/
+bool CRMManager::LoadMission ( qboolean IsServer )
+{
+#ifndef PRE_RELEASE_DEMO
+	char	instances[MAX_QPATH];
+	char	mission[MAX_QPATH];
+	char	course[MAX_QPATH];
+	char	map[MAX_QPATH];
+	char	temp[MAX_QPATH];
+
+#ifndef FINAL_BUILD
+	Com_Printf ("--------- Random Mission Manager ---------\n\n");
+	Com_Printf ("RMG version : 0.01\n\n");
+#endif
+
+	if (!mTerrain)
+	{
+		return false;
+	}
+
+	// Grab the arioche variables
+	Cvar_VariableStringBuffer("rmg_usetimelimit", temp, MAX_QPATH);
+	if (strcmpi(temp, "yes") == 0)
+	{
+		mUseTimeLimit = true;
+	}
+	Cvar_VariableStringBuffer("rmg_instances", instances, MAX_QPATH);
+	Cvar_VariableStringBuffer("RMG_mission", temp, MAX_QPATH);
+	Cvar_VariableStringBuffer("rmg_map", map, MAX_QPATH);
+	sprintf(mission, "%s_%s", temp, map);
+	Cvar_VariableStringBuffer("rmg_course", course, MAX_QPATH);
+
+	// dump existing mission, if any
+	if (mMission)
+	{
+		delete mMission;
+		mMission = NULL;
+	}
+
+	// Create a new mission file	
+	mMission = new CRMMission ( mTerrain );
+
+	// Load the mission using the arioche variables
+	if ( !mMission->Load ( mission, instances, course ) )
+	{
+		return false;
+	}
+	
+	if (mUseTimeLimit)
+	{
+		Cvar_Set("rmg_timelimit", va("%d", mMission->GetTimeLimit()));
+	}
+	else
+	{
+		Cvar_Set("rmg_timelimit", "0");
+	}
+
+	if (IsServer)
+	{	// set the names of the teams 
+		CGenericParser2		parser;
+		//CGPGroup*			root;
+
+		Cvar_VariableStringBuffer("RMG_terrain", temp, MAX_QPATH);
+
+		/*
+		// Create the parser for the mission file
+		if(Com_ParseTextFile(va("ext_data/rmg/%s.teams", temp), parser))
+		{
+			root = parser.GetBaseParseGroup()->GetSubGroups();
+			if (0 == stricmp(root->GetName(), "teams"))
+			{
+				SV_SetConfigstring( CS_GAMETYPE_REDTEAM, root->FindPairValue ( "red", "marine" ));
+				SV_SetConfigstring( CS_GAMETYPE_BLUETEAM, root->FindPairValue ( "blue", "thug" ));
+			}
+			parser.Clean();
+		}
+		*/
+		//rww - This is single player, no such thing.
+	}
+
+	// Must have a valid landscape before we can spawn the mission
+	assert ( mLandScape );
+
+#ifndef FINAL_BUILD
+	Com_Printf ("------------------------------------------\n");
+#endif
+
+	return true;
+#else
+	return false;
+#endif // PRE_RELEASE_DEMO
+}
+
+/************************************************************************************************
+ * CRMManager::IsMissionComplete
+ *	Determines whether or not all the arioche objectives have been met
+ *
+ * inputs:
+ *  none
+ *
+ * return:
+ *	true: all objectives have been completed
+ *  false: one or more of the objectives has not been met
+ *
+ ************************************************************************************************/
+bool CRMManager::IsMissionComplete(void)
+{
+	if ( NULL == mMission->GetCurrentObjective ( ) )
+	{
+		return true;
+	}
+
+	return false;
+}
+
+/************************************************************************************************
+ * CRMManager::HasTimeExpired
+ *	Determines whether or not the time limit (if one) has expired
+ *
+ * inputs:
+ *  none
+ *
+ * return:
+ *	true: time limit has expired
+ *  false: time limit has not expired
+ *
+ ************************************************************************************************/
+bool CRMManager::HasTimeExpired(void)
+{
+/*	if (mMission->GetTimeLimit() == 0 || !mUseTimeLimit)
+	{	// no time limit set
+		return false;
+	}
+
+	if (mMission->GetTimeLimit() * 1000 * 60 > level.time - level.startTime)
+	{	// we are still under our time limit
+		return false;
+	}
+
+	// over our time limit!
+	return true;*/
+
+	return false;
+}
+
+/************************************************************************************************
+ * CRMManager::UpdateStatisticCvars
+ *	Updates the statistic cvars with data from the game
+ *
+ * inputs:
+ *  none
+ *
+ * return:
+ *	none
+ *
+ ************************************************************************************************/
+void CRMManager::UpdateStatisticCvars ( void )
+{
+/*	// No player set then nothing more to do
+	if ( mPlayer )
+	{
+		float accuracy;
+
+		// Calculate the accuracy
+		accuracy  = (float)mPlayer->client->ps.persistant[PERS_SHOTS_HIT];
+		accuracy /= (float)mPlayer->client->ps.persistant[PERS_SHOTS];
+		accuracy *= 100.0f;
+		
+		// set the accuracy cvar
+		gi.Cvar_Set ( "ar_pl_accuracy", va("%d%%",(int)accuracy) );
+
+		// Set the # of kills cvar
+		gi.Cvar_Set ( "ar_kills", va("%d", mPlayer->client->ps.persistant[PERS_SCORE] ) );
+
+		int hours;
+		int mins;
+		int seconds;
+		int tens;
+		int millisec = (level.time - level.startTime);
+
+		seconds = millisec / 1000;
+		hours = seconds / (60 * 60);
+		seconds -= (hours * 60 * 60);
+		mins = seconds / 60;		
+		seconds -= mins * 60;
+		tens = seconds / 10;
+		seconds -= tens * 10;
+
+		gi.Cvar_Set ( "ar_duration", va("%dhr %dmin %dsec", hours, mins, seconds ) );
+
+		WpnID wpnID = TheWpnSysMgr().GetFavoriteWeapon ( );
+		gi.Cvar_Set ( "ar_fav_wp", CWeaponSystem::GetWpnName ( wpnID ) );
+
+		// show difficulty
+		char difficulty[MAX_QPATH];
+		gi.Cvar_VariableStringBuffer("g_skill", difficulty, MAX_QPATH);
+		strupr(difficulty);
+		gi.Cvar_Set ( "ar_diff", va("&GENERIC_%s&",difficulty) );
+
+		// compute rank
+		float compositeRank = 1;
+		int rankMax = 3;  // max rank less 1
+		float timeRank = mUseTimeLimit ? (1.0f - (mins / (float)mMission->GetTimeLimit())) : 0;
+		float killRank = mPlayer->client->ps.persistant[PERS_SCORE] / (float)GetCharacterManager().GetAllSize();
+		killRank = (killRank > 0) ? killRank : 1.0f; 
+		float accuRank = (accuracy > 0) ? accuracy*0.01f : 1.0f;	
+		float weapRank = 1.0f - CWeaponSystem::GetRank(wpnID);
+
+		compositeRank = ((timeRank + killRank + accuRank + weapRank) / 3.0f) * rankMax + 1;
+		
+		if (compositeRank > 4)
+			compositeRank = 4;
+
+		gi.Cvar_Set ( "ar_rank", va("&RMG_RANK%d&",((int)compositeRank)) );
+	}*/
+}
+
+/************************************************************************************************
+ * CRMManager::CompleteMission
+ *	Does end-of-mission stuff (pause game, end screen, return to menu)
+ *    <Description>                                                                             *
+ * Input                                                                                        *
+ *    <Variable>: <Description>                                                                 *
+ * Output / Return                                                                              *
+ *    <Variable>: <Description>                                                                 *
+ ************************************************************************************************/
+void CRMManager::CompleteMission(void)
+{
+	UpdateStatisticCvars ( );
+
+	mMission->CompleteMission();
+}
+
+/************************************************************************************************
+ * CRMManager::FailedMission
+ *	Does end-of-mission stuff (pause game, end screen, return to menu)
+ *    <Description>                                                                             *
+ * Input                                                                                        *
+ *    TimeExpired: indicates if the reason failed was because of time
+ * Output / Return                                                                              *
+ *    <Variable>: <Description>                                                                 *
+ ************************************************************************************************/
+void CRMManager::FailedMission(bool TimeExpired)
+{
+	UpdateStatisticCvars ( );
+
+	mMission->FailedMission(TimeExpired);
+}
+
+/************************************************************************************************
+ * CRMManager::CompleteObjective
+ *	Marks the given objective as completed
+ *
+ * inputs:
+ *  obj:  objective to set as completed
+ *
+ * return:
+ *	none
+ *
+ ************************************************************************************************/
+void CRMManager::CompleteObjective ( CRMObjective *obj )
+{
+	assert ( obj );
+
+	mMission->CompleteObjective ( obj );
+}
+
+/************************************************************************************************
+ * CRMManager::Preview
+ *	previews the random mission genration information
+ *
+ * inputs:
+ *  from:  origin being previed from
+ *
+ * return:
+ *	none
+ *
+ ************************************************************************************************/
+void CRMManager::Preview ( const vec3_t from )
+{
+	// Dont bother if we havent reached our timer yet
+/*	if ( level.time < mPreviewTimer )
+	{
+		return;
+	}
+
+	// Let the mission do all the previewing
+	mMission->Preview ( from );
+
+	// Another second
+	mPreviewTimer = level.time + 1000;*/
+}
+
+/************************************************************************************************
+ * CRMManager::Preview
+ *	previews the random mission genration information
+ *
+ * inputs:
+ *  from:  origin being previed from
+ *
+ * return:
+ *	none
+ *
+ ************************************************************************************************/
+bool CRMManager::SpawnMission ( qboolean IsServer )
+{
+	// Spawn the mission
+	mMission->Spawn ( mTerrain, IsServer );
+
+	return true;
+}
diff --git a/code/RMG/RM_Manager.h b/code/RMG/RM_Manager.h
new file mode 100644
index 0000000..c423a06
--- /dev/null
+++ b/code/RMG/RM_Manager.h
@@ -0,0 +1,55 @@
+#pragma once
+#if !defined(RM_MANAGER_H_INC)
+#define RM_MANAGER_H_INC
+
+#if !defined(CM_LANDSCAPE_H_INC)
+#include "../qcommon/cm_landscape.h"
+#endif
+
+class CRMManager
+{
+private:
+
+	CRMMission*			mMission;
+	CCMLandScape*		mLandScape;
+	CRandomTerrain*		mTerrain;
+	int					mPreviewTimer;
+	int					mCurPriority;
+	bool				mUseTimeLimit;
+
+	void			UpdateStatisticCvars ( void );
+
+public:
+
+	// Constructors
+	CRMManager (void);
+	~CRMManager (void);
+
+	bool			LoadMission		( qboolean IsServer );
+	bool			SpawnMission	( qboolean IsServer );
+
+	// Accessors
+	void			SetLandScape	(CCMLandScape *landscape);
+	void			SetCurPriority	(int priority) { mCurPriority = priority; }
+
+	CRandomTerrain*	GetTerrain		(void)	{ return mTerrain; }
+	CCMLandScape*	GetLandScape	(void)	{ return mLandScape; }
+	CRMMission*		GetMission		(void)  { return mMission; }
+	int				GetCurPriority	(void) { return mCurPriority; }
+
+	void			Preview			( const vec3_t from );
+
+	bool			IsMissionComplete		(void);
+	bool			HasTimeExpired			(void);
+	void			CompleteObjective		( CRMObjective *obj );
+	void			CompleteMission			(void);
+	void			FailedMission			(bool TimeExpired);
+
+	// eek
+	static CRMObjective	*mCurObjective;
+};
+
+extern CRMManager*	TheRandomMissionManager;
+
+
+#endif // RANDOMMISSION_H_INC
\ No newline at end of file
diff --git a/code/RMG/RM_Mission.cpp b/code/RMG/RM_Mission.cpp
new file mode 100644
index 0000000..193fc52
--- /dev/null
+++ b/code/RMG/RM_Mission.cpp
@@ -0,0 +1,1930 @@
+/************************************************************************************************
+ *
+ * RM_Mission.cpp
+ *
+ * implements the CRMMission class.  The CRMMission class loads and manages an arioche mission
+ *
+ ************************************************************************************************/
+
+#include "../server/exe_headers.h"
+
+#include "rm_headers.h"
+
+#define ARIOCHE_CLIPBRUSH_SIZE	300
+#define	CVAR_OBJECTIVE	0
+
+/************************************************************************************************
+ * CRMMission::CRMMission
+ *	constructor
+ *
+ * inputs:
+ *  none
+ *
+ * return:
+ *	none
+ *
+ ************************************************************************************************/
+CRMMission::CRMMission ( CRandomTerrain* landscape )
+{
+	mCurrentObjective		= NULL;
+	mValidPaths				= false;
+	mValidRivers			= false;
+	mValidNodes				= false;
+	mValidWeapons			= false;
+	mValidAmmo				= false;
+	mValidObjectives		= false;
+	mValidInstances			= false;
+	mTimeLimit				= 0;
+	mMaxInstancePosition	= 1;
+	mAccuracyMultiplier		= 1.0f;
+	mHealthMultiplier		= 1.0f;
+	mPickupHealth			= 1.0f;
+	mPickupArmor			= 1.0f;
+	mPickupAmmo				= 1.0f;
+	mPickupWeapon			= 1.0f;
+	mPickupEquipment		= 1.0f;
+	
+	mDefaultPadding = 0;
+	mSymmetric = SYMMETRY_NONE;
+
+//	mCheckedEnts.clear();
+
+	mLandScape = landscape;
+
+	// cut down the possible area that is 'legal' for area manager to use by 20%
+	vec3_t land_min, land_max;
+
+	land_min[0] = mLandScape->GetBounds ( )[0][0] + (mLandScape->GetBounds ( )[1][0]-mLandScape->GetBounds ( )[0][0]) * 0.1f;
+	land_min[1] = mLandScape->GetBounds ( )[0][1] + (mLandScape->GetBounds ( )[1][1]-mLandScape->GetBounds ( )[0][1]) * 0.1f;
+	land_min[2] = mLandScape->GetBounds ( )[0][2] + (mLandScape->GetBounds ( )[1][2]-mLandScape->GetBounds ( )[0][2]) * 0.1f;
+
+	land_max[0] = mLandScape->GetBounds ( )[1][0] - (mLandScape->GetBounds ( )[1][0]-mLandScape->GetBounds ( )[0][0]) * 0.1f;
+	land_max[1] = mLandScape->GetBounds ( )[1][1] - (mLandScape->GetBounds ( )[1][1]-mLandScape->GetBounds ( )[0][1]) * 0.1f;
+	land_max[2] = mLandScape->GetBounds ( )[1][2] - (mLandScape->GetBounds ( )[1][2]-mLandScape->GetBounds ( )[0][2]) * 0.1f;
+
+	// Create a new area manager for the landscape
+	mAreaManager = new CRMAreaManager ( land_min,
+										land_max );
+
+	// Create a new path manager
+	mPathManager = new CRMPathManager ( mLandScape );
+}
+
+/************************************************************************************************
+ * CRMMission::~CRMMission
+ *	destructor
+ *
+ * inputs:
+ *  none
+ *
+ * return:
+ *	none
+ *
+ ************************************************************************************************/
+CRMMission::~CRMMission ( )
+{
+	rmObjectiveIter_t	oit;
+	rmInstanceIter_t	iit;
+
+//	mCheckedEnts.clear();
+
+	// Cleanup the objectives
+	for (oit = mObjectives.begin(); oit != mObjectives.end(); oit++)
+	{
+		delete (*oit);
+	}
+
+	// Cleanup the instances
+	for (iit = mInstances.begin(); iit != mInstances.end(); iit++)
+	{
+		delete (*iit);
+	}
+
+	if (mPathManager)
+	{
+		delete mPathManager;
+		mPathManager = 0;
+	}
+
+	if (mAreaManager)
+	{
+		delete mAreaManager;
+		mAreaManager = 0;
+	}
+}
+
+/************************************************************************************************
+ * CRMMission::FindObjective
+ *	searches through the missions objectives for the one with the given name
+ *
+ * inputs:
+ *  name: name of objective to find
+ *
+ * return:
+ *	objective: objective matching the given name or NULL if it couldnt be found
+ *
+ ************************************************************************************************/
+CRMObjective* CRMMission::FindObjective ( const char* name )
+{
+	rmObjectiveIter_t it;
+
+	for (it = mObjectives.begin(); it != mObjectives.end(); it++)
+	{
+		// Does it match?
+		if (!stricmp ((*it)->GetName(), name ))
+		{
+			return (*it);
+		}
+	}
+
+	// Not found
+	return NULL;
+}
+
+void	CRMMission::MirrorPos(vec3_t pos)
+{
+	pos[0] = 1.0f - pos[0];
+	pos[1] = 1.0f - pos[1];
+}
+
+/************************************************************************************************
+ * CRMMission::ParseOrigin
+ *	parses an origin block which includes linking to a node and absolute origins
+ *
+ * inputs:
+ *  group: parser group containing the node or origin 
+ *
+ * return:
+ *	true: parsed successfully
+ *  false: failed to parse
+ *
+ ************************************************************************************************/
+bool CRMMission::ParseOrigin ( CGPGroup* originGroup, vec3_t origin, vec3_t lookat, int* flattenHeight )
+{
+	const char*	szNodeName;
+	vec3_t		mins;
+	vec3_t		maxs;
+
+	if ( flattenHeight )
+	{
+		*flattenHeight = 66;
+	}
+	
+	// If no group was given then use 0,0,0
+	if ( NULL == originGroup )
+	{
+		VectorCopy ( vec3_origin, origin );
+		return false;
+	}
+
+	// See if attaching to a named node
+	szNodeName = originGroup->FindPairValue ( "node", "" );
+	if ( *szNodeName )
+	{
+		CRMNode*	node;
+		// Find the node being attached to
+		node = mPathManager->FindNodeByName ( szNodeName );
+		if ( node )
+		{
+			if ( flattenHeight )
+			{
+				if ( node->GetFlattenHeight ( ) == -1 )
+				{
+					node->SetFlattenHeight ( 40 + mLandScape->irand(0,40) );
+				}
+
+				*flattenHeight = node->GetFlattenHeight ( );
+			}
+
+			VectorCopy(node->GetPos(), origin);
+
+			VectorCopy ( origin, lookat );
+
+			int dir;
+			int rnd_offset = mLandScape->irand(0, DIR_MAX-1);
+			for (dir=0; dir<DIR_MAX; dir++)
+			{
+				int d = (dir + rnd_offset) % DIR_MAX;
+				if (node->PathExist(d))
+				{
+					vec4_t tmp_pt, tmp_dir;
+					int pathID = node->GetPath(d);
+					mLandScape->GetPathInfo(pathID, 0.1f, tmp_pt, tmp_dir );
+					lookat[0] = tmp_pt[0];
+					lookat[1] = tmp_pt[1];
+					lookat[2] = 0;
+					return true;
+				}
+			}
+			return true;
+		}
+	}
+
+	mins[0] = atof( originGroup->FindPairValue ( "left", ".1" ) );
+	mins[1] = atof( originGroup->FindPairValue ( "top", ".1" ) );
+	maxs[0] = atof( originGroup->FindPairValue ( "right", ".9" ) );
+	maxs[1] = atof( originGroup->FindPairValue ( "bottom", ".9" ) );
+
+	lookat[0] = origin[0] = mLandScape->flrand(mins[0],maxs[0]);
+	lookat[1] = origin[1] = mLandScape->flrand(mins[1],maxs[1]);
+	lookat[2] = origin[2] = 0;
+
+	return true;
+}
+
+/************************************************************************************************
+ * CRMMission::ParseNodes
+ *	parses all the named nodes in the file
+ *
+ * inputs:
+ *  group: parser group containing the named nodes
+ *
+ * return:
+ *	true:  parsed successfully
+ *  false: failed to parse
+ *
+ ************************************************************************************************/
+bool CRMMission::ParseNodes ( CGPGroup* group )
+{
+	// If NULL that means this particular difficulty level has no named nodes
+	if ( NULL == group || mValidNodes)
+	{
+		return true;
+	}
+
+	// how many nodes spaced over map?
+	int			x_cells;
+	int			y_cells;
+
+	x_cells = atoi ( group->FindPairValue ( "x_cells", "3" ) );
+	y_cells = atoi ( group->FindPairValue ( "y_cells", "3" ) );
+
+	mPathManager->CreateArray(x_cells, y_cells);
+
+	// Loop through all the nodes and generate each as specified
+	for ( group = group->GetSubGroups(); 
+		  group; 
+		  group=group->GetNext() )
+	{
+		int min_depth = atof( group->FindPairValue ( "min_depth", "0" ) );
+		int max_depth = atof( group->FindPairValue ( "max_depth", "5" ) );
+		int min_paths = atoi( group->FindPairValue ( "min_paths", "1" ) );
+		int max_paths = atoi( group->FindPairValue ( "max_paths", "1" ) );		
+
+		mPathManager->CreateLocation( group->GetName(), min_depth, max_depth, min_paths, max_paths );
+	}
+
+	mValidNodes = true;
+	return true;
+}
+
+/************************************************************************************************
+ * CRMMission::ParsePaths
+ *	parses all path styles in the file and then generates paths
+ *
+ * inputs:
+ *  group: parser group containing the list of path styles
+ *
+ * return:
+ *	true:  parsed successfully
+ *  false: failed to parse
+ *
+ ************************************************************************************************/
+bool CRMMission::ParsePaths ( CGPGroup* group )
+{
+	// If NULL that means this particular difficulty level has no paths
+	if ( NULL == group || mValidPaths)
+	{
+		return true;
+	}
+
+	// path style info
+	float		depth;
+	float		deviation;
+	float		breadth;
+	float		minwidth;
+	float		maxwidth;
+	int			points;
+
+	points    = atoi ( group->FindPairValue ( "points", "10" ) );
+	depth     = atof ( group->FindPairValue ( "depth", ".31" ) );
+	deviation = atof ( group->FindPairValue ( "deviation", ".025" ) );
+	breadth   = atof ( group->FindPairValue ( "breadth", "5" ) );
+	minwidth  = atof ( group->FindPairValue ( "minwidth", ".03" ) );
+	maxwidth  = atof ( group->FindPairValue ( "maxwidth", ".05" ) );
+
+	mPathManager->SetPathStyle( points, minwidth, maxwidth, depth, deviation, breadth);
+
+	if (!mValidPaths)
+	{	// we must create paths
+		mPathManager->GeneratePaths( mSymmetric );
+		mValidPaths = true;
+	}
+
+	return true;
+}
+
+/************************************************************************************************
+ * CRMMission::ParseRivers
+ *	parses all river styles in the file and then generates rivers
+ *
+ * inputs:
+ *  group: parser group containing the list of path styles
+ *
+ * return:
+ *	true:  parsed successfully
+ *  false: failed to parse
+ *
+ ************************************************************************************************/
+bool CRMMission::ParseRivers ( CGPGroup* group )
+{
+	// If NULL that means this particular difficulty level has no rivers
+	if ( NULL == group || mValidRivers)
+	{
+		return true;
+	}
+
+	// river style info
+	int			maxdepth;
+	float		beddepth;
+	float		deviation;
+	float		breadth;
+	float		minwidth;
+	float		maxwidth;
+	int			points;
+	string		bridge_name;
+
+	maxdepth  = atoi ( group->FindPairValue ( "maxpathdepth", "5" ) );
+	points    = atoi ( group->FindPairValue ( "points", "10" ) );
+	beddepth  = atof ( group->FindPairValue ( "depth", "1" ) );
+	deviation = atof ( group->FindPairValue ( "deviation", ".03" ) );
+	breadth   = atof ( group->FindPairValue ( "breadth", "7" ) );
+	minwidth  = atof ( group->FindPairValue ( "minwidth", ".01" ) );
+	maxwidth  = atof ( group->FindPairValue ( "maxwidth", ".03" ) );
+	bridge_name= group->FindPairValue ( "bridge", "" ) ;
+
+	mPathManager->SetRiverStyle( maxdepth, points, minwidth, maxwidth, beddepth, deviation, breadth, bridge_name);
+
+	if (!mValidRivers && 
+		beddepth < 1)						// use a depth of 1 if we don't want any rivers
+	{	// we must create rivers
+		mPathManager->GenerateRivers();
+		mValidRivers = true;
+	}
+
+	return true;
+}
+
+void CRMMission::PlaceBridges()
+{
+	if (!mValidRivers || strlen(mPathManager->GetBridgeName()) < 1)
+		return;
+
+	int		max_bridges = 0;
+	int		path;
+	float	t;
+	float	river_depth = mLandScape->GetLandScape()->GetWaterHeight();
+	vec3_t	pos, lastpos;
+	vec3pair_t bounds;
+	VectorSet(bounds[0], 0,0,0);
+	VectorSet(bounds[1], 0,0,0);
+
+	// walk along paths looking for dips
+	for (path = 0; path < mPathManager->GetPathCount(); path++)
+	{
+		vec4_t tmp_pt, tmp_dir;
+		bool	new_water = true;
+
+		mLandScape->GetPathInfo(path, 0, tmp_pt, tmp_dir );
+		lastpos[0] = mLandScape->GetBounds ( )[0][0] + (mLandScape->GetBounds ( )[1][0]-mLandScape->GetBounds ( )[0][0]) * tmp_pt[0];
+		lastpos[1] = mLandScape->GetBounds ( )[0][1] + (mLandScape->GetBounds ( )[1][1]-mLandScape->GetBounds ( )[0][1]) * tmp_pt[1];
+		lastpos[2] = mLandScape->GetBounds ( )[0][2] + (mLandScape->GetBounds ( )[1][2]-mLandScape->GetBounds ( )[0][2]) * tmp_pt[2];
+		mLandScape->GetLandScape()->GetWorldHeight ( lastpos, bounds, true );
+
+		const float delta = 0.05f;
+		for (t= delta; t < 1.0f; t += delta)
+		{
+			mLandScape->GetPathInfo(path, t, tmp_pt, tmp_dir );
+			pos[0] = mLandScape->GetBounds ( )[0][0] + (mLandScape->GetBounds ( )[1][0]-mLandScape->GetBounds ( )[0][0]) * tmp_pt[0];
+			pos[1] = mLandScape->GetBounds ( )[0][1] + (mLandScape->GetBounds ( )[1][1]-mLandScape->GetBounds ( )[0][1]) * tmp_pt[1];
+			pos[2] = mLandScape->GetBounds ( )[0][2] + (mLandScape->GetBounds ( )[1][2]-mLandScape->GetBounds ( )[0][2]) * tmp_pt[2];
+			mLandScape->GetLandScape()->GetWorldHeight ( pos, bounds, true );
+
+			if (new_water && 
+				lastpos[2] < river_depth && 
+				pos[2] < river_depth && 
+				pos[2] > lastpos[2])
+			{	// add a bridge
+				if (max_bridges < 3)
+				{
+					CRMArea*		area;
+					CRMInstance*	instance;
+
+					max_bridges++;
+
+					// create a single bridge
+					lastpos[2] = mLandScape->GetBounds ( )[0][2] + (mLandScape->GetBounds ( )[1][2]-mLandScape->GetBounds ( )[0][2]) * mPathManager->GetPathDepth();
+					instance = mInstanceFile.CreateInstance ( mPathManager->GetBridgeName() );
+
+					if ( NULL != instance )
+					{	// Set the area 
+						vec3_t zerodvec;
+						VectorClear(zerodvec);
+						area = mAreaManager->CreateArea ( lastpos, instance->GetSpacingRadius(), instance->GetSpacingLine(), GetDefaultPadding(), 0, zerodvec, pos, instance->GetFlattenRadius()?true:false, false, instance->GetLockOrigin() );
+						area->EnableLookAt(false);
+
+						instance->SetArea ( mAreaManager, area );
+						mInstances.push_back ( instance );
+						new_water = false;
+					}
+				}
+			}
+			else if (pos[2] > river_depth)
+			{	// hit land again
+				new_water = true;
+			}
+			VectorCopy ( pos, lastpos );
+		}
+	}
+}
+
+void CRMMission::PlaceWallInstance(CRMInstance*	instance, float xpos, float ypos, float zpos, int x, int y, float angle)
+{
+	if (NULL == instance)
+		return;
+
+	float spacing = instance->GetSpacingRadius();
+	CRMArea*		area;
+	vec3_t			origin;
+	vec3_t zerodvec;
+	VectorClear(zerodvec);
+
+	origin[0] = xpos + spacing * x;
+	origin[1] = ypos + spacing * y;
+	origin[2] = zpos;
+
+	// Set the area of position
+	area = mAreaManager->CreateArea ( origin, (spacing / 2.1f), 0, GetDefaultPadding(), 0, zerodvec, origin, instance->GetFlattenRadius()?true:false, false, instance->GetLockOrigin() );
+	area->EnableLookAt(false);
+	area->SetAngle(angle);
+	instance->SetArea ( mAreaManager, area );
+
+	mInstances.push_back ( instance );
+}
+
+
+/************************************************************************************************
+ * CRMMission::ParseWallRect
+ *	creates instances for walled rectangle at this node (fence)
+ *
+ * inputs:
+ *  group: parser group containing the wall rect info
+ *
+ * return:
+ *	true:  parsed successfully
+ *  false: failed to parse
+ *
+ ************************************************************************************************/
+bool CRMMission::ParseWallRect(CGPGroup* group , int side)
+{
+#ifndef PRE_RELEASE_DEMO
+	CGPGroup* wallGroup = group->FindSubGroup ( "wallrect" ) ;
+
+	// If NULL that means this particular instance has no wall rect
+	if ( NULL == group || NULL == wallGroup)
+	{
+		return true;
+	}
+
+	const char* wallName = wallGroup->FindPairValue ( "wall_instance", "" );
+	const char* cornerName = wallGroup->FindPairValue ( "corner_instance", "" );
+	const char* towerName = wallGroup->FindPairValue ( "tower_instance", "" );
+	const char* gateName = wallGroup->FindPairValue ( "gate_instance", "" );
+	const char* ripName = wallGroup->FindPairValue ( "rip_instance", "" );
+
+	if ( NULL != wallName )
+	{
+		int xcount = atoi( wallGroup->FindPairValue ( "xcount", "0" ) );
+		int ycount = atoi( wallGroup->FindPairValue ( "ycount", "0" ) );
+
+		int gateCount = atoi( wallGroup->FindPairValue ( "gate_count", "1" ) );
+		int gateMin = atoi( wallGroup->FindPairValue ( "gate_min", "0" ) );
+		int gateMax = atoi( wallGroup->FindPairValue ( "gate_max", "0" ) );
+
+		int ripCount = atoi( wallGroup->FindPairValue ( "rip_count", "0" ) );
+		int ripMin = atoi( wallGroup->FindPairValue ( "rip_min", "0" ) );
+		int ripMax = atoi( wallGroup->FindPairValue ( "rip_max", "0" ) );
+
+		int towerCount = atoi( wallGroup->FindPairValue ( "tower_count", "0" ) );
+		int towerMin = atoi( wallGroup->FindPairValue ( "tower_min", "0" ) );
+		int towerMax = atoi( wallGroup->FindPairValue ( "tower_max", "0" ) );
+
+		if (gateMin != gateMax)
+			gateCount = mLandScape->irand(gateMin,gateMax);
+
+		if (ripMin != ripMax)
+			ripCount = mLandScape->irand(ripMin,ripMax);
+
+		if (towerMin != towerMax)
+			towerCount = mLandScape->irand(towerMin,towerMax);
+
+		if (NULL == gateName)
+			gateCount = 0;
+
+		if (NULL == towerName)
+			towerCount = 0;
+
+		if (NULL == ripName)
+			ripCount = 0;
+
+		const char*		nodename;
+		CGPGroup* originGroup = group->FindSubGroup ( "origin" );
+		if (originGroup)
+		{
+			nodename = originGroup->FindPairValue ( "node", "" );
+			if (*nodename)
+			{
+				CRMNode*	node;
+				// Find the node being attached to
+				node = mPathManager->FindNodeByName ( nodename );
+				if ( node )
+				{
+					CRMInstance*	instance;
+					int x,y;
+					int halfx = xcount/2;
+					int halfy = ycount/2;
+					float xpos = mLandScape->GetBounds ( )[0][0] + (mLandScape->GetBounds ( )[1][0]-mLandScape->GetBounds ( )[0][0]) * node->GetPos()[0];
+					float ypos = mLandScape->GetBounds ( )[0][1] + (mLandScape->GetBounds ( )[1][1]-mLandScape->GetBounds ( )[0][1]) * node->GetPos()[1];
+					float zpos = mLandScape->GetBounds ( )[1][2] + 100;
+					float angle = 0;
+					int  lastGate = 0;
+					int  lastRip = 0;
+
+					// corners
+					x = -halfx;
+					y = -halfy;
+					if (towerCount > 3 || 
+  					    (towerCount > 0 && mLandScape->irand(1,2) == 1) )
+					{
+						towerCount--;
+						instance = mInstanceFile.CreateInstance ( towerName );
+					}
+					else
+						instance = mInstanceFile.CreateInstance ( cornerName );
+					angle = (float)DEG2RAD(90);
+					instance->SetSide(side);
+					PlaceWallInstance(instance, xpos, ypos, zpos, x, y, angle);
+
+					x = halfx;
+					y = -halfy;
+					if (towerCount > 3 || 
+  					    (towerCount > 0 && mLandScape->irand(1,2) == 1) )
+					{
+						towerCount--;
+						instance = mInstanceFile.CreateInstance ( towerName );
+					}
+					else
+						instance = mInstanceFile.CreateInstance ( cornerName );
+					angle = (float)DEG2RAD(180);
+					instance->SetSide(side);
+					PlaceWallInstance(instance, xpos, ypos, zpos, x, y, angle);
+
+					x = halfx;
+					y = halfy;
+					if (towerCount > 3 || 
+  					    (towerCount > 0 && mLandScape->irand(1,2) == 1) )
+					{
+						towerCount--;
+						instance = mInstanceFile.CreateInstance ( towerName );
+					}
+					else
+						instance = mInstanceFile.CreateInstance ( cornerName );
+					angle = (float)DEG2RAD(270);
+					instance->SetSide(side);
+					PlaceWallInstance(instance, xpos, ypos, zpos, x, y, angle);
+
+					x = -halfx;
+					y = halfy;
+					if (towerCount > 3 || 
+  					    (towerCount > 0 && mLandScape->irand(1,2) == 1) )
+					{
+						towerCount--;
+						instance = mInstanceFile.CreateInstance ( towerName );
+					}
+					else
+						instance = mInstanceFile.CreateInstance ( cornerName );
+					angle = DEG2RAD(0);
+					instance->SetSide(side);
+					PlaceWallInstance(instance, xpos, ypos, zpos, x, y, angle);
+
+					// walls
+					angle = DEG2RAD(0);
+					for (x = -halfx+1; x <= halfx-1; x++)
+					{
+						if (lastGate<1 && gateCount > 0 && mLandScape->irand(1,(halfx+halfy)/gateCount) == 1)
+						{	// gate
+							gateCount--;
+							lastGate = 3;
+							instance = mInstanceFile.CreateInstance ( gateName );
+						}
+						else if (lastRip<1 && ripCount > 0 && mLandScape->irand(1,(halfx+halfy)/ripCount) == 1)
+						{	// damaged fence
+							ripCount--;
+							lastRip = 3;
+							instance = mInstanceFile.CreateInstance ( ripName );
+						}
+						else
+						{   // just a wall
+							instance = mInstanceFile.CreateInstance ( wallName );
+							lastRip--;
+							lastGate--;
+						}
+						instance->SetSide(side);
+						PlaceWallInstance(instance, xpos, ypos, zpos, x, -halfy, angle);
+					}
+					for (x = -halfx+1; x <= halfx-1; x++)
+					{
+						if (lastGate<1 && gateCount > 0 && mLandScape->irand(1,(halfx+halfy)/gateCount) == 1)
+						{	// gate
+							gateCount--;
+							lastGate = 3;
+							instance = mInstanceFile.CreateInstance ( gateName );
+						}
+						else if (lastRip<1 && ripCount > 0 && mLandScape->irand(1,(halfx+halfy)/ripCount) == 1)
+						{	// damaged fence
+							ripCount--;
+							lastRip = 3;
+							instance = mInstanceFile.CreateInstance ( ripName );
+						}
+						else
+						{   // just a wall
+							instance = mInstanceFile.CreateInstance ( wallName );
+							lastRip--;
+							lastGate--;
+						}
+						instance->SetSide(side);
+						PlaceWallInstance(instance, xpos, ypos, zpos, x, halfy, angle);
+					}
+
+					angle = (float)DEG2RAD(90);
+					for (y = -halfy+1; y <= halfy-1; y++)
+					{
+						if (lastGate<1 && gateCount > 0 && mLandScape->irand(1,(halfx+halfy)/gateCount) == 1)
+						{	// gate
+							gateCount--;
+							lastGate = 3;
+							instance = mInstanceFile.CreateInstance ( gateName );
+						}
+						else if (lastRip<1 && ripCount > 0 && mLandScape->irand(1,(halfx+halfy)/ripCount) == 1)
+						{	// damaged fence
+							ripCount--;
+							lastRip = 3;
+							instance = mInstanceFile.CreateInstance ( ripName );
+						}
+						else
+						{   // just a wall
+							instance = mInstanceFile.CreateInstance ( wallName );
+							lastRip--;
+							lastGate--;
+						}
+						instance->SetSide(side);
+						PlaceWallInstance(instance, xpos, ypos, zpos, -halfx, y, angle);
+					}
+					for (y = -halfy+1; y <= halfy-1; y++)
+					{
+						if (lastGate<1 && gateCount > 0 && mLandScape->irand(1,(halfx+halfy)/gateCount) == 1)
+						{	// gate
+							gateCount--;
+							lastGate = 3;
+							instance = mInstanceFile.CreateInstance ( gateName );
+						}
+						else if (lastRip<1 && ripCount > 0 && mLandScape->irand(1,(halfx+halfy)/ripCount) == 1)
+						{	// damaged fence
+							ripCount--;
+							lastRip = 3;
+							instance = mInstanceFile.CreateInstance ( ripName );
+						}
+						else
+						{   // just a wall
+							instance = mInstanceFile.CreateInstance ( wallName );
+							lastRip--;
+							lastGate--;
+						}
+						instance->SetSide(side);
+						PlaceWallInstance(instance, xpos, ypos, zpos, halfx, y, angle);
+					}
+				}
+			}
+		}
+	}			
+	else
+		return false;
+#endif // #ifndef PRE_RELEASE_DEMO
+
+	return true;
+}
+
+
+/************************************************************************************************
+ * CRMMission::ParseInstancesOnPath
+ *	creates instances on path between nodes
+ *
+ * inputs:
+ *  group: parser group containing the defenses, other instances on the path between nodes
+ *
+ * return:
+ *	true:  parsed successfully
+ *  false: failed to parse
+ *
+ ************************************************************************************************/
+bool CRMMission::ParseInstancesOnPath ( CGPGroup* group )
+{
+#ifndef PRE_RELEASE_DEMO
+	CGPGroup* defenseGroup;
+	for ( defenseGroup = group->GetSubGroups(); 
+		  defenseGroup; 
+		  defenseGroup=defenseGroup->GetNext() )
+	if (stricmp ( defenseGroup->GetName ( ), "defenses" )==0 ||
+		stricmp ( defenseGroup->GetName(), "instanceonpath")==0)
+	{
+		const char* defName = defenseGroup->FindPairValue ( "instance", "" );
+		if ( *defName )
+		{
+			float	minpos;
+			float	maxpos;
+			int		mincount;
+			int		maxcount;
+
+			// how far along path does this get placed?
+			minpos = atof( defenseGroup->FindPairValue ( "minposition", "0.5" ) );
+			maxpos = atof( defenseGroup->FindPairValue ( "maxposition", "0.5" ) );
+			mincount = atoi( defenseGroup->FindPairValue ( "mincount", "1" ) );
+			maxcount = atoi( defenseGroup->FindPairValue ( "maxcount", "1" ) );
+
+			const char*		nodename;
+			CGPGroup* originGroup = group->FindSubGroup ( "origin" );
+			if (originGroup)
+			{
+				nodename = originGroup->FindPairValue ( "node", "" );
+				if (*nodename)
+				{
+					CRMNode*	node;
+					// Find the node being attached to
+					node = mPathManager->FindNodeByName ( nodename );
+					if ( node )
+					{
+						int dir;
+						// look at each connection from this node to others, if there is a path, create a defense
+						for (dir=0; dir<DIR_MAX; dir++)
+						{
+							if (node->PathExist(dir))
+							{	// path leads out of this node
+								CRMArea*		area;
+								CRMInstance*	instance;
+								float			spacing;
+								vec3_t			origin;
+								vec3_t			lookat;
+								vec4_t			tmp_pt, tmp_dir;
+								int				n,num_insts = mLandScape->irand(mincount,maxcount);
+								int				pathID = node->GetPath(dir);
+
+								if (0 == num_insts)
+									continue;
+
+								float posdelta = (maxpos - minpos) / num_insts;
+
+								for (n=0; n<num_insts; n++)
+								{
+
+									instance = mInstanceFile.CreateInstance ( defName );
+									// Failed to create, not good
+									if ( NULL == instance )
+									{
+										continue; 
+									}
+									// If a spacing radius was specified then override the one thats
+									// in the instance
+									spacing = atof( defenseGroup->FindPairValue ( "spacing", "0" ) );
+									if ( spacing )
+									{
+										instance->SetSpacingRadius ( spacing );
+									}
+
+									instance->SetFilter(group->FindPairValue("filter", ""));
+									instance->SetTeamFilter(group->FindPairValue("teamfilter", ""));
+
+									if (strstr(instance->GetTeamFilter(),"red"))
+										instance->SetSide(SIDE_RED);
+									else if (strstr(instance->GetTeamFilter(),"blue"))
+										instance->SetSide(SIDE_BLUE);
+
+									float pos_along_path = mLandScape->flrand(minpos + posdelta*n, minpos + posdelta*(n+1));
+									float look_along_path = atof( defenseGroup->FindPairValue ( "pathalign", "1" ) ) ;
+									mLandScape->GetPathInfo (pathID, pos_along_path, tmp_pt, tmp_dir );
+									origin[0] = tmp_pt[0];
+									origin[1] = tmp_pt[1];
+
+									mLandScape->GetPathInfo (pathID, look_along_path, tmp_dir, tmp_pt );
+									lookat[0] = tmp_pt[0];
+									lookat[1] = tmp_pt[1];
+
+									origin[0] = mLandScape->GetBounds ( )[0][0] + (mLandScape->GetBounds ( )[1][0]-mLandScape->GetBounds ( )[0][0]) * origin[0];
+									origin[1] = mLandScape->GetBounds ( )[0][1] + (mLandScape->GetBounds ( )[1][1]-mLandScape->GetBounds ( )[0][1]) * origin[1];
+									origin[2] = mLandScape->GetBounds ( )[0][2] ;
+
+									// look at a point along the path at this location
+									lookat[0] = mLandScape->GetBounds ( )[0][0] + (mLandScape->GetBounds ( )[1][0]-mLandScape->GetBounds ( )[0][0]) * lookat[0];
+									lookat[1] = mLandScape->GetBounds ( )[0][1] + (mLandScape->GetBounds ( )[1][1]-mLandScape->GetBounds ( )[0][1]) * lookat[1];
+									lookat[2] = 0;
+
+									// Fixed height?  (used for bridges)
+									if ( !atoi(group->FindPairValue ( "nodrop", "0" )) )
+									{
+										origin[2] = mLandScape->GetBounds ( )[1][2] + 100;
+									}
+					
+									// Set the area of position
+									area = mAreaManager->CreateArea ( origin, instance->GetSpacingRadius(), instance->GetSpacingLine(), GetDefaultPadding(), 0, origin, lookat, instance->GetFlattenRadius()?true:false, true, instance->GetLockOrigin(), mSymmetric );
+									area->EnableLookAt(false);
+
+									if ( node->GetFlattenHeight ( ) == -1 )
+									{
+										node->SetFlattenHeight ( 66 + mLandScape->irand(0,40) );
+									}
+									instance->SetFlattenHeight ( node->GetFlattenHeight ( ) );
+
+									instance->SetArea ( mAreaManager, area );
+
+									mInstances.push_back ( instance );
+								}
+							}
+						}
+					}
+				}
+			}
+			else
+				return false;
+		}			
+		else
+			return false;
+
+	}
+#endif // #ifndef PRE_RELEASE_DEMO
+
+	return true;
+}
+
+/************************************************************************************************
+ * CRMMission::ParseInstance
+ *	Parses an individual instance
+ *
+ * inputs:
+ *  group: parser group containing the list of instances
+ *
+ * return:
+ *	true: instances parsed successfully
+ *  false: instances failed to parse
+ *
+ ************************************************************************************************/
+bool CRMMission::ParseInstance ( CGPGroup* group )
+{
+	CRMArea*		area;
+	CRMInstance*	instance;
+	float			spacing;
+	vec3_t			origin;
+	vec3_t			lookat;
+	int				flattenHeight;
+	vec3_t			zerodvec;
+
+	VectorClear(zerodvec);
+
+	// create fences / walls 
+
+	// Create the instance using the instance file helper class
+	instance = mInstanceFile.CreateInstance ( group->GetName ( ) );
+
+	// Failed to create, not good
+	if ( NULL == instance )
+	{
+		return false;
+	}
+
+	// If a spacing radius was specified then override the one thats
+	// in the instance
+	spacing = atof( group->FindPairValue ( "spacing", "0" ) );
+	if ( spacing )
+	{
+		instance->SetSpacingRadius ( spacing );
+	}
+
+	instance->SetFilter(group->FindPairValue("filter", ""));
+	instance->SetTeamFilter(group->FindPairValue("teamfilter", ""));
+
+	if (strstr(instance->GetTeamFilter(),"red"))
+		instance->SetSide( SIDE_RED);
+	else if (strstr(instance->GetTeamFilter(),"blue"))
+		instance->SetSide( SIDE_BLUE );
+
+//	ParseWallRect(group, instance->GetSide());
+
+	// Get its origin now
+	ParseOrigin ( group->FindSubGroup ( "origin" ), origin, lookat, &flattenHeight );
+	origin[0] = mLandScape->GetBounds ( )[0][0] + (mLandScape->GetBounds ( )[1][0]-mLandScape->GetBounds ( )[0][0]) * origin[0];
+	origin[1] = mLandScape->GetBounds ( )[0][1] + (mLandScape->GetBounds ( )[1][1]-mLandScape->GetBounds ( )[0][1]) * origin[1];
+	origin[2] = mLandScape->GetBounds ( )[0][2] + (mLandScape->GetBounds ( )[1][2]-mLandScape->GetBounds ( )[0][2]) * origin[2];
+
+	lookat[0] = mLandScape->GetBounds ( )[0][0] + (mLandScape->GetBounds ( )[1][0]-mLandScape->GetBounds ( )[0][0]) * lookat[0];
+	lookat[1] = mLandScape->GetBounds ( )[0][1] + (mLandScape->GetBounds ( )[1][1]-mLandScape->GetBounds ( )[0][1]) * lookat[1];
+	lookat[2] = mLandScape->GetBounds ( )[0][2] + (mLandScape->GetBounds ( )[1][2]-mLandScape->GetBounds ( )[0][2]) * lookat[2];
+
+	// Fixed height?  (used for bridges)
+	if ( !atoi(group->FindPairValue ( "nodrop", "0" )) )
+	{
+		origin[2] = mLandScape->GetBounds ( )[1][2] + 100;
+	}
+
+	// Set the area of position
+	area = mAreaManager->CreateArea ( origin, instance->GetSpacingRadius(), instance->GetSpacingLine(), GetDefaultPadding(), 0, zerodvec, lookat, instance->GetFlattenRadius()?true:false, true, instance->GetLockOrigin(), mSymmetric );
+	instance->SetArea ( mAreaManager, area );
+	instance->SetFlattenHeight ( flattenHeight );
+
+	mInstances.push_back ( instance );
+
+	// create defenses?
+	ParseInstancesOnPath(group );
+
+	return true;
+}
+
+
+/************************************************************************************************
+ * CRMMission::ParseInstances
+ *	parses all instances within the mission and populates the instance list
+ *
+ * inputs:
+ *  group: parser group containing the list of instances
+ *
+ * return:
+ *	true: instances parsed successfully
+ *  false: instances failed to parse
+ *
+ ************************************************************************************************/
+bool CRMMission::ParseInstances ( CGPGroup* group )
+{
+#ifndef PRE_RELEASE_DEMO
+	// If NULL that means this particular difficulty level has no instances
+	if ( NULL == group )
+	{
+		return true;
+	}
+
+	// Loop through all the instances in the mission and add each 
+	// to the master list of instances
+	for ( group = group->GetSubGroups(); 
+		  group; 
+		  group=group->GetNext() )
+	{
+		ParseInstance ( group );
+	}
+#endif // #ifndef PRE_RELEASE_DEMO
+
+	return true;
+}
+
+/************************************************************************************************
+ * CRMMission::ParseObjectives
+ *	parses all objectives within the mission and populates the objective list
+ *
+ * inputs:
+ *  group: parser group containing the list of objectives
+ *
+ * return:
+ *	true: objectives parsed successfully
+ *  false: objectives failed to parse
+ *
+ ************************************************************************************************/
+bool CRMMission::ParseObjectives ( CGPGroup* group )
+{
+	// If NULL that means this particular difficulty level has no objectives
+	if ( NULL == group )
+	{
+		return true;
+	}
+
+	// Loop through all the objectives in the mission and add each
+	// to the master list of objectives
+	for ( group = group->GetSubGroups(); 
+		  group; 
+		  group=group->GetNext() )
+	{
+		CRMObjective* objective;
+
+		// Create the new objective
+		objective = new CRMObjective ( group );
+
+		mObjectives.push_back ( objective );
+	}
+
+	mValidObjectives = true;
+	
+	return true;
+}
+
+/************************************************************************************************
+ * CRMMission::ParseAmmo
+ *	parses the given ammo list and sets the necessary ammo cvars to grant those 
+ *  weapons to the players
+ *
+ * inputs:
+ *  ammos: parser group containing the ammo list
+ *
+ * return:
+ *	true: ammo parsed successfully
+ *  false: ammo failed to parse
+ *
+ ************************************************************************************************/
+bool CRMMission::ParseAmmo ( CGPGroup* ammos )
+{
+/*	CGPValue* ammo;
+
+	// No weapons, no success
+	if ( NULL == ammos )
+	{
+		return false;
+	}
+
+	if (0 == gi.Cvar_VariableIntegerValue("ar_wpnselect"))
+	{
+		// Make sure the ammo cvars are all reset so ammo from the last map or 
+		// another difficulty level wont carry over
+		CWeaponSystem::ClearAmmoCvars (TheWpnSysHelper());
+
+		ammo = ammos->GetPairs ( );
+
+		// Loop through the weapons listed and grant them to the player
+		while ( ammo )
+		{	
+			// Grab the weapons ID
+			AmmoID id = CWeaponSystem::GetAmmoID ( ammo->GetName ( ) );
+
+			// Now set the weapon cvar with the given data
+			TheWpnSysHelper().CvarSet ( CWeaponSystem::GetAmmoCvar ( id ), ammo->GetTopValue ( ), CVAR_AMMO );	
+
+			// Move on to the next weapon
+			ammo = (CGPValue*)ammo->GetNext();
+		}
+	}
+*/
+	mValidAmmo = true;
+
+	return true;
+}
+
+/************************************************************************************************
+ * CRMMission::ParseWeapons
+ *	parses the given weapon list and sets the necessary weapon cvars to grant those 
+ *  weapons to the players
+ *
+ * inputs:
+ *  weapons: parser group containing the weapons list
+ *
+ * return:
+ *	true: weapons parsed successfully
+ *  false: weapons failed to parse
+ *
+ ************************************************************************************************/
+bool CRMMission::ParseWeapons ( CGPGroup* weapons )
+{
+/*	CGPValue*	weapon;
+	WpnID		id;
+
+	// No weapons, no success
+	if ( NULL == weapons )
+	{
+		return false;
+	}
+
+	if (0 == gi.Cvar_VariableIntegerValue("ar_wpnselect"))
+	{
+		// Make sure the weapon cvars are all reset so weapons from the last map or 
+		// another difficulty level wont carry over
+		CWeaponSystem::ClearWpnCvars (TheWpnSysHelper());
+
+		id     = NULL_WpnID;
+		weapon = weapons->GetPairs ( );
+
+		// Loop through the weapons listed and grant them to the player
+		while ( weapon )
+		{	
+			// Grab the weapons ID
+			id = CWeaponSystem::GetWpnID ( weapon->GetName ( ) );
+
+			// Now set the weapon cvar with the given data
+			TheWpnSysHelper().CvarSet ( CWeaponSystem::GetWpnCvar ( id ), weapon->GetTopValue ( ) );	
+
+			// Move on to the next weapon
+			weapon = (CGPValue*)weapon->GetNext();
+		}
+
+		// If we found at least one weapon then ready the last one in the list
+		if ( NULL_WpnID != id )
+		{
+			TheWpnSysHelper().CvarSet("wp_righthand", va("%i/%i/0/0",id,CWeaponSystem::GetClipSize ( id )), CVAR_MISC );
+		}
+	}
+*/
+	mValidWeapons = true;
+
+	return true;
+}
+
+/************************************************************************************************
+ * CRMMission::ParseOutfit
+ *	parses the outfit (weapons and ammo)
+ *
+ * inputs:
+ *  outfit: parser group containing the outfit
+ *
+ * return:
+ *	true: weapons and ammo parsed successfully
+ *  false: failed to parse
+ *
+ ************************************************************************************************/
+bool CRMMission::ParseOutfit ( CGPGroup* outfit )
+{
+	if ( NULL == outfit )
+	{
+		return false;
+	}
+
+/*	// Its ok to fail parsing weapons as long as weapons have
+	// already been parsed at some point
+	if ( !ParseWeapons ( ParseRandom ( outfit->FindSubGroup ( "weapons" ) ) ) )
+	{
+		if ( !mValidWeapons )
+		{
+			return false;
+		}
+	}
+
+	// Its ok to fail parsing ammo as long as ammo have
+	// already been parsed at some point
+	if ( !ParseAmmo ( ParseRandom ( outfit->FindSubGroup ( "ammo" ) ) ) )
+	{
+		if ( !mValidAmmo)
+		{
+			return false;
+		}
+	}
+*/
+	return true;
+}
+
+/************************************************************************************************
+ * CRMMission::ParseRandom
+ *	selects a random sub group with from all within this one
+ *
+ * inputs:
+ *  random: parser group containing the various subgroups
+ *
+ * return:
+ *	true:  parsed successfuly
+ *  false: failed to parse
+ *
+ ************************************************************************************************/
+CGPGroup* CRMMission::ParseRandom ( CGPGroup* randomGroup )
+{
+	if (NULL == randomGroup)
+		return NULL;
+
+	CGPGroup* group;
+	CGPGroup* groups[MAX_RANDOM_CHOICES];
+	int		  numGroups;
+
+	// Build a list of the groups one can be chosen
+	for ( numGroups = 0, group = randomGroup->GetSubGroups ( ); 
+		  group; 
+		  group = group->GetNext ( ) )
+	{
+		if ( stricmp ( group->GetName ( ), "random_choice" ) )
+		{
+			continue;
+		}
+
+		int weight = atoi ( group->FindPairValue ( "random_weight", "1" ) );
+		while (weight-- > 0)
+			groups[numGroups++] = group;
+		assert (numGroups <= MAX_RANDOM_CHOICES);
+	}
+
+	// No groups!
+	if ( !numGroups )
+	{
+		return randomGroup;
+	}
+
+	// Now choose a group to parse
+	return groups[mLandScape->irand(0,numGroups-1)];
+}
+
+/************************************************************************************************
+ * CRMMission::ParseDifficulty
+ *	parses the given difficulty and populates the mission with its data
+ *
+ * inputs:
+ *  difficulty: parser group containing the difficulties info
+ *
+ * return:
+ *	true: difficulty parsed successfully
+ *  false: difficulty failed to parse
+ *
+ ************************************************************************************************/
+bool CRMMission::ParseDifficulty ( CGPGroup* difficulty, CGPGroup *parent )
+{
+	// If a null difficulty then stop the recursion.  Make sure to
+	// return true here so the parsing doesnt fail
+	if ( NULL == difficulty )
+	{
+		return true;
+	}
+
+	if (difficulty->GetParent())
+	{
+		parent = difficulty->GetParent();
+	}
+
+	// is map supposed to be symmetric?
+	mSymmetric = (symmetry_t)atoi(parent->FindPairValue ( "symmetric", "0" ));
+	mBackUpPath = atoi(parent->FindPairValue ( "backuppath", "0" ));
+	if( mSymmetric )
+	{// pick between the 2 starting corners -- yes this is a hack
+		mSymmetric = SYMMETRY_TOPLEFT;
+		if( TheRandomMissionManager->GetLandScape()->irand(0, 1) )
+		{
+			mSymmetric = SYMMETRY_BOTTOMRIGHT;
+		}
+	}
+	
+	mDefaultPadding = atoi(parent->FindPairValue ( "padding", "0" ));
+		
+	// Parse the nodes
+	if ( !ParseNodes (  ParseRandom ( difficulty->FindSubGroup ( "nodes" ) ) ) )
+	{
+		return false;
+	}
+
+	// Parse the paths
+	if ( !ParsePaths (  ParseRandom ( difficulty->FindSubGroup ( "paths" ) ) ) )
+	{
+		return false;
+	}
+
+	// Parse the rivers 
+	if ( !ParseRivers (  ParseRandom ( difficulty->FindSubGroup ( "rivers" ) ) ) )
+	{
+		return false;
+	}
+
+	// Handle inherited properties
+	if ( !ParseDifficulty ( parent->FindSubGroup ( difficulty->FindPairValue ( "inherit", "" ) ), parent ) )
+	{
+		return false;
+	}
+
+	// parse the player's outfit (weapons and ammo)
+	if ( !ParseOutfit( ParseRandom ( difficulty->FindSubGroup ( "outfit" ) ) ) )
+	{
+		// Its ok to fail parsing weapons as long as weapons have
+		// already been parsed at some point
+		if ( !ParseWeapons ( ParseRandom ( difficulty->FindSubGroup ( "weapons" ) ) ) )
+		{
+			if ( !mValidWeapons )
+			{
+				return false;
+			}
+		}
+
+		// Its ok to fail parsing ammo as long as ammo have
+		// already been parsed at some point
+		if ( !ParseAmmo ( ParseRandom ( difficulty->FindSubGroup ( "ammo" ) ) ) )
+		{
+			if ( !mValidAmmo)
+			{
+				return false;
+			}
+		}
+	}
+
+	// Its ok to fail parsing objectives as long as objectives have
+	// already been parsed at some point
+	if ( !ParseObjectives ( ParseRandom ( difficulty->FindSubGroup ( "objectives" ) ) ) )
+	{
+		if ( !mValidObjectives )
+		{
+			return false;
+		}
+	}
+
+	// Set the cvars with the available values
+	Cvar_Set ( "mi_health", difficulty->FindPairValue ( "health", "100" ) );
+	Cvar_Set ( "mi_armor", difficulty->FindPairValue ( "armor", "0" ) );
+
+	// Parse out the timelimit
+	mTimeLimit = atol(difficulty->FindPairValue("timelimit", "0"));
+
+	// NPC multipliers
+	mAccuracyMultiplier = atof(difficulty->FindPairValue("npcaccuracy", "1"));
+	mHealthMultiplier = atof(difficulty->FindPairValue("npchealth", "1"));
+
+	// keep only some of RMG pickups 1 = 100%
+	mPickupHealth = atof(difficulty->FindPairValue("pickup_health", "1"));
+	mPickupArmor = atof(difficulty->FindPairValue("pickup_armor", "1"));
+	mPickupAmmo = atof(difficulty->FindPairValue("pickup_ammo", "1"));
+	mPickupWeapon = atof(difficulty->FindPairValue("pickup_weapon", "1"));
+	mPickupEquipment = atof(difficulty->FindPairValue("pickup_equipment", "1"));
+
+	// Its ok to fail parsing instances as long as instances have
+	// already been parsed at some point
+	if ( !ParseInstances ( ParseRandom ( difficulty->FindSubGroup ( "instances" ) ) ) )
+	{
+		if ( !mValidInstances )
+		{
+			return false;
+		}
+	}
+
+	return true;
+}
+
+/************************************************************************************************
+ * CRMMission::Load
+ *	Loads the given mission using the given difficulty level
+ *
+ * inputs:
+ *  name: Name of the mission to load (should only be the name rather than the full path)
+ *  difficulty: difficulty level to load
+ *
+ * return:
+ *	true: mission successfully loaded
+ *  false: mission failed to load
+ *
+ ************************************************************************************************/
+bool CRMMission::Load ( const char* mission, const char* instances, const char* difficulty )
+{
+	CGenericParser2		parser;
+	CGPGroup*			root;
+
+	// Create the parser for the mission file
+	if(!Com_ParseTextFile(va("ext_data/rmg/%s.mission", mission), parser))
+	{
+		if(!Com_ParseTextFile(va("ext_data/arioche/%s.mission", mission), parser))
+		{
+			Com_Printf("ERROR: Failed to open mission file '%s'\n", mission);
+			return false;
+		}
+	}
+	
+	// Grab the root parser groop and make sure its mission, otherwise this
+	// isnt a valid mission file
+	root = parser.GetBaseParseGroup()->GetSubGroups();
+	if(stricmp(root->GetName(), "mission"))
+	{
+		Com_Printf("ERROR: '%s' is not a valid mission file\n", mission );
+		parser.Clean();
+		return false;
+	}
+	
+	// Grab the mission description and set the cvar for it
+	mDescription = root->FindPairValue ( "description", "<MISSION DESCRIPTION MISSING>" );
+//	Cvar_Set("ar_obj_main0",mDescription.c_str(), CVAR_OBJECTIVE);
+//	Cvar_Set("ar_obj_maincom0", "&OBJECTIVES_INPROGRESS&", CVAR_OBJECTIVE);
+//	Cvar_SetValue ("ar_cur_objective", 0, CVAR_OBJECTIVE);
+
+	string mInfo = root->FindPairValue ( "info", "<MISSION ADDITIONAL INFO MISSING>" );
+//	Cvar_Set("ar_obj_info0",mInfo.c_str(), CVAR_OBJECTIVE);
+
+	mExitScreen = root->FindPairValue ( "exitScreen", "<EXIT SCREEN MISSING>" );
+	mTimeExpiredScreen = root->FindPairValue ( "TimeExpiredScreen", "<TIME EXPIRED SCREEN MISSING>" );
+	
+	// Open the instance file for the specified instances
+	if ( !mInstanceFile.Open ( instances) )
+	{
+		Com_Printf ( "ERROR: Could not open instance file '%s'\n", instances );
+		return false;
+	}
+
+	// Start at one and readjust each time we see and instance
+	// with a higher value
+	mMaxInstancePosition = 1;
+
+	// Now parse the specified difficulty level
+	CGPGroup* parserdif = root->FindSubGroup ( difficulty );
+	CGPGroup* parserpar = parserdif->GetParent();
+	if (!parserpar)
+	{ //rww - expected to have a parent, but sometime doesn't get set.
+	  //I take it JK2's generic parser is not quite the same as SOF2's. Or is out of date.
+		parserpar = root;
+	}
+	if ( !ParseDifficulty ( parserdif, parserpar ) )
+	{
+		return false;
+	}
+
+	// Generate the terrain now
+	mLandScape->Generate(mSymmetric);
+
+	// Cleanup
+	parser.Clean();
+
+	return true;
+}
+
+/************************************************************************************************
+ * CRMMission::Spawn
+ *	Spawns all of the instances for the entire mission onto the given landscape
+ *
+ * inputs:
+ *  landscape: landscape to spawn instances on
+ *
+ * return:
+ *	true: instances spawned successfully
+ *  false: instances failed to spawn
+ *
+ ************************************************************************************************/
+bool CRMMission::Spawn ( CRandomTerrain* terrain, qboolean IsServer )
+{
+#ifndef PRE_RELEASE_DEMO
+	rmInstanceIter_t	it;
+	int					areaIndex;
+	CRMArea*			area;
+
+	// Prespawn all instances, this is mainly for flattening
+	for(it = mInstances.begin(); it != mInstances.end(); it++)
+	{
+		CRMInstance* instance = *it;
+
+		// Pre-Spawn
+		instance->PreSpawn ( terrain, IsServer );
+
+		if (mSymmetric)
+		{
+			instance->SetMirror(1);
+			instance->PreSpawn ( terrain, IsServer );
+			instance->SetMirror(0);
+		}
+	}
+
+	mLandScape->Smooth ( );
+
+	// place bridges
+	PlaceBridges();
+
+	// create automap
+//	if (!com_dedicated->integer)
+	{
+#ifndef DEDICATED
+		CM_TM_Create(mLandScape->GetLandScape());
+#endif
+	}
+
+	mLandScape->GetLandScape()->UpdatePatches();
+
+	// Spawn all instances
+	for(it = mInstances.begin(); it != mInstances.end(); it++)
+	{
+		CRMInstance* instance = *it;
+
+		// Spawn
+		instance->Spawn ( terrain, IsServer );
+		instance->PostSpawn ( terrain, IsServer );
+
+		if (mSymmetric)
+		{	// spawn the mirror version
+			instance->SetMirror(1);
+			instance->Spawn ( terrain, IsServer );
+			instance->PostSpawn ( terrain, IsServer );
+			instance->SetMirror(0);
+		}
+	}
+
+#ifndef FINAL_BUILD
+	// make sure to write out after the mirror happens so red side is displayed on map
+	if (1 == Cvar_VariableIntegerValue("rmg_saveautomap"))
+	{	// write out automap for test purposes
+		char seed[MAX_QPATH];
+		char terrainName[MAX_QPATH];
+		char missionName[MAX_QPATH];
+		Cvar_VariableStringBuffer("RMG_seed", seed, MAX_QPATH);
+		Cvar_VariableStringBuffer("RMG_terrain", terrainName, MAX_QPATH);
+		Cvar_VariableStringBuffer("RMG_mission", missionName, MAX_QPATH);
+
+#ifndef DEDICATED
+		for(it = mInstances.begin(); it != mInstances.end(); it++)
+		{
+			(*it)->DrawAutomapSymbol();
+		}
+		//gi.CM_TM_SaveImageToDisk(terrainName, missionName, seed);
+		CM_TM_SaveImageToDisk(terrainName, missionName, seed);
+#endif
+		Com_Error (ERR_DROP, "RMG Automap written.");
+		return false;
+	}
+#endif
+
+//	// draw player start on automap
+//	CEntity	*spot = NULL;
+//	spot = entitySystem->GetEntityFromClassname( spot, "info_player_start");
+//	if (spot)
+//	{
+//		gi.CM_TM_AddStart(spot->GetOrigin()[0], spot->GetOrigin()[1]);
+//	}
+
+	// Spawn NPC triggers now
+//	SpawnNPCTriggers ( mLandScape );
+
+	// Restory all the NPC's accuracies to the template accuracies times the
+	// multiplier
+//	INPCEnt::RestoreTemplate ( mAccuracyMultiplier, mHealthMultiplier );
+
+	// Little trick to set the current objective to the first in the list
+	CompleteObjective ( NULL );
+
+	// Iterate through the areas and add each to the landscapes list, this is sorta hacky
+	// but bridges the game / common gap
+	for ( areaIndex = 0; NULL != (area = mAreaManager->EnumArea ( areaIndex )); areaIndex ++ )
+	{
+		// Dont bother adding it to the list if collision isnt enabled
+		if ( !area->IsCollisionEnabled() )
+		{
+			continue;
+		}
+
+		CArea* newarea = new CArea ( );
+		newarea->Init ( area->GetOrigin(), area->GetSpacingRadius (), 0, area->IsFlattened()?AT_FLAT:AT_NONE );
+		mLandScape->GetLandScape()->SaveArea( newarea );
+
+		if (mSymmetric)
+		{
+			CArea* newarea = new CArea ( );
+			newarea->Init ( area->GetOrigin(), area->GetSpacingRadius (), 0, area->IsFlattened()?AT_FLAT:AT_NONE );
+			newarea->GetPosition()[0] = mLandScape->GetBounds ( )[0][0]+mLandScape->GetBounds ( )[1][0]-newarea->GetPosition()[0];
+			newarea->GetPosition()[1] = mLandScape->GetBounds ( )[0][1]+mLandScape->GetBounds ( )[1][1]-newarea->GetPosition()[1];
+			mLandScape->GetLandScape()->SaveArea( newarea );
+		}
+	}
+
+	mInstanceFile.Close ( );
+#endif // PRE_RELEASE_DEMO
+
+	return true;
+}
+
+/************************************************************************************************
+ * CRMMission::CompleteMission
+ *	Pauses the game, plays an end screen after a brief delay, which then returns the player to
+ * the RMG menu.
+ *                                                                             *
+ * Input                                                                                        *
+ *    <Variable>: <Description>                                                                 *
+ * Output / Return                                                                              *
+ *    <Variable>: <Description>                                                                 *
+ ************************************************************************************************/
+ void CRMMission::CompleteMission(void)
+ {
+	Cvar_Set ("cl_paused", "1");
+
+//	AddText(va("killserver; menu %s\n", mExitScreen.c_str()));
+	return;
+ }
+
+/************************************************************************************************
+ * CRMMission::FailedMission
+ *	Pauses the game, plays an end screen after a brief delay, which then returns the player to
+ * the RMG menu.
+ *                                                                             *
+ * Input                                                                                        *
+ *    TimeExpired: indicates if the reason failed was because of time
+ * Output / Return                                                                              *
+ *    <Variable>: <Description>                                                                 *
+ ************************************************************************************************/
+ void CRMMission::FailedMission(bool TimeExpired)
+ {
+	Cvar_Set ("cl_paused", "1");
+
+	if (TimeExpired)
+	{
+//		AddText(va("killserver; menu %s\n", mTimeExpiredScreen.c_str()));
+	}
+	return;
+ }
+
+/************************************************************************************************
+ * CRMMission::CompleteObjective
+ *	Completes the given objective and advances the current objective accordingly
+ *
+ * inputs:
+ *  objective: the objetive to mark complete
+ *
+ * return:
+ *	none
+ *
+ ************************************************************************************************/
+void CRMMission::CompleteObjective ( CRMObjective* objective )
+{
+	rmObjectiveIter_t it;
+
+	// Set the object as completed
+	if ( objective )
+	{
+		objective->Complete ( true );
+
+		// Set the completed text for the objective
+//		gi.Cvar_Set( va("ar_obj_subcom0_%i", objective->GetOrderIndex ( )), "&OBJECTIVES_COMPLETE&", CVAR_OBJECTIVE) ;
+
+/*		CEntity *tent = G_TempEntity( vec3_origin, EV_SUB_PRINT );
+		tent->s.time2 = gi.SP_GetStringID ( objective->GetMessage ( ) );	
+		tent->r.svFlags |= SVF_BROADCAST;
+		G_AddTempEntity(tent);
+
+		if (objective->CompleteSoundID())
+			G_SoundBroadcast( tent, objective->CompleteSoundID());
+*/
+	}
+
+	mCurrentObjective = NULL;
+
+	// Find the next objective
+	for (it = mObjectives.begin(); it != mObjectives.end(); it++)
+	{
+		objective = (*it);
+
+		// Skip completed objectives
+		if ( objective->IsCompleted ( ) )
+		{
+			continue;
+		}
+
+		// Find the objective with the lowest priority
+		if ( mCurrentObjective && objective->GetPriority ( ) > mCurrentObjective->GetPriority ( ) )
+		{
+			continue;
+		}
+
+		// Found one
+		mCurrentObjective = objective;
+	}	
+
+	if ( NULL != mCurrentObjective )
+	{
+//		Cvar_SetValue ("ar_cur_objective", mCurrentObjective->GetOrderIndex ( ), CVAR_OBJECTIVE);
+
+		mCurrentObjective->Activate ( );
+	}
+	else
+	{
+		// Set the completed text for the objective
+//		Cvar_Set( "ar_obj_maincom0", "&OBJECTIVES_COMPLETE&", CVAR_OBJECTIVE) ;
+	}
+}
+
+/************************************************************************************************
+ * CRMMission::Preview
+ *	Previews the instances within the mission
+ *
+ * inputs:
+ *  from: the origin which the mission is being previewed from
+ *
+ * return:
+ *	none
+ *
+ ************************************************************************************************/
+void CRMMission::Preview ( const vec3_t from )
+{
+	rmInstanceIter_t	it;
+
+	// Look for settlements close to the player and put up some debug stuff
+	for(it = mInstances.begin(); it != mInstances.end(); it++)
+	{
+		CRMInstance* instance = *it;
+
+		vec3_t a;
+		vec3_t b;
+
+		VectorCopy ( from, a );
+		VectorCopy ( instance->GetOrigin(), b );
+
+		a[2] = 0;
+		b[2] = 0;
+
+		// Skip stuff thats too far away
+		if ( Distance ( a, b) > 2000 )
+		{
+			continue;
+		}
+
+		instance->Preview ( from );
+	}
+}
+
+/************************************************************************************************
+ * CRMMission::PurgeTrigger
+ *	Purge the trigger and all its targets
+ *
+ * inputs:
+ *  trigger: trigger to purge
+ *
+ * return:
+ *	none
+ *
+ ************************************************************************************************/
+/*void CRMMission::PurgeTrigger ( CEntity* trigger )
+{
+	CEntity* target;
+	
+	// Purge all targets
+	target = entitySystem->GetEntityFromTargetName ( NULL, trigger->GetTarget ( ) );
+	while ( target )
+	{
+		PurgeTrigger ( target );
+
+		target = entitySystem->GetEntityFromTargetName ( target, trigger->GetTarget ( ) );
+	}
+
+	// Get rid of the purge trigger
+	entitySystem->RemoveEntityWithServer ( trigger );
+	entitySystem->RemoveEntity ( trigger );
+}
+*/
+/************************************************************************************************
+ * CRMMission::PurgeUnlinkedTriggers
+ *	Searches the entitySystem form a random arioche trigger that matches the objective name
+ *
+ * inputs:
+ *  none
+ *
+ * return:
+ *	trigger: a random trigger or NULL if one couldnt be found
+ *
+ ************************************************************************************************/
+/*void CRMMission::PurgeUnlinkedTriggers ( )
+{
+	CTriggerAriocheObjective*	search;
+
+	// Start at the first match of the classname
+	search = (CTriggerAriocheObjective*) entitySystem->GetEntityFromClassname ( NULL, "trigger_arioche_objective" );
+
+	// Continue on as long as there are triggers
+	while ( search ) 
+	{
+		CTriggerAriocheObjective* purge = search;
+
+		// move on to the next trigger before deleting the entity 
+		// just in case there are some state issues with the search
+		search = (CTriggerAriocheObjective*) entitySystem->GetEntityFromClassname ( search, "trigger_arioche_objective" );
+
+		// Dont purge linked triggers
+		if ( purge->GetObjective ( ) )
+		{
+			continue;
+		}
+
+		// Purge the trigger and all its targets
+		PurgeTrigger ( purge );
+	}
+}
+*/
+/************************************************************************************************
+ * CRMMission::SpawnNPCTriggers
+ *	Spawn triggers across the map which will activate sleeping NPCs
+ *
+ * inputs:
+ *  landscape: landscape to spawn the triggers relative to
+ *
+ * return:
+ *	trigger: a random trigger or NULL if one couldnt be found
+ *
+ ************************************************************************************************/
+/*void CRMMission::SpawnNPCTriggers ( CCMLandScape* landscape )
+{
+	CEntity* ent;
+	int		 i;
+	int		 count;
+	float	 section;
+
+	// Determine how many NPC sections there are in the map
+	count   = (landscape->GetBounds()[1][0] - landscape->GetBounds()[0][0]) / 5000.0f;
+	section = (landscape->GetBounds()[1][0] - landscape->GetBounds()[0][0]) / count;
+
+	// Drop a trigger down at each NPC section interval except for the first and last.
+	for ( i = 1; i < count - 1; i ++ )
+	{
+		vec3_t mins;
+		vec3_t maxs;
+		vec3_t origin;
+
+		VectorCopy ( landscape->GetBounds()[0], mins );
+		VectorCopy ( landscape->GetBounds()[1], maxs );
+
+		// Set up the mins and maxs for the trigger
+		mins[0] = mins[0] + (section * i) - 100;
+		maxs[0] = mins[0] + 100;
+		maxs[2] = maxs[2] + 100;
+		mins[2] = mins[2] - 100;
+
+		origin[0] = (maxs[0]-mins[0])/2 + mins[0];
+		origin[1] = (maxs[1]-mins[1])/2 + mins[1];
+		origin[2] = (maxs[2]-mins[2])/2 + mins[2];
+
+		spawnSystem->ClearSpawnFields();
+		spawnSystem->AddSpawnField("classname", "trigger_arioche_npcspawner" );
+		spawnSystem->AddSpawnField("origin", va("%f %f %f",origin[0],origin[1],origin[2]) );
+		spawnSystem->AddSpawnField("target", va("rmg_npc_%i", i + 1) );
+
+		// Spawn the inhabitant, if it fails then fail
+		ent = entitySystem->SpawnItem("trigger_arioche_npcspawner");
+		if ( !ent )
+		{
+			continue;
+		}
+
+		// Fail if we cant register the entity
+		if ( -1 == entitySystem->RegisterEntityWithServer( ent ) )
+		{
+			entitySystem->RemoveEntity ( ent );
+			continue;
+		}
+
+		// Normalize the mins and maxs for the X axis since they arent
+		// absolute mins and maxs
+		mins[0] = -100;
+		maxs[0] = 100;
+
+		// Adjust the absmin and absmax for the trigger now
+		VectorCopy ( mins, ent->r.mins[0] );
+		VectorCopy ( maxs, ent->r.maxs[0] );
+
+		Com_DPrintf( "NPC Trigger spawned at '%f %f %f' for targets 'rmg_npc_%i'\n", origin[0], origin[1], origin[2], i + 1 );
+
+		// Set the "ONLY_ONCE" spawn flag
+		ent->AddSpawnflags ( 2 );
+
+#ifdef _GAME
+		// initial linking
+		gi.SV_LinkEntity( ent ); 
+#endif	
+	}
+
+	AttachNPCTriggers ( landscape );
+}
+*/
+
+/************************************************************************************************
+ * CRMMission::AttachNPCTriggers
+ *	Attaches npc triggers to all unattached npcs
+ *
+ * inputs:
+ *  landscape: landscape triggers were spawned on
+ *
+ * return:
+ *	trigger: a random trigger or NULL if one couldnt be found
+ *
+ ************************************************************************************************/
+/*void CRMMission::AttachNPCTriggers ( CCMLandScape* landscape )
+{
+	TNPCList	npcList;
+	TNPCFinder	npcFinder;
+	CNPC*		theNPC = 0;
+	int			npcsegment;
+
+	GetCharacterManager().GetCharacterList(npcList);
+
+	// Loop through all npcs and reset their accuracy
+	for( npcFinder = npcList.begin(); npcFinder != npcList.end(); npcFinder++)
+	{		
+		theNPC = (CNPC*) INPCEnt::GetEntity(*npcFinder);
+		if(!theNPC)
+		{
+			continue;
+		}
+
+		npcsegment = (theNPC->r.currentOrigin[0] - landscape->GetMins()[0]) / 5000.0f;		
+
+		// All npcs in segment 0 and 1 are immediately spawned, all others wait for the
+		// trigger
+		if ( npcsegment > 1 )
+		{
+			entitySystem->RemoveFromTargetNameMap(theNPC);	
+			theNPC->SetTargetName ( va("rmg_npc_%i", npcsegment ) );
+			entitySystem->AddToTargetNameMap(theNPC);
+
+			// Start the NPC in the off position
+			theNPC->SetSpawnflags(1);
+			theNPC->r.contents	= 0;
+			theNPC->r.svFlags	|= SVF_NOCLIENT;
+			theNPC->s.eFlags	|= EF_NODRAW;				
+		}
+	}
+}
+*/
+
+
diff --git a/code/RMG/RM_Mission.h b/code/RMG/RM_Mission.h
new file mode 100644
index 0000000..92199cf
--- /dev/null
+++ b/code/RMG/RM_Mission.h
@@ -0,0 +1,129 @@
+#pragma once
+#if !defined(RM_MISSION_H_INC)
+#define RM_MISSION_H_INC
+
+#ifdef DEBUG_LINKING
+	#pragma message("...including RM_Mission.h")
+#endif
+
+// maximum random choices
+#define MAX_RANDOM_CHOICES 100
+
+typedef vector<int> 	rmIntVector_t;
+
+
+class CRMMission
+{
+private:
+
+	rmObjectiveList_t		mObjectives;
+	rmInstanceList_t		mInstances;
+
+	CRMInstanceFile			mInstanceFile;
+	CRMObjective*			mCurrentObjective;
+
+	bool					mValidNodes;
+	bool					mValidPaths;
+	bool					mValidRivers;
+	bool					mValidWeapons;
+	bool					mValidAmmo;
+	bool					mValidObjectives;
+	bool					mValidInstances;
+
+	int						mTimeLimit;
+	int						mMaxInstancePosition;
+
+	// npc multipliers
+	float					mAccuracyMultiplier;
+	float					mHealthMultiplier;
+
+	// % chance that RMG pickup is actually spawned
+	float					mPickupHealth;
+	float					mPickupArmor;
+	float					mPickupAmmo;
+	float					mPickupWeapon;
+	float					mPickupEquipment;
+
+	string					mDescription;
+	string					mExitScreen;
+	string					mTimeExpiredScreen;
+
+	// symmetric landscape style
+	symmetry_t				mSymmetric;
+
+	// if set to 1 in the mission file, adds an extra connecting path in symmetric maps
+	// to ensure both sides actually do connect
+	int						mBackUpPath;
+
+	int						mDefaultPadding;
+
+	CRMAreaManager*			mAreaManager;
+
+	CRMPathManager*			mPathManager;
+
+	CRandomTerrain*			mLandScape;
+
+public:	
+
+	CRMMission ( CRandomTerrain* );
+	~CRMMission ( );
+
+	bool			Load					( const char* name, const char* instances, const char* difficulty );
+	bool			Spawn					( CRandomTerrain* terrain, qboolean IsServer );
+
+	void			Preview					( const vec3_t from );									
+										
+	CRMObjective*	FindObjective			( const char* name );
+	CRMObjective*	GetCurrentObjective		( ) { return mCurrentObjective; }
+	
+	void			CompleteMission			(void);
+	void			FailedMission			(bool TimeExpired);
+	void			CompleteObjective		( CRMObjective* ojective );
+
+	int				GetTimeLimit			(void)	{ return mTimeLimit; }
+	int				GetMaxInstancePosition	(void)  { return mMaxInstancePosition; }
+	const char*		GetDescription			(void)  { return mDescription.c_str(); }
+	const char*		GetExitScreen			(void)  { return mExitScreen.c_str(); }
+	int				GetSymmetric			(void)  { return mSymmetric; }
+	int				GetBackUpPath			(void)  { return mBackUpPath; }
+	int				GetDefaultPadding		(void)  { return mDefaultPadding; }
+
+//	void			CreateMap				( void );
+
+	bool			DenyPickupHealth	() {return mLandScape->flrand(0.0f,1.0f) > mPickupHealth;}
+	bool			DenyPickupArmor		() {return mLandScape->flrand(0.0f,1.0f) > mPickupArmor;}
+	bool			DenyPickupAmmo		() {return mLandScape->flrand(0.0f,1.0f) > mPickupAmmo;}
+	bool			DenyPickupWeapon	() {return mLandScape->flrand(0.0f,1.0f) > mPickupWeapon;}
+	bool			DenyPickupEquipment	() {return mLandScape->flrand(0.0f,1.0f) > mPickupEquipment;}
+
+private:
+					
+//	void			PurgeUnlinkedTriggers	( );
+//	void			PurgeTrigger			( CEntity* trigger );
+
+	void			MirrorPos				(vec3_t pos);
+	CGPGroup*		ParseRandom				( CGPGroup* random );
+	bool			ParseOrigin				( CGPGroup* originGroup, vec3_t origin, vec3_t lookat, int* flattenHeight );
+	bool			ParseNodes				( CGPGroup* group );
+	bool			ParsePaths				( CGPGroup *paths);					
+	bool			ParseRivers				( CGPGroup *rivers);
+	void			PlaceBridges			();
+	void			PlaceWallInstance(CRMInstance*	instance, float xpos, float ypos, float zpos, int x, int y, float angle);
+
+
+	bool			ParseDifficulty			( CGPGroup* difficulty, CGPGroup *parent );
+	bool			ParseWeapons			( CGPGroup* weapons );
+	bool			ParseAmmo				( CGPGroup* ammo );
+	bool			ParseOutfit				( CGPGroup* outfit );
+	bool			ParseObjectives			( CGPGroup* objectives );
+	bool			ParseInstance			( CGPGroup* instance );
+	bool			ParseInstances			( CGPGroup* instances );
+	bool			ParseInstancesOnPath	( CGPGroup* group );
+	bool			ParseWallRect			( CGPGroup* group, int side);
+
+//	void			SpawnNPCTriggers		( CCMLandScape* landscape );
+//	void			AttachNPCTriggers		( CCMLandScape* landscape );
+};
+
+
+#endif
diff --git a/code/RMG/RM_Objective.cpp b/code/RMG/RM_Objective.cpp
new file mode 100644
index 0000000..17eb81e
--- /dev/null
+++ b/code/RMG/RM_Objective.cpp
@@ -0,0 +1,134 @@
+/************************************************************************************************
+ *
+ * RM_Objective.cpp
+ *
+ * Implements the CRMObjective class.  This class is reponsible for parsing an objective 
+ * from the mission file as well as linking the objective into the world.
+ *
+ ************************************************************************************************/
+
+#include "../server/exe_headers.h"
+
+#include "rm_headers.h"
+
+/************************************************************************************************
+ * CRMObjective::CRMObjective
+ *	Constructs a random mission objective and fills in the default properties
+ *
+ * inputs:
+ *  none
+ *
+ * return:
+ *	none
+ *
+ ************************************************************************************************/
+CRMObjective::CRMObjective ( CGPGroup* group )
+{	
+	SetPriority(atoi(group->FindPairValue("priority", "0")));
+	SetMessage( group->FindPairValue("message",va("Objective %i Completed", GetPriority()) ) );
+	SetDescription(group->FindPairValue("description",va("Objective %i", GetPriority()) ) );
+	SetInfo(group->FindPairValue("info",va("Info %i", GetPriority()) ) );
+	SetTrigger(group->FindPairValue("trigger",""));
+	SetName(group->GetName());
+	
+/*	const char * soundPath = group->FindPairValue("completed_sound", "" ); 
+	if (soundPath)
+		mCompleteSoundID = G_SoundIndex(soundPath); 
+*/
+
+	mCompleted  = false;
+	mOrderIndex = -1;
+
+	// If no priority was specified for this objective then its active by default.
+	if ( GetPriority ( ) )
+	{
+		mActive	= false;
+	}
+	else
+	{
+		mActive = true;
+	}
+}
+
+/************************************************************************************************
+ * CRMObjective::FindRandomTrigger
+ *	Searches the entitySystem form a random arioche trigger that matches the objective name
+ *
+ * inputs:
+ *  none
+ *
+ * return:
+ *	trigger: a random trigger or NULL if one couldnt be found
+ *
+ ************************************************************************************************/
+/*CTriggerAriocheObjective* CRMObjective::FindRandomTrigger ( )
+{	
+	CEntity*	search;
+	CEntity*	triggers[20];
+	int			numTriggers;
+
+	// Start off the first trigger
+	numTriggers = 0;
+	search      = entitySystem->GetEntityFromClassname ( NULL, "trigger_arioche_objective" );
+
+	// Make a list of triggers
+	while ( numTriggers < 20 && search )
+	{
+		CTriggerAriocheObjective* trigger = (CTriggerAriocheObjective*) search;
+
+		// Move on to the next trigger
+		search = entitySystem->GetEntityFromClassname ( search, "trigger_arioche_objective" );
+
+		// See if this trigger is already in use
+		if ( trigger->GetObjective ( ) )
+		{
+			continue;
+		}
+
+		// If the objective names dont match then ignore this trigger
+		if ( stricmp ( trigger->GetObjectiveName ( ), GetTrigger() ) )
+		{
+			continue;
+		}
+	
+		// Add the trigger to the list
+		triggers[numTriggers++] = trigger;
+	}
+
+	// If no matching triggers then just return NULL
+	if ( 0 == numTriggers )
+	{
+		return NULL;
+	}
+
+	// Return a random choice from the trigger list
+	return (CTriggerAriocheObjective*)triggers[TheRandomMissionManager->GetLandScape()->irand(0,numTriggers-1)];
+}
+*/
+/************************************************************************************************
+ * CRMObjective::Link
+ *	Links the objective into the world using the current state of the world to determine
+ *  where it should link
+ *
+ * inputs:
+ *  none
+ *
+ * return:
+ *	true: objective successfully linked
+ *  false: objective failed to link
+ *
+ ************************************************************************************************/
+bool CRMObjective::Link ( )
+{
+/*	CTriggerAriocheObjective* trigger;
+
+	// Look for a random trigger to associate this objective to.
+	trigger = FindRandomTrigger ( );
+	if ( NULL != trigger )
+	{
+		trigger->SetObjective ( this );
+	}
+*/	
+	return true;
+}
+
diff --git a/code/RMG/RM_Objective.h b/code/RMG/RM_Objective.h
new file mode 100644
index 0000000..96368a9
--- /dev/null
+++ b/code/RMG/RM_Objective.h
@@ -0,0 +1,65 @@
+#pragma once
+#if !defined(RM_OBJECTIVE_H_INC)
+#define RM_OBJECTIVE_H_INC
+
+#ifdef DEBUG_LINKING
+	#pragma message("...including RM_Objective.h")
+#endif
+
+class CRMObjective
+{
+protected:
+
+	bool		mCompleted;		// Is objective completed?
+	bool		mActive;		// set to false if the objective requires another objective to be met first
+	int			mPriority;		// sequence in which objectives need to be completed
+	int			mOrderIndex;	// objective index in ui
+	int			mCompleteSoundID; // sound for when objective is finished
+	string		mMessage;		// message outputed when objective is completed
+	string		mDescription;	// description of objective
+	string		mInfo;			// more info for objective
+	string		mName;			// name of objective
+	string		mTrigger;		// trigger associated with objective
+
+public:
+	
+	CRMObjective(CGPGroup *group);
+	~CRMObjective(void) {}
+
+	bool			Link			(void);
+
+	bool			IsCompleted		(void) const { return mCompleted; }
+	bool			IsActive		(void) const { return mActive; }
+
+	void			Activate		(void)		 { mActive = true; }
+	void			Complete		(bool comp)  { mCompleted = comp;}
+
+	// Get methods
+	int				GetPriority(void){return mPriority;}
+	int				GetOrderIndex(void) { return mOrderIndex; }
+	const char*		GetMessage(void) { return mMessage.c_str(); }
+	const char*		GetDescription(void) { return mDescription.c_str(); }
+	const char*		GetInfo(void) { return mInfo.c_str(); }
+	const char*		GetName(void) { return mName.c_str(); }
+	const char*		GetTrigger(void) { return mTrigger.c_str(); }
+	int				CompleteSoundID() { return mCompleteSoundID; };
+
+	// Set methods
+	void			SetPriority(int priority){mPriority = priority;}
+	void			SetOrderIndex(int order) { mOrderIndex = order; }
+	void			SetMessage(const char* msg) { mMessage = msg; }
+	void			SetDescription(const char* desc) { mDescription = desc; }
+	void			SetInfo(const char* info) { mInfo = info; }
+	void			SetName(const char* name) { mName = name; }
+	void			SetTrigger(const char* name) { mTrigger = name; }
+
+private:
+
+//	CTriggerAriocheObjective*		FindRandomTrigger		( );
+};
+
+typedef list<CRMObjective *>::iterator	rmObjectiveIter_t;
+typedef list<CRMObjective *>			rmObjectiveList_t;
+
+
+#endif
\ No newline at end of file
diff --git a/code/RMG/RM_Path.cpp b/code/RMG/RM_Path.cpp
new file mode 100644
index 0000000..bc50257
--- /dev/null
+++ b/code/RMG/RM_Path.cpp
@@ -0,0 +1,721 @@
+/************************************************************************************************
+ *
+ *	Copyright (C) 2001-2002 Raven Software
+ *
+ *  RM_Path.cpp
+ *
+ ************************************************************************************************/
+#include "../server/exe_headers.h"
+
+#include "rm_headers.h"
+
+#define max(a,b)    (((a) > (b)) ? (a) : (b))
+
+/************************************************************************************************
+ * CRMNode::CRMNode
+ *	constructor
+ *
+ * inputs:
+ *  none
+ *
+ * return:
+ *	none
+ *
+ ************************************************************************************************/
+CRMNode::CRMNode ( )
+{
+	int i;
+
+	mFlattenHeight = -1;
+
+	mPos[0] = 0;
+	mPos[1] = 0;
+	mPos[2] = 0;
+
+	// no paths
+	for (i = 0; i < DIR_MAX; i++)
+		mPathID[i] = -1;
+
+	mAreaPointPlaced = false;
+}
+
+
+/************************************************************************************************
+ * CRMPathManager::CRMPathManager
+ *	constructor
+ *
+ * inputs:
+ *  none
+ *
+ * return:
+ *	none
+ *
+ ************************************************************************************************/
+CRMPathManager::CRMPathManager ( CRandomTerrain* terrain )
+: mXNodes(0), mYNodes(0), mPathCount(0), mRiverCount(0), mMaxDepth(0), mDepth(0),
+  mPathPoints(10), mPathMinWidth(0.02f), mPathMaxWidth(0.04f), mPathDepth(0.3f), mPathDeviation(0.03f), mPathBreadth(5),
+  mRiverDepth(5), mRiverPoints(10), mRiverMinWidth(0.01f), mRiverMaxWidth(0.02f), mRiverBedDepth(1), mRiverDeviation(0.01f), mRiverBreadth(7),
+  mTerrain(terrain), mCrossed(false)
+{
+}
+
+CRMPathManager::~CRMPathManager ( )
+{
+	int i,j;
+
+	for ( i = mLocations.size() - 1; i >=0; i-- )
+	{
+		if (mLocations[i])
+			delete mLocations[i];
+	}
+	mLocations.clear();
+
+	for ( j = mNodes.size() - 1; j >=0; j-- )
+	{
+		if (mNodes[j])
+			delete mNodes[j];
+	}
+	mNodes.clear();
+}
+
+void CRMPathManager::CreateLocation ( const char* name, const int min_depth, int max_depth, const int min_paths, int max_paths )
+{
+	int i;
+
+	// sanity checks -- dmv
+	if( max_paths < min_paths )
+	{
+		Com_Printf("[CreateLocation()] ERROR : max_paths < min_paths :: set max_paths = min_paths\n" );
+		max_paths = min_paths;
+	}
+	if( max_depth < min_depth )
+	{
+		Com_Printf("[CreateLocation()] ERROR : max_depth < min_depth :: set max_depth = min_depth\n" );
+		max_depth = min_depth;
+	}
+
+	for (i = mLocations.size()-1; i>=0; --i)
+		if ( !stricmp ( name, mLocations[i]->GetName ( ) ) )
+		{
+			mLocations[i]->SetMinDepth(min_depth);
+			mLocations[i]->SetMaxDepth(max_depth);
+			mLocations[i]->SetMinPaths(min_paths);
+			mLocations[i]->SetMaxPaths(max_paths);
+			return;
+		}
+
+	CRMLoc* pLoc= new CRMLoc(name, min_depth, max_depth, min_paths, max_paths); 
+	mLocations.push_back(pLoc); 
+	mMaxDepth =  max(mMaxDepth, max_depth);
+}
+
+void CRMPathManager::ClearCells(int x_nodes, int y_nodes)
+{
+	int x,y;
+
+	// clear cell array - used for generating paths
+	CRMCell empty;
+	for (x=0; x < x_nodes * y_nodes; x++)
+	{
+		if (x >= mCells.size())
+			mCells.push_back(empty);
+		else
+			mCells[x] = empty;
+	}
+
+	// set borders of world
+	for (y = 0; y < y_nodes; y++)
+	{
+		mCells[y * x_nodes].SetBorder(DIR_W );
+		mCells[y * x_nodes].SetBorder(DIR_SW );
+		mCells[y * x_nodes].SetBorder(DIR_NW );
+		mCells[y * x_nodes + x_nodes-1].SetBorder( DIR_E );
+		mCells[y * x_nodes + x_nodes-1].SetBorder( DIR_NE );
+		mCells[y * x_nodes + x_nodes-1].SetBorder( DIR_SE );
+	}
+
+	for (x = 0; x < x_nodes; x++)
+	{
+		mCells[x].SetBorder( DIR_N );
+		mCells[x].SetBorder( DIR_NE );
+		mCells[x].SetBorder( DIR_NW );
+		mCells[(y_nodes-1) * x_nodes + x].SetBorder( DIR_S );
+		mCells[(y_nodes-1) * x_nodes + x].SetBorder( DIR_SE );
+		mCells[(y_nodes-1) * x_nodes + x].SetBorder( DIR_SW );
+	}
+}
+
+/************************************************************************************************
+ * CRMPathManager::CreateArray
+ *	Create array of nodes that are spaced over the landscape.
+ *	Create array of cells, which is used to determine how nodes are connected.
+ *
+ * inputs:
+ *  x_nodes, y_nodes - how many nodes in each dimension to layout
+ *
+ * return:
+ *	true if the node array was created, false if we have a problem
+ *
+ ************************************************************************************************/
+bool CRMPathManager::CreateArray(const int x_nodes, const int y_nodes)
+{
+	mXNodes = x_nodes;
+	mYNodes = y_nodes;
+
+	// fill node array with positions that are spaced over the landscape
+	int x,y;
+
+	// dump existing nodes
+	for ( x = mNodes.size() - 1; x >=0; x-- )
+	{
+		if (mNodes[x])
+			delete mNodes[x];
+	}
+	mNodes.clear();
+	mNodes.resize(mXNodes * mYNodes, NULL);
+
+	// add a small amount of random jitter to spots chosen
+	float x_rnd = 0.2f / (mXNodes+1);
+	float y_rnd = 0.2f / (mYNodes+1);
+
+	for (x = 0; x < mXNodes; x++)
+	{
+		float cell_x = (x + 1.0f) / (mXNodes+1);
+//		float cell_x = (x + 2.0f) / (mXNodes+3);
+
+		for (y = 0; y < mYNodes; y++)
+		{
+			vec3_t pos;
+			CRMNode * pnode = new CRMNode();
+			mNodes[x + y*mXNodes] = pnode;
+
+			float cell_y = (y + 1.0f) / (mYNodes+1);
+//			float cell_y = (y + 2.0f) / (mYNodes+3);
+
+			pos[0] = TheRandomMissionManager->GetLandScape()->flrand(cell_x - x_rnd, cell_x + x_rnd);
+			pos[1] = TheRandomMissionManager->GetLandScape()->flrand(cell_y - y_rnd, cell_y + y_rnd);
+			pos[2] = 0;
+			 
+			SetNodePos(x, y, pos);
+		}
+	}
+
+	ClearCells(mXNodes, mYNodes);
+
+	return true;
+}
+
+// neighbor offsets - easy way to turn a direction into the array position for a neighboring cell or node
+int CRMPathManager::neighbor_x[DIR_MAX] = { 0, 1, 1, 1, 0,-1,-1,-1};
+int CRMPathManager::neighbor_y[DIR_MAX] = {-1,-1, 0, 1, 1, 1, 0,-1};
+
+/************************************************************************************************
+ * CRMPathManager::PlaceLocation
+ * This method is used to determine if a named location should be placed at this node.
+ *
+ * inputs:
+ *  c_x, c_y - cell to examine
+ *
+ * return:
+ *	none
+ *
+ ************************************************************************************************/
+void CRMPathManager::PlaceLocation(const int c_x, const int c_y)
+{
+	if ( !Node(c_x,c_y)->IsLocation() )
+	{	// not currently a location
+
+		// how many paths lead to this cell?
+		int count_paths = 0;
+		int i;
+
+		for (i = 0; i<DIR_MAX; i++)
+			if (Node(c_x,c_y)->PathExist(i))
+				count_paths++;
+
+		int deepest_depth = -1;
+		int deepest_loc = -1;
+		for (i = mLocations.size()-1; i>=0; --i)
+		{
+			if (!mLocations[i]->Placed() &&					// node has not been placed
+				 mLocations[i]->MinDepth() <= mDepth &&		// our current depth is in the proper range
+				 mLocations[i]->MaxDepth() >= mDepth &&
+				 mLocations[i]->MinPaths() <= count_paths && // our path count is in the proper range
+				 mLocations[i]->MaxPaths() >= count_paths &&
+				 mLocations[i]->MaxDepth() > deepest_depth)	// and this is the deepest location of the ones that match
+			{
+				deepest_loc = i;
+				deepest_depth = mLocations[i]->MaxDepth();
+			}
+		}
+
+		if (deepest_loc >= 0 && deepest_loc < mLocations.size())
+		{	// found a location to place at this node / cell
+			const char * name = mLocations[deepest_loc]->GetName();
+			Node(c_x,c_y)->SetName(name);
+			mLocations[deepest_loc]->SetPlaced(true);
+
+			// need a new max depth
+			int max_depth = -1;
+			for (i = mLocations.size()-1; i>=0; --i)
+			{
+				// figure out new max depth based on the max depth of unplaced locations
+				if (!mLocations[i]->Placed() &&	   			// node has not been placed
+					 mLocations[i]->MaxDepth() > max_depth)	// and this is the deepest 
+				{
+					max_depth = mLocations[i]->MaxDepth();
+				}
+			}
+			mMaxDepth = max_depth;
+		}
+	}
+}
+
+/************************************************************************************************
+ * CRMPathManager::PathVisit
+ * This method is called recursively to create a network of nodes connected with paths.
+ *
+ * inputs:
+ *  c_x, c_y - cell to visit
+ *
+ * return:
+ *	none
+ *
+ ************************************************************************************************/
+void CRMPathManager::PathVisit(const int c_x, const int c_y)
+{
+	// does this cell have any neighbors with all walls intact?
+	int i,off;
+	
+	// look at neighbors in random order
+	off = TheRandomMissionManager->GetLandScape()->irand(DIR_FIRST, DIR_MAX-1);
+
+	++mDepth;	// track our depth of recursion
+
+	for (i = DIR_FIRST; i<DIR_MAX && mDepth <= mMaxDepth; i++)
+	{
+		int d = (i + off) % DIR_MAX;
+		if ( !Cell(c_x, c_y).Border(d) )
+		{	// we can move this way, since no border
+			int new_c_x = c_x + neighbor_x[d];
+			int new_c_y = c_y + neighbor_y[d];
+			if (Cell(new_c_x,new_c_y).Wall() == DIR_ALL)
+			{	// we have a new cell that has not been visited!
+				int new_dir;
+				// d is the direction relative to the current cell
+				// new_dir is the direction relative to the next cell (N becomes S, NE becomes SW, etc...)
+				if( d < HALF_DIR_MAX )
+				{
+					new_dir = d + HALF_DIR_MAX;
+				}
+				else
+				{
+					new_dir = d - HALF_DIR_MAX;
+				}
+	
+				// knock down walls
+				Cell(c_x,c_y).RemoveWall(d);
+				Cell(new_c_x,new_c_y).RemoveWall(new_dir); //DIR_MAX - d);
+
+				// set path id
+				Node(c_x, c_y)->SetPath(d, mPathCount);
+				Node(new_c_x, new_c_y)->SetPath(new_dir, mPathCount); //DIR_MAX - d, mPathCount);
+
+				// create path between cells
+				mTerrain->CreatePath( mPathCount++,
+									-1,
+									0,
+									mPathPoints,
+									GetNodePos(c_x,c_y)[0],
+									GetNodePos(c_x,c_y)[1],
+									GetNodePos(new_c_x,new_c_y)[0],
+									GetNodePos(new_c_x,new_c_y)[1],
+									mPathMinWidth,
+									mPathMaxWidth,
+									mPathDepth,
+									mPathDeviation,
+									mPathBreadth );
+
+				// flatten a small spot
+				CArea		area;
+				float flat_radius = mPathMaxWidth * 
+					fabs(TheRandomMissionManager->GetLandScape()->GetBounds()[1][0] - TheRandomMissionManager->GetLandScape()->GetBounds()[0][0]);
+				area.Init( GetNodePos(c_x,c_y), flat_radius, 0.0f, AT_NONE, 0, 0 );
+				TheRandomMissionManager->GetLandScape()->FlattenArea(&area, 255 * mPathDepth, false, true, true );
+
+				// recurse
+				PathVisit(new_c_x, new_c_y);
+			}
+		}
+	}
+	
+	--mDepth;
+
+	// NOTE: *whoop* hack alert, the first time this is reached, it should be the very last placed node.
+	if( !mCrossed && TheRandomMissionManager->GetMission()->GetSymmetric() &&
+		TheRandomMissionManager->GetMission()->GetBackUpPath() )
+	{	
+		mCrossed = true; 
+	
+		int directionSet[3][3] = {DIR_NW,DIR_W,DIR_SW,DIR_N,-1,DIR_S,DIR_NE,DIR_E,DIR_SE};
+		int	ncx	= (mXNodes-1)-c_x;
+		int	ncy	= (mYNodes-1)-c_y;
+
+		int x_delta = ncx - c_x;
+		int y_delta = ncy - c_y;
+
+		if( x_delta < -1 )
+		{
+			x_delta = -1;
+		}
+		else if( x_delta > 1 )
+		{
+			x_delta = 1;
+		}
+
+		if( y_delta < -1 )
+		{
+			y_delta = -1;
+		}
+		else if( y_delta > 1 )
+		{
+			y_delta = 1;
+		}
+		
+		// make sure the mirror is actually in a different position than then un-mirrored node
+		if( x_delta || y_delta )
+		{
+
+			int d = directionSet[x_delta][y_delta];
+			int new_dir;
+			// d is the direction relative to the current cell
+			// new_dir is the direction relative to the next cell (N becomes S, NE becomes SW, etc...)
+			if( d < HALF_DIR_MAX )
+			{
+				new_dir = d + HALF_DIR_MAX;
+			}
+			else
+			{
+				new_dir = d - HALF_DIR_MAX;
+			}
+
+			//NOTE: Knocking down these walls will cause instances to be created on this new artificial path
+			// Since this path could span more than just the normal 1 cell, these walls being knocked down are not exactly correct... but get the job done
+
+			// knock down walls
+			Cell(c_x,c_y).RemoveWall(d);
+			Cell(ncx,ncy).RemoveWall(new_dir); //DIR_MAX - d);
+
+			// set path id
+			Node(c_x, c_y)->SetPath(d, mPathCount);
+			Node(ncx, ncy)->SetPath(new_dir, mPathCount); //DIR_MAX - d, mPathCount);
+		
+			// create an artificial path that crosses over to connect the symmetric and non-symmetric map parts
+			mTerrain->CreatePath( mPathCount++,
+								-1,
+								0,
+								mPathPoints,
+								GetNodePos(c_x,c_y)[0],
+								GetNodePos(c_x,c_y)[1],
+								GetNodePos(ncx,ncy)[0],
+								GetNodePos(ncx,ncy)[1],
+								mPathMinWidth,
+								mPathMaxWidth,
+								mPathDepth,
+								mPathDeviation,
+								mPathBreadth );
+		
+		}
+	}
+
+	PlaceLocation(c_x, c_y);
+}
+
+
+/************************************************************************************************
+ * CRMPathManager::FindNodeByName
+ *	Finds the managed node with the matching case-insensivity name
+ *
+ * inputs:
+ *  name - name of the node to find
+ *
+ * return:
+ *	a pointer to the found node or NULL if the node couldn't be found
+ *
+ ************************************************************************************************/
+CRMNode* CRMPathManager::FindNodeByName ( const char* name )
+{
+	int		 j;
+
+	for ( j = mNodes.size() - 1; j >=0; j-- )
+	{
+		if ( !stricmp ( name, mNodes[j]->GetName ( ) ) )
+			return mNodes[j];
+	}
+	return NULL;
+}
+
+
+/************************************************************************************************
+ * CRMPathManager::SetPathStyle
+ *	sets style for all paths
+ *
+ * inputs:
+ *  settings for paths that are created
+ *
+ * return:
+ *	none
+ *
+ ************************************************************************************************/
+void CRMPathManager::SetPathStyle ( 
+	const int	points,
+	const float	minwidth,
+	const float	maxwidth,
+	const float	depth,
+	const float	deviation,
+	const float	breadth
+	)
+{
+	// save path style
+	mPathPoints   = points  ;
+	mPathMinWidth = minwidth;
+	mPathMaxWidth = maxwidth;
+	mPathDepth    = depth   ;
+	mPathDeviation= deviation;
+	mPathBreadth  = breadth ;
+}
+
+/************************************************************************************************
+ * CRMPathManager::SetRiverStyle
+ *	sets style for all rivers
+ *
+ * inputs:
+ *  settings for river paths that are created
+ *
+ * return:
+ *	none
+ *
+ ************************************************************************************************/
+void CRMPathManager::SetRiverStyle (const int   depth,
+									const int	points,
+									const float minwidth,
+									const float maxwidth,
+									const float beddepth, 
+									const float deviation, 
+									const float breadth,
+									string bridge_name)
+{
+	// save river style
+	mRiverDepth    = depth;
+	mRiverPoints   = points  ;
+	mRiverMinWidth = minwidth;
+	mRiverMaxWidth = maxwidth;
+	mRiverBedDepth = beddepth   ;
+	mRiverDeviation= deviation;
+	mRiverBreadth  = breadth ;
+	mRiverBridge   = bridge_name;
+}
+
+vec3_t&	CRMPathManager::GetRiverPos( const int x, const int y ) 
+{ 
+	mRiverPos[0] = (float)(x + 1.0f) / (float)(mXNodes+2);
+	mRiverPos[1] = (float)(y + 1.0f) / (float)(mYNodes+2);
+	return mRiverPos; 
+}
+
+void CRMPathManager::RiverVisit(const int c_x, const int c_y)
+{
+	// does this cell have any neighbors with all walls intact?
+	int i,off;
+
+	// look at neighbors in random order
+	off = TheRandomMissionManager->GetLandScape()->irand(DIR_FIRST, DIR_MAX-1);
+
+	++mDepth;	// track our depth of recursion
+
+	for (i = DIR_FIRST; i<DIR_MAX && mDepth <= mMaxDepth; i+=2)
+	{
+		int d = (i + off) % DIR_MAX;
+		if ( !Cell(c_x, c_y).Border(d) )
+		{	// we can move this way, since no border
+			int new_c_x = c_x + neighbor_x[d];
+			int new_c_y = c_y + neighbor_y[d];
+			if (RiverCell(new_c_x,new_c_y).Wall() == DIR_ALL)
+			{	// we have a new cell that has not been visited!
+
+				int new_dir;
+				// d is the direction relative to the current cell
+				// new_dir is the direction relative to the next cell (N becomes S, NE becomes SW, etc...)
+				if( d < HALF_DIR_MAX )
+				{
+					new_dir = d + HALF_DIR_MAX;
+				}
+				else
+				{
+					new_dir = d - HALF_DIR_MAX;
+				}
+				// knock down walls
+				RiverCell(c_x,c_y).RemoveWall(d);
+				RiverCell(new_c_x,new_c_y).RemoveWall(new_dir); //DIR_MAX - d);
+
+				// create river between cells
+				mTerrain->CreatePath ( mPathCount++,
+									-1,
+									0,
+									mRiverPoints,
+									GetRiverPos(c_x,c_y)[0],
+									GetRiverPos(c_x,c_y)[1],
+									GetRiverPos(new_c_x,new_c_y)[0],
+									GetRiverPos(new_c_x,new_c_y)[1],
+									mRiverMinWidth,
+									mRiverMaxWidth,
+									mRiverBedDepth,
+									mRiverDeviation,
+									mRiverBreadth );
+
+				// flatten a small spot
+				CArea		area;
+				float flat_radius = mRiverMinWidth * 
+					fabs(TheRandomMissionManager->GetLandScape()->GetBounds()[1][0] - TheRandomMissionManager->GetLandScape()->GetBounds()[0][0]);
+				area.Init( GetRiverPos(c_x,c_y), flat_radius, 0.0f, AT_NONE, 0, 0 );
+				TheRandomMissionManager->GetLandScape()->FlattenArea (&area, 255 * mRiverBedDepth, false, true, true );
+
+				// recurse
+				RiverVisit(new_c_x, new_c_y);
+			}
+		}
+	}
+	
+//	--mDepth;
+}
+
+/************************************************************************************************
+ * CRMPathManager::GenerateRivers
+ *	Creates a river which intersects the main path
+ *
+ * inputs:
+ *  none
+ *
+ * return:
+ *	none
+ *
+ ************************************************************************************************/
+void CRMPathManager::GenerateRivers ()
+{
+	if (mRiverBedDepth == 1)
+		// no rivers
+		return;
+
+	mMaxDepth = mRiverDepth;
+	mDepth = 0;
+
+	int cell_x = 0;
+	int cell_y = 0;
+
+	// choose starting cell along an edge
+	int edge = TheRandomMissionManager->GetLandScape()->irand(0, 7);
+	switch ( edge )
+	{
+		case 0:
+			cell_x = mXNodes / 2; cell_y = 0;
+			break;
+		case 1:
+			cell_x = mXNodes; cell_y = 0;
+			break;
+		case 2:
+			cell_x = mXNodes; cell_y = mYNodes / 2;
+			break;
+		case 3:
+			cell_x = mXNodes; cell_y = mYNodes;
+			break;
+		case 4:
+			cell_x = mXNodes / 2; cell_y = mYNodes;
+			break;
+		case 5:
+			cell_x = 0; cell_y = mYNodes;
+			break;
+		case 6:
+			cell_x = 0; cell_y = mYNodes / 2;
+			break;
+		case 7:
+			cell_x = 0; cell_y = 0;
+			break;
+	}
+
+	ClearCells(mXNodes+1, mYNodes+1);
+
+	mRiverCount = mPathCount;
+
+	// visit the first cell
+	RiverVisit(cell_x,cell_y);
+
+	mRiverCount = mPathCount - mRiverCount;
+
+	return;
+}
+
+/************************************************************************************************
+ * CRMPathManager::GeneratePaths
+ *	Creates all paths 
+ *
+ * inputs:
+ *  none
+ *
+ * return:
+ *	none
+ *
+ ************************************************************************************************/
+void CRMPathManager::GeneratePaths ( symmetry_t symmetric )
+{
+	int cell_x = 0;
+	int cell_y = 0;
+
+	switch ( symmetric )
+	{
+		case SYMMETRY_TOPLEFT:
+			cell_x = mXNodes-1;
+			cell_y = 0;
+			break;
+
+		case SYMMETRY_BOTTOMRIGHT:
+			cell_x = 0;
+			cell_y = mYNodes-1;
+			break;
+
+		default:
+		case SYMMETRY_NONE:
+			// choose starting cell along an edge
+			switch ( TheRandomMissionManager->GetLandScape()->irand(0, 7) )
+			{
+				case 0:
+					cell_x = mXNodes / 2;
+					break;
+				case 1:
+					cell_x = mXNodes-1;
+					break;
+				case 2:
+					cell_x = mXNodes-1; cell_y = mYNodes / 2;
+					break;
+				case 3:
+					cell_x = mXNodes-1; cell_y = mYNodes-1;
+					break;
+				case 4:
+					cell_x = mXNodes / 2; cell_y = mYNodes-1;
+					break;
+				case 5:
+					cell_y = mYNodes-1;
+					break;
+				case 6:
+					cell_y = mYNodes / 2;
+					break;
+				default:
+				case 7:
+					break;
+			}
+			break;
+	}
+
+	// visit the first cell
+	PathVisit(cell_x,cell_y);
+}
+
diff --git a/code/RMG/RM_Path.h b/code/RMG/RM_Path.h
new file mode 100644
index 0000000..cb7ed4e
--- /dev/null
+++ b/code/RMG/RM_Path.h
@@ -0,0 +1,223 @@
+/************************************************************************************************
+ *
+ *	Copyright (C) 2001-2002 Raven Software
+ *
+ *  RM_Path.h
+ *
+ ************************************************************************************************/
+
+#pragma once
+#if !defined(RM_PATH_H_INC)
+#define RM_PATH_H_INC
+
+#ifdef DEBUG_LINKING
+	#pragma message("...including RM_Path.h")
+#endif
+
+#if !defined(CM_RANDOMTERRAIN_H_INC)
+#include "../qcommon/cm_randomterrain.h"
+#endif
+
+class CRMPathManager;
+
+// directions you can proceed from cells 
+enum ERMDir
+{
+	DIR_FIRST= 0,
+	DIR_N	= 0,
+	DIR_NE,
+	DIR_E ,
+	DIR_SE,
+	DIR_S ,
+	DIR_SW,
+	DIR_W ,
+	DIR_NW,
+	DIR_MAX,
+	DIR_ALL = 255
+};
+
+#define	HALF_DIR_MAX (DIR_MAX/2)
+
+class CRMNode
+{
+private:
+
+	string			mName;					// name of node - "" if not used yet
+	vec3_t			mPos;					// where node is
+	int				mPathID[DIR_MAX]; 		// path id's that lead from this node
+	bool			mAreaPointPlaced;		// false if no area point here yet.
+
+	int				mFlattenHeight;
+
+public:
+
+	CRMNode ( );
+
+	bool		IsLocation() {return strlen(mName.c_str())>0;};
+	const char*	GetName	 ( ) { return mName.c_str(); }
+	vec3_t&		GetPos	 ( ) { return mPos; }
+	const float PathExist( const int dir) { return (mPathID[dir % DIR_MAX] != -1); };
+	const float GetPath  ( const int dir) { return mPathID[dir % DIR_MAX]; };
+	bool		AreaPoint() {return mAreaPointPlaced;};
+
+	void		SetName ( const char* name ) { mName = name; }
+	void		SetPos ( const vec3_t& v ) { VectorCopy ( v, mPos ); }
+	void		SetPath( const int dir, const int id) { mPathID[dir % DIR_MAX] = id; };
+	void		SetAreaPoint(bool ap) {mAreaPointPlaced = ap;};
+
+	void		SetFlattenHeight(int flattenHeight) {mFlattenHeight = flattenHeight; }
+	int			GetFlattenHeight() {return mFlattenHeight; }
+};
+
+typedef vector<CRMNode*>	 	rmNodeVector_t;
+
+// named spots on the map, should be placed into nodes
+class CRMLoc
+{
+private:
+
+	string			mName;		// name of location
+	int				mMinDepth;
+	int				mMaxDepth;
+	int				mMinPaths;
+	int				mMaxPaths;
+	bool			mPlaced;	// location has been placed at a node
+
+public:
+	CRMLoc (const char *name, const int min_depth, const int max_depth, const int min_paths =1, const int max_paths=1 ) 
+		: mMinDepth(min_depth), mMaxDepth(max_depth), mPlaced(false), mMinPaths(min_paths), mMaxPaths(max_paths)
+	{ mName = name; };
+
+	const char*	GetName	 ( ) { return mName.c_str(); }
+	void		SetName ( const char* name ) { mName = name; }
+	
+	int			MinDepth() {return mMinDepth;};
+	void		SetMinDepth(const int deep) {mMinDepth = deep;};
+
+	int			MaxDepth() {return mMaxDepth;};
+	void		SetMaxDepth(const int deep) {mMaxDepth = deep;};
+	
+	int			MinPaths() {return mMinPaths;};
+	void		SetMinPaths(const int paths) {mMinPaths = paths;};
+
+	int			MaxPaths() {return mMaxPaths;};
+	void		SetMaxPaths(const int paths) {mMaxPaths = paths;};
+	
+	bool		Placed() { return mPlaced; };
+	void		SetPlaced(bool p) { mPlaced = p;};
+};
+
+typedef vector<CRMLoc*> 	rmLocVector_t;
+
+
+// cells are used for figuring out node connections / paths
+struct CRMCell
+{
+private:
+	int		border;
+	int		wall;
+
+public:
+	CRMCell() { border = 0; wall = DIR_ALL; };
+
+	int		Border() {return border;};
+	int		Wall() {return wall;};
+	bool	Border(const int dir) { return (border & (1<<dir))!=0; };
+	bool	Wall(const int dir) { return (wall & (1<<dir))!=0; };
+	void	SetBorder(const int dir) { border |= (1<<dir); };
+	void	SetWall(const int dir) { wall |= (1<<dir); };
+	void	RemoveWall(const int dir) { wall &= ~(1<<dir); };
+};
+
+typedef vector<CRMCell>			rmCellVector_t;
+
+
+class CRMPathManager
+{
+public:
+	int				mXNodes;	// number of nodes in the x dimension
+	int				mYNodes;	// number of nodes in the y dimension
+
+private:
+	rmLocVector_t	mLocations; // location, named spots to be placed at nodes
+	rmNodeVector_t	mNodes;		// nodes, spots on map that *may* be connected by paths
+	rmCellVector_t	mCells;		// array of cells for doing path generation
+
+	int				mPathCount;
+	int				mRiverCount;
+	int				mMaxDepth;	// deepest any location wants to be
+	int				mDepth;		// current depth
+
+	bool			mCrossed;  // used to indicate if paths crossed the imaginary diagonal that cuts symmetric maps in half
+
+	// path style
+	int				mPathPoints;
+	float			mPathMinWidth;
+	float			mPathMaxWidth;
+	float			mPathDepth;
+	float			mPathDeviation;
+	float			mPathBreadth;
+
+	// river style
+	int				mRiverDepth;
+	int				mRiverPoints;
+	float			mRiverMinWidth;
+	float			mRiverMaxWidth;
+	float			mRiverBedDepth;
+	float			mRiverDeviation;
+	float			mRiverBreadth;
+	string			mRiverBridge;
+	vec3_t			mRiverPos;
+
+	static int neighbor_x[DIR_MAX];
+	static int neighbor_y[DIR_MAX];
+
+	CRandomTerrain*	mTerrain;
+
+public:
+	CRMPathManager ( CRandomTerrain* terrain );
+	~CRMPathManager ( );
+
+	void		ClearCells		(int x_nodes, int y_nodes);
+	bool		CreateArray		( const int x_nodes, const int y_nodes );
+
+	CRMNode*	FindNodeByName	( const char* name );
+	CRMNode*	Node			( const int x, const int y ) {return mNodes[x + y*mXNodes];};
+
+	void		CreateLocation	( const char* name, const int min_depth, int max_depth, const int min_paths =1, int max_paths =1 );
+
+	vec3_t&		GetNodePos		( const int x, const int y ) { return mNodes[x + y*mXNodes]->GetPos(); };
+	void		SetNodePos		( const int x, const int y, const vec3_t& pos) { mNodes[x + y*mXNodes]->SetPos(pos); };
+	int			GetPathCount	() {return mPathCount;};
+	int			GetRiverCount	() {return mRiverCount;};
+	float		GetRiverDepth	() {return mRiverBedDepth;};
+	float		GetPathDepth	() {return mPathDepth;};
+	const char *GetBridgeName	() {return 	mRiverBridge.c_str();};
+	vec3_t&		GetRiverPos		( const int x, const int y );
+
+	CRMCell&	Cell			( const int x, const int y ) {return mCells[x + y*mXNodes];};
+	CRMCell&	RiverCell  		( const int x, const int y ) {return mCells[x + y*(mXNodes+1)];};
+	void		PlaceLocation	( const int x, const int y );
+	void		PathVisit		( const int x, const int y );
+	void		RiverVisit		( const int x, const int y );
+	void		SetPathStyle	( const int	points = 10,
+								  const float minwidth = 0.01f, 
+								  const float maxwidth = 0.05f,	
+								  const float depth = 0.3f, 
+								  const float deviation = 0.2f, 
+								  const float breadth = 5);
+
+	void		SetRiverStyle	( const int depth = 5,
+								  const int	points = 10,
+								  const	float minwidth = 0.01,
+								  const	float maxwidth = 0.03,
+								  const float beddepth = 0.0f, 
+								  const float deviation = 0.25f, 
+								  const float breadth = 7,
+								  string bridge_name = "");
+
+	void		GeneratePaths	( symmetry_t symmetric = SYMMETRY_NONE );
+	void		GenerateRivers  ( );
+};
+
+#endif
\ No newline at end of file
diff --git a/code/RMG/RM_Terrain.cpp b/code/RMG/RM_Terrain.cpp
new file mode 100644
index 0000000..0164651
--- /dev/null
+++ b/code/RMG/RM_Terrain.cpp
@@ -0,0 +1,533 @@
+#include "../server/exe_headers.h"
+
+#include "../client/client.h"
+#include "../qcommon/cm_local.h"
+#include "../renderer/tr_types.h"
+#include "rm_headers.h"
+
+//#include "../qcommon/q_imath.h"
+
+#pragma optimize("", off)
+
+void R_LoadDataImage	( const char *name, byte **pic, int *width, int *height);
+void R_InvertImage		( byte *data, int width, int height, int depth);
+void R_Resample			( byte *source, int swidth, int sheight, byte *dest, int dwidth, int dheight, int components);
+void RE_GetModelBounds	(refEntity_t *refEnt, vec3_t bounds1, vec3_t bounds2);
+
+static CRMLandScape		*rm_landscape;
+static CCMLandScape		*origin_land;
+
+CRMLandScape::CRMLandScape(void)
+{
+	common = NULL;
+	mDensityMap = NULL;
+}
+
+CRMLandScape::~CRMLandScape(void)
+{
+	if(mDensityMap)
+	{
+		Z_Free(mDensityMap);
+		mDensityMap = NULL;
+	}
+}
+
+void CCGHeightDetails::AddModel(const CRandomModel *hd)
+{
+	if(mNumModels < MAX_RANDOM_MODELS)
+	{
+		mTotalFrequency += hd->GetFrequency();
+		mModels[mNumModels++] = *hd;
+	}
+}
+
+void CRMLandScape::AddModel(const int height, int maxheight, const CRandomModel *hd)
+{
+	int		i;
+
+	if(maxheight > HEIGHT_RESOLUTION)
+	{
+		maxheight = HEIGHT_RESOLUTION;
+	}
+
+	for(i = height; hd->GetModel() && (i < maxheight); i++)
+	{
+		mHeightDetails[i].AddModel(hd);
+	}
+}
+
+void CRMLandScape::LoadMiscentDef(const char *td)
+{
+	char				miscentDef[MAX_QPATH];
+	CGenericParser2		parse;
+	CGPGroup			*basegroup, *classes, *items, *model;
+	CGPValue			*pair;
+
+	Com_sprintf(miscentDef, MAX_QPATH, "ext_data/RMG/%s.miscents", Info_ValueForKey(td, "miscentDef"));
+	Com_DPrintf("CG_Terrain: Loading and parsing miscentDef %s.....\n", Info_ValueForKey(td, "miscentDef"));
+
+	if(!Com_ParseTextFile(miscentDef, parse))
+	{
+		Com_sprintf(miscentDef, MAX_QPATH, "ext_data/arioche/%s.miscents", Info_ValueForKey(td, "miscentDef"));
+		if(!Com_ParseTextFile(miscentDef, parse))
+		{
+			Com_Printf("Could not open %s\n", miscentDef);
+			return;
+		}
+	}
+	// The whole file....
+	basegroup = parse.GetBaseParseGroup();
+
+	// The root { } struct
+	classes = basegroup->GetSubGroups();
+	while(classes)
+	{
+		items = classes->GetSubGroups();
+		while(items)
+		{
+			if(!stricmp(items->GetName(), "miscent"))
+			{
+				int			height, maxheight;
+
+				// Height must exist - the rest are optional
+				height = atol(items->FindPairValue("height", "0"));
+				maxheight = atol(items->FindPairValue("maxheight", "255"));
+
+				model = items->GetSubGroups();
+				while(model)
+				{
+					if(!stricmp(model->GetName(), "model"))
+					{
+						CRandomModel	hd;
+
+						// Set defaults
+						hd.SetModel("");
+						hd.SetFrequency(1.0f);
+						hd.SetMinScale(1.0f);
+						hd.SetMaxScale(1.0f);
+
+						pair = model->GetPairs();
+						while(pair)
+						{
+							if(!stricmp(pair->GetName(), "name"))
+							{
+								hd.SetModel(pair->GetTopValue());
+							}
+							else if(!stricmp(pair->GetName(), "frequency"))
+							{
+								hd.SetFrequency((float)atof(pair->GetTopValue()));
+							}
+							else if(!stricmp(pair->GetName(), "minscale"))
+							{
+								hd.SetMinScale((float)atof(pair->GetTopValue()));
+							}
+							else if(!stricmp(pair->GetName(), "maxscale"))
+							{
+								hd.SetMaxScale((float)atof(pair->GetTopValue()));
+							}
+							pair = (CGPValue *)pair->GetNext();
+						}
+						AddModel(height, maxheight, &hd);
+					}
+ 					model = (CGPGroup *)model->GetNext();
+				}
+			}
+			items = (CGPGroup *)items->GetNext();
+		}
+		classes = (CGPGroup *)classes->GetNext();
+	}
+	Com_ParseTextFileDestroy(parse);
+}
+
+void CG_Decrease(byte *work, float lerp, int *info)
+{
+	int		val;
+
+	val = *work - origin_land->irand(2, 5);
+	*work = (byte)Com_Clamp(1, 255, val);
+}
+
+void CRMLandScape::CreateRandomDensityMap(byte *density, int width, int height, int seed)
+{
+//	int			i, border, inc;
+	int			x, y, count;
+//	byte		*work, *work2;
+	CArea		*area;
+	vec3_t		derxelSize, pos;
+	ivec3_t		dmappos;
+	byte		*hm_map = common->GetHeightMap();
+	int			hm_width = common->GetRealWidth();
+	int			hm_height = common->GetRealHeight();
+	int			xpos, ypos, dx, dy;
+	byte		*densityPos = density;
+	bool		foundUneven;
+
+	// Init to linear spread
+	memset(density, 0, width * height);
+
+/*	// Make more prevalent towards the edges
+	border = Com_Clamp(6, 12, (width + height) >> 4);
+
+	for(i = 0; i < border; i++)
+	{
+		inc = (border - i + 1) * 9;
+
+		// Top line
+		work = density + i + (i * width);
+		for(x = i; x < width - i; x++, work++)
+		{
+			*work += (byte)common->irand(inc >> 1, inc);
+		}
+
+		// Left and right edges
+		work = density + i + ((i + 1) * width);
+		work2 = density + (width - i) + ((i + 1) * width);
+		for(y = i + 1; y < height - i - 2; y++, work += width, work2 += width)
+		{
+			*work += (byte)common->irand(inc >> 1, inc);
+			*work2 += (byte)common->irand(inc >> 1, inc);
+		}
+
+		// Bottom line
+		work = density + i + ((height - i - 1) * width);
+		for(x = i; x < width - i; x++, work++)
+		{
+			*work += (byte)common->irand(inc >> 1, inc);
+		}
+	}
+*/
+	count = 0;
+
+	for(y=0;y<height;y++)
+	{
+		for(x=0;x<width;x++,densityPos++)
+		{
+			xpos = (x * hm_width / width);
+			ypos = (y * hm_height / height);
+			ypos = hm_height - ypos - 1;
+
+			if (hm_map[ypos*hm_width + xpos] < 150)
+			{
+				continue;
+			}
+
+			foundUneven = false;
+			for(dx=-4;(dx<=4 && !foundUneven);dx++)
+			{
+				for(dy=-4;(dy<=4 && !foundUneven);dy++)
+				{
+					if (dx == 0 && dy == 0)
+					{
+						continue;
+					}
+					if ((xpos+dx) >= 0 && (xpos+dx) < hm_width && (ypos+dy) >= 0 && (ypos+dy) < hm_height)
+					{
+						if (hm_map[(ypos+dy)*hm_width + (xpos+dx)] < 190)
+						{
+							*densityPos = 205;
+							count++;
+							foundUneven = true;
+						}
+					}
+				}
+			}
+		}
+	}
+
+/*	FILE	*FH;
+
+	FH = fopen("c:\o.raw", "wb");
+	fwrite(hm_map, 1, common->GetRealWidth() * common->GetRealHeight(), FH);
+	fclose(FH);
+
+	FH = fopen("c:\d.raw", "wb");
+	fwrite(density, 1, width*height, FH);
+	fclose(FH);
+*/
+	// Reduce severely for any settlements/buildings/objectives
+	VectorScale(common->GetSize(), 1.0f / width, derxelSize);
+
+	origin_land = common;
+	area = common->GetFirstArea();
+	while(area)
+	{
+		// Skip group types since they encompass to much open area
+		if ( area->GetType ( ) == AT_GROUP )
+		{
+			area = common->GetNextArea();
+			continue;
+		}
+
+		VectorSubtract(area->GetPosition(), common->GetMins(), pos);
+		VectorInverseScaleVector(pos, derxelSize, dmappos);
+		// Damn upside down gensurf
+		dmappos[1] = height - dmappos[1];
+
+		count = ceilf(area->GetRadius() / derxelSize[1]);
+
+		while(count > 0)
+		{
+			CM_CircularIterate(density, width, height, dmappos[0], dmappos[1], 0, count, NULL, CG_Decrease);
+			count--;
+		}
+		area = common->GetNextArea();
+	}
+}
+
+void CRMLandScape::LoadDensityMap(const char *td)
+{
+	char		densityMap[MAX_QPATH];
+	byte		*imageData;
+	int			iWidth, iHeight, seed;
+	char 		*ptr;
+
+	// Fill in with default values
+	mDensityMap = (byte *)Z_Malloc(common->GetBlockCount(), TAG_R_TERRAIN, qfalse);
+	memset(mDensityMap, 128, common->GetBlockCount());
+
+	// Load in density map (if any)
+	Com_sprintf(densityMap, MAX_QPATH, "%s", Info_ValueForKey(td, "densityMap"));
+	if(strlen(densityMap))
+	{
+		Com_DPrintf("CG_Terrain: Loading density map %s.....\n", densityMap);
+		R_LoadDataImage(densityMap, &imageData, &iWidth, &iHeight);
+		if(imageData)
+		{
+			if(strstr(densityMap, "density_"))
+			{
+				seed = strtoul(Info_ValueForKey(td, "seed"),&ptr,10);
+				CreateRandomDensityMap(imageData, iWidth, iHeight, seed);
+			}
+			R_Resample(imageData, iWidth, iHeight, mDensityMap, common->GetBlockWidth(), common->GetBlockHeight(), 1);
+			R_InvertImage(mDensityMap, common->GetBlockWidth(), common->GetBlockHeight(), 1);
+			Z_Free(imageData);
+		}
+	}
+}
+
+CRandomModel *CCGHeightDetails::GetRandomModel(CCMLandScape *land)
+{
+	int		seek, i;
+
+	seek = land->irand(0, mTotalFrequency);
+	for(i = 0; i < mNumModels; i++)
+	{
+		seek -= mModels[i].GetFrequency();
+		if(seek <= 0)
+		{
+			return(mModels + i);
+		}
+	}
+	assert(0);
+	return(NULL);
+}
+#ifndef DEDICATED
+void CRMLandScape::Sprinkle(CCMPatch *patch, CCGHeightDetails *hd, int level)
+{
+	int				i, count, px, py;
+	float			density;
+	vec3_t			origin, scale, angles, bounds[2];
+	refEntity_t		refEnt;
+	CRandomModel	*rm;
+	CArea			area;
+//	int				areaTypes[] = { AT_BSP, AT_OBJECTIVE };
+//	TCGMiscEnt		*data = (TCGMiscEnt *)cl.mSharedMemory;
+//	TCGTrace		*td = (TCGTrace *)cl.mSharedMemory;
+
+//	memset(&refEnt, 0, sizeof(refEntity_t));
+
+	px = patch->GetHeightMapX() / common->GetTerxels();
+	py = patch->GetHeightMapY() / common->GetTerxels();
+	// Get a number -5.3f to 5.3f
+	density = (mDensityMap[px + (common->GetBlockWidth() * py)] - 128) / 24.0f;
+	// ..and multiply that into the count
+	count = Round(common->GetPatchScalarSize() * hd->GetAverageFrequency() * powf(2.0f, density) * 0.001);
+
+	for(i = 0; i < count; i++)
+	{
+		if(!common->irand(0, 10))
+		{
+			vec3_t temp;
+			trace_t tr;
+			float  average;
+
+			rm = hd->GetRandomModel(common);
+
+			refEnt.hModel = re.RegisterModel(rm->GetModelName());
+			refEnt.frame = 0;
+			RE_GetModelBounds(&refEnt, bounds[0], bounds[1]);
+
+			// Calculate the scale using some magic to help ensure that the
+			// scales are never too different from eachother.  Otherwise you
+			// could get an entity that is really small on one axis but huge 
+			// on another.
+			temp[0] = common->flrand(rm->GetMinScale(), rm->GetMaxScale());
+			temp[1] = common->flrand(rm->GetMinScale(), rm->GetMaxScale());
+			temp[2] = common->flrand(rm->GetMinScale(), rm->GetMaxScale());
+
+			// Average of the three random numbers and divide that by two
+			average = ( ( temp[0] + temp[1] + temp[2] ) / 3) / 2;
+
+			// Add in half of the other two numbers and then subtract half the average to prevent.
+			// any number from going beyond the range. If all three numbers were the same then
+			// they would remain unchanged after this calculation.
+			scale[0] = temp[0] + (temp[1]+temp[2]) / 2 - average;
+			scale[1] = temp[1] + (temp[0]+temp[2]) / 2 - average;
+			scale[2] = temp[2] + (temp[0]+temp[1]) / 2 - average;
+
+			angles[0] = 0.0f;
+			angles[1] = common->flrand((float)-M_PI, (float)M_PI);
+			angles[2] = 0.0f;
+
+			VectorCopy(patch->GetMins(), origin);
+			origin[0] += common->flrand(0.0f, common->GetPatchWidth());
+			origin[1] += common->flrand(0.0f, common->GetPatchHeight());
+			// Get above world height
+			float slope = common->GetWorldHeight(origin, bounds, true);
+
+			if (slope > 1.33)
+			{	// spot has too steep of a slope
+				continue;
+			}
+			if(origin[2] < common->GetWaterHeight())
+			{
+				continue;
+			}
+			// very that we aren't dropped too low
+			if (origin[2] < common->CalcWorldHeight(level))
+			{
+				continue;
+			}
+
+			// Hack-ariffic, don't allow them to drop below the big player clip brush.
+			if (origin[2] < 1280 )
+			{
+				continue;
+			}
+			// FIXME: shouldn't be using a hard-coded 1280 number, only allow to spawn if inside player clip brush? 
+	//		if( !(CONTENTS_PLAYERCLIP & VM_Call( cgvm, CG_POINT_CONTENTS )) )
+	//		{
+	//			continue;
+	//		}
+			// Simple radius check for buildings
+/*			area.Init(origin, VectorLength(bounds[0]));
+			if(common->AreaCollision(&area, areaTypes, sizeof(areaTypes) / sizeof(int)))
+			{
+				continue;
+			}*/
+			// Make sure there is no architecture around - doesn't work for ents though =(
+
+			/*
+			memset(td, sizeof(*td), 0);
+			VectorCopy(origin, td->mStart);
+			VectorCopy(bounds[0], td->mMins);
+			VectorCopy(bounds[1], td->mMaxs);
+			VectorCopy(origin, td->mEnd);
+			td->mSkipNumber = -1;
+			td->mMask = MASK_PLAYERSOLID;
+			*/
+			SV_Trace(&tr, origin, bounds[0], bounds[1], origin, -1, (CONTENTS_SOLID|CONTENTS_PLAYERCLIP|CONTENTS_BODY|CONTENTS_TERRAIN));
+
+			/*
+			VM_Call( cgvm, CG_TRACE );
+			if(td->mResult.surfaceFlags & SURF_NOMISCENTS)
+			{
+				continue;
+			}
+			if(td->mResult.startsolid)
+			{
+//				continue;
+			}
+			*/
+			if (tr.surfaceFlags & SURF_NOMISCENTS)
+			{
+				continue;
+			}
+			if (tr.startsolid)
+			{
+//				continue;
+			}
+
+			// Get minimum height of area
+			common->GetWorldHeight(origin, bounds, false);
+			// Account for relative origin
+			origin[2] -= bounds[0][2] * scale[2];
+			origin[2] -= common->flrand(2.0, (bounds[1][2] - bounds[0][2]) / 4);
+			
+			//rwwFIXMEFIXME: Do this properly
+			// Spawn the client model
+			/*
+			strcpy(data->mModel, rm->GetModelName());
+			VectorCopy(origin, data->mOrigin);
+			VectorCopy(angles, data->mAngles);
+			VectorCopy(scale, data->mScale);
+			VM_Call( cgvm, CG_MISC_ENT);
+			*/
+
+			mModelCount++;
+		}
+	}
+}
+#endif // !DEDICATED
+
+void CRMLandScape::SpawnPatchModels(CCMPatch *patch)
+{
+	int					i;
+	CCGHeightDetails	*hd;
+
+//	Rand_Init(10);
+#ifndef DEDICATED
+	for(i = 0; i < 4; i++)
+	{
+		hd = mHeightDetails + patch->GetHeight(i);
+		if(hd->GetNumModels())
+		{
+			Sprinkle(patch, hd, patch->GetHeight(i));
+		}
+	}
+#endif // !DEDICATED
+}
+
+void SpawnPatchModelsWrapper(CCMPatch *patch, void *userdata)
+{
+	CRMLandScape *landscape = (CRMLandScape *)userdata;
+	landscape->SpawnPatchModels(patch);
+}
+
+void RM_CreateRandomModels(int terrainId, const char *terrainInfo)
+{
+	CRMLandScape	*landscape;
+
+	landscape = rm_landscape = new CRMLandScape;
+	landscape->SetCommon(cmg.landScape);
+
+	Com_DPrintf("CG_Terrain: Creating random models.....\n");
+	landscape->LoadMiscentDef(terrainInfo);
+	landscape->LoadDensityMap(terrainInfo);
+	landscape->ClearModelCount();
+	CM_TerrainPatchIterate(landscape->GetCommon(), SpawnPatchModelsWrapper, landscape);
+
+	Com_DPrintf(".....%d random client models spawned\n", landscape->GetModelCount());
+}
+
+void RM_InitTerrain(void)
+{
+	rm_landscape = NULL;
+}
+
+void RM_ShutdownTerrain(void)
+{
+	CRMLandScape 	*landscape;
+
+	landscape = rm_landscape;
+	if(landscape)
+	{
+//			CM_ShutdownTerrain(i);
+		delete landscape;
+		rm_landscape = NULL;
+	}
+}
+
+// end
+
+#pragma optimize("", on)
diff --git a/code/RMG/RM_Terrain.h b/code/RMG/RM_Terrain.h
new file mode 100644
index 0000000..820d2e3
--- /dev/null
+++ b/code/RMG/RM_Terrain.h
@@ -0,0 +1,97 @@
+#pragma once
+#if !defined(RM_TERRAIN_H_INC)
+#define RM_TERRAIN_H_INC
+
+#define MAX_RANDOM_MODELS		8
+
+class CRandomModel
+{
+private:
+	char		mModelName[MAX_QPATH];
+	float		mFrequency;
+	float		mMinScale;
+	float		mMaxScale;
+public:
+	CRandomModel(void) { }
+	~CRandomModel(void) { }
+
+	// Accessors 
+	const bool GetModel( void ) const { return(!!strlen(mModelName)); }
+	const char *GetModelName( void ) const { return(mModelName); }
+	void SetModel(const char *name) { Com_sprintf(mModelName, MAX_QPATH, "%s.md3", name); }
+	const float GetFrequency(void) const { return(mFrequency); }
+	void SetFrequency(const float freq) { mFrequency = freq; }
+	const float GetMinScale(void) const { return(mMinScale); }
+	void SetMinScale(const float minscale) { mMinScale = minscale; }
+	const float GetMaxScale(void) const { return(mMaxScale); }
+	void SetMaxScale(const float maxscale) { mMaxScale = maxscale; }
+};
+
+class CCGHeightDetails
+{
+private:
+	int				mNumModels;
+	int				mTotalFrequency;
+	CRandomModel	mModels[MAX_RANDOM_MODELS];
+public:
+	// Constructors
+	CCGHeightDetails( void ) { memset(this, 0, sizeof(*this)); }
+	~CCGHeightDetails( void ) { }
+
+	// Accessors
+	const int GetNumModels(void) const { return(mNumModels); }
+	const int GetAverageFrequency(void) const { return(mTotalFrequency / mNumModels); }
+
+	// Prototypes
+	void AddModel(const CRandomModel *hd);
+	CRandomModel *GetRandomModel(CCMLandScape *land);
+};
+
+class CCGPatch
+{
+private:
+	class CCMLandScape	*owner;
+	class CCGLandScape	*localowner;
+	CCMPatch			*common;
+public:
+};
+
+class CRMLandScape
+{
+private:
+	CCMLandScape			*common;
+
+	byte					*mDensityMap;							// Data image of model densities
+	int						mModelCount;							// Count of spawned client models
+	CCGHeightDetails		mHeightDetails[HEIGHT_RESOLUTION];		// Array of info specific to height
+
+public:
+	CRMLandScape(void);
+	~CRMLandScape(void);
+
+	// Accessors
+	void SetCommon(CCMLandScape *landscape) { common = landscape; }
+	const CCMLandScape *GetCommon( void ) const { return(common); }
+	const thandle_t GetCommonId( void ) const { return(common->GetTerrainId()); }
+	const int GetTerxels(void) const { return(common->GetTerxels()); }
+	const int GetRealWidth(void) const { return(common->GetRealWidth()); }
+	const float GetPatchScalarSize(void) const { return(common->GetPatchScalarSize()); }
+	const CCGHeightDetails *GetHeightDetail(int height) const { return(mHeightDetails + height); }
+	void ClearModelCount(void) { mModelCount = 0; }
+	const int GetModelCount(void) const { return(mModelCount); }
+
+	// Prototypes
+	void SetShaders(const int height, const qhandle_t shader);
+	void AddModel(const int height, int maxheight, const CRandomModel *hd);
+	void LoadMiscentDef(const char *td);
+	void LoadDensityMap(const char *td);
+	void SpawnPatchModels(CCMPatch *patch);
+	void Sprinkle(CCMPatch *patch, CCGHeightDetails *hd, int level);
+	void CreateRandomDensityMap(byte *imageData, int width, int height, int seed);
+};
+
+void RM_CreateRandomModels(int terrainId, const char *terrainInfo);
+void RM_InitTerrain(void);
+void RM_ShutdownTerrain(void);
+
+#endif // RM_TERRAIN_H_INC
diff --git a/code/RMG/vssver.scc b/code/RMG/vssver.scc
new file mode 100644
index 0000000..2f374f9
Binary files /dev/null and b/code/RMG/vssver.scc differ
diff --git a/code/Ragl/graph_region.h b/code/Ragl/graph_region.h
new file mode 100644
index 0000000..6339bc4
--- /dev/null
+++ b/code/Ragl/graph_region.h
@@ -0,0 +1,419 @@
+////////////////////////////////////////////////////////////////////////////////////////
+// RAVEN STANDARD TEMPLATE LIBRARY
+//  (c) 2002 Activision
+//
+//
+// Graph Region
+// ------------
+//
+//
+////////////////////////////////////////////////////////////////////////////////////////
+#if !defined(RATL_GRAPH_REGION_INC)
+#define RATL_GRAPH_REGION_INC
+
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Includes
+////////////////////////////////////////////////////////////////////////////////////////
+#if defined(RA_DEBUG_LINKING)
+	#pragma message("...including graph_region.h")
+#endif
+#if !defined(RAGL_COMMON_INC)
+	#include "ragl_common.h"
+#endif
+#if !defined(RAGL_GRAPH_VS_INC)
+	#include "graph_vs.h"
+#endif
+
+namespace ragl
+{
+
+
+
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// The Graph Region Class
+////////////////////////////////////////////////////////////////////////////////////////
+template <class TNODE, int MAXNODES, class TEDGE, int MAXEDGES, int NUM_EDGES_PER_NODE,    int MAXREGIONS, int MAXREGIONEDGES>
+class graph_region : public ratl::ratl_base
+{
+public:
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Capacity Enum
+    ////////////////////////////////////////////////////////////////////////////////////
+ 	enum 
+	{
+		NULL_REGION	= -1,
+		NULL_EDGE	= -1,
+		CAPACITY	= MAXREGIONS
+	};
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Some Public Type Defines
+    ////////////////////////////////////////////////////////////////////////////////////
+	typedef		ragl::graph_vs<TNODE, MAXNODES, TEDGE, MAXEDGES, NUM_EDGES_PER_NODE>	TGraph;
+	typedef		ratl::vector_vs<int, MAXNODES>						TRegions;		
+	typedef		ratl::vector_vs<short, MAXREGIONS>					TRegionEdge;	// List Of All Edges Which Connect RegionA<->RegionB
+	typedef		ratl::pool_vs<TRegionEdge, MAXREGIONEDGES>			TEdges;			// Pool Of All RegionEdges
+	typedef		ratl::grid2_vs<short, MAXREGIONS, MAXREGIONS>		TLinks;			// Graph Of Links From Region To Region, Each Points To A RegionEdge
+	typedef		ratl::bits_vs<MAXREGIONS>							TClosed;
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Constructor
+    ////////////////////////////////////////////////////////////////////////////////////
+	graph_region(TGraph& Graph)	: mGraph(Graph)
+	{
+		clear();
+	}
+	~graph_region()
+	{
+	}
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Clear Out All Temp Data So We Can Recalculate Regions
+    ////////////////////////////////////////////////////////////////////////////////////
+	void	clear()
+	{
+		mRegions.resize(0, (int)NULL_REGION);
+		mRegions.resize(MAXNODES, (int)NULL_REGION);
+		mRegionCount = 0;
+		mReservedRegionCount = 0;
+
+		mLinks.init(NULL_EDGE);
+
+		for (int i=0; i<MAXREGIONEDGES; i++)
+		{
+			if (mEdges.is_used(i))
+			{
+				mEdges[i].resize(0, NULL_EDGE);
+			}
+		}
+		mEdges.clear();
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// How Many Regions Have Been Created
+    ////////////////////////////////////////////////////////////////////////////////////
+	int		size()
+	{
+		return mRegionCount;
+	}
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Get The Region For A Given Node
+    ////////////////////////////////////////////////////////////////////////////////////
+	int		get_node_region(int Node)
+	{
+		return mRegions[mGraph.node_index(Node)];
+	}
+
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Call this function to find out if it is at all possible to get from nodeA to
+	// nodeB.  If there is no possible connection, or there is one, but the connection 
+	// is not valid at the current time, this routine will return false.  Use it as
+	// a quick cull routine before a search.
+	//
+	// In order to use this function, you must have an EdgeQuery class (use the default
+	// above, or derive your own for more specialized behavior).
+    ////////////////////////////////////////////////////////////////////////////////////
+	bool	has_valid_edge(int NodeA, int NodeB, const typename TGraph::user& user)
+	{
+		int	RegionA = mRegions[NodeA];
+		int	RegionB = mRegions[NodeB];
+
+		if (RegionA==RegionB)
+		{
+			return true;
+		}
+
+		mClosed.clear();
+
+		return has_valid_region_edge(RegionA, RegionB, user);
+	}
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Reserve Region
+	//
+	// Allows a user to pre-allocate a special region for a group of points
+    ////////////////////////////////////////////////////////////////////////////////////
+	int		reserve()
+	{
+		assert(mRegionCount < (MAXREGIONS-1));
+		if (mRegionCount >= (MAXREGIONS-1) )
+		{//stop adding points, we're full, you MUST increase MAXREGIONS for this to work
+			return NULL_REGION;
+		}
+		mReservedRegionCount ++;
+		mRegionCount ++;
+		return (mRegionCount);
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// assign_region
+	//
+	// Allows a user to pre-allocate a special region for a group of points
+    ////////////////////////////////////////////////////////////////////////////////////
+	void	assign_region(int NodeIndex, int RegionIndex)
+	{
+		mRegions[NodeIndex] = RegionIndex;
+	}
+
+
+
+
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Define Regions
+	//
+	// Scan through all the nodes (calling the depth first recursive traversal below),
+	// and mark regions of nodes which can traverse to one another without needing to check
+	// for valid edges.
+	//
+    ////////////////////////////////////////////////////////////////////////////////////
+	bool	find_regions(const typename TGraph::user& user)
+	{
+		int		CurNodeIndex;
+		for (TGraph::TNodes::iterator i=mGraph.nodes_begin(); i!=mGraph.nodes_end(); i++)
+		{
+			CurNodeIndex = i.index();
+			if (mRegions[CurNodeIndex] == NULL_REGION)
+			{
+				assert(mRegionCount < (MAXREGIONS-1));
+				if (mRegionCount >= (MAXREGIONS-1) )
+				{//stop adding points, we're full, you MUST increase MAXREGIONS for this to work
+					return false;
+				}
+				mRegionCount ++;				// Allocate The New Region
+				assign(CurNodeIndex, user);		// Assign All Points To It
+			}
+		}
+		mRegionCount ++;		// Size is actually 1 greater than the number of regions
+		return true;
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Search For All Possible Edges Which Connect Regions
+	//
+	// Once called, this class will have reference data for how to get from one region
+	// to another.
+    ////////////////////////////////////////////////////////////////////////////////////
+	bool	find_region_edges()
+	{
+		int		RegionA;
+		int		RegionB;
+		int		RegionLink;
+		bool	Success = true;
+		bool	ReservedRegionLink;
+
+		for (int indexA=0; indexA<MAXNODES; indexA++)
+		{
+			RegionA = mRegions[indexA];
+			if (RegionA!=NULL_REGION)
+			{
+				for (int indexB=0; indexB<MAXNODES; indexB++)
+				{
+					RegionB				= mRegions[indexB];
+					ReservedRegionLink	= (RegionA<=mReservedRegionCount || RegionB<=mReservedRegionCount);
+					if (RegionB!=NULL_REGION && RegionB!=RegionA && mGraph.get_edge_across(indexA, indexB))
+					{
+						RegionLink = mLinks.get(RegionA, RegionB);
+
+						// Do We Need To Allocate A New Region Link Vector?
+						//--------------------------------------------------
+						if (RegionLink==-1)
+						{
+							if (ReservedRegionLink)
+							{
+								mLinks.get(RegionA, RegionB) = -2;		// Special Flag For Reserved Regions - they have no edges
+								mLinks.get(RegionB, RegionA) = -2;
+							}
+							else
+							{
+								if (mEdges.full())
+								{
+									assert("graph_region: Too Many Region Edges"==0);
+									Success = false;
+								}
+								else
+								{
+									RegionLink = mEdges.alloc();
+									mEdges[RegionLink].resize(0, NULL_EDGE);
+									mEdges[RegionLink].push_back(mGraph.get_edge_across(indexA, indexB));
+
+									mLinks.get(RegionA, RegionB) = RegionLink;
+									mLinks.get(RegionB, RegionA) = RegionLink;
+								}
+							}
+						}
+
+						
+						// Add This Edge To The Other Region Links
+						//-----------------------------------------
+						else if (!ReservedRegionLink)
+						{
+							mEdges[RegionLink].push_back(mGraph.get_edge_across(indexA, indexB));
+						}
+					}
+				}
+			}
+		}
+		return Success;
+	}
+
+private:
+    ////////////////////////////////////////////////////////////////////////////////////
+	// This Routine Is A Depth First Recursive Traversal
+	//
+	// It will visit all neighbors for each node which have not already been visited
+	// and assigned to a region.  Neighbors must always be valid.
+    ////////////////////////////////////////////////////////////////////////////////////
+	void	assign(int Node, const typename TGraph::user& user)
+	{
+		mRegions[Node] = mRegionCount;
+		for (int i=0; i<MAXNODES; i++)
+		{
+			if (mRegions[i]==-1)
+			{
+				int edgeNum = mGraph.get_edge_across(Node, i);
+				if (edgeNum && !user.can_be_invalid(mGraph.get_edge(edgeNum)))
+				{
+					assign(i, user);
+				}
+			}
+		}
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// This Routine Is A Depth First Recursive Search For Target Region
+	//
+	// Visited regions are makred on the "closed" bit field.
+    ////////////////////////////////////////////////////////////////////////////////////
+	bool	has_valid_region_edge(int CurRegion, int TargetRegion, const typename TGraph::user& user)
+	{
+		// Mark The Cur Region As Visited, So We Don't Try To Return To It
+		//-----------------------------------------------------------------
+		mClosed.set_bit(CurRegion);
+
+		// If The Two Nodes Are In The Same Region, Then This Is Valid
+		//-------------------------------------------------------------
+		if (CurRegion==TargetRegion)
+		{
+			return true;
+		}
+
+		// Scan Through The Cur Region's Neighbors With Currently Valid Region Edges
+		//---------------------------------------------------------------------------
+		int	CurRegionEdge;
+		for (int NextRegion=0; NextRegion<mRegionCount; NextRegion++)
+		{
+			// Check If The Link Exists And We Have Not Already Visited The Next Region
+			//--------------------------------------------------------------------------
+			CurRegionEdge = mLinks.get(CurRegion, NextRegion);
+			if (CurRegionEdge!=NULL_EDGE && !mClosed.get_bit(NextRegion))
+			{
+				if (CurRegion<=mReservedRegionCount)
+				{
+					// Great, So We Have Found A Valid Neighboring Region, Search There
+					//------------------------------------------------------------------
+					if (has_valid_region_edge(NextRegion, TargetRegion, user))
+					{
+						return true;		// HEY!  Somehow, Going To Next Region Got Us To The Target Region!
+					}
+				}
+				else
+				{
+					// Scan Through This Region Edge List Of Graph Edges For Any Valid One
+					//---------------------------------------------------------------------
+					assert(mEdges[CurRegionEdge].size()>0);
+					for (int j=0; j<mEdges[CurRegionEdge].size(); j++)
+					{
+						if (user.is_valid(
+										mGraph.get_edge(mEdges[CurRegionEdge][j]), 
+										(NextRegion==TargetRegion)?(-1):(0)
+										)
+							)
+						{
+							// Great, So We Have Found A Valid Neighboring Region, Search There
+							//------------------------------------------------------------------
+							if (has_valid_region_edge(NextRegion, TargetRegion, user))
+							{
+								return true;		// HEY!  Somehow, Going To Next Region Got Us To The Target Region!
+							}
+
+							// Ok, The Target Region Turned Out To Be A Dead End, We Can Stop Trying To Get There
+							//------------------------------------------------------------------------------------
+							break;
+						}
+					}
+				}
+			}
+		}
+
+		// Nope, We Failed To Find Any Valid Region Edges Which Lead To The Target Region
+		//--------------------------------------------------------------------------------
+		return false;
+	}
+
+
+private:
+	////////////////////////////////////////////////////////////////////////////////////
+	//
+	////////////////////////////////////////////////////////////////////////////////////
+	TGraph&			mGraph;
+
+	TRegions		mRegions;
+	int				mRegionCount;
+	int				mReservedRegionCount;
+
+	TLinks			mLinks;
+	TEdges			mEdges;
+	TClosed			mClosed;
+
+
+
+
+
+public:
+#if !defined(FINAL_BUILD)
+	void	ProfileSpew()
+	{
+		ProfilePrint("");
+		ProfilePrint("");
+		ProfilePrint("--------------------------------------------------------");
+		ProfilePrint("RAVEN STANDARD LIBRARY  -  COMPUTATIONAL GEOMETRY MODULE");
+		ProfilePrint("              Region Profile Results                    ");
+		ProfilePrint("--------------------------------------------------------");
+		ProfilePrint("");
+		ProfilePrint("REGION SIZE (Bytes): (%d)  (KiloBytes): (%5.3f)", sizeof(*this), ((float)(sizeof(*this))/1024.0f));
+		ProfilePrint("REGION COUNT: (%d) Regions  (%d) Edges", mRegionCount, mEdges.size());
+		if (mRegionCount)
+		{
+			int RegionEdges = 0;
+			for (TEdges::iterator it=mEdges.begin(); it!=mEdges.end(); it++)
+			{
+				RegionEdges += (*it).size();
+			}
+			ProfilePrint("REGION COUNT: (%f) Ave Edges Size", (float)RegionEdges / (float)mRegionCount);
+		}
+		ProfilePrint("");
+	};
+#endif
+
+};
+
+
+}
+
+
+
+#endif
\ No newline at end of file
diff --git a/code/Ragl/graph_triangulate.h b/code/Ragl/graph_triangulate.h
new file mode 100644
index 0000000..b130c82
--- /dev/null
+++ b/code/Ragl/graph_triangulate.h
@@ -0,0 +1,833 @@
+////////////////////////////////////////////////////////////////////////////////////////
+// RAVEN STANDARD TEMPLATE LIBRARY
+//  (c) 2002 Activision
+//
+//
+// Graph Triangulate
+// -----------------
+// Triangulation is the process of generating graph edges between "nearby" points.
+//
+// This class is designed to work with the ragl_graph template class, and requires that
+// the same template parameters for that class be used here.  The memory requirements
+// of this class are not inconsequential, so it is best to allocate this class during
+// a preprocess step and then throw it away.
+//
+// NOTE: This is a 2D triangulation!  All Z Coordinates are ignored!
+//
+//
+//
+//
+// How Do I Triangulate A Raw Set Of Points?
+// -----------------------------------------
+// First of all, in order to construct a triangulation, you need to have your graph and
+// pass it in to the constructor:
+//
+//   typedef	ragl::graph_triangulate<TNODE, MAXNODES, TEDGE, MAXEDGES>	TTriangulation
+//   TTriangulation		MyTriangulation(mMyGraph);
+//
+// Next, you are free to call any of the public functions in any order, but the best use
+// is to call them in this order:
+//
+//   MyTriangulation.insertion_hull();
+//   MyTriangulation.delaunay_edge_flip();
+//   MyTriangulation.alpha_shape(MyGraphUser, <MIN>, <MAX>);
+//
+// For documentation on the above functions, look at their def below.  Also, the doc on
+// the Graph User class is in graph_vs.h
+//
+//
+// Finally, when you are ready, call the finish() function.  That will populate your
+// graph (which has not been altered in any way up until now).  After calling finish()
+// you can dump the triangulation class, as it has done it's job and all the data is
+// now stored in the class.
+//
+//   MyTriangulation.finish();
+//
+//
+//
+//
+// How Does It Work?  (Overview)
+// -----------------------------
+// The details of how each step works are outlined below, however, here is the general
+// idea:
+//
+// - Call insertion hull to generate a "rough and dirty" triangulation of the point set.
+//   The algorithm is relativly fast, and as a handy bi-product, generates the convex
+//   hull of the points.  The resulting mesh is ugly though.  You probably won't want
+//   to use it in the rough state.  The basic idea of this algorithm is to iterativly
+//   add points which have been presorted along the x-axis into the triangulation.  It
+//   is easy to do so, because you always know it will be on the right side of any edge
+//   it needs to connect with.
+//
+// - Now that you have a functional triangulation with edges and faces, there is fairly
+//   simple and fast algorithm to "clean it up" called EdgeFlipping.  The idea is simple.
+//   Just scan through the edges, if you find one that is "bad", flip it!  Continue until
+//   you find no "bad" edges.  NOTE: This algorithm can lock up if any four points are
+//   colinear!
+//
+// - Finally, Alpha Shape is just a simple prune scan of the edges for anything that is
+//   too big or too small.  This step is totally optional.
+//
+//
+////////////////////////////////////////////////////////////////////////////////////////
+#if !defined(RATL_GRAPH_TRIANGULATE_INC)
+#define RATL_GRAPH_TRIANGULATE_INC
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Includes
+////////////////////////////////////////////////////////////////////////////////////////
+#if defined(RA_DEBUG_LINKING)
+	#pragma message("...including graph_triangulate.h")
+#endif
+#if !defined(RAGL_COMMON_INC)
+	#include "ragl_common.h"
+#endif
+#if !defined(RAGL_GRAPH_VS_INC)
+	#include "graph_vs.h"
+#endif
+#if !defined(RATL_LIST_VS_INC)
+	#include "..\Ratl\list_vs.h"
+#endif
+namespace ragl
+{
+
+
+
+
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// The Graph Class
+////////////////////////////////////////////////////////////////////////////////////////
+template <class TNODE, int MAXNODES, class TEDGE, int MAXEDGES, int MAXNODENEIGHBORS>
+class graph_triangulate : public ratl::ratl_base
+{
+public:
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Capacity Enum
+    ////////////////////////////////////////////////////////////////////////////////////
+ 	enum 
+	{
+		CAPACITY = MAXNODES,
+		MAXFACES = MAXEDGES*2,
+		NULLEDGE = -1
+	};
+
+	typedef		graph_vs<TNODE, MAXNODES, TEDGE, MAXEDGES, MAXNODENEIGHBORS>			TGraph;
+
+
+public:
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Constructor
+    ////////////////////////////////////////////////////////////////////////////////////
+	graph_triangulate(TGraph& Graph)	: mGraph(Graph), mHull(), mHullIter(mHull.begin())
+	{
+		mLinks.init(0);
+	}
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Clear Out All Temp Data So We Can Triangulate Again
+    ////////////////////////////////////////////////////////////////////////////////////
+	void	clear()
+	{
+		mLinks.init(0);
+		mEdges.clear();
+		mFaces.clear();
+
+		mHull.clear();
+		mHullIter = mHull.begin();
+
+		mSortNodes.clear();
+	}
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Insertion Hull
+	//
+	// This is a "quick and dirty" triangulation technique.  It does not give you a very
+	// nice looking or terribly useful mesh, but it is a good place to start.  Once
+	// you have an insertion hull triangulation, you can call delauny_edge_flip() to 
+	// clean it up some.
+	//
+	// This algorithm's complexity isbounded in the worst case where all the points in 
+	// the mesh are on the "hull", in which case it is O(n^2).  However the number of
+	// points on the hull for most common point clouds is more likely to be log n.
+	//
+    ////////////////////////////////////////////////////////////////////////////////////
+	void	insertion_hull()
+	{
+		assert(mGraph.size_nodes()>3);		// We Need More Than 3 Points To Triangulate
+
+		// STEP ONE: Sort all points along the x axis in increasing order
+		//----------------------------------------------------------------
+		// COMPLEXITY: O(n log n)    Heapsort
+
+		sort_points();
+
+
+
+		// STEP TWO: Manually constructe the first face of the triangulation out of the 3 rightmost points
+		//--------------------------------------------------------------------------------------------------
+		// COMPLEXITY: O(1)
+
+		add_face(mSortNodes[0].mNodeHandle, mSortNodes[1].mNodeHandle, mSortNodes[2].mNodeHandle);
+
+
+
+		// STEP THREE: Add each remaining point to the hull, constructing new faces as we go
+		//-----------------------------------------------------------------------------------
+		// COMPLEXITY: O(n*c)  (n = num nodes,   c = num nodes on hull)
+
+		for (int i=3; i<mSortNodes.size(); i++)
+		{
+			insert_point(mSortNodes[i].mNodeHandle);
+		}
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Delaunay Edge Flipping
+	//
+	// This algorithm iterativly rotates edges which do not fit the "delaunay" criterion
+	// of all points on two adjacent faces containment within the circumscribed circles
+	// of the two faces.  It solves the all pairs nearest neighbors problem.
+	//
+	// The routine is sadly bounded by n^2 complexity, but in practice perfromes very
+	// well - much better than n^2 (closer to n log n).
+	//
+    ////////////////////////////////////////////////////////////////////////////////////
+	void	delaunay_edge_flip()
+	{
+		int	CurFlipped;
+		int	TotalFlipped = 0;
+
+		do
+		{
+			CurFlipped = flip();
+			TotalFlipped += CurFlipped;
+		}
+		while (CurFlipped!=0 && TotalFlipped<10000 /*Sanity Condition*/);
+	}
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// This function attempts to prune out edges which connect across "floors" and
+	//
+	//
+	//
+	////////////////////////////////////////////////////////////////////////////////////
+	void	floor_shape(typename TGraph::user& user, float maxzdelta)
+	{
+		ratl::vector_vs<int, MAXEDGES>		CullEdges;
+		int		nEdge;
+		TEdges::iterator stop=mEdges.end();
+		for (TEdges::iterator it=mEdges.begin(); it!=mEdges.end(); it++)
+		{
+			if (!(*it).mOnHull)
+			{
+				edge&	EdgeAt	= *it;
+				face&	FaceR	= mFaces[EdgeAt.mRight];
+				face&	FaceL	= mFaces[EdgeAt.mLeft];
+
+//				int		Edge	= mEdges.index_to_handle(it.index());
+				int		R		= FaceR.opposing_node(EdgeAt.mA, EdgeAt.mB);
+				int		L		= FaceL.opposing_node(EdgeAt.mA, EdgeAt.mB);
+				int		RInd	= mGraph.node_index(R);
+				int		LInd	= mGraph.node_index(L);
+
+				TNODE&	PtA		= mGraph.get_node(EdgeAt.mA);
+				TNODE&	PtB		= mGraph.get_node(EdgeAt.mB);
+				TNODE&	PtR		= mGraph.get_node(R);
+				TNODE&	PtL		= mGraph.get_node(L);
+
+
+				if (
+					(user.on_same_floor(PtR, PtL)) &&
+					(mLinks.get(RInd, LInd)==0) &&
+					(mLinks.get(LInd, RInd)==0) &&
+					(!user.on_same_floor(PtL, PtA) || !user.on_same_floor(PtL, PtB))
+				   )
+				{
+					nEdge= mEdges.alloc();
+
+					mEdges[nEdge].mA		= R;
+					mEdges[nEdge].mB		= L;
+					mEdges[nEdge].mHullLoc	= mHullIter;
+					mEdges[nEdge].mOnHull	= true;
+					mEdges[nEdge].mFlips	= 0;
+					mEdges[nEdge].mLeft		= 0;
+					mEdges[nEdge].mRight	= 0;
+
+
+					mLinks.get(RInd, LInd) = nEdge;
+					mLinks.get(LInd, RInd) = nEdge;
+				}
+
+				if (!user.on_same_floor(PtA, PtB))
+				{
+					mLinks.get(mGraph.node_index(EdgeAt.mA), mGraph.node_index(EdgeAt.mB)) = 0;
+					mLinks.get(mGraph.node_index(EdgeAt.mB), mGraph.node_index(EdgeAt.mA)) = 0;
+					
+					CullEdges.push_back(it.index());
+				}
+			}
+		}
+
+		for (int i=0; i<CullEdges.size(); i++)
+		{
+			mEdges.free_index(CullEdges[i]);
+		}
+	}
+
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// This function is a simple routine to prune out any edges which are larger or
+	// smaller than the desired range (min, max).
+    ////////////////////////////////////////////////////////////////////////////////////
+	void	alpha_shape(typename TGraph::user& user, float max, float min=0)
+	{
+		ratl::vector_vs<int, MAXEDGES>		CullEdges;
+		float cost;
+		for (TEdges::iterator it=mEdges.begin(); it!=mEdges.end(); it++)
+		{
+			cost = user.cost(mGraph.get_node((*it).mA), mGraph.get_node((*it).mB));
+			if (cost<min || cost>max)
+			{
+				mLinks.get(mGraph.node_index((*it).mA), mGraph.node_index((*it).mB)) = 0;
+				mLinks.get(mGraph.node_index((*it).mB), mGraph.node_index((*it).mA)) = 0;
+				
+				CullEdges.push_back(it.index());
+			}
+		}
+
+		for (int i=0; i<CullEdges.size(); i++)
+		{
+			mEdges.free_index(CullEdges[i]);
+		}
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Call this function when you are done with the triangulation and want to copy all
+	// the temp data into your graph.
+    ////////////////////////////////////////////////////////////////////////////////////
+	void	finish(typename TGraph::user& user)
+	{
+		mGraph.clear_edges();
+		TEDGE	DefaultEdge;
+		for (TEdges::iterator it=mEdges.begin(); it!=mEdges.end(); it++)
+		{
+			user.setup_edge(DefaultEdge, (*it).mA, (*it).mB, (*it).mOnHull, mGraph.get_node((*it).mA), mGraph.get_node((*it).mB));
+			mGraph.connect_node(DefaultEdge, (*it).mA, (*it).mB);
+		}
+	}
+
+
+
+
+
+private:
+	////////////////////////////////////////////////////////////////////////////////////
+	//
+	////////////////////////////////////////////////////////////////////////////////////
+	typedef		typename ratl::list_vs<int, MAXNODES>						THull;
+	typedef		typename ratl::list_vs<int, MAXNODES>::iterator				THullIter;
+	typedef		typename ratl::grid2_vs<int,	MAXNODES, MAXNODES>				TLinks;
+
+    
+	////////////////////////////////////////////////////////////////////////////////////
+	// The Local Edge Class
+	//
+	//       RIGHT    
+	//   B<-<-<-<-<-<-A 
+	//       LEFT    
+	//
+    ////////////////////////////////////////////////////////////////////////////////////
+	class	edge
+	{
+	public:
+		int			mA;
+		int			mB;
+
+		int			mLeft;
+		int			mRight;
+		int			mFlips;
+
+		THullIter	mHullLoc;
+		bool		mOnHull;
+
+		void		flip_face(int OldFace, int NewFace)
+		{
+			assert(mRight!=mLeft);
+			assert(mLeft!=NewFace && mRight!=NewFace);
+			if (mLeft==OldFace)
+			{
+				mLeft=NewFace;
+			}
+			else
+			{
+				assert(mRight==OldFace);
+				mRight = NewFace;
+			}
+			assert(mRight!=mLeft);
+		}
+		void	verify(int PtA, int PtB, int Edge)
+		{
+			assert(PtA==mA || PtA==mB);
+			assert(PtB==mA || PtB==mB);
+			assert(mRight==Edge || mLeft==Edge);
+			assert(mRight!=mLeft);
+			assert(mA!=mB);
+		}
+		void	verify(int PtA, int PtB, int PtC, int Edge)
+		{
+			assert((PtC==mA && (PtA==mB || PtB==mB)) || (PtC==mB && (PtA==mA || PtB==mA)));
+
+			assert(mRight==Edge || mLeft==Edge);
+			assert(mRight!=mLeft);
+			assert(mA!=mB);
+		}
+	};
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// The Local Face Class
+	// 
+	//       _ C
+	//       /|  \
+	//  LEFT/     \RIGHT
+	//     /       \  
+	//    B-<-<-<-<-A 
+	//       BOTTOM    
+	//  
+    ////////////////////////////////////////////////////////////////////////////////////
+	class	face
+	{
+	public:
+		int			mA;
+		int			mB;
+		int			mC;
+
+		int			mLeft;
+		int			mRight;
+		int			mBottom;
+
+		int			mFlips;
+
+		int&		opposing_node(int A, int B)
+		{
+			if (mA!=A && mA!=B)
+			{
+				return mA;
+			}
+			if (mB!=A && mB!=B)
+			{
+				return mB;
+			}
+			assert(mC!=A && mC!=B);
+			return mC;
+		}
+
+		int&		relative_left(int edge)
+		{
+			if (edge==mLeft)
+			{
+				return mRight;
+			}
+			if (edge==mRight)
+			{
+				return mBottom;
+			}
+			assert(edge==mBottom);	// If you hit this assert, then the edge is not in this face
+			return mLeft;
+		}
+		int&		relative_right(int edge)
+		{
+			if (edge==mLeft)
+			{
+				return mBottom;
+			}
+			if (edge==mRight)
+			{
+				return mLeft;
+			}
+			assert(edge==mBottom);	// If you hit this assert, then the edge is not in this face
+			return mRight;
+		}
+	};
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// The Sort Node Class
+	//
+	// Used To Sort Nodes In Increasing X Order
+    ////////////////////////////////////////////////////////////////////////////////////
+	class	sort_node
+	{
+	public:
+		bool			operator<(const sort_node& r) const
+		{
+			return ((*r.mNodePointer)[0] < (*mNodePointer)[0]);
+		}
+
+		int		mNodeHandle;
+		TNODE*	mNodePointer;
+	};
+
+
+	////////////////////////////////////////////////////////////////////////////////////
+	//
+	////////////////////////////////////////////////////////////////////////////////////
+	typedef		typename ratl::handle_pool_vs<edge,	MAXEDGES>				TEdges;
+	typedef		typename ratl::handle_pool_vs<edge,	MAXEDGES>::iterator		TEdgesIter;
+	typedef		typename ratl::handle_pool_vs<face,	MAXFACES>				TFaces;
+	typedef		typename ratl::vector_vs<sort_node, MAXNODES>				TSortNodes;
+
+
+	TGraph&		mGraph;			// A Reference To The Graph Points To Triangulate
+
+	TLinks		mLinks;
+	TEdges		mEdges;
+	TFaces		mFaces;
+
+	THull		mHull;			// The Convex Hull
+	THullIter	mHullIter;
+
+	TSortNodes	mSortNodes;		// Need To Presort Nodes On (x-Axis) For Insertion Hull
+	sort_node	mSortNode;
+
+
+
+
+private:
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Copy All The Graph Nodes To Our Sort Node Class And Run Heap Sort
+    ////////////////////////////////////////////////////////////////////////////////////
+	void	sort_points()
+	{
+		mSortNodes.clear();
+		for (TGraph::TNodes::iterator i=mGraph.nodes_begin(); i!=mGraph.nodes_end(); i++)
+		{
+			mSortNode.mNodeHandle	= mGraph.node_handle(i);
+			mSortNode.mNodePointer	= &(*i);
+			mSortNodes.push_back(mSortNode);
+		}
+		mSortNodes.sort();		
+
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Create A New Edge A->B, And Fix Up The Face
+    ////////////////////////////////////////////////////////////////////////////////////
+	int		add_edge(int A, int B, int Face=0, bool OnHull=true)
+	{
+		assert(A!=B );
+
+		int	nEdge = mLinks.get(mGraph.node_index(A), mGraph.node_index(B));
+
+		// Apparently This Edge Does Not Exist, So Make A New One
+		//--------------------------------------------------------
+		if (nEdge==0)
+		{
+			nEdge= mEdges.alloc();
+			
+			mHull.insert_after(mHullIter, nEdge);
+			assert(mHullIter!=mHull.end());
+
+			mEdges[nEdge].mA		= A;
+			mEdges[nEdge].mB		= B;
+			mEdges[nEdge].mHullLoc	= mHullIter;
+			mEdges[nEdge].mOnHull	= true;
+			mEdges[nEdge].mFlips	= 0;
+			mEdges[nEdge].mLeft		= 0;
+			mEdges[nEdge].mRight	= 0;
+
+
+			mLinks.get(mGraph.node_index(A), mGraph.node_index(B)) = nEdge;
+			mLinks.get(mGraph.node_index(B), mGraph.node_index(A)) = nEdge;
+		}
+
+		// If This Edge DOES Already Exist, Then We Need To Remove It From The Hull
+		//--------------------------------------------------------------------------
+		else if (mEdges[nEdge].mOnHull)
+		{
+			assert(mEdges[nEdge].mHullLoc!=mHull.end());
+
+			if (mHullIter==mEdges[nEdge].mHullLoc)
+			{
+				mHull.erase(mHullIter);					// Make Sure To Fix Up The Hull Iter If That Is What We Are Removing
+			}
+			else
+			{
+				mHull.erase(mEdges[nEdge].mHullLoc);
+			}
+			mEdges[nEdge].mOnHull = false;
+		}
+
+
+		// If The Edge Was Made With The Same Orientation Currently Asked For (A->B), Then Mark Face As Right
+		//----------------------------------------------------------------------------------------------------
+		if (mEdges[nEdge].mA==A)
+		{
+			mEdges[nEdge].mRight	= Face;
+		}
+		else
+		{
+			mEdges[nEdge].mLeft		= Face;
+		}
+		return nEdge;
+	}
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Create A New Face A->B->C, And Fix Up The Edges & Neighboring Faces
+    ////////////////////////////////////////////////////////////////////////////////////
+	int		add_face(int A, int B, int C)
+	{
+		int		Temp	= 0;
+		int		nFace	= mFaces.alloc();
+
+		// First, Make Sure Node A.x Is Greater Than B and C.  If Not, Swap With B or C
+		//------------------------------------------------------------------------------
+		if (mGraph.get_node(B)[0]>mGraph.get_node(A)[0])
+		{
+			Temp	= A;
+			A		= B;
+			B		= Temp;
+		}
+		if (mGraph.get_node(C)[0]>mGraph.get_node(A)[0])
+		{
+			Temp	= A;
+			A		= C;
+			C		= Temp;
+		}
+
+		// Similarly, Make Sure Node B.y Is Greater Than Node C.y
+		//--------------------------------------------------------
+		if (mGraph.get_node(C).LRTest(mGraph.get_node(A), mGraph.get_node(B))==Side_Left)
+		{
+			Temp	= C;
+			C		= B;
+			B		= Temp;
+		}
+
+		// DEBUG ASSERTS
+		//====================================================================================
+		// IF YOU HIT THESE ASSERTS, CHANCES ARE THAT YOU ARE TRYING TO TRIANGULATE OVER A SET
+		// WITH MORE THAN 2 COLINEAR POINTS ON THE SAME FACE.  INSERT HULL WILL FAIL IN THIS 
+		// FACE.  INSERT HULL WILL FAIL IN THIS SITUATION
+		
+		assert(mGraph.get_node(C).LRTest(mGraph.get_node(A), mGraph.get_node(B))==Side_Right);
+		assert(mGraph.get_node(A).LRTest(mGraph.get_node(B), mGraph.get_node(C))==Side_Right);
+		assert(mGraph.get_node(B).LRTest(mGraph.get_node(C), mGraph.get_node(A))==Side_Right);
+		//====================================================================================
+
+		mFaces[nFace].mA		= A;
+		mFaces[nFace].mB		= B;
+		mFaces[nFace].mC		= C;
+
+		mFaces[nFace].mRight	= add_edge(C, A, nFace);
+		mFaces[nFace].mBottom	= add_edge(A, B, nFace);
+		mFaces[nFace].mLeft		= add_edge(B, C, nFace);
+
+		mFaces[nFace].mFlips	= 0;
+
+		return nFace;
+	}
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Insertion Hull Triangulation
+	//
+	// This algorithm works by scanning the outer convex hull of the set of points that
+	// have already been triangulated.  When encountering a hull edge which evaluates
+	// LEFT in a left right test (remember, the triangles always have clockwise orientation)
+	// it adds a face to the triangulation including the edge as one side of the triangle
+	// and two new edges to the node handle.  It's very important to traverse the convex
+	// hull in counter clockwise order (backwards).
+	//
+	// In the example below, we assume the convex hull starts at the edge (CA).  (nodeHandle) is
+	// RIGHT of (C->A), so it skips that edge and moves on to (D->C).  (nodeHandle) is in fact
+	// LEFT of (D->C), so we would add a new face that would go (D->nodeHandle->C), and we remove
+	// (D->C) from the hull.
+	//
+	//
+	//
+	//                              (C)-------------(A)
+	//                              / \         __/   \
+	//       (nodeHandle)         /    \     __/       \
+	//                          /       \   /           \
+	//                        (D)----____(B)_            \
+	//                          \         |  \ __
+	//                           \        |      \__
+	//                            \       |         \
+	//
+    ////////////////////////////////////////////////////////////////////////////////////
+	void	insert_point(int nodeHandle)
+	{
+		// Iterate Over The Existing Convex Hull
+		//---------------------------------------
+		for (mHullIter = mHull.begin(); mHullIter!=mHull.end(); mHullIter++)
+		{
+			edge&	curEdge = mEdges[*mHullIter];
+
+			// Can This Edge "See" The node Handle We Have Passed In?
+			//---------------------------------------------------------
+			if ( mGraph.get_node(nodeHandle).LRTest(mGraph.get_node(curEdge.mA), mGraph.get_node(curEdge.mB))==Side_Left )
+			{
+				// Then Add The Face And Remove This Edge From The Hull
+				//------------------------------------------------------
+				add_face(curEdge.mA, curEdge.mB, nodeHandle);
+			}
+		}
+	}
+
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Edge Flip Function
+	// 
+	// This function scans the edge list for any edge that is "bad" (defined as not 
+	// fitting within the circumscribed circle of either adjoining face).  When it
+	// encounters one, it "flips" the edge in question and fixes up the adjoining faces
+	// which were altered.
+	//
+	//
+	// The Flip Edge (PtA->PtB):
+	//
+	//
+	//
+	//          BEFORE                         AFTER
+	//
+	//           (PtR)				           (PtA)				
+	//           /   \				           / | \				
+	//         /       \			         /   |   \			
+	//       /  (FaceR)  \			       /     V     \			
+	//     /               \		     /       |       \		
+	//  (PtB)-<---------<-(PtA)		  (PtR)      |     (PtL)		
+	//     \               /		     \       |       /		
+	//       \  (FaceL)  /			       \     V     /			
+	//         \       /			         \   |   /			
+	//           \   /				           \ | /				
+	//           (PtL)				           (PtB)				
+	//
+    ////////////////////////////////////////////////////////////////////////////////////
+	int		flip()
+	{
+		int		Flipped = 0;
+		
+		int		EdgeHandle;
+		int		PtR,	PtL,	PtA,	PtB;
+		int		EdgeRL,	EdgeRR,	EdgeLL,	EdgeLR;
+
+
+		// Iterate Through All The Edges Looking For Potential NON-Delauney Edges
+		//------------------------------------------------------------------------
+		for (TEdgesIter CurEdge=mEdges.begin(); CurEdge!=mEdges.end(); CurEdge++)
+		{
+			// If It Is On The Hull, We Don't Even Need To Look At It
+			//--------------------------------------------------------
+			if (!(*CurEdge).mOnHull)
+			{
+				edge&	EdgeAt	= *CurEdge;
+				face&	FaceR	= mFaces[EdgeAt.mRight];
+				face&	FaceL	= mFaces[EdgeAt.mLeft];
+
+				EdgeHandle		= mEdges.index_to_handle(CurEdge.index());
+				PtA				= EdgeAt.mA;
+				PtB				= EdgeAt.mB;
+				PtR				= FaceR.opposing_node(PtA, PtB);
+				PtL				= FaceL.opposing_node(PtA, PtB);
+
+				assert(EdgeAt.mRight!=EdgeAt.mLeft);
+				assert(PtA!=PtB);
+				assert(PtR!=PtL);
+				assert(PtA!=PtR && PtA!=PtL);
+				assert(PtB!=PtR && PtB!=PtL);
+
+				// Is This Edge Invalid For Delaunay?
+				//-------------------------------------
+				if (!mGraph.get_node(PtB).InCircle(mGraph.get_node(PtR), mGraph.get_node(PtL), mGraph.get_node(PtA)) &&
+					!mGraph.get_node(PtA).InCircle(mGraph.get_node(PtR), mGraph.get_node(PtB), mGraph.get_node(PtL))					
+					)
+				{
+					// Change The Link: Remove The Old, Add The New
+					//----------------------------------------------
+					mLinks.get(mGraph.node_index(PtA), mGraph.node_index(PtB)) = 0;
+					mLinks.get(mGraph.node_index(PtB), mGraph.node_index(PtA)) = 0;
+
+					mLinks.get(mGraph.node_index(PtR), mGraph.node_index(PtL)) = EdgeHandle;
+					mLinks.get(mGraph.node_index(PtL), mGraph.node_index(PtR)) = EdgeHandle;
+
+
+					Flipped++;
+					EdgeAt.mFlips++;
+					FaceL.mFlips++;
+					FaceR.mFlips++;
+
+					// Flip The Edge We Found
+					//------------------------
+					EdgeAt.mA		= PtR;
+					EdgeAt.mB		= PtL;
+
+					// Calculate Relatave Edges And Points Assuming (EdgeAt) Were mBottom For The Two Faces
+					//--------------------------------------------------------------------------------------
+					EdgeRL			= FaceR.relative_left(EdgeHandle);
+					EdgeRR			= FaceR.relative_right(EdgeHandle);
+
+					EdgeLL			= FaceL.relative_left(EdgeHandle);
+					EdgeLR			= FaceL.relative_right(EdgeHandle);
+
+
+					// Fix Edges Which Had Been Rotated To New Faces
+					//-----------------------------------------------
+					mEdges[EdgeLR].flip_face(EdgeAt.mLeft, EdgeAt.mRight);
+					mEdges[EdgeRR].flip_face(EdgeAt.mRight, EdgeAt.mLeft);
+
+					// Rotate The Edges Clockwise
+					//----------------------------
+					FaceR.mLeft		= EdgeLR;
+					FaceR.mRight	= EdgeRL;
+					FaceR.mBottom	= EdgeHandle;
+
+					FaceL.mLeft		= EdgeRR;
+					FaceL.mRight	= EdgeLL;
+					FaceL.mBottom	= EdgeHandle;
+
+					FaceR.mA		= PtR;
+					FaceR.mB		= PtL;
+					FaceR.mC		= PtB;
+
+					FaceL.mA		= PtR;
+					FaceL.mB		= PtL;
+					FaceL.mC		= PtA;
+
+
+					// DEBUG VERIFICATION
+					//========================================================================
+					#ifdef _DEBUG
+					mEdges[FaceR.mLeft  ].verify(FaceR.mA, FaceR.mB, FaceR.mC,	EdgeAt.mRight);
+					mEdges[FaceR.mRight ].verify(FaceR.mA, FaceR.mB, FaceR.mC,	EdgeAt.mRight);
+					mEdges[FaceR.mBottom].verify(FaceR.mA, FaceR.mB,			EdgeAt.mRight);
+
+					mEdges[FaceL.mLeft  ].verify(FaceL.mA, FaceL.mB, FaceL.mC,	EdgeAt.mLeft);
+					mEdges[FaceL.mRight ].verify(FaceL.mA, FaceL.mB, FaceL.mC,	EdgeAt.mLeft);
+					mEdges[FaceL.mBottom].verify(FaceL.mA, FaceL.mB,			EdgeAt.mLeft);
+					#endif
+
+					assert(EdgeAt.mRight!=EdgeAt.mLeft);
+					assert(PtA!=PtB);
+					assert(PtR!=PtL);
+					//========================================================================
+				}
+			}
+		}
+		return Flipped;
+	}
+
+};
+
+
+
+
+}
+#endif
\ No newline at end of file
diff --git a/code/Ragl/graph_vs.h b/code/Ragl/graph_vs.h
new file mode 100644
index 0000000..6c89280
--- /dev/null
+++ b/code/Ragl/graph_vs.h
@@ -0,0 +1,1776 @@
+////////////////////////////////////////////////////////////////////////////////////////
+// RAVEN STANDARD TEMPLATE LIBRARY
+//  (c) 2002 Activision
+//
+//
+// Graph
+// -----
+// A Graph object is one of the most generic data structures.  Theoretically, a graph
+// could be used to make a tree, list, or any other standard structure.  A graph has
+// two data types: NODE and EDGE, and maintains connection information how edges can
+// link two nodes.
+//
+// One of the most intuitive uses of a graph class is a navigation bouy system.  In such
+// a use, the nodes would probably be vector based objects with positional information
+// and the edges might contain portal information (door is open / closed / locked).
+//
+// Another example might be a web page, or decision tree, or any other problem space
+// which requires object connection data.
+//
+//
+//
+//
+// Implimentation
+// --------------
+// This template allocates a pool for NODES, a pool for EDGES, and a grid2_vs<int> to serve
+// as an Adjacency Matrix (called Links).  The Adj. Matrix stores indicies to EDGE objects
+// in the EDGE pool.
+//
+//
+//
+//
+// What If You Do Not Need Any Edge Objects?
+// -----------------------------------------
+// It's fairly common to have a graph with no connection information other than the
+// existance of the link.  For this case, you should be able to create a graph with a
+// MAXEDGES of 1.  You will want to call the version of connect_node() which does not
+// take an edge object, and uses 1 as the "index" in the Adj. Matrix.
+//
+// 
+//
+//
+// How Do You Search?
+// -------------------
+// This graph supports 3 search methods:
+//  Breadth First - Exausts as many links close to start as possible
+//  Depth First	  - Gets as far from start as quickly as possible
+//  A*            - Uses a distance heuristic toward end point
+//
+// First, create a (graph_vs::search) object with the start and end points that you want
+// to search for.  Then, call either bfs(), dfs(), or astar().  When you get the
+// object back, it will have a vector of all the nodes that were visited and methods
+// for iterating over that vector to get the path.
+//
+//	for (TestSearch.path_begin(); !TestSearch.path_end(); TestSearch.path_inc())
+//	{
+//		sprintf(Buf, "(%d)", TestSearch.path_at());
+//		OutputDebugString(Buf);
+//	}
+//
+// 
+//
+//
+// Complexity Analisis
+// -------------------
+// All data operations except remove_node() are O(1) constant time.
+// remove_node() can be O(n) where n is the number of NODES in the graph.
+// 
+// Search routines:
+//  BFS - 
+//  DFS - 
+//  A*  - 
+//
+//
+//
+//
+////////////////////////////////////////////////////////////////////////////////////////
+#if !defined(RAGL_GRAPH_VS_INC)
+#define RAGL_GRAPH_VS_INC
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Includes
+////////////////////////////////////////////////////////////////////////////////////////
+#if defined(RA_DEBUG_LINKING)
+	#pragma message("...including graph_vs.h")
+#endif
+#if !defined(RAGL_COMMON_INC)
+	#include "ragl_common.h"
+#endif
+#if !defined(RATL_ARRAY_VS_INC)
+	#include "..\Ratl\array_vs.h"
+#endif
+#if !defined(RATL_VECTOR_VS_INC)
+	#include "..\Ratl\vector_vs.h"
+#endif
+#if !defined(RATL_BITS_INC)
+	#include "..\Ratl\bits_vs.h"
+#endif
+#if !defined(RATL_QUEUE_VS_INC)
+	#include "..\Ratl\queue_vs.h"
+#endif
+#if !defined(RATL_STACK_VS_INC)
+	#include "..\Ratl\stack_vs.h"
+#endif
+#if !defined(RBTREE_MAP_VS_INC)
+	#include "..\Ratl\map_vs.h"
+#endif
+#if !defined(RATL_POOL_VS_INC)
+	#include "..\Ratl\pool_vs.h"
+#endif
+#if !defined(RATL_GRID_VS_INC)
+	#include "..\Ratl\grid_vs.h"
+#endif
+namespace ragl
+{
+
+
+
+
+
+
+
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// The Graph Class
+////////////////////////////////////////////////////////////////////////////////////////
+template <class TNODE, int MAXNODES, class TEDGE, int MAXEDGES, int MAXNODENEIGHBORS>
+class graph_vs : public ratl::ratl_base
+{
+public:
+    ////////////////////////////////////////////////////////////////////////////////////
+	// The Graph User Class
+	//
+	// When executing a search (in particular an A* search), you may want to derive your
+	// own user class so that you can provide specific functionality to the search.  For
+	// example, you might want characters on one team to bias the cost of going to nodes
+	// which are occupied by the other team.  Or you might want to allow specific
+	// characters to access some edges where others cannot.  Perhaps one can fly or has
+	// a special key to a door...
+	//
+    ////////////////////////////////////////////////////////////////////////////////////
+	class user
+	{
+	public:
+		////////////////////////////////////////////////////////////////////////////////////
+		// can be invalid edge (For Region)
+		////////////////////////////////////////////////////////////////////////////////////
+		virtual		bool	can_be_invalid(const TEDGE& Edge) const = 0;
+		
+		////////////////////////////////////////////////////////////////////////////////////
+		// valid edge (For A* and Region)
+		////////////////////////////////////////////////////////////////////////////////////
+		virtual		bool	is_valid(TEDGE& Edge, int EndPoint=0) const = 0;
+
+		////////////////////////////////////////////////////////////////////////////////////
+		// cost estimate from A to B (For A*)
+		////////////////////////////////////////////////////////////////////////////////////
+		virtual		float	cost(const TNODE& A, const TNODE& B) const = 0;
+
+		////////////////////////////////////////////////////////////////////////////////////
+		// cost estimate of Edge (For A*)
+		////////////////////////////////////////////////////////////////////////////////////
+		virtual		float	cost(const TEDGE& Edge, const TNODE& B) const = 0;
+
+		////////////////////////////////////////////////////////////////////////////////////
+		// same floor check (For Triangulation)
+		////////////////////////////////////////////////////////////////////////////////////
+		virtual		bool	on_same_floor(const TNODE& A, const TNODE& B) const = 0;
+
+		////////////////////////////////////////////////////////////////////////////////////
+		// setup the edge (For Triangulation)
+		////////////////////////////////////////////////////////////////////////////////////
+		virtual		void	setup_edge(TEDGE& Edge, int A, int B, bool OnHull, const TNODE& NodeA, const TNODE& NodeB, bool CanBeInvalid=false) = 0;
+	};
+
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Capacity Enum
+    ////////////////////////////////////////////////////////////////////////////////////
+ 	enum 
+	{
+		CAPACITY = MAXNODES,
+		NULLEDGE = -1,
+	};
+
+
+	typedef typename ratl::pool_vs<TNODE,		MAXNODES>				TNodes;
+	typedef typename ratl::pool_vs<TEDGE,		MAXEDGES>				TEdges;
+	struct	SNodeNeighbor
+	{
+		short	mEdge;
+		short	mNode;
+	};
+	typedef typename ratl::vector_vs<SNodeNeighbor,  MAXNODENEIGHBORS>	TNodeNeighbors;
+	typedef typename ratl::array_vs< TNodeNeighbors, MAXNODES>			TLinks;
+
+
+	typedef	typename ragl::graph_vs<TNODE, MAXNODES, TEDGE, MAXEDGES, MAXNODENEIGHBORS>	TGraph;
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// cells class
+    ////////////////////////////////////////////////////////////////////////////////////
+	template <int NODESPERCELL, int CELLSX, int CELLSY>
+	class cells : public ratl::ratl_base
+	{
+	public:
+	 	enum 
+		{
+			SIZEX = CELLSX,
+			SIZEY = CELLSY,
+			SIZENODES = NODESPERCELL
+		};
+
+
+		struct SSortNode
+		{
+			float	mCost;
+			short	mHandle;
+			bool			operator<(const SSortNode& t) const	
+			{
+				return	(mCost<t.mCost);
+			}
+		};
+		typedef	typename ratl::vector_vs<SSortNode, (NODESPERCELL*25)>		TSortNodes;
+		typedef	typename ratl::vector_vs<short, NODESPERCELL>				TCellNodes;
+		struct SCell
+		{
+			TCellNodes	mNodes;
+			TCellNodes	mEdges;
+		};
+		typedef	typename ratl::grid2_vs<SCell,	CELLSX, CELLSY>				TCells;
+
+
+	    ////////////////////////////////////////////////////////////////////////////////
+		//
+	    ////////////////////////////////////////////////////////////////////////////////
+		cells(TGraph& g) : mGraph(g)
+		{
+		}
+
+		void		clear()
+		{
+			mCells.clear();
+			SCell		EmptyCell;
+			mCells.init(EmptyCell);
+		}
+
+		void		get_cell_upperleft(int x, int y, float& xReal, float& yReal)
+		{
+			mCells.get_cell_upperleft(x,y,xReal,yReal);
+		}
+		void		get_cell_lowerright(int x, int y, float& xReal, float& yReal)
+		{
+			mCells.get_cell_lowerright(x,y,xReal,yReal);
+		}
+
+	    ////////////////////////////////////////////////////////////////////////////////
+		//
+	    ////////////////////////////////////////////////////////////////////////////////
+		void			expand_bounds(int nodeHandle)
+		{
+			TNODE&	node = mGraph.get_node(nodeHandle);
+			mCells.expand_bounds(node[0], node[1]);
+		}
+
+	    ////////////////////////////////////////////////////////////////////////////////
+		//
+	    ////////////////////////////////////////////////////////////////////////////////
+		SCell&			get_cell(float x, float y)
+		{
+			return mCells.get(x,y);
+		}
+		SCell&			get_cell(int x, int y)
+		{
+			return mCells.get(x,y);
+		}
+		void			convert_to_cell_coords(float x, float y, int& xint, int& yint)
+		{
+			mCells.get_cell_coords(x, y, xint, yint);
+		}
+
+	    ////////////////////////////////////////////////////////////////////////////////
+		//
+	    ////////////////////////////////////////////////////////////////////////////////
+		void			fill_cells_nodes(float range)
+		{
+			// I. Fill All The Cells With The Points Contained By Those Cells
+			//----------------------------------------------------------------
+			bool full = false;
+			for (TNodes::iterator it=mGraph.nodes_begin(); it!=mGraph.nodes_end() && !full; it++)
+			{
+				TNODE&	node = (*it);
+				SCell&	cell = mCells.get(node[0], node[1]);
+
+				cell.mNodes.push_back(it.index());
+				full = cell.mNodes.full();
+				assert(!full || "Cell Filled On Inital Containment"==0);
+			}
+
+			mCells.scale_by_largest_axis(range);
+
+
+			// II. Go To All Neighboring Cells And Get Them
+			//==============================================
+			int					iRange = (int)(range) + 1;
+			TCells::riterator	rcell;
+			TCells::riterator	rcellend;
+			CVec3				cellCenter(0,0,0);
+			CVec3				nodeCenter(0,0,0);
+
+			TSortNodes			*sortnodes	= new TSortNodes;
+			SSortNode			sortnode;
+
+			TCells				*sortcells	= new TCells;
+			sortcells->copy_bounds(mCells);
+
+
+
+			// For Every Cell
+			//----------------
+			for (int x=0; x<CELLSX; x++)
+			{
+				for (int y=0; y<CELLSY; y++)
+				{
+					// Setup the Sortnodes vector And Range Iterators
+					//------------------------------------------------
+					sortnodes->clear();
+
+					mCells.get_cell_position(x,y, cellCenter.v[0], cellCenter.v[1]);
+
+					for (rcell = mCells.rangeBegin(iRange,x,y); !rcell.at_end(); rcell++)
+					{
+						SCell& cell = (*rcell);
+
+						// Add The Nodes To The Sort List
+						//--------------------------------
+						for (int i=0; i<cell.mNodes.size() && !sortnodes->full(); i++)
+						{
+							int	nodeHandle = cell.mNodes[i];
+
+							TNODE&	node  = mGraph.get_node(nodeHandle);
+							nodeCenter[0] = node[0];
+							nodeCenter[1] = node[1];
+
+							sortnode.mHandle	= nodeHandle;
+							sortnode.mCost		= cellCenter.Dist2(nodeCenter);
+							sortnodes->push_back(sortnode);
+						}
+					}
+
+					// Sort The Results
+					//------------------
+					sortnodes->sort();
+
+
+					// Copy The Sorted Nodes Vector Into The Sorted Cell (Of The Sorted Cell Grid)
+					//----------------------------------------------------------------------------
+					SCell&	cell = sortcells->get(x,y);
+					cell.mNodes.clear();
+					for (int i=0; i<sortnodes->size() && i<NODESPERCELL; i++)
+					{
+						cell.mNodes.push_back((*sortnodes)[i].mHandle);
+					}
+				}
+			}
+
+			// Now Copy The Sorted Results To The Main Cells
+			//-----------------------------------------------
+			for (int xb=0; xb<CELLSX; xb++)
+			{
+				for (int yb=0; yb<CELLSY; yb++)
+				{
+					SCell&	scell = sortcells->get(xb,yb);
+					SCell&	mcell = mCells.get(xb,yb);
+					mcell.mNodes = scell.mNodes;
+				}
+			}
+
+			delete sortnodes;
+			delete sortcells;
+		}
+
+
+	    ////////////////////////////////////////////////////////////////////////////////
+		//
+	    ////////////////////////////////////////////////////////////////////////////////
+		void			fill_cells_edges(float range)
+		{
+			// I. Fill All The Cells With The Points Contained By Those Cells
+			//----------------------------------------------------------------
+			bool full = false;
+			for (TEdges::iterator eit=mGraph.edges_begin(); eit!=mGraph.edges_end() && !full; eit++)
+			{
+				TEDGE&	edge = (*eit);
+				SCell&	cell = mCells.get(edge[0], edge[1]);
+
+				cell.mEdges.push_back(eit.index());
+				full = cell.mEdges.full();
+				assert(!full || "Cell Filled On Inital Containment"==0);
+			}
+
+
+			mCells.scale_by_largest_axis(range);
+
+
+			// II. Go To All Neighboring Cells And Get Them
+			//==============================================
+			int					iRange = (int)(range) + 1;
+			TCells::riterator	rcell;
+			TCells::riterator	rcellend;
+			CVec3				cellCenter(0,0,0);
+			CVec3				nodeCenter(0,0,0);
+
+			TSortNodes			*sortedges	= new TSortNodes;
+			SSortNode			sortnode;
+
+			TCells				*sortcells	= new TCells;
+			sortcells->copy_bounds(mCells);
+
+
+			// For Every Cell
+			//----------------
+			for (int x=0; x<CELLSX; x++)
+			{
+				for (int y=0; y<CELLSY; y++)
+				{
+					// Setup the Sortnodes vector And Range Iterators
+					//------------------------------------------------
+					sortedges->clear();
+
+					mCells.get_cell_position(x,y, cellCenter.v[0], cellCenter.v[1]);
+
+					for (rcell = mCells.rangeBegin(iRange,x,y); !rcell.at_end(); rcell++)
+					{
+						SCell& cell = (*rcell);
+
+						// Add The Edges To The Sort List
+						//--------------------------------
+						for (int e=0; e<cell.mEdges.size() && !sortedges->full(); e++)
+						{
+							int	edgeHandle = cell.mEdges[e];
+
+							TEDGE&	edge  = mGraph.get_edge(edgeHandle);
+							nodeCenter[0] = edge[0];
+							nodeCenter[1] = edge[1];
+
+							sortnode.mHandle	= edgeHandle;
+							sortnode.mCost		= cellCenter.Dist2(nodeCenter);
+							sortedges->push_back(sortnode);
+						}
+					}
+
+					// Sort The Results
+					//------------------
+					sortedges->sort();
+
+
+					// Copy The Sorted Nodes Vector Into The Sorted Cell (Of The Sorted Cell Grid)
+					//----------------------------------------------------------------------------
+					SCell&	cell = sortcells->get(x,y);
+					cell.mEdges.clear();
+					for (int j=0; j<sortedges->size() && j<NODESPERCELL; j++)
+					{
+						cell.mEdges.push_back((*sortedges)[j].mHandle);
+					}
+				}
+			}
+
+			// Now Copy The Sorted Results To The Main Cells
+			//-----------------------------------------------
+			for (int xb=0; xb<CELLSX; xb++)
+			{
+				for (int yb=0; yb<CELLSY; yb++)
+				{
+					SCell&	scell = sortcells->get(xb,yb);
+					SCell&	mcell = mCells.get(xb,yb);
+					mcell.mEdges = scell.mEdges;
+				}
+			}
+
+			delete sortedges;
+			delete sortcells;
+		}
+
+
+	private:
+		TGraph&		mGraph;
+		TCells		mCells;
+	};
+
+
+
+
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Remove All Edges
+    ////////////////////////////////////////////////////////////////////////////////////
+	void		clear_edges()
+	{	
+		mEdges.clear();
+		mEdges.alloc();		// Alloc a dummy edge at location 0
+		for (int i=0; i<MAXNODES; i++)
+		{
+			mLinks[i].clear();
+		}
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Clear Out All Nodes And Edges
+    ////////////////////////////////////////////////////////////////////////////////////
+	void	clear()
+	{
+		mNodes.clear();
+		mNodes.alloc();		// Alloc A dummy node at location 0
+		clear_edges();
+
+#if !defined(FINAL_BUILD)
+		mSearchCount = 0;
+		mSearchMemorySize = 0;
+
+		mSearchSuccess = 0;
+		mSearchSuccessVisited = 0;
+		mSearchSuccessPathLen = 0;
+
+		mSearchFail = 0;
+		mSearchFailVisited = 0;
+#endif
+	}
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Constructor
+    ////////////////////////////////////////////////////////////////////////////////////
+	graph_vs()
+	{
+		clear();
+	}
+
+	~graph_vs()
+	{
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Number Of Nodes
+    ////////////////////////////////////////////////////////////////////////////////////
+	int			size_nodes()
+	{
+		return (mNodes.size()-1);
+	}
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Access A Node
+    ////////////////////////////////////////////////////////////////////////////////////
+	TNODE&		get_node(int i)
+	{
+		return mNodes[i];
+	}
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Access The Beginning Of The Nodes List
+    ////////////////////////////////////////////////////////////////////////////////////
+	typename TNodes::iterator	nodes_begin()
+	{
+		typename TNodes::iterator x = mNodes.begin();
+		x++;
+		return x;
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Access The End Of The Nodes List
+    ////////////////////////////////////////////////////////////////////////////////////
+	typename TNodes::iterator	nodes_end()
+	{
+		return mNodes.end();
+	}
+
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Number Of Edges
+    ////////////////////////////////////////////////////////////////////////////////////
+	int			size_edges()
+	{
+		return (mEdges.size()-1);
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Access An Edge
+    ////////////////////////////////////////////////////////////////////////////////////
+	TEDGE&		get_edge(int i)
+	{
+		return mEdges[i];
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Get The Edge That Connects nodeA to nodeB
+	//
+	// NOTE: This is now a linear scan witout the adjacency matrix (worst case 8 depth)
+    ////////////////////////////////////////////////////////////////////////////////////
+	int			get_edge_across(int nodeA, int nodeB)
+	{
+		int numNeighbors = mLinks[nodeA].size();
+		for (int curNeighbor=0; curNeighbor<numNeighbors; curNeighbor++)
+		{
+			if (mLinks[nodeA][curNeighbor].mNode==nodeB)
+			{
+				if (mLinks[nodeA][curNeighbor].mEdge)
+				{
+					return mLinks[nodeA][curNeighbor].mEdge;
+				}
+				return -1;	// -1 signifies that a link exists with no edge
+			}
+		}
+		return 0;
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Access The Beginning Of The Nodes List
+    ////////////////////////////////////////////////////////////////////////////////////
+	typename TEdges::iterator	edges_begin()
+	{
+		typename TEdges::iterator x = mEdges.begin();
+		x++;
+		return x;
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Access The End Of The Nodes List
+    ////////////////////////////////////////////////////////////////////////////////////
+	typename TEdges::iterator	edges_end()
+	{
+		return mEdges.end();
+	}
+
+	int							edge_index(const TEDGE& edge)
+	{
+		return mEdges.pointer_to_index(&edge);
+	}
+
+
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Get All The Neighbors Of A Given Node
+    ////////////////////////////////////////////////////////////////////////////////////
+	TNodeNeighbors&		get_node_neighbors(const int nodeA)
+	{
+		return mLinks[nodeA];
+	}
+	bool						node_has_neighbors(const int nodeA)
+	{
+		return !(mLinks[nodeA].empty());
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Add A Node
+    ////////////////////////////////////////////////////////////////////////////////////
+	int			insert_node(const TNODE& t)
+	{
+		int	nNode = mNodes.alloc();
+		mNodes[nNode] = t;
+		return nNode;
+	}
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Remove Node And Clear Out All Edges Once Connected To This Node
+	//   Note: This is a fairly expensive operation, not to be done often
+    ////////////////////////////////////////////////////////////////////////////////////
+	void		remove_node(int node)
+	{
+		mNodes.free(node);
+
+		// For Each Link To A Neighboring Node
+		//--------------------------------------
+		for (int i=0; i<mLinks[node].size(); i++)
+		{
+			int	curNeighbor = mLinks[node][i].mNode;
+			int curEdge		= mLinks[node][i].mEdge;
+
+			// Free The Edge
+			//---------------
+			if (curEdge)
+			{
+				mEdges.free(curEdge);
+			}
+
+
+			// Remove The Edge From Any Recorded Neighbors
+			//---------------------------------------------
+			TNodeNeighbors& neighbors = mLinks[curNeighbor];
+			for (int j=0; j<neighbors.size(); j++)
+			{
+				if (neighbors[j].mNode==node)
+				{
+					neighbors.erase_swap(j);
+					break;
+				}
+			}
+		}
+		mLinks[node].clear();
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Connect Node With An Edge Object  (A->B)  if reflexive, also (B->A)
+    ////////////////////////////////////////////////////////////////////////////////////
+	int			connect_node(const TEDGE& t, int nodeA, int nodeB, bool reflexive=true)
+	{
+		if (nodeA==nodeB || !nodeA || !nodeB || !mNodes.is_used(nodeA) || !mNodes.is_used(nodeB))
+		{
+			assert("ERROR: Cannot Connect A and B!"==0);
+			return 0;
+		}
+
+		if (mLinks[nodeA].full() || (reflexive && mLinks[nodeB].full()))
+		{
+			assert("ERROR: Max edges per node exceeded!"==0);
+			return 0;
+		}
+
+		if (mEdges.full())
+		{
+			assert("ERROR: Max edges exceeded!"==0);
+			return 0;
+		}
+
+		SNodeNeighbor	nNbr;
+
+		nNbr.mNode = nodeB;
+		nNbr.mEdge = mEdges.alloc();
+		mEdges[nNbr.mEdge] = t;
+
+
+		mLinks[nodeA].push_back(nNbr);
+		if (reflexive)
+		{
+			nNbr.mNode = nodeA;
+			mLinks[nodeB].push_back(nNbr);
+		}
+
+		return nNbr.mEdge;
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Connect Node Without Allocating An Edge Object  (A->B)  if reflexive, also (B->A)
+    ////////////////////////////////////////////////////////////////////////////////////
+	void		connect_node(int nodeA, int nodeB, bool reflexive=true)
+	{
+		if (nodeA==nodeB || !nodeA || !nodeB || !mNodes.is_used(nodeA) || !mNodes.is_used(nodeB))
+		{
+			assert("ERROR: Cannot Connect A and B!"==0);
+			return 0;
+		}
+
+		if (mLinks[nodeA].full() || (reflexive && mLinks[nodeB].full()))
+		{
+			assert("ERROR: Max edges per node exceeded!"==0);
+			return 0;
+		}
+
+
+		SNodeNeighbor	nNbr;
+
+		nNbr.mNode = nodeB;
+		nNbr.mEdge = 0;
+
+
+		mLinks[nodeA].push_back(nNbr);
+		if (reflexive)
+		{
+			nNbr.mNode = nodeA;
+			mLinks[nodeB].push_back(nNbr);
+		}
+
+		return nNbr.mEdge;
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Remove Edge
+    ////////////////////////////////////////////////////////////////////////////////////
+	void		remove_edge(int nodeA, int nodeB, bool reflexive=true)
+	{
+		if (!mNodes.is_used(nodeA) || !mNodes.is_used(nodeB) && nodeA==nodeB)
+		{
+			assert("Unable To Remove Edge"==0);
+			return;
+		}
+
+		int	linkNum=0;
+
+		for (linkNum=0; linkNum<mLinks[nodeA].size(); linkNum++)
+		{
+			if (mLinks[nodeA][linkNum].mNode==nodeB)
+			{
+				if (mLinks[nodeA][linkNum].mEdge && mEdges.is_used(mLinks[nodeA][linkNum].mEdge))
+				{
+					mEdges.free(mLinks[nodeA][linkNum].mEdge);
+				}
+				mLinks[nodeA].erase_swap(linkNum);
+				break;
+			}
+		}
+
+
+		for (linkNum=0; linkNum<mLinks[nodeB].size(); linkNum++)
+		{
+			if (mLinks[nodeB][linkNum].mNode==nodeA)
+			{
+				if (mLinks[nodeB][linkNum].mEdge && mEdges.is_used(mLinks[nodeB][linkNum].mEdge))
+				{
+					mEdges.free(mLinks[nodeB][linkNum].mEdge);
+				}
+				mLinks[nodeB].erase_swap(linkNum);
+				break;
+			}
+		}
+	}
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Data
+    ////////////////////////////////////////////////////////////////////////////////////
+private:
+	TNodes		mNodes;
+	TEdges		mEdges;
+	TLinks		mLinks;
+
+
+	////////////////////////////////////////////////////////////////////////////////////////
+	// The Handle Heap Class
+	//
+	// A handle heap is a specially designed heap class which remembers the handle of any
+	// value that is inserted.  Should the value of an already inserted object change, it is
+	// possible to reheapify around that value, no matter where the value lies inside the heap
+	// because of the additional memory to convert handle->index.
+	//
+	// The handle heap is used by A* to sort the open list by cost.
+	//
+	////////////////////////////////////////////////////////////////////////////////////////
+	template<class T>
+	class handle_heap
+	{
+	public:
+
+		////////////////////////////////////////////////////////////////////////////////////
+		// Constructor
+		////////////////////////////////////////////////////////////////////////////////////
+		handle_heap(TNodes& Nodes) : mNodes(Nodes)
+		{
+			clear();
+		}
+    
+		////////////////////////////////////////////////////////////////////////////////////
+		// Get The Size (The Difference Between The Push And Pop "Pointers")
+		////////////////////////////////////////////////////////////////////////////////////
+		int				size() const
+		{
+			return (mPush);
+		}
+		
+		////////////////////////////////////////////////////////////////////////////////////
+		// Check To See If The Size Is Zero
+		////////////////////////////////////////////////////////////////////////////////////
+		bool			empty() const
+		{
+			return (!size());
+		}
+
+		////////////////////////////////////////////////////////////////////////////////////
+		// Check To See If The Size Is Full
+		////////////////////////////////////////////////////////////////////////////////////
+		bool			full() const
+		{
+			return (size()==MAXNODES);
+		}
+
+		////////////////////////////////////////////////////////////////////////////////////
+		// Empty Out The Entire Heap
+		////////////////////////////////////////////////////////////////////////////////////
+		void			clear()
+		{
+			mPush = 0;
+			for (int i=0; i<MAXNODES; i++)
+			{
+				mHandleToPos[i] = -1;
+			}
+		}
+
+		////////////////////////////////////////////////////////////////////////////////////
+		// Check If The Handle Has Been Added To This Heap
+		////////////////////////////////////////////////////////////////////////////////////
+		bool			used(int handle)
+		{
+			return (mHandleToPos[handle]!=-1 && mData[mHandleToPos[handle]].handle()==handle);
+		}
+
+		////////////////////////////////////////////////////////////////////////////////////
+		// Get The Data Value At The Top Of The Heap
+		////////////////////////////////////////////////////////////////////////////////////
+		T&				top()
+		{
+			assert(mPush>0);		// Don't Try To Look At This If There Is Nothing In Here
+			return (mData[0]);
+		}
+
+		////////////////////////////////////////////////////////////////////////////////////
+		// Accessor
+		////////////////////////////////////////////////////////////////////////////////////
+		T&			operator[](int handle)											
+		{
+			// If You Hit This Assert, Then You Are Asking For Unallocated Data
+			//------------------------------------------------------------------
+			assert(used(handle));
+			return mData[mHandleToPos[handle]];
+		}
+
+
+		////////////////////////////////////////////////////////////////////////////////////
+		// Add A Value To The Queue
+		////////////////////////////////////////////////////////////////////////////////////
+		void			push(const T& nValue)
+		{
+			assert(size()<MAXNODES);
+
+			// Get The Handle From The Value And Make Sure We Don't Already Have One Stored There
+			//------------------------------------------------------------------------------------
+			assert(mHandleToPos[nValue.handle()] == -1);
+
+			// Add It
+			//--------
+			mData[mPush]										= nValue;
+			mHandleToPos[nValue.handle()]	= mPush;
+
+			
+
+			// Fix Possible Heap Inconsistancies
+			//-----------------------------------
+			reheapify_upward(mPush);
+			
+			mPush++;
+		}
+
+		////////////////////////////////////////////////////////////////////////////////////
+		// Remove A Value From The Queue
+		////////////////////////////////////////////////////////////////////////////////////
+		void			pop()
+		{
+			assert(size()>0);
+
+			mPush--;
+
+			assert(mHandleToPos[mData[0].handle()]==0);
+			
+
+			// Swap The Lowest Element Up To The Spot We Just "Erased"
+			//---------------------------------------------------------
+			swap(0, mPush);
+
+			mHandleToPos[mData[mPush].handle()] = -1;	// Erase This Handles Marker
+
+
+			// Fix Possible Heap Inconsistancies
+			//-----------------------------------
+			reheapify_downward(0);
+		}
+
+		////////////////////////////////////////////////////////////////////////////////////
+		// Call This Func If The Value At The Given Handle Has Changed & Needs Adjustment
+		////////////////////////////////////////////////////////////////////////////////////
+		void			reheapify(int handle)
+		{
+			assert(used(handle));
+
+			int Pos = mHandleToPos[handle];
+			reheapify_upward(Pos);
+			reheapify_downward(Pos);
+		}
+
+	private:
+		////////////////////////////////////////////////////////////////////////////////////
+		// Returns The Location Of Node (i)'s Parent Node (The Parent Node Of Zero Is Zero)
+		////////////////////////////////////////////////////////////////////////////////////
+		int			parent(int i)				
+		{
+			return ((i-1)/2);
+		}
+
+		////////////////////////////////////////////////////////////////////////////////////
+		// Returns The Location Of Node (i)'s Left Child (The Child Of A Leaf Is The Leaf)
+		////////////////////////////////////////////////////////////////////////////////////
+		int			left(int i)	
+		{
+			return (2*i)+1;
+		}
+
+		////////////////////////////////////////////////////////////////////////////////////
+		// Returns The Location Of Node (i)'s Right Child (The Child Of A Leaf Is The Leaf)
+		////////////////////////////////////////////////////////////////////////////////////
+		int			right(int i)
+		{
+			return (2*i)+2;
+		}
+
+		////////////////////////////////////////////////////////////////////////////////////
+		// Returns The Location Of Largest Child Of Node (i)
+		////////////////////////////////////////////////////////////////////////////////////
+		int			largest_child(int i)
+		{
+			if (left(i)<mPush)
+			{
+				if (right(i)<mPush)
+				{
+					return ( (mData[right(i)] < mData[left(i)]) ? (left(i)) : (right(i)) );
+				}
+				return left(i);	// Node i only has a left child, so by default it is the biggest
+			}
+			return i;		// Node i is a leaf, so just return it
+		}
+
+
+		////////////////////////////////////////////////////////////////////////////////////
+		// Swaps Two Element Locations
+		////////////////////////////////////////////////////////////////////////////////////
+		void		swap(int a, int b)
+		{
+			if (a==b)
+			{
+				return;
+			}
+
+			assert(a>=0 && b>=0 && a<MAXNODES && b<MAXNODES);
+			assert(mHandleToPos[mData[a].handle()]==a);
+			assert(mHandleToPos[mData[b].handle()]==b);
+
+			// Swap Handles
+			//--------------
+			mHandleToPos[mData[a].handle()] = b;
+			mHandleToPos[mData[b].handle()] = a;
+
+			// Swap Data
+			//-----------
+			mData[MAXNODES]	= mData[a];		// a->TEMP
+			mData[a]		= mData[b];		// b->a
+			mData[b]		= mData[MAXNODES];	// TEMP->B
+
+			assert(mHandleToPos[mData[a].handle()]==a);
+			assert(mHandleToPos[mData[b].handle()]==b);
+		}
+
+		////////////////////////////////////////////////////////////////////////////////////
+		// Swaps The Data Up The Heap Until It Reaches A Valid Location
+		////////////////////////////////////////////////////////////////////////////////////
+		void		reheapify_upward(int Pos)
+		{
+			while (Pos && mData[parent(Pos)]<mData[Pos])
+			{
+				swap(parent(Pos), Pos);
+				Pos = parent(Pos);
+			}
+		}
+
+		////////////////////////////////////////////////////////////////////////////////////
+		// Swaps The Data Down The Heap Until It Reaches A Valid Location
+		////////////////////////////////////////////////////////////////////////////////////
+		void		reheapify_downward(int Pos)
+		{
+			int largestChild = largest_child(Pos);
+			while (largestChild!=Pos && mData[Pos]<mData[largestChild])
+			{
+				swap(largestChild, Pos);
+				Pos = largestChild;
+				largestChild = largest_child(Pos);
+			}
+		}
+
+		////////////////////////////////////////////////////////////////////////////////////
+		// Validate Will Run Through The Heap And Make Sure The Top Element Is Smallest
+		////////////////////////////////////////////////////////////////////////////////////
+	#ifdef _DEBUG
+		void		validate()
+		{
+			for (int i=1; i<mPush; i++)
+			{
+				assert(mData[i]<mData[0]);
+			}
+		}
+	#endif
+
+
+
+		////////////////////////////////////////////////////////////////////////////////////
+		// Data
+		////////////////////////////////////////////////////////////////////////////////////
+	private:
+		ratl::array_vs<T, MAXNODES+1>	mData;				// The Memory (Plus One For Temp Sort)
+		ratl::array_vs<int, MAXNODES>	mHandleToPos;		//
+
+		int								mPush;				// Address Of Next Add Location
+
+		TNodes&							mNodes;
+	};
+
+
+
+
+
+
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// A Search Node
+    ////////////////////////////////////////////////////////////////////////////////////
+	class	search_node
+	{
+	public:
+		////////////////////////////////////////////////////////////////////////////////
+		// Constructors
+		////////////////////////////////////////////////////////////////////////////////
+		search_node(int Node=-1, int Parent=-1) : 
+			mNode(Node), 
+			mParentVisit(Parent),
+			mCostToGoal(-1),
+			mCostFromStart(0)
+		{}
+		search_node(const search_node& t) : 
+			mNode(t.mNode), 
+			mParentVisit(t.mParentVisit)
+			mCostToGoal(t.mCostToGoal),
+			mCostFromStart(t.mCostFromStart)
+		{}
+
+		////////////////////////////////////////////////////////////////////////////////
+		// Assignment Operator
+		////////////////////////////////////////////////////////////////////////////////
+		void		operator=(const search_node& t)
+		{
+			mNode			= (t.mNode); 
+			mParentVisit	= (t.mParentVisit);
+			mCostToGoal		= (t.mCostToGoal);
+			mCostFromStart	= (t.mCostFromStart);	
+		}
+
+		////////////////////////////////////////////////////////////////////////////////
+		// 
+		////////////////////////////////////////////////////////////////////////////////
+		int			handle() const
+		{
+			return mNode;
+		}
+
+		////////////////////////////////////////////////////////////////////////////////
+		// 
+		////////////////////////////////////////////////////////////////////////////////
+		float		cost_estimate() const
+		{
+			return mCostFromStart+mCostToGoal;
+		}
+
+		////////////////////////////////////////////////////////////////////////////////
+		// 
+		////////////////////////////////////////////////////////////////////////////////
+		bool		operator<  (const search_node& t) const	
+		{
+			return (cost_estimate() > t.cost_estimate());
+		}
+
+		////////////////////////////////////////////////////////////////////////////////
+		// Data
+		////////////////////////////////////////////////////////////////////////////////
+		int		mNode;					// Which Node Is This (Index To Pool mNodes)
+		int		mParentVisit;			// Which Search Node (In Visited)
+
+		float	mCostToGoal;			// How Far From The Start Of The Search Are We?
+		float	mCostFromStart;			// How Far From The End Of The Search Are We?
+	};
+
+
+
+public:
+ 	typedef		ratl::vector_vs<search_node, MAXNODES>	TVisited;
+ 	typedef		ratl::array_vs<int, MAXNODES>			TVisitedHandles;
+	typedef		ratl::bits_vs<MAXNODES>					TNodeState;
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// The Search Data Object
+    ////////////////////////////////////////////////////////////////////////////////////
+	class	search
+	{
+	public:
+		////////////////////////////////////////////////////////////////////////////////
+		// Constructor
+		////////////////////////////////////////////////////////////////////////////////
+		search(int nodeStart=0, int nodeEnd=0) :
+			mStart(nodeStart),
+			mEnd(nodeEnd)
+		{
+			clear(true, false);
+		}
+
+		enum
+		{
+			NULL_NODE			= 0,
+			NULL_NODE_INDEX		= -1,
+			NULL_VISIT_INDEX	= -1,
+			NULL_COST			= -1,
+		};
+
+
+		////////////////////////////////////////////////////////////////////////////////
+		// Reset All The Search Parameters
+		////////////////////////////////////////////////////////////////////////////////
+		void			clear(bool clearNodesPtr=true, bool clearStartAndEnd=true)
+		{
+			// Reset All Data
+			//----------------
+			mClosed.clear();
+			mVisited.clear();
+			mNodeIndexToVisited.fill(NULL_VISIT_INDEX);
+
+
+			mNext.mNode			= NULL_NODE;
+			mNext.mParentVisit	= NULL_VISIT_INDEX;
+			mNext.mCostToGoal	= NULL_COST;
+			mNext.mCostFromStart= NULL_COST;
+
+			mPrevIndex			= NULL_NODE_INDEX;
+			mNextIndex			= NULL_NODE_INDEX;
+
+			mPathVisit			= NULL_VISIT_INDEX;
+
+			if (clearNodesPtr)
+			{
+				mNodesPtr		= 0;
+			}
+
+			// Clear Out The Start And End Handles
+			//-------------------------------------
+			if (clearStartAndEnd)
+			{
+				mStart			= NULL_NODE;
+				mEnd			= NULL_NODE;
+			}
+
+			// Otherwise, We Can Start The Next Index
+			//----------------------------------------
+			else if (mNodesPtr && mStart!=NULL_NODE && mEnd!=NULL_NODE)
+			{
+				mNextIndex		= mStart;
+			}
+
+		}
+
+		////////////////////////////////////////////////////////////////////////////////
+		// Call This Function To Clear Out Everything EXCEPT Start And End Points
+		////////////////////////////////////////////////////////////////////////////////
+		void			reset()
+		{
+			clear(false, false);
+		}
+
+		////////////////////////////////////////////////////////////////////////////////
+		// Mark This Node As Closed
+		////////////////////////////////////////////////////////////////////////////////
+		void			close(int node)
+		{
+			mClosed.set_bit(node);
+		}
+		////////////////////////////////////////////////////////////////////////////////
+		// Mark This Node As Closed
+		////////////////////////////////////////////////////////////////////////////////
+		void			close(const TNodeState& AllNodesToClose)
+		{
+			mClosed |= AllNodesToClose;
+		}
+
+
+		////////////////////////////////////////////////////////////////////////////////
+		// Return True If We Have Found The Node We Were Searching For
+		////////////////////////////////////////////////////////////////////////////////
+		bool			success()
+		{
+			if (mEnd && mPrevIndex!=NULL_NODE_INDEX)
+			{
+				return (mPrevIndex==mEnd);
+			}
+			return false;
+		}
+
+		////////////////////////////////////////////////////////////////////////////////
+		// Get An Index To The Beginning Of The Path
+		////////////////////////////////////////////////////////////////////////////////
+		void			path_begin()
+		{
+			if (success())
+			{
+				mPathVisit = (mVisited.size()-1);
+			}
+			else
+			{
+				mPathVisit = NULL_VISIT_INDEX;
+			}
+		}
+
+		////////////////////////////////////////////////////////////////////////////////
+		// Check ForThe End Of The Path (Use In A for() Loop)
+		////////////////////////////////////////////////////////////////////////////////
+		bool			path_end()
+		{
+			return (mPathVisit==NULL_VISIT_INDEX);
+		}
+
+		////////////////////////////////////////////////////////////////////////////////
+		// Index Path Inc (Get The Old Path Node's Parent)
+		////////////////////////////////////////////////////////////////////////////////
+		void			path_inc()
+		{
+			assert(mPathVisit!=NULL_VISIT_INDEX);
+			mPathVisit = mVisited[mPathVisit].mParentVisit;
+		}
+
+		////////////////////////////////////////////////////////////////////////////////
+		// Get the node handle of the current node
+		////////////////////////////////////////////////////////////////////////////////
+		int				path_at()
+		{
+			assert(mPathVisit!=NULL_VISIT_INDEX);
+			return mVisited[mPathVisit].mNode;
+		}
+
+		////////////////////////////////////////////////////////////////////////////////
+		// The Total Cost Of The Path
+		////////////////////////////////////////////////////////////////////////////////
+		float			path_cost()
+		{
+			if (success())
+			{
+				return (mVisited[(mVisited.size()-1)].mCostFromStart);
+			}
+			return NULL_COST;
+		}
+
+
+		////////////////////////////////////////////////////////////////////////////////
+		// How Many Nodes Were Looked At In This Search
+		////////////////////////////////////////////////////////////////////////////////
+		int				num_visited()
+		{
+			return mVisited.size();
+		}
+
+		////////////////////////////////////////////////////////////////////////////////
+		// Get An Iterator To The Beginning Of The Visited Pool
+		////////////////////////////////////////////////////////////////////////////////
+		typename TVisited::iterator	visited_begin()
+		{
+			return mVisited.begin();
+		}
+
+		////////////////////////////////////////////////////////////////////////////////
+		// Get An Iterator To The End Of The Visited Pool
+		////////////////////////////////////////////////////////////////////////////////
+		typename TVisited::iterator	visited_end()
+		{
+			return mVisited.end();
+		}
+
+
+
+
+
+	private:
+		////////////////////////////////////////////////////////////////////////////////
+		// Start At The First NON Closed Node
+		////////////////////////////////////////////////////////////////////////////////
+		void			setup(TNodes* nodesPtr)
+		{
+			mNodesPtr			= nodesPtr;
+			clear(false, false);
+		}
+
+
+		////////////////////////////////////////////////////////////////////////////////
+		// Pretend the next index is open, probably because we found a shorter route 
+		// than the first time it was closed, and want it back on the open list
+		////////////////////////////////////////////////////////////////////////////////
+		void			reopen_next_index()
+		{
+			assert(mNextIndex!=NULL_NODE_INDEX);
+
+			mNodeIndexToVisited[mNextIndex] = NULL_VISIT_INDEX;
+			mClosed.clear_bit(mNextIndex);
+		}
+
+		////////////////////////////////////////////////////////////////////////////////
+		// The current estimated cost of reaching a give node, if the node was never
+		// visited, but IS closed, it returns NULL cost
+		////////////////////////////////////////////////////////////////////////////////
+		float			visited_cost(int NodeIndex)
+		{
+			int VisitedIndex = mNodeIndexToVisited[NodeIndex];
+			if (VisitedIndex!=NULL_VISIT_INDEX)
+			{
+				return mVisited[VisitedIndex].cost_estimate();
+			}
+			return NULL_COST;
+		}
+
+
+		////////////////////////////////////////////////////////////////////////////////
+		// Add This Search Node To The Visited List And Keep Track Of It For Later
+		////////////////////////////////////////////////////////////////////////////////
+		void			visit(search_node& t)
+		{
+			assert(mNodesPtr!=0);
+			mPrevIndex						= t.mNode;
+
+			// Add It To The Visited List, And Mark The Location In The Node Index Array
+			//---------------------------------------------------------------------------
+			mVisited.push_back(t);
+			mNodeIndexToVisited[mPrevIndex] = (mVisited.size()-1);
+			mClosed.set_bit(mPrevIndex);
+
+			// Setup Our Next Node To Know It Came From The Last Location In The Visited Vector
+			//----------------------------------------------------------------------------------
+			mNext.mParentVisit				= (mVisited.size()-1);
+		}
+
+		////////////////////////////////////////////////////////////////////////////////
+		// Check To See If The Next Index Has Already Been Closed
+		////////////////////////////////////////////////////////////////////////////////
+		bool			next_index_closed()
+		{
+			assert(mNextIndex!=NULL_NODE_INDEX);
+
+			return (mClosed.get_bit(mNextIndex));
+		}
+
+		////////////////////////////////////////////////////////////////////////////////
+		// The Simple "Get Next" Just Converts The Next Index To A Handle In mNext
+		////////////////////////////////////////////////////////////////////////////////
+		search_node&	get_next()
+		{
+			assert(mNodesPtr);
+			assert(mNextIndex!=NULL_NODE_INDEX);
+
+			mClosed.set_bit(mNextIndex);
+
+			mNext.mNode				= mNextIndex;
+			mNext.mCostToGoal		= 0;
+			mNext.mCostFromStart	= 0;
+
+			return mNext;
+		}
+		
+		////////////////////////////////////////////////////////////////////////////////
+		// This "Get Next" Function Is For A* and Sets Up THe Costs Of The Search Node
+		////////////////////////////////////////////////////////////////////////////////
+		search_node&	get_next(const user& suser, TEDGE& edge_parent_to_next)
+		{
+			assert(mNodesPtr);
+			assert(mNextIndex!=NULL_NODE_INDEX);
+
+			//NOTE: we do not do a "mClosed.set_bit(mNextIndex);" here because A* only closes nodes that are visited
+
+			mNext.mNode				= mNextIndex;
+			mNext.mCostToGoal		= suser.cost((*mNodesPtr)[mNext.mNode], (*mNodesPtr)[mEnd]);
+			mNext.mCostFromStart	= suser.cost(edge_parent_to_next, (*mNodesPtr)[mNext.mNode]);
+			
+			if (mNext.mParentVisit!=NULL_VISIT_INDEX)
+			{
+				mNext.mCostFromStart += mVisited[mNext.mParentVisit].mCostFromStart;
+			}
+			return mNext;
+		}
+
+		////////////////////////////////////////////////////////////////////////////////
+		// Parameters (Start And End Are External Handles)
+		////////////////////////////////////////////////////////////////////////////////
+	public:
+		int							mStart;
+		int							mEnd;
+
+
+		////////////////////////////////////////////////////////////////////////////////
+		// Data
+		////////////////////////////////////////////////////////////////////////////////
+	private:
+		TNodes*						mNodesPtr;
+		
+		int							mPathVisit;
+		int							mPrevIndex;
+		int							mNextIndex;
+		search_node					mNext;
+
+		ratl::bits_vs<MAXNODES>		mClosed;
+		TVisited					mVisited;
+		TVisitedHandles				mNodeIndexToVisited;
+
+		friend class graph_vs<TNODE, MAXNODES, TEDGE, MAXEDGES, MAXNODENEIGHBORS>;
+	};
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Setup The Search Data
+    ////////////////////////////////////////////////////////////////////////////////////
+	void		setup_search(search& sdata)
+	{
+		sdata.setup(&mNodes);
+	}
+
+
+
+
+
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// A* Search
+    ////////////////////////////////////////////////////////////////////////////////////
+	void		astar(search& sdata, const user& suser)
+	{
+		// Make Sure The Nodes We Are Searching For Exist
+		//------------------------------------------------
+		assert(MAXEDGES>1);
+		sdata.setup(&mNodes);
+
+		// Allocate Our Data Structures
+		//------------------------------
+		handle_heap<search_node>		open(mNodes);
+		int								curNeighbor;
+		int								curEdge;
+		float							curCost;
+
+		// Run Through The Open List
+		//---------------------------
+		open.push(sdata.get_next());
+		while (!open.empty() && !sdata.success())
+		{
+			sdata.visit(open.top());
+			open.pop();
+
+			// Search Through The Non Closed Nodes Edges
+			//-------------------------------------------
+			TNodeNeighbors&		curNeighbors = get_node_neighbors(sdata.mPrevIndex);
+			for (curNeighbor=0; curNeighbor<curNeighbors.size(); curNeighbor++)
+			{
+				curEdge = curNeighbors[curNeighbor].mEdge;
+				if (curEdge==-1 || suser.is_valid(mEdges[curEdge], sdata.mEnd))
+				{
+					sdata.mNextIndex			= curNeighbors[curNeighbor].mNode;
+					search_node& snode			= sdata.get_next(suser, mEdges[curEdge]);
+					curCost						= snode.cost_estimate();
+
+					// Is It Already In The Open List?
+					//---------------------------------
+					if (open.used(snode.mNode))
+					{
+						if (curCost<(open[snode.mNode]).cost_estimate())
+						{
+							open[snode.mNode]		= snode;		// Use This As The Node (With New Parent & Cost)
+							open.reheapify(snode.mNode);			// Resort the node in the heap
+						}
+					}
+
+					// Is It Already In The Closed List?
+					//-----------------------------------
+					else if (sdata.next_index_closed())
+					{
+						if (curCost < sdata.visited_cost(snode.mNode))
+						{
+							sdata.reopen_next_index();				// Pull it off the closed list
+							open.push(snode);						// Add it to open
+						}
+					}
+
+					// It Must Be A Whole New Node
+					//------------------------------
+					else
+					{
+						open.push(snode);
+					}
+				}
+			}
+		}
+
+
+#if !defined(FINAL_BUILD)
+		mSearchCount++;
+		mSearchMemorySize += (sizeof(sdata) + sizeof(suser) + sizeof(open));
+
+		if (sdata.success())
+		{
+			mSearchSuccess++;
+			mSearchSuccessVisited += sdata.num_visited();
+			for (sdata.path_begin(); !sdata.path_end(); sdata.path_inc())
+			{
+				mSearchSuccessPathLen ++;
+			}
+		}
+		else
+		{
+			mSearchFail++;
+			mSearchFailVisited += sdata.num_visited();
+		}
+#endif
+	}
+
+
+
+
+
+
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Breadth First Search (Use Queue Open List)
+    ////////////////////////////////////////////////////////////////////////////////////
+	void		bfs(search& sdata)
+	{
+		sdata.setup(&mNodes);
+
+		// Allocate Our Data Structures
+		//------------------------------
+		ratl::queue_vs<search_node, MAXNODES>	open;
+
+		// Run Through The Open List
+		//---------------------------
+		open.push(sdata.get_next());
+		while (open.size()>0 && !sdata.success())
+		{
+			sdata.visit(open.top());
+			open.pop();
+
+
+			// Search Through The Non Closed Nodes Edges
+			//-------------------------------------------
+			for (sdata.mNextIndex=0; sdata.mNextIndex<MAXNODES; sdata.mNextIndex++)
+			{
+				if (!sdata.next_index_closed())
+				{
+					if (get_edge_across(sdata.mPrevIndex, sdata.mNextIndex))
+					{
+						open.push(sdata.get_next());
+					}
+				}
+			}
+		}
+
+#if !defined(FINAL_BUILD)
+		mSearchCount++;
+		mSearchMemorySize += (sizeof(sdata) + sizeof(open));
+
+		if (sdata.success())
+		{
+			mSearchSuccess++;
+			mSearchSuccessVisited += sdata.num_visited();
+		}
+		else
+		{
+			mSearchFail++;
+			mSearchFailVisited += sdata.num_visited();
+		}
+#endif
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Depth First Search (Use Stack Open List)
+    ////////////////////////////////////////////////////////////////////////////////////
+	void		dfs(search& sdata)
+	{
+		sdata.setup(&mNodes);
+
+		// Allocate Our Data Structures
+		//------------------------------
+		ratl::stack_vs<search_node, MAXNODES>	open;
+
+		// Run Through The Open List
+		//---------------------------
+		open.push(sdata.get_next());
+		while (open.size()>0 && !sdata.success())
+		{
+			sdata.visit(open.top());
+			open.pop();
+
+
+			// Search Through The Non Closed Nodes Edges
+			//-------------------------------------------
+			for (sdata.mNextIndex=0; sdata.mNextIndex<MAXNODES; sdata.mNextIndex++)
+			{
+				if (!sdata.next_index_closed())
+				{
+					if (get_edge_across(sdata.mPrevIndex, sdata.mNextIndex))
+					{
+						open.push(sdata.get_next());
+					}
+				}
+			}
+		}
+
+#if !defined(FINAL_BUILD)
+		mSearchCount++;
+		mSearchMemorySize += (sizeof(sdata) + sizeof(open));
+
+		if (sdata.success())
+		{
+			mSearchSuccess++;
+			mSearchSuccessVisited += sdata.num_visited();
+		}
+		else
+		{
+			mSearchFail++;
+			mSearchFailVisited += sdata.num_visited();
+		}
+#endif
+	}
+
+
+
+#if !defined(FINAL_BUILD)
+	int		mSearchCount;
+	int		mSearchMemorySize;
+
+	int		mSearchSuccess;
+	int		mSearchSuccessVisited;
+	int		mSearchSuccessPathLen;
+
+	int		mSearchFail;
+	int		mSearchFailVisited;
+
+	void	ProfileSpew()
+	{
+		ProfilePrint("");
+		ProfilePrint("");
+		ProfilePrint("--------------------------------------------------------");
+		ProfilePrint("RAVEN STANDARD LIBRARY  -  COMPUTATIONAL GEOMETRY MODULE");
+		ProfilePrint("               Graph Profile Results                    ");
+		ProfilePrint("--------------------------------------------------------");
+		ProfilePrint("");
+		ProfilePrint("GRAPH SIZE (Bytes): (%d)  (KiloBytes): (%5.3f)  MeggaBytes(%3.3f)", 
+			(sizeof(*this)), 
+			((float)(sizeof(*this))/1024.0f), 
+			((float)(sizeof(*this))/1048576.0f)
+			);
+		ProfilePrint("GRAPH COUNT: (%d) Nodes  (%d) Edges", mNodes.size(), mEdges.size());
+		if (mNodes.size())
+		{
+			ProfilePrint("GRAPH COUNT: (%f) Edges/Node", (float)mEdges.size()/(float)mNodes.size());
+		}
+		ProfilePrint("");
+		if (mSearchCount)
+		{
+			ProfilePrint("SEARCH: (%d) Searches  (%f) AveSize", mSearchCount,  ((float)mSearchMemorySize/(float)mSearchCount));
+			if (mSearchSuccess)
+			{
+				ProfilePrint("SEARCH: (%d) Successes  (%f) AveVisited  (%f) AvePathLen", 
+					mSearchSuccess,  
+					((float)mSearchSuccessVisited/(float)mSearchSuccess),
+					((float)mSearchSuccessPathLen/(float)mSearchSuccess)					
+					);
+			}
+			if (mSearchFail)
+			{
+				ProfilePrint("SEARCH: (%d) Failures  (%f) AveVisited", mSearchFail,  ((float)mSearchFailVisited/(float)mSearchFail));
+			}
+		}
+		ProfilePrint("");
+	};
+#endif
+};
+
+}
+#endif
\ No newline at end of file
diff --git a/code/Ragl/kdtree_vs.h b/code/Ragl/kdtree_vs.h
new file mode 100644
index 0000000..a6c1503
--- /dev/null
+++ b/code/Ragl/kdtree_vs.h
@@ -0,0 +1,458 @@
+////////////////////////////////////////////////////////////////////////////////////////
+// RAVEN STANDARD TEMPLATE LIBRARY
+//  (c) 2002 Activision
+//
+//
+// KD Tree
+// -------
+//
+//
+//
+// NOTES:
+// 
+//
+//
+////////////////////////////////////////////////////////////////////////////////////////
+#if !defined(RATL_KDTREE_VS_INC)
+#define RATL_KDTREE_VS_INC
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Includes
+////////////////////////////////////////////////////////////////////////////////////////
+#if defined(RA_DEBUG_LINKING)
+	#pragma message("...including kdtree_vs.h")
+#endif
+#if !defined(RAGL_COMMON_INC)
+	#include "ragl_common.h"
+#endif
+namespace ragl
+{
+
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// The List Class
+////////////////////////////////////////////////////////////////////////////////////////
+template <class T, int DIMENSION, int SIZE>
+class kdtree_vs : public ratl::ratl_base
+{
+public:
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Capacity Enum
+    ////////////////////////////////////////////////////////////////////////////////////
+ 	enum 
+	{
+		CAPACITY	= SIZE,
+		NULL_NODE	= SIZE+2,		// Invalid Node ID
+		TARG_NODE	= SIZE+3		// Used To Mark Nodes Add Location
+	};
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Constructor
+    ////////////////////////////////////////////////////////////////////////////////////
+	kdtree_vs() : mRoot(NULL_NODE)
+	{
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// How Many Objects Are In This Tree
+    ////////////////////////////////////////////////////////////////////////////////////
+	int			size() const
+	{
+		return (mPool.size());
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Are There Any Objects In This Tree?
+    ////////////////////////////////////////////////////////////////////////////////////
+	bool		empty() const
+	{
+		return (mRoot==NULL_NODE);
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Is This List Filled?
+    ////////////////////////////////////////////////////////////////////////////////////
+	bool		full() const
+	{
+		return (mPool.full());
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Clear All Elements
+    ////////////////////////////////////////////////////////////////////////////////////
+	void		clear()
+	{
+		mRoot = NULL_NODE;
+		mPool.clear();
+	}
+
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Add A New Element To The Tree
+    ////////////////////////////////////////////////////////////////////////////////////
+	void		add(const T& data)
+	{
+		// CREATE: New
+		//--------------------------------------------
+		int nNew					= mPool.alloc();
+		mPool[nNew].mData			= data;
+		mPool[nNew].mLeft			= NULL_NODE;
+		mPool[nNew].mRight			= NULL_NODE;
+
+		// LINK: (nNew)->(Parent)
+		//--------------------------------------------
+		if (mRoot==NULL_NODE)
+		{
+			mRoot = nNew;
+			mPool[nNew].mParent = NULL_NODE;
+			return;
+		}
+
+		// LINK: (nNew)->(Parent)
+		//--------------------------------------------
+		mPool[nNew].mParent			= find_index(data, mRoot, 0, true, true); 
+
+
+		// LINK: (Parent)->(nNew)
+		//--------------------------------------------
+		if (mPool[mPool[nNew].mParent].mLeft==TARG_NODE)
+		{
+			mPool[mPool[nNew].mParent].mLeft	= nNew;
+		}
+		else if (mPool[mPool[nNew].mParent].mRight==TARG_NODE)
+		{
+			mPool[mPool[nNew].mParent].mRight	= nNew;
+		}
+
+		// Hey!  It Didn't Mark Any Targets, Which Means We Found An Exact match To This Data
+		//------------------------------------------------------------------------------------
+		else
+		{
+			mPool.free(nNew);
+		}
+	}
+
+
+
+
+
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Does (data) Exist In The Tree?
+    ////////////////////////////////////////////////////////////////////////////////////
+	bool	find(const T& data)
+	{
+		assert(mRoot!=NULL_NODE); // If You Hit This Assert, You Are Asking For Data On An Empty Tree
+
+		int		node = find_index(data, mRoot, 0, true, true);
+
+		// Exact Find, Or Found Root?
+		//----------------------------
+		if (mPool[node].mData==data || mPool[node].mParent==NULL_NODE)
+		{
+			return true;
+		}
+		return false;
+	}
+
+
+
+
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// 
+    ////////////////////////////////////////////////////////////////////////////////////
+	class		range_query
+	{
+	public:
+		range_query()						{}
+
+	public:
+		ratl::vector_vs<T, SIZE>		mReported;
+		T								mMins;
+		T								mMaxs;
+	};
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// 
+    ////////////////////////////////////////////////////////////////////////////////////
+	void		find(range_query& query)
+	{
+		if (mRoot!=NULL_NODE)
+		{
+			query.mReported.clear();
+			tree_search(query);
+		}
+	}
+
+
+
+
+
+
+
+private:
+	////////////////////////////////////////////////////////////////////////////////////
+	// 
+    ////////////////////////////////////////////////////////////////////////////////////
+	class node
+	{
+	public:
+		int		mParent;
+		int		mLeft;
+		int		mRight;
+
+		T		mData;
+	};
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// 
+    ////////////////////////////////////////////////////////////////////////////////////
+	class		range_bounds
+	{
+	public:
+		int		mMins[DIMENSION];
+		int		mMaxs[DIMENSION];
+	};
+
+
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// This Private Function Of The Class Does A Standard Binary Tree Search
+    ////////////////////////////////////////////////////////////////////////////////////
+	int			find_index(const T& data, int curNode, int curDimension, bool returnClosest, bool markTarget)
+	{
+		// Did We Just Go Off The End Of The Tree Or Find The Data We Were Looking For?
+		//------------------------------------------------------------------------------
+		if (curNode==NULL_NODE || mPool[curNode].mData==data)
+		{
+			return curNode;
+		}
+
+
+		// Calculate The Next Dimension For Searching
+		//--------------------------------------------
+		int	nextDimension = curDimension+1;
+		if (nextDimension>=DIMENSION)
+		{
+			nextDimension = 0;
+		}
+
+		
+		// Search Recursivly Down The Tree Either Left (For Data > Current Node), Or Right
+		//---------------------------------------------------------------------------------
+		int		findRecursive;
+		bool	goLeft = (data[curDimension] < mPool[curNode].mData[curDimension]);
+		if (goLeft)
+		{
+			findRecursive = find_index(data, mPool[curNode].mLeft, nextDimension, returnClosest, markTarget);
+		}
+		else
+		{
+			findRecursive = find_index(data, mPool[curNode].mRight, nextDimension, returnClosest, markTarget);
+		}
+
+		// Success!
+		//----------
+		if (findRecursive!=NULL_NODE)
+		{
+			return findRecursive;
+		}
+
+		// If We Want To Return The CLOSEST Node, And We Went Off The End, Then Return This One
+		//--------------------------------------------------------------------------------------
+		if (returnClosest)
+		{
+			// If We Are Asked To Mark The Target, We Mark (TARG_NODE) At Either mLeft or mRight,
+			// Depending On Where The Node Should Have Been
+			//----------------------------------------------------------------------------------
+			if (markTarget)
+			{
+				if (goLeft)
+				{
+					mPool[curNode].mLeft = TARG_NODE;
+				}
+				else
+				{
+					mPool[curNode].mRight = TARG_NODE;
+				}
+			}
+
+			// Go Ahead And Return This Node, It's The One We Would Have Put As The Child
+			return curNode;
+		}
+
+		// Return The Results Of The Recursive Call
+		//------------------------------------------
+		return NULL_NODE;
+	}
+
+
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// This function just sets up the range bounds and starts the recursive tree search
+    ////////////////////////////////////////////////////////////////////////////////////
+	void		tree_search(range_query& query)
+	{
+		range_bounds	bounds;
+		for (int i=0; i<DIMENSION; i++)
+		{
+			bounds.mMins[i] = 0;
+			bounds.mMaxs[i] = 0;
+		}
+		tree_search(query, mRoot, 0, bounds);
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// 
+    ////////////////////////////////////////////////////////////////////////////////////
+	void		tree_search(range_query& query, int curNode, int curDimension, range_bounds bounds)
+	{
+		assert(curNode<SIZE);
+
+		// Is This Node In The Query Range?  If So, Report It
+		//----------------------------------------------------
+		if (curNode!=NULL_NODE && tree_search_node_in_range(query, mPool[curNode]))
+		{
+			query.mReported.push_back(mPool[curNode].mData);
+		}
+
+		// If This Is A Leaf Node, We're Done Here
+		//-----------------------------------------
+		if (curNode==NULL_NODE || (mPool[curNode].mLeft==NULL_NODE && mPool[curNode].mRight==NULL_NODE))
+		{
+			return;
+		}
+
+		// Calculate The Next Dimension For Searching
+		//--------------------------------------------
+		int	nextDimension = curDimension+1;
+		if (nextDimension>=DIMENSION)
+		{
+			nextDimension = 0;
+		}
+
+
+		// Test To See If Our Subtree Is In Range
+		//----------------------------------------
+		ESide	Side = tree_search_bounds_in_range(query, bounds);
+
+		// If The Bounds Are Contained Entirely Within The Query Range, We Report The Sub Tree
+		//-------------------------------------------------------------------------------------
+		if (Side==Side_AllIn)
+		{
+			tree_search_report_sub_tree(query, curNode);
+		}
+
+		// Otherwise, If Our Bounds Intersect The Query Range, We Need To Look Further
+		//-----------------------------------------------------------------------------
+		else if (Side==Side_In)
+		{
+			// Test The Left Child
+			//---------------------
+			if (mPool[curNode].mLeft!=NULL_NODE)
+			{
+				int	OldMaxs = bounds.mMaxs[curDimension];
+				if ( !bounds.mMins[curDimension] || ((mPool[curNode].mData[curDimension]) < (mPool[bounds.mMins[curDimension]].mData[curDimension])) )
+				{
+					bounds.mMins[curDimension] = curNode;
+				}
+				tree_search(query, mPool[curNode].mLeft, nextDimension, bounds);
+				bounds.mMaxs[curDimension] = OldMaxs;	// Restore Old Maxs For The Right Child Search
+			}
+
+			// Test The Right Child
+			//----------------------
+			if (mPool[curNode].mRight!=NULL_NODE)
+			{
+				if ( !bounds.mMaxs[curDimension] || ((mPool[bounds.mMaxs[curDimension]].mData[curDimension]) < (mPool[curNode].mData[curDimension])) )
+				{
+					bounds.mMaxs[curDimension] = curNode;
+				}
+				tree_search(query, mPool[curNode].mRight, nextDimension, bounds);
+			}
+		}
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// This Function Returns True If The Node Is Within The Query Range
+    ////////////////////////////////////////////////////////////////////////////////////
+	bool		tree_search_node_in_range(range_query& query, node& n)
+	{
+		for (int dim=0; dim<DIMENSION; dim++)
+		{
+			if (n.mData[dim]<query.mMins[dim] || query.mMaxs[dim]<n.mData[dim])
+			{
+				return false;
+			}
+		}		
+		return true;
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// 
+    ////////////////////////////////////////////////////////////////////////////////////
+	ESide		tree_search_bounds_in_range(range_query& query, range_bounds& bounds)
+	{
+		ESide	S = Side_AllIn;
+		for (int dim=0; dim<DIMENSION; dim++)
+		{
+			// If Any Of Our Dimensions Are Undefined Right Now, Always Return INTERSECT
+			//---------------------------------------------------------------------------
+			if (!bounds.mMaxs[dim] || !bounds.mMins[dim])
+			{
+				return Side_In;
+			}
+
+			// Check To See If They Intersect At All?
+			//----------------------------------------
+			if ((mPool[bounds.mMaxs[dim]].mData[dim]<query.mMins[dim]) || 
+				(query.mMaxs[dim]<mPool[bounds.mMins[dim]].mData[dim]))
+			{
+				return Side_None;
+			}
+
+			// Check To See If It Is Contained
+			//---------------------------------
+			if ((mPool[bounds.mMins[dim]].mData[dim]<query.mMins[dim]) || 
+				(query.mMaxs[dim]<mPool[bounds.mMaxs[dim]].mData[dim]))
+			{
+				S = Side_In;
+			}
+		}		
+		return S;
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Add The Cur Node And All Childeren Of The Cur Node
+    ////////////////////////////////////////////////////////////////////////////////////
+	void		tree_search_report_sub_tree(range_query& query, int curNode)
+	{
+		assert(curNode<SIZE);
+
+		if (mPool[curNode].mLeft!=NULL_NODE)
+		{
+			query.mReported.push_back(mPool[mPool[curNode].mLeft].mData);
+			tree_search_report_sub_tree(query, mPool[curNode].mRight);
+		}
+		if (mPool[curNode].mRight!=NULL_NODE)
+		{
+			query.mReported.push_back(mPool[mPool[curNode].mRight].mData);
+			tree_search_report_sub_tree(query, mPool[curNode].mRight);
+		}
+	}
+
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Data
+    ////////////////////////////////////////////////////////////////////////////////////
+private:
+	ratl::handle_pool_vs<node, SIZE>	mPool;				// The Allocation Data Pool
+	int									mRoot;				// The Beginning Of The Tree
+};
+
+}
+#endif
\ No newline at end of file
diff --git a/code/Ragl/ragl_common.h b/code/Ragl/ragl_common.h
new file mode 100644
index 0000000..d490f6b
--- /dev/null
+++ b/code/Ragl/ragl_common.h
@@ -0,0 +1,232 @@
+////////////////////////////////////////////////////////////////////////////////////////
+// RAVEN STANDARD TEMPLATE LIBRARY
+//  (c) 2002 Activision
+//
+//
+// Common
+// ------
+// The raven libraries contain a number of common defines, enums, and typedefs which
+// need to be accessed by all templates.  Each of these is included here.
+//
+// Also included is a safeguarded assert file for all the asserts in RTL.
+//
+// This file is included in EVERY TEMPLATE, so it should be very light in order to 
+// reduce compile times.
+//
+//
+// Format
+// ------
+// In order to simplify code and provide readability, the template library has some
+// standard formats.  Any new templates or functions should adhere to these formats:
+//
+// - All memory is statically allocated, usually by parameter SIZE
+// - All classes provide an enum which defines constant variables, including CAPACITY
+// - All classes which moniter the number of items allocated provide the following functions:
+//     size()   - the number of objects
+//     empty()  - does the container have zero objects
+//     full()   - does the container have any room left for more objects
+//     clear()  - remove all objects
+//
+//
+// - Functions are defined in the following order:
+//     Capacity
+//     Constructors  (copy, from string, etc...)
+//     Range		 (size(), empty(), full(), clear(), etc...)
+//     Access        (operator[], front(), back(), etc...)
+//     Modification  (add(), remove(), push(), pop(), etc...)
+//     Iteration     (begin(), end(), insert(), erase(), find(), etc...)
+//
+//
+// NOTES:
+//
+//
+//
+////////////////////////////////////////////////////////////////////////////////////////
+#if !defined(RAGL_COMMON_INC)
+#define RAGL_COMMON_INC
+
+
+
+
+
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Includes
+////////////////////////////////////////////////////////////////////////////////////////
+#if defined(RA_DEBUG_LINKING)
+	#pragma message("...including ragl_common.h")
+#endif
+#if !defined(RAGL_ASSERT_INC)
+	#define  RAGL_ASSERT_INC
+	#include <assert.h>
+#endif
+#if !defined(FINAL_BUILD)
+	#if !defined(RAGL_PROFILE_INC) && !defined(_XBOX)
+		#define  RAGL_PROFILE_INC
+		#include "Windows.h"
+	#endif
+#endif
+#if !defined(RAVL_VEC_INC)
+	#include "..\Ravl\CVec.h"
+#endif
+#if !defined(RATL_COMMON_INC)
+	#include "..\Ratl\ratl_common.h"
+#endif
+namespace ragl
+{
+
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Enums
+////////////////////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Typedefs
+////////////////////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Defines
+////////////////////////////////////////////////////////////////////////////////////////
+
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// The Graph Node Class
+////////////////////////////////////////////////////////////////////////////////////////
+class	CNode
+{
+public:
+	CNode()									{}
+	CNode(const CVec3&	Pt) : mPoint(Pt)	{}
+
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Access Operator (For Triangulation)
+	////////////////////////////////////////////////////////////////////////////////////
+	float			operator[](int dimension)
+	{
+		return mPoint[dimension];
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Equality Operator (For KDTree)
+	////////////////////////////////////////////////////////////////////////////////////
+	bool			operator==(const CNode& t) const
+	{
+		return (t.mPoint==mPoint);
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Left Right Test (For Triangulation)
+	////////////////////////////////////////////////////////////////////////////////////
+	virtual		ESide	LRTest(const CNode& A, const CNode& B) const
+	{
+		return (mPoint.LRTest(A.mPoint, B.mPoint));
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Point In Circle (For Triangulation)
+	////////////////////////////////////////////////////////////////////////////////////
+	virtual		bool	InCircle(const CNode& A, const CNode& B, const CNode& C) const
+	{
+		return (mPoint.PtInCircle(A.mPoint, B.mPoint, C.mPoint));
+	}
+
+
+
+public:
+	CVec3		mPoint;
+};
+
+
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// The Graph Edge Class
+////////////////////////////////////////////////////////////////////////////////////////
+class	CEdge
+{
+public:
+	int			mNodeA;
+	int			mNodeB;
+	bool		mOnHull;
+	float		mDistance;
+	bool		mCanBeInval;
+	bool		mValid;
+};
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// The Geometric Reference Class
+//
+// This adds one additional function to the common ratl_ref class to allow access for
+// various dimensions.  It is used in both Triangulation and KDTree
+////////////////////////////////////////////////////////////////////////////////////////
+template <class TDATA, class TDATAREF>
+class	ragl_ref
+{
+public:
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Constructors
+    ////////////////////////////////////////////////////////////////////////////////////
+	ragl_ref()												{}
+	ragl_ref(const ragl_ref & r)							{mDataRef = (TDATAREF)(r.mDataRef);}
+	ragl_ref(const TDATA & r)								{mDataRef = (TDATAREF)(& r);}
+	ragl_ref(const TDATAREF r)								{mDataRef = (TDATAREF)(r);}
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Assignment Operators
+    ////////////////////////////////////////////////////////////////////////////////////
+	void			operator=(const ragl_ref & r)			{mDataRef = (TDATAREF)(r.mDataRef);}
+	void			operator=(const TDATA & r)				{mDataRef = (TDATAREF)(& r);}
+	void			operator=(const TDATAREF r)				{mDataRef = (TDATAREF)(r);}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Access Operator (For Triangulation)
+	////////////////////////////////////////////////////////////////////////////////////
+	float			operator[](int dimension) const			{return (*mDataRef)[dimension];}
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Dereference Operator
+    ////////////////////////////////////////////////////////////////////////////////////
+	TDATA &			operator*()								{return (*mDataRef);}
+	const TDATA &	operator*() const						{return (*mDataRef);}
+
+	TDATAREF		handle() const							{return mDataRef;}
+
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Equality / Inequality Operators
+    ////////////////////////////////////////////////////////////////////////////////////
+	bool			operator== (const ragl_ref& t) const	{return	(*mDataRef)==(*(t.mDataRef));}
+	bool			operator!= (const ragl_ref& t) const	{return	(*mDataRef)!=(*(t.mDataRef));}
+	bool			operator<  (const ragl_ref& t) const	{return	(*mDataRef)< (*(t.mDataRef));}
+	bool			operator>  (const ragl_ref& t) const	{return	(*mDataRef)> (*(t.mDataRef));}
+	bool			operator<= (const ragl_ref& t) const	{return	(*mDataRef)<=(*(t.mDataRef));}
+	bool			operator>= (const ragl_ref& t) const	{return	(*mDataRef)>=(*(t.mDataRef));}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Equality / Inequality Operators
+    ////////////////////////////////////////////////////////////////////////////////////
+	bool			operator== (const TDATA& t) const		{return	(*mDataRef)==t;}
+	bool			operator!= (const TDATA& t) const		{return	(*mDataRef)!=t;}
+	bool			operator<  (const TDATA& t) const		{return	(*mDataRef)< t;}
+	bool			operator>  (const TDATA& t) const		{return	(*mDataRef)> t;}
+	bool			operator<= (const TDATA& t) const		{return	(*mDataRef)<=t;}
+	bool			operator>= (const TDATA& t) const		{return	(*mDataRef)>=t;}
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// The Data Reference
+    ////////////////////////////////////////////////////////////////////////////////////
+private:
+	TDATAREF		mDataRef;
+};
+
+}
+#endif
\ No newline at end of file
diff --git a/code/Ragl/vssver.scc b/code/Ragl/vssver.scc
new file mode 100644
index 0000000..45055c3
Binary files /dev/null and b/code/Ragl/vssver.scc differ
diff --git a/code/Ratl/array_vs.h b/code/Ratl/array_vs.h
new file mode 100644
index 0000000..7813ecd
--- /dev/null
+++ b/code/Ratl/array_vs.h
@@ -0,0 +1,73 @@
+////////////////////////////////////////////////////////////////////////////////////////
+// RAVEN STANDARD TEMPLATE LIBRARY
+//  (c) 2002 Activision
+//
+//
+// Array
+// -----
+// This array class is little more than an assert loaded wrapper around a standard
+// array.
+//
+//
+//
+// NOTES:
+// 
+//
+//
+////////////////////////////////////////////////////////////////////////////////////////
+#if !defined(RATL_ARRAY_VS)
+#define RATL_ARRAY_VS
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Includes
+////////////////////////////////////////////////////////////////////////////////////////
+#if !defined(RATL_COMMON_INC)
+	#include "ratl_common.h"
+#endif
+
+namespace ratl
+{
+
+template<class T, int ARG_CAPACITY>
+class array_vs : public array_base<storage::value_semantics<T,ARG_CAPACITY> >
+{
+public:
+	typedef typename storage::value_semantics<T,ARG_CAPACITY> TStorageTraits;
+	typedef typename TStorageTraits::TValue TTValue;
+ 	enum 
+	{
+		CAPACITY		= ARG_CAPACITY
+	};
+	array_vs() {}
+};
+
+template<class T, int ARG_CAPACITY>
+class array_os : public array_base<storage::object_semantics<T,ARG_CAPACITY> >
+{
+public:
+	typedef typename storage::object_semantics<T,ARG_CAPACITY> TStorageTraits;
+	typedef typename TStorageTraits::TValue TTValue;
+ 	enum 
+	{
+		CAPACITY		= ARG_CAPACITY
+	};
+	array_os() {}
+};
+
+template<class T, int ARG_CAPACITY, int ARG_MAX_CLASS_SIZE>
+class array_is : public array_base<storage::virtual_semantics<T,ARG_CAPACITY,ARG_MAX_CLASS_SIZE> >
+{
+public:
+	typedef typename storage::virtual_semantics<T,ARG_CAPACITY,ARG_MAX_CLASS_SIZE> TStorageTraits;
+	typedef typename TStorageTraits::TValue TTValue;
+ 	enum 
+	{
+		CAPACITY		= ARG_CAPACITY,
+		MAX_CLASS_SIZE	= ARG_MAX_CLASS_SIZE
+	};
+	array_is() {}
+};
+
+}
+#endif
\ No newline at end of file
diff --git a/code/Ratl/bits_vs.h b/code/Ratl/bits_vs.h
new file mode 100644
index 0000000..61ef28e
--- /dev/null
+++ b/code/Ratl/bits_vs.h
@@ -0,0 +1,218 @@
+////////////////////////////////////////////////////////////////////////////////////////
+// RAVEN STANDARD TEMPLATE LIBRARY
+//  (c) 2002 Activision
+//
+//
+// Bit Field
+// ---------
+// The bits class is a bit field of any length which supports all the 
+// standard bitwize operations in addition to some operators for adding & removing 
+// individual bits by their integer indicies and a string conversion method.
+//
+//
+//
+// NOTES:
+// - The SIZE template variable determines how many BITS are available in this template,
+// not how much memory (number of ints) were used to store it.
+//
+//
+////////////////////////////////////////////////////////////////////////////////////////
+#if !defined(RATL_BITS_INC)
+#define RATL_BITS_INC
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Includes
+////////////////////////////////////////////////////////////////////////////////////////
+#if !defined(RATL_COMMON_INC)
+	#include "ratl_common.h"
+#endif
+namespace ratl
+{
+	
+////////////////////////////////////////////////////////////////////////////////////////
+// The Bit Field Class
+////////////////////////////////////////////////////////////////////////////////////////
+template <int	SZ>
+class bits_vs : public bits_base<SZ>
+{
+	////////////////////////////////////////////////////////////////////////////////////
+	// Call This Function To Set All Bits Beyond SIZE to Zero
+    ////////////////////////////////////////////////////////////////////////////////////
+    void	clear_trailing_bits()
+	{
+		for (int i=SIZE; i<ARRAY_SIZE*BITS_INT_SIZE; i++)
+		{
+			mV[i>>BITS_SHIFT] &= ~(1<<(i&BITS_AND));
+		}
+	}
+	
+public:
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Capacity Enum
+    ////////////////////////////////////////////////////////////////////////////////////
+	enum	
+	{
+		SIZE			= SZ,
+		CAPACITY		= SZ,
+	};
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Standard Constructor
+	////////////////////////////////////////////////////////////////////////////////////
+	bits_vs(bool init=true,bool initValue=false) : bits_base<SZ>(init,initValue)
+	{
+	}
+	////////////////////////////////////////////////////////////////////////////////////
+	// Copy Constructor
+	////////////////////////////////////////////////////////////////////////////////////
+	bits_vs(const bits_vs &B)
+	{
+		mem::cpy(mV, B.mV,BYTE_SIZE);
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// String Constructor (Format: "100010100101")
+	////////////////////////////////////////////////////////////////////////////////////
+	bits_vs(const char* Str)
+	{
+		clear();
+
+		for (int b=0; b<SIZE; b++)
+		{
+			if (!Str[b])
+			{
+				return;			// Reached The End Of The String
+			}
+			if (Str[b]=='1')
+			{
+				set_bit(b);		// Found A True Bit
+			}
+		}
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////////
+	// Checks If There Are Any Values At All In This Bit Field (Same as operator !())
+	////////////////////////////////////////////////////////////////////////////////////////
+	bool		empty() const
+	{
+		for (int i=0; i<ARRAY_SIZE; i++)
+		{
+			if (mV[i])
+			{
+				return false;
+			}
+		}
+		return true;
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////////
+	// Get The Number Of Bits Represented Here
+	////////////////////////////////////////////////////////////////////////////////////////
+	int			size()	const
+	{
+		return SIZE;
+	}	
+
+	////////////////////////////////////////////////////////////////////////////////////////
+	// Execute A Bitwise Flip On All The Bits
+	////////////////////////////////////////////////////////////////////////////////////////
+	void		invert()
+	{
+		for (int i=0; i<ARRAY_SIZE; i++)
+		{
+			mV[i] = ~mV[i];
+		}
+		clear_trailing_bits();
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////////
+	// Execute A Bitwise Flip On All The Bits
+	////////////////////////////////////////////////////////////////////////////////////////
+	void		operator~()
+	{
+		invert();
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////////
+	// Query 
+	////////////////////////////////////////////////////////////////////////////////////////
+	bool		get_bit(const int i) const
+	{
+		// If you hit this assert, then you are trying 
+		// to query a bit that goes beyond the number
+		// of bits this object can hold.
+		//--------------------------------------------
+		assert(i>=0 && i < SIZE);
+		return ( (mV[i>>BITS_SHIFT] & (1<<(i&BITS_AND)))!=0 );
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////////
+	// Checks If There Are Any Values At All In This Bit Field
+	////////////////////////////////////////////////////////////////////////////////////////
+	bool		operator!() const
+	{
+		return empty();
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////////
+	// Equality Operator
+	////////////////////////////////////////////////////////////////////////////////////////
+	bool		operator==(const bits_vs &B) const
+	{
+		return (mem::eql(mV, B.mV,BYTE_SIZE));
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////////
+	// InEquality Operator
+	////////////////////////////////////////////////////////////////////////////////////////
+	bool		operator!=(const bits_vs &B) const
+	{
+		return !(operator==(B));
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////////
+	// Or In From Another Bits Object
+	////////////////////////////////////////////////////////////////////////////////////////
+	void		operator|=(const bits_vs &B)
+	{
+		for (int i=0; i<ARRAY_SIZE; i++)
+		{
+			mV[i] |= B.mV[i];
+		}
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////////
+	// And In From Another Bits Object
+	////////////////////////////////////////////////////////////////////////////////////////
+	void		operator&=(const bits_vs &B)
+	{
+		for (int i=0; i<ARRAY_SIZE; i++)
+		{
+			mV[i] &= B.mV[i];
+		}
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////////
+	// xor In From Another Bits Object
+	////////////////////////////////////////////////////////////////////////////////////////
+	void		operator^=(const bits_vs &B)
+	{
+		for (int i=0; i<ARRAY_SIZE; i++)
+		{
+			mV[i] ^= B.mV[i];
+		}
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////////
+	// Assignment Operator
+	////////////////////////////////////////////////////////////////////////////////////////
+	void		operator=(const bits_vs &B)
+	{
+		mem::cpy(mV, B.mV,BYTE_SIZE);
+	}
+
+};
+
+}
+#endif
diff --git a/code/Ratl/grid_vs.h b/code/Ratl/grid_vs.h
new file mode 100644
index 0000000..c31d377
--- /dev/null
+++ b/code/Ratl/grid_vs.h
@@ -0,0 +1,526 @@
+////////////////////////////////////////////////////////////////////////////////////////
+// RAVEN STANDARD TEMPLATE LIBRARY
+//  (c) 2002 Activision
+//
+//
+// Grid
+// ----
+// There are two versions of the Grid class.  Simply, they apply a discreet function
+// mapping from a n dimensional space to a linear aray.
+//
+//
+//
+//
+//
+//
+// NOTES:
+// 
+//
+//
+////////////////////////////////////////////////////////////////////////////////////////
+#if !defined(RATL_GRID_VS_INC)
+#define RATL_GRID_VS_INC
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Includes
+////////////////////////////////////////////////////////////////////////////////////////
+#if !defined(RATL_COMMON_INC)
+	#include "ratl_common.h"
+#endif
+#if !defined(RATL_ARRAY_VS)
+	#include "array_vs.h"
+#endif
+namespace ratl
+{
+
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// The 2D Grid Class
+////////////////////////////////////////////////////////////////////////////////////////
+template <class T, int XSIZE_MAX, int YSIZE_MAX>
+class grid2_vs : public ratl_base
+{
+public:
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Constructor
+    ////////////////////////////////////////////////////////////////////////////////////
+	grid2_vs()
+	{
+		clear();
+	}
+
+	enum
+	{
+		RANGE_NULL = 12345,
+	};
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Assignment Operator
+    ////////////////////////////////////////////////////////////////////////////////////
+	grid2_vs&	operator=(const grid2_vs& other)
+	{
+		mData = other.mData;
+		for (int i=0; i<2; i++)
+		{
+			mSize[i] = other.mSize[i];
+			mMins[i] = other.mMins[i];
+			mMaxs[i] = other.mMaxs[i];
+			mScale[i] = other.mScale[i];
+		}
+		return (*this);
+	}
+
+	void		set_size(int xSize, int ySize)
+	{
+		if (xSize<XSIZE_MAX)
+		{
+			mSize[0] = xSize;
+		}
+		if (ySize<YSIZE_MAX)
+		{
+			mSize[1] = ySize;
+		}
+	}
+
+	void		snap_scale()
+	{
+		mScale[0] = (float)((int)(mScale[0]));
+		mScale[1] = (float)((int)(mScale[1]));
+	}
+
+	void		get_size(int& xSize, int& ySize)
+	{
+		xSize = mSize[0];
+		ySize = mSize[1];
+	}
+
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Clear
+    ////////////////////////////////////////////////////////////////////////////////////
+	void		clear()
+	{
+		mSize[0] = XSIZE_MAX;
+		mSize[1] = YSIZE_MAX;
+		mData.clear();
+		for (int i=0; i<2; i++)
+		{
+			mMins[i] = RANGE_NULL;
+			mMaxs[i] = RANGE_NULL;
+			mScale[i] = 0.0f;
+		}
+	}
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Initialize The Entire Grid To A Value
+    ////////////////////////////////////////////////////////////////////////////////////
+	void		init(const T& val)
+	{
+		for (int i=0; i<(XSIZE_MAX*YSIZE_MAX); i++)
+		{
+			mData[i] = val;
+		}
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Copy The Bounds Of Another Grid
+    ////////////////////////////////////////////////////////////////////////////////////
+	void		copy_bounds(const grid2_vs& other)
+	{
+		for (int i=0; i<2; i++)
+		{
+			mSize[i] = other.mSize[i];
+			mMins[i] = other.mMins[i];
+			mMaxs[i] = other.mMaxs[i];
+			mScale[i] = other.mScale[i];
+		}
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Accessor
+    ////////////////////////////////////////////////////////////////////////////////////
+	T&			get(const int x, const int y)
+	{
+		assert(x>=0 && y>=0 && x<mSize[0] && y<mSize[1]);
+		return mData[(x + y*XSIZE_MAX)];
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Accessor
+    ////////////////////////////////////////////////////////////////////////////////////
+	T&			get(float x, float y)
+	{
+		assert(mScale[0]!=0.0f && mScale[1]!=0.0f);
+		truncate_position_to_bounds(x, y);
+
+		int xint = (int)( (x-mMins[0]) / mScale[0] );
+		int yint = (int)( (y-mMins[1]) / mScale[1] );
+
+		assert(xint>=0 && yint>=0 && xint<mSize[0] && yint<mSize[1]);
+		return mData[(xint + yint*XSIZE_MAX)];
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Convert The Scaled Coordinates To A Grid Coordinate
+    ////////////////////////////////////////////////////////////////////////////////////
+	void		get_cell_coords(float x, float y, int& xint, int& yint)
+	{
+		assert(mScale[0]!=0.0f && mScale[1]!=0.0f);
+		truncate_position_to_bounds(x, y);
+
+		xint = (int)( (x-mMins[0]) / mScale[0] );
+		yint = (int)( (y-mMins[1]) / mScale[1] );
+
+		assert(xint>=0 && yint>=0 && xint<mSize[0] && yint<mSize[1]);
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Expand
+	//
+	// NOTE:  This MUST be at least a 2 dimensional point
+    ////////////////////////////////////////////////////////////////////////////////////
+	void		expand_bounds(float xReal, float yReal)
+	{
+		float	point[2] = {xReal, yReal};
+		for (int i=0; i<2; i++)
+		{
+			if (point[i]<mMins[i] || mMins[i]==RANGE_NULL)
+			{
+				mMins[i] = point[i];
+			}
+			if (point[i]>mMaxs[i] || mMaxs[i]==RANGE_NULL)
+			{
+				mMaxs[i] = point[i];
+			}
+		}
+		assert(mSize[0]>0 && mSize[1]>0);
+
+		mScale[0] = ((mMaxs[0] - mMins[0])/mSize[0]);
+		mScale[1] = ((mMaxs[1] - mMins[1])/mSize[1]);
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// 
+    ////////////////////////////////////////////////////////////////////////////////////
+	void		truncate_position_to_bounds(float& xReal, float& yReal)
+	{
+		if (xReal<mMins[0])
+		{
+			xReal = mMins[0];
+		}
+		if (xReal>(mMaxs[0]-1.0f))
+		{
+			xReal = mMaxs[0]-1.0f;
+		}
+		if (yReal<mMins[1])
+		{
+			yReal = mMins[1];
+		}
+		if (yReal>(mMaxs[1]-1.0f))
+		{
+			yReal = mMaxs[1]-1.0f;
+		}
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// 
+    ////////////////////////////////////////////////////////////////////////////////////
+	void		get_cell_position(int x, int y, float& xReal, float& yReal)
+	{
+	//	assert(mScale[0]!=0.0f && mScale[1]!=0.0f);
+		xReal = (x * mScale[0]) + mMins[0] + (mScale[0] * 0.5f);
+		yReal = (y * mScale[1]) + mMins[1] + (mScale[1] * 0.5f);
+	}
+	void		get_cell_upperleft(int x, int y, float& xReal, float& yReal)
+	{
+	//	assert(mScale[0]!=0.0f && mScale[1]!=0.0f);
+		xReal = (x * mScale[0]) + mMins[0];
+		yReal = (y * mScale[1]) + mMins[1];
+	}
+	void		get_cell_lowerright(int x, int y, float& xReal, float& yReal)
+	{
+	//	assert(mScale[0]!=0.0f && mScale[1]!=0.0f);
+		xReal = (x * mScale[0]) + mMins[0] + (mScale[0]);
+		yReal = (y * mScale[1]) + mMins[1] + (mScale[1]);
+	}
+	void		scale_by_largest_axis(float& dist)
+	{
+		assert(mScale[0]!=0.0f && mScale[1]!=0.0f);
+		if (mScale[0]>mScale[1])
+		{
+			dist /= mScale[0];
+		}
+		else
+		{
+			dist /= mScale[1];
+		}
+	}
+
+
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Data
+    ////////////////////////////////////////////////////////////////////////////////////
+private:
+	array_vs<T, XSIZE_MAX*YSIZE_MAX>	mData;
+	
+	int							mSize[2];
+	float						mMins[2];
+	float						mMaxs[2];
+	float						mScale[2];
+
+
+
+
+public:
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Raw Get - For The Iterator Dereference Function
+    ////////////////////////////////////////////////////////////////////////////////////
+	T&			rawGet(int Loc)
+	{
+		assert(Loc>=0 && Loc<XSIZE_MAX*YSIZE_MAX);
+		return mData[Loc];
+	}
+
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Iterator
+    ////////////////////////////////////////////////////////////////////////////////////
+	class iterator
+	{
+	public:
+
+		// Constructors
+		//--------------
+		iterator()														{}
+		iterator(grid2_vs* p, int t)	: 	mOwner(p), mLoc(t)			{}
+
+		// Assignment Operator
+		//---------------------
+		void		operator= (const iterator &t)						{mOwner=t.mOwner;	mLoc=t.mLoc;}
+
+		// Equality & Inequality Operators
+		//---------------------------------
+		bool		operator!=(const iterator &t)						{return (mLoc!=t.mLoc);}
+		bool		operator==(const iterator &t)						{return (mLoc==t.mLoc);}
+
+		// Dereference Operator
+		//----------------------
+		T&			operator* ()										{return (mOwner->rawGet(mLoc));}
+
+		// Inc Operator
+		//--------------
+		void		operator++(int)										{mLoc++;}
+
+
+		// Row & Col Offsets
+		//-------------------
+		void		offsetRows(int num)									{mLoc += (YSIZE_MAX*num);}
+		void		offsetCols(int num)									{mLoc += (num);}
+
+
+		// Return True If On Frist Column Of A Row
+		//-----------------------------------------
+		bool		onColZero()
+		{
+			return (mLoc%XSIZE_MAX)==0;
+		}
+
+		// Evaluate The XY Position Of This Iterator
+		//-------------------------------------------
+		void		position(int& X, int& Y)
+		{
+			Y = mLoc / XSIZE_MAX;
+			X = mLoc - (Y*XSIZE_MAX);
+		}
+
+	private:
+		int					mLoc;
+		grid2_vs*			mOwner;
+	};
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Iterator Begin
+    ////////////////////////////////////////////////////////////////////////////////////
+	iterator	begin(int x=0, int y=0)
+	{
+		assert(x>=0 && y>=0 && x<mSize[0] && y<mSize[1]);
+
+		return iterator(this, (x + y*XSIZE_MAX));
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Iterator Begin (scaled position, use mins and maxs to calc real position)
+    ////////////////////////////////////////////////////////////////////////////////////
+	iterator	begin(float xReal, float yReal)
+	{
+		assert(mScale[0]!=0.0f && mScale[1]!=0.0f);
+		truncate_position_to_bounds(xReal, yReal);
+
+		int x = (int)( (xReal-mMins[0]) / mScale[0] );
+		int y = (int)( (yReal-mMins[1]) / mScale[1] );
+		
+		return begin(x,y);
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Iterator End
+    ////////////////////////////////////////////////////////////////////////////////////
+	iterator	end()
+	{
+		return iterator(this, (XSIZE_MAX*YSIZE_MAX));
+	}
+
+
+
+
+
+
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Ranged Iterator
+    ////////////////////////////////////////////////////////////////////////////////////
+	class riterator
+	{
+	public:
+
+		// Constructors
+		//--------------
+		riterator()	
+		{}
+		riterator(grid2_vs* p, int Range, int SX, int SY)	: 	
+			mOwner(p)
+		{
+			int		Start[2] = {SX, SY};
+			int		Bounds[2] = {XSIZE_MAX-1, YSIZE_MAX-1};
+
+			for (int i=0; i<2; i++)
+			{
+				mMins[i] = Start[i] - Range;
+				mMaxs[i] = Start[i] + Range;
+
+				if (mMins[i]<0)
+				{
+					mMins[i] = 0;
+				}
+				if (mMaxs[i] > Bounds[i])
+				{
+					mMaxs[i] = Bounds[i];
+				}
+
+				mLoc[i] = mMins[i];
+			}
+		}
+
+		// Assignment Operator
+		//---------------------
+		void		operator= (const riterator &t)
+		{
+			mOwner		= t.mOwner;
+			for (int i=0; i<2; i++)
+			{
+				mMins[i] = t.mMins[i];
+				mMaxs[i] = t.mMaxs[i];
+				mLoc[i]  = t.mLoc[i];
+			}
+		}
+
+		// Equality & Inequality Operators
+		//---------------------------------
+		bool		operator!=(const riterator &t)		
+		{
+			return (mLoc[0]!=t.mLoc[0] || mLoc[1]!=t.mLoc[1]);
+		}
+		bool		operator==(const riterator &t)		
+		{
+			return (mLoc[0]==t.mLoc[0] && mLoc[1]==t.mLoc[1]);
+		}
+
+		// Dereference Operator
+		//----------------------
+		T&			operator* ()						
+		{
+			return (mOwner->get(mLoc[0], mLoc[1]));
+		}
+
+		// Inc Operator
+		//--------------
+		void		operator++(int)										
+		{
+			if (mLoc[1] <= mMaxs[1])
+			{
+				mLoc[0]++;
+				if (mLoc[0]>(mMaxs[0]))
+				{
+					mLoc[0] = mMins[0];
+					mLoc[1]++;
+				}
+			}
+		}
+
+		bool		at_end()
+		{
+			return (mLoc[1]>mMaxs[1]);
+		}
+
+
+		// Return True If On Frist Column Of A Row
+		//-----------------------------------------
+		bool		onColZero()
+		{
+			return (mLoc[0]==mMins[0]);
+		}
+
+		// Evaluate The XY Position Of This Iterator
+		//-------------------------------------------
+		void		position(int& X, int& Y)
+		{
+			Y = mLoc[1];
+			X = mLoc[0];
+		}
+
+	private:
+		int						mMins[2];
+		int						mMaxs[2];
+		int						mLoc[2];
+		grid2_vs*				mOwner;
+	};
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Ranged Iterator Begin (x and y are the center of the range)
+    ////////////////////////////////////////////////////////////////////////////////////
+	riterator	rangeBegin(int range, int x, int y)
+	{
+		assert(x>=0 && y>=0 && x<XSIZE_MAX && y<YSIZE_MAX);
+		return riterator(this, range, x, y);
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// 
+    ////////////////////////////////////////////////////////////////////////////////////
+	riterator	rangeBegin(int range, float xReal, float yReal)
+	{
+		float	position[2] = {xReal, yReal};
+		assert(mScale[0]!=0.0f && mScale[1]!=0.0f);
+		truncate_position_to_bounds(xReal, yReal);
+		int x = ( (position[0]-mMins[0]) / mScale[0] );
+		int y = ( (position[1]-mMins[1]) / mScale[1] );
+
+		assert(x>=0 && y>=0 && x<XSIZE_MAX && y<YSIZE_MAX);
+		return riterator(this, range, x, y);
+	}
+};
+
+}
+#endif
+
+
+
diff --git a/code/Ratl/handle_pool_vs.h b/code/Ratl/handle_pool_vs.h
new file mode 100644
index 0000000..a6a782f
--- /dev/null
+++ b/code/Ratl/handle_pool_vs.h
@@ -0,0 +1,291 @@
+////////////////////////////////////////////////////////////////////////////////////////
+// RAVEN STANDARD TEMPLATE LIBRARY
+//  (c) 2002 Activision
+//
+//
+// Handle Pool
+// -----------
+// The memory pool class is a simple routine for constant time allocation and deallocation
+// from a fixed size pool of objects.  The class uses a simple array to hold the actual
+// data, a queue for the free list, and a bit field to mark which spots in the array
+// are allocated.
+//
+// In addition to the standard memory pool features, this Handle Pool provides a fast
+// iterator, asserts on attempting to access unused data, and a unique ID "handle" for
+// the external system to use.
+//
+//
+//
+// NOTES:
+// 
+//
+//
+////////////////////////////////////////////////////////////////////////////////////////
+#if !defined(RATL_HANDLE_POOL_VS_INC)
+#define RATL_HANDLE_POOL_VS_INC
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Includes
+////////////////////////////////////////////////////////////////////////////////////////
+#if !defined(RATL_COMMON_INC)
+	#include "ratl_common.h"
+#endif
+#if !defined(RATL_POOL_VS_INC)
+	#include "pool_vs.h"
+#endif
+
+namespace ratl
+{
+
+
+template <class T>
+class handle_pool_base : public pool_root<T>
+{
+public:
+	typedef typename T TStorageTraits;
+	typedef typename T::TValue TTValue;
+ 	////////////////////////////////////////////////////////////////////////////////////
+	// Capacity Enum
+    ////////////////////////////////////////////////////////////////////////////////////
+ 	enum 
+	{
+		CAPACITY		= T::CAPACITY
+	};
+
+private:
+	int							mHandles[CAPACITY];
+	int							mMASK_HANDLE_TO_INDEX;
+	int							mMASK_NUM_BITS;
+
+	void IncHandle(int index)
+	{
+		mHandles[index] += (1<<mMASK_NUM_BITS);
+		if (mHandles[index]<0)
+		{
+			// we rolled over
+			mHandles[index] = index;			// Reset The ID Counter
+			mHandles[index] |= (1<<mMASK_NUM_BITS);
+		}
+	}
+public:
+	
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Constructor
+	//
+	// We need a routine to calculate the MASK used to convert a handle to an index and
+	// the number of bits needed to shift by.
+	//
+    ////////////////////////////////////////////////////////////////////////////////////
+	handle_pool_base()
+	{
+		mMASK_HANDLE_TO_INDEX = 0;
+		mMASK_NUM_BITS = 0;
+
+		int	value=CAPACITY-1;
+		while(value)
+		{
+			value>>= 1;
+
+			mMASK_HANDLE_TO_INDEX <<= 1;
+			mMASK_HANDLE_TO_INDEX |= 1;
+			mMASK_NUM_BITS++;
+		}
+		for (int i=0; i<CAPACITY; i++)
+		{
+#ifdef _DEBUG
+			mHandles[i] = i;			// Reset The ID Counter
+			mHandles[i] |= ((++HandleSaltValue)<<mMASK_NUM_BITS);
+#else
+			mHandles[i] = i;			// Reset The ID Counter
+			mHandles[i] |= (1<<mMASK_NUM_BITS);
+#endif
+		}
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Clear - Removes all allocation information
+    ////////////////////////////////////////////////////////////////////////////////////
+	void		clear()
+	{
+		pool_root<T>::clear();
+		// note that we do not refill the handles cause we want old handles to still be stale
+		for (int i=0; i<CAPACITY; i++)
+		{
+			IncHandle(i);
+		}
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Constant Accessor
+    ////////////////////////////////////////////////////////////////////////////////////
+	const TTValue&	operator[](int handle) const 									
+	{
+		assert(is_used(handle));		//typically this is a stale handle (already been freed)
+		return value_at_index(handle&mMASK_HANDLE_TO_INDEX);
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Accessor
+    ////////////////////////////////////////////////////////////////////////////////////
+	TTValue&			operator[](int i)											
+	{
+		assert(is_used(i));		//typically this is a stale handle (already been freed)
+		return value_at_index(i&mMASK_HANDLE_TO_INDEX);
+	}
+
+	bool				is_used(int i) const
+	{
+		if (mHandles[i&mMASK_HANDLE_TO_INDEX]==i)
+		{
+			return is_used_index(i&mMASK_HANDLE_TO_INDEX);
+		}
+		return false;
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Swap two items based on handle
+    ////////////////////////////////////////////////////////////////////////////////////
+	void swap(int i,int j)
+	{
+		assert(is_used(i));		//typically this is a stale handle (already been freed)
+		assert(is_used(j));		//typically this is a stale handle (already been freed)
+		swap_index(handle_to_index(i),handle_to_index(j));
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// The Allocator	returns a handle
+    ////////////////////////////////////////////////////////////////////////////////////
+	int			alloc()
+	{
+		int index=alloc_index();
+		return	mHandles[index];
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// The Allocator, with value, returns a handle
+    ////////////////////////////////////////////////////////////////////////////////////
+	int			alloc(const TTValue &v)
+	{
+		int index=alloc_index(v);
+		return	mHandles[index];
+	}
+    ////////////////////////////////////////////////////////////////////////////////////
+	// The Deallocator, by index, not something generally needed
+    ////////////////////////////////////////////////////////////////////////////////////
+	void		free_index(int index)
+	{
+		pool_root<T>::free_index(index);
+		IncHandle(index);
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// The Deallocator, by handle
+    ////////////////////////////////////////////////////////////////////////////////////
+	void		free(int handle)
+	{
+		assert(is_used(handle));
+		free_index(handle&mMASK_HANDLE_TO_INDEX);
+	}
+	
+    ////////////////////////////////////////////////////////////////////////////////////
+	// The Deallocator, by pointer
+    ////////////////////////////////////////////////////////////////////////////////////
+	void		free(TTValue *me)
+	{
+		free_index(pointer_to_index(me));
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Convert a handle to a raw index, not generally something you should use
+    ////////////////////////////////////////////////////////////////////////////////////
+	int			handle_to_index(int handle) const
+	{
+		assert(is_used(handle));
+		return (handle&mMASK_HANDLE_TO_INDEX);
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// FInd the handle for a given index, this cannot check for stale handles, so it is ill advised
+    ////////////////////////////////////////////////////////////////////////////////////
+	int			index_to_handle(int index) const
+	{
+		assert(index>=0 && index<CAPACITY && is_used_index(index)); //disallowing this on stale handles
+		return (mHandles[index]);
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// converts a T pointer to a handle, generally not something you need, cannot check for stale handles
+    ////////////////////////////////////////////////////////////////////////////////////
+	int			pointer_to_handle(const TTValue *me) const 
+	{
+		return index_to_handle(pointer_to_index(me));
+	}
+	////////////////////////////////////////////////////////////////////////////////////
+	// converts a T pointer to a handle, generally not something you need, cannot check for stale handles
+    ////////////////////////////////////////////////////////////////////////////////////
+	int			pointer_to_handle(const TRatlNew *me) const 
+	{
+		return index_to_handle(pointer_to_index(me));
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Get An Iterator To The Object At handle
+    ////////////////////////////////////////////////////////////////////////////////////
+	pool_root<T>::iterator	at(int handle)
+	{
+		assert(is_used(handle));
+		return at_index(handle&mMASK_HANDLE_TO_INDEX);
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Get An Iterator To The Object At handle
+    ////////////////////////////////////////////////////////////////////////////////////
+	pool_root<T>::const_iterator	at(int handle) const
+	{
+		assert(is_used(handle));
+		return at_index(handle&mMASK_HANDLE_TO_INDEX);
+	}
+};
+
+template<class T, int ARG_CAPACITY>
+class handle_pool_vs : public handle_pool_base<storage::value_semantics<T,ARG_CAPACITY> >
+{
+public:
+	typedef typename storage::value_semantics<T,ARG_CAPACITY> TStorageTraits;
+	typedef typename TStorageTraits::TValue TTValue;
+ 	enum 
+	{
+		CAPACITY		= ARG_CAPACITY
+	};
+	handle_pool_vs() {}
+};
+
+template<class T, int ARG_CAPACITY>
+class handle_pool_os : public handle_pool_base<storage::object_semantics<T,ARG_CAPACITY> >
+{
+public:
+	typedef typename storage::object_semantics<T,ARG_CAPACITY> TStorageTraits;
+	typedef typename TStorageTraits::TValue TTValue;
+ 	enum 
+	{
+		CAPACITY		= ARG_CAPACITY
+	};
+	handle_pool_os() {}
+};
+
+template<class T, int ARG_CAPACITY, int ARG_MAX_CLASS_SIZE>
+class handle_pool_is : public handle_pool_base<storage::virtual_semantics<T,ARG_CAPACITY,ARG_MAX_CLASS_SIZE> >
+{
+public:
+	typedef typename storage::virtual_semantics<T,ARG_CAPACITY,ARG_MAX_CLASS_SIZE> TStorageTraits;
+	typedef typename TStorageTraits::TValue TTValue;
+ 	enum 
+	{
+		CAPACITY		= ARG_CAPACITY,
+		MAX_CLASS_SIZE	= ARG_MAX_CLASS_SIZE
+	};
+	handle_pool_is() {}
+};
+
+}
+#endif
\ No newline at end of file
diff --git a/code/Ratl/hash_pool_vs.h b/code/Ratl/hash_pool_vs.h
new file mode 100644
index 0000000..7b6b640
--- /dev/null
+++ b/code/Ratl/hash_pool_vs.h
@@ -0,0 +1,200 @@
+////////////////////////////////////////////////////////////////////////////////////////
+// RAVEN STANDARD TEMPLATE LIBRARY
+//  (c) 2002 Activision
+//
+//
+// Hash Pool
+// ---------
+// The hash pool stores raw data of variable size.  It uses a hash table to check for
+// redundant data, and upon finding any, will return the existing handle.  Otherwise
+// it copies the data to memory and returns a new handle.
+//
+//
+// NOTES:
+// 
+//
+//
+////////////////////////////////////////////////////////////////////////////////////////
+#if !defined(RATL_HASH_POOL_VS_INC)
+#define RATL_HASH_POOL_VS_INC
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Includes
+////////////////////////////////////////////////////////////////////////////////////////
+#if !defined(RATL_COMMON_INC)
+	#include "ratl_common.h"
+#endif
+namespace ratl
+{
+
+
+
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// The Hash Pool
+////////////////////////////////////////////////////////////////////////////////////////
+template <int SIZE, int SIZE_HANDLES>
+class	hash_pool
+{
+	int		mHandles[SIZE_HANDLES];					// each handle holds the start index of it's data
+
+	int		mDataAlloc;								// where the next chunck of data will go
+	char	mData[SIZE];
+
+	#ifdef _DEBUG
+	int		mFinds;									// counts how many total finds have run
+	int		mCurrentCollisions;						// counts how many collisions on the last find
+	int		mTotalCollisions;						// counts the total number of collisions
+	int		mTotalAllocs;
+	#endif
+
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// This function searches for a handle which already stores the data (assuming the
+	// handle is a hash within range SIZE_HANDLES).
+	//
+	// If it failes, it returns false, and the handle passed in points to the next
+	// free slot.
+	////////////////////////////////////////////////////////////////////////////////////
+	bool		find_existing(int& handle, const void* data, int datasize)
+	{
+		#ifdef _DEBUG
+		mFinds++;
+		mCurrentCollisions = 0;
+		#endif
+
+		while (mHandles[handle])					// So long as a handle exists there
+		{
+			if (mem::eql((void*)(&mData[mHandles[handle]]), data, datasize))
+			{
+				return true;						// found 
+			}
+			handle=(handle+1)&(SIZE_HANDLES-1);		// incriment the handle
+
+			#ifdef _DEBUG
+			mCurrentCollisions ++;
+			mTotalCollisions ++;
+
+			//assert(mCurrentCollisions < 16);		// If We Had 16+ Collisions, Hash May Be Inefficient.  
+													// Evaluate SIZE and SIZEHANDLES
+			#endif
+		}
+		return false;								// failed to find
+	}
+
+
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// A simple hash function for the range of [0, SIZE_HANDLES]
+	////////////////////////////////////////////////////////////////////////////////////
+	int			hash(const void* data, int datasize)
+	{
+		int	 h=0;
+		for (int i=0; i<datasize; i++)
+		{
+			h += ((const char*)(data))[i] * (i + 119);		// 119.  Prime Number?
+		}
+		h &= SIZE_HANDLES - 1;						// zero out bits beyoned SIZE_HANDLES
+		return h;
+	}
+
+public:
+	hash_pool()
+	{
+		clear();
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// The Number Of Bytes Allocated
+    ////////////////////////////////////////////////////////////////////////////////////
+	int			size()	 const													
+	{
+		return mDataAlloc;
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Check To See If This Memory Pool Is Empty
+    ////////////////////////////////////////////////////////////////////////////////////
+	bool		empty()	 const													
+	{
+		return (mDataAlloc==1);
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Check To See If This Memory Pool Has Enough Space Left For (minimum) Bytes
+    ////////////////////////////////////////////////////////////////////////////////////
+	bool		full(int minimum)	 const													
+	{
+		return ((SIZE - mDataAlloc)<minimum);
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Clear - Removes all allocation information - Note!  DOES NOT CLEAR MEMORY
+    ////////////////////////////////////////////////////////////////////////////////////
+	void		clear()
+	{
+		mData[0] = 0;
+		mDataAlloc = 1;
+		for (int i=0; i<SIZE_HANDLES; i++)
+		{
+			mHandles[i] = 0;
+		}
+
+		#ifdef _DEBUG
+		mFinds = 0;
+		mCurrentCollisions = 0;
+		mTotalCollisions = 0;
+		mTotalAllocs = 0;
+		#endif
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// This is the primary functionality of the hash pool.  It will search for existing
+	// data of the same size, and failing to find any, it will append the data to the
+	// memory.
+	//
+	// In both cases, it gives you a handle to look up the data later.
+	////////////////////////////////////////////////////////////////////////////////////
+	int			get_handle(const void* data, int datasize)
+	{
+		int	handle = hash(data, datasize);				// Initialize Our Handle By Hash Fcn
+		if (!find_existing(handle, data, datasize))
+		{
+			assert(mDataAlloc+datasize < SIZE);			// Is There Enough Memory?
+
+			#ifdef _DEBUG
+			mTotalAllocs++;
+			#endif
+
+			mem::cpy((void*)(&mData[mDataAlloc]), data, datasize);// Copy Data To Memory
+			mHandles[handle] = mDataAlloc;				// Mark Memory In Hash Tbl
+			mDataAlloc += datasize;						// Adjust Next Alloc Location
+		}
+		return handle;									// Return The Hash Tbl handleess
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Constant Access Operator
+	////////////////////////////////////////////////////////////////////////////////////
+	const void*	operator[](int handle) const
+	{
+		assert(handle>=0 && handle<SIZE_HANDLES);
+
+		return &(mData[mHandles[handle]]);
+	}
+
+
+#ifdef _DEBUG
+	float		average_collisions()	{return ((float)mTotalCollisions / (float)mFinds);}
+	int			total_allocs()			{return mTotalAllocs;}
+	int			total_finds()			{return mFinds;}
+	int			total_collisions()		{return mTotalCollisions;}
+#endif
+
+};
+
+
+}
+#endif
\ No newline at end of file
diff --git a/code/Ratl/heap_vs.h b/code/Ratl/heap_vs.h
new file mode 100644
index 0000000..16b10f9
--- /dev/null
+++ b/code/Ratl/heap_vs.h
@@ -0,0 +1,324 @@
+////////////////////////////////////////////////////////////////////////////////////////
+// RAVEN STANDARD TEMPLATE LIBRARY
+//  (c) 2002 Activision
+//
+//
+// Heap
+// ------
+//
+//
+//
+//
+// TODO:
+//
+//
+// NOTES:
+//
+//
+////////////////////////////////////////////////////////////////////////////////////////
+#if !defined(RATL_HEAP_VS_INC)
+#define RATL_HEAP_VS_INC
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Includes
+////////////////////////////////////////////////////////////////////////////////////////
+#if !defined(RATL_COMMON_INC)
+	#include "ratl_common.h"
+#endif
+namespace ratl
+{
+
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// The Vector Class
+////////////////////////////////////////////////////////////////////////////////////////
+template<class T>
+class heap_base : public ratl_base
+{
+public:
+	typedef typename T TStorageTraits;
+	typedef typename T::TValue TTValue;
+ 	////////////////////////////////////////////////////////////////////////////////////
+	// Capacity Enum
+    ////////////////////////////////////////////////////////////////////////////////////
+ 	enum 
+	{
+		CAPACITY		= T::CAPACITY
+	};
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Data
+	////////////////////////////////////////////////////////////////////////////////////
+private:
+	array_base<TStorageTraits>	mData;					// The Memory
+	int							mPush;					// Address Of Next Add Location
+
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Returns The Location Of Node (i)'s Parent Node (The Parent Node Of Zero Is Zero)
+	////////////////////////////////////////////////////////////////////////////////////
+	static int			parent(int i)
+	{
+		return ((i-1)/2);
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Returns The Location Of Node (i)'s Left Child (The Child Of A Leaf Is The Leaf)
+	////////////////////////////////////////////////////////////////////////////////////
+	static int			left(int i)	
+	{
+		return (2*i)+1;
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Returns The Location Of Node (i)'s Right Child (The Child Of A Leaf Is The Leaf)
+	////////////////////////////////////////////////////////////////////////////////////
+	static int			right(int i)
+	{
+		return (2*i)+2;
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Returns The Location Of Largest Child Of Node (i)
+	////////////////////////////////////////////////////////////////////////////////////
+	int			largest_child(int i) const
+	{
+		if (left(i)<mPush)
+		{
+			if (right(i)<mPush)
+			{
+				return ( (mData[right(i)] < mData[left(i)]) ? (left(i)) : (right(i)) );
+			}
+			return left(i);	// Node i only has a left child, so by default it is the biggest
+		}
+		return i;		// Node i is a leaf, so just return it
+	}
+
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Swaps Two Element Locations
+	////////////////////////////////////////////////////////////////////////////////////
+	void		swap(int a, int b)
+	{
+		if (a==b)
+		{
+			return;
+		}
+		assert(a>=0 && b>=0 && a<CAPACITY && b<CAPACITY);
+		mData.swap(a,b);
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Swaps The Data Up The Heap Until It Reaches A Valid Location
+	////////////////////////////////////////////////////////////////////////////////////
+	void		reheapify_upward(int Pos)
+	{
+		while (Pos && mData[parent(Pos)]<mData[Pos])
+		{
+			swap(parent(Pos), Pos);
+			Pos = parent(Pos);
+		}
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Swaps The Data Down The Heap Until It Reaches A Valid Location
+	////////////////////////////////////////////////////////////////////////////////////
+	void		reheapify_downward(int Pos)
+	{
+		int largestChild = largest_child(Pos);
+		while (largestChild!=Pos && mData[Pos]<mData[largestChild])
+		{
+			swap(largestChild, Pos);
+			Pos = largestChild;
+			largestChild = largest_child(Pos);
+		}
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Validate Will Run Through The Heap And Make Sure The Top Element Is Smallest
+	////////////////////////////////////////////////////////////////////////////////////
+	bool		valid()
+	{
+		for (int i=1; i<mPush; i++)
+		{
+			if (mData[0]<mData[i])
+			{
+				return false;
+			}
+		}
+		return true;
+	}
+public:
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Constructor
+    ////////////////////////////////////////////////////////////////////////////////////
+	heap_base() : mPush(0)
+	{
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Get The Size (The Difference Between The Push And Pop "Pointers")
+    ////////////////////////////////////////////////////////////////////////////////////
+	int				size() const
+	{
+		return mPush;
+	}
+	
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Check To See If The Size Is Zero
+    ////////////////////////////////////////////////////////////////////////////////////
+	bool			empty() const
+	{
+		return !size();
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Check To See If The Size Is Full
+    ////////////////////////////////////////////////////////////////////////////////////
+	bool			full() const
+	{
+		return size()==CAPACITY;
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Empty Out The Entire Heap
+	////////////////////////////////////////////////////////////////////////////////////
+	void			clear()
+	{
+		mPush = 0;
+		mData.clear();
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Get The Data Value At The Top Of The Heap
+    ////////////////////////////////////////////////////////////////////////////////////
+	const TTValue &		top() const
+	{
+		assert(mPush>0);		// Don't Try To Look At This If There Is Nothing In Here
+		return mData[0];
+	}
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Add A Value To The Queue
+    ////////////////////////////////////////////////////////////////////////////////////
+	void			push(const TTValue& nValue)
+	{
+		assert(size()<CAPACITY);
+
+		// Add It
+		//--------
+		mData.construct(mPush,nValue);
+
+		// Fix Possible Heap Inconsistancies
+		//-----------------------------------
+		reheapify_upward(mPush);
+		
+		mPush++;
+		assert(valid());
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Alloc A Value, call push_alloced to add
+    ////////////////////////////////////////////////////////////////////////////////////
+	TTValue&	alloc()
+	{
+		assert(size()<CAPACITY);
+
+		// Add It
+		//--------
+		mData.construct(mPush);
+
+		return mData[mPush];
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Alloc A Raw Value for placement new, call push_alloced to add
+    ////////////////////////////////////////////////////////////////////////////////////
+	TRatlNew *	alloc_raw()
+	{
+		assert(size()<CAPACITY);
+
+		return mData.alloc_raw(mPush);
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Add A Value To The Queue, after filling an alloced slot
+    ////////////////////////////////////////////////////////////////////////////////////
+	void			push_alloced()
+	{
+		assert(size()<CAPACITY);
+		// Fix Possible Heap Inconsistancies
+		//-----------------------------------
+		reheapify_upward(mPush);
+		
+		mPush++;
+		assert(valid());
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Remove A Value From The Queue
+    ////////////////////////////////////////////////////////////////////////////////////
+	void			pop()
+	{
+		assert(size()>0);
+
+		mPush--;
+
+		// Swap The Lowest Element Up To The Spot We Just "Erased"
+		//---------------------------------------------------------
+		swap(0, mPush);
+		mData.destruct(mPush);
+
+		// Fix Possible Heap Inconsistancies
+		//-----------------------------------
+		reheapify_downward(0);
+		assert(valid());
+	}
+
+
+
+};
+template<class T, int ARG_CAPACITY>
+class heap_vs : public heap_base<storage::value_semantics<T,ARG_CAPACITY> >
+{
+public:
+	typedef typename storage::value_semantics<T,ARG_CAPACITY> TStorageTraits;
+	typedef typename TStorageTraits::TValue TTValue;
+ 	enum 
+	{
+		CAPACITY		= ARG_CAPACITY
+	};
+	heap_vs() {}
+};
+
+template<class T, int ARG_CAPACITY>
+class heap_os : public heap_base<storage::object_semantics<T,ARG_CAPACITY> >
+{
+public:
+	typedef typename storage::object_semantics<T,ARG_CAPACITY> TStorageTraits;
+	typedef typename TStorageTraits::TValue TTValue;
+ 	enum 
+	{
+		CAPACITY		= ARG_CAPACITY
+	};
+	heap_os() {}
+};
+
+template<class T, int ARG_CAPACITY, int ARG_MAX_CLASS_SIZE>
+class heap_is : public heap_base<storage::virtual_semantics<T,ARG_CAPACITY,ARG_MAX_CLASS_SIZE> >
+{
+public:
+	typedef typename storage::virtual_semantics<T,ARG_CAPACITY,ARG_MAX_CLASS_SIZE> TStorageTraits;
+	typedef typename TStorageTraits::TValue TTValue;
+ 	enum 
+	{
+		CAPACITY		= ARG_CAPACITY,
+		MAX_CLASS_SIZE	= ARG_MAX_CLASS_SIZE
+	};
+	heap_is() {}
+};
+
+}
+#endif
diff --git a/code/Ratl/list_vs.h b/code/Ratl/list_vs.h
new file mode 100644
index 0000000..37c23e5
--- /dev/null
+++ b/code/Ratl/list_vs.h
@@ -0,0 +1,751 @@
+////////////////////////////////////////////////////////////////////////////////////////
+// RAVEN STANDARD TEMPLATE LIBRARY
+//  (c) 2002 Activision
+//
+//
+// List
+// ----
+// The list class supports ordered insertion and deletion in O(1) constant time.
+// It simulates a linked list of pointers by allocating free spots in a pool and
+// maintaining "links" as indicies to the pool array objects.
+//
+//
+//
+// NOTES:
+// 
+//
+//
+////////////////////////////////////////////////////////////////////////////////////////
+#if !defined(RATL_LIST_VS_INC)
+#define RATL_LIST_VS_INC
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Includes
+////////////////////////////////////////////////////////////////////////////////////////
+#if defined(RA_DEBUG_LINKING)
+	#pragma message("...including list_vs.h")
+#endif
+#if !defined(RATL_COMMON_INC)
+	#include "ratl_common.h"
+#endif
+#if !defined(RATL_POOL_VS_INC)
+	#include "pool_vs.h"
+#endif
+namespace ratl
+{
+
+
+// this is private to the list, but you have no access to it, soooo..
+class list_node
+{
+public:
+	int		mNext;
+	int		mPrev;
+};
+
+////////////////////////////////////////////////////////////////////////////////////////
+// The List Class
+////////////////////////////////////////////////////////////////////////////////////////
+template <class T>
+class list_base : public ratl_base
+{
+public:
+	typedef typename T TStorageTraits;
+	typedef typename T::TValue TTValue;
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Capacity Enum
+    ////////////////////////////////////////////////////////////////////////////////////
+ 	enum 
+	{
+		CAPACITY		= T::CAPACITY
+	};
+private:
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Data
+    ////////////////////////////////////////////////////////////////////////////////////
+	pool_base<TStorageTraits>		mPool;				// The Allocation Data Pool
+
+	int				mFront;				// The Beginning Of The List
+	int				mBack;				// The End Of The List
+ 	enum 
+	{
+		NULL_NODE		= -1
+	};
+
+public:
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Constructor
+    ////////////////////////////////////////////////////////////////////////////////////
+	list_base() : mFront(NULL_NODE), mBack(NULL_NODE)
+	{
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// How Many Objects Are In This List
+    ////////////////////////////////////////////////////////////////////////////////////
+	int			size() const
+	{
+		return (mPool.size());
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Are There Any Objects In This List?
+    ////////////////////////////////////////////////////////////////////////////////////
+	bool		empty() const
+	{
+		assert(mFront!=NULL_NODE || size()==0);
+		return (mFront==NULL_NODE);
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Is This List Filled?
+    ////////////////////////////////////////////////////////////////////////////////////
+	bool		full() const
+	{
+		return (mPool.full());
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Clear All Elements
+    ////////////////////////////////////////////////////////////////////////////////////
+	void		clear()
+	{
+		mFront = NULL_NODE;
+		mBack  = NULL_NODE;
+		mPool.clear();
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Get The First Object In The List
+    ////////////////////////////////////////////////////////////////////////////////////
+	TTValue &			front()
+	{
+		assert(mFront!=NULL_NODE);  // this is empty
+		return mPool[mFront];
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Get The Last Object In The List
+    ////////////////////////////////////////////////////////////////////////////////////
+	TTValue &			back()
+	{
+		assert(mBack!=NULL_NODE);
+		return mPool[mBack];
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Get The First Object In The List
+    ////////////////////////////////////////////////////////////////////////////////////
+	const TTValue &			front() const
+	{
+		assert(mFront!=NULL_NODE);  // this is empty
+		return mPool[mFront];
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Get The Last Object In The List
+    ////////////////////////////////////////////////////////////////////////////////////
+	const TTValue &			back() const
+	{
+		assert(mBack!=NULL_NODE);
+		return mPool[mBack];
+	}
+
+public:
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Iterator
+    ////////////////////////////////////////////////////////////////////////////////////
+	class const_iterator;
+	class iterator
+	{
+		friend class list_base<T>;
+		friend class const_iterator;
+
+		int						mLoc;
+		list_base<T>*			mOwner;
+
+
+	public:
+		// Constructors
+		//--------------
+		iterator()						: mOwner(0), mLoc(0)
+		{}
+		iterator(list_base* p, int t)		: mOwner(p), mLoc(t)
+		{}
+		iterator(const iterator &t)		: mOwner(t.mOwner), mLoc(t.mLoc)
+		{}
+
+		// Assignment Operator
+		//---------------------
+		void		operator= (const iterator &t)
+		{
+			mOwner	= t.mOwner;	
+			mLoc	= t.mLoc;
+		}
+
+
+		// Equality Operators
+		//--------------------
+		bool		operator!=(const iterator &t)	const
+		{
+			return (mLoc!=t.mLoc  || mOwner!=t.mOwner);
+		}
+		bool		operator==(const iterator &t)	const				
+		{
+			return (mLoc==t.mLoc && mOwner==t.mOwner);
+		}
+
+		// DeReference Operator
+		//----------------------
+		TTValue&			operator* ()	const			
+		{
+			assert(mLoc>=0 && mLoc<T::CAPACITY);
+			return (mOwner->mPool[mLoc]);
+		}
+
+		// DeReference Operator
+		//----------------------
+		TTValue&			value()	const			
+		{
+			assert(mLoc>=0 && mLoc<T::CAPACITY);
+			return (mOwner->mPool[mLoc]);
+		}
+
+		// DeReference Operator
+		//----------------------
+		TTValue*			operator-> ()	const			
+		{
+			assert(mLoc>=0 && mLoc<T::CAPACITY);
+			return (&mOwner->mPool[mLoc]);
+		}
+
+		// prefix Inc Operator
+		//--------------
+		iterator operator++(int)
+		{
+			assert(mLoc>=0 && mLoc<T::CAPACITY);
+			iterator old(*this);
+			mLoc = T::node(mOwner->mPool[mLoc]).mNext;
+			return old;
+		}
+
+		// postfix Inc Operator
+		//--------------
+		iterator operator++()
+		{
+			assert(mLoc>=0 && mLoc<T::CAPACITY);
+			mLoc = T::node(mOwner->mPool[mLoc]).mNext;
+			return *this;
+		}
+		// prefix Inc Operator
+		//--------------
+		iterator operator--(int)
+		{
+			assert(mLoc>=0 && mLoc<T::CAPACITY);
+			iterator old(*this);
+			mLoc = T::node(mOwner->mPool[mLoc]).mPrev;
+			return old;
+		}
+
+		//--------------
+		// postfix Dec Operator
+		//--------------
+		iterator operator--()
+		{
+			assert(mLoc>=0 && mLoc<T::CAPACITY);
+			mLoc = T::node(mOwner->mPool[mLoc]).mPrev;
+			return *this;
+		}
+
+	};
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Constant Iterator
+    ////////////////////////////////////////////////////////////////////////////////////
+	class const_iterator
+	{
+		friend class list_base<T>;
+
+		int								mLoc;
+		const list_base<T>*				mOwner;
+
+	public:
+		// Constructors
+		//--------------
+		const_iterator()							: mOwner(0), mLoc(0)
+		{}
+		const_iterator(const list_base* p, int t)	: mOwner(p), mLoc(t)
+		{}
+		const_iterator(const const_iterator &t)		: mOwner(t.mOwner), mLoc(t.mLoc)
+		{}
+		const_iterator(const iterator &t)			: mOwner(t.mOwner), mLoc(t.mLoc)
+		{}
+
+		// Assignment Operator
+		//---------------------
+		void		operator= (const const_iterator &t)
+		{
+			mOwner	= t.mOwner;	
+			mLoc	= t.mLoc;
+		}
+		// Assignment Operator
+		//---------------------
+		void		operator= (const iterator &t)
+		{
+			mOwner	= t.mOwner;	
+			mLoc	= t.mLoc;
+		}
+
+
+
+		// Equality Operators
+		//--------------------
+		bool		operator!=(const iterator &t)		const
+		{
+			return (mLoc!=t.mLoc  || mOwner!=t.mOwner);
+		}
+		bool		operator==(const iterator &t)		const				
+		{
+			return (mLoc==t.mLoc && mOwner==t.mOwner);
+		}
+
+		// Equality Operators
+		//--------------------
+		bool		operator!=(const const_iterator &t)		const
+		{
+			return (mLoc!=t.mLoc || mOwner!=t.mOwner);
+		}
+		bool		operator==(const const_iterator &t)		const				
+		{
+			return (mLoc==t.mLoc  && mOwner==t.mOwner);
+		}
+
+		// DeReference Operator
+		//----------------------
+		const TTValue&			operator* ()		const
+		{
+			assert(mLoc>=0 && mLoc<T::CAPACITY);
+			return (mOwner->mPool[mLoc]);
+		}
+
+		// DeReference Operator
+		//----------------------
+		const TTValue*			operator-> ()		const
+		{
+			assert(mLoc>=0 && mLoc<T::CAPACITY);
+			return (&mOwner->mPool[mLoc]);
+		}
+
+		// DeReference Operator
+		//----------------------
+		const TTValue&			value()	const			
+		{
+			assert(mLoc>=0 && mLoc<T::CAPACITY);
+			return (mOwner->mPool[mLoc]);
+		}
+
+		// prefix Inc Operator
+		//--------------
+		const_iterator operator++(int)
+		{
+			assert(mLoc>=0 && mLoc<T::CAPACITY);
+			const_iterator old(*this);
+			mLoc = T::node(mOwner->mPool[mLoc]).mNext;
+			return old;
+		}
+
+		// postfix Inc Operator
+		//--------------
+		const_iterator operator++()
+		{
+			assert(mLoc>=0 && mLoc<T::CAPACITY);
+			mLoc = T::node(mOwner->mPool[mLoc]).mNext;
+			return *this;
+		}
+		// prefix Inc Operator
+		//--------------
+		const_iterator operator--(int)
+		{
+			assert(mLoc>=0 && mLoc<T::CAPACITY);
+			const_iterator old(*this);
+			mLoc = T::node(mOwner->mPool[mLoc]).mPrev;
+			return old;
+		}
+
+		//--------------
+		// postfix Dec Operator
+		//--------------
+		const_iterator operator--()
+		{
+			assert(mLoc>=0 && mLoc<T::CAPACITY);
+			mLoc = T::node(mOwner->mPool[mLoc]).mPrev;
+			return *this;
+		}
+	};
+	friend class				iterator;
+	friend class				const_iterator;
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Iterator Begin (Starts At Address mFront)
+    ////////////////////////////////////////////////////////////////////////////////////
+	iterator	begin()
+	{
+		return iterator(this, mFront);
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Iterator Begin (Starts At Address mFront)
+    ////////////////////////////////////////////////////////////////////////////////////
+	const_iterator	begin() const
+	{
+		return const_iterator(this, mFront);
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Reverse Iterator Begin (Starts At Address mBack)
+    ////////////////////////////////////////////////////////////////////////////////////
+	iterator	rbegin()
+	{
+		return iterator(this, mBack);
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Reverse Iterator Begin (Starts At Address mBack)
+    ////////////////////////////////////////////////////////////////////////////////////
+	const_iterator	rbegin() const
+	{
+		return const_iterator(this, mBack);
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Iterator End (Set To Address NULL_NODE)  Should Work For Forward & Backward Iteration
+    ////////////////////////////////////////////////////////////////////////////////////
+	iterator	end()
+	{
+		return iterator(this, NULL_NODE);
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Iterator End (Set To Address NULL_NODE)  Should Work For Forward & Backward Iteration
+    ////////////////////////////////////////////////////////////////////////////////////
+	const_iterator	end() const
+	{
+		return const_iterator(this, NULL_NODE);
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Iterator Insert (BEFORE POINTED ELEMENT)
+    ////////////////////////////////////////////////////////////////////////////////////
+	T&			insert(const iterator& it)
+	{
+		int nNew= mPool.alloc();
+		insert_low(it,nNew);
+		return mPool[mNew];
+	}
+	////////////////////////////////////////////////////////////////////////////////////
+	// Iterator Insert Value(BEFORE POINTED ELEMENT)
+    ////////////////////////////////////////////////////////////////////////////////////
+	void	insert(const iterator& it, const TTValue& val)
+	{
+		int nNew= mPool.alloc(val);
+		insert_low(it,nNew);
+	}
+	////////////////////////////////////////////////////////////////////////////////////
+	// Iterator Insert Raw(BEFORE POINTED ELEMENT)
+    ////////////////////////////////////////////////////////////////////////////////////
+	TRatlNew*	insert_raw(const iterator& it)
+	{
+		TRatlNew *ret = mPool.alloc_raw();
+		insert_low(it,mPool.pointer_to_index(ret));
+		return ret;
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Iterator Insert (AFTER POINTED ELEMENT) (ALSO - NOT CONSTANT, WILL CHANGE it)
+    ////////////////////////////////////////////////////////////////////////////////////
+	T&			insert_after(iterator& it)
+	{
+		int nNew= mPool.alloc();
+		insert_low_after(it,nNew);
+		it = iterator(this, nNew);
+		return mPool[mNew];
+	}
+	////////////////////////////////////////////////////////////////////////////////////
+	// Iterator Insert Value(AFTER POINTED ELEMENT) (ALSO - NOT CONSTANT, WILL CHANGE it)
+    ////////////////////////////////////////////////////////////////////////////////////
+	void	insert_after(iterator& it, const TTValue& val)
+	{
+		int nNew= mPool.alloc(val);
+		insert_low_after(it,nNew);
+		it = iterator(this, nNew);
+	}
+	////////////////////////////////////////////////////////////////////////////////////
+	// Iterator Insert Raw(AFTER POINTED ELEMENT) (ALSO - NOT CONSTANT, WILL CHANGE it)
+    ////////////////////////////////////////////////////////////////////////////////////
+	TRatlNew*	insert_raw_after(iterator& it)
+	{
+		TRatlNew *ret = mPool.alloc_raw();
+		insert_low_after(it,mPool.pointer_to_index(ret));
+		it = iterator(this, mPool.pointer_to_index(ret));
+		return ret;
+	}
+
+
+
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Front Insert (BEFORE POINTED ELEMENT)
+    ////////////////////////////////////////////////////////////////////////////////////
+	T&			push_front()
+	{
+		int nNew= mPool.alloc();
+		insert_low(begin(),nNew);
+		return mPool[mNew];
+	}
+	////////////////////////////////////////////////////////////////////////////////////
+	// Front Insert Value(BEFORE POINTED ELEMENT)
+    ////////////////////////////////////////////////////////////////////////////////////
+	void	push_front(const TTValue& val)
+	{
+		int nNew= mPool.alloc(val);
+		insert_low(begin(),nNew);
+	}
+	////////////////////////////////////////////////////////////////////////////////////
+	// Front Insert Raw(BEFORE POINTED ELEMENT)
+    ////////////////////////////////////////////////////////////////////////////////////
+	TRatlNew *	push_front_raw()
+	{
+		TRatlNew *ret = mPool.alloc_raw();
+		insert_low(begin(),mPool.pointer_to_index(ret));
+		return ret;
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Front Insert (BEFORE POINTED ELEMENT)
+    ////////////////////////////////////////////////////////////////////////////////////
+	T&			push_back()
+	{
+		int nNew= mPool.alloc();
+		insert_low(end(),nNew);
+		return mPool[mNew];
+	}
+	////////////////////////////////////////////////////////////////////////////////////
+	// Front Insert Value(BEFORE POINTED ELEMENT)
+    ////////////////////////////////////////////////////////////////////////////////////
+	void	push_back(const TTValue& val)
+	{
+		int nNew= mPool.alloc(val);
+		insert_low(end(),nNew);
+	}
+	////////////////////////////////////////////////////////////////////////////////////
+	// Front Insert Raw(BEFORE POINTED ELEMENT)
+    ////////////////////////////////////////////////////////////////////////////////////
+	TRatlNew *	push_back_raw()
+	{
+		TRatlNew *ret = mPool.alloc_raw();
+		insert_low(end(),mPool.pointer_to_index(ret));
+		return ret;
+	}
+	////////////////////////////////////////////////////////////////////////////////////
+	// Iterator Erase
+    ////////////////////////////////////////////////////////////////////////////////////
+	void		erase(iterator& it)
+	{
+		assert(it.mOwner==this);		// Iterators must be mixed up, this is from a different list.
+		assert(it.mLoc!=NULL_NODE);
+
+		int		At				= it.mLoc;
+		int		Prev			= T::node(mPool[At]).mPrev;
+		int		Next			= T::node(mPool[At]).mNext;
+
+		// LINK: (Prev)<-(At)--(Next)
+		//--------------------------------------------
+		if (Next!=NULL_NODE)
+		{
+			T::node(mPool[Next]).mPrev	= Prev;
+		}
+
+		// LINK: (Prev)--(At)->(Next)
+		//--------------------------------------------
+		if (Prev!=NULL_NODE)
+		{
+			T::node(mPool[Prev]).mNext	= Next;
+		}
+
+		// UPDATE: Front & Back
+		//----------------------
+		if (At==mBack)
+		{
+			mBack				= Prev;
+		}
+		if (At==mFront)
+		{
+			mFront				= Next;
+		}
+
+		// ERASE At
+		//--------------------------------------------
+		mPool.free(At);
+		it.mLoc = Prev;
+	}
+	template<class CAST_TO>
+	CAST_TO *verify_alloc(CAST_TO *p) const
+	{
+		return mPool.verify_alloc(p);
+	}
+private:
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Iterator Insert, returns pool index
+    ////////////////////////////////////////////////////////////////////////////////////
+	void insert_low(const iterator& it,int nNew)
+	{
+		assert(it.mOwner==this);	// Iterators must be mixed up, this is from a different list.
+
+		int		Next				= it.mLoc;
+		int		Prev				= NULL_NODE;
+		if (Next!=NULL_NODE)
+		{
+			Prev = T::node(mPool[Next]).mPrev;
+		}
+		else
+		{
+			Prev = mBack;
+		}
+
+
+		assert(nNew!=Next && nNew!=Prev);
+
+
+		// LINK: (Prev)<-(New)->(Next)
+		//--------------------------------------------
+		T::node(mPool[nNew]).mPrev			= Prev;
+		T::node(mPool[nNew]).mNext			= Next;
+
+
+		// LINK:         (New)<-(Next)
+		//--------------------------------------------
+		if (Next!=NULL_NODE)
+		{
+			T::node(mPool[Next]).mPrev		= nNew;
+			assert(T::node(mPool[Next]).mPrev!=T::node(mPool[Next]).mNext);
+		}
+		else
+		{
+			mBack					= nNew;
+		}
+
+
+		// LINK: (Prev)->(New)
+		//--------------------------------------------
+		if (Prev!=NULL_NODE)
+		{
+			T::node(mPool[Prev]).mNext		= nNew;
+			assert(T::node(mPool[Prev]).mPrev!=T::node(mPool[Prev]).mNext);
+		}
+		else
+		{
+			mFront					= nNew;
+		}
+	}
+
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Iterator Insert, returns pool index (AFTER POINTED ELEMENT)
+    ////////////////////////////////////////////////////////////////////////////////////
+	void insert_low_after(const iterator& it,int nNew)
+	{
+		assert(it.mOwner==this);	// Iterators must be mixed up, this is from a different list.
+
+		int		Next				= NULL_NODE;//it.mLoc;
+		int		Prev				= it.mLoc;//NULL_NODE;
+		if (Prev!=NULL_NODE)
+		{
+			Next = T::node(mPool[Prev]).mNext;
+		}
+		else
+		{
+			Prev = mFront;
+		}
+
+
+		assert(nNew!=Next && nNew!=Prev);
+
+
+		// LINK: (Prev)<-(New)->(Next)
+		//--------------------------------------------
+		T::node(mPool[nNew]).mPrev			= Prev;
+		T::node(mPool[nNew]).mNext			= Next;
+
+
+		// LINK:         (New)<-(Next)
+		//--------------------------------------------
+		if (Next!=NULL_NODE)
+		{
+			T::node(mPool[Next]).mPrev		= nNew;
+			assert(T::node(mPool[Next]).mPrev!=T::node(mPool[Next]).mNext);
+		}
+		else
+		{
+			mBack					= nNew;
+		}
+
+
+		// LINK: (Prev)->(New)
+		//--------------------------------------------
+		if (Prev!=NULL_NODE)
+		{
+			T::node(mPool[Prev]).mNext		= nNew;
+			assert(T::node(mPool[Prev]).mPrev!=T::node(mPool[Prev]).mNext);
+		}
+		else
+		{
+			mFront					= nNew;
+		}
+	}
+
+};
+
+template<class T, int ARG_CAPACITY>
+class list_vs : public list_base<storage::value_semantics_node<T,ARG_CAPACITY,list_node> >
+{
+public:
+	typedef typename storage::value_semantics_node<T,ARG_CAPACITY,list_node> TStorageTraits;
+	typedef typename TStorageTraits::TValue TTValue;
+ 	enum 
+	{
+		CAPACITY		= ARG_CAPACITY
+	};
+	list_vs() {}
+};
+
+template<class T, int ARG_CAPACITY>
+class list_os : public list_base<storage::object_semantics_node<T,ARG_CAPACITY,list_node> >
+{
+public:
+	typedef typename storage::object_semantics_node<T,ARG_CAPACITY,list_node> TStorageTraits;
+	typedef typename TStorageTraits::TValue TTValue;
+ 	enum 
+	{
+		CAPACITY		= ARG_CAPACITY
+	};
+	list_os() {}
+};
+
+template<class T, int ARG_CAPACITY, int ARG_MAX_CLASS_SIZE>
+class list_is : public list_base<storage::virtual_semantics_node<T,ARG_CAPACITY,ARG_MAX_CLASS_SIZE,list_node> >
+{
+public:
+	typedef typename storage::virtual_semantics_node<T,ARG_CAPACITY,ARG_MAX_CLASS_SIZE,list_node> TStorageTraits;
+	typedef typename TStorageTraits::TValue TTValue;
+ 	enum 
+	{
+		CAPACITY		= ARG_CAPACITY,
+		MAX_CLASS_SIZE	= ARG_MAX_CLASS_SIZE
+	};
+	list_is() {}
+};
+
+}
+#endif
\ No newline at end of file
diff --git a/code/Ratl/map_vs.h b/code/Ratl/map_vs.h
new file mode 100644
index 0000000..819759b
--- /dev/null
+++ b/code/Ratl/map_vs.h
@@ -0,0 +1,1629 @@
+////////////////////////////////////////////////////////////////////////////////////////
+// RAVEN STANDARD TEMPLATE LIBRARY
+//  (c) 2002 Activision
+//
+//
+// Map
+// ---
+// This map is based on a red black tree, which guarentees balanced data, no mater what
+// order elements are added.  The map uses a memory pool for storage of node data.
+//
+//
+////////////////////////////////////////////////////////////////////////////////////////
+#if !defined(RATL_MAP_VS_INC)
+#define RATL_MAP_VS_INC
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Includes
+////////////////////////////////////////////////////////////////////////////////////////
+#if defined(RA_DEBUG_LINKING)
+	#pragma message("...including map_vs.h")
+#endif
+#if !defined(RATL_COMMON_INC)
+	#include "ratl_common.h"
+#endif
+#if !defined(RATL_POOL_VS_INC)
+	#include "pool_vs.h"
+#endif
+namespace ratl
+{
+
+
+// this is private to the set, but you have no access to it, soooo..
+	
+class tree_node
+{
+	int		mParent;
+	int		mLeft;
+	int		mRight;
+public:
+ 	enum 
+	{
+		RED_BIT			= 0x40000000, // to save space we are putting the red bool in a high bit
+										// this is in the parent only
+		NULL_NODE		= 0x3fffffff, // this must not have the red bit set
+	};
+	void	init()
+	{
+		mLeft	= NULL_NODE;
+		mRight	= NULL_NODE;
+		mParent	= NULL_NODE | RED_BIT;
+	}
+	int left() const
+	{
+		return mLeft;
+	}
+	int right() const
+	{
+		return mRight;
+	}
+	int parent() const
+	{
+		return mParent & (~RED_BIT);
+	}
+	bool red() const
+	{
+		return !!(mParent & RED_BIT);
+	}
+	void set_left(int l)
+	{
+		mLeft = l;
+	}
+	void set_right(int r)
+	{
+		mRight = r;
+	}
+	void set_parent(int p)
+	{
+		mParent &= RED_BIT;
+		mParent	|= p;
+	}
+	void set_red(bool isRed)
+	{
+		if (isRed)
+		{
+			mParent |= RED_BIT;
+		}
+		else
+		{
+			mParent &= ~RED_BIT;
+		}
+	}
+};
+
+//fixme void *, comparison function pointer-ize this for code bloat.
+
+template<class T, int IS_MULTI>
+class tree_base
+{
+public:
+	typedef typename T TStorageTraits;
+	typedef typename T::TValue TTValue;
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Capacity Enum
+    ////////////////////////////////////////////////////////////////////////////////////
+ 	enum 
+	{
+		CAPACITY		= T::CAPACITY,
+	};
+private:
+	pool_base<TStorageTraits>		mPool;				// The Allocation Data Pool
+	int								mRoot;
+	int								mLastAdd;
+
+
+	void link_left(int node,int left)
+	{
+		T::node(mPool[node]).set_left(left);
+		if (left!=tree_node::NULL_NODE)
+		{
+			T::node(mPool[left]).set_parent(node);
+		}
+	}
+
+	void link_right(int node,int right)
+	{
+		T::node(mPool[node]).set_right(right);
+		if (right!=tree_node::NULL_NODE)
+		{
+			T::node(mPool[right]).set_parent(node);
+		}
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// This is the map internal recursive find function - do not use externally
+    ////////////////////////////////////////////////////////////////////////////////////
+	int			find_internal(const TTValue &key, int at) const
+	{
+
+		// FAIL TO FIND?
+		//---------------
+		if (at==tree_node::NULL_NODE)
+		{
+			return tree_node::NULL_NODE;
+		}
+
+		// Should We Search Left?
+		//------------------------
+		if      (key<mPool[at])
+		{
+			return find_internal(key, T::node(mPool[at]).left());
+		}
+
+		// Should We Search Right?
+		//------------------------
+		else if (mPool[at]<key)
+		{
+			return find_internal(key, T::node(mPool[at]).right());
+		}
+
+		// FOUND!
+		//--------
+		return at;
+	}
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// This is the map internal recursive find function - do not use externally
+    ////////////////////////////////////////////////////////////////////////////////////
+	int			find_internal(const TTValue &key, int target, int at, int& parent) const
+	{
+		// FAIL TO FIND?
+		//---------------
+		if (at==tree_node::NULL_NODE)
+		{
+			parent = tree_node::NULL_NODE;
+			return tree_node::NULL_NODE;
+		}
+
+		// FOUND!
+		//--------
+		if (at==target)
+		{
+			if (at==mRoot)
+			{
+				parent = tree_node::NULL_NODE;
+			}
+			return at;
+		}
+
+		// Should We Search Left?
+		//------------------------
+		if      (key<mPool[at])
+		{
+			parent = at;
+			return find_internal(key, target, T::node(mPool[at]).left(), parent);
+		}
+
+		parent = at;
+		return find_internal(key, target, T::node(mPool[at]).right(), parent);
+	}
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// This is the map internal recursive insertion - do not use externally
+    ////////////////////////////////////////////////////////////////////////////////////
+	int			insert_internal(const TTValue &key, int &at)
+	{
+		// If At Is A NULL_NODE, We Have Found A Leaf.  
+		//----------------------------------------------
+		if (at==tree_node::NULL_NODE)
+		{
+			if (mRoot==tree_node::NULL_NODE)
+			{
+				mRoot = mLastAdd;
+			}
+			return tree_node::NULL_NODE;					// There Are No Excess Red Children (No Childeren At All, Actually)
+		}
+
+
+		int		nxtChild;						// The Child We Will Eventually Add Underneath
+		int		altChild;						// The "other" Child
+		bool	nxtRotateLeft;
+		int		excessRedChild;					// If The Insert Results In An Excess Red Child, This Will Be It
+
+
+		// Choose Which Side To Add The New Node Under
+		//---------------------------------------------
+		if (key < mPool[at])						// The Key Classes Must Support A < Operator
+		{
+			int tmp=T::node(mPool[at]).left();
+			excessRedChild = insert_internal(key,tmp);
+			link_left(at,tmp);//T::node(mPool[at]).set_left(tmp);
+
+			if (tmp==tree_node::NULL_NODE)
+			{
+
+				link_left(at,mLastAdd);//T::node(mPool[at]).set_left(mLastAdd);			// If mLeft Of The Current Node Is NULL, We Must Have Added DIRECTLY Below nAt
+			}
+			nxtChild = T::node(mPool[at]).left();
+			altChild = T::node(mPool[at]).right();
+			nxtRotateLeft = false;
+		}
+		else if (mPool[at] < key)
+		{
+			int tmp=T::node(mPool[at]).right();
+			excessRedChild = insert_internal(key,tmp);
+			link_right(at,tmp); // T::node(mPool[at]).set_right(tmp);
+
+			if (tmp==tree_node::NULL_NODE)
+			{
+				link_right(at,mLastAdd); // T::node(mPool[at]).set_right(mLastAdd);			// If mRight Of The Current Node Is NULL, We Must Have Added DIRECTLY Below nAt
+			}
+			nxtChild = T::node(mPool[at]).right();
+			altChild = T::node(mPool[at]).left();
+			nxtRotateLeft = true;
+		}
+
+		// Exact Match
+		//-------------
+		else
+		{
+			// the node of interest is at
+			return tree_node::NULL_NODE;
+		}
+
+		
+		// If The Add Resulted In An Excess Red Child, We Need To Change Colors And Rotate
+		//---------------------------------------------------------------------------------		
+		if (excessRedChild!=tree_node::NULL_NODE)
+		{
+			// If Both Childeren Are Red, Just Switch And Be Done
+			//----------------------------------------------------
+			if (T::node(mPool[at]).right()!=tree_node::NULL_NODE && 
+				T::node(mPool[at]).left()!=tree_node::NULL_NODE && 
+				T::node(mPool[T::node(mPool[at]).right()]).red() && 
+				T::node(mPool[T::node(mPool[at]).left()]).red())
+			{
+				set_colors(T::node(mPool[at]), true, false);
+			}
+			else
+			{
+				int	excessRedChildCompare = 
+					(nxtRotateLeft)?(T::node(mPool[nxtChild]).right()):(T::node(mPool[nxtChild]).left());
+				if (excessRedChild==excessRedChildCompare)
+				{
+					// Single Rotation
+					//-----------------
+					rotate(at,   nxtRotateLeft);
+				}
+				else
+				{
+					if (nxtRotateLeft)
+					{
+						int nxt=T::node(mPool[at]).right();
+						rotate(nxt, false);
+						link_right(at,nxt); // T::node(mPool[at]).set_right(nxt);
+					}
+					else
+					{
+						int nxt=T::node(mPool[at]).left();
+						rotate(nxt,true);
+						link_left(at,nxt); // T::node(mPool[at]).set_left(nxt);
+					}
+					rotate(at,   nxtRotateLeft);
+				}
+
+				set_colors(T::node(mPool[at]), false, true);
+			}
+		}
+		
+		if (T::node(mPool[at]).red())
+		{
+			if (T::node(mPool[at]).left()!=tree_node::NULL_NODE && 
+				T::node(mPool[T::node(mPool[at]).left()]).red())
+			{
+				return T::node(mPool[at]).left();
+			}
+			if (T::node(mPool[at]).right()!=tree_node::NULL_NODE && 
+				T::node(mPool[T::node(mPool[at]).right()]).red())
+			{
+				return T::node(mPool[at]).right();
+			}
+		}
+		return tree_node::NULL_NODE;
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// This is the map internal recursive erase - do not use externally
+    ////////////////////////////////////////////////////////////////////////////////////
+	bool	erase_internal(const TTValue &key, int& at)
+	{
+		// If At Is A NULL_NODE, We Have Found A Leaf.
+		//---------------------------------------------
+		if (at==tree_node::NULL_NODE)
+		{
+			return true;
+		}
+
+		//==============================================================================
+		// Now The Question Is, Do We Need To Continue Searching?
+		//==============================================================================
+
+
+		// Recurse To The Left?
+		//----------------------
+		if (key < mPool[at])
+		{
+			int a=T::node(mPool[at]).left();
+			bool r=erase_internal(key, a);
+			link_left(at,a); // T::node(mPool[at]).set_left(a);
+			if (!r)		// If It Was Not Red, We Need To Rebalance
+			{
+				return rebalance(at, true);
+			}
+			return true;
+		}
+
+		// Recurse To The Right?
+		//-----------------------
+		if (mPool[at] < key)
+		{
+			int a=T::node(mPool[at]).right();
+			bool r=erase_internal(key, a);
+			link_right(at,a); // T::node(mPool[at]).set_right(a);
+			if (!r)		// If It Was Not Red, We Need To Rebalance
+			{
+				return rebalance(at, false);
+			}
+			return true;
+		}
+
+		//==============================================================================
+		// At This Point, We Must Have Discovered An Exact Match For Our Key
+		//==============================================================================
+
+
+		// Are There Any Open Childeren Slots?
+		//-------------------------------------
+		if (T::node(mPool[at]).left()==tree_node::NULL_NODE || T::node(mPool[at]).right()==tree_node::NULL_NODE)
+		{
+			bool	atWasRed	= T::node(mPool[at]).red();
+			int		oldAt		= at;
+
+			at = (T::node(mPool[at]).left()==tree_node::NULL_NODE)?(T::node(mPool[at]).right()):(T::node(mPool[at]).left());	// If Left Is Null, At Goes Right
+
+			// Actually Free It!
+			//-------------------
+			mPool.free(oldAt);
+
+			// If We Are Now At A Null Node, Just Return
+			//-------------------------------------------
+			if (at==tree_node::NULL_NODE)
+			{
+				return atWasRed;
+			}
+
+			// Otherwise, Mark The New Child As Red, And Return That Fact Up
+			//---------------------------------------------------------------
+			T::node(mPool[at]).set_red(false);
+			return true;
+		}
+
+
+		//==============================================================================
+		// There Are No Childeren To Link With, We Are In The Middle Of The Tree.
+		// We Need To Find An Open Leaf, Swap Data With That Leaf, and Then Go Find It
+		//==============================================================================
+
+		// Find A Successor Leaf
+		//-----------------------
+		int at_parent = T::node(mPool[at]).parent();
+		int	successor = T::node(mPool[at]).right();
+
+		int parent_successor=-1;
+		while(T::node(mPool[successor]).left()!=tree_node::NULL_NODE)
+		{
+			parent_successor=successor;
+			successor = T::node(mPool[successor]).left();
+		} 
+		
+		int	successor_right = T::node(mPool[successor]).right();
+
+
+		link_left(successor,T::node(mPool[at]).left());
+
+		bool red=T::node(mPool[successor]).red();
+		T::node(mPool[successor]).set_red(T::node(mPool[at]).red());
+		T::node(mPool[at]).set_red(red);
+
+		if (parent_successor!=-1)
+		{
+
+			link_right(successor,T::node(mPool[at]).right());
+			link_left(parent_successor,at);
+		}
+		else
+		{
+			link_right(successor,at);
+		}
+
+		if (at_parent!=tree_node::NULL_NODE)
+		{
+			if (T::node(mPool[at_parent]).left()==at)
+			{
+				//my parents left child
+				link_left(at_parent,successor);
+			}
+			else
+			{
+				assert(T::node(mPool[at_parent]).right()==at); // better be my parents right child then
+				link_right(at_parent,successor);
+			}
+		}
+
+		link_left(at,tree_node::NULL_NODE);		
+		link_right(at,successor_right);		
+
+		at=successor;
+		int a=T::node(mPool[at]).right();
+		bool r=erase_internal(key, a);
+		link_right(at,a); // T::node(mPool[at]).set_right(a);
+		// And Keep Going
+		//----------------
+		if (!r)		// If It Was Not Red, We Need To Rebalance
+		{
+			return rebalance(at, false);
+		}
+		return true;
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// HELPER: Change the color of a node and children
+    ////////////////////////////////////////////////////////////////////////////////////
+	void		set_colors(tree_node& at, bool red, bool childRed)
+	{
+		at.set_red(red);
+		if (at.left()!=tree_node::NULL_NODE)
+		{
+			T::node(mPool[at.left()]).set_red(childRed);
+		}
+		if (at.right()!=tree_node::NULL_NODE)
+		{
+			T::node(mPool[at.right()]).set_red(childRed);
+		}
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// HELPER: Rotate node located at (at) either left or right
+    ////////////////////////////////////////////////////////////////////////////////////
+	void		rotate(int& at, bool left)
+	{
+		int	t;
+		if (left)
+		{
+			assert(T::node(mPool[at]).right()!=tree_node::NULL_NODE);
+
+			t					= T::node(mPool[at]).right();
+			link_right(at,T::node(mPool[t]).left()); // T::node(mPool[at]).set_right(T::node(mPool[t]).left());
+			link_left(t,at);	// T::node(mPool[t]).set_left(at);
+			at					= t;
+		}
+		else
+		{
+			assert(T::node(mPool[at]).left()!=tree_node::NULL_NODE);
+
+			t					= T::node(mPool[at]).left();
+			link_left(at,T::node(mPool[t]).right()); // T::node(mPool[at]).set_left(T::node(mPool[t]).right());
+			link_right(t,at);	//T::node(mPool[t]).set_right(at);
+			at					= t;
+		}
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// HELPER: Localally rebalance the tree here
+    ////////////////////////////////////////////////////////////////////////////////////
+	bool		rebalance(int& at, bool left)
+	{
+		// Decide Which Child, Left Or Right?
+		//------------------------------------
+		int	w = (left)?(T::node(mPool[at]).right()):(T::node(mPool[at]).left());	// w is the child of at
+		if (w==tree_node::NULL_NODE)
+		{
+			bool	atWasRed = T::node(mPool[at]).red();			// Remember what mPool[at] WAS
+			T::node(mPool[at]).set_red(false);						// Mark mPool[at] as BLACK
+			return  atWasRed;						// Return what it used to be
+		}
+
+
+		// Get A Reference To The Child W, And Record It's Children x And y
+		//------------------------------------------------------------------
+		tree_node&	wAt = T::node(mPool[w]);
+		int		x = (left)?(wAt.left()):(wAt.right());// x and y are the grand children of at
+		int		y = (left)?(wAt.right()):(wAt.left());
+
+
+		// Is The Child Black?
+		//---------------------
+		if (!wAt.red())
+		{
+			// If Both X and Y are Empty, Or Both Are Red
+			//--------------------------------------------
+			if ((x==tree_node::NULL_NODE || !T::node(mPool[x]).red()) && 
+				(y==tree_node::NULL_NODE || !T::node(mPool[y]).red()))
+			{
+				bool	atWasRed = T::node(mPool[at]).red();		// Remember what mPool[at] WAS
+				T::node(mPool[at]).set_red(false);		// Mark mPool[at] as BLACK
+				wAt.set_red(true);					// Mark The Child As RED
+				return  atWasRed;					// Return what it used to be
+			}
+
+			// If Y Is Valid
+			//---------------
+			if (y!=tree_node::NULL_NODE && T::node(mPool[y]).red())
+			{
+				wAt.set_red(T::node(mPool[at]).red());
+				rotate(at, left);
+				T::node(mPool[T::node(mPool[at]).left()]).set_red(false);
+				T::node(mPool[T::node(mPool[at]).right()]).set_red(false);
+				return true;
+			}
+
+			// X Must Be Valid
+			//-----------------
+			T::node(mPool[x]).set_red(T::node(mPool[at]).red());
+			T::node(mPool[at]).set_red(false);
+
+			if (left)
+			{
+				int r=T::node(mPool[at]).right();
+				rotate(r,false);
+				link_right(at,r); // T::node(mPool[at]).set_right(r);
+			}
+			else
+			{
+				int r=T::node(mPool[at]).left();
+				rotate(r,true);
+				link_left(at,r); // T::node(mPool[at]).set_left(r);
+			}
+			rotate(at, left);
+
+			return true;
+		}
+
+		// The Child Must Have Been Red
+		//------------------------------
+		wAt.set_red(T::node(mPool[at]).red());				// Switch Child Color
+		T::node(mPool[at]).set_red(true);
+		rotate(at, left);					// Rotate At
+
+		// Select The Next Rebalance Child And Recurse
+		//----------------------------------------------
+		if (left)
+		{
+			int r=T::node(mPool[at]).left();
+			rebalance(r,true);
+			link_left(at,r); // T::node(mPool[at]).set_left(r);
+		}
+		else
+		{
+			int r=T::node(mPool[at]).right();
+			rebalance(r,false);
+			link_right(at,r); //T::node(mPool[at]).set_right(r);
+		}
+		return true;
+	}
+    ////////////////////////////////////////////////////////////////////////////////////
+	// This is the map internal recursive front function - do not use externally
+    ////////////////////////////////////////////////////////////////////////////////////
+	int			front(int at) const
+	{
+		if (at!=tree_node::NULL_NODE && 
+			T::node(mPool[at]).left()!=tree_node::NULL_NODE)
+		{
+			return front(T::node(mPool[at]).left());
+		}
+		return at;
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// This is the map internal recursive back function - do not use externally
+    ////////////////////////////////////////////////////////////////////////////////////
+	int			back(int at) const
+	{
+		if (at!=tree_node::NULL_NODE && T::node(mPool[at]).right()!=tree_node::NULL_NODE)
+		{
+			return back(T::node(mPool[at]).right());
+		}
+		return at;
+	}
+protected:
+	int			front() const
+	{
+		return front(mRoot);
+	}
+
+	int			back() const
+	{
+		return back(mRoot);
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// This is the map internal recursive next function - do not use externally
+    ////////////////////////////////////////////////////////////////////////////////////
+	int			next(int at) const
+	{
+		assert(at!=tree_node::NULL_NODE);
+		const TTValue&	kAt = mPool[at];
+		const tree_node&	nAt = T::node(kAt);
+		if (nAt.right()!=tree_node::NULL_NODE)
+		{
+			return front(nAt.right());
+		}
+
+		int		child	= at;
+		int		parent	= tree_node::NULL_NODE;
+		find_internal(kAt, at, mRoot, parent);
+
+		while(parent!=tree_node::NULL_NODE && (child==T::node(mPool[parent]).right()))
+		{
+			child = parent;
+			find_internal(mPool[parent], parent, mRoot, parent);
+		}
+		return parent;
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// This is the map internal recursive previous function - do not use externally
+    ////////////////////////////////////////////////////////////////////////////////////
+	int			previous(int at) const
+	{
+		assert(at!=tree_node::NULL_NODE);
+		const TTValue&	kAt = mPool[at];
+		const tree_node&		nAt = T::node(mPool[at]);
+		if (kAt.left()!=tree_node::NULL_NODE)
+		{
+			return back(kAt.left());
+		}
+
+		int		child	= at;
+		int		parent	= tree_node::NULL_NODE;
+		find_internal(nAt, at, mRoot, parent);
+
+		while(parent!=tree_node::NULL_NODE && (child==T::node(mPool[parent]).left()))
+		{
+			child = parent;
+			find_internal(mPool[parent], parent, mRoot, parent);
+		}
+		return parent;
+	}
+
+
+
+public:
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Constructor
+    ////////////////////////////////////////////////////////////////////////////////////
+    tree_base() : mRoot(tree_node::NULL_NODE), mLastAdd(-1)
+	{
+	}
+
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// How Many Objects Are In This Map
+    ////////////////////////////////////////////////////////////////////////////////////
+	int			size() const
+	{
+		return (mPool.size());
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Are There Any Objects In This Map?
+    ////////////////////////////////////////////////////////////////////////////////////
+	bool		empty() const
+	{
+		return (mPool.empty());
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Is This Map Filled?
+    ////////////////////////////////////////////////////////////////////////////////////
+	bool		full() const
+	{
+		return (mPool.full());
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Clear All Data From The Map
+    ////////////////////////////////////////////////////////////////////////////////////
+	void		clear()
+	{
+		mRoot = tree_node::NULL_NODE;
+		mPool.clear();
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Adds Element Value At Location Key  - O(log n)
+    ////////////////////////////////////////////////////////////////////////////////////
+	void alloc_key(const TTValue &key)
+	{
+		
+		//fixme handle duplicates more sensibly?
+		assert(!full());
+		mLastAdd = mPool.alloc(key);			// Grab A New One
+		T::node(mPool[mLastAdd]).init();	// Initialize Our Data And Color
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Allocs an item, when filled, call insert_alloced
+    ////////////////////////////////////////////////////////////////////////////////////
+	TTValue & alloc_key()
+	{		
+		assert(!full());
+		mLastAdd = mPool.alloc();			// Grab A New One
+		T::node(mPool[mLastAdd]).init();	// Initialize Our Data And Color
+		return mPool[mLastAdd];
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Allocs an item (raw), when constucted, call insert_alloced
+    ////////////////////////////////////////////////////////////////////////////////////
+	TRatlNew *alloc_key_raw()
+	{
+		assert(!full());
+		TRatlNew *ret=mPool.alloc_raw();			// Grab A New One
+		mLastAdd = mPool.pointer_to_index(ret);
+		T::node(mPool[mLastAdd]).init();	// Initialize Our Data And Color
+		return ret;
+	}
+	template<class CAST_TO>
+	CAST_TO *verify_alloc_key(CAST_TO *p) const
+	{
+		return mPool.verify_alloc(p);
+	}
+
+	void insert_alloced_key()
+	{
+		assert(mLastAdd>=0&&mLastAdd<CAPACITY);		
+		assert(!IS_MULTI || find_index(mPool[mLastAdd])!=tree_node::NULL_NODE); //fixme handle duplicates more sensibly?
+
+		insert_internal(mPool[mLastAdd],mRoot);
+		assert(mRoot!=tree_node::NULL_NODE);
+		T::node(mPool[mRoot]).set_red(false);
+		T::node(mPool[mRoot]).set_parent(tree_node::NULL_NODE);
+	}
+
+	int index_of_alloced_key() const
+	{
+		assert(mLastAdd>=0&&mLastAdd<CAPACITY);		
+		return mLastAdd;
+	}
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Removes The Element Pointed To At (it) And Decrements (it)  - O((log n)^2)
+    ////////////////////////////////////////////////////////////////////////////////////
+	void erase_index(int i)
+	{
+		assert(i>=0&&i<CAPACITY);
+		assert(mRoot!=tree_node::NULL_NODE);
+
+		//fixme this is lame to have to look by key to erase
+		erase_internal(mPool[i],mRoot);
+		if (mRoot!=tree_node::NULL_NODE)
+		{
+			T::node(mPool[mRoot]).set_red(false);
+			T::node(mPool[mRoot]).set_parent(tree_node::NULL_NODE);
+		}
+	}
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Seach For A Given Key.  Will Return -1 if Failed  - O(log n)
+    ////////////////////////////////////////////////////////////////////////////////////
+	int	find_index(const TTValue &key) const
+	{
+		return find_internal(key, mRoot);
+	}
+	const TTValue &index_to_key(int i) const
+	{
+		assert(i>=0&&i<CAPACITY);
+		return mPool[i];
+	}
+
+	//fixme lower bound, upper bound, equal range
+
+
+};
+
+
+
+template<class T,int IS_MULTI>
+class set_base : public tree_base<T,IS_MULTI>
+{
+
+public:
+	typedef typename T TStorageTraits;
+	typedef typename T::TValue TTValue;
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Capacity Enum
+    ////////////////////////////////////////////////////////////////////////////////////
+ 	enum 
+	{
+		CAPACITY		= T::CAPACITY
+	};
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Adds Element Value At Location Key  - O(log n)
+    ////////////////////////////////////////////////////////////////////////////////////
+	void insert(const TTValue &key)
+	{
+		
+		assert(!IS_MULTI || find_index(key)==tree_node::NULL_NODE); //fixme handle duplicates more sensibly?
+
+		alloc_key(key);
+		insert_alloced_key();
+
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Allocs an item, when filled, call insert_alloced
+    ////////////////////////////////////////////////////////////////////////////////////
+	TTValue & alloc()
+	{		
+		return alloc_key();
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Allocs an item (raw), when constucted, call insert_alloced
+    ////////////////////////////////////////////////////////////////////////////////////
+	TRatlNew *alloc_raw()
+	{
+		return alloc_key_raw();
+	}
+	template<class CAST_TO>
+	CAST_TO *verify_alloc(CAST_TO *p) const
+	{
+		return verify_alloc_key(p);
+	}
+
+	void insert_alloced()
+	{
+		insert_alloced_key();
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Removes The First Element With Key (key)  - O(log n)
+    ////////////////////////////////////////////////////////////////////////////////////
+	void		erase(const TTValue &key)
+	{
+		//fixme this is a double search currently
+		int i=find_index(key);
+		if (i!=tree_node::NULL_NODE)
+		{
+			erase_index(i);
+		}
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Iterator
+	//
+	// A map is sorted in ascending order on the KEY type.  ++ and -- are both
+	// O((log n)^2) operations
+	//
+    ////////////////////////////////////////////////////////////////////////////////////
+	class iterator
+	{
+		friend class set_base<TStorageTraits,IS_MULTI>;
+		friend class const_iterator;
+
+		int			mLoc;
+		set_base<TStorageTraits,IS_MULTI>*	mOwner;
+
+	public:
+		iterator(set_base<TStorageTraits,IS_MULTI> *owner=0, int loc=tree_node::NULL_NODE) : 
+			mOwner(owner), 
+			mLoc(loc)	
+		{
+		}
+		iterator(const iterator &o) : 
+			mOwner(o.mOwner), 
+			mLoc(o.mLoc)	
+		{
+		}
+
+		void operator=(const iterator &o)
+		{
+			mOwner=o.mOwner;
+			mLoc=o.mLoc;
+		}
+
+		iterator	operator++()		//prefix
+		{	
+			assert(mOwner);	
+			mLoc=mOwner->next(mLoc);
+			return *this;
+		}
+		iterator	operator++(int)		//postfix
+		{
+			assert(mOwner);	
+			iterator old(*this);
+			mLoc=mOwner->next(mLoc);
+			return old;
+		}
+
+		iterator	operator--()		//prefix
+		{	
+			assert(mOwner);	
+			mLoc=mOwner->previous(mLoc);
+			return *this;
+		}
+		iterator	operator--(int)		//postfix
+		{
+			assert(mOwner);	
+			iterator old(*this);
+			mLoc=mOwner->previous(mLoc);
+			return old;
+		}
+
+		bool	operator!=(const iterator p) const	{return (mLoc!=p.mLoc || mOwner!=p.mOwner);}
+		bool	operator==(const iterator p) const 	{return (mLoc==p.mLoc && mOwner==p.mOwner);}
+
+		const TTValue &	operator*() const				
+		{
+			assert(mOwner);	
+			assert(mLoc>=0&&mLoc<CAPACITY); // deferencing end()?
+			return mOwner->index_to_key(mLoc);
+		}
+		const TTValue *	operator->() const				
+		{
+			assert(mOwner);	
+			assert(mLoc>=0&&mLoc<CAPACITY); // deferencing end()?
+			return &mOwner->index_to_key(mLoc);
+		}
+	};
+	class const_iterator
+	{
+		friend class set_base<TStorageTraits,IS_MULTI>;
+
+		int		mLoc;
+
+		const set_base<TStorageTraits,IS_MULTI>*		mOwner;
+
+	public:
+		const_iterator(const set_base<TStorageTraits,IS_MULTI> *owner=0, int loc=tree_node::NULL_NODE) : 
+			mOwner(owner), 
+			mLoc(loc)	
+		{
+		}
+		const_iterator(const const_iterator &o) : 
+			mOwner(o.mOwner), 
+			mLoc(o.mLoc)	
+		{
+		}
+		const_iterator(const iterator &o) : 
+			mOwner(o.mOwner), 
+			mLoc(o.mLoc)	
+		{
+		}
+		void operator=(const const_iterator &o)
+		{
+			mOwner=o.mOwner;
+			mLoc=o.mLoc;
+		}
+		void operator=(const iterator &o)
+		{
+			mOwner=o.mOwner;
+			mLoc=o.mLoc;
+		}
+
+
+		const_iterator	operator++()		//prefix
+		{	
+			assert(mOwner);	
+			mLoc=mOwner->next(mLoc);
+			return *this;
+		}
+		const_iterator	operator++(int)		//postfix
+		{
+			assert(mOwner);	
+			const_iterator old(*this);
+			mLoc=mOwner->next(mLoc);
+			return old;
+		}
+
+		const_iterator	operator--()		//prefix
+		{	
+			assert(mOwner);	
+			mLoc=mOwner->previous(mLoc);
+			return *this;
+		}
+		const_iterator	operator--(int)		//postfix
+		{
+			assert(mOwner);	
+			const_iterator old(*this);
+			mLoc=mOwner->previous(mLoc);
+			return old;
+		}
+
+		bool	operator!=(const const_iterator p) const	{return (mLoc!=p.mLoc || mOwner!=p.mOwner);}
+		bool	operator==(const const_iterator p) const 	{return (mLoc==p.mLoc && mOwner==p.mOwner);}
+		bool	operator!=(const iterator p) const	{return (mLoc!=p.mLoc || mOwner!=p.mOwner);}
+		bool	operator==(const iterator p) const 	{return (mLoc==p.mLoc && mOwner==p.mOwner);}
+
+		const TTValue &	operator*() const				
+		{
+			assert(mOwner);	
+			assert(mLoc>=0&&mLoc<CAPACITY); // deferencing end()?
+			return mOwner->index_to_key(mLoc);
+		}
+		const TTValue *	operator->() const				
+		{
+			assert(mOwner);	
+			assert(mLoc>=0&&mLoc<CAPACITY); // deferencing end()?
+			return &mOwner->index_to_key(mLoc);
+		}
+	};
+	friend class iterator;
+	friend class const_iterator;
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Seach For A Given Key.  Will Return end() if Failed  - O(log n)
+    ////////////////////////////////////////////////////////////////////////////////////
+	iterator	find(const TTValue &key)
+	{
+		return iterator(this,find_index(key));		
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Get An Iterator To The Smallest Element  - O(log n)
+    ////////////////////////////////////////////////////////////////////////////////////
+	iterator	begin()
+	{
+		return iterator(this, front());	
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Get An Iterator To The Largest Element  - O(log n)
+    ////////////////////////////////////////////////////////////////////////////////////
+	iterator	rbegin()
+	{
+		return iterator(this, back());
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// The Invalid Iterator, Use As A Stop Condition In Your For Loops  - O(1)
+    ////////////////////////////////////////////////////////////////////////////////////
+	iterator	end()
+	{
+		return iterator(this);
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Seach For A Given Key.  Will Return end() if Failed  - O(log n)
+    ////////////////////////////////////////////////////////////////////////////////////
+	const_iterator	find(const TTValue &key) const
+	{
+		return const_iterator(this, find_index(key));		
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Get An const_iterator To The Smallest Element  - O(log n)
+    ////////////////////////////////////////////////////////////////////////////////////
+	const_iterator	begin() const
+	{
+		return const_iterator(this, front());	
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Get An const_iterator To The Largest Element  - O(log n)
+    ////////////////////////////////////////////////////////////////////////////////////
+	const_iterator	rbegin() const
+	{
+		return const_iterator(this, back());
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// The Invalid const_iterator, Use As A Stop Condition In Your For Loops  - O(1)
+    ////////////////////////////////////////////////////////////////////////////////////
+	const_iterator	end() const
+	{
+		return const_iterator(this);
+	}
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Removes The Element Pointed To At (it) And Decrements (it)  - O((log n)^2)
+    ////////////////////////////////////////////////////////////////////////////////////
+	void		erase(const iterator &it)
+	{
+		assert(it.mOwner==this && it.mLoc>=0&&it.mLoc<CAPACITY);
+		erase_index(it.mLoc);
+	}
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	//
+    ////////////////////////////////////////////////////////////////////////////////////
+	iterator	lower_bound(const TTValue &key)
+	{
+		return iterator(this, find_index(key));
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	//
+    ////////////////////////////////////////////////////////////////////////////////////
+	iterator	upper_bound(const TTValue &key)
+	{
+		// fixme, this don't work
+		iterator ubound(this, find_index(key));
+		ubound++;
+		return ubound;
+	}
+
+};
+
+
+template<class T, int ARG_CAPACITY>
+class set_vs : public set_base<storage::value_semantics_node<T,ARG_CAPACITY,tree_node>,0 >
+{
+public:
+	typedef typename storage::value_semantics_node<T,ARG_CAPACITY,tree_node> TStorageTraits;
+	typedef typename TStorageTraits::TValue TTValue;
+ 	enum 
+	{
+		CAPACITY		= ARG_CAPACITY
+	};
+	set_vs() {}
+};
+
+template<class T, int ARG_CAPACITY>
+class set_os : public set_base<storage::object_semantics_node<T,ARG_CAPACITY,tree_node>,0 >
+{
+public:
+	typedef typename storage::object_semantics_node<T,ARG_CAPACITY,tree_node> TStorageTraits;
+	typedef typename TStorageTraits::TValue TTValue;
+ 	enum 
+	{
+		CAPACITY		= ARG_CAPACITY
+	};
+	set_os() {}
+};
+
+template<class T, int ARG_CAPACITY, int ARG_MAX_CLASS_SIZE>
+class set_is : public set_base<storage::virtual_semantics_node<T,ARG_CAPACITY,ARG_MAX_CLASS_SIZE,tree_node>,0 >
+{
+public:
+	typedef typename storage::virtual_semantics_node<T,ARG_CAPACITY,ARG_MAX_CLASS_SIZE,tree_node> TStorageTraits;
+	typedef typename TStorageTraits::TValue TTValue;
+ 	enum 
+	{
+		CAPACITY		= ARG_CAPACITY,
+		MAX_CLASS_SIZE	= ARG_MAX_CLASS_SIZE
+	};
+	set_is() {}
+};
+
+
+template<class K,class V,int IS_MULTI>
+class map_base : public tree_base<K,IS_MULTI>
+{
+public:
+	typedef typename K TKeyStorageTraits;
+	typedef typename K::TValue TKTValue;
+	typedef typename V TValueStorageTraits;
+	typedef typename V::TValue TVTValue;
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Capacity Enum
+    ////////////////////////////////////////////////////////////////////////////////////
+ 	enum 
+	{
+		CAPACITY		= K::CAPACITY
+	};
+private:
+	array_base<TValueStorageTraits>	mValues;
+public:
+	map_base()
+	{
+		compile_assert<K::CAPACITY==V::CAPACITY>();
+	}
+
+	void clear()
+	{
+		tree_base<K,IS_MULTI>::clear();
+		mValues.clear();
+	}
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Adds Element Value At Location Key  - O(log n)
+    ////////////////////////////////////////////////////////////////////////////////////
+	void insert(const TKTValue &key,const TVTValue &value)
+	{
+		assert(!IS_MULTI || find_index(key)==tree_node::NULL_NODE); //fixme handle duplicates more sensibly?
+
+		alloc_key(key);
+		insert_alloced_key();		
+		assert(check_validity());
+		mValues.construct(index_of_alloced_key(),value);
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Adds Element Value At Location Key  returns a reference
+    ////////////////////////////////////////////////////////////////////////////////////
+	TVTValue &insert(const TKTValue &key)
+	{
+		
+		assert(!IS_MULTI || find_index(key)==tree_node::NULL_NODE); //fixme handle duplicates more sensibly?
+
+		alloc_key(key);
+		insert_alloced_key();		
+
+		int idx=index_of_alloced_key();
+		assert(check_validity());
+		mValues.construct(idx);
+		return mValues[idx];
+	}
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Adds Element Value At Location Key  returns a rew pointer for placement new
+    ////////////////////////////////////////////////////////////////////////////////////
+	TRatlNew *insert_raw(const TKTValue &key)
+	{
+		
+		assert(!IS_MULTI || find_index(key)==tree_node::NULL_NODE); //fixme handle duplicates more sensibly?
+
+		alloc_key(key);
+		insert_alloced_key();		
+		assert(check_validity());
+		return mValues.alloc_raw(index_of_alloced_key());
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// After calling alloc_key*, you may call this to alloc the value
+    ////////////////////////////////////////////////////////////////////////////////////
+	TVTValue &alloc_value()
+	{		
+		mValues.construct(index_of_alloced_key());
+		return mValues[index_of_alloced_key()];
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// After calling alloc_key*, you may call this to alloc_raw the value
+    ////////////////////////////////////////////////////////////////////////////////////
+	TRatlNew *alloc_value_raw()
+	{
+		return mValues.alloc_raw(index_of_alloced_key());
+	}
+
+	template<class CAST_TO>
+	CAST_TO *verify_alloc(CAST_TO *p) const
+	{
+		return mValues.verify_alloc(p);
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Removes The First Element With Key (key)  - O(log n)
+    ////////////////////////////////////////////////////////////////////////////////////
+	void		erase(const TKTValue &key)
+	{
+		//fixme this is a double search currently
+		int i=find_index(key);
+		if (i!=tree_node::NULL_NODE)
+		{
+			erase_index(i);
+			mValues.destruct(i);
+		}
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Iterator
+	//
+	// A map is sorted in ascending order on the KEY type.  ++ and -- are both
+	// O((log n)^2) operations
+	//
+    ////////////////////////////////////////////////////////////////////////////////////
+	class const_iterator;
+	class iterator
+	{
+		friend class map_base<K,V, IS_MULTI>;
+		friend class const_iterator;
+
+		int							mLoc;
+		map_base<K,V, IS_MULTI>*	mOwner;
+
+	public:
+		iterator(map_base<K,V, IS_MULTI> *owner=0, int loc=tree_node::NULL_NODE) : 
+			mOwner(owner), 
+			mLoc(loc)	
+		{
+		}
+		iterator(const iterator &o) : 
+			mOwner(o.mOwner), 
+			mLoc(o.mLoc)	
+		{
+		}
+
+		void operator=(const iterator &o)
+		{
+			mOwner=o.mOwner;
+			mLoc=o.mLoc;
+		}
+
+		iterator	operator++()		//prefix
+		{	
+			assert(mOwner);	
+			mLoc=mOwner->next(mLoc);
+			return *this;
+		}
+		iterator	operator++(int)		//postfix
+		{
+			assert(mOwner);	
+			iterator old(*this);
+			mLoc=mOwner->next(mLoc);
+			return old;
+		}
+
+		iterator	operator--()		//prefix
+		{	
+			assert(mOwner);	
+			mLoc=mOwner->previous(mLoc);
+			return *this;
+		}
+		iterator	operator--(int)		//postfix
+		{
+			assert(mOwner);	
+			iterator old(*this);
+			mLoc=mOwner->previous(mLoc);
+			return old;
+		}
+
+		bool	operator!=(const iterator &p) const	{return (mLoc!=p.mLoc || mOwner!=p.mOwner);}
+		bool	operator==(const iterator &p) const 	{return (mLoc==p.mLoc && mOwner==p.mOwner);}
+
+		TVTValue &	operator*() const				
+		{
+			assert(mOwner);	
+			assert(mLoc>=0&&mLoc<CAPACITY); // deferencing end()?
+			return mOwner->mValues[mLoc];
+		}
+		const TKTValue &	key() const				
+		{
+			assert(mOwner);	
+			assert(mLoc>=0&&mLoc<CAPACITY); // deferencing end()?
+			return mOwner->index_to_key(mLoc);
+		}		
+		TVTValue &	value() const				
+		{
+			assert(mOwner);	
+			assert(mLoc>=0&&mLoc<CAPACITY); // deferencing end()?
+			return mOwner->mValues[mLoc];
+		}
+		TVTValue *	operator->() const				
+		{
+			assert(mOwner);	
+			assert(mLoc>=0&&mLoc<CAPACITY); // deferencing end()?
+			return &mOwner->mValues[mLoc];
+		}
+	};
+	class const_iterator
+	{
+		friend class map_base<K,V,IS_MULTI>;
+
+		int									mLoc;
+		const map_base<K,V,IS_MULTI>*		mOwner;
+
+	public:
+		const_iterator(const map_base<K,V,IS_MULTI> *owner=0, int loc=tree_node::NULL_NODE) : 
+			mOwner(owner), 
+			mLoc(loc)	
+		{
+		}
+		const_iterator(const const_iterator &o) : 
+			mOwner(o.mOwner), 
+			mLoc(o.mLoc)	
+		{
+		}
+		const_iterator(const iterator &o) : 
+			mOwner(o.mOwner), 
+			mLoc(o.mLoc)	
+		{
+		}
+		void operator=(const const_iterator &o)
+		{
+			mOwner=o.mOwner;
+			mLoc=o.mLoc;
+		}
+		void operator=(const iterator &o)
+		{
+			mOwner=o.mOwner;
+			mLoc=o.mLoc;
+		}
+
+
+		const_iterator	operator++()		//prefix
+		{	
+			assert(mOwner);	
+			mLoc=mOwner->next(mLoc);
+			return *this;
+		}
+		const_iterator	operator++(int)		//postfix
+		{
+			assert(mOwner);	
+			const_iterator old(*this);
+			mLoc=mOwner->next(mLoc);
+			return old;
+		}
+
+		const_iterator	operator--()		//prefix
+		{	
+			assert(mOwner);	
+			mLoc=mOwner->previous(mLoc);
+			return *this;
+		}
+		const_iterator	operator--(int)		//postfix
+		{
+			assert(mOwner);	
+			const_iterator old(*this);
+			mLoc=mOwner->previous(mLoc);
+			return old;
+		}
+
+		bool	operator!=(const const_iterator &p) const	{return (mLoc!=p.mLoc || mOwner!=p.mOwner);}
+		bool	operator==(const const_iterator &p) const 	{return (mLoc==p.mLoc && mOwner==p.mOwner);}
+		bool	operator!=(const iterator &p) const	{return (mLoc!=p.mLoc || mOwner!=p.mOwner);}
+		bool	operator==(const iterator &p) const 	{return (mLoc==p.mLoc && mOwner==p.mOwner);}
+
+		const TVTValue &	operator*() const				
+		{
+			assert(mOwner);	
+			assert(mLoc>=0&&mLoc<CAPACITY); // deferencing end()?
+			return mOwner->mValues[mLoc];
+		}
+		const TKTValue &	key() const				
+		{
+			assert(mOwner);	
+			assert(mLoc>=0&&mLoc<CAPACITY); // deferencing end()?
+			return mOwner->index_to_key(mLoc);
+		}		
+		const TVTValue &	value() const				
+		{
+			assert(mOwner);	
+			assert(mLoc>=0&&mLoc<CAPACITY); // deferencing end()?
+			return mOwner->mValues[mLoc];
+		}
+		const TVTValue *	operator->() const				
+		{
+			assert(mOwner);	
+			assert(mLoc>=0&&mLoc<CAPACITY); // deferencing end()?
+			return &mOwner->mValues[mLoc];
+		}
+	};
+	friend class iterator;
+	friend class const_iterator;
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Seach For A Given Key.  Will Return end() if Failed  - O(log n)
+    ////////////////////////////////////////////////////////////////////////////////////
+	iterator	find(const TKTValue &key)
+	{
+		return iterator(this,find_index(key));		
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Get An Iterator To The Smallest Element  - O(log n)
+    ////////////////////////////////////////////////////////////////////////////////////
+	iterator	begin()
+	{
+		return iterator(this, front());	
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Get An Iterator To The Largest Element  - O(log n)
+    ////////////////////////////////////////////////////////////////////////////////////
+	iterator	rbegin()
+	{
+		return iterator(this, back());
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// The Invalid Iterator, Use As A Stop Condition In Your For Loops  - O(1)
+    ////////////////////////////////////////////////////////////////////////////////////
+	iterator	end()
+	{
+		return iterator(this);
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Seach For A Given Key.  Will Return end() if Failed  - O(log n)
+    ////////////////////////////////////////////////////////////////////////////////////
+	const_iterator	find(const TKTValue &key) const
+	{
+		return const_iterator(this, find_index(key));		
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Get An const_iterator To The Smallest Element  - O(log n)
+    ////////////////////////////////////////////////////////////////////////////////////
+	const_iterator	begin() const
+	{
+		return const_iterator(this, front());	
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Get An const_iterator To The Largest Element  - O(log n)
+    ////////////////////////////////////////////////////////////////////////////////////
+	const_iterator	rbegin() const
+	{
+		return const_iterator(this, back());
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// The Invalid const_iterator, Use As A Stop Condition In Your For Loops  - O(1)
+    ////////////////////////////////////////////////////////////////////////////////////
+	const_iterator	end() const
+	{
+		return const_iterator(this);
+	}
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Removes The Element Pointed To At (it) And Decrements (it)  - O((log n)^2)
+    ////////////////////////////////////////////////////////////////////////////////////
+	void		erase(const iterator &it)
+	{
+		assert(it.mOwner==this && it.mLoc>=0&&it.mLoc<CAPACITY);
+		erase_index(it.mLoc);
+		mValues.destruct(it.mLoc);
+	}
+private:
+	bool check_validity()
+	{
+#if (0)
+		int cnt=0;
+		iterator it=begin();
+		for (;it!=end();it++)
+		{
+			cnt++;
+		}
+//		assert(cnt==size());
+		return cnt==size();
+#else
+		return true;
+#endif
+	}
+};
+
+template<class K,class V, int ARG_CAPACITY>
+class map_vs : public map_base<
+	storage::value_semantics_node<K,ARG_CAPACITY,tree_node>,
+	storage::value_semantics<V,ARG_CAPACITY>,
+	0 >
+{
+public:
+	typedef typename storage::value_semantics<V,ARG_CAPACITY> VStorageTraits;
+	typedef typename VStorageTraits::TValue TTValue;
+ 	enum 
+	{
+		CAPACITY		= ARG_CAPACITY
+	};
+	map_vs() {}
+};
+
+template<class K,class V, int ARG_CAPACITY>
+class map_os : public map_base<
+	storage::value_semantics_node<K,ARG_CAPACITY,tree_node>,
+	storage::object_semantics<V,ARG_CAPACITY>,
+	0 >
+{
+public:
+	typedef typename storage::object_semantics<V,ARG_CAPACITY> VStorageTraits;
+	typedef typename VStorageTraits::TValue TTValue;
+ 	enum 
+	{
+		CAPACITY		= ARG_CAPACITY
+	};
+	map_os() {}
+};
+
+template<class K,class V, int ARG_CAPACITY,int ARG_MAX_CLASS_SIZE>
+class map_is : public map_base<
+	storage::value_semantics_node<K,ARG_CAPACITY,tree_node>,
+	storage::virtual_semantics<V,ARG_CAPACITY,ARG_MAX_CLASS_SIZE>,
+	0 >
+{
+public:
+	typedef typename storage::virtual_semantics<V,ARG_CAPACITY,ARG_MAX_CLASS_SIZE> VStorageTraits;
+	typedef typename VStorageTraits::TValue TTValue;
+ 	enum 
+	{
+		CAPACITY		= ARG_CAPACITY,
+		MAX_CLASS_SIZE	= ARG_MAX_CLASS_SIZE
+	};
+	map_is() {}
+};
+
+}
+
+#endif
diff --git a/code/Ratl/pool_vs.h b/code/Ratl/pool_vs.h
new file mode 100644
index 0000000..4471d49
--- /dev/null
+++ b/code/Ratl/pool_vs.h
@@ -0,0 +1,570 @@
+////////////////////////////////////////////////////////////////////////////////////////
+// RAVEN STANDARD TEMPLATE LIBRARY
+//  (c) 2002 Activision
+//
+//
+// Memory Pool
+// -----------
+// The memory pool class is a simple routine for constant time allocation and deallocation
+// from a fixed size pool of objects.  The class uses a simple array to hold the actual
+// data, a queue for the free list, and a bit field to mark which spots in the array
+// are allocated.
+//
+//
+//
+// NOTES:
+// 
+//
+//
+////////////////////////////////////////////////////////////////////////////////////////
+#if !defined(RATL_POOL_VS_INC)
+#define RATL_POOL_VS_INC
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Includes
+////////////////////////////////////////////////////////////////////////////////////////
+#if !defined(RATL_COMMON_INC)
+	#include "ratl_common.h"
+#endif
+#if !defined(RATL_QUEUE_VS_INC)
+	#include "queue_vs.h"
+#endif
+
+namespace ratl
+{
+
+// fixme, this could be made more efficient by keepingtrack of the highest slot ever used
+// then there is no need to fill the free list
+template <class T>
+class pool_root : public ratl_base
+{
+public:
+	typedef typename T TStorageTraits;
+	typedef typename T::TValue TTValue;
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Capacity Enum
+    ////////////////////////////////////////////////////////////////////////////////////
+ 	enum 
+	{
+		CAPACITY		= T::CAPACITY
+	};
+private:
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Data
+    ////////////////////////////////////////////////////////////////////////////////////
+	array_base<TStorageTraits>	mData;
+	queue_vs<int, CAPACITY>		mFree;
+	bits_base<CAPACITY>			mUsed;
+	int							mSize;
+
+
+	void FillFreeList()
+	{
+		mFree.clear();
+		int i;
+		for (i=0;i<CAPACITY;i++)
+		{
+			mFree.push(i);
+		}
+	}
+	int			alloc_low()
+	{
+		assert(mSize<CAPACITY);
+		assert(!mUsed[mFree.top()]);
+
+		int NextIndex = mFree.top();				// Get The First Available Location
+
+		mUsed.set_bit(NextIndex);
+		mFree.pop();
+		mSize ++;
+		return	NextIndex;
+	}
+public:
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Constructor
+    ////////////////////////////////////////////////////////////////////////////////////
+	pool_root() : mSize(0)
+	{
+		FillFreeList();
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// The Number Of Objects Allocated
+    ////////////////////////////////////////////////////////////////////////////////////
+	int			size()	 const													
+	{
+		return (mSize);
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Check To See If This Memory Pool Is Empty
+    ////////////////////////////////////////////////////////////////////////////////////
+	bool		empty()	 const													
+	{
+		return (mSize==0);
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Check To See If This Memory Pool Is Full
+    ////////////////////////////////////////////////////////////////////////////////////
+	bool		full()	 const													
+	{
+		return (mSize==CAPACITY);
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Constant Accessor
+    ////////////////////////////////////////////////////////////////////////////////////
+	const TTValue&	value_at_index(int i) const 									
+	{
+		assert(mUsed[i]);
+		return (mData[i]);
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Accessor
+    ////////////////////////////////////////////////////////////////////////////////////
+	TTValue&			value_at_index(int i)											
+	{
+		assert(mUsed[i]);
+		return (mData[i]);
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Clear - Removes all allocation information
+    ////////////////////////////////////////////////////////////////////////////////////
+	void		clear()
+	{
+		mSize = 0;
+		mUsed.clear();
+		mData.clear();
+		FillFreeList();
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Check If An Index Has Been Allocated
+    ////////////////////////////////////////////////////////////////////////////////////
+	bool		is_used_index(int i) const
+	{
+		return mUsed[i];
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Convert a pointer back to an index
+    ////////////////////////////////////////////////////////////////////////////////////
+	int pointer_to_index(const TTValue *me) const
+	{
+		assert(mSize>0);
+
+		int index=mData.pointer_to_index(me);
+
+		assert(index>=0 && index<CAPACITY);
+		assert(mUsed[index]);	// I am disallowing obtaining the index of a freed item
+
+		return index;
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Convert a pointer back to an index
+    ////////////////////////////////////////////////////////////////////////////////////
+	int pointer_to_index(const TRatlNew *me) const
+	{
+		assert(mSize>0);
+
+		int index=mData.pointer_to_index(me);
+
+		assert(index>=0 && index<CAPACITY);
+		assert(mUsed[index]);	// I am disallowing obtaining the index of a freed item
+
+		return index;
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Swap two items based on index
+    ////////////////////////////////////////////////////////////////////////////////////
+	void swap_index(int i,int j)
+	{
+		assert(i>=0 && i<CAPACITY);
+		assert(j>=0 && j<CAPACITY);
+		mData.swap(i,j);
+	}
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// The Allocator
+    ////////////////////////////////////////////////////////////////////////////////////
+	int			alloc_index()
+	{
+		int NextIndex = alloc_low();
+		mData.construct(NextIndex);
+		return	NextIndex;
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// The Allocator
+    ////////////////////////////////////////////////////////////////////////////////////
+	int			alloc_index(const TTValue &v)
+	{
+		int NextIndex = alloc_low();
+		mData.construct(NextIndex,v);
+		return	NextIndex;
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// The Allocator
+    ////////////////////////////////////////////////////////////////////////////////////
+	TRatlNew *		alloc_raw()
+	{
+		int NextIndex = alloc_low();
+		return mData.alloc_raw(NextIndex);
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// The Deallocator
+    ////////////////////////////////////////////////////////////////////////////////////
+	void		free_index(int i)
+	{
+		assert(mSize>0);
+		assert(i>=0 && i<CAPACITY);
+		assert(mUsed[i]);
+
+		mData.destruct(i);
+
+		mUsed.clear_bit(i);
+		mFree.push(i);
+		mSize --;
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// The Deallocator
+    ////////////////////////////////////////////////////////////////////////////////////
+	void		free(TTValue *me)
+	{
+		free(pointer_to_index(me));
+	}
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Iterator
+    ////////////////////////////////////////////////////////////////////////////////////
+	class const_iterator;
+	class iterator
+	{
+		friend class pool_root<T>;
+		friend class const_iterator;
+		int				mIndex;
+		pool_root<T>*	mOwner;
+	public:
+		// Constructors
+		//--------------
+		iterator()									: mOwner(0)
+		{}
+		iterator(pool_root<T>* p, int index)	: mOwner(p), mIndex(index)
+		{}
+		iterator(const iterator &t)	: mOwner(t.mOwner), mIndex(t.mIndex)
+		{}
+
+		// Assignment Operator
+		//---------------------
+		void		operator= (const iterator &t)
+		{
+			mOwner	= t.mOwner;	
+			mIndex	= t.mIndex;
+		}
+
+		// Equality Operators
+		//--------------------
+		bool	operator!=(const iterator& t)	{assert(mOwner && mOwner==t.mOwner);		return (mIndex!=t.mIndex);}
+		bool	operator==(const iterator& t)	{assert(mOwner && mOwner==t.mOwner);		return (mIndex==t.mIndex);}
+
+		// Dereference Operators
+		//----------------------
+		TTValue&		operator* () const				{assert(mOwner && mOwner->is_used_index(mIndex));	return (mOwner->mData[mIndex]);}
+		TTValue*		operator->() const				{assert(mOwner && mOwner->is_used_index(mIndex));	return (&mOwner->mData[mIndex]);}
+
+		// Handle & Index Access
+		//-----------------------
+		int		index()							{assert(mOwner && mOwner->is_used_index(mIndex));	return mIndex;}
+		
+		// Inc Operator
+		//-------------
+		iterator operator++(int)	 // postfix
+		{
+			assert(mIndex>=0&&mIndex<CAPACITY);						// this typically means you did end()++
+			assert(mOwner && mOwner->is_used_index(mIndex));
+
+			iterator ret(*this);
+			mIndex = mOwner->mUsed.next_bit(mIndex+1);
+			return ret;
+		}
+		// Inc Operator
+		//-------------
+		iterator operator++()	 // prefix
+		{
+			assert(mIndex>=0&&mIndex<CAPACITY);						// this typically means you did end()++
+			assert(mOwner && mOwner->is_used_index(mIndex));
+			mIndex = mOwner->mUsed.next_bit(mIndex+1);
+			return *this;
+		}
+	};
+	friend class iterator;
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Iterator
+    ////////////////////////////////////////////////////////////////////////////////////
+	class const_iterator 
+	{
+		int					mIndex;
+		const pool_root<T>*	mOwner;
+	public:
+		// Constructors
+		//--------------
+		const_iterator()									: mOwner(0)
+		{}
+		const_iterator(const pool_root<T>* p, int index)		: mOwner(p), mIndex(index)
+		{}
+		const_iterator(const iterator &t)							: mOwner(t.mOwner), mIndex(t.mIndex)
+		{}
+		const_iterator(const const_iterator &t)					: mOwner(t.mOwner), mIndex(t.mIndex)
+		{}
+
+		// Equality Operators
+		//--------------------
+		bool	operator!=(const const_iterator& t) const		{assert(mOwner && mOwner==t.mOwner);		return (mIndex!=t.mIndex);}
+		bool	operator==(const const_iterator& t) const		{assert(mOwner && mOwner==t.mOwner);		return (mIndex==t.mIndex);}
+		bool	operator!=(const iterator& t) const				{assert(mOwner && mOwner==t.mOwner);		return (mIndex!=t.mIndex);}
+		bool	operator==(const iterator& t) const				{assert(mOwner && mOwner==t.mOwner);		return (mIndex==t.mIndex);}
+
+		// Dereference Operators
+		//----------------------
+		const TTValue&		operator* () const				{assert(mOwner && mOwner->is_used_index(mIndex));	return (mOwner->mData[mIndex]);}
+		const TTValue*		operator->() const				{assert(mOwner && mOwner->is_used_index(mIndex));	return (&mOwner->mData[mIndex]);}
+
+		// Handle & Index Access
+		//-----------------------
+		int		index() const					{assert(mOwner && mOwner->is_used_index(mIndex));	return mIndex;}
+		
+		// Inc Operator
+		//-------------
+		const_iterator operator++(int)	 // postfix
+		{
+			assert(mIndex>=0&&mIndex<CAPACITY);						// this typically means you did end()++
+			assert(mOwner && mOwner->is_used_index(mIndex));
+
+			const_iterator ret(*this);
+			mIndex = mOwner->mUsed.next_bit(mIndex+1);
+			return ret;
+		}
+		// Inc Operator
+		//-------------
+		const_iterator operator++()	 // prefix
+		{
+			assert(mIndex>=0&&mIndex<CAPACITY);						// this typically means you did end()++
+			assert(mOwner && mOwner->is_used_index(mIndex));
+			mIndex = mOwner->mUsed.next_bit(mIndex+1);
+			return *this;
+		}
+	};
+	friend class const_iterator;
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Get An Iterator To The First Allocated Memory Block
+    ////////////////////////////////////////////////////////////////////////////////////
+	iterator	begin()
+	{
+		int idx=mUsed.next_bit(0);
+		return iterator(this,idx);			// Find The First Allocated
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Get An Iterator To The Object At index
+    ////////////////////////////////////////////////////////////////////////////////////
+	iterator	at_index(int index)
+	{
+		assert(mUsed[index]);  // disallow iterators to non alloced things
+		return iterator(this, index);
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Get An Iterator To The End Of The Memroy (One Step Beyond)
+    ////////////////////////////////////////////////////////////////////////////////////
+	iterator	end()
+	{
+		return iterator(this, CAPACITY);
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Get An Iterator To The First Allocated Memory Block
+    ////////////////////////////////////////////////////////////////////////////////////
+	const_iterator	begin() const
+	{
+		int idx=mUsed.next_bit(0);
+		return iterator(this,idx);			// Find The First Allocated
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Get An Iterator To The Object At index
+    ////////////////////////////////////////////////////////////////////////////////////
+	const_iterator	at_index(int index) const
+	{
+		assert(mUsed[index]);  // disallow iterators to non alloced things
+		return iterator(this, index);
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Get An Iterator To The End Of The Memroy (One Step Beyond)
+    ////////////////////////////////////////////////////////////////////////////////////
+	const_iterator	end() const
+	{
+		return iterator(this, CAPACITY);
+	}
+
+	template<class CAST_TO>
+	CAST_TO *verify_alloc(CAST_TO *p) const
+	{
+		return mData.verify_alloc(p);
+	}
+};
+
+/*
+pool_base, base class for the pools
+
+operations:
+
+size()
+empty()
+full()
+clear()							op[]
+at_index()						op[]
+at_index() const
+index pointer_to_index(ptr)
+index alloc_index()				alloc()
+index alloc_index(ref)			alloc()
+ptr alloc_raw()
+free_index(index)
+free(ptr)
+is_used_index(index)
+
+*/
+
+template <class T>
+class pool_base : public pool_root<T>
+{
+public:
+	typedef typename T::TValue TTValue;
+	
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Constant Accessor
+    ////////////////////////////////////////////////////////////////////////////////////
+	const TTValue&	operator[](int i) const 									
+	{
+		return value_at_index(i);
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Accessor
+    ////////////////////////////////////////////////////////////////////////////////////
+	TTValue&			operator[](int i)											
+	{
+		return value_at_index(i);
+	}
+
+	bool				is_used(int i) const
+	{
+		return is_used_index(i);
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Swap two items based on index
+    ////////////////////////////////////////////////////////////////////////////////////
+	void swap(int i,int j)
+	{
+		swap_index(i,j);
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// The Allocator	returns an index
+    ////////////////////////////////////////////////////////////////////////////////////
+	int			alloc()
+	{
+		return	alloc_index();
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// The Allocator	returns an index
+    ////////////////////////////////////////////////////////////////////////////////////
+	int			alloc(const TTValue &v)
+	{
+		return	alloc_index(v);
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// The Deallocator
+    ////////////////////////////////////////////////////////////////////////////////////
+	void		free(int i)
+	{
+		free_index(i);
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Get An Iterator To The Object At index
+    ////////////////////////////////////////////////////////////////////////////////////
+	pool_root<T>::iterator	at(int index)
+	{
+		return at_index(index);
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Get An Iterator To The Object At index
+    ////////////////////////////////////////////////////////////////////////////////////
+	pool_root<T>::const_iterator	at(int index) const
+	{
+		return at_index(index);
+	}
+};
+
+template<class T, int ARG_CAPACITY>
+class pool_vs : public pool_base<storage::value_semantics<T,ARG_CAPACITY> >
+{
+public:
+	typedef typename storage::value_semantics<T,ARG_CAPACITY> TStorageTraits;
+	typedef typename TStorageTraits::TValue TTValue;
+ 	enum 
+	{
+		CAPACITY		= ARG_CAPACITY
+	};
+	pool_vs() {}
+};
+
+template<class T, int ARG_CAPACITY>
+class pool_os : public pool_base<storage::object_semantics<T,ARG_CAPACITY> >
+{
+public:
+	typedef typename storage::object_semantics<T,ARG_CAPACITY> TStorageTraits;
+	typedef typename TStorageTraits::TValue TTValue;
+ 	enum 
+	{
+		CAPACITY		= ARG_CAPACITY
+	};
+	pool_os() {}
+};
+
+template<class T, int ARG_CAPACITY, int ARG_MAX_CLASS_SIZE>
+class pool_is : public pool_base<storage::virtual_semantics<T,ARG_CAPACITY,ARG_MAX_CLASS_SIZE> >
+{
+public:
+	typedef typename storage::virtual_semantics<T,ARG_CAPACITY,ARG_MAX_CLASS_SIZE> TStorageTraits;
+	typedef typename TStorageTraits::TValue TTValue;
+ 	enum 
+	{
+		CAPACITY		= ARG_CAPACITY,
+		MAX_CLASS_SIZE	= ARG_MAX_CLASS_SIZE
+	};
+	pool_is() {}
+};
+
+}
+#endif
\ No newline at end of file
diff --git a/code/Ratl/queue_vs.h b/code/Ratl/queue_vs.h
new file mode 100644
index 0000000..2588f49
--- /dev/null
+++ b/code/Ratl/queue_vs.h
@@ -0,0 +1,231 @@
+////////////////////////////////////////////////////////////////////////////////////////
+// RAVEN STANDARD TEMPLATE LIBRARY
+//  (c) 2002 Activision
+//
+//
+// Queue Template
+// --------------
+// The queue is a circular buffer of objects which supports a push at the "front" and a
+// pop at the "back".  Therefore it is:
+//
+// First In, First Out
+//
+// As the pointers to the push and pop locations are changed it wrapps around the end
+// of the array and back to the front.  There are asserts to make sure it never goes
+// beyond the capacity of the object.
+//
+//
+//
+// NOTES:
+// 
+//
+//
+////////////////////////////////////////////////////////////////////////////////////////
+#if !defined(RATL_QUEUE_VS_INC)
+#define RATL_QUEUE_VS_INC
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Includes
+////////////////////////////////////////////////////////////////////////////////////////
+#if !defined(RATL_COMMON_INC)
+	#include "ratl_common.h"
+#endif
+namespace ratl
+{
+
+////////////////////////////////////////////////////////////////////////////////////////
+// The Queue Class
+////////////////////////////////////////////////////////////////////////////////////////
+template <class T>
+class queue_base : public ratl_base
+{
+public:
+	typedef typename T TStorageTraits;
+	typedef typename T::TValue TTValue;
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Capacity Enum
+    ////////////////////////////////////////////////////////////////////////////////////
+ 	enum 
+	{
+		CAPACITY		= T::CAPACITY
+	};
+private:
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Data
+	////////////////////////////////////////////////////////////////////////////////////
+	array_base<TStorageTraits>	mData;			// The Memory
+	int							mPush;			// Address Of Next Add Location
+	int							mPop;			// Address Of Next Remove Location
+	int							mSize;
+
+
+	int push_low()
+	{
+		assert(size()<CAPACITY);
+
+		// Add It
+		//--------
+		mPush++;
+		mSize++;
+
+		// Update Push Location
+		//----------------------
+		if (mPush>=CAPACITY)
+		{
+			mPush=0;
+			return CAPACITY-1;
+		}
+		return mPush-1;
+	}
+
+
+public:
+	typedef T TStorageTraits;
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Constructor
+    ////////////////////////////////////////////////////////////////////////////////////
+	queue_base() : mPush(0), mPop(0), mSize(0)
+	{
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Get The Size (The Difference Between The Push And Pop "Pointers")
+    ////////////////////////////////////////////////////////////////////////////////////
+	int				size() const
+	{
+		return mSize;
+	}
+	
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Check To See If The Size Is Zero
+    ////////////////////////////////////////////////////////////////////////////////////
+	bool			empty() const
+	{
+		return !mSize;
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Check To See If The Size Is Full
+    ////////////////////////////////////////////////////////////////////////////////////
+	bool			full() const
+	{
+		return mSize>=CAPACITY;
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Empty Out The Entire Queue
+	////////////////////////////////////////////////////////////////////////////////////
+	void			clear()
+	{
+		mPush = 0;
+		mPop = 0;
+		mSize = 0;
+		mData.clear();
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Add A Value, returns a reference to the value in place
+    ////////////////////////////////////////////////////////////////////////////////////
+	TTValue &		push()
+	{
+		int idx=push_low();
+		mData.construct(idx);	
+		return mData[idx];
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Add A Value to the Queue
+    ////////////////////////////////////////////////////////////////////////////////////
+	void push(const TTValue& v)
+	{
+		mData.construct(push_low(),v);	
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Add A Value to the Queue, returning a void * to the memory
+    ////////////////////////////////////////////////////////////////////////////////////
+	TRatlNew *push_raw()
+	{
+		return mData.alloc_raw(push_low());	
+	}
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Remove A Value From The Queue
+    ////////////////////////////////////////////////////////////////////////////////////
+	void			pop()
+	{
+		assert(size()>0);
+
+		mData.destruct(mPop);
+		// Update Pop Location
+		//---------------------
+		mPop++;
+		if (mPop>=CAPACITY)
+		{
+			mPop=0;
+		}
+
+		mSize--;
+	}
+
+	TTValue & top()
+	{
+		assert(size()>0);
+		return mData[mPop];
+	}
+
+	const TTValue & top() const
+	{
+		assert(size()>0);
+		return mData[mPop];
+	}
+	template<class CAST_TO>
+	CAST_TO *verify_alloc(CAST_TO *p) const
+	{
+		return mData.verify_alloc(p);
+	}
+};
+
+template<class T, int ARG_CAPACITY>
+class queue_vs : public queue_base<storage::value_semantics<T,ARG_CAPACITY> >
+{
+public:
+	typedef typename storage::value_semantics<T,ARG_CAPACITY> TStorageTraits;
+	typedef typename TStorageTraits::TValue TTValue;
+ 	enum 
+	{
+		CAPACITY		= ARG_CAPACITY
+	};
+	queue_vs() {}
+};
+
+template<class T, int ARG_CAPACITY>
+class queue_os : public queue_base<storage::object_semantics<T,ARG_CAPACITY> >
+{
+public:
+	typedef typename storage::object_semantics<T,ARG_CAPACITY> TStorageTraits;
+	typedef typename TStorageTraits::TValue TTValue;
+ 	enum 
+	{
+		CAPACITY		= ARG_CAPACITY
+	};
+	queue_os() {}
+};
+
+template<class T, int ARG_CAPACITY, int ARG_MAX_CLASS_SIZE>
+class queue_is : public queue_base<storage::virtual_semantics<T,ARG_CAPACITY,ARG_MAX_CLASS_SIZE> >
+{
+public:
+	typedef typename storage::virtual_semantics<T,ARG_CAPACITY,ARG_MAX_CLASS_SIZE> TStorageTraits;
+	typedef typename TStorageTraits::TValue TTValue;
+ 	enum 
+	{
+		CAPACITY		= ARG_CAPACITY,
+		MAX_CLASS_SIZE	= ARG_MAX_CLASS_SIZE
+	};
+	queue_is() {}
+};
+
+}
+#endif
\ No newline at end of file
diff --git a/code/Ratl/ratl.cpp b/code/Ratl/ratl.cpp
new file mode 100644
index 0000000..ec7fd0e
--- /dev/null
+++ b/code/Ratl/ratl.cpp
@@ -0,0 +1,130 @@
+#if !defined(RATL_COMMON_INC)
+	#include "ratl_common.h"
+#endif
+
+#if 0
+#include "array_vs.h"
+#include "bits_vs.h"
+#include "heap_vs.h"
+#include "pool_vs.h"
+#include "list_vs.h"
+#include "queue_vs.h"
+#include "stack_vs.h"
+#include "string_vs.h"
+#include "vector_vs.h"
+#include "handle_pool_vs.h"
+#include "hash_pool_vs.h"
+#include "map_vs.h"
+#include "scheduler_vs.h"
+#endif
+
+#if !defined(CTYPE_H_INC)
+	#include <ctype.h>
+	#define CTYPE_H_INC
+#endif
+
+#if !defined(STDARG_H_INC)
+	#include <stdarg.h>
+	#define STDARG_H_INC
+#endif
+
+#if !defined(STDIO_H_INC)
+	#include <stdio.h>
+	#define STDIO_H_INC
+#endif
+
+
+#if !defined(RUFL_HFILE_INC)
+	#include "..\Rufl\hfile.h"
+#endif
+
+
+void*	ratl::ratl_base::OutputPrint = 0;
+
+
+
+namespace ratl
+{
+
+#ifdef _DEBUG
+	int HandleSaltValue=1027; //this is used in debug for global uniqueness of handles
+	int FoolTheOptimizer=5;		//this is used to make sure certain things aren't optimized out
+#endif
+
+
+#ifndef _XBOX
+void	ratl_base::save(hfile& file)
+{
+}
+
+void	ratl_base::load(hfile& file)
+{
+}
+#endif
+
+////////////////////////////////////////////////////////////////////////////////////////
+// A Profile Print Function 
+////////////////////////////////////////////////////////////////////////////////////////
+#if !defined(FINAL_BUILD)
+void	ratl_base::ProfilePrint(const char * format, ...)
+{
+	static char		string[2][1024];	// in case this is called by nested functions
+	static int		index = 0;
+	static char		nFormat[300];
+	char*			buf;
+
+	// Tack On The Standard Format Around The Given Format
+	//-----------------------------------------------------
+	sprintf(nFormat, "[PROFILE] %s\n", format);
+
+
+	// Resolve Remaining Elipsis Parameters Into Newly Formated String
+	//-----------------------------------------------------------------
+	buf = string[index & 1];
+	index++;
+
+	va_list		argptr;
+	va_start (argptr, format);
+	vsprintf (buf, nFormat, argptr);
+	va_end (argptr);
+
+	// Print It To Debug Output Console
+	//----------------------------------
+	if (OutputPrint!=0)
+	{
+		void (*OutputPrintFcn)(const char* text) = (void (__cdecl*)(const char*))OutputPrint;
+		OutputPrintFcn(buf);
+	}
+}
+#else
+void	ratl_base::ProfilePrint(const char * format, ...)
+{
+}
+#endif
+
+namespace str
+{
+	void	to_upper(char *dest)
+	{
+		for (int i=0; i<len(dest);i++)
+		{
+			dest[i] = (char)(toupper(dest[i]));
+		}
+	}
+	void	to_lower(char *dest)
+	{
+		for (int i=0; i<len(dest);i++)
+		{
+			dest[i] = (char)(tolower(dest[i]));
+		}
+	}
+	void	printf(char *dest,const char *formatS, ...)
+	{
+		va_list		argptr;
+		va_start (argptr, formatS);
+		vsprintf (dest, formatS,argptr);
+		va_end (argptr);
+	}
+}
+}
+
diff --git a/code/Ratl/ratl_common.h b/code/Ratl/ratl_common.h
new file mode 100644
index 0000000..f4f59b0
--- /dev/null
+++ b/code/Ratl/ratl_common.h
@@ -0,0 +1,1180 @@
+////////////////////////////////////////////////////////////////////////////////////////
+// RAVEN STANDARD TEMPLATE LIBRARY
+//  (c) 2002 Activision
+//
+//
+// Common
+// ------
+// The raven libraries contain a number of common defines, enums, and typedefs which
+// need to be accessed by all templates.  Each of these is included here.
+//
+// Also included is a safeguarded assert file for all the asserts in RTL.
+//
+// This file is included in EVERY TEMPLATE, so it should be very light in order to 
+// reduce compile times.
+//
+//
+// Format
+// ------
+// In order to simplify code and provide readability, the template library has some
+// standard formats.  Any new templates or functions should adhere to these formats:
+//
+// - All memory is statically allocated, usually by parameter SIZE
+// - All classes provide an enum which defines constant variables, including CAPACITY
+// - All classes which moniter the number of items allocated provide the following functions:
+//     size()   - the number of objects
+//     empty()  - does the container have zero objects
+//     full()   - does the container have any room left for more objects
+//     clear()  - remove all objects
+//
+//
+// - Functions are defined in the following order:
+//     Capacity
+//     Constructors  (copy, from string, etc...)
+//     Range		 (size(), empty(), full(), clear(), etc...)
+//     Access        (operator[], front(), back(), etc...)
+//     Modification  (add(), remove(), push(), pop(), etc...)
+//     Iteration     (begin(), end(), insert(), erase(), find(), etc...)
+//
+//
+// NOTES:
+//
+//
+//
+////////////////////////////////////////////////////////////////////////////////////////
+#if !defined(RATL_COMMON_INC)
+#define RATL_COMMON_INC
+
+////////////////////////////////////////////////////////////////////////////////////////
+// In VC++, Don't Bother With These Warnings
+////////////////////////////////////////////////////////////////////////////////////////
+#if defined(_MSC_VER) && !defined(__MWERKS__)
+	#pragma warning ( disable : 4786 )			// Truncated to 255 characters warning
+	#pragma warning ( disable : 4284 )			// nevamind what this is
+	#pragma warning ( disable : 4100 )			// unreferenced formal parameter
+	#pragma warning ( disable : 4512 )			// unable to generate default operator=
+	#pragma warning ( disable : 4130 )			// logical operation on address of string constant
+	#pragma warning ( disable : 4127 )			// conditional expression is constant
+#endif
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Includes
+////////////////////////////////////////////////////////////////////////////////////////
+#if !defined(ASSERT_H_INC)
+#include <assert.h>
+#define ASSERT_H_INC
+#endif
+
+#if !defined(STRING_H_INC)
+#include <string.h>
+#define STRING_H_INC
+#endif
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Forward Dec.
+////////////////////////////////////////////////////////////////////////////////////////
+class hfile;
+
+
+
+// I don't know why this needs to be in the global namespace, but it does
+class TRatlNew;
+inline void *operator new(size_t,TRatlNew *where)
+{
+	return where;
+}
+
+inline void operator delete(void *, TRatlNew *)
+{
+	return; 
+}
+
+namespace ratl
+{
+
+
+
+#ifdef _DEBUG
+extern int HandleSaltValue; //this is used in debug for global uniqueness of handles
+extern int FoolTheOptimizer; //this is used to make sure certain things aren't optimized out
+#endif
+
+////////////////////////////////////////////////////////////////////////////////////////
+// All Raven Template Library Internal Memory Operations
+//
+// This is mostly for future use.  For now, they only provide a simple interface with
+// a couple extra functions (eql and clr).
+////////////////////////////////////////////////////////////////////////////////////////
+namespace	mem
+{
+////////////////////////////////////////////////////////////////////////////////////////
+// The Align Struct Is The Root Memory Structure for Inheritance and Object Semantics
+//
+// In most cases, we just want a simple int.  However, sometimes we need to use an
+// unsigned character array
+//
+////////////////////////////////////////////////////////////////////////////////////////
+#if defined(_MSC_VER) && !defined(__MWERKS__)
+	struct alignStruct
+	{
+		int space;
+	};
+#else
+	struct alignStruct
+	{
+		unsigned char space[16];
+	} __attribute__ ((aligned(16)));
+#endif 
+
+	inline void*	cpy( void *dest, const void *src, size_t count )
+	{
+		return memcpy(dest, src, count);
+	}
+	inline void*	set( void *dest, int c, size_t count )
+	{
+		return memset(dest, c, count);
+	}
+	inline int		cmp( const void *buf1, const void *buf2, size_t count )
+	{
+		return memcmp( buf1, buf2, count );
+	}
+	inline bool	eql( const void *buf1, const void *buf2, size_t count )
+	{
+		return (memcmp( buf1, buf2, count )==0);
+	}
+	inline void*	zero( void *dest, size_t count )
+	{
+		return memset(dest, 0, count);
+	}
+
+	template<class T>
+	inline 	void	cpy( T *dest, const T *src)
+	{
+		cpy(dest, src, sizeof(T));
+	}
+	template<class T>
+	inline 	void	set(T *dest, int c)
+	{
+		set(dest, c, sizeof(T));
+	}
+
+	template<class T>
+	inline 	void	swap(T *s1, T *s2)
+	{
+		unsigned char temp[sizeof(T)];
+		cpy((T *)temp,s1);
+		cpy(s1,s2);
+		cpy(s2,(T *)temp);
+	}
+
+	template<class T>
+	inline 	int		cmp( const T *buf1, const T *buf2)
+	{
+		return cmp( buf1, buf2, sizeof(T) );
+	}
+
+	template<class T>
+	inline 	bool	eql( const T *buf1, const T *buf2)
+	{
+		return cmp( buf1, buf2,sizeof(T))==0;
+	}
+
+	template<class T>
+	inline 	void	zero( T *dest )
+	{
+		return set(dest, 0, sizeof(T));
+	}
+}
+
+namespace str
+{
+	inline int		len(const char *src)
+	{
+		return strlen(src);
+	}
+
+	inline void	cpy(char *dest,const char *src)
+	{
+		strcpy(dest,src);
+	}
+
+	inline void	ncpy(char *dest,const char *src,int destBufferLen)
+	{
+		strncpy(dest,src,destBufferLen);
+	}
+
+	inline void	cat(char *dest,const char *src)
+	{
+		strcat(dest,src);
+	}
+
+	inline void	ncat(char *dest,const char *src,int destBufferLen)
+	{
+		ncpy(dest+len(dest),src,destBufferLen-len(dest));
+	}
+
+	inline int		cmp(const char *s1,const char *s2)
+	{
+		return strcmp(s1,s2);
+	}
+	inline bool	eql(const char *s1,const char *s2)
+	{
+		return !strcmp(s1,s2);
+	}
+	inline int		icmp(const char *s1,const char *s2)
+	{
+		return stricmp(s1,s2);
+	}
+	inline int		cmpi(const char *s1,const char *s2)
+	{
+		return stricmp(s1,s2);
+	}
+	inline bool	ieql(const char *s1,const char *s2)
+	{
+		return !stricmp(s1,s2);
+	}
+	inline bool	eqli(const char *s1,const char *s2)
+	{
+		return !stricmp(s1,s2);
+	}
+
+	inline char	*tok(char *s,const char *gap)
+	{
+		return strtok(s,gap);
+	}
+
+	void	to_upper(char *dest);
+	void	to_lower(char *dest);
+	void	printf(char *dest,const char *formatS, ...);
+}
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// The Raven Template Library Compile Assert
+//
+// If, during compile time the stuff under (condition) is zero, this code will not
+// compile.
+////////////////////////////////////////////////////////////////////////////////////////
+template<int condition>
+class	compile_assert
+{
+#ifdef _DEBUG
+	int	junk[(1 - (2 * !condition))];		// Look At Where This Was Being Compiled
+public:
+	compile_assert()
+	{
+		assert(condition);
+		junk[0]=FoolTheOptimizer++;
+	}
+	int operator()()
+	{
+		assert(condition);
+		FoolTheOptimizer++;
+		return junk[0];
+	}
+#else
+public:
+	int operator()()
+	{
+		return 1;
+	}
+#endif;
+};
+
+
+
+
+
+	
+////////////////////////////////////////////////////////////////////////////////////////
+// The Raven Template Library Base Class
+//
+// This is the base class for all the Raven Template Library container classes like
+// vector_vs and pool_vs.  
+//
+// This class might be a good place to put memory profile code in the future.
+//
+////////////////////////////////////////////////////////////////////////////////////////
+class	ratl_base
+{
+public:
+#ifndef _XBOX
+	void	save(hfile& file);
+	void	load(hfile& file);
+#endif
+
+	void	ProfilePrint(const char * format, ...);
+
+public:
+	static	void*	OutputPrint;
+};
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// this is a simplified version of bits_vs
+////////////////////////////////////////////////////////////////////////////////////////
+template <int	SZ>
+class bits_base
+{
+protected:
+	enum
+	{
+		BITS_SHIFT		= 5,									// 5.  Such A Nice Number
+		BITS_INT_SIZE	= 32,									// Size Of A Single Word
+		BITS_AND		= (BITS_INT_SIZE - 1),					// Used For And Operation
+		ARRAY_SIZE		= ((SZ + BITS_AND)/(BITS_INT_SIZE)),	// Num Words Used
+		BYTE_SIZE		= (ARRAY_SIZE*sizeof(unsigned int)),	// Num Bytes Used
+	};
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Data
+	////////////////////////////////////////////////////////////////////////////////////
+	unsigned int						mV[ARRAY_SIZE];
+public:
+	enum	
+	{
+		SIZE			= SZ,
+		CAPACITY		= SZ,
+	};
+
+	bits_base(bool init=true,bool initValue=false)
+	{
+		if (init)
+		{
+			if (initValue)
+			{
+				set();
+			}
+			else
+			{
+				clear();
+			}
+		}
+	}
+	void clear()
+	{
+		mem::zero(&mV,BYTE_SIZE);
+	}
+	void		set()
+	{
+		mem::set(&mV, 0xff,BYTE_SIZE);
+	}
+
+	void set_bit(const int i)
+	{
+		assert(i>=0 && i < SIZE);
+		mV[i>>BITS_SHIFT] |=  (1<<(i&BITS_AND));
+	}
+	void clear_bit(const int i)
+	{
+		assert(i>=0 && i < SIZE);
+		mV[i>>BITS_SHIFT] &= ~(1<<(i&BITS_AND));
+	}
+	void mark_bit(const int i, bool set)
+	{
+		assert(i>=0 && i < SIZE);
+		if (set)
+		{
+			mV[i>>BITS_SHIFT] |=  (1<<(i&BITS_AND));
+		}
+		else
+		{
+			mV[i>>BITS_SHIFT] &= ~(1<<(i&BITS_AND));
+		}
+	}
+	bool operator[](const int i) const
+	{
+		assert(i>=0 && i < SIZE);
+		return (mV[i>>BITS_SHIFT] & (1<<(i&BITS_AND)))!=0;
+	}
+	int	next_bit(int start=0,bool onBit=true) const
+	{
+		assert(start>=0&&start<=SIZE);  //we have to accept start==size for the way the loops are done
+		if (start>=SIZE)
+		{
+			return SIZE;			// Did Not Find
+		}
+		// Get The Word Which Contains The Start Bit & Mask Out Everything Before The Start Bit
+		//--------------------------------------------------------------------------------------
+		unsigned int	v = mV[start>>BITS_SHIFT];
+		if (!onBit)
+		{
+			v= (~v);
+		}
+		v >>= (start&31);
+
+
+		// Search For The First Non Zero Word In The Array
+		//-------------------------------------------------
+		while(!v)
+		{
+			start = (start & (~(BITS_INT_SIZE-1))) + BITS_INT_SIZE;
+			if (start>=SIZE)
+			{
+				return SIZE;			// Did Not Find
+			}
+			v = mV[start>>BITS_SHIFT];
+			if (!onBit)
+			{
+				v= (~v);
+			}
+		}
+
+
+		// So, We've Found A Non Zero Word, So Start Masking Against Parts To Skip Over Bits
+		//-----------------------------------------------------------------------------------
+		if (!(v&0xffff))
+		{
+			start+=16;
+			v>>=16;
+		}
+		if (!(v&0xff))
+		{
+			start+=8;
+			v>>=8;
+		}
+		if (!(v&0xf))
+		{
+			start+=4;
+			v>>=4;
+		}
+
+		// Time To Search Each Bit
+		//-------------------------
+		while(!(v&1))
+		{
+			start++;
+			v>>=1;
+		}
+		if (start>=SIZE)
+		{
+			return SIZE;
+		}
+		return start;
+	}
+};
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Raven Standard Compare Class
+////////////////////////////////////////////////////////////////////////////////////////
+struct ratl_compare
+{
+	float	mCost;
+	int		mHandle;
+
+	bool	operator<(const ratl_compare& t) const	
+	{
+		return (mCost<t.mCost);
+	}
+};
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// this is used to keep track of the constuction state for things that are always constucted
+////////////////////////////////////////////////////////////////////////////////////////
+class bits_true
+{
+public:
+
+	void clear()
+	{
+	}
+	void set()
+	{
+	}
+	void set_bit(const int i)
+	{
+	}
+	void clear_bit(const int i)
+	{
+	}
+	bool operator[](const int i) const
+	{
+		return true;
+	}
+	int	next_bit(int start=0,bool onBit=true) const
+	{
+		assert(onBit); ///I didn't want to add the sz template arg, you could though
+		return start;
+	}
+};
+
+
+namespace storage
+{
+	template<class T,int SIZE>
+	struct value_semantics
+	{
+		enum	
+		{
+			CAPACITY		= SIZE,
+		};
+		typedef T TAlign;		// this is any type that has the right alignment
+		typedef T TValue;		// this is the actual thing the user uses
+		typedef T TStorage;		// this is what we make our array of
+
+		typedef bits_true TConstructed;
+		typedef TStorage TArray[SIZE];
+
+
+		enum 
+		{
+			NEEDS_CONSTRUCT=0,
+			TOTAL_SIZE=sizeof(TStorage),
+			VALUE_SIZE=sizeof(TStorage),
+		};
+		static void construct(TStorage *)
+		{
+
+		}
+		static void construct(TStorage *me,const TValue &v)
+		{
+			*me=v;
+		}
+		static void destruct(TStorage *)
+		{
+
+		}
+		static TRatlNew *raw(TStorage *me)
+		{
+			return (TRatlNew *)me;
+		}
+		static T * ptr(TStorage *me)
+		{
+			return me;
+		}
+		static const T * ptr(const TStorage *me)
+		{
+			return me;
+		}
+		static T & ref(TStorage *me)
+		{
+			return *me;
+		}
+		static const T & ref(const TStorage *me)
+		{
+			return *me;
+		}
+		static T *raw_array(TStorage *me)
+		{
+			return me;
+		}
+		static const T *raw_array(const TStorage *me)
+		{
+			return me;
+		}
+		static void swap(TStorage *s1,TStorage *s2)
+		{
+			mem::swap(ptr(s1),ptr(s2));
+		}
+		static int pointer_to_index(const void *s1,const void *s2)
+		{
+			return ((TStorage *)s1)-((TStorage *)s2);
+		}
+	};
+	template<class T,int SIZE>
+	struct object_semantics
+	{
+		enum	
+		{
+			CAPACITY		= SIZE,
+		};
+		typedef mem::alignStruct TAlign;		// this is any type that has the right alignment
+		typedef T TValue;				// this is the actual thing the user uses
+
+		typedef bits_base<SIZE> TConstructed;
+
+		struct TStorage
+		{
+			TAlign mMemory[((sizeof(T) + sizeof(TAlign) -1 )/sizeof(TAlign))];
+		};
+		typedef TStorage TArray[SIZE];
+
+		enum 
+		{
+			NEEDS_CONSTRUCT=1,
+			TOTAL_SIZE=sizeof(TStorage),
+			VALUE_SIZE=sizeof(TStorage),
+		};
+
+		static void construct(TStorage *me)
+		{
+			new(raw(me)) TValue();						
+		}
+		static void construct(TStorage *me,const TValue &v)
+		{
+			new(raw(me)) TValue(v);									
+		}
+		static void destruct(TStorage *me)
+		{
+			ptr(me)->~T();				
+		}
+		static TRatlNew *raw(TStorage *me)
+		{
+			return (TRatlNew *)me;
+		}
+		static T * ptr(TStorage *me)
+		{
+			return (T *)me;
+		}
+		static const T * ptr(const TStorage *me)
+		{
+			return (const T *)me;
+		}
+		static T & ref(TStorage *me)
+		{
+			return *(T *)me;
+		}
+		static const T & ref(const TStorage *me)
+		{
+			return *(const T *)me;
+		}
+		static void swap(TStorage *s1,TStorage *s2)
+		{
+			TValue temp(ref(s1));
+			ref(s1)=ref(s2);
+			ref(s2)=temp;
+		}
+		static int pointer_to_index(const void *s1,const void *s2)
+		{
+			return ((TStorage *)s1)-((TStorage *)s2);
+		}	
+	};
+	template<class T,int SIZE,int MAX_CLASS_SIZE>
+	struct virtual_semantics
+	{
+		enum	
+		{
+			CAPACITY		= SIZE,
+		};
+		typedef mem::alignStruct TAlign;		// this is any type that has the right alignment
+		typedef T TValue;				// this is the actual thing the user uses
+
+		typedef bits_base<SIZE> TConstructed;
+
+		struct TStorage
+		{
+			TAlign mMemory[((MAX_CLASS_SIZE + sizeof(TAlign) -1 )/sizeof(TAlign))];
+		};
+		typedef TStorage TArray[SIZE];
+
+		enum 
+		{
+			NEEDS_CONSTRUCT=1,
+			TOTAL_SIZE=sizeof(TStorage),
+			VALUE_SIZE=MAX_CLASS_SIZE,
+		};
+
+		static void construct(TStorage *me)
+		{
+			new(raw(me)) TValue();						
+		}
+		static void destruct(TStorage *me)
+		{
+			ptr(me)->~T();				
+		}
+		static TRatlNew *raw(TStorage *me)
+		{
+			return (TRatlNew *)me;
+		}
+		static T * ptr(TStorage *me)
+		{
+			return (T *)me;
+		}
+		static const T * ptr(const TStorage *me)
+		{
+			return (const T *)me;
+		}
+		static T & ref(TStorage *me)
+		{
+			return *(T *)me;
+		}
+		static const T & ref(const TStorage *me)
+		{
+			return *(const T *)me;
+		}
+		// this is a bit suspicious, we are forced to do a memory swap, and for a class, that, say
+		// stores a pointer to itself, it won't work right
+		static void swap(TStorage *s1,TStorage *s2)
+		{
+			mem::swap(s1,s2);
+		}
+		static int pointer_to_index(const void *s1,const void *s2)
+		{
+			return ((TStorage *)s1)-((TStorage *)s2);
+		}	
+		template<class CAST_TO>
+		static CAST_TO *verify_alloc(CAST_TO *p)
+		{
+#ifdef _DEBUG
+			assert(p);
+			assert(dynamic_cast<const T *>(p));
+			T *ptr=p; // if this doesn't compile, you are trying to alloc something that is not derived from base
+			assert(dynamic_cast<const CAST_TO *>(ptr));
+			int i=VALUE_SIZE;
+			int k=MAX_CLASS_SIZE;
+			int j=sizeof(CAST_TO);
+			compile_assert<sizeof(CAST_TO)<=MAX_CLASS_SIZE>();
+			assert(sizeof(CAST_TO)<=MAX_CLASS_SIZE);
+#endif
+			return p;
+		}
+	};
+
+	// The below versions are for nodes
+
+	template<class T,int SIZE,class NODE>
+	struct value_semantics_node
+	{
+		enum	
+		{
+			CAPACITY		= SIZE,
+		};
+		struct SNode
+		{
+			NODE	nodeData;
+			T		value;
+		};
+		typedef SNode		TAlign;		// this is any type that has the right alignment
+		typedef T			TValue;		// this is the actual thing the user uses
+		typedef SNode		TStorage;		// this is what we make our array of
+
+		typedef bits_true TConstructed;
+		typedef TStorage TArray[SIZE];
+
+		enum 
+		{
+			NEEDS_CONSTRUCT=0,
+			TOTAL_SIZE=sizeof(TStorage),
+			VALUE_SIZE=sizeof(TValue),
+		};
+		static void construct(TStorage *)
+		{
+
+		}
+		static void construct(TStorage *me,const TValue &v)
+		{
+			me->value=v;
+		}
+		static void destruct(TStorage *)
+		{
+
+		}
+		static TRatlNew *raw(TStorage *me)
+		{
+			return (TRatlNew *)&me->value;
+		}
+		static T * ptr(TStorage *me)
+		{
+			return &me->value;
+		}
+		static const T * ptr(const TStorage *me)
+		{
+			return &me->value;
+		}
+		static T & ref(TStorage *me)
+		{
+			return me->value;
+		}
+		static const T & ref(const TStorage *me)
+		{
+			return me->value;
+		}
+		// this ugly unsafe cast-hack is a backhanded way of getting the node data from the value data
+		// this is so node support does not need to be added to the primitive containers
+		static NODE & node(TValue &v)
+		{
+			return *(NODE *)((unsigned char *)(&v)+int(&((TStorage *)0)->nodeData)-int(&((TStorage *)0)->value));
+		}
+		static const NODE & node(const TValue &v)
+		{
+			return *(const NODE *)((unsigned char *)(&v)+int(&((TStorage *)0)->nodeData)-int(&((TStorage *)0)->value));
+		}
+		static void swap(TStorage *s1,TStorage *s2)
+		{
+			mem::swap(&s1->value,&s2->value);
+		}
+		// this is hideous
+		static int pointer_to_index(const void *s1,const void *s2)
+		{
+			return 
+				((TStorage *)(((unsigned char *)s1)-int(&((TStorage *)0)->value))) - 
+				((TStorage *)(((unsigned char *)s2)-int(&((TStorage *)0)->value)));
+		}	
+	};
+
+	template<class T,int SIZE,class NODE>
+	struct object_semantics_node
+	{
+		enum	
+		{
+			CAPACITY		= SIZE,
+		};
+		typedef mem::alignStruct TAlign;		// this is any type that has the right alignment
+		typedef T			TValue;		// this is the actual thing the user uses
+
+		typedef bits_base<SIZE> TConstructed;
+
+		struct TValueStorage
+		{
+			TAlign mMemory[((sizeof(T) + sizeof(TAlign) -1 )/sizeof(TAlign))];
+		};
+		struct SNode
+		{
+			NODE				nodeData;
+			TValueStorage		value;
+		};
+		typedef SNode		TStorage;		// this is what we make our array of
+		typedef TStorage TArray[SIZE];
+
+
+		enum 
+		{
+			NEEDS_CONSTRUCT=0,
+			TOTAL_SIZE=sizeof(TStorage),
+			VALUE_SIZE=sizeof(TValueStorage),
+		};
+
+		static void construct(TStorage *me)
+		{
+			new(raw(me)) TValue();						
+		}
+		static void construct(TStorage *me,const TValue &v)
+		{
+			new(raw(me)) TValue(v);									
+		}
+		static void destruct(TStorage *me)
+		{
+			ptr(me)->~T();				
+		}
+		static TRatlNew *raw(TStorage *me)
+		{
+			return (TRatlNew *)&me->value;
+		}
+		static T * ptr(TStorage *me)
+		{
+			return (T *)&me->value;
+		}
+		static const T * ptr(const TStorage *me)
+		{
+			return (const T *)&me->value;
+		}
+		static T & ref(TStorage *me)
+		{
+			return *(T *)&me->value;
+		}
+		static const T & ref(const TStorage *me)
+		{
+			return *(const T *)&me->value;
+		}
+		static NODE & node(TStorage *me)
+		{
+			return me->nodeData;
+		}
+		static const NODE & node(const TStorage *me)
+		{
+			return me->nodeData;
+		}
+		// this ugly unsafe cast-hack is a backhanded way of getting the node data from the value data
+		// this is so node support does not need to be added to the primitive containers
+		static NODE & node(TValue &v)
+		{
+			return *(NODE *)((unsigned char *)(&v)+int(&((TStorage *)0)->nodeData)-int(&((TStorage *)0)->value));
+		}
+		static const NODE & node(const TValue &v)
+		{
+			return *(const NODE *)((unsigned char *)(&v)+int(&((TStorage *)0)->nodeData)-int(&((TStorage *)0)->value));
+		}
+		static void swap(TStorage *s1,TStorage *s2)
+		{
+			TValue temp(ref(s1));
+			ref(s1)=ref(s2);
+			ref(s2)=temp;
+		}
+		// this is hideous
+		static int pointer_to_index(const void *s1,const void *s2)
+		{
+			return 
+				((TStorage *)(((unsigned char *)s1)-int(&((TStorage *)0)->value))) - 
+				((TStorage *)(((unsigned char *)s2)-int(&((TStorage *)0)->value)));
+		}	
+	};
+	template<class T,int SIZE,int MAX_CLASS_SIZE,class NODE>
+	struct virtual_semantics_node
+	{
+		enum	
+		{
+			CAPACITY		= SIZE,
+		};
+		typedef mem::alignStruct TAlign;		// this is any type that has the right alignment
+		typedef T TValue;				// this is the actual thing the user uses
+
+		typedef bits_base<SIZE> TConstructed;
+
+		struct TValueStorage
+		{
+			TAlign mMemory[((MAX_CLASS_SIZE + sizeof(TAlign) -1 )/sizeof(TAlign))];
+		};
+		struct SNode
+		{
+			NODE				nodeData;
+			TValueStorage		value;
+		};
+		typedef SNode		TStorage;		// this is what we make our array of
+		typedef TStorage TArray[SIZE];
+
+		enum 
+		{
+			NEEDS_CONSTRUCT=1,
+			TOTAL_SIZE=sizeof(TStorage),
+			VALUE_SIZE=sizeof(TValueStorage),
+		};
+
+		static void construct(TStorage *me)
+		{
+			new(raw(me)) TValue();						
+		}
+		static void destruct(TStorage *me)
+		{
+			ptr(me)->~T();				
+		}
+		static TRatlNew *raw(TStorage *me)
+		{
+			return (TRatlNew *)&me->value;
+		}
+		static T * ptr(TStorage *me)
+		{
+			return (T *)&me->value;
+		}
+		static const T * ptr(const TStorage *me)
+		{
+			return (const T *)&me->value;
+		}
+		static T & ref(TStorage *me)
+		{
+			return *(T *)&me->value;
+		}
+		static const T & ref(const TStorage *me)
+		{
+			return *(const T *)&me->value;
+		}
+		static NODE & node(TStorage *me)
+		{
+			return me->nodeData;
+		}
+		static const NODE & node(const TStorage *me)
+		{
+			return me->nodeData;
+		}
+		// this ugly unsafe cast-hack is a backhanded way of getting the node data from the value data
+		// this is so node support does not need to be added to the primitive containers
+		static NODE & node(TValue &v)
+		{
+			return *(NODE *)((unsigned char *)(&v)+int(&((TStorage *)0)->nodeData)-int(&((TStorage *)0)->value));
+		}
+		static const NODE & node(const TValue &v)
+		{
+			return *(const NODE *)((unsigned char *)(&v)+int(&((TStorage *)0)->nodeData)-int(&((TStorage *)0)->value));
+		}
+		// this is a bit suspicious, we are forced to do a memory swap, and for a class, that, say
+		// stores a pointer to itself, it won't work right
+		static void swap(TStorage *s1,TStorage *s2)
+		{
+			mem::swap(&s1->value,&s2->value);
+		}
+		// this is hideous
+		static int pointer_to_index(const void *s1,const void *s2)
+		{
+			return 
+				((TStorage *)(((unsigned char *)s1)-int(&((TStorage *)0)->value))) - 
+				((TStorage *)(((unsigned char *)s2)-int(&((TStorage *)0)->value)));
+		}	
+		template<class CAST_TO>
+		static CAST_TO *verify_alloc(CAST_TO *p)
+		{
+#ifdef _DEBUG
+			assert(p);
+			assert(dynamic_cast<const T *>(p));
+			T *ptr=p; // if this doesn't compile, you are trying to alloc something that is not derived from base
+			assert(dynamic_cast<const CAST_TO *>(ptr));
+			int i=VALUE_SIZE;
+			int k=MAX_CLASS_SIZE;
+			int j=sizeof(CAST_TO);
+			compile_assert<sizeof(CAST_TO)<=MAX_CLASS_SIZE>();
+			assert(sizeof(CAST_TO)<=MAX_CLASS_SIZE);
+#endif
+			return p;
+		}
+	};
+
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// The Array Base Class, used for most containers
+////////////////////////////////////////////////////////////////////////////////////////
+template<class T>
+class array_base : public ratl_base
+{
+public:
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Capacity Enum
+    ////////////////////////////////////////////////////////////////////////////////////
+ 	enum 
+	{
+		CAPACITY	= T::CAPACITY,
+		SIZE		= T::CAPACITY,
+	};
+	////////////////////////////////////////////////////////////////////////////////////
+	// Data
+	////////////////////////////////////////////////////////////////////////////////////
+	typedef typename T					TStorageTraits;
+	typedef typename T::TArray			TTArray;
+	typedef typename T::TValue			TTValue;
+	typedef typename T::TConstructed	TTConstructed;
+
+private:
+	TTArray				mArray;
+	TTConstructed		mConstructed;
+
+public:
+
+	array_base()
+	{
+	}
+
+	~array_base()
+	{
+		clear();
+	}
+
+	void clear()
+	{
+		if (T::NEEDS_CONSTRUCT)
+		{
+			int i=mConstructed.next_bit();
+			while (i<SIZE)
+			{
+				T::destruct(mArray+i);
+				i=mConstructed.next_bit(i+1);
+			}
+			mConstructed.clear();
+		}
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Access Operator
+	////////////////////////////////////////////////////////////////////////////////////
+	TTValue&			operator[](int index)
+	{
+		assert(index>=0 && index<SIZE);
+		assert(mConstructed[index]);
+		return T::ref(mArray+index);
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Const Access Operator
+	////////////////////////////////////////////////////////////////////////////////////
+	const TTValue&	operator[](int index) const
+	{
+		assert(index>=0 && index<SIZE);
+		assert(mConstructed[index]);
+		return T::ref(mArray+index);
+	}
+
+	void construct(int i)
+	{
+		if (T::NEEDS_CONSTRUCT)
+		{
+			assert(!mConstructed[i]);
+			T::construct(mArray+i);
+			mConstructed.set_bit(i);
+		}
+	}
+	void construct(int i, const TTValue &v)
+	{
+		assert(i>=0 && i<SIZE);
+		T::construct(mArray+i,v);
+		if (T::NEEDS_CONSTRUCT)
+		{
+			assert(!mConstructed[i]);
+			mConstructed.set_bit(i);
+		}
+	}
+	void fill(const TTValue &v)
+	{
+		clear();
+		int i;
+		for (i=0;i<SIZE;i++)
+		{
+			T::construct(mArray+i,v);
+		}
+		if (T::NEEDS_CONSTRUCT)
+		{
+			mConstructed.set();
+		}
+	}
+	void swap(int i,int j)
+	{
+		assert(i>=0 && i<SIZE);
+		assert(j>=0 && j<SIZE);
+		assert(i!=j);
+		assert(mConstructed[i]);
+		assert(mConstructed[j]);
+		T::swap(mArray+i,mArray+j);
+	}
+
+	TRatlNew	*alloc_raw(int i)
+	{
+		assert(i>=0 && i<SIZE);
+		if (T::NEEDS_CONSTRUCT)
+		{
+			assert(!mConstructed[i]);
+			mConstructed.set_bit(i);
+		}
+		return T::raw(mArray+i);
+	}
+	void	destruct(int i)
+	{
+		assert(i>=0 && i<SIZE);
+		assert(mConstructed[i]);
+		if (T::NEEDS_CONSTRUCT)
+		{
+			T::destruct(mArray+i);
+			mConstructed.clear_bit(i);
+		}
+	}
+	int pointer_to_index(const TTValue *me) const
+	{
+		int index=T::pointer_to_index(me,mArray);
+		assert(index>=0 && index<SIZE);
+		assert(mConstructed[index]);
+		return index;
+	}
+	int pointer_to_index(const TRatlNew *me) const
+	{
+		int index=T::pointer_to_index(me,mArray);
+		assert(index>=0 && index<SIZE);
+		assert(mConstructed[index]);
+		return index;
+	}
+	typename T::TValue *raw_array()
+	{
+		return T::raw_array(mArray);
+	}
+	const typename T::TValue *raw_array() const
+	{
+		return T::raw_array(mArray);
+	}
+	template<class CAST_TO>
+	CAST_TO *verify_alloc(CAST_TO *p) const
+	{
+		return T::verify_alloc(p);
+	}
+
+};
+
+}
+#endif
\ No newline at end of file
diff --git a/code/Ratl/scheduler_vs.h b/code/Ratl/scheduler_vs.h
new file mode 100644
index 0000000..13847b0
--- /dev/null
+++ b/code/Ratl/scheduler_vs.h
@@ -0,0 +1,218 @@
+////////////////////////////////////////////////////////////////////////////////////////
+// RAVEN STANDARD TEMPLATE LIBRARY
+//  (c) 2002 Activision
+//
+//
+// Scheduler
+// ---------
+// The scheduler is a common piece of game functionality.  To use it, simply add events
+// at the given time, and call update() with the current time as frequently as you wish.
+//
+// Your event class MUST define a Fire() function which accepts a TCALLBACKPARAMS
+// parameter.
+//
+// NOTES:
+// 
+//
+//
+////////////////////////////////////////////////////////////////////////////////////////
+#if !defined(RATL_SCHEDULER_VS_INC)
+#define RATL_SCHEDULER_VS_INC
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Includes
+////////////////////////////////////////////////////////////////////////////////////////
+#if !defined(RATL_COMMON_INC)
+	#include "ratl_common.h"
+#endif
+#if !defined(RATL_POOL_VS_INC)
+	#include "pool_vs.h"
+#endif
+#if !defined(RATL_HEAP_VS_INC)
+	#include "heap_vs.h"
+#endif
+namespace ratl
+{
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// The Scheduler Class
+////////////////////////////////////////////////////////////////////////////////////////
+template <class T>
+class scheduler_base : public ratl_base
+{
+public:
+	typedef typename T TStorageTraits;
+	typedef typename T::TValue TTValue;
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Capacity Enum
+    ////////////////////////////////////////////////////////////////////////////////////
+ 	enum 
+	{
+		CAPACITY		= T::CAPACITY
+	};
+private:
+	////////////////////////////////////////////////////////////////////////////////////
+	// The Timed Event Class
+	//
+	// This class stores two numbers, a timer and an iterator to the events list.  We
+	// don't store the event directly in the heap to make the swap operation in the
+	// heap faster.  We define a less than operator so we can sort in the heap.
+	//
+    ////////////////////////////////////////////////////////////////////////////////////
+	struct timed_event
+	{
+		float	mTime;
+		int		mEvent;
+
+		timed_event() {}
+		timed_event(float time, int event) : mTime(time), mEvent(event)	{}
+		bool	operator<  (const timed_event& t) const
+		{
+			return	(mTime > t.mTime);
+		}
+	};
+
+	pool_base<TStorageTraits>			mEvents;
+	heap_vs<timed_event, CAPACITY>		mHeap;
+
+public:
+	////////////////////////////////////////////////////////////////////////////////////
+	// How Many Objects Are In This List
+    ////////////////////////////////////////////////////////////////////////////////////
+	int			size() const
+	{
+		// warning during a fire call, there will be one extra event
+		return mEvents.size();
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Are There Any Objects In This List?
+    ////////////////////////////////////////////////////////////////////////////////////
+	bool		empty() const
+	{
+		return !size();
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Is This List Filled?
+    ////////////////////////////////////////////////////////////////////////////////////
+	bool		full() const
+	{
+		return mEvents.full();
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Clear All Elements
+    ////////////////////////////////////////////////////////////////////////////////////
+	void		clear()
+	{
+		mEvents.clear();
+		mHeap.clear();
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Add An Event
+    ////////////////////////////////////////////////////////////////////////////////////
+	void		add(float time, const TTValue& e)
+	{
+		int	nLoc = mEvents.alloc(e);
+		mHeap.push(timed_event(time, nLoc));
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Add An Event
+    ////////////////////////////////////////////////////////////////////////////////////
+	TTValue &	add(float time)
+	{
+		int	nLoc = mEvents.alloc();
+		mHeap.push(timed_event(time, nLoc));
+		return mEvents[nLoc];
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Add A Raw Event for placement new
+    ////////////////////////////////////////////////////////////////////////////////////
+	TRatlNew *	add_raw(float time)
+	{
+		TRatlNew *ret = mEvents.alloc_raw();
+		mHeap.push(timed_event(time, mEvents.pointer_to_index(ret)));
+		return ret;
+	}
+
+	template<class TCALLBACKPARAMS>
+	void		update(float time, TCALLBACKPARAMS& Params)
+	{
+		while (!mHeap.empty())
+		{
+			timed_event	Next = mHeap.top();
+			if (Next.mTime>=time)
+			{
+				break;
+			}
+			mHeap.pop();
+			mEvents[Next.mEvent].Fire(Params);
+			mEvents.free(Next.mEvent);
+		}
+	}
+
+	void update(float time)
+	{
+		while (!mHeap.empty())
+		{
+			timed_event	Next = mHeap.top();
+			if (Next.mTime>=time)
+			{
+				break;
+			}
+			mHeap.pop();
+			mEvents[Next.mEvent].Fire();
+			mEvents.free(Next.mEvent);
+		}
+	}	
+};
+
+
+template<class T, int ARG_CAPACITY>
+class scheduler_vs : public scheduler_base<storage::value_semantics<T,ARG_CAPACITY> >
+{
+public:
+	typedef typename storage::value_semantics<T,ARG_CAPACITY> TStorageTraits;
+	typedef typename TStorageTraits::TValue TTValue;
+ 	enum 
+	{
+		CAPACITY		= ARG_CAPACITY
+	};
+	scheduler_vs() {}
+};
+
+template<class T, int ARG_CAPACITY>
+class scheduler_os : public scheduler_base<storage::object_semantics<T,ARG_CAPACITY> >
+{
+public:
+	typedef typename storage::object_semantics<T,ARG_CAPACITY> TStorageTraits;
+	typedef typename TStorageTraits::TValue TTValue;
+ 	enum 
+	{
+		CAPACITY		= ARG_CAPACITY
+	};
+	scheduler_os() {}
+};
+
+template<class T, int ARG_CAPACITY, int ARG_MAX_CLASS_SIZE>
+class scheduler_is : public scheduler_base<storage::virtual_semantics<T,ARG_CAPACITY,ARG_MAX_CLASS_SIZE> >
+{
+public:
+	typedef typename storage::virtual_semantics<T,ARG_CAPACITY,ARG_MAX_CLASS_SIZE> TStorageTraits;
+	typedef typename TStorageTraits::TValue TTValue;
+ 	enum 
+	{
+		CAPACITY		= ARG_CAPACITY,
+		MAX_CLASS_SIZE	= ARG_MAX_CLASS_SIZE
+	};
+	scheduler_is() {}
+};
+
+}
+#endif
\ No newline at end of file
diff --git a/code/Ratl/stack_vs.h b/code/Ratl/stack_vs.h
new file mode 100644
index 0000000..a49fe5b
--- /dev/null
+++ b/code/Ratl/stack_vs.h
@@ -0,0 +1,197 @@
+////////////////////////////////////////////////////////////////////////////////////////
+// RAVEN STANDARD TEMPLATE LIBRARY
+//  (c) 2002 Activision
+//
+//
+// Stack
+// -----
+// This is a very simple wrapper around a stack object.
+//
+// First In, Last Out
+//
+//
+//
+// NOTES:
+// 
+//
+//
+////////////////////////////////////////////////////////////////////////////////////////
+#if !defined(RATL_STACK_VS_INC)
+#define RATL_STACK_VS_INC
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Includes
+////////////////////////////////////////////////////////////////////////////////////////
+#if !defined(RATL_COMMON_INC)
+	#include "ratl_common.h"
+#endif
+namespace ratl
+{
+
+////////////////////////////////////////////////////////////////////////////////////////
+// The stack Class
+////////////////////////////////////////////////////////////////////////////////////////
+template <class T>
+class stack_base : public ratl_base
+{
+public:
+	typedef typename T TStorageTraits;
+	typedef typename T::TValue TTValue;
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Capacity Enum
+    ////////////////////////////////////////////////////////////////////////////////////
+ 	enum 
+	{
+		CAPACITY		= T::CAPACITY
+	};
+private:
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Data
+	////////////////////////////////////////////////////////////////////////////////////
+	array_base<TStorageTraits>		mData;			// The Memory
+	int								mSize;
+
+public:
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Constructor
+    ////////////////////////////////////////////////////////////////////////////////////
+	stack_base() : mSize(0)
+	{
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Get The Size (The Difference Between The Push And Pop "Pointers")
+    ////////////////////////////////////////////////////////////////////////////////////
+	int				size() const
+	{
+		return mSize;
+	}
+	
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Check To See If The Size Is Zero
+    ////////////////////////////////////////////////////////////////////////////////////
+	bool			empty() const
+	{
+		return !mSize;
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Check To See If The Size Is Full
+    ////////////////////////////////////////////////////////////////////////////////////
+	bool			full() const
+	{
+		return mSize>=CAPACITY;
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Empty Out The Entire stack
+	////////////////////////////////////////////////////////////////////////////////////
+	void			clear()
+	{
+		mSize = 0;
+		mData.clear();
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Add A Value, returns a reference to the value in place
+    ////////////////////////////////////////////////////////////////////////////////////
+	TTValue &		push()
+	{
+		assert(!full());
+		mData.construct(mSize);	
+		mSize++;
+		return mData[mSize-1];
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Add A Value to the stack
+    ////////////////////////////////////////////////////////////////////////////////////
+	void push(const TTValue& v)
+	{
+		assert(!full());
+		mData.construct(mSize,v);	
+		mSize++;
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Add A Value to the stack, returning a void * to the memory
+    ////////////////////////////////////////////////////////////////////////////////////
+	TRatlNew *push_raw()
+	{
+		assert(!full());
+		mSize++;
+		return mData.alloc_raw(mSize-1);	
+	}
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Remove A Value From The stack
+    ////////////////////////////////////////////////////////////////////////////////////
+	void			pop()
+	{
+		assert(!empty());
+		mSize--;
+		mData.destruct(mSize);
+	}
+
+	TTValue & top()
+	{
+		assert(!empty());
+		return mData[mSize-1];
+	}
+
+	const TTValue & top() const
+	{
+		assert(!empty());
+		return mData[mSize-1];
+	}
+	template<class CAST_TO>
+	CAST_TO *verify_alloc(CAST_TO *p) const
+	{
+		return mData.verify_alloc(p);
+	}
+};
+
+template<class T, int ARG_CAPACITY>
+class stack_vs : public stack_base<storage::value_semantics<T,ARG_CAPACITY> >
+{
+public:
+	typedef typename storage::value_semantics<T,ARG_CAPACITY> TStorageTraits;
+	typedef typename TStorageTraits::TValue TTValue;
+ 	enum 
+	{
+		CAPACITY		= ARG_CAPACITY
+	};
+	stack_vs() {}
+};
+
+template<class T, int ARG_CAPACITY>
+class stack_os : public stack_base<storage::object_semantics<T,ARG_CAPACITY> >
+{
+public:
+	typedef typename storage::object_semantics<T,ARG_CAPACITY> TStorageTraits;
+	typedef typename TStorageTraits::TValue TTValue;
+ 	enum 
+	{
+		CAPACITY		= ARG_CAPACITY
+	};
+	stack_os() {}
+};
+
+template<class T, int ARG_CAPACITY, int ARG_MAX_CLASS_SIZE>
+class stack_is : public stack_base<storage::virtual_semantics<T,ARG_CAPACITY,ARG_MAX_CLASS_SIZE> >
+{
+public:
+	typedef typename storage::virtual_semantics<T,ARG_CAPACITY,ARG_MAX_CLASS_SIZE> TStorageTraits;
+	typedef typename TStorageTraits::TValue TTValue;
+ 	enum 
+	{
+		CAPACITY		= ARG_CAPACITY,
+		MAX_CLASS_SIZE	= ARG_MAX_CLASS_SIZE
+	};
+	stack_is() {}
+};
+
+
+}
+#endif
\ No newline at end of file
diff --git a/code/Ratl/string_vs.h b/code/Ratl/string_vs.h
new file mode 100644
index 0000000..39fc12e
--- /dev/null
+++ b/code/Ratl/string_vs.h
@@ -0,0 +1,366 @@
+////////////////////////////////////////////////////////////////////////////////////////
+// RAVEN STANDARD TEMPLATE LIBRARY
+//  (c) 2002 Activision
+//
+//
+// String
+// ------
+// Simple wrapper around a char[SIZE] array.
+//
+//
+//
+// NOTES:
+// 
+//
+//
+////////////////////////////////////////////////////////////////////////////////////////
+#if !defined(RATL_STRING_VS_INC)
+#define RATL_STRING_VS_INC
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Includes
+////////////////////////////////////////////////////////////////////////////////////////
+#if !defined(RATL_COMMON_INC)
+	#include "ratl_common.h"
+#endif
+
+namespace ratl
+{
+
+////////////////////////////////////////////////////////////////////////////////////////
+// The String Class
+////////////////////////////////////////////////////////////////////////////////////////
+template<int ARG_CAPACITY>
+class string_vs : public ratl_base
+{
+public:
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Capacity Enum
+    ////////////////////////////////////////////////////////////////////////////////////
+ 	enum 
+	{
+		CAPACITY			= ARG_CAPACITY,
+	};
+private:
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Data
+    ////////////////////////////////////////////////////////////////////////////////////
+#ifdef _DEBUG
+	char	mData[CAPACITY+4];
+#else
+	char	mData[CAPACITY];
+#endif
+
+	void FillTerminator()
+	{
+#ifdef _DEBUG
+		mData[CAPACITY]='e';
+		mData[CAPACITY+1]='n';
+		mData[CAPACITY+2]='d';
+		mData[CAPACITY+3]=0;
+#endif
+	}
+
+public:
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Constructor
+    ////////////////////////////////////////////////////////////////////////////////////
+	string_vs()
+	{
+		mData[0]=0;
+		FillTerminator();
+	}
+#ifdef _DEBUG
+	~string_vs()
+	{
+		//if you hit the below asserts, the end of the string was overwritten
+		assert(mData[CAPACITY]=='e');
+		assert(mData[CAPACITY+1]=='n');
+		assert(mData[CAPACITY+2]=='d');
+		assert(mData[CAPACITY+3]==0);
+	}
+#endif
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Copy Constructor
+    ////////////////////////////////////////////////////////////////////////////////////
+	string_vs(const string_vs<CAPACITY> &o)
+	{		
+		assert(str::len(o.mData)<CAPACITY);
+		str::ncpy(mData, o.mData, CAPACITY);		// Safe String Copy
+		mData[CAPACITY-1] = 0;					// Make Sure We Have A Null Terminated Str
+		FillTerminator();
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Copy Constructor
+    ////////////////////////////////////////////////////////////////////////////////////
+	string_vs(const char *s)
+	{
+		assert(str::len(s)<CAPACITY);
+		str::ncpy(mData, s, CAPACITY);		// Safe String Copy
+		mData[CAPACITY-1] = 0;					// Make Sure We Have A Null Terminated Str
+		FillTerminator();
+	}
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// 
+    ////////////////////////////////////////////////////////////////////////////////////
+	string_vs& operator=(const char *s)
+	{
+		assert(str::len(s)<CAPACITY);
+		str::ncpy(mData, s, CAPACITY);			// Safe String Copy
+		mData[CAPACITY-1] = 0;					// Make Sure We Have A Null Terminated Str
+		FillTerminator();
+		return *this;
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Access To Raw Array
+    ////////////////////////////////////////////////////////////////////////////////////
+	char*			c_str()
+	{
+		return mData;
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Access To Raw Array
+    ////////////////////////////////////////////////////////////////////////////////////
+	const char*		c_str() const
+	{
+		return mData;
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Access To Raw Array
+    ////////////////////////////////////////////////////////////////////////////////////
+	operator const char *()
+	{
+		return mData;
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Access To Raw Array
+    ////////////////////////////////////////////////////////////////////////////////////
+	const char*		operator*()
+	{
+		return mData;
+	}
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// How Many Characters Can This Hold
+    ////////////////////////////////////////////////////////////////////////////////////
+	int				capacity() const
+	{
+		return CAPACITY;
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Length
+    ////////////////////////////////////////////////////////////////////////////////////
+	int				length() const
+	{
+		assert(str::len(mData)<CAPACITY-1);
+		return str::len(mData);
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Character Bracket Operator
+    ////////////////////////////////////////////////////////////////////////////////////
+	char			operator[](int index)
+	{
+		assert(index<CAPACITY);
+		return mData[index];
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Equality Operator
+    ////////////////////////////////////////////////////////////////////////////////////
+	bool			operator==(const string_vs &o) const
+	{
+		if (!stricmp(mData,o.mData))
+		{
+			return true;
+		}
+		return false;
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// InEquality Operator
+    ////////////////////////////////////////////////////////////////////////////////////
+	bool			operator!=(const string_vs &o) const
+	{
+		if (str::icmp(mData,o.mData)!=0)
+		{
+			return true;
+		}
+		return false;
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Compare Less Than
+    ////////////////////////////////////////////////////////////////////////////////////
+	bool			operator<(const string_vs &o) const
+	{
+		if (str::icmp(mData,o.mData)<0)
+		{
+			return true;
+		}
+		return false;
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Compare Greater Than
+    ////////////////////////////////////////////////////////////////////////////////////
+	bool			operator>(const string_vs &o) const
+	{
+		if (str::icmp(mData,o.mData)>0)
+		{
+			return true;
+		}
+		return false;
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// 
+    ////////////////////////////////////////////////////////////////////////////////////
+	void			operator+=(const string_vs &o)
+	{
+		if ( (str::len(mData)+o.length())<CAPACITY )		// Only If It Is Safe
+		{
+			str::cat(mData, o.c_str());
+		}
+		else
+		{
+			assert(!"string_vs overflow\n");
+		}
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// 
+    ////////////////////////////////////////////////////////////////////////////////////
+	void			operator+=(const char *s)
+	{
+		if ( (str::len(mData)+str::len(s))<CAPACITY )		// Only If It Is Safe
+		{
+			str::cat(mData, s);
+		}
+		else
+		{
+			assert(!"string_vs overflow\n");
+		}
+	}
+
+
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Tokenizer
+	//
+	// The string tokenizer class is similar to an iterator in that it essentially
+	// iterates over all the tokens in the string seperated by a common series of
+	// delinating sequences.  For example:  " ,\t\n" would seperate tokens on spaces
+	// commas, tabs and linefeeds.
+	//
+	// Iterating over string tokens is just like normal iteration:
+	//
+	// for (string_vs<CAPACITY>::tokenizer it=MyString.begin(" ,\t\n"); it!=MyString.end(); it++)
+	// {
+	//    const char* token = *it;
+	// }
+	//
+	//
+	// NOTE: This class is built upon the c library function strtok() which uses a
+	// static working area, so having multiple tokenizers in multiple threads or just
+	// plain at the same time is not safe.
+	//
+    ////////////////////////////////////////////////////////////////////////////////////
+	class tokenizer
+	{
+		enum
+		{
+			TOKEN_GAP_LEN	= 15,
+		};
+
+	public:
+		// Constructors
+		//--------------
+		tokenizer()							: mLoc(0)
+		{}
+		tokenizer(const char* t, const char* gap)	
+		{
+			strncpy(mGap, gap, TOKEN_GAP_LEN);		// Safe String Copy
+			mGap[TOKEN_GAP_LEN-1] = 0;				// Make Sure We Have A Null Terminated Str
+
+			char*	temp = (char*)t;
+			mLoc = str::tok(temp, mGap);
+		}
+
+		// Assignment Operator
+		//---------------------
+		void		operator= (const tokenizer &t)
+		{
+			mLoc	= t.mLoc;
+			str::cpy(mGap, t.mGap);
+		}
+
+		// Equality Operators
+		//--------------------
+		bool		operator==(const tokenizer &t)		{return (mLoc==t.mLoc);}
+		bool		operator!=(const tokenizer &t)		{return !(operator==(t));}
+
+
+
+		// DeReference Operator
+		//----------------------
+		const char*	operator*()								
+		{
+			assert(mLoc);
+			return mLoc;
+		}
+
+		// Inc & Dec Operators
+		//--------------------
+		void		operator++(int)
+		{
+			assert(mLoc && mGap[0]);
+			mLoc = str::tok(NULL, mGap);
+		}
+
+		// Data
+		//------
+	private:
+		char*					mLoc;
+		char					mGap[TOKEN_GAP_LEN];
+	};
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Get An Iterator To The First Token Seperated By Gap
+    ////////////////////////////////////////////////////////////////////////////////////
+	tokenizer	begin(const char* gap)
+	{
+		return tokenizer(mData, gap);
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// The Invalid Iterator, Use As A Stop Condition In Your For Loops
+    ////////////////////////////////////////////////////////////////////////////////////
+	tokenizer	end()
+	{
+		return tokenizer();
+	}
+
+};
+
+
+}
+
+//fixme get rid of these
+typedef ratl::string_vs<256> TString_vs;
+typedef ratl::string_vs<128> TUIString_vs;
+
+#endif
diff --git a/code/Ratl/vector_vs.h b/code/Ratl/vector_vs.h
new file mode 100644
index 0000000..ad8bb05
--- /dev/null
+++ b/code/Ratl/vector_vs.h
@@ -0,0 +1,757 @@
+////////////////////////////////////////////////////////////////////////////////////////
+// RAVEN STANDARD TEMPLATE LIBRARY
+//  (c) 2002 Activision
+//
+//
+// Vector
+// ------
+// The vector class is a simple addition to the array.  It supports some useful additions
+// like sort and binary search, as well as keeping track of the number of objects
+// contained within.
+//
+//
+//
+//
+//
+// NOTES:
+//
+//
+////////////////////////////////////////////////////////////////////////////////////////
+#if !defined(RATL_VECTOR_VS_INC)
+#define RATL_VECTOR_VS_INC
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Includes
+////////////////////////////////////////////////////////////////////////////////////////
+#if !defined(RATL_COMMON_INC)
+	#include "ratl_common.h"
+#endif
+namespace ratl
+{
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// The Vector Class
+////////////////////////////////////////////////////////////////////////////////////////
+template<class T>
+class vector_base : public ratl_base
+{
+public:
+	typedef typename T TStorageTraits;
+	typedef typename T::TValue TTValue;
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Capacity Enum
+    ////////////////////////////////////////////////////////////////////////////////////
+ 	enum 
+	{
+		CAPACITY		= T::CAPACITY
+	};
+private:
+	array_base<TStorageTraits>		mArray;			// The Memory
+	int								mSize;
+public:
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Constructor
+    ////////////////////////////////////////////////////////////////////////////////////
+	vector_base()
+	{
+		mSize = 0;
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Copy Constructor
+	////////////////////////////////////////////////////////////////////////////////////
+	vector_base(const vector_base &B)
+	{
+		for (int i=0; i<B.size(); i++)
+		{
+			mArray[i] = B.mArray[i];
+		}
+		mSize = val.mSize;
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// How Many Objects Can Be Added?
+    ////////////////////////////////////////////////////////////////////////////////////
+	int				capacity() const
+	{
+		assert(mSize>=0&&mSize<=CAPACITY);
+		return (CAPACITY);
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// How Many Objects Have Been Added To This Vector?
+    ////////////////////////////////////////////////////////////////////////////////////
+	int				size() const
+	{
+		assert(mSize>=0&&mSize<=CAPACITY);
+		return (mSize);
+	}
+    
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Have Any Objects Have Been Added To This Vector?
+    ////////////////////////////////////////////////////////////////////////////////////
+	bool			empty() const
+	{
+		assert(mSize>=0&&mSize<=CAPACITY);
+		return (!mSize);
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Have Any Objects Have Been Added To This Vector?
+    ////////////////////////////////////////////////////////////////////////////////////
+	bool			full() const
+	{
+		assert(mSize>=0&&mSize<=CAPACITY);
+		return (mSize==CAPACITY);
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Clear Out Entire Array
+	////////////////////////////////////////////////////////////////////////////////////
+	void			clear()
+	{
+		mArray.clear();
+		mSize = 0;
+	}
+	// Constant Access Operator
+	////////////////////////////////////////////////////////////////////////////////////
+	const TTValue&		operator[](int index) const
+	{
+		assert(index>=0&&index<mSize);
+		return mArray[index];
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Access Operator
+	////////////////////////////////////////////////////////////////////////////////////
+	TTValue&				operator[](int index)
+	{
+		assert(index>=0&&index<mSize);
+		return mArray[index];
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Access To The Raw Array Pointer
+	////////////////////////////////////////////////////////////////////////////////////
+	TTValue *				raw_array()
+	{
+		  // this (intentionally) won't compile for anything except value semantics
+			// could be done with object semantics, but I would want to assert that all objects are contructed
+		  return T::raw_array(mArray);
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Access To The Raw Array Pointer
+	////////////////////////////////////////////////////////////////////////////////////
+	const TTValue*				raw_array() const
+	{
+		  // this (intentionally) won't compile for anything except value semantics
+			// could be done with object semantics, but I would want to assert that all objects are contructed
+		  return T::raw_array(mArray);
+	}
+
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Assignment Operator
+	////////////////////////////////////////////////////////////////////////////////////
+	vector_base&		operator=(const vector_base& val)
+	{
+		for (int i=0; i<val.size(); i++)
+		{
+			mArray[i] = val.mArray[i];
+		}
+		mSize = val.mSize;
+		return *this;
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Add
+	////////////////////////////////////////////////////////////////////////////////////
+	TTValue &				push_back()
+	{
+		assert(mSize>=0&&mSize<CAPACITY);
+		mArray.construct(mSize);
+		mSize++;
+		return (mArray[mSize-1]);
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Add (And Set)
+	////////////////////////////////////////////////////////////////////////////////////
+	void			push_back(const TTValue& value)
+	{
+		assert(mSize>=0&&mSize<CAPACITY);
+		mArray.construct(mSize,value);
+		mSize++;
+	}
+	
+	////////////////////////////////////////////////////////////////////////////////////
+	// Add raw
+	////////////////////////////////////////////////////////////////////////////////////
+	TRatlNew *			push_back_raw()
+	{
+		assert(mSize>=0&&mSize<CAPACITY);
+		mSize++;
+		return mArray.alloc_raw(mSize-1);
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Remove
+	////////////////////////////////////////////////////////////////////////////////////
+	void			pop_back()
+	{
+		assert(mSize>0);
+		mSize--;
+		mArray.destruct(mSize);
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Resizes The Array.  If New Elements Are Needed, It Uses The (value) Param
+	////////////////////////////////////////////////////////////////////////////////////
+	void			resize(int nSize, const TTValue& value)
+	{
+		int i;
+		for (i=(mSize-1); i>=nSize; i--)
+		{
+			mArray.destruct(i);
+			mSize--;
+		}
+		for (i=mSize; i<nSize; i++)
+		{
+			mArray.construct(i,value);
+		}
+		mSize = nSize;
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Resizes The Array.  If New Elements Are Needed, It Uses The (value) Param
+	////////////////////////////////////////////////////////////////////////////////////
+	void			resize(int nSize)
+	{
+		int i;
+		for (i=mSize-1; i>=nSize; i--)
+		{
+			mArray.destruct(i);
+			mSize--;
+		}
+		for (i=mSize; i<nSize; i++)
+		{
+			mArray.construct(i);
+		}
+		mSize = nSize;
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Swap the values at two locations
+	////////////////////////////////////////////////////////////////////////////////////
+	void swap(int i,int j)
+	{
+		assert(i<mSize && j<mSize);
+		mArray.swap(i, j);
+	}
+
+
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Erase An Iterator Location... NOTE: THIS DOES NOT PRESERVE ORDER IN THE VECTOR!!
+	////////////////////////////////////////////////////////////////////////////////////
+	void erase_swap(int Index)
+	{
+		assert(Index>=0 && Index<mSize);
+		if (Index != mSize - 1)
+		{
+			mArray.swap(Index, mSize - 1);
+		}
+		pop_back();
+	}
+
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Binary Search
+	////////////////////////////////////////////////////////////////////////////////////
+	int				find_index(const TTValue& value) const
+	{
+		int base = 0;
+		int head = mSize-1;
+
+		while (1)
+		{
+			int searchAt = (base+head)/2;
+
+			if (base == head && searchAt == head)
+			{
+				break;
+			}
+
+			if (value < mArray[searchAt])
+			{
+				head = searchAt-1;
+			}
+			else if (mArray[searchAt] < value)
+			{
+				base = searchAt;
+			}
+			else
+			{
+				return searchAt;
+			}
+			if (head < base)
+			{
+				break;
+			}
+		}
+
+		return mSize; //not found!
+	}
+
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Heap Sort
+	//
+	// This sort algorithm has all the advantages of merge sort in terms of guarenteeing
+	// O(n log n) worst case, as well as all the advantages of quick sort in that it is
+	// "in place" and requires no additional storage.
+	//
+	////////////////////////////////////////////////////////////////////////////////////
+	void			sort()
+	{
+		// Temporary Data
+		//----------------
+		int	HeapSize;	// How Large The Heap Is (Grows In PHASE 1, Shrinks In PHASE 2)
+		int	Pos;		// The Location We Are AT During "re-heapify" Loops
+		int	Compare;	// The Location We Are Comparing AGAINST During "re-heapify" Loops
+
+
+
+
+		// PHASE 1, CONSTRUCT THE HEAP										  O(n log n)
+		//===============================================================================
+		for (HeapSize=1; HeapSize<mSize; HeapSize++)
+		{
+			// We Now Have An Element At Heap Size Which Is Not In It's Correct Place
+			//------------------------------------------------------------------------
+			Pos		= HeapSize;
+			Compare	= parent(Pos);
+			while (mArray[Compare]<mArray[Pos])
+			{
+				// Swap The Compare Element With The Pos Element
+				//-----------------------------------------------
+				mArray.swap(Compare, Pos);
+
+				// Move Pos To The Current Compare, And Recalc Compare
+				//------------------------------------------------------
+				Pos		= Compare;
+				Compare = parent(Pos);
+			}
+		}
+
+	
+
+
+		// PHASE 2, POP OFF THE TOP OF THE HEAP ONE AT A TIME (AND FIX)       O(n log n)
+		//===============================================================================
+		for (HeapSize=(mSize-1); HeapSize>0; HeapSize--)
+		{
+			// Swap The End And Front Of The "Heap" Half Of The Array
+			//--------------------------------------------------------
+			mArray.swap(0, HeapSize);
+
+			// We Now Have A Bogus Element At The Root, So Fix The Heap
+			//----------------------------------------------------------
+			Pos		= 0;
+			Compare = largest_child(Pos, HeapSize);
+			while (mArray[Pos]<mArray[Compare])
+			{
+				// Swap The Compare Element With The Pos Element
+				//-----------------------------------------------
+				mArray.swap(Compare, Pos);
+
+				// Move Pos To The Current Compare, And Recalc Compare
+				//------------------------------------------------------
+				Pos		= Compare;
+				Compare	= largest_child(Pos, HeapSize);
+			}
+		}
+	}
+
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// THIS IS A QUICK VALIDATION OF A SORTED LIST
+	////////////////////////////////////////////////////////////////////////////////////
+#ifdef _DEBUG
+	void			sort_validate() const
+	{
+		for (int a=0; a<(mSize-1); a++)
+		{
+			assert(mArray[a] < mArray[a+1]);
+		}
+	}
+#endif
+
+private:
+	////////////////////////////////////////////////////////////////////////////////////
+	// For Heap Sort
+	// Returns The Location Of Node (i)'s Parent Node (The Parent Node Of Zero Is Zero)
+	////////////////////////////////////////////////////////////////////////////////////
+	static int			parent(int i)				
+	{
+		return ((i-1)/2);
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// For Heap Sort
+	// Returns The Location Of Node (i)'s Left Child (The Child Of A Leaf Is The Leaf)
+	////////////////////////////////////////////////////////////////////////////////////
+	static int			left(int i)	
+	{
+		return ((2*i)+1);
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// For Heap Sort
+	// Returns The Location Of Node (i)'s Right Child (The Child Of A Leaf Is The Leaf)
+	////////////////////////////////////////////////////////////////////////////////////
+	static int			right(int i)
+	{
+		return ((2*i)+2);
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// For Heap Sort
+	// Returns The Location Of Largest Child Of Node (i)
+	////////////////////////////////////////////////////////////////////////////////////
+	int			largest_child(int i, int Size) const
+	{
+		if (left(i)<Size)
+		{
+			if (right(i)<Size)
+			{
+				return ( (mArray[right(i)] < mArray[left(i)]) ? (left(i)) : (right(i)) );
+			}
+			return left(i);	// Node i only has a left child, so by default it is the biggest
+		}
+		return i;		// Node i is a leaf, so just return it
+	}
+
+public:
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Iterator
+    ////////////////////////////////////////////////////////////////////////////////////
+	class const_iterator;
+	class iterator
+	{
+		friend class vector_base<T>;
+		friend class const_iterator;
+		// Data
+		//------
+		int						mLoc;
+		vector_base<T>*			mOwner;
+
+	public:
+		// Constructors
+		//--------------
+		iterator()						: mOwner(0), mLoc(0)
+		{}
+		iterator(vector_base<T>* p, int t)	: mOwner(p), mLoc(t)
+		{}
+
+		iterator(const iterator &t)		: mOwner(t.mOwner), mLoc(t.mLoc)
+		{}
+
+		// Assignment Operator
+		//---------------------
+		void		operator= (const iterator &t)
+		{
+			mOwner	= t.mOwner;	
+			mLoc	= t.mLoc;
+		}
+
+
+		// Equality Operators
+		//--------------------
+		bool		operator!=(const iterator &t)	const
+		{
+			return (mLoc!=t.mLoc  || mOwner!=t.mOwner);
+		}
+		bool		operator==(const iterator &t)	const				
+		{
+			return (mLoc==t.mLoc && mOwner==t.mOwner);
+		}
+
+		// DeReference Operator
+		//----------------------
+		TTValue&			operator* ()	const			
+		{
+			assert(mLoc>=0 && mLoc<mOwner->mSize);
+			return (mOwner->mArray[mLoc]);
+		}
+		// DeReference Operator
+		//----------------------
+		TTValue&			value()	const			
+		{
+			assert(mLoc>=0 && mLoc<mOwner->mSize);
+			return (mOwner->mArray[mLoc]);
+		}
+
+		// DeReference Operator
+		//----------------------
+		TTValue*			operator-> ()	const			
+		{
+			assert(mLoc>=0 && mLoc<mOwner->mSize);
+			return (&mOwner->mArray[mLoc]);
+		}
+
+		// Inc Operator
+		//--------------
+		iterator	operator++(int) //postfix
+		{
+			assert(mLoc>=0 && mLoc<mOwner->mSize);
+			iterator old(*this);
+			mLoc ++;
+			return old;
+		}
+
+		// Inc Operator
+		//--------------
+		iterator	operator++()
+		{
+			assert(mLoc>=0 && mLoc<mOwner->mSize);
+			mLoc ++;
+			return *this;
+		}
+
+	};
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Constant Iterator
+    ////////////////////////////////////////////////////////////////////////////////////
+	class const_iterator
+	{
+		friend class vector_base<T>;
+
+		int							mLoc;
+		const vector_base<T>*		mOwner;
+
+	public:
+		// Constructors
+		//--------------
+		const_iterator()							: mOwner(0), mLoc(0)
+		{}
+		const_iterator(const vector_base<T>* p, int t)	: mOwner(p), mLoc(t)
+		{}
+		const_iterator(const const_iterator &t)		: mOwner(t.mOwner), mLoc(t.mLoc)
+		{}
+		const_iterator(const iterator &t)			: mOwner(t.mOwner), mLoc(t.mLoc)
+		{}
+
+		// Assignment Operator
+		//---------------------
+		void		operator= (const const_iterator &t)
+		{
+			mOwner	= t.mOwner;	
+			mLoc	= t.mLoc;
+		}
+		// Assignment Operator
+		//---------------------
+		void		operator= (const iterator &t)
+		{
+			mOwner	= t.mOwner;	
+			mLoc	= t.mLoc;
+		}
+
+
+
+		// Equality Operators
+		//--------------------
+		bool		operator!=(const iterator &t)		const
+		{
+			return (mLoc!=t.mLoc  || mOwner!=t.mOwner);
+		}
+		bool		operator==(const iterator &t)		const				
+		{
+			return (mLoc==t.mLoc && mOwner==t.mOwner);
+		}
+
+		// Equality Operators
+		//--------------------
+		bool		operator!=(const const_iterator &t)		const
+		{
+			return (mLoc!=t.mLoc || mOwner!=t.mOwner);
+		}
+		bool		operator==(const const_iterator &t)		const				
+		{
+			return (mLoc==t.mLoc  && mOwner==t.mOwner);
+		}
+
+		// DeReference Operator
+		//----------------------
+		const TTValue&			operator* ()		const
+		{
+			assert(mLoc>=0 && mLoc<mOwner->mSize);
+			return (mOwner->mArray[mLoc]);
+		}
+
+		// DeReference Operator
+		//----------------------
+		const TTValue&			value()		const
+		{
+			assert(mLoc>=0 && mLoc<mOwner->mSize);
+			return (mOwner->mArray[mLoc]);
+		}
+
+		// DeReference Operator
+		//----------------------
+		const TTValue*			operator-> ()		const
+		{
+			assert(mLoc>=0 && mLoc<mOwner->mSize);
+			return (&mOwner->mArray[mLoc]);
+		}
+
+		// Inc Operator
+		//--------------
+		const_iterator operator++(int)
+		{
+			assert(mLoc>=0 && mLoc<mOwner->mSize);
+			const_iterator old(*this);
+			mLoc ++;
+			return old;
+		}
+
+		// Inc Operator
+		//--------------
+		const_iterator operator++()
+		{
+			assert(mLoc>=0 && mLoc<mOwner->mSize);
+			mLoc ++;
+			return *this;
+		}
+
+
+	};
+	friend class				iterator;
+	friend class				const_iterator;
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Iterator Begin (Starts At Address 0)
+    ////////////////////////////////////////////////////////////////////////////////////
+	iterator	begin()
+	{
+		return iterator(this, 0);
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Iterator End (Set To Address mSize)
+    ////////////////////////////////////////////////////////////////////////////////////
+	iterator	end()
+	{
+		return iterator(this, mSize);
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Iterator Begin (Starts At Address 0)
+    ////////////////////////////////////////////////////////////////////////////////////
+	const_iterator	begin() const
+	{
+		return const_iterator(this, 0);
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Iterator End (Set To Address mSize)
+    ////////////////////////////////////////////////////////////////////////////////////
+	const_iterator	end() const
+	{
+		return const_iterator(this, mSize);
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Iterator Find (If Fails To Find, Returns iterator end()
+	////////////////////////////////////////////////////////////////////////////////////
+	iterator	find(const TTValue& value)
+	{
+		int		index = find_index(value);		// Call Find By Index
+		if (index<mSize)
+		{
+			return iterator(this, index);		// Found It, Return An Iterator To Index
+		}
+		return end();							// Return "end" Iterator If Not Found
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Iterator Find (If Fails To Find, Returns iterator end()
+	////////////////////////////////////////////////////////////////////////////////////
+	const_iterator	find(const TTValue& value) const
+	{
+		int		index = find_index(value);		// Call Find By Index
+		if (index<mSize)
+		{
+			return const_iterator(this, index);		// Found It, Return An Iterator To Index
+		}
+		return end();							// Return "end" Iterator If Not Found
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Erase An Iterator Location... NOTE: THIS DOES NOT PRESERVE ORDER IN THE VECTOR!!
+	////////////////////////////////////////////////////////////////////////////////////
+	iterator erase_swap(const iterator &it)
+	{
+		assert(it.mLoc>=0 && it.mLoc<it.mOwner->mSize);
+		if (it.mLoc != mSize - 1)
+		{
+			mArray.swap(it.mLoc, mSize - 1);
+		}
+		pop_back();
+		return it;
+	}
+	template<class CAST_TO>
+	CAST_TO *verify_alloc(CAST_TO *p) const
+	{
+		return mArray.verify_alloc(p);
+	}
+};
+
+template<class T, int ARG_CAPACITY>
+class vector_vs : public vector_base<storage::value_semantics<T,ARG_CAPACITY> >
+{
+public:
+	typedef typename storage::value_semantics<T,ARG_CAPACITY> TStorageTraits;
+	typedef typename TStorageTraits::TValue TTValue;
+ 	enum 
+	{
+		CAPACITY		= ARG_CAPACITY
+	};
+	vector_vs() {}
+};
+
+template<class T, int ARG_CAPACITY>
+class vector_os : public vector_base<storage::object_semantics<T,ARG_CAPACITY> >
+{
+public:
+	typedef typename storage::object_semantics<T,ARG_CAPACITY> TStorageTraits;
+	typedef typename TStorageTraits::TValue TTValue;
+ 	enum 
+	{
+		CAPACITY		= ARG_CAPACITY
+	};
+	vector_os() {}
+};
+
+template<class T, int ARG_CAPACITY, int ARG_MAX_CLASS_SIZE>
+class vector_is : public vector_base<storage::virtual_semantics<T,ARG_CAPACITY,ARG_MAX_CLASS_SIZE> >
+{
+public:
+	typedef typename storage::virtual_semantics<T,ARG_CAPACITY,ARG_MAX_CLASS_SIZE> TStorageTraits;
+	typedef typename TStorageTraits::TValue TTValue;
+ 	enum 
+	{
+		CAPACITY		= ARG_CAPACITY,
+		MAX_CLASS_SIZE	= ARG_MAX_CLASS_SIZE
+	};
+	vector_is() {}
+};
+
+}
+#endif
diff --git a/code/Ratl/vssver.scc b/code/Ratl/vssver.scc
new file mode 100644
index 0000000..715da81
Binary files /dev/null and b/code/Ratl/vssver.scc differ
diff --git a/code/Ravl/CBounds.cpp b/code/Ravl/CBounds.cpp
new file mode 100644
index 0000000..1f09b20
--- /dev/null
+++ b/code/Ravl/CBounds.cpp
@@ -0,0 +1,366 @@
+////////////////////////////////////////////////////////////////////////////////////////
+// RAVEN STANDARD TEMPLATE LIBRARY
+//  (c) 2002 Activision
+//
+//
+// Vector Library
+// --------------
+//
+//
+//
+//
+// NOTES:
+// 05/31/02 - CREATED
+//
+//
+////////////////////////////////////////////////////////////////////////////////////////
+
+#if !defined(ASSERT_H_INC)
+#include <assert.h>
+#define ASSERT_H_INC
+#endif
+
+#include <math.h>
+#include <stdio.h>
+#include <float.h>
+#include "CBounds.h"
+
+
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+//
+////////////////////////////////////////////////////////////////////////////////////////
+/*void CBBox::ThroughMatrix(const CBBox &from, const CMatrix4 &mat)
+{
+	Clear();
+	CVec3 bb,t;
+	int i;
+	const CVec3 &xmn=from.GetMin();
+	const CVec3 &xmx=from.GetMax();
+	for ( i = 0; i < 8; i++ )
+	{
+		if ( i & 1 )
+			bb[0] = xmn[0];
+		else
+			bb[0] = xmx[0];
+		if ( i & 2 )
+			bb[1] = xmn[1];
+		else
+			bb[1] = xmx[1];
+		if ( i & 4 )
+			bb[2] = xmn[2];
+		else
+			bb[2] = xmx[2];
+		mat.XFormPoint(t,bb);
+		AddPoint(t);
+	}
+}*/
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+//
+////////////////////////////////////////////////////////////////////////////////////////
+float CBBox::LargestAxisSize() const
+{
+	CVec3	Work(mMax);
+	Work-=mMin;
+	return Work.MaxElement();
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+//
+////////////////////////////////////////////////////////////////////////////////////////
+float CBBox::DistanceEstimate(const CVec3 &p) const
+{
+	float ret=0.0f;
+
+	// X Axis
+	//--------
+	if (p[0]>mMax[0])
+	{
+		ret=p[0]-mMax[0];
+	}
+	else if (p[0]<mMin[0])
+	{
+		ret=mMax[0]-p[0];
+	}
+
+	// Y Axis
+	//--------
+	if (p[1]>mMax[1])
+	{
+		ret+=p[1]-mMax[1];
+	}
+	else if (p[1]<mMin[1])
+	{
+		ret+=mMax[1]-p[1];
+	}
+
+	// Z Axis
+	//--------
+	if (p[2]>mMax[2])
+	{
+		ret+=p[2]-mMax[2];
+	}
+	else if (p[2]<mMin[2])
+	{
+		ret+=mMax[2]-p[2];
+	}
+	return ret;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+//
+////////////////////////////////////////////////////////////////////////////////////////
+float CBBox::AreaEstimate(const CVec3 &p) const
+{
+	float Distance=DistanceEstimate(p);
+	if (Distance)
+	{
+		return LargestAxisSize()/Distance;
+	}
+	return 0;
+}
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+//
+////////////////////////////////////////////////////////////////////////////////////////
+void CBBox::Intersect(const CBBox &b2)
+{
+	mMin.Max(b2.mMin);
+	mMax.Min(b2.mMax);
+	Validate();
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+//
+////////////////////////////////////////////////////////////////////////////////////////
+void CBBox::Union(const CBBox &b2)
+{
+	mMin.Min(b2.mMin);
+	mMax.Max(b2.mMax);
+	Validate();
+}
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+//
+////////////////////////////////////////////////////////////////////////////////////////
+ESide CBBox::InOutTest(const CVec3 &v) const
+{
+	if (v>mMin && v<mMax)
+	{
+		return Side_In;
+	}
+	return Side_Out;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+//
+////////////////////////////////////////////////////////////////////////////////////////
+ESide CBBox::InOutTest(const CVec3 &v,float tolout,float tolin) const
+{
+	if (v[0]<mMin[0]-tolout||v[0]>mMax[0]+tolout||
+		v[1]<mMin[1]-tolout||v[1]>mMax[1]+tolout||
+		v[2]<mMin[2]-tolout||v[2]>mMax[2]+tolout)
+	{
+		return Side_Out;
+	}
+	if (v[0]>mMin[0]+tolin&&v[0]<mMax[0]-tolin&&
+		v[1]>mMin[1]+tolin&&v[1]<mMax[1]-tolin&&
+		v[2]>mMin[2]+tolin&&v[2]<mMax[2]-tolin)
+	{
+		return Side_In;
+	}
+	return Side_None;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+//
+////////////////////////////////////////////////////////////////////////////////////////
+bool CBBox::BoxTouchTest(const CBBox &b2,float tolout) const
+{
+	if (mMin[0]-tolout>b2.mMax[0] ||
+		mMin[1]-tolout>b2.mMax[1] ||
+		mMin[2]-tolout>b2.mMax[2] ||
+		b2.mMin[0]-tolout>mMax[0] ||
+		b2.mMin[1]-tolout>mMax[1] ||
+		b2.mMin[2]-tolout>mMax[2])
+	{
+		return false;
+	}
+	return  true;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+//
+////////////////////////////////////////////////////////////////////////////////////////
+bool CBBox::SphereTouchTest(const CVec3 &v,float rad) const
+{
+	if (v[0]<mMin[0]-rad||v[0]>mMax[0]+rad||
+		v[1]<mMin[1]-rad||v[1]>mMax[1]+rad||
+		v[2]<mMin[2]-rad||v[2]>mMax[2]+rad)
+		return false;
+	return true;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+//
+////////////////////////////////////////////////////////////////////////////////////////
+TPlanes CBBox::PlaneFlags(const CVec3 &p)
+{
+	TPlanes ret=0;
+	if (p[0]<mMin[0])
+	{
+		ret|=1;
+	}
+	else if (p[0]>mMax[0])
+	{
+		ret|=2;
+	}
+	if (p[1]<mMin[1])
+	{
+		ret|=4;
+	}
+	else if (p[1]>mMax[1])
+	{
+		ret|=8;
+	}
+	if (p[2]<mMin[2])
+	{
+		ret|=16;
+	}
+	else if (p[2]>mMax[2])
+	{
+		ret|=32;
+	}
+	return ret;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+//
+// return true if the segment intersect the box, in that case, return the first contact.
+////////////////////////////////////////////////////////////////////////////////////////
+bool CBBox::HitTest(CBTrace& Tr) const
+{
+	// Quick Box Cull
+	//----------------
+	CBBox tmp;
+	tmp.AddPoint(Tr.mStart);
+	tmp.AddPoint(Tr.mStop);
+	if (!BoxTouchTest(tmp))
+	{
+		return false;
+	}
+
+
+	// Initialize Our Ranges
+	//-----------------------
+	Tr.mRange		=-1E30f;
+	Tr.mRangeMax	= 1E30f;
+
+
+	// For Each Non Zero Axis Of The Aim Vector
+	//------------------------------------------
+	float tmax,tmin,temp;
+	for (int axis=0; axis<3; axis++)
+	{
+		if (fabs(Tr.mAim[axis])>1E-6f)
+		{
+			// Find Mins And Maxs From The Start Along The Axis Of Aim
+			//---------------------------------------------------------
+			tmax	= ((mMax[axis]-Tr.mStart[axis])/Tr.mAim[axis]);
+			tmin	= ((mMin[axis]-Tr.mStart[axis])/Tr.mAim[axis]);
+			if (tmax<tmin)
+			{
+				temp = tmax;
+				tmax = tmin;
+				tmin = temp;
+			}
+
+			// Adjust Range Max
+			//------------------
+			if (tmax<Tr.mRangeMax)
+			{
+				Tr.mRangeMax=tmax;
+			}
+	
+			// Adjust Range Min
+			//------------------
+			if (tmin>Tr.mRange)
+			{
+				Tr.mRange=tmin;
+				Tr.mNormal.Clear();
+				Tr.mNormal[axis]=-1.0f;
+			}
+		}
+	}
+
+
+	// Missed?
+	//---------
+	if (Tr.mRangeMax<Tr.mRange || Tr.mRangeMax<0.0f || Tr.mRange>Tr.mLength)
+	{
+		return false;
+	}
+
+
+	// Start Solid Conditions
+	//------------------------
+	if (Tr.mRange<0.0f)
+	{
+		Tr.mRange = 0.0f;
+		Tr.mPoint = Tr.mStart;
+		return true;
+	}
+
+
+	// Calculate The End Point
+	//-------------------------
+	Tr.mPoint =  Tr.mAim;
+	Tr.mPoint *= Tr.mRange;
+	Tr.mPoint += Tr.mStart;
+	return true;
+}
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+//
+////////////////////////////////////////////////////////////////////////////////////////
+void CBBox::FromStr(const char *s)
+{
+	assert(s && s[0]);
+
+	char	MinS[256];
+	char	MaxS[266];
+	sscanf(s, "(%s|%s)", MinS, MaxS);
+
+	mMin.FromStr(MinS);
+	mMax.FromStr(MaxS);
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+//
+////////////////////////////////////////////////////////////////////////////////////////
+void CBBox::ToStr(char* s)
+{
+	assert(s && s[0]);
+
+	char	MinS[256];
+	char	MaxS[266];
+
+	mMin.ToStr(MinS);
+	mMax.ToStr(MaxS);
+	sprintf(s, "(%s|%s)", MinS, MaxS);
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+//
+////////////////////////////////////////////////////////////////////////////////////////
+void CBBox::Validate()
+{
+	assert(mMax>=mMin);
+}
+
diff --git a/code/Ravl/CBounds.h b/code/Ravl/CBounds.h
new file mode 100644
index 0000000..1a41435
--- /dev/null
+++ b/code/Ravl/CBounds.h
@@ -0,0 +1,188 @@
+////////////////////////////////////////////////////////////////////////////////////////
+// RAVEN STANDARD TEMPLATE LIBRARY
+//  (c) 2002 Activision
+//
+//
+// Vector Library
+// --------------
+//
+//
+//
+//
+// NOTES:
+// 05/31/02 - CREATED
+//
+//
+////////////////////////////////////////////////////////////////////////////////////////
+#if !defined(RAVL_BOUNDS_INC)
+#define RAVL_BOUNDS_INC
+//namespace ravl
+//{
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Includes
+////////////////////////////////////////////////////////////////////////////////////////
+#include "CVec.h"
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Defines
+////////////////////////////////////////////////////////////////////////////////////////
+#define		RAVL_BB_EMPTY_MIN				( 1.234567E30f)					// Empty Value
+#define		RAVL_BB_EMPTY_MAX				(-1.234567E30f)					// Empty Value
+
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Enums And Typedefs
+////////////////////////////////////////////////////////////////////////////////////////
+typedef		unsigned char					TPlanes;
+
+
+
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// The Bounds Trace
+////////////////////////////////////////////////////////////////////////////////////////
+class CBTrace
+{
+public:
+	CBTrace(const CVec3& Start, const CVec3& Stop) :
+		mStart(Start),
+		mStop(Stop),
+		mAim(Stop),
+		mRange(0),
+		mRangeMax(0),
+		mPoint(Stop)
+	{
+		mAim-=Start;
+		mLength = mAim.Norm();
+	}
+
+	CBTrace& 	operator	=(const CBTrace& T)
+	{
+		mStart = (T.mStart);
+		mStop = (T.mStop);
+		mAim = (T.mAim);
+		mRange = (T.mRange);
+		mRangeMax = (T.mRangeMax);
+		mPoint = (T.mPoint);
+		return (*this);
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Setup Values, Do Not Change
+    ////////////////////////////////////////////////////////////////////////////////////
+public:
+	CVec3			mStart;
+	CVec3			mStop;
+	CVec3			mAim;
+	float			mLength;
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Results
+    ////////////////////////////////////////////////////////////////////////////////////
+public:
+	float			mRange;
+	float			mRangeMax;
+	CVec3			mPoint;
+	CVec3			mNormal;
+};
+
+
+
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// The Bounding Box Class
+////////////////////////////////////////////////////////////////////////////////////////
+class CBBox
+{
+public:
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Constructors
+    ////////////////////////////////////////////////////////////////////////////////////
+	CBBox()																	{mMin.Set(RAVL_BB_EMPTY_MIN);	mMax.Set(RAVL_BB_EMPTY_MAX);}
+	CBBox(float Radius)														{mMin.Set(-Radius);				mMax.Set(Radius);}
+	CBBox(const CVec3& t)													{mMin=t;						mMax=t;}
+	CBBox(const CVec3& min, const CVec3& max)								{mMin=min;						mMax=max;}
+	CBBox(const CBBox& t)													{mMin=t.mMin;					mMax=t.mMax;}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Initializers
+    ////////////////////////////////////////////////////////////////////////////////////
+	void	Set(const CVec3& min, const CVec3& max)							{mMin=min;						mMax=max;		Validate();}
+	void	Clear()															{mMin.Set(RAVL_BB_EMPTY_MIN);	mMax.Set(RAVL_BB_EMPTY_MAX);}
+	void	AddPoint(const CVec3 &p)										{mMin.Min(p);					mMax.Max(p);	Validate();}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Accessors
+    ////////////////////////////////////////////////////////////////////////////////////
+	bool	IsEmpty() const													{return (mMin[0]==RAVL_BB_EMPTY_MIN);}
+	CVec3	Center() const													{return (mMin+mMax)*0.5;}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Translation, Rotation, Expansion
+    ////////////////////////////////////////////////////////////////////////////////////
+	void	Translate(const CVec3 &f)										{mMin+=f; mMax+=f;}
+	void	Expand(float x)													{mMin-=x; mMax+=x;}
+	void	Expand(const CVec3 &f)											{mMin-=f; mMax+=f;}
+//	void	ThroughMatrix(const CBBox &from, const CMatrix4 &mat);
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Volumetric & Area Operations
+    ////////////////////////////////////////////////////////////////////////////////////
+	float	Volume() const													{return (mMax[0]-mMin[0])*(mMax[1]-mMin[1])*(mMax[2]-mMin[2]);}
+	float	AxisSize(int axis) const										{return (mMax[axis]-mMin[axis]);}
+	float	LargestAxisSize() const;
+	float	DistanceEstimate(const CVec3 &p) const;			// Manhattan Distance
+	float	AreaEstimate(const CVec3 &p) const;				// Manhattan Distance * LargestAxisSize()
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Set Operations
+    ////////////////////////////////////////////////////////////////////////////////////
+	void	Intersect(const CBBox &b2);
+	void	Union(const CBBox &b2);
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Tests
+    ////////////////////////////////////////////////////////////////////////////////////
+	ESide	InOutTest(const CVec3 &p) const;
+	ESide	InOutTest(const CVec3 &p, float tolout, float tolin) const;
+	bool	BoxTouchTest(const CBBox &b2, float tolout=0.0f) const;
+	bool	SphereTouchTest(const CVec3 &c, float rad) const;
+	TPlanes PlaneFlags(const CVec3 &p);
+	
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Hit Tests
+    ////////////////////////////////////////////////////////////////////////////////////
+	bool	HitTest(CBTrace& Tr) const;
+	
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// String Operations
+    ////////////////////////////////////////////////////////////////////////////////////
+	void	FromStr(const char *s);
+	void	ToStr(char* s);
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Debug Operations
+    ////////////////////////////////////////////////////////////////////////////////////
+	void	Validate();
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Data
+    ////////////////////////////////////////////////////////////////////////////////////
+public:
+	CVec3	mMin;
+	CVec3	mMax;
+};
+
+//};
+#endif
\ No newline at end of file
diff --git a/code/Ravl/CMatrix.h b/code/Ravl/CMatrix.h
new file mode 100644
index 0000000..f88b617
--- /dev/null
+++ b/code/Ravl/CMatrix.h
@@ -0,0 +1,165 @@
+////////////////////////////////////////////////////////////////////////////////////////
+// RAVEN STANDARD TEMPLATE LIBRARY
+//  (c) 2002 Activision
+//
+//
+// Matrix Library
+// --------------
+//
+//
+//
+// NOTES:
+//
+//
+////////////////////////////////////////////////////////////////////////////////////////
+#if !defined(RAVL_MATRIX_INC)
+#define RAVL_MATRIX_INC
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Includes
+////////////////////////////////////////////////////////////////////////////////////////
+#if defined(RA_DEBUG_LINKING)
+	#pragma message("...including CMatrix.h")
+#endif
+#if !defined(RAVL_VEC_INC)
+	#include "CVec.h"
+#endif
+//namespace ravl
+//{
+
+
+
+
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// The Matrix
+////////////////////////////////////////////////////////////////////////////////////////
+class CMatrix
+{
+public:
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Constructors
+    ////////////////////////////////////////////////////////////////////////////////////
+	CMatrix()																{}
+	CMatrix(const CVec4& x,const CVec4& y,const CVec4& z, const CVec4& w)	{v[0]=x;		v[1]=y;			v[2]=z;			v[3]=w;}
+	CMatrix(const CMatrix& t)												{v[0]=t.v[0];	v[1]=t.v[1];	v[2]=t.v[2];	v[3]=t.v[3];}
+	CMatrix(const float t[16])												{v[0]=t[0];		v[1]=t[4];		v[2]=t[8];		v[3]=t[12];}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Initializers
+    ////////////////////////////////////////////////////////////////////////////////////
+	void Set(const CVec4& x,const CVec4& y,const CVec4& z, const CVec4& w)	{v[0]=x;		v[1]=y;			v[2]=z;			v[3]=w;}
+	void Set(const CMatrix& t)												{v[0]=t.v[0];	v[1]=t.v[1];	v[2]=t.v[2];	v[3]=t.v[3];}
+	void Set(const float t[16])												{v[0]=t[0];		v[1]=t[4];		v[2]=t[8];		v[3]=t[12];}
+
+	void Clear()															{v[0].Set(0,0,0,0);	v[1].Set(0,0,0,0);	v[2].Set(0,0,0,0);	v[3].Set(0,0,0,0);}
+	void Itentity()															{v[0].Set(1,0,0,0);	v[1].Set(0,1,0,0);	v[2].Set(0,0,1,0);	v[3].Set(0,0,0,1);}
+	void Translate(const float x, const float y, const float z)				{v[0].Set(1,0,0,0);	v[1].Set(0,1,0,0);	v[2].Set(0,0,1,0);	v[3].Set(x,y,z,1);}
+	void Scale(const float x, const float y, const float z)					{v[0].Set(x,0,0,0);	v[1].Set(0,y,0,0);	v[2].Set(0,0,z,0);	v[3].Set(0,0,0,1);}
+	void Rotate(int axis, const float s/*sin(angle)*/, const float c/*cos(angle)*/)
+	{
+		switch(axis)
+		{
+		case 0:
+			v[0].Set( 1, 0, 0, 0);
+			v[1].Set( 0, c,-s, 0);
+			v[2].Set( 0, s, c, 0);
+			break;
+		case 1:
+			v[0].Set( c, 0, s, 0);
+			v[1].Set( 0, 1, 0, 0);
+			v[2].Set(-s, 0, c, 0);
+			break;
+		case 2:
+			v[0].Set( c,-s, 0, 0);
+			v[1].Set( s, c, 0, 0);
+			v[2].Set( 0, 0, 1, 0);
+			break;
+		}
+		v[3].Set( 0, 0, 0, 1);
+	}
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Member Accessors
+    ////////////////////////////////////////////////////////////////////////////////////
+	const CVec4& operator[](int i) const 									{return v[i];}
+	CVec4& operator[](int i)												{return v[i];}
+
+	CVec4& up()																{return v[0];}
+	CVec4& left()															{return v[1];}
+	CVec4& fwd()															{return v[2];}
+	CVec4& origin()															{return v[3];}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Equality / Inequality Operators
+    ////////////////////////////////////////////////////////////////////////////////////
+	bool operator== (const CMatrix& t) const								{return	 (v[0]==t.v[0] && v[1]==t.v[1] && v[2]==t.v[2] && v[3]==t.v[3]);}
+	bool operator!= (const CMatrix& t) const								{return !(v[0]==t.v[0] && v[1]==t.v[1] && v[2]==t.v[2] && v[3]==t.v[3]);}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Basic Arithimitic Operators
+    ////////////////////////////////////////////////////////////////////////////////////
+	const CMatrix &operator=  (const CMatrix& t)							{v[0]=t.v[0];	v[1]=t.v[1];	v[2]=t.v[2];	v[3]=t.v[3]; return *this;}
+	const CMatrix &operator+= (const CMatrix& t)							{v[0]+=t.v[0];	v[1]+=t.v[1];	v[2]+=t.v[2];	v[3]+=t.v[3];return *this;}
+	const CMatrix &operator-= (const CMatrix& t)							{v[0]-=t.v[0];	v[1]-=t.v[1];	v[2]-=t.v[2];	v[3]-=t.v[3];return *this;}
+
+	CMatrix		   operator+ (const CMatrix &t) const						{return CMatrix(v[0]+t.v[0], v[1]+t.v[1], v[2]+t.v[2], v[3]+t.v[3]);}
+	CMatrix		   operator- (const CMatrix &t) const						{return CMatrix(v[0]-t.v[0], v[1]-t.v[1], v[2]-t.v[2], v[3]-t.v[3]);}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Matrix Scale
+    ////////////////////////////////////////////////////////////////////////////////////
+	const CMatrix &operator*= (const float d)								{v[0]*=d;		v[1]*=d;		v[2]*=d;		v[3]*=d;	 return *this;}
+
+	
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Matrix To Matrix Multiply
+    ////////////////////////////////////////////////////////////////////////////////////
+	CMatrix		   operator* (const CMatrix &t) const
+	{
+	//	assert(this!=&t);				// Don't Multiply With Self
+
+		CMatrix		Result;				// The Resulting Matrix
+		int			i,j,k;				// Counters
+		float		Accumulator;		// Current Value Of The Dot Product
+		for (i=0; i<4; i++)
+		{
+			for (j=0; j<4; j++)
+			{
+				Accumulator = 0.0f;		// Reset The Accumulator
+				for(k=0; k<4; k++)
+				{
+					Accumulator += v[i][k]*t[k][j];		// Calculate Dot Product Of The Two Vectors
+				}
+				Result[i][j]=Accumulator;	// Place In Result
+			}
+		}
+
+		return Result;
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Vector To Matrix Multiply
+    ////////////////////////////////////////////////////////////////////////////////////
+	CVec4		   operator* (const CVec4 &t)   const
+	{
+		CVec4		Result;
+
+		Result[0] = v[0][0]*t[0] + v[1][0]*t[1] + v[2][0]*t[2] + v[3][0];
+		Result[1] = v[0][1]*t[0] + v[1][1]*t[1] + v[2][1]*t[2] + v[3][1];
+		Result[2] = v[0][2]*t[0] + v[1][2]*t[1] + v[2][2]*t[2] + v[3][2];
+
+		return Result;
+	}
+
+public:
+	CVec4		v[4];
+};
+
+
+
+//}
+#endif
\ No newline at end of file
diff --git a/code/Ravl/CVec.cpp b/code/Ravl/CVec.cpp
new file mode 100644
index 0000000..11612a4
--- /dev/null
+++ b/code/Ravl/CVec.cpp
@@ -0,0 +1,1154 @@
+////////////////////////////////////////////////////////////////////////////////////////
+// RAVEN STANDARD TEMPLATE LIBRARY
+//  (c) 2002 Activision
+//
+//
+// Vector Library
+////////////////////////////////////////////////////////////////////////////////////////
+
+#include <assert.h>
+
+#include <math.h>
+#include <stdio.h>
+#include <float.h>
+#include "CVec.h"
+
+//using namespace ravl;
+
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Static Class Member Initialization
+////////////////////////////////////////////////////////////////////////////////////////
+const CVec4 CVec4::mX(1.f,		0.f,	0.f,	0.f);
+const CVec4 CVec4::mY(0.f,		1.f,	0.f,	0.f);
+const CVec4 CVec4::mZ(0.f,		0.f,	1.f,	0.f);
+const CVec4 CVec4::mW(0.f,		0.f,	0.f,	1.f);
+const CVec4 CVec4::mZero(0.f,	0.f,	0.f,	0.f);
+
+
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Length
+////////////////////////////////////////////////////////////////////////////////////////
+float	CVec4::Len() const
+{
+	return sqrtf(v[0]*v[0]+v[1]*v[1]+v[2]*v[2]+v[3]*v[3]);
+}
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Distance To Other Point
+////////////////////////////////////////////////////////////////////////////////////////
+float	CVec4::Dist(const CVec4& t) const
+{
+	return sqrtf(
+		(t.v[0]-v[0])*(t.v[0]-v[0]) + 
+		(t.v[1]-v[1])*(t.v[1]-v[1]) + 
+		(t.v[2]-v[2])*(t.v[2]-v[2]) + 
+		(t.v[3]-v[3])*(t.v[3]-v[3]));
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Normalize
+////////////////////////////////////////////////////////////////////////////////////////
+float	CVec4::Norm()
+{
+	float	L = Len();
+	(*this)/=L;
+	return L;
+} 
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Safe Normalize
+//  Do Not Normalize If Length Is Too Small
+////////////////////////////////////////////////////////////////////////////////////////
+float	CVec4::SafeNorm()
+{
+	float d=this->Len();
+	if (d>1E-10) 
+	{
+		(*this)/=d;
+		return d;
+	} 
+	(*this)=0.0f; 
+	return 0;
+} 
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Angular Normalize 
+//  All floats Exist(-180, +180)
+////////////////////////////////////////////////////////////////////////////////////////
+void	CVec4::AngleNorm()
+{
+	v[0]= fmodf(v[0],360.0f);
+	if (v[0]<-180.f)	v[0]+=360.0f;
+	if (v[0]>180.f)		v[0]-=360.0f;
+
+	v[1]= fmodf(v[1],360.0f);
+	if (v[1]<-180.f)	v[1]+=360.0f;
+	if (v[1]>180.f)		v[1]-=360.0f;
+
+	v[2]= fmodf(v[2],360.0f);
+	if (v[2]<-180.f)	v[2]+=360.0f;
+	if (v[2]>180.f)		v[2]-=360.0f;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Perpendicular Vector
+//
+// This implimentation is a bit slow, needs some optimization work...
+//
+////////////////////////////////////////////////////////////////////////////////////////
+void	CVec4::Perp()
+{
+	float rlen,tlen;
+	CVec4 r,t;
+	r = (*this);
+	r.Cross(mX);
+	rlen=r.Len();
+	t = (*this);
+	t.Cross(mY);
+	tlen=t.Len();
+	if (tlen>rlen)
+	{
+		r=t;
+		rlen=tlen;
+	}
+	t = (*this);
+	t.Cross(mZ);
+	tlen=t.Len();
+	if (tlen>rlen)
+	{
+		r=t;
+		rlen=tlen;
+	}
+	(*this) = r;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Find Largest Element (Ignores 4th component for now)
+////////////////////////////////////////////////////////////////////////////////////////
+int		CVec4::MaxElementIndex() const
+{
+	if (fabs(v[0])>fabs(v[1]) && fabs(v[0])>fabs(v[2]))
+	{
+		return 0;
+	}
+	if (fabs(v[1])>fabs(v[2]))
+	{
+		return 1;
+	}
+	return 2;	
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Convert To {Pitch, Yaw}   (DEGREES)
+////////////////////////////////////////////////////////////////////////////////////////
+void	CVec4::VecToAng()
+{
+	float	yaw;
+	float	pitch;
+	
+	if (!v[1] && !v[0]) 
+	{
+		yaw		= 0;
+		pitch	= (v[2]>0) ? (90.0f):(270.0f);
+	}
+	else 
+	{
+		// Calculate Yaw
+		//---------------
+		if (v[0]) 
+		{
+			yaw = (RAVL_VEC_RADTODEG(atan2f(v[1], v[0])));
+			if (yaw<0) 
+			{
+				yaw += 360;
+			}
+		}
+		else 
+		{
+			yaw	= (v[1]>0) ? (90.0f):(270.0f);
+		}
+
+		// Calculate Pitch
+		//-----------------
+		float forward	= (sqrtf(v[0]*v[0] + v[1]*v[1]));
+		pitch			= (RAVL_VEC_RADTODEG(atan2f(v[2], forward)));
+		if (pitch<0)
+		{
+			pitch += 360;
+		}
+	}
+
+	// Copy Over Current Vector
+	//--------------------------
+	v[0]	= -pitch;
+	v[1]	= yaw;
+	v[2]	= 0;
+	v[3]	= 0;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Convert From {Picth, Yaw}   (DEGREES)
+////////////////////////////////////////////////////////////////////////////////////////
+void	CVec4::AngToVec()
+{
+	float		angle;
+	float		sp, sy, cp, cy;
+
+	angle	= yaw() * (RAVL_VEC_DEGTORADCONST);
+	sy		= sinf(angle);
+	cy		= cosf(angle);
+	angle	= pitch() * (RAVL_VEC_DEGTORADCONST);
+	sp		= sinf(angle);
+	cp		= cosf(angle);
+
+	v[0] = cp * cy;
+	v[1] = cp * sy;
+	v[2] = -sp;
+	v[3] = 0;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Convert From {Picth, Yaw, Roll}   (DEGREES)
+////////////////////////////////////////////////////////////////////////////////////////
+void	CVec4::AngToVec(CVec4& Right, CVec4& Up)
+{
+	float		angle;
+	float		sr, sp, sy, cr, cp, cy;
+
+	angle	= yaw() * (RAVL_VEC_DEGTORADCONST);
+	sy		= sinf(angle);
+	cy		= cosf(angle);
+	angle	= pitch() * (RAVL_VEC_DEGTORADCONST);
+	sp		= sinf(angle);
+	cp		= cosf(angle);
+	angle	= roll() * (RAVL_VEC_DEGTORADCONST);
+	sr		= sinf(angle);
+	cr		= cosf(angle);
+
+	// Forward Vector Is Stored Here
+	v[0] = cp * cy;
+	v[1] = cp * sy;
+	v[2] = -sp;
+	v[3] = 0;
+
+	// Calculate Right
+	Right.v[0] = (-1 * sr * sp * cy + -1 * cr * -sy);
+	Right.v[1] = (-1 * sr * sp * sy + -1 * cr * cy);
+	Right.v[2] = -1 * sr * cp;
+	Right.v[3] = 0;
+
+	// Calculate Up
+	Up.v[0] = (cr * sp * cy + -sr * -sy);
+	Up.v[1] = (cr * sp * sy + -sr * cy);
+	Up.v[2] = cr * cp;
+	Up.v[3] = 0;
+}
+
+
+
+
+///////////////////////////////////////////////////////////////////////////////////////
+// Convert To {Pitch, Yaw}   (RADIANS)
+////////////////////////////////////////////////////////////////////////////////////////
+void	CVec4::VecToAngRad()
+{
+	float	yaw;
+	float	pitch;
+	
+	if (!v[1] && !v[0]) 
+	{
+		yaw		= 0;
+		pitch	= (v[2]>0) ? (RAVL_VEC_PI*0.5f):(RAVL_VEC_PI*1.5f);
+	}
+	else 
+	{
+		// Calculate Yaw
+		//---------------
+		if (v[0]) 
+		{
+			yaw = (atan2f(v[1], v[0]));
+		}
+		else 
+		{
+			yaw	= (v[1]>0) ? (RAVL_VEC_PI*0.5f):(RAVL_VEC_PI*1.5f);
+		}
+
+		// Calculate Pitch
+		//-----------------
+		float forward	= (sqrtf(v[0]*v[0] + v[1]*v[1]));
+		pitch			= (atan2f(v[2], forward));
+	}
+
+	// Copy Over Current Vector
+	//--------------------------
+	v[0]	= -pitch;
+	v[1]	= yaw;
+	v[2]	= 0;
+	v[3]	= 0;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Convert From {Picth, Yaw}   (RADIANS)
+////////////////////////////////////////////////////////////////////////////////////////
+void	CVec4::AngToVecRad()
+{
+	float		sp, sy, cp, cy;
+
+	sy		= sinf(yaw());
+	cy		= cosf(yaw());
+	sp		= sinf(pitch());
+	cp		= cosf(pitch());
+
+	v[0] = cp * cy;
+	v[1] = cp * sy;
+	v[2] = -sp;
+	v[3] = 0;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Convert From {Picth, Yaw, Roll}   (RADIANS)
+////////////////////////////////////////////////////////////////////////////////////////
+void	CVec4::AngToVecRad(CVec4& Right, CVec4& Up)
+{
+	float		sr, sp, sy, cr, cp, cy;
+
+	sy		= sinf(yaw());
+	cy		= cosf(yaw());
+	sp		= sinf(pitch());
+	cp		= cosf(pitch());
+	sr		= sinf(roll());
+	cr		= cosf(roll());
+
+	// Forward Vector Is Stored Here
+	v[0] = cp * cy;
+	v[1] = cp * sy;
+	v[2] = -sp;
+	v[3] = 0;
+
+	// Calculate Right
+	Right.v[0] = (-1 * sr * sp * cy + -1 * cr * -sy);
+	Right.v[1] = (-1 * sr * sp * sy + -1 * cr * cy);
+	Right.v[2] = -1 * sr * cp;
+	Right.v[3] = 0;
+
+	// Calculate Up
+	Up.v[0] = (cr * sp * cy + -sr * -sy);
+	Up.v[1] = (cr * sp * sy + -sr * cy);
+	Up.v[2] = cr * cp;
+	Up.v[3] = 0;
+}
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Convert To Radians
+////////////////////////////////////////////////////////////////////////////////////////
+void	CVec4::ToRadians()
+{
+	v[0] = RAVL_VEC_DEGTORAD(v[0]);
+	v[1] = RAVL_VEC_DEGTORAD(v[1]);
+	v[2] = RAVL_VEC_DEGTORAD(v[2]);
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Convert To Degrees
+////////////////////////////////////////////////////////////////////////////////////////
+void	CVec4::ToDegrees()
+{
+	v[0] = RAVL_VEC_RADTODEG(v[0]);
+	v[1] = RAVL_VEC_RADTODEG(v[1]);
+	v[2] = RAVL_VEC_RADTODEG(v[2]);
+}
+
+
+
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Copy Values From String
+////////////////////////////////////////////////////////////////////////////////////////
+void	CVec4::FromStr(const char *s)
+{
+//	assert(s && s[0]);
+	sscanf(s, "(%f %f %f %f)", &v[0], &v[1], &v[2], &v[3]);
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Write Values To A String
+////////////////////////////////////////////////////////////////////////////////////////
+void	CVec4::ToStr(char* s) const
+{
+//	assert(s);
+	sprintf(s, "(%3.3f %3.3f %3.3f %3.3f)", v[0], v[1], v[2], v[3]);
+}
+
+
+
+#ifdef _DEBUG
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Make Sure Entire Vector Has Valid Numbers
+////////////////////////////////////////////////////////////////////////////////////////
+bool	CVec4::IsFinite()
+{
+#if defined(_MSC_VER) 
+	return 	(_finite(v[0]) && _finite(v[1]) && _finite(v[2]) && _finite(v[3]));
+#endif
+#if defined(__MWERKS__)
+	//FIXME:  _finite won't compile on the PS2, so commented it out for now, false seemed like the best option
+	return true;
+#endif
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Make Sure Vector Has Been Initialized
+////////////////////////////////////////////////////////////////////////////////////////
+bool	CVec4::IsInitialized()
+{
+	return (v[0]!=RAVL_VEC_UDF && v[1]!=RAVL_VEC_UDF && v[2]!=RAVL_VEC_UDF && v[3]!=RAVL_VEC_UDF);
+}
+
+#endif 
+
+
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Point In Circumscribed Circle  (True/False)
+//
+//  Returns true if the given point is within the circumscribed
+//  circle of the given ABC Triangle:
+//         _____  
+//        /   B \
+//      /   /   \ \
+//     |  /      \ |
+//     |A---------C|
+//      \    Pt   /
+//       \_______/
+//  
+////////////////////////////////////////////////////////////////////////////////////////
+bool	CVec4::PtInCircle(const CVec4 &A, const CVec4 &B, const CVec4 &C) const
+{
+	float  vol;
+	float  ax, ay, az, bx, by, bz, cx, cy, cz, dx, dy, dz;
+	float  bxdx, bydy, bzdz, cxdx, cydy, czdz;
+
+	float  tolerance=0.00000005f;
+
+	ax = A.v[0];
+	ay = A.v[1];
+	az = ax*ax + ay*ay;
+	bx = B.v[0];
+	by = B.v[1];
+	bz = bx*bx + by*by;
+	cx = C.v[0];
+	cy = C.v[1];
+	cz = cx*cx + cy*cy;
+	dx = v[0];
+	dy = v[1];
+	dz = dx*dx + dy*dy;
+
+	bxdx=bx-dx;
+	bydy=by-dy;
+	bzdz=bz-dz;
+	cxdx=cx-dx;
+	cydy=cy-dy;
+	czdz=cz-dz;
+	vol = (az-dz)*(bxdx*cydy-bydy*cxdx) + (ay-dy)*(bzdz*cxdx-bxdx*czdz) + (ax-dx)*(bydy*czdz-bzdz*cydy);
+
+	if      ( vol >    tolerance)  return  true;
+	else if ( vol < -1*tolerance)  return  false;
+	else                           return  false;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Point In Standard Circle  (True/False)
+//
+//  Returns true if the given point is within the Circle
+//         _____  
+//        /     \
+//      /         \
+//     |   Circle  |
+//     |           |
+//      \    Pt   /
+//       \_______/
+//  
+////////////////////////////////////////////////////////////////////////////////////////
+bool	CVec4::PtInCircle(const CVec4 &Circle, float Radius) const
+{
+	return (Dist2(Circle)<(Radius*Radius));
+}
+
+
+
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Line Intersects Circle  (True/False)
+//
+//  r	- Radius Of The Circle
+//  A	- Start Of Line Segment
+//  B	- End Of Line Segment
+//
+//  P	- Projected Position Of Origin Onto Line AB
+//
+//
+//               B
+//             /
+//           /
+//         P
+//       /   \      \
+//     /     this-r->|
+//   /              /
+// A
+//
+////////////////////////////////////////////////////////////////////////////////////////
+bool	CVec4::LineInCircle(const CVec4 &A, const CVec4 &B, float r, CVec4 &P)
+{
+	P = (*this);
+	float	Scale = P.ProjectToLine(A, B);
+
+	// If The Projected Position Is Not On The Line Segment,
+	// Check If It Is Within Radius Of Endpoints A and B.
+	//-------------------------------------------------------
+	if (Scale<0 || Scale>1)
+	{
+		return (PtInCircle(A, r) || PtInCircle(B, r));
+	}
+
+	// Otherwise, Check To See If P Is Within The Radius Of This Circle
+	//------------------------------------------------------------------
+	return (PtInCircle(P, r));
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Same As Test Above, Just Don't Bother Returning P
+////////////////////////////////////////////////////////////////////////////////////////
+bool	CVec4::LineInCircle(const CVec4 &A, const CVec4 &B, float r)
+{
+	CVec4	P(*this);
+	float	Scale = P.ProjectToLine(A, B);
+
+	// If The Projected Position Is Not On The Line Segment,
+	// Check If It Is Within Radius Of Endpoints A and B.
+	//-------------------------------------------------------
+	if (Scale<0 || Scale>1)
+	{
+		return (PtInCircle(A, r) || PtInCircle(B, r));
+	}
+
+	// Otherwise, Check To See If P Is Within The Radius Of This Circle
+	//------------------------------------------------------------------
+	return (PtInCircle(P, r));
+}
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Rotate
+////////////////////////////////////////////////////////////////////////////////////////
+void	CVec4::RotatePoint(const CVec4 &, const CVec4 &)
+{
+	// TO DO: Use Matrix Code To Rotate
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Reposition
+////////////////////////////////////////////////////////////////////////////////////////
+void	CVec4::Reposition(const CVec4 &Translation, float RotationDegrees)
+{
+	// Apply Any Rotation First
+	//--------------------------
+	if (RotationDegrees)
+	{
+		CVec4 Old(*this);
+		float Rotation = RAVL_VEC_DEGTORAD(RotationDegrees);
+		v[0] = Old.v[0]*cosf(Rotation) - Old.v[1]*sinf(Rotation);
+		v[1] = Old.v[0]*sinf(Rotation) + Old.v[1]*cosf(Rotation);
+	}
+
+	// Now Apply Translation
+	//-----------------------
+	(*this) += Translation;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Static Class Member Initialization
+////////////////////////////////////////////////////////////////////////////////////////
+const CVec3 CVec3::mX(1.f,		0.f,	0.f);
+const CVec3 CVec3::mY(0.f,		1.f,	0.f);
+const CVec3 CVec3::mZ(0.f,		0.f,	1.f);
+const CVec3 CVec3::mZero(0.f,	0.f,	0.f);
+
+
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Length
+////////////////////////////////////////////////////////////////////////////////////////
+float	CVec3::Len() const
+{
+	return sqrtf(v[0]*v[0]+v[1]*v[1]+v[2]*v[2]);
+}
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Distance To Other Point
+////////////////////////////////////////////////////////////////////////////////////////
+float	CVec3::Dist(const CVec3& t) const
+{
+	return sqrtf(
+		(t.v[0]-v[0])*(t.v[0]-v[0]) + 
+		(t.v[1]-v[1])*(t.v[1]-v[1]) + 
+		(t.v[2]-v[2])*(t.v[2]-v[2]));
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Normalize
+////////////////////////////////////////////////////////////////////////////////////////
+float	CVec3::Norm()
+{
+	float	L = Len();
+	(*this)/=L;
+	return L;
+} 
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Safe Normalize
+//  Do Not Normalize If Length Is Too Small
+////////////////////////////////////////////////////////////////////////////////////////
+float	CVec3::SafeNorm()
+{
+	float d=this->Len();
+	if (d>1E-10) 
+	{
+		(*this)/=d;
+		return d;
+	} 
+	(*this)=0.0f; 
+	return 0;
+} 
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Angular Normalize 
+//  All floats Exist(-180, +180)
+////////////////////////////////////////////////////////////////////////////////////////
+void	CVec3::AngleNorm()
+{
+	v[0]= fmodf(v[0],360.0f);
+	if (v[0]<-180.f)	v[0]+=360.0f;
+	if (v[0]>180.f)		v[0]-=360.0f;
+
+	v[1]= fmodf(v[1],360.0f);
+	if (v[1]<-180.f)	v[1]+=360.0f;
+	if (v[1]>180.f)		v[1]-=360.0f;
+
+	v[2]= fmodf(v[2],360.0f);
+	if (v[2]<-180.f)	v[2]+=360.0f;
+	if (v[2]>180.f)		v[2]-=360.0f;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Angular Normalize 
+//  All floats Exist(-180, +180)
+////////////////////////////////////////////////////////////////////////////////////////
+float	CVec3::Truncate(float maxlen)
+{
+	float len=this->Len();
+	if (len>maxlen && len>1E-10)
+	{
+		len = maxlen / len;
+		v[0] *= len;
+		v[1] *= len;
+		v[2] *= len;
+
+		return maxlen;
+	}
+	return len;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Perpendicular Vector
+//
+// This implimentation is a bit slow, needs some optimization work...
+//
+////////////////////////////////////////////////////////////////////////////////////////
+void	CVec3::Perp()
+{
+	float rlen,tlen;
+	CVec3 r,t;
+	r = (*this);
+	r.Cross(mX);
+	rlen=r.Len();
+	t = (*this);
+	t.Cross(mY);
+	tlen=t.Len();
+	if (tlen>rlen)
+	{
+		r=t;
+		rlen=tlen;
+	}
+	t = (*this);
+	t.Cross(mZ);
+	tlen=t.Len();
+	if (tlen>rlen)
+	{
+		r=t;
+		rlen=tlen;
+	}
+	(*this) = r;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Find Largest Element (Ignores 4th component for now)
+////////////////////////////////////////////////////////////////////////////////////////
+int		CVec3::MaxElementIndex() const
+{
+	if (fabs(v[0])>fabs(v[1]) && fabs(v[0])>fabs(v[2]))
+	{
+		return 0;
+	}
+	if (fabs(v[1])>fabs(v[2]))
+	{
+		return 1;
+	}
+	return 2;	
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Convert To {Pitch, Yaw}   (DEGREES)
+////////////////////////////////////////////////////////////////////////////////////////
+void	CVec3::VecToAng()
+{
+	float	yaw;
+	float	pitch;
+	
+	if (!v[1] && !v[0]) 
+	{
+		yaw		= 0;
+		pitch	= (v[2]>0) ? (90.0f):(270.0f);
+	}
+	else 
+	{
+		// Calculate Yaw
+		//---------------
+		if (v[0]) 
+		{
+			yaw = (RAVL_VEC_RADTODEG(atan2f(v[1], v[0])));
+			if (yaw<0) 
+			{
+				yaw += 360;
+			}
+		}
+		else 
+		{
+			yaw	= (v[1]>0) ? (90.0f):(270.0f);
+		}
+
+		// Calculate Pitch
+		//-----------------
+		float forward	= (sqrtf(v[0]*v[0] + v[1]*v[1]));
+		pitch			= (RAVL_VEC_RADTODEG(atan2f(v[2], forward)));
+		if (pitch<0)
+		{
+			pitch += 360;
+		}
+	}
+
+	// Copy Over Current Vector
+	//--------------------------
+	v[0]	= -pitch;
+	v[1]	= yaw;
+	v[2]	= 0;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Convert From {Picth, Yaw}   (DEGREES)
+////////////////////////////////////////////////////////////////////////////////////////
+void	CVec3::AngToVec()
+{
+	float		angle;
+	float		sp, sy, cp, cy;
+
+	angle	= yaw() * (RAVL_VEC_DEGTORADCONST);
+	sy		= sinf(angle);
+	cy		= cosf(angle);
+	angle	= pitch() * (RAVL_VEC_DEGTORADCONST);
+	sp		= sinf(angle);
+	cp		= cosf(angle);
+
+	v[0] = cp * cy;
+	v[1] = cp * sy;
+	v[2] = -sp;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Convert From {Picth, Yaw, Roll}   (DEGREES)
+////////////////////////////////////////////////////////////////////////////////////////
+void	CVec3::AngToVec(CVec3& Right, CVec3& Up)
+{
+	float		angle;
+	float		sr, sp, sy, cr, cp, cy;
+
+	angle	= yaw() * (RAVL_VEC_DEGTORADCONST);
+	sy		= sinf(angle);
+	cy		= cosf(angle);
+	angle	= pitch() * (RAVL_VEC_DEGTORADCONST);
+	sp		= sinf(angle);
+	cp		= cosf(angle);
+	angle	= roll() * (RAVL_VEC_DEGTORADCONST);
+	sr		= sinf(angle);
+	cr		= cosf(angle);
+
+	// Forward Vector Is Stored Here
+	v[0] = cp * cy;
+	v[1] = cp * sy;
+	v[2] = -sp;
+
+	// Calculate Right
+	Right.v[0] = (-1 * sr * sp * cy + -1 * cr * -sy);
+	Right.v[1] = (-1 * sr * sp * sy + -1 * cr * cy);
+	Right.v[2] = -1 * sr * cp;
+
+	// Calculate Up
+	Up.v[0] = (cr * sp * cy + -sr * -sy);
+	Up.v[1] = (cr * sp * sy + -sr * cy);
+	Up.v[2] = cr * cp;
+}
+
+
+
+
+///////////////////////////////////////////////////////////////////////////////////////
+// Convert To {Pitch, Yaw}   (RADIANS)
+////////////////////////////////////////////////////////////////////////////////////////
+void	CVec3::VecToAngRad()
+{
+	float	yaw;
+	float	pitch;
+	
+	if (!v[1] && !v[0]) 
+	{
+		yaw		= 0;
+		pitch	= (v[2]>0) ? (RAVL_VEC_PI*0.5f):(RAVL_VEC_PI*1.5f);
+	}
+	else 
+	{
+		// Calculate Yaw
+		//---------------
+		if (v[0]) 
+		{
+			yaw = (atan2f(v[1], v[0]));
+		}
+		else 
+		{
+			yaw	= (v[1]>0) ? (RAVL_VEC_PI*0.5f):(RAVL_VEC_PI*1.5f);
+		}
+
+		// Calculate Pitch
+		//-----------------
+		float forward	= (sqrtf(v[0]*v[0] + v[1]*v[1]));
+		pitch			= (atan2f(v[2], forward));
+	}
+
+	// Copy Over Current Vector
+	//--------------------------
+	v[0]	= -pitch;
+	v[1]	= yaw;
+	v[2]	= 0;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Convert From {Picth, Yaw}   (RADIANS)
+////////////////////////////////////////////////////////////////////////////////////////
+void	CVec3::AngToVecRad()
+{
+	float		sp, sy, cp, cy;
+
+	sy		= sinf(yaw());
+	cy		= cosf(yaw());
+	sp		= sinf(pitch());
+	cp		= cosf(pitch());
+
+	v[0] = cp * cy;
+	v[1] = cp * sy;
+	v[2] = -sp;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Convert From {Picth, Yaw, Roll}   (RADIANS)
+////////////////////////////////////////////////////////////////////////////////////////
+void	CVec3::AngToVecRad(CVec3& Right, CVec3& Up)
+{
+	float		sr, sp, sy, cr, cp, cy;
+
+	sy		= sinf(yaw());
+	cy		= cosf(yaw());
+	sp		= sinf(pitch());
+	cp		= cosf(pitch());
+	sr		= sinf(roll());
+	cr		= cosf(roll());
+
+	// Forward Vector Is Stored Here
+	v[0] = cp * cy;
+	v[1] = cp * sy;
+	v[2] = -sp;
+
+	// Calculate Right
+	Right.v[0] = (-1 * sr * sp * cy + -1 * cr * -sy);
+	Right.v[1] = (-1 * sr * sp * sy + -1 * cr * cy);
+	Right.v[2] = -1 * sr * cp;
+
+	// Calculate Up
+	Up.v[0] = (cr * sp * cy + -sr * -sy);
+	Up.v[1] = (cr * sp * sy + -sr * cy);
+	Up.v[2] = cr * cp;
+}
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Convert To Radians
+////////////////////////////////////////////////////////////////////////////////////////
+void	CVec3::ToRadians()
+{
+	v[0] = RAVL_VEC_DEGTORAD(v[0]);
+	v[1] = RAVL_VEC_DEGTORAD(v[1]);
+	v[2] = RAVL_VEC_DEGTORAD(v[2]);
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Convert To Degrees
+////////////////////////////////////////////////////////////////////////////////////////
+void	CVec3::ToDegrees()
+{
+	v[0] = RAVL_VEC_RADTODEG(v[0]);
+	v[1] = RAVL_VEC_RADTODEG(v[1]);
+	v[2] = RAVL_VEC_RADTODEG(v[2]);
+}
+
+
+
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Copy Values From String
+////////////////////////////////////////////////////////////////////////////////////////
+void	CVec3::FromStr(const char *s)
+{
+	assert(s && s[0]);
+	sscanf(s, "(%f %f %f)", &v[0], &v[1], &v[2]);
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Write Values To A String
+////////////////////////////////////////////////////////////////////////////////////////
+void	CVec3::ToStr(char* s) const
+{
+	assert(s);
+	sprintf(s, "(%3.3f %3.3f %3.3f)", v[0], v[1], v[2]);
+}
+
+
+
+#ifdef _DEBUG
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Make Sure Entire Vector Has Valid Numbers
+////////////////////////////////////////////////////////////////////////////////////////
+bool	CVec3::IsFinite()
+{
+#if defined(_MSC_VER) 
+		return 	(_finite(v[0]) && _finite(v[1]) && _finite(v[2]));
+#endif
+#if defined(__MWERKS__)
+	//FIXME:  _finite won't compile on the PS2, so commented it out for now, false seemed like the best option
+	return 	true;
+#endif
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Make Sure Vector Has Been Initialized
+////////////////////////////////////////////////////////////////////////////////////////
+bool	CVec3::IsInitialized()
+{
+	return (v[0]!=RAVL_VEC_UDF && v[1]!=RAVL_VEC_UDF && v[2]!=RAVL_VEC_UDF);
+}
+
+#endif 
+
+
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Point In Circumscribed Circle  (True/False)
+//
+//  Returns true if the given point is within the circumscribed
+//  circle of the given ABC Triangle:
+//         _____  
+//        /   B \
+//      /   /   \ \
+//     |  /      \ |
+//     |A---------C|
+//      \    Pt   /
+//       \_______/
+//  
+////////////////////////////////////////////////////////////////////////////////////////
+bool	CVec3::PtInCircle(const CVec3 &A, const CVec3 &B, const CVec3 &C) const
+{
+	float  vol;
+	float  ax, ay, az, bx, by, bz, cx, cy, cz, dx, dy, dz;
+	float  bxdx, bydy, bzdz, cxdx, cydy, czdz;
+
+	float  tolerance=0.00000005f;
+
+	ax = A.v[0];
+	ay = A.v[1];
+	az = ax*ax + ay*ay;
+	bx = B.v[0];
+	by = B.v[1];
+	bz = bx*bx + by*by;
+	cx = C.v[0];
+	cy = C.v[1];
+	cz = cx*cx + cy*cy;
+	dx = v[0];
+	dy = v[1];
+	dz = dx*dx + dy*dy;
+
+	bxdx=bx-dx;
+	bydy=by-dy;
+	bzdz=bz-dz;
+	cxdx=cx-dx;
+	cydy=cy-dy;
+	czdz=cz-dz;
+	vol = (az-dz)*(bxdx*cydy-bydy*cxdx) + (ay-dy)*(bzdz*cxdx-bxdx*czdz) + (ax-dx)*(bydy*czdz-bzdz*cydy);
+
+	if      ( vol >    tolerance)  return  true;
+	else if ( vol < -1*tolerance)  return  false;
+	else                           return  false;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Point In Standard Circle  (True/False)
+//
+//  Returns true if the given point is within the Circle
+//         _____  
+//        /     \
+//      /         \
+//     |   Circle  |
+//     |           |
+//      \    Pt   /
+//       \_______/
+//  
+////////////////////////////////////////////////////////////////////////////////////////
+bool	CVec3::PtInCircle(const CVec3 &Circle, float Radius) const
+{
+	return (Dist2(Circle)<(Radius*Radius));
+}
+
+
+
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Line Intersects Circle  (True/False)
+//
+//  r	- Radius Of The Circle
+//  A	- Start Of Line Segment
+//  B	- End Of Line Segment
+//
+//  P	- Projected Position Of Origin Onto Line AB
+//
+//
+//               B
+//             /
+//           /
+//         P
+//       /   \      \
+//     /     this-r->|
+//   /              /
+// A
+//
+////////////////////////////////////////////////////////////////////////////////////////
+bool	CVec3::LineInCircle(const CVec3 &A, const CVec3 &B, float r, CVec3 &P)
+{
+	P = (*this);
+	float	Scale = P.ProjectToLine(A, B);
+
+	// If The Projected Position Is Not On The Line Segment,
+	// Check If It Is Within Radius Of Endpoints A and B.
+	//-------------------------------------------------------
+	if (Scale<0 || Scale>1)
+	{
+		return (PtInCircle(A, r) || PtInCircle(B, r));
+	}
+
+	// Otherwise, Check To See If P Is Within The Radius Of This Circle
+	//------------------------------------------------------------------
+	return (PtInCircle(P, r));
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Same As Test Above, Just Don't Bother Returning P
+////////////////////////////////////////////////////////////////////////////////////////
+bool	CVec3::LineInCircle(const CVec3 &A, const CVec3 &B, float r)
+{
+	CVec3	P(*this);
+	float	Scale = P.ProjectToLine(A, B);
+
+	// If The Projected Position Is Not On The Line Segment,
+	// Check If It Is Within Radius Of Endpoints A and B.
+	//-------------------------------------------------------
+	if (Scale<0 || Scale>1)
+	{
+		return (PtInCircle(A, r) || PtInCircle(B, r));
+	}
+
+	// Otherwise, Check To See If P Is Within The Radius Of This Circle
+	//------------------------------------------------------------------
+	return (PtInCircle(P, r));
+}
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Rotate
+////////////////////////////////////////////////////////////////////////////////////////
+void	CVec3::RotatePoint(const CVec3 &, const CVec3 &)
+{
+	// TO DO: Use Matrix Code To Rotate
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Reposition
+////////////////////////////////////////////////////////////////////////////////////////
+void	CVec3::Reposition(const CVec3 &Translation, float RotationDegrees)
+{
+	// Apply Any Rotation First
+	//--------------------------
+	if (RotationDegrees)
+	{
+		CVec3 Old(*this);
+		float Rotation = RAVL_VEC_DEGTORAD(RotationDegrees);
+		v[0] = Old.v[0]*cosf(Rotation) - Old.v[1]*sinf(Rotation);
+		v[1] = Old.v[0]*sinf(Rotation) + Old.v[1]*cosf(Rotation);
+	}
+
+	// Now Apply Translation
+	//-----------------------
+	(*this) += Translation;
+}
+
diff --git a/code/Ravl/CVec.h b/code/Ravl/CVec.h
new file mode 100644
index 0000000..4deb525
--- /dev/null
+++ b/code/Ravl/CVec.h
@@ -0,0 +1,1002 @@
+////////////////////////////////////////////////////////////////////////////////////////
+// RAVEN STANDARD TEMPLATE LIBRARY
+//  (c) 2002 Activision
+//
+//
+// Vector Library
+// --------------
+// The base implimention of the Raven Vector object attempts to solve a number of
+// high level problems as efficiently as possible.  Where ever feasible, functions have
+// been included in the .h file so the compiler can inline them.
+// 
+// The vectors define the following operations:
+//  - Construction
+//  - Initialization
+//  - Member Access
+//  - Equality / Inequality Operators
+//  - Arithimitic Operators
+//  - Length & Distance
+//  - Normalization (Standard, Safe, Angular)
+//  - Dot & Cross Product
+//  - Perpendicular Vector
+//  - Truncation
+//  - Min & Max Element Analisis
+//  - Interpolation
+//  - Angle / Vector Conversion
+//  - Translation & Rotation
+//  - Point and Line Intersection Tests
+//  - Left / Right Line Test
+//  - String Operations
+//  - Debug Routines
+//  - "Standard" Vectors As Static Memebers
+//
+// As necessary, some projects may #define special faster versions of these routines to
+// make better use of native hardware / software implimentations.
+//
+//
+//
+//
+// NOTES:
+// 05/29/02 - CREATED
+// 05/30/02 - RotatePoint() is currently unimplimented.  Waiting for Matrix Library
+//
+//
+////////////////////////////////////////////////////////////////////////////////////////
+#if !defined(RAVL_VEC_INC)
+#define RAVL_VEC_INC
+//namespace ravl
+//{
+
+
+template <class T> T	Min(const T& a, const T& b)	{return (a<b)?(a):(b);}
+template <class T> T	Max(const T& a, const T& b)	{return (b<a)?(a):(b);}
+
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Defines
+////////////////////////////////////////////////////////////////////////////////////////
+#define		RAVL_VEC_UDF					(1.234567E-10f)						// Undefined Vector Value (for debugging)
+#define		RAVL_VEC_PI						(3.1415926535f)						// Pi
+#define		RAVL_VEC_DEGTORADCONST			(0.0174532925f)						// (RAVL_VEC_PI / 180.0f)
+#define		RAVL_VEC_RADTODEGCONST			(57.295779514f)						// (180.0f / RAVL_VEC_PI)
+#define		RAVL_VEC_DEGTORAD( a )			( (a) * RAVL_VEC_DEGTORADCONST )	// Quick Macro For Degrees -> Radians
+#define		RAVL_VEC_RADTODEG( a )			( (a) * RAVL_VEC_RADTODEGCONST )	// Quick Macro For Radians -> Degrees
+
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Enums And Typedefs
+////////////////////////////////////////////////////////////////////////////////////////
+enum	ESide
+{
+	Side_None	= 0,
+	Side_Left	= 1,
+	Side_Right	= 2,
+	Side_In		= 3, 
+	Side_Out	= 4,
+	Side_AllIn	= 5
+};
+
+
+
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// The 4 Dimensional Vector
+////////////////////////////////////////////////////////////////////////////////////////
+class CVec4
+{
+public:
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Constructors
+    ////////////////////////////////////////////////////////////////////////////////////
+#ifndef _DEBUG
+	CVec4()																	{}
+#else
+	CVec4()																	{v[0]=v[1]=v[2]=v[3]=RAVL_VEC_UDF;}		// DEBUG INITIALIZATION
+#endif	
+	CVec4(const float val)													{v[0]=val;		v[1]=val;		v[2]=val;		v[3]=val;}
+	CVec4(const float x,const float y,const float z, const float r)			{v[0]=x;		v[1]=y;			v[2]=z;			v[3]=r;}
+	CVec4(const CVec4& t)													{v[0]=t.v[0];	v[1]=t.v[1];	v[2]=t.v[2];	v[3]=t.v[3];}
+	CVec4(const float *t)													{v[0]=t[0];		v[1]=t[1];		v[2]=t[2];		v[3]=t[3];}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Initializers
+    ////////////////////////////////////////////////////////////////////////////////////
+	void Set(const float t)													{v[0]=t;		v[1]=t;			v[2]=t;			v[3]=t;}
+	void Set(const float *t)												{v[0]=t[0];		v[1]=t[1];		v[2]=t[2];		v[3]=t[3];}
+	void Set(const float x,const float y,const float z, const float r)		{v[0]=x;		v[1]=y;			v[2]=z;			v[3]=r;}
+	void Clear()															{v[0]=0;		v[1]=0;			v[2]=0;			v[3]=0;}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Member Accessors
+    ////////////////////////////////////////////////////////////////////////////////////
+	const float& operator[](int i) const 									{return v[i];}
+	float& operator[](int i)												{return v[i];}
+	float& pitch()															{return v[0];}
+	float& yaw()															{return v[1];}
+	float& roll()															{return v[2];}
+	float& radius()															{return v[3];}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Equality / Inequality Operators
+    ////////////////////////////////////////////////////////////////////////////////////
+	bool operator!  () const												{return	!(v[0]         && v[1]         && v[2]         && v[3]        );}
+	bool operator== (const CVec4& t) const									{return	 (v[0]==t.v[0] && v[1]==t.v[1] && v[2]==t.v[2] && v[3]==t.v[3]);}
+	bool operator!= (const CVec4& t) const									{return !(v[0]==t.v[0] && v[1]==t.v[1] && v[2]==t.v[2] && v[3]==t.v[3]);}
+	bool operator<  (const CVec4& t) const									{return	 (v[0]< t.v[0] && v[1]< t.v[1] && v[2]< t.v[2] && v[3]< t.v[3]);}
+	bool operator>  (const CVec4& t) const									{return	 (v[0]> t.v[0] && v[1]> t.v[1] && v[2]> t.v[2] && v[3]> t.v[3]);}
+	bool operator<= (const CVec4& t) const									{return	 (v[0]<=t.v[0] && v[1]<=t.v[1] && v[2]<=t.v[2] && v[3]<=t.v[3]);}
+	bool operator>= (const CVec4& t) const									{return	 (v[0]>=t.v[0] && v[1]>=t.v[1] && v[2]>=t.v[2] && v[3]>=t.v[3]);}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Basic Arithimitic Operators
+    ////////////////////////////////////////////////////////////////////////////////////
+	const CVec4 &operator=  (const float d)									{v[0]=d;		v[1]=d;			v[2]=d;			v[3]=d;		 return *this;}
+	const CVec4 &operator=  (const CVec4& t)								{v[0]=t.v[0];	v[1]=t.v[1];	v[2]=t.v[2];	v[3]=t.v[3]; return *this;}
+
+	const CVec4 &operator+= (const float d)									{v[0]+=d;		v[1]+=d;		v[2]+=d;		v[3]+=d;	 return *this;}
+	const CVec4 &operator+= (const CVec4& t)								{v[0]+=t.v[0];	v[1]+=t.v[1];	v[2]+=t.v[2];	v[3]+=t.v[3];return *this;}
+
+	const CVec4 &operator-= (const float d)									{v[0]-=d;		v[1]-=d;		v[2]-=d; 		v[3]-=d;	 return *this;}
+	const CVec4 &operator-= (const CVec4& t)								{v[0]-=t.v[0];	v[1]-=t.v[1];	v[2]-=t.v[2];	v[3]-=t.v[3];return *this;}
+
+	const CVec4 &operator*= (const float d)									{v[0]*=d;		v[1]*=d;		v[2]*=d;		v[3]*=d;	 return *this;}
+	const CVec4 &operator*= (const CVec4& t)								{v[0]*=t.v[0];	v[1]*=t.v[1];	v[2]*=t.v[2];	v[3]*=t.v[3];return *this;}
+
+	const CVec4 &operator/= (const float d)									{v[0]/=d;		v[1]/=d;		v[2]/=d;		v[3]/=d;	 return *this;}
+	const CVec4 &operator/= (const CVec4& t)								{v[0]/=t.v[0];	v[1]/=t.v[1];	v[2]/=t.v[2];	v[3]/=t.v[3];return *this;}
+
+	inline CVec4 operator+ (const CVec4 &t) const							{return CVec4(v[0]+t.v[0], v[1]+t.v[1], v[2]+t.v[2], v[3]+t.v[3]);}
+	inline CVec4 operator- (const CVec4 &t) const							{return CVec4(v[0]-t.v[0], v[1]-t.v[1], v[2]-t.v[2], v[3]-t.v[3]);}
+	inline CVec4 operator* (const CVec4 &t) const							{return CVec4(v[0]*t.v[0], v[1]*t.v[1], v[2]*t.v[2], v[3]*t.v[3]);}
+	inline CVec4 operator/ (const CVec4 &t) const							{return CVec4(v[0]/t.v[0], v[1]/t.v[1], v[2]/t.v[2], v[3]/t.v[3]);}
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Length And Distance Calculations
+    ////////////////////////////////////////////////////////////////////////////////////
+	float	Len() const;
+	float	Len2() const													{return (v[0]*v[0]+v[1]*v[1]+v[2]*v[2]+v[3]*v[3]);}
+
+	float	Dist(const CVec4& t) const;
+	float	Dist2(const CVec4& t) const										{return ((t.v[0]-v[0])*(t.v[0]-v[0]) + (t.v[1]-v[1])*(t.v[1]-v[1]) + (t.v[2]-v[2])*(t.v[2]-v[2]) + (t.v[3]-v[3])*(t.v[3]-v[3]) );}
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Normalization
+    ////////////////////////////////////////////////////////////////////////////////////
+	float	Norm();
+	float	SafeNorm();
+	void	AngleNorm();
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Dot, Cross & Perpendicular Vector
+    ////////////////////////////////////////////////////////////////////////////////////
+	float	Dot(const CVec4& t) const										{return (v[0]*t.v[0] + v[1]*t.v[1] + v[2]*t.v[2] + v[3]*t.v[3]);}
+	void	Cross(const CVec4& t)
+	{
+		CVec4 temp(*this);
+		v[0] = (temp.v[1]*t.v[2]) - (temp.v[2]*t.v[1]);
+		v[1] = (temp.v[2]*t.v[0]) - (temp.v[0]*t.v[2]);
+		v[2] = (temp.v[0]*t.v[1]) - (temp.v[1]*t.v[0]);
+		v[3] = 0;
+	}
+	void	Perp();
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Truncation & Element Analysis
+    ////////////////////////////////////////////////////////////////////////////////////
+	void	Min(const CVec4& t)
+	{
+		if (t.v[0]<v[0])			v[0]=t.v[0];	
+		if (t.v[1]<v[1])			v[1]=t.v[1];	
+		if (t.v[2]<v[2])			v[2]=t.v[2];	
+		if (t.v[3]<v[3])			v[3]=t.v[3];	
+	}
+	void	Max(const CVec4& t)
+	{
+		if (t.v[0]>v[0])			v[0]=t.v[0];	
+		if (t.v[1]>v[1])			v[1]=t.v[1];	
+		if (t.v[2]>v[2])			v[2]=t.v[2];	
+		if (t.v[3]>v[3])			v[3]=t.v[3];	
+	}
+	float	MaxElement() const
+	{
+			return v[MaxElementIndex()];	
+	}
+	int		MaxElementIndex() const;
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Interpolation
+    ////////////////////////////////////////////////////////////////////////////////////
+	void	Interp(const CVec4 &v1, const CVec4 &v2, const float t)
+	{
+		(*this)=v1;
+		(*this)-=v2;
+		(*this)*=t;
+		(*this)+=v2;
+	}
+	void	ScaleAdd(const CVec4& t, const float scale)
+	{
+		v[0] += (scale * t.v[0]);
+		v[1] += (scale * t.v[1]);
+		v[2] += (scale * t.v[2]);
+		v[3] += (scale * t.v[3]);
+	}
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Conversion Angle To Vector (Angle In Degrees)
+    ////////////////////////////////////////////////////////////////////////////////////
+	void	VecToAng();
+	void	AngToVec();
+	void	AngToVec(CVec4& Right, CVec4& Up);
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Conversion Angle To Vector (Angle In Radians)
+    ////////////////////////////////////////////////////////////////////////////////////
+	void	VecToAngRad();
+	void	AngToVecRad();
+	void	AngToVecRad(CVec4& Right, CVec4& Up);
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Conversion Between Radians And Degrees
+    ////////////////////////////////////////////////////////////////////////////////////
+	void	ToRadians();
+	void	ToDegrees();
+
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Project
+	//
+	// Standard projection function.  Take the (this) and project it onto the vector
+	// (U).  Imagine drawing a line perpendicular to U from the endpoint of the (this)
+	// Vector.  That then becomes the new vector.
+	//
+	// The value returned is the scale of the new vector with respect to the one passed
+	// to the function.  If the scale is less than (1.0) then the new vector is shorter 
+	// than (U).  If the scale is negative, then the vector is going in the opposite 
+	// direction of (U).
+	//
+	//               _  (U)
+	//               /|
+	//             /                                        _ (this)
+	//           /                      RESULTS->           /|
+	//         /                                          /
+	//       /    __\ (this)                            /
+	//     /___---  /                                 /
+	//
+    ////////////////////////////////////////////////////////////////////////////////////
+	float	Project(const CVec4 &U)
+	{
+		float	Scale = (Dot(U) / U.Len2());	// Find the scale of this vector on U
+		(*this)=U;								// Copy U onto this vector
+		(*this)*=Scale;							// Use the previously calculated scale to get the right length.
+		return Scale;
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Project To Line
+	//
+	// This function takes two other points in space as the start and end of a line
+	// segment and projects the (this) point onto the line defined by (Start)->(Stop)
+	//
+	// RETURN VALUES:
+	//   (-INF, 0.0)  : (this) landed on the line before (Start)
+	//   (0.0, 1.0)   : (this) landed in the line segment between (Start) and (Stop)
+	//   (1.0, INF)   : (this) landed on the line beyond (End)
+	//
+	//             (Stop)
+	//               /
+	//             /
+	//           o _
+	//         /  |\
+	//       /     (this)
+	//     / 
+	// (Start)
+	//
+    ////////////////////////////////////////////////////////////////////////////////////
+	float	ProjectToLine(const CVec4 &Start, const CVec4 &Stop)
+	{
+		(*this) -= Start;
+		float	Scale = Project(Stop - Start);
+		(*this) += Start;
+		return Scale;
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+    // Project To Line Seg 
+	//
+	// Same As Project To Line, Except It Will Clamp To Start And Stop
+	////////////////////////////////////////////////////////////////////////////////////
+	float	ProjectToLineSeg(const CVec4 &Start, const CVec4 &Stop)
+	{
+		float Scale = ProjectToLine(Start, Stop);
+		if (Scale<0.0f)
+		{
+			(*this) = Start;
+		}
+		else if (Scale>1.0f)
+		{
+			(*this) = Stop;
+		}
+		return Scale;
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Distance To Line
+	//
+	// Uses project to line and than calculates distance to the new point
+	////////////////////////////////////////////////////////////////////////////////////
+	float	DistToLine(const CVec4 &Start, const CVec4 &Stop) const
+	{
+		CVec4	P(*this);
+		P.ProjectToLineSeg(Start, Stop);
+
+		return Dist(P);
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Distance To Line
+	//
+	// Uses project to line and than calculates distance to the new point
+	////////////////////////////////////////////////////////////////////////////////////
+	float	DistToLine2(const CVec4 &Start, const CVec4 &Stop) const
+	{
+		CVec4	P(*this);
+		P.ProjectToLineSeg(Start, Stop);
+
+		return Dist2(P);
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Translation & Rotation (2D)
+    ////////////////////////////////////////////////////////////////////////////////////
+	void	RotatePoint(const CVec4 &Angle, const CVec4 &Origin);
+	void	Reposition(const CVec4 &Translation, float RotationDegrees=0.0);
+
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Area Of The Parallel Pipid (2D)
+	//
+	// Given two more points, this function calculates the area of the parallel pipid
+	// formed.
+	//
+	// Note: This function CAN return a negative "area" if (this) is above or right of
+	// (A) and (B)...  We do not take the abs because the sign of the "area" is needed
+	// for the left right test (see below)
+	//
+	//
+	//               ___---( ... )
+	//        (A)---/        /
+	//        /             /
+	//       /             /
+	//      /             /
+	//     /      ___---(B)
+	//  (this)---/
+	//
+    ////////////////////////////////////////////////////////////////////////////////////
+	float	AreaParallelPipid(const CVec4 &A, const CVec4 &B) const
+	{
+		return ((A.v[0]*B.v[1] - A.v[1]*B.v[0]) + 
+			    (B.v[0]*  v[1] -   v[0]*B.v[1]) + 
+				(  v[0]*A.v[1] - A.v[0]*  v[1]));
+	}
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Area Of The Triangle (2D)
+	//
+	// Given two more points, this function calculates the area of the triangle formed.
+	//
+	//        (A)
+	//        /  \__
+	//       /      \__
+	//      /          \_
+	//     /      ___---(B)
+	//  (this)---/
+	//
+    ////////////////////////////////////////////////////////////////////////////////////
+	float	AreaTriange(const CVec4 &A, const CVec4 &B) const
+	{
+		return (AreaParallelPipid(A, B) * 0.5f);
+	}
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// The Left Right Test (2D)
+	//
+	// Given a line segment (Start->End) and a tolerance for *right on*, this function
+	// evaluates which side the point is of the line.  (Side_Left in this example)
+	//
+	//
+	//
+	//          (this)        ___---/(End)
+	//                 ___---/
+	//          ___---/
+	//  (Start)/
+	//  
+    ////////////////////////////////////////////////////////////////////////////////////
+	ESide	LRTest(const CVec4 &Start, const CVec4 &End, float Tolerance=0.0) const
+	{	
+		float Area = AreaParallelPipid(Start, End);
+		if (Area>Tolerance)
+		{
+			return Side_Left;
+		}
+		if (Area<(Tolerance*-1))
+		{
+			return Side_Right;
+		}
+		return Side_None;
+
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Point In Circumscribed Circle  (True/False)
+	//
+	//  Returns true if the given point is within the circumscribed
+	//  circle of the given ABC Triangle:
+	//         _____  
+	//        /   B \
+	//      /   /   \ \
+	//     |  /      \ |
+	//     |A---------C|
+	//      \    Pt   /
+	//       \_______/
+	//  
+	////////////////////////////////////////////////////////////////////////////////////
+	bool	PtInCircle(const CVec4 &A, const CVec4 &B, const CVec4 &C) const;
+
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Point In Standard Circle  (True/False)
+	//
+	//  Returns true if the given point is within the Circle
+	//         _____  
+	//        /     \
+	//      /         \
+	//     |   Circle  |
+	//     |           |
+	//      \    Pt   /
+	//       \_______/
+	//  
+	////////////////////////////////////////////////////////////////////////////////////
+	bool	PtInCircle(const CVec4 &Circle, float Radius) const;
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Line Intersects Circle  (True/False)
+	//
+	//  r	- Radius Of The Circle
+	//  A	- Start Of Line Segment
+	//  B	- End Of Line Segment
+	//
+	//  P	- Projected Position Of Origin Onto Line AB
+	//
+	//
+	//            (Stop)
+	//              /
+	//            /
+	//         (P)
+	//        /   \      \
+	//      /   (this)-r->|
+	//    /              /
+	// (Start)
+	//
+	////////////////////////////////////////////////////////////////////////////////////
+	bool	LineInCircle(const CVec4 &Start, const CVec4 &Stop, float Radius);
+	bool	LineInCircle(const CVec4 &Start, const CVec4 &Stop, float Radius, CVec4 &PointOnLine);
+
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// String Operations
+    ////////////////////////////////////////////////////////////////////////////////////
+	void	FromStr(const char *s);
+	void	ToStr(char* s) const;
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Debug Routines
+    ////////////////////////////////////////////////////////////////////////////////////
+#ifdef _DEBUG
+	bool	IsFinite();
+	bool	IsInitialized();
+#endif
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Data
+    ////////////////////////////////////////////////////////////////////////////////////
+private:
+	float v[4];
+
+
+public:
+	static const CVec4 mX;
+	static const CVec4 mY;
+	static const CVec4 mZ;
+	static const CVec4 mW;
+	static const CVec4 mZero;
+};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// The 3 Dimensional Vector
+////////////////////////////////////////////////////////////////////////////////////////
+class CVec3
+{
+public:
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Constructors
+    ////////////////////////////////////////////////////////////////////////////////////
+#ifndef _DEBUG
+	CVec3()																	{}
+#else
+	CVec3()																	{v[0]=v[1]=v[2]=RAVL_VEC_UDF;}		// DEBUG INITIALIZATION
+#endif	
+	CVec3(const float val)													{v[0]=val;		v[1]=val;		v[2]=val;	}
+	CVec3(const float x,const float y,const float z)						{v[0]=x;		v[1]=y;			v[2]=z;		}
+	CVec3(const CVec3& t)													{v[0]=t.v[0];	v[1]=t.v[1];	v[2]=t.v[2];}
+	CVec3(const float *t)													{v[0]=t[0];		v[1]=t[1];		v[2]=t[2];	}
+
+	float	x()		const													{return v[0];}
+	float	y()		const													{return v[1];}
+	float	z()		const													{return v[2];}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Initializers
+    ////////////////////////////////////////////////////////////////////////////////////
+	void Set(const float t)													{v[0]=t;		v[1]=t;			v[2]=t;		}
+	void Set(const float *t)												{v[0]=t[0];		v[1]=t[1];		v[2]=t[2];	}
+	void Set(const float x,const float y,const float z)						{v[0]=x;		v[1]=y;			v[2]=z;		}
+	void Clear()															{v[0]=0;		v[1]=0;			v[2]=0;		}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Member Accessors
+    ////////////////////////////////////////////////////////////////////////////////////
+	const float& operator[](int i) const 									{return v[i];}
+	float& operator[](int i)												{return v[i];}
+	float& pitch()															{return v[0];}
+	float& yaw()															{return v[1];}
+	float& roll()															{return v[2];}
+	float& radius()															{return v[3];}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Equality / Inequality Operators
+    ////////////////////////////////////////////////////////////////////////////////////
+	bool operator!  () const												{return	!(v[0]         && v[1]         && v[2]        );}
+	bool operator== (const CVec3& t) const									{return	 (v[0]==t.v[0] && v[1]==t.v[1] && v[2]==t.v[2]);}
+	bool operator!= (const CVec3& t) const									{return !(v[0]==t.v[0] && v[1]==t.v[1] && v[2]==t.v[2]);}
+	bool operator<  (const CVec3& t) const									{return	 (v[0]< t.v[0] && v[1]< t.v[1] && v[2]< t.v[2]);}
+	bool operator>  (const CVec3& t) const									{return	 (v[0]> t.v[0] && v[1]> t.v[1] && v[2]> t.v[2]);}
+	bool operator<= (const CVec3& t) const									{return	 (v[0]<=t.v[0] && v[1]<=t.v[1] && v[2]<=t.v[2]);}
+	bool operator>= (const CVec3& t) const									{return	 (v[0]>=t.v[0] && v[1]>=t.v[1] && v[2]>=t.v[2]);}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Basic Arithimitic Operators
+    ////////////////////////////////////////////////////////////////////////////////////
+	const CVec3 &operator=  (const float d)									{v[0]=d;		v[1]=d;			v[2]=d;		 return *this;}
+	const CVec3 &operator=  (const CVec3& t)								{v[0]=t.v[0];	v[1]=t.v[1];	v[2]=t.v[2]; return *this;}
+
+	const CVec3 &operator+= (const float d)									{v[0]+=d;		v[1]+=d;		v[2]+=d;	 return *this;}
+	const CVec3 &operator+= (const CVec3& t)								{v[0]+=t.v[0];	v[1]+=t.v[1];	v[2]+=t.v[2];return *this;}
+
+	const CVec3 &operator-= (const float d)									{v[0]-=d;		v[1]-=d;		v[2]-=d; 	 return *this;}
+	const CVec3 &operator-= (const CVec3& t)								{v[0]-=t.v[0];	v[1]-=t.v[1];	v[2]-=t.v[2];return *this;}
+
+	const CVec3 &operator*= (const float d)									{v[0]*=d;		v[1]*=d;		v[2]*=d;	 return *this;}
+	const CVec3 &operator*= (const CVec3& t)								{v[0]*=t.v[0];	v[1]*=t.v[1];	v[2]*=t.v[2];return *this;}
+
+	const CVec3 &operator/= (const float d)									{v[0]/=d;		v[1]/=d;		v[2]/=d;	 return *this;}
+	const CVec3 &operator/= (const CVec3& t)								{v[0]/=t.v[0];	v[1]/=t.v[1];	v[2]/=t.v[2];return *this;}
+
+	inline CVec3 operator+ (const CVec3 &t) const							{return CVec3(v[0]+t.v[0], v[1]+t.v[1], v[2]+t.v[2]);}
+	inline CVec3 operator- (const CVec3 &t) const							{return CVec3(v[0]-t.v[0], v[1]-t.v[1], v[2]-t.v[2]);}
+	inline CVec3 operator* (const CVec3 &t) const							{return CVec3(v[0]*t.v[0], v[1]*t.v[1], v[2]*t.v[2]);}
+	inline CVec3 operator/ (const CVec3 &t) const							{return CVec3(v[0]/t.v[0], v[1]/t.v[1], v[2]/t.v[2]);}
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Length And Distance Calculations
+    ////////////////////////////////////////////////////////////////////////////////////
+	float	Len() const;
+	float	Len2() const													{return (v[0]*v[0]+v[1]*v[1]+v[2]*v[2]);}
+
+	float	Dist(const CVec3& t) const;
+	float	Dist2(const CVec3& t) const										{return ((t.v[0]-v[0])*(t.v[0]-v[0]) + (t.v[1]-v[1])*(t.v[1]-v[1]) + (t.v[2]-v[2])*(t.v[2]-v[2]));}
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Normalization
+    ////////////////////////////////////////////////////////////////////////////////////
+	float	Norm();
+	float	SafeNorm();
+	void	AngleNorm();
+	float	Truncate(float maxlen);
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Dot, Cross & Perpendicular Vector
+    ////////////////////////////////////////////////////////////////////////////////////
+	float	Dot(const CVec3& t) const										{return (v[0]*t.v[0] + v[1]*t.v[1] + v[2]*t.v[2]);}
+	void	Cross(const CVec3& t)
+	{
+		CVec3 temp(*this);
+		v[0] = (temp.v[1]*t.v[2]) - (temp.v[2]*t.v[1]);
+		v[1] = (temp.v[2]*t.v[0]) - (temp.v[0]*t.v[2]);
+		v[2] = (temp.v[0]*t.v[1]) - (temp.v[1]*t.v[0]);
+	}
+	void	Perp();
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Truncation & Element Analysis
+    ////////////////////////////////////////////////////////////////////////////////////
+	void	Min(const CVec3& t)
+	{
+		if (t.v[0]<v[0])			v[0]=t.v[0];	
+		if (t.v[1]<v[1])			v[1]=t.v[1];	
+		if (t.v[2]<v[2])			v[2]=t.v[2];	
+	}
+	void	Max(const CVec3& t)
+	{
+		if (t.v[0]>v[0])			v[0]=t.v[0];	
+		if (t.v[1]>v[1])			v[1]=t.v[1];	
+		if (t.v[2]>v[2])			v[2]=t.v[2];	
+	}
+	float	MaxElement() const
+	{
+			return v[MaxElementIndex()];	
+	}
+	int		MaxElementIndex() const;
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Interpolation
+    ////////////////////////////////////////////////////////////////////////////////////
+	void	Interp(const CVec3 &v1, const CVec3 &v2, const float t)
+	{
+		(*this)=v1;
+		(*this)-=v2;
+		(*this)*=t;
+		(*this)+=v2;
+	}
+	void	ScaleAdd(const CVec3& t, const float scale)
+	{
+		v[0] += (scale * t.v[0]);
+		v[1] += (scale * t.v[1]);
+		v[2] += (scale * t.v[2]);
+	}
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Conversion Angle To Vector (Angle In Degrees)
+    ////////////////////////////////////////////////////////////////////////////////////
+	void	VecToAng();
+	void	AngToVec();
+	void	AngToVec(CVec3& Right, CVec3& Up);
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Conversion Angle To Vector (Angle In Radians)
+    ////////////////////////////////////////////////////////////////////////////////////
+	void	VecToAngRad();
+	void	AngToVecRad();
+	void	AngToVecRad(CVec3& Right, CVec3& Up);
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Conversion Between Radians And Degrees
+    ////////////////////////////////////////////////////////////////////////////////////
+	void	ToRadians();
+	void	ToDegrees();
+
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Project
+	//
+	// Standard projection function.  Take the (this) and project it onto the vector
+	// (U).  Imagine drawing a line perpendicular to U from the endpoint of the (this)
+	// Vector.  That then becomes the new vector.
+	//
+	// The value returned is the scale of the new vector with respect to the one passed
+	// to the function.  If the scale is less than (1.0) then the new vector is shorter 
+	// than (U).  If the scale is negative, then the vector is going in the opposite 
+	// direction of (U).
+	//
+	//               _  (U)
+	//               /|
+	//             /                                        _ (this)
+	//           /                      RESULTS->           /|
+	//         /                                          /
+	//       /    __\ (this)                            /
+	//     /___---  /                                 /
+	//
+    ////////////////////////////////////////////////////////////////////////////////////
+	float	Project(const CVec3 &U)
+	{
+		float	Scale = (Dot(U) / U.Len2());	// Find the scale of this vector on U
+		(*this)=U;								// Copy U onto this vector
+		(*this)*=Scale;							// Use the previously calculated scale to get the right length.
+		return Scale;
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Project To Line
+	//
+	// This function takes two other points in space as the start and end of a line
+	// segment and projects the (this) point onto the line defined by (Start)->(Stop)
+	//
+	// RETURN VALUES:
+	//   (-INF, 0.0)  : (this) landed on the line before (Start)
+	//   (0.0, 1.0)   : (this) landed in the line segment between (Start) and (Stop)
+	//   (1.0, INF)   : (this) landed on the line beyond (End)
+	//
+	//             (Stop)
+	//               /
+	//             /
+	//           o _
+	//         /  |\
+	//       /     (this)
+	//     / 
+	// (Start)
+	//
+    ////////////////////////////////////////////////////////////////////////////////////
+	float	ProjectToLine(const CVec3 &Start, const CVec3 &Stop)
+	{
+		(*this) -= Start;
+		float	Scale = Project(Stop - Start);
+		(*this) += Start;
+		return Scale;
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+    // Project To Line Seg 
+	//
+	// Same As Project To Line, Except It Will Clamp To Start And Stop
+	////////////////////////////////////////////////////////////////////////////////////
+	float	ProjectToLineSeg(const CVec3 &Start, const CVec3 &Stop)
+	{
+		float Scale = ProjectToLine(Start, Stop);
+		if (Scale<0.0f)
+		{
+			(*this) = Start;
+		}
+		else if (Scale>1.0f)
+		{
+			(*this) = Stop;
+		}
+		return Scale;
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Distance To Line
+	//
+	// Uses project to line and than calculates distance to the new point
+	////////////////////////////////////////////////////////////////////////////////////
+	float	DistToLine(const CVec3 &Start, const CVec3 &Stop) const
+	{
+		CVec3	P(*this);
+		P.ProjectToLineSeg(Start, Stop);
+
+		return Dist(P);
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Distance To Line
+	//
+	// Uses project to line and than calculates distance to the new point
+	////////////////////////////////////////////////////////////////////////////////////
+	float	DistToLine2(const CVec3 &Start, const CVec3 &Stop) const
+	{
+		CVec3	P(*this);
+		P.ProjectToLineSeg(Start, Stop);
+
+		return Dist2(P);
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Translation & Rotation (2D)
+    ////////////////////////////////////////////////////////////////////////////////////
+	void	RotatePoint(const CVec3 &Angle, const CVec3 &Origin);
+	void	Reposition(const CVec3 &Translation, float RotationDegrees=0.0);
+
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Area Of The Parallel Pipid (2D)
+	//
+	// Given two more points, this function calculates the area of the parallel pipid
+	// formed.
+	//
+	// Note: This function CAN return a negative "area" if (this) is above or right of
+	// (A) and (B)...  We do not take the abs because the sign of the "area" is needed
+	// for the left right test (see below)
+	//
+	//
+	//               ___---( ... )
+	//        (A)---/        /
+	//        /             /
+	//       /             /
+	//      /             /
+	//     /      ___---(B)
+	//  (this)---/
+	//
+    ////////////////////////////////////////////////////////////////////////////////////
+	float	AreaParallelPipid(const CVec3 &A, const CVec3 &B) const
+	{
+		return ((A.v[0]*B.v[1] - A.v[1]*B.v[0]) + 
+			    (B.v[0]*  v[1] -   v[0]*B.v[1]) + 
+				(  v[0]*A.v[1] - A.v[0]*  v[1]));
+	}
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Area Of The Triangle (2D)
+	//
+	// Given two more points, this function calculates the area of the triangle formed.
+	//
+	//        (A)
+	//        /  \__
+	//       /      \__
+	//      /          \_
+	//     /      ___---(B)
+	//  (this)---/
+	//
+    ////////////////////////////////////////////////////////////////////////////////////
+	float	AreaTriange(const CVec3 &A, const CVec3 &B) const
+	{
+		return (AreaParallelPipid(A, B) * 0.5f);
+	}
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// The Left Right Test (2D)
+	//
+	// Given a line segment (Start->End) and a tolerance for *right on*, this function
+	// evaluates which side the point is of the line.  (Side_Left in this example)
+	//
+	//
+	//
+	//          (this)        ___---/(End)
+	//                 ___---/
+	//          ___---/
+	//  (Start)/
+	//  
+    ////////////////////////////////////////////////////////////////////////////////////
+	ESide	LRTest(const CVec3 &Start, const CVec3 &End, float Tolerance=0.0) const
+	{	
+		float Area = AreaParallelPipid(Start, End);
+		if (Area>Tolerance)
+		{
+			return Side_Left;
+		}
+		if (Area<(Tolerance*-1))
+		{
+			return Side_Right;
+		}
+		return Side_None;
+
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Point In Circumscribed Circle  (True/False)
+	//
+	//  Returns true if the given point is within the circumscribed
+	//  circle of the given ABC Triangle:
+	//         _____  
+	//        /   B \
+	//      /   /   \ \
+	//     |  /      \ |
+	//     |A---------C|
+	//      \    Pt   /
+	//       \_______/
+	//  
+	////////////////////////////////////////////////////////////////////////////////////
+	bool	PtInCircle(const CVec3 &A, const CVec3 &B, const CVec3 &C) const;
+
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Point In Standard Circle  (True/False)
+	//
+	//  Returns true if the given point is within the Circle
+	//         _____  
+	//        /     \
+	//      /         \
+	//     |   Circle  |
+	//     |           |
+	//      \    Pt   /
+	//       \_______/
+	//  
+	////////////////////////////////////////////////////////////////////////////////////
+	bool	PtInCircle(const CVec3 &Circle, float Radius) const;
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Line Intersects Circle  (True/False)
+	//
+	//  r	- Radius Of The Circle
+	//  A	- Start Of Line Segment
+	//  B	- End Of Line Segment
+	//
+	//  P	- Projected Position Of Origin Onto Line AB
+	//
+	//
+	//            (Stop)
+	//              /
+	//            /
+	//         (P)
+	//        /   \      \
+	//      /   (this)-r->|
+	//    /              /
+	// (Start)
+	//
+	////////////////////////////////////////////////////////////////////////////////////
+	bool	LineInCircle(const CVec3 &Start, const CVec3 &Stop, float Radius);
+	bool	LineInCircle(const CVec3 &Start, const CVec3 &Stop, float Radius, CVec3 &PointOnLine);
+
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// String Operations
+    ////////////////////////////////////////////////////////////////////////////////////
+	void	FromStr(const char *s);
+	void	ToStr(char* s) const;
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Debug Routines
+    ////////////////////////////////////////////////////////////////////////////////////
+#ifdef _DEBUG
+	bool	IsFinite();
+	bool	IsInitialized();
+#endif
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Data
+    ////////////////////////////////////////////////////////////////////////////////////
+
+public:
+	float v[3];	
+	static const CVec3 mX;
+	static const CVec3 mY;
+	static const CVec3 mZ;
+	static const CVec3 mZero;
+};
+
+
+
+//};
+#endif
\ No newline at end of file
diff --git a/code/Ravl/vssver.scc b/code/Ravl/vssver.scc
new file mode 100644
index 0000000..e182a3e
Binary files /dev/null and b/code/Ravl/vssver.scc differ
diff --git a/code/Rufl/hfile.cpp b/code/Rufl/hfile.cpp
new file mode 100644
index 0000000..6238d6d
--- /dev/null
+++ b/code/Rufl/hfile.cpp
@@ -0,0 +1,378 @@
+////////////////////////////////////////////////////////////////////////////////////////
+// RAVEN STANDARD USEFUL FUNCTION LIBRARY
+//  (c) 2002 Activision
+//
+//
+// Handle File
+// -----------
+//
+////////////////////////////////////////////////////////////////////////////////////////
+
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Includes
+////////////////////////////////////////////////////////////////////////////////////////
+#include "hfile.h"
+#if !defined(RATL_HANDLE_POOL_VS_INC)
+	#include "..\Ratl\handle_pool_vs.h"
+#endif
+#if !defined(RATL_VECTOR_VS_INC)
+	#include "..\Ratl\vector_vs.h"
+#endif
+#if !defined(RUFL_HSTRING_INC)
+	#include "hstring.h"
+#endif
+
+
+
+
+extern bool	HFILEopen_read(int& handle,	const char* filepath);
+extern bool	HFILEopen_write(int& handle, const char* filepath);
+extern bool	HFILEread(int& handle,		void*		data, int size);
+extern bool	HFILEwrite(int& handle,		const void* data, int size);
+extern bool	HFILEclose(int& handle);
+
+
+
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Defines
+////////////////////////////////////////////////////////////////////////////////////////
+#define MAX_OPEN_FILES			20
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// 
+////////////////////////////////////////////////////////////////////////////////////////
+struct SOpenFile
+{
+#ifdef _XBOX
+	dllNamespace::hstring mPath;
+#else
+	hstring			mPath;
+#endif
+	bool			mForRead;
+	int				mHandle;
+	float			mVersion;
+	int				mChecksum;
+};
+typedef	ratl::handle_pool_vs<SOpenFile, MAX_OPEN_FILES>		TFilePool;
+
+TFilePool&	Pool()
+{
+	static TFilePool TFP;
+	return TFP;
+}
+
+
+
+
+
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Constructor
+//
+// Allocates a new OpenFile structure and initializes it.  DOES NOT OPEN!
+//
+////////////////////////////////////////////////////////////////////////////////////////
+hfile::hfile(const char* file)
+{
+	if (Pool().full())
+	{
+		mHandle = 0;
+		assert("HFILE: Too Many Files Open, Unable To Grab An Unused Handle"==0);
+		return;
+	}
+
+	mHandle = Pool().alloc();
+
+	SOpenFile&	sfile = Pool()[mHandle];
+
+	sfile.mPath		= file;
+	sfile.mHandle	= 0;
+	sfile.mForRead	= true;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Destructor
+//
+// Releases the open file structure for resue.  Also closes the file if open.
+//
+////////////////////////////////////////////////////////////////////////////////////////
+hfile::~hfile()
+{
+	if (is_open())
+	{
+		close();
+	}
+
+	if (mHandle && Pool().is_used(mHandle))
+	{
+		Pool().free(mHandle);
+	}
+	mHandle = 0;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// 
+////////////////////////////////////////////////////////////////////////////////////////
+bool		hfile::is_open(void)	const
+{
+	if (mHandle && Pool().is_used(mHandle))
+	{
+		return (Pool()[mHandle].mHandle!=0);
+	}
+	return false;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// 
+////////////////////////////////////////////////////////////////////////////////////////
+bool		hfile::is_open_for_read(void)	const
+{
+	if (mHandle && Pool().is_used(mHandle))
+	{
+		SOpenFile&	sfile = Pool()[mHandle];
+		return (sfile.mHandle!=0 && sfile.mForRead);
+	}
+	return false;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// 
+////////////////////////////////////////////////////////////////////////////////////////
+bool		hfile::is_open_for_write(void)	const
+{
+	if (mHandle && Pool().is_used(mHandle))
+	{
+		SOpenFile&	sfile = Pool()[mHandle];
+		return (sfile.mHandle!=0 && !sfile.mForRead);
+	}
+	return false;
+}
+
+
+////////////////////////////////////////////////////////////////////////////////////
+// 
+////////////////////////////////////////////////////////////////////////////////////
+bool		hfile::open(float version, int checksum, bool read)
+{
+	// Make Sure This Is A Valid Handle
+	//----------------------------------
+	if (!mHandle || !Pool().is_used(mHandle))
+	{
+		assert("HFILE: Invalid Handle"==0);
+		return false;
+	}
+
+	// Make Sure The File Is Not ALREADY Open
+	//----------------------------------------
+	SOpenFile&	sfile = Pool()[mHandle];
+	if (sfile.mHandle!=0)
+	{
+		assert("HFILE: Attempt To Open An Already Open File"==0);
+		return false;
+	}
+
+	sfile.mForRead = read;
+	if (read)
+	{
+		HFILEopen_read(sfile.mHandle, *sfile.mPath);
+	}
+	else
+	{
+		HFILEopen_write(sfile.mHandle, *sfile.mPath);
+	}
+
+	// If The Open Failed, Report It And Free The SOpenFile
+	//------------------------------------------------------
+	if (sfile.mHandle==0)
+	{
+		if (!read)
+		{
+			assert("HFILE: Unable To Open File"==0);
+		}
+		return false;
+	}
+
+
+	// Read The File's Header
+	//------------------------
+	if (read)
+	{		
+		if (!HFILEread(sfile.mHandle, &sfile.mVersion, sizeof(sfile.mVersion)))
+		{
+			assert("HFILE: Unable To Read File Header"==0);
+			close();
+			return false;
+		}
+		if (!HFILEread(sfile.mHandle, &sfile.mChecksum, sizeof(sfile.mChecksum)))
+		{
+			assert("HFILE: Unable To Read File Header"==0);
+			close();
+			return false;
+		}
+
+		// Make Sure The Checksum & Version Match
+		//----------------------------------------
+		if (sfile.mVersion!=version || sfile.mChecksum!=checksum)
+		{
+			close();
+			return false;	// Failed To Match Checksum Or Version Number -> Old Data
+		}
+	}
+	else
+	{
+		sfile.mVersion = version;
+		sfile.mChecksum = checksum;
+
+		if (!HFILEwrite(sfile.mHandle, &sfile.mVersion, sizeof(sfile.mVersion)))
+		{
+			assert("HFILE: Unable To Write File Header"==0);
+			close();
+			return false;
+		}
+		if (!HFILEwrite(sfile.mHandle, &sfile.mChecksum, sizeof(sfile.mChecksum)))
+		{
+			assert("HFILE: Unable To Write File Header"==0);
+			close();
+			return false;
+		}
+	}
+
+	return true;
+}
+
+////////////////////////////////////////////////////////////////////////////////////
+// 
+////////////////////////////////////////////////////////////////////////////////////
+bool		hfile::close()
+{
+	if (!mHandle || !Pool().is_used(mHandle))
+	{
+		assert("HFILE: Invalid Handle"==0);
+		return false;
+	}
+
+	SOpenFile&	sfile = Pool()[mHandle];
+	if (sfile.mHandle==0)
+	{
+		assert("HFILE: Unable TO Close Unopened File"==0);
+		return false;
+	}
+
+	if (!HFILEclose(sfile.mHandle))
+	{
+		sfile.mHandle = 0;
+		assert("HFILE: Unable To Close File"==0);
+		return false;
+	}
+	sfile.mHandle = 0;
+
+	return true;
+}
+
+////////////////////////////////////////////////////////////////////////////////////
+// Searches for the first block with the matching data size, and reads it in. 
+////////////////////////////////////////////////////////////////////////////////////
+bool		hfile::load(void* data, int datasize)
+{
+	// Go Ahead And Open The File For Reading
+	//----------------------------------------
+	bool auto_opened = false;
+	if (!is_open())
+	{
+		if (!open_read())
+		{
+			return false;
+		}
+		auto_opened = true;
+	}
+
+	// Make Sure That The File Is Readable
+	//-------------------------------------
+	SOpenFile&	sfile = Pool()[mHandle];
+	if (!sfile.mForRead)
+	{
+		assert("HFILE: Unable to load from a file that is opened for save"==0);
+		if (auto_opened)
+		{
+			close();
+		}
+		return false;
+	}
+
+
+	// Now Read It
+	//-------------
+	if (!HFILEread(sfile.mHandle, data, datasize))
+	{
+		assert("HFILE: Unable To Read Object"==0);
+		if (auto_opened)
+		{
+			close();
+		}
+		return false;
+	}
+
+	// Success!
+	//----------
+	if (auto_opened)
+	{
+		close();
+	}
+	return true;
+}
+
+////////////////////////////////////////////////////////////////////////////////////
+// 
+////////////////////////////////////////////////////////////////////////////////////
+bool		hfile::save(void* data, int datasize)
+{
+	// Go Ahead And Open The File For Reading
+	//----------------------------------------
+	bool auto_opened = false;
+	if (!is_open())
+	{
+		if (!open_write())
+		{
+			return false;
+		}
+		auto_opened = true;
+	}
+
+	// Make Sure That The File Is Readable
+	//-------------------------------------
+	SOpenFile&	sfile = Pool()[mHandle];
+	if (sfile.mForRead)
+	{
+		assert("HFILE: Unable to save to a file that is opened for read"==0);
+		if (auto_opened)
+		{
+			close();
+		}
+		return false;
+	}
+
+
+	// Write The Actual Object
+	//-------------------------
+	if (!HFILEwrite(sfile.mHandle, data, datasize))
+	{
+		assert("HFILE: Unable To Write File Data"==0);
+		if (auto_opened)
+		{
+			close();
+		}
+		return false;
+	}
+
+	if (auto_opened)
+	{
+		close();
+	}
+	return true;
+}
diff --git a/code/Rufl/hfile.h b/code/Rufl/hfile.h
new file mode 100644
index 0000000..5b50bbb
--- /dev/null
+++ b/code/Rufl/hfile.h
@@ -0,0 +1,61 @@
+////////////////////////////////////////////////////////////////////////////////////////
+// RAVEN STANDARD USEFUL FUNCTION LIBRARY
+//  (c) 2002 Activision
+//
+//
+// Handle File
+// -----------
+//
+////////////////////////////////////////////////////////////////////////////////////////
+#if !defined(RUFL_HFILE_INC)
+#define RUFL_HFILE_INC
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// HFile Bindings
+//
+// These are the standard C hfile bindings, copy these function wrappers to your .cpp
+// before including hfile, and modify them if needed to support a different file
+// system.
+////////////////////////////////////////////////////////////////////////////////////////
+//bool	HFILEopen_read(int& handle,	const char* filepath)		{handle=(int)fopen(filepath, "rb");	return (handle!=0);}
+//bool	HFILEopen_write(int& handle, const char* filepath)		{handle=(int)fopen(filepath, "wb");	return (handle!=0);}
+//bool	HFILEread(int& handle,		void*		data, int size)	{return (fread(data, size, 1, (FILE*)(handle))>0);}
+//bool	HFILEwrite(int& handle,		const void* data, int size)	{return (fwrite(data, size, 1, (FILE*)(handle))>0);}
+//bool	HFILEclose(int& handle)									{return (fclose((FILE*)handle)==0);}
+
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// The Handle String Class
+////////////////////////////////////////////////////////////////////////////////////////
+class hfile
+{
+public:
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Constructors
+    ////////////////////////////////////////////////////////////////////////////////////
+	hfile(const char *file);
+	~hfile();
+
+	bool		load(void* data, int datasize);
+	bool		save(void* data, int datasize);
+
+	bool		is_open(void)			const;
+	bool		is_open_for_read(void)	const;
+	bool		is_open_for_write(void)	const;
+
+	bool		open_read(float version=1.0f, int checksum=0)		{return open(version, checksum, true);}
+	bool		open_write(float version=1.0f, int checksum=0)		{return open(version, checksum, false);}
+
+	bool		close();
+
+private:
+	bool		open(float version, int checksum, bool read);
+
+
+	int			mHandle;
+};
+
+
+#endif // hfile_H
\ No newline at end of file
diff --git a/code/Rufl/hstring.cpp b/code/Rufl/hstring.cpp
new file mode 100644
index 0000000..25969af
--- /dev/null
+++ b/code/Rufl/hstring.cpp
@@ -0,0 +1,185 @@
+////////////////////////////////////////////////////////////////////////////////////////
+// RAVEN STANDARD USEFUL FUNCTION LIBRARY
+//  (c) 2002 Activision
+//
+//
+// Handle String
+// -------------
+// Handle strings are allocated once in a static buffer (with a hash index), and are 
+// never cleared out.  You should use these for very common string names which are
+// redundant or intended to last a long time.
+//
+// Handle strings are also good for comparison and storage because they compare only
+// the handles, which are simple unique integers.
+//
+////////////////////////////////////////////////////////////////////////////////////////
+
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Includes
+////////////////////////////////////////////////////////////////////////////////////////
+#include "hstring.h"
+#include <string.h>
+#include "..\Ratl\hash_pool_vs.h"
+
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Defines
+////////////////////////////////////////////////////////////////////////////////////////
+#define MAX_HASH		16384			// How Many Hash
+#define	BLOCK_SIZE		65536			// Size of a string storage block in bytes.
+
+
+
+
+
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// The Hash Pool
+////////////////////////////////////////////////////////////////////////////////////////
+typedef	ratl::hash_pool<BLOCK_SIZE, MAX_HASH>		TStrPool;
+
+
+TStrPool&	Pool()
+{
+	static TStrPool TSP;
+	return TSP;
+}
+
+
+
+
+#ifdef _XBOX
+namespace dllNamespace
+{
+#endif
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Constructor
+////////////////////////////////////////////////////////////////////////////////////////
+hstring::hstring()
+{
+	mHandle	= 0;
+#ifdef _DEBUG
+	mStr	= 0;
+#endif
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Constructor
+////////////////////////////////////////////////////////////////////////////////////////
+hstring::hstring(const char *str)
+{
+	init(str);
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Constructor
+////////////////////////////////////////////////////////////////////////////////////////
+hstring::hstring(const hstring &str) 
+{
+	mHandle = str.mHandle;
+
+#ifdef _DEBUG
+	mStr	= str.mStr;
+#endif
+}
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Assignment
+////////////////////////////////////////////////////////////////////////////////////////
+hstring& hstring::operator= (const char *str)
+{
+	init(str);
+	return *this;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Constructor
+////////////////////////////////////////////////////////////////////////////////////////
+hstring& hstring::operator= (const hstring &str)
+{
+	mHandle = str.mHandle;
+
+#ifdef _DEBUG
+	mStr	= str.mStr;
+#endif
+	return *this;
+}
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+//
+////////////////////////////////////////////////////////////////////////////////////////
+const char*	hstring::c_str(void) const
+{
+	if (!mHandle)
+	{
+		return("");
+	}
+	return ((const char*)Pool()[mHandle]);
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+//
+////////////////////////////////////////////////////////////////////////////////////////
+const char*	hstring::operator *(void) const
+{
+	return c_str();
+}
+
+////////////////////////////////////////////////////////////////////////////////////
+// 
+////////////////////////////////////////////////////////////////////////////////////
+int			hstring::length() const
+{
+	return strlen(c_str());
+}
+
+////////////////////////////////////////////////////////////////////////////////////
+// 
+////////////////////////////////////////////////////////////////////////////////////
+int			hstring::handle() const
+{
+	return mHandle;
+}
+
+
+
+////////////////////////////////////////////////////////////////////////////////////
+// 
+////////////////////////////////////////////////////////////////////////////////////
+void		hstring::init(const char *str)
+{
+	if (!str)
+	{
+		mHandle = 0;
+	}
+	else
+	{
+		mHandle = Pool().get_handle(str, strlen(str)+1);		// +1 for null character
+	}
+	#ifdef _DEBUG
+	mStr	= (char*)Pool()[mHandle];
+	#endif
+}
+
+
+////////////////////////////////////////////////////////////////////////////////////
+// 
+////////////////////////////////////////////////////////////////////////////////////
+#ifdef _DEBUG
+float		hstring::ave_collisions()	{return Pool().average_collisions();}
+int			hstring::total_strings()	{return Pool().total_allocs();}
+int			hstring::total_bytes()		{return Pool().size();}
+int			hstring::total_finds()		{return Pool().total_finds();}
+int			hstring::total_collisions()	{return Pool().total_collisions();}
+#endif
+
+#ifdef _XBOX
+} // dllNamespace
+#endif
diff --git a/code/Rufl/hstring.h b/code/Rufl/hstring.h
new file mode 100644
index 0000000..f46df9f
--- /dev/null
+++ b/code/Rufl/hstring.h
@@ -0,0 +1,106 @@
+////////////////////////////////////////////////////////////////////////////////////////
+// RAVEN STANDARD USEFUL FUNCTION LIBRARY
+//  (c) 2002 Activision
+//
+//
+// Handle String
+// -------------
+// Handle strings are allocated once in a static buffer (with a hash index), and are 
+// never cleared out.  You should use these for very common string names which are
+// redundant or intended to last a long time.
+//
+// Handle strings are also good for comparison and storage because they compare only
+// the handles, which are simple unique integers.
+//
+////////////////////////////////////////////////////////////////////////////////////////
+#if !defined(RUFL_HSTRING_INC)
+#define RUFL_HSTRING_INC
+
+
+#ifdef _XBOX
+namespace dllNamespace
+{
+#endif
+
+////////////////////////////////////////////////////////////////////////////////////////
+// The Handle String Class
+////////////////////////////////////////////////////////////////////////////////////////
+class hstring
+{
+public:
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Constructors
+    ////////////////////////////////////////////////////////////////////////////////////
+	hstring();
+	hstring(const char *str);
+	hstring(const hstring &str);
+
+	
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Assignment
+    ////////////////////////////////////////////////////////////////////////////////////
+	hstring&	operator= (const char *str);
+	hstring&	operator= (const hstring &str);
+
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Comparison
+    ////////////////////////////////////////////////////////////////////////////////////
+	bool		operator== (const hstring &str) const	{return (mHandle==str.mHandle);}
+	bool		operator<  (const hstring &str) const	{return (mHandle< str.mHandle);}
+	bool		operator!  () const						{return (mHandle==0);}
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Conversion
+    ////////////////////////////////////////////////////////////////////////////////////
+	const char*	c_str(void) const;
+	const char*	operator *(void) const;
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Access Functions
+    ////////////////////////////////////////////////////////////////////////////////////
+	int			length(void) const;
+	int			handle(void) const;
+	bool		empty()	const							{return handle()==0;}
+
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Debug Statistics Routines
+    ////////////////////////////////////////////////////////////////////////////////////
+#ifdef _DEBUG
+	static	float		ave_collisions();
+	static	int			total_strings();
+	static	int			total_bytes();
+	static	int			total_finds();
+	static	int			total_collisions();
+#endif
+
+
+
+private:
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Helper Functions
+    ////////////////////////////////////////////////////////////////////////////////////
+	void		init(const char *str);
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Data
+    ////////////////////////////////////////////////////////////////////////////////////
+	int		mHandle;
+
+#ifdef _DEBUG
+	char*	mStr;
+#endif
+};
+
+#ifdef _XBOX
+} // dllNamespace
+using namespace dllNamespace;
+#endif
+
+#endif // HSTRING_H
\ No newline at end of file
diff --git a/code/Rufl/random.cpp b/code/Rufl/random.cpp
new file mode 100644
index 0000000..e69de29
diff --git a/code/Rufl/random.h b/code/Rufl/random.h
new file mode 100644
index 0000000..e69de29
diff --git a/code/Rufl/vssver.scc b/code/Rufl/vssver.scc
new file mode 100644
index 0000000..f5c7800
Binary files /dev/null and b/code/Rufl/vssver.scc differ
diff --git a/code/SHDebug/HA312W32.DLL b/code/SHDebug/HA312W32.DLL
new file mode 100644
index 0000000..2b1ea82
Binary files /dev/null and b/code/SHDebug/HA312W32.DLL differ
diff --git a/code/SHDebug/SHW32.DLL b/code/SHDebug/SHW32.DLL
new file mode 100644
index 0000000..42b2f67
Binary files /dev/null and b/code/SHDebug/SHW32.DLL differ
diff --git a/code/SHDebug/vssver.scc b/code/SHDebug/vssver.scc
new file mode 100644
index 0000000..1209876
Binary files /dev/null and b/code/SHDebug/vssver.scc differ
diff --git a/code/VU.bat b/code/VU.bat
new file mode 100644
index 0000000..0eb318d
--- /dev/null
+++ b/code/VU.bat
@@ -0,0 +1 @@
+VersionUpdate -ss_ini \\Ravendata1\VSS\central_code\SRCSAFE.INI -ss_prj $/Jedi/Code -header win32/AutoVersion.h -email SW-Everyone -interactive
diff --git a/code/cgame/FX_ATSTMain.cpp b/code/cgame/FX_ATSTMain.cpp
new file mode 100644
index 0000000..b60c493
--- /dev/null
+++ b/code/cgame/FX_ATSTMain.cpp
@@ -0,0 +1,105 @@
+// Bowcaster Weapon
+
+// this line must stay at top so the whole PCH thing works...
+#include "cg_headers.h"
+
+//#include "cg_local.h"
+#include "cg_media.h"
+#include "FxScheduler.h"
+
+
+/*
+---------------------------
+FX_ATSTMainProjectileThink
+---------------------------
+*/
+void FX_ATSTMainProjectileThink( centity_t *cent, const struct weaponInfo_s *weapon )
+{
+	vec3_t forward;
+
+	if ( VectorNormalize2( cent->gent->s.pos.trDelta, forward ) == 0.0f )
+	{
+		if ( VectorNormalize2( cent->currentState.pos.trDelta, forward ) == 0.0f )
+		{
+			forward[2] = 1.0f;
+		}
+	}
+
+	// hack the scale of the forward vector if we were just fired or bounced...this will shorten up the tail for a split second so tails don't clip so harshly
+	int dif = cg.time - cent->gent->s.pos.trTime;
+
+	if ( dif < 30 )
+	{
+		if ( dif < 0 )
+		{
+			dif = 0;
+		}
+
+		float scale = ( dif / 30.0f ) * 0.95f + 0.05f;
+
+		VectorScale( forward, scale, forward );
+	}
+
+	theFxScheduler.PlayEffect( "atst/shot", cent->lerpOrigin, forward );
+}
+
+/*
+---------------------------
+FX_ATSTMainHitWall
+---------------------------
+*/
+void FX_ATSTMainHitWall( vec3_t origin, vec3_t normal )
+{
+	theFxScheduler.PlayEffect( "atst/wall_impact", origin, normal );
+}
+
+/*
+---------------------------
+FX_ATSTMainHitPlayer
+---------------------------
+*/
+void FX_ATSTMainHitPlayer( vec3_t origin, vec3_t normal, qboolean humanoid )
+{
+	if ( humanoid )
+	{
+		theFxScheduler.PlayEffect( "atst/flesh_impact", origin, normal );
+	}
+	else
+	{
+		theFxScheduler.PlayEffect( "atst/droid_impact", origin, normal );
+	}
+}
+
+/*
+---------------------------
+FX_ATSTSideAltProjectileThink
+---------------------------
+*/
+void FX_ATSTSideAltProjectileThink( centity_t *cent, const struct weaponInfo_s *weapon )
+{
+	vec3_t forward;
+
+	if ( VectorNormalize2( cent->currentState.pos.trDelta, forward ) == 0.0f )
+	{
+		forward[2] = 1.0f;
+	}
+
+	theFxScheduler.PlayEffect( "atst/side_alt_shot", cent->lerpOrigin, forward );
+}
+
+/*
+---------------------------
+FX_ATSTSideMainProjectileThink
+---------------------------
+*/
+void FX_ATSTSideMainProjectileThink( centity_t *cent, const struct weaponInfo_s *weapon )
+{
+	vec3_t forward;
+
+	if ( VectorNormalize2( cent->currentState.pos.trDelta, forward ) == 0.0f )
+	{
+		forward[2] = 1.0f;
+	}
+
+	theFxScheduler.PlayEffect( "atst/side_main_shot", cent->lerpOrigin, forward );
+}
diff --git a/code/cgame/FX_Blaster.cpp b/code/cgame/FX_Blaster.cpp
new file mode 100644
index 0000000..b89b9f0
--- /dev/null
+++ b/code/cgame/FX_Blaster.cpp
@@ -0,0 +1,95 @@
+// Blaster Weapon
+
+// this line must stay at top so the whole PCH thing works...
+#include "cg_headers.h"
+
+#include "cg_local.h"
+#include "cg_media.h"
+#include "FxScheduler.h"
+
+/*
+-------------------------
+FX_BlasterProjectileThink
+-------------------------
+*/
+
+void FX_BlasterProjectileThink( centity_t *cent, const struct weaponInfo_s *weapon )
+{
+	vec3_t forward;
+
+ 	if (cent->currentState.eFlags & EF_USE_ANGLEDELTA)
+	{
+		AngleVectors(cent->currentState.angles, forward, 0, 0);
+	}
+	else
+	{
+		if ( VectorNormalize2( cent->gent->s.pos.trDelta, forward ) == 0.0f )
+		{
+			if ( VectorNormalize2( cent->currentState.pos.trDelta, forward ) == 0.0f )
+			{
+				forward[2] = 1.0f;
+			}
+		}
+	}
+
+	// hack the scale of the forward vector if we were just fired or bounced...this will shorten up the tail for a split second so tails don't clip so harshly
+	int dif = cg.time - cent->gent->s.pos.trTime;
+
+	if ( dif < 75 )
+	{
+		if ( dif < 0 )
+		{
+			dif = 0;
+		}
+
+		float scale = ( dif / 75.0f ) * 0.95f + 0.05f;
+
+		VectorScale( forward, scale, forward );
+	}
+
+	if ( cent->gent && cent->gent->owner && cent->gent->owner->s.number > 0 )
+	{
+		theFxScheduler.PlayEffect( "blaster/NPCshot", cent->lerpOrigin, forward );
+	}
+	else
+	{
+		theFxScheduler.PlayEffect( cgs.effects.blasterShotEffect, cent->lerpOrigin, forward );
+	}
+}
+
+/*
+-------------------------
+FX_BlasterAltFireThink
+-------------------------
+*/
+void FX_BlasterAltFireThink( centity_t *cent, const struct weaponInfo_s *weapon )
+{
+	FX_BlasterProjectileThink( cent, weapon );
+}
+
+/*
+-------------------------
+FX_BlasterWeaponHitWall
+-------------------------
+*/
+void FX_BlasterWeaponHitWall( vec3_t origin, vec3_t normal )
+{
+	theFxScheduler.PlayEffect( cgs.effects.blasterWallImpactEffect, origin, normal );
+}
+
+/*
+-------------------------
+FX_BlasterWeaponHitPlayer
+-------------------------
+*/
+void FX_BlasterWeaponHitPlayer( gentity_t *hit, vec3_t origin, vec3_t normal, qboolean humanoid )
+{
+	//temporary? just testing out the damage skin stuff -rww
+	if ( hit && hit->client && hit->ghoul2.size() )
+	{
+		CG_AddGhoul2Mark(cgs.media.bdecal_burnmark1, flrand(3.5, 4.0), origin, normal, hit->s.number,
+			hit->client->ps.origin, hit->client->renderInfo.legsYaw, hit->ghoul2, hit->s.modelScale, Q_irand(10000, 13000));
+	}
+        
+	theFxScheduler.PlayEffect( cgs.effects.blasterFleshImpactEffect, origin, normal );
+}
diff --git a/code/cgame/FX_Bowcaster.cpp b/code/cgame/FX_Bowcaster.cpp
new file mode 100644
index 0000000..5f40aaa
--- /dev/null
+++ b/code/cgame/FX_Bowcaster.cpp
@@ -0,0 +1,66 @@
+// Bowcaster Weapon
+
+// this line must stay at top so the whole PCH thing works...
+#include "cg_headers.h"
+
+//#include "cg_local.h"
+#include "cg_media.h"
+#include "FxScheduler.h"
+
+/*
+---------------------------
+FX_BowcasterProjectileThink
+---------------------------
+*/
+
+void FX_BowcasterProjectileThink( centity_t *cent, const struct weaponInfo_s *weapon )
+{
+	vec3_t forward;
+
+	if ( VectorNormalize2( cent->gent->s.pos.trDelta, forward ) == 0.0f )
+	{
+		if ( VectorNormalize2( cent->currentState.pos.trDelta, forward ) == 0.0f )
+		{
+			forward[2] = 1.0f;
+		}
+	}
+
+	// hack the scale of the forward vector if we were just fired or bounced...this will shorten up the tail for a split second so tails don't clip so harshly
+	int dif = cg.time - cent->gent->s.pos.trTime;
+
+	if ( dif < 75 )
+	{
+		if ( dif < 0 )
+		{
+			dif = 0;
+		}
+
+		float scale = ( dif / 75.0f ) * 0.95f + 0.05f;
+
+		VectorScale( forward, scale, forward );
+	}
+
+	theFxScheduler.PlayEffect( cgs.effects.bowcasterShotEffect, cent->lerpOrigin, forward );
+}
+
+/*
+---------------------------
+FX_BowcasterHitWall
+---------------------------
+*/
+
+void FX_BowcasterHitWall( vec3_t origin, vec3_t normal )
+{
+	theFxScheduler.PlayEffect( cgs.effects.bowcasterImpactEffect, origin, normal );
+}
+
+/*
+---------------------------
+FX_BowcasterHitPlayer
+---------------------------
+*/
+
+void FX_BowcasterHitPlayer( vec3_t origin, vec3_t normal, qboolean humanoid )
+{
+	theFxScheduler.PlayEffect( cgs.effects.bowcasterImpactEffect, origin, normal );
+}
\ No newline at end of file
diff --git a/code/cgame/FX_BryarPistol.cpp b/code/cgame/FX_BryarPistol.cpp
new file mode 100644
index 0000000..caa4c6b
--- /dev/null
+++ b/code/cgame/FX_BryarPistol.cpp
@@ -0,0 +1,156 @@
+// Bryar Pistol Weapon Effects
+
+// this line must stay at top so the whole PCH thing works...
+#include "cg_headers.h"
+
+//#include "cg_local.h"
+#include "cg_media.h"
+#include "FxScheduler.h"
+
+/*
+-------------------------
+
+	MAIN FIRE
+
+-------------------------
+FX_BryarProjectileThink
+-------------------------
+*/
+void FX_BryarProjectileThink(  centity_t *cent, const struct weaponInfo_s *weapon )
+{
+	vec3_t forward;
+
+	if ( VectorNormalize2( cent->gent->s.pos.trDelta, forward ) == 0.0f )
+	{
+		if ( VectorNormalize2( cent->currentState.pos.trDelta, forward ) == 0.0f )
+		{
+			forward[2] = 1.0f;
+		}
+	}
+
+	// hack the scale of the forward vector if we were just fired or bounced...this will shorten up the tail for a split second so tails don't clip so harshly
+	int dif = cg.time - cent->gent->s.pos.trTime;
+
+	if ( dif < 75 )
+	{
+		if ( dif < 0 )
+		{
+			dif = 0;
+		}
+
+		float scale = ( dif / 75.0f ) * 0.95f + 0.05f;
+
+		VectorScale( forward, scale, forward );
+	}
+
+	if ( cent->gent && cent->gent->owner && cent->gent->owner->s.number > 0 )
+	{
+		theFxScheduler.PlayEffect( "bryar/NPCshot", cent->lerpOrigin, forward );
+	}
+	else
+	{
+		theFxScheduler.PlayEffect( cgs.effects.bryarShotEffect, cent->lerpOrigin, forward );
+	}
+}
+
+/*
+-------------------------
+FX_BryarHitWall
+-------------------------
+*/
+void FX_BryarHitWall( vec3_t origin, vec3_t normal )
+{
+	theFxScheduler.PlayEffect( cgs.effects.bryarWallImpactEffect, origin, normal );
+}
+
+/*
+-------------------------
+FX_BryarHitPlayer
+-------------------------
+*/
+void FX_BryarHitPlayer( vec3_t origin, vec3_t normal, qboolean humanoid )
+{
+	theFxScheduler.PlayEffect( cgs.effects.bryarFleshImpactEffect, origin, normal );
+}
+
+
+/*
+-------------------------
+
+	ALT FIRE
+
+-------------------------
+FX_BryarAltProjectileThink
+-------------------------
+*/
+void FX_BryarAltProjectileThink(  centity_t *cent, const struct weaponInfo_s *weapon )
+{
+	vec3_t forward;
+
+	if ( VectorNormalize2( cent->gent->s.pos.trDelta, forward ) == 0.0f )
+	{
+		if ( VectorNormalize2( cent->currentState.pos.trDelta, forward ) == 0.0f )
+		{
+			forward[2] = 1.0f;
+		}
+	}
+
+	// hack the scale of the forward vector if we were just fired or bounced...this will shorten up the tail for a split second so tails don't clip so harshly
+	int dif = cg.time - cent->gent->s.pos.trTime;
+
+	if ( dif < 75 )
+	{
+		if ( dif < 0 )
+		{
+			dif = 0;
+		}
+
+		float scale = ( dif / 75.0f ) * 0.95f + 0.05f;
+
+		VectorScale( forward, scale, forward );
+	}
+
+	// see if we have some sort of extra charge going on
+	for ( int t = 1; t < cent->gent->count; t++ )
+	{
+		// just add ourselves over, and over, and over when we are charged
+		theFxScheduler.PlayEffect( cgs.effects.bryarPowerupShotEffect, cent->lerpOrigin, forward );
+	}
+
+	theFxScheduler.PlayEffect( cgs.effects.bryarShotEffect, cent->lerpOrigin, forward );
+}
+
+/*
+-------------------------
+FX_BryarAltHitWall
+-------------------------
+*/
+void FX_BryarAltHitWall( vec3_t origin, vec3_t normal, int power )
+{
+	switch( power )
+	{
+	case 4:
+	case 5:
+		theFxScheduler.PlayEffect( cgs.effects.bryarWallImpactEffect3, origin, normal );
+		break;
+
+	case 2:
+	case 3:
+		theFxScheduler.PlayEffect( cgs.effects.bryarWallImpactEffect2, origin, normal );
+		break;
+
+	default:
+		theFxScheduler.PlayEffect( cgs.effects.bryarWallImpactEffect, origin, normal );
+		break;
+	}
+}
+
+/*
+-------------------------
+FX_BryarAltHitPlayer
+-------------------------
+*/
+void FX_BryarAltHitPlayer( vec3_t origin, vec3_t normal, qboolean humanoid )
+{
+	theFxScheduler.PlayEffect( cgs.effects.bryarFleshImpactEffect, origin, normal );
+}
diff --git a/code/cgame/FX_Concussion.cpp b/code/cgame/FX_Concussion.cpp
new file mode 100644
index 0000000..90ff22d
--- /dev/null
+++ b/code/cgame/FX_Concussion.cpp
@@ -0,0 +1,98 @@
+// Concussion Rifle Weapon
+
+// this line must stay at top so the whole PCH thing works...
+#include "cg_headers.h"
+
+//#include "cg_local.h"
+#include "cg_media.h"
+#include "FxScheduler.h"
+
+/*
+---------------------------
+FX_ConcProjectileThink
+---------------------------
+*/
+
+void FX_ConcProjectileThink( centity_t *cent, const struct weaponInfo_s *weapon )
+{
+	vec3_t forward;
+
+	if ( VectorNormalize2( cent->currentState.pos.trDelta, forward ) == 0.0f )
+	{
+		forward[2] = 1.0f;
+	}
+
+	theFxScheduler.PlayEffect( "concussion/shot", cent->lerpOrigin, forward );
+}
+
+/*
+---------------------------
+FX_ConcHitWall
+---------------------------
+*/
+
+void FX_ConcHitWall( vec3_t origin, vec3_t normal )
+{
+	theFxScheduler.PlayEffect( "concussion/explosion", origin, normal );
+}
+
+/*
+---------------------------
+FX_ConcHitPlayer
+---------------------------
+*/
+
+void FX_ConcHitPlayer( vec3_t origin, vec3_t normal, qboolean humanoid )
+{
+	theFxScheduler.PlayEffect( "concussion/explosion", origin, normal );
+}
+
+/*
+---------------------------
+FX_ConcAltShot
+---------------------------
+*/
+static vec3_t WHITE	={1.0f,1.0f,1.0f};
+
+void FX_ConcAltShot( vec3_t start, vec3_t end )
+{
+	//"concussion/beam"
+	FX_AddLine( -1, start, end, 0.1f, 10.0f, 0.0f, 
+							1.0f, 0.0f, 0.0f,
+							WHITE, WHITE, 0.0f,
+							175, cgi_R_RegisterShader( "gfx/effects/blueLine" ), 
+							0, FX_SIZE_LINEAR | FX_ALPHA_LINEAR );
+
+	vec3_t	BRIGHT={0.75f,0.5f,1.0f};
+
+	// add some beef
+	FX_AddLine( -1, start, end, 0.1f, 7.0f, 0.0f, 
+						1.0f, 0.0f, 0.0f,
+						BRIGHT, BRIGHT, 0.0f,
+						150, cgi_R_RegisterShader( "gfx/misc/whiteline2" ), 
+						0, FX_SIZE_LINEAR | FX_ALPHA_LINEAR );
+}
+
+
+/*
+---------------------------
+FX_ConcAltMiss
+---------------------------
+*/
+
+void FX_ConcAltMiss( vec3_t origin, vec3_t normal )
+{
+	vec3_t pos, c1, c2;
+
+	VectorMA( origin, 4.0f, normal, c1 );
+	VectorCopy( c1, c2 );
+	c1[2] += 4;
+	c2[2] += 12;
+	
+	VectorAdd( origin, normal, pos );
+	pos[2] += 28;
+
+	FX_AddBezier( origin, pos, c1, vec3_origin, c2, vec3_origin, 6.0f, 6.0f, 0.0f, 0.0f, 0.2f, 0.5f, WHITE, WHITE, 0.0f, 4000, cgi_R_RegisterShader( "gfx/effects/smokeTrail" ), FX_ALPHA_WAVE );
+
+	theFxScheduler.PlayEffect( "concussion/alt_miss", origin, normal );
+}
\ No newline at end of file
diff --git a/code/cgame/FX_DEMP2.cpp b/code/cgame/FX_DEMP2.cpp
new file mode 100644
index 0000000..e6c98e9
--- /dev/null
+++ b/code/cgame/FX_DEMP2.cpp
@@ -0,0 +1,92 @@
+// DEMP2 Weapon
+
+// this line must stay at top so the whole PCH thing works...
+#include "cg_headers.h"
+
+//#include "cg_local.h"
+#include "cg_media.h"
+#include "FxScheduler.h"
+#include "FxUtil.h"
+
+/*
+---------------------------
+FX_DEMP2_ProjectileThink
+---------------------------
+*/
+
+void FX_DEMP2_ProjectileThink( centity_t *cent, const struct weaponInfo_s *weapon )
+{
+	vec3_t forward;
+
+	if ( VectorNormalize2( cent->currentState.pos.trDelta, forward ) == 0.0f )
+	{
+		forward[2] = 1.0f;
+	}
+
+//	theFxScheduler.PlayEffect( "demp2/shot", cent->lerpOrigin, forward );
+//	theFxScheduler.PlayEffect( "demp2/shot2", cent->lerpOrigin, forward );
+	theFxScheduler.PlayEffect( "demp2/projectile", cent->lerpOrigin, forward );
+}
+
+/*
+---------------------------
+FX_DEMP2_HitWall
+---------------------------
+*/
+
+void FX_DEMP2_HitWall( vec3_t origin, vec3_t normal )
+{
+	theFxScheduler.PlayEffect( "demp2/wall_impact", origin, normal );
+}
+
+/*
+---------------------------
+FX_DEMP2_HitPlayer
+---------------------------
+*/
+
+void FX_DEMP2_HitPlayer( vec3_t origin, vec3_t normal, qboolean humanoid )
+{
+	theFxScheduler.PlayEffect( "demp2/flesh_impact", origin, normal );
+}
+
+/*
+---------------------------
+FX_DEMP2_AltProjectileThink
+---------------------------
+*/
+
+void FX_DEMP2_AltProjectileThink( centity_t *cent, const struct weaponInfo_s *weapon )
+{
+	vec3_t forward;
+
+	if ( VectorNormalize2( cent->currentState.pos.trDelta, forward ) == 0.0f )
+	{
+		forward[2] = 1.0f;
+	}
+
+	theFxScheduler.PlayEffect( "demp2/projectile", cent->lerpOrigin, forward );
+}
+
+//---------------------------------------------
+void FX_DEMP2_AltDetonate( vec3_t org, float size )
+{
+	localEntity_t	*ex;
+
+	ex = CG_AllocLocalEntity();
+	ex->leType = LE_FADE_SCALE_MODEL;
+	memset( &ex->refEntity, 0, sizeof( refEntity_t ));
+
+	ex->refEntity.renderfx |= RF_VOLUMETRIC;
+
+	ex->startTime = cg.time;
+	ex->endTime = ex->startTime + 1300;
+	
+	ex->radius = size;
+	ex->refEntity.customShader = cgi_R_RegisterShader( "gfx/effects/demp2shell" );
+
+	ex->refEntity.hModel = cgi_R_RegisterModel( "models/items/sphere.md3" );
+	VectorCopy( org, ex->refEntity.origin );
+		
+	ex->color[0] = ex->color[1] = ex->color[2] = 255.0f;
+}
diff --git a/code/cgame/FX_Disruptor.cpp b/code/cgame/FX_Disruptor.cpp
new file mode 100644
index 0000000..74dba47
--- /dev/null
+++ b/code/cgame/FX_Disruptor.cpp
@@ -0,0 +1,98 @@
+// Disruptor Weapon
+
+// this line must stay at top so the whole PCH thing works...
+#include "cg_headers.h"
+
+//#include "cg_local.h"
+#include "cg_media.h"
+#include "FxScheduler.h"
+
+
+/*
+---------------------------
+FX_DisruptorMainShot
+---------------------------
+*/
+static vec3_t WHITE	={1.0f,1.0f,1.0f};
+
+void FX_DisruptorMainShot( vec3_t start, vec3_t end )
+{
+	FX_AddLine( -1, start, end, 0.1f, 4.0f, 0.0f, 
+							1.0f, 0.0f, 0.0f,
+							WHITE, WHITE, 0.0f,
+							120, cgi_R_RegisterShader( "gfx/effects/redLine" ), 
+							0, FX_SIZE_LINEAR | FX_ALPHA_LINEAR );
+}
+
+
+/*
+---------------------------
+FX_DisruptorAltShot
+---------------------------
+*/
+void FX_DisruptorAltShot( vec3_t start, vec3_t end, qboolean fullCharge )
+{
+	FX_AddLine( -1, start, end, 0.1f, 10.0f, 0.0f, 
+							1.0f, 0.0f, 0.0f,
+							WHITE, WHITE, 0.0f,
+							175, cgi_R_RegisterShader( "gfx/effects/redLine" ), 
+							0, FX_SIZE_LINEAR | FX_ALPHA_LINEAR );
+
+	if ( fullCharge )
+	{
+		vec3_t	YELLER={0.8f,0.7f,0.0f};
+
+		// add some beef
+		FX_AddLine( -1, start, end, 0.1f, 7.0f, 0.0f, 
+							1.0f, 0.0f, 0.0f,
+							YELLER, YELLER, 0.0f,
+							150, cgi_R_RegisterShader( "gfx/misc/whiteline2" ), 
+							0, FX_SIZE_LINEAR | FX_ALPHA_LINEAR );
+	}
+}
+
+/*
+---------------------------
+FX_DisruptorAltMiss
+---------------------------
+*/
+
+void FX_DisruptorAltMiss( vec3_t origin, vec3_t normal )
+{
+	vec3_t pos, c1, c2;
+
+	VectorMA( origin, 4.0f, normal, c1 );
+	VectorCopy( c1, c2 );
+	c1[2] += 4;
+	c2[2] += 12;
+	
+	VectorAdd( origin, normal, pos );
+	pos[2] += 28;
+
+	FX_AddBezier( origin, pos, c1, vec3_origin, c2, vec3_origin, 6.0f, 6.0f, 0.0f, 0.0f, 0.2f, 0.5f, WHITE, WHITE, 0.0f, 4000, cgi_R_RegisterShader( "gfx/effects/smokeTrail" ), FX_ALPHA_WAVE );
+
+	theFxScheduler.PlayEffect( "disruptor/alt_miss", origin, normal );
+}
+
+/*
+---------------------------
+FX_KothosBeam
+---------------------------
+*/
+void FX_KothosBeam( vec3_t start, vec3_t end )
+{
+	FX_AddLine( -1, start, end, 0.1f, 10.0f, 0.0f, 
+							1.0f, 0.0f, 0.0f,
+							WHITE, WHITE, 0.0f,
+							175, cgi_R_RegisterShader( "gfx/misc/dr1" ), 
+							0, FX_SIZE_LINEAR | FX_ALPHA_LINEAR );
+
+	vec3_t	YELLER={0.8f,0.7f,0.0f};
+
+	// add some beef
+	FX_AddLine( -1, start, end, 0.1f, 7.0f, 0.0f, 
+						1.0f, 0.0f, 0.0f,
+						YELLER, YELLER, 0.0f,
+						150, cgi_R_RegisterShader( "gfx/misc/whiteline2" ), 
+						0, FX_SIZE_LINEAR | FX_ALPHA_LINEAR );
+}
diff --git a/code/cgame/FX_Emplaced.cpp b/code/cgame/FX_Emplaced.cpp
new file mode 100644
index 0000000..ba95237
--- /dev/null
+++ b/code/cgame/FX_Emplaced.cpp
@@ -0,0 +1,146 @@
+// Emplaced Weapon
+
+// this line must stay at top so the whole PCH thing works...
+#include "cg_headers.h"
+
+//#include "cg_local.h"
+#include "cg_media.h"
+#include "FxScheduler.h"
+
+/*
+---------------------------
+FX_EmplacedProjectileThink
+---------------------------
+*/
+
+void FX_EmplacedProjectileThink( centity_t *cent, const struct weaponInfo_s *weapon )
+{
+	vec3_t forward;
+
+	if ( VectorNormalize2( cent->gent->s.pos.trDelta, forward ) == 0.0f )
+	{
+		if ( VectorNormalize2( cent->currentState.pos.trDelta, forward ) == 0.0f )
+		{
+			forward[2] = 1.0f;
+		}
+	}
+
+	// hack the scale of the forward vector if we were just fired or bounced...this will shorten up the tail for a split second so tails don't clip so harshly
+	int dif = cg.time - cent->gent->s.pos.trTime;
+
+	if ( dif < 75 )
+	{
+		if ( dif < 0 )
+		{
+			dif = 0;
+		}
+
+		float scale = ( dif / 75.0f ) * 0.95f + 0.05f;
+
+		VectorScale( forward, scale, forward );
+	}
+
+	// If tie-fighter missle use green shot.
+	if ( cent->currentState.weapon == WP_TIE_FIGHTER )
+	{
+		theFxScheduler.PlayEffect( "ships/imp_blastershot", cent->lerpOrigin, forward );
+	}
+	else
+	{
+		if ( cent->gent && cent->gent->owner && cent->gent->owner->activator && cent->gent->owner->activator->s.number > 0 )
+		{
+			// NPC's do short shot
+			if ( cent->gent->alt_fire )
+			{
+				theFxScheduler.PlayEffect( "eweb/shotNPC", cent->lerpOrigin, forward );
+			}
+			else
+			{
+				theFxScheduler.PlayEffect( "emplaced/shotNPC", cent->lerpOrigin, forward );
+			}
+		}
+		else
+		{
+			// players do long shot
+			if ( cent->gent && cent->gent->alt_fire )
+			{
+				theFxScheduler.PlayEffect( "eweb/shotNPC", cent->lerpOrigin, forward );
+			}
+			else
+			{
+				theFxScheduler.PlayEffect( "emplaced/shot", cent->lerpOrigin, forward );
+			}
+		}
+	}
+}
+
+/*
+---------------------------
+FX_EmplacedHitWall
+---------------------------
+*/
+
+void FX_EmplacedHitWall( vec3_t origin, vec3_t normal, qboolean eweb )
+{
+	if ( eweb )
+	{
+		theFxScheduler.PlayEffect( "eweb/wall_impact", origin, normal );
+	}
+	else
+	{
+		theFxScheduler.PlayEffect( "emplaced/wall_impact", origin, normal );
+	}
+}
+
+/*
+---------------------------
+FX_EmplacedHitPlayer
+---------------------------
+*/
+
+void FX_EmplacedHitPlayer( vec3_t origin, vec3_t normal, qboolean eweb )
+{
+	if ( eweb )
+	{
+		theFxScheduler.PlayEffect( "eweb/flesh_impact", origin, normal );
+	}
+	else
+	{
+		theFxScheduler.PlayEffect( "emplaced/wall_impact", origin, normal );
+	}
+}
+/*
+---------------------------
+FX_TurretProjectileThink
+---------------------------
+*/
+
+void FX_TurretProjectileThink( centity_t *cent, const struct weaponInfo_s *weapon )
+{
+	vec3_t forward;
+
+	if ( VectorNormalize2( cent->gent->s.pos.trDelta, forward ) == 0.0f )
+	{
+		if ( VectorNormalize2( cent->currentState.pos.trDelta, forward ) == 0.0f )
+		{
+			forward[2] = 1.0f;
+		}
+	}
+
+	// hack the scale of the forward vector if we were just fired or bounced...this will shorten up the tail for a split second so tails don't clip so harshly
+	int dif = cg.time - cent->gent->s.pos.trTime;
+
+	if ( dif < 75 )
+	{
+		if ( dif < 0 )
+		{
+			dif = 0;
+		}
+
+		float scale = ( dif / 75.0f ) * 0.95f + 0.05f;
+
+		VectorScale( forward, scale, forward );
+	}
+
+	theFxScheduler.PlayEffect( "turret/shot", cent->lerpOrigin, forward );
+}
\ No newline at end of file
diff --git a/code/cgame/FX_Flechette.cpp b/code/cgame/FX_Flechette.cpp
new file mode 100644
index 0000000..8e784b1
--- /dev/null
+++ b/code/cgame/FX_Flechette.cpp
@@ -0,0 +1,73 @@
+// Golan Arms Flechette Weapon
+
+// this line must stay at top so the whole PCH thing works...
+#include "cg_headers.h"
+
+//#include "cg_local.h"
+#include "cg_media.h"
+#include "FxScheduler.h"
+
+/*
+-------------------------
+FX_FlechetteProjectileThink
+-------------------------
+*/
+
+void FX_FlechetteProjectileThink( centity_t *cent, const struct weaponInfo_s *weapon )
+{
+	vec3_t forward;
+
+	EvaluateTrajectoryDelta( &cent->gent->s.pos, cg.time, forward );
+
+	if ( VectorNormalize( forward ) == 0.0f )
+	{
+		forward[2] = 1.0f;
+	}
+
+	theFxScheduler.PlayEffect( cgs.effects.flechetteShotEffect, cent->lerpOrigin, forward );
+}
+
+/*
+-------------------------
+FX_FlechetteWeaponHitWall
+-------------------------
+*/
+void FX_FlechetteWeaponHitWall( vec3_t origin, vec3_t normal )
+{
+	theFxScheduler.PlayEffect( cgs.effects.flechetteShotDeathEffect, origin, normal );
+}
+
+/*
+-------------------------
+FX_BlasterWeaponHitPlayer
+-------------------------
+*/
+void FX_FlechetteWeaponHitPlayer( vec3_t origin, vec3_t normal, qboolean humanoid )
+{
+//	if ( humanoid )
+//	{
+		theFxScheduler.PlayEffect( cgs.effects.flechetteFleshImpactEffect, origin, normal );
+//	}
+//	else
+//	{
+//		theFxScheduler.PlayEffect( "blaster/droid_impact", origin, normal );
+//	}
+}
+
+/*
+-------------------------
+FX_FlechetteProjectileThink
+-------------------------
+*/
+
+void FX_FlechetteAltProjectileThink( centity_t *cent, const struct weaponInfo_s *weapon )
+{
+	vec3_t forward;
+
+	if ( VectorNormalize2( cent->currentState.pos.trDelta, forward ) == 0.0f )
+	{
+		forward[2] = 1.0f;
+	}
+
+	theFxScheduler.PlayEffect( cgs.effects.flechetteAltShotEffect, cent->lerpOrigin, forward );
+}
\ No newline at end of file
diff --git a/code/cgame/FX_HeavyRepeater.cpp b/code/cgame/FX_HeavyRepeater.cpp
new file mode 100644
index 0000000..61492b6
--- /dev/null
+++ b/code/cgame/FX_HeavyRepeater.cpp
@@ -0,0 +1,92 @@
+// Heavy Repeater Weapon
+
+// this line must stay at top so the whole PCH thing works...
+#include "cg_headers.h"
+
+//#include "cg_local.h"
+#include "cg_media.h"
+#include "FxScheduler.h"
+
+/*
+---------------------------
+FX_RepeaterProjectileThink
+---------------------------
+*/
+
+void FX_RepeaterProjectileThink( centity_t *cent, const struct weaponInfo_s *weapon )
+{
+	vec3_t forward;
+
+	if ( VectorNormalize2( cent->currentState.pos.trDelta, forward ) == 0.0f )
+	{
+		forward[2] = 1.0f;
+	}
+
+	theFxScheduler.PlayEffect( "repeater/projectile", cent->lerpOrigin, forward );
+}
+
+/*
+------------------------
+FX_RepeaterHitWall
+------------------------
+*/
+
+void FX_RepeaterHitWall( vec3_t origin, vec3_t normal )
+{
+	theFxScheduler.PlayEffect( "repeater/wall_impact", origin, normal );
+}
+
+/*
+------------------------
+FX_RepeaterHitPlayer
+------------------------
+*/
+
+void FX_RepeaterHitPlayer( vec3_t origin, vec3_t normal, qboolean humanoid )
+{
+	theFxScheduler.PlayEffect( "repeater/wall_impact", origin, normal );
+//	theFxScheduler.PlayEffect( "repeater/flesh_impact", origin, normal );
+}
+
+/*
+------------------------------
+FX_RepeaterAltProjectileThink
+-----------------------------
+*/
+
+void FX_RepeaterAltProjectileThink( centity_t *cent, const struct weaponInfo_s *weapon )
+{
+	vec3_t forward;
+
+	if ( VectorNormalize2( cent->currentState.pos.trDelta, forward ) == 0.0f )
+	{
+		forward[2] = 1.0f;
+	}
+
+	theFxScheduler.PlayEffect( "repeater/alt_projectile", cent->lerpOrigin, forward );
+//	theFxScheduler.PlayEffect( "repeater/alt_projectile", cent->lerpOrigin, forward );
+}
+
+/*
+------------------------
+FX_RepeaterAltHitWall
+------------------------
+*/
+
+void FX_RepeaterAltHitWall( vec3_t origin, vec3_t normal )
+{
+	theFxScheduler.PlayEffect( "repeater/concussion", origin, normal );
+//	theFxScheduler.PlayEffect( "repeater/alt_wall_impact2", origin, normal );
+}
+
+/*
+------------------------
+FX_RepeaterAltHitPlayer
+------------------------
+*/
+
+void FX_RepeaterAltHitPlayer( vec3_t origin, vec3_t normal, qboolean humanoid )
+{
+	theFxScheduler.PlayEffect( "repeater/concussion", origin );
+//	theFxScheduler.PlayEffect( "repeater/alt_wall_impact2", origin, normal );
+}
\ No newline at end of file
diff --git a/code/cgame/FX_NoghriShot.cpp b/code/cgame/FX_NoghriShot.cpp
new file mode 100644
index 0000000..59c194c
--- /dev/null
+++ b/code/cgame/FX_NoghriShot.cpp
@@ -0,0 +1,72 @@
+// Noghri Rifle
+
+// this line must stay at top so the whole PCH thing works...
+#include "cg_headers.h"
+
+#include "cg_local.h"
+#include "cg_media.h"
+#include "FxScheduler.h"
+
+/*
+-------------------------
+FX_NoghriShotProjectileThink
+-------------------------
+*/
+
+void FX_NoghriShotProjectileThink( centity_t *cent, const struct weaponInfo_s *weapon )
+{
+	vec3_t forward;
+
+	if ( VectorNormalize2( cent->gent->s.pos.trDelta, forward ) == 0.0f )
+	{
+		if ( VectorNormalize2( cent->currentState.pos.trDelta, forward ) == 0.0f )
+		{
+			forward[2] = 1.0f;
+		}
+	}
+
+	// hack the scale of the forward vector if we were just fired or bounced...this will shorten up the tail for a split second so tails don't clip so harshly
+	int dif = cg.time - cent->gent->s.pos.trTime;
+
+	if ( dif < 75 )
+	{
+		if ( dif < 0 )
+		{
+			dif = 0;
+		}
+
+		float scale = ( dif / 75.0f ) * 0.95f + 0.05f;
+
+		VectorScale( forward, scale, forward );
+	}
+
+	theFxScheduler.PlayEffect( "noghri_stick/shot", cent->lerpOrigin, forward );
+}
+
+/*
+-------------------------
+FX_NoghriShotWeaponHitWall
+-------------------------
+*/
+void FX_NoghriShotWeaponHitWall( vec3_t origin, vec3_t normal )
+{
+	theFxScheduler.PlayEffect( "noghri_stick/flesh_impact", origin, normal );//no "noghri/wall_impact"?
+}
+/*
+-------------------------
+FX_NoghriShotWeaponHitPlayer
+-------------------------
+*/
+void FX_NoghriShotWeaponHitPlayer( gentity_t *hit, vec3_t origin, vec3_t normal, qboolean humanoid )
+{
+	//temporary? just testing out the damage skin stuff -rww
+	/*
+	if ( hit && hit->client && hit->ghoul2.size() )
+	{
+		CG_AddGhoul2Mark(cgs.media.bdecal_burnmark1, flrand(3.5, 4.0), origin, normal, hit->s.number,
+			hit->client->ps.origin, hit->client->renderInfo.legsYaw, hit->ghoul2, hit->s.modelScale, Q_irand(10000, 13000));
+	}
+	*/
+        
+	theFxScheduler.PlayEffect( "noghri_stick/flesh_impact", origin, normal );
+}
diff --git a/code/cgame/FX_RocketLauncher.cpp b/code/cgame/FX_RocketLauncher.cpp
new file mode 100644
index 0000000..e390cc4
--- /dev/null
+++ b/code/cgame/FX_RocketLauncher.cpp
@@ -0,0 +1,66 @@
+// Rocket Launcher Weapon
+
+// this line must stay at top so the whole PCH thing works...
+#include "cg_headers.h"
+
+//#include "cg_local.h"
+#include "cg_media.h"
+#include "FxScheduler.h"
+
+/*
+---------------------------
+FX_RocketProjectileThink
+---------------------------
+*/
+
+void FX_RocketProjectileThink( centity_t *cent, const struct weaponInfo_s *weapon )
+{
+	vec3_t forward;
+
+	if ( VectorNormalize2( cent->currentState.pos.trDelta, forward ) == 0.0f )
+	{
+		forward[2] = 1.0f;
+	}
+
+	theFxScheduler.PlayEffect( "rocket/shot", cent->lerpOrigin, forward );
+}
+
+/*
+---------------------------
+FX_RocketHitWall
+---------------------------
+*/
+
+void FX_RocketHitWall( vec3_t origin, vec3_t normal )
+{
+	theFxScheduler.PlayEffect( "rocket/explosion", origin, normal );
+}
+
+/*
+---------------------------
+FX_RocketHitPlayer
+---------------------------
+*/
+
+void FX_RocketHitPlayer( vec3_t origin, vec3_t normal, qboolean humanoid )
+{
+	theFxScheduler.PlayEffect( "rocket/explosion", origin, normal );
+}
+
+/*
+---------------------------
+FX_RocketAltProjectileThink
+---------------------------
+*/
+
+void FX_RocketAltProjectileThink( centity_t *cent, const struct weaponInfo_s *weapon )
+{
+	vec3_t forward;
+
+	if ( VectorNormalize2( cent->currentState.pos.trDelta, forward ) == 0.0f )
+	{
+		forward[2] = 1.0f;
+	}
+
+	theFxScheduler.PlayEffect( "rocket/shot", cent->lerpOrigin, forward );
+}
diff --git a/code/cgame/FX_TuskenShot.cpp b/code/cgame/FX_TuskenShot.cpp
new file mode 100644
index 0000000..35b8a7c
--- /dev/null
+++ b/code/cgame/FX_TuskenShot.cpp
@@ -0,0 +1,70 @@
+// Tusken Rifle
+
+// this line must stay at top so the whole PCH thing works...
+#include "cg_headers.h"
+
+#include "cg_local.h"
+#include "cg_media.h"
+#include "FxScheduler.h"
+
+/*
+-------------------------
+FX_TuskenShotProjectileThink
+-------------------------
+*/
+
+void FX_TuskenShotProjectileThink( centity_t *cent, const struct weaponInfo_s *weapon )
+{
+	vec3_t forward;
+
+	if ( VectorNormalize2( cent->gent->s.pos.trDelta, forward ) == 0.0f )
+	{
+		if ( VectorNormalize2( cent->currentState.pos.trDelta, forward ) == 0.0f )
+		{
+			forward[2] = 1.0f;
+		}
+	}
+
+	// hack the scale of the forward vector if we were just fired or bounced...this will shorten up the tail for a split second so tails don't clip so harshly
+	int dif = cg.time - cent->gent->s.pos.trTime;
+
+	if ( dif < 75 )
+	{
+		if ( dif < 0 )
+		{
+			dif = 0;
+		}
+
+		float scale = ( dif / 75.0f ) * 0.95f + 0.05f;
+
+		VectorScale( forward, scale, forward );
+	}
+
+	theFxScheduler.PlayEffect( "tusken/shot", cent->lerpOrigin, forward );
+}
+
+/*
+-------------------------
+FX_TuskenShotWeaponHitWall
+-------------------------
+*/
+void FX_TuskenShotWeaponHitWall( vec3_t origin, vec3_t normal )
+{
+	theFxScheduler.PlayEffect( "tusken/hitwall", origin, normal );
+}
+/*
+-------------------------
+FX_TuskenShotWeaponHitPlayer
+-------------------------
+*/
+void FX_TuskenShotWeaponHitPlayer( gentity_t *hit, vec3_t origin, vec3_t normal, qboolean humanoid )
+{
+	//temporary? just testing out the damage skin stuff -rww
+	if ( hit && hit->client && hit->ghoul2.size() )
+	{
+		CG_AddGhoul2Mark(cgs.media.bdecal_burnmark1, flrand(3.5, 4.0), origin, normal, hit->s.number,
+			hit->client->ps.origin, hit->client->renderInfo.legsYaw, hit->ghoul2, hit->s.modelScale, Q_irand(10000, 13000));
+	}
+        
+	theFxScheduler.PlayEffect( "tusken/hit", origin, normal );
+}
diff --git a/code/cgame/FxParsing.cpp b/code/cgame/FxParsing.cpp
new file mode 100644
index 0000000..3f8b977
--- /dev/null
+++ b/code/cgame/FxParsing.cpp
@@ -0,0 +1,5 @@
+// this include must remain at the top of every FXxxxx.CPP file
+#include "common_headers.h"
+
+
+
diff --git a/code/cgame/FxParsing.h b/code/cgame/FxParsing.h
new file mode 100644
index 0000000..0d9914a
--- /dev/null
+++ b/code/cgame/FxParsing.h
@@ -0,0 +1,6 @@
+#pragma once
+#if !defined(FX_PARSING_H_INC)
+#define FX_PARSING_H_INC
+
+
+#endif // FX_PARSING_H
diff --git a/code/cgame/FxPrimitives.cpp b/code/cgame/FxPrimitives.cpp
new file mode 100644
index 0000000..2bfe9d1
--- /dev/null
+++ b/code/cgame/FxPrimitives.cpp
@@ -0,0 +1,2289 @@
+// this include must remain at the top of every CPP file
+#include "common_headers.h"
+
+#if !defined(FX_SCHEDULER_H_INC)
+	#include "FxScheduler.h"
+#endif
+
+#include "cg_media.h"
+
+#pragma warning(disable: 4035)
+static long myftol( float f ) 
+{
+	static int tmp;
+	__asm fld f
+	__asm fistp tmp
+	__asm mov eax, tmp
+}
+#pragma warning(default: 4035)
+
+extern int drawnFx;
+extern int mParticles;
+extern int mOParticles;
+extern int mLines;
+extern int mTails;
+
+extern vmCvar_t	fx_expensivePhysics;
+
+// Helper function
+//-------------------------
+void ClampVec( vec3_t dat, byte *res )
+{
+	int r;
+
+	// clamp all vec values, then multiply the normalized values by 255 to maximize the result
+	for ( int i = 0; i < 3; i++ )
+	{
+		r = myftol(dat[i] * 255.0f);
+
+		if ( r < 0 )
+		{
+			r = 0;
+		}
+		else if ( r > 255 )
+		{
+			r = 255;
+		}
+
+		res[i] = (unsigned char)r;
+	}	
+}
+
+void GetOrigin( int clientID, vec3_t org )
+{
+	if ( clientID >=0 )
+	{
+		centity_t *cent = &cg_entities[clientID];
+
+		if ( cent && cent->gent && cent->gent->client )
+		{
+			VectorCopy( cent->gent->client->renderInfo.muzzlePoint, org );
+		}
+	}
+}
+
+void GetDir( int clientID, vec3_t org )
+{
+	if ( clientID >=0 )
+	{
+		centity_t *cent = &cg_entities[clientID];
+
+		if ( cent && cent->gent && cent->gent->client )
+		{
+			VectorCopy( cent->gent->client->renderInfo.muzzleDir, org );
+		}
+	}
+}
+
+//--------------------------
+//
+// Base Effect Class
+//
+//--------------------------
+
+
+//--------------------------
+//
+// Derived Particle Class
+//
+//--------------------------
+
+void CParticle::Die()
+{
+	if ( mFlags & FX_DEATH_RUNS_FX && !(mFlags & FX_KILL_ON_IMPACT) )
+	{
+		vec3_t	norm;
+
+		// Man, this just seems so, like, uncool and stuff...
+		VectorSet( norm, crandom(), crandom(), crandom());
+		VectorNormalize( norm );
+
+		theFxScheduler.PlayEffect( mDeathFxID, mOrigin1, norm );
+	}
+}
+
+//----------------------------
+bool CParticle::Cull()
+{
+	vec3_t	dir;
+
+	// Get the direction to the view
+	VectorSubtract( mOrigin1, cg.refdef.vieworg, dir );
+
+	// Check if it's behind the viewer
+	if ( (DotProduct( cg.refdef.viewaxis[0], dir )) < 0 )
+	{
+		return true;
+	}
+
+	float len = VectorLengthSquared( dir );
+
+	// Can't be too close
+	if ( len < 16 * 16 )
+	{
+		return true;
+	}
+
+	return false;
+}
+
+//----------------------------
+void CParticle::Draw()
+{
+	if ( mFlags & FX_DEPTH_HACK )
+	{
+		// Not sure if first person needs to be set, but it can't hurt?
+		mRefEnt.renderfx |= RF_DEPTHHACK;
+	}
+
+	// Add our refEntity to the scene
+	VectorCopy( mOrigin1, mRefEnt.origin );
+	theFxHelper.AddFxToScene( &mRefEnt );
+
+	drawnFx++;
+	mParticles++;
+}
+
+//----------------------------
+// Update
+//----------------------------
+bool CParticle::Update()
+{
+	// Game pausing can cause dumb time things to happen, so kill the effect in this instance
+	if ( mTimeStart > theFxHelper.mTime )
+	{
+		return false;
+	}
+
+	if ( mFlags & FX_RELATIVE )
+	{
+		if ( mClientID < 0 || mClientID >= ENTITYNUM_WORLD )
+		{	// we are somehow not bolted even though the flag is on?
+			return false;
+		}
+
+		vec3_t	org;
+		vec3_t	ax[3];
+
+		// Get our current position and direction
+		if (mModelNum>=0 && mBoltNum>=0)	//bolt style
+		{
+			const centity_t &cent = cg_entities[mClientID];
+			if (cent.gent->ghoul2.IsValid())
+			{
+				if (!theFxHelper.GetOriginAxisFromBolt(cent, mModelNum, mBoltNum, org, ax))
+				{	//could not get bolt
+					return false;
+				}
+			}
+		}
+		else
+		{//fixme change this to bolt style...
+			vec3_t dir, ang;
+
+			GetOrigin( mClientID, org );
+			GetDir( mClientID, dir );
+		
+			vectoangles( dir, ang );
+			AngleVectors( ang, ax[0], ax[1], ax[2] );
+		}
+		vec3_t 	realVel, realAccel;
+
+		VectorMA( org, mOrgOffset[0], ax[0], org );
+		VectorMA( org, mOrgOffset[1], ax[1], org );
+		VectorMA( org, mOrgOffset[2], ax[2], org );
+
+		const float	time = (theFxHelper.mTime - mTimeStart) * 0.001f;
+		// calc the real velocity and accel vectors
+		VectorScale( ax[0], mVel[0], realVel );
+		VectorMA( realVel, mVel[1], ax[1], realVel );
+		VectorMA( realVel, mVel[2], ax[2], realVel );
+		realVel[2] += 0.5f * mGravity * time;
+
+		VectorScale( ax[0], mAccel[0], realAccel );
+		VectorMA( realAccel, mAccel[1], ax[1], realAccel );
+		VectorMA( realAccel, mAccel[2], ax[2], realAccel );
+
+		// Get our real velocity at the current time, taking into account the effects of acceleartion.  NOTE: not sure if this is even 100% correct math-wise
+		VectorMA( realVel, time, realAccel, realVel );
+
+		// Now move us to where we should be at the given time
+		VectorMA( org, time, realVel, mOrigin1 );
+		
+	}
+	else if (( mTimeStart < theFxHelper.mTime ) && UpdateOrigin() == false )
+	{
+		// we are marked for death
+		return false;
+	}
+
+	if ( !Cull())
+	{
+		UpdateSize();
+		UpdateRGB();
+		UpdateAlpha();
+		UpdateRotation();
+
+		Draw();
+	}
+
+	return true;
+}
+
+//----------------------------
+// Update Origin
+//----------------------------
+bool CParticle::UpdateOrigin()
+{
+	vec3_t	new_origin;
+//	float	ftime, time2;
+
+	UpdateVelocity();
+
+	// Calc the time differences
+//	ftime = theFxHelper.mFrameTime * 0.001f;
+	//time2 = ftime * ftime * 0.5f;
+//	time2=0;
+
+	// Predict the new position
+	new_origin[0] = mOrigin1[0] + theFxHelper.mFloatFrameTime * mVel[0];// + time2 * mVel[0];
+	new_origin[1] = mOrigin1[1] + theFxHelper.mFloatFrameTime * mVel[1];// + time2 * mVel[1];
+	new_origin[2] = mOrigin1[2] + theFxHelper.mFloatFrameTime * mVel[2];// + time2 * mVel[2];
+
+	// Only perform physics if this object is tagged to do so
+	if ( (mFlags & FX_APPLY_PHYSICS) )
+	{
+		bool solid;
+
+		if ( (mFlags&FX_EXPENSIVE_PHYSICS) 
+			&& fx_expensivePhysics.integer )
+		{
+			solid = true; // by setting this to true, we force a real trace to happen
+		}
+		else
+		{
+			// if this returns solid, we need to do a trace
+			solid = !!(CG_PointContents( new_origin, ENTITYNUM_WORLD ) & ( MASK_SHOT | CONTENTS_WATER ));
+		}
+
+		if ( solid )
+		{
+			trace_t	trace;
+			float	dot;
+
+			if ( mFlags & FX_USE_BBOX )
+			{
+				if (mFlags & FX_GHOUL2_TRACE)
+				{
+					theFxHelper.G2Trace( &trace, mOrigin1, mMin, mMax, new_origin, ENTITYNUM_NONE, ( MASK_SHOT | CONTENTS_WATER ) );
+				}
+				else
+				{
+					theFxHelper.Trace( &trace, mOrigin1, mMin, mMax, new_origin, -1, ( MASK_SHOT | CONTENTS_WATER ) );
+				}
+			}
+			else
+			{
+				if (mFlags & FX_GHOUL2_TRACE)
+				{
+					theFxHelper.G2Trace( &trace, mOrigin1, NULL, NULL, new_origin, ENTITYNUM_NONE, ( MASK_SHOT | CONTENTS_WATER ) );
+				}
+				else
+				{
+					theFxHelper.Trace( &trace, mOrigin1, NULL, NULL, new_origin, -1, ( MASK_SHOT | CONTENTS_WATER ) );
+				}
+			}
+
+			// Hit something
+			if ( trace.fraction < 1.0f )//|| trace.startsolid || trace.allsolid )
+			{
+				if ( mFlags & FX_IMPACT_RUNS_FX && !(trace.surfaceFlags & SURF_NOIMPACT ))
+				{
+					theFxScheduler.PlayEffect( mImpactFxID, trace.endpos, trace.plane.normal );
+				}
+
+				if ( mFlags & FX_KILL_ON_IMPACT	)
+				{
+					// time to die
+					return false;
+				}
+
+				VectorMA( mVel, theFxHelper.mFloatFrameTime * trace.fraction, mAccel, mVel );
+
+				dot = DotProduct( mVel, trace.plane.normal );
+
+				VectorMA( mVel, -2 * dot, trace.plane.normal, mVel );
+
+				VectorScale( mVel, mElasticity, mVel );
+
+				// If the velocity is too low, make it stop moving, rotating, and turn off physics to avoid
+				//	doing expensive operations when they aren't needed
+				if ( trace.plane.normal[2] > 0 && mVel[2] < 4 )
+				{
+					VectorClear( mVel );
+					VectorClear( mAccel );
+
+					mFlags &= ~(FX_APPLY_PHYSICS|FX_IMPACT_RUNS_FX);
+				}
+
+				// Set the origin to the exact impact point
+				VectorCopy( trace.endpos, mOrigin1 );
+				return true;
+			}
+		}
+	}
+
+	// No physics were done to this object, move it
+	VectorCopy( new_origin, mOrigin1 );
+
+	return true;
+}
+
+//----------------------------
+// Update Size
+//----------------------------
+void CParticle::UpdateSize()
+{
+	// completely biased towards start if it doesn't get overridden
+	float	perc1 = 1.0f, perc2 = 1.0f; 
+
+	if ( (mFlags & FX_SIZE_LINEAR) )
+	{ 
+		// calculate element biasing
+		perc1 = 1.0f - (float)(theFxHelper.mTime - mTimeStart) 
+						/ (float)(mTimeEnd - mTimeStart);
+	}
+
+	// We can combine FX_LINEAR with _either_ FX_NONLINEAR, FX_WAVE, or FX_CLAMP
+	if (( mFlags & FX_SIZE_PARM_MASK ) == FX_SIZE_NONLINEAR )
+	{
+		if ( theFxHelper.mTime > mSizeParm )
+		{ 
+			// get percent done, using parm as the start of the non-linear fade
+			perc2 = 1.0f - (float)(theFxHelper.mTime - mSizeParm) 
+							/ (float)(mTimeEnd - mSizeParm);
+		}
+
+		if ( mFlags & FX_SIZE_LINEAR )
+		{
+			// do an even blend
+			perc1 = perc1 * 0.5f + perc2 * 0.5f;
+		}
+		else
+		{ 
+			// just copy it over...sigh
+			perc1 = perc2;
+		}
+	}
+	else if (( mFlags & FX_SIZE_PARM_MASK ) == FX_SIZE_WAVE )
+	{ 
+		// wave gen, with parm being the frequency multiplier
+		perc1 = perc1 * (float)cos( (theFxHelper.mTime - mTimeStart) * mSizeParm );
+	}
+	else if (( mFlags & FX_SIZE_PARM_MASK ) == FX_SIZE_CLAMP )
+	{
+		if ( theFxHelper.mTime < mSizeParm )
+		{ 
+			// get percent done, using parm as the start of the non-linear fade
+			perc2 = (float)(mSizeParm - theFxHelper.mTime) 
+							/ (float)(mSizeParm - mTimeStart);
+		}
+		else
+		{
+			perc2 = 0.0f; // make it full size??
+		}
+
+		if ( (mFlags & FX_SIZE_LINEAR) )
+		{ 
+			// do an even blend
+			perc1 = perc1 * 0.5f + perc2 * 0.5f;
+		}
+		else
+		{ 
+			// just copy it over...sigh
+			perc1 = perc2;
+		}
+	}
+
+	// If needed, RAND can coexist with linear and either non-linear or wave.
+	if (( mFlags & FX_SIZE_RAND ))
+	{ 
+		// Random simply modulates the existing value
+		perc1 = random() * perc1;
+	}
+
+	mRefEnt.radius = (mSizeStart * perc1) + (mSizeEnd * (1.0f - perc1));
+}
+
+//----------------------------
+// Update RGB
+//----------------------------
+void CParticle::UpdateRGB()
+{
+	// completely biased towards start if it doesn't get overridden
+	float	perc1 = 1.0f, perc2 = 1.0f; 
+	vec3_t	res;
+
+	if ( (mFlags & FX_RGB_LINEAR) )
+	{ 
+		// calculate element biasing
+		perc1 = 1.0f - (float)( theFxHelper.mTime - mTimeStart ) 
+						/ (float)( mTimeEnd - mTimeStart );
+	}
+
+	// We can combine FX_LINEAR with _either_ FX_NONLINEAR, FX_WAVE, or FX_CLAMP
+	if (( mFlags & FX_RGB_PARM_MASK ) == FX_RGB_NONLINEAR )
+	{
+		if ( theFxHelper.mTime > mRGBParm )
+		{ 
+			// get percent done, using parm as the start of the non-linear fade
+			perc2 = 1.0f - (float)( theFxHelper.mTime - mRGBParm ) 
+							/ (float)( mTimeEnd - mRGBParm );
+		}
+
+		if ( (mFlags & FX_RGB_LINEAR) )
+		{ 
+			// do an even blend
+			perc1 = perc1 * 0.5f + perc2 * 0.5f;
+		}
+		else
+		{ 
+			// just copy it over...sigh
+			perc1 = perc2;
+		}
+	}
+	else if (( mFlags & FX_RGB_PARM_MASK ) == FX_RGB_WAVE )
+	{ 
+		// wave gen, with parm being the frequency multiplier
+		perc1 = perc1 * (float)cos(( theFxHelper.mTime - mTimeStart ) * mRGBParm );
+	}
+	else if (( mFlags & FX_RGB_PARM_MASK ) == FX_RGB_CLAMP )
+	{
+		if ( theFxHelper.mTime < mRGBParm )
+		{ 
+			// get percent done, using parm as the start of the non-linear fade
+			perc2 = (float)(mRGBParm - theFxHelper.mTime) 
+							/ (float)(mRGBParm - mTimeStart);
+		}
+		else
+		{
+			perc2 = 0.0f; // make it full size??
+		}
+
+		if (( mFlags & FX_RGB_LINEAR ))
+		{ 
+			// do an even blend
+			perc1 = perc1 * 0.5f + perc2 * 0.5f;
+		}
+		else
+		{ 
+			// just copy it over...sigh
+			perc1 = perc2;
+		}
+	}
+
+	// If needed, RAND can coexist with linear and either non-linear or wave.
+	if (( mFlags & FX_RGB_RAND ))
+	{ 
+		// Random simply modulates the existing value
+		perc1 = random() * perc1;
+	}
+
+	// Now get the correct color 
+	VectorScale( mRGBStart, perc1, res );
+	VectorMA( res, (1.0f - perc1), mRGBEnd, mRefEnt.angles ); // angles is a temp storage, will get clamped to a byte in the UpdateAlpha section
+}
+
+
+//----------------------------
+// Update Alpha
+//----------------------------
+void CParticle::UpdateAlpha()
+{
+	// completely biased towards start if it doesn't get overridden
+	float	perc1 = 1.0f, perc2 = 1.0f;
+
+	if ( mFlags & FX_ALPHA_LINEAR )
+	{ 
+		// calculate element biasing
+		perc1 = 1.0f - (float)(theFxHelper.mTime - mTimeStart) 
+						/ (float)(mTimeEnd - mTimeStart);
+	}
+
+	// We can combine FX_LINEAR with _either_ FX_NONLINEAR, FX_WAVE, or FX_CLAMP
+	if (( mFlags & FX_ALPHA_PARM_MASK ) == FX_ALPHA_NONLINEAR )
+	{
+		if ( theFxHelper.mTime > mAlphaParm )
+		{ 
+			// get percent done, using parm as the start of the non-linear fade
+			perc2 = 1.0f - (float)(theFxHelper.mTime - mAlphaParm) 
+							/ (float)(mTimeEnd - mAlphaParm);
+		}
+
+		if ( mFlags & FX_ALPHA_LINEAR )
+		{ 
+			// do an even blend
+			perc1 = perc1 * 0.5f + perc2 * 0.5f;
+		}
+		else
+		{ 
+			// just copy it over...sigh
+			perc1 = perc2;
+		}
+	}
+	else if (( mFlags & FX_ALPHA_PARM_MASK ) == FX_ALPHA_WAVE )
+	{ 
+		// wave gen, with parm being the frequency multiplier
+		perc1 = perc1 * (float)cos( (theFxHelper.mTime - mTimeStart) * mAlphaParm );
+	}
+	else if (( mFlags & FX_ALPHA_PARM_MASK ) == FX_ALPHA_CLAMP )
+	{
+		if ( theFxHelper.mTime < mAlphaParm )
+		{ 
+			// get percent done, using parm as the start of the non-linear fade
+			perc2 = (float)(mAlphaParm - theFxHelper.mTime) 
+							/ (float)(mAlphaParm - mTimeStart);
+		}
+		else
+		{
+			perc2 = 0.0f; // make it full size??
+		}
+
+		if ( mFlags & FX_ALPHA_LINEAR )
+		{ 
+			// do an even blend
+			perc1 = perc1 * 0.5f + perc2 * 0.5f;
+		}
+		else
+		{ 
+			// just copy it over...sigh
+			perc1 = perc2;
+		}
+	}
+
+	perc1 = (mAlphaStart * perc1) + (mAlphaEnd * (1.0f - perc1));
+
+	// We should be in the right range, but clamp to ensure
+	if ( perc1 < 0.0f )
+	{
+		perc1 = 0.0f;
+	}
+	else if ( perc1 > 1.0f )
+	{
+		perc1 = 1.0f;
+	}
+
+	// If needed, RAND can coexist with linear and either non-linear or wave.
+	if ( (mFlags & FX_ALPHA_RAND) )
+	{ 
+		// Random simply modulates the existing value
+		perc1 = random() * perc1;
+	}
+
+	if ( mFlags & FX_USE_ALPHA )
+	{
+		// should use this when using art that has an alpha channel
+		 ClampVec( mRefEnt.angles, (byte*)(&mRefEnt.shaderRGBA) );
+		 mRefEnt.shaderRGBA[3] = (byte)(perc1 * 0xff);
+	}
+	else
+	{
+		// Modulate the rgb fields by the alpha value to do the fade, works fine for additive blending
+		VectorScale( mRefEnt.angles, perc1, mRefEnt.angles );
+		ClampVec( mRefEnt.angles, (byte*)(&mRefEnt.shaderRGBA) );
+	}
+}
+
+//--------------------------------
+//
+// Derived Oriented Particle Class
+//
+//--------------------------------
+
+
+//----------------------------
+bool COrientedParticle::Cull()
+{
+	vec3_t	dir;
+
+	// Get the direction to the view
+	VectorSubtract( mOrigin1, cg.refdef.vieworg, dir );
+
+	// Check if it's behind the viewer
+	if ( (DotProduct( cg.refdef.viewaxis[0], dir )) < 0 )
+	{
+		return true;
+	}
+
+	float len = VectorLengthSquared( dir );
+
+	// Can't be too close
+	if ( len < 24 * 24 )
+	{
+		return true;
+	}
+
+	return false;
+}
+
+//----------------------------
+void COrientedParticle::Draw()
+{
+	if ( mFlags & FX_DEPTH_HACK )
+	{
+		// Not sure if first person needs to be set
+		mRefEnt.renderfx |= RF_DEPTHHACK;
+	}
+
+	// Add our refEntity to the scene
+	VectorCopy( mOrigin1, mRefEnt.origin );
+	VectorCopy( mNormal, mRefEnt.axis[0] );
+	theFxHelper.AddFxToScene( &mRefEnt );
+
+	drawnFx++;
+	mOParticles++;
+}
+
+//----------------------------
+// Update
+//----------------------------
+bool COrientedParticle::Update()
+{
+	// Game pausing can cause dumb time things to happen, so kill the effect in this instance
+	if ( mTimeStart > theFxHelper.mTime )
+	{
+		return false;
+	}
+		
+	if ( mFlags & FX_RELATIVE )
+	{
+		if ( mClientID < 0 || mClientID >= ENTITYNUM_WORLD )
+		{	// we are somehow not bolted even though the flag is on?
+			return false;
+		}
+
+		vec3_t	org;
+		vec3_t	ax[3];
+
+		// Get our current position and direction
+		if (mModelNum>=0 && mBoltNum>=0)	//bolt style
+		{
+			const centity_t &cent = cg_entities[mClientID];
+			if (cent.gent->ghoul2.IsValid())
+			{
+				if (!theFxHelper.GetOriginAxisFromBolt(cent, mModelNum, mBoltNum, org, ax))
+				{	//could not get bolt
+					return false;
+				}
+			}
+		}
+		else
+		{//fixme change this to bolt style...
+			vec3_t dir, ang;
+
+			GetOrigin( mClientID, org );
+			GetDir( mClientID, dir );
+		
+			vectoangles( dir, ang );
+			AngleVectors( ang, ax[0], ax[1], ax[2] );
+		}
+		vec3_t 	realVel, realAccel;
+
+		VectorMA( org, mOrgOffset[0], ax[0], org );
+		VectorMA( org, mOrgOffset[1], ax[1], org );
+		VectorMA( org, mOrgOffset[2], ax[2], org );
+
+		const float	time = (theFxHelper.mTime - mTimeStart) * 0.001f;
+		// calc the real velocity and accel vectors
+		VectorScale( ax[0], mVel[0], realVel );
+		VectorMA( realVel, mVel[1], ax[1], realVel );
+		VectorMA( realVel, mVel[2], ax[2], realVel );
+		realVel[2] += 0.5f * mGravity * time;
+
+		VectorScale( ax[0], mAccel[0], realAccel );
+		VectorMA( realAccel, mAccel[1], ax[1], realAccel );
+		VectorMA( realAccel, mAccel[2], ax[2], realAccel );
+
+		// Get our real velocity at the current time, taking into account the effects of acceleartion.  NOTE: not sure if this is even 100% correct math-wise
+		VectorMA( realVel, time, realAccel, realVel );
+
+		// Now move us to where we should be at the given time
+		VectorMA( org, time, realVel, mOrigin1 );
+
+		//use the normalOffset and add that to the actual normal of the bolt
+		//NOTE: not tested!!!
+		vec3_t	boltAngles, offsetAngles, transformedAngles;
+		vectoangles( ax[0], boltAngles );
+		vectoangles( mNormalOffset, offsetAngles );
+		VectorAdd( boltAngles, offsetAngles, transformedAngles );
+		AngleVectors( transformedAngles, mNormal, NULL, NULL );
+	}
+	else if (( mTimeStart < theFxHelper.mTime ) && UpdateOrigin() == false )
+	{
+		// we are marked for death
+		return false;
+	}
+
+	if ( !Cull())
+	{
+		UpdateSize();
+		UpdateRGB();
+		UpdateAlpha();
+		UpdateRotation();
+
+		Draw();
+	}
+
+	return true;
+}
+
+
+//----------------------------
+//
+// Derived Line Class
+//
+//----------------------------
+
+//----------------------------
+void CLine::Draw()
+{
+	if ( mFlags & FX_DEPTH_HACK )
+	{
+		// Not sure if first person needs to be set, but it can't hurt?
+		mRefEnt.renderfx |= RF_DEPTHHACK;
+	}
+
+	VectorCopy( mOrigin1, mRefEnt.origin );
+	VectorCopy( mOrigin2, mRefEnt.oldorigin );
+
+	theFxHelper.AddFxToScene( &mRefEnt );
+
+	drawnFx++;
+	mLines++;
+}
+
+//----------------------------
+bool CLine::Update()
+{
+	// Game pausing can cause dumb time things to happen, so kill the effect in this instance
+	if ( mTimeStart > theFxHelper.mTime )
+	{
+		return false;
+	}
+		
+	if ( mFlags & FX_RELATIVE )
+	{
+		if ( mClientID < 0 || mClientID >= ENTITYNUM_WORLD )
+		{	// we are somehow not bolted even though the flag is on?
+			return false;
+		}
+
+		vec3_t	ax[3] = {0};
+		// Get our current position and direction
+		if (mModelNum>=0 && mBoltNum>=0)	//bolt style
+		{
+			const centity_t &cent = cg_entities[mClientID];
+			if (cent.gent->ghoul2.IsValid())
+			{
+				if (!theFxHelper.GetOriginAxisFromBolt(cent, mModelNum, mBoltNum, mOrigin1, ax))
+				{	//could not get bolt
+					return false;
+				}
+			}
+		}
+		else
+		{//fixme change this to bolt style...
+			// Get our current position and direction
+			GetOrigin( mClientID, mOrigin1 );
+			GetDir( mClientID, ax[0] );
+		}
+
+		VectorAdd(mOrigin1, mOrgOffset, mOrigin1);	//add the offset to the bolt point
+		
+		vec3_t	end;
+		trace_t	trace;
+		if ( mFlags & FX_APPLY_PHYSICS )
+		{
+			VectorMA( mOrigin1, 2048, ax[0], end );
+
+			theFxHelper.Trace( &trace, mOrigin1, NULL, NULL, end, mClientID, MASK_SHOT );
+
+			VectorCopy( trace.endpos, mOrigin2 );
+
+			if ( mImpactFxID > 0 )
+			{
+				theFxScheduler.PlayEffect( mImpactFxID, trace.endpos, trace.plane.normal );
+			}
+		}
+		else
+		{
+			VectorMA( mOrigin1, mVel[0], ax[0], mOrigin2 );
+			VectorMA( mOrigin2, mVel[1], ax[1], mOrigin2 );
+			VectorMA( mOrigin2, mVel[2], ax[2], mOrigin2 );
+		}
+	}
+
+	UpdateSize();
+	UpdateRGB();
+	UpdateAlpha();
+
+	Draw();
+
+	return true;
+}
+
+
+//----------------------------
+//
+// Derived Electricity Class
+//
+//----------------------------
+void CElectricity::Initialize()
+{
+	mRefEnt.frame = random() * 1265536;
+	mRefEnt.endTime = cg.time + (mTimeEnd - mTimeStart);
+
+	if ( mFlags & FX_DEPTH_HACK )
+	{
+		mRefEnt.renderfx |= RF_DEPTHHACK;
+	}
+
+	if ( mFlags & FX_BRANCH )
+	{
+		mRefEnt.renderfx |= RF_FORKED;	
+	}
+
+	if ( mFlags & FX_TAPER )
+	{
+		mRefEnt.renderfx |= RF_TAPERED;
+	}
+
+	if ( mFlags & FX_GROW )
+	{
+		mRefEnt.renderfx |= RF_GROW;
+	}
+}
+
+//----------------------------
+void CElectricity::Draw()
+{
+	VectorCopy( mOrigin1, mRefEnt.origin );
+	VectorCopy( mOrigin2, mRefEnt.oldorigin );
+	mRefEnt.angles[0] = mChaos;
+	mRefEnt.angles[1] = mTimeEnd - mTimeStart;
+
+	theFxHelper.AddFxToScene( &mRefEnt );
+
+	drawnFx++;
+	mLines++; // NOT REALLY A LINE!
+}
+
+//----------------------------
+bool CElectricity::Update()
+{
+	// Game pausing can cause dumb time things to happen, so kill the effect in this instance
+	if ( mTimeStart > theFxHelper.mTime )
+	{
+		return false;
+	}
+		
+	//Handle Relative and Bolted Effects
+	if ( mFlags & FX_RELATIVE )
+	{//add mOrgOffset to bolt position and store in mOrigin1
+		if ( mClientID < 0 || mClientID >= ENTITYNUM_WORLD )
+		{	// we are somehow not bolted even though the flag is on?
+			return false;
+		}
+
+		vec3_t	ax[3] = {0};
+		// Get our current position and direction
+		if (mModelNum>=0 && mBoltNum>=0)	//bolt style
+		{
+			const centity_t &cent = cg_entities[mClientID];
+			if (cent.gent->ghoul2.IsValid())
+			{
+				if (!theFxHelper.GetOriginAxisFromBolt(cent, mModelNum, mBoltNum, mOrigin1, ax))
+				{	//could not get bolt
+					return false;
+				}
+			}
+		}
+		else
+		{//fixme change this to bolt style...
+			// Get our current position and direction
+			GetOrigin( mClientID, mOrigin1 );
+			GetDir( mClientID, ax[0] );
+		}
+
+		//add the offset to the bolt point
+		VectorAdd(mOrigin1, mOrgOffset, mOrigin1);
+		
+		//add the endpoint offset to the start to get the final offset
+		VectorMA( mOrigin1, mVel[0], ax[0], mOrigin2 );
+		VectorMA( mOrigin2, mVel[1], ax[1], mOrigin2 );
+		VectorMA( mOrigin2, mVel[2], ax[2], mOrigin2 );
+	}
+	//else just uses the static origin1 & origin2 as start and end
+	UpdateSize();
+	UpdateRGB();
+	UpdateAlpha();
+
+	Draw();
+
+	return true;
+}
+
+
+//----------------------------
+//
+// Derived Tail Class
+//
+//----------------------------
+bool CTail::Cull()
+{
+	vec3_t	dir;
+
+	// Get the direction to the view
+	VectorSubtract( mOrigin1, cg.refdef.vieworg, dir );
+
+	// Check if it's behind the viewer
+	if ( (DotProduct( cg.refdef.viewaxis[0], dir )) < 0 )
+	{
+		return true;
+	}
+
+	return false;
+}
+
+//----------------------------
+void CTail::Draw()
+{
+	if ( mFlags & FX_DEPTH_HACK )
+	{
+		// Not sure if first person needs to be set
+		mRefEnt.renderfx |= RF_DEPTHHACK;
+	}
+
+	VectorCopy( mOrigin1, mRefEnt.origin );
+
+	theFxHelper.AddFxToScene( &mRefEnt );
+
+	drawnFx++;
+	mTails++;
+}
+
+//----------------------------
+bool CTail::Update()
+{
+	// Game pausing can cause dumb time things to happen, so kill the effect in this instance
+	if ( mTimeStart > theFxHelper.mTime )
+	{
+		return false;
+	}
+	
+	if ( !fx_freeze.integer )
+	{
+		VectorCopy( mOrigin1, mOldOrigin );
+	}
+
+	if ( mFlags & FX_RELATIVE )
+	{
+		if ( mClientID < 0 || mClientID >= ENTITYNUM_WORLD )
+		{	// we are somehow not bolted even though the flag is on?
+			return false;
+		}
+
+		vec3_t	org;
+		vec3_t	ax[3];
+		if (mModelNum>=0 && mBoltNum>=0)	//bolt style
+		{
+			const centity_t &cent = cg_entities[mClientID];
+			if (cent.gent->ghoul2.IsValid())
+			{
+				if (!theFxHelper.GetOriginAxisFromBolt(cent, mModelNum, mBoltNum, org, ax))
+				{	//could not get bolt
+					return false;
+				}
+			}
+		}
+		else
+		{
+			vec3_t	dir;
+			// Get our current position and direction
+			GetOrigin( mClientID, org );
+			GetDir( mClientID, dir );
+			vec3_t ang;
+
+			vectoangles( dir, ang );
+			AngleVectors( ang, ax[0], ax[1], ax[2] );
+		}
+
+		vec3_t 	realVel, realAccel;
+
+		VectorMA( org, mOrgOffset[0], ax[0], org );
+		VectorMA( org, mOrgOffset[1], ax[1], org );
+		VectorMA( org, mOrgOffset[2], ax[2], org );
+
+		// calc the real velocity and accel vectors
+		// FIXME: if you want right and up movement in addition to the forward movement, you'll have to convert dir into a set of perp. axes and do some extra work
+		VectorScale( ax[0], mVel[0], realVel );
+		VectorMA( realVel, mVel[1], ax[1], realVel );
+		VectorMA( realVel, mVel[2], ax[2], realVel );
+
+		VectorScale( ax[0], mAccel[0], realAccel );
+		VectorMA( realAccel, mAccel[1], ax[1], realAccel );
+		VectorMA( realAccel, mAccel[2], ax[2], realAccel );
+
+		const float	time = (theFxHelper.mTime - mTimeStart) * 0.001f;
+
+		// Get our real velocity at the current time, taking into account the effects of acceleration.  NOTE: not sure if this is even 100% correct math-wise
+		VectorMA( realVel, time, realAccel, realVel );
+
+		// Now move us to where we should be at the given time
+		VectorMA( org, time, realVel, mOrigin1 );
+
+		// Just calc an old point some time in the past, doesn't really matter when
+		VectorMA( org, (time - 0.003f), realVel, mOldOrigin );
+	}
+	else if (( mTimeStart < theFxHelper.mTime ) && UpdateOrigin() == false )
+	{
+		// we are marked for death
+		return false;
+	}
+
+	if ( !Cull() )
+	{
+		UpdateSize();
+		UpdateLength();
+		UpdateRGB();
+		UpdateAlpha();
+
+		CalcNewEndpoint();
+
+		Draw();
+	}
+
+	return true;
+}
+
+//----------------------------
+void CTail::UpdateLength()
+{
+	// completely biased towards start if it doesn't get overridden
+	float	perc1 = 1.0f, perc2 = 1.0f; 
+
+	if ( mFlags & FX_LENGTH_LINEAR )
+	{ 
+		// calculate element biasing
+		perc1 = 1.0f - (float)(theFxHelper.mTime - mTimeStart) 
+						/ (float)(mTimeEnd - mTimeStart);
+	}
+
+	// We can combine FX_LINEAR with _either_ FX_NONLINEAR or FX_WAVE
+	if (( mFlags & FX_LENGTH_PARM_MASK ) == FX_LENGTH_NONLINEAR )
+	{
+		if ( theFxHelper.mTime > mLengthParm )
+		{ 
+			// get percent done, using parm as the start of the non-linear fade
+			perc2 = 1.0f - (float)(theFxHelper.mTime - mLengthParm) 
+							/ (float)(mTimeEnd - mLengthParm);
+		}
+
+		if ( mFlags & FX_LENGTH_LINEAR )
+		{ 
+			// do an even blend
+			perc1 = perc1 * 0.5f + perc2 * 0.5f;
+		}
+		else
+		{ 
+			// just copy it over...sigh
+			perc1 = perc2;
+		}
+	}
+	else if (( mFlags & FX_LENGTH_PARM_MASK ) == FX_LENGTH_WAVE )
+	{ 
+		// wave gen, with parm being the frequency multiplier
+		perc1 = perc1 * (float)cos( (theFxHelper.mTime - mTimeStart) * mLengthParm );
+	}
+	else if (( mFlags & FX_LENGTH_PARM_MASK ) == FX_LENGTH_CLAMP )
+	{
+		if ( theFxHelper.mTime < mLengthParm )
+		{ 
+			// get percent done, using parm as the start of the non-linear fade
+			perc2 = (float)(mLengthParm - theFxHelper.mTime) 
+							/ (float)(mLengthParm - mTimeStart);
+		}
+		else
+		{
+			perc2 = 0.0f; // make it full size??
+		}
+
+		if ( mFlags & FX_LENGTH_LINEAR )
+		{ 
+			// do an even blend
+			perc1 = perc1 * 0.5f + perc2 * 0.5f;
+		}
+		else
+		{ 
+			// just copy it over...sigh
+			perc1 = perc2;
+		}
+	}
+
+	// If needed, RAND can coexist with linear and either non-linear or wave.
+	if ( mFlags & FX_LENGTH_RAND )
+	{ 
+		// Random simply modulates the existing value
+		perc1 = random() * perc1;
+	}
+
+	mLength = (mLengthStart * perc1) + (mLengthEnd * (1.0f - perc1));
+}
+
+//----------------------------
+void CTail::CalcNewEndpoint()
+{
+	vec3_t temp;
+
+	// FIXME:  Hmmm, this looks dumb when physics are on and a bounce happens
+	VectorSubtract( mOldOrigin, mOrigin1, temp );
+
+	// I wish we didn't have to do a VectorNormalize every frame.....
+	VectorNormalize( temp );
+
+	VectorMA( mOrigin1, mLength, temp, mRefEnt.oldorigin );
+}
+
+
+//----------------------------
+//
+// Derived Cylinder Class
+//
+//----------------------------
+void CCylinder::Draw()
+{
+	if ( mFlags & FX_DEPTH_HACK )
+	{
+		// Not sure if first person needs to be set, but it can't hurt?
+		mRefEnt.renderfx |= RF_DEPTHHACK;
+	}
+
+	VectorCopy( mOrigin1, mRefEnt.origin );
+	VectorMA( mOrigin1, mLength, mRefEnt.axis[0], mRefEnt.oldorigin );
+
+	theFxHelper.AddFxToScene( &mRefEnt );
+
+	drawnFx++;
+}
+
+//----------------------------
+// Update Size2
+//----------------------------
+void CCylinder::UpdateSize2()
+{
+	// completely biased towards start if it doesn't get overridden
+	float	perc1 = 1.0f, perc2 = 1.0f; 
+
+	if ( mFlags & FX_SIZE2_LINEAR )
+	{ 
+		// calculate element biasing
+		perc1 = 1.0f - (float)(theFxHelper.mTime - mTimeStart) 
+						/ (float)(mTimeEnd - mTimeStart);
+	}
+
+	// We can combine FX_LINEAR with _either_ FX_NONLINEAR or FX_WAVE
+	if (( mFlags & FX_SIZE2_PARM_MASK ) == FX_SIZE2_NONLINEAR )
+	{
+		if ( theFxHelper.mTime > mSize2Parm )
+		{ 
+			// get percent done, using parm as the start of the non-linear fade
+			perc2 = 1.0f - (float)(theFxHelper.mTime - mSize2Parm) 
+							/ (float)(mTimeEnd - mSize2Parm);
+		}
+
+		if ( (mFlags & FX_SIZE2_LINEAR) )
+		{ 
+			// do an even blend
+			perc1 = perc1 * 0.5f + perc2 * 0.5f;
+		}
+		else
+		{ 
+			// just copy it over...sigh
+			perc1 = perc2;
+		}
+	}
+	else if (( mFlags & FX_SIZE2_PARM_MASK ) == FX_SIZE2_WAVE )
+	{ 
+		// wave gen, with parm being the frequency multiplier
+		perc1 = perc1 * (float)cos( (theFxHelper.mTime - mTimeStart) * mSize2Parm );
+	}
+	else if (( mFlags & FX_SIZE2_PARM_MASK ) == FX_SIZE2_CLAMP )
+	{
+		if ( theFxHelper.mTime < mSize2Parm )
+		{ 
+			// get percent done, using parm as the start of the non-linear fade
+			perc2 = (float)(mSize2Parm - theFxHelper.mTime) 
+							/ (float)(mSize2Parm - mTimeStart);
+		}
+		else
+		{
+			perc2 = 0.0f; // make it full size??
+		}
+
+		if ( mFlags & FX_SIZE2_LINEAR )
+		{ 
+			// do an even blend
+			perc1 = perc1 * 0.5f + perc2 * 0.5f;
+		}
+		else
+		{ 
+			// just copy it over...sigh
+			perc1 = perc2;
+		}
+	}
+
+	// If needed, RAND can coexist with linear and either non-linear or wave.
+	if ( mFlags & FX_SIZE2_RAND )
+	{ 
+		// Random simply modulates the existing value
+		perc1 = random() * perc1;
+	}
+
+	mRefEnt.backlerp = (mSize2Start * perc1) + (mSize2End * (1.0f - perc1));
+}
+
+//----------------------------
+bool CCylinder::Update()
+{
+	// Game pausing can cause dumb time things to happen, so kill the effect in this instance
+	if ( mTimeStart > theFxHelper.mTime )
+	{
+		return false;
+	}
+		
+	if ( mFlags & FX_RELATIVE )
+	{
+		if ( mClientID < 0 || mClientID >= ENTITYNUM_WORLD )
+		{	// we are somehow not bolted even though the flag is on?
+			return false;
+		}
+
+		vec3_t	ax[3] = {0};
+		// Get our current position and direction
+		if (mModelNum>=0 && mBoltNum>=0)	//bolt style
+		{
+			const centity_t &cent = cg_entities[mClientID];
+			if (cent.gent->ghoul2.IsValid())
+			{
+				if (!theFxHelper.GetOriginAxisFromBolt(cent, mModelNum, mBoltNum, mOrigin1, ax))
+				{	//could not get bolt
+					return false;
+				}
+			}
+		}
+		else
+		{//fixme change this to bolt style...
+			// Get our current position and direction
+			GetOrigin( mClientID, mOrigin1 );
+			GetDir( mClientID, ax[0] );
+		}
+
+		VectorAdd(mOrigin1, mOrgOffset, mOrigin1);	//add the offset to the bolt point
+		
+		VectorCopy( ax[0], mRefEnt.axis[0] );
+		//FIXME: should mNormal be a modifier on the forward axis?
+		/*
+		VectorMA( mOrigin1, mNormal[0], ax[0], mOrigin2 );
+		VectorMA( mOrigin2, mNormal[1], ax[1], mOrigin2 );
+		VectorMA( mOrigin2, mNormal[2], ax[2], mOrigin2 );
+		*/
+	}
+
+	UpdateSize();
+	UpdateSize2();
+	UpdateLength();
+	UpdateRGB();
+	UpdateAlpha();
+
+	Draw();
+
+	return true;
+}
+
+
+//----------------------------
+//
+// Derived Emitter Class
+//
+//----------------------------
+
+//----------------------------
+// Draw
+//----------------------------
+void CEmitter::Draw()
+{
+	// Emitters don't draw themselves, but they may need to add an attached model
+	if ( mFlags & FX_ATTACHED_MODEL )
+	{
+		mRefEnt.nonNormalizedAxes = qtrue;
+
+		VectorCopy( mOrigin1, mRefEnt.origin );
+
+		// ensure that we are sized
+		for ( int i = 0; i < 3; i++ )
+		{
+			VectorScale( mRefEnt.axis[i], mRefEnt.radius, mRefEnt.axis[i] );
+		}
+
+		theFxHelper.AddFxToScene( &mRefEnt );
+	}
+
+	// If we are emitting effects, we had better be careful because just calling it every cgame frame could
+	//	either choke up the effects system on a fast machine, or look really nasty on a low end one.
+	if ( mFlags & FX_EMIT_FX )
+	{
+		vec3_t	org, v;
+		float	ftime, time2, 
+				step;
+		int		i, t, dif;
+
+#define TRAIL_RATE		8 // we "think" at about a 60hz rate
+
+		// Pick a target step distance and square it
+		step = mDensity + crandom() * mVariance;
+		step *= step;
+
+		dif = 0;
+
+		for ( t = mOldTime; t <= theFxHelper.mTime; t += TRAIL_RATE ) 
+		{
+			dif += TRAIL_RATE;
+
+			// ?Not sure if it's better to update this before or after updating the origin
+			VectorMA( mOldVelocity, dif * 0.001f, mAccel, v );
+
+			// Calc the time differences
+			ftime = dif * 0.001f;
+			time2 = ftime * ftime * 0.5f;
+
+			// Predict the new position
+			for ( i = 0 ; i < 3 ; i++ ) 
+			{
+				org[i] = mOldOrigin[i] + ftime * v[i] + time2 * v[i];
+			}
+	
+			// Only perform physics if this object is tagged to do so
+			if ( (mFlags & FX_APPLY_PHYSICS) )
+			{
+				bool solid;
+
+				if ( (mFlags&FX_EXPENSIVE_PHYSICS) 
+					&& fx_expensivePhysics.integer )
+				{
+					solid = true; // by setting this to true, we force a real trace to happen
+				}
+				else
+				{
+					// if this returns solid, we need to do a trace
+					solid = !!(CG_PointContents( org, ENTITYNUM_WORLD ) & MASK_SHOT);
+				}
+
+				if ( solid )
+				{
+					trace_t	trace;
+
+					if ( mFlags & FX_USE_BBOX )
+					{
+						theFxHelper.Trace( &trace, mOldOrigin, mMin, mMax, org, -1, MASK_SHOT );
+					}
+					else
+					{
+						theFxHelper.Trace( &trace, mOldOrigin, NULL, NULL, org, -1, MASK_SHOT );
+					}
+
+					// Hit something
+					if ( trace.fraction < 1.0f || trace.startsolid || trace.allsolid )
+					{
+						return;
+					}
+				}
+			}
+
+			// Is it time to draw an effect?
+			if ( DistanceSquared( org, mOldOrigin ) >= step )
+			{ 
+				// Pick a new target step distance and square it
+				step = mDensity + crandom() * mVariance;
+				step *= step;
+
+				// We met the step criteria so, we should add in the effect
+				theFxScheduler.PlayEffect( mEmitterFxID, org, mRefEnt.axis );
+
+				VectorCopy( org, mOldOrigin );
+				VectorCopy( v, mOldVelocity );
+				dif = 0;
+				mOldTime = t;
+			}
+		}
+	}
+
+	drawnFx++;
+}
+
+//----------------------------
+bool CEmitter::Update()
+{
+	// Game pausing can cause dumb time things to happen, so kill the effect in this instance
+	if ( mTimeStart > theFxHelper.mTime )
+	{
+		return false;
+	}
+		
+	//FIXME: Handle Relative and Bolted Effects
+	/*
+	if ( mFlags & FX_RELATIVE )
+	{
+		if ( mClientID < 0 || mClientID >= ENTITYNUM_WORLD )
+		{	// we are somehow not bolted even though the flag is on?
+			return false;
+		}
+
+		// Get our current position and direction
+		if (mModelNum>=0 && mBoltNum>=0)	//bolt style
+		{
+		}
+	}
+	*/
+	// Use this to track if we've stopped moving
+	VectorCopy( mOrigin1, mOldOrigin );
+	VectorCopy( mVel, mOldVelocity );
+
+	if (( mTimeStart < theFxHelper.mTime ) && UpdateOrigin() == false )
+	{	// we are marked for death
+		return false;
+	}
+
+	// If the thing is no longer moving, kill the angle delta, but don't do it too quickly or it will
+	//	look very artificial.  Don't do it too slowly or it will look like there is no friction.
+	if ( VectorCompare( mOldOrigin, mOrigin1 ))
+	{
+		VectorScale( mAngleDelta, 0.6f, mAngleDelta );
+	}
+
+	UpdateAngles();
+	UpdateSize();
+//	UpdateRGB();	// had wanted to do something slick whereby an emitted effect could somehow inherit these
+//	UpdateAlpha();	// values, but it's not a priority right now.
+
+	Draw();
+
+	return true;
+}
+
+//----------------------------
+void CEmitter::UpdateAngles()
+{
+	VectorMA( mAngles, theFxHelper.mFrameTime * 0.01f, mAngleDelta, mAngles ); // was 0.001f, but then you really have to jack up the delta to even notice anything
+	AnglesToAxis( mAngles, mRefEnt.axis );
+}
+
+
+//--------------------------
+//
+// Derived Light Class
+//
+//--------------------------
+//----------------------------
+// Update
+//----------------------------
+bool CLight::Update()
+{
+	// Game pausing can cause dumb time things to happen, so kill the effect in this instance
+	if ( mTimeStart > theFxHelper.mTime )
+	{
+		return false;
+	}
+		
+	//FIXME: Handle Relative and Bolted Effects
+	/*
+	if ( mFlags & FX_RELATIVE )
+	{
+		if ( mClientID < 0 || mClientID >= ENTITYNUM_WORLD )
+		{	// we are somehow not bolted even though the flag is on?
+			return false;
+		}
+
+		// Get our current position and direction
+		if (mModelNum>=0 && mBoltNum>=0)	//bolt style
+		{
+		}
+	}
+	*/
+	UpdateSize();
+	UpdateRGB();
+
+	Draw();
+
+	return true;
+}
+
+//----------------------------
+// Update Size
+//----------------------------
+void CLight::UpdateSize()
+{
+	// completely biased towards start if it doesn't get overridden
+	float	perc1 = 1.0f, perc2 = 1.0f; 
+
+	if ( mFlags & FX_SIZE_LINEAR )
+	{ 
+		// calculate element biasing
+		perc1 = 1.0f - (float)(theFxHelper.mTime - mTimeStart) 
+						/ (float)(mTimeEnd - mTimeStart);
+	}
+
+	// We can combine FX_LINEAR with _either_ FX_NONLINEAR or FX_WAVE
+	if (( mFlags & FX_SIZE_PARM_MASK ) == FX_SIZE_NONLINEAR )
+	{
+		if ( theFxHelper.mTime > mSizeParm )
+		{ 
+			// get percent done, using parm as the start of the non-linear fade
+			perc2 = 1.0f - (float)(theFxHelper.mTime - mSizeParm) 
+							/ (float)(mTimeEnd - mSizeParm);
+		}
+
+		if ( (mFlags & FX_SIZE_LINEAR) )
+		{ 
+			// do an even blend
+			perc1 = perc1 * 0.5f + perc2 * 0.5f;
+		}
+		else
+		{ 
+			// just copy it over...sigh
+			perc1 = perc2;
+		}
+	}
+	else if (( mFlags & FX_SIZE_PARM_MASK ) == FX_SIZE_WAVE )
+	{ 
+		// wave gen, with parm being the frequency multiplier
+		perc1 = perc1 * (float)cos( (theFxHelper.mTime - mTimeStart) * mSizeParm );
+	}
+	else if (( mFlags & FX_SIZE_PARM_MASK ) == FX_SIZE_CLAMP )
+	{
+		if ( theFxHelper.mTime < mSizeParm )
+		{ 
+			// get percent done, using parm as the start of the non-linear fade
+			perc2 = (float)(mSizeParm - theFxHelper.mTime) 
+							/ (float)(mSizeParm - mTimeStart);
+		}
+		else
+		{
+			perc2 = 0.0f; // make it full size??
+		}
+
+		if ( mFlags & FX_SIZE_LINEAR )
+		{ 
+			// do an even blend
+			perc1 = perc1 * 0.5f + perc2 * 0.5f;
+		}
+		else
+		{ 
+			// just copy it over...sigh
+			perc1 = perc2;
+		}
+	}
+
+	// If needed, RAND can coexist with linear and either non-linear or wave.
+	if ( mFlags & FX_SIZE_RAND )
+	{ 
+		// Random simply modulates the existing value
+		perc1 = random() * perc1;
+	}
+
+	mRefEnt.radius = (mSizeStart * perc1) + (mSizeEnd * (1.0f - perc1));
+}
+
+//----------------------------
+// Update RGB
+//----------------------------
+void CLight::UpdateRGB()
+{
+	// completely biased towards start if it doesn't get overridden
+	float	perc1 = 1.0f, perc2 = 1.0f; 
+	vec3_t	res;
+
+	if ( mFlags & FX_RGB_LINEAR )
+	{ 
+		// calculate element biasing
+		perc1 = 1.0f - (float)( theFxHelper.mTime - mTimeStart ) 
+						/ (float)( mTimeEnd - mTimeStart );
+	}
+
+	// We can combine FX_LINEAR with _either_ FX_NONLINEAR or FX_WAVE
+	if (( mFlags & FX_RGB_PARM_MASK ) == FX_RGB_NONLINEAR )
+	{
+		if ( theFxHelper.mTime > mRGBParm )
+		{ 
+			// get percent done, using parm as the start of the non-linear fade
+			perc2 = 1.0f - (float)( theFxHelper.mTime - mRGBParm ) 
+							/ (float)( mTimeEnd - mRGBParm );
+		}
+
+		if ( mFlags & FX_RGB_LINEAR )
+		{ 
+			// do an even blend
+			perc1 = perc1 * 0.5f + perc2 * 0.5f;
+		}
+		else
+		{ 
+			// just copy it over...sigh
+			perc1 = perc2;
+		}
+	}
+	else if (( mFlags & FX_RGB_PARM_MASK ) == FX_RGB_WAVE )
+	{ 
+		// wave gen, with parm being the frequency multiplier
+		perc1 = perc1 * (float)cos(( theFxHelper.mTime - mTimeStart ) * mRGBParm );
+	}
+	else if (( mFlags & FX_RGB_PARM_MASK ) == FX_RGB_CLAMP )
+	{
+		if ( theFxHelper.mTime < mRGBParm )
+		{ 
+			// get percent done, using parm as the start of the non-linear fade
+			perc2 = (float)(mRGBParm - theFxHelper.mTime) 
+							/ (float)(mRGBParm - mTimeStart);
+		}
+		else
+		{
+			perc2 = 0.0f; // make it full size??
+		}
+
+		if ( mFlags & FX_RGB_LINEAR )
+		{ 
+			// do an even blend
+			perc1 = perc1 * 0.5f + perc2 * 0.5f;
+		}
+		else
+		{ 
+			// just copy it over...sigh
+			perc1 = perc2;
+		}
+	}
+
+	// If needed, RAND can coexist with linear and either non-linear or wave.
+	if ( mFlags & FX_RGB_RAND )
+	{ 
+		// Random simply modulates the existing value
+		perc1 = random() * perc1;
+	}
+
+	// Now get the correct color 
+	VectorScale( mRGBStart, perc1, res );
+
+	mRefEnt.lightingOrigin[0] = res[0] + ( 1.0f - perc1 ) * mRGBEnd[0];
+	mRefEnt.lightingOrigin[1] = res[1] + ( 1.0f - perc1 ) * mRGBEnd[1];
+	mRefEnt.lightingOrigin[2] = res[2] + ( 1.0f - perc1 ) * mRGBEnd[2];
+}
+
+
+//--------------------------
+//
+// Derived Trail Class
+//
+//--------------------------
+#define NEW_MUZZLE	0
+#define NEW_TIP		1
+#define OLD_TIP		2
+#define OLD_MUZZLE	3
+
+//----------------------------
+void CTrail::Draw()
+{
+	polyVert_t	verts[3];
+//	vec3_t		color;
+
+	// build the first tri out of the new muzzle...new tip...old muzzle
+	VectorCopy( mVerts[NEW_MUZZLE].origin, verts[0].xyz );
+	VectorCopy( mVerts[NEW_TIP].origin, verts[1].xyz );
+	VectorCopy( mVerts[OLD_MUZZLE].origin, verts[2].xyz );
+
+//	VectorScale( mVerts[NEW_MUZZLE].curRGB, mVerts[NEW_MUZZLE].curAlpha, color );
+	verts[0].modulate[0] = mVerts[NEW_MUZZLE].rgb[0];
+	verts[0].modulate[1] = mVerts[NEW_MUZZLE].rgb[1];
+	verts[0].modulate[2] = mVerts[NEW_MUZZLE].rgb[2];
+	verts[0].modulate[3] = mVerts[NEW_MUZZLE].alpha;
+
+//	VectorScale( mVerts[NEW_TIP].curRGB, mVerts[NEW_TIP].curAlpha, color );
+	verts[1].modulate[0] = mVerts[NEW_TIP].rgb[0];
+	verts[1].modulate[1] = mVerts[NEW_TIP].rgb[1];
+	verts[1].modulate[2] = mVerts[NEW_TIP].rgb[2];
+	verts[1].modulate[3] = mVerts[NEW_TIP].alpha;
+
+//	VectorScale( mVerts[OLD_MUZZLE].curRGB, mVerts[OLD_MUZZLE].curAlpha, color );
+	verts[2].modulate[0] = mVerts[OLD_MUZZLE].rgb[0];
+	verts[2].modulate[1] = mVerts[OLD_MUZZLE].rgb[1];
+	verts[2].modulate[2] = mVerts[OLD_MUZZLE].rgb[2];
+	verts[2].modulate[3] = mVerts[OLD_MUZZLE].alpha;
+
+	verts[0].st[0] = mVerts[NEW_MUZZLE].curST[0];
+	verts[0].st[1] = mVerts[NEW_MUZZLE].curST[1];
+	verts[1].st[0] = mVerts[NEW_TIP].curST[0];
+	verts[1].st[1] = mVerts[NEW_TIP].curST[1];
+	verts[2].st[0] = mVerts[OLD_MUZZLE].curST[0];
+	verts[2].st[1] = mVerts[OLD_MUZZLE].curST[1];
+
+	// Add this tri
+	theFxHelper.AddPolyToScene( mShader, 3, verts );
+
+	// build the second tri out of the old muzzle...old tip...new tip
+	VectorCopy( mVerts[OLD_MUZZLE].origin, verts[0].xyz );
+	VectorCopy( mVerts[OLD_TIP].origin, verts[1].xyz );
+	VectorCopy( mVerts[NEW_TIP].origin, verts[2].xyz );
+
+//	VectorScale( mVerts[OLD_MUZZLE].curRGB, mVerts[OLD_MUZZLE].curAlpha, color );
+	verts[0].modulate[0] = mVerts[OLD_MUZZLE].rgb[0];
+	verts[0].modulate[1] = mVerts[OLD_MUZZLE].rgb[1];
+	verts[0].modulate[2] = mVerts[OLD_MUZZLE].rgb[2];
+	verts[0].modulate[3] = mVerts[OLD_MUZZLE].alpha;
+
+//	VectorScale( mVerts[OLD_TIP].curRGB, mVerts[OLD_TIP].curAlpha, color );
+	verts[1].modulate[0] = mVerts[OLD_TIP].rgb[0];
+	verts[1].modulate[1] = mVerts[OLD_TIP].rgb[1];
+	verts[1].modulate[2] = mVerts[OLD_TIP].rgb[2];
+	verts[0].modulate[3] = mVerts[OLD_TIP].alpha;
+
+//	VectorScale( mVerts[NEW_TIP].curRGB, mVerts[NEW_TIP].curAlpha, color );
+	verts[2].modulate[0] = mVerts[NEW_TIP].rgb[0];
+	verts[2].modulate[1] = mVerts[NEW_TIP].rgb[1];
+	verts[2].modulate[2] = mVerts[NEW_TIP].rgb[2];
+	verts[0].modulate[3] = mVerts[NEW_TIP].alpha;
+
+	verts[0].st[0] = mVerts[OLD_MUZZLE].curST[0];
+	verts[0].st[1] = mVerts[OLD_MUZZLE].curST[1];
+	verts[1].st[0] = mVerts[OLD_TIP].curST[0];
+	verts[1].st[1] = mVerts[OLD_TIP].curST[1];
+	verts[2].st[0] = mVerts[NEW_TIP].curST[0];
+	verts[2].st[1] = mVerts[NEW_TIP].curST[1];
+
+	// Add this tri
+	theFxHelper.AddPolyToScene( mShader, 3, verts );
+
+	drawnFx++;
+}
+
+//----------------------------
+// Update
+//----------------------------
+bool CTrail::Update()
+{
+	// Game pausing can cause dumb time things to happen, so kill the effect in this instance
+	if ( mTimeStart > theFxHelper.mTime )
+	{
+		return false;
+	}
+		
+	//FIXME: Handle Relative and Bolted Effects
+	/*
+	if ( mFlags & FX_RELATIVE )
+	{
+		if ( mClientID < 0 || mClientID >= ENTITYNUM_WORLD )
+		{	// we are somehow not bolted even though the flag is on?
+			return false;
+		}
+
+		// Get our current position and direction
+		if (mModelNum>=0 && mBoltNum>=0)	//bolt style
+		{
+		}
+	}
+	*/
+	float perc = (float)(mTimeEnd - theFxHelper.mTime) / (float)(mTimeEnd - mTimeStart);
+
+	for ( int t = 0; t < 4; t++ )
+	{
+//		mVerts[t].curAlpha = mVerts[t].alpha * perc + mVerts[t].destAlpha * ( 1.0f - perc );
+//		if ( mVerts[t].curAlpha < 0.0f )
+//		{
+//			mVerts[t].curAlpha = 0.0f;
+//		}
+
+//		VectorScale( mVerts[t].rgb, perc, mVerts[t].curRGB );
+//		VectorMA( mVerts[t].curRGB, ( 1.0f - perc ), mVerts[t].destrgb, mVerts[t].curRGB );
+		mVerts[t].curST[0] = mVerts[t].ST[0] * perc + mVerts[t].destST[0] * ( 1.0f - perc );
+		if ( mVerts[t].curST[0] > 1.0f )
+		{
+			mVerts[t].curST[0] = 1.0f;
+		}
+		mVerts[t].curST[1] = mVerts[t].ST[1] * perc + mVerts[t].destST[1] * ( 1.0f - perc );
+	}
+
+	Draw();
+
+	return true;
+}
+
+
+//--------------------------
+//
+// Derived Poly Class
+//
+//--------------------------
+bool CPoly::Cull()
+{
+	vec3_t	dir;
+
+	// Get the direction to the view
+	VectorSubtract( mOrigin1, cg.refdef.vieworg, dir );
+
+	// Check if it's behind the viewer
+	if ( (DotProduct( cg.refdef.viewaxis[0], dir )) < 0 )
+	{
+		return true;
+	}
+
+	float len = VectorLengthSquared( dir );
+
+	// Can't be too close
+	if ( len < 24 * 24 )
+	{
+		return true;
+	}
+
+	return false;
+}
+
+//----------------------------
+void CPoly::Draw()
+{
+	polyVert_t	verts[MAX_CPOLY_VERTS];
+
+	for ( int i = 0; i < mCount; i++ )
+	{
+		// Add our midpoint and vert offset to get the actual vertex
+		VectorAdd( mOrigin1, mOrg[i], verts[i].xyz );
+
+		// Assign the same color to each vert
+		verts[i].modulate[0] = mRefEnt.shaderRGBA[0];
+		verts[i].modulate[1] = mRefEnt.shaderRGBA[1];
+		verts[i].modulate[2] = mRefEnt.shaderRGBA[2];
+		verts[i].modulate[3] = mRefEnt.shaderRGBA[3];
+
+		// Copy the ST coords
+		Vector2Copy( mST[i], verts[i].st );
+	}
+
+	// Add this poly
+	theFxHelper.AddPolyToScene( mRefEnt.customShader, mCount, verts );
+
+	drawnFx++;
+}
+
+//----------------------------
+void CPoly::CalcRotateMatrix()
+{
+	float	cosX, cosZ;
+	float	sinX, sinZ;
+	float	rad;
+
+	// rotate around Z
+	rad = DEG2RAD( mRotDelta[YAW] * theFxHelper.mFrameTime * 0.01f );
+	cosZ = cos( rad );
+	sinZ = sin( rad );
+	// rotate around X
+	rad = DEG2RAD( mRotDelta[PITCH] * theFxHelper.mFrameTime * 0.01f );
+	cosX = cos( rad );
+	sinX = sin( rad );
+
+/*Pitch - aroundx  Yaw - around z
+1 0  0			 c -s 0
+0 c -s			 s  c 0 
+0 s  c			 0  0 1
+*/
+	mRot[0][0] = cosZ;
+	mRot[1][0] = -sinZ;
+	mRot[2][0] = 0;
+	mRot[0][1] = cosX * sinZ;
+	mRot[1][1] = cosX * cosZ;
+	mRot[2][1] = -sinX;
+	mRot[0][2] = sinX * sinZ;
+	mRot[1][2] = sinX * cosZ;
+	mRot[2][2] = cosX;
+/*
+// ROLL is not supported unless anyone complains, if it needs to be added, use this format
+Roll
+
+ c 0 s
+ 0 1 0 
+-s 0 c
+*/
+	mLastFrameTime = theFxHelper.mFrameTime;
+}
+
+//--------------------------------
+void CPoly::Rotate()
+{
+	vec3_t	temp[MAX_CPOLY_VERTS];
+	float	dif = abs(mLastFrameTime - theFxHelper.mFrameTime);
+
+	// Very generous check with frameTimes
+	if ( dif > 0.5f * mLastFrameTime )
+	{
+		CalcRotateMatrix();
+	}
+
+	// Multiply our rotation matrix by each of the offset verts to get their new position
+	for ( int i = 0; i < mCount; i++ )
+	{
+		VectorRotate( mOrg[i], mRot, temp[i] );
+		VectorCopy( temp[i], mOrg[i] );
+	}
+}
+
+//----------------------------
+// Update
+//----------------------------
+bool CPoly::Update()
+{
+	vec3_t mOldOrigin;
+	
+	//FIXME: Handle Relative and Bolted Effects
+	/*
+	if ( mFlags & FX_RELATIVE )
+	{
+		if ( mClientID < 0 || mClientID >= ENTITYNUM_WORLD )
+		{	// we are somehow not bolted even though the flag is on?
+			return false;
+		}
+
+		// Get our current position and direction
+		if (mModelNum>=0 && mBoltNum>=0)	//bolt style
+		{
+		}
+	}
+	*/
+	// Game pausing can cause dumb time things to happen, so kill the effect in this instance
+	if ( mTimeStart > theFxHelper.mTime )
+	{
+		return false;
+	}
+
+	// If our timestamp hasn't exired yet, we won't even consider doing any kind of motion
+	if ( theFxHelper.mTime > mTimeStamp )
+	{
+		VectorCopy( mOrigin1, mOldOrigin );
+
+		if (( mTimeStart < theFxHelper.mTime ) && UpdateOrigin() == false )
+		{
+			// we are marked for death
+			return false;
+		}
+	}
+
+	if ( !Cull() )
+	{
+		// only rotate when our start timestamp has expired
+		if ( theFxHelper.mTime > mTimeStamp )
+		{
+			// Only rotate whilst moving
+			if ( !VectorCompare( mOldOrigin, mOrigin1 ))
+			{
+				Rotate();
+			}
+		}
+
+		UpdateRGB();
+		UpdateAlpha();
+
+		Draw();
+	}
+
+	return true;
+}
+
+//----------------------------
+void CPoly::PolyInit()
+{
+	if ( mCount < 3 )
+	{
+		return;
+	}
+
+	int		i;
+	vec3_t	org={0,0,0};
+
+	// Find our midpoint
+	for ( i = 0; i < mCount; i++ )
+	{
+		VectorAdd( org, mOrg[i], org );
+	}
+
+	VectorScale( org, (float)(1.0f / mCount), org );
+
+	// now store our midpoint for physics purposes
+	VectorCopy( org, mOrigin1 );
+
+	// Now we process the passed in points and make it so that they aren't actually the point...
+	//	rather, they are the offset from mOrigin1.
+	for ( i = 0; i < mCount; i++ )
+	{
+		VectorSubtract( mOrg[i], mOrigin1, mOrg[i] );
+	}
+
+	CalcRotateMatrix();
+}
+
+/*
+-------------------------
+CBezier
+
+Bezier curve line
+-------------------------
+*/
+//----------------------------
+bool CBezier::Update( void )
+{
+	float	ftime, time2;
+
+	//FIXME: Handle Relative and Bolted Effects
+	/*
+	if ( mFlags & FX_RELATIVE )
+	{
+		if ( mClientID < 0 || mClientID >= ENTITYNUM_WORLD )
+		{	// we are somehow not bolted even though the flag is on?
+			return false;
+		}
+
+		// Get our current position and direction
+		if (mModelNum>=0 && mBoltNum>=0)	//bolt style
+		{
+		}
+	}
+	*/
+	ftime = cg.frametime * 0.001f;
+	time2 = ftime * ftime * 0.5f;
+
+	for ( int i = 0; i < 3; i++ ) 
+	{
+		mControl1[i] = mControl1[i] + ftime * mControl1Vel[i] + time2 * mControl1Vel[i];
+		mControl2[i] = mControl2[i] + ftime * mControl2Vel[i] + time2 * mControl2Vel[i];
+	}
+
+	UpdateSize();
+	UpdateRGB();
+	UpdateAlpha();
+
+	Draw();
+
+	return true;
+}
+
+//----------------------------
+inline void CBezier::DrawSegment( vec3_t start, vec3_t end, float texcoord1, float texcoord2 )
+{
+	vec3_t			lineDir, cross, viewDir;
+	static vec3_t	lastEnd[2];
+	polyVert_t		verts[4];
+	float			scale;
+
+	VectorSubtract( end, start, lineDir );
+	VectorSubtract( end, cg.refdef.vieworg, viewDir );
+	CrossProduct( lineDir, viewDir, cross );
+	VectorNormalize( cross );
+
+	scale = mRefEnt.radius * 0.5f;
+
+	//Construct the oriented quad
+	if ( mInit )
+	{
+		VectorCopy( lastEnd[0], verts[0].xyz );
+		VectorCopy( lastEnd[1], verts[1].xyz );
+	}
+	else
+	{
+		VectorMA( start, -scale, cross, verts[0].xyz );
+		VectorMA( start, scale, cross, verts[1].xyz );
+	}
+
+	verts[0].st[0] = 0.0f;
+	verts[0].st[1] = texcoord1;
+
+	verts[0].modulate[0] = mRefEnt.shaderRGBA[0] * ( 1.0f - texcoord1 );
+	verts[0].modulate[1] = mRefEnt.shaderRGBA[1] * ( 1.0f - texcoord1 );
+	verts[0].modulate[2] = mRefEnt.shaderRGBA[2] * ( 1.0f - texcoord1 );
+	verts[0].modulate[3] = mRefEnt.shaderRGBA[3];
+
+	verts[1].st[0] = 1.0f;
+	verts[1].st[1] = texcoord1;
+	verts[1].modulate[0] = mRefEnt.shaderRGBA[0] * ( 1.0f - texcoord1 );
+	verts[1].modulate[1] = mRefEnt.shaderRGBA[1] * ( 1.0f - texcoord1 );
+	verts[1].modulate[2] = mRefEnt.shaderRGBA[2] * ( 1.0f - texcoord1 );
+	verts[1].modulate[3] = mRefEnt.shaderRGBA[3];
+
+	if ( texcoord1 == 0.0f )
+	{
+		verts[0].modulate[0] = 0;
+		verts[0].modulate[1] = 0;
+		verts[0].modulate[2] = 0;
+		verts[0].modulate[3] = 0;
+		verts[1].modulate[0] = 0;
+		verts[1].modulate[1] = 0;
+		verts[1].modulate[2] = 0;
+		verts[1].modulate[3] = 0;
+	}
+
+	VectorMA( end, scale, cross, verts[2].xyz );
+	verts[2].st[0] = 1.0f;
+	verts[2].st[1] = texcoord2;
+	verts[2].modulate[0] = mRefEnt.shaderRGBA[0] * ( 1.0f - texcoord2 );
+	verts[2].modulate[1] = mRefEnt.shaderRGBA[1] * ( 1.0f - texcoord2 );
+	verts[2].modulate[2] = mRefEnt.shaderRGBA[2] * ( 1.0f - texcoord2 );
+	verts[2].modulate[3] = mRefEnt.shaderRGBA[3];
+
+	VectorMA( end, -scale, cross, verts[3].xyz );
+	verts[3].st[0] = 0.0f;
+	verts[3].st[1] = texcoord2;
+	verts[3].modulate[0] = mRefEnt.shaderRGBA[0] * ( 1.0f - texcoord2 );
+	verts[3].modulate[1] = mRefEnt.shaderRGBA[1] * ( 1.0f - texcoord2 );
+	verts[3].modulate[2] = mRefEnt.shaderRGBA[2] * ( 1.0f - texcoord2 );
+	verts[3].modulate[3] = mRefEnt.shaderRGBA[3];
+
+	cgi_R_AddPolyToScene( mRefEnt.customShader, 4, verts );
+
+	VectorCopy( verts[2].xyz, lastEnd[1] );
+	VectorCopy( verts[3].xyz, lastEnd[0] );
+
+	mInit = true;
+}
+
+const	float	BEZIER_RESOLUTION	= 16.0f;
+
+//----------------------------
+void CBezier::Draw( void )	
+{
+	vec3_t	pos, old_pos;
+    float	mu, mum1;
+	float	incr = 1.0f / BEZIER_RESOLUTION, tex = 1.0f, tc1, tc2;
+	int		i;
+
+	VectorCopy( mOrigin1, old_pos );
+
+	mInit = false;	//Signify a new batch for vert gluing
+
+	// Calculate the texture coords so the texture can stretch along the whole bezier
+//	if ( mFlags & FXF_WRAP )
+//	{
+//		tex = m_stScale / 1.0f;
+//	}
+
+	float mum13, mu3, group1, group2;
+
+	tc1 = 0.0f;
+
+	for ( mu = incr; mu <= 1.0f; mu += incr )
+	{
+		//Four point curve
+		mum1	= 1 - mu;
+		mum13	= mum1 * mum1 * mum1;
+		mu3		= mu * mu * mu;
+		group1	= 3 * mu * mum1 * mum1;
+		group2	= 3 * mu * mu *mum1;
+
+		for ( i = 0; i < 3; i++ )
+		{
+			pos[i] = mum13 * mOrigin1[i] + group1 * mControl1[i] + group2 * mControl2[i] + mu3 * mOrigin2[i];
+		}
+
+//		if ( m_flags & FXF_WRAP ) 
+//		{
+			tc2 = mu * tex;
+//		}
+//		else
+//		{
+//			// Texture will get mapped onto each segement
+//			tc1 = 0.0f;
+//			tc2 = 1.0f;
+//		}
+
+		//Draw it
+		DrawSegment( old_pos, pos, tc1, tc2 );
+
+		VectorCopy( pos, old_pos );
+		tc1 = tc2;
+	}
+
+	drawnFx++;
+	mLines++; // NOT REALLY A LINE
+}
+
+/*
+-------------------------
+CFlash
+
+Full screen flash
+-------------------------
+*/
+
+//----------------------------
+bool CFlash::Update( void )
+{
+	UpdateRGB();
+	Draw();
+
+	return true;
+}
+
+//----------------------------
+void CFlash::Init( void )
+{
+	vec3_t	dif;
+	float	mod = 1.0f, dis;
+
+	VectorSubtract( mOrigin1, cg.refdef.vieworg, dif );
+	dis = VectorNormalize( dif );
+
+	mod = DotProduct( dif, cg.refdef.viewaxis[0] );
+
+	if ( dis > 600 || ( mod < 0.5f && dis > 100 ))
+	{
+		mod = 0.0f;
+	}
+	else if ( mod < 0.5f && dis <= 100 )
+	{
+		mod += 1.1f;
+	}
+
+	mod *= (1.0f - ((dis * dis) / (600.0f * 600.0f)));
+
+	VectorScale( mRGBStart, mod, mRGBStart );
+	VectorScale( mRGBEnd, mod, mRGBEnd );
+}
+
+//----------------------------
+void CFlash::Draw( void )	
+{
+	mRefEnt.reType = RT_SPRITE;
+
+	for ( int i = 0; i < 3; i++ )
+	{
+		if ( mRefEnt.lightingOrigin[i] > 1.0f )
+		{
+			mRefEnt.lightingOrigin[i] = 1.0f;
+		}
+		else if ( mRefEnt.lightingOrigin[i] < 0.0f )
+		{
+			mRefEnt.lightingOrigin[i] = 0.0f;
+		}
+	}
+	mRefEnt.shaderRGBA[0] = mRefEnt.lightingOrigin[0] * 255; 
+	mRefEnt.shaderRGBA[1] = mRefEnt.lightingOrigin[1] * 255; 
+	mRefEnt.shaderRGBA[2] = mRefEnt.lightingOrigin[2] * 255; 
+	mRefEnt.shaderRGBA[3] = 255;
+
+	VectorCopy( cg.refdef.vieworg, mRefEnt.origin );
+	VectorMA( mRefEnt.origin, 8, cg.refdef.viewaxis[0], mRefEnt.origin );
+	mRefEnt.radius = 12.0f;
+
+	theFxHelper.AddFxToScene( &mRefEnt );
+
+	drawnFx++;
+}
diff --git a/code/cgame/FxPrimitives.h b/code/cgame/FxPrimitives.h
new file mode 100644
index 0000000..2a40a5a
--- /dev/null
+++ b/code/cgame/FxPrimitives.h
@@ -0,0 +1,572 @@
+
+#if !defined(FX_SYSTEM_H_INC)
+	#include "FxSystem.h"
+#endif
+
+#ifndef FX_PRIMITIVES_H_INC
+#define FX_PRIMITIVES_H_INC
+
+
+#define MAX_EFFECTS			1200
+
+
+// Generic group flags, used by parser, then get converted to the appropriate specific flags
+#define FX_PARM_MASK		0xC	// use this to mask off any transition types that use a parm
+#define FX_GENERIC_MASK		0xF
+#define FX_LINEAR			0x1
+#define FX_RAND				0x2
+#define FX_NONLINEAR		0x4
+#define FX_WAVE				0x8
+#define FX_CLAMP			0xC
+
+// Group flags
+#define FX_ALPHA_SHIFT		0
+#define FX_ALPHA_PARM_MASK	0x0000000C
+#define	FX_ALPHA_LINEAR		0x00000001
+#define FX_ALPHA_RAND		0x00000002
+#define	FX_ALPHA_NONLINEAR	0x00000004
+#define FX_ALPHA_WAVE		0x00000008
+#define FX_ALPHA_CLAMP		0x0000000C
+
+#define FX_RGB_SHIFT		4
+#define FX_RGB_PARM_MASK	0x000000C0
+#define	FX_RGB_LINEAR		0x00000010
+#define FX_RGB_RAND			0x00000020
+#define	FX_RGB_NONLINEAR	0x00000040
+#define FX_RGB_WAVE			0x00000080
+#define FX_RGB_CLAMP		0x000000C0
+
+#define FX_SIZE_SHIFT		8
+#define FX_SIZE_PARM_MASK	0x00000C00
+#define	FX_SIZE_LINEAR		0x00000100
+#define FX_SIZE_RAND		0x00000200
+#define	FX_SIZE_NONLINEAR	0x00000400
+#define FX_SIZE_WAVE		0x00000800
+#define FX_SIZE_CLAMP		0x00000C00
+
+#define FX_LENGTH_SHIFT		12
+#define FX_LENGTH_PARM_MASK	0x0000C000
+#define	FX_LENGTH_LINEAR	0x00001000
+#define FX_LENGTH_RAND		0x00002000
+#define	FX_LENGTH_NONLINEAR	0x00004000
+#define FX_LENGTH_WAVE		0x00008000
+#define FX_LENGTH_CLAMP		0x0000C000
+
+#define FX_SIZE2_SHIFT		16
+#define FX_SIZE2_PARM_MASK	0x000C0000
+#define	FX_SIZE2_LINEAR		0x00010000
+#define FX_SIZE2_RAND		0x00020000
+#define	FX_SIZE2_NONLINEAR	0x00040000
+#define FX_SIZE2_WAVE		0x00080000
+#define FX_SIZE2_CLAMP		0x000C0000
+
+// Feature flags
+#define	FX_DEPTH_HACK		0x00100000
+#define	FX_RELATIVE			0x00200000
+#define	FX_SET_SHADER_TIME	0x00400000		// by having the effects system set the shader time, we can make animating textures start at the correct time
+#define FX_EXPENSIVE_PHYSICS 0x00800000		
+
+//rww - g2-related flags (these can slow things down significantly, use sparingly)
+//These should be used only with particles/decals as they steal flags used by cylinders.
+#define	FX_GHOUL2_TRACE		0x00020000		//use in conjunction with particles - actually do full ghoul2 traces for physics collision against entities with a ghoul2 instance
+							//shared FX_SIZE2_RAND (used only with cylinders)
+#define	FX_GHOUL2_DECALS	0x00040000		//use in conjunction with decals - can project decal as a ghoul2 gore skin object onto ghoul2 models
+							//shared FX_SIZE2_NONLINEAR (used only with cylinders)
+
+#define FX_ATTACHED_MODEL	0x01000000
+
+#define FX_APPLY_PHYSICS	0x02000000
+#define FX_USE_BBOX			0x04000000		// can make physics more accurate at the expense of speed
+
+#define FX_USE_ALPHA		0x08000000		// the FX system actually uses RGB to do fades, but this will override that
+											//	and cause it to fill in the alpha.
+
+#define FX_EMIT_FX			0x10000000		// emitters technically don't have to emit stuff, but when they do
+											//	this flag needs to be set
+#define FX_DEATH_RUNS_FX	0x20000000		// Normal death triggers effect, but not kill_on_impact
+#define FX_KILL_ON_IMPACT	0x40000000		// works just like it says, but only when physics are on.
+#define FX_IMPACT_RUNS_FX	0x80000000		// an effect can call another effect when it hits something.
+
+// Lightning flags, duplicates of existing flags, but lightning doesn't use those flags in that context...and nothing will ever use these in this context..so we are safe.
+#define FX_TAPER			0x01000000		// tapers as it moves towards its endpoint
+#define FX_BRANCH			0x02000000		// enables lightning branching
+#define FX_GROW				0x04000000		// lightning grows from start point to end point over the course of its life
+
+//------------------------------
+class CEffect
+{
+protected:
+
+	vec3_t		mOrigin1;
+
+	int			mTimeStart;
+	int			mTimeEnd;
+
+	unsigned int	mFlags;
+
+	// Size of our object, useful for things that have physics
+	vec3_t		mMin;
+	vec3_t		mMax;
+
+	int			mImpactFxID;		// if we have an impact event, we may have to call an effect
+	int			mDeathFxID;			// if we have a death event, we may have to call an effect
+
+	refEntity_t	mRefEnt;
+
+
+public:
+
+	CEffect()			{ memset( &mRefEnt, 0, sizeof( refEntity_t )); }
+	virtual ~CEffect() {}
+	virtual void Die() {}
+
+	virtual bool Update()
+	{	// Game pausing can cause dumb time things to happen, so kill the effect in this instance
+		if ( mTimeStart > theFxHelper.mTime ) {
+			return false;
+		}	
+		return true;
+	}
+
+	inline void SetSTScale(float s,float t)	{ mRefEnt.shaderTexCoord[0]=s;mRefEnt.shaderTexCoord[1]=t;}
+
+	inline void SetMin( const vec3_t min )		{ if(min){VectorCopy(min,mMin);}else{VectorClear(mMin);}			}
+	inline void SetMax( const vec3_t max )		{ if(max){VectorCopy(max,mMax);}else{VectorClear(mMax);}			}
+	inline void SetFlags( int flags )		{ mFlags = flags;				}
+	inline void AddFlags( int flags )		{ mFlags |= flags;				}
+	inline void ClearFlags( int flags )		{ mFlags &= ~flags;				}
+	inline void SetOrigin1( const vec3_t org )	{ if(org){VectorCopy(org,mOrigin1);}else{VectorClear(mOrigin1);}	}
+	inline void SetTimeStart( int time )	{ mTimeStart = time; if (mFlags&FX_SET_SHADER_TIME) { mRefEnt.shaderTime = cg.time * 0.001f; }}
+	inline void	SetTimeEnd( int time )		{ mTimeEnd = time;				}
+	inline void SetImpactFxID( int id )		{ mImpactFxID = id;				}
+	inline void SetDeathFxID( int id )		{ mDeathFxID = id;				}
+};
+
+
+//---------------------------------------------------
+// This class is kind of an exception to the "rule".
+//	For now it exists only for allowing an easy way
+//	to get the saber slash trails rendered.
+//---------------------------------------------------
+class CTrail : public CEffect
+{
+// This is such a specific case thing, just grant public access to the goods.
+protected:
+
+	void Draw();
+
+public:
+
+	typedef struct
+	{
+		vec3_t	origin;
+
+		// very specifc case, we can modulate the color and the alpha
+		vec3_t	rgb;
+		vec3_t	destrgb;
+		vec3_t	curRGB;
+
+		float	alpha;
+		float	destAlpha;
+		float	curAlpha;
+
+		// this is a very specific case thing...allow interpolating the st coords so we can map the texture
+		//	properly as this segement progresses through it's life
+		float	ST[2];
+		float	destST[2];
+		float	curST[2];
+
+	} TVert;
+
+	TVert		mVerts[4];
+	qhandle_t	mShader;
+
+
+	CTrail()			{};
+	virtual ~CTrail()	{};
+
+	virtual bool Update();
+};
+
+
+//------------------------------
+class CLight : public CEffect
+{
+protected:
+
+	float		mSizeStart;
+	float		mSizeEnd;
+	float		mSizeParm;
+
+	vec3_t		mRGBStart;
+	vec3_t		mRGBEnd;
+	float		mRGBParm;
+
+
+	void		UpdateSize();
+	void		UpdateRGB();
+
+	void Draw()
+	{
+		theFxHelper.AddLightToScene( mOrigin1, mRefEnt.radius, 
+			mRefEnt.lightingOrigin[0], mRefEnt.lightingOrigin[1], mRefEnt.lightingOrigin[2] );
+	}
+
+public:
+
+	CLight() {}
+	virtual ~CLight() {}
+	virtual bool Update();
+	
+	inline void SetSizeStart( float sz )	{ mSizeStart = sz;			}
+	inline void SetSizeEnd( float sz )		{ mSizeEnd = sz;			}
+	inline void SetSizeParm( float parm )	{ mSizeParm = parm;			}
+
+	inline void SetRGBStart( vec3_t rgb )	{ if(rgb){VectorCopy(rgb,mRGBStart);}else{VectorClear(mRGBStart);}	}
+	inline void SetRGBEnd( vec3_t rgb )		{ if(rgb){VectorCopy(rgb,mRGBEnd);}else{VectorClear(mRGBEnd);}		}
+	inline void SetRGBParm( float parm )	{ mRGBParm = parm;			}
+};
+
+//------------------------------
+class CFlash : public CLight
+{
+protected:
+
+	void Draw();
+
+public:
+
+	CFlash() {}
+	virtual ~CFlash() {}
+
+	virtual bool Update();
+
+	inline void SetShader( qhandle_t sh )	
+	{	assert(sh); 
+		mRefEnt.customShader = sh;				
+	}
+	void		Init( void );
+};
+
+//------------------------------
+class CParticle : public CEffect
+{
+protected:
+
+	vec3_t		mOrgOffset;
+
+	vec3_t		mVel;
+	vec3_t		mAccel;
+	float		mGravity;
+
+	float		mSizeStart;
+	float		mSizeEnd;
+	float		mSizeParm;
+
+	vec3_t		mRGBStart;
+	vec3_t		mRGBEnd;
+	float		mRGBParm;
+	
+	float		mAlphaStart;
+	float		mAlphaEnd;
+	float		mAlphaParm;
+
+	float		mRotationDelta;
+	float		mElasticity;
+
+	short		mClientID;
+	char		mModelNum;
+	char		mBoltNum;
+
+	bool		UpdateOrigin();
+	void		UpdateVelocity() {VectorMA( mVel, theFxHelper.mFloatFrameTime, mAccel, mVel ); }
+
+	void		UpdateSize();
+	void		UpdateRGB();
+	void		UpdateAlpha();
+	void		UpdateRotation() { mRefEnt.rotation += theFxHelper.mFrameTime * 0.01f * mRotationDelta; }
+
+	bool Cull();
+	void Draw();
+	
+public:
+
+	inline CParticle() { mRefEnt.reType = RT_SPRITE; mClientID = -1; mModelNum = -1; mBoltNum = -1; }
+	virtual ~CParticle() {}
+
+	virtual void Die();
+	virtual bool Update();
+
+	inline void SetShader( qhandle_t sh )		{ mRefEnt.customShader = sh;}
+
+	inline void SetOrgOffset( const vec3_t o )	{ if(o){VectorCopy(o,mOrgOffset);}else{VectorClear(mOrgOffset);}}
+	inline void SetVel( const vec3_t vel )		{ if(vel){VectorCopy(vel,mVel);}else{VectorClear(mVel);}	}
+	inline void SetAccel( const vec3_t ac )		{ if(ac){VectorCopy(ac,mAccel);}else{VectorClear(mAccel);}	}
+	inline void SetGravity( float grav )		{ mGravity = grav;			}
+
+	inline void SetSizeStart( float sz )		{ mSizeStart = sz;			}
+	inline void SetSizeEnd( float sz )			{ mSizeEnd = sz;			}
+	inline void SetSizeParm( float parm )		{ mSizeParm = parm;			}
+
+	inline void SetRGBStart( const vec3_t rgb )	{ if(rgb){VectorCopy(rgb,mRGBStart);}else{VectorClear(mRGBStart);}	}
+	inline void SetRGBEnd( const vec3_t rgb )	{ if(rgb){VectorCopy(rgb,mRGBEnd);}else{VectorClear(mRGBEnd);}		}
+	inline void SetRGBParm( float parm )		{ mRGBParm = parm;			}
+
+	inline void SetAlphaStart( float al )		{ mAlphaStart = al;			}
+	inline void SetAlphaEnd( float al )			{ mAlphaEnd = al;			}
+	inline void SetAlphaParm( float parm )		{ mAlphaParm = parm;		}
+
+	inline void SetRotation( float rot )		{ mRefEnt.rotation = rot;	}
+	inline void SetRotationDelta( float rot )	{ mRotationDelta = rot;		}
+	inline void SetElasticity( float el )		{ mElasticity = el;			}
+
+	inline void SetClient( int clientID,  int modelNum = -1, int boltNum = -1 )	{mClientID = clientID;	mModelNum = modelNum; mBoltNum = boltNum; }
+};
+
+
+//------------------------------
+class CLine : public CParticle
+{
+protected:
+
+	vec3_t	mOrigin2;
+
+	void Draw();
+
+public:
+
+	CLine() { mRefEnt.reType = RT_LINE;}
+	virtual ~CLine() {}
+	virtual void Die() {}
+	virtual bool Update();
+
+
+	inline void SetOrigin2( const vec3_t org2 )	{ VectorCopy( org2, mOrigin2 ); }
+};
+
+//------------------------------
+class CBezier : public CLine
+{
+protected:
+
+	vec3_t	mControl1;
+	vec3_t	mControl1Vel;
+
+	vec3_t	mControl2;
+	vec3_t	mControl2Vel;
+
+	bool	mInit;
+
+	void Draw();
+
+public:
+
+	CBezier(){ mInit = false; }
+	virtual ~CBezier() {}
+	virtual void Die() {}
+
+	virtual bool Update();
+	
+	void DrawSegment( vec3_t start, vec3_t end, float texcoord1, float texcoord2 );
+
+	inline void SetControlPoints( const vec3_t ctrl1, const vec3_t ctrl2 )	{ VectorCopy( ctrl1, mControl1 ); VectorCopy( ctrl2, mControl2 ); }
+	inline void SetControlVel( const vec3_t ctrl1v, const vec3_t ctrl2v )	{ VectorCopy( ctrl1v, mControl1Vel ); VectorCopy( ctrl2v, mControl2Vel ); }
+};
+
+
+//------------------------------
+class CElectricity : public CLine
+{
+protected:
+
+	float	mChaos;
+
+	void Draw();
+
+public:
+
+	CElectricity() { mRefEnt.reType = RT_ELECTRICITY; }
+	virtual ~CElectricity() {}
+	virtual void Die() {}
+
+	virtual bool Update();
+
+	void Initialize();
+
+	inline void SetChaos( float chaos )		{ mChaos = chaos; }
+};
+
+
+// Oriented quad
+//------------------------------
+class COrientedParticle : public CParticle
+{
+protected:
+
+	vec3_t	mNormal;
+	vec3_t	mNormalOffset;
+
+	bool Cull();
+	void Draw();
+
+public:
+
+	COrientedParticle() { mRefEnt.reType = RT_ORIENTED_QUAD; }
+	virtual ~COrientedParticle() {}
+
+	virtual bool Update();
+
+	inline void SetNormal( const vec3_t norm )	{ VectorCopy( norm, mNormal );	}
+	inline void SetNormalOffset( const vec3_t norm )	{ VectorCopy( norm, mNormalOffset );	}
+};
+
+//------------------------------
+class CTail : public CParticle
+{
+protected:
+
+	vec3_t	mOldOrigin;
+
+	float	mLengthStart;
+	float	mLengthEnd;
+	float	mLengthParm;
+
+	float	mLength;
+
+	void	UpdateLength();
+	void	CalcNewEndpoint();
+
+	void Draw();
+	bool Cull();
+
+public:
+
+	CTail() { mRefEnt.reType = RT_LINE; }
+	virtual ~CTail() {}
+
+	virtual bool Update();
+
+	inline void SetLengthStart( float len )	{ mLengthStart = len;	}
+	inline void SetLengthEnd( float len )	{ mLengthEnd = len;	}
+	inline void SetLengthParm( float len )	{ mLengthParm = len;	}
+};
+
+
+//------------------------------
+class CCylinder : public CTail
+{
+protected:
+
+	float		mSize2Start;
+	float		mSize2End;
+	float		mSize2Parm;
+
+	void	UpdateSize2();
+
+	void Draw();
+
+public:
+
+	CCylinder() { mRefEnt.reType = RT_CYLINDER; }
+	virtual ~CCylinder() {}
+
+	virtual bool Update();
+
+	inline void SetSize2Start( float sz )	{ mSize2Start = sz;			}
+	inline void SetSize2End( float sz )		{ mSize2End = sz;			}
+	inline void SetSize2Parm( float parm )	{ mSize2Parm = parm;		}
+
+	inline void SetNormal( const vec3_t norm )	{ VectorCopy( norm, mRefEnt.axis[0] ); }
+};
+
+
+//------------------------------
+// Emitters are derived from particles because, although they don't draw, any effect called
+//	from them can borrow an initial or ending value from the emitters current alpha, rgb, etc..
+class CEmitter : public CParticle
+{
+protected:
+
+	vec3_t		mOldOrigin;		// we use these to do some nice
+	vec3_t		mLastOrigin;	//	tricks...
+	vec3_t		mOldVelocity;	//	
+	int			mOldTime;
+
+	vec3_t		mAngles;		// for a rotating thing, using a delta  
+	vec3_t		mAngleDelta;	//	as opposed to an end angle is probably much easier
+
+	int			mEmitterFxID;	// if we have emitter fx, this is our id
+
+	float		mDensity;		// controls how often emitter chucks an effect
+	float		mVariance;		// density sloppiness
+
+	void		UpdateAngles();
+
+	void Draw();
+
+public:
+
+	CEmitter() {
+		// There may or may not be a model, but if there isn't one, 
+		//	we just won't bother adding the refEnt in our Draw func
+		mRefEnt.reType = RT_MODEL;
+	}
+	virtual ~CEmitter() {}
+
+	virtual bool Update();
+
+	inline void SetModel( qhandle_t model )		{ mRefEnt.hModel = model;	}
+	inline void SetAngles( const vec3_t ang )	{ if(ang){VectorCopy(ang,mAngles);}else{VectorClear(mAngles);}			}
+	inline void SetAngleDelta( const vec3_t ang){ if(ang){VectorCopy(ang,mAngleDelta);}else{VectorClear(mAngleDelta);}	}
+	inline void SetEmitterFxID( int id )		{ mEmitterFxID = id;		}
+	inline void SetDensity( float density )		{ mDensity = density;		}
+	inline void SetVariance( float var )		{ mVariance = var;			}
+	inline void SetOldTime( int time )			{ mOldTime = time;			}
+	inline void SetLastOrg( const vec3_t org )	{ if(org){VectorCopy(org,mLastOrigin);}else{VectorClear(mLastOrigin);}	}
+	inline void SetLastVel( const vec3_t vel )	{ if(vel){VectorCopy(vel,mOldVelocity);}else{VectorClear(mOldVelocity);}}
+
+};
+
+// We're getting pretty low level here, not the kind of thing to abuse considering how much overhead this
+//	adds to a SINGLE triangle or quad....
+// The editor doesn't need to see or do anything with this
+//------------------------------
+#define MAX_CPOLY_VERTS	5
+
+class CPoly : public CParticle
+{
+protected:
+
+	int		mCount;
+	vec3_t	mRotDelta;
+	int		mTimeStamp;
+
+	bool Cull();
+	void Draw();
+
+public:
+
+	vec3_t	mOrg[MAX_CPOLY_VERTS];
+	vec2_t	mST[MAX_CPOLY_VERTS];
+
+	float	mRot[3][3];
+	int		mLastFrameTime;
+
+
+	CPoly()				{}
+	virtual ~CPoly()	{}
+
+	virtual bool Update();
+
+	void PolyInit();
+	void CalcRotateMatrix();
+	void Rotate();
+
+	inline void SetNumVerts( int c )					{ mCount = c;			}
+	inline void SetRot( vec3_t r )						{ if(r){VectorCopy(r,mRotDelta);}else{VectorClear(mRotDelta);}}
+	inline void SetMotionTimeStamp( int t )				{ mTimeStamp = theFxHelper.mTime + t; }
+	inline int	GetMotionTimeStamp()					{ return mTimeStamp; }
+};
+
+
+#endif //FX_PRIMITIVES_H_INC
\ No newline at end of file
diff --git a/code/cgame/FxScheduler.cpp b/code/cgame/FxScheduler.cpp
new file mode 100644
index 0000000..c89a905
--- /dev/null
+++ b/code/cgame/FxScheduler.cpp
@@ -0,0 +1,2049 @@
+// this include must remain at the top of every CPP file
+#include "common_headers.h"
+
+
+#if !defined(FX_SCHEDULER_H_INC)
+	#include "FxScheduler.h"
+#endif
+
+#if !defined(GHOUL2_SHARED_H_INC)
+	#include "..\game\ghoul2_shared.h"	//for CGhoul2Info_v
+#endif
+
+#if !defined(G2_H_INC)
+	#include "../ghoul2/G2.h"
+#endif
+
+#if !defined(__Q_SHARED_H)
+	#include "../game/q_shared.h"
+#endif
+
+
+CFxScheduler	theFxScheduler;
+
+// don't even ask,. it's to do with loadsave...
+//
+vector < sstring_t > g_vstrEffectsNeededPerSlot;
+SLoopedEffect	gLoopedEffectArray[MAX_LOOPED_FX];	// must be in sync with CFxScheduler::mLoopedEffectArray
+void CFxScheduler::FX_CopeWithAnyLoadedSaveGames(void)
+{
+	if ( !g_vstrEffectsNeededPerSlot.empty() )
+	{
+		memcpy( mLoopedEffectArray, gLoopedEffectArray, sizeof(mLoopedEffectArray) );
+		assert( g_vstrEffectsNeededPerSlot.size() == MAX_LOOPED_FX );
+
+		for (int iFX = 0; iFX < g_vstrEffectsNeededPerSlot.size(); iFX++)
+		{
+			const char *psFX_Filename = g_vstrEffectsNeededPerSlot[iFX].c_str();
+			if ( psFX_Filename[0] )
+			{
+				// register it...
+				//
+				mLoopedEffectArray[ iFX ].mId = RegisterEffect( psFX_Filename );
+				//
+				// cope with any relative stop time...
+				//
+				if ( mLoopedEffectArray[ iFX ].mLoopStopTime )
+				{
+					 mLoopedEffectArray[ iFX ].mLoopStopTime -= mLoopedEffectArray[ iFX ].mNextTime;
+				} 
+				//
+				// and finally reset the time to be the newly-zeroed game time...
+				//
+				mLoopedEffectArray[ iFX ].mNextTime = 0;	// otherwise it won't process until game time catches up
+			}
+			else
+			{
+				mLoopedEffectArray[ iFX ].mId = 0;
+			}
+		}
+
+		g_vstrEffectsNeededPerSlot.clear();
+	}
+}
+
+void FX_CopeWithAnyLoadedSaveGames(void)
+{
+	theFxScheduler.FX_CopeWithAnyLoadedSaveGames();
+}
+
+// for loadsave...
+//
+void FX_Read( void )
+{
+	theFxScheduler.LoadSave_Read();
+}
+
+// for loadsave...
+//
+void FX_Write( void )
+{
+	theFxScheduler.LoadSave_Write();
+}
+
+void CFxScheduler::LoadSave_Read()
+{		
+	Clean();	// need to get rid of old pre-cache handles, or it thinks it has some older effects when it doesn't	
+	g_vstrEffectsNeededPerSlot.clear();	// jic
+	gi.ReadFromSaveGame('FXLE', (void *) &gLoopedEffectArray, sizeof(gLoopedEffectArray));
+	//
+	// now read in and re-register the effects we need for those structs...
+	//
+	for (int iFX = 0; iFX < MAX_LOOPED_FX; iFX++)
+	{
+		char sFX_Filename[MAX_QPATH];
+		gi.ReadFromSaveGame('FXFN', sFX_Filename, sizeof(sFX_Filename));
+		g_vstrEffectsNeededPerSlot.push_back( sFX_Filename );
+	}
+}
+
+void CFxScheduler::LoadSave_Write()
+{
+	// bsave the data we need...
+	//
+	gi.AppendToSaveGame('FXLE', mLoopedEffectArray, sizeof(mLoopedEffectArray));
+	//
+	// then cope with the fact that the mID field in each struct of the array we've just saved will not 
+	//	necessarily point at the same thing when reloading, so save out the actual fx filename strings they
+	//	need for re-registration...
+	//
+	// since this is only for savegames, and I've got < 2 hours to finish this and test it I'm going to be lazy
+	//	with the ondisk data... (besides, the RLE compression will kill most of this anyway)
+	//
+	for (int iFX = 0; iFX < MAX_LOOPED_FX; iFX++)
+	{
+		char sFX_Filename[MAX_QPATH];
+		memset(sFX_Filename,0,sizeof(sFX_Filename));	// instead of "sFX_Filename[0]=0;" so RLE will squash whole array to nothing, not just stop at '\0' then have old crap after it to compress
+
+		int &iID = mLoopedEffectArray[ iFX ].mId;
+		if ( iID )
+		{
+			// now we need to look up what string this represents, unfortunately the existing
+			//	lookup table is backwards (keywise) for our needs, so parse the whole thing...
+			//
+			for (TEffectID::iterator it = mEffectIDs.begin(); it != mEffectIDs.end(); ++it)
+			{
+				if ( (*it).second == iID )
+				{
+					Q_strncpyz( sFX_Filename, (*it).first.c_str(), sizeof(sFX_Filename) );
+					break;
+				}
+			}
+		}
+
+		// write out this string...
+		//
+		gi.AppendToSaveGame('FXFN', sFX_Filename, sizeof(sFX_Filename));
+	}
+}
+
+
+//-----------------------------------------------------------
+void CMediaHandles::operator=(const CMediaHandles &that )
+{
+	mMediaList.clear();
+
+	for ( int i = 0; i < that.mMediaList.size(); i++ )
+	{
+		mMediaList.push_back( that.mMediaList[i] );
+	}
+}
+
+//------------------------------------------------------
+CFxScheduler::CFxScheduler()
+{ 
+	memset( &mEffectTemplates, 0, sizeof( mEffectTemplates ));
+	memset( &mLoopedEffectArray, 0, sizeof( mLoopedEffectArray ));
+}
+
+int CFxScheduler::ScheduleLoopedEffect( int id, int boltInfo, bool isPortal, int iLoopTime, bool isRelative )
+{
+	int i;
+	
+	assert(id);
+	assert(boltInfo!=-1);
+
+	for (i=0;i<MAX_LOOPED_FX;i++)	//see if it's already playing so we can just update it
+	{
+		if (mLoopedEffectArray[i].mId == id &&
+			mLoopedEffectArray[i].mBoltInfo == boltInfo &&
+			mLoopedEffectArray[i].mPortalEffect == isPortal 
+			)
+		{
+#ifdef _DEBUG
+//			theFxHelper.Print( "CFxScheduler::ScheduleLoopedEffect- updating %s\n", mEffectTemplates[id].mEffectName);
+#endif
+			break;
+		}
+	}
+
+	if(i==MAX_LOOPED_FX)	//didn't find it existing, so find a free spot
+	{
+		for (i=0;i<MAX_LOOPED_FX;i++)
+		{
+			if (!mLoopedEffectArray[i].mId)
+			{
+				break;
+			}
+		}
+	}
+
+	if(i==MAX_LOOPED_FX)
+	{//bad
+		assert(i!=MAX_LOOPED_FX);
+		theFxHelper.Print( "CFxScheduler::AddLoopedEffect- No Free Slots available for %d\n", mEffectTemplates[id].mEffectName);
+		return -1;
+	}
+	mLoopedEffectArray[i].mId = id;
+	mLoopedEffectArray[i].mBoltInfo = boltInfo;
+	mLoopedEffectArray[i].mPortalEffect = isPortal;
+	mLoopedEffectArray[i].mIsRelative = isRelative;
+	mLoopedEffectArray[i].mNextTime = theFxHelper.mTime + mEffectTemplates[id].mRepeatDelay ;
+	mLoopedEffectArray[i].mLoopStopTime = (iLoopTime==1) ? 0 : theFxHelper.mTime + iLoopTime;
+	return i;
+}
+
+void CFxScheduler::StopEffect( const char *file, int boltInfo, bool isPortal )
+{
+	int i;
+	char	sfile[MAX_QPATH];
+
+	// Get an extenstion stripped version of the file
+	COM_StripExtension( file, sfile );
+	const int id = mEffectIDs[sfile];
+#ifndef FINAL_BUILD
+	if ( id == 0 )
+	{
+		theFxHelper.Print( "CFxScheduler::StopEffect- unregistered/non-existent effect: %s\n", sfile );
+		return;
+	}
+#endif
+
+	for (i=0;i<MAX_LOOPED_FX;i++)
+	{
+		if (mLoopedEffectArray[i].mId == id &&
+			mLoopedEffectArray[i].mBoltInfo == boltInfo &&
+			mLoopedEffectArray[i].mPortalEffect == isPortal 
+			)
+		{
+			memset( &mLoopedEffectArray[i], 0, sizeof(mLoopedEffectArray[i]) );
+			return;
+		}
+	}
+#ifdef _DEBUG_FX
+	theFxHelper.Print( "CFxScheduler::StopEffect- (%s) is not looping!\n", file);
+#endif
+}
+
+void CFxScheduler::AddLoopedEffects()
+{
+	int i;
+	
+	for (i=0;i<MAX_LOOPED_FX;i++)
+	{
+		if (mLoopedEffectArray[i].mId && mLoopedEffectArray[i].mNextTime < theFxHelper.mTime )
+		{
+			const int entNum = ( mLoopedEffectArray[i].mBoltInfo >> ENTITY_SHIFT )	& ENTITY_AND;
+			if ( cg_entities[entNum].gent->inuse )
+			{// only play the looped effect when the ent is still inUse....
+				PlayEffect( mLoopedEffectArray[i].mId, cg_entities[entNum].lerpOrigin, 0, mLoopedEffectArray[i].mBoltInfo, -1, mLoopedEffectArray[i].mPortalEffect, false,  mLoopedEffectArray[i].mIsRelative );	//very important to send FALSE looptime to not recursively add me!
+				mLoopedEffectArray[i].mNextTime = theFxHelper.mTime + mEffectTemplates[mLoopedEffectArray[i].mId].mRepeatDelay;
+			}
+			else
+			{
+				theFxHelper.Print( "CFxScheduler::AddLoopedEffects- entity was removed without stopping any looping fx it owned." );
+				memset( &mLoopedEffectArray[i], 0, sizeof(mLoopedEffectArray[i]) );
+				continue;
+			}
+			if ( mLoopedEffectArray[i].mLoopStopTime && mLoopedEffectArray[i].mLoopStopTime < theFxHelper.mTime )	//time's up
+			{//kill this entry
+				memset( &mLoopedEffectArray[i], 0, sizeof(mLoopedEffectArray[i]) );
+			}
+		}
+	}
+
+}
+
+//-----------------------------------------------------------
+void SEffectTemplate::operator=(const SEffectTemplate &that)
+{
+	mCopy = true;
+
+	strcpy( mEffectName, that.mEffectName );
+
+	mPrimitiveCount = that.mPrimitiveCount;
+
+	for( int i = 0; i < mPrimitiveCount; i++ )
+	{
+		mPrimitives[i] = new CPrimitiveTemplate;
+		*(mPrimitives[i]) = *(that.mPrimitives[i]);
+		// Mark use as a copy so that we know that we should be chucked when used up
+		mPrimitives[i]->mCopy = true;
+	}
+}
+
+//------------------------------------------------------
+// Clean
+//	Free up any memory we've allocated so we aren't leaking memory
+//
+// Input:
+//	Whether to clean everything or just stop the playing (active) effects
+//
+// Return:
+//	None
+//
+//------------------------------------------------------
+void CFxScheduler::Clean(bool bRemoveTemplates /*= true*/, int idToPreserve /*= 0*/)
+{
+	int								i, j;
+	TScheduledEffect::iterator		itr, next;
+
+	// Ditch any scheduled effects
+	itr = mFxSchedule.begin();
+
+	while ( itr != mFxSchedule.end() )
+	{
+		next = itr;
+		next++;
+
+		delete *itr;
+		mFxSchedule.erase(itr);
+
+		itr = next;
+	}
+
+	if (bRemoveTemplates)
+	{
+		// Ditch any effect templates
+		for ( i = 1; i < FX_MAX_EFFECTS; i++ )
+		{
+			if ( i == idToPreserve)
+			{
+				continue;
+			}
+
+			if ( mEffectTemplates[i].mInUse )
+			{
+				// Ditch the primitives
+				for (j = 0; j < mEffectTemplates[i].mPrimitiveCount; j++)
+				{
+					delete mEffectTemplates[i].mPrimitives[j];
+				}
+			} 
+
+			mEffectTemplates[i].mInUse = false;
+		}
+
+		if (idToPreserve == 0)
+		{
+			mEffectIDs.clear();
+		}
+		else
+		{
+			// Clear the effect names, but first get the name of the effect to preserve,
+			// and restore it after clearing.
+			fxString_t str;
+			TEffectID::iterator iter;
+
+			for (iter = mEffectIDs.begin(); iter != mEffectIDs.end(); ++iter)
+			{
+				if ((*iter).second == idToPreserve)
+				{
+					str = (*iter).first;
+					break;
+				}
+			}
+
+			mEffectIDs.clear();
+
+			mEffectIDs[str] = idToPreserve;
+		}
+	}
+}
+
+//------------------------------------------------------
+// RegisterEffect
+//	Attempt to open the specified effect file, if 
+//	file read succeeds, parse the file.
+//
+// Input:
+//	path or filename to open
+//
+// Return:
+//	int handle to the effect
+//------------------------------------------------------
+int CFxScheduler::RegisterEffect( const char *file, bool bHasCorrectPath /*= false*/ )
+{
+	// Dealing with file names:
+	// File names can come from two places - the editor, in which case we should use the given
+	// path as is, and the effect file, in which case we should add the correct path and extension.
+	// In either case we create a stripped file name to use for naming effects.
+	//
+
+	char sfile[MAX_QPATH];
+
+	// Get an extension stripped version of the file
+	if (bHasCorrectPath)
+	{
+		const char *last = file, *p = file;
+
+		while (*p != '\0')
+		{
+			if ((*p == '/') || (*p == '\\'))
+			{
+				last = p + 1;
+			}
+
+			p++;
+		}
+
+		COM_StripExtension( last, sfile );
+	}
+	else
+	{
+		COM_StripExtension( file, sfile );
+	}
+
+	// see if the specified file is already registered.  If it is, just return the id of that file
+	TEffectID::iterator itr;
+	
+	itr = mEffectIDs.find( sfile );
+
+	if ( itr != mEffectIDs.end() )
+	{
+		return (*itr).second;
+	}
+
+	CGenericParser2	parser;
+	int				len = 0;
+	fileHandle_t	fh;
+	char			*data;
+	char			temp[MAX_QPATH];
+	const char		*pfile;
+	char			*bufParse = 0;
+
+	if (bHasCorrectPath)
+	{
+		pfile = file;
+	}
+	else
+	{
+		// Add on our extension and prepend the file with the default path
+		sprintf( temp, "%s/%s.efx", FX_FILE_PATH, sfile );
+		pfile = temp;
+	}
+
+	len = theFxHelper.OpenFile( pfile, &fh, FS_READ );
+
+	if ( len < 0 )
+	{
+		theFxHelper.Print( "RegisterEffect: failed to load: %s\n", pfile );
+		return 0;
+	}
+
+	if (len == 0)
+	{
+		theFxHelper.Print( "RegisterEffect: INVALID file: %s\n", pfile );
+		theFxHelper.CloseFile( fh );
+		return 0;
+	}
+
+	// Allocate enough space to hold the file
+	// This should be flagged temp, but it seems ok as is.
+	data = new char[len+1];
+
+	// Get the goods and ensure Null termination
+	theFxHelper.ReadFile( data, len, fh );
+	data[len] = '\0';
+	bufParse = data;
+
+	// Let the generic parser process the whole file
+	parser.Parse( &bufParse );
+
+	theFxHelper.CloseFile( fh );
+
+	// Delete our temp copy of the file
+	delete [] data;
+
+	// Lets convert the effect file into something that we can work with
+	return ParseEffect( sfile, parser.GetBaseParseGroup() );
+}
+
+
+//------------------------------------------------------
+// ParseEffect
+//	Starts at ground zero, using each group header to 
+//	determine which kind of effect we are working with.
+//	Then we call the appropriate function to parse the
+//	specified effect group.
+//
+// Input:
+//	base group, essentially the whole files contents
+//
+// Return:
+//	int handle of the effect
+//------------------------------------------------------
+int CFxScheduler::ParseEffect( const char *file, CGPGroup *base )
+{
+	CGPGroup			*primitiveGroup;
+	CPrimitiveTemplate	*prim;
+	const char			*grpName;
+	SEffectTemplate		*effect = 0;
+	EPrimType			type;
+	int					handle;
+	CGPValue			*pair;
+
+	effect = GetNewEffectTemplate( &handle, file );
+
+	if ( !handle || !effect )
+	{
+		// failure
+		return 0;
+	}
+
+	if ((pair = base->GetPairs())!=0)
+	{
+		grpName = pair->GetName();
+		if ( !stricmp( grpName, "repeatDelay" ))
+		{
+			effect->mRepeatDelay = atoi(pair->GetTopValue());
+		}
+		else
+		{//unknown
+
+		}
+	}
+
+	primitiveGroup = base->GetSubGroups();
+
+	while ( primitiveGroup )
+	{
+		grpName = primitiveGroup->GetName();
+
+		// Huge stricmp lists suxor
+		if ( !stricmp( grpName, "particle" ))
+		{
+			type = Particle;
+		}
+		else if ( !stricmp( grpName, "line" ))
+		{
+			type = Line;
+		}
+		else if ( !stricmp( grpName, "tail" ))
+		{
+			type = Tail;
+		}
+		else if ( !stricmp( grpName, "sound" ))
+		{
+			type = Sound;
+		}
+#ifdef _IMMERSION
+		else if ( !stricmp( grpName, "forcefeedback" ))
+		{
+			type = Force;
+		}
+#endif // _IMMERSION
+		else if ( !stricmp( grpName, "cylinder" ))
+		{
+			type = Cylinder;
+		}
+		else if ( !stricmp( grpName, "electricity" ))
+		{
+			type = Electricity;
+		}
+		else if ( !stricmp( grpName, "emitter" ))
+		{
+			type = Emitter;
+		}
+		else if ( !stricmp( grpName, "decal" ))
+		{
+			type = Decal;
+		}
+		else if ( !stricmp( grpName, "orientedparticle" ))
+		{
+			type = OrientedParticle;
+		}
+		else if ( !stricmp( grpName, "fxrunner" ))
+		{
+			type = FxRunner;
+		}
+		else if ( !stricmp( grpName, "light" ))
+		{
+			type = Light;
+		}
+		else if ( !stricmp( grpName, "cameraShake" ))
+		{
+			type = CameraShake;
+		}
+		else if ( !stricmp( grpName, "flash" ))
+		{
+			type = ScreenFlash;
+		}
+		else 
+		{
+			type = None;
+		}
+		
+		if ( type != None )
+		{
+			prim = new CPrimitiveTemplate;
+
+			prim->mType = type;
+			prim->ParsePrimitive( primitiveGroup );
+
+			// Add our primitive template to the effect list
+			AddPrimitiveToEffect( effect, prim );
+		}
+
+		primitiveGroup = (CGPGroup *)primitiveGroup->GetNext();
+	}
+
+	return handle;
+}
+
+
+//------------------------------------------------------
+// AddPrimitiveToEffect
+//	Takes a primitive and attaches it to the effect.
+//	
+// Input:
+//	Effect template that we tack the primitive on to
+//	Primitive to add to the effect template
+//
+// Return:
+//	None
+//------------------------------------------------------
+void CFxScheduler::AddPrimitiveToEffect( SEffectTemplate *fx, CPrimitiveTemplate *prim )
+{
+	int ct = fx->mPrimitiveCount;
+
+	if ( ct >= FX_MAX_EFFECT_COMPONENTS )
+	{
+		theFxHelper.Print( "FxScheduler:  Error--too many primitives in an effect\n" );
+	}
+	else
+	{
+		fx->mPrimitives[ct] = prim;
+		fx->mPrimitiveCount++;
+	}
+}
+
+//------------------------------------------------------
+// GetNewEffectTemplate
+//	Finds an unused effect template and returns it to the
+//	caller.
+//	
+// Input:
+//	pointer to an id that will be filled in, 
+//	file name-- should be NULL when requesting a copy
+//
+// Return:
+//	the id of the added effect template
+//------------------------------------------------------
+SEffectTemplate *CFxScheduler::GetNewEffectTemplate( int *id, const char *file )
+{
+	SEffectTemplate *effect;
+
+	// wanted zero to be a bogus effect ID, so we just skip it.
+	for ( int i = 1; i < FX_MAX_EFFECTS; i++ )
+	{
+		effect = &mEffectTemplates[i];
+
+		if ( !effect->mInUse )
+		{
+			*id = i;
+			memset( effect, 0, sizeof( SEffectTemplate ));
+
+			// If we are a copy, we really won't have a name that we care about saving for later
+			if ( file )
+			{
+				mEffectIDs[file] = i;
+				strcpy( effect->mEffectName, file );
+			}
+
+			effect->mInUse = true;
+			effect->mRepeatDelay = 300;
+			return effect;
+		}
+	}
+
+	theFxHelper.Print( "FxScheduler:  Error--reached max effects\n" );
+	*id = 0;
+	return 0;
+}
+
+//------------------------------------------------------
+// GetEffectCopy
+//	Returns a copy of the desired effect so that it can
+//	easily be modified run-time.
+//	
+// Input:
+//	file-- the name of the effect file that you want a copy of
+//	newHandle-- will actually be the returned handle to the new effect
+//				you have to hold onto this if you intend to call it again
+//
+// Return:
+//	the pointer to the copy
+//------------------------------------------------------
+SEffectTemplate *CFxScheduler::GetEffectCopy( const char *file, int *newHandle )
+{
+	return ( GetEffectCopy( mEffectIDs[file], newHandle ) );
+}
+
+//------------------------------------------------------
+// GetEffectCopy
+//	Returns a copy of the desired effect so that it can
+//	easily be modified run-time.
+//	
+// Input:
+//	fxHandle-- the handle to the effect that you want a copy of
+//	newHandle-- will actually be the returned handle to the new effect
+//				you have to hold onto this if you intend to call it again
+//
+// Return:
+//	the pointer to the copy
+//------------------------------------------------------
+SEffectTemplate *CFxScheduler::GetEffectCopy( int fxHandle, int *newHandle )
+{
+	if ( fxHandle < 1 || fxHandle >= FX_MAX_EFFECTS || !mEffectTemplates[fxHandle].mInUse )
+	{
+		// Didn't even request a valid effect to copy!!!
+		theFxHelper.Print( "FxScheduler: Bad effect file copy request\n" );
+
+		*newHandle = 0;
+		return 0;
+	}
+
+	// never get a copy when time is frozen
+	if ( fx_freeze.integer )
+	{
+		return 0;
+	}
+
+	// Copies shouldn't have names, otherwise they could trash our stl map used for getting ID from name
+	SEffectTemplate *copy = GetNewEffectTemplate( newHandle, NULL );
+
+	if ( copy && *newHandle )
+	{
+		// do the effect copy and mark us as what we are
+		*copy = mEffectTemplates[fxHandle];
+		copy->mCopy = true;
+
+		// the user had better hold onto this handle if they ever hope to call this effect.
+		return copy;
+	}
+
+	// No space left to return an effect
+	*newHandle = 0;
+	return 0;
+}
+
+//------------------------------------------------------
+// GetPrimitiveCopy
+//	Helper function that returns a copy of the desired primitive
+//	
+// Input:
+//	fxHandle - the pointer to the effect copy you want to override
+//	componentName - name of the component to find
+//
+// Return:
+//	the pointer to the desired primitive
+//------------------------------------------------------
+CPrimitiveTemplate *CFxScheduler::GetPrimitiveCopy( SEffectTemplate *effectCopy, const char *componentName )
+{
+	if ( !effectCopy || !effectCopy->mInUse )
+	{
+		return NULL;
+	}
+
+	for ( int i = 0; i < effectCopy->mPrimitiveCount; i++ )
+	{
+		if ( !stricmp( effectCopy->mPrimitives[i]->mName, componentName ))
+		{
+			// we found a match, so return it
+			return effectCopy->mPrimitives[i];
+		}
+	}
+
+	// bah, no good.
+	return NULL;
+}
+
+//------------------------------------------------------
+static void ReportPlayEffectError(int id)
+{
+#ifdef _DEBUG
+		theFxHelper.Print( "CFxScheduler::PlayEffect called with invalid effect ID: %i\n", id );
+#endif
+}
+
+
+//------------------------------------------------------
+// PlayEffect
+//	Handles scheduling an effect so all the components
+//	happen at the specified time.  Applies a default up
+//	axis.
+//	
+// Input:
+//	Effect file id and the origin
+//
+// Return:
+//	none
+//------------------------------------------------------
+void CFxScheduler::PlayEffect( int id, vec3_t origin, bool isPortal )
+{
+	vec3_t	axis[3];
+
+	VectorSet( axis[0], 0, 0, 1 );
+	VectorSet( axis[1], 1, 0, 0 );
+	VectorSet( axis[2], 0, 1, 0 );
+
+	PlayEffect( id, origin, axis, -1, -1, isPortal );
+}
+
+//------------------------------------------------------
+// PlayEffect
+//	Handles scheduling an effect so all the components
+//	happen at the specified time.  Takes a fwd vector
+//	and builds a right and up vector
+//	
+// Input:
+//	Effect file id, the origin, and a fwd vector
+//
+// Return:
+//	none
+//------------------------------------------------------
+void CFxScheduler::PlayEffect( int id, vec3_t origin, vec3_t forward, bool isPortal )
+{
+	vec3_t	axis[3];
+
+	// Take the forward vector and create two arbitrary but perpendicular vectors
+	VectorCopy( forward, axis[0] );
+	MakeNormalVectors( forward, axis[1], axis[2] );
+
+	PlayEffect( id, origin, axis, -1, -1, isPortal );
+}
+
+#ifdef _IMMERSION
+//------------------------------------------------------
+// PlayEffect
+//	Handles scheduling an effect so all the components
+//	happen at the specified time.  Takes a fwd vector
+//	and builds a right and up vector
+//	
+// Input:
+//	Effect file id, the origin, a fwd vector, and clientNum
+//
+// Return:
+//	none
+//------------------------------------------------------
+void CFxScheduler::PlayEffect( int id, int clientNum, vec3_t origin, vec3_t forward, bool isPortal )
+{
+	vec3_t	axis[3];
+
+	// Take the forward vector and create two arbitrary but perpendicular vectors
+	VectorCopy( forward, axis[0] );
+	MakeNormalVectors( forward, axis[1], axis[2] );
+
+	PlayEffect( id, origin, axis, -1, clientNum, isPortal );
+}
+
+//------------------------------------------------------
+// PlayEffect
+//	Handles scheduling an effect so all the components
+//	happen at the specified time.  Takes a forward vector
+//	and uses this to complete the axis field.
+//	
+// Input:
+//	Effect file name, the origin, and a forward vector
+//
+// Return:
+//	none
+//------------------------------------------------------
+void CFxScheduler::PlayEffect( const char *file, int clientNum, vec3_t origin, vec3_t forward, bool isPortal )
+{
+	char	sfile[MAX_QPATH];
+
+	// Get an extenstion stripped version of the file
+	COM_StripExtension( file, sfile );
+
+	PlayEffect( mEffectIDs[sfile], clientNum, origin, forward, isPortal );
+
+#ifndef FINAL_BUILD
+	if ( mEffectIDs[sfile] == 0 )
+	{
+		theFxHelper.Print( "CFxScheduler::PlayEffect unregistered/non-existent effect: %s\n", file );		
+	}
+#endif
+}
+
+#endif // _IMMERSION
+//------------------------------------------------------
+// PlayEffect
+//	Handles scheduling an effect so all the components
+//	happen at the specified time.  Uses the specified axis
+//	
+// Input:
+//	Effect file name, the origin, and axis.
+//	Optional boltInfo (defaults to -1)
+//  Optional entity number to be used by a cheap entity origin bolt (defaults to -1)
+//
+// Return:
+//	none
+//------------------------------------------------------
+void CFxScheduler::PlayEffect( const char *file, vec3_t origin, vec3_t axis[3], const int boltInfo, const int entNum, bool isPortal, int iLoopTime, bool isRelative )
+{
+	char	sfile[MAX_QPATH];
+
+	// Get an extenstion stripped version of the file
+	COM_StripExtension( file, sfile );
+
+	// This is a horribly dumb thing to have to do, but QuakeIII might not have calc'd the lerpOrigin
+	//	for the entity we may be trying to bolt onto.  We like having the correct origin, so we are
+	//	forced to call this function....
+	if ( entNum > -1 )
+	{
+		CG_CalcEntityLerpPositions( &cg_entities[entNum] );
+	}
+
+#ifndef FINAL_BUILD
+	if ( mEffectIDs[sfile] == 0 )
+	{
+		theFxHelper.Print( "CFxScheduler::PlayEffect unregistered/non-existent effect: %s\n", sfile );		
+	}
+#endif
+
+	PlayEffect( mEffectIDs[sfile], origin, axis, boltInfo, entNum, isPortal, iLoopTime, isRelative );
+}
+
+//------------------------------------------------------
+// PlayEffect
+//	Handles scheduling an effect so all the components
+//	happen at the specified time.  Uses the specified axis
+//	
+// Input:
+//	Effect file name, the origin, and axis.
+//	Optional boltInfo (defaults to -1)
+//  Optional entity number to be used by a cheap entity origin bolt (defaults to -1)
+//
+// Return:
+//	none
+//------------------------------------------------------
+void CFxScheduler::PlayEffect( const char *file, int clientID, bool isPortal )
+{
+	char	sfile[MAX_QPATH];
+	int		id;
+
+	// Get an extenstion stripped version of the file
+	COM_StripExtension( file, sfile );
+	id = mEffectIDs[sfile];
+
+#ifndef FINAL_BUILD
+	if ( id == 0 )
+	{
+		theFxHelper.Print( "CFxScheduler::PlayEffect unregistered/non-existent effect: %s\n", file );		
+	}
+#endif
+
+	SEffectTemplate			*fx;
+	CPrimitiveTemplate		*prim;
+	int						i = 0;
+	int						count = 0, delay = 0;
+	SScheduledEffect		*sfx;
+	float					factor = 0.0f;
+
+	if ( id < 1 || id >= FX_MAX_EFFECTS || !mEffectTemplates[id].mInUse )
+	{
+		// Now you've done it!
+		ReportPlayEffectError(id);
+		return;
+	}
+
+	// Don't bother scheduling the effect if the system is currently frozen
+ 
+	// Get the effect.
+	fx = &mEffectTemplates[id];
+
+	// Loop through the primitives and schedule each bit
+	for ( i = 0; i < fx->mPrimitiveCount; i++ )
+	{
+		prim = fx->mPrimitives[i];
+
+		count = prim->mSpawnCount.GetRoundedVal();
+
+		if ( prim->mCopy )
+		{
+			// If we are a copy, we need to store a "how many references count" so that we
+			//	can keep the primitive template around for the correct amount of time.
+			prim->mRefCount = count;
+		}
+
+		if ( prim->mSpawnFlags & FX_EVEN_DISTRIBUTION )
+		{
+			factor = abs(prim->mSpawnDelay.GetMax() - prim->mSpawnDelay.GetMin()) / (float)count;
+		}
+
+		// Schedule the random number of bits
+		for ( int t = 0; t < count; t++ )
+		{
+			if ( prim->mSpawnFlags & FX_EVEN_DISTRIBUTION )
+			{
+				delay = t * factor;
+			}
+			else
+			{
+				delay = prim->mSpawnDelay.GetVal();
+			}
+
+			// if the delay is so small, we may as well just create this bit right now
+			if ( delay < 1 && !isPortal )
+			{
+				CreateEffect( prim, clientID, -delay );
+			}
+			else
+			{
+				// We have to create a new scheduled effect so that we can create it at a later point
+				//	you should avoid this because it's much more expensive
+				sfx = new SScheduledEffect;
+				sfx->mStartTime = theFxHelper.mTime + delay;
+				sfx->mpTemplate = prim;
+				sfx->mClientID	= clientID;
+
+				if (isPortal)
+				{
+					sfx->mPortalEffect = true;
+				}
+				else
+				{
+					sfx->mPortalEffect = false;
+				}
+
+				mFxSchedule.push_front( sfx );
+			}
+		}
+	}
+
+	// We track effect templates and primitive templates separately.
+	if ( fx->mCopy )
+	{
+		// We don't use dynamic memory allocation, so just mark us as dead
+		fx->mInUse = false;
+	}
+}
+
+bool gEffectsInPortal = false; //this is just because I don't want to have to add an mPortalEffect field to every actual effect.
+
+//------------------------------------------------------
+// CreateEffect
+//	Creates the specified fx taking into account the
+//	multitude of different ways it could be spawned.
+//	
+// Input:
+//	template used to build the effect, desired effect origin, 
+//	desired orientation and how late the effect is so that
+//	it can be moved to the correct spot
+//
+// Return:
+//	none
+//------------------------------------------------------
+void CFxScheduler::CreateEffect( CPrimitiveTemplate *fx, int clientID, int delay )
+{
+	vec3_t	sRGB, eRGB;
+	vec3_t	vel, accel;
+	vec3_t	org,org2;
+	int		flags = 0;
+
+	// Origin calculations -- completely ignores most things
+	//-------------------------------------
+	VectorSet( org,  fx->mOrigin1X.GetVal(), fx->mOrigin1Y.GetVal(), fx->mOrigin1Z.GetVal() );
+	VectorSet( org2, fx->mOrigin2X.GetVal(), fx->mOrigin2Y.GetVal(), fx->mOrigin2Z.GetVal() );
+
+	// handle RGB color
+	if ( fx->mSpawnFlags & FX_RGB_COMPONENT_INTERP )
+	{
+		float perc = random();
+
+		VectorSet( sRGB, fx->mRedStart.GetVal( perc ), fx->mGreenStart.GetVal( perc ), fx->mBlueStart.GetVal( perc ) );
+		VectorSet( eRGB, fx->mRedEnd.GetVal( perc ), fx->mGreenEnd.GetVal( perc ), fx->mBlueEnd.GetVal( perc ) );
+	}
+	else
+	{
+		VectorSet( sRGB, fx->mRedStart.GetVal(), fx->mGreenStart.GetVal(), fx->mBlueStart.GetVal() );
+		VectorSet( eRGB, fx->mRedEnd.GetVal(), fx->mGreenEnd.GetVal(), fx->mBlueEnd.GetVal() );
+	}
+
+	// NOTE: This completely disregards a few specialty flags.
+	VectorSet( vel, fx->mVelX.GetVal( ), fx->mVelY.GetVal( ), fx->mVelZ.GetVal( ) );
+	VectorSet( accel, fx->mAccelX.GetVal( ), fx->mAccelY.GetVal( ), fx->mAccelZ.GetVal( ) );
+
+	// If depth hack ISN'T already on, then turn it on.  Otherwise, we treat a pre-existing depth_hack flag as NOT being depth_hack.
+	//	This is done because muzzle flash fx files are shared amongst all shooters, but for the player we need to do depth hack in first person....
+	if ( !( fx->mFlags & FX_DEPTH_HACK ) && !cg.renderingThirdPerson ) // hack!
+	{
+		flags = fx->mFlags | FX_RELATIVE | FX_DEPTH_HACK;
+	}
+	else
+	{
+		flags = (fx->mFlags | FX_RELATIVE) & ~FX_DEPTH_HACK;
+	}
+
+	// We only support particles for now
+	//------------------------
+	switch( fx->mType )
+	{
+	//---------
+	case Particle:
+	//---------
+
+		FX_AddParticle( clientID, org, vel, accel, fx->mGravity.GetVal(),
+						fx->mSizeStart.GetVal(), fx->mSizeEnd.GetVal(), fx->mSizeParm.GetVal(),
+						fx->mAlphaStart.GetVal(), fx->mAlphaEnd.GetVal(), fx->mAlphaParm.GetVal(),
+						sRGB, eRGB, fx->mRGBParm.GetVal(),
+						fx->mRotation.GetVal(), fx->mRotationDelta.GetVal(),
+						fx->mMin, fx->mMax, fx->mElasticity.GetVal(),
+						fx->mDeathFxHandles.GetHandle(), fx->mImpactFxHandles.GetHandle(),
+						fx->mLife.GetVal(), fx->mMediaHandles.GetHandle(), flags );
+		break;
+
+	//---------
+	case Line:
+	//---------
+
+		FX_AddLine( clientID, org, org2,
+						fx->mSizeStart.GetVal(), fx->mSizeEnd.GetVal(), fx->mSizeParm.GetVal(),
+						fx->mAlphaStart.GetVal(), fx->mAlphaEnd.GetVal(), fx->mAlphaParm.GetVal(),
+						sRGB, eRGB, fx->mRGBParm.GetVal(),
+						fx->mLife.GetVal(), fx->mMediaHandles.GetHandle(), fx->mImpactFxHandles.GetHandle(), flags );
+		break;
+
+	//---------
+	case Tail:
+	//---------
+
+		FX_AddTail( clientID, org, vel, accel,
+						fx->mSizeStart.GetVal(), fx->mSizeEnd.GetVal(), fx->mSizeParm.GetVal(),
+						fx->mLengthStart.GetVal(), fx->mLengthEnd.GetVal(), fx->mLengthParm.GetVal(),
+						fx->mAlphaStart.GetVal(), fx->mAlphaEnd.GetVal(), fx->mAlphaParm.GetVal(),
+						sRGB, eRGB, fx->mRGBParm.GetVal(),
+						fx->mMin, fx->mMax, fx->mElasticity.GetVal(), 
+						fx->mDeathFxHandles.GetHandle(), fx->mImpactFxHandles.GetHandle(),
+						fx->mLife.GetVal(), fx->mMediaHandles.GetHandle(), flags );
+		break;
+
+
+	//---------
+	case Sound:
+	//---------
+
+		if (gEffectsInPortal)
+		{ //could orient this anyway for panning, but eh. It's going to appear to the player in the sky the same place no matter what, so just make it a local sound.
+			theFxHelper.PlayLocalSound( fx->mMediaHandles.GetHandle(), CHAN_AUTO );
+		}
+		else
+		{
+			// bolted sounds actually play on the client....
+			theFxHelper.PlaySound( NULL, clientID, CHAN_WEAPON, fx->mMediaHandles.GetHandle() );
+		}
+		break;
+
+#ifdef _IMMERSION
+	//---------
+	case Force:
+	//---------
+
+		// Analogous to Sound (same assumption defined in RegisterForce)
+		theFxHelper.PlayForce( clientID, fx->mMediaHandles.GetHandle() );
+		break;
+#endif // _IMMERSION
+	//---------
+	case Light:
+	//---------
+
+		// don't much care if the light stays bolted...so just add it.  
+		if ( clientID >= 0 && clientID < ENTITYNUM_WORLD )
+		{
+			// ..um, ok.....
+			centity_t *cent = &cg_entities[clientID];
+
+			if ( cent && cent->gent && cent->gent->client )
+			{
+				FX_AddLight( cent->gent->client->renderInfo.muzzlePoint, fx->mSizeStart.GetVal(), fx->mSizeEnd.GetVal(), fx->mSizeParm.GetVal(),
+						sRGB, eRGB, fx->mRGBParm.GetVal(),
+						fx->mLife.GetVal(), fx->mFlags );
+			}
+		}
+		break;
+
+	//---------
+	case CameraShake:
+	//---------
+
+		if ( clientID >= 0 && clientID < ENTITYNUM_WORLD )
+		{
+			// ..um, ok.....
+			centity_t *cent = &cg_entities[clientID];
+
+			if ( cent && cent->gent && cent->gent->client )
+			{
+				theFxHelper.CameraShake( cent->gent->currentOrigin, fx->mElasticity.GetVal(), fx->mRadius.GetVal(), fx->mLife.GetVal() );
+			}
+		}
+		break;
+
+	default:
+		break;
+	}
+
+	// Track when we need to clean ourselves up if we are a copy
+	if ( fx->mCopy )
+	{
+		fx->mRefCount--;
+
+		if ( fx->mRefCount <= 0 )
+		{
+			delete fx;
+		}
+	}
+}
+
+//------------------------------------------------------
+// PlayEffect
+//	Handles scheduling an effect so all the components
+//	happen at the specified time.  Uses the specified axis
+//	
+// Input:
+//	Effect id, the origin, and axis.
+//	Optional boltInfo (defaults to -1)
+//  Optional entity number to be used by a cheap entity origin bolt (defaults to -1)
+//
+// Return:
+//	none
+//------------------------------------------------------
+void CFxScheduler::PlayEffect( int id, vec3_t origin, vec3_t axis[3], const int boltInfo, const int entNum, bool isPortal, int iLoopTime, bool isRelative )
+{
+	SEffectTemplate			*fx;
+	CPrimitiveTemplate		*prim;
+	int						i = 0;
+	int						count = 0, delay = 0;
+	float					factor = 0.0f;
+	bool					forceScheduling = false;
+
+	if ( id < 1 || id >= FX_MAX_EFFECTS || !mEffectTemplates[id].mInUse )
+	{
+		// Now you've done it!
+		ReportPlayEffectError(id);
+		return;
+	}
+
+	// Don't bother scheduling the effect if the system is currently frozen
+	if ( fx_freeze.integer )
+	{
+		return;
+	}
+
+	int	modelNum = 0, boltNum = -1;
+	int	entityNum = entNum;
+
+#ifdef _IMMERSION
+	entityNum =
+	(	entNum < -1					// HACKHACKHACK (negative if effect plays uncentered on an entity)
+	?	FF_CLIENT( entNum )			// decode -2 as entNum=0, -3 as entNum=1, ...
+	:	entNum						// default
+	);
+#endif // _IMMERSION
+	if ( boltInfo > 0 )
+	{
+		// extract the wraith ID from the bolt info
+		modelNum	= ( boltInfo >> MODEL_SHIFT )	& MODEL_AND;
+		boltNum		= ( boltInfo >> BOLT_SHIFT )	& BOLT_AND;
+		entityNum	= ( boltInfo >> ENTITY_SHIFT )	& ENTITY_AND;
+
+		// We always force ghoul bolted objects to be scheduled so that they don't play right away.
+		forceScheduling = true;
+		
+		if (iLoopTime)//0 = not looping, 1 for infinite, else duration
+		{//store off the id to reschedule every frame
+			ScheduleLoopedEffect(id, boltInfo, isPortal, iLoopTime, isRelative);
+		}
+	}
+
+
+	// Get the effect.
+	fx = &mEffectTemplates[id];
+
+	// Loop through the primitives and schedule each bit
+	for ( i = 0; i < fx->mPrimitiveCount; i++ )
+	{
+		prim = fx->mPrimitives[i];
+
+		if ( prim->mCullRange )
+		{
+			if ( DistanceSquared( origin, cg.refdef.vieworg ) > prim->mCullRange )  // cull range has already been squared
+			{
+				// is too far away, so don't add this primitive group
+				continue;
+			}
+		}
+
+		count = prim->mSpawnCount.GetRoundedVal();
+
+		if ( prim->mCopy )
+		{
+			// If we are a copy, we need to store a "how many references count" so that we
+			//	can keep the primitive template around for the correct amount of time.
+			prim->mRefCount = count;
+		}
+
+		if ( prim->mSpawnFlags & FX_EVEN_DISTRIBUTION )
+		{
+			factor = abs(prim->mSpawnDelay.GetMax() - prim->mSpawnDelay.GetMin()) / (float)count;
+		}
+
+		// Schedule the random number of bits
+		for ( int t = 0; t < count; t++ )
+		{
+			if ( prim->mSpawnFlags & FX_EVEN_DISTRIBUTION )
+			{
+				delay = t * factor;
+			}
+			else
+			{
+				delay = prim->mSpawnDelay.GetVal();
+			}
+
+			// if the delay is so small, we may as well just create this bit right now
+			if ( delay < 1 && !forceScheduling && !isPortal )
+			{
+#ifdef _IMMERSION
+				if ( boltInfo == -1 && entNum > -1 )
+#else
+				if ( boltInfo == -1 && entNum != -1 )
+#endif // _IMMERSION
+				{
+					// Find out where the entity currently is
+					CreateEffect( prim, cg_entities[entNum].lerpOrigin, axis, -delay );
+				}
+				else
+				{
+					CreateEffect( prim, origin, axis, -delay );
+				}
+			}
+			else
+			{
+				// We have to create a new scheduled effect so that we can create it at a later point
+				//	you should avoid this because it's much more expensive
+				SScheduledEffect	*sfx;
+				sfx = new SScheduledEffect;
+				sfx->mStartTime = theFxHelper.mTime + delay;
+				sfx->mpTemplate = prim;
+				sfx->mClientID = -1;
+				sfx->mIsRelative = isRelative;
+				sfx->mEntNum = entityNum;	//ent if bolted, else -1 for none, or -2 for _Immersion client 0
+
+				sfx->mPortalEffect = isPortal;
+
+				if ( boltInfo == -1 )
+				{
+#ifdef _IMMERSION
+					if ( entNum <= -1 )
+#else
+					if ( entNum == -1 )
+#endif // _IMMERSION
+					{
+						// we aren't bolting, so make sure the spawn system knows this by putting -1's in these fields
+						sfx->mBoltNum = -1;
+						sfx->mModelNum = 0;
+
+						if ( origin )
+						{
+							VectorCopy( origin, sfx->mOrigin );
+						}
+						else
+						{
+							VectorClear( sfx->mOrigin );
+						}
+
+						AxisCopy( axis, sfx->mAxis );
+					}
+					else
+					{
+						// we are doing bolting onto the origin of the entity, so use a cheaper method
+						sfx->mBoltNum = -1;
+						sfx->mModelNum = 0;
+
+						AxisCopy( axis, sfx->mAxis );
+					}
+				}
+				else
+				{
+					// we are bolting, so store the extra info
+					sfx->mBoltNum = boltNum;
+					sfx->mModelNum = modelNum;
+
+					// Also, the ghoul bolt may not be around yet, so delay the creation one frame
+					sfx->mStartTime++;
+				}
+
+				mFxSchedule.push_front( sfx );
+			}
+		}
+	}
+
+	// We track effect templates and primitive templates separately.
+	if ( fx->mCopy )
+	{
+		// We don't use dynamic memory allocation, so just mark us as dead
+		fx->mInUse = false;
+	}
+}
+
+//------------------------------------------------------
+// PlayEffect
+//	Handles scheduling an effect so all the components
+//	happen at the specified time.  Applies a default up
+//	axis.
+//	
+// Input:
+//	Effect file name and the origin
+//
+// Return:
+//	none
+//------------------------------------------------------
+void CFxScheduler::PlayEffect( const char *file, vec3_t origin, bool isPortal )
+{
+	char	sfile[MAX_QPATH];
+
+	// Get an extenstion stripped version of the file
+	COM_StripExtension( file, sfile );
+
+	PlayEffect( mEffectIDs[sfile], origin, isPortal );
+
+#ifndef FINAL_BUILD
+	if ( mEffectIDs[sfile] == 0 )
+	{
+		theFxHelper.Print( "CFxScheduler::PlayEffect unregistered/non-existent effect: %s\n", file );		
+	}
+#endif
+}
+
+//------------------------------------------------------
+// PlayEffect
+//	Handles scheduling an effect so all the components
+//	happen at the specified time.  Takes a forward vector
+//	and uses this to complete the axis field.
+//	
+// Input:
+//	Effect file name, the origin, and a forward vector
+//
+// Return:
+//	none
+//------------------------------------------------------
+void CFxScheduler::PlayEffect( const char *file, vec3_t origin, vec3_t forward, bool isPortal )
+{
+	char	sfile[MAX_QPATH];
+
+	// Get an extenstion stripped version of the file
+	COM_StripExtension( file, sfile );
+
+	PlayEffect( mEffectIDs[sfile], origin, forward, isPortal );
+
+#ifndef FINAL_BUILD
+	if ( mEffectIDs[sfile] == 0 )
+	{
+		theFxHelper.Print( "CFxScheduler::PlayEffect unregistered/non-existent effect: %s\n", file );		
+	}
+#endif
+}
+
+//------------------------------------------------------
+// AddScheduledEffects
+//	Handles determining if a scheduled effect should
+//	be created or not.  If it should it handles converting
+//	the template effect into a real one.
+//	
+// Input:
+//	boolean portal (true when adding effects to be drawn in the skyportal)
+//
+// Return:
+//	none
+//------------------------------------------------------
+void CFxScheduler::AddScheduledEffects( bool portal )
+{
+	TScheduledEffect::iterator	itr, next;
+	vec3_t						origin;
+	vec3_t						axis[3];
+	int							oldEntNum = -1, oldBoltIndex = -1, oldModelNum = -1;
+	qboolean					doesBoltExist  = qfalse;
+
+	if (portal)
+	{
+		gEffectsInPortal = true;
+	}
+	else
+	{
+		AddLoopedEffects();
+	}
+
+	itr = mFxSchedule.begin();
+
+	while ( itr != mFxSchedule.end() )
+	{
+		next = itr;
+		next++;
+
+		if (portal == (*itr)->mPortalEffect)
+		{
+			if ( *(*itr) <= theFxHelper.mTime )
+			{
+				if ( (*itr)->mClientID >= 0 )
+				{
+					CreateEffect( (*itr)->mpTemplate, (*itr)->mClientID, 
+									theFxHelper.mTime - (*itr)->mStartTime );
+				}
+				else if ((*itr)->mBoltNum == -1)
+				{// normal effect
+	#ifdef _IMMERSION
+					int entNum = (*itr)->mEntNum;
+					int hitEntNum =	(	entNum < -1 ?	FF_CLIENT( entNum )	:	entNum	);
+
+					CreateEffect
+					(	(*itr)->mpTemplate
+					,	(entNum >= 0 ? cg_entities[entNum].lerpOrigin : (*itr)->mOrigin)
+					,	(*itr)->mAxis
+					,	theFxHelper.mTime - (*itr)->mStartTime
+					,	hitEntNum
+					);
+	#else
+					if ( (*itr)->mEntNum != -1 )
+					{
+						// Find out where the entity currently is
+						CreateEffect( (*itr)->mpTemplate, 
+									cg_entities[(*itr)->mEntNum].lerpOrigin, (*itr)->mAxis, 
+									theFxHelper.mTime - (*itr)->mStartTime );
+					}
+					else
+					{
+						CreateEffect( (*itr)->mpTemplate, 
+									(*itr)->mOrigin, (*itr)->mAxis, 
+									theFxHelper.mTime - (*itr)->mStartTime );
+					}
+	#endif // _IMMERSION
+				}
+				else
+				{	//bolted on effect				
+					// do we need to go and re-get the bolt matrix again? Since it takes time lets try to do it only once
+					if (((*itr)->mModelNum != oldModelNum) || ((*itr)->mEntNum != oldEntNum) || ((*itr)->mBoltNum != oldBoltIndex))
+					{
+						const centity_t &cent = cg_entities[(*itr)->mEntNum];
+						if (cent.gent->ghoul2.IsValid())
+						{
+							if ((*itr)->mModelNum>=0&&(*itr)->mModelNum<cent.gent->ghoul2.size())
+							{
+								if (cent.gent->ghoul2[(*itr)->mModelNum].mModelindex>=0)
+								{
+									doesBoltExist = theFxHelper.GetOriginAxisFromBolt(cent, (*itr)->mModelNum, (*itr)->mBoltNum, origin, axis);
+								}
+							}
+						}
+					
+						oldModelNum = (*itr)->mModelNum;
+						oldEntNum = (*itr)->mEntNum;
+						oldBoltIndex = (*itr)->mBoltNum;
+					}
+
+					// only do this if we found the bolt
+					if (doesBoltExist)
+					{
+						if ((*itr)->mIsRelative )
+						{
+							CreateEffect( (*itr)->mpTemplate, 
+										vec3_origin, axis, 
+										0, (*itr)->mEntNum, (*itr)->mModelNum, (*itr)->mBoltNum );
+						}
+						else
+						{
+							CreateEffect( (*itr)->mpTemplate, 
+										origin, axis, 
+										theFxHelper.mTime - (*itr)->mStartTime );
+						}
+					}
+				}
+
+				// Get 'em out of there.
+				delete *itr;
+				mFxSchedule.erase(itr);
+			}
+		}
+
+		itr = next;
+	}
+
+	// Add all active effects into the scene
+	FX_Add(portal);
+
+	gEffectsInPortal = false;
+}
+
+//------------------------------------------------------
+// CreateEffect
+//	Creates the specified fx taking into account the
+//	multitude of different ways it could be spawned.
+//	
+// Input:
+//	template used to build the effect, desired effect origin, 
+//	desired orientation and how late the effect is so that
+//	it can be moved to the correct spot
+//
+// Return:
+//	none
+//------------------------------------------------------
+void CFxScheduler::CreateEffect( CPrimitiveTemplate *fx, const vec3_t origin, vec3_t axis[3], int lateTime, int clientID, int modelNum, int boltNum )
+{
+	vec3_t	org, org2, temp,
+				vel, accel,
+				sRGB, eRGB,
+				ang, angDelta,
+				ax[3];
+	trace_t	tr;
+	int		emitterModel;
+
+	// We may modify the axis, so make a work copy
+	AxisCopy( axis, ax );
+
+	int flags = fx->mFlags;
+	if (clientID>=0 && modelNum>=0 && boltNum>=0)
+	{//since you passed in these values, mark as relative to use them
+		flags |= FX_RELATIVE;
+	}
+
+	if( fx->mSpawnFlags & FX_RAND_ROT_AROUND_FWD )
+	{
+		RotatePointAroundVector( ax[1], ax[0], axis[1], random()*360.0f );
+		CrossProduct( ax[0], ax[1], ax[2] );
+	}
+
+	// Origin calculations
+	//-------------------------------------
+	if ( fx->mSpawnFlags & FX_CHEAP_ORG_CALC || flags & FX_RELATIVE  )
+	{ // let's take the easy way out
+		VectorSet( org, fx->mOrigin1X.GetVal(), fx->mOrigin1Y.GetVal(), fx->mOrigin1Z.GetVal() );
+	}
+	else
+	{ // time for some extra work
+		VectorScale( ax[0], fx->mOrigin1X.GetVal(), org );
+		VectorMA( org, fx->mOrigin1Y.GetVal(), ax[1], org );
+		VectorMA( org, fx->mOrigin1Z.GetVal(), ax[2], org );
+	}
+
+	// We always add our calculated offset to the passed in origin...
+	VectorAdd( org, origin, org );
+
+	// Now, we may need to calc a point on a sphere/ellipsoid/cylinder/disk and add that to it
+	//----------------------------------------------------------------
+	if ( fx->mSpawnFlags & FX_ORG_ON_SPHERE )
+	{
+		float x, y;
+		float width, height;
+		
+		x = DEG2RAD( random() * 360.0f );
+		y = DEG2RAD( random() * 180.0f );
+
+		width = fx->mRadius.GetVal();
+		height = fx->mHeight.GetVal();
+
+		// calculate point on ellipse
+		VectorSet( temp, sin(x) * width * sin(y), cos(x) * width * sin(y), cos(y) * height ); // sinx * siny, cosx * siny, cosy
+		VectorAdd( org, temp, org );
+
+		if ( fx->mSpawnFlags & FX_AXIS_FROM_SPHERE )
+		{ 
+			// well, we will now override the axis at the users request
+			VectorNormalize2( temp, ax[0] );
+			MakeNormalVectors( ax[0], ax[1], ax[2] );
+		}
+	}
+	else if ( fx->mSpawnFlags & FX_ORG_ON_CYLINDER )
+	{
+		vec3_t	pt;
+
+		// set up our point, then rotate around the current direction to.  Make unrotated cylinder centered around 0,0,0
+		VectorScale( ax[1], fx->mRadius.GetVal(), pt );
+		VectorMA( pt, crandom() * 0.5f * fx->mHeight.GetVal(), ax[0], pt );
+		RotatePointAroundVector( temp, ax[0], pt, random() * 360.0f );
+
+		VectorAdd( org, temp, org );
+
+		if ( fx->mSpawnFlags & FX_AXIS_FROM_SPHERE )
+		{ 
+			vec3_t up={0,0,1};
+
+			// well, we will now override the axis at the users request
+			VectorNormalize2( temp, ax[0] );
+
+			if ( ax[0][2] == 1.0f )
+			{
+				// readjust up
+				VectorSet( up, 0, 1, 0 );
+			}
+
+			CrossProduct( up, ax[0], ax[1] );
+			CrossProduct( ax[0], ax[1], ax[2] );
+		}
+	}
+
+
+	// There are only a few types that really use velocity and acceleration, so do extra work for those types
+	//--------------------------------------------------------------------------------------------------------
+	if ( fx->mType == Particle || fx->mType == OrientedParticle || fx->mType == Tail || fx->mType == Emitter )
+	{
+		// Velocity calculations
+		//-------------------------------------
+		if ( fx->mSpawnFlags & FX_VEL_IS_ABSOLUTE || flags & FX_RELATIVE )
+		{  
+			VectorSet( vel, fx->mVelX.GetVal(), fx->mVelY.GetVal(), fx->mVelZ.GetVal() );
+		}
+		else
+		{ // bah, do some extra work to coerce it
+			VectorScale( ax[0], fx->mVelX.GetVal(), vel );
+			VectorMA( vel, fx->mVelY.GetVal(), ax[1], vel );
+			VectorMA( vel, fx->mVelZ.GetVal(), ax[2], vel );
+		}
+
+		// Acceleration calculations
+		//-------------------------------------
+		if ( fx->mSpawnFlags & FX_ACCEL_IS_ABSOLUTE || flags & FX_RELATIVE )
+		{ 
+			VectorSet( accel, fx->mAccelX.GetVal(), fx->mAccelY.GetVal(), fx->mAccelZ.GetVal() );
+		}
+		else
+		{
+			VectorScale( ax[0], fx->mAccelX.GetVal(), accel );
+			VectorMA( accel, fx->mAccelY.GetVal(), ax[1], accel );
+			VectorMA( accel, fx->mAccelZ.GetVal(), ax[2], accel );
+		}
+
+		// Gravity is completely decoupled from acceleration since it is __always__ absolute
+		// NOTE: I only effect Z ( up/down in the Quake world )
+		accel[2] += fx->mGravity.GetVal();
+	
+		// There may be a lag between when the effect should be created and when it actually gets created.  
+		//	Since we know what the discrepancy is, we can attempt to compensate...
+		if ( lateTime > 0 )
+		{
+			// Calc the time differences
+			float ftime = lateTime * 0.001f;
+			float time2 = ftime * ftime * 0.5f;
+
+			VectorMA( vel, ftime, accel, vel );
+
+			// Predict the new position
+			for ( int i = 0 ; i < 3 ; i++ ) 
+			{
+				org[i] = org[i] + ftime * vel[i] + time2 * vel[i];
+			}
+		}
+	} // end moving types
+
+	// Line type primitives work with an origin2, so do the extra work for them
+	//--------------------------------------------------------------------------
+	if ( fx->mType == Line || fx->mType == Electricity )
+	{
+		// We may have to do a trace to find our endpoint
+		if ( fx->mSpawnFlags & FX_ORG2_FROM_TRACE )
+		{
+			VectorMA( org, FX_MAX_TRACE_DIST, ax[0], temp );
+
+			if ( fx->mSpawnFlags & FX_ORG2_IS_OFFSET )
+			{ // add a random flair to the endpoint...note: org2 will have to be pretty large to affect this much
+				// we also do this pre-trace as opposed to post trace since we may have to render an impact effect
+				//	and we will want the normal at the exact endpos...
+				if ( fx->mSpawnFlags & FX_CHEAP_ORG2_CALC || flags & FX_RELATIVE )
+				{ 
+					VectorSet( org2, fx->mOrigin2X.GetVal(), fx->mOrigin2Y.GetVal(), fx->mOrigin2Z.GetVal() );
+					VectorAdd( org2, temp, temp );
+				}
+				else
+				{ // I can only imagine a few cases where you might want to do this...
+					VectorMA( temp, fx->mOrigin2X.GetVal(), ax[0], temp );
+					VectorMA( temp, fx->mOrigin2Y.GetVal(), ax[1], temp );
+					VectorMA( temp, fx->mOrigin2Z.GetVal(), ax[2], temp );
+				}
+			}
+
+			theFxHelper.Trace( &tr, org, NULL, NULL, temp, -1, CONTENTS_SOLID | CONTENTS_SHOTCLIP );//MASK_SHOT );
+
+			if ( tr.startsolid || tr.allsolid )
+			{
+				VectorCopy( org, org2 ); // this is not a very good solution
+			}
+			else
+			{
+				VectorCopy( tr.endpos, org2 );
+			}
+
+			if ( fx->mSpawnFlags & FX_TRACE_IMPACT_FX )
+			{
+				PlayEffect( fx->mImpactFxHandles.GetHandle(), org2, tr.plane.normal );
+			}
+		}
+		else
+		{
+			if ( fx->mSpawnFlags & FX_CHEAP_ORG2_CALC || flags & FX_RELATIVE )
+			{
+				VectorSet( org2, fx->mOrigin2X.GetVal(), fx->mOrigin2Y.GetVal(), fx->mOrigin2Z.GetVal() );
+			}
+			else
+			{
+				VectorScale( ax[0], fx->mOrigin2X.GetVal(), org2 );
+				VectorMA( org2, fx->mOrigin2Y.GetVal(), ax[1], org2 );
+				VectorMA( org2, fx->mOrigin2Z.GetVal(), ax[2], org2 );
+
+				VectorAdd( org2, origin, org2 );
+			}
+
+		}
+	} // end special org2 types
+
+	// handle RGB color, but only for types that will use it
+	//---------------------------------------------------------------------------
+#ifdef _IMMERSION
+	if ( fx->mType != Sound && fx->mType != FxRunner && fx->mType != CameraShake && fx->mType != Force )
+#else
+	if ( fx->mType != Sound && fx->mType != FxRunner && fx->mType != CameraShake )
+#endif // _IMMERSION
+	{
+		if ( fx->mSpawnFlags & FX_RGB_COMPONENT_INTERP )
+		{
+			float perc = random();
+
+			VectorSet( sRGB, fx->mRedStart.GetVal( perc ), fx->mGreenStart.GetVal( perc ), fx->mBlueStart.GetVal( perc ) );
+			VectorSet( eRGB, fx->mRedEnd.GetVal( perc ), fx->mGreenEnd.GetVal( perc ), fx->mBlueEnd.GetVal( perc ) );
+		}
+		else
+		{
+			VectorSet( sRGB, fx->mRedStart.GetVal(), fx->mGreenStart.GetVal(), fx->mBlueStart.GetVal() );
+			VectorSet( eRGB, fx->mRedEnd.GetVal(), fx->mGreenEnd.GetVal(), fx->mBlueEnd.GetVal() );
+		}
+	}
+
+	// Now create the appropriate effect entity
+	//------------------------
+	switch( fx->mType )
+	{
+	//---------
+	case Particle:
+	//---------
+
+		FX_AddParticle( clientID, org, vel, accel, fx->mGravity.GetVal(),
+						fx->mSizeStart.GetVal(), fx->mSizeEnd.GetVal(), fx->mSizeParm.GetVal(),
+						fx->mAlphaStart.GetVal(), fx->mAlphaEnd.GetVal(), fx->mAlphaParm.GetVal(),
+						sRGB, eRGB, fx->mRGBParm.GetVal(),
+						fx->mRotation.GetVal(), fx->mRotationDelta.GetVal(),
+						fx->mMin, fx->mMax, fx->mElasticity.GetVal(), 
+						fx->mDeathFxHandles.GetHandle(), fx->mImpactFxHandles.GetHandle(),
+						fx->mLife.GetVal(), fx->mMediaHandles.GetHandle(), flags, modelNum, boltNum );
+		break;
+
+	//---------
+	case Line:
+	//---------
+
+		FX_AddLine( clientID, org, org2, 
+						fx->mSizeStart.GetVal(), fx->mSizeEnd.GetVal(), fx->mSizeParm.GetVal(),
+						fx->mAlphaStart.GetVal(), fx->mAlphaEnd.GetVal(), fx->mAlphaParm.GetVal(),
+						sRGB, eRGB, fx->mRGBParm.GetVal(),
+						fx->mLife.GetVal(), fx->mMediaHandles.GetHandle(), fx->mImpactFxHandles.GetHandle(), flags, modelNum, boltNum );
+		break;
+
+	//---------
+	case Tail:
+	//---------
+
+		FX_AddTail( clientID, org, vel, accel,
+						fx->mSizeStart.GetVal(), fx->mSizeEnd.GetVal(), fx->mSizeParm.GetVal(),
+						fx->mLengthStart.GetVal(), fx->mLengthEnd.GetVal(), fx->mLengthParm.GetVal(),
+						fx->mAlphaStart.GetVal(), fx->mAlphaEnd.GetVal(), fx->mAlphaParm.GetVal(),
+						sRGB, eRGB, fx->mRGBParm.GetVal(),
+						fx->mMin, fx->mMax, fx->mElasticity.GetVal(), 
+						fx->mDeathFxHandles.GetHandle(), fx->mImpactFxHandles.GetHandle(),
+						fx->mLife.GetVal(), fx->mMediaHandles.GetHandle(), flags, modelNum, boltNum );
+		break;
+
+	//----------------
+	case Electricity:
+	//----------------
+
+		FX_AddElectricity( clientID, org, org2, 
+						fx->mSizeStart.GetVal(), fx->mSizeEnd.GetVal(), fx->mSizeParm.GetVal(),
+						fx->mAlphaStart.GetVal(), fx->mAlphaEnd.GetVal(), fx->mAlphaParm.GetVal(),
+						sRGB, eRGB, fx->mRGBParm.GetVal(),
+						fx->mElasticity.GetVal(), fx->mLife.GetVal(), fx->mMediaHandles.GetHandle(), flags, modelNum, boltNum );
+		break;
+
+	//---------
+	case Cylinder:
+	//---------
+
+		FX_AddCylinder( clientID, org, ax[0],
+						fx->mSizeStart.GetVal(), fx->mSizeEnd.GetVal(), fx->mSizeParm.GetVal(),
+						fx->mSize2Start.GetVal(), fx->mSize2End.GetVal(), fx->mSize2Parm.GetVal(),
+						fx->mLengthStart.GetVal(), fx->mLengthEnd.GetVal(), fx->mLengthParm.GetVal(),
+						fx->mAlphaStart.GetVal(), fx->mAlphaEnd.GetVal(), fx->mAlphaParm.GetVal(),
+						sRGB, eRGB, fx->mRGBParm.GetVal(),
+						fx->mLife.GetVal(), fx->mMediaHandles.GetHandle(), flags, modelNum, boltNum );
+		break;
+
+	//---------
+	case Emitter:
+	//---------
+
+		// for chunk angles, you don't really need much control over the end result...you just want variation..
+		VectorSet( ang, 
+					fx->mAngle1.GetVal(), 
+					fx->mAngle2.GetVal(), 
+					fx->mAngle3.GetVal() );
+
+		vectoangles( ax[0], temp );
+		VectorAdd( ang, temp, ang );
+
+		VectorSet( angDelta, 
+					fx->mAngle1Delta.GetVal(), 
+					fx->mAngle2Delta.GetVal(), 
+					fx->mAngle3Delta.GetVal() );
+
+		emitterModel = fx->mMediaHandles.GetHandle();
+
+		FX_AddEmitter( org, vel, accel,
+						fx->mSizeStart.GetVal(), fx->mSizeEnd.GetVal(), fx->mSizeParm.GetVal(),
+						fx->mAlphaStart.GetVal(), fx->mAlphaEnd.GetVal(), fx->mAlphaParm.GetVal(),
+						sRGB, eRGB, fx->mRGBParm.GetVal(),
+						ang, angDelta,
+						fx->mMin, fx->mMax, fx->mElasticity.GetVal(),
+						fx->mDeathFxHandles.GetHandle(), fx->mImpactFxHandles.GetHandle(),
+						fx->mEmitterFxHandles.GetHandle(),
+						fx->mDensity.GetVal(), fx->mVariance.GetVal(),
+						fx->mLife.GetVal(), emitterModel, flags );
+		break;
+
+	//---------
+	case Decal:
+	//---------
+
+		// I'm calling this function ( at least for now ) because it handles projecting
+		//	the decal mark onto the surfaces properly.  This is especially important for large marks.
+		// The downside is that it's much less flexible....
+		CG_ImpactMark( fx->mMediaHandles.GetHandle(), org, ax[0], fx->mRotation.GetVal(), 
+			sRGB[0], sRGB[1], sRGB[2], fx->mAlphaStart.GetVal(), 
+			qtrue, fx->mSizeStart.GetVal(), qfalse );
+
+		if (fx->mFlags & FX_GHOUL2_DECALS)
+		{
+			trace_t	tr;
+			vec3_t	end;
+
+			VectorMA(org, 64, ax[0], end);
+
+			theFxHelper.G2Trace(&tr, org, NULL, NULL, end, ENTITYNUM_NONE, MASK_PLAYERSOLID);
+
+			if (tr.entityNum < ENTITYNUM_WORLD &&
+				g_entities[tr.entityNum].ghoul2.size())
+			{
+				gentity_t *ent = &g_entities[tr.entityNum];
+
+				CG_AddGhoul2Mark(fx->mMediaHandles.GetHandle(), fx->mSizeStart.GetVal(), tr.endpos, tr.plane.normal,
+					tr.entityNum, ent->client->ps.origin, ent->client->ps.viewangles[YAW],
+					ent->ghoul2, ent->s.modelScale, Q_irand(40000, 60000));
+			}
+		}
+		break;
+
+	//-------------------
+	case OrientedParticle:
+	//-------------------
+
+		FX_AddOrientedParticle( clientID, org, ax[0], vel, accel,
+					fx->mSizeStart.GetVal(), fx->mSizeEnd.GetVal(), fx->mSizeParm.GetVal(),
+					fx->mAlphaStart.GetVal(), fx->mAlphaEnd.GetVal(), fx->mAlphaParm.GetVal(),
+					sRGB, eRGB, fx->mRGBParm.GetVal(),
+					fx->mRotation.GetVal(), fx->mRotationDelta.GetVal(),
+					fx->mMin, fx->mMax, fx->mElasticity.GetVal(),
+					fx->mDeathFxHandles.GetHandle(), fx->mImpactFxHandles.GetHandle(),
+					fx->mLife.GetVal(), fx->mMediaHandles.GetHandle(), flags, modelNum, boltNum );
+		break;
+
+	//---------
+	case Sound:
+	//---------
+		if (gEffectsInPortal)
+		{ //could orient this anyway for panning, but eh. It's going to appear to the player in the sky the same place no matter what, so just make it a local sound.
+			theFxHelper.PlayLocalSound( fx->mMediaHandles.GetHandle(), CHAN_AUTO );
+		}
+		else if ( fx->mSpawnFlags & FX_SND_LESS_ATTENUATION )
+		{
+			theFxHelper.PlaySound( org, ENTITYNUM_NONE, CHAN_LESS_ATTEN, fx->mMediaHandles.GetHandle() );
+		}
+		else
+		{
+			theFxHelper.PlaySound( org, ENTITYNUM_NONE, CHAN_AUTO, fx->mMediaHandles.GetHandle() );
+		}
+		break;
+
+#ifdef _IMMERSION
+	//---------
+	case Force:
+	//---------
+
+		if ( clientID > -1 )	// Fix me: Allow or abolish FF_LOCAL_CLIENT?
+		theFxHelper.PlayForce( clientID, fx->mMediaHandles.GetHandle() );
+		break;
+
+#endif // _IMMERSION
+	//---------
+	case FxRunner:
+	//---------
+		
+		PlayEffect( fx->mPlayFxHandles.GetHandle(), org, ax );
+		break;
+
+	//---------
+	case Light:
+	//---------
+
+		FX_AddLight( org, fx->mSizeStart.GetVal(), fx->mSizeEnd.GetVal(), fx->mSizeParm.GetVal(),
+						sRGB, eRGB, fx->mRGBParm.GetVal(),
+						fx->mLife.GetVal(), fx->mFlags );
+		break;
+
+	//---------
+	case CameraShake:
+	//---------
+		// It calculates how intense the shake should be based on how close you are to the origin you pass in here
+		//	elasticity is actually the intensity...radius is the distance in which the shake will have some effect
+		//	life is how long the effect lasts.
+		theFxHelper.CameraShake( org, fx->mElasticity.GetVal(), fx->mRadius.GetVal(), fx->mLife.GetVal() );
+		break;
+
+	//--------------
+	case ScreenFlash:
+	//--------------
+
+		FX_AddFlash( org, 
+					sRGB, eRGB, fx->mRGBParm.GetVal(),
+					fx->mLife.GetVal(), fx->mMediaHandles.GetHandle(), fx->mFlags );
+		break;
+
+	default:
+		break;
+	}
+
+	// Track when we need to clean ourselves up if we are a copy
+	if ( fx->mCopy )
+	{
+		fx->mRefCount--;
+
+		if ( fx->mRefCount <= 0 )
+		{
+			delete fx;
+		}
+	}
+}
\ No newline at end of file
diff --git a/code/cgame/FxScheduler.h b/code/cgame/FxScheduler.h
new file mode 100644
index 0000000..f66c48d
--- /dev/null
+++ b/code/cgame/FxScheduler.h
@@ -0,0 +1,497 @@
+
+#if !defined(FX_UTIL_H_INC)
+	#include "FxUtil.h"
+#endif
+
+
+#include "../qcommon/sstring.h"
+typedef sstring_t fxString_t;
+
+#if !defined(FX_PARSING_H_INC)
+	#include "FxParsing.h"
+#endif
+
+#ifndef FX_SCHEDULER_H_INC
+#define FX_SCHEDULER_H_INC
+
+using namespace std;
+
+
+#define FX_FILE_PATH	"effects"
+
+#define FX_MAX_TRACE_DIST			WORLD_SIZE
+#define FX_MAX_EFFECTS				150		// how many effects the system can store
+#define FX_MAX_EFFECT_COMPONENTS	24		// how many primitives an effect can hold, this should be plenty
+#define FX_MAX_PRIM_NAME			32
+	
+//-----------------------------------------------
+// These are spawn flags for primitiveTemplates
+//-----------------------------------------------
+
+#define FX_ORG_ON_SPHERE		0x00001	// Pretty dang expensive, calculates a point on a sphere/ellipsoid
+#define FX_AXIS_FROM_SPHERE		0x00002	// Can be used in conjunction with org_on_sphere to cause particles to move out 
+										//	from the center of the sphere
+#define FX_ORG_ON_CYLINDER		0x00004	// calculate point on cylinder/disk
+
+#define FX_ORG2_FROM_TRACE		0x00010
+#define FX_TRACE_IMPACT_FX		0x00020	// if trace impacts, we should play one of the specified impact fx files
+#define FX_ORG2_IS_OFFSET		0x00040	// template specified org2 should be the offset from a trace endpos or 
+										//	passed in org2. You might use this to lend a random flair to the endpos.
+										//	Note: this is done pre-trace, so you may have to specify large numbers for this
+
+#define FX_CHEAP_ORG_CALC		0x00100	// Origin is calculated relative to passed in axis unless this is on.
+#define FX_CHEAP_ORG2_CALC		0x00200	// Origin2 is calculated relative to passed in axis unless this is on.
+#define FX_VEL_IS_ABSOLUTE		0x00400	// Velocity isn't relative to passed in axis with this flag on.
+#define FX_ACCEL_IS_ABSOLUTE	0x00800	// Acceleration isn't relative to passed in axis with this flag on.
+
+#define FX_RAND_ROT_AROUND_FWD	0x01000	// Randomly rotates up and right around forward vector
+#define FX_EVEN_DISTRIBUTION	0x02000	// When you have a delay, it normally picks a random time to play.  When
+										// this flag is on, it generates an even time distribution
+#define FX_RGB_COMPONENT_INTERP	0x04000	// Picks a color on the line defined by RGB min & max, default is to pick color in cube defined by min & max
+
+#define FX_AFFECTED_BY_WIND		0x10000 // we take into account our wind vector when we spawn in
+
+#define FX_SND_LESS_ATTENUATION	0x20000	// attenuate sounds less
+
+//-----------------------------------------------------------------
+//
+// CMediaHandles
+//
+// Primitive templates might want to use a list of sounds, shaders 
+//	or models to get a bit more variation in their effects.
+//
+//-----------------------------------------------------------------
+class CMediaHandles
+{
+private:
+
+	vector<int>	mMediaList;
+
+public:
+
+	void	AddHandle( int item )	{ mMediaList.push_back( item );	}
+	int		GetHandle()				{ if (mMediaList.size()==0) {return 0;}
+										else {return mMediaList[irand(0,mMediaList.size()-1)];} }
+
+	void operator=(const CMediaHandles &that );
+};
+
+
+//-----------------------------------------------------------------
+//
+// CFxRange
+//
+// Primitive templates typically use this class to define each of
+//	its members.  This is done to make it easier to create effects 
+//	with a desired range of characteristics.
+//
+//-----------------------------------------------------------------
+class CFxRange
+{
+private:
+
+	float	mMin;
+	float	mMax;
+
+public:
+
+	CFxRange()										{mMin=0; mMax=0;}
+
+	inline void		SetRange(float min,float max)	{mMin=min; mMax=max;}
+	inline void		SetMin(float min)				{mMin=min;}
+	inline void		SetMax(float max)				{mMax=max;}
+
+	inline float	GetMax() const					{return mMax;}
+	inline float	GetMin() const					{return mMin;}
+
+	inline float	GetVal(float percent) const		{if(mMin == mMax){return mMin;}
+														return (mMin + (mMax - mMin) * percent);}
+	inline float	GetVal() const					{if(mMin == mMax){return mMin;}
+														return flrand(mMin, mMax);}
+	inline int		GetRoundedVal() const			{if(mMin == mMax){return mMin;}
+														return (int)(flrand(mMin, mMax) + 0.5f);}
+
+	inline void		ForceRange(float min,float max)	{if(mMin < min){mMin=min;} if(mMin > max){mMin=max;}
+														if(mMax < min){mMax=min;} if(mMax > max){mMax=max;}}
+	inline void		Sort()							{if(mMin > mMax){float temp = mMin; mMin=mMax;mMax=temp;}}
+	void operator=(const CFxRange &that)			{mMin=that.mMin; mMax=that.mMax;}
+
+	bool operator==(const CFxRange &rhs) const		{ return ((mMin == rhs.mMin) &&
+															  (mMax == rhs.mMax)); }
+};
+
+
+//----------------------------
+// Supported primitive types
+//----------------------------
+
+enum EPrimType
+{
+	None = 0,
+	Particle,		// sprite
+	Line,
+	Tail,			// comet-like tail thing
+	Cylinder,
+	Emitter,		// emits effects as it moves, can also attach a chunk
+	Sound,
+#ifdef _IMMERSION
+	Force,
+#endif // _IMMERSION
+	Decal,			// projected onto architecture
+	OrientedParticle,
+	Electricity,
+	FxRunner,
+	Light,
+	CameraShake,
+	ScreenFlash
+};
+
+
+//-----------------------------------------------------------------
+//
+// CPrimitiveTemplate
+//
+// The primitive template is used to spawn 1 or more fx primitives 
+//	with the range of characteristics defined by the template.
+//
+// As such, I just made this one huge shared class knowing that 
+//	there won't be many of them in memory at once, 	and we won't 
+//	be dynamically creating and deleting them mid-game.  Also,
+//	note that not every primitive type will use all of these fields.
+//
+//-----------------------------------------------------------------
+class CPrimitiveTemplate
+{
+
+public:
+
+	// These kinds of things should not even be allowed to be accessed publicly
+	bool			mCopy;
+	int				mRefCount;		// For a copy of a primitive...when we figure out how many items we want to spawn, 
+									//	we'll store that here and then decrement us for each we actually spawn.  When we 
+									//	hit zero, we are no longer used and so we can just free ourselves
+
+	char			mName[FX_MAX_PRIM_NAME];
+
+	EPrimType		mType;
+
+	CFxRange		mSpawnDelay;
+	CFxRange		mSpawnCount;
+	CFxRange		mLife;
+	int				mCullRange;
+
+	CMediaHandles	mMediaHandles;
+	CMediaHandles	mImpactFxHandles;
+	CMediaHandles	mDeathFxHandles;
+	CMediaHandles	mEmitterFxHandles;
+	CMediaHandles	mPlayFxHandles;
+
+	int				mFlags;			// These need to get passed on to the primitive
+	int				mSpawnFlags;	// These are only used to control spawning, but never get passed to prims.
+
+	vec3_t			mMin;
+	vec3_t			mMax;
+
+	CFxRange		mOrigin1X;
+	CFxRange		mOrigin1Y;
+	CFxRange		mOrigin1Z;
+
+	CFxRange		mOrigin2X;
+	CFxRange		mOrigin2Y;
+	CFxRange		mOrigin2Z;
+
+	CFxRange		mRadius;		// spawn on sphere/ellipse/disk stuff.
+	CFxRange		mHeight;
+
+	CFxRange		mRotation;
+	CFxRange		mRotationDelta;
+
+	CFxRange		mAngle1;
+	CFxRange		mAngle2;
+	CFxRange		mAngle3;
+
+	CFxRange		mAngle1Delta;
+	CFxRange		mAngle2Delta;
+	CFxRange		mAngle3Delta;
+
+	CFxRange		mVelX;
+	CFxRange		mVelY;
+	CFxRange		mVelZ;
+
+	CFxRange		mAccelX;
+	CFxRange		mAccelY;
+	CFxRange		mAccelZ;
+
+	CFxRange		mGravity;
+
+	CFxRange		mDensity;
+	CFxRange		mVariance;
+
+	CFxRange		mRedStart;
+	CFxRange		mGreenStart;
+	CFxRange		mBlueStart;
+
+	CFxRange		mRedEnd;
+	CFxRange		mGreenEnd;
+	CFxRange		mBlueEnd;
+
+	CFxRange		mRGBParm;
+
+	CFxRange		mAlphaStart;
+	CFxRange		mAlphaEnd;
+	CFxRange		mAlphaParm;
+
+	CFxRange		mSizeStart;
+	CFxRange		mSizeEnd;
+	CFxRange		mSizeParm;
+
+	CFxRange		mSize2Start;
+	CFxRange		mSize2End;
+	CFxRange		mSize2Parm;
+
+	CFxRange		mLengthStart;
+	CFxRange		mLengthEnd;
+	CFxRange		mLengthParm;
+
+	CFxRange		mTexCoordS;
+	CFxRange		mTexCoordT;
+
+	CFxRange		mElasticity;
+
+
+	// Lower level parsing utilities
+	bool ParseVector( const char *val, vec3_t min, vec3_t max );
+	bool ParseFloat( const char *val, float *min, float *max );
+	bool ParseGroupFlags( const char *val, int *flags );
+
+	// Base key processing
+	// Note that these all have their own parse functions in case it becomes important to do certain kinds
+	//	of validation specific to that type.
+	bool ParseMin( const char *val );
+	bool ParseMax( const char *val );
+	bool ParseDelay( const char *val );
+	bool ParseCount( const char *val );
+	bool ParseLife( const char *val );
+	bool ParseElasticity( const char *val );
+	bool ParseFlags( const char *val );
+	bool ParseSpawnFlags( const char *val );
+
+	bool ParseOrigin1( const char *val );
+	bool ParseOrigin2( const char *val );
+	bool ParseRadius( const char *val );
+	bool ParseHeight( const char *val );
+	bool ParseRotation( const char *val );
+	bool ParseRotationDelta( const char *val );
+	bool ParseAngle( const char *val );
+	bool ParseAngleDelta( const char *val );
+	bool ParseVelocity( const char *val );
+	bool ParseAcceleration( const char *val );
+	bool ParseGravity( const char *val );
+	bool ParseDensity( const char *val );
+	bool ParseVariance( const char *val );
+
+	// Group type processing
+	bool ParseRGB( CGPGroup *grp );
+	bool ParseAlpha( CGPGroup *grp );
+	bool ParseSize( CGPGroup *grp );
+	bool ParseSize2( CGPGroup *grp );
+	bool ParseLength( CGPGroup *grp );
+
+	bool ParseModels( CGPValue *grp );
+	bool ParseShaders( CGPValue *grp );
+	bool ParseSounds( CGPValue *grp );
+#ifdef _IMMERSION
+	bool ParseForces( CGPValue *grp );
+#endif // _IMMERSION
+
+	bool ParseImpactFxStrings( CGPValue *grp );
+	bool ParseDeathFxStrings( CGPValue *grp );
+	bool ParseEmitterFxStrings( CGPValue *grp );
+	bool ParsePlayFxStrings( CGPValue *grp );
+
+	// Group keys
+	bool ParseRGBStart( const char *val );
+	bool ParseRGBEnd( const char *val );
+	bool ParseRGBParm( const char *val );
+	bool ParseRGBFlags( const char *val );
+
+	bool ParseAlphaStart( const char *val );
+	bool ParseAlphaEnd( const char *val );
+	bool ParseAlphaParm( const char *val );
+	bool ParseAlphaFlags( const char *val );
+
+	bool ParseSizeStart( const char *val );
+	bool ParseSizeEnd( const char *val );
+	bool ParseSizeParm( const char *val );
+	bool ParseSizeFlags( const char *val );
+
+	bool ParseSize2Start( const char *val );
+	bool ParseSize2End( const char *val );
+	bool ParseSize2Parm( const char *val );
+	bool ParseSize2Flags( const char *val );
+
+	bool ParseLengthStart( const char *val );
+	bool ParseLengthEnd( const char *val );
+	bool ParseLengthParm( const char *val );
+	bool ParseLengthFlags( const char *val );
+
+
+public:
+
+	CPrimitiveTemplate();
+	~CPrimitiveTemplate()	{};
+
+	bool ParsePrimitive( CGPGroup *grp );
+
+	void operator=(const CPrimitiveTemplate &that);
+};
+
+// forward declaration
+struct SEffectTemplate;
+
+// Effects are built of one or more primitives
+struct SEffectTemplate
+{
+	bool	mInUse;
+	bool	mCopy;
+	char	mEffectName[MAX_QPATH];					// is this extraneous??
+	int		mPrimitiveCount;
+	int		mRepeatDelay;
+	CPrimitiveTemplate	*mPrimitives[FX_MAX_EFFECT_COMPONENTS];	 
+
+	bool operator == (const char * name) const 
+	{
+		return !stricmp( mEffectName, name );
+	}
+	void operator=(const SEffectTemplate &that);
+};
+
+
+
+//-----------------------------------------------------------------
+//
+// CFxScheduler
+//
+// The scheduler not only handles requests to play an effect, it 
+//	tracks the request throughout its life if necessary, creating 
+//	any of the delayed components as needed.
+//
+//-----------------------------------------------------------------
+// needs to be in global space now (loadsave stuff)
+
+#define MAX_LOOPED_FX 32
+// We hold a looped effect here
+struct SLoopedEffect
+{
+	int		mId;			// effect id
+	int		mBoltInfo;		// used to determine which bolt on the ghoul2 model we should be attaching this effect to
+	int		mNextTime;		//time to render again
+	int		mLoopStopTime;	//time to die
+	bool	mPortalEffect;	// rww - render this before skyportals, and not in the normal world view.
+	bool	mIsRelative;	// bolt this puppy on keep it updated
+};
+
+class CFxScheduler
+{
+private:
+
+	// We hold a scheduled effect here
+	struct SScheduledEffect
+	{
+		CPrimitiveTemplate	*mpTemplate;	// primitive template
+		int		mStartTime;
+		char	mModelNum;		// uset to determine which ghoul2 model we want to bolt this effect to
+		char	mBoltNum;		// used to determine which bolt on the ghoul2 model we should be attaching this effect to
+		short	mEntNum;		// used to determine which entity this ghoul model is attached to.
+		short	mClientID;		// FIXME: redundant. this is used for muzzle bolts, merge into normal bolting
+		bool	mPortalEffect;	// rww - render this before skyportals, and not in the normal world view.
+		bool	mIsRelative;	// bolt this puppy on keep it updated
+		vec3_t	mOrigin;
+		vec3_t	mAxis[3];
+
+		bool operator <= (const int time) const 
+		{
+			return mStartTime <= time;
+		}
+	};
+	
+/* Looped Effects get stored and reschedule at mRepeatRate */
+
+	// must be in sync with gLoopedEffectArray[MAX_LOOPED_FX]!
+	//
+	SLoopedEffect	mLoopedEffectArray[MAX_LOOPED_FX];
+
+	int		ScheduleLoopedEffect( int id, int boltInfo, bool isPortal, int iLoopTime, bool isRelative );
+	void	AddLoopedEffects( );
+
+
+	// this makes looking up the index based on the string name much easier
+	typedef map<fxString_t, int>			TEffectID;
+
+	typedef list<SScheduledEffect*>			TScheduledEffect;
+
+	// Effects
+	SEffectTemplate		mEffectTemplates[FX_MAX_EFFECTS];
+	TEffectID			mEffectIDs;								// if you only have the unique effect name, you'll have to use this to get the ID.
+
+	// List of scheduled effects that will need to be created at the correct time.
+	TScheduledEffect	mFxSchedule;
+
+
+	// Private function prototypes
+	SEffectTemplate *GetNewEffectTemplate( int *id, const char *file );
+
+	void	AddPrimitiveToEffect( SEffectTemplate *fx, CPrimitiveTemplate *prim );
+	int		ParseEffect( const char *file, CGPGroup *base );
+
+	void	CreateEffect( CPrimitiveTemplate *fx, const vec3_t origin, vec3_t axis[3], int lateTime, int clientID = -1, int modelNum = -1, int boltNum = -1 );
+	void	CreateEffect( CPrimitiveTemplate *fx, int clientID, int lateTime );
+
+public:
+
+	CFxScheduler();
+
+	void	LoadSave_Read();
+	void	LoadSave_Write();
+	void	FX_CopeWithAnyLoadedSaveGames();
+	
+	int		RegisterEffect( const char *file, bool bHasCorrectPath = false );	// handles pre-caching
+
+
+	// Nasty overloaded madness
+	void	PlayEffect( int id, vec3_t org, bool isPortal = false );							// uses a default up axis
+	void	PlayEffect( int id, vec3_t org, vec3_t fwd, bool isPortal = false );				// builds arbitrary perp. right vector, does a cross product to define up
+	void	PlayEffect( int id, vec3_t origin, vec3_t axis[3], const int boltInfo=-1, const int entNum=-1, bool isPortal = false, int iLoopTime = false, bool isRelative = false );
+	void	PlayEffect( const char *file, vec3_t org, bool isPortal = false );					// uses a default up axis
+	void	PlayEffect( const char *file, vec3_t org, vec3_t fwd, bool isPortal = false );		// builds arbitrary perp. right vector, does a cross product to define up
+	void	PlayEffect( const char *file, vec3_t origin, vec3_t axis[3], const int boltInfo, const int entNum, bool isPortal = false, int iLoopTime = false, bool isRelative = false );
+
+	//for muzzle
+	void	PlayEffect( const char *file, int clientID, bool isPortal = false );
+
+#ifdef _IMMERSION	// for ff-system
+	void	PlayEffect( int id, int clientNum, vec3_t org, vec3_t fwd, bool isPortal = false );
+	void	PlayEffect( const char *file, int clientNum, vec3_t origin, vec3_t forward, bool isPortal = false );
+#endif // _IMMERSION
+
+	void	StopEffect( const char *file, const int boltInfo, bool isPortal = false );	//find a scheduled Looping effect with these parms and kill it
+
+	void	AddScheduledEffects( bool portal );								// call once per CGame frame [rww ammendment - twice now actually, but first only renders portal effects]
+
+	int		NumScheduledFx()	{ return mFxSchedule.size();	}
+	void	Clean(bool bRemoveTemplates = true, int idToPreserve = 0);	// clean out the system
+
+	// FX Override functions
+	SEffectTemplate		*GetEffectCopy( int fxHandle, int *newHandle );
+	SEffectTemplate		*GetEffectCopy( const char *file, int *newHandle );
+
+	CPrimitiveTemplate	*GetPrimitiveCopy( SEffectTemplate *effectCopy, const char *componentName );
+};
+
+//-------------------
+// The one and only
+//-------------------
+extern CFxScheduler theFxScheduler;
+
+
+#endif // FX_SCHEDULER_H_INC
diff --git a/code/cgame/FxSystem.cpp b/code/cgame/FxSystem.cpp
new file mode 100644
index 0000000..958dd47
--- /dev/null
+++ b/code/cgame/FxSystem.cpp
@@ -0,0 +1,215 @@
+// this include must remain at the top of every FXxxxx.CPP file
+#include "common_headers.h"
+
+#if !defined(FX_SCHEDULER_H_INC)
+	#include "FxScheduler.h"
+#endif
+
+#include "cg_media.h"	//for cgs.model_draw for G2
+
+extern vmCvar_t	fx_debug;
+extern vmCvar_t	fx_freeze;
+
+extern void CG_ExplosionEffects( vec3_t origin, float intensity, int radius, int time );
+
+// Stuff for the FxHelper
+//------------------------------------------------------
+void SFxHelper::Init()
+{
+	mTime = 0;
+}
+
+//------------------------------------------------------
+void SFxHelper::Print( const char *msg, ... )
+{
+#ifndef FINAL_BUILD
+
+	va_list		argptr;
+	char		text[1024];
+
+	va_start( argptr, msg );
+	vsprintf( text, msg, argptr );
+	va_end( argptr );
+ 
+	gi.Printf( text );
+
+#endif
+}
+
+//------------------------------------------------------
+void SFxHelper::AdjustTime( int frameTime )
+{
+	if ( fx_freeze.integer || ( frameTime <= 0 ))
+	{
+		// Allow no time progression when we are paused.
+		mFrameTime = 0;
+		mFloatFrameTime = 0.0f;
+	}
+	else
+	{
+		if ( !cg_paused.integer )
+		{
+			if ( frameTime > 300 ) // hack for returning from paused and time bursts
+			{
+				frameTime = 300;
+			}
+
+			mFrameTime = frameTime;
+			mFloatFrameTime = mFrameTime * 0.001f;
+			mTime += mFrameTime;
+		}
+	}
+}
+
+//------------------------------------------------------
+int SFxHelper::OpenFile( const char *file, fileHandle_t *fh, int mode )
+{
+//	char path[256];
+
+//	sprintf( path, "%s/%s", FX_FILE_PATH, file );
+	return cgi_FS_FOpenFile( file, fh, FS_READ );
+}
+
+//------------------------------------------------------
+int SFxHelper::ReadFile( void *data, int len, fileHandle_t fh )
+{
+	return cgi_FS_Read( data, len, fh );
+}
+
+//------------------------------------------------------
+void SFxHelper::CloseFile( fileHandle_t fh )
+{
+	cgi_FS_FCloseFile( fh );
+}
+
+//------------------------------------------------------
+void SFxHelper::PlaySound( const vec3_t org, int entityNum, int entchannel, int sfxHandle )
+{
+	cgi_S_StartSound( org, entityNum, entchannel, sfxHandle );
+}
+
+//------------------------------------------------------
+void SFxHelper::PlayLocalSound( int sfxHandle, int channelNum )
+{
+	cgi_S_StartLocalSound(sfxHandle, channelNum);
+}
+
+//------------------------------------------------------
+void SFxHelper::Trace( trace_t *tr, vec3_t start, vec3_t min, vec3_t max, 
+						vec3_t end, int skipEntNum, int flags )
+{
+	CG_Trace( tr, start, min, max, end, skipEntNum, flags );
+}
+
+void SFxHelper::G2Trace( trace_t *tr, vec3_t start, vec3_t min, vec3_t max, 
+						vec3_t end, int skipEntNum, int flags )
+{
+	//CG_Trace( tr, start, min, max, end, skipEntNum, flags, G2_COLLIDE );
+	gi.trace(tr, start, NULL, NULL, end, skipEntNum, flags, G2_COLLIDE);
+}
+
+//------------------------------------------------------
+void SFxHelper::AddFxToScene( refEntity_t *ent )
+{
+	cgi_R_AddRefEntityToScene( ent );
+}
+
+//------------------------------------------------------
+int SFxHelper::RegisterShader( const char *shader )
+{
+	return cgi_R_RegisterShader( shader );
+}
+
+//------------------------------------------------------
+int SFxHelper::RegisterSound( const char *sound )
+{
+	return cgi_S_RegisterSound( sound );
+}
+
+//------------------------------------------------------
+int SFxHelper::RegisterModel( const char *model )
+{
+	return cgi_R_RegisterModel( model );
+}
+
+//------------------------------------------------------
+void SFxHelper::AddLightToScene( vec3_t org, float radius, float red, float green, float blue )
+{
+	cgi_R_AddLightToScene( org, radius, red, green, blue );
+}
+
+//------------------------------------------------------
+void SFxHelper::AddPolyToScene( int shader, int count, polyVert_t *verts )
+{
+	cgi_R_AddPolyToScene( shader, count, verts );
+}
+
+//------------------------------------------------------
+void SFxHelper::CameraShake( vec3_t origin, float intensity, int radius, int time )
+{
+	CG_ExplosionEffects( origin, intensity, radius, time );
+}
+
+//------------------------------------------------------
+int SFxHelper::GetOriginAxisFromBolt(const centity_t &cent, int modelNum, int boltNum, vec3_t /*out*/origin, vec3_t /*out*/axis[3])
+{
+	if ((cg.time-cent.snapShotTime) > 200)
+	{ //you were added more than 200ms ago, so I say you are no longer valid/in our snapshot.
+		return 0;
+	}
+
+	int doesBoltExist;
+	mdxaBone_t 	boltMatrix;
+	vec3_t	G2Angles = {cent.lerpAngles[0] , cent.lerpAngles[1], cent.lerpAngles[2]};
+	if ( cent.currentState.eType == ET_PLAYER )
+	{//players use cent.renderAngles
+		VectorCopy( cent.renderAngles, G2Angles );
+		
+		if ( cent.gent //has a game entity
+			&& cent.gent->s.m_iVehicleNum != 0 //in a vehicle
+			&& cent.gent->m_pVehicle //have a valid vehicle pointer
+			&& cent.gent->m_pVehicle->m_pVehicleInfo->type != VH_FIGHTER //it's not a fighter
+			&& cent.gent->m_pVehicle->m_pVehicleInfo->type != VH_SPEEDER //not a speeder
+			)
+		{
+			G2Angles[PITCH]=0;
+			G2Angles[ROLL] =0;
+		}
+	}
+
+	// go away and get me the bolt position for this frame please
+	doesBoltExist = gi.G2API_GetBoltMatrix(cent.gent->ghoul2, modelNum, 
+		boltNum, &boltMatrix, G2Angles, 
+		cent.lerpOrigin, cg.time, cgs.model_draw, 
+		cent.currentState.modelScale);
+	// set up the axis and origin we need for the actual effect spawning
+	origin[0] = boltMatrix.matrix[0][3];
+	origin[1] = boltMatrix.matrix[1][3];
+	origin[2] = boltMatrix.matrix[2][3];
+
+	axis[1][0] = boltMatrix.matrix[0][0];
+	axis[1][1] = boltMatrix.matrix[1][0];
+	axis[1][2] = boltMatrix.matrix[2][0];
+
+	axis[0][0] = boltMatrix.matrix[0][1];
+	axis[0][1] = boltMatrix.matrix[1][1];
+	axis[0][2] = boltMatrix.matrix[2][1];
+
+	axis[2][0] = boltMatrix.matrix[0][2];
+	axis[2][1] = boltMatrix.matrix[1][2];
+	axis[2][2] = boltMatrix.matrix[2][2];
+	return doesBoltExist;
+}
+#ifdef _IMMERSION
+//------------------------------------------------------
+ffHandle_t SFxHelper::RegisterForce( const char *force, int channel )
+{
+	return cgi_FF_Register( force, channel );
+}
+
+//------------------------------------------------------
+void SFxHelper::PlayForce( int entityNum, ffHandle_t ff )
+{
+	cgi_FF_Start( ff, entityNum );
+}
+#endif // _IMMERSION
\ No newline at end of file
diff --git a/code/cgame/FxSystem.h b/code/cgame/FxSystem.h
new file mode 100644
index 0000000..a9ee6e2
--- /dev/null
+++ b/code/cgame/FxSystem.h
@@ -0,0 +1,84 @@
+
+#if !defined(CG_LOCAL_H_INC)
+	#include "cg_local.h"
+#endif
+
+#ifndef FX_SYSTEM_H_INC
+#define FX_SYSTEM_H_INC
+
+
+#define irand	Q_irand
+#define flrand	Q_flrand
+
+extern vmCvar_t	fx_debug;
+extern vmCvar_t	fx_freeze;
+
+inline void Vector2Clear(vec2_t a)
+{
+	a[0] = 0.0f;
+	a[1] = 0.0f;
+}
+
+inline void Vector2Set(vec2_t a,float b,float c)
+{
+	a[0] = b;
+	a[1] = c;
+}
+
+inline void Vector2Copy(vec2_t src,vec2_t dst)
+{
+	dst[0] = src[0];
+	dst[1] = src[1];
+}
+
+
+extern void	CG_CalcEntityLerpPositions( centity_t * );	
+
+
+struct SFxHelper
+{
+	int		mTime;
+	int		mFrameTime;
+	float	mFloatFrameTime;
+
+	void	Init();
+	void	AdjustTime( int time );
+
+	// These functions are wrapped and used by the fx system in case it makes things a bit more portable
+	void	Print( const char *msg, ... );
+
+	// File handling
+	int		OpenFile( const char *path, fileHandle_t *fh, int mode );
+	int		ReadFile( void *data, int len, fileHandle_t fh );
+	void	CloseFile( fileHandle_t fh );
+
+	// Sound
+	void	PlaySound( const vec3_t origin, int entityNum, int entchannel, sfxHandle_t sfx );
+	void	PlayLocalSound( sfxHandle_t sfx, int channelNum );
+	int		RegisterSound( const char *sound );
+
+#ifdef _IMMERSION
+	void	PlayForce( int entityNum, ffHandle_t ff );
+	ffHandle_t RegisterForce( const char *force, int channel );
+#endif // _IMMERSION
+	//G2
+	int		GetOriginAxisFromBolt(const centity_t &cent, int modelNum, int boltNum, vec3_t /*out*/origin, vec3_t /*out*/*axis);
+
+	// Physics/collision
+	void	Trace( trace_t *tr, vec3_t start, vec3_t min, vec3_t max, vec3_t end, int skipEntNum, int flags );
+	void	G2Trace( trace_t *tr, vec3_t start, vec3_t min, vec3_t max, vec3_t end, int skipEntNum, int flags );
+
+	void	AddFxToScene( refEntity_t *ent );
+	void	AddLightToScene( vec3_t org, float radius, float red, float green, float blue );
+
+	int		RegisterShader( const char *shader );
+	int		RegisterModel( const char *model );
+
+	void	AddPolyToScene( int shader, int count, polyVert_t *verts );
+
+	void	CameraShake( vec3_t origin, float intensity, int radius, int time );
+};
+
+extern SFxHelper	theFxHelper;
+
+#endif // FX_SYSTEM_H_INC
diff --git a/code/cgame/FxTemplate.cpp b/code/cgame/FxTemplate.cpp
new file mode 100644
index 0000000..9bc8cbd
--- /dev/null
+++ b/code/cgame/FxTemplate.cpp
@@ -0,0 +1,2370 @@
+
+// this include must remain at the top of every CPP file
+#include "common_headers.h"
+
+#if !defined(FX_SCHEDULER_H_INC)
+	#include "FxScheduler.h"
+#endif
+
+//------------------------------------------------------
+// CPrimitiveTemplate
+//	Set up our minimal default values
+//
+// Input:
+//	none
+//
+// Return:
+//	none
+//------------------------------------------------------
+CPrimitiveTemplate::CPrimitiveTemplate()
+{ 
+	// We never start out as a copy or with a name
+	mCopy = false;
+	mName[0] = 0;
+	mCullRange = 0;
+
+	mFlags = mSpawnFlags = 0;
+
+	mLife.SetRange( 50.0f, 50.0f );
+	mSpawnCount.SetRange( 1.0f, 1.0f );
+	mRadius.SetRange( 10.0f, 10.0f );
+	mHeight.SetRange( 10.0f, 10.0f );
+
+	VectorSet( mMin, 0.0f, 0.0f, 0.0f );
+	VectorSet( mMax, 0.0f, 0.0f, 0.0f );
+
+	mRedStart.SetRange( 1.0f, 1.0f );
+	mGreenStart.SetRange( 1.0f, 1.0f );
+	mBlueStart.SetRange( 1.0f, 1.0f );
+
+	mRedEnd.SetRange( 1.0f, 1.0f );
+	mGreenEnd.SetRange( 1.0f, 1.0f );
+	mBlueEnd.SetRange( 1.0f, 1.0f );
+
+	mAlphaStart.SetRange( 1.0f, 1.0f );
+	mAlphaEnd.SetRange( 1.0f, 1.0f );
+
+	mSizeStart.SetRange( 1.0f, 1.0f );
+	mSizeEnd.SetRange( 1.0f, 1.0f );
+
+	mSize2Start.SetRange( 1.0f, 1.0f );
+	mSize2End.SetRange( 1.0f, 1.0f );
+
+	mLengthStart.SetRange( 1.0f, 1.0f );
+	mLengthEnd.SetRange( 1.0f, 1.0f );
+
+	mTexCoordS.SetRange( 1.0f, 1.0f );
+	mTexCoordT.SetRange( 1.0f, 1.0f );
+
+	mVariance.SetRange( 1.0f, 1.0f );
+	mDensity.SetRange( 10.0f, 10.0f );// default this high so it doesn't do bad things
+}
+
+//-----------------------------------------------------------
+void CPrimitiveTemplate::operator=(const CPrimitiveTemplate &that)
+{
+	// I'm assuming that doing a memcpy wouldn't work here
+	// If you are looking at this and know a better way to do this, please tell me.
+	strcpy( mName, that.mName );
+
+	mType				= that.mType;
+
+	mSpawnDelay			= that.mSpawnDelay;
+	mSpawnCount			= that.mSpawnCount;
+	mLife				= that.mLife;
+	mCullRange			= that.mCullRange;
+
+	mMediaHandles		= that.mMediaHandles;
+	mImpactFxHandles	= that.mImpactFxHandles;
+	mDeathFxHandles		= that.mDeathFxHandles;
+	mEmitterFxHandles	= that.mEmitterFxHandles;
+	mPlayFxHandles		= that.mPlayFxHandles;
+
+	mFlags				= that.mFlags;
+	mSpawnFlags			= that.mSpawnFlags;
+
+	VectorCopy( that.mMin, mMin );
+	VectorCopy( that.mMax, mMax );
+
+	mOrigin1X			= that.mOrigin1X;
+	mOrigin1Y			= that.mOrigin1Y;
+	mOrigin1Z			= that.mOrigin1Z;
+
+	mOrigin2X			= that.mOrigin2X;
+	mOrigin2Y			= that.mOrigin2Y;
+	mOrigin2Z			= that.mOrigin2Z;
+
+	mRadius				= that.mRadius;
+	mHeight				= that.mHeight;
+
+	mRotation			= that.mRotation;
+	mRotationDelta		= that.mRotationDelta;
+
+	mAngle1				= that.mAngle1;
+	mAngle2				= that.mAngle2;
+	mAngle3				= that.mAngle3;
+
+	mAngle1Delta		= that.mAngle1Delta;
+	mAngle2Delta		= that.mAngle2Delta;
+	mAngle3Delta		= that.mAngle3Delta;
+
+	mVelX				= that.mVelX;
+	mVelY				= that.mVelY;
+	mVelZ				= that.mVelZ;
+
+	mAccelX				= that.mAccelX;
+	mAccelY				= that.mAccelY;
+	mAccelZ				= that.mAccelZ;
+
+	mGravity			= that.mGravity;
+
+	mDensity			= that.mDensity;
+	mVariance			= that.mVariance;
+
+	mRedStart			= that.mRedStart;
+	mGreenStart			= that.mGreenStart;
+	mBlueStart			= that.mBlueStart;
+
+	mRedEnd				= that.mRedEnd;
+	mGreenEnd			= that.mGreenEnd;
+	mBlueEnd			= that.mBlueEnd;
+
+	mRGBParm			= that.mRGBParm;
+
+	mAlphaStart			= that.mAlphaStart;
+	mAlphaEnd			= that.mAlphaEnd;
+	mAlphaParm			= that.mAlphaParm;
+
+	mSizeStart			= that.mSizeStart;
+	mSizeEnd			= that.mSizeEnd;
+	mSizeParm			= that.mSizeParm;
+
+	mSize2Start			= that.mSize2Start;
+	mSize2End			= that.mSize2End;
+	mSize2Parm			= that.mSize2Parm;
+
+	mLengthStart		= that.mLengthStart;
+	mLengthEnd			= that.mLengthEnd;
+	mLengthParm			= that.mLengthParm;
+
+	mTexCoordS			= that.mTexCoordS;
+	mTexCoordT			= that.mTexCoordT;
+
+	mElasticity			= that.mElasticity;
+}
+
+//------------------------------------------------------
+// ParseFloat
+//	Removes up to two values from a passed in string and
+//	sets these values into the passed in min and max 
+//	fields.  if no max is present, min is copied into it.
+//
+// input:
+//	string that contains up to two float values
+//  min & max are used to return the parse values
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseFloat( const char *val, float *min, float *max )
+{
+	// We don't allow passing in a null for either of the fields
+	if ( min == 0 || max == 0 )
+	{ // failue
+		return false;
+	}
+
+	// attempt to read out the values
+	int v = sscanf( val, "%f %f", min, max );
+
+	if ( v == 0 )
+	{ // nothing was there, failure
+		return false;
+	}
+	else if ( v == 1 )
+	{ // only one field entered, this is ok, but we should copy min into max
+		*max = *min;
+	}
+
+	return true;
+}
+
+
+//------------------------------------------------------
+// ParseVector
+//	Removes up to six values from a passed in string and
+//	sets these values into the passed in min and max vector
+//	fields. if no max is present, min is copied into it.
+//
+// input:
+//	string that contains up to six float values
+//  min & max are used to return the parse values
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseVector( const char *val, vec3_t min, vec3_t max )
+{
+	// we don't allow passing in a null
+	if ( min == 0 || max == 0 )
+	{
+		return false;
+	}
+
+	// attempt to read out our values
+	int v = sscanf( val, "%f %f %f   %f %f %f", &min[0], &min[1], &min[2], &max[0], &max[1], &max[2] );
+
+	// Check for completeness
+	if ( v < 3 || v == 4 || v == 5 )
+	{ // not a complete value
+		return false;
+	}
+	else if ( v == 3 )
+	{ // only a min was entered, so copy the result into max
+		VectorCopy( min, max );
+	}
+
+	return true;
+}
+
+//------------------------------------------------------
+// ParseGroupFlags
+//	Group flags are generic in nature, so we can easily
+//	use a generic function to parse them in, then the
+//	caller can shift them into the appropriate range.
+//
+// input:
+//	string that contains the flag strings
+//  *flags returns the set bit flags
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseGroupFlags( const char *val, int *flags )
+{
+	// Must pass in a non-null pointer
+	if ( flags == 0 )
+	{
+		return false;
+	}
+
+	char	flag[][32] = {"\0","\0","\0","0"};
+	bool	ok = true;
+	
+	// For a sub group, really you probably only have one or two flags set
+	int v = sscanf( val, "%s %s %s %s", flag[0], flag[1], flag[2], flag[3] );
+
+	// Clear out the flags field, then convert the flag string to an actual value ( use generic flags )
+	*flags = 0;
+
+	for ( int i = 0; i < 4; i++ )
+	{
+		if ( i + 1 > v )
+		{
+			return true;
+		}
+
+		if ( !stricmp( flag[i], "linear" ))
+		{
+			*flags |= FX_LINEAR;
+		}
+		else if ( !stricmp( flag[i], "nonlinear" ))
+		{
+			*flags |= FX_NONLINEAR;
+		}
+		else if ( !stricmp( flag[i], "wave" ))
+		{
+			*flags |= FX_WAVE;
+		}
+		else if ( !stricmp( flag[i], "random" ))
+		{
+			*flags |= FX_RAND;
+		}
+		else if ( !stricmp( flag[i], "clamp" ))
+		{
+			*flags |= FX_CLAMP;
+		}
+		else
+		{ // we have badness going on, but continue on in case there are any valid fields in here
+			ok = false;
+		}
+	}
+
+	return ok;
+}
+
+//------------------------------------------------------
+// ParseMin
+//	Reads in a min bounding box field in vector format
+//
+// input:
+//	string that contains three float values
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseMin( const char *val )
+{
+	vec3_t min;
+
+	if ( ParseVector( val, min, min ) == true )
+	{
+		VectorCopy( min, mMin );
+
+		// We assume that if a min is being set that we are using physics and a bounding box
+		mFlags |= (FX_USE_BBOX | FX_APPLY_PHYSICS);
+		return true;
+	}
+
+	return false;
+}
+
+//------------------------------------------------------
+// ParseMax
+//	Reads in a max bounding box field in vector format
+//
+// input:
+//	string that contains three float values
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseMax( const char *val )
+{
+	vec3_t max;
+
+	if ( ParseVector( val, max, max ) == true )
+	{
+		VectorCopy( max, mMax );
+
+		// We assume that if a max is being set that we are using physics and a bounding box
+		mFlags |= (FX_USE_BBOX | FX_APPLY_PHYSICS);
+		return true;
+	}
+
+	return false;
+}
+
+//------------------------------------------------------
+// ParseLife
+//	Reads in a ranged life value
+//
+// input:
+//	string that contains a float range ( two vals )
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseLife( const char *val )
+{
+	float min, max;
+
+	if ( ParseFloat( val, &min, &max ) == true )
+	{
+		mLife.SetRange( min, max );
+		return true;
+	}
+
+	return false;
+}
+
+//------------------------------------------------------
+// ParseDelay
+//	Reads in a ranged delay value
+//
+// input:
+//	string that contains a float range ( two vals )
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseDelay( const char *val )
+{
+	float min, max;
+
+	if ( ParseFloat( val, &min, &max ) == true )
+	{
+		mSpawnDelay.SetRange( min, max );
+		return true;
+	}
+
+	return false;
+}
+
+//------------------------------------------------------
+// ParseCount
+//	Reads in a ranged count value
+//
+// input:
+//	string that contains a float range ( two vals )
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseCount( const char *val )
+{
+	float min, max;
+
+	if ( ParseFloat( val, &min, &max ) == true )
+	{
+		mSpawnCount.SetRange( min, max );
+		return true;
+	}
+
+	return false;
+}
+
+//------------------------------------------------------
+// ParseElasticity
+//	Reads in a ranged elasticity value
+//
+// input:
+//	string that contains a float range ( two vals )
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseElasticity( const char *val )
+{
+	float min, max;
+
+	if ( ParseFloat( val, &min, &max ) == true )
+	{
+		mElasticity.SetRange( min, max );
+
+		// We assume that if elasticity is set that we are using physics, but don't assume we are
+		//	using a bounding box unless a min/max are explicitly set
+//		mFlags |= FX_APPLY_PHYSICS;
+		return true;
+	}
+
+	return false;
+}
+
+//------------------------------------------------------
+// ParseOrigin1
+//	Reads in an origin field in vector format
+//
+// input:
+//	string that contains three float values
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseOrigin1( const char *val )
+{
+	vec3_t min, max;
+
+	if ( ParseVector( val, min, max ) == true )
+	{
+		mOrigin1X.SetRange( min[0], max[0] );
+		mOrigin1Y.SetRange( min[1], max[1] );
+		mOrigin1Z.SetRange( min[2], max[2] );
+		return true;
+	}
+
+	return false;
+}
+
+//------------------------------------------------------
+// ParseOrigin2
+//	Reads in an origin field in vector format
+//
+// input:
+//	string that contains three float values
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseOrigin2( const char *val )
+{
+	vec3_t min, max;
+
+	if ( ParseVector( val, min, max ) == true )
+	{
+		mOrigin2X.SetRange( min[0], max[0] );
+		mOrigin2Y.SetRange( min[1], max[1] );
+		mOrigin2Z.SetRange( min[2], max[2] );
+		return true;
+	}
+
+	return false;
+}
+
+//------------------------------------------------------
+// ParseRadius
+//	Reads in a ranged radius value
+//
+// input:
+//	string that contains one or two floats
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseRadius( const char *val )
+{
+	float min, max;
+
+	if ( ParseFloat( val, &min, &max ) == true )
+	{
+		mRadius.SetRange( min, max );
+		return true;
+	}
+
+	return false;
+}
+
+//------------------------------------------------------
+// ParseHeight
+//	Reads in a ranged height value
+//
+// input:
+//	string that contains one or two floats
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseHeight( const char *val )
+{
+	float min, max;
+
+	if ( ParseFloat( val, &min, &max ) == true )
+	{
+		mHeight.SetRange( min, max );
+		return true;
+	}
+
+	return false;
+}
+
+//------------------------------------------------------
+// ParseRotation
+//	Reads in a ranged rotation value
+//
+// input:
+//	string that contains one or two floats
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseRotation( const char *val )
+{
+	float min, max;
+
+	if ( ParseFloat( val, &min, &max ) == qtrue )
+	{
+		mRotation.SetRange( min, max );
+		return true;
+	}
+
+	return false;
+}
+
+//------------------------------------------------------
+// ParseRotationDelta
+//	Reads in a ranged rotationDelta value
+//
+// input:
+//	string that contains one or two floats
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseRotationDelta( const char *val )
+{
+	float min, max;
+
+	if ( ParseFloat( val, &min, &max ) == qtrue )
+	{
+		mRotationDelta.SetRange( min, max );
+		return true;
+	}
+
+	return false;
+}
+
+//------------------------------------------------------
+// ParseAngle
+//	Reads in a ranged angle field in vector format
+//
+// input:
+//	string that contains one or two vectors
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseAngle( const char *val )
+{
+	vec3_t min, max;
+
+	if ( ParseVector( val, min, max ) == true )
+	{
+		mAngle1.SetRange( min[0], max[0] );
+		mAngle2.SetRange( min[1], max[1] );
+		mAngle3.SetRange( min[2], max[2] );
+		return true;
+	}
+
+	return false;
+}
+
+//------------------------------------------------------
+// ParseAngleDelta
+//	Reads in a ranged angleDelta field in vector format
+//
+// input:
+//	string that contains one or two vectors
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseAngleDelta( const char *val )
+{
+	vec3_t min, max;
+
+	if ( ParseVector( val, min, max ) == true )
+	{
+		mAngle1Delta.SetRange( min[0], max[0] );
+		mAngle2Delta.SetRange( min[1], max[1] );
+		mAngle3Delta.SetRange( min[2], max[2] );
+		return true;
+	}
+
+	return false;
+}
+
+//------------------------------------------------------
+// ParseVelocity
+//	Reads in a ranged velocity field in vector format
+//
+// input:
+//	string that contains one or two vectors
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseVelocity( const char *val )
+{
+	vec3_t min, max;
+
+	if ( ParseVector( val, min, max ) == true )
+	{
+		mVelX.SetRange( min[0], max[0] );
+		mVelY.SetRange( min[1], max[1] );
+		mVelZ.SetRange( min[2], max[2] );
+		return true;
+	}
+
+	return false;
+}
+
+//------------------------------------------------------
+// ParseFlags
+//	These are flags that are not specific to a group, 
+//	rather, they are specific to the whole primitive.
+//
+// input:
+//	string that contains the flag strings
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseFlags( const char *val )
+{
+	char	flag[][32] = {"\0","\0","\0","\0","\0","\0","\0"};
+	bool	ok = true;
+	
+	// For a primitive, really you probably only have two or less flags set
+	int v = sscanf( val, "%s %s %s %s %s %s %s", flag[0], flag[1], flag[2], flag[3], flag[4], flag[5], flag[6] );
+
+	for ( int i = 0; i < 7; i++ )
+	{
+		if ( i + 1 > v )
+		{
+			return true;
+		}
+
+		if ( !stricmp( flag[i], "useModel" ))
+		{
+			mFlags |= FX_ATTACHED_MODEL;
+		}
+		else if ( !stricmp( flag[i], "useBBox" ))
+		{
+			mFlags |= FX_USE_BBOX;
+		}
+		else if ( !stricmp( flag[i], "usePhysics" ))
+		{
+			mFlags |= FX_APPLY_PHYSICS;
+		}
+		else if ( !stricmp( flag[i], "expensivePhysics" ))
+		{
+			mFlags |= FX_EXPENSIVE_PHYSICS;
+		}
+		//rww - begin g2 stuff
+		else if ( !stricmp( flag[i], "ghoul2Collision" ))
+		{
+			mFlags |= (FX_GHOUL2_TRACE|FX_APPLY_PHYSICS|FX_EXPENSIVE_PHYSICS);
+		}
+		else if ( !stricmp( flag[i], "ghoul2Decals" ))
+		{
+			mFlags |= FX_GHOUL2_DECALS;
+		}
+		//rww - end
+		else if ( !stricmp( flag[i], "impactKills" ))
+		{
+			mFlags |= FX_KILL_ON_IMPACT;
+		}
+		else if ( !stricmp( flag[i], "impactFx" ))
+		{
+			mFlags |= FX_IMPACT_RUNS_FX;
+		}
+		else if ( !stricmp( flag[i], "deathFx" ))
+		{
+			mFlags |= FX_DEATH_RUNS_FX;
+		}
+		else if ( !stricmp( flag[i], "useAlpha" ))
+		{
+			mFlags |= FX_USE_ALPHA;
+		}
+		else if ( !stricmp( flag[i], "emitFx" ))
+		{
+			mFlags |= FX_EMIT_FX;
+		}
+		else if ( !stricmp( flag[i], "depthHack" ))
+		{
+			mFlags |= FX_DEPTH_HACK;
+		}
+		else if ( !stricmp( flag[i], "setShaderTime" ))
+		{
+			mFlags |= FX_SET_SHADER_TIME;
+		}
+		else
+		{ // we have badness going on, but continue on in case there are any valid fields in here
+			ok = false;
+		}
+	}
+
+	return ok;
+}
+
+//------------------------------------------------------
+// ParseSpawnFlags
+//	These kinds of flags control how things spawn.  They 
+//	never get passed on to a primitive.
+//
+// input:
+//	string that contains the flag strings
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseSpawnFlags( const char *val )
+{
+	char	flag[][32] = {"\0","\0","\0","\0","\0","\0","\0"};
+	bool	ok = true;
+	
+	// For a primitive, really you probably only have two or less flags set
+	int v = sscanf( val, "%s %s %s %s %s %s %s", flag[0], flag[1], flag[2], flag[3], flag[4], flag[5], flag[6] );
+
+	for ( int i = 0; i < 7; i++ )
+	{
+		if ( i + 1 > v )
+		{
+			return true;
+		}
+
+		if ( !stricmp( flag[i], "org2fromTrace" ))
+		{
+			mSpawnFlags |= FX_ORG2_FROM_TRACE;
+		}
+		else if ( !stricmp( flag[i], "traceImpactFx" ))
+		{
+			mSpawnFlags |= FX_TRACE_IMPACT_FX;
+		}
+		else if ( !stricmp( flag[i], "org2isOffset" ))
+		{
+			mSpawnFlags |= FX_ORG2_IS_OFFSET;
+		}
+		else if ( !stricmp( flag[i], "cheapOrgCalc" ))
+		{
+			mSpawnFlags |= FX_CHEAP_ORG_CALC;
+		}
+		else if ( !stricmp( flag[i], "cheapOrg2Calc" ))
+		{
+			mSpawnFlags |= FX_CHEAP_ORG2_CALC;
+		}
+		else if ( !stricmp( flag[i], "absoluteVel" ))
+		{
+			mSpawnFlags |= FX_VEL_IS_ABSOLUTE;
+		}
+		else if ( !stricmp( flag[i], "absoluteAccel" ))
+		{
+			mSpawnFlags |= FX_ACCEL_IS_ABSOLUTE;
+		}
+		else if ( !stricmp( flag[i], "orgOnSphere" )) // sphere/ellipsoid
+		{
+			mSpawnFlags |= FX_ORG_ON_SPHERE;
+		}
+		else if ( !stricmp( flag[i], "orgOnCylinder" )) // cylinder/disk
+		{
+			mSpawnFlags |= FX_ORG_ON_CYLINDER;
+		}
+		else if ( !stricmp( flag[i], "axisFromSphere" ))
+		{
+			mSpawnFlags |= FX_AXIS_FROM_SPHERE;
+		}
+		else if ( !stricmp( flag[i], "randrotaroundfwd" ))
+		{
+			mSpawnFlags |= FX_RAND_ROT_AROUND_FWD;
+		}
+		else if ( !stricmp( flag[i], "evenDistribution" ))
+		{
+			mSpawnFlags |= FX_EVEN_DISTRIBUTION;
+		}
+		else if ( !stricmp( flag[i], "rgbComponentInterpolation" ))
+		{
+			mSpawnFlags |= FX_RGB_COMPONENT_INTERP;
+		}
+		else if ( !stricmp( flag[i], "lessAttenuation" ))
+		{
+			mSpawnFlags |= FX_SND_LESS_ATTENUATION;
+		}
+		else
+		{ // we have badness going on, but continue on in case there are any valid fields in here
+			ok = false;
+		}
+	}
+
+	return ok;
+}
+
+//------------------------------------------------------
+// ParseAcceleration
+//	Reads in a ranged acceleration field in vector format
+//
+// input:
+//	string that contains one or two vectors
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseAcceleration( const char *val )
+{
+	vec3_t min, max;
+
+	if ( ParseVector( val, min, max ) == true )
+	{
+		mAccelX.SetRange( min[0], max[0] );
+		mAccelY.SetRange( min[1], max[1] );
+		mAccelZ.SetRange( min[2], max[2] );
+		return true;
+	}
+
+	return false;
+}
+
+//------------------------------------------------------
+// ParseGravity
+//	Reads in a ranged gravity value
+//
+// input:
+//	string that contains one or two floats
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseGravity( const char *val )
+{
+	float min, max;
+
+	if ( ParseFloat( val, &min, &max ) == true )
+	{
+		mGravity.SetRange( min, max );
+		return true;
+	}
+
+	return false;
+}
+
+//------------------------------------------------------
+// ParseDensity
+//	Reads in a ranged density value.  Density is only
+//	for emitters that are calling effects...it basically
+//	specifies how often the emitter should emit fx.
+//
+// input:
+//	string that contains one or two floats
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseDensity( const char *val )
+{
+	float min, max;
+
+	if ( ParseFloat( val, &min, &max ) == true )
+	{
+		mDensity.SetRange( min, max );
+		return true;
+	}
+
+	return false;
+}
+
+//------------------------------------------------------
+// ParseVariance
+//	Reads in a ranged variance value.  Variance is only 
+//	valid for emitters that are calling effects...
+//	it basically determines the amount of slop in the
+//	density calculations
+//
+// input:
+//	string that contains one or two floats
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseVariance( const char *val )
+{
+	float min, max;
+
+	if ( ParseFloat( val, &min, &max ) == true )
+	{
+		mVariance.SetRange( min, max );
+		return true;
+	}
+
+	return false;
+}
+
+//------------------------------------------------------
+// ParseRGBStart
+//	Reads in a ranged rgbStart field in vector format
+//
+// input:
+//	string that contains one or two vectors
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseRGBStart( const char *val )
+{
+	vec3_t min, max;
+
+	if ( ParseVector( val, min, max ) == true )
+	{
+		mRedStart.SetRange( min[0], max[0] );
+		mGreenStart.SetRange( min[1], max[1] );
+		mBlueStart.SetRange( min[2], max[2] );
+		return true;
+	}
+
+	return false;
+}
+
+//------------------------------------------------------
+// ParseRGBEnd
+//	Reads in a ranged rgbEnd field in vector format
+//
+// input:
+//	string that contains one or two vectors
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseRGBEnd( const char *val )
+{
+	vec3_t min, max;
+
+	if ( ParseVector( val, min, max ) == true )
+	{
+		mRedEnd.SetRange( min[0], max[0] );
+		mGreenEnd.SetRange( min[1], max[1] );
+		mBlueEnd.SetRange( min[2], max[2] );
+		return true;
+	}
+
+	return false;
+}
+
+//------------------------------------------------------
+// ParseRGBParm
+//	Reads in a ranged rgbParm field in float format
+//
+// input:
+//	string that contains one or two floats
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseRGBParm( const char *val )
+{
+	float min, max;
+
+	if ( ParseFloat( val, &min, &max ) == true )
+	{
+		mRGBParm.SetRange( min, max );
+		return true;
+	}
+
+	return false;
+}
+
+//------------------------------------------------------
+// ParseRGBFlags
+//	Reads in a set of rgbFlags in string format
+//
+// input:
+//	string that contains the flag strings
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseRGBFlags( const char *val )
+{
+	int flags;
+
+	if ( ParseGroupFlags( val, &flags ) == true )
+	{
+		// Convert our generic flag values into type specific ones
+		mFlags |= ( flags << FX_RGB_SHIFT );
+		return true;
+	}
+
+	return false;
+}
+
+//------------------------------------------------------
+// ParseAlphaStart
+//	Reads in a ranged alphaStart field in float format
+//
+// input:
+//	string that contains one or two floats
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseAlphaStart( const char *val )
+{
+	float min, max;
+
+	if ( ParseFloat( val, &min, &max ) == true )
+	{
+		mAlphaStart.SetRange( min, max );
+		return true;
+	}
+
+	return false;
+}
+
+//------------------------------------------------------
+// ParseAlphaEnd
+//	Reads in a ranged alphaEnd field in float format
+//
+// input:
+//	string that contains one or two floats
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseAlphaEnd( const char *val )
+{
+	float min, max;
+
+	if ( ParseFloat( val, &min, &max ) == true )
+	{
+		mAlphaEnd.SetRange( min, max );
+		return true;
+	}
+
+	return false;
+}
+
+//------------------------------------------------------
+// ParseAlphaParm
+//	Reads in a ranged alphaParm field in float format
+//
+// input:
+//	string that contains one or two floats
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseAlphaParm( const char *val )
+{
+	float min, max;
+
+	if ( ParseFloat( val, &min, &max ) == true )
+	{
+		mAlphaParm.SetRange( min, max );
+		return true;
+	}
+
+	return false;
+}
+
+//------------------------------------------------------
+// ParseAlphaFlags
+//	Reads in a set of alphaFlags in string format
+//
+// input:
+//	string that contains the flag strings
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseAlphaFlags( const char *val )
+{
+	int flags;
+
+	if ( ParseGroupFlags( val, &flags ) == true )
+	{
+		// Convert our generic flag values into type specific ones
+		mFlags |= ( flags << FX_ALPHA_SHIFT );
+		return true;
+	}
+
+	return false;
+}
+
+//------------------------------------------------------
+// ParseSizeStart
+//	Reads in a ranged sizeStart field in float format
+//
+// input:
+//	string that contains one or two floats
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseSizeStart( const char *val )
+{
+	float min, max;
+
+	if ( ParseFloat( val, &min, &max ) == true )
+	{
+		mSizeStart.SetRange( min, max );
+		return true;
+	}
+
+	return false;
+}
+
+//------------------------------------------------------
+// ParseSizeEnd
+//	Reads in a ranged sizeEnd field in float format
+//
+// input:
+//	string that contains one or two floats
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseSizeEnd( const char *val )
+{
+	float min, max;
+
+	if ( ParseFloat( val, &min, &max ) == true )
+	{
+		mSizeEnd.SetRange( min, max );
+		return true;
+	}
+
+	return false;
+}
+
+//------------------------------------------------------
+// ParseSizeParm
+//	Reads in a ranged sizeParm field in float format
+//
+// input:
+//	string that contains one or two floats
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseSizeParm( const char *val )
+{
+	float min, max;
+
+	if ( ParseFloat( val, &min, &max ) == true )
+	{
+		mSizeParm.SetRange( min, max );
+		return true;
+	}
+
+	return false;
+}
+
+//------------------------------------------------------
+// ParseSizeFlags
+//	Reads in a set of sizeFlags in string format
+//
+// input:
+//	string that contains the flag strings
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseSizeFlags( const char *val )
+{
+	int flags;
+
+	if ( ParseGroupFlags( val, &flags ) == true )
+	{
+		// Convert our generic flag values into type specific ones
+		mFlags |= ( flags << FX_SIZE_SHIFT );
+		return true;
+	}
+
+	return false;
+}
+
+//------------------------------------------------------
+// ParseSize2Start
+//	Reads in a ranged Size2Start field in float format
+//
+// input:
+//	string that contains one or two floats
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseSize2Start( const char *val )
+{
+	float min, max;
+
+	if ( ParseFloat( val, &min, &max ) == true )
+	{
+		mSize2Start.SetRange( min, max );
+		return true;
+	}
+
+	return false;
+}
+
+//------------------------------------------------------
+// ParseSize2End
+//	Reads in a ranged Size2End field in float format
+//
+// input:
+//	string that contains one or two floats
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseSize2End( const char *val )
+{
+	float min, max;
+
+	if ( ParseFloat( val, &min, &max ) == true )
+	{
+		mSize2End.SetRange( min, max );
+		return true;
+	}
+
+	return false;
+}
+
+//------------------------------------------------------
+// ParseSize2Parm
+//	Reads in a ranged Size2Parm field in float format
+//
+// input:
+//	string that contains one or two floats
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseSize2Parm( const char *val )
+{
+	float min, max;
+
+	if ( ParseFloat( val, &min, &max ) == true )
+	{
+		mSize2Parm.SetRange( min, max );
+		return true;
+	}
+
+	return false;
+}
+
+//------------------------------------------------------
+// ParseSize2Flags
+//	Reads in a set of Size2Flags in string format
+//
+// input:
+//	string that contains the flag strings
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseSize2Flags( const char *val )
+{
+	int flags;
+
+	if ( ParseGroupFlags( val, &flags ) == true )
+	{
+		// Convert our generic flag values into type specific ones
+		mFlags |= ( flags << FX_SIZE2_SHIFT );
+		return true;
+	}
+
+	return false;
+}
+
+//------------------------------------------------------
+// ParseLengthStart
+//	Reads in a ranged lengthStart field in float format
+//
+// input:
+//	string that contains one or two floats
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseLengthStart( const char *val )
+{
+	float min, max;
+
+	if ( ParseFloat( val, &min, &max ) == true )
+	{
+		mLengthStart.SetRange( min, max );
+		return true;
+	}
+
+	return false;
+}
+
+//------------------------------------------------------
+// ParseLengthEnd
+//	Reads in a ranged lengthEnd field in float format
+//
+// input:
+//	string that contains one or two floats
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseLengthEnd( const char *val )
+{
+	float min, max;
+
+	if ( ParseFloat( val, &min, &max ) == true )
+	{
+		mLengthEnd.SetRange( min, max );
+		return true;
+	}
+
+	return false;
+}
+
+//------------------------------------------------------
+// ParseLengthParm
+//	Reads in a ranged lengthParm field in float format
+//
+// input:
+//	string that contains one or two floats
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseLengthParm( const char *val )
+{
+	float min, max;
+
+	if ( ParseFloat( val, &min, &max ) == true )
+	{
+		mLengthParm.SetRange( min, max );
+		return true;
+	}
+
+	return false;
+}
+
+//------------------------------------------------------
+// ParseLengthFlags
+//	Reads in a set of lengthFlags in string format
+//
+// input:
+//	string that contains the flag strings
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseLengthFlags( const char *val )
+{
+	int flags;
+
+	if ( ParseGroupFlags( val, &flags ) == true )
+	{
+		// Convert our generic flag values into type specific ones
+		mFlags |= ( flags << FX_LENGTH_SHIFT );
+		return true;
+	}
+
+	return false;
+}
+
+//------------------------------------------------------
+// ParseShaders
+//	Reads in a group of shaders and registers them
+//
+// input:
+//	Parse group that contains the list of shaders to parse
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseShaders( CGPValue *grp )
+{
+	const char	*val;
+	int			handle;
+
+	if ( grp->IsList() )
+	{
+		// If we are a list we have to do separate processing
+		CGPObject *list = grp->GetList();
+
+		while ( list )
+		{
+			// name is actually the value contained in the list
+			val = list->GetName();
+
+			handle = theFxHelper.RegisterShader( val );
+			mMediaHandles.AddHandle( handle );
+
+			list = (CGPValue *)list->GetNext();
+		}
+	}
+	else
+	{
+		// Let's get a value
+		val = grp->GetTopValue();
+
+		if ( val )
+		{
+			handle = theFxHelper.RegisterShader( val );
+			mMediaHandles.AddHandle( handle );
+		}
+		else
+		{
+			// empty "list"
+			theFxHelper.Print( "CPrimitiveTemplate::ParseShaders called with an empty list!\n" );
+			return false;
+		}
+	}
+
+	return true;
+}
+
+//------------------------------------------------------
+// ParseSounds
+//	Reads in a group of sounds and registers them
+//
+// input:
+//	Parse group that contains the list of sounds to parse
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseSounds( CGPValue *grp )
+{
+	const char	*val;
+	int			handle;
+
+	if ( grp->IsList() )
+	{
+		// If we are a list we have to do separate processing
+		CGPObject *list = grp->GetList();
+
+		while ( list )
+		{
+			// name is actually the value contained in the list
+			val = list->GetName();
+
+			handle = theFxHelper.RegisterSound( val );
+			mMediaHandles.AddHandle( handle );
+
+			list = (CGPValue *)list->GetNext();
+		}
+	}
+	else
+	{
+		// Let's get a value
+		val = grp->GetTopValue();
+
+		if ( val )
+		{
+			handle = theFxHelper.RegisterSound( val );
+			mMediaHandles.AddHandle( handle );
+		}
+		else
+		{
+			// empty "list"
+			theFxHelper.Print( "CPrimitiveTemplate::ParseSounds called with an empty list!\n" );
+			return false;
+		}
+	}
+
+	return true;
+}
+
+#ifdef _IMMERSION
+//------------------------------------------------------
+// ParseForces
+//	Reads in a group of forces and registers them
+//
+// input:
+//	Parse group that contains the list of forces to parse
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseForces( CGPValue *grp )
+{
+	const char	*val;
+	int			handle;
+
+	if ( grp->IsList() )
+	{
+		// If we are a list we have to do separate processing
+		CGPObject *list = grp->GetList();
+
+		while ( list )
+		{
+			// name is actually the value contained in the list
+			val = list->GetName();
+
+			// Assumes FF_CHANNEL_WEAPON because sound mechanism assumes this
+			handle = theFxHelper.RegisterForce( val, FF_CHANNEL_WEAPON );
+			mMediaHandles.AddHandle( handle );
+
+			list = (CGPValue *)list->GetNext();
+		}
+	}
+	else
+	{
+		// Let's get a value
+		val = grp->GetTopValue();
+
+		if ( val )
+		{
+			// Assumes FF_CHANNEL_WEAPON because sound mechanism assumes this
+			handle = theFxHelper.RegisterForce( val, FF_CHANNEL_WEAPON );
+			mMediaHandles.AddHandle( handle );
+		}
+		else
+		{
+			// empty "list"
+			theFxHelper.Print( "CPrimitiveTemplate::ParseForces called with an empty list!\n" );
+			return false;
+		}
+	}
+
+	return true;
+}
+#endif // _IMMERSION
+//------------------------------------------------------
+// ParseModels
+//	Reads in a group of models and registers them
+//
+// input:
+//	Parse group that contains the list of models to parse
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseModels( CGPValue *grp )
+{
+	const char	*val;
+	int			handle;
+
+	if ( grp->IsList() )
+	{
+		// If we are a list we have to do separate processing
+		CGPObject *list = grp->GetList();
+
+		while ( list )
+		{
+			// name is actually the value contained in the list
+			val = list->GetName();
+
+			handle = theFxHelper.RegisterModel( val );
+			mMediaHandles.AddHandle( handle );
+
+			list = (CGPValue *)list->GetNext();
+		}
+	}
+	else
+	{
+		// Let's get a value
+		val = grp->GetTopValue();
+
+		if ( val )
+		{
+			handle = theFxHelper.RegisterModel( val );
+			mMediaHandles.AddHandle( handle );
+		}
+		else
+		{
+			// empty "list"
+			theFxHelper.Print( "CPrimitiveTemplate::ParseModels called with an empty list!\n" );
+			return false;
+		}
+	}
+
+	mFlags |= FX_ATTACHED_MODEL;
+
+	return true;
+}
+
+//------------------------------------------------------
+// ParseImpactFxStrings
+//	Reads in a group of fx file names and registers them
+//
+// input:
+//	Parse group that contains the list of fx to parse
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseImpactFxStrings( CGPValue *grp )
+{
+	const char	*val;
+	int			handle;
+
+	if ( grp->IsList() )
+	{
+		// If we are a list we have to do separate processing
+		CGPObject *list = grp->GetList();
+
+		while ( list )
+		{
+			// name is actually the value contained in the list
+			val = list->GetName();
+			handle = theFxScheduler.RegisterEffect( val );
+	
+			if ( handle )
+			{
+				mImpactFxHandles.AddHandle( handle );
+			}
+			else
+			{
+				theFxHelper.Print( "FxTemplate: Impact effect file not found.\n" );
+				return false;
+			}
+
+			list = (CGPValue *)list->GetNext();
+		}
+	}
+	else
+	{
+		// Let's get a value
+		val = grp->GetTopValue();
+
+		if ( val )
+		{
+			handle = theFxScheduler.RegisterEffect( val );
+
+			if ( handle )
+			{
+				mImpactFxHandles.AddHandle( handle );
+			}
+			else
+			{
+				theFxHelper.Print( "FxTemplate: Impact effect file not found.\n" );
+				return false;
+			}
+		}
+		else
+		{
+			// empty "list"
+			theFxHelper.Print( "CPrimitiveTemplate::ParseImpactFxStrings called with an empty list!\n" );
+			return false;
+		}
+	}
+
+	mFlags |= FX_IMPACT_RUNS_FX | FX_APPLY_PHYSICS;	
+
+	return true;
+}
+
+//------------------------------------------------------
+// ParseDeathFxStrings
+//	Reads in a group of fx file names and registers them
+//
+// input:
+//	Parse group that contains the list of fx to parse
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseDeathFxStrings( CGPValue *grp )
+{
+	const char	*val;
+	int			handle;
+
+	if ( grp->IsList() )
+	{
+		// If we are a list we have to do separate processing
+		CGPObject *list = grp->GetList();
+
+		while ( list )
+		{
+			// name is actually the value contained in the list
+			val = list->GetName();
+			handle = theFxScheduler.RegisterEffect( val );
+	
+			if ( handle )
+			{
+				mDeathFxHandles.AddHandle( handle );
+			}
+			else
+			{
+				theFxHelper.Print( "FxTemplate: Death effect file not found.\n" );
+				return false;
+			}
+
+			list = (CGPValue *)list->GetNext();
+		}
+	}
+	else
+	{
+		// Let's get a value
+		val = grp->GetTopValue();
+
+		if ( val )
+		{
+			handle = theFxScheduler.RegisterEffect( val );
+
+			if ( handle )
+			{
+				mDeathFxHandles.AddHandle( handle );
+			}
+			else
+			{
+				theFxHelper.Print( "FxTemplate: Death effect file not found.\n" );
+				return false;
+			}
+		}
+		else
+		{
+			// empty "list"
+			theFxHelper.Print( "CPrimitiveTemplate::ParseDeathFxStrings called with an empty list!\n" );
+			return false;
+		}
+	}
+
+	mFlags |= FX_DEATH_RUNS_FX;	
+
+	return true;
+}
+
+//------------------------------------------------------
+// ParseEmitterFxStrings
+//	Reads in a group of fx file names and registers them
+//
+// input:
+//	Parse group that contains the list of fx to parse
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseEmitterFxStrings( CGPValue *grp )
+{
+	const char	*val;
+	int			handle;
+
+	if ( grp->IsList() )
+	{
+		// If we are a list we have to do separate processing
+		CGPObject *list = grp->GetList();
+
+		while ( list )
+		{
+			// name is actually the value contained in the list
+			val = list->GetName();
+			handle = theFxScheduler.RegisterEffect( val );
+
+			if ( handle )
+			{
+				mEmitterFxHandles.AddHandle( handle );
+			}
+			else
+			{
+				theFxHelper.Print( "FxTemplate: Emitter effect file not found.\n" );
+				return false;
+			}
+
+			list = (CGPValue *)list->GetNext();
+		}
+	}
+	else
+	{
+		// Let's get a value
+		val = grp->GetTopValue();
+
+		if ( val )
+		{
+			handle = theFxScheduler.RegisterEffect( val );
+
+			if ( handle )
+			{
+				mEmitterFxHandles.AddHandle( handle );
+			}
+			else
+			{
+				theFxHelper.Print( "FxTemplate: Emitter effect file not found.\n" );
+				return false;
+			}
+		}
+		else
+		{
+			// empty "list"
+			theFxHelper.Print( "CPrimitiveTemplate::ParseEmitterFxStrings called with an empty list!\n" );
+			return false;
+		}
+	}
+
+	mFlags |= FX_EMIT_FX;	
+
+	return true;
+}
+
+//------------------------------------------------------
+// ParsePlayFxStrings
+//	Reads in a group of fx file names and registers them
+//
+// input:
+//	Parse group that contains the list of fx to parse
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParsePlayFxStrings( CGPValue *grp )
+{
+	const char	*val;
+	int			handle;
+
+	if ( grp->IsList() )
+	{
+		// If we are a list we have to do separate processing
+		CGPObject *list = grp->GetList();
+
+		while ( list )
+		{
+			// name is actually the value contained in the list
+			val = list->GetName();
+			handle = theFxScheduler.RegisterEffect( val );
+
+			if ( handle )
+			{
+				mPlayFxHandles.AddHandle( handle );
+			}
+			else
+			{
+				theFxHelper.Print( "FxTemplate: Effect file not found.\n" );
+				return false;
+			}
+
+			list = (CGPValue *)list->GetNext();
+		}
+	}
+	else
+	{
+		// Let's get a value
+		val = grp->GetTopValue();
+
+		if ( val )
+		{
+			handle = theFxScheduler.RegisterEffect( val );
+
+			if ( handle )
+			{
+				mPlayFxHandles.AddHandle( handle );
+			}
+			else
+			{
+				theFxHelper.Print( "FxTemplate: Effect file not found.\n" );
+				return false;
+			}
+		}
+		else
+		{
+			// empty "list"
+			theFxHelper.Print( "CPrimitiveTemplate::ParsePlayFxStrings called with an empty list!\n" );
+			return false;
+		}
+	}
+
+	return true;
+}
+
+//------------------------------------------------------
+// ParseRGB
+//	Takes an RGB group and chomps out any pairs contained
+//	in it.
+//
+// input:
+//	the parse group to process
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseRGB( CGPGroup *grp )
+{
+	CGPValue	*pairs;
+	const char	*key;
+	const char	*val;
+
+	// Inside of the group, we should have a series of pairs
+	pairs = grp->GetPairs();
+
+	while( pairs )
+	{	
+		// Let's get the key field
+		key = pairs->GetName();
+		val = pairs->GetTopValue();
+
+		// Huge stricmp lists suxor
+		if ( !stricmp( key, "start" ))
+		{
+			ParseRGBStart( val );
+		}
+		else if ( !stricmp( key, "end" ))
+		{
+			ParseRGBEnd( val );
+		}
+		else if ( !stricmp( key, "parm" ) || !stricmp( key, "parms" ))
+		{
+			ParseRGBParm( val );
+		}
+		else if ( !stricmp( key, "flags" ) || !stricmp( key, "flag" ))
+		{
+			ParseRGBFlags( val );
+		}
+		else
+		{
+			theFxHelper.Print( "Unknown key parsing an RGB group: %s\n", key );
+		}
+
+		pairs = (CGPValue *)pairs->GetNext();
+	}
+
+	return true;
+}
+
+//------------------------------------------------------
+// ParseAlpha
+//	Takes an alpha group and chomps out any pairs contained
+//	in it.
+//
+// input:
+//	the parse group to process
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseAlpha( CGPGroup *grp )
+{
+	CGPValue	*pairs;
+	const char	*key;
+	const char	*val;
+
+	// Inside of the group, we should have a series of pairs
+	pairs = grp->GetPairs();
+
+	while( pairs )
+	{	
+		// Let's get the key field
+		key = pairs->GetName();
+		val = pairs->GetTopValue();
+
+		// Huge stricmp lists suxor
+		if ( !stricmp( key, "start" ))
+		{
+			ParseAlphaStart( val );
+		}
+		else if ( !stricmp( key, "end" ))
+		{
+			ParseAlphaEnd( val );
+		}
+		else if ( !stricmp( key, "parm" ) || !stricmp( key, "parms" ))
+		{
+			ParseAlphaParm( val );
+		}
+		else if ( !stricmp( key, "flags" ) || !stricmp( key, "flag" ))
+		{
+			ParseAlphaFlags( val );
+		}
+		else
+		{
+			theFxHelper.Print( "Unknown key parsing an Alpha group: %s\n", key );
+		}
+
+		pairs = (CGPValue *)pairs->GetNext();
+	}
+
+	return true;
+}
+
+//------------------------------------------------------
+// ParseSize
+//	Takes a size group and chomps out any pairs contained
+//	in it.
+//
+// input:
+//	the parse group to process
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseSize( CGPGroup *grp )
+{
+	CGPValue	*pairs;
+	const char	*key;
+	const char	*val;
+
+	// Inside of the group, we should have a series of pairs
+	pairs = grp->GetPairs();
+
+	while( pairs )
+	{	
+		// Let's get the key field
+		key = pairs->GetName();
+		val = pairs->GetTopValue();
+
+		// Huge stricmp lists suxor
+		if ( !stricmp( key, "start" ))
+		{
+			ParseSizeStart( val );
+		}
+		else if ( !stricmp( key, "end" ))
+		{
+			ParseSizeEnd( val );
+		}
+		else if ( !stricmp( key, "parm" ) || !stricmp( key, "parms" ))
+		{
+			ParseSizeParm( val );
+		}
+		else if ( !stricmp( key, "flags" ) || !stricmp( key, "flag" ))
+		{
+			ParseSizeFlags( val );
+		}
+		else
+		{
+			theFxHelper.Print( "Unknown key parsing a Size group: %s\n", key );
+		}
+
+		pairs = (CGPValue *)pairs->GetNext();
+	}
+
+	return true;
+}
+
+//------------------------------------------------------
+// ParseSize2
+//	Takes a Size2 group and chomps out any pairs contained
+//	in it.
+//
+// input:
+//	the parse group to process
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseSize2( CGPGroup *grp )
+{
+	CGPValue	*pairs;
+	const char	*key;
+	const char	*val;
+
+	// Inside of the group, we should have a series of pairs
+	pairs = grp->GetPairs();
+
+	while( pairs )
+	{	
+		// Let's get the key field
+		key = pairs->GetName();
+		val = pairs->GetTopValue();
+
+		// Huge stricmp lists suxor
+		if ( !stricmp( key, "start" ))
+		{
+			ParseSize2Start( val );
+		}
+		else if ( !stricmp( key, "end" ))
+		{
+			ParseSize2End( val );
+		}
+		else if ( !stricmp( key, "parm" ) || !stricmp( key, "parms" ))
+		{
+			ParseSize2Parm( val );
+		}
+		else if ( !stricmp( key, "flags" ) || !stricmp( key, "flag" ))
+		{
+			ParseSize2Flags( val );
+		}
+		else
+		{
+			theFxHelper.Print( "Unknown key parsing a Size2 group: %s\n", key );
+		}
+
+		pairs = (CGPValue *)pairs->GetNext();
+	}
+
+	return true;
+}
+
+//------------------------------------------------------
+// ParseLength
+//	Takes a length group and chomps out any pairs contained
+//	in it.
+//
+// input:
+//	the parse group to process
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseLength( CGPGroup *grp )
+{
+	CGPValue	*pairs;
+	const char	*key;
+	const char	*val;
+
+	// Inside of the group, we should have a series of pairs
+	pairs = grp->GetPairs();
+
+	while( pairs )
+	{	
+		// Let's get the key field
+		key = pairs->GetName();
+		val = pairs->GetTopValue();
+
+		// Huge stricmp lists suxor
+		if ( !stricmp( key, "start" ))
+		{
+			ParseLengthStart( val );
+		}
+		else if ( !stricmp( key, "end" ))
+		{
+			ParseLengthEnd( val );
+		}
+		else if ( !stricmp( key, "parm" ) || !stricmp( key, "parms" ))
+		{
+			ParseLengthParm( val );
+		}
+		else if ( !stricmp( key, "flags" ) || !stricmp( key, "flag" ))
+		{
+			ParseLengthFlags( val );
+		}
+		else
+		{
+			theFxHelper.Print( "Unknown key parsing a Length group: %s\n", key );
+		}
+
+		pairs = (CGPValue *)pairs->GetNext();
+	}
+
+	return true;
+}
+
+
+// Parse a primitive, apply defaults first, grab any base level
+//	key pairs, then process any sub groups we may contain.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParsePrimitive( CGPGroup *grp )
+{
+	CGPGroup	*subGrp;
+	CGPValue	*pairs;
+	const char	*key; 
+	const char	*val;
+
+	// Lets work with the pairs first
+	pairs = grp->GetPairs();
+
+	while( pairs )
+	{
+		// the fields
+		key = pairs->GetName();
+		val = pairs->GetTopValue();
+
+		// Huge stricmp lists suxor
+		if ( !stricmp( key, "count" ))
+		{
+			ParseCount( val );
+		}
+		else if ( !stricmp( key, "shaders" ) || !stricmp( key, "shader" ))
+		{
+			ParseShaders( pairs );
+		}
+		else if ( !stricmp( key, "models" ) || !stricmp( key, "model" ))
+		{
+			ParseModels( pairs );
+		}
+		else if ( !stricmp( key, "sounds" ) || !stricmp( key, "sound" ))
+		{
+			ParseSounds( pairs );
+		}
+#ifdef _IMMERSION
+		else if ( !stricmp( key, "forces" ) || !stricmp( key, "force" ))
+		{
+			ParseForces( pairs );
+		}
+#endif // _IMMERSION
+		else if ( !stricmp( key, "impactfx" ))
+		{
+			ParseImpactFxStrings( pairs );
+		}
+		else if ( !stricmp( key, "deathfx" ))
+		{
+			ParseDeathFxStrings( pairs );
+		}
+		else if ( !stricmp( key, "emitfx" ))
+		{
+			ParseEmitterFxStrings( pairs );
+		}
+		else if ( !stricmp( key, "playfx" ))
+		{
+			ParsePlayFxStrings( pairs );
+		}
+		else if ( !stricmp( key, "life" ))
+		{
+			ParseLife( val );
+		}
+		else if ( !stricmp( key, "cullrange" ))
+		{
+			mCullRange = atoi( val );
+			mCullRange *= mCullRange; // Square
+		}
+		else if ( !stricmp( key, "delay" ))
+		{
+			ParseDelay( val );
+		}
+		else if ( !stricmp( key, "bounce" ) || !stricmp( key, "intensity" )) // me==bad for reusing this...but it shouldn't hurt anything)
+		{
+			ParseElasticity( val );
+		}
+		else if ( !stricmp( key, "min" ))
+		{
+			ParseMin( val );
+		}
+		else if ( !stricmp( key, "max" ))
+		{
+			ParseMax( val );
+		}
+		else if ( !stricmp( key, "angle" ) || !stricmp( key, "angles" ))
+		{
+			ParseAngle( val );
+		}
+		else if ( !stricmp( key, "angleDelta" ))
+		{
+			ParseAngleDelta( val );
+		}
+		else if ( !stricmp( key, "velocity" ) || !stricmp( key, "vel" ))
+		{
+			ParseVelocity( val );
+		}
+		else if ( !stricmp( key, "acceleration" ) || !stricmp( key, "accel" ))
+		{
+			ParseAcceleration( val );
+		}
+		else if ( !stricmp( key, "gravity" ))
+		{
+			ParseGravity( val );
+		}
+		else if ( !stricmp( key, "density" ))
+		{
+			ParseDensity( val );
+		}
+		else if ( !stricmp( key, "variance" ))
+		{
+			ParseVariance( val );
+		}
+		else if ( !stricmp( key, "origin" ))
+		{
+			ParseOrigin1( val );
+		}
+		else if ( !stricmp( key, "origin2" ))
+		{
+			ParseOrigin2( val );
+		}
+		else if ( !stricmp( key, "radius" )) // part of ellipse/cylinder calcs.
+		{
+			ParseRadius( val );
+		}
+		else if ( !stricmp( key, "height" )) // part of ellipse/cylinder calcs.
+		{
+			ParseHeight( val );
+		}
+		else if ( !stricmp( key, "rotation" ))
+		{
+			ParseRotation( val );
+		}
+		else if ( !Q_stricmp( key, "rotationDelta" ))
+		{
+			ParseRotationDelta( val );
+		}
+		else if ( !stricmp( key, "flags" ) || !stricmp( key, "flag" ))
+		{ // these need to get passed on to the primitive
+			ParseFlags( val );
+		}
+		else if ( !stricmp( key, "spawnFlags" ) || !stricmp( key, "spawnFlag" ))
+		{ // these are used to spawn things in cool ways, but don't ever get passed on to prims.
+			ParseSpawnFlags( val );
+		}
+		else if ( !stricmp( key, "name" ))
+		{
+			if ( val )
+			{
+				// just stash the descriptive name of the primitive
+				strcpy( mName, val );
+			}
+		}
+		else
+		{
+			theFxHelper.Print( "Unknown key parsing an effect primitive: %s\n", key );
+		}
+
+		pairs = (CGPValue *)pairs->GetNext();
+	}
+
+	subGrp = grp->GetSubGroups();
+
+	// Lets chomp on the groups now
+	while ( subGrp )
+	{
+		key = subGrp->GetName();
+
+		if ( !stricmp( key, "rgb" ))
+		{
+			ParseRGB( subGrp );
+		}
+		else if ( !stricmp( key, "alpha" ))
+		{
+			ParseAlpha( subGrp );
+		}
+		else if ( !stricmp( key, "size" ) || !stricmp( key, "width" ))
+		{
+			ParseSize( subGrp );
+		}
+		else if ( !stricmp( key, "size2" ) || !stricmp( key, "width2" ))
+		{
+			ParseSize2( subGrp );
+		}
+		else if ( !stricmp( key, "length" ) || !stricmp( key, "height" ))
+		{
+			ParseLength( subGrp );
+		}
+		else
+		{
+			theFxHelper.Print( "Unknown group key parsing a particle: %s\n", key );
+		}
+
+		subGrp = (CGPGroup *)subGrp->GetNext();
+	}
+
+	return true;
+}
\ No newline at end of file
diff --git a/code/cgame/FxUtil.cpp b/code/cgame/FxUtil.cpp
new file mode 100644
index 0000000..2e3650d
--- /dev/null
+++ b/code/cgame/FxUtil.cpp
@@ -0,0 +1,1400 @@
+
+// this include must remain at the top of every CPP file
+#include "common_headers.h"
+
+#if !defined(FX_SCHEDULER_H_INC)
+	#include "FxScheduler.h"
+#endif
+
+vec3_t	WHITE = {1.0f, 1.0f, 1.0f};
+
+struct SEffectList
+{
+	CEffect *mEffect;
+	int		mKillTime;
+	bool	mPortal;
+};
+
+#define PI		3.14159f
+
+SEffectList		effectList[MAX_EFFECTS];
+SEffectList		*nextValidEffect;
+SFxHelper		theFxHelper;
+
+int				activeFx = 0;
+int				mMax = 0;
+int				mMaxTime = 0;
+int				drawnFx;
+int				mParticles;
+int				mOParticles;
+int				mLines;
+int				mTails;
+qboolean		fxInitialized = qfalse;	
+
+//-------------------------
+// FX_Free
+//
+// Frees all FX
+//-------------------------
+bool FX_Free( void )
+{
+	for ( int i = 0; i < MAX_EFFECTS; i++ )
+	{
+		if ( effectList[i].mEffect )
+		{
+			delete effectList[i].mEffect;
+		}
+
+		effectList[i].mEffect = 0;
+	}
+
+	activeFx = 0;
+
+	theFxScheduler.Clean();
+	return true;
+}
+
+//-------------------------
+// FX_Stop
+//
+// Frees all active FX but leaves the templates
+//-------------------------
+void FX_Stop( void )
+{
+	for ( int i = 0; i < MAX_EFFECTS; i++ )
+	{
+		if ( effectList[i].mEffect )
+		{
+			delete effectList[i].mEffect;
+		}
+
+		effectList[i].mEffect = 0;
+	}
+
+	activeFx = 0;
+
+	theFxScheduler.Clean(false);
+}
+
+//-------------------------
+// FX_Init
+//
+// Preps system for use
+//-------------------------
+int	FX_Init( void )
+{ 
+	if ( fxInitialized == qfalse )
+	{
+		fxInitialized = qtrue;
+
+		for ( int i = 0; i < MAX_EFFECTS; i++ )
+		{
+			effectList[i].mEffect = 0;
+		}
+	}
+
+	FX_Free();
+
+	mMax = 0;
+	mMaxTime = 0;
+
+	nextValidEffect = &effectList[0];
+	theFxHelper.Init();
+
+	// ( nothing to see here, go away )
+	//
+	extern void FX_CopeWithAnyLoadedSaveGames();
+	FX_CopeWithAnyLoadedSaveGames();
+
+	return true;
+}
+
+
+//-------------------------
+// FX_FreeMember
+//-------------------------
+static void FX_FreeMember( SEffectList *obj )
+{
+	obj->mEffect->Die();
+	delete obj->mEffect;
+	obj->mEffect = 0;
+
+	// May as well mark this to be used next
+	nextValidEffect = obj;
+
+	activeFx--;
+}
+
+
+//-------------------------
+// FX_GetValidEffect
+//
+// Finds an unused effect slot
+//
+// Note - in the editor, this function may return NULL, indicating that all
+// effects are being stopped.
+//-------------------------
+static SEffectList *FX_GetValidEffect()
+{
+	if ( nextValidEffect->mEffect == 0 )
+	{
+		return nextValidEffect;
+	}
+
+	int			i;
+	SEffectList	*ef;
+
+	// Blah..plow through the list till we find something that is currently untainted
+	for ( i = 0, ef = effectList; i < MAX_EFFECTS; i++, ef++ )
+	{
+		if ( ef->mEffect == 0 )
+		{
+			return ef;
+		}
+	}
+
+	// report the error.
+#ifndef FINAL_BUILD
+	theFxHelper.Print( "FX system out of effects\n" );
+#endif
+
+	// Hmmm.. just trashing the first effect in the list is a poor approach
+	FX_FreeMember( &effectList[0] );
+
+	// Recursive call
+	return nextValidEffect;
+}
+
+
+//-------------------------
+// FX_ActiveFx
+//
+// Returns whether these are any active or scheduled effects
+//-------------------------
+bool FX_ActiveFx(void)
+{
+	return ((activeFx > 0) || (theFxScheduler.NumScheduledFx() > 0));
+}
+
+
+//-------------------------
+// FX_Add
+//
+// Adds all fx to the view
+//-------------------------
+void FX_Add( bool portal )
+{
+	int			i;
+	SEffectList	*ef;
+
+	drawnFx = 0;
+	mParticles = 0;
+	mOParticles = 0;
+	mLines = 0;
+	mTails = 0;
+
+	int numFx = activeFx;	//but stop when there can't be any more left!
+	for ( i = 0, ef = effectList; i < MAX_EFFECTS && numFx; i++, ef++ )
+	{
+		if ( ef->mEffect != 0)
+		{ 
+			--numFx;
+			if (portal != ef->mPortal)
+			{
+				continue;	//this one does not render in this scene
+			}
+			// Effect is active
+			if ( theFxHelper.mTime > ef->mKillTime )
+			{ 
+				// Clean up old effects, calling any death effects as needed
+				// this flag just has to be cleared otherwise death effects might not happen correctly
+				ef->mEffect->ClearFlags( FX_KILL_ON_IMPACT ); 
+				FX_FreeMember( ef );
+			}
+			else
+			{
+				if ( ef->mEffect->Update() == false )
+				{
+					// We've been marked for death
+					FX_FreeMember( ef );
+					continue;
+				}
+			}
+		}
+	}
+	if ( fx_debug.integer == 2 && !portal )
+	{
+		if (theFxHelper.mFrameTime > 100 || theFxHelper.mFrameTime < 5)
+		theFxHelper.Print( "theFxHelper.mFrameTime = %i\n", theFxHelper.mFrameTime );
+	}
+	if ( fx_debug.integer == 1 && !portal )
+	{
+		if ( theFxHelper.mTime > mMaxTime )
+		{
+			// decay pretty harshly when we do it
+			mMax *= 0.9f;
+			mMaxTime = theFxHelper.mTime + 200; // decay 5 times a second if we haven't set a new max
+		}
+		if ( activeFx > mMax )
+		{
+			// but we can never be less that the current activeFx count
+			mMax = activeFx;
+			mMaxTime = theFxHelper.mTime + 4000; // since we just increased the max, hold it for at least 4 seconds
+		}
+
+		// Particles
+		if ( mParticles > 500 )
+		{
+			theFxHelper.Print( ">Particles  ^1%4i  ", mParticles );
+		}
+		else if ( mParticles > 250 )
+		{
+			theFxHelper.Print( ">Particles  ^3%4i  ", mParticles );
+		}
+		else
+		{
+			theFxHelper.Print( ">Particles  %4i  ", mParticles );
+		}
+
+		// Lines
+		if ( mLines > 500 )
+		{
+			theFxHelper.Print( ">Lines ^1%4i\n", mLines );
+		}
+		else if ( mLines > 250 )
+		{
+			theFxHelper.Print( ">Lines ^3%4i\n", mLines );
+		}
+		else
+		{
+			theFxHelper.Print( ">Lines %4i\n", mLines );
+		}
+
+		// OParticles
+		if ( mOParticles > 500 )
+		{
+			theFxHelper.Print( ">OParticles ^1%4i  ", mOParticles );
+		}
+		else if ( mOParticles > 250 )
+		{
+			theFxHelper.Print( ">OParticles ^3%4i  ", mOParticles );
+		}
+		else
+		{
+			theFxHelper.Print( ">OParticles %4i  ", mOParticles );
+		}
+
+		// Tails
+		if ( mTails > 400 )
+		{
+			theFxHelper.Print( ">Tails ^1%4i\n", mTails );
+		}
+		else if ( mTails > 200 )
+		{
+			theFxHelper.Print( ">Tails ^3%4i\n", mTails );
+		}
+		else
+		{
+			theFxHelper.Print( ">Tails %4i\n", mTails );
+		}
+
+		// Active
+		if ( activeFx > 600 )
+		{
+			theFxHelper.Print( ">Active     ^1%4i  ", activeFx );
+		}
+		else if ( activeFx > 400 )
+		{
+			theFxHelper.Print( ">Active     ^3%4i  ", activeFx );
+		}
+		else
+		{
+			theFxHelper.Print( ">Active     %4i  ", activeFx );
+		}
+
+		// Drawn
+		if ( drawnFx > 600 )
+		{
+			theFxHelper.Print( ">Drawn ^1%4i  ", drawnFx );
+		}
+		else if ( drawnFx > 400 )
+		{
+			theFxHelper.Print( ">Drawn ^3%4i  ", drawnFx );
+		}
+		else
+		{
+			theFxHelper.Print( ">Drawn %4i  ", drawnFx );
+		}
+
+		// Max
+		if ( mMax > 600 )
+		{
+			theFxHelper.Print( ">Max ^1%4i  ", mMax );
+		}
+		else if ( mMax > 400 )
+		{
+			theFxHelper.Print( ">Max ^3%4i  ", mMax );
+		}
+		else
+		{
+			theFxHelper.Print( ">Max %4i  ", mMax );
+		}
+
+		// Scheduled
+		if ( theFxScheduler.NumScheduledFx() > 100 )
+		{
+			theFxHelper.Print( ">Scheduled ^1%4i\n", theFxScheduler.NumScheduledFx() );
+		}
+		else if ( theFxScheduler.NumScheduledFx() > 50 )
+		{
+			theFxHelper.Print( ">Scheduled ^3%4i\n", theFxScheduler.NumScheduledFx() );
+		}
+		else
+		{
+			theFxHelper.Print( ">Scheduled %4i\n", theFxScheduler.NumScheduledFx() );
+		}
+	}
+}
+
+
+//-------------------------
+// FX_AddPrimitive
+//
+// Note - in the editor, this function may change *pEffect to NULL, indicating that
+// all effects are being stopped.
+//-------------------------
+extern bool gEffectsInPortal;	//from FXScheduler.cpp so i don't have to pass it in on EVERY FX_ADD*
+void FX_AddPrimitive( CEffect **pEffect, int killTime )
+{
+	SEffectList *item = FX_GetValidEffect();
+
+	item->mEffect = *pEffect;
+	item->mKillTime = theFxHelper.mTime + killTime;
+	item->mPortal = gEffectsInPortal;	//global set in AddScheduledEffects
+
+	activeFx++;
+
+	// Stash these in the primitive so it has easy access to the vals
+	(*pEffect)->SetTimeStart( theFxHelper.mTime );
+	(*pEffect)->SetTimeEnd( theFxHelper.mTime + killTime );
+}
+
+
+//-------------------------
+//  FX_AddParticle
+//-------------------------
+CParticle *FX_AddParticle(  int clientID, const vec3_t org, const vec3_t vel, const vec3_t accel, float gravity,
+							float size1, float size2, float sizeParm, 
+							float alpha1, float alpha2, float alphaParm, 
+							const vec3_t sRGB, const vec3_t eRGB, float rgbParm,
+							float rotation, float rotationDelta,
+							const vec3_t min, const vec3_t max, float elasticity,
+							int deathID, int impactID,
+							int killTime, qhandle_t shader, int flags, int modelNum, int boltNum )
+{
+	if ( theFxHelper.mFrameTime < 1 )
+	{ // disallow adding effects when the system is paused
+		return 0;
+	}
+
+	CParticle *fx = new CParticle;
+
+	if ( fx )
+	{
+		if (flags&FX_RELATIVE && clientID>=0)
+		{
+			fx->SetOrigin1( NULL );
+			fx->SetOrgOffset( org );
+			fx->SetClient( clientID, modelNum, boltNum );
+		}
+		else
+		{
+			fx->SetOrigin1( org );
+		}
+		fx->SetVel( vel );
+		fx->SetAccel( accel );
+		fx->SetGravity( gravity );
+
+		// RGB----------------
+		fx->SetRGBStart( sRGB );
+		fx->SetRGBEnd( eRGB );
+
+		if (( flags & FX_RGB_PARM_MASK ) == FX_RGB_WAVE )
+		{
+			fx->SetRGBParm( rgbParm * PI * 0.001f );
+		}
+		else if ( flags & FX_RGB_PARM_MASK )
+		{
+			// rgbParm should be a value from 0-100..
+			fx->SetRGBParm( rgbParm * 0.01f * killTime + theFxHelper.mTime );
+		}
+
+		// Alpha----------------
+		fx->SetAlphaStart( alpha1 );
+		fx->SetAlphaEnd( alpha2 );
+
+		if (( flags & FX_ALPHA_PARM_MASK ) == FX_ALPHA_WAVE )
+		{
+			fx->SetAlphaParm( alphaParm * PI * 0.001f );
+		}
+		else if ( flags & FX_ALPHA_PARM_MASK )
+		{
+			fx->SetAlphaParm( alphaParm * 0.01f * killTime + theFxHelper.mTime );
+		}
+
+		// Size----------------
+		fx->SetSizeStart( size1 );
+		fx->SetSizeEnd( size2 );
+
+		if (( flags & FX_SIZE_PARM_MASK ) == FX_SIZE_WAVE )
+		{
+			fx->SetSizeParm( sizeParm * PI * 0.001f );
+		}
+		else if ( flags & FX_SIZE_PARM_MASK )
+		{
+			fx->SetSizeParm( sizeParm * 0.01f * killTime + theFxHelper.mTime );
+		}
+
+		fx->SetFlags( flags );
+		fx->SetShader( shader );
+		fx->SetRotation( rotation );
+		fx->SetRotationDelta( rotationDelta );
+		fx->SetElasticity( elasticity );
+		fx->SetMin( min );
+		fx->SetMax( max );
+		fx->SetDeathFxID( deathID );
+		fx->SetImpactFxID( impactID );
+
+		FX_AddPrimitive( (CEffect**)&fx, killTime );
+		// in the editor, fx may now be NULL
+	}
+
+	return fx;
+}
+
+
+//-------------------------
+//  FX_AddLine
+//-------------------------
+CLine *FX_AddLine( int clientID, vec3_t start, vec3_t end, float size1, float size2, float sizeParm,
+									float alpha1, float alpha2, float alphaParm,
+									vec3_t sRGB, vec3_t eRGB, float rgbParm,
+									int killTime, qhandle_t shader, int impactFX_id, int flags, int modelNum, int boltNum )
+{
+	if ( theFxHelper.mFrameTime < 1 )
+	{ // disallow adding new effects when the system is paused
+		return 0;
+	}
+
+	CLine *fx = new CLine;
+
+	if ( fx )
+	{
+		if (flags&FX_RELATIVE && clientID>=0)
+		{
+			fx->SetOrigin1( NULL );
+			fx->SetOrgOffset( start ); //offset from bolt pos
+			fx->SetVel( end );	//vel is the vector offset from bolt+orgOffset
+			fx->SetClient( clientID, modelNum, boltNum );
+		}
+		else
+		{
+			fx->SetOrigin1( start );
+			fx->SetOrigin2( end );
+		}
+		// RGB----------------
+		fx->SetRGBStart( sRGB );
+		fx->SetRGBEnd( eRGB );
+
+		if (( flags & FX_RGB_PARM_MASK ) == FX_RGB_WAVE )
+		{
+			fx->SetRGBParm( rgbParm * PI * 0.001f );
+		}
+		else if ( flags & FX_RGB_PARM_MASK )
+		{
+			// rgbParm should be a value from 0-100..
+			fx->SetRGBParm( rgbParm * 0.01f * killTime + theFxHelper.mTime );
+		}
+
+		// Alpha----------------
+		fx->SetAlphaStart( alpha1 );
+		fx->SetAlphaEnd( alpha2 );
+
+		if (( flags & FX_ALPHA_PARM_MASK ) == FX_ALPHA_WAVE )
+		{
+			fx->SetAlphaParm( alphaParm * PI * 0.001f );
+		}
+		else if ( flags & FX_ALPHA_PARM_MASK )
+		{
+			fx->SetAlphaParm( alphaParm * 0.01f * killTime + theFxHelper.mTime );
+		}
+
+		// Size----------------
+		fx->SetSizeStart( size1 );
+		fx->SetSizeEnd( size2 );
+
+		if (( flags & FX_SIZE_PARM_MASK ) == FX_SIZE_WAVE )
+		{
+			fx->SetSizeParm( sizeParm * PI * 0.001f );
+		}
+		else if ( flags & FX_SIZE_PARM_MASK )
+		{
+			fx->SetSizeParm( sizeParm * 0.01f * killTime + theFxHelper.mTime );
+		}
+
+		fx->SetShader( shader );
+		fx->SetFlags( flags );
+
+		fx->SetSTScale( 1.0f, 1.0f );
+		fx->SetImpactFxID( impactFX_id );
+
+		FX_AddPrimitive( (CEffect**)&fx, killTime );
+		// in the editor, fx may now be NULL
+	}
+
+	return fx;
+}
+
+//-------------------------
+//  FX_AddElectricity
+//-------------------------
+CElectricity *FX_AddElectricity( int clientID, vec3_t start, vec3_t end, float size1, float size2, float sizeParm,
+									float alpha1, float alpha2, float alphaParm,
+									vec3_t sRGB, vec3_t eRGB, float rgbParm,
+									float chaos, int killTime, qhandle_t shader, int flags, int modelNum, int boltNum )
+{
+	if ( theFxHelper.mFrameTime < 1 )
+	{ // disallow adding new effects when the system is paused
+		return 0;
+	}
+
+	CElectricity *fx = new CElectricity;
+
+	if ( fx )
+	{
+		if (flags&FX_RELATIVE && clientID>=0)
+		{
+			fx->SetOrigin1( NULL );
+			fx->SetOrgOffset( start );//offset
+			fx->SetVel( end );	//vel is the vector offset from bolt+orgOffset
+			fx->SetClient( clientID, modelNum, boltNum );
+		}
+		else
+		{
+			fx->SetOrigin1( start );
+			fx->SetOrigin2( end );
+		}
+
+		// RGB----------------
+		fx->SetRGBStart( sRGB );
+		fx->SetRGBEnd( eRGB );
+
+		if (( flags & FX_RGB_PARM_MASK ) == FX_RGB_WAVE )
+		{
+			fx->SetRGBParm( rgbParm * PI * 0.001f );
+		}
+		else if ( flags & FX_RGB_PARM_MASK )
+		{
+			// rgbParm should be a value from 0-100..
+			fx->SetRGBParm( rgbParm * 0.01f * killTime + theFxHelper.mTime );
+		}
+
+		// Alpha----------------
+		fx->SetAlphaStart( alpha1 );
+		fx->SetAlphaEnd( alpha2 );
+
+		if (( flags & FX_ALPHA_PARM_MASK ) == FX_ALPHA_WAVE )
+		{
+			fx->SetAlphaParm( alphaParm * PI * 0.001f );
+		}
+		else if ( flags & FX_ALPHA_PARM_MASK )
+		{
+			fx->SetAlphaParm( alphaParm * 0.01f * killTime + theFxHelper.mTime );
+		}
+
+		// Size----------------
+		fx->SetSizeStart( size1 );
+		fx->SetSizeEnd( size2 );
+
+		if (( flags & FX_SIZE_PARM_MASK ) == FX_SIZE_WAVE )
+		{
+			fx->SetSizeParm( sizeParm * PI * 0.001f );
+		}
+		else if ( flags & FX_SIZE_PARM_MASK )
+		{
+			fx->SetSizeParm( sizeParm * 0.01f * killTime + theFxHelper.mTime );
+		}
+
+		fx->SetShader( shader );
+		fx->SetFlags( flags );
+		fx->SetChaos( chaos );
+
+		fx->SetSTScale( 1.0f, 1.0f );
+
+		FX_AddPrimitive( (CEffect**)&fx, killTime );
+		// in the editor, fx may now be NULL?
+		if ( fx )
+		{
+			fx->Initialize(); 
+		}
+	}
+
+	return fx;
+}
+
+
+//-------------------------
+//  FX_AddTail
+//-------------------------
+CTail *FX_AddTail( int clientID, vec3_t org, vec3_t vel, vec3_t accel, 
+							float size1, float size2, float sizeParm, 
+							float length1, float length2, float lengthParm,
+							float alpha1, float alpha2, float alphaParm,
+							vec3_t sRGB, vec3_t eRGB, float rgbParm,
+							vec3_t min, vec3_t max, float elasticity, 
+							int deathID, int impactID,
+							int killTime, qhandle_t shader, int flags, int modelNum, int boltNum )
+{
+	if ( theFxHelper.mFrameTime < 1 )
+	{ // disallow adding effects when the system is paused
+		return 0;
+	}
+
+	CTail *fx = new CTail;
+
+	if ( fx )
+	{
+		if (flags&FX_RELATIVE && clientID>=0)
+		{
+			fx->SetOrigin1( NULL );
+			fx->SetOrgOffset( org );
+			fx->SetClient( clientID, modelNum, boltNum );
+		}
+		else
+		{
+			fx->SetOrigin1( org );
+		}
+		fx->SetVel( vel );
+		fx->SetAccel( accel );
+		// RGB----------------
+		fx->SetRGBStart( sRGB );
+		fx->SetRGBEnd( eRGB );
+
+		if (( flags & FX_RGB_PARM_MASK ) == FX_RGB_WAVE )
+		{
+			fx->SetRGBParm( rgbParm * PI * 0.001f );
+		}
+		else if ( flags & FX_RGB_PARM_MASK )
+		{
+			// rgbParm should be a value from 0-100..
+			fx->SetRGBParm( rgbParm * 0.01f * killTime + theFxHelper.mTime );
+		}
+
+		// Alpha----------------
+		fx->SetAlphaStart( alpha1 );
+		fx->SetAlphaEnd( alpha2 );
+
+		if (( flags & FX_ALPHA_PARM_MASK ) == FX_ALPHA_WAVE )
+		{
+			fx->SetAlphaParm( alphaParm * PI * 0.001f );
+		}
+		else if ( flags & FX_ALPHA_PARM_MASK )
+		{
+			fx->SetAlphaParm( alphaParm * 0.01f * killTime + theFxHelper.mTime );
+		}
+
+		// Size----------------
+		fx->SetSizeStart( size1 );
+		fx->SetSizeEnd( size2 );
+
+		if (( flags & FX_SIZE_PARM_MASK ) == FX_SIZE_WAVE )
+		{
+			fx->SetSizeParm( sizeParm * PI * 0.001f );
+		}
+		else if ( flags & FX_SIZE_PARM_MASK )
+		{
+			fx->SetSizeParm( sizeParm * 0.01f * killTime + theFxHelper.mTime );
+		}
+
+		// Length----------------
+		fx->SetLengthStart( length1 );
+		fx->SetLengthEnd( length2 );
+
+		if (( flags & FX_LENGTH_PARM_MASK ) == FX_LENGTH_WAVE )
+		{
+			fx->SetLengthParm( lengthParm * PI * 0.001f );
+		}
+		else if ( flags & FX_LENGTH_PARM_MASK )
+		{
+			fx->SetLengthParm( lengthParm * 0.01f * killTime + theFxHelper.mTime );
+		}
+
+		fx->SetFlags( flags );
+		fx->SetShader( shader );
+		fx->SetElasticity( elasticity );
+		fx->SetMin( min );
+		fx->SetMax( max );
+		fx->SetSTScale( 1.0f, 1.0f );
+		fx->SetDeathFxID( deathID );
+		fx->SetImpactFxID( impactID );
+
+		FX_AddPrimitive( (CEffect**)&fx, killTime );
+		// in the editor, fx may now be NULL
+	}
+
+	return fx;
+}
+
+//-------------------------
+//  FX_AddCylinder
+//-------------------------
+CCylinder *FX_AddCylinder( int clientID, vec3_t start, vec3_t normal, 
+							float size1s, float size1e, float sizeParm,
+							float size2s, float size2e, float size2Parm,
+							float length1, float length2, float lengthParm,
+							float alpha1, float alpha2, float alphaParm,
+							vec3_t rgb1, vec3_t rgb2, float rgbParm,
+							int killTime, qhandle_t shader, int flags, int modelNum, int boltNum )
+{
+	if ( theFxHelper.mFrameTime < 1 )
+	{ // disallow adding new effects when the system is paused
+		return 0;
+	}
+
+	CCylinder *fx = new CCylinder;
+
+	if ( fx )
+	{
+		if (flags&FX_RELATIVE && clientID>=0)
+		{
+			fx->SetOrigin1( NULL );
+			fx->SetOrgOffset( start );//offset
+			//NOTE: relative version doesn't ever use normal!
+			//fx->SetNormal( normal );
+			fx->SetClient( clientID, modelNum, boltNum );
+		}
+		else
+		{
+			fx->SetOrigin1( start );
+			fx->SetNormal( normal );
+		}
+
+		// RGB----------------
+		fx->SetRGBStart( rgb1 );
+		fx->SetRGBEnd( rgb2 );
+
+		if (( flags & FX_RGB_PARM_MASK ) == FX_RGB_WAVE )
+		{
+			fx->SetRGBParm( rgbParm * PI * 0.001f );
+		}
+		else if ( flags & FX_RGB_PARM_MASK )
+		{
+			// rgbParm should be a value from 0-100..
+			fx->SetRGBParm( rgbParm * 0.01f * killTime + theFxHelper.mTime );
+		}
+
+		// Size1----------------
+		fx->SetSizeStart( size1s );
+		fx->SetSizeEnd( size1e );
+
+		if (( flags & FX_SIZE_PARM_MASK ) == FX_SIZE_WAVE )
+		{
+			fx->SetSizeParm( sizeParm * PI * 0.001f );
+		}
+		else if ( flags & FX_SIZE_PARM_MASK )
+		{
+			fx->SetSizeParm( sizeParm * 0.01f * killTime + theFxHelper.mTime );
+		}
+
+		// Size2----------------
+		fx->SetSize2Start( size2s );
+		fx->SetSize2End( size2e );
+
+		if (( flags & FX_SIZE2_PARM_MASK ) == FX_SIZE2_WAVE )
+		{
+			fx->SetSize2Parm( size2Parm * PI * 0.001f );
+		}
+		else if ( flags & FX_SIZE2_PARM_MASK )
+		{
+			fx->SetSize2Parm( size2Parm * 0.01f * killTime + theFxHelper.mTime );
+		}
+
+		// Length1---------------
+		fx->SetLengthStart( length1 );
+		fx->SetLengthEnd( length2 );
+
+		if (( flags & FX_LENGTH_PARM_MASK ) == FX_LENGTH_WAVE )
+		{
+			fx->SetLengthParm( lengthParm * PI * 0.001f );
+		}
+		else if ( flags & FX_LENGTH_PARM_MASK )
+		{
+			fx->SetLengthParm( lengthParm * 0.01f * killTime + theFxHelper.mTime );
+		}
+
+		// Alpha----------------
+		fx->SetAlphaStart( alpha1 );
+		fx->SetAlphaEnd( alpha2 );
+
+		if (( flags & FX_ALPHA_PARM_MASK ) == FX_ALPHA_WAVE )
+		{
+			fx->SetAlphaParm( alphaParm * PI * 0.001f );
+		}
+		else if ( flags & FX_ALPHA_PARM_MASK )
+		{
+			fx->SetAlphaParm( alphaParm * 0.01f * killTime + theFxHelper.mTime );
+		}
+
+		fx->SetShader( shader );
+		fx->SetFlags( flags );
+
+		FX_AddPrimitive( (CEffect**)&fx, killTime );
+	}
+
+	return fx;
+}
+
+//-------------------------
+//  FX_AddEmitter
+//-------------------------
+CEmitter *FX_AddEmitter( vec3_t org, vec3_t vel, vec3_t accel, 
+								float size1, float size2, float sizeParm,
+								float alpha1, float alpha2, float alphaParm,
+								vec3_t rgb1, vec3_t rgb2, float rgbParm,
+								vec3_t angs, vec3_t deltaAngs,
+								vec3_t min, vec3_t max, float elasticity, 
+								int deathID, int impactID, int emitterID,
+								float density, float variance,
+								int killTime, qhandle_t model, int flags )
+{
+	if ( theFxHelper.mFrameTime < 1 )
+	{ // disallow adding effects when the system is paused
+		return 0;
+	}
+
+	CEmitter *fx = new CEmitter;
+
+	if ( fx )
+	{
+		fx->SetOrigin1( org );
+		fx->SetVel( vel );
+		fx->SetAccel( accel );
+
+		// RGB----------------
+		fx->SetRGBStart( rgb1 );
+		fx->SetRGBEnd( rgb2 );
+
+		if (( flags & FX_RGB_PARM_MASK ) == FX_RGB_WAVE )
+		{
+			fx->SetRGBParm( rgbParm * PI * 0.001f );
+		}
+		else if ( flags & FX_RGB_PARM_MASK )
+		{
+			// rgbParm should be a value from 0-100..
+			fx->SetRGBParm( rgbParm * 0.01f * killTime + theFxHelper.mTime );
+		}
+
+		// Size----------------
+		fx->SetSizeStart( size1 );
+		fx->SetSizeEnd( size2 );
+
+		if (( flags & FX_SIZE_PARM_MASK ) == FX_SIZE_WAVE )
+		{
+			fx->SetSizeParm( sizeParm * PI * 0.001f );
+		}
+		else if ( flags & FX_SIZE_PARM_MASK )
+		{
+			fx->SetSizeParm( sizeParm * 0.01f * killTime + theFxHelper.mTime );
+		}
+
+		// Alpha----------------
+		fx->SetAlphaStart( alpha1 );
+		fx->SetAlphaEnd( alpha2 );
+
+		if (( flags & FX_ALPHA_PARM_MASK ) == FX_ALPHA_WAVE )
+		{
+			fx->SetAlphaParm( alphaParm * PI * 0.001f );
+		}
+		else if ( flags & FX_ALPHA_PARM_MASK )
+		{
+			fx->SetAlphaParm( alphaParm * 0.01f * killTime + theFxHelper.mTime );
+		}
+
+		fx->SetAngles( angs );
+		fx->SetAngleDelta( deltaAngs );
+		fx->SetFlags( flags );
+		fx->SetModel( model );
+		fx->SetElasticity( elasticity );
+		fx->SetMin( min );
+		fx->SetMax( max );
+		fx->SetDeathFxID( deathID );
+		fx->SetImpactFxID( impactID );
+		fx->SetEmitterFxID( emitterID );
+		fx->SetDensity( density );
+		fx->SetVariance( variance );
+		fx->SetOldTime( theFxHelper.mTime );
+
+		fx->SetLastOrg( org );
+		fx->SetLastVel( vel );
+
+		FX_AddPrimitive( (CEffect**)&fx, killTime );
+		// in the editor, fx may now be NULL
+	}
+
+	return fx;
+}
+
+//-------------------------
+//  FX_AddLight
+//-------------------------
+CLight *FX_AddLight( vec3_t org, float size1, float size2, float sizeParm,
+							vec3_t rgb1, vec3_t rgb2, float rgbParm,
+							int killTime, int flags )
+{
+	if ( theFxHelper.mFrameTime < 1 )
+	{ // disallow adding effects when the system is paused
+		return 0;
+	}
+
+	CLight *fx = new CLight;
+
+	if ( fx )
+	{
+		fx->SetOrigin1( org );
+
+		// RGB----------------
+		fx->SetRGBStart( rgb1 );
+		fx->SetRGBEnd( rgb2 );
+
+		if (( flags & FX_RGB_PARM_MASK ) == FX_RGB_WAVE )
+		{
+			fx->SetRGBParm( rgbParm * PI * 0.001f );
+		}
+		else if ( flags & FX_RGB_PARM_MASK )
+		{
+			// rgbParm should be a value from 0-100..
+			fx->SetRGBParm( rgbParm * 0.01f * killTime + theFxHelper.mTime );
+		}
+
+		// Size----------------
+		fx->SetSizeStart( size1 );
+		fx->SetSizeEnd( size2 );
+
+		if (( flags & FX_SIZE_PARM_MASK ) == FX_SIZE_WAVE )
+		{
+			fx->SetSizeParm( sizeParm * PI * 0.001f );
+		}
+		else if ( flags & FX_SIZE_PARM_MASK )
+		{
+			fx->SetSizeParm( sizeParm * 0.01f * killTime + theFxHelper.mTime );
+		}
+
+		fx->SetFlags( flags );
+
+		FX_AddPrimitive( (CEffect**)&fx, killTime );
+		// in the editor, fx may now be NULL
+	}
+
+	return fx;
+
+}
+
+
+//-------------------------
+//  FX_AddOrientedParticle
+//-------------------------
+COrientedParticle *FX_AddOrientedParticle( int clientID, vec3_t org, vec3_t norm, vec3_t vel, vec3_t accel,
+						float size1, float size2, float sizeParm,
+						float alpha1, float alpha2, float alphaParm,
+						vec3_t rgb1, vec3_t rgb2, float rgbParm,
+						float rotation, float rotationDelta,
+						vec3_t min, vec3_t max, float bounce,
+						int deathID, int impactID,
+						int killTime, qhandle_t shader, int flags, int modelNum, int boltNum )
+{
+	if ( theFxHelper.mFrameTime < 1 )
+	{ // disallow adding effects when the system is paused
+		return 0;
+	}
+
+	COrientedParticle *fx = new COrientedParticle;
+
+	if ( fx )
+	{
+		if (flags&FX_RELATIVE && clientID>=0)
+		{
+			fx->SetOrigin1( NULL );
+			fx->SetOrgOffset( org );//offset
+			fx->SetNormalOffset( norm );
+			fx->SetClient( clientID, modelNum, boltNum );
+		}
+		else
+		{
+			fx->SetOrigin1( org );
+			fx->SetNormal( norm );
+		}
+		fx->SetVel( vel );
+		fx->SetAccel( accel );
+
+		// RGB----------------
+		fx->SetRGBStart( rgb1 );
+		fx->SetRGBEnd( rgb2 );
+
+		if (( flags & FX_RGB_PARM_MASK ) == FX_RGB_WAVE )
+		{
+			fx->SetRGBParm( rgbParm * PI * 0.001f );
+		}
+		else if ( flags & FX_RGB_PARM_MASK )
+		{
+			// rgbParm should be a value from 0-100..
+			fx->SetRGBParm( rgbParm * 0.01f * killTime + theFxHelper.mTime );
+		}
+
+		// Alpha----------------
+		fx->SetAlphaStart( alpha1 );
+		fx->SetAlphaEnd( alpha2 );
+
+		if (( flags & FX_ALPHA_PARM_MASK ) == FX_ALPHA_WAVE )
+		{
+			fx->SetAlphaParm( alphaParm * PI * 0.001f );
+		}
+		else if ( flags & FX_ALPHA_PARM_MASK )
+		{
+			fx->SetAlphaParm( alphaParm * 0.01f * killTime + theFxHelper.mTime );
+		}
+
+		// Size----------------
+		fx->SetSizeStart( size1 );
+		fx->SetSizeEnd( size2 );
+
+		if (( flags & FX_SIZE_PARM_MASK ) == FX_SIZE_WAVE )
+		{
+			fx->SetSizeParm( sizeParm * PI * 0.001f );
+		}
+		else if ( flags & FX_SIZE_PARM_MASK )
+		{
+			fx->SetSizeParm( sizeParm * 0.01f * killTime + theFxHelper.mTime );
+		}
+
+		fx->SetFlags( flags );
+		fx->SetShader( shader );
+		fx->SetRotation( rotation );
+		fx->SetRotationDelta( rotationDelta );
+		fx->SetElasticity( bounce );
+		fx->SetMin( min );
+		fx->SetMax( max );
+		fx->SetDeathFxID( deathID );
+		fx->SetImpactFxID( impactID );
+
+		FX_AddPrimitive( (CEffect**)&fx, killTime );
+		// in the editor, fx may now be NULL
+	}
+
+	return fx;
+}
+
+
+//-------------------------
+//  FX_AddPoly
+//-------------------------
+CPoly *FX_AddPoly( vec3_t *verts, vec2_t *st, int numVerts, 
+							vec3_t vel, vec3_t accel,
+							float alpha1, float alpha2, float alphaParm,
+							vec3_t rgb1, vec3_t rgb2, float rgbParm,
+							vec3_t rotationDelta, float bounce, int motionDelay,
+							int killTime, qhandle_t shader, int flags )
+{
+	if ( theFxHelper.mFrameTime < 1 || !verts )
+	{ // disallow adding effects when the system is paused or the user doesn't pass in a vert array
+		return 0;
+	}
+
+	CPoly *fx = new CPoly;
+
+	if ( fx )
+	{
+		// Do a cheesy copy of the verts and texture coords into our own structure
+		for ( int i = 0; i < numVerts; i++ )
+		{
+			VectorCopy( verts[i], fx->mOrg[i] );
+			Vector2Copy( st[i], fx->mST[i] );
+		}
+
+		fx->SetVel( vel );
+		fx->SetAccel( accel );
+
+		// RGB----------------
+		fx->SetRGBStart( rgb1 );
+		fx->SetRGBEnd( rgb2 );
+
+		if (( flags & FX_RGB_PARM_MASK ) == FX_RGB_WAVE )
+		{
+			fx->SetRGBParm( rgbParm * PI * 0.001f );
+		}
+		else if ( flags & FX_RGB_PARM_MASK )
+		{
+			// rgbParm should be a value from 0-100..
+			fx->SetRGBParm( rgbParm * 0.01f * killTime + theFxHelper.mTime );
+		}
+
+		// Alpha----------------
+		fx->SetAlphaStart( alpha1 );
+		fx->SetAlphaEnd( alpha2 );
+
+		if (( flags & FX_ALPHA_PARM_MASK ) == FX_ALPHA_WAVE )
+		{
+			fx->SetAlphaParm( alphaParm * PI * 0.001f );
+		}
+		else if ( flags & FX_ALPHA_PARM_MASK )
+		{
+			fx->SetAlphaParm( alphaParm * 0.01f * killTime + theFxHelper.mTime );
+		}
+
+		fx->SetFlags( flags );
+		fx->SetShader( shader );
+		fx->SetRot( rotationDelta );
+		fx->SetElasticity( bounce );
+		fx->SetMotionTimeStamp( motionDelay );
+		fx->SetNumVerts( numVerts );
+
+		// Now that we've set our data up, let's process it into a useful format
+		fx->PolyInit();
+
+		FX_AddPrimitive( (CEffect**)&fx, killTime );
+		// in the editor, fx may now be NULL
+	}
+
+	return fx;
+}
+
+
+//-------------------------
+//  FX_AddBezier
+//-------------------------
+CBezier *FX_AddBezier( const vec3_t start, const vec3_t end, 
+						const vec3_t control1, const vec3_t control1Vel,
+						const vec3_t control2, const vec3_t control2Vel,
+						float size1, float size2, float sizeParm,
+						float alpha1, float alpha2, float alphaParm,
+						const vec3_t sRGB, const vec3_t eRGB, const float rgbParm,
+						int killTime, qhandle_t shader, int flags )
+{
+	if ( theFxHelper.mFrameTime < 1 )
+	{ // disallow adding new effects when the system is paused
+		return 0;
+	}
+
+	CBezier *fx = new CBezier;
+
+	if ( fx )
+	{
+		fx->SetOrigin1( start );
+		fx->SetOrigin2( end );
+
+		fx->SetControlPoints( control1, control2 );
+		fx->SetControlVel( control1Vel, control2Vel );
+
+		// RGB----------------
+		fx->SetRGBStart( sRGB );
+		fx->SetRGBEnd( eRGB );
+
+		if (( flags & FX_RGB_PARM_MASK ) == FX_RGB_WAVE )
+		{
+			fx->SetRGBParm( rgbParm * PI * 0.001f );
+		}
+		else if ( flags & FX_RGB_PARM_MASK )
+		{
+			// rgbParm should be a value from 0-100..
+			fx->SetRGBParm( rgbParm * 0.01f * killTime + theFxHelper.mTime );
+		}
+
+		// Alpha----------------
+		fx->SetAlphaStart( alpha1 );
+		fx->SetAlphaEnd( alpha2 );
+
+		if (( flags & FX_ALPHA_PARM_MASK ) == FX_ALPHA_WAVE )
+		{
+			fx->SetAlphaParm( alphaParm * PI * 0.001f );
+		}
+		else if ( flags & FX_ALPHA_PARM_MASK )
+		{
+			fx->SetAlphaParm( alphaParm * 0.01f * killTime + theFxHelper.mTime );
+		}
+
+		// Size----------------
+		fx->SetSizeStart( size1 );
+		fx->SetSizeEnd( size2 );
+
+		if (( flags & FX_SIZE_PARM_MASK ) == FX_SIZE_WAVE )
+		{
+			fx->SetSizeParm( sizeParm * PI * 0.001f );
+		}
+		else if ( flags & FX_SIZE_PARM_MASK )
+		{
+			fx->SetSizeParm( sizeParm * 0.01f * killTime + theFxHelper.mTime );
+		}
+
+		fx->SetShader( shader );
+		fx->SetFlags( flags );
+
+		fx->SetSTScale( 1.0f, 1.0f );
+
+		FX_AddPrimitive( (CEffect**)&fx, killTime );
+	}
+
+	return fx;
+}
+
+//-------------------------
+//  FX_AddFlash
+//-------------------------
+CFlash *FX_AddFlash( vec3_t origin, vec3_t sRGB, vec3_t eRGB, float rgbParm,
+						int killTime, qhandle_t shader, int flags = 0 )
+{
+	if ( theFxHelper.mFrameTime < 1 )
+	{ // disallow adding new effects when the system is paused
+		return 0;
+	}
+
+	CFlash *fx = new CFlash;
+
+	if ( fx )
+	{
+		fx->SetOrigin1( origin );
+
+		// RGB----------------
+		fx->SetRGBStart( sRGB );
+		fx->SetRGBEnd( eRGB );
+
+		if (( flags & FX_RGB_PARM_MASK ) == FX_RGB_WAVE )
+		{
+			fx->SetRGBParm( rgbParm * PI * 0.001f );
+		}
+		else if ( flags & FX_RGB_PARM_MASK )
+		{
+			// rgbParm should be a value from 0-100..
+			fx->SetRGBParm( rgbParm * 0.01f * killTime + theFxHelper.mTime );
+		}
+
+/*		// Alpha----------------
+		fx->SetAlphaStart( alpha1 );
+		fx->SetAlphaEnd( alpha2 );
+
+		if (( flags & FX_ALPHA_PARM_MASK ) == FX_ALPHA_WAVE )
+		{
+			fx->SetAlphaParm( alphaParm * PI * 0.001f );
+		}
+		else if ( flags & FX_ALPHA_PARM_MASK )
+		{
+			fx->SetAlphaParm( alphaParm * 0.01f * killTime + theFxHelper.mTime );
+		}
+
+		// Size----------------
+		fx->SetSizeStart( size1 );
+		fx->SetSizeEnd( size2 );
+
+		if (( flags & FX_SIZE_PARM_MASK ) == FX_SIZE_WAVE )
+		{
+			fx->SetSizeParm( sizeParm * PI * 0.001f );
+		}
+		else if ( flags & FX_SIZE_PARM_MASK )
+		{
+			fx->SetSizeParm( sizeParm * 0.01f * killTime + theFxHelper.mTime );
+		}
+*/
+		fx->SetShader( shader );
+		fx->SetFlags( flags );
+
+//		fx->SetSTScale( 1.0f, 1.0f );
+		
+		fx->Init();
+
+		FX_AddPrimitive( (CEffect**)&fx, killTime );
+	}
+
+	return fx;
+}
+
+//-------------------------------------------------------
+// Functions for limited backward compatibility with EF.
+//	These calls can be used for simple programmatic 
+//	effects, temp effects or debug graphics.
+// Note that this is not an all-inclusive list of
+//	fx add functions from EF, nor are the calls guaranteed
+//	to produce the exact same result.
+//-------------------------------------------------------
+
+//---------------------------------------------------
+void FX_AddSprite( vec3_t origin, vec3_t vel, vec3_t accel, 
+							float scale, float dscale, 
+							float sAlpha, float eAlpha, 
+							float rotation, float bounce,  
+							int life, qhandle_t shader, int flags )
+{
+	FX_AddParticle( -1, origin, vel, accel, 0, scale, scale, 0, 
+							sAlpha, eAlpha, FX_ALPHA_LINEAR,
+							WHITE, WHITE, 0,
+							rotation, 0,
+							vec3_origin, vec3_origin, bounce,
+							0, 0,
+							life, shader, flags );
+}
+
+//---------------------------------------------------
+void FX_AddSprite( vec3_t origin, vec3_t vel, vec3_t accel, 
+							float scale, float dscale, 
+							float sAlpha, float eAlpha, 
+							vec3_t sRGB, vec3_t eRGB, 
+							float rotation, float bounce, 
+							int life, qhandle_t shader, int flags )
+{
+	FX_AddParticle( -1, origin, vel, accel, 0, scale, scale, 0, 
+							sAlpha, eAlpha, FX_ALPHA_LINEAR,
+							sRGB, eRGB, 0,
+							rotation, 0,
+							vec3_origin, vec3_origin, bounce,
+							0, 0,
+							life, shader, flags );
+}
+
+//---------------------------------------------------
+void FX_AddLine( vec3_t start, vec3_t end, float stScale, 
+							float width, float dwidth, 
+							float sAlpha, float eAlpha, 
+							int life, qhandle_t shader, int flags )
+{
+	FX_AddLine( -1, start, end, width, width, 0,
+							sAlpha, eAlpha, FX_ALPHA_LINEAR,
+							WHITE, WHITE, 0,
+							life, shader, 0, 0 );
+}
+
+//---------------------------------------------------
+void FX_AddLine( vec3_t start, vec3_t end, float stScale, 
+							float width, float dwidth, 
+							float sAlpha, float eAlpha, 
+							vec3_t sRGB, vec3_t eRGB, 
+							int life, qhandle_t shader, int flags )
+{
+	FX_AddLine( -1, start, end, width, width, 0,
+							sAlpha, eAlpha, FX_ALPHA_LINEAR,
+							sRGB, eRGB, 0,
+							life, shader, 0, flags );
+}
+
+//---------------------------------------------------
+void FX_AddQuad( vec3_t origin, vec3_t normal, 
+							vec3_t vel, vec3_t accel, 
+							float sradius, float eradius, 
+							float salpha, float ealpha, 
+							vec3_t sRGB, vec3_t eRGB, 
+							float rotation, int life, qhandle_t shader, int flags )
+{
+	FX_AddOrientedParticle( -1, origin, normal, vel, accel, 
+							sradius, eradius, 0.0f,
+							salpha, ealpha, 0.0f,
+							sRGB, eRGB, 0.0f,
+							rotation, 0.0f, 
+							NULL, NULL, 0.0f, 0, 0, life,
+							shader, 0 );
+}
diff --git a/code/cgame/FxUtil.h b/code/cgame/FxUtil.h
new file mode 100644
index 0000000..37dfa81
--- /dev/null
+++ b/code/cgame/FxUtil.h
@@ -0,0 +1,130 @@
+
+#if !defined(FX_PRIMITIVES_H_INC)
+	#include "FxPrimitives.h"
+#endif
+
+#ifndef FX_UTIL_H_INC
+#define FX_UTIL_H_INC
+
+
+bool	FX_Free( void );	// ditches all active effects;
+int		FX_Init( void );	// called in CG_Init to purge the fx system.
+void	FX_Add( bool portal );		// called every cgame frame to add all fx into the scene.
+void	FX_Stop( void );	// ditches all active effects without touching the templates.
+
+bool	FX_ActiveFx(void);	// returns whether there are any active or scheduled effects
+
+
+CParticle *FX_AddParticle( int clientID, const vec3_t org, const vec3_t vel, const vec3_t accel, float gravity,
+							float size1, float size2, float sizeParm, 
+							float alpha1, float alpha2, float alphaParm, 
+							const vec3_t rgb1, const vec3_t rgb2, float rgbParm,
+							float rotation, float rotationDelta,
+							const vec3_t min, const vec3_t max, float elasticity, 
+							int deathID, int impactID,
+							int killTime, qhandle_t shader, int flags, int modelNum = -1, int boltNum = -1 );
+
+CLine *FX_AddLine( int clientID, vec3_t start, vec3_t end, 
+							float size1, float size2, float sizeParm,
+							float alpha1, float alpha2, float alphaParm,
+							vec3_t rgb1, vec3_t rgb2, float rgbParm,
+							int killTime, qhandle_t shader, int impactFX_id, int flags, int modelNum = -1, int boltNum = -1 );
+
+CElectricity *FX_AddElectricity( int clientID, vec3_t start, vec3_t end, float size1, float size2, float sizeParm,
+							float alpha1, float alpha2, float alphaParm,
+							vec3_t sRGB, vec3_t eRGB, float rgbParm,
+							float chaos, int killTime, qhandle_t shader, int flags, int modelNum = -1, int boltNum = -1 );
+
+CTail *FX_AddTail( int clientID, vec3_t org, vec3_t vel, vec3_t accel, 
+							float size1, float size2, float sizeParm, 
+							float length1, float length2, float lengthParm,
+							float alpha1, float alpha2, float alphaParm,
+							vec3_t rgb1, vec3_t rgb2, float rgbParm,
+							vec3_t min, vec3_t max, float elasticity, 
+							int deathID, int impactID,
+							int killTime, qhandle_t shader, int flags, int modelNum = -1, int boltNum = -1 );
+
+CCylinder *FX_AddCylinder( int clientID, vec3_t start, vec3_t normal, 
+							float size1s, float size1e, float size1Parm,
+							float size2s, float size2e, float size2Parm,
+							float length1, float length2, float lengthParm,
+							float alpha1, float alpha2, float alphaParm,
+							vec3_t rgb1, vec3_t rgb2, float rgbParm,
+							int killTime, qhandle_t shader, int flags, int modelNum = -1, int boltNum = -1 );
+
+CEmitter *FX_AddEmitter( vec3_t org, vec3_t vel, vec3_t accel,
+							float size1, float size2, float sizeParm,
+							float alpha1, float alpha2, float alphaParm,
+							vec3_t rgb1, vec3_t rgb2, float rgbParm,
+							vec3_t angs, vec3_t deltaAngs,
+							vec3_t min, vec3_t max, float elasticity, 
+							int deathID, int impactID, int emitterID,
+							float density, float variance,
+							int killTime, qhandle_t model, int flags );
+
+CLight *FX_AddLight( vec3_t org, float size1, float size2, float sizeParm,
+							vec3_t rgb1, vec3_t rgb2, float rgbParm,
+							int killTime, int flags );
+
+COrientedParticle *FX_AddOrientedParticle( int clientID, vec3_t org, vec3_t norm, vec3_t vel, vec3_t accel,
+							float size1, float size2, float sizeParm,
+							float alpha1, float alpha2, float alphaParm,
+							vec3_t rgb1, vec3_t rgb2, float rgbParm,
+							float rotation, float rotationDelta,
+							vec3_t min, vec3_t max, float bounce,
+							int deathID, int impactID,
+							int killTime, qhandle_t shader, int flags, int modelNum = -1, int boltNum = -1 );
+
+CPoly *FX_AddPoly( vec3_t *verts, vec2_t *st, int numVerts,
+							vec3_t vel, vec3_t accel,
+							float alpha1, float alpha2, float alphaParm,
+							vec3_t rgb1, vec3_t rgb2, float rgbParm,
+							vec3_t rotationDelta, float bounce, int motionDelay,
+							int killTime, qhandle_t shader, int flags );
+
+CFlash *FX_AddFlash( vec3_t origin, vec3_t sRGB, vec3_t eRGB, float rgbParm,
+						int life, qhandle_t shader, int flags );
+
+
+// Included for backwards compatibility with CHC and for doing quick programmatic effects.
+void FX_AddSprite( vec3_t origin, vec3_t vel, vec3_t accel, 
+							float scale, float dscale, 
+							float sAlpha, float eAlpha, 
+							float rotation, float bounce, 
+							int life, qhandle_t shader, int flags = 0 );
+
+void FX_AddSprite( vec3_t origin, vec3_t vel, vec3_t accel, 
+							float scale, float dscale, 
+							float sAlpha, float eAlpha, 
+							vec3_t sRGB, vec3_t eRGB, 
+							float rotation, float bounce, 
+							int life, qhandle_t shader, int flags = 0 );
+
+void FX_AddLine( vec3_t start, vec3_t end, float stScale, 
+							float width, float dwidth, 
+							float sAlpha, float eAlpha, 
+							int life, qhandle_t shader, int flags = 0 );
+
+void FX_AddLine( vec3_t start, vec3_t end, float stScale, 
+							float width, float dwidth, 
+							float sAlpha, float eAlpha, 
+							vec3_t sRGB, vec3_t eRGB, 
+							int life, qhandle_t shader, int flags = 0 );
+
+void FX_AddQuad( vec3_t origin, vec3_t normal, 
+						vec3_t vel, vec3_t accel, 
+						float sradius, float eradius, 
+						float salpha, float ealpha, 
+						vec3_t sRGB, vec3_t eRGB, 
+						float rotation, int life, qhandle_t shader, int flags = 0 );
+
+CBezier *FX_AddBezier( const vec3_t start, const vec3_t end, 
+						const vec3_t control1, const vec3_t control1Vel,
+						const vec3_t control2, const vec3_t control2Vel,
+						float size1, float size2, float sizeParm,
+						float alpha1, float alpha2, float alphaParm,
+						const vec3_t sRGB, const vec3_t eRGB, const float rgbParm,
+						int killTime, qhandle_t shader, int flags = 0 );
+
+
+#endif //FX_UTIL_H_INC
\ No newline at end of file
diff --git a/code/cgame/animtable.h b/code/cgame/animtable.h
new file mode 100644
index 0000000..84bfc55
--- /dev/null
+++ b/code/cgame/animtable.h
@@ -0,0 +1,1792 @@
+// special file included only by cg_players.cpp & ui_players.cpp
+//
+// moved it from the original header file for PCH reasons...
+//
+
+#if defined(_XBOX) && !defined(_JK2EXE) && !defined(_UI)	// Linker only wants one copy
+extern stringID_table_t animTable[MAX_ANIMATIONS+1];
+#else
+stringID_table_t animTable [MAX_ANIMATIONS+1] =
+{
+	//=================================================
+	//HEAD ANIMS
+	//=================================================
+	//# #sep Head-only anims
+	ENUM2STRING(FACE_TALK0),			//# silent
+	ENUM2STRING(FACE_TALK1),			//# quiet
+	ENUM2STRING(FACE_TALK2),			//# semi-quiet
+	ENUM2STRING(FACE_TALK3),			//# semi-loud
+	ENUM2STRING(FACE_TALK4),			//# loud
+	ENUM2STRING(FACE_ALERT),				//# 
+	ENUM2STRING(FACE_SMILE),				//# 
+	ENUM2STRING(FACE_FROWN),				//# 
+	ENUM2STRING(FACE_DEAD),				//# 
+
+	//=================================================
+	//ANIMS IN WHICH UPPER AND LOWER OBJECTS ARE IN MD3
+	//=================================================
+	//# #sep ENUM2STRING(BOTH_ DEATHS
+	ENUM2STRING(BOTH_DEATH1),		//# First Death anim
+	ENUM2STRING(BOTH_DEATH2),			//# Second Death anim
+	ENUM2STRING(BOTH_DEATH3),			//# Third Death anim
+	ENUM2STRING(BOTH_DEATH4),			//# Fourth Death anim
+	ENUM2STRING(BOTH_DEATH5),			//# Fifth Death anim
+	ENUM2STRING(BOTH_DEATH6),			//# Sixth Death anim
+	ENUM2STRING(BOTH_DEATH7),			//# Seventh Death anim
+	ENUM2STRING(BOTH_DEATH8),			//# 
+	ENUM2STRING(BOTH_DEATH9),			//# 
+	ENUM2STRING(BOTH_DEATH10),			//# 
+	ENUM2STRING(BOTH_DEATH11),			//#
+	ENUM2STRING(BOTH_DEATH12),			//# 
+	ENUM2STRING(BOTH_DEATH13),			//# 
+	ENUM2STRING(BOTH_DEATH14),			//# 
+	ENUM2STRING(BOTH_DEATH15),			//# 
+	ENUM2STRING(BOTH_DEATH16),			//# 
+	ENUM2STRING(BOTH_DEATH17),			//# 
+	ENUM2STRING(BOTH_DEATH18),			//# 
+	ENUM2STRING(BOTH_DEATH19),			//# 
+	ENUM2STRING(BOTH_DEATH20),			//# 
+	ENUM2STRING(BOTH_DEATH21),			//# 
+	ENUM2STRING(BOTH_DEATH22),			//# 
+	ENUM2STRING(BOTH_DEATH23),			//# 
+	ENUM2STRING(BOTH_DEATH24),			//# 
+	ENUM2STRING(BOTH_DEATH25),			//# 
+
+	ENUM2STRING(BOTH_DEATHFORWARD1),		//# First Death in which they get thrown forward
+	ENUM2STRING(BOTH_DEATHFORWARD2),		//# Second Death in which they get thrown forward
+	ENUM2STRING(BOTH_DEATHFORWARD3),		//# Tavion's falling in cin# 23
+	ENUM2STRING(BOTH_DEATHBACKWARD1),	//# First Death in which they get thrown backward
+	ENUM2STRING(BOTH_DEATHBACKWARD2),	//# Second Death in which they get thrown backward
+
+	ENUM2STRING(BOTH_DEATH1IDLE),		//# Idle while close to death
+	ENUM2STRING(BOTH_LYINGDEATH1),		//# Death to play when killed lying down
+	ENUM2STRING(BOTH_STUMBLEDEATH1),		//# Stumble forward and fall face first death
+	ENUM2STRING(BOTH_FALLDEATH1),		//# Fall forward off a high cliff and splat death - start
+	ENUM2STRING(BOTH_FALLDEATH1INAIR),	//# Fall forward off a high cliff and splat death - loop
+	ENUM2STRING(BOTH_FALLDEATH1LAND),	//# Fall forward off a high cliff and splat death - hit bottom
+	ENUM2STRING(BOTH_DEATH_ROLL),		//# Death anim from a roll
+	ENUM2STRING(BOTH_DEATH_FLIP),		//# Death anim from a flip
+	ENUM2STRING(BOTH_DEATH_SPIN_90_R),	//# Death anim when facing 90 degrees right
+	ENUM2STRING(BOTH_DEATH_SPIN_90_L),	//# Death anim when facing 90 degrees left
+	ENUM2STRING(BOTH_DEATH_SPIN_180),	//# Death anim when facing backwards
+	ENUM2STRING(BOTH_DEATH_LYING_UP),	//# Death anim when lying on back
+	ENUM2STRING(BOTH_DEATH_LYING_DN),	//# Death anim when lying on front
+	ENUM2STRING(BOTH_DEATH_FALLING_DN),	//# Death anim when falling on face
+	ENUM2STRING(BOTH_DEATH_FALLING_UP),	//# Death anim when falling on back
+	ENUM2STRING(BOTH_DEATH_CROUCHED),	//# Death anim when crouched
+	//# #sep ENUM2STRING(BOTH_ DEAD POSES # Should be last frame of corresponding previous anims
+	ENUM2STRING(BOTH_DEAD1),				//# First Death finished pose
+	ENUM2STRING(BOTH_DEAD2),				//# Second Death finished pose
+	ENUM2STRING(BOTH_DEAD3),				//# Third Death finished pose
+	ENUM2STRING(BOTH_DEAD4),				//# Fourth Death finished pose
+	ENUM2STRING(BOTH_DEAD5),				//# Fifth Death finished pose
+	ENUM2STRING(BOTH_DEAD6),				//# Sixth Death finished pose
+	ENUM2STRING(BOTH_DEAD7),				//# Seventh Death finished pose
+	ENUM2STRING(BOTH_DEAD8),				//# 
+	ENUM2STRING(BOTH_DEAD9),				//# 
+	ENUM2STRING(BOTH_DEAD10),			//# 
+	ENUM2STRING(BOTH_DEAD11),			//#
+	ENUM2STRING(BOTH_DEAD12),			//# 
+	ENUM2STRING(BOTH_DEAD13),			//# 
+	ENUM2STRING(BOTH_DEAD14),			//# 
+	ENUM2STRING(BOTH_DEAD15),			//# 
+	ENUM2STRING(BOTH_DEAD16),			//# 
+	ENUM2STRING(BOTH_DEAD17),			//# 
+	ENUM2STRING(BOTH_DEAD18),			//# 
+	ENUM2STRING(BOTH_DEAD19),			//# 
+	ENUM2STRING(BOTH_DEAD20),			//# 
+	ENUM2STRING(BOTH_DEAD21),			//# 
+	ENUM2STRING(BOTH_DEAD22),			//# 
+	ENUM2STRING(BOTH_DEAD23),			//# 
+	ENUM2STRING(BOTH_DEAD24),			//# 
+	ENUM2STRING(BOTH_DEAD25),			//# 
+	ENUM2STRING(BOTH_DEADFORWARD1),		//# First thrown forward death finished pose
+	ENUM2STRING(BOTH_DEADFORWARD2),		//# Second thrown forward death finished pose
+	ENUM2STRING(BOTH_DEADBACKWARD1),		//# First thrown backward death finished pose
+	ENUM2STRING(BOTH_DEADBACKWARD2),		//# Second thrown backward death finished pose
+	ENUM2STRING(BOTH_LYINGDEAD1),		//# Killed lying down death finished pose
+	ENUM2STRING(BOTH_STUMBLEDEAD1),		//# Stumble forward death finished pose
+	ENUM2STRING(BOTH_FALLDEAD1LAND),		//# Fall forward and splat death finished pose
+	//# #sep ENUM2STRING(BOTH_ DEAD TWITCH/FLOP # React to being shot from death poses
+	ENUM2STRING(BOTH_DEADFLOP1),		//# React to being shot from First Death finished pose
+	ENUM2STRING(BOTH_DEADFLOP2),		//# React to being shot from Second Death finished pose
+	ENUM2STRING(BOTH_DISMEMBER_HEAD1),	//#
+	ENUM2STRING(BOTH_DISMEMBER_TORSO1),	//#
+	ENUM2STRING(BOTH_DISMEMBER_LLEG),	//#
+	ENUM2STRING(BOTH_DISMEMBER_RLEG),	//#
+	ENUM2STRING(BOTH_DISMEMBER_RARM),	//#
+	ENUM2STRING(BOTH_DISMEMBER_LARM),	//#
+	//# #sep ENUM2STRING(BOTH_ PAINS
+	ENUM2STRING(BOTH_PAIN1),				//# First take pain anim
+	ENUM2STRING(BOTH_PAIN2),				//# Second take pain anim
+	ENUM2STRING(BOTH_PAIN3),				//# Third take pain anim
+	ENUM2STRING(BOTH_PAIN4),				//# Fourth take pain anim
+	ENUM2STRING(BOTH_PAIN5),				//# Fifth take pain anim - from behind
+	ENUM2STRING(BOTH_PAIN6),				//# Sixth take pain anim - from behind
+	ENUM2STRING(BOTH_PAIN7),				//# Seventh take pain anim - from behind
+	ENUM2STRING(BOTH_PAIN8),				//# Eigth take pain anim - from behind
+	ENUM2STRING(BOTH_PAIN9),				//# 
+	ENUM2STRING(BOTH_PAIN10),			//# 
+	ENUM2STRING(BOTH_PAIN11),			//# 
+	ENUM2STRING(BOTH_PAIN12),			//# 
+	ENUM2STRING(BOTH_PAIN13),			//# 
+	ENUM2STRING(BOTH_PAIN14),			//# 
+	ENUM2STRING(BOTH_PAIN15),			//# 
+	ENUM2STRING(BOTH_PAIN16),			//# 
+	ENUM2STRING(BOTH_PAIN17),			//# 
+	ENUM2STRING(BOTH_PAIN18),			//# 
+
+	//# #sep ENUM2STRING(BOTH_ ATTACKS
+	ENUM2STRING(BOTH_ATTACK1),			//# Attack with stun baton
+	ENUM2STRING(BOTH_ATTACK2),			//# Attack with one-handed pistol
+	ENUM2STRING(BOTH_ATTACK3),			//# Attack with blaster rifle
+	ENUM2STRING(BOTH_ATTACK4),			//# Attack with disruptor
+	ENUM2STRING(BOTH_ATTACK5),			//# Another Rancor Attack
+	ENUM2STRING(BOTH_ATTACK6),			//# Yet Another Rancor Attack
+	ENUM2STRING(BOTH_ATTACK7),			//# Yet Another Rancor Attack
+	ENUM2STRING(BOTH_ATTACK10),			//# Attack with thermal det
+	ENUM2STRING(BOTH_ATTACK11),			//# "Attack" with tripmine and detpack
+	ENUM2STRING(BOTH_MELEE1),			//# First melee attack
+	ENUM2STRING(BOTH_MELEE2),			//# Second melee attack
+	ENUM2STRING(BOTH_THERMAL_READY),	//# pull back with thermal
+	ENUM2STRING(BOTH_THERMAL_THROW),	//# throw thermal
+	//* #sep ENUM2STRING(BOTH_ SABER ANIMS
+	//Saber attack anims - power level 1
+	ENUM2STRING(BOTH_A1_T__B_),	//# Fast weak vertical attack top to bottom
+	ENUM2STRING(BOTH_A1__L__R),	//# Fast weak horizontal attack left to right
+	ENUM2STRING(BOTH_A1__R__L),	//# Fast weak horizontal attack right to left
+	ENUM2STRING(BOTH_A1_TL_BR),	//# Fast weak diagonal attack top left to botom right
+	ENUM2STRING(BOTH_A1_BR_TL),	//# Fast weak diagonal attack top left to botom right
+	ENUM2STRING(BOTH_A1_BL_TR),	//# Fast weak diagonal attack bottom left to top right
+	ENUM2STRING(BOTH_A1_TR_BL),	//# Fast weak diagonal attack bottom left to right
+	//Saber Arc and Spin Transitions
+	ENUM2STRING(BOTH_T1_BR__R),	//# Fast arc bottom right to right
+	ENUM2STRING(BOTH_T1_BR_TL),	//# Fast weak spin bottom right to top left
+	ENUM2STRING(BOTH_T1_BR__L),	//# Fast weak spin bottom right to left
+	ENUM2STRING(BOTH_T1_BR_BL),	//# Fast weak spin bottom right to bottom left
+	ENUM2STRING(BOTH_T1__R_TR),	//# Fast arc right to top right
+	ENUM2STRING(BOTH_T1__R_TL),	//# Fast arc right to top left
+	ENUM2STRING(BOTH_T1__R__L),	//# Fast weak spin right to left
+	ENUM2STRING(BOTH_T1__R_BL),	//# Fast weak spin right to bottom left
+	ENUM2STRING(BOTH_T1_TR_BR),	//# Fast arc top right to bottom right
+	ENUM2STRING(BOTH_T1_TR_TL),	//# Fast arc top right to top left
+	ENUM2STRING(BOTH_T1_TR__L),	//# Fast arc top right to left
+	ENUM2STRING(BOTH_T1_TR_BL),	//# Fast weak spin top right to bottom left
+	ENUM2STRING(BOTH_T1_T__BR),	//# Fast arc top to bottom right
+	ENUM2STRING(BOTH_T1_T___R),	//# Fast arc top to right
+	ENUM2STRING(BOTH_T1_T__TR),	//# Fast arc top to top right
+	ENUM2STRING(BOTH_T1_T__TL),	//# Fast arc top to top left
+	ENUM2STRING(BOTH_T1_T___L),	//# Fast arc top to left
+	ENUM2STRING(BOTH_T1_T__BL),	//# Fast arc top to bottom left
+	ENUM2STRING(BOTH_T1_TL_BR),	//# Fast weak spin top left to bottom right
+	ENUM2STRING(BOTH_T1_TL_BL),	//# Fast arc top left to bottom left
+	ENUM2STRING(BOTH_T1__L_BR),	//# Fast weak spin left to bottom right
+	ENUM2STRING(BOTH_T1__L__R),	//# Fast weak spin left to right
+	ENUM2STRING(BOTH_T1__L_TL),	//# Fast arc left to top left
+	ENUM2STRING(BOTH_T1_BL_BR),	//# Fast weak spin bottom left to bottom right
+	ENUM2STRING(BOTH_T1_BL__R),	//# Fast weak spin bottom left to right
+	ENUM2STRING(BOTH_T1_BL_TR),	//# Fast weak spin bottom left to top right
+	ENUM2STRING(BOTH_T1_BL__L),	//# Fast arc bottom left to left
+	//Saber Arc Transitions that use existing animations played backwards
+	ENUM2STRING(BOTH_T1_BR_TR),	//# Fast arc bottom right to top right		(use: ENUM2STRING(BOTH_T1_TR_BR)
+	ENUM2STRING(BOTH_T1_BR_T_),	//# Fast arc bottom right to top			(use: ENUM2STRING(BOTH_T1_T__BR)
+	ENUM2STRING(BOTH_T1__R_BR),	//# Fast arc right to bottom right			(use: ENUM2STRING(BOTH_T1_BR__R)
+	ENUM2STRING(BOTH_T1__R_T_),	//# Fast ar right to top				(use: ENUM2STRING(BOTH_T1_T___R)
+	ENUM2STRING(BOTH_T1_TR__R),	//# Fast arc top right to right			(use: ENUM2STRING(BOTH_T1__R_TR)
+	ENUM2STRING(BOTH_T1_TR_T_),	//# Fast arc top right to top				(use: ENUM2STRING(BOTH_T1_T__TR)
+	ENUM2STRING(BOTH_T1_TL__R),	//# Fast arc top left to right			(use: ENUM2STRING(BOTH_T1__R_TL)
+	ENUM2STRING(BOTH_T1_TL_TR),	//# Fast arc top left to top right			(use: ENUM2STRING(BOTH_T1_TR_TL)
+	ENUM2STRING(BOTH_T1_TL_T_),	//# Fast arc top left to top				(use: ENUM2STRING(BOTH_T1_T__TL)
+	ENUM2STRING(BOTH_T1_TL__L),	//# Fast arc top left to left				(use: ENUM2STRING(BOTH_T1__L_TL)
+	ENUM2STRING(BOTH_T1__L_TR),	//# Fast arc left to top right			(use: ENUM2STRING(BOTH_T1_TR__L)
+	ENUM2STRING(BOTH_T1__L_T_),	//# Fast arc left to top				(use: ENUM2STRING(BOTH_T1_T___L)
+	ENUM2STRING(BOTH_T1__L_BL),	//# Fast arc left to bottom left			(use: ENUM2STRING(BOTH_T1_BL__L)
+	ENUM2STRING(BOTH_T1_BL_T_),	//# Fast arc bottom left to top			(use: ENUM2STRING(BOTH_T1_T__BL)
+	ENUM2STRING(BOTH_T1_BL_TL),	//# Fast arc bottom left to top left		(use: ENUM2STRING(BOTH_T1_TL_BL)
+	//Saber Attack Start Transitions
+	ENUM2STRING(BOTH_S1_S1_T_),	//# Fast plain transition from stance1 to top-to-bottom Fast weak attack
+	ENUM2STRING(BOTH_S1_S1__L),	//# Fast plain transition from stance1 to left-to-right Fast weak attack
+	ENUM2STRING(BOTH_S1_S1__R),	//# Fast plain transition from stance1 to right-to-left Fast weak attack
+	ENUM2STRING(BOTH_S1_S1_TL),	//# Fast plain transition from stance1 to top-left-to-bottom-right Fast weak attack
+	ENUM2STRING(BOTH_S1_S1_BR),	//# Fast plain transition from stance1 to bottom-right-to-top-left Fast weak attack
+	ENUM2STRING(BOTH_S1_S1_BL),	//# Fast plain transition from stance1 to bottom-left-to-top-right Fast weak attack
+	ENUM2STRING(BOTH_S1_S1_TR),	//# Fast plain transition from stance1 to top-right-to-bottom-left Fast weak attack
+	//Saber Attack Return Transitions
+	ENUM2STRING(BOTH_R1_B__S1),	//# Fast plain transition from top-to-bottom Fast weak attack to stance1
+	ENUM2STRING(BOTH_R1__L_S1),	//# Fast plain transition from left-to-right Fast weak attack to stance1
+	ENUM2STRING(BOTH_R1__R_S1),	//# Fast plain transition from right-to-left Fast weak attack to stance1
+	ENUM2STRING(BOTH_R1_TL_S1),	//# Fast plain transition from top-left-to-bottom-right Fast weak attack to stance1
+	ENUM2STRING(BOTH_R1_BR_S1),	//# Fast plain transition from bottom-right-to-top-left Fast weak attack to stance1
+	ENUM2STRING(BOTH_R1_BL_S1),	//# Fast plain transition from bottom-left-to-top-right Fast weak attack to stance1
+	ENUM2STRING(BOTH_R1_TR_S1),	//# Fast plain transition from top-right-to-bottom-left Fast weak attack
+	//Saber Attack Bounces (first 4 frames of an attack), played backwards)
+	ENUM2STRING(BOTH_B1_BR___),	//# Bounce-back if attack from BR is blocked
+	ENUM2STRING(BOTH_B1__R___),	//# Bounce-back if attack from R is blocked
+	ENUM2STRING(BOTH_B1_TR___),	//# Bounce-back if attack from TR is blocked
+	ENUM2STRING(BOTH_B1_T____),	//# Bounce-back if attack from T is blocked
+	ENUM2STRING(BOTH_B1_TL___),	//# Bounce-back if attack from TL is blocked
+	ENUM2STRING(BOTH_B1__L___),	//# Bounce-back if attack from L is blocked
+	ENUM2STRING(BOTH_B1_BL___),	//# Bounce-back if attack from BL is blocked
+	//Saber Attack Deflections (last 4 frames of an attack)
+	ENUM2STRING(BOTH_D1_BR___),	//# Deflection toward BR
+	ENUM2STRING(BOTH_D1__R___),	//# Deflection toward R
+	ENUM2STRING(BOTH_D1_TR___),	//# Deflection toward TR
+	ENUM2STRING(BOTH_D1_TL___),	//# Deflection toward TL
+	ENUM2STRING(BOTH_D1__L___),	//# Deflection toward L
+	ENUM2STRING(BOTH_D1_BL___),	//# Deflection toward BL
+	ENUM2STRING(BOTH_D1_B____),	//# Deflection toward B
+	//Saber attack anims - power level 2
+	ENUM2STRING(BOTH_A2_T__B_),	//# Fast weak vertical attack top to bottom
+	ENUM2STRING(BOTH_A2__L__R),	//# Fast weak horizontal attack left to right
+	ENUM2STRING(BOTH_A2__R__L),	//# Fast weak horizontal attack right to left
+	ENUM2STRING(BOTH_A2_TL_BR),	//# Fast weak diagonal attack top left to botom right
+	ENUM2STRING(BOTH_A2_BR_TL),	//# Fast weak diagonal attack top left to botom right
+	ENUM2STRING(BOTH_A2_BL_TR),	//# Fast weak diagonal attack bottom left to top right
+	ENUM2STRING(BOTH_A2_TR_BL),	//# Fast weak diagonal attack bottom left to right
+	//Saber Arc and Spin Transitions
+	ENUM2STRING(BOTH_T2_BR__R),	//# Fast arc bottom right to right
+	ENUM2STRING(BOTH_T2_BR_TL),	//# Fast weak spin bottom right to top left
+	ENUM2STRING(BOTH_T2_BR__L),	//# Fast weak spin bottom right to left
+	ENUM2STRING(BOTH_T2_BR_BL),	//# Fast weak spin bottom right to bottom left
+	ENUM2STRING(BOTH_T2__R_TR),	//# Fast arc right to top right
+	ENUM2STRING(BOTH_T2__R_TL),	//# Fast arc right to top left
+	ENUM2STRING(BOTH_T2__R__L),	//# Fast weak spin right to left
+	ENUM2STRING(BOTH_T2__R_BL),	//# Fast weak spin right to bottom left
+	ENUM2STRING(BOTH_T2_TR_BR),	//# Fast arc top right to bottom right
+	ENUM2STRING(BOTH_T2_TR_TL),	//# Fast arc top right to top left
+	ENUM2STRING(BOTH_T2_TR__L),	//# Fast arc top right to left
+	ENUM2STRING(BOTH_T2_TR_BL),	//# Fast weak spin top right to bottom left
+	ENUM2STRING(BOTH_T2_T__BR),	//# Fast arc top to bottom right
+	ENUM2STRING(BOTH_T2_T___R),	//# Fast arc top to right
+	ENUM2STRING(BOTH_T2_T__TR),	//# Fast arc top to top right
+	ENUM2STRING(BOTH_T2_T__TL),	//# Fast arc top to top left
+	ENUM2STRING(BOTH_T2_T___L),	//# Fast arc top to left
+	ENUM2STRING(BOTH_T2_T__BL),	//# Fast arc top to bottom left
+	ENUM2STRING(BOTH_T2_TL_BR),	//# Fast weak spin top left to bottom right
+	ENUM2STRING(BOTH_T2_TL_BL),	//# Fast arc top left to bottom left
+	ENUM2STRING(BOTH_T2__L_BR),	//# Fast weak spin left to bottom right
+	ENUM2STRING(BOTH_T2__L__R),	//# Fast weak spin left to right
+	ENUM2STRING(BOTH_T2__L_TL),	//# Fast arc left to top left
+	ENUM2STRING(BOTH_T2_BL_BR),	//# Fast weak spin bottom left to bottom right
+	ENUM2STRING(BOTH_T2_BL__R),	//# Fast weak spin bottom left to right
+	ENUM2STRING(BOTH_T2_BL_TR),	//# Fast weak spin bottom left to top right
+	ENUM2STRING(BOTH_T2_BL__L),	//# Fast arc bottom left to left
+	//Saber Arc Transitions that use existing animations played backwards
+	ENUM2STRING(BOTH_T2_BR_TR),	//# Fast arc bottom right to top right		(use: ENUM2STRING(BOTH_T2_TR_BR)
+	ENUM2STRING(BOTH_T2_BR_T_),	//# Fast arc bottom right to top			(use: ENUM2STRING(BOTH_T2_T__BR)
+	ENUM2STRING(BOTH_T2__R_BR),	//# Fast arc right to bottom right			(use: ENUM2STRING(BOTH_T2_BR__R)
+	ENUM2STRING(BOTH_T2__R_T_),	//# Fast ar right to top				(use: ENUM2STRING(BOTH_T2_T___R)
+	ENUM2STRING(BOTH_T2_TR__R),	//# Fast arc top right to right			(use: ENUM2STRING(BOTH_T2__R_TR)
+	ENUM2STRING(BOTH_T2_TR_T_),	//# Fast arc top right to top				(use: ENUM2STRING(BOTH_T2_T__TR)
+	ENUM2STRING(BOTH_T2_TL__R),	//# Fast arc top left to right			(use: ENUM2STRING(BOTH_T2__R_TL)
+	ENUM2STRING(BOTH_T2_TL_TR),	//# Fast arc top left to top right			(use: ENUM2STRING(BOTH_T2_TR_TL)
+	ENUM2STRING(BOTH_T2_TL_T_),	//# Fast arc top left to top				(use: ENUM2STRING(BOTH_T2_T__TL)
+	ENUM2STRING(BOTH_T2_TL__L),	//# Fast arc top left to left				(use: ENUM2STRING(BOTH_T2__L_TL)
+	ENUM2STRING(BOTH_T2__L_TR),	//# Fast arc left to top right			(use: ENUM2STRING(BOTH_T2_TR__L)
+	ENUM2STRING(BOTH_T2__L_T_),	//# Fast arc left to top				(use: ENUM2STRING(BOTH_T2_T___L)
+	ENUM2STRING(BOTH_T2__L_BL),	//# Fast arc left to bottom left			(use: ENUM2STRING(BOTH_T2_BL__L)
+	ENUM2STRING(BOTH_T2_BL_T_),	//# Fast arc bottom left to top			(use: ENUM2STRING(BOTH_T2_T__BL)
+	ENUM2STRING(BOTH_T2_BL_TL),	//# Fast arc bottom left to top left		(use: ENUM2STRING(BOTH_T2_TL_BL)
+	//Saber Attack Start Transitions
+	ENUM2STRING(BOTH_S2_S1_T_),	//# Fast plain transition from stance1 to top-to-bottom Fast weak attack
+	ENUM2STRING(BOTH_S2_S1__L),	//# Fast plain transition from stance1 to left-to-right Fast weak attack
+	ENUM2STRING(BOTH_S2_S1__R),	//# Fast plain transition from stance1 to right-to-left Fast weak attack
+	ENUM2STRING(BOTH_S2_S1_TL),	//# Fast plain transition from stance1 to top-left-to-bottom-right Fast weak attack
+	ENUM2STRING(BOTH_S2_S1_BR),	//# Fast plain transition from stance1 to bottom-right-to-top-left Fast weak attack
+	ENUM2STRING(BOTH_S2_S1_BL),	//# Fast plain transition from stance1 to bottom-left-to-top-right Fast weak attack
+	ENUM2STRING(BOTH_S2_S1_TR),	//# Fast plain transition from stance1 to top-right-to-bottom-left Fast weak attack
+	//Saber Attack Return Transitions
+	ENUM2STRING(BOTH_R2_B__S1),	//# Fast plain transition from top-to-bottom Fast weak attack to stance1
+	ENUM2STRING(BOTH_R2__L_S1),	//# Fast plain transition from left-to-right Fast weak attack to stance1
+	ENUM2STRING(BOTH_R2__R_S1),	//# Fast plain transition from right-to-left Fast weak attack to stance1
+	ENUM2STRING(BOTH_R2_TL_S1),	//# Fast plain transition from top-left-to-bottom-right Fast weak attack to stance1
+	ENUM2STRING(BOTH_R2_BR_S1),	//# Fast plain transition from bottom-right-to-top-left Fast weak attack to stance1
+	ENUM2STRING(BOTH_R2_BL_S1),	//# Fast plain transition from bottom-left-to-top-right Fast weak attack to stance1
+	ENUM2STRING(BOTH_R2_TR_S1),	//# Fast plain transition from top-right-to-bottom-left Fast weak attack
+	//Saber Attack Bounces (first 4 frames of an attack), played backwards)
+	ENUM2STRING(BOTH_B2_BR___),	//# Bounce-back if attack from BR is blocked
+	ENUM2STRING(BOTH_B2__R___),	//# Bounce-back if attack from R is blocked
+	ENUM2STRING(BOTH_B2_TR___),	//# Bounce-back if attack from TR is blocked
+	ENUM2STRING(BOTH_B2_T____),	//# Bounce-back if attack from T is blocked
+	ENUM2STRING(BOTH_B2_TL___),	//# Bounce-back if attack from TL is blocked
+	ENUM2STRING(BOTH_B2__L___),	//# Bounce-back if attack from L is blocked
+	ENUM2STRING(BOTH_B2_BL___),	//# Bounce-back if attack from BL is blocked
+	//Saber Attack Deflections (last 4 frames of an attack)
+	ENUM2STRING(BOTH_D2_BR___),	//# Deflection toward BR
+	ENUM2STRING(BOTH_D2__R___),	//# Deflection toward R
+	ENUM2STRING(BOTH_D2_TR___),	//# Deflection toward TR
+	ENUM2STRING(BOTH_D2_TL___),	//# Deflection toward TL
+	ENUM2STRING(BOTH_D2__L___),	//# Deflection toward L
+	ENUM2STRING(BOTH_D2_BL___),	//# Deflection toward BL
+	ENUM2STRING(BOTH_D2_B____),	//# Deflection toward B
+	//Saber attack anims - power level 3
+	ENUM2STRING(BOTH_A3_T__B_),	//# Fast weak vertical attack top to bottom
+	ENUM2STRING(BOTH_A3__L__R),	//# Fast weak horizontal attack left to right
+	ENUM2STRING(BOTH_A3__R__L),	//# Fast weak horizontal attack right to left
+	ENUM2STRING(BOTH_A3_TL_BR),	//# Fast weak diagonal attack top left to botom right
+	ENUM2STRING(BOTH_A3_BR_TL),	//# Fast weak diagonal attack top left to botom right
+	ENUM2STRING(BOTH_A3_BL_TR),	//# Fast weak diagonal attack bottom left to top right
+	ENUM2STRING(BOTH_A3_TR_BL),	//# Fast weak diagonal attack bottom left to right
+	//Saber Arc and Spin Transitions
+	ENUM2STRING(BOTH_T3_BR__R),	//# Fast arc bottom right to right
+	ENUM2STRING(BOTH_T3_BR_TL),	//# Fast weak spin bottom right to top left
+	ENUM2STRING(BOTH_T3_BR__L),	//# Fast weak spin bottom right to left
+	ENUM2STRING(BOTH_T3_BR_BL),	//# Fast weak spin bottom right to bottom left
+	ENUM2STRING(BOTH_T3__R_TR),	//# Fast arc right to top right
+	ENUM2STRING(BOTH_T3__R_TL),	//# Fast arc right to top left
+	ENUM2STRING(BOTH_T3__R__L),	//# Fast weak spin right to left
+	ENUM2STRING(BOTH_T3__R_BL),	//# Fast weak spin right to bottom left
+	ENUM2STRING(BOTH_T3_TR_BR),	//# Fast arc top right to bottom right
+	ENUM2STRING(BOTH_T3_TR_TL),	//# Fast arc top right to top left
+	ENUM2STRING(BOTH_T3_TR__L),	//# Fast arc top right to left
+	ENUM2STRING(BOTH_T3_TR_BL),	//# Fast weak spin top right to bottom left
+	ENUM2STRING(BOTH_T3_T__BR),	//# Fast arc top to bottom right
+	ENUM2STRING(BOTH_T3_T___R),	//# Fast arc top to right
+	ENUM2STRING(BOTH_T3_T__TR),	//# Fast arc top to top right
+	ENUM2STRING(BOTH_T3_T__TL),	//# Fast arc top to top left
+	ENUM2STRING(BOTH_T3_T___L),	//# Fast arc top to left
+	ENUM2STRING(BOTH_T3_T__BL),	//# Fast arc top to bottom left
+	ENUM2STRING(BOTH_T3_TL_BR),	//# Fast weak spin top left to bottom right
+	ENUM2STRING(BOTH_T3_TL_BL),	//# Fast arc top left to bottom left
+	ENUM2STRING(BOTH_T3__L_BR),	//# Fast weak spin left to bottom right
+	ENUM2STRING(BOTH_T3__L__R),	//# Fast weak spin left to right
+	ENUM2STRING(BOTH_T3__L_TL),	//# Fast arc left to top left
+	ENUM2STRING(BOTH_T3_BL_BR),	//# Fast weak spin bottom left to bottom right
+	ENUM2STRING(BOTH_T3_BL__R),	//# Fast weak spin bottom left to right
+	ENUM2STRING(BOTH_T3_BL_TR),	//# Fast weak spin bottom left to top right
+	ENUM2STRING(BOTH_T3_BL__L),	//# Fast arc bottom left to left
+	//Saber Arc Transitions that use existing animations played backwards
+	ENUM2STRING(BOTH_T3_BR_TR),	//# Fast arc bottom right to top right		(use: ENUM2STRING(BOTH_T3_TR_BR)
+	ENUM2STRING(BOTH_T3_BR_T_),	//# Fast arc bottom right to top			(use: ENUM2STRING(BOTH_T3_T__BR)
+	ENUM2STRING(BOTH_T3__R_BR),	//# Fast arc right to bottom right			(use: ENUM2STRING(BOTH_T3_BR__R)
+	ENUM2STRING(BOTH_T3__R_T_),	//# Fast ar right to top				(use: ENUM2STRING(BOTH_T3_T___R)
+	ENUM2STRING(BOTH_T3_TR__R),	//# Fast arc top right to right			(use: ENUM2STRING(BOTH_T3__R_TR)
+	ENUM2STRING(BOTH_T3_TR_T_),	//# Fast arc top right to top				(use: ENUM2STRING(BOTH_T3_T__TR)
+	ENUM2STRING(BOTH_T3_TL__R),	//# Fast arc top left to right			(use: ENUM2STRING(BOTH_T3__R_TL)
+	ENUM2STRING(BOTH_T3_TL_TR),	//# Fast arc top left to top right			(use: ENUM2STRING(BOTH_T3_TR_TL)
+	ENUM2STRING(BOTH_T3_TL_T_),	//# Fast arc top left to top				(use: ENUM2STRING(BOTH_T3_T__TL)
+	ENUM2STRING(BOTH_T3_TL__L),	//# Fast arc top left to left				(use: ENUM2STRING(BOTH_T3__L_TL)
+	ENUM2STRING(BOTH_T3__L_TR),	//# Fast arc left to top right			(use: ENUM2STRING(BOTH_T3_TR__L)
+	ENUM2STRING(BOTH_T3__L_T_),	//# Fast arc left to top				(use: ENUM2STRING(BOTH_T3_T___L)
+	ENUM2STRING(BOTH_T3__L_BL),	//# Fast arc left to bottom left			(use: ENUM2STRING(BOTH_T3_BL__L)
+	ENUM2STRING(BOTH_T3_BL_T_),	//# Fast arc bottom left to top			(use: ENUM2STRING(BOTH_T3_T__BL)
+	ENUM2STRING(BOTH_T3_BL_TL),	//# Fast arc bottom left to top left		(use: ENUM2STRING(BOTH_T3_TL_BL)
+	//Saber Attack Start Transitions
+	ENUM2STRING(BOTH_S3_S1_T_),	//# Fast plain transition from stance1 to top-to-bottom Fast weak attack
+	ENUM2STRING(BOTH_S3_S1__L),	//# Fast plain transition from stance1 to left-to-right Fast weak attack
+	ENUM2STRING(BOTH_S3_S1__R),	//# Fast plain transition from stance1 to right-to-left Fast weak attack
+	ENUM2STRING(BOTH_S3_S1_TL),	//# Fast plain transition from stance1 to top-left-to-bottom-right Fast weak attack
+	ENUM2STRING(BOTH_S3_S1_BR),	//# Fast plain transition from stance1 to bottom-right-to-top-left Fast weak attack
+	ENUM2STRING(BOTH_S3_S1_BL),	//# Fast plain transition from stance1 to bottom-left-to-top-right Fast weak attack
+	ENUM2STRING(BOTH_S3_S1_TR),	//# Fast plain transition from stance1 to top-right-to-bottom-left Fast weak attack
+	//Saber Attack Return Transitions
+	ENUM2STRING(BOTH_R3_B__S1),	//# Fast plain transition from top-to-bottom Fast weak attack to stance1
+	ENUM2STRING(BOTH_R3__L_S1),	//# Fast plain transition from left-to-right Fast weak attack to stance1
+	ENUM2STRING(BOTH_R3__R_S1),	//# Fast plain transition from right-to-left Fast weak attack to stance1
+	ENUM2STRING(BOTH_R3_TL_S1),	//# Fast plain transition from top-left-to-bottom-right Fast weak attack to stance1
+	ENUM2STRING(BOTH_R3_BR_S1),	//# Fast plain transition from bottom-right-to-top-left Fast weak attack to stance1
+	ENUM2STRING(BOTH_R3_BL_S1),	//# Fast plain transition from bottom-left-to-top-right Fast weak attack to stance1
+	ENUM2STRING(BOTH_R3_TR_S1),	//# Fast plain transition from top-right-to-bottom-left Fast weak attack
+	//Saber Attack Bounces (first 4 frames of an attack), played backwards)
+	ENUM2STRING(BOTH_B3_BR___),	//# Bounce-back if attack from BR is blocked
+	ENUM2STRING(BOTH_B3__R___),	//# Bounce-back if attack from R is blocked
+	ENUM2STRING(BOTH_B3_TR___),	//# Bounce-back if attack from TR is blocked
+	ENUM2STRING(BOTH_B3_T____),	//# Bounce-back if attack from T is blocked
+	ENUM2STRING(BOTH_B3_TL___),	//# Bounce-back if attack from TL is blocked
+	ENUM2STRING(BOTH_B3__L___),	//# Bounce-back if attack from L is blocked
+	ENUM2STRING(BOTH_B3_BL___),	//# Bounce-back if attack from BL is blocked
+	//Saber Attack Deflections (last 4 frames of an attack)
+	ENUM2STRING(BOTH_D3_BR___),	//# Deflection toward BR
+	ENUM2STRING(BOTH_D3__R___),	//# Deflection toward R
+	ENUM2STRING(BOTH_D3_TR___),	//# Deflection toward TR
+	ENUM2STRING(BOTH_D3_TL___),	//# Deflection toward TL
+	ENUM2STRING(BOTH_D3__L___),	//# Deflection toward L
+	ENUM2STRING(BOTH_D3_BL___),	//# Deflection toward BL
+	ENUM2STRING(BOTH_D3_B____),	//# Deflection toward B
+	//Saber attack anims - power level 4 - Desann's
+	ENUM2STRING(BOTH_A4_T__B_),	//# Fast weak vertical attack top to bottom
+	ENUM2STRING(BOTH_A4__L__R),	//# Fast weak horizontal attack left to right
+	ENUM2STRING(BOTH_A4__R__L),	//# Fast weak horizontal attack right to left
+	ENUM2STRING(BOTH_A4_TL_BR),	//# Fast weak diagonal attack top left to botom right
+	ENUM2STRING(BOTH_A4_BR_TL),	//# Fast weak diagonal attack top left to botom right
+	ENUM2STRING(BOTH_A4_BL_TR),	//# Fast weak diagonal attack bottom left to top right
+	ENUM2STRING(BOTH_A4_TR_BL),	//# Fast weak diagonal attack bottom left to right
+	//Saber Arc and Spin Transitions
+	ENUM2STRING(BOTH_T4_BR__R),	//# Fast arc bottom right to right
+	ENUM2STRING(BOTH_T4_BR_TL),	//# Fast weak spin bottom right to top left
+	ENUM2STRING(BOTH_T4_BR__L),	//# Fast weak spin bottom right to left
+	ENUM2STRING(BOTH_T4_BR_BL),	//# Fast weak spin bottom right to bottom left
+	ENUM2STRING(BOTH_T4__R_TR),	//# Fast arc right to top right
+	ENUM2STRING(BOTH_T4__R_TL),	//# Fast arc right to top left
+	ENUM2STRING(BOTH_T4__R__L),	//# Fast weak spin right to left
+	ENUM2STRING(BOTH_T4__R_BL),	//# Fast weak spin right to bottom left
+	ENUM2STRING(BOTH_T4_TR_BR),	//# Fast arc top right to bottom right
+	ENUM2STRING(BOTH_T4_TR_TL),	//# Fast arc top right to top left
+	ENUM2STRING(BOTH_T4_TR__L),	//# Fast arc top right to left
+	ENUM2STRING(BOTH_T4_TR_BL),	//# Fast weak spin top right to bottom left
+	ENUM2STRING(BOTH_T4_T__BR),	//# Fast arc top to bottom right
+	ENUM2STRING(BOTH_T4_T___R),	//# Fast arc top to right
+	ENUM2STRING(BOTH_T4_T__TR),	//# Fast arc top to top right
+	ENUM2STRING(BOTH_T4_T__TL),	//# Fast arc top to top left
+	ENUM2STRING(BOTH_T4_T___L),	//# Fast arc top to left
+	ENUM2STRING(BOTH_T4_T__BL),	//# Fast arc top to bottom left
+	ENUM2STRING(BOTH_T4_TL_BR),	//# Fast weak spin top left to bottom right
+	ENUM2STRING(BOTH_T4_TL_BL),	//# Fast arc top left to bottom left
+	ENUM2STRING(BOTH_T4__L_BR),	//# Fast weak spin left to bottom right
+	ENUM2STRING(BOTH_T4__L__R),	//# Fast weak spin left to right
+	ENUM2STRING(BOTH_T4__L_TL),	//# Fast arc left to top left
+	ENUM2STRING(BOTH_T4_BL_BR),	//# Fast weak spin bottom left to bottom right
+	ENUM2STRING(BOTH_T4_BL__R),	//# Fast weak spin bottom left to right
+	ENUM2STRING(BOTH_T4_BL_TR),	//# Fast weak spin bottom left to top right
+	ENUM2STRING(BOTH_T4_BL__L),	//# Fast arc bottom left to left
+	//Saber Arc Transitions that use existing animations played backwards
+	ENUM2STRING(BOTH_T4_BR_TR),	//# Fast arc bottom right to top right		(use: ENUM2STRING(BOTH_T4_TR_BR)
+	ENUM2STRING(BOTH_T4_BR_T_),	//# Fast arc bottom right to top			(use: ENUM2STRING(BOTH_T4_T__BR)
+	ENUM2STRING(BOTH_T4__R_BR),	//# Fast arc right to bottom right			(use: ENUM2STRING(BOTH_T4_BR__R)
+	ENUM2STRING(BOTH_T4__R_T_),	//# Fast ar right to top				(use: ENUM2STRING(BOTH_T4_T___R)
+	ENUM2STRING(BOTH_T4_TR__R),	//# Fast arc top right to right			(use: ENUM2STRING(BOTH_T4__R_TR)
+	ENUM2STRING(BOTH_T4_TR_T_),	//# Fast arc top right to top				(use: ENUM2STRING(BOTH_T4_T__TR)
+	ENUM2STRING(BOTH_T4_TL__R),	//# Fast arc top left to right			(use: ENUM2STRING(BOTH_T4__R_TL)
+	ENUM2STRING(BOTH_T4_TL_TR),	//# Fast arc top left to top right			(use: ENUM2STRING(BOTH_T4_TR_TL)
+	ENUM2STRING(BOTH_T4_TL_T_),	//# Fast arc top left to top				(use: ENUM2STRING(BOTH_T4_T__TL)
+	ENUM2STRING(BOTH_T4_TL__L),	//# Fast arc top left to left				(use: ENUM2STRING(BOTH_T4__L_TL)
+	ENUM2STRING(BOTH_T4__L_TR),	//# Fast arc left to top right			(use: ENUM2STRING(BOTH_T4_TR__L)
+	ENUM2STRING(BOTH_T4__L_T_),	//# Fast arc left to top				(use: ENUM2STRING(BOTH_T4_T___L)
+	ENUM2STRING(BOTH_T4__L_BL),	//# Fast arc left to bottom left			(use: ENUM2STRING(BOTH_T4_BL__L)
+	ENUM2STRING(BOTH_T4_BL_T_),	//# Fast arc bottom left to top			(use: ENUM2STRING(BOTH_T4_T__BL)
+	ENUM2STRING(BOTH_T4_BL_TL),	//# Fast arc bottom left to top left		(use: ENUM2STRING(BOTH_T4_TL_BL)
+	//Saber Attack Start Transitions
+	ENUM2STRING(BOTH_S4_S1_T_),	//# Fast plain transition from stance1 to top-to-bottom Fast weak attack
+	ENUM2STRING(BOTH_S4_S1__L),	//# Fast plain transition from stance1 to left-to-right Fast weak attack
+	ENUM2STRING(BOTH_S4_S1__R),	//# Fast plain transition from stance1 to right-to-left Fast weak attack
+	ENUM2STRING(BOTH_S4_S1_TL),	//# Fast plain transition from stance1 to top-left-to-bottom-right Fast weak attack
+	ENUM2STRING(BOTH_S4_S1_BR),	//# Fast plain transition from stance1 to bottom-right-to-top-left Fast weak attack
+	ENUM2STRING(BOTH_S4_S1_BL),	//# Fast plain transition from stance1 to bottom-left-to-top-right Fast weak attack
+	ENUM2STRING(BOTH_S4_S1_TR),	//# Fast plain transition from stance1 to top-right-to-bottom-left Fast weak attack
+	//Saber Attack Return Transitions
+	ENUM2STRING(BOTH_R4_B__S1),	//# Fast plain transition from top-to-bottom Fast weak attack to stance1
+	ENUM2STRING(BOTH_R4__L_S1),	//# Fast plain transition from left-to-right Fast weak attack to stance1
+	ENUM2STRING(BOTH_R4__R_S1),	//# Fast plain transition from right-to-left Fast weak attack to stance1
+	ENUM2STRING(BOTH_R4_TL_S1),	//# Fast plain transition from top-left-to-bottom-right Fast weak attack to stance1
+	ENUM2STRING(BOTH_R4_BR_S1),	//# Fast plain transition from bottom-right-to-top-left Fast weak attack to stance1
+	ENUM2STRING(BOTH_R4_BL_S1),	//# Fast plain transition from bottom-left-to-top-right Fast weak attack to stance1
+	ENUM2STRING(BOTH_R4_TR_S1),	//# Fast plain transition from top-right-to-bottom-left Fast weak attack
+	//Saber Attack Bounces (first 4 frames of an attack), played backwards)
+	ENUM2STRING(BOTH_B4_BR___),	//# Bounce-back if attack from BR is blocked
+	ENUM2STRING(BOTH_B4__R___),	//# Bounce-back if attack from R is blocked
+	ENUM2STRING(BOTH_B4_TR___),	//# Bounce-back if attack from TR is blocked
+	ENUM2STRING(BOTH_B4_T____),	//# Bounce-back if attack from T is blocked
+	ENUM2STRING(BOTH_B4_TL___),	//# Bounce-back if attack from TL is blocked
+	ENUM2STRING(BOTH_B4__L___),	//# Bounce-back if attack from L is blocked
+	ENUM2STRING(BOTH_B4_BL___),	//# Bounce-back if attack from BL is blocked
+	//Saber Attack Deflections (last 4 frames of an attack)
+	ENUM2STRING(BOTH_D4_BR___),	//# Deflection toward BR
+	ENUM2STRING(BOTH_D4__R___),	//# Deflection toward R
+	ENUM2STRING(BOTH_D4_TR___),	//# Deflection toward TR
+	ENUM2STRING(BOTH_D4_TL___),	//# Deflection toward TL
+	ENUM2STRING(BOTH_D4__L___),	//# Deflection toward L
+	ENUM2STRING(BOTH_D4_BL___),	//# Deflection toward BL
+	ENUM2STRING(BOTH_D4_B____),	//# Deflection toward B
+	//Saber attack anims - power level 5 - Tavion's
+	ENUM2STRING(BOTH_A5_T__B_),	//# Fast weak vertical attack top to bottom
+	ENUM2STRING(BOTH_A5__L__R),	//# Fast weak horizontal attack left to right
+	ENUM2STRING(BOTH_A5__R__L),	//# Fast weak horizontal attack right to left
+	ENUM2STRING(BOTH_A5_TL_BR),	//# Fast weak diagonal attack top left to botom right
+	ENUM2STRING(BOTH_A5_BR_TL),	//# Fast weak diagonal attack top left to botom right
+	ENUM2STRING(BOTH_A5_BL_TR),	//# Fast weak diagonal attack bottom left to top right
+	ENUM2STRING(BOTH_A5_TR_BL),	//# Fast weak diagonal attack bottom left to right
+	//Saber Arc and Spin Transitions
+	ENUM2STRING(BOTH_T5_BR__R),	//# Fast arc bottom right to right
+	ENUM2STRING(BOTH_T5_BR_TL),	//# Fast weak spin bottom right to top left
+	ENUM2STRING(BOTH_T5_BR__L),	//# Fast weak spin bottom right to left
+	ENUM2STRING(BOTH_T5_BR_BL),	//# Fast weak spin bottom right to bottom left
+	ENUM2STRING(BOTH_T5__R_TR),	//# Fast arc right to top right
+	ENUM2STRING(BOTH_T5__R_TL),	//# Fast arc right to top left
+	ENUM2STRING(BOTH_T5__R__L),	//# Fast weak spin right to left
+	ENUM2STRING(BOTH_T5__R_BL),	//# Fast weak spin right to bottom left
+	ENUM2STRING(BOTH_T5_TR_BR),	//# Fast arc top right to bottom right
+	ENUM2STRING(BOTH_T5_TR_TL),	//# Fast arc top right to top left
+	ENUM2STRING(BOTH_T5_TR__L),	//# Fast arc top right to left
+	ENUM2STRING(BOTH_T5_TR_BL),	//# Fast weak spin top right to bottom left
+	ENUM2STRING(BOTH_T5_T__BR),	//# Fast arc top to bottom right
+	ENUM2STRING(BOTH_T5_T___R),	//# Fast arc top to right
+	ENUM2STRING(BOTH_T5_T__TR),	//# Fast arc top to top right
+	ENUM2STRING(BOTH_T5_T__TL),	//# Fast arc top to top left
+	ENUM2STRING(BOTH_T5_T___L),	//# Fast arc top to left
+	ENUM2STRING(BOTH_T5_T__BL),	//# Fast arc top to bottom left
+	ENUM2STRING(BOTH_T5_TL_BR),	//# Fast weak spin top left to bottom right
+	ENUM2STRING(BOTH_T5_TL_BL),	//# Fast arc top left to bottom left
+	ENUM2STRING(BOTH_T5__L_BR),	//# Fast weak spin left to bottom right
+	ENUM2STRING(BOTH_T5__L__R),	//# Fast weak spin left to right
+	ENUM2STRING(BOTH_T5__L_TL),	//# Fast arc left to top left
+	ENUM2STRING(BOTH_T5_BL_BR),	//# Fast weak spin bottom left to bottom right
+	ENUM2STRING(BOTH_T5_BL__R),	//# Fast weak spin bottom left to right
+	ENUM2STRING(BOTH_T5_BL_TR),	//# Fast weak spin bottom left to top right
+	ENUM2STRING(BOTH_T5_BL__L),	//# Fast arc bottom left to left
+	//Saber Arc Transitions that use existing animations played backwards
+	ENUM2STRING(BOTH_T5_BR_TR),	//# Fast arc bottom right to top right		(use: ENUM2STRING(BOTH_T5_TR_BR)
+	ENUM2STRING(BOTH_T5_BR_T_),	//# Fast arc bottom right to top			(use: ENUM2STRING(BOTH_T5_T__BR)
+	ENUM2STRING(BOTH_T5__R_BR),	//# Fast arc right to bottom right			(use: ENUM2STRING(BOTH_T5_BR__R)
+	ENUM2STRING(BOTH_T5__R_T_),	//# Fast ar right to top				(use: ENUM2STRING(BOTH_T5_T___R)
+	ENUM2STRING(BOTH_T5_TR__R),	//# Fast arc top right to right			(use: ENUM2STRING(BOTH_T5__R_TR)
+	ENUM2STRING(BOTH_T5_TR_T_),	//# Fast arc top right to top				(use: ENUM2STRING(BOTH_T5_T__TR)
+	ENUM2STRING(BOTH_T5_TL__R),	//# Fast arc top left to right			(use: ENUM2STRING(BOTH_T5__R_TL)
+	ENUM2STRING(BOTH_T5_TL_TR),	//# Fast arc top left to top right			(use: ENUM2STRING(BOTH_T5_TR_TL)
+	ENUM2STRING(BOTH_T5_TL_T_),	//# Fast arc top left to top				(use: ENUM2STRING(BOTH_T5_T__TL)
+	ENUM2STRING(BOTH_T5_TL__L),	//# Fast arc top left to left				(use: ENUM2STRING(BOTH_T5__L_TL)
+	ENUM2STRING(BOTH_T5__L_TR),	//# Fast arc left to top right			(use: ENUM2STRING(BOTH_T5_TR__L)
+	ENUM2STRING(BOTH_T5__L_T_),	//# Fast arc left to top				(use: ENUM2STRING(BOTH_T5_T___L)
+	ENUM2STRING(BOTH_T5__L_BL),	//# Fast arc left to bottom left			(use: ENUM2STRING(BOTH_T5_BL__L)
+	ENUM2STRING(BOTH_T5_BL_T_),	//# Fast arc bottom left to top			(use: ENUM2STRING(BOTH_T5_T__BL)
+	ENUM2STRING(BOTH_T5_BL_TL),	//# Fast arc bottom left to top left		(use: ENUM2STRING(BOTH_T5_TL_BL)
+	//Saber Attack Start Transitions
+	ENUM2STRING(BOTH_S5_S1_T_),	//# Fast plain transition from stance1 to top-to-bottom Fast weak attack
+	ENUM2STRING(BOTH_S5_S1__L),	//# Fast plain transition from stance1 to left-to-right Fast weak attack
+	ENUM2STRING(BOTH_S5_S1__R),	//# Fast plain transition from stance1 to right-to-left Fast weak attack
+	ENUM2STRING(BOTH_S5_S1_TL),	//# Fast plain transition from stance1 to top-left-to-bottom-right Fast weak attack
+	ENUM2STRING(BOTH_S5_S1_BR),	//# Fast plain transition from stance1 to bottom-right-to-top-left Fast weak attack
+	ENUM2STRING(BOTH_S5_S1_BL),	//# Fast plain transition from stance1 to bottom-left-to-top-right Fast weak attack
+	ENUM2STRING(BOTH_S5_S1_TR),	//# Fast plain transition from stance1 to top-right-to-bottom-left Fast weak attack
+	//Saber Attack Return Transitions
+	ENUM2STRING(BOTH_R5_B__S1),	//# Fast plain transition from top-to-bottom Fast weak attack to stance1
+	ENUM2STRING(BOTH_R5__L_S1),	//# Fast plain transition from left-to-right Fast weak attack to stance1
+	ENUM2STRING(BOTH_R5__R_S1),	//# Fast plain transition from right-to-left Fast weak attack to stance1
+	ENUM2STRING(BOTH_R5_TL_S1),	//# Fast plain transition from top-left-to-bottom-right Fast weak attack to stance1
+	ENUM2STRING(BOTH_R5_BR_S1),	//# Fast plain transition from bottom-right-to-top-left Fast weak attack to stance1
+	ENUM2STRING(BOTH_R5_BL_S1),	//# Fast plain transition from bottom-left-to-top-right Fast weak attack to stance1
+	ENUM2STRING(BOTH_R5_TR_S1),	//# Fast plain transition from top-right-to-bottom-left Fast weak attack
+	//Saber Attack Bounces (first 4 frames of an attack), played backwards)
+	ENUM2STRING(BOTH_B5_BR___),	//# Bounce-back if attack from BR is blocked
+	ENUM2STRING(BOTH_B5__R___),	//# Bounce-back if attack from R is blocked
+	ENUM2STRING(BOTH_B5_TR___),	//# Bounce-back if attack from TR is blocked
+	ENUM2STRING(BOTH_B5_T____),	//# Bounce-back if attack from T is blocked
+	ENUM2STRING(BOTH_B5_TL___),	//# Bounce-back if attack from TL is blocked
+	ENUM2STRING(BOTH_B5__L___),	//# Bounce-back if attack from L is blocked
+	ENUM2STRING(BOTH_B5_BL___),	//# Bounce-back if attack from BL is blocked
+	//Saber Attack Deflections (last 4 frames of an attack)
+	ENUM2STRING(BOTH_D5_BR___),	//# Deflection toward BR
+	ENUM2STRING(BOTH_D5__R___),	//# Deflection toward R
+	ENUM2STRING(BOTH_D5_TR___),	//# Deflection toward TR
+	ENUM2STRING(BOTH_D5_TL___),	//# Deflection toward TL
+	ENUM2STRING(BOTH_D5__L___),	//# Deflection toward L
+	ENUM2STRING(BOTH_D5_BL___),	//# Deflection toward BL
+	ENUM2STRING(BOTH_D5_B____),	//# Deflection toward B
+	//Saber attack anims - power level 6
+	ENUM2STRING(BOTH_A6_T__B_),	//# Fast weak vertical attack top to bottom
+	ENUM2STRING(BOTH_A6__L__R),	//# Fast weak horizontal attack left to right
+	ENUM2STRING(BOTH_A6__R__L),	//# Fast weak horizontal attack right to left
+	ENUM2STRING(BOTH_A6_TL_BR),	//# Fast weak diagonal attack top left to botom right
+	ENUM2STRING(BOTH_A6_BR_TL),	//# Fast weak diagonal attack top left to botom right
+	ENUM2STRING(BOTH_A6_BL_TR),	//# Fast weak diagonal attack bottom left to top right
+	ENUM2STRING(BOTH_A6_TR_BL),	//# Fast weak diagonal attack bottom left to right
+	//Saber Arc and Spin Transitions
+	ENUM2STRING(BOTH_T6_BR__R),	//# Fast arc bottom right to right
+	ENUM2STRING(BOTH_T6_BR_TL),	//# Fast weak spin bottom right to top left
+	ENUM2STRING(BOTH_T6_BR__L),	//# Fast weak spin bottom right to left
+	ENUM2STRING(BOTH_T6_BR_BL),	//# Fast weak spin bottom right to bottom left
+	ENUM2STRING(BOTH_T6__R_TR),	//# Fast arc right to top right
+	ENUM2STRING(BOTH_T6__R_TL),	//# Fast arc right to top left
+	ENUM2STRING(BOTH_T6__R__L),	//# Fast weak spin right to left
+	ENUM2STRING(BOTH_T6__R_BL),	//# Fast weak spin right to bottom left
+	ENUM2STRING(BOTH_T6_TR_BR),	//# Fast arc top right to bottom right
+	ENUM2STRING(BOTH_T6_TR_TL),	//# Fast arc top right to top left
+	ENUM2STRING(BOTH_T6_TR__L),	//# Fast arc top right to left
+	ENUM2STRING(BOTH_T6_TR_BL),	//# Fast weak spin top right to bottom left
+	ENUM2STRING(BOTH_T6_T__BR),	//# Fast arc top to bottom right
+	ENUM2STRING(BOTH_T6_T___R),	//# Fast arc top to right
+	ENUM2STRING(BOTH_T6_T__TR),	//# Fast arc top to top right
+	ENUM2STRING(BOTH_T6_T__TL),	//# Fast arc top to top left
+	ENUM2STRING(BOTH_T6_T___L),	//# Fast arc top to left
+	ENUM2STRING(BOTH_T6_T__BL),	//# Fast arc top to bottom left
+	ENUM2STRING(BOTH_T6_TL_BR),	//# Fast weak spin top left to bottom right
+	ENUM2STRING(BOTH_T6_TL_BL),	//# Fast arc top left to bottom left
+	ENUM2STRING(BOTH_T6__L_BR),	//# Fast weak spin left to bottom right
+	ENUM2STRING(BOTH_T6__L__R),	//# Fast weak spin left to right
+	ENUM2STRING(BOTH_T6__L_TL),	//# Fast arc left to top left
+	ENUM2STRING(BOTH_T6_BL_BR),	//# Fast weak spin bottom left to bottom right
+	ENUM2STRING(BOTH_T6_BL__R),	//# Fast weak spin bottom left to right
+	ENUM2STRING(BOTH_T6_BL_TR),	//# Fast weak spin bottom left to top right
+	ENUM2STRING(BOTH_T6_BL__L),	//# Fast arc bottom left to left
+	//Saber Arc Transitions that use existing animations played backwards
+	ENUM2STRING(BOTH_T6_BR_TR),	//# Fast arc bottom right to top right		(use: ENUM2STRING(BOTH_T6_TR_BR)
+	ENUM2STRING(BOTH_T6_BR_T_),	//# Fast arc bottom right to top			(use: ENUM2STRING(BOTH_T6_T__BR)
+	ENUM2STRING(BOTH_T6__R_BR),	//# Fast arc right to bottom right			(use: ENUM2STRING(BOTH_T6_BR__R)
+	ENUM2STRING(BOTH_T6__R_T_),	//# Fast ar right to top				(use: ENUM2STRING(BOTH_T6_T___R)
+	ENUM2STRING(BOTH_T6_TR__R),	//# Fast arc top right to right			(use: ENUM2STRING(BOTH_T6__R_TR)
+	ENUM2STRING(BOTH_T6_TR_T_),	//# Fast arc top right to top				(use: ENUM2STRING(BOTH_T6_T__TR)
+	ENUM2STRING(BOTH_T6_TL__R),	//# Fast arc top left to right			(use: ENUM2STRING(BOTH_T6__R_TL)
+	ENUM2STRING(BOTH_T6_TL_TR),	//# Fast arc top left to top right			(use: ENUM2STRING(BOTH_T6_TR_TL)
+	ENUM2STRING(BOTH_T6_TL_T_),	//# Fast arc top left to top				(use: ENUM2STRING(BOTH_T6_T__TL)
+	ENUM2STRING(BOTH_T6_TL__L),	//# Fast arc top left to left				(use: ENUM2STRING(BOTH_T6__L_TL)
+	ENUM2STRING(BOTH_T6__L_TR),	//# Fast arc left to top right			(use: ENUM2STRING(BOTH_T6_TR__L)
+	ENUM2STRING(BOTH_T6__L_T_),	//# Fast arc left to top				(use: ENUM2STRING(BOTH_T6_T___L)
+	ENUM2STRING(BOTH_T6__L_BL),	//# Fast arc left to bottom left			(use: ENUM2STRING(BOTH_T6_BL__L)
+	ENUM2STRING(BOTH_T6_BL_T_),	//# Fast arc bottom left to top			(use: ENUM2STRING(BOTH_T6_T__BL)
+	ENUM2STRING(BOTH_T6_BL_TL),	//# Fast arc bottom left to top left		(use: ENUM2STRING(BOTH_T6_TL_BL)
+	//Saber Attack Start Transitions
+	ENUM2STRING(BOTH_S6_S6_T_),	//# Fast plain transition from stance1 to top-to-bottom Fast weak attack
+	ENUM2STRING(BOTH_S6_S6__L),	//# Fast plain transition from stance1 to left-to-right Fast weak attack
+	ENUM2STRING(BOTH_S6_S6__R),	//# Fast plain transition from stance1 to right-to-left Fast weak attack
+	ENUM2STRING(BOTH_S6_S6_TL),	//# Fast plain transition from stance1 to top-left-to-bottom-right Fast weak attack
+	ENUM2STRING(BOTH_S6_S6_BR),	//# Fast plain transition from stance1 to bottom-right-to-top-left Fast weak attack
+	ENUM2STRING(BOTH_S6_S6_BL),	//# Fast plain transition from stance1 to bottom-left-to-top-right Fast weak attack
+	ENUM2STRING(BOTH_S6_S6_TR),	//# Fast plain transition from stance1 to top-right-to-bottom-left Fast weak attack
+	//Saber Attack Return Transitions
+	ENUM2STRING(BOTH_R6_B__S6),	//# Fast plain transition from top-to-bottom Fast weak attack to stance1
+	ENUM2STRING(BOTH_R6__L_S6),	//# Fast plain transition from left-to-right Fast weak attack to stance1
+	ENUM2STRING(BOTH_R6__R_S6),	//# Fast plain transition from right-to-left Fast weak attack to stance1
+	ENUM2STRING(BOTH_R6_TL_S6),	//# Fast plain transition from top-left-to-bottom-right Fast weak attack to stance1
+	ENUM2STRING(BOTH_R6_BR_S6),	//# Fast plain transition from bottom-right-to-top-left Fast weak attack to stance1
+	ENUM2STRING(BOTH_R6_BL_S6),	//# Fast plain transition from bottom-left-to-top-right Fast weak attack to stance1
+	ENUM2STRING(BOTH_R6_TR_S6),	//# Fast plain transition from top-right-to-bottom-left Fast weak attack
+	//Saber Attack Bounces (first 4 frames of an attack), played backwards)
+	ENUM2STRING(BOTH_B6_BR___),	//# Bounce-back if attack from BR is blocked
+	ENUM2STRING(BOTH_B6__R___),	//# Bounce-back if attack from R is blocked
+	ENUM2STRING(BOTH_B6_TR___),	//# Bounce-back if attack from TR is blocked
+	ENUM2STRING(BOTH_B6_T____),	//# Bounce-back if attack from T is blocked
+	ENUM2STRING(BOTH_B6_TL___),	//# Bounce-back if attack from TL is blocked
+	ENUM2STRING(BOTH_B6__L___),	//# Bounce-back if attack from L is blocked
+	ENUM2STRING(BOTH_B6_BL___),	//# Bounce-back if attack from BL is blocked
+	//Saber Attack Deflections (last 4 frames of an attack)
+	ENUM2STRING(BOTH_D6_BR___),	//# Deflection toward BR
+	ENUM2STRING(BOTH_D6__R___),	//# Deflection toward R
+	ENUM2STRING(BOTH_D6_TR___),	//# Deflection toward TR
+	ENUM2STRING(BOTH_D6_TL___),	//# Deflection toward TL
+	ENUM2STRING(BOTH_D6__L___),	//# Deflection toward L
+	ENUM2STRING(BOTH_D6_BL___),	//# Deflection toward BL
+	ENUM2STRING(BOTH_D6_B____),	//# Deflection toward B
+	//Saber attack anims - power level 7
+	ENUM2STRING(BOTH_A7_T__B_),	//# Fast weak vertical attack top to bottom
+	ENUM2STRING(BOTH_A7__L__R),	//# Fast weak horizontal attack left to right
+	ENUM2STRING(BOTH_A7__R__L),	//# Fast weak horizontal attack right to left
+	ENUM2STRING(BOTH_A7_TL_BR),	//# Fast weak diagonal attack top left to botom right
+	ENUM2STRING(BOTH_A7_BR_TL),	//# Fast weak diagonal attack top left to botom right
+	ENUM2STRING(BOTH_A7_BL_TR),	//# Fast weak diagonal attack bottom left to top right
+	ENUM2STRING(BOTH_A7_TR_BL),	//# Fast weak diagonal attack bottom left to right
+	//Saber Arc and Spin Transitions
+	ENUM2STRING(BOTH_T7_BR__R),	//# Fast arc bottom right to right
+	ENUM2STRING(BOTH_T7_BR_TL),	//# Fast weak spin bottom right to top left
+	ENUM2STRING(BOTH_T7_BR__L),	//# Fast weak spin bottom right to left
+	ENUM2STRING(BOTH_T7_BR_BL),	//# Fast weak spin bottom right to bottom left
+	ENUM2STRING(BOTH_T7__R_TR),	//# Fast arc right to top right
+	ENUM2STRING(BOTH_T7__R_TL),	//# Fast arc right to top left
+	ENUM2STRING(BOTH_T7__R__L),	//# Fast weak spin right to left
+	ENUM2STRING(BOTH_T7__R_BL),	//# Fast weak spin right to bottom left
+	ENUM2STRING(BOTH_T7_TR_BR),	//# Fast arc top right to bottom right
+	ENUM2STRING(BOTH_T7_TR_TL),	//# Fast arc top right to top left
+	ENUM2STRING(BOTH_T7_TR__L),	//# Fast arc top right to left
+	ENUM2STRING(BOTH_T7_TR_BL),	//# Fast weak spin top right to bottom left
+	ENUM2STRING(BOTH_T7_T__BR),	//# Fast arc top to bottom right
+	ENUM2STRING(BOTH_T7_T___R),	//# Fast arc top to right
+	ENUM2STRING(BOTH_T7_T__TR),	//# Fast arc top to top right
+	ENUM2STRING(BOTH_T7_T__TL),	//# Fast arc top to top left
+	ENUM2STRING(BOTH_T7_T___L),	//# Fast arc top to left
+	ENUM2STRING(BOTH_T7_T__BL),	//# Fast arc top to bottom left
+	ENUM2STRING(BOTH_T7_TL_BR),	//# Fast weak spin top left to bottom right
+	ENUM2STRING(BOTH_T7_TL_BL),	//# Fast arc top left to bottom left
+	ENUM2STRING(BOTH_T7__L_BR),	//# Fast weak spin left to bottom right
+	ENUM2STRING(BOTH_T7__L__R),	//# Fast weak spin left to right
+	ENUM2STRING(BOTH_T7__L_TL),	//# Fast arc left to top left
+	ENUM2STRING(BOTH_T7_BL_BR),	//# Fast weak spin bottom left to bottom right
+	ENUM2STRING(BOTH_T7_BL__R),	//# Fast weak spin bottom left to right
+	ENUM2STRING(BOTH_T7_BL_TR),	//# Fast weak spin bottom left to top right
+	ENUM2STRING(BOTH_T7_BL__L),	//# Fast arc bottom left to left
+	//Saber Arc Transitions that use existing animations played backwards
+	ENUM2STRING(BOTH_T7_BR_TR),	//# Fast arc bottom right to top right		(use: ENUM2STRING(BOTH_T7_TR_BR)
+	ENUM2STRING(BOTH_T7_BR_T_),	//# Fast arc bottom right to top			(use: ENUM2STRING(BOTH_T7_T__BR)
+	ENUM2STRING(BOTH_T7__R_BR),	//# Fast arc right to bottom right			(use: ENUM2STRING(BOTH_T7_BR__R)
+	ENUM2STRING(BOTH_T7__R_T_),	//# Fast ar right to top				(use: ENUM2STRING(BOTH_T7_T___R)
+	ENUM2STRING(BOTH_T7_TR__R),	//# Fast arc top right to right			(use: ENUM2STRING(BOTH_T7__R_TR)
+	ENUM2STRING(BOTH_T7_TR_T_),	//# Fast arc top right to top				(use: ENUM2STRING(BOTH_T7_T__TR)
+	ENUM2STRING(BOTH_T7_TL__R),	//# Fast arc top left to right			(use: ENUM2STRING(BOTH_T7__R_TL)
+	ENUM2STRING(BOTH_T7_TL_TR),	//# Fast arc top left to top right			(use: ENUM2STRING(BOTH_T7_TR_TL)
+	ENUM2STRING(BOTH_T7_TL_T_),	//# Fast arc top left to top				(use: ENUM2STRING(BOTH_T7_T__TL)
+	ENUM2STRING(BOTH_T7_TL__L),	//# Fast arc top left to left				(use: ENUM2STRING(BOTH_T7__L_TL)
+	ENUM2STRING(BOTH_T7__L_TR),	//# Fast arc left to top right			(use: ENUM2STRING(BOTH_T7_TR__L)
+	ENUM2STRING(BOTH_T7__L_T_),	//# Fast arc left to top				(use: ENUM2STRING(BOTH_T7_T___L)
+	ENUM2STRING(BOTH_T7__L_BL),	//# Fast arc left to bottom left			(use: ENUM2STRING(BOTH_T7_BL__L)
+	ENUM2STRING(BOTH_T7_BL_T_),	//# Fast arc bottom left to top			(use: ENUM2STRING(BOTH_T7_T__BL)
+	ENUM2STRING(BOTH_T7_BL_TL),	//# Fast arc bottom left to top left		(use: ENUM2STRING(BOTH_T7_TL_BL)
+	//Saber Attack Start Transitions
+	ENUM2STRING(BOTH_S7_S7_T_),	//# Fast plain transition from stance1 to top-to-bottom Fast weak attack
+	ENUM2STRING(BOTH_S7_S7__L),	//# Fast plain transition from stance1 to left-to-right Fast weak attack
+	ENUM2STRING(BOTH_S7_S7__R),	//# Fast plain transition from stance1 to right-to-left Fast weak attack
+	ENUM2STRING(BOTH_S7_S7_TL),	//# Fast plain transition from stance1 to top-left-to-bottom-right Fast weak attack
+	ENUM2STRING(BOTH_S7_S7_BR),	//# Fast plain transition from stance1 to bottom-right-to-top-left Fast weak attack
+	ENUM2STRING(BOTH_S7_S7_BL),	//# Fast plain transition from stance1 to bottom-left-to-top-right Fast weak attack
+	ENUM2STRING(BOTH_S7_S7_TR),	//# Fast plain transition from stance1 to top-right-to-bottom-left Fast weak attack
+	//Saber Attack Return Transitions
+	ENUM2STRING(BOTH_R7_B__S7),	//# Fast plain transition from top-to-bottom Fast weak attack to stance1
+	ENUM2STRING(BOTH_R7__L_S7),	//# Fast plain transition from left-to-right Fast weak attack to stance1
+	ENUM2STRING(BOTH_R7__R_S7),	//# Fast plain transition from right-to-left Fast weak attack to stance1
+	ENUM2STRING(BOTH_R7_TL_S7),	//# Fast plain transition from top-left-to-bottom-right Fast weak attack to stance1
+	ENUM2STRING(BOTH_R7_BR_S7),	//# Fast plain transition from bottom-right-to-top-left Fast weak attack to stance1
+	ENUM2STRING(BOTH_R7_BL_S7),	//# Fast plain transition from bottom-left-to-top-right Fast weak attack to stance1
+	ENUM2STRING(BOTH_R7_TR_S7),	//# Fast plain transition from top-right-to-bottom-left Fast weak attack
+	//Saber Attack Bounces (first 4 frames of an attack), played backwards)
+	ENUM2STRING(BOTH_B7_BR___),	//# Bounce-back if attack from BR is blocked
+	ENUM2STRING(BOTH_B7__R___),	//# Bounce-back if attack from R is blocked
+	ENUM2STRING(BOTH_B7_TR___),	//# Bounce-back if attack from TR is blocked
+	ENUM2STRING(BOTH_B7_T____),	//# Bounce-back if attack from T is blocked
+	ENUM2STRING(BOTH_B7_TL___),	//# Bounce-back if attack from TL is blocked
+	ENUM2STRING(BOTH_B7__L___),	//# Bounce-back if attack from L is blocked
+	ENUM2STRING(BOTH_B7_BL___),	//# Bounce-back if attack from BL is blocked
+	//Saber Attack Deflections (last 4 frames of an attack)
+	ENUM2STRING(BOTH_D7_BR___),	//# Deflection toward BR
+	ENUM2STRING(BOTH_D7__R___),	//# Deflection toward R
+	ENUM2STRING(BOTH_D7_TR___),	//# Deflection toward TR
+	ENUM2STRING(BOTH_D7_TL___),	//# Deflection toward TL
+	ENUM2STRING(BOTH_D7__L___),	//# Deflection toward L
+	ENUM2STRING(BOTH_D7_BL___),	//# Deflection toward BL
+	ENUM2STRING(BOTH_D7_B____),	//# Deflection toward B
+	//Saber parry anims
+	ENUM2STRING(BOTH_P1_S1_T_),	//# Block shot/saber top
+	ENUM2STRING(BOTH_P1_S1_TR),	//# Block shot/saber top right
+	ENUM2STRING(BOTH_P1_S1_TL),	//# Block shot/saber top left
+	ENUM2STRING(BOTH_P1_S1_BL),	//# Block shot/saber bottom left
+	ENUM2STRING(BOTH_P1_S1_BR),	//# Block shot/saber bottom right
+	//Saber knockaway
+	ENUM2STRING(BOTH_K1_S1_T_),	//# knockaway saber top
+	ENUM2STRING(BOTH_K1_S1_TR),	//# knockaway saber top right
+	ENUM2STRING(BOTH_K1_S1_TL),	//# knockaway saber top left
+	ENUM2STRING(BOTH_K1_S1_BL),	//# knockaway saber bottom left
+	ENUM2STRING(BOTH_K1_S1_B_),	//# knockaway saber bottom
+	ENUM2STRING(BOTH_K1_S1_BR),	//# knockaway saber bottom right
+	//Saber attack knocked away
+	ENUM2STRING(BOTH_V1_BR_S1),	//# BR attack knocked away
+	ENUM2STRING(BOTH_V1__R_S1),	//# R attack knocked away
+	ENUM2STRING(BOTH_V1_TR_S1),	//# TR attack knocked away
+	ENUM2STRING(BOTH_V1_T__S1),	//# T attack knocked away
+	ENUM2STRING(BOTH_V1_TL_S1),	//# TL attack knocked away
+	ENUM2STRING(BOTH_V1__L_S1),	//# L attack knocked away
+	ENUM2STRING(BOTH_V1_BL_S1),	//# BL attack knocked away
+	ENUM2STRING(BOTH_V1_B__S1),	//# B attack knocked away
+	//Saber parry broken
+	ENUM2STRING(BOTH_H1_S1_T_),	//# saber knocked down from top parry
+	ENUM2STRING(BOTH_H1_S1_TR),	//# saber knocked down-left from TR parry
+	ENUM2STRING(BOTH_H1_S1_TL),	//# saber knocked down-right from TL parry
+	ENUM2STRING(BOTH_H1_S1_BL),	//# saber knocked up-right from BL parry
+	ENUM2STRING(BOTH_H1_S1_B_),	//# saber knocked up over head from ready?
+	ENUM2STRING(BOTH_H1_S1_BR),	//# saber knocked up-left from BR parry
+	//Dual Sabers parry anims
+	ENUM2STRING(BOTH_P6_S6_T_),	//# Block shot/saber top
+	ENUM2STRING(BOTH_P6_S6_TR),	//# Block shot/saber top right
+	ENUM2STRING(BOTH_P6_S6_TL),	//# Block shot/saber top left
+	ENUM2STRING(BOTH_P6_S6_BL),	//# Block shot/saber bottom left
+	ENUM2STRING(BOTH_P6_S6_BR),	//# Block shot/saber bottom right
+	//Dual Sabers knockaway
+	ENUM2STRING(BOTH_K6_S6_T_),	//# knockaway saber top
+	ENUM2STRING(BOTH_K6_S6_TR),	//# knockaway saber top right
+	ENUM2STRING(BOTH_K6_S6_TL),	//# knockaway saber top left
+	ENUM2STRING(BOTH_K6_S6_BL),	//# knockaway saber bottom left
+	ENUM2STRING(BOTH_K6_S6_B_),	//# knockaway saber bottom
+	ENUM2STRING(BOTH_K6_S6_BR),	//# knockaway saber bottom right
+	//Dual Sabers attack knocked away
+	ENUM2STRING(BOTH_V6_BR_S6),	//# BR attack knocked away
+	ENUM2STRING(BOTH_V6__R_S6),	//# R attack knocked away
+	ENUM2STRING(BOTH_V6_TR_S6),	//# TR attack knocked away
+	ENUM2STRING(BOTH_V6_T__S6),	//# T attack knocked away
+	ENUM2STRING(BOTH_V6_TL_S6),	//# TL attack knocked away
+	ENUM2STRING(BOTH_V6__L_S6),	//# L attack knocked away
+	ENUM2STRING(BOTH_V6_BL_S6),	//# BL attack knocked away
+	ENUM2STRING(BOTH_V6_B__S6),	//# B attack knocked away
+	//Dual Sabers parry broken
+	ENUM2STRING(BOTH_H6_S6_T_),	//# saber knocked down from top parry
+	ENUM2STRING(BOTH_H6_S6_TR),	//# saber knocked down-left from TR parry
+	ENUM2STRING(BOTH_H6_S6_TL),	//# saber knocked down-right from TL parry
+	ENUM2STRING(BOTH_H6_S6_BL),	//# saber knocked up-right from BL parry
+	ENUM2STRING(BOTH_H6_S6_B_),	//# saber knocked up over head from ready?
+	ENUM2STRING(BOTH_H6_S6_BR),	//# saber knocked up-left from BR parry
+	//SaberStaff parry anims
+	ENUM2STRING(BOTH_P7_S7_T_),	//# Block shot/saber top
+	ENUM2STRING(BOTH_P7_S7_TR),	//# Block shot/saber top right
+	ENUM2STRING(BOTH_P7_S7_TL),	//# Block shot/saber top left
+	ENUM2STRING(BOTH_P7_S7_BL),	//# Block shot/saber bottom left
+	ENUM2STRING(BOTH_P7_S7_BR),	//# Block shot/saber bottom right
+	//SaberStaff knockaway
+	ENUM2STRING(BOTH_K7_S7_T_),	//# knockaway saber top
+	ENUM2STRING(BOTH_K7_S7_TR),	//# knockaway saber top right
+	ENUM2STRING(BOTH_K7_S7_TL),	//# knockaway saber top left
+	ENUM2STRING(BOTH_K7_S7_BL),	//# knockaway saber bottom left
+	ENUM2STRING(BOTH_K7_S7_B_),	//# knockaway saber bottom
+	ENUM2STRING(BOTH_K7_S7_BR),	//# knockaway saber bottom right
+	//SaberStaff attack knocked away
+	ENUM2STRING(BOTH_V7_BR_S7),	//# BR attack knocked away
+	ENUM2STRING(BOTH_V7__R_S7),	//# R attack knocked away
+	ENUM2STRING(BOTH_V7_TR_S7),	//# TR attack knocked away
+	ENUM2STRING(BOTH_V7_T__S7),	//# T attack knocked away
+	ENUM2STRING(BOTH_V7_TL_S7),	//# TL attack knocked away
+	ENUM2STRING(BOTH_V7__L_S7),	//# L attack knocked away
+	ENUM2STRING(BOTH_V7_BL_S7),	//# BL attack knocked away
+	ENUM2STRING(BOTH_V7_B__S7),	//# B attack knocked away
+	//SaberStaff parry broken
+	ENUM2STRING(BOTH_H7_S7_T_),	//# saber knocked down from top parry
+	ENUM2STRING(BOTH_H7_S7_TR),	//# saber knocked down-left from TR parry
+	ENUM2STRING(BOTH_H7_S7_TL),	//# saber knocked down-right from TL parry
+	ENUM2STRING(BOTH_H7_S7_BL),	//# saber knocked up-right from BL parry
+	ENUM2STRING(BOTH_H7_S7_B_),	//# saber knocked up over head from ready?
+	ENUM2STRING(BOTH_H7_S7_BR),	//# saber knocked up-left from BR parry
+	//Sabers locked anims
+	//* #sep BOTH_ SABER LOCKED ANIMS
+	//BOTH_(DL, S, ST)_(DL, S, ST)_(T, S)_(L, B, SB)_1(_W, _L)
+//===Single locks==================================================================
+//SINGLE vs. DUAL
+	//side locks - I'm using a single and they're using dual
+	ENUM2STRING(BOTH_LK_S_DL_S_B_1_L),	//normal break I lost
+	ENUM2STRING(BOTH_LK_S_DL_S_B_1_W),	//normal break I won
+	ENUM2STRING(BOTH_LK_S_DL_S_L_1),		//lock if I'm using single vs. a dual
+	ENUM2STRING(BOTH_LK_S_DL_S_SB_1_L),	//super break I lost
+	ENUM2STRING(BOTH_LK_S_DL_S_SB_1_W),	//super break I won
+	//top locks
+	ENUM2STRING(BOTH_LK_S_DL_T_B_1_L),	//normal break I lost
+	ENUM2STRING(BOTH_LK_S_DL_T_B_1_W),	//normal break I won
+	ENUM2STRING(BOTH_LK_S_DL_T_L_1),		//lock if I'm using single vs. a dual
+	ENUM2STRING(BOTH_LK_S_DL_T_SB_1_L),	//super break I lost
+	ENUM2STRING(BOTH_LK_S_DL_T_SB_1_W),	//super break I won
+//SINGLE vs. STAFF
+	//side locks
+	ENUM2STRING(BOTH_LK_S_ST_S_B_1_L),	//normal break I lost
+	ENUM2STRING(BOTH_LK_S_ST_S_B_1_W),	//normal break I won
+	ENUM2STRING(BOTH_LK_S_ST_S_L_1),		//lock if I'm using single vs. a staff
+	ENUM2STRING(BOTH_LK_S_ST_S_SB_1_L),	//super break I lost
+	ENUM2STRING(BOTH_LK_S_ST_S_SB_1_W),	//super break I won
+	//top locks
+	ENUM2STRING(BOTH_LK_S_ST_T_B_1_L),	//normal break I lost
+	ENUM2STRING(BOTH_LK_S_ST_T_B_1_W),	//normal break I won
+	ENUM2STRING(BOTH_LK_S_ST_T_L_1),		//lock if I'm using single vs. a staff
+	ENUM2STRING(BOTH_LK_S_ST_T_SB_1_L),	//super break I lost
+	ENUM2STRING(BOTH_LK_S_ST_T_SB_1_W),	//super break I won
+//SINGLE vs. SINGLE
+	//side locks
+	ENUM2STRING(BOTH_LK_S_S_S_B_1_L),	//normal break I lost
+	ENUM2STRING(BOTH_LK_S_S_S_B_1_W),	//normal break I won
+	ENUM2STRING(BOTH_LK_S_S_S_L_1),		//lock if I'm using single vs. a single and I initiated
+	ENUM2STRING(BOTH_LK_S_S_S_SB_1_L),	//super break I lost
+	ENUM2STRING(BOTH_LK_S_S_S_SB_1_W),	//super break I won
+	//top locks
+	ENUM2STRING(BOTH_LK_S_S_T_B_1_L),	//normal break I lost
+	ENUM2STRING(BOTH_LK_S_S_T_B_1_W),	//normal break I won
+	ENUM2STRING(BOTH_LK_S_S_T_L_1),		//lock if I'm using single vs. a single and I initiated
+	ENUM2STRING(BOTH_LK_S_S_T_SB_1_L),	//super break I lost
+	ENUM2STRING(BOTH_LK_S_S_T_SB_1_W),	//super break I won
+//===Dual Saber locks==================================================================
+//DUAL vs. DUAL	
+	//side locks
+	ENUM2STRING(BOTH_LK_DL_DL_S_B_1_L),	//normal break I lost
+	ENUM2STRING(BOTH_LK_DL_DL_S_B_1_W),	//normal break I won
+	ENUM2STRING(BOTH_LK_DL_DL_S_L_1),	//lock if I'm using dual vs. dual and I initiated
+	ENUM2STRING(BOTH_LK_DL_DL_S_SB_1_L),	//super break I lost
+	ENUM2STRING(BOTH_LK_DL_DL_S_SB_1_W),	//super break I won
+	//top locks
+	ENUM2STRING(BOTH_LK_DL_DL_T_B_1_L),	//normal break I lost
+	ENUM2STRING(BOTH_LK_DL_DL_T_B_1_W),	//normal break I won
+	ENUM2STRING(BOTH_LK_DL_DL_T_L_1),	//lock if I'm using dual vs. dual and I initiated
+	ENUM2STRING(BOTH_LK_DL_DL_T_SB_1_L),	//super break I lost
+	ENUM2STRING(BOTH_LK_DL_DL_T_SB_1_W),	//super break I won
+//DUAL vs. STAFF
+	//side locks
+	ENUM2STRING(BOTH_LK_DL_ST_S_B_1_L),	//normal break I lost
+	ENUM2STRING(BOTH_LK_DL_ST_S_B_1_W),	//normal break I won
+	ENUM2STRING(BOTH_LK_DL_ST_S_L_1),	//lock if I'm using dual vs. a staff
+	ENUM2STRING(BOTH_LK_DL_ST_S_SB_1_L),	//super break I lost
+	ENUM2STRING(BOTH_LK_DL_ST_S_SB_1_W),	//super break I won
+	//top locks
+	ENUM2STRING(BOTH_LK_DL_ST_T_B_1_L),	//normal break I lost
+	ENUM2STRING(BOTH_LK_DL_ST_T_B_1_W),	//normal break I won
+	ENUM2STRING(BOTH_LK_DL_ST_T_L_1),	//lock if I'm using dual vs. a staff
+	ENUM2STRING(BOTH_LK_DL_ST_T_SB_1_L),	//super break I lost
+	ENUM2STRING(BOTH_LK_DL_ST_T_SB_1_W),	//super break I won
+//DUAL vs. SINGLE
+	//side locks
+	ENUM2STRING(BOTH_LK_DL_S_S_B_1_L),	//normal break I lost
+	ENUM2STRING(BOTH_LK_DL_S_S_B_1_W),	//normal break I won
+	ENUM2STRING(BOTH_LK_DL_S_S_L_1),		//lock if I'm using dual vs. a single
+	ENUM2STRING(BOTH_LK_DL_S_S_SB_1_L),	//super break I lost
+	ENUM2STRING(BOTH_LK_DL_S_S_SB_1_W),	//super break I won
+	//top locks
+	ENUM2STRING(BOTH_LK_DL_S_T_B_1_L),	//normal break I lost
+	ENUM2STRING(BOTH_LK_DL_S_T_B_1_W),	//normal break I won
+	ENUM2STRING(BOTH_LK_DL_S_T_L_1),		//lock if I'm using dual vs. a single
+	ENUM2STRING(BOTH_LK_DL_S_T_SB_1_L),	//super break I lost
+	ENUM2STRING(BOTH_LK_DL_S_T_SB_1_W),	//super break I won
+//===Saber Staff locks==================================================================
+//STAFF vs. DUAL
+	//side locks
+	ENUM2STRING(BOTH_LK_ST_DL_S_B_1_L),	//normal break I lost
+	ENUM2STRING(BOTH_LK_ST_DL_S_B_1_W),	//normal break I won
+	ENUM2STRING(BOTH_LK_ST_DL_S_L_1),	//lock if I'm using staff vs. dual
+	ENUM2STRING(BOTH_LK_ST_DL_S_SB_1_L),	//super break I lost
+	ENUM2STRING(BOTH_LK_ST_DL_S_SB_1_W),	//super break I won
+	//top locks
+	ENUM2STRING(BOTH_LK_ST_DL_T_B_1_L),	//normal break I lost
+	ENUM2STRING(BOTH_LK_ST_DL_T_B_1_W),	//normal break I won
+	ENUM2STRING(BOTH_LK_ST_DL_T_L_1),	//lock if I'm using staff vs. dual
+	ENUM2STRING(BOTH_LK_ST_DL_T_SB_1_L),	//super break I lost
+	ENUM2STRING(BOTH_LK_ST_DL_T_SB_1_W),	//super break I won
+//STAFF vs. STAFF
+	//side locks
+	ENUM2STRING(BOTH_LK_ST_ST_S_B_1_L),	//normal break I lost
+	ENUM2STRING(BOTH_LK_ST_ST_S_B_1_W),	//normal break I won
+	ENUM2STRING(BOTH_LK_ST_ST_S_L_1),	//lock if I'm using staff vs. a staff and I initiated
+	ENUM2STRING(BOTH_LK_ST_ST_S_SB_1_L),	//super break I lost
+	ENUM2STRING(BOTH_LK_ST_ST_S_SB_1_W),	//super break I won
+	//top locks
+	ENUM2STRING(BOTH_LK_ST_ST_T_B_1_L),	//normal break I lost
+	ENUM2STRING(BOTH_LK_ST_ST_T_B_1_W),	//normal break I won
+	ENUM2STRING(BOTH_LK_ST_ST_T_L_1),	//lock if I'm using staff vs. a staff and I initiated
+	ENUM2STRING(BOTH_LK_ST_ST_T_SB_1_L),	//super break I lost
+	ENUM2STRING(BOTH_LK_ST_ST_T_SB_1_W),	//super break I won
+//STAFF vs. SINGLE
+	//side locks
+	ENUM2STRING(BOTH_LK_ST_S_S_B_1_L),	//normal break I lost
+	ENUM2STRING(BOTH_LK_ST_S_S_B_1_W),	//normal break I won
+	ENUM2STRING(BOTH_LK_ST_S_S_L_1),		//lock if I'm using staff vs. a single
+	ENUM2STRING(BOTH_LK_ST_S_S_SB_1_L),	//super break I lost
+	ENUM2STRING(BOTH_LK_ST_S_S_SB_1_W),	//super break I won
+	//top locks
+	ENUM2STRING(BOTH_LK_ST_S_T_B_1_L),	//normal break I lost
+	ENUM2STRING(BOTH_LK_ST_S_T_B_1_W),	//normal break I won
+	ENUM2STRING(BOTH_LK_ST_S_T_L_1),		//lock if I'm using staff vs. a single
+	ENUM2STRING(BOTH_LK_ST_S_T_SB_1_L),	//super break I lost
+	ENUM2STRING(BOTH_LK_ST_S_T_SB_1_W),	//super break I won
+//Special cases for same saber style vs. each other (won't fit in nice 5-anim size lists above)
+	ENUM2STRING(BOTH_LK_S_S_S_L_2),		//lock if I'm using single vs. a single and other intitiated
+	ENUM2STRING(BOTH_LK_S_S_T_L_2),		//lock if I'm using single vs. a single and other initiated
+	ENUM2STRING(BOTH_LK_DL_DL_S_L_2),	//lock if I'm using dual vs. dual and other initiated
+	ENUM2STRING(BOTH_LK_DL_DL_T_L_2),	//lock if I'm using dual vs. dual and other initiated
+	ENUM2STRING(BOTH_LK_ST_ST_S_L_2),	//lock if I'm using staff vs. a staff and other initiated
+	ENUM2STRING(BOTH_LK_ST_ST_T_L_2),	//lock if I'm using staff vs. a staff and other initiated
+//===End Saber locks==================================================================
+	ENUM2STRING(BOTH_BF2RETURN),	//#
+	ENUM2STRING(BOTH_BF2BREAK),	//#
+	ENUM2STRING(BOTH_BF2LOCK),	//#
+	ENUM2STRING(BOTH_BF1RETURN),	//#
+	ENUM2STRING(BOTH_BF1BREAK),	//#
+	ENUM2STRING(BOTH_BF1LOCK),	//#
+	ENUM2STRING(BOTH_CWCIRCLE_R2__R_S1),	//#
+	ENUM2STRING(BOTH_CCWCIRCLE_R2__L_S1),	//#
+	ENUM2STRING(BOTH_CWCIRCLE_A2__L__R),	//#
+	ENUM2STRING(BOTH_CCWCIRCLE_A2__R__L),	//#
+	ENUM2STRING(BOTH_CWCIRCLEBREAK),	//#
+	ENUM2STRING(BOTH_CCWCIRCLEBREAK),	//#
+	ENUM2STRING(BOTH_CWCIRCLELOCK),	//#
+	ENUM2STRING(BOTH_CCWCIRCLELOCK),	//#
+	//other saber anims/attacks
+	ENUM2STRING(BOTH_SABERFAST_STANCE),
+	ENUM2STRING(BOTH_SABERSLOW_STANCE),
+	ENUM2STRING(BOTH_SABERDUAL_STANCE),
+	ENUM2STRING(BOTH_SABERSTAFF_STANCE),
+	ENUM2STRING(BOTH_A2_STABBACK1),		//# Stab saber backward
+	ENUM2STRING(BOTH_ATTACK_BACK),		//# Swing around backwards and attack
+	ENUM2STRING(BOTH_JUMPFLIPSLASHDOWN1),//#
+	ENUM2STRING(BOTH_JUMPFLIPSTABDOWN),//#
+	ENUM2STRING(BOTH_FORCELEAP2_T__B_),//#
+	ENUM2STRING(BOTH_LUNGE2_B__T_),//#
+	ENUM2STRING(BOTH_CROUCHATTACKBACK1),//#
+	//New specials for JKA:
+	ENUM2STRING(BOTH_JUMPATTACK6),//#
+	ENUM2STRING(BOTH_JUMPATTACK7),//#
+	ENUM2STRING(BOTH_SPINATTACK6),//#
+	ENUM2STRING(BOTH_SPINATTACK7),//#
+	ENUM2STRING(BOTH_S1_S6),//#	From stand1 to saberdual stance - turning on your dual sabers
+	ENUM2STRING(BOTH_S6_S1),//#	From dualstaff stance to stand1 - turning off your dual sabers
+	ENUM2STRING(BOTH_S1_S7),//#	From stand1 to saberstaff stance - turning on your saberstaff
+	ENUM2STRING(BOTH_S7_S1),//#	From saberstaff stance to stand1 - turning off your saberstaff
+	ENUM2STRING(BOTH_FORCELONGLEAP_START),
+	ENUM2STRING(BOTH_FORCELONGLEAP_ATTACK),
+	ENUM2STRING(BOTH_FORCELONGLEAP_LAND),
+	ENUM2STRING(BOTH_FORCEWALLRUNFLIP_START),
+	ENUM2STRING(BOTH_FORCEWALLRUNFLIP_END),
+	ENUM2STRING(BOTH_FORCEWALLRUNFLIP_ALT),
+	ENUM2STRING(BOTH_FORCEWALLREBOUND_FORWARD),
+	ENUM2STRING(BOTH_FORCEWALLREBOUND_LEFT),
+	ENUM2STRING(BOTH_FORCEWALLREBOUND_BACK),
+	ENUM2STRING(BOTH_FORCEWALLREBOUND_RIGHT),
+	ENUM2STRING(BOTH_FORCEWALLHOLD_FORWARD),
+	ENUM2STRING(BOTH_FORCEWALLHOLD_LEFT),
+	ENUM2STRING(BOTH_FORCEWALLHOLD_BACK),
+	ENUM2STRING(BOTH_FORCEWALLHOLD_RIGHT),
+	ENUM2STRING(BOTH_FORCEWALLRELEASE_FORWARD),
+	ENUM2STRING(BOTH_FORCEWALLRELEASE_LEFT),
+	ENUM2STRING(BOTH_FORCEWALLRELEASE_BACK),
+	ENUM2STRING(BOTH_FORCEWALLRELEASE_RIGHT),
+	ENUM2STRING(BOTH_A7_KICK_F),
+	ENUM2STRING(BOTH_A7_KICK_B),
+	ENUM2STRING(BOTH_A7_KICK_R),
+	ENUM2STRING(BOTH_A7_KICK_L),
+	ENUM2STRING(BOTH_A7_KICK_S),
+	ENUM2STRING(BOTH_A7_KICK_BF),
+	ENUM2STRING(BOTH_A7_KICK_BF_STOP),
+	ENUM2STRING(BOTH_A7_KICK_RL),
+	ENUM2STRING(BOTH_A7_KICK_F_AIR),
+	ENUM2STRING(BOTH_A7_KICK_B_AIR),
+	ENUM2STRING(BOTH_A7_KICK_R_AIR),
+	ENUM2STRING(BOTH_A7_KICK_L_AIR),
+	ENUM2STRING(BOTH_FLIP_ATTACK7),
+	ENUM2STRING(BOTH_FLIP_HOLD7),
+	ENUM2STRING(BOTH_FLIP_LAND),
+	ENUM2STRING(BOTH_PULL_IMPALE_STAB),
+	ENUM2STRING(BOTH_PULL_IMPALE_SWING),
+	ENUM2STRING(BOTH_PULLED_INAIR_B),
+	ENUM2STRING(BOTH_PULLED_INAIR_F),
+	ENUM2STRING(BOTH_STABDOWN),
+	ENUM2STRING(BOTH_STABDOWN_STAFF),
+	ENUM2STRING(BOTH_STABDOWN_DUAL),
+	ENUM2STRING(BOTH_A6_SABERPROTECT),
+	ENUM2STRING(BOTH_A7_SOULCAL),
+	ENUM2STRING(BOTH_A1_SPECIAL),
+	ENUM2STRING(BOTH_A2_SPECIAL),
+	ENUM2STRING(BOTH_A3_SPECIAL),
+	ENUM2STRING(BOTH_ROLL_STAB),
+
+	//# #sep ENUM2STRING(BOTH_ STANDING
+	ENUM2STRING(BOTH_STAND1),			//# Standing idle, no weapon, hands down
+	ENUM2STRING(BOTH_STAND1IDLE1),		//# Random standing idle
+	ENUM2STRING(BOTH_STAND2),			//# Standing idle with a saber
+	ENUM2STRING(BOTH_STAND2IDLE1),		//# Random standing idle
+	ENUM2STRING(BOTH_STAND2IDLE2),
+	ENUM2STRING(BOTH_STAND3),			//# Standing idle with 2-handed weapon
+	ENUM2STRING(BOTH_STAND3IDLE1),		//# Random standing idle
+	ENUM2STRING(BOTH_STAND4),			//# hands clasp behind back
+	ENUM2STRING(BOTH_STAND5),			//# standing idle, no weapon, hand down, back straight
+	ENUM2STRING(BOTH_STAND5IDLE1),		//# Random standing idle
+	ENUM2STRING(BOTH_STAND6),			//# one handed), gun at side), relaxed stand
+	ENUM2STRING(BOTH_STAND8),			//# both hands on hips (male)
+	ENUM2STRING(BOTH_STAND1TO2),			//# Transition from stand1 to stand2
+	ENUM2STRING(BOTH_STAND2TO1),			//# Transition from stand2 to stand1
+	ENUM2STRING(BOTH_STAND2TO4),			//# Transition from stand2 to stand4
+	ENUM2STRING(BOTH_STAND4TO2),			//# Transition from stand4 to stand2
+	ENUM2STRING(BOTH_STAND4TOATTACK2),	//# relaxed stand to 1-handed pistol ready
+	ENUM2STRING(BOTH_STANDUP2),			//# Luke standing up from his meditation platform (cin # 37)
+	ENUM2STRING(BOTH_STAND5TOSIT3),		//# transition from stand 5 to sit 3
+	ENUM2STRING(BOTH_STAND1TOSTAND5),	//# Transition from stand1 to stand5
+	ENUM2STRING(BOTH_STAND5TOSTAND1),	//# Transition from stand5 to stand1
+	ENUM2STRING(BOTH_STAND5TOAIM),		//# Transition of Kye aiming his gun at Desann (cin #9) 
+	ENUM2STRING(BOTH_STAND5STARTLEDLOOKLEFT),	//# Kyle turning to watch the bridge drop (cin #9) 
+	ENUM2STRING(BOTH_STARTLEDLOOKLEFTTOSTAND5),	//# Kyle returning to stand 5 from watching the bridge drop (cin #9) 
+	ENUM2STRING(BOTH_STAND5TOSTAND8),	//# Transition from stand5 to stand8
+	ENUM2STRING(BOTH_STAND7TOSTAND8),	//# Tavion putting hands on back of chair (cin #11)
+	ENUM2STRING(BOTH_STAND8TOSTAND5),	//# Transition from stand8 to stand5
+	ENUM2STRING(BOTH_STAND9),			//# Kyle's standing idle, no weapon, hands down
+	ENUM2STRING(BOTH_STAND9IDLE1),		//# Kyle's random standing idle
+	ENUM2STRING(BOTH_STAND5SHIFTWEIGHT),	//# Weightshift from stand5 to side and back to stand5
+	ENUM2STRING(BOTH_STAND5SHIFTWEIGHTSTART),	//# From stand5 to side
+	ENUM2STRING(BOTH_STAND5SHIFTWEIGHTSTOP),		//# From side to stand5
+	ENUM2STRING(BOTH_STAND5TURNLEFTSTART),		//# Start turning left from stand5
+	ENUM2STRING(BOTH_STAND5TURNLEFTSTOP),		//# Stop turning left from stand5
+	ENUM2STRING(BOTH_STAND5TURNRIGHTSTART),		//# Start turning right from stand5
+	ENUM2STRING(BOTH_STAND5TURNRIGHTSTOP),		//# Stop turning right from stand5
+	ENUM2STRING(BOTH_STAND5LOOK180LEFTSTART),	//# Start looking over left shoulder (cin #17)
+	ENUM2STRING(BOTH_STAND5LOOK180LEFTSTOP),	//# Stop looking over left shoulder (cin #17)
+
+	ENUM2STRING(BOTH_CONSOLE1START),	//# typing at a console
+	ENUM2STRING(BOTH_CONSOLE1),			//# typing at a console
+	ENUM2STRING(BOTH_CONSOLE1STOP),		//# typing at a console
+	ENUM2STRING(BOTH_CONSOLE2START),	//# typing at a console with comm link in hand (cin #5) 
+	ENUM2STRING(BOTH_CONSOLE2),			//# typing at a console with comm link in hand (cin #5) 
+	ENUM2STRING(BOTH_CONSOLE2STOP),		//# typing at a console with comm link in hand (cin #5) 
+	ENUM2STRING(BOTH_CONSOLE2HOLDCOMSTART),	//# lean in to type at console while holding comm link in hand (cin #5) 
+	ENUM2STRING(BOTH_CONSOLE2HOLDCOMSTOP),	//# lean away after typing at console while holding comm link in hand (cin #5) 
+
+	ENUM2STRING(BOTH_GUARD_LOOKAROUND1),	//# Cradling weapon and looking around
+	ENUM2STRING(BOTH_GUARD_IDLE1),		//# Cradling weapon and standing
+	ENUM2STRING(BOTH_GESTURE1),			//# Generic gesture), non-specific
+	ENUM2STRING(BOTH_GESTURE2),			//# Generic gesture), non-specific
+	ENUM2STRING(BOTH_WALK1TALKCOMM1),	//# Talking into coom link while walking
+	ENUM2STRING(BOTH_TALK1),			//# Generic talk anim
+	ENUM2STRING(BOTH_TALK2),			//# Generic talk anim
+	ENUM2STRING(BOTH_TALKCOMM1START),	//# Start talking into a comm link
+	ENUM2STRING(BOTH_TALKCOMM1),		//# Talking into a comm link
+	ENUM2STRING(BOTH_TALKCOMM1STOP),	//# Stop talking into a comm link
+	ENUM2STRING(BOTH_TALKGESTURE1),		//# Generic talk anim
+
+	ENUM2STRING(BOTH_HEADTILTLSTART),		//# Head tilt to left
+	ENUM2STRING(BOTH_HEADTILTLSTOP),		//# Head tilt to left
+	ENUM2STRING(BOTH_HEADTILTRSTART),		//# Head tilt to right
+	ENUM2STRING(BOTH_HEADTILTRSTOP),		//# Head tilt to right
+	ENUM2STRING(BOTH_HEADNOD),				//# Head shake YES
+	ENUM2STRING(BOTH_HEADSHAKE),			//# Head shake NO
+	ENUM2STRING(BOTH_SIT2HEADTILTLSTART),	//# Head tilt to left from seated position 2
+	ENUM2STRING(BOTH_SIT2HEADTILTLSTOP),	//# Head tilt to left from seated position 2
+
+	ENUM2STRING(BOTH_REACH1START),		//# Monmothma reaching for crystal
+	ENUM2STRING(BOTH_REACH1STOP),		//# Monmothma reaching for crystal
+
+	ENUM2STRING(BOTH_COME_ON1),				//# Jan gesturing to Kyle (cin #32a)
+	ENUM2STRING(BOTH_STEADYSELF1),			//# Jan trying to keep footing (cin #32a) Kyle (cin#5)
+	ENUM2STRING(BOTH_STEADYSELF1END),		//# Return hands to side from STEADSELF1 Kyle (cin#5)
+	ENUM2STRING(BOTH_SILENCEGESTURE1),		//# Luke silencing Kyle with a raised hand (cin #37)
+	ENUM2STRING(BOTH_REACHFORSABER1),		//# Luke holding hand out for Kyle's saber (cin #37)
+	ENUM2STRING(BOTH_SABERKILLER1),			//# Tavion about to strike Jan with saber (cin #9)
+	ENUM2STRING(BOTH_SABERKILLEE1),			//# Jan about to be struck by Tavion with saber (cin #9)
+	ENUM2STRING(BOTH_HUGGER1),				//# Kyle hugging Jan (cin #29)
+	ENUM2STRING(BOTH_HUGGERSTOP1),			//# Kyle stop hugging Jan but don't let her go (cin #29)
+	ENUM2STRING(BOTH_HUGGEE1),				//# Jan being hugged (cin #29)
+	ENUM2STRING(BOTH_HUGGEESTOP1),			//# Jan stop being hugged but don't let go (cin #29)
+
+	ENUM2STRING(BOTH_SABERTHROW1START),		//# Desann throwing his light saber (cin #26)
+	ENUM2STRING(BOTH_SABERTHROW1STOP),		//# Desann throwing his light saber (cin #26)
+	ENUM2STRING(BOTH_SABERTHROW2START),		//# Kyle throwing his light saber (cin #32)
+	ENUM2STRING(BOTH_SABERTHROW2STOP),		//# Kyle throwing his light saber (cin #32)
+
+	//# #sep ENUM2STRING(BOTH_ SITTING/CROUCHING
+	ENUM2STRING(BOTH_SIT1),				//# Normal chair sit.
+	ENUM2STRING(BOTH_SIT2),				//# Lotus position.
+	ENUM2STRING(BOTH_SIT3),				//# Sitting in tired position), elbows on knees
+
+	ENUM2STRING(BOTH_SIT2TOSTAND5),		//# Transition from sit 2 to stand 5
+	ENUM2STRING(BOTH_STAND5TOSIT2),		//# Transition from stand 5 to sit 2
+	ENUM2STRING(BOTH_SIT2TOSIT4),		//# Trans from sit2 to sit4 (cin #12) Luke leaning back from lotus position.
+	ENUM2STRING(BOTH_SIT3TOSTAND5),		//# transition from sit 3 to stand 5
+
+	ENUM2STRING(BOTH_CROUCH1),			//# Transition from standing to crouch
+	ENUM2STRING(BOTH_CROUCH1IDLE),		//# Crouching idle
+	ENUM2STRING(BOTH_CROUCH1WALK),		//# Walking while crouched
+	ENUM2STRING(BOTH_CROUCH1WALKBACK),	//# Walking while crouched
+	ENUM2STRING(BOTH_UNCROUCH1),			//# Transition from crouch to standing
+	ENUM2STRING(BOTH_CROUCH2TOSTAND1),	//# going from crouch2 to stand1
+	ENUM2STRING(BOTH_CROUCH3),			//# Desann crouching down to Kyle (cin 9)
+	ENUM2STRING(BOTH_UNCROUCH3),			//# Desann uncrouching down to Kyle (cin 9)
+	ENUM2STRING(BOTH_CROUCH4),			//# Slower version of crouch1 for cinematics
+	ENUM2STRING(BOTH_UNCROUCH4),		//# Slower version of uncrouch1 for cinematics
+
+	ENUM2STRING(BOTH_GUNSIT1),			//# sitting on an emplaced gun.
+
+	// Swoop Vehicle animations.
+	//* #sep BOTH_ SWOOP ANIMS
+	ENUM2STRING(BOTH_VS_MOUNT_L),			//# Mount from left		
+	ENUM2STRING(BOTH_VS_DISMOUNT_L),		//# Dismount to left		
+	ENUM2STRING(BOTH_VS_MOUNT_R),			//# Mount from  right (symmetry)		
+	ENUM2STRING(BOTH_VS_DISMOUNT_R),		//# Dismount to  right (symmetry)		
+
+	ENUM2STRING(BOTH_VS_MOUNTJUMP_L),		//#
+	ENUM2STRING(BOTH_VS_MOUNTTHROW),		//# Land on an occupied vehicle & throw off current pilot
+	ENUM2STRING(BOTH_VS_MOUNTTHROW_L),		//# Land on an occupied vehicle & throw off current pilot
+	ENUM2STRING(BOTH_VS_MOUNTTHROW_R),		//# Land on an occupied vehicle & throw off current pilot
+	ENUM2STRING(BOTH_VS_MOUNTTHROWEE),		//# Current pilot getting thrown off by another guy
+				
+	ENUM2STRING(BOTH_VS_LOOKLEFT),			//# Turn & Look behind and to the left (no weapon)		
+	ENUM2STRING(BOTH_VS_LOOKRIGHT),			//# Turn & Look behind and to the right (no weapon)		
+
+	ENUM2STRING(BOTH_VS_TURBO),				//# Hit The Turbo Button
+
+	ENUM2STRING(BOTH_VS_REV),				//# Player looks back as swoop reverses		
+
+	ENUM2STRING(BOTH_VS_AIR),				//# Player stands up when swoop is airborn		
+	ENUM2STRING(BOTH_VS_AIR_G),				//# "" with Gun
+	ENUM2STRING(BOTH_VS_AIR_SL),			//# "" with Saber Left
+	ENUM2STRING(BOTH_VS_AIR_SR),			//# "" with Saber Right
+
+	ENUM2STRING(BOTH_VS_LAND),				//# Player bounces down when swoop lands		
+	ENUM2STRING(BOTH_VS_LAND_G),			//#  "" with Gun
+	ENUM2STRING(BOTH_VS_LAND_SL),			//#  "" with Saber Left
+	ENUM2STRING(BOTH_VS_LAND_SR),			//#  "" with Saber Right
+
+	ENUM2STRING(BOTH_VS_IDLE),				//# Sit
+	ENUM2STRING(BOTH_VS_IDLE_G),			//# Sit (gun)
+	ENUM2STRING(BOTH_VS_IDLE_SL),			//# Sit (saber left)		
+	ENUM2STRING(BOTH_VS_IDLE_SR),			//# Sit (saber right)		
+
+	ENUM2STRING(BOTH_VS_LEANL),				//# Lean left
+	ENUM2STRING(BOTH_VS_LEANL_G),			//# Lean left (gun)		
+	ENUM2STRING(BOTH_VS_LEANL_SL),			//# Lean left (saber left)		
+	ENUM2STRING(BOTH_VS_LEANL_SR),			//# Lean left (saber right)		
+
+	ENUM2STRING(BOTH_VS_LEANR),				//# Lean right		
+	ENUM2STRING(BOTH_VS_LEANR_G),			//# Lean right (gun)		
+	ENUM2STRING(BOTH_VS_LEANR_SL),			//# Lean right (saber left)		
+	ENUM2STRING(BOTH_VS_LEANR_SR),			//# Lean right (saber right)		
+				
+	ENUM2STRING(BOTH_VS_ATL_S),				//# Attack left with saber		
+	ENUM2STRING(BOTH_VS_ATR_S),				//# Attack right with saber		
+	ENUM2STRING(BOTH_VS_ATR_TO_L_S),		//# Attack toss saber from right to left hand
+	ENUM2STRING(BOTH_VS_ATL_TO_R_S),		//# Attack toss saber from left to right hand
+	ENUM2STRING(BOTH_VS_ATR_G),				//# Attack right with gun (90)		
+	ENUM2STRING(BOTH_VS_ATL_G),				//# Attack left with gun (90)		
+	ENUM2STRING(BOTH_VS_ATF_G),				//# Attack forward with gun		
+
+	ENUM2STRING(BOTH_VS_PAIN1),				//# Pain		
+
+	// Added 12/04/02 by Aurelio.
+	//* #sep BOTH_ TAUNTAUN ANIMS
+	ENUM2STRING(BOTH_VT_MOUNT_L),			//# Mount from left	
+	ENUM2STRING(BOTH_VT_MOUNT_R),			//# Mount from right	
+	ENUM2STRING(BOTH_VT_MOUNT_B),			//# Mount from air, behind
+	ENUM2STRING(BOTH_VT_DISMOUNT),			//# Dismount for tauntaun
+	ENUM2STRING(BOTH_VT_DISMOUNT_L),		//# Dismount to tauntauns left	
+	ENUM2STRING(BOTH_VT_DISMOUNT_R),		//# Dismount to tauntauns right (symmetry)	
+
+	ENUM2STRING(BOTH_VT_WALK_FWD),			//# Walk forward	
+	ENUM2STRING(BOTH_VT_WALK_REV),			//# Walk backward	
+	ENUM2STRING(BOTH_VT_WALK_FWD_L),		//# walk lean left
+	ENUM2STRING(BOTH_VT_WALK_FWD_R),		//# walk lean right
+	ENUM2STRING(BOTH_VT_RUN_FWD),			//# Run forward	
+	ENUM2STRING(BOTH_VT_RUN_REV),			//# Look backwards while running (not weapon specific)	
+	ENUM2STRING(BOTH_VT_RUN_FWD_L),			//# run lean left
+	ENUM2STRING(BOTH_VT_RUN_FWD_R),			//# run lean right
+
+	ENUM2STRING(BOTH_VT_SLIDEF),			//# Tauntaun slides forward with abrupt stop	
+	ENUM2STRING(BOTH_VT_AIR),				//# Tauntaun jump	
+	ENUM2STRING(BOTH_VT_ATB),				//# Tauntaun tail swipe	
+	ENUM2STRING(BOTH_VT_PAIN1),				//# Pain	
+	ENUM2STRING(BOTH_VT_DEATH1),			//# Die	
+	ENUM2STRING(BOTH_VT_STAND),				//# Stand still and breath	
+	ENUM2STRING(BOTH_VT_BUCK),				//# Tauntaun bucking loop animation	
+
+	ENUM2STRING(BOTH_VT_LAND),				//# Player bounces down when tauntaun lands	
+	ENUM2STRING(BOTH_VT_TURBO),				//# Hit The Turbo Button
+	ENUM2STRING(BOTH_VT_IDLE_SL),			//# Sit (saber left)		
+	ENUM2STRING(BOTH_VT_IDLE_SR),			//# Sit (saber right)		
+	ENUM2STRING(BOTH_VT_IDLE),				//# Sit with no weapon selected	
+	ENUM2STRING(BOTH_VT_IDLE1),				//# Sit with no weapon selected	
+	ENUM2STRING(BOTH_VT_IDLE_S),			//# Sit with saber selected	
+	ENUM2STRING(BOTH_VT_IDLE_G),			//# Sit with gun selected	
+	ENUM2STRING(BOTH_VT_IDLE_T),			//# Sit with thermal grenade selected
+
+	ENUM2STRING(BOTH_VT_ATL_S),				//# Attack left with saber	
+	ENUM2STRING(BOTH_VT_ATR_S),				//# Attack right with saber	
+	ENUM2STRING(BOTH_VT_ATR_TO_L_S),		//# Attack toss saber from right to left hand
+	ENUM2STRING(BOTH_VT_ATL_TO_R_S),		//# Attack toss saber from left to right hand
+	ENUM2STRING(BOTH_VT_ATR_G),				//# Attack right with gun (90)	
+	ENUM2STRING(BOTH_VT_ATL_G),				//# Attack left with gun (90)	
+	ENUM2STRING(BOTH_VT_ATF_G),				//# Attack forward with gun	
+
+
+	// Added 2/26/02 by Aurelio.
+	//* #sep BOTH_ FIGHTER ANIMS
+	ENUM2STRING( BOTH_GEARS_OPEN ),
+	ENUM2STRING( BOTH_GEARS_CLOSE ),
+	ENUM2STRING( BOTH_WINGS_OPEN ),
+	ENUM2STRING( BOTH_WINGS_CLOSE ),
+
+	///////////////////////////////////
+
+	ENUM2STRING(BOTH_DEATH14_UNGRIP),	//# Desann's end death (cin #35)
+	ENUM2STRING(BOTH_DEATH14_SITUP),	//# Tavion sitting up after having been thrown (cin #23)
+	ENUM2STRING(BOTH_KNEES1),			//# Tavion on her knees
+	ENUM2STRING(BOTH_KNEES2),			//# Tavion on her knees looking down
+	ENUM2STRING(BOTH_KNEES2TO1),		//# Transition of KNEES2 to KNEES1
+
+	//# #sep ENUM2STRING(BOTH_ MOVING
+	ENUM2STRING(BOTH_WALK1),				//# Normal walk
+	ENUM2STRING(BOTH_WALK2),				//# Normal walk
+	ENUM2STRING(BOTH_WALK_STAFF),		//# Walk with saberstaff turned on
+	ENUM2STRING(BOTH_WALKBACK_STAFF),	//# Walk backwards with saberstaff turned on
+	ENUM2STRING(BOTH_WALK_DUAL),			//# Walk with dual turned on
+	ENUM2STRING(BOTH_WALKBACK_DUAL),		//# Walk backwards with dual turned on
+	ENUM2STRING(BOTH_WALK5),				//# Tavion taunting Kyle (cin 22)
+	ENUM2STRING(BOTH_WALK6),				//# Slow walk for Luke (cin 12)
+	ENUM2STRING(BOTH_WALK7),				//# Fast walk
+	ENUM2STRING(BOTH_RUN1),				//# Full run
+	ENUM2STRING(BOTH_RUN1START),			//# Start into full run1
+	ENUM2STRING(BOTH_RUN1STOP),			//# Stop from full run1
+	ENUM2STRING(BOTH_RUN2),				//# Full run
+	ENUM2STRING(BOTH_RUN1TORUN2),		//# Wampa run anim transition
+	ENUM2STRING(BOTH_RUN2TORUN1),		//# Wampa run anim transition
+	ENUM2STRING(BOTH_RUN4),				//# Jawa run
+	ENUM2STRING(BOTH_RUN_STAFF),			//# Run with saberstaff turned on
+	ENUM2STRING(BOTH_RUNBACK_STAFF),		//# Run backwards with saberstaff turned on
+	ENUM2STRING(BOTH_RUN_DUAL),			//# Run with dual turned on
+	ENUM2STRING(BOTH_RUNBACK_DUAL),		//# Run backwards with dual turned on
+	ENUM2STRING(BOTH_STRAFE_LEFT1),		//# Sidestep left), should loop
+	ENUM2STRING(BOTH_STRAFE_RIGHT1),		//# Sidestep right), should loop
+	ENUM2STRING(BOTH_RUNSTRAFE_LEFT1),	//# Sidestep left), should loop
+	ENUM2STRING(BOTH_RUNSTRAFE_RIGHT1),	//# Sidestep right), should loop
+	ENUM2STRING(BOTH_TURN_LEFT1),		//# Turn left), should loop
+	ENUM2STRING(BOTH_TURN_RIGHT1),		//# Turn right), should loop
+	ENUM2STRING(BOTH_TURNSTAND1),		//# Turn from STAND1 position
+	ENUM2STRING(BOTH_TURNSTAND2),		//# Turn from STAND2 position
+	ENUM2STRING(BOTH_TURNSTAND3),		//# Turn from STAND3 position
+	ENUM2STRING(BOTH_TURNSTAND4),		//# Turn from STAND4 position
+	ENUM2STRING(BOTH_TURNSTAND5),		//# Turn from STAND5 position
+	ENUM2STRING(BOTH_TURNCROUCH1),		//# Turn from CROUCH1 position
+
+	ENUM2STRING(BOTH_WALKBACK1),			//# Walk1 backwards
+	ENUM2STRING(BOTH_WALKBACK2),			//# Walk2 backwards
+	ENUM2STRING(BOTH_RUNBACK1),			//# Run1 backwards
+	ENUM2STRING(BOTH_RUNBACK2),			//# Run1 backwards
+	
+	//# #sep BOTH_ JUMPING
+	ENUM2STRING(BOTH_JUMP1),				//# Jump - wind-up and leave ground
+	ENUM2STRING(BOTH_INAIR1),			//# In air loop (from jump)
+	ENUM2STRING(BOTH_LAND1),				//# Landing (from in air loop)
+	ENUM2STRING(BOTH_LAND2),				//# Landing Hard (from a great height)
+
+	ENUM2STRING(BOTH_JUMPBACK1),			//# Jump backwards - wind-up and leave ground
+	ENUM2STRING(BOTH_INAIRBACK1),		//# In air loop (from jump back)
+	ENUM2STRING(BOTH_LANDBACK1),			//# Landing backwards(from in air loop)
+
+	ENUM2STRING(BOTH_JUMPLEFT1),			//# Jump left - wind-up and leave ground
+	ENUM2STRING(BOTH_INAIRLEFT1),		//# In air loop (from jump left)
+	ENUM2STRING(BOTH_LANDLEFT1),			//# Landing left(from in air loop)
+
+	ENUM2STRING(BOTH_JUMPRIGHT1),		//# Jump right - wind-up and leave ground
+	ENUM2STRING(BOTH_INAIRRIGHT1),		//# In air loop (from jump right)
+	ENUM2STRING(BOTH_LANDRIGHT1),		//# Landing right(from in air loop)
+
+	ENUM2STRING(BOTH_FORCEJUMP1),				//# Jump - wind-up and leave ground
+	ENUM2STRING(BOTH_FORCEINAIR1),			//# In air loop (from jump)
+	ENUM2STRING(BOTH_FORCELAND1),				//# Landing (from in air loop)
+
+	ENUM2STRING(BOTH_FORCEJUMPBACK1),			//# Jump backwards - wind-up and leave ground
+	ENUM2STRING(BOTH_FORCEINAIRBACK1),		//# In air loop (from jump back)
+	ENUM2STRING(BOTH_FORCELANDBACK1),			//# Landing backwards(from in air loop)
+
+	ENUM2STRING(BOTH_FORCEJUMPLEFT1),			//# Jump left - wind-up and leave ground
+	ENUM2STRING(BOTH_FORCEINAIRLEFT1),		//# In air loop (from jump left)
+	ENUM2STRING(BOTH_FORCELANDLEFT1),			//# Landing left(from in air loop)
+
+	ENUM2STRING(BOTH_FORCEJUMPRIGHT1),		//# Jump right - wind-up and leave ground
+	ENUM2STRING(BOTH_FORCEINAIRRIGHT1),		//# In air loop (from jump right)
+	ENUM2STRING(BOTH_FORCELANDRIGHT1),		//# Landing right(from in air loop)
+	//# #sep BOTH_ ACROBATICS
+	ENUM2STRING(BOTH_FLIP_F),			//# Flip forward
+	ENUM2STRING(BOTH_FLIP_B),			//# Flip backwards
+	ENUM2STRING(BOTH_FLIP_L),			//# Flip left
+	ENUM2STRING(BOTH_FLIP_R),			//# Flip right
+
+	ENUM2STRING(BOTH_ROLL_F),			//# Roll forward
+	ENUM2STRING(BOTH_ROLL_B),			//# Roll backward
+	ENUM2STRING(BOTH_ROLL_L),			//# Roll left
+	ENUM2STRING(BOTH_ROLL_R),			//# Roll right
+
+	ENUM2STRING(BOTH_HOP_F),				//# quickstep forward
+	ENUM2STRING(BOTH_HOP_B),				//# quickstep backwards
+	ENUM2STRING(BOTH_HOP_L),				//# quickstep left
+	ENUM2STRING(BOTH_HOP_R),				//# quickstep right
+
+	ENUM2STRING(BOTH_DODGE_FL),			//# lean-dodge forward left
+	ENUM2STRING(BOTH_DODGE_FR),			//# lean-dodge forward right
+	ENUM2STRING(BOTH_DODGE_BL),			//# lean-dodge backwards left
+	ENUM2STRING(BOTH_DODGE_BR),			//# lean-dodge backwards right
+	ENUM2STRING(BOTH_DODGE_L),			//# lean-dodge left
+	ENUM2STRING(BOTH_DODGE_R),			//# lean-dodge right
+	ENUM2STRING(BOTH_DODGE_HOLD_FL),			//# lean-dodge pose forward left
+	ENUM2STRING(BOTH_DODGE_HOLD_FR),			//# lean-dodge pose forward right
+	ENUM2STRING(BOTH_DODGE_HOLD_BL),			//# lean-dodge pose backwards left
+	ENUM2STRING(BOTH_DODGE_HOLD_BR),			//# lean-dodge pose backwards right
+	ENUM2STRING(BOTH_DODGE_HOLD_L),			//# lean-dodge pose left
+	ENUM2STRING(BOTH_DODGE_HOLD_R),			//# lean-dodge pose right
+
+	//MP taunt anims
+	ENUM2STRING(BOTH_ENGAGETAUNT),
+	ENUM2STRING(BOTH_BOW),
+	ENUM2STRING(BOTH_MEDITATE),
+	ENUM2STRING(BOTH_MEDITATE_END),
+	ENUM2STRING(BOTH_SHOWOFF_FAST),
+	ENUM2STRING(BOTH_SHOWOFF_MEDIUM),
+	ENUM2STRING(BOTH_SHOWOFF_STRONG),
+	ENUM2STRING(BOTH_SHOWOFF_DUAL),
+	ENUM2STRING(BOTH_SHOWOFF_STAFF),
+	ENUM2STRING(BOTH_VICTORY_FAST),
+	ENUM2STRING(BOTH_VICTORY_MEDIUM),
+	ENUM2STRING(BOTH_VICTORY_STRONG),
+	ENUM2STRING(BOTH_VICTORY_DUAL),
+	ENUM2STRING(BOTH_VICTORY_STAFF),
+	//other saber/acro anims
+	ENUM2STRING(BOTH_ARIAL_LEFT),		//# 
+	ENUM2STRING(BOTH_ARIAL_RIGHT),		//# 
+	ENUM2STRING(BOTH_CARTWHEEL_LEFT),	//# 
+	ENUM2STRING(BOTH_CARTWHEEL_RIGHT),	//# 
+	ENUM2STRING(BOTH_FLIP_LEFT),			//# 
+	ENUM2STRING(BOTH_FLIP_BACK1),		//# 
+	ENUM2STRING(BOTH_FLIP_BACK2),		//# 
+	ENUM2STRING(BOTH_FLIP_BACK3),		//# 
+	ENUM2STRING(BOTH_BUTTERFLY_LEFT),	//# 
+	ENUM2STRING(BOTH_BUTTERFLY_RIGHT),	//# 
+	ENUM2STRING(BOTH_WALL_RUN_RIGHT),	//# 
+	ENUM2STRING(BOTH_WALL_RUN_RIGHT_FLIP),//#
+	ENUM2STRING(BOTH_WALL_RUN_RIGHT_STOP),//# 
+	ENUM2STRING(BOTH_WALL_RUN_LEFT),		//# 
+	ENUM2STRING(BOTH_WALL_RUN_LEFT_FLIP),//#
+	ENUM2STRING(BOTH_WALL_RUN_LEFT_STOP),//# 
+	ENUM2STRING(BOTH_WALL_FLIP_RIGHT),	//# 
+	ENUM2STRING(BOTH_WALL_FLIP_LEFT),	//# 
+	ENUM2STRING(BOTH_KNOCKDOWN1),		//# knocked backwards
+	ENUM2STRING(BOTH_KNOCKDOWN2),		//# knocked backwards hard
+	ENUM2STRING(BOTH_KNOCKDOWN3),		//#	knocked forwards
+	ENUM2STRING(BOTH_KNOCKDOWN4),		//# knocked backwards from crouch
+	ENUM2STRING(BOTH_KNOCKDOWN5),		//# dupe of 3 - will be removed
+	ENUM2STRING(BOTH_GETUP1),			//#
+	ENUM2STRING(BOTH_GETUP2),			//#
+	ENUM2STRING(BOTH_GETUP3),			//#
+	ENUM2STRING(BOTH_GETUP4),			//#
+	ENUM2STRING(BOTH_GETUP5),			//#
+	ENUM2STRING(BOTH_GETUP_CROUCH_F1),	//#
+	ENUM2STRING(BOTH_GETUP_CROUCH_B1),	//#
+	ENUM2STRING(BOTH_FORCE_GETUP_F1),	//#
+	ENUM2STRING(BOTH_FORCE_GETUP_F2),	//#
+	ENUM2STRING(BOTH_FORCE_GETUP_B1),	//#
+	ENUM2STRING(BOTH_FORCE_GETUP_B2),	//#
+	ENUM2STRING(BOTH_FORCE_GETUP_B3),	//#
+	ENUM2STRING(BOTH_FORCE_GETUP_B4),	//#
+	ENUM2STRING(BOTH_FORCE_GETUP_B5),	//#
+	ENUM2STRING(BOTH_FORCE_GETUP_B6),	//#
+	ENUM2STRING(BOTH_GETUP_BROLL_B),	//#
+	ENUM2STRING(BOTH_GETUP_BROLL_F),	//#
+	ENUM2STRING(BOTH_GETUP_BROLL_L),	//#
+	ENUM2STRING(BOTH_GETUP_BROLL_R),	//#
+	ENUM2STRING(BOTH_GETUP_FROLL_B),	//#
+	ENUM2STRING(BOTH_GETUP_FROLL_F),	//#
+	ENUM2STRING(BOTH_GETUP_FROLL_L),	//#
+	ENUM2STRING(BOTH_GETUP_FROLL_R),	//#
+	ENUM2STRING(BOTH_WALL_FLIP_BACK1),	//#
+	ENUM2STRING(BOTH_WALL_FLIP_BACK2),	//#
+	ENUM2STRING(BOTH_SPIN1),				//#
+	ENUM2STRING(BOTH_CEILING_CLING),		//# clinging to ceiling
+	ENUM2STRING(BOTH_CEILING_DROP),		//# dropping from ceiling cling
+
+	//TESTING
+	ENUM2STRING(BOTH_FJSS_TR_BL),		//# jump spin slash tr to bl
+	ENUM2STRING(BOTH_FJSS_TL_BR),		//# jump spin slash bl to tr
+	ENUM2STRING(BOTH_RIGHTHANDCHOPPEDOFF),//#
+	ENUM2STRING(BOTH_DEFLECTSLASH__R__L_FIN),//#
+	ENUM2STRING(BOTH_BASHED1),//#
+	ENUM2STRING(BOTH_ARIAL_F1),//#
+	ENUM2STRING(BOTH_BUTTERFLY_FR1),//#
+	ENUM2STRING(BOTH_BUTTERFLY_FL1),//#
+
+	//NEW SABER/JEDI/FORCE ANIMS
+	ENUM2STRING(BOTH_BACK_FLIP_UP),	//# back flip up Bonus Animation!!!!	
+	ENUM2STRING(BOTH_LOSE_SABER),	//# player losing saber (pulled from hand by force pull 4 - Kyle?)
+	ENUM2STRING(BOTH_STAFF_TAUNT),	//# taunt saberstaff			
+	ENUM2STRING(BOTH_DUAL_TAUNT),		//# taunt dual
+	ENUM2STRING(BOTH_A6_FB),				//# dual attack front/back		
+	ENUM2STRING(BOTH_A6_LR),				//# dual attack left/right
+	ENUM2STRING(BOTH_A7_HILT),			//# saber knock (alt + stand still)
+	//Alora			
+	ENUM2STRING(BOTH_ALORA_SPIN),		//#jump spin attack	death ballet	
+	ENUM2STRING(BOTH_ALORA_FLIP_1),		//# gymnast move 1		
+	ENUM2STRING(BOTH_ALORA_FLIP_2),		//# gymnast move 2		
+	ENUM2STRING(BOTH_ALORA_FLIP_3),		//# gymnast move3		
+	ENUM2STRING(BOTH_ALORA_FLIP_B),		//# gymnast move back		
+	ENUM2STRING(BOTH_ALORA_SPIN_THROW),	//# dual saber throw		
+	ENUM2STRING(BOTH_ALORA_SPIN_SLASH),	//# spin slash	special bonus animation!! :)	
+	ENUM2STRING(BOTH_ALORA_TAUNT),		//# special taunt
+	//Rosh (Kothos battle)			
+	ENUM2STRING(BOTH_ROSH_PAIN),	//# hurt animation (exhausted)		
+	ENUM2STRING(BOTH_ROSH_HEAL),	//# healed/rejuvenated		
+	//Tavion			
+	ENUM2STRING(BOTH_TAVION_SCEPTERGROUND), //# stabbing ground with sith sword shoots electricity everywhere
+	ENUM2STRING(BOTH_TAVION_SWORDPOWER),//# Tavion doing the He-Man(tm) thing
+	ENUM2STRING(BOTH_SCEPTER_START),	//#Point scepter and attack start
+	ENUM2STRING(BOTH_SCEPTER_HOLD),	//#Point scepter and attack hold
+	ENUM2STRING(BOTH_SCEPTER_STOP),	//#Point scepter and attack stop
+	//Kyle Boss			
+	ENUM2STRING(BOTH_KYLE_GRAB),		//# grab
+	ENUM2STRING(BOTH_KYLE_MISS),		//# miss
+	ENUM2STRING(BOTH_KYLE_PA_1),		//# hold 1
+	ENUM2STRING(BOTH_PLAYER_PA_1),	//# player getting held 1
+	ENUM2STRING(BOTH_KYLE_PA_2),		//# hold 2
+	ENUM2STRING(BOTH_PLAYER_PA_2),	//# player getting held 2
+	ENUM2STRING(BOTH_PLAYER_PA_FLY),	//# player getting knocked back from punch at end of hold 1
+	ENUM2STRING(BOTH_KYLE_PA_3),		//# hold 3
+	ENUM2STRING(BOTH_PLAYER_PA_3),	//# player getting held 3
+	ENUM2STRING(BOTH_PLAYER_PA_3_FLY),//# player getting thrown at end of hold 3
+	//Rancor
+	ENUM2STRING(BOTH_BUCK_RIDER),	//# Rancor bucks when someone is on him
+	//WAMPA Grabbing enemy
+	ENUM2STRING(BOTH_HOLD_START),	//#
+	ENUM2STRING(BOTH_HOLD_MISS),	//#
+	ENUM2STRING(BOTH_HOLD_IDLE),	//#
+	ENUM2STRING(BOTH_HOLD_END),	//#
+	ENUM2STRING(BOTH_HOLD_ATTACK),	//#
+	ENUM2STRING(BOTH_HOLD_SNIFF),	//# Sniff the guy you're holding
+	ENUM2STRING(BOTH_HOLD_DROP),		//# just drop 'em
+	//BEING GRABBED BY WAMPA
+	ENUM2STRING(BOTH_GRABBED),	//#
+	ENUM2STRING(BOTH_RELEASED),	//#
+	ENUM2STRING(BOTH_HANG_IDLE),	//#
+	ENUM2STRING(BOTH_HANG_ATTACK),	//#
+	ENUM2STRING(BOTH_HANG_PAIN),	//#
+
+	//# #sep BOTH_ MISC MOVEMENT
+	ENUM2STRING(BOTH_HIT1),				//# Kyle hit by crate in cin #9
+	ENUM2STRING(BOTH_LADDER_UP1),		//# Climbing up a ladder with rungs at 16 unit intervals
+	ENUM2STRING(BOTH_LADDER_DWN1),		//# Climbing down a ladder with rungs at 16 unit intervals
+	ENUM2STRING(BOTH_LADDER_IDLE),		//#	Just sitting on the ladder
+
+	//# #sep ENUM2STRING(BOTH_ FLYING IDLE
+	ENUM2STRING(BOTH_FLY_SHIELDED),		//# For sentry droid, shields in
+
+	//# #sep BOTH_ SWIMMING
+	ENUM2STRING(BOTH_SWIM_IDLE1),		//# Swimming Idle 1
+	ENUM2STRING(BOTH_SWIMFORWARD),		//# Swim forward loop
+	ENUM2STRING(BOTH_SWIMBACKWARD),		//# Swim backward loop
+	
+	//# #sep ENUM2STRING(BOTH_ LYING
+	ENUM2STRING(BOTH_SLEEP1),			//# laying on back-rknee up-rhand on torso
+	ENUM2STRING(BOTH_SLEEP6START),		//# Kyle leaning back to sleep (cin 20)
+	ENUM2STRING(BOTH_SLEEP6STOP),		//# Kyle waking up and shaking his head (cin 21)
+	ENUM2STRING(BOTH_SLEEP1GETUP),		//# alarmed and getting up out of sleep1 pose to stand
+	ENUM2STRING(BOTH_SLEEP1GETUP2),		//# 
+
+	ENUM2STRING(BOTH_CHOKE1START),		//# tavion in force grip choke
+	ENUM2STRING(BOTH_CHOKE1STARTHOLD),		//# loop of tavion in force grip choke
+	ENUM2STRING(BOTH_CHOKE1),			//# tavion in force grip choke
+
+	ENUM2STRING(BOTH_CHOKE2),			//# tavion recovering from force grip choke
+	ENUM2STRING(BOTH_CHOKE3),			//# left-handed choke (for people still holding a weapon)
+
+	//# #sep ENUM2STRING(BOTH_ HUNTER-SEEKER BOT-SPECIFIC
+	ENUM2STRING(BOTH_POWERUP1),			//# Wakes up
+
+	ENUM2STRING(BOTH_TURNON),			//# Protocol Droid wakes up
+	ENUM2STRING(BOTH_TURNOFF),			//# Protocol Droid shuts off
+	ENUM2STRING(BOTH_BUTTON1),			//# Single button push with right hand
+	ENUM2STRING(BOTH_BUTTON2),			//# Single button push with left finger
+	ENUM2STRING(BOTH_BUTTON_HOLD),		//# Single button hold with left hand
+	ENUM2STRING(BOTH_BUTTON_RELEASE),	//# Single button release with left hand
+
+	//# JEDI-SPECIFIC
+	//# #sep BOTH_ FORCE ANIMS
+	ENUM2STRING(BOTH_RESISTPUSH),			//# plant yourself to resist force push/pulls.
+	ENUM2STRING(BOTH_FORCEPUSH),			//# Use off-hand to do force power.
+	ENUM2STRING(BOTH_FORCEPULL),			//# Use off-hand to do force power.
+	ENUM2STRING(BOTH_MINDTRICK1),			//# Use off-hand to do mind trick
+	ENUM2STRING(BOTH_MINDTRICK2),			//# Use off-hand to do distraction
+	ENUM2STRING(BOTH_FORCELIGHTNING),		//# Use off-hand to do lightning
+	ENUM2STRING(BOTH_FORCELIGHTNING_START),	//# Use off-hand to do lightning - start
+	ENUM2STRING(BOTH_FORCELIGHTNING_HOLD),	//# Use off-hand to do lightning - hold
+	ENUM2STRING(BOTH_FORCELIGHTNING_RELEASE),//# Use off-hand to do lightning - release
+	ENUM2STRING(BOTH_FORCEHEAL_START),		//# Healing meditation pose start
+	ENUM2STRING(BOTH_FORCEHEAL_STOP),		//# Healing meditation pose end
+	ENUM2STRING(BOTH_FORCEHEAL_QUICK),		//# Healing meditation gesture
+	ENUM2STRING(BOTH_SABERPULL),			//# Use off-hand to do force power.
+	ENUM2STRING(BOTH_FORCEGRIP1),			//# force-gripping (no anim?)
+	ENUM2STRING(BOTH_FORCEGRIP3),			//# force-gripping (right-hand)
+	ENUM2STRING(BOTH_FORCEGRIP3THROW),		//# throwing while force-gripping (right hand)
+	ENUM2STRING(BOTH_FORCEGRIP_HOLD),	//# Use off-hand to do grip - hold
+	ENUM2STRING(BOTH_FORCEGRIP_RELEASE),//# Use off-hand to do grip - release
+	ENUM2STRING(BOTH_TOSS1),				//# throwing to left after force gripping
+	ENUM2STRING(BOTH_TOSS2),				//# throwing to right after force gripping
+	//NEW force anims for JKA:
+	ENUM2STRING(BOTH_FORCE_RAGE),
+	ENUM2STRING(BOTH_FORCE_2HANDEDLIGHTNING),
+	ENUM2STRING(BOTH_FORCE_2HANDEDLIGHTNING_START),
+	ENUM2STRING(BOTH_FORCE_2HANDEDLIGHTNING_HOLD),
+	ENUM2STRING(BOTH_FORCE_2HANDEDLIGHTNING_RELEASE),
+	ENUM2STRING(BOTH_FORCE_DRAIN),
+	ENUM2STRING(BOTH_FORCE_DRAIN_START),
+	ENUM2STRING(BOTH_FORCE_DRAIN_HOLD),
+	ENUM2STRING(BOTH_FORCE_DRAIN_RELEASE),
+	ENUM2STRING(BOTH_FORCE_DRAIN_GRAB_START),
+	ENUM2STRING(BOTH_FORCE_DRAIN_GRAB_HOLD),
+	ENUM2STRING(BOTH_FORCE_DRAIN_GRAB_END),
+	ENUM2STRING(BOTH_FORCE_DRAIN_GRABBED),
+	ENUM2STRING(BOTH_FORCE_ABSORB),
+	ENUM2STRING(BOTH_FORCE_ABSORB_START),
+	ENUM2STRING(BOTH_FORCE_ABSORB_END),
+	ENUM2STRING(BOTH_FORCE_PROTECT),
+	ENUM2STRING(BOTH_FORCE_PROTECT_FAST),
+
+	ENUM2STRING(BOTH_WIND),
+
+	ENUM2STRING(BOTH_STAND_TO_KNEEL),
+	ENUM2STRING(BOTH_KNEEL_TO_STAND),
+
+	ENUM2STRING(BOTH_TUSKENATTACK1),
+	ENUM2STRING(BOTH_TUSKENATTACK2),
+	ENUM2STRING(BOTH_TUSKENATTACK3),
+	ENUM2STRING(BOTH_TUSKENLUNGE1),
+	ENUM2STRING(BOTH_TUSKENTAUNT1),
+
+	ENUM2STRING(BOTH_COWER1_START),		//# cower start
+	ENUM2STRING(BOTH_COWER1),			//# cower loop
+	ENUM2STRING(BOTH_COWER1_STOP),		//# cower stop
+	ENUM2STRING(BOTH_SONICPAIN_START),
+	ENUM2STRING(BOTH_SONICPAIN_HOLD),
+	ENUM2STRING(BOTH_SONICPAIN_END),
+
+	//new anim slots per Jarrod's request
+	ENUM2STRING(BOTH_STAND10),
+	ENUM2STRING(BOTH_STAND10_TALK1),
+	ENUM2STRING(BOTH_STAND10_TALK2),
+	ENUM2STRING(BOTH_STAND10TOSTAND1),
+
+	ENUM2STRING(BOTH_STAND1_TALK1),
+	ENUM2STRING(BOTH_STAND1_TALK2),
+	ENUM2STRING(BOTH_STAND1_TALK3),
+
+	ENUM2STRING(BOTH_SIT4),
+	ENUM2STRING(BOTH_SIT5),
+	ENUM2STRING(BOTH_SIT5_TALK1),
+	ENUM2STRING(BOTH_SIT5_TALK2),
+	ENUM2STRING(BOTH_SIT5_TALK3),
+
+	ENUM2STRING(BOTH_SIT6),
+	ENUM2STRING(BOTH_SIT7),
+	//=================================================
+	//ANIMS IN WHICH ONLY THE UPPER OBJECTS ARE IN MD3
+	//=================================================
+	//# #sep ENUM2STRING(TORSO_ WEAPON-RELATED
+	ENUM2STRING(TORSO_DROPWEAP1),		//# Put weapon away
+	ENUM2STRING(TORSO_DROPWEAP4),		//# Put weapon away
+	ENUM2STRING(TORSO_RAISEWEAP1),		//# Draw Weapon
+	ENUM2STRING(TORSO_RAISEWEAP4),		//# Draw Weapon
+	ENUM2STRING(TORSO_WEAPONREADY1),		//# Ready to fire stun baton
+	ENUM2STRING(TORSO_WEAPONREADY2),		//# Ready to fire one-handed blaster pistol
+	ENUM2STRING(TORSO_WEAPONREADY3),		//# Ready to fire blaster rifle
+	ENUM2STRING(TORSO_WEAPONREADY4),		//# Ready to fire sniper rifle
+	ENUM2STRING(TORSO_WEAPONREADY10),	//# Ready to fire thermal det
+	ENUM2STRING(TORSO_WEAPONIDLE2),		//# Holding one-handed blaster
+	ENUM2STRING(TORSO_WEAPONIDLE3),		//# Holding blaster rifle
+	ENUM2STRING(TORSO_WEAPONIDLE4),		//# Holding sniper rifle
+	ENUM2STRING(TORSO_WEAPONIDLE10),		//# Holding thermal det
+
+	//# #sep ENUM2STRING(TORSO_ USING NON-WEAPON OBJECTS
+
+	//# #sep ENUM2STRING(TORSO_ MISC
+	ENUM2STRING(TORSO_SURRENDER_START),	//# arms up
+	ENUM2STRING(TORSO_SURRENDER_STOP),	//# arms back down
+	ENUM2STRING(TORSO_CHOKING1),			//# TEMP
+
+	ENUM2STRING(TORSO_HANDSIGNAL1),
+	ENUM2STRING(TORSO_HANDSIGNAL2),
+	ENUM2STRING(TORSO_HANDSIGNAL3),
+	ENUM2STRING(TORSO_HANDSIGNAL4),
+	ENUM2STRING(TORSO_HANDSIGNAL5),
+
+	//=================================================
+	//ANIMS IN WHICH ONLY THE LOWER OBJECTS ARE IN MD3
+	//=================================================
+	//# #sep Legs-only anims
+	ENUM2STRING(LEGS_TURN1),				//# What legs do when you turn your lower body to match your upper body facing
+	ENUM2STRING(LEGS_TURN2),				//# Leg turning from stand2
+	ENUM2STRING(LEGS_LEAN_LEFT1),		//# Lean left
+	ENUM2STRING(LEGS_LEAN_RIGHT1),		//# Lean Right
+	ENUM2STRING(LEGS_CHOKING1),			//# TEMP
+	ENUM2STRING(LEGS_LEFTUP1),			//# On a slope with left foot 4 higher than right
+	ENUM2STRING(LEGS_LEFTUP2),			//# On a slope with left foot 8 higher than right
+	ENUM2STRING(LEGS_LEFTUP3),			//# On a slope with left foot 12 higher than right
+	ENUM2STRING(LEGS_LEFTUP4),			//# On a slope with left foot 16 higher than right
+	ENUM2STRING(LEGS_LEFTUP5),			//# On a slope with left foot 20 higher than right
+	ENUM2STRING(LEGS_RIGHTUP1),			//# On a slope with RIGHT foot 4 higher than left
+	ENUM2STRING(LEGS_RIGHTUP2),			//# On a slope with RIGHT foot 8 higher than left
+	ENUM2STRING(LEGS_RIGHTUP3),			//# On a slope with RIGHT foot 12 higher than left
+	ENUM2STRING(LEGS_RIGHTUP4),			//# On a slope with RIGHT foot 16 higher than left
+	ENUM2STRING(LEGS_RIGHTUP5),			//# On a slope with RIGHT foot 20 higher than left
+	ENUM2STRING(LEGS_S1_LUP1),
+	ENUM2STRING(LEGS_S1_LUP2),
+	ENUM2STRING(LEGS_S1_LUP3),
+	ENUM2STRING(LEGS_S1_LUP4),
+	ENUM2STRING(LEGS_S1_LUP5),
+	ENUM2STRING(LEGS_S1_RUP1),
+	ENUM2STRING(LEGS_S1_RUP2),
+	ENUM2STRING(LEGS_S1_RUP3),
+	ENUM2STRING(LEGS_S1_RUP4),
+	ENUM2STRING(LEGS_S1_RUP5),
+	ENUM2STRING(LEGS_S3_LUP1),
+	ENUM2STRING(LEGS_S3_LUP2),
+	ENUM2STRING(LEGS_S3_LUP3),
+	ENUM2STRING(LEGS_S3_LUP4),
+	ENUM2STRING(LEGS_S3_LUP5),
+	ENUM2STRING(LEGS_S3_RUP1),
+	ENUM2STRING(LEGS_S3_RUP2),
+	ENUM2STRING(LEGS_S3_RUP3),
+	ENUM2STRING(LEGS_S3_RUP4),
+	ENUM2STRING(LEGS_S3_RUP5),
+	ENUM2STRING(LEGS_S4_LUP1),
+	ENUM2STRING(LEGS_S4_LUP2),
+	ENUM2STRING(LEGS_S4_LUP3),
+	ENUM2STRING(LEGS_S4_LUP4),
+	ENUM2STRING(LEGS_S4_LUP5),
+	ENUM2STRING(LEGS_S4_RUP1),
+	ENUM2STRING(LEGS_S4_RUP2),
+	ENUM2STRING(LEGS_S4_RUP3),
+	ENUM2STRING(LEGS_S4_RUP4),
+	ENUM2STRING(LEGS_S4_RUP5),
+	ENUM2STRING(LEGS_S5_LUP1),
+	ENUM2STRING(LEGS_S5_LUP2),
+	ENUM2STRING(LEGS_S5_LUP3),
+	ENUM2STRING(LEGS_S5_LUP4),
+	ENUM2STRING(LEGS_S5_LUP5),
+	ENUM2STRING(LEGS_S5_RUP1),
+	ENUM2STRING(LEGS_S5_RUP2),
+	ENUM2STRING(LEGS_S5_RUP3),
+	ENUM2STRING(LEGS_S5_RUP4),
+	ENUM2STRING(LEGS_S5_RUP5),
+	ENUM2STRING(LEGS_S6_LUP1),
+	ENUM2STRING(LEGS_S6_LUP2),
+	ENUM2STRING(LEGS_S6_LUP3),
+	ENUM2STRING(LEGS_S6_LUP4),
+	ENUM2STRING(LEGS_S6_LUP5),
+	ENUM2STRING(LEGS_S6_RUP1),
+	ENUM2STRING(LEGS_S6_RUP2),
+	ENUM2STRING(LEGS_S6_RUP3),
+	ENUM2STRING(LEGS_S6_RUP4),
+	ENUM2STRING(LEGS_S6_RUP5),
+	ENUM2STRING(LEGS_S7_LUP1),
+	ENUM2STRING(LEGS_S7_LUP2),
+	ENUM2STRING(LEGS_S7_LUP3),
+	ENUM2STRING(LEGS_S7_LUP4),
+	ENUM2STRING(LEGS_S7_LUP5),
+	ENUM2STRING(LEGS_S7_RUP1),
+	ENUM2STRING(LEGS_S7_RUP2),
+	ENUM2STRING(LEGS_S7_RUP3),
+	ENUM2STRING(LEGS_S7_RUP4),
+	ENUM2STRING(LEGS_S7_RUP5),
+
+	//New anim as per Jarrod's request
+	ENUM2STRING(LEGS_TURN180),
+
+	//======================================================
+	//cinematic anims
+	//======================================================
+	//# #sep BOTH_ CINEMATIC-ONLY
+	ENUM2STRING(BOTH_CIN_1),		//# Level specific cinematic 1
+	ENUM2STRING(BOTH_CIN_2),		//# Level specific cinematic 2
+	ENUM2STRING(BOTH_CIN_3),		//# Level specific cinematic 3
+	ENUM2STRING(BOTH_CIN_4),		//# Level specific cinematic 4
+	ENUM2STRING(BOTH_CIN_5),		//# Level specific cinematic 5
+	ENUM2STRING(BOTH_CIN_6),		//# Level specific cinematic 6
+	ENUM2STRING(BOTH_CIN_7),		//# Level specific cinematic 7
+	ENUM2STRING(BOTH_CIN_8),		//# Level specific cinematic 8
+	ENUM2STRING(BOTH_CIN_9),		//# Level specific cinematic 9
+	ENUM2STRING(BOTH_CIN_10),		//# Level specific cinematic 10
+	ENUM2STRING(BOTH_CIN_11),		//# Level specific cinematic 11
+	ENUM2STRING(BOTH_CIN_12),		//# Level specific cinematic 12
+	ENUM2STRING(BOTH_CIN_13),		//# Level specific cinematic 13
+	ENUM2STRING(BOTH_CIN_14),		//# Level specific cinematic 14
+	ENUM2STRING(BOTH_CIN_15),		//# Level specific cinematic 15
+	ENUM2STRING(BOTH_CIN_16),		//# Level specific cinematic 16
+	ENUM2STRING(BOTH_CIN_17),		//# Level specific cinematic 17
+	ENUM2STRING(BOTH_CIN_18),		//# Level specific cinematic 18
+	ENUM2STRING(BOTH_CIN_19),		//# Level specific cinematic 19
+	ENUM2STRING(BOTH_CIN_20),		//# Level specific cinematic 20
+	ENUM2STRING(BOTH_CIN_21),		//# Level specific cinematic 21
+	ENUM2STRING(BOTH_CIN_22),		//# Level specific cinematic 22
+	ENUM2STRING(BOTH_CIN_23),		//# Level specific cinematic 23
+	ENUM2STRING(BOTH_CIN_24),		//# Level specific cinematic 24
+	ENUM2STRING(BOTH_CIN_25),		//# Level specific cinematic 25
+
+	ENUM2STRING(BOTH_CIN_26),		//# Level specific cinematic
+	ENUM2STRING(BOTH_CIN_27),		//# Level specific cinematic
+	ENUM2STRING(BOTH_CIN_28),		//# Level specific cinematic
+	ENUM2STRING(BOTH_CIN_29),		//# Level specific cinematic
+	ENUM2STRING(BOTH_CIN_30),		//# Level specific cinematic
+	ENUM2STRING(BOTH_CIN_31),		//# Level specific cinematic
+	ENUM2STRING(BOTH_CIN_32),		//# Level specific cinematic
+	ENUM2STRING(BOTH_CIN_33),		//# Level specific cinematic
+	ENUM2STRING(BOTH_CIN_34),		//# Level specific cinematic
+	ENUM2STRING(BOTH_CIN_35),		//# Level specific cinematic
+	ENUM2STRING(BOTH_CIN_36),		//# Level specific cinematic
+	ENUM2STRING(BOTH_CIN_37),		//# Level specific cinematic
+	ENUM2STRING(BOTH_CIN_38),		//# Level specific cinematic
+	ENUM2STRING(BOTH_CIN_39),		//# Level specific cinematic
+	ENUM2STRING(BOTH_CIN_40),		//# Level specific cinematic
+	ENUM2STRING(BOTH_CIN_41),		//# Level specific cinematic
+	ENUM2STRING(BOTH_CIN_42),		//# Level specific cinematic
+	ENUM2STRING(BOTH_CIN_43),		//# Level specific cinematic
+	ENUM2STRING(BOTH_CIN_44),		//# Level specific cinematic
+	ENUM2STRING(BOTH_CIN_45),		//# Level specific cinematic
+	ENUM2STRING(BOTH_CIN_46),		//# Level specific cinematic
+	ENUM2STRING(BOTH_CIN_47),		//# Level specific cinematic
+	ENUM2STRING(BOTH_CIN_48),		//# Level specific cinematic
+	ENUM2STRING(BOTH_CIN_49),		//# Level specific cinematic
+	ENUM2STRING(BOTH_CIN_50),		//# Level specific cinematic
+										
+	//must be terminated
+	NULL,-1
+};
+#endif	// _XBOX / _UI
diff --git a/code/cgame/cg_camera.cpp b/code/cgame/cg_camera.cpp
new file mode 100644
index 0000000..c0a3e9a
--- /dev/null
+++ b/code/cgame/cg_camera.cpp
@@ -0,0 +1,1955 @@
+//Client camera controls for cinematics
+
+// this line must stay at top so the whole PCH thing works...
+#include "cg_headers.h"
+
+#include "cg_media.h"
+
+#include "..\game\g_roff.h"
+
+bool		in_camera = false;
+camera_t	client_camera={0};
+extern qboolean	player_locked;
+
+extern gentity_t *G_Find (gentity_t *from, int fieldofs, const char *match);
+extern void G_UseTargets (gentity_t *ent, gentity_t *activator);
+void CGCam_FollowDisable( void );
+void CGCam_TrackDisable( void );
+void CGCam_Distance( float distance, qboolean initLerp );
+void CGCam_DistanceDisable( void );
+extern int CG_CalcFOVFromX( float fov_x );
+extern void WP_SaberCatch( gentity_t *self, gentity_t *saber, qboolean switchToSaber );
+
+/*
+TODO:
+CloseUp, FullShot & Longshot commands:
+
+  camera( CLOSEUP, <entity targetname>, angles(pitch yaw roll) )
+  Will find the ent, apply angle offset to their head forward(minus pitch),
+  get a preset distance away and set the FOV.  Trace to point, if less than
+  1.0, put it there and open up FOV accordingly.
+  Be sure to frame it so that eyespot and tag_head are positioned at proper
+  places in the frame - ie: eyespot not in center, but not closer than 1/4
+  screen width to the top...?
+*/
+/*
+-------------------------
+CGCam_Init
+-------------------------
+*/
+
+void CGCam_Init( void )
+{
+	extern qboolean qbVidRestartOccured;
+	if (!qbVidRestartOccured)
+	{
+		memset( &client_camera, 0, sizeof ( camera_t ) );
+	}
+}
+
+#ifdef _XBOX
+void CGCam_SetWidescreen( qboolean widescreen )
+{
+	client_camera.widescreen = widescreen;
+	cg.widescreen = widescreen;
+}
+#endif
+
+/*
+-------------------------
+CGCam_Enable
+-------------------------
+*/
+extern void CG_CalcVrect(void);
+void CGCam_Enable( void )
+{
+	client_camera.bar_alpha = 0.0f;
+	client_camera.bar_time = cg.time;
+
+	client_camera.bar_alpha_source = 0.0f;
+	client_camera.bar_alpha_dest = 1.0f;
+	
+	client_camera.bar_height_source = 0.0f;
+	client_camera.bar_height_dest = 480/10;
+	client_camera.bar_height = 0.0f;
+
+	client_camera.info_state |= CAMERA_BAR_FADING;
+
+	client_camera.FOV	= CAMERA_DEFAULT_FOV;
+	client_camera.FOV2	= CAMERA_DEFAULT_FOV;
+
+	in_camera = true;
+
+	client_camera.next_roff_time = 0;
+
+	if ( &g_entities[0] && g_entities[0].client )
+	{
+		//Player zero not allowed to do anything
+		VectorClear( g_entities[0].client->ps.velocity );
+		g_entities[0].contents = 0;
+
+		if ( cg.zoomMode )
+		{
+			// need to shut off some form of zooming
+			cg.zoomMode = 0;
+		}
+
+		if ( g_entities[0].client->ps.saberInFlight && g_entities[0].client->ps.saber[0].Active() )
+		{//saber is out
+			gentity_t *saberent = &g_entities[g_entities[0].client->ps.saberEntityNum];
+			if ( saberent )
+			{
+				WP_SaberCatch( &g_entities[0], saberent, qfalse );
+			}
+		}
+
+		for ( int i = 0; i < NUM_FORCE_POWERS; i++ )
+		{//deactivate any active force powers
+			g_entities[0].client->ps.forcePowerDuration[i] = 0;
+extern void WP_ForcePowerStop( gentity_t *self, forcePowers_t forcePower );
+			if ( g_entities[0].client->ps.forcePowerDuration[i] || (g_entities[0].client->ps.forcePowersActive&( 1 << i )) )
+			{
+				WP_ForcePowerStop( &g_entities[0], (forcePowers_t)i );
+			}
+		}
+	}
+}
+/*
+-------------------------
+CGCam_Disable
+-------------------------
+*/
+
+void CGCam_Disable( void )
+{
+	in_camera = false;
+
+	client_camera.bar_alpha = 1.0f;
+	client_camera.bar_time = cg.time;
+
+	client_camera.bar_alpha_source = 1.0f;
+	client_camera.bar_alpha_dest = 0.0f;
+	
+	client_camera.bar_height_source = 480/10;
+	client_camera.bar_height_dest = 0.0f;
+
+	client_camera.info_state |= CAMERA_BAR_FADING;
+
+	if ( &g_entities[0] && g_entities[0].client )
+	{
+		g_entities[0].contents = CONTENTS_BODY;//MASK_PLAYERSOLID;
+	}
+
+	gi.SendServerCommand( NULL, "cts");
+
+	//if ( cg_skippingcin.integer )
+	{//We're skipping the cinematic and it's over now
+		gi.cvar_set("timescale", "1");
+		gi.cvar_set("skippingCinematic", "0");
+	}
+
+	//we just came out of camera, so update cg.refdef.vieworg out of the camera's origin so the snapshot will know our new ori
+	VectorCopy( g_entities[0].currentOrigin, cg.refdef.vieworg);
+	VectorCopy( g_entities[0].client->ps.viewangles, cg.refdefViewAngles );
+}
+
+/*
+-------------------------
+CGCam_SetPosition
+-------------------------
+*/
+
+void CGCam_SetPosition( vec3_t org )
+{
+	VectorCopy( org, client_camera.origin );
+	VectorCopy( client_camera.origin, cg.refdef.vieworg );
+}
+
+/*
+-------------------------
+CGCam_Move
+-------------------------
+*/
+
+void CGCam_Move( vec3_t dest, float duration )
+{
+	if ( client_camera.info_state & CAMERA_ROFFING )
+	{
+		client_camera.info_state &= ~CAMERA_ROFFING;
+	}
+
+	CGCam_TrackDisable();
+	CGCam_DistanceDisable();
+
+	if ( !duration )
+	{
+		client_camera.info_state &= ~CAMERA_MOVING;
+		CGCam_SetPosition( dest );
+		return;
+	}
+
+	client_camera.info_state |= CAMERA_MOVING;
+
+	VectorCopy( dest, client_camera.origin2 );
+	
+	client_camera.move_duration = duration;
+	client_camera.move_time = cg.time;
+}
+
+/*
+-------------------------
+CGCam_SetAngles
+-------------------------
+*/
+
+void CGCam_SetAngles( vec3_t ang )
+{
+	VectorCopy( ang, client_camera.angles );
+	VectorCopy(client_camera.angles, cg.refdefViewAngles );
+}
+
+/*
+-------------------------
+CGCam_Pan
+-------------------------
+*/
+
+void CGCam_Pan( vec3_t dest, vec3_t panDirection, float duration )
+{
+	//vec3_t	panDirection = {0, 0, 0};
+	int		i;
+	float	delta1 , delta2;
+
+	CGCam_FollowDisable();
+	CGCam_DistanceDisable();
+
+	if ( !duration )
+	{
+		CGCam_SetAngles( dest );
+		client_camera.info_state &= ~CAMERA_PANNING;
+		return;
+	}
+
+	//FIXME: make the dest an absolute value, and pass in a
+	//panDirection as well.  If a panDirection's axis value is
+	//zero, find the shortest difference for that axis.
+	//Store the delta in client_camera.angles2. 
+	for( i = 0; i < 3; i++ )
+	{
+		dest[i] = AngleNormalize360( dest[i] );
+		delta1 = dest[i] - AngleNormalize360( client_camera.angles[i] );
+		if ( delta1 < 0 )
+		{
+			delta2 = delta1 + 360;
+		}
+		else
+		{
+			delta2 = delta1 - 360;
+		}
+		if ( !panDirection[i] )
+		{//Didn't specify a direction, pick shortest
+			if( Q_fabs(delta1) < Q_fabs(delta2) )
+			{
+				client_camera.angles2[i] = delta1;
+			}
+			else
+			{
+				client_camera.angles2[i] = delta2;
+			}
+		}
+		else if ( panDirection[i] < 0 )
+		{
+			if( delta1 < 0 )
+			{
+				client_camera.angles2[i] = delta1;
+			}
+			else if( delta1 > 0 )
+			{
+				client_camera.angles2[i] = delta2;
+			}
+			else
+			{//exact
+				client_camera.angles2[i] = 0;
+			}
+		}
+		else if ( panDirection[i] > 0 )
+		{
+			if( delta1 > 0 )
+			{
+				client_camera.angles2[i] = delta1;
+			}
+			else if( delta1 < 0 )
+			{
+				client_camera.angles2[i] = delta2;
+			}
+			else
+			{//exact
+				client_camera.angles2[i] = 0;
+			}
+		}
+	}
+	//VectorCopy( dest, client_camera.angles2 );
+
+	client_camera.info_state |= CAMERA_PANNING;
+	
+	client_camera.pan_duration = duration;
+	client_camera.pan_time = cg.time;
+}
+
+/*
+-------------------------
+CGCam_SetRoll
+-------------------------
+*/
+
+void CGCam_SetRoll( float roll )
+{
+	client_camera.angles[2] = roll;
+}
+
+/*
+-------------------------
+CGCam_Roll
+-------------------------
+*/
+
+void CGCam_Roll( float	dest, float duration )
+{
+	if ( !duration )
+	{
+		CGCam_SetRoll( dest );
+		return;
+	}
+
+	//FIXME/NOTE: this will override current panning!!!
+	client_camera.info_state |= CAMERA_PANNING;
+	
+	VectorCopy( client_camera.angles, client_camera.angles2 );
+	client_camera.angles2[2] = AngleDelta( dest, client_camera.angles[2] );
+	
+	client_camera.pan_duration = duration;
+	client_camera.pan_time = cg.time;
+}
+
+/*
+-------------------------
+CGCam_SetFOV
+-------------------------
+*/
+
+void CGCam_SetFOV( float FOV )
+{
+	client_camera.FOV = FOV;
+}
+
+/*
+-------------------------
+CGCam_Zoom
+-------------------------
+*/
+
+void CGCam_Zoom( float FOV, float duration )
+{
+	if ( !duration )
+	{
+		CGCam_SetFOV( FOV );
+		return;
+	}
+	client_camera.info_state |= CAMERA_ZOOMING;
+
+	client_camera.FOV_time	= cg.time;
+	client_camera.FOV2		= FOV;
+
+	client_camera.FOV_duration = duration;
+}
+
+void CGCam_Zoom2( float FOV, float FOV2, float duration )
+{
+	if ( !duration )
+	{
+		CGCam_SetFOV( FOV2 );
+		return;
+	}
+	client_camera.info_state |= CAMERA_ZOOMING;
+
+	client_camera.FOV_time	= cg.time;
+	client_camera.FOV = FOV;
+	client_camera.FOV2		= FOV2;
+
+	client_camera.FOV_duration = duration;
+}
+
+void CGCam_ZoomAccel( float initialFOV, float fovVelocity, float fovAccel, float duration)
+{
+	if ( !duration )
+	{
+		return;
+	}
+	client_camera.info_state |= CAMERA_ACCEL;
+
+	client_camera.FOV_time	= cg.time;
+	client_camera.FOV2 = initialFOV;
+	client_camera.FOV_vel = fovVelocity;
+	client_camera.FOV_acc = fovAccel;
+
+	client_camera.FOV_duration = duration;
+}
+
+/*
+-------------------------
+CGCam_Fade
+-------------------------
+*/
+
+void CGCam_SetFade( vec4_t dest )
+{//Instant completion
+	client_camera.info_state &= ~CAMERA_FADING;
+	client_camera.fade_duration = 0;
+	Vector4Copy( dest, client_camera.fade_source );
+	Vector4Copy( dest, client_camera.fade_color );
+}
+
+/*
+-------------------------
+CGCam_Fade
+-------------------------
+*/
+
+void CGCam_Fade( vec4_t source, vec4_t dest, float duration )
+{
+	if ( !duration )
+	{
+		CGCam_SetFade( dest );
+		return;
+	}
+
+	Vector4Copy( source, client_camera.fade_source );
+	Vector4Copy( dest, client_camera.fade_dest );
+
+	client_camera.fade_duration = duration;
+	client_camera.fade_time = cg.time;
+
+	client_camera.info_state |= CAMERA_FADING;
+}
+
+void CGCam_FollowDisable( void )
+{
+	client_camera.info_state &= ~CAMERA_FOLLOWING;
+	client_camera.cameraGroup[0] = 0;
+	client_camera.cameraGroupZOfs = 0;
+	client_camera.cameraGroupTag[0] = 0;
+}
+
+void CGCam_TrackDisable( void )
+{
+	client_camera.info_state &= ~CAMERA_TRACKING;
+	client_camera.trackEntNum = ENTITYNUM_WORLD;
+}
+
+void CGCam_DistanceDisable( void )
+{
+	client_camera.distance = 0;
+}
+/*
+-------------------------
+CGCam_Follow
+-------------------------
+*/
+
+void CGCam_Follow( const char *cameraGroup, float speed, float initLerp )
+{
+	int len;
+
+	//Clear any previous
+	CGCam_FollowDisable();
+
+	if(!cameraGroup || !cameraGroup[0])
+	{
+		return;
+	}
+
+	if ( Q_stricmp("none", (char *)cameraGroup) == 0 )
+	{//Turn off all aiming
+		return;
+	}
+	
+	if ( Q_stricmp("NULL", (char *)cameraGroup) == 0 )
+	{//Turn off all aiming
+		return;
+	}
+
+	//NOTE: if this interrupts a pan before it's done, need to copy the cg.refdef.viewAngles to the camera.angles!
+	client_camera.info_state |= CAMERA_FOLLOWING;
+	client_camera.info_state &= ~CAMERA_PANNING;
+
+	len = strlen(cameraGroup);
+	strncpy( client_camera.cameraGroup, cameraGroup, sizeof(client_camera.cameraGroup) );
+	//NULL terminate last char in case they type a name too long
+	client_camera.cameraGroup[len] = 0;
+
+	if ( speed )
+	{
+		client_camera.followSpeed = speed;
+	}
+	else
+	{
+		client_camera.followSpeed = 100.0f;
+	}
+
+	if ( initLerp )
+	{
+		client_camera.followInitLerp = qtrue;
+	}
+	else
+	{
+		client_camera.followInitLerp = qfalse;
+	}
+}
+
+/*
+-------------------------
+Q3_CameraAutoAim
+
+  Keeps camera pointed at an entity, usually will be a misc_camera_focus
+  misc_camera_focus can be on a track that stays closest to it's subjects on that
+  path (like Q3_CameraAutoTrack) or is can simply always put itself between it's subjects.
+  misc_camera_focus can also set FOV/camera dist needed to keep the subjects in frame
+-------------------------
+*/
+
+void CG_CameraAutoAim( const char *name )
+{
+	/*
+	gentity_t *aimEnt = NULL;
+
+	//Clear any previous
+	CGCam_FollowDisable();
+
+	if(Q_stricmp("none", (char *)name) == 0)
+	{//Turn off all aiming
+		return;
+	}
+
+	aimEnt = G_Find(NULL, FOFS(targetname), (char *)name);
+
+	if(!aimEnt)
+	{
+		gi.Printf(S_COLOR_RED"ERROR: %s camera aim target not found\n", name);
+		return;
+	}
+
+	//Lerp time...
+	//aimEnt->aimDebounceTime = level.time;//FIXME: over time
+	client_camera.aimEntNum = aimEnt->s.number;
+	CGCam_Follow( aimEnt->cameraGroup, aimEnt->speed, aimEnt->spawnflags&1 );
+	*/
+}
+
+/*
+-------------------------
+CGCam_Track
+-------------------------
+*/
+//void CGCam_Track( char *trackName, float speed, float duration )
+void CGCam_Track( const char *trackName, float speed, float initLerp )
+{
+	gentity_t	*trackEnt = NULL;
+
+	CGCam_TrackDisable();
+
+	if(Q_stricmp("none", (char *)trackName) == 0)
+	{//turn off tracking
+		return;
+	}
+
+	//NOTE: if this interrupts a move before it's done, need to copy the cg.refdef.vieworg to the camera.origin!
+	//This will find a path_corner now, not a misc_camera_track
+	trackEnt = G_Find(NULL, FOFS(targetname), (char *)trackName);
+
+	if ( !trackEnt )
+	{
+		gi.Printf(S_COLOR_RED"ERROR: %s camera track target not found\n", trackName);
+		return;
+	}
+
+	client_camera.info_state |= CAMERA_TRACKING;
+	client_camera.info_state &= ~CAMERA_MOVING;
+
+	client_camera.trackEntNum = trackEnt->s.number;
+	client_camera.initSpeed = speed/10.0f;
+	client_camera.speed = speed;
+	client_camera.nextTrackEntUpdateTime = cg.time;
+
+	if ( initLerp )
+	{
+		client_camera.trackInitLerp = qtrue;
+	}
+	else
+	{
+		client_camera.trackInitLerp = qfalse;
+	}
+	/*
+	if ( client_camera.info_state & CAMERA_FOLLOWING )
+	{//Used to snap angles?  Do what...?
+	}
+	*/
+
+	//Set a moveDir
+	VectorSubtract( trackEnt->currentOrigin, client_camera.origin, client_camera.moveDir );
+
+	if ( !client_camera.trackInitLerp )
+	{//want to snap to first position
+		//Snap to trackEnt's origin
+		VectorCopy( trackEnt->currentOrigin, client_camera.origin );
+
+		//Set new moveDir if trackEnt has a next path_corner
+		//Possible that track has no next point, in which case we won't be moving anyway
+		if ( trackEnt->target && trackEnt->target[0] )
+		{
+			gentity_t *newTrackEnt = G_Find( NULL, FOFS(targetname), trackEnt->target );
+			if ( newTrackEnt )
+			{
+				VectorSubtract( newTrackEnt->currentOrigin, client_camera.origin, client_camera.moveDir );
+			}
+		}
+	}
+
+	VectorNormalize( client_camera.moveDir );
+}
+
+/*
+-------------------------
+Q3_CameraAutoTrack
+
+  Keeps camera a certain distance from target entity but on the specified CameraPath
+  The distance can be set in a script or derived from a misc_camera_focus.
+  Dist will interpolate when changed, can also set acceleration/deceleration values.
+  FOV will also interpolate.
+
+  CameraPath might be a MAX path or perhaps a series of path_corners on the map itself
+-------------------------
+*/
+
+void CG_CameraAutoTrack( const char *name )
+{
+	/*
+	gentity_t *trackEnt = NULL;
+
+	CGCam_TrackDisable();
+
+	if(Q_stricmp("none", (char *)name) == 0)
+	{//turn off tracking
+		return;
+	}
+
+	//This will find a path_corner now, not a misc_camera_track
+	trackEnt = G_Find(NULL, FOFS(targetname), (char *)name);
+
+	if(!trackEnt)
+	{
+		gi.Printf(S_COLOR_RED"ERROR: %s camera track target not found\n", name);
+		return;
+	}
+
+	//FIXME: last arg will be passed in
+	CGCam_Track( trackEnt->s.number, trackEnt->speed, qfalse );
+	//FIXME: this will be a seperate call
+	CGCam_Distance( trackEnt->radius, qtrue);
+	*/
+}
+
+/*
+-------------------------
+CGCam_Distance
+-------------------------
+*/
+
+void CGCam_Distance( float distance, float initLerp )
+{
+	client_camera.distance = distance;
+
+	if ( initLerp )
+	{
+		client_camera.distanceInitLerp = qtrue;
+	}
+	else
+	{
+		client_camera.distanceInitLerp = qfalse;
+	}
+}
+
+//========================================================================================
+
+
+void CGCam_FollowUpdate ( void )
+{
+	vec3_t		center, dir, cameraAngles, vec, focus[MAX_CAMERA_GROUP_SUBJECTS];//No more than 16 subjects in a cameraGroup
+	gentity_t	*from = NULL;
+	centity_t	*fromCent = NULL;
+	int			num_subjects = 0, i;
+	qboolean	focused = qfalse;
+	
+	if ( client_camera.cameraGroup && client_camera.cameraGroup[0] )
+	{
+		//Stay centered in my cameraGroup, if I have one
+		while( NULL != (from = G_Find(from, FOFS(cameraGroup), client_camera.cameraGroup)))
+		{
+			/*
+			if ( from->s.number == client_camera.aimEntNum )
+			{//This is the misc_camera_focus, we'll be removing this ent altogether eventually
+				continue;
+			}
+			*/
+
+			if ( num_subjects >= MAX_CAMERA_GROUP_SUBJECTS )
+			{
+				gi.Printf(S_COLOR_RED"ERROR: Too many subjects in shot composition %s", client_camera.cameraGroup);
+				break;
+			}
+
+			fromCent = &cg_entities[from->s.number];
+			if ( !fromCent )
+			{
+				continue;
+			}
+
+			focused = qfalse;
+			if ( from->client && client_camera.cameraGroupTag && client_camera.cameraGroupTag[0] && fromCent->gent->ghoul2.size() )
+			{
+				int newBolt = gi.G2API_AddBolt( &fromCent->gent->ghoul2[from->playerModel], client_camera.cameraGroupTag );
+				if ( newBolt != -1 )
+				{
+					mdxaBone_t	boltMatrix;
+					vec3_t	fromAngles = {0,from->client->ps.legsYaw,0};
+
+					gi.G2API_GetBoltMatrix( fromCent->gent->ghoul2, from->playerModel, newBolt, &boltMatrix, fromAngles, fromCent->lerpOrigin, cg.time, cgs.model_draw, fromCent->currentState.modelScale );
+					gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, focus[num_subjects] );
+
+					focused = qtrue;
+				}
+			}
+			if ( !focused )
+			{
+				if ( from->s.pos.trType != TR_STATIONARY )
+//				if ( from->s.pos.trType == TR_INTERPOLATE )
+				{//use interpolated origin?
+					if ( !VectorCompare( vec3_origin, fromCent->lerpOrigin ) )
+					{//hunh?  Somehow we've never seen this gentity on the client, so there is no lerpOrigin, so cheat over to the game and use the currentOrigin
+						VectorCopy( from->currentOrigin, focus[num_subjects] );
+					}
+					else
+					{
+						VectorCopy( fromCent->lerpOrigin, focus[num_subjects] );
+					}
+				}
+				else
+				{
+					VectorCopy(from->currentOrigin, focus[num_subjects]);
+				} 
+				//FIXME: make a list here of their s.numbers instead so we can do other stuff with the list below
+				if ( from->client )
+				{//Track to their eyes - FIXME: maybe go off a tag?
+					//FIXME: 
+					//Based on FOV and distance to subject from camera, pick the point that
+					//keeps eyes 3/4 up from bottom of screen... what about bars?
+					focus[num_subjects][2] += from->client->ps.viewheight;
+				}
+			}
+			if ( client_camera.cameraGroupZOfs )
+			{
+				focus[num_subjects][2] += client_camera.cameraGroupZOfs;
+			}
+			num_subjects++;
+		}
+
+		if ( !num_subjects )	// Bad cameragroup 
+		{
+#ifndef FINAL_BUILD
+			gi.Printf(S_COLOR_RED"ERROR: Camera Focus unable to locate cameragroup: %s\n", client_camera.cameraGroup);
+#endif
+			return;
+		}
+
+		//Now average all points
+		VectorCopy( focus[0], center );
+		for( i = 1; i < num_subjects; i++ )
+		{
+			VectorAdd( focus[i], center, center );
+		}
+		VectorScale( center, 1.0f/((float)num_subjects), center );
+	}
+	else
+	{
+		return;
+	}
+
+	//Need to set a speed to keep a distance from
+	//the subject- fixme: only do this if have a distance
+	//set
+	VectorSubtract( client_camera.subjectPos, center, vec );
+	client_camera.subjectSpeed = VectorLengthSquared( vec ) * 100.0f / cg.frametime;
+
+	/*
+	if ( !cg_skippingcin.integer )
+	{
+		Com_Printf( S_COLOR_RED"org: %s\n", vtos(center) );
+	}
+	*/
+	VectorCopy( center, client_camera.subjectPos );
+
+	VectorSubtract( center, cg.refdef.vieworg, dir );//can't use client_camera.origin because it's not updated until the end of the move.
+
+	//Get desired angle
+	vectoangles(dir, cameraAngles);
+	
+	if ( client_camera.followInitLerp )
+	{//Lerping
+		float frac = cg.frametime/100.0f * client_camera.followSpeed/100.f;
+		for( i = 0; i < 3; i++ )
+		{
+			cameraAngles[i] = AngleNormalize180( cameraAngles[i] );
+			cameraAngles[i] = AngleNormalize180( client_camera.angles[i] + frac * AngleNormalize180(cameraAngles[i] - client_camera.angles[i]) );
+			cameraAngles[i] = AngleNormalize180( cameraAngles[i] );
+		}
+#if 0
+		Com_Printf( "%s\n", vtos(cameraAngles) );
+#endif
+	}
+	else
+	{//Snapping, should do this first time if follow_lerp_to_start_duration is zero
+		//will lerp from this point on
+		client_camera.followInitLerp = qtrue;
+		for( i = 0; i < 3; i++ )
+		{//normalize so that when we start lerping, it doesn't freak out
+			cameraAngles[i] = AngleNormalize180( cameraAngles[i] );
+		}
+		//So tracker doesn't move right away thinking the first angle change
+		//is the subject moving... FIXME: shouldn't set this until lerp done OR snapped?
+		client_camera.subjectSpeed = 0;
+	}
+
+	//Point camera to lerp angles
+	/*
+	if ( !cg_skippingcin.integer )
+	{
+		Com_Printf( "ang: %s\n", vtos(cameraAngles) );
+	}
+	*/
+	VectorCopy( cameraAngles, client_camera.angles );
+}
+
+void CGCam_TrackEntUpdate ( void )
+{//FIXME: only do every 100 ms
+	gentity_t	*trackEnt = NULL;
+	gentity_t	*newTrackEnt = NULL;
+	qboolean	reached = qfalse;
+	vec3_t		vec;
+	float		dist;
+
+	if ( client_camera.trackEntNum >= 0 && client_camera.trackEntNum < ENTITYNUM_WORLD )
+	{//We're already heading to a path_corner
+		trackEnt = &g_entities[client_camera.trackEntNum];
+		VectorSubtract( trackEnt->currentOrigin, client_camera.origin, vec );
+		dist = VectorLengthSquared( vec );
+		if ( dist < 256 )//16 squared
+		{//FIXME: who should be doing the using here?
+			G_UseTargets( trackEnt, trackEnt );
+			reached = qtrue;
+		}
+	}
+	
+	if ( trackEnt && reached )
+	{
+		
+		if ( trackEnt->target && trackEnt->target[0] )
+		{//Find our next path_corner
+			newTrackEnt = G_Find( NULL, FOFS(targetname), trackEnt->target );
+			if ( newTrackEnt )
+			{
+				if ( newTrackEnt->radius < 0 )
+				{//Don't bother trying to maintain a radius
+					client_camera.distance = 0;
+					client_camera.speed = client_camera.initSpeed;
+				}
+				else if ( newTrackEnt->radius > 0 )
+				{
+					client_camera.distance = newTrackEnt->radius;
+				}
+
+				if ( newTrackEnt->speed < 0 )
+				{//go back to our default speed
+					client_camera.speed = client_camera.initSpeed;
+				}
+				else if ( newTrackEnt->speed > 0 )
+				{
+					client_camera.speed = newTrackEnt->speed/10.0f;
+				}
+			}
+		}
+		else
+		{//stop thinking if this is the last one
+			CGCam_TrackDisable();
+		}
+	}
+
+	if ( newTrackEnt )
+	{//Update will lerp this
+		client_camera.info_state |= CAMERA_TRACKING; 
+		client_camera.trackEntNum = newTrackEnt->s.number; 
+		VectorCopy( newTrackEnt->currentOrigin, client_camera.trackToOrg );
+	}
+
+	client_camera.nextTrackEntUpdateTime = cg.time + 100;
+}
+
+void CGCam_TrackUpdate ( void )
+{
+	vec3_t		goalVec, curVec, trackPos, vec;
+	float		goalDist, dist;
+	qboolean	slowDown = qfalse;
+
+	if ( client_camera.nextTrackEntUpdateTime <= cg.time )
+	{
+		CGCam_TrackEntUpdate();
+	}
+
+	VectorSubtract( client_camera.trackToOrg, client_camera.origin, goalVec );
+	goalDist = VectorNormalize( goalVec );
+	if ( goalDist > 100 )
+	{
+		goalDist = 100;
+	}
+	else if ( goalDist < 10 )
+	{
+		goalDist = 10;
+	}
+
+	if ( client_camera.distance && client_camera.info_state & CAMERA_FOLLOWING )
+	{
+		float	adjust = 0.0f, desiredSpeed = 0.0f;
+		float	dot;
+
+		if ( !client_camera.distanceInitLerp )
+		{
+			VectorSubtract( client_camera.origin, client_camera.subjectPos, vec );
+			VectorNormalize( vec );
+			//FIXME: use client_camera.moveDir here?
+			VectorMA( client_camera.subjectPos, client_camera.distance, vec, client_camera.origin );
+			//Snap to first time only
+			client_camera.distanceInitLerp = qtrue;
+			return;
+		}
+		else if ( client_camera.subjectSpeed > 0.05f )
+		{//Don't start moving until subject moves 
+			VectorSubtract( client_camera.subjectPos, client_camera.origin, vec );
+			dist = VectorNormalize(vec);
+			dot = DotProduct(goalVec, vec);
+
+			if ( dist > client_camera.distance )
+			{//too far away
+				if ( dot > 0 )
+				{//Camera is moving toward the subject
+					adjust = (dist - client_camera.distance);//Speed up
+				}
+				else if ( dot < 0 )
+				{//Camera is moving away from the subject
+					adjust = (dist - client_camera.distance) * -1.0f;//Slow down
+				}
+			}
+			else if ( dist < client_camera.distance )
+			{//too close
+				if(dot > 0)
+				{//Camera is moving toward the subject
+					adjust = (client_camera.distance - dist) * -1.0f;//Slow down
+				}
+				else if(dot < 0)
+				{//Camera is moving away from the subject
+					adjust = (client_camera.distance - dist);//Speed up
+				}
+			}
+			
+			//Speed of the focus + our error
+			//desiredSpeed = aimCent->gent->speed + (adjust * cg.frametime/100.0f);//cg.frameInterpolation);
+			desiredSpeed = (adjust);// * cg.frametime/100.0f);//cg.frameInterpolation);
+			
+			//self->moveInfo.speed = desiredSpeed;
+			
+			//Don't change speeds faster than 10 every 10th of a second
+			float	max_allowed_accel = MAX_ACCEL_PER_FRAME * (cg.frametime/100.0f);
+
+			if ( !client_camera.subjectSpeed )
+			{//full stop
+				client_camera.speed = desiredSpeed;
+			}
+			else if ( client_camera.speed - desiredSpeed > max_allowed_accel )
+			{//new speed much slower, slow down at max accel
+				client_camera.speed -= max_allowed_accel;
+			}
+			else if ( desiredSpeed - client_camera.speed > max_allowed_accel )
+			{//new speed much faster, speed up at max accel
+				client_camera.speed += max_allowed_accel;
+			}
+			else
+			{//remember this speed
+				client_camera.speed = desiredSpeed;
+			}
+
+			//Com_Printf("Speed: %4.2f (%4.2f)\n", self->moveInfo.speed, aimCent->gent->speed);
+		}
+	}
+	else
+	{
+		//slowDown = qtrue;
+	}
+	
+
+	//FIXME: this probably isn't right, round it out more
+	VectorScale( goalVec, cg.frametime/100.0f, goalVec );
+	VectorScale( client_camera.moveDir, (100.0f - cg.frametime)/100.0f, curVec );
+	VectorAdd( goalVec, curVec, client_camera.moveDir );
+	VectorNormalize( client_camera.moveDir );
+	if(slowDown)
+	{
+		VectorMA( client_camera.origin, client_camera.speed * goalDist/100.0f * cg.frametime/100.0f, client_camera.moveDir, trackPos );
+	}
+	else
+	{
+		VectorMA( client_camera.origin, client_camera.speed * cg.frametime/100.0f , client_camera.moveDir, trackPos );
+	}
+
+	//FIXME: Implement
+	//Need to find point on camera's path that is closest to the desired distance from subject
+	//OR: Need to intelligently pick this desired distance based on framing...
+	VectorCopy( trackPos, client_camera.origin );
+}
+
+//=========================================================================================
+
+/*
+-------------------------
+CGCam_UpdateBarFade
+-------------------------
+*/
+
+void CGCam_UpdateBarFade( void )
+{
+	if ( client_camera.bar_time + BAR_DURATION < cg.time )
+	{
+		client_camera.bar_alpha = client_camera.bar_alpha_dest;
+		client_camera.info_state &= ~CAMERA_BAR_FADING;
+		client_camera.bar_height = client_camera.bar_height_dest;
+	}
+	else
+	{
+		client_camera.bar_alpha  = client_camera.bar_alpha_source + ( ( client_camera.bar_alpha_dest - client_camera.bar_alpha_source ) / BAR_DURATION ) * ( cg.time - client_camera.bar_time );;
+		client_camera.bar_height = client_camera.bar_height_source + ( ( client_camera.bar_height_dest - client_camera.bar_height_source ) / BAR_DURATION ) * ( cg.time - client_camera.bar_time );;
+	}
+}
+
+/*
+-------------------------
+CGCam_UpdateFade
+-------------------------
+*/
+
+void CGCam_UpdateFade( void )
+{
+	if ( client_camera.info_state & CAMERA_FADING )
+	{
+		if ( client_camera.fade_time + client_camera.fade_duration < cg.time )
+		{
+			Vector4Copy( client_camera.fade_dest, client_camera.fade_color );
+			client_camera.info_state &= ~CAMERA_FADING;
+		}
+		else
+		{
+			for ( int i = 0; i < 4; i++ )
+			{
+				client_camera.fade_color[i] = client_camera.fade_source[i] + (( ( client_camera.fade_dest[i] - client_camera.fade_source[i] ) ) / client_camera.fade_duration ) * ( cg.time - client_camera.fade_time );
+			}
+		}
+	}
+}
+/*
+-------------------------
+CGCam_Update
+-------------------------
+*/
+static void CGCam_Roff( void );
+
+void CGCam_Update( void )
+{
+	int	i;
+	qboolean	checkFollow = qfalse;
+	qboolean	checkTrack = qfalse;
+
+	// Apply new roff data to the camera as needed
+	if ( client_camera.info_state & CAMERA_ROFFING )
+	{
+		CGCam_Roff();
+	}
+
+	//Check for a zoom
+	if (client_camera.info_state & CAMERA_ACCEL)
+	{
+		// x = x0 + vt + 0.5*a*t*t
+		float	actualFOV_X = client_camera.FOV;
+		float	sanityMin = 1, sanityMax = 180;
+		float	t = (cg.time - client_camera.FOV_time)*0.001; // mult by 0.001 cuz otherwise t is too darned big
+		float	fovDuration = client_camera.FOV_duration;
+
+#ifndef FINAL_BUILD
+		if (cg_roffval4.integer)
+		{
+			fovDuration = cg_roffval4.integer;
+		}
+#endif
+		if ( client_camera.FOV_time + fovDuration < cg.time )
+		{
+			client_camera.info_state &= ~CAMERA_ACCEL;
+		}
+		else
+		{
+			float	initialPosVal = client_camera.FOV2;
+			float	velVal = client_camera.FOV_vel;
+			float	accVal = client_camera.FOV_acc;
+
+#ifndef FINAL_BUILD
+			if (cg_roffdebug.integer)
+			{
+				if (fabs(cg_roffval1.value) > 0.001f)
+				{
+					initialPosVal = cg_roffval1.value;
+				}
+				if (fabs(cg_roffval2.value) > 0.001f)
+				{
+					velVal = cg_roffval2.value;
+				}
+				if (fabs(cg_roffval3.value) > 0.001f)
+				{
+					accVal = cg_roffval3.value;
+				}
+			}
+#endif
+			float	initialPos = initialPosVal;
+			float	vel = velVal*t;
+			float	acc = 0.5*accVal*t*t;
+
+			actualFOV_X = initialPos + vel + acc;
+			if (cg_roffdebug.integer)
+			{
+				Com_Printf("%d: fovaccel from %2.1f using vel = %2.4f, acc = %2.4f (current fov calc = %5.6f)\n",
+					cg.time, initialPosVal, velVal, accVal, actualFOV_X);
+			}
+
+			if (actualFOV_X < sanityMin)
+			{
+				actualFOV_X = sanityMin;
+			}
+			else if (actualFOV_X > sanityMax)
+			{
+				actualFOV_X = sanityMax;
+			}
+			client_camera.FOV = actualFOV_X;
+		}
+		CG_CalcFOVFromX( actualFOV_X );
+	}
+	else if ( client_camera.info_state & CAMERA_ZOOMING )
+	{
+		float	actualFOV_X;
+
+		if ( client_camera.FOV_time + client_camera.FOV_duration < cg.time )
+		{
+			actualFOV_X = client_camera.FOV = client_camera.FOV2;
+			client_camera.info_state &= ~CAMERA_ZOOMING;
+		}
+		else
+		{
+			actualFOV_X = client_camera.FOV + (( ( client_camera.FOV2 - client_camera.FOV ) ) / client_camera.FOV_duration ) * ( cg.time - client_camera.FOV_time );
+		}
+		CG_CalcFOVFromX( actualFOV_X );
+	}
+	else
+	{
+		CG_CalcFOVFromX( client_camera.FOV );
+	}
+
+	//Check for roffing angles
+	if ( (client_camera.info_state & CAMERA_ROFFING) && !(client_camera.info_state & CAMERA_FOLLOWING) )
+	{
+		if (client_camera.info_state & CAMERA_CUT)
+		{
+			// we're doing a cut, so just go to the new angles. none of this hifalutin lerping business.
+			for ( i = 0; i < 3; i++ )
+			{
+				cg.refdefViewAngles[i] = AngleNormalize360( ( client_camera.angles[i] + client_camera.angles2[i] ) );
+			}
+		}
+		else
+		{
+			for ( i = 0; i < 3; i++ )
+			{
+				cg.refdefViewAngles[i] =  client_camera.angles[i] + ( client_camera.angles2[i] / client_camera.pan_duration ) * ( cg.time - client_camera.pan_time );
+			}
+		}
+	}
+	else if ( client_camera.info_state & CAMERA_PANNING )
+	{
+		if (client_camera.info_state & CAMERA_CUT)
+		{
+			// we're doing a cut, so just go to the new angles. none of this hifalutin lerping business.
+			for ( i = 0; i < 3; i++ )
+			{
+				cg.refdefViewAngles[i] = AngleNormalize360( ( client_camera.angles[i] + client_camera.angles2[i] ) );
+			}
+		}
+		else
+		{
+			//Note: does not actually change the camera's angles until the pan time is done!
+			if ( client_camera.pan_time + client_camera.pan_duration < cg.time )
+			{//finished panning
+				for ( i = 0; i < 3; i++ )
+				{
+					client_camera.angles[i] = AngleNormalize360( ( client_camera.angles[i] + client_camera.angles2[i] ) );
+				}
+
+				client_camera.info_state &= ~CAMERA_PANNING;
+				VectorCopy(client_camera.angles, cg.refdefViewAngles );
+			}
+			else
+			{//still panning
+				for ( i = 0; i < 3; i++ )
+				{
+					//NOTE: does not store the resultant angle in client_camera.angles until pan is done
+					cg.refdefViewAngles[i] = client_camera.angles[i] + ( client_camera.angles2[i] / client_camera.pan_duration ) * ( cg.time - client_camera.pan_time );
+				}
+			}
+		}
+	}
+	else 
+	{
+		checkFollow = qtrue;
+	}
+
+	//Check for movement
+	if ( client_camera.info_state & CAMERA_MOVING )
+	{
+		//NOTE: does not actually move the camera until the movement time is done!
+		if ( client_camera.move_time + client_camera.move_duration < cg.time )
+		{
+			VectorCopy( client_camera.origin2, client_camera.origin );
+			client_camera.info_state &= ~CAMERA_MOVING;
+			VectorCopy( client_camera.origin, cg.refdef.vieworg );
+		}
+		else
+		{
+			if (client_camera.info_state & CAMERA_CUT)
+			{
+				// we're doing a cut, so just go to the new origin. none of this fancypants lerping stuff.
+				for ( i = 0; i < 3; i++ )
+				{
+					cg.refdef.vieworg[i] = client_camera.origin2[i];
+				}
+			}
+			else
+			{
+				for ( i = 0; i < 3; i++ )
+				{
+					cg.refdef.vieworg[i] = client_camera.origin[i] + (( ( client_camera.origin2[i] - client_camera.origin[i] ) ) / client_camera.move_duration ) * ( cg.time - client_camera.move_time );
+				}
+			}
+		}
+	}
+	else
+	{
+		checkTrack = qtrue;
+	}
+
+	if ( checkFollow )
+	{
+		if ( client_camera.info_state & CAMERA_FOLLOWING )
+		{//This needs to be done after camera movement
+			CGCam_FollowUpdate();
+		}
+		VectorCopy(client_camera.angles, cg.refdefViewAngles );
+	}
+
+	if ( checkTrack )
+	{
+		if ( client_camera.info_state & CAMERA_TRACKING )
+		{//This has to run AFTER Follow if the camera is following a cameraGroup
+			CGCam_TrackUpdate();
+		}
+
+		VectorCopy( client_camera.origin, cg.refdef.vieworg );
+	}
+
+	//Bar fading
+	if ( client_camera.info_state & CAMERA_BAR_FADING )
+	{
+		CGCam_UpdateBarFade();
+	}
+
+	//Normal fading - separate call because can finish after camera is disabled
+	CGCam_UpdateFade();
+
+	//Update shaking if there's any
+	//CGCam_UpdateSmooth( cg.refdef.vieworg, cg.refdefViewAngles );
+	CGCam_UpdateShake( cg.refdef.vieworg, cg.refdefViewAngles );
+	AnglesToAxis( cg.refdefViewAngles, cg.refdef.viewaxis );
+}
+
+/*
+-------------------------
+CGCam_DrawWideScreen
+-------------------------
+*/
+
+void CGCam_DrawWideScreen( void )
+{
+	vec4_t	modulate;
+
+	//Only draw if visible
+	if ( client_camera.bar_alpha )
+	{
+		CGCam_UpdateBarFade();
+
+		modulate[0] = modulate[1] = modulate[2] = 0.0f;
+		modulate[3] = client_camera.bar_alpha;
+	
+		CG_FillRect( cg.refdef.x, cg.refdef.y, 640, client_camera.bar_height, modulate  );
+		CG_FillRect( cg.refdef.x, cg.refdef.y + 480 - client_camera.bar_height, 640, client_camera.bar_height, modulate  );
+	}
+
+	//NOTENOTE: Camera always draws the fades unless the alpha is 0
+	if ( client_camera.fade_color[3] == 0.0f )
+		return;
+
+	CG_FillRect( cg.refdef.x, cg.refdef.y, 640, 480, client_camera.fade_color );
+}
+
+/*
+-------------------------
+CGCam_RenderScene
+-------------------------
+*/
+void CGCam_RenderScene( void )
+{
+	CGCam_Update();
+	CG_CalcVrect();
+}
+
+/*
+-------------------------
+CGCam_Shake
+-------------------------
+*/
+
+void CGCam_Shake( float intensity, int duration )
+{
+	if ( intensity > MAX_SHAKE_INTENSITY )
+		intensity = MAX_SHAKE_INTENSITY;
+
+	client_camera.shake_intensity = intensity;
+	client_camera.shake_duration = duration;
+	client_camera.shake_start = cg.time;
+#ifdef _IMMERSION
+	// FIX ME: This is far too weak... but I don't want it to interfere with other effects.
+	cgi_FF_Shake( int(intensity * 625), duration );	// 625 = (10000 / MAX_SHAKE_INTENSITY)
+#endif // _IMMERSION
+#ifdef _XBOX
+	cgi_FF_Xbox_Shake(intensity,duration);
+#endif
+}
+
+/*
+-------------------------
+CGCam_UpdateShake
+
+This doesn't actually affect the camera's info, but passed information instead
+-------------------------
+*/
+
+void CGCam_UpdateShake( vec3_t origin, vec3_t angles )
+{
+	vec3_t	moveDir;
+	float	intensity_scale, intensity;
+
+	if ( client_camera.shake_duration <= 0 )
+		return;
+
+	if ( cg.time > ( client_camera.shake_start + client_camera.shake_duration ) )
+	{
+		client_camera.shake_intensity = 0;
+		client_camera.shake_duration = 0;
+		client_camera.shake_start = 0;
+		return;
+	}
+
+	//intensity_scale now also takes into account FOV with 90.0 as normal
+	intensity_scale = 1.0f - ( (float) ( cg.time - client_camera.shake_start ) / (float) client_camera.shake_duration ) * (((client_camera.FOV+client_camera.FOV2)/2.0f)/90.0f);
+
+	intensity = client_camera.shake_intensity * intensity_scale;
+
+	for ( int i = 0; i < 3; i++ )
+	{
+		moveDir[i] = ( crandom() * intensity );
+	}
+
+	//FIXME: Lerp
+
+	//Move the camera
+	VectorAdd( origin, moveDir, origin );
+
+	for ( i=0; i < 2; i++ ) // Don't do ROLL
+		moveDir[i] = ( crandom() * intensity );
+
+	//FIXME: Lerp
+
+	//Move the angles
+	VectorAdd( angles, moveDir, angles );
+}
+
+void CGCam_Smooth( float intensity, int duration )
+{
+	client_camera.smooth_active=false; // means smooth_origin and angles are valid
+	if ( intensity>1.0f||intensity==0.0f||duration<1)
+	{
+		client_camera.info_state &= ~CAMERA_SMOOTHING;
+		return;
+	}
+	client_camera.info_state |= CAMERA_SMOOTHING;
+	client_camera.smooth_intensity = intensity;
+	client_camera.smooth_duration = duration;
+	client_camera.smooth_start = cg.time;
+}
+
+void CGCam_UpdateSmooth( vec3_t origin, vec3_t angles )
+{
+	if (!(client_camera.info_state&CAMERA_SMOOTHING)||cg.time > ( client_camera.smooth_start + client_camera.smooth_duration ))
+	{
+		client_camera.info_state &= ~CAMERA_SMOOTHING;
+		return;
+	}
+	if (!client_camera.smooth_active)
+	{
+		client_camera.smooth_active=true;
+		VectorCopy(origin,client_camera.smooth_origin);
+		return;
+	}
+	float factor=client_camera.smooth_intensity;
+	if (client_camera.smooth_duration>200&&cg.time > ( client_camera.smooth_start + client_camera.smooth_duration-100 ))
+	{
+		factor+=(1.0f-client_camera.smooth_intensity)*
+			(100.0f-(client_camera.smooth_start + client_camera.smooth_duration-cg.time))/100.0f;
+	}
+	int i;
+	for (i=0;i<3;i++)
+	{
+		client_camera.smooth_origin[i]*=(1.0f-factor);
+		client_camera.smooth_origin[i]+=factor*origin[i];
+		origin[i]=client_camera.smooth_origin[i];
+	}
+}
+
+void CGCam_NotetrackProcessFov(const char *addlArg)
+{
+	int a = 0;
+	char t[64];
+
+	if (!addlArg || !addlArg[0])
+	{
+		Com_Printf("camera roff 'fov' notetrack missing fov argument\n", addlArg);
+		return;
+	}
+	if (isdigit(addlArg[a]))
+	{
+		// "fov <new fov>"
+		int d = 0, tsize = 64;
+
+		memset(t, 0, tsize*sizeof(char));
+		while (addlArg[a] && d < tsize)
+		{
+			t[d++] = addlArg[a++];
+		}
+		// now the contents of t represent our desired fov 
+		float newFov = atof(t);
+#ifndef FINAL_BUILD
+		if (cg_roffdebug.integer)
+		{
+			if (fabs(cg_roffval1.value) > 0.001f)
+			{
+				newFov = cg_roffval1.value;
+			}
+		}
+#endif
+		if (cg_roffdebug.integer)
+		{
+			Com_Printf("notetrack: 'fov %2.2f' on frame %d\n", newFov, client_camera.roff_frame);
+		}
+		CGCam_Zoom(newFov, 0);
+	}
+}
+
+void CGCam_NotetrackProcessFovZoom(const char *addlArg)
+{
+	int		a = 0;
+	float	beginFOV = 0, endFOV = 0, fovTime = 0;
+
+	if (!addlArg || !addlArg[0])
+	{
+		Com_Printf("camera roff 'fovzoom' notetrack missing arguments\n", addlArg);
+		return;
+	}
+	//
+	// "fovzoom <begin fov> <end fov> <time>"
+	//
+	char t[64];
+	int d = 0, tsize = 64;
+
+	memset(t, 0, tsize*sizeof(char));
+	while (addlArg[a] && !isspace(addlArg[a]) && d < tsize)
+	{
+		t[d++] = addlArg[a++];
+	}
+	if (!isdigit(t[0]))
+	{
+		// assume a non-number here means we should start from our current fov
+		beginFOV = client_camera.FOV;
+	}
+	else
+	{
+		// now the contents of t represent our beginning fov
+		beginFOV = atof(t);
+	}
+
+	// eat leading whitespace
+	while (addlArg[a] && addlArg[a] == ' ')
+	{
+		a++;
+	}
+	if (addlArg[a])
+	{
+		d = 0;
+		memset(t, 0, tsize*sizeof(char));
+		while (addlArg[a] && !isspace(addlArg[a]) && d < tsize)
+		{
+			t[d++] = addlArg[a++];
+		}
+		// now the contents of t represent our end fov
+		endFOV = atof(t);
+
+		// eat leading whitespace
+		while (addlArg[a] && addlArg[a] == ' ')
+		{
+			a++;
+		}
+		if (addlArg[a])
+		{
+			d = 0;
+			memset(t, 0, tsize*sizeof(char));
+			while (addlArg[a] && !isspace(addlArg[a]) && d < tsize)
+			{
+				t[d++] = addlArg[a++];
+			}
+			// now the contents of t represent our time
+			fovTime = atof(t);
+		}
+		else
+		{
+			Com_Printf("camera roff 'fovzoom' notetrack missing 'time' argument\n", addlArg);
+			return;
+		}
+#ifndef FINAL_BUILD
+		if (cg_roffdebug.integer)
+		{
+			if (fabs(cg_roffval1.value) > 0.001f)
+			{
+				beginFOV = cg_roffval1.value;
+			}
+			if (fabs(cg_roffval2.value) > 0.001f)
+			{
+				endFOV = cg_roffval2.value;
+			}
+			if (fabs(cg_roffval3.value) > 0.001f)
+			{
+				fovTime = cg_roffval3.value;
+			}
+		}
+#endif
+		if (cg_roffdebug.integer)
+		{
+			Com_Printf("notetrack: 'fovzoom %2.2f %2.2f %5.1f' on frame %d\n", beginFOV, endFOV, fovTime, client_camera.roff_frame);
+		}
+		CGCam_Zoom2(beginFOV, endFOV, fovTime);
+	}
+	else
+	{
+		Com_Printf("camera roff 'fovzoom' notetrack missing 'end fov' argument\n", addlArg);
+		return;
+	}
+}
+
+void CGCam_NotetrackProcessFovAccel(const char *addlArg)
+{
+	int		a = 0;
+	float	beginFOV = 0, fovDelta = 0, fovDelta2 = 0, fovTime = 0;
+
+	if (!addlArg || !addlArg[0])
+	{
+		Com_Printf("camera roff 'fovaccel' notetrack missing arguments\n", addlArg);
+		return;
+	}
+	//
+	// "fovaccel <begin fov> <fov delta> <fov delta2> <time>"
+	//
+	// where 'begin fov' is initial position, 'fov delta' is velocity, and 'fov delta2' is acceleration.
+	char t[64];
+	int d = 0, tsize = 64;
+
+	memset(t, 0, tsize*sizeof(char));
+	while (addlArg[a] && !isspace(addlArg[a]) && d < tsize)
+	{
+		t[d++] = addlArg[a++];
+	}
+	if (!isdigit(t[0]))
+	{
+		// assume a non-number here means we should start from our current fov
+		beginFOV = client_camera.FOV;
+	}
+	else
+	{
+		// now the contents of t represent our beginning fov
+		beginFOV = atof(t);
+	}
+
+	// eat leading whitespace
+	while (addlArg[a] && addlArg[a] == ' ')
+	{
+		a++;
+	}
+	if (addlArg[a])
+	{
+		d = 0;
+		memset(t, 0, tsize*sizeof(char));
+		while (addlArg[a] && !isspace(addlArg[a]) && d < tsize)
+		{
+			t[d++] = addlArg[a++];
+		}
+		// now the contents of t represent our delta
+		fovDelta = atof(t);
+
+		// eat leading whitespace
+		while (addlArg[a] && addlArg[a] == ' ')
+		{
+			a++;
+		}
+		if (addlArg[a])
+		{
+			d = 0;
+			memset(t, 0, tsize*sizeof(char));
+			while (addlArg[a] && !isspace(addlArg[a]) && d < tsize)
+			{
+				t[d++] = addlArg[a++];
+			}
+			// now the contents of t represent our fovDelta2
+			fovDelta2 = atof(t);
+
+			// eat leading whitespace
+			while (addlArg[a] && addlArg[a] == ' ')
+			{
+				a++;
+			}
+			if (addlArg[a])
+			{
+				d = 0;
+				memset(t, 0, tsize*sizeof(char));
+				while (addlArg[a] && !isspace(addlArg[a]) && d < tsize)
+				{
+					t[d++] = addlArg[a++];
+				}
+				// now the contents of t represent our time
+				fovTime = atof(t);
+			}
+			else
+			{
+				Com_Printf("camera roff 'fovaccel' notetrack missing 'time' argument\n", addlArg);
+				return;
+			}
+			if (cg_roffdebug.integer)
+			{
+				Com_Printf("notetrack: 'fovaccel %2.2f %3.5f %3.5f %d' on frame %d\n", beginFOV, fovDelta, fovDelta2, fovTime, client_camera.roff_frame);
+			}
+			CGCam_ZoomAccel(beginFOV, fovDelta, fovDelta2, fovTime);
+		}
+		else
+		{
+			Com_Printf("camera roff 'fovaccel' notetrack missing 'delta2' argument\n", addlArg);
+			return;
+		}
+	}
+	else
+	{
+		Com_Printf("camera roff 'fovaccel' notetrack missing 'delta' argument\n", addlArg);
+		return;
+	}
+}
+
+// 3/18/03 kef -- blatantly thieved from G_RoffNotetrackCallback
+static void CG_RoffNotetrackCallback(const char *notetrack)
+{
+	int i = 0, r = 0;
+	char type[256];
+//	char argument[512];
+	char addlArg[512];
+	int addlArgs = 0;
+
+	if (!notetrack)
+	{
+		return;
+	}
+
+	//notetrack = "fov 65";
+
+	while (notetrack[i] && notetrack[i] != ' ')
+	{
+		type[i] = notetrack[i];
+		i++;
+	}
+
+	type[i] = '\0';
+
+	//if (notetrack[i] != ' ')
+	//{ //didn't pass in a valid notetrack type, or forgot the argument for it
+	//	return;
+	//}
+
+/*	i++;
+
+	while (notetrack[i] && notetrack[i] != ' ')
+	{
+		if (notetrack[i] != '\n' && notetrack[i] != '\r')
+		{ //don't read line ends for an argument
+			argument[r] = notetrack[i];
+			r++;
+		}
+		i++;
+	}
+	argument[r] = '\0';
+	if (!r)
+	{
+		return;
+	}
+*/
+
+	if (notetrack[i] == ' ')
+	{ //additional arguments...
+		addlArgs = 1;
+
+		i++;
+		r = 0;
+		while (notetrack[i])
+		{
+			addlArg[r] = notetrack[i];
+			r++;
+			i++;
+		}
+		addlArg[r] = '\0';
+	}
+
+	if (strcmp(type, "cut") == 0)
+	{
+		client_camera.info_state |= CAMERA_CUT;
+		if (cg_roffdebug.integer)
+		{
+			Com_Printf("notetrack: 'cut' on frame %d\n", client_camera.roff_frame);
+		}
+
+		// this is just a really hacky way of getting a cut and a fov command on the same frame
+		if (addlArgs)
+		{
+			CG_RoffNotetrackCallback(addlArg);
+		}
+	}
+	else if (strcmp(type, "fov") == 0)
+	{
+		if (addlArgs)
+		{
+			CGCam_NotetrackProcessFov(addlArg);
+			return;
+		}
+		Com_Printf("camera roff 'fov' notetrack missing fov argument\n", addlArg);
+	}
+	else if (strcmp(type, "fovzoom") == 0)
+	{
+		if (addlArgs)
+		{
+			CGCam_NotetrackProcessFovZoom(addlArg);
+			return;
+		}
+		Com_Printf("camera roff 'fovzoom' notetrack missing 'begin fov' argument\n", addlArg);
+	}
+	else if (strcmp(type, "fovaccel") == 0)
+	{
+		if (addlArgs)
+		{
+			CGCam_NotetrackProcessFovAccel(addlArg);
+			return;
+		}
+		Com_Printf("camera roff 'fovaccel' notetrack missing 'begin fov' argument\n", addlArg);
+	}
+}
+
+/*
+-------------------------
+CGCam_StartRoff
+
+Sets up the camera to use
+a rof file
+-------------------------
+*/
+
+void CGCam_StartRoff( char *roff )
+{
+	CGCam_FollowDisable();
+	CGCam_TrackDisable();
+
+	// Set up the roff state info..we'll hijack the moving and panning code until told otherwise 
+	//	...CAMERA_FOLLOWING would be a case that could override this..
+	client_camera.info_state |= CAMERA_MOVING;
+	client_camera.info_state |= CAMERA_PANNING;
+
+	if ( !G_LoadRoff( roff ) )
+	{
+		// The load failed so don't turn on the roff playback...
+		Com_Printf( S_COLOR_RED"ROFF camera playback failed\n" );
+		return;
+	};
+
+	client_camera.info_state |= CAMERA_ROFFING;
+
+	strncpy(client_camera.sRoff,roff,sizeof(client_camera.sRoff));
+	client_camera.roff_frame = 0;
+	client_camera.next_roff_time = cg.time;	// I can work right away
+}
+
+/*
+-------------------------
+CGCam_StopRoff
+
+Stops camera rof
+-------------------------
+*/
+
+static void CGCam_StopRoff( void )
+{
+	// Clear the roff flag
+	client_camera.info_state &= ~CAMERA_ROFFING;
+	client_camera.info_state &= ~CAMERA_MOVING;
+}
+
+/*
+------------------------------------------------------
+CGCam_Roff
+
+Applies the sampled roff data to the camera and does 
+the lerping itself...this is done because the current
+camera interpolation doesn't seem to work all that
+great when you are adjusting the camera org and angles
+so often...or maybe I'm just on crack.
+------------------------------------------------------
+*/
+
+static void CGCam_Roff( void )
+{
+ while ( client_camera.next_roff_time <= cg.time )
+ {
+	// Make sure that the roff is cached
+	const int roff_id = G_LoadRoff( client_camera.sRoff );
+
+	if ( !roff_id )
+	{
+		return;
+	}
+
+	// The ID is one higher than the array index
+	const roff_list_t	*roff	= &roffs[ roff_id - 1 ];
+	vec3_t org, ang;
+
+	if ( roff->type == 2 )
+	{
+		move_rotate2_t	*data	= &((move_rotate2_t *)roff->data)[ client_camera.roff_frame ];
+		VectorCopy( data->origin_delta, org );
+		VectorCopy( data->rotate_delta, ang );
+
+		// since we just hit a new frame, clear our CUT flag
+		client_camera.info_state &= ~CAMERA_CUT;
+
+		if (data->mStartNote != -1 || data->mNumNotes)
+		{
+			CG_RoffNotetrackCallback(roffs[roff_id - 1].mNoteTrackIndexes[data->mStartNote]);
+		}
+	}
+	else
+	{
+		move_rotate_t	*data	= &((move_rotate_t *)roff->data)[ client_camera.roff_frame ];
+		VectorCopy( data->origin_delta, org );
+		VectorCopy( data->rotate_delta, ang );
+	}
+
+	// Yeah, um, I guess this just has to be negated?
+	//ang[PITCH]	=- ang[PITCH];
+	ang[ROLL]	=- ang[ROLL];
+	// might need to to yaw as well.  need a test...
+
+	if ( cg_developer.integer )
+	{
+		Com_Printf( S_COLOR_GREEN"CamROFF: frame: %d o:<%.2f %.2f %.2f> a:<%.2f %.2f %.2f>\n", 
+					client_camera.roff_frame,
+					org[0], org[1], org[2],
+					ang[0], ang[1], ang[2] );
+	}
+
+	if ( client_camera.roff_frame )
+	{
+		// Don't mess with angles if we are following
+		if ( !(client_camera.info_state & CAMERA_FOLLOWING) )
+		{
+			VectorAdd( client_camera.angles, client_camera.angles2, client_camera.angles );
+		}
+
+		VectorCopy( client_camera.origin2, client_camera.origin );
+	}
+
+	// Don't mess with angles if we are following
+	if ( !(client_camera.info_state & CAMERA_FOLLOWING) )
+	{
+		VectorCopy( ang, client_camera.angles2 );
+		client_camera.pan_time = cg.time;
+		client_camera.pan_duration = roff->mFrameTime;
+	}
+
+	VectorAdd( client_camera.origin, org, client_camera.origin2 );
+
+	client_camera.move_time = cg.time;
+	client_camera.move_duration = roff->mFrameTime;
+
+	if ( ++client_camera.roff_frame >= roff->frames )
+	{
+		CGCam_StopRoff();	
+		return;
+	}
+
+	// Check back in frameTime to get the next roff entry
+	client_camera.next_roff_time += roff->mFrameTime;
+ }
+}
+
+void CMD_CGCam_Disable( void )
+{
+	vec4_t	fade = {0, 0, 0, 0};
+
+	CGCam_Disable();
+	CGCam_SetFade( fade );
+	player_locked = qfalse;
+}
diff --git a/code/cgame/cg_camera.h b/code/cgame/cg_camera.h
new file mode 100644
index 0000000..fcdf7cd
--- /dev/null
+++ b/code/cgame/cg_camera.h
@@ -0,0 +1,164 @@
+#ifndef __CG_CAMERA__
+#define __CG_CAMERA__
+
+//
+// cg_camera.cpp
+
+#define MAX_CAMERA_GROUP_SUBJECTS	16
+#define MAX_ACCEL_PER_FRAME			10.0f
+#define MAX_SHAKE_INTENSITY			16.0f
+#define	CAMERA_DEFAULT_FOV			90.0f
+#define CAMERA_WIDESCREEN_FOV		120.0f
+#define	BAR_DURATION				1000.0f
+#define BAR_RATIO					48.0f
+
+#define CAMERA_MOVING		0x00000001
+#define CAMERA_PANNING		0x00000002
+#define CAMERA_ZOOMING		0x00000004
+#define	CAMERA_BAR_FADING	0x00000008
+#define	CAMERA_FADING		0x00000010
+#define	CAMERA_FOLLOWING	0x00000020
+#define	CAMERA_TRACKING		0x00000040
+#define CAMERA_ROFFING		0x00000080
+#define CAMERA_SMOOTHING	0x00000100
+#define CAMERA_CUT			0x00000200
+#define CAMERA_ACCEL		0x00000400
+
+// NOTE!! This structure is now saved out as part of the load/save game, so tell me if you put any pointers or
+//	other goofy crap in... -Ste
+//
+typedef struct camera_s
+{
+	//Position / Facing information
+	vec3_t	origin;
+	vec3_t	angles;
+	
+	vec3_t	origin2;
+	vec3_t	angles2;
+
+	//Movement information
+	float	move_duration;
+	float	move_time;
+	int		move_type;	//CMOVE_LINEAR, CMOVE_BEZIER
+
+	//FOV information
+	float	FOV;
+	float	FOV2;
+	float	FOV_duration;
+	float	FOV_time;
+	float	FOV_vel;
+	float	FOV_acc;
+
+	//Pan information
+	float	pan_time;
+	float	pan_duration;
+
+	//Following information
+	char	cameraGroup[MAX_QPATH];
+	float	cameraGroupZOfs;
+	char	cameraGroupTag[MAX_QPATH];
+	vec3_t	subjectPos;
+	float	subjectSpeed;
+	float	followSpeed;
+	qboolean followInitLerp;
+	float	distance;
+	qboolean distanceInitLerp;
+	//int		aimEntNum;//FIXME: remove
+
+	//Tracking information
+	int		trackEntNum;
+	vec3_t	trackToOrg;
+	vec3_t	moveDir;
+	float	speed;
+	float	initSpeed;
+	float	trackInitLerp;
+	int		nextTrackEntUpdateTime;
+
+	//Cine-bar information
+	float	bar_alpha;
+	float	bar_alpha_source;
+	float	bar_alpha_dest;
+	float	bar_time;
+	
+	float	bar_height_source;
+	float	bar_height_dest;
+	float	bar_height;
+
+	vec4_t	fade_color;
+	vec4_t	fade_source;
+	vec4_t	fade_dest;
+	float	fade_time;
+	float	fade_duration;
+
+	//State information
+	int		info_state;
+
+	//Shake information
+	float	shake_intensity;
+	int		shake_duration;
+	int		shake_start;
+
+	//Smooth information
+	float	smooth_intensity;
+	int		smooth_duration;
+	int		smooth_start;
+	vec3_t	smooth_origin;
+	bool	smooth_active; // means smooth_origin and angles are valid
+
+
+	// ROFF information
+	char	sRoff[MAX_QPATH];	// name of a cached roff 
+	int		roff_frame;		// current frame in the roff data
+	int		next_roff_time;	// time when it's ok to apply the next roff frame 
+
+#ifdef _XBOX
+	qboolean	widescreen;
+#endif
+
+} camera_t;
+
+extern	bool		in_camera;
+extern	camera_t	client_camera;
+
+void CGCam_Init( void );
+
+void CGCam_Enable( void );
+void CGCam_Disable( void );
+
+#ifdef _XBOX
+void CGCam_SetWidescreen( qboolean widescreen );
+#endif
+
+void CGCam_SetPosition( vec3_t org );
+void CGCam_SetAngles( vec3_t ang );
+void CGCam_SetFOV( float FOV );
+#ifdef _XBOX
+void CGCam_SetFOV2( float FOV2 );
+#endif
+
+void CGCam_Zoom( float FOV, float duration );
+//void CGCam_Pan( vec3_t	dest, float duration );
+void CGCam_Pan( vec3_t dest, vec3_t panDirection, float duration );
+void CGCam_Move( vec3_t dest, float duration );
+void CGCam_Fade( vec4_t source, vec4_t dest, float duration );
+
+void CGCam_UpdateFade( void );
+
+void CGCam_Update( void );
+void CGCam_RenderScene( void );
+void CGCam_DrawWideScreen( void );
+
+void CGCam_Shake( float intensity, int duration );
+void CGCam_UpdateShake( vec3_t origin, vec3_t angles );
+
+void CGCam_Follow( const char *cameraGroup, float speed, float initLerp );
+void CGCam_Track( const char *trackName, float speed, float initLerp );
+void CGCam_Distance( float distance, float initLerp );
+void CGCam_Roll( float	dest, float duration );
+
+void CGCam_StartRoff( char *roff );
+
+void CGCam_Smooth( float intensity, int duration );
+void CGCam_UpdateSmooth( vec3_t origin, vec3_t angles );
+
+#endif	//__CG_CAMERA__
\ No newline at end of file
diff --git a/code/cgame/cg_consolecmds.cpp b/code/cgame/cg_consolecmds.cpp
new file mode 100644
index 0000000..db714b0
--- /dev/null
+++ b/code/cgame/cg_consolecmds.cpp
@@ -0,0 +1,324 @@
+// cg_consolecmds.c -- text commands typed in at the local console, or
+// executed by a key binding
+
+// this line must stay at top so the whole PCH thing works...
+#include "cg_headers.h"
+
+//#include "cg_local.h"
+#include "cg_media.h"	//just for cgs....
+
+void CG_TargetCommand_f( void );
+extern qboolean	player_locked;
+extern void CMD_CGCam_Disable( void );
+void CG_NextInventory_f( void );
+void CG_PrevInventory_f( void );
+void CG_NextForcePower_f( void );
+void CG_PrevForcePower_f( void );
+void CG_LoadHud_f( void );
+
+/*
+====================
+CG_ColorFromString
+====================
+*/
+/*
+static void CG_SetColor_f( void) {
+
+	if (cgi_Argc()==4)
+	{
+		g_entities[0].client->renderInfo.customRGBA[0] = atoi( CG_Argv(1) );
+		g_entities[0].client->renderInfo.customRGBA[1] = atoi( CG_Argv(2) );
+		g_entities[0].client->renderInfo.customRGBA[2] = atoi( CG_Argv(3) );
+	}
+	if (cgi_Argc()==2)
+	{
+		int val = atoi( CG_Argv(1) );
+				
+		if ( val < 1 || val > 7 ) {
+			g_entities[0].client->renderInfo.customRGBA[0] = 255;
+			g_entities[0].client->renderInfo.customRGBA[1] = 255;
+			g_entities[0].client->renderInfo.customRGBA[2] = 255;
+			return;
+		}
+		g_entities[0].client->renderInfo.customRGBA[0]=0;
+		g_entities[0].client->renderInfo.customRGBA[1]=0;
+		g_entities[0].client->renderInfo.customRGBA[2]=0;
+		
+		if ( val & 1 ) {
+			g_entities[0].client->renderInfo.customRGBA[2] = 255;
+		}
+		if ( val & 2 ) {
+			g_entities[0].client->renderInfo.customRGBA[1] = 255;
+		}
+		if ( val & 4 ) {
+			g_entities[0].client->renderInfo.customRGBA[0] = 255;
+		}
+	}
+}
+*/
+/*
+=============
+CG_Viewpos_f
+
+Debugging command to print the current position
+=============
+*/
+static void CG_Viewpos_f (void) {
+	CG_Printf ("%s (%i %i %i) : %i\n", cgs.mapname, (int)cg.refdef.vieworg[0],
+		(int)cg.refdef.vieworg[1], (int)cg.refdef.vieworg[2], 
+		(int)cg.refdefViewAngles[YAW]);
+}
+
+void CG_WriteCam_f (void)
+{
+	char	text[1024];
+	char	*targetname;
+	static	int	numCams;
+
+	numCams++;
+	
+	targetname = (char	*)CG_Argv(1);
+
+	if( !targetname || !targetname[0] )
+	{
+		targetname = "nameme!";
+	}
+
+	CG_Printf( "Camera #%d ('%s') written to: ", numCams, targetname );
+	sprintf( text, "//entity %d\n{\n\"classname\"	\"ref_tag\"\n\"targetname\"	\"%s\"\n\"origin\" \"%i %i %i\"\n\"angles\" \"%i %i %i\"\n\"fov\" \"%i\"\n}\n", numCams, targetname, (int)cg.refdef.vieworg[0], (int)cg.refdef.vieworg[1], (int)cg.refdef.vieworg[2], (int)cg.refdefViewAngles[0], (int)cg.refdefViewAngles[1], (int)cg.refdefViewAngles[2], cg_fov.integer );
+	gi.WriteCam( text );
+}
+
+void Lock_Disable ( void )
+{
+	player_locked = qfalse;
+}
+
+extern float cg_zoomFov;	//from cg_view.cpp
+
+void CG_ToggleBinoculars( void )
+{
+	if ( in_camera || !cg.snap )
+	{
+		return;
+	}
+
+	if ( cg.zoomMode == 0 || cg.zoomMode >= 2 ) // not zoomed or currently zoomed with the disruptor or LA goggles
+	{
+		if ( (cg.snap->ps.saber[0].Active() && cg.snap->ps.saberInFlight) || cg.snap->ps.stats[STAT_HEALTH] <= 0)
+		{//can't select binoculars when throwing saber
+			//FIXME: indicate this to the player
+			return;
+		}
+
+		if ( cg.snap->ps.viewEntity || ( cg_entities[cg.snap->ps.clientNum].currentState.eFlags & ( EF_LOCKED_TO_WEAPON | EF_IN_ATST )))
+		{
+			// can't zoom when you have a viewEntity or driving an atst or in an emplaced gun
+			return;
+		}
+
+		cg.zoomMode = 1;
+		cg.zoomLocked = qfalse;
+
+		if ( cg.snap->ps.batteryCharge )
+		{
+			// when you have batteries, you can actually zoom in
+			cg_zoomFov = 40.0f;
+		}
+		else if ( cg.overrides.active & CG_OVERRIDE_FOV )
+		{
+			cg_zoomFov = cg.overrides.fov;
+		}
+		else
+		{
+			cg_zoomFov = cg_fov.value;
+		}
+
+		cgi_S_StartSound( NULL, cg.snap->ps.clientNum, CHAN_AUTO, cgs.media.zoomStart );
+#ifdef _IMMERSION
+		cgi_FF_Start( cgs.media.zoomStartForce, cg.snap->ps.clientNum );
+#endif // _IMMERSION
+	}
+	else
+	{
+		cg.zoomMode = 0;
+		cg.zoomTime = cg.time;
+		cgi_S_StartSound( NULL, cg.snap->ps.clientNum, CHAN_AUTO, cgs.media.zoomEnd );
+#ifdef _IMMERSION
+		cgi_FF_Start( cgs.media.zoomEndForce, cg.snap->ps.clientNum );
+#endif // _IMMERSION
+	}
+}
+
+void CG_ToggleLAGoggles( void )
+{
+	if ( in_camera || !cg.snap)
+	{
+		return;
+	}
+
+	if ( cg.zoomMode == 0 || cg.zoomMode < 3 ) // not zoomed or currently zoomed with the disruptor or regular binoculars
+	{
+		if ( (cg.snap->ps.saber[0].Active() && cg.snap->ps.saberInFlight) || cg.snap->ps.stats[STAT_HEALTH] <= 0 )
+		{//can't select binoculars when throwing saber
+			//FIXME: indicate this to the player
+			return;
+		}
+
+		if ( cg.snap->ps.viewEntity || ( cg_entities[cg.snap->ps.clientNum].currentState.eFlags & ( EF_LOCKED_TO_WEAPON | EF_IN_ATST )))
+		{
+			// can't zoom when you have a viewEntity or driving an atst or in an emplaced gun
+			return;
+		}
+
+		cg.zoomMode = 3;
+		cg.zoomLocked = qfalse;
+		if ( cg.overrides.active & CG_OVERRIDE_FOV )
+		{
+			cg_zoomFov = cg.overrides.fov;
+		}
+		else
+		{
+			cg_zoomFov = cg_fov.value; // does not zoom!!
+		}
+
+		cgi_S_StartSound( NULL, cg.snap->ps.clientNum, CHAN_AUTO, cgs.media.zoomStart );
+#ifdef _IMMERSION
+		cgi_FF_Start( cgs.media.zoomStartForce, cg.snap->ps.clientNum );
+#endif // _IMMERSION
+	}
+	else
+	{
+		cg.zoomMode = 0;
+		cg.zoomTime = cg.time;
+		cgi_S_StartSound( NULL, cg.snap->ps.clientNum, CHAN_AUTO, cgs.media.zoomEnd );
+#ifdef _IMMERSION
+		cgi_FF_Start( cgs.media.zoomEndForce, cg.snap->ps.clientNum );
+#endif // _IMMERSION
+	}
+}
+
+static void CG_InfoDown_f( void ) {
+//	cg.showInformation = qtrue;
+}
+
+static void CG_InfoUp_f( void ) 
+{
+//	cg.showInformation = qfalse;
+}
+
+typedef struct {
+	char	*cmd;
+	void	(*function)(void);
+} consoleCommand_t;
+
+
+static consoleCommand_t	commands[] = {
+	{ "testmodel", CG_TestModel_f },
+	{ "nextframe", CG_TestModelNextFrame_f },
+	{ "prevframe", CG_TestModelPrevFrame_f },
+	{ "nextskin", CG_TestModelNextSkin_f },
+	{ "prevskin", CG_TestModelPrevSkin_f },
+/*
+Ghoul2 Insert Start
+*/
+	{ "testG2Model", CG_TestG2Model_f},
+	{ "testsurface", CG_TestModelSurfaceOnOff_f },
+	{ "testanglespre", CG_TestModelSetAnglespre_f},
+	{ "testanglespost", CG_TestModelSetAnglespost_f},
+	{ "testanimate", CG_TestModelAnimate_f},
+	{ "testlistbones", CG_ListModelBones_f},
+	{ "testlistsurfaces", CG_ListModelSurfaces_f},
+/*
+Ghoul2 Insert End
+*/
+	{ "viewpos", CG_Viewpos_f },
+	{ "writecam", CG_WriteCam_f },
+	{ "+info", CG_InfoDown_f },
+	{ "-info", CG_InfoUp_f },
+	{ "weapnext", CG_NextWeapon_f },
+	{ "weapprev", CG_PrevWeapon_f },
+	{ "weapon", CG_Weapon_f },
+	{ "tcmd", CG_TargetCommand_f },
+	{ "cam_disable", CMD_CGCam_Disable },	//gets out of camera mode for debuggin
+	{ "cam_enable", CGCam_Enable },	//gets into camera mode for precise camera placement
+	{ "lock_disable", Lock_Disable },	//player can move now
+	{ "zoom", CG_ToggleBinoculars },
+	{ "la_zoom", CG_ToggleLAGoggles },
+	{ "invnext", CG_NextInventory_f },
+	{ "invprev", CG_PrevInventory_f },
+	{ "forcenext", CG_NextForcePower_f },
+	{ "forceprev", CG_PrevForcePower_f },
+	{ "loadhud", CG_LoadHud_f },
+	{ "dpweapnext", CG_DPNextWeapon_f },
+	{ "dpweapprev", CG_DPPrevWeapon_f },
+	{ "dpinvnext", CG_DPNextInventory_f },
+	{ "dpinvprev", CG_DPPrevInventory_f },
+	{ "dpforcenext", CG_DPNextForcePower_f },
+	{ "dpforceprev", CG_DPPrevForcePower_f },
+//	{ "color", CG_SetColor_f },
+};
+
+
+//extern menuDef_t *menuScoreboard;
+void Menu_Reset();	
+
+void CG_LoadHud_f( void) 
+{
+	const char *hudSet;
+
+//	cgi_UI_String_Init();
+
+//	cgi_UI_Menu_Reset();
+	
+	hudSet = cg_hudFiles.string;
+	if (hudSet[0] == '\0') 
+	{
+		hudSet = "ui/jahud.txt";
+	}
+
+	CG_LoadMenus(hudSet);
+//	menuScoreboard = NULL;
+
+}
+
+/*
+=================
+CG_ConsoleCommand
+
+The string has been tokenized and can be retrieved with
+Cmd_Argc() / Cmd_Argv()
+=================
+*/
+qboolean CG_ConsoleCommand( void ) {
+	const char	*cmd;
+	int		i;
+
+	cmd = CG_Argv(0);
+
+	for ( i = 0 ; i < sizeof( commands ) / sizeof( commands[0] ) ; i++ ) {
+		if ( !Q_stricmp( cmd, commands[i].cmd ) ) {
+			commands[i].function();
+			return qtrue;
+		}
+	}
+
+	return qfalse;
+}
+
+
+/*
+=================
+CG_InitConsoleCommands
+
+Let the client system know about all of our commands
+so it can perform tab completion
+=================
+*/
+void CG_InitConsoleCommands( void ) {
+	int		i;
+
+	for ( i = 0 ; i < sizeof( commands ) / sizeof( commands[0] ) ; i++ ) {
+		cgi_AddCommand( commands[i].cmd );
+	}
+}
diff --git a/code/cgame/cg_credits.cpp b/code/cgame/cg_credits.cpp
new file mode 100644
index 0000000..5d633af
--- /dev/null
+++ b/code/cgame/cg_credits.cpp
@@ -0,0 +1,654 @@
+// Filename:-	cg_credits.cpp
+//
+// module for end credits code
+
+// this line must stay at top so the whole PCH thing works...
+//
+#include "cg_headers.h"
+
+//#include "cg_local.h"
+#include "cg_media.h"
+
+#define max(a,b)            (((a) > (b)) ? (a) : (b))
+
+#define fCARD_FADESECONDS		1.0f	// fade up time, also fade down time
+#define fCARD_SUSTAINSECONDS	2.0f	// hold time before fade down
+#define fLINE_SECONDTOSCROLLUP	15.0f	// how long one line takes to scroll up the screen
+
+
+#define MAX_LINE_BYTES 2048
+
+qhandle_t ghFontHandle = 0;
+float gfFontScale = 1.0f;
+vec4_t gv4Color = {0};
+
+struct StringAndSize_t
+{
+	int iStrLenPixels;
+	string str;
+
+	StringAndSize_t()
+	{
+		iStrLenPixels = -1;
+		str = "";
+	}
+	StringAndSize_t(const char *psString)
+	{
+		iStrLenPixels = -1;
+		str = psString;
+	}
+	StringAndSize_t & operator = (const char *psString)
+	{
+		iStrLenPixels = -1;
+		str = psString;
+		return *this;
+	}
+
+	const char *c_str(void)
+	{
+		return str.c_str();
+	}
+
+	int GetPixelLength(void)
+	{
+		if (iStrLenPixels == -1)
+		{
+			iStrLenPixels = cgi_R_Font_StrLenPixels(str.c_str(), ghFontHandle, gfFontScale);
+		}
+
+		return iStrLenPixels;
+	}
+
+	bool IsEmpty(void)
+	{
+		return str.empty();
+	}
+};
+
+struct CreditCard_t
+{
+	int						iTime;
+	StringAndSize_t			strTitle;
+	vector<StringAndSize_t> vstrText;
+
+	CreditCard_t()
+	{
+		iTime = -1;	// flag "not set yet"
+	}
+};
+
+struct CreditLine_t
+{
+	int						iLine;
+	StringAndSize_t			strText;
+	vector<StringAndSize_t> vstrText;
+	bool					bDotted;
+};
+
+typedef list <CreditLine_t>		CreditLines_t;
+typedef list <CreditCard_t>		CreditCards_t;
+
+struct CreditData_t
+{
+	int			iStartTime;
+
+	CreditCards_t CreditCards;
+	CreditLines_t CreditLines;
+
+	bool Running(void)
+	{
+		return !!( CreditCards.size() || CreditLines.size() );
+	}
+};
+
+CreditData_t CreditData;
+
+
+static LPCSTR Capitalize(LPCSTR psTest)
+{	
+	static char sTemp[MAX_LINE_BYTES];
+
+	Q_strncpyz(sTemp, psTest, sizeof(sTemp));
+	
+//	if (!cgi_Language_IsAsian())	// we don't have asian credits, so this is ok to do now
+	{
+		strupr(sTemp);	// capitalise titles (if not asian!!!!)
+	}
+
+	return sTemp;
+}
+
+// cope with hyphenated names and initials (awkward gits)...
+//
+static bool CountsAsWhiteSpaceForCaps( unsigned /* avoid euro-char sign-extend assert within isspace()*/char c )
+{ 
+	return !!(isspace(c) || c == '-' || c == '.' || c == '(' || c == ')' || c=='\'');
+}
+static LPCSTR UpperCaseFirstLettersOnly(LPCSTR psTest)
+{
+	static char sTemp[MAX_LINE_BYTES];
+
+	Q_strncpyz(sTemp, psTest, sizeof(sTemp));
+	
+//	if (!cgi_Language_IsAsian())	// we don't have asian credits, so this is ok to do now
+	{
+		strlwr(sTemp);
+
+		char *p = sTemp;
+		while (*p)
+		{
+			while (*p && CountsAsWhiteSpaceForCaps(*p)) p++;
+			if (*p)
+			{
+				*p = toupper(*p);
+				while (*p && !CountsAsWhiteSpaceForCaps(*p)) p++;
+			}
+		}
+	}
+
+	// now restore any weird stuff...
+	//
+	char *p = strstr(sTemp," Mc");	// eg "Mcfarrell" should be "McFarrell"
+	if (p && isalpha(p[3]))
+	{
+		p[3] = toupper(p[3]);
+	}
+	p = strstr(sTemp," O'");	// eg "O'flaherty" should be "O'Flaherty" (this is probably done automatically now, but wtf.
+	if (p && isalpha(p[3]))
+	{
+		p[3] = toupper(p[3]);
+	}
+	p = strstr(sTemp,"Lucasarts");
+	if (p)
+	{
+		p[5] = 'A';	// capitalise the 'A' in LucasArts (jeez...)
+	}
+
+	return sTemp;
+}
+
+static const char *GetSubString(string &strResult)
+{
+	static char sTemp[MAX_LINE_BYTES];
+
+	if (!strlen(strResult.c_str()))
+		return NULL;
+	
+	strncpy(sTemp,strResult.c_str(),sizeof(sTemp)-1);
+	sTemp[sizeof(sTemp)-1]='\0';
+
+	char *psSemiColon = strchr(sTemp,';');
+	if (  psSemiColon)
+	{
+		 *psSemiColon = '\0';
+
+		 strResult.erase(0,(psSemiColon-sTemp)+1);
+	}
+	else
+	{
+		// no semicolon found, probably last entry? (though i think even those have them on, oh well)
+		//
+		strResult.erase();
+	}
+
+	return sTemp;
+}
+
+// sort entries by their last name (starts at back of string and moves forward until start or just before whitespace)
+// ...
+static int SortBySurname(const void *elem1, const void *elem2)
+{
+	StringAndSize_t *p1 = (StringAndSize_t *) elem1;
+	StringAndSize_t *p2 = (StringAndSize_t *) elem2;
+
+	LPCSTR psSurName1 = p1->c_str() + (strlen(p1->c_str())-1);
+	LPCSTR psSurName2 = p2->c_str() + (strlen(p2->c_str())-1);
+
+	while (psSurName1 > p1->c_str() && !isspace(*psSurName1)) psSurName1--;
+	while (psSurName2 > p2->c_str() && !isspace(*psSurName2)) psSurName2--;
+	if (isspace(*psSurName1)) psSurName1++;
+	if (isspace(*psSurName2)) psSurName2++;
+		
+	return stricmp(psSurName1, psSurName2);
+}
+
+
+
+void CG_Credits_Init( LPCSTR psStripReference, vec4_t *pv4Color)
+{
+	// Play the light side end credits music.
+	if ( g_entities[0].client->sess.mission_objectives[0].status != 2 )
+	{
+		cgi_S_StartBackgroundTrack( "music/endcredits.mp3", NULL, false );
+	}
+	// Play the dark side end credits music.
+	else
+	{
+		cgi_S_StartBackgroundTrack( "music/vjun3/vjun3_explore.mp3", NULL, false );
+	}
+
+	// could make these into parameters later, but for now...
+	//
+	ghFontHandle = cgs.media.qhFontMedium;
+	gfFontScale = 1.0f;
+
+	memcpy(gv4Color,pv4Color,sizeof(gv4Color));	// memcpy so we can poke into alpha channel
+
+	// first, ask the strlen of the final string...
+	//	
+	int iStrLen = cgi_SP_GetStringTextString( psStripReference, NULL, 0 );
+	if (!iStrLen)
+	{
+#ifndef FINAL_BUILD
+		Com_Printf("WARNING: CG_Credits_Init(): invalid text key :'%s'\n", psStripReference);
+#endif
+		return; 
+	}
+	//
+	// malloc space to hold it...
+	//
+	char *psMallocText = (char *) cgi_Z_Malloc( iStrLen+1, TAG_TEMP_WORKSPACE );
+	//
+	// now get the string...
+	//	
+	iStrLen = cgi_SP_GetStringTextString( psStripReference, psMallocText, iStrLen+1 );
+	//ensure we found a match
+	if (!iStrLen)
+	{
+		assert(0);	// should never get here now, but wtf?
+		cgi_Z_Free(psMallocText);
+#ifndef FINAL_BUILD
+		Com_Printf("WARNING: CG_Credits_Init(): invalid text key :'%s'\n", psStripReference);
+#endif
+		return; 
+	}
+
+	// read whole string in and process as cards, lines etc...
+	//
+	typedef enum
+	{
+		eNothing = 0,
+		eLine,
+		eDotEntry,
+		eTitle,
+		eCard,
+		eFinished,
+	} Mode_e;
+	Mode_e eMode = eNothing;
+
+	qboolean bCardsFinished = qfalse;
+	int iLineNumber = 0;
+	const char *psTextParse = psMallocText;
+	while (*psTextParse != NULL)
+	{
+		// read a line...
+		//	
+		char sLine[MAX_LINE_BYTES];
+			 sLine[0]='\0';
+		qboolean bWasCommand = qtrue;
+		while (1)
+		{
+			qboolean bIsTrailingPunctuation;
+			int iAdvanceCount;
+			unsigned int uiLetter = cgi_AnyLanguage_ReadCharFromString(psTextParse, &iAdvanceCount, &bIsTrailingPunctuation);
+			psTextParse += iAdvanceCount;
+
+			// concat onto string so far...
+			//
+			if (uiLetter == 32 && sLine[0] == '\0')
+			{
+				continue;	// unless it's a space at the start of a line, in which case ignore it.
+			}
+
+			if (uiLetter == '\n' || uiLetter == '\0' )
+			{
+				// have we got a command word?...
+				//
+				if (!strnicmp(sLine,"(#",2))
+				{
+					// yep...
+					//
+					if (!stricmp(sLine, "(#CARD)"))
+					{
+						if (!bCardsFinished)
+						{
+							eMode = eCard;
+						}
+						else
+						{
+							#ifndef FINAL_BUILD
+							Com_Printf( S_COLOR_YELLOW "CG_Credits_Init(): No current support for cards after scroll!\n" );
+							#endif
+							eMode = eNothing;
+						}
+						break;
+					}
+					else
+					if (!stricmp(sLine, "(#TITLE)"))
+					{
+						eMode = eTitle;
+						bCardsFinished = qtrue;
+						break;
+					}
+					else
+					if (!stricmp(sLine, "(#LINE)"))
+					{
+						eMode = eLine;
+						bCardsFinished = qtrue;
+						break;
+					}
+					else
+					if (!stricmp(sLine, "(#DOTENTRY)"))
+					{
+						eMode = eDotEntry;
+						bCardsFinished = qtrue;
+						break;
+					}
+					else
+					{
+						#ifndef FINAL_BUILD
+						Com_Printf( S_COLOR_YELLOW "CG_Credits_Init(): bad keyword \"%s\"!\n", sLine );
+						#endif
+						eMode = eNothing;
+					}
+				}
+				else
+				{
+					// I guess not...
+					//
+					bWasCommand = qfalse;
+					break;
+				}
+			}
+			else
+			{
+				// must be a letter...
+				//
+				if (uiLetter > 255)
+				{
+					assert(0);	// this means we're attempting to display asian credits, and we don't
+								//	support these now because the auto-capitalisation rules etc would have to
+								//	be inhibited.
+					Q_strcat(sLine, sizeof(sLine), va("%c%c",uiLetter >> 8, uiLetter & 0xFF));
+				}
+				else
+				{
+					Q_strcat(sLine, sizeof(sLine), va("%c",uiLetter & 0xFF));
+				}
+			}
+		}
+
+		// command?...
+		//
+		if (bWasCommand)
+		{
+			// this'll just be a mode change, so ignore...
+			//
+		}
+		else
+		{
+			// else we've got some text to display...
+			//
+			switch (eMode)
+			{
+				case eNothing:	break;
+				case eLine:		
+				{
+					CreditLine_t	CreditLine;
+									CreditLine.iLine	= iLineNumber++;									
+									CreditLine.strText	= sLine;
+
+					CreditData.CreditLines.push_back( CreditLine );
+				}
+				break;
+
+				case eDotEntry:	
+				{
+					CreditLine_t	CreditLine;
+									CreditLine.iLine	= iLineNumber;
+									CreditLine.bDotted	= true;
+
+					string strResult(sLine);
+					const char *p;
+					while ((p=GetSubString(strResult)) != NULL)
+					{
+						if (CreditLine.strText.IsEmpty())
+						{
+							CreditLine.strText = p;
+						}
+						else
+						{
+							CreditLine.vstrText.push_back( UpperCaseFirstLettersOnly(p) );
+						}
+					}
+
+					if (!CreditLine.strText.IsEmpty() && CreditLine.vstrText.size())
+					{
+						// sort entries RHS dotted entries by alpha...
+						//
+						qsort(&CreditLine.vstrText[0], CreditLine.vstrText.size(), sizeof(CreditLine.vstrText[0]), SortBySurname);
+
+						CreditData.CreditLines.push_back( CreditLine );
+						iLineNumber += CreditLine.vstrText.size();
+					}
+				}
+				break;
+
+				case eTitle:	
+				{
+					iLineNumber++;	// leading blank line
+
+					CreditLine_t	CreditLine;
+									CreditLine.iLine	= iLineNumber++;
+									CreditLine.strText	= Capitalize(sLine);
+
+					CreditData.CreditLines.push_back( CreditLine );
+
+					iLineNumber++;	// trailing blank line
+					break;
+				}
+				case eCard:
+				{
+					CreditCard_t CreditCard;
+	
+					string strResult(sLine);
+					const char *p;
+					while ((p=GetSubString(strResult)) != NULL)
+					{
+						if (CreditCard.strTitle.IsEmpty())
+						{
+							CreditCard.strTitle = Capitalize( p );
+						}
+						else
+						{
+							CreditCard.vstrText.push_back( UpperCaseFirstLettersOnly( p ) );
+						}
+					}
+
+					if (!CreditCard.strTitle.IsEmpty())
+					{
+						// sort entries by alpha...
+						//
+						qsort(&CreditCard.vstrText[0], CreditCard.vstrText.size(), sizeof(CreditCard.vstrText[0]), SortBySurname);
+
+						CreditData.CreditCards.push_back(CreditCard);
+					}
+				}
+				break;
+			}
+		}
+	}
+
+	cgi_Z_Free(psMallocText);
+	CreditData.iStartTime = cg.time;
+}
+
+qboolean CG_Credits_Running( void )
+{
+	return CreditData.Running();
+}
+
+// returns qtrue if still drawing...
+//
+qboolean CG_Credits_Draw( void )
+{
+	if ( CG_Credits_Running() )
+	{
+		const int iFontHeight = (int) (1.5f * (float) cgi_R_Font_HeightPixels(ghFontHandle, gfFontScale));	// taiwanese & japanese need 1.5 fontheight spacing
+
+//		cgi_R_SetColor( *gpv4Color );
+
+		// display cards first...
+		//
+		if (CreditData.CreditCards.size())
+		{
+			// grab first card off the list (we know there's at least one here, so...)
+			//
+			CreditCard_t &CreditCard = (*CreditData.CreditCards.begin());
+
+			if (CreditCard.iTime == -1)
+			{
+				// onceonly time init...
+				//
+				CreditCard.iTime = cg.time;
+			}
+
+			// play with the alpha channel for fade up/down...
+			//
+			const float fMilliSecondsElapsed = cg.time - CreditCard.iTime;
+			const float fSecondsElapsed		 = fMilliSecondsElapsed / 1000.0f;
+			if (fSecondsElapsed < fCARD_FADESECONDS)
+			{
+				// fading up...
+				//
+				gv4Color[3] = fSecondsElapsed / fCARD_FADESECONDS;
+//				OutputDebugString(va("fade up: %f\n",gv4Color[3]));
+			}
+			else
+			if (fSecondsElapsed > fCARD_FADESECONDS + fCARD_SUSTAINSECONDS)
+			{
+				// fading down...
+				//
+				const float fFadeDownSeconds = fSecondsElapsed - (fCARD_FADESECONDS + fCARD_SUSTAINSECONDS);
+				gv4Color[3] = 1.0f - (fFadeDownSeconds / fCARD_FADESECONDS);
+//				OutputDebugString(va("fade dw: %f\n",gv4Color[3]));
+			}
+			else
+			{
+				gv4Color[3] = 1.0f;
+//				OutputDebugString(va("normal: %f\n",gv4Color[3]));
+			}
+			if (gv4Color[3] < 0.0f)
+				gv4Color[3] = 0.0f;	// ... otherwise numbers that have dipped slightly -ve flash up fullbright after fade down
+
+			//
+			// how many lines is it?
+			//
+			int iLines = CreditCard.vstrText.size() + 2;	// +2 for title itself & one seperator line
+			//
+			int iYpos = (SCREEN_HEIGHT - (iLines * iFontHeight))/2;
+			//
+			// draw it, title first...
+			//
+			int iWidth = CreditCard.strTitle.GetPixelLength();
+			int iXpos  = (SCREEN_WIDTH - iWidth)/2;
+			cgi_R_Font_DrawString(iXpos, iYpos, CreditCard.strTitle.c_str(), gv4Color, ghFontHandle, -1, gfFontScale);
+			//
+			iYpos += iFontHeight*2;	// skip blank line then move to main pos
+			//
+			for (int i=0; i<CreditCard.vstrText.size(); i++)
+			{
+				StringAndSize_t &StringAndSize = CreditCard.vstrText[i];
+				iWidth = StringAndSize.GetPixelLength();
+				iXpos  = (SCREEN_WIDTH - iWidth)/2;
+				cgi_R_Font_DrawString(iXpos, iYpos, StringAndSize.c_str(), gv4Color, ghFontHandle, -1, gfFontScale);
+				iYpos += iFontHeight;
+			}
+
+			// next card?...
+			//
+			if (fSecondsElapsed > fCARD_FADESECONDS + fCARD_SUSTAINSECONDS + fCARD_FADESECONDS)
+			{
+				// yep, so erase the first entry (which will trigger the next one to be initialised on re-entry)...
+				//
+				CreditData.CreditCards.erase( CreditData.CreditCards.begin() );
+
+				if (!CreditData.CreditCards.size())
+				{
+					// all cards gone, so re-init timer for lines...
+					//
+					CreditData.iStartTime = cg.time;
+				}
+			}
+			//
+			return qtrue;
+		}
+		else
+		{
+			// doing scroll text...
+			//
+			if (CreditData.CreditLines.size())
+			{
+				// process all lines...
+				//
+				const float fMilliSecondsElapsed = cg.time - CreditData.iStartTime;
+				const float fSecondsElapsed		 = fMilliSecondsElapsed / 1000.0f;
+
+				bool bEraseOccured = false;
+				for (CreditLines_t::iterator it = CreditData.CreditLines.begin(); it != CreditData.CreditLines.end(); bEraseOccured ? it : ++it)
+				{
+					CreditLine_t &CreditLine = (*it);
+					bEraseOccured = false;
+
+					static const float fPixelsPerSecond = ((float)SCREEN_HEIGHT / fLINE_SECONDTOSCROLLUP);
+
+					int iYpos = SCREEN_HEIGHT + (CreditLine.iLine * iFontHeight);
+						iYpos-= (int) (fPixelsPerSecond * fSecondsElapsed);
+
+					int iTextLinesThisItem = max(CreditLine.vstrText.size(),1);
+					if (iYpos + (iTextLinesThisItem * iFontHeight) < 0)
+					{
+						// scrolled off top of screen, so erase it...
+						//
+						it = CreditData.CreditLines.erase( it );
+						bEraseOccured = true;
+					}
+					else
+					if (iYpos < SCREEN_HEIGHT)
+					{
+						// onscreen, so print it...
+						//
+						bool bIsDotted = !!CreditLine.vstrText.size();	// eg "STUNTS ...................... MR ED"
+
+						int iWidth = CreditLine.strText.GetPixelLength();
+						int iXpos  = bIsDotted ? 4 : (SCREEN_WIDTH - iWidth)/2;
+
+						gv4Color[3] = 1.0f;
+
+						cgi_R_Font_DrawString(iXpos, iYpos, CreditLine.strText.c_str(), gv4Color, ghFontHandle, -1, gfFontScale);
+
+						// now print any dotted members...
+						//
+						for (int i=0; i<CreditLine.vstrText.size(); i++)
+						{
+							StringAndSize_t &StringAndSize = CreditLine.vstrText[i];
+							iWidth = StringAndSize.GetPixelLength();
+							iXpos  = (SCREEN_WIDTH-4 - iWidth);
+							cgi_R_Font_DrawString(iXpos, iYpos, StringAndSize.c_str(), gv4Color, ghFontHandle, -1, gfFontScale);
+							iYpos += iFontHeight;
+						}
+					}
+				}
+
+				return qtrue;
+			}
+		}
+	}
+
+	return qfalse;
+}
+
+
+
+////////////////////// eof /////////////////////
+
diff --git a/code/cgame/cg_draw.cpp b/code/cgame/cg_draw.cpp
new file mode 100644
index 0000000..d8d9c1a
--- /dev/null
+++ b/code/cgame/cg_draw.cpp
@@ -0,0 +1,4134 @@
+// cg_draw.c -- draw all of the graphical elements during
+// active (after loading) gameplay
+
+// this line must stay at top so the whole PCH thing works...
+#include "cg_headers.h"
+
+//#include "cg_local.h"
+#include "cg_media.h"
+#include "..\game\objectives.h"
+#include "..\game\g_vehicles.h"
+
+#ifdef _XBOX
+#include "../client/fffx.h"
+#endif
+
+extern vmCvar_t	cg_debugHealthBars;
+
+extern Vehicle_t *G_IsRidingVehicle( gentity_t *ent );
+
+void CG_DrawIconBackground(void);
+void CG_DrawMissionInformation( void );
+void CG_DrawInventorySelect( void );
+void CG_DrawForceSelect( void );
+qboolean CG_WorldCoordToScreenCoord(vec3_t worldCoord, int *x, int *y);
+qboolean CG_WorldCoordToScreenCoordFloat(vec3_t worldCoord, float *x, float *y);
+
+extern float g_crosshairEntDist;
+extern int g_crosshairSameEntTime;
+extern int g_crosshairEntNum;
+extern int g_crosshairEntTime;
+qboolean cg_forceCrosshair = qfalse;
+
+// bad cheating
+extern int g_rocketLockEntNum;
+extern int g_rocketLockTime;
+extern int g_rocketSlackTime;
+
+vec3_t	vfwd;
+vec3_t	vright;
+vec3_t	vup;
+vec3_t	vfwd_n;
+vec3_t	vright_n;
+vec3_t	vup_n;
+int		infoStringCount;
+
+int cgRageTime = 0;
+int cgRageFadeTime = 0;
+float cgRageFadeVal = 0;
+
+int cgRageRecTime = 0;
+int cgRageRecFadeTime = 0;
+float cgRageRecFadeVal = 0;
+
+int cgAbsorbTime = 0;
+int cgAbsorbFadeTime = 0;
+float cgAbsorbFadeVal = 0;
+
+int cgProtectTime = 0;
+int cgProtectFadeTime = 0;
+float cgProtectFadeVal = 0;
+//===============================================================
+
+
+/*
+================
+CG_DrawMessageLit
+================
+*/
+static void CG_DrawMessageLit(centity_t *cent,int x,int y)
+{
+	cgi_R_SetColor(colorTable[CT_WHITE]);
+
+	if (cg.missionInfoFlashTime	> cg.time )
+	{
+		if (!((cg.time / 600 ) & 1))
+		{
+			if (!cg.messageLitActive)
+			{
+				/*
+
+				kef 4/16/03 --	as fun as this was, its time has passed. I will, however, hijack this cvar at James'
+								recommendation and use it for another nefarious purpose
+
+				if (cg_neverHearThatDumbBeepingSoundAgain.integer == 0)
+				{
+					cgi_S_StartSound( NULL, 0, CHAN_AUTO, cgs.media.messageLitSound );
+				}
+				*/
+				cg.messageLitActive = qtrue;
+			}
+
+			cgi_R_SetColor(colorTable[CT_HUD_RED]);
+			CG_DrawPic( x + 33,y + 41, 16,16, cgs.media.messageLitOn);
+		}
+		else
+		{
+			cg.messageLitActive = qfalse;
+		}
+	}
+
+	cgi_R_SetColor(colorTable[CT_WHITE]);
+	CG_DrawPic( x + 33,y + 41, 16,16, cgs.media.messageLitOff);
+
+}
+
+/*
+================
+CG_DrawForcePower
+
+Draw the force power graphics (tics) and the force power numeric amount. Any tics that are partial will
+be alphaed out.
+================
+*/
+static void CG_DrawForcePower(const centity_t *cent,const int xPos,const int yPos)
+{
+	int			i;
+	qboolean	flash=qfalse;
+	vec4_t		calcColor;
+	float		value,extra=0,inc,percent;
+
+	if ( !cent->gent->client->ps.forcePowersKnown )
+	{
+		return;
+	}
+
+	// Make the hud flash by setting forceHUDTotalFlashTime above cg.time
+	if (cg.forceHUDTotalFlashTime > cg.time )
+	{
+		flash = qtrue;
+		if (cg.forceHUDNextFlashTime < cg.time)	
+		{
+			cg.forceHUDNextFlashTime = cg.time + 400;
+			cgi_S_StartSound( NULL, 0, CHAN_AUTO, cgs.media.noforceSound );
+			if (cg.forceHUDActive)
+			{
+				cg.forceHUDActive = qfalse;
+			}
+			else
+			{
+				cg.forceHUDActive = qtrue;
+			}
+
+		}
+	}
+	else	// turn HUD back on if it had just finished flashing time.
+	{
+		cg.forceHUDNextFlashTime = 0;
+		cg.forceHUDActive = qtrue;
+	}
+
+	// I left the funtionality for flashing in because I might be needed yet.
+//	if (!cg.forceHUDActive)
+//	{
+//		return;
+//	}
+
+	inc = (float)  cent->gent->client->ps.forcePowerMax / MAX_HUD_TICS;
+	value = cent->gent->client->ps.forcePower;
+	if ( value > cent->gent->client->ps.forcePowerMax )
+	{//supercharged with force
+		extra = value - cent->gent->client->ps.forcePowerMax;
+		value = cent->gent->client->ps.forcePowerMax;
+	}
+
+	for (i=MAX_HUD_TICS-1;i>=0;i--)
+	{
+		if ( extra )
+		{//supercharged
+			memcpy(calcColor, colorTable[CT_WHITE], sizeof(vec4_t));
+			percent = 0.75f + (sin( cg.time * 0.005f )*((extra/cent->gent->client->ps.forcePowerMax)*0.25f));
+			calcColor[0] *= percent;
+			calcColor[1] *= percent;
+			calcColor[2] *= percent;
+		}
+		else if ( value <= 0 )	// no more
+		{
+			break;
+		}
+		else if (value < inc)	// partial tic
+		{
+			if (flash)
+			{
+				memcpy(calcColor,  colorTable[CT_RED], sizeof(vec4_t));
+			}
+			else 
+			{
+				memcpy(calcColor,  colorTable[CT_WHITE], sizeof(vec4_t));
+			}
+
+			percent = value / inc;
+			calcColor[3] = percent;
+		}
+		else
+		{
+			if (flash)
+			{
+				memcpy(calcColor,  colorTable[CT_RED], sizeof(vec4_t));
+			}
+			else 
+			{
+				memcpy(calcColor,  colorTable[CT_WHITE], sizeof(vec4_t));
+			}
+		}
+
+		cgi_R_SetColor( calcColor);
+		CG_DrawPic( forceTics[i].xPos, 
+			forceTics[i].yPos, 
+			forceTics[i].width, 
+			forceTics[i].height, 
+			forceTics[i].background );
+
+		value -= inc;
+	}
+
+	if (flash)
+	{
+		cgi_R_SetColor( colorTable[CT_RED] );	
+	}
+	else
+	{
+		cgi_R_SetColor( otherHUDBits[OHB_FORCEAMOUNT].color );	
+	}
+
+	// Print force numeric amount
+	CG_DrawNumField (
+		otherHUDBits[OHB_FORCEAMOUNT].xPos, 
+		otherHUDBits[OHB_FORCEAMOUNT].yPos, 
+		3, 
+		cent->gent->client->ps.forcePower, 
+		otherHUDBits[OHB_FORCEAMOUNT].width, 
+		otherHUDBits[OHB_FORCEAMOUNT].height, 
+		NUM_FONT_SMALL,
+		qfalse);
+}
+
+/*
+================
+CG_DrawSaberStyle
+
+If the weapon is a light saber (which needs no ammo) then draw a graphic showing
+the saber style (fast, medium, strong)
+================
+*/
+static void CG_DrawSaberStyle(const centity_t	*cent,const int xPos,const int yPos)
+{
+	int index;
+
+	if (!cent->currentState.weapon ) // We don't have a weapon right now
+	{
+		return;
+	}
+
+	if ( cent->currentState.weapon != WP_SABER || !cent->gent )
+	{
+		return;
+	}
+
+	cgi_R_SetColor( colorTable[CT_WHITE] );
+
+	if ( !cg.saberAnimLevelPending && cent->gent->client )
+	{//uninitialized after a loadgame, cheat across and get it
+		cg.saberAnimLevelPending = cent->gent->client->ps.saberAnimLevel;
+	}
+
+	// don't need to draw ammo, but we will draw the current saber style in this window
+	if (cg.saberAnimLevelPending == SS_FAST
+		|| cg.saberAnimLevelPending == SS_TAVION )
+	{
+		index = OHB_SABERSTYLE_FAST;
+	}
+	else if (cg.saberAnimLevelPending == SS_MEDIUM
+		|| cg.saberAnimLevelPending == SS_DUAL
+		|| cg.saberAnimLevelPending == SS_STAFF )
+	{
+		index = OHB_SABERSTYLE_MEDIUM;
+	}
+	else 
+	{
+		index = OHB_SABERSTYLE_STRONG;
+	}
+
+	cgi_R_SetColor( otherHUDBits[index].color);
+
+	CG_DrawPic( 
+		otherHUDBits[index].xPos,
+		otherHUDBits[index].yPos,
+		otherHUDBits[index].width, 
+		otherHUDBits[index].height, 
+		otherHUDBits[index].background 
+		);
+
+}
+
+/*
+================
+CG_DrawAmmo
+
+Draw the ammo graphics (tics) and the ammo numeric amount. Any tics that are partial will
+be alphaed out. 
+================
+*/
+static void CG_DrawAmmo(const centity_t	*cent,const int xPos,const int yPos)
+{
+	playerState_t	*ps;
+	int			i;
+	vec4_t		calcColor;
+	float		currValue=0,inc;
+
+	if (!cent->currentState.weapon ) // We don't have a weapon right now
+	{
+		return;
+	}
+
+	if ( cent->currentState.weapon == WP_STUN_BATON )
+	{
+		return;
+	}
+
+	ps = &cg.snap->ps;
+
+	currValue = ps->ammo[weaponData[cent->currentState.weapon].ammoIndex];
+
+	if (currValue < 0)	// No ammo
+	{
+		return;
+	}
+
+
+	//
+	// ammo
+	//
+	if (cg.oldammo < currValue)
+	{
+		cg.oldAmmoTime = cg.time + 200;
+	}
+
+	cg.oldammo = currValue;
+
+
+	// Determine the color of the numeric field
+
+	// Firing or reloading?
+	if (( cg.predicted_player_state.weaponstate == WEAPON_FIRING
+		&& cg.predicted_player_state.weaponTime > 100 ))
+	{
+		memcpy(calcColor, colorTable[CT_LTGREY], sizeof(vec4_t));
+	} 
+	else 
+	{
+		if ( currValue > 0 ) 
+		{
+			if (cg.oldAmmoTime > cg.time)
+			{
+				memcpy(calcColor, colorTable[CT_YELLOW], sizeof(vec4_t));
+			}
+			else
+			{
+				memcpy(calcColor, otherHUDBits[OHB_AMMOAMOUNT].color, sizeof(vec4_t));
+			}
+		} 
+		else 
+		{
+			memcpy(calcColor, colorTable[CT_RED], sizeof(vec4_t));
+		}
+	}
+
+	// Print number amount
+	cgi_R_SetColor( calcColor );	
+
+	CG_DrawNumField (
+		otherHUDBits[OHB_AMMOAMOUNT].xPos, 
+		otherHUDBits[OHB_AMMOAMOUNT].yPos, 
+		3, 
+		ps->ammo[weaponData[cent->currentState.weapon].ammoIndex], 
+		otherHUDBits[OHB_AMMOAMOUNT].width, 
+		otherHUDBits[OHB_AMMOAMOUNT].height, 
+		NUM_FONT_SMALL,
+		qfalse);
+
+
+
+	inc = (float) ammoData[weaponData[cent->currentState.weapon].ammoIndex].max / MAX_HUD_TICS;
+	currValue =ps->ammo[weaponData[cent->currentState.weapon].ammoIndex];
+	memcpy(calcColor, colorTable[CT_WHITE], sizeof(vec4_t));
+
+	for (i=MAX_HUD_TICS-1;i>=0;i--)
+	{
+
+		if (currValue <= 0)	// don't show tic
+		{
+			break;
+		}
+		else if (currValue < inc)	// partial tic (alpha it out)
+		{
+			memcpy(calcColor, ammoTics[i].color, sizeof(vec4_t));
+			float percent = currValue / inc;
+			calcColor[3] *= percent;
+		}
+
+		cgi_R_SetColor( calcColor);
+		CG_DrawPic( ammoTics[i].xPos, 
+			ammoTics[i].yPos, 
+			ammoTics[i].width, 
+			ammoTics[i].height, 
+			ammoTics[i].background );
+
+		currValue -= inc;
+	}
+
+}
+
+
+/*
+================
+CG_DrawHealth
+================
+*/
+static void CG_DrawHealth(const int x,const int y,const int w,const int h)
+{
+	vec4_t			calcColor;
+	playerState_t	*ps = &cg.snap->ps;
+
+	// Print all the tics of the health graphic
+	// Look at the amount of health left and show only as much of the graphic as there is health.
+	// Use alpha to fade out partial section of health
+	float inc = (float) ps->stats[STAT_MAX_HEALTH] / MAX_HUD_TICS;
+	float currValue = ps->stats[STAT_HEALTH];
+	memcpy(calcColor, colorTable[CT_WHITE], sizeof(vec4_t));
+	int i;
+	for (i=(MAX_HUD_TICS-1);i>=0;i--)
+	{
+
+		if (currValue <= 0)	// don't show tic
+		{
+			break;
+		}
+		else if (currValue < inc)	// partial tic (alpha it out)
+		{
+			memcpy(calcColor, healthTics[i].color, sizeof(vec4_t));
+			float percent = currValue / inc;
+			calcColor[3] *= percent;		// Fade it out
+		}
+
+		cgi_R_SetColor( calcColor);
+
+		CG_DrawPic( 
+			healthTics[i].xPos,
+			healthTics[i].yPos,
+			healthTics[i].width, 
+			healthTics[i].height, 
+			healthTics[i].background 
+			);
+
+		currValue -= inc;
+	}
+
+
+	// Print force health amount
+	cgi_R_SetColor( otherHUDBits[OHB_HEALTHAMOUNT].color );	
+
+	CG_DrawNumField (
+		otherHUDBits[OHB_HEALTHAMOUNT].xPos, 
+		otherHUDBits[OHB_HEALTHAMOUNT].yPos, 
+		3, 
+		ps->stats[STAT_HEALTH], 
+		otherHUDBits[OHB_HEALTHAMOUNT].width, 
+		otherHUDBits[OHB_HEALTHAMOUNT].height, 
+		NUM_FONT_SMALL,
+		qfalse);
+
+}
+
+/*
+================
+CG_DrawArmor
+
+Draw the armor graphics (tics) and the armor numeric amount. Any tics that are partial will
+be alphaed out.
+================
+*/
+static void CG_DrawArmor(const int x,const int y,const int w,const int h)
+{
+	vec4_t			calcColor;
+	playerState_t	*ps = &cg.snap->ps;
+
+	// Print all the tics of the armor graphic
+	// Look at the amount of armor left and show only as much of the graphic as there is armor.
+	// Use alpha to fade out partial section of armor 
+	// MAX_HEALTH is the same thing as max armor
+	float inc = (float) ps->stats[STAT_MAX_HEALTH] / MAX_HUD_TICS;
+	float currValue = ps->stats[STAT_ARMOR];
+
+	memcpy(calcColor, colorTable[CT_WHITE], sizeof(vec4_t));
+	int i;
+	for (i=(MAX_HUD_TICS-1);i>=0;i--)
+	{
+
+		if (currValue <= 0)	// don't show tic
+		{
+			break;
+		}
+		else if (currValue < inc)	// partial tic (alpha it out)
+		{
+			memcpy(calcColor, armorTics[i].color, sizeof(vec4_t));
+			float percent = currValue / inc;
+			calcColor[3] *= percent;
+		}
+
+		cgi_R_SetColor( calcColor);
+
+		if ((i==(MAX_HUD_TICS-1)) && (currValue < inc))
+		{
+			if (cg.HUDArmorFlag)
+			{
+				CG_DrawPic( 
+					armorTics[i].xPos,
+					armorTics[i].yPos,
+					armorTics[i].width, 
+					armorTics[i].height, 
+					armorTics[i].background
+					);
+			}
+		}
+		else 
+		{
+			CG_DrawPic( 
+				armorTics[i].xPos,
+				armorTics[i].yPos,
+				armorTics[i].width, 
+				armorTics[i].height, 
+				armorTics[i].background
+				);
+		}
+
+		currValue -= inc;
+	}
+
+	// Print armor amount
+	cgi_R_SetColor( otherHUDBits[OHB_ARMORAMOUNT].color );	
+
+	CG_DrawNumField (
+		otherHUDBits[OHB_ARMORAMOUNT].xPos, 
+		otherHUDBits[OHB_ARMORAMOUNT].yPos, 
+		3, 
+		ps->stats[STAT_ARMOR], 
+		otherHUDBits[OHB_ARMORAMOUNT].width, 
+		otherHUDBits[OHB_ARMORAMOUNT].height, 
+		NUM_FONT_SMALL,
+		qfalse);
+
+
+	// If armor is low, flash a graphic to warn the player
+	if (ps->stats[STAT_ARMOR])	// Is there armor? Draw the HUD Armor TIC
+	{
+		float quarterArmor = (float) (ps->stats[STAT_MAX_HEALTH] / 4.0f);
+
+		// Make tic flash if armor is at 25% of full armor
+		if (ps->stats[STAT_ARMOR] < quarterArmor)		// Do whatever the flash timer says
+		{
+			if (cg.HUDTickFlashTime < cg.time)			// Flip at the same time
+			{
+				cg.HUDTickFlashTime = cg.time + 400;
+				if (cg.HUDArmorFlag)
+				{
+					cg.HUDArmorFlag = qfalse;
+				}
+				else
+				{
+					cg.HUDArmorFlag = qtrue;
+				}
+			}
+		}
+		else
+		{
+			cg.HUDArmorFlag=qtrue;
+		}
+	}
+	else						// No armor? Don't show it.
+	{
+		cg.HUDArmorFlag=qfalse;
+	}
+
+}
+
+#define MAX_VHUD_SHIELD_TICS 12
+#define MAX_VHUD_SPEED_TICS 5
+#define MAX_VHUD_ARMOR_TICS 5
+#define MAX_VHUD_AMMO_TICS 5
+
+static void CG_DrawVehicleSheild( const centity_t *cent, const Vehicle_t *pVeh )
+{
+	int xPos,yPos,width,height,i;
+	vec4_t	color,calcColor;
+	qhandle_t	background;
+	char itemName[64];
+	float inc, currValue,maxHealth;
+
+	//riding some kind of living creature 
+	if ( pVeh->m_pVehicleInfo->type == VH_ANIMAL || pVeh->m_pVehicleInfo->type == VH_FLIER )
+	{
+		maxHealth = 100.0f;
+		currValue = pVeh->m_pParentEntity->health;
+	}
+	else //normal vehicle 
+	{
+		maxHealth = pVeh->m_pVehicleInfo->armor;
+		currValue = pVeh->m_iArmor;
+	}
+
+	if (cgi_UI_GetMenuItemInfo(
+		"swoopvehiclehud",
+		"shieldbackground",
+		&xPos,
+		&yPos,
+		&width,
+		&height,
+		color,
+		&background))
+	{
+		cgi_R_SetColor( color );
+		CG_DrawPic( xPos, yPos, width, height, background );
+	}
+
+	// Print all the tics of the shield graphic
+	// Look at the amount of health left and show only as much of the graphic as there is health.
+	// Use alpha to fade out partial section of health
+	inc = (float) maxHealth / MAX_VHUD_SHIELD_TICS;
+	for (i=1;i <= MAX_VHUD_SHIELD_TICS;i++)
+	{
+		sprintf( itemName, "shield_tic%d",	i );
+
+		if (!cgi_UI_GetMenuItemInfo(
+			"swoopvehiclehud",
+			itemName,
+			&xPos,
+			&yPos,
+			&width,
+			&height,
+			color,
+			&background))
+		{
+			continue;
+		}
+
+		memcpy(calcColor, color, sizeof(vec4_t));
+
+		if (currValue <= 0)	// don't show tic
+		{
+			break;
+		}
+		else if (currValue < inc)	// partial tic (alpha it out)
+		{
+			float percent = currValue / inc;
+			calcColor[3] *= percent;		// Fade it out
+		}
+
+		cgi_R_SetColor( calcColor);
+
+		CG_DrawPic( xPos, yPos, width, height, background );
+
+		currValue -= inc;
+	}
+}
+
+// The HUD.menu file has the graphic print with a negative height, so it will print from the bottom up.
+static void CG_DrawVehicleTurboRecharge( const centity_t *cent, const Vehicle_t *pVeh )
+{
+	int xPos,yPos,width,height;
+	qhandle_t	background;
+	vec4_t	color;
+
+	if (cgi_UI_GetMenuItemInfo(
+		"swoopvehiclehud",
+		"turborecharge",
+		&xPos,
+		&yPos,
+		&width,
+		&height,
+		color,
+		&background))
+	{
+		float percent=0.0f;
+		int diff = ( cg.time - pVeh->m_iTurboTime );
+
+		// Calc max time
+
+		if (diff > pVeh->m_pVehicleInfo->turboRecharge)
+		{
+			percent = 1.0f;
+			cgi_R_SetColor( colorTable[CT_GREEN] );
+		}
+		else 
+		{
+			percent = (float) diff / pVeh->m_pVehicleInfo->turboRecharge;
+			if (percent < 0.0f)
+			{
+				percent = 0.0f;
+			}
+			cgi_R_SetColor( colorTable[CT_RED] );
+		}
+
+		height *= percent;
+
+		CG_DrawPic(xPos,yPos, width, height, cgs.media.whiteShader);	// Top
+	}
+
+
+}
+
+static void CG_DrawVehicleSpeed( const centity_t *cent, const Vehicle_t *pVeh, const char *entHud )
+{
+	int xPos,yPos,width,height;
+	qhandle_t	background;
+	gentity_t *parent = pVeh->m_pParentEntity;
+	playerState_t *parentPS = &parent->client->ps;
+	float currValue,maxSpeed;
+	vec4_t	color,calcColor;
+	float inc;
+	int i;
+	char itemName[64];
+
+	if (cgi_UI_GetMenuItemInfo(
+		entHud,
+		"speedbackground",
+		&xPos,
+		&yPos,
+		&width,
+		&height,
+		color,
+		&background))
+	{
+		cgi_R_SetColor( color );
+		CG_DrawPic( xPos, yPos, width, height, background );
+	}
+
+	maxSpeed = pVeh->m_pVehicleInfo->speedMax;
+	currValue = parentPS->speed;
+
+	// Print all the tics of the shield graphic
+	// Look at the amount of health left and show only as much of the graphic as there is health.
+	// Use alpha to fade out partial section of health
+	inc = (float) maxSpeed / MAX_VHUD_SPEED_TICS;
+	for (i=1;i<=MAX_VHUD_SPEED_TICS;i++)
+	{
+		sprintf( itemName, "speed_tic%d",	i );
+
+		if (!cgi_UI_GetMenuItemInfo(
+			entHud,
+			itemName,
+			&xPos,
+			&yPos,
+			&width,
+			&height,
+			color,
+			&background))
+		{
+			continue;
+		}
+
+		if ( level.time > pVeh->m_iTurboTime )
+		{
+			memcpy(calcColor, color, sizeof(vec4_t));
+		}
+		else	// In turbo mode
+		{
+			if (cg.VHUDFlashTime < cg.time)	
+			{
+				cg.VHUDFlashTime = cg.time + 400;
+				if (cg.VHUDTurboFlag)
+				{
+					cg.VHUDTurboFlag = qfalse;
+				}
+				else
+				{
+					cg.VHUDTurboFlag = qtrue;
+				}
+			}
+
+			if (cg.VHUDTurboFlag)
+			{
+				memcpy(calcColor, colorTable[CT_LTRED1], sizeof(vec4_t));
+			}
+			else
+			{
+				memcpy(calcColor, color, sizeof(vec4_t));
+			}
+		}
+
+
+		if (currValue <= 0)	// don't show tic
+		{
+			break;
+		}
+		else if (currValue < inc)	// partial tic (alpha it out)
+		{
+			float percent = currValue / inc;
+			calcColor[3] *= percent;		// Fade it out
+		}
+
+		cgi_R_SetColor( calcColor);
+
+		CG_DrawPic( xPos, yPos, width, height, background );
+
+		currValue -= inc;
+	}
+
+}
+
+static void CG_DrawVehicleArmor( const centity_t *cent, const Vehicle_t *pVeh )
+{
+	int xPos,yPos,width,height,i;
+	qhandle_t	background;
+	char itemName[64];
+	float inc, currValue,maxArmor;
+	vec4_t	color,calcColor;
+
+	if (cgi_UI_GetMenuItemInfo(
+		"swoopvehiclehud",
+		"armorbackground",
+		&xPos,
+		&yPos,
+		&width,
+		&height,
+		color,
+		&background))
+	{
+		cgi_R_SetColor( color );
+		CG_DrawPic( xPos, yPos, width, height, background );
+	}
+
+	maxArmor = pVeh->m_iArmor;
+	currValue = pVeh->m_pVehicleInfo->armor;
+
+	// Print all the tics of the shield graphic
+	// Look at the amount of health left and show only as much of the graphic as there is health.
+	// Use alpha to fade out partial section of health
+	inc = (float) maxArmor / MAX_VHUD_ARMOR_TICS;
+	for (i=1;i<=MAX_VHUD_ARMOR_TICS;i++)
+	{
+		sprintf( itemName, "armor_tic%d",	i );
+
+		if (!cgi_UI_GetMenuItemInfo(
+			"swoopvehiclehud",
+			itemName,
+			&xPos,
+			&yPos,
+			&width,
+			&height,
+			color,
+			&background))
+		{
+			continue;
+		}
+
+		memcpy(calcColor, color, sizeof(vec4_t));
+
+		if (currValue <= 0)	// don't show tic
+		{
+			break;
+		}
+		else if (currValue < inc)	// partial tic (alpha it out)
+		{
+			float percent = currValue / inc;
+			calcColor[3] *= percent;		// Fade it out
+		}
+
+		cgi_R_SetColor( calcColor);
+
+		CG_DrawPic( xPos, yPos, width, height, background );
+
+		currValue -= inc;
+	}
+}
+
+static void CG_DrawVehicleAmmo( const centity_t *cent, const Vehicle_t *pVeh )
+{
+	int xPos,yPos,width,height,i;
+	qhandle_t	background;
+	char itemName[64];
+	float inc, currValue,maxAmmo;
+	vec4_t	color,calcColor;
+
+	if (cgi_UI_GetMenuItemInfo(
+		"swoopvehiclehud",
+		"ammobackground",
+		&xPos,
+		&yPos,
+		&width,
+		&height,
+		color,
+		&background))
+	{
+		cgi_R_SetColor( color );
+		CG_DrawPic( xPos, yPos, width, height, background );
+	}
+
+	maxAmmo = pVeh->m_pVehicleInfo->weapon[0].ammoMax;
+	currValue = pVeh->weaponStatus[0].ammo;
+	inc = (float) maxAmmo / MAX_VHUD_AMMO_TICS;
+	for (i=1;i<=MAX_VHUD_AMMO_TICS;i++)
+	{
+		sprintf( itemName, "ammo_tic%d",	i );
+
+		if (!cgi_UI_GetMenuItemInfo(
+			"swoopvehiclehud",
+			itemName,
+			&xPos,
+			&yPos,
+			&width,
+			&height,
+			color,
+			&background))
+		{
+			continue;
+		}
+
+		memcpy(calcColor, color, sizeof(vec4_t));
+
+		if (currValue <= 0)	// don't show tic
+		{
+			break;
+		}
+		else if (currValue < inc)	// partial tic (alpha it out)
+		{
+			float percent = currValue / inc;
+			calcColor[3] *= percent;		// Fade it out
+		}
+
+		cgi_R_SetColor( calcColor );
+		CG_DrawPic( xPos, yPos, width, height, background );
+
+		currValue -= inc;
+	}
+}
+
+ 
+static void CG_DrawVehicleAmmoUpper( const centity_t *cent, const Vehicle_t *pVeh )
+{
+	int xPos,yPos,width,height,i;
+	qhandle_t	background;
+	char itemName[64];
+	float inc, currValue,maxAmmo;
+	vec4_t	color,calcColor;
+
+	if (cgi_UI_GetMenuItemInfo(
+		"swoopvehiclehud",
+		"ammoupperbackground",
+		&xPos,
+		&yPos,
+		&width,
+		&height,
+		color,
+		&background))
+	{
+		cgi_R_SetColor( color );
+		CG_DrawPic( xPos, yPos, width, height, background );
+	}
+
+	maxAmmo = pVeh->m_pVehicleInfo->weapon[0].ammoMax;
+	currValue = pVeh->weaponStatus[0].ammo;
+	inc = (float) maxAmmo / MAX_VHUD_AMMO_TICS;
+	for (i=1;i<MAX_VHUD_AMMO_TICS;i++)
+	{
+		sprintf( itemName, "ammoupper_tic%d",	i );
+
+		if (!cgi_UI_GetMenuItemInfo(
+			"swoopvehiclehud",
+			itemName,
+			&xPos,
+			&yPos,
+			&width,
+			&height,
+			color,
+			&background))
+		{
+			continue;
+		}
+
+		memcpy(calcColor, color, sizeof(vec4_t));
+
+		if (currValue <= 0)	// don't show tic
+		{
+			break;
+		}
+		else if (currValue < inc)	// partial tic (alpha it out)
+		{
+			float percent = currValue / inc;
+			calcColor[3] *= percent;		// Fade it out
+		}
+
+		cgi_R_SetColor( calcColor );
+		CG_DrawPic( xPos, yPos, width, height, background );
+
+		currValue -= inc;
+	}
+}
+
+
+static void CG_DrawVehicleAmmoLower( const centity_t *cent, const Vehicle_t *pVeh )
+{
+	int xPos,yPos,width,height,i;
+	qhandle_t	background;
+	char itemName[64];
+	float inc, currValue,maxAmmo;
+	vec4_t	color,calcColor;
+
+	if (cgi_UI_GetMenuItemInfo(
+		"swoopvehiclehud",
+		"ammolowerbackground",
+		&xPos,
+		&yPos,
+		&width,
+		&height,
+		color,
+		&background))
+	{
+		cgi_R_SetColor( color );
+		CG_DrawPic( xPos, yPos, width, height, background );
+	}
+
+	maxAmmo = pVeh->m_pVehicleInfo->weapon[1].ammoMax;
+	currValue = pVeh->weaponStatus[1].ammo;
+	inc = (float) maxAmmo / MAX_VHUD_AMMO_TICS;
+	for (i=1;i<MAX_VHUD_AMMO_TICS;i++)
+	{
+		sprintf( itemName, "ammolower_tic%d",	i );
+
+		if (!cgi_UI_GetMenuItemInfo(
+			"swoopvehiclehud",
+			itemName,
+			&xPos,
+			&yPos,
+			&width,
+			&height,
+			color,
+			&background))
+		{
+			continue;
+		}
+
+		memcpy(calcColor, color, sizeof(vec4_t));
+
+		if (currValue <= 0)	// don't show tic
+		{
+			break;
+		}
+		else if (currValue < inc)	// partial tic (alpha it out)
+		{
+			float percent = currValue / inc;
+			calcColor[3] *= percent;		// Fade it out
+		}
+
+		cgi_R_SetColor( calcColor );
+		CG_DrawPic( xPos, yPos, width, height, background );
+
+		currValue -= inc;
+	}
+}
+
+static void CG_DrawVehicleHud( const centity_t *cent, const Vehicle_t *pVeh )
+{
+	int xPos,yPos,width,height;
+	vec4_t	color;
+	qhandle_t	background;
+
+	CG_DrawVehicleTurboRecharge( cent, pVeh );
+
+	// Draw frame
+	if (cgi_UI_GetMenuItemInfo(
+		"swoopvehiclehud",
+		"leftframe",
+		&xPos,
+		&yPos,
+		&width,
+		&height,
+		color,
+		&background))
+	{
+		cgi_R_SetColor( color );
+		CG_DrawPic( xPos, yPos, width, height, background );
+	}
+
+	if (cgi_UI_GetMenuItemInfo(
+		"swoopvehiclehud",
+		"rightframe",
+		&xPos,
+		&yPos,
+		&width,
+		&height,
+		color,
+		&background))
+	{
+		cgi_R_SetColor( color );
+		CG_DrawPic( xPos, yPos, width, height, background );
+	}
+	
+	CG_DrawVehicleSheild( cent, pVeh );
+
+	CG_DrawVehicleSpeed( cent, pVeh, "swoopvehiclehud" );
+
+	CG_DrawVehicleArmor( cent, pVeh );
+
+	CG_DrawVehicleAmmo( cent, pVeh );
+
+	if (0)
+	{
+		CG_DrawVehicleAmmoUpper( cent, pVeh );
+	}
+
+	if (0)
+	{
+		CG_DrawVehicleAmmoLower( cent, pVeh );
+	}
+
+}
+
+static void CG_DrawTauntaunHud( const centity_t *cent, const Vehicle_t *pVeh )
+{
+	int xPos,yPos,width,height;
+	vec4_t	color;
+	qhandle_t	background;
+
+	CG_DrawVehicleTurboRecharge( cent, pVeh );
+
+	// Draw frame
+	if (cgi_UI_GetMenuItemInfo(
+		"swoopvehiclehud",
+		"leftframe",
+		&xPos,
+		&yPos,
+		&width,
+		&height,
+		color,
+		&background))
+	{
+		cgi_R_SetColor( color );
+		CG_DrawPic( xPos, yPos, width, height, background );
+	}
+
+	if (cgi_UI_GetMenuItemInfo(
+		"swoopvehiclehud",
+		"rightframe",
+		&xPos,
+		&yPos,
+		&width,
+		&height,
+		color,
+		&background))
+	{
+		cgi_R_SetColor( color );
+		CG_DrawPic( xPos, yPos, width, height, background );
+	}
+	
+	CG_DrawVehicleSheild( cent, pVeh );
+
+	CG_DrawVehicleSpeed( cent, pVeh, "tauntaunhud" );
+
+	if (0)
+	{
+		CG_DrawVehicleAmmoUpper( cent, pVeh );
+	}
+
+	if (0)
+	{
+		CG_DrawVehicleAmmoLower( cent, pVeh );
+	}
+
+}
+
+
+
+static void CG_DrawEmplacedGunHealth( const centity_t *cent )
+{
+	int xPos,yPos,width,height,i, health=0;
+	vec4_t	color,calcColor;
+	qhandle_t	background;
+	char itemName[64];
+	float inc, currValue,maxHealth;
+
+	if ( cent->gent && cent->gent->owner )
+	{
+		if (( cent->gent->owner->flags & FL_GODMODE ))
+		{
+			// chair is in godmode, so render the health of the player instead
+			health = cent->gent->health;
+		}
+		else
+		{
+			// render the chair health
+			health = cent->gent->owner->health;
+		}
+	}
+	else
+	{
+		return;
+	}
+	//riding some kind of living creature 
+	maxHealth = (float)cent->gent->max_health;
+	currValue = health;
+
+	if (cgi_UI_GetMenuItemInfo(
+		"swoopvehiclehud",
+		"shieldbackground",
+		&xPos,
+		&yPos,
+		&width,
+		&height,
+		color,
+		&background))
+	{
+		cgi_R_SetColor( color );
+		CG_DrawPic( xPos, yPos, width, height, background );
+	}
+
+	// Print all the tics of the shield graphic
+	// Look at the amount of health left and show only as much of the graphic as there is health.
+	// Use alpha to fade out partial section of health
+	inc = (float) maxHealth / MAX_VHUD_SHIELD_TICS;
+	for (i=1;i <= MAX_VHUD_SHIELD_TICS;i++)
+	{
+		sprintf( itemName, "shield_tic%d",	i );
+
+		if (!cgi_UI_GetMenuItemInfo(
+			"swoopvehiclehud",
+			itemName,
+			&xPos,
+			&yPos,
+			&width,
+			&height,
+			color,
+			&background))
+		{
+			continue;
+		}
+
+		memcpy(calcColor, color, sizeof(vec4_t));
+
+		if (currValue <= 0)	// don't show tic
+		{
+			break;
+		}
+		else if (currValue < inc)	// partial tic (alpha it out)
+		{
+			float percent = currValue / inc;
+			calcColor[3] *= percent;		// Fade it out
+		}
+
+		cgi_R_SetColor( calcColor);
+
+		CG_DrawPic( xPos, yPos, width, height, background );
+
+		currValue -= inc;
+	}
+}
+
+static void CG_DrawEmplacedGunHud( const centity_t *cent )
+{
+	int xPos,yPos,width,height;
+	vec4_t	color;
+	qhandle_t	background;
+
+	// Draw frame
+	if (cgi_UI_GetMenuItemInfo(
+		"swoopvehiclehud",
+		"leftframe",
+		&xPos,
+		&yPos,
+		&width,
+		&height,
+		color,
+		&background))
+	{
+		cgi_R_SetColor( color );
+		CG_DrawPic( xPos, yPos, width, height, background );
+	}
+
+	if (cgi_UI_GetMenuItemInfo(
+		"swoopvehiclehud",
+		"rightframe",
+		&xPos,
+		&yPos,
+		&width,
+		&height,
+		color,
+		&background))
+	{
+		cgi_R_SetColor( color );
+		CG_DrawPic( xPos, yPos, width, height, background );
+	}
+
+	CG_DrawEmplacedGunHealth( cent );
+
+}
+
+
+static void CG_DrawItemHealth( float currValue, float maxHealth )
+{
+	int xPos,yPos,width,height,i;
+	vec4_t	color,calcColor;
+	qhandle_t	background;
+	char itemName[64];
+	float inc;
+
+	if (cgi_UI_GetMenuItemInfo(
+		"swoopvehiclehud",
+		"shieldbackground",
+		&xPos,
+		&yPos,
+		&width,
+		&height,
+		color,
+		&background))
+	{
+		cgi_R_SetColor( color );
+		CG_DrawPic( xPos, yPos, width, height, background );
+	}
+
+	// Print all the tics of the shield graphic
+	// Look at the amount of health left and show only as much of the graphic as there is health.
+	// Use alpha to fade out partial section of health
+	inc = (float) maxHealth / MAX_VHUD_SHIELD_TICS;
+	for (i=1;i <= MAX_VHUD_SHIELD_TICS;i++)
+	{
+		sprintf( itemName, "shield_tic%d",	i );
+
+		if (!cgi_UI_GetMenuItemInfo(
+			"swoopvehiclehud",
+			itemName,
+			&xPos,
+			&yPos,
+			&width,
+			&height,
+			color,
+			&background))
+		{
+			continue;
+		}
+
+		memcpy(calcColor, color, sizeof(vec4_t));
+
+		if (currValue <= 0)	// don't show tic
+		{
+			break;
+		}
+		else if (currValue < inc)	// partial tic (alpha it out)
+		{
+			float percent = currValue / inc;
+			calcColor[3] *= percent;		// Fade it out
+		}
+
+		cgi_R_SetColor( calcColor);
+
+		CG_DrawPic( xPos, yPos, width, height, background );
+
+		currValue -= inc;
+	}
+}
+
+static void CG_DrawPanelTurretHud( void )
+{
+	int xPos,yPos,width,height;
+	vec4_t	color;
+	qhandle_t	background;
+
+	// Draw frame
+	if (cgi_UI_GetMenuItemInfo(
+		"swoopvehiclehud",
+		"leftframe",
+		&xPos,
+		&yPos,
+		&width,
+		&height,
+		color,
+		&background))
+	{
+		cgi_R_SetColor( color );
+		CG_DrawPic( xPos, yPos, width, height, background );
+	}
+
+	if (cgi_UI_GetMenuItemInfo(
+		"swoopvehiclehud",
+		"rightframe",
+		&xPos,
+		&yPos,
+		&width,
+		&height,
+		color,
+		&background))
+	{
+		cgi_R_SetColor( color );
+		CG_DrawPic( xPos, yPos, width, height, background );
+	}
+
+	CG_DrawItemHealth( 
+		g_entities[cg.snap->ps.viewEntity].health, 
+		(float)g_entities[cg.snap->ps.viewEntity].max_health
+		);
+
+}
+
+static void CG_DrawATSTHud( centity_t *cent )
+{
+	int xPos,yPos,width,height;
+	vec4_t	color;
+	qhandle_t	background;
+	float	health;
+
+	if ( !cg.snap
+		||!g_entities[cg.snap->ps.viewEntity].activator )
+	{
+		return;
+	}
+
+	// Draw frame
+	if (cgi_UI_GetMenuItemInfo(
+		"swoopvehiclehud",
+		"leftframe",
+		&xPos,
+		&yPos,
+		&width,
+		&height,
+		color,
+		&background))
+	{
+		cgi_R_SetColor( color );
+		CG_DrawPic( xPos, yPos, width, height, background );
+	}
+
+	if (cgi_UI_GetMenuItemInfo(
+		"swoopvehiclehud",
+		"rightframe",
+		&xPos,
+		&yPos,
+		&width,
+		&height,
+		color,
+		&background))
+	{
+		cgi_R_SetColor( color );
+		CG_DrawPic( xPos, yPos, width, height, background );
+	}
+
+	// we just calc the display value from the sum of health and armor
+	if ( g_entities[cg.snap->ps.viewEntity].activator ) // ensure we can look back to the atst_drivable to get the max health
+	{
+		health = ( g_entities[cg.snap->ps.viewEntity].health + g_entities[cg.snap->ps.viewEntity].client->ps.stats[STAT_ARMOR] );
+	}
+	else
+	{
+		health = ( g_entities[cg.snap->ps.viewEntity].health + g_entities[cg.snap->ps.viewEntity].client->ps.stats[STAT_ARMOR] );
+	}
+
+	CG_DrawItemHealth(health,g_entities[cg.snap->ps.viewEntity].activator->max_health );
+
+	if (cgi_UI_GetMenuItemInfo(
+		"atsthud",
+		"background",
+		&xPos,
+		&yPos,
+		&width,
+		&height,
+		color,
+		&background))
+	{
+		cgi_R_SetColor( color );
+
+		CG_DrawPic( xPos, yPos, width, height, background );
+	}
+
+	if (cgi_UI_GetMenuItemInfo(
+		"atsthud",
+		"outer_frame",
+		&xPos,
+		&yPos,
+		&width,
+		&height,
+		color,
+		&background))
+	{
+		cgi_R_SetColor( color );
+		CG_DrawPic( xPos, yPos, width, height, background );
+	}
+
+	if (cgi_UI_GetMenuItemInfo(
+		"atsthud",
+		"left_pic",
+		&xPos,
+		&yPos,
+		&width,
+		&height,
+		color,
+		&background))
+	{
+		cgi_R_SetColor( color );
+
+		CG_DrawPic( xPos, yPos, width, height, background );
+	}
+}
+
+//-----------------------------------------------------
+static qboolean CG_DrawCustomHealthHud( centity_t *cent )
+{
+	Vehicle_t *pVeh;
+
+	// In a Weapon?
+	if (( cent->currentState.eFlags & EF_LOCKED_TO_WEAPON ))
+	{
+		CG_DrawEmplacedGunHud(cent);
+
+		// DRAW emplaced HUD
+/*		color[0] = color[1] = color[2] = 0.0f;
+		color[3] = 0.3f;
+
+		cgi_R_SetColor( color );
+		CG_DrawPic( 14, 480 - 50, 94, 32, cgs.media.whiteShader );
+
+		// NOTE: this looks ugly
+		if ( cent->gent && cent->gent->owner )
+		{
+			if (( cent->gent->owner->flags & FL_GODMODE ))
+			{
+				// chair is in godmode, so render the health of the player instead
+				health = cent->gent->health / (float)cent->gent->max_health;
+			}
+			else
+			{
+				// render the chair health
+				health = cent->gent->owner->health / (float)cent->gent->owner->max_health;
+			}
+		}
+
+		color[0] = 1.0f;
+		color[3] = 0.5f;
+
+		cgi_R_SetColor( color );
+		CG_DrawPic( 18, 480 - 41, 87 * health, 19, cgs.media.whiteShader );
+
+		cgi_R_SetColor( colorTable[CT_WHITE] );
+		CG_DrawPic( 2, 480 - 64, 128, 64, cgs.media.emplacedHealthBarShader);
+*/
+		return qfalse; // drew this hud, so don't draw the player one
+	}
+	// In an ATST
+	else if (( cent->currentState.eFlags & EF_IN_ATST ))
+	{
+
+/*
+		// we are an ATST...
+		color[0] = color[1] = color[2] = 0.0f;
+		color[3] = 0.3f;
+
+		cgi_R_SetColor( color );
+		CG_DrawPic( 14, 480 - 50, 94, 32, cgs.media.whiteShader );
+
+		// we just calc the display value from the sum of health and armor
+		if ( g_entities[cg.snap->ps.viewEntity].activator ) // ensure we can look back to the atst_drivable to get the max health
+		{
+			health = ( g_entities[cg.snap->ps.viewEntity].health + g_entities[cg.snap->ps.viewEntity].client->ps.stats[STAT_ARMOR] ) / 
+				(float)(g_entities[cg.snap->ps.viewEntity].max_health + g_entities[cg.snap->ps.viewEntity].activator->max_health );
+		}
+		else
+		{
+			health = ( g_entities[cg.snap->ps.viewEntity].health + g_entities[cg.snap->ps.viewEntity].client->ps.stats[STAT_ARMOR]) / 
+				(float)(g_entities[cg.snap->ps.viewEntity].max_health + 800 ); // hacked max armor since we don't have an activator...should never happen
+		}
+
+		color[1] = 0.25f; // blue-green
+		color[2] = 1.0f;
+		color[3] = 0.5f;
+
+		cgi_R_SetColor( color );
+		CG_DrawPic( 18, 480 - 41, 87 * health, 19, cgs.media.whiteShader );
+
+		cgi_R_SetColor( colorTable[CT_WHITE] );
+		CG_DrawPic( 2, 480 - 64, 128, 64, cgs.media.emplacedHealthBarShader);
+*/
+		CG_DrawATSTHud(cent);
+
+		return qfalse; // drew this hud, so don't draw the player one
+	}
+	// In a vehicle
+	else if ( (pVeh = G_IsRidingVehicle( cent->gent ) ) != 0 )
+	{
+
+		//riding some kind of living creature 
+		if ( pVeh->m_pVehicleInfo->type == VH_ANIMAL )
+		{
+			CG_DrawTauntaunHud( cent, pVeh );
+		}
+		else
+		{
+			CG_DrawVehicleHud( cent, pVeh );
+		}
+		return qtrue; // draw this hud AND the player one
+	}
+	// Other?
+	else if ( cg.snap->ps.viewEntity && ( g_entities[cg.snap->ps.viewEntity].dflags & DAMAGE_CUSTOM_HUD ))
+	{
+		CG_DrawPanelTurretHud();
+		return qfalse; // drew this hud, so don't draw the player one
+	}
+
+	return qtrue;
+}
+
+//--------------------------------------
+static void CG_DrawBatteryCharge( void )
+{
+	if ( cg.batteryChargeTime > cg.time )
+	{
+		vec4_t color;
+
+		// FIXME: drawing it here will overwrite zoom masks...find a better place
+		if ( cg.batteryChargeTime < cg.time + 1000 )
+		{
+			// fading out for the last second
+			color[0] = color[1] = color[2] = 1.0f;
+			color[3] = (cg.batteryChargeTime - cg.time) / 1000.0f;
+		}
+		else
+		{
+			// draw full
+			color[0] = color[1] = color[2] = color[3] = 1.0f;
+		}
+
+		cgi_R_SetColor( color );
+
+		// batteries were just charged
+		CG_DrawPic( 605, 295, 24, 32, cgs.media.batteryChargeShader );
+	}
+}
+
+/*
+================
+CG_DrawHUD
+================
+*/
+static void CG_DrawHUD( centity_t *cent )
+{
+	int value;
+	int	sectionXPos,sectionYPos,sectionWidth,sectionHeight;
+
+	// Draw the lower left section of the HUD
+	if (cgi_UI_GetMenuInfo("lefthud",&sectionXPos,&sectionYPos,&sectionWidth,&sectionHeight))
+	{
+
+		// Draw armor & health values
+		if ( cg_drawStatus.integer == 2 ) 
+		{
+			CG_DrawSmallStringColor(sectionXPos+5, sectionYPos - 60,va("Armor:%d",cg.snap->ps.stats[STAT_ARMOR]), colorTable[CT_HUD_GREEN] );
+			CG_DrawSmallStringColor(sectionXPos+5, sectionYPos - 40,va("Health:%d",cg.snap->ps.stats[STAT_HEALTH]), colorTable[CT_HUD_GREEN] );
+		}
+
+		// Print scanline
+		cgi_R_SetColor( otherHUDBits[OHB_SCANLINE_LEFT].color);
+
+		CG_DrawPic( 
+			otherHUDBits[OHB_SCANLINE_LEFT].xPos,
+			otherHUDBits[OHB_SCANLINE_LEFT].yPos,
+			otherHUDBits[OHB_SCANLINE_LEFT].width, 
+			otherHUDBits[OHB_SCANLINE_LEFT].height, 
+			otherHUDBits[OHB_SCANLINE_LEFT].background 
+			);
+
+		// Print frame
+		cgi_R_SetColor( otherHUDBits[OHB_FRAME_LEFT].color);
+		CG_DrawPic( 
+			otherHUDBits[OHB_FRAME_LEFT].xPos,
+			otherHUDBits[OHB_FRAME_LEFT].yPos,
+			otherHUDBits[OHB_FRAME_LEFT].width, 
+			otherHUDBits[OHB_FRAME_LEFT].height, 
+			otherHUDBits[OHB_FRAME_LEFT].background 
+			);
+
+		CG_DrawArmor(sectionXPos,sectionYPos,sectionWidth,sectionHeight);
+
+		CG_DrawHealth(sectionXPos,sectionYPos,sectionWidth,sectionHeight);
+	}
+
+
+	// Draw the lower right section of the HUD
+	if (cgi_UI_GetMenuInfo("righthud",&sectionXPos,&sectionYPos,&sectionWidth,&sectionHeight))
+	{
+		// Draw armor & health values
+		if ( cg_drawStatus.integer == 2 ) 
+		{
+			if ( cent->currentState.weapon != WP_SABER && cent->currentState.weapon != WP_STUN_BATON && cent->gent )
+			{
+				value = cg.snap->ps.ammo[weaponData[cent->currentState.weapon].ammoIndex];
+				CG_DrawSmallStringColor(sectionXPos, sectionYPos - 60,va("Ammo:%d",value), colorTable[CT_HUD_GREEN] );
+			}
+			CG_DrawSmallStringColor(sectionXPos, sectionYPos - 40,va("Force:%d",cent->gent->client->ps.forcePower), colorTable[CT_HUD_GREEN] );
+		}
+
+		// Print scanline
+		cgi_R_SetColor( otherHUDBits[OHB_SCANLINE_RIGHT].color);
+
+		CG_DrawPic( 
+			otherHUDBits[OHB_SCANLINE_RIGHT].xPos,
+			otherHUDBits[OHB_SCANLINE_RIGHT].yPos,
+			otherHUDBits[OHB_SCANLINE_RIGHT].width, 
+			otherHUDBits[OHB_SCANLINE_RIGHT].height, 
+			otherHUDBits[OHB_SCANLINE_RIGHT].background 
+			);
+
+
+		// Print frame
+		cgi_R_SetColor( otherHUDBits[OHB_FRAME_RIGHT].color);
+		CG_DrawPic( 
+			otherHUDBits[OHB_FRAME_RIGHT].xPos,
+			otherHUDBits[OHB_FRAME_RIGHT].yPos,
+			otherHUDBits[OHB_FRAME_RIGHT].width, 
+			otherHUDBits[OHB_FRAME_RIGHT].height, 
+			otherHUDBits[OHB_FRAME_RIGHT].background 
+			);
+
+		CG_DrawForcePower(cent,sectionXPos,sectionYPos);
+
+		// Draw ammo tics or saber style
+		if ( cent->currentState.weapon == WP_SABER )
+		{
+			CG_DrawSaberStyle(cent,sectionXPos,sectionYPos);
+		}
+		else
+		{
+			CG_DrawAmmo(cent,sectionXPos,sectionYPos);
+		}
+//		CG_DrawMessageLit(cent,x,y);
+	}
+}
+
+/*
+================
+CG_ClearDataPadCvars
+================
+*/
+void CG_ClearDataPadCvars( void )
+{
+	cg_updatedDataPadForcePower1.integer = 0; //don't wait for the cvar-refresh.
+	cg_updatedDataPadForcePower2.integer = 0; //don't wait for the cvar-refresh.
+	cg_updatedDataPadForcePower3.integer = 0; //don't wait for the cvar-refresh.
+	cgi_Cvar_Set( "cg_updatedDataPadForcePower1", "0" );
+	cgi_Cvar_Set( "cg_updatedDataPadForcePower2", "0" );
+	cgi_Cvar_Set( "cg_updatedDataPadForcePower3", "0" );
+
+	cg_updatedDataPadObjective.integer = 0; //don't wait for the cvar-refresh.
+	cgi_Cvar_Set( "cg_updatedDataPadObjective", "0" );
+}
+
+/*
+================
+CG_DrawDataPadHUD
+================
+*/
+void CG_DrawDataPadHUD( centity_t *cent )
+{
+	int x,y;
+
+	x = 34;
+	y = 286;
+
+	CG_DrawHealth(x,y,80,80);
+
+	x = 526;
+
+	if ((missionInfo_Updated) && ((cg_updatedDataPadForcePower1.integer) || (cg_updatedDataPadObjective.integer)))
+	{
+		// Stop flashing light
+		cg.missionInfoFlashTime = 0;
+		missionInfo_Updated = qfalse;
+
+		// Set which force power to show.
+		// cg_updatedDataPadForcePower is set from Q3_Interface, because force powers would only be given 
+		// from a script.
+		if (cg_updatedDataPadForcePower1.integer)
+		{
+			cg.DataPadforcepowerSelect = cg_updatedDataPadForcePower1.integer - 1; // Not pretty, I know
+			if (cg.DataPadforcepowerSelect >= MAX_DPSHOWPOWERS)
+			{	//duh
+				cg.DataPadforcepowerSelect = MAX_DPSHOWPOWERS-1;
+			}
+			else if (cg.DataPadforcepowerSelect<0)
+			{
+				cg.DataPadforcepowerSelect=0;
+			}
+		}
+//		CG_ClearDataPadCvars();
+	}
+
+	CG_DrawForcePower(cent,x,y);
+	CG_DrawAmmo(cent,x,y);
+	CG_DrawMessageLit(cent,x,y);
+
+	cgi_R_SetColor( colorTable[CT_WHITE]);
+	CG_DrawPic( 0, 0, 640, 480, cgs.media.dataPadFrame );
+
+}
+
+//------------------------
+// CG_DrawZoomMask
+//------------------------
+static void CG_DrawBinocularNumbers( qboolean power )
+{
+	vec4_t color1;
+
+	cgi_R_SetColor( colorTable[CT_BLACK]);
+	CG_DrawPic( 212, 367, 200, 40, cgs.media.whiteShader );
+
+	if ( power )
+	{
+		// Numbers should be kind of greenish
+		color1[0] = 0.2f;
+		color1[1] = 0.4f;
+		color1[2] = 0.2f;
+		color1[3] = 0.3f;
+		cgi_R_SetColor( color1 );
+
+		// Draw scrolling numbers, use intervals 10 units apart--sorry, this section of code is just kind of hacked
+		//	up with a bunch of magic numbers.....
+		int val = ((int)((cg.refdefViewAngles[YAW] + 180) / 10)) * 10;
+		float off = (cg.refdefViewAngles[YAW] + 180) - val;
+
+		for ( int i = -10; i < 30; i += 10 )
+		{
+			val -= 10;
+
+			if ( val < 0 )
+			{
+				val += 360;
+			}
+
+			// we only want to draw the very far left one some of the time, if it's too far to the left it will poke outside the mask.
+			if (( off > 3.0f && i == -10 ) || i > -10 )
+			{
+				// draw the value, but add 200 just to bump the range up...arbitrary, so change it if you like
+				CG_DrawNumField( 155 + i * 10 + off * 10, 374, 3, val + 200, 24, 14, NUM_FONT_CHUNKY, qtrue );
+				CG_DrawPic( 245 + (i-1) * 10 + off * 10, 376, 6, 6, cgs.media.whiteShader );
+			}
+		}
+
+		CG_DrawPic( 212, 367, 200, 28, cgs.media.binocularOverlay );
+	}
+}
+
+/*
+================
+CG_DrawZoomMask
+
+================
+*/
+extern float cg_zoomFov;	//from cg_view.cpp
+
+static void CG_DrawZoomMask( void )
+{
+	vec4_t			color1;
+	centity_t		*cent;
+	float			level;
+	static qboolean	flip = qtrue;
+	float			charge = cg.snap->ps.batteryCharge / (float)MAX_BATTERIES; // convert charge to a percentage
+	qboolean		power = qfalse;
+
+	cent = &cg_entities[0];
+
+	if ( charge > 0.0f )
+	{
+		power = qtrue;
+	}
+
+	//-------------
+	// Binoculars
+	//--------------------------------
+	if ( cg.zoomMode == 1 )
+	{
+		CG_RegisterItemVisuals( ITM_BINOCULARS_PICKUP );
+
+		// zoom level
+		level = (float)(80.0f - cg_zoomFov) / 80.0f;
+
+		// ...so we'll clamp it
+		if ( level < 0.0f )
+		{
+			level = 0.0f;
+		}
+		else if ( level > 1.0f )
+		{
+			level = 1.0f;
+		}
+
+		// Using a magic number to convert the zoom level to scale amount
+		level *= 162.0f;
+
+		if ( power )
+		{
+			// draw blue tinted distortion mask, trying to make it as small as is necessary to fill in the viewable area
+			cgi_R_SetColor( colorTable[CT_WHITE] );
+			CG_DrawPic( 34, 48, 570, 362, cgs.media.binocularStatic );
+		}
+	
+		CG_DrawBinocularNumbers( power );
+
+		// Black out the area behind the battery display
+		cgi_R_SetColor( colorTable[CT_DKGREY]);
+		CG_DrawPic( 50, 389, 161, 16, cgs.media.whiteShader );
+
+		if ( power )
+		{
+			color1[0] = sin( cg.time * 0.01f ) * 0.5f + 0.5f;
+			color1[0] = color1[0] * color1[0];
+			color1[1] = color1[0];
+			color1[2] = color1[0];
+			color1[3] = 1.0f;
+
+			cgi_R_SetColor( color1 );
+
+			CG_DrawPic( 82, 94, 16, 16, cgs.media.binocularCircle );
+		}
+
+		CG_DrawPic( 0, 0, 640, 480, cgs.media.binocularMask );
+
+		if ( power )
+		{
+			// Flickery color
+			color1[0] = 0.7f + crandom() * 0.1f;
+			color1[1] = 0.8f + crandom() * 0.1f;
+			color1[2] = 0.7f + crandom() * 0.1f;
+			color1[3] = 1.0f;
+			cgi_R_SetColor( color1 );
+		
+			CG_DrawPic( 4, 282 - level, 16, 16, cgs.media.binocularArrow );
+		}
+		else
+		{
+			// No power color
+			color1[0] = 0.15f;
+			color1[1] = 0.15f;
+			color1[2] = 0.15f;
+			color1[3] = 1.0f;
+			cgi_R_SetColor( color1 );
+		}
+
+		// The top triangle bit randomly flips when the power is on
+		if ( flip && power )
+		{
+			CG_DrawPic( 330, 60, -26, -30, cgs.media.binocularTri );
+		}
+		else
+		{
+			CG_DrawPic( 307, 40, 26, 30, cgs.media.binocularTri );
+		}
+
+		if ( random() > 0.98f && ( cg.time & 1024 ))
+		{
+			flip = !flip;
+		}
+
+		if ( power )
+		{
+			color1[0] = 1.0f * ( charge < 0.2f ? !!(cg.time & 256) : 1 );
+			color1[1] = charge * color1[0];
+			color1[2] = 0.0f;
+			color1[3] = 0.2f;
+
+			cgi_R_SetColor( color1 );
+			CG_DrawPic( 60, 394.5f, charge * 141, 5, cgs.media.whiteShader );
+		}
+	}
+	//------------
+	// Disruptor 
+	//--------------------------------
+	else if ( cg.zoomMode == 2 )
+	{
+		level = (float)(80.0f - cg_zoomFov) / 80.0f;
+
+		// ...so we'll clamp it
+		if ( level < 0.0f )
+		{
+			level = 0.0f;
+		}
+		else if ( level > 1.0f )
+		{
+			level = 1.0f;
+		}
+
+		// Using a magic number to convert the zoom level to a rotation amount that correlates more or less with the zoom artwork. 
+		level *= 103.0f;
+
+		// Draw target mask
+		cgi_R_SetColor( colorTable[CT_WHITE] );
+		CG_DrawPic( 0, 0, 640, 480, cgs.media.disruptorMask );
+
+		// apparently 99.0f is the full zoom level
+		if ( level >= 99 )
+		{
+			// Fully zoomed, so make the rotating insert pulse
+			color1[0] = 1.0f; 
+			color1[1] = 1.0f;
+			color1[2] = 1.0f;
+			color1[3] = 0.7f + sin( cg.time * 0.01f ) * 0.3f;
+
+			cgi_R_SetColor( color1 );
+		}
+
+		// Draw rotating insert
+		CG_DrawRotatePic2( 320, 240, 640, 480, -level, cgs.media.disruptorInsert );
+
+		float cx, cy;
+		float max;
+
+		max = cg_entities[0].gent->client->ps.ammo[weaponData[WP_DISRUPTOR].ammoIndex] / (float)ammoData[weaponData[WP_DISRUPTOR].ammoIndex].max;
+
+		if ( max > 1.0f )
+		{
+			max = 1.0f;
+		}
+
+		color1[0] = (1.0f - max) * 2.0f; 
+		color1[1] = max * 1.5f;
+		color1[2] = 0.0f;
+		color1[3] = 1.0f;
+
+		// If we are low on ammo, make us flash
+		if ( max < 0.15f && ( cg.time & 512 ))
+		{
+			VectorClear( color1 );
+		}
+
+		if ( color1[0] > 1.0f )
+		{
+			color1[0] = 1.0f;
+		}
+
+		if ( color1[1] > 1.0f )
+		{
+			color1[1] = 1.0f;
+		}
+
+		cgi_R_SetColor( color1 );
+
+		max *= 58.0f;
+
+		for ( float i = 18.5f; i <= 18.5f + max; i+= 3 ) // going from 15 to 45 degrees, with 5 degree increments
+		{
+			cx = 320 + sin( (i+90.0f)/57.296f ) * 190;
+			cy = 240 + cos( (i+90.0f)/57.296f ) * 190;
+
+			CG_DrawRotatePic2( cx, cy, 12, 24, 90 - i, cgs.media.disruptorInsertTick );
+		}
+
+		// FIXME: doesn't know about ammo!! which is bad because it draws charge beyond what ammo you may have..
+		if ( cg_entities[0].gent->client->ps.weaponstate == WEAPON_CHARGING_ALT )
+		{
+			cgi_R_SetColor( colorTable[CT_WHITE] );
+
+			// draw the charge level
+			max = ( cg.time - cg_entities[0].gent->client->ps.weaponChargeTime ) / ( 150.0f * 10.0f ); // bad hardcodedness 150 is disruptor charge unit and 10 is max charge units allowed.
+
+			if ( max > 1.0f )
+			{
+				max = 1.0f;
+			}
+
+			CG_DrawPic2( 257, 435, 134 * max, 34, 0,0,max,1,cgi_R_RegisterShaderNoMip( "gfx/2d/crop_charge" ));
+		}
+	}
+	//-----------
+	// Light Amp
+	//--------------------------------
+	else if ( cg.zoomMode == 3 )
+	{
+		CG_RegisterItemVisuals( ITM_LA_GOGGLES_PICKUP );
+
+		if ( power )
+		{
+			cgi_R_SetColor( colorTable[CT_WHITE] );
+			CG_DrawPic( 34, 29, 580, 410, cgs.media.laGogglesStatic );
+
+			CG_DrawPic( 570, 140, 12, 160, cgs.media.laGogglesSideBit );
+			
+			float light = (128-cent->gent->lightLevel) * 0.5f;
+
+			if ( light < -81 ) // saber can really jack up local light levels....?magic number??
+			{
+				light = -81;
+			}
+
+			float pos1 = 220 + light;
+			float pos2 = 220 + cos( cg.time * 0.0004f + light * 0.05f ) * 40 + sin( cg.time * 0.0013f + 1 ) * 20 + sin( cg.time * 0.0021f ) * 5;
+
+			// Flickery color
+			color1[0] = 0.7f + crandom() * 0.2f;
+			color1[1] = 0.8f + crandom() * 0.2f;
+			color1[2] = 0.7f + crandom() * 0.2f;
+			color1[3] = 1.0f;
+			cgi_R_SetColor( color1 );
+
+			CG_DrawPic( 565, pos1, 22, 8, cgs.media.laGogglesBracket );
+			CG_DrawPic( 558, pos2, 14, 5, cgs.media.laGogglesArrow );
+		}
+
+		// Black out the area behind the battery display
+		cgi_R_SetColor( colorTable[CT_DKGREY]);
+		CG_DrawPic( 236, 357, 164, 16, cgs.media.whiteShader );
+
+		if ( power )
+		{
+			// Power bar
+			color1[0] = 1.0f * ( charge < 0.2f ? !!(cg.time & 256) : 1 );
+			color1[1] = charge * color1[0];
+			color1[2] = 0.0f;
+			color1[3] = 0.4f;
+
+			cgi_R_SetColor( color1 );
+			CG_DrawPic( 247.0f, 362.5f, charge * 143.0f, 6, cgs.media.whiteShader );
+
+			// pulsing dot bit
+			color1[0] = sin( cg.time * 0.01f ) * 0.5f + 0.5f;
+			color1[0] = color1[0] * color1[0];
+			color1[1] = color1[0];
+			color1[2] = color1[0];
+			color1[3] = 1.0f;
+
+			cgi_R_SetColor( color1 );
+
+			CG_DrawPic( 65, 94, 16, 16, cgs.media.binocularCircle );
+		}
+	
+		CG_DrawPic( 0, 0, 640, 480, cgs.media.laGogglesMask );
+	}
+}
+
+/*
+================
+CG_DrawStats
+
+================
+*/
+static void CG_DrawStats( void ) 
+{
+	centity_t		*cent;
+	playerState_t	*ps;
+
+	if ( cg_drawStatus.integer == 0 ) {
+		return;
+	}
+
+	cent = &cg_entities[cg.snap->ps.clientNum];
+	ps = &cg.snap->ps;
+
+	if ((cg.snap->ps.viewEntity>0&&cg.snap->ps.viewEntity<ENTITYNUM_WORLD))
+	{
+		// MIGHT try and draw a custom hud if it wants...
+		CG_DrawCustomHealthHud( cent );
+		return;
+	}
+
+	cgi_UI_MenuPaintAll();
+
+	qboolean drawHud = qtrue;
+
+	if ( cent && cent->gent )
+	{
+		drawHud = CG_DrawCustomHealthHud( cent );
+	}
+
+	if (( drawHud ) && ( cg_drawHUD.integer ))
+	{
+		CG_DrawHUD( cent );	
+	}
+}
+
+
+/*
+===================
+CG_DrawPickupItem
+===================
+*/
+static void CG_DrawPickupItem( void ) {
+	int		value;
+	float	*fadeColor;
+
+	value = cg.itemPickup;
+	if ( value && cg_items[ value ].icon != -1 ) 
+	{
+		fadeColor = CG_FadeColor( cg.itemPickupTime, 3000 );
+		if ( fadeColor ) 
+		{
+			CG_RegisterItemVisuals( value );
+			cgi_R_SetColor( fadeColor );
+			CG_DrawPic( 573, 320, ICON_SIZE, ICON_SIZE, cg_items[ value ].icon );
+			//CG_DrawBigString( ICON_SIZE + 16, 398, bg_itemlist[ value ].classname, fadeColor[0] );
+			//CG_DrawProportionalString( ICON_SIZE + 16, 398, 
+			//	bg_itemlist[ value ].classname, CG_SMALLFONT,fadeColor );
+			cgi_R_SetColor( NULL );
+		}
+	}
+}
+
+extern int cgi_EndGame(void);
+
+/*
+===================
+CG_DrawPickupItem
+===================
+*/
+void CG_DrawCredits(void)
+{
+	if (!cg.creditsStart)
+	{
+		//
+		cg.creditsStart = qtrue;
+		CG_Credits_Init("CREDITS_RAVEN", &colorTable[CT_ICON_BLUE]);
+		if ( cg_skippingcin.integer )
+		{//Were skipping a cinematic and it's over now
+			gi.cvar_set("timescale", "1");
+			gi.cvar_set("skippingCinematic", "0");
+		}
+	}
+
+
+	if (cg.creditsStart)
+	{
+		if ( !CG_Credits_Running() ) 
+		{
+			cgi_Cvar_Set( "cg_endcredits", "0" );
+			cgi_EndGame();
+		}
+	}
+}
+
+//draw the health bar based on current "health" and maxhealth
+void CG_DrawHealthBar(centity_t *cent, float chX, float chY, float chW, float chH)
+{
+	vec4_t aColor;
+	vec4_t bColor;
+	vec4_t cColor;
+	float x = chX-(chW/2);
+	float y = chY-chH;
+	float percent = 0.0f;
+	
+	if ( !cent || !cent->gent )
+	{
+		return;
+	}
+	percent = ((float)cent->gent->health/(float)cent->gent->max_health);
+	if (percent <= 0)
+	{
+		return;
+	}
+
+	//color of the bar
+	//hostile
+	aColor[0] = 1.0f;
+	aColor[1] = 0.0f;
+	aColor[2] = 0.0f;
+	aColor[3] = 0.4f;
+
+	//color of the border
+	bColor[0] = 0.0f;
+	bColor[1] = 0.0f;
+	bColor[2] = 0.0f;
+	bColor[3] = 0.3f;
+
+	//color of greyed out "missing health"
+	cColor[0] = 0.5f;
+	cColor[1] = 0.5f;
+	cColor[2] = 0.5f;
+	cColor[3] = 0.4f;
+
+	//draw the background (black)
+	CG_DrawRect(x, y, chW, chH, 1.0f, colorTable[CT_BLACK]);
+
+	//now draw the part to show how much health there is in the color specified
+	CG_FillRect(x+1.0f, y+1.0f, (percent*chW)-1.0f, chH-1.0f, aColor);
+
+	//then draw the other part greyed out
+	CG_FillRect(x+(percent*chW), y+1.0f, chW-(percent*chW)-1.0f, chH-1.0f, cColor);
+}
+
+#define MAX_HEALTH_BAR_ENTS 32
+int cg_numHealthBarEnts = 0;
+int cg_healthBarEnts[MAX_HEALTH_BAR_ENTS];
+#define HEALTH_BAR_WIDTH	50
+#define HEALTH_BAR_HEIGHT	5
+
+void CG_DrawHealthBars( void )
+{
+	float chX=0, chY=0;
+	centity_t *cent;
+	vec3_t pos;
+	for ( int i = 0; i < cg_numHealthBarEnts; i++ )
+	{
+		cent = &cg_entities[cg_healthBarEnts[i]];
+		if ( cent && cent->gent )
+		{
+			VectorCopy( cent->lerpOrigin, pos );
+			pos[2] += cent->gent->maxs[2]+HEALTH_BAR_HEIGHT+8;
+			if ( CG_WorldCoordToScreenCoordFloat( pos, &chX, &chY ) )
+			{//on screen
+				CG_DrawHealthBar( cent, chX, chY, HEALTH_BAR_WIDTH, HEALTH_BAR_HEIGHT );
+			}
+		}
+	}
+}
+
+#define HEALTHBARRANGE 422
+void CG_AddHealthBarEnt( int entNum )
+{
+	if ( cg_numHealthBarEnts >= MAX_HEALTH_BAR_ENTS )
+	{//FIXME: Debug error message?
+		return;
+	}
+
+	if (DistanceSquared( cg_entities[entNum].lerpOrigin, g_entities[0].client->renderInfo.eyePoint ) < (HEALTHBARRANGE*HEALTHBARRANGE) )
+	{
+		cg_healthBarEnts[cg_numHealthBarEnts++] = entNum;
+	}
+}
+
+void CG_ClearHealthBarEnts( void )
+{
+	if ( cg_numHealthBarEnts )
+	{
+		cg_numHealthBarEnts = 0;
+		memset( &cg_healthBarEnts, 0, MAX_HEALTH_BAR_ENTS );
+	}
+}
+/*
+================================================================================
+
+CROSSHAIR
+
+================================================================================
+*/
+
+
+/*
+=================
+CG_DrawCrosshair
+=================
+*/
+#ifdef _XBOX
+short cg_crossHairStatus = 0;
+#endif
+static void CG_DrawCrosshair( vec3_t worldPoint ) 
+{
+	float		w, h;
+	qhandle_t	hShader;
+	qboolean	corona = qfalse;
+	vec4_t		ecolor;
+	float		f;
+	float		x, y;
+
+	if ( !cg_drawCrosshair.integer ) 
+	{
+		return;
+	}
+
+	if ( cg.zoomMode > 0 && cg.zoomMode < 3 )
+	{
+		//not while scoped
+		return;
+	}
+
+#ifdef _XBOX
+	cg_crossHairStatus = 0;
+#endif
+	//set color based on what kind of ent is under crosshair
+	if ( g_crosshairEntNum >= ENTITYNUM_WORLD )
+	{
+		ecolor[0] = ecolor[1] = ecolor[2] = 1.0f;
+	}
+	else if ( cg_forceCrosshair && cg_crosshairForceHint.integer )
+	{
+		ecolor[0] = 0.2f;
+		ecolor[1] = 0.5f;
+		ecolor[2] = 1.0f;
+
+		corona = qtrue;
+	}
+	else if ( cg_crosshairIdentifyTarget.integer )
+	{
+		gentity_t *crossEnt = &g_entities[g_crosshairEntNum];
+
+		if ( crossEnt->client )
+		{
+			if ( crossEnt->client->ps.powerups[PW_CLOAKED] )
+			{//cloaked don't show up
+				ecolor[0] = 1.0f;//R
+				ecolor[1] = 1.0f;//G
+				ecolor[2] = 1.0f;//B
+			}
+			else if ( g_entities[0].client && g_entities[0].client->playerTeam == TEAM_FREE )
+			{//evil player: everyone is red
+#ifdef _XBOX
+				cg_crossHairStatus = 1;
+#endif
+				//Enemies are red
+				ecolor[0] = 1.0f;//R
+				ecolor[1] = 0.1f;//G
+				ecolor[2] = 0.1f;//B
+			}
+			else if ( crossEnt->client->playerTeam == TEAM_PLAYER )
+			{
+				//Allies are green
+				ecolor[0] = 0.0f;//R
+				ecolor[1] = 1.0f;//G
+				ecolor[2] = 0.0f;//B
+			}
+			else if ( crossEnt->client->playerTeam == TEAM_NEUTRAL )
+			{
+				// NOTE: was yellow, but making it white unless they really decide they want to see colors
+				ecolor[0] = 1.0f;//R
+				ecolor[1] = 1.0f;//G
+				ecolor[2] = 1.0f;//B
+			}
+			else
+			{
+#ifdef _XBOX
+				cg_crossHairStatus = 1;
+#endif
+				//Enemies are red
+				ecolor[0] = 1.0f;//R
+				ecolor[1] = 0.1f;//G
+				ecolor[2] = 0.1f;//B
+			}
+		}
+		else if ( crossEnt->s.weapon == WP_TURRET && (crossEnt->svFlags&SVF_NONNPC_ENEMY) )
+		{
+			// a turret
+			if ( crossEnt->noDamageTeam == TEAM_PLAYER )
+			{
+				// mine are green
+				ecolor[0] = 0.0;//R
+				ecolor[1] = 1.0;//G
+				ecolor[2] = 0.0;//B
+			}
+			else
+			{
+				// hostile ones are red
+#ifdef _XBOX
+				cg_crossHairStatus = 1;
+#endif
+				ecolor[0] = 1.0;//R
+				ecolor[1] = 0.0;//G
+				ecolor[2] = 0.0;//B
+			}
+		}
+		else if ( crossEnt->s.weapon == WP_TRIP_MINE )
+		{
+			// tripmines are red
+#ifdef _XBOX
+			cg_crossHairStatus = 1;
+#endif
+			ecolor[0] = 1.0;//R
+			ecolor[1] = 0.0;//G
+			ecolor[2] = 0.0;//B
+		}
+		else if ( (crossEnt->flags&FL_RED_CROSSHAIR) )
+		{//special case flagged to turn crosshair red
+			ecolor[0] = 1.0;//R
+			ecolor[1] = 0.0;//G
+			ecolor[2] = 0.0;//B
+		}
+		else
+		{
+			VectorCopy( crossEnt->startRGBA, ecolor );
+
+			if ( !ecolor[0] && !ecolor[1] && !ecolor[2] )
+			{
+				// We don't want a black crosshair, so use white since it will show up better
+				ecolor[0] = 1.0f;//R
+				ecolor[1] = 1.0f;//G
+				ecolor[2] = 1.0f;//B
+			}
+		}
+	}
+	else // cg_crosshairIdentifyTarget is not on, so make it white
+	{
+		ecolor[0] = ecolor[1] = ecolor[2] = 1.0f;
+	}
+
+	ecolor[3] = 1.0;
+	cgi_R_SetColor( ecolor );
+
+	if ( cg.forceCrosshairStartTime )
+	{
+		// both of these calcs will fade the corona in one direction
+		if ( cg.forceCrosshairEndTime )
+		{
+			ecolor[3] = (cg.time - cg.forceCrosshairEndTime) / 500.0f;
+		}
+		else
+		{
+			ecolor[3] = (cg.time - cg.forceCrosshairStartTime) / 300.0f;
+		}
+
+		// clamp 
+		if ( ecolor[3] < 0 )
+		{
+			ecolor[3] = 0;
+		}
+		else if ( ecolor[3] > 1.0f )
+		{
+			ecolor[3] = 1.0f;
+		}
+
+		if ( !cg.forceCrosshairEndTime )
+		{
+			// but for the other direction, we'll need to reverse it
+			ecolor[3] = 1.0f - ecolor[3];
+		}
+	}
+
+	if ( corona ) // we are pointing at a crosshair item
+	{
+		if ( !cg.forceCrosshairStartTime )
+		{
+			// must have just happened because we are not fading in yet...start it now
+			cg.forceCrosshairStartTime = cg.time;
+			cg.forceCrosshairEndTime = 0;
+		}
+		if ( cg.forceCrosshairEndTime )
+		{
+			// must have just gone over a force thing again...and we were in the process of fading out.  Set fade in level to the level where the fade left off
+			cg.forceCrosshairStartTime = cg.time - ( 1.0f - ecolor[3] ) * 300.0f;
+			cg.forceCrosshairEndTime = 0;
+		}
+	}
+	else // not pointing at a crosshair item
+	{
+		if ( cg.forceCrosshairStartTime && !cg.forceCrosshairEndTime ) // were currently fading in
+		{
+			// must fade back out, but we will have to set the fadeout time to be equal to the current level of faded-in-edness
+			cg.forceCrosshairEndTime = cg.time - ecolor[3] * 500.0f;
+		}
+		if ( cg.forceCrosshairEndTime && cg.time - cg.forceCrosshairEndTime > 500.0f ) // not pointing at anything and fade out is totally done
+		{
+			// reset everything
+			cg.forceCrosshairStartTime = 0;
+			cg.forceCrosshairEndTime = 0;
+		}
+	}
+
+	w = h = cg_crosshairSize.value;
+
+	// pulse the size of the crosshair when picking up items
+	f = cg.time - cg.itemPickupBlendTime;
+	if ( f > 0 && f < ITEM_BLOB_TIME ) {
+		f /= ITEM_BLOB_TIME;
+		w *= ( 1 + f );
+		h *= ( 1 + f );
+	}
+
+	if ( worldPoint && VectorLength( worldPoint ) )
+	{
+		if ( !CG_WorldCoordToScreenCoordFloat( worldPoint, &x, &y ) )
+		{//off screen, don't draw it
+			return;
+		}
+		x -= 320;//????
+		y -= 240;//????
+	}
+	else
+	{
+		x = cg_crosshairX.integer;
+		y = cg_crosshairY.integer;
+	}
+
+	if ( cg.snap->ps.viewEntity > 0 && cg.snap->ps.viewEntity < ENTITYNUM_WORLD )
+	{
+		if ( !Q_stricmp( "misc_panel_turret", g_entities[cg.snap->ps.viewEntity].classname ))
+		{
+			// draws a custom crosshair that is twice as large as normal
+			cgi_R_DrawStretchPic( x + cg.refdef.x + 320 - w, 
+				y + cg.refdef.y + 240 - h, 
+				w * 2, h * 2, 0, 0, 1, 1, cgs.media.turretCrossHairShader );	
+
+		}
+	}
+	else 
+	{
+		hShader = cgs.media.crosshairShader[ cg_drawCrosshair.integer % NUM_CROSSHAIRS ];
+
+		cgi_R_DrawStretchPic( x + cg.refdef.x + 0.5 * (640 - w), 
+			y + cg.refdef.y + 0.5 * (480 - h), 
+			w, h, 0, 0, 1, 1, hShader );	
+	}
+
+	if ( cg.forceCrosshairStartTime && cg_crosshairForceHint.integer ) // drawing extra bits
+	{
+		ecolor[0] = ecolor[1] = ecolor[2] = (1 - ecolor[3]) * ( sin( cg.time * 0.001f ) * 0.08f + 0.35f ); // don't draw full color
+		ecolor[3] = 1.0f;
+
+		cgi_R_SetColor( ecolor );
+
+		w *= 2.0f;
+		h *= 2.0f;
+
+		cgi_R_DrawStretchPic( x + cg.refdef.x + 0.5f * ( 640 - w ), y + cg.refdef.y + 0.5f * ( 480 - h ), 
+								w, h, 
+								0, 0, 1, 1, 
+								cgs.media.forceCoronaShader ); 
+	}
+}
+
+/*
+qboolean CG_WorldCoordToScreenCoord(vec3_t worldCoord, int *x, int *y)
+
+  Take any world coord and convert it to a 2D virtual 640x480 screen coord
+*/
+qboolean CG_WorldCoordToScreenCoordFloat(vec3_t worldCoord, float *x, float *y)
+{
+	float	xcenter, ycenter;
+	vec3_t	local, transformed;
+
+//	xcenter = cg.refdef.width / 2;//gives screen coords adjusted for resolution
+//	ycenter = cg.refdef.height / 2;//gives screen coords adjusted for resolution
+	
+	//NOTE: did it this way because most draw functions expect virtual 640x480 coords
+	//	and adjust them for current resolution
+	xcenter = 640.0f / 2.0f;//gives screen coords in virtual 640x480, to be adjusted when drawn
+	ycenter = 480.0f / 2.0f;//gives screen coords in virtual 640x480, to be adjusted when drawn
+
+	VectorSubtract (worldCoord, cg.refdef.vieworg, local);
+
+	transformed[0] = DotProduct(local,vright);
+	transformed[1] = DotProduct(local,vup);
+	transformed[2] = DotProduct(local,vfwd);		
+
+	// Make sure Z is not negative.
+	if(transformed[2] < 0.01f)
+	{
+		return qfalse;
+	}
+	// Simple convert to screen coords.
+	float xzi = xcenter / transformed[2] * (100.0f/cg.refdef.fov_x);
+	float yzi = ycenter / transformed[2] * (100.0f/cg.refdef.fov_y);
+
+	*x = xcenter + xzi * transformed[0];
+	*y = ycenter - yzi * transformed[1];
+
+	return qtrue;
+}
+
+qboolean CG_WorldCoordToScreenCoord( vec3_t worldCoord, int *x, int *y )
+{
+	float	xF, yF;
+	qboolean retVal = CG_WorldCoordToScreenCoordFloat( worldCoord, &xF, &yF );
+	*x = (int)xF;
+	*y = (int)yF;
+	return retVal;
+}
+
+// I'm keeping the rocket tracking code separate for now since I may want to do different logic...but it still uses trace info from scanCrosshairEnt
+//-----------------------------------------
+static void CG_ScanForRocketLock( void )
+//-----------------------------------------
+{
+	gentity_t	*traceEnt;
+	static qboolean tempLock = qfalse; // this will break if anything else uses this locking code ( other than the player )
+
+	traceEnt = &g_entities[g_crosshairEntNum];
+
+	if ( !traceEnt || g_crosshairEntNum <= 0 || g_crosshairEntNum >= ENTITYNUM_WORLD || (!traceEnt->client && traceEnt->s.weapon != WP_TURRET ) || !traceEnt->health 
+			|| ( traceEnt && traceEnt->client && traceEnt->client->ps.powerups[PW_CLOAKED] ))
+	{
+		// see how much locking we have
+		int dif = ( cg.time - g_rocketLockTime ) / ( 1200.0f / 8.0f );
+
+		// 8 is full locking....also if we just traced onto the world, 
+		//	give them 1/2 second of slop before dropping the lock
+		if ( dif < 8 && g_rocketSlackTime + 500 < cg.time )
+		{
+			// didn't have a full lock and not in grace period, so drop the lock
+			g_rocketLockTime = 0;
+			g_rocketSlackTime = 0;
+			tempLock = qfalse;
+		}
+
+		if ( g_rocketSlackTime + 500 >= cg.time && g_rocketLockEntNum < ENTITYNUM_WORLD )
+		{
+			// were locked onto an ent, aren't right now.....but still within the slop grace period
+			//	keep the current lock amount
+			g_rocketLockTime += cg.frametime;
+		}
+
+		if ( !tempLock && g_rocketLockEntNum < ENTITYNUM_WORLD && dif >= 8 )
+		{
+			tempLock = qtrue;
+
+			if ( g_rocketLockTime + 1200 < cg.time )
+			{
+				g_rocketLockTime = cg.time - 1200; // doh, hacking the time so the targetting still gets drawn full
+			}
+		} 		
+
+		// keep locking to this thing for one second after it gets out of view
+		if ( g_rocketLockTime + 2000.0f < cg.time ) // since time was hacked above, I'm compensating so that 2000ms is really only 1000ms
+		{
+			// too bad, you had your chance
+			g_rocketLockEntNum = ENTITYNUM_NONE;
+			g_rocketSlackTime = 0;
+			g_rocketLockTime = 0;
+		}
+	}
+	else
+	{
+		tempLock = qfalse;
+
+		if ( g_rocketLockEntNum >= ENTITYNUM_WORLD )
+		{
+			if ( g_rocketSlackTime + 500 < cg.time )
+			{
+				// we just locked onto something, start the lock at the current time
+				g_rocketLockEntNum = g_crosshairEntNum;
+				g_rocketLockTime = cg.time;
+				g_rocketSlackTime = cg.time;
+			}
+		}
+		else
+		{
+			if ( g_rocketLockEntNum != g_crosshairEntNum )
+			{
+				g_rocketLockTime = cg.time;
+			}
+
+			// may as well always set this when we can potentially lock to something
+			g_rocketSlackTime = cg.time;
+			g_rocketLockEntNum = g_crosshairEntNum;
+		}
+	}
+}
+
+/*
+=================
+CG_ScanForCrosshairEntity
+=================
+*/
+extern Vehicle_t *G_IsRidingVehicle( gentity_t *ent );
+extern float forcePushPullRadius[];
+static void CG_ScanForCrosshairEntity( qboolean scanAll ) 
+{
+	trace_t		trace;
+	gentity_t	*traceEnt = NULL;
+	vec3_t		start, end;
+	int			content;
+	int			ignoreEnt = cg.snap->ps.clientNum;
+	Vehicle_t *pVeh = NULL;
+
+	//FIXME: debounce this to about 10fps?
+
+	cg_forceCrosshair = qfalse;
+	if ( cg_entities[0].gent && cg_entities[0].gent->client ) // <-Mike said it should always do this   //if (cg_crosshairForceHint.integer &&
+	{//try to check for force-affectable stuff first
+		vec3_t d_f, d_rt, d_up;
+
+		// If you're riding a vehicle and not being drawn.
+		if ( ( pVeh = G_IsRidingVehicle( cg_entities[0].gent ) ) != NULL && cg_entities[0].currentState.eFlags & EF_NODRAW )
+		{
+			VectorCopy( cg_entities[pVeh->m_pParentEntity->s.number].lerpOrigin, start );
+			AngleVectors( cg_entities[pVeh->m_pParentEntity->s.number].lerpAngles, d_f, d_rt, d_up );
+		}
+		else
+		{
+			VectorCopy( g_entities[0].client->renderInfo.eyePoint, start );
+			AngleVectors( cg_entities[0].lerpAngles, d_f, d_rt, d_up );
+		}
+
+		VectorMA( start, 2048, d_f, end );//4028 is max for mind trick
+
+		//YES!  This is very very bad... but it works!  James made me do it.  Really, he did.  Blame James.
+		gi.trace( &trace, start, vec3_origin, vec3_origin, end, 
+			ignoreEnt, MASK_OPAQUE|CONTENTS_SHOTCLIP|CONTENTS_BODY|CONTENTS_ITEM|CONTENTS_TERRAIN, G2_NOCOLLIDE, 10 );// ); took out CONTENTS_SOLID| so you can target people through glass.... took out CONTENTS_CORPSE so disintegrated guys aren't shown, could just remove their body earlier too...
+
+		if ( trace.entityNum < ENTITYNUM_WORLD )
+		{//hit something
+			traceEnt = &g_entities[trace.entityNum];
+			if ( traceEnt )
+			{
+				// Check for mind trickable-guys
+				if ( traceEnt->client )
+				{//is a client
+					if ( cg_entities[0].gent->client->ps.forcePowerLevel[FP_TELEPATHY] && traceEnt->health > 0 && VALIDSTRING(traceEnt->behaviorSet[BSET_MINDTRICK]) )
+					{//I have the ability to mind-trick and he is alive and he has a mind trick script
+						//NOTE: no need to check range since it's always 2048
+						cg_forceCrosshair = qtrue;
+					}
+				}
+				// No?  Check for force-push/pullable doors and func_statics
+				else if ( traceEnt->s.eType == ET_MOVER )
+				{//hit a mover
+					if ( !Q_stricmp( "func_door", traceEnt->classname ) )
+					{//it's a func_door
+						if ( traceEnt->spawnflags & 2/*MOVER_FORCE_ACTIVATE*/ )
+						{//it's force-usable
+							if ( cg_entities[0].gent->client->ps.forcePowerLevel[FP_PULL] || cg_entities[0].gent->client->ps.forcePowerLevel[FP_PUSH] )
+							{//player has push or pull
+								float maxRange;
+								if ( cg_entities[0].gent->client->ps.forcePowerLevel[FP_PULL] > cg_entities[0].gent->client->ps.forcePowerLevel[FP_PUSH] )
+								{//use the better range
+									maxRange = forcePushPullRadius[cg_entities[0].gent->client->ps.forcePowerLevel[FP_PULL]];
+								}
+								else
+								{//use the better range
+									maxRange = forcePushPullRadius[cg_entities[0].gent->client->ps.forcePowerLevel[FP_PUSH]];
+								}
+								if ( maxRange >= trace.fraction * 2048 )
+								{//actually close enough to use one of our force powers on it
+									cg_forceCrosshair = qtrue;
+								}
+							}
+						}
+					}
+					else if ( !Q_stricmp( "func_static", traceEnt->classname ) )
+					{//it's a func_static
+						if ( (traceEnt->spawnflags & 1/*F_PUSH*/) && (traceEnt->spawnflags & 2/*F_PULL*/) )
+						{//push or pullable
+							float maxRange;
+							if ( cg_entities[0].gent->client->ps.forcePowerLevel[FP_PULL] > cg_entities[0].gent->client->ps.forcePowerLevel[FP_PUSH] )
+							{//use the better range
+								maxRange = forcePushPullRadius[cg_entities[0].gent->client->ps.forcePowerLevel[FP_PULL]];
+							}
+							else
+							{//use the better range
+								maxRange = forcePushPullRadius[cg_entities[0].gent->client->ps.forcePowerLevel[FP_PUSH]];
+							}
+							if ( maxRange >= trace.fraction * 2048 )
+							{//actually close enough to use one of our force powers on it
+								cg_forceCrosshair = qtrue;
+							}
+						}
+						else if ( (traceEnt->spawnflags & 1/*F_PUSH*/) )
+						{//pushable only
+							if ( forcePushPullRadius[cg_entities[0].gent->client->ps.forcePowerLevel[FP_PUSH]] >= trace.fraction * 2048 )
+							{//actually close enough to use force push on it
+								cg_forceCrosshair = qtrue;
+							}
+						}
+						else if ( (traceEnt->spawnflags & 2/*F_PULL*/) )
+						{//pullable only
+							if ( forcePushPullRadius[cg_entities[0].gent->client->ps.forcePowerLevel[FP_PULL]] >= trace.fraction * 2048 )
+							{//actually close enough to use force pull on it
+								cg_forceCrosshair = qtrue;
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+	if ( !cg_forceCrosshair )
+	{
+		if ( 1 ) //(cg_dynamicCrosshair.integer )
+		{//100% accurate
+			vec3_t d_f, d_rt, d_up;
+			// If you're riding a vehicle and not being drawn.
+			if ( ( pVeh = G_IsRidingVehicle( cg_entities[0].gent ) ) != NULL && cg_entities[0].currentState.eFlags & EF_NODRAW )
+			{
+				VectorCopy( cg_entities[pVeh->m_pParentEntity->s.number].lerpOrigin, start );
+				AngleVectors( cg_entities[pVeh->m_pParentEntity->s.number].lerpAngles, d_f, d_rt, d_up );
+			}
+			else if ( cg.snap->ps.weapon == WP_NONE || cg.snap->ps.weapon == WP_SABER || cg.snap->ps.weapon == WP_STUN_BATON )
+			{
+				if ( cg.snap->ps.viewEntity > 0 && cg.snap->ps.viewEntity < ENTITYNUM_WORLD )
+				{//in camera ent view
+					ignoreEnt = cg.snap->ps.viewEntity;
+					if ( g_entities[cg.snap->ps.viewEntity].client )
+					{
+						VectorCopy( g_entities[cg.snap->ps.viewEntity].client->renderInfo.eyePoint, start );
+					}
+					else
+					{
+						VectorCopy( cg_entities[cg.snap->ps.viewEntity].lerpOrigin, start );
+					}
+					AngleVectors( cg_entities[cg.snap->ps.viewEntity].lerpAngles, d_f, d_rt, d_up );
+				}
+				else
+				{
+					VectorCopy( g_entities[0].client->renderInfo.eyePoint, start );
+					AngleVectors( cg_entities[0].lerpAngles, d_f, d_rt, d_up );
+				}
+			}
+			else
+			{
+				extern void CalcMuzzlePoint( gentity_t *const ent, vec3_t forward, vec3_t right, vec3_t up, vec3_t muzzlePoint, float lead_in );
+				AngleVectors( cg_entities[0].lerpAngles, d_f, d_rt, d_up );
+				CalcMuzzlePoint( &g_entities[0], d_f, d_rt, d_up, start , 0 );
+			}
+			//VectorCopy( g_entities[0].client->renderInfo.muzzlePoint, start );
+			//FIXME: increase this?  Increase when zoom in?
+			VectorMA( start, 4096, d_f, end );//was 8192
+		}
+		else
+		{//old way
+			VectorCopy( cg.refdef.vieworg, start );
+			//FIXME: increase this?  Increase when zoom in?
+			VectorMA( start, 4096, cg.refdef.viewaxis[0], end );//was 8192
+		}
+		//YES!  This is very very bad... but it works!  James made me do it.  Really, he did.  Blame James.
+		gi.trace( &trace, start, vec3_origin, vec3_origin, end, 
+			ignoreEnt, MASK_OPAQUE|CONTENTS_TERRAIN|CONTENTS_SHOTCLIP|CONTENTS_BODY|CONTENTS_ITEM, G2_NOCOLLIDE, 10 );// ); took out CONTENTS_SOLID| so you can target people through glass.... took out CONTENTS_CORPSE so disintegrated guys aren't shown, could just remove their body earlier too...
+
+		/*
+		CG_Trace( &trace, start, vec3_origin, vec3_origin, end, 
+			cg.snap->ps.clientNum, MASK_PLAYERSOLID|CONTENTS_CORPSE|CONTENTS_ITEM );
+		*/
+		//FIXME: pick up corpses
+		if ( trace.startsolid || trace.allsolid )
+		{
+			// trace should not be allowed to pick up anything if it started solid.  I tried actually moving the trace start back, which also worked, 
+			//	but the dynamic cursor drawing caused it to render around the clip of the gun when I pushed the blaster all the way into a wall.
+			//	It looked quite horrible...but, if this is bad for some reason that I don't know
+			trace.entityNum = ENTITYNUM_NONE;
+		}
+
+		traceEnt = &g_entities[trace.entityNum];
+	}
+	
+
+	// if the object is "dead", don't show it
+/*	if ( cg.crosshairClientNum && g_entities[cg.crosshairClientNum].health <= 0 )
+	{
+		cg.crosshairClientNum = 0;
+		return;
+	}
+*/
+	//CROSSHAIR is now always drawn from this trace so it's 100% accurate
+	if ( 1 )	//(cg_dynamicCrosshair.integer )
+	{//draw crosshair at endpoint
+		CG_DrawCrosshair( trace.endpos );
+	}
+
+	g_crosshairEntNum = trace.entityNum;
+	g_crosshairEntDist = 4096*trace.fraction;
+
+	if ( !traceEnt )
+	{
+		//not looking at anything
+		g_crosshairSameEntTime = 0;
+		g_crosshairEntTime = 0;
+	}
+	else
+	{//looking at a valid ent
+		//store the distance
+		if ( trace.entityNum != g_crosshairEntNum )
+		{//new crosshair ent
+			g_crosshairSameEntTime = 0;
+		}
+		else if ( g_crosshairEntDist < 256 )
+		{//close enough to start counting how long you've been looking
+			g_crosshairSameEntTime += cg.frametime;
+		}
+		//remember the last time you looked at the person
+		g_crosshairEntTime = cg.time;
+	}
+
+	if ( !traceEnt )
+	{
+		if ( traceEnt && scanAll )
+		{
+		}
+		else
+		{
+			return;
+		}
+	}
+
+	// if the player is in fog, don't show it
+	content = cgi_CM_PointContents( trace.endpos, 0 );
+	if ( content & CONTENTS_FOG ) 
+	{
+		return;
+	}
+
+	// if the player is cloaked, don't show it
+	if ( cg_entities[ trace.entityNum ].currentState.powerups & ( 1 << PW_CLOAKED )) 
+	{
+		return;
+	}
+
+	// update the fade timer
+	if ( cg.crosshairClientNum != trace.entityNum )
+	{
+		infoStringCount = 0;
+	}
+
+	cg.crosshairClientNum = trace.entityNum;
+	cg.crosshairClientTime = cg.time;
+}
+
+
+/*
+=====================
+CG_DrawCrosshairNames
+=====================
+*/
+static void CG_DrawCrosshairNames( void ) 
+{
+	qboolean	scanAll = qfalse;
+	centity_t	*player = &cg_entities[0];
+
+	if ( 1 ) //cg_dynamicCrosshair.integer )
+	{
+		// still need to scan for dynamic crosshair
+		CG_ScanForCrosshairEntity( scanAll );
+		return;
+	}
+
+	if ( !player->gent )
+	{
+		return;
+	}
+
+	if ( !player->gent->client )
+	{
+		return;
+	}
+
+	// scan the known entities to see if the crosshair is sighted on one
+	// This is currently being called by the rocket tracking code, so we don't necessarily want to do duplicate traces :)
+	CG_ScanForCrosshairEntity( scanAll );
+}
+
+//--------------------------------------------------------------
+static void CG_DrawActivePowers(void)
+//--------------------------------------------------------------
+{
+	int icon_size = 40;
+	int startx = icon_size*2+16;
+	int starty = SCREEN_HEIGHT - icon_size*2;
+
+	int endx = icon_size;
+	int endy = icon_size;
+
+	if (cg.zoomMode)
+	{ //don't display over zoom mask
+		return;
+	}
+
+	/*
+	//draw icon for duration powers so we know what powers are active cuttently
+	int i = 0;
+	while (i < NUM_FORCE_POWERS)
+	{
+		if ((cg.snap->ps.forcePowersActive & (1 << forcePowerSorted[i])) &&
+			CG_IsDurationPower(forcePowerSorted[i]))
+		{
+			CG_DrawPic( startx, starty, endx, endy, cgs.media.forcePowerIcons[forcePowerSorted[i]]);
+			startx += (icon_size+2); //+2 for spacing
+			if ((startx+icon_size) >= SCREEN_WIDTH-80)
+			{
+				startx = icon_size*2+16;
+				starty += (icon_size+2);
+			}
+		}
+
+		i++;
+	}
+	*/
+
+	//additionally, draw an icon force force rage recovery
+	if (cg.snap->ps.forceRageRecoveryTime > cg.time)
+	{
+		CG_DrawPic( startx, starty, endx, endy, cgs.media.rageRecShader);
+	}
+}
+
+//--------------------------------------------------------------
+static void CG_DrawRocketLocking( int lockEntNum, int lockTime )
+//--------------------------------------------------------------
+{
+	gentity_t *gent = &g_entities[lockEntNum];
+
+	if ( !gent )
+	{
+		return;
+	}
+
+	int		cx, cy;
+	vec3_t	org;
+	static	int oldDif = 0;
+
+	VectorCopy( gent->currentOrigin, org );
+	org[2] += (gent->mins[2] + gent->maxs[2]) * 0.5f;
+
+	if ( CG_WorldCoordToScreenCoord( org, &cx, &cy ))
+	{
+		// we care about distance from enemy to eye, so this is good enough
+		float sz = Distance( gent->currentOrigin, cg.refdef.vieworg ) / 1024.0f; 
+		
+		if ( cg.zoomMode > 0 )
+		{
+			if ( cg.overrides.active & CG_OVERRIDE_FOV )
+			{
+				sz -= ( cg.overrides.fov - cg_zoomFov ) / 80.0f;
+			}
+			else
+			{
+				sz -= ( cg_fov.value - cg_zoomFov ) / 80.0f;
+			}
+		}
+
+		if ( sz > 1.0f )
+		{
+			sz = 1.0f;
+		}
+		else if ( sz < 0.0f )
+		{
+			sz = 0.0f;
+		}
+
+		sz = (1.0f - sz) * (1.0f - sz) * 32 + 6;
+
+		vec4_t color={0.0f,0.0f,0.0f,0.0f};
+
+		cy += sz * 0.5f;
+		
+		// well now, take our current lock time and divide that by 8 wedge slices to get the current lock amount
+		int dif = ( cg.time - g_rocketLockTime ) / ( 1200.0f / 8.0f );
+
+		if ( dif < 0 )
+		{
+			oldDif = 0;
+			return;
+		}
+		else if ( dif > 8 )
+		{
+			dif = 8;
+		}
+
+		// do sounds
+		if ( oldDif != dif )
+		{
+			if ( dif == 8 )
+			{
+				cgi_S_StartSound( org, 0, CHAN_AUTO, cgi_S_RegisterSound( "sound/weapons/rocket/lock.wav" ));
+			}
+			else
+			{
+				cgi_S_StartSound( org, 0, CHAN_AUTO, cgi_S_RegisterSound( "sound/weapons/rocket/tick.wav" ));
+			}
+		}
+
+		oldDif = dif;
+
+		for ( int i = 0; i < dif; i++ )
+		{
+			color[0] = 1.0f;
+			color[1] = 0.0f;
+			color[2] = 0.0f;
+			color[3] = 0.1f * i + 0.2f;
+
+			cgi_R_SetColor( color );
+
+			// our slices are offset by about 45 degrees.
+			CG_DrawRotatePic( cx - sz, cy - sz, sz, sz, i * 45.0f, cgi_R_RegisterShaderNoMip( "gfx/2d/wedge" ));
+		}
+
+		// we are locked and loaded baby
+		if ( dif == 8 )
+		{
+			color[0] = color[1] = color[2] = sin( cg.time * 0.05f ) * 0.5f + 0.5f;
+			color[3] = 1.0f; // this art is additive, so the alpha value does nothing
+
+			cgi_R_SetColor( color );
+
+			CG_DrawPic( cx - sz, cy - sz * 2, sz * 2, sz * 2, cgi_R_RegisterShaderNoMip( "gfx/2d/lock" ));
+		}
+	}
+}
+
+
+//------------------------------------
+static void CG_RunRocketLocking( void )
+//------------------------------------
+{
+	centity_t	*player = &cg_entities[0];
+
+	// Only bother with this when the player is holding down the alt-fire button of the rocket launcher
+	if ( player->currentState.weapon == WP_ROCKET_LAUNCHER )
+	{
+		if ( player->currentState.eFlags & EF_ALT_FIRING )
+		{
+			CG_ScanForRocketLock();
+
+			if ( g_rocketLockEntNum > 0 && g_rocketLockEntNum < ENTITYNUM_WORLD && g_rocketLockTime > 0 )
+			{
+#ifdef _XBOX
+				FFFX_START( fffx_StartConst );
+#endif
+				CG_DrawRocketLocking( g_rocketLockEntNum, g_rocketLockTime );
+			}
+#ifdef _XBOX
+			else
+			{
+				FFFX_START( fffx_StopConst );
+			}
+#endif
+		}
+		else
+		{
+			// disengage any residual locking
+#ifdef _XBOX
+			FFFX_START( fffx_StopConst );
+#endif
+			g_rocketLockEntNum = ENTITYNUM_WORLD;
+			g_rocketLockTime = 0;
+		}
+	}
+}
+
+/*
+=================
+CG_DrawIntermission
+=================
+*/
+static void CG_DrawIntermission( void ) {
+	CG_DrawScoreboard();
+}
+
+
+/*
+==================
+CG_DrawSnapshot
+==================
+*/
+static float CG_DrawSnapshot( float y ) {
+	char		*s;
+	int			w;
+
+	s = va( "time:%i snap:%i cmd:%i", cg.snap->serverTime, 
+		cg.latestSnapshotNum, cgs.serverCommandSequence );
+
+	w = cgi_R_Font_StrLenPixels(s, cgs.media.qhFontMedium, 1.0f);	
+	cgi_R_Font_DrawString(635 - w, y+2, s, colorTable[CT_LTGOLD1], cgs.media.qhFontMedium, -1, 1.0f);
+
+	return y + BIGCHAR_HEIGHT + 10;
+}
+
+
+/*
+==================
+CG_DrawFPS
+==================
+*/
+#define	FPS_FRAMES	16
+static float CG_DrawFPS( float y ) {
+	char		*s;
+	static unsigned short previousTimes[FPS_FRAMES];
+	static unsigned short index;
+	static int	previous, lastupdate;
+	int		t, i, fps, total;
+	unsigned short frameTime;
+#ifdef _XBOX
+	const int		xOffset = 30;
+#else
+	const int		xOffset = 0;
+#endif
+
+	// don't use serverTime, because that will be drifting to
+	// correct for internet lag changes, timescales, timedemos, etc
+	t = cgi_Milliseconds();
+	frameTime = t - previous;
+	previous = t;
+	if (t - lastupdate > 50)	//don't sample faster than this
+	{
+		lastupdate = t;
+		previousTimes[index % FPS_FRAMES] = frameTime;
+		index++;
+	}
+	// average multiple frames together to smooth changes out a bit
+	total = 0;
+	for ( i = 0 ; i < FPS_FRAMES ; i++ ) {
+		total += previousTimes[i];
+	}
+	if ( !total ) {
+		total = 1;
+	}
+	fps = 1000 * FPS_FRAMES / total;
+
+	s = va( "%ifps", fps );
+	const int w = cgi_R_Font_StrLenPixels(s, cgs.media.qhFontMedium, 1.0f);	
+	cgi_R_Font_DrawString(635-xOffset - w, y+2, s, colorTable[CT_LTGOLD1], cgs.media.qhFontMedium, -1, 1.0f);
+
+	return y + BIGCHAR_HEIGHT + 10;
+}
+
+/*
+=================
+CG_DrawTimer
+=================
+*/
+static float CG_DrawTimer( float y ) {
+	char		*s;
+	int			w;
+	int			mins, seconds, tens;
+
+	seconds = cg.time / 1000;
+	mins = seconds / 60;
+	seconds -= mins * 60;
+	tens = seconds / 10;
+	seconds -= tens * 10;
+
+	s = va( "%i:%i%i", mins, tens, seconds );
+
+	w = cgi_R_Font_StrLenPixels(s, cgs.media.qhFontMedium, 1.0f);	
+	cgi_R_Font_DrawString(635 - w, y+2, s, colorTable[CT_LTGOLD1], cgs.media.qhFontMedium, -1, 1.0f);
+
+	return y + BIGCHAR_HEIGHT + 10;
+}
+
+
+/*
+=================
+CG_DrawAmmoWarning
+=================
+*/
+static void CG_DrawAmmoWarning( void ) {
+	char text[1024]={0};
+	int			w;
+
+	if ( cg_drawAmmoWarning.integer == 0 ) {
+		return;
+	}
+
+	if ( !cg.lowAmmoWarning ) {
+		return;
+	}
+
+	if ( weaponData[cg.snap->ps.weapon].ammoIndex == AMMO_NONE )
+	{//doesn't use ammo, so no warning
+		return;
+	}
+
+	if ( cg.lowAmmoWarning == 2 ) {
+		cgi_SP_GetStringTextString( "SP_INGAME_INSUFFICIENTENERGY", text, sizeof(text) );
+	} else {
+		return;
+		//s = "LOW AMMO WARNING";
+	}
+
+	w = cgi_R_Font_StrLenPixels(text, cgs.media.qhFontSmall, 1.0f);	
+	cgi_R_Font_DrawString(320 - w/2, 64, text, colorTable[CT_LTGOLD1], cgs.media.qhFontSmall, -1, 1.0f);
+}
+
+//---------------------------------------
+static qboolean CG_RenderingFromMiscCamera()
+{
+	//centity_t *cent;
+
+	//cent = &cg_entities[cg.snap->ps.clientNum];
+
+	if ( cg.snap->ps.viewEntity > 0 &&
+		cg.snap->ps.viewEntity < ENTITYNUM_WORLD )// cent && cent->gent && cent->gent->client && cent->gent->client->ps.viewEntity)
+	{
+		// Only check viewEntities
+		if ( !Q_stricmp( "misc_camera", g_entities[cg.snap->ps.viewEntity].classname ))
+		{
+			// Only doing a misc_camera, so check health.
+			if ( g_entities[cg.snap->ps.viewEntity].health > 0 )
+			{
+				CG_DrawPic( 0, 0, 640, 480, cgi_R_RegisterShader( "gfx/2d/workingCamera" ));
+			}
+			else
+			{
+				CG_DrawPic( 0, 0, 640, 480, cgi_R_RegisterShader( "gfx/2d/brokenCamera" ));
+			}
+			// don't render other 2d stuff
+			return qtrue;
+		}
+		else if ( !Q_stricmp( "misc_panel_turret", g_entities[cg.snap->ps.viewEntity].classname ))
+		{
+			// could do a panel turret screen overlay...this is a cheesy placeholder
+			CG_DrawPic( 30, 90, 128, 300, cgs.media.turretComputerOverlayShader );
+			CG_DrawPic( 610, 90, -128, 300, cgs.media.turretComputerOverlayShader );
+		}
+		else
+		{
+			// FIXME: make sure that this assumption is correct...because I'm assuming that I must be a droid.
+			CG_DrawPic( 0, 0, 640, 480, cgi_R_RegisterShader( "gfx/2d/droid_view" ));
+		}
+	}
+
+	// not in misc_camera, render other stuff.
+	return qfalse;
+}
+
+qboolean cg_usingInFrontOf = qfalse;
+qboolean CanUseInfrontOf(gentity_t*);
+static void CG_UseIcon()
+{
+	cg_usingInFrontOf = CanUseInfrontOf(cg_entities[cg.snap->ps.clientNum].gent);
+	if (cg_usingInFrontOf)
+	{
+		cgi_R_SetColor( NULL );
+		CG_DrawPic( 50, 285, 64, 64, cgs.media.useableHint );
+	}
+}
+
+static void CG_Draw2DScreenTints( void )
+{
+	float	rageTime, rageRecTime, absorbTime, protectTime;
+	vec4_t	hcolor;
+	//force effects
+	if (cg.snap->ps.forcePowersActive & (1 << FP_RAGE))
+	{
+		if (!cgRageTime)
+		{
+			cgRageTime = cg.time;
+		}
+		
+		rageTime = (float)(cg.time - cgRageTime);
+		
+		rageTime /= 9000;
+		
+		if ( rageTime < 0 )
+		{
+			rageTime = 0;
+		}
+		if ( rageTime > 0.15f )
+		{
+			rageTime = 0.15f;
+		}
+		
+		hcolor[3] = rageTime;
+		hcolor[0] = 0.7f;
+		hcolor[1] = 0;
+		hcolor[2] = 0;
+		
+		if (!cg.renderingThirdPerson)
+		{
+			CG_FillRect( 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, hcolor  );
+		}
+		
+		cgRageFadeTime = 0;
+		cgRageFadeVal = 0;
+	}
+	else if (cgRageTime)
+	{
+		if (!cgRageFadeTime)
+		{
+			cgRageFadeTime = cg.time;
+			cgRageFadeVal = 0.15f;
+		}
+		
+		rageTime = cgRageFadeVal;
+		
+		cgRageFadeVal -= (cg.time - cgRageFadeTime)*0.000005;
+		
+		if (rageTime < 0)
+		{
+			rageTime = 0;
+		}
+		if ( rageTime > 0.15f )
+		{
+			rageTime = 0.15f;
+		}
+		
+		if ( cg.snap->ps.forceRageRecoveryTime > cg.time )
+		{
+			float checkRageRecTime = rageTime;
+			
+			if ( checkRageRecTime < 0.15f )
+			{
+				checkRageRecTime = 0.15f;
+			}
+			
+			hcolor[3] = checkRageRecTime;
+			hcolor[0] = rageTime*4;
+			if ( hcolor[0] < 0.2f )
+			{
+				hcolor[0] = 0.2f;
+			}
+			hcolor[1] = 0.2f;
+			hcolor[2] = 0.2f;
+		}
+		else
+		{
+			hcolor[3] = rageTime;
+			hcolor[0] = 0.7f;
+			hcolor[1] = 0;
+			hcolor[2] = 0;
+		}
+		
+		if (!cg.renderingThirdPerson && rageTime)
+		{
+			CG_FillRect( 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, hcolor  );
+		}
+		else
+		{
+			if (cg.snap->ps.forceRageRecoveryTime > cg.time)
+			{
+				hcolor[3] = 0.15f;
+				hcolor[0] = 0.2f;
+				hcolor[1] = 0.2f;
+				hcolor[2] = 0.2f;
+				CG_FillRect( 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, hcolor  );
+			}
+			cgRageTime = 0;
+		}
+	}
+	else if (cg.snap->ps.forceRageRecoveryTime > cg.time)
+	{
+		if (!cgRageRecTime)
+		{
+			cgRageRecTime = cg.time;
+		}
+		
+		rageRecTime = (float)(cg.time - cgRageRecTime);
+		
+		rageRecTime /= 9000;
+		
+		if ( rageRecTime < 0.15f )//0)
+		{
+			rageRecTime = 0.15f;//0;
+		}
+		if ( rageRecTime > 0.15f )
+		{
+			rageRecTime = 0.15f;
+		}
+		
+		hcolor[3] = rageRecTime;
+		hcolor[0] = 0.2f;
+		hcolor[1] = 0.2f;
+		hcolor[2] = 0.2f;
+		
+		if ( !cg.renderingThirdPerson )
+		{
+			CG_FillRect( 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, hcolor  );
+		}
+		
+		cgRageRecFadeTime = 0;
+		cgRageRecFadeVal = 0;
+	}
+	else if (cgRageRecTime)
+	{
+		if (!cgRageRecFadeTime)
+		{
+			cgRageRecFadeTime = cg.time;
+			cgRageRecFadeVal = 0.15f;
+		}
+		
+		rageRecTime = cgRageRecFadeVal;
+		
+		cgRageRecFadeVal -= (cg.time - cgRageRecFadeTime)*0.000005;
+		
+		if (rageRecTime < 0)
+		{
+			rageRecTime = 0;
+		}
+		if ( rageRecTime > 0.15f )
+		{
+			rageRecTime = 0.15f;
+		}
+		
+		hcolor[3] = rageRecTime;
+		hcolor[0] = 0.2f;
+		hcolor[1] = 0.2f;
+		hcolor[2] = 0.2f;
+		
+		if (!cg.renderingThirdPerson && rageRecTime)
+		{
+			CG_FillRect( 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, hcolor  );
+		}
+		else
+		{
+			cgRageRecTime = 0;
+		}
+	}
+	
+	if (cg.snap->ps.forcePowersActive & (1 << FP_ABSORB))
+	{
+		if (!cgAbsorbTime)
+		{
+			cgAbsorbTime = cg.time;
+		}
+		
+		absorbTime = (float)(cg.time - cgAbsorbTime);
+		
+		absorbTime /= 9000;
+		
+		if ( absorbTime < 0 )
+		{
+			absorbTime = 0;
+		}
+		if ( absorbTime > 0.15f )
+		{
+			absorbTime = 0.15f;
+		}
+		
+		hcolor[3] = absorbTime/2;
+		hcolor[0] = 0;
+		hcolor[1] = 0;
+		hcolor[2] = 0.7f;
+		
+		if ( !cg.renderingThirdPerson )
+		{
+			CG_FillRect( 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, hcolor  );
+		}
+		
+		cgAbsorbFadeTime = 0;
+		cgAbsorbFadeVal = 0;
+	}
+	else if (cgAbsorbTime)
+	{
+		if (!cgAbsorbFadeTime)
+		{
+			cgAbsorbFadeTime = cg.time;
+			cgAbsorbFadeVal = 0.15f;
+		}
+		
+		absorbTime = cgAbsorbFadeVal;
+		
+		cgAbsorbFadeVal -= (cg.time - cgAbsorbFadeTime)*0.000005;
+		
+		if ( absorbTime < 0 )
+		{
+			absorbTime = 0;
+		}
+		if ( absorbTime > 0.15f )
+		{
+			absorbTime = 0.15f;
+		}
+		
+		hcolor[3] = absorbTime/2;
+		hcolor[0] = 0;
+		hcolor[1] = 0;
+		hcolor[2] = 0.7f;
+		
+		if ( !cg.renderingThirdPerson && absorbTime )
+		{
+			CG_FillRect( 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, hcolor  );
+		}
+		else
+		{
+			cgAbsorbTime = 0;
+		}
+	}
+	
+	if (cg.snap->ps.forcePowersActive & (1 << FP_PROTECT))
+	{
+		if (!cgProtectTime)
+		{
+			cgProtectTime = cg.time;
+		}
+		
+		protectTime = (float)(cg.time - cgProtectTime);
+		
+		protectTime /= 9000;
+		
+		if (protectTime < 0)
+		{
+			protectTime = 0;
+		}
+		if ( protectTime > 0.15f )
+		{
+			protectTime = 0.15f;
+		}
+		
+		hcolor[3] = protectTime/2;
+		hcolor[0] = 0;
+		hcolor[1] = 0.7f;
+		hcolor[2] = 0;
+		
+		if ( !cg.renderingThirdPerson )
+		{
+			CG_FillRect( 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, hcolor  );
+		}
+		
+		cgProtectFadeTime = 0;
+		cgProtectFadeVal = 0;
+	}
+	else if ( cgProtectTime )
+	{
+		if ( !cgProtectFadeTime )
+		{
+			cgProtectFadeTime = cg.time;
+			cgProtectFadeVal = 0.15f;
+		}
+		
+		protectTime = cgProtectFadeVal;
+		
+		cgProtectFadeVal -= (cg.time - cgProtectFadeTime)*0.000005;
+		
+		if (protectTime < 0)
+		{
+			protectTime = 0;
+		}
+		if (protectTime > 0.15f)
+		{
+			protectTime = 0.15f;
+		}
+		
+		hcolor[3] = protectTime/2;
+		hcolor[0] = 0;
+		hcolor[1] = 0.7f;
+		hcolor[2] = 0;
+		
+		if ( !cg.renderingThirdPerson && protectTime )
+		{
+			CG_FillRect( 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, hcolor  );
+		}
+		else
+		{
+			cgProtectTime = 0;
+		}
+	}
+
+	if ( (cg.refdef.viewContents&CONTENTS_LAVA) )
+	{//tint screen red
+		float phase = cg.time / 1000.0 * WAVE_FREQUENCY * M_PI * 2;
+		hcolor[3] = 0.5 + (0.15f*sin( phase ));
+		hcolor[0] = 0.7f;
+		hcolor[1] = 0;
+		hcolor[2] = 0;
+		
+		CG_FillRect( 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, hcolor  );
+	}
+	else if ( (cg.refdef.viewContents&CONTENTS_SLIME) )
+	{//tint screen green
+		float phase = cg.time / 1000.0 * WAVE_FREQUENCY * M_PI * 2;
+		hcolor[3] = 0.4 + (0.1f*sin( phase ));
+		hcolor[0] = 0;
+		hcolor[1] = 0.7f;
+		hcolor[2] = 0;
+		
+		CG_FillRect( 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, hcolor  );
+	}
+	else if ( (cg.refdef.viewContents&CONTENTS_WATER) )
+	{//tint screen light blue -- FIXME: check to see if in fog? 
+		float phase = cg.time / 1000.0 * WAVE_FREQUENCY * M_PI * 2;
+		hcolor[3] = 0.3 + (0.05f*sin( phase ));
+		hcolor[0] = 0;
+		hcolor[1] = 0.2f;
+		hcolor[2] = 0.8f;
+		
+		CG_FillRect( 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, hcolor  );
+	}
+}
+/*
+=================
+CG_Draw2D
+=================
+*/
+extern void CG_SaberClashFlare( void );
+static void CG_Draw2D( void ) 
+{
+	char	text[1024]={0};
+	int		w,y_pos;
+	centity_t *cent = &cg_entities[cg.snap->ps.clientNum];
+
+	// if we are taking a levelshot for the menu, don't draw anything
+	if ( cg.levelShot ) 
+	{
+		return;
+	}
+
+	if ( cg_draw2D.integer == 0 ) 
+	{
+		return;
+	}
+
+	if ( cg.snap->ps.pm_type == PM_INTERMISSION ) 
+	{
+		CG_DrawIntermission();
+		return;
+	}
+
+	CG_Draw2DScreenTints();
+
+	//end credits
+	if (cg_endcredits.integer)
+	{
+		if (!CG_Credits_Draw())
+		{
+			CG_DrawCredits();	// will probably get rid of this soon
+		}
+	}
+
+	CGCam_DrawWideScreen();
+
+	CG_DrawBatteryCharge();
+
+	if (cg.snap->ps.forcePowersActive || cg.snap->ps.forceRageRecoveryTime > cg.time)
+	{
+		CG_DrawActivePowers();
+	}
+
+	// Draw this before the text so that any text won't get clipped off
+	if ( !in_camera )
+	{
+		CG_DrawZoomMask();
+	}
+
+	CG_DrawScrollText();
+	CG_DrawCaptionText(); 
+
+	if ( in_camera )
+	{//still draw the saber clash flare, but nothing else
+		CG_SaberClashFlare();
+		return;
+	}
+
+	if ( CG_RenderingFromMiscCamera())
+	{
+		// purposely doing an early out when in a misc_camera, change it if needed.
+		
+		// allowing center print when in camera mode, probably just an alpha thing - dmv
+		CG_DrawCenterString();
+		return;
+	}
+
+	if ( (cg.snap->ps.forcePowersActive&(1<<FP_SEE)) )
+	{//force sight is on
+		//indicate this with sight cone thingy
+		CG_DrawPic( 0, 0, 640, 480, cgi_R_RegisterShader( "gfx/2d/jsense" ));
+		CG_DrawHealthBars();
+	}
+	else if ( cg_debugHealthBars.integer )
+	{
+		CG_DrawHealthBars();
+	}
+
+
+	// don't draw any status if dead
+	if ( cg.snap->ps.stats[STAT_HEALTH] > 0 ) 
+	{
+		if ( !(cent->gent && cent->gent->s.eFlags & (EF_LOCKED_TO_WEAPON )))//|EF_IN_ATST
+		{
+			//CG_DrawIconBackground();
+		}
+
+		CG_DrawWeaponSelect();
+
+		if ( cg.zoomMode == 0 )
+		{
+			CG_DrawStats();
+		}
+		CG_DrawAmmoWarning();
+
+		//CROSSHAIR is now done from the crosshair ent trace
+		//if ( !cg.renderingThirdPerson && !cg_dynamicCrosshair.integer ) // disruptor draws it's own crosshair artwork; binocs draw nothing; third person draws its own crosshair
+		//{
+		//	CG_DrawCrosshair( NULL );
+		//}
+
+
+		CG_DrawCrosshairNames();
+
+		CG_RunRocketLocking();
+
+		CG_DrawInventorySelect();
+
+		CG_DrawForceSelect();
+
+		CG_DrawPickupItem();
+
+		CG_UseIcon();
+	}
+	CG_SaberClashFlare();
+
+#ifdef _XBOX
+	float y = 32;
+#else
+	float y = 0;
+#endif
+	if (cg_drawSnapshot.integer) {
+		y=CG_DrawSnapshot(y);
+	} 
+	if (cg_drawFPS.integer) {
+		y=CG_DrawFPS(y);
+	} 
+	if (cg_drawTimer.integer) {
+		y=CG_DrawTimer(y);
+	}
+
+	// don't draw center string if scoreboard is up
+	if ( !CG_DrawScoreboard() ) {
+		CG_DrawCenterString();
+	}
+
+/*	if (cg.showInformation)
+	{
+//		CG_DrawMissionInformation();
+	}
+	else 
+*/	
+	if (missionInfo_Updated)
+	{	
+		if (cg.predicted_player_state.pm_type != PM_DEAD)
+		{
+			// Was a objective given?
+/*			if ((cg_updatedDataPadForcePower.integer) || (cg_updatedDataPadObjective.integer))
+			{
+				// How long has the game been running? If within 15 seconds of starting, throw up the datapad.
+				if (cg.dataPadLevelStartTime>cg.time)
+				{
+					// Make it pop up
+					if (!in_camera)
+					{
+						cgi_SendConsoleCommand( "datapad" );
+						cg.dataPadLevelStartTime=cg.time;	//and don't do it again this level!
+					}
+				}
+			}
+*/
+			if (!cg.missionInfoFlashTime)
+			{
+				cg.missionInfoFlashTime	= cg.time + cg_missionInfoFlashTime.integer;
+			}
+
+			if (cg.missionInfoFlashTime < cg.time)	// Time's up.  They didn't read it.
+			{
+				cg.missionInfoFlashTime = 0;
+				missionInfo_Updated = qfalse;
+
+				CG_ClearDataPadCvars();
+			}
+
+			cgi_SP_GetStringTextString( "SP_INGAME_NEW_OBJECTIVE_INFO", text, sizeof(text) );
+			
+			int x_pos = 0;
+			y_pos = 20;
+			w = cgi_R_Font_StrLenPixels(text,cgs.media.qhFontSmall, 1.0f);
+			x_pos = (SCREEN_WIDTH/2)-(w/2);
+			cgi_R_Font_DrawString(x_pos, y_pos, text,  colorTable[CT_LTRED1], cgs.media.qhFontMedium, -1, 1.0f);
+		}
+	}
+
+	if (cg.weaponPickupTextTime	> cg.time )
+	{
+		int x_pos = 0;
+		y_pos = 5;
+		gi.Cvar_VariableStringBuffer( "cg_WeaponPickupText", text, sizeof(text) );
+
+		w = cgi_R_Font_StrLenPixels(text,cgs.media.qhFontSmall, 0.8f);
+		x_pos = (SCREEN_WIDTH/2)-(w/2);
+
+		cgi_R_Font_DrawString(x_pos, y_pos, text,  colorTable[CT_WHITE], cgs.media.qhFontMedium, -1, 0.8f);
+	}
+}
+
+/*
+===================
+CG_DrawIconBackground
+
+Choose the proper background for the icons, scale it depending on if your opening or
+closing the icon section of the HU
+===================
+*/
+void CG_DrawIconBackground(void)
+{
+	int				backgroundXPos,backgroundYPos;
+	int				backgroundWidth,backgroundHeight;
+	qhandle_t		background;
+	const float		shutdownTime = 130.0f;
+
+	// Are we in zoom mode or the HUD is turned off?
+	if (( cg.zoomMode != 0 ) || !( cg_drawHUD.integer ))
+	{
+		return;
+	}
+
+	if ((cg.snap->ps.viewEntity>0 && cg.snap->ps.viewEntity<ENTITYNUM_WORLD))
+	{
+		return;
+	}
+
+	// Get size and location of bakcround specified in the HUD.MENU file
+	if (!cgi_UI_GetMenuInfo("iconbackground",&backgroundXPos,&backgroundYPos,&backgroundWidth,&backgroundHeight))
+	{
+		return;
+	}
+
+	// Use inventory background?
+	if (((cg.inventorySelectTime+WEAPON_SELECT_TIME)>cg.time) || (cgs.media.currentBackground == ICON_INVENTORY))	
+	{
+		background = cgs.media.inventoryIconBackground;
+	}
+	// Use weapon background?
+	else if (((cg.weaponSelectTime+WEAPON_SELECT_TIME)>cg.time) || (cgs.media.currentBackground == ICON_WEAPONS))	
+	{
+		background = 0;
+		//background = cgs.media.weaponIconBackground;
+	}
+	// Use force background?
+	else 	
+	{
+		background = cgs.media.forceIconBackground;
+	}
+
+	// Time is up, shutdown the icon section of the HUD
+	if ((cg.iconSelectTime+WEAPON_SELECT_TIME)<cg.time)
+	{
+		// Scale background down as it goes away
+		if (background && cg.iconHUDActive)		
+		{
+			cg.iconHUDPercent = (cg.time - (cg.iconSelectTime+WEAPON_SELECT_TIME))/ shutdownTime;
+			cg.iconHUDPercent = 1.0f - cg.iconHUDPercent;
+
+			if (cg.iconHUDPercent<0.0f)
+			{
+				cg.iconHUDActive = qfalse;
+				cg.iconHUDPercent=0.f;
+			}
+
+			float holdFloat = (float) backgroundHeight;
+			backgroundHeight = (int) (holdFloat*cg.iconHUDPercent);
+			CG_DrawPic( backgroundXPos, backgroundYPos, backgroundWidth, -backgroundHeight, background);	// Top half
+			CG_DrawPic( backgroundXPos, backgroundYPos,backgroundWidth, backgroundHeight, background);	// Bottom half
+		}
+		return;
+	}
+
+	// Scale background up as it comes up
+	if (!cg.iconHUDActive)
+	{
+		cg.iconHUDPercent = (cg.time - cg.iconSelectTime)/ shutdownTime;
+
+		// Calc how far into opening sequence we are
+		if (cg.iconHUDPercent>1.0f)
+		{
+			cg.iconHUDActive = qtrue;
+			cg.iconHUDPercent=1.0f;
+		}
+		else if (cg.iconHUDPercent<0.0f)
+		{
+			cg.iconHUDPercent=0.0f;
+		}
+	}
+	else
+	{
+		cg.iconHUDPercent=1.0f;
+	}
+
+	// Print the background
+	if (background)
+	{
+		cgi_R_SetColor( colorTable[CT_WHITE] );					
+		float holdFloat = (float) backgroundHeight;
+		backgroundHeight = (int) (holdFloat*cg.iconHUDPercent);
+		CG_DrawPic( backgroundXPos, backgroundYPos, backgroundWidth, -backgroundHeight, background);	// Top half
+		CG_DrawPic( backgroundXPos, backgroundYPos,backgroundWidth, backgroundHeight, background);	// Bottom half
+	}
+	if ((cg.inventorySelectTime+WEAPON_SELECT_TIME)>cg.time)	
+	{
+		cgs.media.currentBackground = ICON_INVENTORY;
+	}
+	else if ((cg.weaponSelectTime+WEAPON_SELECT_TIME)>cg.time)	 
+	{
+		cgs.media.currentBackground = ICON_WEAPONS;
+	}
+	else 
+	{
+		cgs.media.currentBackground = ICON_FORCE;
+	}
+}
+
+/*
+=====================
+CG_DrawActive
+
+Perform all drawing needed to completely fill the screen
+=====================
+*/
+void CG_DrawActive( stereoFrame_t stereoView ) {
+	float		separation;
+	vec3_t		baseOrg;
+
+	// optionally draw the info screen instead
+	if ( !cg.snap ) {
+		CG_DrawInformation();
+		return;
+	}
+
+	//FIXME: these globals done once at start of frame for various funcs
+	AngleVectors (cg.refdefViewAngles, vfwd, vright, vup);
+	VectorCopy( vfwd, vfwd_n );
+	VectorCopy( vright, vright_n );
+	VectorCopy( vup, vup_n );
+	VectorNormalize( vfwd_n );
+	VectorNormalize( vright_n );
+	VectorNormalize( vup_n );
+
+	switch ( stereoView ) {
+	case STEREO_CENTER:
+		separation = 0;
+		break;
+	case STEREO_LEFT:
+		separation = -cg_stereoSeparation.value / 2;
+		break;
+	case STEREO_RIGHT:
+		separation = cg_stereoSeparation.value / 2;
+		break;
+	default:
+		separation = 0;
+		CG_Error( "CG_DrawActive: Undefined stereoView" );
+	}
+
+
+	// clear around the rendered view if sized down
+	CG_TileClear();
+
+	// offset vieworg appropriately if we're doing stereo separation
+	VectorCopy( cg.refdef.vieworg, baseOrg );
+	if ( separation != 0 ) {
+		VectorMA( cg.refdef.vieworg, -separation, cg.refdef.viewaxis[1], cg.refdef.vieworg );
+	}
+
+	if ( cg.zoomMode == 3 && cg.snap->ps.batteryCharge ) // doing the Light amp goggles thing
+	{
+		cgi_R_LAGoggles();
+	}
+
+	if ( (cg.snap->ps.forcePowersActive&(1<<FP_SEE)) )
+	{
+		cg.refdef.rdflags |= RDF_ForceSightOn;
+	}
+
+	cg.refdef.rdflags |= RDF_DRAWSKYBOX;
+
+	// draw 3D view
+	cgi_R_RenderScene( &cg.refdef );
+
+	// restore original viewpoint if running stereo
+	if ( separation != 0 ) {
+		VectorCopy( baseOrg, cg.refdef.vieworg );
+	}
+
+	// draw status bar and other floating elements
+	CG_Draw2D();
+
+}
+
diff --git a/code/cgame/cg_drawtools.cpp b/code/cgame/cg_drawtools.cpp
new file mode 100644
index 0000000..e2f3246
--- /dev/null
+++ b/code/cgame/cg_drawtools.cpp
@@ -0,0 +1,473 @@
+
+// this line must stay at top so the whole PCH thing works...
+#include "cg_headers.h"
+
+//#include "cg_local.h"
+#include "cg_media.h"
+
+/*
+================
+CG_DrawSides
+
+Coords are virtual 640x480
+================
+*/
+void CG_DrawSides(float x, float y, float w, float h, float size) {
+	//size *= cgs.screenXScale;
+	cgi_R_DrawStretchPic( x, y, size, h, 0, 0, 0, 0, cgs.media.whiteShader );
+	cgi_R_DrawStretchPic( x + w - size, y, size, h, 0, 0, 0, 0, cgs.media.whiteShader );
+}
+
+void CG_DrawTopBottom(float x, float y, float w, float h, float size) {
+	//size *= cgs.screenYScale;
+	cgi_R_DrawStretchPic( x, y, w, size, 0, 0, 0, 0, cgs.media.whiteShader );
+	cgi_R_DrawStretchPic( x, y + h - size, w, size, 0, 0, 0, 0, cgs.media.whiteShader );
+}
+
+/*
+================
+CG_DrawRect
+
+Coordinates are 640*480 virtual values
+=================
+*/
+void CG_DrawRect( float x, float y, float width, float height, float size, const float *color ) {
+	cgi_R_SetColor( color );
+	
+	CG_DrawTopBottom(x, y, width, height, size);
+	CG_DrawSides(x, y, width, height, size);
+	
+	cgi_R_SetColor( NULL );
+}
+
+/*
+================
+CG_FillRect
+
+Coordinates are 640*480 virtual values
+=================
+*/
+void CG_FillRect( float x, float y, float width, float height, const float *color ) {
+	cgi_R_SetColor( color );
+	cgi_R_DrawStretchPic( x, y, width, height, 0, 0, 0, 0, cgs.media.whiteShader);
+	cgi_R_SetColor( NULL );
+}
+
+
+/*
+================
+CG_Scissor
+
+Coordinates are 640*480 virtual values
+=================
+*/
+void CG_Scissor( float x, float y, float width, float height) 
+{
+
+	cgi_R_Scissor( x, y, width, height);
+
+}
+
+
+/*
+================
+CG_DrawPic
+
+Coordinates are 640*480 virtual values
+A width of 0 will draw with the original image width
+=================
+*/
+void CG_DrawPic( float x, float y, float width, float height, qhandle_t hShader ) {
+	cgi_R_DrawStretchPic( x, y, width, height, 0, 0, 1, 1, hShader );
+}
+
+/*
+================
+CG_DrawPic2
+
+Coordinates are 640*480 virtual values
+A width of 0 will draw with the original image width
+Can also specify the exact texture coordinates
+=================
+*/
+void CG_DrawPic2( float x, float y, float width, float height, float s1, float t1, float s2, float t2, qhandle_t hShader ) 
+{
+	cgi_R_DrawStretchPic( x, y, width, height, s1, t1, s2, t2, hShader );
+}
+
+/*
+================
+CG_DrawRotatePic
+
+Coordinates are 640*480 virtual values
+A width of 0 will draw with the original image width
+rotates around the upper right corner of the passed in point
+=================
+*/
+void CG_DrawRotatePic( float x, float y, float width, float height,float angle, qhandle_t hShader ) {
+	cgi_R_DrawRotatePic( x, y, width, height, 0, 0, 1, 1, angle, hShader );
+}
+
+/*
+================
+CG_DrawRotatePic2
+
+Coordinates are 640*480 virtual values
+A width of 0 will draw with the original image width
+Actually rotates around the center point of the passed in coordinates
+=================
+*/
+void CG_DrawRotatePic2( float x, float y, float width, float height,float angle, qhandle_t hShader ) {
+	cgi_R_DrawRotatePic2( x, y, width, height, 0, 0, 1, 1, angle, hShader );
+}
+
+/*
+===============
+CG_DrawChar
+
+Coordinates and size in 640*480 virtual screen size
+===============
+*/
+void CG_DrawChar( int x, int y, int width, int height, int ch ) {
+	int row, col;
+	float frow, fcol;
+	float size;
+	float	ax, ay, aw, ah;
+
+	ch &= 255;
+
+	if ( ch == ' ' ) {
+		return;
+	}
+
+	ax = x;
+	ay = y;
+	aw = width;
+	ah = height;
+
+	row = ch>>4;
+	col = ch&15;
+/*
+	frow = row*0.0625;
+	fcol = col*0.0625;
+	size = 0.0625;
+
+	cgi_R_DrawStretchPic( ax, ay, aw, ah,
+					   fcol, frow, 
+					   fcol + size, frow + size, 
+					   cgs.media.charsetShader );
+*/
+
+	float size2;
+
+	frow = row*0.0625;
+	fcol = col*0.0625;
+	size = 0.03125;
+	size2 = 0.0625;
+
+	cgi_R_DrawStretchPic( ax, ay, aw, ah, fcol, frow, fcol + size, frow + size2, 
+		cgs.media.charsetShader );
+
+}
+
+
+/*
+==================
+CG_DrawStringExt
+
+Draws a multi-colored string with a drop shadow, optionally forcing
+to a fixed color.
+
+Coordinates are at 640 by 480 virtual resolution
+==================
+*/
+void CG_DrawStringExt( int x, int y, const char *string, const float *setColor, 
+		qboolean forceColor, qboolean shadow, int charWidth, int charHeight ) {
+	vec4_t		color;
+	const char	*s;
+	int			xx;
+
+	// draw the drop shadow
+	if (shadow) {
+		color[0] = color[1] = color[2] = 0;
+		color[3] = setColor[3];
+		cgi_R_SetColor( color );
+		s = string;
+		xx = x;
+		while ( *s ) {
+			if ( Q_IsColorString( s ) ) {
+				s += 2;
+				continue;
+			}
+			CG_DrawChar( xx + 2, y + 2, charWidth, charHeight, *s );
+			xx += charWidth;
+			s++;
+		}
+	}
+
+	// draw the colored text
+	s = string;
+	xx = x;
+	cgi_R_SetColor( setColor );
+	while ( *s ) {
+		if ( Q_IsColorString( s ) ) {
+			if ( !forceColor ) {
+				memcpy( color, g_color_table[ColorIndex(*(s+1))], sizeof( color ) );
+				color[3] = setColor[3];
+				cgi_R_SetColor( color );
+			}
+			s += 2;
+			continue;
+		}
+		CG_DrawChar( xx, y, charWidth, charHeight, *s );
+		xx += charWidth;
+		s++;
+	}
+	cgi_R_SetColor( NULL );
+}
+
+
+void CG_DrawSmallStringColor( int x, int y, const char *s, vec4_t color ) {
+	CG_DrawStringExt( x, y, s, color, qtrue, qfalse, SMALLCHAR_WIDTH, SMALLCHAR_HEIGHT );
+}
+
+/*
+=================
+CG_DrawStrlen
+
+Returns character count, skiping color escape codes
+=================
+*/
+int CG_DrawStrlen( const char *str ) {
+	const char *s = str;
+	int count = 0;
+
+	while ( *s ) {
+		if ( Q_IsColorString( s ) ) {
+			s += 2;
+		} else {
+			count++;
+			s++;
+		}
+	}
+
+	return count;
+}
+
+/*
+=============
+CG_TileClearBox
+
+This repeats a 64*64 tile graphic to fill the screen around a sized down
+refresh window.
+=============
+*/
+static void CG_TileClearBox( int x, int y, int w, int h, qhandle_t hShader ) {
+	float	s1, t1, s2, t2;
+
+	s1 = x/64.0;
+	t1 = y/64.0;
+	s2 = (x+w)/64.0;
+	t2 = (y+h)/64.0;
+	cgi_R_DrawStretchPic( x, y, w, h, s1, t1, s2, t2, hShader );
+}
+
+
+
+/*
+==============
+CG_TileClear
+
+Clear around a sized down screen
+==============
+*/
+void CG_TileClear( void ) {
+	int		top, bottom, left, right;
+	int		w, h;
+
+	w = cgs.glconfig.vidWidth;
+	h = cgs.glconfig.vidHeight;
+
+	if ( cg.refdef.x == 0 && cg.refdef.y == 0 && 
+		cg.refdef.width == w && cg.refdef.height == h ) {
+		return;		// full screen rendering
+	}
+
+	top = cg.refdef.y;
+	bottom = top + cg.refdef.height-1;
+	left = cg.refdef.x;
+	right = left + cg.refdef.width-1;
+
+	// clear above view screen
+	CG_TileClearBox( 0, 0, w, top, cgs.media.backTileShader );
+
+	// clear below view screen
+	CG_TileClearBox( 0, bottom, w, h - bottom, cgs.media.backTileShader );
+
+	// clear left of view screen
+	CG_TileClearBox( 0, top, left, bottom - top + 1, cgs.media.backTileShader );
+
+	// clear right of view screen
+	CG_TileClearBox( right, top, w - right, bottom - top + 1, cgs.media.backTileShader );
+}
+
+
+
+/*
+================
+CG_FadeColor
+================
+*/
+float *CG_FadeColor( int startMsec, int totalMsec ) {
+	static vec4_t		color;
+	int			t;
+
+	if ( startMsec == 0 ) {
+		return NULL;
+	}
+
+	t = cg.time - startMsec;
+
+	if ( t >= totalMsec ) {
+		return NULL;
+	}
+
+	// fade out
+	if ( totalMsec - t < FADE_TIME ) {
+		color[3] = ( totalMsec - t ) * 1.0/FADE_TIME;
+	} else {
+		color[3] = 1.0;
+	}
+	color[0] = color[1] = color[2] = 1;
+
+	return color;
+}
+
+/*
+==============
+CG_DrawNumField
+
+Take x,y positions as if 640 x 480 and scales them to the proper resolution
+
+==============
+*/
+void CG_DrawNumField (int x, int y, int width, int value,int charWidth,int charHeight,int style,qboolean zeroFill) 
+{
+	char	num[16], *ptr;
+	int		l;
+	int		frame;
+	int		xWidth;
+
+	if (width < 1) {
+		return;
+	}
+
+	// draw number string
+	if (width > 5) {
+		width = 5;
+	}
+
+	switch ( width ) {
+	case 1:
+		value = value > 9 ? 9 : value;
+		value = value < 0 ? 0 : value;
+		break;
+	case 2:
+		value = value > 99 ? 99 : value;
+		value = value < -9 ? -9 : value;
+		break;
+	case 3:
+		value = value > 999 ? 999 : value;
+		value = value < -99 ? -99 : value;
+		break;
+	case 4:
+		value = value > 9999 ? 9999 : value;
+		value = value < -999 ? -999 : value;
+		break;
+	}
+
+	Com_sprintf (num, sizeof(num), "%i", value);
+	l = strlen(num);
+	if (l > width)
+		l = width;
+
+	// FIXME: Might need to do something different for the chunky font??
+	switch(style)
+	{
+	case NUM_FONT_SMALL:
+		xWidth = charWidth;
+		break;
+	case NUM_FONT_CHUNKY:
+		xWidth = (charWidth/1.2f) + 2;
+		break;
+	default:
+	case NUM_FONT_BIG:
+		xWidth = (charWidth/2) + 7;//(charWidth/6);
+		break;
+	}
+
+	if ( zeroFill )
+	{
+		for (int i = 0; i < (width - l); i++ )
+		{
+			switch(style)
+			{
+			case NUM_FONT_SMALL:
+				CG_DrawPic( x,y, charWidth, charHeight, cgs.media.smallnumberShaders[0] );
+				break;
+			case NUM_FONT_CHUNKY:
+				CG_DrawPic( x,y, charWidth, charHeight, cgs.media.chunkyNumberShaders[0] );
+				break;
+			default:
+			case NUM_FONT_BIG:
+				CG_DrawPic( x,y, charWidth, charHeight, cgs.media.numberShaders[0] );
+				break;
+			}
+			x += 2 + (xWidth);
+		}
+	}
+	else
+	{
+		x += 2 + (xWidth)*(width - l);
+	}
+
+	ptr = num;
+	while (*ptr && l)
+	{
+		if (*ptr == '-')
+			frame = STAT_MINUS;
+		else
+			frame = *ptr -'0';
+
+		switch(style)
+		{
+		case NUM_FONT_SMALL:
+			CG_DrawPic( x,y, charWidth, charHeight, cgs.media.smallnumberShaders[frame] );
+			x++;	// For a one line gap
+			break;
+		case NUM_FONT_CHUNKY:
+			CG_DrawPic( x,y, charWidth, charHeight, cgs.media.chunkyNumberShaders[frame] );
+			break;
+		default:
+		case NUM_FONT_BIG:
+			CG_DrawPic( x,y, charWidth, charHeight, cgs.media.numberShaders[frame] );
+			break;
+		}
+
+		x += (xWidth);
+		ptr++;
+		l--;
+	}
+
+}
+
+/*
+=================
+CG_DrawProportionalString
+=================
+*/
+void CG_DrawProportionalString( int x, int y, const char* str, int style, vec4_t color ) 
+{
+	//assert(!style);//call this directly if you need style (OR it into the font handle)
+	cgi_R_Font_DrawString (x, y, str, color, cgs.media.qhFontMedium, -1, 1.0f);
+}
\ No newline at end of file
diff --git a/code/cgame/cg_effects.cpp b/code/cgame/cg_effects.cpp
new file mode 100644
index 0000000..a908426
--- /dev/null
+++ b/code/cgame/cg_effects.cpp
@@ -0,0 +1,1087 @@
+// cg_effects.c -- these functions generate localentities
+
+// this line must stay at top so the whole PCH thing works...
+#include "cg_headers.h"
+
+//#include "cg_local.h"
+#include "cg_media.h"
+
+#if !defined(FX_SCHEDULER_H_INC)
+	#include "FxScheduler.h"
+#endif
+
+//void DoBolt( vec3_t m_origin, vec3_t m_origin2, float m_scale, float m_deviation );
+
+/*
+====================
+CG_MakeExplosion
+====================
+*/
+/*
+localEntity_t *CG_MakeExplosion( vec3_t origin, vec3_t dir, 
+								qhandle_t hModel, int numFrames, qhandle_t shader,
+								int msec, qboolean isSprite, float scale, int flags )
+{
+	float			ang = 0;
+	localEntity_t	*ex;
+	int				offset;
+	vec3_t			tmpVec, newOrigin;
+
+	if ( msec <= 0 ) {
+		CG_Error( "CG_MakeExplosion: msec = %i", msec );
+	}
+
+	// skew the time a bit so they aren't all in sync
+	offset = rand() & 63;
+
+	ex = CG_AllocLocalEntity();
+	if ( isSprite ) {
+		ex->leType = LE_SPRITE_EXPLOSION; 
+		ex->refEntity.rotation = rand() % 360;
+		ex->radius = scale;
+		VectorScale( dir, 16, tmpVec );
+		VectorAdd( tmpVec, origin, newOrigin );
+	} else {
+		ex->leType = LE_EXPLOSION;
+		VectorCopy( origin, newOrigin );
+
+		// set axis with random rotate when necessary
+		if ( !dir )
+		{
+			AxisClear( ex->refEntity.axis );
+		}
+		else
+		{
+			if ( !(flags & LEF_NO_RANDOM_ROTATE) )
+				ang = rand() % 360;
+			VectorCopy( dir, ex->refEntity.axis[0] );
+			RotateAroundDirection( ex->refEntity.axis, ang );
+		}
+	}
+
+	ex->startTime = cg.time - offset;
+	ex->endTime = ex->startTime + msec;
+	
+	// bias the time so all shader effects start correctly
+	ex->refEntity.shaderTime = ex->startTime / 1000.0f;
+
+	ex->refEntity.hModel = hModel;
+	ex->refEntity.customShader = shader;
+	ex->lifeRate = (float)numFrames / msec;
+	ex->leFlags = flags;
+
+	//Scale the explosion
+	if (scale != 1) {
+		ex->refEntity.nonNormalizedAxes = qtrue;
+
+		VectorScale( ex->refEntity.axis[0], scale, ex->refEntity.axis[0] );
+		VectorScale( ex->refEntity.axis[1], scale, ex->refEntity.axis[1] );
+		VectorScale( ex->refEntity.axis[2], scale, ex->refEntity.axis[2] );
+	}
+	// set origin
+	VectorCopy ( newOrigin, ex->refEntity.origin);
+	VectorCopy ( newOrigin, ex->refEntity.oldorigin );
+
+	ex->color[0] = ex->color[1] = ex->color[2] = 1.0;
+
+	return ex;
+}
+*/
+// When calling this version, just pass in a zero for the flags
+//localEntity_t *CG_MakeExplosion( vec3_t origin, vec3_t dir, 
+//								qhandle_t hModel, int numFrames, qhandle_t shader,
+//								int msec, qboolean isSprite, float scale ) {
+//	return CG_MakeExplosion( origin, dir, hModel, numFrames, shader, msec, isSprite, scale, 0 );
+//}
+
+/*
+====================
+CG_AddTempLight
+====================
+*/
+localEntity_t *CG_AddTempLight( vec3_t origin, float scale, vec3_t color, int msec )
+{
+	localEntity_t	*ex;
+
+	if ( msec <= 0 ) {
+		CG_Error( "CG_AddTempLight: msec = %i", msec );
+	}
+
+	ex = CG_AllocLocalEntity();
+
+	ex->leType = LE_LIGHT; 
+
+	ex->startTime = cg.time;
+	ex->endTime = ex->startTime + msec;
+	
+	// set origin
+	VectorCopy ( origin, ex->refEntity.origin);
+	VectorCopy ( origin, ex->refEntity.oldorigin );
+
+	VectorCopy( color, ex->lightColor );
+	ex->light = scale;	
+
+	return ex;
+}
+
+/*
+-------------------------
+CG_ExplosionEffects
+
+Used to find the player and shake the camera if close enough
+intensity ranges from 1 (minor tremble) to 16 (major quake)
+-------------------------
+*/
+
+void CG_ExplosionEffects( vec3_t origin, float intensity, int radius, int time )
+{
+	//FIXME: When exactly is the vieworg calculated in relation to the rest of the frame?s
+
+	vec3_t	dir;
+	float	dist, intensityScale;
+	float	realIntensity;
+
+	VectorSubtract( cg.refdef.vieworg, origin, dir );
+	dist = VectorNormalize( dir );
+
+	//Use the dir to add kick to the explosion
+
+	if ( dist > radius )
+		return;
+
+	intensityScale = 1 - ( dist / (float) radius );
+	realIntensity = intensity * intensityScale;
+
+	CGCam_Shake( realIntensity, time );
+}
+
+
+/*
+-------------------------
+CG_SurfaceExplosion
+
+Adds an explosion to a surface
+-------------------------
+*/
+
+/*
+#define NUM_SPARKS		12
+#define NUM_PUFFS		1
+#define NUM_EXPLOSIONS	4
+
+void CG_SurfaceExplosion( vec3_t origin, vec3_t normal, float radius, float shake_speed, qboolean smoke )
+{
+	localEntity_t	*le;
+	//FXTrail			*particle;
+	vec3_t			direction, new_org;
+	vec3_t			velocity		= { 0, 0, 0 };
+	vec3_t			temp_org, temp_vel;
+	float			scale, dscale;
+	int				i, numSparks;
+
+	//Sparks
+	numSparks = 16 + (random() * 16.0f);
+	
+	for ( i = 0; i < numSparks; i++ )
+	{	
+		scale = 0.25f + (random() * 2.0f);
+		dscale = -scale*0.5;
+
+		particle = FX_AddTrail( origin,
+								NULL,
+								NULL,
+								32.0f,
+								-64.0f,
+								scale,
+								-scale,
+								1.0f,
+								0.0f,
+								0.25f,
+								4000.0f,
+								cgs.media.sparkShader,
+								rand() & FXF_BOUNCE);
+		if ( particle == NULL )
+			return;
+
+		FXE_Spray( normal, 500, 150, 1.0f, 768 + (rand() & 255), (FXPrimitive *) particle );
+	}
+
+	//Smoke
+	//Move this out a little from the impact surface
+	VectorMA( origin, 4, normal, new_org );
+	VectorSet( velocity, 0.0f, 0.0f, 16.0f );
+
+	for ( i = 0; i < 4; i++ )
+	{
+		VectorSet( temp_org, new_org[0] + (crandom() * 16.0f), new_org[1] + (crandom() * 16.0f), new_org[2] + (random() * 4.0f) );
+		VectorSet( temp_vel, velocity[0] + (crandom() * 8.0f), velocity[1] + (crandom() * 8.0f), velocity[2] + (crandom() * 8.0f) );
+
+		FX_AddSprite(	temp_org,
+						temp_vel, 
+						NULL, 
+						64.0f + (random() * 32.0f), 
+						16.0f, 
+						1.0f, 
+						0.0f,
+						20.0f + (crandom() * 90.0f),
+						0.5f,
+						1500.0f, 
+						cgs.media.smokeShader, FXF_USE_ALPHA_CHAN );	
+	}
+
+	//Core of the explosion
+
+	//Orient the explosions to face the camera
+	VectorSubtract( cg.refdef.vieworg, origin, direction );
+	VectorNormalize( direction );
+
+	//Tag the last one with a light
+	le = CG_MakeExplosion( origin, direction, cgs.media.explosionModel, 6, cgs.media.surfaceExplosionShader, 500, qfalse, radius * 0.02f + (random() * 0.3f) );
+	le->light = 150;
+	VectorSet( le->lightColor, 0.9f, 0.8f, 0.5f );
+
+	for ( i = 0; i < NUM_EXPLOSIONS-1; i ++)
+	{
+		VectorSet( new_org, (origin[0] + (16 + (crandom() * 8))*crandom()), (origin[1] + (16 + (crandom() * 8))*crandom()), (origin[2] + (16 + (crandom() * 8))*crandom()) );
+		le = CG_MakeExplosion( new_org, direction, cgs.media.explosionModel, 6, cgs.media.surfaceExplosionShader, 300 + (rand() & 99), qfalse, radius * 0.05f + (crandom() *0.3f) );
+	}
+
+	//Shake the camera
+	CG_ExplosionEffects( origin, shake_speed, 350, 750 );
+
+	// The level designers wanted to be able to turn the smoke spawners off.  The rationale is that they
+	//	want to blow up catwalks and such that fall down...when that happens, it shouldn't really leave a mark
+	//	and a smoke spewer at the explosion point...
+	if ( smoke )
+	{
+		VectorMA( origin, -8, normal, temp_org );
+//		FX_AddSpawner( temp_org, normal, NULL, NULL, 100, random()*25.0f, 5000.0f, (void *) CG_SmokeSpawn );
+
+		//Impact mark
+		//FIXME: Replace mark
+		//CG_ImpactMark( cgs.media.burnMarkShader, origin, normal, random()*360, 1,1,1,1, qfalse, 8, qfalse );
+	}
+}
+*/
+/*
+-------------------------
+CG_MiscModelExplosion
+
+Adds an explosion to a misc model breakables
+-------------------------
+*/
+
+void CG_MiscModelExplosion( vec3_t mins, vec3_t maxs, int size, material_t chunkType )
+{
+	int		ct = 13;
+	float	r;
+	vec3_t	org, mid, dir;
+	char	*effect = NULL, *effect2 = NULL;
+
+	VectorAdd( mins, maxs, mid );
+	VectorScale( mid, 0.5f, mid );
+
+	switch( chunkType )
+	{
+	case MAT_GLASS:
+		effect = "chunks/glassbreak";
+		ct = 5;
+		break;
+	case MAT_GLASS_METAL:
+		effect = "chunks/glassbreak";
+		effect2 = "chunks/metalexplode";
+		ct = 5;
+		break;
+	case MAT_ELECTRICAL:
+	case MAT_ELEC_METAL:
+		effect = "chunks/sparkexplode";
+		ct = 5;
+		break;
+	case MAT_METAL:
+	case MAT_METAL2:
+	case MAT_METAL3:
+	case MAT_CRATE1:
+	case MAT_CRATE2:
+		effect = "chunks/metalexplode";
+		ct = 2;
+		break;
+	case MAT_GRATE1:
+		effect = "chunks/grateexplode";
+		ct = 8;
+		break;
+	case MAT_ROPE:
+		ct = 20;
+		effect = "chunks/ropebreak";
+		break;
+	case MAT_WHITE_METAL: //not sure what this crap is really supposed to be..
+	case MAT_DRK_STONE:
+	case MAT_LT_STONE:
+	case MAT_GREY_STONE:
+		switch( size )
+		{
+		case 2:
+			effect = "chunks/rockbreaklg";
+			break;
+		case 1:
+		default:
+			effect = "chunks/rockbreakmed";
+			break;
+		}
+	}
+
+	if ( !effect )
+	{
+		return;
+	}
+
+	ct += 7 * size;
+
+	// FIXME: real precache .. VERify that these need to be here...don't think they would because the effects should be registered in g_breakable
+	theFxScheduler.RegisterEffect( effect );
+
+	if ( effect2 )
+	{
+		// FIXME: real precache
+		theFxScheduler.RegisterEffect( effect2 );
+	}
+
+	// spawn chunk roughly in the bbox of the thing..
+	for ( int i = 0; i < ct; i++ )
+	{
+		for( int j = 0; j < 3; j++ )
+		{
+			r = random() * 0.8f + 0.1f;
+			org[j] = ( r * mins[j] + ( 1 - r ) * maxs[j] );
+		}
+
+		// shoot effect away from center
+		VectorSubtract( org, mid, dir );
+		VectorNormalize( dir );
+
+		if ( effect2 && ( rand() & 1 ))
+		{
+			theFxScheduler.PlayEffect( effect2, org, dir );
+		}
+		else
+		{
+			theFxScheduler.PlayEffect( effect, org, dir );
+		}
+	}
+}
+
+/*
+-------------------------
+CG_Chunks
+
+Fun chunk spewer
+-------------------------
+*/
+
+void CG_Chunks( int owner, vec3_t origin, const vec3_t normal, const vec3_t mins, const vec3_t maxs, 
+						float speed, int numChunks, material_t chunkType, int customChunk, float baseScale, int customSound = 0 )
+{
+	localEntity_t	*le;
+	refEntity_t		*re;
+	vec3_t			dir;
+	int				i, j, k;
+	int				chunkModel = 0;
+	leBounceSound_t	bounce = LEBS_NONE;
+	float			r, speedMod = 1.0f;
+	qboolean		chunk = qfalse;
+
+	if ( chunkType == MAT_NONE )
+	{
+		// Well, we should do nothing
+		return;
+	}
+
+	if ( customSound )
+	{
+		if ( cgs.sound_precache[customSound] ) 
+		{
+			cgi_S_StartSound( NULL, owner, CHAN_BODY, cgs.sound_precache[customSound] );
+		}
+	}
+	// Set up our chunk sound info...breaking sounds are done here so they are done once on breaking..some return instantly because the chunks are done with effects instead of models
+	switch( chunkType )
+	{
+	case MAT_GLASS:
+		if ( !customSound )
+		{
+			cgi_S_StartSound( NULL, owner, CHAN_BODY, cgs.media.glassChunkSound );
+		}
+		return;
+		break;
+	case MAT_GRATE1:
+		if ( !customSound )
+		{
+			cgi_S_StartSound( NULL, owner, CHAN_BODY, cgs.media.grateSound );
+		}
+		return;
+		break;
+	case MAT_ELECTRICAL:// (sparks)
+		if ( !customSound )
+		{
+			cgi_S_StartSound( NULL, owner, CHAN_BODY, cgi_S_RegisterSound (va("sound/ambience/spark%d.wav", Q_irand(1, 6))) );
+		}
+		return;
+		break;
+	case MAT_DRK_STONE:
+	case MAT_LT_STONE:
+	case MAT_GREY_STONE:
+	case MAT_WHITE_METAL:  // not quite sure what this stuff is supposed to be...it's for Stu
+		if ( !customSound )
+		{
+			cgi_S_StartSound( NULL, owner, CHAN_BODY, cgs.media.rockBreakSound );
+			bounce = LEBS_ROCK;
+		}
+		speedMod = 0.5f; // rock blows up less
+		break;
+	case MAT_GLASS_METAL:
+		if ( !customSound )
+		{
+			cgi_S_StartSound( NULL, owner, CHAN_BODY, cgs.media.glassChunkSound ); // FIXME: should probably have a custom sound
+			bounce = LEBS_METAL;
+		}
+		break;
+	case MAT_CRATE1:
+	case MAT_CRATE2:
+		if ( !customSound )
+		{
+			cgi_S_StartSound( NULL, owner, CHAN_BODY, cgs.media.crateBreakSound[Q_irand(0,1)] );
+		}
+		break;
+	case MAT_METAL:
+	case MAT_METAL2:
+	case MAT_METAL3:
+	case MAT_ELEC_METAL:// FIXME: maybe have its own sound?
+		if ( !customSound )
+		{
+			cgi_S_StartSound( NULL, owner, CHAN_BODY, cgs.media.chunkSound );
+			bounce = LEBS_METAL;
+		}
+		speedMod = 0.8f; // metal blows up a bit more
+		break;
+	case MAT_ROPE:
+		/*
+		if ( !customSound )
+		{
+			cgi_S_StartSound( NULL, owner, CHAN_BODY, cgi_S_RegisterSound( "" ));  FIXME:  needs a sound
+		}
+		*/
+		return;
+		break;
+	}
+
+	if ( baseScale <= 0.0f )
+	{
+		baseScale = 1.0f;
+	}
+
+	// Chunks
+	for( i = 0; i < numChunks; i++ )
+	{
+		if ( customChunk > 0 )
+		{
+			// Try to use a custom chunk.
+			if ( cgs.model_draw[customChunk] )
+			{
+				chunk = qtrue;
+				chunkModel = cgs.model_draw[customChunk];
+			}
+		}
+
+		if ( !chunk )
+		{
+			// No custom chunk.  Pick a random chunk type at run-time so we don't get the same chunks
+			switch( chunkType )
+			{
+			case MAT_METAL2: //bluegrey
+				chunkModel = cgs.media.chunkModels[CHUNK_METAL2][Q_irand(0, 3)];
+				break;
+			case MAT_GREY_STONE://gray
+				chunkModel = cgs.media.chunkModels[CHUNK_ROCK1][Q_irand(0, 3)];
+				break;
+			case MAT_LT_STONE: //tan
+				chunkModel = cgs.media.chunkModels[CHUNK_ROCK2][Q_irand(0, 3)];
+				break;
+			case MAT_DRK_STONE://brown
+				chunkModel = cgs.media.chunkModels[CHUNK_ROCK3][Q_irand(0, 3)];
+				break;
+			case MAT_WHITE_METAL:
+				chunkModel = cgs.media.chunkModels[CHUNK_WHITE_METAL][Q_irand(0, 3)];
+				break;
+			case MAT_CRATE1://yellow multi-colored crate chunks
+				chunkModel = cgs.media.chunkModels[CHUNK_CRATE1][Q_irand(0, 3)];
+				break;
+			case MAT_CRATE2://red multi-colored crate chunks
+				chunkModel = cgs.media.chunkModels[CHUNK_CRATE2][Q_irand(0, 3)];
+				break;
+			case MAT_ELEC_METAL:
+			case MAT_GLASS_METAL:
+			case MAT_METAL://grey
+				chunkModel = cgs.media.chunkModels[CHUNK_METAL1][Q_irand(0, 3)];
+				break;
+			case MAT_METAL3:
+				if ( rand() & 1 )
+				{
+					chunkModel = cgs.media.chunkModels[CHUNK_METAL1][Q_irand(0, 3)];
+				}
+				else
+				{
+					chunkModel = cgs.media.chunkModels[CHUNK_METAL2][Q_irand(0, 3)];
+				}
+				break;
+			}
+		}
+
+		// It wouldn't look good to throw a bunch of RGB axis models...so make sure we have something to work with.
+		if ( chunkModel )
+		{
+			le = CG_AllocLocalEntity();
+			re = &le->refEntity;
+
+			re->hModel = chunkModel;
+			le->leType = LE_FRAGMENT;
+			le->endTime = cg.time + 1300 + random() * 900;
+
+			// spawn chunk roughly in the bbox of the thing...bias towards center in case thing blowing up doesn't complete fill its bbox.
+			for( j = 0; j < 3; j++ )
+			{
+				r = random() * 0.8f + 0.1f;
+				re->origin[j] = ( r * mins[j] + ( 1 - r ) * maxs[j] );
+			}
+			VectorCopy( re->origin, le->pos.trBase );
+
+			// Move out from center of thing, otherwise you can end up things moving across the brush in an undesirable direction.  Visually looks wrong
+			VectorSubtract( re->origin, origin, dir );
+			VectorNormalize( dir );
+			VectorScale( dir, Q_flrand( speed * 0.5f, speed * 1.25f ) * speedMod, le->pos.trDelta );
+
+			// Angular Velocity
+			VectorSet( le->angles.trBase, random() * 360, random() * 360, random() * 360 );
+
+			le->angles.trDelta[0] = crandom();
+			le->angles.trDelta[1] = crandom();
+			le->angles.trDelta[2] = 0; // don't do roll
+
+			VectorScale( le->angles.trDelta, random() * 600.0f + 200.0f, le->angles.trDelta );
+
+			le->pos.trType = TR_GRAVITY;
+			le->angles.trType = TR_LINEAR;
+			le->pos.trTime = le->angles.trTime = cg.time;
+			le->bounceFactor = 0.2f + random() * 0.2f;
+			le->leFlags |= LEF_TUMBLE;
+			le->ownerGentNum = owner;
+			le->leBounceSoundType = bounce; 
+
+			// Make sure that we have the desired start size set
+			le->radius = Q_flrand( baseScale * 0.75f, baseScale * 1.25f );
+			re->nonNormalizedAxes = qtrue;
+			AxisCopy( axisDefault, re->axis ); // could do an angles to axis, but this is cheaper and works ok
+			for( k = 0; k < 3; k++ )
+			{
+				VectorScale( re->axis[k], le->radius, re->axis[k] );
+			}
+		}
+	}
+}
+
+void CG_TestLine( vec3_t start, vec3_t end, int time, unsigned int color, int radius ) 
+{
+	localEntity_t	*le;
+	refEntity_t		*re;
+
+	le = CG_AllocLocalEntity();
+	le->leType = LE_LINE;
+	le->startTime = cg.time;
+	le->endTime = cg.time + time;
+	le->lifeRate = 1.0 / ( le->endTime - le->startTime );
+
+	re = &le->refEntity;
+	VectorCopy( start, re->origin );
+	VectorCopy( end, re->oldorigin);
+	re->shaderTime = cg.time / 1000.0f;
+
+	re->reType = RT_LINE;
+	re->radius = 0.5*radius;
+	re->customShader = cgs.media.whiteShader; //trap_R_RegisterShaderNoMip("textures/colombia/canvas_doublesided");
+
+	re->shaderTexCoord[0] = re->shaderTexCoord[1] = 1.0f;
+
+	if (color==0)
+	{
+		re->shaderRGBA[0] = re->shaderRGBA[1] = re->shaderRGBA[2] = re->shaderRGBA[3] = 0xff;
+	}
+	else
+	{
+		re->shaderRGBA[0] = color & 0xff;
+		color >>= 8;
+		re->shaderRGBA[1] = color & 0xff;
+		color >>= 8;
+		re->shaderRGBA[2] = color & 0xff;
+//		color >>= 8;
+//		re->shaderRGBA[3] = color & 0xff;
+		re->shaderRGBA[3] = 0xff;
+	}
+
+	le->color[3] = 1.0;
+}
+
+//----------------------------
+//
+// Breaking Glass Technology
+//
+//----------------------------
+
+// Since we have shared verts when we tesselate the glass sheet, it helps to have a 
+//	random offset table set up up front...so that we can have more random looking breaks.
+
+static float offX[20][20],
+			offZ[20][20];
+
+static void CG_DoGlassQuad( vec3_t p[4], vec2_t uv[4], bool stick, int time, vec3_t dmgDir )
+{
+	float	bounce;
+	vec3_t	rotDelta;
+	vec3_t	vel, accel;
+	vec3_t	rgb1;
+
+	VectorSet( vel, crandom() * 12, crandom() * 12, -1 );
+
+	if ( !stick )
+	{
+		// We aren't a motion delayed chunk, so let us move quickly
+		VectorMA( vel, 0.3f, dmgDir, vel );
+	}
+
+	// Set up acceleration due to gravity, 800 is standard QuakeIII gravity, so let's use something close
+	VectorSet( accel, 0.0f, 0.0f, -(600.0f + random() * 100.0f ) );
+
+	VectorSet( rgb1, 1.0f, 1.0f, 1.0f );
+
+	// Being glass, we don't want to bounce much
+	bounce = random() * 0.2f + 0.15f;
+
+	// Set up our random rotate, we only do PITCH and YAW, not ROLL.  This is something like degrees per second
+	VectorSet( rotDelta, crandom() * 40.0f, crandom() * 40.0f, 0.0f );
+
+	CPoly *pol = FX_AddPoly(p, uv, 4,			// verts, ST, vertCount
+			vel, accel,				// motion
+			0.15f, 0.0f, 85.0f,		// alpha start, alpha end, alpha parm ( begin alpha fade when 85% of life is complete )
+			rgb1, rgb1, 0.0f,		// rgb start, rgb end, rgb parm ( not used )
+			rotDelta, bounce, time,	// rotation amount, bounce, and time to delay motion for ( zero if no delay );
+			3500 + random() * 1000,	// life
+			cgi_R_RegisterShader( "gfx/misc/test_crackle" ), 
+			FX_APPLY_PHYSICS | FX_ALPHA_NONLINEAR | FX_USE_ALPHA );
+
+	if ( random() > 0.95f && pol )
+	{
+		pol->AddFlags( FX_IMPACT_RUNS_FX | FX_KILL_ON_IMPACT );
+		pol->SetImpactFxID( theFxScheduler.RegisterEffect( "misc/glass_impact" ));
+	}
+}
+
+static void CG_CalcBiLerp( vec3_t verts[4], vec3_t subVerts[4], vec2_t uv[4] )
+{
+	vec3_t	temp;
+
+	// Nasty crap
+	VectorScale( verts[0],	1.0f - uv[0][0],	subVerts[0] );
+	VectorMA( subVerts[0],	uv[0][0],			verts[1], subVerts[0] );
+	VectorScale( subVerts[0], 1.0f - uv[0][1],	temp );
+	VectorScale( verts[3],	1.0f - uv[0][0],	subVerts[0] );
+	VectorMA( subVerts[0],	uv[0][0],			verts[2], subVerts[0] );
+	VectorMA( temp,			uv[0][1],			subVerts[0], subVerts[0] );
+
+	VectorScale( verts[0],	1.0f - uv[1][0],	subVerts[1] );
+	VectorMA( subVerts[1],	uv[1][0],			verts[1], subVerts[1] );
+	VectorScale( subVerts[1], 1.0f - uv[1][1],	temp );
+	VectorScale( verts[3],	1.0f - uv[1][0],	subVerts[1] );
+	VectorMA( subVerts[1],	uv[1][0],			verts[2], subVerts[1] );
+	VectorMA( temp,			uv[1][1],			subVerts[1], subVerts[1] );
+
+	VectorScale( verts[0],	1.0f - uv[2][0],	subVerts[2] );
+	VectorMA( subVerts[2],	uv[2][0],			verts[1], subVerts[2] );
+	VectorScale( subVerts[2], 1.0f - uv[2][1],		temp );
+	VectorScale( verts[3],	1.0f - uv[2][0],	subVerts[2] );
+	VectorMA( subVerts[2],	uv[2][0],			verts[2], subVerts[2] );
+	VectorMA( temp,			uv[2][1],			subVerts[2], subVerts[2] );
+
+	VectorScale( verts[0],	1.0f - uv[3][0],	subVerts[3] );
+	VectorMA( subVerts[3],	uv[3][0],			verts[1], subVerts[3] );
+	VectorScale( subVerts[3], 1.0f - uv[3][1],	temp );
+	VectorScale( verts[3],	1.0f - uv[3][0],	subVerts[3] );
+	VectorMA( subVerts[3],	uv[3][0],			verts[2], subVerts[3] );
+	VectorMA( temp,			uv[3][1],			subVerts[3], subVerts[3] );
+}
+// bilinear
+//f(p',q') = (1 - y) × {[(1 - x) × f(p,q)] + [x × f(p,q+1)]} + y × {[(1 - x) × f(p+1,q)] + [x × f(p+1,q+1)]}. 
+
+
+static void CG_CalcHeightWidth( vec3_t verts[4], float *height, float *width )
+{
+	vec3_t	dir1, dir2, cross;
+
+	VectorSubtract( verts[3], verts[0], dir1 ); // v
+	VectorSubtract( verts[1], verts[0], dir2 ); // p-a
+	CrossProduct( dir1, dir2, cross );
+	*width = VectorNormalize( cross ) / VectorNormalize( dir1 ); // v 
+	VectorSubtract( verts[2], verts[0], dir2 ); // p-a
+	CrossProduct( dir1, dir2, cross );
+	*width += VectorNormalize( cross ) / VectorNormalize( dir1 ); // v 
+	*width *= 0.5f;
+
+	VectorSubtract( verts[1], verts[0], dir1 ); // v
+	VectorSubtract( verts[2], verts[0], dir2 ); // p-a
+	CrossProduct( dir1, dir2, cross );
+	*height = VectorNormalize( cross ) / VectorNormalize( dir1 ); // v 
+	VectorSubtract( verts[3], verts[0], dir2 ); // p-a
+	CrossProduct( dir1, dir2, cross );
+	*height += VectorNormalize( cross ) / VectorNormalize( dir1 ); // v 
+	*height *= 0.5f;
+}
+//Consider a line in 3D with position vector "a" and direction vector "v" and 
+// let "p" be the position vector of an arbitrary point in 3D
+//dist = len( crossprod(p-a,v) ) / len(v); 
+
+void CG_InitGlass( void )
+{
+	int i, t;
+
+	// Build a table first, so that we can do a more unpredictable crack scheme
+	//	do it once, up front to save a bit of time.
+	for ( i = 0; i < 20; i++ )
+	{
+		for ( t = 0; t < 20; t++ )
+		{
+			offX[t][i] = crandom() * 0.03f;
+			offZ[i][t] = crandom() * 0.03f;
+		}
+	}
+}
+
+#define TIME_DECAY_SLOW		0.1f
+#define TIME_DECAY_MED		0.04f
+#define TIME_DECAY_FAST		0.009f
+
+void CG_DoGlass( vec3_t verts[4], vec3_t normal, vec3_t dmgPt, vec3_t dmgDir, float dmgRadius )
+{
+	int		i, t;
+	int		mxHeight, mxWidth;
+	float	height, width;
+	float	stepWidth, stepHeight;
+	float	timeDecay;
+	float	x, z;
+	float	xx, zz;
+	int		time = 0;
+	bool	stick = true;
+	vec3_t	subVerts[4];
+	vec2_t	biPoints[4];
+
+	// To do a smarter tesselation, we should figure out the relative height and width of the brush face,
+	//	then use this to pick a lod value from 1-3 in each axis.  This will give us 1-9 lod levels, which will
+	//	hopefully be sufficient.
+	CG_CalcHeightWidth( verts, &height, &width );
+
+	cgi_S_StartSound( dmgPt, -1, CHAN_AUTO, cgi_S_RegisterSound("sound/effects/glassbreak1.wav"));
+
+	// Pick "LOD" for height
+	if ( height < 100 )
+	{
+		stepHeight = 0.2f;
+		mxHeight = 5;
+		timeDecay = TIME_DECAY_SLOW;
+	}
+/*	else if ( height > 220 ) // was originally mxHeight = 20....but removing this whole section because it causes huge number of chunks...which is bad
+	{
+		stepHeight = 0.075f;
+		mxHeight = 15;
+		timeDecay = TIME_DECAY_FAST;
+	}*/
+	else
+	{
+		stepHeight = 0.1f;
+		mxHeight = 10;
+		timeDecay = TIME_DECAY_MED;
+	}
+
+	// Pick "LOD" for width
+	if ( width < 100 )
+	{
+		stepWidth = 0.2f;
+		mxWidth = 5;
+		timeDecay = ( timeDecay + TIME_DECAY_SLOW ) * 0.5f;
+	}
+/*	else if ( width > 220 ) // don't do this because it causes too much chug with large glass panes...especially when more than one pane can be broken at a time
+	{
+		stepWidth = 0.075f;
+		mxWidth = 15;
+		timeDecay = ( timeDecay + TIME_DECAY_FAST ) * 0.5f;
+	}*/
+	else
+	{
+		stepWidth = 0.1f;
+		mxWidth = 10;
+		timeDecay = ( timeDecay + TIME_DECAY_MED ) * 0.5f;
+	}
+
+	for ( z = 0.0f, i = 0; z < 1.0f; z += stepHeight, i++ )
+	{
+		for ( x = 0.0f, t = 0; x < 1.0f; x += stepWidth, t++ )
+		{
+			// This is nasty..we do this because we don't want to add a random offset on the edge of the glass brush
+			//	...but we do in the center, otherwise the breaking scheme looks way too orderly
+			if ( t > 0 && t < mxWidth )
+			{
+				xx = x - offX[i][t];
+			}
+			else
+			{
+				xx = x;
+			}
+
+			if ( i > 0 && i < mxHeight )
+			{
+				zz = z - offZ[t][i];
+			}
+			else
+			{
+				zz = z;
+			}
+
+			Vector2Set( biPoints[0], xx, zz );
+
+			if ( t + 1 > 0 && t + 1 < mxWidth )
+			{
+				xx = x - offX[i][t + 1];
+			}
+			else
+			{
+				xx = x;
+			}
+
+			if ( i > 0 && i < mxHeight )
+			{
+				zz = z - offZ[t + 1][i];
+			}
+			else
+			{
+				zz = z;
+			}
+
+			Vector2Set( biPoints[1], xx + stepWidth, zz );
+
+			if ( t + 1 > 0 && t + 1 < mxWidth )
+			{
+				xx = x - offX[i + 1][t + 1];
+			}
+			else
+			{
+				xx = x;
+			}
+
+			if ( i + 1 > 0 && i + 1 < mxHeight )
+			{
+				zz = z - offZ[t + 1][i + 1];
+			}
+			else
+			{
+				zz = z;
+			}
+
+			Vector2Set( biPoints[2], xx + stepWidth, zz + stepHeight);
+
+			if ( t > 0 && t < mxWidth )
+			{
+				xx = x - offX[i + 1][t];
+			}
+			else
+			{
+				xx = x;
+			}
+
+			if ( i + 1 > 0 && i + 1 < mxHeight )
+			{
+				zz = z - offZ[t][i + 1];
+			}
+			else
+			{
+				zz = z;
+			}
+
+			Vector2Set( biPoints[3], xx, zz + stepHeight );
+
+			CG_CalcBiLerp( verts, subVerts, biPoints );
+			
+			float dif = DistanceSquared( subVerts[0], dmgPt ) * timeDecay - random() * 32;
+			
+			// If we decrease dif, we are increasing the impact area, making it more likely to blow out large holes
+			dif -= dmgRadius * dmgRadius;
+
+			if ( dif > 1 )
+			{
+				stick = true;
+				time = dif + random() * 200;
+			}
+			else
+			{
+				stick = false;
+				time = 0;
+			}
+
+			CG_DoGlassQuad( subVerts, biPoints, stick, time, dmgDir );
+		}
+	}
+}
+
+/*
+=================
+CG_Seeker
+=================
+*/
+/*void CG_Seeker( centity_t *cent )
+{
+	refEntity_t	re;
+
+	vec3_t	seekerOrg, viewAng;
+	float	angle, c;
+
+	// must match cg_effects ( CG_Seeker ) & g_weapon ( SeekerAcquiresTarget ) & cg_weapons ( CG_FireSeeker )
+	angle = cg.time * 0.004f;
+	c = cos( angle );
+
+	seekerOrg[0] = cent->lerpOrigin[0] + 18 * c;
+	seekerOrg[1] = cent->lerpOrigin[1] + 18 * sin(angle);
+	seekerOrg[2] = cent->lerpOrigin[2] + cg.predicted_player_state.viewheight + 8 + (3 * cos(cg.time * 0.001));
+
+	memset( &re, 0, sizeof( re ) );
+
+	re.reType = RT_MODEL;
+	VectorCopy( seekerOrg, re.origin);
+	re.hModel = cgi_R_RegisterModel( "models/items/remote.md3" );
+
+	VectorCopy( cent->lerpAngles, viewAng ); // so the seeker faces the same direction the player is
+	viewAng[PITCH] = -90; // but, we don't want the seeker facing up or down, always horizontal
+	viewAng[YAW] += c * 15.f;
+
+	AnglesToAxis( viewAng, re.axis );
+	VectorScale( re.axis[0], 0.5f, re.axis[0] );
+	VectorScale( re.axis[1], 0.5f, re.axis[1] );
+	VectorScale( re.axis[2], 0.5f, re.axis[2] );
+	re.nonNormalizedAxes = qtrue;
+
+	cgi_R_AddRefEntityToScene( &re );
+}
+*/
+//------------------------------------------------------------------------------------------
+void CG_DrawTargetBeam( vec3_t start, vec3_t end, vec3_t norm, const char *beamFx, const char *impactFx )
+{
+	int				handle = 0;
+	vec3_t			dir;
+	SEffectTemplate	*temp;
+
+	// overriding the effect, so give us a copy first
+	temp = theFxScheduler.GetEffectCopy( beamFx, &handle );	
+
+	VectorSubtract( start, end, dir );
+	VectorNormalize( dir );
+
+	if ( temp )
+	{
+		// have a copy, so get the line element out of there
+		CPrimitiveTemplate *prim = theFxScheduler.GetPrimitiveCopy( temp, "beam" );
+
+		if ( prim )
+		{
+			// we have the primitive, so modify the endpoint
+			prim->mOrigin2X.SetRange( end[0], end[0] );
+			prim->mOrigin2Y.SetRange( end[1], end[1] );
+			prim->mOrigin2Z.SetRange( end[2], end[2] );
+
+			// have a copy, so get the line element out of there
+			CPrimitiveTemplate *prim = theFxScheduler.GetPrimitiveCopy( temp, "glow" );
+
+			// glow is not required
+			if ( prim )
+			{
+				// we have the primitive, so modify the endpoint
+				prim->mOrigin2X.SetRange( end[0], end[0] );
+				prim->mOrigin2Y.SetRange( end[1], end[1] );
+				prim->mOrigin2Z.SetRange( end[2], end[2] );
+			}
+
+			// play the modified effect
+			theFxScheduler.PlayEffect( handle, start, dir );
+		}
+	}
+
+	if ( impactFx )
+	{
+		theFxScheduler.PlayEffect( impactFx, end, norm );
+	}
+}
+
+void CG_PlayEffectBolted( const char *fxName, const int modelIndex, const int boltIndex, const int entNum, vec3_t origin, int iLoopTime, const bool isRelative )
+{
+	vec3_t	axis[3];//FIXME: shouldn't this be initialized to something?  It isn't in the EV_PLAY_EFFECT call... irrelevant?
+	int		boltInfo;
+
+	//pack the data into boltInfo as if we were going to send it over the network
+	gi.G2API_AttachEnt(&boltInfo,
+						&g_entities[entNum].ghoul2[modelIndex],
+						boltIndex,
+						entNum,
+						modelIndex); 
+	//send direcly to FX scheduler
+	theFxScheduler.PlayEffect( fxName,
+								origin,
+								axis,
+								boltInfo,
+								-1,
+								false,
+								iLoopTime,
+								isRelative );	//iLoopTime 0 = not looping, 1 for infinite, else duration
+}
+
+void CG_PlayEffectIDBolted( const int fxID, const int modelIndex, const int boltIndex, const int entNum, vec3_t origin, int iLoopTime, const bool isRelative )
+{
+	const char *fxName = CG_ConfigString( CS_EFFECTS + fxID );
+	CG_PlayEffectBolted( fxName, modelIndex, boltIndex, entNum, origin, iLoopTime, isRelative );
+}
+
+void CG_PlayEffectOnEnt( const char *fxName, const int clientNum, vec3_t origin, const vec3_t fwd )
+{
+	vec3_t		temp, axis[3];
+
+	// Assume angles, we'll do a cross product to finish up
+	VectorCopy( fwd, axis[0] );
+	MakeNormalVectors( fwd, axis[1], temp );
+	CrossProduct( axis[0], axis[1], axis[2] );
+	//call FX scheduler directly
+	theFxScheduler.PlayEffect( fxName, origin, axis, -1, clientNum, false );
+}
+
+void CG_PlayEffectIDOnEnt( const int fxID, const int clientNum, vec3_t origin, const vec3_t fwd )
+{
+	const char *fxName = CG_ConfigString( CS_EFFECTS + fxID );
+	CG_PlayEffectOnEnt( fxName, clientNum, origin, fwd );
+}
+
+void CG_PlayEffect( const char *fxName, vec3_t origin, const vec3_t fwd )
+{
+	vec3_t	temp, axis[3];
+
+	// Assume angles, we'll do a cross product to finish up
+	VectorCopy( fwd, axis[0] );
+	MakeNormalVectors( fwd, axis[1], temp );
+	CrossProduct( axis[0], axis[1], axis[2] );
+	//call FX scheduler directly
+	theFxScheduler.PlayEffect( fxName, origin, axis, -1, -1, false );
+}
+
+void CG_PlayEffectID( const int fxID, vec3_t origin, const vec3_t fwd )
+{
+	const char *fxName = CG_ConfigString( CS_EFFECTS + fxID );
+	CG_PlayEffect( fxName, origin, fwd );
+}
\ No newline at end of file
diff --git a/code/cgame/cg_ents.cpp b/code/cgame/cg_ents.cpp
new file mode 100644
index 0000000..026e753
--- /dev/null
+++ b/code/cgame/cg_ents.cpp
@@ -0,0 +1,2658 @@
+// cg_ents.c -- present snapshot entities, happens every single frame
+
+// this line must stay at top so the whole PCH thing works...
+#include "cg_headers.h"
+
+//#include "cg_local.h"
+#include "cg_media.h"
+#include "..\game\g_functions.h"
+#include "..\ghoul2\g2.h"
+#include "FxScheduler.h"
+#include "..\game\wp_saber.h"
+#include "..\game\g_vehicles.h"
+
+extern void CG_AddSaberBlade( centity_t *cent, centity_t *scent, refEntity_t *saber, int renderfx, int modelIndex, vec3_t origin, vec3_t angles);
+extern void CG_CheckSaberInWater( centity_t *cent, centity_t *scent, int modelIndex, vec3_t origin, vec3_t angles );
+extern void CG_ForcePushBlur( const vec3_t org, qboolean darkSide = qfalse );
+extern void CG_AddForceSightShell( refEntity_t *ent, centity_t *cent );
+extern qboolean CG_PlayerCanSeeCent( centity_t *cent );
+
+/*
+======================
+CG_PositionEntityOnTag
+
+Modifies the entities position and axis by the given
+tag location
+======================
+*/
+void CG_PositionEntityOnTag( refEntity_t *entity, const refEntity_t *parent, 
+							qhandle_t parentModel, char *tagName ) {
+	int				i;
+	orientation_t	lerped;
+	
+	// lerp the tag
+	cgi_R_LerpTag( &lerped, parentModel, parent->oldframe, parent->frame,
+		1.0f - parent->backlerp, tagName );
+
+	// FIXME: allow origin offsets along tag?
+	VectorCopy( parent->origin, entity->origin );
+	for ( i = 0 ; i < 3 ; i++ ) 
+	{
+		VectorMA( entity->origin, lerped.origin[i], parent->axis[i], entity->origin );
+	}
+
+	// had to cast away the const to avoid compiler problems...
+	MatrixMultiply( lerped.axis, ((refEntity_t *)parent)->axis, entity->axis );
+	entity->backlerp = parent->backlerp;
+}
+
+/*
+======================
+CG_PositionRotatedEntityOnTag
+
+Modifies the entities position and axis by the given
+tag location
+======================
+*/
+void CG_PositionRotatedEntityOnTag( refEntity_t *entity, const refEntity_t *parent, 
+							qhandle_t parentModel, char *tagName, orientation_t *tagOrient ) {
+	int				i;
+	orientation_t	lerped;
+	vec3_t			tempAxis[3];
+
+	// lerp the tag
+	cgi_R_LerpTag( &lerped, parentModel, parent->oldframe, parent->frame,
+		1.0f - parent->backlerp, tagName );
+
+	if ( tagOrient )
+	{
+		VectorCopy( lerped.origin, tagOrient->origin );
+		for ( i = 0 ; i < 3 ; i++ ) 
+		{
+			VectorCopy( lerped.axis[i], tagOrient->axis[i] );
+		}
+	}
+
+	// FIXME: allow origin offsets along tag?
+	VectorCopy( parent->origin, entity->origin );
+	for ( i = 0 ; i < 3 ; i++ ) {
+		VectorMA( entity->origin, lerped.origin[i], parent->axis[i], entity->origin );
+	}
+
+	MatrixMultiply( entity->axis, lerped.axis, tempAxis );
+	MatrixMultiply( tempAxis, ((refEntity_t *)parent)->axis, entity->axis );
+}
+
+
+
+/*
+==========================================================================
+
+FUNCTIONS CALLED EACH FRAME
+
+==========================================================================
+*/
+
+/*
+======================
+CG_SetEntitySoundPosition
+
+Also called by event processing code
+======================
+*/
+vec3_t *CG_SetEntitySoundPosition( centity_t *cent ) {
+	static vec3_t v3Return;
+	if ( cent->currentState.solid == SOLID_BMODEL ) {
+		vec3_t	origin;
+		float	*v;
+
+		v = cgs.inlineModelMidpoints[ cent->currentState.modelindex ];
+		VectorAdd( cent->lerpOrigin, v, origin );
+		cgi_S_UpdateEntityPosition( cent->currentState.number, origin );
+		VectorCopy(origin, v3Return);
+	} else {
+		if ( cent->currentState.eType == ET_PLAYER
+			&& cent->gent
+			&& cent->gent->client
+			&& cent->gent->ghoul2.IsValid() 
+			&& cent->gent->ghoul2[0].animModelIndexOffset )//If it has an animOffset it's a cinematic anim
+		{//I might be running out of my bounding box, so use my headPoint from the last render frame...?
+			//NOTE: if I'm not rendered, will this not update correctly?  Would cent->lerpOrigin be any more updated?
+			VectorCopy(cent->gent->client->renderInfo.eyePoint, v3Return);
+		}
+		else
+		{//just use my org
+			VectorCopy(cent->lerpOrigin, v3Return);
+		}
+		cgi_S_UpdateEntityPosition( cent->currentState.number, v3Return );
+	}
+
+	return &v3Return;
+}
+
+/*
+==================
+CG_EntityEffects
+
+Add continuous entity effects, like local entity emission and lighting
+==================
+*/
+static void CG_EntityEffects( centity_t *cent ) {
+
+	// update sound origins
+	vec3_t v3Origin;
+	VectorCopy(*CG_SetEntitySoundPosition( cent ),v3Origin);
+
+	// add loop sound
+	if ( cent->currentState.loopSound ) 
+	{
+		soundChannel_t chan = CHAN_AUTO;
+
+		gentity_t *ent = cent->gent;
+
+		if ( ent->s.eFlags & EF_LESS_ATTEN )
+		{
+			chan = CHAN_LESS_ATTEN;
+		}
+		
+		sfxHandle_t	sfx = ( cent->currentState.eType == ET_MOVER ) ? cent->currentState.loopSound : cgs.sound_precache[ cent->currentState.loopSound ];
+
+		// Only play sound if being drawn.
+		if ( !( ent->s.eFlags & EF_NODRAW ) )
+		{
+			cgi_S_AddLoopingSound( cent->currentState.number, v3Origin/*cent->lerpOrigin*/, vec3_origin, sfx, chan );
+		}
+	}
+
+	// constant light glow
+	if ( cent->currentState.constantLight ) {
+		int		cl;
+		int		i, r, g, b;
+
+		cl = cent->currentState.constantLight;
+		r = cl & 255;
+		g = ( cl >> 8 ) & 255;
+		b = ( cl >> 16 ) & 255;
+		i = ( ( cl >> 24 ) & 255 ) * 4;
+		cgi_R_AddLightToScene( cent->lerpOrigin, (float)i, (float)r, (float)g, (float)b );
+	}
+}
+
+void CG_AddRefEntWithTransportEffect ( centity_t *cent, refEntity_t *ent )
+{
+	// We are a normal thing....
+	cgi_R_AddRefEntityToScene (ent);
+
+	if ( ent->renderfx & RF_PULSATE && cent->gent->owner && cent->gent->owner->health &&
+		!cent->gent->owner->s.number && cent->gent->owner->client && //only for player
+			cent->gent->owner->client->ps.saberEntityState == SES_RETURNING && 
+			cent->currentState.saberActive == qfalse )
+	{
+		// if we are the saber and we have been dropped, do a glow so it can be spotted easier
+		float	wv;
+		vec3_t	org;
+
+		ent->customShader = cgi_R_RegisterShader( "gfx/effects/solidWhite_cull" );
+		ent->renderfx = RF_RGB_TINT;
+		wv = sin( cg.time * 0.003f ) * 0.08f + 0.1f;
+		ent->shaderRGBA[0] = wv * 255;
+		ent->shaderRGBA[1] = wv * 255;
+		ent->shaderRGBA[2] = wv * 0;
+		cgi_R_AddRefEntityToScene (ent);
+
+		for ( int i = -4; i < 10; i += 1 )
+		{
+			VectorMA( ent->origin, -i, ent->axis[2], org );
+
+			FX_AddSprite( org, NULL, NULL, 5.5f, 5.5f, wv, wv, 0.0f, 0.0f, 1.0f, cgs.media.yellowDroppedSaberShader, 0x08000000 );
+		}
+		if ( cent->gent->owner->s.weapon == WP_SABER )
+		{//he's still controlling me
+			FX_AddSprite( cent->gent->owner->client->renderInfo.handRPoint, NULL, NULL, 8.0f, 8.0f, wv, wv, 0.0f, 0.0f, 1.0f, cgs.media.yellowDroppedSaberShader, 0x08000000 );
+		}
+	}
+}
+
+
+/*
+Ghoul2 Insert Start
+*/
+
+// Copy the ghoul2 data into the ref ent correctly
+void CG_SetGhoul2Info( refEntity_t *ent, centity_t *cent)
+{
+	ent->ghoul2 = &cent->gent->ghoul2;
+	VectorCopy( cent->currentState.modelScale, ent->modelScale);
+	ent->radius = cent->currentState.radius;
+	VectorCopy (cent->lerpAngles, ent->angles);
+}
+
+
+// write in the axis and stuff
+void G2_BoltToGhoul2Model(centity_t *cent, refEntity_t *ent)
+{
+		// extract the wraith ID from the bolt info
+	int modelNum = cent->currentState.boltInfo >> MODEL_SHIFT;
+	modelNum &= MODEL_AND;
+	int boltNum	= cent->currentState.boltInfo >> BOLT_SHIFT;
+	boltNum &= BOLT_AND;
+	int	entNum = cent->currentState.boltInfo >> ENTITY_SHIFT;
+	entNum &= ENTITY_AND;
+
+ 	mdxaBone_t 		boltMatrix;
+
+ 	// go away and get me the bolt position for this frame please
+ 	gi.G2API_GetBoltMatrix(cent->gent->ghoul2, modelNum, boltNum, &boltMatrix, cg_entities[entNum].currentState.angles, cg_entities[entNum].currentState.origin, cg.time, cgs.model_draw, cent->currentState.modelScale);
+
+	// set up the axis and origin we need for the actual effect spawning
+ 	ent->origin[0] = boltMatrix.matrix[0][3];
+ 	ent->origin[1] = boltMatrix.matrix[1][3];
+ 	ent->origin[2] = boltMatrix.matrix[2][3];
+
+ 	ent->axis[0][0] = boltMatrix.matrix[0][0];
+ 	ent->axis[0][1] = boltMatrix.matrix[1][0];
+ 	ent->axis[0][2] = boltMatrix.matrix[2][0];
+
+ 	ent->axis[1][0] = boltMatrix.matrix[0][1];
+ 	ent->axis[1][1] = boltMatrix.matrix[1][1];
+ 	ent->axis[1][2] = boltMatrix.matrix[2][1];
+
+ 	ent->axis[2][0] = boltMatrix.matrix[0][2];
+ 	ent->axis[2][1] = boltMatrix.matrix[1][2];
+ 	ent->axis[2][2] = boltMatrix.matrix[2][2];
+}
+
+void ScaleModelAxis(refEntity_t	*ent)
+
+{		// scale the model should we need to
+		if (ent->modelScale[0] && ent->modelScale[0] != 1.0f)
+		{
+			VectorScale( ent->axis[0], ent->modelScale[0] , ent->axis[0] );
+			ent->nonNormalizedAxes = qtrue;
+		}
+		if (ent->modelScale[1] && ent->modelScale[1] != 1.0f)
+		{
+			VectorScale( ent->axis[1], ent->modelScale[1] , ent->axis[1] );
+			ent->nonNormalizedAxes = qtrue;
+		}
+		if (ent->modelScale[2] && ent->modelScale[2] != 1.0f)
+		{
+			VectorScale( ent->axis[2], ent->modelScale[2] , ent->axis[2] );
+			ent->nonNormalizedAxes = qtrue;
+		}
+}
+/*
+Ghoul2 Insert End
+*/
+
+/*
+==================
+CG_General
+==================
+*/
+static void CG_General( centity_t *cent ) 
+{
+	refEntity_t			ent;
+	entityState_t		*s1;
+
+	s1 = &cent->currentState;
+/*
+Ghoul2 Insert Start
+*/
+
+	// if set to invisible, skip
+	if (!s1->modelindex && !cent->gent->ghoul2.IsValid() ) {
+		return;
+	}
+/*
+Ghoul2 Insert End
+*/
+
+	if ( s1->eFlags & EF_NODRAW )
+	{
+		// If you don't like it doing NODRAW, then don't set the flag
+		return;
+	}
+
+	memset (&ent, 0, sizeof(ent));
+
+	// set frame
+
+	if ( cent->currentState.eFlags & EF_DISABLE_SHADER_ANIM )
+	{
+		// by setting the shader time to the current time, we can force an animating shader to not animate
+		ent.shaderTime = cg.time * 0.001f;
+	}
+
+	if ( s1->eFlags & EF_SHADER_ANIM )
+	{
+		// Deliberately setting it up so that shader anim will completely override any kind of model animation frame setting.
+		ent.renderfx|=RF_SETANIMINDEX;
+		ent.skinNum = s1->frame;
+	}
+	else if ( s1->eFlags & EF_ANIM_ONCE )
+	{
+		//s1->frame++;
+		//ent.frame = s1->frame;
+		ent.frame = cent->gent->s.frame;
+		ent.renderfx|=RF_CAP_FRAMES;
+	}
+	else if ( s1->eFlags & EF_ANIM_ALLFAST )
+	{
+		ent.frame = (cg.time / 100);
+		ent.renderfx|=RF_WRAP_FRAMES;
+	}
+	else
+	{
+		ent.frame = s1->frame;
+	}
+	ent.oldframe = ent.frame;
+	ent.backlerp = 0;
+/*
+Ghoul2 Insert Start
+*/
+	CG_SetGhoul2Info(&ent, cent);
+/*
+Ghoul2 Insert End
+*/
+
+	VectorCopy( cent->lerpOrigin, ent.origin);
+	VectorCopy( cent->lerpOrigin, ent.oldorigin);
+
+	ent.hModel = cgs.model_draw[s1->modelindex];
+
+	if ( !ent.radius )
+	{// Set default g2 cull radius.
+		ent.radius = 60;
+	}
+
+	if ( s1->eFlags & EF_AUTO_SIZE && cent->gent )
+	{
+		cgi_R_ModelBounds( ent.hModel, cent->gent->mins, cent->gent->maxs );
+		//Only do this once
+		cent->gent->s.eFlags &= ~EF_AUTO_SIZE;
+	}
+
+	// player model
+	if (s1->number == cg.snap->ps.clientNum) 
+	{
+		ent.renderfx |= RF_THIRD_PERSON;	// only draw from mirrors
+	}
+/*
+Ghoul2 Insert Start
+*/
+	// are we bolted to a Ghoul2 model?
+	if (s1->boltInfo)
+	{
+		G2_BoltToGhoul2Model(cent, &ent);
+	}
+	else
+	{
+		//-------------------------------------------------------
+		// Start of chair
+		//-------------------------------------------------------
+		if ( cent->gent->s.weapon == WP_EMPLACED_GUN || ( cent->gent->activator && cent->gent->activator->owner && 
+				cent->gent->activator->s.eFlags & EF_LOCKED_TO_WEAPON ))
+		{
+			vec3_t	temp;
+
+			if ( cent->gent->health <= 0 && cent->gent->e_ThinkFunc == thinkF_NULL )
+			{
+				if ( !cent->gent->bounceCount )
+				{//not an EWeb
+					ent.customShader = cgi_R_RegisterShader( "models/map_objects/imp_mine/turret_chair_dmg" );
+				}
+
+				VectorSet( temp, 0, 0, 1 );
+
+				// add a big scorch mark under the gun
+				CG_ImpactMark( cgs.media.scavMarkShader, cent->lerpOrigin, temp, 
+					0, 1,1,1, 1.0f, qfalse, 92, qtrue );
+				CG_ImpactMark( cgs.media.scavMarkShader, cent->lerpOrigin, temp, 
+					90, 1,1,1, 1.0f, qfalse, 48, qtrue );
+			}
+			else
+			{
+				VectorSet( temp, 0, 0, 1 );
+
+				if ( !( cent->gent->svFlags & SVF_INACTIVE ))
+				{
+					if ( !cent->gent->bounceCount )
+					{//not an EWeb
+						ent.customShader = cgi_R_RegisterShader( "models/map_objects/imp_mine/turret_chair_on" );
+					}
+				}
+
+				// shadow under the gun
+				CG_ImpactMark( cgs.media.shadowMarkShader, cent->lerpOrigin, temp, 
+					0, 1,1,1, 1.0f, qfalse, 32, qtrue );
+			}
+		}
+
+		if ( cent->gent->activator && cent->gent->activator->owner && 
+				cent->gent->activator->s.eFlags & EF_LOCKED_TO_WEAPON && 
+				cent->gent->activator->owner->s.number == cent->currentState.number ) // gun number must be same as current entities number
+		{
+			centity_t *cc = &cg_entities[cent->gent->activator->s.number];
+
+const weaponData_t  *wData = NULL;
+
+			if ( cc->currentState.weapon )
+			{
+				wData = &weaponData[cc->currentState.weapon];
+			}
+
+			if ( !( cc->currentState.eFlags & EF_FIRING ) && !( cc->currentState.eFlags & EF_ALT_FIRING ))
+			{
+				// not animating..pausing was leaving the barrels in a bad state
+				gi.G2API_PauseBoneAnim( &cent->gent->ghoul2[cent->gent->playerModel], "model_root", cg.time );
+
+//				gi.G2API_SetBoneAnimIndex( &cent->gent->ghoul2[cent->gent->playerModel], cent->gent->rootBone, 
+//						0, 0, BONE_ANIM_OVERRIDE, 1.0f, cg.time );
+			}
+
+			// get alternating muzzle end bolts
+			int			bolt = cent->gent->handRBolt;
+			mdxaBone_t	boltMatrix;
+
+			if ( !cc->gent->fxID || bolt == -1 )
+			{
+				bolt = cent->gent->handLBolt;
+			}
+
+			if ( bolt == -1 )
+			{
+				bolt = 0;
+			}
+			gi.G2API_GetBoltMatrix( cent->gent->ghoul2, 0, bolt, 
+				&boltMatrix, cent->lerpAngles, cent->lerpOrigin, cg.time,
+				cgs.model_draw, cent->currentState.modelScale );
+
+			// store the muzzle point and direction so that we can fire in the right direction
+			gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, cc->gent->client->renderInfo.muzzlePoint );
+			if ( cent->gent->bounceCount )
+			{//EWeb - *sigh* the muzzle tag on this is not aligned like th eone on the emplaced gun... consistency anyone...?
+				gi.G2API_GiveMeVectorFromMatrix( boltMatrix, NEGATIVE_X, cc->gent->client->renderInfo.muzzleDir );
+			}
+			else
+			{//Emplaced gun
+				gi.G2API_GiveMeVectorFromMatrix( boltMatrix, POSITIVE_Y, cc->gent->client->renderInfo.muzzleDir );
+			}
+			cc->gent->client->renderInfo.mPCalcTime = cg.time;
+
+			// HACK: adding in muzzle flashes
+			if ( cc->muzzleFlashTime > 0 && wData )
+			{
+				const char *effect = NULL;
+				cc->muzzleFlashTime = 0;
+
+				// Try and get a default muzzle so we have one to fall back on
+				if ( wData->mMuzzleEffect[0] )
+				{
+					effect = &wData->mMuzzleEffect[0];
+				}
+
+				if ( cc->currentState.eFlags & EF_ALT_FIRING )
+				{
+					// We're alt-firing, so see if we need to override with a custom alt-fire effect
+					if ( wData->mAltMuzzleEffect[0] )
+					{
+						effect = &wData->mAltMuzzleEffect[0];
+					}
+				}
+
+				if ( cc->currentState.eFlags & EF_FIRING || cc->currentState.eFlags & EF_ALT_FIRING )
+				{
+					if ( cent->gent->bounceCount )
+					{//EWeb
+						gi.G2API_SetBoneAnimIndex( &cent->gent->ghoul2[cent->gent->playerModel], cent->gent->rootBone, 
+							2, 4, BONE_ANIM_OVERRIDE_FREEZE, 0.6f, cg.time );
+					}
+					else
+					{//Emplaced Gun
+						gi.G2API_SetBoneAnimIndex( &cent->gent->ghoul2[cent->gent->playerModel], cent->gent->rootBone, 
+							0, 3, BONE_ANIM_OVERRIDE_FREEZE, 0.6f, cg.time );
+					}
+		
+					if ( effect )
+					{
+						// We got an effect and we're firing, so let 'er rip.
+						theFxScheduler.PlayEffect( effect, cc->gent->client->renderInfo.muzzlePoint, 
+													cc->gent->client->renderInfo.muzzleDir );
+					}
+				}
+			}
+
+			VectorCopy( cent->gent->s.apos.trBase, cent->lerpAngles );
+		}
+		//-------------------------------------------------------
+		// End of chair
+		//-------------------------------------------------------
+
+		AnglesToAxis( cent->lerpAngles, ent.axis );
+	}
+
+	//copy modelscale, if any
+	VectorCopy( cent->currentState.modelScale, ent.modelScale );
+	//apply modelscale, if any
+	ScaleModelAxis(&ent);
+
+	if (cent->gent->ghoul2.size())
+	{
+		//FIXME: use a flag for this, not a strcmp
+		if ( cent->gent->classname && Q_stricmp( "limb", cent->gent->classname ) == 0 )
+		{//limb, copy RGB
+			ent.shaderRGBA[0] = cent->gent->startRGBA[0];
+			ent.shaderRGBA[1] = cent->gent->startRGBA[1];
+			ent.shaderRGBA[2] = cent->gent->startRGBA[2];
+		}
+		if ( s1->weapon == WP_SABER && cent->gent && cent->gent->owner && cent->gent->owner->inuse )
+		{//flying lightsaber
+			//FIXME: better way to tell what it is would be nice
+			if ( cent->gent->classname && !Q_stricmp( "limb", cent->gent->classname ) )
+			{//limb, just add blade
+				if ( cent->gent->owner->client )
+				{
+					if ( cent->gent->owner->client->ps.saber[0].Length() > 0 )
+					{
+						CG_AddSaberBlade( &cg_entities[cent->gent->owner->s.number], 
+							&cg_entities[cent->gent->s.number], NULL, ent.renderfx, 
+							cent->gent->weaponModel[0], cent->lerpOrigin, cent->lerpAngles );
+					}
+					else if ( cent->gent->owner->client->ps.saberEventFlags & SEF_INWATER )
+					{
+						CG_CheckSaberInWater( &cg_entities[cent->gent->owner->s.number], 
+							&cg_entities[cent->gent->s.number], cent->gent->weaponModel[0], 
+							cent->lerpOrigin, cent->lerpAngles );
+					}
+				}
+			}
+			else
+			{//thrown saber
+				//light?  sound?
+				if ( cent->gent->owner->client && g_entities[cent->currentState.otherEntityNum].client && g_entities[cent->currentState.otherEntityNum].client->ps.saber[0].Active() )
+				{//saber is in-flight and active, play a sound on it
+					if ( cent->gent->owner->client->ps.saberEntityState == SES_RETURNING 
+						&& cent->gent->owner->client->ps.saber[0].type != SABER_STAR )
+					{
+						cgi_S_AddLoopingSound( cent->currentState.number, 
+							cent->lerpOrigin, vec3_origin, 
+							cgs.sound_precache[g_entities[cent->currentState.clientNum].client->ps.saber[0].soundLoop] );
+					}
+					else
+					{
+						int spinSound;
+						if ( cent->gent->owner->client->ps.saber[0].type == SABER_SITH_SWORD )
+						{
+							spinSound = cgi_S_RegisterSound( "sound/weapons/saber/saberspinoff.wav" );
+						}
+						else
+						{
+							switch ( cent->gent->owner->client->ps.forcePowerLevel[FP_SABERTHROW] )
+							{
+							case FORCE_LEVEL_1:
+								spinSound = cgi_S_RegisterSound( "sound/weapons/saber/saberspin3.wav" );
+								break;
+							case FORCE_LEVEL_2:
+								spinSound = cgi_S_RegisterSound( "sound/weapons/saber/saberspin2.wav" );
+								break;
+							default:
+							case FORCE_LEVEL_3:
+								spinSound = cgi_S_RegisterSound( "sound/weapons/saber/saberspin1.wav" );
+								break;
+							}
+						}
+						cgi_S_AddLoopingSound( cent->currentState.number, cent->lerpOrigin, 
+							vec3_origin, spinSound );
+						/*
+						if ( cg_weapons[WP_SABER].missileSound )
+						{
+							cgi_S_AddLoopingSound( cent->currentState.number, cent->lerpOrigin, vec3_origin, cg_weapons[WP_SABER].missileSound );
+						}
+						*/
+					}
+				}
+				if ( cent->gent->owner->client )
+				{
+					if ( cent->gent->owner->client->ps.saber[0].Length() > 0 )
+					{//only add the blade if it's on
+						CG_AddSaberBlade( &cg_entities[cent->gent->owner->s.number], 
+							&cg_entities[cent->gent->s.number], NULL, ent.renderfx, 
+							0, cent->lerpOrigin, cent->lerpAngles );
+					}
+					else if ( cent->gent->owner->client->ps.saberEventFlags & SEF_INWATER )
+					{
+						CG_CheckSaberInWater( &cg_entities[cent->gent->owner->s.number], 
+							&cg_entities[cent->gent->s.number], 0, cent->lerpOrigin, 
+							cent->lerpAngles );
+					}
+				}
+				if ( cent->gent->owner->health )
+				{
+					//make sure we can always be seen
+					ent.renderfx |= RF_PULSATE;
+				}
+			}
+		}
+	}
+	else
+	{
+		if ( s1->weapon == WP_SABER && cent->gent && cent->gent->owner )
+		{//flying lightsaber
+			//light?  sound?
+			if ( cent->gent->owner->client && cent->currentState.saberActive )
+			{//saber is in-flight and active, play a sound on it
+				if ( cent->gent->owner->client->ps.saberEntityState == SES_RETURNING 
+					&& cent->gent->owner->client->ps.saber[0].type != SABER_STAR )
+				{
+					if ( cg_weapons[WP_SABER].firingSound )
+					{
+						cgi_S_AddLoopingSound( cent->currentState.number, 
+							cent->lerpOrigin, vec3_origin, cg_weapons[WP_SABER].firingSound );
+					}
+				}
+				else
+				{
+					int spinSound;
+					if ( cent->gent->owner->client->ps.saber[0].type == SABER_SITH_SWORD )
+					{
+						spinSound = cgi_S_RegisterSound( "sound/weapons/saber/saberspinoff.wav" );
+					}
+					else
+					{
+						switch ( cent->gent->owner->client->ps.forcePowerLevel[FP_SABERTHROW] )
+						{
+						case FORCE_LEVEL_1:
+							spinSound = cgi_S_RegisterSound( "sound/weapons/saber/saberspin3.wav" );
+							break;
+						case FORCE_LEVEL_2:
+							spinSound = cgi_S_RegisterSound( "sound/weapons/saber/saberspin2.wav" );
+							break;
+						default:
+						case FORCE_LEVEL_3:
+							spinSound = cgi_S_RegisterSound( "sound/weapons/saber/saberspin1.wav" );
+							break;
+						}
+					}
+					cgi_S_AddLoopingSound( cent->currentState.number, cent->lerpOrigin, 
+						vec3_origin, spinSound );
+					/*
+					if ( cg_weapons[WP_SABER].missileSound )
+					{
+						cgi_S_AddLoopingSound( cent->currentState.number, cent->lerpOrigin, vec3_origin, cg_weapons[WP_SABER].missileSound );
+					}
+					*/
+				}
+			}
+			CG_AddSaberBlade( &cg_entities[cent->gent->owner->s.number], 
+				NULL, &ent, ent.renderfx, 0, NULL, NULL );
+
+			if ( cent->gent->owner->health )
+			{
+				//make sure we can always be seen
+				ent.renderfx |= RF_PULSATE;
+			}
+		}
+	}
+/*
+Ghoul2 Insert End
+*/
+
+	if ( cent->gent && cent->gent->forcePushTime > cg.time )
+	{//FIXME: if I'm a rather large model, this will look kind of stupid...
+		CG_ForcePushBlur( cent->lerpOrigin );
+	}
+	CG_AddRefEntWithTransportEffect( cent, &ent );
+
+	if ( cent->gent->health <= 0 
+		&& cent->gent->s.weapon == WP_EMPLACED_GUN 
+		&& cent->gent->e_ThinkFunc )
+	{
+		// make the gun pulse red to warn about it exploding
+		float val = (1.0f - (float)(cent->gent->nextthink - cg.time) / 3200.0f ) * 0.3f;
+
+		ent.customShader = cgi_R_RegisterShader( "gfx/effects/solidWhite" );
+		ent.shaderRGBA[0] = (sin( cg.time * 0.04f ) * val * 0.4f + val) * 255;
+		ent.shaderRGBA[1] = ent.shaderRGBA[2] = 0;
+		ent.renderfx |= RF_RGB_TINT;
+		cgi_R_AddRefEntityToScene( &ent );
+	}
+
+	//--------------------------
+	if ( s1->eFlags & EF_FIRING && cent->gent->inuse )
+	{
+		//special code for adding the beam to the attached tripwire mine
+		vec3_t			beamOrg;
+		int				handle = 0;
+		SEffectTemplate	*temp;
+
+		VectorMA( ent.origin, 6.6f, ent.axis[0], beamOrg );// forward
+
+		// overriding the effect, so give us a copy first
+		temp = theFxScheduler.GetEffectCopy( "tripMine/laser", &handle );	
+
+		if ( temp )
+		{
+			// have a copy, so get the line element out of there
+			CPrimitiveTemplate *prim = theFxScheduler.GetPrimitiveCopy( temp, "line1" );
+
+			if ( prim )
+			{
+				// we have the primitive, so modify the endpoint
+				prim->mOrigin2X.SetRange( cent->gent->pos4[0], cent->gent->pos4[0] );
+				prim->mOrigin2Y.SetRange( cent->gent->pos4[1], cent->gent->pos4[1] );
+				prim->mOrigin2Z.SetRange( cent->gent->pos4[2], cent->gent->pos4[2] );
+
+				// have a copy, so get the line element out of there
+				CPrimitiveTemplate *prim = theFxScheduler.GetPrimitiveCopy( temp, "line2" );
+
+				if ( prim )
+				{
+					// we have the primitive, so modify the cent->gent->pos3point
+					prim->mOrigin2X.SetRange( cent->gent->pos4[0], cent->gent->pos4[0] );
+					prim->mOrigin2Y.SetRange( cent->gent->pos4[1], cent->gent->pos4[1] );
+					prim->mOrigin2Z.SetRange( cent->gent->pos4[2], cent->gent->pos4[2] );
+
+					// play the modified effect
+					theFxScheduler.PlayEffect( handle, beamOrg, ent.axis[0] );
+				}
+			}
+		}
+
+		theFxScheduler.PlayEffect( "tripMine/laserImpactGlow", cent->gent->pos4, ent.axis[0] );
+	}
+
+
+	if ( s1->eFlags & EF_PROX_TRIP )
+	{
+		//special code for adding the glow end to proximity tripmine
+		vec3_t	beamOrg;
+
+		VectorMA( ent.origin, 6.6f, ent.axis[0], beamOrg );// forward
+		theFxScheduler.PlayEffect( "tripMine/glowBit", beamOrg, ent.axis[0] );
+	}
+
+	if ( s1->eFlags & EF_ALT_FIRING )
+	{
+		// hack for the spotlight
+		vec3_t	org, axis[3], dir;
+
+		AngleVectors( cent->lerpAngles, dir, NULL, NULL );
+
+		CG_GetTagWorldPosition( &ent, "tag_flash", org, axis );
+
+		theFxScheduler.PlayEffect( "env/light_cone", org, axis[0] );
+
+		VectorMA( cent->lerpOrigin, cent->gent->radius - 5, dir, org ); // stay a bit back from the impact point...this may not be enough?
+
+		cgi_R_AddLightToScene( org, 225, 1.0f, 1.0f, 1.0f );
+	}
+
+	//-----------------------------------------------------------
+	if ( cent->gent->flags & (FL_DMG_BY_HEAVY_WEAP_ONLY | FL_SHIELDED ))
+	{
+		// Dumb assumption, but I guess we must be a shielded ion_cannon??  We should probably verify
+		// if it's an ion_cannon that's Heavy Weapon only, we don't want to make it shielded do we...?
+		if ( (!strcmp( "misc_ion_cannon", cent->gent->classname )) && (cent->gent->flags & FL_SHIELDED ))
+		{
+			// must be doing "pain"....er, impact
+			if ( cent->gent->painDebounceTime > cg.time )
+			{
+				float t = (float)(cent->gent->painDebounceTime - cg.time ) / 1000.0f;
+
+				// Only display when we have damage
+				if ( t >= 0.0f && t <= 1.0f ) 
+				{
+					t *= random();
+
+					ent.shaderRGBA[0] = ent.shaderRGBA[1] = ent.shaderRGBA[2] = 255.0f * t;
+					ent.shaderRGBA[3] = 255;
+					ent.renderfx &= ~RF_ALPHA_FADE;
+					ent.renderfx |= RF_RGB_TINT;
+					ent.customShader = cgi_R_RegisterShader( "gfx/misc/ion_shield" );
+				
+					cgi_R_AddRefEntityToScene( &ent );
+				}
+			}
+		}
+	}
+
+	//draw force sight shell around it, too
+	if ((cg.snap->ps.forcePowersActive & (1 << FP_SEE)) 
+		&& cg.snap->ps.clientNum != cent->currentState.number 
+		&& CG_PlayerCanSeeCent( cent ) )
+	{//so player can see dark missiles/explosives
+		if ( s1->weapon == WP_THERMAL
+			|| s1->weapon == WP_DET_PACK
+			|| s1->weapon == WP_TRIP_MINE
+			|| (cent->gent&&cent->gent->e_UseFunc==useF_ammo_power_converter_use)
+			|| (cent->gent&&cent->gent->e_UseFunc==useF_shield_power_converter_use)
+			|| (s1->eFlags&EF_FORCE_VISIBLE) )
+		{//really, we only need to do this for things like thermals, detpacks and tripmines, no?
+			CG_AddForceSightShell( &ent, cent );
+		}
+	}
+}
+
+/*
+==================
+CG_Speaker
+
+Speaker entities can automatically play sounds
+==================
+*/
+static void CG_Speaker( centity_t *cent ) {
+	if ( ! cent->currentState.clientNum ) {	// FIXME: use something other than clientNum...
+		return;		// not auto triggering
+	}
+
+	if ( cg.time < cent->miscTime ) {
+		return;
+	}
+
+	cgi_S_StartSound (NULL, cent->currentState.number, CHAN_ITEM, cgs.sound_precache[cent->currentState.eventParm] );
+
+	//	ent->s.frame = ent->wait * 10;
+	//	ent->s.clientNum = ent->random * 10;
+	cent->miscTime = (int)(cg.time + cent->currentState.frame * 100 + cent->currentState.clientNum * 100 * crandom());
+}
+
+/*
+==================
+CG_Item
+==================
+*/
+static void CG_Item( centity_t *cent ) 
+{
+	refEntity_t			ent;
+	entityState_t		*es;
+	gitem_t				*item;
+//	int					msec;
+//	float				frac;
+	float				scale;
+
+	es = &cent->currentState;
+	if ( es->modelindex >= bg_numItems ) 
+	{
+		CG_Error( "Bad item index %i on entity", es->modelindex );
+	}
+/*
+Ghoul2 Insert Start
+*/
+
+	// if set to invisible, skip
+	if ( (!es->modelindex && !cent->gent->ghoul2.IsValid() ) || ( es->eFlags & EF_NODRAW ) ) 
+	{
+		return;
+	}
+/*
+Ghoul2 Insert End
+*/
+	if ( cent->gent && !cent->gent->inuse )
+	{
+		// Yeah, I know....items were being freed on touch, but it could still get here and draw incorrectly...
+		return;
+	}
+
+	item = &bg_itemlist[ es->modelindex ];
+
+	if ( cg_simpleItems.integer ) 
+	{
+		memset( &ent, 0, sizeof( ent ) );
+		ent.reType = RT_SPRITE;
+		VectorCopy( cent->lerpOrigin, ent.origin );
+		ent.radius = 14;
+		ent.customShader = cg_items[es->modelindex].icon;
+		ent.shaderRGBA[0] = 255;
+		ent.shaderRGBA[1] = 255;
+		ent.shaderRGBA[2] = 255;
+		ent.shaderRGBA[3] = 255;
+		cgi_R_AddRefEntityToScene(&ent);
+		return;
+	}
+
+	memset (&ent, 0, sizeof(ent));
+
+	// items bob up and down continuously
+	if( item->giType == IT_HOLOCRON )
+	{
+		scale = 0.005f + cent->currentState.number * 0.00001f;
+		cent->lerpOrigin[2] += (float)(4 + cos( ( cg.time + 1000 ) *  scale ) * 3)+8; // just raised them up a bit
+	}
+
+
+
+	// autorotate at one of two speeds
+//	if ( item->giType == IT_HEALTH ) {
+//		VectorCopy( cg.autoAnglesFast, cent->lerpAngles );
+//		AxisCopy( cg.autoAxisFast, ent.axis );
+//	} else {
+	if( item->giType == IT_HOLOCRON )
+	{
+		VectorCopy( cg.autoAngles, cent->lerpAngles );
+		AxisCopy( cg.autoAxis, ent.axis );
+	}
+
+
+	// the weapons have their origin where they attatch to player
+	// models, so we need to offset them or they will rotate
+	// eccentricly
+//	if ( item->giType == IT_WEAPON ) {
+//		weaponInfo_t	*wi;
+//
+//		wi = &cg_weapons[item->giTag];
+//		cent->lerpOrigin[0] -= 
+//			wi->weaponMidpoint[0] * ent.axis[0][0] +
+//			wi->weaponMidpoint[1] * ent.axis[1][0] +
+//			wi->weaponMidpoint[2] * ent.axis[2][0];
+//		cent->lerpOrigin[1] -= 
+//			wi->weaponMidpoint[0] * ent.axis[0][1] +
+//			wi->weaponMidpoint[1] * ent.axis[1][1] +
+//			wi->weaponMidpoint[2] * ent.axis[2][1];
+//		cent->lerpOrigin[2] -= 
+//			wi->weaponMidpoint[0] * ent.axis[0][2] +
+//			wi->weaponMidpoint[1] * ent.axis[1][2] +
+//			wi->weaponMidpoint[2] * ent.axis[2][2];
+
+//		cent->lerpOrigin[2] += 8;	// an extra height boost
+//	}
+	vec3_t spinAngles;
+
+	//AxisClear( ent.axis );
+	VectorCopy( cent->gent->s.angles, spinAngles );
+
+	if ( cent->gent->ghoul2.IsValid()
+		&& cent->gent->ghoul2.size() )
+	{//since modelindex is used by items as an index into items(not models), we need to ignore the hModel here to force it to use the ghoul2 model if we have one
+		ent.hModel = cgs.model_draw[0];
+	}
+	else
+	{
+		ent.hModel = cg_items[es->modelindex].models;
+	}
+/*
+Ghoul2 Insert Start
+*/
+	CG_SetGhoul2Info(&ent, cent);  
+/*
+Ghoul2 Insert End
+*/
+
+	VectorCopy( cent->lerpOrigin, ent.origin);
+	VectorCopy( cent->lerpOrigin, ent.oldorigin);
+
+	ent.nonNormalizedAxes = qfalse;
+
+	// lovely...this is for weapons that should be oriented vertically.  For weapons lockers and such.
+	if ( cent->gent->spawnflags & 16 )
+	{	//VectorClear( spinAngles );
+		spinAngles[PITCH] -= 75;
+	}
+	
+	if( item->giType != IT_HOLOCRON )
+	{
+		AnglesToAxis( spinAngles, ent.axis );
+	}
+
+	// items without glow textures need to keep a minimum light value
+	// so they are always visible
+/*	if (( item->giType == IT_WEAPON ) || ( item->giType == IT_ARMOR )) 
+	{
+		ent.renderfx |= RF_MINLIGHT;
+	}
+*/
+	// increase the size of the weapons when they are presented as items
+//	if ( item->giType == IT_WEAPON ) {
+//		VectorScale( ent.axis[0], 1.5f, ent.axis[0] );
+//		VectorScale( ent.axis[1], 1.5f, ent.axis[1] );
+//		VectorScale( ent.axis[2], 1.5f, ent.axis[2] );
+//		ent.nonNormalizedAxes = qtrue;
+//	}
+
+	// add to refresh list
+	cgi_R_AddRefEntityToScene(&ent);
+
+	if ((cg.snap->ps.forcePowersActive & (1 << FP_SEE)) 
+		&& cg.snap->ps.clientNum != cent->currentState.number 
+		&& CG_PlayerCanSeeCent( cent ) )
+	{
+		CG_AddForceSightShell( &ent, cent );
+	}
+
+	if ( item->giType == IT_WEAPON 
+		&& item->giTag == WP_SABER 
+		&& (!cent->gent || !(cent->gent->spawnflags&64/*ITMSF_NOGLOW*/)) )
+	{
+		// saber pickup item needs to be more visible
+		float	wv;
+		vec3_t	org;
+
+		ent.customShader = cgi_R_RegisterShader( "gfx/effects/solidWhite_cull" );
+		ent.renderfx = RF_RGB_TINT;
+		wv = sin( cg.time * 0.002f ) * 0.08f + 0.2f;
+		ent.shaderRGBA[0] = ent.shaderRGBA[1] = wv * 255;
+		ent.shaderRGBA[2] = 0;
+		cgi_R_AddRefEntityToScene(&ent);
+
+		for ( int i = -4; i < 10; i += 1 )
+		{
+			VectorMA( ent.origin, -i, ent.axis[2], org );
+
+			FX_AddSprite( org, NULL, NULL, 10.0f, 10.0f, wv * 0.5f, wv * 0.5f, 0.0f, 0.0f, 1.0f, cgs.media.yellowDroppedSaberShader, 0x08000000 );
+		}
+
+		// THIS light looks crappy...maybe it should just be removed...
+		cgi_R_AddLightToScene( ent.origin, wv * 350 + 180, 1.0f, 1.0f, 0.0f );
+	}
+}
+
+//============================================================================
+
+/*
+===============
+CG_Missile
+===============
+*/
+static void CG_Missile( centity_t *cent ) {
+	refEntity_t			ent;
+	entityState_t		*s1;
+	const weaponInfo_t	*weapon;
+	const weaponData_t  *wData;
+
+	if ( !cent->gent->inuse )
+		return;
+
+	s1 = &cent->currentState;
+	if ( s1->weapon >= WP_NUM_WEAPONS ) {
+		s1->weapon = 0;
+	}
+	weapon = &cg_weapons[s1->weapon];
+	wData = &weaponData[s1->weapon];
+
+	if ( s1->pos.trType != TR_INTERPOLATE )
+	{
+		// calculate the axis
+		VectorCopy( s1->angles, cent->lerpAngles );
+	}
+
+	if ( cent->gent->alt_fire )
+	{
+		// add trails
+		if ( weapon->alt_missileTrailFunc )  
+			weapon->alt_missileTrailFunc( cent, weapon );
+
+		// add dynamic light
+		if ( wData->alt_missileDlight )
+				cgi_R_AddLightToScene(cent->lerpOrigin, wData->alt_missileDlight, 
+					wData->alt_missileDlightColor[0], wData->alt_missileDlightColor[1], wData->alt_missileDlightColor[2] );
+
+		// add missile sound
+		if ( weapon->alt_missileSound )
+			cgi_S_AddLoopingSound( cent->currentState.number, cent->lerpOrigin, vec3_origin, weapon->alt_missileSound );
+
+		//Don't draw something without a model
+		if ( weapon->alt_missileModel == NULL )
+			return;
+	}
+	else
+	{
+		// add trails
+		if ( weapon->missileTrailFunc )  
+			weapon->missileTrailFunc( cent, weapon );
+
+		// add dynamic light
+		if ( wData->missileDlight )
+			cgi_R_AddLightToScene(cent->lerpOrigin, wData->missileDlight, 
+				wData->missileDlightColor[0], wData->missileDlightColor[1], wData->missileDlightColor[2] );
+
+		// add missile sound
+		if ( weapon->missileSound )
+			cgi_S_AddLoopingSound( cent->currentState.number, cent->lerpOrigin, vec3_origin, weapon->missileSound );
+
+		//Don't draw something without a model
+		if ( weapon->missileModel == NULL )
+			return;
+	}
+
+	// create the render entity
+	memset (&ent, 0, sizeof(ent));
+	VectorCopy( cent->lerpOrigin, ent.origin);
+	VectorCopy( cent->lerpOrigin, ent.oldorigin);
+/*
+Ghoul2 Insert Start
+*/
+	CG_SetGhoul2Info(&ent, cent);  
+
+/*
+Ghoul2 Insert End
+*/
+
+	// flicker between two skins
+	ent.skinNum = cg.clientFrame & 1;
+	ent.renderfx = /*weapon->missileRenderfx | */RF_NOSHADOW;
+
+	if ( cent->gent->alt_fire )
+		ent.hModel = weapon->alt_missileModel;
+	else
+		ent.hModel = weapon->missileModel;
+
+	// spin as it moves
+	if ( s1->apos.trType != TR_INTERPOLATE)
+	{
+
+		// convert direction of travel into axis
+		if ( VectorNormalize2( s1->pos.trDelta, ent.axis[0] ) == 0 ) {
+			ent.axis[0][2] = 1;
+		}
+		if ( s1->pos.trType != TR_STATIONARY )
+		{
+			if ( s1->eFlags & EF_MISSILE_STICK )
+				RotateAroundDirection( ent.axis, cg.time * 0.5f );//Did this so regular missiles don't get broken
+			else
+				RotateAroundDirection( ent.axis, cg.time * 0.25f );//JFM:FLOAT FIX
+		}
+		else
+		{
+			if ( s1->eFlags & EF_MISSILE_STICK )
+				RotateAroundDirection( ent.axis, (float)s1->pos.trTime * 0.5f );
+			else
+				RotateAroundDirection( ent.axis, (float)s1->time );
+		}
+	}
+	else
+	{
+		AnglesToAxis( cent->lerpAngles, ent.axis );
+	}
+
+	// add to refresh list, possibly with quad glow
+	CG_AddRefEntityWithPowerups( &ent, s1->powerups, NULL );
+
+	if ((cg.snap->ps.forcePowersActive & (1 << FP_SEE)) 
+		&& cg.snap->ps.clientNum != cent->currentState.number 
+		&& CG_PlayerCanSeeCent( cent ) )
+	{//so player can see dark missiles/explosives
+		if ( s1->weapon == WP_THERMAL
+			|| s1->weapon == WP_DET_PACK
+			|| s1->weapon == WP_TRIP_MINE
+			|| (s1->eFlags&EF_FORCE_VISIBLE) )
+		{//really, we only need to do this for things like thermals, detpacks and tripmines, no?
+			CG_AddForceSightShell( &ent, cent );
+		}
+	}
+}
+
+/*
+===============
+CG_Mover
+===============
+*/
+
+#define DOOR_OPENING	1
+#define DOOR_CLOSING	2
+#define DOOR_OPEN		3
+#define DOOR_CLOSED		4
+
+static void CG_Mover( centity_t *cent ) {
+	refEntity_t			ent;
+	entityState_t		*s1;
+
+	s1 = &cent->currentState;
+
+	// create the render entity
+	memset (&ent, 0, sizeof(ent));
+	//FIXME: why are these always 0, 0, 0???!
+	VectorCopy( cent->lerpOrigin, ent.origin);
+	VectorCopy( cent->lerpOrigin, ent.oldorigin);
+	AnglesToAxis( cent->lerpAngles, ent.axis );
+/*
+Ghoul2 Insert Start
+*/
+
+	CG_SetGhoul2Info(&ent, cent);  
+/*
+Ghoul2 Insert End
+*/
+
+	ent.renderfx = RF_NOSHADOW;
+
+	// flicker between two skins (FIXME?)
+	ent.skinNum = ( cg.time >> 6 ) & 1;
+
+	// get the model, either as a bmodel or a modelindex
+	if ( s1->solid == SOLID_BMODEL ) {
+		ent.hModel = cgs.inlineDrawModel[s1->modelindex];
+	} else {
+		ent.hModel = cgs.model_draw[s1->modelindex];
+	}
+
+	// If there isn't an hModel for this mover, an RGB axis model will get drawn.
+	if ( !ent.hModel )
+	{
+		return;
+	}
+
+	if ( cent->currentState.eFlags & EF_DISABLE_SHADER_ANIM )
+	{
+		// by setting the shader time to the current time, we can force an animating shader to not animate
+		ent.shaderTime = cg.time * 0.001f;
+	}
+
+	// add the secondary model
+	if ( s1->solid == SOLID_BMODEL && s1->modelindex2 ) 
+	{
+//		vec3_t	org;
+		if ( !(s1->eFlags & EF_NODRAW) )
+		{
+			// add to refresh list
+			CG_AddRefEntWithTransportEffect( cent, &ent );
+		}
+
+/*		// Um, this does not interpolate nicely?  Not sure why it was here....
+		VectorAdd(cent->gent->absmin, cent->gent->absmax, org);
+		VectorScale(org, 0.5, org);
+		VectorCopy( org, ent.origin);
+		VectorCopy( org, ent.oldorigin);
+*/
+		if ( !VectorCompare( vec3_origin, cent->gent->modelAngles ) )
+		{//we have a rotational offset for the model for this brush
+			vec3_t modelAngles;
+			VectorAdd( cent->lerpAngles, cent->gent->modelAngles, modelAngles );
+			AnglesToAxis( modelAngles, ent.axis );
+		}
+		ent.hModel = cgs.model_draw[s1->modelindex2];
+	}
+
+	// I changed it to always do it because nodraw seemed like it should actually do what it says. Be aware that if you change this,
+	//	the movers for the shooting gallery on doom_detention will break.
+	if ( (s1->eFlags & EF_NODRAW) )
+	{
+		return;
+	}
+	//fall through and render the hModel or...
+
+	//We're a normal model being moved, animate our model
+	ent.skinNum = 0;
+	if ( s1->eFlags & EF_ANIM_ONCE )
+	{//FIXME: needs to anim at once per 100 ms
+		ent.frame = cent->gent->s.frame;
+		ent.renderfx|=RF_CAP_FRAMES;
+	}
+	else if ( s1->eFlags & EF_ANIM_ALLFAST )
+	{
+		ent.frame = (cg.time / 100);
+		ent.renderfx|=RF_WRAP_FRAMES;
+	}
+	else
+	{
+		ent.frame = s1->frame;
+	}
+
+	if ( s1->eFlags & EF_SHADER_ANIM )
+	{
+		ent.renderfx|=RF_SETANIMINDEX;
+		ent.skinNum = s1->frame;
+		//ent.shaderTime = cg.time*0.001f - s1->frame/s1->time;//NOTE: s1->time is number of frames
+	}
+
+	// add to refresh list
+	CG_AddRefEntWithTransportEffect( cent, &ent );
+
+	if ((cg.snap->ps.forcePowersActive & (1 << FP_SEE)) 
+		&& cg.snap->ps.clientNum != cent->currentState.number 
+		&& (s1->eFlags&EF_FORCE_VISIBLE) )
+	{//so player can see func_breakables
+		CG_AddForceSightShell( &ent, cent );
+	}
+}
+
+/*
+===============
+CG_Beam
+
+Also called as an event
+===============
+*/
+void CG_Beam( centity_t *cent, int color ) {
+	refEntity_t			ent;
+	entityState_t		*s1;
+
+	s1 = &cent->currentState;
+
+	// create the render entity
+	memset (&ent, 0, sizeof(ent));
+	VectorCopy( s1->pos.trBase, ent.origin );
+	VectorCopy( s1->origin2, ent.oldorigin );
+	AxisClear( ent.axis );
+	ent.reType = RT_BEAM;
+	ent.skinNum = color;
+
+	ent.renderfx = RF_NOSHADOW;
+/*
+Ghoul2 Insert Start
+*/
+	CG_SetGhoul2Info(&ent, cent);  
+
+/*
+Ghoul2 Insert End
+*/
+
+	// add to refresh list
+	cgi_R_AddRefEntityToScene(&ent);
+}
+
+/*
+===============
+CG_Cylinder
+===============
+*/
+void CG_Cylinder( vec3_t start, vec3_t end, float radius, vec3_t color ) 
+{
+	vec3_t	dir;
+	float	length;
+
+	VectorSubtract( end, start, dir );
+	length = VectorNormalize( dir );
+
+/*	FX_AddCylinder( -1, start, 
+					dir, 
+					length, 
+					0.0f, 
+					radius,
+					0.0f,
+					radius,
+					0.0f,
+					1.0f,
+					1.0f,
+					color,
+					color,
+					100.0f,
+					cgs.media.waterDropShader
+					0, -1, -1 );*/
+}
+
+static vec2_t st[] = 
+{
+	0.0f, 0.0f,
+	1.0f, 0.0f,
+	1.0f, 1.0f,
+	0.0f, 1.0f
+};
+
+void CG_Cube( vec3_t mins, vec3_t maxs, vec3_t color, float alpha ) 
+{
+	vec3_t	point[4], rot={0,0,0};
+	vec2_t	st[4];
+	int		vec[3];
+	int		axis, i;
+
+	for ( axis = 0, vec[0] = 0, vec[1] = 1, vec[2] = 2; axis < 3; axis++, vec[0]++, vec[1]++, vec[2]++ )
+	{
+		for ( i = 0; i < 3; i++ )
+		{
+			if ( vec[i] > 2 )
+			{
+				vec[i] = 0;
+			}
+		}
+
+		point[0][vec[1]] = mins[vec[1]];
+		point[0][vec[2]] = mins[vec[2]];
+
+		point[1][vec[1]] = mins[vec[1]];
+		point[1][vec[2]] = maxs[vec[2]];
+
+		point[2][vec[1]] = maxs[vec[1]];
+		point[2][vec[2]] = maxs[vec[2]];
+		
+		point[3][vec[1]] = maxs[vec[1]];
+		point[3][vec[2]] = mins[vec[2]];
+
+		//- face
+		point[0][vec[0]] = point[1][vec[0]] = point[2][vec[0]] = point[3][vec[0]] = mins[vec[0]];
+
+		FX_AddPoly( point, st, 4, NULL, NULL, alpha, alpha, 0.0f, 
+						color, color, 0.0f, rot, 0.0f, 0.0f, 
+						100, cgs.media.solidWhiteShader, 0 );
+
+		//+ face
+		point[0][vec[0]] = point[1][vec[0]] = point[2][vec[0]] = point[3][vec[0]] = maxs[vec[0]];
+
+		FX_AddPoly( point, st, 4, NULL, NULL, alpha, alpha, 0.0f, 
+						color, color, 0.0f, rot, 0.0f, 0.0f, 
+						100, cgs.media.solidWhiteShader, 0 );
+	}
+}
+
+void CG_CubeOutline( vec3_t mins, vec3_t maxs, int time, unsigned int color, float alpha )
+{
+	vec3_t	point1, point2, point3, point4;
+	int		vec[3];
+	int		axis, i;
+
+	for ( axis = 0, vec[0] = 0, vec[1] = 1, vec[2] = 2; axis < 3; axis++, vec[0]++, vec[1]++, vec[2]++ )
+	{
+		for ( i = 0; i < 3; i++ )
+		{
+			if ( vec[i] > 2 )
+			{
+				vec[i] = 0;
+			}
+		}
+
+		point1[vec[1]] = mins[vec[1]];
+		point1[vec[2]] = mins[vec[2]];
+
+		point2[vec[1]] = mins[vec[1]];
+		point2[vec[2]] = maxs[vec[2]];
+
+		point3[vec[1]] = maxs[vec[1]];
+		point3[vec[2]] = maxs[vec[2]];
+		
+		point4[vec[1]] = maxs[vec[1]];
+		point4[vec[2]] = mins[vec[2]];
+
+		//- face
+		point1[vec[0]] = point2[vec[0]] = point3[vec[0]] = point4[vec[0]] = mins[vec[0]];
+
+		CG_TestLine( point1, point2, time, color, 1 );
+		CG_TestLine( point2, point3, time, color, 1 );
+		CG_TestLine( point1, point4, time, color, 1 );
+		CG_TestLine( point4, point3, time, color, 1 );
+
+		//+ face
+		point1[vec[0]] = point2[vec[0]] = point3[vec[0]] = point4[vec[0]] = maxs[vec[0]];
+
+		CG_TestLine( point1, point2, time, color, 1 );
+		CG_TestLine( point2, point3, time, color, 1 );
+		CG_TestLine( point1, point4, time, color, 1 );
+		CG_TestLine( point4, point1, time, color, 1 );
+	}
+}
+
+void CG_Line( vec3_t start, vec3_t end, vec3_t color, float alpha ) 
+{
+	/*FX_AddLine( start,
+				end,
+				1.0f,
+				1.0,
+				1.0f,
+				alpha,
+				alpha,
+				color, 
+				color, 
+				100.0f,
+				cgs.media.whiteShader );*/
+}
+
+/*
+===============
+CG_Portal
+===============
+*/
+static void CG_Portal( centity_t *cent ) {
+	refEntity_t			ent;
+	entityState_t		*s1;
+
+	s1 = &cent->currentState;
+
+	//FIXME: this tends to give a bad axis[1], perhaps we
+	//should just do the VectorSubtraction here rather than
+	//on the game side.  Would also allow camera to follow
+	//a moving target.
+
+	// create the render entity
+	memset (&ent, 0, sizeof(ent));
+	VectorCopy( cent->lerpOrigin, ent.origin );
+	VectorCopy( s1->origin2, ent.oldorigin );
+	ByteToDir( s1->eventParm, ent.axis[0] );
+	PerpendicularVector( ent.axis[1], ent.axis[0] );
+
+	// negating this tends to get the directions like they want
+	// we really should have a camera roll value
+	VectorSubtract( vec3_origin, ent.axis[1], ent.axis[1] );
+
+	CrossProduct( ent.axis[0], ent.axis[1], ent.axis[2] );
+	ent.reType = RT_PORTALSURFACE;
+	ent.frame = s1->frame;		// rotation speed
+	ent.skinNum = (int)(s1->clientNum/256.0 * 360);	// roll offset
+
+/*
+Ghoul2 Insert Start
+*/
+	CG_SetGhoul2Info(&ent, cent);  
+/*
+Ghoul2 Insert End
+*/
+
+
+	// add to refresh list
+	cgi_R_AddRefEntityToScene(&ent);
+}
+
+
+/*
+=========================
+CG_AdjustPositionForMover
+
+Also called by client movement prediction code
+=========================
+*/
+void CG_AdjustPositionForMover( const vec3_t in, int moverNum, int atTime, vec3_t out ) {
+	centity_t	*cent;
+	vec3_t	oldOrigin, origin, deltaOrigin;
+//	vec3_t	oldAngles, angles, deltaAngles;
+
+	if ( moverNum <= 0 ) {
+		VectorCopy( in, out );
+		return;
+	}
+
+	cent = &cg_entities[ moverNum ];
+	if ( cent->currentState.eType != ET_MOVER ) {
+		VectorCopy( in, out );
+		return;
+	}
+
+	EvaluateTrajectory( &cent->currentState.pos, cg.snap->serverTime, oldOrigin );
+//	EvaluateTrajectory( &cent->currentState.apos, cg.snap->serverTime, oldAngles );
+
+	EvaluateTrajectory( &cent->currentState.pos, atTime, origin );
+//	EvaluateTrajectory( &cent->currentState.apos, atTime, angles );
+
+	VectorSubtract( origin, oldOrigin, deltaOrigin );
+//	VectorSubtract( angles, oldAngles, deltaAngles );
+
+
+	VectorAdd( in, deltaOrigin, out );
+
+	// FIXME: origin change when on a rotating object
+}
+/*
+===============
+CG_CalcEntityLerpPositions
+
+===============
+*/
+extern char	*vtos( const vec3_t v );
+#if 1
+void CG_CalcEntityLerpPositions( centity_t *cent ) {
+	if ( cent->gent && cent->gent->client && cent->gent->client->NPC_class == CLASS_VEHICLE && cent->nextState ) //cent->currentState.vehicleIndex != VEHICLE_NONE )
+	{
+		float		f = cg.frameInterpolation;
+
+		cent->currentState.vehicleAngles[0] = LerpAngle( cent->currentState.vehicleAngles[0], cent->nextState->vehicleAngles[0], f );
+		cent->currentState.vehicleAngles[1] = LerpAngle( cent->currentState.vehicleAngles[1], cent->nextState->vehicleAngles[1], f );
+		cent->currentState.vehicleAngles[2] = LerpAngle( cent->currentState.vehicleAngles[2], cent->nextState->vehicleAngles[2], f );
+	}
+
+	if ( cent->currentState.number == cg.snap->ps.clientNum)
+	{
+		// if the player, take position from prediction
+		VectorCopy( cg.predicted_player_state.origin, cent->lerpOrigin );
+		VectorCopy( cg.predicted_player_state.viewangles, cent->lerpAngles );
+/*
+Ghoul2 Insert Start
+*/
+//		LerpBoneAngleOverrides(cent);
+/*
+Ghoul2 Insert End
+*/
+		return;
+	}
+	
+	//FIXME: prediction on clients in timescale results in jerky positional translation
+	if ( cent->interpolate )
+	{
+		// if the entity has a valid next state, interpolate a value between the frames
+		// unless it is a mover with a known start and stop
+		vec3_t		current, next;
+		float		f;
+
+		// it would be an internal error to find an entity that interpolates without
+		// a snapshot ahead of the current one
+		if ( cg.nextSnap == NULL ) {
+			CG_Error( "CG_AddCEntity: cg.nextSnap == NULL" );
+		}
+
+		f = cg.frameInterpolation;
+
+		if ( cent->currentState.apos.trType == TR_INTERPOLATE && cent->nextState )
+		{
+			EvaluateTrajectory( &cent->currentState.apos, cg.snap->serverTime, current );
+			EvaluateTrajectory( &cent->nextState->apos, cg.nextSnap->serverTime, next );
+
+			cent->lerpAngles[0] = LerpAngle( current[0], next[0], f );
+			cent->lerpAngles[1] = LerpAngle( current[1], next[1], f );
+			cent->lerpAngles[2] = LerpAngle( current[2], next[2], f );
+
+			/*
+			if(cent->gent && cent->currentState.clientNum != 0 && !VectorCompare(current, next))
+			{
+				Com_Printf("%s last/next/lerp apos %s/%s/%s, f = %4.2f\n", cent->gent->script_targetname, vtos(current), vtos(next), vtos(cent->lerpAngles), f);
+			}
+			*/
+	/*
+	Ghoul2 Insert Start
+	*/
+			// now the nasty stuff - this will interpolate all ghoul2 models bone angle overrides per model attached to this cent
+			/*
+			if (cent->gent->ghoul2.size())
+			{
+				LerpBoneAngleOverrides(cent);
+			}
+			*/
+	/*
+	Ghoul2 Insert End
+	*/
+		}
+		if ( cent->currentState.pos.trType == TR_INTERPOLATE && cent->nextState ) 
+		{
+			// this will linearize a sine or parabolic curve, but it is important
+			// to not extrapolate player positions if more recent data is available
+			EvaluateTrajectory( &cent->currentState.pos, cg.snap->serverTime, current );
+			EvaluateTrajectory( &cent->nextState->pos, cg.nextSnap->serverTime, next );
+
+			cent->lerpOrigin[0] = current[0] + f * ( next[0] - current[0] );
+			cent->lerpOrigin[1] = current[1] + f * ( next[1] - current[1] );
+			cent->lerpOrigin[2] = current[2] + f * ( next[2] - current[2] );
+
+			/*
+			if ( cent->gent && cent->currentState.clientNum != 0 )
+			{
+				Com_Printf("%s last/next/lerp pos %s/%s/%s, f = %4.2f\n", cent->gent->script_targetname, vtos(current), vtos(next), vtos(cent->lerpOrigin), f);
+			}
+			*/
+			return;//FIXME: should this be outside this if?
+		}
+	}
+	else
+	{
+		if ( cent->currentState.apos.trType == TR_INTERPOLATE )
+		{
+			EvaluateTrajectory( &cent->currentState.apos, cg.snap->serverTime, cent->lerpAngles );
+		}
+		if ( cent->currentState.pos.trType == TR_INTERPOLATE ) 
+		{
+			EvaluateTrajectory( &cent->currentState.pos, cg.snap->serverTime, cent->lerpOrigin );
+			/*
+			if(cent->gent && cent->currentState.clientNum != 0 )
+			{
+				Com_Printf("%s last/next/lerp pos %s, f = 1.0\n", cent->gent->script_targetname, vtos(cent->lerpOrigin) );
+			}
+			*/
+			return;
+		}
+	}
+	
+	// FIXME: if it's blocked, it wigs out, draws it in a predicted spot, but never
+	// makes it there - we need to predict it in the right place if this is happens...
+
+	// just use the current frame and evaluate as best we can
+	trajectory_t *posData = &cent->currentState.pos;
+	{
+		gentity_t *ent = &g_entities[cent->currentState.number];
+
+		if ( ent && ent->inuse)
+		{
+			if ( ent->s.eFlags & EF_BLOCKED_MOVER || ent->s.pos.trType == TR_STATIONARY )
+			{//this mover has stopped moving and is going to wig out if we predict it
+				//based on last frame's info- cut across the network and use the currentOrigin
+				VectorCopy( ent->currentOrigin, cent->lerpOrigin );
+				posData = NULL;
+			}
+			else
+			{
+				posData = &ent->s.pos;
+			}
+		}
+	}
+
+	if ( posData )
+	{
+		EvaluateTrajectory( posData, cg.time, cent->lerpOrigin );
+	}
+
+	// FIXME: this will stomp an apos trType of TR_INTERPOLATE!!
+	EvaluateTrajectory( &cent->currentState.apos, cg.time, cent->lerpAngles );
+
+	// adjust for riding a mover
+	CG_AdjustPositionForMover( cent->lerpOrigin, cent->currentState.groundEntityNum, cg.time, cent->lerpOrigin );
+/*
+Ghoul2 Insert Start
+*/
+		// now the nasty stuff - this will interpolate all ghoul2 models bone angle overrides per model attached to this cent
+	/*
+	if (cent->gent->ghoul2.size())
+	{
+		LerpBoneAngleOverrides(cent);
+	}
+	*/
+/*
+Ghoul2 Insert End
+*/
+	// FIXME: perform general error decay?
+}
+#else
+void CG_CalcEntityLerpPositions( centity_t *cent ) 
+{
+	if ( cent->currentState.number == cg.snap->ps.clientNum)
+	{
+		// if the player, take position from prediction
+		VectorCopy( cg.predicted_player_state.origin, cent->lerpOrigin );
+		VectorCopy( cg.predicted_player_state.viewangles, cent->lerpAngles );
+OutputDebugString(va("b=(%6.2f,%6.2f,%6.2f)\n",cent->lerpOrigin[0],cent->lerpOrigin[1],cent->lerpOrigin[2]));
+		return;
+	}
+
+
+if (cent->currentState.number != cg.snap->ps.clientNum&&cent->interpolate && cent->currentState.pos.trType == TR_INTERPOLATE)
+{
+	if (cent->interpolate)
+	{
+OutputDebugString(va("[%3d] interp %4.2f t=%6d  st = %6d  nst = %6d     b=%6.2f   nb=%6.2f\n",
+		cent->currentState.number,
+		cg.frameInterpolation,
+		cg.time,
+		cg.snap->serverTime,
+		cg.nextSnap->serverTime,
+		cent->currentState.pos.trBase[0],
+		cent->nextState.pos.trBase[0]));
+	}
+	else
+	{
+OutputDebugString(va("[%3d] nonext %4.2f t=%6d  st = %6d  nst = %6d     b=%6.2f   nb=%6.2f\n",
+		cent->currentState.number,
+		cg.frameInterpolation,
+		cg.time,
+		cg.snap->serverTime,
+		0,
+		cent->currentState.pos.trBase[0],
+		0.0f));
+	}
+}
+
+	//FIXME: prediction on clients in timescale results in jerky positional translation
+	if (cent->interpolate && 
+		(cent->currentState.number == cg.snap->ps.clientNum ||
+		cent->interpolate && cent->currentState.pos.trType == TR_INTERPOLATE ) )
+	{
+		vec3_t		current, next;
+		float		f;
+
+		// it would be an internal error to find an entity that interpolates without
+		// a snapshot ahead of the current one
+		if ( cg.nextSnap == NULL ) 
+		{
+			CG_Error( "CG_AddCEntity: cg.nextSnap == NULL" );
+		}
+
+		f = cg.frameInterpolation;
+
+		EvaluateTrajectory( &cent->currentState.apos, cg.snap->serverTime, current );
+		EvaluateTrajectory( &cent->nextState.apos, cg.nextSnap->serverTime, next );
+
+		cent->lerpAngles[0] = LerpAngle( current[0], next[0], f );
+		cent->lerpAngles[1] = LerpAngle( current[1], next[1], f );
+		cent->lerpAngles[2] = LerpAngle( current[2], next[2], f );
+
+		EvaluateTrajectory( &cent->currentState.pos, cg.snap->serverTime, current );
+		EvaluateTrajectory( &cent->nextState.pos, cg.nextSnap->serverTime, next );
+
+		cent->lerpOrigin[0] = current[0] + f * ( next[0] - current[0] );
+		cent->lerpOrigin[1] = current[1] + f * ( next[1] - current[1] );
+		cent->lerpOrigin[2] = current[2] + f * ( next[2] - current[2] );
+		return;
+	}
+	// just use the current frame and evaluate as best we can
+	trajectory_t *posData = &cent->currentState.pos;
+	{
+		gentity_t *ent = &g_entities[cent->currentState.number];
+
+		if ( ent && ent->inuse)
+		{
+			if ( ent->s.eFlags & EF_BLOCKED_MOVER || ent->s.pos.trType == TR_STATIONARY )
+			{//this mover has stopped moving and is going to wig out if we predict it
+				//based on last frame's info- cut across the network and use the currentOrigin
+				VectorCopy( ent->currentOrigin, cent->lerpOrigin );
+				posData = NULL;
+			}
+			else
+			{
+				posData = &ent->s.pos;
+				EvaluateTrajectory(&ent->s.pos,cg.time, cent->lerpOrigin );
+			}
+		}
+		else
+		{
+			EvaluateTrajectory( &cent->currentState.pos, cg.snap->serverTime, cent->lerpOrigin );
+		}
+	}
+	EvaluateTrajectory( &cent->currentState.apos, cg.time, cent->lerpAngles );
+
+	// adjust for riding a mover
+	CG_AdjustPositionForMover( cent->lerpOrigin, cent->currentState.groundEntityNum, cg.time, cent->lerpOrigin );
+}
+#endif
+/*
+===============
+CG_AddLocalSet
+===============
+*/
+
+static void CG_AddLocalSet( centity_t *cent )
+{
+	cent->gent->setTime = cgi_S_AddLocalSet( cent->gent->soundSet, cg.refdef.vieworg, cent->lerpOrigin, cent->gent->s.number, cent->gent->setTime );
+}
+
+/*
+-------------------------
+CAS_GetBModelSound
+-------------------------
+*/
+
+sfxHandle_t CAS_GetBModelSound( const char *name, int stage )
+{
+	return cgi_AS_GetBModelSound( name, stage );
+}
+
+void CG_DLightThink ( centity_t *cent )
+{
+	if(cent->gent)
+	{
+		float	tDelta = cg.time - cent->gent->painDebounceTime;
+		float	percentage = ( tDelta/((float)cent->gent->speed) );
+		vec3_t	org;
+		vec4_t	currentRGBA;
+		gentity_t	*owner = NULL;
+		int		i;
+		
+		if ( percentage >= 1.0f )
+		{//We hit the end
+			percentage = 1.0f;
+			switch( cent->gent->pushDebounceTime )
+			{
+			case 0://Fading from start to final
+				if ( cent->gent->spawnflags & 8 )
+				{//PULSER
+					if ( tDelta - cent->gent->speed - cent->gent->wait >= 0 )
+					{//Time to start fading down
+						cent->gent->painDebounceTime = cg.time;
+						cent->gent->pushDebounceTime = 1;
+						percentage = 0.0f;
+					}
+				}
+				else
+				{//Stick on startRGBA
+					percentage = 0.0f;
+				}
+				break;
+			case 1://Fading from final to start
+				if ( tDelta - cent->gent->speed - cent->gent->radius >= 0 )
+				{//Time to start fading up
+					cent->gent->painDebounceTime = cg.time;
+					cent->gent->pushDebounceTime = 0;
+					percentage = 0.0f;
+				}
+				break;
+			case 2://Fading from 0 intensity to start intensity
+				//Time to start fading from start to final
+				cent->gent->painDebounceTime = cg.time;
+				cent->gent->pushDebounceTime = 0;
+				percentage = 0.0f;
+				break;
+			case 3://Fading from current intensity to 0 intensity
+				//Time to turn off
+				cent->gent->misc_dlight_active = qfalse;
+				cent->gent->e_clThinkFunc = clThinkF_NULL;
+				cent->gent->s.eType = ET_GENERAL;
+				cent->gent->svFlags &= ~SVF_BROADCAST;
+				return;		
+				break;
+			default:
+				break;
+			}
+		}
+
+		switch( cent->gent->pushDebounceTime )
+		{
+		case 0://Fading from start to final
+			for ( i = 0; i < 4; i++ )
+			{
+				currentRGBA[i] = cent->gent->startRGBA[i] + ( (cent->gent->finalRGBA[i] - cent->gent->startRGBA[i]) * percentage );
+			}
+			break;
+		case 1://Fading from final to start
+			for ( i = 0; i < 4; i++ )
+			{
+				currentRGBA[i] = cent->gent->finalRGBA[i] + ( (cent->gent->startRGBA[i] - cent->gent->finalRGBA[i]) * percentage );
+			}
+			break;
+		case 2://Fading from 0 intensity to start
+			for ( i = 0; i < 3; i++ )
+			{
+				currentRGBA[i] = cent->gent->startRGBA[i];
+			}
+			currentRGBA[3] = cent->gent->startRGBA[3] * percentage;
+			break;
+		case 3://Fading from current intensity to 0
+			for ( i = 0; i < 3; i++ )
+			{//FIXME: use last
+				currentRGBA[i] = cent->gent->startRGBA[i];
+			}
+			currentRGBA[3] = cent->gent->startRGBA[3] - (cent->gent->startRGBA[3] * percentage);
+			break;
+		default:
+			return;
+			break;
+		}
+
+		if ( cent->gent->owner )
+		{
+			owner = cent->gent->owner;
+		}
+		else
+		{
+			owner = cent->gent;
+		}
+
+		if ( owner->s.pos.trType == TR_INTERPOLATE )
+		{
+			VectorCopy( cg_entities[owner->s.number].lerpOrigin, org );
+		}
+		else
+		{
+			VectorCopy( owner->currentOrigin, org );
+		}
+
+		cgi_R_AddLightToScene(org, currentRGBA[3]*10, currentRGBA[0], currentRGBA[1], currentRGBA[2] );
+	}
+}
+
+void CG_Limb ( centity_t *cent )
+{//first time we're drawn, remove us from the owner ent
+	if ( cent->gent && cent->gent->owner && cent->gent->owner->ghoul2.size() )
+	{
+		gentity_t	*owner = cent->gent->owner;
+		if ( cent->gent->aimDebounceTime )
+		{//done with dismemberment, just waiting to mark owner dismemberable again
+			if ( cent->gent->aimDebounceTime > cg.time )
+			{//still waiting
+				return;
+			}
+			//done!
+			owner->client->dismembered = false;
+			//done!
+			cent->gent->e_clThinkFunc = clThinkF_NULL;
+		}
+		else
+		{
+extern cvar_t	*g_dismemberment;
+extern cvar_t	*g_saberRealisticCombat;
+			//3) turn off w/descendants that surf in original model
+			if ( cent->gent->target )//stubTagName )
+			{//add smoke to cap surf, spawn effect
+				if ( cent->gent->delay <= cg.time )
+				{//debounced so it only plays effect once every 50ms
+					int newBolt = gi.G2API_AddBolt( &owner->ghoul2[owner->playerModel], cent->gent->target );
+					if ( newBolt != -1 )
+					{
+						cent->gent->delay = cg.time + 50;
+						CG_PlayEffectBolted( "blaster/smoke_bolton", owner->playerModel, newBolt, owner->s.number, owner->s.origin );	//ent origin used to make FX culling work
+					}
+				}
+			}
+			if ( cent->gent->target2 )//limbName
+			{//turn the limb off
+				//NOTE: MUST use G2SURFACEFLAG_NODESCENDANTS
+				gi.G2API_SetSurfaceOnOff( &owner->ghoul2[owner->playerModel], cent->gent->target2, 0x00000100 );//G2SURFACEFLAG_NODESCENDANTS
+			}
+			if ( cent->gent->target3 )//stubCapName )
+			{//turn on caps
+				gi.G2API_SetSurfaceOnOff( &owner->ghoul2[owner->playerModel], cent->gent->target3, 0 );
+			}
+			if ( owner->weaponModel[0] > 0 )
+			{//the corpse hasn't dropped their weapon
+				if ( cent->gent->count == BOTH_DISMEMBER_RARM || cent->gent->count == BOTH_DISMEMBER_TORSO1 )//&& ent->s.weapon == WP_SABER && ent->weaponModel[0] != -1 )
+				{//FIXME: is this first check needed with this lower one?
+					gi.G2API_RemoveGhoul2Model( owner->ghoul2, owner->weaponModel[0] );
+					owner->weaponModel[0] = -1;
+				}
+			}
+			if ( owner->client->NPC_class == CLASS_PROTOCOL 
+				|| g_dismemberment->integer == 113811381138
+				|| g_saberRealisticCombat->integer )
+			{
+				//wait 100ms before allowing owner to be dismembered again
+				cent->gent->aimDebounceTime = cg.time + 100;
+				return;
+			}
+			else
+			{
+				//done!
+				cent->gent->e_clThinkFunc = clThinkF_NULL;
+			}
+		}
+	}
+}
+
+extern Vehicle_t *G_IsRidingVehicle( gentity_t *ent );
+qboolean	MatrixMode = qfalse;
+extern cvar_t	*g_skippingcin;
+void CG_MatrixEffect ( centity_t *cent )
+{
+	float	MATRIX_EFFECT_TIME = 1000.0f;
+	if ( (cent->currentState.boltInfo&MEF_MULTI_SPIN) )
+	{//multiple spins
+		if ( cent->currentState.time2 > 0 )
+		{//with a custom amount of time per spin
+			MATRIX_EFFECT_TIME = cent->currentState.time2;
+		}
+	}
+	else
+	{
+		if ( cent->currentState.eventParm 
+			&& cent->currentState.eventParm != MATRIX_EFFECT_TIME )
+		{//not a falling multi-spin, so stretch out the effect over the whole desired length (or: condenses it, too)
+			MATRIX_EFFECT_TIME = cent->currentState.eventParm;
+		}
+	}
+	//VectorCopy( cent->lerpOrigin, cg.refdef.vieworg );
+	float totalElapsedTime = (float)(cg.time - cent->currentState.time);
+	float elapsedTime = totalElapsedTime;
+	bool	stopEffect = ((totalElapsedTime > cent->currentState.eventParm) || cg.missionStatusShow || in_camera);
+
+	if (!stopEffect && (cent->currentState.boltInfo&MEF_HIT_GROUND_STOP) && g_entities[cent->currentState.otherEntityNum].client)
+	{
+		if (g_entities[cent->currentState.otherEntityNum].client->ps.groundEntityNum!=ENTITYNUM_NONE)
+		{
+			stopEffect = true;
+		}
+		else if (g_entities[cent->currentState.otherEntityNum].client->NPC_class == CLASS_VEHICLE)
+		{
+			Vehicle_t*	pVeh = g_entities[cent->currentState.otherEntityNum].m_pVehicle;
+			if (pVeh && !(pVeh->m_ulFlags&VEH_FLYING))
+			{
+				stopEffect = true;
+			}
+		}
+	}
+	if (!stopEffect && (cent->currentState.boltInfo&MEF_LOOK_AT_ENEMY))
+	{
+		if (!g_entities[cent->currentState.otherEntityNum].lastEnemy || 
+			!g_entities[cent->currentState.otherEntityNum].lastEnemy->inuse)
+		{
+			stopEffect = true;
+		}
+	}
+
+	if (stopEffect)
+	{//time is up or this is a falling spin and they hit the ground or mission end screen is up
+		cg.overrides.active &= ~(/*CG_OVERRIDE_3RD_PERSON_ENT|*/CG_OVERRIDE_3RD_PERSON_RNG|CG_OVERRIDE_3RD_PERSON_ANG|CG_OVERRIDE_3RD_PERSON_POF);
+		//cg.overrides.thirdPersonEntity = 0;
+		cg.overrides.thirdPersonAngle = 0;
+		cg.overrides.thirdPersonPitchOffset = 0;
+		cg.overrides.thirdPersonRange = 0;
+		if ( g_skippingcin->integer )
+		{//skipping?  don't mess with timescale
+			/*
+			if ( g_timescale->integer < 100 )
+			{//something messed up timescale, reset it?
+				cgi_Cvar_Set( "timescale", "100" );
+			}
+			*/
+		}
+		else
+		{//set it back to 1
+			cgi_Cvar_Set( "timescale", "1.0" );
+		}
+		MatrixMode = qfalse;
+		cent->gent->e_clThinkFunc = clThinkF_NULL;
+		cent->gent->e_ThinkFunc = thinkF_G_FreeEntity;
+		cent->gent->nextthink = cg.time + 500;
+		return;
+	}
+	else 
+	{
+		while ( elapsedTime > MATRIX_EFFECT_TIME )
+		{
+			elapsedTime -= MATRIX_EFFECT_TIME;
+		}
+	}
+	
+	MatrixMode = qtrue;
+
+	//FIXME: move the position towards them and back?
+	//cg.overrides.active |= CG_OVERRIDE_3RD_PERSON_ENT;
+	//cg.overrides.thirdPersonEntity = cent->currentState.otherEntityNum;
+
+	if (cent->currentState.boltInfo&MEF_LOOK_AT_ENEMY)
+	{
+		vec3_t	toEnemy;
+		vec3_t	toEnemyAngles;
+
+		VectorCopy(cg_entities[g_entities[cent->currentState.otherEntityNum].lastEnemy->s.number].lerpOrigin, toEnemy);
+//		CG_DrawEdge(cg_entities[cent->currentState.otherEntityNum].lerpOrigin, toEnemy, EDGE_NORMAL);
+		VectorSubtract(cg_entities[cent->currentState.otherEntityNum].lerpOrigin, toEnemy, toEnemy);
+		vectoangles(toEnemy, toEnemyAngles);
+
+
+		cg.overrides.active					|= CG_OVERRIDE_3RD_PERSON_ANG;
+  	 	cg.overrides.thirdPersonAngle		 = 
+			toEnemyAngles[1] - 
+			cg_entities[cent->currentState.otherEntityNum].lerpAngles[1] + 
+ 			145.0f;
+	 	cg.overrides.thirdPersonAngle = AngleNormalize180(cg.overrides.thirdPersonAngle);
+
+		float	MATRIX_EFFECT_TIME_HALF = MATRIX_EFFECT_TIME/2.0f;
+		float	X = 1.0f;
+		if (elapsedTime>MATRIX_EFFECT_TIME_HALF)
+		{
+			X -= ((elapsedTime - MATRIX_EFFECT_TIME_HALF)/MATRIX_EFFECT_TIME_HALF);
+		}
+		cg.overrides.thirdPersonAngle		*= X;
+
+ //		gi.Printf("%f\n", cg.overrides.thirdPersonAngle);
+		cg.overrides.thirdPersonPitchOffset	 = 0.0f;
+		cg.overrides.thirdPersonRange		 = cg_thirdPersonRange.value * 3.0f;
+	}
+
+	if ( !(cent->currentState.boltInfo&MEF_NO_SPIN) )
+	{//rotate around them
+		//rotate
+		cg.overrides.active |= CG_OVERRIDE_3RD_PERSON_ANG;
+		cg.overrides.thirdPersonAngle = 360.0f*elapsedTime/MATRIX_EFFECT_TIME;
+		if ( (cent->currentState.boltInfo&MEF_REVERSE_SPIN) )
+		{
+			cg.overrides.thirdPersonAngle *= -1;
+		}
+	}
+
+	//do all the slowdown and vert bob stuff
+	if ( cent->currentState.angles2[0] )
+	{
+		cgi_Cvar_Set( "timescale", va("%4.2f",cent->currentState.angles2[0]) );
+	}
+	else if ( !(cent->currentState.boltInfo&MEF_NO_TIMESCALE) )
+	{//ramp the timescale
+		//slowdown
+		float timescale = (elapsedTime/MATRIX_EFFECT_TIME);
+		if ( timescale < 0.01f )
+		{
+			timescale = 0.01f;
+		}
+		cgi_Cvar_Set( "timescale", va("%4.2f",timescale) );
+	}
+	else
+	{//FIXME: MEF_HIT_GROUND_STOP: if they're on the ground, stop spinning and stop timescale
+		//FIXME: if they go to the menu, restore timescale?
+		//cgi_Cvar_Set( "timescale", "1.0ff" );
+	}
+
+	if ( !(cent->currentState.boltInfo&MEF_NO_VERTBOB) )
+	{//bob the pitch
+		//pitch
+		//dip - FIXME: use pitchOffet?
+		cg.overrides.active |= CG_OVERRIDE_3RD_PERSON_POF;
+		cg.overrides.thirdPersonPitchOffset = cg_thirdPersonPitchOffset.value;
+		if ( elapsedTime < MATRIX_EFFECT_TIME*0.33f )
+		{
+			cg.overrides.thirdPersonPitchOffset -= 30.0f*elapsedTime/(MATRIX_EFFECT_TIME*0.33);
+		}
+		else if ( elapsedTime > MATRIX_EFFECT_TIME*0.66f )
+		{
+			cg.overrides.thirdPersonPitchOffset -= 30.0f*(MATRIX_EFFECT_TIME-elapsedTime)/(MATRIX_EFFECT_TIME*0.33);
+		}
+		else
+		{
+			cg.overrides.thirdPersonPitchOffset -= 30.0f;
+		}
+	}
+
+	if ( !(cent->currentState.boltInfo&MEF_NO_RANGEVAR) )
+	{//vary the camera range
+		//pull back
+		cg.overrides.active |= CG_OVERRIDE_3RD_PERSON_RNG;
+		cg.overrides.thirdPersonRange = cg_thirdPersonRange.value;
+		if ( elapsedTime < MATRIX_EFFECT_TIME*0.33 )
+		{
+			cg.overrides.thirdPersonRange += 80.0f*elapsedTime/(MATRIX_EFFECT_TIME*0.33);
+		}
+		else if ( elapsedTime > MATRIX_EFFECT_TIME*0.66 )
+		{
+			cg.overrides.thirdPersonRange += 80.0f*(MATRIX_EFFECT_TIME-elapsedTime)/(MATRIX_EFFECT_TIME*0.33);
+		}
+		else
+		{
+			cg.overrides.thirdPersonRange += 80.0f;
+		}
+	}
+}
+
+static void CG_Think ( centity_t *cent )
+{
+	if(!cent->gent)
+	{
+		return;
+	}
+
+	CEntity_ThinkFunc(cent);	//	cent->gent->clThink(cent);
+}
+
+static void CG_Clouds( centity_t *cent )
+{
+	refEntity_t		ent;
+	entityState_t	*s1;
+
+	s1 = &cent->currentState;
+
+	// create the render entity
+	memset( &ent, 0, sizeof( ent ));
+
+	VectorCopy( cent->lerpOrigin, ent.origin );
+
+	ent.shaderRGBA[0] = ent.shaderRGBA[1] = ent.shaderRGBA[2] = ent.shaderRGBA[3] = 255;
+
+	ent.radius = cent->gent->radius;
+	ent.backlerp = cent->gent->wait;
+
+	ent.reType = RT_CLOUDS;
+
+	if ( cent->gent->spawnflags & 1 ) // TUBE type, the one with a hole in the middle
+	{
+		ent.rotation = cent->gent->random;
+		ent.renderfx = RF_GROW;// tube flag 
+	}
+
+	if ( cent->gent->spawnflags & 2 ) // ALT type, uses a different shader
+	{
+		ent.customShader = cgi_R_RegisterShader( "gfx/world/haze2" );
+	}
+	else
+	{
+		ent.customShader = cgi_R_RegisterShader( "gfx/world/haze" );
+	}
+	
+	cgi_R_AddRefEntityToScene( &ent );
+}
+
+/*
+===============
+CG_AddCEntity
+
+===============
+*/
+static void CG_AddCEntity( centity_t *cent ) 
+{
+	// event-only entities will have been dealt with already
+	if ( cent->currentState.eType >= ET_EVENTS ) {
+		return;
+	}
+
+	//we must have restarted the game
+	if (!cent->gent)
+	{
+		return;
+	}
+
+	cent->snapShotTime = cg.time;
+
+	// calculate the current origin
+	CG_CalcEntityLerpPositions( cent );
+
+	// add automatic effects
+	CG_EntityEffects( cent );
+
+	// add local sound set if any
+	if ( cent->gent && cent->gent->soundSet && cent->gent->soundSet[0] && cent->currentState.eType != ET_MOVER )
+	{
+		CG_AddLocalSet( cent );
+	}
+/*
+Ghoul2 Insert Start
+*/
+	// do this before we copy the data to refEnts
+	if (cent->gent->ghoul2.IsValid())
+	{
+		trap_G2_SetGhoul2ModelIndexes(cent->gent->ghoul2, cgs.model_draw, cgs.skins);
+	}
+
+/*
+Ghoul2 Insert End
+*/
+
+	switch ( cent->currentState.eType ) {
+	default:
+		CG_Error( "Bad entity type: %i\n", cent->currentState.eType );
+		break;
+	case ET_INVISIBLE:
+	case ET_PUSH_TRIGGER:
+	case ET_TELEPORT_TRIGGER:
+	case ET_TERRAIN:
+		break;
+	case ET_GENERAL:
+		CG_General( cent );
+		break;
+	case ET_PLAYER:
+		CG_Player( cent );
+		break;
+	case ET_ITEM:
+		CG_Item( cent );
+		break;
+	case ET_MISSILE:
+		CG_Missile( cent );
+		break;
+	case ET_MOVER:
+		CG_Mover( cent );
+		break;
+	case ET_BEAM:
+		CG_Beam( cent, 0 );
+		break;
+	case ET_PORTAL:
+		CG_Portal( cent );
+		break;
+	case ET_SPEAKER:
+		if ( cent->gent && cent->gent->soundSet && cent->gent->soundSet[0] )
+		{
+			break;
+		}
+		CG_Speaker( cent );
+		break;
+	case ET_THINKER:
+		CG_General( cent );
+		CG_Think( cent );
+		break;
+	case ET_CLOUD: // dumb
+		CG_Clouds( cent );
+		break;
+	}
+}
+
+/*
+===============
+CG_AddPacketEntities
+
+===============
+*/
+void CG_AddPacketEntities( qboolean isPortal ) {
+	int					num;
+	centity_t			*cent;
+	playerState_t		*ps;
+
+	if (isPortal)
+	{
+		for ( num = 0 ; num < cg.snap->numEntities ; num++ )
+		{
+			cent = &cg_entities[ cg.snap->entities[ num ].number ];
+
+			if (cent->currentState.isPortalEnt)
+			{
+				CG_AddCEntity( cent );
+			}
+		}
+		return;
+	}
+
+	// set cg.frameInterpolation
+	if ( cg.nextSnap ) 
+	{
+		int		delta;
+
+		delta = (cg.nextSnap->serverTime - cg.snap->serverTime);
+		if ( delta == 0 ) 
+		{
+			cg.frameInterpolation = 0;
+		} 
+		else 
+		{
+			cg.frameInterpolation = (float)( cg.time - cg.snap->serverTime ) / delta;
+		}
+//OutputDebugString(va("interp %4.2f ct=%6d nt=%6d st=%6d\n",cg.frameInterpolation,cg.time,cg.nextSnap->serverTime,cg.snap->serverTime));
+	} 
+	else 
+	{
+		cg.frameInterpolation = 0;	// actually, it should never be used, because 
+									// no entities should be marked as interpolating
+//OutputDebugString(va("noterp %4.2f ct=%6d nt=%6d st=%6d\n",cg.frameInterpolation,cg.time,0,cg.snap->serverTime));
+	}
+
+	// the auto-rotating items will all have the same axis
+	cg.autoAngles[0] = 0;
+	cg.autoAngles[1] = ( cg.time & 2047 ) * 360 / 2048.0f;
+	cg.autoAngles[2] = 0;
+
+	cg.autoAnglesFast[0] = 0;
+	cg.autoAnglesFast[1] = ( cg.time & 1023 ) * 360 / 1024.0f;
+	cg.autoAnglesFast[2] = 0;
+
+	AnglesToAxis( cg.autoAngles, cg.autoAxis );
+	AnglesToAxis( cg.autoAnglesFast, cg.autoAxisFast );
+
+	// generate and add the entity from the playerstate
+	ps = &cg.predicted_player_state;
+	PlayerStateToEntityState( ps, &cg_entities[ ps->clientNum ].currentState );
+//	cent = &cg_entities[ ps->clientNum ];	// not needed now that player is in the snap packet
+//	CG_AddCEntity( cent );					//
+
+	// add each entity sent over by the server
+	for ( num = 0 ; num < cg.snap->numEntities ; num++ ) {
+		cent = &cg_entities[ cg.snap->entities[ num ].number ];
+
+		CG_AddCEntity( cent );
+	}
+
+	for(num=0;num<cg_numpermanents;num++)
+	{
+		cent = cg_permanents[num];
+		if (cent->currentValid)
+		{
+			CG_AddCEntity( cent );
+		}
+	}
+}
+
+//rww - This function is not currently called. Use it as the client-side ROFF
+//callback once that's implemented fully.
+void CG_ROFF_NotetrackCallback( centity_t *cent, const char *notetrack)
+{
+	int i = 0, r = 0, objectID = 0, anglesGathered = 0, posoffsetGathered = 0;
+	char type[256];
+	char argument[512];
+	char addlArg[512];
+	char errMsg[256];
+	char t[64];
+	int addlArgs = 0;
+	vec3_t parsedAngles, parsedOffset, useAngles, useOrigin, forward, right, up;
+
+	if (!cent || !notetrack)
+	{
+		return;
+	}
+
+	//notetrack = "effect effects/explosion1.efx 0+0+64 0-0-1";
+
+	while (notetrack[i] && notetrack[i] != ' ')
+	{
+		type[i] = notetrack[i];
+		i++;
+	}
+
+	type[i] = '\0';
+
+	if (notetrack[i] != ' ')
+	{ //didn't pass in a valid notetrack type, or forgot the argument for it
+		return;
+	}
+
+	i++;
+
+	while (notetrack[i] && notetrack[i] != ' ')
+	{
+		argument[r] = notetrack[i];
+		r++;
+		i++;
+	}
+	argument[r] = '\0';
+
+	if (!r)
+	{
+		return;
+	}
+
+	if (notetrack[i] == ' ')
+	{ //additional arguments...
+		addlArgs = 1;
+
+		i++;
+		r = 0;
+		while (notetrack[i])
+		{
+			addlArg[r] = notetrack[i];
+			r++;
+			i++;
+		}
+		addlArg[r] = '\0';
+	}
+
+	if (strcmp(type, "effect") == 0)
+	{
+		if (!addlArgs)
+		{
+			//sprintf(errMsg, "Offset position argument for 'effect' type is invalid.");
+			//goto functionend;
+			VectorClear(parsedOffset);
+			goto defaultoffsetposition;
+		}
+
+		i = 0;
+
+		while (posoffsetGathered < 3)
+		{
+			r = 0;
+			while (addlArg[i] && addlArg[i] != '+' && addlArg[i] != ' ')
+			{
+				t[r] = addlArg[i];
+				r++;
+				i++;
+			}
+			t[r] = '\0';
+			i++;
+			if (!r)
+			{ //failure..
+				//sprintf(errMsg, "Offset position argument for 'effect' type is invalid.");
+				//goto functionend;
+				VectorClear(parsedOffset);
+				i = 0;
+				goto defaultoffsetposition;
+			}
+			parsedOffset[posoffsetGathered] = atof(t);
+			posoffsetGathered++;
+		}
+
+		if (posoffsetGathered < 3)
+		{
+			sprintf(errMsg, "Offset position argument for 'effect' type is invalid.");
+			goto functionend;
+		}
+
+		i--;
+
+		if (addlArg[i] != ' ')
+		{
+			addlArgs = 0;
+		}
+
+defaultoffsetposition:
+
+		objectID = theFxScheduler.RegisterEffect(argument);
+
+		if (objectID)
+		{
+			if (addlArgs)
+			{ //if there is an additional argument for an effect it is expected to be XANGLE-YANGLE-ZANGLE
+				i++;
+				while (anglesGathered < 3)
+				{
+					r = 0;
+					while (addlArg[i] && addlArg[i] != '-')
+					{
+						t[r] = addlArg[i];
+						r++;
+						i++;
+					}
+					t[r] = '\0';
+					i++;
+
+					if (!r)
+					{ //failed to get a new part of the vector
+						anglesGathered = 0;
+						break;
+					}
+
+					parsedAngles[anglesGathered] = atof(t);
+					anglesGathered++;
+				}
+
+				if (anglesGathered)
+				{
+					VectorCopy(parsedAngles, useAngles);
+				}
+				else
+				{ //failed to parse angles from the extra argument provided..
+					VectorCopy(cent->lerpAngles, useAngles);
+				}
+			}
+			else
+			{ //if no constant angles, play in direction entity is facing
+				VectorCopy(cent->lerpAngles, useAngles);
+			}
+
+			AngleVectors(useAngles, forward, right, up);
+
+			VectorCopy(cent->lerpOrigin, useOrigin);
+
+			//forward
+			useOrigin[0] += forward[0]*parsedOffset[0];
+			useOrigin[1] += forward[1]*parsedOffset[0];
+			useOrigin[2] += forward[2]*parsedOffset[0];
+
+			//right
+			useOrigin[0] += right[0]*parsedOffset[1];
+			useOrigin[1] += right[1]*parsedOffset[1];
+			useOrigin[2] += right[2]*parsedOffset[1];
+
+			//up
+			useOrigin[0] += up[0]*parsedOffset[2];
+			useOrigin[1] += up[1]*parsedOffset[2];
+			useOrigin[2] += up[2]*parsedOffset[2];
+
+			theFxScheduler.PlayEffect(objectID, useOrigin, useAngles);
+		}
+	}
+	else if (strcmp(type, "sound") == 0)
+	{
+		objectID = cgi_S_RegisterSound(argument);
+		cgi_S_StartSound(cent->lerpOrigin, cent->currentState.number, CHAN_BODY, objectID);
+	}
+	else if (strcmp(type, "loop") == 0)
+	{ //handled server-side
+		return;
+	}
+	//else if ...
+	else
+	{
+		if (type[0])
+		{
+			Com_Printf("^3Warning: \"%s\" is an invalid ROFF notetrack function\n", type);
+		}
+		else
+		{
+			Com_Printf("^3Warning: Notetrack is missing function and/or arguments\n");
+		}
+	}
+
+	return;
+
+functionend:
+	Com_Printf("^3Type-specific notetrack error: %s\n", errMsg);
+	return;
+}
diff --git a/code/cgame/cg_event.cpp b/code/cgame/cg_event.cpp
new file mode 100644
index 0000000..5b2cf76
--- /dev/null
+++ b/code/cgame/cg_event.cpp
@@ -0,0 +1,1279 @@
+// cg_event.c -- handle entity events at snapshot or playerstate transitions
+
+// this line must stay at top so the whole PCH thing works...
+#include "cg_headers.h"
+
+//#include "cg_local.h"
+#include "cg_media.h"
+#include "FxScheduler.h"
+
+#include "..\game\anims.h"
+
+#ifdef _XBOX
+#include "..\client\fffx.h"
+#endif
+
+#ifdef _IMMERSION
+#include "../ff/ff.h"
+#endif // _IMMERSION
+extern qboolean CG_TryPlayCustomSound( vec3_t origin, int entityNum, soundChannel_t channel, const char *soundName, int customSoundSet );
+extern void FX_KothosBeam( vec3_t start, vec3_t end );
+
+//==========================================================================
+
+qboolean CG_IsFemale( const char *infostring ) {
+	char		*sex;
+
+	sex = Info_ValueForKey( infostring, "s" );
+	if (sex[0] == 'f' || sex[0] == 'F')
+		return qtrue;
+	return qfalse;
+}
+
+const char	*CG_PlaceString( int rank ) {
+	static char	str[64];
+	char	*s, *t;
+
+	if ( rank & RANK_TIED_FLAG ) {
+		rank &= ~RANK_TIED_FLAG;
+		t = "Tied for ";
+	} else {
+		t = "";
+	}
+
+	if ( rank == 1 ) {
+		s = "\03341st\0337";		// draw in blue
+	} else if ( rank == 2 ) {
+		s = "\03312nd\0337";		// draw in red
+	} else if ( rank == 3 ) {
+		s = "\03333rd\0337";		// draw in yellow
+	} else if ( rank == 11 ) {
+		s = "11th";
+	} else if ( rank == 12 ) {
+		s = "12th";
+	} else if ( rank == 13 ) {
+		s = "13th";
+	} else if ( rank % 10 == 1 ) {
+		s = va("%ist", rank);
+	} else if ( rank % 10 == 2 ) {
+		s = va("%ind", rank);
+	} else if ( rank % 10 == 3 ) {
+		s = va("%ird", rank);
+	} else {
+		s = va("%ith", rank);
+	}
+
+	Com_sprintf( str, sizeof( str ), "%s%s", t, s );
+	return str;
+}
+
+
+/*
+================
+CG_ItemPickup
+
+A new item was picked up this frame
+================
+*/
+void CG_ItemPickup( int itemNum, qboolean bHadItem ) {
+	cg.itemPickup = itemNum;
+	cg.itemPickupTime = cg.time;
+	cg.itemPickupBlendTime = cg.time;
+
+	if (bg_itemlist[itemNum].classname && bg_itemlist[itemNum].classname[0])
+	{ 
+
+		char text[1024], data[1024];
+		if (cgi_SP_GetStringTextString("SP_INGAME_PICKUPLINE",text, sizeof(text)) )
+		{			
+			if ( cgi_SP_GetStringTextString( va("SP_INGAME_%s",bg_itemlist[itemNum].classname ), data, sizeof( data )))
+			{
+//				Com_Printf("%s %s\n", text, data );
+				cgi_Cvar_Set( "cg_WeaponPickupText", va("%s %s\n", text, data));
+				cg.weaponPickupTextTime	= cg.time + 5000;
+			}
+		}
+	}
+	
+	// see if it should be the grabbed weapon
+	if ( bg_itemlist[itemNum].giType == IT_WEAPON ) 
+	{
+		const int nCurWpn = cg.predicted_player_state.weapon;
+		const int nNewWpn = bg_itemlist[itemNum].giTag;
+
+		if ( nCurWpn == WP_SABER || bHadItem)
+		{//never switch away from the saber!
+			return;
+		}
+
+		// kef -- check cg_autoswitch...
+		//
+		// 0 == no switching
+		// 1 == automatically switch to best SAFE weapon
+		// 2 == automatically switch to best weapon, safe or otherwise
+		//
+		// NOTE: automatically switching to any weapon you pick up is stupid and annoying and we won't do it.
+		//
+
+		if ( nNewWpn == WP_SABER )
+		{//always switch to saber
+			SetWeaponSelectTime();
+			cg.weaponSelect = nNewWpn;
+		}
+		else if (0 == cg_autoswitch.integer)
+		{
+			// don't switch
+		}
+		else if (1 == cg_autoswitch.integer)
+		{
+			// safe switching
+			if (	(nNewWpn > nCurWpn) &&
+					!(nNewWpn == WP_DET_PACK) &&
+					!(nNewWpn == WP_TRIP_MINE) &&
+					!(nNewWpn == WP_THERMAL) &&
+					!(nNewWpn == WP_ROCKET_LAUNCHER) &&
+					!(nNewWpn == WP_CONCUSSION) )
+			{
+				// switch to new wpn
+//				cg.weaponSelectTime = cg.time;
+				SetWeaponSelectTime();
+				cg.weaponSelect = nNewWpn;
+			}
+		}
+		else if (2 == cg_autoswitch.integer)
+		{
+			// best
+			if (nNewWpn > nCurWpn)
+			{
+				// switch to new wpn
+//				cg.weaponSelectTime = cg.time;
+				SetWeaponSelectTime();
+				cg.weaponSelect = nNewWpn;
+			}
+		}
+	}
+}
+
+
+/*
+===============
+UseItem
+===============
+*/
+extern void CG_ToggleBinoculars( void );
+extern void CG_ToggleLAGoggles( void );
+
+void UseItem(int itemNum)
+{
+	centity_t		*cent;
+
+	cent = &cg_entities[cg.snap->ps.clientNum];
+
+	switch ( itemNum ) 
+	{
+	case INV_ELECTROBINOCULARS:
+		CG_ToggleBinoculars();
+		break;
+	case INV_LIGHTAMP_GOGGLES:
+		CG_ToggleLAGoggles();
+		break;
+	case INV_GOODIE_KEY:
+		if (cent->gent->client->ps.inventory[INV_GOODIE_KEY])
+		{
+			cent->gent->client->ps.inventory[INV_GOODIE_KEY]--;
+		}
+		break;
+	case INV_SECURITY_KEY:
+		if (cent->gent->client->ps.inventory[INV_SECURITY_KEY])
+		{
+			cent->gent->client->ps.inventory[INV_SECURITY_KEY]--;
+		}
+		break;
+	}
+}
+
+/*
+===============
+CG_UseForce
+===============
+*/
+static void CG_UseForce( centity_t *cent ) 
+{
+	//FIXME: sound or graphic change or something?
+	//actual force power action is on game/pm side
+}
+
+/*
+===============
+CG_UseItem
+===============
+*/
+static void CG_UseItem( centity_t *cent ) 
+{
+	int			itemNum;
+	entityState_t *es;
+
+	es = &cent->currentState;
+	
+	itemNum = cg.inventorySelect;
+	if ( itemNum < 0 || itemNum > INV_MAX ) 
+	{
+		itemNum = 0;
+	}
+
+	// print a message if the local player
+	if ( es->number == cg.snap->ps.clientNum ) 
+	{
+		if ( !itemNum ) 
+		{
+//			CG_CenterPrint( "No item to use", SCREEN_HEIGHT * 0.30, BIGCHAR_WIDTH );
+		} 
+		else 
+		{
+//			item = BG_FindItemForHoldable( itemNum );
+//			CG_CenterPrint( va("Use %s", item->pickup_name), SCREEN_HEIGHT * 0.30, BIGCHAR_WIDTH );
+		}
+	}
+
+	UseItem(itemNum);
+
+}
+
+#ifdef _IMMERSION
+qboolean CG_ConfigForce( int index, const char *&name, int &channel )
+{
+	qboolean result = qfalse;
+	const char *configstring = CG_ConfigString( CS_FORCES + index );
+
+	result = qboolean
+	(	configstring
+	&&	sscanf( configstring, "%d", &channel ) == 1
+	);
+
+	if ( result )
+	{
+		name = strchr( configstring, ',' ) + 1;
+		result = qboolean( name != (char *)1 );
+	}
+
+	return result;
+}
+#endif // _IMMERSION
+/*
+==============
+CG_EntityEvent
+
+An entity has an event value
+==============
+*/
+#define	DEBUGNAME(x) if(cg_debugEvents.integer){CG_Printf(x"\n");}
+void CG_EntityEvent( centity_t *cent, vec3_t position ) {
+	entityState_t	*es;
+	int				event;
+	vec3_t			axis[3];
+	const char		*s, *s2;
+	int				clientNum;
+	//clientInfo_t	*ci;
+
+	es = &cent->currentState;
+	event = es->event & ~EV_EVENT_BITS;
+
+	if ( cg_debugEvents.integer ) {
+		CG_Printf( "ent:%3i  event:%3i ", es->number, event );
+	}
+
+	if ( !event ) {
+		DEBUGNAME("ZEROEVENT");
+		return;
+	}
+
+	if ( !cent->gent )//|| !cent->gent->client )
+	{
+		return;
+	}
+
+	//ci = &cent->gent->client->clientInfo;
+	clientNum = cent->gent->s.number;
+
+	switch ( event ) {
+	//
+	// movement generated events
+	//
+/*	case EV_FOOTSTEP:
+		DEBUGNAME("EV_FOOTSTEP");
+		if (cg_footsteps.integer) {
+			if ( cent->gent && cent->gent->s.number == 0 && !cg.renderingThirdPerson )//!cg_thirdPerson.integer )
+			{//Everyone else has keyframed footsteps in animevents.cfg
+#ifdef _IMMERSION
+				int index = rand()&3;
+				cgi_S_StartSound (NULL, es->number, CHAN_BODY, cgs.media.footsteps[ FOOTSTEP_NORMAL ][index] );
+				cgi_FF_Start( cgs.media.footstepForces[ FOOTSTEP_NORMAL ][ index ], es->number );
+#else
+				cgi_S_StartSound (NULL, es->number, CHAN_BODY, 
+					cgs.media.footsteps[ FOOTSTEP_NORMAL ][rand()&3] );
+#endif // _IMMERSION
+			}
+		}
+		break;
+	case EV_FOOTSTEP_METAL:
+		DEBUGNAME("EV_FOOTSTEP_METAL");
+		if (cg_footsteps.integer) 
+		{
+			if ( cent->gent && cent->gent->s.number == 0 && !cg.renderingThirdPerson )
+			{//Everyone else has keyframed footsteps in animevents.cfg
+#ifdef _IMMERSION
+				int index = rand()&3;
+				cgi_S_StartSound (NULL, es->number, CHAN_BODY, cgs.media.footsteps[ FOOTSTEP_METAL ][index] );
+				cgi_FF_Start( cgs.media.footstepForces[ FOOTSTEP_METAL ][ index ], es->number );
+#else
+				cgi_S_StartSound (NULL, es->number, CHAN_BODY, cgs.media.footsteps[ FOOTSTEP_METAL ][rand()&3] );
+#endif // _IMMERSION
+			}
+		}
+		break;
+*/
+	case EV_FOOTSPLASH:
+		DEBUGNAME("EV_FOOTSPLASH");
+		if (cg_footsteps.integer) {
+#ifdef _IMMERSION
+			int index = rand()&3;
+			cgi_S_StartSound (NULL, es->number, CHAN_BODY, cgs.media.footsteps[ FOOTSTEP_SPLASH ][index] );
+			cgi_FF_Start( cgs.media.footstepForces[ FOOTSTEP_SPLASH ][ index ], es->number );
+#else
+			cgi_S_StartSound (NULL, es->number, CHAN_BODY, cgs.media.footsteps[ FOOTSTEP_SPLASH ][rand()&3] );
+#endif // _IMMERSION
+		}
+		break;
+	case EV_FOOTWADE:
+		DEBUGNAME("EV_FOOTWADE");
+		if (cg_footsteps.integer) {
+#ifdef _IMMERSION
+			int index = rand()&3;
+			cgi_S_StartSound (NULL, es->number, CHAN_BODY, cgs.media.footsteps[ FOOTSTEP_WADE ][index] );
+			cgi_FF_Start( cgs.media.footstepForces[ FOOTSTEP_WADE ][ index ], es->number );
+#else
+			cgi_S_StartSound (NULL, es->number, CHAN_BODY, cgs.media.footsteps[ FOOTSTEP_WADE ][rand()&3] );
+#endif // _IMMERSION
+		}
+		break;
+	case EV_SWIM:
+		DEBUGNAME("EV_SWIM");
+		if (cg_footsteps.integer) {
+#ifdef _IMMERSION
+				int index = rand()&3;
+				cgi_S_StartSound (NULL, es->number, CHAN_BODY, cgs.media.footsteps[ FOOTSTEP_SWIM ][index] );
+				cgi_FF_Start( cgs.media.footstepForces[ FOOTSTEP_SWIM ][ index ], es->number );
+#else
+			cgi_S_StartSound (NULL, es->number, CHAN_BODY, cgs.media.footsteps[ FOOTSTEP_SWIM ][rand()&3] );
+#endif // _IMMERSION
+		}
+		break;
+
+
+	case EV_FALL_SHORT:
+		DEBUGNAME("EV_FALL_SHORT");
+		cgi_S_StartSound( NULL, es->number, CHAN_AUTO, cgs.media.landSound  );
+#ifdef _IMMERSION
+		cgi_FF_Start( cgs.media.landForce, es->number );
+#endif // _IMMERSION
+		if ( clientNum == cg.predicted_player_state.clientNum ) {
+			// smooth landing z changes
+			cg.landChange = -8;
+			cg.landTime = cg.time;
+		}
+		//FIXME: maybe kick up some dust?
+		break;
+	case EV_FALL_MEDIUM:
+		DEBUGNAME("EV_FALL_MEDIUM");
+		// use normal pain sound - 
+		if ( g_entities[es->number].health <= 0 ) 
+		{//dead
+			cgi_S_StartSound( NULL, es->number, CHAN_AUTO, cgs.media.landSound  );
+#ifdef _IMMERSION
+			cgi_FF_Start( cgs.media.landForce, es->number );
+#endif // _IMMERSION
+		}
+		else if ( g_entities[es->number].s.weapon == WP_SABER 
+			|| (g_entities[es->number].client && (g_entities[es->number].client->ps.forcePowersKnown&(1<<FP_LEVITATION))) )
+		{//jedi or someone who has force jump (so probably took no damage)
+			CG_TryPlayCustomSound( NULL, es->number, CHAN_BODY, "*land1.wav", CS_BASIC );
+		}
+		else
+		{//still alive
+			CG_TryPlayCustomSound( NULL, es->number, CHAN_BODY, "*pain100.wav", CS_BASIC );
+		}
+		if ( clientNum == cg.predicted_player_state.clientNum ) {
+			// smooth landing z changes
+			cg.landChange = -16;
+			cg.landTime = cg.time;
+		}
+#ifdef _XBOX
+		cgi_FF_StartFX( fffx_FallingMedium );
+#endif
+		//FIXME: maybe kick up some dust?
+		break;
+	case EV_FALL_FAR:
+		DEBUGNAME("EV_FALL_FAR");
+		CG_TryPlayCustomSound( NULL, es->number, CHAN_BODY, "*land1.wav", CS_BASIC );
+		cgi_S_StartSound( NULL, es->number, CHAN_AUTO, cgs.media.landSound  );
+		cent->pe.painTime = cg.time;	// don't play a pain sound right after this
+		if ( clientNum == cg.predicted_player_state.clientNum ) {
+			// smooth landing z changes
+			cg.landChange = -24;
+			cg.landTime = cg.time;
+		}
+#ifdef _XBOX
+		cgi_FF_StartFX( fffx_FallingFar );
+#endif
+		//FIXME: maybe kick up some dust?
+		break;
+
+	case EV_STEP_4:
+	case EV_STEP_8:
+	case EV_STEP_12:
+	case EV_STEP_16:		// smooth out step up transitions
+		DEBUGNAME("EV_STEP");
+	{
+		float	oldStep;
+		int		delta;
+		int		step;
+
+		if ( clientNum != cg.predicted_player_state.clientNum ) {
+			break;
+		}
+		// if we are interpolating, we don't need to smooth steps
+		if ( cg_timescale.value >= 1.0f )
+		{
+			break;
+		}
+		// check for stepping up before a previous step is completed
+		delta = cg.time - cg.stepTime;
+		if (delta < STEP_TIME) {
+			oldStep = cg.stepChange * (STEP_TIME - delta) / STEP_TIME;
+		} else {
+			oldStep = 0;
+		}
+
+		// add this amount
+		step = 4 * (event - EV_STEP_4 + 1 );
+		cg.stepChange = oldStep + step;
+		if ( cg.stepChange > MAX_STEP_CHANGE ) {
+			cg.stepChange = MAX_STEP_CHANGE;
+		}
+		cg.stepTime = cg.time;
+		break;
+	}
+
+	case EV_JUMP:
+		DEBUGNAME("EV_JUMP");
+		CG_TryPlayCustomSound(NULL, es->number, CHAN_AUTO, "*jump1.wav", CS_BASIC );//CHAN_VOICE
+		break;
+
+	case EV_ROLL:
+		DEBUGNAME("EV_ROLL");
+		CG_TryPlayCustomSound(NULL, es->number, CHAN_AUTO, "*jump1.wav", CS_BASIC );//CHAN_VOICE
+		cgi_S_StartSound( NULL, es->number, CHAN_BODY, cgs.media.rollSound  );//CHAN_AUTO
+		//FIXME: need some sort of body impact on ground sound and maybe kick up some dust?
+		break;
+
+	case EV_LAVA_TOUCH:
+		DEBUGNAME("EV_LAVA_TOUCH");
+		cgi_S_StartSound (NULL, es->number, CHAN_AUTO, cgs.media.lavaInSound );
+#ifdef _IMMERSION
+		cgi_FF_Start( cgs.media.watrInSound, es->number );
+#endif // _IMMERSION
+		break;
+	
+	case EV_LAVA_LEAVE:
+		DEBUGNAME("EV_LAVA_LEAVE");
+		cgi_S_StartSound (NULL, es->number, CHAN_AUTO, cgs.media.lavaOutSound );
+#ifdef _IMMERSION
+		cgi_FF_Start( cgs.media.watrOutSound, es->number );
+#endif // _IMMERSION
+		break;
+	
+	case EV_LAVA_UNDER:
+		DEBUGNAME("EV_LAVA_UNDER");
+		cgi_S_StartSound (NULL, es->number, CHAN_AUTO, cgs.media.lavaUnSound );
+#ifdef _IMMERSION
+		cgi_FF_Start( cgs.media.watrUnSound, es->number );
+#endif // _IMMERSION
+		break;
+	
+	case EV_WATER_TOUCH:
+		DEBUGNAME("EV_WATER_TOUCH");
+		cgi_S_StartSound (NULL, es->number, CHAN_AUTO, cgs.media.watrInSound );
+#ifdef _IMMERSION
+		cgi_FF_Start( cgs.media.watrInSound, es->number );
+#endif // _IMMERSION
+		break;
+	
+	case EV_WATER_LEAVE:
+		DEBUGNAME("EV_WATER_LEAVE");
+		cgi_S_StartSound (NULL, es->number, CHAN_AUTO, cgs.media.watrOutSound );
+#ifdef _IMMERSION
+		cgi_FF_Start( cgs.media.watrOutSound, es->number );
+#endif // _IMMERSION
+		break;
+	
+	case EV_WATER_UNDER:
+		DEBUGNAME("EV_WATER_UNDER");
+		cgi_S_StartSound (NULL, es->number, CHAN_AUTO, cgs.media.watrUnSound );
+#ifdef _IMMERSION
+		cgi_FF_Start( cgs.media.watrUnSound, es->number );
+#endif // _IMMERSION
+		break;
+	
+	case EV_WATER_CLEAR:
+		DEBUGNAME("EV_WATER_CLEAR");
+		CG_TryPlayCustomSound(NULL, es->number, CHAN_AUTO, "*gasp.wav", CS_BASIC );
+		break;
+
+	case EV_WATER_GURP1:
+	case EV_WATER_GURP2:
+		DEBUGNAME("EV_WATER_GURPx");
+		CG_TryPlayCustomSound(NULL, es->number, CHAN_AUTO, va("*gurp%d.wav",event-EV_WATER_GURP1+1), CS_BASIC );
+		break;
+
+	case EV_WATER_DROWN:
+		DEBUGNAME("EV_WATER_DROWN");
+		CG_TryPlayCustomSound(NULL, es->number, CHAN_AUTO, "*drown.wav", CS_BASIC );
+		break;
+
+	case EV_ITEM_PICKUP:
+		DEBUGNAME("EV_ITEM_PICKUP");
+		{
+			gitem_t	*item;
+			int		index;
+			qboolean bHadItem = qfalse;
+					
+			index = es->eventParm;		// player predicted
+
+			if ( (char)index < 0 ) 
+			{
+				index = -(char)index;
+				bHadItem = qtrue;
+			}
+
+			if ( index >= bg_numItems ) {
+				break;
+			}
+			item = &bg_itemlist[ index ];
+			cgi_S_StartSound (NULL, es->number, CHAN_AUTO,	cgi_S_RegisterSound( item->pickup_sound ) );
+#ifdef _IMMERSION
+			cgi_FF_Start( cgi_FF_Register( item->pickup_force, FF_CHANNEL_TOUCH ), es->number );
+#endif // _IMMERSION
+
+			// show icon and name on status bar
+			if ( es->number == cg.snap->ps.clientNum ) {
+				CG_ItemPickup( index, bHadItem );
+			}
+		}
+		break;
+
+	//
+	// weapon events
+	//
+	case EV_NOAMMO:
+		DEBUGNAME("EV_NOAMMO");
+		//cgi_S_StartSound (NULL, es->number, CHAN_AUTO, cgs.media.noAmmoSound );
+		if ( es->number == cg.snap->ps.clientNum ) {
+			CG_OutOfAmmoChange();
+		}
+		break;
+	case EV_CHANGE_WEAPON:
+		DEBUGNAME("EV_CHANGE_WEAPON");
+		if ( es->weapon == WP_SABER )
+		{
+			/*
+			if ( !cent->gent || !cent->gent->client || (cent->currentState.saberInFlight == qfalse && cent->currentState.saberActive == qtrue) )
+			{
+				cgi_S_StartSound (NULL, es->number, CHAN_AUTO, cgi_S_RegisterSound( "sound/weapons/saber/saberoffquick.wav" ) );
+			}
+			*/
+			if ( cent->gent && cent->gent->client )
+			{
+				//if ( cent->gent->client->ps.saberInFlight )
+				{//if it's not in flight or lying around, turn it off!
+					cent->currentState.saberActive = qfalse;
+				}
+			}
+		}
+
+		// FIXME: if it happens that you don't want the saber to play the switch sounds, feel free to modify this bit.
+		if ( weaponData[cg.weaponSelect].selectSnd[0] )
+		{
+			// custom select sound
+			cgi_S_StartSound (NULL, es->number, CHAN_AUTO, cgi_S_RegisterSound( weaponData[cg.weaponSelect].selectSnd ));
+#ifdef _IMMERSION
+			cgi_FF_Start( cgi_FF_Register( weaponData[cg.weaponSelect].selectFrc, FF_CHANNEL_WEAPON ), es->number );
+#endif // _IMMERSION
+		}
+		else
+		{
+			// generic sound
+			cgi_S_StartSound (NULL, es->number, CHAN_AUTO, cgs.media.selectSound );
+#ifdef _IMMERSION
+			cgi_FF_Start( cgs.media.selectForce, es->number );
+#endif // _IMMERSION
+		}
+		break;
+
+	case EV_FIRE_WEAPON:
+		DEBUGNAME("EV_FIRE_WEAPON");
+		CG_FireWeapon( cent, qfalse );
+		break;
+
+	case EV_ALT_FIRE:
+		DEBUGNAME("EV_ALT_FIRE");
+		CG_FireWeapon( cent, qtrue );
+		break;
+
+	case EV_DISRUPTOR_MAIN_SHOT:
+		DEBUGNAME("EV_DISRUPTOR_MAIN_SHOT");
+		FX_DisruptorMainShot( cent->currentState.origin2, cent->lerpOrigin ); 
+		break;
+
+	case EV_DISRUPTOR_SNIPER_SHOT:
+		DEBUGNAME("EV_DISRUPTOR_SNIPER_SHOT");
+		FX_DisruptorAltShot( cent->currentState.origin2, cent->lerpOrigin, cent->gent->alt_fire );
+		break;
+
+	case EV_DISRUPTOR_SNIPER_MISS:
+		DEBUGNAME("EV_DISRUPTOR_SNIPER_MISS");
+		FX_DisruptorAltMiss( cent->lerpOrigin, cent->gent->pos1 );
+		break;
+
+	case EV_DEMP2_ALT_IMPACT:
+		FX_DEMP2_AltDetonate( cent->lerpOrigin, es->eventParm );
+		break;
+
+	case EV_CONC_ALT_SHOT:
+		DEBUGNAME("EV_CONC_ALT_SHOT");
+		FX_ConcAltShot( cent->currentState.origin2, cent->lerpOrigin );
+		break;
+
+	case EV_CONC_ALT_MISS:
+		DEBUGNAME("EV_CONC_ALT_MISS");
+		FX_ConcAltMiss( cent->lerpOrigin, cent->gent->pos1 );
+		break;
+
+//	case EV_POWERUP_SEEKER_FIRE:
+//		DEBUGNAME("EV_POWERUP_SEEKER_FIRE");
+//		CG_FireSeeker( cent ); 
+//		break;
+
+	case EV_POWERUP_BATTLESUIT:
+		DEBUGNAME("EV_POWERUP_BATTLESUIT");
+		if ( es->number == cg.snap->ps.clientNum ) {
+			cg.powerupActive = PW_BATTLESUIT;
+			cg.powerupTime = cg.time;
+		}
+		//cgi_S_StartSound (NULL, es->number, CHAN_ITEM, cgs.media.invulnoProtectSound );
+		break;
+
+	case EV_KOTHOS_BEAM:
+		DEBUGNAME("EV_KOTHOS_BEAM");
+		if ( Q_irand( 0, 1 ) )
+		{
+			FX_KothosBeam( cg_entities[cent->currentState.otherEntityNum].gent->client->renderInfo.handRPoint, cg_entities[cent->currentState.otherEntityNum2].lerpOrigin ); 
+		}
+		else
+		{
+			FX_KothosBeam( cg_entities[cent->currentState.otherEntityNum].gent->client->renderInfo.handLPoint, cg_entities[cent->currentState.otherEntityNum2].lerpOrigin ); 
+		}
+		break;
+	//=================================================================
+
+	//
+	// other events
+	//
+	case EV_REPLICATOR:
+		DEBUGNAME("EV_REPLICATOR");
+//		FX_Replicator( cent, position );
+		break;
+
+	case EV_BATTERIES_CHARGED:
+		cg.batteryChargeTime = cg.time + 3000;
+		cgi_S_StartSound( vec3_origin, es->number, CHAN_AUTO, cgs.media.batteryChargeSound );
+		break;
+
+	case EV_DISINTEGRATION:
+		{
+			DEBUGNAME("EV_DISINTEGRATION");
+			qboolean makeNotSolid = qfalse;
+			int disintPW = es->eventParm;
+			int disintEffect = 0;
+			int disintLength = 0;
+			qhandle_t disintSound1 = NULL;
+			qhandle_t disintSound2 = NULL;
+			qhandle_t disintSound3 = NULL;
+
+			switch( disintPW )
+			{
+			case PW_DISRUPTION:// sniper rifle
+				disintEffect = EF_DISINTEGRATION;//ef_
+				disintSound1 = cgs.media.disintegrateSound;//with scream
+				disintSound2 = cgs.media.disintegrate2Sound;//no scream
+				disintSound3 = cgs.media.disintegrate3Sound;//with inhuman scream
+				disintLength = 2000;
+				makeNotSolid = qtrue;
+				break;
+/*			case PW_SHOCKED:// arc welder
+				disintEffect = EF_DISINT_1;//ef_
+				disintSound1 = NULL;//with scream
+				disintSound2 = NULL;//no scream
+				disintSound3 = NULL;//with inhuman scream
+				disintLength = 4000;
+				break;
+*/
+			default:
+				return;
+				break;
+			}
+
+			if ( cent->gent->owner )
+			{
+				cent->gent->owner->fx_time = cg.time;
+				if ( cent->gent->owner->client )
+				{
+					if ( disintSound1 && disintSound2 )
+					{//play an extra sound
+					/*
+						if ( cent->gent->owner->client->playerTeam == TEAM_STARFLEET ||
+								cent->gent->owner->client->playerTeam == TEAM_SCAVENGERS ||
+								cent->gent->owner->client->playerTeam == TEAM_MALON ||
+								cent->gent->owner->client->playerTeam == TEAM_IMPERIAL ||
+								cent->gent->owner->client->playerTeam == TEAM_HIROGEN ||
+								cent->gent->owner->client->playerTeam == TEAM_DISGUISE ||
+								cent->gent->owner->client->playerTeam == TEAM_KLINGON )
+					*/
+						// listed all the non-humanoids, because there's a lot more humanoids
+						class_t	npc_class = cent->gent->owner->client->NPC_class;
+						if( npc_class != CLASS_ATST && npc_class != CLASS_GONK &&
+							npc_class != CLASS_INTERROGATOR && npc_class != CLASS_MARK1 &&
+							npc_class != CLASS_MARK2 && npc_class != CLASS_MOUSE &&
+							npc_class != CLASS_PROBE && npc_class != CLASS_PROTOCOL &&
+							npc_class != CLASS_R2D2 && npc_class != CLASS_R5D2 &&
+							npc_class != CLASS_SEEKER && npc_class != CLASS_SENTRY)
+						{//Only the humanoids scream
+							cgi_S_StartSound ( NULL, cent->gent->owner->s.number, CHAN_VOICE, disintSound1 );
+						}
+						// no more forge or 8472
+					//	else if ( cent->gent->owner->client->playerTeam == TEAM_FORGE ||
+					//			cent->gent->owner->client->playerTeam == TEAM_8472 )
+					//	{
+					//		cgi_S_StartSound ( NULL, cent->gent->s.number, CHAN_VOICE, disintSound3 );
+					//	}
+						else
+						{
+							cgi_S_StartSound ( NULL, cent->gent->s.number, CHAN_AUTO, disintSound2 );
+						}
+					}
+					cent->gent->owner->s.powerups |= ( 1 << disintPW );
+					cent->gent->owner->client->ps.powerups[disintPW] = cg.time + disintLength;
+
+					// Things that are being disintegrated should probably not be solid...
+					if ( makeNotSolid && cent->gent->owner->client->playerTeam != TEAM_NEUTRAL )
+					{
+						cent->gent->contents = CONTENTS_NONE;
+					}
+				}
+				else
+				{
+					cent->gent->owner->s.eFlags = disintEffect;//FIXME: |= ?
+					cent->gent->owner->delay = cg.time + disintLength;
+				}
+			}
+		}
+		break;
+
+	// This does not necessarily have to be from a grenade...
+	case EV_GRENADE_BOUNCE:
+		DEBUGNAME("EV_GRENADE_BOUNCE");
+		CG_BounceEffect( cent, es->weapon, position, cent->gent->pos1 );
+		break;
+
+	//
+	// missile impacts
+	//
+
+	case EV_MISSILE_STICK:
+		DEBUGNAME("EV_MISSILE_STICK");
+		CG_MissileStick( cent, es->weapon, position );
+		break;
+
+	case EV_MISSILE_HIT:
+		DEBUGNAME("EV_MISSILE_HIT");
+		CG_MissileHitPlayer( cent, es->weapon, position, cent->gent->pos1, cent->gent->alt_fire );
+		break;
+
+	case EV_MISSILE_MISS:
+		DEBUGNAME("EV_MISSILE_MISS");
+		CG_MissileHitWall( cent, es->weapon, position, cent->gent->pos1, cent->gent->alt_fire );
+		break;
+
+	case EV_BMODEL_SOUND:
+		DEBUGNAME("EV_BMODEL_SOUND");
+		cgi_S_StartSound( NULL, es->number, CHAN_AUTO, es->eventParm );
+		break;
+
+	case EV_GENERAL_SOUND:
+		DEBUGNAME("EV_GENERAL_SOUND");
+		if ( cgs.sound_precache[ es->eventParm ] ) 
+		{
+			cgi_S_StartSound (NULL, es->number, CHAN_AUTO, cgs.sound_precache[ es->eventParm ] );
+		} 
+		else 
+		{
+			s = CG_ConfigString( CS_SOUNDS + es->eventParm );
+			CG_TryPlayCustomSound(NULL, es->number, CHAN_AUTO, s, CS_BASIC );
+		}
+		break;
+
+	case EV_GLOBAL_SOUND:	// play from the player's head so it never diminishes
+		DEBUGNAME("EV_GLOBAL_SOUND");
+		if ( cgs.sound_precache[ es->eventParm ] ) {
+			cgi_S_StartSound (NULL, cg.snap->ps.clientNum, CHAN_AUTO, cgs.sound_precache[ es->eventParm ] );
+		} else {
+			s = CG_ConfigString( CS_SOUNDS + es->eventParm );
+			CG_TryPlayCustomSound( NULL, cg.snap->ps.clientNum, CHAN_AUTO, s, CS_BASIC );
+		}
+		break;
+
+#ifdef _IMMERSION
+	case EV_ENTITY_FORCE:				// Plays force on entity
+		DEBUGNAME("EV_ENTITY_FORCE");
+		if ( !cgs.force_precache[ es->eventParm ] )
+		{
+			const char *name;
+			int channel;
+			if ( CG_ConfigForce( es->eventParm, name, channel ) )
+			{
+				cgs.force_precache[ es->eventParm ] = cgi_FF_Register( name, channel );
+			}
+		}
+		cgi_FF_Start( cgs.force_precache[ es->eventParm ], es->number );
+		break;
+
+	case EV_GLOBAL_FORCE:
+	case EV_AREA_FORCE:
+		DEBUGNAME("EV_AREA_FORCE");	// Plays force for anyone
+		if ( !cgs.force_precache[ es->eventParm ] )
+		{
+			const char *name;
+			int channel;
+			if ( CG_ConfigForce( es->eventParm, name, channel ) )
+			{
+				cgs.force_precache[ es->eventParm ] = cgi_FF_Register( name, channel );
+			}
+		}
+		cgi_FF_Start( cgs.force_precache[ es->eventParm ], es->number );
+		break;
+
+	case EV_FORCE_STOP:
+		DEBUGNAME("EV_FORCE_STOP");
+		if ( es->eventParm < 0 )
+		{
+			cgi_FF_StopAll( );
+		}
+		else if ( es->eventParm < MAX_FORCES && cgs.force_precache[ es->eventParm ] )
+		{
+			cgi_FF_Stop( cgs.force_precache[ es->eventParm ], es->number );
+		}
+		
+		break;
+#endif // _IMMERSION
+	case EV_DRUGGED:
+		DEBUGNAME("EV_DRUGGED");
+		if ( cent->gent && cent->gent->owner && cent->gent->owner->s.number == 0 )
+		{
+			// Only allow setting up the wonky vision on the player..do it for 10 seconds...must be synchronized with calcs done in cg_view.  Just search for cg.wonkyTime to find 'em.
+			cg.wonkyTime = cg.time + 10000;
+		}
+		break;
+
+	case EV_PAIN:
+		{
+		char	*snd;
+		const int health = es->eventParm;
+
+		if ( cent->gent && cent->gent->NPC && (cent->gent->NPC->aiFlags & NPCAI_DIE_ON_IMPACT) )
+		{
+			return;
+		}
+		//FIXME: don't do this if we're falling to our deaths...
+		DEBUGNAME("EV_PAIN");
+		// don't do more than two pain sounds a second
+		if ( cg.time - cent->pe.painTime < 500 ) {
+			return;
+		}
+
+		if ( health < 25 ) {
+			snd = "*pain100.wav";
+		} else if ( health < 50 ) {
+			snd = "*pain75.wav";
+		} else if ( health < 75 ) {
+			snd = "*pain50.wav";
+		} else {
+			snd = "*pain25.wav";
+		}
+		CG_TryPlayCustomSound( NULL, es->number, CHAN_VOICE, snd, CS_BASIC );
+
+		// save pain time for programitic twitch animation
+		cent->pe.painTime = cg.time;
+		cent->pe.painDirection ^= 1;
+		}
+		break;
+
+	case EV_DEATH1:
+	case EV_DEATH2:
+	case EV_DEATH3:
+		DEBUGNAME("EV_DEATHx");
+		/*
+		if ( cent->gent && cent->gent->NPC && (cent->gent->NPC->aiFlags & NPCAI_DIE_ON_IMPACT) )
+		{
+			return;
+		}
+		*/
+		CG_TryPlayCustomSound( NULL, es->number, CHAN_VOICE, va("*death%i.wav", event - EV_DEATH1 + 1), CS_BASIC );
+		break;
+
+	// Called by the FxRunner entity...usually for Environmental FX Events
+	case EV_PLAY_EFFECT:
+		DEBUGNAME("EV_PLAY_EFFECT");
+		{
+			const bool portalEnt = !!es->isPortalEnt; //the fxrunner spawning this effect is within a skyportal, so only render this effect within that portal.
+
+			s = CG_ConfigString( CS_EFFECTS + es->eventParm );
+	// Ghoul2 Insert Start
+			if (es->boltInfo != 0)
+			{
+				const bool isRelative = !!es->weapon;
+				theFxScheduler.PlayEffect( s, cent->lerpOrigin, axis, es->boltInfo, -1, portalEnt, es->loopSound, isRelative );	//loopSound 0 = not looping, 1 for infinite, else duration
+			}
+			else
+			{
+				VectorCopy( cent->gent->pos3, axis[0] );
+				VectorCopy( cent->gent->pos4, axis[1] );
+				CrossProduct( axis[0], axis[1], axis[2] );
+
+				// the entNum the effect may be attached to
+	#ifdef _IMMERSION
+				if ( es->saberActive )
+				{
+					theFxScheduler.PlayEffect( s, cent->lerpOrigin, axis, -1, FF_CLIENT( es->otherEntityNum ), portalEnt );
+				}
+				else
+	#endif // _IMMERSION
+				if ( es->otherEntityNum )
+				{
+					theFxScheduler.PlayEffect( s, cent->lerpOrigin, axis, -1, es->otherEntityNum, portalEnt );
+				}
+				else
+				{
+					theFxScheduler.PlayEffect( s, cent->lerpOrigin, axis, -1, -1, portalEnt );
+				}
+			}
+		}
+// Ghoul2 Insert End
+		break;
+
+		// play an effect bolted onto a muzzle
+	case EV_PLAY_MUZZLE_EFFECT:
+		DEBUGNAME("EV_PLAY_MUZZLE_EFFECT");
+		s = CG_ConfigString( CS_EFFECTS + es->eventParm );
+
+		theFxScheduler.PlayEffect( s, es->otherEntityNum );
+		break;
+
+	case EV_STOP_EFFECT:
+		DEBUGNAME("EV_STOP_EFFECT");
+		{
+			bool portalEnt = false;
+
+			if ( es->isPortalEnt )
+			{ //the fxrunner spawning this effect is within a skyportal, so only render this effect within that portal.
+				portalEnt = true;
+			}
+
+			s = CG_ConfigString( CS_EFFECTS + es->eventParm );
+			if ( es->boltInfo != 0 )
+			{
+				theFxScheduler.StopEffect( s, es->boltInfo, portalEnt );
+			}
+		}
+		break;
+
+	case EV_TARGET_BEAM_DRAW:
+		DEBUGNAME("EV_TARGET_BEAM_DRAW");
+		if ( cent->gent )
+		{
+			s = CG_ConfigString( CS_EFFECTS + es->eventParm );
+
+			if ( s && s[0] )
+			{
+				if ( cent->gent->delay )
+				{
+					s2 = CG_ConfigString( CS_EFFECTS + cent->gent->delay );
+				}
+				else
+				{
+					s2 = NULL;
+				}
+
+				CG_DrawTargetBeam( cent->lerpOrigin, cent->gent->s.origin2, cent->gent->pos1, s, s2 );
+			}
+/*			else
+			{
+				int gack = 0; // this is bad if it get's here
+			}
+*/
+		}
+		break;
+
+	case EV_ANGER1:	//Say when acquire an enemy when didn't have one before
+	case EV_ANGER2:
+	case EV_ANGER3:
+		DEBUGNAME("EV_ANGERx");
+		CG_TryPlayCustomSound( NULL, es->number, CHAN_VOICE, va("*anger%i.wav", event - EV_ANGER1 + 1), CS_COMBAT );
+		break;
+
+	case EV_VICTORY1:	//Say when killed an enemy
+	case EV_VICTORY2:
+	case EV_VICTORY3:
+		DEBUGNAME("EV_VICTORYx");
+		CG_TryPlayCustomSound( NULL, es->number, CHAN_VOICE, va("*victory%i.wav", event - EV_VICTORY1 + 1), CS_COMBAT );
+		break;
+
+	case EV_CONFUSE1:	//Say when confused
+	case EV_CONFUSE2:
+	case EV_CONFUSE3:
+		DEBUGNAME("EV_CONFUSEDx");
+		CG_TryPlayCustomSound( NULL, es->number, CHAN_VOICE, va("*confuse%i.wav", event - EV_CONFUSE1 + 1), CS_COMBAT );
+		break;
+
+	case EV_PUSHED1:	//Say when pushed
+	case EV_PUSHED2:
+	case EV_PUSHED3:
+		DEBUGNAME("EV_PUSHEDx");
+		CG_TryPlayCustomSound( NULL, es->number, CHAN_VOICE, va("*pushed%i.wav", event - EV_PUSHED1 + 1), CS_COMBAT );
+		break;
+
+	case EV_CHOKE1:	//Say when choking
+	case EV_CHOKE2:
+	case EV_CHOKE3:
+		DEBUGNAME("EV_CHOKEx");
+		CG_TryPlayCustomSound( NULL, es->number, CHAN_VOICE, va("*choke%i.wav", event - EV_CHOKE1 + 1), CS_COMBAT );
+		break;
+
+	case EV_FFWARN:	//Warn ally to stop shooting you
+		DEBUGNAME("EV_FFWARN");
+		CG_TryPlayCustomSound( NULL, es->number, CHAN_VOICE, "*ffwarn.wav", CS_COMBAT );
+		break;
+
+	case EV_FFTURN:	//Turn on ally after being shot by them
+		DEBUGNAME("EV_FFTURN");
+		CG_TryPlayCustomSound( NULL, es->number, CHAN_VOICE, "*ffturn.wav", CS_COMBAT );
+		break;
+
+	//extra sounds for ST
+	case EV_CHASE1:
+	case EV_CHASE2:
+	case EV_CHASE3:
+		DEBUGNAME("EV_CHASEx");
+		CG_TryPlayCustomSound( NULL, es->number, CHAN_VOICE, va("*chase%i.wav", event - EV_CHASE1 + 1), CS_EXTRA );
+		break;
+	case EV_COVER1:
+	case EV_COVER2:
+	case EV_COVER3:
+	case EV_COVER4:
+	case EV_COVER5:
+		DEBUGNAME("EV_COVERx");
+		CG_TryPlayCustomSound( NULL, es->number, CHAN_VOICE, va("*cover%i.wav", event - EV_COVER1 + 1), CS_EXTRA );
+		break;
+	case EV_DETECTED1:
+	case EV_DETECTED2:
+	case EV_DETECTED3:
+	case EV_DETECTED4:
+	case EV_DETECTED5:
+		DEBUGNAME("EV_DETECTEDx");
+		CG_TryPlayCustomSound( NULL, es->number, CHAN_VOICE, va("*detected%i.wav", event - EV_DETECTED1 + 1), CS_EXTRA );
+		break;
+	case EV_GIVEUP1:
+	case EV_GIVEUP2:
+	case EV_GIVEUP3:
+	case EV_GIVEUP4:
+		DEBUGNAME("EV_GIVEUPx");
+		CG_TryPlayCustomSound( NULL, es->number, CHAN_VOICE, va("*giveup%i.wav", event - EV_GIVEUP1 + 1), CS_EXTRA );
+		break;
+	case EV_LOOK1:
+	case EV_LOOK2:
+		DEBUGNAME("EV_LOOKx");
+		CG_TryPlayCustomSound( NULL, es->number, CHAN_VOICE, va("*look%i.wav", event - EV_LOOK1 + 1), CS_EXTRA );
+		break;
+	case EV_LOST1:
+		DEBUGNAME("EV_LOST1");
+		CG_TryPlayCustomSound( NULL, es->number, CHAN_VOICE, "*lost1.wav", CS_EXTRA );
+		break;
+	case EV_OUTFLANK1:
+	case EV_OUTFLANK2:
+		DEBUGNAME("EV_OUTFLANKx");
+		CG_TryPlayCustomSound( NULL, es->number, CHAN_VOICE, va("*outflank%i.wav", event - EV_OUTFLANK1 + 1), CS_EXTRA );
+		break;
+	case EV_ESCAPING1:
+	case EV_ESCAPING2:
+	case EV_ESCAPING3:
+		DEBUGNAME("EV_ESCAPINGx");
+		CG_TryPlayCustomSound( NULL, es->number, CHAN_VOICE, va("*escaping%i.wav", event - EV_ESCAPING1 + 1), CS_EXTRA );
+		break;
+	case EV_SIGHT1:
+	case EV_SIGHT2:
+	case EV_SIGHT3:
+		DEBUGNAME("EV_SIGHTx");
+		CG_TryPlayCustomSound( NULL, es->number, CHAN_VOICE, va("*sight%i.wav", event - EV_SIGHT1 + 1), CS_EXTRA );
+		break;
+	case EV_SOUND1:
+	case EV_SOUND2:
+	case EV_SOUND3:
+		DEBUGNAME("EV_SOUNDx");
+		CG_TryPlayCustomSound( NULL, es->number, CHAN_VOICE, va("*sound%i.wav", event - EV_SOUND1 + 1), CS_EXTRA );
+		break;
+	case EV_SUSPICIOUS1:
+	case EV_SUSPICIOUS2:
+	case EV_SUSPICIOUS3:
+	case EV_SUSPICIOUS4:
+	case EV_SUSPICIOUS5:
+		DEBUGNAME("EV_SUSPICIOUSx");
+		CG_TryPlayCustomSound( NULL, es->number, CHAN_VOICE, va("*suspicious%i.wav", event - EV_SUSPICIOUS1 + 1), CS_EXTRA );
+		break;
+	//extra sounds for Jedi
+	case EV_COMBAT1:
+	case EV_COMBAT2:
+	case EV_COMBAT3:
+		DEBUGNAME("EV_COMBATx");
+		CG_TryPlayCustomSound( NULL, es->number, CHAN_VOICE, va("*combat%i.wav", event - EV_COMBAT1 + 1), CS_JEDI );
+		break;
+	case EV_JDETECTED1:
+	case EV_JDETECTED2:
+	case EV_JDETECTED3:
+		DEBUGNAME("EV_JDETECTEDx");
+		CG_TryPlayCustomSound( NULL, es->number, CHAN_VOICE, va("*jdetected%i.wav", event - EV_JDETECTED1 + 1), CS_JEDI );
+		break;
+	case EV_TAUNT1:
+	case EV_TAUNT2:
+	case EV_TAUNT3:
+		DEBUGNAME("EV_TAUNTx");
+		CG_TryPlayCustomSound( NULL, es->number, CHAN_VOICE, va("*taunt%i.wav", event - EV_TAUNT1 + 1), CS_JEDI );
+		break;
+	case EV_JCHASE1:
+	case EV_JCHASE2:
+	case EV_JCHASE3:
+		DEBUGNAME("EV_JCHASEx");
+		CG_TryPlayCustomSound( NULL, es->number, CHAN_VOICE, va("*jchase%i.wav", event - EV_JCHASE1 + 1), CS_JEDI );
+		break;
+	case EV_JLOST1:
+	case EV_JLOST2:
+	case EV_JLOST3:
+		DEBUGNAME("EV_JLOSTx");
+		CG_TryPlayCustomSound( NULL, es->number, CHAN_VOICE, va("*jlost%i.wav", event - EV_JLOST1 + 1), CS_JEDI );
+		break;
+	case EV_DEFLECT1:
+	case EV_DEFLECT2:
+	case EV_DEFLECT3:
+		DEBUGNAME("EV_DEFLECTx");
+		CG_TryPlayCustomSound( NULL, es->number, CHAN_VOICE, va("*deflect%i.wav", event - EV_DEFLECT1 + 1), CS_JEDI );
+		break;
+	case EV_GLOAT1:
+	case EV_GLOAT2:
+	case EV_GLOAT3:
+		DEBUGNAME("EV_GLOATx");
+		CG_TryPlayCustomSound( NULL, es->number, CHAN_VOICE, va("*gloat%i.wav", event - EV_GLOAT1 + 1), CS_JEDI );
+		break;
+	case EV_PUSHFAIL:
+		DEBUGNAME("EV_PUSHFAIL");
+		CG_TryPlayCustomSound( NULL, es->number, CHAN_VOICE, "*pushfail.wav", CS_JEDI );
+		break;
+
+	case EV_USE_FORCE:
+		DEBUGNAME("EV_USE_FORCEITEM");
+		CG_UseForce( cent );
+		break;
+
+	case EV_USE_ITEM:
+		DEBUGNAME("EV_USE_ITEM");
+		CG_UseItem( cent );
+		break;
+
+	case EV_USE_INV_BINOCULARS:
+		DEBUGNAME("EV_USE_INV_BINOCULARS");
+		UseItem(INV_ELECTROBINOCULARS );
+		break;
+
+	case EV_USE_INV_BACTA:
+		DEBUGNAME("EV_USE_INV_BACTA");
+		UseItem(INV_BACTA_CANISTER );
+		break;
+
+	case EV_USE_INV_SEEKER:
+		DEBUGNAME("EV_USE_INV_SEEKER");
+		UseItem(INV_SEEKER );
+		break;
+
+	case EV_USE_INV_LIGHTAMP_GOGGLES:
+		DEBUGNAME("EV_USE_INV_LIGHTAMP_GOGGLES");
+		UseItem(INV_LIGHTAMP_GOGGLES );
+		break;
+	
+	case EV_USE_INV_SENTRY:
+		DEBUGNAME("EV_USE_INV_SENTRY");
+		UseItem(INV_SENTRY );
+		break;
+	
+	case EV_DEBUG_LINE:
+		DEBUGNAME("EV_DEBUG_LINE");
+		CG_TestLine(position, es->origin2, es->time, (unsigned int)(es->time2), es->weapon);
+		break;
+
+	default:
+		DEBUGNAME("UNKNOWN");
+		CG_Error( "Unknown event: %i", event );
+		break;
+	}
+
+}
+
+
+/*
+==============
+CG_CheckEvents
+
+==============
+*/
+void CG_CheckEvents( centity_t *cent ) {
+	// check for event-only entities
+	if ( cent->currentState.eType > ET_EVENTS ) {
+		if ( cent->previousEvent ) {
+			return;	// already fired
+		}
+		cent->previousEvent = 1;
+
+		cent->currentState.event = cent->currentState.eType - ET_EVENTS;
+	} else {
+		// check for events riding with another entity
+		if ( cent->currentState.event == cent->previousEvent ) {
+			return;
+		}
+		cent->previousEvent = cent->currentState.event;
+		if ( ( cent->currentState.event & ~EV_EVENT_BITS ) == 0 ) {
+			return;
+		}
+	}
+
+	// calculate the position at exactly the frame time
+	EvaluateTrajectory( &cent->currentState.pos, cg.snap->serverTime, cent->lerpOrigin );
+	CG_SetEntitySoundPosition( cent );
+
+	CG_EntityEvent( cent, cent->lerpOrigin );
+}
+
diff --git a/code/cgame/cg_headers.cpp b/code/cgame/cg_headers.cpp
new file mode 100644
index 0000000..854ae34
--- /dev/null
+++ b/code/cgame/cg_headers.cpp
@@ -0,0 +1,3 @@
+// this line must stay at top so the whole PCH thing works...
+#include "cg_headers.h"
+
diff --git a/code/cgame/cg_headers.h b/code/cgame/cg_headers.h
new file mode 100644
index 0000000..c5ea69f
--- /dev/null
+++ b/code/cgame/cg_headers.h
@@ -0,0 +1,20 @@
+// Precompiled header file for the client game
+
+#include "cg_local.h"
+
+// No PCH at all on Xbox build, we just include everything. Does this slow
+// down builds? Somewhat. But then again, if I do change headers, I have to
+// tolerate VS.net's piss poor dependency system that requires my to manually
+// delete the .pch for the PC version to work at all. So, I'll live.
+#ifdef _XBOX
+	#include "../game/g_local.h"
+	#include "../game/g_functions.h"
+	#include "../game/b_local.h"
+#endif
+
+//#include "CGEntity.h"
+//#include "../game/SpawnSystem.h"
+//#include "../game/EntitySystem.h"
+//#include "../game/CScheduleSystem.h"
+
+// end
diff --git a/code/cgame/cg_info.cpp b/code/cgame/cg_info.cpp
new file mode 100644
index 0000000..911b737
--- /dev/null
+++ b/code/cgame/cg_info.cpp
@@ -0,0 +1,860 @@
+// this line must stay at top so the whole PCH thing works...
+#include "cg_headers.h"
+
+//#include "cg_local.h"
+#include "cg_media.h"
+#include "..\game\objectives.h"
+
+
+// For printing objectives
+static const short objectiveStartingYpos = 75;		// Y starting position for objective text
+static const short objectiveStartingXpos = 60;		// X starting position for objective text
+static const int objectiveTextBoxWidth = 500;		// Width (in pixels) of text box
+static const int objectiveTextBoxHeight = 300;		// Height (in pixels) of text box
+
+const char *showLoadPowersName[] = 
+{
+	"SP_INGAME_HEAL2",
+	"SP_INGAME_JUMP2",
+	"SP_INGAME_SPEED2",
+	"SP_INGAME_PUSH2",
+	"SP_INGAME_PULL2",
+	"SP_INGAME_MINDTRICK2",
+	"SP_INGAME_GRIP2",
+	"SP_INGAME_LIGHTNING2",
+	"SP_INGAME_SABER_THROW2",
+	"SP_INGAME_SABER_OFFENSE2",
+	"SP_INGAME_SABER_DEFENSE2",
+	NULL,
+};
+
+#define MAX_OBJ_GRAPHICS 4
+#define OBJ_GRAPHIC_SIZE 240
+int obj_graphics[MAX_OBJ_GRAPHICS];
+
+qboolean CG_ForcePower_Valid(int forceKnownBits, int index);
+
+/*
+====================
+ObjectivePrint_Line
+
+Print a single mission objective
+====================
+*/
+static void ObjectivePrint_Line(const int color, const int objectIndex, int &missionYcnt)
+{
+	char *str,*strBegin;
+	int y,pixelLen,charLen,i;
+	const int maxHoldText = 1024;
+	char holdText[maxHoldText];
+	char finalText[2048];
+	qhandle_t	graphic;
+
+	int iYPixelsPerLine = cgi_R_Font_HeightPixels(cgs.media.qhFontMedium, 1.0f);
+
+	cgi_SP_GetStringTextString( va("OBJECTIVES_%s",objectiveTable[objectIndex].name) , finalText, sizeof(finalText) );
+
+	// A hack to be able to count prisoners 
+	if (objectIndex==T2_RANCOR_OBJ5)
+	{
+		char value[64];
+		int	currTotal, minTotal;
+
+		gi.Cvar_VariableStringBuffer("ui_prisonerobj_currtotal",value,sizeof(value));
+		currTotal = atoi(value);
+		gi.Cvar_VariableStringBuffer("ui_prisonerobj_maxtotal",value,sizeof(value));
+		minTotal = atoi(value);
+
+		sprintf(finalText,va(finalText,currTotal,minTotal));
+	}
+
+	pixelLen = cgi_R_Font_StrLenPixels(finalText, cgs.media.qhFontMedium, 1.0f);
+
+	str = finalText;
+
+	if (cgi_Language_IsAsian())
+	{
+		// this is execrable, and should NOT have had to've been done now, but...
+		//
+		extern const char *CG_DisplayBoxedText(	int iBoxX, int iBoxY, int iBoxWidth, int iBoxHeight, 
+												const char *psText, int iFontHandle, float fScale,
+												const vec4_t v4Color);
+		extern int giLinesOutput;
+		extern float gfAdvanceHack;
+
+		gfAdvanceHack = 1.0f;	// override internal vertical advance
+		y = objectiveStartingYpos + (iYPixelsPerLine * missionYcnt);
+
+		// Advance line if a graphic has printed
+		for (i=0;i<MAX_OBJ_GRAPHICS;i++)
+		{
+			if (obj_graphics[i])
+			{
+				y += OBJ_GRAPHIC_SIZE + 4;
+			}
+		}
+
+		CG_DisplayBoxedText(
+			objectiveStartingXpos,
+			y,
+			objectiveTextBoxWidth,
+			objectiveTextBoxHeight,
+			finalText,	// int iBoxX, int iBoxY, int iBoxWidth, int iBoxHeight, const char *psText
+			cgs.media.qhFontMedium,		// int iFontHandle, 
+			1.0f,						// float fScale,
+			colorTable[color]			// const vec4_t v4Color
+			);
+
+		gfAdvanceHack = 0.0f;	// restore
+		missionYcnt += giLinesOutput;
+	}
+	else
+	{
+		// western...
+		//
+		if (pixelLen < objectiveTextBoxWidth)	// One shot - small enough to print entirely on one line
+		{
+			y =objectiveStartingYpos + (iYPixelsPerLine * (missionYcnt));
+
+			cgi_R_Font_DrawString (
+				objectiveStartingXpos, 
+				y, 
+				str, 
+				colorTable[color], 
+				cgs.media.qhFontMedium, 
+				-1, 
+				1.0f);
+
+			++missionYcnt;
+		}
+		// Text is too long, break into lines.
+		else
+		{
+			char holdText2[2];
+			pixelLen = 0;
+			charLen = 0;
+			holdText2[1] = NULL;
+			strBegin = str;
+
+			while( *str ) 
+			{
+				holdText2[0] = *str;
+				pixelLen += cgi_R_Font_StrLenPixels(holdText2, cgs.media.qhFontMedium, 1.0f);
+
+				pixelLen += 2; // For kerning
+				++charLen;
+
+				if (pixelLen > objectiveTextBoxWidth ) 
+				{	//Reached max length of this line
+					//step back until we find a space
+					while ((charLen>10) && (*str != ' ' ))
+					{
+						--str;
+						--charLen;
+					}
+
+					if (*str==' ')
+					{
+						++str;	// To get past space
+					}
+
+					assert( charLen<maxHoldText );	// Too big?
+
+					Q_strncpyz( holdText, strBegin, charLen);
+					holdText[charLen] = NULL;
+					strBegin = str;
+					pixelLen = 0;
+					charLen = 1;
+
+					y = objectiveStartingYpos + (iYPixelsPerLine * missionYcnt);
+
+					CG_DrawProportionalString(
+						objectiveStartingXpos, 
+						y, 
+						holdText, 
+						CG_SMALLFONT, 
+						colorTable[color] );
+
+					++missionYcnt;
+				} 
+				else if (*(str+1) == NULL)
+				{
+					++charLen;
+
+					assert( charLen<maxHoldText );	// Too big?
+
+					y = objectiveStartingYpos + (iYPixelsPerLine * missionYcnt);
+
+					Q_strncpyz( holdText, strBegin, charLen);
+					CG_DrawProportionalString(
+						objectiveStartingXpos, 
+						y, holdText, 
+						CG_SMALLFONT, 
+						colorTable[color] );
+
+					++missionYcnt;
+					break;
+				}
+				++str; 
+
+
+			} 
+		}
+	}
+
+	if (objectIndex == T3_BOUNTY_OBJ1)
+	{
+		y =objectiveStartingYpos + (iYPixelsPerLine * missionYcnt);
+		if (obj_graphics[1])
+		{
+			y += OBJ_GRAPHIC_SIZE + 4;
+		}
+		if (obj_graphics[2])
+		{
+			y += OBJ_GRAPHIC_SIZE + 4;
+		}
+		graphic = cgi_R_RegisterShaderNoMip("textures/system/viewscreen1");
+		CG_DrawPic( 355, 50, OBJ_GRAPHIC_SIZE, OBJ_GRAPHIC_SIZE, graphic );
+		obj_graphics[3] = qtrue;
+	}
+
+}
+
+/*
+====================
+CG_DrawDataPadObjectives
+
+Draw routine for the objective info screen of the data pad.
+====================
+*/
+void CG_DrawDataPadObjectives(const centity_t *cent )
+{
+	int		i,totalY;
+	int		iYPixelsPerLine = cgi_R_Font_HeightPixels(cgs.media.qhFontMedium, 1.0f);
+
+	const short titleXPos = objectiveStartingXpos - 22;		// X starting position for title text
+	const short titleYPos = objectiveStartingYpos - 23;		// Y starting position for title text
+	const short graphic_size = 16;							// Size (width and height) of graphic used to show status of objective
+	const short graphicXpos = objectiveStartingXpos - graphic_size - 8;	// Amount of X to backup from text starting position
+	const short graphicYOffset = (iYPixelsPerLine - graphic_size)/2;	// Amount of Y to raise graphic so it's in the center of the text line
+
+	missionInfo_Updated = qfalse;		// This will stop the text from flashing
+	cg.missionInfoFlashTime = 0;
+
+	// zero out objective graphics 
+	for (i=0;i<MAX_OBJ_GRAPHICS;i++)
+	{
+		obj_graphics[i] = qfalse;
+	}
+
+	// Title Text at the top 
+	char text[1024]={0};
+	cgi_SP_GetStringTextString( "SP_INGAME_OBJECTIVES", text, sizeof(text) );
+	cgi_R_Font_DrawString (titleXPos, titleYPos, text, colorTable[CT_TITLE], cgs.media.qhFontMedium, -1, 1.0f);
+
+	int missionYcnt = 0;
+
+	// Print all active objectives
+	for (i=0;i<MAX_OBJECTIVES;i++)
+	{
+		// Is there an objective to see?
+		if (cent->gent->client->sess.mission_objectives[i].display)
+		{
+			// Calculate the Y position
+			totalY = objectiveStartingYpos + (iYPixelsPerLine * (missionYcnt))+(iYPixelsPerLine/2);
+
+			//	Draw graphics that show if mission has been accomplished or not
+			cgi_R_SetColor(colorTable[CT_BLUE3]);
+			CG_DrawPic( (graphicXpos),   (totalY-graphicYOffset),   graphic_size,  graphic_size, cgs.media.messageObjCircle);	// Circle in front
+			if (cent->gent->client->sess.mission_objectives[i].status == OBJECTIVE_STAT_SUCCEEDED)
+			{
+				CG_DrawPic( (graphicXpos),   (totalY-graphicYOffset),   graphic_size,  graphic_size, cgs.media.messageLitOn);	// Center Dot
+			}
+
+			// Print current objective text
+			ObjectivePrint_Line(CT_WHITE, i, missionYcnt );
+		}
+	}
+
+	// No mission text?
+	if (!missionYcnt)
+	{
+		// Set the message a quarter of the way down and in the center of the text box
+		int messageYPosition = objectiveStartingYpos + (objectiveTextBoxHeight / 4);
+
+		cgi_SP_GetStringTextString( "SP_INGAME_OBJNONE", text, sizeof(text) );
+		int messageXPosition = objectiveStartingXpos + (objectiveTextBoxWidth/2) -  (cgi_R_Font_StrLenPixels(text, cgs.media.qhFontMedium, 1.0f) /2);
+
+		cgi_R_Font_DrawString (
+			messageXPosition, 
+			messageYPosition, 
+			text, 
+			colorTable[CT_WHITE], 
+			cgs.media.qhFontMedium, 
+			-1, 
+			1.0f);
+	}
+}
+
+/*
+
+//-------------------------------------------------------
+static void CG_DrawForceCount( const int force, int x, float *y, const int pad,qboolean *hasForcePowers )
+{
+	char	s[MAX_STRING_CHARS];
+	int		val, textColor;
+	char	text[1024]={0};
+
+	gi.Cvar_VariableStringBuffer( va("playerfplvl%d", force ),s, sizeof(s) );
+
+	sscanf( s, "%d",&val );
+
+	if ((val<1) || (val> NUM_FORCE_POWERS))	
+	{
+		return;
+	}
+
+	textColor = CT_ICON_BLUE;
+
+	// Draw title
+	cgi_SP_GetStringTextString( showLoadPowersName[force], text, sizeof(text) );
+	CG_DrawProportionalString( x, *y, text, CG_BIGFONT, colorTable[textColor] );
+
+
+	// Draw icons
+	cgi_R_SetColor( colorTable[CT_WHITE]);
+	const int iconSize = 30;
+	if ( val >= 0 )
+	{
+		x -= 10;	// Back up from title a little
+
+		for ( int i = 0; i < val; i++ )
+		{
+			CG_DrawPic( x - iconSize - i * (iconSize + 10) , *y, iconSize, iconSize, force_icons[force] ); 
+		}
+	}
+
+	*y += pad;
+
+	*hasForcePowers = qtrue;
+}
+
+
+/*
+====================
+CG_LoadScreen_PersonalInfo
+====================
+*/
+/*
+static void CG_LoadScreen_PersonalInfo(void)
+{
+	float	x, y;
+	int		pad = 25;
+	char	text[1024]={0};
+	qboolean	hasForcePowers;
+
+	y = 65 + 30;
+
+	pad = 28;
+	x = 300;
+	hasForcePowers=qfalse;
+
+	CG_DrawForceCount( FP_HEAL, x, &y, pad,&hasForcePowers);
+	CG_DrawForceCount( FP_LEVITATION, x, &y, pad,&hasForcePowers );
+	CG_DrawForceCount( FP_SPEED, x, &y, pad,&hasForcePowers );
+	CG_DrawForceCount( FP_PUSH, x, &y, pad,&hasForcePowers );
+	CG_DrawForceCount( FP_PULL, x, &y, pad,&hasForcePowers );
+	CG_DrawForceCount( FP_TELEPATHY, x, &y, pad,&hasForcePowers );
+	CG_DrawForceCount( FP_GRIP, x, &y, pad,&hasForcePowers );
+	CG_DrawForceCount( FP_LIGHTNING, x, &y, pad,&hasForcePowers );
+	CG_DrawForceCount( FP_SABERTHROW, x, &y, pad,&hasForcePowers );
+	CG_DrawForceCount( FP_SABER_OFFENSE, x, &y, pad,&hasForcePowers );
+	CG_DrawForceCount( FP_SABER_DEFENSE, x, &y, pad,&hasForcePowers );
+	
+	if (hasForcePowers)
+	{	
+		cgi_SP_GetStringTextString( "SP_INGAME_CURRENTFORCEPOWERS", text, sizeof(text) );
+		CG_DrawProportionalString( 200, 65, text, CG_CENTER | CG_BIGFONT, colorTable[CT_WHITE] );
+	}
+	else
+	{	//you are only totally empty on the very first map?
+//		cgi_SP_GetStringTextString( "SP_INGAME_NONE", text, sizeof(text) );
+//		CG_DrawProportionalString( 320, y+30, text, CG_CENTER | CG_BIGFONT, colorTable[CT_ICON_BLUE] );
+		cgi_SP_GetStringTextString( "SP_INGAME_ALONGTIME", text, sizeof(text) );
+		int w = cgi_R_Font_StrLenPixels(text,cgs.media.qhFontMedium, 1.5f);
+		cgi_R_Font_DrawString((320)-(w/2), y+40, text,  colorTable[CT_ICON_BLUE], cgs.media.qhFontMedium, -1, 1.5f);
+	}
+
+}
+*/
+
+static void CG_LoadBar(void)
+{
+	const int numticks = 9, tickwidth = 40, tickheight = 8;
+	const int tickpadx = 20, tickpady = 12;
+	const int capwidth = 8;
+	const int barwidth = numticks*tickwidth+tickpadx*2+capwidth*2, barleft = ((640-barwidth)/2);
+	const int barheight = tickheight + tickpady*2, bartop = 475-barheight;
+	const int capleft = barleft+tickpadx, tickleft = capleft+capwidth, ticktop = bartop+tickpady;
+
+	cgi_R_SetColor( colorTable[CT_WHITE]);
+	// Draw background
+	CG_DrawPic(barleft, bartop, barwidth, barheight, cgs.media.levelLoad);
+
+	// Draw left cap (backwards)
+	CG_DrawPic(tickleft, ticktop, -capwidth, tickheight, cgs.media.loadTickCap);
+
+	// Draw bar
+	CG_DrawPic(tickleft, ticktop, tickwidth*cg.loadLCARSStage, tickheight, cgs.media.loadTick);
+
+	// Draw right cap
+	CG_DrawPic(tickleft+tickwidth*cg.loadLCARSStage, ticktop, capwidth, tickheight, cgs.media.loadTickCap);
+}
+
+int CG_WeaponCheck( int weaponIndex );
+
+// For printing load screen icons
+const int	MAXLOADICONSPERROW = 8;		// Max icons displayed per row
+const int	MAXLOADWEAPONS = 16;
+const int	MAXLOADFORCEPOWERS = 12;	
+const int	MAXLOAD_FORCEICONSIZE = 40;	// Size of force power icons
+const int	MAXLOAD_FORCEICONPAD = 12;	// Padding space between icons
+
+static int CG_DrawLoadWeaponsPrintRow( const char *itemName, int weaponsBits,int rowIconCnt, int startIndex) 
+{
+	int		i,endIndex=0, printedIconCnt=0;
+	int		iconSize;
+	int		holdX,x,y,pad;
+	int		yOffset = 0;
+	int		width,height;
+	vec4_t	color;
+	qhandle_t	background;
+
+	if (!cgi_UI_GetMenuItemInfo(
+		"loadScreen",
+		itemName,
+		&x,
+		&y,
+		&width,
+		&height,
+		color,
+		&background))
+	{
+		return(0);
+	}
+
+	cgi_R_SetColor( color );
+
+	iconSize = 60;
+	pad = 12;
+
+	// calculate placement of weapon icons
+	holdX = x + (width - ((iconSize*rowIconCnt) + (pad * (rowIconCnt-1))))/2;
+
+	for (i=startIndex;i<MAXLOADWEAPONS;i++)
+	{
+		if ( !(weaponsBits & ( 1 << i )))	// Does he have this weapon?
+		{
+			continue;
+		}
+
+		if (weaponData[i].weaponIcon[0])
+		{
+			weaponInfo_t	*weaponInfo;
+			CG_RegisterWeapon( i );	
+			weaponInfo = &cg_weapons[i];
+			endIndex = i;
+
+	// NOTE : during loading screen always show the have ammo icon
+	//		if (!CG_WeaponCheck(i))
+	//		{
+	//			CG_DrawPic( holdX, y+yOffset, iconSize, iconSize, weaponInfo->weaponIconNoAmmo );
+	//		}
+	//		else
+			{
+				CG_DrawPic( holdX, y+yOffset, iconSize, iconSize, weaponInfo->weaponIcon );
+			}
+
+			printedIconCnt++;
+			if (printedIconCnt==MAXLOADICONSPERROW)
+			{
+				break;
+			}
+
+			holdX += (iconSize+pad);
+		}
+	}
+
+	return (endIndex);
+}
+
+// Print weapons the player is carrying
+// Two rows print if there are too many
+static void CG_DrawLoadWeapons( int weaponBits ) 
+{
+	int		i,endIndex=0;
+	int		iconCnt,rowIconCnt;
+
+	// count the number of weapons owned
+	iconCnt = 0;
+	for ( i = 1 ; i < MAXLOADWEAPONS ; i++ ) 
+	{
+		if ( weaponBits & ( 1 << i ) ) 
+		{
+			iconCnt++;
+		}
+	}
+
+	if (!iconCnt)	// If no weapons, don't display
+	{
+		return;
+	}
+
+	// Single line of icons
+	if (iconCnt<=MAXLOADICONSPERROW)
+	{
+		CG_DrawLoadWeaponsPrintRow("weaponicons_singlerow", weaponBits, iconCnt,0);
+	}
+	// Two lines of icons
+	else
+	{
+		// Print top row
+		endIndex = CG_DrawLoadWeaponsPrintRow("weaponicons_row1", weaponBits, MAXLOADICONSPERROW,0);
+
+		// Print second row
+		rowIconCnt = iconCnt - MAXLOADICONSPERROW;
+		CG_DrawLoadWeaponsPrintRow("weaponicons_row2", weaponBits, rowIconCnt,endIndex+1);
+	}
+
+	cgi_R_SetColor( NULL );
+}
+
+
+static int CG_DrawLoadForcePrintRow( const char *itemName, int forceBits,int rowIconCnt, int startIndex) 
+{
+	int		i,endIndex=0, printedIconCnt=0;
+	int		holdX,x,y;
+	int		yOffset = 0;
+	int		width,height;
+	vec4_t	color;
+	qhandle_t	background;
+
+	if (!cgi_UI_GetMenuItemInfo(
+		"loadScreen",
+		itemName,
+		&x,
+		&y,
+		&width,
+		&height,
+		color,
+		&background))
+	{
+		return(0);
+	}
+
+	cgi_R_SetColor( color );
+
+	// calculate placement of weapon icons
+	holdX = x + (width - ((MAXLOAD_FORCEICONSIZE*rowIconCnt) + (MAXLOAD_FORCEICONPAD * (rowIconCnt-1))))/2;
+
+	for (i=startIndex;i<MAX_SHOWPOWERS;i++)
+	{
+		if (!CG_ForcePower_Valid(forceBits,i))	// Does he have this power?
+		{
+			continue;
+		}
+
+		if (force_icons[showPowers[i]])
+		{
+			endIndex = i;
+
+			CG_DrawPic( holdX, y+yOffset, MAXLOAD_FORCEICONSIZE, MAXLOAD_FORCEICONSIZE, force_icons[showPowers[i]] );
+
+			printedIconCnt++;
+			if (printedIconCnt==MAXLOADICONSPERROW)
+			{
+				break;
+			}
+
+			holdX += (MAXLOAD_FORCEICONSIZE+MAXLOAD_FORCEICONPAD);
+		}
+	}
+
+	return (endIndex);
+}
+
+int			loadForcePowerLevel[NUM_FORCE_POWERS];
+
+/*
+===============
+ForcePowerDataPad_Valid
+===============
+*/
+qboolean CG_ForcePower_Valid(int forceKnownBits, int index)
+{
+	if ((forceKnownBits & (1 << showPowers[index])) && 
+		loadForcePowerLevel[showPowers[index]])	// Does he have the force power?
+	{
+		return qtrue;
+	}
+
+	return qfalse;
+}
+
+// Print force powers the player is using
+// Two rows print if there are too many
+static void CG_DrawLoadForcePowers( int forceBits ) 
+{
+	int		i,endIndex=0;
+	int		iconCnt=0,rowIconCnt;
+
+	// Count the number of force powers known
+	for (i=0; i<MAX_SHOWPOWERS; ++i)
+	{
+		if (CG_ForcePower_Valid(forceBits, i)) 
+		{
+			iconCnt++;
+		}
+	}
+
+	if (!iconCnt)	// If no force powers, don't display
+	{
+		return;
+	}
+
+	// Single line of icons
+	if (iconCnt<=MAXLOADICONSPERROW)
+	{
+		CG_DrawLoadForcePrintRow("forceicons_singlerow", forceBits, iconCnt,0);
+	}
+	// Two lines of icons
+	else
+	{
+		// Print top row
+		endIndex = CG_DrawLoadForcePrintRow("forceicons_row1", forceBits, MAXLOADICONSPERROW,0);
+
+		// Print second row
+		rowIconCnt = iconCnt - MAXLOADICONSPERROW;
+		CG_DrawLoadForcePrintRow("forceicons_row2", forceBits, rowIconCnt,endIndex+1);
+	}
+
+	cgi_R_SetColor( NULL );
+}
+
+// Get the player weapons and force power info 
+static void CG_GetLoadScreenInfo(int *weaponBits,int *forceBits)
+{
+	char	s[MAX_STRING_CHARS];
+	int		iDummy,i;
+	float	fDummy;
+	const char	*var;
+
+	gi.Cvar_VariableStringBuffer( sCVARNAME_PLAYERSAVE, s, sizeof(s) );
+
+	// Get player weapons and force powers known
+	if (s[0])	
+	{
+	//				|general info				  |-force powers 
+		sscanf( s, "%i %i %i %i %i %i %i %f %f %f %i %i", 
+				&iDummy,	//	&client->ps.stats[STAT_HEALTH],
+				&iDummy,	//	&client->ps.stats[STAT_ARMOR],
+				&*weaponBits,//	&client->ps.stats[STAT_WEAPONS],
+				&iDummy,	//	&client->ps.stats[STAT_ITEMS],
+				&iDummy,	//	&client->ps.weapon,
+				&iDummy,	//	&client->ps.weaponstate,
+				&iDummy,	//	&client->ps.batteryCharge,
+				&fDummy,	//	&client->ps.viewangles[0],
+				&fDummy,	//	&client->ps.viewangles[1],
+				&fDummy,	//	&client->ps.viewangles[2],
+							//force power data
+				&*forceBits,	//	&client->ps.forcePowersKnown,
+				&iDummy		//	&client->ps.forcePower,
+
+				);
+	}
+
+	// the new JK2 stuff - force powers, etc...
+	//
+	gi.Cvar_VariableStringBuffer( "playerfplvl", s, sizeof(s) );
+	i=0;
+	var = strtok( s, " " );
+	while( var != NULL )
+	{
+		/* While there are tokens in "s" */
+		loadForcePowerLevel[i++] = atoi(var);
+		/* Get next token: */
+		var = strtok( NULL, " " );
+	}
+
+}
+
+/*
+====================
+CG_DrawLoadingScreen
+
+Load screen displays the map pic, the mission briefing and weapons/force powers
+====================
+*/
+static void CG_DrawLoadingScreen( qhandle_t	levelshot ,const char *mapName) 
+{
+	int xPos,yPos,width,height;
+	vec4_t	color;
+	qhandle_t	background;
+	int weapons=0, forcepowers=0;
+
+	// Get mission briefing for load screen
+	if (cgi_SP_GetStringTextString( va("BRIEFINGS_%s",mapName), NULL, 0 ) == 0)
+	{
+		cgi_Cvar_Set( "ui_missionbriefing", "@BRIEFINGS_NONE" );
+	}
+	else
+	{
+		cgi_Cvar_Set( "ui_missionbriefing", va("@BRIEFINGS_%s",mapName) );
+	}
+
+	// Print background
+	if (cgi_UI_GetMenuItemInfo(
+		"loadScreen",
+		"background",
+		&xPos,
+		&yPos,
+		&width,
+		&height,
+		color,
+		&background))
+	{
+		cgi_R_SetColor( color );
+		CG_DrawPic( xPos, yPos, width, height, background );
+	}
+
+	// Print level pic
+	if (cgi_UI_GetMenuItemInfo(
+		"loadScreen",
+		"mappic",
+		&xPos,
+		&yPos,
+		&width,
+		&height,
+		color,
+		&background))
+	{
+		//if (!levelshot)
+		//{// No level shot so use screenshot.
+ 	//		CG_DrawPic( xPos, yPos, 1, 1, 0);	//force the tess to flush
+		//	cgi_R_DrawScreenShot( xPos, yPos+height, width, -height );
+		//}
+		//else
+		{
+			cgi_R_SetColor( color );
+			CG_DrawPic( xPos, yPos, width, height, levelshot );
+		}
+	}
+
+	// Get player weapons and force power info
+	CG_GetLoadScreenInfo(&weapons,&forcepowers);
+
+	// Print weapon icons
+	if (weapons)
+	{
+		CG_DrawLoadWeapons(weapons);
+	}
+
+	// Print force power icons
+	if (forcepowers)
+	{
+		CG_DrawLoadForcePowers(forcepowers);
+	}
+}
+
+/*
+====================
+CG_DrawInformation
+
+Draw all the status / pacifier stuff during level loading
+====================
+*/
+void CG_DrawInformation( void ) {
+	int		y;
+
+	// draw the dialog background
+	const char	*info	= CG_ConfigString( CS_SERVERINFO );
+	const char	*s		= Info_ValueForKey( info, "mapname" );
+
+	qhandle_t	levelshot;
+
+	extern SavedGameJustLoaded_e g_eSavedGameJustLoaded;	// hack! (hey, it's the last week of coding, ok?
+//#ifndef _XBOX
+//	if ( g_eSavedGameJustLoaded == eFULL ) 
+//	{
+//		levelshot = 0;	//use the loaded thumbnail instead of the levelshot
+//	} 
+//	else
+//#endif
+	{
+		levelshot = cgi_R_RegisterShaderNoMip( va( "levelshots/%s", s ) );	
+	#ifndef FINAL_BUILD
+		if (!levelshot && !strncmp(s, "work/",5) )
+		{
+			levelshot = cgi_R_RegisterShaderNoMip( va( "levelshots/%s", s+5 ) );	
+		}
+	#endif
+		if (!levelshot) {
+			levelshot = cgi_R_RegisterShaderNoMip( "menu/art/unknownmap" );	
+		}
+	}
+
+	if ( g_eSavedGameJustLoaded != eFULL && (!strcmp(s,"yavin1") || !strcmp(s,"demo")) )//special case for first map!
+	{
+		char	text[1024]={0};
+
+		//
+		cgi_R_SetColor( colorTable[CT_BLACK] );
+		CG_DrawPic( 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, cgs.media.whiteShader );
+
+		cgi_SP_GetStringTextString( "SP_INGAME_ALONGTIME", text, sizeof(text) );
+
+		int w = cgi_R_Font_StrLenPixels(text,cgs.media.qhFontMedium, 1.0f);
+		cgi_R_Font_DrawString((320)-(w/2), 140, text,  colorTable[CT_ICON_BLUE], cgs.media.qhFontMedium, -1, 1.0f);
+	}
+	else
+	{
+		CG_DrawLoadingScreen(levelshot, s);
+		cgi_UI_MenuPaintAll();
+	}
+
+	CG_LoadBar();
+
+
+	// the first 150 rows are reserved for the client connection
+	// screen to write into
+//	if ( cg.processedSnapshotNum == 0 ) 
+	{
+		// still loading
+		// print the current item being loaded
+
+#ifdef _DEBUG
+		cgi_R_Font_DrawString( 40, 416, va("LOADING ... %s",cg.infoScreenText),colorTable[CT_LTGOLD1], cgs.media.qhFontSmall, -1, 1.0f );
+#endif
+	}
+
+	// draw info string information
+
+	y = 20;
+	// map-specific message (long map name)
+	s = CG_ConfigString( CS_MESSAGE );
+
+	if ( s[0] ) 
+	{
+		if (s[0] == '@')
+		{	
+			char text[1024]={0};
+			cgi_SP_GetStringTextString( s+1, text, sizeof(text) );
+			cgi_R_Font_DrawString( 15, y, va("\"%s\"",text),colorTable[CT_WHITE],cgs.media.qhFontMedium, -1, 1.0f );
+		}
+		else 
+		{
+			cgi_R_Font_DrawString( 15, y, va("\"%s\"",s),colorTable[CT_WHITE],cgs.media.qhFontMedium, -1, 1.0f );
+		}
+		y += 20;
+	}
+}
\ No newline at end of file
diff --git a/code/cgame/cg_lights.cpp b/code/cgame/cg_lights.cpp
new file mode 100644
index 0000000..224e13d
--- /dev/null
+++ b/code/cgame/cg_lights.cpp
@@ -0,0 +1,87 @@
+// this line must stay at top so the whole PCH thing works...
+#include "cg_headers.h"
+//#include "cg_local.h"
+
+#if !defined(CG_LIGHTS_H_INC)
+	#include "cg_lights.h"
+#endif
+
+static	clightstyle_t	cl_lightstyle[MAX_LIGHT_STYLES];
+static	int				lastofs;
+
+/*
+================
+FX_ClearLightStyles
+================
+*/
+void CG_ClearLightStyles (void)
+{
+	int	i;
+
+	memset (cl_lightstyle, 0, sizeof(cl_lightstyle));
+	lastofs = -1;
+
+	for(i=0;i<MAX_LIGHT_STYLES*3;i++)
+	{
+		CG_SetLightstyle (i);
+	}
+}
+
+/*
+================
+FX_RunLightStyles
+================
+*/
+void CG_RunLightStyles (void)
+{
+	int		ofs;
+	int		i;
+	clightstyle_t	*ls;
+
+	ofs = cg.time / 50;
+//	if (ofs == lastofs)
+//		return;
+	lastofs = ofs;
+
+	for (i=0,ls=cl_lightstyle ; i<MAX_LIGHT_STYLES ; i++, ls++)
+	{
+		if (!ls->length)
+		{
+			ls->value[0] = ls->value[1] = ls->value[2] = ls->value[3] = 255;
+		}
+		else if (ls->length == 1)
+		{
+			ls->value[0] = ls->map[0][0];
+			ls->value[1] = ls->map[0][1];
+			ls->value[2] = ls->map[0][2];
+			ls->value[3] = 255; //ls->map[0][3];
+		}
+		else
+		{
+			ls->value[0] = ls->map[ofs%ls->length][0];
+			ls->value[1] = ls->map[ofs%ls->length][1];
+			ls->value[2] = ls->map[ofs%ls->length][2];
+			ls->value[3] = 255; //ls->map[ofs%ls->length][3];
+		}
+		trap_R_SetLightStyle(i, *(int*)ls->value);
+	}
+}
+
+void CG_SetLightstyle (int i)
+{
+	const char	*s;
+	int			j, k;
+
+	s = CG_ConfigString( i+CS_LIGHT_STYLES );
+	j = strlen (s);
+	if (j >= MAX_QPATH)
+	{
+		Com_Error (ERR_DROP, "svc_lightstyle length=%i", j);
+	}
+
+	cl_lightstyle[(i/3)].length = j;
+	for (k=0 ; k<j ; k++)
+	{
+		cl_lightstyle[(i/3)].map[k][(i%3)] = (float)(s[k]-'a')/(float)('z'-'a') * 255.0;
+	}
+}
diff --git a/code/cgame/cg_lights.h b/code/cgame/cg_lights.h
new file mode 100644
index 0000000..065f192
--- /dev/null
+++ b/code/cgame/cg_lights.h
@@ -0,0 +1,16 @@
+#pragma once
+#if !defined(CG_LIGHTS_H_INC)
+#define CG_LIGHTS_H_INC
+
+typedef struct
+{
+	int				length;
+	color4ub_t		value;
+	color4ub_t		map[MAX_QPATH];
+} clightstyle_t;
+
+void	CG_ClearLightStyles (void);
+void	CG_RunLightStyles (void);
+void	CG_SetLightstyle (int i);
+
+#endif // CG_LIGHTS_H_INC
\ No newline at end of file
diff --git a/code/cgame/cg_local.h b/code/cgame/cg_local.h
new file mode 100644
index 0000000..732a3af
--- /dev/null
+++ b/code/cgame/cg_local.h
@@ -0,0 +1,1233 @@
+#ifndef	__CG_LOCAL_H__
+#define	__CG_LOCAL_H__
+
+#include "../game/q_shared.h"
+
+// define GAME_INCLUDE so that g_public.h does not define the
+// short, server-visible gclient_t and gentity_t structures,
+// because we define the full size ones in this file
+#define	GAME_INCLUDE
+#include "../game/g_shared.h"
+#include "cg_camera.h"
+
+// The entire cgame module is unloaded and reloaded on each level change,
+// so there is NO persistant data between levels on the client side.
+// If you absolutely need something stored, it can either be kept
+// by the server in the server stored userinfos, or stashed in a cvar.
+
+#define	POWERUP_BLINKS		5
+#define	POWERUP_BLINK_TIME	1000
+#define	FADE_TIME			200
+#define	PULSE_TIME			200
+#define	DAMAGE_DEFLECT_TIME	100
+#define	DAMAGE_RETURN_TIME	400
+#define DAMAGE_TIME			500
+#define	LAND_DEFLECT_TIME	150
+#define	LAND_RETURN_TIME	300
+#define	STEP_TIME			200
+#define	DUCK_TIME			100
+#define	PAIN_TWITCH_TIME	200
+#define	WEAPON_SELECT_TIME	1400
+#define	ITEM_SCALEUP_TIME	1000
+// Zoom vars
+#define	ZOOM_TIME			150		// not currently used?
+#define MAX_ZOOM_FOV		3.0f
+#define ZOOM_IN_TIME		1500.0f	
+#define ZOOM_OUT_TIME		100.0f
+#define ZOOM_START_PERCENT	0.3f	
+
+#define	ITEM_BLOB_TIME		200
+#define	MUZZLE_FLASH_TIME	20
+#define	FRAG_FADE_TIME		1000		// time for fragments to fade away
+
+#define	PULSE_SCALE			1.5			// amount to scale up the icons when activating
+
+#define	MAX_STEP_CHANGE		32
+
+#define	MAX_VERTS_ON_POLY	10
+#define	MAX_MARK_POLYS		256
+
+#define STAT_MINUS			10	// num frame for '-' stats digit
+
+#define	ICON_SIZE			48
+#define	CHAR_WIDTH			32
+#define	CHAR_HEIGHT			48
+#define	TEXT_ICON_SPACE		4
+
+#define	CHARSMALL_WIDTH		16
+#define	CHARSMALL_HEIGHT	32
+
+// very large characters
+#define	GIANT_WIDTH			32
+#define	GIANT_HEIGHT		48
+
+#define MAX_PRINTTEXT		128
+#define MAX_CAPTIONTEXT		 32	// we don't need 64 now since we don't use this for scroll text, and I needed to change a hardwired 128 to 256, so...
+#define MAX_LCARSTEXT		128
+
+
+#define NUM_FONT_BIG	1
+#define NUM_FONT_SMALL	2
+#define NUM_FONT_CHUNKY	3
+
+#define CS_BASIC	0
+#define CS_COMBAT	1
+#define CS_EXTRA	2
+#define CS_JEDI		3
+#define CS_TRY_ALL	4
+
+#define	WAVE_AMPLITUDE	1
+#define	WAVE_FREQUENCY	0.4
+
+//=================================================
+
+// player entities need to track more information
+// than any other type of entity.
+
+// note that not every player entity is a client entity,
+// because corpses after respawn are outside the normal
+// client numbering range
+
+// when changing animation, set animationTime to frameTime + lerping time
+// The current lerp will finish out, then it will lerp to the new animation
+typedef struct {
+	int			oldFrame;
+	int			oldFrameTime;		// time when ->oldFrame was exactly on
+
+	int			frame;
+	int			frameTime;			// time when ->frame will be exactly on
+
+	float		backlerp;
+
+	float		yawAngle;
+	qboolean	yawing;
+	float		pitchAngle;
+	qboolean	pitching;
+
+	int			animationNumber;	
+	animation_t	*animation;
+	int			animationTime;		// time when the first frame of the animation will be exact
+} lerpFrame_t;
+
+typedef struct {
+	lerpFrame_t		legs, torso;
+	int				painTime;
+	int				painDirection;	// flip from 0 to 1
+
+	// For persistent beam weapons, so they don't play their start sound more than once
+	qboolean		lightningFiring;
+
+	// machinegun spinning
+//	float			barrelAngle;
+//	int				barrelTime;
+//	qboolean		barrelSpinning;
+} playerEntity_t;
+
+//=================================================
+
+// centity_t have a direct corespondence with gentity_t in the game, but
+// only the entityState_t is directly communicated to the cgame
+struct centity_s 
+{
+	entityState_t	currentState;	// from cg.frame
+	const entityState_t	*nextState;		// from cg.nextFrame, if available
+#ifdef _XBOX
+	byte		interpolate;	// true if next is valid to interpolate to
+	byte		currentValid;	// true if cg.frame holds this entity
+#else
+	qboolean		interpolate;	// true if next is valid to interpolate to
+	qboolean		currentValid;	// true if cg.frame holds this entity
+#endif
+
+	int				muzzleFlashTime;	// move to playerEntity?
+	qboolean		altFire;			// move to playerEntity?
+
+	int				previousEvent;
+//	int				teleportFlag;
+
+//	int				trailTime;		// so missile trails can handle dropped initial packets
+	int				miscTime;
+
+	playerEntity_t	pe;
+
+//	int				errorTime;		// decay the error from this time
+//	vec3_t			errorOrigin;
+//	vec3_t			errorAngles;
+	
+//	qboolean		extrapolated;	// false if origin / angles is an interpolation
+//	vec3_t			rawOrigin;
+//	vec3_t			rawAngles;
+
+//	vec3_t			beamEnd;
+
+	// exact interpolated position of entity on this frame
+	vec3_t			lerpOrigin;
+	vec3_t			lerpAngles;
+	vec3_t			renderAngles;	//for ET_PLAYERS, the actual angles it was rendered at- should be used by any getboltmatrix calls after CG_Player
+	
+	float			rotValue; //rotation increment for repeater effect
+
+	int				snapShotTime;
+
+	//Pointer to corresponding gentity
+	gentity_t		*gent;
+};
+
+typedef centity_s centity_t;
+
+
+//======================================================================
+
+// local entities are created as a result of events or predicted actions,
+// and live independently from all server transmitted entities
+
+typedef struct markPoly_s {
+	struct markPoly_s	*prevMark, *nextMark;
+	int			time;
+	qhandle_t	markShader;
+	qboolean	alphaFade;		// fade alpha instead of rgb
+	float		color[4];
+	poly_t		poly;
+	polyVert_t	verts[MAX_VERTS_ON_POLY];
+} markPoly_t;
+
+
+typedef enum {
+	LE_MARK,
+	LE_FADE_MODEL,
+	LE_FADE_SCALE_MODEL, // currently only for Demp2 shock sphere
+	LE_FRAGMENT,
+	LE_PUFF,
+	LE_FADE_RGB,
+	LE_LIGHT,
+	LE_LINE,
+	LE_QUAD,
+	LE_SPRITE,
+} leType_t;
+
+typedef enum {
+	LEF_PUFF_DONT_SCALE = 0x0001,			// do not scale size over time
+	LEF_TUMBLE			= 0x0002,			// tumble over time, used for ejecting shells
+	LEF_FADE_RGB		= 0x0004,			// explicitly fade
+	LEF_NO_RANDOM_ROTATE= 0x0008			// MakeExplosion adds random rotate which could be bad in some cases
+} leFlag_t;
+
+typedef enum 
+{
+	LEBS_NONE,
+	LEBS_METAL,
+	LEBS_ROCK
+} leBounceSound_t;	// fragment local entities can make sounds on impacts
+
+typedef struct localEntity_s {
+	struct localEntity_s	*prev, *next;
+	leType_t		leType;
+	int				leFlags;
+
+	int				startTime;
+	int				endTime;
+
+	float			lifeRate;			// 1.0 / (endTime - startTime)
+
+	trajectory_t	pos;
+	trajectory_t	angles;
+
+	float			bounceFactor;		// 0.0 = no bounce, 1.0 = perfect
+
+	float			color[4];
+
+	float			radius;
+
+	float			light;
+	vec3_t			lightColor;
+
+	leBounceSound_t	leBounceSoundType;
+
+	refEntity_t		refEntity;
+	int				ownerGentNum;
+} localEntity_t;
+
+//======================================================================
+
+
+// each IT_* item has an associated itemInfo_t
+// that constains media references necessary to present the
+// item and its effects
+typedef struct {
+	qboolean		registered;
+	qhandle_t		models;
+	qhandle_t		icon;
+} itemInfo_t;
+
+
+typedef struct {
+	int				itemNum;
+} powerupInfo_t;
+
+
+#define	CG_OVERRIDE_3RD_PERSON_ENT	0x00000001
+#define	CG_OVERRIDE_3RD_PERSON_RNG	0x00000002
+#define	CG_OVERRIDE_3RD_PERSON_ANG	0x00000004
+#define	CG_OVERRIDE_3RD_PERSON_VOF	0x00000008
+#define	CG_OVERRIDE_3RD_PERSON_POF	0x00000010
+#define	CG_OVERRIDE_3RD_PERSON_CDP	0x00000020
+#define	CG_OVERRIDE_3RD_PERSON_APH	0x00000040
+#define	CG_OVERRIDE_FOV				0x00000080
+
+typedef struct {
+	//NOTE: these probably get cleared in save/load!!!
+	int				active;	//bit-flag field of which overrides are active
+	int				thirdPersonEntity;	//who to center on
+	float			thirdPersonRange;	//how far to be from them
+	float			thirdPersonAngle;	//what angle to look at them from
+	float			thirdPersonVertOffset;	//how high to be above them
+	float			thirdPersonPitchOffset;	//what offset pitch to apply the the camera view
+	float			thirdPersonCameraDamp;	//how tightly to move the camera pos behind the player
+	float			thirdPersonAlpha;	//how tightly to move the camera pos behind the player
+	float			fov;				//what fov to use
+	//NOTE: could put Alpha and HorzOffset and the target & camera damps, but no-one is trying to override those, so...
+} overrides_t;
+
+//======================================================================
+
+
+// all cg.stepTime, cg.duckTime, cg.landTime, etc are set to cg.time when the action
+// occurs, and they will have visible effects for #define STEP_TIME or whatever msec after
+ 
+typedef struct {
+	int			clientFrame;		// incremented each frame
+	
+	qboolean	levelShot;			// taking a level menu screenshot
+
+	// there are only one or two snapshot_t that are relevent at a time
+	int			latestSnapshotNum;	// the number of snapshots the client system has received
+	int			latestSnapshotTime;	// the time from latestSnapshotNum, so we don't need to read the snapshot yet
+	int			processedSnapshotNum;// the number of snapshots cgame has requested
+	snapshot_t	*snap;				// cg.snap->serverTime <= cg.time
+	snapshot_t	*nextSnap;			// cg.nextSnap->serverTime > cg.time, or NULL
+
+	float		frameInterpolation;	// (float)( cg.time - cg.frame->serverTime ) / (cg.nextFrame->serverTime - cg.frame->serverTime)
+
+	qboolean	thisFrameTeleport;
+	qboolean	nextFrameTeleport;
+
+	int			frametime;		// cg.time - cg.oldTime
+
+	int			time;			// this is the time value that the client
+								// is rendering at.
+	int			oldTime;		// time at last frame, used for missile trails and prediction checking
+
+	int			timelimitWarnings;	// 5 min, 1 min, overtime
+
+	qboolean	renderingThirdPerson;		// during deaths, chasecams, etc
+
+	// prediction state
+	qboolean	hyperspace;				// true if prediction has hit a trigger_teleport
+	playerState_t	predicted_player_state;
+	qboolean	validPPS;				// clear until the first call to CG_PredictPlayerState
+	int			predictedErrorTime;
+	vec3_t		predictedError;
+
+	float		stepChange;				// for stair up smoothing
+	int			stepTime;
+
+	float		duckChange;				// for duck viewheight smoothing
+	int			duckTime;
+
+	float		landChange;				// for landing hard
+	int			landTime;
+	
+	// input state sent to server
+	int			weaponSelect;
+	int			saberAnimLevelPending;
+
+	// auto rotating items
+	vec3_t		autoAngles;
+	vec3_t		autoAxis[3];
+	vec3_t		autoAnglesFast;
+	vec3_t		autoAxisFast[3];
+
+	// view rendering
+	refdef_t	refdef;
+	vec3_t		refdefViewAngles;		// will be converted to refdef.viewaxis
+
+#ifdef _XBOX
+	qboolean	widescreen;
+#endif
+
+	// zoom key
+	int			zoomMode;		// 0 - not zoomed, 1 - binoculars, 2 - disruptor weapon
+	int			zoomDir;		// -1, 1
+	int			zoomTime;
+	qboolean	zoomLocked;
+
+	// gonk use
+	int			batteryChargeTime;
+
+	// FIXME:
+	int			forceCrosshairStartTime;
+	int			forceCrosshairEndTime;
+
+	// information screen text during loading
+	char		infoScreenText[MAX_STRING_CHARS];
+
+	// centerprinting
+	int			centerPrintTime;
+	int			centerPrintY;
+	char		centerPrint[1024];
+	int			centerPrintLines;
+
+	// Scrolling text, caption text and LCARS text use this
+	char		printText[MAX_PRINTTEXT][128];	
+	int			printTextY;			 	
+
+	char		captionText[MAX_CAPTIONTEXT][256/*128*/];	// bosted for taiwanese squealy radio static speech in kejim post
+	int			captionTextY;
+
+	int			scrollTextLines;	// Number of lines being printed
+	int			scrollTextTime;
+
+	int			captionNextTextTime;
+	int			captionTextCurrentLine;
+	int			captionTextTime;
+	int			captionLetterTime;
+
+	// For flashing health armor counter
+	int			oldhealth;
+	int			oldHealthTime;
+	int			oldarmor;
+	int			oldArmorTime;
+	int			oldammo;
+	int			oldAmmoTime;
+
+	// low ammo warning state
+	int			lowAmmoWarning;		// 1 = low, 2 = empty
+
+	// crosshair client ID
+	int			crosshairClientNum;		//who you're looking at
+	int			crosshairClientTime;	//last time you looked at them
+
+	// powerup active flashing
+	int			powerupActive;
+	int			powerupTime;
+
+	//==========================
+	int			creditsStart;
+
+	int			itemPickup;
+	int			itemPickupTime;
+	int			itemPickupBlendTime;	// the pulse around the crosshair is timed seperately
+
+	float		iconHUDPercent;			// How far into opening sequence the icon HUD is
+	int			iconSelectTime;			// How long the Icon HUD has been active
+	qboolean	iconHUDActive;
+
+	int			DataPadInventorySelect;		// Current inventory item chosen on Data Pad
+	int			DataPadWeaponSelect;		// Current weapon item chosen on Data Pad
+	int			DataPadforcepowerSelect;	// Current force power chosen on Data Pad
+
+	qboolean	messageLitActive;			// Flag to show of message lite is active
+
+	int			weaponSelectTime;
+	int			weaponAnimation;
+	int			weaponAnimationTime;
+
+	int			inventorySelect;		// Current inventory item chosen
+	int			inventorySelectTime;
+
+	int			forcepowerSelect;		// Current force power chosen
+	int			forcepowerSelectTime;
+
+	// blend blobs
+	float		damageTime;
+	float		damageX, damageY, damageValue;
+
+	// status bar head
+	float		headYaw;
+	float		headEndPitch;
+	float		headEndYaw;
+	int			headEndTime;
+	float		headStartPitch;
+	float		headStartYaw;
+	int			headStartTime;
+
+	int			loadLCARSStage;
+
+	int			missionInfoFlashTime;
+	qboolean	missionStatusShow;
+	int			missionStatusDeadTime;
+
+	int			forceHUDTotalFlashTime;
+	int			forceHUDNextFlashTime;
+	qboolean	forceHUDActive;				// Flag to show force hud is off/on
+
+	qboolean	missionFailedScreen;	// qtrue if opened
+
+	int			weaponPickupTextTime;
+
+	int			VHUDFlashTime;
+	qboolean	VHUDTurboFlag;
+	int			HUDTickFlashTime;
+	qboolean	HUDArmorFlag;
+	qboolean	HUDHealthFlag;
+
+	// view movement
+	float		v_dmg_time;
+	float		v_dmg_pitch;
+	float		v_dmg_roll;
+
+	int			wonkyTime;		// when interrogator gets you, wonky time controls "drugged" camera view.
+
+	vec3_t		kick_angles;	// weapon kicks
+	int			kick_time;		// when the kick happened, so it gets reduced over time
+
+	// temp working variables for player view
+	float		bobfracsin;
+	int			bobcycle;
+	float		xyspeed;
+
+	// development tool
+	char			testModelName[MAX_QPATH];
+/*
+Ghoul2 Insert Start
+*/
+	int				testModel;
+	// had to be moved so we wouldn't wipe these out with the memset - these have STL in them and shouldn't be cleared that way
+	snapshot_t	activeSnapshots[2];
+	refEntity_t		testModelEntity;
+/*
+Ghoul2 Insert End
+*/
+	overrides_t	overrides;	//for overriding certain third-person camera properties
+
+} cg_t;
+
+
+#define MAX_SHOWPOWERS 12
+extern int showPowers[MAX_SHOWPOWERS]; 
+extern char *showPowersName[MAX_SHOWPOWERS];
+extern int force_icons[NUM_FORCE_POWERS];
+#define MAX_DPSHOWPOWERS 16
+
+//==============================================================================
+
+
+#define SG_OFF		0
+#define SG_STRING	1
+#define SG_GRAPHIC	2
+#define SG_NUMBER	3
+#define SG_VAR		4
+
+typedef struct
+{
+	int				type;		// STRING or GRAPHIC
+	float			timer;		// When it changes
+	int				x;			// X position
+	int				y;			// Y positon
+	int				width;		// Graphic width
+	int				height;		// Graphic height
+	char			*file;		// File name of graphic/ text if STRING
+	int				ingameEnum;	// Index to ingame_text[]
+	qhandle_t		graphic;	// Handle of graphic if GRAPHIC
+	int				min;		// 
+	int				max;
+	int				target;		// Final value
+	int				inc;
+	int				style;
+	int				color;		// Normal color
+	void			*pointer;		// To an address
+} screengraphics_s;
+
+
+extern	cg_t			cg;
+extern	centity_t		cg_entities[MAX_GENTITIES];
+
+extern	centity_t		*cg_permanents[MAX_GENTITIES];
+extern	int				cg_numpermanents;
+
+extern	weaponInfo_t	cg_weapons[MAX_WEAPONS];
+extern	itemInfo_t		cg_items[MAX_ITEMS];
+extern	markPoly_t		cg_markPolys[MAX_MARK_POLYS];
+
+
+extern	vmCvar_t		cg_runpitch;
+extern	vmCvar_t		cg_runroll;
+extern	vmCvar_t		cg_bobup;
+extern	vmCvar_t		cg_bobpitch;
+extern	vmCvar_t		cg_bobroll;
+extern	vmCvar_t		cg_shadows;
+extern	vmCvar_t		cg_renderToTextureFX;
+extern	vmCvar_t		cg_shadowCullDistance;
+extern	vmCvar_t		cg_paused;
+extern	vmCvar_t		cg_drawTimer;
+extern	vmCvar_t		cg_drawFPS;
+extern	vmCvar_t		cg_drawSnapshot;
+extern	vmCvar_t		cg_drawAmmoWarning;
+extern	vmCvar_t		cg_drawCrosshair;
+extern	vmCvar_t		cg_crosshairForceHint;
+extern	vmCvar_t		cg_crosshairIdentifyTarget;
+extern	vmCvar_t		cg_crosshairX;
+extern	vmCvar_t		cg_crosshairY;
+extern	vmCvar_t		cg_crosshairSize;
+extern	vmCvar_t		cg_drawStatus;
+extern	vmCvar_t		cg_drawHUD;
+extern	vmCvar_t		cg_draw2D;
+extern	vmCvar_t		cg_debugAnim;
+#ifndef FINAL_BUILD
+extern	vmCvar_t		cg_debugAnimTarget;
+extern	vmCvar_t		cg_gun_frame;
+#endif
+extern	vmCvar_t		cg_debugSaber;
+extern	vmCvar_t		cg_debugEvents;
+extern	vmCvar_t		cg_errorDecay;
+extern	vmCvar_t		cg_footsteps;
+extern	vmCvar_t		cg_addMarks;
+extern	vmCvar_t		cg_drawGun;
+extern	vmCvar_t		cg_autoswitch;
+extern	vmCvar_t		cg_simpleItems;
+extern	vmCvar_t		cg_fov;
+extern	vmCvar_t		cg_endcredits;
+extern	vmCvar_t		cg_updatedDataPadForcePower1;
+extern	vmCvar_t		cg_updatedDataPadForcePower2;
+extern	vmCvar_t		cg_updatedDataPadForcePower3;
+extern	vmCvar_t		cg_updatedDataPadObjective;
+extern	vmCvar_t		cg_drawBreath;
+extern	vmCvar_t		cg_roffdebug;
+#ifndef FINAL_BUILD
+extern	vmCvar_t		cg_roffval1;
+extern	vmCvar_t		cg_roffval2;
+extern	vmCvar_t		cg_roffval3;
+extern	vmCvar_t		cg_roffval4;
+#endif
+extern	vmCvar_t		cg_thirdPerson;
+extern	vmCvar_t		cg_thirdPersonRange;
+extern	vmCvar_t		cg_thirdPersonMaxRange;
+extern	vmCvar_t		cg_thirdPersonAngle;
+extern	vmCvar_t		cg_thirdPersonPitchOffset;
+extern	vmCvar_t		cg_thirdPersonVertOffset;
+extern	vmCvar_t		cg_thirdPersonCameraDamp;
+extern	vmCvar_t		cg_thirdPersonTargetDamp;
+extern	vmCvar_t		cg_gunAutoFirst;
+
+extern	vmCvar_t		cg_stereoSeparation;
+extern	vmCvar_t		cg_developer;
+extern	vmCvar_t		cg_timescale;
+extern	vmCvar_t		cg_skippingcin;
+
+extern	vmCvar_t		cg_pano;
+extern	vmCvar_t		cg_panoNumShots;
+
+extern	vmCvar_t		fx_freeze;
+extern	vmCvar_t		fx_debug;
+
+extern	vmCvar_t		cg_missionInfoFlashTime;
+extern	vmCvar_t		cg_hudFiles;
+
+extern	vmCvar_t		cg_turnAnims;
+extern	vmCvar_t		cg_motionBoneComp;
+extern	vmCvar_t		cg_reliableAnimSounds;
+
+extern	vmCvar_t		cg_smoothPlayerPos;
+extern	vmCvar_t		cg_smoothPlayerPlat;
+extern	vmCvar_t		cg_smoothPlayerPlatAccel;
+
+void CG_NewClientinfo( int clientNum );
+//
+// cg_main.c
+//
+const char *CG_ConfigString( int index );
+const char *CG_Argv( int arg );
+
+void QDECL CG_Printf( const char *msg, ... );
+void QDECL CG_Error( const char *msg, ... );
+
+void CG_StartMusic( qboolean bForceStart );
+
+void CG_UpdateCvars( void );
+
+int CG_CrosshairPlayer( void );
+void CG_LoadMenus(const char *menuFile);
+
+//
+// cg_view.c
+//
+void CG_TestModel_f (void);
+void CG_TestModelNextFrame_f (void);
+void CG_TestModelPrevFrame_f (void);
+void CG_TestModelNextSkin_f (void);
+void CG_TestModelPrevSkin_f (void);
+
+void CG_ZoomDown_f( void );
+void CG_ZoomUp_f( void );
+
+void CG_DrawActiveFrame( int serverTime, stereoFrame_t stereoView );
+/*
+Ghoul2 Insert Start
+*/
+
+void CG_TestG2Model_f (void);
+void CG_TestModelSurfaceOnOff_f(void);
+void CG_ListModelSurfaces_f (void);
+void CG_ListModelBones_f (void);
+void CG_TestModelSetAnglespre_f(void);
+void CG_TestModelSetAnglespost_f(void);
+void CG_TestModelAnimate_f(void);
+/*
+Ghoul2 Insert End
+*/
+
+
+//
+// cg_drawtools.c
+//
+
+#define CG_LEFT			0x00000000	// default
+#define CG_CENTER		0x00000001
+#define CG_RIGHT		0x00000002
+#define CG_FORMATMASK	0x00000007
+#define CG_SMALLFONT	0x00000010
+#define CG_BIGFONT		0x00000020	// default
+#define CG_GIANTFONT	0x00000040
+#define CG_DROPSHADOW	0x00000800
+#define CG_BLINK		0x00001000
+#define CG_INVERSE		0x00002000
+#define CG_PULSE		0x00004000
+#define CG_UNDERLINE	0x00008000
+#define CG_TINYFONT		0x00010000
+
+
+void CG_DrawRect( float x, float y, float width, float height, float size, const float *color );
+void CG_FillRect( float x, float y, float width, float height, const float *color );
+void CG_Scissor( float x, float y, float width, float height);
+void CG_DrawPic( float x, float y, float width, float height, qhandle_t hShader );
+void CG_DrawPic2( float x, float y, float width, float height, float s1, float t1, float s2, float t2, qhandle_t hShader );
+void CG_DrawRotatePic( float x, float y, float width, float height,float angle, qhandle_t hShader );
+void CG_DrawRotatePic2( float x, float y, float width, float height,float angle, qhandle_t hShader );
+void CG_DrawString( float x, float y, const char *string, 
+				   float charWidth, float charHeight, const float *modulate );
+void CG_PrintInterfaceGraphics(int min,int max);
+void CG_DrawNumField (int x, int y, int width, int value,int charWidth,int charHeight,int style,qboolean zeroFill);
+void CG_DrawProportionalString( int x, int y, const char* str, int style, vec4_t color );
+
+
+void CG_DrawStringExt( int x, int y, const char *string, const float *setColor, 
+		qboolean forceColor, qboolean shadow, int charWidth, int charHeight );
+void CG_DrawSmallStringColor( int x, int y, const char *s, vec4_t color );
+
+int CG_DrawStrlen( const char *str );
+
+float	*CG_FadeColor( int startMsec, int totalMsec );
+void CG_TileClear( void );
+
+
+//
+// cg_draw.c
+//
+void CG_CenterPrint( const char *str, int y );
+void CG_DrawActive( stereoFrame_t stereoView );
+void CG_ScrollText( const char *str, int iPixelWidth );
+void CG_CaptionText( const char *str, int sound, int y );
+void CG_CaptionTextStop( void );
+
+//
+// cg_text.c
+//
+void CG_DrawScrollText( void );
+void CG_DrawCaptionText( void );
+void CG_DrawCenterString( void ); 
+
+
+//
+// cg_player.c
+//
+void CG_AddGhoul2Mark(int type, float size, vec3_t hitloc, vec3_t hitdirection, 
+				int entnum, vec3_t entposition, float entangle, CGhoul2Info_v &ghoul2, vec3_t modelScale, int lifeTime = 0, vec3_t uaxis = 0);
+void CG_Player( centity_t *cent );
+void CG_ResetPlayerEntity( centity_t *cent );
+void CG_AddRefEntityWithPowerups( refEntity_t *ent, int powerups, centity_t *cent );
+void CG_GetTagWorldPosition( refEntity_t *model, char *tag, vec3_t pos, vec3_t axis[3] );
+
+//
+// cg_predict.c
+//
+int	CG_PointContents( const vec3_t point, int passEntityNum );
+void CG_Trace( trace_t *result, const vec3_t start, const vec3_t mins, const vec3_t maxs, const vec3_t end, 
+					 const int skipNumber, const int mask, const EG2_Collision eG2TraceType=G2_NOCOLLIDE, const int useLod=0 );
+void CG_PredictPlayerState( void );
+
+//
+// cg_events.c
+//
+void CG_CheckEvents( centity_t *cent );
+const char	*CG_PlaceString( int rank );
+void CG_EntityEvent( centity_t *cent, vec3_t position );
+
+
+//
+// cg_ents.c
+//
+vec3_t *CG_SetEntitySoundPosition( centity_t *cent );
+void CG_AddPacketEntities( qboolean isPortal );
+void CG_Beam( centity_t *cent, int color );
+void CG_Cylinder( vec3_t start, vec3_t end, float radius, vec3_t color );
+void CG_AdjustPositionForMover( const vec3_t in, int moverNum, int atTime, vec3_t out );
+
+void CG_PositionEntityOnTag( refEntity_t *entity, const refEntity_t *parent, 
+							qhandle_t parentModel, char *tagName );
+void CG_PositionRotatedEntityOnTag( refEntity_t *entity, const refEntity_t *parent, 
+							qhandle_t parentModel, char *tagName, orientation_t *tagOrient );
+
+/*
+Ghoul2 Insert Start
+*/
+void ScaleModelAxis(refEntity_t	*ent);
+/*
+Ghoul2 Insert End
+*/
+
+
+//
+// cg_weapons.c
+//
+void CG_NextWeapon_f( void );
+void CG_PrevWeapon_f( void );
+void CG_Weapon_f( void );
+void CG_DPNextWeapon_f( void );
+void CG_DPPrevWeapon_f( void );
+void CG_DPNextInventory_f( void );
+void CG_DPPrevInventory_f( void );
+void CG_DPNextForcePower_f( void );
+void CG_DPPrevForcePower_f( void );
+
+
+void CG_RegisterWeapon( int weaponNum );
+void CG_RegisterItemVisuals( int itemNum );
+void CG_RegisterItemSounds( int itemNum );
+
+void CG_FireWeapon( centity_t *cent, qboolean alt_fire );
+//void CG_ChargeWeapon( centity_t *cent );
+
+void CG_AddViewWeapon (playerState_t *ps);
+void CG_DrawWeaponSelect( void );
+
+void CG_OutOfAmmoChange( void );	// should this be in pmove?
+
+//
+// cg_marks.c
+//
+void	CG_InitMarkPolys( void );
+void	CG_AddMarks( void );
+void	CG_ImpactMark( qhandle_t markShader, 
+				    const vec3_t origin, const vec3_t dir, 
+					float orientation, 
+				    float r, float g, float b, float a, 
+					qboolean alphaFade, 
+					float radius, qboolean temporary );
+
+//
+// cg_localents.c
+//
+void	CG_InitLocalEntities( void );
+localEntity_t	*CG_AllocLocalEntity( void );
+void	CG_AddLocalEntities( void );
+
+//
+// cg_effects.c
+//
+
+/*localEntity_t *CG_MakeExplosion( vec3_t origin, vec3_t dir, 
+								qhandle_t hModel, int numframes, qhandle_t shader, int msec,
+								qboolean isSprite, float scale = 1.0f );// Overloaded
+
+localEntity_t *CG_MakeExplosion( vec3_t origin, vec3_t dir, 
+								qhandle_t hModel, int numframes, qhandle_t shader, int msec,
+								qboolean isSprite, float scale, int flags );// Overloaded
+*/
+localEntity_t *CG_AddTempLight( vec3_t origin, float scale, vec3_t color, int msec );
+
+void CG_TestLine( vec3_t start, vec3_t end, int time, unsigned int color, int radius);
+
+//
+// cg_snapshot.c
+//
+void CG_ProcessSnapshots( void );
+
+//
+// cg_info.c
+//
+void CG_DrawInformation( void );
+
+//
+// cg_scoreboard.c
+//
+qboolean CG_DrawScoreboard( void );
+extern void CG_MissionCompletion(void);
+
+//
+// cg_consolecmds.c
+//
+qboolean CG_ConsoleCommand( void );
+void CG_InitConsoleCommands( void );
+
+//
+// cg_servercmds.c
+//
+void CG_ExecuteNewServerCommands( int latestSequence );
+void CG_ParseServerinfo( void );
+
+//
+// cg_playerstate.c
+//
+void CG_Respawn( void );
+void CG_TransitionPlayerState( playerState_t *ps, playerState_t *ops );
+
+// cg_credits.cpp
+//
+void CG_Credits_Init( const char *psStripReference, vec4_t *pv4Color);
+qboolean CG_Credits_Running( void );
+qboolean CG_Credits_Draw( void );
+
+
+//===============================================
+
+//
+// system calls
+// These functions are how the cgame communicates with the main game system
+//
+
+// print message on the local console
+void	cgi_Printf( const char *fmt );
+
+// abort the game
+void	cgi_Error( const char *fmt );
+
+// milliseconds should only be used for performance tuning, never
+// for anything game related.  Get time from the CG_DrawActiveFrame parameter
+int		cgi_Milliseconds( void );
+
+// console variable interaction
+void	cgi_Cvar_Register( vmCvar_t *vmCvar, const char *varName, const char *defaultValue, int flags );
+void	cgi_Cvar_Update( vmCvar_t *vmCvar );
+void	cgi_Cvar_Set( const char *var_name, const char *value );
+
+
+// ServerCommand and ConsoleCommand parameter access
+int		cgi_Argc( void );
+void	cgi_Argv( int n, char *buffer, int bufferLength );
+void	cgi_Args( char *buffer, int bufferLength );
+
+// filesystem access
+// returns length of file
+int		cgi_FS_FOpenFile( const char *qpath, fileHandle_t *f, fsMode_t mode );
+int		cgi_FS_Read( void *buffer, int len, fileHandle_t f );
+int		cgi_FS_Write( const void *buffer, int len, fileHandle_t f );
+void	cgi_FS_FCloseFile( fileHandle_t f );
+
+// add commands to the local console as if they were typed in
+// for map changing, etc.  The command is not executed immediately,
+// but will be executed in order the next time console commands
+// are processed
+void	cgi_SendConsoleCommand( const char *text );
+
+// register a command name so the console can perform command completion.
+// FIXME: replace this with a normal console command "defineCommand"?
+void	cgi_AddCommand( const char *cmdName );
+
+// send a string to the server over the network
+void	cgi_SendClientCommand( const char *s );
+
+// force a screen update, only used during gamestate load
+void	cgi_UpdateScreen( void );
+
+//RMG
+void	cgi_RMG_Init(int terrainID, const char *terrainInfo);
+int		cgi_CM_RegisterTerrain(const char *terrainInfo);
+void	cgi_RE_InitRendererTerrain( const char *terrainInfo );
+
+// model collision
+void	cgi_CM_LoadMap( const char *mapname, qboolean subBSP );
+int		cgi_CM_NumInlineModels( void );
+clipHandle_t cgi_CM_InlineModel( int index );		// 0 = world, 1+ = bmodels
+clipHandle_t cgi_CM_TempBoxModel( const vec3_t mins, const vec3_t maxs );//, const int contents );
+int		cgi_CM_PointContents( const vec3_t p, clipHandle_t model );
+int		cgi_CM_TransformedPointContents( const vec3_t p, clipHandle_t model, const vec3_t origin, const vec3_t angles );
+void	cgi_CM_BoxTrace( trace_t *results, const vec3_t start, const vec3_t end,
+						  const vec3_t mins, const vec3_t maxs,
+						  clipHandle_t model, int brushmask );
+void	cgi_CM_TransformedBoxTrace( trace_t *results, const vec3_t start, const vec3_t end,
+						  const vec3_t mins, const vec3_t maxs,
+						  clipHandle_t model, int brushmask,
+						  const vec3_t origin, const vec3_t angles );
+
+// Returns the projection of a polygon onto the solid brushes in the world
+int		cgi_CM_MarkFragments( int numPoints, const vec3_t *points, 
+				const vec3_t projection,
+				int maxPoints, vec3_t pointBuffer,
+				int maxFragments, markFragment_t *fragmentBuffer );
+
+// normal sounds will have their volume dynamically changed as their entity
+// moves and the listener moves
+void	cgi_S_StartSound( const vec3_t origin, int entityNum, int entchannel, sfxHandle_t sfx );
+void	cgi_S_StopSounds( void );
+
+// a local sound is always played full volume
+void	cgi_S_StartLocalSound( sfxHandle_t sfx, int channelNum );
+void	cgi_S_ClearLoopingSounds( void );
+void	cgi_S_AddLoopingSound(int entityNum, const vec3_t origin, const vec3_t velocity, sfxHandle_t sfx, soundChannel_t chan = CHAN_AUTO );
+void	cgi_S_UpdateEntityPosition( int entityNum, const vec3_t origin );
+
+// repatialize recalculates the volumes of sound as they should be heard by the
+// given entityNum and position
+void	cgi_S_Respatialize( int entityNum, const vec3_t origin, vec3_t axis[3], qboolean inwater );
+sfxHandle_t	cgi_S_RegisterSound( const char *sample );		// returns buzz if not found
+void	cgi_S_StartBackgroundTrack( const char *intro, const char *loop, qboolean bForceStart );	// empty name stops music
+float	cgi_S_GetSampleLength( sfxHandle_t sfx);
+
+
+#ifdef _IMMERSION
+void	cgi_FF_Start( ffHandle_t ff, int clientNum );
+void	cgi_FF_Ensure( ffHandle_t ff, int clientNum );
+void	cgi_FF_Stop( ffHandle_t ff, int clientNum );
+void	cgi_FF_StopAll( void );
+void	cgi_FF_Shake( int intensity, int duration );
+ffHandle_t	cgi_FF_Register( const char *name, int channel );
+void	cgi_FF_AddLoopingForce( ffHandle_t handle, int entNum );
+#else
+// I've made these into ints instead of original typedefs to cut down on rebuild time
+//	if I update the module they're in. No point in rebuilding all CGAME modules...
+//
+void	cgi_FF_StartFX( int iFX );
+void	cgi_FF_EnsureFX( int iFX );
+void	cgi_FF_StopFX( int iFX );
+void	cgi_FF_StopAllFX( void );
+
+#endif // _IMMERSION
+
+#ifdef _XBOX
+void	cgi_FF_Xbox_Shake( float intensity, int duration );
+void	cgi_FF_Xbox_Damage( int damage, float xpos );
+#endif
+
+
+
+void	cgi_R_LoadWorldMap( const char *mapname );
+
+// all media should be registered during level startup to prevent
+// hitches during gameplay
+qhandle_t	cgi_R_RegisterModel( const char *name );			// returns rgb axis if not found
+qhandle_t	cgi_R_RegisterSkin( const char *name );			
+qhandle_t	cgi_R_RegisterShader( const char *name );			// returns default shader if not found
+qhandle_t	cgi_R_RegisterShaderNoMip( const char *name );			// returns all white if not found
+qhandle_t	cgi_R_RegisterFont( const char *name );
+int			cgi_R_Font_StrLenPixels(const char *text, const int iFontIndex, const float scale = 1.0f);
+int			cgi_R_Font_StrLenChars(const char *text);
+int			cgi_R_Font_HeightPixels(const int iFontIndex, const float scale = 1.0f);
+void		cgi_R_Font_DrawString(int ox, int oy, const char *text, const float *rgba, const int setIndex, int iMaxPixelWidth, const float scale = 1.0f);
+qboolean	cgi_Language_IsAsian(void);
+qboolean	cgi_Language_UsesSpaces(void);
+unsigned	cgi_AnyLanguage_ReadCharFromString( const char *psText, int *iAdvanceCount, qboolean *pbIsTrailingPunctuation = NULL );
+
+void	cgi_R_SetRefractProp(float alpha, float stretch, qboolean prepost, qboolean negate);
+
+// a scene is built up by calls to R_ClearScene and the various R_Add functions.
+// Nothing is drawn until R_RenderScene is called.
+void	cgi_R_ClearScene( void );
+void	cgi_R_AddRefEntityToScene( const refEntity_t *re );
+void	cgi_R_GetLighting( const vec3_t origin, vec3_t ambientLight, vec3_t directedLight, vec3_t ligthDir );
+
+//used by miscents
+qboolean	cgi_R_inPVS( vec3_t p1, vec3_t p2 );
+
+// polys are intended for simple wall marks, not really for doing
+// significant construction
+void	cgi_R_AddPolyToScene( qhandle_t hShader , int numVerts, const polyVert_t *verts );
+void	cgi_R_AddLightToScene( const vec3_t org, float intensity, float r, float g, float b );
+void	cgi_R_RenderScene( const refdef_t *fd );
+void	cgi_R_SetColor( const float *rgba );	// NULL = 1,1,1,1
+void	cgi_R_DrawStretchPic( float x, float y, float w, float h, 
+	float s1, float t1, float s2, float t2, qhandle_t hShader );
+//void	cgi_R_DrawScreenShot( float x, float y, float w, float h);
+
+void	cgi_R_ModelBounds( qhandle_t model, vec3_t mins, vec3_t maxs );
+void	cgi_R_LerpTag( orientation_t *tag, qhandle_t mod, int startFrame, int endFrame, 
+					 float frac, const char *tagName );
+// Does weird, barely controllable rotation behaviour
+void	cgi_R_DrawRotatePic( float x, float y, float w, float h, 
+	float s1, float t1, float s2, float t2,float a, qhandle_t hShader );
+// rotates image around exact center point of passed in coords
+void	cgi_R_DrawRotatePic2( float x, float y, float w, float h, 
+	float s1, float t1, float s2, float t2,float a, qhandle_t hShader );
+void	cgi_R_SetRangeFog(float range);
+void	cgi_R_LAGoggles( void );
+void	cgi_R_Scissor( float x, float y, float w, float h);
+
+// The glconfig_t will not change during the life of a cgame.
+// If it needs to change, the entire cgame will be restarted, because
+// all the qhandle_t are then invalid.
+void		cgi_GetGlconfig( glconfig_t *glconfig );
+
+// the gamestate should be grabbed at startup, and whenever a
+// configstring changes
+void		cgi_GetGameState( gameState_t *gamestate );
+
+// cgame will poll each frame to see if a newer snapshot has arrived
+// that it is interested in.  The time is returned seperately so that
+// snapshot latency can be calculated.
+void		cgi_GetCurrentSnapshotNumber( int *snapshotNumber, int *serverTime );
+
+// a snapshot get can fail if the snapshot (or the entties it holds) is so
+// old that it has fallen out of the client system queue
+qboolean	cgi_GetSnapshot( int snapshotNumber, snapshot_t *snapshot );
+
+qboolean	cgi_GetDefaultState(int entityIndex, entityState_t *state );
+
+// retrieve a text command from the server stream
+// the current snapshot will hold the number of the most recent command
+// qfalse can be returned if the client system handled the command
+// argc() / argv() can be used to examine the parameters of the command
+qboolean	cgi_GetServerCommand( int serverCommandNumber );
+
+// returns the most recent command number that can be passed to GetUserCmd
+// this will always be at least one higher than the number in the current
+// snapshot, and it may be quite a few higher if it is a fast computer on
+// a lagged connection
+int			cgi_GetCurrentCmdNumber( void );	
+qboolean	cgi_GetUserCmd( int cmdNumber, usercmd_t *ucmd );
+
+// used for the weapon select and zoom
+void		cgi_SetUserCmdValue( int stateValue, float sensitivityScale, float mPitchOverride, float mYawOverride );
+void		cgi_SetUserCmdAngles( float pitchOverride, float yawOverride, float rollOverride );
+
+void		cgi_S_UpdateAmbientSet( const char *name, vec3_t origin );
+void		cgi_AS_ParseSets( void );
+void		cgi_AS_AddPrecacheEntry( const char *name );
+int			cgi_S_AddLocalSet( const char *name, vec3_t listener_origin, vec3_t origin, int entID, int time );
+sfxHandle_t	cgi_AS_GetBModelSound( const char *name, int stage );
+
+
+void CG_DrawMiscEnts(void);
+
+
+//-----------------------------
+// Effects related prototypes
+//-----------------------------
+
+// Weapon prototypes
+void FX_Saber( vec3_t start, vec3_t normal, float height, float radius, saber_colors_t color );
+
+void FX_BryarHitWall( vec3_t origin, vec3_t normal );
+void FX_BryarAltHitWall( vec3_t origin, vec3_t normal, int power );
+void FX_BryarHitPlayer( vec3_t origin, vec3_t normal, qboolean humanoid );
+void FX_BryarAltHitPlayer( vec3_t origin, vec3_t normal, qboolean humanoid );
+
+void FX_BlasterProjectileThink( centity_t *cent, const struct weaponInfo_s *weapon );
+void FX_BlasterAltFireThink( centity_t *cent, const struct weaponInfo_s *weapon );
+void FX_BlasterWeaponHitWall( vec3_t origin, vec3_t normal );
+void FX_BlasterWeaponHitPlayer( gentity_t *hit, vec3_t origin, vec3_t normal, qboolean humanoid );
+
+void FX_DisruptorMainShot( vec3_t start, vec3_t end );
+void FX_DisruptorAltShot( vec3_t start, vec3_t end, qboolean full );
+void FX_DisruptorAltMiss( vec3_t origin, vec3_t normal );
+
+void FX_BowcasterHitWall( vec3_t origin, vec3_t normal );
+void FX_BowcasterHitPlayer( vec3_t origin, vec3_t normal, qboolean humanoid );
+
+void FX_RepeaterHitWall( vec3_t origin, vec3_t normal );
+void FX_RepeaterAltHitWall( vec3_t origin, vec3_t normal );
+void FX_RepeaterHitPlayer( vec3_t origin, vec3_t normal, qboolean humanoid );
+void FX_RepeaterAltHitPlayer( vec3_t origin, vec3_t normal, qboolean humanoid );
+
+void FX_DEMP2_HitWall( vec3_t origin, vec3_t normal );
+void FX_DEMP2_HitPlayer( vec3_t origin, vec3_t normal, qboolean humanoid );
+void FX_DEMP2_AltDetonate( vec3_t org, float size );
+
+void FX_FlechetteProjectileThink( centity_t *cent, const struct weaponInfo_s *weapon );
+void FX_FlechetteWeaponHitWall( vec3_t origin, vec3_t normal );
+void FX_FlechetteWeaponHitPlayer( vec3_t origin, vec3_t normal, qboolean humanoid );
+
+void FX_RocketHitWall( vec3_t origin, vec3_t normal );
+void FX_RocketHitPlayer( vec3_t origin, vec3_t normal, qboolean humanoid );
+
+void FX_ConcProjectileThink( centity_t *cent, const struct weaponInfo_s *weapon );
+void FX_ConcHitWall( vec3_t origin, vec3_t normal );
+void FX_ConcHitPlayer( vec3_t origin, vec3_t normal, qboolean humanoid );
+void FX_ConcAltShot( vec3_t start, vec3_t end );
+void FX_ConcAltMiss( vec3_t origin, vec3_t normal );
+
+void FX_EmplacedHitWall( vec3_t origin, vec3_t normal, qboolean eweb );
+void FX_EmplacedHitPlayer( vec3_t origin, vec3_t normal, qboolean eweb );
+void FX_EmplacedProjectileThink( centity_t *cent, const struct weaponInfo_s *weapon );
+
+void FX_ATSTMainHitWall( vec3_t origin, vec3_t normal );
+void FX_ATSTMainHitPlayer( vec3_t origin, vec3_t normal, qboolean humanoid );
+void FX_ATSTMainProjectileThink( centity_t *cent, const struct weaponInfo_s *weapon );
+
+void FX_TuskenShotProjectileThink( centity_t *cent, const struct weaponInfo_s *weapon );
+void FX_TuskenShotWeaponHitWall( vec3_t origin, vec3_t normal );
+void FX_TuskenShotWeaponHitPlayer( gentity_t *hit, vec3_t origin, vec3_t normal, qboolean humanoid );
+
+void FX_NoghriShotProjectileThink( centity_t *cent, const struct weaponInfo_s *weapon );
+void FX_NoghriShotWeaponHitWall( vec3_t origin, vec3_t normal );
+void FX_NoghriShotWeaponHitPlayer( gentity_t *hit, vec3_t origin, vec3_t normal, qboolean humanoid );
+
+void CG_BounceEffect( centity_t *cent, int weapon, vec3_t origin, vec3_t normal );
+void CG_MissileStick( centity_t *cent, int weapon, vec3_t origin );
+
+void CG_MissileHitPlayer( centity_t *cent, int weapon, vec3_t origin, vec3_t dir, qboolean altFire );
+void CG_MissileHitWall( centity_t *cent, int weapon, vec3_t origin, vec3_t dir, qboolean altFire );
+
+void CG_DrawTargetBeam( vec3_t start, vec3_t end, vec3_t norm, const char *beamFx, const char *impactFx );
+
+
+/*
+Ghoul2 Insert Start
+*/
+// CG specific API access
+void		trap_G2_SetGhoul2ModelIndexes(CGhoul2Info_v &ghoul2, qhandle_t *modelList, qhandle_t *skinList);
+void		CG_Init_CG(void);
+
+void CG_SetGhoul2Info( refEntity_t *ent, centity_t *cent);
+
+/*
+Ghoul2 Insert End
+*/
+void	trap_Com_SetOrgAngles(vec3_t org,vec3_t angles);
+void	trap_R_GetLightStyle(int style, color4ub_t color);
+void	trap_R_SetLightStyle(int style, int color);
+
+int		trap_CIN_PlayCinematic( const char *arg0, int xpos, int ypos, int width, int height, int bits, const char *psAudioFile = NULL);
+e_status trap_CIN_StopCinematic(int handle);
+e_status trap_CIN_RunCinematic (int handle);
+void	trap_CIN_DrawCinematic (int handle);
+void	trap_CIN_SetExtents (int handle, int x, int y, int w, int h);
+void	*cgi_Z_Malloc( int size, int tag );
+void	cgi_Z_Free( void *ptr );
+
+int		cgi_SP_GetStringTextString(const char *text, char *buf, int bufferlength);
+
+
+void	cgi_UI_Menu_Reset( void );
+void	cgi_UI_Menu_New(char *buf );
+void	cgi_UI_Menu_OpenByName(char *buf);
+void	cgi_UI_SetActive_Menu(char *name);
+void	cgi_UI_Parse_Int(int *value);
+void	cgi_UI_Parse_String(char *buf);
+void	cgi_UI_Parse_Float(float *value);
+int		cgi_UI_StartParseSession(char *menuFile,char **buf);
+void	cgi_UI_ParseExt(char **token);
+void	cgi_UI_MenuPaintAll(void);
+void	cgi_UI_MenuCloseAll(void);
+void	cgi_UI_String_Init(void);
+int		cgi_UI_GetMenuItemInfo(const char *menuFile,const char *itemName,int *x,int *y,int *w,int *h,vec4_t color,qhandle_t *background);
+int		cgi_UI_GetMenuInfo(char *menuFile,int *x,int *y,int *w,int *h);
+
+void	SetWeaponSelectTime(void);
+
+void CG_PlayEffectBolted( const char *fxName, const int modelIndex, const int boltIndex, const int entNum, vec3_t origin, int iLoopTime=0, const bool isRelative=false );
+void CG_PlayEffectIDBolted( const int fxID, const int modelIndex, const int boltIndex, const int entNum, vec3_t origin, int iLoopTime=0, const bool isRelative=false );
+void CG_PlayEffectOnEnt( const char *fxName, const int clientNum, vec3_t origin, const vec3_t fwd );
+void CG_PlayEffectIDOnEnt( const int fxID, const int clientNum, vec3_t origin, const vec3_t fwd );
+void CG_PlayEffect( const char *fxName, vec3_t origin, const vec3_t fwd );
+void CG_PlayEffectID( const int fxID, vec3_t origin, const vec3_t fwd );
+
+#endif	//__CG_LOCAL_H__
diff --git a/code/cgame/cg_localents.cpp b/code/cgame/cg_localents.cpp
new file mode 100644
index 0000000..b2e9702
--- /dev/null
+++ b/code/cgame/cg_localents.cpp
@@ -0,0 +1,599 @@
+// cg_localents.c -- every frame, generate renderer commands for locally
+// processed entities, like smoke puffs, gibs, shells, etc.
+
+// this line must stay at top so the whole PCH thing works...
+#include "cg_headers.h"
+
+
+#include "cg_media.h"
+
+#ifdef _XBOX
+#define	MAX_LOCAL_ENTITIES	128
+#else
+#define	MAX_LOCAL_ENTITIES	512
+#endif
+localEntity_t	cg_localEntities[MAX_LOCAL_ENTITIES];
+localEntity_t	cg_activeLocalEntities;		// double linked list
+localEntity_t	*cg_freeLocalEntities;		// single linked list
+
+/*
+===================
+CG_InitLocalEntities
+
+This is called at startup and for tournement restarts
+===================
+*/
+
+void	CG_InitLocalEntities( void ) {
+	int		i;
+
+	memset( cg_localEntities, 0, sizeof( cg_localEntities ) );
+	cg_activeLocalEntities.next = &cg_activeLocalEntities;
+	cg_activeLocalEntities.prev = &cg_activeLocalEntities;
+	cg_freeLocalEntities = cg_localEntities;
+	for ( i = 0 ; i < MAX_LOCAL_ENTITIES - 1 ; i++ ) {
+		cg_localEntities[i].next = &cg_localEntities[i+1];
+	}
+}
+
+
+/*
+==================
+CG_FreeLocalEntity
+==================
+*/
+void CG_FreeLocalEntity( localEntity_t *le ) {
+	if ( !le->prev ) {
+		CG_Error( "CG_FreeLocalEntity: not active" );
+	}
+
+	// remove from the doubly linked active list
+	le->prev->next = le->next;
+	le->next->prev = le->prev;
+
+	// the free list is only singly linked
+	le->next = cg_freeLocalEntities;
+	cg_freeLocalEntities = le;
+}
+
+/*
+===================
+CG_AllocLocalEntity
+
+Will allways succeed, even if it requires freeing an old active entity
+===================
+*/
+localEntity_t	*CG_AllocLocalEntity( void ) {
+	localEntity_t	*le;
+
+	if ( !cg_freeLocalEntities ) {
+		// no free entities, so free the one at the end of the chain
+		// remove the oldest active entity
+		CG_FreeLocalEntity( cg_activeLocalEntities.prev );
+	}
+
+	le = cg_freeLocalEntities;
+	cg_freeLocalEntities = cg_freeLocalEntities->next;
+
+	memset( le, 0, sizeof( *le ) );
+
+	// link into the active list
+	le->next = cg_activeLocalEntities.next;
+	le->prev = &cg_activeLocalEntities;
+	cg_activeLocalEntities.next->prev = le;
+	cg_activeLocalEntities.next = le;
+	le->ownerGentNum = -1;
+	return le;
+}
+
+
+/*
+====================================================================================
+
+FRAGMENT PROCESSING
+
+A fragment localentity interacts with the environment in some way (hitting walls),
+or generates more localentities along a trail.
+
+====================================================================================
+*/
+
+
+/*
+================
+CG_FragmentBounceSound
+================
+*/
+void CG_FragmentBounceSound( localEntity_t *le, trace_t *trace ) 
+{
+	// half the fragments will make a bounce sounds
+	if ( rand() & 1 ) 
+	{
+		sfxHandle_t	s = 0;
+
+		switch( le->leBounceSoundType )
+		{
+		case LEBS_ROCK:
+			s = cgs.media.rockBounceSound[Q_irand(0,1)];
+			break;
+		case LEBS_METAL:
+			s = cgs.media.metalBounceSound[Q_irand(0,1)];// FIXME: make sure that this sound is registered properly...might still be rock bounce sound....
+			break;
+		}
+
+		if ( s )
+		{
+			cgi_S_StartSound( trace->endpos, ENTITYNUM_WORLD, CHAN_AUTO, s );
+		}
+
+		// bouncers only make the sound once...
+		// FIXME: arbitrary...change if it bugs you
+		le->leBounceSoundType = LEBS_NONE;
+	} 
+	else if ( rand() & 1 )
+	{
+		// we may end up bouncing again, but each bounce reduces the chance of playing the sound again or they may make a lot of noise when they settle
+		// FIXME: maybe just always do this??
+		le->leBounceSoundType = LEBS_NONE;
+	}
+}
+
+
+/*
+================
+CG_ReflectVelocity
+================
+*/
+void CG_ReflectVelocity( localEntity_t *le, trace_t *trace ) 
+{
+	vec3_t	velocity;
+	float	dot;
+	int		hitTime;
+
+	// reflect the velocity on the trace plane
+	hitTime = cg.time - cg.frametime + cg.frametime * trace->fraction;
+	EvaluateTrajectoryDelta( &le->pos, hitTime, velocity );
+	dot = DotProduct( velocity, trace->plane.normal );
+	VectorMA( velocity, -2*dot, trace->plane.normal, le->pos.trDelta );
+
+	VectorScale( le->pos.trDelta, le->bounceFactor, le->pos.trDelta );
+
+	VectorCopy( trace->endpos, le->pos.trBase );
+	le->pos.trTime = cg.time;
+
+	// check for stop, making sure that even on low FPS systems it doesn't bobble
+	if ( trace->allsolid || 
+		( trace->plane.normal[2] > 0 && 
+		( le->pos.trDelta[2] < 40 || le->pos.trDelta[2] < -cg.frametime * le->pos.trDelta[2] ) ) ) 
+	{
+		le->pos.trType = TR_STATIONARY;
+	}
+}
+
+/*
+================
+CG_AddFragment
+================
+*/
+void CG_AddFragment( localEntity_t *le ) 
+{
+	vec3_t	newOrigin;
+	trace_t	trace;
+	// used to sink into the ground, but it looks better to maybe just fade them out
+	int		t;
+	
+	t = le->endTime - cg.time;
+
+	if ( t < FRAG_FADE_TIME ) 
+	{
+		le->refEntity.renderfx |= RF_ALPHA_FADE;
+		le->refEntity.shaderRGBA[0] = le->refEntity.shaderRGBA[1] = le->refEntity.shaderRGBA[2] = 255;
+		le->refEntity.shaderRGBA[3] = ((float)t / FRAG_FADE_TIME) * 255.0f;
+	}
+
+	if ( le->pos.trType == TR_STATIONARY ) 
+	{
+		if ( !(cgi_CM_PointContents( le->refEntity.origin, 0 ) & CONTENTS_SOLID )) 
+		{
+			// thing is no longer in solid, so let gravity take it back
+			VectorCopy( le->refEntity.origin, le->pos.trBase );
+			VectorClear( le->pos.trDelta );
+			le->pos.trTime = cg.time;
+			le->pos.trType = TR_GRAVITY;
+		}
+
+		cgi_R_AddRefEntityToScene( &le->refEntity );
+
+		return;
+	}
+
+	// calculate new position
+	EvaluateTrajectory( &le->pos, cg.time, newOrigin );
+
+	le->refEntity.renderfx |= RF_LIGHTING_ORIGIN;
+	VectorCopy( newOrigin, le->refEntity.lightingOrigin );
+	
+	// trace a line from previous position to new position
+	CG_Trace( &trace, le->refEntity.origin, NULL, NULL, newOrigin, le->ownerGentNum, CONTENTS_SOLID );
+	if ( trace.fraction == 1.0 ) {
+		// still in free fall
+		VectorCopy( newOrigin, le->refEntity.origin );
+
+		if ( le->leFlags & LEF_TUMBLE ) {
+			vec3_t angles;
+
+			EvaluateTrajectory( &le->angles, cg.time, angles );
+			AnglesToAxis( angles, le->refEntity.axis );
+			for(int k = 0; k < 3; k++)
+			{
+				VectorScale(le->refEntity.axis[k], le->radius, le->refEntity.axis[k]);
+			}
+
+		}
+
+		cgi_R_AddRefEntityToScene( &le->refEntity );
+
+		return;
+	}
+
+	// if it is in a nodrop zone, remove it
+	// this keeps gibs from waiting at the bottom of pits of death
+	// and floating levels
+	if ( cgi_CM_PointContents( trace.endpos, 0 ) & CONTENTS_NODROP ) 
+	{
+		CG_FreeLocalEntity( le );
+		return;
+	}
+
+	// do a bouncy sound
+	CG_FragmentBounceSound( le, &trace );
+
+	// reflect the velocity on the trace plane
+	CG_ReflectVelocity( le, &trace );
+	//FIXME: if LEF_TUMBLE, change avelocity too?
+
+	cgi_R_AddRefEntityToScene( &le->refEntity );
+}
+
+/*
+=====================================================================
+
+TRIVIAL LOCAL ENTITIES
+
+These only do simple scaling or modulation before passing to the renderer
+=====================================================================
+*/
+
+/*
+** CG_AddTeleporterEffect
+*/
+void CG_AddTeleporterEffect( localEntity_t *le ) {
+	refEntity_t *re;
+	float c;
+
+	re = &le->refEntity;
+
+	c = ( le->endTime - cg.time ) / ( float ) ( le->endTime - le->startTime );
+
+	re->shaderRGBA[0] =
+	re->shaderRGBA[1] =
+	re->shaderRGBA[2] =
+	re->shaderRGBA[3] = 0xff * c;
+
+	cgi_R_AddRefEntityToScene( re );
+}
+
+/*
+** CG_AddFadeRGB
+*/
+void CG_AddFadeRGB( localEntity_t *le ) {
+	refEntity_t *re;
+	float c;
+
+	re = &le->refEntity;
+
+	c = ( le->endTime - cg.time ) * le->lifeRate;
+	c *= 0xff;
+
+	re->shaderRGBA[0] = le->color[0] * c;
+	re->shaderRGBA[1] = le->color[1] * c;
+	re->shaderRGBA[2] = le->color[2] * c;
+	re->shaderRGBA[3] = le->color[3] * c;
+
+	cgi_R_AddRefEntityToScene( re );
+}
+
+/*
+==================
+CG_AddPuff
+==================
+*/
+static void CG_AddPuff( localEntity_t *le ) {
+	refEntity_t	*re;
+	float		c;
+	vec3_t		delta;
+	float		len;
+
+	re = &le->refEntity;
+
+	// fade / grow time
+	c = ( le->endTime - cg.time ) / (float)( le->endTime - le->startTime );
+
+	re->shaderRGBA[0] = le->color[0] * c;
+	re->shaderRGBA[1] = le->color[1] * c;
+	re->shaderRGBA[2] = le->color[2] * c;
+
+	if ( !( le->leFlags & LEF_PUFF_DONT_SCALE ) ) {
+		re->radius = le->radius * ( 1.0 - c ) + 8;
+	}
+
+	EvaluateTrajectory( &le->pos, cg.time, re->origin );
+
+	// if the view would be "inside" the sprite, kill the sprite
+	// so it doesn't add too much overdraw
+	VectorSubtract( re->origin, cg.refdef.vieworg, delta );
+	len = VectorLength( delta );
+	if ( len < le->radius ) {
+		CG_FreeLocalEntity( le );
+		return;
+	}
+
+	cgi_R_AddRefEntityToScene( re );
+}
+
+/*
+================
+CG_AddLocalLight
+================
+*/
+static void CG_AddLocalLight( localEntity_t *le ) 
+{
+	// There should be a light if this is being used, but hey...
+	if ( le->light ) 
+	{
+		float		light;
+
+		light = (float)( cg.time - le->startTime ) / ( le->endTime - le->startTime );
+
+		if ( light < 0.5 ) 
+		{
+			light = 1.0;
+		} 
+		else 
+		{
+			light = 1.0 - ( light - 0.5 ) * 2;
+		}
+
+		light = le->light * light;
+
+		cgi_R_AddLightToScene( le->refEntity.origin, light, le->lightColor[0], le->lightColor[1], le->lightColor[2] );
+	}
+}
+
+//---------------------------------------------------
+static void CG_AddFadeModel( localEntity_t *le )
+{
+	refEntity_t	*ent = &le->refEntity;
+
+	if ( cg.time < le->startTime )
+	{
+		CG_FreeLocalEntity( le );
+		return;
+	}
+
+	float frac = 1.0f - ((float)( cg.time - le->startTime )/(float)( le->endTime - le->startTime ));
+
+	ent->shaderRGBA[0] = le->color[0] * frac;
+	ent->shaderRGBA[1] = le->color[1] * frac;
+	ent->shaderRGBA[2] = le->color[2] * frac;
+	ent->shaderRGBA[3] = le->color[3] * frac;
+
+	EvaluateTrajectory( &le->pos, cg.time, ent->origin );
+
+	// add the entity
+	cgi_R_AddRefEntityToScene( ent );
+}
+
+// NOTE: this is 100% for the demp2 alt-fire effect, so changes to the visual effect will affect game side demp2 code
+//---------------------------------------------------
+static void CG_AddFadeScaleModel( localEntity_t *le )
+{
+	refEntity_t	*ent = &le->refEntity;
+
+	float frac = ( cg.time - le->startTime )/((float)( le->endTime - le->startTime ));
+
+	frac *= frac * frac; // yes, this is completely ridiculous...but it causes the shell to grow slowly then "explode" at the end
+
+	ent->nonNormalizedAxes = qtrue;
+
+	AxisCopy( axisDefault, ent->axis );
+
+	VectorScale( ent->axis[0], le->radius * frac, ent->axis[0] );
+	VectorScale( ent->axis[1], le->radius * frac, ent->axis[1] );
+	VectorScale( ent->axis[2], le->radius * 0.5f * frac, ent->axis[2] );
+
+	frac = 1.0f - frac;
+
+	ent->shaderRGBA[0] = le->color[0] * frac;
+	ent->shaderRGBA[1] = le->color[1] * frac;
+	ent->shaderRGBA[2] = le->color[2] * frac;
+	ent->shaderRGBA[3] = le->color[3] * frac;
+
+	// add the entity
+	cgi_R_AddRefEntityToScene( ent );
+}
+
+// create a quad that doesn't use a refEnt.  Currently only for use with the DebugNav drawing so it doesn't have to use fx
+//------------------------------------------
+static void CG_AddQuad( localEntity_t *le )
+{
+	polyVert_t	verts[4];
+
+	VectorCopy( le->refEntity.origin, verts[0].xyz );
+	verts[0].xyz[0] -= le->radius;
+	verts[0].xyz[1] -= le->radius;
+	verts[0].st[0] = 0;
+	verts[0].st[1] = 0;
+
+	for ( int i = 0; i < 4; i++ )
+	{
+		verts[i].modulate[0] = le->color[0];
+		verts[i].modulate[1] = le->color[1];
+		verts[i].modulate[2] = le->color[2];
+		verts[i].modulate[3] = le->color[3];
+	}
+
+	VectorCopy( le->refEntity.origin, verts[1].xyz );
+	verts[1].xyz[0] -= le->radius;
+	verts[1].xyz[1] += le->radius;
+	verts[1].st[0] = 0;
+	verts[1].st[1] = 1;
+
+	VectorCopy( le->refEntity.origin, verts[2].xyz );
+	verts[2].xyz[0] += le->radius;
+	verts[2].xyz[1] += le->radius;
+	verts[2].st[0] = 1;
+	verts[2].st[1] = 1;
+
+	VectorCopy( le->refEntity.origin, verts[3].xyz );
+	verts[3].xyz[0] += le->radius;
+	verts[3].xyz[1] -= le->radius;
+	verts[3].st[0] = 1;
+	verts[3].st[1] = 0;
+
+	cgi_R_AddPolyToScene( le->refEntity.customShader, 4, verts );
+}
+
+// create a sprite that doesn't use a refEnt.  Currently only for use with the DebugNav drawing so it doesn't have to use fx
+//------------------------------------------
+static void CG_AddSprite( localEntity_t *le )
+{
+	polyVert_t	verts[4];
+
+	VectorCopy( le->refEntity.origin, verts[0].xyz );
+	VectorMA( verts[0].xyz, -le->radius, cg.refdef.viewaxis[2], verts[0].xyz );
+	VectorMA( verts[0].xyz, -le->radius, cg.refdef.viewaxis[1], verts[0].xyz );
+	verts[0].st[0] = 0;
+	verts[0].st[1] = 0;
+
+	for ( int i = 0; i < 4; i++ )
+	{
+		verts[i].modulate[0] = le->color[0];
+		verts[i].modulate[1] = le->color[1];
+		verts[i].modulate[2] = le->color[2];
+		verts[i].modulate[3] = le->color[3];
+	}
+
+	VectorCopy( le->refEntity.origin, verts[1].xyz );
+	VectorMA( verts[1].xyz, -le->radius, cg.refdef.viewaxis[2], verts[1].xyz );
+	VectorMA( verts[1].xyz, le->radius, cg.refdef.viewaxis[1], verts[1].xyz );
+	verts[1].st[0] = 0;
+	verts[1].st[1] = 1;
+
+	VectorCopy( le->refEntity.origin, verts[2].xyz );
+	VectorMA( verts[2].xyz, le->radius, cg.refdef.viewaxis[2], verts[2].xyz );
+	VectorMA( verts[2].xyz, le->radius, cg.refdef.viewaxis[1], verts[2].xyz );
+	verts[2].st[0] = 1;
+	verts[2].st[1] = 1;
+
+	VectorCopy( le->refEntity.origin, verts[3].xyz );
+	VectorMA( verts[3].xyz, le->radius, cg.refdef.viewaxis[2], verts[3].xyz );
+	VectorMA( verts[3].xyz, -le->radius, cg.refdef.viewaxis[1], verts[3].xyz );
+	verts[3].st[0] = 1;
+	verts[3].st[1] = 0;
+
+	cgi_R_AddPolyToScene( le->refEntity.customShader, 4, verts );
+}
+
+/*
+===================
+CG_AddLine
+
+for beams and the like.
+===================
+*/
+void CG_AddLine( localEntity_t *le )
+{
+	refEntity_t	*re;
+
+	re = &le->refEntity;
+
+	re->reType = RT_LINE;
+
+	cgi_R_AddRefEntityToScene( re );
+}
+
+//==============================================================================
+
+/*
+===================
+CG_AddLocalEntities
+
+===================
+*/
+void CG_AddLocalEntities( void ) 
+{
+	localEntity_t	*le, *next;
+
+	// walk the list backwards, so any new local entities generated
+	// (trails, marks, etc) will be present this frame
+	le = cg_activeLocalEntities.prev;
+	for ( ; le != &cg_activeLocalEntities ; le = next ) {
+		// grab next now, so if the local entity is freed we
+		// still have it
+		next = le->prev;
+
+		if ( cg.time >= le->endTime ) {
+			CG_FreeLocalEntity( le );
+			continue;
+		}
+		switch ( le->leType ) {
+		default:
+			CG_Error( "Bad leType: %i", le->leType );
+			break;
+
+		case LE_MARK:
+			break;
+
+		case LE_FADE_MODEL:
+			CG_AddFadeModel( le );
+			break;
+
+		case LE_FADE_SCALE_MODEL:
+			CG_AddFadeScaleModel( le );
+			break;
+
+		case LE_FRAGMENT:
+			CG_AddFragment( le );
+			break;
+
+		case LE_PUFF:
+			CG_AddPuff( le );
+			break;
+
+		case LE_FADE_RGB:		// teleporters, railtrails
+			CG_AddFadeRGB( le );
+			break;
+
+		case LE_LIGHT:
+			CG_AddLocalLight( le );
+			break;
+
+		case LE_LINE:					// oriented lines for FX
+			CG_AddLine( le );
+			break;
+
+		// Use for debug only
+		case LE_QUAD:
+			CG_AddQuad( le );
+			break;
+
+		case LE_SPRITE:
+			CG_AddSprite( le );
+		}
+	}
+}
+
+
+
+
diff --git a/code/cgame/cg_main.cpp b/code/cgame/cg_main.cpp
new file mode 100644
index 0000000..0dd69ad
--- /dev/null
+++ b/code/cgame/cg_main.cpp
@@ -0,0 +1,4517 @@
+// this line must stay at top so the whole PCH thing works...
+#include "cg_headers.h"
+//#include "../ui/ui_shared.h"
+
+//#include "cg_local.h"
+#include "cg_media.h"
+#include "FxScheduler.h"
+
+#include "..\client\vmachine.h"
+#include "cg_lights.h"
+
+#ifdef _IMMERSION
+#include "../ff/ff.h"
+#endif // _IMMERSION
+#include "../qcommon/sstring.h"
+//NOTENOTE: Be sure to change the mirrored code in g_shared.h
+typedef	map< sstring_t, unsigned char, less<sstring_t>, allocator< unsigned char >  >	namePrecache_m;
+extern namePrecache_m	*as_preCacheMap;
+extern void CG_RegisterNPCCustomSounds( clientInfo_t *ci );
+extern qboolean G_AddSexToMunroString ( char *string, qboolean qDoBoth );
+//extern void CG_RegisterNPCEffects( team_t team );
+extern int G_ParseAnimFileSet( const char *skeletonName, const char *modelName=0);
+extern void CG_DrawDataPadInventorySelect( void );
+
+void CG_Init( int serverCommandSequence );
+qboolean CG_ConsoleCommand( void );
+void CG_Shutdown( void );
+int CG_GetCameraPos( vec3_t camerapos );
+int CG_GetCameraAng( vec3_t cameraang );
+void UseItem(int itemNum);
+const char *CG_DisplayBoxedText(int iBoxX, int iBoxY, int iBoxWidth, int iBoxHeight, 
+								const char *psText, int iFontHandle, float fScale,
+								const vec4_t v4Color);
+
+#define NUM_CHUNKS		6
+/*
+Ghoul2 Insert Start
+*/
+
+void CG_ResizeG2Bolt(boltInfo_v *bolt, int newCount);
+void CG_ResizeG2Surface(surfaceInfo_v *surface, int newCount);
+void CG_ResizeG2Bone(boneInfo_v *bone, int newCount);
+void CG_ResizeG2(CGhoul2Info_v *ghoul2, int newCount);
+void CG_ResizeG2TempBone(mdxaBone_v *tempBone, int newCount);
+/*
+Ghoul2 Insert End
+*/
+
+
+#ifdef _XBOX
+extern bool CL_ExtendSelectTime(void);
+#endif
+
+
+
+void CG_LoadHudMenu(void);
+int inv_icons[INV_MAX];
+char *inv_names[] =
+{
+"ELECTROBINOCULARS",
+"BACTA CANISTER",
+"SEEKER",
+"LIGHT AMP GOGGLES",
+"ASSAULT SENTRY",
+"GOODIE KEY",
+"GOODIE KEY",
+"GOODIE KEY",
+"GOODIE KEY",
+"GOODIE KEY",
+"SECURITY KEY",
+"SECURITY KEY",
+"SECURITY KEY",
+"SECURITY KEY",
+"SECURITY KEY",
+};
+
+int	force_icons[NUM_FORCE_POWERS];
+
+
+void CG_DrawDataPadHUD( centity_t *cent );
+void CG_DrawDataPadObjectives(const centity_t *cent );
+void CG_DrawDataPadIconBackground(const int backgroundType);
+void CG_DrawDataPadWeaponSelect( void );
+void CG_DrawDataPadForceSelect( void );
+
+/*
+================
+vmMain
+
+This is the only way control passes into the cgame module.
+This must be the very first function compiled into the .q3vm file
+================
+*/
+int vmMain( int command, int arg0, int arg1, int arg2, int arg3, int arg4, int arg5, int arg6, int arg7 ) {
+	centity_t		*cent;
+
+	switch ( command ) {
+	case CG_INIT:
+		CG_Init( arg0 );
+		return 0;
+	case CG_SHUTDOWN:
+		CG_Shutdown();
+		return 0;
+	case CG_CONSOLE_COMMAND:
+		return CG_ConsoleCommand();
+	case CG_DRAW_ACTIVE_FRAME:
+		CG_DrawActiveFrame( arg0, (stereoFrame_t) arg1 );
+		return 0;
+	case CG_CROSSHAIR_PLAYER:
+		return CG_CrosshairPlayer();
+	case CG_CAMERA_POS:
+		return CG_GetCameraPos( (float*)arg0);
+	case CG_CAMERA_ANG:
+		return CG_GetCameraAng( (float*)arg0);
+/*
+Ghoul2 Insert Start
+*/
+	case CG_RESIZE_G2:
+		CG_ResizeG2((CGhoul2Info_v *)arg0, arg1);
+		return 0;
+	case CG_RESIZE_G2_BOLT:
+		CG_ResizeG2Bolt((boltInfo_v *)arg0, arg1);
+		return 0;
+	case CG_RESIZE_G2_BONE:
+		CG_ResizeG2Bone((boneInfo_v *)arg0, arg1);
+		return 0;
+	case CG_RESIZE_G2_SURFACE:
+		CG_ResizeG2Surface((surfaceInfo_v *)arg0, arg1);
+		return 0;
+	case CG_RESIZE_G2_TEMPBONE:
+		CG_ResizeG2TempBone((mdxaBone_v *)arg0, arg1);
+		return 0;
+
+/*
+Ghoul2 Insert End
+*/
+	case CG_DRAW_DATAPAD_HUD:
+		if (cg.snap)
+		{
+			cent = &cg_entities[cg.snap->ps.clientNum];
+			CG_DrawDataPadHUD(cent);
+		}
+		return 0;
+
+	case CG_DRAW_DATAPAD_OBJECTIVES:
+		if (cg.snap)
+		{
+			cent = &cg_entities[cg.snap->ps.clientNum];
+			CG_DrawDataPadObjectives(cent);
+		}
+		return 0;
+
+	case CG_DRAW_DATAPAD_WEAPONS:
+		if (cg.snap)
+		{
+			CG_DrawDataPadIconBackground(ICON_WEAPONS);
+			CG_DrawDataPadWeaponSelect();
+		}
+		return 0;
+	case CG_DRAW_DATAPAD_INVENTORY:
+		if (cg.snap)
+		{
+			CG_DrawDataPadIconBackground(ICON_INVENTORY);
+			CG_DrawDataPadInventorySelect();
+		}
+		return 0;
+	case CG_DRAW_DATAPAD_FORCEPOWERS:
+		if (cg.snap)
+		{
+			CG_DrawDataPadIconBackground(ICON_FORCE);
+			CG_DrawDataPadForceSelect();
+		}
+		return 0;
+	}
+	return -1;
+}
+
+/*
+Ghoul2 Insert Start
+*/
+
+void CG_ResizeG2Bolt(boltInfo_v *bolt, int newCount)
+{
+	bolt->resize(newCount);
+}
+
+void CG_ResizeG2Surface(surfaceInfo_v *surface, int newCount)
+{
+	surface->resize(newCount);
+}
+
+void CG_ResizeG2Bone(boneInfo_v *bone, int newCount)
+{
+	bone->resize(newCount);
+}
+
+void CG_ResizeG2(CGhoul2Info_v *ghoul2, int newCount)
+{
+	ghoul2->resize(newCount);
+}
+
+void CG_ResizeG2TempBone(mdxaBone_v *tempBone, int newCount)
+{
+	tempBone->resize(newCount);
+}
+/*
+Ghoul2 Insert End
+*/
+
+cg_t				cg;
+cgs_t				cgs;
+centity_t			cg_entities[MAX_GENTITIES];
+
+centity_t			*cg_permanents[MAX_GENTITIES];
+int					cg_numpermanents = 0;
+
+weaponInfo_t		cg_weapons[MAX_WEAPONS];
+itemInfo_t			cg_items[MAX_ITEMS];
+
+typedef struct {
+	qboolean		registered;		// Has the player picked it up
+	qboolean		active;			// Is it the chosen inventory item
+	int				count;			// Count of items.
+	char			description[128];
+} inventoryInfo_t;
+
+inventoryInfo_t		cg_inventory[INV_MAX];
+
+vmCvar_t	cg_runpitch;
+vmCvar_t	cg_runroll;
+vmCvar_t	cg_bobup;
+vmCvar_t	cg_bobpitch;
+vmCvar_t	cg_bobroll;
+vmCvar_t	cg_shadows;
+vmCvar_t	cg_renderToTextureFX;
+vmCvar_t	cg_shadowCullDistance;
+vmCvar_t	cg_footsteps;
+vmCvar_t	cg_saberEntMarks;
+vmCvar_t	cg_paused;
+vmCvar_t	cg_drawTimer;
+vmCvar_t	cg_drawFPS;
+vmCvar_t	cg_drawSnapshot;
+vmCvar_t	cg_drawAmmoWarning;
+vmCvar_t	cg_drawCrosshair;
+vmCvar_t	cg_crosshairIdentifyTarget;
+//vmCvar_t	cg_dynamicCrosshair;
+vmCvar_t	cg_crosshairForceHint;
+vmCvar_t	cg_crosshairX;
+vmCvar_t	cg_crosshairY;
+vmCvar_t	cg_crosshairSize;
+vmCvar_t	cg_draw2D;
+vmCvar_t	cg_drawStatus;
+vmCvar_t	cg_drawHUD;
+vmCvar_t	cg_debugAnim;
+#ifndef FINAL_BUILD
+vmCvar_t	cg_debugAnimTarget;
+vmCvar_t	cg_gun_frame;
+#endif
+vmCvar_t	cg_debugSaber;
+vmCvar_t	cg_debugEvents;
+vmCvar_t	cg_errorDecay;
+vmCvar_t	cg_addMarks;
+vmCvar_t	cg_drawGun;
+vmCvar_t	cg_autoswitch;
+vmCvar_t	cg_simpleItems;
+vmCvar_t	cg_fov;
+vmCvar_t	cg_endcredits;
+vmCvar_t	cg_updatedDataPadForcePower1;
+vmCvar_t	cg_updatedDataPadForcePower2;
+vmCvar_t	cg_updatedDataPadForcePower3;
+vmCvar_t	cg_updatedDataPadObjective;
+vmCvar_t	cg_drawBreath;
+vmCvar_t	cg_roffdebug;
+#ifndef FINAL_BUILD
+vmCvar_t	cg_roffval1;
+vmCvar_t	cg_roffval2;
+vmCvar_t	cg_roffval3;
+vmCvar_t	cg_roffval4;
+#endif
+vmCvar_t	cg_thirdPerson;
+vmCvar_t	cg_thirdPersonRange;
+vmCvar_t	cg_thirdPersonMaxRange;
+vmCvar_t	cg_thirdPersonAngle;
+vmCvar_t	cg_thirdPersonPitchOffset;
+vmCvar_t	cg_thirdPersonVertOffset;
+vmCvar_t	cg_thirdPersonCameraDamp;
+vmCvar_t	cg_thirdPersonTargetDamp;
+vmCvar_t	cg_gunAutoFirst;
+
+vmCvar_t	cg_thirdPersonAlpha;
+vmCvar_t	cg_thirdPersonAutoAlpha;
+vmCvar_t	cg_thirdPersonHorzOffset;
+
+vmCvar_t	cg_stereoSeparation;
+vmCvar_t 	cg_developer;
+vmCvar_t 	cg_timescale;
+vmCvar_t	cg_skippingcin;
+
+vmCvar_t	cg_pano;
+vmCvar_t	cg_panoNumShots;
+
+vmCvar_t	fx_freeze;
+vmCvar_t	fx_debug;
+
+vmCvar_t	cg_missionInfoFlashTime;
+vmCvar_t	cg_hudFiles;
+
+vmCvar_t	cg_neverHearThatDumbBeepingSoundAgain;
+
+vmCvar_t	cg_VariantSoundCap;	// 0 = no capping, else cap to (n) max (typically just 1, but allows more)
+vmCvar_t	cg_turnAnims;
+vmCvar_t	cg_motionBoneComp;
+vmCvar_t	cg_distributeMBCorrection;
+vmCvar_t	cg_reliableAnimEvents;
+
+vmCvar_t	cg_smoothPlayerPos;
+vmCvar_t	cg_smoothPlayerPlat;
+vmCvar_t	cg_smoothPlayerPlatAccel;
+vmCvar_t	cg_g2Marks;
+vmCvar_t	fx_expensivePhysics;
+vmCvar_t	cg_debugHealthBars;
+
+typedef struct {
+	vmCvar_t	*vmCvar;
+	char		*cvarName;
+	char		*defaultString;
+	int			cvarFlags;
+} cvarTable_t;
+
+static cvarTable_t cvarTable[] = {
+	{ &cg_autoswitch, "cg_autoswitch", "1", CVAR_ARCHIVE },
+	{ &cg_drawGun, "cg_drawGun", "1", CVAR_ARCHIVE },
+	{ &cg_fov, "cg_fov", "80", 0 },//must be 80
+	{ &cg_stereoSeparation, "cg_stereoSeparation", "0.4", CVAR_ARCHIVE  },
+	{ &cg_shadows, "cg_shadows", "1", CVAR_ARCHIVE  },
+	{ &cg_renderToTextureFX, "cg_renderToTextureFX", "1", CVAR_ARCHIVE  },
+	{ &cg_shadowCullDistance, "r_shadowRange", "1000", CVAR_ARCHIVE },
+	{ &cg_footsteps, "cg_footsteps", "3", CVAR_ARCHIVE  },//1 = sounds, 2 = sounds & effects, 3 = sounds, effects & marks, 4 = always
+	{ &cg_saberEntMarks, "cg_saberEntMarks", "1", CVAR_ARCHIVE  },
+
+	{ &cg_draw2D, "cg_draw2D", "1", CVAR_ARCHIVE  },
+	{ &cg_drawStatus, "cg_drawStatus", "1", CVAR_ARCHIVE  },
+	{ &cg_drawHUD, "cg_drawHUD", "1", 0  },
+	{ &cg_drawTimer, "cg_drawTimer", "0", CVAR_ARCHIVE  },
+	{ &cg_drawFPS, "cg_drawFPS", "0", CVAR_ARCHIVE  },
+	{ &cg_drawSnapshot, "cg_drawSnapshot", "0", CVAR_ARCHIVE  },
+	{ &cg_drawAmmoWarning, "cg_drawAmmoWarning", "1", CVAR_ARCHIVE  },
+	{ &cg_drawCrosshair, "cg_drawCrosshair", "1", CVAR_ARCHIVE },
+//	{ &cg_dynamicCrosshair, "cg_dynamicCrosshair", "1", CVAR_ARCHIVE },
+	// NOTE : I also create this in UI_Init()
+	{ &cg_crosshairIdentifyTarget, "cg_crosshairIdentifyTarget", "1", CVAR_ARCHIVE },
+	{ &cg_crosshairForceHint, "cg_crosshairForceHint", "1", CVAR_ARCHIVE },
+	{ &cg_endcredits, "cg_endcredits", "0", 0},
+	{ &cg_updatedDataPadForcePower1, "cg_updatedDataPadForcePower1", "0", 0},
+	{ &cg_updatedDataPadForcePower2, "cg_updatedDataPadForcePower2", "0", 0},
+	{ &cg_updatedDataPadForcePower3, "cg_updatedDataPadForcePower3", "0", 0},
+	{ &cg_updatedDataPadObjective, "cg_updatedDataPadObjective", "0", 0},
+
+	{ &cg_crosshairSize, "cg_crosshairSize", "24", CVAR_ARCHIVE },
+	{ &cg_crosshairX, "cg_crosshairX", "0", CVAR_ARCHIVE },
+	{ &cg_crosshairY, "cg_crosshairY", "0", CVAR_ARCHIVE },
+	{ &cg_simpleItems, "cg_simpleItems", "0", CVAR_ARCHIVE },
+	// NOTE : I also create this in UI_Init()
+	{ &cg_addMarks, "cg_marks", "1", CVAR_ARCHIVE },
+	// NOTE : I also create these weapon sway cvars in UI_Init()
+	{ &cg_runpitch, "cg_runpitch", "0.002", CVAR_ARCHIVE},
+	{ &cg_runroll, "cg_runroll", "0.005", CVAR_ARCHIVE },
+	{ &cg_bobup , "cg_bobup", "0.005", CVAR_ARCHIVE },
+	{ &cg_bobpitch, "cg_bobpitch", "0.002", CVAR_ARCHIVE },
+	{ &cg_bobroll, "cg_bobroll", "0.002", CVAR_ARCHIVE },
+
+	{ &cg_debugAnim, "cg_debuganim", "0", CVAR_CHEAT },
+#ifndef FINAL_BUILD
+	{ &cg_gun_frame, "gun_frame", "0", CVAR_CHEAT },
+	{ &cg_debugAnimTarget, "cg_debugAnimTarget", "0", CVAR_CHEAT },
+#endif	
+	{ &cg_debugSaber, "cg_debugsaber", "0", CVAR_CHEAT },
+	{ &cg_debugEvents, "cg_debugevents", "0", CVAR_CHEAT },
+	{ &cg_errorDecay, "cg_errordecay", "100", 0 },
+
+	{ &cg_drawBreath, "cg_drawBreath", "0", CVAR_ARCHIVE },		// Added 11/07/02
+	{ &cg_roffdebug, "cg_roffdebug", "0" },
+#ifndef FINAL_BUILD
+	{ &cg_roffval1, "cg_roffval1", "0" },
+	{ &cg_roffval2, "cg_roffval2", "0" },
+	{ &cg_roffval3, "cg_roffval3", "0" },
+	{ &cg_roffval4, "cg_roffval4", "0" },
+#endif
+	{ &cg_thirdPerson, "cg_thirdPerson", "1", CVAR_SAVEGAME },
+	{ &cg_thirdPersonRange, "cg_thirdPersonRange", "80", 0 },
+	{ &cg_thirdPersonMaxRange, "cg_thirdPersonMaxRange", "150", 0 },
+	{ &cg_thirdPersonAngle, "cg_thirdPersonAngle", "0", 0 },
+	{ &cg_thirdPersonPitchOffset, "cg_thirdPersonPitchOffset", "0", 0 },
+	{ &cg_thirdPersonVertOffset, "cg_thirdPersonVertOffset", "16", 0},
+	{ &cg_thirdPersonCameraDamp, "cg_thirdPersonCameraDamp", "0.3", 0},
+	{ &cg_thirdPersonTargetDamp, "cg_thirdPersonTargetDamp", "0.5", 0},
+	
+	{ &cg_thirdPersonHorzOffset, "cg_thirdPersonHorzOffset", "0", 0},
+	{ &cg_thirdPersonAlpha,	"cg_thirdPersonAlpha",	"1.0", CVAR_CHEAT },
+	{ &cg_thirdPersonAutoAlpha,	"cg_thirdPersonAutoAlpha",	"0", 0 },
+	// NOTE: also declare this in UI_Init
+	{ &cg_gunAutoFirst, "cg_gunAutoFirst", "1", CVAR_ARCHIVE },
+
+	{ &cg_pano, "pano", "0", 0 },
+	{ &cg_panoNumShots, "panoNumShots", "10", 0 },
+
+	{ &fx_freeze, "fx_freeze", "0", 0 },
+	{ &fx_debug, "fx_debug", "0", 0 },
+	// the following variables are created in other parts of the system,
+	// but we also reference them here
+
+	{ &cg_paused, "cl_paused", "0", CVAR_ROM },
+	{ &cg_developer, "developer", "", 0 }, 
+	{ &cg_timescale, "timescale", "1", 0 }, 	
+	{ &cg_skippingcin, "skippingCinematic", "0", CVAR_ROM},
+	{ &cg_missionInfoFlashTime, "cg_missionInfoFlashTime", "10000", 0  },
+	{ &cg_hudFiles, "cg_hudFiles", "ui/jahud.txt", CVAR_ARCHIVE},
+
+	{ &cg_VariantSoundCap, "cg_VariantSoundCap", "0", 0 },
+	{ &cg_turnAnims, "cg_turnAnims", "0", 0 },
+	{ &cg_motionBoneComp, "cg_motionBoneComp", "2", 0 },
+	{ &cg_distributeMBCorrection, "cg_distributeMBCorrection", "1", 0 },
+	{ &cg_reliableAnimEvents, "cg_reliableAnimEvents", "1", CVAR_ARCHIVE },
+	{ &cg_smoothPlayerPos, "cg_smoothPlayerPos", "0.5", 0},
+	{ &cg_smoothPlayerPlat, "cg_smoothPlayerPlat", "0.75", 0},
+	{ &cg_smoothPlayerPlatAccel, "cg_smoothPlayerPlatAccel", "3.25", 0},
+	{ &cg_g2Marks, "cg_g2Marks", "1", CVAR_ARCHIVE },
+	{ &fx_expensivePhysics, "fx_expensivePhysics", "1", CVAR_ARCHIVE },
+	{ &cg_debugHealthBars,	"cg_debugHealthBars",	"0", CVAR_CHEAT },
+};
+
+static int cvarTableSize = sizeof( cvarTable ) / sizeof( cvarTable[0] );
+
+/*
+=================
+CG_RegisterCvars
+=================
+*/
+void CG_RegisterCvars( void ) {
+	int			i;
+	cvarTable_t	*cv;
+
+	for ( i = 0, cv = cvarTable ; i < cvarTableSize ; i++, cv++ ) {
+		cgi_Cvar_Register( cv->vmCvar, cv->cvarName,
+			cv->defaultString, cv->cvarFlags );
+	}
+}
+
+/*
+=================
+CG_UpdateCvars
+=================
+*/
+void CG_UpdateCvars( void ) {
+	int			i;
+	cvarTable_t	*cv;
+
+	for ( i = 0, cv = cvarTable ; i < cvarTableSize ; i++, cv++ ) {
+		cgi_Cvar_Update( cv->vmCvar );
+	}
+}
+
+
+int CG_CrosshairPlayer( void ) 
+{
+	if ( cg.time > ( cg.crosshairClientTime + 1000 ) ) 
+	{
+		return -1;
+	}
+	return cg.crosshairClientNum;
+}
+
+
+int CG_GetCameraPos( vec3_t camerapos ) {
+	if ( in_camera) {
+		VectorCopy(client_camera.origin, camerapos);
+		return 1;
+	}
+	else if ( cg_entities[0].gent && cg_entities[0].gent->client && cg_entities[0].gent->client->ps.viewEntity > 0 && cg_entities[0].gent->client->ps.viewEntity < ENTITYNUM_WORLD )
+	//else if ( cg.snap && cg.snap->ps.viewEntity > 0 && cg.snap->ps.viewEntity < ENTITYNUM_WORLD )
+	{//in an entity camera view
+		if ( g_entities[cg_entities[0].gent->client->ps.viewEntity].client && cg.renderingThirdPerson )
+		{
+			VectorCopy( g_entities[cg_entities[0].gent->client->ps.viewEntity].client->renderInfo.eyePoint, camerapos );
+		}
+		else
+		{
+			VectorCopy( g_entities[cg_entities[0].gent->client->ps.viewEntity].currentOrigin, camerapos );
+		}
+		//VectorCopy( cg_entities[cg_entities[0].gent->client->ps.viewEntity].lerpOrigin, camerapos );
+		/*
+		if ( g_entities[cg.snap->ps.viewEntity].client && cg.renderingThirdPerson )
+		{
+			VectorCopy( g_entities[cg.snap->ps.viewEntity].client->renderInfo.eyePoint, camerapos );
+		}
+		else
+		{//use the g_ent because it may not have gotten over to the client yet...
+			VectorCopy( g_entities[cg.snap->ps.viewEntity].currentOrigin, camerapos );
+		}
+		*/
+		return 1;
+	}
+	else if ( cg.renderingThirdPerson )
+	{//in third person
+		//FIXME: what about hacks that render in third person regardless of this value?
+		VectorCopy( cg.refdef.vieworg, camerapos );
+		return 1;
+	}
+	else if (cg.snap && (cg.snap->ps.weapon == WP_SABER||cg.snap->ps.weapon == WP_MELEE) )//implied: !cg.renderingThirdPerson 
+	{//first person saber hack
+		VectorCopy( cg.refdef.vieworg, camerapos );
+		return 1;
+	}
+	return 0;
+}
+
+int CG_GetCameraAng( vec3_t cameraang ) 
+{
+	if ( in_camera) 
+	{
+		VectorCopy(client_camera.angles, cameraang);
+		return 1;
+	}
+	else
+	{
+		VectorCopy( cg.refdefViewAngles, cameraang );
+		return 1;
+	}
+}
+
+void CG_TargetCommand_f( void ) {
+	int		targetNum;
+	char	test[4];
+
+	targetNum = CG_CrosshairPlayer();
+	if (targetNum <= 0) {
+		return;
+	}
+
+	cgi_Argv( 1, test, 4 );	//FIXME: this is now an exec_now command - in case we start using it... JFM
+	cgi_SendConsoleCommand( va( "gc %i %i", targetNum, atoi( test ) ) );
+}
+
+
+
+void CG_Printf( const char *msg, ... ) {
+	va_list		argptr;
+	char		text[1024];
+
+	va_start (argptr, msg);
+	vsprintf (text, msg, argptr);
+	va_end (argptr);
+
+	cgi_Printf( text );
+}
+
+void CG_Error( const char *msg, ... ) {
+	va_list		argptr;
+	char		text[1024];
+
+	va_start (argptr, msg);
+	vsprintf (text, msg, argptr);
+	va_end (argptr);
+
+	cgi_Error( text );
+}
+
+
+/*
+================
+CG_Argv
+================
+*/
+const char *CG_Argv( int arg ) {
+	static char	buffer[MAX_STRING_CHARS];
+
+	cgi_Argv( arg, buffer, sizeof( buffer ) );
+
+	return buffer;
+}
+
+
+//========================================================================
+
+/*
+=================
+CG_RegisterItemSounds
+
+The server says this item is used on this level
+=================
+*/
+void CG_RegisterItemSounds( int itemNum ) {
+	gitem_t			*item;
+	char			data[MAX_QPATH];
+	char			*s, *start;
+	int				len;
+
+	item = &bg_itemlist[ itemNum ];
+
+	if (item->pickup_sound)
+	{
+		cgi_S_RegisterSound( item->pickup_sound );
+	}
+
+	// parse the space seperated precache string for other media
+	s = item->sounds;
+	if (!s || !s[0])
+		return;
+
+	while (*s) {
+		start = s;
+		while (*s && *s != ' ') {
+			s++;
+		}
+
+		len = s-start;
+		if (len >= MAX_QPATH || len < 5) {
+			CG_Error( "PrecacheItem: %s has bad precache string", 
+				item->classname);
+			return;
+		}
+		memcpy (data, start, len);
+		data[len] = 0;
+		if ( *s ) {
+			s++;
+		}
+
+		if ( !strcmp(data+len-3, "wav" )) {
+			cgi_S_RegisterSound( data );
+		}
+	}
+}
+
+#ifdef _IMMERSION
+/*
+=================
+CG_RegisterItemForces
+
+The server says this item is used on this level
+=================
+*/
+void CG_RegisterItemForces( int itemNum ) {
+	gitem_t			*item;
+	char			data[MAX_QPATH];
+	char			*s, *start;
+	int				len;
+
+	item = &bg_itemlist[ itemNum ];
+
+	if (item->pickup_force)
+	{
+		cgi_FF_Register( item->pickup_force, FF_CHANNEL_TOUCH );
+	}
+
+	// parse the space seperated precache string for other media
+	s = item->forces;
+	if (!s || !s[0])
+		return;
+
+	while (*s) {
+		start = s;
+		while (*s && *s != ' ') {
+			s++;
+		}
+
+		len = s-start;
+		if (len >= MAX_QPATH) {
+			CG_Error( "PrecacheItem: %s has bad precache string", 
+				item->classname);
+			return;
+		}
+		memcpy (data, start, len);
+		data[len] = 0;
+		if ( *s ) {
+			s++;
+		}
+
+		cgi_FF_Register( data, FF_CHANNEL_TOUCH );
+	}
+}
+#endif // _IMMERSION
+
+/*
+======================
+CG_LoadingString
+
+======================
+*/
+void CG_LoadingString( const char *s ) {
+	Q_strncpyz( cg.infoScreenText, s, sizeof( cg.infoScreenText ) );
+	cgi_UpdateScreen();
+}
+
+
+static inline void CG_AS_Register(void)
+{
+	CG_LoadingString( "ambient sound sets" );
+
+	assert(as_preCacheMap);
+
+	//Load the ambient sets
+
+	cgi_AS_AddPrecacheEntry( "#clear" );	// ;-)
+	//FIXME: Don't ask... I had to get around a really nasty MS error in the templates with this...
+	namePrecache_m::iterator	pi;
+	STL_ITERATE( pi, (*as_preCacheMap) )
+	{
+		cgi_AS_AddPrecacheEntry( ((*pi).first).c_str() );
+	}
+
+	cgi_AS_ParseSets();
+}
+
+
+/*
+=================
+CG_RegisterSounds
+
+called during a precache command
+=================
+*/
+static void CG_RegisterSounds( void ) {
+	int		i;
+	char	name[MAX_QPATH];
+	const char	*soundName;
+
+	CG_AS_Register();
+
+	CG_LoadingString( "general sounds" );
+
+	//FIXME: add to cg.media?
+	cgi_S_RegisterSound( "sound/player/fallsplat.wav" );
+
+	cgs.media.selectSound = cgi_S_RegisterSound( "sound/weapons/change.wav" );
+	cgs.media.selectSound2 = cgi_S_RegisterSound( "sound/interface/sub_select.wav" );
+//	cgs.media.useNothingSound = cgi_S_RegisterSound( "sound/items/use_nothing.wav" );
+
+	cgs.media.noAmmoSound = cgi_S_RegisterSound( "sound/weapons/noammo.wav" );
+//	cgs.media.talkSound = 	cgi_S_RegisterSound( "sound/interface/communicator.wav" );
+	cgs.media.landSound =	cgi_S_RegisterSound( "sound/player/land1.wav");
+	cgs.media.rollSound =	cgi_S_RegisterSound( "sound/player/roll1.wav");
+	theFxScheduler.RegisterEffect( "env/slide_dust" );
+
+	cgs.media.overchargeFastSound	= cgi_S_RegisterSound("sound/weapons/overchargeFast.wav" );
+	cgs.media.overchargeSlowSound	= cgi_S_RegisterSound("sound/weapons/overchargeSlow.wav" );
+	cgs.media.overchargeLoopSound	= cgi_S_RegisterSound("sound/weapons/overchargeLoop.wav");
+	cgs.media.overchargeEndSound	= cgi_S_RegisterSound("sound/weapons/overchargeEnd.wav");
+
+	cgs.media.batteryChargeSound	= cgi_S_RegisterSound( "sound/interface/pickup_battery.wav" );
+
+//	cgs.media.tedTextSound = cgi_S_RegisterSound( "sound/interface/tedtext.wav" );
+	cgs.media.messageLitSound = cgi_S_RegisterSound( "sound/interface/update" );
+
+	cgs.media.noforceSound = cgi_S_RegisterSound( "sound/weapons/force/noforce" );
+	
+	cgs.media.watrInSound = cgi_S_RegisterSound ("sound/player/watr_in.wav");
+	cgs.media.watrOutSound = cgi_S_RegisterSound ("sound/player/watr_out.wav");
+	cgs.media.watrUnSound = cgi_S_RegisterSound ("sound/player/watr_un.wav");
+
+	if ( (gi.totalMapContents()&CONTENTS_LAVA) )
+	{
+		cgs.media.lavaInSound = cgi_S_RegisterSound ("sound/player/inlava.wav");
+		cgs.media.lavaOutSound = cgi_S_RegisterSound ("sound/player/watr_out.wav");
+		cgs.media.lavaUnSound = cgi_S_RegisterSound ("sound/player/muckexit.wav");
+	}
+	// Zoom
+	cgs.media.zoomStart = cgi_S_RegisterSound( "sound/interface/zoomstart.wav" );
+	cgs.media.zoomLoop = cgi_S_RegisterSound( "sound/interface/zoomloop.wav" );
+	cgs.media.zoomEnd = cgi_S_RegisterSound( "sound/interface/zoomend.wav" );
+
+	cgi_S_RegisterSound( "sound/chars/turret/startup.wav" );
+	cgi_S_RegisterSound( "sound/chars/turret/shutdown.wav" );
+	cgi_S_RegisterSound( "sound/chars/turret/ping.wav" );
+	cgi_S_RegisterSound( "sound/chars/turret/move.wav" );
+	cgi_S_RegisterSound( "sound/player/use_sentry" );
+	cgi_R_RegisterModel( "models/items/psgun.glm" );
+	theFxScheduler.RegisterEffect( "turret/explode" );
+	theFxScheduler.RegisterEffect( "sparks/spark_exp_nosnd" );
+
+	for (i=0 ; i<4 ; i++) {
+		Com_sprintf (name, sizeof(name), "sound/player/footsteps/stone_step%i.wav", i+1);
+		cgs.media.footsteps[FOOTSTEP_STONEWALK][i] = cgi_S_RegisterSound (name);
+		Com_sprintf (name, sizeof(name), "sound/player/footsteps/stone_run%i.wav", i+1);
+		cgs.media.footsteps[FOOTSTEP_STONERUN][i] = cgi_S_RegisterSound (name);
+
+		Com_sprintf (name, sizeof(name), "sound/player/footsteps/metal_step%i.wav", i+1);
+		cgs.media.footsteps[FOOTSTEP_METALWALK][i] = cgi_S_RegisterSound (name);
+		Com_sprintf (name, sizeof(name), "sound/player/footsteps/metal_run%i.wav", i+1);
+		cgs.media.footsteps[FOOTSTEP_METALRUN][i] = cgi_S_RegisterSound (name);
+
+		Com_sprintf (name, sizeof(name), "sound/player/footsteps/pipe_step%i.wav", i+1);
+		cgs.media.footsteps[FOOTSTEP_PIPEWALK][i] = cgi_S_RegisterSound (name);
+		Com_sprintf (name, sizeof(name), "sound/player/footsteps/pipe_run%i.wav", i+1);
+		cgs.media.footsteps[FOOTSTEP_PIPERUN][i] = cgi_S_RegisterSound (name);
+
+		Com_sprintf (name, sizeof(name), "sound/player/footsteps/water_run%i.wav", i+1);
+		cgs.media.footsteps[FOOTSTEP_SPLASH][i] = cgi_S_RegisterSound (name);
+
+		Com_sprintf (name, sizeof(name), "sound/player/footsteps/water_walk%i.wav", i+1);
+		cgs.media.footsteps[FOOTSTEP_WADE][i] = cgi_S_RegisterSound (name);
+
+		Com_sprintf (name, sizeof(name), "sound/player/footsteps/water_wade_0%i.wav", i+1);
+		cgs.media.footsteps[FOOTSTEP_SWIM][i] = cgi_S_RegisterSound (name);
+
+		Com_sprintf (name, sizeof(name), "sound/player/footsteps/snow_step%i.wav", i+1);
+		cgs.media.footsteps[FOOTSTEP_SNOWWALK][i] = cgi_S_RegisterSound (name);
+		Com_sprintf (name, sizeof(name), "sound/player/footsteps/snow_run%i.wav", i+1);
+		cgs.media.footsteps[FOOTSTEP_SNOWRUN][i] = cgi_S_RegisterSound (name);
+
+		Com_sprintf (name, sizeof(name), "sound/player/footsteps/sand_walk%i.wav", i+1);
+		cgs.media.footsteps[FOOTSTEP_SANDWALK][i] = cgi_S_RegisterSound (name);
+		Com_sprintf (name, sizeof(name), "sound/player/footsteps/sand_run%i.wav", i+1);
+		cgs.media.footsteps[FOOTSTEP_SANDRUN][i] = cgi_S_RegisterSound (name);
+
+		Com_sprintf (name, sizeof(name), "sound/player/footsteps/grass_step%i.wav", i+1);
+		cgs.media.footsteps[FOOTSTEP_GRASSWALK][i] = cgi_S_RegisterSound (name);
+		Com_sprintf (name, sizeof(name), "sound/player/footsteps/grass_run%i.wav", i+1);
+		cgs.media.footsteps[FOOTSTEP_GRASSRUN][i] = cgi_S_RegisterSound (name);
+
+		Com_sprintf (name, sizeof(name), "sound/player/footsteps/dirt_step%i.wav", i+1);
+		cgs.media.footsteps[FOOTSTEP_DIRTWALK][i] = cgi_S_RegisterSound (name);
+		Com_sprintf (name, sizeof(name), "sound/player/footsteps/dirt_run%i.wav", i+1);
+		cgs.media.footsteps[FOOTSTEP_DIRTRUN][i] = cgi_S_RegisterSound (name);
+
+		Com_sprintf (name, sizeof(name), "sound/player/footsteps/mud_walk%i.wav", i+1);
+		cgs.media.footsteps[FOOTSTEP_MUDWALK][i] = cgi_S_RegisterSound (name);
+		Com_sprintf (name, sizeof(name), "sound/player/footsteps/mud_run%i.wav", i+1);
+		cgs.media.footsteps[FOOTSTEP_MUDRUN][i] = cgi_S_RegisterSound (name);
+
+		Com_sprintf (name, sizeof(name), "sound/player/footsteps/gravel_walk%i.wav", i+1);
+		cgs.media.footsteps[FOOTSTEP_GRAVELWALK][i] = cgi_S_RegisterSound (name);
+		Com_sprintf (name, sizeof(name), "sound/player/footsteps/gravel_run%i.wav", i+1);
+		cgs.media.footsteps[FOOTSTEP_GRAVELRUN][i] = cgi_S_RegisterSound (name);
+
+		Com_sprintf (name, sizeof(name), "sound/player/footsteps/rug_step%i.wav", i+1);
+		cgs.media.footsteps[FOOTSTEP_RUGWALK][i] = cgi_S_RegisterSound (name);
+		Com_sprintf (name, sizeof(name), "sound/player/footsteps/rug_run%i.wav", i+1);
+		cgs.media.footsteps[FOOTSTEP_RUGRUN][i] = cgi_S_RegisterSound (name);
+
+		Com_sprintf (name, sizeof(name), "sound/player/footsteps/wood_walk%i.wav", i+1);
+		cgs.media.footsteps[FOOTSTEP_WOODWALK][i] = cgi_S_RegisterSound (name);
+		Com_sprintf (name, sizeof(name), "sound/player/footsteps/wood_run%i.wav", i+1);
+		cgs.media.footsteps[FOOTSTEP_WOODRUN][i] = cgi_S_RegisterSound (name);
+	}
+
+	cg.loadLCARSStage = 1;
+	CG_LoadingString( "item sounds" );
+
+	// only register the items that the server says we need
+	char	items[MAX_ITEMS+1];
+	strcpy( items, CG_ConfigString( CS_ITEMS ) );
+
+	for ( i = 1 ; i < bg_numItems ; i++ ) {
+		if ( items[ i ] == '1' )	//even with sound pooling, don't clutter it for low end machines
+		{
+			CG_RegisterItemSounds( i );
+		}
+	}
+
+	cg.loadLCARSStage = 2;
+	CG_LoadingString( "preregistered sounds" );
+
+	for ( i = 1 ; i < MAX_SOUNDS ; i++ ) {
+		soundName = CG_ConfigString( CS_SOUNDS+i );
+		if ( !soundName[0] ) {
+			break;
+		}
+		if ( soundName[0] == '*' ) {
+			continue;	// custom sound
+		}
+		if (!(i&7)) {
+			CG_LoadingString( soundName );
+		}
+		cgs.sound_precache[i] = cgi_S_RegisterSound( soundName );
+	}
+}
+
+#ifdef _IMMERSION
+extern qboolean CG_ConfigForce( int index, const char *&name, int &channel );
+/*
+=================
+CG_RegisterForces
+
+called during a precache command
+=================
+*/
+static void CG_RegisterForces( void )
+{
+	char name[512];
+	int i, channel;
+	const char *forceName;
+
+	cgs.media.selectForce = cgi_FF_Register( "fffx/weapons/change", FF_CHANNEL_WEAPON );
+
+	for (i=0 ; i<4 ; i++) {
+		Com_sprintf (name, sizeof(name), "fffx/player/footsteps/step%i", i+1);
+		cgs.media.footstepForces[FOOTSTEP_STONEWALK][i] = cgi_FF_Register( name, FF_CHANNEL_FOOT );
+
+		Com_sprintf (name, sizeof(name), "fffx/player/footsteps/splash%i", i+1);
+		cgs.media.footstepForces[FOOTSTEP_SPLASH][i] = cgi_FF_Register( name, FF_CHANNEL_FOOT );
+
+		Com_sprintf (name, sizeof(name), "fffx/player/footsteps/clank%i", i+1);
+		cgs.media.footstepForces[FOOTSTEP_METALWALK][i] = cgi_FF_Register( name, FF_CHANNEL_FOOT );
+	}
+
+	cgs.media.noAmmoForce = cgi_FF_Register( "fffx/weapons/noammo", FF_CHANNEL_WEAPON );
+	cgs.media.landForce = cgi_FF_Register( "fffx/player/land1", FF_CHANNEL_BODY );
+
+	cgs.media.watrInForce = cgi_FF_Register( "fffx/player/watr_in", FF_CHANNEL_BODY );
+	cgs.media.watrOutForce = cgi_FF_Register( "fffx/player/watr_out", FF_CHANNEL_BODY );
+	cgs.media.watrUnForce = cgi_FF_Register( "fffx/player/watr_un", FF_CHANNEL_BODY );
+
+	cgs.media.zoomStartForce = cgi_FF_Register( "fffx/interface/zoomstart", FF_CHANNEL_WEAPON );
+	cgs.media.zoomLoopForce = cgi_FF_Register( "fffx/interface/zoomloop", FF_CHANNEL_WEAPON );
+	cgs.media.zoomEndForce = cgi_FF_Register( "fffx/interface/zoomend", FF_CHANNEL_WEAPON );
+
+	cgs.media.grenadeBounce1Force = cgi_FF_Register( "fffx/weapons/thermal/bounce1", FF_CHANNEL_WEAPON );
+	cgs.media.grenadeBounce2Force = cgi_FF_Register( "fffx/weapons/thermal/bounce2", FF_CHANNEL_WEAPON );
+
+	for ( i = 1 ; i < bg_numItems ; i++ )
+	{
+		CG_RegisterItemForces( i );
+	}
+
+	for ( i = 1 ; i < MAX_FORCES ; i++ )
+	{
+		if ( !CG_ConfigForce( i, forceName, channel ) )
+			break;
+
+		if ( forceName[0] == '*' ) {
+			continue;	// custom force???
+		}
+		if (!(i&7)) {
+			CG_LoadingString( forceName );
+		}
+
+		cgs.force_precache[i] = cgi_FF_Register( forceName, channel );
+	}
+}
+#endif // _IMMERSION
+/*
+=============================================================================
+
+CLIENT INFO
+
+=============================================================================
+*/
+
+qhandle_t CG_RegisterHeadSkin( const char *headModelName, const char *headSkinName, qboolean *extensions )
+{
+	char		hfilename[MAX_QPATH];
+	qhandle_t	headSkin;
+
+	Com_sprintf( hfilename, sizeof( hfilename ), "models/players/%s/head_%s.skin", headModelName, headSkinName );
+	headSkin = cgi_R_RegisterSkin( hfilename );
+	if ( headSkin < 0 ) 
+	{	//have extensions
+		*extensions = qtrue;
+		headSkin = -headSkin;
+	} 
+	else 
+	{
+		*extensions = qfalse;	//just to be sure.
+	}
+
+	if ( !headSkin )
+	{
+		Com_Printf( "Failed to load skin file: %s : %s\n", headModelName, headSkinName );
+	}
+	return headSkin;
+}
+
+/*
+==========================
+CG_RegisterClientSkin
+==========================
+*/
+qboolean	CG_RegisterClientSkin( clientInfo_t *ci,
+								  const char *headModelName, const char *headSkinName,
+								  const char *torsoModelName, const char *torsoSkinName,
+								  const char *legsModelName, const char *legsSkinName) 
+{
+	char		hfilename[MAX_QPATH];
+	char		tfilename[MAX_QPATH];
+	char		lfilename[MAX_QPATH];
+
+	Com_sprintf( lfilename, sizeof( lfilename ), "models/players/%s/lower_%s.skin", legsModelName, legsSkinName );
+	ci->legsSkin = cgi_R_RegisterSkin( lfilename );
+
+	if ( !ci->legsSkin )
+	{
+//		Com_Printf( "Failed to load skin file: %s : %s\n", legsModelName, legsSkinName );
+		//return qfalse;
+	}
+
+	if(torsoModelName && torsoSkinName && torsoModelName[0] && torsoSkinName[0])
+	{
+		Com_sprintf( tfilename, sizeof( tfilename ), "models/players/%s/upper_%s.skin", torsoModelName, torsoSkinName );
+		ci->torsoSkin = cgi_R_RegisterSkin( tfilename );
+
+		if ( !ci->torsoSkin )
+		{
+			Com_Printf( "Failed to load skin file: %s : %s\n", torsoModelName, torsoSkinName );
+			return qfalse;
+		}
+	}
+
+	if(headModelName && headSkinName && headModelName[0] && headSkinName[0])
+	{
+		Com_sprintf( hfilename, sizeof( hfilename ), "models/players/%s/head_%s.skin", headModelName, headSkinName );
+		ci->headSkin = cgi_R_RegisterSkin( hfilename );
+
+		if ( !ci->headSkin )
+		{
+			Com_Printf( "Failed to load skin file: %s : %s\n", headModelName, headSkinName );
+			return qfalse;
+		}
+	}
+
+	return qtrue;
+}
+
+/*
+==========================
+CG_RegisterClientModelname
+==========================
+*/
+qboolean CG_RegisterClientModelname( clientInfo_t *ci,
+									const char *headModelName, const char *headSkinName,
+									const char *torsoModelName, const char *torsoSkinName,
+									const char *legsModelName, const char *legsSkinName ) 
+{
+/*
+Ghoul2 Insert Start
+*/
+#if 1
+	char		filename[MAX_QPATH];
+
+
+	if ( !legsModelName || !legsModelName[0] )
+	{
+		return qtrue;
+	}
+	Com_sprintf( filename, sizeof( filename ), "models/players/%s/lower.mdr", legsModelName );
+	ci->legsModel = cgi_R_RegisterModel( filename );
+	if ( !ci->legsModel ) 
+	{//he's not skeletal, try the old way
+		Com_sprintf( filename, sizeof( filename ), "models/players/%s/lower.md3", legsModelName );
+		ci->legsModel = cgi_R_RegisterModel( filename );
+		if ( !ci->legsModel )
+		{
+			Com_Printf( S_COLOR_RED"Failed to load model file %s\n", filename );
+			return qfalse;
+		}
+	}
+
+	if(torsoModelName && torsoModelName[0])
+	{//You are trying to set one
+		Com_sprintf( filename, sizeof( filename ), "models/players/%s/upper.mdr", torsoModelName );
+		ci->torsoModel = cgi_R_RegisterModel( filename );
+		if ( !ci->torsoModel ) 
+		{//he's not skeletal, try the old way
+			Com_sprintf( filename, sizeof( filename ), "models/players/%s/upper.md3", torsoModelName );
+			ci->torsoModel = cgi_R_RegisterModel( filename );
+			if ( !ci->torsoModel ) 
+			{
+				Com_Printf( S_COLOR_RED"Failed to load model file %s\n", filename );
+				return qfalse;
+			}
+		}
+	}
+	else
+	{
+		ci->torsoModel = 0;
+	}
+
+	if(headModelName && headModelName[0])
+	{//You are trying to set one
+		Com_sprintf( filename, sizeof( filename ), "models/players/%s/head.md3", headModelName );
+		ci->headModel = cgi_R_RegisterModel( filename );
+		if ( !ci->headModel ) 
+		{
+			Com_Printf( S_COLOR_RED"Failed to load model file %s\n", filename );
+			return qfalse;
+		}
+	}
+	else
+	{
+		ci->headModel = 0;
+	}
+
+
+	// if any skins failed to load, return failure
+	if ( !CG_RegisterClientSkin( ci, headModelName, headSkinName, torsoModelName, torsoSkinName, legsModelName, legsSkinName ) ) 
+	{
+		//Com_Printf( "Failed to load skin file: %s : %s/%s : %s/%s : %s\n", headModelName, headSkinName, torsoModelName, torsoSkinName, legsModelName, legsSkinName );
+		return qfalse;
+	}
+
+	//FIXME: for now, uses the legs model dir for anim cfg, but should we set this in some sort of NPCs.cfg?
+	// load the animation file set
+	ci->animFileIndex = G_ParseAnimFileSet(legsModelName);
+	if (ci->animFileIndex<0) 
+	{
+		Com_Printf( S_COLOR_RED"Failed to load animation file set models/players/%s\n", legsModelName );
+		return qfalse;
+	}
+#endif
+/*
+Ghoul2 Insert End
+*/
+	return qtrue;
+}
+
+
+void CG_RegisterClientRenderInfo(clientInfo_t *ci, renderInfo_t *ri)
+{
+	char			*slash;
+	char			headModelName[MAX_QPATH];
+	char			torsoModelName[MAX_QPATH];
+	char			legsModelName[MAX_QPATH];
+	char			headSkinName[MAX_QPATH];
+	char			torsoSkinName[MAX_QPATH];
+	char			legsSkinName[MAX_QPATH];
+
+	if(!ri->legsModelName || !ri->legsModelName[0])
+	{//Must have at LEAST a legs model
+		return;
+	}
+
+	Q_strncpyz( legsModelName, ri->legsModelName, sizeof( legsModelName ) );
+	//Legs skin
+	slash = strchr( legsModelName, '/' );
+	if ( !slash ) 
+	{
+		// modelName didn not include a skin name
+		Q_strncpyz( legsSkinName, "default", sizeof( legsSkinName ) );
+	} 
+	else 
+	{
+		Q_strncpyz( legsSkinName, slash + 1, sizeof( legsSkinName ) );
+		// truncate modelName
+		*slash = 0;
+	}
+
+	if(ri->torsoModelName && ri->torsoModelName[0])
+	{
+		Q_strncpyz( torsoModelName, ri->torsoModelName, sizeof( torsoModelName ) );
+		//Torso skin
+		slash = strchr( torsoModelName, '/' );
+		if ( !slash ) 
+		{
+			// modelName didn't include a skin name
+			Q_strncpyz( torsoSkinName, "default", sizeof( torsoSkinName ) );
+		} 
+		else 
+		{
+			Q_strncpyz( torsoSkinName, slash + 1, sizeof( torsoSkinName ) );
+			// truncate modelName
+			*slash = 0;
+		}
+	}
+	else
+	{
+		torsoModelName[0] = 0;
+	}
+
+	//Head
+	if(ri->headModelName && ri->headModelName[0])
+	{
+		Q_strncpyz( headModelName, ri->headModelName, sizeof( headModelName ) );
+		//Head skin
+		slash = strchr( headModelName, '/' );
+		if ( !slash ) 
+		{
+			// modelName didn not include a skin name
+			Q_strncpyz( headSkinName, "default", sizeof( headSkinName ) );
+		} 
+		else 
+		{
+			Q_strncpyz( headSkinName, slash + 1, sizeof( headSkinName ) );
+			// truncate modelName
+			*slash = 0;
+		}
+	}
+	else
+	{
+		headModelName[0] = 0;
+	}
+
+	if ( !CG_RegisterClientModelname( ci, headModelName, headSkinName, torsoModelName, torsoSkinName, legsModelName, legsSkinName) ) 
+	{
+		if ( !CG_RegisterClientModelname( ci, DEFAULT_HEADMODEL, "default", DEFAULT_TORSOMODEL, "default", DEFAULT_LEGSMODEL, "default" ) ) 
+		{
+			CG_Error( "DEFAULT_MODELS failed to register");
+		}
+	}
+}
+
+//-------------------------------------
+// CG_RegisterEffects
+// 
+// Handles precaching all effect files
+//	and any shader, model, or sound
+//	files an effect may use.
+//-------------------------------------
+extern void CG_InitGlass( void );
+extern void	cgi_R_WorldEffectCommand( const char *command );
+
+extern cvar_t *g_delayedShutdown;
+static void CG_RegisterEffects( void )
+{
+	char	*effectName;
+	int		i, numFailed=0;
+
+	// Register external effects
+	for ( i = 1 ; i < MAX_FX ; i++ ) 
+	{
+		effectName = ( char *)CG_ConfigString( CS_EFFECTS + i );
+
+		if ( !effectName[0] ) 
+		{
+			break;
+		}
+
+		if (!theFxScheduler.RegisterEffect( (const char*)effectName ))
+		{
+			assert(0);
+			numFailed++;
+		}
+	}
+	if (numFailed && g_delayedShutdown->integer)
+	{
+		assert(0);
+		CG_Error( "CG_RegisterEffects: %i Effects failed to load.  Please fix, or ask Aurelio.", numFailed );
+	}
+
+	// Start world effects
+	for ( i = 1 ; i < MAX_WORLD_FX ; i++ ) 
+	{
+		effectName = ( char *)CG_ConfigString( CS_WORLD_FX + i );
+
+		if ( !effectName[0] ) 
+		{
+			break;
+		}
+
+		cgi_R_WorldEffectCommand( effectName );
+	}
+
+	// Set up the glass effects mini-system.
+	CG_InitGlass();
+
+	//footstep effects
+	cgs.effects.footstepMud = theFxScheduler.RegisterEffect( "materials/mud" );
+	cgs.effects.footstepSand = theFxScheduler.RegisterEffect( "materials/sand" );
+	cgs.effects.footstepSnow = theFxScheduler.RegisterEffect( "materials/snow" );
+	cgs.effects.footstepGravel = theFxScheduler.RegisterEffect( "materials/gravel" );
+	//landing effects
+	cgs.effects.landingMud = theFxScheduler.RegisterEffect( "materials/mud_large" );
+	cgs.effects.landingSand = theFxScheduler.RegisterEffect( "materials/sand_large" );
+	cgs.effects.landingDirt = theFxScheduler.RegisterEffect( "materials/dirt_large" );
+	cgs.effects.landingSnow = theFxScheduler.RegisterEffect( "materials/snow_large" );
+	cgs.effects.landingGravel = theFxScheduler.RegisterEffect( "materials/gravel_large" );
+	//splashes
+	if ( (gi.totalMapContents()&CONTENTS_WATER) )
+	{
+		theFxScheduler.RegisterEffect( "env/water_impact" );
+		theFxScheduler.RegisterEffect( "misc/waterbreath" );
+	}
+	if ( (gi.totalMapContents()&CONTENTS_LAVA) )
+	{
+		theFxScheduler.RegisterEffect( "env/lava_splash" );
+	}
+	if ( (gi.totalMapContents()&CONTENTS_SLIME) )
+	{
+		theFxScheduler.RegisterEffect( "env/acid_splash" );
+	}
+	theFxScheduler.RegisterEffect( "misc/breath" );
+}
+
+/*
+void CG_RegisterClientModels (int entityNum)
+
+Only call if clientInfo->infoValid is not true
+
+For players and NPCs to register their models
+*/
+void CG_RegisterClientModels (int entityNum)
+{
+	gentity_t		*ent;
+
+	if(entityNum < 0 || entityNum > ENTITYNUM_WORLD)
+	{
+		return;
+	}
+
+	ent = &g_entities[entityNum];
+
+	if(!ent->client)
+	{
+		return;
+	}
+
+	ent->client->clientInfo.infoValid = qtrue;
+
+	if ( ent->playerModel != -1 && ent->ghoul2.size() )
+	{
+		return;
+	}
+
+	CG_RegisterClientRenderInfo(&ent->client->clientInfo, &ent->client->renderInfo);
+
+	if(entityNum < MAX_CLIENTS)
+	{
+		memcpy(&cgs.clientinfo[entityNum], &ent->client->clientInfo, sizeof(clientInfo_t));
+	}
+}
+
+//===================================================================================
+
+
+HUDMenuItem_t forceTics[] = 
+{
+"rightHUD", "force_tic1", 0,  0,  0,  0, 0.0f, 0.0f, 0.0f, 0.0f, NULL, 	// Top 
+"rightHUD", "force_tic2", 0,  0,  0,  0, 0.0f, 0.0f, 0.0f, 0.0f, NULL, 	// Top 
+"rightHUD", "force_tic3", 0,  0,  0,  0, 0.0f, 0.0f, 0.0f, 0.0f, NULL, 	// Top 
+"rightHUD", "force_tic4", 0,  0,  0,  0, 0.0f, 0.0f, 0.0f, 0.0f, NULL, 	// Top 
+};
+
+HUDMenuItem_t ammoTics[] = 
+{
+"rightHUD", "ammo_tic1", 0,  0,  0,  0, 0.0f, 0.0f, 0.0f, 0.0f, NULL, 	// Top 
+"rightHUD", "ammo_tic2", 0,  0,  0,  0, 0.0f, 0.0f, 0.0f, 0.0f, NULL, 	// Top 
+"rightHUD", "ammo_tic3", 0,  0,  0,  0, 0.0f, 0.0f, 0.0f, 0.0f, NULL, 	// Top 
+"rightHUD", "ammo_tic4", 0,  0,  0,  0, 0.0f, 0.0f, 0.0f, 0.0f, NULL, 	// Top 
+};
+
+HUDMenuItem_t armorTics[] = 
+{
+"leftHUD", "armor_tic1", 0,  0,  0,  0, 0.0f, 0.0f, 0.0f, 0.0f, NULL, 	// Top 
+"leftHUD", "armor_tic2", 0,  0,  0,  0, 0.0f, 0.0f, 0.0f, 0.0f, NULL, 	
+"leftHUD", "armor_tic3", 0,  0,  0,  0, 0.0f, 0.0f, 0.0f, 0.0f, NULL, 	
+"leftHUD", "armor_tic4", 0,  0,  0,  0, 0.0f, 0.0f, 0.0f, 0.0f, NULL, 	
+};
+
+HUDMenuItem_t healthTics[] = 
+{
+"leftHUD", "health_tic1", 0,  0,  0,  0, 0.0f, 0.0f, 0.0f, 0.0f, NULL, 	// Top 
+"leftHUD", "health_tic2", 0,  0,  0,  0, 0.0f, 0.0f, 0.0f, 0.0f, NULL,	// 
+"leftHUD", "health_tic3", 0,  0,  0,  0, 0.0f, 0.0f, 0.0f, 0.0f, NULL,	// 
+"leftHUD", "health_tic4", 0,  0,  0,  0, 0.0f, 0.0f, 0.0f, 0.0f, NULL,	// Bottom
+};
+
+
+HUDMenuItem_t otherHUDBits[] = 
+{
+"lefthud", "healthamount",			0,  0,  0,  0, 0.0f, 0.0f, 0.0f, 0.0f, NULL,	// OHB_HEALTHAMOUNT
+"lefthud", "armoramount",			0,  0,  0,  0, 0.0f, 0.0f, 0.0f, 0.0f, NULL,	// OHB_ARMORAMOUNT
+"righthud", "forceamount",			0,  0,  0,  0, 0.0f, 0.0f, 0.0f, 0.0f, NULL,	// OHB_FORCEAMOUNT 
+"righthud", "ammoamount",			0,  0,  0,  0, 0.0f, 0.0f, 0.0f, 0.0f, NULL,	// OHB_AMMOAMOUNT
+"righthud", "saberstyle_strong",	0,  0,  0,  0, 0.0f, 0.0f, 0.0f, 0.0f, NULL,	// OHB_SABERSTYLE_STRONG
+"righthud", "saberstyle_medium",	0,  0,  0,  0, 0.0f, 0.0f, 0.0f, 0.0f, NULL,	// OHB_SABERSTYLE_MEDIUM
+"righthud", "saberstyle_fast",		0,  0,  0,  0, 0.0f, 0.0f, 0.0f, 0.0f, NULL,	// OHB_SABERSTYLE_FAST
+"lefthud",	"scanline",				0,  0,  0,  0, 0.0f, 0.0f, 0.0f, 0.0f, NULL,	// OHB_SCANLINE_LEFT
+"righthud",	"scanline",				0,  0,  0,  0, 0.0f, 0.0f, 0.0f, 0.0f, NULL,	// OHB_SCANLINE_RIGHT
+"lefthud",	"frame",				0,  0,  0,  0, 0.0f, 0.0f, 0.0f, 0.0f, NULL,	// OHB_FRAME_LEFT
+"righthud",	"frame",				0,  0,  0,  0, 0.0f, 0.0f, 0.0f, 0.0f, NULL,	// OHB_FRAME_RIGHT
+};
+
+/*const char *HolocronIcons[] = {
+	"gfx/mp/f_icon_lt_heal",		//FP_HEAL,
+	"gfx/mp/f_icon_levitation",		//FP_LEVITATION,
+	"gfx/mp/f_icon_speed",			//FP_SPEED,
+	"gfx/mp/f_icon_push",			//FP_PUSH,
+	"gfx/mp/f_icon_pull",			//FP_PULL,
+	"gfx/mp/f_icon_lt_telepathy",	//FP_TELEPATHY,
+	"gfx/mp/f_icon_dk_grip",		//FP_GRIP,
+	"gfx/mp/f_icon_dk_l1",			//FP_LIGHTNING,
+	"gfx/mp/f_icon_dk_rage",		//FP_RAGE,
+	"gfx/mp/f_icon_lt_protect",		//FP_PROTECT,
+	"gfx/mp/f_icon_lt_absorb",		//FP_ABSORB,
+	"gfx/mp/f_icon_lt_healother",	//FP_TEAM_HEAL,
+	"gfx/mp/f_icon_dk_forceother",	//FP_TEAM_FORCE,
+	"gfx/mp/f_icon_dk_drain",		//FP_DRAIN,
+	"gfx/mp/f_icon_sight",			//FP_SEE,
+	"gfx/mp/f_icon_saber_attack",	//FP_SABERATTACK,
+	"gfx/mp/f_icon_saber_defend",	//FP_SABERDEFEND,
+	"gfx/mp/f_icon_saber_throw"		//FP_SABERTHROW
+};
+*/
+extern void NPC_Precache ( gentity_t *spawner );
+qboolean NPCsPrecached = qfalse;
+/*
+=================
+CG_PrepRefresh
+
+Call before entering a new level, or after changing renderers
+This function may execute for a couple of minutes with a slow disk.
+=================
+*/
+void CG_CreateMiscEnts(void);
+static void CG_RegisterGraphics( void ) {
+	int			i;
+	char		items[MAX_ITEMS+1];
+	int			breakPoint = 0;
+	const char		*sb_nums[11] = {
+		"gfx/2d/numbers/zero",
+		"gfx/2d/numbers/one",
+		"gfx/2d/numbers/two",
+		"gfx/2d/numbers/three",
+		"gfx/2d/numbers/four",
+		"gfx/2d/numbers/five",
+		"gfx/2d/numbers/six",
+		"gfx/2d/numbers/seven",
+		"gfx/2d/numbers/eight",
+		"gfx/2d/numbers/nine",
+		"gfx/2d/numbers/minus",
+	};
+
+	const char		*sb_t_nums[11] = {
+		"gfx/2d/numbers/t_zero",
+		"gfx/2d/numbers/t_one",
+		"gfx/2d/numbers/t_two",
+		"gfx/2d/numbers/t_three",
+		"gfx/2d/numbers/t_four",
+		"gfx/2d/numbers/t_five",
+		"gfx/2d/numbers/t_six",
+		"gfx/2d/numbers/t_seven",
+		"gfx/2d/numbers/t_eight",
+		"gfx/2d/numbers/t_nine",
+		"gfx/2d/numbers/t_minus",
+	};
+
+	const char		*sb_c_nums[11] = {
+		"gfx/2d/numbers/c_zero",
+		"gfx/2d/numbers/c_one",
+		"gfx/2d/numbers/c_two",
+		"gfx/2d/numbers/c_three",
+		"gfx/2d/numbers/c_four",
+		"gfx/2d/numbers/c_five",
+		"gfx/2d/numbers/c_six",
+		"gfx/2d/numbers/c_seven",
+		"gfx/2d/numbers/c_eight",
+		"gfx/2d/numbers/c_nine",
+		"gfx/2d/numbers/t_minus", //?????
+	};
+
+	// Clean, then register...rinse...repeat...
+	CG_LoadingString( "effects" );
+	FX_Init();
+	CG_RegisterEffects();
+
+	// clear any references to old media
+	memset( &cg.refdef, 0, sizeof( cg.refdef ) );
+	cgi_R_ClearScene();
+
+	cg.loadLCARSStage = 3;
+	CG_LoadingString( cgs.mapname );
+
+#ifndef _XBOX // this gets handled elsewhere on Xbox
+	cgi_R_LoadWorldMap( cgs.mapname );
+#endif
+
+	cg.loadLCARSStage = 4;
+	CG_LoadingString( "game media shaders" );
+
+	for ( i=0; i < 11; i++ )
+	{
+		cgs.media.numberShaders[i]			= cgi_R_RegisterShaderNoMip( sb_nums[i] );
+		cgs.media.smallnumberShaders[i]		= cgi_R_RegisterShaderNoMip( sb_t_nums[i] );
+		cgs.media.chunkyNumberShaders[i]	= cgi_R_RegisterShaderNoMip( sb_c_nums[i] );
+	}
+
+	// FIXME: conditionally do this??  Something must be wrong with inventory item caching..?
+	cgi_R_RegisterModel( "models/items/remote.md3" );
+
+	cgs.media.explosionModel				= cgi_R_RegisterModel ( "models/weaphits/explosion.md3" );
+	cgs.media.surfaceExplosionShader		= cgi_R_RegisterShader( "surfaceExplosion" );
+
+	cgs.media.halfShieldModel				= cgi_R_RegisterModel( "models/weaphits/testboom.md3" );
+
+	cgs.media.solidWhiteShader			= cgi_R_RegisterShader( "gfx/effects/solidWhite" );
+	cgs.media.refractShader				= cgi_R_RegisterShader( "effects/refraction" );
+
+	//on players
+	cgs.media.personalShieldShader		= cgi_R_RegisterShader( "gfx/misc/personalshield" );
+	cgs.media.cloakedShader				= cgi_R_RegisterShader( "gfx/effects/cloakedShader" );
+											cgi_R_RegisterShader( "gfx/misc/ion_shield" );
+
+	cgs.media.boltShader				= cgi_R_RegisterShader( "gfx/misc/blueLine" );
+
+	// FIXME: do these conditionally
+	cgi_R_RegisterShader( "gfx/2d/workingCamera" );
+	cgi_R_RegisterShader( "gfx/2d/brokenCamera" );
+	//cgi_R_RegisterShader( "gfx/effects/irid_shield" ); // for galak, but he doesn't have his own weapon so I can't register the shader there.
+
+	//interface
+	for ( i = 0 ; i < NUM_CROSSHAIRS ; i++ ) {
+		cgs.media.crosshairShader[i] = cgi_R_RegisterShaderNoMip( va("gfx/2d/crosshair%c", 'a'+i) );
+	}
+	cgs.media.backTileShader		= cgi_R_RegisterShader( "gfx/2d/backtile" );
+//	cgs.media.noammoShader			= cgi_R_RegisterShaderNoMip( "gfx/hud/noammo");
+	cgs.media.weaponIconBackground	= cgi_R_RegisterShaderNoMip( "gfx/hud/background");
+	cgs.media.forceIconBackground	= cgi_R_RegisterShaderNoMip( "gfx/hud/background_f");
+	cgs.media.inventoryIconBackground= cgi_R_RegisterShaderNoMip( "gfx/hud/background_i");
+	cgs.media.dataPadFrame			= cgi_R_RegisterShaderNoMip( "gfx/menus/datapad");
+
+	//gore decal shaders -rww
+	cgs.media.bdecal_burnmark1		= cgi_R_RegisterShader( "gfx/damage/burnmark1" );
+	cgs.media.bdecal_saberglowmark	= cgi_R_RegisterShader( "gfx/damage/saberglowmark" );
+
+	cg.loadLCARSStage = 5;
+	CG_LoadingString( "game media models" );
+	
+	// Chunk models
+	//FIXME: jfm:? bother to conditionally load these if an ent has this material type?
+	for ( i = 0; i < NUM_CHUNK_MODELS; i++ )
+	{
+		cgs.media.chunkModels[CHUNK_METAL2][i]	= cgi_R_RegisterModel( va( "models/chunks/metal/metal1_%i.md3", i+1 ) ); //_ /switched\ _
+		cgs.media.chunkModels[CHUNK_METAL1][i]	= cgi_R_RegisterModel( va( "models/chunks/metal/metal2_%i.md3", i+1 ) ); //  \switched/
+		cgs.media.chunkModels[CHUNK_ROCK1][i]	= cgi_R_RegisterModel( va( "models/chunks/rock/rock1_%i.md3", i+1 ) );
+		cgs.media.chunkModels[CHUNK_ROCK2][i]	= cgi_R_RegisterModel( va( "models/chunks/rock/rock2_%i.md3", i+1 ) );
+		cgs.media.chunkModels[CHUNK_ROCK3][i]	= cgi_R_RegisterModel( va( "models/chunks/rock/rock3_%i.md3", i+1 ) );
+		cgs.media.chunkModels[CHUNK_CRATE1][i]	= cgi_R_RegisterModel( va( "models/chunks/crate/crate1_%i.md3", i+1 ) );
+		cgs.media.chunkModels[CHUNK_CRATE2][i]	= cgi_R_RegisterModel( va( "models/chunks/crate/crate2_%i.md3", i+1 ) );
+		cgs.media.chunkModels[CHUNK_WHITE_METAL][i]	= cgi_R_RegisterModel( va( "models/chunks/metal/wmetal1_%i.md3", i+1 ) );
+	}
+
+	cgs.media.chunkSound			= cgi_S_RegisterSound("sound/weapons/explosions/glasslcar");
+	cgs.media.grateSound			= cgi_S_RegisterSound( "sound/effects/grate_destroy" );
+	cgs.media.rockBreakSound		= cgi_S_RegisterSound("sound/effects/wall_smash");
+	cgs.media.rockBounceSound[0]	= cgi_S_RegisterSound("sound/effects/stone_bounce");
+	cgs.media.rockBounceSound[1]	= cgi_S_RegisterSound("sound/effects/stone_bounce2");
+	cgs.media.metalBounceSound[0]	= cgi_S_RegisterSound("sound/effects/metal_bounce");
+	cgs.media.metalBounceSound[1]	= cgi_S_RegisterSound("sound/effects/metal_bounce2");
+	cgs.media.glassChunkSound		= cgi_S_RegisterSound("sound/weapons/explosions/glassbreak1");
+	cgs.media.crateBreakSound[0]	= cgi_S_RegisterSound("sound/weapons/explosions/crateBust1" );
+	cgs.media.crateBreakSound[1]	= cgi_S_RegisterSound("sound/weapons/explosions/crateBust2" );
+
+	cgs.media.weaponbox	 = cgi_R_RegisterShaderNoMip( "gfx/interface/weapon_box");
+
+	//Models & Shaders
+	cgs.media.damageBlendBlobShader	= cgi_R_RegisterShader( "gfx/misc/borgeyeflare" );
+
+	cg.loadLCARSStage = 6;
+
+	cgs.media.messageLitOn = cgi_R_RegisterShaderNoMip( "gfx/hud/message_on" );
+	cgs.media.messageLitOff = cgi_R_RegisterShaderNoMip( "gfx/hud/message_off" );
+	cgs.media.messageObjCircle = cgi_R_RegisterShaderNoMip( "gfx/hud/objective_circle" );
+
+	cgs.media.DPForcePowerOverlay = cgi_R_RegisterShader( "gfx/hud/force_swirl" );
+
+	//NOTE: we should only cache this if there is a vehicle or emplaced gun somewhere on the map
+	cgs.media.emplacedHealthBarShader = cgi_R_RegisterShaderNoMip( "gfx/hud/health_frame" );
+
+	// battery charge shader when using a gonk
+	cgs.media.batteryChargeShader = cgi_R_RegisterShader( "gfx/2d/battery" );
+	cgi_R_RegisterShader( "gfx/2d/droid_view" );
+	cgs.media.useableHint = cgi_R_RegisterShader("gfx/hud/useableHint");
+
+	// Load up other HUD bits
+	for (i=0;i<OHB_MAX;i++)
+	{
+		cgi_UI_GetMenuItemInfo(
+			otherHUDBits[i].menuName,
+			otherHUDBits[i].itemName,
+			&otherHUDBits[i].xPos,
+			&otherHUDBits[i].yPos,
+			&otherHUDBits[i].width,
+			&otherHUDBits[i].height,
+			otherHUDBits[i].color,
+			&otherHUDBits[i].background);
+	}
+
+	// Get all the info for each HUD piece
+	for (i=0;i<MAX_HUD_TICS;i++)
+	{
+		cgi_UI_GetMenuItemInfo(
+			healthTics[i].menuName,
+			healthTics[i].itemName,
+			&healthTics[i].xPos,
+			&healthTics[i].yPos,
+			&healthTics[i].width,
+			&healthTics[i].height,
+			healthTics[i].color,
+			&healthTics[i].background);
+
+		cgi_UI_GetMenuItemInfo(
+			armorTics[i].menuName,
+			armorTics[i].itemName,
+			&armorTics[i].xPos,
+			&armorTics[i].yPos,
+			&armorTics[i].width,
+			&armorTics[i].height,
+			armorTics[i].color,
+			&armorTics[i].background);
+
+		cgi_UI_GetMenuItemInfo(
+			forceTics[i].menuName,
+			forceTics[i].itemName,
+			&forceTics[i].xPos,
+			&forceTics[i].yPos,
+			&forceTics[i].width,
+			&forceTics[i].height,
+			forceTics[i].color,
+			&forceTics[i].background);
+
+		cgi_UI_GetMenuItemInfo(
+			ammoTics[i].menuName,
+			ammoTics[i].itemName,
+			&ammoTics[i].xPos,
+			&ammoTics[i].yPos,
+			&ammoTics[i].width,
+			&ammoTics[i].height,
+			ammoTics[i].color,
+			&ammoTics[i].background);
+
+	}
+
+
+	memset( cg_items, 0, sizeof( cg_items ) );
+	memset( cg_weapons, 0, sizeof( cg_weapons ) );
+
+	// only register the items that the server says we need
+	strcpy( items, CG_ConfigString( CS_ITEMS) );
+
+	for ( i = 1 ; i < bg_numItems ; i++ ) {
+		if ( items[ i ] == '1' ) 
+		{
+			if (bg_itemlist[i].classname)
+			{
+				CG_LoadingString( bg_itemlist[i].classname );
+				CG_RegisterItemVisuals( i );
+			}
+		}
+		if (bg_itemlist[i].giType == IT_HOLDABLE)
+		{
+			if (bg_itemlist[i].giTag < INV_MAX)
+			{
+				inv_icons[bg_itemlist[i].giTag] = cgi_R_RegisterShaderNoMip( bg_itemlist[i].icon );
+			}
+		}
+	}
+
+	//precache force power icons here
+/*	i = 0;
+	while (i < NUM_FORCE_POWERS)
+	{
+		cgs.media.forcePowerIcons[i] = cgi_R_RegisterShaderNoMip(HolocronIcons[i]);
+		i++;
+	}
+*/
+	cgs.media.rageRecShader = cgi_R_RegisterShaderNoMip("gfx/mp/f_icon_ragerec");
+	//etc.
+	cgi_R_RegisterShader( "gfx/misc/test_crackle" );	//CG_DoGlassQuad
+
+	// wall marks
+	cgs.media.scavMarkShader				= cgi_R_RegisterShader( "gfx/damage/burnmark4" );
+	cgs.media.rivetMarkShader				= cgi_R_RegisterShader( "gfx/damage/rivetmark" );
+
+	// doing one shader just makes it look like a shell.  By using two shaders with different bulge offsets and different texture scales, it has a much more chaotic look
+	cgs.media.electricBodyShader			= cgi_R_RegisterShader( "gfx/misc/electric" );
+	cgs.media.electricBody2Shader			= cgi_R_RegisterShader( "gfx/misc/fullbodyelectric2" );
+
+	cgs.media.shadowMarkShader	= cgi_R_RegisterShader( "markShadow" );
+	cgs.media.wakeMarkShader	= cgi_R_RegisterShader( "wake" );
+	cgs.media.fsrMarkShader	= cgi_R_RegisterShader( "footstep_r" );
+	cgs.media.fslMarkShader	= cgi_R_RegisterShader( "footstep_l" );
+	cgs.media.fshrMarkShader	= cgi_R_RegisterShader( "footstep_heavy_r" );
+	cgs.media.fshlMarkShader	= cgi_R_RegisterShader( "footstep_heavy_l" );
+	cgi_S_RegisterSound( "sound/effects/energy_crackle.wav" );
+
+	CG_LoadingString("map brushes");
+	// register the inline models
+	breakPoint = cgs.numInlineModels = cgi_CM_NumInlineModels();
+	assert (cgs.numInlineModels < sizeof(cgs.inlineDrawModel)/sizeof(cgs.inlineDrawModel[0]) );
+	for ( i = 1 ; i < cgs.numInlineModels ; i++ ) {
+		char	name[10];
+		vec3_t			mins, maxs;
+		int				j;
+
+		Com_sprintf( name, sizeof(name), "*%i", i );
+		cgs.inlineDrawModel[i] = cgi_R_RegisterModel( name );
+
+		if (!cgs.inlineDrawModel[i])
+		{
+			breakPoint = i;
+			break;
+		}
+
+		cgi_R_ModelBounds( cgs.inlineDrawModel[i], mins, maxs );
+		for ( j = 0 ; j < 3 ; j++ ) {
+			cgs.inlineModelMidpoints[i][j] = mins[j] + 0.5 * ( maxs[j] - mins[j] );
+		}
+	}
+
+	cg.loadLCARSStage = 7;
+	CG_LoadingString("map models");
+	// register all the server specified models
+	for (i=1 ; i<MAX_MODELS ; i++) {
+		const char		*modelName;
+
+		modelName = CG_ConfigString( CS_MODELS+i );
+		if ( !modelName[0] ) {
+			break;
+		}
+		cgs.model_draw[i] = cgi_R_RegisterModel( modelName );
+//		OutputDebugString(va("### CG_RegisterGraphics(): cgs.model_draw[%d] = \"%s\"\n",i,modelName));
+	}
+
+	cg.loadLCARSStage = 8;
+
+/*
+Ghoul2 Insert Start
+*/
+	CG_LoadingString("skins");
+	// register all the server specified models
+	for (i=1 ; i<MAX_CHARSKINS ; i++) {
+		const char		*modelName;
+
+		modelName = CG_ConfigString( CS_CHARSKINS+i );
+		if ( !modelName[0] ) {
+			break;
+		}
+		cgs.skins[i] = cgi_R_RegisterSkin( modelName );
+	}
+
+/*
+Ghoul2 Insert End
+*/
+
+	for (i=0 ; i<MAX_CLIENTS ; i++) 
+	{
+		//feedback( va("client %i", i ) );
+		CG_NewClientinfo( i );
+	}
+
+	for (i=0 ; i < ENTITYNUM_WORLD ; i++)
+	{
+		if(&g_entities[i])
+		{
+			if(g_entities[i].client)
+			{
+				//if(!g_entities[i].client->clientInfo.infoValid)
+				//We presume this
+				{
+					CG_LoadingString( va("client %s", g_entities[i].client->clientInfo.name ) );
+					CG_RegisterClientModels(i);
+					if ( i != 0 )
+					{//Client weapons already precached
+						CG_RegisterWeapon( g_entities[i].client->ps.weapon );
+						CG_RegisterNPCCustomSounds( &g_entities[i].client->clientInfo );
+						//CG_RegisterNPCEffects( g_entities[i].client->playerTeam );
+					}
+				}
+			}
+			else if ( g_entities[i].svFlags & SVF_NPC_PRECACHE && g_entities[i].NPC_type && g_entities[i].NPC_type[0] )
+			{//Precache the NPC_type
+				//FIXME: make sure we didn't precache this NPC_type already
+				CG_LoadingString( va("NPC %s", g_entities[i].NPC_type ) );
+				/*
+				if (g_entities[i].classname && g_entities[i].classname[0] && Q_stricmp( g_entities[i].classname, "NPC_Vehicle" ) == 0)
+				{
+					// Get The Index, And Make Sure To Register All The Skins
+					int iVehIndex = BG_VehicleGetIndex( g_entities[i].NPC_type );
+				}
+				else
+				*/
+				{
+					NPC_Precache( &g_entities[i] );
+				}
+			}
+		}
+	}
+
+	CG_LoadingString( "static models" );
+	CG_CreateMiscEnts();
+
+	cg.loadLCARSStage = 9;
+
+	NPCsPrecached = qtrue;
+
+	extern	cvar_t	*com_buildScript;
+
+	if (com_buildScript->integer) {
+		cgi_R_RegisterShader( "gfx/misc/nav_cpoint" );
+		cgi_R_RegisterShader( "gfx/misc/nav_line" );
+		cgi_R_RegisterShader( "gfx/misc/nav_arrow" );
+		cgi_R_RegisterShader( "gfx/misc/nav_node" );
+	}
+
+	for(i = 1; i < MAX_SUB_BSP; i++)
+	{
+		const char		*bspName = 0;
+		vec3_t			mins, maxs;
+		int				j = 0;
+		int				sub = 0;
+		char			temp[MAX_QPATH];
+
+		bspName = CG_ConfigString( CS_BSP_MODELS+i );
+		if ( !bspName[0] ) 
+		{
+			break;
+		}
+		CG_LoadingString( "BSP instances" );
+
+		cgi_CM_LoadMap( bspName, qtrue );
+		cgs.inlineDrawModel[breakPoint] = cgi_R_RegisterModel( bspName );
+		cgi_R_ModelBounds( cgs.inlineDrawModel[breakPoint], mins, maxs );
+		for ( j = 0 ; j < 3 ; j++ ) 
+		{
+			cgs.inlineModelMidpoints[breakPoint][j] = mins[j] + 0.5 * ( maxs[j] - mins[j] );
+		}
+		breakPoint++;
+		for(sub=1;sub<MAX_MODELS;sub++)
+		{
+			Com_sprintf(temp, MAX_QPATH, "*%d-%d", i, sub);
+			cgs.inlineDrawModel[breakPoint] = cgi_R_RegisterModel( temp );
+			if (!cgs.inlineDrawModel[breakPoint])
+			{
+				break;
+			}
+			cgi_R_ModelBounds( cgs.inlineDrawModel[breakPoint], mins, maxs );
+			for ( j = 0 ; j < 3 ; j++ ) 
+			{
+				cgs.inlineModelMidpoints[breakPoint][j] = mins[j] + 0.5 * ( maxs[j] - mins[j] );
+			}
+			breakPoint++;
+		}
+	}
+
+	const char	*terrainInfo;
+	int			terrainID;
+
+	for(i = 1; i < MAX_TERRAINS; i++)
+	{
+		terrainInfo = CG_ConfigString( CS_TERRAINS + i );
+		if ( !terrainInfo[0] )
+		{
+			break;
+		}
+		CG_LoadingString("Creating terrain");
+
+		terrainID = cgi_CM_RegisterTerrain(terrainInfo);
+
+		cgi_RMG_Init(terrainID, terrainInfo);
+
+		// Send off the terrainInfo to the renderer
+		cgi_RE_InitRendererTerrain( terrainInfo );
+	}
+}
+
+//===========================================================================
+
+/*
+=================
+CG_ConfigString
+=================
+*/
+const char *CG_ConfigString( int index ) {
+	if ( index < 0 || index >= MAX_CONFIGSTRINGS ) {
+		CG_Error( "CG_ConfigString: bad index: %i", index );
+	}
+	return cgs.gameState.stringData + cgs.gameState.stringOffsets[ index ];
+}
+
+//==================================================================
+
+void CG_LinkCentsToGents(void)
+{
+	int	i;
+
+	for(i = 0; i < MAX_GENTITIES; i++)
+	{
+		cg_entities[i].gent = &g_entities[i];
+	}
+}
+
+/*
+======================
+CG_StartMusic
+
+======================
+*/
+void CG_StartMusic( qboolean bForceStart ) {
+	const char	*s;
+	char	parm1[MAX_QPATH], parm2[MAX_QPATH];
+
+	// start the background music
+	s = (char *)CG_ConfigString( CS_MUSIC );
+	Q_strncpyz( parm1, COM_Parse( &s ), sizeof( parm1 ) );
+	Q_strncpyz( parm2, COM_Parse( &s ), sizeof( parm2 ) );
+
+	cgi_S_StartBackgroundTrack( parm1, parm2, !bForceStart );
+}
+
+/*
+======================
+CG_GameStateReceived
+
+Displays the info screen while loading media
+======================
+*/
+
+int iCGResetCount=0;
+qboolean qbVidRestartOccured = qfalse;
+
+//===================
+qboolean gbUseTheseValuesFromLoadSave = qfalse;	// MUST default to this
+int gi_cg_forcepowerSelect;
+int gi_cg_inventorySelect;
+//===================
+
+
+static void CG_GameStateReceived( void ) {
+	// clear everything
+	
+	extern void CG_ClearAnimEvtCache( void );
+	CG_ClearAnimEvtCache();	// else sound handles wrong after vid_restart
+
+	qbVidRestartOccured = qtrue;
+	iCGResetCount++;
+	if (iCGResetCount == 1)	// this will only equal 1 first time, after each vid_restart it just gets higher.
+	{						//	This non-clear is so the user can vid_restart during scrolling text without losing it.
+		qbVidRestartOccured = qfalse;		
+	}
+
+	if (!qbVidRestartOccured)
+	{
+		CG_Init_CG();
+		cg.weaponSelect = WP_NONE;
+		cg.forcepowerSelect = FP_HEAL;
+	}
+
+	memset( cg_weapons, 0, sizeof(cg_weapons) );
+	memset( cg_items, 0, sizeof(cg_items) );
+	
+	CG_LinkCentsToGents();
+
+	if (gbUseTheseValuesFromLoadSave)
+	{
+		gbUseTheseValuesFromLoadSave = qfalse;	// ack
+		cg.forcepowerSelect = gi_cg_forcepowerSelect;
+		cg.inventorySelect	= gi_cg_inventorySelect;
+	}
+
+
+	// get the rendering configuration from the client system
+	cgi_GetGlconfig( &cgs.glconfig );
+
+/*	cgs.charScale = cgs.glconfig.vidHeight * (1.0/480.0);
+	if ( cgs.glconfig.vidWidth * 480 > cgs.glconfig.vidHeight * 640 ) {
+		// wide screen
+		cgs.bias = 0.5 * ( cgs.glconfig.vidWidth - ( cgs.glconfig.vidHeight * (640.0/480.0) ) );
+	}
+	else {
+		// no wide screen
+		cgs.bias = 0;
+	}
+*/
+	// get the gamestate from the client system
+	cgi_GetGameState( &cgs.gameState );
+
+	CG_ParseServerinfo();
+
+	// load the new map
+	cgs.media.levelLoad = cgi_R_RegisterShaderNoMip( "gfx/hud/mp_levelload" );
+	CG_LoadingString( "collision map" );
+
+	cgi_CM_LoadMap( cgs.mapname, qfalse );
+
+	CG_RegisterSounds();
+
+#ifdef _IMMERSION
+	CG_RegisterForces();
+#endif // _IMMERSION
+	CG_RegisterGraphics();
+
+	//jfm: moved down to preinit
+//	CG_InitLocalEntities();
+//	CG_InitMarkPolys();
+
+	CG_LoadingString( "music" );
+	CG_StartMusic( qfalse );
+
+	// remove the last loading update
+	cg.infoScreenText[0] = 0;
+
+	CGCam_Init();
+
+	CG_ClearLightStyles();
+
+	// Okay so this doesn't exactly belong here
+	cg.messageLitActive = qfalse;
+	cg.forceHUDActive = qtrue;
+	cg.forceHUDTotalFlashTime = 0;
+	cg.forceHUDNextFlashTime = 0;
+
+}
+
+void CG_WriteTheEvilCGHackStuff(void)
+{
+	gi.AppendToSaveGame('FPSL', &cg.forcepowerSelect, sizeof(cg.forcepowerSelect));
+	gi.AppendToSaveGame('IVSL', &cg.inventorySelect,  sizeof(cg.inventorySelect));
+
+}
+void CG_ReadTheEvilCGHackStuff(void)
+{
+	gi.ReadFromSaveGame('FPSL', (void *)&gi_cg_forcepowerSelect, sizeof(gi_cg_forcepowerSelect));
+	gi.ReadFromSaveGame('IVSL', (void *)&gi_cg_inventorySelect,  sizeof(gi_cg_inventorySelect));
+	gbUseTheseValuesFromLoadSave = qtrue;
+}
+
+/*
+Ghoul2 Insert Start
+*/
+
+// initialise the cg_entities structure
+void CG_Init_CG(void)
+{
+#ifdef _XBOX
+	qboolean widescreen = cg.widescreen;
+#endif
+	memset( &cg, 0, sizeof(cg));
+#ifdef _XBOX
+	cg.widescreen = widescreen;
+#endif
+}
+
+
+#ifdef _XBOX	// Enough for all maps right now
+#define MAX_MISC_ENTS	1000
+#else
+#define MAX_MISC_ENTS	2000
+#endif
+
+typedef struct cgMiscEntData_s
+{
+	char		model[MAX_QPATH];
+	qhandle_t	hModel;
+	vec3_t		origin;
+	vec3_t		angles;
+	vec3_t		scale;
+	float		radius;
+	float		zOffset; //some models need a z offset for culling, because of stupid wrong model origins
+} cgMiscEntData_t;
+
+static cgMiscEntData_t	MiscEnts[MAX_MISC_ENTS]; //statically allocated for now.
+static int				NumMiscEnts=0;
+
+void CG_CreateMiscEntFromGent(gentity_t *ent, const vec3_t scale, float zOff)
+{ //store the model data
+	if (NumMiscEnts == MAX_MISC_ENTS)
+	{
+		Com_Error(ERR_DROP,"Maximum misc_model_static reached (%d)\n",MAX_MISC_ENTS);
+		return;
+	}
+
+	if (!ent || !ent->model || !ent->model[0])
+	{
+		Com_Error(ERR_DROP, "misc_model_static with no model.");
+		return;
+	}
+	const int len = strlen(ent->model);
+	if (len < 4 || stricmp(&ent->model[len-4],".md3")!=0)
+	{
+		Com_Error(ERR_DROP, "misc_model_static model(%s) is not an md3.",ent->model);
+		return;
+	}
+	cgMiscEntData_t	*MiscEnt = &MiscEnts[NumMiscEnts++];
+	memset(MiscEnt, 0, sizeof(*MiscEnt));
+
+	strcpy(MiscEnt->model, ent->model);
+	VectorCopy(ent->s.angles,	MiscEnt->angles);
+	VectorCopy(scale,			MiscEnt->scale);
+	VectorCopy(ent->s.origin,	MiscEnt->origin);
+	MiscEnt->zOffset = zOff;
+}
+
+#define VectorScaleVector(a,b,c)		(((c)[0]=(a)[0]*(b)[0]),((c)[1]=(a)[1]*(b)[1]),((c)[2]=(a)[2]*(b)[2]))
+//call on standard model load to spawn the queued stuff
+void CG_CreateMiscEnts(void)
+{
+	vec3_t		mins, maxs;
+
+	int i;
+	for (i=0; i < NumMiscEnts; i++)
+	{
+		cgMiscEntData_t	*MiscEnt = &MiscEnts[i];
+
+		MiscEnt->hModel = cgi_R_RegisterModel(MiscEnt->model);
+		if (MiscEnt->hModel == 0)
+		{
+			Com_Error(ERR_DROP, "misc_model_static failed to load model '%s'",MiscEnt->model);
+			continue;
+		}
+
+		cgi_R_ModelBounds(MiscEnt->hModel, mins, maxs);
+
+		VectorScaleVector(mins, MiscEnt->scale, mins);
+		VectorScaleVector(maxs, MiscEnt->scale, maxs);
+		MiscEnt->radius = DistanceSquared(mins, maxs);
+	}
+}
+
+void CG_DrawMiscEnts(void)
+{
+	int			i;
+	cgMiscEntData_t	*MiscEnt = MiscEnts;
+	refEntity_t	refEnt; 
+	vec3_t		difference;
+	vec3_t		cullOrigin;
+
+	memset (&refEnt, 0, sizeof(refEnt));
+	refEnt.reType = RT_MODEL;
+	refEnt.frame = 0;
+	refEnt.renderfx = RF_LIGHTING_ORIGIN;
+	for(i=0;i<NumMiscEnts;i++)
+	{
+		VectorCopy(MiscEnt->origin, cullOrigin);
+		cullOrigin[2] += MiscEnt->zOffset+1.0f;
+
+		if (gi.inPVS(cg.refdef.vieworg, cullOrigin))
+		{
+			VectorSubtract(MiscEnt->origin, cg.refdef.vieworg, difference);
+			if (VectorLengthSquared(difference)-(MiscEnt->radius) <= 8192*8192/*RMG_distancecull.value*/)
+			{ //fixme: need access to the real cull dist here
+				refEnt.hModel = MiscEnt->hModel;
+				AnglesToAxis( MiscEnt->angles, refEnt.axis );
+				VectorCopy(MiscEnt->scale, refEnt.modelScale);
+				VectorCopy(MiscEnt->origin, refEnt.origin);
+				VectorCopy(cullOrigin, refEnt.lightingOrigin);
+				ScaleModelAxis(&refEnt);
+				cgi_R_AddRefEntityToScene(&refEnt);
+			}
+		}
+		MiscEnt++;
+	}
+}
+
+void CG_TransitionPermanent(void)
+{
+	centity_t	*cent = cg_entities;
+	int			i;
+
+	cg_numpermanents = 0;
+	for(i=0;i<MAX_GENTITIES;i++,cent++)
+	{
+		if (cgi_GetDefaultState(i, &cent->currentState))
+		{
+			cent->nextState = &cent->currentState;
+			VectorCopy (cent->currentState.origin, cent->lerpOrigin);
+			VectorCopy (cent->currentState.angles, cent->lerpAngles);
+			cent->currentValid = qtrue;
+
+			cg_permanents[cg_numpermanents++] = cent;
+		}
+	}
+}
+
+/*
+Ghoul2 Insert End
+*/
+
+
+/*
+=================
+CG_PreInit
+
+Called when DLL loads (after subsystem restart, but before gamestate is received)
+=================
+*/
+void CG_PreInit() {
+	CG_Init_CG();
+
+	memset( &cgs, 0, sizeof( cgs ) );
+	iCGResetCount = 0;
+
+	CG_RegisterCvars();
+
+//moved from CG_GameStateReceived because it's loaded sooner now
+	CG_InitLocalEntities();
+
+#ifdef _XBOX	// I can't believe that this isn't necessary on PC, but I'll hold off
+	NumMiscEnts = 0;
+	memset( MiscEnts, 0, sizeof(MiscEnts) );
+#endif
+
+	CG_InitMarkPolys();
+
+
+}
+
+/*
+=================
+CG_Init
+
+Called after every level change or subsystem restart
+=================
+*/
+void CG_Init( int serverCommandSequence ) {
+	cgs.serverCommandSequence = serverCommandSequence;
+
+	cgi_Cvar_Set( "cg_drawHUD", "1" );
+
+	// fonts...
+	//
+	cgs.media.charsetShader = cgi_R_RegisterShaderNoMip("gfx/2d/charsgrid_med");
+
+	cgs.media.qhFontSmall = cgi_R_RegisterFont("ocr_a");
+	cgs.media.qhFontMedium= cgi_R_RegisterFont("ergoec");
+
+	cgs.media.whiteShader   = cgi_R_RegisterShader( "white" );
+	cgs.media.loadTick		= cgi_R_RegisterShaderNoMip( "gfx/hud/load_tick" );
+	cgs.media.loadTickCap	= cgi_R_RegisterShaderNoMip( "gfx/hud/load_tick_cap" );
+	
+	const char	*force_icon_files[NUM_FORCE_POWERS] = 
+	{//icons matching enums forcePowers_t
+		"gfx/mp/f_icon_lt_heal",		//FP_HEAL,
+		"gfx/mp/f_icon_levitation",		//FP_LEVITATION,
+		"gfx/mp/f_icon_speed",			//FP_SPEED,
+		"gfx/mp/f_icon_push",			//FP_PUSH,
+		"gfx/mp/f_icon_pull",			//FP_PULL,
+		"gfx/mp/f_icon_lt_telepathy",	//FP_TELEPATHY,
+		"gfx/mp/f_icon_dk_grip",		//FP_GRIP,
+		"gfx/mp/f_icon_dk_l1",			//FP_LIGHTNING,
+		"gfx/mp/f_icon_saber_throw",	//FP_SABERTHROW
+		"gfx/mp/f_icon_saber_defend",	//FP_SABERDEFEND,
+		"gfx/mp/f_icon_saber_attack",	//FP_SABERATTACK,
+		"gfx/mp/f_icon_dk_rage",		//FP_RAGE,
+		"gfx/mp/f_icon_lt_protect",		//FP_PROTECT,
+		"gfx/mp/f_icon_lt_absorb",		//FP_ABSORB,
+		"gfx/mp/f_icon_dk_drain",		//FP_DRAIN,
+		"gfx/mp/f_icon_sight",			//FP_SEE,
+	};
+
+	// Precache inventory icons
+	for ( int i=0;i<NUM_FORCE_POWERS;i++)
+	{
+		if (force_icon_files[i])
+		{
+			force_icons[i] = cgi_R_RegisterShaderNoMip( force_icon_files[i] );
+		}
+	}
+
+	CG_LoadHudMenu();      // load new hud stuff
+
+	cgi_UI_Menu_OpenByName("loadscreen");
+
+	//rww - Moved from CG_GameStateReceived (we don't want to clear perm ents)
+	memset( cg_entities, 0, sizeof(cg_entities) );
+
+	CG_TransitionPermanent();
+
+	cg.loadLCARSStage		= 0;
+
+	CG_GameStateReceived();
+
+	CG_InitConsoleCommands();
+
+	//
+	// the game server will interpret these commands, which will be automatically
+	// forwarded to the server after they are not recognized locally
+	//
+	cgi_AddCommand ("kill");
+	cgi_AddCommand ("give");
+	cgi_AddCommand ("god");
+	cgi_AddCommand ("notarget");
+	cgi_AddCommand ("noclip");
+	cgi_AddCommand ("undying");
+	cgi_AddCommand ("setviewpos");
+	cgi_AddCommand ("setobjective");
+	cgi_AddCommand ("viewobjective");
+
+
+//ConsoleCommand in g_svcmds.cpp
+	cgi_AddCommand ("entitylist");
+	cgi_AddCommand ("nav");
+	cgi_AddCommand ("npc");
+
+	cgi_AddCommand ("saberColor");
+	cgi_AddCommand ("saber");
+	cgi_AddCommand ("saberblade");
+
+	cgi_AddCommand ("runscript");
+
+	cgi_AddCommand ("playerteam");
+	cgi_AddCommand ("playermodel");
+
+	cgi_AddCommand ("saberAttackCycle");
+
+	cg.weaponPickupTextTime = 0;
+
+	cg.missionInfoFlashTime = 0;
+	cg.missionStatusShow = qfalse;
+
+	cg.missionFailedScreen = qfalse;	// Screen hasn't been opened.
+	cgi_UI_MenuCloseAll();	// So the loadscreen menu will turn off just after the opening snapshot
+}
+
+/*
+=================
+CG_Shutdown
+
+Called before every level change or subsystem restart
+=================
+*/
+void CG_Shutdown( void ) 
+{
+	in_camera = false;
+	FX_Free();
+}
+
+//// DEBUG STUFF
+/*
+-------------------------
+CG_DrawNode
+-------------------------
+*/
+void CG_DrawNode( vec3_t origin, int type )
+{
+	localEntity_t	*ex;
+
+	ex = CG_AllocLocalEntity();
+
+	ex->leType = LE_SPRITE;
+	ex->startTime = cg.time;
+	ex->endTime = ex->startTime + 51;
+	VectorCopy( origin, ex->refEntity.origin );
+		
+	ex->refEntity.customShader = cgi_R_RegisterShader( "gfx/misc/nav_node" );
+
+	float	scale = 16.0f;
+
+	switch ( type )
+	{
+	case NODE_NORMAL:
+		ex->color[0] = 255;
+		ex->color[1] = 255;
+		ex->color[2] = 0;
+		break;
+
+	case NODE_FLOATING:
+		ex->color[0] = 0;
+		ex->color[1] = 255;
+		ex->color[2] = 255;
+		scale += 16.0f;
+		break;
+
+	case NODE_GOAL:
+		ex->color[0] = 255;
+		ex->color[1] = 0;
+		ex->color[2] = 0;
+		scale += 16.0f;
+		break;
+
+	case NODE_NAVGOAL:
+		ex->color[0] = 0;
+		ex->color[1] = 255;
+		ex->color[2] = 0;
+		break;
+	}
+	
+	ex->radius = scale;
+}
+
+/*
+-------------------------
+CG_DrawRadius
+-------------------------
+*/
+
+void CG_DrawRadius( vec3_t origin, unsigned int radius, int type )
+{
+	localEntity_t	*ex;
+
+	ex = CG_AllocLocalEntity();
+
+	ex->leType = LE_QUAD;
+	ex->radius = radius;
+	ex->startTime = cg.time;
+	ex->endTime = ex->startTime + 51;
+	VectorCopy( origin, ex->refEntity.origin );
+		
+	ex->refEntity.customShader = cgi_R_RegisterShader( "gfx/misc/nav_radius" );
+
+	switch ( type )
+	{
+	case NODE_NORMAL:
+		ex->color[0] = 255;
+		ex->color[1] = 255;
+		ex->color[2] = 0;
+		break;
+
+	case NODE_FLOATING:
+		ex->color[0] = 0;
+		ex->color[1] = 255;
+		ex->color[2] = 255;
+		break;
+
+	case NODE_GOAL:
+		ex->color[0] = 255;
+		ex->color[1] = 0;
+		ex->color[2] = 0;
+		break;
+
+	case NODE_NAVGOAL:
+		ex->color[0] = 0;
+		ex->color[1] = 255;
+		ex->color[2] = 0;
+		break;
+	}
+}
+
+/*
+-------------------------
+CG_DrawEdge
+-------------------------
+*/
+
+void CG_DrawEdge( vec3_t start, vec3_t end, int type )
+{
+	switch ( type )
+	{	
+		// NAVIGATION EDGES BETWEEN POINTS
+		//=====================================
+	case EDGE_NORMAL:
+		{
+			FX_AddLine( start, end, 8.0f, 4.0f, 0.0f, 0.5f, 0.5f, 51, cgi_R_RegisterShader( "gfx/misc/nav_line" ), 0 );
+		}
+		break;
+	case EDGE_LARGE:
+		{
+			FX_AddLine( start, end, 8.0f, 15.0f, 0.0f, 0.5f, 0.5f, 51, cgi_R_RegisterShader( "gfx/misc/nav_line" ), 0 );
+		}
+		break;	
+	case EDGE_BLOCKED:
+		{
+			vec3_t	color = { 255, 0, 0 };	// RED
+			FX_AddLine( start, end, 8.0f, 4.0f, 0.0f, 0.5f, 0.5f, color, color, 51, cgi_R_RegisterShader( "gfx/misc/nav_line" ), 0 );
+		}
+		break;
+	case EDGE_FLY:
+		{
+			vec3_t	color = { 0, 255, 255 };// GREEN
+			FX_AddLine( start, end, 8.0f, 4.0f, 0.0f, 0.5f, 0.5f, color, color, 51, cgi_R_RegisterShader( "gfx/misc/nav_line" ), 0 );
+		}
+		break;
+	case EDGE_JUMP:
+		{
+			vec3_t	color = { 0, 0, 255 };	// BLUE
+			FX_AddLine( start, end, 8.0f, 4.0f, 0.0f, 0.5f, 0.5f, color, color, 51, cgi_R_RegisterShader( "gfx/misc/nav_line" ), 0 );
+		}
+		break;
+
+
+
+		// EDGE NODES
+		//=====================================
+	case EDGE_NODE_NORMAL:
+		{
+			vec3_t	color = { 155, 155, 155 };
+			FX_AddLine( start, end, 2.0f, 1.0f, 0.0f, 1.0f, 1.0f, color, color, 151, cgi_R_RegisterShader( "gfx/misc/whiteline2" ), 0 );
+		}
+		break;
+	case EDGE_NODE_FLOATING:
+		{
+			vec3_t	color = { 155, 155, 0 };
+			FX_AddLine( start, end, 2.0f, 1.0f, 0.0f, 1.0f, 1.0f, color, color, 151, cgi_R_RegisterShader( "gfx/misc/whiteline2" ), 0 );
+		}
+		break;
+	case EDGE_NODE_GOAL:
+		{
+			vec3_t	color = { 0, 0, 155 };
+			FX_AddLine( start, end, 2.0f, 1.0f, 0.0f, 1.0f, 1.0f, color, color, 151, cgi_R_RegisterShader( "gfx/misc/whiteline2" ), 0 );
+		}
+		break;
+	case EDGE_NODE_COMBAT:
+		{
+			vec3_t	color = { 155, 0, 0 };
+			FX_AddLine( start, end, 2.0f, 1.0f, 0.0f, 1.0f, 1.0f, color, color, 151, cgi_R_RegisterShader( "gfx/misc/whiteline2" ), 0 );
+		}
+		break;
+
+
+
+
+		// NEAREST NAV 
+		//=====================================
+	case EDGE_NEARESTVALID:
+		{
+			vec3_t	color = { 155, 155, 155 };	// WHITE
+			FX_AddLine( -1, start, end, 1.0f, 1.0f, 0, 1.0f, 1.0f, FX_ALPHA_LINEAR, color, color, 0, 51, cgi_R_RegisterShader( "gfx/misc/whiteline2" ), 0, 0 );
+		}
+		break;
+
+	case EDGE_NEARESTINVALID:
+		{
+			vec3_t	color = { 155, 0, 0 };	// WHITE
+			FX_AddLine( -1, start, end, 1.0f, 1.0f, 0, 1.0f, 1.0f, FX_ALPHA_LINEAR, color, color, 0, 51, cgi_R_RegisterShader( "gfx/misc/whiteline2" ), 0, 0 );
+		}
+		break;
+
+
+		// NEAREST NAV CELLS
+		//=====================================
+	case EDGE_CELL:
+		{
+			vec3_t	color = { 155, 155, 155 };	// WHITE
+			FX_AddLine( -1, start, end, 1.0f, 1.0f, 0, 1.0f, 1.0f, FX_ALPHA_LINEAR, color, color, 0, 51, cgi_R_RegisterShader( "gfx/misc/whiteline2" ), 0, 0 );
+		}
+		break;
+	case EDGE_CELL_EMPTY:
+		{	
+			vec3_t	color = { 255, 0, 0 };		// RED
+			FX_AddLine( -1, start, end, 1.0f, 1.0f, 0, 1.0f, 1.0f, FX_ALPHA_LINEAR, color, color, 0, 51, cgi_R_RegisterShader( "gfx/misc/whiteline2" ), 0, 0 );
+		}
+		break;
+
+
+		// ACTOR PATHS
+		//=============
+	case EDGE_PATH:
+		{
+  			vec3_t	color = { 0, 0, 155 };		// WHITE
+ 			FX_AddLine( start, end, 5.0f, 5.0f, 0.0f, 0.5f, 0.5f, color, color, 151, cgi_R_RegisterShader( "gfx/misc/nav_arrow_new" ), 0 );
+		}
+		break;
+
+	case EDGE_PATHBLOCKED:
+		{
+ 			vec3_t	color = { 255, 0, 0 };		// RED
+			FX_AddLine( start, end, 5.0f, 5.0f, 0.0f, 0.5f, 0.5f, color, color, 151, cgi_R_RegisterShader( "gfx/misc/nav_arrow_new" ), 0 );
+			break;
+		}
+
+	case EDGE_FOLLOWPOS:
+		{
+			vec3_t	color = { 0, 255, 0 };		// GREEN
+			FX_AddLine( start, end, 5.0f, 5.0f, 0.0f, 0.5f, 0.5f, color, color, 151, cgi_R_RegisterShader( "gfx/misc/nav_arrow_new" ), 0 );
+			break;
+		}
+
+
+		// STEERING
+		//=====================================
+	case EDGE_IMPACT_SAFE:
+		{
+			vec3_t	color = { 155, 155, 155 };	// WHITE
+			FX_AddLine( start, end, 2.0f, 1.0f, 0.0f, 1.0f, 1.0f, color, color, 151, cgi_R_RegisterShader( "gfx/misc/whiteline2" ), 0 );
+		}
+		break;
+	case EDGE_IMPACT_POSSIBLE:
+		{
+			vec3_t	color = { 255, 0, 0 };		// RED
+			FX_AddLine( start, end, 2.0f, 1.0f, 0.0f, 1.0f, 1.0f, color, color, 151, cgi_R_RegisterShader( "gfx/misc/whiteline2" ), 0 );
+		}
+		break;
+	case EDGE_VELOCITY:
+		{
+			vec3_t	color = { 0, 255, 0 };		// GREEN
+			FX_AddLine( start, end, 4.0f, 1.0f, 0.0f, 1.0f, 1.0f, color, color, 151, cgi_R_RegisterShader( "gfx/misc/whiteline2" ), 0 );
+		}
+		break;
+	case EDGE_THRUST:
+		{
+			vec3_t	color = { 0, 0, 255 };		// BLUE
+			FX_AddLine( start, end, 3.0f, 1.0f, 0.0f, 1.0f, 1.0f, color, color, 151, cgi_R_RegisterShader( "gfx/misc/whiteline2" ), 0 );
+		}
+		break;
+
+
+		// MISC Colored Lines
+		//=====================================
+	case EDGE_WHITE_ONESECOND:
+		{
+			vec3_t	color = { 155, 155, 155 };	// WHITE
+			FX_AddLine( start, end, 3.0f, 1.0f, 0.0f, 1.0f, 1.0f, color, color, 1051, cgi_R_RegisterShader( "gfx/misc/whiteline2" ), 0 );
+		}
+		break;
+	case EDGE_WHITE_TWOSECOND:
+		{
+			vec3_t	color = { 155, 155, 155 };	// WHITE
+			FX_AddLine( start, end, 3.0f, 1.0f, 0.0f, 1.0f, 1.0f, color, color, 1051, cgi_R_RegisterShader( "gfx/misc/whiteline2" ), 0 );
+		}
+		break;
+	case EDGE_RED_ONESECOND:
+		{
+			vec3_t	color = { 255, 0, 0 };		// RED
+			FX_AddLine( start, end, 3.0f, 1.0f, 0.0f, 1.0f, 1.0f, color, color, 2051, cgi_R_RegisterShader( "gfx/misc/whiteline2" ), 0 );
+		}
+		break;
+	case EDGE_RED_TWOSECOND:
+		{
+			vec3_t	color = { 255, 0, 0 };		// RED
+			FX_AddLine( start, end, 3.0f, 1.0f, 0.0f, 1.0f, 1.0f, color, color, 2051, cgi_R_RegisterShader( "gfx/misc/whiteline2" ), 0 );
+		}
+		break;
+
+	default:
+		break;
+	}
+}
+
+/*
+-------------------------
+CG_DrawCombatPoint
+-------------------------
+*/
+
+void CG_DrawCombatPoint( vec3_t origin, int type )
+{
+	localEntity_t	*ex;
+
+	ex = CG_AllocLocalEntity();
+
+	ex->leType = LE_SPRITE;
+	ex->startTime = cg.time;
+	ex->radius = 8;
+	ex->endTime = ex->startTime + 51;
+	VectorCopy( origin, ex->refEntity.origin );
+		
+	ex->refEntity.customShader = cgi_R_RegisterShader( "gfx/misc/nav_cpoint" );
+
+	ex->color[0] = 255;
+	ex->color[1] = 0;
+	ex->color[2] = 255;
+
+/*
+	switch( type )
+	{
+	case 0:	//FIXME: To shut up the compiler warning (more will be added here later of course)
+	default:
+		FX_AddSprite( origin, NULL, NULL, 8.0f, 0.0f, 1.0f, 1.0f, color, color, 0.0f, 0.0f, 51, cgi_R_RegisterShader( "gfx/misc/nav_cpoint" ) );
+		break;
+	}
+*/
+}
+
+/*
+-------------------------
+CG_DrawAlert
+-------------------------
+*/
+
+void CG_DrawAlert( vec3_t origin, float rating )
+{
+	vec3_t	drawPos;
+
+	VectorCopy( origin, drawPos );
+	drawPos[2] += 48;
+
+	vec3_t	startRGB;
+
+	//Fades from green at 0, to red at 1
+	startRGB[0] = rating;
+	startRGB[1] = 1 - rating;
+	startRGB[2] = 0;
+
+	FX_AddSprite( drawPos, NULL, NULL, 16, 0.0f, 1.0f, 1.0f, startRGB, startRGB, 0, 0, 50, cgs.media.whiteShader );
+}
+
+
+#define MAX_MENUDEFFILE				4096
+
+//
+// ==============================
+// new hud stuff ( mission pack )
+// ==============================
+//
+qboolean CG_Asset_Parse(const char **p) 
+{
+	const char *token;
+	const char *tempStr;
+	int pointSize;
+
+	token = COM_ParseExt(p, qtrue);
+
+	if (!token)
+	{
+		return qfalse;
+	}
+
+	if (Q_stricmp(token, "{") != 0) 
+	{
+		return qfalse;
+	}
+    
+	while ( 1 ) 
+	{
+		token = COM_ParseExt(p, qtrue);
+		if (!token)
+		{
+			return qfalse;
+		}
+
+		if (Q_stricmp(token, "}") == 0) 
+		{
+			return qtrue;
+		}
+
+		// font
+		if (Q_stricmp(token, "font") == 0) 
+		{
+/*
+			int pointSize;
+
+			cgi_UI_Parse_String(tempStr);
+			cgi_UI_Parse_Int(&pointSize);
+
+			if (!tempStr || !pointSize) 
+			{
+				return qfalse;
+			}
+*/
+//			cgDC.registerFont(tempStr, pointSize, &cgDC.Assets.textFont);
+			continue;
+		}
+
+		// smallFont
+		if (Q_stricmp(token, "smallFont") == 0) 
+		{
+			if (!COM_ParseString(p, &tempStr) || !COM_ParseInt(p, &pointSize)) 
+			{
+				return qfalse;
+			}
+//			cgDC.registerFont(tempStr, pointSize, &cgDC.Assets.smallFont);
+			continue;
+		}
+
+		// smallFont - because the HUD file needs it for MP.
+		if (Q_stricmp(token, "small2Font") == 0) 
+		{
+			if (!COM_ParseString(p, &tempStr) || !COM_ParseInt(p, &pointSize)) 
+			{
+				return qfalse;
+			}
+//			cgDC.registerFont(tempStr, pointSize, &cgDC.Assets.smallFont);
+			continue;
+		}
+
+		// font
+		if (Q_stricmp(token, "bigfont") == 0) 
+		{
+			int pointSize;
+			if (!COM_ParseString(p, &tempStr) || !COM_ParseInt(p, &pointSize)) 
+			{
+				return qfalse;
+			}
+//			cgDC.registerFont(tempStr, pointSize, &cgDC.Assets.bigFont);
+			continue;
+		}
+
+		// gradientbar
+		if (Q_stricmp(token, "gradientbar") == 0) 
+		{
+			if (!COM_ParseString(p, &tempStr)) 
+			{
+				return qfalse;
+			}
+//			cgDC.Assets.gradientBar = trap_R_RegisterShaderNoMip(tempStr);
+			continue;
+		}
+
+		// enterMenuSound
+		if (Q_stricmp(token, "menuEnterSound") == 0) 
+		{
+			if (!COM_ParseString(p, &tempStr)) 
+			{
+				return qfalse;
+			}
+//			cgDC.Assets.menuEnterSound = trap_S_RegisterSound( tempStr );
+			continue;
+		}
+
+		// exitMenuSound
+		if (Q_stricmp(token, "menuExitSound") == 0) 
+		{
+			if (!COM_ParseString(p, &tempStr)) 
+			{
+				return qfalse;
+			}
+//			cgDC.Assets.menuExitSound = trap_S_RegisterSound( tempStr );
+			continue;
+		}
+
+		// itemFocusSound
+		if (Q_stricmp(token, "itemFocusSound") == 0) 
+		{
+			if (!COM_ParseString(p, &tempStr)) 
+			{
+				return qfalse;
+			}
+//			cgDC.Assets.itemFocusSound = trap_S_RegisterSound( tempStr );
+			continue;
+		}
+
+		// menuBuzzSound
+		if (Q_stricmp(token, "menuBuzzSound") == 0) 
+		{
+			if (!COM_ParseString(p, &tempStr)) 
+			{
+				return qfalse;
+			}
+//			cgDC.Assets.menuBuzzSound = trap_S_RegisterSound( tempStr );
+			continue;
+		}
+
+		if (Q_stricmp(token, "cursor") == 0) 
+		{
+//			if (!COM_ParseString(p, &cgDC.Assets.cursorStr)) 
+//			{
+//				return qfalse;
+//			}
+//			cgDC.Assets.cursor = trap_R_RegisterShaderNoMip( cgDC.Assets.cursorStr);
+			continue;
+		}
+
+		if (Q_stricmp(token, "fadeClamp") == 0) 
+		{
+//			if (!COM_ParseFloat(p, &cgDC.Assets.fadeClamp)) 
+//			{
+//				return qfalse;
+//			}
+			continue;
+		}
+
+		if (Q_stricmp(token, "fadeCycle") == 0) 
+		{
+//			if (!COM_ParseInt(p, &cgDC.Assets.fadeCycle)) 
+//			{
+//				return qfalse;
+//			}
+			continue;
+		}
+
+		if (Q_stricmp(token, "fadeAmount") == 0) 
+		{
+//			if (!COM_ParseFloat(p, &cgDC.Assets.fadeAmount)) 
+//			{
+//				return qfalse;
+//			}
+			continue;
+		}
+
+		if (Q_stricmp(token, "shadowX") == 0) 
+		{
+//			if (!COM_ParseFloat(p, &cgDC.Assets.shadowX)) 
+//			{
+//				return qfalse;
+//			}
+			continue;
+		}
+
+		if (Q_stricmp(token, "shadowY") == 0) 
+		{
+//			if (!COM_ParseFloat(p, &cgDC.Assets.shadowY)) 
+//			{
+//				return qfalse;
+//			}
+			continue;
+		}
+
+		if (Q_stricmp(token, "shadowColor") == 0) 
+		{
+			/*
+			if (!PC_Color_Parse(handle, &cgDC.Assets.shadowColor)) 
+			{
+				return qfalse;
+			}
+			cgDC.Assets.shadowFadeClamp = cgDC.Assets.shadowColor[3];
+			*/
+			continue;
+		}
+	}
+	return qfalse; // bk001204 - why not?
+}
+
+void cgi_UI_EndParseSession(char *buf);
+
+/*
+=================
+CG_ParseMenu();
+=================
+*/
+void CG_ParseMenu(const char *menuFile) 
+{
+	char			*token;
+	int				result;
+	char			*buf,*p;
+
+	//Com_Printf("Parsing menu file:%s\n", menuFile);
+
+	result = cgi_UI_StartParseSession((char *) menuFile,&buf);
+
+	if (!result)
+	{
+		Com_Printf("Unable to load hud menu file:%s. Using default ui/testhud.menu.\n", menuFile);
+		result = cgi_UI_StartParseSession("ui/testhud.menu",&buf);
+		if (!result)
+		{
+			Com_Printf("Unable to load default ui/testhud.menu.\n");
+			return;
+		}
+	}
+
+	p = buf;
+	while ( 1 ) 
+	{
+		cgi_UI_ParseExt(&token);
+
+		if (!*token)	// All done?
+		{
+			break;
+		}
+
+		//if ( Q_stricmp( token, "{" ) ) {
+		//	Com_Printf( "Missing { in menu file\n" );
+		//	break;
+		//}
+
+		//if ( menuCount == MAX_MENUS ) {
+		//	Com_Printf( "Too many menus!\n" );
+		//	break;
+		//}
+
+//		if ( *token == '}' ) 
+//		{
+//			break;
+//		}
+
+		if (Q_stricmp(token, "assetGlobalDef") == 0) 
+		{
+			/*
+			if (CG_Asset_Parse(handle)) 
+			{
+				continue;
+			} 
+			else 
+			{
+				break;
+			}
+			*/
+		}
+
+
+		if (Q_stricmp(token, "menudef") == 0) 
+		{
+			// start a new menu
+			cgi_UI_Menu_New(p);
+		}
+	}
+
+	cgi_UI_EndParseSession(buf);
+
+}
+
+/*
+=================
+CG_Load_Menu();
+
+=================
+*/
+qboolean CG_Load_Menu( const char **p) 
+{
+	const char *token;
+
+	token = COM_ParseExt(p, qtrue);
+
+	if (token[0] != '{') 
+	{
+		return qfalse;
+	}
+
+	while ( 1 ) 
+	{
+
+		token = COM_ParseExt(p, qtrue);
+    
+		if (Q_stricmp(token, "}") == 0) 
+		{
+			return qtrue;
+		}
+
+		if ( !token || token[0] == 0 ) 
+		{
+			return qfalse;
+		}
+
+		CG_ParseMenu(token); 
+	}
+	return qfalse;
+}
+
+/*
+=================
+CG_LoadMenus();
+
+=================
+*/
+void CG_LoadMenus(const char *menuFile) 
+{
+	const char	*token;
+	const char	*p;
+	int	len, start;
+	fileHandle_t	f;
+	char buf[MAX_MENUDEFFILE];
+
+	start = cgi_Milliseconds();
+
+	len = cgi_FS_FOpenFile( menuFile, &f, FS_READ );
+	if ( !f ) 
+	{
+		cgi_Error( va( S_COLOR_YELLOW "menu file not found: %s, using default\n", menuFile ) );
+		len = cgi_FS_FOpenFile( "ui/jahud.txt", &f, FS_READ );
+		if (!f) 
+		{
+			cgi_Error( va( S_COLOR_RED "default menu file not found: ui/hud.txt, unable to continue!\n", menuFile ) );
+		}
+	}
+
+	if ( len >= MAX_MENUDEFFILE ) 
+	{
+		cgi_Error( va( S_COLOR_RED "menu file too large: %s is %i, max allowed is %i", menuFile, len, MAX_MENUDEFFILE ) );
+		cgi_FS_FCloseFile( f );
+		return;
+	}
+
+	cgi_FS_Read( buf, len, f );
+	buf[len] = 0;
+	cgi_FS_FCloseFile( f );
+	
+//	COM_Compress(buf);
+
+//	cgi_UI_Menu_Reset();
+
+	p = buf;
+
+	while ( 1 ) 
+	{
+		token = COM_ParseExt( &p, qtrue );
+		if( !token || token[0] == 0 || token[0] == '}') 
+		{
+			break;
+		}
+
+		if ( Q_stricmp( token, "}" ) == 0 ) 
+		{
+			break;
+		}
+
+		if (Q_stricmp(token, "loadmenu") == 0) 
+		{
+			if (CG_Load_Menu(&p)) 
+			{
+				continue;
+			} 
+			else 
+			{
+				break;
+			}
+		}
+	}
+
+	//Com_Printf("UI menu load time = %d milli seconds\n", cgi_Milliseconds() - start);
+}
+
+/*
+=================
+CG_LoadHudMenu();
+
+=================
+*/
+void CG_LoadHudMenu(void) 
+{
+	const char *hudSet;
+/*
+	cgDC.registerShaderNoMip = &trap_R_RegisterShaderNoMip;
+	cgDC.setColor = &trap_R_SetColor;
+	cgDC.drawHandlePic = &CG_DrawPic;
+	cgDC.drawStretchPic = &trap_R_DrawStretchPic;
+	cgDC.drawText = &CG_Text_Paint;
+	cgDC.textWidth = &CG_Text_Width;
+	cgDC.textHeight = &CG_Text_Height;
+	cgDC.registerModel = &trap_R_RegisterModel;
+	cgDC.modelBounds = &trap_R_ModelBounds;
+	cgDC.fillRect = &CG_FillRect;
+	cgDC.drawRect = &CG_DrawRect;   
+	cgDC.drawSides = &CG_DrawSides;
+	cgDC.drawTopBottom = &CG_DrawTopBottom;
+	cgDC.clearScene = &trap_R_ClearScene;
+	cgDC.addRefEntityToScene = &trap_R_AddRefEntityToScene;
+	cgDC.renderScene = &trap_R_RenderScene;
+	cgDC.registerFont = &trap_R_RegisterFont;
+	cgDC.ownerDrawItem = &CG_OwnerDraw;
+	cgDC.getValue = &CG_GetValue;
+	cgDC.ownerDrawVisible = &CG_OwnerDrawVisible;
+	cgDC.runScript = &CG_RunMenuScript;
+	cgDC.getTeamColor = &CG_GetTeamColor;
+	cgDC.setCVar = trap_Cvar_Set;
+	cgDC.getCVarString = trap_Cvar_VariableStringBuffer;
+	cgDC.getCVarValue = CG_Cvar_Get;
+	cgDC.drawTextWithCursor = &CG_Text_PaintWithCursor;
+	cgDC.startLocalSound = &trap_S_StartLocalSound;
+	cgDC.ownerDrawHandleKey = &CG_OwnerDrawHandleKey;
+	cgDC.feederCount = &CG_FeederCount;
+	cgDC.feederItemImage = &CG_FeederItemImage;
+	cgDC.feederItemText = &CG_FeederItemText;
+	cgDC.feederSelection = &CG_FeederSelection;
+	cgDC.Error = &Com_Error; 
+	cgDC.Print = &Com_Printf; 
+	cgDC.ownerDrawWidth = &CG_OwnerDrawWidth;
+	cgDC.registerSound = &trap_S_RegisterSound;
+	cgDC.startBackgroundTrack = &trap_S_StartBackgroundTrack;
+	cgDC.stopBackgroundTrack = &trap_S_StopBackgroundTrack;
+	cgDC.playCinematic = &CG_PlayCinematic;
+	cgDC.stopCinematic = &CG_StopCinematic;
+	cgDC.drawCinematic = &CG_DrawCinematic;
+	cgDC.runCinematicFrame = &CG_RunCinematicFrame;
+*/	
+//	Init_Display(&cgDC);
+
+//	cgi_UI_String_Init();
+
+//	cgi_UI_Menu_Reset();
+	
+	hudSet = cg_hudFiles.string;
+	if (hudSet[0] == '\0') 
+	{
+		hudSet = "ui/jahud.txt";
+	}
+
+	CG_LoadMenus(hudSet);
+}
+
+
+/*
+==============================================================================
+
+INVENTORY SELECTION
+
+==============================================================================
+*/
+
+/*
+===============
+CG_InventorySelectable
+===============
+*/
+static inline qboolean CG_InventorySelectable( int index) 
+{
+	if (cg.snap->ps.inventory[index])	// Is there any in the inventory?
+	{
+		return qtrue;
+	}
+
+	return qfalse;
+}
+
+
+/*
+===============
+SetInventoryTime
+===============
+*/
+static inline void SetInventoryTime(void)
+{
+	if (((cg.weaponSelectTime + WEAPON_SELECT_TIME) > cg.time) ||	// The Weapon HUD was currently active to just swap it out with Force HUD
+		((cg.forcepowerSelectTime + WEAPON_SELECT_TIME) > cg.time))	// The Force HUD was currently active to just swap it out with Force HUD
+	{
+		cg.weaponSelectTime = 0;
+		cg.forcepowerSelectTime = 0;
+		cg.inventorySelectTime = cg.time + 130.0f;
+	}
+	else
+	{
+		cg.inventorySelectTime = cg.time;
+	}
+}
+
+/*
+===============
+CG_DPPrevInventory_f
+===============
+*/
+void CG_DPPrevInventory_f( void ) 
+{
+	int		i;
+
+	if ( !cg.snap ) 
+	{
+		return;
+	}
+
+	const int original = cg.DataPadInventorySelect;
+
+	for ( i = 0 ; i < INV_MAX ; i++ ) 
+	{
+		cg.DataPadInventorySelect--;
+
+		if ((cg.DataPadInventorySelect < INV_ELECTROBINOCULARS) || (cg.DataPadInventorySelect >= INV_MAX))
+		{ 
+			cg.DataPadInventorySelect = (INV_MAX - 1); 
+		}
+		
+		if ( CG_InventorySelectable( cg.DataPadInventorySelect ) )
+		{	
+			return;
+		}
+	}
+
+	cg.DataPadInventorySelect = original;
+}
+/*
+===============
+CG_DPNextInventory_f
+===============
+*/
+void CG_DPNextInventory_f( void ) 
+{
+	int		i;
+
+	if ( !cg.snap ) 
+	{
+		return;
+	}
+
+	const int original = cg.DataPadInventorySelect;
+
+	for ( i = 0 ; i < INV_MAX ; i++ ) 
+	{
+		cg.DataPadInventorySelect++;
+
+		if ((cg.DataPadInventorySelect < INV_ELECTROBINOCULARS) || (cg.DataPadInventorySelect >= INV_MAX))
+		{ 
+			cg.DataPadInventorySelect = INV_ELECTROBINOCULARS; 
+		}
+
+		if ( CG_InventorySelectable( cg.DataPadInventorySelect ) && (inv_icons[cg.DataPadInventorySelect])) 
+		{	
+			return;
+		}
+	}
+
+	cg.DataPadInventorySelect = original;
+}
+
+/*
+===============
+CG_NextInventory_f
+===============
+*/
+void CG_NextInventory_f( void ) 
+{
+	int		i;
+	float	*color;
+
+	if ( !cg.snap ) 
+	{
+		return;
+	}
+
+	// The first time it's been hit so just show inventory but don't advance in inventory.
+	color = CG_FadeColor( cg.inventorySelectTime, WEAPON_SELECT_TIME );	
+	if ( !color )	
+	{
+		SetInventoryTime();
+		return;
+	}
+
+	const int original = cg.inventorySelect;
+
+	for ( i = 0 ; i < INV_MAX ; i++ ) 
+	{
+		cg.inventorySelect++;
+
+		if ((cg.inventorySelect < INV_ELECTROBINOCULARS) || (cg.inventorySelect >= INV_MAX))
+		{ 
+			cg.inventorySelect = INV_ELECTROBINOCULARS; 
+		}
+
+		if ( CG_InventorySelectable( cg.inventorySelect ) && (inv_icons[cg.inventorySelect])) 
+		{	
+			cgi_S_StartSound (NULL, 0, CHAN_AUTO, cgs.media.selectSound2 );
+			SetInventoryTime();
+			return;
+		}
+	}
+
+	cg.inventorySelect = original;
+}
+
+/*
+===============
+CG_UseInventory_f
+===============
+*/
+/*
+this func was moved to Cmd_UseInventory_f in g_cmds.cpp
+*/
+
+/*
+===============
+CG_PrevInventory_f
+===============
+*/
+void CG_PrevInventory_f( void ) 
+{
+	int		i;
+	float	*color;
+
+	if ( !cg.snap ) 
+	{
+		return;
+	}
+
+	// The first time it's been hit so just show inventory but don't advance in inventory.
+	color = CG_FadeColor( cg.inventorySelectTime, WEAPON_SELECT_TIME );	
+	if ( !color )	
+	{
+		SetInventoryTime();
+		return;
+	}
+
+	const int original = cg.inventorySelect;
+
+	for ( i = 0 ; i < INV_MAX ; i++ ) 
+	{
+		cg.inventorySelect--;
+
+		if ((cg.inventorySelect < INV_ELECTROBINOCULARS) || (cg.inventorySelect >= INV_MAX))
+		{ 
+			cg.inventorySelect = (INV_MAX - 1); 
+		}
+		
+		if ( CG_InventorySelectable( cg.inventorySelect ) && (inv_icons[cg.inventorySelect])) 
+		{	
+			cgi_S_StartSound (NULL, 0, CHAN_AUTO, cgs.media.selectSound2 );
+			SetInventoryTime();
+			return;
+		}
+	}
+
+	cg.inventorySelect = original;
+}
+
+
+/*
+===================
+FindInventoryItemTag
+===================
+*/
+gitem_t *FindInventoryItemTag(int tag)
+{
+	int		i;
+
+	for ( i = 1 ; i < bg_numItems ; i++ ) 
+	{
+		if ( bg_itemlist[i].giTag == tag && bg_itemlist[i].giType == IT_HOLDABLE ) // I guess giTag's aren't unique amongst items..must also make sure it's a holdable
+		{
+			return &bg_itemlist[i];
+		}
+	}
+
+	return (0);
+}
+
+
+
+
+/*
+===================
+CG_DrawInventorySelect
+===================
+*/
+void CG_DrawInventorySelect( void ) 
+{
+	int				i;
+	int				holdCount,iconCnt;
+	int				sideLeftIconCnt,sideRightIconCnt;
+	int				count;
+	int				holdX;
+	int				height;
+//	int				tag;
+	float			addX;
+	vec4_t			textColor = { .312f, .75f, .621f, 1.0f };
+	char			text[1024]={0};
+
+	// don't display if dead
+	if ( cg.predicted_player_state.stats[STAT_HEALTH] <= 0 || ( cg.snap->ps.viewEntity > 0 && cg.snap->ps.viewEntity < ENTITYNUM_WORLD )) 
+	{
+		return;
+	}
+
+	if ((cg.inventorySelectTime+WEAPON_SELECT_TIME)<cg.time)	// Time is up for the HUD to display
+	{
+		return;
+	}
+
+	int x2,y2,w2,h2;
+	if (!cgi_UI_GetMenuInfo("inventoryselecthud",&x2,&y2,&w2,&h2))
+	{
+		return;
+	}
+
+	cg.iconSelectTime = cg.inventorySelectTime;
+
+	// showing weapon select clears pickup item display, but not the blend blob
+	cg.itemPickupTime = 0;
+
+	// count the number of items owned
+	count = 0;
+	for ( i = 0 ; i < INV_MAX ; i++ ) 
+	{
+		if (CG_InventorySelectable(i) && inv_icons[i]) 
+		{
+			count++;
+		}
+	}
+
+	if (!count)
+	{
+		cgi_SP_GetStringTextString("SP_INGAME_EMPTY_INV",text, sizeof(text) );
+		int w = cgi_R_Font_StrLenPixels( text, cgs.media.qhFontSmall, 1.0f );	
+		int x = ( SCREEN_WIDTH - w ) / 2;
+		CG_DrawProportionalString(x, y2 + 22, text, CG_CENTER | CG_SMALLFONT, colorTable[CT_ICON_BLUE]);
+		return;
+	}
+
+	const int sideMax = 3;	// Max number of icons on the side
+
+	// Calculate how many icons will appear to either side of the center one
+	holdCount = count - 1;	// -1 for the center icon
+	if (holdCount == 0)			// No icons to either side
+	{
+		sideLeftIconCnt = 0;
+		sideRightIconCnt = 0;
+	}
+	else if (count > (2*sideMax))	// Go to the max on each side
+	{
+		sideLeftIconCnt = sideMax;
+		sideRightIconCnt = sideMax;
+	}
+	else							// Less than max, so do the calc
+	{
+		sideLeftIconCnt = holdCount/2;
+		sideRightIconCnt = holdCount - sideLeftIconCnt;
+	}
+
+	i = cg.inventorySelect - 1;
+	if (i<0)
+	{
+		i = INV_MAX-1;
+	}
+
+	const int smallIconSize = 40;
+	const int bigIconSize = 80;
+	const int pad = 16;
+
+	const int x = 320;
+	const int y = 410;
+
+	// Left side ICONS
+	// Work backwards from current icon
+	holdX = x - ((bigIconSize/2) + pad + smallIconSize);
+	height = smallIconSize * cg.iconHUDPercent;
+	addX = (float) smallIconSize * .75;
+
+	for (iconCnt=0;iconCnt<sideLeftIconCnt;i--)
+	{
+		if (i<0)
+		{
+			i = INV_MAX-1;
+		}
+
+		if ((!CG_InventorySelectable(i)) || (!inv_icons[i]))
+		{
+			continue;
+		}
+
+		++iconCnt;					// Good icon
+
+		if (inv_icons[i])
+		{
+			cgi_R_SetColor(NULL);
+			CG_DrawPic( holdX, y+10, smallIconSize, smallIconSize, inv_icons[i] );
+
+			cgi_R_SetColor(colorTable[CT_ICON_BLUE]);
+			CG_DrawNumField (holdX + addX, y + smallIconSize, 2, cg.snap->ps.inventory[i], 6, 12, 
+				NUM_FONT_SMALL,qfalse);
+
+			holdX -= (smallIconSize+pad);
+		}
+	}
+
+	// Current Center Icon
+	height = bigIconSize * cg.iconHUDPercent;
+	if (inv_icons[cg.inventorySelect])
+	{
+		cgi_R_SetColor(NULL);
+		CG_DrawPic( x-(bigIconSize/2), (y-((bigIconSize-smallIconSize)/2))+10, bigIconSize, bigIconSize, inv_icons[cg.inventorySelect] );
+		addX = (float) bigIconSize * .75;
+		cgi_R_SetColor(colorTable[CT_ICON_BLUE]);
+		CG_DrawNumField ((x-(bigIconSize/2)) + addX, y, 2, cg.snap->ps.inventory[cg.inventorySelect], 6, 12, 
+			NUM_FONT_SMALL,qfalse);
+
+		if (inv_names[cg.inventorySelect])
+		{
+			// FIXME: This is ONLY a temp solution, the icon stuff, etc, should all just use items.dat for everything
+			gitem_t *item = FindInventoryItemTag( cg.inventorySelect );
+
+			if ( item && item->classname && item->classname[0] )
+			{
+				char itemName[256], data[1024]; // FIXME: do these really need to be this large??  does it matter?
+
+				sprintf( itemName, "SP_INGAME_%s",	item->classname );
+			
+				if ( cgi_SP_GetStringTextString( itemName, data, sizeof( data )))
+				{
+					int w = cgi_R_Font_StrLenPixels( data, cgs.media.qhFontSmall, 1.0f );	
+					int x = ( SCREEN_WIDTH - w ) / 2;
+
+					cgi_R_Font_DrawString( x, (SCREEN_HEIGHT - 24), data, textColor, cgs.media.qhFontSmall, -1, 1.0f);
+				}
+			}
+		}
+	}
+
+	i = cg.inventorySelect + 1;
+	if (i> INV_MAX-1)
+	{
+		i = 0;
+	}
+
+	// Right side ICONS
+	// Work forwards from current icon
+	holdX = x + (bigIconSize/2) + pad;
+	height = smallIconSize * cg.iconHUDPercent;
+	addX = (float) smallIconSize * .75;
+	for (iconCnt=0;iconCnt<sideRightIconCnt;i++)
+	{
+		if (i> INV_MAX-1)
+		{
+			i = 0;
+		}
+
+		if ((!CG_InventorySelectable(i)) || (!inv_icons[i]))
+		{
+			continue;
+		}
+
+		++iconCnt;					// Good icon
+
+		if (inv_icons[i])
+		{
+			cgi_R_SetColor(NULL);
+			CG_DrawPic( holdX, y+10, smallIconSize, smallIconSize, inv_icons[i] );
+
+			cgi_R_SetColor(colorTable[CT_ICON_BLUE]);
+			CG_DrawNumField (holdX + addX, y + smallIconSize, 2, cg.snap->ps.inventory[i], 6, 12, 
+				NUM_FONT_SMALL,qfalse);
+
+			holdX += (smallIconSize+pad);
+		}
+	}
+}
+
+int cgi_UI_GetItemText(char *menuFile,char *itemName, char *text);
+
+char *inventoryDesc[15] = 
+{
+"NEURO_SAAV_DESC",
+"BACTA_DESC",
+"INQUISITOR_DESC",
+"LA_GOGGLES_DESC",
+"PORTABLE_SENTRY_DESC",
+"GOODIE_KEY_DESC",
+"SECURITY_KEY_DP_DESC",
+};
+
+
+/*
+===================
+CG_DrawDataPadInventorySelect
+===================
+*/
+void CG_DrawDataPadInventorySelect( void ) 
+{
+	int				i;
+	int				holdCount,iconCnt;
+	int				sideLeftIconCnt,sideRightIconCnt;
+	int				count;
+	int				holdX;
+	int				height;
+	float			addX;
+	char			text[1024]={0};
+	vec4_t			textColor = { .312f, .75f, .621f, 1.0f };
+
+
+	// count the number of items owned
+	count = 0;
+	for ( i = 0 ; i < INV_MAX ; i++ ) 
+	{
+		if (CG_InventorySelectable(i) && inv_icons[i]) 
+		{
+			count++;
+		}
+	}
+
+
+	if (!count)
+	{
+		cgi_SP_GetStringTextString("SP_INGAME_EMPTY_INV",text, sizeof(text) );
+		int w = cgi_R_Font_StrLenPixels( text, cgs.media.qhFontSmall, 1.0f );	
+		int x = ( SCREEN_WIDTH - w ) / 2;
+		CG_DrawProportionalString(x, 300 + 22, text, CG_CENTER | CG_SMALLFONT, colorTable[CT_ICON_BLUE]);
+		return;
+	}
+
+	const int sideMax = 3;	// Max number of icons on the side
+
+	// Calculate how many icons will appear to either side of the center one
+	holdCount = count - 1;	// -1 for the center icon
+	if (holdCount == 0)			// No icons to either side
+	{
+		sideLeftIconCnt = 0;
+		sideRightIconCnt = 0;
+	}
+	else if (count > (2*sideMax))	// Go to the max on each side
+	{
+		sideLeftIconCnt = sideMax;
+		sideRightIconCnt = sideMax;
+	}
+	else							// Less than max, so do the calc
+	{
+		sideLeftIconCnt = holdCount/2;
+		sideRightIconCnt = holdCount - sideLeftIconCnt;
+	}
+
+	i = cg.DataPadInventorySelect - 1;
+	if (i<0)
+	{
+		i = INV_MAX-1;
+	}
+
+
+	const int smallIconSize = 40;
+	const int bigIconSize = 80;
+	const int bigPad = 64;
+	const int pad = 32;
+
+	const int centerXPos = 320;
+	const int graphicYPos = 340;
+
+
+	// Left side ICONS
+	// Work backwards from current icon
+	holdX = centerXPos - ((bigIconSize/2) + bigPad + smallIconSize);
+	height = smallIconSize * cg.iconHUDPercent;
+	addX = (float) smallIconSize * .75;
+
+	for (iconCnt=0;iconCnt<sideLeftIconCnt;i--)
+	{
+		if (i<0)
+		{
+			i = INV_MAX-1;
+		}
+
+		if ((!CG_InventorySelectable(i)) || (!inv_icons[i]))
+		{
+			continue;
+		}
+
+		++iconCnt;					// Good icon
+
+		if (inv_icons[i])
+		{
+			cgi_R_SetColor(colorTable[CT_WHITE]);
+			CG_DrawPic( holdX, graphicYPos+10, smallIconSize, smallIconSize, inv_icons[i] );
+
+			cgi_R_SetColor(colorTable[CT_ICON_BLUE]);
+			CG_DrawNumField (holdX + addX, graphicYPos + smallIconSize, 2, cg.snap->ps.inventory[i], 6, 12, 
+				NUM_FONT_SMALL,qfalse);
+
+			holdX -= (smallIconSize+pad);
+		}
+	}
+
+	// Current Center Icon
+	height = bigIconSize * cg.iconHUDPercent;
+	if (inv_icons[cg.DataPadInventorySelect])
+	{
+		cgi_R_SetColor(colorTable[CT_WHITE]);
+		CG_DrawPic( centerXPos-(bigIconSize/2), (graphicYPos-((bigIconSize-smallIconSize)/2))+10, bigIconSize, bigIconSize, inv_icons[cg.DataPadInventorySelect] );
+		addX = (float) bigIconSize * .75;
+		cgi_R_SetColor(colorTable[CT_ICON_BLUE]);
+		CG_DrawNumField ((centerXPos-(bigIconSize/2)) + addX, graphicYPos, 2, cg.snap->ps.inventory[cg.DataPadInventorySelect], 6, 12, 
+			NUM_FONT_SMALL,qfalse);
+
+	}
+
+	i = cg.DataPadInventorySelect + 1;
+	if (i> INV_MAX-1)
+	{
+		i = 0;
+	}
+
+	// Right side ICONS
+	// Work forwards from current icon
+	holdX = centerXPos + (bigIconSize/2) + bigPad;
+	height = smallIconSize * cg.iconHUDPercent;
+	addX = (float) smallIconSize * .75;
+	for (iconCnt=0;iconCnt<sideRightIconCnt;i++)
+	{
+		if (i> INV_MAX-1)
+		{
+			i = 0;
+		}
+
+		if ((!CG_InventorySelectable(i)) || (!inv_icons[i]))
+		{
+			continue;
+		}
+
+		++iconCnt;					// Good icon
+
+		if (inv_icons[i])
+		{
+			cgi_R_SetColor(colorTable[CT_WHITE]);
+			CG_DrawPic( holdX, graphicYPos+10, smallIconSize, smallIconSize, inv_icons[i] );
+
+			cgi_R_SetColor(colorTable[CT_ICON_BLUE]);
+			CG_DrawNumField (holdX + addX, graphicYPos + smallIconSize, 2, cg.snap->ps.inventory[i], 6, 12, 
+				NUM_FONT_SMALL,qfalse);
+
+			holdX += (smallIconSize+pad);
+		}
+	}
+
+	// draw the weapon description
+	if ((cg.DataPadInventorySelect>=0) && (cg.DataPadInventorySelect<13))
+	{
+		cgi_SP_GetStringTextString( va("SP_INGAME_%s",inventoryDesc[cg.DataPadInventorySelect]), text, sizeof(text) );
+
+		if (text)
+		{
+			CG_DisplayBoxedText(70,50,500,300,text,
+											cgs.media.qhFontSmall,
+											0.7f,
+											textColor	
+											);
+		}
+	}
+}
+
+/*
+===============
+SetForcePowerTime
+===============
+*/
+void SetForcePowerTime(void)
+{
+	if (((cg.weaponSelectTime + WEAPON_SELECT_TIME) > cg.time) ||	// The Weapon HUD was currently active to just swap it out with Force HUD
+		((cg.inventorySelectTime + WEAPON_SELECT_TIME) > cg.time))	// The Inventory HUD was currently active to just swap it out with Force HUD
+	{
+		cg.weaponSelectTime = 0;
+		cg.inventorySelectTime = 0;
+		cg.forcepowerSelectTime = cg.time + 130.0f;
+	}
+	else
+	{
+		cg.forcepowerSelectTime = cg.time;
+	}
+}
+
+int showPowers[MAX_SHOWPOWERS] = 
+{
+	FP_ABSORB,
+	FP_HEAL,
+	FP_PROTECT,
+	FP_TELEPATHY,
+
+	FP_SPEED,
+	FP_PUSH,
+	FP_PULL,
+	FP_SEE,
+
+	FP_DRAIN,
+	FP_LIGHTNING,
+	FP_RAGE,
+	FP_GRIP,
+};
+
+char *showPowersName[MAX_SHOWPOWERS] = 
+{
+	"SP_INGAME_ABSORB2",
+	"SP_INGAME_HEAL2",
+	"SP_INGAME_PROTECT2",
+	"SP_INGAME_MINDTRICK2",
+
+	"SP_INGAME_SPEED2",
+	"SP_INGAME_PUSH2",
+	"SP_INGAME_PULL2",
+	"SP_INGAME_SEEING2",
+
+	"SP_INGAME_DRAIN2",
+	"SP_INGAME_LIGHTNING2",
+	"SP_INGAME_DARK_RAGE2",
+	"SP_INGAME_GRIP2",
+};
+
+// Keep these with groups light side, core, and dark side
+int showDataPadPowers[MAX_DPSHOWPOWERS] = 
+{
+	// Light side
+	FP_ABSORB,
+	FP_HEAL,
+	FP_PROTECT,
+	FP_TELEPATHY,
+
+	// Core Powers
+	FP_LEVITATION,
+	FP_SPEED,
+	FP_PUSH,
+	FP_PULL,
+	FP_SABERTHROW,
+	FP_SABER_DEFENSE,
+	FP_SABER_OFFENSE,
+	FP_SEE,
+
+	//Dark Side
+	FP_DRAIN,
+	FP_LIGHTNING,
+	FP_RAGE,
+	FP_GRIP,
+};
+
+/*
+===============
+ForcePower_Valid
+===============
+*/
+qboolean ForcePower_Valid(int index)
+{
+	gentity_t	*player = &g_entities[0];
+
+	assert (MAX_SHOWPOWERS == ( sizeof(showPowers)/sizeof(showPowers[0]) ));
+	assert (index < MAX_SHOWPOWERS );	//is this a valid index?
+	if (player->client->ps.forcePowersKnown & (1 << showPowers[index]) && 
+		player->client->ps.forcePowerLevel[showPowers[index]])	// Does he have the force power?
+	{
+		return qtrue;
+	}
+
+	return qfalse;
+}
+
+/*
+===============
+CG_NextForcePower_f
+===============
+*/
+void CG_NextForcePower_f( void ) 
+{
+	int		i;
+
+	if ( !cg.snap || in_camera ) 
+	{
+		return;
+	}
+
+	SetForcePowerTime();
+
+	if ((cg.forcepowerSelectTime + WEAPON_SELECT_TIME) < cg.time)
+	{
+		return;
+	}
+
+	const int original = cg.forcepowerSelect;
+
+	for ( i = 0; i < MAX_SHOWPOWERS; i++ ) 
+	{
+		cg.forcepowerSelect++;
+
+		if (cg.forcepowerSelect >= MAX_SHOWPOWERS)
+		{ 
+			cg.forcepowerSelect = 0; 
+		}
+
+		if (ForcePower_Valid(cg.forcepowerSelect))	// Does he have the force power?
+		{
+			cgi_S_StartSound (NULL, 0, CHAN_AUTO, cgs.media.selectSound2 );
+			return;
+		}
+	}
+
+	cg.forcepowerSelect = original;
+}
+
+/*
+===============
+CG_PrevForcePower_f
+===============
+*/
+void CG_PrevForcePower_f( void ) 
+{
+	int		i;
+
+	if ( !cg.snap || in_camera ) 
+	{
+		return;
+	}
+
+	SetForcePowerTime();
+
+	if ((cg.forcepowerSelectTime + WEAPON_SELECT_TIME) < cg.time)
+	{
+		return;
+	}
+
+	const int original = cg.forcepowerSelect;
+
+	for ( i = 0; i < MAX_SHOWPOWERS; i++ ) 
+	{
+		cg.forcepowerSelect--;
+
+		if (cg.forcepowerSelect < 0)
+		{ 
+			cg.forcepowerSelect = MAX_SHOWPOWERS - 1; 
+		}
+
+		if (ForcePower_Valid(cg.forcepowerSelect))	// Does he have the force power?
+		{
+			cgi_S_StartSound (NULL, 0, CHAN_AUTO, cgs.media.selectSound2 );
+			return;
+		}
+	}
+
+
+	cg.forcepowerSelect = original;
+}
+
+/*
+===================
+CG_DrawForceSelect
+===================
+*/
+void CG_DrawForceSelect( void ) 
+{
+	int		i;
+	int		count;
+	int		holdX;
+	int		sideLeftIconCnt,sideRightIconCnt;
+	int		holdCount,iconCnt;
+	char	text[1024]={0};
+	int		yOffset = 0;
+
+
+	// don't display if dead
+	if ( cg.predicted_player_state.stats[STAT_HEALTH] <= 0 || ( cg.snap->ps.viewEntity > 0 && cg.snap->ps.viewEntity < ENTITYNUM_WORLD )) 
+	{
+		return;
+	}
+
+	if ((cg.forcepowerSelectTime+WEAPON_SELECT_TIME)<cg.time)	// Time is up for the HUD to display
+	{
+		return;
+	}
+
+#ifdef _XBOX
+	if(CL_ExtendSelectTime()) {
+		cg.forcepowerSelectTime = cg.time;
+	}
+
+	yOffset = -36;
+#endif
+
+	// count the number of powers owned
+	count = 0;
+
+	for (i=0; i<MAX_SHOWPOWERS; ++i)
+	{
+		if (ForcePower_Valid(i))
+		{
+			count++;
+		}
+	}
+
+	if (count == 0)	// If no force powers, don't display
+	{
+		return;
+	}
+
+/*
+	int x2,y2;
+	if (!cgi_UI_GetMenuInfo("forceselecthud",&x2,&y2,&w2,&h2))
+	{
+		return;
+	}
+*/
+	cg.iconSelectTime = cg.forcepowerSelectTime;
+
+	// showing weapon select clears pickup item display, but not the blend blob
+	cg.itemPickupTime = 0;
+
+	const int sideMax = 3;	// Max number of icons on the side
+
+	// Calculate how many icons will appear to either side of the center one
+	holdCount = count - 1;	// -1 for the center icon
+	if (holdCount == 0)			// No icons to either side
+	{
+		sideLeftIconCnt = 0;
+		sideRightIconCnt = 0;
+	}
+	else if (count > (2*sideMax))	// Go to the max on each side
+	{
+		sideLeftIconCnt = sideMax;
+		sideRightIconCnt = sideMax;
+	}
+	else							// Less than max, so do the calc
+	{
+		sideLeftIconCnt = holdCount/2;
+		sideRightIconCnt = holdCount - sideLeftIconCnt;
+	}
+
+	const int smallIconSize = 30;
+	const int bigIconSize = 60;
+	const int pad = 12;
+
+	const int x = 320;
+	const int y = 425;
+
+	i = cg.forcepowerSelect - 1;
+	if (i < 0)
+	{
+		i = MAX_SHOWPOWERS-1;
+	}
+
+	cgi_R_SetColor(NULL);
+	// Work backwards from current icon
+	holdX = x - ((bigIconSize/2) + pad + smallIconSize);
+	for (iconCnt=1;iconCnt<(sideLeftIconCnt+1);i--)
+	{
+		if (i < 0)
+		{
+			i = MAX_SHOWPOWERS-1;
+		}
+
+		if (!ForcePower_Valid(i))	// Does he have this power?
+		{
+			continue;
+		}
+
+		++iconCnt;					// Good icon
+
+		if (force_icons[showPowers[i]])
+		{
+			CG_DrawPic( holdX, y + yOffset, smallIconSize, smallIconSize, force_icons[showPowers[i]] ); 
+			holdX -= (smallIconSize+pad);
+		}
+	}
+
+	// Current Center Icon
+	if (force_icons[showPowers[cg.forcepowerSelect]])
+	{
+		CG_DrawPic( x-(bigIconSize/2), (y-((bigIconSize-smallIconSize)/2)) + yOffset, bigIconSize, bigIconSize, force_icons[showPowers[cg.forcepowerSelect]] );
+	}
+
+
+	i = cg.forcepowerSelect + 1;
+	if (i>=MAX_SHOWPOWERS)
+	{
+		i = 0;
+	}
+
+	// Work forwards from current icon
+	holdX = x + (bigIconSize/2) + pad;
+	for (iconCnt=1;iconCnt<(sideRightIconCnt+1);i++)
+	{
+		if (i>=MAX_SHOWPOWERS)
+		{
+			i = 0;
+		}
+
+		if (!ForcePower_Valid(i))	// Does he have this power?
+		{
+			continue;
+		}
+
+		++iconCnt;					// Good icon
+
+		if (force_icons[showPowers[i]])
+		{
+			CG_DrawPic( holdX, y + yOffset, smallIconSize, smallIconSize, force_icons[showPowers[i]] );
+			holdX += (smallIconSize+pad);
+		}
+	}
+
+	// This only a temp solution.
+	if (cgi_SP_GetStringTextString( showPowersName[cg.forcepowerSelect], text, sizeof(text) ))
+	{
+			int w = cgi_R_Font_StrLenPixels(text, cgs.media.qhFontSmall, 1.0f);	
+			int x = ( SCREEN_WIDTH - w ) / 2;
+			cgi_R_Font_DrawString(x, (SCREEN_HEIGHT - 24) + yOffset, text, colorTable[CT_ICON_BLUE], cgs.media.qhFontSmall, -1, 1.0f);
+	}
+}
+
+/*
+===============
+ForcePowerDataPad_Valid
+===============
+*/
+qboolean ForcePowerDataPad_Valid(int index)
+{
+	gentity_t	*player = &g_entities[0];
+
+	assert (index < MAX_DPSHOWPOWERS);
+	if (player->client->ps.forcePowersKnown & (1 << showDataPadPowers[index]) && 
+		player->client->ps.forcePowerLevel[showDataPadPowers[index]])	// Does he have the force power?
+	{
+		return qtrue;
+	}
+
+	return qfalse;
+}
+
+/*
+===============
+CG_DPNextForcePower_f
+===============
+*/
+void CG_DPNextForcePower_f( void ) 
+{
+	int		i;
+	int		original;
+
+	if ( !cg.snap ) 
+	{
+		return;
+	}
+
+	original = cg.DataPadforcepowerSelect;
+
+	for ( i = 0; i<MAX_DPSHOWPOWERS; i++ ) 
+	{
+		cg.DataPadforcepowerSelect++;
+
+		if (cg.DataPadforcepowerSelect >= MAX_DPSHOWPOWERS)
+		{ 
+			cg.DataPadforcepowerSelect = 0; 
+		}
+
+		if (ForcePowerDataPad_Valid(cg.DataPadforcepowerSelect))	// Does he have the force power?
+		{
+			return;
+		}
+	}
+
+	cg.DataPadforcepowerSelect = original;
+}
+
+/*
+===============
+CG_DPPrevForcePower_f
+===============
+*/
+void CG_DPPrevForcePower_f( void ) 
+{
+	int		i;
+	int		original;
+
+	if ( !cg.snap ) 
+	{
+		return;
+	}
+
+	original = cg.DataPadforcepowerSelect;
+
+	for ( i = 0; i<MAX_DPSHOWPOWERS; i++ ) 
+	{
+		cg.DataPadforcepowerSelect--;
+
+		if (cg.DataPadforcepowerSelect < 0)
+		{ 
+			cg.DataPadforcepowerSelect = MAX_DPSHOWPOWERS-1; 
+		}
+
+		if (ForcePowerDataPad_Valid(cg.DataPadforcepowerSelect))	// Does he have the force power?
+		{
+			return;
+		}
+	}
+
+
+	cg.DataPadforcepowerSelect = original;
+}
+
+char *forcepowerDesc[NUM_FORCE_POWERS] = 
+{
+"FORCE_ABSORB_DESC",
+"FORCE_HEAL_DESC",
+"FORCE_PROTECT_DESC",
+"FORCE_MIND_TRICK_DESC",
+
+"FORCE_JUMP_DESC",
+"FORCE_SPEED_DESC",
+"FORCE_PUSH_DESC",
+"FORCE_PULL_DESC",
+"FORCE_SABER_THROW_DESC",
+"FORCE_SABER_DEFENSE_DESC",
+"FORCE_SABER_OFFENSE_DESC",
+"FORCE_SENSE_DESC",
+
+"FORCE_DRAIN_DESC",
+"FORCE_LIGHTNING_DESC",
+"FORCE_RAGE_DESC",
+"FORCE_GRIP_DESC",
+};
+
+
+char *forcepowerLvl1Desc[NUM_FORCE_POWERS] = 
+{
+"FORCE_ABSORB_LVL1_DESC",
+"FORCE_HEAL_LVL1_DESC",
+"FORCE_PROTECT_LVL1_DESC",
+"FORCE_MIND_TRICK_LVL1_DESC",
+
+"FORCE_JUMP_LVL1_DESC",
+"FORCE_SPEED_LVL1_DESC",
+"FORCE_PUSH_LVL1_DESC",
+"FORCE_PULL_LVL1_DESC",
+"FORCE_SABER_THROW_LVL1_DESC",
+"FORCE_SABER_DEFENSE_LVL1_DESC",
+"FORCE_SABER_OFFENSE_LVL1_DESC",
+"FORCE_SENSE_LVL1_DESC",
+
+"FORCE_DRAIN_LVL1_DESC",
+"FORCE_LIGHTNING_LVL1_DESC",
+"FORCE_RAGE_LVL1_DESC",
+"FORCE_GRIP_LVL1_DESC",
+};
+
+char *forcepowerLvl2Desc[NUM_FORCE_POWERS] = 
+{
+"FORCE_ABSORB_LVL2_DESC",
+"FORCE_HEAL_LVL2_DESC",
+"FORCE_PROTECT_LVL2_DESC",
+"FORCE_MIND_TRICK_LVL2_DESC",
+
+"FORCE_JUMP_LVL2_DESC",
+"FORCE_SPEED_LVL2_DESC",
+"FORCE_PUSH_LVL2_DESC",
+"FORCE_PULL_LVL2_DESC",
+"FORCE_SABER_THROW_LVL2_DESC",
+"FORCE_SABER_DEFENSE_LVL2_DESC",
+"FORCE_SABER_OFFENSE_LVL2_DESC",
+"FORCE_SENSE_LVL2_DESC",
+
+"FORCE_DRAIN_LVL2_DESC",
+"FORCE_LIGHTNING_LVL2_DESC",
+"FORCE_RAGE_LVL2_DESC",
+"FORCE_GRIP_LVL2_DESC",
+};
+
+char *forcepowerLvl3Desc[NUM_FORCE_POWERS] = 
+{
+"FORCE_ABSORB_LVL3_DESC",
+"FORCE_HEAL_LVL3_DESC",
+"FORCE_PROTECT_LVL3_DESC",
+"FORCE_MIND_TRICK_LVL3_DESC",
+
+"FORCE_JUMP_LVL3_DESC",
+"FORCE_SPEED_LVL3_DESC",
+"FORCE_PUSH_LVL3_DESC",
+"FORCE_PULL_LVL3_DESC",
+"FORCE_SABER_THROW_LVL3_DESC",
+"FORCE_SABER_DEFENSE_LVL3_DESC",
+"FORCE_SABER_OFFENSE_LVL3_DESC",
+"FORCE_SENSE_LVL3_DESC",
+
+"FORCE_DRAIN_LVL3_DESC",
+"FORCE_LIGHTNING_LVL3_DESC",
+"FORCE_RAGE_LVL3_DESC",
+"FORCE_GRIP_LVL3_DESC",
+};
+
+/*
+===================
+CG_DrawDataPadForceSelect
+===================
+*/
+void CG_DrawDataPadForceSelect( void ) 
+{
+	int		i;
+	int		count;
+	int		holdX;
+	int		sideLeftIconCnt,sideRightIconCnt;
+	int		holdCount,iconCnt;
+	char	text[1024]={0};
+	char	text2[1024]={0};
+
+	// count the number of powers known
+	count = 0;
+	for (i=0;i<MAX_DPSHOWPOWERS;i++)
+	{
+		if (ForcePowerDataPad_Valid(i))
+		{
+			count++;
+		}
+	}
+
+	if (count < 1)	// If no force powers, don't display
+	{
+		return;
+	}
+
+
+	// Time to switch new icon colors
+	// Faded side icon color
+//	memcpy(fadeColor, colorTable[CT_WHITE], sizeof(vec4_t));
+
+	cg.iconSelectTime = cg.forcepowerSelectTime;
+
+	const int sideMax = 3;	// Max number of icons on the side
+
+	// Calculate how many icons will appear to either side of the center one
+	holdCount = count - 1;	// -1 for the center icon
+	if (holdCount == 0)			// No icons to either side
+	{
+		sideLeftIconCnt = 0;
+		sideRightIconCnt = 0;
+	}
+	else if (count > (2*sideMax))	// Go to the max on each side
+	{
+		sideLeftIconCnt = sideMax;
+		sideRightIconCnt = sideMax;
+	}
+	else							// Less than max, so do the calc
+	{
+		sideLeftIconCnt = holdCount/2;
+		sideRightIconCnt = holdCount - sideLeftIconCnt;
+	}
+
+
+	const int smallIconSize = 40;
+	const int bigIconSize = 70;
+	const int bigPad = 64;
+	const int pad = 32;
+
+	const int centerXPos = 320;
+	const int graphicYPos = 340;
+
+	i = cg.DataPadforcepowerSelect - 1;
+	if (i < 0)
+	{
+		i = MAX_DPSHOWPOWERS-1;
+	}
+
+	// Print icons to the left of the center 
+
+	cgi_R_SetColor(colorTable[CT_WHITE]);
+	// Work backwards from current icon
+	holdX = centerXPos - ((bigIconSize/2) + bigPad + smallIconSize);
+	for (iconCnt=1;iconCnt<(sideLeftIconCnt+1);i--)
+	{
+		if (i < 0)
+		{
+			i = MAX_DPSHOWPOWERS-1;
+		}
+
+		if (!ForcePowerDataPad_Valid(i))	// Does he have this power?
+		{
+			continue;
+		}
+
+		++iconCnt;					// Good icon
+
+		if (force_icons[showDataPadPowers[i]])
+		{
+			CG_DrawPic( holdX, graphicYPos, smallIconSize, smallIconSize, force_icons[showDataPadPowers[i]] ); 
+		}
+
+		// A new force power
+		if (((cg_updatedDataPadForcePower1.integer - 1) == showDataPadPowers[i]) ||
+			((cg_updatedDataPadForcePower2.integer - 1) == showDataPadPowers[i]) ||
+			((cg_updatedDataPadForcePower3.integer - 1) == showDataPadPowers[i]))
+		{
+			CG_DrawPic( holdX, graphicYPos, smallIconSize, smallIconSize, cgs.media.DPForcePowerOverlay ); 
+		}
+
+		if (force_icons[showDataPadPowers[i]])
+		{
+			holdX -= (smallIconSize+pad);
+		}
+	}
+
+	// Current Center Icon
+	if (force_icons[showDataPadPowers[cg.DataPadforcepowerSelect]])
+	{
+
+		cgi_R_SetColor(colorTable[CT_WHITE]);
+		CG_DrawPic( centerXPos-(bigIconSize/2), (graphicYPos-((bigIconSize-smallIconSize)/2)), bigIconSize, bigIconSize, force_icons[showDataPadPowers[cg.DataPadforcepowerSelect]] );
+
+		// New force power
+		if (((cg_updatedDataPadForcePower1.integer - 1) == showDataPadPowers[cg.DataPadforcepowerSelect]) ||
+			((cg_updatedDataPadForcePower2.integer - 1) == showDataPadPowers[cg.DataPadforcepowerSelect]) ||
+			((cg_updatedDataPadForcePower3.integer - 1) == showDataPadPowers[cg.DataPadforcepowerSelect]))
+		{			
+			CG_DrawPic( centerXPos-(bigIconSize/2), (graphicYPos-((bigIconSize-smallIconSize)/2)), bigIconSize, bigIconSize, cgs.media.DPForcePowerOverlay ); 
+		}
+	}
+
+
+	i = cg.DataPadforcepowerSelect + 1;
+	if (i>=MAX_DPSHOWPOWERS)
+	{
+		i = 0;
+	}
+
+	cgi_R_SetColor(colorTable[CT_WHITE]);
+
+	// Work forwards from current icon
+	holdX = centerXPos + (bigIconSize/2) + bigPad;
+	for (iconCnt=1;iconCnt<(sideRightIconCnt+1);i++)
+	{
+		if (i>=MAX_DPSHOWPOWERS)
+		{
+			i = 0;
+		}
+
+		if (!ForcePowerDataPad_Valid(i))	// Does he have this power?
+		{
+			continue;
+		}
+
+		++iconCnt;					// Good icon
+
+		if (force_icons[showDataPadPowers[i]])
+		{
+			CG_DrawPic( holdX, graphicYPos, smallIconSize, smallIconSize, force_icons[showDataPadPowers[i]] );
+		}
+
+		// A new force power
+		if (((cg_updatedDataPadForcePower1.integer - 1) == showDataPadPowers[i]) ||
+			((cg_updatedDataPadForcePower2.integer - 1) == showDataPadPowers[i]) ||
+			((cg_updatedDataPadForcePower3.integer - 1) == showDataPadPowers[i]))
+		{
+			CG_DrawPic( holdX, graphicYPos, smallIconSize, smallIconSize, cgs.media.DPForcePowerOverlay );
+		}
+
+		if (force_icons[showDataPadPowers[i]])
+		{
+			holdX += (smallIconSize+pad);
+		}
+	}
+
+	cgi_SP_GetStringTextString( va("SP_INGAME_%s",forcepowerDesc[cg.DataPadforcepowerSelect]), text, sizeof(text) );
+
+	if (player->client->ps.forcePowerLevel[showDataPadPowers[cg.DataPadforcepowerSelect]]==1)
+	{
+		cgi_SP_GetStringTextString( va("SP_INGAME_%s",forcepowerLvl1Desc[cg.DataPadforcepowerSelect]), text2, sizeof(text2) );
+	}
+	else if (player->client->ps.forcePowerLevel[showDataPadPowers[cg.DataPadforcepowerSelect]]==2)
+	{
+		cgi_SP_GetStringTextString( va("SP_INGAME_%s",forcepowerLvl2Desc[cg.DataPadforcepowerSelect]), text2, sizeof(text2) );
+	}
+	else 
+	{
+		cgi_SP_GetStringTextString( va("SP_INGAME_%s",forcepowerLvl3Desc[cg.DataPadforcepowerSelect]), text2, sizeof(text2) );
+	}
+
+	const short textboxXPos = 40;
+	const short textboxYPos = 60;
+	const int	textboxWidth = 560;
+	const int	textboxHeight = 300;
+	const float	textScale = 1.0f;
+
+	if (text)
+	{
+
+		CG_DisplayBoxedText(textboxXPos,textboxYPos,textboxWidth,textboxHeight,va("%s%s",text,text2),
+													4,
+													textScale,
+													colorTable[CT_WHITE]	
+													);
+	}
+}
+
+// actually, these are pretty pointless so far in CHC, since in TA codebase they were used only so init some HUD
+//	function ptrs to allow cinematics in onscreen displays. So far, we don't use those, but here they are anyway...
+//
+/*	These stupid pragmas don't work, they still give the warning. Forget it, REM the lot.
+
+#pragma warning ( disable : 4505)		// unreferenced local function has been removed
+static int CG_PlayCinematic(const char *name, float x, float y, float w, float h) {
+  return trap_CIN_PlayCinematic(name, x, y, w, h, CIN_loop);
+}
+
+static void CG_StopCinematic(int handle) {
+  trap_CIN_StopCinematic(handle);
+}
+
+static void CG_DrawCinematic(int handle, float x, float y, float w, float h) {
+  trap_CIN_SetExtents(handle, x, y, w, h);
+  trap_CIN_DrawCinematic(handle);
+}
+
+static void CG_RunCinematicFrame(int handle) {
+  trap_CIN_RunCinematic(handle);
+}
+#pragma warning ( default : 4505)
+*/
+
+
+
+
diff --git a/code/cgame/cg_marks.cpp b/code/cgame/cg_marks.cpp
new file mode 100644
index 0000000..437847c
--- /dev/null
+++ b/code/cgame/cg_marks.cpp
@@ -0,0 +1,264 @@
+// cg_marks.c -- wall marks
+
+// this line must stay at top so the whole PCH thing works...
+#include "cg_headers.h"
+
+
+//#include "cg_local.h"
+#include "cg_media.h"
+
+/*
+===================================================================
+
+MARK POLYS
+
+===================================================================
+*/
+
+
+markPoly_t	cg_activeMarkPolys;			// double linked list
+markPoly_t	*cg_freeMarkPolys;			// single linked list
+markPoly_t	cg_markPolys[MAX_MARK_POLYS];
+
+/*
+===================
+CG_InitMarkPolys
+
+This is called at startup and for tournement restarts
+===================
+*/
+void	CG_InitMarkPolys( void ) {
+	int		i;
+
+	memset( cg_markPolys, 0, sizeof(cg_markPolys) );
+
+	cg_activeMarkPolys.nextMark = &cg_activeMarkPolys;
+	cg_activeMarkPolys.prevMark = &cg_activeMarkPolys;
+	cg_freeMarkPolys = cg_markPolys;
+	for ( i = 0 ; i < MAX_MARK_POLYS - 1 ; i++ ) {
+		cg_markPolys[i].nextMark = &cg_markPolys[i+1];
+	}
+}
+
+
+/*
+==================
+CG_FreeMarkPoly
+==================
+*/
+void CG_FreeMarkPoly( markPoly_t *le ) {
+	if ( !le->prevMark ) {
+		CG_Error( "CG_FreeLocalEntity: not active" );
+	}
+
+	// remove from the doubly linked active list
+	le->prevMark->nextMark = le->nextMark;
+	le->nextMark->prevMark = le->prevMark;
+
+	// the free list is only singly linked
+	le->nextMark = cg_freeMarkPolys;
+	cg_freeMarkPolys = le;
+}
+
+/*
+===================
+CG_AllocMark
+
+Will allways succeed, even if it requires freeing an old active mark
+===================
+*/
+markPoly_t	*CG_AllocMark( void ) {
+	markPoly_t	*le;
+	int time;
+
+	if ( !cg_freeMarkPolys ) {
+		// no free entities, so free the one at the end of the chain
+		// remove the oldest active entity
+		time = cg_activeMarkPolys.prevMark->time;
+		while (cg_activeMarkPolys.prevMark && time == cg_activeMarkPolys.prevMark->time) {
+			CG_FreeMarkPoly( cg_activeMarkPolys.prevMark );
+		}
+	}
+
+	le = cg_freeMarkPolys;
+	cg_freeMarkPolys = cg_freeMarkPolys->nextMark;
+
+	memset( le, 0, sizeof( *le ) );
+
+	// link into the active list
+	le->nextMark = cg_activeMarkPolys.nextMark;
+	le->prevMark = &cg_activeMarkPolys;
+	cg_activeMarkPolys.nextMark->prevMark = le;
+	cg_activeMarkPolys.nextMark = le;
+	return le;
+}
+
+
+
+/*
+=================
+CG_ImpactMark
+
+origin should be a point within a unit of the plane
+dir should be the plane normal
+
+temporary marks will not be stored or randomly oriented, but immediately
+passed to the renderer.
+=================
+*/
+#define	MAX_MARK_FRAGMENTS	128
+#define	MAX_MARK_POINTS		384
+
+void CG_ImpactMark( qhandle_t markShader, const vec3_t origin, const vec3_t dir, 
+				   float orientation, float red, float green, float blue, float alpha,
+				   qboolean alphaFade, float radius, qboolean temporary ) {
+	vec3_t			axis[3];
+	float			texCoordScale;
+	vec3_t			originalPoints[4];
+	byte			colors[4];
+	int				i, j;
+	int				numFragments;
+	markFragment_t	markFragments[MAX_MARK_FRAGMENTS], *mf;
+	vec3_t			markPoints[MAX_MARK_POINTS];
+	vec3_t			projection;
+
+	if ( !cg_addMarks.integer ) {
+		return;
+	}
+
+	if ( radius <= 0 ) {
+		CG_Error( "CG_ImpactMark called with <= 0 radius" );
+	}
+
+	// create the texture axis
+	VectorNormalize2( dir, axis[0] );
+	PerpendicularVector( axis[1], axis[0] );
+	RotatePointAroundVector( axis[2], axis[0], axis[1], orientation );
+	CrossProduct( axis[0], axis[2], axis[1] );
+
+	texCoordScale = 0.5 * 1.0 / radius;
+
+	// create the full polygon
+	for ( i = 0 ; i < 3 ; i++ ) {
+		originalPoints[0][i] = origin[i] - radius * axis[1][i] - radius * axis[2][i];
+		originalPoints[1][i] = origin[i] + radius * axis[1][i] - radius * axis[2][i];
+		originalPoints[2][i] = origin[i] + radius * axis[1][i] + radius * axis[2][i];
+		originalPoints[3][i] = origin[i] - radius * axis[1][i] + radius * axis[2][i];
+	}
+
+	// get the fragments
+	VectorScale( dir, -20, projection );
+	numFragments = cgi_CM_MarkFragments( 4, (const float (*)[3])originalPoints,
+					projection, MAX_MARK_POINTS, markPoints[0],
+					MAX_MARK_FRAGMENTS, markFragments );
+
+	colors[0] = red * 255;
+	colors[1] = green * 255;
+	colors[2] = blue * 255;
+	colors[3] = alpha * 255;
+
+	for ( i = 0, mf = markFragments ; i < numFragments ; i++, mf++ ) {
+		polyVert_t	*v;
+		polyVert_t	verts[MAX_VERTS_ON_POLY];
+		markPoly_t	*mark;
+
+		// we have an upper limit on the complexity of polygons
+		// that we store persistantly
+		if ( mf->numPoints > MAX_VERTS_ON_POLY ) {
+			mf->numPoints = MAX_VERTS_ON_POLY;
+		}
+		for ( j = 0, v = verts ; j < mf->numPoints ; j++, v++ ) {
+			vec3_t		delta;
+
+			VectorCopy( markPoints[mf->firstPoint + j], v->xyz );
+
+			VectorSubtract( v->xyz, origin, delta );
+			v->st[0] = 0.5 + DotProduct( delta, axis[1] ) * texCoordScale;
+			v->st[1] = 0.5 + DotProduct( delta, axis[2] ) * texCoordScale;
+			*(int *)v->modulate = *(int *)colors;
+		}
+
+		// if it is a temporary (shadow) mark, add it immediately and forget about it
+		if ( temporary ) {
+			cgi_R_AddPolyToScene( markShader, mf->numPoints, verts );
+			continue;
+		}
+
+		// otherwise save it persistantly
+		mark = CG_AllocMark();
+		mark->time = cg.time;
+		mark->alphaFade = alphaFade;
+		mark->markShader = markShader;
+		mark->poly.numVerts = mf->numPoints;
+		mark->color[0] = colors[0];//red;
+		mark->color[1] = colors[1];//green;
+		mark->color[2] = colors[2];//blue;
+		mark->color[3] = colors[3];//alpha;
+		memcpy( mark->verts, verts, mf->numPoints * sizeof( verts[0] ) );
+	}
+}
+
+
+/*
+===============
+CG_AddMarks
+===============
+*/
+#define	MARK_TOTAL_TIME		10000
+#define	MARK_FADE_TIME		1000
+
+void CG_AddMarks( void ) {
+	int			j;
+	markPoly_t	*mp, *next;
+	int			t;
+	int			fade;
+
+	if ( !cg_addMarks.integer ) {
+		return;
+	}
+
+	mp = cg_activeMarkPolys.nextMark;
+	for ( ; mp != &cg_activeMarkPolys ; mp = next ) {
+		// grab next now, so if the local entity is freed we
+		// still have it
+		next = mp->nextMark;
+
+		// see if it is time to completely remove it
+		if ( cg.time > mp->time + MARK_TOTAL_TIME ) {
+			CG_FreeMarkPoly( mp );
+			continue;
+		}
+
+		// fade all marks out with time
+		t = mp->time + MARK_TOTAL_TIME - cg.time;
+		if ( t < MARK_FADE_TIME ) {
+			fade = 255 * t / MARK_FADE_TIME;
+			if ( mp->alphaFade ) {
+				for ( j = 0 ; j < mp->poly.numVerts ; j++ ) {
+					mp->verts[j].modulate[3] = fade;
+				}
+			}
+			else 
+			{
+				float f = (float)t / MARK_FADE_TIME;
+				for ( j = 0 ; j < mp->poly.numVerts ; j++ ) {
+					mp->verts[j].modulate[0] = mp->color[0] * f;
+					mp->verts[j].modulate[1] = mp->color[1] * f;
+					mp->verts[j].modulate[2] = mp->color[2] * f;
+				}
+			}
+		}
+		else
+		{
+			for ( j = 0 ; j < mp->poly.numVerts ; j++ ) {
+				mp->verts[j].modulate[0] = mp->color[0];
+				mp->verts[j].modulate[1] = mp->color[1];
+				mp->verts[j].modulate[2] = mp->color[2];
+			}
+		}
+
+
+		cgi_R_AddPolyToScene( mp->markShader, mp->poly.numVerts, mp->verts );
+	}
+}
+
diff --git a/code/cgame/cg_media.h b/code/cgame/cg_media.h
new file mode 100644
index 0000000..dc40de6
--- /dev/null
+++ b/code/cgame/cg_media.h
@@ -0,0 +1,413 @@
+#ifndef __CG_MEDIA_H_
+#define __CG_MEDIA_H_
+
+#define	NUM_CROSSHAIRS		9
+
+typedef enum {
+	FOOTSTEP_STONEWALK,
+	FOOTSTEP_STONERUN,
+	FOOTSTEP_METALWALK,
+	FOOTSTEP_METALRUN,
+	FOOTSTEP_PIPEWALK,
+	FOOTSTEP_PIPERUN,
+	FOOTSTEP_SPLASH,
+	FOOTSTEP_WADE,
+	FOOTSTEP_SWIM,
+	FOOTSTEP_SNOWWALK,
+	FOOTSTEP_SNOWRUN,
+	FOOTSTEP_SANDWALK,
+	FOOTSTEP_SANDRUN,
+	FOOTSTEP_GRASSWALK,
+	FOOTSTEP_GRASSRUN,
+	FOOTSTEP_DIRTWALK,
+	FOOTSTEP_DIRTRUN,
+	FOOTSTEP_MUDWALK,
+	FOOTSTEP_MUDRUN,
+	FOOTSTEP_GRAVELWALK,
+	FOOTSTEP_GRAVELRUN,
+	FOOTSTEP_RUGWALK,
+	FOOTSTEP_RUGRUN,
+	FOOTSTEP_WOODWALK,
+	FOOTSTEP_WOODRUN,
+
+	FOOTSTEP_TOTAL
+} footstep_t;
+
+#define ICON_WEAPONS	0
+#define ICON_FORCE		1
+#define ICON_INVENTORY	2
+
+#define MAX_HUD_TICS	4
+
+
+typedef struct HUDMenuItem_s
+{
+	char			*menuName;
+	char			*itemName;
+	int				xPos;
+	int				yPos;
+	int				width;
+	int				height;
+	vec4_t			color;
+	qhandle_t		background;
+} HUDMenuItem_t;
+extern HUDMenuItem_t healthTics[];
+extern HUDMenuItem_t armorTics[];
+extern HUDMenuItem_t ammoTics[];
+extern HUDMenuItem_t forceTics[];
+extern HUDMenuItem_t otherHUDBits[];
+
+
+typedef enum 
+{
+	OHB_HEALTHAMOUNT = 0,
+	OHB_ARMORAMOUNT,
+	OHB_FORCEAMOUNT,
+	OHB_AMMOAMOUNT,
+	OHB_SABERSTYLE_STRONG,
+	OHB_SABERSTYLE_MEDIUM,
+	OHB_SABERSTYLE_FAST,
+	OHB_SCANLINE_LEFT,
+	OHB_SCANLINE_RIGHT,
+	OHB_FRAME_LEFT,
+	OHB_FRAME_RIGHT,
+	OHB_MAX
+} otherhudbits_t;
+
+#define NUM_CHUNK_MODELS	4
+
+typedef enum 
+{
+	CHUNK_METAL1 = 0,
+	CHUNK_METAL2,
+	CHUNK_ROCK1,
+	CHUNK_ROCK2,
+	CHUNK_ROCK3,
+	CHUNK_CRATE1,
+	CHUNK_CRATE2,
+	CHUNK_WHITE_METAL,
+	NUM_CHUNK_TYPES
+};
+
+// all of the model, shader, and sound references that are
+// loaded at gamestate time are stored in cgMedia_t
+// Other media that can be tied to clients, weapons, or items are
+// stored in the clientInfo_t, itemInfo_t, weaponInfo_t, and powerupInfo_t
+typedef struct {
+	qhandle_t	charsetShader;
+	qhandle_t	whiteShader;
+
+	qhandle_t	crosshairShader[NUM_CROSSHAIRS];
+	qhandle_t	backTileShader;
+//	qhandle_t	noammoShader;
+
+	qhandle_t	numberShaders[11];
+	qhandle_t	smallnumberShaders[11];
+	qhandle_t	chunkyNumberShaders[11];
+
+	qhandle_t	loadTick;
+	qhandle_t	loadTickCap;
+
+	//			HUD artwork
+	int			currentBackground;
+	qhandle_t	weaponbox;
+	qhandle_t	weaponIconBackground;
+	qhandle_t	forceIconBackground;
+	qhandle_t	inventoryIconBackground;
+	qhandle_t	turretComputerOverlayShader;
+	qhandle_t	turretCrossHairShader;
+
+//Chunks
+	qhandle_t	chunkModels[NUM_CHUNK_TYPES][4];
+	sfxHandle_t	chunkSound;
+	sfxHandle_t	grateSound;
+	sfxHandle_t	rockBreakSound;
+	sfxHandle_t	rockBounceSound[2];
+	sfxHandle_t	metalBounceSound[2];
+	sfxHandle_t	glassChunkSound;
+	sfxHandle_t	crateBreakSound[2];
+
+	// Saber shaders
+	//-----------------------------
+	qhandle_t	forceCoronaShader;
+	qhandle_t	saberBlurShader;
+	qhandle_t	swordTrailShader;
+	qhandle_t	yellowDroppedSaberShader; // glow
+
+	qhandle_t	redSaberGlowShader;
+	qhandle_t	redSaberCoreShader;
+	qhandle_t	orangeSaberGlowShader;
+	qhandle_t	orangeSaberCoreShader;
+	qhandle_t	yellowSaberGlowShader;
+	qhandle_t	yellowSaberCoreShader;
+	qhandle_t	greenSaberGlowShader;
+	qhandle_t	greenSaberCoreShader;
+	qhandle_t	blueSaberGlowShader;
+	qhandle_t	blueSaberCoreShader;
+	qhandle_t	purpleSaberGlowShader;
+	qhandle_t	purpleSaberCoreShader;
+
+	qhandle_t	explosionModel;
+	qhandle_t	surfaceExplosionShader;
+
+	qhandle_t	halfShieldModel;
+
+	qhandle_t	solidWhiteShader;
+	qhandle_t	electricBodyShader;
+	qhandle_t	electricBody2Shader;
+	qhandle_t	refractShader;
+	qhandle_t	boltShader;
+
+	// Disruptor zoom graphics
+	qhandle_t	disruptorMask;
+	qhandle_t	disruptorInsert;
+	qhandle_t	disruptorLight;
+	qhandle_t	disruptorInsertTick;
+
+	// Binocular graphics
+	qhandle_t	binocularCircle;
+	qhandle_t	binocularMask;
+	qhandle_t	binocularArrow;
+	qhandle_t	binocularTri;
+	qhandle_t	binocularStatic;
+	qhandle_t	binocularOverlay;
+
+	// LA Goggles graphics
+	qhandle_t	laGogglesStatic;
+	qhandle_t	laGogglesMask;
+	qhandle_t	laGogglesSideBit;
+	qhandle_t	laGogglesBracket;
+	qhandle_t	laGogglesArrow;
+
+	// wall mark shaders
+	qhandle_t	scavMarkShader;
+	qhandle_t	rivetMarkShader;
+
+	qhandle_t	shadowMarkShader;
+	qhandle_t	wakeMarkShader;
+	qhandle_t	fsrMarkShader;
+	qhandle_t	fslMarkShader;
+	qhandle_t	fshrMarkShader;
+	qhandle_t	fshlMarkShader;
+
+	qhandle_t	damageBlendBlobShader;
+
+	// fonts...
+	//
+	qhandle_t	qhFontSmall;
+	qhandle_t	qhFontMedium;
+
+	// special effects models / etc.
+	qhandle_t	personalShieldShader;
+	qhandle_t	cloakedShader;
+
+	// Interface media
+	qhandle_t	ammoslider;
+	qhandle_t	emplacedHealthBarShader;
+
+	qhandle_t	dataPadFrame;
+	qhandle_t	DPForcePowerOverlay;
+
+	qhandle_t	bdecal_burnmark1;
+	qhandle_t	bdecal_saberglowmark;
+
+	qhandle_t	messageLitOn;
+	qhandle_t	messageLitOff;
+	qhandle_t	messageObjCircle;
+
+	qhandle_t	batteryChargeShader;
+	qhandle_t	useableHint;
+
+	qhandle_t	levelLoad;
+
+	//new stuff for Jedi Academy
+	//force power icons
+//	qhandle_t	forcePowerIcons[NUM_FORCE_POWERS];
+	qhandle_t	rageRecShader;
+	qhandle_t	playerShieldDamage;
+	qhandle_t	forceSightBubble;
+	qhandle_t	forceShell;
+	qhandle_t	sightShell;
+	qhandle_t	drainShader;
+
+	// sounds
+	sfxHandle_t disintegrateSound;
+	sfxHandle_t disintegrate2Sound;
+	sfxHandle_t disintegrate3Sound;
+
+	sfxHandle_t	grenadeBounce1;
+	sfxHandle_t	grenadeBounce2;
+
+	sfxHandle_t	flechetteStickSound;
+	sfxHandle_t	detPackStickSound;
+	sfxHandle_t	tripMineStickSound;
+	
+	sfxHandle_t	selectSound;
+	sfxHandle_t	selectSound2;
+	sfxHandle_t	overchargeSlowSound;
+	sfxHandle_t overchargeFastSound;
+	sfxHandle_t	overchargeLoopSound;
+	sfxHandle_t	overchargeEndSound;
+
+//	sfxHandle_t	useNothingSound;
+	sfxHandle_t	footsteps[FOOTSTEP_TOTAL][4];
+
+//	sfxHandle_t talkSound;
+	sfxHandle_t	noAmmoSound;
+	
+	sfxHandle_t landSound;
+	sfxHandle_t rollSound;
+	sfxHandle_t messageLitSound;
+
+	sfxHandle_t	batteryChargeSound;
+
+	sfxHandle_t watrInSound;
+	sfxHandle_t watrOutSound;
+	sfxHandle_t watrUnSound;
+
+	sfxHandle_t lavaInSound;
+	sfxHandle_t lavaOutSound;
+	sfxHandle_t lavaUnSound;
+
+	sfxHandle_t noforceSound;
+
+	// Zoom
+	sfxHandle_t	zoomStart;
+	sfxHandle_t	zoomLoop;
+	sfxHandle_t	zoomEnd;
+	sfxHandle_t	disruptorZoomLoop;
+	
+	//new stuff for Jedi Academy
+	sfxHandle_t	drainSound;
+
+#ifdef _IMMERSION
+	//force feedback stuff
+	ffHandle_t grenadeBounce1Force;
+	ffHandle_t grenadeBounce2Force;
+
+	ffHandle_t selectForce;
+
+	ffHandle_t footstepForces[FOOTSTEP_TOTAL][4];
+
+	ffHandle_t noAmmoForce;
+
+	ffHandle_t landForce;
+	ffHandle_t messageLitForce;
+
+	ffHandle_t watrInForce;
+	ffHandle_t watrOutForce;
+	ffHandle_t watrUnForce;
+
+	ffHandle_t zoomStartForce;
+	ffHandle_t zoomLoopForce;
+	ffHandle_t zoomEndForce;
+	ffHandle_t disruptorZoomLoopForce;
+#endif // _IMMERSION
+} cgMedia_t;
+
+
+// Stored FX handles
+//--------------------
+typedef struct
+{
+	// BRYAR PISTOL
+	fxHandle_t	bryarShotEffect;
+	fxHandle_t	bryarPowerupShotEffect;
+	fxHandle_t	bryarWallImpactEffect;
+	fxHandle_t	bryarWallImpactEffect2;
+	fxHandle_t	bryarWallImpactEffect3;
+	fxHandle_t	bryarFleshImpactEffect;
+
+	// BLASTER
+	fxHandle_t	blasterShotEffect;
+	fxHandle_t	blasterOverchargeEffect;
+	fxHandle_t	blasterWallImpactEffect;
+	fxHandle_t	blasterFleshImpactEffect;
+
+	// BOWCASTER
+	fxHandle_t	bowcasterShotEffect;
+	fxHandle_t	bowcasterBounceEffect;
+	fxHandle_t	bowcasterImpactEffect;
+
+	// FLECHETTE
+	fxHandle_t	flechetteShotEffect;
+	fxHandle_t	flechetteAltShotEffect;
+	fxHandle_t	flechetteShotDeathEffect;
+	fxHandle_t	flechetteFleshImpactEffect;
+	fxHandle_t	flechetteRicochetEffect;
+
+	//FORCE
+	fxHandle_t	forceConfusion;
+	fxHandle_t	forceLightning;
+	fxHandle_t	forceLightningWide;
+	//fxHandle_t	forceInvincibility;
+	fxHandle_t	forceHeal;
+
+	//new stuff for Jedi Academy
+	fxHandle_t forceDrain;
+	fxHandle_t forceDrainWide;
+	fxHandle_t forceDrained;
+
+	//footstep effects
+	fxHandle_t footstepMud;
+	fxHandle_t footstepSand;
+	fxHandle_t footstepSnow;
+	fxHandle_t footstepGravel;
+	//landing effects
+	fxHandle_t landingMud;
+	fxHandle_t landingSand;
+	fxHandle_t landingDirt;
+	fxHandle_t landingSnow;
+	fxHandle_t landingGravel;
+} cgEffects_t;
+
+
+// The client game static (cgs) structure hold everything
+// loaded or calculated from the gamestate.  It will NOT
+// be cleared when a tournement restart is done, allowing
+// all clients to begin playing instantly
+#define STRIPED_LEVELNAME_VARIATIONS 3	// sigh, to cope with levels that use text from >1 SP file (plus 1 for common)
+typedef struct {
+	gameState_t		gameState;			// gamestate from server
+	glconfig_t		glconfig;			// rendering configuration
+
+	int				serverCommandSequence;	// reliable command stream counter
+	
+	// parsed from serverinfo
+	int				dmflags;
+	int				teamflags;
+	int				timelimit;
+	int				maxclients;
+	char			mapname[MAX_QPATH];
+	char			stripLevelName[STRIPED_LEVELNAME_VARIATIONS][MAX_QPATH];
+
+	//
+	// locally derived information from gamestate
+	//
+	qhandle_t		model_draw[MAX_MODELS];
+	sfxHandle_t		sound_precache[MAX_SOUNDS];
+#ifdef _IMMERSION
+	ffHandle_t		force_precache[MAX_FORCES];
+#endif // _IMMERSION
+// Ghoul2 start
+	qhandle_t		skins[MAX_CHARSKINS];
+
+// Ghoul2 end
+
+	int				numInlineModels;
+	qhandle_t		inlineDrawModel[MAX_SUBMODELS];
+	vec3_t			inlineModelMidpoints[MAX_SUBMODELS];
+
+	clientInfo_t	clientinfo[MAX_CLIENTS];
+
+	// media
+	cgMedia_t		media;
+
+	// effects
+	cgEffects_t		effects;
+
+} cgs_t;
+
+extern	cgs_t			cgs;
+
+#endif //__CG_MEDIA_H_
\ No newline at end of file
diff --git a/code/cgame/cg_players.cpp b/code/cgame/cg_players.cpp
new file mode 100644
index 0000000..3187121
--- /dev/null
+++ b/code/cgame/cg_players.cpp
@@ -0,0 +1,8259 @@
+
+// this line must stay at top so the whole PCH thing works...
+#include "cg_headers.h"
+
+#define	CG_PLAYERS_CPP
+//#include "cg_local.h"
+#include "cg_media.h"
+#include "FxScheduler.h"
+#include "..\game\ghoul2_shared.h"
+#include "..\game\anims.h"
+#include "..\game\wp_saber.h"
+#include "..\game\g_vehicles.h"
+#include "..\Rufl\hstring.h"
+
+#define	LOOK_SWING_SCALE	0.5f
+#define	CG_SWINGSPEED		0.3f
+
+#include "animtable.h"
+
+extern vmCvar_t	cg_debugHealthBars;
+/*
+
+player entities generate a great deal of information from implicit ques
+taken from the entityState_t
+
+*/
+
+//rww - generic function for applying a shader to the skin.
+extern vmCvar_t	cg_g2Marks;
+void CG_AddGhoul2Mark(int type, float size, vec3_t hitloc, vec3_t hitdirection, 
+				int entnum, vec3_t entposition, float entangle, CGhoul2Info_v &ghoul2, vec3_t modelScale, int lifeTime, vec3_t uaxis )
+{
+	if ( !cg_g2Marks.integer )
+	{//don't want these
+		return;
+	}
+
+	static SSkinGoreData goreSkin;
+
+	memset ( &goreSkin, 0, sizeof(goreSkin) );
+
+	goreSkin.growDuration = -1; // do not grow
+	goreSkin.goreScaleStartFraction = 1.0; // default start scale
+	goreSkin.frontFaces = true; // yes front
+	goreSkin.backFaces = false; // no back
+	goreSkin.lifeTime = lifeTime;
+	if (lifeTime > 0)
+	{
+		goreSkin.fadeOutTime = lifeTime*0.1; //use whatever you want here -rww
+	}
+	goreSkin.fadeRGB = true; //fade on RGB and alpha instead of just alpha (not needed for all shaders, but whatever)
+	
+	goreSkin.currentTime = cg.time;
+	goreSkin.entNum      = entnum;
+	goreSkin.SSize		 = size;
+	goreSkin.TSize		 = size;
+	goreSkin.shader		 = type;
+	goreSkin.theta		 = flrand(0.0f,6.28f);
+
+	if (uaxis)
+	{
+		goreSkin.backFaces = true;
+		goreSkin.SSize		 = 6;
+		goreSkin.TSize		 = 3;
+		goreSkin.depthStart = -10;	//arbitrary depths, just limiting marks to near hit loc
+		goreSkin.depthEnd	= 15;
+		goreSkin.useTheta = false;
+		VectorCopy(uaxis, goreSkin.uaxis);
+		if(	VectorNormalize(goreSkin.uaxis) < 0.001f )
+		{//too short to make a mark
+			return;
+		}
+	}
+	else
+	{
+		goreSkin.depthStart = -1000;
+		goreSkin.depthEnd	= 1000;
+		goreSkin.useTheta = true;
+	}
+	VectorCopy(modelScale, goreSkin.scale);
+
+	VectorCopy ( hitdirection, goreSkin.rayDirection);
+
+	VectorCopy ( hitloc, goreSkin.hitLocation );
+	VectorCopy ( entposition, goreSkin.position );
+	goreSkin.angles[YAW] = entangle;
+
+	gi.G2API_AddSkinGore(ghoul2,goreSkin);
+}
+
+qboolean CG_RegisterClientModelname( clientInfo_t *ci, const char *headModelName, const char *headSkinName, 
+									const char *torsoModelName, const char *torsoSkinName, 
+									const char *legsModelName, const char *legsSkinName );
+
+static void CG_PlayerFootsteps( centity_t *const cent, footstepType_t footStepType );
+static void CG_PlayerAnimEvents( int animFileIndex, qboolean torso, int oldFrame, int frame, int entNum );
+extern void BG_G2SetBoneAngles( centity_t *cent, gentity_t *gent, int boneIndex, const vec3_t angles, const int flags,
+							 const Eorientations up, const Eorientations left, const Eorientations forward, qhandle_t *modelList );
+extern void FX_BorgDeathSparkParticles( vec3_t origin, vec3_t angles, vec3_t vel, vec3_t user );
+extern qboolean PM_SaberInSpecialAttack( int anim );
+extern qboolean PM_SaberInAttack( int move );
+extern qboolean PM_SaberInTransitionAny( int move );
+extern int PM_GetTurnAnim( gentity_t *gent, int anim );
+extern int PM_AnimLength( int index, animNumber_t anim );
+extern qboolean PM_InRoll( playerState_t *ps );
+extern Vehicle_t *G_IsRidingVehicle( gentity_t *ent );
+extern qboolean PM_SuperBreakWinAnim( int anim );
+
+//Basic set of custom sounds that everyone needs
+// (keep numbers in ascending order in order for variant-capping to work)
+const char	*cg_customBasicSoundNames[MAX_CUSTOM_BASIC_SOUNDS] = 
+{
+	"*death1.wav",
+	"*death2.wav",
+	"*death3.wav",
+	"*jump1.wav",
+	"*pain25.wav",
+	"*pain50.wav",
+	"*pain75.wav",
+	"*pain100.wav",
+	"*gurp1.wav",
+	"*gurp2.wav",
+	"*drown.wav",
+	"*gasp.wav",
+	"*land1.wav",
+	"*falling1.wav",
+};
+
+//Used as a supplement to the basic set for enemies and hazard team
+// (keep numbers in ascending order in order for variant-capping to work)
+const char	*cg_customCombatSoundNames[MAX_CUSTOM_COMBAT_SOUNDS] = 
+{
+	"*anger1.wav",	//Say when acquire an enemy when didn't have one before
+	"*anger2.wav",
+	"*anger3.wav",
+	"*victory1.wav",	//Say when killed an enemy
+	"*victory2.wav",
+	"*victory3.wav",
+	"*confuse1.wav",	//Say when confused
+	"*confuse2.wav",
+	"*confuse3.wav",
+	"*pushed1.wav",	//Say when force-pushed
+	"*pushed2.wav",
+	"*pushed3.wav",
+	"*choke1.wav",
+	"*choke2.wav",
+	"*choke3.wav",
+	"*ffwarn.wav",
+	"*ffturn.wav",
+};
+
+//Used as a supplement to the basic set for stormtroopers
+// (keep numbers in ascending order in order for variant-capping to work)
+const char	*cg_customExtraSoundNames[MAX_CUSTOM_EXTRA_SOUNDS] = 
+{
+	"*chase1.wav",
+	"*chase2.wav",
+	"*chase3.wav",
+	"*cover1.wav",
+	"*cover2.wav",
+	"*cover3.wav",
+	"*cover4.wav",
+	"*cover5.wav",
+	"*detected1.wav",
+	"*detected2.wav",
+	"*detected3.wav",
+	"*detected4.wav",
+	"*detected5.wav",
+	"*lost1.wav",
+	"*outflank1.wav",
+	"*outflank2.wav",
+	"*escaping1.wav",
+	"*escaping2.wav",
+	"*escaping3.wav",
+	"*giveup1.wav",
+	"*giveup2.wav",
+	"*giveup3.wav",
+	"*giveup4.wav",
+	"*look1.wav",
+	"*look2.wav",
+	"*sight1.wav",
+	"*sight2.wav",
+	"*sight3.wav",
+	"*sound1.wav",
+	"*sound2.wav",
+	"*sound3.wav",
+	"*suspicious1.wav",
+	"*suspicious2.wav",
+	"*suspicious3.wav",
+	"*suspicious4.wav",
+	"*suspicious5.wav",
+};
+
+//Used as a supplement to the basic set for jedi
+// (keep numbers in ascending order in order for variant-capping to work)
+const char	*cg_customJediSoundNames[MAX_CUSTOM_JEDI_SOUNDS] = 
+{
+	"*combat1.wav",
+	"*combat2.wav",
+	"*combat3.wav",
+	"*jdetected1.wav",
+	"*jdetected2.wav",
+	"*jdetected3.wav",
+	"*taunt1.wav",
+	"*taunt2.wav",
+	"*taunt3.wav",
+	"*jchase1.wav",
+	"*jchase2.wav",
+	"*jchase3.wav",
+	"*jlost1.wav",
+	"*jlost2.wav",
+	"*jlost3.wav",
+	"*deflect1.wav",
+	"*deflect2.wav",
+	"*deflect3.wav",
+	"*gloat1.wav",
+	"*gloat2.wav",
+	"*gloat3.wav",
+	"*pushfail.wav",
+};
+
+
+// done at registration time only...
+//
+// cuts down on sound-variant registration for low end machines, 
+//		eg *gloat1.wav (plus...2,...3) can be capped to all be just *gloat1.wav
+//
+static const char *GetCustomSound_VariantCapped(const char *ppsTable[], int iEntryNum, qboolean bForceVariant1)
+{
+	extern vmCvar_t	cg_VariantSoundCap;
+		
+//	const int iVariantCap = 2;	// test
+	const int &iVariantCap = cg_VariantSoundCap.integer;
+
+	if (iVariantCap || bForceVariant1)
+	{
+		char *p = strchr(ppsTable[iEntryNum],'.');
+		if (p && p-2 > ppsTable[iEntryNum] && isdigit(p[-1]) && !isdigit(p[-2]))
+		{
+			int iThisVariant = p[-1]-'0';
+
+			if (iThisVariant > iVariantCap || bForceVariant1)
+			{
+				// ok, let's not load this variant, so pick a random one below the cap value...
+				//
+				for (int i=0; i<2; i++)	// 1st pass, choose random, 2nd pass (if random not in list), choose xxx1, else fall through...
+				{
+					char sName[MAX_QPATH];
+
+					Q_strncpyz(sName, ppsTable[iEntryNum], sizeof(sName));
+					p = strchr(sName,'.');
+					if (p)
+					{
+						*p = '\0';
+						sName[strlen(sName)-1] = '\0';	// strip the digit
+
+						int iRandom = bForceVariant1 ? 1 : (!i ? Q_irand(1,iVariantCap) : 1);
+
+						strcat(sName,va("%d",iRandom));
+
+						// does this exist in the entries before the original one?...
+						//
+						for (int iScanNum=0; iScanNum<iEntryNum; iScanNum++)
+						{
+							if (!stricmp(ppsTable[iScanNum], sName))
+							{
+								// yeah, this entry is also present in the table, so ok to return it
+								//
+								return ppsTable[iScanNum];
+							}
+						}
+					}
+				}
+
+				// didn't find an entry corresponding to either the random name, or the xxxx1 version, 
+				//	so give up and drop through to return the original...
+				//
+			}
+		}
+	}
+
+	return ppsTable[iEntryNum];
+}
+
+extern	cvar_t	*g_sex;
+extern	cvar_t	*com_buildScript;
+static void CG_RegisterCustomSounds(clientInfo_t *ci, int iSoundEntryBase,
+									int iTableEntries, const char *ppsTable[], const char *psDir
+									)
+{ 
+	for ( int i=0 ; i<iTableEntries; i++ ) 
+	{
+		char	s[MAX_QPATH]={0};
+		const char *pS = GetCustomSound_VariantCapped(ppsTable,i, qfalse);
+		if ( !s ) 
+		{
+			break;	// fairly pointless code in original, since there are no NULL's in the table, but wtf...
+		}
+		COM_StripExtension( pS, s );
+
+		sfxHandle_t hSFX = 0;
+		if ( g_sex->string[0] == 'f' )
+		{
+			hSFX = cgi_S_RegisterSound( va("sound/chars/%s/misc/%s_f.wav", psDir, s + 1) );
+		}
+		if (hSFX == 0 || com_buildScript->integer)
+		{
+			hSFX = cgi_S_RegisterSound( va("sound/chars/%s/misc/%s.wav", psDir, s + 1) );
+		}
+		if (hSFX == 0)
+		{
+			// hmmm... variant in table was missing, so forcibly-retry with %1 version (which we may have just tried, but wtf?)...
+			//
+			pS = GetCustomSound_VariantCapped(ppsTable,i, qtrue);
+			COM_StripExtension( pS, s );
+			if ( g_sex->string[0] == 'f' )
+			{
+				hSFX = cgi_S_RegisterSound( va("sound/chars/%s/misc/%s_f.wav", psDir, s + 1) );
+			}
+			if (hSFX == 0 || com_buildScript->integer)
+			{
+				hSFX = cgi_S_RegisterSound( va("sound/chars/%s/misc/%s.wav", psDir, s + 1) );
+			}
+			//
+			// and fall through regardless...
+			//
+		}
+		
+		ci->sounds[i + iSoundEntryBase] = hSFX;
+	}
+}
+
+
+
+/*
+================
+CG_CustomSound
+
+  NOTE: when you call this, check the value.  If zero, do not try to play the sound.
+		Either that or when a sound that doesn't exist is played, don't play the null 
+		sound honk and don't display the error message
+
+================
+*/
+static sfxHandle_t	CG_CustomSound( int entityNum, const char *soundName, int customSoundSet ) 
+{
+	clientInfo_t *ci;
+	int			i;
+
+	if ( soundName[0] != '*' ) 
+	{
+		return cgi_S_RegisterSound( soundName );
+	}
+
+	if ( !g_entities[entityNum].client )
+	{
+		// No client, this should never happen, so just don't
+#ifndef FINAL_BUILD
+//		CG_Printf( "custom sound not on client: %s", soundName );
+#endif
+		return 0;
+	}
+	else
+	{
+		ci = &g_entities[entityNum].client->clientInfo;
+	}
+
+	//FIXME: if the sound you want to play could not be found, pick another from the same
+	//general grouping?  ie: if you want ff_2c and there is none, try ff_2b or ff_2a...
+	switch ( customSoundSet )
+	{
+	case CS_BASIC:
+		// There should always be a clientInfo structure if there is a client, but just make sure...
+		if ( ci )
+		{
+			for ( i = 0 ; i < MAX_CUSTOM_BASIC_SOUNDS && cg_customBasicSoundNames[i] ; i++ ) 
+			{
+				if ( !Q_stricmp( soundName, cg_customBasicSoundNames[i] ) ) 
+				{
+					return ci->sounds[i];
+				}
+			}
+		}
+		break;
+	case CS_COMBAT:
+		// There should always be a clientInfo structure if there is a client, but just make sure...
+		if ( ci )
+		{
+			for ( i = 0 ; i < MAX_CUSTOM_COMBAT_SOUNDS && cg_customCombatSoundNames[i] ; i++ ) 
+			{
+				if ( !Q_stricmp( soundName, cg_customCombatSoundNames[i] ) ) 
+				{
+					return ci->sounds[i+MAX_CUSTOM_BASIC_SOUNDS];
+				}
+			}
+		}
+		break;
+	case CS_EXTRA:
+		// There should always be a clientInfo structure if there is a client, but just make sure...
+		if ( ci )
+		{
+			for ( i = 0 ; i < MAX_CUSTOM_EXTRA_SOUNDS && cg_customExtraSoundNames[i] ; i++ ) 
+			{
+				if ( !Q_stricmp( soundName, cg_customExtraSoundNames[i] ) ) 
+				{
+					return ci->sounds[i+MAX_CUSTOM_BASIC_SOUNDS+MAX_CUSTOM_COMBAT_SOUNDS];
+				}
+			}
+		}
+		break;
+	case CS_JEDI:
+		// There should always be a clientInfo structure if there is a client, but just make sure...
+		if ( ci )
+		{
+			for ( i = 0 ; i < MAX_CUSTOM_JEDI_SOUNDS && cg_customJediSoundNames[i] ; i++ ) 
+			{
+				if ( !Q_stricmp( soundName, cg_customJediSoundNames[i] ) ) 
+				{
+					return ci->sounds[i+MAX_CUSTOM_BASIC_SOUNDS+MAX_CUSTOM_COMBAT_SOUNDS+MAX_CUSTOM_EXTRA_SOUNDS];
+				}
+			}
+		}
+		break;
+	case CS_TRY_ALL:
+	default:
+		//no set specified, search all
+		if ( ci )
+		{
+			for ( i = 0 ; i < MAX_CUSTOM_BASIC_SOUNDS && cg_customBasicSoundNames[i] ; i++ ) 
+			{
+				if ( !Q_stricmp( soundName, cg_customBasicSoundNames[i] ) ) 
+				{
+					return ci->sounds[i];
+				}
+			}
+			for ( i = 0 ; i < MAX_CUSTOM_COMBAT_SOUNDS && cg_customCombatSoundNames[i] ; i++ ) 
+			{
+				if ( !Q_stricmp( soundName, cg_customCombatSoundNames[i] ) ) 
+				{
+					return ci->sounds[i+MAX_CUSTOM_BASIC_SOUNDS];
+				}
+			}
+			for ( i = 0 ; i < MAX_CUSTOM_EXTRA_SOUNDS && cg_customExtraSoundNames[i] ; i++ ) 
+			{
+				if ( !Q_stricmp( soundName, cg_customExtraSoundNames[i] ) ) 
+				{
+					return ci->sounds[i+MAX_CUSTOM_BASIC_SOUNDS+MAX_CUSTOM_COMBAT_SOUNDS];
+				}
+			}
+			for ( i = 0 ; i < MAX_CUSTOM_JEDI_SOUNDS && cg_customJediSoundNames[i] ; i++ ) 
+			{
+				if ( !Q_stricmp( soundName, cg_customJediSoundNames[i] ) ) 
+				{
+					return ci->sounds[i+MAX_CUSTOM_BASIC_SOUNDS+MAX_CUSTOM_COMBAT_SOUNDS+MAX_CUSTOM_EXTRA_SOUNDS];
+				}
+			}
+		}
+		break;
+	}
+
+#ifdef FINAL_BUILD
+	CG_Printf( "Unknown custom sound: %s", soundName );
+#else
+	CG_Error( "Unknown custom sound: %s", soundName );
+#endif
+	return 0;
+}
+
+qboolean CG_TryPlayCustomSound( vec3_t origin, int entityNum, soundChannel_t channel, const char *soundName, int customSoundSet )
+{
+	sfxHandle_t	soundIndex = CG_CustomSound( entityNum, soundName, customSoundSet );
+	if ( !soundIndex )
+	{
+		return qfalse;
+	}
+
+	cgi_S_StartSound( origin, entityNum, channel, soundIndex );
+	return qtrue;
+}
+/*
+======================
+CG_NewClientinfo
+
+  For player only, NPCs get them through NPC_stats and G_ModelIndex
+======================
+*/
+void CG_NewClientinfo( int clientNum ) 
+{
+	clientInfo_t *ci;
+	const char	*configstring;
+	const char	*v;
+//	const char	*s;
+//	int			i;
+
+	configstring = CG_ConfigString( clientNum + CS_PLAYERS );
+
+	if ( !configstring[0] ) 
+	{
+		return;		// player just left
+	}
+	//ci = &cgs.clientinfo[clientNum];
+	if ( !(&g_entities[clientNum].client) )
+	{
+		return;
+	}
+	ci = &g_entities[clientNum].client->clientInfo;
+
+	// isolate the player's name
+	v = Info_ValueForKey(configstring, "n");
+	Q_strncpyz( ci->name, v, sizeof( ci->name ) );
+
+	// handicap
+	v = Info_ValueForKey( configstring, "hc" );
+	ci->handicap = atoi( v );
+
+	// team
+	v = Info_ValueForKey( configstring, "t" );
+	ci->team = (team_t) atoi( v );
+
+	// legsModel
+	v = Info_ValueForKey( configstring, "legsModel" );
+	
+	Q_strncpyz(			g_entities[clientNum].client->renderInfo.legsModelName, v,
+				sizeof(	g_entities[clientNum].client->renderInfo.legsModelName), qtrue);
+
+	// torsoModel
+	v = Info_ValueForKey( configstring, "torsoModel" );
+	
+	Q_strncpyz(			g_entities[clientNum].client->renderInfo.torsoModelName, v,
+				sizeof(	g_entities[clientNum].client->renderInfo.torsoModelName), qtrue);	
+	
+	// headModel
+	v = Info_ValueForKey( configstring, "headModel" );
+	
+	Q_strncpyz(			g_entities[clientNum].client->renderInfo.headModelName, v,
+				sizeof(	g_entities[clientNum].client->renderInfo.headModelName), qtrue);
+
+	// sounds
+	v = Info_ValueForKey( configstring, "snd" );
+	
+	ci->customBasicSoundDir = G_NewString( v );
+
+	//player uses only the basic custom and combat sound sets, not the extra or jedi
+	CG_RegisterCustomSounds(ci, 
+							0,							// int iSoundEntryBase,
+							MAX_CUSTOM_BASIC_SOUNDS,	// int iTableEntries,
+							cg_customBasicSoundNames,	// const char *ppsTable[], 
+							ci->customBasicSoundDir		// const char *psDir
+							);
+
+	CG_RegisterCustomSounds(ci, 
+							MAX_CUSTOM_BASIC_SOUNDS,	// int iSoundEntryBase,
+							MAX_CUSTOM_COMBAT_SOUNDS,	// int iTableEntries,
+							cg_customCombatSoundNames,	// const char *ppsTable[], 
+							ci->customBasicSoundDir		// const char *psDir
+							);
+	ci->infoValid = qfalse;
+}
+
+/*
+CG_RegisterNPCCustomSounds
+*/
+void CG_RegisterNPCCustomSounds( clientInfo_t *ci )
+{
+//	const char	*s;
+//	int			i;
+
+	// sounds
+
+	if ( ci->customBasicSoundDir && ci->customBasicSoundDir[0] )
+	{
+		CG_RegisterCustomSounds(ci, 
+								0,							// int iSoundEntryBase,
+								MAX_CUSTOM_BASIC_SOUNDS,	// int iTableEntries,
+								cg_customBasicSoundNames,	// const char *ppsTable[], 
+								ci->customBasicSoundDir		// const char *psDir
+								);
+	}
+
+	if ( ci->customCombatSoundDir && ci->customCombatSoundDir[0] )
+	{
+		CG_RegisterCustomSounds(ci, 
+								MAX_CUSTOM_BASIC_SOUNDS,	// int iSoundEntryBase,
+								MAX_CUSTOM_COMBAT_SOUNDS,	// int iTableEntries,
+								cg_customCombatSoundNames,	// const char *ppsTable[], 
+								ci->customCombatSoundDir	// const char *psDir
+								);
+	}
+
+	if ( ci->customExtraSoundDir && ci->customExtraSoundDir[0] )
+	{
+		CG_RegisterCustomSounds(ci, 
+								MAX_CUSTOM_BASIC_SOUNDS+MAX_CUSTOM_COMBAT_SOUNDS,	// int iSoundEntryBase,
+								MAX_CUSTOM_EXTRA_SOUNDS,	// int iTableEntries,
+								cg_customExtraSoundNames,	// const char *ppsTable[], 
+								ci->customExtraSoundDir		// const char *psDir
+								);
+	}
+
+	if ( ci->customJediSoundDir && ci->customJediSoundDir[0] )
+	{
+		CG_RegisterCustomSounds(ci, 
+								MAX_CUSTOM_BASIC_SOUNDS+MAX_CUSTOM_COMBAT_SOUNDS+MAX_CUSTOM_EXTRA_SOUNDS,							// int iSoundEntryBase,
+								MAX_CUSTOM_JEDI_SOUNDS,		// int iTableEntries,
+								cg_customJediSoundNames,	// const char *ppsTable[], 
+								ci->customJediSoundDir		// const char *psDir
+								);
+	}
+}
+
+//=============================================================================
+
+/*
+void CG_RegisterNPCEffects( team_t team )
+
+  This should register all the shaders, models and sounds used by a specific type
+  of NPC's spawn, death and other miscellaneous effects.  NOT WEAPON EFFECTS, as those
+  are taken care of in CG_RegisterWeapon
+*/
+/*
+void CG_RegisterNPCEffects( team_t team )
+{
+	switch( team )
+	{
+
+	case TEAM_ENEMY:
+		break;
+
+	case TEAM_NEUTRAL:
+		break;
+
+	case TEAM_PLAYER:
+		break;
+
+	default:
+		break;
+	}
+}
+*/
+/*
+=============================================================================
+
+PLAYER ANIMATION
+
+=============================================================================
+*/
+
+qboolean ValidAnimFileIndex ( int index )
+{
+	if ( index < 0 || index >= level.numKnownAnimFileSets )
+	{
+		Com_Printf( S_COLOR_RED "Bad animFileIndex: %d\n", index );
+		return qfalse;
+	}
+
+	return qtrue;
+}
+
+
+/*
+======================
+CG_ClearAnimEvtCache
+
+resets all the eventcache so that a vid restart will recache them
+======================
+*/
+void CG_ClearAnimEvtCache( void )
+{
+	int i;
+	for (i=0; i < level.numKnownAnimFileSets; i++) 
+	{
+		// TODO: Make this work again?
+	//	level.knownAnimFileSets[i].eventsParsed = qfalse;
+	}
+}
+
+/*
+===============
+CG_SetLerpFrameAnimation
+===============
+*/
+static void CG_SetLerpFrameAnimation( clientInfo_t *ci, lerpFrame_t *lf, int newAnimation ) 
+{
+	animation_t	*anim;
+
+	if ( newAnimation < 0 || newAnimation >= MAX_ANIMATIONS ) 
+	{
+#ifdef FINAL_BUILD
+		newAnimation = 0;
+#else
+		CG_Error( "Bad animation number: %i for ", newAnimation, ci->name );
+#endif
+	}
+
+	lf->animationNumber = newAnimation;
+
+	if ( !ValidAnimFileIndex( ci->animFileIndex ) )
+	{
+#ifdef FINAL_BUILD
+		ci->animFileIndex = 0;
+#else
+		CG_Error( "Bad animFileIndex: %i for %s", ci->animFileIndex, ci->name);
+#endif
+	}
+
+	anim = &level.knownAnimFileSets[ci->animFileIndex].animations[ newAnimation ];
+
+	lf->animation = anim;
+	lf->animationTime = lf->frameTime + abs(anim->frameLerp);
+}
+
+/*
+===============
+CG_RunLerpFrame
+
+Sets cg.snap, cg.oldFrame, and cg.backlerp
+cg.time should be between oldFrameTime and frameTime after exit
+===============
+*/
+static qboolean CG_RunLerpFrame( clientInfo_t *ci, lerpFrame_t *lf, int newAnimation, float fpsMod, int entNum ) {
+	int			f, animFrameTime;
+	animation_t	*anim;
+	qboolean	newFrame = qfalse;
+
+	if(fpsMod > 2 || fpsMod < 0.5)
+	{//should have been set right
+		fpsMod = 1.0f;
+	}
+
+	// see if the animation sequence is switching
+	//FIXME: allow multiple-frame overlapped lerping between sequences? - Possibly last 3 of last seq and first 3 of next seq?
+	if ( newAnimation != lf->animationNumber || !lf->animation ) 
+	{
+		CG_SetLerpFrameAnimation( ci, lf, newAnimation );
+	}
+
+	// if we have passed the current frame, move it to
+	// oldFrame and calculate a new frame
+	if ( cg.time >= lf->frameTime ) 
+	{
+		lf->oldFrame = lf->frame;
+		lf->oldFrameTime = lf->frameTime;
+
+		// get the next frame based on the animation
+		anim = lf->animation;
+		//Do we need to speed up or slow down the anim?
+		/*if(fpsMod != 1.0)
+		{//Note!  despite it's name, a higher fpsMod slows down the anim, a lower one speeds it up
+			animFrameTime = ceil(lf->frameTime * fpsMod);
+		}
+		else*/
+		{
+			animFrameTime = abs(anim->frameLerp);
+			
+			//special hack for player to ensure quick weapon change
+			if ( entNum == 0 )
+			{
+				if ( lf->animationNumber == TORSO_DROPWEAP1 || lf->animationNumber == TORSO_RAISEWEAP1 )
+				{
+					animFrameTime = 50;
+				}
+			}
+		}
+
+		if ( cg.time < lf->animationTime ) 
+		{
+			lf->frameTime = lf->animationTime;		// initial lerp
+		} 
+		else 
+		{
+			lf->frameTime = lf->oldFrameTime + animFrameTime;
+		}
+
+		f = ( lf->frameTime - lf->animationTime ) / animFrameTime;
+		if ( f >= anim->numFrames ) 
+		{//Reached the end of the anim
+			//FIXME: Need to set a flag here to TASK_COMPLETE
+			f -= anim->numFrames;
+			if ( anim->loopFrames != -1 ) //Before 0 meant no loop
+			{
+				if(anim->numFrames - anim->loopFrames == 0)
+				{
+					f %= anim->numFrames;
+				}
+				else
+				{
+					f %= (anim->numFrames - anim->loopFrames);
+				}
+				f += anim->loopFrames;
+			} 
+			else 
+			{
+				f = anim->numFrames - 1;
+				if (f<0)
+				{
+					f = 0;
+				}
+				// the animation is stuck at the end, so it
+				// can immediately transition to another sequence
+				lf->frameTime = cg.time;
+			}
+		}
+
+		if ( anim->frameLerp < 0 )
+		{
+			lf->frame = anim->firstFrame + anim->numFrames - 1 - f;
+		}
+		else
+		{
+			lf->frame = anim->firstFrame + f;
+		}
+
+		if ( cg.time > lf->frameTime ) 
+		{
+			lf->frameTime = cg.time;
+		}
+
+		newFrame = qtrue;
+	}
+
+	if ( lf->frameTime > cg.time + 200 ) 
+	{
+		lf->frameTime = cg.time;
+	}
+
+	if ( lf->oldFrameTime > cg.time ) 
+	{
+		lf->oldFrameTime = cg.time;
+	}
+	// calculate current lerp value
+	if ( lf->frameTime == lf->oldFrameTime ) 
+	{
+		lf->backlerp = 0;
+	} 
+	else 
+	{
+		lf->backlerp = 1.0 - (float)( cg.time - lf->oldFrameTime ) / ( lf->frameTime - lf->oldFrameTime );
+	}
+
+	return newFrame;
+}
+
+
+/*
+===============
+CG_ClearLerpFrame
+===============
+*/
+static void CG_ClearLerpFrame( clientInfo_t *ci, lerpFrame_t *lf, int animationNumber ) 
+{
+	lf->frameTime = lf->oldFrameTime = cg.time;
+	CG_SetLerpFrameAnimation( ci, lf, animationNumber );
+	if ( lf->animation->frameLerp < 0 )
+	{//Plays backwards
+		lf->oldFrame = lf->frame = (lf->animation->firstFrame + lf->animation->numFrames);
+	}
+	else
+	{
+		lf->oldFrame = lf->frame = lf->animation->firstFrame;
+	}
+}
+
+/*
+===============
+CG_PlayerAnimation
+===============
+*/
+static void CG_PlayerAnimation( centity_t *cent, int *legsOld, int *legs, float *legsBackLerp,
+						int *torsoOld, int *torso, float *torsoBackLerp ) {
+	clientInfo_t	*ci;
+	int				clientNum;
+	int				legsAnim;
+	int				legsTurnAnim = -1;
+	qboolean		newLegsFrame = qfalse;
+	qboolean		newTorsoFrame = qfalse;
+
+	clientNum = cent->currentState.clientNum;
+
+	ci = &cent->gent->client->clientInfo;
+	//Changed this from cent->currentState.legsAnim to cent->gent->client->ps.legsAnim because it was screwing up our timers when we've just changed anims while turning
+	legsAnim = cent->gent->client->ps.legsAnim;
+
+	// do the shuffle turn frames locally (MAN this is an Fugly-ass hack!)
+	
+	if ( cent->pe.legs.yawing )
+	{
+		legsTurnAnim = PM_GetTurnAnim( cent->gent, legsAnim );
+	}
+
+	if ( legsTurnAnim != -1 )
+	{
+		newLegsFrame = CG_RunLerpFrame( ci, &cent->pe.legs, legsTurnAnim, cent->gent->client->renderInfo.legsFpsMod, cent->gent->s.number );
+		//This line doesn't seem to serve any useful purpose, rather it
+		//breaks things since any task waiting for a lower anim to complete
+		//never will finish if this happens!!!
+		//cent->gent->client->ps.legsAnimTimer = 0;
+	} 
+	else 
+	{
+		newLegsFrame = CG_RunLerpFrame( ci, &cent->pe.legs, legsAnim, cent->gent->client->renderInfo.legsFpsMod, cent->gent->s.number);
+	}
+
+	*legsOld = cent->pe.legs.oldFrame;
+	*legs = cent->pe.legs.frame;
+	*legsBackLerp = cent->pe.legs.backlerp;
+
+	if( newLegsFrame )
+	{
+		if ( ValidAnimFileIndex( ci->animFileIndex ) )
+		{
+			CG_PlayerAnimEvents( ci->animFileIndex, qfalse, cent->pe.legs.frame, cent->pe.legs.frame, cent->currentState.number );
+		}
+	}
+
+	//HACKHACKHACK
+	/*
+	if ( cent->gent->client->playerTeam == TEAM_BORG &&
+		cent->gent->client->ps.weapon == WP_BORG_ASSIMILATOR )
+	{
+		if ( cent->gent->NPC->attackHoldTime > cg.time )
+		{
+			if ( cent->pe.torso.frame >= 468 && cent->pe.torso.frame < 478 )
+			{//Do not animate
+				*torsoOld = *torso = cent->pe.torso.frame = 468;
+				*torsoBackLerp = 0;
+				if ( ValidAnimFileIndex( ci->animFileIndex ) )
+				{
+					CG_PlayerAnimSounds(ci->animFileIndex, qtrue, cent->pe.torso.frame, cent->pe.torso.frame, cent->currentState.number );
+				}
+				return;
+			}
+		}
+	}
+	*/
+
+	newTorsoFrame = CG_RunLerpFrame( ci, &cent->pe.torso, cent->gent->client->ps.torsoAnim, cent->gent->client->renderInfo.torsoFpsMod, cent->gent->s.number );
+
+	*torsoOld = cent->pe.torso.oldFrame;
+	*torso = cent->pe.torso.frame;
+	*torsoBackLerp = cent->pe.torso.backlerp;
+
+	if( newTorsoFrame )
+	{
+		if ( ValidAnimFileIndex( ci->animFileIndex ) )
+		{
+			CG_PlayerAnimEvents(ci->animFileIndex, qtrue, cent->pe.torso.frame, cent->pe.torso.frame, cent->currentState.number );
+		}
+	}
+}
+
+
+extern int PM_LegsAnimForFrame( gentity_t *ent, int legsFrame );
+extern int PM_TorsoAnimForFrame( gentity_t *ent, int torsoFrame );
+static void CG_PlayerAnimEventDo( centity_t *cent, animevent_t *animEvent )
+{
+	//FIXME: pass in event, switch off the type
+	if ( cent == NULL || animEvent == NULL )
+	{
+		return;
+	}
+
+	soundChannel_t channel = CHAN_AUTO;
+	switch ( animEvent->eventType )
+	{
+	case AEV_SOUNDCHAN:
+		channel = (soundChannel_t)animEvent->eventData[AED_SOUNDCHANNEL];
+	case AEV_SOUND:
+		// are there variations on the sound?
+		{
+			const int holdSnd = animEvent->eventData[ AED_SOUNDINDEX_START+Q_irand( 0, animEvent->eventData[AED_SOUND_NUMRANDOMSNDS] ) ];
+			if ( holdSnd > 0 )
+			{
+				if ( cgs.sound_precache[ holdSnd ] ) 
+				{
+					cgi_S_StartSound( NULL, cent->currentState.clientNum, channel, cgs.sound_precache[holdSnd ] );
+				}
+				else
+				{//try a custom sound
+					const char *s = CG_ConfigString( CS_SOUNDS + holdSnd );
+					CG_TryPlayCustomSound(NULL, cent->currentState.clientNum, channel, va("%s.wav",s), CS_TRY_ALL );
+				}
+			}
+		}
+		break;
+	case AEV_FOOTSTEP:
+		CG_PlayerFootsteps( cent, (footstepType_t)animEvent->eventData[AED_FOOTSTEP_TYPE] );
+		break;
+	case AEV_EFFECT:
+			if ( animEvent->eventData[AED_EFFECTINDEX] == -1 )
+		{//invalid effect
+			if ( animEvent->stringData != NULL
+				&& animEvent->stringData[0] )
+			{//some sort of hard-coded effect
+				if ( Q_stricmp( "push_l", animEvent->stringData ) == 0 )
+				{
+					cgi_S_StartSound ( cent->lerpOrigin, cent->currentState.clientNum, CHAN_AUTO, cgi_S_RegisterSound( "sound/weapons/force/push.wav" ) );
+					cent->gent->client->ps.powerups[PW_FORCE_PUSH] = cg.time + animEvent->eventData[AED_EFFECT_PROBABILITY];//AED_EFFECT_PROBABILITY in this case is the number of ms for the effect to last
+					cent->gent->client->pushEffectFadeTime = 0;
+				}
+				else if ( Q_stricmp( "push_r", animEvent->stringData ) == 0 )
+				{
+					cgi_S_StartSound ( cent->lerpOrigin, cent->currentState.clientNum, CHAN_AUTO, cgi_S_RegisterSound( "sound/weapons/force/push.wav" ) );
+					cent->gent->client->ps.powerups[PW_FORCE_PUSH_RHAND] = cg.time + animEvent->eventData[AED_EFFECT_PROBABILITY];//AED_EFFECT_PROBABILITY in this case is the number of ms for the effect to last
+					cent->gent->client->pushEffectFadeTime = 0;
+				}
+				else if ( Q_stricmp( "scepter_beam", animEvent->stringData ) == 0 )
+				{
+					int modelIndex = cent->gent->weaponModel[1];
+					if ( modelIndex <= 0 )
+					{
+						modelIndex = cent->gent->cinematicModel;
+					}
+					if ( modelIndex > 0 )
+					{//we have a cinematic model
+						int boltIndex = gi.G2API_AddBolt( &cent->gent->ghoul2[modelIndex], "*flash" );
+						if ( boltIndex > -1 )
+						{//cinematic model has a flash bolt
+							CG_PlayEffectBolted( "scepter/beam.efx", modelIndex, boltIndex, cent->currentState.clientNum, cent->lerpOrigin, animEvent->eventData[AED_EFFECT_PROBABILITY], qtrue );//AED_EFFECT_PROBABILITY in this case is the number of ms for the effect to last
+						}
+					}
+				}
+				//FIXME: add more
+			}
+		}
+		else
+		{
+			//add bolt, play effect
+			if ( animEvent->stringData != NULL && cent && cent->gent && cent->gent->ghoul2.size() )
+			{//have a bolt name we want to use
+				animEvent->eventData[AED_MODELINDEX] = cent->gent->playerModel;
+				if ( ( Q_stricmpn( "*blade", animEvent->stringData, 6 ) == 0 
+					   || Q_stricmp( "*flash", animEvent->stringData ) == 0 )
+					&& cent->gent->weaponModel[0] > 0 )
+				{//must be a weapon, try weapon 0?
+					animEvent->eventData[AED_BOLTINDEX] = gi.G2API_AddBolt( &cent->gent->ghoul2[cent->gent->weaponModel[0]], animEvent->stringData );
+					if ( animEvent->eventData[AED_BOLTINDEX] != -1 )
+					{//found it!
+						animEvent->eventData[AED_MODELINDEX] = cent->gent->weaponModel[0];
+					}
+					else
+					{//hmm, just try on the player model, then?
+						animEvent->eventData[AED_BOLTINDEX] = gi.G2API_AddBolt( &cent->gent->ghoul2[cent->gent->playerModel], animEvent->stringData );
+					}
+				}
+				else
+				{
+					animEvent->eventData[AED_BOLTINDEX] = gi.G2API_AddBolt( &cent->gent->ghoul2[cent->gent->playerModel], animEvent->stringData );
+				}
+				animEvent->stringData = NULL;//so we don't try to do this again
+			}
+			if ( animEvent->eventData[AED_BOLTINDEX] != -1 )
+			{//have a bolt we want to play the effect on
+				CG_PlayEffectIDBolted( animEvent->eventData[AED_EFFECTINDEX], 
+								animEvent->eventData[AED_MODELINDEX], 
+								animEvent->eventData[AED_BOLTINDEX], 
+								cent->currentState.clientNum, 
+								cent->lerpOrigin );
+			}
+			else
+			{//play at origin?  FIXME: maybe allow a fwd/rt/up offset?
+				const vec3_t up = {0,0,1};
+				CG_PlayEffectID( animEvent->eventData[AED_EFFECTINDEX], cent->lerpOrigin, up );
+				//G_PlayEffect( animEvent->eventData[AED_EFFECTINDEX], cent->lerpOrigin, up );
+				//theFxScheduler.PlayEffect( animEvent->eventData[AED_EFFECTINDEX], cent->lerpOrigin, qfalse );
+			}
+		}
+		break;
+	case AEV_FIRE:
+		//add fire event
+		if ( animEvent->eventData[AED_FIRE_ALT] )
+		{
+			G_AddEvent( cent->gent, EV_ALT_FIRE, 0 );
+		}
+		else
+		{
+			G_AddEvent( cent->gent, EV_FIRE_WEAPON, 0 );
+		}
+		break;
+	case AEV_MOVE:
+		//make him jump
+		if ( cent && cent->gent && cent->gent->client )
+		{
+			if ( cent->gent->client->ps.groundEntityNum != ENTITYNUM_NONE )
+			{//on something
+				vec3_t	fwd, rt, up, angles = {0, cent->gent->client->ps.viewangles[YAW], 0};
+				AngleVectors( angles, fwd, rt, up );
+				//FIXME: set or add to velocity?
+				VectorScale( fwd, animEvent->eventData[AED_MOVE_FWD], cent->gent->client->ps.velocity );
+				VectorMA( cent->gent->client->ps.velocity, animEvent->eventData[AED_MOVE_RT], rt, cent->gent->client->ps.velocity );
+				VectorMA( cent->gent->client->ps.velocity, animEvent->eventData[AED_MOVE_UP], up, cent->gent->client->ps.velocity );
+				
+				if ( animEvent->eventData[AED_MOVE_UP] > 0 )
+				{//a jump
+					cent->gent->client->ps.pm_flags |= PMF_JUMPING;
+
+					G_AddEvent( cent->gent, EV_JUMP, 0 );
+					//FIXME: if have force jump, do this?  or specify sound in the event data?
+					//cent->gent->client->ps.forceJumpZStart = cent->gent->client->ps.origin[2];//so we don't take damage if we land at same height
+					//G_SoundOnEnt( cent->gent, CHAN_BODY, "sound/weapons/force/jump.wav" );
+				}
+			}
+		}
+		break;
+	default:
+		return;
+		break;
+	}
+}
+
+static void CG_PlayerAnimEvents( int animFileIndex, qboolean torso, int oldFrame, int frame, int entNum )
+{
+	int		i;
+	int		firstFrame = 0, lastFrame = 0;
+	qboolean	doEvent = qfalse, inSameAnim = qfalse, loopAnim = qfalse, match = qfalse, animBackward = qfalse;
+	animevent_t *animEvents = NULL;
+	int		glaIndex = -1;
+	
+	if ( g_entities[entNum].ghoul2.size() )
+	{
+		glaIndex = gi.G2API_GetAnimIndex(&(g_entities[entNum].ghoul2[0]));
+	}
+	
+	if ( torso )
+	{
+		animEvents = level.knownAnimFileSets[animFileIndex].torsoAnimEvents;
+	}
+	else
+	{
+		animEvents = level.knownAnimFileSets[animFileIndex].legsAnimEvents;
+	}
+	if ( abs(oldFrame-frame) > 1 )
+	{//given a range, see if keyFrame falls in that range
+		int oldAnim, anim;
+		if ( torso )
+		{
+			//more precise, slower
+			oldAnim = PM_TorsoAnimForFrame( &g_entities[entNum], oldFrame );
+			anim = PM_TorsoAnimForFrame( &g_entities[entNum], frame );
+		}
+		else
+		{
+			//more precise, slower
+			oldAnim = PM_LegsAnimForFrame( &g_entities[entNum], oldFrame );
+			anim = PM_TorsoAnimForFrame( &g_entities[entNum], frame );
+		}
+
+		if ( anim != oldAnim )
+		{//not in same anim
+			inSameAnim = qfalse;
+			//FIXME: we *could* see if the oldFrame was *just about* to play the keyframed sound...
+		}
+		else
+		{//still in same anim, check for looping anim
+			inSameAnim = qtrue;
+			animation_t *animation = &level.knownAnimFileSets[animFileIndex].animations[anim];
+			animBackward = (animation->frameLerp<0);
+			if ( animation->loopFrames != -1 )
+			{//a looping anim!
+				loopAnim = qtrue;
+				firstFrame = animation->firstFrame;
+				lastFrame = animation->firstFrame+animation->numFrames;
+			}
+		}
+	}
+
+#ifdef _XBOX
+	using dllNamespace::hstring;
+#endif
+	hstring myModel = g_entities[entNum].NPC_type;		//apparently NPC_type is always the same as the model name???
+
+
+	// Check for anim event
+	for ( i=0; i < MAX_ANIM_EVENTS; ++i )
+	{
+		if ( animEvents[i].eventType == AEV_NONE )	// No event, end of list
+		{
+			break;
+		}
+
+		if (glaIndex != -1 && animEvents[i].glaIndex!=glaIndex)
+		{
+			continue;
+		}
+
+		match = qfalse;
+		if (animEvents[i].modelOnly==0 || animEvents[i].modelOnly==myModel.handle())
+		{
+			if ( animEvents[i].keyFrame == frame )
+			{//exact match
+				match = qtrue;
+			}
+			else if ( abs(oldFrame-frame) > 1 )//&& cg_reliableAnimEvents.integer )
+			{//given a range, see if keyFrame falls in that range
+				if ( inSameAnim )
+				{//if changed anims altogether, sorry, the sound is lost
+					if ( abs(oldFrame-animEvents[i].keyFrame) <= 3
+						|| abs(frame-animEvents[i].keyFrame) <= 3 )
+					{//must be at least close to the keyframe
+						if ( animBackward )
+						{//animation plays backwards
+							if ( oldFrame > animEvents[i].keyFrame && frame < animEvents[i].keyFrame )
+							{//old to new passed through keyframe
+								match = qtrue;
+							}
+							else if ( loopAnim )
+							{//hmm, didn't pass through it linearally, see if we looped
+								if ( animEvents[i].keyFrame >= firstFrame && animEvents[i].keyFrame < lastFrame )
+								{//keyframe is in this anim
+									if ( oldFrame > animEvents[i].keyFrame 
+										&& frame > oldFrame )
+									{//old to new passed through keyframe
+										match = qtrue;
+									}
+								}
+							}
+						}
+						else
+						{//anim plays forwards
+							if ( oldFrame < animEvents[i].keyFrame && frame > animEvents[i].keyFrame )
+							{//old to new passed through keyframe
+								match = qtrue;
+							}
+							else if ( loopAnim )
+							{//hmm, didn't pass through it linearally, see if we looped
+								if ( animEvents[i].keyFrame >= firstFrame && animEvents[i].keyFrame < lastFrame )
+								{//keyframe is in this anim
+									if ( oldFrame < animEvents[i].keyFrame 
+										&& frame < oldFrame )
+									{//old to new passed through keyframe
+										match = qtrue;
+									}
+								}
+							}
+						}
+					}
+				}
+			}
+			if ( match )
+			{
+				switch ( animEvents[i].eventType )
+				{
+				case AEV_SOUNDCHAN:
+				case AEV_SOUND:
+					// Determine probability of playing sound
+					if (!animEvents[i].eventData[AED_SOUND_PROBABILITY])	// 100% 
+					{
+						doEvent = qtrue;
+					}
+					else if (animEvents[i].eventData[AED_SOUND_PROBABILITY] > Q_irand(0, 99) )
+					{
+						doEvent = qtrue;
+					}
+					break;
+				case AEV_FOOTSTEP:
+					// Determine probability of playing sound 
+					//Com_Printf( "Footstep event on frame %d, even should be on frame %d, off by %d\n", frame, animEvents[i].keyFrame, frame-animEvents[i].keyFrame );
+					if (!animEvents[i].eventData[AED_FOOTSTEP_PROBABILITY])	// 100% 
+					{
+						doEvent = qtrue;
+					}
+					else if (animEvents[i].eventData[AED_FOOTSTEP_PROBABILITY] > Q_irand(0, 99) )
+					{
+						doEvent = qtrue;
+					}
+					break;
+				case AEV_EFFECT:
+					// Determine probability of playing sound
+					if (!animEvents[i].eventData[AED_EFFECT_PROBABILITY])	// 100% 
+					{
+						doEvent = qtrue;
+					}
+					else if (animEvents[i].eventData[AED_EFFECT_PROBABILITY] > Q_irand(0, 99) )
+					{
+						doEvent = qtrue;
+					}
+					break;
+				case AEV_FIRE:
+					// Determine probability of playing sound
+					if (!animEvents[i].eventData[AED_FIRE_PROBABILITY])	// 100% 
+					{
+						doEvent = qtrue;
+					}
+					else if (animEvents[i].eventData[AED_FIRE_PROBABILITY] > Q_irand(0, 99) )
+					{
+						doEvent = qtrue;
+					}
+					break;
+				case AEV_MOVE:
+					doEvent = qtrue;
+					break;
+				default:
+					//doEvent = qfalse;//implicit
+					break;
+				}
+				// do event
+				if ( doEvent )
+				{
+					CG_PlayerAnimEventDo( &cg_entities[entNum], &animEvents[i] );
+				}
+			}// end if event matches
+		}// end if model matches
+	}// end for	
+}
+
+static void CGG2_AnimEvents( centity_t *cent )
+{
+	if ( !cent || !cent->gent || !cent->gent->client)
+	{
+		return;
+	}
+	if ( !cent->gent->ghoul2.size() )
+	{//sorry, ghoul2 models only
+		return;
+	}
+	assert(cent->gent->playerModel>=0&&cent->gent->playerModel<cent->gent->ghoul2.size());
+	if ( ValidAnimFileIndex( cent->gent->client->clientInfo.animFileIndex ) )
+	{
+		int		junk, curFrame=0;
+		float	currentFrame=0, animSpeed;
+
+		if (cent->gent->rootBone>=0&&gi.G2API_GetBoneAnimIndex( &cent->gent->ghoul2[cent->gent->playerModel], cent->gent->rootBone, cg.time, &currentFrame, &junk, &junk, &junk, &animSpeed, cgs.model_draw ))
+		{
+			// the above may have failed, not sure what to do about it, current frame will be zero in that case
+			curFrame = floor( currentFrame );
+		}
+		if ( curFrame != cent->gent->client->renderInfo.legsFrame )
+		{
+			CG_PlayerAnimEvents( cent->gent->client->clientInfo.animFileIndex, qfalse, cent->gent->client->renderInfo.legsFrame, curFrame, cent->currentState.clientNum );
+		}
+		cent->gent->client->renderInfo.legsFrame = curFrame;
+		cent->pe.legs.frame = curFrame;
+
+		if (cent->gent->lowerLumbarBone>=0&& gi.G2API_GetBoneAnimIndex(&cent->gent->ghoul2[cent->gent->playerModel], cent->gent->lowerLumbarBone, cg.time, &currentFrame, &junk, &junk, &junk, &animSpeed, cgs.model_draw ) )
+		{
+			curFrame = floor( currentFrame );
+		}
+		if ( curFrame != cent->gent->client->renderInfo.torsoFrame )
+		{
+			CG_PlayerAnimEvents( cent->gent->client->clientInfo.animFileIndex, qtrue, cent->gent->client->renderInfo.torsoFrame, curFrame, cent->currentState.clientNum );
+		}
+		cent->gent->client->renderInfo.torsoFrame = curFrame;
+		cent->pe.torso.frame = curFrame;
+	}
+}
+/*
+=============================================================================
+
+PLAYER ANGLES
+
+=============================================================================
+*/
+
+/*
+==================
+CG_UpdateAngleClamp
+Turn curAngle toward destAngle at angleSpeed, but stay within clampMin and Max
+==================
+*/
+static void CG_UpdateAngleClamp( float destAngle, float clampMin, float clampMax, float angleSpeed, float *curAngle, float normalAngle) 
+{
+	float	swing;
+	float	move;
+	float	scale;
+	float	actualSpeed;
+
+	swing = AngleSubtract( destAngle, *curAngle );
+
+	if(swing == 0)
+	{//Don't have to turn
+		return;
+	}
+
+	// modify the angleSpeed depending on the delta
+	// so it doesn't seem so linear
+	scale = fabs( swing );
+	if (swing > 0)
+	{
+		if ( swing < clampMax * 0.25 ) 
+		{//Pretty small way to go
+			scale = 0.25;
+		} 
+		else if ( swing > clampMax * 2.0 )
+		{//Way out of our range
+			scale = 2.0;
+		}
+		else
+		{//Scale it smoothly
+			scale = swing/clampMax;
+		} 
+	}
+	else// if (swing < 0)
+	{
+		if ( swing > clampMin * 0.25 ) 
+		{//Pretty small way to go
+			scale = 0.5;
+		} 
+		else if ( swing < clampMin * 2.0 )
+		{//Way out of our range
+			scale = 2.0;
+		}
+		else
+		{//Scale it smoothly
+			scale = swing/clampMin;
+		} 
+	}
+
+	actualSpeed = scale * angleSpeed;
+	// swing towards the destination angle
+	if ( swing >= 0 ) 
+	{
+		move = cg.frametime * actualSpeed;
+		if ( move >= swing ) 
+		{//our turnspeed is so fast, no need to swing, just match
+			*curAngle = destAngle;
+		}
+		else
+		{
+			*curAngle = AngleNormalize360( *curAngle + move );
+		}
+	} 
+	else if ( swing < 0 ) 
+	{
+		move = cg.frametime * -actualSpeed;
+		if ( move <= swing ) 
+		{//our turnspeed is so fast, no need to swing, just match
+			*curAngle = destAngle;
+		}
+		else
+		{
+			*curAngle = AngleNormalize180( *curAngle + move );
+		}
+	}
+	
+	swing = AngleSubtract( *curAngle, normalAngle );
+
+	// clamp to no more than normalAngle + tolerance
+	if ( swing > clampMax ) 
+	{
+		*curAngle = AngleNormalize180( normalAngle + clampMax );
+	} 
+	else if ( swing < clampMin ) 
+	{
+		*curAngle = AngleNormalize180( normalAngle + clampMin );
+	}
+}
+/*
+==================
+CG_SwingAngles
+
+  If the body is not locked OR if the upper part is trying to swing beyond it's
+	range, turn the lower body part to catch up.
+
+  Parms:	desired angle,		(Our eventual goal angle
+			min swing tolerance,(Lower angle value threshold at which to start turning)
+			max swing tolerance,(Upper angle value threshold at which to start turning)
+			min clamp tolerance,(Lower angle value threshold to clamp output angle to)
+			max clamp tolerance,(Upper angle value threshold to clamp output angle to)
+			angle speed,		(How fast to turn)
+			current angle,		(Current angle to modify)
+			locked mode			(Don't turn unless you exceed the swing/clamp tolerance)
+==================
+*/
+static void CG_SwingAngles( float destAngle, 
+					float swingTolMin, float swingTolMax, 
+					float clampMin, float clampMax,
+					float angleSpeed, float *curAngle, 
+					qboolean *turning ) 
+{
+	float	swing;
+	float	move;
+	float	scale;
+
+	swing = AngleSubtract( destAngle, *curAngle );
+
+	if(swing == 0)
+	{//Don't have to turn
+		*turning = qfalse;
+	}
+	else
+	{
+		*turning = qtrue;
+	}
+
+	//If we're not turning, then we're done
+	if ( *turning == qfalse) 
+		return;
+
+	// modify the angleSpeed depending on the delta
+	// so it doesn't seem so linear
+	scale = fabs( swing );
+
+	if (swing > 0)
+	{
+		if ( clampMax <= 0 )
+		{
+			*curAngle = destAngle;
+			return;
+		}
+
+		if ( swing < swingTolMax * 0.5 ) 
+		{//Pretty small way to go
+			scale = 0.5;
+		} 
+		else if ( scale < swingTolMax ) 
+		{//More than halfway to go
+			scale = 1.0;
+		} 
+		else 
+		{//Way out of our range
+			scale = 2.0;
+		}
+	}
+	else// if (swing < 0)
+	{
+		if ( clampMin >= 0 )
+		{
+			*curAngle = destAngle;
+			return;
+		}
+
+		if ( swing > swingTolMin * 0.5 ) 
+		{//Pretty small way to go
+			scale = 0.5;
+		} 
+		else if ( scale > swingTolMin ) 
+		{//More than halfway to go
+			scale = 1.0;
+		} 
+		else 
+		{//Way out of our range
+			scale = 2.0;
+		}
+	}
+
+	// swing towards the destination angle
+	if ( swing >= 0 ) 
+	{
+		move = cg.frametime * scale * angleSpeed;
+		if ( move >= swing ) 
+		{//our turnspeed is so fast, no need to swing, just match
+			move = swing;
+		}
+		*curAngle = AngleNormalize360( *curAngle + move );
+	} 
+	else if ( swing < 0 ) 
+	{
+		move = cg.frametime * scale * -angleSpeed;
+		if ( move <= swing ) 
+		{//our turnspeed is so fast, no need to swing, just match
+			move = swing;
+		}
+		*curAngle = AngleNormalize360( *curAngle + move );
+	}
+	
+
+	// clamp to no more than tolerance
+	if ( swing > clampMax ) 
+	{
+		*curAngle = AngleNormalize360( destAngle - (clampMax - 1) );
+	} 
+	else if ( swing < clampMin ) 
+	{
+		*curAngle = AngleNormalize360( destAngle + (-clampMin - 1) );
+	}
+}
+
+/*
+===============
+CG_BreathPuffs
+===============
+Description: Makes the player appear to have breath puffs (from the cold).
+Added 11/06/02 by Aurelio Reis.
+*/
+extern vmCvar_t	cg_drawBreath;
+static void CG_BreathPuffs( centity_t *cent, vec3_t angles, vec3_t origin )
+{
+	gclient_s *client = cent->gent->client;
+	
+	/*	cg_drawBreath.integer	== 0 - Don't draw at all.
+								== 1 - Draw both (but bubbles only when under water).
+								== 2 - Draw only cold breath.
+								== 3 - Draw only under water bubbles (when under water)	*/
+
+	if ( !client 
+		|| cg_drawBreath.integer == 0 
+		|| !cg.renderingThirdPerson 
+		|| client->ps.pm_type == PM_DEAD 
+		|| client->breathPuffTime > cg.time )
+	{
+		return;
+	}
+
+	// Get the head-front bolt/tag.
+	int bolt = gi.G2API_AddBolt( &cent->gent->ghoul2[cent->gent->playerModel], "*head_front" );
+	if ( bolt == -1 )
+	{
+		return;
+	}
+
+	vec3_t vEffectOrigin;
+	mdxaBone_t	boltMatrix;
+	gi.G2API_GetBoltMatrix( cent->gent->ghoul2, cent->gent->playerModel, bolt, &boltMatrix, angles, origin, cg.time, cgs.model_draw, cent->currentState.modelScale );
+	gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, vEffectOrigin );
+
+	int contents = cgi_CM_PointContents( vEffectOrigin, 0 );
+	if ( contents & ( CONTENTS_SLIME | CONTENTS_LAVA ) )	// If they're submerged in something bad, leave.
+	{
+		return;
+	}
+
+	// Show bubbles effect if we're under water.
+	if ( (contents & CONTENTS_WATER) && ( cg_drawBreath.integer == 1 || cg_drawBreath.integer == 3 ) )
+	{
+		CG_PlayEffectBolted( "misc/waterbreath", cent->gent->playerModel, bolt, cent->currentState.clientNum, vEffectOrigin );
+	}
+	// Draw cold breath effect.
+	else if ( cg_drawBreath.integer == 1 || cg_drawBreath.integer == 2 )
+	{
+		CG_PlayEffectBolted( "misc/breath", cent->gent->playerModel, bolt, cent->currentState.clientNum, vEffectOrigin );
+	}
+
+	// TODO: It'd be nice if they breath faster when they're more damaged or when running...
+	if ( gi.VoiceVolume[cent->currentState.number] > 0 )
+	{//make breath when talking
+		client->breathPuffTime = cg.time + 300; // every 200 ms
+	}
+	else
+	{
+		client->breathPuffTime = cg.time + 3000; // every 3 seconds.
+	}
+}
+
+#define LOOK_DEFAULT_SPEED	0.15f
+#define LOOK_TALKING_SPEED	0.15f	
+
+static qboolean CG_CheckLookTarget( centity_t *cent, vec3_t	lookAngles, float *lookingSpeed )
+{
+	if ( !cent->gent->ghoul2.size() )
+	{
+		if ( !cent->gent->client->clientInfo.torsoModel || !cent->gent->client->clientInfo.headModel )
+		{
+			return qfalse;
+		}
+	}
+
+	//FIXME: also clamp the lookAngles based on the clamp + the existing difference between
+	//		headAngles and torsoAngles?  But often the tag_torso is straight but the torso itself
+	//		is deformed to not face straight... sigh...
+
+	//Now calc head angle to lookTarget, if any
+	if ( cent->gent->client->renderInfo.lookTarget >= 0 && cent->gent->client->renderInfo.lookTarget < ENTITYNUM_WORLD )
+	{
+		vec3_t	lookDir, lookOrg, eyeOrg;
+		if ( cent->gent->client->renderInfo.lookMode == LM_ENT )
+		{
+			centity_t	*lookCent = &cg_entities[cent->gent->client->renderInfo.lookTarget];
+			if ( lookCent && lookCent->gent )
+			{
+				if ( lookCent->gent != cent->gent->enemy )
+				{//We turn heads faster than headbob speed, but not as fast as if watching an enemy
+					if ( cent->gent->client->NPC_class == CLASS_ROCKETTROOPER )
+					{//they look around slowly and deliberately
+						*lookingSpeed = LOOK_DEFAULT_SPEED*0.25f;
+					}
+					else
+					{
+						*lookingSpeed = LOOK_DEFAULT_SPEED;
+					}
+				}
+
+				//FIXME: Ignore small deltas from current angles so we don't bob our head in synch with theirs?
+
+				if ( cent->gent->client->renderInfo.lookTarget == 0 && !cg.renderingThirdPerson )//!cg_thirdPerson.integer )
+				{//Special case- use cg.refdef.vieworg if looking at player and not in third person view
+					VectorCopy( cg.refdef.vieworg, lookOrg );
+				}
+				else if ( lookCent->gent->client )
+				{
+					VectorCopy( lookCent->gent->client->renderInfo.eyePoint, lookOrg );
+				}
+				else if ( lookCent->gent->s.pos.trType == TR_INTERPOLATE )
+				{
+					VectorCopy( lookCent->lerpOrigin, lookOrg );
+				}
+				else if ( lookCent->gent->inuse && !VectorCompare( lookCent->gent->currentOrigin, vec3_origin ) )
+				{
+					VectorCopy( lookCent->gent->currentOrigin, lookOrg );
+				}
+				else
+				{//at origin of world
+					return qfalse;
+				}
+				//Look in dir of lookTarget
+			}
+		}
+		else if ( cent->gent->client->renderInfo.lookMode == LM_INTEREST && cent->gent->client->renderInfo.lookTarget > -1 && cent->gent->client->renderInfo.lookTarget < MAX_INTEREST_POINTS )
+		{
+			VectorCopy( level.interestPoints[cent->gent->client->renderInfo.lookTarget].origin, lookOrg );
+		}
+		else
+		{
+			return qfalse;
+		}
+
+		VectorCopy( cent->gent->client->renderInfo.eyePoint, eyeOrg );
+
+		VectorSubtract( lookOrg, eyeOrg, lookDir );
+#if 1
+		vectoangles( lookDir, lookAngles );
+#else
+		//FIXME: get the angle of the head tag and account for that when finding the lookAngles-
+		//		so if they're lying on their back we get an accurate lookAngle...
+		vec3_t	headDirs[3];
+		vec3_t	finalDir;
+
+		AnglesToAxis( cent->gent->client->renderInfo.headAngles, headDirs );
+		VectorRotate( lookDir, headDirs, finalDir );
+		vectoangles( finalDir, lookAngles );
+#endif
+		for ( int i = 0; i < 3; i++ )
+		{
+			lookAngles[i] = AngleNormalize180( lookAngles[i] );
+			cent->gent->client->renderInfo.eyeAngles[i] = AngleNormalize180( cent->gent->client->renderInfo.eyeAngles[i] );
+		}
+		AnglesSubtract( lookAngles, cent->gent->client->renderInfo.eyeAngles, lookAngles );
+		return qtrue;
+	}
+
+	return qfalse;
+}
+
+/*
+=================
+CG_AddHeadBob
+=================
+*/
+static qboolean CG_AddHeadBob( centity_t *cent, vec3_t addTo ) 
+{
+	renderInfo_t	*renderInfo	= &cent->gent->client->renderInfo;
+	const int		volume		= gi.VoiceVolume[cent->gent->s.clientNum];
+	const int		volChange	= volume - renderInfo->lastVoiceVolume;//was *3 because voice fromLA was too low
+	int				i;
+
+	renderInfo->lastVoiceVolume = volume;
+
+	if ( !volume )
+	{
+		// Not talking, set our target to be the normal head position
+		VectorClear( renderInfo->targetHeadBobAngles );
+
+		if ( VectorLengthSquared( renderInfo->headBobAngles ) < 1.0f )
+		{
+			// We are close enough to being back to our normal head position, so we are done for now
+			return qfalse;
+		}
+	}
+	else if ( volChange > 2 )
+	{
+		// a big positive change in volume
+		for ( i = 0; i < 3; i++ )
+		{
+			// Move our head angle target a bit
+			renderInfo->targetHeadBobAngles[i] += Q_flrand( -1.0 * volChange, 1.0 * volChange );
+
+			// Clamp so we don't get too out of hand
+			if ( renderInfo->targetHeadBobAngles[i] > 7.0f )
+				renderInfo->targetHeadBobAngles[i] = 7.0f;
+
+			if ( renderInfo->targetHeadBobAngles[i] < -7.0f )
+				renderInfo->targetHeadBobAngles[i] = -7.0f;
+		}
+	}
+
+	for ( i = 0; i < 3; i++ )
+	{
+		// Always try to move head angles towards our target
+		renderInfo->headBobAngles[i] += ( renderInfo->targetHeadBobAngles[i] - renderInfo->headBobAngles[i] ) * ( cg.frametime / 150.0f );
+		if ( addTo )
+		{
+			addTo[i] = AngleNormalize180( addTo[i] + AngleNormalize180( renderInfo->headBobAngles[i] ) );
+		}
+	}
+
+	// We aren't back to our normal position yet, so we still have to apply headBobAngles
+	return qtrue;
+}
+
+extern float vectoyaw( const vec3_t vec );
+static qboolean CG_PlayerLegsYawFromMovement( centity_t *cent, const vec3_t velocity, float *yaw, float fwdAngle, float swingTolMin, float swingTolMax, qboolean alwaysFace )
+{
+	float newAddAngle, angleDiff, turnRate = 10, addAngle = 0;
+
+	//figure out what the offset, if any, should be
+	if ( velocity[0] || velocity[1] )
+	{
+		float	moveYaw;
+		moveYaw = vectoyaw( velocity );
+		addAngle = AngleDelta( cent->lerpAngles[YAW], moveYaw )*-1;
+		if ( addAngle > 150 || addAngle < -150 )
+		{
+			addAngle = 0;
+		}
+		else
+		{
+			//FIXME: use actual swing/clamp tolerances
+			if ( addAngle > swingTolMax )
+			{
+				addAngle = swingTolMax;
+			}
+			else if ( addAngle < swingTolMin )
+			{
+				addAngle = swingTolMin;
+			}
+			if ( cent->gent->client->ps.pm_flags&PMF_BACKWARDS_RUN )
+			{
+				addAngle *= -1;
+			}
+			turnRate = 5;
+		}
+	}
+	else if ( !alwaysFace )
+	{
+		return qfalse;
+	}
+	if ( cent->gent && cent->gent->client && cent->gent->client->ps.forcePowersActive & (1 << FP_SPEED) )
+	{//using force speed
+		//scale up the turning speed
+		turnRate /= cg_timescale.value;
+	}
+	//lerp the legs angle to the new angle
+	angleDiff = AngleDelta( cent->pe.legs.yawAngle, (*yaw+addAngle) );
+	newAddAngle = angleDiff*cg.frameInterpolation*-1;
+	if ( fabs(newAddAngle) > fabs(angleDiff) )
+	{
+		newAddAngle = angleDiff*-1;
+	}
+	if ( newAddAngle > turnRate )
+	{
+		newAddAngle = turnRate;
+	}
+	else if ( newAddAngle < -turnRate )
+	{
+		newAddAngle = -turnRate;
+	}
+	*yaw = cent->pe.legs.yawAngle + newAddAngle;
+	//Now clamp
+	angleDiff = AngleDelta( fwdAngle, *yaw );
+	if ( angleDiff > swingTolMax )
+	{
+		*yaw = fwdAngle - swingTolMax;
+	}
+	else if ( angleDiff < swingTolMin )
+	{
+		*yaw = fwdAngle - swingTolMin;
+	}
+	return qtrue;
+}
+
+static void CG_ATSTLegsYaw( centity_t *cent, vec3_t trailingLegsAngles )
+{
+
+	float ATSTLegsYaw = cent->lerpAngles[YAW];
+
+	CG_PlayerLegsYawFromMovement( cent, cent->gent->client->ps.velocity, &ATSTLegsYaw, cent->lerpAngles[YAW], -60, 60, qtrue );
+
+	float legAngleDiff = AngleNormalize180(ATSTLegsYaw) - AngleNormalize180(cent->pe.legs.yawAngle);
+	int legsAnim = cent->currentState.legsAnim;
+	qboolean moving = (!VectorCompare(cent->gent->client->ps.velocity, vec3_origin));
+	if ( moving || legsAnim == BOTH_TURN_LEFT1 || legsAnim == BOTH_TURN_RIGHT1 || fabs(legAngleDiff) > 45 )
+	{//moving or turning or beyond the turn allowance
+		if ( legsAnim == BOTH_STAND1 && !moving )
+		{//standing
+			if ( legAngleDiff > 0 )
+			{
+				NPC_SetAnim( cent->gent, SETANIM_LEGS, BOTH_TURN_LEFT1, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+			}
+			else
+			{
+				NPC_SetAnim( cent->gent, SETANIM_LEGS, BOTH_TURN_RIGHT1, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+			}
+			VectorSet( trailingLegsAngles, 0, cent->pe.legs.yawAngle, 0 );
+			cent->gent->client->renderInfo.legsYaw = trailingLegsAngles[YAW];
+		}
+		else if ( legsAnim == BOTH_TURN_LEFT1 || legsAnim == BOTH_TURN_RIGHT1 )
+		{//turning
+			legAngleDiff = AngleSubtract( ATSTLegsYaw, cent->gent->client->renderInfo.legsYaw );
+			float add = 0;
+			if ( legAngleDiff > 50 )
+			{
+				cent->pe.legs.yawAngle += legAngleDiff - 50;
+			}
+			else if ( legAngleDiff < -50 )
+			{
+				cent->pe.legs.yawAngle += legAngleDiff + 50;
+			}
+			float animLength = PM_AnimLength( cent->gent->client->clientInfo.animFileIndex, (animNumber_t)legsAnim );
+			legAngleDiff *= ( animLength - cent->gent->client->ps.legsAnimTimer)/animLength;
+			VectorSet( trailingLegsAngles, 0, cent->pe.legs.yawAngle+legAngleDiff+add, 0 );
+			if ( !cent->gent->client->ps.legsAnimTimer )
+			{//FIXME: if start turning in the middle of this, our legs pop back to the old cent->pe.legs.yawAngle...
+				cent->gent->client->renderInfo.legsYaw = trailingLegsAngles[YAW];
+			}
+		}
+		else
+		{//moving
+			legAngleDiff = AngleSubtract( ATSTLegsYaw, cent->pe.legs.yawAngle );
+			//FIXME: framerate dependant!!!
+			if ( legAngleDiff > 50 )
+			{
+				legAngleDiff -= 50;
+			}
+			else if ( legAngleDiff > 5 )
+			{
+				legAngleDiff = 5;
+			}
+			else if ( legAngleDiff < -50 )
+			{
+				legAngleDiff += 50;
+			}
+			else if ( legAngleDiff < -5 )
+			{
+				legAngleDiff = -5;
+			}
+			legAngleDiff *= cg.frameInterpolation;
+			VectorSet( trailingLegsAngles, 0, AngleNormalize180(cent->pe.legs.yawAngle + legAngleDiff), 0 );
+			cent->gent->client->renderInfo.legsYaw = trailingLegsAngles[YAW];
+		}
+		cent->gent->client->renderInfo.legsYaw = cent->pe.legs.yawAngle = trailingLegsAngles[YAW];
+		cent->pe.legs.yawing = qtrue;
+	}
+	else
+	{
+		VectorSet( trailingLegsAngles, 0, cent->pe.legs.yawAngle, 0 );
+		cent->gent->client->renderInfo.legsYaw = cent->pe.legs.yawAngle = trailingLegsAngles[YAW];
+		cent->pe.legs.yawing = qfalse;
+	}
+	return;
+}
+
+extern qboolean G_ClassHasBadBones( int NPC_class );
+extern void G_BoneOrientationsForClass( int NPC_class, char *boneName, Eorientations *oUp, Eorientations *oRt, Eorientations *oFwd );
+extern qboolean PM_FlippingAnim( int anim );
+extern qboolean PM_SpinningSaberAnim( int anim );
+static CGhoul2Info_v	dummyGhoul2;
+static int				dummyRootBone;
+static int				dummyHipsBolt;
+static void CG_G2ClientSpineAngles( centity_t *cent, vec3_t viewAngles, const vec3_t angles, vec3_t thoracicAngles, vec3_t ulAngles, vec3_t llAngles )
+{
+	vec3_t	motionBoneCorrectAngles = {0};
+	cent->pe.torso.pitchAngle = viewAngles[PITCH];
+	viewAngles[YAW] = AngleDelta( cent->lerpAngles[YAW], angles[YAW] );
+	cent->pe.torso.yawAngle = viewAngles[YAW];
+
+	/*
+	if ( G_ClassHasBadBones( cent->gent->client->NPC_class ) )
+	{//don't use lower bones
+		VectorClear( thoracicAngles );
+		VectorClear( ulAngles );
+		VectorClear( llAngles );
+		BG_G2SetBoneAngles( cent, cent->gent, cent->gent->upperLumbarBone, vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_X, POSITIVE_Y, POSITIVE_Z, cgs.model_draw ); 
+		BG_G2SetBoneAngles( cent, cent->gent, cent->gent->lowerLumbarBone, vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_X, POSITIVE_Y, POSITIVE_Z, cgs.model_draw ); 
+		return;
+	}
+	*/
+
+	if ( cent->gent->client->NPC_class == CLASS_SABER_DROID )
+	{//don't use lower bones
+		VectorClear( thoracicAngles );
+		VectorClear( ulAngles );
+		VectorClear( llAngles );
+		return;
+	}
+
+	if ( cg_motionBoneComp.integer 
+		&& !PM_FlippingAnim( cent->currentState.legsAnim ) 
+		&& !PM_SpinningSaberAnim( cent->currentState.legsAnim ) 
+		&& !PM_SpinningSaberAnim( cent->currentState.torsoAnim )
+		&& cent->currentState.legsAnim != cent->currentState.torsoAnim //NOTE: presumes your legs & torso are on the same frame, though they *should* be because PM_SetAnimFinal tries to keep them in synch
+		&& !G_ClassHasBadBones( cent->gent->client->NPC_class ) )//these guys' bones are so fucked up we shouldn't even bother with this motion bone comp...
+	{//FIXME: no need to do this if legs and torso on are same frame
+		mdxaBone_t	boltMatrix;
+
+		if ( cg_motionBoneComp.integer > 2 && cent->gent->rootBone >= 0 && cent->gent->lowerLumbarBone >= 0 )
+		{//expensive version
+			//have a local ghoul2 instance to mess with for this stuff... :/
+			//remember the frame the lower is on
+			float	upperFrame, animSpeed;
+			int		junk;
+			vec3_t	llFwd, llRt, destPAngles, curPAngles, tempAng;
+
+			if ( !dummyGhoul2.size() )
+			{//set it up
+				int dummyHModel = cgi_R_RegisterModel( "models/players/_humanoid/_humanoid.glm" );
+				gi.G2API_InitGhoul2Model( dummyGhoul2, "models/players/_humanoid/_humanoid.glm", dummyHModel, 0 );
+				dummyRootBone = gi.G2API_GetBoneIndex( &dummyGhoul2[0], "model_root", qtrue );
+				dummyHipsBolt = gi.G2API_AddBolt( &dummyGhoul2[0], "pelvis" );
+			}
+			
+			gi.G2API_GetBoneAnimIndex( &cent->gent->ghoul2[cent->gent->playerModel], cent->gent->lowerLumbarBone, cg.time, &upperFrame, &junk, &junk, &junk, &animSpeed, cgs.model_draw );
+			//set the dummyGhoul2 lower body to same frame as upper
+			gi.G2API_SetBoneAnimIndex(&dummyGhoul2[0], dummyRootBone, upperFrame, upperFrame, BONE_ANIM_OVERRIDE_FREEZE, 1, cg.time, upperFrame, 0 );
+			//get the dummyGhoul2 lower_lumbar orientation
+			gi.G2API_GetBoltMatrix( dummyGhoul2, 0, dummyHipsBolt, &boltMatrix, vec3_origin, vec3_origin, cg.time, cgs.model_draw, cent->currentState.modelScale );
+			gi.G2API_GiveMeVectorFromMatrix( boltMatrix, NEGATIVE_Z, llFwd );
+			gi.G2API_GiveMeVectorFromMatrix( boltMatrix, NEGATIVE_Y, llRt );
+			vectoangles( llFwd, destPAngles );
+			vectoangles( llRt, tempAng );
+			destPAngles[ROLL] = -tempAng[PITCH];
+			//get my lower_lumbar
+			gi.G2API_GetBoltMatrix( cent->gent->ghoul2, cent->gent->playerModel, cent->gent->crotchBolt, &boltMatrix, vec3_origin, vec3_origin, cg.time, cgs.model_draw, cent->currentState.modelScale );
+			gi.G2API_GiveMeVectorFromMatrix( boltMatrix, NEGATIVE_Z, llFwd );
+			gi.G2API_GiveMeVectorFromMatrix( boltMatrix, NEGATIVE_Y, llRt );
+			vectoangles( llFwd, curPAngles );
+			vectoangles( llRt, tempAng );
+			curPAngles[ROLL] = -tempAng[PITCH];
+
+			//get the difference
+			for ( int ang = 0; ang < 3; ang++ )
+			{
+				motionBoneCorrectAngles[ang] = AngleNormalize180( AngleDelta( AngleNormalize180( destPAngles[ang] ), AngleNormalize180( curPAngles[ang]) ) );
+			}
+#ifdef _DEBUG
+			Com_Printf( "motion bone correction:  %4.2f %4.2f %4.2f\n", motionBoneCorrectAngles[PITCH], motionBoneCorrectAngles[YAW], motionBoneCorrectAngles[ROLL] );
+#endif// _DEBUG
+			/*
+			for ( int ang = 0; ang < 3; ang++ )
+			{
+				viewAngles[ang] = AngleNormalize180( viewAngles[ang] - AngleNormalize180( destLLAngles[ang] ) );
+			}
+			*/
+		}
+		else
+		{
+			//adjust for motion offset
+			vec3_t		motionFwd, motionAngles;
+
+			gi.G2API_GetBoltMatrix( cent->gent->ghoul2, cent->gent->playerModel, cent->gent->motionBolt, &boltMatrix, vec3_origin, cent->lerpOrigin, cg.time, cgs.model_draw, cent->currentState.modelScale );
+			gi.G2API_GiveMeVectorFromMatrix( boltMatrix, NEGATIVE_Y, motionFwd );
+			vectoangles( motionFwd, motionAngles );
+			if ( cg_motionBoneComp.integer > 1 )
+			{//do roll, too
+				vec3_t motionRt, tempAng;
+				gi.G2API_GiveMeVectorFromMatrix( boltMatrix, NEGATIVE_X, motionRt );
+				vectoangles( motionRt, tempAng );
+				motionAngles[ROLL] = -tempAng[PITCH];
+			}
+
+			for ( int ang = 0; ang < 3; ang++ )
+			{
+				viewAngles[ang] = AngleNormalize180( viewAngles[ang] - AngleNormalize180( motionAngles[ang] ) );
+			}
+		}
+	}
+	//distribute the angles differently up the spine
+	//NOTE: each of these distributions must add up to 1.0f
+	if ( cent->gent->client->NPC_class == CLASS_HAZARD_TROOPER )
+	{//only uses lower_lumbar and upper_lumbar to look around
+		VectorClear( thoracicAngles );
+		ulAngles[PITCH] = viewAngles[PITCH]*0.50f;
+		llAngles[PITCH] = viewAngles[PITCH]*0.50f+motionBoneCorrectAngles[PITCH];
+
+		ulAngles[YAW] = viewAngles[YAW]*0.45f;
+		llAngles[YAW] = viewAngles[YAW]*0.55f+motionBoneCorrectAngles[YAW];
+
+		ulAngles[ROLL] = viewAngles[ROLL]*0.45f;
+		llAngles[ROLL] = viewAngles[ROLL]*0.55f+motionBoneCorrectAngles[ROLL];
+	}
+	else if ( cent->gent->client->NPC_class == CLASS_ASSASSIN_DROID )
+	{//each bone has only 1 axis of rotation!
+		//upper lumbar does not pitch
+		thoracicAngles[PITCH] = viewAngles[PITCH]*0.40f;
+		ulAngles[PITCH] = 0.0f;
+		llAngles[PITCH] = viewAngles[PITCH]*0.60f+motionBoneCorrectAngles[PITCH];
+		//only upper lumbar yaws
+		thoracicAngles[YAW] = 0.0f;
+		ulAngles[YAW] = viewAngles[YAW];
+		llAngles[YAW] = motionBoneCorrectAngles[YAW];
+		//no bone is capable of rolling
+		thoracicAngles[ROLL] = 0.0f;
+		ulAngles[ROLL] = 0.0f;
+		llAngles[ROLL] = motionBoneCorrectAngles[ROLL];
+	}
+	else
+	{//use all 3 bones
+		thoracicAngles[PITCH] = viewAngles[PITCH]*0.20f;
+		ulAngles[PITCH] = viewAngles[PITCH]*0.40f;
+		llAngles[PITCH] = viewAngles[PITCH]*0.40f+motionBoneCorrectAngles[PITCH];
+
+		thoracicAngles[YAW] = viewAngles[YAW]*0.20f;
+		ulAngles[YAW] = viewAngles[YAW]*0.35f;
+		llAngles[YAW] = viewAngles[YAW]*0.45f+motionBoneCorrectAngles[YAW];
+
+		thoracicAngles[ROLL] = viewAngles[ROLL]*0.20f;
+		ulAngles[ROLL] = viewAngles[ROLL]*0.35f;
+		llAngles[ROLL] = viewAngles[ROLL]*0.45f+motionBoneCorrectAngles[ROLL];
+	}
+	
+	if ( G_IsRidingVehicle( cent->gent ) )// && type == VH_SPEEDER ?
+	{//aim torso forward too
+		ulAngles[YAW] = llAngles[YAW] = 0;
+
+		// Only if they have weapon can they pitch forward/back.
+		if ( cent->gent->client->ps.weapon == WP_NONE || cent->gent->client->ps.weapon == WP_SABER )
+		{
+			ulAngles[PITCH] = llAngles[PITCH] = 0;
+		}
+	}
+	//thoracic is added modified again by neckAngle calculations, so don't set it until then
+	if ( G_ClassHasBadBones( cent->gent->client->NPC_class ) )
+	{
+		Eorientations oUp, oRt, oFwd;
+		if ( cent->gent->client->NPC_class == CLASS_RANCOR )
+		{
+			llAngles[YAW] = llAngles[ROLL] = 0.0f;
+			ulAngles[YAW] = ulAngles[ROLL] = 0.0f;
+		}
+		G_BoneOrientationsForClass( cent->gent->client->NPC_class, "upper_lumbar", &oUp, &oRt, &oFwd );
+		BG_G2SetBoneAngles( cent, cent->gent, cent->gent->upperLumbarBone, ulAngles, BONE_ANGLES_POSTMULT, oUp, oRt, oFwd, cgs.model_draw); 
+		G_BoneOrientationsForClass( cent->gent->client->NPC_class, "lower_lumbar", &oUp, &oRt, &oFwd );
+		BG_G2SetBoneAngles( cent, cent->gent, cent->gent->lowerLumbarBone, llAngles, BONE_ANGLES_POSTMULT, oUp, oRt, oFwd, cgs.model_draw); 
+	}
+	else
+	{
+		BG_G2SetBoneAngles( cent, cent->gent, cent->gent->upperLumbarBone, ulAngles, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, cgs.model_draw); 
+		BG_G2SetBoneAngles( cent, cent->gent, cent->gent->lowerLumbarBone, llAngles, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, cgs.model_draw); 
+	}
+}
+
+static void CG_G2ClientNeckAngles( centity_t *cent, const vec3_t lookAngles, vec3_t headAngles, vec3_t neckAngles, vec3_t thoracicAngles, vec3_t headClampMinAngles, vec3_t headClampMaxAngles )
+{
+	/*
+	if ( G_ClassHasBadBones( cent->gent->client->NPC_class ) )
+	{//don't use lower bones
+		VectorClear( thoracicAngles );
+		VectorClear( headAngles );
+		VectorClear( neckAngles );
+		BG_G2SetBoneAngles( cent, cent->gent, cent->gent->thoracicBone, vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_X, POSITIVE_Y, POSITIVE_Z, cgs.model_draw ); 
+		BG_G2SetBoneAngles( cent, cent->gent, cent->gent->cervicalBone, vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_X, POSITIVE_Y, POSITIVE_Z, cgs.model_draw ); 
+		BG_G2SetBoneAngles( cent, cent->gent, cent->gent->craniumBone, vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_X, POSITIVE_Y, POSITIVE_Z, cgs.model_draw ); 
+		return;
+	}
+	*/
+	if ( cent->gent->client->NPC_class == CLASS_HAZARD_TROOPER )
+	{//don't use upper bones
+		return;
+	}
+	vec3_t	lA;
+	VectorCopy( lookAngles, lA );
+	//clamp the headangles (which should now be relative to the cervical (neck) angles
+	if ( lA[PITCH] < headClampMinAngles[PITCH] )
+	{
+		lA[PITCH] = headClampMinAngles[PITCH];
+	}
+	else if ( lA[PITCH] > headClampMaxAngles[PITCH] )
+	{
+		lA[PITCH] = headClampMaxAngles[PITCH];
+	}
+
+	if ( lA[YAW] < headClampMinAngles[YAW] )
+	{
+		lA[YAW] = headClampMinAngles[YAW];
+	}
+	else if ( lA[YAW] > headClampMaxAngles[YAW] )
+	{
+		lA[YAW] = headClampMaxAngles[YAW];
+	}
+
+	if ( lA[ROLL] < headClampMinAngles[ROLL] )
+	{
+		lA[ROLL] = headClampMinAngles[ROLL];
+	}
+	else if ( lA[ROLL] > headClampMaxAngles[ROLL] )
+	{
+		lA[ROLL] = headClampMaxAngles[ROLL];
+	}
+
+	//split it up between the neck and cranium
+	if ( cent->gent->client->NPC_class == CLASS_ASSASSIN_DROID )
+	{//each bone has only 1 axis of rotation!
+		//thoracic only pitches, split with cervical
+		if ( thoracicAngles[PITCH] )
+		{//already been set above, blend them
+			thoracicAngles[PITCH] = (thoracicAngles[PITCH] + (lA[PITCH] * 0.5f)) * 0.5f;
+		}
+		else
+		{
+			thoracicAngles[PITCH] = lA[PITCH] * 0.5f;
+		}
+		thoracicAngles[YAW] = thoracicAngles[ROLL] = 0.0f;
+		//cervical only pitches, split with thoracis
+		neckAngles[PITCH] = lA[PITCH] * 0.5f;
+		neckAngles[YAW] = 0.0f;
+		neckAngles[ROLL] = 0.0f;
+		//cranium only yaws
+		headAngles[PITCH] = 0.0f;
+		headAngles[YAW] = lA[YAW];
+		headAngles[ROLL] = 0.0f;
+		//no bones roll
+	}
+	else if ( cent->gent->client->NPC_class == CLASS_SABER_DROID )
+	{//each bone has only 1 axis of rotation!
+		//no thoracic
+		VectorClear( thoracicAngles );
+		//cervical only yaws
+		neckAngles[PITCH] = 0.0f;
+		neckAngles[YAW] = lA[YAW];
+		neckAngles[ROLL] = 0.0f;
+		//cranium only pitches
+		headAngles[PITCH] = lA[PITCH];
+		headAngles[YAW] = 0.0f;
+		headAngles[ROLL] = 0.0f;
+		//none of the bones roll
+	}
+	else
+	{
+		if ( thoracicAngles[PITCH] )
+		{//already been set above, blend them
+			thoracicAngles[PITCH] = (thoracicAngles[PITCH] + (lA[PITCH] * 0.4f)) * 0.5f;
+		}
+		else
+		{
+			thoracicAngles[PITCH] = lA[PITCH] * 0.4f;
+		}
+		if ( thoracicAngles[YAW] )
+		{//already been set above, blend them
+			thoracicAngles[YAW] = (thoracicAngles[YAW] + (lA[YAW] * 0.1f)) * 0.5f;
+		}
+		else
+		{
+			thoracicAngles[YAW] = lA[YAW] * 0.1f;
+		}
+		if ( thoracicAngles[ROLL] )
+		{//already been set above, blend them
+			thoracicAngles[ROLL] = (thoracicAngles[ROLL] + (lA[ROLL] * 0.1f)) * 0.5f;
+		}
+		else
+		{
+			thoracicAngles[ROLL] = lA[ROLL] * 0.1f;
+		}
+
+		neckAngles[PITCH] = lA[PITCH] * 0.2f;
+		neckAngles[YAW] = lA[YAW] * 0.3f;
+		neckAngles[ROLL] = lA[ROLL] * 0.3f;
+
+		headAngles[PITCH] = lA[PITCH] * 0.4f;
+		headAngles[YAW] = lA[YAW] * 0.6f;
+		headAngles[ROLL] = lA[ROLL] * 0.6f;
+	}
+
+	if ( G_IsRidingVehicle( cent->gent ) )// && type == VH_SPEEDER ?
+	{//aim torso forward too
+		headAngles[YAW] = neckAngles[YAW] = thoracicAngles[YAW] = 0;
+
+		// Only if they have weapon can they pitch forward/back.
+		if ( cent->gent->client->ps.weapon == WP_NONE || cent->gent->client->ps.weapon == WP_SABER )
+		{
+			thoracicAngles[PITCH] = 0;
+		}
+
+		/* ABORTED ATTEMPT AT AIMING GUN WITH SHOULDER WHEN ON BIKE...  POSSIBLY RETURN TO THIS LATER
+		if ( cent->gent &&
+			 cent->gent->client &&
+			 cent->gent->enemy && 
+			 cent->gent->humerusRBone!=-1 && 
+			(cent->gent->client->ps.torsoAnim==BOTH_VS_ATR_G || cent->gent->client->ps.torsoAnim==BOTH_VS_ATF_G))
+		{
+			vec3_t		toEnemy;
+			vec3_t		toEnemyAngles;
+			float		toEnemyDistance;
+			gentity_t*	actor = cent->gent;
+			vec3_t		actorPos;
+			vec3_t		actorAim;
+			vec3_t		actorAngles;
+			float		actorAimDot;
+
+			mdxaBone_t	boltMatrix;
+			vec3_t		boltAngles;
+
+			gi.G2API_GetBoltMatrix( actor->ghoul2, actor->playerModel, actor->humerusRBone, &boltMatrix, vec3_origin, cent->lerpOrigin, cg.time, cgs.model_draw, cent->currentState.modelScale );
+			gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, actorPos );
+
+			VectorSubtract(actorPos, actor->enemy->currentOrigin, toEnemy);
+			toEnemyDistance = VectorNormalize(toEnemy);
+
+			AngleVectors(actor->currentAngles, actorAim, 0, 0);
+			actorAimDot = DotProduct(toEnemy, actorAim);
+
+			if (actorAimDot>0.9f || (actorAimDot<0.1f && actorAimDot>-0.1f))
+			{
+				gi.G2API_GiveMeVectorFromMatrix( boltMatrix, NEGATIVE_Y, actorAim );
+				vectoangles( actorAim, actorAngles );
+				vectoangles( toEnemy, toEnemyAngles );
+				
+				boltAngles[0] = AngleDelta(actorAngles[0], toEnemyAngles[0]);
+				boltAngles[1] = AngleDelta(actorAngles[1], toEnemyAngles[1]);
+				boltAngles[2] = AngleDelta(actorAngles[2], toEnemyAngles[2]);
+
+				BG_G2SetBoneAngles( cent, actor, actor->humerusRBone, boltAngles, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, cgs.model_draw); 
+			}
+		}*/
+	}
+	if ( G_ClassHasBadBones( cent->gent->client->NPC_class ) )
+	{
+		Eorientations oUp, oRt, oFwd;
+		if ( cent->gent->client->NPC_class != CLASS_RANCOR )
+		{//Rancor doesn't use cranium and cervical
+			G_BoneOrientationsForClass( cent->gent->client->NPC_class, "cranium", &oUp, &oRt, &oFwd );
+			BG_G2SetBoneAngles( cent, cent->gent, cent->gent->craniumBone, headAngles, BONE_ANGLES_POSTMULT, oUp, oRt, oFwd, cgs.model_draw );
+			G_BoneOrientationsForClass( cent->gent->client->NPC_class, "cervical", &oUp, &oRt, &oFwd );
+			BG_G2SetBoneAngles( cent, cent->gent, cent->gent->cervicalBone, neckAngles, BONE_ANGLES_POSTMULT, oUp, oRt, oFwd, cgs.model_draw); 
+		}
+		if ( cent->gent->client->NPC_class != CLASS_SABER_DROID )
+		{//saber droid doesn't use thoracic
+			if ( cent->gent->client->NPC_class == CLASS_RANCOR )
+			{
+				thoracicAngles[YAW] = thoracicAngles[ROLL] = 0.0f;
+			}
+			G_BoneOrientationsForClass( cent->gent->client->NPC_class, "thoracic", &oUp, &oRt, &oFwd );
+			BG_G2SetBoneAngles( cent, cent->gent, cent->gent->thoracicBone, thoracicAngles, BONE_ANGLES_POSTMULT, oUp, oRt, oFwd, cgs.model_draw); 
+		}
+	}
+	else
+	{
+		BG_G2SetBoneAngles( cent, cent->gent, cent->gent->craniumBone, headAngles, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, cgs.model_draw );
+		BG_G2SetBoneAngles( cent, cent->gent, cent->gent->cervicalBone, neckAngles, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, cgs.model_draw); 
+		BG_G2SetBoneAngles( cent, cent->gent, cent->gent->thoracicBone, thoracicAngles, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, cgs.model_draw); 
+	}
+}
+
+static void CG_UpdateLookAngles( centity_t *cent, vec3_t lookAngles, float lookSpeed, float minPitch, float maxPitch, float minYaw, float maxYaw, float minRoll, float maxRoll )
+{
+	if ( !cent || !cent->gent || !cent->gent->client )
+	{
+		return;
+	}
+	if ( cent->gent->client->renderInfo.lookingDebounceTime > cg.time )
+	{
+		//clamp so don't get "Exorcist" effect
+		if ( lookAngles[PITCH] > maxPitch )
+		{
+			lookAngles[PITCH] = maxPitch;
+		}
+		else if ( lookAngles[PITCH] < minPitch )
+		{
+			lookAngles[PITCH] = minPitch;
+		}
+		if ( lookAngles[YAW] > maxYaw )
+		{
+			lookAngles[YAW] = maxYaw;
+		}
+		else if ( lookAngles[YAW] < minYaw )
+		{
+			lookAngles[YAW] = minYaw;
+		}
+		if ( lookAngles[ROLL] > maxRoll )
+		{
+			lookAngles[ROLL] = maxRoll;
+		}
+		else if ( lookAngles[ROLL] < minRoll )
+		{
+			lookAngles[ROLL] = minRoll;
+		}
+
+		//slowly lerp to this new value
+		//Remember last headAngles
+		vec3_t	oldLookAngles;
+		VectorCopy( cent->gent->client->renderInfo.lastHeadAngles, oldLookAngles );
+		vec3_t lookAnglesDiff;
+		VectorSubtract( lookAngles, oldLookAngles, lookAnglesDiff );
+
+		for ( int ang = 0; ang < 3; ang++ )
+		{
+			lookAnglesDiff[ang] = AngleNormalize180( lookAnglesDiff[ang] );
+		}
+
+		if( VectorLengthSquared( lookAnglesDiff ) )
+		{
+			lookAngles[PITCH] = AngleNormalize180( oldLookAngles[PITCH]+(lookAnglesDiff[PITCH]*cg.frameInterpolation*lookSpeed) );
+			lookAngles[YAW] = AngleNormalize180( oldLookAngles[YAW]+(lookAnglesDiff[YAW]*cg.frameInterpolation*lookSpeed) );
+			lookAngles[ROLL] = AngleNormalize180( oldLookAngles[ROLL]+(lookAnglesDiff[ROLL]*cg.frameInterpolation*lookSpeed) );
+		}
+	}
+	//Remember current lookAngles next time
+	VectorCopy( lookAngles, cent->gent->client->renderInfo.lastHeadAngles );
+}
+
+/*
+===============
+CG_PlayerAngles
+
+Handles seperate torso motion
+
+  legs pivot based on direction of movement
+
+  head always looks exactly at cent->lerpAngles
+
+  if motion < 20 degrees, show in head only
+  if < 45 degrees, also show in torso
+
+===============
+*/
+extern int PM_TurnAnimForLegsAnim( gentity_t *gent, int anim );
+extern float PM_GetTimeScaleMod( gentity_t *gent );
+static void CG_G2PlayerAngles( centity_t *cent, vec3_t legs[3], vec3_t angles ) 
+{
+	vec3_t		headAngles, neckAngles, chestAngles, thoracicAngles = {0,0,0};//legsAngles, torsoAngles, 
+	vec3_t		ulAngles, llAngles;
+	//float		speed;
+	//vec3_t		velocity;
+	vec3_t		lookAngles, viewAngles;
+	/*
+	float		headYawClampMin, headYawClampMax;
+	float		headPitchClampMin, headPitchClampMax;
+	float		torsoYawSwingTolMin, torsoYawSwingTolMax;
+	float		torsoYawClampMin, torsoYawClampMax;
+	float		torsoPitchSwingTolMin, torsoPitchSwingTolMax;
+	float		torsoPitchClampMin, torsoPitchClampMax;
+	float		legsYawSwingTolMin, legsYawSwingTolMax;
+	float		yawSpeed, maxYawSpeed, lookingSpeed;
+	*/
+	float		lookAngleSpeed = LOOK_TALKING_SPEED;//shut up the compiler
+	//float		swing, scale;
+	//int			i;
+	qboolean	looking = qfalse, talking = qfalse;
+
+	if ( cent->gent 
+		&& (cent->gent->flags&FL_NO_ANGLES) )
+	{//flatten out all bone angles we might have been overriding
+		cent->lerpAngles[PITCH] = cent->lerpAngles[ROLL] = 0;
+		VectorCopy( cent->lerpAngles, angles );
+
+		BG_G2SetBoneAngles( cent, cent->gent, cent->gent->craniumBone, vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, cgs.model_draw ); 
+		BG_G2SetBoneAngles( cent, cent->gent, cent->gent->cervicalBone, vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, cgs.model_draw ); 
+		BG_G2SetBoneAngles( cent, cent->gent, cent->gent->thoracicBone, vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, cgs.model_draw ); 
+
+		cent->pe.torso.pitchAngle = 0;
+		cent->pe.torso.yawAngle = 0;
+		BG_G2SetBoneAngles( cent, cent->gent, cent->gent->upperLumbarBone, vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, cgs.model_draw ); 
+		BG_G2SetBoneAngles( cent, cent->gent, cent->gent->lowerLumbarBone, vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, cgs.model_draw ); 
+
+		cent->pe.legs.pitchAngle = angles[0];
+		cent->pe.legs.yawAngle = angles[1];
+		if ( cent->gent->client )
+		{
+			cent->gent->client->renderInfo.legsYaw = angles[1];
+		}
+		AnglesToAxis( angles, legs );
+		return;
+	}
+	// Dead entity
+	if ( cent->gent && cent->gent->health <= 0 )
+	{
+		if ( cent->gent->hipsBone != -1 )
+		{
+			gi.G2API_StopBoneAnimIndex( &cent->gent->ghoul2[cent->gent->playerModel], cent->gent->hipsBone );
+		}
+
+		VectorCopy( cent->lerpAngles, angles );
+
+		BG_G2SetBoneAngles( cent, cent->gent, cent->gent->craniumBone, vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, cgs.model_draw ); 
+		BG_G2SetBoneAngles( cent, cent->gent, cent->gent->cervicalBone, vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, cgs.model_draw ); 
+		BG_G2SetBoneAngles( cent, cent->gent, cent->gent->thoracicBone, vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, cgs.model_draw ); 
+
+		cent->pe.torso.pitchAngle = 0;
+		cent->pe.torso.yawAngle = 0;
+		BG_G2SetBoneAngles( cent, cent->gent, cent->gent->upperLumbarBone, vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, cgs.model_draw ); 
+		BG_G2SetBoneAngles( cent, cent->gent, cent->gent->lowerLumbarBone, vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, cgs.model_draw ); 
+
+		cent->pe.legs.pitchAngle = angles[0];
+		cent->pe.legs.yawAngle = angles[1];
+		if ( cent->gent->client )
+		{
+			cent->gent->client->renderInfo.legsYaw = angles[1];
+		}
+		AnglesToAxis( angles, legs );
+		return;
+	}
+
+	if ( cent->gent && cent->gent->client 
+		&& (cent->gent->client->NPC_class != CLASS_GONK ) 
+		&& (cent->gent->client->NPC_class != CLASS_INTERROGATOR) 
+		&& (cent->gent->client->NPC_class != CLASS_SENTRY) 
+		&& (cent->gent->client->NPC_class != CLASS_PROBE ) 
+		&& (cent->gent->client->NPC_class != CLASS_R2D2 ) 
+		&& (cent->gent->client->NPC_class != CLASS_R5D2) 
+		&& (cent->gent->client->NPC_class != CLASS_ATST||!cent->gent->s.number) )
+	{// If we are rendering third person, we should just force the player body to always fully face
+		//	whatever way they are looking, otherwise, you can end up with gun shots coming off of the
+		//	gun at angles that just look really wrong.
+
+		//NOTENOTE: shots are coming out of the gun at ridiculous angles. The head & torso
+		//should pitch *some* when looking up and down...
+		VectorCopy( cent->lerpAngles, angles );
+		angles[PITCH] = 0;
+
+		if ( cent->gent->client )
+		{
+			if ( cent->gent->client->NPC_class != CLASS_ATST )
+			{
+				if ( !PM_SpinningSaberAnim( cent->currentState.legsAnim ) )
+				{//don't turn legs if in a spinning saber transition
+					//FIXME: use actual swing/clamp tolerances?
+					if ( cent->gent->client->ps.groundEntityNum != ENTITYNUM_NONE && !PM_InRoll( &cent->gent->client->ps ) )
+					{//on the ground
+						CG_PlayerLegsYawFromMovement( cent, cent->gent->client->ps.velocity, &angles[YAW], cent->lerpAngles[YAW], -60, 60, qtrue );
+					}
+					else
+					{//face legs to front
+						CG_PlayerLegsYawFromMovement( cent, vec3_origin, &angles[YAW], cent->lerpAngles[YAW], -60, 60, qtrue );
+					}
+				}
+			}
+		}
+
+		//VectorClear( viewAngles );
+		VectorCopy( cent->lerpAngles, viewAngles );
+		viewAngles[YAW] = viewAngles[ROLL] = 0;
+		if ( cent->gent && cent->gent->client && cent->gent->client->NPC_class == CLASS_RANCOR )
+		{//rancor uses full pitch
+			if ( cent->gent->count ) 
+			{//don't look up or down at enemy when he's in your hand...
+				viewAngles[PITCH] = 0.0f;
+			}
+			else if ( cent->gent->enemy )
+			{
+				if ( cent->gent->enemy->s.solid == SOLID_BMODEL )
+				{//don't look up or down at architecture?
+					viewAngles[PITCH] = 0.0f;
+				}
+				else if ( cent->gent->client->ps.legsAnim == BOTH_MELEE1 )
+				{//don't look up or down when smashing the ground
+					viewAngles[PITCH] = 0.0f;
+				}
+				else
+				{
+					vec3_t eDir, eAngles, lookFrom;
+					VectorCopy( cent->lerpOrigin, lookFrom );
+					lookFrom[2] += cent->gent->maxs[2]*0.6f;  
+					VectorSubtract( cg_entities[cent->gent->enemy->s.number].lerpOrigin, lookFrom, eDir );
+					vectoangles( eDir, eAngles );
+					viewAngles[PITCH] = AngleNormalize180(eAngles[0]);
+					if ( cent->gent->client->ps.legsAnim == BOTH_ATTACK2 )
+					{//swinging at something on the ground
+						if ( viewAngles[PITCH] > 0.0f )
+						{//don't look down
+							viewAngles[PITCH] = 0.0f;
+						}
+					}
+					else if ( cent->gent->client->ps.legsAnim == BOTH_ATTACK4 )
+					{//in breath attack anim
+						if ( viewAngles[PITCH] > 0.0f )
+						{//don't look down
+							viewAngles[PITCH] = 0.0f;
+						}
+						else
+						{//exaggerate looking up
+							viewAngles[PITCH] *= 2.0f;
+						}
+					}
+					else if ( viewAngles[PITCH] > 0.0f )
+					{//reduce looking down
+						viewAngles[PITCH] *= 0.5f;
+					}
+					//clamp?
+					/*
+					if ( viewAngles[PITCH] > 30.0f )
+					{
+						viewAngles[PITCH] > 30.0f;
+					}
+					if ( viewAngles[PITCH] < -75.0f )
+					{
+						viewAngles[PITCH] = -75.0f;
+					}
+					*/
+				}
+			}
+			else
+			{
+				viewAngles[PITCH] = 0.0f;
+			}
+		}
+		else
+		{
+			viewAngles[PITCH] *= 0.5;
+		}
+		VectorCopy( viewAngles, lookAngles );
+
+	//	if ( cent->gent && !Q_stricmp( "atst", cent->gent->NPC_type ) )
+		if ( cent->gent && cent->gent->client && cent->gent->client->NPC_class == CLASS_ATST )
+		{
+			lookAngles[YAW] = 0;
+			BG_G2SetBoneAngles( cent, cent->gent, cent->gent->craniumBone, lookAngles, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, cgs.model_draw); 
+			VectorCopy( viewAngles, lookAngles );
+		}
+		else
+		{
+			if ( cg_turnAnims.integer && !in_camera && cent->gent->hipsBone >= 0 )
+			{
+				//override the hips bone with a turn anim when turning
+				//and clear it when we're not... does blend from and to parent actually work?
+				int startFrame, endFrame;
+				const qboolean animatingHips = gi.G2API_GetAnimRangeIndex( &cent->gent->ghoul2[cent->gent->playerModel], cent->gent->hipsBone, &startFrame, &endFrame );
+
+				//FIXME: make legs lag behind when turning in place, only play turn anim when legs have to catch up
+				if ( angles[YAW] == cent->pe.legs.yawAngle )
+				{
+					gi.G2API_StopBoneAnimIndex( &cent->gent->ghoul2[cent->gent->playerModel], cent->gent->hipsBone );
+				}
+				else if ( VectorCompare( vec3_origin, cent->gent->client->ps.velocity ) )
+				{//FIXME: because of LegsYawFromMovement, we play the turnAnims when we stop running, which looks really bad.
+					int turnAnim = PM_TurnAnimForLegsAnim( cent->gent, cent->gent->client->ps.legsAnim );
+					if ( turnAnim != -1 && cent->gent->health > 0 )
+					{
+						animation_t *animations = level.knownAnimFileSets[cent->gent->client->clientInfo.animFileIndex].animations;
+												
+						if ( !animatingHips || ( animations[turnAnim].firstFrame != startFrame ) )// only set the anim if we aren't going to do the same animation again
+						{
+							float animSpeed = 50.0f / animations[turnAnim].frameLerp * PM_GetTimeScaleMod( cent->gent );
+
+							gi.G2API_SetBoneAnimIndex( &cent->gent->ghoul2[cent->gent->playerModel], cent->gent->hipsBone,
+								animations[turnAnim].firstFrame, animations[turnAnim].firstFrame+animations[turnAnim].numFrames, 
+								BONE_ANIM_OVERRIDE_LOOP/*|BONE_ANIM_OVERRIDE_FREEZE|BONE_ANIM_BLEND*/, animSpeed, cg.time, -1, 100 );
+						}
+					}
+					else
+					{
+						gi.G2API_StopBoneAnimIndex( &cent->gent->ghoul2[cent->gent->playerModel], cent->gent->hipsBone );
+					}
+				}
+				else
+				{
+					gi.G2API_StopBoneAnimIndex( &cent->gent->ghoul2[cent->gent->playerModel], cent->gent->hipsBone );
+				}
+			}
+
+			CG_G2ClientSpineAngles( cent, viewAngles, angles, thoracicAngles, ulAngles, llAngles );
+		}
+
+		vec3_t	trailingLegsAngles;
+		if ( cent->gent->client && cent->gent->client->NPC_class == CLASS_ATST )
+		{
+			CG_ATSTLegsYaw( cent, trailingLegsAngles );
+			AnglesToAxis( trailingLegsAngles, legs );
+			angles[YAW] = trailingLegsAngles[YAW];
+		}
+		/*
+		else if ( cent->gent->client && cent->gent->client->NPC_class == CLASS_WAMPA )
+		{
+			CG_ATSTLegsYaw( cent, trailingLegsAngles );
+			AnglesToAxis( trailingLegsAngles, legs );
+			angles[YAW] = trailingLegsAngles[YAW];
+		}
+		*/
+		// either riding a vehicle or we are a vehicle
+		if ( cent->gent && cent->gent->client && cent->gent->client->NPC_class == CLASS_VEHICLE )
+		{//you are a vehicle, just use your lerpAngles which comes from m_vOrientation
+			cent->pe.legs.yawing = qfalse;
+			cent->pe.legs.yawAngle = cent->lerpAngles[YAW];
+			if ( cent->gent->client )
+			{
+				cent->gent->client->renderInfo.legsYaw = cent->lerpAngles[YAW];
+			}
+			AnglesToAxis( cent->lerpAngles, legs );
+			if ( cent->gent->m_pVehicle )
+			{
+				if ( cent->gent->m_pVehicle->m_pVehicleInfo )
+				{
+                    if ( cent->gent->m_pVehicle->m_pVehicleInfo->type == VH_FIGHTER
+						|| cent->gent->m_pVehicle->m_pVehicleInfo->type == VH_SPEEDER )
+					{
+						VectorCopy( cent->lerpAngles, angles );
+					}
+				}
+			}
+		}
+		else if ( G_IsRidingVehicle( cent->gent ) )
+		{//riding a vehicle, get the vehicle's lerpAngles (which comes from m_vOrientation)
+			cent->pe.legs.yawing = qfalse;
+			cent->pe.legs.yawAngle = cg_entities[cent->gent->owner->s.number].lerpAngles[YAW];
+			if ( cent->gent->client )
+			{
+				cent->gent->client->renderInfo.legsYaw = cg_entities[cent->gent->owner->s.number].lerpAngles[YAW];
+			}
+			AnglesToAxis( cg_entities[cent->gent->owner->s.number].lerpAngles, legs );
+		}
+		else
+		{
+
+			//set the legs.yawing field so we play the turning anim when turning in place
+			if ( angles[YAW] == cent->pe.legs.yawAngle )
+			{
+				cent->pe.legs.yawing = qfalse;
+			}
+			else
+			{
+				cent->pe.legs.yawing = qtrue;
+			}
+			cent->pe.legs.yawAngle = angles[YAW];
+			if ( cent->gent->client )
+			{
+				cent->gent->client->renderInfo.legsYaw = angles[YAW];
+			}
+			if ( ((cent->gent->client->ps.eFlags&EF_FORCE_GRIPPED)||((cent->gent->client->NPC_class == CLASS_BOBAFETT||cent->gent->client->NPC_class == CLASS_ROCKETTROOPER)&&cent->gent->client->moveType==MT_FLYSWIM))
+				&& cent->gent->client->ps.groundEntityNum == ENTITYNUM_NONE )
+			{
+				vec3_t	centFwd, centRt;
+				float	divFactor = 1.0f;
+				if ( (cent->gent->client->NPC_class == CLASS_BOBAFETT||cent->gent->client->NPC_class == CLASS_ROCKETTROOPER)
+					&& cent->gent->client->moveType == MT_FLYSWIM )
+				{
+					divFactor = 3.0f;
+				}
+
+				AngleVectors( cent->lerpAngles, centFwd, centRt, NULL );
+				angles[PITCH] = AngleNormalize180( DotProduct( cent->gent->client->ps.velocity, centFwd )/(2*divFactor) );
+				if ( angles[PITCH] > 90 )
+				{
+					angles[PITCH] = 90;
+				}
+				else if ( angles[PITCH] < -90 )
+				{
+					angles[PITCH] = -90;
+				}
+				angles[ROLL] = AngleNormalize180( DotProduct( cent->gent->client->ps.velocity, centRt )/(10*divFactor) );
+				if ( angles[ROLL] > 90 )
+				{
+					angles[ROLL] = 90;
+				}
+				else if ( angles[ROLL] < -90 )
+				{
+					angles[ROLL] = -90;
+				}
+			}
+			AnglesToAxis( angles, legs );
+		}
+
+		//clamp relative to forward of cervical bone!
+		if ( cent->gent && cent->gent->client && cent->gent->client->NPC_class == CLASS_ATST )
+		{
+			looking = qfalse;
+			VectorCopy( vec3_origin, chestAngles );
+		}
+		else
+		{
+			//look at lookTarget!
+			float	lookingSpeed = 0.3f;
+			looking = CG_CheckLookTarget( cent, lookAngles, &lookingSpeed );
+			//Now add head bob when talking
+			talking = CG_AddHeadBob( cent, lookAngles );
+
+			//NOTE: previously, lookAngleSpeed was always 0.25f for the player
+			//Figure out how fast head should be turning
+			if ( cent->pe.torso.yawing || cent->pe.torso.pitching )
+			{//If torso is turning, we want to turn head just as fast
+				if ( cent->gent->NPC )
+				{
+					lookAngleSpeed = cent->gent->NPC->stats.yawSpeed/150;//about 0.33 normally
+				}
+				else
+				{
+					lookAngleSpeed = CG_SWINGSPEED;
+				}
+			}
+			else if ( talking )
+			{//Slow for head bobbing
+				lookAngleSpeed = LOOK_TALKING_SPEED;
+			}
+			else if ( looking )
+			{//Not talking, set it up for looking at enemy, CheckLookTarget will scale it down if neccessary
+				lookAngleSpeed = lookingSpeed;
+			}
+			else if ( cent->gent->client->renderInfo.lookingDebounceTime > cg.time )
+			{//Not looking, not talking, head is returning from a talking head bob, use talking speed
+				lookAngleSpeed = LOOK_TALKING_SPEED;
+			}
+
+			if ( looking || talking )
+			{//want to keep doing this lerp behavior for a full second after stopped looking (so don't snap)
+				//we should have a relative look angle, normalized to 180
+				cent->gent->client->renderInfo.lookingDebounceTime = cg.time + 1000;
+			}
+			else
+			{
+				//still have a relative look angle from above
+			}
+
+			if ( cent->gent->client->NPC_class == CLASS_RANCOR )
+			{//always use the viewAngles we calced
+				VectorCopy( viewAngles, lookAngles );
+			}
+			CG_UpdateLookAngles( cent, lookAngles, lookAngleSpeed, -50.0f, 50.0f, -70.0f, 70.0f, -30.0f, 30.0f );
+		}
+
+		if ( cent->gent && cent->gent->client && cent->gent->client->NPC_class == CLASS_ATST )
+		{
+			VectorCopy( cent->lerpAngles, lookAngles );
+			lookAngles[0] = lookAngles[2] = 0;
+			lookAngles[YAW] -= trailingLegsAngles[YAW];
+			BG_G2SetBoneAngles( cent, cent->gent, cent->gent->thoracicBone, lookAngles, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, cgs.model_draw); 
+		}
+		else
+		{
+			vec3_t headClampMinAngles = {-25,-55,-10}, headClampMaxAngles = {50,50,10};
+			CG_G2ClientNeckAngles( cent, lookAngles, headAngles, neckAngles, thoracicAngles, headClampMinAngles, headClampMaxAngles );
+		}
+		return;
+	}
+	// All other entities
+	else if ( cent->gent && cent->gent->client )
+	{
+		if ( (cent->gent->client->NPC_class == CLASS_PROBE ) 
+			|| (cent->gent->client->NPC_class == CLASS_R2D2 ) 
+			|| (cent->gent->client->NPC_class == CLASS_R5D2) 
+			|| (cent->gent->client->NPC_class == CLASS_RANCOR) 
+			|| (cent->gent->client->NPC_class == CLASS_WAMPA) 
+			|| (cent->gent->client->NPC_class == CLASS_ATST) )
+		{
+			VectorCopy( cent->lerpAngles, angles );
+			angles[PITCH] = 0;
+
+			//FIXME: use actual swing/clamp tolerances?
+			if ( cent->gent->client->ps.groundEntityNum != ENTITYNUM_NONE )
+			{//on the ground
+				CG_PlayerLegsYawFromMovement( cent, cent->gent->client->ps.velocity, &angles[YAW], cent->lerpAngles[YAW], -60, 60, qtrue );
+			}
+			else
+			{//face legs to front
+				CG_PlayerLegsYawFromMovement( cent, vec3_origin, &angles[YAW], cent->lerpAngles[YAW], -60, 60, qtrue );
+			}
+
+			VectorCopy( cent->lerpAngles, viewAngles );
+//			viewAngles[YAW] = viewAngles[ROLL] = 0;
+			viewAngles[PITCH] *= 0.5;
+			VectorCopy( viewAngles, lookAngles );
+
+			lookAngles[1] = 0;
+
+			if ( cent->gent->client->NPC_class == CLASS_ATST )
+			{//body pitch
+				BG_G2SetBoneAngles( cent, cent->gent, cent->gent->thoracicBone, lookAngles, BONE_ANGLES_POSTMULT,POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, cgs.model_draw);
+			}
+
+			VectorCopy( viewAngles, lookAngles );
+
+			vec3_t	trailingLegsAngles;
+			if ( cent->gent && cent->gent->client && cent->gent->client->NPC_class == CLASS_ATST )
+			{
+				CG_ATSTLegsYaw( cent, trailingLegsAngles );
+				AnglesToAxis( trailingLegsAngles, legs );
+			}
+			/*
+			else if ( cent->gent->client 
+				&& (cent->gent->client->NPC_class == CLASS_WAMPA||cent->gent->client->NPC_class == CLASS_RANCOR) )
+			{
+				CG_ATSTLegsYaw( cent, trailingLegsAngles );
+				AnglesToAxis( trailingLegsAngles, legs );
+			}
+			*/
+			else
+			{
+				//FIXME: this needs to properly set the legs.yawing field so we don't erroneously play the turning anim, but we do play it when turning in place
+				if ( angles[YAW] == cent->pe.legs.yawAngle )
+				{
+					cent->pe.legs.yawing = qfalse;
+				}
+				else
+				{
+					cent->pe.legs.yawing = qtrue;
+				}
+
+				cent->pe.legs.yawAngle = angles[YAW];
+				if ( cent->gent->client )
+				{
+					cent->gent->client->renderInfo.legsYaw = angles[YAW];
+				}
+				AnglesToAxis( angles, legs );
+			}
+
+//			if ( cent->gent && cent->gent->client && cent->gent->client->NPC_class == CLASS_ATST )
+//			{
+//				looking = qfalse;
+//			}
+//			else
+			{	//look at lookTarget!
+				//FIXME: snaps to side when lets go of lookTarget... ?
+				float	lookingSpeed = 0.3f;
+				looking = CG_CheckLookTarget( cent, lookAngles, &lookingSpeed );
+				lookAngles[PITCH] = lookAngles[ROLL] = 0;//droids can't pitch or roll their heads
+				if ( looking )
+				{//want to keep doing this lerp behavior for a full second after stopped looking (so don't snap)
+					cent->gent->client->renderInfo.lookingDebounceTime = cg.time + 1000;
+				}
+			}
+			if ( cent->gent->client->renderInfo.lookingDebounceTime > cg.time )
+			{	//adjust for current body orientation
+				lookAngles[YAW] -= cent->pe.torso.yawAngle;
+				lookAngles[YAW] -= cent->pe.legs.yawAngle;
+
+				//normalize
+				lookAngles[YAW] = AngleNormalize180( lookAngles[YAW] );
+
+				//slowly lerp to this new value
+				//Remember last headAngles
+				vec3_t	oldLookAngles;
+				VectorCopy( cent->gent->client->renderInfo.lastHeadAngles, oldLookAngles );
+				if( VectorCompare( oldLookAngles, lookAngles ) == qfalse )
+				{
+					//FIXME: This clamp goes off viewAngles,
+					//but really should go off the tag_torso's axis[0] angles, no?
+					lookAngles[YAW] = oldLookAngles[YAW]+(lookAngles[YAW]-oldLookAngles[YAW])*cg.frameInterpolation*0.25;
+				}
+				//Remember current lookAngles next time
+				VectorCopy( lookAngles, cent->gent->client->renderInfo.lastHeadAngles );
+			}
+			else
+			{//Remember current lookAngles next time
+				VectorCopy( lookAngles, cent->gent->client->renderInfo.lastHeadAngles );
+			}
+			if ( cent->gent->client->NPC_class == CLASS_ATST )
+			{
+				VectorCopy( cent->lerpAngles, lookAngles );
+				lookAngles[0] = lookAngles[2] = 0;
+				lookAngles[YAW] -= trailingLegsAngles[YAW];
+			}
+			else
+			{
+				lookAngles[PITCH] = lookAngles[ROLL] = 0;
+				lookAngles[YAW] -= cent->pe.legs.yawAngle;
+			}
+			if ( cent->gent->client->NPC_class == CLASS_WAMPA )
+			{
+				Eorientations oUp, oRt, oFwd;
+				G_BoneOrientationsForClass( cent->gent->client->NPC_class, "cranium", &oUp, &oRt, &oFwd );
+				BG_G2SetBoneAngles( cent, cent->gent, cent->gent->craniumBone, lookAngles, BONE_ANGLES_POSTMULT, oUp, oRt, oFwd, cgs.model_draw );
+			}
+			else
+			{
+				BG_G2SetBoneAngles( cent, cent->gent, cent->gent->craniumBone, lookAngles, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, cgs.model_draw); 
+			}
+			//return;
+		}
+		else//if ( (cent->gent->client->NPC_class == CLASS_GONK ) || (cent->gent->client->NPC_class == CLASS_INTERROGATOR) || (cent->gent->client->NPC_class == CLASS_SENTRY) )
+		{
+			VectorCopy( cent->lerpAngles, angles );
+			cent->pe.torso.pitchAngle = 0;
+			cent->pe.torso.yawAngle = 0;
+			cent->pe.legs.pitchAngle = angles[0];
+			cent->gent->client->renderInfo.legsYaw = cent->pe.legs.yawAngle = angles[1];
+			AnglesToAxis( angles, legs );
+			//return;
+		}
+	}
+}
+
+static void CG_PlayerAngles( centity_t *cent, vec3_t legs[3], vec3_t torso[3], vec3_t head[3] ) 
+{
+	vec3_t		legsAngles, torsoAngles, headAngles;
+	vec3_t		lookAngles, viewAngles;
+	float		headYawClampMin, headYawClampMax;
+	float		headPitchClampMin, headPitchClampMax;
+	float		torsoYawSwingTolMin, torsoYawSwingTolMax;
+	float		torsoYawClampMin, torsoYawClampMax;
+	float		torsoPitchSwingTolMin, torsoPitchSwingTolMax;
+	float		torsoPitchClampMin, torsoPitchClampMax;
+	float		legsYawSwingTolMin, legsYawSwingTolMax;
+	float		maxYawSpeed, yawSpeed, lookingSpeed;
+	float		lookAngleSpeed = LOOK_TALKING_SPEED;//shut up the compiler
+	float		swing, scale;
+	int			i;
+	qboolean	looking = qfalse, talking = qfalse;
+
+	if ( cg.renderingThirdPerson && cent->gent && cent->gent->s.number == 0 )
+	{
+		// If we are rendering third person, we should just force the player body to always fully face
+		//	whatever way they are looking, otherwise, you can end up with gun shots coming off of the
+		//	gun at angles that just look really wrong.
+
+		//NOTENOTE: shots are coming out of the gun at ridiculous angles. The head & torso
+		//should pitch *some* when looking up and down...
+
+		//VectorClear( viewAngles );
+		VectorCopy( cent->lerpAngles, viewAngles );
+		
+		viewAngles[YAW] = viewAngles[ROLL] = 0;
+		viewAngles[PITCH] *= 0.5;
+		AnglesToAxis( viewAngles, head );
+		
+		viewAngles[PITCH] *= 0.75;
+		cent->pe.torso.pitchAngle = viewAngles[PITCH];
+		cent->pe.torso.yawAngle = viewAngles[YAW];
+		AnglesToAxis( viewAngles, torso );
+
+		VectorCopy( cent->lerpAngles, lookAngles );
+		lookAngles[PITCH] = 0;
+
+		//FIXME: this needs to properly set the legs.yawing field so we don't erroneously play the turning anim, but we do play it when turning in place
+		if ( lookAngles[YAW] == cent->pe.legs.yawAngle )
+		{
+			cent->pe.legs.yawing = qfalse;
+		}
+		else
+		{
+			cent->pe.legs.yawing = qtrue;
+		}
+
+		if ( cent->gent->client->ps.velocity[0] || cent->gent->client->ps.velocity[1] )
+		{
+			float	moveYaw;
+			moveYaw = vectoyaw( cent->gent->client->ps.velocity );
+			lookAngles[YAW] = cent->lerpAngles[YAW] + AngleDelta( cent->lerpAngles[YAW], moveYaw );
+		}
+
+		cent->pe.legs.yawAngle = lookAngles[YAW];
+		if ( cent->gent->client )
+		{
+			cent->gent->client->renderInfo.legsYaw = lookAngles[YAW];
+		}
+		AnglesToAxis( lookAngles, legs );
+
+		return;
+	}
+
+	if ( cent->currentState.clientNum != 0 )
+	{
+		headYawClampMin = -cent->gent->client->renderInfo.headYawRangeLeft;
+		headYawClampMax = cent->gent->client->renderInfo.headYawRangeRight;
+		//These next two are only used for a calc below- this clamp is done in PM_UpdateViewAngles
+		headPitchClampMin = -cent->gent->client->renderInfo.headPitchRangeUp;
+		headPitchClampMax = cent->gent->client->renderInfo.headPitchRangeDown;
+
+		torsoYawSwingTolMin = headYawClampMin * 0.3;
+		torsoYawSwingTolMax = headYawClampMax * 0.3;
+		torsoPitchSwingTolMin = headPitchClampMin * 0.5;
+		torsoPitchSwingTolMax =  headPitchClampMax * 0.5;
+		torsoYawClampMin = -cent->gent->client->renderInfo.torsoYawRangeLeft;
+		torsoYawClampMax = cent->gent->client->renderInfo.torsoYawRangeRight;
+		torsoPitchClampMin = -cent->gent->client->renderInfo.torsoPitchRangeUp;
+		torsoPitchClampMax = cent->gent->client->renderInfo.torsoPitchRangeDown;
+
+		legsYawSwingTolMin = torsoYawClampMin * 0.5;
+		legsYawSwingTolMax = torsoYawClampMax * 0.5;
+
+		if ( cent->gent && cent->gent->next_roff_time && cent->gent->next_roff_time >= cg.time )
+		{//Following a roff, body must keep up with head, yaw-wise
+			headYawClampMin = 
+			headYawClampMax = 
+			torsoYawSwingTolMin = 
+			torsoYawSwingTolMax = 
+			torsoYawClampMin = 
+			torsoYawClampMax = 
+			legsYawSwingTolMin = 
+			legsYawSwingTolMax = 0;
+		}
+
+		yawSpeed = maxYawSpeed = cent->gent->NPC->stats.yawSpeed/150;//about 0.33 normally
+	}
+	else
+	{
+		headYawClampMin = -70;
+		headYawClampMax = 70;
+		
+		//These next two are only used for a calc below- this clamp is done in PM_UpdateViewAngles
+		headPitchClampMin = -90;
+		headPitchClampMax = 90;
+
+		torsoYawSwingTolMin = -90;
+		torsoYawSwingTolMax = 90;
+		torsoPitchSwingTolMin = -90;
+		torsoPitchSwingTolMax = 90;
+		torsoYawClampMin = -90;
+		torsoYawClampMax = 90;
+		torsoPitchClampMin = -90;
+		torsoPitchClampMax = 90;
+
+		legsYawSwingTolMin = -90;
+		legsYawSwingTolMax = 90;
+
+		yawSpeed = maxYawSpeed = CG_SWINGSPEED;
+	}
+	
+	if(yawSpeed <= 0)
+	{//Just in case
+		yawSpeed = 0.5f;	//was 0.33
+	}
+
+	lookingSpeed = yawSpeed;
+
+	VectorCopy( cent->lerpAngles, headAngles );
+	headAngles[YAW] = AngleNormalize360( headAngles[YAW] );
+	VectorClear( legsAngles );
+	VectorClear( torsoAngles );
+
+	// --------- yaw -------------
+
+	//Clamp and swing the legs
+	legsAngles[YAW] = headAngles[YAW];
+	
+	if(cent->gent->client->renderInfo.renderFlags & RF_LOCKEDANGLE)
+	{
+		cent->gent->client->renderInfo.legsYaw = cent->pe.legs.yawAngle = cent->gent->client->renderInfo.lockYaw;
+		cent->pe.legs.yawing = qfalse;
+		legsAngles[YAW] = cent->pe.legs.yawAngle;
+	}
+	else
+	{
+		qboolean alwaysFace = qfalse;
+		if ( cent->gent && cent->gent->health > 0 )
+		{
+			if ( cent->gent->enemy )
+			{
+				alwaysFace = qtrue;
+			}
+			if ( CG_PlayerLegsYawFromMovement( cent, cent->gent->client->ps.velocity, &legsAngles[YAW], headAngles[YAW], torsoYawClampMin, torsoYawClampMax, alwaysFace ) )
+			{
+				if ( legsAngles[YAW] == cent->pe.legs.yawAngle )
+				{
+					cent->pe.legs.yawing = qfalse;
+				}
+				else
+				{
+					cent->pe.legs.yawing = qtrue;
+				}
+				cent->pe.legs.yawAngle = legsAngles[YAW];
+				if ( cent->gent->client )
+				{
+					cent->gent->client->renderInfo.legsYaw = legsAngles[YAW];
+				}
+			}
+			else
+			{
+				CG_SwingAngles( legsAngles[YAW], legsYawSwingTolMin, legsYawSwingTolMax, torsoYawClampMin, torsoYawClampMax, maxYawSpeed, &cent->pe.legs.yawAngle, &cent->pe.legs.yawing );
+				legsAngles[YAW] = cent->pe.legs.yawAngle;
+				if ( cent->gent->client )
+				{
+					cent->gent->client->renderInfo.legsYaw = legsAngles[YAW];
+				}
+			}
+		}
+		else
+		{
+			CG_SwingAngles( legsAngles[YAW], legsYawSwingTolMin, legsYawSwingTolMax, torsoYawClampMin, torsoYawClampMax, maxYawSpeed, &cent->pe.legs.yawAngle, &cent->pe.legs.yawing );
+			legsAngles[YAW] = cent->pe.legs.yawAngle;
+			if ( cent->gent->client )
+			{
+				cent->gent->client->renderInfo.legsYaw = legsAngles[YAW];
+			}
+		}
+	}
+
+	/*
+	legsAngles[YAW] = cent->pe.legs.yawAngle;
+	if ( cent->gent->client )
+	{
+		cent->gent->client->renderInfo.legsYaw = legsAngles[YAW];
+	}
+	*/
+	
+	// torso
+	// If applicable, swing the lower parts to catch up with the head
+	CG_SwingAngles( headAngles[YAW], torsoYawSwingTolMin, torsoYawSwingTolMax, headYawClampMin, headYawClampMax, yawSpeed, &cent->pe.torso.yawAngle, &cent->pe.torso.yawing);
+	torsoAngles[YAW] = cent->pe.torso.yawAngle;
+
+	// ---------- pitch -----------
+
+	//As the body twists to its extents, the back tends to arch backwards
+	
+
+	float dest;
+	// only show a fraction of the pitch angle in the torso
+	if ( headAngles[PITCH] > 180 ) 
+	{
+		dest = (-360 + headAngles[PITCH]) * 0.75;
+	} 
+	else 
+	{
+		dest = headAngles[PITCH] * 0.75;
+	}
+
+	CG_SwingAngles( dest, torsoPitchSwingTolMin, torsoPitchSwingTolMax, torsoPitchClampMin, torsoPitchClampMax, 0.1f, &cent->pe.torso.pitchAngle, &cent->pe.torso.pitching );
+	torsoAngles[PITCH] = cent->pe.torso.pitchAngle;
+	// --------- roll -------------
+
+	// pain twitch - FIXME: don't do this if you have no head (like droids?)
+	// Maybe need to have clamp angles for roll as well as pitch and yaw?
+	//CG_AddPainTwitch( cent, torsoAngles );
+
+	//----------- Special head looking ---------------
+
+	//FIXME: to clamp the head angles, figure out tag_head's offset from tag_torso and add
+	//	that to whatever offset we're getting here... so turning the head in an
+	//	anim that also turns the head doesn't allow the head to turn out of range.
+
+	//Start with straight ahead
+	VectorCopy( headAngles, viewAngles );
+	VectorCopy( headAngles, lookAngles );
+
+	//Remember last headAngles
+	VectorCopy( cent->gent->client->renderInfo.lastHeadAngles, headAngles );
+
+	//See if we're looking at someone/thing
+	looking = CG_CheckLookTarget( cent, lookAngles, &lookingSpeed );
+
+	//Now add head bob when talking
+/*	if ( cent->gent->client->clientInfo.extensions )
+	{
+		talking = CG_AddHeadBob( cent, lookAngles );
+	}
+*/
+	//Figure out how fast head should be turning
+	if ( cent->pe.torso.yawing || cent->pe.torso.pitching )
+	{//If torso is turning, we want to turn head just as fast
+		lookAngleSpeed = yawSpeed;
+	}
+	else if ( talking )
+	{//Slow for head bobbing
+		lookAngleSpeed = LOOK_TALKING_SPEED;
+	}
+	else if ( looking )
+	{//Not talking, set it up for looking at enemy, CheckLookTarget will scale it down if neccessary
+		lookAngleSpeed = lookingSpeed;
+	}
+	else if ( cent->gent->client->renderInfo.lookingDebounceTime > cg.time )
+	{//Not looking, not talking, head is returning from a talking head bob, use talking speed
+		lookAngleSpeed = LOOK_TALKING_SPEED;
+	}
+
+	if ( looking || talking )
+	{//Keep this type of looking for a second after stopped looking
+		cent->gent->client->renderInfo.lookingDebounceTime = cg.time + 1000;
+	}
+	
+	if ( cent->gent->client->renderInfo.lookingDebounceTime > cg.time )
+	{
+		//Calc our actual desired head angles
+		for ( i = 0; i < 3; i++ )
+		{
+			lookAngles[i] = AngleNormalize360( cent->gent->client->renderInfo.headBobAngles[i] + lookAngles[i] );
+		}
+
+		if( VectorCompare( headAngles, lookAngles ) == qfalse )
+		{
+			//FIXME: This clamp goes off viewAngles,
+			//but really should go off the tag_torso's axis[0] angles, no?
+			CG_UpdateAngleClamp( lookAngles[PITCH], headPitchClampMin/1.25, headPitchClampMax/1.25, lookAngleSpeed, &headAngles[PITCH], viewAngles[PITCH] );
+			CG_UpdateAngleClamp( lookAngles[YAW], headYawClampMin/1.25, headYawClampMax/1.25, lookAngleSpeed, &headAngles[YAW], viewAngles[YAW] );
+			CG_UpdateAngleClamp( lookAngles[ROLL], -10, 10, lookAngleSpeed, &headAngles[ROLL], viewAngles[ROLL] );
+		}
+
+		if ( !cent->gent->enemy || cent->gent->enemy->s.number != cent->gent->client->renderInfo.lookTarget )
+		{
+			//NOTE: Hacky, yes, I know, but necc.  
+			//We want to turn the body to follow the lookTarget 
+			//ONLY IF WE DON'T HAVE AN ENEMY OR OUR ENEMY IS NOT OUR LOOKTARGET
+			//This is the piece of code that was making the enemies not face where
+			//they were actually aiming.
+
+			//Yaw change
+			swing = AngleSubtract( legsAngles[YAW], headAngles[YAW] );
+			scale = fabs( swing ) / ( torsoYawClampMax + 0.01 );	//NOTENOTE: Some ents have a clamp of 0, which is bad for division
+
+			scale *= LOOK_SWING_SCALE;
+			torsoAngles[YAW] = legsAngles[YAW] - ( swing * scale );
+
+			//Pitch change
+			swing = AngleSubtract( legsAngles[PITCH], headAngles[PITCH] );
+			scale = fabs( swing ) / ( torsoPitchClampMax + 0.01 );	//NOTENOTE: Some ents have a clamp of 0, which is bad for division
+
+			scale *= LOOK_SWING_SCALE;
+			torsoAngles[PITCH] = legsAngles[PITCH] - ( swing * scale );	
+		}
+	}
+	else
+	{//Look straight ahead
+		VectorCopy( viewAngles, headAngles );
+	}
+
+	//Remember current headAngles next time
+	VectorCopy( headAngles, cent->gent->client->renderInfo.lastHeadAngles );
+
+	//-------------------------------------------------------------
+
+	// pull the angles back out of the hierarchial chain
+	AnglesSubtract( headAngles, torsoAngles, headAngles );
+	AnglesSubtract( torsoAngles, legsAngles, torsoAngles );
+	AnglesToAxis( legsAngles, legs );
+	AnglesToAxis( torsoAngles, torso );
+	AnglesToAxis( headAngles, head );
+}
+
+
+//==========================================================================
+
+
+/*
+===============
+CG_TrailItem
+===============
+*/
+/*
+static void CG_TrailItem( centity_t *cent, qhandle_t hModel ) {
+	refEntity_t		ent;
+	vec3_t			angles;
+	vec3_t			axis[3];
+
+	VectorCopy( cent->lerpAngles, angles );
+	angles[PITCH] = 0;
+	angles[ROLL] = 0;
+	AnglesToAxis( angles, axis );
+
+	memset( &ent, 0, sizeof( ent ) );
+	VectorMA( cent->lerpOrigin, -24, axis[0], ent.origin );
+	ent.origin[2] += 20;
+	VectorScale( cg.autoAxis[0], 0.75, ent.axis[0] );
+	VectorScale( cg.autoAxis[1], 0.75, ent.axis[1] );
+	VectorScale( cg.autoAxis[2], 0.75, ent.axis[2] );
+	ent.hModel = hModel;
+	cgi_R_AddRefEntityToScene( &ent );
+}
+*/
+
+/*
+===============
+CG_PlayerPowerups
+===============
+*/
+extern void CG_Seeker( centity_t *cent );
+static void CG_PlayerPowerups( centity_t *cent ) 
+{
+	if ( !cent->currentState.powerups )
+	{
+		return;
+	}
+/*
+
+	// quad gives a dlight
+	if ( cent->currentState.powerups & ( 1 << PW_QUAD ) ) {
+		cgi_R_AddLightToScene( cent->lerpOrigin, 200 + (rand()&31), 0.2, 0.2, 1 );
+	}
+
+	// redflag
+	if ( cent->currentState.powerups & ( 1 << PW_REDFLAG ) ) {
+		CG_TrailItem( cent, cgs.media.redFlagModel );
+		cgi_R_AddLightToScene( cent->lerpOrigin, 200 + (rand()&31), 1, 0.2, 0.2 );
+	}
+
+	// blueflag
+	if ( cent->currentState.powerups & ( 1 << PW_BLUEFLAG ) ) {
+		CG_TrailItem( cent, cgs.media.blueFlagModel );
+		cgi_R_AddLightToScene( cent->lerpOrigin, 200 + (rand()&31), 0.2, 0.2, 1 );
+	}
+*/
+	// invul gives a dlight
+//	if ( cent->currentState.powerups & ( 1 << PW_BATTLESUIT ) ) 
+//	{
+//		cgi_R_AddLightToScene( cent->lerpOrigin, 200 + (rand()&31), 0.8f, 0.8f, 0.2f );
+//	}
+
+	// seeker coolness
+/*	if ( cent->currentState.powerups & ( 1 << PW_SEEKER ) )
+	{
+//		CG_Seeker(cent);
+	}*/
+}
+
+#define	SHADOW_DISTANCE		128
+static qboolean _PlayerShadow( const vec3_t origin, const float orientation, float *const shadowPlane, const float radius, qhandle_t markShader ) {
+	vec3_t		end, mins = {-7, -7, 0}, maxs = {7, 7, 2};
+	trace_t		trace;
+	float		alpha;
+
+	// send a trace down from the player to the ground
+	VectorCopy( origin, end );
+	end[2] -= SHADOW_DISTANCE;
+
+	cgi_CM_BoxTrace( &trace, origin, end, mins, maxs, 0, MASK_PLAYERSOLID );
+
+	// no shadow if too high
+	if ( trace.fraction == 1.0 ) {
+		return qfalse;
+	}
+
+	*shadowPlane = trace.endpos[2] + 1;
+
+	// no mark for stencil or projection shadows
+	if ( cg_shadows.integer == 1 
+		|| (in_camera && cg_shadows.integer == 2) )//don't want stencil shadows during a cinematic
+	{	
+		// fade the shadow out with height
+		alpha = 1.0 - trace.fraction;
+
+		// add the mark as a temporary, so it goes directly to the renderer
+		// without taking a spot in the cg_marks array
+		CG_ImpactMark( markShader, trace.endpos, trace.plane.normal, 
+			orientation, 1,1,1,alpha, qfalse, radius, qtrue );
+	}
+	return qtrue;
+}
+
+/*
+===============
+CG_PlayerShadow
+
+Returns the Z component of the surface being shadowed
+
+  should it return a full plane instead of a Z?
+===============
+*/
+static qboolean CG_PlayerShadow( centity_t *const cent, float *const shadowPlane ) {
+	*shadowPlane = 0;
+
+	if ( cg_shadows.integer == 0 ) {
+		return qfalse;
+	}
+
+	// no shadows when cloaked
+	if ( cent->currentState.powerups & ( 1 << PW_CLOAKED )) 
+	{
+		return qfalse;
+	}
+
+	if ( cent->gent->client->NPC_class == CLASS_SAND_CREATURE )
+	{//sand creatures have no shadow
+		return qfalse;
+	}
+
+	vec3_t rootOrigin;
+	vec3_t tempAngles;
+	tempAngles[PITCH]	= 0;
+	tempAngles[YAW]		= cent->pe.legs.yawAngle;
+	tempAngles[ROLL]	= 0;
+	if (cent->gent->rootBone>=0 && cent->gent->ghoul2.IsValid() && cent->gent->ghoul2[0].animModelIndexOffset)//If it has an animOffset it's a cinematic anim
+	{	//i might be running out of my bounding box, so get my root origin
+		mdxaBone_t	boltMatrix;
+		gi.G2API_GetBoltMatrix( cent->gent->ghoul2, cent->gent->playerModel, cent->gent->rootBone, 
+				&boltMatrix, tempAngles, cent->lerpOrigin, 
+				cg.time, cgs.model_draw, cent->currentState.modelScale);
+		gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, rootOrigin );
+	}
+	else
+	{
+		VectorCopy(cent->lerpOrigin,rootOrigin);
+	}
+
+	if ( DistanceSquared( cg.refdef.vieworg, rootOrigin ) > cg_shadowCullDistance.value * cg_shadowCullDistance.value )
+	{
+		// Shadow is too far away, don't do any traces, don't do any marks...blah
+		return qfalse;
+	}
+
+	if (cent->gent->client->NPC_class == CLASS_ATST)
+	{
+		qboolean bShadowed;
+		mdxaBone_t	boltMatrix;
+		vec3_t sideOrigin;
+		
+		gi.G2API_GetBoltMatrix( cent->gent->ghoul2, cent->gent->playerModel, cent->gent->footLBolt, 
+				&boltMatrix, tempAngles, cent->lerpOrigin, 
+				cg.time, cgs.model_draw, cent->currentState.modelScale);
+		gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, sideOrigin );
+		sideOrigin[2] += 30;	//fudge up a bit for coplaner
+		bShadowed = _PlayerShadow(sideOrigin, 0, shadowPlane, 28, cgs.media.shadowMarkShader);
+		
+		gi.G2API_GetBoltMatrix( cent->gent->ghoul2, cent->gent->playerModel, cent->gent->footRBolt, 
+				&boltMatrix, tempAngles, cent->lerpOrigin, cg.time, 
+				cgs.model_draw, cent->currentState.modelScale);
+		gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, sideOrigin );
+		sideOrigin[2] += 30;	//fudge up a bit for coplaner
+		bShadowed = _PlayerShadow(sideOrigin, 0, shadowPlane, 28, cgs.media.shadowMarkShader) || bShadowed;
+
+		bShadowed =  _PlayerShadow(rootOrigin, cent->pe.legs.yawAngle, shadowPlane, 64, cgs.media.shadowMarkShader) || bShadowed;
+		return bShadowed;
+	}
+	else if ( cent->gent->client->NPC_class == CLASS_RANCOR )
+	{
+		return _PlayerShadow(rootOrigin, cent->pe.legs.yawAngle, shadowPlane, 64, cgs.media.shadowMarkShader);
+	}
+	else
+	{
+		return _PlayerShadow(rootOrigin, cent->pe.legs.yawAngle, shadowPlane, 16, cgs.media.shadowMarkShader);
+	}
+
+}
+
+void CG_LandingEffect( vec3_t origin, vec3_t normal, int material )
+{
+	int	effectID = -1;
+	switch ( material )
+	{
+	case MATERIAL_MUD:
+		effectID = cgs.effects.landingMud;
+		break;
+	case MATERIAL_DIRT:			
+		effectID = cgs.effects.landingDirt;
+		break;
+	case MATERIAL_SAND:			
+		effectID = cgs.effects.landingSand;
+		break;
+	case MATERIAL_SNOW:			
+		effectID = cgs.effects.landingSnow;
+		break;
+	case MATERIAL_GRAVEL:
+		effectID = cgs.effects.landingGravel;
+		break;
+	}
+
+	if ( effectID != -1 )
+	{
+		theFxScheduler.PlayEffect( effectID, origin, normal );
+	}
+}
+#define	FOOTSTEP_DISTANCE	32
+static void _PlayerFootStep( const vec3_t origin, 
+								const vec3_t traceDir, 
+								const float orientation, 
+								const float radius, 
+								centity_t *const cent, footstepType_t footStepType ) 
+{
+	vec3_t		end, mins = {-7, -7, 0}, maxs = {7, 7, 2};
+	trace_t		trace;
+	footstep_t	soundType = FOOTSTEP_TOTAL;
+	bool		bMark = false;
+	int			effectID = -1;
+	//float		alpha;
+
+	// send a trace down from the player to the ground
+	VectorCopy( origin, end );
+	VectorMA( origin, FOOTSTEP_DISTANCE, traceDir, end );//was end[2] -= FOOTSTEP_DISTANCE;
+
+	cgi_CM_BoxTrace( &trace, origin, end, mins, maxs, 0, MASK_PLAYERSOLID );
+
+	// no shadow if too high
+	if ( trace.fraction >= 1.0f ) 
+	{
+		return;
+	}
+
+	//check for foot-steppable surface flag
+	switch( trace.surfaceFlags & MATERIAL_MASK )
+	{
+		case MATERIAL_MUD:
+			bMark = true;
+			if ( footStepType == FOOTSTEP_HEAVY_R || footStepType == FOOTSTEP_HEAVY_L) {
+				soundType = FOOTSTEP_MUDRUN;
+			} else {
+				soundType = FOOTSTEP_MUDWALK;
+			}
+			effectID = cgs.effects.footstepMud;
+			break;
+		case MATERIAL_DIRT:			
+			bMark = true;
+			if ( footStepType == FOOTSTEP_HEAVY_R || footStepType == FOOTSTEP_HEAVY_L) {
+				soundType = FOOTSTEP_DIRTRUN;
+			} else {
+				soundType = FOOTSTEP_DIRTWALK;
+			}
+			effectID = cgs.effects.footstepSand;
+			break;
+		case MATERIAL_SAND:			
+			bMark = true;
+			if ( footStepType == FOOTSTEP_HEAVY_R || footStepType == FOOTSTEP_HEAVY_L) {
+				soundType = FOOTSTEP_SANDRUN;
+			} else {
+				soundType = FOOTSTEP_SANDWALK;
+			}
+			effectID = cgs.effects.footstepSand;
+			break;
+		case MATERIAL_SNOW:			
+			bMark = true;
+			if ( footStepType == FOOTSTEP_HEAVY_R || footStepType == FOOTSTEP_HEAVY_L) {
+				soundType = FOOTSTEP_SNOWRUN;
+			} else {
+				soundType = FOOTSTEP_SNOWWALK;
+			}
+			effectID = cgs.effects.footstepSnow;
+			break;
+		case MATERIAL_SHORTGRASS:		
+		case MATERIAL_LONGGRASS:		
+			if ( footStepType == FOOTSTEP_HEAVY_R || footStepType == FOOTSTEP_HEAVY_L) {
+				soundType = FOOTSTEP_GRASSRUN;
+			} else {
+				soundType = FOOTSTEP_GRASSWALK;
+			}
+			break;
+		case MATERIAL_SOLIDMETAL:		
+			if ( footStepType == FOOTSTEP_HEAVY_R || footStepType == FOOTSTEP_HEAVY_L) {
+				soundType = FOOTSTEP_METALRUN;
+			} else {
+				soundType = FOOTSTEP_METALWALK;
+			}
+			break;
+		case MATERIAL_HOLLOWMETAL:	
+			if ( footStepType == FOOTSTEP_HEAVY_R || footStepType == FOOTSTEP_HEAVY_L) {
+				soundType = FOOTSTEP_PIPERUN;
+			} else {
+				soundType = FOOTSTEP_PIPEWALK;
+			}
+			break;
+		case MATERIAL_GRAVEL:
+			if ( footStepType == FOOTSTEP_HEAVY_R || footStepType == FOOTSTEP_HEAVY_L) {
+				soundType = FOOTSTEP_GRAVELRUN;
+			} else {
+				soundType = FOOTSTEP_GRAVELWALK;
+			}
+			effectID = cgs.effects.footstepGravel;
+			break;
+		case MATERIAL_CARPET:
+		case MATERIAL_FABRIC:
+		case MATERIAL_CANVAS:
+		case MATERIAL_RUBBER:
+		case MATERIAL_PLASTIC:
+			if ( footStepType == FOOTSTEP_HEAVY_R || footStepType == FOOTSTEP_HEAVY_L) {
+				soundType = FOOTSTEP_RUGRUN;
+			} else {
+				soundType = FOOTSTEP_RUGWALK;
+			}
+			break;
+		case MATERIAL_SOLIDWOOD:
+		case MATERIAL_HOLLOWWOOD:
+			if ( footStepType == FOOTSTEP_HEAVY_R || footStepType == FOOTSTEP_HEAVY_L) {
+				soundType = FOOTSTEP_WOODRUN;
+			} else {
+				soundType = FOOTSTEP_WOODWALK;
+			}
+			break;
+
+		default:
+		//fall through
+		case MATERIAL_GLASS:
+		case MATERIAL_WATER:
+		case MATERIAL_FLESH:
+		case MATERIAL_BPGLASS:
+		case MATERIAL_DRYLEAVES:
+		case MATERIAL_GREENLEAVES:
+		case MATERIAL_TILES:		
+		case MATERIAL_PLASTER:
+		case MATERIAL_SHATTERGLASS:
+		case MATERIAL_ARMOR:
+		case MATERIAL_COMPUTER:
+
+		case MATERIAL_CONCRETE:		
+		case MATERIAL_ROCK:			
+		case MATERIAL_ICE:			
+		case MATERIAL_MARBLE:			
+			if ( footStepType == FOOTSTEP_HEAVY_R || footStepType == FOOTSTEP_HEAVY_L) {
+				soundType = FOOTSTEP_STONERUN;
+			} else {
+				soundType = FOOTSTEP_STONEWALK;
+			}
+			break;
+	}
+
+	if (soundType < FOOTSTEP_TOTAL) 
+	{
+	 	cgi_S_StartSound( NULL, cent->currentState.clientNum, CHAN_BODY, cgs.media.footsteps[soundType][Q_irand( 0, 3)] );
+	}
+
+	if ( cg_footsteps.integer < 4 )
+	{//debugging - 4 always does footstep effect
+		if ( cg_footsteps.integer < 2 )	//1 for sounds, 2 for effects, 3 for marks
+		{
+			return;
+		}
+	}
+
+	if ( effectID != -1 )
+	{
+		theFxScheduler.PlayEffect( effectID, trace.endpos, trace.plane.normal );
+	}
+
+	if ( cg_footsteps.integer < 4 )
+	{//debugging - 4 always does footprint decal
+		if (!bMark || cg_footsteps.integer < 3)	//1 for sounds, 2 for effects, 3 for marks
+		{
+			return;
+		}
+	}
+	qhandle_t footMarkShader;
+	switch ( footStepType )
+	{
+	case FOOTSTEP_HEAVY_R:
+		footMarkShader = cgs.media.fshrMarkShader;
+		break;
+	case FOOTSTEP_HEAVY_L:
+		footMarkShader = cgs.media.fshlMarkShader;
+		break;
+	case FOOTSTEP_R:
+		footMarkShader = cgs.media.fsrMarkShader;
+		break;
+	default:
+	case FOOTSTEP_L:
+		footMarkShader = cgs.media.fslMarkShader;
+		break;
+	}
+
+	// fade the shadow out with height
+//	alpha = 1.0 - trace.fraction;
+
+	// add the mark as a temporary, so it goes directly to the renderer
+	// without taking a spot in the cg_marks array
+
+	vec3_t		projNormal;
+	VectorCopy(trace.plane.normal,projNormal);
+	if (projNormal[2]>0.5f)
+	{
+		// footsteps will not have the correct orientation for all surfaces, so punt and set the projection to Z
+		projNormal[0]=0.0f;
+		projNormal[1]=0.0f;
+		projNormal[2]=1.0f;
+	}
+	CG_ImpactMark( footMarkShader, trace.endpos,projNormal, 
+		orientation, 1,1,1, 1.0f, qfalse, radius, qfalse );
+}
+
+extern vmCvar_t	cg_footsteps;
+static void CG_PlayerFootsteps( centity_t *const cent, footstepType_t footStepType )
+{
+	if ( cg_footsteps.integer == 0 ) 
+	{
+		return;
+	}
+
+	//FIXME: make this a feature of NPCs in the NPCs.cfg? Specify a footstep shader, if any?
+	if ( cent->gent->client->NPC_class != CLASS_ATST
+		&& cent->gent->client->NPC_class != CLASS_CLAW
+		&& cent->gent->client->NPC_class != CLASS_FISH
+		&& cent->gent->client->NPC_class != CLASS_FLIER2
+		&& cent->gent->client->NPC_class != CLASS_GLIDER
+		&& cent->gent->client->NPC_class != CLASS_INTERROGATOR
+		&& cent->gent->client->NPC_class != CLASS_MURJJ
+		&& cent->gent->client->NPC_class != CLASS_PROBE
+		&& cent->gent->client->NPC_class != CLASS_R2D2
+		&& cent->gent->client->NPC_class != CLASS_R5D2
+		&& cent->gent->client->NPC_class != CLASS_REMOTE
+		&& cent->gent->client->NPC_class != CLASS_SEEKER
+		&& cent->gent->client->NPC_class != CLASS_SENTRY
+		&& cent->gent->client->NPC_class != CLASS_SWAMP )
+	{
+		mdxaBone_t	boltMatrix;
+		vec3_t tempAngles, sideOrigin, footDownDir;
+
+		tempAngles[PITCH]	= 0;
+		tempAngles[YAW]		= cent->pe.legs.yawAngle;
+		tempAngles[ROLL]	= 0;
+
+		int footBolt = cent->gent->footLBolt;
+		if ( footStepType == FOOTSTEP_HEAVY_R || footStepType == FOOTSTEP_R) 
+		{
+			footBolt = cent->gent->footRBolt;
+		}
+		//FIXME: get yaw orientation of the foot and use on decal
+		gi.G2API_GetBoltMatrix( cent->gent->ghoul2, cent->gent->playerModel, footBolt, 
+				&boltMatrix, tempAngles, cent->lerpOrigin, 
+				cg.time, cgs.model_draw, cent->currentState.modelScale);
+		gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, sideOrigin );
+		gi.G2API_GiveMeVectorFromMatrix( boltMatrix, NEGATIVE_Y, footDownDir );
+		VectorMA( sideOrigin, -8.0f, footDownDir, sideOrigin );//was [2] += 15;	//fudge up a bit for coplanar
+		_PlayerFootStep( sideOrigin, footDownDir, cent->pe.legs.yawAngle-90, 6, cent, footStepType );
+	}
+}
+
+static void _PlayerSplash( const vec3_t origin, const vec3_t velocity, const float radius, const int maxUp )
+{
+	static vec3_t WHITE={1,1,1};
+	vec3_t		start, end;
+	trace_t		trace;
+	int			contents;
+	
+	VectorCopy( origin, end );
+	end[2] -= 24;
+
+	// if the feet aren't in liquid, don't make a mark
+	// this won't handle moving water brushes, but they wouldn't draw right anyway...
+	contents = cgi_CM_PointContents( end, 0 );
+	if ( !( contents & ( CONTENTS_WATER | CONTENTS_SLIME | CONTENTS_LAVA ) ) ) 
+	{
+		return;
+	}
+
+	VectorCopy( origin, start );
+	if ( maxUp < 32 )
+	{//our head may actually be lower than 32 above our origin
+		start[2] += maxUp;
+	}
+	else
+	{
+		start[2] += 32;
+	}
+
+	// if the head isn't out of liquid, don't make a mark
+	contents = cgi_CM_PointContents( start, 0 );
+	if ( contents & ( CONTENTS_SOLID | CONTENTS_WATER | CONTENTS_SLIME | CONTENTS_LAVA ) ) 
+	{
+		return;
+	}
+
+	// trace down to find the surface
+	cgi_CM_BoxTrace( &trace, start, end, NULL, NULL, 0, ( CONTENTS_WATER | CONTENTS_SLIME | CONTENTS_LAVA ) );
+
+	if ( trace.fraction == 1.0 ) 
+	{
+		return;
+	}
+
+	VectorCopy( trace.endpos, end );
+
+	end[0] += crandom() * 3.0f;
+	end[1] += crandom() * 3.0f;
+	end[2] += 1.0f; //fudge up
+	
+	int t = VectorLengthSquared( velocity );
+	
+	if ( t > 8192 ) // oh, magic number
+	{
+		t = 8192;
+	}
+
+	float alpha = ( t / 8192.0f ) * 0.6f + 0.2f;
+
+	FX_AddOrientedParticle( -1, end, trace.plane.normal, NULL, NULL, 
+								6.0f, radius + random() * 48.0f, 0, 
+								alpha, 0.0f, 0.0f,
+								WHITE, WHITE, 0.0f, 
+								random() * 360, crandom() * 6.0f, NULL, NULL, 0.0f, 0 ,0, 1200, 
+								cgs.media.wakeMarkShader, FX_ALPHA_LINEAR | FX_SIZE_LINEAR );
+}
+
+/*
+===============
+CG_PlayerSplash
+
+Draw a mark at the water surface
+===============
+*/
+static void CG_PlayerSplash( centity_t *cent ) 
+{
+	if ( !cg_shadows.integer ) 
+	{
+		return;
+	}
+
+	if ( cent->gent && cent->gent->client )
+	{
+		gclient_t *cl = cent->gent->client;
+
+		if ( cent->gent->disconnectDebounceTime < cg.time ) // can't do these expanding ripples all the time
+		{
+			if ( cl->NPC_class == CLASS_ATST )
+			{
+				mdxaBone_t	boltMatrix;
+				vec3_t		tempAngles, sideOrigin;
+
+				tempAngles[PITCH]	= 0;
+				tempAngles[YAW]		= cent->pe.legs.yawAngle;
+				tempAngles[ROLL]	= 0;
+				
+				gi.G2API_GetBoltMatrix( cent->gent->ghoul2, cent->gent->playerModel, cent->gent->footLBolt, 
+						&boltMatrix, tempAngles, cent->lerpOrigin, 
+						cg.time, cgs.model_draw, cent->currentState.modelScale );
+				gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, sideOrigin );
+				sideOrigin[2] += 22;	//fudge up a bit for coplaner
+				_PlayerSplash( sideOrigin, cl->ps.velocity, 42, cent->gent->maxs[2] );
+				
+				gi.G2API_GetBoltMatrix( cent->gent->ghoul2, cent->gent->playerModel, cent->gent->footRBolt, 
+						&boltMatrix, tempAngles, cent->lerpOrigin, cg.time, 
+						cgs.model_draw, cent->currentState.modelScale);
+				gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, sideOrigin );
+				sideOrigin[2] += 22;	//fudge up a bit for coplaner
+
+				_PlayerSplash( sideOrigin, cl->ps.velocity, 42, cent->gent->maxs[2] );	
+			}
+			else
+			{
+				// player splash mark
+				_PlayerSplash( cent->lerpOrigin, cl->ps.velocity, 36, cl->renderInfo.eyePoint[2] - cent->lerpOrigin[2] + 5 );	
+			}
+
+			cent->gent->disconnectDebounceTime = cg.time + 125 + random() * 50.0f;
+		}
+	}
+}
+
+
+/*
+===============
+CG_LightningBolt
+===============
+*/
+#if 0
+static void CG_LightningBolt( centity_t *cent, vec3_t origin ) 
+{
+	// FIXME:  This sound also plays when the weapon first fires which causes little sputtering sounds..not exactly cool
+	// Must be currently firing
+	if ( !( cent->currentState.eFlags & EF_FIRING ) )
+		return;
+
+	//Must be a durational weapon
+//	if ( cent->currentState.weapon == WP_DEMP2 && cent->currentState.eFlags & EF_ALT_FIRING ) 
+//	{ /*nothing*/ }
+//	else
+	{
+		return;
+	}
+
+/*	trace_t		trace;
+	gentity_t	*traceEnt;
+	vec3_t		end, forward, org, angs;
+	qboolean	spark = qfalse, impact = qtrue;//, weak = qfalse;
+
+	// for lightning weapons coming from the player, it had better hit the crosshairs or else..
+	if ( cent->gent->s.number )
+	{
+		VectorCopy( origin, org );
+	}
+	else
+	{
+		VectorCopy( cg.refdef.vieworg, org );
+	}
+
+	// Find the impact point of the beam
+	VectorCopy( cent->lerpAngles, angs );
+
+	AngleVectors( angs, forward, NULL, NULL );
+
+	VectorMA( org, weaponData[cent->currentState.weapon].range, forward, end );
+	
+	CG_Trace( &trace, org, vec3_origin, vec3_origin, end, cent->currentState.number, MASK_SHOT );
+	traceEnt = &g_entities[ trace.entityNum ];
+
+	// Make sparking be a bit less frame-rate dependent..also never add sparking when we hit a surface with a NOIMPACT flag
+	if ( cent->gent->fx_time < cg.time && !(trace.surfaceFlags & SURF_NOIMPACT ))
+	{
+		spark = qtrue;
+		cent->gent->fx_time = cg.time + random() * 100 + 100;
+	}
+
+	// Don't draw certain kinds of impacts when it hits a player and such..or when we hit a surface with a NOIMPACT flag
+	if ( (traceEnt->takedamage && traceEnt->client) || (trace.surfaceFlags & SURF_NOIMPACT) )
+	{
+		impact = qfalse;
+	}
+	
+	// Add in the effect
+	switch ( cent->currentState.weapon )
+	{
+	case WP_DEMP2:
+//		vec3_t org;
+
+extern void FX_DEMP2_AltBeam( vec3_t start, vec3_t end, vec3_t normal, //qboolean spark, 
+									vec3_t targ1, vec3_t targ2 );
+
+		// Move the beam back a bit to help cover up the poly edges on the fire beam
+//		VectorMA( origin, -4, forward, org );
+//		FIXME:  Looks and works like ASS, so don't let people see it until it improves
+		FX_DEMP2_AltBeam( origin, trace.endpos, trace.plane.normal, cent->gent->pos1, cent->gent->pos2 );
+		break;
+
+	}
+	*/
+}
+#endif
+
+//-------------------------------------------
+#define REFRACT_EFFECT_DURATION		500
+void CG_ForcePushBlur( const vec3_t org, qboolean darkSide = qfalse );
+static void CG_ForcePushRefraction( vec3_t org, centity_t *cent )
+{
+	refEntity_t ent;
+	vec3_t ang;
+	float scale;
+	float vLen;
+	float alpha;
+	int tDif;
+
+	if (!cg_renderToTextureFX.integer)
+	{
+		CG_ForcePushBlur(org);
+		return;
+	}
+
+	if (!cent->gent ||
+		!cent->gent->client)
+	{ //can only do this for player/npc's
+		return;
+	}
+
+	if (!cent->gent->client->pushEffectFadeTime)
+	{ //the duration for the expansion and fade
+		cent->gent->client->pushEffectFadeTime = cg.time + REFRACT_EFFECT_DURATION;
+	}
+
+	//closer tDif is to 0, the closer we are to
+	//being "done"
+	tDif = (cent->gent->client->pushEffectFadeTime - cg.time);
+	if ((REFRACT_EFFECT_DURATION-tDif) < 200)
+	{ //stop following the hand after a little and stay in a fixed spot
+		//save the initial spot of the effect
+		VectorCopy(org, cent->gent->client->pushEffectOrigin);
+	}
+
+	//scale from 1.0f to 0.1f then hold at 0.1 for the rest of the duration
+	if (cent->gent->client->ps.forcePowersActive & ( 1 << FP_PULL ) )
+	{
+		scale = (float)(REFRACT_EFFECT_DURATION-tDif)*0.003f;
+	}
+	else
+	{
+		scale = (float)(tDif)*0.003f;
+	}
+	if (scale > 1.0f)
+	{
+		scale = 1.0f;
+	}
+	else if (scale < 0.2f)
+	{
+		scale = 0.2f;
+	}
+
+	//start alpha at 244, fade to 10
+	alpha = (float)tDif*0.488f;
+
+	if (alpha > 244.0f)
+	{
+		alpha = 244.0f;
+	}
+	else if (alpha < 10.0f)
+	{
+		alpha = 10.0f;
+	}
+
+	memset( &ent, 0, sizeof( ent ) );
+	ent.shaderTime = (cent->gent->client->pushEffectFadeTime-REFRACT_EFFECT_DURATION) / 1000.0f;
+
+	VectorCopy( cent->gent->client->pushEffectOrigin, ent.origin );
+
+	VectorSubtract(ent.origin, cg.refdef.vieworg, ent.axis[0]);
+	vLen = VectorLength(ent.axis[0]);
+	if (vLen <= 0.1f)
+	{	// Entity is right on vieworg.  quit.
+		return;
+	}
+
+	vectoangles(ent.axis[0], ang);
+	ang[ROLL] += 180.0f;
+
+	AnglesToAxis(ang, ent.axis);
+
+	//radius must be a power of 2, and is the actual captured texture size
+	if (vLen < 128)
+	{
+		ent.radius = 256;
+	}
+	else if (vLen < 256)
+	{
+		ent.radius = 128;
+	}
+	else if (vLen < 512)
+	{
+		ent.radius = 64;
+	}
+	else
+	{
+		ent.radius = 32;
+	}
+
+	VectorScale(ent.axis[0], scale, ent.axis[0]);
+	VectorScale(ent.axis[1], scale, ent.axis[1]);
+	VectorScale(ent.axis[2], scale, ent.axis[2]);
+
+	ent.hModel = cgs.media.halfShieldModel;
+	ent.customShader = cgs.media.refractShader;
+	ent.nonNormalizedAxes = qtrue;
+
+	//make it partially transparent so it blends with the background
+	ent.renderfx = (RF_DISTORTION|RF_ALPHA_FADE);
+	ent.shaderRGBA[0] = 255.0f;
+	ent.shaderRGBA[1] = 255.0f;
+	ent.shaderRGBA[2] = 255.0f;
+	ent.shaderRGBA[3] = alpha;
+
+
+	cgi_R_AddRefEntityToScene( &ent );
+}
+
+void CG_ForcePushBlur( const vec3_t org, qboolean darkSide )
+{
+	localEntity_t	*ex;
+
+	ex = CG_AllocLocalEntity();
+	ex->leType = LE_PUFF;
+	ex->refEntity.reType = RT_SPRITE;
+	ex->radius = 2.0f;
+	ex->startTime = cg.time;
+	ex->endTime = ex->startTime + 120;
+	VectorCopy( org, ex->pos.trBase );
+	ex->pos.trTime = cg.time;
+	ex->pos.trType = TR_LINEAR;
+	VectorScale( cg.refdef.viewaxis[1], 55, ex->pos.trDelta );
+		
+	if ( darkSide )
+	{//make it red
+		ex->color[0] = 60;
+		ex->color[1] = 8;
+		ex->color[2] = 8;
+	}
+	else
+	{//blue
+		ex->color[0] = 24;
+		ex->color[1] = 32;
+		ex->color[2] = 40;
+	}
+	ex->refEntity.customShader = cgi_R_RegisterShader( "gfx/effects/forcePush" );
+
+	ex = CG_AllocLocalEntity();
+	ex->leType = LE_PUFF;
+	ex->refEntity.reType = RT_SPRITE;
+	ex->refEntity.rotation = 180.0f;
+	ex->radius = 2.0f;
+	ex->startTime = cg.time;
+	ex->endTime = ex->startTime + 120;
+	VectorCopy( org, ex->pos.trBase );
+	ex->pos.trTime = cg.time;
+	ex->pos.trType = TR_LINEAR;
+	VectorScale( cg.refdef.viewaxis[1], -55, ex->pos.trDelta );
+		
+	if ( darkSide )
+	{//make it red
+		ex->color[0] = 60;
+		ex->color[1] = 8;
+		ex->color[2] = 8;
+	}
+	else
+	{//blue
+		ex->color[0] = 24;
+		ex->color[1] = 32;
+		ex->color[2] = 40;
+	}
+	ex->refEntity.customShader = cgi_R_RegisterShader( "gfx/effects/forcePush" );
+}
+
+static void CG_ForcePushBodyBlur( centity_t *cent, const vec3_t origin, vec3_t tempAngles )
+{
+	vec3_t fxOrg;
+	mdxaBone_t	boltMatrix;
+
+	// Head blur
+	CG_ForcePushBlur( cent->gent->client->renderInfo.eyePoint );
+
+	// Do a torso based blur
+	if (cent->gent->torsoBolt>=0)
+	{
+		gi.G2API_GetBoltMatrix( cent->gent->ghoul2, cent->gent->playerModel, cent->gent->torsoBolt, 
+						&boltMatrix, tempAngles, origin, cg.time, 
+						cgs.model_draw, cent->currentState.modelScale);
+		gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, fxOrg );
+		CG_ForcePushBlur( fxOrg );
+	}
+
+	if (cent->gent->handRBolt>=0)
+	{
+		// Do a right-hand based blur
+		gi.G2API_GetBoltMatrix( cent->gent->ghoul2, cent->gent->playerModel, cent->gent->handRBolt, 
+						&boltMatrix, tempAngles, origin, cg.time, 
+						cgs.model_draw, cent->currentState.modelScale);
+		gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, fxOrg );
+		CG_ForcePushBlur( fxOrg );
+	}
+
+	if (cent->gent->handLBolt>=0)
+	{
+		// Do a left-hand based blur
+		gi.G2API_GetBoltMatrix( cent->gent->ghoul2, cent->gent->playerModel, cent->gent->handLBolt, 
+						&boltMatrix, tempAngles, origin, cg.time, 
+						cgs.model_draw, cent->currentState.modelScale);
+		gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, fxOrg );
+		CG_ForcePushBlur( fxOrg );
+	}
+
+	// Do the knees
+	if (cent->gent->kneeLBolt>=0)
+	{
+		gi.G2API_GetBoltMatrix( cent->gent->ghoul2, cent->gent->playerModel, cent->gent->kneeLBolt, 
+						&boltMatrix, tempAngles, origin, cg.time, 
+						cgs.model_draw, cent->currentState.modelScale);
+		gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, fxOrg );
+		CG_ForcePushBlur( fxOrg );
+	}
+
+	if (cent->gent->kneeRBolt>=0)
+	{
+		gi.G2API_GetBoltMatrix( cent->gent->ghoul2, cent->gent->playerModel, cent->gent->kneeRBolt, 
+						&boltMatrix, tempAngles, origin, cg.time, 
+						cgs.model_draw, cent->currentState.modelScale);
+		gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, fxOrg );
+		CG_ForcePushBlur( fxOrg );
+	}
+
+	if (cent->gent->elbowLBolt>=0)
+	{
+		// Do the elbows
+		gi.G2API_GetBoltMatrix( cent->gent->ghoul2, cent->gent->playerModel, cent->gent->elbowLBolt, 
+						&boltMatrix, tempAngles, origin, cg.time, 
+						cgs.model_draw, cent->currentState.modelScale);
+		gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, fxOrg );
+		CG_ForcePushBlur( fxOrg );
+	}
+	if (cent->gent->elbowRBolt>=0)
+	{
+		gi.G2API_GetBoltMatrix( cent->gent->ghoul2, cent->gent->playerModel, cent->gent->elbowRBolt, 
+						&boltMatrix, tempAngles, origin, cg.time, 
+						cgs.model_draw, cent->currentState.modelScale);
+		gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, fxOrg );
+		CG_ForcePushBlur( fxOrg );
+	}
+}
+
+static void CG_ForceElectrocution( centity_t *cent, const vec3_t origin, vec3_t tempAngles, qhandle_t shader, qboolean alwaysDo = qfalse )
+{
+	// Undoing for now, at least this code should compile if I ( or anyone else ) decides to work on this effect
+	qboolean	found = qfalse;
+	vec3_t		fxOrg, fxOrg2, dir;
+	vec3_t		rgb = {1.0f,1.0f,1.0f};
+	mdxaBone_t	boltMatrix;
+
+	int bolt=-1;
+	int iter=0;
+	// Pick a random start point
+	while (bolt<0)
+	{
+		int test;
+		if (iter>5)
+		{
+			test=iter-5;
+		}
+		else
+		{
+			test=Q_irand(0,6);
+		}
+		switch(test)
+		{
+		case 0:
+			// Right Elbow
+			bolt=cent->gent->elbowRBolt;
+			break;
+		case 1:
+			// Left Hand
+			bolt=cent->gent->handLBolt;
+			break;
+		case 2:
+			// Right hand
+			bolt=cent->gent->handRBolt;
+			break;
+		case 3:
+			// Left Foot
+			bolt=cent->gent->footLBolt;
+			break;
+		case 4:
+			// Right foot
+			bolt=cent->gent->footRBolt;
+			break;
+		case 5:
+			// Torso
+			bolt=cent->gent->torsoBolt;
+			break;
+		case 6:
+		default:
+			// Left Elbow
+			bolt=cent->gent->elbowLBolt;
+			break;
+		}
+		if (++iter==20)
+			break;
+	}
+	if (bolt>=0)
+	{
+		found = gi.G2API_GetBoltMatrix( cent->gent->ghoul2, cent->gent->playerModel, bolt, 
+				&boltMatrix, tempAngles, origin, cg.time, 
+				cgs.model_draw, cent->currentState.modelScale);
+	}
+	// Make sure that it's safe to even try and get these values out of the Matrix, otherwise the values could be garbage
+	if ( found )
+	{
+		gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, fxOrg );
+		if ( random() > 0.5f )
+		{
+			gi.G2API_GiveMeVectorFromMatrix( boltMatrix, NEGATIVE_X, dir );
+		}
+		else
+		{
+			gi.G2API_GiveMeVectorFromMatrix( boltMatrix, NEGATIVE_Y, dir );
+		}
+
+		// Add some fudge, makes us not normalized, but that isn't really important
+		dir[0] += crandom() * 0.4f;
+		dir[1] += crandom() * 0.4f;
+		dir[2] += crandom() * 0.4f;
+	}
+	else
+	{
+		// Just use the lerp Origin and a random direction
+		VectorCopy( cent->lerpOrigin, fxOrg );
+		VectorSet( dir, crandom(), crandom(), crandom() ); // Not normalized, but who cares.
+		if ( cent->gent && cent->gent->client )
+		{
+			switch ( cent->gent->client->NPC_class )
+			{
+			case CLASS_PROBE:
+				fxOrg[2] += 50;
+				break;
+			case CLASS_MARK1:
+				fxOrg[2] += 50;
+				break;
+			case CLASS_ATST:
+				fxOrg[2] += 120;
+				break;
+			}
+		}
+	}
+
+	VectorMA( fxOrg, random() * 40 + 40, dir, fxOrg2 );
+
+	trace_t	tr;
+
+	CG_Trace( &tr, fxOrg, NULL, NULL, fxOrg2, -1, CONTENTS_SOLID );
+
+	if ( tr.fraction < 1.0f || random() > 0.94f || alwaysDo )
+	{
+		FX_AddElectricity( -1, fxOrg, tr.endpos,
+			1.5f, 4.0f, 0.0f, 
+			1.0f, 0.5f, 0.0f,
+			rgb, rgb, 0.0f,
+			5.5f, random() * 50 + 100, shader, FX_ALPHA_LINEAR | FX_SIZE_LINEAR | FX_BRANCH | FX_GROW | FX_TAPER, -1, -1 );
+	}
+}
+
+static void CG_BoltedEffects( centity_t *cent, const vec3_t origin, vec3_t tempAngles )
+{
+	if ( cent->gent && cent->gent->client && cent->gent->client->NPC_class == CLASS_VEHICLE )
+	{
+		Vehicle_t *pVeh = cent->gent->m_pVehicle;
+		gentity_t *parent = cent->gent;
+ 		if (pVeh->m_ulFlags&VEH_ARMORLOW 
+			&& (pVeh->m_iLastFXTime<=cg.time) 
+			&& Q_irand(0,1)==0 )
+		{
+			pVeh->m_iLastFXTime = cg.time + 50;//Q_irand(50, 100);
+			CG_PlayEffectIDBolted(pVeh->m_pVehicleInfo->iArmorLowFX, parent->playerModel, parent->crotchBolt, parent->s.number, parent->currentOrigin);
+		}
+	}
+}
+
+/*
+===============
+CG_PlayerCanSeeCent
+
+tests force sight level
+===============
+*/
+qboolean CG_PlayerCanSeeCent( centity_t *cent )
+{//return true if this cent is in view
+	//NOTE: this is similar to the func SV_PlayerCanSeeEnt in sv_snapshot
+	if ( (cent->currentState.eFlags&EF_FORCE_VISIBLE) )
+	{//can always be seen
+		return qtrue;
+	}
+
+	if ( g_entities[0].client->ps.forcePowerLevel[FP_SEE] < FORCE_LEVEL_2 
+		&& cent->currentState.eType != ET_PLAYER )
+	{//TEST: level 1 only sees force hints and enemies
+		return qfalse;
+	}
+
+	float dot = 0.25f;//1.0f;
+	float range = 512.0f;
+
+	switch ( g_entities[0].client->ps.forcePowerLevel[FP_SEE] )
+	{
+	case FORCE_LEVEL_1:
+		//dot = 0.95f;
+		range = 1024.0f;
+		break;
+	case FORCE_LEVEL_2:
+		//dot = 0.7f;
+		range = 2048.0f;
+		break;
+	case FORCE_LEVEL_3:
+	case FORCE_LEVEL_4:
+	case FORCE_LEVEL_5:
+		//dot = 0.4f;
+		range = 4096.0f;
+		break;
+	}
+
+	vec3_t	centDir, lookDir;
+	VectorSubtract( cent->lerpOrigin, cg.refdef.vieworg, centDir );
+	float centDist = VectorNormalize( centDir );
+
+	if ( centDist < 128.0f )
+	{//can always see them if they're really close
+		return qtrue;
+	}
+
+	if ( centDist > range )
+	{//too far away to see them
+		return qfalse;
+	}
+
+	dot += (0.99f-dot)*centDist/range;//the farther away they are, the more in front they have to be
+
+	AngleVectors( cg.refdefViewAngles, lookDir, NULL, NULL );
+	
+	if ( DotProduct( centDir, lookDir ) < dot )
+	{//not in force sight cone
+		return qfalse;
+	}
+
+	return qtrue;
+}
+
+/*
+===============
+CG_AddForceSightShell
+
+Adds the special effect
+===============
+*/
+extern void CG_AddHealthBarEnt( int entNum );
+void CG_AddForceSightShell( refEntity_t *ent, centity_t *cent )
+{
+	ent->customShader = cgs.media.forceShell;
+	ent->renderfx &= ~RF_RGB_TINT;
+	// See through walls.
+	ent->renderfx |= (RF_MORELIGHT|RF_NODEPTH);
+
+	if ( (cent->currentState.eFlags&EF_FORCE_VISIBLE) 
+		|| (cent->currentState.eType == ET_PLAYER && cent->gent && cent->gent->message) )
+	{		
+		ent->shaderRGBA[0] = 0;
+		ent->shaderRGBA[1] = 0;
+		ent->shaderRGBA[2] = 255;
+		ent->shaderRGBA[3] = 254;
+
+		cgi_R_AddRefEntityToScene( ent );
+		return;
+	}
+
+	ent->shaderRGBA[0] = 255;
+	ent->shaderRGBA[1] = 255;
+	ent->shaderRGBA[2] = 0;
+
+	//if ( g_entities[0].client->ps.forcePowerLevel[FP_SEE] > FORCE_LEVEL_2 )
+	//{TEST: level 3 identifies friend or foe with color
+		team_t team = TEAM_NEUTRAL;
+		if ( cent->gent && cent->gent->client )
+		{
+			team = cent->gent->client->playerTeam;
+		}
+		else if ( cent->gent->owner )
+		{
+			if ( cent->gent->owner->client )
+			{
+				team = cent->gent->owner->client->playerTeam;
+			}
+			else
+			{
+				team = cent->gent->owner->noDamageTeam;
+			}
+		}
+		switch ( team )
+		{
+		case TEAM_ENEMY:
+			ent->shaderRGBA[0] = 255;
+			ent->shaderRGBA[1] = 0;
+			ent->shaderRGBA[2] = 0;
+			break;
+		case TEAM_PLAYER:
+			ent->shaderRGBA[0] = 0;
+			ent->shaderRGBA[1] = 255;
+			ent->shaderRGBA[2] = 0;
+			break;
+		case TEAM_FREE:
+			if ( cent->gent && cent->gent->client )
+			{
+				if ( cent->gent->client->NPC_class == CLASS_TUSKEN
+					|| cent->gent->client->NPC_class == CLASS_RANCOR
+					|| cent->gent->client->NPC_class == CLASS_WAMPA
+					|| cent->gent->client->NPC_class == CLASS_SAND_CREATURE )
+				{
+					ent->shaderRGBA[0] = 255;
+					ent->shaderRGBA[1] = 0;
+					ent->shaderRGBA[2] = 0;
+				}
+			}
+			break;
+		}
+
+	if ( g_entities[0].client->ps.forcePowerLevel[FP_SEE] > FORCE_LEVEL_2 )
+	{//TEST: level 3 also displays health
+		if ( cent->gent && cent->gent->health > 0 && cent->gent->max_health > 0 )
+		{//draw a health bar over them
+			CG_AddHealthBarEnt( cent->currentState.clientNum );
+		}
+	}
+
+	/*
+	if ( g_entities[0].client->ps.forcePowerLevel[FP_SEE] < FORCE_LEVEL_2 )
+	{ //only level 2+ can see players through walls
+		ent->renderfx &= ~RF_NODEPTH;
+	}
+	*/
+	
+	//FIXME: make it darker or more translucent the further away it is?
+
+	cgi_R_AddRefEntityToScene( ent );
+}
+
+/*
+===============
+CG_AddRefEntityWithPowerups
+
+Adds a piece with modifications or duplications for powerups
+===============
+*/
+void CG_AddRefEntityWithPowerups( refEntity_t *ent, int powerups, centity_t *cent )
+{
+	if ( !cent )
+	{
+		cgi_R_AddRefEntityToScene( ent );
+		return;
+	}
+	gentity_t *gent  = cent->gent;
+	if ( !gent )
+	{
+		cgi_R_AddRefEntityToScene( ent );
+		return;
+	}
+	if ( gent->client->ps.powerups[PW_DISRUPTION] < cg.time )
+	{//disruptor
+		if (( powerups & ( 1 << PW_DISRUPTION )))
+		{
+			//stop drawing him after this effect
+			gent->client->ps.eFlags |= EF_NODRAW;
+			return;
+		}
+	}
+
+//	if ( gent->client->ps.powerups[PW_WEAPON_OVERCHARGE] > 0 )
+//	{
+//		centity_t *cent = &cg_entities[gent->s.number];
+//		cgi_S_AddLoopingSound( 0, cent->lerpOrigin, vec3_origin, cgs.media.overchargeLoopSound );
+//	}
+
+	//get the dude's color choice in
+	ent->shaderRGBA[0] = gent->client->renderInfo.customRGBA[0];
+	ent->shaderRGBA[1] = gent->client->renderInfo.customRGBA[1];
+	ent->shaderRGBA[2] = gent->client->renderInfo.customRGBA[2];
+	ent->shaderRGBA[3] = gent->client->renderInfo.customRGBA[3];
+
+	// If certain states are active, we don't want to add in the regular body
+	if ( !gent->client->ps.powerups[PW_CLOAKED] && 
+		!gent->client->ps.powerups[PW_UNCLOAKING] && 
+		!gent->client->ps.powerups[PW_DISRUPTION] )
+	{
+		cgi_R_AddRefEntityToScene( ent );
+	}
+	
+	// Disruptor Gun Alt-fire
+	if ( gent->client->ps.powerups[PW_DISRUPTION] ) 
+	{
+		// I guess when something dies, it looks like pos1 gets set to the impact point on death, we can do fun stuff with this
+		vec3_t tempAng;
+		VectorSubtract( gent->pos1, ent->origin, ent->oldorigin );
+		//er, adjust this to get the proper position in model space... account for yaw
+		float tempLength = VectorNormalize( ent->oldorigin );
+		vectoangles( ent->oldorigin, tempAng );
+		tempAng[YAW] -= gent->client->ps.viewangles[YAW];
+		AngleVectors( tempAng, ent->oldorigin, NULL, NULL );
+		VectorScale( ent->oldorigin, tempLength, ent->oldorigin );
+
+		ent->endTime = gent->fx_time;
+		ent->renderfx |= (RF_DISINTEGRATE2);
+
+		ent->customShader = cgi_R_RegisterShader( "gfx/effects/burn" );
+		cgi_R_AddRefEntityToScene( ent );
+
+		ent->renderfx &= ~(RF_DISINTEGRATE2);
+		ent->renderfx |= (RF_DISINTEGRATE1);
+		ent->customShader = 0;
+		cgi_R_AddRefEntityToScene( ent );
+
+		if ( cg.time - ent->endTime < 1000 && (cg_timescale.value * cg_timescale.value * random()) > 0.05f )
+		{
+			vec3_t fxOrg;
+			mdxaBone_t	boltMatrix;
+
+			gi.G2API_GetBoltMatrix( cent->gent->ghoul2, gent->playerModel, gent->torsoBolt, 
+					&boltMatrix, gent->currentAngles, ent->origin, cg.time, 
+					cgs.model_draw, gent->s.modelScale);
+					gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, fxOrg );
+
+			VectorMA( fxOrg, -18, cg.refdef.viewaxis[0], fxOrg );
+			fxOrg[2] += crandom() * 20;
+			theFxScheduler.PlayEffect( "disruptor/death_smoke", fxOrg );
+
+			if ( random() > 0.5f )
+			{
+				theFxScheduler.PlayEffect( "disruptor/death_smoke", fxOrg );
+			}
+		}
+	}
+
+	// Cloaking & Uncloaking Technology
+	//----------------------------------------
+
+	if (( powerups & ( 1 << PW_UNCLOAKING )))
+	{//in the middle of cloaking
+		if ((cg.snap->ps.forcePowersActive & (1 << FP_SEE)) 
+			&& cg.snap->ps.clientNum != cent->currentState.number 
+			&& CG_PlayerCanSeeCent( cent ))
+		{//just draw him
+			cgi_R_AddRefEntityToScene( ent );
+		}
+		else
+		{
+			float perc = (float)(gent->client->ps.powerups[PW_UNCLOAKING] - cg.time) / 2000.0f;
+			if (( powerups & ( 1 << PW_CLOAKED ))) 
+			{//actually cloaking, so reverse it
+				perc = 1.0f - perc;
+			}
+
+			if ( perc >= 0.0f && perc <= 1.0f )
+			{
+				ent->renderfx &= ~RF_ALPHA_FADE;
+				ent->renderfx |= RF_RGB_TINT;
+				ent->shaderRGBA[0] = ent->shaderRGBA[1] = ent->shaderRGBA[2] = 255.0f * perc;
+				ent->shaderRGBA[3] = 0;
+				ent->customShader = cgs.media.cloakedShader;
+				cgi_R_AddRefEntityToScene( ent );
+
+				ent->shaderRGBA[0] = ent->shaderRGBA[1] = ent->shaderRGBA[2] = 255;
+				ent->shaderRGBA[3] = 255 * (1.0f - perc); // let model alpha in
+				ent->customShader = 0; // use regular skin
+				ent->renderfx &= ~RF_RGB_TINT;
+				ent->renderfx |= RF_ALPHA_FADE;
+				cgi_R_AddRefEntityToScene( ent );
+			}
+		}
+	}
+	else if (( powerups & ( 1 << PW_CLOAKED ))) 
+	{//fully cloaked
+		if ((cg.snap->ps.forcePowersActive & (1 << FP_SEE)) 
+			&& cg.snap->ps.clientNum != cent->currentState.number 
+			&& CG_PlayerCanSeeCent( cent ))
+		{//just draw him
+			cgi_R_AddRefEntityToScene( ent );
+		}
+		else
+		{
+			if (cg_renderToTextureFX.integer && cg_shadows.integer != 2 && cgs.glconfig.stencilBits >= 4)
+			{
+				cgi_R_SetRefractProp(1.0f, 0.0f, qfalse, qfalse); //don't need to do this every frame.. but..
+				ent->customShader = 2; //crazy "refractive" shader
+				cgi_R_AddRefEntityToScene( ent );
+				ent->customShader = 0;
+			}
+			else
+			{ //stencil buffer's in use, sorry
+				ent->renderfx = 0;//&= ~(RF_RGB_TINT|RF_ALPHA_FADE);
+				ent->shaderRGBA[0] = ent->shaderRGBA[1] = ent->shaderRGBA[2] = ent->shaderRGBA[3] = 255;
+				ent->customShader = cgs.media.cloakedShader;
+				cgi_R_AddRefEntityToScene( ent );
+			}
+		}
+	}
+
+	// Electricity
+	//------------------------------------------------
+	if ( (powerups & ( 1 << PW_SHOCKED )) ) 
+	{
+		int	dif = gent->client->ps.powerups[PW_SHOCKED] - cg.time;
+
+		if ( dif > 0 && random() > 0.4f )
+		{
+			// fade out over the last 500 ms
+			int brightness = 255;
+			
+			if ( dif < 500 )
+			{
+				brightness = floor((dif - 500.0f) / 500.0f * 255.0f );
+			}
+
+			ent->renderfx |= RF_RGB_TINT;
+			ent->shaderRGBA[0] = ent->shaderRGBA[1] = ent->shaderRGBA[2] = brightness;
+			ent->shaderRGBA[3] = 255;
+
+			if ( rand() & 1 )
+			{
+				ent->customShader = cgs.media.electricBodyShader;	
+			}
+			else
+			{
+				ent->customShader = cgs.media.electricBody2Shader;
+			}
+
+			cgi_R_AddRefEntityToScene( ent );
+
+			if ( random() > 0.9f )
+				cgi_S_StartSound ( ent->origin, gent->s.number, CHAN_AUTO, cgi_S_RegisterSound( "sound/effects/energy_crackle.wav" ) );
+		}
+	} 
+
+	// FORCE speed does blur trails
+	//------------------------------------------------------
+	if ( (gent->client->ps.forcePowersActive & (1 << FP_SPEED) //in force speed 
+		|| cent->gent->client->ps.legsAnim == BOTH_FORCELONGLEAP_START//or force long jump - FIXME: only 1st half of that anim?
+		|| cent->gent->client->ps.legsAnim == BOTH_FORCELONGLEAP_ATTACK )//or force long jump attack
+		&& (gent->s.number || cg.renderingThirdPerson) ) // looks dumb doing this with first peron mode on
+	{
+		//FIXME: debounce this
+		localEntity_t	*ex;
+
+		ex = CG_AllocLocalEntity();
+		ex->leType = LE_FADE_MODEL;
+		memcpy( &ex->refEntity, ent, sizeof( refEntity_t ));
+	
+		ex->refEntity.renderfx |= (RF_ALPHA_FADE | RF_NOSHADOW | RF_G2MINLOD ) ;
+		//ex->refEntity.renderfx |= RF_ALPHA_FADE;
+		ex->startTime = cg.time;
+		ex->endTime = ex->startTime + 75;
+		VectorCopy( ex->refEntity.origin, ex->pos.trBase );
+		VectorClear( ex->pos.trDelta );
+			
+		if ( gent->client->renderInfo.customRGBA[0]
+			|| gent->client->renderInfo.customRGBA[1]
+			|| gent->client->renderInfo.customRGBA[2] )
+		{
+			ex->color[0] = gent->client->renderInfo.customRGBA[0];
+			ex->color[1] = gent->client->renderInfo.customRGBA[1];
+			ex->color[2] = gent->client->renderInfo.customRGBA[2];
+		}
+		else
+		{
+			ex->color[0] = ex->color[1] = ex->color[2] = 255.0f;
+		}
+		ex->color[3] = 50.0f;
+	}
+
+	// Personal Shields
+	//------------------------
+	if ( powerups & ( 1 << PW_BATTLESUIT )) 
+	{
+		float diff = gent->client->ps.powerups[PW_BATTLESUIT] - cg.time;
+		float t;
+
+		if ( diff > 0 )
+		{
+			t = 1.0f - ( diff / (ARMOR_EFFECT_TIME * 2.0f));
+			// Only display when we have damage
+			if ( t < 0.0f || t > 1.0f ) 
+			{
+			}
+			else
+			{
+				ent->shaderRGBA[0] = ent->shaderRGBA[1] = ent->shaderRGBA[2] = 255.0f * t;
+				ent->shaderRGBA[3] = 255;
+				ent->renderfx &= ~RF_ALPHA_FADE;
+				ent->renderfx |= RF_RGB_TINT;
+				ent->customShader = cgs.media.personalShieldShader;
+				
+				cgi_R_AddRefEntityToScene( ent );
+			}
+		}
+	}
+
+	// Galak Mech shield bubble
+	//------------------------------------------------------
+	if ( powerups & ( 1 << PW_GALAK_SHIELD ))
+	{
+/*		refEntity_t tent;
+
+		memset( &tent, 0, sizeof( refEntity_t ));
+
+		tent.reType = RT_LATHE;
+
+		// Setting up the 2d control points, these get swept around to make a 3D lathed model
+		Vector2Set( tent.axis[0], 0.5, 0 );		// start point of curve
+		Vector2Set( tent.axis[1], 50,	85 );		// control point 1
+		Vector2Set( tent.axis[2], 135, -100 );		// control point 2
+		Vector2Set( tent.oldorigin, 0, -90 );		// end point of curve
+
+		if ( gent->client->poisonTime && gent->client->poisonTime + 1000 > cg.time )
+		{
+			VectorCopy( gent->pos4, tent.lightingOrigin );
+			tent.frame = gent->client->poisonTime;
+		}
+
+		mdxaBone_t	boltMatrix;
+		vec3_t angles = {0,gent->client->ps.legsYaw,0};
+
+		gi.G2API_GetBoltMatrix( cent->gent->ghoul2, gent->playerModel, gent->genericBolt1, &boltMatrix, angles, cent->lerpOrigin, cg.time, cgs.model_draw, cent->currentState.modelScale );
+		gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, tent.origin );// pass in the emitter origin here
+
+		tent.endTime = gent->fx_time + 1000;			// if you want the shell to build around the guy, pass in a time that is 1000ms after the start of the turn-on-effect
+		tent.customShader = cgi_R_RegisterShader( "gfx/effects/irid_shield" );
+
+		cgi_R_AddRefEntityToScene( &tent );*/
+	}
+
+	// Invincibility -- effect needs work
+	//------------------------------------------------------
+	/*
+	if ( powerups & ( 1 << PW_INVINCIBLE ))
+	{
+		theFxScheduler.PlayEffect( cgs.effects.forceInvincibility, cent->lerpOrigin );
+	}
+	*/
+
+	// Healing -- could use some work....maybe also make it NOT be framerate dependant
+	//------------------------------------------------------
+/*	if ( powerups & ( 1 << PW_HEALING ))
+	{
+		vec3_t axis[3];
+
+		AngleVectors( cent->gent->client->renderInfo.eyeAngles, axis[0], axis[1], axis[2] );
+
+		theFxScheduler.PlayEffect( cgs.effects.forceHeal, cent->gent->client->renderInfo.eyePoint, axis );
+	}
+*/
+	// Push Blur
+	if ( gent->forcePushTime > cg.time && gi.G2API_HaveWeGhoul2Models( cent->gent->ghoul2 ) )
+	{
+		CG_ForcePushBlur( ent->origin );
+	}
+
+	//new Jedi Academy force powers
+	//Rage effect
+	if ((cent->gent->client->ps.forcePowersActive & (1 << FP_RAGE)) &&
+		(cg.renderingThirdPerson || cent->currentState.number != cg.snap->ps.clientNum))
+	{
+		//ent->renderfx &= ~RF_FORCE_ENT_ALPHA;
+		//ent->renderfx &= ~RF_MINLIGHT;
+
+		ent->renderfx |= RF_RGB_TINT;
+		ent->shaderRGBA[0] = 255;
+		ent->shaderRGBA[1] = ent->shaderRGBA[2] = 0;
+		ent->shaderRGBA[3] = 255;
+
+		if ( rand() & 1 )
+		{
+			ent->customShader = cgs.media.electricBodyShader;	
+		}
+		else
+		{
+			ent->customShader = cgs.media.electricBody2Shader;
+		}
+
+		cgi_R_AddRefEntityToScene( ent);
+	}
+
+	//FIXME: Tavion possessed effect?  White?
+	//For now, these two are using the old shield shader. This is just so that you
+	//can tell it apart from the JM/duel shaders, but it's still very obvious.
+	if ( (cent->gent->client->ps.forcePowersActive & (1 << FP_PROTECT))
+		&& (cent->gent->client->ps.forcePowersActive & (1 << FP_ABSORB)) )
+	{//using both at once, save ourselves some rendering
+		//protect+absorb is represented by cyan..
+		ent->shaderRGBA[0] = 0;
+		ent->shaderRGBA[1] = 255;
+		ent->shaderRGBA[2] = 255;
+		ent->shaderRGBA[3] = 254;
+
+		ent->renderfx &= ~RF_RGB_TINT;
+		//ent->renderfx &= ~RF_FORCE_ENT_ALPHA;
+		if ( cent->gent->client->ps.forcePowerLevel[FP_PROTECT] > FORCE_LEVEL_1
+			|| cent->gent->client->ps.forcePowerLevel[FP_ABSORB] > FORCE_LEVEL_1 )
+		{
+			ent->customShader = cgs.media.forceShell;
+		}
+		else
+		{
+			ent->customShader = cgs.media.playerShieldDamage;
+		}
+		
+		cgi_R_AddRefEntityToScene( ent );
+	}
+	else if ( cent->gent->client->ps.forcePowersActive & (1 << FP_PROTECT) )
+	{ //protect is represented by green..
+		ent->shaderRGBA[0] = 0;
+		ent->shaderRGBA[1] = 255;
+		ent->shaderRGBA[2] = 0;
+		ent->shaderRGBA[3] = 254;
+
+		ent->renderfx &= ~RF_RGB_TINT;
+		//ent->renderfx &= ~RF_FORCE_ENT_ALPHA;
+		if ( cent->gent->client->ps.forcePowerLevel[FP_PROTECT] > FORCE_LEVEL_1 )
+		{
+			ent->customShader = cgs.media.forceShell;
+		}
+		else
+		{
+			ent->customShader = cgs.media.playerShieldDamage;
+		}
+		
+		cgi_R_AddRefEntityToScene( ent );
+	}
+	else if ( cent->gent->client->ps.forcePowersActive & (1 << FP_ABSORB))
+	{ //absorb is represented by blue..
+		ent->shaderRGBA[0] = 0;
+		ent->shaderRGBA[1] = 0;
+		ent->shaderRGBA[2] = 255;
+		ent->shaderRGBA[3] = 254;
+
+		ent->renderfx &= ~RF_RGB_TINT;
+		//ent->renderfx &= ~RF_FORCE_ENT_ALPHA;
+		if ( cent->gent->client->ps.forcePowerLevel[FP_ABSORB] > FORCE_LEVEL_1 )
+		{
+			ent->customShader = cgs.media.forceShell;
+		}
+		else
+		{
+			ent->customShader = cgs.media.playerShieldDamage;
+		}
+		
+		cgi_R_AddRefEntityToScene( ent );
+	}
+
+	if ((cg.snap->ps.forcePowersActive & (1 << FP_SEE)) 
+		&& cg.snap->ps.clientNum != cent->currentState.number 
+		&& (cent->currentState.eFlags&EF_FORCE_VISIBLE
+			|| ((cent->gent->health > 0 || cent->gent->message )
+			&& cent->currentState.eType == ET_PLAYER//other things handle this in their own render funcs
+			&& CG_PlayerCanSeeCent( cent )) 
+			)
+		)
+	{//force sight draws auras around living things
+		CG_AddForceSightShell( ent, cent );
+	}
+
+	//temp stuff for drain
+	if ( ( (cent->gent->client->ps.eFlags&EF_FORCE_DRAINED) || cent->gent->client->ps.forcePowersActive&(1<<FP_DRAIN) ) &&
+		(cg.renderingThirdPerson || cent->currentState.number != cg.snap->ps.clientNum))
+	{//draining or being drained
+		ent->renderfx |= RF_RGB_TINT;
+		ent->shaderRGBA[0] = 255;
+		ent->shaderRGBA[1] = ent->shaderRGBA[2] = 0;
+		ent->shaderRGBA[3] = 255;
+
+		if ( rand() & 1 )
+		{
+			ent->customShader = cgs.media.electricBodyShader;	
+		}
+		else
+		{
+			ent->customShader = cgs.media.electricBody2Shader;
+		}
+
+		cgi_R_AddRefEntityToScene( ent);
+	}
+}
+
+
+/*
+-------------------------
+CG_G2SetHeadBlink
+-------------------------
+*/
+static void CG_G2SetHeadBlink( centity_t *cent, qboolean bStart )
+{
+	if ( !cent )
+	{
+		return;
+	}
+	gentity_t *gent = cent->gent;
+	//FIXME: get these boneIndices game-side and pass it down?
+	//FIXME: need a version of this that *doesn't* need the mFileName in the ghoul2
+	const int hLeye = gi.G2API_GetBoneIndex( &gent->ghoul2[0], "leye", qtrue );
+	if (hLeye == -1)
+	{
+		return;
+	}
+
+	vec3_t	desiredAngles = {0};
+	int blendTime = 80;
+	qboolean bWink = qfalse;
+
+	if (bStart)
+	{
+		desiredAngles[YAW] = -38;
+		if ( !in_camera && random() > 0.95f )
+		{
+			bWink = qtrue;
+			blendTime /=3;
+		}
+	}
+	gi.G2API_SetBoneAnglesIndex( &gent->ghoul2[gent->playerModel], hLeye, desiredAngles,
+		BONE_ANGLES_POSTMULT, POSITIVE_Y, POSITIVE_Z, POSITIVE_X, NULL, blendTime, cg.time ); 
+	const int hReye = gi.G2API_GetBoneIndex( &gent->ghoul2[0], "reye", qtrue );
+	if (hReye == -1)
+	{
+		return;
+	}
+	
+	if (!bWink)
+	gi.G2API_SetBoneAnglesIndex( &gent->ghoul2[gent->playerModel], hReye, desiredAngles,
+		BONE_ANGLES_POSTMULT, POSITIVE_Y, POSITIVE_Z, POSITIVE_X, NULL, blendTime, cg.time ); 
+}
+
+/*
+-------------------------
+CG_G2SetHeadAnims
+-------------------------
+*/
+static void CG_G2SetHeadAnim( centity_t *cent, int anim )
+{
+	gentity_t	*gent = cent->gent;
+	const int blendTime = 50;
+	const animation_t *animations = level.knownAnimFileSets[gent->client->clientInfo.animFileIndex].animations;
+	int	animFlags = BONE_ANIM_OVERRIDE ;//| BONE_ANIM_BLEND;
+	// animSpeed is 1.0 if the frameLerp (ms/frame) is 50 (20 fps).
+//	float		timeScaleMod = (cg_timescale.value&&gent&&gent->s.clientNum==0&&!player_locked&&!MatrixMode&&gent->client->ps.forcePowersActive&(1<<FP_SPEED))?(1.0/cg_timescale.value):1.0;
+	const float		timeScaleMod = (cg_timescale.value)?(1.0/cg_timescale.value):1.0;
+	float animSpeed = 50.0f / animations[anim].frameLerp * timeScaleMod;
+
+	if (animations[anim].numFrames <= 0)
+	{
+		return;
+	}
+	if (anim == FACE_DEAD)
+	{
+		animFlags |= BONE_ANIM_OVERRIDE_FREEZE;
+	}
+	// animSpeed is 1.0 if the frameLerp (ms/frame) is 50 (20 fps).
+	int	firstFrame;
+	int	lastFrame;
+	if ( animSpeed < 0 )
+	{//play anim backwards
+		
+		lastFrame = animations[anim].firstFrame -1;
+		firstFrame = (animations[anim].numFrames -1) + animations[anim].firstFrame ;
+	}
+	else
+	{
+		firstFrame = animations[anim].firstFrame;
+		lastFrame = (animations[anim].numFrames) + animations[anim].firstFrame;
+	}
+
+	// first decide if we are doing an animation on the head already
+//	int startFrame, endFrame;
+//	const qboolean animatingHead =  gi.G2API_GetAnimRangeIndex(&gent->ghoul2[gent->playerModel], cent->gent->faceBone, &startFrame, &endFrame);
+	
+//	if (!animatingHead || ( animations[anim].firstFrame != startFrame ) )// only set the anim if we aren't going to do the same animation again
+	{
+		gi.G2API_SetBoneAnimIndex(&gent->ghoul2[gent->playerModel], cent->gent->faceBone,
+			firstFrame, lastFrame, animFlags, animSpeed, cg.time, -1, blendTime);
+	}
+}
+
+static qboolean CG_G2PlayerHeadAnims( centity_t *cent )
+{
+	if(!ValidAnimFileIndex(cent->gent->client->clientInfo.animFileIndex))
+	{
+		return qfalse;
+	}
+	
+	if (cent->gent->faceBone == BONE_INDEX_INVALID)
+	{	// i don't have a face
+		return qfalse;
+	}
+
+	int anim = -1;
+	
+	if ( cent->gent->health <= 0 )
+	{//Dead people close their eyes and don't make faces!
+		anim = FACE_DEAD;
+	}
+	else 
+	{
+		if (!cent->gent->client->facial_blink)
+		{	// set the timers
+			cent->gent->client->facial_blink = cg.time + Q_flrand(4000.0, 8000.0);
+			cent->gent->client->facial_timer = cg.time + Q_flrand(6000.0, 10000.0);
+		}
+		
+		//are we blinking?
+		if (cent->gent->client->facial_blink < 0)
+		{	// yes, check if we are we done blinking ?
+			if (-(cent->gent->client->facial_blink) < cg.time)
+			{	// yes, so reset blink timer
+				cent->gent->client->facial_blink = cg.time + Q_flrand(4000.0, 8000.0);
+				CG_G2SetHeadBlink( cent, qfalse );	//stop the blink
+			}
+		}
+		else // no we aren't blinking 
+		{	
+			if (cent->gent->client->facial_blink < cg.time)// but should we start ?
+			{
+				CG_G2SetHeadBlink( cent, qtrue );
+				if (cent->gent->client->facial_blink == 1)
+				{//requested to stay shut by SET_FACEEYESCLOSED
+					cent->gent->client->facial_blink = -(cg.time + 99999999.0f);// set blink timer
+				}
+				else
+				{
+					cent->gent->client->facial_blink = -(cg.time + 300.0f);// set blink timer
+				}
+			} 
+		}
+		
+
+		if (gi.VoiceVolume[cent->gent->s.clientNum] > 0)	// if we aren't talking, then it will be 0, -1 for talking but paused
+		{
+			anim = FACE_TALK1 + gi.VoiceVolume[cent->gent->s.clientNum] -1;
+			cent->gent->client->facial_timer = cg.time + Q_flrand(2000.0, 7000.0);
+			if ( cent->gent->client->breathPuffTime > cg.time + 300 )
+			{//when talking, do breath puff
+				cent->gent->client->breathPuffTime = cg.time;
+			} 
+		}
+		else if (gi.VoiceVolume[cent->gent->s.clientNum] == -1 )
+		{//talking but silent
+			anim = FACE_TALK0;
+			cent->gent->client->facial_timer = cg.time + Q_flrand(2000.0, 7000.0);
+		}
+		else if (gi.VoiceVolume[cent->gent->s.clientNum] == 0)	//don't do aux if in a slient part of speech
+		{//not talking
+			if (cent->gent->client->facial_timer < 0)	// are we auxing ?
+			{	//yes
+				if (-(cent->gent->client->facial_timer) < cg.time)// are we done auxing ?
+				{	// yes, reset aux timer
+					cent->gent->client->facial_timer = cg.time + Q_flrand(7000.0, 10000.0);
+				}
+				else
+				{	// not yet, so choose anim
+					anim = cent->gent->client->facial_anim;
+				}
+			}
+			else // no we aren't auxing 
+			{	// but should we start ?
+				if (cent->gent->client->facial_timer < cg.time)
+				{//yes
+					cent->gent->client->facial_anim = FACE_ALERT + Q_irand(0,2);	//alert, smile, frown
+					// set aux timer
+					cent->gent->client->facial_timer = -(cg.time + 2000.0);
+					anim = cent->gent->client->facial_anim;
+				} 
+			}	
+		}//talking
+	}//dead
+	if (anim != -1)
+	{
+		CG_G2SetHeadAnim( cent, anim );
+		return qtrue;
+	}
+	return qfalse;
+}
+
+/*
+-------------------------
+CG_PlayerHeadExtension
+-------------------------
+*/
+/*
+int CG_PlayerHeadExtension( centity_t *cent, refEntity_t *head )
+{
+	clientInfo_t	*ci = &cent->gent->client->clientInfo;;
+
+	// if we have facial texture extensions, go get the sound override and add it to the face skin
+	// if we aren't talking, then it will be 0
+	if (ci->extensions && (gi.VoiceVolume[cent->gent->s.clientNum] > 0))
+	{//FIXME: When talking, look at talkTarget, if any
+		//ALSO: When talking, add a head bob/movement on syllables - when gi.VoiceVolume[] changes drastically
+	
+		if ( cent->gent->health <= 0 )
+		{//Dead people close their eyes and don't make faces!  They also tell no tales...  BUM BUM BAHHHHHHH!
+			//Make them always blink and frown
+			head->customSkin = ci->headSkin + 3;
+			return qtrue;
+		}
+
+		head->customSkin = ci->headSkin + 4+gi.VoiceVolume[cent->gent->s.clientNum];
+		//reset the frown and blink timers
+	}
+	else
+	// ok, we have facial extensions, but we aren't speaking. Lets decide if we need to frown or blink
+	if (ci->extensions)
+	{
+		int	add_in = 0;
+
+		// deal with blink first
+		
+		//Dead people close their eyes and don't make faces!  They also tell no tales...  BUM BUM BAHHHHHHH!
+		if ( cent->gent->health <= 0 )
+		{
+			//Make them always blink and frown
+			head->customSkin = ci->headSkin + 3;
+			return qtrue;
+		}
+
+		if (!cent->gent->client->facial_blink)
+		{	// reset blink timer
+			cent->gent->client->facial_blink = cg.time + Q_flrand(3000.0, 5000.0);
+			cent->gent->client->facial_frown = cg.time + Q_flrand(6000.0, 10000.0);
+			cent->gent->client->facial_aux = cg.time + Q_flrand(6000.0, 10000.0);
+		}
+
+
+		// now deal with auxing
+		// are we frowning ?
+		if (cent->gent->client->facial_aux < 0)
+		{
+			// are we done frowning ?
+			if (-(cent->gent->client->facial_aux) < cg.time)
+			{
+				// reset frown timer
+				cent->gent->client->facial_aux = cg.time + Q_flrand(6000.0, 10000.0);
+			}
+			else
+			{
+				// yes so set offset to frown
+				add_in = 4;
+			}
+		}
+		// no we aren't frowning 
+		else
+		{
+			// but should we start ?
+			if (cent->gent->client->facial_aux < cg.time)
+			{
+				add_in = 4;
+				// set blink timer
+				cent->gent->client->facial_aux = -(cg.time + 3000.0);
+			}
+		}
+
+		// now, if we aren't auxing - lets see if we should be blinking or frowning
+		if (!add_in)
+		{
+			if( gi.VoiceVolume[cent->gent->s.clientNum] == -1 )
+			{//then we're talking and don't want to use blinking normal frames, force open eyes.
+				add_in = 0;
+				// reset blink timer
+				cent->gent->client->facial_blink = cg.time + Q_flrand(3000.0, 5000.0);
+			}
+			// are we blinking ?
+			else if (cent->gent->client->facial_blink < 0)
+			{
+
+				// yes so set offset to blink
+				add_in = 1;
+
+				// are we done blinking ?
+				if (-(cent->gent->client->facial_blink) < cg.time)
+				{
+					add_in = 0;
+					// reset blink timer
+					cent->gent->client->facial_blink = cg.time + Q_flrand(3000.0, 5000.0);
+				}
+			}
+			// no we aren't blinking 
+			else
+			{
+				// but should we start ?
+				if (cent->gent->client->facial_blink < cg.time)
+				{
+					add_in = 1;
+					// set blink timer
+					cent->gent->client->facial_blink = -(cg.time + 200.0);
+				}
+			}
+
+			// now deal with frowning
+			// are we frowning ?
+			if (cent->gent->client->facial_frown < 0)
+			{
+
+				// yes so set offset to frown
+				add_in += 2;
+
+				// are we done frowning ?
+				if (-(cent->gent->client->facial_frown) < cg.time)
+				{
+					add_in -= 2;
+					// reset frown timer
+					cent->gent->client->facial_frown = cg.time + Q_flrand(6000.0, 10000.0);
+				}
+			}
+			// no we aren't frowning 
+			else
+			{
+				// but should we start ?
+				if (cent->gent->client->facial_frown < cg.time)
+				{
+					add_in += 2;
+					// set blink timer
+				 	cent->gent->client->facial_frown = -(cg.time + 3000.0);
+				}
+			}
+		}
+
+		// add in whatever we should
+		head->customSkin = ci->headSkin + add_in;
+	}
+	// at this point, we don't have any facial extensions, so who cares ?
+	else
+	{
+		head->customSkin = ci->headSkin;
+	}
+
+	return qtrue;
+}
+*/
+
+//--------------------------------------------------------------
+// CG_GetTagWorldPosition
+//
+// Can pass in NULL for the axis
+//--------------------------------------------------------------
+void CG_GetTagWorldPosition( refEntity_t *model, char *tag, vec3_t pos, vec3_t axis[3] )
+{
+	orientation_t	orientation;
+
+	// Get the requested tag
+	cgi_R_LerpTag( &orientation, model->hModel, model->oldframe, model->frame,
+		1.0f - model->backlerp, tag );
+
+	VectorCopy( model->origin, pos );
+	for ( int i = 0 ; i < 3 ; i++ ) 
+	{
+		VectorMA( pos, orientation.origin[i], model->axis[i], pos );
+	}
+
+	if ( axis )
+	{
+		MatrixMultiply( orientation.axis, model->axis, axis );
+	}
+}
+
+static qboolean calcedMp = qfalse;
+
+/*
+-------------------------
+CG_GetPlayerLightLevel
+-------------------------
+*/
+
+static void CG_GetPlayerLightLevel( centity_t *cent )
+{
+	vec3_t	ambient={0}, directed, lightDir;
+
+	//Poll the renderer for the light level
+	if ( cent->currentState.clientNum == cg.snap->ps.clientNum )
+	{//hAX0R
+		ambient[0] = 666;
+	}
+	cgi_R_GetLighting( cent->lerpOrigin, ambient, directed, lightDir );
+
+	//Get the maximum value for the player
+	cent->gent->lightLevel = directed[0];
+
+	if ( directed[1] > cent->gent->lightLevel )
+		cent->gent->lightLevel = directed[1];
+
+	if ( directed[2] > cent->gent->lightLevel )
+		cent->gent->lightLevel = directed[2];
+
+	if ( cent->gent->client->ps.weapon == WP_SABER && cent->gent->client->ps.SaberLength() > 0 )
+	{
+		cent->gent->lightLevel += (cent->gent->client->ps.SaberLength()/cent->gent->client->ps.SaberLengthMax())*200;
+	}
+}
+
+#ifdef _IMMERSION
+static int CG_SaberHumForceForEnt( gentity_t *gent )
+{
+	//now: based on saber type and npc, pick correct hum sound
+	int	saberHumForce = cgi_FF_Register( "fffx/weapons/saber/saberhum1", FF_CHANNEL_WEAPON );
+	if ( gent && gent->client )
+	{
+		if ( gent->client->NPC_class == CLASS_DESANN )
+		{//desann
+			saberHumForce = cgi_FF_Register( "fffx/weapons/saber/saberhum2", FF_CHANNEL_WEAPON );
+		}
+		else if ( gent->client->NPC_class == CLASS_LUKE )
+		{//luke
+			saberHumForce = cgi_FF_Register( "fffx/weapons/saber/saberhum5", FF_CHANNEL_WEAPON );
+		}
+		else if ( gent->client->NPC_class == CLASS_PLAYER
+					|| gent->client->NPC_class == CLASS_KYLE )
+		{//Kyle NPC and player
+			saberHumForce = cgi_FF_Register( "fffx/weapons/saber/saberhum4", FF_CHANNEL_WEAPON );
+		}
+		else if ( gent->client->playerTeam == TEAM_ENEMY )//NPC_class == CLASS_TAVION )
+		{//reborn, shadowtroopers, tavion
+			saberHumForce = cgi_FF_Register( "fffx/weapons/saber/saberhum3", FF_CHANNEL_WEAPON );
+		}
+		else
+		{//allies
+			//use default
+			//saberHumSound = cgi_S_RegisterSound( "sound/weapons/saber/saberhum1.wav" );
+		}
+	}
+	return saberHumForce;
+}
+#endif // _IMMERSION
+/*
+===============
+CG_StopWeaponSounds
+
+Stops any weapon sounds as needed
+===============
+*/
+static void CG_StopWeaponSounds( centity_t *cent )
+{
+	weaponInfo_t	*weapon = &cg_weapons[ cent->currentState.weapon ];
+
+	if ( cent->currentState.weapon == WP_SABER )
+	{
+		if ( cent->gent && cent->gent->client )
+		{
+			if ( !cent->gent->client->ps.SaberActive() )
+			{//neither saber is on
+				return;
+			}
+			else if ( cent->gent->client->ps.saberInFlight ) //cent->gent->client->ps.saberInFlight )
+			{//throwing saber
+				if ( !cent->gent->client->ps.dualSabers || !cent->gent->client->ps.saber[1].Active() )
+				{//don't have a second saber or it's not on
+					return;
+				}
+			}
+		}
+
+		cgi_S_AddLoopingSound( cent->currentState.number, 
+			cent->lerpOrigin, 
+			vec3_origin, 
+			cgs.sound_precache[g_entities[cent->currentState.clientNum].client->ps.saber[0].soundLoop] );
+#ifdef _IMMERSION
+		cgi_FF_AddLoopingForce
+		(	CG_SaberHumForceForEnt( &g_entities[cent->currentState.clientNum] )
+		,	cent->currentState.number
+		);
+#endif // _IMMERSION
+		return;
+	}
+
+	if ( cent->currentState.weapon == WP_STUN_BATON || cent->currentState.weapon == WP_CONCUSSION )
+	{	//idling sounds
+		cgi_S_AddLoopingSound( cent->currentState.number, 
+			cent->lerpOrigin, 
+			vec3_origin, 
+			weapon->firingSound );
+		return;
+	}
+
+	if ( !( cent->currentState.eFlags & EF_FIRING ) )
+	{
+		if ( cent->pe.lightningFiring )
+		{
+			if ( weapon->stopSound )
+			{
+				cgi_S_StartSound( cent->lerpOrigin, cent->currentState.number, CHAN_WEAPON, weapon->stopSound );
+			}
+
+#ifdef _IMMERSION
+			if ( weapon->stopForce )
+			{
+				cgi_FF_Start( weapon->stopForce, cent->currentState.number );
+			}
+#endif // _IMMERSION
+			cent->pe.lightningFiring = qfalse;
+		}
+		return;
+	}
+
+	if ( cent->currentState.eFlags & EF_ALT_FIRING )
+	{
+		if ( weapon->altFiringSound )
+		{
+			cgi_S_AddLoopingSound( cent->currentState.number, cent->lerpOrigin, vec3_origin, weapon->altFiringSound );
+		}
+#ifdef _IMMERSION
+		if ( weapon->altFiringForce )
+		{
+			cgi_FF_AddLoopingForce( weapon->altFiringForce, cent->currentState.number );
+		}
+#endif // _IMMERSION
+		cent->pe.lightningFiring = qtrue;
+	}
+}
+
+
+//--------------- SABER STUFF --------
+extern void CG_Smoke( vec3_t origin, vec3_t dir, float radius, float speed, qhandle_t shader, int flags);
+
+static void CG_RGBForSaberColor( saber_colors_t color, vec3_t rgb )
+{
+	switch( color )
+	{
+		case SABER_RED:
+			VectorSet( rgb, 1.0f, 0.2f, 0.2f );
+			break;
+		case SABER_ORANGE:
+			VectorSet( rgb, 1.0f, 0.5f, 0.1f );
+			break;
+		case SABER_YELLOW:
+			VectorSet( rgb, 1.0f, 1.0f, 0.2f );
+			break;
+		case SABER_GREEN:
+			VectorSet( rgb, 0.2f, 1.0f, 0.2f );
+			break;
+		case SABER_BLUE:
+			VectorSet( rgb, 0.2f, 0.4f, 1.0f );
+			break;
+		case SABER_PURPLE:
+			VectorSet( rgb, 0.9f, 0.2f, 1.0f );
+			break;
+	}
+}
+
+static void CG_DoSaberLight( saberInfo_t *saber )
+{
+	//RGB combine all the colors of the sabers you're using into one averaged color!
+	if ( !saber )
+	{ 
+		return;
+	}
+
+	vec3_t		positions[MAX_BLADES*2], mid={0}, rgbs[MAX_BLADES*2], rgb={0};
+	float		lengths[MAX_BLADES*2]={0}, totallength = 0, numpositions = 0, dist, diameter = 0;
+	int			i, j;
+
+	if ( saber )
+	{
+		for ( i = 0; i < saber->numBlades; i++ )
+		{
+			if ( saber->blade[i].length >= MIN_SABERBLADE_DRAW_LENGTH )
+			{
+				//FIXME: make RGB sabers
+				CG_RGBForSaberColor( saber->blade[i].color, rgbs[i] );
+				lengths[i] = saber->blade[i].length;
+				if ( saber->blade[i].length*2.0f > diameter )
+				{
+					diameter = saber->blade[i].length*2.0f;
+				}
+				totallength += saber->blade[i].length;
+				VectorMA( saber->blade[i].muzzlePoint, saber->blade[i].length, saber->blade[i].muzzleDir, positions[i] );
+				if ( !numpositions )
+				{//first blade, store middle of that as midpoint
+					VectorMA( saber->blade[i].muzzlePoint, saber->blade[i].length*0.5, saber->blade[i].muzzleDir, mid );
+					VectorCopy( rgbs[i], rgb );
+				}
+				numpositions++;
+			}
+		}
+	}
+
+	if ( totallength )
+	{//actually have something to do	
+		if ( numpositions == 1 )
+		{//only 1 blade, midpoint is already set (halfway between the start and end of that blade), rgb is already set, so it diameter
+		}
+		else
+		{//multiple blades, calc averages
+			VectorClear( mid );
+			VectorClear( rgb );
+			//now go through all the data and get the average RGB and middle position and the radius
+			for ( i = 0; i < MAX_BLADES*2; i++ )
+			{
+				if ( lengths[i] )
+				{
+					VectorMA( rgb, lengths[i], rgbs[i], rgb );
+					VectorAdd( mid, positions[i], mid );
+				}
+			}
+
+			//get middle rgb
+			VectorScale( rgb, 1/totallength, rgb );//get the average, normalized RGB
+			//get mid position
+			VectorScale( mid, 1/numpositions, mid );
+			//find the farthest distance between the blade tips, this will be our diameter
+			for ( i = 0; i < MAX_BLADES*2; i++ )
+			{
+				if ( lengths[i] )
+				{
+					for ( j = 0; j < MAX_BLADES*2; j++ )
+					{
+						if ( lengths[j] )
+						{
+							dist = Distance( positions[i], positions[j] );
+							if ( dist > diameter )
+							{
+								diameter = dist;
+							}
+						}
+					}
+				}
+			}
+		}
+
+		cgi_R_AddLightToScene( mid, diameter + (random()*8.0f), rgb[0], rgb[1], rgb[2] );
+	}
+}
+
+static void CG_DoSaber( vec3_t origin, vec3_t dir, float length, float lengthMax, float radius, saber_colors_t color, int rfx, qboolean doLight )
+{
+	vec3_t		mid;
+	qhandle_t	blade = 0, glow = 0;
+	refEntity_t saber;
+	float radiusmult;
+
+	if ( length < MIN_SABERBLADE_DRAW_LENGTH )
+	{
+		// if the thing is so short, just forget even adding me.
+		return;
+	}
+
+	// Find the midpoint of the saber for lighting purposes
+	VectorMA( origin, length * 0.5f, dir, mid );
+	
+	switch( color )
+	{
+		case SABER_RED:
+			glow = cgs.media.redSaberGlowShader;
+			blade = cgs.media.redSaberCoreShader;
+			break;
+		case SABER_ORANGE:
+			glow = cgs.media.orangeSaberGlowShader;
+			blade = cgs.media.orangeSaberCoreShader;
+			break;
+		case SABER_YELLOW:
+			glow = cgs.media.yellowSaberGlowShader;
+			blade = cgs.media.yellowSaberCoreShader;
+			break;
+		case SABER_GREEN:
+			glow = cgs.media.greenSaberGlowShader;
+			blade = cgs.media.greenSaberCoreShader;
+			break;
+		case SABER_BLUE:
+			glow = cgs.media.blueSaberGlowShader;
+			blade = cgs.media.blueSaberCoreShader;
+			break;
+		case SABER_PURPLE:
+			glow = cgs.media.purpleSaberGlowShader;
+			blade = cgs.media.purpleSaberCoreShader;
+			break;
+	}
+
+	// always add a light because sabers cast a nice glow before they slice you in half!!  or something...
+	if ( doLight )
+	{//FIXME: RGB combine all the colors of the sabers you're using into one averaged color!
+		vec3_t rgb={1,1,1};
+		CG_RGBForSaberColor( color, rgb );
+		cgi_R_AddLightToScene( mid, (length*1.4f) + (random()*3.0f), rgb[0], rgb[1], rgb[2] );
+	}
+
+	memset( &saber, 0, sizeof( refEntity_t ));
+
+	// Saber glow is it's own ref type because it uses a ton of sprites, otherwise it would eat up too many
+	//	refEnts to do each glow blob individually
+	saber.saberLength = length;
+
+	// Jeff, I did this because I foolishly wished to have a bright halo as the saber is unleashed.  
+	// It's not quite what I'd hoped tho.  If you have any ideas, go for it!  --Pat
+	if (length < lengthMax )
+	{
+		radiusmult = 1.0 + (2.0 / length);		// Note this creates a curve, and length cannot be < 0.5.
+	}
+	else
+	{
+		radiusmult = 1.0;
+	}
+
+	float radiusRange = radius * 0.075f;
+	float radiusStart = radius-radiusRange;
+
+	saber.radius = (radiusStart + crandom() * radiusRange)*radiusmult;
+	//saber.radius = (2.8f + crandom() * 0.2f)*radiusmult;
+
+
+	VectorCopy( origin, saber.origin );
+	VectorCopy( dir, saber.axis[0] );
+	saber.reType = RT_SABER_GLOW;
+	saber.customShader = glow;
+	saber.shaderRGBA[0] = saber.shaderRGBA[1] = saber.shaderRGBA[2] = saber.shaderRGBA[3] = 0xff;
+	saber.renderfx = rfx;
+
+	cgi_R_AddRefEntityToScene( &saber );
+
+	// Do the hot core
+	VectorMA( origin, length, dir, saber.origin );
+	VectorMA( origin, -1, dir, saber.oldorigin );
+	saber.customShader = blade;
+	saber.reType = RT_LINE;
+	radiusStart = radius/3.0f;
+	saber.radius = (radiusStart + crandom() * radiusRange)*radiusmult;
+//	saber.radius = (1.0 + crandom() * 0.2f)*radiusmult;
+
+	cgi_R_AddRefEntityToScene( &saber );
+}
+
+#define	MAX_MARK_FRAGMENTS	128
+#define	MAX_MARK_POINTS		384
+extern markPoly_t *CG_AllocMark();
+
+static void CG_CreateSaberMarks( vec3_t start, vec3_t end, vec3_t normal )
+{
+//	byte			colors[4];
+	int				i, j, numFragments;
+	vec3_t			axis[3], originalPoints[4], mid;
+	vec3_t			markPoints[MAX_MARK_POINTS], projection;
+	polyVert_t		*v, verts[MAX_VERTS_ON_POLY];
+	markPoly_t		*mark;
+	markFragment_t	markFragments[MAX_MARK_FRAGMENTS], *mf;
+
+	if ( !cg_addMarks.integer ) {
+		return;
+	}
+
+	float	radius = 0.65f;
+
+	VectorSubtract( end, start, axis[1] );
+	VectorNormalizeFast( axis[1] );
+
+	// create the texture axis
+	VectorCopy( normal, axis[0] );
+	CrossProduct( axis[1], axis[0], axis[2] );
+
+	// create the full polygon that we'll project
+	for ( i = 0 ; i < 3 ; i++ ) 
+	{
+		originalPoints[0][i] = start[i] - radius * axis[1][i] - radius * axis[2][i];
+		originalPoints[1][i] = end[i] + radius * axis[1][i] - radius * axis[2][i];
+		originalPoints[2][i] = end[i] + radius * axis[1][i] + radius * axis[2][i];
+		originalPoints[3][i] = start[i] - radius * axis[1][i] + radius * axis[2][i];
+	}
+
+	VectorScale( normal, -1, projection );
+
+	// get the fragments
+	numFragments = cgi_CM_MarkFragments( 4, (const float (*)[3])originalPoints,
+					projection, MAX_MARK_POINTS, markPoints[0], MAX_MARK_FRAGMENTS, markFragments );
+
+
+	for ( i = 0, mf = markFragments ; i < numFragments ; i++, mf++ ) 
+	{
+		// we have an upper limit on the complexity of polygons that we store persistantly
+		if ( mf->numPoints > MAX_VERTS_ON_POLY ) 
+		{
+			mf->numPoints = MAX_VERTS_ON_POLY;
+		}
+
+		for ( j = 0, v = verts ; j < mf->numPoints ; j++, v++ ) 
+		{
+			vec3_t delta;
+
+			// Set up our texture coords, this may need some work 
+			VectorCopy( markPoints[mf->firstPoint + j], v->xyz );
+			VectorAdd( end, start, mid );
+			VectorScale( mid, 0.5f, mid );
+			VectorSubtract( v->xyz, mid, delta );
+
+			v->st[0] = 0.5 + DotProduct( delta, axis[1] ) * (0.05f + random() * 0.03f);
+			v->st[1] = 0.5 + DotProduct( delta, axis[2] ) * (0.15f + random() * 0.05f);
+		}
+
+		// save it persistantly, do burn first
+		mark = CG_AllocMark();
+		mark->time = cg.time;
+		mark->alphaFade = qtrue;
+		mark->markShader = cgs.media.rivetMarkShader;
+		mark->poly.numVerts = mf->numPoints;
+		mark->color[0] = mark->color[1] = mark->color[2] = mark->color[3] = 255;
+		memcpy( mark->verts, verts, mf->numPoints * sizeof( verts[0] ) );
+
+		// And now do a glow pass
+		// by moving the start time back, we can hack it to fade out way before the burn does
+		mark = CG_AllocMark();
+		mark->time = cg.time - 8500;
+		mark->alphaFade = qfalse;
+		mark->markShader = cgi_R_RegisterShader("gfx/effects/saberDamageGlow" );
+		mark->poly.numVerts = mf->numPoints;
+		mark->color[0] = 215 + random() * 40.0f;
+		mark->color[1] = 96 + random() * 32.0f;
+		mark->color[2] = mark->color[3] = random()*15.0f;
+		memcpy( mark->verts, verts, mf->numPoints * sizeof( verts[0] ) );
+	}
+}
+
+extern void FX_AddPrimitive( CEffect **effect, int killTime );
+//-------------------------------------------------------
+void CG_CheckSaberInWater( centity_t *cent, centity_t *scent, int modelIndex, vec3_t origin, vec3_t angles )
+{
+	gclient_s *client = cent->gent->client;
+	if ( !client )
+	{
+		return;
+	}
+	if ( !scent || 
+		modelIndex == -1 ||
+		scent->gent->ghoul2.size() <= modelIndex ||
+		scent->gent->ghoul2[modelIndex].mBltlist.size() <= 0 ||	//using a camera puts away your saber so you have no bolts
+		scent->gent->ghoul2[modelIndex].mModelindex == -1 )
+	{
+		return;
+	}
+
+	if (gi.totalMapContents() & (CONTENTS_WATER|CONTENTS_SLIME))
+	{
+		vec3_t		saberOrg;
+		mdxaBone_t	boltMatrix;
+
+		// figure out where the actual model muzzle is
+		gi.G2API_GetBoltMatrix( scent->gent->ghoul2, modelIndex, 0, &boltMatrix, angles, origin, cg.time, cgs.model_draw, scent->currentState.modelScale );
+		// work the matrix axis stuff into the original axis and origins used.
+		gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, saberOrg );
+
+		const int contents = gi.pointcontents( saberOrg, cent->currentState.clientNum );
+		if ( contents & (CONTENTS_WATER|CONTENTS_SLIME) )
+		{//still in water
+			client->ps.saberEventFlags |= SEF_INWATER;
+			return;
+		}
+	}
+	//not in water
+	client->ps.saberEventFlags &= ~SEF_INWATER;
+}
+
+static void CG_AddSaberBladeGo( centity_t *cent, centity_t *scent, refEntity_t *saber, int renderfx, int modelIndex, vec3_t origin, vec3_t angles, int saberNum, int bladeNum )
+{
+	vec3_t	org_, end,//org_future, 
+			axis_[3] = {0,0,0, 0,0,0, 0,0,0};//, axis_future[3]={0,0,0, 0,0,0, 0,0,0};	// shut the compiler up
+	trace_t	trace;
+	float	length;
+	int		bolt;
+	mdxaBone_t	boltMatrix;
+	qboolean tagHack = qfalse;
+
+	gclient_s *client = cent->gent->client;
+
+	if ( !client )
+	{
+		return;
+	}
+/*
+Ghoul2 Insert Start
+*/
+
+//	if (scent->gent->ghoul2.size())
+	if(1)
+	{
+		if ( !scent || 
+			modelIndex == -1 ||
+			scent->gent->ghoul2.size() <= modelIndex ||
+			scent->gent->ghoul2[modelIndex].mModelindex == -1 )
+		{
+			return;
+		}
+
+		if ( cent->gent->client->ps.saber[saberNum].type == SABER_CLAW )
+		{//hack - come off the forearm
+			int	fwdAxis = POSITIVE_Y;
+			int	rtAxis = POSITIVE_X;
+			int	upAxis = POSITIVE_Z;
+			if ( saberNum == 0 )
+			{
+				bolt = gi.G2API_AddBolt( &cent->gent->ghoul2[cent->gent->playerModel], "*r_hand_cap_r_arm" );
+				if ( bolt == -1 )
+				{
+					bolt = cent->gent->handRBolt;
+					fwdAxis = NEGATIVE_Y;
+					rtAxis = POSITIVE_Z;
+					upAxis = NEGATIVE_X;
+				}
+			}
+			else
+			{
+				bolt = gi.G2API_AddBolt( &cent->gent->ghoul2[cent->gent->playerModel], "*l_hand_cap_l_arm" );
+				if ( bolt == -1 )
+				{
+					bolt = cent->gent->handLBolt;
+					fwdAxis = NEGATIVE_Y;
+					rtAxis = POSITIVE_Z;
+					upAxis = POSITIVE_X;
+				}
+			}
+			tagHack = qtrue;//use the hacked switch statement below to position and orient the blades
+			// figure out where the actual model muzzle is
+			gi.G2API_GetBoltMatrix( cent->gent->ghoul2, cent->gent->playerModel, bolt, &boltMatrix, angles, origin, cg.time, cgs.model_draw, cent->currentState.modelScale );
+			// work the matrix axis stuff into the original axis and origins used.
+			gi.G2API_GiveMeVectorFromMatrix(boltMatrix, ORIGIN, org_);
+			gi.G2API_GiveMeVectorFromMatrix(boltMatrix, (Eorientations)fwdAxis, axis_[0]);
+			gi.G2API_GiveMeVectorFromMatrix(boltMatrix, (Eorientations)rtAxis, axis_[1]);//right
+			gi.G2API_GiveMeVectorFromMatrix(boltMatrix, (Eorientations)upAxis, axis_[2]);//up
+		}
+		else
+		{
+			// figure out where the actual model muzzle is
+
+			//old way - only 1 tag ever in a saber:
+			//gi.G2API_GetBoltMatrix(scent->gent->ghoul2, modelIndex, 0, &boltMatrix, angles, origin, cg.time, cgs.model_draw, scent->currentState.modelScale);
+
+			//New way, multiple blade tags:
+			char *tagName = va( "*blade%d", bladeNum+1 );
+			bolt = gi.G2API_AddBolt( &scent->gent->ghoul2[modelIndex], tagName );
+
+			if ( bolt == -1 )
+			{
+				tagHack = qtrue;//use the hacked switch statement below to position and orient the blades
+				//hmm, just fall back to the most basic tag (this will also make it work with pre-JKA saber models
+				bolt = gi.G2API_AddBolt( &scent->gent->ghoul2[modelIndex], "*flash" );
+				if ( bolt == -1 )
+				{//no tag_flash either?!!
+					bolt = 0;
+				}
+			}
+			gi.G2API_GetBoltMatrix(scent->gent->ghoul2, modelIndex, bolt, &boltMatrix, angles, origin, cg.time, cgs.model_draw, scent->currentState.modelScale);
+
+			// work the matrix axis stuff into the original axis and origins used.
+			gi.G2API_GiveMeVectorFromMatrix(boltMatrix, ORIGIN, org_);
+			gi.G2API_GiveMeVectorFromMatrix(boltMatrix, NEGATIVE_X, axis_[0]);//front (was NEGATIVE_Y, but the md3->glm exporter screws up this tag somethin' awful)
+			gi.G2API_GiveMeVectorFromMatrix(boltMatrix, NEGATIVE_Y, axis_[1]);//right
+			gi.G2API_GiveMeVectorFromMatrix(boltMatrix, POSITIVE_Z, axis_[2]);//up
+		}
+
+		//Now figure out where this info will be next frame
+		/*
+		{
+			vec3_t	futureOrigin, futureAngles, orgDiff, angDiff;
+			int futuretime;
+
+			//futuretime = (int)((cg.time + 99)/50) * 50;
+			futuretime = cg.time+100;
+
+			VectorCopy( angles, futureAngles );
+			VectorCopy( origin, futureOrigin );
+
+			//note: for a thrown saber, this does nothing, really
+			if ( cent->gent )
+			{
+				VectorSubtract( cent->lerpOrigin, cent->gent->lastOrigin, orgDiff );
+				VectorSubtract( cent->lerpAngles, cent->gent->lastAngles, angDiff );
+				VectorAdd( futureOrigin, orgDiff, futureOrigin );
+				for ( int i = 0; i < 3; i++ )
+				{
+					futureAngles[i] = AngleNormalize360( futureAngles[i]+angDiff[i] );
+				}
+			}
+
+			// figure out where the actual model muzzle will be after next server frame.
+			gi.G2API_GetBoltMatrix(scent->gent->ghoul2, modelIndex, 0, &boltMatrix, futureAngles, futureOrigin, futuretime, cgs.model_draw, scent->currentState.modelScale);
+			// work the matrix axis stuff into the original axis and origins used.
+			gi.G2API_GiveMeVectorFromMatrix(boltMatrix, ORIGIN, org_future);
+			gi.G2API_GiveMeVectorFromMatrix(boltMatrix, NEGATIVE_X, axis_future[0]);//was NEGATIVE_Y, but the md3->glm exporter screws up this tag somethin' awful
+		}
+		*/
+	}
+	else
+	{
+		CG_GetTagWorldPosition( saber, "*flash", org_, axis_ );
+	}
+
+/*
+Ghoul2 Insert End
+*/
+
+//====FIXMEFIXMEFIXMEFIXMEFIXME========================================================
+//FIXME: temp hack until we have a tag_flash2 for the second (3rd? 4th?) blade
+	//FIXME: maybe fall back on this if the saber model has only 1 tag_flash?
+	//			or, better yet, if the saber info doesn't list tagnames for the blades?
+	if ( tagHack )
+	{
+		switch ( cent->gent->client->ps.saber[saberNum].type )
+		{
+		case SABER_SINGLE:
+		case SABER_DAGGER:
+		case SABER_LANCE:
+			break;
+		case SABER_STAFF:
+			if ( bladeNum == 1 )
+			{
+				VectorScale( axis_[0], -1, axis_[0] );
+				VectorMA( org_, 16, axis_[0], org_ );
+			}
+			break;
+		case SABER_BROAD:
+			if ( bladeNum == 0 )
+			{
+				VectorMA( org_, -1, axis_[1], org_ );
+			}
+			else if ( bladeNum == 1 )
+			{
+				VectorMA( org_, 1, axis_[1], org_ );
+			}
+			break;
+		case SABER_PRONG:
+			if ( bladeNum == 0 )
+			{
+				VectorMA( org_, -3, axis_[1], org_ );
+			}
+			else if ( bladeNum == 1 )
+			{
+				VectorMA( org_, 3, axis_[1], org_ );
+			}
+			break;
+		case SABER_ARC:
+			VectorSubtract( axis_[1], axis_[2], axis_[1] );
+			VectorNormalizeFast( axis_[1] );
+			switch ( bladeNum )
+			{
+			case 0:
+				VectorMA( org_, 8, axis_[0], org_ );
+				VectorScale( axis_[0], 0.75f, axis_[0] );
+				VectorScale( axis_[1], 0.25f, axis_[1] );
+				VectorAdd( axis_[0], axis_[1], axis_[0] );
+				//VectorNormalize( axis_[0] );
+				break;
+			case 1:
+				//VectorMA( org_, 0, axis_[0], org_ );
+				VectorScale( axis_[0], 0.25f, axis_[0] );
+				VectorScale( axis_[1], 0.75f, axis_[1] );
+				VectorAdd( axis_[0], axis_[1], axis_[0] );
+				//VectorNormalize( axis_[0] );
+				break;
+			case 2:
+				VectorMA( org_, -8, axis_[0], org_ );
+				VectorScale( axis_[0], -0.25f, axis_[0] );
+				VectorScale( axis_[1], 0.75f, axis_[1] );
+				VectorAdd( axis_[0], axis_[1], axis_[0] );
+				//VectorNormalize( axis_[0] );
+				break;
+			case 3:
+				VectorMA( org_, -16, axis_[0], org_ );
+				VectorScale( axis_[0], -0.75f, axis_[0] );
+				VectorScale( axis_[1], 0.25f, axis_[1] );
+				VectorAdd( axis_[0], axis_[1], axis_[0] );
+				//VectorNormalize( axis_[0] );
+				break;
+			}
+			break;
+		case SABER_SAI:
+			if ( bladeNum == 1 )
+			{
+				VectorMA( org_, -3, axis_[1], org_ );
+			}
+			else if ( bladeNum == 2 )
+			{
+				VectorMA( org_, 3, axis_[1], org_ );
+			}
+			break;
+		case SABER_CLAW:
+			switch ( bladeNum )
+			{
+			case 0:
+				VectorMA( org_, 2, axis_[0], org_ );
+				VectorMA( org_, 2, axis_[2], org_ );
+				break;
+			case 1:
+				VectorMA( org_, 2, axis_[0], org_ );
+				VectorMA( org_, 2, axis_[2], org_ );
+				VectorMA( org_, 2, axis_[1], org_ );
+				break;
+			case 2:
+				VectorMA( org_, 2, axis_[0], org_ );
+				VectorMA( org_, 2, axis_[2], org_ );
+				VectorMA( org_, -2, axis_[1], org_ );
+				break;
+			}
+			/*
+			if ( bladeNum == 1 )
+			{
+				VectorMA( org_, -2, axis_[1], org_ );
+			}
+			else if ( bladeNum == 2 )
+			{
+				VectorMA( org_, 2, axis_[1], org_ );
+			}
+			*/
+			break;
+		case SABER_STAR:
+			/*
+			if ( saber )
+			{
+				VectorCopy( saber->origin, org_ );
+			}
+			else
+			{
+				bolt = cent->gent->handRBolt;
+				if ( saberNum == 1 )
+				{
+					bolt = cent->gent->handLBolt;
+				}
+				// figure out where the actual model muzzle is
+				gi.G2API_GetBoltMatrix( cent->gent->ghoul2, cent->gent->playerModel, bolt, &boltMatrix, angles, origin, cg.time, cgs.model_draw, cent->currentState.modelScale );
+				// work the matrix axis stuff into the original axis and origins used.
+				gi.G2API_GiveMeVectorFromMatrix(boltMatrix, ORIGIN, org_);
+			}
+			*/
+			/*
+			if ( cent->currentState.clientNum && cent->gent->client->ps.saberInFlight )
+			{//WTF?  For some reason, sabers thrown by NPCs are 90 degrees off on roll
+				VectorCopy( axis_[1], axis_[2] );
+			}
+			*/
+			switch ( bladeNum )
+			{
+			case 0:
+				VectorMA( org_, 8, axis_[0], org_ );
+				break;
+			case 1:
+				VectorScale( axis_[0], 0.33f, axis_[0] );
+				VectorScale( axis_[2], 0.67f, axis_[2] );
+				VectorAdd( axis_[0], axis_[2], axis_[0] );
+				//VectorNormalize( axis_[0] );
+				VectorMA( org_, 8, axis_[0], org_ );
+				break;
+			case 2:
+				VectorScale( axis_[0], -0.33f, axis_[0] );
+				VectorScale( axis_[2], 0.67f, axis_[2] );
+				VectorAdd( axis_[0], axis_[2], axis_[0] );
+				//VectorNormalize( axis_[0] );
+				VectorMA( org_, 8, axis_[0], org_ );
+				break;
+			case 3:
+				VectorScale( axis_[0], -1, axis_[0] );
+				VectorMA( org_, 8, axis_[0], org_ );
+				break;
+			case 4:
+				VectorScale( axis_[0], -0.33f, axis_[0] );
+				VectorScale( axis_[2], -0.67f, axis_[2] );
+				VectorAdd( axis_[0], axis_[2], axis_[0] );
+				//VectorNormalize( axis_[0] );
+				VectorMA( org_, 8, axis_[0], org_ );
+				break;
+			case 5:
+				VectorScale( axis_[0], 0.33f, axis_[0] );
+				VectorScale( axis_[2], -0.67f, axis_[2] );
+				VectorAdd( axis_[0], axis_[2], axis_[0] );
+				//VectorNormalize( axis_[0] );
+				VectorMA( org_, 8, axis_[0], org_ );
+				break;
+			}
+			break;
+		case SABER_TRIDENT:
+			switch ( bladeNum )
+			{
+			case 0:
+				VectorMA( org_, 24, axis_[0], org_ );
+				break;
+			case 1:
+				VectorMA( org_, -6, axis_[1], org_ );
+				VectorMA( org_, 24, axis_[0], org_ );
+				break;
+			case 2:
+				VectorMA( org_, 6, axis_[1], org_ );
+				VectorMA( org_, 24, axis_[0], org_ );
+				break;
+			case 3:
+				VectorMA( org_, -32, axis_[0], org_ );
+				VectorScale( axis_[0], -1, axis_[0] );
+				break;
+			}
+			break;
+		case SABER_SITH_SWORD:
+			//no blade
+			break;
+		}
+	}
+//====FIXMEFIXMEFIXMEFIXMEFIXME========================================================
+
+	//store where saber is this frame
+	VectorCopy( org_, cent->gent->client->ps.saber[saberNum].blade[bladeNum].muzzlePoint );
+	VectorCopy( axis_[0], cent->gent->client->ps.saber[saberNum].blade[bladeNum].muzzleDir );
+	if ( saberNum == 0 && bladeNum == 0 )
+	{
+		VectorCopy( org_, cent->gent->client->renderInfo.muzzlePoint );
+		VectorCopy( axis_[0], cent->gent->client->renderInfo.muzzleDir );
+		cent->gent->client->renderInfo.mPCalcTime = cg.time;
+	}
+	//length for purposes of rendering and marks trace will be longer than blade so we don't damage past a wall's surface
+	if ( cent->gent->client->ps.saber[saberNum].blade[bladeNum].length < cent->gent->client->ps.saber[saberNum].blade[bladeNum].lengthMax )
+	{
+		if ( cent->gent->client->ps.saber[saberNum].blade[bladeNum].length < cent->gent->client->ps.saber[saberNum].blade[bladeNum].lengthMax - 8 )
+		{
+			length = cent->gent->client->ps.saber[saberNum].blade[bladeNum].length + 8;
+		}
+		else
+		{
+			length = cent->gent->client->ps.saber[saberNum].blade[bladeNum].lengthMax;
+		}
+	}
+	else
+	{
+		length = cent->gent->client->ps.saber[saberNum].blade[bladeNum].length;
+	}
+	VectorMA( org_, length, axis_[0], end );
+
+	// Now store where the saber will be after next frame.
+	//VectorCopy(org_future, cent->gent->client->renderInfo.muzzlePointNext);
+	//VectorCopy(axis_future[0], cent->gent->client->renderInfo.muzzleDirNext);
+
+	VectorAdd( end, axis_[0], end );
+
+	// If the saber is in flight we shouldn't trace from the player to the muzzle point
+	if ( cent->gent->client->ps.saberInFlight && saberNum == 0 )
+	{
+		trace.fraction = 1.0f;
+	}
+	else
+	{
+		vec3_t rootOrigin;
+		if (cent->gent->rootBone>=0 && cent->gent->ghoul2.IsValid() && cent->gent->ghoul2[0].animModelIndexOffset)//If it has an animOffset it's a cinematic anim
+		{	//i might be running out of my bounding box, so get my root origin
+			mdxaBone_t	boltMatrix;
+			gi.G2API_GetBoltMatrix( cent->gent->ghoul2, cent->gent->playerModel, cent->gent->rootBone, 
+					&boltMatrix, angles, cent->lerpOrigin, 
+					cg.time, cgs.model_draw, cent->currentState.modelScale);
+			gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, rootOrigin );
+		}
+		else
+		{
+			VectorCopy( cent->lerpOrigin, rootOrigin );
+		}
+		gi.trace( &trace, rootOrigin, NULL, NULL, cent->gent->client->ps.saber[saberNum].blade[bladeNum].muzzlePoint, cent->currentState.number, CONTENTS_SOLID );
+	}
+
+	if ( trace.fraction < 1.0f )
+	{
+		// Saber is on the other side of a wall
+		cent->gent->client->ps.saber[saberNum].blade[bladeNum].length = 0.1f;
+		cent->gent->client->ps.saberEventFlags &= ~SEF_INWATER;
+	}
+	else
+	{
+		extern vmCvar_t cg_saberEntMarks;
+		int traceMask = MASK_SOLID;
+
+		if ( cg_saberEntMarks.integer )
+		{
+			if ( cent->gent->client->ps.saberInFlight
+				|| PM_SaberInAttack( cent->gent->client->ps.saberMove )
+				//|| PM_SaberInTransitionAny( cent->gent->client->ps.saberMove )
+				|| PM_SaberInSpecialAttack( cent->gent->client->ps.torsoAnim ) )
+			{
+				traceMask |= (CONTENTS_BODY|CONTENTS_CORPSE);
+			}
+		}
+
+		for ( int i = 0; i < 1; i++ )//was 2 because it would go through architecture and leave saber trails on either side of the brush - but still looks bad if we hit a corner, blade is still 8 longer than hit
+		{
+			if ( i )
+			{//tracing from end to base
+				gi.trace( &trace, end, NULL, NULL, org_, cent->currentState.clientNum, traceMask );
+			}
+			else
+			{//tracing from base to end
+				gi.trace( &trace, org_, NULL, NULL, end, cent->currentState.clientNum, traceMask|CONTENTS_WATER|CONTENTS_SLIME );
+			}
+			
+			if ( trace.fraction < 1.0f )
+			{
+				if ( (trace.contents&CONTENTS_WATER) || (trace.contents&CONTENTS_SLIME) )
+				{
+					/*
+					if ( !(cent->gent->client->ps.saberEventFlags&SEF_INWATER) )
+					{
+					}
+					*/
+					if ( !Q_irand( 0, 10 ) )
+					{//FIXME: don't do this this way.... :)
+#ifdef _IMMERSION
+						if ( !cent->gent->client->ps.saberInFlight || saberNum != 0 )
+						{
+							cgi_FF_Start( cgi_FF_Register( "fffx/weapons/saber/hitwater", FF_CHANNEL_WEAPON ), cent->currentState.number );
+						}
+#endif // _IMMERSION
+						vec3_t	spot;
+						VectorCopy( trace.endpos, spot );
+						spot[2] += 4;
+						if ( Q_irand( 1, client->ps.saber[saberNum].numBlades ) == 1 )
+						{
+							theFxScheduler.PlayEffect( "saber/boil", spot );
+							cgi_S_StartSound ( spot, -1, CHAN_AUTO, cgi_S_RegisterSound( "sound/weapons/saber/hitwater.wav" ) );
+						}
+					}
+					//cent->gent->client->ps.saberEventFlags |= SEF_INWATER;
+					//don't do other trace
+					i = 1;
+				}
+				else
+				{
+					if ( !(trace.surfaceFlags & SURF_NOIMPACT) // never spark on sky
+						&& (trace.entityNum == ENTITYNUM_WORLD || cg_entities[trace.entityNum].currentState.solid == SOLID_BMODEL) 
+						&& Q_irand( 1, client->ps.saber[saberNum].numBlades ) == 1 )
+					{
+						//was "sparks/spark"
+						theFxScheduler.PlayEffect( "sparks/spark_nosnd", trace.endpos, trace.plane.normal );
+					}
+					// All I need is a bool to mark whether I have a previous point to work with.
+					//....come up with something better..
+					if ( client->ps.saber[saberNum].blade[bladeNum].trail.haveOldPos[i] )
+					{
+						if ( trace.entityNum == ENTITYNUM_WORLD || (cg_entities[trace.entityNum].currentState.eFlags & EF_PERMANENT) || cg_entities[trace.entityNum].currentState.eType == ET_TERRAIN )
+						{//only put marks on architecture
+							// Let's do some cool burn/glowing mark bits!!!
+							CG_CreateSaberMarks( client->ps.saber[saberNum].blade[bladeNum].trail.oldPos[i], trace.endpos, trace.plane.normal );
+						
+							if ( Q_irand( 1, client->ps.saber[saberNum].numBlades ) == 1 )
+							{
+								//make a sound
+								if ( cg.time - cent->gent->client->ps.saberHitWallSoundDebounceTime >= 100 )
+								{//ugh, need to have a real sound debouncer... or do this game-side
+									cent->gent->client->ps.saberHitWallSoundDebounceTime = cg.time;
+	#ifdef _IMMERSION
+									int index = Q_irand( 1, 3 );
+									cgi_S_StartSound ( cent->lerpOrigin, cent->currentState.clientNum, CHAN_WEAPON, cgi_S_RegisterSound( va ( "sound/weapons/saber/saberhitwall%d.wav", index ) ) );
+									if ( !cent->gent->client->ps.saberInFlight || saberNum == 1 )
+									{
+										cgi_FF_Start( cgi_FF_Register( va( "fffx/weapons/saber/saberhitwall%d", index ), FF_CHANNEL_WEAPON ), cent->currentState.clientNum );
+									}
+	#else
+									cgi_S_StartSound ( cent->lerpOrigin, cent->currentState.clientNum, CHAN_ITEM, cgi_S_RegisterSound( va ( "sound/weapons/saber/saberhitwall%d.wav", Q_irand( 1, 3 ) ) ) );
+	#endif // _IMMERSION
+								}
+							}
+						}
+						else if ( !i )
+						{//can put marks on G2 clients (but only on base to tip trace)
+							gentity_t *hitEnt = &g_entities[trace.entityNum];
+							if ( hitEnt && hitEnt->client && hitEnt->ghoul2.size() )
+							{//burn mark with glow
+								//FIXME: set the correct angle based on direction of swing
+								//FIXME: keep a count of these on the ent and don't add too many
+								int lifeTime = (1.01-(float)(hitEnt->health)/hitEnt->max_health) * (float)Q_irand( 5000, 10000 );
+								vec3_t uaxis;
+								VectorSubtract(client->ps.saber[saberNum].blade[bladeNum].trail.oldPos[i], trace.endpos, uaxis);
+								CG_AddGhoul2Mark( cgs.media.bdecal_saberglowmark, Q_flrand(3.0, 4.0), trace.endpos, axis_[0], hitEnt->s.number,
+									hitEnt->client->ps.origin, hitEnt->client->renderInfo.legsYaw, hitEnt->ghoul2, hitEnt->s.modelScale,
+									lifeTime, uaxis );
+							}
+						}
+					}
+					else
+					{
+						// if we impact next frame, we'll mark a slash mark
+						client->ps.saber[saberNum].blade[bladeNum].trail.haveOldPos[i] = qtrue;
+						CG_ImpactMark( cgs.media.rivetMarkShader, client->ps.saber[saberNum].blade[bladeNum].trail.oldPos[i], client->ps.saber[saberNum].blade[bladeNum].trail.oldNormal[i],
+								0.0f, 1.0f, 1.0f, 1.0f, 1.0f, qfalse, 1.1f, qfalse );
+					}
+				}
+
+				// stash point so we can connect-the-dots later
+				VectorCopy( trace.endpos, client->ps.saber[saberNum].blade[bladeNum].trail.oldPos[i] );
+				VectorCopy( trace.plane.normal, client->ps.saber[saberNum].blade[bladeNum].trail.oldNormal[i] );
+
+				if ( !i && trace.contents&(CONTENTS_SOLID|CONTENTS_TERRAIN|CONTENTS_SHOTCLIP) )
+				{	//Now that we don't let the blade go through walls, we need to shorten the blade when it hits one
+					cent->gent->client->ps.saber[saberNum].blade[bladeNum].length = cent->gent->client->ps.saber[saberNum].blade[bladeNum].length * trace.fraction;//this will stop damage from going through walls
+					if ( cent->gent->client->ps.saber[saberNum].blade[bladeNum].length <= 0.1f )
+					{//SIGH... hack so it doesn't play the saber turn-on sound that plays when you first turn the saber on (assumed when saber is active but length is zero)
+						cent->gent->client->ps.saber[saberNum].blade[bladeNum].length = 0.1f;//FIXME: may go through walls still??
+					}
+					//FIXME: should probably re-extend instantly, not use the "turning-on" growth rate
+				}
+			}
+			else
+			{
+				cent->gent->client->ps.saberEventFlags &= ~SEF_INWATER;
+				if ( client->ps.saber[saberNum].blade[bladeNum].trail.haveOldPos[i] )
+				{
+					// Hmmm, no impact this frame, but we have an old point
+					// Let's put the mark there, we should use an endcap mark to close the line, but we 
+					//	can probably just get away with a round mark
+					CG_ImpactMark( cgs.media.rivetMarkShader, client->ps.saber[saberNum].blade[bladeNum].trail.oldPos[i], client->ps.saber[saberNum].blade[bladeNum].trail.oldNormal[i],
+							0.0f, 1.0f, 1.0f, 1.0f, 1.0f, qfalse, 1.1f, qfalse );
+				}
+
+				// we aren't impacting, so turn off our mark tracking mechanism
+				client->ps.saber[saberNum].blade[bladeNum].trail.haveOldPos[i] = qfalse;
+			}
+		}
+	}
+
+	// Added 10/02/02 by Aurelio Reis.
+	// If the Blade is not active, leave here; we do not Render it!
+/*	if ( cent->gent->client->ps.saber[saberNum].type == SABER_SITH_SWORD )
+	{//draws no blade or trail
+		//FIXME: draw some sort of energy halo and motion trail!
+		return;
+	}
+*/
+	if ( !client->ps.saber[saberNum].blade[bladeNum].active && client->ps.saber[saberNum].blade[bladeNum].length <= 0 )
+	{
+		return;
+	}
+
+	saberTrail_t	*saberTrail = &client->ps.saber[saberNum].blade[bladeNum].trail;
+
+#define SABER_TRAIL_TIME	40.0f
+
+	// if we happen to be timescaled or running in a high framerate situation, we don't want to flood
+	//	the system with very small trail slices...but perhaps doing it by distance would yield better results?
+	if ( saberTrail->lastTime > cg.time )
+	{//after a pause, cg.time jumps ahead in time for one frame 
+	 //and lastTime gets set to that and will freak out, so, since
+	 //it's never valid for saberTrail->lastTime to be > cg.time, 
+	 //cap it to cg.time here
+		saberTrail->lastTime = cg.time;
+	}
+	if ( cg.time > saberTrail->lastTime + 2  && saberTrail->inAction ) // 2ms
+	{
+		if ( saberTrail->inAction && cg.time < saberTrail->lastTime + 300 ) // if we have a stale segment, don't draw until we have a fresh one
+		{
+			vec3_t	rgb1={255,255,255};
+
+			if ( cent->gent->client->ps.saber[saberNum].type != SABER_SITH_SWORD )
+			{
+				switch( client->ps.saber[saberNum].blade[bladeNum].color )
+				{ 
+					case SABER_RED:
+						VectorSet( rgb1, 255.0f, 0.0f, 0.0f );
+						break;
+					case SABER_ORANGE:
+						VectorSet( rgb1, 255.0f, 64.0f, 0.0f );
+						break;
+					case SABER_YELLOW:
+						VectorSet( rgb1, 255.0f, 255.0f, 0.0f );
+						break;
+					case SABER_GREEN:
+						VectorSet( rgb1, 0.0f, 255.0f, 0.0f );
+						break;
+					case SABER_BLUE:
+						VectorSet( rgb1, 0.0f, 64.0f, 255.0f );
+						break;
+					case SABER_PURPLE:
+						VectorSet( rgb1, 220.0f, 0.0f, 255.0f );
+						break;
+				}
+			}
+
+			float diff = cg.time - saberTrail->lastTime;
+
+			// I'm not sure that clipping this is really the best idea
+			if ( diff <= SABER_TRAIL_TIME * 2 )
+			{
+				// build a quad
+				CTrail *fx = new CTrail;
+
+				float duration;
+
+				if ( cent->gent->client->ps.saber[saberNum].type == SABER_SITH_SWORD)
+				{
+					fx->mShader = cgs.media.swordTrailShader;
+					duration = saberTrail->duration/2.0f; // stay around twice as long
+					VectorSet( rgb1, 32.0f, 32.0f, 32.0f ); // make the sith sword trail pretty faint
+				} 
+				else 
+				{ 
+					fx->mShader = cgs.media.saberBlurShader;
+					duration = saberTrail->duration/5.0f;
+				}
+
+				float oldAlpha = 1.0f - ( diff / duration );
+
+				// Go from new muzzle to new end...then to old end...back down to old muzzle...finally
+				//	connect back to the new muzzle...this is our trail quad
+				VectorCopy( org_, fx->mVerts[0].origin );
+				VectorMA( end, 3.0f, axis_[0], fx->mVerts[1].origin );
+
+				VectorCopy( saberTrail->tip, fx->mVerts[2].origin );
+				VectorCopy( saberTrail->base, fx->mVerts[3].origin );
+
+				// New muzzle
+				VectorCopy( rgb1, fx->mVerts[0].rgb );
+				fx->mVerts[0].alpha = 255.0f;
+
+				fx->mVerts[0].ST[0] = 0.0f;
+				fx->mVerts[0].ST[1] = 0.99f;
+				fx->mVerts[0].destST[0] = 0.99f;
+				fx->mVerts[0].destST[1] = 0.99f;
+
+				// new tip
+				VectorCopy( rgb1, fx->mVerts[1].rgb );
+				fx->mVerts[1].alpha = 255.0f;
+				
+				fx->mVerts[1].ST[0] = 0.0f;
+				fx->mVerts[1].ST[1] = 0.0f;
+				fx->mVerts[1].destST[0] = 0.99f;
+				fx->mVerts[1].destST[1] = 0.0f;
+
+				// old tip
+				VectorCopy( rgb1, fx->mVerts[2].rgb );
+				fx->mVerts[2].alpha = 255.0f;
+
+				fx->mVerts[2].ST[0] = 0.99f - oldAlpha; // NOTE: this just happens to contain the value I want
+				fx->mVerts[2].ST[1] = 0.0f;
+				fx->mVerts[2].destST[0] = 0.99f + fx->mVerts[2].ST[0];
+				fx->mVerts[2].destST[1] = 0.0f;
+
+				// old muzzle
+				VectorCopy( rgb1, fx->mVerts[3].rgb );
+				fx->mVerts[3].alpha = 255.0f;
+
+				fx->mVerts[3].ST[0] = 0.99f - oldAlpha; // NOTE: this just happens to contain the value I want
+				fx->mVerts[3].ST[1] = 0.99f;
+				fx->mVerts[3].destST[0] = 0.99f + fx->mVerts[2].ST[0];
+				fx->mVerts[3].destST[1] = 0.99f; 
+		
+//				fx->SetFlags( FX_USE_ALPHA );
+				FX_AddPrimitive( (CEffect**)&fx, duration );//SABER_TRAIL_TIME );
+			}
+		} 
+
+		// we must always do this, even if we aren't active..otherwise we won't know where to pick up from
+		VectorCopy( org_, saberTrail->base );
+		VectorMA( end, 3.0f, axis_[0], saberTrail->tip );
+		saberTrail->lastTime = cg.time;
+	}
+
+	if ( cent->gent->client->ps.saber[saberNum].type == SABER_SITH_SWORD)
+	{
+		// don't need to do nuthin else
+		return;
+	}
+
+	// Pass in the renderfx flags attached to the saber weapon model...this is done so that saber glows
+	//	will get rendered properly in a mirror...not sure if this is necessary??
+	CG_DoSaber( org_, axis_[0], length, client->ps.saber[saberNum].blade[bladeNum].lengthMax, client->ps.saber[saberNum].blade[bladeNum].radius, client->ps.saber[saberNum].blade[bladeNum].color, renderfx, (qboolean)(client->ps.saber[saberNum].numBlades<3) );
+}
+
+void CG_AddSaberBlade( centity_t *cent, centity_t *scent, refEntity_t *saber, int renderfx, int modelIndex, vec3_t origin, vec3_t angles )
+{
+	//FIXME: if this is a dropped saber, it could be possible that it's the second saber?
+	if ( cent->gent->client )
+	{
+		for ( int i = 0; i < cent->gent->client->ps.saber[0].numBlades;i++ )
+		{
+			CG_AddSaberBladeGo( cent, scent, saber, renderfx, modelIndex, origin, angles, 0, i );
+		}
+		if ( cent->gent->client->ps.saber[0].numBlades > 2 )
+		{// add blended light
+			CG_DoSaberLight( &cent->gent->client->ps.saber[0] );
+		}
+	}
+}
+
+/*
+static void CG_AddSaberBlades( centity_t *cent, int renderfx, vec3_t origin, vec3_t angles, int saberNum )
+{
+	if ( cent->gent->client )
+	{
+		for ( int i = 0; i < cent->gent->client->ps.saber[saberNum].numBlades; i++ )
+		{
+			CG_AddSaberBladeGo( cent, cent, NULL, renderfx, cent->gent->weaponModel[saberNum], origin, angles, saberNum, i );
+		}
+	}
+}
+*/
+//--------------- END SABER STUFF --------
+
+/*
+===============
+CG_Player
+
+  FIXME: Extend this to be a render func for all multiobject entities in the game such that:
+
+	You can have and stack multiple animated pieces (not just legs and torso)
+	You can attach "bolt-ons" that either animate or don't (weapons, heads, borg pieces)
+	You can attach any object to any tag on any object (weapon on the head, etc.)
+	
+	Basically, keep a list of objects:
+		Root object (in this case, the legs) with this info:
+			model
+			skin
+			effects
+			scale
+			if animated, frame or anim number
+			drawn at origin and angle of master entity
+		Animated objects, with this info:
+			model
+			skin
+			effects
+			scale
+			frame or anim number
+			object it's attached to
+			tag to attach it's tag_parent to
+			angle offset to attach it with
+		Non-animated objects, with this info:
+			model
+			skin
+			effects
+			scale
+			object it's attached to
+			tag to attach it's tag_parent to
+			angle offset to attach it with
+
+  ALSO: 
+	Move the auto angle setting back up to the game
+	Implement 3-axis scaling
+	Implement alpha
+	Implement tint
+	Implement other effects (generic call effect at org and dir (or tag), with parms?)
+
+===============
+*/
+extern qboolean G_GetRootSurfNameWithVariant( gentity_t *ent, const char *rootSurfName, char *returnSurfName, int returnSize );
+extern qboolean G_ControlledByPlayer( gentity_t *self );
+extern qboolean G_RagDoll(gentity_t *ent, vec3_t forcedAngles);
+int	cg_saberOnSoundTime[MAX_GENTITIES] = {0};
+
+void CG_Player( centity_t *cent ) {
+	clientInfo_t	*ci;
+	qboolean		shadow, staticScale = qfalse;
+	float			shadowPlane;
+	entityState_t	*ent;
+	const weaponData_t  *wData = NULL;
+
+	if ( cent->currentState.eFlags & EF_NODRAW ) 
+	{
+		return;
+	}
+
+	//make sure this thing has a gent and client
+	if(!cent->gent)
+	{
+		return;
+	}
+
+	if(!cent->gent->client)
+	{
+		return;
+	}
+
+	calcedMp = qfalse;
+	ent = &cent->currentState;
+
+
+	//Get the player's light level for stealth calculations
+	CG_GetPlayerLightLevel( cent );
+
+	if ((in_camera) && cent->currentState.clientNum == 0 )	// If player in camera then no need for shadow
+	{
+		return;
+	}
+
+	if(cent->currentState.number == 0 && !cg.renderingThirdPerson )//!cg_thirdPerson.integer )
+	{
+		calcedMp = qtrue;
+	}
+
+	ci = &cent->gent->client->clientInfo;
+
+	if ( !ci->infoValid ) 
+	{
+		return;
+	}
+
+	G_RagDoll(cent->gent, cent->lerpAngles);
+
+	if ( cent->currentState.weapon )
+	{
+		wData = &weaponData[cent->currentState.weapon];
+	}
+/*
+Ghoul2 Insert Start
+*/
+	if (cent->gent->ghoul2.size())	//do we have ghoul models attached?
+	{
+		refEntity_t			ent;
+		vec3_t				tempAngles;
+		memset (&ent, 0, sizeof(ent));
+
+		//FIXME: if at all possible, do all our sets before our gets to do only *1* G2 skeleton transform per render frame
+		CG_SetGhoul2Info(&ent, cent);
+
+		// Weapon sounds may need to be stopped, so check now
+		CG_StopWeaponSounds( cent );
+
+		// add powerups floating behind the player
+		CG_PlayerPowerups( cent );
+
+		// add the shadow
+		//FIXME: funcs that modify our origin below will cause the shadow to be in the wrong spot
+		shadow = CG_PlayerShadow( cent, &shadowPlane );
+
+		// add a water splash if partially in and out of water
+		CG_PlayerSplash( cent );
+
+		// get the player model information
+		ent.renderfx = 0;
+		if ( !cg.renderingThirdPerson || cg.zoomMode ) 
+		{//in first person or zoomed in
+			if ( cg.snap->ps.viewEntity <= 0 || cg.snap->ps.viewEntity >= ENTITYNUM_WORLD)
+			{//no viewentity
+				if ( cent->currentState.number == cg.snap->ps.clientNum )
+				{//I am the player
+					if ( cg.snap->ps.weapon != WP_SABER && cg.snap->ps.weapon != WP_MELEE )
+					{//not using saber or fists
+						ent.renderfx = RF_THIRD_PERSON;			// only draw in mirrors
+					}
+				}
+			}
+			else if ( cent->currentState.number == cg.snap->ps.viewEntity )
+			{//I am the view entity
+				if ( cg.snap->ps.weapon != WP_SABER && cg.snap->ps.weapon != WP_MELEE )
+				{//not using first person saber test or, if so, not using saber
+					ent.renderfx = RF_THIRD_PERSON;			// only draw in mirrors
+				}
+			}
+		}
+
+		if ( cent->gent->client->ps.powerups[PW_DISINT_2] > cg.time )
+		{//ghost!
+			ent.renderfx = RF_THIRD_PERSON;			// only draw in mirrors
+		}
+		else if (cg_shadows.integer == 2 && (ent.renderfx & RF_THIRD_PERSON))
+		{ //show stencil shadow in first person now because we can -rww
+			ent.renderfx |= RF_SHADOW_ONLY;
+		}
+
+		if ( (cg_shadows.integer == 2 && !in_camera) || (cg_shadows.integer == 3 && shadow) ) 
+		{
+			ent.renderfx |= RF_SHADOW_PLANE;
+		}
+		ent.shadowPlane = shadowPlane;
+		ent.renderfx |= RF_LIGHTING_ORIGIN;			// use the same origin for all
+		if ( cent->gent->NPC && cent->gent->NPC->scriptFlags & SCF_MORELIGHT )
+		{
+			ent.renderfx |= RF_MORELIGHT;			//bigger than normal min light
+		}
+
+		CG_RegisterWeapon( cent->currentState.weapon );
+
+//---------------
+		Vehicle_t *pVeh;
+
+		if ( cent->currentState.eFlags & EF_LOCKED_TO_WEAPON && cent->gent && cent->gent->health > 0 && cent->gent->owner )
+		{
+			centity_t	*chair = &cg_entities[cent->gent->owner->s.number];
+			if ( chair && chair->gent )
+			{
+				vec3_t		temp;
+				mdxaBone_t	boltMatrix;
+
+				//NOTE: call this so it updates on the server and client
+				if ( chair->gent->bounceCount )
+				{//EWeb
+					// We'll set the turret angles directly
+					VectorClear( temp );
+					VectorClear( chair->gent->pos1 );
+
+					temp[PITCH] = cent->lerpAngles[PITCH];
+					chair->gent->pos1[YAW] = AngleSubtract( cent->lerpAngles[YAW], chair->gent->s.angles[YAW] );//remember which dir our turret is facing for later
+					cent->lerpAngles[ROLL] = 0;
+
+                    BG_G2SetBoneAngles( chair, chair->gent, chair->gent->lowerLumbarBone, chair->gent->pos1, BONE_ANGLES_POSTMULT, POSITIVE_Z, NEGATIVE_X, NEGATIVE_Y, cgs.model_draw ); 
+                    BG_G2SetBoneAngles( chair, chair->gent, chair->gent->upperLumbarBone, temp, BONE_ANGLES_POSTMULT, POSITIVE_Z, NEGATIVE_X, NEGATIVE_Y, cgs.model_draw ); 
+				}
+				else
+				{
+					// We'll set the turret yaw directly
+					VectorClear( chair->gent->s.apos.trBase );
+					VectorClear( temp );
+
+					chair->gent->s.apos.trBase[YAW] = cent->lerpAngles[YAW];
+					temp[PITCH] = -cent->lerpAngles[PITCH];
+					cent->lerpAngles[ROLL] = 0;
+                    BG_G2SetBoneAngles( chair, chair->gent, chair->gent->lowerLumbarBone, temp, BONE_ANGLES_POSTMULT, POSITIVE_Y, POSITIVE_Z, POSITIVE_X, cgs.model_draw ); 
+				}
+				//gi.G2API_SetBoneAngles( &chair->gent->ghoul2[0], "swivel_bone", temp, BONE_ANGLES_POSTMULT, POSITIVE_Y, POSITIVE_Z, POSITIVE_X, cgs.model_draw ); 
+				VectorCopy( temp, chair->gent->lastAngles );
+
+				gi.G2API_StopBoneAnimIndex( &cent->gent->ghoul2[cent->gent->playerModel], cent->gent->hipsBone );
+
+				// Getting the seat bolt here
+				gi.G2API_GetBoltMatrix( chair->gent->ghoul2, chair->gent->playerModel, chair->gent->headBolt, 
+						&boltMatrix, chair->gent->s.apos.trBase, chair->gent->currentOrigin, cg.time,
+						cgs.model_draw, chair->currentState.modelScale );
+
+				if ( chair->gent->bounceCount )
+				{//put behind it, not in chair
+					gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, ent.origin );
+					gi.G2API_GiveMeVectorFromMatrix( boltMatrix, NEGATIVE_Y, chair->gent->pos3 );
+					chair->gent->pos3[2] = 0;
+					VectorNormalizeFast( chair->gent->pos3 );
+					VectorMA( ent.origin, -44.0f, chair->gent->pos3, ent.origin );
+					ent.origin[2] = cent->lerpOrigin[2];
+					cent->lerpAngles[YAW] = vectoyaw( chair->gent->pos3 );
+					cent->lerpAngles[ROLL] = 0;
+					CG_G2PlayerAngles( cent, ent.axis, tempAngles);
+					calcedMp = qtrue;
+				}
+				else
+				{//sitting in it
+					// Storing ent position, bolt position, and bolt axis
+					gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, ent.origin );
+					VectorCopy( ent.origin, chair->gent->pos2 );
+					gi.G2API_GiveMeVectorFromMatrix( boltMatrix, POSITIVE_Y, chair->gent->pos3 );
+					gi.G2API_GiveMeVectorFromMatrix( boltMatrix, NEGATIVE_Z, chair->gent->pos4 );
+
+					AnglesToAxis( cent->lerpAngles, ent.axis );
+					VectorCopy( cent->lerpAngles, tempAngles);//tempAngles is needed a lot below
+				}
+
+				VectorCopy( ent.origin, ent.oldorigin );
+				VectorCopy( ent.origin, ent.lightingOrigin );
+
+				// FIXME:  Mike claims that hacking the eyepoint will make them shoot at me.......so,
+				//	we move up from the seat bolt and store off that point.
+	//			VectorMA( ent.origin, -20, chair->gent->pos3, cent->gent->client->renderInfo.eyePoint );
+	//			VectorMA( cent->gent->client->renderInfo.eyePoint, 40, chair->gent->pos4, cent->gent->client->renderInfo.eyePoint );
+			}
+		}
+		else if ( ( pVeh = G_IsRidingVehicle( cent->gent ) ) != NULL )
+		{//rider
+			CG_G2PlayerAngles( cent, ent.axis, tempAngles);
+			//Deal with facial expressions
+			CG_G2PlayerHeadAnims( cent );
+
+			centity_t *vehEnt = &cg_entities[cent->gent->owner->s.number];
+			CG_CalcEntityLerpPositions( vehEnt );
+			// Get the driver tag.
+			mdxaBone_t	boltMatrix;
+			gi.G2API_GetBoltMatrix( vehEnt->gent->ghoul2, vehEnt->gent->playerModel, vehEnt->gent->crotchBolt, 
+					&boltMatrix, vehEnt->lerpAngles, vehEnt->lerpOrigin, (cg.time?cg.time:level.time), NULL, vehEnt->currentState.modelScale );
+			gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, ent.origin );
+
+			float savPitch = cent->lerpAngles[PITCH];
+			VectorCopy( vehEnt->lerpAngles, cent->lerpAngles );
+			AnglesToAxis( cent->lerpAngles, ent.axis );
+
+			VectorCopy( ent.origin, ent.oldorigin );
+			VectorCopy( ent.origin, ent.lightingOrigin );
+
+			VectorCopy( cent->lerpAngles, tempAngles );//tempAngles is needed a lot below
+			VectorCopy( ent.origin, cent->lerpOrigin );
+			VectorCopy( ent.origin, cent->gent->client->ps.origin );
+			//bah, keep our pitch!
+			cent->lerpAngles[PITCH] = savPitch;
+		}
+		else if ( ( (cent->gent->client->ps.eFlags&EF_HELD_BY_RANCOR)||(cent->gent->client->ps.eFlags&EF_HELD_BY_WAMPA) )
+			&& cent->gent && cent->gent->activator )
+		{
+			centity_t	*monster = &cg_entities[cent->gent->activator->s.number];
+			if ( monster && monster->gent && monster->gent->inuse && monster->gent->health > 0 )
+			{
+				mdxaBone_t	boltMatrix;
+				// Getting the bolt here
+				//in mouth
+				int boltIndex = monster->gent->gutBolt;
+				if ( monster->gent->count == 1 )
+				{//in hand
+					boltIndex = monster->gent->handRBolt;
+				}
+				vec3_t rancAngles = {0};
+				rancAngles[YAW] = monster->lerpAngles[YAW];
+				gi.G2API_GetBoltMatrix( monster->gent->ghoul2, monster->gent->playerModel, boltIndex, 
+						&boltMatrix, rancAngles, monster->lerpOrigin, cg.time,
+						cgs.model_draw, monster->currentState.modelScale );
+				// Storing ent position, bolt position, and bolt axis
+				gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, ent.origin );
+				if ( (cent->gent->client->ps.eFlags&EF_HELD_BY_WAMPA) )
+				{
+					gi.G2API_GiveMeVectorFromMatrix( boltMatrix, NEGATIVE_Y, ent.axis[0] );
+					gi.G2API_GiveMeVectorFromMatrix( boltMatrix, POSITIVE_X, ent.axis[1] );
+					gi.G2API_GiveMeVectorFromMatrix( boltMatrix, POSITIVE_Z, ent.axis[2] );
+				}
+				else if ( monster->gent->count == 1 )
+				{
+					gi.G2API_GiveMeVectorFromMatrix( boltMatrix, NEGATIVE_Y, ent.axis[0] );
+					gi.G2API_GiveMeVectorFromMatrix( boltMatrix, POSITIVE_X, ent.axis[1] );
+					gi.G2API_GiveMeVectorFromMatrix( boltMatrix, POSITIVE_Z, ent.axis[2] );
+				}
+				else
+				{
+					gi.G2API_GiveMeVectorFromMatrix( boltMatrix, POSITIVE_Z, ent.axis[0] );
+					gi.G2API_GiveMeVectorFromMatrix( boltMatrix, NEGATIVE_Y, ent.axis[1] );
+					gi.G2API_GiveMeVectorFromMatrix( boltMatrix, NEGATIVE_X, ent.axis[2] );
+				}
+				//FIXME: this is messing up our axis and turning us inside-out
+				if ( cent->gent->client->isRagging )
+				{//hack, ragdoll has you way at bottom of bounding box
+					VectorMA( ent.origin, 32, ent.axis[2], ent.origin );
+				}
+				VectorCopy( ent.origin, ent.oldorigin );
+				VectorCopy( ent.origin, ent.lightingOrigin );
+
+				vectoangles( ent.axis[0], cent->lerpAngles );
+				vec3_t temp;
+				vectoangles( ent.axis[2], temp );
+				cent->lerpAngles[ROLL] = -temp[PITCH];
+
+				VectorCopy( cent->lerpAngles, tempAngles );//tempAngles is needed a lot below
+				VectorCopy( ent.origin, cent->lerpOrigin );
+				VectorCopy( ent.origin, cent->gent->client->ps.origin );
+			//	if ( (cent->gent->client->ps.eFlags&EF_HELD_BY_WAMPA) )
+			//	{
+					vectoangles( ent.axis[0], cent->lerpAngles );
+					VectorCopy( cent->lerpAngles, tempAngles );//tempAngles is needed a lot below
+			//	}
+			//	else
+			//	{
+			//		//cent->gent->client->ps.viewangles[YAW] = cent->lerpAngles[YAW];
+			//	}
+			}
+			else
+			{//wtf happened to the guy holding me?  Better get out
+				cent->gent->activator = NULL;
+				cent->gent->client->ps.eFlags &= ~(EF_HELD_BY_WAMPA|EF_HELD_BY_RANCOR);
+			}
+		}
+		else if ( (cent->gent->client->ps.eFlags&EF_HELD_BY_SAND_CREATURE) 
+			&& cent->gent 
+			&& cent->gent->activator )
+		{
+			centity_t	*sand_creature = &cg_entities[cent->gent->activator->s.number];
+			if ( sand_creature && sand_creature->gent )
+			{
+				mdxaBone_t	boltMatrix;
+				// Getting the bolt here
+				//in hand
+				vec3_t scAngles = {0};
+				scAngles[YAW] = sand_creature->lerpAngles[YAW];
+				gi.G2API_GetBoltMatrix( sand_creature->gent->ghoul2, sand_creature->gent->playerModel, sand_creature->gent->gutBolt, 
+						&boltMatrix, scAngles, sand_creature->lerpOrigin, cg.time,
+						cgs.model_draw, sand_creature->currentState.modelScale );
+				// Storing ent position, bolt position, and bolt axis
+				gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, ent.origin );
+				gi.G2API_GiveMeVectorFromMatrix( boltMatrix, NEGATIVE_Y, ent.axis[0] );
+				gi.G2API_GiveMeVectorFromMatrix( boltMatrix, NEGATIVE_X, ent.axis[1] );
+				gi.G2API_GiveMeVectorFromMatrix( boltMatrix, POSITIVE_Z, ent.axis[2] );
+				//FIXME: this is messing up our axis and turning us inside-out
+				if ( cent->gent->client->isRagging )
+				{//hack, ragdoll has you way at bottom of bounding box
+					VectorMA( ent.origin, 32, ent.axis[2], ent.origin );
+				}
+				VectorCopy( ent.origin, ent.oldorigin );
+				VectorCopy( ent.origin, ent.lightingOrigin );
+
+				vectoangles( ent.axis[0], cent->lerpAngles );
+				vec3_t temp;
+				vectoangles( ent.axis[2], temp );
+				cent->lerpAngles[ROLL] = -temp[PITCH];
+
+				VectorCopy( cent->lerpAngles, tempAngles );//tempAngles is needed a lot below
+				VectorCopy( ent.origin, cent->lerpOrigin );
+				VectorCopy( ent.origin, cent->gent->client->ps.origin );
+				cent->gent->client->ps.viewangles[YAW] = cent->lerpAngles[YAW];
+			}
+		}
+		else
+		{
+//---------------		
+			CG_G2PlayerAngles( cent, ent.axis, tempAngles);
+			//Deal with facial expressions
+			CG_G2PlayerHeadAnims( cent );
+			
+			/*
+			if ( cent->gent->client->ps.eFlags & EF_FORCE_DRAINED 
+				&& !VectorCompare( cent->gent->client->ps.forceDrainOrg, vec3_origin ) )
+			{//HACKHACKHACK!!!! being drained
+				VectorCopy( cent->gent->client->ps.forceDrainOrg, ent.origin);
+			}
+			else
+			*/
+			{
+				VectorCopy( cent->lerpOrigin, ent.origin);
+			}
+
+			if (ent.modelScale[2] && ent.modelScale[2] != 1.0f)
+			{
+				ent.origin[2] += 24 * (ent.modelScale[2] - 1);
+			}
+			VectorCopy( ent.origin, ent.oldorigin);
+			VectorCopy( ent.origin, ent.lightingOrigin );
+		}	
+		
+		if ( cent->gent && cent->gent->client )
+		{
+			cent->gent->client->ps.legsYaw = tempAngles[YAW];
+		}
+		ScaleModelAxis(&ent);
+
+//HACK - add swoop model
+		/*
+		if ( cent->currentState.vehicleIndex != VEHICLE_NONE 
+			&& g_vehicleInfo[cent->currentState.vehicleIndex].type == VH_SPEEDER )
+		{//add it at my origin
+			//FIXME: should be a G2 model
+			refEntity_t	swoopEnt;
+
+			memset (&swoopEnt, 0, sizeof(swoopEnt));
+			
+			VectorCopy( cent->lerpOrigin, swoopEnt.origin );
+			VectorMA( swoopEnt.origin, -32, ent.axis[2], swoopEnt.origin );
+			VectorCopy( swoopEnt.origin, swoopEnt.oldorigin );
+			AnglesToAxis( cent->currentState.vehicleAngles, swoopEnt.axis );
+			swoopEnt.hModel = cgs.model_draw[g_vehicleInfo[cent->currentState.vehicleIndex].modelIndex];
+			cgi_R_AddRefEntityToScene( &swoopEnt );
+		}
+		*/
+//HACK - add swoop model
+
+extern vmCvar_t	cg_thirdPersonAlpha;
+
+		if ( (cent->gent->s.number == 0 || G_ControlledByPlayer( cent->gent )) )
+		{
+			float alpha = 1.0f;		
+			if ( (cg.overrides.active&CG_OVERRIDE_3RD_PERSON_APH) )
+			{
+				alpha = cg.overrides.thirdPersonAlpha;
+			}
+			else
+			{
+				alpha = cg_thirdPersonAlpha.value;
+			}
+
+			if ( alpha < 1.0f )
+			{
+				ent.renderfx |= RF_ALPHA_FADE;
+				ent.shaderRGBA[3] = (unsigned char)(alpha * 255.0f);
+			}
+		}
+
+		if ( cg_debugHealthBars.integer )
+		{
+			if ( cent->gent && cent->gent->health > 0 && cent->gent->max_health > 0 )
+			{//draw a health bar over them
+				CG_AddHealthBarEnt( cent->currentState.clientNum );
+			} 
+		}
+		CG_AddRefEntityWithPowerups( &ent, cent->currentState.powerups, cent );
+		VectorCopy( tempAngles, cent->renderAngles );
+
+		//Initialize all these to *some* valid data
+		VectorCopy( ent.origin, cent->gent->client->renderInfo.headPoint );
+		VectorCopy( ent.origin, cent->gent->client->renderInfo.handRPoint );
+		VectorCopy( ent.origin, cent->gent->client->renderInfo.handLPoint );
+		VectorCopy( ent.origin, cent->gent->client->renderInfo.footRPoint );
+		VectorCopy( ent.origin, cent->gent->client->renderInfo.footLPoint );
+		VectorCopy( ent.origin, cent->gent->client->renderInfo.torsoPoint );
+		VectorCopy( cent->lerpAngles, cent->gent->client->renderInfo.torsoAngles );
+		VectorCopy( ent.origin, cent->gent->client->renderInfo.crotchPoint );
+		if ( cent->currentState.number != 0 
+			|| cg.renderingThirdPerson 
+			|| cg.snap->ps.stats[STAT_HEALTH] <= 0 
+			|| ( !cg.renderingThirdPerson && (cg.snap->ps.weapon == WP_SABER||cg.snap->ps.weapon == WP_MELEE) )//First person saber
+			)
+		{//in some third person mode or NPC
+			//we don't override thes in pure 1st person because they will be set before this func
+			VectorCopy( ent.origin, cent->gent->client->renderInfo.eyePoint );
+			VectorCopy( cent->lerpAngles, cent->gent->client->renderInfo.eyeAngles );
+			if ( !cent->gent->client->ps.saberInFlight )
+			{
+				VectorCopy( ent.origin, cent->gent->client->renderInfo.muzzlePoint );
+				VectorCopy( ent.axis[0], cent->gent->client->renderInfo.muzzleDir );
+			}
+		}
+		//now try to get the right data
+
+		mdxaBone_t	boltMatrix;
+		vec3_t		tempAxis, G2Angles = {0, tempAngles[YAW], 0};
+
+		if ( cent->gent->handRBolt != -1 )
+		{
+			//Get handRPoint		
+			gi.G2API_GetBoltMatrix( cent->gent->ghoul2, cent->gent->playerModel, cent->gent->handRBolt, 
+							&boltMatrix, G2Angles, ent.origin, cg.time, 
+							cgs.model_draw, cent->currentState.modelScale );
+			gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, cent->gent->client->renderInfo.handRPoint );
+		}
+		if ( cent->gent->handLBolt != -1 )
+		{
+			//always get handLPoint too...?
+			gi.G2API_GetBoltMatrix( cent->gent->ghoul2, cent->gent->playerModel, cent->gent->handLBolt, 
+							&boltMatrix, G2Angles, ent.origin, cg.time, 
+							cgs.model_draw, cent->currentState.modelScale );
+			gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, cent->gent->client->renderInfo.handLPoint );
+		}
+		if ( cent->gent->footLBolt != -1 )
+		{
+			//get the feet
+			gi.G2API_GetBoltMatrix( cent->gent->ghoul2, cent->gent->playerModel, cent->gent->footLBolt, 
+							&boltMatrix, G2Angles, ent.origin, cg.time, 
+							cgs.model_draw, cent->currentState.modelScale );
+			gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, cent->gent->client->renderInfo.footLPoint );
+		}
+		
+		if ( cent->gent->footRBolt != -1 )
+		{
+			gi.G2API_GetBoltMatrix( cent->gent->ghoul2, cent->gent->playerModel, cent->gent->footRBolt, 
+							&boltMatrix, G2Angles, ent.origin, cg.time, 
+							cgs.model_draw, cent->currentState.modelScale );
+			gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, cent->gent->client->renderInfo.footRPoint );
+		}
+
+		//Handle saber
+		if ( cent->gent 
+			&& cent->gent->client 
+			&& ( cent->currentState.weapon == WP_SABER || cent->gent->client->ps.saberInFlight ) 
+			&& cent->gent->client->NPC_class != CLASS_ATST )
+		{//FIXME: somehow saberactive is getting lost over the network
+			//loop this and do for both sabers
+			int	numSabers = 1;
+			if ( cent->gent->client->ps.dualSabers )
+			{
+				numSabers = 2;
+			}
+			for ( int saberNum = 0; saberNum < numSabers; saberNum++ )
+			{
+				if ( cent->gent->client->ps.saberEventFlags&SEF_INWATER )
+				{
+					cent->gent->client->ps.saber[saberNum].Deactivate();
+				}
+				//loop this and do for both blades
+				for ( int bladeNum = 0; bladeNum < cent->gent->client->ps.saber[saberNum].numBlades; bladeNum++ )
+				{
+					if ( !cent->gent->client->ps.saber[saberNum].blade[bladeNum].active || 
+						cent->gent->client->ps.saber[saberNum].blade[bladeNum].length > cent->gent->client->ps.saber[saberNum].blade[bladeNum].lengthMax )//hack around network lag for now
+					{//saber blade is off
+						if ( cent->gent->client->ps.saber[saberNum].blade[bladeNum].length > 0 )
+						{
+							if ( cent->gent->client->ps.stats[STAT_HEALTH] <= 0 )
+							{//dead, didn't actively turn it off
+								cent->gent->client->ps.saber[saberNum].blade[bladeNum].length -= cent->gent->client->ps.saber[saberNum].blade[bladeNum].lengthMax/10 * cg.frametime/100;
+							}
+							else
+							{//actively turned it off, shrink faster
+								cent->gent->client->ps.saber[saberNum].blade[bladeNum].length -= cent->gent->client->ps.saber[saberNum].blade[bladeNum].lengthMax/10 * cg.frametime/100;
+							}
+						}
+					}
+					else 
+					{//saber blade is on
+						if ( cent->gent->client->ps.saber[saberNum].blade[bladeNum].length < cent->gent->client->ps.saber[saberNum].blade[bladeNum].lengthMax )
+						{
+							if ( !cent->gent->client->ps.saber[saberNum].blade[bladeNum].length )
+							{
+								qhandle_t saberOnSound = cgs.sound_precache[g_entities[cent->currentState.clientNum].client->ps.saber[saberNum].soundOn];
+	#ifdef _IMMERSION
+								ffHandle_t saberOnForce;
+								if ( cent->gent->client->playerTeam == TEAM_PLAYER )
+								{
+									saberOnForce = cgi_FF_Register( "fffx/weapons/saber/saberon", FF_CHANNEL_WEAPON );
+								}
+								else
+								{
+									saberOnForce = cgi_FF_Register( "fffx/weapons/saber/enemy_saber_on", FF_CHANNEL_WEAPON );
+								}
+	#endif // _IMMERSION
+								if ( !cent->gent->client->ps.weaponTime 
+									&& !saberNum//first saber only
+									&& !bladeNum )//first blade only
+								{//make us play the turn on anim
+									cent->gent->client->ps.weaponstate = WEAPON_RAISING;
+									cent->gent->client->ps.weaponTime = 250;
+								}
+								if ( cent->gent->client->ps.saberInFlight && saberNum == 0 )
+								{//play it on the saber
+									if ( cg_saberOnSoundTime[cent->currentState.number] < cg.time )
+									{
+										cgi_S_UpdateEntityPosition( cent->gent->client->ps.saberEntityNum, g_entities[cent->gent->client->ps.saberEntityNum].currentOrigin );
+										cgi_S_StartSound (NULL, cent->gent->client->ps.saberEntityNum, CHAN_AUTO, saberOnSound );
+										cg_saberOnSoundTime[cent->currentState.number] = cg.time;//so we don't play multiple on sounds at one time
+									}
+								}
+								else
+								{
+									if ( cg_saberOnSoundTime[cent->currentState.number] < cg.time )
+									{
+										cgi_S_StartSound (NULL, cent->currentState.number, CHAN_AUTO, saberOnSound );
+										cg_saberOnSoundTime[cent->currentState.number] = cg.time;//so we don't play multiple on sounds at one time
+#ifdef _IMMERSION
+										cgi_FF_Start( saberOnForce, cent->currentState.number );
+#endif // _IMMERSION
+									}
+								}
+							}
+							if ( cg.frametime > 0 )
+							{
+								if ( PM_SuperBreakWinAnim( cent->gent->client->ps.torsoAnim ) )
+								{//just keep it full length!
+									//NOTE: does this mean it will go through walls now...?
+									cent->gent->client->ps.saber[saberNum].blade[bladeNum].length = cent->gent->client->ps.saber[saberNum].blade[bladeNum].lengthMax;
+								}
+								else
+								{
+									cent->gent->client->ps.saber[saberNum].blade[bladeNum].length += cent->gent->client->ps.saber[saberNum].blade[bladeNum].lengthMax/10 * cg.frametime/100;
+								}
+							}
+							if ( cent->gent->client->ps.saber[saberNum].blade[bladeNum].length > cent->gent->client->ps.saber[saberNum].blade[bladeNum].lengthMax )
+							{
+								cent->gent->client->ps.saber[saberNum].blade[bladeNum].length = cent->gent->client->ps.saber[saberNum].blade[bladeNum].lengthMax;
+							}
+						}
+					}
+
+					if ( cent->gent->client->ps.saber[saberNum].blade[bladeNum].length > 0 )
+					{
+						if ( !cent->gent->client->ps.saberInFlight || saberNum != 0 )//&& cent->gent->client->ps.saberActive)
+						{//holding the saber in-hand
+		//						CGhoul2Info *currentModel = &cent->gent->ghoul2[1]; 
+		//						CGhoul2Info *nextModel = &cent->gent->ghoul2[1]; 
+							//FIXME: need a version of this that *doesn't* need the mFileName in the ghoul2
+							//FIXME: use an actual surfaceIndex?
+							char	handName[MAX_QPATH];
+							if ( saberNum == 0 )
+							{
+								//this returns qfalse if it doesn't exist or isn't being rendered
+								if ( G_GetRootSurfNameWithVariant( cent->gent, "r_hand", handName, sizeof(handName) ) ) //!gi.G2API_GetSurfaceRenderStatus( &cent->gent->ghoul2[cent->gent->playerModel], "r_hand" ) )//surf is still on
+								{
+									CG_AddSaberBladeGo( cent, cent, NULL, ent.renderfx, cent->gent->weaponModel[saberNum], ent.origin, tempAngles, saberNum, bladeNum );
+									//CG_AddSaberBlades( cent, ent.renderfx, ent.origin, tempAngles, saberNum );
+								}//else, the limb will draw the blade itself
+							}
+							else if ( saberNum == 1 )
+							{
+								//this returns qfalse if it doesn't exist or isn't being rendered
+								if ( G_GetRootSurfNameWithVariant( cent->gent, "l_hand", handName, sizeof(handName) ) ) //!gi.G2API_GetSurfaceRenderStatus( &cent->gent->ghoul2[cent->gent->playerModel], "l_hand" ) )//surf is still on
+								{
+									CG_AddSaberBladeGo( cent, cent, NULL, ent.renderfx, cent->gent->weaponModel[saberNum], ent.origin, tempAngles, saberNum, bladeNum );
+									//CG_AddSaberBlades( cent, ent.renderfx, ent.origin, tempAngles, saberNum );
+								}//else, the limb will draw the blade itself
+							}
+						}//in-flight saber draws it's own blade
+					}
+					else
+					{
+						if ( cent->gent->client->ps.saber[saberNum].blade[bladeNum].length < 0 )
+						{
+							cent->gent->client->ps.saber[saberNum].blade[bladeNum].length = 0;
+						}
+						//if ( cent->gent->client->ps.saberEventFlags&SEF_INWATER )
+						{
+							CG_CheckSaberInWater( cent, cent, cent->gent->weaponModel[saberNum], ent.origin, tempAngles );
+						}
+					}
+					if ( cent->currentState.weapon == WP_SABER 
+						&& (cent->gent->client->ps.saber[saberNum].blade[bladeNum].length > 0 || cent->gent->client->ps.saberInFlight) )
+					{
+						calcedMp = qtrue;
+					}		
+				}
+			}
+			//add the light
+			if ( cent->gent->client->ps.dualSabers )
+			{
+				if ( cent->gent->client->ps.saber[0].Length() > 0.0f 
+					&& !cent->gent->client->ps.saberInFlight )
+				{
+					if ( cent->gent->client->ps.saber[0].numBlades > 2 )
+					{// add blended light
+						CG_DoSaberLight( &cent->gent->client->ps.saber[0] );
+					}
+				}
+				if ( cent->gent->client->ps.saber[1].Length() > 0.0f )
+				{
+					if ( cent->gent->client->ps.saber[1].numBlades > 2 )
+					{// add blended light
+						CG_DoSaberLight( &cent->gent->client->ps.saber[1] );
+					}
+				}
+			}
+			else if ( cent->gent->client->ps.saber[0].Length() > 0.0f
+				&& !cent->gent->client->ps.saberInFlight )
+			{
+				if ( cent->gent->client->ps.saber[0].numBlades > 2 )
+				{// add blended light
+					CG_DoSaberLight( &cent->gent->client->ps.saber[0] );
+				}
+			}
+		}
+
+		if ( cent->currentState.number != 0 
+			|| cg.renderingThirdPerson 
+			|| cg.snap->ps.stats[STAT_HEALTH] <= 0 
+			|| ( !cg.renderingThirdPerson && (cg.snap->ps.weapon == WP_SABER||cg.snap->ps.weapon == WP_MELEE) )//First person saber
+			)
+		{//if NPC, third person, or dead, unless using saber
+			//Get eyePoint & eyeAngles
+			/*
+			if ( cg.snap->ps.viewEntity > 0 
+				&& cg.snap->ps.viewEntity < ENTITYNUM_WORLD 
+				&& cg.snap->ps.viewEntity == cent->currentState.clientNum )
+			{//player is in an entity camera view, ME
+				VectorCopy( ent.origin, cent->gent->client->renderInfo.eyePoint );
+				VectorCopy( tempAngles, cent->gent->client->renderInfo.eyeAngles );
+				VectorCopy( ent.origin, cent->gent->client->renderInfo.headPoint );
+			}
+			else 
+			*/if ( cent->gent->headBolt == -1 )
+			{//no headBolt
+				VectorCopy( ent.origin, cent->gent->client->renderInfo.eyePoint );
+				VectorCopy( tempAngles, cent->gent->client->renderInfo.eyeAngles );
+				VectorCopy( ent.origin, cent->gent->client->renderInfo.headPoint );
+			}
+			else
+			{
+				//FIXME: if head is missing, we should let the dismembered head set our eyePoint...
+				gi.G2API_GetBoltMatrix(cent->gent->ghoul2, cent->gent->playerModel, cent->gent->headBolt, &boltMatrix, tempAngles, ent.origin, cg.time, cgs.model_draw, cent->currentState.modelScale );
+				gi.G2API_GiveMeVectorFromMatrix(boltMatrix, ORIGIN, cent->gent->client->renderInfo.eyePoint);
+				if ( cent->gent->client->NPC_class == CLASS_RANCOR )
+				{//temp hack
+					gi.G2API_GiveMeVectorFromMatrix(boltMatrix,	POSITIVE_X, tempAxis);
+				}
+				else
+				{
+					gi.G2API_GiveMeVectorFromMatrix(boltMatrix,	NEGATIVE_Y, tempAxis);
+				}
+				vectoangles( tempAxis, cent->gent->client->renderInfo.eyeAngles );
+				//estimate where the neck would be...
+				gi.G2API_GiveMeVectorFromMatrix(boltMatrix,	NEGATIVE_Z, tempAxis);//go down to find neck
+				VectorMA( cent->gent->client->renderInfo.eyePoint, 8, tempAxis, cent->gent->client->renderInfo.headPoint );
+
+				// Play the breath puffs (or not).
+				CG_BreathPuffs( cent, tempAngles, ent.origin );
+			}
+			//Get torsoPoint & torsoAngles
+			if (cent->gent->chestBolt>=0)
+			{
+				gi.G2API_GetBoltMatrix( cent->gent->ghoul2, cent->gent->playerModel, cent->gent->chestBolt, &boltMatrix, tempAngles, ent.origin, cg.time, cgs.model_draw, cent->currentState.modelScale );
+				gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, cent->gent->client->renderInfo.torsoPoint );
+				gi.G2API_GiveMeVectorFromMatrix( boltMatrix, NEGATIVE_Z, tempAxis );
+				vectoangles( tempAxis, cent->gent->client->renderInfo.torsoAngles );
+			}
+			else
+			{
+				VectorCopy( ent.origin, cent->gent->client->renderInfo.torsoPoint);
+				VectorClear(cent->gent->client->renderInfo.torsoAngles);
+			}
+			//get crotchPoint
+			if (cent->gent->crotchBolt>=0)
+			{
+				gi.G2API_GetBoltMatrix( cent->gent->ghoul2, cent->gent->playerModel, cent->gent->crotchBolt, &boltMatrix, tempAngles, ent.origin, cg.time, cgs.model_draw, cent->currentState.modelScale );
+				gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, cent->gent->client->renderInfo.crotchPoint );
+			}
+			else
+			{
+				VectorCopy( ent.origin, cent->gent->client->renderInfo.crotchPoint);
+			}
+			//NOTE: these are used for any case where an NPC fires and the next shot needs to come out
+			//		of a new barrel/point.  That way the muzzleflash will draw on the old barrel/point correctly
+			//NOTE: I'm only doing this for the saboteur right now - AT-STs might need this... others?
+			vec3_t oldMP = {0,0,0};
+			vec3_t oldMD = {0,0,0};
+
+			if( !calcedMp )
+			{
+				if ( cent->gent && cent->gent->client && cent->gent->client->NPC_class == CLASS_ATST)
+				{//FIXME: different for the three different weapon positions
+					mdxaBone_t		boltMatrix;
+					int				bolt;
+					entityState_t	*es;
+
+					es = &cent->currentState;
+
+					// figure out where the actual model muzzle is
+					if (es->weapon == WP_ATST_MAIN)
+					{
+						if ( !es->number )
+						{//player, just use left one, I guess
+							if ( cent->gent->alt_fire )
+							{
+								bolt = cent->gent->handRBolt;
+							}
+							else
+							{
+								bolt = cent->gent->handLBolt;
+							}
+						}
+						else if (cent->gent->count > 0)
+						{
+							cent->gent->count = 0;
+							bolt = cent->gent->handLBolt;
+						}
+						else
+						{
+							cent->gent->count = 1;
+							bolt = cent->gent->handRBolt;
+						}
+					}
+					else	// ATST SIDE weapons
+					{
+						if ( cent->gent->alt_fire)
+						{
+							bolt = cent->gent->genericBolt2;
+						}
+						else
+						{
+							bolt = cent->gent->genericBolt1;
+						}
+					}
+
+					gi.G2API_GetBoltMatrix( cent->gent->ghoul2, cent->gent->playerModel, bolt, &boltMatrix, tempAngles, ent.origin, cg.time, cgs.model_draw, cent->currentState.modelScale );
+
+					// work the matrix axis stuff into the original axis and origins used.
+					gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, cent->gent->client->renderInfo.muzzlePoint );
+					gi.G2API_GiveMeVectorFromMatrix( boltMatrix, NEGATIVE_Y, cent->gent->client->renderInfo.muzzleDir );
+				}
+				else if ( cent->gent && cent->gent->client && cent->gent->client->NPC_class == CLASS_GALAKMECH )
+				{
+					int bolt = -1;
+					if ( cent->gent->lockCount )
+					{//using the big laser beam
+						bolt = cent->gent->handLBolt;
+					}
+					else//repeater
+					{
+						if ( cent->gent->alt_fire )
+						{//fire from the lower barrel (not that anyone will ever notice this, but...)
+							bolt = cent->gent->genericBolt3;
+						}
+						else
+						{
+							bolt = cent->gent->handRBolt;
+						}
+					}
+
+					if ( bolt == -1 )
+					{
+						VectorCopy( ent.origin, cent->gent->client->renderInfo.muzzlePoint );
+						AngleVectors( tempAngles, cent->gent->client->renderInfo.muzzleDir, NULL, NULL );
+					}
+					else
+					{
+						gi.G2API_GetBoltMatrix( cent->gent->ghoul2, cent->gent->playerModel, bolt, &boltMatrix, tempAngles, ent.origin, cg.time, cgs.model_draw, cent->currentState.modelScale );
+
+						// work the matrix axis stuff into the original axis and origins used.
+						gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, cent->gent->client->renderInfo.muzzlePoint );
+						gi.G2API_GiveMeVectorFromMatrix( boltMatrix, NEGATIVE_Y, cent->gent->client->renderInfo.muzzleDir );
+					}
+				}
+				// Set the Vehicle Muzzle Point and Direction.
+				else if ( cent->gent && cent->gent->client && cent->gent->client->NPC_class == CLASS_VEHICLE )
+				{
+					// Get the Position and Direction of the Tag and use that as our Muzzles Properties.
+					mdxaBone_t	boltMatrix;
+					vec3_t		velocity;
+					VectorCopy(cent->gent->client->ps.velocity, velocity);
+					velocity[2] = 0;
+ 					for ( int i = 0; i < MAX_VEHICLE_MUZZLES; i++ )
+					{
+ 						if ( cent->gent->m_pVehicle->m_iMuzzleTag[i] != -1 )
+						{
+							gi.G2API_GetBoltMatrix( cent->gent->ghoul2, cent->gent->playerModel, cent->gent->m_pVehicle->m_iMuzzleTag[i], &boltMatrix, cent->lerpAngles, ent.origin, cg.time, cgs.model_draw, cent->currentState.modelScale );
+							gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, cent->gent->m_pVehicle->m_Muzzles[i].m_vMuzzlePos ); 
+							gi.G2API_GiveMeVectorFromMatrix( boltMatrix, NEGATIVE_Y, cent->gent->m_pVehicle->m_Muzzles[i].m_vMuzzleDir );
+  							VectorMA(cent->gent->m_pVehicle->m_Muzzles[i].m_vMuzzlePos, 0.075f, velocity, cent->gent->m_pVehicle->m_Muzzles[i].m_vMuzzlePos);
+						}
+						else
+						{
+							break;
+						}
+					}
+				}
+				else if ( cent->gent->client && cent->gent->NPC//client NPC
+					/*
+					&& cent->gent->client->NPC_class == CLASS_REBORN//cultist
+					&& cent->gent->NPC->rank >= RANK_LT_COMM//commando
+					*/
+					&& cent->gent->s.weapon == WP_BLASTER_PISTOL//using blaster pistol
+					&& cent->gent->weaponModel[1] )//one in each hand
+				{
+					qboolean getBoth = qfalse;
+					int	oldOne = 0;
+					if ( cent->muzzleFlashTime > 0 && wData && !(cent->currentState.eFlags & EF_LOCKED_TO_WEAPON ))
+					{//we need to get both muzzles since we're toggling and we fired recently
+						getBoth = qtrue;
+						oldOne = (cent->gent->count)?0:1;
+					}
+					if ( ( cent->gent->weaponModel[cent->gent->count] != -1)
+						&& ( cent->gent->ghoul2.size() > cent->gent->weaponModel[cent->gent->count] ) 
+						&& ( cent->gent->ghoul2[cent->gent->weaponModel[cent->gent->count]].mModelindex != -1) )
+					{//get whichever one we're using now
+						mdxaBone_t	boltMatrix;
+						// figure out where the actual model muzzle is
+						gi.G2API_GetBoltMatrix( cent->gent->ghoul2, cent->gent->weaponModel[cent->gent->count], 0, &boltMatrix, tempAngles, ent.origin, cg.time, cgs.model_draw, cent->currentState.modelScale );
+						// work the matrix axis stuff into the original axis and origins used.
+						gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, cent->gent->client->renderInfo.muzzlePoint );
+						gi.G2API_GiveMeVectorFromMatrix( boltMatrix, NEGATIVE_Y, cent->gent->client->renderInfo.muzzleDir );
+					}
+					//get the old one too, if needbe, and store it in muzzle2
+					if ( getBoth
+						&& ( cent->gent->weaponModel[oldOne] != -1) //have a second weapon
+						&& ( cent->gent->ghoul2.size() > cent->gent->weaponModel[oldOne] ) //have a valid ghoul model index
+						&& ( cent->gent->ghoul2[cent->gent->weaponModel[oldOne]].mModelindex != -1) )//model exists and was loaded
+					{//saboteur commando, toggle the muzzle point back and forth between the two pistols each time he fires
+						mdxaBone_t	boltMatrix;
+						// figure out where the actual model muzzle is
+						gi.G2API_GetBoltMatrix( cent->gent->ghoul2, cent->gent->weaponModel[oldOne], 0, &boltMatrix, tempAngles, ent.origin, cg.time, cgs.model_draw, cent->currentState.modelScale );
+						// work the matrix axis stuff into the original axis and origins used.
+						gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, oldMP );
+						gi.G2API_GiveMeVectorFromMatrix( boltMatrix, NEGATIVE_Y, oldMD );
+					}
+				}
+				else if (( cent->gent->weaponModel[0] != -1) &&
+					( cent->gent->ghoul2.size() > cent->gent->weaponModel[0] ) &&
+					( cent->gent->ghoul2[cent->gent->weaponModel[0]].mModelindex != -1))
+				{
+					mdxaBone_t	boltMatrix;
+					// figure out where the actual model muzzle is
+					gi.G2API_GetBoltMatrix( cent->gent->ghoul2, cent->gent->weaponModel[0], 0, &boltMatrix, tempAngles, ent.origin, cg.time, cgs.model_draw, cent->currentState.modelScale );
+					// work the matrix axis stuff into the original axis and origins used.
+					gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, cent->gent->client->renderInfo.muzzlePoint );
+					gi.G2API_GiveMeVectorFromMatrix( boltMatrix, NEGATIVE_Y, cent->gent->client->renderInfo.muzzleDir );
+				}
+				else
+				{
+					VectorCopy( cent->gent->client->renderInfo.eyePoint, cent->gent->client->renderInfo.muzzlePoint );
+					AngleVectors( cent->gent->client->renderInfo.eyeAngles, cent->gent->client->renderInfo.muzzleDir, NULL, NULL );
+				}
+				cent->gent->client->renderInfo.mPCalcTime = cg.time;
+			}
+
+			// Draw Vehicle Muzzle Flashs.
+			if ( cent->gent && cent->gent->client && cent->gent->client->NPC_class == CLASS_VEHICLE )
+			{
+				for ( int i = 0; i < MAX_VEHICLE_MUZZLES; i++ )
+				{
+					/*if ( cent->gent->m_pVehicle->m_pVehicleInfo->weap1ID == cent->gent->m_pVehicle->m_pVehicleInfo->weapMuzzle[i] )
+					{
+						iDelay = cent->gent->m_pVehicle->m_pVehicleInfo->weap1Delay;
+					}
+					else if ( cent->gent->m_pVehicle->m_pVehicleInfo->weap2ID == cent->gent->m_pVehicle->m_pVehicleInfo->weapMuzzle[i] )
+					{
+						iDelay = cent->gent->m_pVehicle->m_pVehicleInfo->weap2Delay;
+					}
+
+					if ( cent->gent->m_pVehicle->m_Muzzles[i].m_iMuzzleWait - cg.time > ( iDelay - 500 ) )*/
+
+					if ( cent->gent->m_pVehicle->m_Muzzles[i].m_bFired )
+					{
+						const char *effect = &weaponData[ cent->gent->m_pVehicle->m_pVehicleInfo->weapMuzzle[i] ].mMuzzleEffect[0];
+						if ( effect )
+						{
+							theFxScheduler.PlayEffect( effect, cent->gent->m_pVehicle->m_Muzzles[i].m_vMuzzlePos, cent->gent->m_pVehicle->m_Muzzles[i].m_vMuzzleDir );
+						}
+						cent->gent->m_pVehicle->m_Muzzles[i].m_bFired = false;
+					}
+				}
+			}
+			// Pick the right effect for the type of weapon we are, defaults to no effect unless explicitly specified
+			else if ( cent->muzzleFlashTime > 0 && wData && !(cent->currentState.eFlags & EF_LOCKED_TO_WEAPON ))
+			{
+				const char *effect = NULL;
+
+				cent->muzzleFlashTime  = 0;
+
+				// Try and get a default muzzle so we have one to fall back on
+				if ( wData->mMuzzleEffect[0] )
+				{
+					effect = &wData->mMuzzleEffect[0];
+				}
+
+				if ( cent->altFire )
+				{
+					// We're alt-firing, so see if we need to override with a custom alt-fire effect
+					if ( wData->mAltMuzzleEffect[0] )
+					{
+						effect = &wData->mAltMuzzleEffect[0];
+					}
+				}
+
+				if (/*( cent->currentState.eFlags & EF_FIRING || cent->currentState.eFlags & EF_ALT_FIRING ) &&*/ effect )
+				{
+					if ( cent->gent && cent->gent->NPC )
+					{
+						if ( !VectorCompare( oldMP, vec3_origin )
+							&& !VectorCompare( oldMD, vec3_origin ) )
+						{//we have an old muzzlePoint we want to use
+							theFxScheduler.PlayEffect( effect, oldMP, oldMD );
+						}
+						else
+						{//use the current one
+							theFxScheduler.PlayEffect( effect, cent->gent->client->renderInfo.muzzlePoint, 
+														cent->gent->client->renderInfo.muzzleDir );
+						}
+					}
+					else
+					{
+						// We got an effect and we're firing, so let 'er rip.
+						theFxScheduler.PlayEffect( effect, cent->currentState.clientNum );
+					}
+				}
+			}
+
+			//play special force effects
+			/*
+			if ( cent->gent->NPC && ( cent->gent->NPC->confusionTime > cg.time || cent->gent->NPC->charmedTime > cg.time || cent->gent->NPC->controlledTime > cg.time) )
+			{// we are currently confused, so play an effect at the headBolt position
+				if ( TIMER_Done( cent->gent, "confusionEffectDebounce" ) )
+				{//ARGH!!!
+					theFxScheduler.PlayEffect( cgs.effects.forceConfusion, cent->gent->client->renderInfo.eyePoint );
+					TIMER_Set( cent->gent, "confusionEffectDebounce", 1000 );
+				}
+			}
+			*/
+
+			if ( cent->gent->client && cent->gent->forcePushTime > cg.time )
+			{//being pushed
+				CG_ForcePushBodyBlur( cent, ent.origin, tempAngles );
+			}
+			
+			//This is now being done via an effect and the animevents.cfg
+			//if ( cent->gent->client->ps.powerups[PW_FORCE_PUSH] > cg.time ||
+			if ( (cent->gent->client->ps.forcePowersActive & (1<<FP_GRIP)) )
+			{//doing the gripping
+				//FIXME: effect?
+				CG_ForcePushBlur( cent->gent->client->renderInfo.handLPoint, qtrue );
+			}
+
+			if ( cent->gent->client->ps.eFlags & EF_FORCE_GRIPPED )
+			{//being gripped
+				CG_ForcePushBlur( cent->gent->client->renderInfo.headPoint, qtrue );
+			}
+
+			if ( cent->gent->client && cent->gent->client->ps.powerups[PW_SHOCKED] > cg.time )
+			{//being electrocuted
+				CG_ForceElectrocution( cent, ent.origin, tempAngles, cgs.media.boltShader );
+			}
+
+			if ( cent->gent->client->ps.eFlags & EF_FORCE_DRAINED
+				|| (cent->currentState.powerups&(1<<PW_DRAINED)) )
+			{//being drained
+				//do red electricity lines off them and red drain shell on them
+				CG_ForceElectrocution( cent, ent.origin, tempAngles, cgs.media.drainShader, qtrue );
+			}
+
+			if ( cent->gent->client->ps.forcePowersActive&(1<<FP_LIGHTNING) )
+			{//doing the electrocuting
+				//FIXME: if the target is absorbing or blocking lightning w/saber, draw a beam from my hand to his (hand?chest?saber?)
+				vec3_t tAng, fxDir;
+				VectorCopy( cent->lerpAngles, tAng );
+				if ( cent->gent->client->ps.forcePowerLevel[FP_LIGHTNING] > FORCE_LEVEL_2 )
+				{//arc
+					vec3_t	fxAxis[3];
+					AnglesToAxis( tAng, fxAxis );
+					theFxScheduler.PlayEffect( cgs.effects.forceLightningWide, cent->gent->client->renderInfo.handLPoint, fxAxis );
+					if ( cent->gent->client->ps.torsoAnim == BOTH_FORCE_2HANDEDLIGHTNING
+						|| cent->gent->client->ps.torsoAnim == BOTH_FORCE_2HANDEDLIGHTNING_START
+						|| cent->gent->client->ps.torsoAnim == BOTH_FORCE_2HANDEDLIGHTNING_HOLD
+						|| cent->gent->client->ps.torsoAnim == BOTH_FORCE_2HANDEDLIGHTNING_RELEASE )
+					{//jackin' 'em up, Palpatine-style
+						theFxScheduler.PlayEffect( cgs.effects.forceLightningWide, cent->gent->client->renderInfo.handRPoint, fxAxis );
+					}
+				}
+				else
+				{//line
+					AngleVectors( tAng, fxDir, NULL, NULL );
+					theFxScheduler.PlayEffect( cgs.effects.forceLightning, cent->gent->client->renderInfo.handLPoint, fxDir );
+				}
+			}
+
+			if ( (cent->gent->client->ps.eFlags&EF_POWERING_ROSH) )
+			{
+				vec3_t tAng, fxDir;
+				VectorCopy( cent->lerpAngles, tAng );
+				AngleVectors( tAng, fxDir, NULL, NULL );
+				theFxScheduler.PlayEffect( cgs.effects.forceDrain, cent->gent->client->renderInfo.handLPoint, fxDir );//theFxScheduler.RegisterEffect( "force/dr1" )
+			}
+
+			if ( cent->gent->client->ps.forcePowersActive&(1<<FP_DRAIN) 
+				&& cent->gent->client->ps.forceDrainEntityNum >= ENTITYNUM_WORLD )
+			{//doing the draining and not on a single person
+				vec3_t tAng, fxDir;
+				VectorCopy( cent->lerpAngles, tAng );
+				if ( cent->gent->client->ps.forcePowerLevel[FP_DRAIN] > FORCE_LEVEL_2 )
+				{//arc
+					vec3_t	fxAxis[3];
+					AnglesToAxis( tAng, fxAxis );
+					theFxScheduler.PlayEffect( cgs.effects.forceDrainWide, cent->gent->client->renderInfo.handLPoint, fxAxis );
+				}
+				else
+				{//line
+					AngleVectors( tAng, fxDir, NULL, NULL );
+					theFxScheduler.PlayEffect( cgs.effects.forceDrain, cent->gent->client->renderInfo.handLPoint, fxDir );
+				}
+			}
+			//spotlight?
+			if ( (cent->currentState.eFlags&EF_SPOTLIGHT) )
+			{//FIXME: player's view should glare/flare if look at this... maybe build into the effect?
+				// hack for the spotlight
+				vec3_t	org, eyeFwd;
+
+				AngleVectors( cent->gent->client->renderInfo.eyeAngles, eyeFwd, NULL, NULL );
+				theFxScheduler.PlayEffect( "rockettrooper/light_cone", cent->gent->client->renderInfo.eyePoint, eyeFwd );
+				// stay a bit back from the server-side's trace impact point...this may not be enough?
+				VectorMA( cent->gent->client->renderInfo.eyePoint, cent->gent->speed - 5, eyeFwd, org ); 
+				float radius = cent->gent->speed;
+				if ( radius < 128.0f )
+				{
+					radius = 128.0f;
+				}
+				else if ( radius > 1024.0f )
+				{
+					radius = 1024.0f;
+				}
+				cgi_R_AddLightToScene( org, radius, 1.0f, 1.0f, 1.0f );
+			}
+		}
+		//"refraction" effect -rww
+		if ( cent->gent->client->ps.powerups[PW_FORCE_PUSH] > cg.time )
+		{ 
+			CG_ForcePushRefraction(cent->gent->client->renderInfo.handLPoint, cent);
+		}
+		else if ( cent->gent->client->ps.powerups[PW_FORCE_PUSH_RHAND] > cg.time )
+		{
+			CG_ForcePushRefraction(cent->gent->client->renderInfo.handRPoint, cent);
+		}
+		else
+		{
+			cent->gent->client->ps.forcePowersActive &= ~( 1 << FP_PULL );
+		}
+
+		//bolted effects
+		CG_BoltedEffects( cent, ent.origin, tempAngles );
+		//As good a place as any, I suppose, to do this keyframed sound thing
+		CGG2_AnimEvents( cent );
+		//setup old system for gun to look at
+		//CG_RunLerpFrame( ci, &cent->pe.torso, cent->gent->client->ps.torsoAnim, cent->gent->client->renderInfo.torsoFpsMod, cent->gent->s.number );
+		if ( cent->gent && cent->gent->client && cent->gent->client->ps.weapon == WP_SABER )
+		{
+extern qboolean PM_KickingAnim( int anim );
+			if ( !PM_KickingAnim( cent->gent->client->ps.torsoAnim ) 
+				|| cent->gent->client->ps.torsoAnim == BOTH_A7_KICK_S )
+			{//not kicking (unless it's the spinning kick)
+				if ( cg_timescale.value < 1.0f && (cent->gent->client->ps.forcePowersActive&(1<<FP_SPEED)) )
+				{
+					int wait = floor( (float)FRAMETIME/2.0f );
+					//sanity check
+					if ( cent->gent->client->ps.saberDamageDebounceTime - cg.time > wait )
+					{//when you unpause the game with force speed on, the time gets *really* wiggy...
+						cent->gent->client->ps.saberDamageDebounceTime = cg.time + wait;
+					}
+					if ( cent->gent->client->ps.saberDamageDebounceTime <= cg.time )
+					{
+extern void WP_SabersDamageTrace( gentity_t *ent, qboolean noEffects );
+extern void WP_SaberUpdateOldBladeData( gentity_t *ent );
+						//FIXME: this causes an ASSLOAD of effects
+						WP_SabersDamageTrace( cent->gent, qtrue );
+						WP_SaberUpdateOldBladeData( cent->gent );
+						cent->gent->client->ps.saberDamageDebounceTime = cg.time + floor((float)wait*cg_timescale.value);
+					}
+				}
+			}
+		}
+	}
+	else
+	{
+	refEntity_t		legs;
+	refEntity_t		torso;
+	refEntity_t		head;
+	refEntity_t		gun;
+	refEntity_t		flash;
+	refEntity_t		flashlight;
+	int				renderfx, i;
+	const weaponInfo_t	*weapon;
+
+
+/*
+Ghoul2 Insert End
+*/
+
+	memset( &legs, 0, sizeof(legs) );
+	memset( &torso, 0, sizeof(torso) );
+	memset( &head, 0, sizeof(head) );
+	memset( &gun, 0, sizeof(gun) );
+	memset( &flash, 0, sizeof(flash) );
+	memset( &flashlight, 0, sizeof(flashlight) );
+
+	// Weapon sounds may need to be stopped, so check now
+	CG_StopWeaponSounds( cent );
+
+	//FIXME: pass in the axis/angles offset between the tag_torso and the tag_head?
+	// get the rotation information
+	CG_PlayerAngles( cent, legs.axis, torso.axis, head.axis );
+	if ( cent->gent && cent->gent->client )
+	{
+		cent->gent->client->ps.legsYaw = cent->lerpAngles[YAW];
+	}
+
+	// get the animation state (after rotation, to allow feet shuffle)
+	// NB: Also plays keyframed animSounds (Bob- hope you dont mind, I was here late and at about 5:30 Am i needed to do something to keep me awake and i figured you wouldn't mind- you might want to check it, though, to make sure I wasn't smoking crack and missed something important, it is pretty late and I'm getting pretty close to being up for 24 hours here, so i wouldn't doubt if I might have messed something up, but i tested it and it looked right.... noticed in old code base i was doing it wrong too, whic            h explains why I was getting so many damn sounds all the time!  I had to lower the probabilities because it seemed like i was getting way too many sounds, and that was the problem!  Well, should be fixed now I think...)
+	CG_PlayerAnimation( cent, &legs.oldframe, &legs.frame, &legs.backlerp,
+		 &torso.oldframe, &torso.frame, &torso.backlerp );
+
+	cent->gent->client->renderInfo.legsFrame = cent->pe.legs.frame;
+	cent->gent->client->renderInfo.torsoFrame = cent->pe.torso.frame;
+
+	// add powerups floating behind the player
+	CG_PlayerPowerups( cent );
+
+	// add the shadow
+	shadow = CG_PlayerShadow( cent, &shadowPlane );
+
+	// add a water splash if partially in and out of water
+	CG_PlayerSplash( cent );
+
+	// get the player model information
+	renderfx = 0;
+	if ( !cg.renderingThirdPerson || cg.zoomMode ) 
+	{
+		if ( cg.snap->ps.viewEntity <= 0 || cg.snap->ps.viewEntity >= ENTITYNUM_WORLD)
+		{//no viewentity
+			if ( cent->currentState.number == cg.snap->ps.clientNum )
+			{//I am the player
+				if ( cg.snap->ps.weapon != WP_SABER && cg.snap->ps.weapon != WP_MELEE )
+				{//not using saber or fists
+					renderfx = RF_THIRD_PERSON;			// only draw in mirrors
+				}
+			}
+		}
+		else if ( cent->currentState.number == cg.snap->ps.viewEntity )
+		{//I am the view entity
+			if ( cg.snap->ps.weapon != WP_SABER && cg.snap->ps.weapon != WP_MELEE )
+			{//not using saber or fists
+				renderfx = RF_THIRD_PERSON;			// only draw in mirrors
+			}
+		}
+	}
+	
+	if ( (cg_shadows.integer == 2) || (cg_shadows.integer == 3 && shadow) ) 
+	{
+		renderfx |= RF_SHADOW_PLANE;
+	}
+	renderfx |= RF_LIGHTING_ORIGIN;			// use the same origin for all
+	if ( cent->gent->NPC && cent->gent->NPC->scriptFlags & SCF_MORELIGHT )
+	{
+		renderfx |= RF_MORELIGHT;			//bigger than normal min light
+	}
+
+	if ( cent->gent && cent->gent->client )
+	{
+		VectorCopy( cent->lerpOrigin, cent->gent->client->renderInfo.headPoint );
+		VectorCopy( cent->lerpOrigin, cent->gent->client->renderInfo.handRPoint );
+		VectorCopy( cent->lerpOrigin, cent->gent->client->renderInfo.handLPoint );
+		VectorCopy( cent->lerpOrigin, cent->gent->client->renderInfo.footRPoint );
+		VectorCopy( cent->lerpOrigin, cent->gent->client->renderInfo.footLPoint );
+		VectorCopy( cent->lerpOrigin, cent->gent->client->renderInfo.torsoPoint );
+		VectorCopy( cent->lerpAngles, cent->gent->client->renderInfo.torsoAngles );
+		VectorCopy( cent->lerpOrigin, cent->gent->client->renderInfo.crotchPoint );
+	}
+	if ( cg.snap->ps.viewEntity > 0 && cg.snap->ps.viewEntity < ENTITYNUM_WORLD && cg.snap->ps.viewEntity == cent->currentState.clientNum )
+	{//player is in an entity camera view, ME
+		VectorCopy( cent->lerpOrigin, cent->gent->client->renderInfo.eyePoint );
+		VectorCopy( cent->lerpAngles, cent->gent->client->renderInfo.eyeAngles );
+		VectorCopy( cent->lerpOrigin, cent->gent->client->renderInfo.headPoint );
+	}
+	//
+	// add the legs
+	//
+	legs.hModel = ci->legsModel;
+	legs.customSkin = ci->legsSkin;
+
+	VectorCopy( cent->lerpOrigin, legs.origin );
+
+	//Scale applied to a refEnt will apply to any models attached to it... 
+	//This seems to copy the scale to every piece attached, kinda cool, but doesn't
+	//allow the body to be scaled up without scaling a bolt on or whatnot...
+	//Only apply scale if it's not 100% scale...
+	if(cent->currentState.modelScale[0] != 0.0f)
+	{
+		VectorScale( legs.axis[0], cent->currentState.modelScale[0], legs.axis[0] );
+		legs.nonNormalizedAxes = qtrue;
+	}
+
+	if(cent->currentState.modelScale[1] != 0.0f)
+	{
+		VectorScale( legs.axis[1], cent->currentState.modelScale[1], legs.axis[1] );
+		legs.nonNormalizedAxes = qtrue;
+	}
+
+	if(cent->currentState.modelScale[2] != 0.0f)
+	{
+		VectorScale( legs.axis[2], cent->currentState.modelScale[2], legs.axis[2] );
+		legs.nonNormalizedAxes = qtrue;
+		if ( !staticScale )
+		{
+			//FIXME:? need to know actual height of leg model bottom to origin, not hardcoded
+			legs.origin[2] += 24 * (cent->currentState.modelScale[2] - 1);
+		}
+	}
+
+	VectorCopy( legs.origin, legs.lightingOrigin );
+	legs.shadowPlane = shadowPlane;
+	legs.renderfx = renderfx;
+	VectorCopy (legs.origin, legs.oldorigin);	// don't positionally lerp at all
+
+	CG_AddRefEntityWithPowerups( &legs, cent->currentState.powerups, cent );
+
+	// if the model failed, allow the default nullmodel to be displayed
+	if (!legs.hModel) 
+	{
+		return;
+	}
+
+	//
+	// add the torso
+	//
+	torso.hModel = ci->torsoModel;
+	if (torso.hModel) 
+	{
+		orientation_t	tag_torso;
+
+		torso.customSkin = ci->torsoSkin;
+
+		VectorCopy( cent->lerpOrigin, torso.lightingOrigin );
+
+		CG_PositionRotatedEntityOnTag( &torso, &legs, legs.hModel, "tag_torso", &tag_torso );
+		VectorCopy( torso.origin, cent->gent->client->renderInfo.torsoPoint );
+		vectoangles( tag_torso.axis[0], cent->gent->client->renderInfo.torsoAngles );
+
+		torso.shadowPlane = shadowPlane;
+		torso.renderfx = renderfx;
+
+		CG_AddRefEntityWithPowerups( &torso, cent->currentState.powerups, cent );
+
+		//
+		// add the head
+		//
+		head.hModel = ci->headModel;
+		if (head.hModel) 
+		{
+			orientation_t	tag_head;
+
+			//Deal with facial expressions
+			//CG_PlayerHeadExtension( cent, &head );
+
+			VectorCopy( cent->lerpOrigin, head.lightingOrigin );
+
+			CG_PositionRotatedEntityOnTag( &head, &torso, torso.hModel, "tag_head", &tag_head );
+			VectorCopy( head.origin, cent->gent->client->renderInfo.headPoint );
+			vectoangles( tag_head.axis[0], cent->gent->client->renderInfo.headAngles );
+
+			head.shadowPlane = shadowPlane;
+			head.renderfx = renderfx;
+
+			CG_AddRefEntityWithPowerups( &head, cent->currentState.powerups, cent );
+
+			if ( cent->gent && cent->gent->NPC && ( cent->gent->NPC->confusionTime > cg.time || cent->gent->NPC->charmedTime > cg.time || cent->gent->NPC->controlledTime > cg.time) )
+			{
+				// we are currently confused, so play an effect
+				if ( TIMER_Done( cent->gent, "confusionEffectDebounce" ) )
+				{//ARGH!!!
+					theFxScheduler.PlayEffect( cgs.effects.forceConfusion, head.origin );
+					TIMER_Set( cent->gent, "confusionEffectDebounce", 1000 );
+				}
+			}
+
+			if ( !calcedMp )
+			{//First person player's eyePoint and eyeAngles should be copies from cg.refdef...
+				//Calc this client's eyepoint
+				VectorCopy( head.origin, cent->gent->client->renderInfo.eyePoint );
+				// race is gone, eyepoint should refer to the tag/bolt on the model... if this breaks something let me know - dmv
+			//	VectorMA( cent->gent->client->renderInfo.eyePoint, CG_EyePointOfsForRace[cent->gent->client->race][1]*scaleFactor[2], head.axis[2], cent->gent->client->renderInfo.eyePoint );//up
+			//	VectorMA( cent->gent->client->renderInfo.eyePoint, CG_EyePointOfsForRace[cent->gent->client->race][0]*scaleFactor[0], head.axis[0], cent->gent->client->renderInfo.eyePoint );//forward
+				//Calc this client's eyeAngles
+				vectoangles( head.axis[0], cent->gent->client->renderInfo.eyeAngles );
+			}
+		}
+		else
+		{
+			VectorCopy( torso.origin, cent->gent->client->renderInfo.eyePoint );
+			cent->gent->client->renderInfo.eyePoint[2] += cent->gent->maxs[2] - 4;
+			vectoangles( torso.axis[0], cent->gent->client->renderInfo.eyeAngles );
+		}
+
+		//
+		// add the gun
+		//
+		CG_RegisterWeapon( cent->currentState.weapon );
+		weapon = &cg_weapons[cent->currentState.weapon];
+
+		gun.hModel = weapon->weaponWorldModel;
+		if (gun.hModel) 
+		{
+			qboolean drawGun = qtrue;
+			//FIXME: allow scale, animation and angle offsets
+			VectorCopy( cent->lerpOrigin, gun.lightingOrigin );
+
+			//FIXME: allow it to be put anywhere and move this out of if(torso.hModel)
+			//Will have to call CG_PositionRotatedEntityOnTag
+			
+			CG_PositionEntityOnTag( &gun, &torso, torso.hModel, "tag_weapon");
+
+//--------------------- start saber hacks
+/*
+			if ( cent->gent && cent->gent->client && ( cent->currentState.weapon == WP_SABER || cent->gent->client->ps.saberInFlight ) )
+			{
+				int numSabers = 1;
+				if ( cent->gent->client->ps.dualSabers )
+				{
+					numSabers = 2;
+				}
+				for ( int saberNum = 0; saberNum < numSabers; saberNum++ )
+				{
+					if ( !cent->gent->client->ps.saber[saberNum].active )//!cent->gent->client->ps.saberActive )
+					{//saber is off
+						if ( cent->gent->client->ps.saber[saberNum].length > 0 )
+						{
+							if ( cent->gent->client->ps.stats[STAT_HEALTH] <= 0 )
+							{//dead, didn't actively turn it off
+								cent->gent->client->ps.saber[saberNum].length -= cent->gent->client->ps.saber[saberNum].lengthMax/10 * cg.frametime/100;
+							}
+							else
+							{//actively turned it off, shrink faster
+								cent->gent->client->ps.saber[saberNum].length -= cent->gent->client->ps.saber[saberNum].lengthMax/3 * cg.frametime/100;
+							}
+						}
+						if ( cent->gent->client->ps.saber[saberNum].length < 0 )
+						{
+							cent->gent->client->ps.saber[saberNum].length = 0;
+						}
+					}
+					else if ( cent->gent->client->ps.saber[saberNum].length < cent->gent->client->ps.saber[saberNum].lengthMax )
+					{//saber is on
+						if ( !cent->gent->client->ps.saber[saberNum].length )
+						{
+							if ( cent->gent->client->ps.saberInFlight )
+							{//play it on the saber
+								cgi_S_UpdateEntityPosition( cent->gent->client->ps.saberEntityNum, g_entities[cent->gent->client->ps.saberEntityNum].currentOrigin );
+								cgi_S_StartSound (NULL, cent->gent->client->ps.saberEntityNum, CHAN_AUTO, cgs.sound_precache[cent->gent->client->ps.saber[0].soundOn] );
+							}
+							else
+							{
+								cgi_S_StartSound (NULL, cent->currentState.number, CHAN_AUTO, cgs.sound_precache[cent->gent->client->ps.saber[0].soundOn] );
+#ifdef _IMMERSION
+								cgi_FF_Start( cgi_FF_Register( "fffx/weapons/saber/saberon", FF_CHANNEL_WEAPON ), cent->currentState.number );
+#endif // _IMMERSION
+							}
+						}
+						cent->gent->client->ps.saber[saberNum].length += cent->gent->client->ps.saber[saberNum].lengthMax/6 * cg.frametime/100;//= saber[saberNum].lengthMax;
+						if ( cent->gent->client->ps.saber[saberNum].length > cent->gent->client->ps.saber[saberNum].lengthMax )
+						{
+							cent->gent->client->ps.saber[saberNum].length = cent->gent->client->ps.saber[saberNum].lengthMax;
+						}
+					}
+
+					if ( cent->gent->client->ps.saberInFlight )
+					{//not holding the saber in-hand
+						drawGun = qfalse;
+					}
+					if ( cent->gent->client->ps.saber[saberNum].length > 0 )
+					{
+						if ( !cent->gent->client->ps.saberInFlight )
+						{//holding the saber in-hand
+							CG_AddSaberBlade( cent, cent, &gun, renderfx, 0, NULL, NULL );
+							calcedMp = qtrue;
+						}
+					}
+					else
+					{
+						//if ( cent->gent->client->ps.saberEventFlags&SEF_INWATER )
+						{
+							CG_CheckSaberInWater( cent, cent, 0, NULL, NULL );
+						}
+					}
+				}
+			}
+
+*/
+//--------------------- end saber hacks
+
+			gun.shadowPlane = shadowPlane;
+			gun.renderfx = renderfx;
+
+			if ( drawGun )
+			{
+				CG_AddRefEntityWithPowerups( &gun, 
+					(cent->currentState.powerups & ((1<<PW_CLOAKED)|(1<<PW_BATTLESUIT)) ),
+					cent );
+			}
+
+			//
+			// add the flash (even if invisible)
+			//
+			
+			// impulse flash
+			if ( cent->muzzleFlashTime > 0 && wData && !(cent->currentState.eFlags & EF_LOCKED_TO_WEAPON ))
+			{
+				int effect = 0;
+
+				cent->muzzleFlashTime  = 0;
+
+				CG_PositionEntityOnTag( &flash, &gun, gun.hModel, "tag_flash");
+
+				// Try and get a default muzzle so we have one to fall back on
+				if ( wData->mMuzzleEffectID )
+				{
+					effect = wData->mMuzzleEffectID;
+				}
+
+				if ( cent->currentState.eFlags & EF_ALT_FIRING )
+				{
+					// We're alt-firing, so see if we need to override with a custom alt-fire effect
+					if ( wData->mAltMuzzleEffectID )
+					{
+						effect = wData->mAltMuzzleEffectID;
+					}
+				}
+
+				if (( cent->currentState.eFlags & EF_FIRING || cent->currentState.eFlags & EF_ALT_FIRING ) && effect )
+				{
+					vec3_t up={0,0,1}, ax[3];
+
+					VectorCopy( flash.axis[0], ax[0] );
+
+					CrossProduct( up, ax[0], ax[1] );
+					CrossProduct( ax[0], ax[1], ax[2] );
+
+					if (( cent->gent && cent->gent->NPC ) || cg.renderingThirdPerson )
+					{
+						theFxScheduler.PlayEffect( effect, flash.origin, ax );
+					}
+					else
+					{
+						// We got an effect and we're firing, so let 'er rip.
+						theFxScheduler.PlayEffect( effect, flash.origin, ax );
+					}
+				}
+			}
+			
+			if ( !calcedMp && !(cent->currentState.eFlags & EF_LOCKED_TO_WEAPON ))
+			{// Set the muzzle point
+				orientation_t orientation;
+
+				cgi_R_LerpTag( &orientation, weapon->weaponModel, gun.oldframe, gun.frame,
+					1.0f - gun.backlerp, "tag_flash" );
+
+				// FIXME: allow origin offsets along tag?
+				VectorCopy( gun.origin, cent->gent->client->renderInfo.muzzlePoint );
+				for ( i = 0 ; i < 3 ; i++ ) 
+				{
+					VectorMA( cent->gent->client->renderInfo.muzzlePoint, orientation.origin[i], gun.axis[i], cent->gent->client->renderInfo.muzzlePoint );
+				}
+//				VectorCopy( gun.axis[0], cent->gent->client->renderInfo.muzzleDir );
+//				VectorAdd( gun.axis[0], orientation.axis[0], cent->gent->client->renderInfo.muzzleDir );
+//				VectorNormalize( cent->gent->client->renderInfo.muzzleDir );
+
+
+				cent->gent->client->renderInfo.mPCalcTime = cg.time;
+				// Weapon wasn't firing anymore, so ditch any weapon associated looping sounds.
+				//cent->gent->s.loopSound = 0;
+			}
+		}
+	}
+	else
+	{
+		VectorCopy( legs.origin, cent->gent->client->renderInfo.eyePoint );
+		cent->gent->client->renderInfo.eyePoint[2] += cent->gent->maxs[2] - 4;
+		vectoangles( legs.axis[0], cent->gent->client->renderInfo.eyeAngles );
+	}
+
+	}
+
+	//FIXME: for debug, allow to draw a cone of the NPC's FOV...
+	if ( cent->currentState.number == 0 && cg.renderingThirdPerson )
+	{
+		playerState_t *ps = &cg.predicted_player_state;
+
+		if (( ps->weaponstate == WEAPON_CHARGING_ALT && ps->weapon == WP_BRYAR_PISTOL ) 
+			|| ( ps->weaponstate == WEAPON_CHARGING_ALT && ps->weapon == WP_BLASTER_PISTOL ) 
+			|| ( ps->weapon == WP_BOWCASTER && ps->weaponstate == WEAPON_CHARGING )
+			|| ( ps->weapon == WP_DEMP2 && ps->weaponstate == WEAPON_CHARGING_ALT ))
+		{
+			int		shader = 0;
+			float	val = 0.0f, scale = 1.0f;
+			vec3_t	WHITE	= {1.0f,1.0f,1.0f};
+
+			if ( ps->weapon == WP_BRYAR_PISTOL
+				|| ps->weapon == WP_BLASTER_PISTOL )
+			{
+				// Hardcoded max charge time of 1 second
+				val = ( cg.time - ps->weaponChargeTime ) * 0.001f;
+				shader = cgi_R_RegisterShader( "gfx/effects/bryarFrontFlash" );
+			}
+			else if ( ps->weapon == WP_BOWCASTER )
+			{
+				// Hardcoded max charge time of 1 second
+				val = ( cg.time - ps->weaponChargeTime ) * 0.001f;
+				shader = cgi_R_RegisterShader( "gfx/effects/greenFrontFlash" );
+			}
+			else if ( ps->weapon == WP_DEMP2 )
+			{
+				// Hardcoded max charge time of 1 second
+				val = ( cg.time - ps->weaponChargeTime ) * 0.001f;
+				shader = cgi_R_RegisterShader( "gfx/misc/lightningFlash" );
+				scale = 1.75f;
+			}
+
+			if ( val < 0.0f )
+			{
+				val = 0.0f;
+			}
+			else if ( val > 1.0f )
+			{
+				val = 1.0f;
+				CGCam_Shake( 0.1f, 100 );
+			}
+			else
+			{
+				CGCam_Shake( val * val * 0.3f, 100 );
+			}
+
+			val += random() * 0.5f;
+
+			FX_AddSprite( cent->gent->client->renderInfo.muzzlePoint, NULL, NULL, 3.0f * val * scale, 0.0f, 0.7f, 0.7f, WHITE, WHITE, random() * 360, 0.0f, 1.0f, shader, FX_USE_ALPHA );
+		}
+	}
+}
+
+//=====================================================================
+
+/*
+===============
+CG_ResetPlayerEntity
+
+A player just came into view or teleported, so reset all animation info
+
+FIXME: We do not need to do this, we can remember the last anim and frame they were
+on and coontinue from there.
+===============
+*/
+void CG_ResetPlayerEntity( centity_t *cent ) {
+//	cent->errorTime = -99999;		// guarantee no error decay added
+//	cent->extrapolated = qfalse;	
+
+	if ( cent->gent && cent->gent->ghoul2.size() )
+	{
+		if ( cent->currentState.clientNum < MAX_CLIENTS )
+		{
+			CG_ClearLerpFrame( &cgs.clientinfo[ cent->currentState.clientNum ], &cent->pe.legs, cent->currentState.legsAnim );
+			CG_ClearLerpFrame( &cgs.clientinfo[ cent->currentState.clientNum ], &cent->pe.torso, cent->currentState.torsoAnim );
+		}
+		else if ( cent->gent && cent->gent->client )
+		{
+			CG_ClearLerpFrame( &cent->gent->client->clientInfo, &cent->pe.legs, cent->currentState.legsAnim );
+			CG_ClearLerpFrame( &cent->gent->client->clientInfo, &cent->pe.torso, cent->currentState.torsoAnim );
+		}
+	}
+	//else????
+
+	EvaluateTrajectory( &cent->currentState.pos, cg.time, cent->lerpOrigin );
+	EvaluateTrajectory( &cent->currentState.apos, cg.time, cent->lerpAngles );
+
+// Removed by BTO (VV) - These values are crap anyway. Also changed below to use lerp instead
+//	VectorCopy( cent->lerpOrigin, cent->rawOrigin );
+//	VectorCopy( cent->lerpAngles, cent->rawAngles );
+
+	memset( &cent->pe.legs, 0, sizeof( cent->pe.legs ) );
+	cent->pe.legs.yawAngle = cent->lerpAngles[YAW];
+	cent->pe.legs.yawing = qfalse;
+	cent->pe.legs.pitchAngle = 0;
+	cent->pe.legs.pitching = qfalse;
+
+	memset( &cent->pe.torso, 0, sizeof( cent->pe.legs ) );
+	cent->pe.torso.yawAngle = cent->lerpAngles[YAW];
+	cent->pe.torso.yawing = qfalse;
+	cent->pe.torso.pitchAngle = cent->lerpAngles[PITCH];
+	cent->pe.torso.pitching = qfalse;
+}
\ No newline at end of file
diff --git a/code/cgame/cg_playerstate.cpp b/code/cgame/cg_playerstate.cpp
new file mode 100644
index 0000000..f5f0332
--- /dev/null
+++ b/code/cgame/cg_playerstate.cpp
@@ -0,0 +1,364 @@
+// cg_playerstate.c -- this file acts on changes in a new playerState_t
+// With normal play, this will be done after local prediction, but when
+// following another player or playing back a demo, it will be checked
+// when the snapshot transitions like all the other entities
+
+// this line must stay at top so the whole PCH thing works...
+#include "cg_headers.h"
+
+
+//#include "cg_local.h"
+#include "cg_media.h"
+
+/*
+==============
+CG_CheckAmmo
+
+If the ammo has gone low enough to generate the warning, play a sound
+==============
+*/
+void CG_CheckAmmo( void ) 
+{
+//	int		i;
+	int		total;
+	int		previous;
+//	int		weapons;
+
+#if 0
+		
+	// see about how many seconds of ammo we have remaining
+	weapons = cg.snap->ps.stats[ STAT_WEAPONS ];
+	total = 0;
+
+	for ( i = WP_SABER; i < WP_NUM_WEAPONS  i++ ) 
+	{
+		if ( ! ( weapons & ( 1 << i ) ) )
+			continue;
+
+		/*
+		switch ( i ) 
+		{
+		case WP_ROCKET_LAUNCHER:
+		case WP_GRENADE_LAUNCHER:
+		case WP_RAILGUN:
+		case WP_SHOTGUN:
+			total += cg.snap->ps.ammo[i] * 1000;
+			break;
+		default:
+			total += cg.snap->ps.ammo[i] * 200;
+			break;
+		}
+		*/
+		
+		if ( total >= 5000 ) 
+		{
+			cg.lowAmmoWarning = 0;
+			return;
+		}
+	}
+#endif
+
+	// Don't bother drawing the ammo warning when have no weapon selected
+	if ( cg.weaponSelect == WP_NONE )
+	{
+		return;
+	}
+
+	total = cg.snap->ps.ammo[weaponData[cg.weaponSelect].ammoIndex];
+
+	if (total > weaponData[cg.weaponSelect].ammoLow) // Low on ammo?
+	{
+		cg.lowAmmoWarning = 0;
+		return;
+	}
+
+
+	previous = cg.lowAmmoWarning;
+
+	if (!total)		// We're completely freak'in out!
+	{
+		cg.lowAmmoWarning = 2;
+	} 
+	else			// Got a little left
+	{
+		cg.lowAmmoWarning = 1;
+	}
+
+	// play a sound on transitions
+	if ( cg.lowAmmoWarning != previous ) {
+		cgi_S_StartLocalSound( cgs.media.noAmmoSound, CHAN_LOCAL_SOUND ); //"sound/weapons/noammo.wav"
+#ifdef _IMMERSION
+		cgi_FF_Start( cgs.media.noAmmoForce, FF_CLIENT_LOCAL );
+#endif // _IMMERSION
+	}
+}
+
+/*
+==============
+CG_DamageFeedback
+==============
+*/
+void CG_DamageFeedback( int yawByte, int pitchByte, int damage ) {
+	float		left, front, up;
+	float		kick;
+	int			health;
+	float		scale;
+	vec3_t		dir;
+	vec3_t		angles;
+	float		dist;
+	float		yaw, pitch;
+
+	//FIXME: Based on MOD, do different kinds of damage effects,
+	//		for example, Borg damage could progressively tint screen green and raise FOV?
+
+	// the lower on health you are, the greater the view kick will be
+	health = cg.snap->ps.stats[STAT_HEALTH];
+	if ( health < 40 ) {
+		scale = 1;
+	} else {
+		scale = 40.0 / health;
+	}
+	kick = damage * scale;
+
+	if (kick < 5)
+		kick = 5;
+	if (kick > 10)
+		kick = 10;
+
+	// if yaw and pitch are both 255, make the damage always centered (falling, etc)
+	if ( yawByte == 255 && pitchByte == 255 ) {
+		cg.damageX = 0;
+		cg.damageY = 0;
+		cg.v_dmg_roll = 0;
+		cg.v_dmg_pitch = -kick;
+	} else {
+		// positional
+		pitch = pitchByte / 255.0 * 360;
+		yaw = yawByte / 255.0 * 360;
+
+		angles[PITCH] = pitch;
+		angles[YAW] = yaw;
+		angles[ROLL] = 0;
+
+		AngleVectors( angles, dir, NULL, NULL );
+		VectorSubtract( vec3_origin, dir, dir );
+
+		front = DotProduct (dir, cg.refdef.viewaxis[0] );
+		left = DotProduct (dir, cg.refdef.viewaxis[1] );
+		up = DotProduct (dir, cg.refdef.viewaxis[2] );
+
+		dir[0] = front;
+		dir[1] = left;
+		dir[2] = 0;
+		dist = VectorLength( dir );
+		if ( dist < 0.1 ) {
+			dist = 0.1f;
+		}
+
+		cg.v_dmg_roll = kick * left;
+		
+		cg.v_dmg_pitch = -kick * front;
+
+		if ( front <= 0.1 ) {
+			front = 0.1f;
+		}
+		cg.damageX = -left / front;
+		cg.damageY = up / dist;
+	}
+
+	// clamp the position
+	if ( cg.damageX > 1.0 ) {
+		cg.damageX = 1.0;
+	}
+	if ( cg.damageX < - 1.0 ) {
+		cg.damageX = -1.0;
+	}
+
+	if ( cg.damageY > 1.0 ) {
+		cg.damageY = 1.0;
+	}
+	if ( cg.damageY < - 1.0 ) {
+		cg.damageY = -1.0;
+	}
+
+	// don't let the screen flashes vary as much
+	if ( kick > 10 ) {
+		kick = 10;
+	}
+	cg.damageValue = kick;
+	cg.v_dmg_time = cg.time + DAMAGE_TIME;
+	cg.damageTime = cg.snap->serverTime;
+#ifdef _IMMERSION
+	cgi_FF_Start( cgi_FF_Register( "fffx/player/damage", FF_CHANNEL_DAMAGE ), cg.snap->ps.clientNum );
+#endif // _IMMERSION
+
+#ifdef _XBOX
+	cgi_FF_Xbox_Damage(damage, cg.damageX);
+#endif
+}
+
+
+
+
+/*
+================
+CG_Respawn
+
+A respawn happened this snapshot
+================
+*/
+void CG_Respawn( void ) {
+	// no error decay on player movement
+	cg.thisFrameTeleport = qtrue;
+
+	// display weapons available
+//	cg.weaponSelectTime = cg.time;
+	SetWeaponSelectTime();
+
+	// select the weapon the server says we are using
+	if (cg.snap->ps.weapon)
+		cg.weaponSelect = cg.snap->ps.weapon;
+}
+
+
+/*
+==============
+CG_CheckPlayerstateEvents
+
+==============
+*/
+void CG_CheckPlayerstateEvents( playerState_t *ps, playerState_t *ops ) {
+	int			i;
+	int			event;
+	centity_t	*cent;
+
+#if 0
+	if ( ps->externalEvent && ps->externalEvent != ops->externalEvent ) {
+		cent = &cg_entities[ ps->clientNum ];
+		cent->currentState.event = ps->externalEvent;
+		cent->currentState.eventParm = ps->externalEventParm;
+		CG_EntityEvent( cent, cent->lerpOrigin );
+	}
+#endif
+
+	for ( i = ps->eventSequence - MAX_PS_EVENTS ; i < ps->eventSequence ; i++ ) {
+		if ( ps->events[i & (MAX_PS_EVENTS-1)] != ops->events[i & (MAX_PS_EVENTS-1)]
+			|| i >= ops->eventSequence ) {
+			event = ps->events[ i & (MAX_PS_EVENTS-1) ];
+
+			cent = &cg_entities[ ps->clientNum ];
+			cent->currentState.event = event;
+			cent->currentState.eventParm = ps->eventParms[ i & (MAX_PS_EVENTS-1) ];
+			CG_EntityEvent( cent, cent->lerpOrigin );
+		}
+	}
+}
+
+/*
+==================
+CG_CheckLocalSounds
+==================
+*/
+/*
+void CG_CheckLocalSounds( playerState_t *ps, playerState_t *ops ) {
+	const char *s;
+
+	// hit changes
+	if ( ps->persistant[PERS_HITS] > ops->persistant[PERS_HITS] ) {
+		cgi_S_StartLocalSound( "sound/feedback/hit.wav" );
+	} else if ( ps->persistant[PERS_HITS] < ops->persistant[PERS_HITS] ) {
+		cgi_S_StartLocalSound( "sound/feedback/hit_teammate.wav" );
+	}
+
+	// score up / down changes
+	if ( ps->persistant[PERS_SCORE] > ops->persistant[PERS_SCORE] ) {
+		cgi_S_StartLocalSound( "sound/feedback/scoreup.wav" );
+	} else if ( ps->persistant[PERS_SCORE] < ops->persistant[PERS_SCORE] ) {
+		cgi_S_StartLocalSound( "sound/feedback/scoredown.wav" );
+	}
+
+	// reward sounds
+	if ( ps->persistant[PERS_REWARD_COUNT] > ops->persistant[PERS_REWARD_COUNT] ) {
+		switch ( ps->persistant[PERS_REWARD] ) {
+		case REWARD_IMPRESSIVE:
+			cgi_S_StartLocalSound( "sound/feedback/impressive.wav" );
+			break;
+		case REWARD_EXCELLENT:
+			cgi_S_StartLocalSound( "sound/feedback/excellent.wav" );
+			break;
+		case REWARD_DENIED:
+			cgi_S_StartLocalSound( "sound/feedback/denied.wav" );
+			break;
+
+		default:
+			CG_Error( "Bad reward_t" );
+		}
+	}
+
+	// timelimit warnings
+	if ( cgs.timelimit > 0 ) {
+		if ( cgs.timelimit > 5 && !( cg.timelimitWarnings & 1 ) && cg.time > (cgs.timelimit - 5) * 60 * 1000 ) {
+			cg.timelimitWarnings |= 1;
+			cgi_S_StartLocalSound( "sound/feedback/5_minute.wav" );
+		}
+		if ( !( cg.timelimitWarnings & 2 ) && cg.time > (cgs.timelimit - 1) * 60 * 1000 ) {
+			cg.timelimitWarnings |= 2;
+			cgi_S_StartLocalSound( "sound/feedback/1_minute.wav" );
+		}
+		if ( !( cg.timelimitWarnings & 4 ) && cg.time > ( cgs.timelimit * 60 + 2 ) * 1000 ) {
+			cg.timelimitWarnings |= 4;
+			cgi_S_StartLocalSound( "sound/feedback/sudden_death.wav" );
+		}
+	}
+}
+*/
+
+/*
+===============
+CG_TransitionPlayerState
+
+===============
+*/
+void CG_TransitionPlayerState( playerState_t *ps, playerState_t *ops ) {
+	// teleporting
+	if ( ( ps->eFlags ^ ops->eFlags ) & EF_TELEPORT_BIT ) {
+		cg.thisFrameTeleport = qtrue;
+	} else {
+		cg.thisFrameTeleport = qfalse;
+	}
+
+	// check for changing follow mode
+	if ( ps->clientNum != ops->clientNum ) {
+		cg.thisFrameTeleport = qtrue;
+		// make sure we don't get any unwanted transition effects
+		*ops = *ps;
+	}
+
+	// damage events (player is getting wounded)
+	if ( ps->damageEvent != ops->damageEvent && ps->damageCount ) {
+		CG_DamageFeedback( ps->damageYaw, ps->damagePitch, ps->damageCount );
+	}
+
+	// respawning
+	if ( ps->persistant[PERS_SPAWN_COUNT] != ops->persistant[PERS_SPAWN_COUNT] ) {
+		CG_Respawn();
+	}
+
+	// check for going low on ammo
+	CG_CheckAmmo();
+
+	// run events
+	CG_CheckPlayerstateEvents( ps, ops );
+
+	// smooth the ducking viewheight change
+	if ( ps->viewheight != ops->viewheight ) 
+	{
+		if ( !cg.nextFrameTeleport )
+		{//when we crouch/uncrouch in mid-air, our viewhieght doesn't actually change in
+			//absolute world coordinates, just locally.
+			cg.duckChange = ps->viewheight - ops->viewheight;
+			cg.duckTime = cg.time;
+		}
+	}
+}
+
diff --git a/code/cgame/cg_predict.cpp b/code/cgame/cg_predict.cpp
new file mode 100644
index 0000000..4111baf
--- /dev/null
+++ b/code/cgame/cg_predict.cpp
@@ -0,0 +1,780 @@
+// cg_predict.c -- this file generates cg.predicted_player_state by either
+// interpolating between snapshots from the server or locally predicting
+// ahead the client's movement
+
+// this line must stay at top so the whole PCH thing works...
+#include "cg_headers.h"
+
+//#include "cg_local.h"
+#include "cg_media.h"
+
+#include "..\game\g_vehicles.h"
+
+static	pmove_t		cg_pmove;
+
+static	int			cg_numSolidEntities;
+static	centity_t	*cg_solidEntities[MAX_ENTITIES_IN_SNAPSHOT];
+
+#if MEM_DEBUG
+#include "..\smartheap\heapagnt.h"
+#define CG_TRACE_PROFILE (0)
+#endif
+
+/*
+====================
+CG_BuildSolidList
+
+When a new cg.snap has been set, this function builds a sublist
+of the entities that are actually solid, to make for more
+efficient collision detection
+====================
+*/
+void CG_BuildSolidList( void ) 
+{
+	int			i;
+	centity_t	*cent;
+	vec3_t		difference;
+	float		dsquared;
+
+	cg_numSolidEntities = 0;
+
+	if(!cg.snap)
+	{
+		return;
+	}
+
+	for ( i = 0 ; i < cg.snap->numEntities ; i++ ) 
+	{
+		if ( cg.snap->entities[ i ].number < ENTITYNUM_WORLD )
+		{
+			cent = &cg_entities[ cg.snap->entities[ i ].number ];
+
+			if ( cent->gent != NULL && cent->gent->s.solid ) 
+			{
+				cg_solidEntities[cg_numSolidEntities] = cent;
+				cg_numSolidEntities++;
+			}
+		}
+	}
+
+	dsquared = 5000+500;
+	dsquared *= dsquared;
+
+	for(i=0;i<cg_numpermanents;i++)
+	{
+		cent = cg_permanents[i];
+		VectorSubtract(cent->lerpOrigin, cg.snap->ps.origin, difference);
+		if (cent->currentState.eType == ET_TERRAIN ||
+			((difference[0]*difference[0]) + (difference[1]*difference[1]) + (difference[2]*difference[2])) <= dsquared)
+		{
+			cent->currentValid = qtrue;
+			if ( cent->nextState && cent->nextState->solid ) 
+			{
+				cg_solidEntities[cg_numSolidEntities] = cent;
+				cg_numSolidEntities++;
+			}
+		}
+		else
+		{
+			cent->currentValid = qfalse;
+		}
+	}
+}
+
+/*
+====================
+CG_ClipMoveToEntities
+
+====================
+*/
+void CG_ClipMoveToEntities ( const vec3_t start, const vec3_t mins, const vec3_t maxs, const vec3_t end,
+							int skipNumber, int mask, trace_t *tr ) {
+	int			i, x, zd, zu;
+	trace_t		trace;
+	entityState_t	*ent;
+	clipHandle_t 	cmodel;
+	vec3_t		bmins, bmaxs;
+	vec3_t		origin, angles;
+	centity_t	*cent;
+
+	for ( i = 0 ; i < cg_numSolidEntities ; i++ ) {
+		cent = cg_solidEntities[ i ];
+		ent = &cent->currentState;
+
+		if ( ent->number == skipNumber ) {
+			continue;
+		}
+
+		if ( ent->eType == ET_PUSH_TRIGGER ) {
+			continue;
+		}
+		if ( ent->eType == ET_TELEPORT_TRIGGER ) {
+			continue;
+		}
+
+		if ( ent->solid == SOLID_BMODEL ) {
+			// special value for bmodel
+			cmodel = cgi_CM_InlineModel( ent->modelindex );
+			VectorCopy( cent->lerpAngles, angles );
+
+			//Hmm... this would cause traces against brush movers to snap at 20fps (as with the third person camera)... 
+			//Let's use the lerpOrigin for now and see if it breaks anything...
+			//EvaluateTrajectory( &cent->currentState.pos, cg.snap->serverTime, origin );
+			VectorCopy( cent->lerpOrigin, origin );
+
+		} else {
+			// encoded bbox
+			x = (ent->solid & 255);
+			zd = ((ent->solid>>8) & 255);
+			zu = ((ent->solid>>16) & 255) - 32;
+
+			bmins[0] = bmins[1] = -x;
+			bmaxs[0] = bmaxs[1] = x;
+			bmins[2] = -zd;
+			bmaxs[2] = zu;
+
+			cmodel = cgi_CM_TempBoxModel( bmins, bmaxs );//, cent->gent->contents );
+			VectorCopy( vec3_origin, angles );
+			VectorCopy( cent->lerpOrigin, origin );
+		}
+
+
+		cgi_CM_TransformedBoxTrace ( &trace, start, end,
+			mins, maxs, cmodel,  mask, origin, angles);
+
+		if (trace.allsolid || trace.fraction < tr->fraction) {
+			trace.entityNum = ent->number;
+			*tr = trace;
+		} else if (trace.startsolid) {
+			tr->startsolid = qtrue;
+		}
+		if ( tr->allsolid ) {
+			return;
+		}
+	}
+}
+
+/*
+================
+CG_Trace
+================
+*/
+void	CG_Trace( trace_t *result, const vec3_t start, const vec3_t mins, const vec3_t maxs, const vec3_t end, 
+					 const int skipNumber, const int mask, const EG2_Collision eG2TraceType/*=G2_NOCOLLIDE*/, const int useLod/*=0*/) {
+	trace_t	t;
+#if CG_TRACE_PROFILE
+#if MEM_DEBUG
+	{
+		int old=dbgMemSetCheckpoint(2004);
+		malloc(1);
+		dbgMemSetCheckpoint(old);
+	}
+#endif
+#endif
+
+	cgi_CM_BoxTrace ( &t, start, end, mins, maxs, 0, mask);
+	t.entityNum = t.fraction != 1.0 ? ENTITYNUM_WORLD : ENTITYNUM_NONE;
+	// check all other solid models
+	CG_ClipMoveToEntities (start, mins, maxs, end, skipNumber, mask, &t);
+
+	*result = t;
+}
+
+/*
+================
+CG_PointContents
+================
+*/
+
+#define USE_SV_PNT_CONTENTS (1)
+
+#if USE_SV_PNT_CONTENTS
+int		CG_PointContents( const vec3_t point, int passEntityNum ) {
+	return gi.pointcontents(point,passEntityNum );
+}
+#else
+int		CG_PointContents( const vec3_t point, int passEntityNum ) {
+	int			i;
+	entityState_t	*ent;
+	centity_t	*cent;
+	clipHandle_t cmodel;
+	int			contents;
+
+#if CG_TRACE_PROFILE
+#if MEM_DEBUG
+	{
+		int old=dbgMemSetCheckpoint(2005);
+		malloc(1);
+		dbgMemSetCheckpoint(old);
+	}
+#endif
+#endif
+	contents = cgi_CM_PointContents (point, 0);
+
+	for ( i = 0 ; i < cg_numSolidEntities ; i++ ) {
+		cent = cg_solidEntities[ i ];
+
+		ent = &cent->currentState;
+
+		if ( ent->number == passEntityNum ) {
+			continue;
+		}
+
+		if (ent->solid != SOLID_BMODEL) { // special value for bmodel
+			continue;
+		}
+
+		cmodel = cgi_CM_InlineModel( ent->modelindex );
+		if ( !cmodel ) {
+			continue;
+		}
+
+		contents |= cgi_CM_TransformedPointContents( point, cmodel, ent->origin, ent->angles );
+	}
+
+	return contents;
+}
+#endif
+
+void CG_SetClientViewAngles( vec3_t angles, qboolean overrideViewEnt )
+{
+	if ( cg.snap->ps.viewEntity <= 0 || cg.snap->ps.viewEntity >= ENTITYNUM_WORLD || overrideViewEnt )
+	{//don't clamp angles when looking through a viewEntity
+		for( int i = 0; i < 3; i++ ) 
+		{
+			cg.predicted_player_state.viewangles[i] = angles[i];
+			cg.predicted_player_state.delta_angles[i] = 0;
+			cg.snap->ps.viewangles[i] = angles[i];
+			cg.snap->ps.delta_angles[i] = 0;
+			g_entities[0].client->pers.cmd_angles[i] = ANGLE2SHORT(angles[i]);
+		}
+		cgi_SetUserCmdAngles( angles[PITCH], angles[YAW], angles[ROLL] );
+	}
+}
+
+extern qboolean PM_AdjustAnglesToGripper( gentity_t *gent, usercmd_t *cmd );
+extern qboolean PM_AdjustAnglesForSpinningFlip( gentity_t *ent, usercmd_t *ucmd, qboolean anglesOnly );
+extern qboolean G_CheckClampUcmd( gentity_t *ent, usercmd_t *ucmd );
+extern Vehicle_t *G_IsRidingVehicle( gentity_t *ent );
+qboolean CG_CheckModifyUCmd( usercmd_t *cmd, vec3_t viewangles )
+{
+	qboolean overridAngles = qfalse;
+	if ( cg.snap->ps.viewEntity > 0 && cg.snap->ps.viewEntity < ENTITYNUM_WORLD )
+	{//controlling something else
+		memset( cmd, 0, sizeof( usercmd_t ) );
+		/*
+		//to keep pointing in same dir, need to set cmd.angles
+		cmd->angles[PITCH] = ANGLE2SHORT( cg.snap->ps.viewangles[PITCH] ) - cg.snap->ps.delta_angles[PITCH];
+		cmd->angles[YAW] = ANGLE2SHORT( cg.snap->ps.viewangles[YAW] ) - cg.snap->ps.delta_angles[YAW];
+		cmd->angles[ROLL] = 0;
+		*/
+		VectorCopy( g_entities[0].pos4, viewangles );
+		overridAngles = qtrue;
+		//CG_SetClientViewAngles( g_entities[cg.snap->ps.viewEntity].client->ps.viewangles, qtrue );
+	}
+	else if ( G_IsRidingVehicle( &g_entities[0] ) )
+	{
+		overridAngles = qtrue;
+		/*
+		int vehIndex = g_entities[0].owner->client->ps.vehicleIndex;
+		if ( vehIndex != VEHICLE_NONE 
+			&& (vehicleData[vehIndex].type == VH_FIGHTER || (vehicleData[vehIndex].type == VH_SPEEDER )) )
+		{//in vehicle flight mode
+			float speed = VectorLength( cg.snap->ps.velocity );
+			if ( !speed || cg.snap->ps.groundEntityNum != ENTITYNUM_NONE )
+			{
+				cmd->rightmove = 0;
+				cmd->angles[PITCH] = 0;
+				cmd->angles[YAW] = ANGLE2SHORT( cg.snap->ps.viewangles[YAW] ) - cg.snap->ps.delta_angles[YAW];
+				CG_SetClientViewAngles( cg.snap->ps.viewangles, qfalse );
+			}
+		}
+		*/
+	}
+
+	if ( &g_entities[0] && g_entities[0].client )
+	{
+		if ( !PM_AdjustAnglesToGripper( &g_entities[0], cmd ) )
+		{
+			if ( PM_AdjustAnglesForSpinningFlip( &g_entities[0], cmd, qtrue ) )
+			{
+				CG_SetClientViewAngles( g_entities[0].client->ps.viewangles, qfalse );
+				if ( viewangles )
+				{
+					VectorCopy( g_entities[0].client->ps.viewangles, viewangles );
+					overridAngles = qtrue;
+				}
+			}
+		}
+		else
+		{
+			CG_SetClientViewAngles( g_entities[0].client->ps.viewangles, qfalse );
+			if ( viewangles )
+			{
+				VectorCopy( g_entities[0].client->ps.viewangles, viewangles );
+				overridAngles = qtrue;
+			}
+		}
+		if ( G_CheckClampUcmd( &g_entities[0], cmd ) )
+		{
+			CG_SetClientViewAngles( g_entities[0].client->ps.viewangles, qfalse );
+			if ( viewangles )
+			{
+				VectorCopy( g_entities[0].client->ps.viewangles, viewangles );
+				overridAngles = qtrue;
+			}
+		}
+	}
+	return overridAngles;
+}
+
+qboolean CG_OnMovingPlat( playerState_t *ps )
+{
+	if ( ps->groundEntityNum != ENTITYNUM_NONE )
+	{
+		entityState_t *es = &cg_entities[ps->groundEntityNum].currentState;
+		if ( es->eType == ET_MOVER )
+		{//on a mover
+			if ( es->pos.trType != TR_STATIONARY )
+			{
+				if ( es->pos.trType != TR_LINEAR_STOP && es->pos.trType != TR_NONLINEAR_STOP )
+				{//a constant mover
+					if ( !VectorCompare( vec3_origin, es->pos.trDelta ) )
+					{//is moving
+						return qtrue;
+					}
+				}
+				else
+				{//a linear-stop mover
+					if ( es->pos.trTime+es->pos.trDuration > cg.time )
+					{//still moving
+						return qtrue;
+					}
+				}
+			}
+		}
+	}
+	return qfalse;
+}
+/*
+========================
+CG_InterpolatePlayerState
+
+Generates cg.predicted_player_state by interpolating between
+cg.snap->player_state and cg.nextFrame->player_state
+========================
+*/
+void CG_InterpolatePlayerState( qboolean grabAngles ) {
+	float			f;
+	int				i;
+	playerState_t	*out;
+	snapshot_t		*prev, *next;
+	qboolean		skip = qfalse;
+	vec3_t			oldOrg;
+
+	out = &cg.predicted_player_state;
+	prev = cg.snap;
+	next = cg.nextSnap;
+
+	VectorCopy(out->origin,oldOrg);
+	*out = cg.snap->ps;
+
+	// if we are still allowing local input, short circuit the view angles
+	if ( grabAngles ) {
+		usercmd_t	cmd;
+		int			cmdNum;
+
+		cmdNum = cgi_GetCurrentCmdNumber();
+		cgi_GetUserCmd( cmdNum, &cmd );
+
+		skip = CG_CheckModifyUCmd( &cmd, out->viewangles );
+
+		if ( !skip )
+		{
+			//NULL so that it doesn't execute a block of code that must be run from game
+			PM_UpdateViewAngles( out, &cmd, NULL );
+		}
+	}
+
+	// if the next frame is a teleport, we can't lerp to it
+	if ( cg.nextFrameTeleport ) 
+	{
+		return;
+	}
+
+	if (!( !next || next->serverTime <= prev->serverTime ) )
+	{
+
+		f = (float)( cg.time - prev->serverTime ) / ( next->serverTime - prev->serverTime );
+		
+		i = next->ps.bobCycle;
+		if ( i < prev->ps.bobCycle ) 
+		{
+			i += 256;		// handle wraparound
+		}
+		out->bobCycle = prev->ps.bobCycle + f * ( i - prev->ps.bobCycle );
+
+		for ( i = 0 ; i < 3 ; i++ ) 
+		{
+			out->origin[i] = prev->ps.origin[i] + f * (next->ps.origin[i] - prev->ps.origin[i] );
+			if ( !grabAngles ) 
+			{
+				out->viewangles[i] = LerpAngle( 
+					prev->ps.viewangles[i], next->ps.viewangles[i], f );
+			}
+			out->velocity[i] = prev->ps.velocity[i] + 
+				f * (next->ps.velocity[i] - prev->ps.velocity[i] );
+		}
+	}
+
+	bool onPlat=false;
+	centity_t	*pent=0;
+	if (out->groundEntityNum>0)
+	{
+		pent=&cg_entities[out->groundEntityNum];
+		if (pent->currentState.eType == ET_MOVER ) 
+
+		{
+			onPlat=true;
+		}
+	}
+
+	if (
+		cg.validPPS && 
+		cg_smoothPlayerPos.value>0.0f && 
+		cg_smoothPlayerPos.value<1.0f &&
+		!onPlat
+		)
+	{
+		// 0 = no smoothing, 1 = no movement
+		for (i=0;i<3;i++)
+		{
+			out->origin[i]=cg_smoothPlayerPos.value*(oldOrg[i]-out->origin[i])+out->origin[i];
+		}
+	}
+	else if (onPlat&&cg_smoothPlayerPlat.value>0.0f&&cg_smoothPlayerPlat.value<1.0f)
+	{
+//		if (cg.frametime<150)
+//		{
+		assert(pent);
+		vec3_t	p1,p2,vel;
+		float lerpTime;
+
+
+		EvaluateTrajectory( &pent->currentState.pos,cg.snap->serverTime, p1 );
+		if ( cg.nextSnap &&cg.nextSnap->serverTime > cg.snap->serverTime && pent->nextState) 
+		{
+			EvaluateTrajectory( &pent->nextState->pos,cg.nextSnap->serverTime, p2 );
+			lerpTime=float(cg.nextSnap->serverTime - cg.snap->serverTime);
+		}
+		else
+		{
+			EvaluateTrajectory( &pent->currentState.pos,cg.snap->serverTime+50, p2 );
+			lerpTime=50.0f;
+		}
+
+		float accel=cg_smoothPlayerPlatAccel.value*cg.frametime/lerpTime;
+
+		if (accel>20.0f)
+		{
+			accel=20.0f;
+		}
+
+		for (i=0;i<3;i++)
+		{
+			vel[i]=accel*(p2[i]-p1[i]);
+		}
+
+		VectorAdd(out->origin,vel,out->origin);
+
+		if (cg.validPPS && 
+			cg_smoothPlayerPlat.value>0.0f && 
+			cg_smoothPlayerPlat.value<1.0f
+			)
+		{
+			// 0 = no smoothing, 1 = no movement
+			for (i=0;i<3;i++)
+			{
+				out->origin[i]=cg_smoothPlayerPlat.value*(oldOrg[i]-out->origin[i])+out->origin[i];
+			}
+		}
+//		}
+	}
+}
+
+/*
+===================
+CG_TouchItem
+===================
+*/
+void CG_TouchItem( centity_t *cent ) {
+	gitem_t		*item;
+
+	// never pick an item up twice in a prediction
+	if ( cent->miscTime == cg.time ) {
+		return;
+	}
+
+	if ( !BG_PlayerTouchesItem( &cg.predicted_player_state, &cent->currentState, cg.time ) ) {
+		return;
+	}
+
+	if ( !BG_CanItemBeGrabbed( &cent->currentState, &cg.predicted_player_state ) ) {
+		return;		// can't hold it
+	}
+
+	item = &bg_itemlist[ cent->currentState.modelindex ];
+
+	// grab it
+	AddEventToPlayerstate( EV_ITEM_PICKUP, cent->currentState.modelindex , &cg.predicted_player_state);
+
+	// remove it from the frame so it won't be drawn
+	cent->currentState.eFlags |= EF_NODRAW;
+
+	// don't touch it again this prediction
+	cent->miscTime = cg.time;
+
+	// if its a weapon, give them some predicted ammo so the autoswitch will work
+	if ( item->giType == IT_WEAPON ) {
+		int ammotype = weaponData[item->giTag].ammoIndex;
+		cg.predicted_player_state.stats[ STAT_WEAPONS ] |= 1 << item->giTag;
+		if ( !cg.predicted_player_state.ammo[ ammotype] ) {
+			cg.predicted_player_state.ammo[ ammotype ] = 1;
+		}
+	}
+}
+
+
+/*
+=========================
+CG_TouchTriggerPrediction
+
+Predict push triggers and items
+Only called for the last command
+=========================
+*/
+void CG_TouchTriggerPrediction( void ) {
+	int			i;
+	trace_t		trace;
+	entityState_t	*ent;
+	clipHandle_t cmodel;
+	centity_t	*cent;
+	qboolean	spectator;
+
+	// dead clients don't activate triggers
+	if ( cg.predicted_player_state.stats[STAT_HEALTH] <= 0 ) {
+		return;
+	}
+
+	spectator = ( cg.predicted_player_state.pm_type == PM_SPECTATOR );
+
+	if ( cg.predicted_player_state.pm_type != PM_NORMAL && !spectator ) {
+		return;
+	}
+
+	for ( i = 0 ; i < cg.snap->numEntities ; i++ ) {
+		cent = &cg_entities[ cg.snap->entities[ i ].number ];
+		ent = &cent->currentState;
+
+		if ( ent->eType == ET_ITEM && !spectator ) {
+			CG_TouchItem( cent );
+			continue;
+		}
+
+		if ( ent->eType != ET_PUSH_TRIGGER && ent->eType != ET_TELEPORT_TRIGGER ) {
+			continue;
+		}
+
+		if ( ent->solid != SOLID_BMODEL ) {
+			continue;
+		}
+
+		cmodel = cgi_CM_InlineModel( ent->modelindex );
+		if ( !cmodel ) {
+			continue;
+		}
+
+		cgi_CM_BoxTrace( &trace, cg.predicted_player_state.origin, cg.predicted_player_state.origin, 
+			cg_pmove.mins, cg_pmove.maxs, cmodel, -1 );
+
+		if ( !trace.startsolid ) {
+			continue;
+		}
+
+		if ( ent->eType == ET_TELEPORT_TRIGGER ) {
+			cg.hyperspace = qtrue;
+		} else {
+			// we hit this push trigger
+			if ( spectator ) {
+				continue;
+			}
+
+			VectorCopy( ent->origin2, cg.predicted_player_state.velocity );
+		}
+	}
+}
+
+
+/*
+=================
+CG_PredictPlayerState
+
+Generates cg.predicted_player_state for the current cg.time
+cg.predicted_player_state is guaranteed to be valid after exiting.
+
+For normal gameplay, it will be the result of predicted usercmd_t on
+top of the most recent playerState_t received from the server.
+
+Each new refdef will usually have exactly one new usercmd over the last,
+but we have to simulate all unacknowledged commands since the last snapshot
+received.  This means that on an internet connection, quite a few
+pmoves may be issued each frame.
+
+OPTIMIZE: don't re-simulate unless the newly arrived snapshot playerState_t
+differs from the predicted one.
+
+We detect prediction errors and allow them to be decayed off over several frames
+to ease the jerk.
+=================
+*/
+extern	qboolean	player_locked;
+void CG_PredictPlayerState( void ) {
+	int			cmdNum, current;
+	playerState_t	oldPlayerState;
+
+	cg.hyperspace = qfalse;	// will be set if touching a trigger_teleport
+
+	// if this is the first frame we must guarantee
+	// predicted_player_state is valid even if there is some
+	// other error condition
+	if ( !cg.validPPS ) {
+		cg.validPPS = qtrue;
+		cg.predicted_player_state = cg.snap->ps;
+	}
+
+
+	if ( 1 )//cg_timescale.value >= 1.0f )
+	{
+		// demo playback just copies the moves
+		/*
+		if ( (cg.snap->ps.pm_flags & PMF_FOLLOW) ) {
+			CG_InterpolatePlayerState( qfalse );
+			return;
+		}
+		*/
+
+		// non-predicting local movement will grab the latest angles
+		CG_InterpolatePlayerState( qtrue );
+		return;
+	}
+
+	// prepare for pmove
+	//FIXME: is this bad???
+	cg_pmove.gent = NULL;
+	cg_pmove.ps = &cg.predicted_player_state;
+	cg_pmove.trace = CG_Trace;
+	cg_pmove.pointcontents = CG_PointContents;
+	cg_pmove.tracemask = MASK_PLAYERSOLID;
+	cg_pmove.noFootsteps = 0;//( cgs.dmflags & DF_NO_FOOTSTEPS ) > 0;
+
+	// save the state before the pmove so we can detect transitions
+	oldPlayerState = cg.predicted_player_state;
+
+	// if we are too far out of date, just freeze
+	cmdNum = cg.snap->cmdNum;
+	current = cgi_GetCurrentCmdNumber();
+
+	if ( current - cmdNum >= CMD_BACKUP ) {
+		return;	
+	}
+
+	// get the most recent information we have
+	cg.predicted_player_state = cg.snap->ps;
+
+	// we should always be predicting at least one frame
+	if ( cmdNum >= current )	{
+		return;	
+	}
+
+	// run cmds
+	do {
+		// check for a prediction error from last frame
+		// on a lan, this will often be the exact value
+		// from the snapshot, but on a wan we will have
+		// to predict several commands to get to the point
+		// we want to compare
+		if ( cmdNum == current - 1 ) {
+			vec3_t	delta;
+			float	len;
+
+			if ( cg.thisFrameTeleport ) {
+				// a teleport will not cause an error decay
+				VectorClear( cg.predictedError );
+				cg.thisFrameTeleport = qfalse;
+			} else {
+				vec3_t	adjusted;
+				CG_AdjustPositionForMover( cg.predicted_player_state.origin, 
+					cg.predicted_player_state.groundEntityNum, cg.oldTime, adjusted );
+
+				VectorSubtract( oldPlayerState.origin, adjusted, delta );
+				len = VectorLength( delta );
+				if ( len > 0.1 ) {
+					if ( cg_errorDecay.integer ) {
+						int		t;
+						float	f;
+
+						t = cg.time - cg.predictedErrorTime;
+						f = ( cg_errorDecay.value - t ) / cg_errorDecay.value;
+						if ( f < 0 ) {
+							f = 0;
+						}
+						VectorScale( cg.predictedError, f, cg.predictedError );
+					} else {
+						VectorClear( cg.predictedError );
+					}
+					VectorAdd( delta, cg.predictedError, cg.predictedError );
+					cg.predictedErrorTime = cg.oldTime;
+				}
+			}
+		}
+
+		// if the command can't be gotten because it is
+		// too far out of date, the frame is invalid
+		// this should never happen, because we check ranges at
+		// the top of the function
+		cmdNum++;
+		if ( !cgi_GetUserCmd( cmdNum, &cg_pmove.cmd ) ) {
+			break;
+		}
+
+		gentity_t *ent = &g_entities[0];//cheating and dirty, I know, but this is a SP game so prediction can cheat
+		if ( player_locked ||
+			(ent && !ent->s.number&&ent->aimDebounceTime>level.time) ||
+			(ent && ent->client && ent->client->ps.pm_time && (ent->client->ps.pm_flags&PMF_TIME_KNOCKBACK)) ||
+			(ent && ent->forcePushTime > level.time) ) 
+		{//lock out player control unless dead
+			//VectorClear( cg_pmove.cmd.angles );
+			cg_pmove.cmd.forwardmove = 0;
+			cg_pmove.cmd.rightmove = 0;
+			cg_pmove.cmd.buttons = 0;
+			cg_pmove.cmd.upmove = 0;
+		}
+		CG_CheckModifyUCmd( &cg_pmove.cmd, NULL );
+		//FIXME: prediction on clients in timescale results in jerky positional translation
+		Pmove( &cg_pmove );
+		
+		// add push trigger movement effects
+		CG_TouchTriggerPrediction();
+
+	} while ( cmdNum < current );
+
+	// adjust for the movement of the groundentity
+	CG_AdjustPositionForMover( cg.predicted_player_state.origin, 
+		cg.predicted_player_state.groundEntityNum, 
+		cg.time, cg.predicted_player_state.origin );
+
+	// fire events and other transition triggered things
+	CG_TransitionPlayerState( &cg.predicted_player_state, &oldPlayerState );
+}
+
+
diff --git a/code/cgame/cg_public.h b/code/cgame/cg_public.h
new file mode 100644
index 0000000..cb091b3
--- /dev/null
+++ b/code/cgame/cg_public.h
@@ -0,0 +1,214 @@
+#ifndef _CG_PUBLIC_H
+#define _CG_PUBLIC_H
+
+#define NUM_EXPLOSION_SHADERS	8
+#define NUM_EXPLOSION_FRAMES	3
+
+#define	CMD_BACKUP			64	
+#define	CMD_MASK			(CMD_BACKUP - 1)
+// allow a lot of command backups for very fast systems
+// multiple commands may be combined into a single packet, so this
+// needs to be larger than PACKET_BACKUP
+
+
+#define	MAX_ENTITIES_IN_SNAPSHOT	512
+
+#define	SNAPFLAG_RATE_DELAYED		1		// the server withheld a packet to save bandwidth
+#define	SNAPFLAG_DROPPED_COMMANDS	2		// the server lost some cmds coming from the client
+
+// snapshots are a view of the server at a given time
+
+// Snapshots are generated at regular time intervals by the server,
+// but they may not be sent if a client's rate level is exceeded, or
+// they may be dropped by the network.
+struct snapshot_s 
+{
+	int				snapFlags;			// SNAPFLAG_RATE_DELAYED, SNAPFLAG_DROPPED_COMMANDS
+	int				ping;
+
+	int				serverTime;		// server time the message is valid for (in msec)
+
+	byte			areamask[MAX_MAP_AREA_BYTES];		// portalarea visibility bits
+
+	int				cmdNum;			// the next cmdNum the server is expecting
+									// client side prediction should start with this cmd
+	playerState_t	ps;						// complete information about the current player at this time
+
+	int				numEntities;			// all of the entities that need to be presented
+	entityState_t	entities[MAX_ENTITIES_IN_SNAPSHOT];	// at the time of this snapshot
+
+	int				numConfigstringChanges;	// configstrings that have changed since the last
+	int				configstringNum;		// acknowledged snapshot_t (which is usually NOT the previous snapshot!)
+
+	int				numServerCommands;		// text based server commands to execute when this
+	int				serverCommandSequence;	// snapshot becomes current
+};
+
+typedef snapshot_s snapshot_t;
+
+
+/*
+==================================================================
+
+functions imported from the main executable
+
+==================================================================
+*/
+
+#define	CGAME_IMPORT_API_VERSION	4
+
+typedef enum {
+	CG_PRINT,
+	CG_ERROR,
+	CG_MILLISECONDS,
+	CG_CVAR_REGISTER,
+	CG_CVAR_UPDATE,
+	CG_CVAR_SET,
+	CG_ARGC,
+	CG_ARGV,
+	CG_ARGS,
+	CG_FS_FOPENFILE,
+	CG_FS_READ,
+	CG_FS_WRITE,
+	CG_FS_FCLOSEFILE,
+	CG_SENDCONSOLECOMMAND,
+	CG_ADDCOMMAND,
+	CG_SENDCLIENTCOMMAND,
+	CG_UPDATESCREEN,
+	CG_RMG_INIT,
+	CG_CM_REGISTER_TERRAIN,
+	CG_RE_INIT_RENDERER_TERRAIN,
+	CG_CM_LOADMAP,
+	CG_CM_NUMINLINEMODELS,
+	CG_CM_INLINEMODEL,
+	CG_CM_TEMPBOXMODEL,
+	CG_CM_POINTCONTENTS,
+	CG_CM_TRANSFORMEDPOINTCONTENTS,
+	CG_CM_BOXTRACE,
+	CG_CM_TRANSFORMEDBOXTRACE,
+	CG_CM_MARKFRAGMENTS,
+	CG_CM_SNAPPVS,
+	CG_S_STARTSOUND,
+	CG_S_STARTLOCALSOUND,
+	CG_S_CLEARLOOPINGSOUNDS,
+	CG_S_ADDLOOPINGSOUND,
+	CG_S_STOPSOUNDS,
+	CG_S_UPDATEENTITYPOSITION,
+	CG_S_RESPATIALIZE,
+	CG_S_REGISTERSOUND,
+	CG_S_STARTBACKGROUNDTRACK,
+#ifdef _IMMERSION
+	CG_FF_START,
+	CG_FF_STOP,	
+	CG_FF_STOPALL,
+	CG_FF_SHAKE,
+	CG_FF_REGISTER,
+	CG_FF_ADDLOOPINGFORCE,
+#else
+	CG_FF_STARTFX,
+	CG_FF_ENSUREFX,
+	CG_FF_STOPFX,	
+	CG_FF_STOPALLFX,
+#endif // _IMMERSION
+#ifdef _XBOX
+	CG_FF_XBOX_SHAKE,
+	CG_FF_XBOX_DAMAGE,
+#endif
+	CG_R_LOADWORLDMAP,
+	CG_R_REGISTERMODEL,
+	CG_R_REGISTERSKIN,
+	CG_R_REGISTERSHADER,
+	CG_R_REGISTERSHADERNOMIP,
+	CG_R_REGISTERFONT,
+	CG_R_FONTSTRLENPIXELS,
+	CG_R_FONTSTRLENCHARS,
+	CG_R_FONTHEIGHTPIXELS,
+	CG_R_FONTDRAWSTRING,
+	CG_LANGUAGE_ISASIAN,
+	CG_LANGUAGE_USESSPACES,
+	CG_ANYLANGUAGE_READFROMSTRING,
+	CG_R_SETREFRACTIONPROP,
+	CG_R_CLEARSCENE,
+	CG_R_ADDREFENTITYTOSCENE,
+
+	CG_R_INPVS,
+
+	CG_R_GETLIGHTING,
+	CG_R_ADDPOLYTOSCENE,
+	CG_R_ADDLIGHTTOSCENE,
+	CG_R_RENDERSCENE,
+	CG_R_SETCOLOR,
+	CG_R_DRAWSTRETCHPIC,
+	//CG_R_DRAWSCREENSHOT,
+	CG_R_MODELBOUNDS,
+	CG_R_LERPTAG,
+	CG_R_DRAWROTATEPIC,
+	CG_R_DRAWROTATEPIC2,
+	CG_R_SETRANGEFOG,
+	CG_R_LA_GOGGLES,
+	CG_R_SCISSOR,
+	CG_GETGLCONFIG,
+	CG_GETGAMESTATE,
+	CG_GETCURRENTSNAPSHOTNUMBER,
+	CG_GETSNAPSHOT,
+
+	CG_GETDEFAULTSTATE,
+
+	CG_GETSERVERCOMMAND,
+	CG_GETCURRENTCMDNUMBER,
+	CG_GETUSERCMD,
+	CG_SETUSERCMDVALUE,
+	CG_SETUSERCMDANGLES,
+	CG_S_UPDATEAMBIENTSET,
+	CG_S_ADDLOCALSET,
+	CG_AS_PARSESETS,
+	CG_AS_ADDENTRY,
+	CG_AS_GETBMODELSOUND,
+	CG_S_GETSAMPLELENGTH,
+	COM_SETORGANGLES,
+/*
+Ghoul2 Insert Start
+*/
+	CG_G2_LISTBONES,
+	CG_G2_LISTSURFACES,
+	CG_G2_HAVEWEGHOULMODELS,
+	CG_G2_SETMODELS,
+/*
+Ghoul2 Insert End
+*/
+
+	CG_R_GET_LIGHT_STYLE,
+	CG_R_SET_LIGHT_STYLE,
+	CG_R_GET_BMODEL_VERTS,
+	CG_R_WORLD_EFFECT_COMMAND,
+
+	CG_CIN_PLAYCINEMATIC,
+	CG_CIN_STOPCINEMATIC,
+	CG_CIN_RUNCINEMATIC,
+	CG_CIN_DRAWCINEMATIC,
+	CG_CIN_SETEXTENTS,
+	CG_Z_MALLOC,
+	CG_Z_FREE,
+	CG_UI_MENU_RESET,
+	CG_UI_MENU_NEW,
+	CG_UI_SETACTIVE_MENU,
+	CG_UI_MENU_OPENBYNAME,
+	CG_UI_PARSE_INT,
+	CG_UI_PARSE_STRING,
+	CG_UI_PARSE_FLOAT,
+	CG_UI_STARTPARSESESSION,
+	CG_UI_ENDPARSESESSION,
+	CG_UI_PARSEEXT,
+	CG_UI_MENUPAINT_ALL,
+	CG_UI_MENUCLOSE_ALL,
+	CG_UI_STRING_INIT,
+	CG_UI_GETMENUINFO,
+	CG_SP_GETSTRINGTEXTSTRING,
+	CG_UI_GETITEMTEXT,
+	CG_UI_GETITEMINFO,
+
+} cgameImport_t;
+
+//----------------------------------------------
+
+#endif _CG_PUBLIC_H
diff --git a/code/cgame/cg_scoreboard.cpp b/code/cgame/cg_scoreboard.cpp
new file mode 100644
index 0000000..8ad4ec4
--- /dev/null
+++ b/code/cgame/cg_scoreboard.cpp
@@ -0,0 +1,373 @@
+// this line must stay at top so the whole PCH thing works...
+#include "cg_headers.h"
+
+//#include "cg_local.h"
+#include "cg_media.h"
+#include "..\game\objectives.h"
+#include "..\game\b_local.h"
+
+#define	SCOREBOARD_WIDTH	(26*BIGCHAR_WIDTH)
+
+
+/*
+static void Scoreboard_Draw( void )
+{
+	vec4_t	newColor;
+/*
+		player = g_entities[0];
+		if( player->client->ps.persistant[PERS_ACCURACY_SHOTS] ) {
+			accuracy = player->client->ps.persistant[PERS_ACCURACY_HITS] * 100 / player->client->ps.persistant[PERS_ACCURACY_SHOTS];
+		}
+*/
+/*	cg.LCARSTextTime = 0;	//	Turn off LCARS screen
+
+	// Background
+	newColor[0] = colorTable[CT_BLACK][0];
+	newColor[1] = colorTable[CT_BLACK][1];
+	newColor[2] = colorTable[CT_BLACK][2];
+	newColor[3] = 0.5;
+	cgi_R_SetColor(newColor);
+	CG_DrawPic( 137, 73, 475, 300, cgs.media.whiteShader);	// Background
+	CG_DrawPic( 120, 99,  18, 256, cgs.media.whiteShader);	// Background
+	CG_DrawPic(  40, 94,  66, 266, cgs.media.whiteShader);	// Background
+
+	// Right side box
+	cgi_R_SetColor( colorTable[CT_DKBROWN1]);
+	CG_DrawPic( 120, 354,  32, 32, cgs.media.status_corner_16_18);
+	CG_DrawPic(  94, 356,  16, 32, cgs.media.status_corner_8_16_b);
+	CG_DrawPic(  94, 73,  16, 32, cgs.media.status_corner_8_22);
+
+	CG_DrawPic(135,73,  302, 22, cgs.media.whiteShader);	// Top
+
+	CG_DrawPic(120, 100,  18, 12, cgs.media.whiteShader);	// Middle Top
+	CG_DrawPic(120, 353,  18, 4,  cgs.media.whiteShader);	// Middle Bottom
+  
+	CG_DrawPic(130,357,  482, 18, cgs.media.whiteShader);	// Bottom
+
+	// Left side box
+	cgi_R_SetColor( colorTable[CT_DKBROWN1]);
+	CG_DrawPic(40,73,  56, 22, cgs.media.whiteShader);	// Top
+
+	CG_DrawPic(98,95,  8, 17, cgs.media.whiteShader);		// Middle Top
+	CG_DrawPic(98,353, 8, 7, cgs.media.whiteShader);		// Middle Bottom
+
+	CG_DrawPic(40,357, 58, 18, cgs.media.whiteShader);	// Bottom
+
+	CG_DrawProportionalString( 356, 208, "%", UI_RIGHT | UI_SMALLFONT, colorTable[CT_LTPURPLE1] );
+	CG_DrawProportionalString( 610, 72, ingame_text[IGT_MISSIONANALYSIS],UI_RIGHT| CG_BIGFONT, colorTable[CT_LTORANGE] );
+
+	CG_PrintScreenGraphics(statsmenu_graphics,SMG_MAX);
+
+}
+*/
+
+
+
+/*
+=================
+CG_MissionFailed
+=================
+*/
+int statusTextIndex = -1;
+void CG_MissionFailed(void)
+{
+	char *text;
+
+	if (!cg.missionFailedScreen)
+	{ 
+		cgi_UI_SetActive_Menu("missionfailed_menu");
+		cg.missionFailedScreen = qtrue;
+
+		switch (statusTextIndex)
+		{
+			case -1:	//Our HERO DIED!!!
+				text = "@SP_INGAME_MISSIONFAILED_PLAYER";
+				break;
+			case MISSIONFAILED_JAN:
+				text = "@SP_INGAME_MISSIONFAILED_JAN";
+					break;
+			case MISSIONFAILED_LUKE:
+				text = "@SP_INGAME_MISSIONFAILED_LUKE";
+					break;
+			case MISSIONFAILED_LANDO:
+				text = "@SP_INGAME_MISSIONFAILED_LANDO";
+					break;
+			case MISSIONFAILED_R5D2:
+				text = "@SP_INGAME_MISSIONFAILED_R5D2";
+					break;
+			case MISSIONFAILED_WARDEN:
+				text = "@SP_INGAME_MISSIONFAILED_WARDEN";
+					break;
+			case MISSIONFAILED_PRISONERS:
+				text = "@SP_INGAME_MISSIONFAILED_PRISONERS";
+					break;
+			case MISSIONFAILED_EMPLACEDGUNS:
+				text = "@SP_INGAME_MISSIONFAILED_EMPLACEDGUNS";
+					break;
+			case MISSIONFAILED_LADYLUCK:
+				text = "@SP_INGAME_MISSIONFAILED_LADYLUCK";
+					break;
+			case MISSIONFAILED_KYLECAPTURE:
+				text = "@SP_INGAME_MISSIONFAILED_KYLECAPTURE";
+					break;
+			case MISSIONFAILED_TOOMANYALLIESDIED:
+				text = "@SP_INGAME_MISSIONFAILED_TOOMANYALLIESDIED";
+					break;
+
+			case MISSIONFAILED_CHEWIE:
+				text = "@SP_INGAME_MISSIONFAILED_CHEWIE";
+					break;
+
+			case MISSIONFAILED_KYLE:
+				text = "@SP_INGAME_MISSIONFAILED_KYLE";
+					break;
+
+			case MISSIONFAILED_ROSH:
+				text = "@SP_INGAME_MISSIONFAILED_ROSH";
+					break;
+
+			case MISSIONFAILED_WEDGE:
+				text = "@SP_INGAME_MISSIONFAILED_WEDGE";
+					break;
+
+			case MISSIONFAILED_TURNED:
+				text = "@SP_INGAME_MISSIONFAILED_TURNED";
+					break;
+
+			default:
+				text = "@SP_INGAME_MISSIONFAILED_UNKNOWN";
+					break;
+		}
+
+		gi.cvar_set("ui_missionfailed_text", text);
+	}
+//	w = cgi_R_Font_StrLenPixels(text, cgs.media.qhFontMedium, 1.2f);	
+//		cgi_R_Font_DrawString(320 - w/2, y+30, text, colorTable[CT_HUD_RED], cgs.media.qhFontMedium, -1, 1.2f);
+
+//		cgi_SP_GetStringTextString( "SP_INGAME_RELOADMISSION", text, sizeof(text) );
+//	w = cgi_R_Font_StrLenPixels(text, cgs.media.qhFontSmall, 1.0f);	
+//		cgi_R_Font_DrawString(320 - w/2, 450, text, colorTable[CT_CYAN], cgs.media.qhFontSmall, -1, 1.0f);
+
+}
+
+/*
+=================
+CG_MissionCompletion
+=================
+*/
+#if 0 
+/*
+void CG_MissionCompletion(void)
+{
+	char text[1024]={0};
+	int w,x,y;
+	const int pad = 18;
+
+	cgi_SP_GetStringTextString( "SP_INGAME_MISSIONCOMPLETION", text, sizeof(text) );
+w = cgi_R_Font_StrLenPixels(text, cgs.media.qhFontMedium, 1.2f);	
+	cgi_R_Font_DrawString(320 - w/2, 53, text, colorTable[CT_LTGOLD1], cgs.media.qhFontMedium, -1, 1.2f);
+
+	x = 75;
+	y =86;
+	cgi_SP_GetStringTextString( "SP_INGAME_SECRETAREAS", text, sizeof(text) );
+w = cgi_R_Font_StrLenPixels(text, cgs.media.qhFontSmall, 0.8f);	
+	cgi_R_Font_DrawString(x,    y, text, colorTable[CT_LTGOLD1], cgs.media.qhFontSmall, -1, 0.8f);
+	cgi_SP_GetStringTextString( "SP_INGAME_SECRETAREAS_OF", text, sizeof(text) );
+	cgi_R_Font_DrawString(x+w,  y, va("%d %s %d", 
+										cg_entities[0].gent->client->sess.missionStats.secretsFound, 
+										text,
+										cg_entities[0].gent->client->sess.missionStats.totalSecrets
+										),
+							colorTable[CT_WHITE], cgs.media.qhFontSmall, -1, 0.8f);
+
+	y +=pad;
+	cgi_SP_GetStringTextString( "SP_INGAME_ENEMIESKILLED", text, sizeof(text) );
+w = cgi_R_Font_StrLenPixels(text, cgs.media.qhFontSmall, 0.8f);	
+	cgi_R_Font_DrawString(x, y, text, colorTable[CT_LTGOLD1], cgs.media.qhFontSmall, -1, 0.8f);
+	cgi_R_Font_DrawString(x+w,y, va("%d",cg_entities[0].gent->client->sess.missionStats.enemiesKilled), colorTable[CT_WHITE], cgs.media.qhFontSmall, -1, 0.8f);
+	/*
+	cgi_SP_GetStringTextString( "SP_INGAME_SECRETAREAS_OF", text, sizeof(text) );
+	cgi_R_Font_DrawString(x+w,y, va("%d %s %d",
+										cg_entities[0].gent->client->sess.missionStats.enemiesKilled,
+										text,
+										cg_entities[0].gent->client->sess.missionStats.enemiesSpawned
+										), 
+							colorTable[CT_WHITE], cgs.media.qhFontSmall, -1, 0.8f);
+	*/
+
+	y +=pad;
+	y +=pad;
+	cgi_SP_GetStringTextString( "SP_INGAME_FAVORITEWEAPON", text, sizeof(text) );
+w = cgi_R_Font_StrLenPixels(text, cgs.media.qhFontSmall, 0.8f);	
+	cgi_R_Font_DrawString(x, y, text, colorTable[CT_LTGOLD1], cgs.media.qhFontSmall, -1, 0.8f);
+	
+	int wpn=0,i;
+	int max_wpn = cg_entities[0].gent->client->sess.missionStats.weaponUsed[0];
+	for (i = 1; i<WP_NUM_WEAPONS; i++)
+	{
+		if (cg_entities[0].gent->client->sess.missionStats.weaponUsed[i] > max_wpn)
+		{
+			max_wpn = cg_entities[0].gent->client->sess.missionStats.weaponUsed[i];
+			wpn = i;
+		}
+	}
+
+	if ( wpn )
+	{
+		gitem_t	*wItem= FindItemForWeapon( (weapon_t)wpn);
+		cgi_SP_GetStringTextString( va("SP_INGAME_%s",wItem->classname ), text, sizeof( text ));
+	//	cgi_R_Font_DrawString(x+w, y, va("%d",wpn), colorTable[CT_WHITE], cgs.media.qhFontSmall, -1, 0.8f);
+		cgi_R_Font_DrawString(x+w, y, text, colorTable[CT_WHITE], cgs.media.qhFontSmall, -1, 0.8f);
+	}
+
+	x = 334+70;
+	y = 86;
+	cgi_SP_GetStringTextString( "SP_INGAME_SHOTSFIRED", text, sizeof(text) );
+w = cgi_R_Font_StrLenPixels(text, cgs.media.qhFontSmall, 0.8f);	
+	cgi_R_Font_DrawString(x, y, text, colorTable[CT_LTGOLD1], cgs.media.qhFontSmall, -1, 0.8f);
+	cgi_R_Font_DrawString(x+w, y, va("%d",cg_entities[0].gent->client->sess.missionStats.shotsFired), colorTable[CT_WHITE], cgs.media.qhFontSmall, -1, 0.8f);
+
+
+	y +=pad;
+	cgi_SP_GetStringTextString( "SP_INGAME_HITS", text, sizeof(text) );
+w = cgi_R_Font_StrLenPixels(text, cgs.media.qhFontSmall, 0.8f);	
+	cgi_R_Font_DrawString(x, y, text, colorTable[CT_LTGOLD1], cgs.media.qhFontSmall, -1, 0.8f);
+	cgi_R_Font_DrawString(x+w, y, va("%d",cg_entities[0].gent->client->sess.missionStats.hits), colorTable[CT_WHITE], cgs.media.qhFontSmall, -1, 0.8f);
+
+
+	y +=pad;
+	cgi_SP_GetStringTextString( "SP_INGAME_ACCURACY", text, sizeof(text) );
+w = cgi_R_Font_StrLenPixels(text, cgs.media.qhFontSmall, 0.8f);	
+	cgi_R_Font_DrawString(x, y, text, colorTable[CT_LTGOLD1], cgs.media.qhFontSmall, -1, 0.8f);
+	const float percent = cg_entities[0].gent->client->sess.missionStats.shotsFired? 100.0f * (float)cg_entities[0].gent->client->sess.missionStats.hits / cg_entities[0].gent->client->sess.missionStats.shotsFired : 0;
+	cgi_R_Font_DrawString(x+w, y, va("%.2f%%",percent), colorTable[CT_WHITE], cgs.media.qhFontSmall, -1, 0.8f);
+
+	if ( cg_entities[0].gent->client->sess.missionStats.weaponUsed[WP_SABER] <= 0 )
+	{
+		return; //don't have saber yet, so don't print any stats
+	}
+//first column, FORCE POWERS
+	y =180;
+	cgi_SP_GetStringTextString( "SP_INGAME_FORCEUSE", text, sizeof(text) );
+	cgi_R_Font_DrawString(x, y, text, colorTable[CT_WHITE], cgs.media.qhFontSmall, -1, 0.8f);
+
+	y +=pad;
+	cgi_SP_GetStringTextString( "SP_INGAME_HEAL", text, sizeof(text) );
+w = cgi_R_Font_StrLenPixels(text, cgs.media.qhFontSmall, 0.8f);	
+	cgi_R_Font_DrawString(x,   y, text, colorTable[CT_LTGOLD1], cgs.media.qhFontSmall, -1, 0.8f);
+	cgi_R_Font_DrawString(x+w, y, va("%d",cg_entities[0].gent->client->sess.missionStats.forceUsed[FP_HEAL]), colorTable[CT_WHITE], cgs.media.qhFontSmall, -1, 0.8f);
+
+	y +=pad;
+	cgi_SP_GetStringTextString( "SP_INGAME_SPEED", text, sizeof(text) );
+w = cgi_R_Font_StrLenPixels(text, cgs.media.qhFontSmall, 0.8f);	
+	cgi_R_Font_DrawString(x,   y, text, colorTable[CT_LTGOLD1], cgs.media.qhFontSmall, -1, 0.8f);
+	cgi_R_Font_DrawString(x+w, y, va("%d",cg_entities[0].gent->client->sess.missionStats.forceUsed[FP_SPEED]), colorTable[CT_WHITE], cgs.media.qhFontSmall, -1, 0.8f);
+
+	y +=pad;
+	cgi_SP_GetStringTextString( "SP_INGAME_PULL", text, sizeof(text) );
+w = cgi_R_Font_StrLenPixels(text, cgs.media.qhFontSmall, 0.8f);	
+	cgi_R_Font_DrawString(x,   y, text, colorTable[CT_LTGOLD1], cgs.media.qhFontSmall, -1, 0.8f);
+	cgi_R_Font_DrawString(x+w, y, va("%d",cg_entities[0].gent->client->sess.missionStats.forceUsed[FP_PULL]), colorTable[CT_WHITE], cgs.media.qhFontSmall, -1, 0.8f);
+
+	y +=pad;
+	cgi_SP_GetStringTextString( "SP_INGAME_PUSH", text, sizeof(text) );
+w = cgi_R_Font_StrLenPixels(text, cgs.media.qhFontSmall, 0.8f);	
+	cgi_R_Font_DrawString(x,   y, text, colorTable[CT_LTGOLD1], cgs.media.qhFontSmall, -1, 0.8f);
+	cgi_R_Font_DrawString(x+w, y, va("%d",cg_entities[0].gent->client->sess.missionStats.forceUsed[FP_PUSH]), colorTable[CT_WHITE], cgs.media.qhFontSmall, -1, 0.8f);
+
+	y +=pad;
+	cgi_SP_GetStringTextString("SP_INGAME_MINDTRICK", text, sizeof(text) );
+w = cgi_R_Font_StrLenPixels(text, cgs.media.qhFontSmall, 0.8f);	
+	cgi_R_Font_DrawString(x,   y, text, colorTable[CT_LTGOLD1], cgs.media.qhFontSmall, -1, 0.8f);
+	cgi_R_Font_DrawString(x+w, y, va("%d",cg_entities[0].gent->client->sess.missionStats.forceUsed[FP_TELEPATHY]), colorTable[CT_WHITE], cgs.media.qhFontSmall, -1, 0.8f);
+
+	y +=pad;
+	cgi_SP_GetStringTextString( "SP_INGAME_GRIP", text, sizeof(text) );
+w = cgi_R_Font_StrLenPixels(text, cgs.media.qhFontSmall, 0.8f);	
+	cgi_R_Font_DrawString(x,   y, text, colorTable[CT_LTGOLD1], cgs.media.qhFontSmall, -1, 0.8f);
+	cgi_R_Font_DrawString(x+w, y, va("%d",cg_entities[0].gent->client->sess.missionStats.forceUsed[FP_GRIP]), colorTable[CT_WHITE], cgs.media.qhFontSmall, -1, 0.8f);
+
+	y +=pad;
+	cgi_SP_GetStringTextString( "SP_INGAME_LIGHTNING", text, sizeof(text) );
+w = cgi_R_Font_StrLenPixels(text, cgs.media.qhFontSmall, 0.8f);	
+	cgi_R_Font_DrawString(x,   y, text, colorTable[CT_LTGOLD1], cgs.media.qhFontSmall, -1, 0.8f);
+	cgi_R_Font_DrawString(x+w, y, va("%d",cg_entities[0].gent->client->sess.missionStats.forceUsed[FP_LIGHTNING]), colorTable[CT_WHITE], cgs.media.qhFontSmall, -1, 0.8f);
+
+//second column, LIGHT SABER
+	y = 180;
+	x = 140;
+	cgi_SP_GetStringTextString( "SP_INGAME_LIGHTSABERUSE", text, sizeof(text) );
+	cgi_R_Font_DrawString(x, y, text, colorTable[CT_WHITE], cgs.media.qhFontSmall, -1, 0.8f);
+
+	y +=pad;
+	cgi_SP_GetStringTextString( "SP_INGAME_THROWN", text, sizeof(text) );
+w = cgi_R_Font_StrLenPixels(text, cgs.media.qhFontSmall, 0.8f);	
+	cgi_R_Font_DrawString(x,   y, text, colorTable[CT_LTGOLD1], cgs.media.qhFontSmall, -1, 0.8f);
+	cgi_R_Font_DrawString(x+w, y, va("%d",cg_entities[0].gent->client->sess.missionStats.saberThrownCnt), colorTable[CT_WHITE], cgs.media.qhFontSmall, -1, 0.8f);
+
+	y +=pad;
+	cgi_SP_GetStringTextString( "SP_INGAME_BLOCKS", text, sizeof(text) );
+w = cgi_R_Font_StrLenPixels(text, cgs.media.qhFontSmall, 0.8f);	
+	cgi_R_Font_DrawString(x,   y, text, colorTable[CT_LTGOLD1], cgs.media.qhFontSmall, -1, 0.8f);
+	cgi_R_Font_DrawString(x+w, y, va("%d",cg_entities[0].gent->client->sess.missionStats.saberBlocksCnt), colorTable[CT_WHITE], cgs.media.qhFontSmall, -1, 0.8f);
+
+	y +=pad;
+	cgi_SP_GetStringTextString( "SP_INGAME_LEGATTACKS", text, sizeof(text) );
+w = cgi_R_Font_StrLenPixels(text, cgs.media.qhFontSmall, 0.8f);	
+	cgi_R_Font_DrawString(x,   y, text, colorTable[CT_LTGOLD1], cgs.media.qhFontSmall, -1, 0.8f);
+	cgi_R_Font_DrawString(x+w, y, va("%d",cg_entities[0].gent->client->sess.missionStats.legAttacksCnt), colorTable[CT_WHITE], cgs.media.qhFontSmall, -1, 0.8f);
+
+	y +=pad;
+	cgi_SP_GetStringTextString( "SP_INGAME_ARMATTACKS", text, sizeof(text) );
+w = cgi_R_Font_StrLenPixels(text, cgs.media.qhFontSmall, 0.8f);	
+	cgi_R_Font_DrawString(x,   y, text, colorTable[CT_LTGOLD1], cgs.media.qhFontSmall, -1, 0.8f);
+	cgi_R_Font_DrawString(x+w, y, va("%d",cg_entities[0].gent->client->sess.missionStats.armAttacksCnt), colorTable[CT_WHITE], cgs.media.qhFontSmall, -1, 0.8f);
+
+	y +=pad;
+	cgi_SP_GetStringTextString( "SP_INGAME_BODYATTACKS", text, sizeof(text) );
+w = cgi_R_Font_StrLenPixels(text, cgs.media.qhFontSmall, 0.8f);	
+	cgi_R_Font_DrawString(x,   y, text, colorTable[CT_LTGOLD1], cgs.media.qhFontSmall, -1, 0.8f);
+	cgi_R_Font_DrawString(x+w, y, va("%d",cg_entities[0].gent->client->sess.missionStats.torsoAttacksCnt), colorTable[CT_WHITE], cgs.media.qhFontSmall, -1, 0.8f);
+
+	y +=pad;
+	cgi_SP_GetStringTextString( "SP_INGAME_OTHERATTACKS", text, sizeof(text) );
+w = cgi_R_Font_StrLenPixels(text, cgs.media.qhFontSmall, 0.8f);	
+	cgi_R_Font_DrawString(x,   y, text, colorTable[CT_LTGOLD1], cgs.media.qhFontSmall, -1, 0.8f);
+	cgi_R_Font_DrawString(x+w, y, va("%d",cg_entities[0].gent->client->sess.missionStats.otherAttacksCnt), colorTable[CT_WHITE], cgs.media.qhFontSmall, -1, 0.8f);
+}
+*/
+#endif
+
+/*
+=================
+CG_DrawScoreboard
+
+Draw the normal in-game scoreboard
+return value is bool to NOT draw centerstring
+=================
+*/
+qboolean CG_DrawScoreboard( void ) 
+{
+	// don't draw anything if the menu is up
+	if ( cg_paused.integer ) 
+	{
+		return qfalse;
+	}
+
+	// Character is either dead, or a script has brought up the screen
+	if (((cg.predicted_player_state.pm_type == PM_DEAD) && (cg.missionStatusDeadTime < level.time)) 
+		|| (cg.missionStatusShow))
+	{
+		CG_MissionFailed();
+		return qtrue;
+	}
+
+	return qfalse;
+}
+
+void ScoreBoardReset(void)
+{
+}
+
+//================================================================================
+
diff --git a/code/cgame/cg_servercmds.cpp b/code/cgame/cg_servercmds.cpp
new file mode 100644
index 0000000..5b1edb8
--- /dev/null
+++ b/code/cgame/cg_servercmds.cpp
@@ -0,0 +1,254 @@
+// cg_servercmds.c -- text commands sent by the server
+
+// this line must stay at top so the whole PCH thing works...
+#include "cg_headers.h"
+
+//#include "cg_local.h"
+#include "cg_media.h"
+#include "FxScheduler.h"
+#include "cg_lights.h"
+
+
+/*
+================
+CG_ParseServerinfo
+
+This is called explicitly when the gamestate is first received,
+and whenever the server updates any serverinfo flagged cvars
+================
+*/
+void CG_ParseServerinfo( void ) {
+	const char	*info;
+	char	*mapname;
+
+	info = CG_ConfigString( CS_SERVERINFO );
+	cgs.dmflags = atoi( Info_ValueForKey( info, "dmflags" ) );
+	cgs.teamflags = atoi( Info_ValueForKey( info, "teamflags" ) );
+	cgs.timelimit = atoi( Info_ValueForKey( info, "timelimit" ) );
+	cgs.maxclients = 1;
+	mapname = Info_ValueForKey( info, "mapname" );
+	Com_sprintf( cgs.mapname, sizeof( cgs.mapname ), "maps/%s.bsp", mapname );
+	char *p = strrchr(mapname,'/');
+	strcpy( cgs.stripLevelName[0], p?p+1:mapname );
+	strupr( cgs.stripLevelName[0] );
+	for (int i=1; i<STRIPED_LEVELNAME_VARIATIONS; i++)	// clear retry-array
+	{
+		cgs.stripLevelName[i][0]='\0';
+	}
+	// be careful with the []-numbers here. Currently I use 0,1,2 for replacements or substitution, and [3] for "INGAME"
+	//	I know, if I'd known there was going to be this much messing about I'd have subroutinised it all and done it
+	//	neater, but it kinda evolved...   Feel free to bug me if you want to add to it... ?  -Ste.
+	//
+
+//FIXME: a better way to handle sound-matched strings from other levels (currently uses levelname+sound as key)
+
+	// additional String files needed for some levels...
+	//
+	// JKA...
+	if (!stricmp(cgs.stripLevelName[0],"YAVIN1B"))
+	{
+		strcpy( cgs.stripLevelName[1], "YAVIN1");
+	}
+
+/*	// JK2...
+	if (!stricmp(cgs.stripLevelName[0],"KEJIM_BASE") ||
+		!stricmp(cgs.stripLevelName[0],"KEJIM_POST")
+		)
+	{
+		strcpy( cgs.stripLevelName[1], "ARTUS_MINE" );
+	}
+	if (!stricmp(cgs.stripLevelName[0],"DOOM_DETENTION") ||
+		!stricmp(cgs.stripLevelName[0],"DOOM_SHIELDS")
+		)
+	{
+		strcpy( cgs.stripLevelName[1], "DOOM_COMM" );
+	}
+	if (!stricmp(cgs.stripLevelName[0],"DOOM_COMM"))
+	{
+		strcpy( cgs.stripLevelName[1], "CAIRN_BAY" );
+	}
+	if (!stricmp(cgs.stripLevelName[0],"NS_STARPAD"))
+	{
+		strcpy( cgs.stripLevelName[1], "ARTUS_TOPSIDE" );	// for dream sequence...
+
+		strcpy( cgs.stripLevelName[2], "BESPIN_UNDERCITY" );	// for dream sequence...
+	}
+	if (!stricmp(cgs.stripLevelName[0],"BESPIN_PLATFORM"))
+	{
+		strcpy( cgs.stripLevelName[1], "BESPIN_UNDERCITY" );
+	}
+*/
+}
+
+
+/*
+================
+CG_ConfigStringModified
+
+================
+*/
+void CG_RegisterClientModels (int entityNum);
+extern void	cgi_R_WorldEffectCommand( const char *command );
+static void CG_ConfigStringModified( void ) {
+	const char	*str;
+	int		num;
+
+	num = atoi( CG_Argv( 1 ) );
+
+	// get the gamestate from the client system, which will have the
+	// new configstring already integrated
+	cgi_GetGameState( &cgs.gameState );
+
+	// look up the individual string that was modified
+	str = CG_ConfigString( num );
+
+	// do something with it if necessary
+	if ( num == CS_ITEMS ) {
+		int i;
+		for ( i = 1 ; i < bg_numItems ; i++ ) {
+			if ( str[ i ] == '1' ) 
+			{
+				if (bg_itemlist[i].classname)
+				{
+					CG_RegisterItemSounds( i );
+					CG_RegisterItemVisuals( i );
+				}
+			}
+		}
+	}
+	else if ( num == CS_MUSIC ) {
+		CG_StartMusic( qtrue );
+	} else if ( num == CS_SERVERINFO ) {
+		CG_ParseServerinfo();
+	} else if ( num >= CS_MODELS && num < CS_MODELS+MAX_MODELS ) {
+		cgs.model_draw[ num-CS_MODELS ] = cgi_R_RegisterModel( str );
+//		OutputDebugString(va("### CG_ConfigStringModified(): cgs.model_draw[%d] = \"%s\"\n",num-CS_MODELS,str));
+// GHOUL2 Insert start
+	} else if ( num >= CS_CHARSKINS && num < CS_CHARSKINS+MAX_CHARSKINS ) {
+		cgs.skins[ num-CS_CHARSKINS ] = cgi_R_RegisterSkin( str );
+// Ghoul2 Insert end
+	} else if ( num >= CS_SOUNDS && num < CS_SOUNDS+MAX_SOUNDS ) {
+		if ( str[0] != '*' ) {
+			cgs.sound_precache[ num-CS_SOUNDS] = cgi_S_RegisterSound( str );
+		}
+	} 
+	else if ( num >= CS_EFFECTS && num < CS_EFFECTS + MAX_FX ) 
+	{
+		theFxScheduler.RegisterEffect( str );
+	} 
+	else if ( num >= CS_PLAYERS && num < CS_PLAYERS+MAX_CLIENTS ) {
+		CG_NewClientinfo( num - CS_PLAYERS );
+		CG_RegisterClientModels( num - CS_PLAYERS );
+	}
+	else if ( num >= CS_LIGHT_STYLES && num < CS_LIGHT_STYLES + (MAX_LIGHT_STYLES*3))
+	{
+		CG_SetLightstyle(num - CS_LIGHT_STYLES);
+	}
+	else if ( num >= CS_WORLD_FX && num < CS_WORLD_FX + MAX_WORLD_FX )
+	{
+		cgi_R_WorldEffectCommand( str );
+	}
+}
+
+/*
+=================
+CG_ServerCommand
+
+The string has been tokenized and can be retrieved with
+Cmd_Argc() / Cmd_Argv()
+=================
+*/
+static void CG_ServerCommand( void ) {
+	const char	*cmd;
+
+	cmd = CG_Argv(0);
+
+	if ( !strcmp( cmd, "cp" ) ) {
+		CG_CenterPrint( CG_Argv(1), SCREEN_HEIGHT * 0.25 );
+		return;
+	}
+
+	if ( !strcmp( cmd, "cs" ) ) {
+		CG_ConfigStringModified();
+		return;
+	}
+
+	if ( !strcmp( cmd, "print" ) ) {
+		CG_Printf( "%s", CG_Argv(1) );
+		return;
+	}
+
+	if ( !strcmp( cmd, "chat" ) ) {
+//		cgi_S_StartLocalSound ( cgs.media.talkSound, CHAN_LOCAL_SOUND );
+		CG_Printf( "%s\n", CG_Argv(1) );
+		return;
+	}
+
+
+	// Scroll text
+	if ( !strcmp( cmd, "st" ) ) 
+	{
+		CG_ScrollText( CG_Argv(1), SCREEN_WIDTH - 16 );
+		return;
+	}
+
+	// Cinematic text
+	if ( !strcmp( cmd, "ct" ) ) 
+	{
+		CG_CaptionText( CG_Argv(1), cgs.sound_precache[atoi(CG_Argv(2))], SCREEN_HEIGHT * 0.25 );
+		return;
+	}
+
+	// Text stop
+	if ( !strcmp( cmd, "cts" ) ) 
+	{
+		CG_CaptionTextStop();
+		return;
+	}
+
+
+	// Text to appear in center of screen with an LCARS frame around it. 
+	if ( !strcmp( cmd, "lt" ) ) 
+	{
+		CG_Printf("CG_LCARSText() being called. Tell Ste\nString: \"%s\"\n",CG_Argv(1));
+		return;
+	}
+
+	// clientLevelShot is sent before taking a special screenshot for
+	// the menu system during development
+	if ( !strcmp( cmd, "clientLevelShot" ) ) {
+		cg.levelShot = qtrue;
+		return;
+	}
+
+	if ( !strcmp( cmd, "vmsg" ) ) {
+#if 0
+		char snd[MAX_QPATH];
+
+		Com_sprintf(snd, sizeof(snd), 
+			"sound/teamplay/vmsg/%s.wav", CG_Argv(1) );
+		cgi_S_StartSound (NULL, cg.snap->ps.clientNum, CHAN_AUTO, 
+			cgi_S_RegisterSound (snd) );
+#endif
+		return;
+	}
+
+	CG_Printf( "Unknown client game command: %s\n", cmd );
+}
+
+
+/*
+====================
+CG_ExecuteNewServerCommands
+
+Execute all of the server commands that were received along
+with this this snapshot.
+====================
+*/
+void CG_ExecuteNewServerCommands( int latestSequence ) {
+	while ( cgs.serverCommandSequence < latestSequence ) {
+		if ( cgi_GetServerCommand( ++cgs.serverCommandSequence ) ) {
+			CG_ServerCommand();
+		}
+	}
+}
diff --git a/code/cgame/cg_snapshot.cpp b/code/cgame/cg_snapshot.cpp
new file mode 100644
index 0000000..7aa3509
--- /dev/null
+++ b/code/cgame/cg_snapshot.cpp
@@ -0,0 +1,407 @@
+// cg_snapshot.c -- things that happen on snapshot transition,
+// not necessarily every single frame
+
+// this line must stay at top so the whole PCH thing works...
+#include "cg_headers.h"
+
+//#include "cg_local.h"
+
+/*
+==================
+CG_ResetEntity
+==================
+*/
+void CG_ResetEntity( centity_t *cent ) {
+	// if an event is set, assume it is new enough to use
+	// if the event had timed out, it would have been cleared
+	cent->previousEvent = 0;
+
+//	cent->trailTime = cg.snap->serverTime;
+
+	VectorCopy (cent->currentState.origin, cent->lerpOrigin);
+	VectorCopy (cent->currentState.angles, cent->lerpAngles);
+	if ( cent->currentState.eType == ET_PLAYER ) {
+		CG_ResetPlayerEntity( cent );
+	}
+}
+
+/*
+===============
+CG_TransitionEntity
+
+cent->nextState is moved to cent->currentState and events are fired
+===============
+*/
+void CG_TransitionEntity( centity_t *cent ) {
+	if (cent->nextState) {
+		cent->currentState = *cent->nextState;
+	}
+	cent->currentValid = qtrue;
+
+	// reset if the entity wasn't in the last frame or was teleported
+	if ( !cent->interpolate ) {
+		CG_ResetEntity( cent );
+	}
+
+	// clear the next state.  if will be set by the next CG_SetNextSnap
+	cent->interpolate = qfalse;
+
+	if ( cent->currentState.number != 0 )
+	{
+		// check for events
+		CG_CheckEvents( cent );
+	}
+}
+
+
+/*
+==================
+CG_SetInitialSnapshot
+
+This will only happen on the very first snapshot, or
+on tourney restarts.  All other times will use 
+CG_TransitionSnapshot instead.
+==================
+*/
+void CG_SetInitialSnapshot( snapshot_t *snap ) {
+	int				i;
+	centity_t		*cent;
+	entityState_t	*state;
+
+	cg.snap = snap;
+
+	// sort out solid entities
+	//CG_BuildSolidList();
+
+	CG_ExecuteNewServerCommands( snap->serverCommandSequence );
+
+	// set our local weapon selection pointer to
+	// what the server has indicated the current weapon is
+	CG_Respawn();
+
+	for ( i = 0 ; i < cg.snap->numEntities ; i++ ) {
+		state = &cg.snap->entities[ i ];
+		cent = &cg_entities[ state->number ];
+
+		cent->currentState = *state;
+		cent->interpolate = qfalse;
+		cent->currentValid = qtrue;
+
+		CG_ResetEntity( cent );
+
+		// check for events
+		CG_CheckEvents( cent );
+	}
+}
+
+
+/*
+===================
+CG_TransitionSnapshot
+
+The transition point from snap to nextSnap has passed
+===================
+*/
+void CG_TransitionSnapshot( void ) {
+	centity_t			*cent;
+	snapshot_t			*oldFrame;
+	int					i;
+
+	if ( !cg.snap ) {
+		CG_Error( "CG_TransitionSnapshot: NULL cg.snap" );
+	}
+	if ( !cg.nextSnap ) {
+		CG_Error( "CG_TransitionSnapshot: NULL cg.nextSnap" );
+	}
+
+	// execute any server string commands before transitioning entities
+	CG_ExecuteNewServerCommands( cg.nextSnap->serverCommandSequence );
+
+	// clear the currentValid flag for all entities in the existing snapshot
+	for ( i = 0 ; i < cg.snap->numEntities ; i++ ) {
+		cent = &cg_entities[ cg.snap->entities[ i ].number ];
+		cent->currentValid = qfalse;
+	}
+
+	// move nextSnap to snap and do the transitions
+	oldFrame = cg.snap;
+	cg.snap = cg.nextSnap;
+
+	// sort out solid entities
+	//CG_BuildSolidList();
+
+	for ( i = 0 ; i < cg.snap->numEntities ; i++ ) 
+	{
+		if ( 1 ) //cg.snap->entities[ i ].number != 0 ) // I guess the player adds his/her events elsewhere, so doing this also gives us double events for the player!
+		{
+			cent = &cg_entities[ cg.snap->entities[ i ].number ];
+			CG_TransitionEntity( cent );
+		}
+	}
+
+	cg.nextSnap = NULL;
+
+	// check for playerstate transition events
+	if ( oldFrame ) {
+		// if we are not doing client side movement prediction for any
+		// reason, then the client events and view changes will be issued now
+		//if ( cg_timescale.value >= 1.0f )
+		{
+			CG_TransitionPlayerState( &cg.snap->ps, &oldFrame->ps );
+		}
+	}
+
+}
+
+
+/*
+===============
+CG_SetEntityNextState
+
+Determine if the entity can be interpolated between the states
+present in cg.snap and cg,nextSnap
+===============
+*/
+void CG_SetEntityNextState( centity_t *cent, entityState_t *state ) {
+	cent->nextState = state;
+
+	// since we can't interpolate ghoul2 stuff from one frame to another, I'm just going to copy the ghoul2 info directly into the current state now
+//	CGhoul2Info *currentModel = &state->ghoul2[1]; 
+//	cent->gent->ghoul2 = state->ghoul2;
+//	CGhoul2Info *newModel = &cent->gent->ghoul2[1]; 
+
+
+	// if this frame is a teleport, or the entity wasn't in the
+	// previous frame, don't interpolate
+	if ( !cent->currentValid || ( ( cent->currentState.eFlags ^ state->eFlags ) & EF_TELEPORT_BIT )  ) {
+		cent->interpolate = qfalse;
+	} else {
+		cent->interpolate = qtrue;
+	}
+}
+
+
+/*
+===================
+CG_SetNextSnap
+
+A new snapshot has just been read in from the client system.
+===================
+*/
+void CG_SetNextSnap( snapshot_t *snap ) {
+	int					num;
+	entityState_t		*es;
+	centity_t			*cent;
+
+	cg.nextSnap = snap;
+
+	// check for extrapolation errors
+	for ( num = 0 ; num < snap->numEntities ; num++ ) {
+		es = &snap->entities[num];
+		cent = &cg_entities[ es->number ];
+		CG_SetEntityNextState( cent, es );
+	}
+
+	// if the next frame is a teleport for the playerstate,
+	if ( cg.snap && ( ( snap->ps.eFlags ^ cg.snap->ps.eFlags ) & EF_TELEPORT_BIT ) ) {
+		cg.nextFrameTeleport = qtrue;
+	} else {
+		cg.nextFrameTeleport = qfalse;
+	}
+}
+
+
+/*
+========================
+CG_ReadNextSnapshot
+
+This is the only place new snapshots are requested
+This may increment cg.processedSnapshotNum multiple
+times if the client system fails to return a
+valid snapshot.
+========================
+*/
+snapshot_t *CG_ReadNextSnapshot( void ) {
+	qboolean	r;
+	snapshot_t	*dest;
+
+	while ( cg.processedSnapshotNum < cg.latestSnapshotNum ) {
+		// decide which of the two slots to load it into
+		if ( cg.snap == &cg.activeSnapshots[0] ) {
+			dest = &cg.activeSnapshots[1];
+		} else {
+			dest = &cg.activeSnapshots[0];
+		}
+
+		// try to read the snapshot from the client system
+		cg.processedSnapshotNum++;
+		r = cgi_GetSnapshot( cg.processedSnapshotNum, dest );
+
+		// if it succeeded, return
+		if ( r ) {
+			return dest;
+		}
+
+		// a GetSnapshot will return failure if the snapshot
+		// never arrived, or  is so old that its entities
+		// have been shoved off the end of the circular
+		// buffer in the client system.
+
+		// record as a dropped packet
+//		CG_AddLagometerSnapshotInfo( NULL );
+
+		// If there are additional snapshots, continue trying to
+		// read them.
+	}
+
+	// nothing left to read
+	return NULL;
+}
+
+/*
+=================
+CG_RestartLevel
+
+A tournement restart will clear everything, but doesn't
+require a reload of all the media
+=================
+*/
+extern void CG_LinkCentsToGents(void);
+static void CG_RestartLevel( void ) {
+	int		snapshotNum;
+	int		r;
+
+	snapshotNum = cg.processedSnapshotNum;
+
+	memset( cg_entities, 0, sizeof( cg_entities ) );
+	CG_Init_CG();
+
+	CG_LinkCentsToGents();
+	CG_InitLocalEntities();
+	CG_InitMarkPolys();
+
+	// regrab the first snapshot of the restart
+
+	cg.processedSnapshotNum = snapshotNum;
+	r = cgi_GetSnapshot( cg.processedSnapshotNum, &cg.activeSnapshots[0] );
+	if ( !r ) {
+		CG_Error( "cgi_GetSnapshot failed on restart" );
+	}
+
+	CG_SetInitialSnapshot( &cg.activeSnapshots[0] );
+	cg.time = cg.snap->serverTime;
+}
+
+
+/*
+============
+CG_ProcessSnapshots
+
+We are trying to set up a renderable view, so determine
+what the simulated time is, and try to get snapshots
+both before and after that time if available.
+
+If we don't have a valid cg.snap after exiting this function,
+then a 3D game view cannot be rendered.  This should only happen
+right after the initial connection.  After cg.snap has been valid
+once, it will never turn invalid.
+
+Even if cg.snap is valid, cg.nextSnap may not be, if the snapshot
+hasn't arrived yet (it becomes an extrapolating situation instead
+of an interpolating one)
+
+============
+*/
+void CG_ProcessSnapshots( void ) {
+	snapshot_t		*snap;
+	int				n;
+	qboolean		newSnapshots;
+
+	// see what the latest snapshot the client system has is
+	cgi_GetCurrentSnapshotNumber( &n, &cg.latestSnapshotTime );
+	if ( n != cg.latestSnapshotNum ) {
+		if ( n < cg.latestSnapshotNum ) {
+			// this should never happen
+			CG_Error( "CG_ProcessSnapshots: n < cg.latestSnapshotNum" );
+		}
+		cg.latestSnapshotNum = n;
+		newSnapshots = qtrue;
+	} else {
+		newSnapshots = qfalse;
+	}
+
+	// If we have yet to receive a snapshot, check for it.
+	// Once we have gotten the first snapshot, cg.snap will
+	// always have valid data for the rest of the game
+	if ( !cg.snap ) {
+		snap = CG_ReadNextSnapshot();
+		if ( !snap ) {
+			// we can't continue until we get a snapshot
+			return;
+		}
+
+		// set our weapon selection to what
+		// the playerstate is currently using
+		CG_SetInitialSnapshot( snap );
+	}
+
+	// loop until we either have a valid nextSnap with a serverTime
+	// greater than cg.time to interpolate towards, or we run
+	// out of available snapshots
+	do {
+		// if we don't have a nextframe, try to read a new one in
+		if ( !cg.nextSnap ) {
+			snap = CG_ReadNextSnapshot();
+
+			// if we still don't have a nextframe, we will just have to
+			// extrapolate
+			if ( !snap ) {
+				break;
+			}
+
+			CG_SetNextSnap( snap );
+
+			// if time went backwards, we have a level restart
+			if ( cg.nextSnap->serverTime < cg.snap->serverTime ) {
+				// restart the level
+				CG_RestartLevel();
+				continue;	// we might also get a nextsnap
+			}
+		}
+
+		// if our time is < nextFrame's, we have a nice interpolating state
+		if ( cg.time < cg.nextSnap->serverTime ) {
+			break;
+		}
+
+		// we have passed the transition from nextFrame to frame
+		CG_TransitionSnapshot();
+	} while ( 1 );
+
+	if ( cg.snap->serverTime > cg.time ) 
+	{
+		cg.time=cg.snap->serverTime;
+#if _DEBUG
+		Com_Printf("CG_ProcessSnapshots: cg.snap->serverTime > cg.time");
+#endif
+
+	}
+	if ( cg.nextSnap != NULL && cg.nextSnap->serverTime <= cg.time ) 
+	{
+		cg.time=cg.nextSnap->serverTime-1;
+#if _DEBUG
+		Com_Printf("CG_ProcessSnapshots: cg.nextSnap->serverTime <= cg.time");
+#endif
+	}
+	// assert our valid conditions upon exiting
+	if ( cg.snap == NULL ) {
+		CG_Error( "CG_ProcessSnapshots: cg.snap == NULL" );
+	}
+	if ( cg.snap->serverTime > cg.time ) {
+		CG_Error( "CG_ProcessSnapshots: cg.snap->serverTime > cg.time" );
+	}
+	if ( cg.nextSnap != NULL && cg.nextSnap->serverTime <= cg.time ) {
+		CG_Error( "CG_ProcessSnapshots: cg.nextSnap->serverTime <= cg.time" );
+	}
+}
+
diff --git a/code/cgame/cg_syscalls.cpp b/code/cgame/cg_syscalls.cpp
new file mode 100644
index 0000000..31ac0f9
--- /dev/null
+++ b/code/cgame/cg_syscalls.cpp
@@ -0,0 +1,646 @@
+// this line must stay at top so the whole PCH thing works...
+#include "cg_headers.h"
+
+//#include "cg_local.h"
+
+// this file is only included when building a dll
+
+
+
+
+#ifdef _IMMERSION
+#include "../ff/ff.h"
+#else
+/////////////////////  this is a bit kludgy, but it only gives access to one
+//							enum table because of the #define. May get changed.
+#define CGAME_ONLY
+#include "../client/fffx.h"
+//
+/////////////////////
+#endif // _IMMERSION
+
+
+
+
+//prototypes
+extern void CG_PreInit();
+
+static int (*syscall)( int arg, ... ) = (int (*)( int, ...))-1;
+
+#ifdef _XBOX
+void cg_dllEntry( int (*syscallptr)( int arg,... ) ) {
+#else
+void dllEntry( int (*syscallptr)( int arg,... ) ) {
+#endif
+	syscall = syscallptr;
+	CG_PreInit();
+}
+
+
+inline int PASSFLOAT( float x ) {
+	float	floatTemp;
+	floatTemp = x;
+	return *(int *)&floatTemp;
+}
+
+void	cgi_Printf( const char *fmt ) {
+	syscall( CG_PRINT, fmt );
+}
+
+void	cgi_Error( const char *fmt ) {
+	syscall( CG_ERROR, fmt );
+}
+
+int		cgi_Milliseconds( void ) {
+	return syscall( CG_MILLISECONDS ); 
+}
+
+void	cgi_Cvar_Register( vmCvar_t *vmCvar, const char *varName, const char *defaultValue, int flags ) {
+	syscall( CG_CVAR_REGISTER, vmCvar, varName, defaultValue, flags );
+}
+
+void	cgi_Cvar_Update( vmCvar_t *vmCvar ) {
+	syscall( CG_CVAR_UPDATE, vmCvar );
+}
+
+void	cgi_Cvar_Set( const char *var_name, const char *value ) {
+	syscall( CG_CVAR_SET, var_name, value );
+}
+
+int		cgi_Argc( void ) {
+	return syscall( CG_ARGC );
+}
+
+void	cgi_Argv( int n, char *buffer, int bufferLength ) {
+	syscall( CG_ARGV, n, buffer, bufferLength );
+}
+
+void	cgi_Args( char *buffer, int bufferLength ) {
+	syscall( CG_ARGS, buffer, bufferLength );
+}
+
+int		cgi_FS_FOpenFile( const char *qpath, fileHandle_t *f, fsMode_t mode ) {
+	return syscall( CG_FS_FOPENFILE, qpath, f, mode );
+}
+
+int	cgi_FS_Read( void *buffer, int len, fileHandle_t f ) {
+	return syscall( CG_FS_READ, buffer, len, f );
+}
+
+int	cgi_FS_Write( const void *buffer, int len, fileHandle_t f ) {
+	return syscall( CG_FS_WRITE, buffer, len, f );
+}
+
+void	cgi_FS_FCloseFile( fileHandle_t f ) {
+	syscall( CG_FS_FCLOSEFILE, f );
+}
+
+void	cgi_SendConsoleCommand( const char *text ) {
+	syscall( CG_SENDCONSOLECOMMAND, text );
+}
+
+void	cgi_AddCommand( const char *cmdName ) {
+	syscall( CG_ADDCOMMAND, cmdName );
+}
+
+void	cgi_SendClientCommand( const char *s ) {
+	syscall( CG_SENDCLIENTCOMMAND, s );
+}
+
+void	cgi_UpdateScreen( void ) {
+	syscall( CG_UPDATESCREEN );
+}
+
+//RMG BEGIN
+void cgi_RMG_Init(int terrainID, const char *terrainInfo)
+{
+	syscall( CG_RMG_INIT, terrainID, terrainInfo);
+}
+
+int cgi_CM_RegisterTerrain(const char *terrainInfo)
+{
+	return syscall( CG_CM_REGISTER_TERRAIN, terrainInfo);
+}
+
+void cgi_RE_InitRendererTerrain( const char *terrainInfo )
+{
+	syscall(CG_RE_INIT_RENDERER_TERRAIN, terrainInfo);
+}
+//RMG END
+
+void	cgi_CM_LoadMap( const char *mapname, qboolean subBSP ) {
+	syscall( CG_CM_LOADMAP, mapname, subBSP );
+}
+
+int		cgi_CM_NumInlineModels( void ) {
+	return syscall( CG_CM_NUMINLINEMODELS );
+}
+
+clipHandle_t cgi_CM_InlineModel( int index ) {
+	return syscall( CG_CM_INLINEMODEL, index );
+}
+
+clipHandle_t cgi_CM_TempBoxModel( const vec3_t mins, const vec3_t maxs ) {//, const int contents ) {
+	return syscall( CG_CM_TEMPBOXMODEL, mins, maxs );//, contents );
+}
+
+int		cgi_CM_PointContents( const vec3_t p, clipHandle_t model ) {
+	return syscall( CG_CM_POINTCONTENTS, p, model );
+}
+
+int		cgi_CM_TransformedPointContents( const vec3_t p, clipHandle_t model, const vec3_t origin, const vec3_t angles ) {
+	return syscall( CG_CM_TRANSFORMEDPOINTCONTENTS, p, model, origin, angles );
+}
+
+void	cgi_CM_BoxTrace( trace_t *results, const vec3_t start, const vec3_t end,
+						  const vec3_t mins, const vec3_t maxs,
+						  clipHandle_t model, int brushmask ) {
+	syscall( CG_CM_BOXTRACE, results, start, end, mins, maxs, model, brushmask );
+}
+
+void	cgi_CM_TransformedBoxTrace( trace_t *results, const vec3_t start, const vec3_t end,
+						  const vec3_t mins, const vec3_t maxs,
+						  clipHandle_t model, int brushmask,
+						  const vec3_t origin, const vec3_t angles ) {
+	syscall( CG_CM_TRANSFORMEDBOXTRACE, results, start, end, mins, maxs, model, brushmask, origin, angles );
+}
+
+int		cgi_CM_MarkFragments( int numPoints, const vec3_t *points, 
+				const vec3_t projection,
+				int maxPoints, vec3_t pointBuffer,
+				int maxFragments, markFragment_t *fragmentBuffer ) {
+	return syscall( CG_CM_MARKFRAGMENTS, numPoints, points, projection, maxPoints, pointBuffer, maxFragments, fragmentBuffer );
+}
+
+void cgi_CM_SnapPVS(vec3_t origin,byte *buffer)
+{
+	syscall(CG_CM_SNAPPVS,origin,buffer);
+}
+
+void cgi_S_StopSounds( void ) 
+{
+	syscall( CG_S_STOPSOUNDS);
+}
+
+void	cgi_S_StartSound( const vec3_t origin, int entityNum, int entchannel, sfxHandle_t sfx ) {
+	syscall( CG_S_STARTSOUND, origin, entityNum, entchannel, sfx );
+}
+
+void	cgi_AS_ParseSets( void ) {
+	syscall( CG_AS_PARSESETS );
+}
+
+void	cgi_AS_AddPrecacheEntry( const char *name ) {
+	syscall( CG_AS_ADDENTRY, name );
+}
+
+void	cgi_S_UpdateAmbientSet( const char *name, vec3_t origin ) {
+	syscall( CG_S_UPDATEAMBIENTSET, name, origin );
+}
+
+int		cgi_S_AddLocalSet( const char *name, vec3_t listener_origin, vec3_t origin, int entID, int time ) {
+	return syscall( CG_S_ADDLOCALSET, name, listener_origin, origin, entID, time );
+}
+
+sfxHandle_t cgi_AS_GetBModelSound( const char *name, int stage ) {
+	return syscall( CG_AS_GETBMODELSOUND, name, stage );
+}
+
+void	cgi_S_StartLocalSound( sfxHandle_t sfx, int channelNum ) {
+	syscall( CG_S_STARTLOCALSOUND, sfx, channelNum );
+}
+
+void	cgi_S_ClearLoopingSounds( void ) {
+	syscall( CG_S_CLEARLOOPINGSOUNDS );
+}
+
+void	cgi_S_AddLoopingSound( int entityNum, const vec3_t origin, const vec3_t velocity, sfxHandle_t sfx, soundChannel_t chan ) {
+	syscall( CG_S_ADDLOOPINGSOUND, entityNum, origin, velocity, sfx, chan );
+}
+
+void	cgi_S_UpdateEntityPosition( int entityNum, const vec3_t origin ) {
+	syscall( CG_S_UPDATEENTITYPOSITION, entityNum, origin );
+}
+
+void	cgi_S_Respatialize( int entityNum, const vec3_t origin, vec3_t axis[3], qboolean inwater ) {
+	syscall( CG_S_RESPATIALIZE, entityNum, origin, axis, inwater );
+}
+
+sfxHandle_t	cgi_S_RegisterSound( const char *sample ) {
+	return syscall( CG_S_REGISTERSOUND, sample );
+}
+
+void	cgi_S_StartBackgroundTrack( const char *intro, const char *loop, qboolean bForceStart ) {
+	syscall( CG_S_STARTBACKGROUNDTRACK, intro, loop, bForceStart );
+}
+
+float	cgi_S_GetSampleLength( sfxHandle_t sfx ) {
+	return syscall( CG_S_GETSAMPLELENGTH, sfx);
+}
+
+#ifdef _IMMERSION
+
+void	cgi_FF_Start( ffHandle_t ff, int clientNum ){
+	syscall( CG_FF_START, ff, clientNum );
+}
+
+void	cgi_FF_Stop( ffHandle_t ff, int clientNum ){
+	syscall( CG_FF_STOP, ff, clientNum );
+}
+
+void	cgi_FF_StopAll( void ){
+	syscall( CG_FF_STOPALL );
+}
+
+void	cgi_FF_Shake( int intensity, int duration ){
+	syscall( CG_FF_SHAKE, intensity, duration );
+}
+
+ffHandle_t cgi_FF_Register( const char *name, int channel ){
+	return syscall( CG_FF_REGISTER, name, channel );
+}
+
+void	cgi_FF_AddLoopingForce( ffHandle_t handle, int entNum ){
+	syscall( CG_FF_ADDLOOPINGFORCE, handle, entNum );
+}
+
+#else
+
+void	cgi_FF_StartFX( int iFX ){
+	syscall( CG_FF_STARTFX, iFX );
+}
+
+void	cgi_FF_EnsureFX( int iFX ){
+	syscall( CG_FF_ENSUREFX, iFX );
+}
+
+void	cgi_FF_StopFX( int iFX ){
+	syscall( CG_FF_STOPFX, iFX );
+}
+
+void	cgi_FF_StopAllFX( void ){
+	syscall( CG_FF_STOPALLFX );
+}
+
+#endif // _IMMERSION
+
+#ifdef _XBOX
+
+void	cgi_FF_Xbox_Shake( float intensity, int duration ){
+	syscall( CG_FF_XBOX_SHAKE, PASSFLOAT(intensity), duration );
+}
+
+void	cgi_FF_Xbox_Damage( int damage, float xpos ) {
+	syscall( CG_FF_XBOX_DAMAGE, damage, PASSFLOAT(xpos) );
+}
+
+#endif
+
+void	cgi_R_LoadWorldMap( const char *mapname ) {
+	syscall( CG_R_LOADWORLDMAP, mapname );
+}
+
+qhandle_t cgi_R_RegisterModel( const char *name ) {
+	return syscall( CG_R_REGISTERMODEL, name );
+}
+
+qhandle_t cgi_R_RegisterSkin( const char *name ) {
+	return syscall( CG_R_REGISTERSKIN, name );
+}
+
+qhandle_t cgi_R_RegisterShader( const char *name ) {
+	qhandle_t hShader = syscall( CG_R_REGISTERSHADER, name );
+	assert (hShader);
+	return  hShader;
+}
+
+qhandle_t cgi_R_RegisterShaderNoMip( const char *name ) {
+	return syscall( CG_R_REGISTERSHADERNOMIP, name );
+}
+
+qhandle_t cgi_R_RegisterFont( const char *name ) {
+	return syscall( CG_R_REGISTERFONT, name );
+}
+
+int cgi_R_Font_StrLenPixels(const char *text, const int iFontIndex, const float scale /*= 1.0f*/) {
+	return syscall( CG_R_FONTSTRLENPIXELS, text, iFontIndex, PASSFLOAT(scale) ) ;
+}
+
+int cgi_R_Font_StrLenChars(const char *text) {
+	return syscall( CG_R_FONTSTRLENCHARS, text ) ;
+}
+
+int cgi_R_Font_HeightPixels(const int iFontIndex, const float scale /*= 1.0f*/) {
+	return syscall( CG_R_FONTHEIGHTPIXELS, iFontIndex, PASSFLOAT(scale) );
+}
+
+qboolean cgi_Language_IsAsian( void )
+{
+	return syscall( CG_LANGUAGE_ISASIAN );
+}
+
+qboolean cgi_Language_UsesSpaces(void)
+{
+	return syscall( CG_LANGUAGE_USESSPACES );
+}
+
+unsigned int cgi_AnyLanguage_ReadCharFromString( const char *psText, int *piAdvanceCount, qboolean *pbIsTrailingPunctuation /* = NULL */ )
+{
+	return syscall( CG_ANYLANGUAGE_READFROMSTRING, psText, piAdvanceCount, pbIsTrailingPunctuation );
+}
+
+void cgi_R_Font_DrawString(int ox, int oy, const char *text, const float *rgba, const int setIndex, int iMaxPixelWidth, const float scale /*= 1.0f*/) {
+	syscall (CG_R_FONTDRAWSTRING, ox, oy, text, rgba, setIndex, iMaxPixelWidth, PASSFLOAT(scale) );
+}
+
+//set some properties for the draw layer for my refractive effect (here primarily for mod authors) -rww
+void cgi_R_SetRefractProp(float alpha, float stretch, qboolean prepost, qboolean negate)
+{
+	syscall(CG_R_SETREFRACTIONPROP, PASSFLOAT(alpha), PASSFLOAT(stretch), prepost, negate);
+}
+
+void	cgi_R_ClearScene( void ) {
+	syscall( CG_R_CLEARSCENE );
+}
+
+void	cgi_R_AddRefEntityToScene( const refEntity_t *re ) {
+	syscall( CG_R_ADDREFENTITYTOSCENE, re );
+}
+
+qboolean	cgi_R_inPVS( vec3_t p1, vec3_t p2 )
+{
+	return syscall( CG_R_INPVS, p1, p2 );
+}
+
+
+void	cgi_R_GetLighting( const vec3_t origin, vec3_t ambientLight, vec3_t directedLight, vec3_t ligthDir ) {
+	syscall( CG_R_GETLIGHTING, origin, ambientLight, directedLight, ligthDir );
+}
+
+void	cgi_R_AddPolyToScene( qhandle_t hShader , int numVerts, const polyVert_t *verts ) {
+	syscall( CG_R_ADDPOLYTOSCENE, hShader, numVerts, verts );
+}
+
+void	cgi_R_AddLightToScene( const vec3_t org, float intensity, float r, float g, float b ) {
+	syscall( CG_R_ADDLIGHTTOSCENE, org, PASSFLOAT(intensity), PASSFLOAT(r), PASSFLOAT(g), PASSFLOAT(b) );
+}
+
+void	cgi_R_RenderScene( const refdef_t *fd ) {
+	syscall( CG_R_RENDERSCENE, fd );
+}
+
+void	cgi_R_SetColor( const float *rgba ) {
+	syscall( CG_R_SETCOLOR, rgba );
+}
+
+void	cgi_R_DrawStretchPic( float x, float y, float w, float h, 
+							   float s1, float t1, float s2, float t2, qhandle_t hShader ) {
+	syscall( CG_R_DRAWSTRETCHPIC, PASSFLOAT(x), PASSFLOAT(y), PASSFLOAT(w), PASSFLOAT(h), PASSFLOAT(s1), PASSFLOAT(t1), PASSFLOAT(s2), PASSFLOAT(t2), hShader );
+}
+
+//void	cgi_R_DrawScreenShot( float x, float y, float w, float h){
+//	syscall( CG_R_DRAWSCREENSHOT, PASSFLOAT(x), PASSFLOAT(y), PASSFLOAT(w), PASSFLOAT(h) );
+//}
+
+void	cgi_R_ModelBounds( qhandle_t model, vec3_t mins, vec3_t maxs ) {
+	syscall( CG_R_MODELBOUNDS, model, mins, maxs );
+}
+
+void	cgi_R_LerpTag( orientation_t *tag, qhandle_t mod, int startFrame, int endFrame, 
+					   float frac, const char *tagName ) {
+	syscall( CG_R_LERPTAG, tag, mod, startFrame, endFrame, PASSFLOAT(frac), tagName );
+}
+
+void	cgi_R_DrawRotatePic( float x, float y, float w, float h, 
+				   float s1, float t1, float s2, float t2,float a, qhandle_t hShader ) 
+{
+	syscall( CG_R_DRAWROTATEPIC, PASSFLOAT(x), PASSFLOAT(y), PASSFLOAT(w), PASSFLOAT(h), PASSFLOAT(s1), PASSFLOAT(t1), PASSFLOAT(s2), PASSFLOAT(t2), PASSFLOAT(a), hShader );
+}
+
+void	cgi_R_DrawRotatePic2( float x, float y, float w, float h, 
+				   float s1, float t1, float s2, float t2,float a, qhandle_t hShader ) 
+{
+	syscall( CG_R_DRAWROTATEPIC2, PASSFLOAT(x), PASSFLOAT(y), PASSFLOAT(w), PASSFLOAT(h), PASSFLOAT(s1), PASSFLOAT(t1), PASSFLOAT(s2), PASSFLOAT(t2), PASSFLOAT(a), hShader );
+}
+
+//linear fogging, with settable range -rww
+void cgi_R_SetRangeFog(float range)
+{
+	syscall(CG_R_SETRANGEFOG, PASSFLOAT(range));
+}
+
+void	cgi_R_LAGoggles( void )
+{
+	syscall( CG_R_LA_GOGGLES );
+}
+
+void	cgi_R_Scissor( float x, float y, float w, float h) 
+{
+	syscall( CG_R_SCISSOR, PASSFLOAT(x), PASSFLOAT(y), PASSFLOAT(w), PASSFLOAT(h));
+}
+
+void		cgi_GetGlconfig( glconfig_t *glconfig ) {
+	syscall( CG_GETGLCONFIG, glconfig );
+}
+
+void		cgi_GetGameState( gameState_t *gamestate ) {
+	syscall( CG_GETGAMESTATE, gamestate );
+}
+
+void		cgi_GetCurrentSnapshotNumber( int *snapshotNumber, int *serverTime ) {
+	syscall( CG_GETCURRENTSNAPSHOTNUMBER, snapshotNumber, serverTime );
+}
+
+qboolean	cgi_GetSnapshot( int snapshotNumber, snapshot_t *snapshot ) {
+	return syscall( CG_GETSNAPSHOT, snapshotNumber, snapshot );
+}
+
+qboolean	cgi_GetDefaultState(int entityIndex, entityState_t *state )
+{
+	return syscall( CG_GETDEFAULTSTATE, entityIndex, state );
+}
+
+qboolean	cgi_GetServerCommand( int serverCommandNumber ) {
+	return syscall( CG_GETSERVERCOMMAND, serverCommandNumber );
+}
+
+int			cgi_GetCurrentCmdNumber( void ) {
+	return syscall( CG_GETCURRENTCMDNUMBER );
+}
+
+qboolean	cgi_GetUserCmd( int cmdNumber, usercmd_t *ucmd ) {
+	return syscall( CG_GETUSERCMD, cmdNumber, ucmd );
+}
+
+void		cgi_SetUserCmdValue( int stateValue, float sensitivityScale, float mPitchOverride, float mYawOverride ) {
+	syscall( CG_SETUSERCMDVALUE, stateValue, PASSFLOAT(sensitivityScale), PASSFLOAT(mPitchOverride), PASSFLOAT(mYawOverride) );
+}
+
+void		cgi_SetUserCmdAngles( float pitchOverride, float yawOverride, float rollOverride ) {
+	syscall( CG_SETUSERCMDANGLES, PASSFLOAT(pitchOverride), PASSFLOAT(yawOverride), PASSFLOAT(rollOverride) );
+}
+/*
+Ghoul2 Insert Start
+*/
+// CG Specific API calls
+void		trap_G2_SetGhoul2ModelIndexes(CGhoul2Info_v &ghoul2, qhandle_t *modelList, qhandle_t *skinList)
+{
+	syscall( CG_G2_SETMODELS, &ghoul2, modelList, skinList);
+}
+/*
+Ghoul2 Insert End
+*/
+
+void	trap_Com_SetOrgAngles(vec3_t org,vec3_t angles)
+{
+	syscall(COM_SETORGANGLES,org,angles);
+}
+
+void	trap_R_GetLightStyle(int style, color4ub_t color)
+{
+	syscall(CG_R_GET_LIGHT_STYLE, style, color);
+}
+
+void	trap_R_SetLightStyle(int style, int color)
+{
+	syscall(CG_R_SET_LIGHT_STYLE, style, color);
+}
+
+void	cgi_R_GetBModelVerts(int bmodelIndex, vec3_t *verts, vec3_t normal )
+{
+	syscall( CG_R_GET_BMODEL_VERTS, bmodelIndex, verts, normal );
+}
+
+void	cgi_R_WorldEffectCommand( const char *command )
+{
+	syscall( CG_R_WORLD_EFFECT_COMMAND, command );
+}
+
+// this returns a handle.  arg0 is the name in the format "idlogo.roq", set arg1 to NULL, alteredstates to qfalse (do not alter gamestate)
+int trap_CIN_PlayCinematic( const char *arg0, int xpos, int ypos, int width, int height, int bits, const char *psAudioFile /* = NULL */) {
+  return syscall(CG_CIN_PLAYCINEMATIC, arg0, xpos, ypos, width, height, bits, psAudioFile);
+}
+ 
+// stops playing the cinematic and ends it.  should always return FMV_EOF
+// cinematics must be stopped in reverse order of when they are started
+e_status trap_CIN_StopCinematic(int handle) {
+  return (e_status) syscall(CG_CIN_STOPCINEMATIC, handle);
+}
+
+
+// will run a frame of the cinematic but will not draw it.  Will return FMV_EOF if the end of the cinematic has been reached.
+e_status trap_CIN_RunCinematic (int handle) {
+  return (e_status) syscall(CG_CIN_RUNCINEMATIC, handle);
+}
+ 
+
+// draws the current frame
+void trap_CIN_DrawCinematic (int handle) {
+  syscall(CG_CIN_DRAWCINEMATIC, handle);
+}
+ 
+
+// allows you to resize the animation dynamically
+void trap_CIN_SetExtents (int handle, int x, int y, int w, int h) {
+  syscall(CG_CIN_SETEXTENTS, handle, x, y, w, h);
+}
+
+void *cgi_Z_Malloc( int size, int tag )
+{
+	return (void *)syscall(CG_Z_MALLOC,size,tag);
+}
+
+void cgi_Z_Free( void *ptr )
+{
+	syscall(CG_Z_FREE,ptr);
+}
+
+void cgi_UI_SetActive_Menu(char *name)
+{
+	syscall(CG_UI_SETACTIVE_MENU,name);
+}
+
+void cgi_UI_Menu_OpenByName(char *buf)
+{
+	syscall(CG_UI_MENU_OPENBYNAME,buf);
+}
+
+void cgi_UI_Menu_Reset(void)
+{
+	syscall(CG_UI_MENU_RESET);
+}
+
+void cgi_UI_Menu_New(char *buf)
+{
+	syscall(CG_UI_MENU_NEW,buf);
+}
+
+void cgi_UI_Parse_Int(int *value)
+{
+	syscall(CG_UI_PARSE_INT,value);
+}
+
+void cgi_UI_Parse_String(char *buf)
+{
+	syscall(CG_UI_PARSE_STRING,buf);
+}
+
+void cgi_UI_Parse_Float(float *value)
+{
+	syscall(CG_UI_PARSE_FLOAT,value);
+}
+
+int cgi_UI_StartParseSession(char *menuFile,char **buf)
+{
+	return(int) syscall(CG_UI_STARTPARSESESSION,menuFile,buf);
+}
+
+void cgi_UI_EndParseSession(char *buf)
+{
+	syscall(CG_UI_ENDPARSESESSION,buf);
+}
+
+void cgi_UI_ParseExt(char **token)
+{
+	syscall(CG_UI_PARSEEXT,token);
+}
+
+void cgi_UI_MenuCloseAll(void)
+{
+	syscall(CG_UI_MENUCLOSE_ALL);
+}
+
+void cgi_UI_MenuPaintAll(void)
+{
+	syscall(CG_UI_MENUPAINT_ALL);
+}
+
+void cgi_UI_String_Init(void)
+{
+	syscall(CG_UI_STRING_INIT);
+}
+
+int cgi_UI_GetMenuInfo(char *menuFile,int *x,int *y,int *w,int *h)
+{
+	return(int) syscall(CG_UI_GETMENUINFO,menuFile,x,y,w,h);
+}
+
+int cgi_UI_GetMenuItemInfo(const char *menuFile,const char *itemName, int *x,int *y,int *w,int *h,vec4_t color,qhandle_t *background)
+{
+	return(int) syscall(CG_UI_GETITEMINFO,menuFile,itemName,x,y,w,h,color,background);
+}
+
+int cgi_UI_GetItemText(char *menuFile,char *itemName, char* text)
+{
+	return(int) syscall(CG_UI_GETITEMTEXT,menuFile,itemName,text);
+}
+
+int cgi_SP_GetStringTextString(const char *text, char *buffer, int bufferLength)
+{
+	return syscall( CG_SP_GETSTRINGTEXTSTRING, text, buffer, bufferLength );
+}
+
+int cgi_EndGame(void)
+{
+	return syscall( CG_SENDCONSOLECOMMAND, "cam_disable; disconnect\n" );//; cinematic outcast
+}
diff --git a/code/cgame/cg_text.cpp b/code/cgame/cg_text.cpp
new file mode 100644
index 0000000..0774a82
--- /dev/null
+++ b/code/cgame/cg_text.cpp
@@ -0,0 +1,768 @@
+// cg_text.c -- 
+
+// this line must stay at top so the whole PCH thing works...
+#include "cg_headers.h"
+
+#include "cg_media.h"
+
+
+//int precacheWav_i;	// Current high index of precacheWav array
+//precacheWav_t precacheWav[MAX_PRECACHEWAV];
+
+
+//int precacheText_i;	// Current high index of precacheText array
+//precacheText_t precacheText[MAX_PRECACHETEXT];
+
+
+extern vec4_t textcolor_caption;
+extern vec4_t textcolor_center;
+extern vec4_t textcolor_scroll;
+
+
+// display text in a supplied box, start at top left and going down by however many pixels I feel like internally, 
+//	return value is NULL if all fitted, else char * of next char to continue from that didn't fit.
+//
+// (coords are in the usual 640x480 virtual space)...
+//
+// ( if you get the same char * returned as what you passed in, then none of it fitted at all (box too small) )
+//
+		// this is execrable, and should NOT have had to've been done now, but...
+		//
+		float gfAdvanceHack = 0.0f;	// MUST default to this
+		int giLinesOutput;		// hack-city after release, only used by one function
+//
+const char *CG_DisplayBoxedText(int iBoxX, int iBoxY, int iBoxWidth, int iBoxHeight, 
+								const char *psText, int iFontHandle, float fScale,
+								const vec4_t v4Color)
+{
+	giLinesOutput = 0;
+	cgi_R_SetColor( v4Color );
+
+	// Setup a reasonable vertical spacing (taiwanese & japanese need 1.5 fontheight, so use that for all)...
+	//
+	const int iFontHeight		 = cgi_R_Font_HeightPixels(iFontHandle, fScale);
+	const int iFontHeightAdvance = (int) ( ((gfAdvanceHack == 0.0f) ? 1.5f : gfAdvanceHack) * (float) iFontHeight);
+	int iYpos = iBoxY;	// start print pos
+
+	// this could probably be simplified now, but it was converted from something else I didn't originally write, 
+	//	and it works anyway so wtf...
+	//
+	const char *psCurrentTextReadPos = psText;	
+	const char *psReadPosAtLineStart = psCurrentTextReadPos;	
+	const char *psBestLineBreakSrcPos = psCurrentTextReadPos;
+	const char *psLastGood_s;	// needed if we get a full screen of chars with no punctuation or space (see usage notes)
+	while( *psCurrentTextReadPos && (iYpos + iFontHeight < (iBoxY + iBoxHeight)) )
+	{
+		char sLineForDisplay[2048];	// ott
+
+		// construct a line...
+		//
+		psCurrentTextReadPos = psReadPosAtLineStart;
+		sLineForDisplay[0] = '\0';
+		while ( *psCurrentTextReadPos )
+		{
+			psLastGood_s = psCurrentTextReadPos;
+
+			// read letter...
+			//
+			qboolean bIsTrailingPunctuation;
+			int iAdvanceCount;
+			unsigned int uiLetter = cgi_AnyLanguage_ReadCharFromString(psCurrentTextReadPos, &iAdvanceCount, &bIsTrailingPunctuation);
+			psCurrentTextReadPos += iAdvanceCount;
+
+			// concat onto string so far...
+			//
+			if (uiLetter == 32 && sLineForDisplay[0] == '\0')
+			{
+				psReadPosAtLineStart++;
+				continue;	// unless it's a space at the start of a line, in which case ignore it.
+			}
+
+			if (uiLetter > 255)
+			{
+				Q_strcat(sLineForDisplay, sizeof(sLineForDisplay),va("%c%c",uiLetter >> 8, uiLetter & 0xFF));
+			}
+			else
+			{
+				Q_strcat(sLineForDisplay, sizeof(sLineForDisplay),va("%c",uiLetter & 0xFF));
+			}
+
+			if (uiLetter == '\n')
+			{
+				// explicit new line...
+				//
+				sLineForDisplay[ strlen(sLineForDisplay)-1 ] = '\0';	// kill the CR
+				psReadPosAtLineStart = psCurrentTextReadPos;
+				psBestLineBreakSrcPos = psCurrentTextReadPos;
+				break;	// print this line
+			}
+			else 
+			if ( cgi_R_Font_StrLenPixels(sLineForDisplay, iFontHandle, fScale) >= iBoxWidth )
+			{					
+				// reached screen edge, so cap off string at bytepos after last good position...
+				//
+				if (uiLetter > 255 && bIsTrailingPunctuation && !cgi_Language_UsesSpaces())
+				{
+					// Special case, don't consider line breaking if you're on an asian punctuation char of
+					//	a language that doesn't use spaces...
+					//
+				}
+				else
+				{
+					if (psBestLineBreakSrcPos == psReadPosAtLineStart)
+					{
+						//  aarrrggh!!!!!   we'll only get here is someone has fed in a (probably) garbage string,
+						//		since it doesn't have a single space or punctuation mark right the way across one line
+						//		of the screen.  So far, this has only happened in testing when I hardwired a taiwanese 
+						//		string into this function while the game was running in english (which should NEVER happen 
+						//		normally).  On the other hand I suppose it'psCurrentTextReadPos entirely possible that some taiwanese string 
+						//		might have no punctuation at all, so...
+						//
+						psBestLineBreakSrcPos = psLastGood_s;	// force a break after last good letter
+					}
+
+					sLineForDisplay[ psBestLineBreakSrcPos - psReadPosAtLineStart ] = '\0';
+					psReadPosAtLineStart = psCurrentTextReadPos = psBestLineBreakSrcPos;
+					break;	// print this line
+				}
+			}
+
+			// record last-good linebreak pos...  (ie if we've just concat'd a punctuation point (western or asian) or space)
+			//
+			if (bIsTrailingPunctuation || uiLetter == ' ' || (uiLetter > 255 && !cgi_Language_UsesSpaces()))
+			{
+				psBestLineBreakSrcPos = psCurrentTextReadPos;
+			}
+		}
+
+		// ... and print it...
+		//
+		cgi_R_Font_DrawString(iBoxX, iYpos, sLineForDisplay, v4Color, iFontHandle, -1, fScale);
+		iYpos += iFontHeightAdvance;
+		giLinesOutput++;
+
+		// and echo to console in dev mode...
+		//
+		if ( cg_developer.integer )
+		{
+//			Com_Printf( "%psCurrentTextReadPos\n", sLineForDisplay );
+		}
+	}
+	return psReadPosAtLineStart;
+}
+
+
+
+/*
+===============================================================================
+
+CAPTION TEXT
+
+===============================================================================
+*/
+void CG_CaptionTextStop(void) 
+{
+	cg.captionTextTime = 0;
+}
+
+// try and get the correct StripEd text (with retry) for a given reference...
+//
+// returns 0 if failed, else strlen...
+//
+static int cg_SP_GetStringTextStringWithRetry( LPCSTR psReference, char *psDest, int iSizeofDest)
+{
+	int iReturn;
+
+	if (psReference[0] == '#')
+	{
+		// then we know the striped package name is already built in, so do NOT try prepending anything else...
+		//
+		return cgi_SP_GetStringTextString( va("%s",psReference+1), psDest, iSizeofDest );
+	}
+
+	for (int i=0; i<STRIPED_LEVELNAME_VARIATIONS; i++)
+	{
+		if (cgs.stripLevelName[i][0])	// entry present?
+		{
+			iReturn = cgi_SP_GetStringTextString( va("%s_%s",cgs.stripLevelName[i],psReference), psDest, iSizeofDest );
+			if (iReturn)
+			{
+				return iReturn;
+			}
+		}
+	}
+
+	return 0;
+}
+
+// slightly confusingly, the char arg for this function is an audio filename of the form "path/path/filename",
+//	the "filename" part of which should be the same as the StripEd reference we're looking for in the current 
+//	level's string package...
+//
+void CG_CaptionText( const char *str, int sound, int y ) 
+{
+	const char	*s, *holds;
+	int i;
+	int	holdTime;
+	char text[8192]={0};
+
+	const float fFontScale = cgi_Language_IsAsian() ? 0.8f : 1.0f;
+
+	holds = strrchr(str,'/');
+	if (!holds)
+	{
+#ifndef FINAL_BUILD
+		Com_Printf("WARNING: CG_CaptionText given audio filename with no '/':'%s'\n",str);
+#endif
+		return; 
+	}
+	i = cg_SP_GetStringTextStringWithRetry( holds+1, text, sizeof(text) );
+	//ensure we found a match
+	if (!i) 
+	{	
+#ifndef FINAL_BUILD
+		// we only care about some sound dirs...
+		if (!strnicmp(str,"sound/chars/",12))	// whichever language it is, it'll be pathed as english at this point
+		{
+			Com_Printf("WARNING: CG_CaptionText given invalid text key :'%s'\n",str);
+		}
+		else
+		{
+			// anything else is probably stuff we don't care about. It certainly shouldn't be speech, anyway
+		}
+#endif
+		return; 
+	}
+
+	const int fontHeight = (int) ((cgi_Language_IsAsian() ? 1.4f : 1.0f) * (float) cgi_R_Font_HeightPixels(cgs.media.qhFontMedium, fFontScale));	// taiwanese & japanese need 1.5 fontheight spacing
+
+	cg.captionTextTime = cg.time;
+	if (in_camera) {
+		cg.captionTextY = SCREEN_HEIGHT - (client_camera.bar_height_dest/2);	// ths is now a centre'd Y, not a start Y
+	} else {	//get above the hud
+		cg.captionTextY = (int) (0.88f * ((float)SCREEN_HEIGHT - (float)fontHeight * 1.5f));	// do NOT move this, it has to fit in between the weapon HUD and the datapad update.
+	}
+	cg.captionTextCurrentLine = 0;
+
+	// count the number of lines for centering
+	cg.scrollTextLines = 1;
+
+	memset (cg.captionText, 0, sizeof(cg.captionText));
+
+	// Break into individual lines
+	i = 0;	// this could be completely removed and replace by "cg.scrollTextLines-1", but wtf?
+
+	s=(const char*)&text;
+	// tai...
+//	s="Áɨô­ôº¸³Õ¤h¤w¸g¦w¥þ¤F¡A§Ú¤]§â©Ò¦³µo²{³ø§iµ¹¡u°Ó©±¡v¡C«Ü¤£©¯¦a¡A·ç¤hĵ§½¦³¨Ç¥Õèµo²{¤F¤@¨Çª¬ªp¡A·Ç³Æ¦b¾÷³õ¶e®·¨È¾ú¦è¡E¯Ç§J·ç±o¡C¥L°°¸Ë¦¨¥~¥æ¨Ï¸`¡A¬ï¹L¤F¼h¼h¨¾³Æ¡C²{¦b¥L´¤¦³¤H½è¡A¨Ã¥B«Â¯Ù­n´²¼½¯f¬r¡C®Ú¾Ú³Ì·sªº³ø§i¡A¯Ç§J·ç±o¥H¤Î¥LªºÄҦФw¸g§¹¥þ¦û¾Ú¤F¾÷³õ¡C§Ú¨ü©R¨Ó°l®·¯Ç§J·ç±o¥H¤Î±Ï¥X©Ò¦³¤H½è¡C³o¨Ã¤£®e©ö¡C";
+	// kor...
+//	s="Wp:¼îŸÀÓÀÌ´Ù ¸Ö¸°. ±×µéÀÌ ¸»ÇÑ´ë·Î ³×°¡ ÀßÇÒÁö ±â´ëÇÏ°Ú´Ù.¼îŸÀÓÀÌ´Ù ¸Ö¸°. ±×µéÀÌ ¸»ÇÑ´ë·Î ³×°¡ ÀßÇÒÁö ±â´ëÇÏ°Ú´Ù.";
+	holds = s;
+
+	int iPlayingTimeMS	= cgi_S_GetSampleLength(sound);
+	int iLengthInChars	= strlen(s);//cgi_R_Font_StrLenChars(s);	// strlen is also good for MBCS in this instance, since it's for timing
+	if (iLengthInChars == 0)
+	{
+		iLengthInChars = 1;
+	}
+	cg.captionLetterTime = iPlayingTimeMS / iLengthInChars;
+
+	const char *psBestLineBreakSrcPos = s;
+	const char *psLastGood_s;	// needed if we get a full screen of chars with no punctuation or space (see usage notes)
+	while( *s )
+	{
+		psLastGood_s = s;
+
+		// read letter...
+		//
+		qboolean bIsTrailingPunctuation;
+		int iAdvanceCount;
+		unsigned int uiLetter = cgi_AnyLanguage_ReadCharFromString(s, &iAdvanceCount, &bIsTrailingPunctuation);
+		s += iAdvanceCount;
+
+		// concat onto string so far...
+		//
+		if (uiLetter == 32 && cg.captionText[i][0] == '\0')
+		{
+			holds++;
+			continue;	// unless it's a space at the start of a line, in which case ignore it.
+		}
+
+		if (uiLetter > 255)
+		{
+			Q_strcat(cg.captionText[i],sizeof(cg.captionText[i]),va("%c%c",uiLetter >> 8, uiLetter & 0xFF));
+		}
+		else
+		{
+			Q_strcat(cg.captionText[i],sizeof(cg.captionText[i]),va("%c",uiLetter & 0xFF));
+		}
+
+		if (uiLetter == '\n')
+		{
+			// explicit new line...
+			//
+			cg.captionText[i][ strlen(cg.captionText[i])-1 ] = '\0';	// kill the CR
+			i++;
+			holds = s;
+			psBestLineBreakSrcPos = s;
+			cg.scrollTextLines++;
+		}
+		else 
+		if ( cgi_R_Font_StrLenPixels(cg.captionText[i], cgs.media.qhFontMedium, fFontScale) >= SCREEN_WIDTH)
+		{
+			// reached screen edge, so cap off string at bytepos after last good position...
+			//
+			if (uiLetter > 255 && bIsTrailingPunctuation && !cgi_Language_UsesSpaces())
+			{
+				// Special case, don't consider line breaking if you're on an asian punctuation char of
+				//	a language that doesn't use spaces...
+				//
+			}
+			else
+			{
+				if (psBestLineBreakSrcPos == holds)
+				{
+					//  aarrrggh!!!!!   we'll only get here is someone has fed in a (probably) garbage string,
+					//		since it doesn't have a single space or punctuation mark right the way across one line
+					//		of the screen.  So far, this has only happened in testing when I hardwired a taiwanese 
+					//		string into this function while the game was running in english (which should NEVER happen 
+					//		normally).  On the other hand I suppose it's entirely possible that some taiwanese string 
+					//		might have no punctuation at all, so...
+					//
+					psBestLineBreakSrcPos = psLastGood_s;	// force a break after last good letter
+				}
+
+				cg.captionText[i][ psBestLineBreakSrcPos - holds ] = '\0';
+				holds = s = psBestLineBreakSrcPos;
+				i++;
+				cg.scrollTextLines++;
+			}
+		}
+
+		// record last-good linebreak pos...  (ie if we've just concat'd a punctuation point (western or asian) or space)
+		//
+		if (bIsTrailingPunctuation || uiLetter == ' ' || (uiLetter > 255 && !cgi_Language_UsesSpaces()))
+		{
+			psBestLineBreakSrcPos = s;
+		}
+	}
+
+
+	// calc the length of time to hold each 2 lines of text on the screen.... presumably this works?
+	//
+	holdTime = strlen(cg.captionText[0]);
+	if (cg.scrollTextLines > 1)
+	{
+		holdTime += strlen(cg.captionText[1]);	// strlen is also good for MBCS in this instance, since it's for timing
+	}
+	cg.captionNextTextTime = cg.time + (holdTime * cg.captionLetterTime);	
+
+	cg.scrollTextTime = 0;	// No scrolling during captions
+
+	//Echo to console in dev mode
+	if ( cg_developer.integer )
+	{
+		Com_Printf( "%s\n", cg.captionText[0] );	// ste:  was [i], but surely sentence 0 is more useful than last?
+	}
+}
+
+
+void CG_DrawCaptionText(void)
+{
+	int		i;
+	int		x, y, w;
+	int	holdTime;
+
+	if ( !cg.captionTextTime ) 
+	{
+		return;
+	}
+
+	const float fFontScale = cgi_Language_IsAsian() ? 0.8f : 1.0f;
+
+	if (cg_skippingcin.integer != 0)
+	{
+		cg.captionTextTime = 0;
+		return;
+	}
+
+	if ( cg.captionNextTextTime < cg.time ) 
+	{
+		cg.captionTextCurrentLine += 2;
+
+		if (cg.captionTextCurrentLine >= cg.scrollTextLines)
+		{
+			cg.captionTextTime = 0;
+			return;
+		}
+		else
+		{
+			holdTime = strlen(cg.captionText[cg.captionTextCurrentLine]);
+			if (cg.scrollTextLines >= cg.captionTextCurrentLine)
+			{
+				// ( strlen is also good for MBCS in this instance, since it's for timing -ste)
+				//
+				holdTime += strlen(cg.captionText[cg.captionTextCurrentLine + 1]);
+			}
+
+			cg.captionNextTextTime = cg.time + (holdTime * cg.captionLetterTime);//50);
+		}
+	}
+
+	// Give a color if one wasn't given
+	if((textcolor_caption[0] == 0) && (textcolor_caption[1] == 0) && 
+		(textcolor_caption[2] == 0) && (textcolor_caption[3] == 0))
+	{
+		Vector4Copy( colorTable[CT_WHITE], textcolor_caption );
+	}
+
+	cgi_R_SetColor(textcolor_caption);
+
+	// Set Y of the first line (varies if only printing one line of text)
+	// (this all works, please don't mess with it)
+	const int fontHeight = (int) ((cgi_Language_IsAsian() ? 1.4f : 1.0f) * (float) cgi_R_Font_HeightPixels(cgs.media.qhFontMedium, fFontScale));
+	const bool bPrinting2Lines = !!(cg.captionText[ cg.captionTextCurrentLine+1 ][0]);
+	y = cg.captionTextY - ( (float)fontHeight * (bPrinting2Lines ? 1 : 0.5f));	// captionTextY was a centered Y pos, not a top one
+	y -= cgi_Language_IsAsian() ? 0 : 4;
+
+	for (i=	cg.captionTextCurrentLine;i< cg.captionTextCurrentLine + 2;++i)
+	{
+		w = cgi_R_Font_StrLenPixels(cg.captionText[i], cgs.media.qhFontMedium, fFontScale);	
+		if (w)
+		{
+			x = (SCREEN_WIDTH-w) / 2;
+			cgi_R_Font_DrawString(x, y, cg.captionText[i], textcolor_caption, cgs.media.qhFontMedium, -1, fFontScale);
+			y += fontHeight;
+		}
+	}
+
+	cgi_R_SetColor( NULL );
+}
+
+/*
+===============================================================================
+
+SCROLL TEXT
+
+===============================================================================
+
+CG_ScrollText - split text up into seperate lines
+
+ 'str' arg is StripEd string reference, eg "CREDITS_RAVEN"
+
+*/
+int giScrollTextPixelWidth = SCREEN_WIDTH;
+void CG_ScrollText( const char *str, int iPixelWidth )
+{
+	const char	*s,*holds;
+	int i;//, len;//, numChars;
+
+	giScrollTextPixelWidth = iPixelWidth;
+
+	// first, ask the strlen of the final string...
+	//	
+	i = cgi_SP_GetStringTextString( str, NULL, 0 );
+
+	//ensure we found a match
+	if (!i)
+	{
+#ifndef FINAL_BUILD
+		Com_Printf("WARNING: CG_ScrollText given invalid text key :'%s'\n",str);
+#endif
+		return; 
+	}
+	//
+	// malloc space to hold it...
+	//
+	char *psText = (char *) cgi_Z_Malloc( i+1, TAG_TEMP_WORKSPACE );
+	//
+	// now get the string...
+	//	
+	i = cgi_SP_GetStringTextString( str, psText, i+1 );
+	//ensure we found a match
+	if (!i)
+	{
+		assert(0);	// should never get here now, but wtf?
+		cgi_Z_Free(psText);
+#ifndef FINAL_BUILD
+		Com_Printf("WARNING: CG_ScrollText given invalid text key :'%s'\n",str);
+#endif
+		return; 
+	}
+
+	cg.scrollTextTime = cg.time;
+	cg.printTextY = SCREEN_HEIGHT;
+	cg.scrollTextLines = 1;
+	
+	s = psText;
+	i = 0;
+	holds = s;
+
+	const char *psBestLineBreakSrcPos = s;
+	const char *psLastGood_s;	// needed if we get a full screen of chars with no punctuation or space (see usage notes)
+	while( *s )
+	{
+		psLastGood_s = s;
+
+		// read letter...
+		//
+		qboolean bIsTrailingPunctuation;
+		int iAdvanceCount;
+		unsigned int uiLetter = cgi_AnyLanguage_ReadCharFromString(s, &iAdvanceCount, &bIsTrailingPunctuation);
+		s += iAdvanceCount;
+
+		// concat onto string so far...
+		//
+		if (uiLetter == 32 && cg.printText[i][0] == '\0')
+		{
+			holds++;
+			continue;	// unless it's a space at the start of a line, in which case ignore it.
+		}
+
+		if (uiLetter > 255)
+		{
+			Q_strcat(cg.printText[i],sizeof(cg.printText[i]),va("%c%c",uiLetter >> 8, uiLetter & 0xFF));
+		}
+		else
+		{
+			Q_strcat(cg.printText[i],sizeof(cg.printText[i]),va("%c",uiLetter & 0xFF));
+		}
+
+		// record last-good linebreak pos...  (ie if we've just concat'd a punctuation point (western or asian) or space)
+		//
+		if (bIsTrailingPunctuation || uiLetter == ' ')
+		{
+			psBestLineBreakSrcPos = s;
+		}
+
+		if (uiLetter == '\n')
+		{
+			// explicit new line...
+			//
+			cg.printText[i][ strlen(cg.printText[i])-1 ] = '\0';	// kill the CR
+			i++;
+			assert (i < (sizeof(cg.printText)/sizeof(cg.printText[0])) );
+			if (i >= (sizeof(cg.printText)/sizeof(cg.printText[0])) )
+			{
+				break;
+			}
+			holds = s;
+			cg.scrollTextLines++;
+		}
+		else 
+		if ( cgi_R_Font_StrLenPixels(cg.printText[i], cgs.media.qhFontMedium, 1.0f) >= iPixelWidth)
+		{
+			// reached screen edge, so cap off string at bytepos after last good position...
+			//
+			if (psBestLineBreakSrcPos == holds)
+			{
+				//  aarrrggh!!!!!   we'll only get here is someone has fed in a (probably) garbage string,
+				//		since it doesn't have a single space or punctuation mark right the way across one line
+				//		of the screen.  So far, this has only happened in testing when I hardwired a taiwanese 
+				//		string into this function while the game was running in english (which should NEVER happen 
+				//		normally).  On the other hand I suppose it's entirely possible that some taiwanese string 
+				//		might have no punctuation at all, so...
+				//
+				psBestLineBreakSrcPos = psLastGood_s;	// force a break after last good letter
+			}
+
+			cg.printText[i][ psBestLineBreakSrcPos - holds ] = '\0';
+			holds = s = psBestLineBreakSrcPos;
+			i++;
+			assert (i < (sizeof(cg.printText)/sizeof(cg.printText[0])) );
+			cg.scrollTextLines++;
+		}
+	}
+
+	cg.captionTextTime = 0;		// No captions during scrolling
+	cgi_Z_Free(psText);
+}
+
+
+// draws using [textcolor_scroll]...
+//
+#define SCROLL_LPM (1/50.0) // 1 line per 50 ms
+void CG_DrawScrollText(void)
+{		
+	char	*start;
+	int		i;
+	int		x,y;	
+	const int fontHeight = (int) (1.5f * (float) cgi_R_Font_HeightPixels(cgs.media.qhFontMedium, 1.0f));	// taiwanese & japanese need 1.5 fontheight spacing
+
+	if ( !cg.scrollTextTime ) 
+	{
+		return;
+	}
+
+	cgi_R_SetColor( textcolor_scroll );
+
+	y = cg.printTextY - (cg.time - cg.scrollTextTime) * SCROLL_LPM;
+
+//	cgi_R_Font_DrawString(320, 200, va("Scrolltext printing @ %d",y), colorTable[CT_LTGOLD1], cgs.media.qhFontMedium, -1, 1.0f);
+
+	// See if text has finished scrolling off screen
+	if ((y + cg.scrollTextLines * fontHeight) < 1)
+	{
+		cg.scrollTextTime = 0;
+		return;
+	}
+
+	for (i=0;i<cg.scrollTextLines;++i)
+	{
+
+		// Is this line off top of screen?
+		if ((y + ((i +1) * fontHeight)) < 1)
+		{
+			y += fontHeight;
+			continue;
+		}
+		// or past bottom of screen?
+		else if (y > SCREEN_HEIGHT)
+		{
+			break;
+		}
+
+		start = cg.printText[i];
+
+//		w = cgi_R_Font_StrLenPixels(cg.printText[i], cgs.media.qhFontMedium, 1.0f);	
+//		if (w)
+		{
+			x = (SCREEN_WIDTH - giScrollTextPixelWidth) / 2;
+			cgi_R_Font_DrawString(x,y, cg.printText[i], textcolor_scroll, cgs.media.qhFontMedium, -1, 1.0f);
+			y += fontHeight;
+		}		
+	}
+
+	cgi_R_SetColor( NULL );
+}
+
+
+/*
+===============================================================================
+
+CENTER PRINTING
+
+===============================================================================
+*/
+
+
+/*
+==============
+CG_CenterPrint
+
+Called for important messages that should stay in the center of the screen
+for a few moments
+==============
+*/
+void CG_CenterPrint( const char *str, int y) {
+	char	*s;
+	
+	// Find text to match the str given
+	if (*str == '@')
+	{
+		int i;
+
+		i = cgi_SP_GetStringTextString( str+1, cg.centerPrint, sizeof(cg.centerPrint) );
+
+		if (!i)
+		{
+			Com_Printf (S_COLOR_RED"CG_CenterPrint: cannot find reference '%s' in StringPackage!\n",str);	
+			Q_strncpyz( cg.centerPrint, str, sizeof(cg.centerPrint) );
+		}
+	}
+	else
+	{
+		Q_strncpyz( cg.centerPrint, str, sizeof(cg.centerPrint) );
+	}
+
+	cg.centerPrintTime = cg.time;
+	cg.centerPrintY = y;
+
+	// count the number of lines for centering
+	cg.centerPrintLines = 1;
+	s = cg.centerPrint;
+	while( *s ) {
+		if (*s == '\n')
+			cg.centerPrintLines++;
+		s++;
+	}
+
+}
+
+
+/*
+===================
+CG_DrawCenterString
+===================
+*/
+void CG_DrawCenterString( void ) 
+{
+	char	*start;
+	int		l;
+	int		x, y, w;
+	float	*color;
+
+	if ( !cg.centerPrintTime ) {
+		return;
+	}
+
+	color = CG_FadeColor( cg.centerPrintTime, 1000 * 3 );
+	if ( !color ) {
+		return;
+	}
+
+	if((textcolor_center[0] == 0) && (textcolor_center[1] == 0) && 
+		(textcolor_center[2] == 0) && (textcolor_center[3] == 0))
+	{
+		Vector4Copy( colorTable[CT_WHITE], textcolor_center );
+	}
+
+	start = cg.centerPrint;
+
+	const int fontHeight = cgi_R_Font_HeightPixels(cgs.media.qhFontMedium, 1.0f);
+	y = cg.centerPrintY - (cg.centerPrintLines * fontHeight) / 2;
+
+	while ( 1 ) {
+		char linebuffer[1024];
+
+		// this is kind of unpleasant when dealing with MBCS, but...
+		//		
+		const char *psString = start;
+		int iOutIndex = 0;
+		for ( l = 0; l < sizeof(linebuffer)-1; l++ ) {
+			int iAdvanceCount;
+			unsigned int uiLetter = cgi_AnyLanguage_ReadCharFromString(psString, &iAdvanceCount);
+			psString += iAdvanceCount;
+			if (!uiLetter || uiLetter == '\n'){
+				break;
+			}
+			if (uiLetter > 255)
+			{
+				linebuffer[iOutIndex++] = uiLetter >> 8;
+				linebuffer[iOutIndex++] = uiLetter & 0xFF;
+			}
+			else
+			{
+				linebuffer[iOutIndex++] = uiLetter & 0xFF;
+			}
+		}
+		linebuffer[iOutIndex++] = '\0';
+
+		w = cgi_R_Font_StrLenPixels(linebuffer, cgs.media.qhFontMedium, 1.0f);	
+
+		x = ( SCREEN_WIDTH - w ) / 2;
+
+		cgi_R_Font_DrawString(x,y,linebuffer, textcolor_center, cgs.media.qhFontMedium, -1, 1.0f);
+
+		y += fontHeight;
+
+		while ( *start && ( *start != '\n' ) ) {
+			start++;
+		}
+		if ( !*start ) {
+			break;
+		}
+		start++;
+	}
+
+}
diff --git a/code/cgame/cg_view.cpp b/code/cgame/cg_view.cpp
new file mode 100644
index 0000000..fb9090f
--- /dev/null
+++ b/code/cgame/cg_view.cpp
@@ -0,0 +1,2249 @@
+ // cg_view.c -- setup all the parameters (position, angle, etc)
+// for a 3D rendering
+
+// this line must stay at top so the whole PCH thing works...
+#include "cg_headers.h"
+
+//#include "cg_local.h"
+#include "cg_media.h"
+#include "FxScheduler.h"
+#include "cg_lights.h"
+#include "..\game\wp_saber.h"
+#include "..\game\g_vehicles.h"
+
+#define MASK_CAMERACLIP (MASK_SOLID)
+#define CAMERA_SIZE	4
+
+float cg_zoomFov;
+
+//#define CG_CAM_ABOVE	2
+extern qboolean CG_OnMovingPlat( playerState_t *ps );
+extern Vehicle_t *G_IsRidingVehicle( gentity_t *ent );
+
+extern int g_crosshairSameEntTime;
+extern int g_crosshairEntNum;
+
+/*
+=============================================================================
+
+  MODEL TESTING
+
+The viewthing and gun positioning tools from Q2 have been integrated and
+enhanced into a single model testing facility.
+
+Model viewing can begin with either "testmodel <modelname>" or "testgun <modelname>".
+
+The names must be the full pathname after the basedir, like 
+"models/weapons/v_launch/tris.md3" or "players/male/tris.md3"
+
+Testmodel will create a fake entity 100 units in front of the current view
+position, directly facing the viewer.  It will remain immobile, so you can
+move around it to view it from different angles.
+
+Testgun will cause the model to follow the player around and supress the real
+view weapon model.  The default frame 0 of most guns is completely off screen,
+so you will probably have to cycle a couple frames to see it.
+
+"nextframe", "prevframe", "nextskin", and "prevskin" commands will change the
+frame or skin of the testmodel.  These are bound to F5, F6, F7, and F8 in
+q3default.cfg.
+
+If a gun is being tested, the "gun_x", "gun_y", and "gun_z" variables will let
+you adjust the positioning.
+
+Note that none of the model testing features update while the game is paused, so
+it may be convenient to test with deathmatch set to 1 so that bringing down the
+console doesn't pause the game.
+
+=============================================================================
+*/
+
+/*
+Ghoul2 Insert Start
+*/
+
+/*
+=================
+CG_TestModel_f
+
+Creates an entity in front of the current position, which
+can then be moved around
+=================
+*/
+void CG_TestG2Model_f (void) {
+	vec3_t		angles;
+	CGhoul2Info_v *ghoul2;
+
+	memset( &cg.testModelEntity, 0, sizeof(cg.testModelEntity) );
+	ghoul2 = new CGhoul2Info_v;
+	cg.testModelEntity.ghoul2 = ghoul2;
+	if ( cgi_Argc() < 2 ) {
+		return;
+	}
+
+	Q_strncpyz (cg.testModelName, CG_Argv( 1 ), MAX_QPATH );
+	cg.testModelEntity.hModel = cgi_R_RegisterModel( cg.testModelName );
+
+	cg.testModel = gi.G2API_InitGhoul2Model(*((CGhoul2Info_v *)cg.testModelEntity.ghoul2), cg.testModelName, cg.testModelEntity.hModel, NULL, NULL,0);
+	cg.testModelEntity.radius = 100.0f;
+
+	if ( cgi_Argc() == 3 ) {
+		cg.testModelEntity.backlerp = atof( CG_Argv( 2 ) );
+		cg.testModelEntity.frame = 1;
+		cg.testModelEntity.oldframe = 0;
+	}
+	if (! cg.testModelEntity.hModel ) {
+		CG_Printf( "Can't register model\n" );
+		return;
+	}
+
+	VectorMA( cg.refdef.vieworg, 100, cg.refdef.viewaxis[0], cg.testModelEntity.origin );
+
+	angles[PITCH] = 0;
+	angles[YAW] = 180 + cg.refdefViewAngles[1];
+	angles[ROLL] = 0;
+
+	AnglesToAxis( angles, cg.testModelEntity.axis );
+}
+
+void CG_ListModelSurfaces_f (void)
+{
+	CGhoul2Info_v	&ghoul2 = *((CGhoul2Info_v *)cg.testModelEntity.ghoul2);
+
+ 	gi.G2API_ListSurfaces(&ghoul2[cg.testModel]);
+}
+
+
+void CG_ListModelBones_f (void)
+{
+  	// test to see if we got enough args
+	if ( cgi_Argc() < 2 ) 
+	{
+		return;
+	}
+	CGhoul2Info_v	&ghoul2 = *((CGhoul2Info_v *)cg.testModelEntity.ghoul2);
+
+	gi.G2API_ListBones(&ghoul2[cg.testModel], atoi(CG_Argv(1)));
+}
+
+void CG_TestModelSurfaceOnOff_f(void)
+{
+	// test to see if we got enough args
+	if ( cgi_Argc() < 3 ) 
+	{
+		return;
+	}
+	CGhoul2Info_v	&ghoul2 = *((CGhoul2Info_v *)cg.testModelEntity.ghoul2);
+
+	gi.G2API_SetSurfaceOnOff(&ghoul2[cg.testModel], CG_Argv(1), atoi(CG_Argv(2)));
+}
+
+void CG_TestModelSetAnglespre_f(void)
+{
+	vec3_t	angles;
+
+	if ( cgi_Argc() < 3 ) 
+	{
+		return;
+	}
+	CGhoul2Info_v	&ghoul2 = *((CGhoul2Info_v *)cg.testModelEntity.ghoul2);
+
+	angles[0] = atof(CG_Argv(2)); 
+	angles[1] = atof(CG_Argv(3)); 
+	angles[2] = atof(CG_Argv(4));
+	gi.G2API_SetBoneAngles(&ghoul2[cg.testModel], CG_Argv(1), angles, BONE_ANGLES_PREMULT, POSITIVE_X, POSITIVE_Z, POSITIVE_Y, NULL);
+}
+
+void CG_TestModelSetAnglespost_f(void)
+{
+	vec3_t	angles;
+
+	if ( cgi_Argc() < 3 ) 
+	{
+		return;
+	}
+	CGhoul2Info_v	&ghoul2 = *((CGhoul2Info_v *)cg.testModelEntity.ghoul2);
+
+	angles[0] = atof(CG_Argv(2)); 
+	angles[1] = atof(CG_Argv(3)); 
+	angles[2] = atof(CG_Argv(4));
+	gi.G2API_SetBoneAngles(&ghoul2[cg.testModel], CG_Argv(1), angles, BONE_ANGLES_POSTMULT, POSITIVE_X, POSITIVE_Z, POSITIVE_Y, NULL);
+}
+
+void CG_TestModelAnimate_f(void)
+{
+	char	boneName[100];
+	CGhoul2Info_v	&ghoul2 = *((CGhoul2Info_v *)cg.testModelEntity.ghoul2);
+
+	strcpy(boneName, CG_Argv(1));
+	gi.G2API_SetBoneAnim(&ghoul2[cg.testModel], boneName, atoi(CG_Argv(2)), atoi(CG_Argv(3)), BONE_ANIM_OVERRIDE_LOOP, atof(CG_Argv(4)), cg.time);
+
+}
+
+/*
+Ghoul2 Insert End
+*/
+
+
+/*
+=================
+CG_TestModel_f
+
+Creates an entity in front of the current position, which
+can then be moved around
+=================
+*/
+void CG_TestModel_f (void) {
+	vec3_t		angles;
+
+	memset( &cg.testModelEntity, 0, sizeof(cg.testModelEntity) );
+	if ( cgi_Argc() < 2 ) {
+		return;
+	}
+
+	Q_strncpyz (cg.testModelName, CG_Argv( 1 ), MAX_QPATH );
+	cg.testModelEntity.hModel = cgi_R_RegisterModel( cg.testModelName );
+
+	if ( cgi_Argc() == 3 ) {
+		cg.testModelEntity.backlerp = atof( CG_Argv( 2 ) );
+		cg.testModelEntity.frame = 1;
+		cg.testModelEntity.oldframe = 0;
+	}
+	if (! cg.testModelEntity.hModel ) {
+		CG_Printf( "Can't register model\n" );
+		return;
+	}
+
+	VectorMA( cg.refdef.vieworg, 100, cg.refdef.viewaxis[0], cg.testModelEntity.origin );
+
+	angles[PITCH] = 0;
+	angles[YAW] = 180 + cg.refdefViewAngles[1];
+	angles[ROLL] = 0;
+
+	AnglesToAxis( angles, cg.testModelEntity.axis );
+}
+
+
+void CG_TestModelNextFrame_f (void) {
+	cg.testModelEntity.frame++;
+	CG_Printf( "frame %i\n", cg.testModelEntity.frame );
+}
+
+void CG_TestModelPrevFrame_f (void) {
+	cg.testModelEntity.frame--;
+	if ( cg.testModelEntity.frame < 0 ) {
+		cg.testModelEntity.frame = 0;
+	}
+	CG_Printf( "frame %i\n", cg.testModelEntity.frame );
+}
+
+void CG_TestModelNextSkin_f (void) {
+	cg.testModelEntity.skinNum++;
+	CG_Printf( "skin %i\n", cg.testModelEntity.skinNum );
+}
+
+void CG_TestModelPrevSkin_f (void) {
+	cg.testModelEntity.skinNum--;
+	if ( cg.testModelEntity.skinNum < 0 ) {
+		cg.testModelEntity.skinNum = 0;
+	}
+	CG_Printf( "skin %i\n", cg.testModelEntity.skinNum );
+}
+
+static void CG_AddTestModel (void) {
+	// re-register the model, because the level may have changed	
+/*	cg.testModelEntity.hModel = cgi_R_RegisterModel( cg.testModelName );
+	if (! cg.testModelEntity.hModel ) {
+		CG_Printf ("Can't register model\n");
+		return;
+	}
+*/
+	cgi_R_AddRefEntityToScene( &cg.testModelEntity );
+}
+
+
+
+//============================================================================
+
+
+/*
+=================
+CG_CalcVrect
+
+Sets the coordinates of the rendered window
+=================
+*/
+void CG_CalcVrect (void) {
+	const int		size = 100;
+
+	cg.refdef.width = cgs.glconfig.vidWidth * size * 0.01;
+	cg.refdef.width &= ~1;
+
+	cg.refdef.height = cgs.glconfig.vidHeight * size * 0.01;
+	cg.refdef.height &= ~1;
+
+	cg.refdef.x = (cgs.glconfig.vidWidth - cg.refdef.width) * 0.5;
+	cg.refdef.y = (cgs.glconfig.vidHeight - cg.refdef.height) * 0.5;
+}
+
+//==============================================================================
+//==============================================================================
+#define CAMERA_DAMP_INTERVAL	50
+
+#define CAMERA_CROUCH_NUDGE		6
+
+static vec3_t	cameramins = { -CAMERA_SIZE, -CAMERA_SIZE, -CAMERA_SIZE };
+static vec3_t	cameramaxs = { CAMERA_SIZE, CAMERA_SIZE, CAMERA_SIZE };
+vec3_t	camerafwd, cameraup, camerahorizdir;
+
+vec3_t	cameraFocusAngles,			cameraFocusLoc;
+vec3_t	cameraIdealTarget,			cameraIdealLoc;
+vec3_t	cameraCurTarget={0,0,0},	cameraCurLoc={0,0,0};
+vec3_t	cameraOldLoc={0,0,0},		cameraNewLoc={0,0,0};
+int		cameraLastFrame=0;
+
+float	cameraLastYaw=0;
+float	cameraStiffFactor=0.0f;
+
+/*
+===============
+Notes on the camera viewpoint in and out...
+
+cg.refdef.vieworg
+--at the start of the function holds the player actor's origin (center of player model).
+--it is set to the final view location of the camera at the end of the camera code.
+cg.refdefViewAngles
+--at the start holds the client's view angles
+--it is set to the final view angle of the camera at the end of the camera code.
+
+===============
+*/
+  
+/*
+===============
+CG_CalcIdealThirdPersonViewTarget
+
+===============
+*/
+static void CG_CalcIdealThirdPersonViewTarget(void)
+{
+	// Initialize IdealTarget
+	VectorCopy(cg.refdef.vieworg, cameraFocusLoc);
+
+	if ( cg.snap->ps.viewEntity > 0 && cg.snap->ps.viewEntity < ENTITYNUM_WORLD )
+	{
+		gentity_t *gent = &g_entities[cg.snap->ps.viewEntity];
+		if ( gent->client && (gent->client->NPC_class != CLASS_GONK ) 
+			&& (gent->client->NPC_class != CLASS_INTERROGATOR) 
+			&& (gent->client->NPC_class != CLASS_SENTRY) 
+			&& (gent->client->NPC_class != CLASS_PROBE ) 
+			&& (gent->client->NPC_class != CLASS_MOUSE ) 
+			&& (gent->client->NPC_class != CLASS_R2D2 ) 
+			&& (gent->client->NPC_class != CLASS_R5D2) )
+		{//use the NPC's viewheight
+			cameraFocusLoc[2] += gent->client->ps.viewheight;
+		}
+		else
+		{//droids use a generic offset
+			cameraFocusLoc[2] += 4;
+		}
+		VectorCopy( cameraFocusLoc,  cameraIdealTarget );
+	}
+	else 
+	{
+		// Add in the new viewheight
+		cameraFocusLoc[2] += cg.predicted_player_state.viewheight;
+		if ( cg.snap 
+			&& (cg.snap->ps.eFlags&EF_HELD_BY_SAND_CREATURE) )
+		{
+			VectorCopy( cameraFocusLoc, cameraIdealTarget );
+			cameraIdealTarget[2] += 192;
+		}
+		else if ( cg.snap 
+			&& (cg.snap->ps.eFlags&EF_HELD_BY_WAMPA) )
+		{
+			VectorCopy( cameraFocusLoc, cameraIdealTarget );
+			cameraIdealTarget[2] -= 48;
+		}
+		else if ( cg.overrides.active & CG_OVERRIDE_3RD_PERSON_VOF )
+		{
+			// Add in a vertical offset from the viewpoint, which puts the actual target above the head, regardless of angle.
+			VectorCopy( cameraFocusLoc, cameraIdealTarget );
+			cameraIdealTarget[2] += cg.overrides.thirdPersonVertOffset;
+			//VectorMA(cameraFocusLoc, cg.overrides.thirdPersonVertOffset, cameraup, cameraIdealTarget);
+		}
+		else
+		{
+			// Add in a vertical offset from the viewpoint, which puts the actual target above the head, regardless of angle.
+			VectorCopy( cameraFocusLoc, cameraIdealTarget );
+			cameraIdealTarget[2] += cg_thirdPersonVertOffset.value;
+			//VectorMA(cameraFocusLoc, cg_thirdPersonVertOffset.value, cameraup, cameraIdealTarget);
+		}
+
+		// Now, if the player is crouching, do a little special tweak.  The problem is that the player's head is way out of his bbox.
+		if (cg.predicted_player_state.pm_flags & PMF_DUCKED)
+		{ // Nudge to focus location up a tad.
+			vec3_t nudgepos;
+			trace_t trace;
+
+			VectorCopy(cameraFocusLoc, nudgepos);
+			nudgepos[2]+=CAMERA_CROUCH_NUDGE;
+			CG_Trace(&trace, cameraFocusLoc, cameramins, cameramaxs, nudgepos, cg.predicted_player_state.clientNum, MASK_CAMERACLIP);
+			if (trace.fraction < 1.0)
+			{
+				VectorCopy(trace.endpos, cameraFocusLoc);
+			}
+			else
+			{
+				VectorCopy(nudgepos, cameraFocusLoc);
+			}
+		}
+	}
+}
+
+	
+
+/*
+===============
+CG_CalcIdealThirdPersonViewLocation
+
+===============
+*/
+static void CG_CalcIdealThirdPersonViewLocation(void)
+{
+	if ( cg.overrides.active & CG_OVERRIDE_3RD_PERSON_RNG )
+	{
+		VectorMA(cameraIdealTarget, -(cg.overrides.thirdPersonRange), camerafwd, cameraIdealLoc);
+	}
+	else if ( cg.snap 
+		&& (cg.snap->ps.eFlags&EF_HELD_BY_RANCOR)
+		&& cg_entities[cg.snap->ps.clientNum].gent->activator )
+	{//stay back
+		VectorMA(cameraIdealTarget, -180.0f*cg_entities[cg.snap->ps.clientNum].gent->activator->s.modelScale[0], camerafwd, cameraIdealLoc);
+	}
+	else if ( cg.snap 
+		&& (cg.snap->ps.eFlags&EF_HELD_BY_WAMPA)
+		&& cg_entities[cg.snap->ps.clientNum].gent->activator
+		&& cg_entities[cg.snap->ps.clientNum].gent->activator->inuse )
+	{//stay back
+		VectorMA(cameraIdealTarget, -120.0f*cg_entities[cg.snap->ps.clientNum].gent->activator->s.modelScale[0], camerafwd, cameraIdealLoc);
+	}
+	else if ( cg.snap 
+		&& (cg.snap->ps.eFlags&EF_HELD_BY_SAND_CREATURE)
+		&& cg_entities[cg.snap->ps.clientNum].gent->activator )
+	{//stay back
+		VectorMA(cg_entities[cg_entities[cg.snap->ps.clientNum].gent->activator->s.number].lerpOrigin, -180.0f, camerafwd, cameraIdealLoc);
+	}
+	else
+	{
+		VectorMA(cameraIdealTarget, -(cg_thirdPersonRange.value), camerafwd, cameraIdealLoc);
+	}
+	
+	if ( cg.renderingThirdPerson && (cg.snap->ps.forcePowersActive&(1<<FP_SPEED)) && player->client->ps.forcePowerDuration[FP_SPEED] )
+	{
+		float timeLeft = player->client->ps.forcePowerDuration[FP_SPEED] - cg.time;
+		float length = FORCE_SPEED_DURATION*forceSpeedValue[player->client->ps.forcePowerLevel[FP_SPEED]];
+		float amt = forceSpeedRangeMod[player->client->ps.forcePowerLevel[FP_SPEED]];
+		if ( timeLeft < 500 )
+		{//start going back
+			VectorMA(cameraIdealLoc, (timeLeft)/500*amt, camerafwd, cameraIdealLoc);
+		}
+		else if ( length - timeLeft < 1000 )
+		{//start zooming in
+			VectorMA(cameraIdealLoc, (length - timeLeft)/1000*amt, camerafwd, cameraIdealLoc);
+		}
+		else
+		{
+			VectorMA(cameraIdealLoc, amt, camerafwd, cameraIdealLoc);
+		}
+	}
+}
+
+
+
+static void CG_ResetThirdPersonViewDamp(void)
+{
+	trace_t trace;
+
+	// Cap the pitch within reasonable limits
+	if (cameraFocusAngles[PITCH] > 89.0)
+	{
+		cameraFocusAngles[PITCH] = 89.0;
+	}
+	else if (cameraFocusAngles[PITCH] < -89.0)
+	{
+		cameraFocusAngles[PITCH] = -89.0;
+	}
+
+	AngleVectors(cameraFocusAngles, camerafwd, NULL, cameraup);
+
+	// Set the cameraIdealTarget
+	CG_CalcIdealThirdPersonViewTarget();
+
+	// Set the cameraIdealLoc
+	CG_CalcIdealThirdPersonViewLocation();
+
+	// Now, we just set everything to the new positions.
+	VectorCopy(cameraIdealLoc, cameraCurLoc);
+	VectorCopy(cameraIdealTarget, cameraCurTarget);
+
+	// First thing we do is trace from the first person viewpoint out to the new target location.
+	CG_Trace(&trace, cameraFocusLoc, cameramins, cameramaxs, cameraCurTarget, cg.predicted_player_state.clientNum, MASK_CAMERACLIP);
+	if (trace.fraction <= 1.0)
+	{
+		VectorCopy(trace.endpos, cameraCurTarget);
+	}
+
+	// Now we trace from the new target location to the new view location, to make sure there is nothing in the way.
+	CG_Trace(&trace, cameraCurTarget, cameramins, cameramaxs, cameraCurLoc, cg.predicted_player_state.clientNum, MASK_CAMERACLIP);
+	if (trace.fraction <= 1.0)
+	{
+		VectorCopy(trace.endpos, cameraCurLoc);
+	}
+
+	cameraLastFrame = cg.time;
+	cameraLastYaw = cameraFocusAngles[YAW];
+	cameraStiffFactor = 0.0f;
+}
+
+// This is called every frame.
+static void CG_UpdateThirdPersonTargetDamp(void)
+{
+	trace_t trace;
+	vec3_t	targetdiff;
+	float	dampfactor, dtime, ratio;
+
+	// Set the cameraIdealTarget
+	// Automatically get the ideal target, to avoid jittering.
+	CG_CalcIdealThirdPersonViewTarget();
+
+	if ( CG_OnMovingPlat( &cg.snap->ps ) )
+	{//if moving on a plat, camera is *tight*
+		VectorCopy(cameraIdealTarget, cameraCurTarget);
+	}
+	else if (cg_thirdPersonTargetDamp.value>=1.0)//||cg.thisFrameTeleport)
+	{	// No damping.
+		VectorCopy(cameraIdealTarget, cameraCurTarget);
+	}
+	else if (cg_thirdPersonTargetDamp.value>=0.0)
+	{	
+		// Calculate the difference from the current position to the new one.
+		VectorSubtract(cameraIdealTarget, cameraCurTarget, targetdiff);
+
+		// Now we calculate how much of the difference we cover in the time allotted.
+		// The equation is (Damp)^(time)
+		dampfactor = 1.0-cg_thirdPersonTargetDamp.value;	// We must exponent the amount LEFT rather than the amount bled off
+		dtime = (float)(cg.time-cameraLastFrame) * (1.0/cg_timescale.value) * (1.0/(float)CAMERA_DAMP_INTERVAL);	// Our dampfactor is geared towards a time interval equal to "1".
+
+		// Note that since there are a finite number of "practical" delta millisecond values possible, 
+		// the ratio should be initialized into a chart ultimately.
+		ratio = pow(dampfactor, dtime);
+		
+		// This value is how much distance is "left" from the ideal.
+		VectorMA(cameraIdealTarget, -ratio, targetdiff, cameraCurTarget);
+		/////////////////////////////////////////////////////////////////////////////////////////////////////////
+	}
+
+	// Now we trace to see if the new location is cool or not.
+
+	// First thing we do is trace from the first person viewpoint out to the new target location.
+	if ( cg.snap
+		&& (cg.snap->ps.eFlags&EF_HELD_BY_SAND_CREATURE) 
+		&& cg_entities[cg.snap->ps.clientNum].gent->activator )
+	{//if being held by a sand creature, trace from his actual origin, since we could be underground or otherwise in solid once he eats us
+		CG_Trace(&trace, cg_entities[cg_entities[cg.snap->ps.clientNum].gent->activator->s.number].lerpOrigin, cameramins, cameramaxs, cameraCurTarget, cg.predicted_player_state.clientNum, MASK_CAMERACLIP);
+	}
+	else
+	{
+		CG_Trace(&trace, cameraFocusLoc, cameramins, cameramaxs, cameraCurTarget, cg.predicted_player_state.clientNum, MASK_CAMERACLIP);
+	}
+	if (trace.fraction < 1.0)
+	{
+		VectorCopy(trace.endpos, cameraCurTarget);
+	}
+
+	// Note that previously there was an upper limit to the number of physics traces that are done through the world
+	// for the sake of camera collision, since it wasn't calced per frame.  Now it is calculated every frame.
+	// This has the benefit that the camera is a lot smoother now (before it lerped between tested points),
+	// however two full volume traces each frame is a bit scary to think about.
+}
+
+// This can be called every interval, at the user's discretion.
+static int camWaterAdjust = 0;
+static void CG_UpdateThirdPersonCameraDamp(void)
+{
+	trace_t trace;
+	vec3_t	locdiff;
+	float dampfactor, dtime, ratio;
+
+	// Set the cameraIdealLoc
+	CG_CalcIdealThirdPersonViewLocation();
+	
+	
+	// First thing we do is calculate the appropriate damping factor for the camera.
+	dampfactor=0.0f;
+	if ( CG_OnMovingPlat( &cg.snap->ps ) )
+	{//if moving on a plat, camera is *tight*
+		dampfactor=1.0f;
+	}
+	else if ( cg.overrides.active & CG_OVERRIDE_3RD_PERSON_CDP )
+	{
+		if ( cg.overrides.thirdPersonCameraDamp != 0.0f )
+		{
+			float pitch;
+
+			// Note that the camera pitch has already been capped off to 89.
+			pitch = Q_fabs(cameraFocusAngles[PITCH]);
+
+			// The higher the pitch, the larger the factor, so as you look up, it damps a lot less.
+			pitch /=115.0f;	
+			dampfactor = (1.0-cg.overrides.thirdPersonCameraDamp)*(pitch*pitch);
+
+			dampfactor += cg.overrides.thirdPersonCameraDamp;
+		}
+	}
+	else if ( cg_thirdPersonCameraDamp.value != 0.0f )
+	{
+		float pitch;
+
+		// Note that the camera pitch has already been capped off to 89.
+		pitch = Q_fabs(cameraFocusAngles[PITCH]);
+
+		// The higher the pitch, the larger the factor, so as you look up, it damps a lot less.
+		pitch /= 115.0f;	
+		dampfactor = (1.0-cg_thirdPersonCameraDamp.value)*(pitch*pitch);
+
+		dampfactor += cg_thirdPersonCameraDamp.value;
+
+		// Now we also multiply in the stiff factor, so that faster yaw changes are stiffer.
+		if (cameraStiffFactor > 0.0f)
+		{	// The cameraStiffFactor is how much of the remaining damp below 1 should be shaved off, i.e. approach 1 as stiffening increases.
+			dampfactor += (1.0-dampfactor)*cameraStiffFactor;
+		}
+	}
+
+	if (dampfactor>=1.0)//||cg.thisFrameTeleport)
+	{	// No damping.
+		VectorCopy(cameraIdealLoc, cameraCurLoc);
+	}
+	else if (dampfactor>=0.0)
+	{	
+		// Calculate the difference from the current position to the new one.
+		VectorSubtract(cameraIdealLoc, cameraCurLoc, locdiff);
+
+		// Now we calculate how much of the difference we cover in the time allotted.
+		// The equation is (Damp)^(time)
+		dampfactor = 1.0-dampfactor;	// We must exponent the amount LEFT rather than the amount bled off
+		dtime = (float)(cg.time-cameraLastFrame) * (1.0/cg_timescale.value) * (1.0/(float)CAMERA_DAMP_INTERVAL);	// Our dampfactor is geared towards a time interval equal to "1".
+
+		// Note that since there are a finite number of "practical" delta millisecond values possible, 
+		// the ratio should be initialized into a chart ultimately.
+		ratio = pow(dampfactor, dtime);
+		
+		// This value is how much distance is "left" from the ideal.
+		VectorMA(cameraIdealLoc, -ratio, locdiff, cameraCurLoc);
+		/////////////////////////////////////////////////////////////////////////////////////////////////////////
+	}
+
+	// Now we trace from the first person viewpoint to the new view location, to make sure there is nothing in the way between the user and the camera...
+//	CG_Trace(&trace, cameraFocusLoc, cameramins, cameramaxs, cameraCurLoc, cg.predicted_player_state.clientNum, MASK_CAMERACLIP);
+	// (OLD) Now we trace from the new target location to the new view location, to make sure there is nothing in the way.
+	if ( cg.snap
+		&& (cg.snap->ps.eFlags&EF_HELD_BY_SAND_CREATURE) 
+		&& cg_entities[cg.snap->ps.clientNum].gent->activator )
+	{//if being held by a sand creature, trace from his actual origin, since we could be underground or otherwise in solid once he eats us
+		CG_Trace( &trace, cg_entities[cg_entities[cg.snap->ps.clientNum].gent->activator->s.number].lerpOrigin, cameramins, cameramaxs, cameraCurLoc, cg.predicted_player_state.clientNum, MASK_CAMERACLIP);
+	}
+	else
+	{
+		CG_Trace( &trace, cameraCurTarget, cameramins, cameramaxs, cameraCurLoc, cg.predicted_player_state.clientNum, MASK_CAMERACLIP);
+	}
+	if ( trace.fraction < 1.0f )
+	{
+		VectorCopy( trace.endpos, cameraCurLoc );
+
+		// We didn't trace all the way back, so push down the target accordingly.
+//		VectorSubtract(cameraCurTarget, cameraFocusLoc, locdiff);
+//		VectorMA(cameraFocusLoc, trace.fraction, locdiff, cameraCurTarget);
+
+		//FIXME: when the trace hits movers, it gets very very jaggy... ?
+		/*
+		//this doesn't actually help any
+		if ( trace.entityNum != ENTITYNUM_WORLD )
+		{
+			centity_t *cent = &cg_entities[trace.entityNum];
+			gentity_t *gent = &g_entities[trace.entityNum];
+			if ( cent != NULL && gent != NULL )
+			{
+				if ( cent->currentState.pos.trType == TR_LINEAR || cent->currentState.pos.trType == TR_LINEAR_STOP )
+				{
+					vec3_t	diff;
+					VectorSubtract( cent->lerpOrigin, gent->currentOrigin, diff );
+					VectorAdd( cameraCurLoc, diff, cameraCurLoc );
+				}
+			}
+		}
+		*/
+	}
+
+	// Note that previously there was an upper limit to the number of physics traces that are done through the world
+	// for the sake of camera collision, since it wasn't calced per frame.  Now it is calculated every frame.
+	// This has the benefit that the camera is a lot smoother now (before it lerped between tested points),
+	// however two full volume traces each frame is a bit scary to think about.
+}
+
+
+
+
+/*
+===============
+CG_OffsetThirdPersonView
+
+===============
+*/
+extern qboolean	MatrixMode;
+static void CG_OffsetThirdPersonView( void ) 
+{
+	vec3_t diff;
+	float deltayaw;
+
+	camWaterAdjust = 0;
+	cameraStiffFactor = 0.0;
+
+	// Set camera viewing direction.
+	VectorCopy( cg.refdefViewAngles, cameraFocusAngles );
+
+	if ( cg.snap 
+		&& (cg.snap->ps.eFlags&EF_HELD_BY_RANCOR) 
+		&& cg_entities[cg.snap->ps.clientNum].gent->activator )
+	{
+		centity_t	*monster = &cg_entities[cg_entities[cg.snap->ps.clientNum].gent->activator->s.number];
+		VectorSet( cameraFocusAngles, 0, AngleNormalize180(monster->lerpAngles[YAW]+180), 0 );
+	}
+	else if ( cg.snap && (cg.snap->ps.eFlags&EF_HELD_BY_SAND_CREATURE) )
+	{
+		centity_t	*monster = &cg_entities[cg_entities[cg.snap->ps.clientNum].gent->activator->s.number];
+		VectorSet( cameraFocusAngles, 0, AngleNormalize180(monster->lerpAngles[YAW]+180), 0 );
+		cameraFocusAngles[PITCH] = 0.0f;//flatten it out
+	}
+	else if ( G_IsRidingVehicle( &g_entities[0] ) )
+	{
+		cameraFocusAngles[YAW] = cg_entities[g_entities[0].owner->s.number].lerpAngles[YAW];
+		if ( cg.overrides.active & CG_OVERRIDE_3RD_PERSON_ANG )
+		{
+			cameraFocusAngles[YAW] += cg.overrides.thirdPersonAngle;
+		}
+		else
+		{
+			cameraFocusAngles[YAW] += cg_thirdPersonAngle.value;
+		}
+	}
+	else if ( cg.predicted_player_state.stats[STAT_HEALTH] <= 0 ) 
+	{// if dead, look at killer
+		if ( MatrixMode )
+		{
+			if ( cg.overrides.active & CG_OVERRIDE_3RD_PERSON_ANG )
+			{
+				cameraFocusAngles[YAW] += cg.overrides.thirdPersonAngle;
+			}
+			else
+			{
+				cameraFocusAngles[YAW] = cg.predicted_player_state.stats[STAT_DEAD_YAW];
+				cameraFocusAngles[YAW] += cg_thirdPersonAngle.value;
+			}
+		}
+		else
+		{
+			cameraFocusAngles[YAW] = cg.predicted_player_state.stats[STAT_DEAD_YAW];
+		}
+	}
+	else
+	{	// Add in the third Person Angle.
+		if ( cg.overrides.active & CG_OVERRIDE_3RD_PERSON_ANG )
+		{
+			cameraFocusAngles[YAW] += cg.overrides.thirdPersonAngle;
+		}
+		else
+		{
+			cameraFocusAngles[YAW] += cg_thirdPersonAngle.value;
+		}
+		if ( cg.overrides.active & CG_OVERRIDE_3RD_PERSON_POF )
+		{
+			cameraFocusAngles[PITCH] += cg.overrides.thirdPersonPitchOffset;
+		}
+		else
+		{
+			cameraFocusAngles[PITCH] += cg_thirdPersonPitchOffset.value;
+		}
+	}
+
+	if ( !cg.renderingThirdPerson && (cg.snap->ps.weapon == WP_SABER||cg.snap->ps.weapon == WP_MELEE) )
+	{// First person saber
+		// FIXME: use something network-friendly
+		vec3_t	org, viewDir;
+		VectorCopy( cg_entities[0].gent->client->renderInfo.eyePoint, org );
+		float blend = 1.0f - fabs(cg.refdefViewAngles[PITCH])/90.0f;
+		AngleVectors( cg.refdefViewAngles, viewDir, NULL, NULL );
+		VectorMA( org, -8, viewDir, org );
+		VectorScale( org, 1.0f - blend, org );
+		VectorMA( org, blend, cg.refdef.vieworg, cg.refdef.vieworg );
+		return;
+	}
+	// The next thing to do is to see if we need to calculate a new camera target location.
+
+	// If we went back in time for some reason, or if we just started, reset the sample.
+	if (cameraLastFrame == 0 || cameraLastFrame > cg.time)
+	{
+		CG_ResetThirdPersonViewDamp();
+	}
+	else
+	{
+		// Cap the pitch within reasonable limits
+		if (cameraFocusAngles[PITCH] > 89.0)
+		{
+			cameraFocusAngles[PITCH] = 89.0;
+		}
+		else if (cameraFocusAngles[PITCH] < -89.0)
+		{
+			cameraFocusAngles[PITCH] = -89.0;
+		}
+
+		AngleVectors(cameraFocusAngles, camerafwd, NULL, cameraup);
+
+		deltayaw = fabs(cameraFocusAngles[YAW] - cameraLastYaw);
+		if (deltayaw > 180.0f)
+		{ // Normalize this angle so that it is between 0 and 180.
+			deltayaw = fabs(deltayaw - 360.0f);
+		}
+		cameraStiffFactor = deltayaw / (float)(cg.time-cameraLastFrame);
+		if (cameraStiffFactor < 1.0)
+		{
+			cameraStiffFactor = 0.0;
+		}
+		else if (cameraStiffFactor > 2.5)
+		{
+			cameraStiffFactor = 0.75;
+		}
+		else
+		{	// 1 to 2 scales from 0.0 to 0.5
+			cameraStiffFactor = (cameraStiffFactor-1.0f)*0.5f;
+		}
+		cameraLastYaw = cameraFocusAngles[YAW];
+
+		// Move the target to the new location.
+		CG_UpdateThirdPersonTargetDamp();
+		CG_UpdateThirdPersonCameraDamp();
+	}
+
+	// Now interestingly, the Quake method is to calculate a target focus point above the player, and point the camera at it.
+	// We won't do that for now.
+
+	// We must now take the angle taken from the camera target and location.
+	VectorSubtract(cameraCurTarget, cameraCurLoc, diff);
+	//Com_Printf( "%s\n", vtos(diff) );
+	float dist = VectorNormalize(diff);
+	if ( dist < 1.0f )
+	{//must be hitting something, need some value to calc angles, so use cam forward
+		VectorCopy( camerafwd, diff );
+	}
+	vectoangles(diff, cg.refdefViewAngles);
+
+	// Temp: just move the camera to the side a bit
+	extern vmCvar_t cg_thirdPersonHorzOffset;
+	if ( cg_thirdPersonHorzOffset.value != 0.0f )
+	{
+		AnglesToAxis( cg.refdefViewAngles, cg.refdef.viewaxis );
+		VectorMA( cameraCurLoc, cg_thirdPersonHorzOffset.value, cg.refdef.viewaxis[1], cameraCurLoc );
+	}
+
+	// ...and of course we should copy the new view location to the proper spot too.
+	VectorCopy(cameraCurLoc, cg.refdef.vieworg);
+
+	//if we hit the water, do a last-minute adjustment
+	if ( camWaterAdjust )
+	{
+		cg.refdef.vieworg[2] += camWaterAdjust;
+	}
+	cameraLastFrame=cg.time;
+}
+
+
+
+/*
+===============
+CG_OffsetThirdPersonView
+
+===============
+*/
+/*
+#define	FOCUS_DISTANCE	512
+static void CG_OffsetThirdPersonView( void ) {
+	vec3_t		forward, right, up;
+	vec3_t		view;
+	vec3_t		focusAngles;
+	trace_t		trace;
+	static vec3_t	mins = { -4, -4, -4 };
+	static vec3_t	maxs = { 4, 4, 4 };
+	vec3_t		focusPoint;
+	float		focusDist;
+	float		forwardScale, sideScale;
+
+	cg.refdef.vieworg[2] += cg.predicted_player_state.viewheight;
+
+	VectorCopy( cg.refdefViewAngles, focusAngles );
+
+	// if dead, look at killer
+	if ( cg.predicted_player_state.stats[STAT_HEALTH] <= 0 ) {
+		focusAngles[YAW] = cg.predicted_player_state.stats[STAT_DEAD_YAW];
+		cg.refdefViewAngles[YAW] = cg.predicted_player_state.stats[STAT_DEAD_YAW];
+	}
+
+	if ( focusAngles[PITCH] > 45 ) {
+		focusAngles[PITCH] = 45;		// don't go too far overhead
+	}
+	AngleVectors( focusAngles, forward, NULL, NULL );
+
+	VectorMA( cg.refdef.vieworg, FOCUS_DISTANCE, forward, focusPoint );
+
+	VectorCopy( cg.refdef.vieworg, view );
+
+	view[2] += 8;
+
+	cg.refdefViewAngles[PITCH] *= 0.5;
+
+	AngleVectors( cg.refdefViewAngles, forward, right, up );
+
+	float tpAngle = cg.overrides.thirdPersonAngle ? cg.overrides.thirdPersonAngle : cg_thirdPersonAngle.value;
+	forwardScale = cos( tpAngle / 180 * M_PI );
+	sideScale = sin( tpAngle / 180 * M_PI );
+	VectorMA( view, -tpAngle * forwardScale, forward, view );
+	VectorMA( view, -tpAngle * sideScale, right, view );
+
+	// trace a ray from the origin to the viewpoint to make sure the view isn't
+	// in a solid block.  Use an 8 by 8 block to prevent the view from near clipping anything
+
+	CG_Trace( &trace, cg.refdef.vieworg, mins, maxs, view, cg.predicted_player_state.clientNum, MASK_CAMERACLIP );
+
+	if ( trace.fraction != 1.0 ) {
+		VectorCopy( trace.endpos, view );
+		view[2] += (1.0 - trace.fraction) * 32;
+		// try another trace to this position, because a tunnel may have the ceiling
+		// close enogh that this is poking out
+
+		CG_Trace( &trace, cg.refdef.vieworg, mins, maxs, view, cg.predicted_player_state.clientNum, MASK_CAMERACLIP );
+		VectorCopy( trace.endpos, view );
+	}
+
+
+	VectorCopy( view, cg.refdef.vieworg );
+
+	// select pitch to look at focus point from vieword
+	VectorSubtract( focusPoint, cg.refdef.vieworg, focusPoint );
+	focusDist = sqrt( focusPoint[0] * focusPoint[0] + focusPoint[1] * focusPoint[1] );
+	if ( focusDist < 1 ) {
+		focusDist = 1;	// should never happen
+	}
+	cg.refdefViewAngles[PITCH] = -180 / M_PI * atan2( focusPoint[2], focusDist );
+	cg.refdefViewAngles[YAW] -= tpAngle;
+}
+
+
+#define MIN_CAMERA_HEIGHT	75
+#define MIN_CAMERA_PITCH	40
+#define MAX_CAMERA_PITCH	90
+
+//----------------------------------------------
+static void CG_OffsetThirdPersonOverheadView( void ) {
+	vec3_t		view, angs;
+	trace_t		trace;
+	static vec3_t	mins = { -4, -4, -4 };
+	static vec3_t	maxs = { 4, 4, 4 };
+
+	VectorCopy( cg.refdef.vieworg, view );
+
+	// Move straight up from the player, making sure to always go at least the min camera height, 
+	//	otherwise, the camera will clip into the head of the player.
+	float tpRange = cg.overrides.thirdPersonRange ? cg.overrides.thirdPersonRange : cg_thirdPersonRange.value;
+	if ( tpRange < MIN_CAMERA_HEIGHT )
+	{
+		view[2] += MIN_CAMERA_HEIGHT;
+	}
+	else
+	{
+		view[2] += tpRange;
+	}
+
+	// Now adjust the camera angles, but we shouldn't adjust the viewAngles...only the viewAxis
+	VectorCopy( cg.refdefViewAngles, angs );
+	angs[PITCH] = cg.overrides.thirdPersonAngle ? cg.overrides.thirdPersonAngle : cg_thirdPersonAngle.value;
+
+	// Simple clamp to weed out any really obviously nasty angles
+	if ( angs[PITCH] < MIN_CAMERA_PITCH )
+	{
+		angs[PITCH] = MIN_CAMERA_PITCH;
+	}
+	else if ( angs[PITCH] > MAX_CAMERA_PITCH )
+	{
+		angs[PITCH] = MAX_CAMERA_PITCH;
+	}
+
+	// Convert our new desired camera angles and store them where they will get used by the engine 
+	//	when setting up the actual camera view.
+	AnglesToAxis( angs, cg.refdef.viewaxis );
+	cg.refdefViewAngles[PITCH] = 0;
+	g_entities[0].client->ps.delta_angles[PITCH] = 0;
+	
+	// Trace a ray from the origin to the viewpoint to make sure the view isn't
+	//	in a solid block.
+	CG_Trace( &trace, cg.refdef.vieworg, mins, maxs, view, cg.predicted_player_state.clientNum, MASK_CAMERACLIP);
+
+	if ( trace.fraction != 1.0 ) 
+	{
+		VectorCopy( trace.endpos, cg.refdef.vieworg );
+	}
+	else
+	{
+		VectorCopy( view, cg.refdef.vieworg );
+	}
+}
+*/
+// this causes a compiler bug on mac MrC compiler
+static void CG_StepOffset( void ) {
+	int		timeDelta;
+	
+	// smooth out stair climbing
+	timeDelta = cg.time - cg.stepTime;
+	if ( timeDelta < STEP_TIME ) {
+		cg.refdef.vieworg[2] -= cg.stepChange 
+			* (STEP_TIME - timeDelta) / STEP_TIME;
+	}
+}
+
+/*
+===============
+CG_OffsetFirstPersonView
+
+===============
+*/
+extern qboolean PM_InForceGetUp( playerState_t *ps );
+extern qboolean PM_InGetUp( playerState_t *ps );
+extern qboolean PM_InKnockDown( playerState_t *ps );
+extern int PM_AnimLength( int index, animNumber_t anim );
+static void CG_OffsetFirstPersonView( qboolean firstPersonSaber ) {
+	float			*origin;
+	float			*angles;
+	float			bob;
+	float			ratio;
+	float			delta;
+	float			speed;
+	float			f;
+	vec3_t			predictedVelocity;
+	int				timeDelta;
+	
+	if ( cg.snap->ps.pm_type == PM_INTERMISSION ) {
+		return;
+	}
+
+	origin = cg.refdef.vieworg;
+	angles = cg.refdefViewAngles;
+
+	// if dead, fix the angle and don't add any kick
+	if ( cg.snap->ps.stats[STAT_HEALTH] <= 0 ) 
+	{
+		angles[ROLL] = 40;
+		angles[PITCH] = -15;
+		angles[YAW] = cg.snap->ps.stats[STAT_DEAD_YAW];
+		origin[2] += cg.predicted_player_state.viewheight;
+		return;
+	}
+
+	if ( g_entities[0].client && PM_InKnockDown( &g_entities[0].client->ps ) )
+	{
+		float perc, animLen = (float)PM_AnimLength( g_entities[0].client->clientInfo.animFileIndex, (animNumber_t)g_entities[0].client->ps.legsAnim );
+		if ( PM_InGetUp( &g_entities[0].client->ps ) || PM_InForceGetUp( &g_entities[0].client->ps ) )
+		{//start righting the view
+			perc = (float)g_entities[0].client->ps.legsAnimTimer/animLen*2;
+		}
+		else
+		{//tilt the view
+			perc = (animLen-g_entities[0].client->ps.legsAnimTimer)/animLen*2;
+		}
+		if ( perc > 1.0f )
+		{
+			perc = 1.0f;
+		}
+		angles[ROLL] = perc*40;
+		angles[PITCH] = perc*-15;
+	}
+
+	// add angles based on weapon kick
+	int kickTime = (cg.time - cg.kick_time);
+	if ( kickTime < 800 )
+	{//kicks are always 1 second long.  Deal with it.
+		float kickPerc = 0.0f;
+		if ( kickTime <= 200 )
+		{//winding up
+			kickPerc = kickTime/200.0f;
+		}
+		else
+		{//returning to normal
+			kickTime = 800 - kickTime;
+			kickPerc = kickTime/600.0f;
+		}
+		VectorMA( angles, kickPerc, cg.kick_angles, angles );
+	}
+
+	// add angles based on damage kick
+	if ( cg.damageTime ) {
+		ratio = cg.time - cg.damageTime;
+		if ( ratio < DAMAGE_DEFLECT_TIME ) {
+			ratio /= DAMAGE_DEFLECT_TIME;
+			angles[PITCH] += ratio * cg.v_dmg_pitch;
+			angles[ROLL] += ratio * cg.v_dmg_roll;
+		} else {
+			ratio = 1.0 - ( ratio - DAMAGE_DEFLECT_TIME ) / DAMAGE_RETURN_TIME;
+			if ( ratio > 0 ) {
+				angles[PITCH] += ratio * cg.v_dmg_pitch;
+				angles[ROLL] += ratio * cg.v_dmg_roll;
+			}
+		}
+	}
+
+	// add pitch based on fall kick
+#if 0
+	ratio = ( cg.time - cg.landTime) / FALL_TIME;
+	if (ratio < 0)
+		ratio = 0;
+	angles[PITCH] += ratio * cg.fall_value;
+#endif
+
+	// add angles based on velocity
+	VectorCopy( cg.predicted_player_state.velocity, predictedVelocity );
+
+	delta = DotProduct ( predictedVelocity, cg.refdef.viewaxis[0]);
+	angles[PITCH] += delta * cg_runpitch.value;
+	
+	delta = DotProduct ( predictedVelocity, cg.refdef.viewaxis[1]);
+	angles[ROLL] -= delta * cg_runroll.value;
+
+	// add angles based on bob
+
+	// make sure the bob is visible even at low speeds
+	speed = cg.xyspeed > 200 ? cg.xyspeed : 200;
+
+	delta = cg.bobfracsin * cg_bobpitch.value * speed;
+	if (cg.predicted_player_state.pm_flags & PMF_DUCKED)
+		delta *= 3;		// crouching
+	angles[PITCH] += delta;
+	delta = cg.bobfracsin * cg_bobroll.value * speed;
+	if (cg.predicted_player_state.pm_flags & PMF_DUCKED)
+		delta *= 3;		// crouching accentuates roll
+	if (cg.bobcycle & 1)
+		delta = -delta;
+	angles[ROLL] += delta;
+
+//===================================
+
+	if ( !firstPersonSaber )//First person saber
+	{
+		// add view height
+		if ( cg.snap->ps.viewEntity > 0 && cg.snap->ps.viewEntity < ENTITYNUM_WORLD )
+		{
+			if ( &g_entities[cg.snap->ps.viewEntity] &&
+				g_entities[cg.snap->ps.viewEntity].client &&
+				g_entities[cg.snap->ps.viewEntity].client->ps.viewheight )
+			{
+				origin[2] += g_entities[cg.snap->ps.viewEntity].client->ps.viewheight;
+			}
+			else
+			{
+				origin[2] += 4;//???
+			}
+		}
+		else
+		{
+			origin[2] += cg.predicted_player_state.viewheight;
+		}
+	}
+
+	// smooth out duck height changes
+	timeDelta = cg.time - cg.duckTime;
+	if ( timeDelta < DUCK_TIME) {
+		cg.refdef.vieworg[2] -= cg.duckChange * (DUCK_TIME - timeDelta) / DUCK_TIME;
+	}
+
+	// add bob height
+	bob = cg.bobfracsin * cg.xyspeed * cg_bobup.value;
+	if (bob > 6) {
+		bob = 6;
+	}
+
+	origin[2] += bob;
+
+
+	// add fall height
+	delta = cg.time - cg.landTime;
+	if ( delta < LAND_DEFLECT_TIME ) {
+		f = delta / LAND_DEFLECT_TIME;
+		cg.refdef.vieworg[2] += cg.landChange * f;
+	} else if ( delta < LAND_DEFLECT_TIME + LAND_RETURN_TIME ) {
+		delta -= LAND_DEFLECT_TIME;
+		f = 1.0 - ( delta / LAND_RETURN_TIME );
+		cg.refdef.vieworg[2] += cg.landChange * f;
+	}
+
+	// add step offset
+	CG_StepOffset();
+
+	if(cg.snap->ps.leanofs != 0)
+	{
+		vec3_t	right;
+		//add leaning offset
+		//FIXME: when crouching, this bounces up and down?!
+		cg.refdefViewAngles[2] += (float)cg.snap->ps.leanofs/2;
+		AngleVectors(cg.refdefViewAngles, NULL, right, NULL);
+		VectorMA(cg.refdef.vieworg, (float)cg.snap->ps.leanofs, right, cg.refdef.vieworg);
+	}
+
+	// pivot the eye based on a neck length
+#if 0
+	{
+#define	NECK_LENGTH		8
+	vec3_t			forward, up;
+ 
+	cg.refdef.vieworg[2] -= NECK_LENGTH;
+	AngleVectors( cg.refdefViewAngles, forward, NULL, up );
+	VectorMA( cg.refdef.vieworg, 3, forward, cg.refdef.vieworg );
+	VectorMA( cg.refdef.vieworg, NECK_LENGTH, up, cg.refdef.vieworg );
+	}
+#endif
+}
+
+
+/*
+====================
+CG_CalcFovFromX
+
+Calcs Y FOV from given X FOV
+====================
+*/
+qboolean CG_CalcFOVFromX( float fov_x ) 
+{
+	float	x;
+	float	fov_y;
+	qboolean	inwater;
+
+	x = cg.refdef.width / tan( fov_x / 360 * M_PI );
+	fov_y = atan2( cg.refdef.height, x );
+	fov_y = fov_y * 360 / M_PI;
+
+	// there's a problem with this, it only takes the leafbrushes into account, not the entity brushes,
+	//	so if you give slime/water etc properties to a func_door area brush in order to move the whole water 
+	//	level up/down this doesn't take into account the door position, so warps the view the whole time
+	//	whether the water is up or not.
+	// warp if underwater
+	float	phase;
+	float	v;
+	cg.refdef.viewContents = 0;
+	if (gi.totalMapContents() & ( CONTENTS_WATER | CONTENTS_SLIME | CONTENTS_LAVA ))
+	{
+		cg.refdef.viewContents = CG_PointContents( cg.refdef.vieworg, -1 );
+	}
+	if ( cg.refdef.viewContents & ( CONTENTS_WATER | CONTENTS_SLIME | CONTENTS_LAVA ) )
+	{
+		phase = cg.time / 1000.0 * WAVE_FREQUENCY * M_PI * 2;
+		v = WAVE_AMPLITUDE * sin( phase );
+		fov_x += v;
+		fov_y -= v;
+		inwater = qtrue;
+	}
+	else 
+	{
+		inwater = qfalse;
+	}
+
+	// see if we are drugged by an interrogator.  We muck with the FOV here, a bit later, after viewangles are calc'ed, I muck with those too.
+	if ( cg.wonkyTime > 0 && cg.wonkyTime > cg.time )
+	{
+		float perc = (float)(cg.wonkyTime - cg.time) / 10000.0f; // goes for 10 seconds
+
+		fov_x += ( 25.0f * perc );
+		fov_y -= ( cos( cg.time * 0.0008f ) * 5.0f * perc );
+	}
+
+	// set it
+	cg.refdef.fov_x = fov_x;
+	cg.refdef.fov_y = fov_y;
+
+#ifdef _XBOX
+	if(cg.widescreen)
+//		cg.refdef.fov_x = fov_y * 1.5;//1.77777f;
+		cg.refdef.fov_x *= 1.125f;
+#endif
+
+	return (inwater);
+}
+
+float CG_ForceSpeedFOV( void )
+{
+	float fov;
+	float timeLeft = player->client->ps.forcePowerDuration[FP_SPEED] - cg.time;
+	float length = FORCE_SPEED_DURATION*forceSpeedValue[player->client->ps.forcePowerLevel[FP_SPEED]];
+	float amt = forceSpeedFOVMod[player->client->ps.forcePowerLevel[FP_SPEED]];
+	if ( timeLeft < 500 )
+	{//start going back
+		fov = cg_fov.value + (timeLeft)/500*amt;
+	}
+	else if ( length - timeLeft < 1000 )
+	{//start zooming in
+		fov = cg_fov.value + (length - timeLeft)/1000*amt;
+	}
+	else
+	{//stay at this FOV
+		fov = cg_fov.value+amt;
+	}
+	return fov;
+}
+/*
+====================
+CG_CalcFov
+
+Fixed fov at intermissions, otherwise account for fov variable and zooms.
+====================
+*/
+//extern float	g_fov;
+static qboolean	CG_CalcFov( void ) {
+	float	fov_x;
+	float	f;
+
+	if ( cg.predicted_player_state.pm_type == PM_INTERMISSION ) {
+		// if in intermission, use a fixed value
+		fov_x = 80;
+	}
+	else if ( cg.snap 
+		&& cg.snap->ps.viewEntity > 0 
+		&& cg.snap->ps.viewEntity < ENTITYNUM_WORLD 
+		&& (!cg.renderingThirdPerson || g_entities[cg.snap->ps.viewEntity].e_DieFunc == dieF_camera_die) )
+	{
+		// if in entity camera view, use a special FOV
+		if ( &g_entities[cg.snap->ps.viewEntity] &&
+			g_entities[cg.snap->ps.viewEntity].NPC )
+		{//FIXME: looks bad when take over a jedi... but never really do that, do we?
+			fov_x = g_entities[cg.snap->ps.viewEntity].NPC->stats.hfov;
+			//sanity-cap?
+			if ( fov_x > 120 )
+			{
+				fov_x = 120;
+			}
+			else if ( fov_x < 10 )
+			{
+				fov_x = 10;
+			}
+		}
+		else
+		{
+			if ( cg.overrides.active & CG_OVERRIDE_FOV )
+			{
+				fov_x = cg.overrides.fov;
+			}
+			else
+			{
+				fov_x = 120;//FIXME: read from the NPC's fov stats?
+			}
+		}
+	} 
+	else if ( (!cg.zoomMode || cg.zoomMode > 2) && (cg.snap->ps.forcePowersActive&(1<<FP_SPEED)) && player->client->ps.forcePowerDuration[FP_SPEED] )//cg.renderingThirdPerson && 
+	{
+		fov_x = CG_ForceSpeedFOV();
+	} else {
+		// user selectable
+		if ( cg.overrides.active & CG_OVERRIDE_FOV )
+		{
+			fov_x = cg.overrides.fov;
+		}
+		else
+		{
+			fov_x = cg_fov.value;
+		}
+		if ( fov_x < 1 ) {
+			fov_x = 1;
+		} else if ( fov_x > 160 ) {
+			fov_x = 160;
+		}
+
+		// Disable zooming when in third person
+		if ( cg.zoomMode && cg.zoomMode < 3 )//&& !cg.renderingThirdPerson ) // light amp goggles do none of the zoom silliness
+		{
+			if ( !cg.zoomLocked )
+			{
+				if ( cg.zoomMode == 1 )
+				{
+					// binoculars zooming either in or out
+					cg_zoomFov += cg.zoomDir * cg.frametime * 0.05f;
+				}
+				else
+				{
+					// disruptor zooming in faster
+					cg_zoomFov -= cg.frametime * 0.075f;
+				}
+
+				// Clamp zoomFov
+				float actualFOV = (cg.overrides.active&CG_OVERRIDE_FOV) ? cg.overrides.fov : cg_fov.value;
+				if ( cg_zoomFov < MAX_ZOOM_FOV )
+				{
+					cg_zoomFov = MAX_ZOOM_FOV;
+				}
+				else if ( cg_zoomFov > actualFOV )
+				{
+					cg_zoomFov = actualFOV;
+				}
+				else
+				{//still zooming
+					static zoomSoundTime = 0;
+
+					if ( zoomSoundTime < cg.time )
+					{
+						sfxHandle_t snd;
+#ifdef _IMMERSION
+//						ffHandle_t ff;
+#endif // _IMMERSION
+						
+						if ( cg.zoomMode == 1 )
+						{
+							snd = cgs.media.zoomLoop;
+#ifdef _IMMERSION
+//							ff = cgs.media.zoomLoopForce;
+#endif // _IMMERSION
+						}
+						else
+						{
+							snd = cgs.media.disruptorZoomLoop;
+#ifdef _IMMERSION
+//							ff = cgs.media.disruptorZoomLoopForce;
+#endif // _IMMERSION
+						}
+
+						// huh?  This could probably just be added as a looping sound??
+						cgi_S_StartSound( cg.refdef.vieworg, ENTITYNUM_WORLD, CHAN_LOCAL, snd );
+#ifdef _IMMERSION
+//						cgi_FF_Start( ff, cg.snap->ps.clientNum );
+#endif // _IMMERSION
+						zoomSoundTime = cg.time + 150; 
+					}
+				}
+			}
+
+			fov_x = cg_zoomFov;
+		} else {
+			f = ( cg.time - cg.zoomTime ) / ZOOM_OUT_TIME;
+			if ( f > 1.0 ) {
+				fov_x = fov_x;
+			} else {
+				fov_x = cg_zoomFov + f * ( fov_x - cg_zoomFov );
+			}
+		}
+	}
+
+//	g_fov = fov_x;
+	return ( CG_CalcFOVFromX( fov_x ) );
+}
+
+
+
+/*
+===============
+CG_DamageBlendBlob
+
+===============
+*/
+static void CG_DamageBlendBlob( void ) 
+{
+	int			t;
+	int			maxTime;
+	refEntity_t		ent;
+
+	if ( !cg.damageValue ) {
+		return;
+	}
+
+	maxTime = DAMAGE_TIME;
+	t = cg.time - cg.damageTime;
+	if ( t <= 0 || t >= maxTime ) {
+		return;
+	}
+
+	memset( &ent, 0, sizeof( ent ) );
+	ent.reType = RT_SPRITE;
+	ent.renderfx = RF_FIRST_PERSON;
+
+	VectorMA( cg.refdef.vieworg, 8, cg.refdef.viewaxis[0], ent.origin );
+	VectorMA( ent.origin, cg.damageX * -8, cg.refdef.viewaxis[1], ent.origin );
+	VectorMA( ent.origin, cg.damageY * 8, cg.refdef.viewaxis[2], ent.origin );
+
+	ent.radius = cg.damageValue * 3 * ( 1.0 - ((float)t / maxTime) );
+	ent.customShader = cgs.media.damageBlendBlobShader;
+	ent.shaderRGBA[0] = 180 * ( 1.0 - ((float)t / maxTime) );
+	ent.shaderRGBA[1] = 50 * ( 1.0 - ((float)t / maxTime) );
+	ent.shaderRGBA[2] = 50 * ( 1.0 - ((float)t / maxTime) );
+	ent.shaderRGBA[3] = 255;
+
+	cgi_R_AddRefEntityToScene( &ent );
+}
+
+/*
+====================
+CG_SaberClashFlare
+====================
+*/
+extern int g_saberFlashTime;
+extern vec3_t g_saberFlashPos;
+extern qboolean CG_WorldCoordToScreenCoord(vec3_t worldCoord, int *x, int *y);
+void CG_SaberClashFlare( void ) 
+{
+	int				t, maxTime = 150;
+
+	t = cg.time - g_saberFlashTime;
+
+	if ( t <= 0 || t >= maxTime ) 
+	{
+		return;
+	}
+
+	vec3_t dif;
+
+	// Don't do clashes for things that are behind us
+	VectorSubtract( g_saberFlashPos, cg.refdef.vieworg, dif );
+
+	if ( DotProduct( dif, cg.refdef.viewaxis[0] ) < 0.2 )
+	{
+		return;
+	}
+
+	trace_t tr;
+
+	CG_Trace( &tr, cg.refdef.vieworg, NULL, NULL, g_saberFlashPos, -1, CONTENTS_SOLID );
+
+	if ( tr.fraction < 1.0f )
+	{
+		return;
+	}
+
+	vec3_t color;
+	int x,y;
+	float v, len = VectorNormalize( dif );
+
+	// clamp to a known range
+	if ( len > 800 )
+	{
+		len = 800;
+	}
+
+	v = ( 1.0f - ((float)t / maxTime )) * ((1.0f - ( len / 800.0f )) * 2.0f + 0.35f);
+
+	CG_WorldCoordToScreenCoord( g_saberFlashPos, &x, &y );
+
+	VectorSet( color, 0.8f, 0.8f, 0.8f );
+	cgi_R_SetColor( color );
+
+	CG_DrawPic( x - ( v * 300 ), y - ( v * 300 ),
+				v * 600, v * 600,
+				cgi_R_RegisterShader( "gfx/effects/saberFlare" ));
+}
+
+/*
+===============
+CG_CalcViewValues
+
+Sets cg.refdef view values
+===============
+*/
+static qboolean CG_CalcViewValues( void ) {
+	playerState_t	*ps;
+	qboolean		viewEntIsCam = qfalse;
+	//extern vec3_t	cgRefdefVieworg;
+
+	memset( &cg.refdef, 0, sizeof( cg.refdef ) );
+
+	// calculate size of 3D view
+	CG_CalcVrect();
+
+	ps = &cg.predicted_player_state;
+#ifndef FINAL_BUILD
+	trap_Com_SetOrgAngles(ps->origin,ps->viewangles);
+#endif
+	// intermission view
+	if ( ps->pm_type == PM_INTERMISSION ) {
+		VectorCopy( ps->origin, cg.refdef.vieworg );
+		VectorCopy( ps->viewangles, cg.refdefViewAngles );
+		AnglesToAxis( cg.refdefViewAngles, cg.refdef.viewaxis );
+		return CG_CalcFov();
+	}
+
+	cg.bobcycle = ( ps->bobCycle & 128 ) >> 7;
+	cg.bobfracsin = fabs( sin( ( ps->bobCycle & 127 ) / 127.0 * M_PI ) );
+	cg.xyspeed = sqrt( ps->velocity[0] * ps->velocity[0] +
+		ps->velocity[1] * ps->velocity[1] );
+
+	if ( G_IsRidingVehicle( &g_entities[0] ) )
+	{
+		VectorCopy( ps->origin, cg.refdef.vieworg );
+		VectorCopy( cg_entities[g_entities[0].owner->s.number].lerpAngles, cg.refdefViewAngles );
+		if ( !(ps->eFlags&EF_NODRAW) )
+		{//riding it, not *inside* it
+			//let us look up & down
+			cg.refdefViewAngles[PITCH] = cg_entities[ps->clientNum].lerpAngles[PITCH] * 0.2f;
+		}
+	}
+	else if ( cg.snap->ps.viewEntity > 0 && cg.snap->ps.viewEntity < ENTITYNUM_WORLD )
+	{//in an entity camera view
+		/*
+		if ( g_entities[cg.snap->ps.viewEntity].client && cg.renderingThirdPerson )
+		{
+			VectorCopy( g_entities[cg.snap->ps.viewEntity].client->renderInfo.eyePoint, cg.refdef.vieworg );
+		}
+		else
+		*/
+		{
+			VectorCopy( cg_entities[cg.snap->ps.viewEntity].lerpOrigin, cg.refdef.vieworg );
+		}
+		VectorCopy( cg_entities[cg.snap->ps.viewEntity].lerpAngles, cg.refdefViewAngles );
+		if ( !Q_stricmp( "misc_camera", g_entities[cg.snap->ps.viewEntity].classname ) || g_entities[cg.snap->ps.viewEntity].s.weapon == WP_TURRET )
+		{
+			viewEntIsCam = qtrue;
+		}
+	}
+	else if ( cg.renderingThirdPerson && !cg.zoomMode && (cg.overrides.active&CG_OVERRIDE_3RD_PERSON_ENT) )
+	{//different center, same angle
+		VectorCopy( cg_entities[cg.overrides.thirdPersonEntity].lerpOrigin, cg.refdef.vieworg );
+		VectorCopy( ps->viewangles, cg.refdefViewAngles );
+	}
+	else
+	{//player's center and angles
+		VectorCopy( ps->origin, cg.refdef.vieworg );
+		VectorCopy( ps->viewangles, cg.refdefViewAngles );
+	}
+
+	// add error decay
+	if ( cg_errorDecay.value > 0 ) {
+		int		t;
+		float	f;
+
+		t = cg.time - cg.predictedErrorTime;
+		f = ( cg_errorDecay.value - t ) / cg_errorDecay.value;
+		if ( f > 0 && f < 1 ) {
+			VectorMA( cg.refdef.vieworg, f, cg.predictedError, cg.refdef.vieworg );
+		} else {
+			cg.predictedErrorTime = 0;
+		}
+	}
+
+	if ( (cg.renderingThirdPerson||cg.snap->ps.weapon == WP_SABER||cg.snap->ps.weapon == WP_MELEE) 
+		&& !cg.zoomMode 
+		&& !viewEntIsCam )
+	{
+		// back away from character
+//		if ( cg_thirdPerson.integer == CG_CAM_ABOVE)
+//		{			`
+//			CG_OffsetThirdPersonOverheadView();
+//		}
+//		else
+//		{
+		// First person saber
+		if ( !cg.renderingThirdPerson )
+		{
+			if ( cg.snap->ps.weapon == WP_SABER||cg.snap->ps.weapon == WP_MELEE )
+			{
+				vec3_t dir;
+				CG_OffsetFirstPersonView( qtrue );
+				cg.refdef.vieworg[2] += 32;
+				AngleVectors( cg.refdefViewAngles, dir, NULL, NULL );
+				VectorMA( cg.refdef.vieworg, -2, dir, cg.refdef.vieworg );
+			}
+		}
+		CG_OffsetThirdPersonView();
+//		}
+	}  
+	else 
+	{
+		// offset for local bobbing and kicks
+		CG_OffsetFirstPersonView( qfalse );
+		centity_t	*playerCent = &cg_entities[0];
+		if ( playerCent && playerCent->gent && playerCent->gent->client )
+		{
+			VectorCopy( cg.refdef.vieworg, playerCent->gent->client->renderInfo.eyePoint );
+			VectorCopy( cg.refdefViewAngles, playerCent->gent->client->renderInfo.eyeAngles );
+			if ( cg.snap->ps.viewEntity > 0 && cg.snap->ps.viewEntity < ENTITYNUM_WORLD )
+			{//in an entity camera view
+				if ( cg_entities[cg.snap->ps.viewEntity].gent->client )
+				{//looking through a client's eyes
+					VectorCopy( cg.refdef.vieworg, cg_entities[cg.snap->ps.viewEntity].gent->client->renderInfo.eyePoint );
+					VectorCopy( cg.refdefViewAngles, cg_entities[cg.snap->ps.viewEntity].gent->client->renderInfo.eyeAngles );
+				}
+				else
+				{//looking through a regular ent's eyes
+					VectorCopy( cg.refdef.vieworg, cg_entities[cg.snap->ps.viewEntity].lerpOrigin );
+					VectorCopy( cg.refdefViewAngles, cg_entities[cg.snap->ps.viewEntity].lerpAngles );
+				}
+			}
+			VectorCopy( playerCent->gent->client->renderInfo.eyePoint, playerCent->gent->client->renderInfo.headPoint );
+			if ( cg.snap->ps.viewEntity <= 0 || cg.snap->ps.viewEntity >= ENTITYNUM_WORLD )
+			{//not in entity cam
+				playerCent->gent->client->renderInfo.headPoint[2] -= 8;
+			}
+		}
+	}
+
+	//VectorCopy( cg.refdef.vieworg, cgRefdefVieworg );
+	// shake the camera if necessary
+	CGCam_UpdateSmooth( cg.refdef.vieworg, cg.refdefViewAngles );
+	CGCam_UpdateShake( cg.refdef.vieworg, cg.refdefViewAngles );
+
+	/*
+	if ( in_camera )
+	{
+		Com_Printf( "%s %s\n", vtos(client_camera.origin), vtos(cg.refdef.vieworg) ); 
+	}
+	*/
+
+	// see if we are drugged by an interrogator.  We muck with the angles here, just a bit earlier, we mucked with the FOV
+	if ( cg.wonkyTime > 0 && cg.wonkyTime > cg.time )
+	{
+		float perc = (float)(cg.wonkyTime - cg.time) / 10000.0f; // goes for 10 seconds
+
+		cg.refdefViewAngles[ROLL] += ( sin( cg.time * 0.0004f )  * 7.0f * perc );
+		cg.refdefViewAngles[PITCH] += ( 26.0f * perc + sin( cg.time * 0.0011f ) * 3.0f * perc );
+	}
+
+	AnglesToAxis( cg.refdefViewAngles, cg.refdef.viewaxis );
+
+	if ( cg.hyperspace ) 
+	{
+		cg.refdef.rdflags |= RDF_NOWORLDMODEL | RDF_HYPERSPACE;
+	}
+
+	// field of view
+	return CG_CalcFov();
+}
+
+
+/*
+=====================
+CG_PowerupTimerSounds
+=====================
+*/
+static void CG_PowerupTimerSounds( void ) 
+{
+	int	i, time;
+	
+	// powerup timers going away
+	for ( i = 0 ; i < MAX_POWERUPS ; i++ ) 
+	{
+		time = cg.snap->ps.powerups[i];
+
+		if ( time > 0 && time < cg.time ) 
+		{
+			// add any special powerup expiration sounds here
+//			switch( i )
+//			{
+//			case PW_WEAPON_OVERCHARGE:
+//				cgi_S_StartSound( NULL, cg.snap->ps.clientNum, CHAN_ITEM, cgs.media.overchargeEndSound );
+//				break;
+//			}
+		}
+	}
+}
+
+/*
+==============
+CG_DrawSkyBoxPortal
+==============
+*/
+extern void cgi_CM_SnapPVS(vec3_t origin,byte *buffer);
+
+static void CG_DrawSkyBoxPortal(void)
+{
+	refdef_t backuprefdef;
+	const char *cstr;
+	char *token;
+
+	cstr = CG_ConfigString(CS_SKYBOXORG);
+
+	if (!cstr || !strlen(cstr))
+	{
+		// no skybox in this map
+		return;
+	}
+
+	backuprefdef = cg.refdef;
+
+	token = COM_ParseExt(&cstr, qfalse);
+	if (!token || !token[0])
+	{
+		CG_Error( "CG_DrawSkyBoxPortal: error parsing skybox configstring\n");
+	}
+	cg.refdef.vieworg[0] = atof(token);
+
+	token = COM_ParseExt(&cstr, qfalse);
+	if (!token || !token[0])
+	{
+		CG_Error( "CG_DrawSkyBoxPortal: error parsing skybox configstring\n");
+	}
+	cg.refdef.vieworg[1] = atof(token);
+
+	token = COM_ParseExt(&cstr, qfalse);
+	if (!token || !token[0])
+	{
+		CG_Error( "CG_DrawSkyBoxPortal: error parsing skybox configstring\n");
+	}
+	cg.refdef.vieworg[2] = atof(token);
+
+	// setup fog the first time, ignore this part of the configstring after that
+	token = COM_ParseExt(&cstr, qfalse);
+	if (!token || !token[0])
+	{
+		CG_Error( "CG_DrawSkyBoxPortal: error parsing skybox configstring.  No fog state\n");
+	}
+	else 
+	{
+		vec4_t	fogColor;
+		int		fogStart, fogEnd;
+
+		if(atoi(token))
+		{	// this camera has fog
+			token = COM_ParseExt(&cstr, qfalse);
+
+			if (!token || !token[0])
+			{
+				CG_Error( "CG_DrawSkyBoxPortal: error parsing skybox configstring.  No fog[0]\n");
+			}
+			fogColor[0] = atof(token);
+
+			token = COM_ParseExt(&cstr, qfalse);
+			if (!token || !token[0])
+			{
+				CG_Error( "CG_DrawSkyBoxPortal: error parsing skybox configstring.  No fog[1]\n");
+			}
+			fogColor[1] = atof(token);
+
+			token = COM_ParseExt(&cstr, qfalse);
+			if (!token || !token[0])
+			{
+				CG_Error( "CG_DrawSkyBoxPortal: error parsing skybox configstring.  No fog[2]\n");
+			}
+			fogColor[2] = atof(token);
+
+			token = COM_ParseExt(&cstr, qfalse);
+			if (!token || !token[0])
+			{
+				fogStart = 0;
+			}
+			else
+			{
+				fogStart = atoi(token);
+			}
+
+			token = COM_ParseExt(&cstr, qfalse);
+			if (!token || !token[0])
+			{
+				fogEnd = 0;
+			}
+			else
+			{
+				fogEnd = atoi(token);
+			}
+		}
+	}
+
+/*
+	static float lastfov = cg_zoomFov;	// for transitions back from zoomed in modes
+	float fov_x;
+	float fov_y;
+	float x;
+	float f = 0;
+
+	if ( cg.predicted_player_state.pm_type == PM_INTERMISSION )
+	{
+		// if in intermission, use a fixed value
+		fov_x = (cg.overrides.active&CG_OVERRIDE_FOV) ? cg.overrides.fov : cg_fov.value;
+	}
+	else
+	{
+		if (cg.zoomMode)
+		{
+			fov_x = cg_zoomFov;
+		} 
+		else
+		{
+			fov_x = (cg.overrides.active&CG_OVERRIDE_FOV) ? cg.overrides.fov : cg_fov.value;
+			if ( fov_x < 1 ) 
+			{
+				fov_x = 1;
+			}
+			else if ( fov_x > 160 )
+			{
+				fov_x = 160;
+			}
+		}
+
+		// do smooth transitions for zooming
+		if (cg.zoomMode)
+		{ //zoomed/zooming in
+			f = ( cg.time - cg.zoomTime ) / (float)ZOOM_OUT_TIME;
+			if ( f > 1.0 ) {
+				fov_x = cg_zoomFov;
+			} else {
+				fov_x = fov_x + f * ( cg_zoomFov - fov_x );
+			}
+			lastfov = fov_x;
+		}
+		else
+		{ //zooming out
+			f = ( cg.time - cg.zoomTime ) / (float)ZOOM_OUT_TIME;
+			if ( f > 1.0 ) {
+				fov_x = fov_x;
+			} else {
+				fov_x = cg_zoomFov + f * ( fov_x - cg_zoomFov);
+			}
+		}
+	}
+
+	x = cg.refdef.width / tan( fov_x / 360 * M_PI );
+	fov_y = atan2( cg.refdef.height, x );
+	fov_y = fov_y * 360 / M_PI;
+
+	cg.refdef.fov_x = fov_x;
+	cg.refdef.fov_y = fov_y;
+*/
+	//inherit fov and axis from whatever the player is doing (regular, camera overrides or zoomed, whatever)
+	if ( !cg.hyperspace ) 
+	{
+		CG_AddPacketEntities(qtrue); //rww - There was no proper way to put real entities inside the portal view before.
+									 //This will put specially flagged entities in the render.
+		//Add effects flagged to play only in portals
+		theFxScheduler.AddScheduledEffects( true );
+	}
+
+	cg.refdef.rdflags |= RDF_SKYBOXPORTAL;	//mark portal scene specialness
+	cg.refdef.rdflags |= RDF_DRAWSKYBOX;	//drawk portal skies
+
+	cgi_CM_SnapPVS( cg.refdef.vieworg, cg.refdef.areamask );	//fill in my areamask for this view origin
+	// draw the skybox
+	cgi_R_RenderScene( &cg.refdef );
+
+	cg.refdef = backuprefdef;
+}
+
+//----------------------------
+void CG_RunEmplacedWeapon()
+{
+	gentity_t	*player = &g_entities[0],
+				*gun = player->owner;
+
+	// Override the camera when we are locked onto the gun.
+	if ( player 
+		&& gun 
+		&& !gun->bounceCount//not an eweb
+		&& ( player->s.eFlags & EF_LOCKED_TO_WEAPON ))
+	{
+//		float dist = -1; // default distance behind gun
+
+		// don't let the player try and change this
+		cg.renderingThirdPerson = qtrue;
+
+//		cg.refdefViewAngles[PITCH] += cg.overrides.thirdPersonPitchOffset? cg.overrides.thirdPersonPitchOffset: cg_thirdPersonPitchOffset.value;
+//		cg.refdefViewAngles[YAW] += cg.overrides.thirdPersonAngle ? cg.overrides.thirdPersonAngle : cg_thirdPersonAngle.value;;
+
+		AnglesToAxis( cg.refdefViewAngles, cg.refdef.viewaxis );
+
+		// Slide in behind the gun.
+//		if ( gun->delay + 500 > cg.time )
+//		{
+//			dist -= (( gun->delay + 500 ) - cg.time ) * 0.02f;
+//		}
+
+		VectorCopy( gun->pos2, cg.refdef.vieworg );
+		VectorMA( cg.refdef.vieworg, -20.0f, gun->pos3, cg.refdef.vieworg );
+		if ( cg.snap->ps.viewEntity <= 0 || cg.snap->ps.viewEntity >= ENTITYNUM_WORLD )
+		{
+			VectorMA( cg.refdef.vieworg, 35.0f, gun->pos4, cg.refdef.vieworg );
+		}
+
+	}
+}
+
+//=========================================================================
+
+/*
+=================
+CG_DrawActiveFrame
+
+Generates and draws a game scene and status information at the given time.
+=================
+*/
+extern void CG_BuildSolidList( void );
+extern void CG_ClearHealthBarEnts( void );
+extern vec3_t	serverViewOrg;
+static qboolean cg_rangedFogging = qfalse; //so we know if we should go back to normal fog
+void CG_DrawActiveFrame( int serverTime, stereoFrame_t stereoView ) {
+	qboolean	inwater = qfalse;
+
+	cg.time = serverTime;
+
+	// update cvars
+	CG_UpdateCvars();
+
+	// if we are only updating the screen as a loading
+	// pacifier, don't even try to read snapshots
+	if ( cg.infoScreenText[0] != 0 ) {
+		CG_DrawInformation();
+		return;
+	}
+
+	CG_ClearHealthBarEnts();
+
+	CG_RunLightStyles();
+
+	// any looped sounds will be respecified as entities
+	// are added to the render list
+	cgi_S_ClearLoopingSounds();
+
+	// clear all the render lists
+	cgi_R_ClearScene();
+
+	CG_BuildSolidList();
+
+	// set up cg.snap and possibly cg.nextSnap
+	CG_ProcessSnapshots();
+	// if we haven't received any snapshots yet, all
+	// we can draw is the information screen
+	if ( !cg.snap ) {
+		//CG_DrawInformation();
+		return;
+	}
+
+	// make sure the lagometerSample and frame timing isn't done twice when in stereo
+	if ( stereoView != STEREO_RIGHT ) {
+		cg.frametime = cg.time - cg.oldTime;
+		cg.oldTime = cg.time;
+	}
+	// Make sure the helper has the updated time
+	theFxHelper.AdjustTime( cg.frametime );
+
+	// let the client system know what our weapon and zoom settings are
+	//FIXME: should really send forcePowersActive over network onto cg.snap->ps...
+	float speed = cg.refdef.fov_y / 75.0 * ((cg_entities[0].gent->client->ps.forcePowersActive&(1<<FP_SPEED))?1.0f:cg_timescale.value);
+
+//FIXME: junk code, BUG:168
+
+	static bool wasForceSpeed=false;
+	bool isForceSpeed=cg_entities[0].gent->client->ps.forcePowersActive&(1<<FP_SPEED)?true:false;
+	if (isForceSpeed&&!wasForceSpeed)
+	{
+		CGCam_Smooth(0.75f,5000);
+	}
+	wasForceSpeed=isForceSpeed;
+
+//
+ 
+	float mPitchOverride = 0.0f;
+	float mYawOverride = 0.0f;
+	if ( cg.snap->ps.clientNum == 0 )
+	{//pointless check, but..
+		if ( cg_entities[0].gent->s.eFlags & EF_LOCKED_TO_WEAPON ) 
+		{
+			speed *= 0.25f;
+		}
+		Vehicle_t *pVeh = NULL;
+
+		// Mouse turns slower.
+		if ( ( pVeh = G_IsRidingVehicle( &g_entities[0] ) ) != NULL )
+		{
+			if ( pVeh->m_pVehicleInfo->mousePitch )
+			{
+				mPitchOverride = pVeh->m_pVehicleInfo->mousePitch;
+			}
+			if ( pVeh->m_pVehicleInfo->mouseYaw )
+			{
+				mYawOverride = pVeh->m_pVehicleInfo->mouseYaw; 
+			}
+		}
+	}
+	cgi_SetUserCmdValue( cg.weaponSelect, speed, mPitchOverride, mYawOverride );
+
+	// this counter will be bumped for every valid scene we generate
+	cg.clientFrame++;
+
+	// update cg.predicted_player_state
+	CG_PredictPlayerState();
+
+	if (cg.snap->ps.eFlags&EF_HELD_BY_SAND_CREATURE)
+	{
+		cg.zoomMode = 0;
+	}
+	// decide on third person view
+	cg.renderingThirdPerson = cg_thirdPerson.integer 
+								|| (cg.snap->ps.stats[STAT_HEALTH] <= 0) 
+								|| (cg.snap->ps.eFlags&EF_HELD_BY_SAND_CREATURE)
+								|| (g_entities[0].client&&g_entities[0].client->NPC_class==CLASS_ATST
+								|| (cg.snap->ps.weapon == WP_SABER || cg.snap->ps.weapon == WP_MELEE) );
+
+	if ( cg.zoomMode )
+	{
+		// zoomed characters should never do third person stuff??
+		cg.renderingThirdPerson = qfalse;
+	}
+
+	if ( in_camera )
+	{
+		// The camera takes over the view
+		CGCam_RenderScene();
+	}
+	else
+	{		
+		//Finish any fading that was happening
+		CGCam_UpdateFade();
+		// build cg.refdef
+		inwater = CG_CalcViewValues();
+	}
+
+	if (cg.zoomMode)
+	{ //zooming with binoculars or sniper, set the fog range based on the zoom level -rww
+		cg_rangedFogging = qtrue;
+		//smaller the fov the less fog we have between the view and cull dist
+		cgi_R_SetRangeFog(cg.refdef.fov_x*64.0f);
+	}
+	else if (cg_rangedFogging)
+	{ //disable it
+		cg_rangedFogging = qfalse;
+		cgi_R_SetRangeFog(0.0f);
+	}
+
+	cg.refdef.time = cg.time;
+
+	CG_DrawSkyBoxPortal();
+
+	// NOTE: this may completely override the camera
+	CG_RunEmplacedWeapon();
+
+	// first person blend blobs, done after AnglesToAxis
+	if ( !cg.renderingThirdPerson ) {
+		CG_DamageBlendBlob();		
+	}
+
+	// build the render lists
+	if ( !cg.hyperspace ) {
+		CG_AddPacketEntities(qfalse);			// adter calcViewValues, so predicted player state is correct
+		CG_AddMarks();
+		CG_AddLocalEntities();
+		CG_DrawMiscEnts();
+	}
+
+	//check for opaque water
+	// this game does not have opaque water
+	if ( 0 )
+	{
+		vec3_t	camTest;
+		VectorCopy( cg.refdef.vieworg, camTest );
+		camTest[2] += 6;
+		if ( !(CG_PointContents( camTest, 0 )&CONTENTS_SOLID) && !gi.inPVS( cg.refdef.vieworg, camTest ) )
+		{//crossed visible line into another room
+			cg.refdef.vieworg[2] -= 6;
+			//cgi_CM_SnapPVS(cg.refdef.vieworg,cg.snap->areamask);
+		}
+		else
+		{
+			VectorCopy( cg.refdef.vieworg, camTest );
+			camTest[2] -= 6;
+			if ( !(CG_PointContents( camTest, 0 )&CONTENTS_SOLID) && !gi.inPVS( cg.refdef.vieworg, camTest ) )
+			{
+				cg.refdef.vieworg[2] += 6;
+				//cgi_CM_SnapPVS(cg.refdef.vieworg,cg.snap->areamask);
+			}
+			else //if ( inwater )
+			{//extra-special hack... sometimes when crouched in water with first person lightsaber, your PVS is wrong???
+				/*
+				if ( !cg.renderingThirdPerson && (cg.snap->ps.weapon == WP_SABER||cg.snap->ps.weapon == WP_MELEE) )
+				{//pseudo first-person for saber and fists
+					cgi_CM_SnapPVS(cg.refdef.vieworg,cg.snap->areamask);
+				}
+				*/
+			}
+		}
+	}
+	//FIXME: first person crouch-uncrouch STILL FUCKS UP THE AREAMASK!!!
+	//if ( !VectorCompare2( cg.refdef.vieworg, cg.snap->ps.serverViewOrg ) && !gi.inPVS( cg.refdef.vieworg, cg.snap->ps.serverViewOrg ) )
+	{//actual view org and server's view org don't match and aren't same PVS, rebuild the areamask
+		//Com_Printf( S_COLOR_RED"%s != %s\n", vtos(cg.refdef.vieworg), vtos(cg.snap->ps.serverViewOrg) );
+		cgi_CM_SnapPVS( cg.refdef.vieworg, cg.snap->areamask );
+	}
+
+	// Don't draw the in-view weapon when in camera mode
+	if ( !in_camera 
+		&& !cg_pano.integer 
+		&& cg.snap->ps.weapon != WP_SABER
+		&& ( cg.snap->ps.viewEntity == 0 || cg.snap->ps.viewEntity >= ENTITYNUM_WORLD ) )
+	{
+		CG_AddViewWeapon( &cg.predicted_player_state );
+	}
+
+	if ( !cg.hyperspace && fx_freeze.integer<2 ) 
+	{
+		//Add all effects
+		theFxScheduler.AddScheduledEffects( false );
+	}
+
+	// finish up the rest of the refdef
+	if ( cg.testModelEntity.hModel ) {
+		CG_AddTestModel();
+	}
+	
+	memcpy( cg.refdef.areamask, cg.snap->areamask, sizeof( cg.refdef.areamask ) );
+
+	// update audio positions
+	//This is done from the vieworg to get origin for non-attenuated sounds
+	cgi_S_UpdateAmbientSet( CG_ConfigString( CS_AMBIENT_SET ), cg.refdef.vieworg );
+	//NOTE: if we want to make you be able to hear far away sounds with electrobinoculars, add the hacked-in positional offset here (base on fov)
+	/*
+	vec3_t listener_origin;
+	VectorCopy( cg.refdef.vieworg, listener_origin );
+	if ( cg.snap->ps.forcePowersActive&(1<<FP_SEE) 
+		&& cg.snap->ps.forcePowerLevel[FP_SEE] >= FORCE_LEVEL_2 )
+	{//FIXME: if I can see through walls, why not actually move the listener_position through the wall too?
+		if ( g_crosshairEntNum < ENTITYNUM_WORLD
+			&& g_crosshairSameEntTime >= 1000 )
+		{//been looking at this guy for at least a full second
+			gentity_t *crossEnt = &g_entities[g_crosshairEntNum];
+			if ( crossEnt->client && crossEnt->health >= 0 )
+			{//a living client, let's listen in...?
+				//FIXME: lerp our listener_origin to their position over a second or two?
+				VectorCopy( cg_entities[g_crosshairEntNum].lerpOrigin, listener_origin );
+				inwater = qtrue;//do cool reverby effect...?
+			}
+		}
+	}
+	cgi_S_Respatialize( cg.snap->ps.clientNum, listener_origin, cg.refdef.viewaxis, inwater );
+	*/
+	cgi_S_Respatialize( cg.snap->ps.clientNum, cg.refdef.vieworg, cg.refdef.viewaxis, inwater );
+
+	// warning sounds when powerup is wearing off
+	CG_PowerupTimerSounds();
+
+	if ( cg_pano.integer ) {	// let's grab a panorama!
+		cg.levelShot = qtrue;  //hide the 2d
+		VectorClear(cg.refdefViewAngles);		
+		cg.refdefViewAngles[YAW] = -360 * cg_pano.integer/cg_panoNumShots.integer;	//choose angle
+		AnglesToAxis( cg.refdefViewAngles, cg.refdef.viewaxis );
+		CG_DrawActive( stereoView );
+		cg.levelShot = qfalse;
+	} 	else {
+		// actually issue the rendering calls
+		CG_DrawActive( stereoView );
+	}
+	/*
+	if ( in_camera && !cg_skippingcin.integer )
+	{
+		Com_Printf( S_COLOR_GREEN"ang: %s\n", vtos(cg.refdefViewAngles) );
+	}
+	*/
+}
+
diff --git a/code/cgame/cg_weapons.cpp b/code/cgame/cg_weapons.cpp
new file mode 100644
index 0000000..6b36a94
--- /dev/null
+++ b/code/cgame/cg_weapons.cpp
@@ -0,0 +1,3309 @@
+// this line must stay at top so the whole PCH thing works...
+#include "cg_headers.h"
+
+//#include "cg_local.h"
+#include "cg_media.h"
+#include "FxScheduler.h"
+#include "..\game\wp_saber.h"
+#include "..\game\g_vehicles.h"
+
+#include "..\game\anims.h"
+
+#ifdef _IMMERSION
+#include "../ff/ff.h"
+#else
+/////////////////////  this is a bit kludgy, but it only gives access to one
+//							enum table because of the #define. May get changed.
+#define CGAME_ONLY
+#include "../client/fffx.h"
+//
+/////////////////////
+#endif // _IMMERSION
+
+#ifdef _XBOX
+extern bool CL_ExtendSelectTime(void);
+#endif
+
+
+extern void CG_LightningBolt( centity_t *cent, vec3_t origin );
+
+#define	PHASER_HOLDFRAME	2
+extern void G_SoundOnEnt( gentity_t *ent, soundChannel_t channel, const char *soundPath );
+const char *CG_DisplayBoxedText(int iBoxX, int iBoxY, int iBoxWidth, int iBoxHeight, 
+								const char *psText, int iFontHandle, float fScale,
+								const vec4_t v4Color);
+
+/*
+=================
+CG_RegisterWeapon
+
+The server says this item is used on this level
+=================
+*/
+void CG_RegisterWeapon( int weaponNum ) {
+	weaponInfo_t	*weaponInfo;
+	gitem_t			*item, *ammo;
+	char			path[MAX_QPATH];
+	vec3_t			mins, maxs;
+	int				i;
+
+	weaponInfo = &cg_weapons[weaponNum];
+
+	// error checking
+	if ( weaponNum == 0 ) {
+		return;
+	}
+
+	if ( weaponInfo->registered ) {
+		return;
+	}
+
+	// clear out the memory we use
+	memset( weaponInfo, 0, sizeof( *weaponInfo ) );
+	weaponInfo->registered = qtrue;
+
+	// find the weapon in the item list
+	for ( item = bg_itemlist + 1 ; item->classname ; item++ ) {
+		if ( item->giType == IT_WEAPON && item->giTag == weaponNum ) {
+			weaponInfo->item = item;
+			break;
+		}
+	}
+	// if we couldn't find which weapon this is, give us an error
+	if ( !item->classname ) {
+		CG_Error( "Couldn't find item for weapon %s\nNeed to update Items.dat!", weaponData[weaponNum].classname);
+	}
+	CG_RegisterItemVisuals( item - bg_itemlist );
+
+	// set up in view weapon model
+	weaponInfo->weaponModel = cgi_R_RegisterModel( weaponData[weaponNum].weaponMdl );
+	{//in case the weaponmodel isn't _w, precache the _w.glm
+		char weaponModel[64];
+		
+		strcpy (weaponModel, weaponData[weaponNum].weaponMdl);	
+		if (char *spot = strstr(weaponModel, ".md3") ) 
+		{
+			*spot = 0;
+			spot = strstr(weaponModel, "_w");//i'm using the in view weapon array instead of scanning the item list, so put the _w back on
+			if (!spot) 
+			{
+				strcat (weaponModel, "_w");
+			}
+			strcat (weaponModel, ".glm");	//and change to ghoul2
+		}
+		gi.G2API_PrecacheGhoul2Model( weaponModel ); // correct way is item->world_model
+	}
+
+	if ( weaponInfo->weaponModel == NULL )
+	{
+		CG_Error( "Couldn't find weapon model %s for weapon %s\n", weaponData[weaponNum].weaponMdl, weaponData[weaponNum].classname);
+		return;
+	}
+
+	// calc midpoint for rotation
+	cgi_R_ModelBounds( weaponInfo->weaponModel, mins, maxs );
+	for ( i = 0 ; i < 3 ; i++ ) {
+		weaponInfo->weaponMidpoint[i] = mins[i] + 0.5 * ( maxs[i] - mins[i] );
+	}
+
+	// setup the shader we will use for the icon
+	if (weaponData[weaponNum].weaponIcon[0])
+	{
+		weaponInfo->weaponIcon = cgi_R_RegisterShaderNoMip( weaponData[weaponNum].weaponIcon);
+		weaponInfo->weaponIconNoAmmo = cgi_R_RegisterShaderNoMip( va("%s_na",weaponData[weaponNum].weaponIcon));
+	}
+
+	for ( ammo = bg_itemlist + 1 ; ammo->classname ; ammo++ ) {	
+		if ( ammo->giType == IT_AMMO && ammo->giTag == weaponData[weaponNum].ammoIndex) {
+			break;
+		}
+	}
+
+	if ( ammo->classname && ammo->world_model ) {
+		weaponInfo->ammoModel = cgi_R_RegisterModel( ammo->world_model );
+	}
+
+	for (i=0; i< weaponData[weaponNum].numBarrels; i++) {
+		Q_strncpyz( path, weaponData[weaponNum].weaponMdl, MAX_QPATH );
+		COM_StripExtension( path, path );
+		if (i)
+		{
+			char	crap[50];
+			sprintf(crap, "_barrel%d.md3", i+1);
+			strcat( path, crap);
+		}
+		else
+			strcat( path, "_barrel.md3" );
+		weaponInfo->barrelModel[i] = cgi_R_RegisterModel( path );
+	}
+
+
+	// set up the world model for the weapon
+	weaponInfo->weaponWorldModel = cgi_R_RegisterModel( item->world_model );
+	if ( !weaponInfo->weaponWorldModel) {
+		weaponInfo->weaponWorldModel = weaponInfo->weaponModel;
+	}
+
+	// set up the hand that holds the in view weapon - assuming we have one
+	strcpy( path, weaponData[weaponNum].weaponMdl );
+	COM_StripExtension( path, path );
+	strcat( path, "_hand.md3" );
+	weaponInfo->handsModel = cgi_R_RegisterModel( path );
+
+	if ( !weaponInfo->handsModel ) {
+		weaponInfo->handsModel = cgi_R_RegisterModel( "models/weapons2/briar_pistol/briar_pistol_hand.md3" );
+	}
+
+	// register the sounds for the weapon
+	if (weaponData[weaponNum].firingSnd[0]) {
+		weaponInfo->firingSound = cgi_S_RegisterSound( weaponData[weaponNum].firingSnd );
+	}
+	if (weaponData[weaponNum].altFiringSnd[0]) {
+		weaponInfo->altFiringSound = cgi_S_RegisterSound( weaponData[weaponNum].altFiringSnd );
+	}
+	if (weaponData[weaponNum].stopSnd[0]) {
+		weaponInfo->stopSound = cgi_S_RegisterSound( weaponData[weaponNum].stopSnd );
+	}
+	if (weaponData[weaponNum].chargeSnd[0]) {
+		weaponInfo->chargeSound = cgi_S_RegisterSound( weaponData[weaponNum].chargeSnd );
+	}
+	if (weaponData[weaponNum].altChargeSnd[0]) {
+		weaponInfo->altChargeSound = cgi_S_RegisterSound( weaponData[weaponNum].altChargeSnd );
+	}
+	if (weaponData[weaponNum].selectSnd[0]) {
+		weaponInfo->selectSound = cgi_S_RegisterSound( weaponData[weaponNum].selectSnd );
+	}
+
+#ifdef _IMMERSION
+	if (weaponData[weaponNum].firingFrc[0]) {
+		weaponInfo->firingForce = cgi_FF_Register( weaponData[weaponNum].firingFrc, FF_CHANNEL_WEAPON );
+	}
+	if (weaponData[weaponNum].altFiringFrc[0]) {
+		weaponInfo->altFiringForce = cgi_FF_Register( weaponData[weaponNum].altFiringFrc, FF_CHANNEL_WEAPON );
+	}
+	if (weaponData[weaponNum].stopFrc[0]) {
+		weaponInfo->stopForce = cgi_FF_Register( weaponData[weaponNum].stopFrc, FF_CHANNEL_WEAPON );
+	}
+	if (weaponData[weaponNum].chargeFrc[0]) {
+		weaponInfo->chargeForce = cgi_FF_Register( weaponData[weaponNum].chargeFrc, FF_CHANNEL_WEAPON );
+	}
+	if (weaponData[weaponNum].altChargeFrc[0]) {
+		weaponInfo->altChargeForce = cgi_FF_Register( weaponData[weaponNum].altChargeFrc, FF_CHANNEL_WEAPON );
+	}
+	if (weaponData[weaponNum].selectFrc[0]) {
+		weaponInfo->selectForce = cgi_FF_Register( weaponData[weaponNum].selectFrc, FF_CHANNEL_WEAPON );
+	}
+#endif // _IMMERSION
+	// give us missile models if we should
+	if (weaponData[weaponNum].missileMdl[0]) 	{
+		weaponInfo->missileModel = cgi_R_RegisterModel(weaponData[weaponNum].missileMdl );
+	}
+	if (weaponData[weaponNum].alt_missileMdl[0]) 	{
+		weaponInfo->alt_missileModel = cgi_R_RegisterModel(weaponData[weaponNum].alt_missileMdl );
+	}
+	if (weaponData[weaponNum].missileSound[0]) {
+		weaponInfo->missileSound = cgi_S_RegisterSound( weaponData[weaponNum].missileSound );
+	}
+	if (weaponData[weaponNum].alt_missileSound[0]) {
+		weaponInfo->alt_missileSound = cgi_S_RegisterSound( weaponData[weaponNum].alt_missileSound );
+	}
+	if (weaponData[weaponNum].missileHitSound[0]) {
+		weaponInfo->missileHitSound = cgi_S_RegisterSound( weaponData[weaponNum].missileHitSound );
+	}
+	if (weaponData[weaponNum].altmissileHitSound[0]) {
+		weaponInfo->altmissileHitSound = cgi_S_RegisterSound( weaponData[weaponNum].altmissileHitSound );
+	}
+	if ( weaponData[weaponNum].mMuzzleEffect[0] ) 
+	{
+		weaponData[weaponNum].mMuzzleEffectID = theFxScheduler.RegisterEffect( weaponData[weaponNum].mMuzzleEffect );
+	}
+	if ( weaponData[weaponNum].mAltMuzzleEffect[0] ) 
+	{
+		weaponData[weaponNum].mAltMuzzleEffectID = theFxScheduler.RegisterEffect( weaponData[weaponNum].mAltMuzzleEffect );
+	}
+
+	//fixme: don't really need to copy these, should just use directly
+	// give ourselves the functions if we can
+	if (weaponData[weaponNum].func)
+	{
+		weaponInfo->missileTrailFunc = (void (__cdecl *)(struct centity_s *,const struct weaponInfo_s *))weaponData[weaponNum].func;
+	}
+	if (weaponData[weaponNum].altfunc)
+	{
+		weaponInfo->alt_missileTrailFunc = (void (__cdecl *)(struct centity_s *,const struct weaponInfo_s *))weaponData[weaponNum].altfunc;
+	}
+
+	switch ( weaponNum )	//extra client only stuff
+	{
+	case WP_SABER:
+		//saber/force FX
+		theFxScheduler.RegisterEffect( "sparks/spark_nosnd" );//was "sparks/spark"
+		theFxScheduler.RegisterEffect( "sparks/blood_sparks2" );
+		theFxScheduler.RegisterEffect( "force/force_touch" );
+		theFxScheduler.RegisterEffect( "saber/saber_block" );
+		theFxScheduler.RegisterEffect( "saber/saber_cut" );
+		theFxScheduler.RegisterEffect( "blaster/smoke_bolton" );
+		theFxScheduler.RegisterEffect( "saber/fizz" );
+		theFxScheduler.RegisterEffect( "saber/boil" );
+
+		cgs.effects.forceHeal			= theFxScheduler.RegisterEffect( "force/heal" );
+		//cgs.effects.forceInvincibility	= theFxScheduler.RegisterEffect( "force/invin" );
+		cgs.effects.forceConfusion		= theFxScheduler.RegisterEffect( "force/confusion" );
+		cgs.effects.forceLightning		= theFxScheduler.RegisterEffect( "force/lightning" );
+		cgs.effects.forceLightningWide	= theFxScheduler.RegisterEffect( "force/lightningwide" );
+		//new Jedi Academy force power effects
+		cgs.effects.forceDrain		= theFxScheduler.RegisterEffect( "mp/drain" );
+		cgs.effects.forceDrainWide	= theFxScheduler.RegisterEffect( "mp/drainwide" );
+		//cgs.effects.forceDrained	= theFxScheduler.RegisterEffect( "mp/drainhit");
+
+		//saber sounds
+		//cgi_S_RegisterSound( "sound/weapons/saber/saberon.wav" );
+		//cgi_S_RegisterSound( "sound/weapons/saber/enemy_saber_on.wav" );
+		cgi_S_RegisterSound( "sound/weapons/saber/saberonquick.wav" );
+		//cgi_S_RegisterSound( "sound/weapons/saber/saberoff.wav" );
+		//cgi_S_RegisterSound( "sound/weapons/saber/enemy_saber_off.wav" );
+		cgi_S_RegisterSound( "sound/weapons/saber/saberspinoff.wav" );
+		cgi_S_RegisterSound( "sound/weapons/saber/saberoffquick.wav" );
+		for ( i = 1; i < 4; i++ )
+		{
+			cgi_S_RegisterSound( va( "sound/weapons/saber/saberbounce%d.wav", i ) );
+		}
+		for ( i = 1; i < 4; i++ )
+		{
+			cgi_S_RegisterSound( va( "sound/weapons/saber/saberhit%d.wav", i ) );
+		}
+		for ( i = 1; i < 4; i++ )
+		{
+			cgi_S_RegisterSound( va( "sound/weapons/saber/saberhitwall%d.wav", i ) );
+		}
+		for ( i = 1; i < 10; i++ )
+		{
+			cgi_S_RegisterSound( va( "sound/weapons/saber/saberblock%d.wav", i ) );
+		}
+		/*
+		for ( i = 1; i < 6; i++ )
+		{
+			cgi_S_RegisterSound( va( "sound/weapons/saber/saberhum%d.wav", i ) );
+		}
+		*/
+		for ( i = 1; i < 10; i++ )
+		{
+			cgi_S_RegisterSound( va( "sound/weapons/saber/saberhup%d.wav", i ) );
+		}
+		for ( i = 1; i < 4; i++ )
+		{
+			cgi_S_RegisterSound( va( "sound/weapons/saber/saberspin%d.wav", i ) );
+		}
+		cgi_S_RegisterSound( "sound/weapons/saber/saber_catch.wav" );
+		for ( i = 1; i < 4; i++ )
+		{
+			cgi_S_RegisterSound( va( "sound/weapons/saber/bounce%d.wav", i ) );
+		}
+		cgi_S_RegisterSound( "sound/weapons/saber/hitwater.wav" );
+		cgi_S_RegisterSound( "sound/weapons/saber/boiling.wav" );
+		for ( i = 1; i < 4; i++ )
+		{
+			cgi_S_RegisterSound( va( "sound/weapons/saber/rainfizz%d.wav", i ) );
+		}
+		cgi_S_RegisterSound( "sound/movers/objects/saber_slam" );
+#ifdef _IMMERSION
+		cgi_FF_Register( "fffx/weapons/saber/saberon", FF_CHANNEL_WEAPON );
+		cgi_FF_Register( "fffx/weapons/saber/enemy_saber_on", FF_CHANNEL_WEAPON );
+		cgi_FF_Register( "fffx/weapons/saber/saberonquick", FF_CHANNEL_WEAPON );
+		cgi_FF_Register( "fffx/weapons/saber/saberoff", FF_CHANNEL_WEAPON );
+		cgi_FF_Register( "fffx/weapons/saber/enemy_saber_off", FF_CHANNEL_WEAPON );
+		cgi_FF_Register( "fffx/weapons/saber/saberspinoff", FF_CHANNEL_WEAPON );
+		cgi_FF_Register( "fffx/weapons/saber/saberoffquick", FF_CHANNEL_WEAPON );
+		for ( i = 1; i < 4; i++ )
+		{
+			cgi_FF_Register( va( "fffx/weapons/saber/saberbounce%d", i ), FF_CHANNEL_WEAPON );
+		}
+		cgi_FF_Register( "fffx/weapons/saber/saberhit", FF_CHANNEL_WEAPON );
+		for ( i = 1; i < 4; i++ )
+		{
+			cgi_FF_Register( va( "fffx/weapons/saber/saberhitwall%d", i ), FF_CHANNEL_WEAPON );
+		}
+		for ( i = 1; i < 10; i++ )
+		{
+			cgi_FF_Register( va( "fffx/weapons/saber/saberblock%d", i ), FF_CHANNEL_WEAPON );
+		}
+		for ( i = 1; i < 6; i++ )
+		{
+			cgi_FF_Register( va( "fffx/weapons/saber/saberhum%d", i ), FF_CHANNEL_WEAPON );
+		}
+		for ( i = 1; i < 10; i++ )
+		{
+			cgi_FF_Register( va( "fffx/weapons/saber/saberhup%d", i ), FF_CHANNEL_WEAPON );
+		}
+		cgi_FF_Register( "fffx/weapons/saber/hitwater", FF_CHANNEL_WEAPON );
+		cgi_FF_Register( "fffx/weapons/saber/boiling", FF_CHANNEL_WEAPON );
+		for ( i = 1; i < 4; i++ )
+		{
+			cgi_FF_Register( va( "fffx/weapons/saber/rainfizz%d", i ), FF_CHANNEL_WEAPON );
+		}
+#endif // _IMMERSION
+
+		//force sounds
+		cgi_S_RegisterSound( "sound/weapons/force/heal.mp3" );
+		cgi_S_RegisterSound( "sound/weapons/force/speed.mp3" );
+		cgi_S_RegisterSound( "sound/weapons/force/speedloop.mp3" );
+		for ( i = 1; i < 5; i++ )
+		{
+			cgi_S_RegisterSound( va( "sound/weapons/force/heal%d_m.mp3", i ) );
+			cgi_S_RegisterSound( va( "sound/weapons/force/heal%d_f.mp3", i ) );
+		}
+		cgi_S_RegisterSound( "sound/weapons/force/lightning.wav" );
+		cgi_S_RegisterSound( "sound/weapons/force/lightning2.wav" );
+		for ( i = 1; i < 4; i++ )
+		{
+			cgi_S_RegisterSound( va( "sound/weapons/force/lightninghit%d.wav", i ) );
+		}
+		cgi_S_RegisterSound( "sound/weapons/force/push.wav" );
+		cgi_S_RegisterSound( "sound/weapons/force/pull.wav" );
+		cgi_S_RegisterSound( "sound/weapons/force/jump.wav" );
+		cgi_S_RegisterSound( "sound/weapons/force/jumpbuild.wav" );
+		cgi_S_RegisterSound( "sound/weapons/force/grip.mp3" );
+		//new Jedi Academy force sounds
+		cgi_S_RegisterSound( "sound/weapons/force/absorb.mp3" );
+		cgi_S_RegisterSound( "sound/weapons/force/absorbhit.mp3" );
+		cgi_S_RegisterSound( "sound/weapons/force/absorbloop.mp3" );
+		cgi_S_RegisterSound( "sound/weapons/force/protect.mp3" );
+		cgi_S_RegisterSound( "sound/weapons/force/protecthit.mp3" );
+		cgi_S_RegisterSound( "sound/weapons/force/protectloop.mp3" );
+		cgi_S_RegisterSound( "sound/weapons/force/rage.mp3" );
+		cgi_S_RegisterSound( "sound/weapons/force/ragehit.mp3" );
+		cgi_S_RegisterSound( "sound/weapons/force/rageloop.mp3" );
+		cgi_S_RegisterSound( "sound/weapons/force/see.mp3" );
+		cgi_S_RegisterSound( "sound/weapons/force/seeloop.mp3" );
+		cgi_S_RegisterSound( "sound/weapons/force/drain.mp3" );
+		cgi_S_RegisterSound( "sound/weapons/force/drained.mp3" );
+		//force graphics
+		cgs.media.playerShieldDamage = cgi_R_RegisterShader("gfx/misc/personalshield");
+		//cgs.media.forceSightBubble = cgi_R_RegisterShader("gfx/misc/sightbubble");
+		//cgs.media.forceShell = cgi_R_RegisterShader("powerups/forceshell");
+		cgs.media.forceShell = cgi_R_RegisterShader("gfx/misc/forceprotect");
+		cgs.media.sightShell = cgi_R_RegisterShader("powerups/sightshell");
+		cgi_R_RegisterShader( "gfx/2d/jsense" );
+		//force effects - FIXME: only if someone has these powers?
+		theFxScheduler.RegisterEffect( "force/rage2" );
+		//theFxScheduler.RegisterEffect( "force/heal_joint" );
+		theFxScheduler.RegisterEffect( "force/heal2" );
+		theFxScheduler.RegisterEffect( "force/drain_hand" );
+
+		//saber graphics
+		cgs.media.saberBlurShader			= cgi_R_RegisterShader("gfx/effects/sabers/saberBlur");
+		cgs.media.swordTrailShader			= cgi_R_RegisterShader("gfx/effects/sabers/swordTrail");
+		cgs.media.yellowDroppedSaberShader	= cgi_R_RegisterShader("gfx/effects/yellow_glow");
+		cgi_R_RegisterShader( "gfx/effects/saberDamageGlow" );
+		cgi_R_RegisterShader( "gfx/effects/solidWhite_cull" );
+		cgi_R_RegisterShader( "gfx/effects/forcePush" );
+		cgi_R_RegisterShader( "gfx/effects/saberFlare" );
+		cgs.media.redSaberGlowShader		= cgi_R_RegisterShader( "gfx/effects/sabers/red_glow" );
+		cgs.media.redSaberCoreShader		= cgi_R_RegisterShader( "gfx/effects/sabers/red_line" );
+		cgs.media.orangeSaberGlowShader		= cgi_R_RegisterShader( "gfx/effects/sabers/orange_glow" );
+		cgs.media.orangeSaberCoreShader		= cgi_R_RegisterShader( "gfx/effects/sabers/orange_line" );
+		cgs.media.yellowSaberGlowShader		= cgi_R_RegisterShader( "gfx/effects/sabers/yellow_glow" );
+		cgs.media.yellowSaberCoreShader		= cgi_R_RegisterShader( "gfx/effects/sabers/yellow_line" );
+		cgs.media.greenSaberGlowShader		= cgi_R_RegisterShader( "gfx/effects/sabers/green_glow" );
+		cgs.media.greenSaberCoreShader		= cgi_R_RegisterShader( "gfx/effects/sabers/green_line" );
+		cgs.media.blueSaberGlowShader		= cgi_R_RegisterShader( "gfx/effects/sabers/blue_glow" );
+		cgs.media.blueSaberCoreShader		= cgi_R_RegisterShader( "gfx/effects/sabers/blue_line" );
+		cgs.media.purpleSaberGlowShader		= cgi_R_RegisterShader( "gfx/effects/sabers/purple_glow" );
+		cgs.media.purpleSaberCoreShader		= cgi_R_RegisterShader( "gfx/effects/sabers/purple_line" );
+
+		cgs.media.forceCoronaShader			= cgi_R_RegisterShaderNoMip( "gfx/hud/force_swirl" );
+
+		//new Jedi Academy force graphics
+		cgs.media.drainShader				= cgi_R_RegisterShader( "gfx/misc/redLine" );
+
+		//for grip slamming into walls
+		theFxScheduler.RegisterEffect( "env/impact_dustonly" );
+		cgi_S_RegisterSound( "sound/weapons/melee/punch1.mp3" );
+		cgi_S_RegisterSound( "sound/weapons/melee/punch2.mp3" );
+		cgi_S_RegisterSound( "sound/weapons/melee/punch3.mp3" );
+		cgi_S_RegisterSound( "sound/weapons/melee/punch4.mp3" );
+
+		//For kicks with saber staff...
+		theFxScheduler.RegisterEffect( "melee/kick_impact" );
+
+		//Kothos beam
+		cgi_R_RegisterShader( "gfx/misc/dr1" );
+		break;
+
+	case WP_BRYAR_PISTOL:
+	case WP_BLASTER_PISTOL: // enemy version
+	case WP_JAWA:
+		cgs.effects.bryarShotEffect			= theFxScheduler.RegisterEffect( "bryar/shot" );
+											theFxScheduler.RegisterEffect( "bryar/NPCshot" );
+		cgs.effects.bryarPowerupShotEffect	= theFxScheduler.RegisterEffect( "bryar/crackleShot" );
+		cgs.effects.bryarWallImpactEffect	= theFxScheduler.RegisterEffect( "bryar/wall_impact" );
+		cgs.effects.bryarWallImpactEffect2	= theFxScheduler.RegisterEffect( "bryar/wall_impact2" );
+		cgs.effects.bryarWallImpactEffect3	= theFxScheduler.RegisterEffect( "bryar/wall_impact3" );
+		cgs.effects.bryarFleshImpactEffect	= theFxScheduler.RegisterEffect( "bryar/flesh_impact" );
+
+		// Note....these are temp shared effects
+		theFxScheduler.RegisterEffect( "blaster/deflect" );
+		theFxScheduler.RegisterEffect( "blaster/smoke_bolton" ); // note: this will be called game side
+		break;
+
+	case WP_BLASTER:
+		cgs.effects.blasterShotEffect			= theFxScheduler.RegisterEffect( "blaster/shot" );
+													theFxScheduler.RegisterEffect( "blaster/NPCshot" );
+//		cgs.effects.blasterOverchargeEffect		= theFxScheduler.RegisterEffect( "blaster/overcharge" );
+		cgs.effects.blasterWallImpactEffect		= theFxScheduler.RegisterEffect( "blaster/wall_impact" );
+		cgs.effects.blasterFleshImpactEffect	= theFxScheduler.RegisterEffect( "blaster/flesh_impact" );
+		theFxScheduler.RegisterEffect( "blaster/deflect" );
+		theFxScheduler.RegisterEffect( "blaster/smoke_bolton" ); // note: this will be called game side
+		break;
+
+	case WP_DISRUPTOR:
+		theFxScheduler.RegisterEffect( "disruptor/wall_impact" );
+		theFxScheduler.RegisterEffect( "disruptor/flesh_impact" );
+		theFxScheduler.RegisterEffect( "disruptor/alt_miss" );
+		theFxScheduler.RegisterEffect( "disruptor/alt_hit" );
+		theFxScheduler.RegisterEffect( "disruptor/line_cap" );
+		theFxScheduler.RegisterEffect( "disruptor/death_smoke" );
+
+		cgi_R_RegisterShader( "gfx/effects/redLine" );
+		cgi_R_RegisterShader( "gfx/misc/whiteline2" );
+		cgi_R_RegisterShader( "gfx/effects/smokeTrail" );
+		cgi_R_RegisterShader( "gfx/effects/burn" );
+
+		cgi_R_RegisterShaderNoMip( "gfx/2d/crop_charge" );
+
+		// zoom sounds
+		cgi_S_RegisterSound( "sound/weapons/disruptor/zoomstart.wav" );
+		cgi_S_RegisterSound( "sound/weapons/disruptor/zoomend.wav" );
+		cgs.media.disruptorZoomLoop = cgi_S_RegisterSound( "sound/weapons/disruptor/zoomloop.wav" );
+#ifdef _IMMERSION
+		cgs.media.disruptorZoomLoopForce = cgi_FF_Register( "fffx/weapons/disruptor/zoomloop", FF_CHANNEL_WEAPON );
+#endif // _IMMERSION
+
+		// Disruptor gun zoom interface
+		cgs.media.disruptorMask			= cgi_R_RegisterShader( "gfx/2d/cropCircle2");
+		cgs.media.disruptorInsert		= cgi_R_RegisterShader( "gfx/2d/cropCircle");
+		cgs.media.disruptorLight		= cgi_R_RegisterShader( "gfx/2d/cropCircleGlow" );
+		cgs.media.disruptorInsertTick	= cgi_R_RegisterShader( "gfx/2d/insertTick" );
+		break;
+
+	case WP_BOWCASTER:
+		cgs.effects.bowcasterShotEffect		= theFxScheduler.RegisterEffect( "bowcaster/shot" );
+		cgs.effects.bowcasterBounceEffect	= theFxScheduler.RegisterEffect( "bowcaster/bounce_wall" );
+		cgs.effects.bowcasterImpactEffect	= theFxScheduler.RegisterEffect( "bowcaster/explosion" );
+		theFxScheduler.RegisterEffect( "bowcaster/deflect" );
+		break;
+
+	case WP_REPEATER:
+		theFxScheduler.RegisterEffect( "repeater/muzzle_smoke" );
+		theFxScheduler.RegisterEffect( "repeater/projectile" );
+		theFxScheduler.RegisterEffect( "repeater/alt_projectile" );
+		theFxScheduler.RegisterEffect( "repeater/wall_impact" );
+//		theFxScheduler.RegisterEffect( "repeater/alt_wall_impact2" );
+//		theFxScheduler.RegisterEffect( "repeater/flesh_impact" );
+		theFxScheduler.RegisterEffect( "repeater/concussion" );
+		break;
+
+	case WP_DEMP2:
+		theFxScheduler.RegisterEffect( "demp2/projectile" );
+		theFxScheduler.RegisterEffect( "demp2/wall_impact" );
+		theFxScheduler.RegisterEffect( "demp2/flesh_impact" );
+		theFxScheduler.RegisterEffect( "demp2/altDetonate" );
+		cgi_R_RegisterModel( "models/items/sphere.md3" );
+		cgi_R_RegisterShader( "gfx/effects/demp2shell" );
+		break;
+
+	case WP_ATST_MAIN:
+		theFxScheduler.RegisterEffect( "atst/shot" );
+		theFxScheduler.RegisterEffect( "atst/wall_impact" );
+		theFxScheduler.RegisterEffect( "atst/flesh_impact" );
+		theFxScheduler.RegisterEffect( "atst/droid_impact" );
+		break;
+
+	case WP_ATST_SIDE:
+		// For the ALT fire
+		theFxScheduler.RegisterEffect( "atst/side_alt_shot" );
+		theFxScheduler.RegisterEffect( "atst/side_alt_explosion" );
+	
+		// For the regular fire
+		theFxScheduler.RegisterEffect( "atst/side_main_shot" );
+		theFxScheduler.RegisterEffect( "atst/side_main_impact" );
+		break;
+
+	case WP_FLECHETTE:
+		cgs.effects.flechetteShotEffect				= theFxScheduler.RegisterEffect( "flechette/shot" );
+		cgs.effects.flechetteAltShotEffect			= theFxScheduler.RegisterEffect( "flechette/alt_shot" );
+		cgs.effects.flechetteShotDeathEffect		= theFxScheduler.RegisterEffect( "flechette/wall_impact" ); // shot death
+		cgs.effects.flechetteFleshImpactEffect		= theFxScheduler.RegisterEffect( "flechette/flesh_impact" );
+		cgs.effects.flechetteRicochetEffect			= theFxScheduler.RegisterEffect( "flechette/ricochet" );
+
+//		theFxScheduler.RegisterEffect( "flechette/explosion" );
+		theFxScheduler.RegisterEffect( "flechette/alt_blow" );
+		break;
+
+	case WP_ROCKET_LAUNCHER:
+		theFxScheduler.RegisterEffect( "rocket/shot" );
+		theFxScheduler.RegisterEffect( "rocket/explosion" );
+	
+		cgi_R_RegisterShaderNoMip( "gfx/2d/wedge" );
+		cgi_R_RegisterShaderNoMip( "gfx/2d/lock" );
+
+		cgi_S_RegisterSound( "sound/weapons/rocket/lock.wav" );
+		cgi_S_RegisterSound( "sound/weapons/rocket/tick.wav" );
+		break;
+
+	case WP_CONCUSSION:
+		//Primary
+		theFxScheduler.RegisterEffect( "concussion/shot" );
+		theFxScheduler.RegisterEffect( "concussion/explosion" );
+		//Alt
+		theFxScheduler.RegisterEffect( "concussion/alt_miss" );
+		theFxScheduler.RegisterEffect( "concussion/alt_hit" );
+		theFxScheduler.RegisterEffect( "concussion/alt_ring" );
+		//not used (eventually)?
+		cgi_R_RegisterShader( "gfx/effects/blueLine" );
+		cgi_R_RegisterShader( "gfx/misc/whiteline2" );
+		break;
+
+	case WP_THERMAL:
+		cgs.media.grenadeBounce1		= cgi_S_RegisterSound( "sound/weapons/thermal/bounce1.wav" );
+		cgs.media.grenadeBounce2		= cgi_S_RegisterSound( "sound/weapons/thermal/bounce2.wav" );
+
+		cgi_S_RegisterSound( "sound/weapons/thermal/thermloop.wav" );
+		cgi_S_RegisterSound( "sound/weapons/thermal/warning.wav" );
+		theFxScheduler.RegisterEffect( "thermal/explosion" );
+		theFxScheduler.RegisterEffect( "thermal/shockwave" );
+		break;
+
+	case WP_TRIP_MINE:
+		theFxScheduler.RegisterEffect( "tripMine/explosion" );
+		theFxScheduler.RegisterEffect( "tripMine/laser" );
+		theFxScheduler.RegisterEffect( "tripMine/laserImpactGlow" );
+		theFxScheduler.RegisterEffect( "tripMine/glowBit" );
+
+		cgs.media.tripMineStickSound = cgi_S_RegisterSound( "sound/weapons/laser_trap/stick.wav" );
+		cgi_S_RegisterSound( "sound/weapons/laser_trap/warning.wav" );
+		cgi_S_RegisterSound( "sound/weapons/laser_trap/hum_loop.wav" );
+		break;
+
+	case WP_DET_PACK:
+		theFxScheduler.RegisterEffect( "detpack/explosion.efx" );
+		
+		cgs.media.detPackStickSound = cgi_S_RegisterSound( "sound/weapons/detpack/stick.wav" );
+		cgi_R_RegisterModel( "models/weapons2/detpack/detpack.md3" );
+		cgi_S_RegisterSound( "sound/weapons/detpack/warning.wav" );
+		cgi_S_RegisterSound( "sound/weapons/explosions/explode5.wav" );
+		break;
+
+	case WP_EMPLACED_GUN:
+		theFxScheduler.RegisterEffect( "emplaced/shot" );
+		theFxScheduler.RegisterEffect( "emplaced/shotNPC" );
+		theFxScheduler.RegisterEffect( "emplaced/wall_impact" );
+		//E-Web, too, can't tell here which one you wanted, so...
+		theFxScheduler.RegisterEffect( "eweb/shot" );
+		theFxScheduler.RegisterEffect( "eweb/shotNPC" );
+		theFxScheduler.RegisterEffect( "eweb/wall_impact" );
+		theFxScheduler.RegisterEffect( "eweb/flesh_impact" );
+
+		cgi_R_RegisterShader( "models/map_objects/imp_mine/turret_chair_dmg" );
+		cgi_R_RegisterShader( "models/map_objects/imp_mine/turret_chair_on" );
+
+		cgs.media.emplacedHealthBarShader		= cgi_R_RegisterShaderNoMip( "gfx/hud/health_frame" );
+		cgs.media.turretComputerOverlayShader	= cgi_R_RegisterShaderNoMip( "gfx/hud/generic_target" );
+		cgs.media.turretCrossHairShader			= cgi_R_RegisterShaderNoMip( "gfx/2d/panel_crosshair" );
+		break;
+
+	case WP_MELEE:
+	case WP_TUSKEN_STAFF:
+		//TEMP
+		theFxScheduler.RegisterEffect( "melee/punch_impact" );
+		theFxScheduler.RegisterEffect( "melee/kick_impact" );
+		cgi_S_RegisterSound( "sound/weapons/melee/punch1.mp3" );
+		cgi_S_RegisterSound( "sound/weapons/melee/punch2.mp3" );
+		cgi_S_RegisterSound( "sound/weapons/melee/punch3.mp3" );
+		cgi_S_RegisterSound( "sound/weapons/melee/punch4.mp3" );
+		break;
+
+	case WP_STUN_BATON:
+		cgi_R_RegisterShader( "gfx/effects/stunPass" );
+		theFxScheduler.RegisterEffect( "stunBaton/flesh_impact" );
+		//TEMP
+		cgi_S_RegisterSound( "sound/weapons/melee/punch1.mp3" );
+		cgi_S_RegisterSound( "sound/weapons/melee/punch2.mp3" );
+		cgi_S_RegisterSound( "sound/weapons/melee/punch3.mp3" );
+		cgi_S_RegisterSound( "sound/weapons/melee/punch4.mp3" );
+		cgi_S_RegisterSound( "sound/weapons/baton/fire" );
+		break;
+
+	case WP_TURRET:
+		theFxScheduler.RegisterEffect( "turret/shot" );
+		theFxScheduler.RegisterEffect( "turret/wall_impact" );
+		theFxScheduler.RegisterEffect( "turret/flesh_impact" );
+		break;
+
+	case WP_TUSKEN_RIFLE:
+		//melee
+		theFxScheduler.RegisterEffect( "melee/punch_impact" );
+		cgi_S_RegisterSound( "sound/weapons/melee/punch1.mp3" );
+		cgi_S_RegisterSound( "sound/weapons/melee/punch2.mp3" );
+		cgi_S_RegisterSound( "sound/weapons/melee/punch3.mp3" );
+		cgi_S_RegisterSound( "sound/weapons/melee/punch4.mp3" );
+		//fire
+		theFxScheduler.RegisterEffect( "tusken/shot" );
+		theFxScheduler.RegisterEffect( "tusken/hit" );
+		theFxScheduler.RegisterEffect( "tusken/hitwall" );
+
+		break;
+
+	case WP_SCEPTER:
+		//???
+		break;
+
+	case WP_NOGHRI_STICK:
+		//fire
+		theFxScheduler.RegisterEffect( "noghri_stick/shot" );
+		theFxScheduler.RegisterEffect( "noghri_stick/flesh_impact" );
+		//explosion
+		theFxScheduler.RegisterEffect( "noghri_stick/gas_cloud" );
+		//cgi_S_RegisterSound("sound/weapons/noghri/smoke.wav");
+		break;
+
+	case WP_TIE_FIGHTER:
+		theFxScheduler.RegisterEffect( "ships/imp_blastershot" );
+		break;
+	}
+}
+
+/*
+=================
+CG_RegisterItemVisuals
+
+The server says this item is used on this level
+=================
+*/
+void CG_RegisterItemVisuals( int itemNum ) {
+	itemInfo_t		*itemInfo;
+	gitem_t			*item;
+
+	itemInfo = &cg_items[ itemNum ];
+	if ( itemInfo->registered ) {
+		return;
+	}
+
+	item = &bg_itemlist[ itemNum ];
+
+	memset( itemInfo, 0, sizeof( &itemInfo ) );
+	itemInfo->registered = qtrue;
+
+	itemInfo->models = cgi_R_RegisterModel( item->world_model );
+
+	if ( item->icon && item->icon[0] )
+	{
+		itemInfo->icon = cgi_R_RegisterShaderNoMip( item->icon );
+	}
+	else
+	{
+		itemInfo->icon = -1;
+	}
+
+	if ( item->giType == IT_WEAPON ) 
+	{
+		CG_RegisterWeapon( item->giTag );
+	}
+
+	// some ammo types are actually the weapon, like in the case of explosives
+	if ( item->giType == IT_AMMO ) 
+	{
+		switch( item->giTag )
+		{
+		case AMMO_THERMAL:
+			CG_RegisterWeapon( WP_THERMAL );
+			break;
+		case AMMO_TRIPMINE:
+			CG_RegisterWeapon( WP_TRIP_MINE );
+			break;
+		case AMMO_DETPACK:
+			CG_RegisterWeapon( WP_DET_PACK );
+			break;
+		}
+	}
+
+
+	if ( item->giType == IT_HOLDABLE )
+	{
+		// This should be set up to actually work.
+		switch( item->giTag )
+		{
+		case INV_SEEKER:
+			cgi_S_RegisterSound("sound/chars/seeker/misc/fire.wav");
+			cgi_S_RegisterSound( "sound/chars/seeker/misc/hiss.wav");
+			theFxScheduler.RegisterEffect( "env/small_explode");
+
+			CG_RegisterWeapon( WP_BLASTER );
+			break;
+
+		case INV_SENTRY:
+			CG_RegisterWeapon( WP_TURRET );
+			cgi_S_RegisterSound( "sound/player/use_sentry" );
+			break;
+
+		case INV_ELECTROBINOCULARS:
+			// Binocular interface
+			cgs.media.binocularCircle		= cgi_R_RegisterShader( "gfx/2d/binCircle" );
+			cgs.media.binocularMask			= cgi_R_RegisterShader( "gfx/2d/binMask" );
+			cgs.media.binocularArrow		= cgi_R_RegisterShader( "gfx/2d/binSideArrow" );
+			cgs.media.binocularTri			= cgi_R_RegisterShader( "gfx/2d/binTopTri" );
+			cgs.media.binocularStatic		= cgi_R_RegisterShader( "gfx/2d/binocularWindow" );
+			cgs.media.binocularOverlay		= cgi_R_RegisterShader( "gfx/2d/binocularNumOverlay" );
+			break;
+
+		case INV_LIGHTAMP_GOGGLES:
+			// LA Goggles Shaders
+			cgs.media.laGogglesStatic		= cgi_R_RegisterShader( "gfx/2d/lagogglesWindow" );
+			cgs.media.laGogglesMask			= cgi_R_RegisterShader( "gfx/2d/amp_mask" );
+			cgs.media.laGogglesSideBit		= cgi_R_RegisterShader( "gfx/2d/side_bit" );
+			cgs.media.laGogglesBracket		= cgi_R_RegisterShader( "gfx/2d/bracket" );
+			cgs.media.laGogglesArrow		= cgi_R_RegisterShader( "gfx/2d/bracket2" );
+			break;
+
+		case INV_BACTA_CANISTER:
+			for ( int i = 1; i < 5; i++ )
+			{
+				cgi_S_RegisterSound( va( "sound/weapons/force/heal%d_m.mp3", i ) );
+				cgi_S_RegisterSound( va( "sound/weapons/force/heal%d_f.mp3", i ) );
+			}
+			break;
+		}
+	}
+}
+
+
+/*
+========================================================================================
+
+VIEW WEAPON
+
+========================================================================================
+*/
+
+/*
+=================
+CG_MapTorsoToWeaponFrame
+
+animations MUST match the defined pattern!
+the weapon hand animation has 3 anims, 
+	6 frames of attack
+	4 frames of drop
+	5 frames of raise
+
+  if the torso anim does not match these lengths, it will not animate correctly!
+=================
+*/
+extern qboolean ValidAnimFileIndex ( int index );
+int CG_MapTorsoToWeaponFrame( const clientInfo_t *ci, int frame, int animNum, int weaponNum, int firing ) 
+{
+	// we should use the animNum to map a weapon frame instead of relying on the torso frame
+	if ( !ValidAnimFileIndex( ci->animFileIndex ) )
+	{
+		return 0;
+	}
+	animation_t *animations = level.knownAnimFileSets[ci->animFileIndex].animations;
+	int ret=0;
+
+	switch( animNum )
+	{
+	case TORSO_WEAPONREADY1:
+	case TORSO_WEAPONREADY2:
+	case TORSO_WEAPONREADY3:
+	case TORSO_WEAPONREADY4:
+	case TORSO_WEAPONREADY10:
+		ret = 0;
+		break;
+
+	case TORSO_DROPWEAP1:
+		if ( frame >= animations[animNum].firstFrame && frame < animations[animNum].firstFrame + 5 ) 
+		{
+			ret = frame - animations[animNum].firstFrame + 6;
+		}
+		else
+		{
+//			assert(0);
+		}
+		break;
+
+	case TORSO_RAISEWEAP1:
+		if ( frame >= animations[animNum].firstFrame && frame < animations[animNum].firstFrame + 4 ) 
+		{
+			ret = frame - animations[animNum].firstFrame + 6 + 5;
+		}
+		else
+		{
+//			assert(0);
+		}
+		break;
+
+	case BOTH_ATTACK1:
+	case BOTH_ATTACK2:
+	case BOTH_ATTACK3:
+	case BOTH_ATTACK4:
+		if ( frame >= animations[animNum].firstFrame && frame < animations[animNum].firstFrame + 6 ) 
+		{
+			ret = 1 + ( frame - animations[animNum].firstFrame );
+		}
+		else
+		{
+//			assert(0);
+		}
+		break;
+	default:
+		break;
+	}	
+
+	return ret;
+}
+
+/*
+==============
+CG_CalculateWeaponPosition
+==============
+*/
+void CG_CalculateWeaponPosition( vec3_t origin, vec3_t angles ) 
+{
+	float	scale;
+	int		delta;
+	float	fracsin;
+
+	VectorCopy( cg.refdef.vieworg, origin );
+	VectorCopy( cg.refdefViewAngles, angles );
+
+	// on odd legs, invert some angles
+	if ( cg.bobcycle & 1 ) {
+		scale = -cg.xyspeed;
+	} else {
+		scale = cg.xyspeed;
+	}
+
+	// gun angles from bobbing
+	angles[ROLL] += scale * cg.bobfracsin * 0.0075;
+	angles[YAW] += scale * cg.bobfracsin * 0.01;
+	angles[PITCH] += cg.xyspeed * cg.bobfracsin * 0.0075;
+
+	// drop the weapon when landing
+	delta = cg.time - cg.landTime;
+	if ( delta < LAND_DEFLECT_TIME ) {
+		origin[2] += cg.landChange*0.25 * delta / LAND_DEFLECT_TIME;
+	} else if ( delta < LAND_DEFLECT_TIME + LAND_RETURN_TIME ) {
+		origin[2] += cg.landChange*0.25 * 
+			(LAND_DEFLECT_TIME + LAND_RETURN_TIME - delta) / LAND_RETURN_TIME;
+	}
+
+#if 0
+	// drop the weapon when stair climbing
+	delta = cg.time - cg.stepTime;
+	if ( delta < STEP_TIME/2 ) {
+		origin[2] -= cg.stepChange*0.25 * delta / (STEP_TIME/2);
+	} else if ( delta < STEP_TIME ) {
+		origin[2] -= cg.stepChange*0.25 * (STEP_TIME - delta) / (STEP_TIME/2);
+	}
+#endif
+
+	// idle drift
+	scale = /*cg.xyspeed + */40;
+	fracsin = sin( cg.time * 0.001 );
+	angles[ROLL] += scale * fracsin * 0.01;
+	angles[YAW] += scale * fracsin * 0.01;
+	angles[PITCH] += (scale * 0.5f ) * fracsin * 0.01;
+}
+
+/*
+======================
+CG_MachinegunSpinAngle
+======================
+*/
+/*
+#define		SPIN_SPEED	0.9
+#define		COAST_TIME	1000
+static float	CG_MachinegunSpinAngle( centity_t *cent ) {
+	int		delta;
+	float	angle;
+	float	speed;
+
+	delta = cg.time - cent->pe.barrelTime;
+	if ( cent->pe.barrelSpinning ) {
+		angle = cent->pe.barrelAngle + delta * SPIN_SPEED;
+	} else {
+		if ( delta > COAST_TIME ) {
+			delta = COAST_TIME;
+		}
+
+		speed = 0.5 * ( SPIN_SPEED + (float)( COAST_TIME - delta ) / COAST_TIME );
+		angle = cent->pe.barrelAngle + delta * speed;
+	}
+
+	if ( cent->pe.barrelSpinning == !(cent->currentState.eFlags & EF_FIRING) ) {
+		cent->pe.barrelTime = cg.time;
+		cent->pe.barrelAngle = AngleNormalize360( angle );
+		cent->pe.barrelSpinning = !!(cent->currentState.eFlags & EF_FIRING);
+	}
+
+	return angle;
+}
+*/
+/*
+Ghoul2 Insert Start
+*/
+// set up the appropriate ghoul2 info to a refent
+void CG_SetGhoul2InfoRef( refEntity_t *ent, refEntity_t	*s1)
+{
+	ent->ghoul2 = s1->ghoul2;
+	VectorCopy( s1->modelScale, ent->modelScale);
+	ent->radius = s1->radius;
+	VectorCopy( s1->angles, ent->angles);
+}
+
+
+//--------------------------------------------------------------------------
+static void CG_DoMuzzleFlash( centity_t *cent, vec3_t org, vec3_t dir, weaponData_t *wData )
+{
+	// Handle muzzle flashes, really this could just be a qboolean instead of a time.......
+	if ( cent->muzzleFlashTime > 0 )
+	{
+		cent->muzzleFlashTime  = 0;
+		const char *effect = NULL;
+
+//		CG_PositionEntityOnTag( &flash, &gun, gun.hModel, "tag_flash");
+
+		// Try and get a default muzzle so we have one to fall back on
+		if ( wData->mMuzzleEffect[0] )
+		{
+			effect = &wData->mMuzzleEffect[0];
+		}
+		
+		if ( cent->altFire )
+		{
+			// We're alt-firing, so see if we need to override with a custom alt-fire effect
+			if ( wData->mAltMuzzleEffect[0] )
+			{
+				effect = &wData->mAltMuzzleEffect[0];
+			}
+		}
+
+		if (/*( cent->currentState.eFlags & EF_FIRING || cent->currentState.eFlags & EF_ALT_FIRING ) &&*/ effect )
+		{
+			if (( cent->gent && cent->gent->NPC ) || cg.renderingThirdPerson )
+			{
+				theFxScheduler.PlayEffect( effect, org, dir );
+			}
+			else
+			{
+				// We got an effect and we're firing, so let 'er rip.
+				theFxScheduler.PlayEffect( effect, cent->currentState.clientNum );
+			}
+		}
+	}
+	else
+	{
+//		CG_PositionRotatedEntityOnTag( &flash, &gun, weapon->weaponModel, "tag_flash", NULL);
+	}
+}
+
+/*
+Ghoul2 Insert End
+*/
+
+/*
+==============
+CG_AddViewWeapon
+
+Add the weapon, and flash for the player's view
+==============
+*/
+extern int PM_TorsoAnimForFrame( gentity_t *ent, int torsoFrame );
+extern float CG_ForceSpeedFOV( void );
+
+void CG_AddViewWeapon( playerState_t *ps ) 
+{
+	refEntity_t	hand;
+	refEntity_t	flash;
+	vec3_t		angles;
+	const weaponInfo_t	*weapon;
+	weaponData_t  *wData;
+	centity_t	*cent;
+	float		fovOffset, leanOffset;
+
+	// no gun if in third person view
+	if ( cg.renderingThirdPerson )
+		return;
+
+	if ( ps->pm_type == PM_INTERMISSION )
+		return;
+
+	cent = &cg_entities[cg.snap->ps.clientNum];
+
+	if ( ps->eFlags & EF_LOCKED_TO_WEAPON )
+	{
+		return;
+	}
+
+	if ( cent->gent && cent->gent->client && cent->gent->client->ps.forcePowersActive&(1<<FP_LIGHTNING) )
+	{//doing the electrocuting
+		vec3_t temp;//tAng, fxDir, 
+		//VectorSet( tAng, cent->pe.torso.pitchAngle, cent->pe.torso.yawAngle, 0 );
+
+		VectorCopy( cent->gent->client->renderInfo.handLPoint, temp );
+		VectorMA( temp, -5, cg.refdef.viewaxis[0], temp );
+		if ( cent->gent->client->ps.forcePowerLevel[FP_LIGHTNING] > FORCE_LEVEL_2 )
+		{//arc
+			//vec3_t	fxAxis[3];
+			//AnglesToAxis( tAng, fxAxis );
+			theFxScheduler.PlayEffect( cgs.effects.forceLightningWide, temp, cg.refdef.viewaxis );
+		}
+		else
+		{//line
+			//AngleVectors( tAng, fxDir, NULL, NULL );
+			theFxScheduler.PlayEffect( cgs.effects.forceLightning, temp, cg.refdef.viewaxis[0] );
+		}
+	}
+
+	if ( cent->gent && cent->gent->client && cent->gent->client->ps.forcePowersActive&(1<<FP_DRAIN) )
+	{//doing the draining
+		vec3_t temp;//tAng, fxDir, 
+		//VectorSet( tAng, cent->pe.torso.pitchAngle, cent->pe.torso.yawAngle, 0 );
+
+		VectorCopy( cent->gent->client->renderInfo.handLPoint, temp );
+		VectorMA( temp, -5, cg.refdef.viewaxis[0], temp );
+		if ( cent->gent->client->ps.forcePowerLevel[FP_DRAIN] > FORCE_LEVEL_2 )
+		{//arc
+			//vec3_t	fxAxis[3];
+			//AnglesToAxis( tAng, fxAxis );
+			theFxScheduler.PlayEffect( cgs.effects.forceDrainWide, temp, cg.refdef.viewaxis );
+		}
+		else
+		{//line
+			//AngleVectors( tAng, fxDir, NULL, NULL );
+			theFxScheduler.PlayEffect( cgs.effects.forceDrain, temp, cg.refdef.viewaxis[0] );
+		}
+	}
+
+	// allow the gun to be completely removed
+	if ( !cg_drawGun.integer || cg.zoomMode ) 
+	{
+		vec3_t		origin;
+
+		// special hack for lightning guns...
+		VectorCopy( cg.refdef.vieworg, origin );
+		VectorMA( origin, -10, cg.refdef.viewaxis[2], origin );
+		VectorMA( origin, 16, cg.refdef.viewaxis[0], origin );
+// Doesn't look like we'll have lightning style guns.  Clean this crap up when we are sure about this.
+//		CG_LightningBolt( cent, origin );	
+
+		// We should still do muzzle flashes though...
+		CG_RegisterWeapon( ps->weapon );
+		weapon = &cg_weapons[ps->weapon];
+		wData =  &weaponData[ps->weapon];
+
+		CG_DoMuzzleFlash( cent, origin, cg.refdef.viewaxis[0], wData );
+
+		// If we don't update this, the muzzle flash point won't even be updated properly
+		VectorCopy( origin, cent->gent->client->renderInfo.muzzlePoint );
+		VectorCopy( cg.refdef.viewaxis[0], cent->gent->client->renderInfo.muzzleDir );
+
+		cent->gent->client->renderInfo.mPCalcTime = cg.time;
+		return;
+	}
+
+	// drop gun lower at higher fov
+	float actualFOV;
+	if ( (cg.snap->ps.forcePowersActive&(1<<FP_SPEED)) && player->client->ps.forcePowerDuration[FP_SPEED] )//cg.renderingThirdPerson && 
+	{
+		actualFOV = CG_ForceSpeedFOV();
+	}
+	else
+	{
+		actualFOV = (cg.overrides.active&CG_OVERRIDE_FOV) ? cg.overrides.fov : cg_fov.value;
+	}
+
+	if ( actualFOV > 80 ) 
+	{
+		fovOffset = -0.1 * ( actualFOV - 80 );
+	} 
+	else 
+	{
+		fovOffset = 0;
+	}
+
+	if ( cg.snap->ps.leanofs != 0 )
+	{	//add leaning offset
+		leanOffset = cg.snap->ps.leanofs * 0.25f;
+		fovOffset += abs(cg.snap->ps.leanofs) * -0.1f;
+	}
+	else
+	{
+		leanOffset = 0;
+	}
+
+	CG_RegisterWeapon( ps->weapon );
+	weapon = &cg_weapons[ps->weapon];
+	wData =  &weaponData[ps->weapon];
+
+	memset (&hand, 0, sizeof(hand));
+
+	if ( ps->weapon == WP_STUN_BATON || ps->weapon == WP_CONCUSSION )
+	{
+		cgi_S_AddLoopingSound( cent->currentState.number, 
+			cent->lerpOrigin, 
+			vec3_origin, 
+			weapon->firingSound );
+	}
+
+	// set up gun position
+	CG_CalculateWeaponPosition( hand.origin, angles );
+
+	//VectorMA( hand.origin, cg_gun_x.value, cg.refdef.viewaxis[0], hand.origin );
+	//VectorMA( hand.origin, (cg_gun_y.value+leanOffset), cg.refdef.viewaxis[1], hand.origin );
+	//VectorMA( hand.origin, (cg_gun_z.value+fovOffset), cg.refdef.viewaxis[2], hand.origin );
+	VectorMA( hand.origin, 0, cg.refdef.viewaxis[0], hand.origin );
+	VectorMA( hand.origin, (0+leanOffset), cg.refdef.viewaxis[1], hand.origin );
+	VectorMA( hand.origin, (0+fovOffset), cg.refdef.viewaxis[2], hand.origin );
+
+	AnglesToAxis( angles, hand.axis );
+
+	// map torso animations to weapon animations
+#ifndef FINAL_BUILD
+	if ( cg_gun_frame.integer ) 
+	{
+		// development tool
+		hand.frame = hand.oldframe = cg_gun_frame.integer;
+		hand.backlerp = 0;
+	} 
+	else 
+#endif
+	{
+		// get clientinfo for animation map
+		const clientInfo_t	*ci = &cent->gent->client->clientInfo;
+		int torsoAnim = cent->gent->client->ps.torsoAnim;//pe.torso.animationNumber;
+		float currentFrame;
+		int startFrame,endFrame,flags;
+		float animSpeed;
+		if (cent->gent->lowerLumbarBone>=0&& gi.G2API_GetBoneAnimIndex(&cent->gent->ghoul2[cent->gent->playerModel], cent->gent->lowerLumbarBone, cg.time, &currentFrame, &startFrame, &endFrame, &flags, &animSpeed,0) )
+		{
+			hand.oldframe = CG_MapTorsoToWeaponFrame( ci,floor(currentFrame), torsoAnim, cent->currentState.weapon, ( cent->currentState.eFlags & EF_FIRING ) );
+			hand.frame = CG_MapTorsoToWeaponFrame( ci,ceil(currentFrame), torsoAnim, cent->currentState.weapon, ( cent->currentState.eFlags & EF_FIRING ) );
+			hand.backlerp=1.0f-(currentFrame-floor(currentFrame));
+			if ( cg_debugAnim.integer == 1 && cent->currentState.clientNum == 0 )
+			{
+				Com_Printf( "Torso frame %d to %d makes Weapon frame %d to %d\n", cent->pe.torso.oldFrame,  cent->pe.torso.frame, hand.oldframe, hand.frame );
+			}
+		}
+		else
+		{
+//			assert(0); // no idea what to do here
+			hand.oldframe=0;
+			hand.frame=0;
+			hand.backlerp=0.0f;
+		}
+	}
+
+	// add the weapon(s) - FIXME: allow for 2 weapons generically, not just 2 sabers?
+	int	numSabers = 1;
+	if ( cent->gent->client->ps.dualSabers )
+	{
+		numSabers = 2;
+	}
+	for ( int saberNum = 0; saberNum < numSabers; saberNum++ )
+	{
+		refEntity_t	gun;
+		memset (&gun, 0, sizeof(gun));
+
+		gun.hModel = weapon->weaponModel;
+		if (!gun.hModel) 
+		{
+			return;
+		}
+
+		AnglesToAxis( angles, gun.axis );
+		CG_PositionEntityOnTag( &gun, &hand, weapon->handsModel, "tag_weapon");
+
+		gun.renderfx = RF_DEPTHHACK | RF_FIRST_PERSON;
+
+	//---------
+		// OK, we are making an assumption here that if we have the phaser that it is always on....
+		//FIXME: if saberInFlight, need to draw empty hand guiding it
+		if ( cent->gent && cent->gent->client && cent->currentState.weapon == WP_SABER )
+		{
+			vec3_t org_, axis_[3];
+
+			for ( int bladeNum = 0; bladeNum < cent->gent->client->ps.saber[saberNum].numBlades; bladeNum++ )
+			{
+				//FIXME: need to get from tag_flash2 for saberstaff's second blade?
+				CG_GetTagWorldPosition( &gun, "tag_flash", org_, axis_ );
+				//loop this and do for both blades
+				if ( cent->gent->client->ps.saber[0].blade[0].active && cent->gent->client->ps.saber[0].blade[0].length < cent->gent->client->ps.saber[0].blade[0].lengthMax )
+				{
+					cent->gent->client->ps.saber[0].blade[0].length += cg.frametime*0.03;
+					if ( cent->gent->client->ps.saber[0].blade[0].length > cent->gent->client->ps.saber[0].blade[0].lengthMax )
+					{
+						cent->gent->client->ps.saber[0].blade[0].length = cent->gent->client->ps.saber[0].blade[0].lengthMax;
+					}
+				}
+		//		FX_Saber( org_, axis_[0], cent->gent->client->ps.saberLength, 2.0 + crandom() * 0.2f, cent->gent->client->ps.saberColor );
+				if ( saberNum == 0 && bladeNum == 0 )
+				{
+					VectorCopy( axis_[0], cent->gent->client->renderInfo.muzzleDir );
+				}
+				else
+				{//need these points stored here when in 1st person saber
+					VectorCopy(org_, cent->gent->client->ps.saber[saberNum].blade[bladeNum].muzzlePoint);
+				}
+				VectorCopy( axis_[0], cent->gent->client->ps.saber[saberNum].blade[bladeNum].muzzleDir );
+			}
+		}
+		//---------
+
+		//	CG_AddRefEntityWithPowerups( &gun, cent->currentState.powerups, cent->gent );
+			cgi_R_AddRefEntityToScene( &gun );
+
+	/*	if ( ps->weapon == WP_STUN_BATON )
+		{
+			gun.shaderRGBA[0] = gun.shaderRGBA[1] = gun.shaderRGBA[2] = 25;
+
+			gun.customShader = cgi_R_RegisterShader( "gfx/effects/stunPass" );
+			gun.renderfx = RF_RGB_TINT | RF_FIRST_PERSON | RF_DEPTHHACK;
+			cgi_R_AddRefEntityToScene( &gun );
+		}
+	*/
+		// add the spinning barrel[s]
+		for (int i = 0; (i < wData->numBarrels); i++)	
+		{
+			refEntity_t	barrel;
+			memset( &barrel, 0, sizeof( barrel ) );
+			barrel.hModel = weapon->barrelModel[i];
+
+			//VectorCopy( parent->lightingOrigin, barrel.lightingOrigin );
+			//barrel.shadowPlane = parent->shadowPlane;
+			barrel.renderfx = gun.renderfx;
+			angles[YAW] = 0;
+			angles[PITCH] = 0;
+	//		if ( ps->weapon == WP_TETRION_DISRUPTOR) {
+	//			angles[ROLL] = CG_MachinegunSpinAngle( cent );
+	//		} else {
+				angles[ROLL] = 0;//CG_MachinegunSpinAngle( cent );
+	//		}
+
+			AnglesToAxis( angles, barrel.axis );
+			if (!i) 
+			{
+				CG_PositionRotatedEntityOnTag( &barrel, &hand, weapon->handsModel, "tag_barrel", NULL );
+			} else 
+			{
+				CG_PositionRotatedEntityOnTag( &barrel, &hand, weapon->handsModel, va("tag_barrel%d",i+1), NULL );
+			}
+
+			cgi_R_AddRefEntityToScene( &barrel );
+		}
+
+		memset (&flash, 0, sizeof(flash));
+
+		// Seems like we should always do this in case we have an animating muzzle flash....that way we can always store the correct muzzle dir, etc.
+		CG_PositionEntityOnTag( &flash, &gun, gun.hModel, "tag_flash");
+
+		CG_DoMuzzleFlash( cent, flash.origin, flash.axis[0], wData );
+
+		if ( cent->gent && cent->gent->client )
+		{
+			if ( saberNum == 0 )
+			{
+				VectorCopy(flash.origin, cent->gent->client->renderInfo.muzzlePoint);
+				VectorCopy(flash.axis[0], cent->gent->client->renderInfo.muzzleDir);
+			}
+	//		VectorNormalize( cent->gent->client->renderInfo.muzzleDir );
+			cent->gent->client->renderInfo.mPCalcTime = cg.time;
+
+			//CG_LightningBolt( cent, flash.origin ); 
+		}
+	}
+
+	// Do special charge bits
+	//-----------------------
+	if (( ps->weaponstate == WEAPON_CHARGING_ALT && ps->weapon == WP_BRYAR_PISTOL ) 
+			|| ( ps->weaponstate == WEAPON_CHARGING_ALT && ps->weapon == WP_BLASTER_PISTOL ) 
+			|| ( ps->weapon == WP_BOWCASTER && ps->weaponstate == WEAPON_CHARGING )
+			|| ( ps->weapon == WP_DEMP2 && ps->weaponstate == WEAPON_CHARGING_ALT ))
+	{
+		int		shader = 0;
+		float	val = 0.0f, scale = 1.0f;
+		vec3_t	WHITE	= {1.0f,1.0f,1.0f};
+
+		if ( ps->weapon == WP_BRYAR_PISTOL
+			|| ps->weapon == WP_BLASTER_PISTOL )
+		{
+			// Hardcoded max charge time of 1 second
+			val = ( cg.time - ps->weaponChargeTime ) * 0.001f;
+			shader = cgi_R_RegisterShader( "gfx/effects/bryarFrontFlash" );
+		}
+		else if ( ps->weapon == WP_BOWCASTER )
+		{
+			// Hardcoded max charge time of 1 second
+			val = ( cg.time - ps->weaponChargeTime ) * 0.001f;
+			shader = cgi_R_RegisterShader( "gfx/effects/greenFrontFlash" );
+		}
+		else if ( ps->weapon == WP_DEMP2 )
+		{
+			// Hardcoded max charge time of 1 second
+			val = ( cg.time - ps->weaponChargeTime ) * 0.001f;
+			shader = cgi_R_RegisterShader( "gfx/misc/lightningFlash" );
+			scale = 1.75f;
+		}
+
+		if ( val < 0.0f )
+		{
+			val = 0.0f;
+		}
+		else if ( val > 1.0f )
+		{
+			val = 1.0f;
+			CGCam_Shake( 0.1f, 100 );
+		}
+		else
+		{
+			CGCam_Shake( val * val * 0.3f, 100 );
+		}
+
+		val += random() * 0.5f;
+
+		FX_AddSprite( flash.origin, NULL, NULL, 3.0f * val * scale, 0.0f, 0.7f, 0.7f, WHITE, WHITE, random() * 360, 0.0f, 1.0f, shader, FX_USE_ALPHA | FX_DEPTH_HACK );
+	}
+
+	// Check if the heavy repeater is finishing up a sustained burst
+	//-------------------------------
+	if ( ps->weapon == WP_REPEATER && ps->weaponstate == WEAPON_FIRING )
+	{
+		if ( cent->gent && cent->gent->client && cent->gent->client->ps.weaponstate != WEAPON_FIRING )
+		{
+			int	ct = 0;
+
+			// the more continuous shots we've got, the more smoke we spawn
+			if ( cent->gent->client->ps.weaponShotCount > 60 ) {
+				ct = 5;
+			}
+			else if ( cent->gent->client->ps.weaponShotCount > 35 ) {
+				ct = 3;
+			}
+			else if ( cent->gent->client->ps.weaponShotCount > 15 ) {
+				ct = 1;
+			}
+
+			for ( int i = 0; i < ct; i++ )
+			{
+				theFxScheduler.PlayEffect( "repeater/muzzle_smoke", cent->currentState.clientNum );
+			}
+
+			cent->gent->client->ps.weaponShotCount = 0;
+		}
+	}
+}
+
+/*
+==============================================================================
+
+WEAPON SELECTION
+
+==============================================================================
+*/
+
+/*
+===================
+CG_WeaponCheck
+===================
+*/
+int CG_WeaponCheck( int weaponIndex ) 
+{
+	int				value;
+	
+	if ( weaponIndex == WP_SABER)
+	{
+		return qtrue;
+	}
+
+
+	value = weaponData[weaponIndex].energyPerShot < weaponData[weaponIndex].altEnergyPerShot 
+							? weaponData[weaponIndex].energyPerShot 
+							: weaponData[weaponIndex].altEnergyPerShot;
+
+	if( !cg.snap )
+	{
+		return qfalse;
+	}
+	
+	// check how much energy(ammo) it takes to fire this weapon against how much ammo we have
+	if ( value > cg.snap->ps.ammo[weaponData[weaponIndex].ammoIndex] )
+	{
+		value = qfalse;
+	}
+	else
+	{
+		value = qtrue;
+	}
+
+	return value;
+}
+
+int cgi_UI_GetItemText(char *menuFile,char *itemName, char *text);
+
+char *weaponDesc[13] = 
+{
+"SABER_DESC",
+"NEW_BLASTER_PISTOL_DESC",
+"BLASTER_RIFLE_DESC",
+"DISRUPTOR_RIFLE_DESC",
+"BOWCASTER_DESC",
+"HEAVYREPEATER_DESC",
+"DEMP2_DESC",
+"FLECHETTE_DESC",
+"MERR_SONN_DESC",
+"THERMAL_DETONATOR_DESC",
+"TRIP_MINE_DESC",
+"DET_PACK_DESC",
+"CONCUSSION_DESC",
+};
+
+/*
+===================
+CG_DrawDataPadWeaponSelect
+
+Allows user to cycle through the various weapons currently owned and view the description
+===================
+*/
+void CG_DrawDataPadWeaponSelect( void ) 
+{
+	int				i;
+	int				weaponBitFlag,weaponCount,weaponSelectI;
+	int				holdX;
+	int				sideLeftIconCnt,sideRightIconCnt;
+	int				holdCount,iconCnt;
+	char			text[1024]={0};
+	qboolean drewConc = qfalse;
+
+	// showing weapon select clears pickup item display, but not the blend blob
+	cg.itemPickupTime = 0;
+
+	weaponBitFlag = cg.snap->ps.stats[ STAT_WEAPONS ];
+
+	// count the number of weapons owned
+	weaponCount = 0;
+	for ( i = 1 ; i < 16 ; i++ ) 
+	{
+		if ( weaponBitFlag & ( 1 << i ) ) 
+		{
+			weaponCount++;
+		}
+	}
+
+	if (weaponCount == 0)	// If no weapons, don't display
+	{
+		return;
+	}
+
+	const short sideMax = 3;	// Max number of icons on the side
+
+	// Calculate how many icons will appear to either side of the center one
+	holdCount = weaponCount - 1;	// -1 for the center icon
+	if (holdCount == 0)			// No icons to either side
+	{
+		sideLeftIconCnt = 0;
+		sideRightIconCnt = 0;
+	}
+	else if (weaponCount > (2*sideMax))	// Go to the max on each side
+	{
+		sideLeftIconCnt = sideMax;
+		sideRightIconCnt = sideMax;
+	}
+	else							// Less than max, so do the calc
+	{
+		sideLeftIconCnt = holdCount/2;
+		sideRightIconCnt = holdCount - sideLeftIconCnt;
+	}
+
+	// This seems to be a problem if datapad comes up too early
+	if (cg.DataPadWeaponSelect<FIRST_WEAPON)
+	{
+		cg.DataPadWeaponSelect = FIRST_WEAPON;
+	}
+	else if (cg.DataPadWeaponSelect>13)
+	{
+		cg.DataPadWeaponSelect = 13;
+	}
+
+	// What weapon does the player currently have selected
+	if ( cg.DataPadWeaponSelect == WP_CONCUSSION )
+	{
+		weaponSelectI = WP_FLECHETTE;
+	}
+	else
+	{
+		weaponSelectI = cg.DataPadWeaponSelect - 1;
+	}
+	if (weaponSelectI<1)
+	{
+		weaponSelectI = 13;
+	}	
+
+	const int smallIconSize = 40;
+	const int bigIconSize = 80;
+	const int bigPad = 64;
+	const int pad = 32;
+
+	const int centerXPos = 320;
+	const int graphicYPos = 340;
+
+
+	// Left side ICONS
+	// Work backwards from current icon
+	holdX = centerXPos - ((bigIconSize/2) + bigPad + smallIconSize);
+
+	cgi_R_SetColor( colorTable[CT_WHITE] );
+	for (iconCnt=1;iconCnt<(sideLeftIconCnt+1);weaponSelectI--)
+	{
+		if ( weaponSelectI == WP_CONCUSSION )
+		{
+			weaponSelectI--;
+		}
+		else if ( weaponSelectI == WP_FLECHETTE && !drewConc && cg.DataPadWeaponSelect != WP_CONCUSSION )
+		{
+			weaponSelectI = WP_CONCUSSION;
+		}
+
+		if (weaponSelectI<1)
+		{
+			weaponSelectI = 13;
+		}
+
+		if ( !(weaponBitFlag & ( 1 << weaponSelectI )))	// Does he have this weapon?
+		{
+			if ( weaponSelectI == WP_CONCUSSION )
+			{
+				drewConc = qtrue;
+				weaponSelectI = WP_ROCKET_LAUNCHER;
+			}
+			continue;
+		}
+
+		++iconCnt;					// Good icon
+
+		if (weaponData[weaponSelectI].weaponIcon[0])
+		{
+			weaponInfo_t	*weaponInfo;
+			CG_RegisterWeapon( weaponSelectI );	
+			weaponInfo = &cg_weapons[weaponSelectI];
+
+			if (!CG_WeaponCheck(weaponSelectI))
+			{
+				CG_DrawPic( holdX, graphicYPos, smallIconSize, smallIconSize, weaponInfo->weaponIconNoAmmo );
+			}
+			else
+			{
+				CG_DrawPic( holdX, graphicYPos, smallIconSize, smallIconSize, weaponInfo->weaponIcon );
+			}
+
+			holdX -= (smallIconSize+pad);
+		}
+
+		if ( weaponSelectI == WP_CONCUSSION )
+		{
+			drewConc = qtrue;
+			weaponSelectI = WP_ROCKET_LAUNCHER;
+		}
+	}
+
+	// Current Center Icon
+	cgi_R_SetColor(colorTable[CT_WHITE]);
+
+	if (weaponData[cg.DataPadWeaponSelect].weaponIcon[0])
+	{
+		weaponInfo_t	*weaponInfo;
+		CG_RegisterWeapon( cg.DataPadWeaponSelect );	
+		weaponInfo = &cg_weapons[cg.DataPadWeaponSelect];
+
+			// Draw graphic to show weapon has ammo or no ammo
+		if (!CG_WeaponCheck(cg.DataPadWeaponSelect))
+		{
+			CG_DrawPic( centerXPos-(bigIconSize/2), (graphicYPos-((bigIconSize-smallIconSize)/2))+10, bigIconSize, bigIconSize, weaponInfo->weaponIconNoAmmo );
+		}
+		else
+		{
+			CG_DrawPic( centerXPos-(bigIconSize/2), (graphicYPos-((bigIconSize-smallIconSize)/2))+10, bigIconSize, bigIconSize, weaponInfo->weaponIcon );
+		}
+	}
+
+	if ( cg.DataPadWeaponSelect == WP_CONCUSSION )
+	{
+		weaponSelectI = WP_ROCKET_LAUNCHER;
+	}
+	else
+	{
+		weaponSelectI = cg.DataPadWeaponSelect + 1;
+	}
+
+	if (weaponSelectI> 13)
+	{
+		weaponSelectI = 1;
+	}
+
+	// Right side ICONS
+	// Work forwards from current icon
+	cgi_R_SetColor(colorTable[CT_WHITE]);
+	holdX = centerXPos + (bigIconSize/2) + bigPad;
+	for (iconCnt=1;iconCnt<(sideRightIconCnt+1);weaponSelectI++)
+	{
+		if ( weaponSelectI == WP_CONCUSSION )
+		{
+			weaponSelectI++;
+		}
+		else if ( weaponSelectI == WP_ROCKET_LAUNCHER && !drewConc && cg.DataPadWeaponSelect != WP_CONCUSSION )
+		{
+			weaponSelectI = WP_CONCUSSION;
+		}
+		if (weaponSelectI>13)
+		{
+			weaponSelectI = 1;
+		}
+
+		if ( !(weaponBitFlag & ( 1 << weaponSelectI )))	// Does he have this weapon?
+		{
+			if ( weaponSelectI == WP_CONCUSSION )
+			{
+				drewConc = qtrue;
+				weaponSelectI = WP_FLECHETTE;
+			}
+			continue;
+		}
+
+		++iconCnt;					// Good icon
+
+		if (weaponData[weaponSelectI].weaponIcon[0])
+		{
+			weaponInfo_t	*weaponInfo;
+			CG_RegisterWeapon( weaponSelectI );	
+			weaponInfo = &cg_weapons[weaponSelectI];
+
+			// Draw graphic to show weapon has ammo or no ammo
+			if (!CG_WeaponCheck(i))
+			{
+				CG_DrawPic( holdX, graphicYPos, smallIconSize, smallIconSize, weaponInfo->weaponIconNoAmmo );
+			}
+			else
+			{
+				CG_DrawPic( holdX, graphicYPos, smallIconSize, smallIconSize, weaponInfo->weaponIcon );
+			}
+
+
+			holdX += (smallIconSize+pad);
+		}
+		if ( weaponSelectI == WP_CONCUSSION )
+		{
+			drewConc = qtrue;
+			weaponSelectI = WP_FLECHETTE;
+		}
+	}
+
+	// Print the weapon description
+	cgi_SP_GetStringTextString( va("SP_INGAME_%s",weaponDesc[cg.DataPadWeaponSelect-1]), text, sizeof(text) );
+
+	const short textboxXPos = 40;
+	const short textboxYPos = 60;
+	const int	textboxWidth = 560;
+	const int	textboxHeight = 300;
+	const float	textScale = 1.0f;
+
+	if (text)
+	{
+		CG_DisplayBoxedText(
+			textboxXPos, textboxYPos,
+			textboxWidth, textboxHeight,
+			text,
+			4,
+			textScale,
+			colorTable[CT_WHITE]	
+				);
+	}
+
+	cgi_R_SetColor( NULL );
+}
+
+/*
+===================
+CG_DrawDataPadIconBackground
+
+Draw the proper background graphic for the icons being displayed on the datapad
+===================
+*/
+void CG_DrawDataPadIconBackground(const int backgroundType)
+{
+//	const int		graphicXPos = 40;
+//	const int		graphicYPos = 340;
+//	const short		graphicHeight = 60;
+//	const short		graphicWidth = 560;
+//	qhandle_t		background;
+
+/*
+	if (backgroundType == ICON_INVENTORY)	// Display inventory background?
+	{
+		background = cgs.media.inventoryIconBackground;
+	}
+	else if (backgroundType == ICON_WEAPONS)	// Display weapon background?
+	{
+		background = cgs.media.weaponIconBackground;
+	}
+	else 	// Display force background?
+	{
+		background = cgs.media.forceIconBackground;
+	}
+
+	cgi_R_SetColor( colorTable[CT_WHITE] );	// Let the graphic set the color
+
+	CG_DrawPic( graphicXPos, 
+		graphicYPos+(graphicHeight/2), 
+		graphicWidth, 
+		-graphicHeight, 
+		background);	// Top half
+
+	CG_DrawPic( graphicXPos, 
+		graphicYPos+(graphicHeight/2),
+		graphicWidth, 
+		graphicHeight, 
+		background);	// Bottom half
+
+*/
+}
+
+/*
+===============
+SetWeaponSelectTime
+===============
+*/
+void SetWeaponSelectTime(void)
+{
+
+	if (((cg.inventorySelectTime + WEAPON_SELECT_TIME) > cg.time) ||	// The Inventory HUD was currently active to just swap it out with Force HUD
+		((cg.forcepowerSelectTime + WEAPON_SELECT_TIME) > cg.time))		// The Force HUD was currently active to just swap it out with Force HUD
+	{
+		cg.inventorySelectTime = 0;
+		cg.forcepowerSelectTime = 0;
+		cg.weaponSelectTime = cg.time + 130.0f;
+	}
+	else
+	{
+		cg.weaponSelectTime = cg.time;
+	}
+}
+
+/*
+===================
+CG_DrawWeaponSelect
+===================
+*/
+extern Vehicle_t *G_IsRidingVehicle( gentity_t *ent );
+extern bool G_IsRidingTurboVehicle( gentity_t *ent );
+
+void CG_DrawWeaponSelect( void ) 
+{
+	int		i;
+	int		bits;
+	int		count;
+	int		smallIconSize,bigIconSize;
+	int		holdX,x,y,x2,y2,w2,h2,pad;
+	int		sideLeftIconCnt,sideRightIconCnt;
+	int		sideMax,holdCount,iconCnt;
+	int		height;
+	vec4_t	calcColor;
+	vec4_t	textColor = { .875f, .718f, .121f, 1.0f };
+	int		yOffset = 0;
+	bool	isOnVeh = false;
+	qboolean drewConc = qfalse;
+
+	if ((cg.weaponSelectTime+WEAPON_SELECT_TIME)<cg.time)	// Time is up for the HUD to display
+	{
+		return;
+	}
+
+	// don't display if dead
+	if ( cg.predicted_player_state.stats[STAT_HEALTH] <= 0 ) 
+	{
+		return; 
+	}
+
+#ifdef _XBOX
+	if(CL_ExtendSelectTime()) {
+		cg.weaponSelectTime = cg.time;
+	}
+
+	yOffset = -36;
+#endif
+
+	cg.iconSelectTime = cg.weaponSelectTime;
+
+	// showing weapon select clears pickup item display, but not the blend blob
+	//cg.itemPickupTime = 0;
+
+	bits = cg.snap->ps.stats[ STAT_WEAPONS ];
+
+	// count the number of weapons owned
+	count = 0;
+	isOnVeh = (G_IsRidingVehicle(cg_entities[0].gent)!=0);
+ 	for ( i = 1 ; i < MAX_PLAYER_WEAPONS ; i++ ) 
+	{
+		if ((bits & ( 1 << i ))  &&
+			(!isOnVeh || i==WP_NONE || i==WP_SABER || i==WP_BLASTER)) 
+		{
+			count++;
+		}
+	}
+
+	if (count == 0)	// If no weapons, don't display
+	{
+		return;
+	}
+
+	sideMax = 3;	// Max number of icons on the side
+
+	// Calculate how many icons will appear to either side of the center one
+	holdCount = count - 1;	// -1 for the center icon
+	if (holdCount == 0)			// No icons to either side
+	{
+		sideLeftIconCnt = 0;
+		sideRightIconCnt = 0;
+	}
+	else if (count > (2*sideMax))	// Go to the max on each side
+	{
+		sideLeftIconCnt = sideMax;
+		sideRightIconCnt = sideMax;
+	}
+	else							// Less than max, so do the calc
+	{
+		sideLeftIconCnt = holdCount/2;
+		sideRightIconCnt = holdCount - sideLeftIconCnt;
+	}
+
+	if ( cg.weaponSelect == WP_CONCUSSION )
+	{
+		i = WP_FLECHETTE;
+	}
+	else
+	{
+		i = cg.weaponSelect - 1;
+	}
+	if (i<1)
+	{
+		i = MAX_PLAYER_WEAPONS;
+	}
+
+	smallIconSize = 40;
+	bigIconSize = 80;
+	pad = 12;
+
+	if (!cgi_UI_GetMenuInfo("weaponselecthud",&x2,&y2,&w2,&h2))
+	{
+		return;
+	}
+	x = 320;
+	y = 410;
+
+	// Background
+	memcpy(calcColor, colorTable[CT_WHITE], sizeof(vec4_t));
+	calcColor[3] = .60f;
+	cgi_R_SetColor( calcColor);					
+
+	// Left side ICONS
+	cgi_R_SetColor( calcColor);					
+	// Work backwards from current icon
+	holdX = x - ((bigIconSize/2) + pad + smallIconSize);
+	height = smallIconSize * cg.iconHUDPercent;
+	drewConc = qfalse;
+
+	for (iconCnt=1;iconCnt<(sideLeftIconCnt+1);i--)
+	{
+		if ( i == WP_CONCUSSION )
+		{
+			i--;
+		}
+		else if ( i == WP_FLECHETTE && !drewConc && cg.weaponSelect != WP_CONCUSSION )
+		{
+			i = WP_CONCUSSION;
+		}
+		if (i<1)
+		{
+			i = MAX_PLAYER_WEAPONS;
+		}
+
+		if ( !(bits & ( 1 << i )))	// Does he have this weapon?
+		{
+			if ( i == WP_CONCUSSION )
+			{
+				drewConc = qtrue;
+				i = WP_ROCKET_LAUNCHER;
+			}
+			continue;
+		}
+		if (isOnVeh)
+		{
+			if ( i != WP_NONE && i!=WP_SABER && i!=WP_BLASTER )
+			{
+				if ( i == WP_CONCUSSION )
+				{
+					drewConc = qtrue;
+					i = WP_ROCKET_LAUNCHER;
+				}
+				continue;	// Don't draw anything else if on a vehicle
+			}
+		}
+
+		++iconCnt;					// Good icon
+
+		if (weaponData[i].weaponIcon[0])
+		{
+			weaponInfo_t	*weaponInfo;
+			CG_RegisterWeapon( i );	
+			weaponInfo = &cg_weapons[i];
+
+			if (!CG_WeaponCheck(i))
+			{
+				CG_DrawPic( holdX, y+10+yOffset, smallIconSize, smallIconSize, weaponInfo->weaponIconNoAmmo );
+			}
+			else
+			{
+				CG_DrawPic( holdX, y+10+yOffset, smallIconSize, smallIconSize, weaponInfo->weaponIcon );
+			}
+
+			holdX -= (smallIconSize+pad);
+		}
+		if ( i == WP_CONCUSSION )
+		{
+			drewConc = qtrue;
+			i = WP_ROCKET_LAUNCHER;
+		}
+	}
+
+	// Current Center Icon
+	height = bigIconSize * cg.iconHUDPercent;
+	cgi_R_SetColor(NULL);
+	if (weaponData[cg.weaponSelect].weaponIcon[0])
+	{
+		weaponInfo_t	*weaponInfo;
+		CG_RegisterWeapon( cg.weaponSelect );	
+		weaponInfo = &cg_weapons[cg.weaponSelect];
+
+		if (!CG_WeaponCheck(cg.weaponSelect))
+		{
+			CG_DrawPic( x-(bigIconSize/2), (y-((bigIconSize-smallIconSize)/2))+10+yOffset, bigIconSize, bigIconSize, weaponInfo->weaponIconNoAmmo );
+		}
+		else
+		{
+			CG_DrawPic( x-(bigIconSize/2), (y-((bigIconSize-smallIconSize)/2))+10+yOffset, bigIconSize, bigIconSize, weaponInfo->weaponIcon );
+		}
+	}
+
+	if ( cg.weaponSelect == WP_CONCUSSION )
+	{
+		i = WP_ROCKET_LAUNCHER;
+	}
+	else
+	{
+		i = cg.weaponSelect + 1;
+	}
+	if (i> MAX_PLAYER_WEAPONS)
+	{
+		i = 1;
+	}
+
+	// Right side ICONS
+	// Work forwards from current icon
+	cgi_R_SetColor( calcColor);					
+	holdX = x + (bigIconSize/2) + pad;
+	height = smallIconSize * cg.iconHUDPercent;
+	drewConc = qfalse;
+	for (iconCnt=1;iconCnt<(sideRightIconCnt+1);i++)
+	{
+		if ( i == WP_CONCUSSION )
+		{
+			i++;
+		}
+		else if ( i == WP_ROCKET_LAUNCHER && !drewConc && cg.weaponSelect != WP_CONCUSSION )
+		{
+			i = WP_CONCUSSION;
+		}
+		if (i>MAX_PLAYER_WEAPONS)
+		{
+			i = 1;
+		}
+
+		if ( !(bits & ( 1 << i )))	// Does he have this weapon?
+		{
+			if ( i == WP_CONCUSSION )
+			{
+				drewConc = qtrue;
+				i = WP_FLECHETTE;
+			}
+			continue;
+		}
+		if (isOnVeh)
+		{
+			if ( i != WP_NONE && i!=WP_SABER && i!=WP_BLASTER )
+			{
+				if ( i == WP_CONCUSSION )
+				{
+					drewConc = qtrue;
+					i = WP_FLECHETTE;
+				}
+				continue;	// Don't draw anything else if on a vehicle
+			}
+		}
+
+		++iconCnt;					// Good icon
+
+		if (weaponData[i].weaponIcon[0])
+		{
+			weaponInfo_t	*weaponInfo;
+			CG_RegisterWeapon( i );	
+			weaponInfo = &cg_weapons[i];
+			// No ammo for this weapon?
+			if (!CG_WeaponCheck(i))
+			{
+				CG_DrawPic( holdX, y+10+yOffset, smallIconSize, smallIconSize, weaponInfo->weaponIconNoAmmo );
+			}
+			else
+			{
+				CG_DrawPic( holdX, y+10+yOffset, smallIconSize, smallIconSize, weaponInfo->weaponIcon );
+			}
+
+
+			holdX += (smallIconSize+pad);
+		}
+		if ( i == WP_CONCUSSION )
+		{
+			drewConc = qtrue;
+			i = WP_FLECHETTE;
+		}
+	}
+
+	gitem_t *item = cg_weapons[ cg.weaponSelect ].item;
+
+	// draw the selected name
+	if ( item && item->classname && item->classname[0] ) 
+	{
+		char text[1024];
+		
+		if ( cgi_SP_GetStringTextString( va("SP_INGAME_%s",item->classname), text, sizeof( text )))
+		{
+			int w = cgi_R_Font_StrLenPixels(text, cgs.media.qhFontSmall, 1.0f);	
+			int x = ( SCREEN_WIDTH - w ) / 2;
+			cgi_R_Font_DrawString(x, (SCREEN_HEIGHT - 24)+yOffset, text, textColor, cgs.media.qhFontSmall, -1, 1.0f);
+		}
+	}
+
+	cgi_R_SetColor( NULL );
+}
+
+
+/*
+===============
+CG_WeaponSelectable
+===============
+*/
+qboolean CG_WeaponSelectable( int i, int original, qboolean dpMode ) 
+{
+	int	usage_for_weap;
+
+	if (i > MAX_PLAYER_WEAPONS)
+	{	
+#ifndef FINAL_BUILD
+		Com_Printf("CG_WeaponSelectable() passed illegal index of %d!\n",i);
+#endif
+		return qfalse;
+	}
+
+	if ( cg.weaponSelectTime + 200 > cg.time )
+	{//TEMP standard weapon cycle debounce for E3 because G2 can't keep up with fast weapon changes
+		return qfalse;
+	}
+
+	//FIXME: this doesn't work below, can still cycle too fast!
+	if ( original == WP_SABER && cg.weaponSelectTime + 500 > cg.time )
+	{//when sqitch to lightsaber, have to stay there for at least half a second!
+		return qfalse;
+	}
+
+	if ( G_IsRidingVehicle(cg_entities[0].gent) )
+	{
+		if (G_IsRidingTurboVehicle(cg_entities[0].gent) || (i!=WP_NONE && i!=WP_SABER && i!=WP_BLASTER) )
+		{ 
+			return qfalse;
+		}
+	}
+
+	if (( weaponData[i].ammoIndex != AMMO_NONE ) && !dpMode )
+	{//weapon uses ammo, see if we have any
+		usage_for_weap = weaponData[i].energyPerShot < weaponData[i].altEnergyPerShot 
+									? weaponData[i].energyPerShot 
+									: weaponData[i].altEnergyPerShot;
+
+		if ( cg.snap->ps.ammo[weaponData[i].ammoIndex] - usage_for_weap < 0 ) 
+		{
+			if ( i != WP_DET_PACK ) // detpack can be switched to...should possibly check if there are any stuck to a wall somewhere?
+			{
+				// This weapon doesn't have enough ammo to shoot either the main or the alt-fire
+				return qfalse;
+			}
+		}
+	}
+
+	if (!(cg.snap->ps.stats[ STAT_WEAPONS ] & ( 1 << i ))) 
+	{
+		// Don't have this weapon to start with.
+		return qfalse;
+	}
+
+	return qtrue;
+}
+
+void CG_ToggleATSTWeapon( void )
+{
+	if ( cg.weaponSelect == WP_ATST_MAIN )
+	{
+		cg.weaponSelect = WP_ATST_SIDE;
+	}
+	else
+	{
+		cg.weaponSelect = WP_ATST_MAIN;
+	}
+//	cg.weaponSelectTime = cg.time;
+	SetWeaponSelectTime();
+}
+
+void CG_PlayerLockedWeaponSpeech( int jumping )
+{
+extern qboolean Q3_TaskIDPending( gentity_t *ent, taskID_t taskType );
+	static int speechDebounceTime = 0;
+	if ( !in_camera )
+	{//not in a cinematic
+		if ( speechDebounceTime < cg.time )
+		{//spoke more than 3 seconds ago
+			if ( !Q3_TaskIDPending( &g_entities[0], TID_CHAN_VOICE ) )
+			{//not waiting on a scripted sound to finish
+				if( !jumping )
+				{
+					if( random() > 0.5 )
+					{
+						G_SoundOnEnt( player, CHAN_VOICE, va( "sound/chars/kyle/09kyk015.wav" ));
+					}
+					else
+					{
+						G_SoundOnEnt( player, CHAN_VOICE, va( "sound/chars/kyle/09kyk016.wav" ));
+					}
+				}
+				else
+				{
+					G_SoundOnEnt( player, CHAN_VOICE, va( "sound/chars/kyle/16kyk007.wav" ));
+				}
+				speechDebounceTime = cg.time + 3000;
+			}
+		}
+	}
+}
+/*
+===============
+CG_NextWeapon_f
+===============
+*/
+void CG_NextWeapon_f( void ) {
+	int		i;
+	int		original;
+
+	if ( !cg.snap ) {
+		return;
+	}
+	/*
+	if ( cg.snap->ps.pm_flags & PMF_FOLLOW ) {
+		return;
+	}
+	*/
+
+	if( g_entities[0].flags & FL_LOCK_PLAYER_WEAPONS )
+	{
+		CG_PlayerLockedWeaponSpeech( qfalse );
+		return;
+	}
+
+	if( g_entities[0].client && g_entities[0].client->NPC_class == CLASS_ATST )
+	{
+		CG_ToggleATSTWeapon();
+		return;
+	}
+
+	if ( cg.snap->ps.eFlags & EF_LOCKED_TO_WEAPON )
+	{
+		// can't do any sort of weapon switching when in the emplaced gun
+		return;
+	}
+
+	if ( cg.snap->ps.viewEntity )
+	{
+		// yeah, probably need a better check here
+		if ( g_entities[cg.snap->ps.viewEntity].client && ( g_entities[cg.snap->ps.viewEntity].client->NPC_class == CLASS_R5D2 
+				|| g_entities[cg.snap->ps.viewEntity].client->NPC_class == CLASS_R2D2 
+				|| g_entities[cg.snap->ps.viewEntity].client->NPC_class == CLASS_MOUSE ))
+		{
+			return;
+		}
+	}
+
+	original = cg.weaponSelect;
+
+	int firstWeapon = FIRST_WEAPON;
+	if (G_IsRidingVehicle(&g_entities[cg.snap->ps.viewEntity]))
+	{
+		firstWeapon = 0;	// include WP_NONE here
+	}
+
+	for ( i = 0 ; i <= MAX_PLAYER_WEAPONS ; i++ ) 
+	{
+		
+		//*SIGH*... Hack to put concussion rifle before rocketlauncher
+		if ( cg.weaponSelect == WP_FLECHETTE )
+		{
+			cg.weaponSelect = WP_CONCUSSION;
+		}
+		else if ( cg.weaponSelect == WP_CONCUSSION )
+		{
+			cg.weaponSelect = WP_ROCKET_LAUNCHER;
+		}
+		else if ( cg.weaponSelect == WP_DET_PACK )
+		{
+			cg.weaponSelect = firstWeapon;
+		}
+		else
+		{
+			cg.weaponSelect++;
+		}
+
+		if ( cg.weaponSelect < firstWeapon || cg.weaponSelect > MAX_PLAYER_WEAPONS) { 
+			cg.weaponSelect = firstWeapon; 
+		}
+		
+		if ( CG_WeaponSelectable( cg.weaponSelect, original, qfalse ) ) 
+		{	
+//			cg.weaponSelectTime = cg.time;
+			SetWeaponSelectTime();
+			return;
+		}
+	}
+
+	cg.weaponSelect = original;
+}
+
+/*
+===============
+CG_DPNextWeapon_f
+===============
+*/
+void CG_DPNextWeapon_f( void ) {
+	int		i;
+	int		original;
+
+	if ( !cg.snap ) {
+		return;
+	}
+	/*
+	if ( cg.snap->ps.pm_flags & PMF_FOLLOW ) {
+		return;
+	}
+	*/
+
+	original = cg.DataPadWeaponSelect;
+
+	for ( i = 0 ; i <= MAX_PLAYER_WEAPONS ; i++ ) 
+	{
+		
+		//*SIGH*... Hack to put concussion rifle before rocketlauncher
+		if ( cg.DataPadWeaponSelect == WP_FLECHETTE )
+		{
+			cg.DataPadWeaponSelect = WP_CONCUSSION;
+		}
+		else if ( cg.DataPadWeaponSelect == WP_CONCUSSION )
+		{
+			cg.DataPadWeaponSelect = WP_ROCKET_LAUNCHER;
+		}
+		else if ( cg.DataPadWeaponSelect == WP_DET_PACK )
+		{
+			cg.DataPadWeaponSelect = FIRST_WEAPON;
+		}
+		else
+		{
+			cg.DataPadWeaponSelect++;
+		}
+
+		if ( cg.DataPadWeaponSelect < FIRST_WEAPON || cg.DataPadWeaponSelect > MAX_PLAYER_WEAPONS) { 
+			cg.DataPadWeaponSelect = FIRST_WEAPON; 
+		}
+		
+		if ( CG_WeaponSelectable( cg.DataPadWeaponSelect, original, qtrue ) ) 
+		{	
+			return;
+		}
+	}
+
+	cg.DataPadWeaponSelect = original;
+}
+
+/*
+===============
+CG_DPPrevWeapon_f
+===============
+*/
+void CG_DPPrevWeapon_f( void ) 
+{
+	int		i;
+	int		original;
+
+	if ( !cg.snap ) 
+	{
+		return;
+	}
+
+	/*
+	if ( cg.snap->ps.pm_flags & PMF_FOLLOW ) 
+	{
+		return;
+	}
+	*/
+
+	original = cg.DataPadWeaponSelect;
+
+	for ( i = 0 ; i <= MAX_PLAYER_WEAPONS ; i++ ) 
+	{
+		
+		//*SIGH*... Hack to put concussion rifle before rocketlauncher
+		if ( cg.DataPadWeaponSelect == WP_ROCKET_LAUNCHER )
+		{
+			cg.DataPadWeaponSelect = WP_CONCUSSION;
+		}
+		else if ( cg.DataPadWeaponSelect == WP_CONCUSSION )
+		{
+			cg.DataPadWeaponSelect = WP_FLECHETTE;
+		}
+		else if ( cg.DataPadWeaponSelect == WP_MELEE )
+		{
+			cg.DataPadWeaponSelect = WP_DET_PACK;
+		}
+		else
+		{
+			cg.DataPadWeaponSelect--;
+		}
+
+		if ( cg.DataPadWeaponSelect < FIRST_WEAPON || cg.DataPadWeaponSelect > MAX_PLAYER_WEAPONS) 
+		{ 
+			cg.DataPadWeaponSelect = MAX_PLAYER_WEAPONS;
+		}
+		
+		if ( CG_WeaponSelectable( cg.DataPadWeaponSelect, original, qtrue ) ) 
+		{
+			return;
+		}
+	}
+
+	cg.DataPadWeaponSelect = original;
+}
+
+/*
+===============
+CG_PrevWeapon_f
+===============
+*/
+void CG_PrevWeapon_f( void ) {
+	int		i;
+	int		original;
+
+	if ( !cg.snap ) {
+		return;
+	}
+	/*
+	if ( cg.snap->ps.pm_flags & PMF_FOLLOW ) {
+		return;
+	}
+	*/
+
+	if( g_entities[0].flags & FL_LOCK_PLAYER_WEAPONS )
+	{
+		CG_PlayerLockedWeaponSpeech( qfalse );
+		return;
+	}
+
+	if( g_entities[0].client && g_entities[0].client->NPC_class == CLASS_ATST )
+	{
+		CG_ToggleATSTWeapon();
+		return;
+	}
+
+	if ( cg.snap->ps.eFlags & EF_LOCKED_TO_WEAPON )
+	{
+		// can't do any sort of weapon switching when in the emplaced gun
+		return;
+	}
+
+	if ( cg.snap->ps.viewEntity )
+	{
+		// yeah, probably need a better check here
+		if ( g_entities[cg.snap->ps.viewEntity].client && ( g_entities[cg.snap->ps.viewEntity].client->NPC_class == CLASS_R5D2 
+				|| g_entities[cg.snap->ps.viewEntity].client->NPC_class == CLASS_R2D2 
+				|| g_entities[cg.snap->ps.viewEntity].client->NPC_class == CLASS_MOUSE ))
+		{
+			return;
+		}
+	}
+
+	original = cg.weaponSelect;
+
+	int firstWeapon = FIRST_WEAPON;
+	if (G_IsRidingVehicle(&g_entities[cg.snap->ps.viewEntity]))
+	{
+		firstWeapon = 0;	// include WP_NONE here
+	}
+
+	for ( i = 0 ; i <= MAX_PLAYER_WEAPONS ; i++ ) {
+		
+		//*SIGH*... Hack to put concussion rifle before rocketlauncher
+		if ( cg.weaponSelect == WP_ROCKET_LAUNCHER )
+		{
+			cg.weaponSelect = WP_CONCUSSION;
+		}
+		else if ( cg.weaponSelect == WP_CONCUSSION )
+		{
+			cg.weaponSelect = WP_FLECHETTE;
+		}
+		else if ( cg.weaponSelect == WP_MELEE )
+		{
+			cg.weaponSelect = WP_DET_PACK;
+		}
+		else
+		{
+			cg.weaponSelect--;
+		}
+
+
+		if ( cg.weaponSelect < firstWeapon || cg.weaponSelect > MAX_PLAYER_WEAPONS) { 
+			cg.weaponSelect = MAX_PLAYER_WEAPONS;
+		}
+		
+		if ( CG_WeaponSelectable( cg.weaponSelect, original, qfalse ) ) 
+		{
+			SetWeaponSelectTime();
+//			cg.weaponSelectTime = cg.time;
+			return;
+		}
+	}
+
+	cg.weaponSelect = original;
+}
+
+/*
+void CG_ChangeWeapon( int num )
+
+  Meant to be called from the normal game, so checks the game-side weapon inventory data
+*/
+void CG_ChangeWeapon( int num )
+{
+	gentity_t	*player = &g_entities[0];
+
+	if ( num < WP_NONE || num >= WP_NUM_WEAPONS ) 
+	{
+		return;
+	}
+
+	if( player->flags & FL_LOCK_PLAYER_WEAPONS )
+	{
+		CG_PlayerLockedWeaponSpeech( qfalse );
+		return;
+	}
+
+	if ( player->client != NULL && !(player->client->ps.stats[STAT_WEAPONS] & ( 1 << num )) ) 
+	{
+		return;		// don't have the weapon
+	}
+
+	// because we don't have an empty hand model for the thermal, don't allow selecting that weapon if it has no ammo
+	if ( num == WP_THERMAL )
+	{
+		if ( cg.snap && cg.snap->ps.ammo[AMMO_THERMAL] <= 0 ) 
+		{
+			return;
+		}
+	}
+	
+	// because we don't have an empty hand model for the thermal, don't allow selecting that weapon if it has no ammo
+	if ( num == WP_TRIP_MINE )
+	{
+		if ( cg.snap && cg.snap->ps.ammo[AMMO_TRIPMINE] <= 0 ) 
+		{
+			return;
+		}
+	}
+
+	SetWeaponSelectTime();
+//	cg.weaponSelectTime = cg.time;
+	cg.weaponSelect = num;
+}
+
+/*
+===============
+CG_Weapon_f
+===============
+*/
+void CG_Weapon_f( void ) 
+{
+	int		num;
+
+	if ( cg.weaponSelectTime + 200 > cg.time )
+	{
+		return;
+	}
+
+	if ( !cg.snap ) {
+		return;
+	}
+	/*
+	if ( cg.snap->ps.pm_flags & PMF_FOLLOW ) {
+		return;
+	}
+	*/
+
+	if( g_entities[0].flags & FL_LOCK_PLAYER_WEAPONS )
+	{
+		CG_PlayerLockedWeaponSpeech( qfalse );
+		return;
+	}
+
+	if( g_entities[0].client && g_entities[0].client->NPC_class == CLASS_ATST )
+	{
+		CG_ToggleATSTWeapon();
+		return;
+	}
+
+	if ( cg.snap->ps.eFlags & EF_LOCKED_TO_WEAPON )
+	{
+		// can't do any sort of weapon switching when in the emplaced gun
+		return;
+	}
+
+	if ( cg.snap->ps.viewEntity )
+	{
+		// yeah, probably need a better check here
+		if ( g_entities[cg.snap->ps.viewEntity].client && ( g_entities[cg.snap->ps.viewEntity].client->NPC_class == CLASS_R5D2 
+				|| g_entities[cg.snap->ps.viewEntity].client->NPC_class == CLASS_R2D2 
+				|| g_entities[cg.snap->ps.viewEntity].client->NPC_class == CLASS_MOUSE ))
+		{
+			return;
+		}
+	}
+
+	num = atoi( CG_Argv( 1 ) );
+
+	if ( num < WP_NONE || num >= WP_NUM_WEAPONS ) {
+		return;
+	}
+
+	if (!CG_WeaponSelectable(num, cg.snap->ps.weapon, qfalse))
+	{
+		return;
+	}
+
+	if ( num == WP_SABER )
+	{//lightsaber
+		if ( ! ( cg.snap->ps.stats[STAT_WEAPONS] & ( 1 << num ) ) )
+		{//don't have saber, try stun baton
+			if ( ( cg.snap->ps.stats[STAT_WEAPONS] & ( 1 << WP_STUN_BATON ) ) )
+			{
+				num = WP_STUN_BATON;
+			}
+			else
+			{//don't have stun baton, use fists
+				num = WP_MELEE;
+			}
+		}
+		else if ( num == cg.snap->ps.weapon )
+		{//already have it up, let's try to toggle it
+			if ( !in_camera )
+			{//player can't activate/deactivate saber when in a cinematic
+				//can't toggle it if not holding it and not controlling it or dead
+				if ( cg.predicted_player_state.stats[STAT_HEALTH] > 0 && (!cg_entities[0].gent->client->ps.saberInFlight || (&g_entities[cg_entities[0].gent->client->ps.saberEntityNum] != NULL && g_entities[cg_entities[0].gent->client->ps.saberEntityNum].s.pos.trType == TR_LINEAR) ) )
+				{//it's either in-hand or it's under telekinetic control
+					if ( cg_entities[0].gent->client->ps.SaberActive() )
+					{//a saber is on
+						if ( cg_entities[0].gent->client->ps.dualSabers 
+							&& cg_entities[0].gent->client->ps.saber[1].Active() )
+						{//2nd saber is on, turn it off, too
+							cg_entities[0].gent->client->ps.saber[1].Deactivate();
+						}
+						cg_entities[0].gent->client->ps.saber[0].Deactivate();
+						if ( cg_entities[0].gent->client->ps.saberInFlight )
+						{//play it on the saber
+							cgi_S_UpdateEntityPosition( cg_entities[0].gent->client->ps.saberEntityNum, g_entities[cg_entities[0].gent->client->ps.saberEntityNum].currentOrigin );
+							cgi_S_StartSound (NULL, cg_entities[0].gent->client->ps.saberEntityNum, CHAN_AUTO, cgs.sound_precache[cg_entities[0].gent->client->ps.saber[0].soundOff] );
+						}
+						else
+						{
+							cgi_S_StartSound (NULL, cg.snap->ps.clientNum, CHAN_AUTO, cgs.sound_precache[cg_entities[0].gent->client->ps.saber[0].soundOff] );
+#ifdef _IMMERSION
+						cgi_FF_Start( cgi_FF_Register( "fffx/weapons/saber/saberoff", FF_CHANNEL_WEAPON ), cg.snap->ps.clientNum );
+#endif // _IMMERSION
+						}
+					}
+					else
+					{//turn them both on
+						cg_entities[0].gent->client->ps.SaberActivate();
+					}
+				}
+			}
+		}
+	}
+	else if ( num >= WP_THERMAL && num <= WP_DET_PACK ) // these weapons cycle
+	{
+		int weap, i = 0;
+
+		if ( cg.snap->ps.weapon >= WP_THERMAL && cg.snap->ps.weapon <= WP_DET_PACK )
+		{
+			// already in cycle range so start with next cycle item
+			weap = cg.snap->ps.weapon + 1;
+		}
+		else
+		{
+			// not in cycle range, so start with thermal detonator
+			weap = WP_THERMAL;
+		}
+
+		// prevent an endless loop
+		while ( i <= 4 )
+		{
+			if ( weap > WP_DET_PACK )
+			{
+				weap = WP_THERMAL;
+			}
+
+			if ( cg.snap->ps.ammo[weaponData[weap].ammoIndex] > 0 || weap == WP_DET_PACK )
+			{
+				if ( CG_WeaponSelectable( weap, cg.snap->ps.weapon, qfalse ) ) 
+				{	
+					num = weap;
+					break;
+				}
+			}
+
+			weap++;
+			i++;
+		}
+	}
+
+	if ( ! ( cg.snap->ps.stats[STAT_WEAPONS] & ( 1 << num ) ) ) {
+		return;		// don't have the weapon
+	}
+
+	SetWeaponSelectTime();
+//	cg.weaponSelectTime = cg.time;
+	cg.weaponSelect = num;
+}
+
+/*
+===================
+CG_OutOfAmmoChange
+
+The current weapon has just run out of ammo
+===================
+*/
+void CG_OutOfAmmoChange( void ) {
+	int		i;
+	int		original;
+
+#ifndef _IMMERSION
+	cgi_FF_StartFX( fffx_OutOfAmmo );
+#endif // _IMMERSION
+
+	if ( cg.weaponSelectTime + 200 > cg.time )
+		return;
+
+	if( g_entities[0].client && g_entities[0].client->NPC_class == CLASS_ATST )
+	{
+		CG_ToggleATSTWeapon();
+		return;
+	}
+
+	original = cg.weaponSelect;
+
+	for ( i = WP_ROCKET_LAUNCHER; i > 0 ; i-- ) 
+	{	
+		// We don't want the emplaced, melee, or explosive devices here
+		if ( original != i && CG_WeaponSelectable( i, original, qfalse ) )
+		{
+			SetWeaponSelectTime();
+			cg.weaponSelect = i;
+			break;
+		}
+	}
+
+	if ( cg_autoswitch.integer != 1 )
+	{
+		// didn't have that, so try these. Start with thermal...
+		for ( i = WP_THERMAL; i <= WP_DET_PACK; i++ ) 
+		{	
+			// We don't want the emplaced, or melee here
+			if ( original != i && CG_WeaponSelectable( i, original, qfalse ) )
+			{
+				if ( i == WP_DET_PACK && cg.snap->ps.ammo[weaponData[i].ammoIndex] <= 0 )
+				{
+					// crap, no point in switching to this
+				}
+				else
+				{
+					SetWeaponSelectTime();
+					cg.weaponSelect = i;
+					break;
+				}
+			}
+		}
+	}
+
+	// try stun baton as a last ditch effort
+	if ( CG_WeaponSelectable( WP_STUN_BATON, original, qfalse ))
+	{
+		SetWeaponSelectTime();
+		cg.weaponSelect = WP_STUN_BATON;
+	}
+}
+
+
+
+/*
+===================================================================================================
+
+WEAPON EVENTS
+
+===================================================================================================
+*/
+
+/*
+================
+CG_FireWeapon
+
+Caused by an EV_FIRE_WEAPON event
+================
+*/
+void CG_FireWeapon( centity_t *cent, qboolean alt_fire ) 
+{
+	entityState_t *ent;
+	weaponInfo_t	*weap;
+
+	ent = &cent->currentState;
+	if ( ent->weapon == WP_NONE ) {
+		return;
+	}
+	if ( ent->weapon >= WP_NUM_WEAPONS ) {
+		CG_Error( "CG_FireWeapon: ent->weapon >= WP_NUM_WEAPONS" );
+		return;
+	}
+	if ( ent->weapon == WP_TUSKEN_RIFLE && cent->gent->client) 
+	{ 	
+		if (cent->gent->client->ps.torsoAnim==BOTH_TUSKENATTACK1 ||
+		cent->gent->client->ps.torsoAnim==BOTH_TUSKENATTACK2 ||
+		cent->gent->client->ps.torsoAnim==BOTH_TUSKENATTACK3 ||
+		cent->gent->client->ps.torsoAnim==BOTH_TUSKENLUNGE1)
+		{
+			return;
+		}
+	}
+
+	weap = &cg_weapons[ ent->weapon ];
+
+	// mark the entity as muzzle flashing, so when it is added it will
+	// append the flash to the weapon model
+	cent->muzzleFlashTime = cg.time;
+	cent->altFire = alt_fire;
+
+	// lightning type guns only does this this on initial press
+	if ( ent->weapon == WP_SABER )
+	{
+		if ( cent->pe.lightningFiring ) 
+		{
+/*			if ( ent->weapon == WP_DREADNOUGHT )
+			{
+				cgi_FF_EnsureFX( fffx_Laser3 );
+			}
+*/
+			return;
+		}
+	}
+	
+#ifndef _IMMERSION
+	// force feedback...
+	//
+	if ( cent->gent->s.number == 0 )
+	switch (ent->weapon)
+	{
+		// FIXME: I can NOT get this !@#$% iFeel USB mouse to work, it completely fails to register even with their
+		//		latest drivers, and I haven't got time to get it working now so close to release, so here's a complete 
+		//		guess as to which FX forces go with which weapon. Sorry if they're crap...
+		//
+		case WP_SABER:				
+			cgi_FF_StartFX( fffx_SwitchClick );	// repeat-fire handled above, but this just give an initial jolt
+			break;
+
+		case WP_DISRUPTOR:
+		case WP_BRYAR_PISTOL:	
+		case WP_BLASTER_PISTOL:	
+		case WP_JAWA:	
+		case WP_THERMAL:
+		case WP_DET_PACK:
+			cgi_FF_StartFX( alt_fire ? fffx_Shotgun : fffx_Pistol);	
+			break;
+
+		case WP_FLECHETTE:	
+			cgi_FF_StartFX( alt_fire ? fffx_Shotgun : fffx_ShortPlasma);
+			break;			
+			
+		case WP_REPEATER:
+			cgi_FF_StartFX( alt_fire ? fffx_MachineGun : fffx_GatlingGun);
+			break;
+
+		case WP_BLASTER:
+			cgi_FF_StartFX( alt_fire ? fffx_Shotgun : fffx_Pistol);	
+			break;
+ 
+		case WP_ROCKET_LAUNCHER:
+		case WP_CONCUSSION:
+			cgi_FF_StartFX( fffx_RocketLaunch );
+			break;
+
+		case WP_BOWCASTER:
+			cgi_FF_StartFX( alt_fire ? fffx_Land : fffx_Jump);	
+			break;
+
+		case WP_DEMP2:
+			cgi_FF_StartFX( alt_fire ? fffx_Shotgun : fffx_Pistol);	
+			break;
+
+		case WP_STUN_BATON:
+			cgi_FF_StartFX( fffx_Laser1 );
+			break;
+
+		case WP_TRIP_MINE:
+			cgi_FF_StartFX( fffx_OutOfAmmo );
+			break;
+	}
+#endif // _IMMERSION
+
+	// Do overcharge sound that get's added to the top
+/*	if (( ent->powerups & ( 1<<PW_WEAPON_OVERCHARGE )))
+	{
+		if ( alt_fire )
+		{
+			switch( ent->weapon )
+			{
+			case WP_THERMAL:
+			case WP_DET_PACK:
+			case WP_TRIP_MINE:
+			case WP_ROCKET_LAUNCHER:
+			case WP_FLECHETTE:
+				// these weapon fires don't overcharge
+				break;
+
+			case WP_BLASTER:
+				cgi_S_StartSound( NULL, ent->number, CHAN_AUTO, cgs.media.overchargeFastSound );
+				break;
+
+			default:
+				cgi_S_StartSound( NULL, ent->number, CHAN_AUTO, cgs.media.overchargeSlowSound );
+				break;
+			}
+		}
+		else
+		{
+			switch( ent->weapon )
+			{
+			case WP_THERMAL:
+			case WP_DET_PACK:
+			case WP_TRIP_MINE:
+			case WP_ROCKET_LAUNCHER:
+				// these weapon fires don't overcharge
+				break;
+
+			case WP_REPEATER:
+				cgi_S_StartSound( NULL, ent->number, CHAN_AUTO, cgs.media.overchargeFastSound );
+				break;
+
+			default:
+				cgi_S_StartSound( NULL, ent->number, CHAN_AUTO, cgs.media.overchargeSlowSound );
+				break;
+			}
+		}
+	}*/
+}
+
+/*
+=================
+CG_BounceEffect
+
+Caused by an EV_BOUNCE | EV_BOUNCE_HALF event
+=================
+*/
+void CG_BounceEffect( centity_t *cent, int weapon, vec3_t origin, vec3_t normal )
+{
+	switch( weapon )
+	{
+	case WP_THERMAL:
+		if ( rand() & 1 ) {
+			cgi_S_StartSound( origin, ENTITYNUM_WORLD, CHAN_AUTO, cgs.media.grenadeBounce1 );
+#ifdef _IMMERSION
+			if ( cent->currentState.saberActive )
+			{
+				cgi_FF_Start( cgs.media.grenadeBounce1Force, cent->currentState.otherEntityNum );
+			}
+#endif // _IMMERSION
+		} else {
+			cgi_S_StartSound( origin, ENTITYNUM_WORLD, CHAN_AUTO, cgs.media.grenadeBounce2 );
+#ifdef _IMMERSION
+			if ( cent->currentState.saberActive )
+			{
+				cgi_FF_Start( cgs.media.grenadeBounce2Force, cent->currentState.otherEntityNum );
+			}
+#endif // _IMMERSION
+		}
+		break;
+
+	case WP_BOWCASTER:
+#ifdef _IMMERSION
+		if ( cent->currentState.saberActive )
+			theFxScheduler.PlayEffect( cgs.effects.bowcasterBounceEffect, FF_CLIENT( cent->currentState.otherEntityNum ), origin, normal );
+		else
+#endif // _IMMERSION
+		theFxScheduler.PlayEffect( cgs.effects.bowcasterBounceEffect, origin, normal );
+		break;
+
+	case WP_FLECHETTE:
+#ifdef _IMMERSION
+		if ( cent->currentState.saberActive )
+			theFxScheduler.PlayEffect( "flechette/ricochet", FF_CLIENT( cent->currentState.otherEntityNum ), origin, normal );
+		else
+#endif // _IMMERSION
+		theFxScheduler.PlayEffect( "flechette/ricochet", origin, normal );
+		break;
+
+	default:
+		if ( rand() & 1 ) {
+			cgi_S_StartSound( origin, ENTITYNUM_WORLD, CHAN_AUTO, cgs.media.grenadeBounce1 );
+#ifdef _IMMERSION
+			if ( cent->currentState.saberActive )
+			{
+				cgi_FF_Start( cgs.media.grenadeBounce1Force, cent->currentState.otherEntityNum );
+			}
+#endif // _IMMERSION
+		} else {
+			cgi_S_StartSound( origin, ENTITYNUM_WORLD, CHAN_AUTO, cgs.media.grenadeBounce2 );
+#ifdef _IMMERSION
+			if ( cent->currentState.saberActive )
+			{
+				cgi_FF_Start( cgs.media.grenadeBounce2Force, cent->currentState.otherEntityNum );
+			}
+#endif // _IMMERSION
+		}
+		break;
+	}
+}
+
+//----------------------------------------------------------------------
+void CG_MissileStick( centity_t *cent, int weapon, vec3_t position )
+//----------------------------------------------------------------------
+{
+	sfxHandle_t snd = 0;
+
+	switch( weapon )
+	{
+	case WP_FLECHETTE:
+		snd = cgs.media.flechetteStickSound;
+		break;
+
+	case WP_DET_PACK:
+		snd = cgs.media.detPackStickSound;
+		break;
+
+	case WP_TRIP_MINE:
+		snd = cgs.media.tripMineStickSound;
+		break;
+	}
+
+	if ( snd )
+	{
+		cgi_S_StartSound( NULL, cent->currentState.number, CHAN_AUTO, snd );
+	}
+}
+
+/*
+=================
+CG_MissileHitWall
+
+Caused by an EV_MISSILE_MISS event, or directly by local bullet tracing
+=================
+*/
+void CG_MissileHitWall( centity_t *cent, int weapon, vec3_t origin, vec3_t dir, qboolean altFire ) 
+{
+	int parm;
+
+	switch( weapon )
+	{
+	case WP_BRYAR_PISTOL:
+	case WP_BLASTER_PISTOL:
+	case WP_JAWA:
+		if ( altFire )
+		{
+			parm = 0;
+
+			if ( cent->gent )
+			{
+				parm += cent->gent->count;
+			}
+
+			FX_BryarAltHitWall( origin, dir, parm );
+		}
+		else
+		{
+			FX_BryarHitWall( origin, dir );
+		}
+		break;
+
+	case WP_BLASTER:
+		FX_BlasterWeaponHitWall( origin, dir );
+		break;
+
+	case WP_BOWCASTER:
+		FX_BowcasterHitWall( origin, dir );
+		break;
+
+	case WP_REPEATER:
+		if ( altFire )
+		{
+			FX_RepeaterAltHitWall( origin, dir );
+		}
+		else
+		{
+			FX_RepeaterHitWall( origin, dir );
+		}
+		break;
+
+	case WP_DEMP2:
+		if ( altFire )
+		{
+		}
+		else
+		{
+			FX_DEMP2_HitWall( origin, dir );
+		}
+		break;
+
+	case WP_FLECHETTE:
+		if ( altFire )
+		{
+			theFxScheduler.PlayEffect( "flechette/alt_blow", origin, dir );
+		}
+		else
+		{
+			FX_FlechetteWeaponHitWall( origin, dir );
+		}
+		break;
+
+	case WP_ROCKET_LAUNCHER:
+		FX_RocketHitWall( origin, dir );
+		break;
+
+	case WP_CONCUSSION:
+		FX_ConcHitWall( origin, dir );
+		break;
+
+	case WP_THERMAL:
+		theFxScheduler.PlayEffect( "thermal/explosion", origin, dir );
+		theFxScheduler.PlayEffect( "thermal/shockwave", origin );
+		break;
+
+	case WP_EMPLACED_GUN:
+		FX_EmplacedHitWall( origin, dir, (cent->gent&&cent->gent->alt_fire) );
+		break;
+
+	case WP_ATST_MAIN:
+		FX_ATSTMainHitWall( origin, dir );
+		break;
+
+	case WP_ATST_SIDE:
+		if ( altFire )
+		{
+			theFxScheduler.PlayEffect( "atst/side_alt_explosion", origin, dir );
+		}
+		else
+		{
+			theFxScheduler.PlayEffect( "atst/side_main_impact", origin, dir );
+		}
+		break;
+
+	case WP_TRIP_MINE:
+		theFxScheduler.PlayEffect( "tripmine/explosion", origin, dir );
+		break;
+
+	case WP_DET_PACK:
+		theFxScheduler.PlayEffect( "detpack/explosion", origin, dir );
+		break;
+
+	case WP_TURRET:
+		theFxScheduler.PlayEffect( "turret/wall_impact", origin, dir );
+		break;
+
+	case WP_TUSKEN_RIFLE:
+		FX_TuskenShotWeaponHitWall( origin, dir );
+		break;
+
+	case WP_NOGHRI_STICK:
+		FX_NoghriShotWeaponHitWall( origin, dir );
+		break;
+	}
+}
+
+/*
+-------------------------
+CG_MissileHitPlayer
+-------------------------
+*/
+
+void CG_MissileHitPlayer( centity_t *cent, int weapon, vec3_t origin, vec3_t dir, qboolean altFire ) 
+{
+	gentity_t *other = NULL;
+	qboolean	humanoid = qtrue;
+	
+	if ( cent->gent )
+	{
+		other = &g_entities[cent->gent->s.otherEntityNum];
+		if( other->client )
+		{
+			class_t	npc_class = other->client->NPC_class;
+			// check for all droids, maybe check for certain monsters if they're considered non-humanoid..?		
+			if ( npc_class == CLASS_SEEKER || npc_class == CLASS_PROBE || npc_class == CLASS_MOUSE ||
+				 npc_class == CLASS_GONK || npc_class == CLASS_R2D2 || npc_class == CLASS_R5D2 ||
+				 npc_class == CLASS_PROTOCOL || npc_class == CLASS_MARK1 || npc_class == CLASS_MARK2 ||
+				 npc_class == CLASS_INTERROGATOR || npc_class == CLASS_ATST || npc_class == CLASS_SENTRY )
+			{
+				humanoid = qfalse;
+			}
+		}
+	}
+
+	switch( weapon )
+	{
+	case WP_BRYAR_PISTOL:
+	case WP_BLASTER_PISTOL:
+	case WP_JAWA:
+		if ( altFire )
+		{
+			FX_BryarAltHitPlayer( origin, dir, humanoid );
+		}
+		else
+		{
+			FX_BryarHitPlayer( origin, dir, humanoid );
+		}
+		break;
+
+	case WP_BLASTER:
+		FX_BlasterWeaponHitPlayer( other, origin, dir, humanoid );
+		break;
+
+	case WP_BOWCASTER:
+		FX_BowcasterHitPlayer( origin, dir, humanoid );
+		break;
+
+	case WP_REPEATER:
+		if ( altFire )
+		{
+			FX_RepeaterAltHitPlayer( origin, dir, humanoid );
+		}
+		else
+		{
+			FX_RepeaterHitPlayer( origin, dir, humanoid );
+		}
+		break;
+
+	case WP_DEMP2:
+		if ( !altFire )
+		{
+			FX_DEMP2_HitPlayer( origin, dir, humanoid );
+		}
+
+		// Do a full body effect here for some more feedback
+		if ( other && other->client )
+		{
+			other->s.powerups |= ( 1 << PW_SHOCKED );
+			other->client->ps.powerups[PW_SHOCKED] = cg.time + 1000;
+		}
+		break;
+
+	case WP_FLECHETTE:
+		if ( altFire )
+		{
+			theFxScheduler.PlayEffect( "flechette/alt_blow", origin, dir );
+		}
+		else
+		{
+			FX_FlechetteWeaponHitPlayer( origin, dir, humanoid );
+		}	
+		break;
+
+	case WP_ROCKET_LAUNCHER:
+		FX_RocketHitPlayer( origin, dir, humanoid );
+		break;
+
+	case WP_CONCUSSION:
+		FX_ConcHitPlayer( origin, dir, humanoid );
+		break;
+
+	case WP_THERMAL:
+		theFxScheduler.PlayEffect( "thermal/explosion", origin, dir );
+		theFxScheduler.PlayEffect( "thermal/shockwave", origin );
+		break;
+
+	case WP_EMPLACED_GUN:
+		FX_EmplacedHitPlayer( origin, dir, (cent->gent&&cent->gent->alt_fire) );
+		break;
+
+	case WP_TRIP_MINE:
+		theFxScheduler.PlayEffect( "tripmine/explosion", origin, dir );
+		break;
+
+	case WP_DET_PACK:
+		theFxScheduler.PlayEffect( "detpack/explosion", origin, dir );
+		break;
+
+	case WP_TURRET:
+		theFxScheduler.PlayEffect( "turret/flesh_impact", origin, dir );
+		break;
+
+	case WP_ATST_MAIN:
+		FX_EmplacedHitWall( origin, dir, qfalse );
+		break;
+
+	case WP_ATST_SIDE:
+		if ( altFire )
+		{
+			theFxScheduler.PlayEffect( "atst/side_alt_explosion", origin, dir );
+		}
+		else
+		{
+			theFxScheduler.PlayEffect( "atst/side_main_impact", origin, dir );
+		}
+		break;
+	case WP_TUSKEN_RIFLE:
+		FX_TuskenShotWeaponHitPlayer( other, origin, dir, humanoid );
+		break;
+
+	case WP_NOGHRI_STICK:
+		FX_NoghriShotWeaponHitPlayer( other, origin, dir, humanoid );
+		break;
+	}
+}
diff --git a/code/cgame/common_headers.h b/code/cgame/common_headers.h
new file mode 100644
index 0000000..9112ea7
--- /dev/null
+++ b/code/cgame/common_headers.h
@@ -0,0 +1,10 @@
+// this line must stay at top so the whole PCH thing works...
+#include "cg_headers.h"
+
+// I am a dummy header file that takes the place of the PCH files in SoF2.  This is done so that we can easily 
+//	transport fx files amongst CHC, SoF2, and the effects editor...( If you are looking at this and have a better
+//	idea, just let me know what the better solution is. )
+// The files can't be shared directly through Source Safe since the projects reside in different SS databases.
+//
+// - JD
+
diff --git a/code/cgame/strip_objectives.h b/code/cgame/strip_objectives.h
new file mode 100644
index 0000000..6cdd560
--- /dev/null
+++ b/code/cgame/strip_objectives.h
@@ -0,0 +1,82 @@
+#ifndef __strip_objectives_h
+#define __strip_objectives_h
+
+
+/********************************************************************************
+
+the objectives... duh...
+
+********************************************************************************/
+
+
+#define PACKAGE_OBJECTIVES		0x08
+
+enum
+{
+	OBJECTIVES_KEJIM_POST_OBJ1 = 0x0800,
+	OBJECTIVES_KEJIM_POST_OBJ2 = 0x0801,
+	OBJECTIVES_KEJIM_BASE_OBJ1 = 0x0802,
+	OBJECTIVES_KEJIM_BASE_OBJ2 = 0x0803,
+	OBJECTIVES_KEJIM_BASE_OBJ3 = 0x0804,
+	OBJECTIVES_ARTUS_MINE_OBJ1 = 0x0805,
+	OBJECTIVES_ARTUS_MINE_OBJ2 = 0x0806,
+	OBJECTIVES_ARTUS_MINE_OBJ3 = 0x0807,
+	OBJECTIVES_ARTUS_DETENTION_OBJ1 = 0x0808,
+	OBJECTIVES_ARTUS_DETENTION_OBJ2 = 0x0809,
+	OBJECTIVES_ARTUS_TOPSIDE_OBJ1 = 0x080a,
+	OBJECTIVES_ARTUS_TOPSIDE_OBJ2 = 0x080b,
+	OBJECTIVES_YAVIN_TEMPLE_OBJ1 = 0x080c,
+	OBJECTIVES_YAVIN_TRIAL_OBJ1 = 0x080d,
+	OBJECTIVES_YAVIN_TRIAL_OBJ2 = 0x080e,
+	OBJECTIVES_NS_STREETS_OBJ1 = 0x080f,
+	OBJECTIVES_NS_STREETS_OBJ2 = 0x0810,
+	OBJECTIVES_NS_STREETS_OBJ3 = 0x0811,
+	OBJECTIVES_NS_HIDEOUT_OBJ1 = 0x0812,
+	OBJECTIVES_NS_HIDEOUT_OBJ2 = 0x0813,
+	OBJECTIVES_NS_STARPAD_OBJ1 = 0x0814,
+	OBJECTIVES_NS_STARPAD_OBJ2 = 0x0815,
+	OBJECTIVES_NS_STARPAD_OBJ3 = 0x0816,
+	OBJECTIVES_NS_STARPAD_OBJ4 = 0x0817,
+	OBJECTIVES_NS_STARPAD_OBJ5 = 0x0818,
+	OBJECTIVES_BESPIN_UNDERCITY_OBJ1 = 0x0819,
+	OBJECTIVES_BESPIN_UNDERCITY_OBJ2 = 0x081a,
+	OBJECTIVES_BESPIN_STREETS_OBJ1 = 0x081b,
+	OBJECTIVES_BESPIN_STREETS_OBJ2 = 0x081c,
+	OBJECTIVES_BESPIN_PLATFORM_OBJ1 = 0x081d,
+	OBJECTIVES_BESPIN_PLATFORM_OBJ2 = 0x081e,
+	OBJECTIVES_CAIRN_BAY_OBJ1 = 0x081f,
+	OBJECTIVES_CAIRN_BAY_OBJ2 = 0x0820,
+	OBJECTIVES_CAIRN_ASSEMBLY_OBJ1 = 0x0821,
+	OBJECTIVES_CAIRN_REACTOR_OBJ1 = 0x0822,
+	OBJECTIVES_CAIRN_REACTOR_OBJ2 = 0x0823,
+	OBJECTIVES_CAIRN_DOCK1_OBJ1 = 0x0824,
+	OBJECTIVES_CAIRN_DOCK1_OBJ2 = 0x0825,
+	OBJECTIVES_DOOM_COMM_OBJ1 = 0x0826,
+	OBJECTIVES_DOOM_COMM_OBJ2 = 0x0827,
+	OBJECTIVES_DOOM_COMM_OBJ3 = 0x0828,
+	OBJECTIVES_DOOM_DETENTION_OBJ1 = 0x0829,
+	OBJECTIVES_DOOM_DETENTION_OBJ2 = 0x082a,
+	OBJECTIVES_DOOM_SHIELDS_OBJ1 = 0x082b,
+	OBJECTIVES_DOOM_SHIELDS_OBJ2 = 0x082c,
+	OBJECTIVES_YAVIN_SWAMP_OBJ1 = 0x082d,
+	OBJECTIVES_YAVIN_SWAMP_OBJ2 = 0x082e,
+	OBJECTIVES_YAVIN_CANYON_OBJ1 = 0x082f,
+	OBJECTIVES_YAVIN_CANYON_OBJ2 = 0x0830,
+	OBJECTIVES_YAVIN_COURTYARD_OBJ1 = 0x0831,
+	OBJECTIVES_YAVIN_COURTYARD_OBJ2 = 0x0832,
+	OBJECTIVES_YAVIN_FINAL_OBJ1 = 0x0833,
+	OBJECTIVES_KEJIM_POST_OBJ3 = 0x0834,
+	OBJECTIVES_KEJIM_POST_OBJ4 = 0x0835,
+	OBJECTIVES_KEJIM_POST_OBJ5 = 0x0836,
+	OBJECTIVES_ARTUS_DETENTION_OBJ3 = 0x0837,
+	OBJECTIVES_DOOM_COMM_OBJ4 = 0x0838,
+	OBJECTIVES_DOOM_SHIELDS_OBJ3 = 0x0839,
+	OBJECTIVES_DEMO_OBJ1 = 0x083a,
+	OBJECTIVES_DEMO_OBJ2 = 0x083b,
+	OBJECTIVES_DEMO_OBJ3 = 0x083c,
+	OBJECTIVES_DEMO_OBJ4 = 0x083d
+};
+
+
+#endif // __strip_objectives_h
+
diff --git a/code/cgame/vssver.scc b/code/cgame/vssver.scc
new file mode 100644
index 0000000..f161c9e
Binary files /dev/null and b/code/cgame/vssver.scc differ
diff --git a/code/client/BinkVideo.cpp b/code/client/BinkVideo.cpp
new file mode 100644
index 0000000..6cf6ca4
--- /dev/null
+++ b/code/client/BinkVideo.cpp
@@ -0,0 +1,389 @@
+/*
+ * This version of BinkVideo.cpp now ONLY works on Xbox.
+ * GCN support is hosed.
+ */
+#include "snd_local_console.h"
+#include "../renderer/tr_local.h"
+#include "BinkVideo.h"
+#include "RAD.h"
+
+char*	binkSndMem = NULL;
+
+static void PTR4* RADEXPLINK AllocWrapper(U32 size)
+{
+	// Give bink pre-initialized sound mem on xbox
+	if(size == XBOX_BINK_SND_MEM) {
+		return binkSndMem;
+	}
+
+	return BinkVideo::Allocate(size);
+}
+
+static void RADEXPLINK FreeWrapper(void PTR4* ptr)
+{
+	BinkVideo::Free(ptr);
+}
+
+
+/*********
+BinkVideo
+*********/
+BinkVideo::BinkVideo()
+{
+	bink		= NULL;
+	buffer		= NULL;
+	texture		= 0;
+	x1			= 0.0f;
+	y1			= 0.0f;
+	x2			= 0.0f;
+	y2			= 0.0f;
+	w			= 0.0f;
+	h			= 0.0f;
+	status		= NS_BV_STOPPED;
+	looping		= false;
+	alpha		= false;
+#ifdef _XBOX
+	initialized = false;
+#endif
+}
+
+/*********
+~BinkVideo
+*********/
+BinkVideo::~BinkVideo()
+{
+	Free(buffer);
+	BinkClose(bink);
+}
+
+/*********
+AllocateXboxMem
+Pre-Allocates sound memory for xbox to avoid fragmenting
+*********/
+void BinkVideo::AllocateXboxMem(void)
+{
+	binkSndMem = (char*)Allocate(XBOX_BINK_SND_MEM);
+	initialized = true;
+}
+
+/*********
+FreeXboxMem
+*********/
+void BinkVideo::FreeXboxMem(void)
+{
+	initialized = false;
+	Z_Free(binkSndMem);
+}
+
+
+/*********
+Start
+Opens a bink file and gets it ready to play
+*********/
+bool BinkVideo::Start(const char *filename, float xOrigin, float yOrigin, float width, float height)
+{
+	assert(initialized);
+
+	// Check to see if a video is being played.
+	if(status == NS_BV_PLAYING)
+	{
+		// stop
+		this->Stop();
+	}
+
+	// Set memory allocation wrapper
+	RADSetMemory(AllocWrapper,FreeWrapper);
+
+	// Set up sound for consoles
+
+	// We are on XBox, tell Bink to play all of the 5.1 tracks
+	U32 TrackIDsToPlay[ 4 ] = { 0, 1, 2, 3 };	
+	BinkSetSoundTrack( 4, TrackIDsToPlay );
+	
+	// Now route the sound tracks to the correct speaker
+	U32 bins[ 2 ];
+
+	bins[ 0 ] = DSMIXBIN_FRONT_LEFT;
+	bins[ 1 ] = DSMIXBIN_FRONT_RIGHT;
+	BinkSetMixBins( bink, 0, bins, 2 );
+	bins[ 0 ] = DSMIXBIN_FRONT_CENTER;
+	BinkSetMixBins( bink, 1, bins, 1 );
+	bins[ 0 ] = DSMIXBIN_LOW_FREQUENCY;
+	BinkSetMixBins( bink, 2, bins, 1 );
+	bins[ 0 ] = DSMIXBIN_BACK_LEFT;
+	bins[ 1 ] = DSMIXBIN_BACK_RIGHT;
+	BinkSetMixBins( bink, 3, bins, 2 );
+	
+	
+	// Try to open the Bink file.
+	bink = BinkOpen( filename, BINKSNDTRACK | BINKALPHA );
+	if(!bink)
+	{
+		return false;
+	}
+
+	assert(bink->Width <= MAX_WIDTH && bink->Height <=MAX_HEIGHT);
+
+	// allocate memory for the frame buffer
+	buffer = AllocWrapper(XBOX_BUFFER_SIZE);
+
+	// set the height, width, etc...
+	x1 = xOrigin;
+	y1 = yOrigin;
+	x2 = x1 + width;
+	y2 = y1 + height;
+	w = width;
+	h = height;
+	// Did the source .bik file have an alpha plane?
+	alpha = (bool)(bink->OpenFlags & BINKALPHA);
+
+	// flush any background sound reads
+	extern void S_DrainRawSoundData(void);
+	S_DrainRawSoundData();
+	
+	// Create the video texture
+	GLuint tex = (GLuint)texture;
+	if (tex != 0)
+		qglDeleteTextures(1, &tex);
+
+	qglGenTextures(1, &tex);
+	qglBindTexture(GL_TEXTURE_2D, tex);
+	glState.currenttextures[glState.currenttmu] = tex;
+
+	qglTexImage2D(GL_TEXTURE_2D,
+				  0,
+				  alpha ? GL_LIN_RGBA8 : GL_LIN_RGB8,
+				  bink->Width,
+				  bink->Height,
+				  0,
+				  alpha ? GL_LIN_RGBA : GL_LIN_RGB,
+				  GL_UNSIGNED_BYTE,
+				  buffer);
+
+	qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
+	qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
+	qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP );
+	qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP );
+
+	texture = (int)tex;
+
+	status = NS_BV_PLAYING;
+
+	return true;
+}
+
+/*********
+Run
+Decompresses a frame, renders it to the screen, and advances to
+the next frame.
+*********/
+bool BinkVideo::Run(void)
+{
+	if(status == NS_BV_STOPPED) // A movie can't be run if it's not started first
+	{
+		return false;
+	}
+	
+	while(BinkWait(bink)); // Wait
+	
+	DecompressFrame(); // Decompress
+	Draw(); // Render
+	
+	if(status != NS_BV_PAUSED) // Only advance the frame is not paused
+	{
+		BinkNextFrame( bink );
+	}
+
+	if(bink->FrameNum == (bink->Frames - 1) && !looping) // The movie is done
+	{
+		Stop();
+		return false;
+	}
+	
+	return true;
+}
+
+/*********
+GetBinkData
+Returns the buffer data for the next frame of the video
+*********/
+void* BinkVideo::GetBinkData(void)
+{
+	//while(BinkWait(bink));
+	// This doesn't follow Bink guidelines. They suggest that you call BinkWait()
+	// very frequently, something like 4 to 5 times as fast as the framerate of
+	// the movie. We're technically coming close to that, but this code won't work
+	// if we have videoMap shaders with higher framerates than the planets (8).
+	if (!BinkWait(bink))
+	{
+		DecompressFrame();
+		BinkNextFrame(bink);
+	}
+	return buffer;
+}
+
+/********
+Draw
+Copies the decompressed frame to a texture to be rendered on
+the screen.
+********/
+void BinkVideo::Draw(void)
+{
+	if(buffer)
+	{
+		qglFlush();
+		
+		extern void	RB_SetGL2D (void);
+		RB_SetGL2D();
+
+		GL_SelectTexture(0);
+
+		// Update the video texture
+		qglBindTexture(GL_TEXTURE_2D, (GLuint)texture);
+		glState.currenttextures[glState.currenttmu] = texture;
+		
+		qglTexSubImage2D( GL_TEXTURE_2D, 0, 0, 0, bink->Width, bink->Height,
+			alpha ? GL_RGBA : GL_RGB, GL_UNSIGNED_BYTE, buffer );
+			
+		// Clear the screen.  We use triangles here (instead
+		// of glClear) because we want the back buffer to stick
+		// around... so we can get a nice, cheap fade on Gamecube
+		// reset.
+		qglColor3f(0.f, 0.f, 0.f);
+#if defined (_XBOX) || (_GAMECUBE)
+		qglBeginEXT (GL_TRIANGLE_STRIP, 4, 0, 0, 4, 0);
+#else
+		qglBegin(GL_TRIANGLE_STRIP);
+#endif
+		qglTexCoord2f ( 0,  0 );
+		qglVertex2f (-10, -10);
+		qglTexCoord2f ( bink->Width ,  0 );
+		qglVertex2f (650, -10);
+		qglTexCoord2f ( 0, bink->Height );
+		qglVertex2f (-10, 490);
+		qglTexCoord2f ( bink->Width, bink->Height );
+		qglVertex2f (650, 490);
+		qglEnd ();
+		
+		// Draw the video
+		qglColor3f(1.f, 1.f, 1.f);
+#if defined (_XBOX) || (_GAMECUBE)
+		qglBeginEXT (GL_TRIANGLE_STRIP, 4, 0, 0, 4, 0);
+#else
+		qglBegin(GL_TRIANGLE_STRIP);
+#endif
+		qglTexCoord2f ( 0,  0 );
+		qglVertex2f (x1, y1);
+		qglTexCoord2f ( bink->Width ,  0 );
+		qglVertex2f (x2, y1);
+		qglTexCoord2f ( 0, bink->Height );
+		qglVertex2f (x1, y2);
+		qglTexCoord2f ( bink->Width, bink->Height );
+		qglVertex2f (x2, y2);
+		qglEnd ();
+	}
+}
+
+/*********
+Stop
+Stops the current movie, and clears it from memory
+*********/
+void BinkVideo::Stop(void)
+{
+	if (bink)
+		BinkClose(bink);
+	bink	= NULL;
+
+	if (buffer)
+		FreeWrapper(buffer);
+	buffer	= NULL;
+
+	GLuint tex = (GLuint)texture;
+	if (tex != 0)
+		qglDeleteTextures(1, &tex);
+
+	texture	= 0;
+	x1		= 0.0f;
+	y1		= 0.0f;
+	x2		= 0.0f;
+	y2		= 0.0f;
+	w		= 0.0f;
+	h		= 0.0f;
+	status	= NS_BV_STOPPED;
+}
+
+/*********
+Pause
+Pauses the current movie. Only the current frame is rendered
+*********/
+void BinkVideo::Pause(void)
+{
+	status = NS_BV_PAUSED;
+}
+
+/*********
+SetExtents
+Sets dimmension variables
+*********/
+
+void BinkVideo::SetExtents(float xOrigin, float yOrigin, float width, float height)
+{
+	x1 = xOrigin;
+	y1 = yOrigin;
+	x2 = x1 + width;
+	y2 = y1 + height;
+	w = width;
+	h = height;
+}
+
+/*********
+SetMasterVolume
+Sets the volume of the specified track
+*********/
+void BinkVideo::SetMasterVolume(s32 volume)
+{
+	int i;
+	for(i = 0; i < 4; i++)
+	{
+		BinkSetVolume(bink,i,volume);
+	}
+}
+
+/*********
+DecompressFrame
+Decompresses current frame and copies the data to
+the buffer
+*********/
+S32 BinkVideo::DecompressFrame()
+{
+	BinkDoFrame(bink);
+
+	S32 skip;	
+	skip = BinkCopyToBuffer(
+		bink,
+		(void *)buffer,
+		NS_BV_DEFAULT_CIN_BPS * bink->Width, //pitch
+		bink->Height,
+		0,
+		0,
+		alpha ? BINKCOPYALL | BINKSURFACE32A : BINKCOPYALL | BINKSURFACE32);
+	return skip;
+}
+
+/*********
+Allocate
+Allocates memory for the frame buffer
+*********/
+void *BinkVideo::Allocate(U32 size)
+{
+	return Z_Malloc(size, TAG_BINK, qfalse, 32);
+}
+
+/*********
+FreeBuffer
+Releases the frame buffer memory
+*********/
+void BinkVideo::Free(void* ptr)
+{
+	Z_Free(ptr);
+}
diff --git a/code/client/BinkVideo.h b/code/client/BinkVideo.h
new file mode 100644
index 0000000..8c65405
--- /dev/null
+++ b/code/client/BinkVideo.h
@@ -0,0 +1,63 @@
+#ifndef NS_BINKVIDEO
+#define NS_BINKVIDEO
+
+#include "bink.h"
+#define NS_BV_DEFAULT_CIN_BPS (4)
+#define MAX_WIDTH			512
+#define MAX_HEIGHT			512
+
+#define XBOX_BUFFER_SIZE	NS_BV_DEFAULT_CIN_BPS * MAX_WIDTH * MAX_HEIGHT
+#define XBOX_BINK_SND_MEM	16448
+
+typedef enum {
+	NS_BV_PLAYING,		// Movie is playing
+	NS_BV_STOPPED,		// Movie is stopped
+	NS_BV_PAUSED		// Movie is paused
+};
+
+class BinkVideo
+{
+private:
+	HBINK	bink;
+	void*	buffer;
+	int		texture;
+	int		status;
+	bool	looping;
+	bool	alpha;
+	float	x1;
+	float	y1;
+	float   x2;
+	float	y2;
+	float	w;
+	float	h;
+
+	bool	initialized;
+
+	void	Draw(void);
+	S32		DecompressFrame();
+	
+
+public:
+	
+	BinkVideo();
+	~BinkVideo();
+	bool	Start(const char *filename, float xOrigin, float yOrigin, float width, float height);
+	bool	Run(void);
+	void	Stop(void);
+	void	Pause(void);
+	void	SetExtents(float xOrigin, float yOrigin, float width, float height);
+	int		GetStatus(void) { return status; }
+	void	SetLooping(bool loop) { looping = loop; }
+	void*	GetBinkData(void);
+	int		GetBinkWidth(void) { return this->bink->Width; }
+	int		GetBinkHeight(void) { return this->bink->Height; }
+	void	SetMasterVolume(s32 volume);
+	void	AllocateXboxMem(void);
+	void	FreeXboxMem(void);
+	static void*	Allocate(U32 size);
+	static void		Free(void* ptr);
+
+	bool	Ready(void) { return (bool)this->bink; }
+};
+
+#endif
diff --git a/code/client/OpenAL/al.h b/code/client/OpenAL/al.h
new file mode 100644
index 0000000..0afa74b
--- /dev/null
+++ b/code/client/OpenAL/al.h
@@ -0,0 +1,564 @@
+#ifndef _AL_H_
+#define _AL_H_
+
+/**
+ * OpenAL cross platform audio library
+ * Copyright (C) 1999-2000 by authors.
+ * This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ *  Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the
+ *  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ *  Boston, MA  02111-1307, USA.
+ * Or go to http://www.gnu.org/copyleft/lgpl.html
+ */
+#include "altypes.h"
+
+#ifdef _XBOX
+ #define ALAPI
+ #define ALAPIENTRY
+ #define AL_CALLBACK
+#else
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef _WIN32
+ #ifdef _OPENAL32LIB
+  #define ALAPI __declspec(dllexport)
+ #else
+  #define ALAPI __declspec(dllimport)
+ #endif
+ #define ALAPIENTRY __cdecl
+ #define AL_CALLBACK
+#else
+ #ifdef TARGET_OS_MAC
+  #if TARGET_OS_MAC
+   #pragma export on
+  #endif
+ #endif
+ #define ALAPI
+ #define ALAPIENTRY __cdecl
+ #define AL_CALLBACK
+#endif
+#endif
+
+#define OPENAL
+
+#ifndef AL_NO_PROTOTYPES
+
+/**
+ * OpenAL Maintenance Functions
+ * Initialization and exiting.
+ * State Management and Query.
+ * Error Handling.
+ * Extension Support.
+ */
+
+/** State management. */
+ALAPI ALvoid	ALAPIENTRY alEnable( ALenum capability );
+ALAPI ALvoid	ALAPIENTRY alDisable( ALenum capability ); 
+ALAPI ALboolean ALAPIENTRY alIsEnabled( ALenum capability ); 
+
+/** Application preferences for driver performance choices. */
+ALAPI ALvoid	ALAPIENTRY alHint( ALenum target, ALenum mode );
+
+/** State retrieval. */
+ALAPI ALboolean ALAPIENTRY alGetBoolean( ALenum param );
+ALAPI ALint		ALAPIENTRY alGetInteger( ALenum param );
+ALAPI ALfloat	ALAPIENTRY alGetFloat( ALenum param );
+ALAPI ALdouble	ALAPIENTRY alGetDouble( ALenum param );
+ALAPI ALvoid	ALAPIENTRY alGetBooleanv( ALenum param, ALboolean* data );
+ALAPI ALvoid	ALAPIENTRY alGetIntegerv( ALenum param, ALint* data );
+ALAPI ALvoid	ALAPIENTRY alGetFloatv( ALenum param, ALfloat* data );
+ALAPI ALvoid	ALAPIENTRY alGetDoublev( ALenum param, ALdouble* data );
+ALAPI ALubyte*	ALAPIENTRY alGetString( ALenum param );
+
+/**
+ * Error support.
+ * Obtain the most recent error generated in the AL state machine.
+ */
+ALAPI ALenum	ALAPIENTRY alGetError( ALvoid );
+
+#ifdef _XBOX
+/**
+ * Update cycle.
+ */
+ALAPI ALvoid	ALAPIENTRY alUpdate( ALvoid );
+
+/**
+ * Returns a global state parameter.
+ */
+ALAPI ALvoid	ALAPIENTRY alGeti( ALenum param, ALint* value );
+
+/**
+ * Adjust the size of the sound buffer pool.
+ */
+ALAPI ALvoid	ALAPIENTRY alResizePool( ALuint size );
+#endif
+
+/** 
+ * Extension support.
+ * Obtain the address of a function (usually an extension)
+ *  with the name fname. All addresses are context-independent. 
+ */
+ALAPI ALboolean ALAPIENTRY alIsExtensionPresent( ALubyte* fname );
+
+
+/** 
+ * Extension support.
+ * Obtain the address of a function (usually an extension)
+ *  with the name fname. All addresses are context-independent. 
+ */
+ALAPI ALvoid*	ALAPIENTRY alGetProcAddress( ALubyte* fname );
+
+
+/**
+ * Extension support.
+ * Obtain the integer value of an enumeration (usually an extension) with the name ename. 
+ */
+ALAPI ALenum	ALAPIENTRY alGetEnumValue( ALubyte* ename );
+
+
+
+
+/**
+ * LISTENER
+ * Listener is the sample position for a given context.
+ * The multi-channel (usually stereo) output stream generated
+ *  by the mixer is parametrized by this Listener object:
+ *  its position and velocity relative to Sources, within
+ *  occluder and reflector geometry.
+ */
+
+
+
+#ifdef _XBOX
+/**
+ * Listener create and delete
+ */
+ALAPI ALvoid	ALAPIENTRY alGenListeners( ALsizei n, ALuint* listeners );
+ALAPI ALvoid	ALAPIENTRY alDeleteListeners( ALsizei n, ALuint* listeners );
+#endif
+
+// VV's Console version of openAL includes multiple listener support,
+// as an extra first arg to the alListener functions. We wrap that up
+// in a macro here, to make the following more concise.
+#ifdef _XBOX
+#define AL_VV_LISTENER ALuint listener,
+#else
+#define AL_VV_LISTENER
+#endif
+
+/**
+ *
+ * Listener Environment:  default 0.
+ */
+ALAPI ALvoid	ALAPIENTRY alListeneri( AL_VV_LISTENER ALenum param, ALint value );
+
+
+/**
+ *
+ * Listener Gain:  default 1.0f.
+ */
+ALAPI ALvoid	ALAPIENTRY alListenerf( AL_VV_LISTENER ALenum param, ALfloat value );
+
+
+/**  
+ *
+ * Listener Position.
+ * Listener Velocity.
+ */
+ALAPI ALvoid	ALAPIENTRY alListener3f( AL_VV_LISTENER ALenum param, ALfloat v1, ALfloat v2, ALfloat v3 ); 
+
+
+/**
+ *
+ * Listener Position:        ALfloat[3]
+ * Listener Velocity:        ALfloat[3]
+ * Listener Orientation:     ALfloat[6]  (forward and up vector).
+ */
+ALAPI ALvoid	ALAPIENTRY alListenerfv( AL_VV_LISTENER ALenum param, ALfloat* values ); 
+
+ALAPI ALvoid	ALAPIENTRY alGetListeneri( AL_VV_LISTENER ALenum param, ALint* value );
+ALAPI ALvoid	ALAPIENTRY alGetListenerf( AL_VV_LISTENER ALenum param, ALfloat* value );
+ALAPI ALvoid	ALAPIENTRY alGetListener3f( AL_VV_LISTENER ALenum param, ALfloat* v1, ALfloat* v2, ALfloat* v3 ); 
+ALAPI ALvoid	ALAPIENTRY alGetListenerfv( AL_VV_LISTENER ALenum param, ALfloat* values ); 
+
+
+/**
+ * SOURCE
+ * Source objects are by default localized. Sources
+ *  take the PCM data provided in the specified Buffer,
+ *  apply Source-specific modifications, and then
+ *  submit them to be mixed according to spatial 
+ *  arrangement etc.
+ */
+
+
+
+/** Create Source objects. */
+#ifdef _XBOX
+ALAPI ALvoid	ALAPIENTRY alGenSources2D( ALsizei n, ALuint* sources ); 
+ALAPI ALvoid	ALAPIENTRY alGenSources3D( ALsizei n, ALuint* sources ); 
+#else
+ALAPI ALvoid	ALAPIENTRY alGenSources( ALsizei n, ALuint* sources ); 
+#endif
+
+/** Delete Source objects. */
+ALAPI ALvoid	ALAPIENTRY alDeleteSources( ALsizei n, ALuint* sources );
+
+/** Verify a handle is a valid Source. */ 
+ALAPI ALboolean ALAPIENTRY alIsSource( ALuint id ); 
+
+/** Set an integer parameter for a Source object. */
+ALAPI ALvoid	ALAPIENTRY alSourcei( ALuint source, ALenum param, ALint value ); 
+ALAPI ALvoid	ALAPIENTRY alSourcef( ALuint source, ALenum param, ALfloat value ); 
+ALAPI ALvoid	ALAPIENTRY alSource3f( ALuint source, ALenum param, ALfloat v1, ALfloat v2, ALfloat v3 );
+ALAPI ALvoid	ALAPIENTRY alSourcefv( ALuint source, ALenum param, ALfloat* values ); 
+
+/** Get an integer parameter for a Source object. */
+ALAPI ALvoid	ALAPIENTRY alGetSourcei( ALuint source,  ALenum param, ALint* value );
+ALAPI ALvoid	ALAPIENTRY alGetSourcef( ALuint source,  ALenum param, ALfloat* value );
+ALAPI ALvoid	ALAPIENTRY alGetSource3f( ALuint source,  ALenum param, ALfloat* v1, ALfloat* v2, ALfloat* v3 );
+ALAPI ALvoid	ALAPIENTRY alGetSourcefv( ALuint source, ALenum param, ALfloat* values );
+
+ALAPI ALvoid	ALAPIENTRY alSourcePlayv( ALsizei n, ALuint *sources );
+ALAPI ALvoid	ALAPIENTRY alSourcePausev( ALsizei n, ALuint *sources );
+ALAPI ALvoid	ALAPIENTRY alSourceStopv( ALsizei n, ALuint *sources );
+ALAPI ALvoid	ALAPIENTRY alSourceRewindv(ALsizei n,ALuint *sources);
+
+/** Activate a source, start replay. */
+ALAPI ALvoid	ALAPIENTRY alSourcePlay( ALuint source );
+
+/**
+ * Pause a source, 
+ *  temporarily remove it from the mixer list.
+ */
+ALAPI ALvoid	ALAPIENTRY alSourcePause( ALuint source );
+
+/**
+ * Stop a source,
+ *  temporarily remove it from the mixer list,
+ *  and reset its internal state to pre-Play.
+ * To remove a Source completely, it has to be
+ *  deleted following Stop, or before Play.
+ */
+ALAPI ALvoid	ALAPIENTRY alSourceStop( ALuint source );
+
+/**
+ * Rewinds a source, 
+ *  temporarily remove it from the mixer list,
+ *  and reset its internal state to pre-Play.
+ */
+ALAPI ALvoid	ALAPIENTRY alSourceRewind( ALuint source );
+
+
+
+/**
+ * BUFFER
+ * Buffer objects are storage space for sample data.
+ * Buffers are referred to by Sources. There can be more than
+ *  one Source using the same Buffer data. If Buffers have
+ *  to be duplicated on a per-Source basis, the driver has to
+ *  take care of allocation, copying, and deallocation as well
+ *  as propagating buffer data changes.
+ */
+
+
+
+
+/** Buffer object generation. */
+ALAPI ALvoid 	ALAPIENTRY alGenBuffers( ALsizei n, ALuint* buffers );
+ALAPI ALvoid	ALAPIENTRY alDeleteBuffers( ALsizei n, ALuint* buffers );
+ALAPI ALboolean ALAPIENTRY alIsBuffer( ALuint buffer );
+
+/**
+ * Specify the data to be filled into a buffer.
+ */
+ALAPI ALvoid	ALAPIENTRY alBufferData( ALuint   buffer,
+										 ALenum   format,
+										 ALvoid*  data,
+										 ALsizei  size,
+										 ALsizei  freq );
+
+
+ALAPI ALvoid	ALAPIENTRY alGetBufferi( ALuint buffer, ALenum param, ALint*   value );
+ALAPI ALvoid	ALAPIENTRY alGetBufferf( ALuint buffer, ALenum param, ALfloat* value );
+
+
+
+
+/**
+ * Queue stuff
+ */
+
+ALAPI ALvoid	ALAPIENTRY alSourceQueueBuffers( ALuint source, ALsizei n, ALuint* buffers );
+ALAPI ALvoid	ALAPIENTRY alSourceUnqueueBuffers( ALuint source, ALsizei n, ALuint* buffers );
+
+
+
+
+#ifdef _XBOX
+/**
+ * STREAM
+ * Stream objects encapsulate traditional sound stream and
+ *  act as both sources and buffers.  They emit sound and 
+ *  manage sound data.
+ */
+
+ALAPI ALvoid	ALAPIENTRY alGenStream( ALvoid );
+ALAPI ALvoid	ALAPIENTRY alDeleteStream( ALvoid );
+
+ALAPI ALvoid	ALAPIENTRY alStreamStop( ALvoid );
+ALAPI ALvoid	ALAPIENTRY alStreamPlay( ALsizei offset, ALint file, ALint loop );
+
+ALAPI ALvoid	ALAPIENTRY alStreamf( ALenum param, ALfloat value );
+
+ALAPI ALvoid	ALAPIENTRY alGetStreamf( ALenum param, ALfloat* value );
+ALAPI ALvoid	ALAPIENTRY alGetStreami( ALenum param, ALint* value );
+#endif
+
+
+/**
+ * Knobs and dials
+ */
+ALAPI ALvoid	ALAPIENTRY alDistanceModel( ALenum value );
+ALAPI ALvoid	ALAPIENTRY alDopplerFactor( ALfloat value );
+ALAPI ALvoid	ALAPIENTRY alDopplerVelocity( ALfloat value );
+#ifdef _XBOX
+ALAPI ALvoid	ALAPIENTRY alGain( ALfloat value );
+#endif
+
+#else /* AL_NO_PROTOTYPES */
+
+/**
+ * OpenAL Maintenance Functions
+ * Initialization and exiting.
+ * State Management and Query.
+ * Error Handling.
+ * Extension Support.
+ */
+
+/** State management. */
+ALAPI ALvoid	ALAPIENTRY (*alEnable)( ALenum capability );
+ALAPI ALvoid	ALAPIENTRY (*alDisable)( ALenum capability ); 
+ALAPI ALboolean ALAPIENTRY (*alIsEnabled)( ALenum capability ); 
+
+/** Application preferences for driver performance choices. */
+ALAPI ALvoid	ALAPIENTRY (*alHint)( ALenum target, ALenum mode );
+
+/** State retrieval. */
+ALAPI ALboolean ALAPIENTRY (*alGetBoolean)( ALenum param );
+ALAPI ALint		ALAPIENTRY (*alGetInteger)( ALenum param );
+ALAPI ALfloat	ALAPIENTRY (*alGetFloat)( ALenum param );
+ALAPI ALdouble	ALAPIENTRY (*alGetDouble)( ALenum param );
+ALAPI ALvoid	ALAPIENTRY (*alGetBooleanv)( ALenum param, ALboolean* data );
+ALAPI ALvoid	ALAPIENTRY (*alGetIntegerv)( ALenum param, ALint* data );
+ALAPI ALvoid	ALAPIENTRY (*alGetFloatv)( ALenum param, ALfloat* data );
+ALAPI ALvoid	ALAPIENTRY (*alGetDoublev)( ALenum param, ALdouble* data );
+ALAPI ALubyte*	ALAPIENTRY (*alGetString)( ALenum param );
+
+/**
+ * Error support.
+ * Obtain the most recent error generated in the AL state machine.
+ */
+ALAPI ALenum	ALAPIENTRY (*alGetError)( ALvoid );
+
+
+/** 
+ * Extension support.
+ * Obtain the address of a function (usually an extension)
+ *  with the name fname. All addresses are context-independent. 
+ */
+ALAPI ALboolean ALAPIENTRY (*alIsExtensionPresent)( ALubyte* fname );
+
+
+/** 
+ * Extension support.
+ * Obtain the address of a function (usually an extension)
+ *  with the name fname. All addresses are context-independent. 
+ */
+ALAPI ALvoid*	ALAPIENTRY (*alGetProcAddress)( ALubyte* fname );
+
+
+/**
+ * Extension support.
+ * Obtain the integer value of an enumeration (usually an extension) with the name ename. 
+ */
+ALAPI ALenum	ALAPIENTRY (*alGetEnumValue)( ALubyte* ename );
+
+
+
+
+/**
+ * LISTENER
+ * Listener is the sample position for a given context.
+ * The multi-channel (usually stereo) output stream generated
+ *  by the mixer is parametrized by this Listener object:
+ *  its position and velocity relative to Sources, within
+ *  occluder and reflector geometry.
+ */
+
+
+
+/**
+ *
+ * Listener Environment:  default 0.
+ */
+ALAPI ALvoid	ALAPIENTRY (*alListeneri)( ALenum param, ALint value );
+
+
+/**
+ *
+ * Listener Gain:  default 1.0f.
+ */
+ALAPI ALvoid	ALAPIENTRY (*alListenerf)( ALenum param, ALfloat value );
+
+
+/**  
+ *
+ * Listener Position.
+ * Listener Velocity.
+ */
+ALAPI ALvoid	ALAPIENTRY (*alListener3f)( ALenum param, ALfloat v1, ALfloat v2, ALfloat v3 ); 
+
+
+/**
+ *
+ * Listener Position:        ALfloat[3]
+ * Listener Velocity:        ALfloat[3]
+ * Listener Orientation:     ALfloat[6]  (forward and up vector).
+ */
+ALAPI ALvoid	ALAPIENTRY (*alListenerfv)( ALenum param, ALfloat* values ); 
+
+ALAPI ALvoid	ALAPIENTRY (*alGetListeneri)( ALenum param, ALint* value );
+ALAPI ALvoid	ALAPIENTRY (*alGetListenerf)( ALenum param, ALfloat* value );
+ALAPI ALvoid	ALAPIENTRY (*alGetListener3f)( ALenum param, ALfloat* v1, ALfloat* v2, ALfloat* v3 ); 
+ALAPI ALvoid	ALAPIENTRY (*alGetListenerfv)( ALenum param, ALfloat* values ); 
+
+
+/**
+ * SOURCE
+ * Source objects are by default localized. Sources
+ *  take the PCM data provided in the specified Buffer,
+ *  apply Source-specific modifications, and then
+ *  submit them to be mixed according to spatial 
+ *  arrangement etc.
+ */
+
+
+
+/** Create Source objects. */
+ALAPI ALvoid	ALAPIENTRY (*alGenSources)( ALsizei n, ALuint* sources ); 
+
+/** Delete Source objects. */
+ALAPI ALvoid	ALAPIENTRY (*alDeleteSources)( ALsizei n, ALuint* sources );
+
+/** Verify a handle is a valid Source. */ 
+ALAPI ALboolean ALAPIENTRY (*alIsSource)( ALuint id ); 
+
+/** Set an integer parameter for a Source object. */
+ALAPI ALvoid	ALAPIENTRY (*alSourcei)( ALuint source, ALenum param, ALint value ); 
+ALAPI ALvoid	ALAPIENTRY (*alSourcef)( ALuint source, ALenum param, ALfloat value ); 
+ALAPI ALvoid	ALAPIENTRY (*alSource3f)( ALuint source, ALenum param, ALfloat v1, ALfloat v2, ALfloat v3 );
+ALAPI ALvoid	ALAPIENTRY (*alSourcefv)( ALuint source, ALenum param, ALfloat* values ); 
+
+/** Get an integer parameter for a Source object. */
+ALAPI ALvoid	ALAPIENTRY (*alGetSourcei)( ALuint source,  ALenum param, ALint* value );
+ALAPI ALvoid	ALAPIENTRY (*alGetSourcef)( ALuint source,  ALenum param, ALfloat* value );
+ALAPI ALvoid	ALAPIENTRY (*alGetSourcefv)( ALuint source, ALenum param, ALfloat* values );
+
+ALAPI ALvoid	ALAPIENTRY (*alSourcePlayv)( ALsizei n, ALuint *sources );
+ALAPI ALvoid	ALAPIENTRY (*alSourceStopv)( ALsizei n, ALuint *sources );
+
+/** Activate a source, start replay. */
+ALAPI ALvoid	ALAPIENTRY (*alSourcePlay)( ALuint source );
+
+/**
+ * Pause a source, 
+ *  temporarily remove it from the mixer list.
+ */
+ALAPI ALvoid	ALAPIENTRY (*alSourcePause)( ALuint source );
+
+/**
+ * Stop a source,
+ *  temporarily remove it from the mixer list,
+ *  and reset its internal state to pre-Play.
+ * To remove a Source completely, it has to be
+ *  deleted following Stop, or before Play.
+ */
+ALAPI ALvoid	ALAPIENTRY (*alSourceStop)( ALuint source );
+
+
+
+/**
+ * BUFFER
+ * Buffer objects are storage space for sample data.
+ * Buffers are referred to by Sources. There can be more than
+ *  one Source using the same Buffer data. If Buffers have
+ *  to be duplicated on a per-Source basis, the driver has to
+ *  take care of allocation, copying, and deallocation as well
+ *  as propagating buffer data changes.
+ */
+
+
+
+
+/** Buffer object generation. */
+ALAPI ALvoid 	ALAPIENTRY (*alGenBuffers)( ALsizei n, ALuint* buffers );
+ALAPI ALvoid	ALAPIENTRY (*alDeleteBuffers)( ALsizei n, ALuint* buffers );
+ALAPI ALboolean ALAPIENTRY (*alIsBuffer)( ALuint buffer );
+
+/**
+ * Specify the data to be filled into a buffer.
+ */
+ALAPI ALvoid	ALAPIENTRY (*alBufferData)( ALuint   buffer,
+											ALenum   format,
+											ALvoid*  data,
+											ALsizei  size,
+											ALsizei  freq );
+
+ALAPI ALvoid	ALAPIENTRY (*alGetBufferi)( ALuint buffer, ALenum param, ALint*   value );
+ALAPI ALvoid	ALAPIENTRY (*alGetBufferf)( ALuint buffer, ALenum param, ALfloat* value );
+
+
+
+
+/**
+ * Queue stuff
+ */
+ALAPI ALvoid	ALAPIENTRY (*alSourceQueueBuffers)( ALuint source, ALsizei n, ALuint* buffers );
+ALAPI ALvoid	ALAPIENTRY (*alSourceUnqueueBuffers)( ALuint source, ALsizei n, ALuint* buffers );
+
+/**
+ * Knobs and dials
+ */
+ALAPI ALvoid	ALAPIENTRY (*alDistanceModel)( ALenum value );
+ALAPI ALvoid	ALAPIENTRY (*alDopplerFactor)( ALfloat value );
+ALAPI ALvoid	ALAPIENTRY (*alDopplerVelocity)( ALfloat value );
+
+#endif /* AL_NO_PROTOTYPES */
+
+#ifdef TARGET_OS_MAC
+ #if TARGET_OS_MAC
+  #pragma export off
+ #endif
+#endif
+
+#ifndef _XBOX
+#ifdef __cplusplus
+}
+#endif
+#endif
+
+#endif
diff --git a/code/client/OpenAL/alc.h b/code/client/OpenAL/alc.h
new file mode 100644
index 0000000..ab1fd3c
--- /dev/null
+++ b/code/client/OpenAL/alc.h
@@ -0,0 +1,97 @@
+#ifndef _ALC_H_
+#define _ALC_H_
+
+#include "altypes.h"
+#include "alctypes.h"
+
+#ifdef _XBOX
+ #define ALCAPI
+ #define ALCAPIENTRY
+#else
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef _WIN32
+ #ifdef _OPENAL32LIB
+  #define ALCAPI __declspec(dllexport)
+ #else
+  #define ALCAPI __declspec(dllimport)
+ #endif
+
+ typedef struct ALCdevice_struct ALCdevice;
+ typedef struct ALCcontext_struct ALCcontext;
+
+ #define ALCAPIENTRY __cdecl
+#else
+ #ifdef TARGET_OS_MAC
+  #if TARGET_OS_MAC
+   #pragma export on
+  #endif
+ #endif
+ #define ALCAPI
+ #define ALCAPIENTRY __cdecl
+#endif
+
+#endif
+
+#ifndef ALC_NO_PROTOTYPES
+
+ALCAPI ALCubyte*  ALCAPIENTRY alcGetString(ALCdevice *device,ALCenum param);
+ALCAPI ALCvoid    ALCAPIENTRY alcGetIntegerv(ALCdevice *device,ALCenum param,ALCsizei size,ALCint *data);
+
+ALCAPI ALCdevice* ALCAPIENTRY alcOpenDevice(ALCubyte *deviceName);
+ALCAPI ALCvoid    ALCAPIENTRY alcCloseDevice(ALCdevice *device);
+
+ALCAPI ALCcontext*ALCAPIENTRY alcCreateContext(ALCdevice *device,ALCint *attrList);
+ALCAPI ALCboolean ALCAPIENTRY alcMakeContextCurrent(ALCcontext *context);
+ALCAPI ALCvoid	  ALCAPIENTRY alcProcessContext(ALCcontext *context);
+ALCAPI ALCcontext*ALCAPIENTRY alcGetCurrentContext(ALCvoid);
+ALCAPI ALCdevice* ALCAPIENTRY alcGetContextsDevice(ALCcontext *context);
+ALCAPI ALCvoid	  ALCAPIENTRY alcSuspendContext(ALCcontext *context);
+ALCAPI ALCvoid    ALCAPIENTRY alcDestroyContext(ALCcontext *context);
+
+ALCAPI ALCenum	  ALCAPIENTRY alcGetError(ALCdevice *device);
+
+ALCAPI ALCboolean ALCAPIENTRY alcIsExtensionPresent(ALCdevice *device,ALCubyte *extName);
+ALCAPI ALCvoid *  ALCAPIENTRY alcGetProcAddress(ALCdevice *device,ALCubyte *funcName);
+ALCAPI ALCenum	  ALCAPIENTRY alcGetEnumValue(ALCdevice *device,ALCubyte *enumName);
+				
+#else /* AL_NO_PROTOTYPES */
+
+ALCAPI ALCubyte*  ALCAPIENTRY (*alcGetString)(ALCdevice *device,ALCenum param);
+ALCAPI ALCvoid    ALCAPIENTRY (*alcGetIntegerv)(ALCdevice * device,ALCenum param,ALCsizei size,ALCint *data);
+
+ALCAPI ALCdevice* ALCAPIENTRY (*alcOpenDevice)(ALubyte *deviceName);
+ALCAPI ALCvoid    ALCAPIENTRY (*alcCloseDevice)(ALCdevice *device);
+
+ALCAPI ALCcontext*ALCAPIENTRY (*alcCreateContext)(ALCdevice *device,ALCint *attrList);
+ALCAPI ALCboolean ALCAPIENTRY (*alcMakeContextCurrent)(ALCcontext *context);
+ALCAPI ALCvoid	  ALCAPIENTRY (*alcProcessContext)(ALCcontext *context);
+ALCAPI ALCcontext*ALCAPIENTRY (*alcGetCurrentContext)(ALCvoid);
+ALCAPI ALCdevice* ALCAPIENTRY (*alcGetContextsDevice)(ALCcontext *context);
+ALCAPI ALCvoid	  ALCAPIENTRY (*alcSuspendContext)(ALCcontext *context);
+ALCAPI ALCvoid    ALCAPIENTRY (*alcDestroyContext)(ALCcontext *context);
+
+ALCAPI ALCenum	  ALCAPIENTRY (*alcGetError)(ALCdevice *device);
+
+ALCAPI ALCboolean ALCAPIENTRY (*alcIsExtensionPresent)(ALCdevice *device,ALCubyte *extName);
+ALCAPI ALCvoid *  ALCAPIENTRY (*alcGetProcAddress)(ALCdevice *device,ALCubyte *funcName);
+ALCAPI ALCenum	  ALCAPIENTRY (*alcGetEnumValue)(ALCdevice *device,ALCubyte *enumName);
+
+#endif /* AL_NO_PROTOTYPES */
+
+#ifdef TARGET_OS_MAC
+ #if TARGET_OS_MAC
+  #pragma export off
+ #endif
+#endif
+
+#ifndef _XBOX
+#ifdef __cplusplus
+}
+#endif
+#endif
+
+#endif
diff --git a/code/client/OpenAL/alctypes.h b/code/client/OpenAL/alctypes.h
new file mode 100644
index 0000000..6450837
--- /dev/null
+++ b/code/client/OpenAL/alctypes.h
@@ -0,0 +1,133 @@
+#ifndef _ALCTYPES_H_
+#define _ALCTYPES_H_
+
+/**
+ * OpenAL cross platform audio library
+ * Copyright (C) 1999-2000 by authors.
+ * This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ *  Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the
+ *  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ *  Boston, MA  02111-1307, USA.
+ * Or go to http://www.gnu.org/copyleft/lgpl.html
+ */
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef _XBOX
+/** ALC device type. */
+typedef int ALCdevice;
+
+/** ALC context type. */
+typedef int ALCcontext;
+#endif
+
+/** ALC boolean type. */
+typedef char ALCboolean;
+
+/** ALC 8bit signed byte. */
+typedef char ALCbyte;
+
+/** ALC 8bit unsigned byte. */
+typedef unsigned char ALCubyte;
+
+/** ALC 16bit signed short integer type. */
+typedef short ALCshort;
+
+/** ALC 16bit unsigned short integer type. */
+typedef unsigned short ALCushort;
+
+/** ALC 32bit unsigned integer type. */
+typedef unsigned ALCuint;
+
+/** ALC 32bit signed integer type. */
+typedef int ALCint;
+
+/** ALC 32bit floating point type. */
+typedef float ALCfloat;
+
+/** ALC 64bit double point type. */
+typedef double ALCdouble;
+
+/** ALC 32bit type. */
+typedef unsigned int ALCsizei;
+
+/** ALC void type */
+typedef void ALCvoid;
+
+/** ALC enumerations. */
+typedef int ALCenum;
+
+/* Bad value. */
+#define ALC_INVALID                              (-1)
+
+/* Boolean False. */
+#define ALC_FALSE                                0
+
+/* Boolean True. */
+#define ALC_TRUE                                 1
+
+/** Errors: No Error. */
+#define ALC_NO_ERROR                             ALC_FALSE
+
+#define ALC_MAJOR_VERSION                        0x1000
+#define ALC_MINOR_VERSION                        0x1001
+#define ALC_ATTRIBUTES_SIZE                      0x1002
+#define ALC_ALL_ATTRIBUTES                       0x1003
+
+#define ALC_DEFAULT_DEVICE_SPECIFIER             0x1004
+#define ALC_DEVICE_SPECIFIER                     0x1005
+#define ALC_EXTENSIONS                           0x1006
+
+#define ALC_FREQUENCY							 0x1007
+#define	ALC_REFRESH								 0x1008
+#define ALC_SYNC								 0x1009
+
+/** 
+ * The device argument does not name a valid dvice.
+ */
+#define ALC_INVALID_DEVICE                       0xA001
+
+/** 
+ * The context argument does not name a valid context.
+ */
+#define ALC_INVALID_CONTEXT                      0xA002  
+
+/**
+ * A function was called at inappropriate time,
+ *  or in an inappropriate way, causing an illegal state.
+ * This can be an incompatible ALenum, object ID,
+ *  and/or function.
+ */
+#define ALC_INVALID_ENUM						 0xA003
+
+/** 
+ * Illegal value passed as an argument to an AL call.
+ * Applies to parameter values, but not to enumerations.
+ */
+#define ALC_INVALID_VALUE                        0xA004
+
+/**
+ * A function could not be completed,
+ * because there is not enough memory available.
+ */
+#define ALC_OUT_OF_MEMORY                        0xA005
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
diff --git a/code/client/OpenAL/altypes.h b/code/client/OpenAL/altypes.h
new file mode 100644
index 0000000..d33514f
--- /dev/null
+++ b/code/client/OpenAL/altypes.h
@@ -0,0 +1,351 @@
+#ifndef _ALTYPES_H_
+#define _ALTYPES_H_
+
+/**
+ * OpenAL cross platform audio library
+ * Copyright (C) 1999-2000 by authors.
+ * This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ *  Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the
+ *  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ *  Boston, MA  02111-1307, USA.
+ * Or go to http://www.gnu.org/copyleft/lgpl.html
+ */
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** OpenAL boolean type. */
+typedef char ALboolean;
+
+/** OpenAL 8bit signed byte. */
+typedef char ALbyte;
+
+/** OpenAL 8bit unsigned byte. */
+typedef unsigned char ALubyte;
+
+/** OpenAL 16bit signed short integer type. */
+typedef short ALshort;
+
+/** OpenAL 16bit unsigned short integer type. */
+typedef unsigned short ALushort;
+
+/** OpenAL 32bit unsigned integer type. */
+typedef unsigned ALuint;
+
+/** OpenAL 32bit signed integer type. */
+typedef int ALint;
+
+/** OpenAL 32bit floating point type. */
+typedef float ALfloat;
+
+/** OpenAL 64bit double point type. */
+typedef double ALdouble;
+
+/** OpenAL 32bit type. */
+typedef unsigned int ALsizei;
+
+/** OpenAL void type */
+typedef void ALvoid;
+
+/** OpenAL enumerations. */
+typedef int ALenum;
+
+/* Bad value. */
+#define AL_INVALID                               (-1)
+
+/* Disable value. */
+#define AL_NONE									 0
+
+/* Boolean False. */
+#define AL_FALSE                                 0
+
+/* Boolean True. */
+#define AL_TRUE                                  1
+
+/**
+  * Indicate the type of AL_SOURCE.
+  * Sources can be spatialized 
+  */
+#define AL_SOURCE_TYPE                           0x200
+
+/** Indicate source has absolute coordinates. */
+#define AL_SOURCE_ABSOLUTE                       0x201
+
+/** Indicate Source has listener relative coordinates. */
+#define AL_SOURCE_RELATIVE                       0x202
+
+/**
+ * Directional source, inner cone angle, in degrees.
+ * Range:    [0-360] 
+ * Default:  360
+ */
+#define AL_CONE_INNER_ANGLE                      0x1001
+
+/**
+ * Directional source, outer cone angle, in degrees.
+ * Range:    [0-360] 
+ * Default:  360
+ */
+#define AL_CONE_OUTER_ANGLE                      0x1002
+
+/**
+ * Specify the pitch to be applied, either at source,
+ *  or on mixer results, at listener.
+ * Range:	 [0.5-2.0]
+ * Default:  1.0
+ */
+#define AL_PITCH                                 0x1003
+
+/** 
+ * Specify the current location in three dimensional space.
+ * OpenAL, like OpenGL, uses a right handed coordinate system,
+ *  where in a frontal default view X (thumb) points right, 
+ *  Y points up (index finger), and Z points towards the
+ *  viewer/camera (middle finger). 
+ * To switch from a left handed coordinate system, flip the
+ *  sign on the Z coordinate.
+ * Listener position is always in the world coordinate system.
+ */ 
+#define AL_POSITION                              0x1004
+  
+/** Specify the current direction as forward vector. */
+#define AL_DIRECTION                             0x1005
+  
+/** Specify the current velocity in three dimensional space. */
+#define AL_VELOCITY                              0x1006
+
+/**
+ * Indicate whether source has to loop infinite.
+ * Type: ALboolean
+ * Range:    [AL_TRUE, AL_FALSE]
+ * Default:  AL_FALSE
+ */
+#define AL_LOOPING                               0x1007
+
+/**
+ * Indicate the buffer to provide sound samples. 
+ * Type: ALuint.
+ * Range: any valid Buffer id.
+ */
+#define AL_BUFFER                                0x1009
+
+/**
+ * Indicate the gain (volume amplification) applied. 
+ * Type:     ALfloat.
+ * Range:    ]0.0-  ]
+ * A value of 1.0 means un-attenuated/unchanged.
+ * Each division by 2 equals an attenuation of -6dB.
+ * Each multiplicaton with 2 equals an amplification of +6dB.
+ * A value of 0.0 is meaningless with respect to a logarithmic
+ *  scale; it is interpreted as zero volume - the channel
+ *  is effectively disabled.
+ */
+#define AL_GAIN                                  0x100A
+
+/**
+ * Indicate minimum source attenuation.
+ * Type:     ALfloat
+ * Range:	 [0.0 - 1.0]
+ */
+#define AL_MIN_GAIN                              0x100D
+
+/**
+ * Indicate maximum source attenuation.
+ * Type:	 ALfloat
+ * Range:	 [0.0 - 1.0]
+ */
+#define AL_MAX_GAIN                              0x100E
+
+/** 
+ * Specify the current orientation.
+ * Type:	 ALfv6 (at/up)
+ * Range:	 N/A
+ */
+#define AL_ORIENTATION                           0x100F
+
+/* byte offset into source (in canon format).  -1 if source
+ * is not playing.  Don't set this, get this.
+ *
+ * Type:     ALfloat
+ * Range:    [0.0 - ]
+ * Default:  1.0
+ */
+#define AL_REFERENCE_DISTANCE                    0x1020
+
+ /**
+ * Indicate the rolloff factor for the source.
+ * Type: ALfloat
+ * Range:    [0.0 - ]
+ * Default:  1.0
+ */
+#define AL_ROLLOFF_FACTOR                        0x1021
+
+/**
+ * Indicate the gain (volume amplification) applied. 
+ * Type:     ALfloat.
+ * Range:    ]0.0-  ]
+ * A value of 1.0 means un-attenuated/unchanged.
+ * Each division by 2 equals an attenuation of -6dB.
+ * Each multiplicaton with 2 equals an amplification of +6dB.
+ * A value of 0.0 is meaningless with respect to a logarithmic
+ *  scale; it is interpreted as zero volume - the channel
+ *  is effectively disabled.
+ */
+#define AL_CONE_OUTER_GAIN                       0x1022
+
+/** 
+ * Specify the maximum distance.
+ * Type:	 ALfloat
+ * Range:	 [0.0 - ]
+ */
+#define AL_MAX_DISTANCE                          0x1023
+
+/**
+ * Specify the panning to be applied (2D only.)
+ * Range:	 [-1.0 - 1.0]
+ * Default:  0.0
+ */
+#define AL_PAN                                   0x1024
+
+/**
+ * Get the playing time of a stream.
+ * Range:	 [0.0 - infinity]
+ */
+#define AL_TIME                                   0x1025
+
+/**
+ * Specify the channel mask. (Creative)
+ * Type:	 ALuint
+ * Range:	 [0 - 255]
+ */
+#define AL_CHANNEL_MASK							 0x3000
+
+/**
+ * Source state information
+ */
+#define AL_SOURCE_STATE                          0x1010
+#define AL_INITIAL                               0x1011
+#define AL_PLAYING                               0x1012
+#define AL_PAUSED                                0x1013
+#define AL_STOPPED                               0x1014
+
+/**
+ * Buffer Queue params
+ */
+#define AL_BUFFERS_QUEUED                        0x1015
+#define AL_BUFFERS_PROCESSED                     0x1016
+
+/** Sound buffers: format specifier. */
+#define AL_FORMAT_MONO8                          0x1100
+#define AL_FORMAT_MONO16                         0x1101
+#define AL_FORMAT_STEREO8                        0x1102
+#define AL_FORMAT_STEREO16                       0x1103
+#define AL_FORMAT_MONO4                          0x1104
+#define AL_FORMAT_STEREO4                        0x1105
+
+/** 
+ * Sound buffers: frequency, in units of Hertz [Hz].
+ * This is the number of samples per second. Half of the
+ *  sample frequency marks the maximum significant
+ *  frequency component.
+ */
+#define AL_FREQUENCY                             0x2001
+#define AL_BITS                                  0x2002
+#define AL_CHANNELS                              0x2003
+#define AL_SIZE                                  0x2004
+#define AL_DATA                                  0x2005
+
+/**
+ * Buffer state.
+ *
+ * Not supported for public use (yet).
+ */
+#define AL_UNUSED                                0x2010
+#define AL_PENDING                               0x2011
+#define AL_PROCESSED                             0x2012
+
+/** Errors: No Error. */
+#define AL_NO_ERROR                              AL_FALSE
+
+/** 
+ * Illegal name passed as an argument to an AL call.
+ */
+#define AL_INVALID_NAME                          0xA001
+
+/** 
+ * Illegal enum passed as an argument to an AL call.
+ */
+#define AL_INVALID_ENUM                          0xA002  
+/** 
+ * Illegal value passed as an argument to an AL call.
+ * Applies to parameter values, but not to enumerations.
+ */
+#define AL_INVALID_VALUE                         0xA003
+  
+/**
+ * A function was called at inappropriate time,
+ *  or in an inappropriate way, causing an illegal state.
+ * This can be an incompatible ALenum, object ID,
+ *  and/or function.
+ */
+#define AL_INVALID_OPERATION                     0xA004
+
+/**
+ * A function could not be completed,
+ * because there is not enough memory available.
+ */
+#define AL_OUT_OF_MEMORY                         0xA005
+
+/** Context strings: Vendor Name. */
+#define AL_VENDOR                                0xB001
+#define AL_VERSION                               0xB002
+#define AL_RENDERER                              0xB003
+#define AL_EXTENSIONS                            0xB004
+#define AL_MEMORY_USED                           0xB005
+#define AL_MEMORY_ALLOCATOR                      0xB006
+#define AL_MEMORY_DEALLOCATOR                    0xB007
+#define AL_STEREO                                0xB008
+
+/** Global tweakage. */
+
+/**
+ * Doppler scale.  Default 1.0
+ */
+#define AL_DOPPLER_FACTOR                        0xC000
+ 
+/**
+ * Doppler velocity.  Default 1.0
+ */
+#define AL_DOPPLER_VELOCITY                      0xC001
+
+/**
+ * Distance model.  Default AL_INVERSE_DISTANCE_CLAMPED
+ */
+#define AL_DISTANCE_MODEL                        0xD000
+
+/** Distance models. */
+
+#define AL_INVERSE_DISTANCE                      0xD001
+#define AL_INVERSE_DISTANCE_CLAMPED              0xD002
+ 
+ /**
+ * enables
+ */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/code/client/OpenAL/alu.h b/code/client/OpenAL/alu.h
new file mode 100644
index 0000000..8a4004b
--- /dev/null
+++ b/code/client/OpenAL/alu.h
@@ -0,0 +1,34 @@
+#ifndef _ALU_H_
+#define _ALU_H_
+
+#define ALUAPI
+#define ALUAPIENTRY __cdecl
+
+#define BUFFERSIZE 48000
+#define FRACTIONBITS 14
+#define FRACTIONMASK ((1L<<FRACTIONBITS)-1)
+#define OUTPUTCHANNELS 2
+
+#include "altypes.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+ALUAPI ALint	ALUAPIENTRY aluF2L(ALfloat value);
+ALUAPI ALshort	ALUAPIENTRY aluF2S(ALfloat value);
+ALUAPI ALvoid	ALUAPIENTRY aluCrossproduct(ALfloat *inVector1,ALfloat *inVector2,ALfloat *outVector);
+ALUAPI ALfloat	ALUAPIENTRY aluDotproduct(ALfloat *inVector1,ALfloat *inVector2);
+ALUAPI ALvoid	ALUAPIENTRY aluNormalize(ALfloat *inVector);
+ALUAPI ALvoid	ALUAPIENTRY aluMatrixVector(ALfloat matrix[3][3],ALfloat *vector);
+ALUAPI ALvoid	ALUAPIENTRY aluCalculateSourceParameters(ALuint source,ALuint channels,ALfloat *drysend,ALfloat *wetsend,ALfloat *pitch);
+ALUAPI ALvoid	ALUAPIENTRY aluMixData(ALvoid *context,ALvoid *buffer,ALsizei size,ALenum format);
+ALUAPI ALvoid	ALUAPIENTRY aluSetReverb(ALvoid *Reverb,ALuint Environment);
+ALUAPI ALvoid	ALUAPIENTRY aluReverb(ALvoid *Reverb,ALfloat Buffer[][2],ALsizei BufferSize);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
diff --git a/code/client/OpenAL/alut.h b/code/client/OpenAL/alut.h
new file mode 100644
index 0000000..e86eb95
--- /dev/null
+++ b/code/client/OpenAL/alut.h
@@ -0,0 +1,24 @@
+#ifndef _ALUT_H_
+#define _ALUT_H_
+
+#define ALUTAPI
+#define ALUTAPIENTRY __cdecl
+
+#include "al.h"
+#include "alu.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+ALUTAPI ALvoid	ALUTAPIENTRY alutInit(ALint *argc,ALbyte **argv);
+ALUTAPI ALvoid	ALUTAPIENTRY alutExit(ALvoid);
+ALUTAPI ALvoid	ALUTAPIENTRY alutLoadWAVFile(ALbyte *file,ALenum *format,ALvoid **data,ALsizei *size,ALsizei *freq,ALboolean *loop);
+ALUTAPI ALvoid	ALUTAPIENTRY alutLoadWAVMemory(ALbyte *memory,ALenum *format,ALvoid **data,ALsizei *size,ALsizei *freq,ALboolean *loop);
+ALUTAPI ALvoid  ALUTAPIENTRY alutUnloadWAV(ALenum format,ALvoid *data,ALsizei size,ALsizei freq);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/code/client/OpenAL/vssver.scc b/code/client/OpenAL/vssver.scc
new file mode 100644
index 0000000..ad643b9
Binary files /dev/null and b/code/client/OpenAL/vssver.scc differ
diff --git a/code/client/cl_cgame.cpp b/code/client/cl_cgame.cpp
new file mode 100644
index 0000000..6a92cc6
--- /dev/null
+++ b/code/client/cl_cgame.cpp
@@ -0,0 +1,1312 @@
+// cl_cgame.c  -- client system interaction with client game
+
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+#include "../ui/ui_shared.h"
+
+#include "../RMG/RM_Headers.h"
+
+#ifdef VV_LIGHTING
+#include "../renderer/tr_lightmanager.h"
+#endif
+	   		
+
+#include "client.h"
+#ifdef _IMMERSION
+#include "../ff/cl_ff.h"
+#include "../ff/ff.h"
+#else
+#include "fffx.h"
+#endif // _IMMERSION
+#include "vmachine.h"
+
+vm_t	cgvm;
+/*
+Ghoul2 Insert Start
+*/
+
+#if !defined(G2_H_INC)
+	#include "../ghoul2/G2.h"
+#endif
+
+/*
+Ghoul2 Insert End
+*/
+
+//FIXME: Temp
+extern void S_UpdateAmbientSet ( const char *name, vec3_t origin );
+extern int S_AddLocalSet( const char *name, vec3_t listener_origin, vec3_t origin, int entID, int time );
+extern void AS_ParseSets( void );
+extern sfxHandle_t AS_GetBModelSound( const char *name, int stage );
+extern void	AS_AddPrecacheEntry( const char *name );
+extern menuDef_t *Menus_FindByName(const char *p);
+
+extern qboolean R_inPVS( vec3_t p1, vec3_t p2 );
+
+void UI_SetActiveMenu( const char* menuname,const char *menuID );
+
+/*
+====================
+CL_GetGameState
+====================
+*/
+void CL_GetGameState( gameState_t *gs ) {
+	*gs = cl.gameState;
+}
+
+/*
+====================
+CL_GetGlconfig
+====================
+*/
+void CL_GetGlconfig( glconfig_t *glconfig ) {
+	*glconfig = cls.glconfig;
+}
+
+
+/*
+====================
+CL_GetUserCmd
+====================
+*/
+qboolean CL_GetUserCmd( int cmdNumber, usercmd_t *ucmd ) {
+	// cmds[cmdNumber] is the last properly generated command
+
+	// can't return anything that we haven't created yet
+	if ( cmdNumber > cl.cmdNumber ) {
+		Com_Error( ERR_DROP, "CL_GetUserCmd: %i >= %i", cmdNumber, cl.cmdNumber );
+	}
+
+	// the usercmd has been overwritten in the wrapping
+	// buffer because it is too far out of date
+	if ( cmdNumber <= cl.cmdNumber - CMD_BACKUP ) {
+		return qfalse;
+	}
+
+	*ucmd = cl.cmds[ cmdNumber & CMD_MASK ];
+
+	return qtrue;
+}
+
+int CL_GetCurrentCmdNumber( void ) {
+	return cl.cmdNumber;
+}
+
+
+/*
+====================
+CL_GetParseEntityState
+====================
+*/
+/*
+qboolean	CL_GetParseEntityState( int parseEntityNumber, entityState_t *state ) {
+	// can't return anything that hasn't been parsed yet
+	if ( parseEntityNumber >= cl.parseEntitiesNum ) {
+		Com_Error( ERR_DROP, "CL_GetParseEntityState: %i >= %i",
+			parseEntityNumber, cl.parseEntitiesNum );
+	}
+
+	// can't return anything that has been overwritten in the circular buffer
+	if ( parseEntityNumber <= cl.parseEntitiesNum - MAX_PARSE_ENTITIES ) {
+		return qfalse;
+	}
+
+	*state = cl.parseEntities[ parseEntityNumber & ( MAX_PARSE_ENTITIES - 1 ) ];
+	return qtrue;
+}
+*/
+
+/*
+====================
+CL_GetCurrentSnapshotNumber
+====================
+*/
+void	CL_GetCurrentSnapshotNumber( int *snapshotNumber, int *serverTime ) {
+	*snapshotNumber = cl.frame.messageNum;
+	*serverTime = cl.frame.serverTime;
+}
+
+/*
+====================
+CL_GetSnapshot
+====================
+*/
+qboolean	CL_GetSnapshot( int snapshotNumber, snapshot_t *snapshot ) {
+	clSnapshot_t	*clSnap;
+	int				i, count;
+
+	if ( snapshotNumber > cl.frame.messageNum ) {
+		Com_Error( ERR_DROP, "CL_GetSnapshot: snapshotNumber > cl.frame.messageNum" );
+	}
+
+	// if the frame has fallen out of the circular buffer, we can't return it
+	if ( cl.frame.messageNum - snapshotNumber >= PACKET_BACKUP ) {
+		return qfalse;
+	}
+
+	// if the frame is not valid, we can't return it
+	clSnap = &cl.frames[snapshotNumber & PACKET_MASK];
+	if ( !clSnap->valid ) {
+		return qfalse;
+	}
+
+	// if the entities in the frame have fallen out of their
+	// circular buffer, we can't return it
+	if ( cl.parseEntitiesNum - clSnap->parseEntitiesNum >= MAX_PARSE_ENTITIES ) {
+		return qfalse;
+	}
+
+	// write the snapshot
+	snapshot->snapFlags = clSnap->snapFlags;
+	snapshot->serverCommandSequence = clSnap->serverCommandNum;
+	snapshot->ping = clSnap->ping;
+	snapshot->serverTime = clSnap->serverTime;
+	memcpy( snapshot->areamask, clSnap->areamask, sizeof( snapshot->areamask ) );
+	snapshot->cmdNum = clSnap->cmdNum;
+	snapshot->ps = clSnap->ps;
+	count = clSnap->numEntities;
+	if ( count > MAX_ENTITIES_IN_SNAPSHOT ) {
+		Com_DPrintf( "CL_GetSnapshot: truncated %i entities to %i\n", count, MAX_ENTITIES_IN_SNAPSHOT );
+		count = MAX_ENTITIES_IN_SNAPSHOT;
+	}
+	snapshot->numEntities = count;
+/*
+Ghoul2 Insert Start
+*/
+ 	for ( i = 0 ; i < count ; i++ ) 
+	{
+
+		int entNum =  ( clSnap->parseEntitiesNum + i ) & (MAX_PARSE_ENTITIES-1) ;		
+		snapshot->entities[i] = cl.parseEntities[ entNum ];
+	}
+/*
+Ghoul2 Insert End
+*/
+
+
+	// FIXME: configstring changes and server commands!!!
+
+	return qtrue;
+}
+
+//bg_public.h won't cooperate in here
+#define EF_PERMANENT   0x00080000
+
+qboolean CL_GetDefaultState(int index, entityState_t *state)
+{
+	if (index < 0 || index >= MAX_GENTITIES)
+	{
+		return qfalse;
+	}
+
+	// Is this safe? I think so. But it's still ugly as sin.
+	if (!(sv.svEntities[index].baseline.eFlags & EF_PERMANENT))
+//	if (!(cl.entityBaselines[index].eFlags & EF_PERMANENT))
+	{
+		return qfalse;
+	}
+
+	*state = sv.svEntities[index].baseline;
+//	*state = cl.entityBaselines[index];
+
+	return qtrue;
+}
+
+extern float cl_mPitchOverride;
+extern float cl_mYawOverride;
+void CL_SetUserCmdValue( int userCmdValue, float sensitivityScale, float mPitchOverride, float mYawOverride ) {
+	cl.cgameUserCmdValue = userCmdValue;
+	cl.cgameSensitivity = sensitivityScale;
+	cl_mPitchOverride = mPitchOverride;
+	cl_mYawOverride = mYawOverride;
+}
+
+extern vec3_t cl_overriddenAngles;
+extern qboolean cl_overrideAngles;
+void CL_SetUserCmdAngles( float pitchOverride, float yawOverride, float rollOverride ) {
+	cl_overriddenAngles[PITCH] = pitchOverride;
+	cl_overriddenAngles[YAW] = yawOverride;
+	cl_overriddenAngles[ROLL] = rollOverride;
+	cl_overrideAngles = qtrue;
+}
+
+void CL_AddCgameCommand( const char *cmdName ) {
+	Cmd_AddCommand( cmdName, NULL );
+}
+
+void CL_CgameError( const char *string ) {
+	Com_Error( ERR_DROP, "%s", string );
+}
+
+
+/*
+=====================
+CL_ConfigstringModified
+=====================
+*/
+void CL_ConfigstringModified( void ) {
+	char		*old, *s;
+	int			i, index;
+	char		*dup;
+	gameState_t	oldGs;
+	int			len;
+
+	index = atoi( Cmd_Argv(1) );
+	if ( index < 0 || index >= MAX_CONFIGSTRINGS ) {
+		Com_Error( ERR_DROP, "configstring > MAX_CONFIGSTRINGS" );
+	}
+	s = Cmd_Argv(2);
+
+	old = cl.gameState.stringData + cl.gameState.stringOffsets[ index ];
+	if ( !strcmp( old, s ) ) {
+		return;		// unchanged
+	}
+
+	// build the new gameState_t
+	oldGs = cl.gameState;
+
+	memset( &cl.gameState, 0, sizeof( cl.gameState ) );
+
+	// leave the first 0 for uninitialized strings
+	cl.gameState.dataCount = 1;
+		
+	for ( i = 0 ; i < MAX_CONFIGSTRINGS ; i++ ) {
+		if ( i == index ) {
+			dup = s;
+		} else {
+			dup = oldGs.stringData + oldGs.stringOffsets[ i ];
+		}
+		if ( !dup[0] ) {
+			continue;		// leave with the default empty string
+		}
+
+		len = strlen( dup );
+
+		if ( len + 1 + cl.gameState.dataCount > MAX_GAMESTATE_CHARS ) {
+			Com_Error( ERR_DROP, "MAX_GAMESTATE_CHARS exceeded" );
+		}
+
+		// append it to the gameState string buffer
+		cl.gameState.stringOffsets[ i ] = cl.gameState.dataCount;
+		memcpy( cl.gameState.stringData + cl.gameState.dataCount, dup, len + 1 );
+		cl.gameState.dataCount += len + 1;
+	}
+
+	if ( index == CS_SYSTEMINFO ) {
+		// parse serverId and other cvars
+		CL_SystemInfoChanged();
+	}
+
+}
+
+
+/*
+===================
+CL_GetServerCommand
+
+Set up argc/argv for the given command
+===================
+*/
+qboolean CL_GetServerCommand( int serverCommandNumber ) {
+	char	*s;
+	char	*cmd;
+
+	// if we have irretrievably lost a reliable command, drop the connection
+	if ( serverCommandNumber <= clc.serverCommandSequence - MAX_RELIABLE_COMMANDS ) {
+		Com_Error( ERR_DROP, "CL_GetServerCommand: a reliable command was cycled out" );
+		return qfalse;
+	}
+
+	if ( serverCommandNumber > clc.serverCommandSequence ) {
+		Com_Error( ERR_DROP, "CL_GetServerCommand: requested a command not received" );
+		return qfalse;
+	}
+
+	s = clc.serverCommands[ serverCommandNumber & ( MAX_RELIABLE_COMMANDS - 1 ) ];
+
+	Com_DPrintf( "serverCommand: %i : %s\n", serverCommandNumber, s );
+
+	Cmd_TokenizeString( s );
+	cmd = Cmd_Argv(0);
+
+	if ( !strcmp( cmd, "disconnect" ) ) {
+		Com_Error (ERR_DISCONNECT,"Server disconnected\n");
+	}
+
+	if ( !strcmp( cmd, "cs" ) ) {
+		CL_ConfigstringModified();
+		// reparse the string, because CL_ConfigstringModified may have done another Cmd_TokenizeString()
+		Cmd_TokenizeString( s );
+		return qtrue;
+	}
+
+	// the clientLevelShot command is used during development
+	// to generate 128*128 screenshots from the intermission
+	// point of levels for the menu system to use
+	// we pass it along to the cgame to make apropriate adjustments,
+	// but we also clear the console and notify lines here
+	if ( !strcmp( cmd, "clientLevelShot" ) ) {
+		// don't do it if we aren't running the server locally,
+		// otherwise malicious remote servers could overwrite
+		// the existing thumbnails
+		if ( !com_sv_running->integer ) {
+			return qfalse;
+		}
+		// close the console
+		Con_Close();
+		// take a special screenshot next frame
+		Cbuf_AddText( "wait ; wait ; wait ; wait ; screenshot levelshot\n" );
+		return qtrue;
+	}
+
+	// we may want to put a "connect to other server" command here
+
+	// cgame can now act on the command
+	return qtrue;
+}
+
+
+/*
+====================
+CL_CM_LoadMap
+
+Just adds default parameters that cgame doesn't need to know about
+====================
+*/
+#ifdef _XBOX
+void CL_CM_LoadMap( const char *mapname ) {
+	int		checksum;
+
+	CM_LoadMap( mapname, qtrue, &checksum );
+}
+#else
+void CL_CM_LoadMap( const char *mapname, qboolean subBSP ) {
+	int		checksum;
+
+	CM_LoadMap( mapname, qtrue, &checksum, subBSP );
+}
+#endif // _XBOX
+
+/*
+====================
+CL_ShutdonwCGame
+
+====================
+*/
+void CL_ShutdownCGame( void ) {
+	cls.cgameStarted = qfalse;
+
+	if ( !cgvm.entryPoint) {
+		return;
+	}
+	VM_Call( CG_SHUTDOWN );
+#ifndef _XBOX	// Not using it
+	RM_ShutdownTerrain();
+#endif
+
+//	VM_Free( cgvm );
+//	cgvm = NULL;
+}
+
+//RMG
+CCMLandScape *CM_RegisterTerrain(const char *config, bool server);
+void RE_InitRendererTerrain( const char *info );
+//RMG
+
+extern float tr_distortionAlpha; //tr_shadows.cpp
+extern float tr_distortionStretch; //tr_shadows.cpp
+extern qboolean tr_distortionPrePost; //tr_shadows.cpp
+extern qboolean tr_distortionNegate; //tr_shadows.cpp
+
+float g_oldRangedFog = 0.0f;
+/*
+====================
+CL_CgameSystemCalls
+
+The cgame module is making a system call
+====================
+*/
+void *VM_ArgPtr( int intValue );
+void CM_SnapPVS(vec3_t origin,byte *buffer);
+//#define	VMA(x) VM_ArgPtr(args[x])
+#define	VMA(x) ((void*)args[x])
+#define	VMF(x)	((float *)args)[x]
+int CL_CgameSystemCalls( int *args ) {
+	switch( args[0] ) {
+	case CG_PRINT:
+		Com_Printf( "%s", VMA(1) );
+		return 0;
+	case CG_ERROR:
+		Com_Error( ERR_DROP, S_COLOR_RED"%s", VMA(1) );
+		return 0;
+	case CG_MILLISECONDS:
+		return Sys_Milliseconds();
+	case CG_CVAR_REGISTER:
+		Cvar_Register( (vmCvar_t *) VMA(1), (const char *) VMA(2), (const char *) VMA(3), args[4] ); 
+		return 0;
+	case CG_CVAR_UPDATE:
+		Cvar_Update( (vmCvar_t *) VMA(1) );
+		return 0;
+	case CG_CVAR_SET:
+		Cvar_Set( (const char *) VMA(1), (const char *) VMA(2) );
+		return 0;
+	case CG_ARGC:
+		return Cmd_Argc();
+	case CG_ARGV:
+		Cmd_ArgvBuffer( args[1], (char *) VMA(2), args[3] );
+		return 0;
+	case CG_ARGS:
+		Cmd_ArgsBuffer( (char *) VMA(1), args[2] );
+		return 0;
+	case CG_FS_FOPENFILE:
+		return FS_FOpenFileByMode( (const char *) VMA(1), (int *) VMA(2), (fsMode_t) args[3] );
+	case CG_FS_READ:
+		FS_Read( VMA(1), args[2], args[3] );
+		return 0;
+	case CG_FS_WRITE:
+		FS_Write( VMA(1), args[2], args[3] );
+		return 0;
+	case CG_FS_FCLOSEFILE:
+		FS_FCloseFile( args[1] );
+		return 0;
+	case CG_SENDCONSOLECOMMAND:
+		Cbuf_AddText( (const char *) VMA(1) );
+		return 0;
+	case CG_ADDCOMMAND:
+		CL_AddCgameCommand( (const char *) VMA(1) );
+		return 0;
+	case CG_SENDCLIENTCOMMAND:
+		CL_AddReliableCommand( (const char *) VMA(1) );
+		return 0;
+	case CG_UPDATESCREEN:
+		// this is used during lengthy level loading, so pump message loop
+		Com_EventLoop();	// FIXME: if a server restarts here, BAD THINGS HAPPEN!
+		SCR_UpdateScreen();
+		return 0;
+
+#ifdef _XBOX
+	case CG_RMG_INIT:
+	case CG_CM_REGISTER_TERRAIN:
+	case CG_RE_INIT_RENDERER_TERRAIN:
+		Com_Error( ERR_FATAL, "ERROR: Terrain unsupported on Xbox.\n" );
+#else
+	case CG_RMG_INIT:
+		/*
+		if (!com_sv_running->integer)
+		{	// don't do this if we are connected locally
+			if (!TheRandomMissionManager)
+			{
+				TheRandomMissionManager = new CRMManager;
+			}
+			TheRandomMissionManager->SetLandScape( cmg.landScapes[args[1]] );
+			TheRandomMissionManager->LoadMission(qfalse);
+			TheRandomMissionManager->SpawnMission(qfalse);
+			cmg.landScapes[args[1]]->UpdatePatches();
+		}
+		*/ //this is SP.. I guess we're always the client and server.
+//		cl.mRMGChecksum = cm.landScapes[args[1]]->get_rand_seed();
+		RM_CreateRandomModels(args[1], (const char *)VMA(2));
+		//cmg.landScapes[args[1]]->rand_seed(cl.mRMGChecksum);		// restore it, in case we do a vid restart
+		cmg.landScape->rand_seed(cmg.landScape->get_rand_seed());
+//		TheRandomMissionManager->CreateMap();
+		return 0;
+	case CG_CM_REGISTER_TERRAIN:
+		return CM_RegisterTerrain((const char *)VMA(1), false)->GetTerrainId();
+
+	case CG_RE_INIT_RENDERER_TERRAIN:
+		RE_InitRendererTerrain((const char *)VMA(1));
+		return 0;
+#endif	// _XBOX
+
+	case CG_CM_LOADMAP:
+#ifdef _XBOX
+		CL_CM_LoadMap( (const char *) VMA(1) );
+#else
+		CL_CM_LoadMap( (const char *) VMA(1), args[2] );
+#endif
+		return 0;
+	case CG_CM_NUMINLINEMODELS:
+		return CM_NumInlineModels();
+	case CG_CM_INLINEMODEL:
+		return CM_InlineModel( args[1] );
+	case CG_CM_TEMPBOXMODEL:
+		return CM_TempBoxModel( (const float *) VMA(1), (const float *) VMA(2) );//, (int) VMA(3) );
+	case CG_CM_POINTCONTENTS:
+		return CM_PointContents( (float *)VMA(1), args[2] );
+	case CG_CM_TRANSFORMEDPOINTCONTENTS:
+		return CM_TransformedPointContents( (const float *) VMA(1), args[2], (const float *) VMA(3), (const float *) VMA(4) );
+	case CG_CM_BOXTRACE:
+		CM_BoxTrace( (trace_t *) VMA(1), (const float *) VMA(2), (const float *) VMA(3), (const float *) VMA(4), (const float *) VMA(5), args[6], args[7] );
+		return 0;
+	case CG_CM_TRANSFORMEDBOXTRACE:
+		CM_TransformedBoxTrace( (trace_t *) VMA(1), (const float *) VMA(2), (const float *) VMA(3), (const float *) VMA(4), (const float *) VMA(5), args[6], args[7], (const float *) VMA(8), (const float *) VMA(9) );
+		return 0;
+	case CG_CM_MARKFRAGMENTS:
+		return re.MarkFragments( args[1], (float(*)[3]) VMA(2), (const float *) VMA(3), args[4], (float *) VMA(5), args[6], (markFragment_t *) VMA(7) );
+	case CG_CM_SNAPPVS:
+		CM_SnapPVS((float(*))VMA(1),(byte *) VMA(2));
+		return 0;
+	case CG_S_STOPSOUNDS:
+		S_StopSounds( );
+		return 0;
+
+	case CG_S_STARTSOUND:
+		// stops an ERR_DROP internally if called illegally from game side, but note that it also gets here 
+		//	legally during level start where normally the internal s_soundStarted check would return. So ok to hit this.
+		if (!cls.cgameStarted){
+			return 0;	
+		}
+		S_StartSound( (float *) VMA(1), args[2], (soundChannel_t)args[3], args[4] );
+		return 0;
+	case CG_S_UPDATEAMBIENTSET:
+		// stops an ERR_DROP internally if called illegally from game side, but note that it also gets here 
+		//	legally during level start where normally the internal s_soundStarted check would return. So ok to hit this.
+		if (!cls.cgameStarted){
+			return 0;
+		}
+		S_UpdateAmbientSet( (const char *) VMA(1), (float *) VMA(2) );
+		return 0;
+	case CG_S_ADDLOCALSET:
+		return S_AddLocalSet( (const char *) VMA(1), (float *) VMA(2), (float *) VMA(3), args[4], args[5] );
+	case CG_AS_PARSESETS:
+		AS_ParseSets();
+		return 0;
+	case CG_AS_ADDENTRY:
+		AS_AddPrecacheEntry( (const char *) VMA(1) );
+		return 0;
+	case CG_AS_GETBMODELSOUND:
+		return AS_GetBModelSound( (const char *) VMA(1), args[2] );	
+	case CG_S_STARTLOCALSOUND:
+		// stops an ERR_DROP internally if called illegally from game side, but note that it also gets here 
+		//	legally during level start where normally the internal s_soundStarted check would return. So ok to hit this.
+		if (!cls.cgameStarted){
+			return 0;
+		}
+		S_StartLocalSound( args[1], args[2] );
+		return 0;
+	case CG_S_CLEARLOOPINGSOUNDS:
+		S_ClearLoopingSounds();
+		return 0;
+	case CG_S_ADDLOOPINGSOUND:
+		// stops an ERR_DROP internally if called illegally from game side, but note that it also gets here 
+		//	legally during level start where normally the internal s_soundStarted check would return. So ok to hit this.
+		if (!cls.cgameStarted){
+			return 0;
+		}
+		S_AddLoopingSound( args[1], (const float *) VMA(2), (const float *) VMA(3), args[4], (soundChannel_t)args[5] );
+		return 0;
+	case CG_S_UPDATEENTITYPOSITION:
+		S_UpdateEntityPosition( args[1], (const float *) VMA(2) );
+		return 0;
+	case CG_S_RESPATIALIZE:
+		S_Respatialize( args[1], (const float *) VMA(2), (float(*)[3]) VMA(3), args[4] );
+		return 0;
+	case CG_S_REGISTERSOUND:
+		return S_RegisterSound( (const char *) VMA(1) );
+	case CG_S_STARTBACKGROUNDTRACK:
+		S_StartBackgroundTrack( (const char *) VMA(1), (const char *) VMA(2), args[3]);
+		return 0;
+	case CG_S_GETSAMPLELENGTH:
+		return S_GetSampleLengthInMilliSeconds(  args[1]);
+#ifdef _IMMERSION
+	case CG_FF_START:
+		CL_FF_Start( (ffHandle_t) args[1], (int) args[2] );
+		return 0;
+	case CG_FF_STOP:
+		CL_FF_Stop( (ffHandle_t) args[1], (int) args[2] );
+		return 0;
+	case CG_FF_STOPALL:
+		FF_StopAll();
+		return 0;
+	case CG_FF_SHAKE:
+		FF_Shake( (int) args[1], (int) args[2] );
+		return 0;
+	case CG_FF_REGISTER:
+		return FF_Register( (const char *) VMA(1), (int) args[2] );
+	case CG_FF_ADDLOOPINGFORCE:
+		CL_FF_AddLoopingForce( (ffHandle_t) args[1], (int) args[2] );
+		return 0;
+#else
+	case CG_FF_STARTFX:
+		FFFX_START( (ffFX_e) args[1] );
+		return 0;
+	case CG_FF_ENSUREFX:
+		FFFX_ENSURE( (ffFX_e) args[1] );
+		return 0;
+	case CG_FF_STOPFX:
+		FFFX_STOP( (ffFX_e) args[1] );
+		return 0;
+	case CG_FF_STOPALLFX:
+		FFFX_STOPALL;
+		return 0;
+#endif // _IMMERSION
+#ifdef _XBOX
+	case CG_FF_XBOX_SHAKE:
+		FF_XboxShake( VMF(1), (int) args[2] );
+		return 0;
+	case CG_FF_XBOX_DAMAGE:
+		FF_XboxDamage( (int) args[1], VMF(2) );
+		return 0;
+#endif
+	case CG_R_LOADWORLDMAP:
+		re.LoadWorld( (const char *) VMA(1) );
+		return 0; 
+	case CG_R_REGISTERMODEL:
+		return re.RegisterModel( (const char *) VMA(1) );
+	case CG_R_REGISTERSKIN:
+		return re.RegisterSkin( (const char *) VMA(1) );
+	case CG_R_REGISTERSHADER:
+		return re.RegisterShader( (const char *) VMA(1) );
+	case CG_R_REGISTERSHADERNOMIP:
+		return re.RegisterShaderNoMip( (const char *) VMA(1) );
+	case CG_R_REGISTERFONT:
+		return re.RegisterFont( (const char *) VMA(1) );
+	case CG_R_FONTSTRLENPIXELS:
+		return re.Font_StrLenPixels( (const char *) VMA(1), args[2], VMF(3) );
+	case CG_R_FONTSTRLENCHARS:
+		return re.Font_StrLenChars( (const char *) VMA(1) );
+	case CG_R_FONTHEIGHTPIXELS:
+		return re.Font_HeightPixels( args[1], VMF(2) );
+	case CG_R_FONTDRAWSTRING:
+		re.Font_DrawString(args[1],args[2], (const char *) VMA(3), (float*)args[4], args[5], args[6], VMF(7));
+		return 0;
+	case CG_LANGUAGE_ISASIAN:
+		return re.Language_IsAsian();
+	case CG_LANGUAGE_USESSPACES:
+		return re.Language_UsesSpaces();
+	case CG_ANYLANGUAGE_READFROMSTRING:
+		return re.AnyLanguage_ReadCharFromString( (const char *) VMA(1), (int *) VMA(2), (qboolean *) VMA(3) );
+	case CG_R_SETREFRACTIONPROP:
+		tr_distortionAlpha = VMF(1);
+		tr_distortionStretch = VMF(2);
+		tr_distortionPrePost = (qboolean)args[3];
+		tr_distortionNegate = (qboolean)args[4];
+		return 0;
+	case CG_R_CLEARSCENE:
+		re.ClearScene();
+		return 0;
+	case CG_R_ADDREFENTITYTOSCENE:
+		re.AddRefEntityToScene( (const refEntity_t *) VMA(1) );
+		return 0;
+
+	case CG_R_INPVS:
+		return R_inPVS((float *) VMA(1), (float *) VMA(2));
+
+	case CG_R_GETLIGHTING:
+		return re.GetLighting( (const float * ) VMA(1), (float *) VMA(2), (float *) VMA(3), (float *) VMA(4) );
+	case CG_R_ADDPOLYTOSCENE:
+		re.AddPolyToScene( args[1], args[2], (const polyVert_t *) VMA(3) );
+		return 0;
+	case CG_R_ADDLIGHTTOSCENE:
+#ifdef VV_LIGHTING
+		VVLightMan.RE_AddLightToScene ( (const float *) VMA(1), VMF(2), VMF(3), VMF(4), VMF(5) );
+#else
+		re.AddLightToScene( (const float *) VMA(1), VMF(2), VMF(3), VMF(4), VMF(5) );
+#endif
+		return 0;
+	case CG_R_RENDERSCENE:
+		re.RenderScene( (const refdef_t *) VMA(1) );
+		return 0;
+	case CG_R_SETCOLOR:
+		re.SetColor( (const float *) VMA(1) );
+		return 0;
+	case CG_R_DRAWSTRETCHPIC:
+		re.DrawStretchPic( VMF(1), VMF(2), VMF(3), VMF(4), VMF(5), VMF(6), VMF(7), VMF(8), args[9] );
+		return 0;
+	//case CG_R_DRAWSCREENSHOT:
+	//	re.DrawStretchRaw( VMF(1), VMF(2), VMF(3), VMF(4), SG_SCR_WIDTH, SG_SCR_HEIGHT, SCR_GetScreenshot(0), 0, qtrue);
+	//	return 0;
+	case CG_R_MODELBOUNDS:
+		re.ModelBounds( args[1], (float *) VMA(2), (float *) VMA(3) );
+		return 0;
+	case CG_R_LERPTAG:
+		re.LerpTag( (orientation_t *) VMA(1), args[2], args[3], args[4], VMF(5), (const char *) VMA(6) );
+		return 0;
+	case CG_R_DRAWROTATEPIC:
+		re.DrawRotatePic( VMF(1), VMF(2), VMF(3), VMF(4), VMF(5), VMF(6), VMF(7), VMF(8), VMF(9), args[10] );
+		return 0;
+	case CG_R_DRAWROTATEPIC2:
+		re.DrawRotatePic2( VMF(1), VMF(2), VMF(3), VMF(4), VMF(5), VMF(6), VMF(7), VMF(8), VMF(9), args[10] );
+		return 0;
+	case CG_R_SETRANGEFOG:
+		if (tr.rangedFog <= 0.0f)
+		{
+			g_oldRangedFog = tr.rangedFog;
+		}
+		tr.rangedFog = VMF(1);
+		if (tr.rangedFog == 0.0f && g_oldRangedFog)
+		{ //restore to previous state if applicable
+			tr.rangedFog = g_oldRangedFog;
+		}
+		return 0;
+	case CG_R_LA_GOGGLES:
+		re.LAGoggles();
+		return 0;
+	case CG_R_SCISSOR:
+		re.Scissor( VMF(1), VMF(2), VMF(3), VMF(4));
+		return 0;
+	case CG_GETGLCONFIG:
+		CL_GetGlconfig( (glconfig_t *) VMA(1) );
+		return 0;
+	case CG_GETGAMESTATE:
+		CL_GetGameState( (gameState_t *) VMA(1) );
+		return 0;
+	case CG_GETCURRENTSNAPSHOTNUMBER:
+		CL_GetCurrentSnapshotNumber( (int *) VMA(1), (int *) VMA(2) );
+		return 0;
+	case CG_GETSNAPSHOT:
+		return CL_GetSnapshot( args[1], (snapshot_t *) VMA(2) );
+
+	case CG_GETDEFAULTSTATE:
+		return CL_GetDefaultState(args[1], (entityState_t *)VMA(2));
+
+	case CG_GETSERVERCOMMAND:
+		return CL_GetServerCommand( args[1] );
+	case CG_GETCURRENTCMDNUMBER:
+		return CL_GetCurrentCmdNumber();
+	case CG_GETUSERCMD:
+		return CL_GetUserCmd( args[1], (usercmd_s *) VMA(2) );
+	case CG_SETUSERCMDVALUE:
+		CL_SetUserCmdValue( args[1], VMF(2), VMF(3), VMF(4) );
+		return 0;
+	case CG_SETUSERCMDANGLES:
+		CL_SetUserCmdAngles( VMF(1), VMF(2), VMF(3) );
+		return 0;
+	case COM_SETORGANGLES:
+		Com_SetOrgAngles((float *)VMA(1),(float *)VMA(2));
+		return 0;
+/*
+Ghoul2 Insert Start
+*/
+		
+	case CG_G2_LISTSURFACES:
+		G2API_ListSurfaces( (CGhoul2Info *) VMA(1) );
+		return 0;
+
+	case CG_G2_LISTBONES:
+		G2API_ListBones( (CGhoul2Info *) VMA(1), args[2]);
+		return 0;
+
+	case CG_G2_HAVEWEGHOULMODELS:
+		return G2API_HaveWeGhoul2Models( *((CGhoul2Info_v *)VMA(1)) );
+
+	case CG_G2_SETMODELS:
+		G2API_SetGhoul2ModelIndexes( *((CGhoul2Info_v *)VMA(1)),(qhandle_t *)VMA(2),(qhandle_t *)VMA(3));
+		return 0;
+
+/*
+Ghoul2 Insert End
+*/
+
+	case CG_R_GET_LIGHT_STYLE:
+		re.GetLightStyle(args[1], (byte*) VMA(2) );
+		return 0;
+	case CG_R_SET_LIGHT_STYLE:
+		re.SetLightStyle(args[1], args[2] );
+		return 0;
+
+	case CG_R_GET_BMODEL_VERTS:
+		re.GetBModelVerts( args[1], (float (*)[3])VMA(2), (float *)VMA(3) );
+		return 0;
+	
+	case CG_R_WORLD_EFFECT_COMMAND:
+		re.WorldEffectCommand( (const char *) VMA(1) );
+		return 0;
+
+	case CG_CIN_PLAYCINEMATIC:
+	  return CIN_PlayCinematic( (const char *) VMA(1), args[2], args[3], args[4], args[5], args[6], (const char *) VMA(7));
+
+	case CG_CIN_STOPCINEMATIC:
+	  return CIN_StopCinematic(args[1]);
+
+	case CG_CIN_RUNCINEMATIC:
+	  return CIN_RunCinematic(args[1]);
+
+	case CG_CIN_DRAWCINEMATIC:
+	  CIN_DrawCinematic(args[1]);
+	  return 0;
+
+	case CG_CIN_SETEXTENTS:
+	  CIN_SetExtents(args[1], args[2], args[3], args[4], args[5]);
+	  return 0;
+
+	case CG_Z_MALLOC:
+		return (int)Z_Malloc(args[1], (memtag_t) args[2], qfalse);
+
+	case CG_Z_FREE:
+		Z_Free((void *) VMA(1));
+		return 0;
+
+	case CG_UI_SETACTIVE_MENU:
+		UI_SetActiveMenu((const char *) VMA(1),NULL);
+		return 0;
+
+	case CG_UI_MENU_OPENBYNAME:
+		Menus_OpenByName((const char *) VMA(1));
+		return 0;
+
+	case CG_UI_MENU_RESET:
+		Menu_Reset();
+		return 0;
+
+	case CG_UI_MENU_NEW:
+		Menu_New((char *) VMA(1));
+		return 0;
+
+	case CG_UI_PARSE_INT:
+		PC_ParseInt((int *) VMA(1));
+		return 0;
+
+	case CG_UI_PARSE_STRING:
+		PC_ParseString((const char **) VMA(1));
+		return 0;
+
+	case CG_UI_PARSE_FLOAT:
+		PC_ParseFloat((float *) VMA(1));
+		return 0;
+
+	case CG_UI_STARTPARSESESSION:
+		return(PC_StartParseSession((char *) VMA(1),(char **) VMA(2)));
+
+	case CG_UI_ENDPARSESESSION:
+		PC_EndParseSession((char *) VMA(1));
+		return 0;
+
+	case CG_UI_PARSEEXT:
+		char **holdPtr;
+
+		holdPtr = (char **) VMA(1);
+		*holdPtr = PC_ParseExt();
+		return 0;
+
+	case CG_UI_MENUCLOSE_ALL:
+		Menus_CloseAll();
+		return 0;
+
+	case CG_UI_MENUPAINT_ALL:
+		Menu_PaintAll();
+		return 0;
+
+	case CG_UI_STRING_INIT:
+		String_Init();
+		return 0;
+
+	case CG_UI_GETMENUINFO:
+		menuDef_t *menu;
+		int		*xPos,*yPos,*w,*h,result;
+
+		menu = Menus_FindByName((char *) VMA(1));	// Get menu 
+		if (menu)
+		{
+			xPos = (int *) VMA(2);
+			*xPos = (int) menu->window.rect.x;
+			yPos = (int *) VMA(3);
+			*yPos = (int) menu->window.rect.y;
+			w = (int *) VMA(4);
+			*w = (int) menu->window.rect.w;
+			h = (int *) VMA(5);
+			*h = (int) menu->window.rect.h;
+			result = qtrue;
+		}
+		else
+		{
+			result = qfalse;
+		}
+
+		return result;
+
+	case CG_UI_GETITEMTEXT:
+		itemDef_t *item;
+		menu = Menus_FindByName((char *) VMA(1));	// Get menu 
+
+		if (menu)
+		{
+			item = (itemDef_s *) Menu_FindItemByName((menuDef_t *) menu, (char *) VMA(2));
+			if (item)
+			{
+				Q_strncpyz( (char *) VMA(3), item->text, 256 );
+				result = qtrue;
+			}
+			else
+			{
+				result = qfalse;
+			}
+		}
+		else
+		{
+			result = qfalse;
+		}
+
+		return result;
+
+	case CG_UI_GETITEMINFO:
+		menu = Menus_FindByName((char *) VMA(1));	// Get menu 
+
+		if (menu)
+		{
+			qhandle_t *background;
+
+			item = (itemDef_s *) Menu_FindItemByName((menuDef_t *) menu, (char *) VMA(2));
+			if (item)
+			{
+				xPos = (int *) VMA(3);
+				*xPos = (int) item->window.rect.x;
+				yPos = (int *) VMA(4);
+				*yPos = (int) item->window.rect.y;
+				w = (int *) VMA(5);
+				*w = (int) item->window.rect.w;
+				h = (int *) VMA(6);
+				*h = (int) item->window.rect.h;
+
+				vec4_t *color;
+
+				color = (vec4_t *) VMA(7);
+				if (!color)
+				{
+					return qfalse;
+				}
+
+				(*color)[0] = (float) item->window.foreColor[0];
+				(*color)[1] = (float) item->window.foreColor[1];
+				(*color)[2] = (float) item->window.foreColor[2];
+				(*color)[3] = (float) item->window.foreColor[3];
+				background = (qhandle_t *) VMA(8);
+				if (!background)
+				{
+					return qfalse;
+				}
+				*background = item->window.background;
+
+				result = qtrue;
+			}
+			else
+			{
+				result = qfalse;
+			}
+		}
+		else
+		{
+			result = qfalse;
+		}
+
+		return result;
+		
+	case CG_SP_GETSTRINGTEXTSTRING:
+		const char* text;
+
+		assert(VMA(1));	
+		text = SE_GetString( (const char *) VMA(1) );
+
+		if (VMA(2))	// only if dest buffer supplied...
+		{
+			if ( text[0] )
+			{
+				Q_strncpyz( (char *) VMA(2), text, args[3] );				
+			}
+			else 
+			{
+				Com_sprintf( (char *) VMA(2), args[3], "??%s", VMA(1) );
+			}
+		}
+		return strlen(text);
+		//break;
+	default:
+		Com_Error( ERR_DROP, "Bad cgame system trap: %i", args[0] );
+	}
+	return 0;
+}
+
+
+/*
+====================
+CL_InitCGame
+
+Should only be called by CL_StartHunkUsers
+====================
+*/
+extern qboolean Sys_LowPhysicalMemory();
+void CL_InitCGame( void ) {
+	const char			*info;
+	const char			*mapname;
+	int		t1, t2;
+
+	t1 = Sys_Milliseconds();
+
+	// put away the console
+	Con_Close();
+
+	// find the current mapname
+	info = cl.gameState.stringData + cl.gameState.stringOffsets[ CS_SERVERINFO ];
+	mapname = Info_ValueForKey( info, "mapname" );
+	Com_sprintf( cl.mapname, sizeof( cl.mapname ), "maps/%s.bsp", mapname );
+
+	cls.state = CA_LOADING;
+
+	// init for this gamestate
+	VM_Call( CG_INIT, clc.serverCommandSequence );
+
+	// we will send a usercmd this frame, which
+	// will cause the server to send us the first snapshot
+	cls.state = CA_PRIMED;
+
+	t2 = Sys_Milliseconds();
+
+	//Com_Printf( "CL_InitCGame: %5.2f seconds\n", (t2-t1)/1000.0 );
+	// have the renderer touch all its images, so they are present
+	// on the card even if the driver does deferred loading
+	re.EndRegistration();
+
+	// make sure everything is paged in
+//	if (!Sys_LowPhysicalMemory()) 
+	{
+		Com_TouchMemory();
+	}
+
+	// clear anything that got printed
+	Con_ClearNotify ();
+}
+
+
+/*
+====================
+CL_GameCommand
+
+See if the current console command is claimed by the cgame
+====================
+*/
+qboolean CL_GameCommand( void ) {
+	if ( cls.state != CA_ACTIVE ) {
+		return qfalse;
+	}
+
+	return VM_Call( CG_CONSOLE_COMMAND );
+}
+
+
+
+/*
+=====================
+CL_CGameRendering
+=====================
+*/
+void CL_CGameRendering( stereoFrame_t stereo ) {
+#if 0
+	if ( cls.state == CA_ACTIVE ) {
+		static int counter;
+
+		if ( ++counter == 40 ) {
+			VM_Debug( 2 );
+		}
+	}
+#endif
+	int timei=cl.serverTime;
+	if (timei>60)
+	{
+		timei-=0;
+	}
+	G2API_SetTime(cl.serverTime,G2T_CG_TIME);
+	VM_Call( CG_DRAW_ACTIVE_FRAME,timei, stereo, qfalse );
+//	VM_Debug( 0 );
+}
+
+
+/*
+=================
+CL_AdjustTimeDelta
+
+Adjust the clients view of server time.
+
+We attempt to have cl.serverTime exactly equal the server's view
+of time plus the timeNudge, but with variable latencies over
+the internet it will often need to drift a bit to match conditions.
+
+Our ideal time would be to have the adjusted time aproach, but not pass,
+the very latest snapshot.
+
+Adjustments are only made when a new snapshot arrives, which keeps the
+adjustment process framerate independent and prevents massive overadjustment
+during times of significant packet loss.
+=================
+*/
+
+#define	RESET_TIME	300
+
+void CL_AdjustTimeDelta( void ) {
+/*
+	cl.newSnapshots = qfalse;
+	// if the current time is WAY off, just correct to the current value
+	if ( cls.realtime + cl.serverTimeDelta < cl.frame.serverTime - RESET_TIME 
+		|| cls.realtime + cl.serverTimeDelta > cl.frame.serverTime + RESET_TIME  ) {
+		cl.serverTimeDelta = cl.frame.serverTime - cls.realtime;
+		cl.oldServerTime = cl.frame.serverTime;
+		if ( cl_showTimeDelta->integer ) {
+			Com_Printf( "<RESET> " );
+		}
+	}
+
+	// if any of the frames between this and the previous snapshot
+	// had to be extrapolated, nudge our sense of time back a little
+	if ( cl.extrapolatedSnapshot ) {
+		cl.extrapolatedSnapshot = qfalse;
+		cl.serverTimeDelta -= 2;
+	} else {
+		// otherwise, move our sense of time forward to minimize total latency
+		cl.serverTimeDelta++;
+	}
+
+	if ( cl_showTimeDelta->integer ) {
+		Com_Printf( "%i ", cl.serverTimeDelta );
+	}
+*/
+	int		resetTime;
+	int		newDelta;
+	int		deltaDelta;
+
+	cl.newSnapshots = qfalse;
+	
+	// if the current time is WAY off, just correct to the current value
+	if ( com_sv_running->integer ) {
+		resetTime = 100;
+	} else {
+		resetTime = RESET_TIME;
+	}
+
+	newDelta = cl.frame.serverTime - cls.realtime;
+	deltaDelta = abs( newDelta - cl.serverTimeDelta );
+
+	if ( deltaDelta > RESET_TIME ) {
+		cl.serverTimeDelta = newDelta;
+		cl.oldServerTime = cl.frame.serverTime;	// FIXME: is this a problem for cgame?
+		cl.serverTime = cl.frame.serverTime;
+		if ( cl_showTimeDelta->integer ) {
+			Com_Printf( "<RESET> " );
+		}
+	} else if ( deltaDelta > 100 ) {
+		// fast adjust, cut the difference in half
+		if ( cl_showTimeDelta->integer ) {
+			Com_Printf( "<FAST> " );
+		}
+		cl.serverTimeDelta = ( cl.serverTimeDelta + newDelta ) >> 1;
+	} else {
+		// slow drift adjust, only move 1 or 2 msec
+
+		// if any of the frames between this and the previous snapshot
+		// had to be extrapolated, nudge our sense of time back a little
+		// the granularity of +1 / -2 is too high for timescale modified frametimes
+		if ( com_timescale->value == 0 || com_timescale->value == 1 ) {
+			if ( cl.extrapolatedSnapshot ) {
+				cl.extrapolatedSnapshot = qfalse;
+				cl.serverTimeDelta -= 2;
+			} else {
+				// otherwise, move our sense of time forward to minimize total latency
+				cl.serverTimeDelta++;
+			}
+		}
+	}
+
+	if ( cl_showTimeDelta->integer ) {
+		Com_Printf( "%i ", cl.serverTimeDelta );
+	}
+}
+
+
+/*
+==================
+CL_FirstSnapshot
+==================
+*/
+void CL_FirstSnapshot( void ) {
+
+	RE_RegisterMedia_LevelLoadEnd();
+
+	cls.state = CA_ACTIVE;
+
+	// set the timedelta so we are exactly on this first frame
+	cl.serverTimeDelta = cl.frame.serverTime - cls.realtime;
+	cl.oldServerTime = cl.frame.serverTime;
+
+	// if this is the first frame of active play,
+	// execute the contents of activeAction now
+	// this is to allow scripting a timedemo to start right
+	// after loading
+	if ( cl_activeAction->string[0] ) {
+		Cbuf_AddText( cl_activeAction->string );
+		Cvar_Set( "activeAction", "" );
+	}
+	
+	Sys_BeginProfiling();
+
+#ifdef _XBOX
+	// turn vsync back on - tearing is ugly
+	qglEnable(GL_VSYNC);
+#endif
+}
+
+/*
+==================
+CL_SetCGameTime
+==================
+*/
+void CL_SetCGameTime( void ) {
+
+	// getting a valid frame message ends the connection process
+	if ( cls.state != CA_ACTIVE ) {
+		if ( cls.state != CA_PRIMED ) {
+			return;
+		}
+		if ( cl.newSnapshots ) {
+			cl.newSnapshots = qfalse;
+			CL_FirstSnapshot();
+		}
+
+		if ( cls.state != CA_ACTIVE ) {
+			return;
+		}
+	}	
+
+	// if we have gotten to this point, cl.frame is guaranteed to be valid
+	if ( !cl.frame.valid ) {
+		Com_Error( ERR_DROP, "CL_SetCGameTime: !cl.snap.valid" );
+	}
+
+	// allow pause in single player
+	if ( sv_paused->integer && cl_paused->integer && com_sv_running->integer ) {
+		// paused
+		return;
+	}
+
+	if ( cl.frame.serverTime < cl.oldFrameServerTime ) {
+		Com_Error( ERR_DROP, "cl.frame.serverTime < cl.oldFrameServerTime" );
+	}
+	cl.oldFrameServerTime = cl.frame.serverTime;
+
+
+	// get our current view of time
+
+	// cl_timeNudge is a user adjustable cvar that allows more
+	// or less latency to be added in the interest of better 
+	// smoothness or better responsiveness.
+	cl.serverTime = cls.realtime + cl.serverTimeDelta - cl_timeNudge->integer;
+
+	// guarantee that time will never flow backwards, even if
+	// serverTimeDelta made an adjustment or cl_timeNudge was changed
+	if ( cl.serverTime < cl.oldServerTime ) {
+		cl.serverTime = cl.oldServerTime;
+	}
+	cl.oldServerTime = cl.serverTime;
+
+	// note if we are almost past the latest frame (without timeNudge),
+	// so we will try and adjust back a bit when the next snapshot arrives
+	if ( cls.realtime + cl.serverTimeDelta >= cl.frame.serverTime - 5 ) {
+		cl.extrapolatedSnapshot = qtrue;
+	}
+
+	// if we have gotten new snapshots, drift serverTimeDelta
+	// don't do this every frame, or a period of packet loss would
+	// make a huge adjustment
+	if ( cl.newSnapshots ) {
+		CL_AdjustTimeDelta();
+	}
+}
+
diff --git a/code/client/cl_cin.cpp b/code/client/cl_cin.cpp
new file mode 100644
index 0000000..b78ad51
--- /dev/null
+++ b/code/client/cl_cin.cpp
@@ -0,0 +1,1950 @@
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+/*****************************************************************************
+ * name:		cl_cin.c
+ *
+ * desc:		video and cinematic playback
+ *
+ * $Archive: /MissionPack/code/client/cl_cin.c $
+ * $Author: Ttimo $ 
+ * $Revision: 82 $
+ * $Modtime: 4/13/01 4:48p $
+ * $Date: 4/13/01 4:48p $
+ *
+ * cl_glconfig.hwtype trtypes 3dfx/ragepro need 256x256
+ *
+ *****************************************************************************/
+
+#include "client.h"
+#include "client_ui.h"	// CHC
+#include "snd_local.h"
+
+#define MAXSIZE				8
+#define MINSIZE				4
+
+#define DEFAULT_CIN_WIDTH	512
+#define DEFAULT_CIN_HEIGHT	512
+
+#define ROQ_QUAD			0x1000
+#define ROQ_QUAD_INFO		0x1001
+#define ROQ_CODEBOOK		0x1002
+#define ROQ_QUAD_VQ			0x1011
+#define ROQ_QUAD_JPEG		0x1012
+#define ROQ_QUAD_HANG		0x1013
+#define ROQ_PACKET			0x1030
+#define ZA_SOUND_MONO		0x1020
+#define ZA_SOUND_STEREO		0x1021
+
+#define MAX_VIDEO_HANDLES	16
+
+extern glconfig_t glConfig;
+extern	int		s_paintedtime;
+extern	int		s_rawend;
+
+extern void S_CIN_StopSound(sfxHandle_t sfxHandle);
+static void RoQ_init( void );
+
+/******************************************************************************
+*
+* Class:		trFMV
+*
+* Description:	RoQ/RnR manipulation routines
+*				not entirely complete for first run
+*
+******************************************************************************/
+
+typedef struct {
+	byte				linbuf[DEFAULT_CIN_WIDTH*DEFAULT_CIN_HEIGHT*4*2];
+	byte				file[65536];
+	short				sqrTable[256];
+
+	unsigned int		mcomp[256];
+	unsigned short		vq2[256*16*4];
+	unsigned short		vq4[256*64*4];
+	unsigned short		vq8[256*256*4];
+
+	long				ROQ_YY_tab[256];
+	long				ROQ_UB_tab[256];
+	long				ROQ_UG_tab[256];
+	long				ROQ_VG_tab[256];
+	long				ROQ_VR_tab[256];
+
+	byte				*qStatus[2][32768];
+
+	long				oldXOff, oldYOff;
+	unsigned int		oldysize, oldxsize;
+} cinematics_t;
+
+typedef struct {
+	char				fileName[MAX_OSPATH];
+	int					CIN_WIDTH, CIN_HEIGHT;
+	int					xpos, ypos, width, height;
+	qboolean			looping, holdAtEnd, dirty, alterGameState, silent, shader;
+	fileHandle_t		iFile;	// 0 = none
+	e_status			status;	
+	unsigned int		startTime;
+	unsigned int		lastTime;
+	long				tfps;
+	long				RoQPlayed;
+	long				ROQSize;
+	unsigned int		RoQFrameSize;
+	long				onQuad;
+	long				numQuads;
+	long				samplesPerLine;
+	unsigned int		roq_id;
+	long				screenDelta;
+
+	void ( *VQ0)(byte *status, void *qdata );
+	void ( *VQ1)(byte *status, void *qdata );
+	void ( *VQNormal)(byte *status, void *qdata );
+	void ( *VQBuffer)(byte *status, void *qdata );
+
+	byte*				gray;
+	unsigned int		xsize, ysize, maxsize, minsize;
+
+	qboolean			inMemory;
+	long				normalBuffer0;
+	long				roq_flags;
+	long				roqF0;
+	long				roqF1;
+	long				t[2];
+	long				roqFPS;
+	int					playonwalls;
+	byte*				buf;
+	long				drawX, drawY;
+	sfxHandle_t			hSFX;	// 0 = none
+	qhandle_t			hCRAWLTEXT;	// 0 = none
+} cin_cache;
+
+static cinematics_t		cin;
+static cin_cache		cinTable[MAX_VIDEO_HANDLES];
+static int				currentHandle = -1;
+static int				CL_handle = -1;
+static int				CL_iPlaybackStartTime;	// so I can stop users quitting playback <1 second after it starts
+
+extern int				s_soundtime;		// sample PAIRS
+extern int   			s_paintedtime; 		// sample PAIRS
+
+
+void CIN_CloseAllVideos(void) {
+	int		i;
+
+	for ( i = 0 ; i < MAX_VIDEO_HANDLES ; i++ ) {
+		if (cinTable[i].fileName[0] != 0 ) {
+			CIN_StopCinematic(i);
+		}
+	}
+}
+
+
+static int CIN_HandleForVideo(void) {
+	int		i;
+
+	//these end up in scratchImage[NUM_SCRATCH_IMAGES], so MAX_VIDEO_HANDLES should match
+	assert (MAX_VIDEO_HANDLES<=NUM_SCRATCH_IMAGES);
+
+	for ( i = 0 ; i < MAX_VIDEO_HANDLES ; i++ ) {
+		if ( cinTable[i].fileName[0] == 0 ) {
+			return i;
+		}
+	}
+	Com_Error( ERR_DROP, "CIN_HandleForVideo: none free" );
+	return -1;
+}
+
+
+
+
+//-----------------------------------------------------------------------------
+// RllSetupTable
+//
+// Allocates and initializes the square table.
+//
+// Parameters:	None
+//
+// Returns:		Nothing
+//-----------------------------------------------------------------------------
+static void RllSetupTable()
+{
+	int z;
+
+	if (currentHandle < 0) return;
+
+	for (z=0;z<128;z++) {
+		cin.sqrTable[z] = (short)(z*z);
+		cin.sqrTable[z+128] = (short)(-cin.sqrTable[z]);
+	}
+}
+
+
+
+//-----------------------------------------------------------------------------
+// RllDecodeMonoToMono
+//
+// Decode mono source data into a mono buffer.
+//
+// Parameters:	from -> buffer holding encoded data
+//				to ->	buffer to hold decoded data
+//				size =	number of bytes of input (= # of shorts of output)
+//				signedOutput = 0 for unsigned output, non-zero for signed output
+//				flag = flags from asset header
+//
+// Returns:		Number of samples placed in output buffer
+//-----------------------------------------------------------------------------
+/*
+static long RllDecodeMonoToMono(unsigned char *from,short *to,unsigned int size,char signedOutput ,unsigned short flag)
+{
+	unsigned int z;
+	int prev;
+	
+	if (currentHandle < 0) return 0;
+
+	if (signedOutput)	
+		prev =  flag - 0x8000;
+	else 
+		prev = flag;
+
+	for (z=0;z<size;z++) {
+		prev = to[z] = (short)(prev + cin.sqrTable[from[z]]); 
+	}
+	return size;	//*sizeof(short));
+}
+*/
+
+//-----------------------------------------------------------------------------
+// RllDecodeMonoToStereo
+//
+// Decode mono source data into a stereo buffer. Output is 4 times the number
+// of bytes in the input.
+//
+// Parameters:	from -> buffer holding encoded data
+//				to ->	buffer to hold decoded data
+//				size =	number of bytes of input (= 1/4 # of bytes of output)
+//				signedOutput = 0 for unsigned output, non-zero for signed output
+//				flag = flags from asset header
+//
+// Returns:		Number of samples placed in output buffer
+//-----------------------------------------------------------------------------
+static long RllDecodeMonoToStereo(unsigned char *from,unsigned int size,char signedOutput,unsigned short flag, qboolean bMixedWithCurrentAudio)
+{
+	unsigned int z;
+	int prev, dst;
+	portable_samplepair_t	*samps;
+	
+	if (currentHandle < 0) return 0;
+
+	if (signedOutput)	
+		prev =  flag - 0x8000;
+	else 
+		prev = flag;
+
+	samps = S_GetRawSamplePointer();
+
+	extern cvar_t *s_volume;
+	int iVolume = 1/*bMixedWithCurrentAudio*/ ? ((int) (256.0f * (s_volume?s_volume->value:1.0f))) : 256;
+
+	for (z = 0; z < size; z++) {
+		dst = s_rawend&(MAX_RAW_SAMPLES-1);
+		s_rawend++;
+		prev = (short)(prev + cin.sqrTable[from[z]]);
+		samps[dst].left = samps[dst].right =  prev*iVolume;
+	}
+	
+	return size;	// * 2 * sizeof(short));
+}
+
+
+//-----------------------------------------------------------------------------
+// RllDecodeStereoToStereo
+//
+// Decode stereo source data into a stereo buffer.
+//
+// Parameters:	from -> buffer holding encoded data
+//				to ->	buffer to hold decoded data
+//				size =	number of bytes of input (= 1/2 # of bytes of output)
+//				signedOutput = 0 for unsigned output, non-zero for signed output
+//				flag = flags from asset header
+//
+// Returns:		Number of samples placed in output buffer
+//-----------------------------------------------------------------------------
+static long RllDecodeStereoToStereo(unsigned char *from,unsigned int size,char signedOutput, unsigned short flag, qboolean bMixedWithCurrentAudio)
+{
+	unsigned int z;
+	unsigned char *zz = from;
+	int	prevL, prevR, dst;
+	portable_samplepair_t	*samps;
+
+	if (currentHandle < 0) return 0;
+
+	if (signedOutput) {
+		prevL = (flag & 0xff00) - 0x8000;
+		prevR = ((flag & 0x00ff) << 8) -0x8000;
+	} else {
+		prevL = flag & 0xff00;
+		prevR = (flag & 0x00ff) << 8;
+	}
+
+	samps = S_GetRawSamplePointer();
+
+	extern cvar_t *s_volume;
+	int iVolume = 1/*bMixedWithCurrentAudio*/ ? ((int) (256.0f * (s_volume?s_volume->value:1.0f))) : 256;
+
+	switch (dma.speed)
+	{
+		case 11025:
+		{
+			for (z=0;z<size;z+=2) {
+				prevL = (short)(prevL + cin.sqrTable[*zz++]); 
+				prevR = (short)(prevR + cin.sqrTable[*zz++]);
+
+				if (z&2)
+				{
+					dst = s_rawend&(MAX_RAW_SAMPLES-1);
+					s_rawend++;
+					samps[dst].left  = prevL*iVolume;
+					samps[dst].right = prevR*iVolume;
+				}
+			}
+		}
+		break;
+
+		case 22050:
+		{
+			// 1:1 case...
+			//
+			for (z=0;z<size;z+=2) {
+				dst = s_rawend&(MAX_RAW_SAMPLES-1);
+				s_rawend++;
+				prevL = (short)(prevL + cin.sqrTable[*zz++]); 
+				prevR = (short)(prevR + cin.sqrTable[*zz++]);
+				samps[dst].left  = prevL*iVolume;
+				samps[dst].right = prevR*iVolume;
+			}
+		}
+		break;
+
+		case 44100:
+		{
+			for (z=0;z<size;z+=2) {
+				prevL = (short)(prevL + cin.sqrTable[*zz++]); 
+				prevR = (short)(prevR + cin.sqrTable[*zz++]);
+
+				dst = s_rawend&(MAX_RAW_SAMPLES-1);
+				s_rawend++;
+				samps[dst].left  = prevL*iVolume;
+				samps[dst].right = prevR*iVolume;
+
+				dst = s_rawend&(MAX_RAW_SAMPLES-1);
+				s_rawend++;
+				samps[dst].left  = prevL*iVolume;
+				samps[dst].right = prevR*iVolume;
+			}
+		}
+		break;
+	}
+	
+	return (size>>1);	//*sizeof(short));
+}
+
+
+//-----------------------------------------------------------------------------
+// RllDecodeStereoToMono
+//
+// Decode stereo source data into a mono buffer.
+//
+// Parameters:	from -> buffer holding encoded data
+//				to ->	buffer to hold decoded data
+//				size =	number of bytes of input (= # of bytes of output)
+//				signedOutput = 0 for unsigned output, non-zero for signed output
+//				flag = flags from asset header
+//
+// Returns:		Number of samples placed in output buffer
+//-----------------------------------------------------------------------------
+/*
+static long RllDecodeStereoToMono(unsigned char *from,short *to,unsigned int size,char signedOutput, unsigned short flag)
+{
+	unsigned int z;
+	int prevL,prevR;
+	
+	if (currentHandle < 0) return 0;
+
+	if (signedOutput) {
+		prevL = (flag & 0xff00) - 0x8000;
+		prevR = ((flag & 0x00ff) << 8) -0x8000;
+	} else {
+		prevL = flag & 0xff00;
+		prevR = (flag & 0x00ff) << 8;
+	}
+
+	for (z=0;z<size;z+=1) {
+		prevL= prevL + cin.sqrTable[from[z*2]];
+		prevR = prevR + cin.sqrTable[from[z*2+1]];
+		to[z] = (short)((prevL + prevR)/2);
+	}
+
+	return size;
+}
+*/
+/******************************************************************************
+*
+* Function:		
+*
+* Description:	
+*
+******************************************************************************/
+
+static void move8_32( byte *src, byte *dst, int spl )
+{
+	double *dsrc, *ddst;
+	int dspl;
+
+	dsrc = (double *)src;
+	ddst = (double *)dst;
+	dspl = spl>>3;
+
+	ddst[0] = dsrc[0]; ddst[1] = dsrc[1]; ddst[2] = dsrc[2]; ddst[3] = dsrc[3];
+	dsrc += dspl; ddst += dspl;
+	ddst[0] = dsrc[0]; ddst[1] = dsrc[1]; ddst[2] = dsrc[2]; ddst[3] = dsrc[3];
+	dsrc += dspl; ddst += dspl;
+	ddst[0] = dsrc[0]; ddst[1] = dsrc[1]; ddst[2] = dsrc[2]; ddst[3] = dsrc[3];
+	dsrc += dspl; ddst += dspl;
+	ddst[0] = dsrc[0]; ddst[1] = dsrc[1]; ddst[2] = dsrc[2]; ddst[3] = dsrc[3];
+	dsrc += dspl; ddst += dspl;
+	ddst[0] = dsrc[0]; ddst[1] = dsrc[1]; ddst[2] = dsrc[2]; ddst[3] = dsrc[3];
+	dsrc += dspl; ddst += dspl;
+	ddst[0] = dsrc[0]; ddst[1] = dsrc[1]; ddst[2] = dsrc[2]; ddst[3] = dsrc[3];
+	dsrc += dspl; ddst += dspl;
+	ddst[0] = dsrc[0]; ddst[1] = dsrc[1]; ddst[2] = dsrc[2]; ddst[3] = dsrc[3];
+	dsrc += dspl; ddst += dspl;
+	ddst[0] = dsrc[0]; ddst[1] = dsrc[1]; ddst[2] = dsrc[2]; ddst[3] = dsrc[3];
+}
+
+/******************************************************************************
+*
+* Function:		
+*
+* Description:	
+*
+******************************************************************************/
+
+static void move4_32( byte *src, byte *dst, int spl  )
+{
+	double *dsrc, *ddst;
+	int dspl;
+
+	dsrc = (double *)src;
+	ddst = (double *)dst;
+	dspl = spl>>3;
+
+	ddst[0] = dsrc[0]; ddst[1] = dsrc[1];
+	dsrc += dspl; ddst += dspl;
+	ddst[0] = dsrc[0]; ddst[1] = dsrc[1];
+	dsrc += dspl; ddst += dspl;
+	ddst[0] = dsrc[0]; ddst[1] = dsrc[1];
+	dsrc += dspl; ddst += dspl;
+	ddst[0] = dsrc[0]; ddst[1] = dsrc[1];
+}
+
+/******************************************************************************
+*
+* Function:		
+*
+* Description:	
+*
+******************************************************************************/
+
+static void blit8_32( byte *src, byte *dst, int spl  )
+{
+	double *dsrc, *ddst;
+	int dspl;
+
+	dsrc = (double *)src;
+	ddst = (double *)dst;
+	dspl = spl>>3;
+
+	ddst[0] = dsrc[0]; ddst[1] = dsrc[1]; ddst[2] = dsrc[2]; ddst[3] = dsrc[3];
+	dsrc += 4; ddst += dspl;
+	ddst[0] = dsrc[0]; ddst[1] = dsrc[1]; ddst[2] = dsrc[2]; ddst[3] = dsrc[3];
+	dsrc += 4; ddst += dspl;
+	ddst[0] = dsrc[0]; ddst[1] = dsrc[1]; ddst[2] = dsrc[2]; ddst[3] = dsrc[3];
+	dsrc += 4; ddst += dspl;
+	ddst[0] = dsrc[0]; ddst[1] = dsrc[1]; ddst[2] = dsrc[2]; ddst[3] = dsrc[3];
+	dsrc += 4; ddst += dspl;
+	ddst[0] = dsrc[0]; ddst[1] = dsrc[1]; ddst[2] = dsrc[2]; ddst[3] = dsrc[3];
+	dsrc += 4; ddst += dspl;
+	ddst[0] = dsrc[0]; ddst[1] = dsrc[1]; ddst[2] = dsrc[2]; ddst[3] = dsrc[3];
+	dsrc += 4; ddst += dspl;
+	ddst[0] = dsrc[0]; ddst[1] = dsrc[1]; ddst[2] = dsrc[2]; ddst[3] = dsrc[3];
+	dsrc += 4; ddst += dspl;
+	ddst[0] = dsrc[0]; ddst[1] = dsrc[1]; ddst[2] = dsrc[2]; ddst[3] = dsrc[3];
+}
+
+/******************************************************************************
+*
+* Function:		
+*
+* Description:	
+*
+******************************************************************************/
+
+static void blit4_32( byte *src, byte *dst, int spl  )
+{
+	double *dsrc, *ddst;
+	int dspl;
+
+	dsrc = (double *)src;
+	ddst = (double *)dst;
+	dspl = spl>>3;
+
+	ddst[0] = dsrc[0]; ddst[1] = dsrc[1];
+	dsrc += 2; ddst += dspl;
+	ddst[0] = dsrc[0]; ddst[1] = dsrc[1];
+	dsrc += 2; ddst += dspl;
+	ddst[0] = dsrc[0]; ddst[1] = dsrc[1];
+	dsrc += 2; ddst += dspl;
+	ddst[0] = dsrc[0]; ddst[1] = dsrc[1];
+}
+
+/******************************************************************************
+*
+* Function:		
+*
+* Description:	
+*
+******************************************************************************/
+
+static void blit2_32( byte *src, byte *dst, int spl  )
+{
+	double *dsrc, *ddst;
+	int dspl;
+
+	dsrc = (double *)src;
+	ddst = (double *)dst;
+	dspl = spl>>3;
+
+	ddst[0] = dsrc[0];
+	ddst[dspl] = dsrc[1];
+}
+
+/******************************************************************************
+*
+* Function:		
+*
+* Description:	
+*
+******************************************************************************/
+
+static void blitVQQuad32fs( byte **status, unsigned char *data )
+{
+unsigned short	newd, celdata, code;
+unsigned int	index, i;
+
+	newd	= 0;
+	celdata = 0;
+	index	= 0;
+	
+	if (currentHandle < 0) return;
+
+	do {
+		if (!newd) { 
+			newd = 7;
+			celdata = data[0] + data[1]*256;
+			data += 2;
+		} else {
+			newd--;
+		}
+
+		code = (unsigned short)(celdata&0xc000); 
+		celdata <<= 2;
+		
+		switch (code) {
+			case	0x8000:													// vq code
+				blit8_32( (byte *)&cin.vq8[(*data)*128], status[index], cinTable[currentHandle].samplesPerLine );
+				data++;
+				index += 5;
+				break;
+			case	0xc000:													// drop
+				index++;													// skip 8x8
+				for(i=0;i<4;i++) {
+					if (!newd) { 
+						newd = 7;
+						celdata = data[0] + data[1]*256;
+						data += 2;
+					} else {
+						newd--;
+					}
+						
+					code = (unsigned short)(celdata&0xc000); celdata <<= 2; 
+
+					switch (code) {											// code in top two bits of code
+						case	0x8000:										// 4x4 vq code
+							blit4_32( (byte *)&cin.vq4[(*data)*32], status[index], cinTable[currentHandle].samplesPerLine );
+							data++;
+							break;
+						case	0xc000:										// 2x2 vq code
+							blit2_32( (byte *)&cin.vq2[(*data)*8], status[index], cinTable[currentHandle].samplesPerLine );
+							data++;
+							blit2_32( (byte *)&cin.vq2[(*data)*8], status[index]+8, cinTable[currentHandle].samplesPerLine );
+							data++;
+							blit2_32( (byte *)&cin.vq2[(*data)*8], status[index]+cinTable[currentHandle].samplesPerLine*2, cinTable[currentHandle].samplesPerLine );
+							data++;
+							blit2_32( (byte *)&cin.vq2[(*data)*8], status[index]+cinTable[currentHandle].samplesPerLine*2+8, cinTable[currentHandle].samplesPerLine );
+							data++;
+							break;
+						case	0x4000:										// motion compensation
+							move4_32( status[index] + cin.mcomp[(*data)], status[index], cinTable[currentHandle].samplesPerLine );
+							data++;
+							break;
+					}
+					index++;
+				}
+				break;
+			case	0x4000:													// motion compensation
+				move8_32( status[index] + cin.mcomp[(*data)], status[index], cinTable[currentHandle].samplesPerLine );
+				data++;
+				index += 5;
+				break;
+			case	0x0000:
+				index += 5;
+				break;
+		}
+	} while ( status[index] != NULL );
+}
+
+/******************************************************************************
+*
+* Function:		
+*
+* Description:	
+*
+******************************************************************************/
+
+static void ROQ_GenYUVTables( void )
+{
+	float t_ub,t_vr,t_ug,t_vg;
+	long i;
+
+	if (currentHandle < 0) return;
+
+	t_ub = (1.77200f/2.0f) * (float)(1<<6) + 0.5f;
+	t_vr = (1.40200f/2.0f) * (float)(1<<6) + 0.5f;
+	t_ug = (0.34414f/2.0f) * (float)(1<<6) + 0.5f;
+	t_vg = (0.71414f/2.0f) * (float)(1<<6) + 0.5f;
+	for(i=0;i<256;i++) {
+		float x = (float)(2 * i - 255);
+	
+		cin.ROQ_UB_tab[i] = (long)( ( t_ub * x) + (1<<5));
+		cin.ROQ_VR_tab[i] = (long)( ( t_vr * x) + (1<<5));
+		cin.ROQ_UG_tab[i] = (long)( (-t_ug * x)		 );
+		cin.ROQ_VG_tab[i] = (long)( (-t_vg * x) + (1<<5));
+		cin.ROQ_YY_tab[i] = (long)( (i << 6) | (i >> 2) );
+	}
+}
+
+#define VQ2TO4(a,b,c,d) { \
+    	*c++ = a[0];	\
+	*d++ = a[0];	\
+	*d++ = a[0];	\
+	*c++ = a[1];	\
+	*d++ = a[1];	\
+	*d++ = a[1];	\
+	*c++ = b[0];	\
+	*d++ = b[0];	\
+	*d++ = b[0];	\
+	*c++ = b[1];	\
+	*d++ = b[1];	\
+	*d++ = b[1];	\
+	*d++ = a[0];	\
+	*d++ = a[0];	\
+	*d++ = a[1];	\
+	*d++ = a[1];	\
+	*d++ = b[0];	\
+	*d++ = b[0];	\
+	*d++ = b[1];	\
+	*d++ = b[1];	\
+	a += 2; b += 2; }
+ 
+#define VQ2TO2(a,b,c,d) { \
+	*c++ = *a;	\
+	*d++ = *a;	\
+	*d++ = *a;	\
+	*c++ = *b;	\
+	*d++ = *b;	\
+	*d++ = *b;	\
+	*d++ = *a;	\
+	*d++ = *a;	\
+	*d++ = *b;	\
+	*d++ = *b;	\
+	a++; b++; }
+
+/******************************************************************************
+*
+* Function:		
+*
+* Description:	
+*
+******************************************************************************/
+/*
+static unsigned short yuv_to_rgb( long y, long u, long v )
+{ 
+	long r,g,b,YY = (long)(cin.ROQ_YY_tab[(y)]);
+
+	r = (YY + cin.ROQ_VR_tab[v]) >> 9;
+	g = (YY + cin.ROQ_UG_tab[u] + cin.ROQ_VG_tab[v]) >> 8;
+	b = (YY + cin.ROQ_UB_tab[u]) >> 9;
+	
+	if (r<0) r = 0; if (g<0) g = 0; if (b<0) b = 0;
+	if (r > 31) r = 31; if (g > 63) g = 63; if (b > 31) b = 31;
+
+	return (unsigned short)((r<<11)+(g<<5)+(b));
+}
+*/
+/******************************************************************************
+*
+* Function:		
+*
+* Description:	
+*
+******************************************************************************/
+
+static unsigned int yuv_to_rgb24( long y, long u, long v )
+{ 
+	long r,g,b,YY = (long)(cin.ROQ_YY_tab[(y)]);
+
+	r = (YY + cin.ROQ_VR_tab[v]) >> 6;
+	g = (YY + cin.ROQ_UG_tab[u] + cin.ROQ_VG_tab[v]) >> 6;
+	b = (YY + cin.ROQ_UB_tab[u]) >> 6;
+	
+	if (r<0) r = 0; if (g<0) g = 0; if (b<0) b = 0;
+	if (r > 255) r = 255; if (g > 255) g = 255; if (b > 255) b = 255;
+	
+	return LittleLong((r)+(g<<8)+(b<<16));
+}
+
+/******************************************************************************
+*
+* Function:		
+*
+* Description:	
+*
+******************************************************************************/
+
+static void decodeCodeBook( byte *input, unsigned short roq_flags )
+{
+	long	i, j, two, four;
+	unsigned short	*bptr;
+	long	y0,y1,y2,y3,cr,cb;
+	unsigned int *iaptr, *ibptr, *icptr, *idptr;
+
+	if (currentHandle < 0) return;
+
+	if (!roq_flags) {
+		two = four = 256;
+	} else {
+		two  = roq_flags>>8;
+		if (!two) two = 256;
+		four = roq_flags&0xff;
+	}
+
+	four *= 2;
+
+	bptr = (unsigned short *)cin.vq2;
+
+	//
+	// normal height
+	//
+	ibptr = (unsigned int *)bptr;
+	for(i=0;i<two;i++) {
+		y0 = (long)*input++;
+		y1 = (long)*input++;
+		y2 = (long)*input++;
+		y3 = (long)*input++;
+		cr = (long)*input++;
+		cb = (long)*input++;
+		*ibptr++ = yuv_to_rgb24( y0, cr, cb );
+		*ibptr++ = yuv_to_rgb24( y1, cr, cb );
+		*ibptr++ = yuv_to_rgb24( y2, cr, cb );
+		*ibptr++ = yuv_to_rgb24( y3, cr, cb );
+	}
+	
+	icptr = (unsigned int *)cin.vq4;
+	idptr = (unsigned int *)cin.vq8;
+	
+	for(i=0;i<four;i++) {
+		iaptr = (unsigned int *)cin.vq2 + (*input++)*4;
+		ibptr = (unsigned int *)cin.vq2 + (*input++)*4;
+		for(j=0;j<2;j++) 
+			VQ2TO4(iaptr, ibptr, icptr, idptr);
+	}
+}
+
+/******************************************************************************
+*
+* Function:		
+*
+* Description:	
+*
+******************************************************************************/
+
+static void recurseQuad( long startX, long startY, long quadSize, long xOff, long yOff )
+{
+	byte *scroff;
+	long bigx, bigy, lowx, lowy, useY;
+	long offset;
+
+	offset = cinTable[currentHandle].screenDelta;
+	
+	lowx = lowy = 0;
+	bigx = cinTable[currentHandle].xsize;
+	bigy = cinTable[currentHandle].ysize;
+
+	if (bigx > cinTable[currentHandle].CIN_WIDTH) bigx = cinTable[currentHandle].CIN_WIDTH;
+	if (bigy > cinTable[currentHandle].CIN_HEIGHT) bigy = cinTable[currentHandle].CIN_HEIGHT;
+
+	if ( (startX >= lowx) && (startX+quadSize) <= (bigx) && (startY+quadSize) <= (bigy) && (startY >= lowy) && quadSize <= MAXSIZE) {
+		useY = startY;
+		scroff = cin.linbuf + (useY+((cinTable[currentHandle].CIN_HEIGHT-bigy)>>1)+yOff)*(cinTable[currentHandle].samplesPerLine) + (((startX+xOff))*4);
+
+		cin.qStatus[0][cinTable[currentHandle].onQuad  ] = scroff;
+		cin.qStatus[1][cinTable[currentHandle].onQuad++] = scroff+offset;
+	}
+
+	if ( quadSize != MINSIZE ) {
+		quadSize >>= 1;
+		recurseQuad( startX,		  startY		  , quadSize, xOff, yOff );
+		recurseQuad( startX+quadSize, startY		  , quadSize, xOff, yOff );
+		recurseQuad( startX,		  startY+quadSize , quadSize, xOff, yOff );
+		recurseQuad( startX+quadSize, startY+quadSize , quadSize, xOff, yOff );
+	}
+}
+
+
+/******************************************************************************
+*
+* Function:		
+*
+* Description:	
+*
+******************************************************************************/
+
+static void setupQuad( long xOff, long yOff )
+{
+	long numQuadCels, i,x,y;
+	byte *temp;
+
+	if (currentHandle < 0) return;
+
+	if (xOff == cin.oldXOff && yOff == cin.oldYOff && cinTable[currentHandle].ysize == cin.oldysize && cinTable[currentHandle].xsize == cin.oldxsize) {
+		return;
+	}
+
+	cin.oldXOff = xOff;
+	cin.oldYOff = yOff;
+	cin.oldysize = cinTable[currentHandle].ysize;
+	cin.oldxsize = cinTable[currentHandle].xsize;
+
+	numQuadCels  = (cinTable[currentHandle].CIN_WIDTH*cinTable[currentHandle].CIN_HEIGHT) / (16);
+	numQuadCels += numQuadCels/4 + numQuadCels/16;
+	numQuadCels += 64;							  // for overflow
+
+	numQuadCels  = (cinTable[currentHandle].xsize*cinTable[currentHandle].ysize) / (16);
+	numQuadCels += numQuadCels/4;
+	numQuadCels += 64;							  // for overflow
+
+	cinTable[currentHandle].onQuad = 0;
+
+	for(y=0;y<(long)cinTable[currentHandle].ysize;y+=16) 
+		for(x=0;x<(long)cinTable[currentHandle].xsize;x+=16) 
+			recurseQuad( x, y, 16, xOff, yOff );
+
+	temp = NULL;
+
+	for(i=(numQuadCels-64);i<numQuadCels;i++) {
+		cin.qStatus[0][i] = temp;			  // eoq
+		cin.qStatus[1][i] = temp;			  // eoq
+	}
+}
+
+/******************************************************************************
+*
+* Function:		
+*
+* Description:	
+*
+******************************************************************************/
+
+static void readQuadInfo( byte *qData )
+{
+	if (currentHandle < 0) return;
+
+	cinTable[currentHandle].xsize    = qData[0]+qData[1]*256;
+	cinTable[currentHandle].ysize    = qData[2]+qData[3]*256;
+	cinTable[currentHandle].maxsize  = qData[4]+qData[5]*256;
+	cinTable[currentHandle].minsize  = qData[6]+qData[7]*256;
+	
+	cinTable[currentHandle].CIN_HEIGHT = cinTable[currentHandle].ysize;
+	cinTable[currentHandle].CIN_WIDTH  = cinTable[currentHandle].xsize;
+
+	cinTable[currentHandle].samplesPerLine = cinTable[currentHandle].CIN_WIDTH*4;
+	cinTable[currentHandle].screenDelta = cinTable[currentHandle].CIN_HEIGHT*cinTable[currentHandle].samplesPerLine;
+	
+	cinTable[currentHandle].VQ0 = cinTable[currentHandle].VQNormal;
+	cinTable[currentHandle].VQ1 = cinTable[currentHandle].VQBuffer;
+
+	cinTable[currentHandle].t[0] = (0 - (unsigned int)cin.linbuf)+(unsigned int)cin.linbuf+cinTable[currentHandle].screenDelta;
+	cinTable[currentHandle].t[1] = (0 - ((unsigned int)cin.linbuf + cinTable[currentHandle].screenDelta))+(unsigned int)cin.linbuf;
+
+	cinTable[currentHandle].drawX = cinTable[currentHandle].CIN_WIDTH;
+	cinTable[currentHandle].drawY = cinTable[currentHandle].CIN_HEIGHT;
+	// jic the card sucks
+	if ( glConfig.maxTextureSize <= 256) {
+        if (cinTable[currentHandle].drawX>256) {
+            cinTable[currentHandle].drawX = 256;
+        }
+        if (cinTable[currentHandle].drawY>256) {
+            cinTable[currentHandle].drawY = 256;
+        }
+		if (cinTable[currentHandle].CIN_WIDTH != 256 || cinTable[currentHandle].CIN_HEIGHT != 256) {
+			Com_DPrintf("HACK: approxmimating cinematic for Rage Pro or Voodoo\n");
+		}
+	}
+}
+
+/******************************************************************************
+*
+* Function:		
+*
+* Description:	
+*
+******************************************************************************/
+
+static void RoQPrepMcomp( long xoff, long yoff ) 
+{
+	long i, j, x, y, temp, temp2;
+
+	if (currentHandle < 0) return;
+
+	i=cinTable[currentHandle].samplesPerLine; 
+	j=4;
+	if ( cinTable[currentHandle].xsize == (cinTable[currentHandle].ysize*4) ) 
+	{ 
+		j = j+j; 
+		i = i+i; 
+	}
+	
+	for(y=0;y<16;y++) {
+		temp2 = (y+yoff-8)*i;
+		for(x=0;x<16;x++) {
+			temp = (x+xoff-8)*j;
+			cin.mcomp[(x*16)+y] = cinTable[currentHandle].normalBuffer0-(temp2+temp);
+		}
+	}
+}
+
+/******************************************************************************
+*
+* Function:		
+*
+* Description:	
+*
+******************************************************************************/
+
+static void initRoQ() 
+{
+	if (currentHandle < 0) return;
+
+	cinTable[currentHandle].VQNormal = (void (*)(byte *, void *))blitVQQuad32fs;
+	cinTable[currentHandle].VQBuffer = (void (*)(byte *, void *))blitVQQuad32fs;
+	ROQ_GenYUVTables();
+	RllSetupTable();
+}
+
+/******************************************************************************
+*
+* Function:		
+*
+* Description:	
+*
+******************************************************************************/
+/*
+static byte* RoQFetchInterlaced( byte *source ) {
+	int x, *src, *dst;
+
+	if (currentHandle < 0) return NULL;
+
+	src = (int *)source;
+	dst = (int *)cinTable[currentHandle].buf2;
+
+	for(x=0;x<256*256;x++) {
+		*dst = *src;
+		dst++; src += 2;
+	}
+	return cinTable[currentHandle].buf2;
+}
+*/
+static void RoQReset() {
+	
+	if (currentHandle < 0) return;
+
+	if (cinTable[currentHandle].iFile) {
+		Sys_EndStreamedFile(cinTable[currentHandle].iFile);
+		FS_Seek(cinTable[currentHandle].iFile, 0, FS_SEEK_SET);
+		FS_Read (cin.file, 16, cinTable[currentHandle].iFile);
+		RoQ_init();
+		// let the background thread start reading ahead
+		Sys_BeginStreamedFile( cinTable[currentHandle].iFile, 0x10000 );
+		cinTable[currentHandle].status = FMV_LOOPED;
+	}
+}
+
+/******************************************************************************
+*
+* Function:		
+*
+* Description:	
+*
+******************************************************************************/
+
+static void RoQInterrupt(void)
+{
+	byte				*framedata;
+
+	if (currentHandle < 0) return;
+
+	Sys_StreamedRead( cin.file, cinTable[currentHandle].RoQFrameSize+8, 1, cinTable[currentHandle].iFile );
+	if ( cinTable[currentHandle].RoQPlayed >= cinTable[currentHandle].ROQSize ) { 
+		if (cinTable[currentHandle].holdAtEnd==qfalse) {
+			if (cinTable[currentHandle].looping) {
+				RoQReset();
+			} else {
+				cinTable[currentHandle].status = FMV_EOF;
+				if (cinTable[currentHandle].hSFX && !cinTable[currentHandle].looping)
+				{
+					S_CIN_StopSound( cinTable[currentHandle].hSFX );
+				}
+			}
+		} else {
+			cinTable[currentHandle].status = FMV_IDLE;
+		}
+		return; 
+	}
+
+	framedata = cin.file;
+//
+// new frame is ready
+//
+redump:
+	switch(cinTable[currentHandle].roq_id) 
+	{
+		case	ROQ_QUAD_VQ:
+			if ((cinTable[currentHandle].numQuads&1)) {
+				cinTable[currentHandle].normalBuffer0 = cinTable[currentHandle].t[1];
+				RoQPrepMcomp( cinTable[currentHandle].roqF0, cinTable[currentHandle].roqF1 );
+				cinTable[currentHandle].VQ1( (byte *)cin.qStatus[1], framedata);
+				cinTable[currentHandle].buf = 	cin.linbuf + cinTable[currentHandle].screenDelta;
+			} else {
+				cinTable[currentHandle].normalBuffer0 = cinTable[currentHandle].t[0];
+				RoQPrepMcomp( cinTable[currentHandle].roqF0, cinTable[currentHandle].roqF1 );
+				cinTable[currentHandle].VQ0( (byte *)cin.qStatus[0], framedata );
+				cinTable[currentHandle].buf = 	cin.linbuf;
+			}
+			if (cinTable[currentHandle].numQuads == 0) {		// first frame
+				memcpy(cin.linbuf+cinTable[currentHandle].screenDelta, cin.linbuf, cinTable[currentHandle].samplesPerLine*cinTable[currentHandle].ysize);
+			}
+			cinTable[currentHandle].numQuads++;
+			cinTable[currentHandle].dirty = qtrue;
+			break;
+		case	ROQ_CODEBOOK:
+			decodeCodeBook( framedata, (unsigned short)cinTable[currentHandle].roq_flags );
+			break;
+		case	ZA_SOUND_MONO:
+			if (!cinTable[currentHandle].silent) {
+				if (cinTable[currentHandle].numQuads == -1) {
+					S_Update();
+					s_rawend = s_soundtime;
+					RllDecodeMonoToStereo( framedata, cinTable[currentHandle].RoQFrameSize, 0, (unsigned short)cinTable[currentHandle].roq_flags, !!(cinTable[currentHandle].hSFX) );
+				}
+				else
+				{
+					if (cinTable[currentHandle].hSFX) {
+						S_Update();
+					}
+					RllDecodeMonoToStereo( framedata, cinTable[currentHandle].RoQFrameSize, 0, (unsigned short)cinTable[currentHandle].roq_flags, !!(cinTable[currentHandle].hSFX) );
+				}
+			}
+			break;
+		case	ZA_SOUND_STEREO:
+			if (!cinTable[currentHandle].silent) {
+				if (cinTable[currentHandle].numQuads == -1) {
+					S_Update();
+					s_rawend = s_soundtime;
+					RllDecodeStereoToStereo( framedata, cinTable[currentHandle].RoQFrameSize, 0, (unsigned short)cinTable[currentHandle].roq_flags, !!(cinTable[currentHandle].hSFX) );
+				}
+				else
+				{
+					if (cinTable[currentHandle].hSFX) {
+						S_Update();
+					}
+					RllDecodeStereoToStereo( framedata, cinTable[currentHandle].RoQFrameSize, 0, (unsigned short)cinTable[currentHandle].roq_flags, !!(cinTable[currentHandle].hSFX) );
+				}
+			}
+			break;
+		case	ROQ_QUAD_INFO:
+			if (cinTable[currentHandle].numQuads == -1) {
+				readQuadInfo( framedata );
+				setupQuad( 0, 0 );
+				cinTable[currentHandle].startTime = cinTable[currentHandle].lastTime = Sys_Milliseconds()*com_timescale->value;
+			}
+			if (cinTable[currentHandle].numQuads != 1) cinTable[currentHandle].numQuads = 0;
+			break;
+		case	ROQ_PACKET:
+			cinTable[currentHandle].inMemory = cinTable[currentHandle].roq_flags;
+			cinTable[currentHandle].RoQFrameSize = 0;           // for header
+			break;
+		case	ROQ_QUAD_HANG:
+			cinTable[currentHandle].RoQFrameSize = 0;
+			break;
+		case	ROQ_QUAD_JPEG:
+			break;
+		default:
+			cinTable[currentHandle].status = FMV_EOF;
+			break;
+	}	
+//
+// read in next frame data
+//
+	if ( cinTable[currentHandle].RoQPlayed >= cinTable[currentHandle].ROQSize ) { 
+		if (cinTable[currentHandle].holdAtEnd==qfalse) {
+			if (cinTable[currentHandle].looping) {
+				RoQReset();
+			} else {
+				cinTable[currentHandle].status = FMV_EOF;
+			}
+		} else {
+			cinTable[currentHandle].status = FMV_IDLE;
+		}
+		return; 
+	}
+	
+	framedata		 += cinTable[currentHandle].RoQFrameSize;
+	cinTable[currentHandle].roq_id		 = framedata[0] + framedata[1]*256;
+	cinTable[currentHandle].RoQFrameSize = framedata[2] + framedata[3]*256 + framedata[4]*65536;
+	cinTable[currentHandle].roq_flags	 = framedata[6] + framedata[7]*256;
+	cinTable[currentHandle].roqF0		 = (char)framedata[7];
+	cinTable[currentHandle].roqF1		 = (char)framedata[6];
+
+	if (cinTable[currentHandle].RoQFrameSize>65536||cinTable[currentHandle].roq_id==0x1084) {
+		Com_DPrintf("roq_size>65536||roq_id==0x1084\n");
+		cinTable[currentHandle].status = FMV_EOF;
+		if (cinTable[currentHandle].looping) {
+			RoQReset();
+		}
+		return;
+	}
+	if (cinTable[currentHandle].inMemory && (cinTable[currentHandle].status != FMV_EOF)) 
+	{ cinTable[currentHandle].inMemory--; framedata += 8; goto redump; }
+//
+// one more frame hits the dust
+//
+//	assert(cinTable[currentHandle].RoQFrameSize <= 65536);
+//	r = Sys_StreamedRead( cin.file, cinTable[currentHandle].RoQFrameSize+8, 1, cinTable[currentHandle].iFile );
+	cinTable[currentHandle].RoQPlayed	+= cinTable[currentHandle].RoQFrameSize+8;
+}
+
+/******************************************************************************
+*
+* Function:		
+*
+* Description:	
+*
+******************************************************************************/
+
+static void RoQ_init( void )
+{
+
+	cinTable[currentHandle].startTime = cinTable[currentHandle].lastTime = Sys_Milliseconds()*com_timescale->value;
+
+	cinTable[currentHandle].RoQPlayed = 24;
+
+/*	get frame rate */	
+	cinTable[currentHandle].roqFPS	 = cin.file[ 6] + cin.file[ 7]*256;
+	
+	if (!cinTable[currentHandle].roqFPS) cinTable[currentHandle].roqFPS = 30;
+	
+
+	cinTable[currentHandle].numQuads = -1;
+
+	cinTable[currentHandle].roq_id		= cin.file[ 8] + cin.file[ 9]*256;
+	cinTable[currentHandle].RoQFrameSize	= cin.file[10] + cin.file[11]*256 + cin.file[12]*65536;
+	cinTable[currentHandle].roq_flags	= cin.file[14] + cin.file[15]*256;
+
+	if (cinTable[currentHandle].RoQFrameSize > 65536 || !cinTable[currentHandle].RoQFrameSize) { 
+		return;
+	}
+
+	if (cinTable[currentHandle].hSFX)
+	{
+		S_StartLocalSound(cinTable[currentHandle].hSFX, CHAN_AUTO);
+	}
+}
+
+/******************************************************************************
+*
+* Function:		
+*
+* Description:	
+*
+******************************************************************************/
+
+static void RoQShutdown( void ) {
+	const char *s;
+	
+	if (!cinTable[currentHandle].buf) {
+		if (cinTable[currentHandle].iFile) {
+//			assert( 0 && "ROQ handle leak-prevention WAS needed!");
+			Sys_EndStreamedFile( cinTable[currentHandle].iFile );
+			FS_FCloseFile( cinTable[currentHandle].iFile );
+			cinTable[currentHandle].iFile = 0;
+			if (cinTable[currentHandle].hSFX) {
+				S_CIN_StopSound( cinTable[currentHandle].hSFX );
+			}
+		}
+		return;
+	}
+
+	if (cinTable[currentHandle].status == FMV_IDLE) {
+		return;
+	}
+
+	Com_DPrintf("finished cinematic\n");
+	cinTable[currentHandle].status = FMV_IDLE;
+
+	if (cinTable[currentHandle].iFile) {
+		Sys_EndStreamedFile( cinTable[currentHandle].iFile );
+		FS_FCloseFile( cinTable[currentHandle].iFile );
+		cinTable[currentHandle].iFile = 0;
+		if (cinTable[currentHandle].hSFX) {
+			S_CIN_StopSound( cinTable[currentHandle].hSFX );
+		}
+	}
+
+	if (cinTable[currentHandle].alterGameState) {
+		cls.state = CA_DISCONNECTED;
+		// we can't just do a vstr nextmap, because
+		// if we are aborting the intro cinematic with
+		// a devmap command, nextmap would be valid by
+		// the time it was referenced
+		s = Cvar_VariableString( "nextmap" );
+		if ( s[0] ) {
+			Cbuf_ExecuteText( EXEC_APPEND, va("%s\n", s) );
+			Cvar_Set( "nextmap", "" );
+		}
+		CL_handle = -1;
+	}
+	cinTable[currentHandle].fileName[0] = 0;
+	currentHandle = -1;
+}
+
+e_status CIN_StopCinematic(int handle) {
+	
+	if (handle < 0 || handle>= MAX_VIDEO_HANDLES || cinTable[handle].status == FMV_EOF) return FMV_EOF;
+	currentHandle = handle;
+
+	Com_DPrintf("trFMV::stop(), closing %s\n", cinTable[currentHandle].fileName);
+
+	if (!cinTable[currentHandle].buf) {
+		if (cinTable[currentHandle].iFile) {
+//			assert( 0 && "ROQ handle leak-prevention WAS needed!");
+			Sys_EndStreamedFile( cinTable[currentHandle].iFile );
+			FS_FCloseFile( cinTable[currentHandle].iFile );
+			cinTable[currentHandle].iFile = 0;
+			cinTable[currentHandle].fileName[0] = 0;
+			if (cinTable[currentHandle].hSFX) {
+				S_CIN_StopSound( cinTable[currentHandle].hSFX );
+			}
+		}
+		return FMV_EOF;
+	}
+
+	if (cinTable[currentHandle].alterGameState) {
+		if ( cls.state != CA_CINEMATIC ) {
+			return cinTable[currentHandle].status;
+		}
+	}
+	cinTable[currentHandle].status = FMV_EOF;
+	RoQShutdown();
+
+	return FMV_EOF;
+}
+
+/*
+==================
+SCR_RunCinematic
+
+Fetch and decompress the pending frame
+==================
+*/
+
+
+e_status CIN_RunCinematic (int handle)
+{
+    // bk001204 - init
+	unsigned int start = 0;
+	int			 thisTime = 0;
+
+	if (handle < 0 || handle>= MAX_VIDEO_HANDLES || cinTable[handle].status == FMV_EOF) 
+	{
+		return FMV_EOF;
+	}
+
+	if (currentHandle != handle) {
+		currentHandle = handle;
+		cinTable[currentHandle].status = FMV_EOF;
+		RoQReset();
+	}
+
+	if (cinTable[handle].playonwalls < -1)
+	{
+		return cinTable[handle].status;
+	}
+
+	currentHandle = handle;
+
+	if (cinTable[currentHandle].alterGameState) {
+		if ( cls.state != CA_CINEMATIC ) {
+			return cinTable[currentHandle].status;
+		}
+	}
+
+	if (cinTable[currentHandle].status == FMV_IDLE) {
+		return cinTable[currentHandle].status;
+	}
+
+	thisTime = Sys_Milliseconds()*com_timescale->value;
+	if (cinTable[currentHandle].shader && (abs(thisTime - cinTable[currentHandle].lastTime))>100) {
+		cinTable[currentHandle].startTime += thisTime - cinTable[currentHandle].lastTime;
+	}
+	cinTable[currentHandle].tfps = ((((Sys_Milliseconds()*com_timescale->value) - cinTable[currentHandle].startTime)*cinTable[currentHandle].roqFPS)/1000);
+
+	start = cinTable[currentHandle].startTime;
+	while(  (cinTable[currentHandle].tfps != cinTable[currentHandle].numQuads)
+		&& (cinTable[currentHandle].status == FMV_PLAY) ) 
+	{
+		RoQInterrupt();
+		if (start != cinTable[currentHandle].startTime) {
+		  cinTable[currentHandle].tfps = ((((Sys_Milliseconds()*com_timescale->value)
+							  - cinTable[currentHandle].startTime)*cinTable[currentHandle].roqFPS)/1000);
+			start = cinTable[currentHandle].startTime;
+		}
+	}
+
+	cinTable[currentHandle].lastTime = thisTime;
+
+	if (cinTable[currentHandle].status == FMV_LOOPED) {
+		cinTable[currentHandle].status = FMV_PLAY;
+	}
+
+	if (cinTable[currentHandle].status == FMV_EOF) {
+	  if (cinTable[currentHandle].looping) {
+		RoQReset();
+	  } else {
+		RoQShutdown();
+		return FMV_IDLE;	//currentHandle is -1 now, so it can't fall through to the default return!
+	  }
+	}
+
+	return cinTable[currentHandle].status;
+}
+
+void		Menus_CloseAll(void);
+void		UI_Cursor_Show(qboolean flag);
+
+/*
+==================
+CL_PlayCinematic
+
+==================
+*/
+int CIN_PlayCinematic( const char *arg, int x, int y, int w, int h, int systemBits, const char *psAudioFile /* = NULL */ )
+{
+	unsigned short RoQID;
+	char	name[MAX_OSPATH];
+	int		i;
+
+	if (strstr(arg, "/") == NULL && strstr(arg, "\\") == NULL) {
+		Com_sprintf (name, sizeof(name), "video/%s", arg);
+	} else {
+		Com_sprintf (name, sizeof(name), "%s", arg);
+	}
+	COM_DefaultExtension(name,sizeof(name),".roq");
+
+	if (!(systemBits & CIN_system)) {
+		for ( i = 0 ; i < MAX_VIDEO_HANDLES ; i++ ) {
+			if (!strcmp(cinTable[i].fileName, name) ) {
+				return i;
+			}
+		}
+	}
+
+	Com_DPrintf("SCR_PlayCinematic( %s )\n", arg);
+
+	memset(&cin, 0, sizeof(cinematics_t) );
+	currentHandle = CIN_HandleForVideo();
+	
+	strcpy(cinTable[currentHandle].fileName, name);
+
+	cinTable[currentHandle].ROQSize = 0;
+	cinTable[currentHandle].ROQSize = FS_FOpenFileRead (cinTable[currentHandle].fileName, &cinTable[currentHandle].iFile, qtrue);
+
+	if (cinTable[currentHandle].ROQSize<=0) {
+		Com_Printf(S_COLOR_RED"ERROR: playCinematic: %s not found!\n", arg);
+		cinTable[currentHandle].fileName[0] = 0;
+		return -1;
+	}
+
+	CIN_SetExtents(currentHandle, x, y, w, h);
+	CIN_SetLooping(currentHandle, (systemBits & CIN_loop)!=0);
+
+	cinTable[currentHandle].CIN_HEIGHT = DEFAULT_CIN_HEIGHT;
+	cinTable[currentHandle].CIN_WIDTH  =  DEFAULT_CIN_WIDTH;
+	cinTable[currentHandle].holdAtEnd = (systemBits & CIN_hold) != 0;
+	cinTable[currentHandle].alterGameState = (systemBits & CIN_system) != 0;
+	cinTable[currentHandle].playonwalls = 1;
+	cinTable[currentHandle].silent = (systemBits & CIN_silent) != 0;
+	cinTable[currentHandle].shader = (systemBits & CIN_shader) != 0;
+	if (psAudioFile)
+	{
+		cinTable[currentHandle].hSFX = S_RegisterSound(psAudioFile);
+	}
+	else
+	{
+		cinTable[currentHandle].hSFX = 0;
+	}
+	cinTable[currentHandle].hCRAWLTEXT = 0;
+
+	if (cinTable[currentHandle].alterGameState) 
+	{
+		// close the menu
+// TA...
+//		if ( uivm ) 
+//		{
+//			VM_Call( uivm, UI_SET_ACTIVE_MENU, UIMENU_NONE );
+//		}
+// CHC:
+		Con_Close();
+		if (cls.uiStarted)
+		{
+			UI_Cursor_Show(qfalse);
+			Menus_CloseAll();
+		}
+	}
+	else 
+	{
+		cinTable[currentHandle].playonwalls = cl_ingameVideo->integer;
+	}
+
+	initRoQ();
+					
+	FS_Read (cin.file, 16, cinTable[currentHandle].iFile);
+
+	RoQID = (unsigned short)(cin.file[0]) + (unsigned short)(cin.file[1])*256;
+	if (RoQID == 0x1084)
+	{
+		RoQ_init();
+//		FS_Read (cin.file, cinTable[currentHandle].RoQFrameSize+8, cinTable[currentHandle].iFile);
+		// let the background thread start reading ahead
+		Sys_BeginStreamedFile( cinTable[currentHandle].iFile, 0x10000 );
+
+		cinTable[currentHandle].status = FMV_PLAY;
+		Com_DPrintf("trFMV::play(), playing %s\n", arg);
+
+		if (cinTable[currentHandle].alterGameState) {
+			cls.state = CA_CINEMATIC;
+		}
+		
+		Con_Close();
+
+		s_rawend = s_soundtime;
+
+		return currentHandle;
+	}
+	Com_DPrintf("trFMV::play(), invalid RoQ ID\n");
+
+	RoQShutdown();
+	return -1;
+}
+
+void CIN_SetExtents (int handle, int x, int y, int w, int h) {
+	if (handle < 0 || handle>= MAX_VIDEO_HANDLES || cinTable[handle].status == FMV_EOF) return;
+	cinTable[handle].xpos = x;
+	cinTable[handle].ypos = y;
+	cinTable[handle].width = w;
+	cinTable[handle].height = h;
+	cinTable[handle].dirty = qtrue;
+}
+
+void CIN_SetLooping(int handle, qboolean loop) {
+	if (handle < 0 || handle>= MAX_VIDEO_HANDLES || cinTable[handle].status == FMV_EOF) return;
+	cinTable[handle].looping = loop;
+}
+
+// Text crawl defines
+#define TC_PLANE_WIDTH	250
+#define TC_PLANE_NEAR	90
+#define TC_PLANE_FAR	715
+#define TC_PLANE_TOP	0
+#define TC_PLANE_BOTTOM	1100
+
+#define TC_DELAY 9000
+#define TC_STOPTIME 81000
+static void CIN_AddTextCrawl()
+{
+	refdef_t	refdef;
+	polyVert_t	verts[4];
+
+	// Set up refdef
+	memset( &refdef, 0, sizeof( refdef ));
+
+	refdef.rdflags = RDF_NOWORLDMODEL;
+	AxisClear( refdef.viewaxis );
+
+	refdef.fov_x = 130;
+	refdef.fov_y = 130;
+
+	refdef.x = 0;
+	refdef.y = -50;
+	refdef.width = cls.glconfig.vidWidth;
+	refdef.height = cls.glconfig.vidHeight * 2; // deliberately extend off the bottom of the screen
+
+	// use to set shaderTime for scrolling shaders
+	refdef.time = 0; 
+
+	// Set up the poly verts
+	float fadeDown = 1.0;
+	if (cls.realtime-CL_iPlaybackStartTime >= (TC_STOPTIME-2500))
+	{
+		fadeDown = (TC_STOPTIME - (cls.realtime-CL_iPlaybackStartTime))/ 2480.0f;
+		if (fadeDown < 0)
+		{
+			fadeDown = 0;
+		}
+		if (fadeDown > 1)
+		{
+			fadeDown = 1;
+		}
+	}
+	for ( int i = 0; i < 4; i++ )
+	{
+		verts[i].modulate[0] = 255*fadeDown; // gold color?
+		verts[i].modulate[1] = 235*fadeDown;
+		verts[i].modulate[2] = 127*fadeDown;
+		verts[i].modulate[3] = 255*fadeDown;
+	}
+
+	_VectorScale( verts[2].modulate, 0.1f, verts[2].modulate ); // darken at the top??
+	_VectorScale( verts[3].modulate, 0.1f, verts[3].modulate );
+
+#define TIMEOFFSET  +(cls.realtime-CL_iPlaybackStartTime-TC_DELAY)*0.000015f -1
+	VectorSet( verts[0].xyz, TC_PLANE_NEAR, -TC_PLANE_WIDTH, TC_PLANE_TOP );
+	verts[0].st[0] = 1;
+	verts[0].st[1] = 1 TIMEOFFSET;
+
+	VectorSet( verts[1].xyz, TC_PLANE_NEAR, TC_PLANE_WIDTH, TC_PLANE_TOP );
+	verts[1].st[0] = 0;
+	verts[1].st[1] = 1 TIMEOFFSET;
+
+	VectorSet( verts[2].xyz, TC_PLANE_FAR, TC_PLANE_WIDTH, TC_PLANE_BOTTOM );
+	verts[2].st[0] = 0;
+	verts[2].st[1] = 0 TIMEOFFSET;
+
+	VectorSet( verts[3].xyz, TC_PLANE_FAR, -TC_PLANE_WIDTH, TC_PLANE_BOTTOM );
+	verts[3].st[0] = 1;
+	verts[3].st[1] = 0 TIMEOFFSET;
+
+	// render it out
+	re.ClearScene();
+	re.AddPolyToScene( cinTable[CL_handle].hCRAWLTEXT, 4, verts );
+	re.RenderScene( &refdef );
+
+	//time's up
+	if (cls.realtime-CL_iPlaybackStartTime >= TC_STOPTIME)
+	{
+//		cinTable[currentHandle].holdAtEnd = qfalse;
+		cinTable[CL_handle].status = FMV_EOF;
+		RoQShutdown();
+		SCR_StopCinematic();	// change ROQ from FMV_IDLE to FMV_EOF, and clear some other vars
+	}
+}
+
+/*
+==================
+SCR_DrawCinematic
+
+==================
+*/
+void CIN_DrawCinematic (int handle) {
+	float	x, y, w, h;
+
+	if (handle < 0 || handle>= MAX_VIDEO_HANDLES || cinTable[handle].status == FMV_EOF) {
+		return;
+	}
+
+	if (!cinTable[handle].buf) {
+		return;
+	}
+
+	x = cinTable[handle].xpos;
+	y = cinTable[handle].ypos;
+	w = cinTable[handle].width;
+	h = cinTable[handle].height;
+
+	if (cinTable[handle].dirty && (cinTable[handle].CIN_WIDTH != cinTable[handle].drawX || cinTable[handle].CIN_HEIGHT != cinTable[handle].drawY)) {
+		int ix, iy, *buf2, *buf3, xm, ym;
+
+		xm = cinTable[handle].CIN_WIDTH/256;
+		ym = cinTable[handle].CIN_HEIGHT/256;
+
+		buf3 = (int*)cinTable[handle].buf;
+		buf2 = (int*)Z_Malloc( 256*256*4, TAG_TEMP_WORKSPACE, qfalse );
+		for (iy = 0; iy<256; iy++) {
+			for (ix = 0; ix<256; ix++) {
+				buf2[(iy<<8)+ix] = buf3[((iy*ym)*cinTable[handle].CIN_WIDTH) + (ix*xm)];
+			}
+		}
+		re.DrawStretchRaw( x, y, w, h, 256, 256, (byte *)buf2, handle, qtrue);
+		cinTable[handle].dirty = qfalse;
+		Z_Free(buf2);
+
+		return;
+	}
+
+	re.DrawStretchRaw( x, y, w, h, cinTable[handle].drawX, cinTable[handle].drawY, cinTable[handle].buf, handle, cinTable[handle].dirty);
+	cinTable[handle].dirty = qfalse;
+}
+
+// external vars so I can check if the game is setup enough that I can play the intro video...
+//
+extern qboolean	com_fullyInitialized;
+extern qboolean s_soundStarted, s_soundMuted;
+//
+// ... and if the app isn't ready yet (which should only apply for the intro video), then I use these...
+//
+static char	 sPendingCinematic_Arg	[256]={0};
+static char	 sPendingCinematic_s	[256]={0};
+static qboolean gbPendingCinematic = qfalse;
+//
+// This stuff is for EF1-type ingame cinematics...
+//
+static qboolean qbPlayingInGameCinematic = qfalse;
+static qboolean qbInGameCinematicOnStandBy = qfalse;
+static char	 sInGameCinematicStandingBy[MAX_QPATH];
+
+
+
+static qboolean CIN_HardwareReadyToPlayVideos(void)
+{
+	if (com_fullyInitialized && cls.rendererStarted && 
+								cls.soundStarted	&& 
+								cls.soundRegistered
+		)
+	{
+		return qtrue;
+	}
+
+	return qfalse;
+}
+
+
+static void PlayCinematic(const char *arg, const char *s, qboolean qbInGame)
+{
+	qboolean bFailed = qfalse;
+
+	Cvar_Set( "timescale", "1" );			// jic we were skipping a scripted cinematic, return to normal after playing video
+	Cvar_Set( "skippingCinematic", "0" );	// "" 
+
+	qbInGameCinematicOnStandBy = qfalse;
+
+	int bits = qbInGame?0:CIN_system;
+
+	Com_DPrintf("CL_PlayCinematic_f\n");
+
+	char sTemp[1024];
+	if (strstr(arg, "/") == NULL && strstr(arg, "\\") == NULL) {
+		Com_sprintf (sTemp, sizeof(sTemp), "video/%s", arg);
+	} else {
+		Com_sprintf (sTemp, sizeof(sTemp), "%s", arg);
+	}	
+	COM_DefaultExtension(sTemp,sizeof(sTemp),".roq");
+	arg = &sTemp[0];
+
+	extern qboolean S_FileExists( const char *psFilename );
+	if (S_FileExists( arg ))
+	{
+		SCR_StopCinematic();
+		// command-line hack to avoid problems when playing intro video before app is fully setup...
+		//
+		if (!CIN_HardwareReadyToPlayVideos())	
+		{
+			strcpy(sPendingCinematic_Arg,arg);
+			strcpy(sPendingCinematic_s , (s&&s[0])?s:"");
+			gbPendingCinematic = qtrue;
+			return;
+		}
+
+		qbPlayingInGameCinematic = qbInGame;
+
+		if ((s && s[0] == '1') || Q_stricmp(arg,"video/end.roq")==0) {
+			bits |= CIN_hold;
+		}
+		if (s && s[0] == '2') {
+			bits |= CIN_loop;
+		}
+
+		S_StopAllSounds ();
+
+
+		////////////////////////////////////////////////////////////////////
+		//
+		// work out associated audio-overlay file, if any...
+		//
+		extern cvar_t *s_language;
+		qboolean	bIsForeign	= s_language && stricmp(s_language->string,"english") && stricmp(s_language->string,"");
+		LPCSTR		psAudioFile	= NULL;
+		qhandle_t	hCrawl = 0;
+		if (!stricmp(arg,"video/jk0101_sw.roq"))
+		{
+			psAudioFile = "music/cinematic_1";
+			if ( Cvar_VariableIntegerValue("com_demo") )
+			{
+				hCrawl = re.RegisterShaderNoMip( "menu/video/tc_demo" );//demo version of text crawl
+			}
+			else
+			{
+				hCrawl = re.RegisterShaderNoMip( va("menu/video/tc_%s",se_language->string) );
+				if (!hCrawl)
+				{
+					hCrawl = re.RegisterShaderNoMip( "menu/video/tc_english" );//failed, so go back to english
+				}
+			}
+			bits |= CIN_hold;
+		}
+		else
+		if (bIsForeign)
+		{
+			if (!stricmp(arg,"video/jk05.roq"))
+			{
+				psAudioFile = "sound/chars/video/cinematic_5";
+				bits |= CIN_silent;	// knock out existing english track
+			}
+			else
+			if (!stricmp(arg,"video/jk06.roq"))
+			{
+				psAudioFile = "sound/chars/video/cinematic_6";
+				bits |= CIN_silent;	// knock out existing english track
+			}
+		}
+		//
+		////////////////////////////////////////////////////////////////////
+
+		CL_handle = CIN_PlayCinematic( arg, 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, bits, psAudioFile );
+		if (CL_handle >= 0) 
+		{
+			cinTable[CL_handle].hCRAWLTEXT = hCrawl;
+			do 
+			{
+				SCR_RunCinematic();
+			} 
+			while (cinTable[currentHandle].buf == NULL && cinTable[currentHandle].status == FMV_PLAY);		// wait for first frame (load codebook and sound)
+		
+			if (qbInGame)
+			{
+				Cvar_SetValue( "cl_paused", 1);	// remove-menu call will have unpaused us, so we sometimes need to re-pause
+			}
+
+			CL_iPlaybackStartTime = cls.realtime;	// special use to avoid accidentally skipping ingame videos via fast-firing
+		}
+		else
+		{
+			// failed to open video...
+			//
+			bFailed = qtrue;
+		}
+	}
+	else
+	{
+		// failed to open video...
+		//
+		bFailed = qtrue;
+	}
+
+	if (bFailed)
+	{
+		Com_Printf(S_COLOR_RED "PlayCinematic(): Failed to open \"%s\"\n",arg);
+		//S_RestartMusic();	//restart the level music
+		SCR_StopCinematic();	// I know this seems pointless, but it clears a bunch of vars as well
+	}
+	else
+	{
+		// this doesn't work for now...
+		//
+//		if (cls.state == CA_ACTIVE){
+//			re.InitDissolve(qfalse);	// so we get a dissolve between previous screen image and cinematic
+//		}
+	}
+}
+
+
+qboolean CL_CheckPendingCinematic(void)
+{
+	if ( gbPendingCinematic && CIN_HardwareReadyToPlayVideos() )
+	{
+		gbPendingCinematic = qfalse;	// BEFORE next line, or we get recursion
+		PlayCinematic(sPendingCinematic_Arg,sPendingCinematic_s[0]?sPendingCinematic_s:NULL,false);		
+		return qtrue;
+	}
+	return qfalse;
+}
+
+
+void CL_PlayCinematic_f(void) 
+{
+	char	*arg, *s;
+	
+	arg = Cmd_Argv( 1 );
+	s = Cmd_Argv(2);
+	PlayCinematic(arg,s,qfalse);
+}
+
+void CL_PlayInGameCinematic_f(void)
+{
+	if (cls.state == CA_ACTIVE)
+	{
+		char *arg = Cmd_Argv( 1 );
+		PlayCinematic(arg,NULL,qtrue);
+	}
+	else
+	{
+		qbInGameCinematicOnStandBy = qtrue;
+		strcpy(sInGameCinematicStandingBy,Cmd_Argv(1));
+	}
+}
+
+
+// Externally-called only, and only if cls.state == CA_CINEMATIC (or CL_IsRunningInGameCinematic() == true now)
+//
+void SCR_DrawCinematic (void) 
+{
+	if (CL_InGameCinematicOnStandBy())
+	{
+		PlayCinematic(sInGameCinematicStandingBy,NULL,qtrue);		
+	}
+
+	if (CL_handle >= 0 && CL_handle < MAX_VIDEO_HANDLES) {
+		CIN_DrawCinematic(CL_handle);
+		if (cinTable[CL_handle].hCRAWLTEXT && (cls.realtime - CL_iPlaybackStartTime >= TC_DELAY))
+		{
+			CIN_AddTextCrawl();
+		}
+	}
+}
+
+void SCR_RunCinematic (void)
+{
+	CL_CheckPendingCinematic();
+
+	if (CL_handle >= 0 && CL_handle < MAX_VIDEO_HANDLES) {
+		e_status Status = CIN_RunCinematic(CL_handle);
+		
+		if (CL_IsRunningInGameCinematic() && Status == FMV_IDLE  && !cinTable[CL_handle].holdAtEnd)
+		{
+			SCR_StopCinematic();	// change ROQ from FMV_IDLE to FMV_EOF, and clear some other vars
+		}
+	}
+}
+
+void SCR_StopCinematic( qboolean bAllowRefusal /* = qfalse */ )
+{
+	if (bAllowRefusal)
+	{
+		if ( (CL_handle >= 0 && CL_handle < MAX_VIDEO_HANDLES)
+			&&
+			cls.realtime < CL_iPlaybackStartTime + 1200	// 1.2 seconds have to have elapsed
+			)
+		{
+			return;
+		}
+	}
+
+	if ( CL_IsRunningInGameCinematic())
+	{
+		Com_DPrintf("In-game Cinematic Stopped\n");
+	}
+
+	if (CL_handle >= 0 && CL_handle < MAX_VIDEO_HANDLES) {
+		CIN_StopCinematic(CL_handle);
+		S_StopAllSounds ();
+		CL_handle = -1;
+		if (CL_IsRunningInGameCinematic()){
+			re.InitDissolve(qfalse);	// dissolve from cinematic to underlying ingame
+		}
+	}
+
+	if (cls.state == CA_CINEMATIC)
+	{
+		Com_DPrintf("Cinematic Stopped\n");
+		cls.state =  CA_DISCONNECTED;
+	}
+
+	qbPlayingInGameCinematic = qfalse;
+	qbInGameCinematicOnStandBy = qfalse;
+	sInGameCinematicStandingBy[0]=0;
+	Cvar_SetValue( "cl_paused", 0 );
+	if (cls.state != CA_DISCONNECTED)	// cut down on needless calls to music code
+	{
+		S_RestartMusic();	//restart the level music
+	}
+}
+
+
+void CIN_UploadCinematic(int handle) {
+	if (handle >= 0 && handle < MAX_VIDEO_HANDLES) {
+		if (!cinTable[handle].buf) {
+			return;
+		}
+		if (cinTable[handle].playonwalls <= 0 && cinTable[handle].dirty) {
+			if (cinTable[handle].playonwalls == 0) {
+				cinTable[handle].playonwalls = -1;
+			} else {
+				if (cinTable[handle].playonwalls == -1) {
+					cinTable[handle].playonwalls = -2;
+				} else {
+					cinTable[handle].dirty = qfalse;
+				}
+			}
+		}
+		re.UploadCinematic( cinTable[handle].drawX, cinTable[handle].drawY, cinTable[handle].buf, handle, cinTable[handle].dirty);
+		if (cl_ingameVideo->integer == 0 && cinTable[handle].playonwalls == 1) {
+			cinTable[handle].playonwalls--;
+		}
+	}
+	else
+	{
+		// useful breakpoint
+//		int z=1;
+	}
+}
+
+
+qboolean CL_IsRunningInGameCinematic(void)
+{
+	return qbPlayingInGameCinematic;
+}
+
+qboolean CL_InGameCinematicOnStandBy(void)
+{
+	return qbInGameCinematicOnStandBy;
+}
+
+
diff --git a/code/client/cl_cin_console.cpp b/code/client/cl_cin_console.cpp
new file mode 100644
index 0000000..6ec28b0
--- /dev/null
+++ b/code/client/cl_cin_console.cpp
@@ -0,0 +1,413 @@
+
+/*****************************************************************************
+ * name:		cl_cin_console.cpp
+ *
+ * desc:		video and cinematic playback interface for Xbox (using Bink)
+ *
+ *****************************************************************************/
+
+#include "client.h"
+#include "../win32/win_local.h"
+#include "../win32/win_input.h"
+#include "BinkVideo.h"
+
+#define XBOX_VIDEO_PATH "d:\\base\\video\\"
+
+BinkVideo bVideo;	// bink video object
+connstate_t	previousState = CA_UNINITIALIZED;	// previous cinematic state
+
+struct CinematicData
+{
+	char	filename[MAX_OSPATH];	// No path, no extension
+	int 	x, y, w, h;				// Dimensions
+	int		bits;					// Flags (loop, silent, shader)
+};
+
+// We have a fixed lookup table of all cinematics that can be played
+// Video handles are just indices into the array. An entry is not
+// considered initialized until its width is nonzero
+CinematicData cinFiles[] = {
+	// Opening logos
+	{ "logos", 0, 0, 0, 0, 0 },
+
+	// Planet shaders
+	{ "cos", 0, 0, 0, 0, 0 },
+	{ "bakura", 0, 0, 0, 0, 0 },
+	{ "blenjeel", 0, 0, 0, 0, 0 },
+	{ "chandrila", 0, 0, 0, 0, 0 },
+	{ "core", 0, 0, 0, 0, 0 },
+	{ "ast", 0, 0, 0, 0, 0 },
+	{ "dosunn", 0, 0, 0, 0, 0 },
+	{ "krildor", 0, 0, 0, 0, 0 },
+	{ "narkreeta", 0, 0, 0, 0, 0 },
+	{ "ordman", 0, 0, 0, 0, 0 },
+	{ "tanaab", 0, 0, 0, 0, 0 },
+	{ "tatooine", 0, 0, 0, 0, 0 },
+	{ "yalara", 0, 0, 0, 0, 0 },
+	{ "zonju", 0, 0, 0, 0, 0 },
+
+	// Others
+//	{ "jk1", 0, 0, 0, 0, 0 },
+//	{ "jk2", 0, 0, 0, 0, 0 },
+//	{ "jk3", 0, 0, 0, 0, 0 },
+//	{ "jk4", 0, 0, 0, 0, 0 },
+//	{ "jk5", 0, 0, 0, 0, 0 },
+};
+
+const int cinNumFiles = sizeof(cinFiles) / sizeof(cinFiles[0]);
+static int currentHandle = -1;
+
+/********
+CIN_CloseAllVideos
+Stops all currently running videos
+*********/
+void CIN_CloseAllVideos(void)
+{
+	// Stop the current bink video
+	bVideo.Stop();
+	currentHandle = -1;
+}
+
+/********
+CIN_StopCinematic
+
+handle	- Not used
+return	- FMV status
+
+Stops the current cinematic
+*********/
+e_status CIN_StopCinematic(int handle)
+{
+	assert( handle == currentHandle );
+	currentHandle = -1;
+
+	if(previousState != CA_UNINITIALIZED)
+	{
+		cls.state = previousState;
+		previousState = CA_UNINITIALIZED;
+	}
+	if(bVideo.GetStatus() != NS_BV_STOPPED)
+	{
+		bVideo.Stop();
+	}
+	return FMV_EOF;
+}
+
+/********
+CIN_RunCinematic
+
+handle	- Ensure that the supplied cinematic is the one running
+return	- FMV status
+
+Fetch and decompress the pending frame
+*********/
+e_status CIN_RunCinematic (int handle)
+{
+	if (handle < 0 || handle >= cinNumFiles || !cinFiles[handle].w)
+	{
+		assert( 0 );
+		return FMV_EOF;
+	}
+
+	// If we weren't playing a movie, or playing the wrong one - start up
+	if (handle != currentHandle)
+	{
+		CIN_StopCinematic(currentHandle);
+		if (!bVideo.Start(
+					va(XBOX_VIDEO_PATH "%s.bik", cinFiles[handle].filename),
+					cinFiles[handle].x, cinFiles[handle].y,
+					cinFiles[handle].w, cinFiles[handle].h))
+		{
+			return FMV_EOF;
+		}
+
+		if (cinFiles[handle].bits & CIN_loop)
+		{
+			bVideo.SetLooping(true);
+		}
+		else
+		{
+			bVideo.SetLooping(false);
+		}
+
+		if (cinFiles[handle].bits & CIN_silent)
+		{
+			bVideo.SetMasterVolume(0);
+		}
+		else
+		{
+			bVideo.SetMasterVolume(32768);	// Default Bink volume
+		}
+
+		if (!(cinFiles[handle].bits & CIN_shader))
+		{
+			previousState = cls.state;
+			cls.state = CA_CINEMATIC;
+		}
+
+		currentHandle = handle;
+	}
+
+	// Normal case does nothing here
+	if(bVideo.GetStatus() == NS_BV_STOPPED)
+	{
+		return FMV_EOF;
+	}
+	else
+	{
+		return FMV_PLAY;
+	}
+}
+
+/********
+CIN_PlayCinematic
+
+arg0	- filename of bink video
+xpos	- x origin
+ypos	- y origin
+width	- width of the movie window
+height	- height of the movie window
+bits	- CIN flags
+psAudioFile	- audio file for movie (not used)
+
+Starts playing the given bink video file
+*********/
+#ifdef _JK2MP
+int CIN_PlayCinematic( const char *arg0, int xpos, int ypos, int width, int height, int bits)
+#else
+int CIN_PlayCinematic( const char *arg0, int xpos, int ypos, int width, int height, int bits, const char *psAudioFile /* = NULL */)
+#endif
+{
+//	char	name[MAX_OSPATH];
+	char	arg[MAX_OSPATH];
+	char*	nameonly;
+	int		handle;
+
+	// get a local copy of the name
+	strcpy(arg,arg0);
+
+	// remove path, find in list
+	nameonly = COM_SkipPath(arg);
+	for (handle = 0; handle < cinNumFiles; ++handle)
+	{
+		if (!Q_stricmp(cinFiles[handle].filename, nameonly))
+			break;
+	}
+
+	// Don't have the requested movie in our table?
+	if (handle == cinNumFiles)
+	{
+		Com_Printf( "ERROR: Movie file %s not found!\n", nameonly );
+		return -1;
+	}
+
+	// Store off information about the movie in the right place. Don't
+	// actually play them movie, CIN_RunCinematic takes care of that.
+	cinFiles[handle].x = xpos;
+	cinFiles[handle].y = ypos;
+	cinFiles[handle].w = width;
+	cinFiles[handle].h = height;
+	cinFiles[handle].bits = bits;
+	currentHandle = -1;
+	return handle;
+}
+
+/*********
+CIN_SetExtents
+
+handle	- handle to a video (not used)
+x		- x origin for window
+y		- y origin for window
+w		- width for window
+h		- height for window
+*********/
+void CIN_SetExtents (int handle, int x, int y, int w, int h)
+{
+	if (handle < 0 || handle >= cinNumFiles)
+		return;
+
+	cinFiles[handle].x = x;
+	cinFiles[handle].y = y;
+	cinFiles[handle].w = w;
+	cinFiles[handle].h = h;
+
+	if (handle == currentHandle)
+		bVideo.SetExtents(x,y,w,h);
+}
+
+/********
+CIN_DrawCinematic
+
+handle	- handle to a video (not used)
+
+Updates the current frame of the current video
+*********/
+void CIN_DrawCinematic (int handle)
+{
+	assert( handle == currentHandle );
+
+	bVideo.Run();
+}
+
+/*********
+SCR_DrawCinematic
+*********/
+void SCR_DrawCinematic (void)
+{
+	CIN_DrawCinematic(currentHandle);
+}
+/*********
+SCR_RunCinematic
+*********/
+void SCR_RunCinematic (void)
+{
+	// This is called every frame, even when we're not playing a movie
+	if (currentHandle > 0 && currentHandle < cinNumFiles)
+		CIN_RunCinematic(currentHandle);
+}
+
+/*********
+SCR_StopCinematic
+*********/
+#ifdef _JK2MP
+void SCR_StopCinematic(void)
+#else
+void SCR_StopCinematic(qboolean bAllowRefusal /* = qfalse */)
+#endif
+{
+	CIN_StopCinematic(currentHandle);
+}
+
+/*********
+CIN_UploadCinematic
+
+handle		- (not used)
+
+This function can be used to render a frame of a movie, if
+it needs to be done outside of CA_CINEMATIC. For example,
+a menu background or wall texture.
+*********/
+void CIN_UploadCinematic(int handle)
+{
+	int w, h;
+	byte* data;
+
+	assert( handle == currentHandle );
+
+	if(!bVideo.Ready()) {
+		return;
+	}
+	
+	w		= bVideo.GetBinkWidth();
+	h		= bVideo.GetBinkHeight();
+	data	= (byte*)bVideo.GetBinkData();
+
+	// handle is actually being used to pick from scratchImages in
+	// this function - we only have two on Xbox, let's just use one.
+	//re.UploadCinematic( w, h, data, handle, 1);
+	re.UploadCinematic( w, h, data, 0, 1);
+}
+
+/*********
+CIN_PlayAllFrames
+
+arg				- bink video filename
+x				- x origin for movie
+y				- y origin for movie
+w				- width of the movie
+h				- height of the movie
+systemBits		- bit rate for movie
+keyBreakAllowed	- if true, button press will end playback
+
+Plays the target movie in full
+*********/
+bool CIN_PlayAllFrames( const char *arg, int x, int y, int w, int h, int systemBits, bool keyBreakAllowed )
+{
+	bool retval;
+	Key_ClearStates();
+
+#ifdef _JK2MP
+	int Handle = CIN_PlayCinematic(arg, x, y, w, h, systemBits);
+#else
+	int Handle = CIN_PlayCinematic(arg, x, y, w, h, systemBits, NULL);
+#endif
+	if (Handle != -1)
+	{
+		while (CIN_RunCinematic(Handle) == FMV_PLAY && !(keyBreakAllowed && kg.anykeydown))
+		{
+			SCR_UpdateScreen	();
+			IN_Frame			();
+			Com_EventLoop		();
+		}
+#ifdef _XBOX
+		while (CIN_RunCinematic(Handle) == FMV_PLAY && !(keyBreakAllowed && !kg.anykeydown))
+		{
+			SCR_UpdateScreen	();
+			IN_Frame			();
+			Com_EventLoop		();
+		}
+#endif
+		CIN_StopCinematic(Handle);
+	}
+
+	retval =(keyBreakAllowed && kg.anykeydown);
+	Key_ClearStates();
+	return retval;
+}
+
+/*********
+CIN_Init
+Initializes cinematic system
+*********/
+void CIN_Init(void)
+{
+	// Allocate Memory for Bink System
+	bVideo.AllocateXboxMem();
+}
+
+/********
+CIN_Shutdown
+Shutdown the cinematic system
+********/
+void CIN_Shutdown(void)
+{
+	// Free Memory for the Bink System
+	bVideo.FreeXboxMem();
+}
+
+
+/***** Possible FIXME *****/
+/***** The following function may need to be implemented *****/
+/***** BEGIN *****/
+void CL_PlayCinematic_f(void)
+{
+	char	*arg;
+	
+	arg = Cmd_Argv(1);
+	CIN_PlayAllFrames(arg, 48, 36, 544, 408, 0, true);
+}
+
+qboolean CL_IsRunningInGameCinematic(void)
+{
+	// Nothing
+	return qfalse;
+}
+
+qboolean CL_CheckPendingCinematic(void)
+{
+	// Nothing
+	return qfalse;
+}
+
+void CL_PlayInGameCinematic_f(void)
+{
+	// Nothing
+}
+
+qboolean CL_InGameCinematicOnStandBy(void)
+{
+	// Nothing
+	return qfalse;
+}
+/***** END *****/
+
diff --git a/code/client/cl_console.cpp b/code/client/cl_console.cpp
new file mode 100644
index 0000000..d0bc6d7
--- /dev/null
+++ b/code/client/cl_console.cpp
@@ -0,0 +1,727 @@
+// console.c
+
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+
+#include "client.h"
+#include "../qcommon/stv_version.h"
+
+int g_console_field_width = 78;
+
+console_t	con;
+
+cvar_t		*con_conspeed;
+cvar_t		*con_notifytime;
+cvar_t		*con_conAlpha;	//background alpha multiplier
+
+#define	DEFAULT_CONSOLE_WIDTH	78
+
+
+/*
+================
+Con_ToggleConsole_f
+================
+*/
+void Con_ToggleConsole_f (void) {
+	// closing a full screen console restarts the demo loop
+	if ( cls.state == CA_DISCONNECTED && cls.keyCatchers == KEYCATCH_CONSOLE ) {
+//		CL_StartDemoLoop();
+		return;
+	}
+
+	Field_Clear( &kg.g_consoleField );
+	kg.g_consoleField.widthInChars = g_console_field_width;
+
+	Con_ClearNotify ();
+
+	cls.keyCatchers ^= KEYCATCH_CONSOLE;
+}
+
+/*
+================
+Con_MessageMode_f
+================
+*/
+void Con_MessageMode_f (void) {
+	Field_Clear( &chatField );
+	chatField.widthInChars = 30;
+
+//	cls.keyCatchers ^= KEYCATCH_MESSAGE;
+}
+
+/*
+================
+Con_Clear_f
+================
+*/
+void Con_Clear_f (void) {
+	int		i;
+
+	for ( i = 0 ; i < CON_TEXTSIZE ; i++ ) {
+		con.text[i] = (ColorIndex(COLOR_WHITE)<<8) | ' ';
+	}
+
+	Con_Bottom();		// go to end
+}
+
+						
+/*
+================
+Con_Dump_f
+
+Save the console contents out to a file
+================
+*/
+void Con_Dump_f (void)
+{
+#ifndef _XBOX
+	int		l, x, i;
+	short	*line;
+	fileHandle_t	f;
+	char	buffer[1024];
+
+	if (Cmd_Argc() != 2)
+	{
+		Com_Printf (SE_GetString("CON_TEXT_DUMP_USAGE"));
+		return;
+	}
+
+	Com_Printf ("Dumped console text to %s.\n", Cmd_Argv(1) );
+
+	f = FS_FOpenFileWrite( Cmd_Argv( 1 ) );
+	if (!f)
+	{
+		Com_Printf (S_COLOR_RED"ERROR: couldn't open dump file.\n");
+		return;
+	}
+
+	// skip empty lines
+	for (l = con.current - con.totallines + 1 ; l <= con.current ; l++)
+	{
+		line = con.text + (l%con.totallines)*con.linewidth;
+		for (x=0 ; x<con.linewidth ; x++)
+			if ((line[x] & 0xff) != ' ')
+				break;
+		if (x != con.linewidth)
+			break;
+	}
+
+	// write the remaining lines
+	buffer[con.linewidth] = 0;
+	for ( ; l <= con.current ; l++)
+	{
+		line = con.text + (l%con.totallines)*con.linewidth;
+		for(i=0; i<con.linewidth; i++)
+			buffer[i] = line[i] & 0xff;
+		for (x=con.linewidth-1 ; x>=0 ; x--)
+		{
+			if (buffer[x] == ' ')
+				buffer[x] = 0;
+			else
+				break;
+		}
+
+		FS_Printf (f, "%s\n", buffer);
+	}
+
+	FS_FCloseFile( f );
+#endif
+}
+
+						
+/*
+================
+Con_ClearNotify
+================
+*/
+void Con_ClearNotify( void ) {
+	int		i;
+	
+	for ( i = 0 ; i < NUM_CON_TIMES ; i++ ) {
+		con.times[i] = 0;
+	}
+}
+
+						
+
+/*
+================
+Con_CheckResize
+
+If the line width has changed, reformat the buffer.
+================
+*/
+void Con_CheckResize (void)
+{
+	int		i, j, width, oldwidth, oldtotallines, numlines, numchars;
+	MAC_STATIC short	tbuf[CON_TEXTSIZE];
+
+	//width = (SCREEN_WIDTH / SMALLCHAR_WIDTH) - 2;
+	width = (cls.glconfig.vidWidth / SMALLCHAR_WIDTH) - 2;
+
+	if (width == con.linewidth)
+		return;
+
+	if (width < 1)			// video hasn't been initialized yet
+	{
+		con.xadjust = 1;
+		con.yadjust = 1;
+		width = DEFAULT_CONSOLE_WIDTH;
+		con.linewidth = width;
+		con.totallines = CON_TEXTSIZE / con.linewidth;
+		for(i=0; i<CON_TEXTSIZE; i++)
+		{
+			con.text[i] = (ColorIndex(COLOR_WHITE)<<8) | ' ';
+		}
+	}
+	else
+	{
+		// on wide screens, we will center the text
+		con.xadjust = 640.0f / cls.glconfig.vidWidth;
+		con.yadjust = 480.0f / cls.glconfig.vidHeight;
+
+		oldwidth = con.linewidth;
+		con.linewidth = width;
+		oldtotallines = con.totallines;
+		con.totallines = CON_TEXTSIZE / con.linewidth;
+		numlines = oldtotallines;
+
+		if (con.totallines < numlines)
+			numlines = con.totallines;
+
+		numchars = oldwidth;
+	
+		if (con.linewidth < numchars)
+			numchars = con.linewidth;
+
+		memcpy (tbuf, con.text, CON_TEXTSIZE * sizeof(short));
+		for(i=0; i<CON_TEXTSIZE; i++)
+
+			con.text[i] = (ColorIndex(COLOR_WHITE)<<8) | ' ';
+
+
+		for (i=0 ; i<numlines ; i++)
+		{
+			for (j=0 ; j<numchars ; j++)
+			{
+				con.text[(con.totallines - 1 - i) * con.linewidth + j] =
+						tbuf[((con.current - i + oldtotallines) %
+							  oldtotallines) * oldwidth + j];
+			}
+		}
+
+		Con_ClearNotify ();
+	}
+
+	con.current = con.totallines - 1;
+	con.display = con.current;
+}
+
+
+/*
+================
+Con_Init
+================
+*/
+void Con_Init (void) {
+	int		i;
+
+	con_notifytime = Cvar_Get ("con_notifytime", "3", 0);
+	con_conspeed = Cvar_Get ("scr_conspeed", "3", 0);
+	con_conAlpha= Cvar_Get( "conAlpha", "1.6", CVAR_ARCHIVE );
+	
+	Field_Clear( &kg.g_consoleField );
+	kg.g_consoleField.widthInChars = g_console_field_width;
+	for ( i = 0 ; i < COMMAND_HISTORY ; i++ ) {
+		Field_Clear( &kg.historyEditLines[i] );
+		kg.historyEditLines[i].widthInChars = g_console_field_width;
+	}
+
+	Cmd_AddCommand ("toggleconsole", Con_ToggleConsole_f);
+	Cmd_AddCommand ("messagemode", Con_MessageMode_f);
+	Cmd_AddCommand ("clear", Con_Clear_f);
+	Cmd_AddCommand ("condump", Con_Dump_f);
+}
+
+
+/*
+===============
+Con_Linefeed
+===============
+*/
+void Con_Linefeed (void)
+{
+	int		i;
+
+	// mark time for transparent overlay
+	if (con.current >= 0)
+		con.times[con.current % NUM_CON_TIMES] = cls.realtime;
+
+	con.x = 0;
+	if (con.display == con.current)
+		con.display++;
+	con.current++;
+	for(i=0; i<con.linewidth; i++)
+		con.text[(con.current%con.totallines)*con.linewidth+i] = (ColorIndex(COLOR_WHITE)<<8) | ' ';
+}
+
+/*
+================
+CL_ConsolePrint
+
+Handles cursor positioning, line wrapping, etc
+All console printing must go through this in order to be logged to disk
+If no console is visible, the text will appear at the top of the game window
+================
+*/
+void CL_ConsolePrint( char *txt ) {
+	int		y;
+	int		c, l;
+	int		color;
+
+	// for some demos we don't want to ever show anything on the console
+	if ( cl_noprint && cl_noprint->integer ) {
+		return;
+	}
+	
+	if (!con.initialized) {
+		con.color[0] = 
+		con.color[1] = 
+		con.color[2] =
+		con.color[3] = 1.0f;
+		con.linewidth = -1;
+		Con_CheckResize ();
+		con.initialized = qtrue;
+	}
+
+	color = ColorIndex(COLOR_WHITE);
+
+	while ( (c = (unsigned char )*txt) != 0 ) {
+		if ( Q_IsColorString( (unsigned char*) txt ) ) {
+			color = ColorIndex( *(txt+1) );
+			txt += 2;
+			continue;
+		}
+
+		// count word length
+		for (l=0 ; l< con.linewidth ; l++) {
+			if ( txt[l] <= ' ') {
+				break;
+			}
+
+		}
+
+		// word wrap
+		if (l != con.linewidth && (con.x + l >= con.linewidth) ) {
+			Con_Linefeed();
+
+		}
+
+		txt++;
+
+		switch (c)
+		{
+		case '\n':
+			Con_Linefeed ();
+			break;
+		case '\r':
+			con.x = 0;
+			break;
+		default:	// display character and advance
+			y = con.current % con.totallines;
+			con.text[y*con.linewidth+con.x] = (color << 8) | c;
+			con.x++;
+			if (con.x >= con.linewidth) {
+
+				Con_Linefeed();
+				con.x = 0;
+			}
+			break;
+		}
+	}
+
+
+	// mark time for transparent overlay
+
+	if (con.current >= 0)
+		con.times[con.current % NUM_CON_TIMES] = cls.realtime;
+}
+
+
+/*
+==============================================================================
+
+DRAWING
+
+==============================================================================
+*/
+
+
+/*
+================
+Con_DrawInput
+
+Draw the editline after a ] prompt
+================
+*/
+void Con_DrawInput (void) {
+	int		y;
+
+	if ( cls.state != CA_DISCONNECTED && !(cls.keyCatchers & KEYCATCH_CONSOLE ) ) {
+		return;
+	}
+
+	y = con.vislines - ( SMALLCHAR_HEIGHT * (re.Language_IsAsian() ? 1.5 : 2) );
+
+	re.SetColor( con.color );
+
+	SCR_DrawSmallChar( con.xadjust + 1 * SMALLCHAR_WIDTH, y, ']' );
+
+	Field_Draw( &kg.g_consoleField, con.xadjust + 2 * SMALLCHAR_WIDTH, y,
+		SCREEN_WIDTH - 3 * SMALLCHAR_WIDTH, qtrue );
+}
+
+
+/*
+================
+Con_DrawNotify
+
+Draws the last few lines of output transparently over the game top
+================
+*/
+void Con_DrawNotify (void)
+{
+	int		x, v;
+	short	*text;
+	int		i;
+	int		time;
+	int		skip;
+	int		currentColor;
+
+	currentColor = 7;
+	re.SetColor( g_color_table[currentColor] );
+
+	v = 0;
+	for (i= con.current-NUM_CON_TIMES+1 ; i<=con.current ; i++)
+	{
+		if (i < 0)
+			continue;
+		time = con.times[i % NUM_CON_TIMES];
+		if (time == 0)
+			continue;
+		time = cls.realtime - time;
+		if (time > con_notifytime->value*1000)
+			continue;
+		text = con.text + (i % con.totallines)*con.linewidth;
+
+		// asian language needs to use the new font system to print glyphs...
+		//
+		// (ignore colours since we're going to print the whole thing as one string)
+		//
+		if (re.Language_IsAsian())
+		{
+			int iFontIndex = re.RegisterFont("ocr_a");	// this seems naughty
+			const float fFontScale = 0.75f*con.yadjust;
+			const int iPixelHeightToAdvance =   2+(1.3/con.yadjust) * re.Font_HeightPixels(iFontIndex, fFontScale);	// for asian spacing, since we don't want glyphs to touch.
+
+			// concat the text to be printed...
+			//
+			char sTemp[4096]={0};	// ott
+			for (x = 0 ; x < con.linewidth ; x++) 
+			{
+				if ( ( (text[x]>>8)&7 ) != currentColor ) {
+					currentColor = (text[x]>>8)&7;
+					strcat(sTemp,va("^%i", (text[x]>>8)&7) );
+				}
+				strcat(sTemp,va("%c",text[x] & 0xFF));				
+			}
+			//
+			// and print...
+			//
+			re.Font_DrawString(con.xadjust*(con.xadjust + (1*SMALLCHAR_WIDTH/*aesthetics*/)), con.yadjust*(v), sTemp, g_color_table[currentColor], iFontIndex, -1, fFontScale);
+
+			v +=  iPixelHeightToAdvance;
+		}
+		else
+		{		
+			for (x = 0 ; x < con.linewidth ; x++) {
+				if ( ( text[x] & 0xff ) == ' ' ) {
+					continue;
+				}
+				if ( ( (text[x]>>8)&7 ) != currentColor ) {
+					currentColor = (text[x]>>8)&7;
+					re.SetColor( g_color_table[currentColor] );
+				}
+				SCR_DrawSmallChar( con.xadjust + (x+1)*SMALLCHAR_WIDTH, v, text[x] & 0xff );
+			}
+			v += SMALLCHAR_HEIGHT;
+		}		
+	}
+
+	re.SetColor( NULL );
+
+	// draw the chat line
+	if ( cls.keyCatchers & KEYCATCH_MESSAGE )
+	{
+		SCR_DrawBigString (8, v, "say:", 1.0f );
+		skip = 5;
+
+		Field_BigDraw( &chatField, skip * BIGCHAR_WIDTH, v,
+			SCREEN_WIDTH - ( skip + 1 ) * BIGCHAR_WIDTH, qtrue );
+
+		v += BIGCHAR_HEIGHT;
+	}
+
+}
+
+/*
+================
+Con_DrawSolidConsole
+
+Draws the console with the solid background
+================
+*/
+void Con_DrawSolidConsole( float frac ) 
+{
+	int				i, x, y;
+	int				rows;
+	short			*text;
+	int				row;
+	int				lines;
+	int				currentColor;
+
+	lines = cls.glconfig.vidHeight * frac;
+	if (lines <= 0)
+		return;
+
+	if (lines > cls.glconfig.vidHeight )
+		lines = cls.glconfig.vidHeight;
+
+	// draw the background
+	y = frac * SCREEN_HEIGHT - 2;
+	if ( y < 1 ) {
+		y = 0;
+	}
+	else {
+		// draw the background only if fullscreen
+		if ( frac != 1.0f )
+		{
+			vec4_t	con_color;
+			MAKERGBA( con_color, 0.0f, 0.0f, 0.0f, frac*con_conAlpha->value );
+			re.SetColor(con_color);
+		}
+		else
+		{
+			re.SetColor(NULL);
+		}
+		SCR_DrawPic( 0, 0, SCREEN_WIDTH, y, cls.consoleShader);
+	}
+
+
+	const vec4_t color = { 0.509f, 0.609f, 0.847f,  1.0f};
+	// draw the bottom bar and version number
+
+	re.SetColor( color );
+	re.DrawStretchPic( 0, y, SCREEN_WIDTH, 2, 0, 0, 0, 0, cls.whiteShader );
+
+	i = strlen( Q3_VERSION );
+
+	for (x=0 ; x<i ; x++) {
+		SCR_DrawSmallChar( cls.glconfig.vidWidth - ( i - x ) * SMALLCHAR_WIDTH, 
+			(lines-(SMALLCHAR_HEIGHT+SMALLCHAR_HEIGHT/2)), Q3_VERSION[x] );
+	}
+
+
+	// draw the text
+	con.vislines = lines;
+	rows = (lines-SMALLCHAR_WIDTH)/SMALLCHAR_WIDTH;		// rows of text to draw
+
+	y = lines - (SMALLCHAR_HEIGHT*3);
+
+	// draw from the bottom up
+	if (con.display != con.current)
+	{
+	// draw arrows to show the buffer is backscrolled
+		re.SetColor( g_color_table[ColorIndex(COLOR_YELLOW)] );
+		for (x=0 ; x<con.linewidth ; x+=4)
+			SCR_DrawSmallChar( con.xadjust + (x+1)*SMALLCHAR_WIDTH, y, '^' );
+		y -= SMALLCHAR_HEIGHT;
+		rows--;
+	}
+	
+	row = con.display;
+
+	if ( con.x == 0 ) {
+		row--;
+	}
+
+	currentColor = 7;
+	re.SetColor( g_color_table[currentColor] );
+
+
+	int iFontIndexForAsian = 0;	// kinda tacky, this just gets the first registered font, since Asian stuff ignores the contents anyway
+	const float fFontScaleForAsian = 0.75f*con.yadjust;
+	int iPixelHeightToAdvance = SMALLCHAR_HEIGHT;
+	if (re.Language_IsAsian())
+	{
+		if (!iFontIndexForAsian) 
+		{
+			iFontIndexForAsian = re.RegisterFont("ocr_a");	// must be a font that's used elsewhere
+		}
+		iPixelHeightToAdvance =   (1.3/con.yadjust) * re.Font_HeightPixels(iFontIndexForAsian, fFontScaleForAsian);	// for asian spacing, since we don't want glyphs to touch.
+	}
+		
+	for (i=0 ; i<rows ; i++, y -= iPixelHeightToAdvance, row--)
+	{
+		if (row < 0)
+			break;
+		if (con.current - row >= con.totallines) {
+			// past scrollback wrap point
+			continue;	
+		}
+
+		text = con.text + (row % con.totallines)*con.linewidth;
+
+
+		// asian language needs to use the new font system to print glyphs...
+		//
+		// (ignore colours since we're going to print the whole thing as one string)
+		//
+		if (re.Language_IsAsian())
+		{
+			// concat the text to be printed...
+			//
+			char sTemp[4096]={0};	// ott
+			for (x = 0 ; x < con.linewidth ; x++) 
+			{
+				if ( ( (text[x]>>8)&7 ) != currentColor ) {
+					currentColor = (text[x]>>8)&7;
+					strcat(sTemp,va("^%i", (text[x]>>8)&7) );
+				}
+				strcat(sTemp,va("%c",text[x] & 0xFF));				
+			}
+			//
+			// and print...
+			//
+			re.Font_DrawString(con.xadjust*(con.xadjust + (1*SMALLCHAR_WIDTH/*(aesthetics)*/)), con.yadjust*(y), sTemp, g_color_table[currentColor], iFontIndexForAsian, -1, fFontScaleForAsian);
+		}
+		else
+		{		
+			for (x=0 ; x<con.linewidth ; x++) {
+				if ( ( text[x] & 0xff ) == ' ' ) {
+					continue;
+				}
+
+				if ( ( (text[x]>>8)&7 ) != currentColor ) {
+					currentColor = (text[x]>>8)&7;
+					re.SetColor( g_color_table[currentColor] );
+				}
+				SCR_DrawSmallChar(  con.xadjust + (x+1)*SMALLCHAR_WIDTH, y, text[x] & 0xff );
+			}
+		}
+	}
+
+	// draw the input prompt, user text, and cursor if desired
+	Con_DrawInput ();
+
+	re.SetColor( NULL );
+}
+
+
+
+/*
+==================
+Con_DrawConsole
+==================
+*/
+void Con_DrawConsole( void ) {
+	// check for console width changes from a vid mode change
+	Con_CheckResize ();
+
+	// if disconnected, render console full screen
+	if ( cls.state == CA_DISCONNECTED ) {
+		if ( !( cls.keyCatchers & KEYCATCH_UI ) ) {
+			Con_DrawSolidConsole( 1.0 );
+			return;
+		}
+	}
+
+	if ( con.displayFrac ) {
+		Con_DrawSolidConsole( con.displayFrac );
+	} else {
+		// draw notify lines
+		if ( cls.state == CA_ACTIVE ) {
+			Con_DrawNotify ();
+		}
+	}
+}
+
+//================================================================
+
+/*
+==================
+Con_RunConsole
+
+Scroll it up or down
+==================
+*/
+void Con_RunConsole (void) {
+	// decide on the destination height of the console
+	if ( cls.keyCatchers & KEYCATCH_CONSOLE )
+		con.finalFrac = 0.5;		// half screen
+	else
+		con.finalFrac = 0;				// none visible
+	
+	// scroll towards the destination height
+	if (con.finalFrac < con.displayFrac)
+	{
+		con.displayFrac -= con_conspeed->value*cls.realFrametime*0.001;
+		if (con.finalFrac > con.displayFrac)
+			con.displayFrac = con.finalFrac;
+
+	}
+	else if (con.finalFrac > con.displayFrac)
+	{
+		con.displayFrac += con_conspeed->value*cls.realFrametime*0.001;
+		if (con.finalFrac < con.displayFrac)
+			con.displayFrac = con.finalFrac;
+	}
+
+}
+
+
+void Con_PageUp( void ) {
+	con.display -= 2;
+	if ( con.current - con.display >= con.totallines ) {
+		con.display = con.current - con.totallines + 1;
+	}
+}
+
+void Con_PageDown( void ) {
+	con.display += 2;
+	if (con.display > con.current) {
+		con.display = con.current;
+	}
+}
+
+void Con_Top( void ) {
+	con.display = con.totallines;
+	if ( con.current - con.display >= con.totallines ) {
+		con.display = con.current - con.totallines + 1;
+	}
+}
+
+void Con_Bottom( void ) {
+	con.display = con.current;
+}
+
+
+void Con_Close( void ) {
+	Field_Clear( &kg.g_consoleField );
+	Con_ClearNotify ();
+	cls.keyCatchers &= ~KEYCATCH_CONSOLE;
+	con.finalFrac = 0;				// none visible
+	con.displayFrac = 0;
+}
diff --git a/code/client/cl_input.cpp b/code/client/cl_input.cpp
new file mode 100644
index 0000000..57bdec4
--- /dev/null
+++ b/code/client/cl_input.cpp
@@ -0,0 +1,1089 @@
+// cl.input.c  -- builds an intended movement command to send to the server
+
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+
+#include "client.h"
+#include "client_ui.h"
+
+#ifdef _XBOX
+#include "cl_input_hotswap.h"
+#endif
+
+unsigned	frame_msec;
+int			old_com_frameTime;
+float cl_mPitchOverride = 0.0f;
+float cl_mYawOverride = 0.0f;
+
+/*
+===============================================================================
+
+KEY BUTTONS
+
+Continuous button event tracking is complicated by the fact that two different
+input sources (say, mouse button 1 and the control key) can both press the
+same button, but the button should only be released when both of the
+pressing key have been released.
+
+When a key event issues a button command (+forward, +attack, etc), it appends
+its key number as argv(1) so it can be matched up with the release.
+
+argv(2) will be set to the time the event happened, which allows exact
+control even at low framerates when the down and up events may both get qued
+at the same time.
+
+===============================================================================
+*/
+
+
+kbutton_t	in_left, in_right, in_forward, in_back;
+kbutton_t	in_lookup, in_lookdown, in_moveleft, in_moveright;
+kbutton_t	in_strafe, in_speed;
+kbutton_t	in_up, in_down;
+
+kbutton_t	in_buttons[9];
+
+
+qboolean	in_mlooking;
+
+
+#ifdef _XBOX
+HotSwapManager swapMan1(HOTSWAP_ID_WHITE);
+HotSwapManager swapMan2(HOTSWAP_ID_BLACK);
+
+
+void IN_HotSwap1On(void)
+{
+	swapMan1.SetDown();
+}
+
+
+void IN_HotSwap2On(void)
+{
+	swapMan2.SetDown();
+}
+
+
+void IN_HotSwap1Off(void)
+{
+	swapMan1.SetUp();
+}
+
+
+void IN_HotSwap2Off(void)
+{
+	swapMan2.SetUp();
+}
+
+
+void CL_UpdateHotSwap(void)
+{
+	swapMan1.Update();
+	swapMan2.Update();
+}
+
+
+bool CL_ExtendSelectTime(void)
+{
+	return swapMan1.ButtonDown() || swapMan2.ButtonDown();
+}
+#endif
+
+
+static void IN_UseGivenForce(void)
+{
+	char *c = Cmd_Argv(1);
+	int forceNum=-1;
+	int genCmdNum = 0;
+
+	if(c) {
+		forceNum = atoi(c);
+	} else {
+		return;
+	}
+
+	switch(forceNum) {
+	case FP_DRAIN:
+		genCmdNum = GENCMD_FORCE_DRAIN;
+		break;
+	case FP_PUSH:
+		genCmdNum = GENCMD_FORCE_THROW;
+		break;
+	case FP_SPEED:
+		genCmdNum = GENCMD_FORCE_SPEED;
+		break;
+	case FP_PULL:
+		genCmdNum = GENCMD_FORCE_PULL;
+		break;
+	case FP_TELEPATHY:
+		genCmdNum = GENCMD_FORCE_DISTRACT;
+		break;
+	case FP_GRIP:
+		genCmdNum = GENCMD_FORCE_GRIP;
+		break;
+	case FP_LIGHTNING:
+		genCmdNum = GENCMD_FORCE_LIGHTNING;
+		break;
+	case FP_RAGE:
+		genCmdNum = GENCMD_FORCE_RAGE;
+		break;
+	case FP_PROTECT:
+		genCmdNum = GENCMD_FORCE_PROTECT;
+		break;
+	case FP_ABSORB:
+		genCmdNum = GENCMD_FORCE_ABSORB;
+		break;
+	case FP_SEE:
+		genCmdNum = GENCMD_FORCE_SEEING;
+		break;
+	case FP_HEAL:
+		genCmdNum = GENCMD_FORCE_HEAL;
+		break;
+	default:
+		assert(0);
+		break;
+	}
+
+	if(genCmdNum) {
+		cl.gcmdSendValue = qtrue;
+		cl.gcmdValue = genCmdNum;
+	}
+}
+
+
+void IN_MLookDown( void ) {
+	in_mlooking = qtrue;
+}
+
+void IN_MLookUp( void ) {
+	in_mlooking = qfalse;
+	if ( !cl_freelook->integer ) {
+		IN_CenterView ();
+	}
+}
+
+void IN_KeyDown( kbutton_t *b ) {
+	int		k;
+	char	*c;
+	
+	c = Cmd_Argv(1);
+	if ( c[0] ) {
+		k = atoi(c);
+	} else {
+		k = -1;		// typed manually at the console for continuous down
+	}
+
+	if ( k == b->down[0] || k == b->down[1] ) {
+		return;		// repeating key
+	}
+	
+	if ( !b->down[0] ) {
+		b->down[0] = k;
+	} else if ( !b->down[1] ) {
+		b->down[1] = k;
+	} else {
+		Com_Printf ("Three keys down for a button!\n");
+		return;
+	}
+	
+	if ( b->active ) {
+		return;		// still down
+	}
+
+	// save timestamp for partial frame summing
+	c = Cmd_Argv(2);
+	b->downtime = atoi(c);
+
+	b->active = qtrue;
+	b->wasPressed = qtrue;
+}
+
+void IN_KeyUp( kbutton_t *b ) {
+	int		k;
+	char	*c;
+	unsigned	uptime;
+
+	c = Cmd_Argv(1);
+	if ( c[0] ) {
+		k = atoi(c);
+	} else {
+		// typed manually at the console, assume for unsticking, so clear all
+		b->down[0] = b->down[1] = 0;
+		b->active = qfalse;
+		return;
+	}
+
+	if ( b->down[0] == k ) {
+		b->down[0] = 0;
+	} else if ( b->down[1] == k ) {
+		b->down[1] = 0;
+	} else {
+		return;		// key up without coresponding down (menu pass through)
+	}
+	if ( b->down[0] || b->down[1] ) {
+		return;		// some other key is still holding it down
+	}
+
+	b->active = qfalse;
+
+	// save timestamp for partial frame summing
+	c = Cmd_Argv(2);
+	uptime = atoi(c);
+	if ( uptime ) {
+		b->msec += uptime - b->downtime;
+	} else {
+		b->msec += frame_msec / 2;
+	}
+
+	b->active = qfalse;
+}
+
+
+
+/*
+===============
+CL_KeyState
+
+Returns the fraction of the frame that the key was down
+===============
+*/
+float CL_KeyState( kbutton_t *key ) {
+	float		val;
+	int			msec;
+
+	msec = key->msec;
+	key->msec = 0;
+
+	if ( key->active ) {
+		// still down
+		if ( !key->downtime ) {
+			msec = com_frameTime;
+		} else {
+			msec += com_frameTime - key->downtime;
+		}
+		key->downtime = com_frameTime;
+	}
+
+#if 0
+	if (msec) {
+		Com_Printf ("%i ", msec);
+	}
+#endif
+
+	val = (float)msec / frame_msec;
+	if ( val < 0 ) {
+		val = 0;
+	}
+	if ( val > 1 ) {
+		val = 1;
+	}
+
+	return val;
+}
+
+
+
+void IN_UpDown(void) {IN_KeyDown(&in_up);}
+void IN_UpUp(void) {IN_KeyUp(&in_up);}
+void IN_DownDown(void) {IN_KeyDown(&in_down);}
+void IN_DownUp(void) {IN_KeyUp(&in_down);}
+void IN_LeftDown(void) {IN_KeyDown(&in_left);}
+void IN_LeftUp(void) {IN_KeyUp(&in_left);}
+void IN_RightDown(void) {IN_KeyDown(&in_right);}
+void IN_RightUp(void) {IN_KeyUp(&in_right);}
+void IN_ForwardDown(void) {IN_KeyDown(&in_forward);}
+void IN_ForwardUp(void) {IN_KeyUp(&in_forward);}
+void IN_BackDown(void) {IN_KeyDown(&in_back);}
+void IN_BackUp(void) {IN_KeyUp(&in_back);}
+void IN_LookupDown(void) {IN_KeyDown(&in_lookup);}
+void IN_LookupUp(void) {IN_KeyUp(&in_lookup);}
+void IN_LookdownDown(void) {IN_KeyDown(&in_lookdown);}
+void IN_LookdownUp(void) {IN_KeyUp(&in_lookdown);}
+void IN_MoveleftDown(void) {IN_KeyDown(&in_moveleft);}
+void IN_MoveleftUp(void) {IN_KeyUp(&in_moveleft);}
+void IN_MoverightDown(void) {IN_KeyDown(&in_moveright);}
+void IN_MoverightUp(void) {IN_KeyUp(&in_moveright);}
+
+void IN_SpeedDown(void) {IN_KeyDown(&in_speed);}
+void IN_SpeedUp(void) {IN_KeyUp(&in_speed);}
+void IN_StrafeDown(void) {IN_KeyDown(&in_strafe);}
+void IN_StrafeUp(void) {IN_KeyUp(&in_strafe);}
+
+void IN_Button0Down(void) {IN_KeyDown(&in_buttons[0]);}
+void IN_Button0Up(void) {IN_KeyUp(&in_buttons[0]);}
+void IN_Button1Down(void) {IN_KeyDown(&in_buttons[1]);}
+void IN_Button1Up(void) {IN_KeyUp(&in_buttons[1]);}
+void IN_Button2Down(void) {IN_KeyDown(&in_buttons[2]);}
+void IN_Button2Up(void) {IN_KeyUp(&in_buttons[2]);}
+void IN_Button3Down(void) {IN_KeyDown(&in_buttons[3]);}
+void IN_Button3Up(void) {IN_KeyUp(&in_buttons[3]);}
+void IN_Button4Down(void) {IN_KeyDown(&in_buttons[4]);}
+void IN_Button4Up(void) {IN_KeyUp(&in_buttons[4]);}
+void IN_Button5Down(void) {IN_KeyDown(&in_buttons[5]);}
+void IN_Button5Up(void) {IN_KeyUp(&in_buttons[5]);}
+void IN_Button6Down(void) {IN_KeyDown(&in_buttons[6]);}
+void IN_Button6Up(void) {IN_KeyUp(&in_buttons[6]);}
+void IN_Button7Down(void) {IN_KeyDown(&in_buttons[7]);}
+void IN_Button7Up(void) {IN_KeyUp(&in_buttons[7]);}
+void IN_Button8Down(void) {IN_KeyDown(&in_buttons[8]);}
+void IN_Button8Up(void) {IN_KeyUp(&in_buttons[8]);}
+
+
+void IN_CenterView (void) {
+	cl.viewangles[PITCH] = -SHORT2ANGLE(cl.frame.ps.delta_angles[PITCH]);
+}
+
+
+//==========================================================================
+
+cvar_t	*cl_upspeed;
+cvar_t	*cl_forwardspeed;
+cvar_t	*cl_sidespeed;
+
+cvar_t	*cl_yawspeed;
+cvar_t	*cl_pitchspeed;
+
+cvar_t	*cl_run;
+
+cvar_t	*cl_anglespeedkey;
+
+
+/*
+================
+CL_AdjustAngles
+
+Moves the local angle positions
+================
+*/
+void CL_AdjustAngles( void ) {
+	float	speed;
+	
+	if ( in_speed.active ) {
+		speed = 0.001 * cls.frametime * cl_anglespeedkey->value;
+	} else {
+		speed = 0.001 * cls.frametime;
+	}
+
+	if ( !in_strafe.active ) {
+		if ( cl_mYawOverride )
+		{
+			cl.viewangles[YAW] -= cl_mYawOverride*5.0f*speed*cl_yawspeed->value*CL_KeyState (&in_right);
+			cl.viewangles[YAW] += cl_mYawOverride*5.0f*speed*cl_yawspeed->value*CL_KeyState (&in_left);
+		}
+		else
+		{
+			cl.viewangles[YAW] -= speed*cl_yawspeed->value*CL_KeyState (&in_right);
+			cl.viewangles[YAW] += speed*cl_yawspeed->value*CL_KeyState (&in_left);
+		}
+	}
+
+	if ( cl_mPitchOverride )
+	{
+		cl.viewangles[PITCH] -= cl_mPitchOverride*5.0f*speed*cl_pitchspeed->value * CL_KeyState (&in_lookup);
+		cl.viewangles[PITCH] += cl_mPitchOverride*5.0f*speed*cl_pitchspeed->value * CL_KeyState (&in_lookdown);
+	}
+	else
+	{
+		cl.viewangles[PITCH] -= speed*cl_pitchspeed->value * CL_KeyState (&in_lookup);
+		cl.viewangles[PITCH] += speed*cl_pitchspeed->value * CL_KeyState (&in_lookdown);
+	}
+}
+
+/*
+================
+CL_KeyMove
+
+Sets the usercmd_t based on key states
+================
+*/
+void CL_KeyMove( usercmd_t *cmd ) {
+	int		movespeed;
+	int		forward, side, up;
+
+	//
+	// adjust for speed key / running
+	// the walking flag is to keep animations consistant
+	// even during acceleration and develeration
+	//
+	if ( in_speed.active ^ cl_run->integer ) {
+		movespeed = 127;
+		cmd->buttons &= ~BUTTON_WALKING;
+	} else {
+		cmd->buttons |= BUTTON_WALKING;
+		movespeed = 64;
+	}
+
+	forward = 0;
+	side = 0;
+	up = 0;
+	if ( in_strafe.active ) {
+		side += movespeed * CL_KeyState (&in_right);
+		side -= movespeed * CL_KeyState (&in_left);
+	}
+
+	side += movespeed * CL_KeyState (&in_moveright);
+	side -= movespeed * CL_KeyState (&in_moveleft);
+
+
+	up += movespeed * CL_KeyState (&in_up);
+	up -= movespeed * CL_KeyState (&in_down);
+
+	forward += movespeed * CL_KeyState (&in_forward);
+	forward -= movespeed * CL_KeyState (&in_back);
+
+	cmd->forwardmove = ClampChar( forward );
+	cmd->rightmove = ClampChar( side );
+	cmd->upmove = ClampChar( up );
+}
+
+void _UI_MouseEvent( int dx, int dy );
+
+/*
+=================
+CL_MouseEvent
+=================
+*/
+void CL_MouseEvent( int dx, int dy, int time ) {
+	if ( cls.keyCatchers & KEYCATCH_UI ) {
+		_UI_MouseEvent( dx, dy );
+	}
+	else {
+		cl.mouseDx[cl.mouseIndex] += dx;
+		cl.mouseDy[cl.mouseIndex] += dy;
+	}
+}
+
+/*
+=================
+CL_JoystickEvent
+
+Joystick values stay set until changed
+=================
+*/
+void CL_JoystickEvent( int axis, int value, int time ) {
+	if ( axis < 0 || axis >= MAX_JOYSTICK_AXIS ) {
+		Com_Error( ERR_DROP, "CL_JoystickEvent: bad axis %i", axis );
+	}
+	cl.joystickAxis[axis] = value;
+}
+
+/*
+=================
+CL_JoystickMove
+=================
+*/
+void CL_JoystickMove( usercmd_t *cmd ) {
+	int		movespeed;
+	float	anglespeed;
+
+	if ( in_speed.active ^ cl_run->integer ) {
+		movespeed = 2;
+	} else {
+		movespeed = 1;
+		cmd->buttons |= BUTTON_WALKING;
+	}
+
+	if ( in_speed.active ) {
+		anglespeed = 0.001 * cls.frametime * cl_anglespeedkey->value;
+	} else {
+		anglespeed = 0.001 * cls.frametime;
+	}
+
+#ifndef _XBOX
+	if ( !in_strafe.active ) {
+		if ( cl_mYawOverride )
+		{
+			cl.viewangles[YAW] += 5.0f * cl_mYawOverride * cl.joystickAxis[AXIS_SIDE];
+		}
+		else
+		{
+			cl.viewangles[YAW] += anglespeed * (cl_yawspeed->value / 100.0f) * cl.joystickAxis[AXIS_SIDE];
+		}
+	} else
+#endif
+	{
+		cmd->rightmove = ClampChar( cmd->rightmove + cl.joystickAxis[AXIS_SIDE] );
+	}
+
+	if ( in_mlooking ) {
+		if ( cl_mPitchOverride )
+		{
+			cl.viewangles[PITCH] += 5.0f * cl_mPitchOverride * cl.joystickAxis[AXIS_FORWARD];
+		}
+		else
+		{
+			cl.viewangles[PITCH] += anglespeed * (cl_pitchspeed->value / 100.0f) * cl.joystickAxis[AXIS_FORWARD];
+		}
+	} else {
+		cmd->forwardmove = ClampChar( cmd->forwardmove + cl.joystickAxis[AXIS_FORWARD] );
+	}
+
+	cmd->upmove = ClampChar( cmd->upmove + cl.joystickAxis[AXIS_UP] );
+}
+
+/*
+=================
+CL_MouseMove
+=================
+*/
+#ifdef _XBOX
+void CL_MouseClamp(int *x, int *y)
+{
+	float ax = Q_fabs(*x);
+	float ay = Q_fabs(*y);
+
+	ax = (ax-10)*(3.0f/45.0f) * (ax-10) * (Q_fabs(*x) > 10);
+	ay = (ay-10)*(3.0f/45.0f) * (ay-10) * (Q_fabs(*y) > 10);
+	if (*x < 0)
+		*x = -ax;
+	else
+		*x = ax;
+	if (*y < 0)
+		*y = -ay;
+	else
+		*y = ay;
+}
+#endif
+
+void CL_MouseMove( usercmd_t *cmd ) {
+	float	mx, my;
+	float	accelSensitivity;
+	float	rate;
+	const float	speed = static_cast<float>(frame_msec);
+	const float pitch = m_pitch->value;
+
+#ifdef _XBOX
+	const float mouseSpeedX = 0.06f;
+	const float mouseSpeedY = 0.05f;
+
+	// allow mouse smoothing
+	if ( m_filter->integer ) {
+		mx = ( cl.mouseDx[0] + cl.mouseDx[1] ) * 0.5f * frame_msec * mouseSpeedX;
+		my = ( cl.mouseDy[0] + cl.mouseDy[1] ) * 0.5f * frame_msec * mouseSpeedY;
+	} else {
+		int ax = cl.mouseDx[cl.mouseIndex];
+		int ay = cl.mouseDy[cl.mouseIndex];
+		CL_MouseClamp(&ax, &ay);
+		
+		mx = ax * speed * mouseSpeedX;	
+		my = ay * speed * mouseSpeedY;		
+	}
+
+	extern short cg_crossHairStatus;
+	const float m_hoverSensitivity = 0.4f;
+	if (cg_crossHairStatus == 1)
+	{
+		mx *= m_hoverSensitivity;
+		my *= m_hoverSensitivity;
+	}
+#else
+	// allow mouse smoothing
+	if ( m_filter->integer ) {
+		mx = ( cl.mouseDx[0] + cl.mouseDx[1] ) * 0.5;
+		my = ( cl.mouseDy[0] + cl.mouseDy[1] ) * 0.5;
+	} else {
+		mx = cl.mouseDx[cl.mouseIndex];
+		my = cl.mouseDy[cl.mouseIndex];
+	}
+#endif
+
+	cl.mouseIndex ^= 1;
+	cl.mouseDx[cl.mouseIndex] = 0;
+	cl.mouseDy[cl.mouseIndex] = 0;
+
+	rate = SQRTFAST( mx * mx + my * my ) / speed;
+	accelSensitivity = cl_sensitivity->value + rate * cl_mouseAccel->value;
+
+	// scale by FOV
+	accelSensitivity *= cl.cgameSensitivity;
+
+	if ( rate && cl_showMouseRate->integer ) {
+		Com_Printf( "%f : %f\n", rate, accelSensitivity );
+	}
+
+	mx *= accelSensitivity;
+	my *= accelSensitivity;
+
+	if (!mx && !my) {
+#ifdef _XBOX
+		// If there was a movement but no change in angles then start auto-leveling the camera
+		extern int g_lastFireTime;
+		float autolevelSpeed = 0.03f;
+
+		if (cg_crossHairStatus != 1 &&							// Not looking at an enemy
+			cl.joystickAxis[AXIS_FORWARD] &&					// Moving forward/backward
+			cl.frame.ps.groundEntityNum != ENTITYNUM_NONE &&	// Not in the air
+			Cvar_VariableIntegerValue("cl_autolevel") &&		// Autolevel is turned on
+			g_lastFireTime < Sys_Milliseconds() - 1000)			// Haven't fired recently
+		{
+			float normAngle = -SHORT2ANGLE(cl.frame.ps.delta_angles[PITCH]);
+			// The adjustment to normAngle below is meant to add or remove some multiple
+			// of 360, so that normAngle is within 180 of viewangles[PITCH]. It should
+			// be correct.
+			int diff = (int)(cl.viewangles[PITCH] - normAngle);
+			if (diff > 180)
+				normAngle += 360.0f * ((diff+180) / 360);
+			else if (diff < -180)
+				normAngle -= 360.0f * ((-diff+180) / 360);
+
+			if (Cvar_VariableIntegerValue("cg_thirdperson") == 1)
+			{
+//				normAngle += 10;	// Removed by BTO, 2003/05/14, I hate it
+				autolevelSpeed *= 1.5f;
+			}
+			if (cl.viewangles[PITCH] > normAngle)
+			{
+				cl.viewangles[PITCH] -= autolevelSpeed * speed;
+				if (cl.viewangles[PITCH] < normAngle) cl.viewangles[PITCH] = normAngle;
+			}
+			else if (cl.viewangles[PITCH] < normAngle)
+			{
+				cl.viewangles[PITCH] += autolevelSpeed * speed;
+				if (cl.viewangles[PITCH] > normAngle) cl.viewangles[PITCH] = normAngle;
+			}
+		}
+#endif
+		return;
+	}
+
+	// add mouse X/Y movement to cmd
+	if ( in_strafe.active ) {
+		cmd->rightmove = ClampChar( cmd->rightmove + m_side->value * mx );
+	} else {
+		if ( cl_mYawOverride )
+		{
+			cl.viewangles[YAW] -= cl_mYawOverride * mx;
+		}
+		else
+		{
+			cl.viewangles[YAW] -= m_yaw->value * mx;
+		}
+	}
+
+	if ( (in_mlooking || cl_freelook->integer) && !in_strafe.active ) {
+		// VVFIXME - This is supposed to be a CVAR
+#ifdef _XBOX
+		const float cl_pitchSensitivity = 0.5f;
+#else
+		const float cl_pitchSensitivity = 1.0f;
+#endif
+		if ( cl_mPitchOverride )
+		{
+			if ( pitch > 0 )
+			{
+				cl.viewangles[PITCH] += cl_mPitchOverride * my * cl_pitchSensitivity;
+			}
+			else
+			{
+				cl.viewangles[PITCH] -= cl_mPitchOverride * my * cl_pitchSensitivity;
+			}
+		}
+		else
+		{
+			cl.viewangles[PITCH] += pitch * my * cl_pitchSensitivity;
+		}
+	} else {
+		cmd->forwardmove = ClampChar( cmd->forwardmove - m_forward->value * my );
+	}
+}
+
+
+/*
+==============
+CL_CmdButtons
+==============
+*/
+void CL_CmdButtons( usercmd_t *cmd ) {
+	int		i;
+
+	//
+	// figure button bits
+	// send a button bit even if the key was pressed and released in
+	// less than a frame
+	//	
+	for (i = 0 ; i < 9 ; i++) {
+		if ( in_buttons[i].active || in_buttons[i].wasPressed ) {
+			cmd->buttons |= 1 << i;
+		}
+		in_buttons[i].wasPressed = qfalse;
+	}
+
+	if ( cls.keyCatchers ) {
+		//cmd->buttons |= BUTTON_TALK;
+	}
+
+	// allow the game to know if any key at all is
+	// currently pressed, even if it isn't bound to anything
+	/*
+	if ( kg.anykeydown && !cls.keyCatchers ) {
+		cmd->buttons |= BUTTON_ANY;
+	}
+	*/
+}
+
+
+/*
+==============
+CL_FinishMove
+==============
+*/
+void CL_FinishMove( usercmd_t *cmd ) {
+	int		i;
+
+	// copy the state that the cgame is currently sending
+	cmd->weapon = cl.cgameUserCmdValue;
+
+	if (cl.gcmdSendValue)
+	{
+		cmd->generic_cmd = cl.gcmdValue;
+		cl.gcmdSendValue = qfalse;
+	}
+	else
+	{
+		cmd->generic_cmd = 0;
+	}
+
+	// send the current server time so the amount of movement
+	// can be determined without allowing cheating
+	cmd->serverTime = cl.serverTime;
+
+	for (i=0 ; i<3 ; i++) {
+		cmd->angles[i] = ANGLE2SHORT(cl.viewangles[i]);
+	}
+}
+
+/*
+=================
+CL_CreateCmd
+=================
+*/
+vec3_t cl_overriddenAngles = {0,0,0};
+qboolean cl_overrideAngles = qfalse;
+usercmd_t CL_CreateCmd( void ) {
+	usercmd_t	cmd;
+	vec3_t		oldAngles;
+
+	VectorCopy( cl.viewangles, oldAngles );
+
+	// keyboard angle adjustment
+	CL_AdjustAngles ();
+	
+	memset( &cmd, 0, sizeof( cmd ) );
+
+	CL_CmdButtons( &cmd );
+
+	// get basic movement from keyboard
+	CL_KeyMove (&cmd);
+
+	// get basic movement from mouse
+	CL_MouseMove( &cmd );
+
+	// get basic movement from joystick
+	CL_JoystickMove( &cmd );
+
+	// check to make sure the angles haven't wrapped
+	if ( cl.viewangles[PITCH] - oldAngles[PITCH] > 90 ) {
+		cl.viewangles[PITCH] = oldAngles[PITCH] + 90;
+	} else if ( oldAngles[PITCH] - cl.viewangles[PITCH] > 90 ) {
+		cl.viewangles[PITCH] = oldAngles[PITCH] - 90;
+	} 
+
+	if ( cl_overrideAngles )
+	{
+		VectorCopy( cl_overriddenAngles, cl.viewangles );
+		cl_overrideAngles = qfalse;
+	}
+	// store out the final values
+	CL_FinishMove( &cmd );
+
+	// draw debug graphs of turning for mouse testing
+#ifndef _XBOX
+	if ( cl_debugMove->integer ) {
+		if ( cl_debugMove->integer == 1 ) {
+			SCR_DebugGraph( abs(cl.viewangles[YAW] - oldAngles[YAW]), 0 );
+		}
+		if ( cl_debugMove->integer == 2 ) {
+			SCR_DebugGraph( abs(cl.viewangles[PITCH] - oldAngles[PITCH]), 0 );
+		}
+	}
+#endif
+
+	return cmd;
+}
+
+
+/*
+=================
+CL_CreateNewCommands
+
+Create a new usercmd_t structure for this frame
+=================
+*/
+void CL_CreateNewCommands( void ) {
+	usercmd_t	*cmd;
+	int			cmdNum;
+
+	// no need to create usercmds until we have a gamestate
+//	if ( cls.state < CA_PRIMED ) {
+//		return;
+//	}
+
+	frame_msec = com_frameTime - old_com_frameTime;
+
+	// if running less than 5fps, truncate the extra time to prevent
+	// unexpected moves after a hitch
+	if ( frame_msec > 200 ) {
+		frame_msec = 200;
+	}
+	old_com_frameTime = com_frameTime;
+
+
+	// generate a command for this frame
+	cl.cmdNumber++;
+	cmdNum = cl.cmdNumber & CMD_MASK;
+	cl.cmds[cmdNum] = CL_CreateCmd ();
+	cmd = &cl.cmds[cmdNum];
+}
+
+/*
+=================
+CL_ReadyToSendPacket
+
+Returns qfalse if we are over the maxpackets limit
+and should choke back the bandwidth a bit by not sending
+a packet this frame.  All the commands will still get
+delivered in the next packet, but saving a header and
+getting more delta compression will reduce total bandwidth.
+=================
+*/
+qboolean CL_ReadyToSendPacket( void ) {
+	// don't send anything if playing back a demo
+//	if ( cls.state == CA_CINEMATIC ) 
+	if ( cls.state == CA_CINEMATIC || CL_IsRunningInGameCinematic())
+	{
+		return qfalse;
+	}
+
+	// if we don't have a valid gamestate yet, only send
+	// one packet a second
+	if ( cls.state != CA_ACTIVE && cls.state != CA_PRIMED
+		&& cls.realtime - clc.lastPacketSentTime < 1000 ) {
+		return qfalse;
+	}
+
+	// send every frame for loopbacks
+	return qtrue;
+}
+
+/*
+===================
+CL_WritePacket
+
+Create and send the command packet to the server
+Including both the reliable commands and the usercmds
+
+During normal gameplay, a client packet will contain something like:
+
+4	sequence number
+2	qport
+4	serverid
+4	acknowledged sequence number
+4	clc.serverCommandSequence
+<optional reliable commands>
+1	clc_move or clc_moveNoDelta
+1	command count
+<count * usercmds>
+
+===================
+*/
+void CL_WritePacket( void ) {
+	msg_t		buf;
+	byte		data[MAX_MSGLEN];
+	int			i, j;
+	usercmd_t	*cmd, *oldcmd;
+	usercmd_t	nullcmd;
+	int			packetNum;
+	int			oldPacketNum;
+	int			count;
+
+	// don't send anything if playing back a demo
+//	if ( cls.state == CA_CINEMATIC ) 
+	if ( cls.state == CA_CINEMATIC || CL_IsRunningInGameCinematic())
+	{
+		return;
+	}
+
+	MSG_Init( &buf, data, sizeof(data) );
+
+	// write any unacknowledged clientCommands
+	for ( i = clc.reliableAcknowledge + 1 ; i <= clc.reliableSequence ; i++ ) {
+		MSG_WriteByte( &buf, clc_clientCommand );
+		MSG_WriteLong( &buf, i );
+		MSG_WriteString( &buf, clc.reliableCommands[ i & (MAX_RELIABLE_COMMANDS-1) ] );
+	}
+
+	// we want to send all the usercmds that were generated in the last
+	// few packet, so even if a couple packets are dropped in a row,
+	// all the cmds will make it to the server
+	if ( cl_packetdup->integer < 0 ) {
+		Cvar_Set( "cl_packetdup", "0" );
+	} else if ( cl_packetdup->integer > 5 ) {
+		Cvar_Set( "cl_packetdup", "5" );
+	}
+	oldPacketNum = (clc.netchan.outgoingSequence - 1 - cl_packetdup->integer) & PACKET_MASK;
+	count = cl.cmdNumber - cl.packetCmdNumber[ oldPacketNum ];
+	if ( count > MAX_PACKET_USERCMDS ) {
+		count = MAX_PACKET_USERCMDS;
+		Com_Printf("MAX_PACKET_USERCMDS\n");
+	}
+	if ( count >= 1 ) {
+		// begin a client move command
+		MSG_WriteByte (&buf, clc_move);
+
+		// write the last reliable message we received
+		MSG_WriteLong( &buf, clc.serverCommandSequence );
+
+		// write the current serverId so the server
+		// can tell if this is from the current gameState
+		MSG_WriteLong (&buf, cl.serverId);
+
+		// write the current time
+		MSG_WriteLong (&buf, cls.realtime);
+
+		// let the server know what the last messagenum we
+		// got was, so the next message can be delta compressed
+		// FIXME: this could just be a bit flag, with the message implicit
+		// from the unreliable ack of the netchan
+		if (cl_nodelta->integer || !cl.frame.valid) {
+			MSG_WriteLong (&buf, -1);	// no compression
+		} else {
+			MSG_WriteLong (&buf, cl.frame.messageNum);
+		}
+
+		// write the cmdNumber so the server can determine which ones it
+		// has already received
+		MSG_WriteLong( &buf, cl.cmdNumber );
+
+		// write the command count
+		MSG_WriteByte( &buf, count );
+
+		// write all the commands, including the predicted command
+		memset( &nullcmd, 0, sizeof(nullcmd) );
+		oldcmd = &nullcmd;
+		for ( i = 0 ; i < count ; i++ ) {
+			j = (cl.cmdNumber - count + i + 1) & CMD_MASK;
+			cmd = &cl.cmds[j];
+			MSG_WriteDeltaUsercmd (&buf, oldcmd, cmd);
+			oldcmd = cmd;
+		}
+	}
+
+	//
+	// deliver the message
+	//
+	packetNum = clc.netchan.outgoingSequence & PACKET_MASK;
+	cl.packetTime[ packetNum ] = cls.realtime;
+	cl.packetCmdNumber[ packetNum ] = cl.cmdNumber;
+	clc.lastPacketSentTime = cls.realtime;
+	Netchan_Transmit (&clc.netchan, buf.cursize, buf.data);	
+}
+
+/*
+=================
+CL_SendCmd
+
+Called every frame to builds and sends a command packet to the server.
+=================
+*/
+void CL_SendCmd( void ) {
+	// don't send any message if not connected
+	if ( cls.state < CA_CONNECTED ) {
+		return;
+	} 
+
+	// don't send commands if paused
+	if ( com_sv_running->integer && sv_paused->integer && cl_paused->integer ) {
+		return;
+	}
+
+	// we create commands even if a demo is playing,
+	CL_CreateNewCommands();
+
+	// don't send a packet if the last packet was sent too recently
+	if ( !CL_ReadyToSendPacket() ) {
+		return;
+	}
+
+	CL_WritePacket();
+}
+
+
+/*
+============
+CL_InitInput
+============
+*/
+void CL_InitInput( void ) {
+	Cmd_AddCommand ("centerview",IN_CenterView);
+
+	Cmd_AddCommand ("+moveup",IN_UpDown);
+	Cmd_AddCommand ("-moveup",IN_UpUp);
+	Cmd_AddCommand ("+movedown",IN_DownDown);
+	Cmd_AddCommand ("-movedown",IN_DownUp);
+	Cmd_AddCommand ("+left",IN_LeftDown);
+	Cmd_AddCommand ("-left",IN_LeftUp);
+	Cmd_AddCommand ("+right",IN_RightDown);
+	Cmd_AddCommand ("-right",IN_RightUp);
+	Cmd_AddCommand ("+forward",IN_ForwardDown);
+	Cmd_AddCommand ("-forward",IN_ForwardUp);
+	Cmd_AddCommand ("+back",IN_BackDown);
+	Cmd_AddCommand ("-back",IN_BackUp);
+	Cmd_AddCommand ("+lookup", IN_LookupDown);
+	Cmd_AddCommand ("-lookup", IN_LookupUp);
+	Cmd_AddCommand ("+lookdown", IN_LookdownDown);
+	Cmd_AddCommand ("-lookdown", IN_LookdownUp);
+	Cmd_AddCommand ("+strafe", IN_StrafeDown);
+	Cmd_AddCommand ("-strafe", IN_StrafeUp);
+	Cmd_AddCommand ("+moveleft", IN_MoveleftDown);
+	Cmd_AddCommand ("-moveleft", IN_MoveleftUp);
+	Cmd_AddCommand ("+moveright", IN_MoverightDown);
+	Cmd_AddCommand ("-moveright", IN_MoverightUp);
+	Cmd_AddCommand ("+speed", IN_SpeedDown);
+	Cmd_AddCommand ("-speed", IN_SpeedUp);
+	//xbox hot swappable buttons
+#ifdef _XBOX
+	Cmd_AddCommand ("+hotswap1", IN_HotSwap1On);
+	Cmd_AddCommand ("+hotswap2", IN_HotSwap2On);
+	Cmd_AddCommand ("-hotswap1", IN_HotSwap1Off);
+	Cmd_AddCommand ("-hotswap2", IN_HotSwap2Off);
+#endif
+	Cmd_AddCommand ("useGivenForce", IN_UseGivenForce);
+	//buttons
+	Cmd_AddCommand ("+attack", IN_Button0Down);//attack
+	Cmd_AddCommand ("-attack", IN_Button0Up);
+	Cmd_AddCommand ("+force_lightning", IN_Button1Down);//force lightning
+	Cmd_AddCommand ("-force_lightning", IN_Button1Up);
+	Cmd_AddCommand ("+useforce", IN_Button2Down);	//use current force power
+	Cmd_AddCommand ("-useforce", IN_Button2Up);
+	Cmd_AddCommand ("+force_drain", IN_Button3Down);//force drain
+	Cmd_AddCommand ("-force_drain", IN_Button3Up);
+	Cmd_AddCommand ("+walk", IN_Button4Down);//walking
+	Cmd_AddCommand ("-walk", IN_Button4Up);
+	Cmd_AddCommand ("+use", IN_Button5Down);//use object
+	Cmd_AddCommand ("-use", IN_Button5Up);
+	Cmd_AddCommand ("+force_grip", IN_Button6Down);//force jump
+	Cmd_AddCommand ("-force_grip", IN_Button6Up);
+	Cmd_AddCommand ("+altattack", IN_Button7Down);//altattack
+	Cmd_AddCommand ("-altattack", IN_Button7Up);
+	Cmd_AddCommand ("+forcefocus", IN_Button8Down);//special saber attacks
+	Cmd_AddCommand ("-forcefocus", IN_Button8Up);
+	//end buttons
+	Cmd_AddCommand ("+mlook", IN_MLookDown);
+	Cmd_AddCommand ("-mlook", IN_MLookUp);
+
+	cl_nodelta = Cvar_Get ("cl_nodelta", "0", 0);
+	cl_debugMove = Cvar_Get ("cl_debugMove", "0", 0);
+}
+
diff --git a/code/client/cl_input_hotswap.cpp b/code/client/cl_input_hotswap.cpp
new file mode 100644
index 0000000..5b5a88c
--- /dev/null
+++ b/code/client/cl_input_hotswap.cpp
@@ -0,0 +1,246 @@
+/* 
+	TODO: finalize item support
+
+	1) Make ItemSelectUp() work.
+	2) Change cg.itemSelect to whatever var is used to store selected item.
+	3) Make sure commands in itemCommands work in both multi & single player.
+*/
+
+#ifdef _JK2MP
+#include "../../codemp/client/client.h"
+#include "../../codemp/cgame/cg_local.h"
+#else
+#include "client.h"
+#include "../cgame/cg_local.h"
+#endif
+
+#include "cl_input_hotswap.h"
+
+
+#ifdef _JK2MP
+#define FORCESELECTTIME forceSelectTime
+#define FORCESELECT		forceSelect
+#define INVSELECTTIME	invenSelectTime
+#define INVSELECT		itemSelect
+#define REGISTERSOUND	S_RegisterSound
+#define STARTSOUND		S_StartLocalSound
+#define WEAPONBINDSTR	"weaponclean"
+#else
+#define FORCESELECTTIME forcepowerSelectTime
+#define FORCESELECT		forcepowerSelect
+#define INVSELECTTIME	inventorySelectTime
+#define INVSELECT		inventorySelect
+#define REGISTERSOUND	cgi_S_RegisterSound
+#define STARTSOUND		cgi_S_StartLocalSound
+#define WEAPONBINDSTR	"weapon"
+#endif
+
+#define BIND_TIME 3000 //number of milliseconds button is held before binding
+#define EXEC_TIME 500  //max ms button can be held to execute in bind mode
+
+
+#ifdef _JK2MP
+const char *itemCommands[HI_NUM_HOLDABLE] = {
+	NULL,						//HI_NONE
+	"use_seeker\n",
+	"use_field\n",
+	"use_bacta\n",
+	"use_bactabig\n",
+	"use_electrobinoculars\n",
+	"use_sentry\n",
+	"use_jetpack\n",
+	NULL,						//ammo dispenser
+	NULL,						//health dispenser
+	"use_eweb\n",
+	"use_cloak\n",
+};
+#else
+const char *itemCommands[INV_MAX] = {
+	"use_electrobinoculars\n",
+	"use_bacta\n",
+	"use_seeker\n",
+	"use_goggles\n",
+	"use_sentry\n",
+	NULL,						//goodie key
+	NULL,						//security key
+};
+#endif
+
+
+
+HotSwapManager::HotSwapManager(int uniqueID) :
+	uniqueID(uniqueID),
+	forceBound(false)
+{
+	Reset();
+}
+
+
+char *HotSwapManager::GetBinding(void)
+{
+	char buf[64];
+
+	sprintf(buf, "hotswap%d", uniqueID);
+	cvar_t *cvar = Cvar_Get(buf, "", CVAR_ARCHIVE);
+
+	if(cvar && cvar->string[0] != 0) {
+		return cvar->string;
+	} else {
+		return NULL;
+	}
+}
+
+
+void HotSwapManager::Bind(void)
+{
+	forceBound = false;
+
+	if(WeaponSelectUp()) {
+		HotSwapBind(uniqueID, HOTSWAP_CAT_WEAPON, cg.weaponSelect);
+	} else if(ForceSelectUp()) {
+		forceBound = true;
+		HotSwapBind(uniqueID, HOTSWAP_CAT_FORCE, 
+#ifdef _JK2MP
+				cg.FORCESELECT
+#else
+				showPowers[cg.FORCESELECT]
+#endif
+				);
+	} else if(ItemSelectUp()) {
+		HotSwapBind(uniqueID, HOTSWAP_CAT_ITEM, cg.INVSELECT);
+	} else{
+		assert(0);
+	}
+
+	noExec = true;
+	noBind = true;
+	STARTSOUND(REGISTERSOUND("sound/interface/update"), 0);
+}
+
+
+bool HotSwapManager::ForceSelectUp(void)
+{
+	return cg.FORCESELECTTIME != 0 &&
+		(cg.FORCESELECTTIME + WEAPON_SELECT_TIME >= cg.time);
+}
+
+
+bool HotSwapManager::WeaponSelectUp(void)
+{
+	return cg.weaponSelectTime != 0 &&
+		(cg.weaponSelectTime + WEAPON_SELECT_TIME >= cg.time);
+}
+
+
+bool HotSwapManager::ItemSelectUp(void)
+{
+	return cg.INVSELECTTIME != 0 &&
+		(cg.INVSELECTTIME + WEAPON_SELECT_TIME >= cg.time);
+}
+
+
+bool HotSwapManager::HUDInBindState(void)
+{
+	return ForceSelectUp() || WeaponSelectUp() || ItemSelectUp();
+}
+
+
+void HotSwapManager::Update(void)
+{
+	if(down) {
+		//Increment bindTime only if HUD is in select mode.
+		if(HUDInBindState()) {
+			bindTime += cls.frametime;
+		} else {
+
+			//Clear bind time.
+			bindTime = 0;
+
+			//If a force power is bound, want to execute whenever the button
+			//is down to handle powers which can be held.
+			if(forceBound) {
+				Execute();
+			}
+		}
+		downTime += cls.frametime;
+	}
+
+	//Down long enough, bind button.
+	if(!noBind && bindTime >= BIND_TIME) {
+		Bind();
+	}
+}
+
+
+void HotSwapManager::Execute(void)
+{
+	char *binding = GetBinding();
+	if(binding && !noExec) {
+		if(!forceBound) {
+			noExec = true;
+		}
+		Cbuf_ExecuteText(EXEC_APPEND, binding);
+	}
+}
+
+
+void HotSwapManager::SetDown(void)
+{
+	//Set the down flag.
+	down = true;
+
+	//Execute the bind if the HUD isn't up.
+	if(!HUDInBindState()) {
+		Execute();
+	}
+}
+
+
+void HotSwapManager::SetUp(void)
+{
+	//Execute the bind if the button was held down for long enough.
+	if(downTime <= EXEC_TIME) {
+		Execute();
+	}
+
+	Reset();
+}
+
+
+void HotSwapManager::Reset(void)
+{
+	down = false;
+	downTime = 0;
+	bindTime = 0;
+	noExec = false;
+	noBind = false;
+}
+
+
+static void HotSwapBind(const char *uniqueID, const char *value)
+{
+	Cvar_Set(uniqueID, value);
+}
+
+
+void HotSwapBind(int buttonID, int category, int value)
+{
+	char uniqueID[64];
+	sprintf(uniqueID, "hotswap%d", buttonID);
+
+	switch(category) {
+	case HOTSWAP_CAT_WEAPON:
+		HotSwapBind(uniqueID, va("%s %d\n", WEAPONBINDSTR, value));
+		break;
+	case HOTSWAP_CAT_ITEM:
+		assert(itemCommands[value]);
+		HotSwapBind(uniqueID, itemCommands[value]);
+		break;
+	case HOTSWAP_CAT_FORCE:
+		HotSwapBind(uniqueID, va("useGivenForce %d\n", value));
+		break;
+	default:
+		assert(0);
+	}
+}
+
diff --git a/code/client/cl_input_hotswap.h b/code/client/cl_input_hotswap.h
new file mode 100644
index 0000000..1047401
--- /dev/null
+++ b/code/client/cl_input_hotswap.h
@@ -0,0 +1,64 @@
+#ifndef __CL_INPUT_HOTSWAP_H
+#define __CL_INPUT_HOTSWAP_H
+
+
+#define HOTSWAP_ID_WHITE 0
+#define HOTSWAP_ID_BLACK 1
+
+#define HOTSWAP_CAT_WEAPON 0
+#define HOTSWAP_CAT_ITEM   1
+#define HOTSWAP_CAT_FORCE  2
+
+
+class HotSwapManager
+{
+private:
+	bool down;		//Is the button down?
+	bool noExec;	//Don't execute the button's bind.
+	bool noBind;	//Don't bind the button.
+	bool forceBound;//Is a force power currently bound?
+	int downTime;	//How long the button has been held down.
+	int bindTime;	//How long the button has been down with the selection up.
+	int uniqueID;	//Unique ID for this button.
+
+	//Return the binding for the button, or NULL if none.
+	char *GetBinding(void);
+
+	//Returns true if the weapon/force/item select screen is up.
+	bool HUDInBindState(void);
+
+	//Returns true if the weapon/force/item select screen is up.
+	bool ForceSelectUp(void);
+	bool WeaponSelectUp(void);
+	bool ItemSelectUp(void);
+
+	//Binds the button based on the current HUD selection.
+	void Bind(void);
+
+	//Execute the current bind, if there is one.
+	void Execute(void);
+
+	//Reset the object to the default state.
+	void Reset(void);
+
+public:
+	HotSwapManager(int uniqueID);
+
+	//Call every frame.  Uses cg.frametime to increment timers.
+	void Update(void);
+
+	//Set the button down or up.
+	void SetDown(void);
+	void SetUp(void);
+
+	//Returns true if the button is currently down.
+	bool ButtonDown(void) { return down; }
+};
+
+
+//External bind function for sharing with UI.
+extern void HotSwapBind(int buttonID, int category, int value);
+
+
+
+#endif
diff --git a/code/client/cl_keys.cpp b/code/client/cl_keys.cpp
new file mode 100644
index 0000000..a551e88
--- /dev/null
+++ b/code/client/cl_keys.cpp
@@ -0,0 +1,1478 @@
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+
+#include "client.h"
+#include "client_ui.h"
+
+/*
+
+key up events are sent even if in console mode
+
+*/
+
+
+field_t		chatField;
+
+qboolean	key_wastab;		// Hit tab once already? 
+char		keymatch_part[256];
+char		keymatch_last[256];
+
+keyGlobals_t	kg;										
+
+// do NOT blithely change any of the key names (3rd field) here, since they have to match the key binds
+//	in the CFG files, they're also prepended with "KEYNAME_" when looking up StripEd references
+//
+keyname_t keynames[MAX_KEYS] =							
+{														
+	{ 0x00, 0x00, NULL, A_NULL, false									},					  
+	{ 0x01, 0x01, "SHIFT", A_SHIFT, false 								},					       
+	{ 0x02, 0x02, "CTRL", A_CTRL, false   								},					       
+	{ 0x03, 0x03, "ALT", A_ALT, false									},					       
+	{ 0x04, 0x04, "CAPSLOCK", A_CAPSLOCK, false							},					       
+	{ 0x05, 0x05, "KP_NUMLOCK", A_NUMLOCK, false						},					       
+	{ 0x06, 0x06, "SCROLLLOCK", A_SCROLLLOCK, false						},					       
+	{ 0x07, 0x07, "PAUSE", A_PAUSE, false								},					       
+	{ 0x08, 0x08, "BACKSPACE", A_BACKSPACE, false						},					       
+	{ 0x09, 0x09, "TAB", A_TAB, false									},					       
+	{ 0x0a, 0x0a, "ENTER", A_ENTER, false								},					       
+	{ 0x0b, 0x0b, "KP_PLUS", A_KP_PLUS, false							},					       
+	{ 0x0c, 0x0c, "KP_MINUS", A_KP_MINUS, false							},					       
+	{ 0x0d, 0x0d, "KP_ENTER", A_KP_ENTER, false							},					       
+	{ 0x0e, 0x0e, "KP_DEL", A_KP_PERIOD, false							},					       
+	{ 0x0f, 0x0f, NULL, A_PRINTSCREEN, false							},
+	{ 0x10, 0x10, "KP_INS", A_KP_0, false								},					       
+	{ 0x11, 0x11, "KP_END", A_KP_1, false								},					       
+	{ 0x12, 0x12, "KP_DOWNARROW", A_KP_2, false							},					       
+	{ 0x13, 0x13, "KP_PGDN", A_KP_3, false								},					       
+	{ 0x14, 0x14, "KP_LEFTARROW", A_KP_4, false							},					       
+	{ 0x15, 0x15, "KP_5", A_KP_5, false									},					       
+	{ 0x16, 0x16, "KP_RIGHTARROW", A_KP_6, false						},					       
+	{ 0x17, 0x17, "KP_HOME", A_KP_7, false								},					       
+	{ 0x18, 0x18, "KP_UPARROW", A_KP_8, false							},					       
+	{ 0x19, 0x19, "KP_PGUP", A_KP_9, false								},					       
+	{ 0x1a, 0x1a, "CONSOLE", A_CONSOLE, false 							},					       
+	{ 0x1b, 0x1b, "ESCAPE", A_ESCAPE, false								},					       
+	{ 0x1c, 0x1c, "F1", A_F1, true										},					       
+	{ 0x1d, 0x1d, "F2", A_F2, true										},					       
+	{ 0x1e, 0x1e, "F3", A_F3, true										},					       
+	{ 0x1f, 0x1f, "F4", A_F4, true										},					       
+			    													        
+	{ 0x20, 0x20, "SPACE", A_SPACE, false								},
+	{ (word)'!', (word)'!', NULL, A_PLING, false		  				},
+	{ (word)'"', (word)'"', NULL, A_DOUBLE_QUOTE, false  				},
+	{ (word)'#', (word)'#', NULL, A_HASH, false		  					},
+	{ (word)'$', (word)'$', NULL, A_STRING, false						},
+	{ (word)'%', (word)'%', NULL, A_PERCENT, false						},
+	{ (word)'&', (word)'&', NULL, A_AND, false							},
+	{ 0x27, 0x27, NULL, A_SINGLE_QUOTE, false							},
+	{ (word)'(', (word)'(', NULL, A_OPEN_BRACKET, false					},
+	{ (word)')', (word)')', NULL, A_CLOSE_BRACKET, false				},
+	{ (word)'*', (word)'*', NULL, A_STAR, false							},
+	{ (word)'+', (word)'+', NULL, A_PLUS, false							},
+	{ (word)',', (word)',', NULL, A_COMMA, false						},
+	{ (word)'-', (word)'-', NULL, A_MINUS, false						},
+	{ (word)'.', (word)'.', NULL, A_PERIOD, false						},
+	{ (word)'/', (word)'/', NULL, A_FORWARD_SLASH, false				},
+	{ (word)'0', (word)'0', NULL, A_0, false							},
+	{ (word)'1', (word)'1', NULL, A_1, false							},
+	{ (word)'2', (word)'2', NULL, A_2, false							},
+	{ (word)'3', (word)'3', NULL, A_3, false							},
+	{ (word)'4', (word)'4', NULL, A_4, false							},
+	{ (word)'5', (word)'5', NULL, A_5, false							},
+	{ (word)'6', (word)'6', NULL, A_6, false							},
+	{ (word)'7', (word)'7', NULL, A_7, false							},
+	{ (word)'8', (word)'8', NULL, A_8, false							},
+	{ (word)'9', (word)'9', NULL, A_9, false							},
+	{ (word)':', (word)':', NULL, A_COLON, false						},
+	{ (word)';', (word)';', "SEMICOLON", A_SEMICOLON, false				},
+	{ (word)'<', (word)'<', NULL, A_LESSTHAN, false						},
+	{ (word)'=', (word)'=', NULL, A_EQUALS, false						},
+	{ (word)'>', (word)'>', NULL, A_GREATERTHAN, false					},
+	{ (word)'?', (word)'?', NULL, A_QUESTION, false						},
+			    													
+	{ (word)'@', (word)'@', NULL, A_AT, false							},	   	            
+	{ (word)'A', (word)'a', NULL, A_CAP_A, false						},		            
+	{ (word)'B', (word)'b', NULL, A_CAP_B, false						},		            
+	{ (word)'C', (word)'c', NULL, A_CAP_C, false						},		            
+	{ (word)'D', (word)'d', NULL, A_CAP_D, false						},		            
+	{ (word)'E', (word)'e', NULL, A_CAP_E, false						},		            
+	{ (word)'F', (word)'f', NULL, A_CAP_F, false						},		            
+	{ (word)'G', (word)'g', NULL, A_CAP_G, false						},		            
+	{ (word)'H', (word)'h', NULL, A_CAP_H, false						},		            
+	{ (word)'I', (word)'i', NULL, A_CAP_I, false						},		            
+	{ (word)'J', (word)'j', NULL, A_CAP_J, false						},		            
+	{ (word)'K', (word)'k', NULL, A_CAP_K, false						},		            
+	{ (word)'L', (word)'l', NULL, A_CAP_L, false						},		            
+	{ (word)'M', (word)'m', NULL, A_CAP_M, false						},		            
+	{ (word)'N', (word)'n', NULL, A_CAP_N, false						},		            
+	{ (word)'O', (word)'o', NULL, A_CAP_O, false						},		            
+	{ (word)'P', (word)'p', NULL, A_CAP_P, false						},		            
+	{ (word)'Q', (word)'q', NULL, A_CAP_Q, false						},		            
+	{ (word)'R', (word)'r', NULL, A_CAP_R, false						},		            
+	{ (word)'S', (word)'s', NULL, A_CAP_S, false						},		            
+	{ (word)'T', (word)'t', NULL, A_CAP_T, false						},		            
+	{ (word)'U', (word)'u', NULL, A_CAP_U, false						},		            
+	{ (word)'V', (word)'v', NULL, A_CAP_V, false						},		            
+	{ (word)'W', (word)'w', NULL, A_CAP_W, false						},		            
+	{ (word)'X', (word)'x', NULL, A_CAP_X, false						},		            
+	{ (word)'Y', (word)'y', NULL, A_CAP_Y, false						},		            
+	{ (word)'Z', (word)'z', NULL, A_CAP_Z, false						},		            
+	{ (word)'[', (word)'[', NULL, A_OPEN_SQUARE, false					},					    
+	{ 0x5c, 0x5c, NULL, A_BACKSLASH, false								},					    
+	{ (word)']', (word)']', NULL, A_CLOSE_SQUARE, false 				},					    
+	{ (word)'^', (word)'^', NULL, A_CARET, false		 				},					    
+	{ (word)'_', (word)'_', NULL, A_UNDERSCORE, false					},					    
+			    													   
+	{ 0x60, 0x60, NULL, A_LEFT_SINGLE_QUOTE, false						},
+	{ (word)'A', (word)'a', NULL, A_LOW_A, false						},           
+	{ (word)'B', (word)'b', NULL, A_LOW_B, false						},           
+	{ (word)'C', (word)'c', NULL, A_LOW_C, false						},           
+	{ (word)'D', (word)'d', NULL, A_LOW_D, false						},           
+	{ (word)'E', (word)'e', NULL, A_LOW_E, false						},           
+	{ (word)'F', (word)'f', NULL, A_LOW_F, false						},           
+	{ (word)'G', (word)'g', NULL, A_LOW_G, false						},           
+	{ (word)'H', (word)'h', NULL, A_LOW_H, false						},           
+	{ (word)'I', (word)'i', NULL, A_LOW_I, false						},           
+	{ (word)'J', (word)'j', NULL, A_LOW_J, false						},           
+	{ (word)'K', (word)'k', NULL, A_LOW_K, false						},           
+	{ (word)'L', (word)'l', NULL, A_LOW_L, false						},           
+	{ (word)'M', (word)'m', NULL, A_LOW_M, false						},           
+	{ (word)'N', (word)'n', NULL, A_LOW_N, false						},           
+	{ (word)'O', (word)'o', NULL, A_LOW_O, false						},           
+	{ (word)'P', (word)'p', NULL, A_LOW_P, false						},           
+	{ (word)'Q', (word)'q', NULL, A_LOW_Q, false						},           
+	{ (word)'R', (word)'r', NULL, A_LOW_R, false						},           
+	{ (word)'S', (word)'s', NULL, A_LOW_S, false						},           
+	{ (word)'T', (word)'t', NULL, A_LOW_T, false						},           
+	{ (word)'U', (word)'u', NULL, A_LOW_U, false						},           
+	{ (word)'V', (word)'v', NULL, A_LOW_V, false						},           
+	{ (word)'W', (word)'w', NULL, A_LOW_W, false						},           
+	{ (word)'X', (word)'x', NULL, A_LOW_X, false						},           
+	{ (word)'Y', (word)'y', NULL, A_LOW_Y, false						},           
+	{ (word)'Z', (word)'z', NULL, A_LOW_Z, false						},           
+	{ (word)'{', (word)'{', NULL, A_OPEN_BRACE, false					},
+	{ (word)'|', (word)'|', NULL, A_BAR, false							},
+	{ (word)'}', (word)'}', NULL, A_CLOSE_BRACE, false					},
+	{ (word)'~', (word)'~', NULL, A_TILDE, false						},
+	{ 0x7f, 0x7f, "DEL", A_DELETE, false								},
+			    													               
+	{ 0x80, 0x80, "EURO", A_EURO, false  								},
+	{ 0x81, 0x81, "SHIFT", A_SHIFT2, false								},
+	{ 0x82, 0x82, "CTRL", A_CTRL2, false								},
+	{ 0x83, 0x83, "ALT", A_ALT2, false									},
+	{ 0x84, 0x84, "F5", A_F5, true										},
+	{ 0x85, 0x85, "F6", A_F6, true										},
+	{ 0x86, 0x86, "F7", A_F7, true										},
+	{ 0x87, 0x87, "F8", A_F8, true										},
+	{ 0x88, 0x88, "CIRCUMFLEX", A_CIRCUMFLEX, false  					},
+	{ 0x89, 0x89, "MWHEELUP", A_MWHEELUP, false							},
+	{ 0x8a, 0x9a, NULL, A_CAP_SCARON, false								},	// ******
+	{ 0x8b, 0x8b, "MWHEELDOWN", A_MWHEELDOWN, false						},
+	{ 0x8c, 0x9c, NULL, A_CAP_OE, false									},	// ******
+	{ 0x8d, 0x8d, "MOUSE1", A_MOUSE1, false								},
+	{ 0x8e, 0x8e, "MOUSE2", A_MOUSE2, false								},
+	{ 0x8f, 0x8f, "INS", A_INSERT, false								},
+	{ 0x90, 0x90, "HOME", A_HOME, false									},
+	{ 0x91, 0x91, "PGUP", A_PAGE_UP, false								},
+	{ 0x92, 0x92, NULL, A_RIGHT_SINGLE_QUOTE, false						},
+	{ 0x93, 0x93, NULL, A_LEFT_DOUBLE_QUOTE, false						},
+	{ 0x94, 0x94, NULL, A_RIGHT_DOUBLE_QUOTE, false						},
+	{ 0x95, 0x95, "F9", A_F9, true										},
+	{ 0x96, 0x96, "F10", A_F10, true									},
+	{ 0x97, 0x97, "F11", A_F11, true									},
+	{ 0x98, 0x98, "F12", A_F12, true									},
+	{ 0x99, 0x99, NULL, A_TRADEMARK, false								},
+	{ 0x8a, 0x9a, NULL, A_LOW_SCARON, false								},	// ******
+	{ 0x9b, 0x9b, "SHIFT_ENTER", A_ENTER, false							},
+	{ 0x8c, 0x9c, NULL, A_LOW_OE, false									},	// ******
+	{ 0x9d, 0x9d, "END", A_END, false									},
+	{ 0x9e, 0x9e, "PGDN", A_PAGE_DOWN, false							},
+	{ 0x9f, 0xff, NULL, A_CAP_YDIERESIS, false							},	// ******
+			    													
+	{ 0xa0, 0,	  "SHIFT_SPACE", A_SPACE, false							},
+	{ 0xa1, 0xa1, NULL, A_EXCLAMDOWN, false								},	// upside down '!' - undisplayable
+	{ (word)(byte)'¢', (word)(byte)'¢', NULL, A_CENT, false	  			},
+	{ (word)(byte)'£', (word)(byte)'£', NULL, A_POUND, false	  		},
+	{ 0xa4, 0,    "SHIFT_KP_ENTER", A_KP_ENTER, false					},
+	{ (word)(byte)'¥', (word)(byte)'¥', NULL, A_YEN, false		  		},
+	{ 0xa6, 0xa6, "MOUSE3", A_MOUSE3, false								},
+	{ 0xa7, 0xa7, "MOUSE4", A_MOUSE4, false								},
+	{ 0xa8, 0xa8, "MOUSE5", A_MOUSE5, false								},
+	{ (word)(byte)'©', (word)(byte)'©', NULL, A_COPYRIGHT, false 		},
+	{ 0xaa, 0xaa, "UPARROW", A_CURSOR_UP, false							},
+	{ 0xab, 0xab, "DOWNARROW", A_CURSOR_DOWN, false						},
+	{ 0xac, 0xac, "LEFTARROW", A_CURSOR_LEFT, false						},
+	{ 0xad, 0xad, "RIGHTARROW", A_CURSOR_RIGHT, false					},
+	{ (word)(byte)'®', (word)(byte)'®', NULL, A_REGISTERED, false		},
+	{ 0xaf, 0,	  NULL, A_UNDEFINED_7, false							},
+	{ 0xb0, 0,	  NULL, A_UNDEFINED_8, false							},
+	{ 0xb1, 0,	  NULL, A_UNDEFINED_9, false							},
+	{ 0xb2, 0,	  NULL, A_UNDEFINED_10, false							},
+	{ 0xb3, 0,	  NULL, A_UNDEFINED_11, false							},
+	{ 0xb4, 0,	  NULL, A_UNDEFINED_12, false							},
+	{ 0xb5, 0,	  NULL, A_UNDEFINED_13, false							},
+	{ 0xb6, 0,	  NULL, A_UNDEFINED_14, false							},
+	{ 0xb7, 0,	  NULL, A_UNDEFINED_15, false							},
+	{ 0xb8, 0,	  NULL, A_UNDEFINED_16, false							},
+	{ 0xb9, 0,	  NULL, A_UNDEFINED_17, false							},
+	{ 0xba, 0,	  NULL, A_UNDEFINED_18, false							},
+	{ 0xbb, 0,	  NULL, A_UNDEFINED_19, false							},
+	{ 0xbc, 0,	  NULL, A_UNDEFINED_20, false							},
+	{ 0xbd, 0,	  NULL, A_UNDEFINED_21, false							},
+	{ 0xbe, 0,	  NULL, A_UNDEFINED_22, false							},
+	{ (word)(byte)'¿', (word)(byte)'¿', NULL, A_QUESTION_DOWN, false	},
+			    		                       
+	{ (word)(byte)'À', (word)(byte)'à', NULL, A_CAP_AGRAVE, false		},
+	{ (word)(byte)'Á', (word)(byte)'á', NULL, A_CAP_AACUTE, false		},
+	{ (word)(byte)'Â', (word)(byte)'â', NULL, A_CAP_ACIRCUMFLEX, false	},
+	{ (word)(byte)'Ã', (word)(byte)'ã', NULL, A_CAP_ATILDE, false		},
+	{ (word)(byte)'Ä', (word)(byte)'ä', NULL, A_CAP_ADIERESIS, false	},
+	{ (word)(byte)'Å', (word)(byte)'å', NULL, A_CAP_ARING, false		},
+	{ (word)(byte)'Æ', (word)(byte)'æ', NULL, A_CAP_AE, false			},
+	{ (word)(byte)'Ç', (word)(byte)'ç', NULL, A_CAP_CCEDILLA, false		},
+	{ (word)(byte)'È', (word)(byte)'è', NULL, A_CAP_EGRAVE, false		},
+	{ (word)(byte)'É', (word)(byte)'é', NULL, A_CAP_EACUTE, false		},
+	{ (word)(byte)'Ê', (word)(byte)'ê', NULL, A_CAP_ECIRCUMFLEX, false	},
+	{ (word)(byte)'Ë', (word)(byte)'ë', NULL, A_CAP_EDIERESIS, false	},
+	{ (word)(byte)'Ì', (word)(byte)'ì', NULL, A_CAP_IGRAVE, false		},
+	{ (word)(byte)'Í', (word)(byte)'í', NULL, A_CAP_IACUTE, false		},
+	{ (word)(byte)'Î', (word)(byte)'î', NULL, A_CAP_ICIRCUMFLEX, false	},
+	{ (word)(byte)'Ï', (word)(byte)'ï', NULL, A_CAP_IDIERESIS, false	},
+	{ (word)(byte)'Ð', (word)(byte)'ð', NULL, A_CAP_ETH, false			},
+	{ (word)(byte)'Ñ', (word)(byte)'ñ', NULL, A_CAP_NTILDE, false		},
+	{ (word)(byte)'Ò', (word)(byte)'ò', NULL, A_CAP_OGRAVE, false		},
+	{ (word)(byte)'Ó', (word)(byte)'ó', NULL, A_CAP_OACUTE, false		},
+	{ (word)(byte)'Ô', (word)(byte)'ô', NULL, A_CAP_OCIRCUMFLEX, false	},
+	{ (word)(byte)'Õ', (word)(byte)'õ', NULL, A_CAP_OTILDE, false		},
+	{ (word)(byte)'Ö', (word)(byte)'ö', NULL, A_CAP_ODIERESIS, false	},
+	{ (word)(byte)'×', (word)(byte)'×', "KP_STAR", A_MULTIPLY, false 	},
+	{ (word)(byte)'Ø', (word)(byte)'ø', NULL, A_CAP_OSLASH, false		},  
+	{ (word)(byte)'Ù', (word)(byte)'ù', NULL, A_CAP_UGRAVE, false		},  
+	{ (word)(byte)'Ú', (word)(byte)'ú', NULL, A_CAP_UACUTE, false		},  
+	{ (word)(byte)'Û', (word)(byte)'û', NULL, A_CAP_UCIRCUMFLEX, false	},  
+	{ (word)(byte)'Ü', (word)(byte)'ü', NULL, A_CAP_UDIERESIS, false	},  
+	{ (word)(byte)'Ý', (word)(byte)'ý', NULL, A_CAP_YACUTE, false		},  
+	{ (word)(byte)'Þ', (word)(byte)'þ', NULL, A_CAP_THORN, false		},  
+	{ (word)(byte)'ß', (word)(byte)'ß', NULL, A_GERMANDBLS, false 		},
+			    		                       
+	{ (word)(byte)'À', (word)(byte)'à', NULL, A_LOW_AGRAVE, false		},		 
+	{ (word)(byte)'Á', (word)(byte)'á', NULL, A_LOW_AACUTE, false		},		 
+	{ (word)(byte)'Â', (word)(byte)'â', NULL, A_LOW_ACIRCUMFLEX, false	},		 
+	{ (word)(byte)'Ã', (word)(byte)'ã', NULL, A_LOW_ATILDE, false		},		 
+	{ (word)(byte)'Ä', (word)(byte)'ä', NULL, A_LOW_ADIERESIS, false	},		 
+	{ (word)(byte)'Å', (word)(byte)'å', NULL, A_LOW_ARING, false		},		 
+	{ (word)(byte)'Æ', (word)(byte)'æ', NULL, A_LOW_AE, false			},		 
+	{ (word)(byte)'Ç', (word)(byte)'ç', NULL, A_LOW_CCEDILLA, false		},		 
+	{ (word)(byte)'È', (word)(byte)'è', NULL, A_LOW_EGRAVE, false		},		 
+	{ (word)(byte)'É', (word)(byte)'é', NULL, A_LOW_EACUTE, false		},		 
+	{ (word)(byte)'Ê', (word)(byte)'ê', NULL, A_LOW_ECIRCUMFLEX, false	},		 
+	{ (word)(byte)'Ë', (word)(byte)'ë', NULL, A_LOW_EDIERESIS, false	},		 
+	{ (word)(byte)'Ì', (word)(byte)'ì', NULL, A_LOW_IGRAVE, false		},		 
+	{ (word)(byte)'Í', (word)(byte)'í', NULL, A_LOW_IACUTE, false		},		 
+	{ (word)(byte)'Î', (word)(byte)'î', NULL, A_LOW_ICIRCUMFLEX, false	},		 
+	{ (word)(byte)'Ï', (word)(byte)'ï', NULL, A_LOW_IDIERESIS, false	},		 
+	{ (word)(byte)'Ð', (word)(byte)'ð', NULL, A_LOW_ETH, false			},		 
+	{ (word)(byte)'Ñ', (word)(byte)'ñ', NULL, A_LOW_NTILDE, false		},		 
+	{ (word)(byte)'Ò', (word)(byte)'ò', NULL, A_LOW_OGRAVE, false		},		 
+	{ (word)(byte)'Ó', (word)(byte)'ó', NULL, A_LOW_OACUTE, false		},		 
+	{ (word)(byte)'Ô', (word)(byte)'ô', NULL, A_LOW_OCIRCUMFLEX, false	},		 
+	{ (word)(byte)'Õ', (word)(byte)'õ', NULL, A_LOW_OTILDE, false		},		 
+	{ (word)(byte)'Ö', (word)(byte)'ö', NULL, A_LOW_ODIERESIS, false	},		 
+	{ (word)(byte)'÷', (word)(byte)'÷', "KP_SLASH", A_DIVIDE, false 	},		 
+	{ (word)(byte)'Ø', (word)(byte)'ø', NULL, A_LOW_OSLASH, false		},		 
+	{ (word)(byte)'Ù', (word)(byte)'ù', NULL, A_LOW_UGRAVE, false		},		 
+	{ (word)(byte)'Ú', (word)(byte)'ú', NULL, A_LOW_UACUTE, false		},		 
+	{ (word)(byte)'Û', (word)(byte)'û', NULL, A_LOW_UCIRCUMFLEX, false	},		 
+	{ (word)(byte)'Ü', (word)(byte)'ü', NULL, A_LOW_UDIERESIS, false	},		 
+	{ (word)(byte)'Ý', (word)(byte)'ý', NULL, A_LOW_YACUTE, false		},		 
+	{ (word)(byte)'Þ', (word)(byte)'þ', NULL, A_LOW_THORN, false		},		 
+	{ 0x9f, 0xff, NULL, A_LOW_YDIERESIS, false							},	// *******
+																		
+	{ 0x100, 0x100, "JOY0", A_JOY0, false								},
+	{ 0x101, 0x101, "JOY1", A_JOY1, false								},
+	{ 0x102, 0x102, "JOY2", A_JOY2, false								},
+	{ 0x103, 0x103, "JOY3", A_JOY3, false								},
+	{ 0x104, 0x104, "JOY4", A_JOY4, false								},
+	{ 0x105, 0x105, "JOY5", A_JOY5, false								},
+	{ 0x106, 0x106, "JOY6", A_JOY6, false								},
+	{ 0x107, 0x107, "JOY7", A_JOY7, false								},
+	{ 0x108, 0x108, "JOY8", A_JOY8, false								},
+	{ 0x109, 0x109, "JOY9", A_JOY9, false								},
+	{ 0x10a, 0x10a, "JOY10", A_JOY10, false								},
+	{ 0x10b, 0x10b, "JOY11", A_JOY11, false								},
+	{ 0x10c, 0x10c, "JOY12", A_JOY12, false								},
+	{ 0x10d, 0x10d, "JOY13", A_JOY13, false								},
+	{ 0x10e, 0x10e, "JOY14", A_JOY14, false								},
+	{ 0x10f, 0x10f, "JOY15", A_JOY15, false								},
+	{ 0x110, 0x110, "JOY16", A_JOY16, false								},
+	{ 0x111, 0x111, "JOY17", A_JOY17, false								},
+	{ 0x112, 0x112, "JOY18", A_JOY18, false								},
+	{ 0x113, 0x113, "JOY19", A_JOY19, false								},
+	{ 0x114, 0x114, "JOY20", A_JOY20, false								},
+	{ 0x115, 0x115, "JOY21", A_JOY21, false								},
+	{ 0x116, 0x116, "JOY22", A_JOY22, false								},
+	{ 0x117, 0x117, "JOY23", A_JOY23, false								},
+	{ 0x118, 0x118, "JOY24", A_JOY24, false								},
+	{ 0x119, 0x119, "JOY25", A_JOY25, false								},
+	{ 0x11a, 0x11a, "JOY26", A_JOY26, false								},
+	{ 0x11b, 0x11b, "JOY27", A_JOY27, false								},
+	{ 0x11c, 0x11c, "JOY28", A_JOY28, false								},
+	{ 0x11d, 0x11d, "JOY29", A_JOY29, false								},
+	{ 0x11e, 0x11e, "JOY30", A_JOY30, false								},
+	{ 0x11f, 0x11f, "JOY31", A_JOY31, false								},
+		    	    												
+	{ 0x120, 0x120, "AUX0", A_AUX0, false								},
+	{ 0x121, 0x121, "AUX1", A_AUX1, false								},
+	{ 0x122, 0x122, "AUX2", A_AUX2, false								},
+	{ 0x123, 0x123, "AUX3", A_AUX3, false								},
+	{ 0x124, 0x124, "AUX4", A_AUX4, false								},
+	{ 0x125, 0x125, "AUX5", A_AUX5, false								},
+	{ 0x126, 0x126, "AUX6", A_AUX6, false								},
+	{ 0x127, 0x127, "AUX7", A_AUX7, false								},
+	{ 0x128, 0x128, "AUX8", A_AUX8, false								},
+	{ 0x129, 0x129, "AUX9", A_AUX9, false								},
+	{ 0x12a, 0x12a, "AUX10", A_AUX10, false								},
+	{ 0x12b, 0x12b, "AUX11", A_AUX11, false								},
+	{ 0x12c, 0x12c, "AUX12", A_AUX12, false								},
+	{ 0x12d, 0x12d, "AUX13", A_AUX13, false								},
+	{ 0x12e, 0x12e, "AUX14", A_AUX14, false								},
+	{ 0x12f, 0x12f, "AUX15", A_AUX15, false								},
+	{ 0x130, 0x130, "AUX16", A_AUX16, false								},
+	{ 0x131, 0x131, "AUX17", A_AUX17, false								},
+	{ 0x132, 0x132, "AUX18", A_AUX18, false								},
+	{ 0x133, 0x133, "AUX19", A_AUX19, false								},
+	{ 0x134, 0x134, "AUX20", A_AUX20, false								},
+	{ 0x135, 0x135, "AUX21", A_AUX21, false								},
+	{ 0x136, 0x136, "AUX22", A_AUX22, false								},
+	{ 0x137, 0x137, "AUX23", A_AUX23, false								},
+	{ 0x138, 0x138, "AUX24", A_AUX24, false								},
+	{ 0x139, 0x139, "AUX25", A_AUX25, false								},
+	{ 0x13a, 0x13a, "AUX26", A_AUX26, false								},
+	{ 0x13b, 0x13b, "AUX27", A_AUX27, false								},
+	{ 0x13c, 0x13c, "AUX28", A_AUX28, false								},
+	{ 0x13d, 0x13d, "AUX29", A_AUX29, false								},
+	{ 0x13e, 0x13e, "AUX30", A_AUX30, false								},
+	{ 0x13f, 0x13f, "AUX31", A_AUX31, false								}
+};
+
+
+
+
+/*
+===================
+Field_Draw
+
+Handles horizontal scrolling and cursor blinking
+x, y, amd width are in pixels
+===================
+*/
+void Field_VariableSizeDraw( field_t *edit, int x, int y, int width, int size, qboolean showCursor ) {
+	int		len;
+	int		drawLen;
+	int		prestep;
+	int		cursorChar;
+	char	str[MAX_STRING_CHARS];
+	int		i;
+
+	drawLen = edit->widthInChars;
+	len = strlen( edit->buffer ) + 1;
+
+	// guarantee that cursor will be visible
+	if ( len <= drawLen ) {
+		prestep = 0;
+	} else {
+		if ( edit->scroll + drawLen > len ) {
+			edit->scroll = len - drawLen;
+			if ( edit->scroll < 0 ) {
+				edit->scroll = 0;
+			}
+		}
+		prestep = edit->scroll;
+/*
+		if ( edit->cursor < len - drawLen ) {
+			prestep = edit->cursor;	// cursor at start
+		} else {
+			prestep = len - drawLen;
+		}
+*/
+	}
+
+	if ( prestep + drawLen > len ) {
+		drawLen = len - prestep;
+	}
+
+
+	// extract <drawLen> characters from the field at <prestep>
+	if ( drawLen >= MAX_STRING_CHARS ) {
+		Com_Error( ERR_DROP, "drawLen >= MAX_STRING_CHARS" );
+	}
+	memcpy( str, edit->buffer + prestep, drawLen );
+	str[ drawLen ] = 0;
+
+	// draw it
+	if ( size == SMALLCHAR_WIDTH ) {
+		for ( i = 0 ; i < drawLen-1 ; i++ ) {
+			SCR_DrawSmallChar( x + i * SMALLCHAR_WIDTH, y, str[i] );
+		}
+	} else {
+		// draw big string with drop shadow
+		SCR_DrawBigString( x, y, str, 1.0 );
+	}
+
+	// draw the cursor
+	if ( !showCursor ) {
+		return;
+	}
+
+	if ( (int)( cls.realtime >> 8 ) & 1 ) {
+		return;		// off blink
+	}
+
+	if ( kg.key_overstrikeMode ) {
+		cursorChar = 11;
+	} else {
+		cursorChar = 10;
+	}
+	if ( size == SMALLCHAR_WIDTH ) {
+		SCR_DrawSmallChar( x + ( edit->cursor - prestep ) * size, y, cursorChar );
+	} else {
+		str[0] = cursorChar;
+		str[1] = 0;
+		SCR_DrawBigString( x + ( edit->cursor - prestep ) * size, y, str, 1.0 );
+	}
+}
+
+void Field_Draw( field_t *edit, int x, int y, int width, qboolean showCursor ) 
+{
+	Field_VariableSizeDraw( edit, x, y, width, SMALLCHAR_WIDTH, showCursor );
+}
+
+void Field_BigDraw( field_t *edit, int x, int y, int width, qboolean showCursor ) 
+{
+	Field_VariableSizeDraw( edit, x, y, width, BIGCHAR_WIDTH, showCursor );
+}
+
+/*
+================
+Field_Paste
+================
+*/
+void Field_CharEvent( field_t *edit, unsigned int ch );
+void Field_Paste( field_t *edit ) {
+	char	*cbd;
+	int		pasteLen, i;
+
+	cbd = Sys_GetClipboardData();
+
+	if ( !cbd ) {
+		return;
+	}
+
+	// send as if typed, so insert / overstrike works properly
+	pasteLen = strlen( cbd );
+	for ( i = 0 ; i < pasteLen ; i++ ) {
+		Field_CharEvent( edit, cbd[i] );
+	}
+
+	Z_Free( cbd );
+}
+
+/*
+=================
+Field_KeyDownEvent
+
+Performs the basic line editing functions for the console,
+in-game talk, and menu fields
+
+Key events are used for non-printable characters, others are gotten from char events.
+=================
+*/
+void Field_KeyDownEvent( field_t *edit, int key ) {
+	int		len;
+
+	// shift-insert is paste
+	if ( ( key == A_INSERT ) && kg.keys[A_SHIFT].down ) 
+	{
+		Field_Paste( edit );
+		return;
+	}
+
+	len = strlen( edit->buffer );
+
+	if ( key == A_DELETE ) {
+		if ( edit->cursor < len ) {
+			memmove( edit->buffer + edit->cursor, 
+				edit->buffer + edit->cursor + 1, len - edit->cursor );
+		}
+		return;
+	}
+
+	if ( key == A_CURSOR_RIGHT ) 
+	{
+		if ( edit->cursor < len ) {
+			edit->cursor++;
+		}
+		if ( edit->cursor >= edit->scroll + edit->widthInChars && edit->cursor <= len )
+		{
+			edit->scroll++;
+		}
+		return;
+	}
+
+	if ( key == A_CURSOR_LEFT ) 
+	{
+		if ( edit->cursor > 0 ) {
+			edit->cursor--;
+		}
+		if ( edit->cursor < edit->scroll )
+		{
+			edit->scroll--;
+		}
+		return;
+	}
+
+	if ( key == A_HOME || ( keynames[key].lower == 'a' && kg.keys[A_CTRL].down ) ) 
+	{
+		edit->cursor = 0;
+		return;
+	}
+
+	if ( key == A_END || ( keynames[key].lower == 'e' && kg.keys[A_CTRL].down ) ) 
+	{
+		edit->cursor = len;
+		return;
+	}
+
+	if ( key == A_INSERT ) 
+	{
+		kg.key_overstrikeMode = !kg.key_overstrikeMode;
+		return;
+	}
+}
+
+/*
+==================
+Field_CharEvent
+==================
+*/
+void Field_CharEvent( field_t *edit, unsigned int ch ) {
+	int		len;
+
+	if ( ch == 'v' - 'a' + 1 ) {	// ctrl-v is paste
+		Field_Paste( edit );
+		return;
+	}
+
+	if ( ch == 'c' - 'a' + 1 ) {	// ctrl-c clears the field
+		Field_Clear( edit );
+		return;
+	}
+
+	len = strlen( edit->buffer );
+
+	if ( ch == 'h' - 'a' + 1 )	{	// ctrl-h is backspace
+		if ( edit->cursor > 0 ) {
+			memmove( edit->buffer + edit->cursor - 1, 
+				edit->buffer + edit->cursor, len + 1 - edit->cursor );
+			edit->cursor--;
+			if ( edit->cursor < edit->scroll )
+			{
+				edit->scroll--;
+			}
+		}
+		return;
+	}
+
+	if ( ch == 'a' - 'a' + 1 ) {	// ctrl-a is home
+		edit->cursor = 0;
+		edit->scroll = 0;
+		return;
+	}
+
+	if ( ch == 'e' - 'a' + 1 ) {	// ctrl-e is end
+		edit->cursor = len;
+		edit->scroll = edit->cursor - edit->widthInChars;
+		return;
+	}
+
+	//
+	// ignore any other non printable chars
+	//
+	if ( ch < 32 ) {
+		return;
+	}
+
+	if ( kg.key_overstrikeMode ) {	
+		if ( edit->cursor == MAX_EDIT_LINE - 1 )
+			return;
+		edit->buffer[edit->cursor] = ch;
+		edit->cursor++;
+	} else {	// insert mode
+		if ( len == MAX_EDIT_LINE - 1 ) {
+			return; // all full
+		}
+		memmove( edit->buffer + edit->cursor + 1, 
+			edit->buffer + edit->cursor, len + 1 - edit->cursor );
+		edit->buffer[edit->cursor] = ch;
+		edit->cursor++;
+	}
+
+	if ( edit->cursor >= edit->widthInChars )
+	{
+		edit->scroll++;
+	}
+
+	if ( edit->cursor == len + 1) {
+		edit->buffer[edit->cursor] = 0;
+	}
+}
+
+/*
+==================
+Field_Clear
+==================
+*/
+void Field_Clear( field_t *edit ) {
+	edit->buffer[0] = 0;
+	edit->cursor = 0;
+	edit->scroll = 0;
+}
+
+/*
+=============================================================================
+
+CONSOLE LINE EDITING
+
+==============================================================================
+*/
+char *Cmd_CompleteCommandNext (char *partial, char *last);
+char *Cvar_CompleteVariableNext (char *partial, char *last);
+
+/*
+===============
+CompleteCommand
+
+Tab expansion
+===============
+*/
+void CompleteCommand( void ) 
+{
+	char		*cmd;
+	field_t	*edit;
+	static qboolean checking_cmd;
+
+	edit = &kg.g_consoleField;
+
+	if (key_wastab)
+	{
+		if (checking_cmd)			
+		{
+			cmd = Cmd_CompleteCommandNext(keymatch_part, keymatch_last);
+			if(!cmd)
+			{
+				checking_cmd = qfalse;  //go to checking variables
+				cmd = Cvar_CompleteVariableNext(keymatch_part, NULL);
+				if(!cmd)
+				{
+					checking_cmd = qtrue;  //go back to checking cmd
+					cmd = Cmd_CompleteCommandNext(keymatch_part, NULL);
+				}	
+			}	
+		}
+		else
+		{
+			cmd = Cvar_CompleteVariableNext(keymatch_part, keymatch_last);
+			if(!cmd)
+			{
+				checking_cmd = qtrue;  //go back to checking cmd
+				cmd = Cmd_CompleteCommandNext(keymatch_part, NULL);
+				if(!cmd)
+				{
+					checking_cmd = qfalse;  //go to checking variables
+					cmd = Cvar_CompleteVariableNext(keymatch_part, NULL);
+				}	
+			}	
+		}
+		if (cmd)
+		{
+			strcpy(keymatch_last, cmd);
+			key_wastab= qtrue;
+			Com_sprintf( edit->buffer, sizeof( edit->buffer ), "%s ", cmd );
+			edit->cursor = strlen( edit->buffer );
+			return;
+		}
+	}
+	else
+	{
+		strcpy(keymatch_part, edit->buffer);
+		checking_cmd = qtrue;
+		cmd = Cmd_CompleteCommand(edit->buffer);
+		if (!cmd)
+		{	//means no cmds, so check cvars only
+			checking_cmd= qfalse;
+			cmd = Cvar_CompleteVariable (edit->buffer);
+		}
+		if (cmd)
+		{
+			Com_sprintf( edit->buffer, sizeof( edit->buffer ), "%s ", cmd );
+			edit->cursor = strlen( edit->buffer );
+			strcpy(keymatch_last, cmd);
+			key_wastab= qtrue;
+			return;
+		}
+
+	}
+
+}
+
+
+/*
+====================
+Console_Key
+
+Handles history and console scrollback
+====================
+*/
+void Console_Key (int key) {
+	// ctrl-L clears screen
+	if ( keynames[ key ].lower == 'l' && kg.keys[A_CTRL].down ) {
+		Cbuf_AddText ("clear\n");
+		key_wastab = qfalse;	// For double tabbing on a cvar
+		return;
+	}
+
+/*	extern qboolean SwallowBadNumLockedKPKey( int iKey );
+	if (SwallowBadNumLockedKPKey(key)){
+		return;
+	}
+*/
+	// enter finishes the line
+	if ( key == A_ENTER || key == A_KP_ENTER ) {
+		Cbuf_AddText( kg.g_consoleField.buffer );	// valid command
+		Cbuf_AddText ("\n");
+		Com_Printf ( "]%s\n", kg.g_consoleField.buffer );
+
+		// copy line to history buffer
+		kg.historyEditLines[kg.nextHistoryLine % COMMAND_HISTORY] = kg.g_consoleField;
+		kg.nextHistoryLine++;
+		kg.historyLine = kg.nextHistoryLine;
+
+		Field_Clear( &kg.g_consoleField );
+		kg.g_consoleField.widthInChars = g_console_field_width;
+		if ( cls.state == CA_DISCONNECTED ) {
+			SCR_UpdateScreen ();	// force an update, because the command
+		}							// may take some time
+		key_wastab = qfalse;	// For double tabbing on a cvar
+		return;
+	}
+
+	// command completion
+
+	if (key == A_TAB) {
+		CompleteCommand();
+		return;
+	}
+
+	key_wastab = qfalse;	// For double tabbing on a cvar
+
+	// command history (ctrl-p ctrl-n for unix style)
+
+	if ( ( key == A_CURSOR_UP ) || ( ( keynames[ key ].lower == 'p' ) && kg.keys[A_CTRL].down ) ) 
+	{
+		if ( kg.nextHistoryLine - kg.historyLine < COMMAND_HISTORY && kg.historyLine > 0 ) 
+		{
+			kg.historyLine--;
+		}
+		kg.g_consoleField = kg.historyEditLines[ kg.historyLine % COMMAND_HISTORY ];
+		return;
+	}
+
+	if ( ( key == A_CURSOR_DOWN ) || ( ( keynames[ key ].lower == 'n' ) && kg.keys[A_CTRL].down ) ) 
+	{
+		if (kg.historyLine == kg.nextHistoryLine)
+			return;
+		kg.historyLine++;
+		kg.g_consoleField = kg.historyEditLines[ kg.historyLine % COMMAND_HISTORY ];
+		return;
+	}
+
+	// console scrolling
+	if ( key == A_PAGE_UP ) {
+		Con_PageUp();
+		return;
+	}
+
+	if ( key == A_PAGE_DOWN ) {
+		Con_PageDown();
+		return;
+	}
+
+	// ctrl-home = top of console
+	if ( key == A_HOME && kg.keys[A_CTRL].down ) 
+	{
+		Con_Top();
+		return;
+	}
+
+	// ctrl-end = bottom of console
+	if ( key == A_END && kg.keys[A_CTRL].down ) 
+	{
+		Con_Bottom();
+		return;
+	}
+
+	// pass to the normal editline routine
+	Field_KeyDownEvent( &kg.g_consoleField, key );
+}
+
+//============================================================================
+
+
+/*
+================
+Message_Key
+
+In game talk message
+================
+*/
+void Message_Key( int key ) {
+	char	buffer[MAX_STRING_CHARS];
+
+	if (key == A_ESCAPE) {
+		cls.keyCatchers &= ~KEYCATCH_MESSAGE;
+		Field_Clear( &chatField );
+		return;
+	}
+
+	if ( key == A_ENTER || key == A_KP_ENTER )
+	{
+		if ( chatField.buffer[0] && cls.state == CA_ACTIVE ) {
+			Com_sprintf( buffer, sizeof( buffer ), "say \"%s\"\n", chatField.buffer );
+
+			CL_AddReliableCommand( buffer );
+		}
+		cls.keyCatchers &= ~KEYCATCH_MESSAGE;
+		Field_Clear( &chatField );
+		return;
+	}
+
+	Field_KeyDownEvent( &chatField, key );
+}
+
+//============================================================================
+
+
+qboolean Key_GetOverstrikeMode( void ) {
+	return kg.key_overstrikeMode;
+}
+
+
+void Key_SetOverstrikeMode( qboolean state ) {
+	kg.key_overstrikeMode = state;
+}
+
+
+/*
+===================
+Key_IsDown
+===================
+*/
+qboolean Key_IsDown( int keynum ) {
+	if ( keynum == -1 ) {
+		return qfalse;
+	}
+
+	return kg.keys[ keynames[keynum].upper ].down;
+}
+
+
+/*
+===================
+Key_StringToKeynum
+
+Returns a key number to be used to index keys[] by looking at
+the given string.  Single ascii characters return themselves, while
+the K_* names are matched up.
+
+0x11 will be interpreted as raw hex, which will allow new controlers
+to be configured even if they don't have defined names.
+===================
+*/
+int Key_StringToKeynum( char *str ) {
+	int			i;
+	
+	if ( !str || !str[0] ) 
+	{
+		return -1;
+	}
+	// If single char bind, presume ascii char bind
+	if ( !str[1] ) 
+	{
+		return keynames[ (unsigned char)str[0] ].upper;
+	}
+
+	// scan for a text match
+	for ( i = 0 ; i < MAX_KEYS ; i++ ) 
+	{
+		if ( keynames[i].name && !stricmp( str, keynames[i].name ) )
+		{
+			return keynames[i].keynum;
+		}
+	}
+
+	// check for hex code
+	if ( str[0] == '0' && str[1] == 'x' && strlen( str ) == 4) 
+	{
+		int		n1, n2;
+		
+		n1 = str[2];
+		if ( n1 >= '0' && n1 <= '9' ) 
+		{
+			n1 -= '0';
+		}
+		else if ( n1 >= 'A' && n1 <= 'F' ) 
+		{
+			n1 = n1 - 'A' + 10;
+		}
+		else 
+		{
+			n1 = 0;
+		}
+
+		n2 = str[3];
+		if ( n2 >= '0' && n2 <= '9' ) 
+		{
+			n2 -= '0';
+		}
+		else if ( n2 >= 'A' && n2 <= 'F' ) 
+		{
+			n2 = n2 - 'A' + 10;
+		}
+		else 
+		{
+			n2 = 0;
+		}
+		return n1 * 16 + n2;
+	}
+
+	return -1;
+}
+
+
+static char tinyString[16];
+static const char *Key_KeynumValid( int keynum )
+{
+	if ( keynum == -1 ) 
+	{
+		return "<KEY NOT FOUND>";
+	}
+	if ( keynum < 0 || keynum >= MAX_KEYS ) 
+	{
+		return "<OUT OF RANGE>";
+	}
+	return NULL;
+}
+
+static const char *Key_KeyToName( int keynum )
+{
+	return keynames[keynum].name;
+}
+
+
+static const char *Key_KeyToAscii( int keynum )
+{
+	if(!keynames[keynum].lower)
+	{
+		return(NULL);
+	}
+	if(keynum == A_SPACE)
+	{
+		tinyString[0] = (char)A_SHIFT_SPACE;
+	}
+	else if(keynum == A_ENTER)
+	{
+		tinyString[0] = (char)A_SHIFT_ENTER;
+	}
+	else if(keynum == A_KP_ENTER)
+	{
+		tinyString[0] = (char)A_SHIFT_KP_ENTER;
+	}
+	else
+	{
+		tinyString[0] = keynames[keynum].upper;
+	}
+	tinyString[1] = 0;
+	return tinyString;
+}
+
+static const char *Key_KeyToHex( int keynum )
+{
+	int		i, j;
+
+	i = keynum >> 4;
+	j = keynum & 15;
+
+	tinyString[0] = '0';
+	tinyString[1] = 'x';
+	tinyString[2] = i > 9 ? i - 10 + 'A' : i + '0';
+	tinyString[3] = j > 9 ? j - 10 + 'A' : j + '0';
+	tinyString[4] = 0;
+
+	return tinyString;
+}
+
+// Returns the ascii code of the keynum
+const char *Key_KeynumToAscii( int keynum ) 
+{
+	const char	*name;
+
+	name = Key_KeynumValid(keynum);
+
+	// check for printable ascii
+	if ( !name && keynum > 0 && keynum < 256 ) 
+	{
+		name = Key_KeyToAscii(keynum);
+	}
+	// Check for name (for JOYx and AUXx buttons)
+	if ( !name )
+	{
+		name = Key_KeyToName(keynum);
+	}
+	// Fallback to hex number
+	if ( !name )
+	{
+		name = Key_KeyToHex(keynum);
+	}
+	return name;
+}
+
+
+/*
+===================
+Key_KeynumToString
+
+Returns a string (either a single ascii char, a K_* name, or a 0x11 hex string) for the
+given keynum.
+===================
+*/
+// Returns a console/config file friendly name for the key
+const char *Key_KeynumToString( int keynum ) 
+{
+	const char	*name;
+
+	name = Key_KeynumValid(keynum);
+
+	// Check for friendly name
+	if ( !name )
+	{
+		name = Key_KeyToName(keynum);
+	}
+	// check for printable ascii
+	if ( !name && keynum > 0 && keynum < 256) 
+	{
+		name = Key_KeyToAscii(keynum);
+	}
+	// Fallback to hex number
+	if ( !name )
+	{
+		name = Key_KeyToHex(keynum);
+	}
+	return name;
+}
+
+
+/*
+===================
+Key_SetBinding
+===================
+*/
+void Key_SetBinding( int keynum, const char *binding ) {
+	if ( keynum == -1 ) {
+		return;
+	}
+
+	// free old bindings
+	if ( kg.keys[ keynames[keynum].upper ].binding ) {
+		Z_Free( kg.keys[ keynames[keynum].upper ].binding );
+		kg.keys[ keynames[keynum].upper ].binding = NULL;
+	}
+			
+	// allocate memory for new binding
+	if (binding)
+	{
+		kg.keys[ keynames[keynum].upper ].binding = CopyString( binding );
+	}
+
+	// consider this like modifying an archived cvar, so the
+	// file write will be triggered at the next oportunity
+	cvar_modifiedFlags |= CVAR_ARCHIVE;
+}
+
+
+/*
+===================
+Key_GetBinding
+===================
+*/
+char *Key_GetBinding( int keynum ) {
+	if ( keynum == -1 ) {
+		return "";
+	}
+
+	assert (keynum < (sizeof(kg.keys)/sizeof(kg.keys[0])));
+	return kg.keys[ keynum ].binding;
+}
+
+
+/*
+===================
+Key_Unbind_f
+===================
+*/
+void Key_Unbind_f (void)
+{
+	int		b;
+
+	if (Cmd_Argc() != 2)
+	{
+		Com_Printf ("unbind <key> : remove commands from a key\n");
+		return;
+	}
+	
+	b = Key_StringToKeynum (Cmd_Argv(1));
+	if (b==-1)
+	{
+		Com_Printf ("\"%s\" isn't a valid key\n", Cmd_Argv(1));
+		return;
+	}
+
+	Key_SetBinding (b, "");
+}
+
+/*
+===================
+Key_Unbindall_f
+===================
+*/
+void Key_Unbindall_f (void)
+{
+	int		i;
+	
+	for (i = 0; i < MAX_KEYS ; i++)
+	{
+		if (kg.keys[i].binding)
+		{
+			Key_SetBinding (i, "");
+		}
+	}
+}
+
+
+/*
+===================
+Key_Bind_f
+===================
+*/
+void Key_Bind_f (void)
+{
+	int			i, c, b;
+	char		cmd[1024];
+	
+	c = Cmd_Argc();
+
+	if (c < 2)
+	{
+		Com_Printf ("bind <key> [command] : attach a command to a key\n");
+		return;
+	}
+	b = Key_StringToKeynum (Cmd_Argv(1));
+	if (b==-1)
+	{
+		Com_Printf ("\"%s\" isn't a valid key\n", Cmd_Argv(1));
+		return;
+	}
+
+	if (c == 2)
+	{
+		if (kg.keys[b].binding)
+			Com_Printf ("\"%s\" = \"%s\"\n", Cmd_Argv(1), kg.keys[b].binding );
+		else
+			Com_Printf ("\"%s\" is not bound\n", Cmd_Argv(1) );
+		return;
+	}
+	
+// copy the rest of the command line
+	cmd[0] = 0;		// start out with a null string
+	for (i=2 ; i< c ; i++)
+	{
+		strcat (cmd, Cmd_Argv(i));
+		if (i != (c-1))
+			strcat (cmd, " ");
+	}
+
+	Key_SetBinding (b, cmd);
+}
+
+/*
+============
+Key_WriteBindings
+
+Writes lines containing "bind key value"
+============
+*/
+void Key_WriteBindings( fileHandle_t f ) {
+#ifndef _XBOX
+	int		i;
+
+	FS_Printf (f, "unbindall\n" );
+	for (i=0 ; i<MAX_KEYS ; i++) {
+		if (kg.keys[i].binding && kg.keys[i].binding[0] ) {
+			FS_Printf (f, "bind %s \"%s\"\n", Key_KeynumToString(i), kg.keys[i].binding);
+		}
+	}
+#endif
+}
+
+
+/*
+============
+Key_Bindlist_f
+
+============
+*/
+void Key_Bindlist_f( void ) {
+	int		i;
+
+	for ( i = 0 ; i < MAX_KEYS ; i++ ) {
+		if ( kg.keys[i].binding && kg.keys[i].binding[0] ) {
+			Com_Printf( "Key : %s (%s) \"%s\"\n", Key_KeynumToAscii(i), Key_KeynumToString(i), kg.keys[i].binding );
+		}
+	}
+}
+
+
+/*
+===================
+CL_InitKeyCommands
+===================
+*/
+void CL_InitKeyCommands( void ) {
+	// register our functions
+	Cmd_AddCommand ("bind",Key_Bind_f);
+	Cmd_AddCommand ("unbind",Key_Unbind_f);
+	Cmd_AddCommand ("unbindall",Key_Unbindall_f);
+	Cmd_AddCommand ("bindlist",Key_Bindlist_f);
+}
+
+
+void CL_ActionEvent(int key, qboolean down, ulong time)
+{
+	const char	*kb;
+	char		cmd[1024];
+
+	// send the bound action
+	kb = kg.keys[ keynames[key].upper ].binding;
+	if(kb)
+	{
+		if (kb[0] == '+') 
+		{	
+			// button commands add keynum and time as parms so that multiple
+			// sources can be discriminated and subframe corrected
+			Com_sprintf (cmd, sizeof(cmd), "%s %i %i\n", kb, key, time);
+			Cbuf_AddText (cmd);
+		}
+		else 
+		{
+			// down-only command
+			Cbuf_AddText (kb);
+			Cbuf_AddText ("\n");
+		}
+	}
+}
+
+/*
+===================
+CL_KeyEvent
+
+Called by the system for both key up and key down events
+===================
+*/
+void CL_KeyEvent (int key, qboolean down, unsigned time) {
+	char	*kb;
+	char	cmd[1024];
+
+	// update auto-repeat status and BUTTON_ANY status
+	kg.keys[ keynames[key].upper ].down = down;
+	if (down)
+	{
+		kg.keys[ keynames[key].upper ].repeats++;
+		if ( kg.keys[ keynames[key].upper ].repeats == 1)
+		{
+			kg.anykeydown = true;
+			kg.keyDownCount++;
+		}
+	}
+	else
+	{
+		kg.keys[ keynames[key].upper ].repeats = 0;
+		kg.keyDownCount--;
+		if(kg.keyDownCount <= 0)
+		{
+			kg.anykeydown = false;
+			kg.keyDownCount = 0;
+		}
+	}
+
+	// console key is hardcoded, so the user can never unbind it
+	if (key == A_CONSOLE) 
+	{
+		if (!down) 
+		{
+			return;
+		}
+
+#ifdef FINAL_BUILD
+		if (!(cls.keyCatchers & KEYCATCH_CONSOLE) && !kg.keys[A_SHIFT].down )	//we're not in the console
+		{//so we require the control keys to get in
+			return;
+		}
+#endif
+
+	    Con_ToggleConsole_f ();
+		return;
+	}
+
+	// most keys during demo playback will bring up the menu, but non-ascii
+
+	// keys can still be used for bound actions
+	if ( down && ( cls.state == CA_CINEMATIC || CL_IsRunningInGameCinematic()) && !cls.keyCatchers ) 
+	{
+		SCR_StopCinematic(true);
+		return;
+//		Cvar_Set ("nextdemo","");
+//		key = K_ESCAPE;
+	}
+
+	// escape is always handled special
+	if ( key == A_ESCAPE && down ) 
+	{
+		if ( cls.keyCatchers & KEYCATCH_MESSAGE ) 
+		{
+			// clear message mode
+			Message_Key( key );
+			return;
+		}
+
+		if ( !( cls.keyCatchers & KEYCATCH_UI ) ) 
+		{
+			if ( cls.state == CA_ACTIVE ) 
+			{
+				UI_SetActiveMenu( "ingame",NULL );
+			}
+			else 
+			{
+				CL_Disconnect_f();
+				UI_SetActiveMenu( "mainMenu",NULL );
+			}
+			return;
+		}
+
+		_UI_KeyEvent( key,down);
+		return;
+	}
+
+	//
+	// key up events only perform actions if the game key binding is
+	// a button command (leading + sign).  These will be processed even in
+	// console mode and menu mode, to keep the character from continuing 
+	// an action started before a mode switch.
+	//
+	if (!down) {
+		kb = kg.keys[ keynames[key].upper ].binding;
+		if (kb && kb[0] == '+') {
+			// button commands add keynum and time as parms so that multiple
+			// sources can be discriminated and subframe corrected
+			Com_sprintf (cmd, sizeof(cmd), "-%s %i %i\n", kb+1, key, time);
+			Cbuf_AddText (cmd);
+		}
+		if ( cls.keyCatchers & KEYCATCH_UI ) 
+		{//need UP messages to clear out captures!
+			_UI_KeyEvent( key,down );
+		}
+		return;
+	}
+
+
+	// distribute the key down event to the apropriate handler
+	if ( cls.keyCatchers & KEYCATCH_CONSOLE ) {
+		Console_Key( key );
+	} else if ( cls.keyCatchers & KEYCATCH_UI ) {
+		_UI_KeyEvent( key,down );
+	} else if ( cls.keyCatchers & KEYCATCH_MESSAGE ) {
+		Message_Key( key );
+	} else if ( cls.state == CA_DISCONNECTED ) {
+
+		Console_Key( key );
+
+	} else {
+		CL_ActionEvent(key, true, time);
+	}
+}
+
+
+/*
+===================
+CL_CharEvent
+
+Normal keyboard characters, already shifted / capslocked / etc
+===================
+*/
+void CL_CharEvent( int key ) {
+	// the console key should never be used as a char
+	if ( key == '`' || key == '~' ) {
+		return;
+	}
+
+	// distribute the key down event to the apropriate handler
+	if ( cls.keyCatchers & KEYCATCH_CONSOLE )
+	{
+		Field_CharEvent( &kg.g_consoleField, key );
+	}
+	else if ( cls.keyCatchers & KEYCATCH_UI )
+	{
+		_UI_KeyEvent( key | K_CHAR_FLAG, qtrue );
+	}
+	else if ( cls.keyCatchers & KEYCATCH_MESSAGE ) 
+	{
+		Field_CharEvent( &chatField, key );
+	}
+	else if ( cls.state == CA_DISCONNECTED )
+	{
+		Field_CharEvent( &kg.g_consoleField, key );
+	}
+}
+
+
+/*
+===================
+Key_ClearStates
+===================
+*/
+void Key_ClearStates (void)
+{
+	int		i;
+
+	kg.anykeydown = qfalse;
+	kg.keyDownCount = 0;
+
+	for ( i=0 ; i < MAX_KEYS ; i++ ) {
+		if ( kg.keys[i].down ) {
+			CL_KeyEvent( i, qfalse, 0 );
+		}
+		kg.keys[i].down = 0;
+		kg.keys[i].repeats = 0;
+	}
+}
+
diff --git a/code/client/cl_main.cpp b/code/client/cl_main.cpp
new file mode 100644
index 0000000..1de19da
--- /dev/null
+++ b/code/client/cl_main.cpp
@@ -0,0 +1,1487 @@
+// cl_main.c  -- client main loop
+
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+
+#include "client.h"
+#include "client_ui.h"
+#include <limits.h>
+#ifdef _IMMERSION
+#include "../ff/ff.h"
+#include "../ff/cl_ff.h"
+#else
+#include "fffx.h"
+#endif // _IMMERSION
+#include "../ghoul2/g2.h"
+
+#include "../RMG/RM_Headers.h"
+
+#ifdef _XBOX
+#include "../ui/ui_splash.h"
+
+#ifndef FINAL_BUILD
+#include <d3d8perf.h>
+#endif
+
+#endif
+
+#define	RETRANSMIT_TIMEOUT	3000	// time between connection packet retransmits
+
+cvar_t	*cl_nodelta;
+cvar_t	*cl_debugMove;
+
+cvar_t	*cl_noprint;
+
+cvar_t	*cl_timeout;
+cvar_t	*cl_maxpackets;
+cvar_t	*cl_packetdup;
+cvar_t	*cl_timeNudge;
+cvar_t	*cl_showTimeDelta;
+cvar_t	*cl_newClock=0;
+
+cvar_t	*cl_shownet;
+cvar_t	*cl_avidemo;
+
+cvar_t	*cl_pano;
+cvar_t	*cl_panoNumShots;
+cvar_t	*cl_skippingcin;
+cvar_t	*cl_endcredits;
+
+cvar_t	*cl_freelook;
+cvar_t	*cl_sensitivity;
+
+cvar_t	*cl_mouseAccel;
+cvar_t	*cl_showMouseRate;
+cvar_t  *cl_VideoQuality;
+cvar_t	*cl_VidFadeUp;	// deliberately kept as "Vid" rather than "Video" so tab-matching matches only VideoQuality
+cvar_t	*cl_VidFadeDown;
+cvar_t	*cl_framerate;
+
+cvar_t	*m_pitch;
+cvar_t	*m_yaw;
+cvar_t	*m_forward;
+cvar_t	*m_side;
+cvar_t	*m_filter;
+
+#ifdef _XBOX
+//MAP HACK
+cvar_t	*cl_mapname;
+qboolean vidRestartReloadMap = qfalse;
+#endif
+
+cvar_t	*cl_activeAction;
+
+cvar_t	*cl_updateInfoString;
+
+cvar_t	*cl_ingameVideo;
+
+cvar_t	*cl_thumbStickMode;
+
+clientActive_t		cl;
+clientConnection_t	clc;
+clientStatic_t		cls;
+
+// Structure containing functions exported from refresh DLL
+refexport_t	re;
+
+ping_t	cl_pinglist[MAX_PINGREQUESTS];
+
+void CL_ShutdownRef( void );
+void CL_InitRef( void );
+void CL_CheckForResend( void );
+
+/*
+=======================================================================
+
+CLIENT RELIABLE COMMAND COMMUNICATION
+
+=======================================================================
+*/
+
+/*
+======================
+CL_AddReliableCommand
+
+The given command will be transmitted to the server, and is gauranteed to
+not have future usercmd_t executed before it is executed
+======================
+*/
+void CL_AddReliableCommand( const char *cmd ) {
+	int		index;
+
+	// if we would be losing an old command that hasn't been acknowledged,
+	// we must drop the connection
+	if ( clc.reliableSequence - clc.reliableAcknowledge > MAX_RELIABLE_COMMANDS ) {
+		Com_Error( ERR_DROP, "Client command overflow" );
+	}
+	clc.reliableSequence++;
+	index = clc.reliableSequence & ( MAX_RELIABLE_COMMANDS - 1 );
+	if ( clc.reliableCommands[ index ] ) {
+		Z_Free( clc.reliableCommands[ index ] );
+	}
+	clc.reliableCommands[ index ] = CopyString( cmd );
+}
+
+//======================================================================
+
+/*
+==================
+CL_NextDemo
+
+Called when a demo or cinematic finishes
+If the "nextdemo" cvar is set, that command will be issued
+==================
+*/
+void CL_NextDemo( void ) {
+	char	v[MAX_STRING_CHARS];
+
+	Q_strncpyz( v, Cvar_VariableString ("nextdemo"), sizeof(v) );
+	v[MAX_STRING_CHARS-1] = 0;
+	Com_DPrintf("CL_NextDemo: %s\n", v );
+	if (!v[0]) {
+		return;
+	}
+
+	Cvar_Set ("nextdemo","");
+	Cbuf_AddText (v);
+	Cbuf_AddText ("\n");
+	Cbuf_Execute();
+}
+
+//======================================================================
+
+/*
+=================
+CL_FlushMemory
+
+Called by CL_MapLoading, CL_Connect_f, and CL_ParseGamestate the only
+ways a client gets into a game
+Also called by Com_Error
+=================
+*/
+void CL_FlushMemory( void ) {
+
+	// clear sounds (moved higher up within this func to avoid the odd sound stutter)
+	S_DisableSounds();
+
+	// unload the old VM
+	CL_ShutdownCGame();
+
+	CL_ShutdownUI();
+
+	if ( re.Shutdown ) {
+		re.Shutdown( qfalse );		// don't destroy window or context
+	}
+
+	//rwwFIXMEFIXME: The game server appears to continue running, so clearing common bsp data causes crashing and other bad things
+	/*
+	CM_ClearMap();
+	*/
+
+	cls.soundRegistered = qfalse;
+	cls.rendererStarted = qfalse;
+#ifdef _IMMERSION
+	CL_ShutdownFF();
+	cls.forceStarted = qfalse;
+#endif // _IMMERSION
+}
+
+/*
+=====================
+CL_MapLoading
+
+A local server is starting to load a map, so update the
+screen to let the user know about it, then dump all client
+memory on the hunk from cgame, ui, and renderer
+=====================
+*/
+void CL_MapLoading( void ) {
+	if ( !com_cl_running->integer ) {
+		return;
+	}
+
+	Con_Close();
+	cls.keyCatchers = 0;
+
+	// if we are already connected to the local host, stay connected
+	if ( cls.state >= CA_CONNECTED && !Q_stricmp( cls.servername, "localhost" ) )  {
+		cls.state = CA_CONNECTED;		// so the connect screen is drawn
+		memset( cls.updateInfoString, 0, sizeof( cls.updateInfoString ) );
+//		memset( clc.serverMessage, 0, sizeof( clc.serverMessage ) );
+		memset( &cl.gameState, 0, sizeof( cl.gameState ) );
+		clc.lastPacketSentTime = -9999;
+		SCR_UpdateScreen();
+	} else {
+		// clear nextmap so the cinematic shutdown doesn't execute it
+		Cvar_Set( "nextmap", "" );
+#ifdef _XBOX	// This was done at E3 time - it's nasty, but we may just keep it.
+		connstate_t oldState = cls.state;
+		cls.state = CA_CHALLENGING;
+		SCR_UpdateScreen();
+		cls.state = oldState;
+#endif
+		CL_Disconnect();
+		Q_strncpyz( cls.servername, "localhost", sizeof(cls.servername) );
+		cls.state = CA_CHALLENGING;		// so the connect screen is drawn
+		cls.keyCatchers = 0;
+#ifndef _XBOX
+		SCR_UpdateScreen();
+#endif
+		clc.connectTime = -RETRANSMIT_TIMEOUT;
+		NET_StringToAdr( cls.servername, &clc.serverAddress);
+		// we don't need a challenge on the localhost
+
+		CL_CheckForResend();
+	}
+
+	CL_FlushMemory();
+}
+
+/*
+=====================
+CL_ClearState
+
+Called before parsing a gamestate
+=====================
+*/
+void CL_ClearState (void) {
+	CL_ShutdownCGame();
+
+	S_StopAllSounds();
+
+	memset( &cl, 0, sizeof( cl ) );
+}
+
+/*
+=====================
+CL_FreeReliableCommands
+
+Wipes all reliableCommands strings from clc
+=====================
+*/
+void CL_FreeReliableCommands( void )
+{
+	// wipe the client connection
+	for ( int i = 0 ; i < MAX_RELIABLE_COMMANDS ; i++ ) {
+		if ( clc.reliableCommands[i] ) {
+			Z_Free( clc.reliableCommands[i] );
+		 	clc.reliableCommands[i] = NULL;
+		}
+	}
+}
+
+
+/*
+=====================
+CL_Disconnect
+
+Called when a connection, or cinematic is being terminated.
+Goes from a connected state to either a menu state or a console state
+Sends a disconnect message to the server
+This is also called on Com_Error and Com_Quit, so it shouldn't cause any errors
+=====================
+*/
+void CL_Disconnect( void ) {
+	if ( !com_cl_running || !com_cl_running->integer ) {
+		return;
+	}
+
+#ifdef _XBOX
+	Cvar_Set("r_norefresh", "0");
+#endif
+
+	if (cls.uiStarted)
+		UI_SetActiveMenu( NULL,NULL );
+
+	SCR_StopCinematic ();
+	S_ClearSoundBuffer();
+
+#ifdef _XBOX
+//	extern qboolean RE_RegisterImages_LevelLoadEnd(void);
+//	RE_RegisterImages_LevelLoadEnd();
+	R_DeleteTextures();
+#endif
+
+	// send a disconnect message to the server
+	// send it a few times in case one is dropped
+	if ( cls.state >= CA_CONNECTED ) {
+		CL_AddReliableCommand( "disconnect" );
+		CL_WritePacket();
+		CL_WritePacket();
+		CL_WritePacket();
+	}
+	
+	CL_ClearState ();
+
+	CL_FreeReliableCommands();
+
+	extern void CL_FreeServerCommands(void);
+	CL_FreeServerCommands();
+
+	memset( &clc, 0, sizeof( clc ) );
+
+	cls.state = CA_DISCONNECTED;
+
+	// allow cheats locally
+	Cvar_Set( "timescale", "1" );//jic we were skipping
+	Cvar_Set( "skippingCinematic", "0" );//jic we were skipping
+}
+
+
+/*
+===================
+CL_ForwardCommandToServer
+
+adds the current command line as a clientCommand
+things like godmode, noclip, etc, are commands directed to the server,
+so when they are typed in at the console, they will need to be forwarded.
+===================
+*/
+void CL_ForwardCommandToServer( void ) {
+	char	*cmd;
+	char	string[MAX_STRING_CHARS];
+
+	cmd = Cmd_Argv(0);
+
+	// ignore key up commands
+	if ( cmd[0] == '-' ) {
+		return;
+	}
+
+	if ( cls.state != CA_ACTIVE || cmd[0] == '+' ) {
+		Com_Printf ("Unknown command \"%s\"\n", cmd);
+		return;
+	}
+
+	if ( Cmd_Argc() > 1 ) {
+		Com_sprintf( string, sizeof(string), "%s %s", cmd, Cmd_Args() );
+	} else {
+		Q_strncpyz( string, cmd, sizeof(string) );
+	}
+
+	CL_AddReliableCommand( string );
+}
+
+
+/*
+======================================================================
+
+CONSOLE COMMANDS
+
+======================================================================
+*/
+
+/*
+==================
+CL_ForwardToServer_f
+==================
+*/
+void CL_ForwardToServer_f( void ) {
+	if ( cls.state != CA_ACTIVE ) {
+		Com_Printf ("Not connected to a server.\n");
+		return;
+	}
+	
+	// don't forward the first argument
+	if ( Cmd_Argc() > 1 ) {
+		CL_AddReliableCommand( Cmd_Args() );
+	}
+}
+
+/*
+==================
+CL_Disconnect_f
+==================
+*/
+void CL_Disconnect_f( void ) {
+	SCR_StopCinematic();	
+
+	//FIXME:
+	// TA codebase added additional CA_CINEMATIC check below, presumably so they could play cinematics
+	//	in the menus when disconnected, although having the SCR_StopCinematic() call above is weird.
+	// Either there's a bug, or the new version of that function conditionally-doesn't stop cinematics...
+	//
+	if ( cls.state != CA_DISCONNECTED && cls.state != CA_CINEMATIC ) {
+		Com_Error (ERR_DISCONNECT, "Disconnected from server");
+	}
+}
+
+
+/*
+=================
+CL_Vid_Restart_f
+
+Restart the video subsystem
+=================
+*/
+void CL_Vid_Restart_f( void ) {
+	S_StopAllSounds();		// don't let them loop during the restart
+	S_BeginRegistration();	// all sound handles are now invalid
+	CL_ShutdownRef();
+	CL_ShutdownUI();
+	CL_ShutdownCGame();
+
+	//rww - sof2mp does this here, but it seems to cause problems in this codebase.
+//	CM_ClearMap();
+
+	CL_InitRef();
+
+	cls.rendererStarted = qfalse;
+	cls.uiStarted = qfalse;
+	cls.cgameStarted = qfalse;
+	cls.soundRegistered = qfalse;
+
+#ifdef _IMMERSION
+	CL_ShutdownFF();
+	cls.forceStarted = qfalse;
+#endif // _IMMERSION
+
+#ifdef _XBOX
+	vidRestartReloadMap = qtrue;
+#endif
+
+	// unpause so the cgame definately gets a snapshot and renders a frame
+	Cvar_Set( "cl_paused", "0" );
+}
+
+/*
+=================
+CL_Snd_Restart_f
+
+Restart the sound subsystem
+The cgame and game must also be forced to restart because
+handles will be invalid
+=================
+*/
+void CL_Snd_Restart_f( void ) {
+	S_Shutdown();
+
+	S_Init();
+
+//	CL_Vid_Restart_f();
+
+	extern qboolean	s_soundMuted;
+	s_soundMuted = qfalse;		// we can play again
+
+	S_RestartMusic();
+
+	extern void S_ReloadAllUsedSounds(void);
+	S_ReloadAllUsedSounds();
+
+	extern void AS_ParseSets(void);
+	AS_ParseSets();
+}
+#ifdef _IMMERSION
+/*
+=================
+CL_FF_Restart_f
+=================
+*/
+void CL_FF_Restart_f( void ) {
+
+	if ( FF_IsInitialized() )
+	{
+		// Apply cvar changes w/o losing registered effects
+		// Allows changing devices in-game without restarting the map
+		if ( !FF_Init() )
+			FF_Shutdown();	// error (shouldn't happen)
+	}
+	else if ( cls.state >= CA_PRIMED )	// maybe > CA_DISCONNECTED
+	{
+		// Restart map or menu
+		CL_Vid_Restart_f();
+	}
+	else if ( cls.uiStarted )
+	{
+		// Restart menu
+		CL_ShutdownUI();
+		cls.forceStarted = qfalse;
+	}
+}
+#endif // _IMMERSION
+/*
+==================
+CL_Configstrings_f
+==================
+*/
+void CL_Configstrings_f( void ) {
+	int		i;
+	int		ofs;
+
+	if ( cls.state != CA_ACTIVE ) {
+		Com_Printf( "Not connected to a server.\n");
+		return;
+	}
+
+	for ( i = 0 ; i < MAX_CONFIGSTRINGS ; i++ ) {
+		ofs = cl.gameState.stringOffsets[ i ];
+		if ( !ofs ) {
+			continue;
+		}
+		Com_Printf( "%4i: %s\n", i, cl.gameState.stringData + ofs );
+	}
+}
+
+/*
+==============
+CL_Clientinfo_f
+==============
+*/
+void CL_Clientinfo_f( void ) {
+	Com_Printf( "--------- Client Information ---------\n" );
+	Com_Printf( "state: %i\n", cls.state );
+	Com_Printf( "Server: %s\n", cls.servername );
+	Com_Printf ("User info settings:\n");
+	Info_Print( Cvar_InfoString( CVAR_USERINFO ) );
+	Com_Printf( "--------------------------------------\n" );
+}
+
+
+//====================================================================
+
+void UI_UpdateConnectionString( char *string );
+
+/*
+=================
+CL_CheckForResend
+
+Resend a connect message if the last one has timed out
+=================
+*/
+void CL_CheckForResend( void ) {
+	int		port;
+	char	info[MAX_INFO_STRING];
+
+//	if ( cls.state == CA_CINEMATIC )  
+	if ( cls.state == CA_CINEMATIC || CL_IsRunningInGameCinematic())
+	{
+		return;
+	}
+
+	// resend if we haven't gotten a reply yet
+	if ( cls.state < CA_CONNECTING || cls.state > CA_CHALLENGING ) {
+		return;
+	}
+
+	if ( cls.realtime - clc.connectTime < RETRANSMIT_TIMEOUT ) {
+		return;
+	}
+
+	clc.connectTime = cls.realtime;	// for retransmit requests
+	clc.connectPacketCount++;
+
+	// requesting a challenge
+	switch ( cls.state ) {
+	case CA_CONNECTING:
+		UI_UpdateConnectionString( va("(%i)", clc.connectPacketCount ) );
+
+		NET_OutOfBandPrint(NS_CLIENT, clc.serverAddress, "getchallenge");
+		break;
+
+	case CA_CHALLENGING:
+	// sending back the challenge
+		port = Cvar_VariableIntegerValue("qport");
+
+		UI_UpdateConnectionString( va("(%i)", clc.connectPacketCount ) );
+
+		Q_strncpyz( info, Cvar_InfoString( CVAR_USERINFO ), sizeof( info ) );
+		Info_SetValueForKey( info, "protocol", va("%i", PROTOCOL_VERSION ) );
+		Info_SetValueForKey( info, "qport", va("%i", port ) );
+		Info_SetValueForKey( info, "challenge", va("%i", clc.challenge ) );
+		NET_OutOfBandPrint( NS_CLIENT, clc.serverAddress, "connect \"%s\"", info );
+		// the most current userinfo has been sent, so watch for any
+		// newer changes to userinfo variables
+		cvar_modifiedFlags &= ~CVAR_USERINFO;
+		break;
+
+	default:
+		Com_Error( ERR_FATAL, "CL_CheckForResend: bad cls.state" );
+	}
+}
+
+
+/*
+===================
+CL_DisconnectPacket
+
+Sometimes the server can drop the client and the netchan based
+disconnect can be lost.  If the client continues to send packets
+to the server, the server will send out of band disconnect packets
+to the client so it doesn't have to wait for the full timeout period.
+===================
+*/
+void CL_DisconnectPacket( netadr_t from ) {
+	if ( cls.state != CA_ACTIVE ) {
+		return;
+	}
+
+	// if not from our server, ignore it
+	if ( !NET_CompareAdr( from, clc.netchan.remoteAddress ) ) {
+		return;
+	}
+
+	// if we have received packets within three seconds, ignore it
+	// (it might be a malicious spoof)
+	if ( cls.realtime - clc.lastPacketTime < 3000 ) {
+		return;
+	}
+
+	// drop the connection (FIXME: connection dropped dialog)
+	Com_Printf( "Server disconnected for unknown reason\n" );
+	CL_Disconnect();
+}
+
+
+/*
+=================
+CL_ConnectionlessPacket
+
+Responses to broadcasts, etc
+=================
+*/
+void CL_ConnectionlessPacket( netadr_t from, msg_t *msg ) {
+	char	*s;
+	char	*c;
+	
+	MSG_BeginReading( msg );
+	MSG_ReadLong( msg );	// skip the -1
+
+	s = MSG_ReadStringLine( msg );
+
+	Cmd_TokenizeString( s );
+
+	c = Cmd_Argv(0);
+
+	Com_DPrintf ("CL packet %s: %s\n", NET_AdrToString(from), c);
+
+	// challenge from the server we are connecting to
+	if ( !strcmp(c, "challengeResponse") ) {
+		if ( cls.state != CA_CONNECTING ) {
+			Com_Printf( "Unwanted challenge response received.  Ignored.\n" );
+		} else {
+			// start sending challenge repsonse instead of challenge request packets
+			clc.challenge = atoi(Cmd_Argv(1));
+			cls.state = CA_CHALLENGING;
+			clc.connectPacketCount = 0;
+			clc.connectTime = -99999;
+
+			// take this address as the new server address.  This allows
+			// a server proxy to hand off connections to multiple servers
+			clc.serverAddress = from;
+		}
+		return;
+	}
+
+	// server connection
+	if ( !strcmp(c, "connectResponse") ) {
+		if ( cls.state >= CA_CONNECTED ) {
+			Com_Printf ("Dup connect received.  Ignored.\n");
+			return;
+		}
+		if ( cls.state != CA_CHALLENGING ) {
+			Com_Printf ("connectResponse packet while not connecting.  Ignored.\n");
+			return;
+		}
+		if ( !NET_CompareBaseAdr( from, clc.serverAddress ) ) {
+			Com_Printf( "connectResponse from a different address.  Ignored.\n" );
+			Com_Printf( "%s should have been %s\n", NET_AdrToString( from ), 
+				NET_AdrToString( clc.serverAddress ) );
+			return;
+		}
+		Netchan_Setup (NS_CLIENT, &clc.netchan, from, Cvar_VariableIntegerValue( "qport" ) );
+		cls.state = CA_CONNECTED;
+		clc.lastPacketSentTime = -9999;		// send first packet immediately
+		return;
+	}
+
+	// a disconnect message from the server, which will happen if the server
+	// dropped the connection but it is still getting packets from us
+	if (!strcmp(c, "disconnect")) {
+		CL_DisconnectPacket( from );
+		return;
+	}
+
+	// echo request from server
+	if ( !strcmp(c, "echo") ) {
+		NET_OutOfBandPrint( NS_CLIENT, from, "%s", Cmd_Argv(1) );
+		return;
+	}
+
+	// print request from server
+	if ( !strcmp(c, "print") ) {
+		s = MSG_ReadString( msg );
+		UI_UpdateConnectionMessageString( s );
+		Com_Printf( "%s", s );
+		return;
+	}
+
+
+	Com_DPrintf ("Unknown connectionless packet command.\n");
+}
+
+
+/*
+=================
+CL_PacketEvent
+
+A packet has arrived from the main event loop
+=================
+*/
+void CL_PacketEvent( netadr_t from, msg_t *msg ) {
+	int		headerBytes;
+
+	clc.lastPacketTime = cls.realtime;
+
+	if ( msg->cursize >= 4 && *(int *)msg->data == -1 ) {
+		CL_ConnectionlessPacket( from, msg );
+		return;
+	}
+
+	if ( cls.state < CA_CONNECTED ) {
+		return;		// can't be a valid sequenced packet
+	}
+
+	if ( msg->cursize < 8 ) {
+		Com_Printf ("%s: Runt packet\n",NET_AdrToString( from ));
+		return;
+	}
+
+	//
+	// packet from server
+	//
+	if ( !NET_CompareAdr( from, clc.netchan.remoteAddress ) ) {
+		Com_DPrintf ("%s:sequenced packet without connection\n"
+			,NET_AdrToString( from ) );
+		// FIXME: send a client disconnect?
+		return;
+	}
+
+	if (!Netchan_Process( &clc.netchan, msg) ) {
+		return;		// out of order, duplicated, etc
+	}
+
+	// the header is different lengths for reliable and unreliable messages
+	headerBytes = msg->readcount;
+
+	clc.lastPacketTime = cls.realtime;
+	CL_ParseServerMessage( msg );
+}
+
+/*
+==================
+CL_CheckTimeout
+
+==================
+*/
+void CL_CheckTimeout( void ) {
+	//
+	// check timeout
+	//
+	if ( ( !cl_paused->integer || !sv_paused->integer ) 
+//		&& cls.state >= CA_CONNECTED && cls.state != CA_CINEMATIC
+		&& cls.state >= CA_CONNECTED && (cls.state != CA_CINEMATIC && !CL_IsRunningInGameCinematic())
+		&& cls.realtime - clc.lastPacketTime > cl_timeout->value*1000) {
+		if (++cl.timeoutcount > 5) {	// timeoutcount saves debugger
+			Com_Printf ("\nServer connection timed out.\n");
+			CL_Disconnect ();
+			return;
+		}
+	} else {
+		cl.timeoutcount = 0;
+	}
+}
+
+
+//============================================================================
+
+/*
+==================
+CL_CheckUserinfo
+
+==================
+*/
+void CL_CheckUserinfo( void ) {
+	if ( cls.state < CA_CHALLENGING ) {
+		return;
+	}
+
+	// send a reliable userinfo update if needed
+	if ( cvar_modifiedFlags & CVAR_USERINFO ) {
+		cvar_modifiedFlags &= ~CVAR_USERINFO;
+		CL_AddReliableCommand( va("userinfo \"%s\"", Cvar_InfoString( CVAR_USERINFO ) ) );
+	}
+
+}
+
+
+/*
+==================
+CL_Frame
+
+==================
+*/
+extern cvar_t	*cl_newClock;
+static unsigned int frameCount;
+float avgFrametime=0.0;
+void CL_Frame ( int msec,float fractionMsec ) {
+
+	if ( !com_cl_running->integer ) {
+		return;
+	}
+
+	// load the ref / cgame if needed
+	CL_StartHunkUsers();
+
+#if defined (_XBOX)// && !defined(_DEBUG)
+	// Play the intro movies once
+	static bool firstRun = true;
+	if(firstRun)
+	{
+	//	SP_DoLicense();
+		SP_DisplayLogos();
+	}
+	
+#endif
+
+#if defined (_XBOX)	//xbox doesn't load ui in StartHunkUsers, so check it here
+	// load ui if needed
+	if ( !cls.uiStarted && cls.state != CA_CINEMATIC) {
+		cls.uiStarted = qtrue;
+		SCR_StopCinematic();
+		CL_InitUI();
+	}
+#endif
+
+	if ( cls.state == CA_DISCONNECTED && !( cls.keyCatchers & KEYCATCH_UI )
+		&& !com_sv_running->integer ) {		
+		// if disconnected, bring up the menu
+		if (!CL_CheckPendingCinematic())	// this avoid having the menu flash for one frame before pending cinematics
+		{
+#ifdef _XBOX
+			if (firstRun)
+			{
+			
+				UI_SetActiveMenu("splashMenu", NULL);
+			}
+			else
+#endif
+			UI_SetActiveMenu( "mainMenu",NULL );
+		}
+	}
+
+#ifdef _XBOX
+	firstRun = false;
+#endif
+
+
+	// if recording an avi, lock to a fixed fps
+	if ( cl_avidemo->integer ) {
+		// save the current screen
+		if ( cls.state == CA_ACTIVE ) {
+			if (cl_avidemo->integer > 0) {
+				Cbuf_ExecuteText( EXEC_NOW, "screenshot silent\n" );
+			} else {
+				Cbuf_ExecuteText( EXEC_NOW, "screenshot_tga silent\n" );
+			}
+		}
+		// fixed time for next frame
+		if (cl_avidemo->integer > 0) {
+			msec = 1000 / cl_avidemo->integer;
+		} else {
+			msec = 1000 / -cl_avidemo->integer;
+		}
+	}
+
+	// save the msec before checking pause
+	cls.realFrametime = msec;
+
+	// decide the simulation time
+	cls.frametime = msec;
+	if(cl_framerate->integer)
+	{
+		avgFrametime+=msec;
+		char mess[256];
+		if(!(frameCount&0x1f))
+		{
+			sprintf(mess,"Frame rate=%f\n\n",1000.0f*(1.0/(avgFrametime/32.0f)));
+	//		OutputDebugString(mess);
+			Com_Printf(mess);
+			avgFrametime=0.0f;
+		}
+		frameCount++;
+	}
+	cls.frametimeFraction=fractionMsec;
+	cls.realtime += msec;
+	cls.realtimeFraction+=fractionMsec;
+	if (cls.realtimeFraction>=1.0f)
+	{
+		if (cl_newClock&&cl_newClock->integer)
+		{
+			cls.realtime++;
+		}
+		cls.realtimeFraction-=1.0f;
+	}
+#ifndef _XBOX
+	if ( cl_timegraph->integer ) {
+		SCR_DebugGraph ( cls.realFrametime * 0.25, 0 );
+	}
+#endif
+
+#ifdef _XBOX
+	//Check on the hot swappable button states.
+	CL_UpdateHotSwap();
+#endif
+
+	// see if we need to update any userinfo
+	CL_CheckUserinfo();
+
+	// if we haven't gotten a packet in a long time,
+	// drop the connection
+	CL_CheckTimeout();
+
+	// send intentions now
+	CL_SendCmd();
+
+	// resend a connection request if necessary
+	CL_CheckForResend();
+
+	// decide on the serverTime to render
+	CL_SetCGameTime();
+
+	if (cl_pano->integer && cls.state == CA_ACTIVE) {	//grab some panoramic shots
+		int i = 1;
+		int pref = cl_pano->integer;
+		int oldnoprint = cl_noprint->integer;
+		Con_Close();
+		cl_noprint->integer = 1;	//hide the screen shot msgs
+		for (; i <= cl_panoNumShots->integer; i++) {
+			Cvar_SetValue( "pano", i );
+			SCR_UpdateScreen();// update the screen
+			Cbuf_ExecuteText( EXEC_NOW, va("screenshot %dpano%02d\n", pref, i) );	//grab this screen
+		}
+		Cvar_SetValue( "pano", 0 );	//done
+		cl_noprint->integer = oldnoprint;
+	}
+
+	if (cl_skippingcin->integer && !cl_endcredits->integer && !com_developer->integer ) {
+		if (cl_skippingcin->modified){
+			S_StopSounds();		//kill em all but music	
+			cl_skippingcin->modified=qfalse;
+			Com_Printf (va(S_COLOR_YELLOW"%s"), SE_GetString("CON_TEXT_SKIPPING"));
+			SCR_UpdateScreen();
+		}
+	} else {
+		// update the screen
+		SCR_UpdateScreen();
+
+#if defined(_XBOX) && !defined(FINAL_BUILD)
+		if (D3DPERF_QueryRepeatFrame())
+			SCR_UpdateScreen();
+#endif
+	}
+	// update audio
+	S_Update();
+
+#ifdef _IMMERSION
+	FF_Update();
+#endif // _IMMERSION
+	// advance local effects for next frame
+	SCR_RunCinematic();
+
+	Con_RunConsole();
+
+	cls.framecount++;
+}
+
+
+//============================================================================
+
+/*
+================
+VID_Printf
+
+DLL glue
+================
+*/
+#define	MAXPRINTMSG	4096
+void VID_Printf (int print_level, const char *fmt, ...)
+{
+	va_list		argptr;
+	char		msg[MAXPRINTMSG];
+	
+	va_start (argptr,fmt);
+	vsprintf (msg,fmt,argptr);
+	va_end (argptr);
+
+	if ( print_level == PRINT_ALL ) {
+		Com_Printf ("%s", msg);
+	} else if ( print_level == PRINT_WARNING ) {
+		Com_Printf (S_COLOR_YELLOW "%s", msg);		// yellow
+	} else if ( print_level == PRINT_DEVELOPER ) {
+		Com_DPrintf (S_COLOR_RED"%s", msg);
+	}
+}
+
+
+
+/*
+============
+CL_ShutdownRef
+============
+*/
+void CL_ShutdownRef( void ) {
+	if ( !re.Shutdown ) {
+		return;
+	}
+	re.Shutdown( qtrue );
+	memset( &re, 0, sizeof( re ) );
+}
+
+/*
+============================
+CL_StartSound
+
+Convenience function for the sound system to be started
+REALLY early on Xbox, helps with memory fragmentation.
+============================
+*/
+void CL_StartSound( void ) {
+	if ( !cls.soundStarted ) {
+		cls.soundStarted = qtrue;
+		S_Init();
+	}
+
+	if ( !cls.soundRegistered ) {
+		cls.soundRegistered = qtrue;
+		S_BeginRegistration();
+	}
+}
+
+/*
+============================
+CL_StartHunkUsers
+
+After the server has cleared the hunk, these will need to be restarted
+This is the only place that any of these functions are called from
+============================
+*/
+void CL_StartHunkUsers( void ) {
+	if ( !com_cl_running->integer ) {
+		return;
+	}
+
+	if ( !cls.rendererStarted ) {
+#ifdef _XBOX
+		//if ((!com_sv_running->integer || com_errorEntered) && !vidRestartReloadMap)
+		//{
+		//	// free up some memory
+		//	extern void SV_ClearLastLevel(void);
+		//	SV_ClearLastLevel();
+		//}
+#endif
+
+		cls.rendererStarted = qtrue;
+		re.BeginRegistration( &cls.glconfig );
+
+		// load character sets
+//		cls.charSetShader = re.RegisterShaderNoMip( "gfx/2d/bigchars" );
+		cls.charSetShader = re.RegisterShaderNoMip( "gfx/2d/charsgrid_med" );
+		cls.whiteShader = re.RegisterShader( "white" );
+		cls.consoleShader = re.RegisterShader( "console" );
+		g_console_field_width = cls.glconfig.vidWidth / SMALLCHAR_WIDTH - 2;
+		kg.g_consoleField.widthInChars = g_console_field_width;
+#ifndef _IMMERSION
+		//-------
+		//	The latest Immersion Force Feedback system initializes here, not through
+		//	win32 input system. Therefore, the window handle is valid :)
+		//-------
+
+		// now that the renderer has started up we know that the global hWnd is now valid,
+		//	so we can now go ahead and (re)setup the input stuff that needs hWnds for DI...
+		//  (especially Force feedback)...
+		//
+		static qboolean bOnceOnly = qfalse;	// only do once, not every renderer re-start
+		if (!bOnceOnly)
+		{
+			bOnceOnly = qtrue;
+			extern void Sys_In_Restart_f( void );
+			Sys_In_Restart_f();
+		}
+
+#ifdef _XBOX
+		if (vidRestartReloadMap)
+		{
+			int checksum;
+			CM_LoadMap(va("maps/%s.bsp", cl_mapname->string), qfalse, &checksum);
+			RE_LoadWorldMap(va("maps/%s.bsp", cl_mapname->string));
+			vidRestartReloadMap = qfalse;
+		}
+#endif // _XBOX
+
+#endif // _IMMERSION
+	}
+
+	if ( !cls.soundStarted ) {
+		cls.soundStarted = qtrue;
+		S_Init();
+	}
+
+	if ( !cls.soundRegistered ) {
+		cls.soundRegistered = qtrue;
+		S_BeginRegistration();
+	}
+
+#ifdef _IMMERSION
+	if ( !cls.forceStarted ) {
+		cls.forceStarted = qtrue;
+		CL_InitFF();
+	}
+#endif // _IMMERSION
+
+#if !defined (_XBOX)	//i guess xbox doesn't want the ui loaded all the time?
+	//we require the ui to be loaded here or else it crashes trying to access the ui on command line map loads
+	if ( !cls.uiStarted ) {
+		cls.uiStarted = qtrue;
+		CL_InitUI();
+	}
+#endif
+
+//	if ( !cls.cgameStarted && cls.state > CA_CONNECTED && cls.state != CA_CINEMATIC ) {
+	if ( !cls.cgameStarted && cls.state > CA_CONNECTED && (cls.state != CA_CINEMATIC && !CL_IsRunningInGameCinematic()) ) 
+	{
+		cls.cgameStarted = qtrue;
+		CL_InitCGame();
+	}
+}
+
+/*
+============
+CL_InitRef
+============
+*/
+void CL_InitRef( void ) {
+	refexport_t	*ret;
+
+	Com_Printf( "----- Initializing Renderer ----\n" );
+
+	// cinematic stuff
+
+	ret = GetRefAPI( REF_API_VERSION );
+
+	Com_Printf( "-------------------------------\n");
+
+	if ( !ret ) {
+		Com_Error (ERR_FATAL, "Couldn't initialize refresh" );
+	}
+
+	re = *ret;
+
+	// unpause so the cgame definately gets a snapshot and renders a frame
+	Cvar_Set( "cl_paused", "0" );
+}
+
+
+//===========================================================================================
+
+/*
+====================
+CL_Init
+====================
+*/
+void CL_Init( void ) {
+	Com_Printf( "----- Client Initialization -----\n" );
+	
+	Con_Init ();
+
+	CL_ClearState ();
+
+	cls.state = CA_DISCONNECTED;	// no longer CA_UNINITIALIZED
+	cls.keyCatchers = KEYCATCH_CONSOLE;
+	cls.realtime = 0;
+	cls.realtimeFraction=0.0f;	// fraction of a msec accumulated
+
+	CL_InitInput ();
+
+#ifndef _XBOX	// No terrain on Xbox
+	RM_InitTerrain();
+#endif
+
+	//
+	// register our variables
+	//
+	cl_noprint = Cvar_Get( "cl_noprint", "0", 0 );
+
+	cl_timeout = Cvar_Get ("cl_timeout", "125", 0);
+
+	cl_timeNudge = Cvar_Get ("cl_timeNudge", "0", CVAR_TEMP );
+	cl_shownet = Cvar_Get ("cl_shownet", "0", CVAR_TEMP );
+	cl_showTimeDelta = Cvar_Get ("cl_showTimeDelta", "0", CVAR_TEMP );
+	cl_newClock = Cvar_Get ("cl_newClock", "1", 0);
+	cl_activeAction = Cvar_Get( "activeAction", "", CVAR_TEMP );
+	
+	cl_avidemo = Cvar_Get ("cl_avidemo", "0", 0);
+	cl_pano = Cvar_Get ("pano", "0", 0);
+	cl_panoNumShots= Cvar_Get ("panoNumShots", "10", CVAR_ARCHIVE);
+	cl_skippingcin = Cvar_Get ("skippingCinematic", "0", CVAR_ROM);
+	cl_endcredits = Cvar_Get ("cg_endcredits", "0", 0);
+
+	cl_yawspeed = Cvar_Get ("cl_yawspeed", "140", CVAR_ARCHIVE);
+	cl_pitchspeed = Cvar_Get ("cl_pitchspeed", "140", CVAR_ARCHIVE);
+	cl_anglespeedkey = Cvar_Get ("cl_anglespeedkey", "1.5", CVAR_ARCHIVE);
+
+	cl_maxpackets = Cvar_Get ("cl_maxpackets", "30", CVAR_ARCHIVE );
+	cl_packetdup = Cvar_Get ("cl_packetdup", "1", CVAR_ARCHIVE );
+
+	cl_run = Cvar_Get ("cl_run", "1", CVAR_ARCHIVE);
+	cl_sensitivity = Cvar_Get ("sensitivity", "5", CVAR_ARCHIVE);
+	cl_mouseAccel = Cvar_Get ("cl_mouseAccel", "0", CVAR_ARCHIVE);
+	cl_freelook = Cvar_Get( "cl_freelook", "1", CVAR_ARCHIVE );
+
+	cl_showMouseRate = Cvar_Get ("cl_showmouserate", "0", 0);
+
+	cl_ingameVideo = Cvar_Get ("cl_ingameVideo", "1", CVAR_ARCHIVE);
+	cl_VideoQuality = Cvar_Get ("cl_VideoQuality", "0", CVAR_ARCHIVE);
+	cl_VidFadeUp	= Cvar_Get ("cl_VidFadeUp", "1", CVAR_TEMP);
+	cl_VidFadeDown	= Cvar_Get ("cl_VidFadeDown", "1", CVAR_TEMP);
+	cl_framerate	= Cvar_Get ("cl_framerate", "0", CVAR_TEMP);
+
+	cl_thumbStickMode = Cvar_Get ("ui_thumbStickMode", "0", CVAR_ARCHIVE);
+
+	// init autoswitch so the ui will have it correctly even
+	// if the cgame hasn't been started
+	Cvar_Get ("cg_autoswitch", "1", CVAR_ARCHIVE);
+
+	m_pitch = Cvar_Get ("m_pitch", "0.022", CVAR_ARCHIVE);
+	m_yaw = Cvar_Get ("m_yaw", "0.022", CVAR_ARCHIVE);
+	m_forward = Cvar_Get ("m_forward", "0.25", CVAR_ARCHIVE);
+	m_side = Cvar_Get ("m_side", "0.25", CVAR_ARCHIVE);
+	m_filter = Cvar_Get ("m_filter", "0", CVAR_ARCHIVE);
+
+#ifdef _XBOX
+	cl_mapname = Cvar_Get ("cl_mapname", "t3_bounty", CVAR_TEMP);
+#endif
+
+	cl_updateInfoString = Cvar_Get( "cl_updateInfoString", "", CVAR_ROM );
+
+	// userinfo
+	Cvar_Get ("name", "Jaden", CVAR_USERINFO | CVAR_ARCHIVE );
+	Cvar_Get ("snaps", "20", CVAR_USERINFO | CVAR_ARCHIVE );
+	
+	Cvar_Get ("sex", "f", CVAR_USERINFO | CVAR_ARCHIVE | CVAR_SAVEGAME );
+	Cvar_Get ("snd", "jaden_fmle", CVAR_USERINFO | CVAR_ARCHIVE | CVAR_SAVEGAME | CVAR_NORESTART );//UI_SetSexandSoundForModel changes to match sounds.cfg for model
+	Cvar_Get ("handicap", "100", CVAR_USERINFO | CVAR_ARCHIVE | CVAR_SAVEGAME );
+
+	//
+	// register our commands
+	//
+	Cmd_AddCommand ("cmd", CL_ForwardToServer_f);
+	Cmd_AddCommand ("configstrings", CL_Configstrings_f);
+	Cmd_AddCommand ("clientinfo", CL_Clientinfo_f);
+	Cmd_AddCommand ("snd_restart", CL_Snd_Restart_f);
+	Cmd_AddCommand ("vid_restart", CL_Vid_Restart_f);
+	Cmd_AddCommand ("disconnect", CL_Disconnect_f);
+	Cmd_AddCommand ("cinematic", CL_PlayCinematic_f);
+	Cmd_AddCommand ("ingamecinematic", CL_PlayInGameCinematic_f);
+	Cmd_AddCommand ("uimenu", CL_GenericMenu_f);
+	Cmd_AddCommand ("datapad", CL_DataPad_f);
+	Cmd_AddCommand ("endscreendissolve", CL_EndScreenDissolve_f);
+#ifdef _IMMERSION
+	Cmd_AddCommand ("ff_restart", CL_FF_Restart_f);
+#endif // _IMMERSION
+
+	CL_InitRef();
+
+	CL_StartHunkUsers();
+
+	SCR_Init ();
+
+	Cbuf_Execute ();
+	
+	Cvar_Set( "cl_running", "1" );
+
+#ifdef _XBOX
+	Com_Printf( "Initializing Cinematics...\n");
+	CIN_Init();
+#endif
+
+	Com_Printf( "----- Client Initialization Complete -----\n" );
+}
+
+
+/*
+===============
+CL_Shutdown
+
+===============
+*/
+void CL_Shutdown( void ) {
+	static qboolean recursive = qfalse;
+	
+	if ( !com_cl_running || !com_cl_running->integer ) {
+		return;
+	}
+
+	Com_Printf( "----- CL_Shutdown -----\n" );
+
+	if ( recursive ) {
+		printf ("recursive shutdown\n");
+		return;
+	}
+	recursive = qtrue;
+
+	CL_ShutdownUI();
+	CL_Disconnect();
+
+	S_Shutdown();
+	CL_ShutdownRef();
+
+#ifdef _IMMERSION
+	CL_ShutdownFF();
+#endif // _IMMERSION
+	Cmd_RemoveCommand ("cmd");
+	Cmd_RemoveCommand ("configstrings");
+	Cmd_RemoveCommand ("clientinfo");
+	Cmd_RemoveCommand ("snd_restart");
+	Cmd_RemoveCommand ("vid_restart");
+	Cmd_RemoveCommand ("disconnect");
+	Cmd_RemoveCommand ("cinematic");	
+	Cmd_RemoveCommand ("ingamecinematic");
+	Cmd_RemoveCommand ("pause");
+
+	Cvar_Set( "cl_running", "0" );
+
+	recursive = qfalse;
+
+	memset( &cls, 0, sizeof( cls ) );
+
+	Com_Printf( "-----------------------\n" );
+}
+
+
+/*
+==================
+CL_GetPing
+==================
+*/
+void CL_GetPing( int n, char *adrstr, int *pingtime )
+{
+	const char*	str;
+	int		time;
+
+	if (!cl_pinglist[n].adr.port)
+	{
+		// empty slot
+		adrstr[0] = '\0';
+		*pingtime = 0;
+		return;
+	}
+
+	str = NET_AdrToString( cl_pinglist[n].adr );
+	strcpy( adrstr, str );
+
+	time = cl_pinglist[n].time;
+	if (!time)
+	{
+		// check for timeout
+		time = cls.realtime - cl_pinglist[n].start;
+		if (time < 500)
+		{
+			// not timed out yet
+			time = 0;
+		}
+	}
+
+	*pingtime = time;
+}
+
+/*
+==================
+CL_ClearPing
+==================
+*/
+void CL_ClearPing( int n )
+{
+	if (n < 0 || n >= MAX_PINGREQUESTS)
+		return;
+
+	cl_pinglist[n].adr.port = 0;
+}
+
+/*
+==================
+CL_GetPingQueueCount
+==================
+*/
+int CL_GetPingQueueCount( void )
+{
+	int		i;
+	int		count;
+	ping_t*	pingptr;
+
+	count   = 0;
+	pingptr = cl_pinglist;
+	for (i=0; i<MAX_PINGREQUESTS; i++, pingptr++ )
+		if (pingptr->adr.port)
+			count++;
+
+	return (count);
+}
+
+/*
+==================
+CL_GetFreePing
+==================
+*/
+ping_t* CL_GetFreePing( void )
+{
+	ping_t*	pingptr;
+	ping_t*	best;	
+	int		oldest;
+	int		i;
+	int		time;
+
+	pingptr = cl_pinglist;
+	for (i=0; i<MAX_PINGREQUESTS; i++, pingptr++ )
+	{
+		// find free ping slot
+		if (pingptr->adr.port)
+		{
+			if (!pingptr->time)
+			{
+				if (cls.realtime - pingptr->start < 500)
+				{
+					// still waiting for response
+					continue;
+				}
+			}
+			else if (pingptr->time < 500)
+			{
+				// results have not been queried
+				continue;
+			}
+		}
+
+		// clear it
+		pingptr->adr.port = 0;
+		return (pingptr);
+	}
+
+	// use oldest entry
+	pingptr = cl_pinglist;
+	best    = cl_pinglist;
+	oldest  = INT_MIN;
+	for (i=0; i<MAX_PINGREQUESTS; i++, pingptr++ )
+	{
+		// scan for oldest
+		time = cls.realtime - pingptr->start;
+		if (time > oldest)
+		{
+			oldest = time;
+			best   = pingptr;
+		}
+	}
+
+	return (best);
+}
diff --git a/code/client/cl_mp3.cpp b/code/client/cl_mp3.cpp
new file mode 100644
index 0000000..ddc963a
--- /dev/null
+++ b/code/client/cl_mp3.cpp
@@ -0,0 +1,554 @@
+// Filename:-	cl_mp3.cpp
+//
+// (The interface module between all the MP3 stuff and Trek)
+//
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+
+#include "client.h"
+#include "cl_mp3.h"					// only included directly by a few snd_xxxx.cpp files plus this one
+#include "../mp3code/mp3struct.h"	// keep this rather awful file secret from the rest of the program
+#include "../mp3code/copyright.h"
+
+// expects data already loaded, filename arg is for error printing only
+//
+// returns success/fail
+//
+qboolean MP3_IsValid( const char *psLocalFilename, void *pvData, int iDataLen, qboolean bStereoDesired /* = qfalse */)
+{
+	char *psError = C_MP3_IsValid(pvData, iDataLen, bStereoDesired);
+
+	if (psError)
+	{
+		Com_Printf(va(S_COLOR_RED"%s(%s)\n",psError, psLocalFilename));
+	}
+
+	return !psError;
+}
+
+
+
+// expects data already loaded, filename arg is for error printing only
+//
+// returns unpacked length, or 0 for errors (which will be printed internally)
+//
+int MP3_GetUnpackedSize( const char *psLocalFilename, void *pvData, int iDataLen, qboolean qbIgnoreID3Tag /* = qfalse */
+						, qboolean bStereoDesired /* = qfalse */
+						)
+{
+	int	iUnpackedSize = 0;	
+
+	// always do this now that we have fast-unpack code for measuring output size... (much safer than relying on tags that may have been edited, or if MP3 has been re-saved with same tag)
+	//
+	if (1)//qbIgnoreID3Tag || !MP3_ReadSpecialTagInfo((byte *)pvData, iDataLen, NULL, &iUnpackedSize))
+	{	
+		char *psError = C_MP3_GetUnpackedSize( pvData, iDataLen, &iUnpackedSize, bStereoDesired);
+
+		if (psError)
+		{
+			Com_Printf(va(S_COLOR_RED"%s\n(File: %s)\n",psError, psLocalFilename));
+			return 0;
+		}
+	}	
+
+	return iUnpackedSize;
+}
+
+
+
+// expects data already loaded, filename arg is for error printing only
+//
+// returns byte count of unpacked data (effectively a success/fail bool)
+//
+int MP3_UnpackRawPCM( const char *psLocalFilename, void *pvData, int iDataLen, byte *pbUnpackBuffer, qboolean bStereoDesired /* = qfalse */)
+{
+	int iUnpackedSize;
+	char *psError = C_MP3_UnpackRawPCM( pvData, iDataLen, &iUnpackedSize, pbUnpackBuffer, bStereoDesired);
+
+	if (psError)
+	{
+		Com_Printf(va(S_COLOR_RED"%s\n(File: %s)\n",psError, psLocalFilename));
+		return 0;
+	}
+
+	return iUnpackedSize;
+}
+
+
+// psLocalFilename is just for error reporting (if any)...
+//
+qboolean MP3Stream_InitPlayingTimeFields( LP_MP3STREAM lpMP3Stream, const char *psLocalFilename, void *pvData, int iDataLen, qboolean bStereoDesired /* = qfalse */)
+{
+	qboolean bRetval = qfalse;
+
+	int iRate, iWidth, iChannels;
+
+	char *psError = C_MP3_GetHeaderData(pvData, iDataLen, &iRate, &iWidth, &iChannels, bStereoDesired );
+	if (psError)
+	{
+		Com_Printf(va(S_COLOR_RED"MP3Stream_InitPlayingTimeFields(): %s\n(File: %s)\n",psError, psLocalFilename));
+	}
+	else
+	{
+		int iUnpackLength = MP3_GetUnpackedSize( psLocalFilename, pvData, iDataLen, qfalse,	// qboolean qbIgnoreID3Tag 
+													bStereoDesired);
+		if (iUnpackLength)
+		{
+			lpMP3Stream->iTimeQuery_UnpackedLength	= iUnpackLength;
+			lpMP3Stream->iTimeQuery_SampleRate		= iRate;
+			lpMP3Stream->iTimeQuery_Channels		= iChannels;
+			lpMP3Stream->iTimeQuery_Width			= iWidth;
+
+			bRetval = qtrue;
+		}
+	}
+
+	return bRetval;
+}
+
+float MP3Stream_GetPlayingTimeInSeconds( LP_MP3STREAM lpMP3Stream )
+{
+	if (lpMP3Stream->iTimeQuery_UnpackedLength)	// fields initialised?
+		return (float)((((double)lpMP3Stream->iTimeQuery_UnpackedLength / (double)lpMP3Stream->iTimeQuery_SampleRate) / (double)lpMP3Stream->iTimeQuery_Channels) / (double)lpMP3Stream->iTimeQuery_Width);
+
+	return 0.0f;
+}
+
+float MP3Stream_GetRemainingTimeInSeconds( LP_MP3STREAM lpMP3Stream )
+{
+	if (lpMP3Stream->iTimeQuery_UnpackedLength)	// fields initialised?
+		return (float)(((((double)(lpMP3Stream->iTimeQuery_UnpackedLength - (lpMP3Stream->iBytesDecodedTotal * (lpMP3Stream->iTimeQuery_SampleRate / dma.speed)))) / (double)lpMP3Stream->iTimeQuery_SampleRate) / (double)lpMP3Stream->iTimeQuery_Channels) / (double)lpMP3Stream->iTimeQuery_Width);
+
+	return 0.0f;
+}
+
+
+
+
+// expects data already loaded, filename arg is for error printing only
+//
+qboolean MP3_FakeUpWAVInfo( const char *psLocalFilename, void *pvData, int iDataLen, int iUnpackedDataLength, 
+						   int &format, int &rate, int &width, int &channels, int &samples, int &dataofs,
+						   qboolean bStereoDesired /* = qfalse */
+						   )
+{
+	// some things can be done instantly...
+	//
+	format = 1;		// 1 for MS format
+	dataofs= 0;		// will be 0 for me (since there's no header in the unpacked data)
+
+	// some things need to be read...  (though the whole stereo flag thing is crap)
+	//
+	char *psError = C_MP3_GetHeaderData(pvData, iDataLen, &rate, &width, &channels, bStereoDesired );
+	if (psError)
+	{
+		Com_Printf(va(S_COLOR_RED"%s\n(File: %s)\n",psError, psLocalFilename));
+	}
+
+	// and some stuff needs calculating...
+	//
+	samples	= iUnpackedDataLength / width;		
+
+	return !psError;
+}
+
+
+
+const char sKEY_MAXVOL[]="#MAXVOL";	// formerly #defines
+const char sKEY_UNCOMP[]="#UNCOMP";	//    "        "
+
+// returns qtrue for success...
+//
+qboolean MP3_ReadSpecialTagInfo(byte *pbLoadedFile, int iLoadedFileLen,
+								id3v1_1** ppTAG /* = NULL */,
+								int *piUncompressedSize /* = NULL */, 
+								float *pfMaxVol /* = NULL */
+								)
+{
+	qboolean qbError = qfalse;
+
+	id3v1_1* pTAG = (id3v1_1*) ((pbLoadedFile+iLoadedFileLen)-sizeof(id3v1_1));	// sizeof = 128	
+
+	if (!strncmp(pTAG->id, "TAG", 3))
+	{
+		// TAG found...
+		//
+		
+		// read MAXVOL key...
+		//
+		if (strncmp(pTAG->comment, sKEY_MAXVOL,	strlen(sKEY_MAXVOL)))
+		{
+			qbError = qtrue;
+		}
+		else
+		{
+			if ( pfMaxVol)
+			{
+				*pfMaxVol = atof(pTAG->comment + strlen(sKEY_MAXVOL));
+			}
+		}
+
+		//
+		// read UNCOMP key...
+		//
+		if (strncmp(pTAG->album, sKEY_UNCOMP, strlen(sKEY_UNCOMP)))
+		{
+			qbError = qtrue;
+		}
+		else
+		{
+			if ( piUncompressedSize)
+			{
+				*piUncompressedSize = atoi(pTAG->album + strlen(sKEY_UNCOMP));
+			}
+		}
+	}
+	else
+	{
+		pTAG = NULL;
+	}
+
+	if (ppTAG)
+	{
+		*ppTAG = pTAG;
+	}
+
+	return (pTAG && !qbError);
+}
+
+
+
+#define FUZZY_AMOUNT (5*1024)	// so it has to be significantly over, not just break even, because of
+								// the xtra CPU time versus memory saving
+
+cvar_t* cv_MP3overhead = NULL;
+void MP3_InitCvars(void)
+{
+	cv_MP3overhead = Cvar_Get("s_mp3overhead", va("%d", sizeof(MP3STREAM) + FUZZY_AMOUNT), CVAR_ARCHIVE );
+}
+
+
+// a file has been loaded in memory, see if we want to keep it as MP3, else as normal WAV...
+//
+// return = qtrue if keeping as MP3
+//
+// (note: the reason I pass in the unpacked size rather than working it out here is simply because I already have it)
+//
+qboolean MP3Stream_InitFromFile( sfx_t* sfx, byte *pbSrcData, int iSrcDatalen, const char *psSrcDataFilename, 
+									int iMP3UnPackedSize, qboolean bStereoDesired /* = qfalse */
+								)
+{
+	// first, make a decision based on size here as to whether or not it's worth it because of MP3 buffer space
+	//	making small files much bigger (and therefore best left as WAV)...
+	//
+	
+	if (cv_MP3overhead &&
+			(
+			//iSrcDatalen + sizeof(MP3STREAM) + FUZZY_AMOUNT < iMP3UnPackedSize
+			iSrcDatalen + cv_MP3overhead->integer < iMP3UnPackedSize
+			)
+		)
+	{
+		// ok, let's keep it as MP3 then...
+		//
+		float fMaxVol = 128;	// seems to be a reasonable typical default for maxvol (for lip synch). Naturally there's no #define I can use instead...
+
+		MP3_ReadSpecialTagInfo(pbSrcData, iSrcDatalen, NULL, NULL, &fMaxVol );	// try and read a read maxvol from MP3 header
+	
+		// fill in some sfx_t fields...
+		//
+//		Q_strncpyz( sfx->name, psSrcDataFilename, sizeof(sfx->name) );					
+		sfx->eSoundCompressionMethod = ct_MP3;
+		sfx->fVolRange = fMaxVol;
+		//sfx->width  = 2;
+		sfx->iSoundLengthInSamples = ((iMP3UnPackedSize / 2/*sfx->width*/) / (44100 / dma.speed)) / (bStereoDesired?2:1);
+		//
+		// alloc mem for data and store it (raw MP3 in this case)...
+		//
+		sfx->pSoundData = (short *) SND_malloc( iSrcDatalen, sfx );
+		memcpy( sfx->pSoundData, pbSrcData, iSrcDatalen );
+		
+		// now init the low-level MP3 stuff...
+		//
+		MP3STREAM SFX_MP3Stream = {0};	// important to init to all zeroes!
+		char *psError = C_MP3Stream_DecodeInit( &SFX_MP3Stream, /*sfx->data*/ /*sfx->soundData*/ pbSrcData, iSrcDatalen,
+												dma.speed,//(s_khz->value == 44)?44100:(s_khz->value == 22)?22050:11025,
+												2/*sfx->width*/ * 8,
+												bStereoDesired
+												);
+		SFX_MP3Stream.pbSourceData = (byte *) sfx->pSoundData;
+		if (psError)
+		{
+			// This should never happen, since any errors or problems with the MP3 file would have stopped us getting
+			//	to this whole function, but just in case...
+			//
+			Com_Printf(va(S_COLOR_YELLOW"File \"%s\": %s\n",psSrcDataFilename,psError));
+
+			// This will leave iSrcDatalen bytes on the hunk stack (since you can't dealloc that), but MP3 files are
+			//	usually small, and like I say, it should never happen.
+			//
+			// Strictly speaking, I should do a Z_Malloc above, then I could do a Z_Free if failed, else do a Hunk_Alloc
+			//	to copy the Z_Malloc data into, then Z_Free, but for something that shouldn't happen it seemed bad to
+			//	penalise the rest of the game with extra alloc demands.
+			//
+			return qfalse;	
+		}
+
+		// success ( ...on a plate).
+		//
+		// make a copy of the filled-in stream struct and attach to the sfx_t struct...
+		//
+				sfx->pMP3StreamHeader = (MP3STREAM *) Z_Malloc( sizeof(MP3STREAM), TAG_SND_MP3STREAMHDR, qfalse );
+		memcpy(	sfx->pMP3StreamHeader, &SFX_MP3Stream,		    sizeof(MP3STREAM) );
+		//
+		return qtrue;
+	}
+
+	return qfalse;
+}
+
+
+
+// decode one packet of MP3 data only (typical output size is 2304, or 2304*2 for stereo, so input size is less
+//
+// return is decoded byte count, else 0 for finished
+//
+int MP3Stream_Decode( LP_MP3STREAM lpMP3Stream, qboolean bDoingMusic )
+{
+	lpMP3Stream->iCopyOffset = 0;
+
+	if (0)//!bDoingMusic)
+	{
+		/*
+		// SOF2: need to make a local buffer up so we can decode the piece we want from a contiguous bitstream rather than
+		//	this linklist junk...
+		//
+		// since MP3 packets are generally 416 or 417 bytes in length it seems reasonable to just find which linked-chunk
+		//	the current read offset lies within then grab the next one as well (since they're 2048 bytes) and make one
+		//	buffer with just the two concat'd together. Shouldn't be much of a processor hit.
+		//
+		sndBuffer *pChunk = (sndBuffer *) lpMP3Stream->pbSourceData;	
+		//
+		// may as well make this static to avoid cut down on stack-validation run-time...
+		//
+		static byte	byRawBuffer[SND_CHUNK_SIZE_BYTE*2];	// *2 for byte->short	// easily enough to decode one frame of MP3 data, most are 416 or 417 bytes
+			
+		// fast-forward to the correct chunk...
+		//		
+		int iBytesToSkipPast = lpMP3Stream->iSourceReadIndex;
+
+		while (iBytesToSkipPast >= SND_CHUNK_SIZE_BYTE) 
+		{
+			pChunk = pChunk->next;			
+			if (!pChunk) 
+			{
+				// err.... reading off the end of the data stream guys...
+				//
+				// pChunk = (sndBuffer *) lpMP3Stream->pbSourceData;	// restart
+				return 0;	// ... 0 bytes decoded, so will just stop caller-decoder all nice and legal as EOS
+			}
+			iBytesToSkipPast -= SND_CHUNK_SIZE_BYTE;
+		}
+
+		{
+			// ok, pChunk is now the 2k or so chunk we're in the middle of...
+			//
+			int iChunk1BytesToCopy = SND_CHUNK_SIZE_BYTE - iBytesToSkipPast;
+			memcpy(byRawBuffer,((byte *)pChunk->sndChunk) + iBytesToSkipPast, iChunk1BytesToCopy);
+			//
+			// concat next chunk on to this as well...
+			//
+			pChunk = pChunk->next;
+			if (pChunk)
+			{
+				memcpy(byRawBuffer + iChunk1BytesToCopy, pChunk->sndChunk,	SND_CHUNK_SIZE_BYTE);
+			}
+			else
+			{
+				memset(byRawBuffer + iChunk1BytesToCopy, 0,					SND_CHUNK_SIZE_BYTE);
+			}
+		}
+
+
+		{
+			// now we need to backup some struct fields, fake 'em, do the lo-level call, then restore 'em...
+			//
+			byte *pbSourceData_Old	= lpMP3Stream->pbSourceData;
+			int iSourceReadIndex_Old= lpMP3Stream->iSourceReadIndex;
+
+			lpMP3Stream->pbSourceData	= &byRawBuffer[0];
+			lpMP3Stream->iSourceReadIndex= 0;	// since this is zero, not the buffer offset within a chunk, we can play tricks further down when restoring
+
+			{
+				unsigned int uiBytesDecoded = C_MP3Stream_Decode( lpMP3Stream, qfalse );
+
+				lpMP3Stream->iSourceReadIndex += iSourceReadIndex_Old;	// note '+=' rather than '=', to take account of movement.
+				lpMP3Stream->pbSourceData	   = pbSourceData_Old;
+
+				return uiBytesDecoded;
+			}
+		}
+		*/
+	}
+	else
+	{
+		// SOF2 music, or EF1 anything...
+		//
+		return C_MP3Stream_Decode( lpMP3Stream, qfalse );	// bFastForwarding
+	}
+}
+
+
+qboolean MP3Stream_SeekTo( channel_t *ch, float fTimeToSeekTo )
+{		
+	const float fEpsilon = 0.05f;	// accurate to 1/50 of a second, but plus or minus this gives 1/10 of second
+
+	MP3Stream_Rewind( ch );
+	//
+	// sanity... :-)
+	//
+	const float fTrackLengthInSeconds = MP3Stream_GetPlayingTimeInSeconds( &ch->MP3StreamHeader );
+	if (fTimeToSeekTo > fTrackLengthInSeconds)
+	{
+		fTimeToSeekTo = fTrackLengthInSeconds;
+	}
+
+	// now do the seek...
+	//
+	while (1)
+	{
+		float fPlayingTimeElapsed = MP3Stream_GetPlayingTimeInSeconds( &ch->MP3StreamHeader ) - MP3Stream_GetRemainingTimeInSeconds( &ch->MP3StreamHeader );
+		float fAbsTimeDiff = fabs(fTimeToSeekTo - fPlayingTimeElapsed);
+
+		if ( fAbsTimeDiff <= fEpsilon)
+			return qtrue;
+
+		// when decoding, use fast-forward until within 3 seconds, then slow-decode (which should init stuff properly?)...
+		//
+		int iBytesDecodedThisPacket = C_MP3Stream_Decode( &ch->MP3StreamHeader, (fAbsTimeDiff > 3.0f) );	// bFastForwarding
+		if (iBytesDecodedThisPacket == 0)
+			break;	// EOS		
+	}
+
+	return qfalse;
+}
+							   
+
+// returns qtrue for all ok
+//
+qboolean MP3Stream_Rewind( channel_t *ch )
+{		
+	ch->iMP3SlidingDecodeWritePos = 0;
+	ch->iMP3SlidingDecodeWindowPos= 0;
+
+/*
+	char *psError = C_MP3Stream_Rewind( &ch->MP3StreamHeader );
+
+	if (psError)
+	{
+		Com_Printf(S_COLOR_YELLOW"%s\n",psError);
+		return qfalse;
+	}
+
+	return qtrue;
+*/
+
+	// speed opt, since I know I already have the right data setup here...
+	//
+	memcpy(&ch->MP3StreamHeader, ch->thesfx->pMP3StreamHeader, sizeof(ch->MP3StreamHeader));
+	return qtrue;
+
+}
+
+
+// returns qtrue while still playing normally, else qfalse for either finished or request-offset-error
+//
+qboolean MP3Stream_GetSamples( channel_t *ch, int startingSampleNum, int count, short *buf, qboolean bStereo )
+{
+	qboolean qbStreamStillGoing = qtrue;
+
+	const int iQuarterOfSlidingBuffer		=  sizeof(ch->MP3SlidingDecodeBuffer)/4;
+	const int iThreeQuartersOfSlidingBuffer	= (sizeof(ch->MP3SlidingDecodeBuffer)*3)/4;
+
+//	Com_Printf("startingSampleNum %d\n",startingSampleNum);
+
+	count *= 2/* <- = SOF2; ch->sfx->width*/;	// count arg was for words, so double it for bytes;
+
+	// convert sample number into a byte offset... (make new variable for clarity?)
+	//
+	startingSampleNum *= 2 /* <- = SOF2; ch->sfx->width*/ * (bStereo?2:1);
+
+	if ( startingSampleNum < ch->iMP3SlidingDecodeWindowPos)
+	{
+		// what?!?!?!   smegging time travel needed or something?, forget it
+		memset(buf,0,count);
+		return qfalse;
+	}
+
+//	OutputDebugString(va("\nRequest: startingSampleNum %d, count %d\n",startingSampleNum,count));
+//	OutputDebugString(va("WindowPos %d, WindowWritePos %d\n",ch->iMP3SlidingDecodeWindowPos,ch->iMP3SlidingDecodeWritePos));
+
+//	qboolean _bDecoded = qfalse;
+
+	while (!
+		(
+			(startingSampleNum			>= ch->iMP3SlidingDecodeWindowPos)
+			&&
+			(startingSampleNum + count	<  ch->iMP3SlidingDecodeWindowPos + ch->iMP3SlidingDecodeWritePos)
+			)
+			)
+	{
+//		if (!_bDecoded)
+//		{
+//			Com_Printf(S_COLOR_YELLOW"Decode needed!\n");
+//		}
+//		_bDecoded = qtrue;
+//		OutputDebugString("Scrolling...");
+
+		int _iBytesDecoded = MP3Stream_Decode( (LP_MP3STREAM) &ch->MP3StreamHeader, bStereo );	// stereo only for music, so this is safe
+//		OutputDebugString(va("%d bytes decoded\n",_iBytesDecoded));
+		if (_iBytesDecoded == 0)
+		{
+			// no more source data left so clear the remainder of the buffer...
+			//
+			memset(ch->MP3SlidingDecodeBuffer + ch->iMP3SlidingDecodeWritePos, 0, sizeof(ch->MP3SlidingDecodeBuffer)-ch->iMP3SlidingDecodeWritePos);
+//			OutputDebugString("Finished\n");
+			qbStreamStillGoing = qfalse;
+			break;
+		}
+		else
+		{
+			memcpy(ch->MP3SlidingDecodeBuffer + ch->iMP3SlidingDecodeWritePos,ch->MP3StreamHeader.bDecodeBuffer,_iBytesDecoded);
+
+			ch->iMP3SlidingDecodeWritePos += _iBytesDecoded;
+
+			// if reached 3/4 of buffer pos, backscroll the decode window by one quarter...
+			//
+			if (ch->iMP3SlidingDecodeWritePos > iThreeQuartersOfSlidingBuffer)
+			{
+				memmove(ch->MP3SlidingDecodeBuffer, ((byte *)ch->MP3SlidingDecodeBuffer + iQuarterOfSlidingBuffer), iThreeQuartersOfSlidingBuffer);
+				ch->iMP3SlidingDecodeWritePos -= iQuarterOfSlidingBuffer;
+				ch->iMP3SlidingDecodeWindowPos+= iQuarterOfSlidingBuffer;
+			}
+		}
+//		OutputDebugString(va("WindowPos %d, WindowWritePos %d\n",ch->iMP3SlidingDecodeWindowPos,ch->iMP3SlidingDecodeWritePos));
+	}
+
+//	if (!_bDecoded)
+//	{
+//		Com_Printf(S_COLOR_YELLOW"No decode needed\n");
+//	}
+
+	assert(startingSampleNum >= ch->iMP3SlidingDecodeWindowPos);
+	memcpy( buf, ch->MP3SlidingDecodeBuffer + (startingSampleNum-ch->iMP3SlidingDecodeWindowPos), count);	
+
+//	OutputDebugString("OK\n\n");
+
+	return qbStreamStillGoing;
+}
+
+
+///////////// eof /////////////
+
diff --git a/code/client/cl_mp3.h b/code/client/cl_mp3.h
new file mode 100644
index 0000000..879b4c8
--- /dev/null
+++ b/code/client/cl_mp3.h
@@ -0,0 +1,87 @@
+// Filename:-	cl_mp3.h
+//
+// (Interface to the rest of the game for the MP3 functions)
+//
+#ifndef CL_MP3_H
+#define CL_MP3_H
+
+
+#ifndef sfx_t
+#include "snd_local.h"
+#endif
+
+
+
+typedef struct id3v1_1 {
+    char id[3];
+    char title[30];		// <file basename>
+    char artist[30];	// "Raven Software"
+    char album[30];		// "#UNCOMP %d"		// needed
+    char year[4];		// "2000"
+    char comment[28];	// "#MAXVOL %g"		// needed
+    char zero;
+    char track;
+    char genre;
+} id3v1_1;	// 128 bytes in size
+
+
+extern const char sKEY_MAXVOL[];
+extern const char sKEY_UNCOMP[];
+
+
+// (so far, all these functions are only called from one place in snd_mem.cpp)
+//
+// (filenames are used purely for error reporting, all files should already be loaded before you get here)
+//
+void		MP3_InitCvars			( void );
+qboolean	MP3_IsValid				( const char *psLocalFilename, void *pvData, int iDataLen, qboolean bStereoDesired = qfalse );
+int			MP3_GetUnpackedSize		( const char *psLocalFilename, void *pvData, int iDataLen, qboolean qbIgnoreID3Tag = qfalse, qboolean bStereoDesired = qfalse );
+qboolean	MP3_UnpackRawPCM		( const char *psLocalFilename, void *pvData, int iDataLen, byte *pbUnpackBuffer, qboolean bStereoDesired = qfalse );
+qboolean	MP3Stream_InitPlayingTimeFields( LP_MP3STREAM lpMP3Stream, const char *psLocalFilename, void *pvData, int iDataLen, qboolean bStereoDesired = qfalse);
+float		MP3Stream_GetPlayingTimeInSeconds( LP_MP3STREAM lpMP3Stream );
+float		MP3Stream_GetRemainingTimeInSeconds( LP_MP3STREAM lpMP3Stream );
+qboolean	MP3_FakeUpWAVInfo		( const char *psLocalFilename, void *pvData, int iDataLen, int iUnpackedDataLength, int &format, int &rate, int &width, int &channels, int &samples, int &dataofs, qboolean bStereoDesired = qfalse );
+qboolean	MP3_ReadSpecialTagInfo	( byte *pbLoadedFile, int iLoadedFileLen,
+										id3v1_1** ppTAG = NULL, int *piUncompressedSize = NULL, float *pfMaxVol = NULL);
+qboolean	MP3Stream_InitFromFile	( sfx_t* sfx, byte *pbSrcData, int iSrcDatalen, const char *psSrcDataFilename, int iMP3UnPackedSize, qboolean bStereoDesired = qfalse );
+int			MP3Stream_Decode		( LP_MP3STREAM lpMP3Stream,  qboolean bDoingMusic );
+qboolean	MP3Stream_SeekTo		( channel_t *ch, float fTimeToSeekTo );
+qboolean	MP3Stream_Rewind		( channel_t *ch );
+qboolean	MP3Stream_GetSamples	( channel_t *ch, int startingSampleNum, int count, short *buf, qboolean bStereo );
+
+
+
+
+
+///////////////////////////////////////
+//
+// the real worker code deep down in the MP3 C code...  (now externalised here so the music streamer can access one)
+//
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+
+char*	C_MP3_IsValid			(void *pvData, int iDataLen, int bStereoDesired);
+char*	C_MP3_GetUnpackedSize	(void *pvData, int iDataLen, int *piUnpackedSize, int bStereoDesired);
+char*	C_MP3_UnpackRawPCM		(void *pvData, int iDataLen, int *piUnpackedSize, void *pbUnpackBuffer, int bStereoDesired);
+char*	C_MP3_GetHeaderData		(void *pvData, int iDataLen, int *piRate, int *piWidth, int *piChannels, int bStereoDesired);
+char*	C_MP3Stream_DecodeInit	(LP_MP3STREAM pSFX_MP3Stream, void *pvSourceData, int iSourceBytesRemaining,
+								int iGameAudioSampleRate, int iGameAudioSampleBits, int bStereoDesired);
+unsigned int C_MP3Stream_Decode( LP_MP3STREAM pSFX_MP3Stream, int bFastForwarding );
+char*	C_MP3Stream_Rewind		(LP_MP3STREAM pSFX_MP3Stream);
+
+
+#ifdef __cplusplus
+}
+#endif
+//
+///////////////////////////////////////
+
+
+
+#endif	// #ifndef CL_MP3_H
+
+///////////////// eof /////////////////////
+
diff --git a/code/client/cl_mp3.org b/code/client/cl_mp3.org
new file mode 100644
index 0000000..1db5f52
--- /dev/null
+++ b/code/client/cl_mp3.org
@@ -0,0 +1,419 @@
+// Filename:-	cl_mp3.cpp
+//
+// (The interface module between all the MP3 stuff and Trek)
+//
+#include "client.h"
+#include "cl_mp3.h"					//(only included directly from snd_mem.cpp, so not in client.h)
+#include "../mp3code/mp3struct.h"	// keep this rather awful file secret from the rest of the program
+
+// call the real worker code in the messy C stuff...
+//
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+char*	C_MP3_IsValid			(void *pvData, int iDataLen);
+char*	C_MP3_GetUnpackedSize	(void *pvData, int iDataLen, int *piUnpackedSize);
+char*	C_MP3_UnpackRawPCM		(void *pvData, int iDataLen, int *piUnpackedSize, void *pbUnpackBuffer);
+char*	C_MP3_GetHeaderData		(void *pvData, int iDataLen, int *piRate, int *piWidth, int *piChannels);
+char*	C_MP3Stream_DecodeInit	(LP_MP3STREAM pSFX_MP3Stream, void *pvSourceData, int iSourceBytesRemaining,
+								int iGameAudioSampleRate, int iGameAudioSampleBits );
+unsigned int C_MP3Stream_Decode	(LP_MP3STREAM pSFX_MP3Stream);
+char*	C_MP3Stream_Rewind		(LP_MP3STREAM pSFX_MP3Stream);
+
+
+// these two are temp and will eventually be deleted... honest...
+//
+char*	C_TEST_MP3_GetUnpackedSize( const char *_FILENAME1, const char *_FILENAME2, const char *_FILENAME3,
+									void *data1,void *data2,void *data3,
+									int size1,int size2,int size3,
+									int *iUnpackedSize1,int *iUnpackedSize2,int *iUnpackedSize3
+									);
+char *	C_TEST_MP3_UnpackRawPCM(const char *_FILENAME1, const char *_FILENAME2, const char *_FILENAME3,
+								void *data1,void *data2,void *data3,
+								int iSourceBytesRemaining1,int iSourceBytesRemaining2,int iSourceBytesRemaining3,
+								int *piUnpackedSize1,int *piUnpackedSize2,int *piUnpackedSize3,
+								void *pbUnpackBuffer1,void *pbUnpackBuffer2,void *pbUnpackBuffer3
+								);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+
+
+// expects data already loaded, filename arg is for error printing only
+//
+// returns success/fail
+//
+qboolean MP3_IsValid( const char *psLocalFilename, void *pvData, int iDataLen )
+{
+	char *psError = C_MP3_IsValid(pvData, iDataLen);
+
+	if (psError)
+	{
+		Com_Printf(va(S_COLOR_RED"%s\n(File: %s)\n",psError, psLocalFilename));
+	}
+
+	return !psError;
+}
+
+
+
+// expects data already loaded, filename arg is for error printing only
+//
+// returns unpacked length, or 0 for errors (which will be printed internally)
+//
+int MP3_GetUnpackedSize( const char *psLocalFilename, void *pvData, int iDataLen, qboolean qbIgnoreID3Tag /* = qfalse */)
+{
+	int	iUnpackedSize = 0;
+	
+	if (qbIgnoreID3Tag || !MP3_ReadSpecialTagInfo((byte *)pvData, iDataLen, NULL, &iUnpackedSize))
+	{	
+		char *psError = C_MP3_GetUnpackedSize( pvData, iDataLen, &iUnpackedSize);
+
+		if (psError)
+		{
+			Com_Printf(va(S_COLOR_RED"%s\n(File: %s)\n",psError, psLocalFilename));
+			return 0;
+		}
+	}	
+
+	return iUnpackedSize;
+}
+
+
+
+// expects data already loaded, filename arg is for error printing only
+//
+// returns byte count of unpacked data (effectively a success/fail bool)
+//
+int MP3_UnpackRawPCM( const char *psLocalFilename, void *pvData, int iDataLen, byte *pbUnpackBuffer )
+{
+	int iUnpackedSize;
+	char *psError = C_MP3_UnpackRawPCM( pvData, iDataLen, &iUnpackedSize, pbUnpackBuffer);
+
+	if (psError)
+	{
+		Com_Printf(va(S_COLOR_RED"%s\n(File: %s)\n",psError, psLocalFilename));
+		return 0;
+	}
+
+	return iUnpackedSize;
+}
+
+
+
+// expects data already loaded, filename arg is for error printing only
+//
+qboolean MP3_FakeUpWAVInfo( const char *psLocalFilename, void *pvData, int iDataLen, int iUnpackedDataLength, int &format, int &rate, int &width, int &channels, int &samples, int &dataofs)
+{
+	// some things can be done instantly...
+	//
+	format = 1;		// 1 for MS format
+	dataofs= 0;		// will be 0 for me (since there's no header in the unpacked data)
+
+	// some things need to be read...
+	//
+	char *psError = C_MP3_GetHeaderData(pvData, iDataLen, &rate, &width, &channels);
+	if (psError)
+	{
+		Com_Printf(va(S_COLOR_RED"%s\n(File: %s)\n",psError, psLocalFilename));
+	}
+
+	// and some stuff needs calculating...
+	//
+	samples	= iUnpackedDataLength / width;
+		
+
+	return !psError;
+
+}
+
+
+
+const char sKEY_MAXVOL[]="#MAXVOL";	// formerly #defines
+const char sKEY_UNCOMP[]="#UNCOMP";	//    "        "
+
+// returns qtrue for success...
+//
+qboolean MP3_ReadSpecialTagInfo(byte *pbLoadedFile, int iLoadedFileLen,		// (in)
+								id3v1_1** ppTAG,							// (out), can be NULL
+								int *piUncompressedSize, float *pfMaxVol	// (out), can be NULL
+								)
+{
+	qboolean qbError = qfalse;
+
+	id3v1_1* pTAG = (id3v1_1*) ((pbLoadedFile+iLoadedFileLen)-sizeof(id3v1_1));	// sizeof = 128	
+
+	if (!strncmp(pTAG->id, "TAG", 3))
+	{
+		// TAG found...
+		//
+		
+		// read MAXVOL key...
+		//
+		if (strncmp(pTAG->comment, sKEY_MAXVOL,	strlen(sKEY_MAXVOL)))
+		{
+			qbError = qtrue;
+		}
+		else
+		{
+			if ( pfMaxVol)
+			{
+				*pfMaxVol = atof(pTAG->comment + strlen(sKEY_MAXVOL));
+			}
+		}
+
+		//
+		// read UNCOMP key...
+		//
+		if (strncmp(pTAG->album, sKEY_UNCOMP, strlen(sKEY_UNCOMP)))
+		{
+			qbError = qtrue;
+		}
+		else
+		{
+			if ( piUncompressedSize)
+			{
+				*piUncompressedSize = atoi(pTAG->album + strlen(sKEY_UNCOMP));
+			}
+		}
+	}
+	else
+	{
+		pTAG = NULL;
+	}
+
+	if (ppTAG)
+	{
+		*ppTAG = pTAG;
+	}
+
+	return (pTAG && !qbError);
+}
+
+
+
+qboolean TEST_MP3_GetUnpackedSize(const char *_FILENAME1, const char *_FILENAME2, const char *_FILENAME3,
+										void *data1,void *data2,void *data3,
+										int size1,int size2,int size3,
+										int *iUnpackedSize1,int *iUnpackedSize2,int *iUnpackedSize3
+										)
+{
+	char *psError = C_TEST_MP3_GetUnpackedSize(_FILENAME1, _FILENAME2, _FILENAME3,
+												data1,data2,data3,
+												size1,size2,size3,
+												iUnpackedSize1,iUnpackedSize2,iUnpackedSize3
+												);
+
+	if (psError)
+	{
+		Com_Printf(va(S_COLOR_RED"%s\n",psError));
+		return qfalse;
+	}
+
+	return qtrue;
+}
+
+
+// expects data already loaded, filename arg is for error printing only
+//
+// returns byte count of unpacked data (effectively a success/fail bool)
+//
+qboolean TEST_MP3_UnpackRawPCM(		const char *_FILENAME1, const char *_FILENAME2, const char *_FILENAME3,
+									void *data1,void *data2,void *data3,
+									int iSourceBytesRemaining1,int iSourceBytesRemaining2,int iSourceBytesRemaining3,
+									int *piUnpackedSize1,int *piUnpackedSize2,int *piUnpackedSize3,
+									void *pbUnpackBuffer1,void *pbUnpackBuffer2,void *pbUnpackBuffer3
+									)
+{
+	char *psError = C_TEST_MP3_UnpackRawPCM(_FILENAME1, _FILENAME2, _FILENAME3,
+											data1,data2,data3,
+											iSourceBytesRemaining1,iSourceBytesRemaining2,iSourceBytesRemaining3,
+											piUnpackedSize1,piUnpackedSize2,piUnpackedSize3,
+											pbUnpackBuffer1,pbUnpackBuffer2,pbUnpackBuffer3
+											);
+	if (psError)
+	{
+		Com_Printf(va(S_COLOR_RED"%s\n",psError));
+		return qfalse;
+	}
+
+	return qtrue;
+}
+
+
+
+
+
+// a file has been loaded in memory, see if we want to keep it as MP3, else as normal WAV...
+//
+// return = qtrue if keeping as MP3
+//
+// (note: the reason I pass in the unpacked size rather than working it out here is simply because I already have it)
+//
+qboolean MP3Stream_InitFromFile( sfx_t* sfx, byte *pbSrcData, int iSrcDatalen, const char *psSrcDataFilename, int iMP3UnPackedSize )
+{
+	// first, make a decision based on size here as to whether or not it's worth it because of MP3 buffer space
+	//	making small files much bigger (and therefore best left as WAV)...
+	//
+#define FUZZY_AMOUNT (5*1024)	// so it has to be significantly over, not just break even, because of
+								// the xtra CPU time versus memory saving
+
+	if (iSrcDatalen + sizeof(MP3STREAM) + FUZZY_AMOUNT < iMP3UnPackedSize)
+	{
+		// ok, let's keep it as MP3 then...
+		//
+
+		float fMaxVol = 128;	// seems to be a reasonable typical default for maxvol (for lip synch). Naturally there's no #define I can use instead...
+
+		MP3_ReadSpecialTagInfo(pbSrcData, iSrcDatalen, NULL, NULL, &fMaxVol );	// try and read a read maxvol from MP3 header
+	
+		// fill in some sfx_t fields...
+		//
+					sfx->eCompressionType = ct_MP3;
+					sfx->data			  = (byte*) Hunk_Alloc( iSrcDatalen );	// will err_drop if fails
+		memcpy	  ( sfx->data, pbSrcData, iSrcDatalen );						// ... so the -> data field is MP3, not PCM		
+					sfx->width  = 2;//(s_compression->value == 1)?1:2;						
+					sfx->length = (iMP3UnPackedSize / sfx->width) / (44100 / dma.speed);
+					sfx->vol_range = fMaxVol;
+
+		// now init the low-level MP3 stuff...
+		//		
+		MP3STREAM SFX_MP3Stream = {0};
+		char *psError = C_MP3Stream_DecodeInit( &SFX_MP3Stream, sfx->data, iSrcDatalen,
+												dma.speed,//(s_khz->value == 44)?44100:(s_khz->value == 22)?22050:11025,
+												sfx->width * 8
+												);
+		if (psError)
+		{
+			// This should never happen, since any errors or problems with the MP3 file would have stopped us getting
+			//	to this whole function, but just in case...
+			//
+			Com_Printf(va(S_COLOR_YELLOW"File \"%s\": %s\n",psSrcDataFilename,psError));
+
+			// This will leave iSrcDatalen bytes on the hunk stack (since you can't dealloc that), but MP3 files are
+			//	usually small, and like I say, it should never happen.
+			//
+			// Strictly speaking, I should do a Z_Malloc above, then I could do a Z_Free if failed, else do a Hunk_Alloc
+			//	to copy the Z_Malloc data into, then Z_Free, but for something that shouldn't happen it seemed bad to
+			//	penalise the rest of the game with extra malloc demands.
+			//
+			return qfalse;	
+		}
+
+		// success ( ...on a plate).
+		//
+		// make a copy of the filled-in stream struct and attach to the sfx_t struct...
+		//
+				sfx->pMP3StreamHeader = (MP3STREAM *) Hunk_Alloc( sizeof(MP3STREAM) );
+		memcpy(	sfx->pMP3StreamHeader, &SFX_MP3Stream,			  sizeof(MP3STREAM) );
+		//
+		return qtrue;
+	}
+
+	return qfalse;
+}
+
+
+// return is decoded byte count, else 0 for finished
+//
+int MP3Stream_Decode( LP_MP3STREAM lpMP3Stream )
+{
+	lpMP3Stream->iCopyOffset = 0;
+	return C_MP3Stream_Decode( lpMP3Stream );
+}
+
+// returns qtrue for all ok
+//
+// (this can be optimised by copying the whole header from the sfx struct sometime)
+//
+qboolean MP3Stream_Rewind( channel_t *ch )
+{		
+/*	char *psError = C_MP3Stream_Rewind( lpMP3Stream );
+
+	if (psError)
+	{
+		Com_Printf(S_COLOR_YELLOW"%s\n",psError);
+		return qfalse;
+	}
+
+	return qtrue;
+*/
+	memcpy(&ch->MP3StreamHeader, ch->sfx->pMP3StreamHeader, sizeof(ch->MP3StreamHeader));
+	return qtrue;
+}
+
+void MP3Stream_GetSamples( channel_t *ch, int startingSampleNum, int count, short *buf )
+{	
+	static const int iQuarterOfSlidingBuffer		=  sizeof(ch->MP3SlidingDecodeBuffer)/4;
+	static const int iThreeQuartersOfSlidingBuffer	= (sizeof(ch->MP3SlidingDecodeBuffer)*3)/4;
+
+//	Com_Printf("startingSampleNum %d\n",startingSampleNum);
+
+	count *= ch->sfx->width;	// count arg was for words, so double it for bytes;
+
+	startingSampleNum *= ch->sfx->width;
+
+	if ( startingSampleNum < ch->iMP3SlidingDecodeWindowPos)
+	{
+		// what?!?!?!   Fucking time travel needed or something?, forget it
+		memset(buf,0,count);
+		return;
+	}
+
+//	OutputDebugString(va("\nRequest: startingSampleNum %d, count %d\n",startingSampleNum,count));
+//	OutputDebugString(va("WindowPos %d, WindowWritePos %d\n",ch->iMP3SlidingDecodeWindowPos,ch->iMP3SlidingDecodeWritePos));
+
+	while (!
+		(
+			(startingSampleNum			>= ch->iMP3SlidingDecodeWindowPos)
+			&&
+			(startingSampleNum + count	<  ch->iMP3SlidingDecodeWindowPos + ch->iMP3SlidingDecodeWritePos)
+			)
+			)
+	{
+//		OutputDebugString("Scrolling...");
+
+		int _iBytesDecoded = MP3Stream_Decode( (LP_MP3STREAM) &ch->MP3StreamHeader );
+//		OutputDebugString(va("%d bytes decoded\n",_iBytesDecoded));
+		if (_iBytesDecoded == 0)
+		{
+			// no more source data left so clear the remainder of the buffer...
+			//
+			memset(ch->MP3SlidingDecodeBuffer + ch->iMP3SlidingDecodeWritePos, 0, sizeof(ch->MP3SlidingDecodeBuffer)-ch->iMP3SlidingDecodeWritePos);
+			//MP3Stream_Rewind(ch);	// should I do this???
+//			OutputDebugString("Finished\n");
+			break;
+		}
+		else
+		{
+			memcpy(ch->MP3SlidingDecodeBuffer + ch->iMP3SlidingDecodeWritePos,ch->MP3StreamHeader.bDecodeBuffer,_iBytesDecoded);
+
+			ch->iMP3SlidingDecodeWritePos += _iBytesDecoded;
+
+			// if reached 3/4 of buffer pos, backscroll the decode window by one quarter...
+			//
+			if (ch->iMP3SlidingDecodeWritePos > (sizeof(ch->MP3SlidingDecodeBuffer)*3)/4)
+			{
+				memmove(ch->MP3SlidingDecodeBuffer, ((byte *)ch->MP3SlidingDecodeBuffer + (sizeof(ch->MP3SlidingDecodeBuffer)/4)), (sizeof(ch->MP3SlidingDecodeBuffer)*3)/4);
+				ch->iMP3SlidingDecodeWritePos -= sizeof(ch->MP3SlidingDecodeBuffer)/4;
+				ch->iMP3SlidingDecodeWindowPos+= sizeof(ch->MP3SlidingDecodeBuffer)/4;
+			}
+		}
+//		OutputDebugString(va("WindowPos %d, WindowWritePos %d\n",ch->iMP3SlidingDecodeWindowPos,ch->iMP3SlidingDecodeWritePos));
+	}
+
+	assert(startingSampleNum >= ch->iMP3SlidingDecodeWindowPos);
+	memcpy( buf, ch->MP3SlidingDecodeBuffer + (startingSampleNum-ch->iMP3SlidingDecodeWindowPos), count);
+	
+
+//	OutputDebugString("OK\n");
+}
+
+
+///////////// eof /////////////
+
diff --git a/code/client/cl_parse.cpp b/code/client/cl_parse.cpp
new file mode 100644
index 0000000..5b5f496
--- /dev/null
+++ b/code/client/cl_parse.cpp
@@ -0,0 +1,510 @@
+// cl_parse.c  -- parse a message received from the server
+
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+
+#include "client.h"
+#include "client_ui.h"
+
+char *svc_strings[256] = {
+	"svc_bad",
+
+	"svc_nop",
+	"svc_gamestate",
+	"svc_configstring",
+	"svc_baseline",	
+	"svc_serverCommand",
+	"svc_download",
+	"svc_snapshot"
+};
+
+void SHOWNET( msg_t *msg, char *s) {
+	if ( cl_shownet->integer >= 2) {
+		Com_Printf ("%3i:%s\n", msg->readcount-1, s);
+	}
+}
+
+
+/*
+=========================================================================
+
+MESSAGE PARSING
+
+=========================================================================
+*/
+
+/*
+==================
+CL_DeltaEntity
+
+Parses deltas from the given base and adds the resulting entity
+to the current frame
+==================
+*/
+void CL_DeltaEntity (msg_t *msg, clSnapshot_t *frame)
+{
+	entityState_t	*state;
+
+	// save the parsed entity state into the big circular buffer so
+	// it can be used as the source for a later delta
+	state = &cl.parseEntities[cl.parseEntitiesNum & (MAX_PARSE_ENTITIES-1)];
+
+	MSG_ReadEntity( msg, state);
+
+	if ( state->number == (MAX_GENTITIES-1) ) {
+		return;		// entity was delta removed
+	}
+	cl.parseEntitiesNum++;
+	frame->numEntities++;
+}
+
+/*
+==================
+CL_ParsePacketEntities
+
+==================
+*/
+void CL_ParsePacketEntities( msg_t *msg, clSnapshot_t *oldframe, clSnapshot_t *newframe) {
+	int			newnum;
+	entityState_t	*oldstate;
+	int			oldindex, oldnum;
+
+	newframe->parseEntitiesNum = cl.parseEntitiesNum;
+	newframe->numEntities = 0;
+
+	// delta from the entities present in oldframe
+	oldindex = 0;
+	oldstate = NULL;
+	if (!oldframe) {
+		oldnum = 99999;
+	} else {
+		if ( oldindex >= oldframe->numEntities ) {
+			oldnum = 99999;
+		} else {
+			oldstate = &cl.parseEntities[
+				(oldframe->parseEntitiesNum + oldindex) & (MAX_PARSE_ENTITIES-1)];
+			oldnum = oldstate->number;
+		}
+	}
+
+	while ( 1 ) {
+		// read the entity index number
+		newnum = MSG_ReadBits( msg, GENTITYNUM_BITS );
+
+		if ( newnum == (MAX_GENTITIES-1) ) {
+			break;
+		}
+
+		if ( msg->readcount > msg->cursize ) {
+			Com_Error (ERR_DROP,"CL_ParsePacketEntities: end of message");
+		}
+
+		while ( oldnum < newnum ) {
+			// one or more entities from the old packet are unchanged
+			if ( cl_shownet->integer == 3 ) {
+				Com_Printf ("%3i:  unchanged: %i\n", msg->readcount, oldnum);
+			}
+			CL_DeltaEntity( msg, newframe );
+			
+			oldindex++;
+
+			if ( oldindex >= oldframe->numEntities ) {
+				oldnum = 99999;
+			} else {
+				oldstate = &cl.parseEntities[
+					(oldframe->parseEntitiesNum + oldindex) & (MAX_PARSE_ENTITIES-1)];
+				oldnum = oldstate->number;
+			}
+		}
+		if (oldnum == newnum) {
+			// delta from previous state
+			if ( cl_shownet->integer == 3 ) {
+				Com_Printf ("%3i:  delta: %i\n", msg->readcount, newnum);
+			}
+			CL_DeltaEntity( msg, newframe );
+
+			oldindex++;
+
+			if ( oldindex >= oldframe->numEntities ) {
+				oldnum = 99999;
+			} else {
+				oldstate = &cl.parseEntities[
+					(oldframe->parseEntitiesNum + oldindex) & (MAX_PARSE_ENTITIES-1)];
+				oldnum = oldstate->number;
+			}
+			continue;
+		}
+
+		if ( oldnum > newnum ) {
+			// delta from baseline
+			if ( cl_shownet->integer == 3 ) {
+				Com_Printf ("%3i:  baseline: %i\n", msg->readcount, newnum);
+			}
+			CL_DeltaEntity( msg, newframe );
+			continue;
+		}
+
+	}
+
+	// any remaining entities in the old frame are copied over
+	while ( oldnum != 99999 ) {
+		// one or more entities from the old packet are unchanged
+		if ( cl_shownet->integer == 3 ) {
+			Com_Printf ("%3i:  unchanged: %i\n", msg->readcount, oldnum);
+		}
+		CL_DeltaEntity( msg, newframe );
+		
+		oldindex++;
+
+		if ( oldindex >= oldframe->numEntities ) {
+			oldnum = 99999;
+		} else {
+			oldstate = &cl.parseEntities[
+				(oldframe->parseEntitiesNum + oldindex) & (MAX_PARSE_ENTITIES-1)];
+			oldnum = oldstate->number;
+		}
+	}
+}
+
+
+/*
+================
+CL_ParseSnapshot
+
+If the snapshot is parsed properly, it will be copied to
+cl.frame and saved in cl.frames[].  If the snapshot is invalid
+for any reason, no changes to the state will be made at all.
+================
+*/
+void CL_ParseSnapshot( msg_t *msg ) {
+	int			len;
+	clSnapshot_t	*old;
+	clSnapshot_t	newSnap;
+	int			deltaNum;
+	int			oldMessageNum;
+	int			i, packetNum;
+
+	// get the reliable sequence acknowledge number
+	clc.reliableAcknowledge = MSG_ReadLong( msg );
+
+	// read in the new snapshot to a temporary buffer
+	// we will only copy to cl.frame if it is valid
+	memset (&newSnap, 0, sizeof(newSnap));
+
+	newSnap.serverCommandNum = clc.serverCommandSequence;
+	newSnap.serverTime = MSG_ReadLong( msg );
+	newSnap.messageNum = MSG_ReadLong( msg );
+	deltaNum = MSG_ReadByte( msg );
+	if ( !deltaNum ) {
+		newSnap.deltaNum = -1;
+	} else {
+		newSnap.deltaNum = newSnap.messageNum - deltaNum;
+	}
+	newSnap.cmdNum = MSG_ReadLong( msg );
+	newSnap.snapFlags = MSG_ReadByte( msg );
+
+	// If the frame is delta compressed from data that we
+	// no longer have available, we must suck up the rest of
+	// the frame, but not use it, then ask for a non-compressed
+	// message 
+	if ( newSnap.deltaNum <= 0 ) {
+		newSnap.valid = qtrue;		// uncompressed frame
+		old = NULL;
+	} else {
+		old = &cl.frames[newSnap.deltaNum & PACKET_MASK];
+		if ( !old->valid ) {
+			// should never happen
+			Com_Printf ("Delta from invalid frame (not supposed to happen!).\n");
+		} else if ( old->messageNum != newSnap.deltaNum ) {
+			// The frame that the server did the delta from
+			// is too old, so we can't reconstruct it properly.
+			Com_Printf ("Delta frame too old.\n");
+		} else if ( cl.parseEntitiesNum - old->parseEntitiesNum > MAX_PARSE_ENTITIES ) {
+			Com_Printf ("Delta parseEntitiesNum too old.\n");
+		} else {
+			newSnap.valid = qtrue;	// valid delta parse
+		}
+	}
+
+	// read areamask
+	len = MSG_ReadByte( msg );
+	MSG_ReadData( msg, &newSnap.areamask, len);
+
+	// read playerinfo
+	SHOWNET( msg, "playerstate" );
+	if ( old ) {
+		MSG_ReadDeltaPlayerstate( msg, &old->ps, &newSnap.ps );
+	} else {
+		MSG_ReadDeltaPlayerstate( msg, NULL, &newSnap.ps );
+	}
+
+	// read packet entities
+	SHOWNET( msg, "packet entities" );
+	CL_ParsePacketEntities( msg, old, &newSnap );
+
+	// if not valid, dump the entire thing now that it has
+	// been properly read
+	if ( !newSnap.valid ) {
+		return;
+	}
+
+	// clear the valid flags of any snapshots between the last
+	// received and this one
+	oldMessageNum = cl.frame.messageNum + 1;
+
+	if ( cl.frame.messageNum - oldMessageNum >= PACKET_BACKUP ) {
+		oldMessageNum = cl.frame.messageNum - ( PACKET_BACKUP - 1 );
+	}
+	for ( ; oldMessageNum < newSnap.messageNum ; oldMessageNum++ ) {
+		cl.frames[oldMessageNum & PACKET_MASK].valid = qfalse;
+	}
+
+	// copy to the current good spot
+	cl.frame = newSnap;
+
+	// calculate ping time
+	for ( i = 0 ; i < PACKET_BACKUP ; i++ ) {
+		packetNum = ( clc.netchan.outgoingSequence - 1 - i ) & PACKET_MASK;
+		if ( cl.frame.cmdNum == cl.packetCmdNumber[ packetNum ] ) {
+			cl.frame.ping = cls.realtime - cl.packetTime[ packetNum ];
+			break;
+		}
+	}
+	// save the frame off in the backup array for later delta comparisons
+	cl.frames[cl.frame.messageNum & PACKET_MASK] = cl.frame;
+
+	if (cl_shownet->integer == 3) {
+		Com_Printf ("   frame:%i  delta:%i\n", cl.frame.messageNum,
+		cl.frame.deltaNum);
+	}
+
+	// actions for valid frames
+	cl.newSnapshots = qtrue;
+}
+
+
+//=====================================================================
+
+/*
+==================
+CL_SystemInfoChanged
+
+The systeminfo configstring has been changed, so parse
+new information out of it.  This will happen at every
+gamestate, and possibly during gameplay.
+==================
+*/
+void CL_SystemInfoChanged( void ) {
+	char			*systemInfo;
+	const char		*s;
+	char			key[MAX_INFO_KEY];
+	char			value[MAX_INFO_VALUE];
+
+	systemInfo = cl.gameState.stringData + cl.gameState.stringOffsets[ CS_SYSTEMINFO ];
+	cl.serverId = atoi( Info_ValueForKey( systemInfo, "sv_serverid" ) );
+
+	s = Info_ValueForKey( systemInfo, "helpUsObi" );
+	if ( atoi(s) == 0 ) {
+		Cvar_SetCheatState();
+	}
+
+	// scan through all the variables in the systeminfo and locally set cvars to match
+	s = systemInfo;
+	while ( s ) {
+		Info_NextPair( &s, key, value );
+		if ( !key[0] ) {
+			break;
+		}
+
+		Cvar_Set( key, value );
+	}
+	//if ( Cvar_VariableIntegerValue("ui_iscensored") == 1 )
+	//{
+	//	Cvar_Set( "g_dismemberment", "0");
+	//}
+}
+
+void UI_UpdateConnectionString( char *string );
+
+/*
+==================
+CL_ParseGamestate
+==================
+*/
+void CL_ParseGamestate( msg_t *msg ) {
+	int				i;
+	int				cmd;
+	char			*s;
+
+	Con_Close();
+
+	UI_UpdateConnectionString( "" );
+
+	// wipe local client state
+	CL_ClearState();
+
+	// a gamestate always marks a server command sequence
+	clc.serverCommandSequence = MSG_ReadLong( msg );
+
+	// parse all the configstrings and baselines
+	cl.gameState.dataCount = 1;	// leave a 0 at the beginning for uninitialized configstrings
+	while ( 1 ) {
+		cmd = MSG_ReadByte( msg );
+
+		if ( cmd <= 0 ) {
+			break;
+		}
+		
+		if ( cmd == svc_configstring ) {
+			int		len;
+
+			i = MSG_ReadShort( msg );
+			if ( i < 0 || i >= MAX_CONFIGSTRINGS ) {
+				Com_Error( ERR_DROP, "configstring > MAX_CONFIGSTRINGS" );
+			}
+			s = MSG_ReadString( msg );
+			len = strlen( s );
+
+			if ( len + 1 + cl.gameState.dataCount > MAX_GAMESTATE_CHARS ) {
+				Com_Error( ERR_DROP, "MAX_GAMESTATE_CHARS exceeded" );
+			}
+
+			// append it to the gameState string buffer
+			cl.gameState.stringOffsets[ i ] = cl.gameState.dataCount;
+			memcpy( cl.gameState.stringData + cl.gameState.dataCount, s, len + 1 );
+			cl.gameState.dataCount += len + 1;
+			if ( cl_shownet->integer == 3 ) {
+				Com_Printf ("%3i:  CS# %d %s (%d)\n",msg->readcount, i,s,len);
+			}
+		} else if ( cmd == svc_baseline ) {
+			assert(0);
+		} else {
+			Com_Error( ERR_DROP, "CL_ParseGamestate: bad command byte" );
+		}
+	}
+
+	// parse serverId and other cvars
+	CL_SystemInfoChanged();
+
+	// reinitialize the filesystem if the game directory has changed
+#if 0
+	if ( fs_game->modified ) {
+	}
+#endif
+
+	// let the client game init and load data
+	cls.state = CA_LOADING;
+
+	CL_StartHunkUsers();
+
+	// make sure the game starts
+	Cvar_Set( "cl_paused", "0" );
+}
+
+
+//=====================================================================
+
+void CL_FreeServerCommands(void)
+{
+	int i;
+
+	for(i=0; i<MAX_RELIABLE_COMMANDS; i++) {
+		if ( clc.serverCommands[ i ] ) {
+			Z_Free( clc.serverCommands[ i ] );
+			clc.serverCommands[ i ] = NULL;
+		}
+	}
+}
+
+
+/*
+=====================
+CL_ParseCommandString
+
+Command strings are just saved off until cgame asks for them
+when it transitions a snapshot
+=====================
+*/
+void CL_ParseCommandString( msg_t *msg ) {
+	char	*s;
+	int		seq;
+	int		index;
+
+	seq = MSG_ReadLong( msg );
+	s = MSG_ReadString( msg );
+
+	// see if we have already executed stored it off
+	if ( clc.serverCommandSequence >= seq ) {
+		return;
+	}
+	clc.serverCommandSequence = seq;
+
+	index = seq & (MAX_RELIABLE_COMMANDS-1);
+	if ( clc.serverCommands[ index ] ) {
+		Z_Free( clc.serverCommands[ index ] );
+	}
+	clc.serverCommands[ index ] = CopyString( s );
+}
+
+
+/*
+=====================
+CL_ParseServerMessage
+=====================
+*/
+void CL_ParseServerMessage( msg_t *msg ) {
+	int			cmd;
+
+	if ( cl_shownet->integer == 1 ) {
+		Com_Printf ("%i ",msg->cursize);
+	} else if ( cl_shownet->integer >= 2 ) {
+		Com_Printf ("------------------\n");
+	}
+
+	//
+	// parse the message
+	//
+	while ( 1 ) {
+		if ( msg->readcount > msg->cursize ) {
+			Com_Error (ERR_DROP,"CL_ParseServerMessage: read past end of server message");
+			break;
+		}
+
+		cmd = MSG_ReadByte( msg );
+
+		if ( cmd == -1 ) {
+			SHOWNET( msg, "END OF MESSAGE" );
+			break;
+		}
+
+		if ( cl_shownet->integer >= 2 ) {
+			if ( !svc_strings[cmd] ) {
+				Com_Printf( "%3i:BAD CMD %i\n", msg->readcount-1, cmd );
+			} else {
+				SHOWNET( msg, svc_strings[cmd] );
+			}
+		}
+	
+	// other commands
+		switch ( cmd ) {
+		default:
+			Com_Error (ERR_DROP,"CL_ParseServerMessage: Illegible server message\n");
+			break;			
+		case svc_nop:
+			break;
+		case svc_serverCommand:
+			CL_ParseCommandString( msg );
+			break;
+		case svc_gamestate:
+			CL_ParseGamestate( msg );
+			break;
+		case svc_snapshot:
+			CL_ParseSnapshot( msg );
+			break;
+		}
+	}
+}
+
+
diff --git a/code/client/cl_scrn.cpp b/code/client/cl_scrn.cpp
new file mode 100644
index 0000000..1c6f596
--- /dev/null
+++ b/code/client/cl_scrn.cpp
@@ -0,0 +1,568 @@
+// cl_scrn.c -- master for refresh, status bar, console, chat, notify, etc
+
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+
+#include "client.h"
+#include "client_ui.h"
+
+extern console_t con;
+
+qboolean	scr_initialized;		// ready to draw
+
+cvar_t		*cl_timegraph;
+cvar_t		*cl_debuggraph;
+cvar_t		*cl_graphheight;
+cvar_t		*cl_graphscale;
+cvar_t		*cl_graphshift;
+
+/*
+================
+SCR_DrawNamedPic
+
+Coordinates are 640*480 virtual values
+=================
+*/
+void SCR_DrawNamedPic( float x, float y, float width, float height, const char *picname ) {
+	qhandle_t	hShader;
+
+	assert( width != 0 );
+
+	hShader = re.RegisterShader( picname );
+	re.DrawStretchPic( x, y, width, height, 0, 0, 1, 1, hShader );
+}
+
+
+/*
+================
+SCR_FillRect
+
+Coordinates are 640*480 virtual values
+=================
+*/
+void SCR_FillRect( float x, float y, float width, float height, const float *color ) {
+	re.SetColor( color );
+
+	re.DrawStretchPic( x, y, width, height, 0, 0, 0, 0, cls.whiteShader );
+
+	re.SetColor( NULL );
+}
+
+
+/*
+================
+SCR_DrawPic
+
+Coordinates are 640*480 virtual values
+A width of 0 will draw with the original image width
+=================
+*/
+void SCR_DrawPic( float x, float y, float width, float height, qhandle_t hShader ) {
+	re.DrawStretchPic( x, y, width, height, 0, 0, 1, 1, hShader );
+}
+
+
+/*
+** SCR_DrawBigChar
+** big chars are drawn at 640*480 virtual screen size
+*/
+void SCR_DrawBigChar( int x, int y, int ch ) {
+	int row, col;
+	float frow, fcol;
+	float size;
+	float	ax, ay, aw, ah;
+
+	ch &= 255;
+
+	if ( ch == ' ' ) {
+		return;
+	}
+
+	if ( y < -BIGCHAR_HEIGHT ) {
+		return;
+	}
+
+	ax = x;
+	ay = y;
+	aw = BIGCHAR_WIDTH;
+	ah = BIGCHAR_HEIGHT;
+
+	row = ch>>4;
+	col = ch&15;
+
+	frow = row*0.0625;
+	fcol = col*0.0625;
+	size = 0.0625;
+/*
+	re.DrawStretchPic( ax, ay, aw, ah,
+					   fcol, frow, 
+					   fcol + size, frow + size, 
+					   cls.charSetShader );
+*/
+	float size2;
+
+	frow = row*0.0625;
+	fcol = col*0.0625;
+	size = 0.03125;
+	size2 = 0.0625;
+
+	re.DrawStretchPic( ax, ay, aw, ah,
+					   fcol, frow, 
+					   fcol + size, frow + size2, 
+					   cls.charSetShader );
+
+}
+
+/*
+** SCR_DrawSmallChar
+** small chars are drawn at native screen resolution
+*/
+void SCR_DrawSmallChar( int x, int y, int ch ) {
+	int row, col;
+	float frow, fcol;
+	float size;
+
+	ch &= 255;
+
+	if ( ch == ' ' ) {
+		return;
+	}
+
+	if ( y < -SMALLCHAR_HEIGHT ) {
+		return;
+	}
+
+	row = ch>>4;
+	col = ch&15;
+/*
+	frow = row*0.0625;
+	fcol = col*0.0625;
+	size = 0.0625;
+
+	re.DrawStretchPic( x, y, SMALLCHAR_WIDTH, SMALLCHAR_HEIGHT,
+					   fcol, frow, 
+					   fcol + size, frow + size, 
+					   cls.charSetShader );
+*/
+
+	float size2;
+
+	frow = row*0.0625;
+	fcol = col*0.0625;
+	size = 0.03125;
+	size2 = 0.0625;
+
+	re.DrawStretchPic( x * con.xadjust, y * con.yadjust, 
+						SMALLCHAR_WIDTH * con.xadjust, SMALLCHAR_HEIGHT * con.yadjust, 
+		fcol, frow, 
+		fcol + size, frow + size2, 
+		cls.charSetShader );
+
+}
+
+
+
+/*
+==================
+SCR_DrawBigString[Color]
+
+Draws a multi-colored string with a drop shadow, optionally forcing
+to a fixed color.
+
+Coordinates are at 640 by 480 virtual resolution
+==================
+*/
+void SCR_DrawBigStringExt( int x, int y, const char *string, float *setColor, qboolean forceColor ) {
+	vec4_t		color;
+	const char	*s;
+	int			xx;
+
+	// draw the drop shadow
+	color[0] = color[1] = color[2] = 0;
+	color[3] = setColor[3];
+	re.SetColor( color );
+	s = string;
+	xx = x;
+	while ( *s ) {
+		if ( Q_IsColorString( s ) ) {
+			s += 2;
+			continue;
+		}
+		SCR_DrawBigChar( xx+2, y+2, *s );
+		xx+=16;
+		s++;
+	}
+
+
+	// draw the colored text
+	s = string;
+	xx = x;
+	re.SetColor( setColor );
+	while ( *s ) {
+		if ( Q_IsColorString( s ) ) {
+			if ( !forceColor ) {
+				memcpy( color, g_color_table[ColorIndex(*(s+1))], sizeof( color ) );
+				color[3] = setColor[3];
+				re.SetColor( color );
+			}
+			s += 2;
+			continue;
+		}
+		SCR_DrawBigChar( xx, y, *s );
+		xx+=16;
+		s++;
+	}
+	re.SetColor( NULL );
+}
+
+
+void SCR_DrawBigString( int x, int y, const char *s, float alpha ) {
+	float	color[4];
+
+	color[0] = color[1] = color[2] = 1.0;
+	color[3] = alpha;
+	SCR_DrawBigStringExt( x, y, s, color, qfalse );
+}
+
+void SCR_DrawBigStringColor( int x, int y, const char *s, vec4_t color ) {
+	SCR_DrawBigStringExt( x, y, s, color, qtrue );
+}
+
+
+/*
+** SCR_Strlen -- skips color escape codes
+*/
+static int SCR_Strlen( const char *str ) {
+	const char *s = str;
+	int count = 0;
+
+	while ( *s ) {
+		if ( Q_IsColorString( s ) ) {
+			s += 2;
+		} else {
+			count++;
+			s++;
+		}
+	}
+
+	return count;
+}
+
+/*
+** SCR_GetBigStringWidth
+*/ 
+int	SCR_GetBigStringWidth( const char *str ) {
+	return SCR_Strlen( str ) * 16;
+}
+
+//===============================================================================
+
+
+/*
+===============================================================================
+
+DEBUG GRAPH
+
+===============================================================================
+*/
+#ifndef _XBOX
+typedef struct
+{
+	float	value;
+	int		color;
+} graphsamp_t;
+
+static	int			current;
+static	graphsamp_t	values[1024];
+
+/*
+==============
+SCR_DebugGraph
+==============
+*/
+void SCR_DebugGraph (float value, int color)
+{
+	values[current&1023].value = value;
+	values[current&1023].color = color;
+	current++;
+}
+
+/*
+==============
+SCR_DrawDebugGraph
+==============
+*/
+void SCR_DrawDebugGraph (void)
+{
+	int		a, x, y, w, i, h;
+	float	v;
+	int		color;
+
+	//
+	// draw the graph
+	//
+	w = cls.glconfig.vidWidth;
+	x = 0;
+	y = cls.glconfig.vidHeight;
+	re.SetColor( g_color_table[0] );
+	re.DrawStretchPic(x, y - cl_graphheight->integer, 
+		w, cl_graphheight->integer, 0, 0, 0, 0, 0 );
+	re.SetColor( NULL );
+
+	for (a=0 ; a<w ; a++)
+	{
+		i = (current-1-a+1024) & 1023;
+		v = values[i].value;
+		color = values[i].color;
+		v = v * cl_graphscale->integer + cl_graphshift->integer;
+		
+		if (v < 0)
+			v += cl_graphheight->integer * (1+(int)(-v / cl_graphheight->integer));
+		h = (int)v % cl_graphheight->integer;
+		re.DrawStretchPic( x+w-1-a, y - h, 1, h, 0, 0, 0, 0, 0 );
+	}
+}
+#endif	// _XBOX
+//=============================================================================
+
+/*
+==================
+SCR_Init
+==================
+*/
+void SCR_Init( void ) {
+	cl_timegraph = Cvar_Get ("timegraph", "0", CVAR_CHEAT);
+	cl_debuggraph = Cvar_Get ("debuggraph", "0", CVAR_CHEAT);
+	cl_graphheight = Cvar_Get ("graphheight", "32", CVAR_CHEAT);
+	cl_graphscale = Cvar_Get ("graphscale", "1", CVAR_CHEAT);
+	cl_graphshift = Cvar_Get ("graphshift", "0", CVAR_CHEAT);
+
+	scr_initialized = qtrue;
+}
+
+
+//=======================================================
+
+void UI_SetActiveMenu( const char* menuname,const char *menuID );
+void _UI_Refresh( int realtime );
+void UI_DrawConnect( const char *servername, const char * updateInfoString );
+
+/*
+==================
+SCR_DrawScreenField
+
+This will be called twice if rendering in stereo mode
+==================
+*/
+void SCR_DrawScreenField( stereoFrame_t stereoFrame ) {
+
+	re.BeginFrame( stereoFrame );
+
+	// wide aspect ratio screens need to have the sides cleared
+	// unless they are displaying game renderings
+	if ( cls.state != CA_ACTIVE ) {
+		if ( cls.glconfig.vidWidth * 480 > cls.glconfig.vidHeight * 640 ) {
+			re.SetColor( g_color_table[0] );
+			re.DrawStretchPic( 0, 0, cls.glconfig.vidWidth, cls.glconfig.vidHeight, 0, 0, 0, 0, 0 );
+			re.SetColor( NULL );
+		}
+	}
+
+	// if the menu is going to cover the entire screen, we
+	// don't need to render anything under it
+	if ( !_UI_IsFullscreen() ) {
+		switch( cls.state ) {
+		default:
+			Com_Error( ERR_FATAL, "SCR_DrawScreenField: bad cls.state" );
+			break;
+		case CA_CINEMATIC:
+			SCR_DrawCinematic();
+			break;
+		case CA_DISCONNECTED:
+			// force menu up
+			UI_SetActiveMenu( "mainMenu",NULL );	//			VM_Call( uivm, UI_SET_ACTIVE_MENU, UIMENU_MAIN );
+			break;
+		case CA_CONNECTING:
+		case CA_CHALLENGING:
+		case CA_CONNECTED:
+			// connecting clients will only show the connection dialog
+			UI_DrawConnect( clc.servername, cls.updateInfoString );
+			break;
+		case CA_LOADING:
+		case CA_PRIMED:
+			// draw the game information screen and loading progress
+			CL_CGameRendering( stereoFrame );
+			break;
+		case CA_ACTIVE:
+			if (CL_IsRunningInGameCinematic() || CL_InGameCinematicOnStandBy())
+			{
+				SCR_DrawCinematic();				
+			}
+			else
+			{
+				CL_CGameRendering( stereoFrame );
+			}
+			break;
+		}
+	}
+
+#ifndef _XBOX // on xbox this is rendered right before a flip
+	re.ProcessDissolve();
+#endif // _XBOX
+
+	// draw downloading progress bar
+
+	// the menu draws next
+	_UI_Refresh( cls.realtime );
+
+	// console draws next
+	Con_DrawConsole ();
+
+	// debug graph can be drawn on top of anything
+#ifndef _XBOX
+	if ( cl_debuggraph->integer || cl_timegraph->integer ) {
+		SCR_DrawDebugGraph ();
+	}
+#endif
+}
+
+/*
+==================
+SCR_UpdateScreen
+
+This is called every frame, and can also be called explicitly to flush
+text to the screen.
+==================
+*/
+void SCR_UpdateScreen( void ) {
+	static int	recursive;
+
+	if ( !scr_initialized ) {
+		return;				// not initialized yet
+	}
+
+	// load the ref / ui / cgame if needed
+	CL_StartHunkUsers();
+
+	if ( ++recursive > 2 ) {
+		Com_Error( ERR_FATAL, "SCR_UpdateScreen: recursively called" );
+	}
+	recursive = qtrue;
+
+	// if running in stereo, we need to draw the frame twice
+	if ( cls.glconfig.stereoEnabled ) {
+		SCR_DrawScreenField( STEREO_LEFT );
+		SCR_DrawScreenField( STEREO_RIGHT );
+	} else {
+		SCR_DrawScreenField( STEREO_CENTER );
+	}
+
+	if ( com_speeds->integer ) {
+		re.EndFrame( &time_frontend, &time_backend );
+	} else {
+		re.EndFrame( NULL, NULL );
+	}
+
+	recursive = 0;
+}
+
+// this stuff is only used by the savegame (SG) code for screenshots...
+//
+#ifdef _XBOX
+
+/*
+static byte	bScreenData[SG_SCR_WIDTH * SG_SCR_HEIGHT * 4];
+static qboolean screenDataValid = qfalse;
+void SCR_UnprecacheScreenshot()
+{
+	screenDataValid = qfalse;
+}
+*/
+
+void SCR_PrecacheScreenshot()
+{
+	// No screenshots unless connected to single player local server...
+	//
+//	char *psInfo = cl.gameState.stringData + cl.gameState.stringOffsets[ CS_SERVERINFO ];
+//	int iMaxClients = atoi(Info_ValueForKey( psInfo, "sv_maxclients" ));		
+
+	// (no need to check single-player status in voyager, this code base is all singleplayer)
+	if ( cls.state != CA_ACTIVE )
+	{	
+		return;
+	}
+
+#ifndef _XBOX
+	if (cls.keyCatchers == 0)
+	{
+		// in-game...
+		//
+//		SCR_UnprecacheScreenshot();
+//		pbScreenData = (byte *)Z_Malloc(SG_SCR_WIDTH * SG_SCR_HEIGHT * 4);		
+		S_ClearSoundBuffer();	// clear DMA etc because the following glReadPixels() call can take ages
+		re.GetScreenShot( (byte *) &bScreenData, SG_SCR_WIDTH, SG_SCR_HEIGHT);
+		screenDataValid = qtrue;
+	}
+	else
+	{
+		// we're in the console, or menu, or message input...
+		//
+	}
+#endif
+
+	// save the current screenshot to the user space to be used
+	// with a savegame
+#ifdef _XBOX
+	extern void SaveCompressedScreenshot( const char* filename );
+	SaveCompressedScreenshot("u:\\saveimage.xbx");
+#endif
+
+}
+
+/*
+byte *SCR_GetScreenshot(qboolean *qValid)
+{
+	if (!screenDataValid) {
+		SCR_PrecacheScreenshot();
+	}
+	if (qValid) {
+		*qValid = screenDataValid;
+	}
+	return (byte *)&bScreenData;
+}
+
+// called from save-game code to set the lo-res loading screen to be the one from the save file...
+//
+void SCR_SetScreenshot(const byte *pbData, int w, int h)
+{
+	if (w == SG_SCR_WIDTH && h == SG_SCR_HEIGHT)
+	{
+		screenDataValid = qtrue;
+		memcpy(&bScreenData, pbData, SG_SCR_WIDTH*SG_SCR_HEIGHT*4);
+	}
+	else
+	{
+		screenDataValid = qfalse;
+		memset(&bScreenData, 0,      SG_SCR_WIDTH*SG_SCR_HEIGHT*4);
+	}
+}
+*/
+
+// This is just a client-side wrapper for the function RE_TempRawImage_ReadFromFile() in the renderer code...
+//
+/*
+byte* SCR_TempRawImage_ReadFromFile(const char *psLocalFilename, int *piWidth, int *piHeight, byte *pbReSampleBuffer, qboolean qbVertFlip)
+{
+	return re.TempRawImage_ReadFromFile(psLocalFilename, piWidth, piHeight, pbReSampleBuffer, qbVertFlip);
+}
+//
+// ditto (sort of)...
+//
+void  SCR_TempRawImage_CleanUp()
+{
+	re.TempRawImage_CleanUp();
+}
+*/
+#endif
diff --git a/code/client/cl_ui.cpp b/code/client/cl_ui.cpp
new file mode 100644
index 0000000..39b93a4
--- /dev/null
+++ b/code/client/cl_ui.cpp
@@ -0,0 +1,504 @@
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+
+#include "client.h"
+#include "client_ui.h"
+
+#include "vmachine.h"
+
+int PC_ReadTokenHandle(int handle, struct pc_token_s *pc_token);
+
+int CL_UISystemCalls( int *args );
+
+//prototypes
+//extern qboolean SG_GetSaveImage( const char *psPathlessBaseName, void *pvAddress );
+extern int SG_GetSaveGameComment(const char *psPathlessBaseName, char *sComment, char *sMapName);
+extern qboolean SG_GameAllowedToSaveHere(qboolean inCamera);
+extern void SG_StoreSaveGameComment(const char *sComment);
+//extern byte *SCR_GetScreenshot(qboolean *qValid);
+
+
+/*
+====================
+Helper functions for User Interface
+====================
+*/
+
+/*
+====================
+GetClientState
+====================
+*/
+static connstate_t GetClientState( void ) {
+	return cls.state;
+}
+
+/*
+====================
+CL_GetGlConfig
+====================
+*/
+static void UI_GetGlconfig( glconfig_t *config ) {
+	*config = cls.glconfig;
+}
+
+/*
+====================
+GetClipboardData
+====================
+*/
+static void GetClipboardData( char *buf, int buflen ) {
+	char	*cbd;
+
+	cbd = Sys_GetClipboardData();
+
+	if ( !cbd ) {
+		*buf = 0;
+		return;
+	}
+
+	Q_strncpyz( buf, cbd, buflen );
+
+	Z_Free( cbd );
+}
+
+/*
+====================
+Key_KeynumToStringBuf
+====================
+*/
+// only ever called by binding-display code, therefore returns non-technical "friendly" names 
+//	in any language that don't necessarily match those in the config file...
+//
+void Key_KeynumToStringBuf( int keynum, char *buf, int buflen ) 
+{
+	const char *psKeyName = Key_KeynumToString( keynum/*, qtrue */);
+
+	// see if there's a more friendly (or localised) name...
+	//
+	const char *psKeyNameFriendly = SE_GetString( va("KEYNAMES_KEYNAME_%s",psKeyName) );
+
+	Q_strncpyz( buf, (psKeyNameFriendly && psKeyNameFriendly[0]) ? psKeyNameFriendly : psKeyName, buflen );
+}
+
+/*
+====================
+Key_GetBindingBuf
+====================
+*/
+void Key_GetBindingBuf( int keynum, char *buf, int buflen ) {
+	char	*value;
+
+	value = Key_GetBinding( keynum );
+	if ( value ) {
+		Q_strncpyz( buf, value, buflen );
+	}
+	else {
+		*buf = 0;
+	}
+}
+
+/*
+====================
+Key_GetCatcher
+====================
+*/
+int Key_GetCatcher( void ) 
+{
+	return cls.keyCatchers;
+}
+
+/*
+====================
+Key_GetCatcher
+====================
+*/
+void Key_SetCatcher( int catcher ) 
+{
+	cls.keyCatchers = catcher;
+}
+
+/*
+====================
+FloatAsInt
+====================
+*/
+int FloatAsInt( float f ) 
+{
+	int		temp;
+
+	*(float *)&temp = f;
+
+	return temp;
+}
+
+static void UI_Cvar_Create( const char *var_name, const char *var_value, int flags ) {
+	Cvar_Get( var_name, var_value, flags );
+}
+
+static int GetConfigString(int index, char *buf, int size)
+{
+	int		offset;
+
+	if (index < 0 || index >= MAX_CONFIGSTRINGS)
+		return qfalse;
+
+	offset = cl.gameState.stringOffsets[index];
+	if (!offset)
+		return qfalse;
+
+	Q_strncpyz( buf, cl.gameState.stringData+offset, size);
+ 
+	return qtrue;
+}
+
+/*
+====================
+CL_ShutdownUI
+====================
+*/
+void CL_ShutdownUI( void ) {
+	cls.keyCatchers &= ~KEYCATCH_UI;
+	cls.uiStarted = qfalse;
+}
+
+void CL_DrawDatapad(int HUDType)
+{
+	switch(HUDType)
+	{
+	case DP_HUD:
+		VM_Call( CG_DRAW_DATAPAD_HUD );
+		break;
+	case DP_OBJECTIVES:
+		VM_Call( CG_DRAW_DATAPAD_OBJECTIVES );
+		break;
+	case DP_WEAPONS:
+		VM_Call( CG_DRAW_DATAPAD_WEAPONS );
+		break;
+	case DP_INVENTORY:
+		VM_Call( CG_DRAW_DATAPAD_INVENTORY );
+		break;
+	case DP_FORCEPOWERS:
+		VM_Call( CG_DRAW_DATAPAD_FORCEPOWERS );
+		break;
+	default:
+		break;
+	}
+
+
+}
+
+void UI_Init( int apiVersion, uiimport_t *uiimport, qboolean inGameLoad );
+
+/*
+====================
+CL_InitUI
+====================
+*/
+void CL_InitUI( void ) {
+	uiimport_t	uii;
+
+	memset( &uii, 0, sizeof( uii ) );
+
+	uii.Printf = Com_Printf;
+	uii.Error = Com_Error;
+
+	uii.Cvar_Set				= Cvar_Set;
+	uii.Cvar_VariableValue		= Cvar_VariableValue;
+	uii.Cvar_VariableStringBuffer = Cvar_VariableStringBuffer;
+	uii.Cvar_SetValue			= Cvar_SetValue;
+	uii.Cvar_Reset				= Cvar_Reset;
+	uii.Cvar_Create				= UI_Cvar_Create;
+	uii.Cvar_InfoStringBuffer	= Cvar_InfoStringBuffer;
+
+	uii.Draw_DataPad			= CL_DrawDatapad;
+
+	uii.Argc					= Cmd_Argc;
+	uii.Argv					= Cmd_ArgvBuffer;
+	uii.Cmd_TokenizeString		= Cmd_TokenizeString;
+
+	uii.Cmd_ExecuteText			= Cbuf_ExecuteText;
+
+	uii.FS_FOpenFile			= FS_FOpenFileByMode;
+	uii.FS_Read					= FS_Read;
+	uii.FS_Write				= FS_Write;
+	uii.FS_FCloseFile			= FS_FCloseFile;
+	uii.FS_GetFileList			= FS_GetFileList;
+	uii.FS_ReadFile				= FS_ReadFile;
+	uii.FS_FreeFile				= FS_FreeFile;
+
+	uii.R_RegisterModel			= re.RegisterModel;
+	uii.R_RegisterSkin			= re.RegisterSkin;
+	uii.R_RegisterShader		= re.RegisterShader;
+	uii.R_RegisterShaderNoMip	= re.RegisterShaderNoMip;
+	uii.R_RegisterFont			= re.RegisterFont;
+#ifndef _XBOX
+	uii.R_Font_StrLenPixels		= re.Font_StrLenPixels;
+	uii.R_Font_HeightPixels		= re.Font_HeightPixels;
+	uii.R_Font_DrawString		= re.Font_DrawString;
+#endif
+	uii.R_Font_StrLenChars		= re.Font_StrLenChars;
+	uii.Language_IsAsian		= re.Language_IsAsian;
+	uii.Language_UsesSpaces		= re.Language_UsesSpaces;
+	uii.AnyLanguage_ReadCharFromString = re.AnyLanguage_ReadCharFromString;
+
+	//uii.SG_GetSaveImage			= SG_GetSaveImage;
+	uii.SG_GetSaveGameComment	= SG_GetSaveGameComment;
+	uii.SG_StoreSaveGameComment = SG_StoreSaveGameComment;
+	uii.SG_GameAllowedToSaveHere= SG_GameAllowedToSaveHere;
+
+	//uii.SCR_GetScreenshot		= SCR_GetScreenshot;
+
+	//uii.DrawStretchRaw			= re.DrawStretchRaw;
+	uii.R_ClearScene			= re.ClearScene;
+	uii.R_AddRefEntityToScene	= re.AddRefEntityToScene;
+	uii.R_AddPolyToScene		=  re.AddPolyToScene;
+	uii.R_AddLightToScene		= re.AddLightToScene;
+	uii.R_RenderScene			= re.RenderScene;
+
+	uii.R_ModelBounds			= re.ModelBounds;
+
+	uii.R_SetColor				= re.SetColor;
+	uii.R_DrawStretchPic		= re.DrawStretchPic;
+	uii.UpdateScreen			= SCR_UpdateScreen;
+
+#ifdef _XBOX
+	uii.PrecacheScreenshot		= SCR_PrecacheScreenshot;
+#endif
+
+	uii.R_LerpTag				= re.LerpTag;
+
+	uii.S_StartLocalLoopingSound= S_StartLocalLoopingSound;
+	uii.S_StartLocalSound		= S_StartLocalSound;
+	uii.S_RegisterSound			= S_RegisterSound;
+
+	uii.Key_KeynumToStringBuf	= Key_KeynumToStringBuf;
+	uii.Key_GetBindingBuf		= Key_GetBindingBuf;
+	uii.Key_SetBinding			= Key_SetBinding;
+	uii.Key_IsDown				= Key_IsDown;
+	uii.Key_GetOverstrikeMode	= Key_GetOverstrikeMode;
+	uii.Key_SetOverstrikeMode	= Key_SetOverstrikeMode;
+	uii.Key_ClearStates			= Key_ClearStates;
+	uii.Key_GetCatcher			= Key_GetCatcher;
+	uii.Key_SetCatcher			= Key_SetCatcher;
+
+	uii.GetClipboardData		= GetClipboardData;
+
+	uii.GetClientState			= GetClientState;
+
+	uii.GetGlconfig				= UI_GetGlconfig;
+
+	uii.GetConfigString			= (void (*)(int, char *, int))GetConfigString;
+
+	uii.Milliseconds			= Sys_Milliseconds;
+
+	UI_Init(UI_API_VERSION, &uii, (cls.state > CA_DISCONNECTED && cls.state <= CA_ACTIVE));
+
+//JLF MPSKIPPED
+#ifdef _XBOX
+	extern void UpdateDemoTimer();
+	UpdateDemoTimer();
+
+#endif
+
+//	uie->UI_Init( UI_API_VERSION, &uii );
+
+}
+
+
+qboolean UI_GameCommand( void ) {
+	if (!cls.uiStarted)
+	{
+		return qfalse;
+	}
+	return UI_ConsoleCommand();
+}
+
+
+void CL_GenericMenu_f(void)
+{		
+	char *arg = Cmd_Argv( 1 );
+
+	if (cls.uiStarted) {
+		UI_SetActiveMenu("ingame",arg);
+	}
+}
+
+
+void CL_EndScreenDissolve_f(void)
+{
+	re.InitDissolve(qtrue);	// dissolve from cinematic to underlying ingame
+}
+
+void CL_DataPad_f(void)
+{		
+	if (cls.uiStarted && cls.cgameStarted && (cls.state == CA_ACTIVE) ) {
+		UI_SetActiveMenu("datapad",NULL);
+	}
+}
+
+/*
+====================
+CL_GetGlConfig
+====================
+*/
+static void CL_GetGlconfig( glconfig_t *config ) 
+{
+	*config = cls.glconfig;
+}
+/*
+int PC_ReadTokenHandle(int handle, pc_token_t *pc_token);
+int PC_SourceFileAndLine(int handle, char *filename, int *line);
+*/
+/*
+====================
+CL_UISystemCalls
+
+The ui module is making a system call
+====================
+*/
+vm_t	uivm;
+
+#define	VMA(x) ((void*)args[x])
+#define	VMF(x)	((float *)args)[x]
+int CL_UISystemCalls( int *args ) 
+{
+
+	switch( args[0] ) 
+	{
+	case UI_ERROR:
+		Com_Error( ERR_DROP, "%s", VMA(1) );
+		return 0;
+
+	case UI_CVAR_REGISTER:
+		Cvar_Register( (vmCvar_t *)VMA(1),(const char *) VMA(2),(const char *) VMA(3), args[4] ); 
+		return 0;
+
+	case UI_CVAR_SET:
+		Cvar_Set( (const char *) VMA(1), (const char *) VMA(2) );
+		return 0;
+
+	case UI_CVAR_SETVALUE:
+		Cvar_SetValue( (const char *) VMA(1), VMF(2) );
+		return 0;
+
+	case UI_CVAR_UPDATE:
+		Cvar_Update( (vmCvar_t *) VMA(1) );
+		return 0;
+
+	case UI_R_REGISTERMODEL:
+		return re.RegisterModel((const char *) VMA(1) );
+
+	case UI_R_REGISTERSHADERNOMIP:
+		return re.RegisterShaderNoMip((const char *) VMA(1) );
+
+	case UI_GETGLCONFIG:
+		CL_GetGlconfig( ( glconfig_t *) VMA(1) );
+		return 0;
+
+	case UI_CMD_EXECUTETEXT:
+		Cbuf_ExecuteText( args[1], (const char *) VMA(2) );
+		return 0;
+
+	case UI_CVAR_VARIABLEVALUE:
+		return FloatAsInt( Cvar_VariableValue( (const char *) VMA(1) ) );
+
+	case UI_FS_GETFILELIST:
+		return FS_GetFileList( (const char *) VMA(1), (const char *) VMA(2), (char *) VMA(3), args[4] );
+
+	case UI_KEY_SETCATCHER:
+		Key_SetCatcher( args[1] );
+		return 0;
+
+	case UI_KEY_CLEARSTATES:
+		Key_ClearStates();
+		return 0;
+
+	case UI_R_SETCOLOR:
+		re.SetColor( (const float *) VMA(1) );
+		return 0;
+
+	case UI_R_DRAWSTRETCHPIC:
+		re.DrawStretchPic( VMF(1), VMF(2), VMF(3), VMF(4), VMF(5), VMF(6), VMF(7), VMF(8), args[9] );
+		return 0;
+
+	case UI_CVAR_VARIABLESTRINGBUFFER:
+		Cvar_VariableStringBuffer( (const char *) VMA(1), (char *) VMA(2), args[3] );
+		return 0;
+
+  case UI_R_MODELBOUNDS:
+		re.ModelBounds( args[1], (float *) VMA(2),(float *) VMA(3) );
+		return 0;
+
+	case UI_R_CLEARSCENE:
+		re.ClearScene();
+		return 0;
+
+//	case UI_KEY_GETOVERSTRIKEMODE:
+//		return Key_GetOverstrikeMode();
+//		return 0;
+
+//	case UI_PC_READ_TOKEN:
+//		return PC_ReadTokenHandle( args[1], VMA(2) );
+		
+//	case UI_PC_SOURCE_FILE_AND_LINE:
+//		return PC_SourceFileAndLine( args[1], VMA(2), VMA(3) );
+
+	case UI_KEY_GETCATCHER:
+		return Key_GetCatcher();
+
+	case UI_MILLISECONDS:
+		return Sys_Milliseconds();
+
+	case UI_S_REGISTERSOUND:
+		return S_RegisterSound((const char *) VMA(1));
+
+	case UI_S_STARTLOCALSOUND:
+		S_StartLocalSound( args[1], args[2] );
+		return 0;
+
+//	case UI_R_REGISTERFONT:
+//		re.RegisterFont( VMA(1), args[2], VMA(3));
+//		return 0;
+
+	case UI_CIN_PLAYCINEMATIC:
+	  Com_DPrintf("UI_CIN_PlayCinematic\n");
+	  return CIN_PlayCinematic((const char *)VMA(1), args[2], args[3], args[4], args[5], args[6], (const char *)VMA(7));
+
+	case UI_CIN_STOPCINEMATIC:
+	  return CIN_StopCinematic(args[1]);
+
+	case UI_CIN_RUNCINEMATIC:
+	  return CIN_RunCinematic(args[1]);
+
+	case UI_CIN_DRAWCINEMATIC:
+	  CIN_DrawCinematic(args[1]);
+	  return 0;
+
+	case UI_KEY_SETBINDING:
+		Key_SetBinding( args[1], (const char *) VMA(2) );
+		return 0;
+
+	case UI_KEY_KEYNUMTOSTRINGBUF:
+		Key_KeynumToStringBuf( args[1],(char *) VMA(2), args[3] );
+		return 0;
+
+	case UI_CIN_SETEXTENTS:
+	  CIN_SetExtents(args[1], args[2], args[3], args[4], args[5]);
+	  return 0;
+
+	case UI_KEY_GETBINDINGBUF:
+		Key_GetBindingBuf( args[1], (char *) VMA(2), args[3] );
+		return 0;
+
+
+	default:
+		Com_Error( ERR_DROP, "Bad UI system trap: %i", args[0] );
+
+	}
+
+	return 0;
+}
+
diff --git a/code/client/client.h b/code/client/client.h
new file mode 100644
index 0000000..e8981a9
--- /dev/null
+++ b/code/client/client.h
@@ -0,0 +1,465 @@
+// client.h -- primary header for client
+#pragma once
+#ifndef __CLIENT_H__
+#define __CLIENT_H__
+
+#include "../game/q_shared.h"
+#include "../qcommon/qcommon.h"
+#include "../renderer/tr_public.h"
+#include "keys.h"
+#include "snd_public.h"
+#include "../cgame/cg_public.h"
+
+// snapshots are a view of the server at a given time
+typedef struct {
+	qboolean		valid;			// cleared if delta parsing was invalid
+	int				snapFlags;		// rate delayed and dropped commands
+
+	int				serverTime;		// server time the message is valid for (in msec)
+
+	int				messageNum;		// copied from netchan->incoming_sequence
+	int				deltaNum;		// messageNum the delta is from
+	int				ping;			// time from when cmdNum-1 was sent to time packet was reeceived
+	byte			areamask[MAX_MAP_AREA_BYTES];		// portalarea visibility bits
+
+	int				cmdNum;			// the next cmdNum the server is expecting
+	playerState_t	ps;						// complete information about the current player at this time
+
+	int				numEntities;			// all of the entities that need to be presented
+	int				parseEntitiesNum;		// at the time of this snapshot
+
+	int				serverCommandNum;		// execute all commands up to this before
+											// making the snapshot current
+} clSnapshot_t;
+
+
+
+/*
+=============================================================================
+
+the clientActive_t structure is wiped completely at every
+new gamestate_t, potentially several times during an established connection
+
+=============================================================================
+*/
+
+// the parseEntities array must be large enough to hold PACKET_BACKUP frames of
+// entities, so that when a delta compressed message arives from the server
+// it can be un-deltad from the original 
+#define MAX_PARSE_ENTITIES	512
+
+extern int g_console_field_width;
+
+typedef struct {
+	int			timeoutcount;
+
+	clSnapshot_t	frame;			// latest received from server
+
+	int			serverTime;
+	int			oldServerTime;		// to prevent time from flowing bakcwards
+	int			oldFrameServerTime;	// to check tournament restarts
+	int			serverTimeDelta;	// cl.serverTime = cls.realtime + cl.serverTimeDelta
+									// this value changes as net lag varies
+	qboolean	extrapolatedSnapshot;	// set if any cgame frame has been forced to extrapolate
+									// cleared when CL_AdjustTimeDelta looks at it
+	qboolean	newSnapshots;		// set on parse, cleared when CL_AdjustTimeDelta looks at it
+
+	gameState_t	gameState;			// configstrings
+	char		mapname[MAX_QPATH];	// extracted from CS_SERVERINFO
+
+	int			parseEntitiesNum;	// index (not anded off) into cl_parse_entities[]
+
+	int			mouseDx[2], mouseDy[2];	// added to by mouse events
+	int			mouseIndex;
+	int			joystickAxis[MAX_JOYSTICK_AXIS];	// set by joystick events
+
+	int			cgameUserCmdValue;	// current weapon to add to usercmd_t
+	float		cgameSensitivity;
+
+	// cmds[cmdNumber] is the predicted command, [cmdNumber-1] is the last
+	// properly generated command
+	usercmd_t	cmds[CMD_BACKUP];	// each mesage will send several old cmds
+	int			cmdNumber;			// incremented each frame, because multiple
+									// frames may need to be packed into a single packet
+
+	int			packetTime[PACKET_BACKUP];	// cls.realtime sent, for calculating pings
+	int			packetCmdNumber[PACKET_BACKUP];	// cmdNumber when packet was sent
+
+	// the client maintains its own idea of view angles, which are
+	// sent to the server each frame.  It is cleared to 0 upon entering each level.
+	// the server sends a delta each frame which is added to the locally
+	// tracked view angles to account for standing on rotating objects,
+	// and teleport direction changes
+	vec3_t		viewangles;
+
+	// these are just parsed out of the configstrings for convenience
+	int			serverId;
+
+	// non-gameserver infornamtion
+	int			cinematictime;		// cls.realtime for first cinematic frame (FIXME: NO LONGER USED!, but I wasn't sure if I could remove it because of struct sizes assumed elsewhere? -Ste)
+
+	// big stuff at end of structure so most offsets are 15 bits or less
+	clSnapshot_t	frames[PACKET_BACKUP];
+
+	entityState_t	parseEntities[MAX_PARSE_ENTITIES];
+
+	//DJC added - making force powers in single player work like those in
+	//multiplayer.  This makes hot swapping code more portable.
+	qboolean		gcmdSendValue;
+	byte			gcmdValue;
+} clientActive_t;
+
+extern	clientActive_t		cl;
+
+/*
+=============================================================================
+
+the clientConnection_t structure is wiped when disconnecting from a server,
+either to go to a full screen console, or connect to a different server
+
+A connection can be to either a server through the network layer,
+or just a streaming cinematic.
+
+=============================================================================
+*/
+
+
+typedef struct {		
+	int			lastPacketSentTime;			// for retransmits
+	int			lastPacketTime;
+	char		servername[MAX_OSPATH];		// name of server from original connect
+	netadr_t	serverAddress;
+	int			connectTime;		// for connection retransmits
+	int			connectPacketCount;	// for display on connection dialog
+
+	int			challenge;			// from the server to use for connecting
+
+	int			reliableSequence;
+	int			reliableAcknowledge;
+	char		*reliableCommands[MAX_RELIABLE_COMMANDS];
+
+	// reliable messages received from server
+	int			serverCommandSequence;
+	char		*serverCommands[MAX_RELIABLE_COMMANDS];
+
+	// big stuff at end of structure so most offsets are 15 bits or less
+	netchan_t	netchan;
+} clientConnection_t;
+
+extern	clientConnection_t clc;
+
+/*
+==================================================================
+
+the clientStatic_t structure is never wiped, and is used even when
+no client connection is active at all
+
+==================================================================
+*/
+
+typedef enum {
+	EXIT_CONSOLE,
+	EXIT_ARENAS,
+	EXIT_SERVERS,
+	EXIT_LAUNCH			// quit all the way out of the game on disconnect
+} exitTo_t;
+
+#ifdef _XBOX
+#define	MAX_LOCAL_SERVERS	1
+#define	MAX_GLOBAL_SERVERS	1
+#define MAX_PINGREQUESTS	1
+#else
+#define	MAX_LOCAL_SERVERS	16
+#define	MAX_GLOBAL_SERVERS	256
+#define MAX_PINGREQUESTS	16
+#endif
+
+typedef struct {
+	netadr_t	adr;
+	int			start;
+	int			time;
+} ping_t;
+
+typedef struct {
+	netadr_t	netadr;
+	char		info[MAX_INFO_STRING];
+} serverInfoResponse_t;
+
+typedef struct {
+	netadr_t	netadr;
+	char		info[MAX_INFO_STRING];
+} getserversResponse_t;
+
+typedef struct {
+	connstate_t	state;				// connection status
+	int			keyCatchers;		// bit flags
+
+	char		servername[MAX_OSPATH];		// name of server from original connect (used by reconnect)
+
+	// when the server clears the hunk, all of these must be restarted
+	qboolean	rendererStarted;
+	qboolean	soundStarted;
+	qboolean	soundRegistered;
+	qboolean	uiStarted;
+	qboolean	cgameStarted;
+#ifdef _IMMERSION
+	qboolean	forceStarted;
+#endif // _IMMERSION
+
+	int			framecount;
+	int			frametime;			// msec since last frame
+	float		frametimeFraction;	// fraction of a msec since last frame
+
+	int			realtime;			// ignores pause
+	float		realtimeFraction;	// fraction of a msec accumulated
+	int			realFrametime;		// ignoring pause, so console always works
+
+	// update server info
+	char		updateInfoString[MAX_INFO_STRING];
+
+	// rendering info
+	glconfig_t	glconfig;
+	qhandle_t	charSetShader;
+	qhandle_t	whiteShader;
+	qhandle_t	consoleShader;
+
+#ifdef _XBOX
+	short		mainGamepad;
+#endif
+} clientStatic_t;
+
+#ifdef _XBOX
+#define	CON_TEXTSIZE	256
+#else
+#define	CON_TEXTSIZE	32768
+#endif
+#define	NUM_CON_TIMES	4
+
+typedef struct {
+	qboolean	initialized;
+
+	short	text[CON_TEXTSIZE];
+	int		current;		// line where next message will be printed
+	int		x;				// offset in current line for next print
+	int		display;		// bottom of console displays this line
+
+	int 	linewidth;		// characters across screen
+	int		totallines;		// total lines in console scrollback
+
+	float	xadjust;		// for wide aspect screens
+	float	yadjust;		
+
+	float	displayFrac;	// aproaches finalFrac at scr_conspeed
+	float	finalFrac;		// 0.0 to 1.0 lines of console to display
+
+	int		vislines;		// in scanlines
+
+	int		times[NUM_CON_TIMES];	// cls.realtime time the line was generated
+								// for transparent notify lines
+	vec4_t	color;
+} console_t;
+
+extern	clientStatic_t		cls;
+
+//=============================================================================
+
+extern	refexport_t		re;		// interface to refresh .dll
+
+
+//
+// cvars
+//
+extern	cvar_t	*cl_nodelta;
+extern	cvar_t	*cl_debugMove;
+extern	cvar_t	*cl_noprint;
+extern	cvar_t	*cl_timegraph;
+extern	cvar_t	*cl_maxpackets;
+extern	cvar_t	*cl_packetdup;
+extern	cvar_t	*cl_shownet;
+extern	cvar_t	*cl_timeNudge;
+extern	cvar_t	*cl_showTimeDelta;
+
+extern	cvar_t	*cl_yawspeed;
+extern	cvar_t	*cl_pitchspeed;
+extern	cvar_t	*cl_run;
+extern	cvar_t	*cl_anglespeedkey;
+
+extern	cvar_t	*cl_sensitivity;
+extern	cvar_t	*cl_freelook;
+
+extern	cvar_t	*cl_mouseAccel;
+extern	cvar_t	*cl_showMouseRate;
+
+extern	cvar_t	*cl_ingameVideo;
+extern  cvar_t  *cl_VideoQuality;
+extern	cvar_t	*cl_VidFadeUp;
+extern	cvar_t	*cl_VidFadeDown;
+
+extern	cvar_t	*m_pitch;
+extern	cvar_t	*m_yaw;
+extern	cvar_t	*m_forward;
+extern	cvar_t	*m_side;
+extern	cvar_t	*m_filter;
+
+extern	cvar_t	*cl_activeAction;
+
+extern	cvar_t	*cl_thumbStickMode;
+
+//=================================================
+
+//
+// cl_main
+//
+
+void CL_Init (void);
+
+void CL_AddReliableCommand( const char *cmd );
+
+void CL_Disconnect_f (void);
+void CL_GetChallengePacket (void);
+void CL_Vid_Restart_f( void );
+void CL_Snd_Restart_f (void);
+
+void CL_NextDemo( void );
+
+void CL_GetPing( int n, char *adrstr, int *pingtime );
+void CL_ClearPing( int n );
+int CL_GetPingQueueCount( void );
+
+//
+// cl_input
+//
+typedef struct {
+	int			down[2];		// key nums holding it down
+	unsigned	downtime;		// msec timestamp
+	unsigned	msec;			// msec down this frame if both a down and up happened
+	qboolean	active;			// current state
+	qboolean	wasPressed;		// set when down, not cleared when up
+} kbutton_t;
+
+extern	kbutton_t	in_mlook, in_klook;
+extern 	kbutton_t 	in_strafe;
+extern 	kbutton_t 	in_speed;
+
+void CL_InitInput (void);
+void CL_SendCmd (void);
+void CL_ClearState (void);
+void CL_ReadPackets (void);
+void CL_UpdateHotSwap(void);
+bool CL_ExtendSelectTime(void);
+
+void CL_WritePacket( void );
+void IN_CenterView (void);
+
+float CL_KeyState (kbutton_t *key);
+const char *Key_KeynumToString( int keynum/*, qboolean bTranslate*/ ); //note: translate is only called for menu display not configs
+
+//
+// cl_parse.c
+//
+void CL_SystemInfoChanged( void );
+void CL_ParseServerMessage( msg_t *msg );
+
+//====================================================================
+
+void	VID_MenuInit( void );
+void	VID_MenuDraw( void );
+const char *VID_MenuKey( int );
+void VID_Printf (int print_level, const char *fmt, ...);
+
+
+//
+// console
+//
+void Con_DrawCharacter (int cx, int line, int num);
+
+void Con_CheckResize (void);
+void Con_Init (void);
+void Con_Clear_f (void);
+void Con_ToggleConsole_f (void);
+void Con_DrawNotify (void);
+void Con_ClearNotify (void);
+void Con_RunConsole (void);
+void Con_DrawConsole (void);
+void Con_PageUp( void );
+void Con_PageDown( void );
+void Con_Top( void );
+void Con_Bottom( void );
+void Con_Close( void );
+
+
+//
+// cl_scrn.c
+//
+void	SCR_Init (void);
+void	SCR_UpdateScreen (void);
+
+void	SCR_DebugGraph (float value, int color);
+
+int		SCR_GetBigStringWidth( const char *str );	// returns in virtual 640x480 coordinates
+
+void	SCR_FillRect( float x, float y, float width, float height, 
+					 const float *color );
+void	SCR_DrawPic( float x, float y, float width, float height, qhandle_t hShader );
+void	SCR_DrawNamedPic( float x, float y, float width, float height, const char *picname );
+
+void	SCR_DrawBigString( int x, int y, const char *s, float alpha );			// draws a string with embedded color control characters with fade
+void	SCR_DrawBigStringColor( int x, int y, const char *s, vec4_t color );	// ignores embedded color control characters
+void	SCR_DrawSmallString( int x, int y, const char *s, float alpha );			// draws a string with embedded color control characters with fade
+void	SCR_DrawSmallStringColor( int x, int y, const char *s, vec4_t color );	// ignores embedded color control characters
+void	SCR_DrawBigChar( int x, int y, int ch );
+void	SCR_DrawSmallChar( int x, int y, int ch );
+
+#ifdef _XBOX
+void	SCR_PrecacheScreenshot();
+#endif
+
+
+//
+// cl_cin.c
+//
+void CL_PlayCinematic_f( void );
+void CL_PlayInGameCinematic_f(void);
+qboolean CL_CheckPendingCinematic(void);
+qboolean CL_IsRunningInGameCinematic(void);
+qboolean CL_InGameCinematicOnStandBy(void);
+void SCR_DrawCinematic (void);
+void SCR_RunCinematic (void);
+void SCR_StopCinematic( qboolean bAllowRefusal = qfalse );
+
+int CIN_PlayCinematic( const char *arg0, int xpos, int ypos, int width, int height, int bits, const char *psAudioFile /* = NULL */);
+e_status CIN_StopCinematic(int handle);
+e_status CIN_RunCinematic (int handle);
+void CIN_DrawCinematic (int handle);
+void CIN_SetExtents (int handle, int x, int y, int w, int h);
+void CIN_SetLooping (int handle, qboolean loop);
+void CIN_UploadCinematic(int handle);
+void CIN_CloseAllVideos(void);
+
+#ifdef _XBOX
+void CIN_Init(void);
+bool CIN_PlayAllFrames( const char *arg, int x, int y, int w, int h, int systemBits, bool keyBreakAllowed );
+#endif
+
+
+//
+// cl_cgame.c
+//
+void CL_InitCGame( void );
+void CL_ShutdownCGame( void );
+qboolean CL_GameCommand( void );
+void CL_CGameRendering( stereoFrame_t stereo );
+void CL_SetCGameTime( void );
+void CL_FirstSnapshot( void );
+
+
+//
+// cl_ui.c
+//
+void CL_InitUI( void );
+void CL_ShutdownUI( void );
+void CL_GenericMenu_f(void);
+void CL_DataPad_f(void);
+void CL_EndScreenDissolve_f(void);
+
+#endif //__CLIENT_H__
diff --git a/code/client/client_ui.h b/code/client/client_ui.h
new file mode 100644
index 0000000..40525bd
--- /dev/null
+++ b/code/client/client_ui.h
@@ -0,0 +1,13 @@
+// client_ui.h -- header for client access to ui funcs
+#ifndef __CLIENTUI_H__
+#define __CLIENTUI_H__
+
+#include "../ui/ui_public.h"
+
+void _UI_KeyEvent( int key, qboolean down );
+void UI_SetActiveMenu( const char* menuname,const char *menuID );
+void UI_UpdateConnectionMessageString( char *string );
+qboolean UI_ConsoleCommand( void ) ;
+qboolean _UI_IsFullscreen( void );
+
+#endif //__CLIENTUI_H__
\ No newline at end of file
diff --git a/code/client/eax/EaxMan.h b/code/client/eax/EaxMan.h
new file mode 100644
index 0000000..c530911
--- /dev/null
+++ b/code/client/eax/EaxMan.h
@@ -0,0 +1,171 @@
+/*
+*/
+#ifndef __EAXMANH
+#define __EAXMANH
+
+#define COM_NO_WINDOWS_H
+#include <objbase.h>
+#include "eax.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+//#define CLSID_EAXMANAGER CLSID_EAX20_Manager
+//#define IID_IEaxManager IID_EAX20_Manager
+#define EM_MAX_NAME 32
+
+#define EMFLAG_IDDEFAULT (-1)
+#define EMFLAG_IDNONE (-2)
+#define EMFLAG_LOCKPOSITION 1
+#define EMFLAG_LOADFROMMEMORY 2
+#define EMFLAG_NODIFFRACTION 4
+
+typedef struct _EMPOINT {
+ float fX;
+ float fY;
+ float fZ;
+} EMPOINT;
+typedef EMPOINT FAR *LPEMPOINT;
+
+typedef struct _LISTENERATTRIBUTES {
+ float fDistanceFactor;
+ float fRolloffFactor;
+ float fDopplerFactor;
+} LISTENERATTRIBUTES;
+typedef LISTENERATTRIBUTES FAR *LPLISTENERATTRIBUTES;
+
+typedef struct _SOURCEATTRIBUTES {
+ EAXSOURCEPROPERTIES eaxAttributes;
+ unsigned long       ulInsideConeAngle;
+ unsigned long       ulOutsideConeAngle;
+ long                lConeOutsideVolume;
+ float               fConeXdir;
+ float               fConeYdir;
+ float               fConeZdir;
+ float               fMinDistance;
+ float               fMaxDistance;
+ long                lDupCount;
+ long                lPriority;
+} SOURCEATTRIBUTES; 
+typedef SOURCEATTRIBUTES FAR *LPSOURCEATTRIBUTES;
+
+typedef struct _MATERIALATTRIBUTES {
+ long  lLevel;
+ float fLFRatio;
+ float fRoomRatio;
+ DWORD dwFlags;
+} MATERIALATTRIBUTES;
+typedef MATERIALATTRIBUTES FAR *LPMATERIALATTRIBUTES;
+
+#define EMMATERIAL_OBSTRUCTS 1
+#define EMMATERIAL_OCCLUDES 3
+
+typedef struct _DIFFRACTIONBOX {
+ long    lSubspaceID;
+ EMPOINT empMin;
+ EMPOINT empMax;
+} DIFFRACTIONBOX;
+typedef DIFFRACTIONBOX FAR *LPDIFFRACTIONBOX;
+
+// {7CE4D6E6-562F-11d3-8812-005004062F83}
+DEFINE_GUID(CLSID_EAXMANAGER, 0x60b721a1, 0xf7c8, 0x11d2, 0xa0, 0x2e, 0x0, 0x50, 0x4, 0x6, 0x18, 0xb8);
+
+#ifdef __cplusplus
+struct IEaxManager;
+#endif // __cplusplus
+
+typedef struct IEaxManager *LPEAXMANAGER;
+
+// {7CE4D6E8-562F-11d3-8812-005004062F83}
+DEFINE_GUID(IID_IEaxManager, 0x60b721a2, 0xf7c8, 0x11d2, 0xa0, 0x2e, 0x0, 0x50, 0x4, 0x6, 0x18, 0xb8);
+
+#undef INTERFACE
+#define INTERFACE IEaxManager
+
+extern HRESULT __stdcall EaxManagerCreate(LPEAXMANAGER*);
+typedef HRESULT (__stdcall *LPEAXMANAGERCREATE)(LPEAXMANAGER*);
+
+DECLARE_INTERFACE_(IEaxManager, IUnknown)
+{
+ // IUnknown methods
+ STDMETHOD(QueryInterface)       (THIS_ REFIID, LPVOID *) PURE;
+ STDMETHOD_(ULONG,AddRef)        (THIS) PURE;
+ STDMETHOD_(ULONG,Release)       (THIS) PURE;
+
+ STDMETHOD(GetDataSetSize) (THIS_ unsigned long*, DWORD) PURE;
+ STDMETHOD(LoadDataSet) (THIS_ char*, DWORD) PURE;
+ STDMETHOD(FreeDataSet) (THIS_ DWORD) PURE;
+ STDMETHOD(GetListenerAttributes) (THIS_ LPLISTENERATTRIBUTES) PURE;
+ STDMETHOD(GetSourceID) (THIS_ char*, long*) PURE;
+ STDMETHOD(GetSourceAttributes) (THIS_ long, LPSOURCEATTRIBUTES) PURE;
+ STDMETHOD(GetSourceNumInstances) (THIS_ long, long*) PURE;
+ STDMETHOD(GetSourceInstancePos) (THIS_ long, long, LPEMPOINT) PURE;
+ STDMETHOD(GetEnvironmentID) (THIS_ char*, long*) PURE;
+ STDMETHOD(GetEnvironmentAttributes) (THIS_ long, LPEAXREVERBPROPERTIES) PURE;
+ STDMETHOD(GetMaterialID) (THIS_ char*, long*) PURE;
+ STDMETHOD(GetMaterialAttributes) (THIS_ long, LPMATERIALATTRIBUTES) PURE;
+ STDMETHOD(GetGeometrySetID) (THIS_ char*, long*) PURE;
+ STDMETHOD(GetListenerDynamicAttributes) (THIS_ long, LPEMPOINT, long*, DWORD) PURE;
+ STDMETHOD(GetSourceDynamicAttributes) (THIS_ long, LPEMPOINT, long*, float*, long*, float*, float*, LPEMPOINT, DWORD) PURE;
+// STDMETHOD(GetSubSpaceID) (THIS_ long, LPEMPOINT, long *) PURE;
+ STDMETHOD(GetEnvironmentName) (THIS_ long, char *szString, long lStrlen) PURE;
+};
+
+#if !defined(__cplusplus) || defined(CINTERFACE)
+#define IEaxManager_QueryInterface(p,a,b)                           (p)->lpVtbl->QueryInterface(p,a,b)
+#define IEaxManager_AddRef(p)                                       (p)->lpVtbl->AddRef(p)
+#define IEaxManager_Release(p)                                      (p)->lpVtbl->Release(p)
+#define IEaxManager_GetDataSetSize(p,a,b)                           (p)->lpVtbl->GetDataSetSize(p,a,b)
+#define IEaxManager_LoadDataSet(p,a,b)                              (p)->lpVtbl->LoadDataSet(p,a,b)
+#define IEaxManager_FreeDataSet(p,a)                                (p)->lpVtbl->FreeDataSet(p,a)
+#define IEaxManager_GetListenerAttributes(p,a)                      (p)->lpVtbl->GetListenerAttributes(p,a)
+#define IEaxManager_GetSourceID(p,a,b)                              (p)->lpVtbl->GetSourceID(p,a,b)
+#define IEaxManager_GetSourceAttributes(p,a,b)                      (p)->lpVtbl->GetSourceAttributes(p,a,b)
+#define IEaxManager_GetSourceNumInstances(p,a,b)                    (p)->lpVtbl->GetSourceNumInstances(p,a,b)
+#define IEaxManager_GetSourceInstancePos(p,a,b,c)                   (p)->lpVtbl->GetSourceInstancePos(p,a,b,c)
+#define IEaxManager_GetEnvironmentID(p,a,b)                         (p)->lpVtbl->GetEnvironmentID(p,a,b)
+#define IEaxManager_GetEnvironmentAttributes(p,a,b)                 (p)->lpVtbl->GetEnvironmentAttributes(p,a,b)
+#define IEaxManager_GetMaterialID(p,a,b)                            (p)->lpVtbl->GetMaterialID(p,a,b)
+#define IEaxManager_GetMaterialAttributes(p,a,b)                    (p)->lpVtbl->GetMaterialAttributes(p,a,b)
+#define IEaxManager_GetGeometrySetID(p,a,b)                         (p)->lpVtbl->GetGeometrySetID(p,a,b)
+#define IEaxManager_GetListenerDynamicAttributes(p,a,b,c,d)         (p)->lpVtbl->GetListenerDynamicAttributes(p,a,b,c,d)
+#define IEaxManager_GetSourceDynamicAttributes(p,a,b,c,d,e,f,g,h,i) (p)->lpVtbl->GetSourceDynamicAttributes(p,a,b,c,d,e,f,g,h,i)
+//#define IEaxManager_GetSubSpaceID(p,a,b,c)							(p)->lpVtbl->GetSubSpaceID(p,a,b,c)
+#define IEaxManager_GetEnvironmentName(p,a,b,c)						(p)->lpVtbl->GetEnvironmentName(p,a,b,c)
+#else
+#define IEaxManager_QueryInterface(p,a,b)                           (p)->QueryInterface(a,b)
+#define IEaxManager_AddRef(p)                                       (p)->AddRef()
+#define IEaxManager_Release(p)                                      (p)->Release()
+#define IEaxManager_GetDataSetSize(p,a,b)                           (p)->GetDataSetSize(a,b)
+#define IEaxManager_LoadDataSet(p,a,b)                              (p)->LoadDataSet(a,b)
+#define IEaxManager_FreeDataSet(p,a)                                (p)->FreeDataSet(a)
+#define IEaxManager_GetListenerAttributes(p,a)                      (p)->GetListenerAttributes(a)
+#define IEaxManager_GetSourceID(p,a,b)                              (p)->GetSourceID(a,b)
+#define IEaxManager_GetSourceAttributes(p,a,b)                      (p)->GetSourceAttributes(a,b)
+#define IEaxManager_GetSourceNumInstances(p,a,b)                    (p)->GetSourceNumInstances(a,b)
+#define IEaxManager_GetSourceInstancePos(p,a,b,c)                   (p)->GetSourceInstancePos(a,b,c)
+#define IEaxManager_GetEnvironmentID(p,a,b)                         (p)->GetEnvironmentID(a,b)
+#define IEaxManager_GetEnvironmentAttributes(p,a,b)                 (p)->GetEnvironmentAttributes(a,b)
+#define IEaxManager_GetMaterialID(p,a,b)                            (p)->GetMaterialID(a,b)
+#define IEaxManager_GetMaterialAttributes(p,a,b)                    (p)->GetMaterialAttributes(a,b)
+#define IEaxManager_GetGeometrySetID(p,a,b)                         (p)->GetGeometrySetID(a,b)
+#define IEaxManager_GetListenerDynamicAttributes(p,a,b,c,d)         (p)->GetListenerDynamicAttributes(a,b,c,d)
+#define IEaxManager_GetSourceDynamicAttributes(p,a,b,c,d,e,f,g,h,i) (p)->GetSourceDynamicAttributes(a,b,c,d,e,f,g,h,i)
+//#define IEaxManager_GetSubSpaceID(p,a,b,c)							(p)->GetSubSpaceID(a,b,c)
+#define IEaxManager_GetEnvironmentName(p,a,b,c)						(p)->GetEnvironmentName(a,b,c)
+#endif
+
+#define EM_OK 0
+#define EM_INVALIDID        MAKE_HRESULT(1, FACILITY_ITF, 1)
+#define EM_IDNOTFOUND       MAKE_HRESULT(1, FACILITY_ITF, 2)
+#define EM_FILENOTFOUND     MAKE_HRESULT(1, FACILITY_ITF, 3)
+#define EM_FILEINVALID      MAKE_HRESULT(1, FACILITY_ITF, 4)
+#define EM_VERSIONINVALID   MAKE_HRESULT(1, FACILITY_ITF, 5)
+#define EM_INSTANCENOTFOUND MAKE_HRESULT(1, FACILITY_ITF, 6)
+
+#ifdef __cplusplus
+};
+#endif // __cplusplus
+
+#endif
diff --git a/code/client/eax/eax.h b/code/client/eax/eax.h
new file mode 100644
index 0000000..538cc6c
--- /dev/null
+++ b/code/client/eax/eax.h
@@ -0,0 +1,1562 @@
+/*******************************************************************\
+*                                                                   *
+*  EAX.H - Environmental Audio Extensions version 4.0               *
+*          for OpenAL and DirectSound3D                             *
+*                                                                   *
+*          File revision 1.6.3 (21 February 2003)                   *
+*          EAX 4.0 API Spec version 1.6                             *
+*                                                                   *
+\*******************************************************************/
+
+#ifndef EAX_H_INCLUDED
+#define EAX_H_INCLUDED
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+#ifndef OPENAL
+    #include <dsound.h>
+
+    /*
+     * EAX Unified Interface (using Direct X 7) {4FF53B81-1CE0-11d3-AAB8-00A0C95949D5}
+     */
+    DEFINE_GUID(CLSID_EAXDirectSound, 
+        0x4ff53b81, 
+        0x1ce0, 
+        0x11d3,
+        0xaa, 0xb8, 0x0, 0xa0, 0xc9, 0x59, 0x49, 0xd5);
+        
+   /*
+    * EAX Unified Interface (using Direct X 8) {CA503B60-B176-11d4-A094-D0C0BF3A560C}
+    */
+    DEFINE_GUID(CLSID_EAXDirectSound8, 
+        0xca503b60,
+        0xb176,
+        0x11d4,
+        0xa0, 0x94, 0xd0, 0xc0, 0xbf, 0x3a, 0x56, 0xc);
+
+    
+
+#ifdef DIRECTSOUND_VERSION        
+#if DIRECTSOUND_VERSION >= 0x0800
+    __declspec(dllimport) HRESULT WINAPI EAXDirectSoundCreate8(GUID*, LPDIRECTSOUND8*, IUnknown FAR *);
+    typedef HRESULT (FAR PASCAL *LPEAXDIRECTSOUNDCREATE8)(GUID*, LPDIRECTSOUND8*, IUnknown FAR*);
+#endif
+#endif
+    
+    __declspec(dllimport) HRESULT WINAPI EAXDirectSoundCreate(GUID*, LPDIRECTSOUND*, IUnknown FAR *);
+    typedef HRESULT (FAR PASCAL *LPEAXDIRECTSOUNDCREATE)(GUID*, LPDIRECTSOUND*, IUnknown FAR*);
+
+#else // OPENAL
+    #include "../OpenAl/al.h"
+    
+    #ifndef GUID_DEFINED
+        #define GUID_DEFINED
+        typedef struct _GUID
+        {
+            unsigned long Data1;
+            unsigned short Data2;
+            unsigned short Data3;
+            unsigned char Data4[8];
+        } GUID;
+    #endif // GUID_DEFINED
+
+    #ifndef DEFINE_GUID
+        #ifndef INITGUID
+            #define DEFINE_GUID(name, l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8) \
+                    extern const GUID /*FAR*/ name
+        #else
+            #define DEFINE_GUID(name, l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8) \
+                    extern const GUID name = { l, w1, w2, { b1, b2,  b3,  b4,  b5,  b6,  b7,  b8 } }
+        #endif // INITGUID
+    #endif // DEFINE_GUID
+
+    /*
+     * EAX OpenAL Extensions
+     */
+    typedef ALenum (*EAXSet)(const GUID*, ALuint, ALuint, ALvoid*, ALuint);
+    typedef ALenum (*EAXGet)(const GUID*, ALuint, ALuint, ALvoid*, ALuint);
+#endif
+
+#pragma pack(push, 4)
+
+
+
+
+////////////////////////////////////////////////////////////////////////////
+// Constants
+
+#define EAX_MAX_FXSLOTS 4
+#define EAX_MAX_ACTIVE_FXSLOTS 2
+
+// The EAX_NULL_GUID is used by EAXFXSLOT_LOADEFFECT, EAXCONTEXT_PRIMARYFXSLOTID
+// and EAXSOURCE_ACTIVEFXSLOTID
+
+// {00000000-0000-0000-0000-000000000000}
+DEFINE_GUID(EAX_NULL_GUID, 
+    0x00000000, 
+    0x0000, 
+    0x0000, 
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00);
+
+// The EAX_PrimaryFXSlotID GUID is used by EAXSOURCE_ACTIVEFXSLOTID 
+
+// {F317866D-924C-450C-861B-E6DAA25E7C20}
+DEFINE_GUID(EAX_PrimaryFXSlotID, 
+    0xf317866d,
+    0x924c,
+    0x450c,
+    0x86, 0x1b, 0xe6, 0xda, 0xa2, 0x5e, 0x7c, 0x20);
+
+
+////////////////////////////////////////////////////////////////////////////
+
+    
+
+    
+////////////////////////////////////////////////////////////////////////////
+// Structures
+
+// Use this structure for EAXCONTEXT_ALL property.
+typedef struct _EAXCONTEXTPROPERTIES
+{
+    GUID          guidPrimaryFXSlotID;
+    float         flDistanceFactor;
+    float         flAirAbsorptionHF;
+    float         flHFReference;
+} EAXCONTEXTPROPERTIES, *LPEAXCONTEXTPROPERTIES; 
+
+// Use this structure for EAXSOURCE_ALLPARAMETERS
+// - all levels are hundredths of decibels
+// - all delays are in seconds
+//
+// NOTE: This structure may change in future EAX versions.
+//       It is recommended to initialize fields by name:
+//              myBuffer.lDirect = 0;
+//              myBuffer.lDirectHF = -200;
+//              ...
+//              myBuffer.dwFlags = myFlags /* see EAXSOURCEFLAGS below */ ;
+//       instead of:
+//              myBuffer = { 0, -200, ... , 0x00000003 };
+//
+typedef struct _EAXSOURCEPROPERTIES
+{
+    long          lDirect;                 // direct path level (at low and mid frequencies)
+    long          lDirectHF;               // relative direct path level at high frequencies
+    long          lRoom;                   // room effect level (at low and mid frequencies)
+    long          lRoomHF;                 // relative room effect level at high frequencies
+    long          lObstruction;            // main obstruction control (attenuation at high frequencies) 
+    float         flObstructionLFRatio;    // obstruction low-frequency level re. main control
+    long          lOcclusion;              // main occlusion control (attenuation at high frequencies)
+    float         flOcclusionLFRatio;      // occlusion low-frequency level re. main control
+    float         flOcclusionRoomRatio;    // relative occlusion control for room effect
+    float         flOcclusionDirectRatio;  // relative occlusion control for direct path
+    long          lExclusion;              // main exlusion control (attenuation at high frequencies)
+    float         flExclusionLFRatio;      // exclusion low-frequency level re. main control
+    long          lOutsideVolumeHF;        // outside sound cone level at high frequencies
+    float         flDopplerFactor;         // like DS3D flDopplerFactor but per source
+    float         flRolloffFactor;         // like DS3D flRolloffFactor but per source
+    float         flRoomRolloffFactor;     // like DS3D flRolloffFactor but for room effect
+    float         flAirAbsorptionFactor;   // multiplies EAXREVERB_AIRABSORPTIONHF
+    unsigned long ulFlags;                 // modifies the behavior of properties
+} EAXSOURCEPROPERTIES, *LPEAXSOURCEPROPERTIES;
+
+// Use this structure for EAXSOURCE_ALLSENDPARAMETERS
+// - all levels are hundredths of decibels
+//
+typedef struct _EAXSOURCEALLSENDPROPERTIES
+{
+	GUID          guidReceivingFXSlotID;
+	long          lSend;                   // send level (at low and mid frequencies)
+	long          lSendHF;                 // relative send level at high frequencies
+	long          lOcclusion;
+	float         flOcclusionLFRatio;
+	float         flOcclusionRoomRatio;
+	float         flOcclusionDirectRatio;
+	long          lExclusion; 
+	float         flExclusionLFRatio;
+} EAXSOURCEALLSENDPROPERTIES, *LPEAXSOURCEALLSENDPROPERTIES;
+
+// Use this structure for EAXSOURCE_ACTIVEFXSLOTID
+typedef struct _EAXACTIVEFXSLOTS
+{
+    GUID          guidActiveFXSlots[EAX_MAX_ACTIVE_FXSLOTS];
+} EAXACTIVEFXSLOTS, *LPEAXACTIVEFXSLOTS;
+
+// Use this structure for EAXSOURCE_OBSTRUCTIONPARAMETERS property.
+typedef struct _EAXOBSTRUCTIONPROPERTIES
+{
+    long          lObstruction;
+    float         flObstructionLFRatio;
+} EAXOBSTRUCTIONPROPERTIES, *LPEAXOBSTRUCTIONPROPERTIES;
+
+// Use this structure for EAXSOURCE_OCCLUSIONPARAMETERS property.
+typedef struct _EAXOCCLUSIONPROPERTIES
+{
+    long          lOcclusion;
+    float         flOcclusionLFRatio;
+    float         flOcclusionRoomRatio;
+    float         flOcclusionDirectRatio;
+} EAXOCCLUSIONPROPERTIES, *LPEAXOCCLUSIONPROPERTIES;
+
+// Use this structure for EAXSOURCE_EXCLUSIONPARAMETERS property.
+typedef struct _EAXEXCLUSIONPROPERTIES
+{
+    long          lExclusion;
+    float         flExclusionLFRatio;
+} EAXEXCLUSIONPROPERTIES, *LPEAXEXCLUSIONPROPERTIES;
+
+// Use this structure for EAXSOURCE_SENDPARAMETERS properties.
+typedef struct _EAXSOURCESENDPROPERTIES
+{
+    GUID          guidReceivingFXSlotID;
+    long          lSend;
+    long          lSendHF;
+} EAXSOURCESENDPROPERTIES, *LPEAXSOURCESENDPROPERTIES;
+
+// Use this structure for EAXSOURCE_OCCLUSIONSENDPARAMETERS 
+typedef struct _EAXSOURCEOCCLUSIONSENDPROPERTIES
+{
+	GUID          guidReceivingFXSlotID;
+	long          lOcclusion;
+	float         flOcclusionLFRatio;
+	float         flOcclusionRoomRatio;
+	float         flOcclusionDirectRatio;
+} EAXSOURCEOCCLUSIONSENDPROPERTIES, *LPEAXSOURCEOCCLUSIONSENDPROPERTIES;
+
+// Use this structure for EAXSOURCE_EXCLUSIONSENDPARAMETERS
+typedef struct _EAXSOURCEEXCLUSIONSENDPROPERTIES
+{
+	GUID          guidReceivingFXSlotID;
+	long          lExclusion;
+	float         flExclusionLFRatio;
+} EAXSOURCEEXCLUSIONSENDPROPERTIES, *LPEAXSOURCEEXCLUSIONSENDPROPERTIES;
+
+// Use this structure for EAXFXSLOT_ALLPARAMETERS
+// - all levels are hundredths of decibels
+//
+// NOTE: This structure may change in future EAX versions.
+//       It is recommended to initialize fields by name:
+//              myFXSlot.guidLoadEffect = EAX_REVERB_EFFECT;
+//              myFXSlot.lVolume = 0;
+//              myFXSlot.lLock = 1;
+//              myFXSlot.ulFlags = myFlags /* see EAXFXSLOTFLAGS below */ ;
+//       instead of:
+//              myFXSlot = { EAX_REVERB_EFFECT, 0, 1, 0x00000001 };
+//
+typedef struct _EAXFXSLOTPROPERTIES
+{
+	GUID          guidLoadEffect;
+	long          lVolume;
+	long          lLock;
+	unsigned long ulFlags;
+} EAXFXSLOTPROPERTIES, *LPEAXFXSLOTPROPERTIES;
+
+// Use this structure for EAXREVERB_REFLECTIONSPAN and EAXREVERB_REVERBPAN properties.
+#ifndef EAXVECTOR_DEFINED
+#define EAXVECTOR_DEFINED
+typedef struct _EAXVECTOR {
+    float x;
+    float y;
+    float z;
+} EAXVECTOR;
+#endif
+
+
+////////////////////////////////////////////////////////////////////////////
+
+
+
+
+////////////////////////////////////////////////////////////////////////////
+// Error Codes
+
+#define EAX_OK                     0
+#define EAXERR_INVALID_OPERATION   (-1)
+#define EAXERR_INVALID_VALUE       (-2)
+#define EAXERR_NO_EFFECT_LOADED    (-3)
+#define EAXERR_UNKNOWN_EFFECT      (-4)
+////////////////////////////////////////////////////////////////////////////
+
+
+
+
+////////////////////////////////////////////////////////////////////////////
+// Context Object
+
+// {1D4870AD-0DEF-43c0-A40C-523632296342}
+DEFINE_GUID(EAXPROPERTYID_EAX40_Context, 
+    0x1d4870ad, 
+    0xdef, 
+    0x43c0, 
+    0xa4, 0xc, 0x52, 0x36, 0x32, 0x29, 0x63, 0x42);
+
+// For compatibility with future EAX versions:
+#define EAXPROPERTYID_EAX_Context EAXPROPERTYID_EAX40_Context
+
+typedef enum
+{
+    EAXCONTEXT_NONE = 0,
+    EAXCONTEXT_ALLPARAMETERS,
+    EAXCONTEXT_PRIMARYFXSLOTID,
+    EAXCONTEXT_DISTANCEFACTOR,
+    EAXCONTEXT_AIRABSORPTIONHF,
+    EAXCONTEXT_HFREFERENCE,
+    EAXCONTEXT_LASTERROR
+} EAXCONTEXT_PROPERTY;
+
+// OR these flags with property id
+#define EAXCONTEXT_PARAMETER_IMMEDIATE 0x00000000 // changes take effect immediately
+#define EAXCONTEXT_PARAMETER_DEFER     0x80000000 // changes take effect later
+#define EAXCONTEXT_PARAMETER_COMMITDEFERREDSETTINGS (EAXCONTEXT_NONE | \
+                                                      EAXCONTEXT_PARAMETER_IMMEDIATE)
+
+// EAX Context property ranges and defaults:
+#define EAXCONTEXT_DEFAULTPRIMARYFXSLOTID EAXPROPERTYID_EAX40_FXSlot0
+
+#define EAXCONTEXT_MINDISTANCEFACTOR        FLT_MIN //minimum positive value
+#define EAXCONTEXT_MAXDISTANCEFACTOR        FLT_MAX
+#define EAXCONTEXT_DEFAULTDISTANCEFACTOR    1.0f
+
+#define EAXCONTEXT_MINAIRABSORPTIONHF     (-100.0f)
+#define EAXCONTEXT_MAXAIRABSORPTIONHF     0.0f
+#define EAXCONTEXT_DEFAULTAIRABSORPTIONHF (-5.0f)
+
+#define EAXCONTEXT_MINHFREFERENCE         1000.0f
+#define EAXCONTEXT_MAXHFREFERENCE         20000.0f
+#define EAXCONTEXT_DEFAULTHFREFERENCE     5000.0f
+
+#define EAXCONTEXT_DEFAULTLASTERROR         EAX_OK
+
+////////////////////////////////////////////////////////////////////////////
+
+
+
+
+////////////////////////////////////////////////////////////////////////////
+// Effect Slot Objects
+
+// {C4D79F1E-F1AC-436b-A81D-A738E7045469}
+DEFINE_GUID(EAXPROPERTYID_EAX40_FXSlot0, 
+    0xc4d79f1e, 
+    0xf1ac, 
+    0x436b, 
+    0xa8, 0x1d, 0xa7, 0x38, 0xe7, 0x4, 0x54, 0x69);
+
+// {08C00E96-74BE-4491-93AA-E8AD35A49117}
+DEFINE_GUID(EAXPROPERTYID_EAX40_FXSlot1, 
+    0x8c00e96, 
+    0x74be, 
+    0x4491, 
+    0x93, 0xaa, 0xe8, 0xad, 0x35, 0xa4, 0x91, 0x17);
+
+// {1D433B88-F0F6-4637-919F-60E7E06B5EDD}
+DEFINE_GUID(EAXPROPERTYID_EAX40_FXSlot2, 
+    0x1d433b88, 
+    0xf0f6, 
+    0x4637, 
+    0x91, 0x9f, 0x60, 0xe7, 0xe0, 0x6b, 0x5e, 0xdd);
+
+// {EFFF08EA-C7D8-44ab-93AD-6DBD5F910064}
+DEFINE_GUID(EAXPROPERTYID_EAX40_FXSlot3, 
+    0xefff08ea, 
+    0xc7d8, 
+    0x44ab, 
+    0x93, 0xad, 0x6d, 0xbd, 0x5f, 0x91, 0x0, 0x64);
+
+// For compatibility with future EAX versions:
+#define EAXPROPERTYID_EAX_FXSlot0 EAXPROPERTYID_EAX40_FXSlot0
+#define EAXPROPERTYID_EAX_FXSlot1 EAXPROPERTYID_EAX40_FXSlot1
+#define EAXPROPERTYID_EAX_FXSlot2 EAXPROPERTYID_EAX40_FXSlot2
+#define EAXPROPERTYID_EAX_FXSlot3 EAXPROPERTYID_EAX40_FXSlot3
+
+// FXSlot object properties
+typedef enum
+{
+    EAXFXSLOT_PARAMETER = 0, // range 0-0x40 reserved for loaded effect parameters
+    EAXFXSLOT_NONE = 0x10000,
+	EAXFXSLOT_ALLPARAMETERS,
+    EAXFXSLOT_LOADEFFECT,
+    EAXFXSLOT_VOLUME,
+	EAXFXSLOT_LOCK,
+	EAXFXSLOT_FLAGS
+} EAXFXSLOT_PROPERTY;
+
+// Note: The number and order of flags may change in future EAX versions.
+//       To insure future compatibility, use flag defines as follows:
+//              myFlags = EAXFXSLOTFLAGS_ENVIRONMENT;
+//       instead of:
+//              myFlags = 0x00000001;
+//
+#define EAXFXSLOTFLAGS_ENVIRONMENT   0x00000001
+#define EAXFXSLOTFLAGS_RESERVED      0xFFFFFFFE // reserved future use
+
+// EAX Effect Slot property ranges and defaults:
+#define EAXFXSLOT_MINVOLUME                    (-10000)
+#define EAXFXSLOT_MAXVOLUME                    0
+#define EAXFXSLOT_DEFAULTVOLUME                0
+
+#define EAXFXSLOT_MINLOCK    0
+#define EAXFXSLOT_MAXLOCK    1
+
+enum
+{
+   EAXFXSLOT_UNLOCKED = 0,
+   EAXFXSLOT_LOCKED = 1
+};
+
+#define EAXFXSLOT_DEFAULTFLAGS                 (EAXFXSLOTFLAGS_ENVIRONMENT)
+////////////////////////////////////////////////////////////////////////////
+
+
+
+
+////////////////////////////////////////////////////////////////////////////
+// Source Object
+
+// {1B86B823-22DF-4eae-8B3C-1278CE544227}
+DEFINE_GUID(EAXPROPERTYID_EAX40_Source, 
+    0x1b86b823, 
+    0x22df, 
+    0x4eae, 
+    0x8b, 0x3c, 0x12, 0x78, 0xce, 0x54, 0x42, 0x27);
+
+// For compatibility with future EAX versions:
+#define EAXPROPERTYID_EAX_Source EAXPROPERTYID_EAX40_Source
+
+// Source object properties
+typedef enum
+{
+    EAXSOURCE_NONE,
+    EAXSOURCE_ALLPARAMETERS,
+    EAXSOURCE_OBSTRUCTIONPARAMETERS,
+    EAXSOURCE_OCCLUSIONPARAMETERS,
+    EAXSOURCE_EXCLUSIONPARAMETERS,
+    EAXSOURCE_DIRECT,
+    EAXSOURCE_DIRECTHF,
+    EAXSOURCE_ROOM,
+    EAXSOURCE_ROOMHF,
+    EAXSOURCE_OBSTRUCTION,
+    EAXSOURCE_OBSTRUCTIONLFRATIO,
+    EAXSOURCE_OCCLUSION,
+    EAXSOURCE_OCCLUSIONLFRATIO, 
+    EAXSOURCE_OCCLUSIONROOMRATIO,
+    EAXSOURCE_OCCLUSIONDIRECTRATIO,
+    EAXSOURCE_EXCLUSION, 
+    EAXSOURCE_EXCLUSIONLFRATIO,
+    EAXSOURCE_OUTSIDEVOLUMEHF, 
+    EAXSOURCE_DOPPLERFACTOR, 
+    EAXSOURCE_ROLLOFFFACTOR, 
+    EAXSOURCE_ROOMROLLOFFFACTOR,
+    EAXSOURCE_AIRABSORPTIONFACTOR,
+    EAXSOURCE_FLAGS,
+    EAXSOURCE_SENDPARAMETERS,
+    EAXSOURCE_ALLSENDPARAMETERS,
+    EAXSOURCE_OCCLUSIONSENDPARAMETERS,
+    EAXSOURCE_EXCLUSIONSENDPARAMETERS,
+    EAXSOURCE_ACTIVEFXSLOTID,
+} EAXSOURCE_PROPERTY;
+
+// OR these flags with property id
+#define EAXSOURCE_PARAMETER_IMMEDIATE 0x00000000 // changes take effect immediately
+#define EAXSOURCE_PARAMETER_DEFERRED  0x80000000 // changes take effect later
+#define EAXSOURCE_PARAMETER_COMMITDEFERREDSETTINGS (EAXSOURCE_NONE | \
+                                                    EAXSOURCE_PARAMETER_IMMEDIATE)
+// Used by EAXSOURCE_FLAGS for EAXSOURCEFLAGS_xxxAUTO
+//    TRUE:    value is computed automatically - property is an offset
+//    FALSE:   value is used directly
+//
+// Note: The number and order of flags may change in future EAX versions.
+//       To insure future compatibility, use flag defines as follows:
+//              myFlags = EAXSOURCE_DIRECTHFAUTO | EAXSOURCE_ROOMAUTO;
+//       instead of:
+//              myFlags = 0x00000003;
+//
+#define EAXSOURCEFLAGS_DIRECTHFAUTO          0x00000001 // relates to EAXSOURCE_DIRECTHF
+#define EAXSOURCEFLAGS_ROOMAUTO              0x00000002 // relates to EAXSOURCE_ROOM
+#define EAXSOURCEFLAGS_ROOMHFAUTO            0x00000004 // relates to EAXSOURCE_ROOMHF
+#define EAXSOURCEFLAGS_RESERVED              0xFFFFFFF8 // reserved future use
+
+// EAX Source property ranges and defaults:
+#define EAXSOURCE_MINSEND                      (-10000)
+#define EAXSOURCE_MAXSEND                      0
+#define EAXSOURCE_DEFAULTSEND                  0
+
+#define EAXSOURCE_MINSENDHF                    (-10000)
+#define EAXSOURCE_MAXSENDHF                    0
+#define EAXSOURCE_DEFAULTSENDHF                0
+
+#define EAXSOURCE_MINDIRECT                    (-10000)
+#define EAXSOURCE_MAXDIRECT                    1000
+#define EAXSOURCE_DEFAULTDIRECT                0
+
+#define EAXSOURCE_MINDIRECTHF                  (-10000)
+#define EAXSOURCE_MAXDIRECTHF                  0
+#define EAXSOURCE_DEFAULTDIRECTHF              0
+
+#define EAXSOURCE_MINROOM                      (-10000)
+#define EAXSOURCE_MAXROOM                      1000
+#define EAXSOURCE_DEFAULTROOM                  0
+
+#define EAXSOURCE_MINROOMHF                    (-10000)
+#define EAXSOURCE_MAXROOMHF                    0
+#define EAXSOURCE_DEFAULTROOMHF                0
+
+#define EAXSOURCE_MINOBSTRUCTION               (-10000)
+#define EAXSOURCE_MAXOBSTRUCTION               0
+#define EAXSOURCE_DEFAULTOBSTRUCTION           0
+
+#define EAXSOURCE_MINOBSTRUCTIONLFRATIO        0.0f
+#define EAXSOURCE_MAXOBSTRUCTIONLFRATIO        1.0f
+#define EAXSOURCE_DEFAULTOBSTRUCTIONLFRATIO    0.0f
+
+#define EAXSOURCE_MINOCCLUSION                 (-10000)
+#define EAXSOURCE_MAXOCCLUSION                 0
+#define EAXSOURCE_DEFAULTOCCLUSION             0
+
+#define EAXSOURCE_MINOCCLUSIONLFRATIO          0.0f
+#define EAXSOURCE_MAXOCCLUSIONLFRATIO          1.0f
+#define EAXSOURCE_DEFAULTOCCLUSIONLFRATIO      0.25f
+
+#define EAXSOURCE_MINOCCLUSIONROOMRATIO        0.0f
+#define EAXSOURCE_MAXOCCLUSIONROOMRATIO        10.0f
+#define EAXSOURCE_DEFAULTOCCLUSIONROOMRATIO    1.5f
+
+#define EAXSOURCE_MINOCCLUSIONDIRECTRATIO      0.0f
+#define EAXSOURCE_MAXOCCLUSIONDIRECTRATIO      10.0f
+#define EAXSOURCE_DEFAULTOCCLUSIONDIRECTRATIO  1.0f
+
+#define EAXSOURCE_MINEXCLUSION                 (-10000)
+#define EAXSOURCE_MAXEXCLUSION                 0
+#define EAXSOURCE_DEFAULTEXCLUSION             0
+
+#define EAXSOURCE_MINEXCLUSIONLFRATIO          0.0f
+#define EAXSOURCE_MAXEXCLUSIONLFRATIO          1.0f
+#define EAXSOURCE_DEFAULTEXCLUSIONLFRATIO      1.0f
+
+#define EAXSOURCE_MINOUTSIDEVOLUMEHF           (-10000)
+#define EAXSOURCE_MAXOUTSIDEVOLUMEHF           0
+#define EAXSOURCE_DEFAULTOUTSIDEVOLUMEHF       0
+
+#define EAXSOURCE_MINDOPPLERFACTOR             0.0f
+#define EAXSOURCE_MAXDOPPLERFACTOR             10.f
+#define EAXSOURCE_DEFAULTDOPPLERFACTOR         1.0f
+
+#define EAXSOURCE_MINROLLOFFFACTOR             0.0f
+#define EAXSOURCE_MAXROLLOFFFACTOR             10.f
+#define EAXSOURCE_DEFAULTROLLOFFFACTOR         0.0f
+
+#define EAXSOURCE_MINROOMROLLOFFFACTOR         0.0f
+#define EAXSOURCE_MAXROOMROLLOFFFACTOR         10.f
+#define EAXSOURCE_DEFAULTROOMROLLOFFFACTOR     0.0f
+
+#define EAXSOURCE_MINAIRABSORPTIONFACTOR       0.0f
+#define EAXSOURCE_MAXAIRABSORPTIONFACTOR       10.0f
+#define EAXSOURCE_DEFAULTAIRABSORPTIONFACTOR   0.0f
+
+#define EAXSOURCE_DEFAULTFLAGS                 (EAXSOURCEFLAGS_DIRECTHFAUTO |       \
+                                                EAXSOURCEFLAGS_ROOMAUTO     |       \
+                                                EAXSOURCEFLAGS_ROOMHFAUTO  )
+
+#define EAXSOURCE_DEFAULTACTIVEFXSLOTID  {{ EAX_NULL_GUID.Data1, EAX_NULL_GUID.Data2, EAX_NULL_GUID.Data3, \
+                                    EAX_NULL_GUID.Data4[0],EAX_NULL_GUID.Data4[1],EAX_NULL_GUID.Data4[2],\
+                                    EAX_NULL_GUID.Data4[3],EAX_NULL_GUID.Data4[4],EAX_NULL_GUID.Data4[5],\
+                                    EAX_NULL_GUID.Data4[6],EAX_NULL_GUID.Data4[7] },                       \
+                                  { EAX_PrimaryFXSlotID.Data1, EAX_PrimaryFXSlotID.Data2, \
+                                    EAX_PrimaryFXSlotID.Data3, EAX_PrimaryFXSlotID.Data4[0],\
+                                    EAX_PrimaryFXSlotID.Data4[1],EAX_PrimaryFXSlotID.Data4[2],\
+                                    EAX_PrimaryFXSlotID.Data4[3],EAX_PrimaryFXSlotID.Data4[4],\
+                                    EAX_PrimaryFXSlotID.Data4[5],EAX_PrimaryFXSlotID.Data4[6],\
+                                    EAX_PrimaryFXSlotID.Data4[7] }}
+
+
+////////////////////////////////////////////////////////////////////////////
+
+
+
+
+////////////////////////////////////////////////////////////////////////////
+// Reverb Effect
+
+// EAX REVERB {0CF95C8F-A3CC-4849-B0B6-832ECC1822DF}
+DEFINE_GUID(EAX_REVERB_EFFECT, 
+    0xcf95c8f, 
+    0xa3cc, 
+    0x4849, 
+    0xb0, 0xb6, 0x83, 0x2e, 0xcc, 0x18, 0x22, 0xdf);
+
+// Reverb effect properties
+typedef enum
+{
+    EAXREVERB_NONE,
+    EAXREVERB_ALLPARAMETERS,
+    EAXREVERB_ENVIRONMENT,
+    EAXREVERB_ENVIRONMENTSIZE,
+    EAXREVERB_ENVIRONMENTDIFFUSION,
+    EAXREVERB_ROOM,
+    EAXREVERB_ROOMHF,
+    EAXREVERB_ROOMLF,
+    EAXREVERB_DECAYTIME,
+    EAXREVERB_DECAYHFRATIO,
+    EAXREVERB_DECAYLFRATIO,
+    EAXREVERB_REFLECTIONS,
+    EAXREVERB_REFLECTIONSDELAY,
+    EAXREVERB_REFLECTIONSPAN,
+    EAXREVERB_REVERB,
+    EAXREVERB_REVERBDELAY,
+    EAXREVERB_REVERBPAN,
+    EAXREVERB_ECHOTIME,
+    EAXREVERB_ECHODEPTH,
+    EAXREVERB_MODULATIONTIME,
+    EAXREVERB_MODULATIONDEPTH,
+    EAXREVERB_AIRABSORPTIONHF,
+    EAXREVERB_HFREFERENCE,
+    EAXREVERB_LFREFERENCE,
+    EAXREVERB_ROOMROLLOFFFACTOR,
+    EAXREVERB_FLAGS,
+} EAXREVERB_PROPERTY;
+
+// OR these flags with property id
+#define EAXREVERB_IMMEDIATE 0x00000000 // changes take effect immediately
+#define EAXREVERB_DEFERRED  0x80000000 // changes take effect later
+#define EAXREVERB_COMMITDEFERREDSETTINGS (EAXREVERB_NONE | \
+                                          EAXREVERB_IMMEDIATE)
+
+// used by EAXREVERB_ENVIRONMENT
+enum
+{
+    EAX_ENVIRONMENT_GENERIC,
+    EAX_ENVIRONMENT_PADDEDCELL,
+    EAX_ENVIRONMENT_ROOM,
+    EAX_ENVIRONMENT_BATHROOM,
+    EAX_ENVIRONMENT_LIVINGROOM,
+    EAX_ENVIRONMENT_STONEROOM,
+    EAX_ENVIRONMENT_AUDITORIUM,
+    EAX_ENVIRONMENT_CONCERTHALL,
+    EAX_ENVIRONMENT_CAVE,
+    EAX_ENVIRONMENT_ARENA,
+    EAX_ENVIRONMENT_HANGAR,
+    EAX_ENVIRONMENT_CARPETEDHALLWAY,
+    EAX_ENVIRONMENT_HALLWAY,
+    EAX_ENVIRONMENT_STONECORRIDOR,
+    EAX_ENVIRONMENT_ALLEY,
+    EAX_ENVIRONMENT_FOREST,
+    EAX_ENVIRONMENT_CITY,
+    EAX_ENVIRONMENT_MOUNTAINS,
+    EAX_ENVIRONMENT_QUARRY,
+    EAX_ENVIRONMENT_PLAIN,
+    EAX_ENVIRONMENT_PARKINGLOT,
+    EAX_ENVIRONMENT_SEWERPIPE,
+    EAX_ENVIRONMENT_UNDERWATER,
+    EAX_ENVIRONMENT_DRUGGED,
+    EAX_ENVIRONMENT_DIZZY,
+    EAX_ENVIRONMENT_PSYCHOTIC,
+
+    EAX_ENVIRONMENT_UNDEFINED,
+
+    EAX_ENVIRONMENT_COUNT
+};
+
+// Used by EAXREVERB_FLAGS
+//
+// Note: The number and order of flags may change in future EAX versions.
+//       It is recommended to use the flag defines as follows:
+//              myFlags = EAXREVERBFLAGS_DECAYTIMESCALE | EAXREVERBFLAGS_REVERBSCALE;
+//       instead of:
+//              myFlags = 0x00000009;
+//
+// These flags determine what properties are affected by environment size.
+#define EAXREVERBFLAGS_DECAYTIMESCALE        0x00000001 // reverberation decay time
+#define EAXREVERBFLAGS_REFLECTIONSSCALE      0x00000002 // reflection level
+#define EAXREVERBFLAGS_REFLECTIONSDELAYSCALE 0x00000004 // initial reflection delay time
+#define EAXREVERBFLAGS_REVERBSCALE           0x00000008 // reflections level
+#define EAXREVERBFLAGS_REVERBDELAYSCALE      0x00000010 // late reverberation delay time
+#define EAXREVERBFLAGS_ECHOTIMESCALE         0x00000040 // echo time
+#define EAXREVERBFLAGS_MODULATIONTIMESCALE   0x00000080 // modulation time
+// This flag limits high-frequency decay time according to air absorption.
+#define EAXREVERBFLAGS_DECAYHFLIMIT          0x00000020
+#define EAXREVERBFLAGS_RESERVED              0xFFFFFF00 // reserved future use
+
+// Use this structure for EAXREVERB_ALLPARAMETERS
+// - all levels are hundredths of decibels
+// - all times and delays are in seconds
+//
+// NOTE: This structure may change in future EAX versions.
+//       It is recommended to initialize fields by name:
+//              myReverb.lRoom = -1000;
+//              myReverb.lRoomHF = -100;
+//              ...
+//              myReverb.dwFlags = myFlags /* see EAXREVERBFLAGS below */ ;
+//       instead of:
+//              myReverb = { -1000, -100, ... , 0x00000009 };
+//       If you want to save and load presets in binary form, you 
+//       should define your own structure to insure future compatibility.
+//
+typedef struct _EAXREVERBPROPERTIES
+{
+    unsigned long ulEnvironment;   // sets all reverb properties
+    float flEnvironmentSize;       // environment size in meters
+    float flEnvironmentDiffusion;  // environment diffusion
+    long lRoom;                    // room effect level (at mid frequencies)
+    long lRoomHF;                  // relative room effect level at high frequencies
+    long lRoomLF;                  // relative room effect level at low frequencies  
+    float flDecayTime;             // reverberation decay time at mid frequencies
+    float flDecayHFRatio;          // high-frequency to mid-frequency decay time ratio
+    float flDecayLFRatio;          // low-frequency to mid-frequency decay time ratio   
+    long lReflections;             // early reflections level relative to room effect
+    float flReflectionsDelay;      // initial reflection delay time
+    EAXVECTOR vReflectionsPan;     // early reflections panning vector
+    long lReverb;                  // late reverberation level relative to room effect
+    float flReverbDelay;           // late reverberation delay time relative to initial reflection
+    EAXVECTOR vReverbPan;          // late reverberation panning vector
+    float flEchoTime;              // echo time
+    float flEchoDepth;             // echo depth
+    float flModulationTime;        // modulation time
+    float flModulationDepth;       // modulation depth
+    float flAirAbsorptionHF;       // change in level per meter at high frequencies
+    float flHFReference;           // reference high frequency
+    float flLFReference;           // reference low frequency 
+    float flRoomRolloffFactor;     // like DS3D flRolloffFactor but for room effect
+    unsigned long ulFlags;         // modifies the behavior of properties
+} EAXREVERBPROPERTIES, *LPEAXREVERBPROPERTIES;
+
+// Property ranges and defaults:
+#define EAXREVERB_MINENVIRONMENT                0
+#define EAXREVERB_MAXENVIRONMENT               (EAX_ENVIRONMENT_COUNT-1)
+#define EAXREVERB_DEFAULTENVIRONMENT            EAX_ENVIRONMENT_GENERIC
+
+#define EAXREVERB_MINENVIRONMENTSIZE            1.0f
+#define EAXREVERB_MAXENVIRONMENTSIZE            100.0f
+#define EAXREVERB_DEFAULTENVIRONMENTSIZE        7.5f
+
+#define EAXREVERB_MINENVIRONMENTDIFFUSION       0.0f
+#define EAXREVERB_MAXENVIRONMENTDIFFUSION       1.0f
+#define EAXREVERB_DEFAULTENVIRONMENTDIFFUSION   1.0f
+
+#define EAXREVERB_MINROOM                       (-10000)
+#define EAXREVERB_MAXROOM                       0
+#define EAXREVERB_DEFAULTROOM                   (-1000)
+
+#define EAXREVERB_MINROOMHF                     (-10000)
+#define EAXREVERB_MAXROOMHF                     0
+#define EAXREVERB_DEFAULTROOMHF                 (-100)
+
+#define EAXREVERB_MINROOMLF                     (-10000)
+#define EAXREVERB_MAXROOMLF                     0
+#define EAXREVERB_DEFAULTROOMLF                 0
+
+#define EAXREVERB_MINDECAYTIME                  0.1f
+#define EAXREVERB_MAXDECAYTIME                  20.0f
+#define EAXREVERB_DEFAULTDECAYTIME              1.49f
+
+#define EAXREVERB_MINDECAYHFRATIO               0.1f
+#define EAXREVERB_MAXDECAYHFRATIO               2.0f
+#define EAXREVERB_DEFAULTDECAYHFRATIO           0.83f
+
+#define EAXREVERB_MINDECAYLFRATIO               0.1f
+#define EAXREVERB_MAXDECAYLFRATIO               2.0f
+#define EAXREVERB_DEFAULTDECAYLFRATIO           1.00f
+
+#define EAXREVERB_MINREFLECTIONS                (-10000)
+#define EAXREVERB_MAXREFLECTIONS                1000
+#define EAXREVERB_DEFAULTREFLECTIONS            (-2602)
+
+#define EAXREVERB_MINREFLECTIONSDELAY           0.0f
+#define EAXREVERB_MAXREFLECTIONSDELAY           0.3f
+#define EAXREVERB_DEFAULTREFLECTIONSDELAY       0.007f
+
+#define EAXREVERB_DEFAULTREFLECTIONSPAN         {0.0f, 0.0f, 0.0f}
+
+#define EAXREVERB_MINREVERB                     (-10000)
+#define EAXREVERB_MAXREVERB                     2000
+#define EAXREVERB_DEFAULTREVERB                 200
+
+#define EAXREVERB_MINREVERBDELAY                0.0f
+#define EAXREVERB_MAXREVERBDELAY                0.1f
+#define EAXREVERB_DEFAULTREVERBDELAY            0.011f
+
+#define EAXREVERB_DEFAULTREVERBPAN              {0.0f, 0.0f, 0.0f}
+
+#define EAXREVERB_MINECHOTIME                   0.075f
+#define EAXREVERB_MAXECHOTIME                      0.25f
+#define EAXREVERB_DEFAULTECHOTIME               0.25f
+
+#define EAXREVERB_MINECHODEPTH                  0.0f
+#define EAXREVERB_MAXECHODEPTH                  1.0f
+#define EAXREVERB_DEFAULTECHODEPTH              0.0f
+
+#define EAXREVERB_MINMODULATIONTIME             0.04f
+#define EAXREVERB_MAXMODULATIONTIME             4.0f
+#define EAXREVERB_DEFAULTMODULATIONTIME         0.25f
+
+#define EAXREVERB_MINMODULATIONDEPTH            0.0f
+#define EAXREVERB_MAXMODULATIONDEPTH            1.0f
+#define EAXREVERB_DEFAULTMODULATIONDEPTH        0.0f
+
+#define EAXREVERB_MINAIRABSORPTIONHF            (-100.0f)
+#define EAXREVERB_MAXAIRABSORPTIONHF            0.0f
+#define EAXREVERB_DEFAULTAIRABSORPTIONHF        (-5.0f)
+
+#define EAXREVERB_MINHFREFERENCE                1000.0f
+#define EAXREVERB_MAXHFREFERENCE                20000.0f
+#define EAXREVERB_DEFAULTHFREFERENCE            5000.0f
+
+#define EAXREVERB_MINLFREFERENCE                20.0f
+#define EAXREVERB_MAXLFREFERENCE                1000.0f
+#define EAXREVERB_DEFAULTLFREFERENCE            250.0f
+
+#define EAXREVERB_MINROOMROLLOFFFACTOR          0.0f
+#define EAXREVERB_MAXROOMROLLOFFFACTOR          10.0f
+#define EAXREVERB_DEFAULTROOMROLLOFFFACTOR      0.0f
+
+#define EAXREVERB_DEFAULTFLAGS                  (EAXREVERBFLAGS_DECAYTIMESCALE |        \
+                                                 EAXREVERBFLAGS_REFLECTIONSSCALE |      \
+                                                 EAXREVERBFLAGS_REFLECTIONSDELAYSCALE | \
+                                                 EAXREVERBFLAGS_REVERBSCALE |           \
+                                                 EAXREVERBFLAGS_REVERBDELAYSCALE |      \
+                                                 EAXREVERBFLAGS_DECAYHFLIMIT)
+////////////////////////////////////////////////////////////////////////////
+
+
+
+
+////////////////////////////////////////////////////////////////////////////
+
+//          New Effect Types
+
+////////////////////////////////////////////////////////////////////////////
+
+
+////////////////////////////////////////////////////////////////////////////
+// AGC Compressor Effect
+
+// EAX AGC COMPRESSOR {BFB7A01E-7825-4039-927F-3AABDA0C560}
+
+DEFINE_GUID(EAX_AGCCOMPRESSOR_EFFECT,
+    0xbfb7a01e,
+    0x7825,
+    0x4039,
+    0x92, 0x7f, 0x3, 0xaa, 0xbd, 0xa0, 0xc5, 0x60);
+
+// AGC Compressor properties
+typedef enum
+{
+    EAXAGCCOMPRESSOR_NONE,
+    EAXAGCCOMPRESSOR_ALLPARAMETERS,
+    EAXAGCCOMPRESSOR_ONOFF
+} EAXAGCCOMPRESSOR_PROPERTY;
+
+// OR these flags with property id
+#define EAXAGCCOMPRESSOR_IMMEDIATE 0x00000000 // changes take effect immediately
+#define EAXAGCCOMPRESSOR_DEFERRED  0x80000000 // changes take effect later
+#define EAXAGCCOMPRESSOR_COMMITDEFERREDSETTINGS (EAXAGCCOMPRESSOR_NONE | \
+                                                 EAXAGCCOMPRESSOR_IMMEDIATE)
+
+// Use this structure for EAXAGCCOMPRESSOR_ALLPARAMETERS
+typedef struct _EAXAGCCOMPRESSORPROPERTIES
+{
+    unsigned long ulOnOff;   // Switch Compressor on or off
+} EAXAGCCOMPRESSORPROPERTIES, *LPEAXAGCCOMPRESSORPROPERTIES;
+
+// Property ranges and defaults:
+
+#define EAXAGCCOMPRESSOR_MINONOFF           0
+#define EAXAGCCOMPRESSOR_MAXONOFF           1
+#define EAXAGCCOMPRESSOR_DEFAULTONOFF       1
+
+////////////////////////////////////////////////////////////////////////////
+
+
+////////////////////////////////////////////////////////////////////////////
+// Autowah Effect
+
+// EAX AUTOWAH {EC3130C0-AC7A-11D2-88DD-A024D13CE1}
+DEFINE_GUID(EAX_AUTOWAH_EFFECT, 
+    0xec3130c0,
+    0xac7a,
+    0x11d2,
+    0x88, 0xdd, 0x0, 0xa0, 0x24, 0xd1, 0x3c, 0xe1);
+
+// Autowah properties
+typedef enum
+{
+    EAXAUTOWAH_NONE,
+    EAXAUTOWAH_ALLPARAMETERS,
+    EAXAUTOWAH_ATTACKTIME,
+    EAXAUTOWAH_RELEASETIME,
+    EAXAUTOWAH_RESONANCE,
+    EAXAUTOWAH_PEAKLEVEL
+} EAXAUTOWAH_PROPERTY;
+
+// OR these flags with property id
+#define EAXAUTOWAH_IMMEDIATE 0x00000000 // changes take effect immediately
+#define EAXAUTOWAH_DEFERRED  0x80000000 // changes take effect later
+#define EAXAUTOWAH_COMMITDEFERREDSETTINGS (EAXAUTOWAH_NONE | \
+                                           EAXAUTOWAH_IMMEDIATE)
+
+// Use this structure for EAXAUTOWAH_ALLPARAMETERS
+typedef struct _EAXAUTOWAHPROPERTIES
+{
+    float   flAttackTime;                // Attack time (seconds)
+    float   flReleaseTime;          // Release time (seconds)
+    long    lResonance;             // Resonance (mB)
+    long    lPeakLevel;             // Peak level (mB)
+} EAXAUTOWAHPROPERTIES, *LPEAXAUTOWAHPROPERTIES;
+
+// Property ranges and defaults:
+
+#define EAXAUTOWAH_MINATTACKTIME            0.0001f 
+#define EAXAUTOWAH_MAXATTACKTIME            1.0f
+#define EAXAUTOWAH_DEFAULTATTACKTIME        0.06f
+
+#define EAXAUTOWAH_MINRELEASETIME           0.0001f
+#define EAXAUTOWAH_MAXRELEASETIME           1.0f
+#define EAXAUTOWAH_DEFAULTRELEASETIME       0.06f
+
+#define EAXAUTOWAH_MINRESONANCE             600     
+#define EAXAUTOWAH_MAXRESONANCE             6000
+#define EAXAUTOWAH_DEFAULTRESONANCE         6000
+
+#define EAXAUTOWAH_MINPEAKLEVEL             (-9000)
+#define EAXAUTOWAH_MAXPEAKLEVEL             9000
+#define EAXAUTOWAH_DEFAULTPEAKLEVEL         2100
+
+////////////////////////////////////////////////////////////////////////////
+
+
+////////////////////////////////////////////////////////////////////////////
+// Chorus Effect
+
+// EAX CHORUS {DE6D6FE0-AC79-11D2-88DD-A024D13CE1}
+
+DEFINE_GUID(EAX_CHORUS_EFFECT,
+    0xde6d6fe0,
+    0xac79,
+    0x11d2,
+    0x88, 0xdd, 0x0, 0xa0, 0x24, 0xd1, 0x3c, 0xe1);
+
+
+// Chorus properties
+typedef enum
+{
+    EAXCHORUS_NONE,
+    EAXCHORUS_ALLPARAMETERS,
+    EAXCHORUS_WAVEFORM,
+    EAXCHORUS_PHASE,
+    EAXCHORUS_RATE,
+    EAXCHORUS_DEPTH,
+    EAXCHORUS_FEEDBACK,
+    EAXCHORUS_DELAY
+} EAXCHORUS_PROPERTY;
+
+// OR these flags with property id
+#define EAXCHORUS_IMMEDIATE 0x00000000 // changes take effect immediately
+#define EAXCHORUS_DEFERRED  0x80000000 // changes take effect later
+#define EAXCHORUS_COMMITDEFERREDSETTINGS (EAXCHORUS_NONE | \
+                                          EAXCHORUS_IMMEDIATE)
+
+// used by EAXCHORUS_WAVEFORM
+enum
+{
+    EAX_CHORUS_SINUSOID,
+    EAX_CHORUS_TRIANGLE
+};
+
+// Use this structure for EAXCHORUS_ALLPARAMETERS
+typedef struct _EAXCHORUSPROPERTIES
+{
+    unsigned long   ulWaveform;      // Waveform selector - see enum above
+    long            lPhase;         // Phase (Degrees)
+    float           flRate;         // Rate (Hz)
+    float           flDepth;        // Depth (0 to 1)
+    float           flFeedback;     // Feedback (-1 to 1)
+    float           flDelay;        // Delay (seconds)
+} EAXCHORUSPROPERTIES, *LPEAXCHORUSPROPERTIES;
+
+// Property ranges and defaults:
+
+#define EAXCHORUS_MINWAVEFORM               0
+#define EAXCHORUS_MAXWAVEFORM               1
+#define EAXCHORUS_DEFAULTWAVEFORM           1
+
+#define EAXCHORUS_MINPHASE              (-180)
+#define EAXCHORUS_MAXPHASE              180
+#define EAXCHORUS_DEFAULTPHASE          90
+
+#define EAXCHORUS_MINRATE               0.0f
+#define EAXCHORUS_MAXRATE               10.0f
+#define EAXCHORUS_DEFAULTRATE           1.1f
+
+#define EAXCHORUS_MINDEPTH              0.0f
+#define EAXCHORUS_MAXDEPTH              1.0f
+#define EAXCHORUS_DEFAULTDEPTH          0.1f
+
+#define EAXCHORUS_MINFEEDBACK           (-1.0f)
+#define EAXCHORUS_MAXFEEDBACK           1.0f
+#define EAXCHORUS_DEFAULTFEEDBACK       0.25f
+
+#define EAXCHORUS_MINDELAY              0.0f
+#define EAXCHORUS_MAXDELAY              0.016f
+#define EAXCHORUS_DEFAULTDELAY          0.016f
+
+////////////////////////////////////////////////////////////////////////////
+
+
+////////////////////////////////////////////////////////////////////////////
+// Distortion Effect
+
+// EAX DISTORTION {975A4CE0-AC7E-11D2-88DD-A024D13CE1}
+
+DEFINE_GUID(EAX_DISTORTION_EFFECT,
+    0x975a4ce0,
+    0xac7e,
+    0x11d2,
+    0x88, 0xdd, 0x0, 0xa0, 0x24, 0xd1, 0x3c, 0xe1);
+
+// Distortion properties
+typedef enum
+{
+    EAXDISTORTION_NONE,
+    EAXDISTORTION_ALLPARAMETERS,
+    EAXDISTORTION_EDGE,
+    EAXDISTORTION_GAIN,
+    EAXDISTORTION_LOWPASSCUTOFF,
+    EAXDISTORTION_EQCENTER,
+    EAXDISTORTION_EQBANDWIDTH
+} EAXDISTORTION_PROPERTY;
+
+// OR these flags with property id
+#define EAXDISTORTION_IMMEDIATE 0x00000000 // changes take effect immediately
+#define EAXDISTORTION_DEFERRED  0x80000000 // changes take effect later
+#define EAXDISTORTION_COMMITDEFERREDSETTINGS (EAXDISTORTION_NONE | \
+                                              EAXDISTORTION_IMMEDIATE)
+
+// Use this structure for EAXDISTORTION_ALLPARAMETERS
+typedef struct _EAXDISTORTIONPROPERTIES
+{
+    float   flEdge;             // Controls the shape of the distortion (0 to 1)
+    long    lGain;              // Controls the post distortion gain (mB)
+    float   flLowPassCutOff;    // Controls the cut-off of the filter pre-distortion (Hz)
+    float   flEQCenter;         // Controls the center frequency of the EQ post-distortion (Hz)
+    float   flEQBandwidth;      // Controls the bandwidth of the EQ post-distortion (Hz)
+} EAXDISTORTIONPROPERTIES, *LPEAXDISTORTIONPROPERTIES;
+
+// Property ranges and defaults:
+
+#define EAXDISTORTION_MINEDGE               0.0f
+#define EAXDISTORTION_MAXEDGE               1.0f
+#define EAXDISTORTION_DEFAULTEDGE           0.2f
+
+#define EAXDISTORTION_MINGAIN               (-6000)
+#define EAXDISTORTION_MAXGAIN               0
+#define EAXDISTORTION_DEFAULTGAIN           (-2600)
+
+#define EAXDISTORTION_MINLOWPASSCUTOFF      80.0f
+#define EAXDISTORTION_MAXLOWPASSCUTOFF      24000.0f
+#define EAXDISTORTION_DEFAULTLOWPASSCUTOFF  8000.0f
+
+#define EAXDISTORTION_MINEQCENTER           80.0f
+#define EAXDISTORTION_MAXEQCENTER           24000.0f
+#define EAXDISTORTION_DEFAULTEQCENTER       3600.0f
+
+#define EAXDISTORTION_MINEQBANDWIDTH        80.0f
+#define EAXDISTORTION_MAXEQBANDWIDTH        24000.0f
+#define EAXDISTORTION_DEFAULTEQBANDWIDTH    3600.0f
+
+////////////////////////////////////////////////////////////////////////////
+
+
+////////////////////////////////////////////////////////////////////////////
+// Echo Effect
+
+// EAX ECHO {E9F1BC0-AC82-11D2-88DD-A024D13CE1}
+
+DEFINE_GUID(EAX_ECHO_EFFECT,
+    0xe9f1bc0,
+    0xac82,
+    0x11d2,
+    0x88, 0xdd, 0x0, 0xa0, 0x24, 0xd1, 0x3c, 0xe1);
+
+// Echo properties
+typedef enum
+{
+    EAXECHO_NONE,
+    EAXECHO_ALLPARAMETERS,
+    EAXECHO_DELAY,
+    EAXECHO_LRDELAY,
+    EAXECHO_DAMPING,
+    EAXECHO_FEEDBACK,
+    EAXECHO_SPREAD
+} EAXECHO_PROPERTY;
+
+// OR these flags with property id
+#define EAXECHO_IMMEDIATE 0x00000000 // changes take effect immediately
+#define EAXECHO_DEFERRED  0x80000000 // changes take effect later
+#define EAXECHO_COMMITDEFERREDSETTINGS (EAXECHO_NONE | \
+                                        EAXECHO_IMMEDIATE)
+
+// Use this structure for EAXECHO_ALLPARAMETERS
+typedef struct _EAXECHOPROPERTIES
+{
+    float   flDelay;            // Controls the initial delay time (seconds)
+    float   flLRDelay;          // Controls the delay time between the first and second taps (seconds)
+    float   flDamping;          // Controls a low-pass filter that dampens the echoes (0 to 1)
+    float   flFeedback;         // Controls the duration of echo repetition (0 to 1)
+    float   flSpread;           // Controls the left-right spread of the echoes
+} EAXECHOPROPERTIES, *LPEAXECHOPROPERTIES;
+
+// Property ranges and defaults:
+                    
+#define EAXECHO_MINDAMPING          0.0f
+#define EAXECHO_MAXDAMPING          0.99f
+#define EAXECHO_DEFAULTDAMPING      0.5f
+
+#define EAXECHO_MINDELAY            0.0f
+#define EAXECHO_MAXDELAY            0.207f
+#define EAXECHO_DEFAULTDELAY        0.1f
+
+#define EAXECHO_MINLRDELAY          0.0f
+#define EAXECHO_MAXLRDELAY          0.404f
+#define EAXECHO_DEFAULTLRDELAY      0.1f
+
+#define EAXECHO_MINFEEDBACK         0.0f
+#define EAXECHO_MAXFEEDBACK         1.0f
+#define EAXECHO_DEFAULTFEEDBACK     0.5f
+
+#define EAXECHO_MINSPREAD           (-1.0f)
+#define EAXECHO_MAXSPREAD             1.0f
+#define EAXECHO_DEFAULTSPREAD       (-1.0f)
+
+////////////////////////////////////////////////////////////////////////////
+
+
+////////////////////////////////////////////////////////////////////////////
+// Equalizer Effect
+
+// EAX EQUALIZER {65F94CE0-9793-11D3-939D-C0F02DD6F0}
+
+DEFINE_GUID(EAX_EQUALIZER_EFFECT,
+    0x65f94ce0,
+    0x9793,
+    0x11d3,
+    0x93, 0x9d, 0x0, 0xc0, 0xf0, 0x2d, 0xd6, 0xf0);
+
+
+// Equalizer properties
+typedef enum
+{
+    EAXEQUALIZER_NONE,
+    EAXEQUALIZER_ALLPARAMETERS,
+    EAXEQUALIZER_LOWGAIN,
+    EAXEQUALIZER_LOWCUTOFF,
+    EAXEQUALIZER_MID1GAIN,
+    EAXEQUALIZER_MID1CENTER,
+    EAXEQUALIZER_MID1WIDTH,
+    EAXEQUALIZER_MID2GAIN,
+    EAXEQUALIZER_MID2CENTER,
+    EAXEQUALIZER_MID2WIDTH,
+    EAXEQUALIZER_HIGHGAIN,
+    EAXEQUALIZER_HIGHCUTOFF
+} EAXEQUALIZER_PROPERTY;
+
+// OR these flags with property id
+#define EAXEQUALIZER_IMMEDIATE 0x00000000 // changes take effect immediately
+#define EAXEQUALIZER_DEFERRED  0x80000000 // changes take effect later
+#define EAXEQUALIZER_COMMITDEFERREDSETTINGS (EAXEQUALIZER_NONE | \
+                                             EAXEQUALIZER_IMMEDIATE)
+
+// Use this structure for EAXEQUALIZER_ALLPARAMETERS
+typedef struct _EAXEQUALIZERPROPERTIES
+{
+    long    lLowGain;           // (mB)
+    float   flLowCutOff;        // (Hz)
+    long    lMid1Gain;          // (mB)
+    float   flMid1Center;       // (Hz)
+    float   flMid1Width;        // (octaves)
+    long    lMid2Gain;          // (mB)
+    float   flMid2Center;       // (Hz)
+    float   flMid2Width;        // (octaves)
+    long    lHighGain;          // (mB)
+    float   flHighCutOff;       // (Hz)
+} EAXEQUALIZERPROPERTIES, *LPEAXEQUALIZERPROPERTIES;
+
+// Property ranges and defaults:
+
+#define EAXEQUALIZER_MINLOWGAIN         (-1800)
+#define EAXEQUALIZER_MAXLOWGAIN         1800
+#define EAXEQUALIZER_DEFAULTLOWGAIN     0
+
+#define EAXEQUALIZER_MINLOWCUTOFF       50.0f
+#define EAXEQUALIZER_MAXLOWCUTOFF       800.0f
+#define EAXEQUALIZER_DEFAULTLOWCUTOFF   200.0f
+
+#define EAXEQUALIZER_MINMID1GAIN        (-1800)
+#define EAXEQUALIZER_MAXMID1GAIN        1800
+#define EAXEQUALIZER_DEFAULTMID1GAIN    0
+
+#define EAXEQUALIZER_MINMID1CENTER      200.0f
+#define EAXEQUALIZER_MAXMID1CENTER      3000.0f
+#define EAXEQUALIZER_DEFAULTMID1CENTER  500.0f
+
+#define EAXEQUALIZER_MINMID1WIDTH       0.01f
+#define EAXEQUALIZER_MAXMID1WIDTH       1.0f
+#define EAXEQUALIZER_DEFAULTMID1WIDTH   1.0f
+
+#define EAXEQUALIZER_MINMID2GAIN        (-1800)
+#define EAXEQUALIZER_MAXMID2GAIN        1800
+#define EAXEQUALIZER_DEFAULTMID2GAIN    0
+
+#define EAXEQUALIZER_MINMID2CENTER      1000.0f
+#define EAXEQUALIZER_MAXMID2CENTER      8000.0f
+#define EAXEQUALIZER_DEFAULTMID2CENTER  3000.0f
+
+#define EAXEQUALIZER_MINMID2WIDTH       0.01f
+#define EAXEQUALIZER_MAXMID2WIDTH       1.0f
+#define EAXEQUALIZER_DEFAULTMID2WIDTH   1.0f
+
+#define EAXEQUALIZER_MINHIGHGAIN        (-1800)
+#define EAXEQUALIZER_MAXHIGHGAIN        1800
+#define EAXEQUALIZER_DEFAULTHIGHGAIN    0
+
+#define EAXEQUALIZER_MINHIGHCUTOFF      4000.0f
+#define EAXEQUALIZER_MAXHIGHCUTOFF      16000.0f
+#define EAXEQUALIZER_DEFAULTHIGHCUTOFF  6000.0f
+
+////////////////////////////////////////////////////////////////////////////
+
+
+////////////////////////////////////////////////////////////////////////////
+// Flanger Effect
+
+// EAX FLANGER {A70007C0-7D2-11D3-9B1E-A024D13CE1}
+
+DEFINE_GUID(EAX_FLANGER_EFFECT,
+    0xa70007c0,
+    0x7d2,
+    0x11d3,
+    0x9b, 0x1e, 0x0, 0xa0, 0x24, 0xd1, 0x3c, 0xe1);
+
+// Flanger properties
+typedef enum
+{
+    EAXFLANGER_NONE,
+    EAXFLANGER_ALLPARAMETERS,
+    EAXFLANGER_WAVEFORM,
+    EAXFLANGER_PHASE,
+    EAXFLANGER_RATE,
+    EAXFLANGER_DEPTH,
+    EAXFLANGER_FEEDBACK,
+    EAXFLANGER_DELAY
+} EAXFLANGER_PROPERTY;
+
+// OR these flags with property id
+#define EAXFLANGER_IMMEDIATE 0x00000000 // changes take effect immediately
+#define EAXFLANGER_DEFERRED  0x80000000 // changes take effect later
+#define EAXFLANGER_COMMITDEFERREDSETTINGS (EAXFLANGER_NONE | \
+                                           EAXFLANGER_IMMEDIATE)
+
+// used by EAXFLANGER_WAVEFORM
+enum
+{
+    EAX_FLANGER_SINUSOID,
+    EAX_FLANGER_TRIANGLE
+};
+
+// Use this structure for EAXFLANGER_ALLPARAMETERS
+typedef struct _EAXFLANGERPROPERTIES
+{
+    unsigned long   ulWaveform;  // Waveform selector - see enum above
+    long            lPhase;     // Phase (Degrees)
+    float           flRate;     // Rate (Hz)
+    float           flDepth;    // Depth (0 to 1)
+    float           flFeedback; // Feedback (0 to 1)
+    float           flDelay;    // Delay (seconds)
+} EAXFLANGERPROPERTIES, *LPEAXFLANGERPROPERTIES;
+
+// Property ranges and defaults:
+
+#define EAXFLANGER_MINWAVEFORM              0
+#define EAXFLANGER_MAXWAVEFORM              1
+#define EAXFLANGER_DEFAULTWAVEFORM          1
+
+#define EAXFLANGER_MINPHASE             (-180)
+#define EAXFLANGER_MAXPHASE             180
+#define EAXFLANGER_DEFAULTPHASE         0
+
+#define EAXFLANGER_MINRATE              0.0f
+#define EAXFLANGER_MAXRATE              10.0f
+#define EAXFLANGER_DEFAULTRATE          0.27f
+
+#define EAXFLANGER_MINDEPTH             0.0f
+#define EAXFLANGER_MAXDEPTH             1.0f
+#define EAXFLANGER_DEFAULTDEPTH         1.0f
+
+#define EAXFLANGER_MINFEEDBACK          (-1.0f)
+#define EAXFLANGER_MAXFEEDBACK          1.0f
+#define EAXFLANGER_DEFAULTFEEDBACK      (-0.5f)
+
+#define EAXFLANGER_MINDELAY             0.0f
+#define EAXFLANGER_MAXDELAY             0.004f
+#define EAXFLANGER_DEFAULTDELAY         0.002f
+
+////////////////////////////////////////////////////////////////////////////
+
+
+////////////////////////////////////////////////////////////////////////////
+// Frequency Shifter Effect
+
+// EAX FREQUENCY SHIFTER {DC3E1880-9212-11D3-939D-C0F02DD6F0}
+
+DEFINE_GUID(EAX_FREQUENCYSHIFTER_EFFECT,
+    0xdc3e1880,
+    0x9212,
+    0x11d3,
+    0x93, 0x9d, 0x0, 0xc0, 0xf0, 0x2d, 0xd6, 0xf0);
+
+// Frequency Shifter properties
+typedef enum
+{
+    EAXFREQUENCYSHIFTER_NONE,
+    EAXFREQUENCYSHIFTER_ALLPARAMETERS,
+    EAXFREQUENCYSHIFTER_FREQUENCY,
+    EAXFREQUENCYSHIFTER_LEFTDIRECTION,
+    EAXFREQUENCYSHIFTER_RIGHTDIRECTION
+} EAXFREQUENCYSHIFTER_PROPERTY;
+
+// OR these flags with property id
+#define EAXFREQUENCYSHIFTER_IMMEDIATE 0x00000000 // changes take effect immediately
+#define EAXFREQUENCYSHIFTER_DEFERRED  0x80000000 // changes take effect later
+#define EAXFREQUENCYSHIFTER_COMMITDEFERREDSETTINGS (EAXFREQUENCYSHIFTER_NONE | \
+                                                    EAXFREQUENCYSHIFTER_IMMEDIATE)
+
+// used by EAXFREQUENCYSHIFTER_LEFTDIRECTION and EAXFREQUENCYSHIFTER_RIGHTDIRECTION 
+enum
+{
+    EAX_FREQUENCYSHIFTER_DOWN,
+    EAX_FREQUENCYSHIFTER_UP,
+    EAX_FREQUENCYSHIFTER_OFF
+};
+
+// Use this structure for EAXFREQUENCYSHIFTER_ALLPARAMETERS
+typedef struct _EAXFREQUENCYSHIFTERPROPERTIES
+{
+    float           flFrequency;        // (Hz)
+    unsigned long   ulLeftDirection;     // see enum above
+    unsigned long   ulRightDirection;    // see enum above
+} EAXFREQUENCYSHIFTERPROPERTIES, *LPEAXFREQUENCYSHIFTERPROPERTIES;
+
+// Property ranges and defaults:
+
+#define EAXFREQUENCYSHIFTER_MINFREQUENCY            0.0f
+#define EAXFREQUENCYSHIFTER_MAXFREQUENCY            24000.0f
+#define EAXFREQUENCYSHIFTER_DEFAULTFREQUENCY        0.0f
+
+#define EAXFREQUENCYSHIFTER_MINLEFTDIRECTION        0
+#define EAXFREQUENCYSHIFTER_MAXLEFTDIRECTION        2
+#define EAXFREQUENCYSHIFTER_DEFAULTLEFTDIRECTION    0
+
+#define EAXFREQUENCYSHIFTER_MINRIGHTDIRECTION       0
+#define EAXFREQUENCYSHIFTER_MAXRIGHTDIRECTION       2
+#define EAXFREQUENCYSHIFTER_DEFAULTRIGHTDIRECTION   0
+
+////////////////////////////////////////////////////////////////////////////
+
+
+////////////////////////////////////////////////////////////////////////////
+// Vocal Morpher Effect
+
+// EAX VOCAL MORPHER {E41CF10C-3383-11D2-88DD-A024D13CE1}
+
+DEFINE_GUID(EAX_VOCALMORPHER_EFFECT, 
+    0xe41cf10c,
+    0x3383,
+    0x11d2,
+    0x88, 0xdd, 0x0, 0xa0, 0x24, 0xd1, 0x3c, 0xe1);
+
+// Vocal Morpher properties
+typedef enum
+{
+    EAXVOCALMORPHER_NONE,
+    EAXVOCALMORPHER_ALLPARAMETERS,
+    EAXVOCALMORPHER_PHONEMEA,
+    EAXVOCALMORPHER_PHONEMEACOARSETUNING,
+    EAXVOCALMORPHER_PHONEMEB,
+    EAXVOCALMORPHER_PHONEMEBCOARSETUNING,
+    EAXVOCALMORPHER_WAVEFORM,
+    EAXVOCALMORPHER_RATE
+} EAXVOCALMORPHER_PROPERTY;
+
+// OR these flags with property id
+#define EAXVOCALMORPHER_IMMEDIATE 0x00000000 // changes take effect immediately
+#define EAXVOCALMORPHER_DEFERRED  0x80000000 // changes take effect later
+#define EAXVOCALMORPHER_COMMITDEFERREDSETTINGS (EAXVOCALMORPHER_NONE | \
+                                                EAXVOCALMORPHER_IMMEDIATE)
+
+// used by EAXVOCALMORPHER_PHONEMEA and EAXVOCALMORPHER_PHONEMEB
+enum
+{
+    A, E, I, O, U, AA, AE, AH, AO, EH, ER, IH, IY, UH, UW, B, D, F, G,
+    J, K, L, M, N, P, R, S, T, V, Z
+};
+
+// used by EAXVOCALMORPHER_WAVEFORM
+enum
+{
+    EAX_VOCALMORPHER_SINUSOID,
+    EAX_VOCALMORPHER_TRIANGLE,
+    EAX_VOCALMORPHER_SAWTOOTH
+};
+
+// Use this structure for EAXVOCALMORPHER_ALLPARAMETERS
+typedef struct _EAXVOCALMORPHERPROPERTIES
+{
+    unsigned long   ulPhonemeA;              // see enum above
+    long            lPhonemeACoarseTuning;  // (semitones)
+    unsigned long   ulPhonemeB;              // see enum above
+    long            lPhonemeBCoarseTuning;  // (semitones)
+    unsigned long   ulWaveform;              // Waveform selector - see enum above
+    float           flRate;                 // (Hz)
+} EAXVOCALMORPHERPROPERTIES, *LPEAXVOCALMORPHERPROPERTIES;
+
+// Property ranges and defaults:
+
+#define EAXVOCALMORPHER_MINPHONEMEA                 0
+#define EAXVOCALMORPHER_MAXPHONEMEA                 29
+#define EAXVOCALMORPHER_DEFAULTPHONEMEA             0
+
+#define EAXVOCALMORPHER_MINPHONEMEACOARSETUNING     (-24)
+#define EAXVOCALMORPHER_MAXPHONEMEACOARSETUNING     24
+#define EAXVOCALMORPHER_DEFAULTPHONEMEACOARSETUNING 0
+
+#define EAXVOCALMORPHER_MINPHONEMEB                 0
+#define EAXVOCALMORPHER_MAXPHONEMEB                 29
+#define EAXVOCALMORPHER_DEFAULTPHONEMEB             10
+
+#define EAXVOCALMORPHER_MINPHONEMEBCOARSETUNING     (-24)
+#define EAXVOCALMORPHER_MAXPHONEMEBCOARSETUNING     24
+#define EAXVOCALMORPHER_DEFAULTPHONEMEBCOARSETUNING 0
+
+#define EAXVOCALMORPHER_MINWAVEFORM                 0
+#define EAXVOCALMORPHER_MAXWAVEFORM                 2
+#define EAXVOCALMORPHER_DEFAULTWAVEFORM             0
+
+#define EAXVOCALMORPHER_MINRATE                     0.0f
+#define EAXVOCALMORPHER_MAXRATE                     10.0f
+#define EAXVOCALMORPHER_DEFAULTRATE                 1.41f
+
+////////////////////////////////////////////////////////////////////////////
+
+
+////////////////////////////////////////////////////////////////////////////
+// Pitch Shifter Effect
+
+// EAX PITCH SHIFTER {E7905100-AFB2-11D2-88DD-A024D13CE1}
+
+DEFINE_GUID(EAX_PITCHSHIFTER_EFFECT,
+    0xe7905100,
+    0xafb2,
+    0x11d2,
+    0x88, 0xdd, 0x0, 0xa0, 0x24, 0xd1, 0x3c, 0xe1);
+
+// Pitch Shifter properties
+typedef enum
+{
+    EAXPITCHSHIFTER_NONE,
+    EAXPITCHSHIFTER_ALLPARAMETERS,
+    EAXPITCHSHIFTER_COARSETUNE,
+    EAXPITCHSHIFTER_FINETUNE
+} EAXPITCHSHIFTER_PROPERTY;
+
+// OR these flags with property id
+#define EAXPITCHSHIFTER_IMMEDIATE 0x00000000 // changes take effect immediately
+#define EAXPITCHSHIFTER_DEFERRED  0x80000000 // changes take effect later
+#define EAXPITCHSHIFTER_COMMITDEFERREDSETTINGS (EAXPITCHSHIFTER_NONE | \
+                                                EAXPITCHSHIFTER_IMMEDIATE)
+
+// Use this structure for EAXPITCHSHIFTER_ALLPARAMETERS
+typedef struct _EAXPITCHSHIFTERPROPERTIES
+{
+    long    lCoarseTune;    // Amount of pitch shift (semitones)
+    long    lFineTune;      // Amount of pitch shift (cents)
+} EAXPITCHSHIFTERPROPERTIES, *LPEAXPITCHSHIFTERPROPERTIES;
+
+// Property ranges and defaults:
+
+#define EAXPITCHSHIFTER_MINCOARSETUNE       (-12)
+#define EAXPITCHSHIFTER_MAXCOARSETUNE       12
+#define EAXPITCHSHIFTER_DEFAULTCOARSETUNE   12
+
+#define EAXPITCHSHIFTER_MINFINETUNE         (-50)
+#define EAXPITCHSHIFTER_MAXFINETUNE         50
+#define EAXPITCHSHIFTER_DEFAULTFINETUNE     0
+
+////////////////////////////////////////////////////////////////////////////
+
+
+////////////////////////////////////////////////////////////////////////////
+// Ring Modulator Effect
+
+// EAX RING MODULATOR {B89FE60-AFB5-11D2-88DD-A024D13CE1}
+
+DEFINE_GUID(EAX_RINGMODULATOR_EFFECT,
+    0xb89fe60,
+    0xafb5,
+    0x11d2,
+    0x88, 0xdd, 0x0, 0xa0, 0x24, 0xd1, 0x3c, 0xe1);
+
+// Ring Modulator properties
+typedef enum
+{
+    EAXRINGMODULATOR_NONE,
+    EAXRINGMODULATOR_ALLPARAMETERS,
+    EAXRINGMODULATOR_FREQUENCY,
+    EAXRINGMODULATOR_HIGHPASSCUTOFF,
+    EAXRINGMODULATOR_WAVEFORM
+} EAXRINGMODULATOR_PROPERTY;
+
+// OR these flags with property id
+#define EAXRINGMODULATOR_IMMEDIATE 0x00000000 // changes take effect immediately
+#define EAXRINGMODULATOR_DEFERRED  0x80000000 // changes take effect later
+#define EAXRINGMODULATOR_COMMITDEFERREDSETTINGS (EAXRINGMODULATOR_NONE | \
+                                                 EAXRINGMODULATOR_IMMEDIATE)
+
+// used by EAXRINGMODULATOR_WAVEFORM
+enum
+{
+    EAX_RINGMODULATOR_SINUSOID,
+    EAX_RINGMODULATOR_SAWTOOTH,
+    EAX_RINGMODULATOR_SQUARE
+};
+
+// Use this structure for EAXRINGMODULATOR_ALLPARAMETERS
+typedef struct _EAXRINGMODULATORPROPERTIES
+{
+    float           flFrequency;        // Frequency of modulation (Hz)
+    float           flHighPassCutOff;   // Cut-off frequency of high-pass filter (Hz)
+    unsigned long   ulWaveform;          // Waveform selector - see enum above
+} EAXRINGMODULATORPROPERTIES, *LPEAXRINGMODULATORPROPERTIES;
+
+// Property ranges and defaults:
+
+#define EAXRINGMODULATOR_MINFREQUENCY           0.0f
+#define EAXRINGMODULATOR_MAXFREQUENCY           8000.0f
+#define EAXRINGMODULATOR_DEFAULTFREQUENCY       440.0f
+
+#define EAXRINGMODULATOR_MINHIGHPASSCUTOFF      0.0f
+#define EAXRINGMODULATOR_MAXHIGHPASSCUTOFF      24000.0f
+#define EAXRINGMODULATOR_DEFAULTHIGHPASSCUTOFF  800.0f
+
+#define EAXRINGMODULATOR_MINWAVEFORM            0
+#define EAXRINGMODULATOR_MAXWAVEFORM            2
+#define EAXRINGMODULATOR_DEFAULTWAVEFORM        0
+
+////////////////////////////////////////////////////////////////////////////
+
+#pragma pack(pop)
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+
+#endif
diff --git a/code/client/eax/vssver.scc b/code/client/eax/vssver.scc
new file mode 100644
index 0000000..aab29e7
Binary files /dev/null and b/code/client/eax/vssver.scc differ
diff --git a/code/client/fffx.h b/code/client/fffx.h
new file mode 100644
index 0000000..c6958b9
--- /dev/null
+++ b/code/client/fffx.h
@@ -0,0 +1,129 @@
+// Filename:-	fffx.h		(Force Feedback FX)
+
+#ifndef FFFX_H
+#define FFFX_H
+
+// this part can be seen by the CGAME as well...
+
+// These enums match the generic ones built into the effects ROM in the MS SideWinder FF Joystick, 
+//	so blame MS for anything you don't like (like that aircraft carrier one - jeez!)...
+//
+// (Judging from the names of most of these, the MS FF guys appear to be rather fond of ID-type games...)
+//
+typedef enum 
+	{
+	fffx_RandomNoise=0,
+	fffx_AircraftCarrierTakeOff,	// this one is pointless / dumb
+	fffx_BasketballDribble,
+	fffx_CarEngineIdle,
+	fffx_ChainsawIdle,
+	fffx_ChainsawInAction,
+	fffx_DieselEngineIdle,
+	fffx_Jump,
+	fffx_Land,
+	fffx_MachineGun,
+	fffx_Punched,
+	fffx_RocketLaunch,
+	fffx_SecretDoor,
+	fffx_SwitchClick,
+	fffx_WindGust,
+	fffx_WindShear,		// also pretty crap
+	fffx_Pistol,
+	fffx_Shotgun,
+	fffx_Laser1,
+	fffx_Laser2,
+	fffx_Laser3,
+	fffx_Laser4,
+	fffx_Laser5,
+	fffx_Laser6,
+	fffx_OutOfAmmo,
+	fffx_LightningGun,
+	fffx_Missile,
+	fffx_GatlingGun,
+	fffx_ShortPlasma,
+	fffx_PlasmaCannon1,
+	fffx_PlasmaCannon2,
+	fffx_Cannon,
+#ifdef _XBOX
+	fffx_FallingShort,
+	fffx_FallingMedium,
+	fffx_FallingFar,
+	fffx_StartConst,
+	fffx_StopConst,
+#endif
+	//
+	fffx_NUMBEROF,
+	fffx_NULL		// special use, ignore during array mallocs etc, use fffx_NUMBEROF instead
+	} ffFX_e;
+
+
+#ifndef CGAME_ONLY
+
+/////////////////////////// START of functions to call /////////////////////////////////
+//
+//
+//
+// Once the game is running you should *only* access FF functions through these 4 macros. Savvy?
+//
+// Usage note: In practice, you can have about 4 FF FX running concurrently, though I defy anyone to make sense
+//	of that amount of white-noise vibration. MS guidelines say you shouldn't leave vibration on for long periods
+//	of time (eg engine rumble) because of various nerve-damage/lawsuit issues, so for this reason there is no API
+//	support for setting durations etc. All FF FX stuff here is designed for things like firing, hit damage, driving
+//	over bumps, etc that can be played as one-off events, though you *can* do things like FFFX_ENSURE(fffx_ChainsawIdle)
+//	if you really want to.
+//
+// Combining small numbers of effects such as having a laser firing (MS photons have higher mass apparently <g>), 
+//	and then firing a machine gun in bursts as well are no problem, and easily felt, hence the ability to stop playing
+//	individual FF FX.
+//
+#define FFFX_START(f)	FF_Play(f)
+#define FFFX_ENSURE(f)	FF_EnsurePlaying(f)
+#define FFFX_STOP(f)	FF_Stop(f)			// some effects (eg. gatling, chainsaw), need this, or they play too long after trigger-off.
+#define FFFX_STOPALL	FF_StopAll()
+
+
+//
+// These 2 are called at app start/stop, but you can call FF_Init to change FF devices anytime (takes a couple of seconds)
+//
+void		FF_Init(qboolean bTryMouseFirst=true);
+void		FF_Shutdown(void);
+//
+// other stuff you may want to call but don't have to...
+//
+qboolean	FF_IsAvailable(void);	
+qboolean	FF_IsMouse(void);		
+qboolean	FF_SetTension(int iTension);	// tension setting 0..3 (0=none)
+qboolean	FF_SetSpring(long lSpring);		// precision version of above, 0..n..10000
+											// (only provided for command line fiddling with 
+											//	weird hardware. FF_SetTension(1) = default
+											// = FF_SetSpring(2000) (internal lookup table))
+
+//
+//
+//
+/////////////////////////// END of functions to call /////////////////////////////////
+
+
+
+
+// do *not* call this functions directly (or else!), use the macros above
+//
+void FF_Play			(ffFX_e fffx);
+void FF_EnsurePlaying	(ffFX_e fffx);
+void FF_Stop			(ffFX_e fffx);
+void FF_StopAll			(void);
+
+#ifdef _XBOX
+void FF_XboxShake		(float intensity, int duration);
+void FF_XboxDamage		(int damage, float xpos);
+#endif
+
+#define MAX_CONCURRENT_FFFXs 4	// only for my code to use/read, do NOT alter!
+
+
+
+#endif	// #ifndef CGAME_ONLY
+#endif	// #ifndef FFFX_H
+
+//////////////////////// eof //////////////////////
+
diff --git a/code/client/keycodes.h b/code/client/keycodes.h
new file mode 100644
index 0000000..8d0f171
--- /dev/null
+++ b/code/client/keycodes.h
@@ -0,0 +1,347 @@
+#ifndef __KEYCODES_H__
+#define __KEYCODES_H__
+
+// these are the key numbers that should be passed to KeyEvent
+
+typedef enum
+{
+	A_NULL = 0,
+	A_SHIFT,
+	A_CTRL,
+	A_ALT,
+	A_CAPSLOCK,
+	A_NUMLOCK,
+	A_SCROLLLOCK,
+	A_PAUSE,
+	A_BACKSPACE,
+	A_TAB,
+	A_ENTER,
+	A_KP_PLUS,
+	A_KP_MINUS,
+	A_KP_ENTER,
+	A_KP_PERIOD,
+	A_PRINTSCREEN,
+	A_KP_0,
+	A_KP_1,
+	A_KP_2,
+	A_KP_3,
+	A_KP_4,
+	A_KP_5,
+	A_KP_6,
+	A_KP_7,
+	A_KP_8,
+	A_KP_9,
+	A_CONSOLE,
+	A_ESCAPE,
+	A_F1,
+	A_F2,
+	A_F3,
+	A_F4,
+
+	A_SPACE,
+	A_PLING,
+	A_DOUBLE_QUOTE,
+	A_HASH,
+	A_STRING,
+	A_PERCENT,
+	A_AND,
+	A_SINGLE_QUOTE,
+	A_OPEN_BRACKET,
+	A_CLOSE_BRACKET,
+	A_STAR,
+	A_PLUS,
+	A_COMMA,
+	A_MINUS,
+	A_PERIOD,
+	A_FORWARD_SLASH,
+	A_0,
+	A_1,
+	A_2,
+	A_3,
+	A_4,
+	A_5,
+	A_6,
+	A_7,
+	A_8,
+	A_9,
+	A_COLON,
+	A_SEMICOLON,
+	A_LESSTHAN,
+	A_EQUALS,
+	A_GREATERTHAN,
+	A_QUESTION,
+
+	A_AT,
+	A_CAP_A,
+	A_CAP_B,
+	A_CAP_C,
+	A_CAP_D,
+	A_CAP_E,
+	A_CAP_F,
+	A_CAP_G,
+	A_CAP_H,
+	A_CAP_I,
+	A_CAP_J,
+	A_CAP_K,
+	A_CAP_L,
+	A_CAP_M,
+	A_CAP_N,
+	A_CAP_O,
+	A_CAP_P,
+	A_CAP_Q,
+	A_CAP_R,
+	A_CAP_S,
+	A_CAP_T,
+	A_CAP_U,
+	A_CAP_V,
+	A_CAP_W,
+	A_CAP_X,
+	A_CAP_Y,
+	A_CAP_Z,
+	A_OPEN_SQUARE,
+	A_BACKSLASH,
+	A_CLOSE_SQUARE,
+	A_CARET,
+	A_UNDERSCORE,
+
+	A_LEFT_SINGLE_QUOTE,
+	A_LOW_A,
+	A_LOW_B,
+	A_LOW_C,
+	A_LOW_D,
+	A_LOW_E,
+	A_LOW_F,
+	A_LOW_G,
+	A_LOW_H,
+	A_LOW_I,
+	A_LOW_J,
+	A_LOW_K,
+	A_LOW_L,
+	A_LOW_M,
+	A_LOW_N,
+	A_LOW_O,
+	A_LOW_P,
+	A_LOW_Q,
+	A_LOW_R,
+	A_LOW_S,
+	A_LOW_T,
+	A_LOW_U,
+	A_LOW_V,
+	A_LOW_W,
+	A_LOW_X,
+	A_LOW_Y,
+	A_LOW_Z,
+	A_OPEN_BRACE,
+	A_BAR,
+	A_CLOSE_BRACE,
+	A_TILDE,
+	A_DELETE,
+
+	A_EURO,
+	A_SHIFT2,
+	A_CTRL2,
+	A_ALT2,
+	A_F5,
+	A_F6,
+	A_F7,
+	A_F8,
+	A_CIRCUMFLEX,
+	A_MWHEELUP,
+	A_CAP_SCARON,
+	A_MWHEELDOWN,
+	A_CAP_OE,
+	A_MOUSE1,
+	A_MOUSE2,
+	A_INSERT,
+	A_HOME,
+	A_PAGE_UP,
+	A_RIGHT_SINGLE_QUOTE,
+	A_LEFT_DOUBLE_QUOTE,
+	A_RIGHT_DOUBLE_QUOTE,
+	A_F9,
+	A_F10,
+	A_F11,
+	A_F12,
+	A_TRADEMARK,
+	A_LOW_SCARON,
+	A_SHIFT_ENTER,
+	A_LOW_OE,
+	A_END,
+	A_PAGE_DOWN,
+	A_CAP_YDIERESIS,
+
+	A_SHIFT_SPACE,
+	A_EXCLAMDOWN,
+	A_CENT,
+	A_POUND,
+	A_SHIFT_KP_ENTER,
+	A_YEN,
+	A_MOUSE3,
+	A_MOUSE4,
+	A_MOUSE5,
+	A_COPYRIGHT,
+	A_CURSOR_UP,
+	A_CURSOR_DOWN,
+	A_CURSOR_LEFT,
+	A_CURSOR_RIGHT,
+	A_REGISTERED,
+	A_UNDEFINED_7,
+	A_UNDEFINED_8,
+	A_UNDEFINED_9,
+	A_UNDEFINED_10,
+	A_UNDEFINED_11,
+	A_UNDEFINED_12,
+	A_UNDEFINED_13,
+	A_UNDEFINED_14,
+	A_UNDEFINED_15,
+	A_UNDEFINED_16,
+	A_UNDEFINED_17,
+	A_UNDEFINED_18,
+	A_UNDEFINED_19,
+	A_UNDEFINED_20,
+	A_UNDEFINED_21,
+	A_UNDEFINED_22,
+	A_QUESTION_DOWN,
+
+	A_CAP_AGRAVE,
+	A_CAP_AACUTE,
+	A_CAP_ACIRCUMFLEX,
+	A_CAP_ATILDE,
+	A_CAP_ADIERESIS,
+	A_CAP_ARING,
+	A_CAP_AE,
+	A_CAP_CCEDILLA,
+	A_CAP_EGRAVE,
+	A_CAP_EACUTE,
+	A_CAP_ECIRCUMFLEX,
+	A_CAP_EDIERESIS,
+	A_CAP_IGRAVE,
+	A_CAP_IACUTE,
+	A_CAP_ICIRCUMFLEX,
+	A_CAP_IDIERESIS,
+	A_CAP_ETH,
+	A_CAP_NTILDE,
+	A_CAP_OGRAVE,
+	A_CAP_OACUTE,
+	A_CAP_OCIRCUMFLEX,
+	A_CAP_OTILDE,
+	A_CAP_ODIERESIS,
+	A_MULTIPLY,
+	A_CAP_OSLASH,
+	A_CAP_UGRAVE,
+	A_CAP_UACUTE,
+	A_CAP_UCIRCUMFLEX,
+	A_CAP_UDIERESIS,
+	A_CAP_YACUTE,
+	A_CAP_THORN,
+	A_GERMANDBLS,
+
+	A_LOW_AGRAVE,
+	A_LOW_AACUTE,
+	A_LOW_ACIRCUMFLEX,
+	A_LOW_ATILDE,
+	A_LOW_ADIERESIS,
+	A_LOW_ARING,
+	A_LOW_AE,
+	A_LOW_CCEDILLA,
+	A_LOW_EGRAVE,
+	A_LOW_EACUTE,
+	A_LOW_ECIRCUMFLEX,
+	A_LOW_EDIERESIS,
+	A_LOW_IGRAVE,
+	A_LOW_IACUTE,
+	A_LOW_ICIRCUMFLEX,
+	A_LOW_IDIERESIS,
+	A_LOW_ETH,
+	A_LOW_NTILDE,
+	A_LOW_OGRAVE,
+	A_LOW_OACUTE,
+	A_LOW_OCIRCUMFLEX,
+	A_LOW_OTILDE,
+	A_LOW_ODIERESIS,
+	A_DIVIDE,
+	A_LOW_OSLASH,
+	A_LOW_UGRAVE,
+	A_LOW_UACUTE,
+	A_LOW_UCIRCUMFLEX,
+	A_LOW_UDIERESIS,
+	A_LOW_YACUTE,
+	A_LOW_THORN,
+	A_LOW_YDIERESIS,
+	
+	A_JOY0,
+	A_JOY1,
+	A_JOY2,
+	A_JOY3,
+	A_JOY4,
+	A_JOY5,
+	A_JOY6,
+	A_JOY7,
+	A_JOY8,
+	A_JOY9,
+	A_JOY10,
+	A_JOY11,
+	A_JOY12,
+	A_JOY13,
+	A_JOY14,
+	A_JOY15,
+	A_JOY16,
+	A_JOY17,
+	A_JOY18,
+	A_JOY19,
+	A_JOY20,
+	A_JOY21,
+	A_JOY22,
+	A_JOY23,
+	A_JOY24,
+	A_JOY25,
+	A_JOY26,
+	A_JOY27,
+	A_JOY28,
+	A_JOY29,
+	A_JOY30,
+	A_JOY31,
+
+	A_AUX0,
+	A_AUX1,
+	A_AUX2,
+	A_AUX3,
+	A_AUX4,
+	A_AUX5,
+	A_AUX6,
+	A_AUX7,
+	A_AUX8,
+	A_AUX9,
+	A_AUX10,
+	A_AUX11,
+	A_AUX12,
+	A_AUX13,
+	A_AUX14,
+	A_AUX15,
+	A_AUX16,
+	A_AUX17,
+	A_AUX18,
+	A_AUX19,
+	A_AUX20,
+	A_AUX21,
+	A_AUX22,
+	A_AUX23,
+	A_AUX24,
+	A_AUX25,
+	A_AUX26,
+	A_AUX27,
+	A_AUX28,
+	A_AUX29,
+	A_AUX30,
+	A_AUX31,
+
+	MAX_KEYS
+} fakeAscii_t;
+
+
+// The menu code needs to get both key and char events, but
+// to avoid duplicating the paths, the char events are just
+// distinguished by or'ing in K_CHAR_FLAG (ugly)
+#define	K_CHAR_FLAG		1024
+
+#endif
diff --git a/code/client/keys.h b/code/client/keys.h
new file mode 100644
index 0000000..0592039
--- /dev/null
+++ b/code/client/keys.h
@@ -0,0 +1,61 @@
+#include "keycodes.h"
+
+typedef struct {
+	qboolean	down;
+	int			repeats;		// if > 1, it is autorepeating
+	char		*binding;
+} qkey_t;
+
+#define	MAX_EDIT_LINE		256
+#define	COMMAND_HISTORY		32
+
+typedef struct {
+	int		cursor;
+	int		scroll;
+	int		widthInChars;
+	char	buffer[MAX_EDIT_LINE];
+} field_t;
+
+typedef struct keyGlobals_s
+{
+	field_t		historyEditLines[COMMAND_HISTORY];
+
+	int			nextHistoryLine;		// the last line in the history buffer, not masked
+	int			historyLine;			// the line being displayed from history buffer
+										// will be <= nextHistoryLine
+	field_t		g_consoleField;
+
+	qboolean	anykeydown;
+	qboolean	key_overstrikeMode;
+	int			keyDownCount;
+
+	qkey_t		keys[MAX_KEYS];
+} keyGlobals_t;
+
+
+typedef struct 
+{
+	word	upper;
+	word	lower;
+	char	*name;
+	int		keynum;
+	bool	menukey;
+} keyname_t;
+
+extern keyGlobals_t	kg;
+extern keyname_t	keynames[MAX_KEYS];
+
+void Field_Clear( field_t *edit );
+void Field_KeyDownEvent( field_t *edit, int key );
+void Field_Draw( field_t *edit, int x, int y, int width, qboolean showCursor );
+void Field_BigDraw( field_t *edit, int x, int y, int width, qboolean showCursor );
+
+extern	field_t	chatField;
+
+void Key_WriteBindings( fileHandle_t f );
+void Key_SetBinding( int keynum, const char *binding );
+char *Key_GetBinding( int keynum );
+qboolean Key_IsDown( int keynum );
+qboolean Key_GetOverstrikeMode( void );
+void Key_SetOverstrikeMode( qboolean state );
+void Key_ClearStates( void );
diff --git a/code/client/snd_ambient.cpp b/code/client/snd_ambient.cpp
new file mode 100644
index 0000000..4631265
--- /dev/null
+++ b/code/client/snd_ambient.cpp
@@ -0,0 +1,1165 @@
+// Ambient Sound System (ASS!)
+
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+#pragma warning ( disable : 4710 )	//not inlined
+#include "client.h"
+#include "snd_ambient.h"
+#ifdef _XBOX
+#include "snd_local_console.h"
+#else
+#include "snd_local.h"
+#endif
+
+static const int MAX_SET_VOLUME =	255;
+
+static void AS_GetGeneralSet( ambientSet_t & );
+static void AS_GetLocalSet( ambientSet_t & );
+static void AS_GetBModelSet( ambientSet_t & );
+
+//Current set and old set for crossfading
+static int	currentSet	= -1;
+static int oldSet		= -1;
+static int crossDelay	= 1000;	//1 second
+
+static int currentSetTime = 0;
+static int oldSetTime = 0;
+
+// Globals for debug purposes
+static int		numSets	= 0;
+
+// Main ambient sound group
+static CSetGroup*	aSets = NULL;
+
+// Globals for speed, blech
+static char	*parseBuffer	= NULL;
+static int		parseSize		= 0;
+static int		parsePos		= 0;
+static char	tempBuffer[1024];
+
+//NOTENOTE: Be sure to change the mirrored code in g_spawn.cpp, and cg_main.cpp
+typedef	map<sstring_t, unsigned char>	namePrecache_m;
+static namePrecache_m*	pMap = NULL;
+
+// Used for enum / string matching
+static const char	*setNames[NUM_AS_SETS] =
+					{	
+						"generalSet",
+						"localSet",
+						"bmodelSet",
+					};
+
+// Used for enum / function matching
+static const parseFunc_t 	parseFuncs[NUM_AS_SETS] =	
+							{
+								AS_GetGeneralSet,
+								AS_GetLocalSet,
+								AS_GetBModelSet,
+							};
+
+// Used for keyword / enum matching
+static const char	*keywordNames[NUM_AS_KEYWORDS]=
+					{	
+						"timeBetweenWaves",
+						"subWaves",
+						"loopedWave",
+						"volRange",
+						"radius",
+						"type",
+						"amsdir",
+						"outdir",
+						"basedir",
+					};
+
+
+CSetGroup::CSetGroup(void)
+{
+	m_ambientSets = new vector<ambientSet_t*>;
+	m_setMap = new map<sstring_t, ambientSet_t*>;
+}
+
+
+CSetGroup::~CSetGroup(void)
+{
+	delete m_ambientSets;
+	m_ambientSets = 0;
+	delete m_setMap;
+	m_setMap = 0;
+}
+
+/*
+-------------------------
+Free
+-------------------------
+*/
+
+void CSetGroup::Free( void )
+{
+	vector<ambientSet_t *>::iterator	ai;
+
+	for ( ai = m_ambientSets->begin(); ai != m_ambientSets->end(); ai++ )
+	{
+		Z_Free ( (*ai) );
+	}
+
+	//Do this in place of clear() so it *really* frees the memory.
+	delete m_ambientSets;
+	delete m_setMap;
+	m_ambientSets = new vector<ambientSet_t*>;
+	m_setMap = new map<sstring_t, ambientSet_t*>;
+
+	m_numSets = 0;
+}
+
+/*
+-------------------------
+AddSet
+-------------------------
+*/
+
+ambientSet_t *CSetGroup::AddSet( const char *name )
+{
+	ambientSet_t	*set;
+
+	//Allocate the memory
+	set = (ambientSet_t *) Z_Malloc( sizeof( ambientSet_t ), TAG_AMBIENTSET, qtrue);
+
+	//Set up some defaults
+	Q_strncpyz(set->name,name,sizeof(set->name));
+	set->loopedVolume = MAX_SET_VOLUME;
+	set->masterVolume = MAX_SET_VOLUME;
+	set->radius = 250;
+	set->time_start = 10;
+	set->time_end	= 25;
+
+	set->volRange_start = MAX_SET_VOLUME;
+	set->volRange_end	= MAX_SET_VOLUME;
+
+	m_ambientSets->insert( m_ambientSets->end(), set );
+
+	set->id = m_numSets++;
+
+	//Map the name to the pointer for reference later
+	(*m_setMap)[name] = set;
+
+	return set;
+}
+
+/*
+-------------------------
+GetSet
+-------------------------
+*/
+
+ambientSet_t *CSetGroup::GetSet( const char *name )
+{
+	map<sstring_t, ambientSet_t *>::iterator	mi;
+
+	if ( name == NULL )
+		return NULL;
+
+	mi = m_setMap->find( name );
+
+	if ( mi == m_setMap->end() )
+		return NULL;
+
+	return (*mi).second;
+}
+
+ambientSet_t *CSetGroup::GetSet( int ID )
+{
+	if ( m_ambientSets->empty() )
+		return NULL;
+
+	if ( ID < 0 )
+		return NULL;
+
+	if ( ID >= m_numSets )
+		return NULL;
+
+	return (*m_ambientSets)[ID];
+}
+
+
+/*
+===============================================
+
+File Parsing
+
+===============================================
+*/
+
+/*
+-------------------------
+AS_GetSetNameIDForString
+-------------------------
+*/
+
+static int AS_GetSetNameIDForString( const char *name )
+{
+	//Make sure it's valid
+	if ( name == NULL || name[0] == NULL )
+		return -1;
+
+	for ( int i = 0; i < NUM_AS_SETS; i++ )
+	{
+		if ( stricmp( name, setNames[i] ) == 0 )
+			return i;
+	}
+
+	return -1;
+}
+
+/*
+-------------------------
+AS_GetKeywordIDForString
+-------------------------
+*/
+
+static int AS_GetKeywordIDForString( const char *name )
+{
+	//Make sure it's valid
+	if ( name == NULL || name[0] == NULL )
+		return -1;
+
+	for ( int i = 0; i < NUM_AS_KEYWORDS; i++ )
+	{
+		if ( stricmp( name, keywordNames[i] ) == 0 )
+			return i;
+	}
+
+	return -1;
+}
+
+/*
+-------------------------
+AS_SkipLine
+
+Skips a line in the character buffer
+-------------------------
+*/
+
+static void AS_SkipLine( void )
+{
+	if ( parsePos > parseSize )	// needed to avoid a crash because of some OOR access that shouldn't be done
+		return;
+
+	while ( (parseBuffer[parsePos] != '\n') && (parseBuffer[parsePos] != '\r') )
+	{
+		parsePos++;
+
+		if ( parsePos > parseSize )
+			return;
+	}
+
+	parsePos++;
+}
+
+/*
+-------------------------
+AS_GetTimeBetweenWaves
+
+getTimeBetweenWaves <start> <end>
+-------------------------
+*/
+
+static void AS_GetTimeBetweenWaves( ambientSet_t &set )
+{
+	int		startTime, endTime;
+
+	//Get the data
+	sscanf( parseBuffer+parsePos, "%s %d %d", &tempBuffer, &startTime, &endTime );
+
+	//Check for swapped start / end
+	if ( startTime > endTime )
+	{
+		#ifndef FINAL_BUILD
+		Com_Printf(S_COLOR_YELLOW"WARNING: Corrected swapped start / end times in a \"timeBetweenWaves\" keyword\n");
+		#endif
+		
+		int swap = startTime;
+		startTime = endTime;
+		endTime = swap;
+	}
+
+	//Store it
+	set.time_start	= startTime;
+	set.time_end	= endTime;
+
+	AS_SkipLine();
+}
+
+/*
+-------------------------
+AS_GetSubWaves
+
+subWaves <directory> <wave1> <wave2> ...
+-------------------------
+*/
+
+static void AS_GetSubWaves( ambientSet_t &set )
+{
+	char	dirBuffer[512], waveBuffer[256], waveName[1024];
+
+	//Get the directory for these sets
+	sscanf( parseBuffer+parsePos, "%s %s", &tempBuffer, &dirBuffer );	
+
+	//Move the pointer past these two strings
+	parsePos += ((strlen(keywordNames[SET_KEYWORD_SUBWAVES])+1) + (strlen(dirBuffer)+1));
+
+	//Get all the subwaves
+	while ( parsePos <= parseSize )
+	{
+		//Get the data
+		sscanf( parseBuffer+parsePos, "%s", &waveBuffer );
+
+		if ( set.numSubWaves > MAX_WAVES_PER_GROUP )
+		{
+			#ifndef FINAL_BUILD
+			Com_Printf(S_COLOR_YELLOW"WARNING: Too many subwaves on set \"%s\"\n", set.name );
+			#endif
+		}
+		else
+		{
+			//Construct the wave name (pretty, huh?)
+			strcpy( (char *) waveName, "sound/" );
+			strncat( (char *) waveName, (const char *) dirBuffer, 1024 );
+			strncat( (char *) waveName, "/", 512 );
+			strncat( (char *) waveName, (const char *) waveBuffer, 512 );
+			strncat( (char *) waveName, ".wav", 512 );
+			
+			//Place this onto the sound directory name
+
+			//Precache the file at this point and store off the ID instead of the name
+			if ( ( set.subWaves[set.numSubWaves++] = S_RegisterSound( waveName ) ) <= 0 )
+			{
+				#ifndef FINAL_BUILD
+				//Com_Printf(S_COLOR_RED"ERROR: Unable to load ambient sound \"%s\"\n", waveName);
+				Com_Error(ERR_DROP, "ERROR: Unable to load ambient sound \"%s\"\n", waveName);
+				#endif
+			}
+		}
+
+		//Move the pointer past this string
+		parsePos += strlen(waveBuffer)+1;
+
+		if ( ( (parseBuffer+parsePos)[0] == '\n') || ( (parseBuffer+parsePos)[0] == '\r') )
+			break;
+	}
+
+	AS_SkipLine();
+}
+
+/*
+-------------------------
+AS_GetLoopedWave
+
+loopedWave <name>
+-------------------------
+*/
+
+static void AS_GetLoopedWave( ambientSet_t &set )
+{
+	char	waveBuffer[256], waveName[1024];
+
+	//Get the looped wave name
+	sscanf( parseBuffer+parsePos, "%s %s", &tempBuffer, &waveBuffer );
+
+	//Construct the wave name
+	strcpy( (char *) waveName, "sound/" );
+	strncat( (char *) waveName, (const char *) waveBuffer, 1024 );
+	strncat( (char *) waveName, ".wav", 1024 );
+	
+	//Precache the file at this point and store off the ID instead of the name
+	if ( ( set.loopedWave = S_RegisterSound( waveName ) ) <= 0 )
+	{
+		#ifndef FINAL_BUILD
+		//Com_Printf(S_COLOR_RED"ERROR: Unable to load ambient sound \"%s\"\n", waveName);
+		Com_Error(ERR_DROP, "ERROR: Unable to load looped ambient sound \"%s\"\n", waveName);
+		#endif
+	}
+
+	AS_SkipLine();
+}
+
+/*
+-------------------------
+AS_GetVolumeRange
+-------------------------
+*/
+
+static void AS_GetVolumeRange( ambientSet_t &set )
+{
+	int		min, max;
+
+	//Get the data
+	sscanf( parseBuffer+parsePos, "%s %d %d", &tempBuffer, &min, &max );
+
+	//Check for swapped min / max
+	if ( min > max )
+	{
+		#ifndef FINAL_BUILD
+		Com_Printf(S_COLOR_YELLOW"WARNING: Corrected swapped min / max range in a \"volRange\" keyword\n");
+		#endif
+		
+		int swap =	min;
+					min = max;
+						  max = swap;		
+	}
+
+	//Store the data
+	set.volRange_start	= min;
+	set.volRange_end	= max;
+
+	AS_SkipLine();
+}
+
+/*
+-------------------------
+AS_GetRadius
+-------------------------
+*/
+
+static void AS_GetRadius( ambientSet_t &set )
+{
+	//Get the data
+	sscanf( parseBuffer+parsePos, "%s %d", &tempBuffer, &set.radius );
+
+	AS_SkipLine();
+}
+
+/*
+-------------------------
+AS_GetGeneralSet
+-------------------------
+*/
+
+static void AS_GetGeneralSet( ambientSet_t &set )
+{
+	int		keywordID;
+
+	//The other parameters of the set come in a specific order
+	while ( parsePos <= parseSize )
+	{
+		int iFieldsScanned = sscanf( parseBuffer+parsePos, "%s", &tempBuffer );
+		if (iFieldsScanned <= 0)
+			return;
+
+		keywordID = AS_GetKeywordIDForString( (const char *) &tempBuffer );
+
+		//Find and parse the keyword info
+		switch ( keywordID )
+		{
+		case SET_KEYWORD_TIMEBETWEENWAVES:
+			AS_GetTimeBetweenWaves( set );
+			break;
+
+		case SET_KEYWORD_SUBWAVES:
+			AS_GetSubWaves( set );
+			break;
+
+		case SET_KEYWORD_LOOPEDWAVE:
+			AS_GetLoopedWave( set );
+			break;
+
+		case SET_KEYWORD_VOLRANGE:
+			AS_GetVolumeRange( set );
+			break;
+
+		default:
+
+			//Check to see if we've finished this group
+			if ( AS_GetSetNameIDForString( (const char *) &tempBuffer ) == -1 )
+			{
+				//Ignore comments
+				if ( tempBuffer[0] == ';' )
+					return;
+
+				//This wasn't a set name, so it's an error
+				#ifndef FINAL_BUILD
+				Com_Printf( S_COLOR_YELLOW"WARNING: Unknown ambient set keyword \"%s\"\n", tempBuffer );
+				#endif
+			}
+
+			return;
+			break;
+		}
+	}
+}
+
+/*
+-------------------------
+AS_GetLocalSet
+-------------------------
+*/
+
+static void AS_GetLocalSet( ambientSet_t &set )
+{
+	int		keywordID;
+
+	//The other parameters of the set come in a specific order
+	while ( parsePos <= parseSize )
+	{
+		int iFieldsScanned = sscanf( parseBuffer+parsePos, "%s", &tempBuffer );
+		if (iFieldsScanned <= 0)
+			return;
+
+		keywordID = AS_GetKeywordIDForString( (const char *) &tempBuffer );
+
+		//Find and parse the keyword info
+		switch ( keywordID )
+		{
+		case SET_KEYWORD_TIMEBETWEENWAVES:
+			AS_GetTimeBetweenWaves( set );
+			break;
+
+		case SET_KEYWORD_SUBWAVES:
+			AS_GetSubWaves( set );
+			break;
+
+		case SET_KEYWORD_LOOPEDWAVE:
+			AS_GetLoopedWave( set );
+			break;
+
+		case SET_KEYWORD_VOLRANGE:
+			AS_GetVolumeRange( set );
+			break;
+
+		case SET_KEYWORD_RADIUS:
+			AS_GetRadius( set );
+			break;
+
+		default:
+
+			//Check to see if we've finished this group
+			if ( AS_GetSetNameIDForString( (const char *) &tempBuffer ) == -1 )
+			{
+				//Ignore comments
+				if ( tempBuffer[0] == ';' )
+					return;
+
+				//This wasn't a set name, so it's an error
+				#ifndef FINAL_BUILD
+				Com_Printf( S_COLOR_YELLOW"WARNING: Unknown ambient set keyword \"%s\"\n", tempBuffer );
+				#endif
+			}
+
+			return;
+			break;
+		}
+	}
+}
+
+/*
+-------------------------
+AS_GetBModelSet
+-------------------------
+*/
+
+static void AS_GetBModelSet( ambientSet_t &set )
+{
+	int		keywordID;
+
+	//The other parameters of the set come in a specific order
+	while ( parsePos <= parseSize )
+	{
+		int iFieldsScanned = sscanf( parseBuffer+parsePos, "%s", &tempBuffer );
+		if (iFieldsScanned <= 0)
+			return;
+
+		keywordID = AS_GetKeywordIDForString( (const char *) &tempBuffer );
+
+		//Find and parse the keyword info
+		switch ( keywordID )
+		{
+		case SET_KEYWORD_SUBWAVES:
+			AS_GetSubWaves( set );
+			break;
+
+		default:
+
+			//Check to see if we've finished this group
+			if ( AS_GetSetNameIDForString( (const char *) &tempBuffer ) == -1 )
+			{
+				//Ignore comments
+				if ( tempBuffer[0] == ';' )
+					return;
+
+				//This wasn't a set name, so it's an error
+				#ifndef FINAL_BUILD
+				Com_Printf( S_COLOR_YELLOW"WARNING: Unknown ambient set keyword \"%s\"\n", tempBuffer );
+				#endif
+			}
+
+			return;
+			break;
+		}
+	}
+}
+
+/*
+-------------------------
+AS_ParseSet
+
+Parses an individual set group out of a set file buffer
+-------------------------
+*/
+
+static qboolean AS_ParseSet( int setID, CSetGroup *sg )
+{
+	ambientSet_t	*set;
+	const char		*name;
+
+	//Make sure we're not overstepping the name array
+	if ( setID > NUM_AS_SETS )
+		return qfalse;
+
+	//Reset the pointers for this run through
+	parsePos = 0;
+
+	name = setNames[setID];
+
+	//Iterate through the whole file and find every occurance of a set
+	while ( parsePos <= parseSize )
+	{
+		//Check for a valid set group
+		if ( strncmp( parseBuffer+parsePos, name, strlen(name) ) == 0 )
+		{
+			//Update the debug info
+			numSets++;	
+			
+			//Push past the set specifier and on to the name
+			parsePos+=strlen(name)+1;	//Also take the following space out
+
+			//Get the set name (this MUST be first)
+			sscanf( parseBuffer+parsePos, "%s", &tempBuffer );
+			AS_SkipLine();
+	
+			//Test the string against the precaches
+			if ( tempBuffer[0] )
+			{
+				//Not in our precache listings, so skip it
+				if ( ( pMap->find( (const char *) &tempBuffer ) == pMap->end() ) )
+					continue;
+			}
+
+			//Create a new set
+			set = sg->AddSet( (const char *) &tempBuffer );
+			
+			//Run the function to parse the data out
+			parseFuncs[setID]( *set );
+			continue;
+		}
+
+		//If not found on this line, go down another and check again
+		AS_SkipLine();
+	}
+	
+	return qtrue;
+}
+
+/*
+-------------------------
+AS_ParseHeader
+
+Parses the directory information out of the beginning of the file
+-------------------------
+*/
+
+static void AS_ParseHeader( void )
+{	
+	char	typeBuffer[128];
+	int		keywordID;
+
+	while ( parsePos <= parseSize )
+	{
+		sscanf( parseBuffer+parsePos, "%s", &tempBuffer );
+
+		keywordID = AS_GetKeywordIDForString( (const char *) &tempBuffer );
+
+		switch ( keywordID )
+		{
+		case SET_KEYWORD_TYPE:
+			sscanf( parseBuffer+parsePos, "%s %s", &tempBuffer, &typeBuffer );
+
+			if ( !stricmp( (const char *) typeBuffer, "ambientSet" ) )
+			{
+				return;
+			}
+			Com_Error( ERR_DROP, "AS_ParseHeader: Set type \"%s\" is not a valid set type!\n", typeBuffer );
+
+			break;
+
+		case SET_KEYWORD_AMSDIR:
+			//TODO: Implement
+			break;
+
+		case SET_KEYWORD_OUTDIR:
+			//TODO: Implement
+			break;
+
+		case SET_KEYWORD_BASEDIR:
+			//TODO: Implement
+			break;
+		}
+
+		AS_SkipLine();
+	}
+}
+
+/*
+-------------------------
+AS_ParseFile
+
+Opens and parses a sound set file
+-------------------------
+*/
+
+static qboolean AS_ParseFile( const char *filename, CSetGroup *sg )
+{
+	//Open the file and read the information from it
+	parseSize = FS_ReadFile( filename, (void **) &parseBuffer );
+
+	if ( parseSize <= 0 )
+		return qfalse;
+
+	//Parse the directory information out of the file
+	AS_ParseHeader();
+
+	//Parse all the relevent sets out of it
+	for ( int i = 0; i < NUM_AS_SETS; i++ )
+		AS_ParseSet( i, sg );
+
+	//Free the memory and close the file
+	FS_FreeFile( parseBuffer );
+
+	return qtrue;
+}
+
+/*
+===============================================
+
+Main code
+
+===============================================
+*/
+
+/*
+-------------------------
+AS_Init
+
+Loads the ambient sound sets and prepares to play them when needed
+-------------------------
+*/
+
+static namePrecache_m *TheNamePrecache()
+{
+	// we use these singletons so we can find memory leaks
+	// if you let things like this leak, you never can tell
+	// what is really leaking and what is merely not ever freed
+	static namePrecache_m singleton;
+	return &singleton;
+}
+
+void AS_Init( void )
+{
+	if (!aSets)
+	{
+		numSets = 0;
+
+		pMap = TheNamePrecache();
+
+		//Setup the structure
+		aSets = new CSetGroup();
+		aSets->Init();
+	}
+}
+
+/*
+-------------------------
+AS_AddPrecacheEntry
+-------------------------
+*/
+
+void AS_AddPrecacheEntry( const char *name )
+{
+	if (!pMap)	//s_initsound 0 probably
+	{
+		return;
+	}
+	if (!stricmp(name,"#clear"))
+	{
+		pMap->clear();
+		currentSet	= -1;
+		oldSet		= -1;
+	}
+	else
+	{
+		(*pMap)[ name ] = 1;
+	}
+}
+
+/*
+-------------------------
+AS_ParseSets
+
+Called on the client side to load and precache all the ambient sound sets
+-------------------------
+*/
+
+void AS_ParseSets( void )
+{
+	cvar_t	*cv = Cvar_Get ("s_initsound", "1", CVAR_ROM);
+	if ( !cv->integer ) {
+		return;
+	}
+	AS_Init();
+
+	//Parse all the sets
+	if ( AS_ParseFile( AMBIENT_SET_FILENAME, aSets ) == qfalse )
+	{
+		Com_Error ( ERR_FATAL, S_COLOR_RED"ERROR: Couldn't load ambient sound sets from %s", AMBIENT_SET_FILENAME );
+	}
+
+	//Com_Printf( "AS_ParseFile: Loaded %d of %d ambient set(s)\n", pMap.size(), numSets );
+
+	int iErrorsOccured = 0;
+	for (namePrecache_m::iterator it = pMap->begin(); it != pMap->end(); ++it)
+	{
+		const char* str = (*it).first.c_str();
+		ambientSet_t *aSet = aSets->GetSet( str );
+		if (!aSet)
+		{
+			// I print these red instead of yellow because they're going to cause an ERR_DROP if they occur
+			Com_Printf( S_COLOR_RED"ERROR: AS_ParseSets: Unable to find ambient soundset \"%s\"!\n",str);
+			iErrorsOccured++;
+		}
+	}
+
+	if (iErrorsOccured)
+	{
+		Com_Error( ERR_DROP, "....%d missing sound sets! (see above)\n", iErrorsOccured);
+	}
+
+//	//Done with the precache info, it will be rebuilt on a restart
+//	pMap->clear();	// do NOT do this here now
+}
+
+/*
+-------------------------
+AS_Free
+
+Frees up the ambient sound system
+-------------------------
+*/
+
+void AS_Free( void )
+{
+	if (aSets)
+	{
+		aSets->Free();
+		delete aSets;
+		aSets = NULL;
+
+		currentSet	= -1;
+		oldSet		= -1;
+
+		currentSetTime = 0;
+		oldSetTime = 0;
+
+		numSets	= 0;
+	}
+}
+
+
+void AS_FreePartial(void)
+{
+	if (aSets)
+	{
+		aSets->Free();
+		currentSet	= -1;
+		oldSet		= -1;
+
+		currentSetTime = 0;
+		oldSetTime = 0;
+
+		numSets	= 0;
+
+		pMap = TheNamePrecache();
+		pMap->clear();
+	}
+}
+
+/*
+===============================================
+
+Sound code
+
+===============================================
+*/
+
+/*
+-------------------------
+AS_UpdateSetVolumes
+
+Fades volumes up or down depending on the action being taken on them.
+-------------------------
+*/
+
+static void AS_UpdateSetVolumes( void )
+{
+	ambientSet_t	*old, *current;
+	float			scale;
+	int				deltaTime;
+
+	//Get the sets and validate them
+	current = aSets->GetSet( currentSet );
+
+	if ( current == NULL )
+		return;
+
+	if ( current->masterVolume < MAX_SET_VOLUME )
+	{
+		deltaTime = cls.realtime - current->fadeTime;
+		scale = ((float)(deltaTime)/(float)(crossDelay));
+		current->masterVolume = (int)((scale) * (float)MAX_SET_VOLUME);
+	}
+
+	if ( current->masterVolume > MAX_SET_VOLUME )
+		current->masterVolume = MAX_SET_VOLUME;
+
+	//Only update the old set if it's still valid
+	if ( oldSet == -1 )
+		return;
+
+	old = aSets->GetSet( oldSet );
+
+	if ( old == NULL )
+		return;
+
+	//Update the volumes
+	if ( old->masterVolume > 0 )
+	{
+		deltaTime = cls.realtime - old->fadeTime;
+		scale = ((float)(deltaTime)/(float)(crossDelay));
+		old->masterVolume = MAX_SET_VOLUME - (int)((scale) * (float)MAX_SET_VOLUME);
+	}
+
+	if ( old->masterVolume <= 0 )
+	{
+		old->masterVolume = 0;
+		oldSet = -1;
+	}
+}
+
+/*
+-------------------------
+S_UpdateCurrentSet
+
+Does internal maintenance to keep track of changing sets.
+-------------------------
+*/
+
+static void AS_UpdateCurrentSet( int id )
+{
+	ambientSet_t	*old, *current;
+
+	//Check for a change
+	if ( id != currentSet )
+	{
+		//This is new, so start the fading
+		oldSet = currentSet;
+		currentSet = id;
+
+		old = aSets->GetSet( oldSet );
+		current = aSets->GetSet( currentSet );
+		// Ste, I just put this null check in for now, not sure if there's a more graceful way to exit this function - dmv
+		if( !current )
+		{
+			return;
+		}
+		if ( old )
+		{
+			old->masterVolume = MAX_SET_VOLUME;
+			old->fadeTime = cls.realtime;
+		}
+	
+		current->masterVolume = 0;
+
+		//Set the fading starts
+		current->fadeTime = cls.realtime;
+	}
+
+	//Update their volumes if fading
+	AS_UpdateSetVolumes();
+}
+
+/*
+-------------------------
+AS_PlayLocalSet
+
+Plays a local set taking volume and subwave playing into account.  
+Alters lastTime to reflect the time updates.
+-------------------------
+*/
+
+static void AS_PlayLocalSet( vec3_t listener_origin, vec3_t origin, ambientSet_t *set, int entID, int *lastTime )
+{
+	unsigned char	volume;
+	vec3_t			dir;
+	float			volScale, dist, distScale;
+	int				time = cls.realtime;
+
+	//Make sure it's valid
+	if ( set == NULL )
+		return;
+
+	VectorSubtract( origin, listener_origin, dir );
+	dist = VectorLength( dir );
+
+	//Determine the volume based on distance (NOTE: This sits on top of what SpatializeOrigin does)
+	distScale	= ( dist < ( set->radius * 0.5f ) ) ? 1 : ( set->radius - dist ) / ( set->radius * 0.5f );
+	volume		= ( distScale > 1.0f || distScale < 0.0f ) ? 0 : (unsigned char) ( set->masterVolume * distScale );
+
+	//Add the looping sound
+	if ( set->loopedWave )
+		S_AddAmbientLoopingSound( origin, volume, set->loopedWave );
+
+	//Check the time to start another one-shot subwave
+	if ( ( time - *lastTime ) < ( ( Q_irand( set->time_start, set->time_end ) ) * 1000 ) )
+		return;
+	
+	//Update the time
+	*lastTime = time;
+
+	//Scale the volume ranges for the subwaves based on the overall master volume
+	volScale = (float) volume / (float) MAX_SET_VOLUME;
+	volume = (unsigned char) Q_irand( (int)(volScale*set->volRange_start), (int)(volScale*set->volRange_end) );
+
+	//Add the random subwave
+	if ( set->numSubWaves )
+		S_StartAmbientSound( origin, entID, volume, set->subWaves[Q_irand( 0, set->numSubWaves-1)] );
+}
+
+/*
+-------------------------
+AS_PlayAmbientSet
+
+Plays an ambient set taking volume and subwave playing into account.  
+Alters lastTime to reflect the time updates.
+-------------------------
+*/
+
+static void AS_PlayAmbientSet( vec3_t origin, ambientSet_t *set, int *lastTime )
+{
+	unsigned char	volume;
+	float			volScale;
+	int				time = cls.realtime;
+
+	//Make sure it's valid
+	if ( set == NULL )
+		return;
+
+	//Add the looping sound
+	if ( set->loopedWave )
+		S_AddAmbientLoopingSound( origin, (unsigned char) set->masterVolume, set->loopedWave );
+
+	//Check the time to start another one-shot subwave
+	if ( ( time - *lastTime ) < ( ( Q_irand( set->time_start, set->time_end ) ) * 1000 ) )
+		return;
+	
+	//Update the time
+	*lastTime = time;
+
+	//Scale the volume ranges for the subwaves based on the overall master volume
+	volScale = (float) set->masterVolume / (float) MAX_SET_VOLUME;
+	volume = Q_irand( (int)(volScale*set->volRange_start), (int)(volScale*set->volRange_end) );
+
+	//Allow for softer noises than the masterVolume, but not louder
+	if ( volume > set->masterVolume )
+		volume = set->masterVolume;
+
+	//Add the random subwave
+	if ( set->numSubWaves )
+		S_StartAmbientSound( origin, 0, volume, set->subWaves[Q_irand( 0, set->numSubWaves-1)] );
+}
+
+/*
+-------------------------
+S_UpdateAmbientSet
+
+Does maintenance and plays the ambient sets (two if crossfading)
+-------------------------
+*/
+
+void S_UpdateAmbientSet ( const char *name, vec3_t origin ) 
+{
+	ambientSet_t	*current, *old;
+	if (aSets == NULL)
+	{
+		return;
+	}
+	ambientSet_t	*set = aSets->GetSet( name );
+	
+	if ( set == NULL )
+		return;
+
+	//Update the current and old set for crossfading
+	AS_UpdateCurrentSet( set->id );
+
+	current = aSets->GetSet( currentSet );
+	old = aSets->GetSet( oldSet );
+
+	if ( current )
+		AS_PlayAmbientSet( origin, set, &currentSetTime );
+
+	if ( old )
+		AS_PlayAmbientSet( origin, old, &oldSetTime );
+}
+
+/*
+-------------------------
+S_AddLocalSet
+-------------------------
+*/
+
+int S_AddLocalSet( const char *name, vec3_t listener_origin, vec3_t origin, int entID, int time )
+{
+	ambientSet_t	*set;
+	int				currentTime = 0;
+
+	set = aSets->GetSet( name );
+
+	if ( set == NULL )
+		return cls.realtime;
+
+	currentTime = time;
+
+	AS_PlayLocalSet( listener_origin, origin, set, entID, &currentTime );
+	
+	return currentTime;
+}
+
+/*
+-------------------------
+AS_GetBModelSound
+-------------------------
+*/
+
+sfxHandle_t AS_GetBModelSound( const char *name, int stage )
+{
+	ambientSet_t	*set;
+
+	set = aSets->GetSet( name );
+
+	if ( set == NULL )
+		return -1;
+
+	//Stage must be within a valid range
+	if ( ( stage > ( set->numSubWaves - 1 ) ) || ( stage < 0 ) )
+		return -1;
+
+	return set->subWaves[ stage ];
+}
diff --git a/code/client/snd_ambient.h b/code/client/snd_ambient.h
new file mode 100644
index 0000000..3b6e7db
--- /dev/null
+++ b/code/client/snd_ambient.h
@@ -0,0 +1,118 @@
+#ifndef	__SND_AMBIENT__
+#define __SND_AMBIENT__
+
+// Includes
+
+#pragma warning ( disable : 4786 )
+#pragma warning ( disable : 4511 )	//copy constructor could not be gen
+#pragma warning ( disable : 4512 )	//assign constructor could not be gen
+
+//these don't work because stl re-sets them
+//#pragma warning ( disable : 4663 )	//spcialize class
+//#pragma warning ( disable : 4018 )	//signed/unsigned
+#pragma warning (disable:4503)	// decorated name length xceeded, name was truncated
+#pragma warning (push, 3)	//go back down to 3 for the stl include
+
+#include "../qcommon/sstring.h"	// #include <string>
+#include <vector>
+#include <map>
+#pragma warning (pop)
+#pragma warning (disable:4503)	// decorated name length xceeded, name was truncated
+
+using namespace std;
+
+// Defines
+
+#define	AMBIENT_SET_FILENAME	"sound/sound.txt"
+
+const	int	MAX_WAVES_PER_GROUP	= 8;
+const	int	MAX_SET_NAME_LENGTH	= 64;
+
+// Enums
+
+enum set_e
+{
+	AS_SET_GENERAL,		//General sets
+	AS_SET_LOCAL,		//Local sets (regional)
+	AS_SET_BMODEL,		//Brush model sets (doors, plats, etc.)
+
+	NUM_AS_SETS
+};
+
+enum setKeyword_e
+{
+	SET_KEYWORD_TIMEBETWEENWAVES,
+	SET_KEYWORD_SUBWAVES,
+	SET_KEYWORD_LOOPEDWAVE,
+	SET_KEYWORD_VOLRANGE,
+	SET_KEYWORD_RADIUS,
+	SET_KEYWORD_TYPE,
+	SET_KEYWORD_AMSDIR,
+	SET_KEYWORD_OUTDIR,
+	SET_KEYWORD_BASEDIR,
+	
+	NUM_AS_KEYWORDS,
+};
+
+// Structures
+
+//NOTENOTE: Was going to make this a class, but don't want to muck around
+typedef struct ambientSet_s
+{
+	char			name[MAX_SET_NAME_LENGTH];
+	unsigned char	loopedVolume;
+	unsigned int	time_start, time_end;
+	unsigned int	volRange_start, volRange_end;
+	unsigned char	numSubWaves;
+	int				subWaves[MAX_WAVES_PER_GROUP];
+	int				loopedWave;
+	int				radius;							//NOTENOTE: -1 is global
+	int				masterVolume;					//Used for fading ambient sets (not a byte to prevent wrapping)
+	int				id;								//Used for easier referencing of sets
+	int				fadeTime;						//When the fade was started on this set
+} ambientSet_t;
+
+typedef void (*parseFunc_t)( ambientSet_t & );
+
+// Classes
+
+//NOTENOTE: But this one should be a class because of all the mapping and internal data handling
+class CSetGroup
+{
+public:
+
+	CSetGroup();
+	~CSetGroup();
+
+	void Init( void ) 
+	{
+		Free();
+	}
+
+	void Free( void );
+
+	ambientSet_t *AddSet( const char *name );
+	
+	ambientSet_t *GetSet ( const char *name );
+	ambientSet_t *GetSet ( int ID );
+
+protected:
+
+	int								m_numSets;
+	vector < ambientSet_t * >		*m_ambientSets;
+	map	< sstring_t, ambientSet_t * >	*m_setMap;
+};
+
+// Prototypes
+
+extern void AS_Init( void );
+extern void AS_Free( void );
+extern void AS_ParseSets( void );
+extern void AS_AddPrecacheEntry( const char *name );
+
+extern void S_UpdateAmbientSet ( const char *name, vec3_t origin );
+extern int S_AddLocalSet( const char *name, vec3_t origin, int time );
+
+extern sfxHandle_t	AS_GetBModelSound( const char *name, int stage );
+
+#endif	//__SND_AMBIENT__
\ No newline at end of file
diff --git a/code/client/snd_dma.cpp b/code/client/snd_dma.cpp
new file mode 100644
index 0000000..2975307
--- /dev/null
+++ b/code/client/snd_dma.cpp
@@ -0,0 +1,6276 @@
+/*****************************************************************************
+ * name:		snd_dma.c
+ *
+ * desc:		main control for any streaming sound output device
+ *
+ *
+ *****************************************************************************/
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+#include "snd_local.h"
+#include "cl_mp3.h"
+#include "snd_music.h"
+
+static void S_Play_f(void);
+static void S_SoundList_f(void);
+static void S_Music_f(void);
+static void S_SetDynamicMusic_f(void);
+
+void S_Update_();
+void S_StopAllSounds(void);
+static void S_UpdateBackgroundTrack( void );
+sfx_t *S_FindName( const char *name );
+static int SND_FreeSFXMem(sfx_t *sfx);
+
+extern qboolean Sys_LowPhysicalMemory();
+
+//////////////////////////
+//
+// vars for bgrnd music track...
+//
+const int iMP3MusicStream_DiskBytesToRead = 10000;//4096;
+const int iMP3MusicStream_DiskBufferSize = iMP3MusicStream_DiskBytesToRead*2; //*10;
+
+typedef struct
+{	
+	qboolean	bIsMP3;
+	//
+	// MP3 specific...
+	//
+	sfx_t		sfxMP3_Bgrnd;
+	MP3STREAM	streamMP3_Bgrnd;	// this one is pointed at by the sfx_t's ptr, and is NOT the one the decoder uses every cycle
+	channel_t	chMP3_Bgrnd;		// ... but the one in this struct IS.	
+	//
+	// MP3 disk streamer stuff... (if music is non-dynamic)
+	//
+	byte		byMP3MusicStream_DiskBuffer[iMP3MusicStream_DiskBufferSize];
+	int			iMP3MusicStream_DiskReadPos;
+	int			iMP3MusicStream_DiskWindowPos;
+	//
+	// MP3 disk-load stuff (for use during dynamic music, which is mem-resident)
+	//
+	byte		*pLoadedData;	// Z_Malloc, Z_Free	// these two MUST be kept as valid/invalid together	
+	char		sLoadedDataName[MAX_QPATH];			//  " " " " "  
+	int			iLoadedDataLen;	
+	//
+	// remaining dynamic fields...
+	//
+	int			iXFadeVolumeSeekTime;
+	int			iXFadeVolumeSeekTo;	// when changing this, set the above timer to Sys_Milliseconds(). 
+									//	Note that this should be thought of more as an up/down bool rather than as a 
+									//	number now, in other words set it only to 0 or 255. I'll probably change this
+									//	to actually be a bool later.
+	int			iXFadeVolume;		// 0 = silent, 255 = max mixer vol, though still modulated via overall music_volume 
+	float		fSmoothedOutVolume;
+	qboolean	bActive;			// whether playing or not
+	qboolean	bExists;			// whether was even loaded for this level (ie don't try and start playing it)
+	//
+	// new dynamic fields...
+	//
+	qboolean	bTrackSwitchPending;
+	MusicState_e eTS_NewState;
+	float		 fTS_NewTime;
+	//
+	// Generic...
+	//
+	fileHandle_t s_backgroundFile;	// valid handle, else -1 if an MP3 (so that NZ compares still work)
+	wavinfo_t	s_backgroundInfo;
+	int			s_backgroundSamples;	
+
+	void Rewind()
+	{
+		MP3Stream_Rewind( &chMP3_Bgrnd );
+		s_backgroundSamples = sfxMP3_Bgrnd.iSoundLengthInSamples;
+	}
+
+	void SeekTo(float fTime)
+	{
+		chMP3_Bgrnd.iMP3SlidingDecodeWindowPos = 0;
+		chMP3_Bgrnd.iMP3SlidingDecodeWritePos = 0;
+		MP3Stream_SeekTo( &chMP3_Bgrnd, fTime );
+		s_backgroundSamples = sfxMP3_Bgrnd.iSoundLengthInSamples;
+	}
+
+} MusicInfo_t;
+
+static void S_SetDynamicMusicState( MusicState_e musicState );
+
+#define fDYNAMIC_XFADE_SECONDS (1.0f)
+
+static MusicInfo_t	tMusic_Info[eBGRNDTRACK_NUMBEROF]	= {0};
+static qboolean		bMusic_IsDynamic					= qfalse;
+static MusicState_e	eMusic_StateActual					= eBGRNDTRACK_EXPLORE;	// actual state, can be any enum
+static MusicState_e	eMusic_StateRequest					= eBGRNDTRACK_EXPLORE;	// requested state, can only be explore, action, boss, or silence
+static char			sMusic_BackgroundLoop[MAX_QPATH]	= {0};	// only valid for non-dynamic music
+static char			sInfoOnly_CurrentDynamicMusicSet[64];	// any old reasonable size, only has to fit stuff like "kejim_post"
+//
+//////////////////////////
+
+
+// =======================================================================
+// Internal sound data & structures
+// =======================================================================
+ 
+// only begin attenuating sound volumes when outside the FULLVOLUME range
+#define		SOUND_FULLVOLUME	256
+
+#define		SOUND_ATTENUATE		0.0008f
+#define		VOICE_ATTENUATE		0.004f
+
+const float	SOUND_FMAXVOL=0.75;//1.0;
+const int	SOUND_MAXVOL=255;
+
+channel_t   s_channels[MAX_CHANNELS];
+
+int			s_soundStarted;
+qboolean	s_soundMuted;
+
+dma_t		dma;
+
+int			listener_number;
+vec3_t		listener_origin;
+vec3_t		listener_axis[3];
+
+int			s_soundtime;		// sample PAIRS
+int   		s_paintedtime; 		// sample PAIRS
+
+// MAX_SFX may be larger than MAX_SOUNDS because
+// of custom player sounds
+#define		MAX_SFX			10000	//512 * 2
+sfx_t		s_knownSfx[MAX_SFX];
+int			s_numSfx;
+
+#define		LOOP_HASH		128
+static	sfx_t		*sfxHash[LOOP_HASH];
+
+
+cvar_t		*s_volume;
+cvar_t		*s_volumeVoice;
+cvar_t		*s_testsound;
+cvar_t		*s_khz;
+cvar_t		*s_allowDynamicMusic;
+cvar_t		*s_show;
+cvar_t		*s_mixahead;
+cvar_t		*s_mixPreStep;
+cvar_t		*s_musicVolume;
+cvar_t		*s_separation;
+cvar_t		*s_lip_threshold_1;
+cvar_t		*s_lip_threshold_2;
+cvar_t		*s_lip_threshold_3;
+cvar_t		*s_lip_threshold_4;
+cvar_t		*s_CPUType;
+cvar_t		*s_language;	// note that this is distinct from "g_language"
+cvar_t		*s_dynamix;
+cvar_t		*s_debugdynamic;
+
+typedef struct 
+{ 
+	unsigned char	volume;
+	vec3_t			origin;
+//	vec3_t			velocity;
+/*	const*/ sfx_t		*sfx;
+	int				mergeFrame;
+	int				entnum;
+	soundChannel_t	entchan;
+
+	// For Open AL
+	bool	bProcessed;
+	bool	bRelative;
+} loopSound_t;
+
+#define	MAX_LOOP_SOUNDS		64
+int			numLoopSounds;
+loopSound_t	loopSounds[MAX_LOOP_SOUNDS];
+
+
+int			s_rawend;
+portable_samplepair_t	s_rawsamples[MAX_RAW_SAMPLES];
+vec3_t		s_entityPosition[MAX_GENTITIES];
+int			s_entityWavVol[MAX_GENTITIES];
+int			s_entityWavVol_back[MAX_GENTITIES];
+
+
+/**************************************************************************************************\
+*
+*	Open AL Specific
+*
+\**************************************************************************************************/
+
+#define FLT_MAX         3.402823466e+38F
+#define FLT_MIN         1.175494351e-38F
+#define sqr(a)			((a)*(a))
+#define ENV_UPDATE_RATE	100			// Environmental audio update rate (in ms)
+
+//#define DISPLAY_CLOSEST_ENVS		// Displays the closest env. zones (including the one the listener is in)
+
+#define DEFAULT_REF_DISTANCE		300.0f		// Default reference distance
+#define DEFAULT_VOICE_REF_DISTANCE	1500.0f		// Default voice reference distance
+
+int			s_UseOpenAL	= false;	// Determines if using Open AL or the default software mixer
+
+ALfloat		listener_pos[3];		// Listener Position
+ALfloat		listener_ori[6];		// Listener Orientation
+int			s_numChannels;			// Number of AL Sources == Num of Channels
+short		s_rawdata[MAX_RAW_SAMPLES*2];	// Used for Raw Samples (Music etc...)
+
+channel_t *S_OpenALPickChannel(int entnum, int entchannel);
+int  S_MP3PreProcessLipSync(channel_t *ch, short *data);
+void UpdateSingleShotSounds();
+void UpdateLoopingSounds();
+void AL_UpdateRawSamples();
+void S_SetLipSyncs();
+
+// EAX Related
+
+typedef struct
+{
+	ALuint		ulNumApertures;
+	ALint		lFXSlotID;
+	ALboolean	bUsed;
+	struct
+	{
+		ALfloat vPos1[3];
+		ALfloat vPos2[3];
+		ALfloat vCenter[3];
+	} Aperture[64];
+} ENVTABLE, *LPENVTABLE;
+
+typedef struct
+{
+	long lEnvID;
+	long lApertureNum;
+	float flDist;
+} REVERBDATA, *LPREVERBDATA;
+
+typedef struct
+{
+	GUID	FXSlotGuid;
+	ALint	lEnvID;
+} FXSLOTINFO, *LPFXSLOTINFO;
+
+ALboolean				s_bEAX;					// Is EAX 4.0 support available
+bool					s_bEALFileLoaded;		// Has an .eal file been loaded for the current level
+bool					s_bInWater;				// Underwater effect currently active 
+int						s_EnvironmentID;		// EAGLE ID of current environment
+LPEAXMANAGER			s_lpEAXManager;			// Pointer to EAXManager object
+HINSTANCE				s_hEAXManInst;			// Handle of EAXManager DLL
+EAXSet					s_eaxSet;				// EAXSet() function
+EAXGet					s_eaxGet;				// EAXGet() function
+EAXREVERBPROPERTIES		s_eaxLPCur;				// Current EAX Parameters
+LPENVTABLE				s_lpEnvTable=NULL;		// Stores information about each environment zone
+long					s_lLastEnvUpdate;		// Time of last EAX update
+long					s_lNumEnvironments;		// Number of environment zones
+long					s_NumFXSlots;			// Number of EAX 4.0 FX Slots
+FXSLOTINFO				s_FXSlotInfo[EAX_MAX_FXSLOTS];	// Stores information about the EAX 4.0 FX Slots
+
+static void InitEAXManager();
+static void ReleaseEAXManager();
+static bool LoadEALFile(char *szEALFilename);
+static void UnloadEALFile();
+static void UpdateEAXListener();
+static void UpdateEAXBuffer(channel_t *ch);
+static void EALFileInit(char *level);
+float CalcDistance(EMPOINT A, EMPOINT B);
+
+void Normalize(EAXVECTOR *v)
+{
+	float flMagnitude;
+
+	flMagnitude = (float)sqrt(sqr(v->x) + sqr(v->y) + sqr(v->z));
+
+	v->x = v->x / flMagnitude;
+	v->y = v->y / flMagnitude;
+	v->z = v->z / flMagnitude;	
+}
+
+// EAX 4.0 GUIDS ... confidential information ...
+
+const GUID EAXPROPERTYID_EAX40_FXSlot0 = { 0xc4d79f1e, 0xf1ac, 0x436b, { 0xa8, 0x1d, 0xa7, 0x38, 0xe7, 0x4, 0x54, 0x69} };
+
+const GUID EAXPROPERTYID_EAX40_FXSlot1 = { 0x8c00e96, 0x74be, 0x4491, { 0x93, 0xaa, 0xe8, 0xad, 0x35, 0xa4, 0x91, 0x17} };
+
+const GUID EAXPROPERTYID_EAX40_FXSlot2 = { 0x1d433b88, 0xf0f6, 0x4637, { 0x91, 0x9f, 0x60, 0xe7, 0xe0, 0x6b, 0x5e, 0xdd} };
+
+const GUID EAXPROPERTYID_EAX40_FXSlot3 = { 0xefff08ea, 0xc7d8, 0x44ab, { 0x93, 0xad, 0x6d, 0xbd, 0x5f, 0x91, 0x0, 0x64} };
+
+const GUID EAXPROPERTYID_EAX40_Context = { 0x1d4870ad, 0xdef, 0x43c0, { 0xa4, 0xc, 0x52, 0x36, 0x32, 0x29, 0x63, 0x42} };
+
+const GUID EAXPROPERTYID_EAX40_Source = { 0x1b86b823, 0x22df, 0x4eae, { 0x8b, 0x3c, 0x12, 0x78, 0xce, 0x54, 0x42, 0x27} };
+
+const GUID EAX_NULL_GUID = { 0x00000000, 0x0000, 0x0000, { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } };
+
+const GUID EAX_PrimaryFXSlotID = { 0xf317866d, 0x924c, 0x450c, { 0x86, 0x1b, 0xe6, 0xda, 0xa2, 0x5e, 0x7c, 0x20} };
+
+const GUID EAX_REVERB_EFFECT = { 0xcf95c8f, 0xa3cc, 0x4849, { 0xb0, 0xb6, 0x83, 0x2e, 0xcc, 0x18, 0x22, 0xdf} };
+
+/**************************************************************************************************\
+*
+*	End of Open AL Specific
+*
+\**************************************************************************************************/
+
+// instead of clearing a whole channel_t struct, we're going to skip the MP3SlidingDecodeBuffer[] buffer in the middle...
+//
+static inline void Channel_Clear(channel_t *ch)
+{
+	// memset (ch, 0, sizeof(*ch));
+
+	memset(ch,0,offsetof(channel_t,MP3SlidingDecodeBuffer));
+
+	byte *const p = (byte *)ch + offsetof(channel_t,MP3SlidingDecodeBuffer) + sizeof(ch->MP3SlidingDecodeBuffer);
+
+	memset(p,0,(sizeof(*ch) - offsetof(channel_t,MP3SlidingDecodeBuffer)) - sizeof(ch->MP3SlidingDecodeBuffer));
+}
+
+// ====================================================================
+// User-setable variables
+// ====================================================================
+static void DynamicMusicInfoPrint(void)
+{
+	if (bMusic_IsDynamic)
+	{
+		// horribly lazy... ;-)
+		//
+		LPCSTR psRequestMusicState	= Music_BaseStateToString( eMusic_StateRequest );
+		LPCSTR psActualMusicState	= Music_BaseStateToString( eMusic_StateActual, qtrue );
+		if (psRequestMusicState == NULL)
+		{
+			psRequestMusicState = "<unknown>";
+		}
+		if (psActualMusicState	== NULL)
+		{
+			psActualMusicState	= "<unknown>";
+		}
+		
+		Com_Printf("( Dynamic music ON, request state: '%s'(%d), actual: '%s' (%d) )\n", psRequestMusicState, eMusic_StateRequest, psActualMusicState, eMusic_StateActual);
+	}
+	else
+	{
+		Com_Printf("( Dynamic music OFF )\n");
+	}
+}
+
+void S_SoundInfo_f(void) {	
+	Com_Printf("----- Sound Info -----\n" );
+
+	if (!s_soundStarted) {
+		Com_Printf ("sound system not started\n");
+	} else {
+		if ( s_soundMuted ) {
+			Com_Printf ("sound system is muted\n");
+		}
+
+		if (s_UseOpenAL)
+		{
+			Com_Printf("EAX 4.0 %s supported\n",s_bEAX?"is":"not");
+			Com_Printf("Eal file %s loaded\n",s_bEALFileLoaded?"is":"not");
+			Com_Printf("s_EnvironmentID = %d\n",s_EnvironmentID);
+			Com_Printf("s_bInWater = %s\n",s_bInWater?"true":"false");	
+		}
+		else
+		{
+			Com_Printf("%5d stereo\n", dma.channels - 1);
+			Com_Printf("%5d samples\n", dma.samples);
+			Com_Printf("%5d samplebits\n", dma.samplebits);
+			Com_Printf("%5d submission_chunk\n", dma.submission_chunk);
+			Com_Printf("%5d speed\n", dma.speed);
+			Com_Printf("0x%x dma buffer\n", dma.buffer);
+		}	
+
+		if (bMusic_IsDynamic)
+		{		
+			DynamicMusicInfoPrint();
+			Com_Printf("( Dynamic music set name: \"%s\" )\n",sInfoOnly_CurrentDynamicMusicSet);
+		}
+		else
+		{
+			if (!s_allowDynamicMusic->integer)
+			{
+				Com_Printf("( Dynamic music inhibited (s_allowDynamicMusic == 0) )\n", sMusic_BackgroundLoop );
+			}
+			if ( tMusic_Info[eBGRNDTRACK_NONDYNAMIC].s_backgroundFile )
+			{
+				Com_Printf("Background file: %s\n", sMusic_BackgroundLoop );
+			}
+			else 
+			{
+				Com_Printf("No background file.\n" );
+			}
+		}
+	}
+	S_DisplayFreeMemory();
+	Com_Printf("----------------------\n" );
+}
+
+
+
+/*
+================
+S_Init
+================
+*/
+void S_Init( void ) {
+	ALCcontext *ALCContext = NULL;
+	ALCdevice *ALCDevice = NULL;
+	ALfloat listenerPos[]={0.0,0.0,0.0};
+	ALfloat listenerVel[]={0.0,0.0,0.0};
+	ALfloat	listenerOri[]={0.0,0.0,-1.0, 0.0,1.0,0.0};
+	cvar_t	*cv;
+	qboolean	r;
+	int i, j;
+	channel_t *ch;
+	char *mapname;
+
+	Com_Printf("\n------- sound initialization -------\n");
+
+	s_volume = Cvar_Get ("s_volume", "0.5", CVAR_ARCHIVE);
+	s_volumeVoice= Cvar_Get ("s_volumeVoice", "1.0", CVAR_ARCHIVE);
+	s_musicVolume = Cvar_Get ("s_musicvolume", "0.25", CVAR_ARCHIVE);
+	s_separation = Cvar_Get ("s_separation", "0.5", CVAR_ARCHIVE);
+	s_khz = Cvar_Get ("s_khz", "22", CVAR_ARCHIVE|CVAR_LATCH);
+	s_allowDynamicMusic = Cvar_Get ("s_allowDynamicMusic", "1", CVAR_ARCHIVE);
+	s_mixahead = Cvar_Get ("s_mixahead", "0.2", CVAR_ARCHIVE);
+
+	s_mixPreStep = Cvar_Get ("s_mixPreStep", "0.05", CVAR_ARCHIVE);
+	s_show = Cvar_Get ("s_show", "0", CVAR_CHEAT);
+	s_testsound = Cvar_Get ("s_testsound", "0", CVAR_CHEAT);
+	s_debugdynamic = Cvar_Get("s_debugdynamic","0", 0);
+	s_lip_threshold_1 = Cvar_Get("s_threshold1" , "0.3",0);
+	s_lip_threshold_2 = Cvar_Get("s_threshold2" , "4",0);
+	s_lip_threshold_3 = Cvar_Get("s_threshold3" , "6",0);
+	s_lip_threshold_4 = Cvar_Get("s_threshold4" , "8",0);
+
+	s_language = Cvar_Get("s_language","english",CVAR_ARCHIVE | CVAR_NORESTART);
+
+	MP3_InitCvars();
+
+	s_CPUType = Cvar_Get("sys_cpuid","",0);
+
+#if !(defined __linux__ && defined __i386__)
+#if	!id386
+#else
+	extern unsigned int uiMMXAvailable;
+	uiMMXAvailable = !!(s_CPUType->integer >= CPUID_INTEL_MMX);
+#endif
+#endif
+
+	cv = Cvar_Get ("s_initsound", "1", CVAR_ROM);
+	if ( !cv->integer ) {
+		s_soundStarted = 0;	// needed in case you set s_initsound to 0 midgame then snd_restart (div0 err otherwise later)
+		Com_Printf ("not initializing.\n");
+		Com_Printf("------------------------------------\n");
+		return;
+	}
+
+	Cmd_AddCommand("play", S_Play_f);
+	Cmd_AddCommand("music", S_Music_f);
+	Cmd_AddCommand("soundlist", S_SoundList_f);
+	Cmd_AddCommand("soundinfo", S_SoundInfo_f);
+	Cmd_AddCommand("soundstop", S_StopAllSounds);
+	Cmd_AddCommand("mp3_calcvols", S_MP3_CalcVols_f);
+	Cmd_AddCommand("s_dynamic", S_SetDynamicMusic_f);
+
+	cv = Cvar_Get("s_UseOpenAL" , "0",CVAR_ARCHIVE|CVAR_LATCH);
+	s_UseOpenAL = !!(cv->integer);
+
+
+	if (s_UseOpenAL)
+	{	
+		ALCDevice = alcOpenDevice((ALubyte*)"DirectSound3D");
+		if (!ALCDevice)
+			return;
+
+		//Create context(s)
+		ALCContext = alcCreateContext(ALCDevice, NULL);
+		if (!ALCContext)
+			return;
+
+		//Set active context
+		alcMakeContextCurrent(ALCContext);		
+		if (alcGetError(ALCDevice) != ALC_NO_ERROR)
+			return;
+
+		s_soundStarted = 1;
+		s_soundMuted = 1;
+		s_soundtime = 0;
+		s_paintedtime = 0;
+		s_rawend = 0;
+
+		S_StopAllSounds();
+
+		//S_SoundInfo_f();
+
+		// Set Listener attributes
+		alListenerfv(AL_POSITION,listenerPos);
+		alListenerfv(AL_VELOCITY,listenerVel);
+		alListenerfv(AL_ORIENTATION,listenerOri);
+
+		InitEAXManager();
+
+		memset(s_channels, 0, sizeof(s_channels));
+
+		s_numChannels = 0;
+
+		// Create as many AL Sources (up to Max) as possible
+		for (i = 0; i < MAX_CHANNELS; i++)
+		{
+			alGenSources(1, &s_channels[i].alSource); // &g_Sources[i]);
+			if (alGetError() != AL_NO_ERROR)
+			{
+				// Reached limit of sources
+				break;
+			}
+			alSourcef(s_channels[i].alSource, AL_REFERENCE_DISTANCE, DEFAULT_REF_DISTANCE);
+			if (alGetError() != AL_NO_ERROR)
+			{
+				break;
+			}
+
+			// Sources / Channels are not sending to any Slots (other than the Listener / Primary FX Slot)
+			s_channels[i].lSlotID = -1;
+
+			s_numChannels++;
+		}
+
+		// Generate AL Buffers for streaming audio playback (used for MP3s)
+		ch = s_channels + 1;
+		for (i = 1; i < s_numChannels; i++, ch++)
+		{
+			for (j = 0; j < NUM_STREAMING_BUFFERS; j++)
+			{
+				alGenBuffers(1, &(ch->buffers[j].BufferID));
+				ch->buffers[j].Status = UNQUEUED;
+				ch->buffers[j].Data = (char *)Z_Malloc(STREAMING_BUFFER_SIZE, TAG_SND_RAWDATA, qfalse);
+			}
+		}
+
+		// clear out the lip synching override array
+		memset(s_entityWavVol, 0, sizeof(s_entityWavVol));
+
+		// These aren't really relevant for Open AL, but for completeness ...
+		dma.speed = 22050;
+		dma.channels = 2;
+		dma.samplebits = 16;
+		dma.samples = 0;
+		dma.submission_chunk = 0;
+		dma.buffer = NULL;
+
+		// Clamp sound volumes between 0.0f and 1.0f (just in case they aren't already)
+		if (s_volume->value < 0.f)
+			s_volume->value = 0.f;
+		if (s_volume->value > 1.f)
+			s_volume->value = 1.f;
+
+		if (s_volumeVoice->value < 0.f)
+			s_volumeVoice->value = 0.f;
+		if (s_volumeVoice->value > 1.f)
+			s_volumeVoice->value = 1.f;
+
+		if (s_musicVolume->value < 0.f)
+			s_musicVolume->value = 0.f;
+		if (s_musicVolume->value > 1.f)
+			s_musicVolume->value = 1.f;
+		
+		// s_init could be called in game, if so there may be an .eal file 
+		// for this level
+
+		mapname = Cvar_VariableString( "mapname" );
+		EALFileInit(mapname);
+
+	}
+	else
+	{
+		r = SNDDMA_Init();
+
+		if ( r ) {
+			s_soundStarted = 1;
+			s_soundMuted = 1;
+	//		s_numSfx = 0;	// do NOT do this here now!!!
+
+			s_soundtime = 0;
+			s_paintedtime = 0;
+
+			S_StopAllSounds ();
+
+			//S_SoundInfo_f();
+		}
+	}
+
+//	Com_Printf("------------------------------------\n");
+
+//	Com_Printf("\n--- ambient sound initialization ---\n");
+
+	AS_Init();
+}
+
+// only called from snd_restart. QA request...
+//
+void S_ReloadAllUsedSounds(void)
+{
+	if (s_soundStarted && !s_soundMuted )
+	{
+		// new bit, reload all soundsthat are used on the current level...
+		//
+		for (int i=1 ; i < s_numSfx ; i++)	// start @ 1 to skip freeing default sound
+		{
+			sfx_t *sfx = &s_knownSfx[i];
+
+			if (!sfx->bInMemory && !sfx->bDefaultSound && sfx->iLastLevelUsedOn == RE_RegisterMedia_GetLevel()){
+				S_memoryLoad(sfx);
+			}
+		}
+	}
+}
+
+// =======================================================================
+// Shutdown sound engine
+// =======================================================================
+
+void S_Shutdown( void )
+{
+	ALCcontext	*ALCContext;
+	ALCdevice	*ALCDevice;
+	channel_t	*ch;
+	int			i, j;
+
+	if ( !s_soundStarted ) {
+		return;
+	}
+
+	S_FreeAllSFXMem();
+	S_UnCacheDynamicMusic();
+
+	if (s_UseOpenAL)
+	{
+		// Release all the AL Sources (including Music channel (Source 0))
+		for (i = 0; i < s_numChannels; i++)
+		{
+			alDeleteSources(1, &(s_channels[i].alSource));
+		}
+
+		// Release Streaming AL Buffers
+		ch = s_channels + 1;
+		for (i = 1; i < s_numChannels; i++, ch++)
+		{
+			for (j = 0; j < NUM_STREAMING_BUFFERS; j++)
+			{
+				alDeleteBuffers(1, &(ch->buffers[j].BufferID));
+				ch->buffers[j].BufferID = 0;
+				ch->buffers[j].Status = UNQUEUED;
+				if (ch->buffers[j].Data)
+				{
+					Z_Free(ch->buffers[j].Data);
+					ch->buffers[j].Data = NULL;
+				}
+			}
+		}
+
+		// Get active context
+		ALCContext = alcGetCurrentContext();
+		// Get device for active context
+		ALCDevice = alcGetContextsDevice(ALCContext);
+		// Release context(s)
+		alcDestroyContext(ALCContext);
+		// Close device
+		alcCloseDevice(ALCDevice);
+
+		ReleaseEAXManager();
+
+		s_numChannels = 0;
+
+	}
+	else
+	{
+		SNDDMA_Shutdown();
+	}
+
+	s_soundStarted = 0;
+
+	Cmd_RemoveCommand("play");
+	Cmd_RemoveCommand("music");
+	Cmd_RemoveCommand("stopsound");
+	Cmd_RemoveCommand("soundlist");
+	Cmd_RemoveCommand("soundinfo");
+	Cmd_RemoveCommand("soundstop");
+	Cmd_RemoveCommand("mp3_calcvols");
+	Cmd_RemoveCommand("s_dynamic");
+	AS_Free();
+}
+
+
+
+/*
+	Mutes / Unmutes all OpenAL sound
+*/
+void S_AL_MuteAllSounds(qboolean bMute)
+{
+     if (!s_soundStarted)
+          return;
+
+     if (!s_UseOpenAL)
+          return;
+
+     if (bMute)
+     {
+          alListenerf(AL_GAIN, 0.0f);
+     }
+     else
+     {
+          alListenerf(AL_GAIN, 1.0f);
+     }
+}
+
+
+
+
+
+// =======================================================================
+// Load a sound
+// =======================================================================
+/*
+================
+return a hash value for the sfx name
+================
+*/
+static long S_HashSFXName(const char *name) {
+	int		i;
+	long	hash;
+	char	letter;
+
+	hash = 0;
+	i = 0;
+	while (name[i] != '\0') {
+		letter = tolower(name[i]);
+		if (letter =='.') break;				// don't include extension
+		if (letter =='\\') letter = '/';		// damn path names
+		hash+=(long)(letter)*(i+119);
+		i++;
+	}
+	hash &= (LOOP_HASH-1);
+	return hash;
+}
+
+/*
+==================
+S_FindName
+
+Will allocate a new sfx if it isn't found
+==================
+*/
+sfx_t *S_FindName( const char *name ) {
+	int		i;
+	int		hash;
+
+	sfx_t	*sfx;
+
+	if (!name) {
+		Com_Error (ERR_FATAL, "S_FindName: NULL\n");
+	}
+	if (!name[0]) {
+		Com_Error (ERR_FATAL, "S_FindName: empty name\n");
+	}
+
+	if (strlen(name) >= MAX_QPATH) {
+		Com_Error (ERR_FATAL, "Sound name too long: %s", name);
+	}
+
+	char sSoundNameNoExt[MAX_QPATH];
+	COM_StripExtension(name,sSoundNameNoExt);
+
+	hash = S_HashSFXName(sSoundNameNoExt);
+
+	sfx = sfxHash[hash];
+	// see if already loaded
+	while (sfx) {
+		if (!Q_stricmp(sfx->sSoundName, sSoundNameNoExt) ) {
+			return sfx;
+		}
+		sfx = sfx->next;
+	}
+/*
+	// find a free sfx
+	for (i=0 ; i < s_numSfx ; i++) {
+		if (!s_knownSfx[i].soundName[0]) {
+			break;
+		}
+	}
+*/
+	i = s_numSfx;	//we don't clear the soundName after failed loads any more, so it'll always be the last entry
+		
+	if (s_numSfx == MAX_SFX) 
+	{
+		// ok, no sfx's free, but are there any with defaultSound set? (which the registering ent will never
+		//	see because he gets zero returned if it's default...)
+		//
+		for (i=0 ; i < s_numSfx ; i++) {
+			if (s_knownSfx[i].bDefaultSound) {
+				break;
+			}
+		}
+
+		if (i==s_numSfx)
+		{	  
+			// genuinely out of handles...
+
+			// if we ever reach this, let me know and I'll either boost the array or put in a map-used-on
+			//	reference to enable sfx_t recycling. TA codebase relies on being able to have structs for every sound
+			//	used anywhere, ever, all at once (though audio bit-buffer gets recycled). SOF1 used about 1900 distinct
+			//	events, so current MAX_SFX limit should do, or only need a small boost...	-ste
+			//
+
+			Com_Error (ERR_FATAL, "S_FindName: out of sfx_t");
+		}
+	}
+	else
+	{
+		s_numSfx++;
+	}
+	
+	sfx = &s_knownSfx[i];
+	memset (sfx, 0, sizeof(*sfx));
+	Q_strncpyz(sfx->sSoundName, sSoundNameNoExt, sizeof(sfx->sSoundName));
+	strlwr(sfx->sSoundName);//force it down low
+
+	sfx->next = sfxHash[hash];
+	sfxHash[hash] = sfx;
+
+	return sfx;
+}
+
+/*
+=================
+S_DefaultSound
+=================
+*/
+static void S_DefaultSound( sfx_t *sfx ) {
+	
+	int		i;
+
+	sfx->iSoundLengthInSamples	= 512;								// #samples, ie shorts
+	sfx->pSoundData				= (short *)	SND_malloc(512*2, sfx);	// ... so *2 for alloc bytes	
+	sfx->bInMemory				= true;
+	
+	for ( i=0 ; i < sfx->iSoundLengthInSamples ; i++ ) 
+	{
+		sfx->pSoundData[i] = i;
+	}
+}
+
+
+/*
+===================
+S_DisableSounds
+
+Disables sounds until the next S_BeginRegistration.
+This is called when the hunk is cleared and the sounds
+are no longer valid.
+===================
+*/
+void S_DisableSounds( void ) {
+	S_StopAllSounds();
+	s_soundMuted = qtrue;
+}
+
+/*
+=====================
+S_BeginRegistration
+
+=====================
+*/
+void S_BeginRegistration( void )
+{
+	char *mapname;
+
+	s_soundMuted = qfalse;		// we can play again
+
+	// Find name of level so we can load in the appropriate EAL file
+	if (s_UseOpenAL)
+	{
+		mapname = Cvar_VariableString( "mapname" );
+		EALFileInit(mapname);
+		// clear carry crap from previous map
+		for (int i = 0; i < EAX_MAX_FXSLOTS; i++)
+		{
+			s_FXSlotInfo[i].lEnvID = -1;
+		}
+	}
+
+	if (s_numSfx == 0) {
+		SND_setup();
+
+		s_numSfx = 0;
+		memset( s_knownSfx, 0, sizeof( s_knownSfx ) );
+		memset(sfxHash, 0, sizeof(sfx_t *)*LOOP_HASH);
+
+#ifdef _DEBUG
+		sfx_t *sfx = S_FindName( "***DEFAULT***" );
+		S_DefaultSound( sfx );
+#else
+		S_RegisterSound("sound/null.wav");
+#endif
+	}
+}
+
+
+static void EALFileInit(char *level)
+{
+	long		lRoom;
+	char		name[MAX_QPATH];
+	char		szEALFilename[MAX_QPATH];
+	int			i;
+
+	// If an EAL File is already unloaded, remove it
+	if (s_bEALFileLoaded)
+	{
+		UnloadEALFile();
+	}
+
+	// Reset variables
+	s_bInWater = false;
+
+	// Try and load an EAL file for the new level
+	COM_StripExtension(level, name);
+	Com_sprintf(szEALFilename, MAX_QPATH, "eagle/%s.eal", name);
+
+	s_bEALFileLoaded = LoadEALFile(szEALFilename);
+
+	if (!s_bEALFileLoaded)
+	{
+		Com_sprintf(szEALFilename, MAX_QPATH, "base/eagle/%s.eal", name);
+		s_bEALFileLoaded = LoadEALFile(szEALFilename);
+	}
+
+	if (s_bEALFileLoaded)
+	{
+		s_lLastEnvUpdate = timeGetTime();
+	}
+	else
+	{
+		// Mute reverbs if no EAL file is found
+		if ((s_bEAX)&&(s_eaxSet))
+		{
+			lRoom = -10000;
+			for (i = 0; i < s_NumFXSlots; i++)
+			{
+				s_eaxSet(&s_FXSlotInfo[i].FXSlotGuid, EAXREVERB_ROOM, NULL,
+					&lRoom, sizeof(long));
+			}
+		}
+	}
+}
+
+
+
+/*
+==================
+S_RegisterSound
+
+Creates a default buzz sound if the file can't be loaded
+==================
+*/
+sfxHandle_t	S_RegisterSound( const char *name) 
+{
+	sfx_t	*sfx;
+
+	if (!s_soundStarted) {
+		return 0;
+	}
+
+	if ( strlen( name ) >= MAX_QPATH ) {		
+		Com_Printf( S_COLOR_RED"Sound name exceeds MAX_QPATH - %s\n", name );
+		return 0;
+	}
+
+	sfx = S_FindName( name );
+
+	SND_TouchSFX(sfx);
+
+	if ( sfx->bDefaultSound )
+		return 0;
+
+	if (s_UseOpenAL)
+	{
+		if ((sfx->pSoundData) || (sfx->Buffer))
+			return sfx - s_knownSfx;
+	}
+	else
+	{
+		if ( sfx->pSoundData )
+		{
+			return sfx - s_knownSfx;
+		}
+	}
+
+	sfx->bInMemory = false;
+
+	S_memoryLoad(sfx);
+
+	if ( sfx->bDefaultSound ) {
+#ifndef FINAL_BUILD
+		Com_DPrintf( S_COLOR_YELLOW "WARNING: could not find %s - using default\n", sfx->sSoundName );
+#endif
+
+
+		return 0;
+	}
+
+	return sfx - s_knownSfx;
+}
+
+void S_memoryLoad(sfx_t	*sfx) 
+{
+	// load the sound file...
+	//
+	if ( !S_LoadSound( sfx ) ) 
+	{
+//		Com_Printf( S_COLOR_YELLOW "WARNING: couldn't load sound: %s\n", sfx->sSoundName );
+		sfx->bDefaultSound = true;
+	}
+	sfx->bInMemory = true;
+}
+
+
+
+//=============================================================================
+static qboolean S_CheckChannelStomp( int chan1, int chan2 )
+{
+	if (!s_UseOpenAL)
+	{
+		if ( chan1 == chan2 )
+		{
+			return qtrue;
+		}
+	}
+
+	if ( ( chan1 == CHAN_VOICE || chan1 == CHAN_VOICE_ATTEN || chan1 == CHAN_VOICE_GLOBAL  ) && ( chan2 == CHAN_VOICE || chan2 == CHAN_VOICE_ATTEN || chan2 == CHAN_VOICE_GLOBAL ) )
+	{
+		return qtrue;
+	}
+
+	return qfalse;
+}
+
+
+/*
+=================
+S_PickChannel
+=================
+*/
+// there were 2 versions of this, one for A3D and one normal, but the normal one wouldn't compile because
+//	it hadn't been updated for some time, so rather than risk anything weird/out of date, I just removed the 
+//	A3D lines from this version and deleted the other one. 
+//
+// If this really bothers you then feel free to play with it. -Ste.
+//
+channel_t *S_PickChannel(int entnum, int entchannel)
+{
+    int			ch_idx;
+	channel_t	*ch, *firstToDie;
+	qboolean	foundChan = qfalse;
+
+	if (s_UseOpenAL)
+		return S_OpenALPickChannel(entnum, entchannel);
+
+	if ( entchannel<0 ) {
+		Com_Error (ERR_DROP, "S_PickChannel: entchannel<0");
+	}
+
+	// Check for replacement sound, or find the best one to replace
+
+    firstToDie = &s_channels[0];
+
+	for ( int pass = 0; (pass < ((entchannel == CHAN_AUTO || entchannel == CHAN_LESS_ATTEN)?1:2)) && !foundChan; pass++ )
+	{
+		for (ch_idx = 0, ch = &s_channels[0]; ch_idx < MAX_CHANNELS ; ch_idx++, ch++ ) 
+		{
+			if ( entchannel == CHAN_AUTO || entchannel == CHAN_LESS_ATTEN || pass > 0 )
+			{//if we're on the second pass, just find the first open chan
+				if ( !ch->thesfx )
+				{//grab the first open channel
+					firstToDie = ch;
+					break;
+				}
+
+			}
+			else if ( ch->entnum == entnum && S_CheckChannelStomp( ch->entchannel, entchannel ) ) 
+			{
+				// always override sound from same entity
+				if ( s_show->integer == 1 && ch->thesfx ) {
+					Com_Printf( S_COLOR_YELLOW"...overrides %s\n", ch->thesfx->sSoundName );
+					ch->thesfx = 0;	//just to clear the next error msg
+				}
+				firstToDie = ch;
+				foundChan = qtrue;
+				break;
+			}
+
+			// don't let anything else override local player sounds
+			if ( ch->entnum == listener_number 	&& entnum != listener_number && ch->thesfx) {
+				continue;
+			}
+
+			// don't override loop sounds
+			if ( ch->loopSound ) {
+				continue;
+			}
+
+			if ( ch->startSample < firstToDie->startSample ) {
+				firstToDie = ch;
+			}
+		}
+	}
+
+	if ( s_show->integer == 1 && firstToDie->thesfx ) {
+		Com_Printf( S_COLOR_RED"***kicking %s\n", firstToDie->thesfx->sSoundName );
+	}
+
+	Channel_Clear(firstToDie);	// memset(firstToDie, 0, sizeof(*firstToDie));
+    
+	return firstToDie;
+}
+
+
+
+/*
+	For use with Open AL
+
+	Allows more than one sound of the same type to emanate from the same entity - sounds much better
+	on hardware this way esp. rapid fire modes of weapons!
+*/
+channel_t *S_OpenALPickChannel(int entnum, int entchannel)
+{
+    int			ch_idx;
+	channel_t	*ch, *ch_firstToDie;
+	bool	foundChan = false;
+	float	source_pos[3];
+
+	if ( entchannel < 0 ) 
+	{
+		Com_Error (ERR_DROP, "S_PickChannel: entchannel<0");
+	}
+
+	// Check for replacement sound, or find the best one to replace
+
+	ch_firstToDie = s_channels + 1;	// channel 0 is reserved for Music
+
+	for (ch_idx = 1, ch = s_channels + ch_idx; ch_idx < s_numChannels; ch_idx++, ch++)
+	{
+		if ( ch->entnum == entnum && S_CheckChannelStomp( ch->entchannel, entchannel ) ) 
+		{
+			// always override sound from same entity
+			if ( s_show->integer == 1 && ch->thesfx ) {
+				Com_Printf( S_COLOR_YELLOW"...overrides %s\n", ch->thesfx->sSoundName );
+				ch->thesfx = 0;	//just to clear the next error msg
+			}
+			ch_firstToDie = ch;
+			foundChan = true;
+			break;
+		}
+	}
+
+	if (!foundChan)
+	for (ch_idx = 1, ch = s_channels + ch_idx; ch_idx < s_numChannels; ch_idx++, ch++)
+	{
+		// See if the channel is free
+		if (!ch->thesfx)
+		{
+			ch_firstToDie = ch;
+			foundChan = true;
+			break;
+		}
+	}
+
+	if (!foundChan)
+	{
+		for (ch_idx = 1, ch = s_channels + ch_idx; ch_idx < s_numChannels; ch_idx++, ch++)
+		{
+			if (	(ch->entnum == entnum) && (ch->entchannel == entchannel) && (ch->entchannel != CHAN_AMBIENT)
+				 && (ch->entnum != listener_number) ) 
+			{
+				// Same entity and same type of sound effect (entchannel)
+				ch_firstToDie = ch;
+				foundChan = true;
+				break;
+			}
+		}
+	}
+
+	int longestDist;
+	int dist;
+
+	if (!foundChan)
+	{
+		// Find sound effect furthest from listener
+		ch = s_channels + 1;
+
+		if (ch->fixed_origin)
+		{
+			// Convert to Open AL co-ordinates
+			source_pos[0] = ch->origin[0];
+			source_pos[1] = ch->origin[2];
+			source_pos[2] = -ch->origin[1];
+
+			longestDist = ((listener_pos[0] - source_pos[0]) * (listener_pos[0] - source_pos[0])) +
+						  ((listener_pos[1] - source_pos[1]) * (listener_pos[1] - source_pos[1])) +
+						  ((listener_pos[2] - source_pos[2]) * (listener_pos[2] - source_pos[2]));
+		}
+		else
+		{
+			if (ch->entnum == listener_number)
+				longestDist = 0;
+			else
+			{
+				if (ch->bLooping)
+				{
+					// Convert to Open AL co-ordinates
+					source_pos[0] = loopSounds[ch->entnum].origin[0];
+					source_pos[1] = loopSounds[ch->entnum].origin[2];
+					source_pos[2] = -loopSounds[ch->entnum].origin[1];
+				}
+				else
+				{
+					// Convert to Open AL co-ordinates
+					source_pos[0] = s_entityPosition[ch->entnum][0];
+					source_pos[1] = s_entityPosition[ch->entnum][2];
+					source_pos[2] = -s_entityPosition[ch->entnum][1];
+				}
+
+				longestDist = ((listener_pos[0] - source_pos[0]) * (listener_pos[0] - source_pos[0])) +
+							  ((listener_pos[1] - source_pos[1]) * (listener_pos[1] - source_pos[1])) +
+							  ((listener_pos[2] - source_pos[2]) * (listener_pos[2] - source_pos[2]));
+			}
+		}
+
+		for (ch_idx = 2, ch = s_channels + ch_idx; ch_idx < s_numChannels; ch_idx++, ch++)
+		{
+			if (ch->fixed_origin)
+			{
+				// Convert to Open AL co-ordinates
+				source_pos[0] = ch->origin[0];
+				source_pos[1] = ch->origin[2];
+				source_pos[2] = -ch->origin[1];
+			
+				dist = ((listener_pos[0] - source_pos[0]) * (listener_pos[0] - source_pos[0])) +
+					   ((listener_pos[1] - source_pos[1]) * (listener_pos[1] - source_pos[1])) +
+					   ((listener_pos[2] - source_pos[2]) * (listener_pos[2] - source_pos[2]));
+			}
+			else
+			{
+				if (ch->entnum == listener_number)
+					dist = 0;
+				else
+				{
+					if (ch->bLooping)
+					{
+						// Convert to Open AL co-ordinates
+						source_pos[0] = loopSounds[ch->entnum].origin[0];
+						source_pos[1] = loopSounds[ch->entnum].origin[2];
+						source_pos[2] = -loopSounds[ch->entnum].origin[1];
+					}
+					else
+					{
+						// Convert to Open AL co-ordinates
+						source_pos[0] = s_entityPosition[ch->entnum][0];
+						source_pos[1] = s_entityPosition[ch->entnum][2];
+						source_pos[2] = -s_entityPosition[ch->entnum][1];
+					}
+
+					dist = ((listener_pos[0] - source_pos[0]) * (listener_pos[0] - source_pos[0])) +
+					       ((listener_pos[1] - source_pos[1]) * (listener_pos[1] - source_pos[1])) +
+						   ((listener_pos[2] - source_pos[2]) * (listener_pos[2] - source_pos[2]));
+				}
+			}
+
+			if (dist > longestDist)
+			{
+				longestDist = dist;
+				ch_firstToDie = ch;
+			}
+		}
+	}
+
+	if (ch_firstToDie->bPlaying)
+	{
+		if (s_show->integer == 1 && ch_firstToDie->thesfx ) 
+		{
+			Com_Printf(S_COLOR_RED"***kicking %s\n", ch_firstToDie->thesfx->sSoundName );
+		}
+
+		// Stop sound
+		alSourceStop(ch_firstToDie->alSource);
+		ch_firstToDie->bPlaying = false;
+	}
+
+	// Reset channel variables
+	memset(&ch_firstToDie->MP3StreamHeader, 0, sizeof(MP3STREAM));
+	ch_firstToDie->bLooping = false;
+	ch_firstToDie->bProcessed = false;
+	ch_firstToDie->bStreaming = false;
+	
+    return ch_firstToDie;
+}
+
+
+/*
+=================
+S_SpatializeOrigin
+
+Used for spatializing s_channels
+=================
+*/
+static void S_SpatializeOrigin (const vec3_t origin, float master_vol, int *left_vol, int *right_vol, soundChannel_t channel)
+{
+    vec_t		dot;
+    vec_t		dist;
+    vec_t		lscale, rscale, scale;
+    vec3_t		source_vec;
+	float		dist_mult = SOUND_ATTENUATE;
+
+	// calculate stereo seperation and distance attenuation
+	VectorSubtract(origin, listener_origin, source_vec);
+
+	dist = VectorNormalize(source_vec);
+	if ( channel == CHAN_VOICE )
+	{
+		dist -= SOUND_FULLVOLUME * 3.0f;
+//		dist_mult = VOICE_ATTENUATE;	// tweak added (this fixes an NPC dialogue "in your ears" bug, but we're not sure if it'll make a bunch of others fade too early. Too close to shipping...)
+	}
+	else if ( channel == CHAN_LESS_ATTEN )
+	{
+		dist -= SOUND_FULLVOLUME * 5.0f; // maybe is too large
+	}
+	else if ( channel == CHAN_VOICE_ATTEN )
+	{
+		dist -= SOUND_FULLVOLUME * 1.35f; // used to be 0.15f, dropped off too sharply - dmv
+		dist_mult = VOICE_ATTENUATE;
+	}
+	else if ( channel == CHAN_VOICE_GLOBAL )
+	{
+		dist = -1;
+	}
+	else	// use normal attenuation.
+	{
+		dist -= SOUND_FULLVOLUME;
+	}
+	
+	if (dist < 0)
+	{
+		dist = 0;			// close enough to be at full volume
+	}
+	dist *= dist_mult;		// different attenuation levels
+
+	dot = -DotProduct(listener_axis[1], source_vec);
+
+	if (dma.channels == 1)	// || !dist_mult)
+	{ // no attenuation = no spatialization
+		rscale = SOUND_FMAXVOL;
+		lscale = SOUND_FMAXVOL;
+	}
+	else
+	{
+		//rscale = 0.5 * (1.0 + dot);
+		//lscale = 0.5 * (1.0 - dot);
+		rscale = s_separation->value + ( 1.0f - s_separation->value ) * dot;
+		lscale = s_separation->value - ( 1.0f - s_separation->value ) * dot;
+		if ( rscale < 0 ) 
+		{
+			rscale = 0;
+		}
+		if ( lscale < 0 ) 
+		{
+			lscale = 0;
+		}
+	}
+
+	// add in distance effect
+	scale = (1.0f - dist) * rscale;
+	*right_vol = (int) (master_vol * scale);
+	if (*right_vol < 0)
+	{
+		*right_vol = 0;
+	}
+
+	scale = (1.0f - dist) * lscale;
+	*left_vol = (int) (master_vol * scale);
+	if (*left_vol < 0)
+	{
+		*left_vol = 0;
+	}
+}
+
+
+// =======================================================================
+// Start a sound effect
+// =======================================================================
+
+/*
+====================
+S_StartAmbientSound
+
+Starts an ambient, 'one-shot" sound.
+====================
+*/
+
+void S_StartAmbientSound( const vec3_t origin, int entityNum, unsigned char volume, sfxHandle_t sfxHandle )
+{
+	channel_t	*ch;
+	/*const*/ sfx_t *sfx;
+
+	if ( !s_soundStarted || s_soundMuted ) {
+		return;
+	}
+	if ( !origin && ( entityNum < 0 || entityNum > MAX_GENTITIES ) )
+		Com_Error( ERR_DROP, "S_StartAmbientSound: bad entitynum %i", entityNum );
+
+	if ( sfxHandle < 0 || sfxHandle >= s_numSfx )
+		Com_Error( ERR_DROP, "S_StartAmbientSound: handle %i out of range", sfxHandle );
+
+	sfx = &s_knownSfx[ sfxHandle ];
+	if (sfx->bInMemory == qfalse){
+		S_memoryLoad(sfx);
+	}	
+	SND_TouchSFX(sfx);
+
+	if (s_UseOpenAL)
+	{
+		if (volume==0)
+			return;
+	}
+
+	if ( s_show->integer == 1 ) {
+		Com_Printf( "%i : %s on (%d) Ambient\n", s_paintedtime, sfx->sSoundName, entityNum );
+	}
+
+	// pick a channel to play on
+	ch = S_PickChannel( entityNum, CHAN_AMBIENT );
+	if (!ch) {
+		return;
+	}
+	
+	if (origin) 
+	{
+		VectorCopy (origin, ch->origin);
+		ch->fixed_origin = qtrue;
+	} 
+	else 
+	{
+		ch->fixed_origin = qfalse;
+	}
+
+	ch->master_vol = volume;
+	ch->entnum = entityNum;
+	ch->entchannel = CHAN_AMBIENT;
+	ch->thesfx = sfx;
+	ch->startSample = START_SAMPLE_IMMEDIATE;
+
+	ch->leftvol = ch->master_vol;		// these will get calced at next spatialize
+	ch->rightvol = ch->master_vol;		// unless the game isn't running
+
+	if (sfx->pMP3StreamHeader)
+	{
+		memcpy(&ch->MP3StreamHeader,sfx->pMP3StreamHeader,	sizeof(ch->MP3StreamHeader));
+		//ch->iMP3SlidingDecodeWritePos = 0; // These will be zero from the memset in S_PickChannel(), but keep them here for reference...
+		//ch->iMP3SlidingDecodeWindowPos= 0; //
+	}
+	else
+	{
+		memset(&ch->MP3StreamHeader,0,						sizeof(ch->MP3StreamHeader));
+	}
+}
+
+/*
+====================
+S_StartSound
+
+Validates the parms and ques the sound up
+if pos is NULL, the sound will be dynamically sourced from the entity
+Entchannel 0 will never override a playing sound
+====================
+*/
+void S_StartSound(const vec3_t origin, int entityNum, soundChannel_t entchannel, sfxHandle_t sfxHandle ) 
+{
+	int i;
+	channel_t	*ch;
+	/*const*/ sfx_t *sfx;
+
+	if ( !s_soundStarted || s_soundMuted ) {
+		return;
+	}
+
+	if ( !origin && ( entityNum < 0 || entityNum > MAX_GENTITIES ) ) {
+		Com_Error( ERR_DROP, "S_StartSound: bad entitynum %i", entityNum );
+	}
+
+	if ( sfxHandle < 0 || sfxHandle >= s_numSfx ) {
+		Com_Error( ERR_DROP, "S_StartSound: handle %i out of range", sfxHandle );
+	}
+
+	sfx = &s_knownSfx[ sfxHandle ];
+	if (sfx->bInMemory == qfalse){
+		S_memoryLoad(sfx);
+	}
+	SND_TouchSFX(sfx);
+
+	if ( s_show->integer == 1 ) {
+		Com_Printf( "%i : %s for ent %d, chan=%d\n", s_paintedtime, sfx->sSoundName, entityNum, entchannel );
+	}
+
+	if (s_UseOpenAL)
+	{
+		if (entchannel == CHAN_VOICE)
+		{
+			// Make howlers and sand_creature VOICE effects use the normal fall-off (they will still be affected
+			// by the Voice Volume)
+			if ((strstr(sfx->sSoundName, "sand_creature")!=NULL) || (strstr(sfx->sSoundName, "howler")!=NULL))
+			{
+				entchannel = CHAN_VOICE_ATTEN;
+			}
+		}
+		if (entchannel == CHAN_WEAPON)
+		{
+			// Check if we are playing a 'charging' sound, if so, stop it now ..
+			ch = s_channels + 1;
+			for (i = 1; i < s_numChannels; i++, ch++)
+			{
+				if ((ch->entnum == entityNum) && (ch->entchannel == CHAN_WEAPON) && (ch->thesfx) && (strstr(ch->thesfx->sSoundName, "altcharge") != NULL))
+				{
+					// Stop this sound
+					alSourceStop(ch->alSource);
+					alSourcei(ch->alSource, AL_BUFFER, NULL);
+					ch->bPlaying = false;
+					ch->thesfx = NULL;
+					break;
+				}
+			}
+		}
+		else
+		{
+			ch = s_channels + 1;
+			for (i = 1; i < s_numChannels; i++, ch++)
+			{
+				if ((ch->entnum == entityNum) && (ch->thesfx) && (strstr(ch->thesfx->sSoundName, "falling") != NULL))
+				{
+					// Stop this sound
+					alSourceStop(ch->alSource);
+					alSourcei(ch->alSource, AL_BUFFER, NULL);
+					ch->bPlaying = false;
+					ch->thesfx = NULL;
+					break;
+				}
+			}
+		}
+	}
+
+
+	// pick a channel to play on
+	
+	ch = S_PickChannel( entityNum, entchannel );
+	if (!ch) {
+		return;
+	}
+
+	if (origin) {
+		VectorCopy (origin, ch->origin);
+		ch->fixed_origin = qtrue;
+	} else {
+		ch->fixed_origin = qfalse;
+	}
+
+	ch->master_vol = SOUND_MAXVOL;	//FIXME: Um.. control?
+	ch->entnum = entityNum;
+	ch->entchannel = entchannel;
+	ch->thesfx = sfx;
+	ch->startSample = START_SAMPLE_IMMEDIATE;
+
+	ch->leftvol = ch->master_vol;		// these will get calced at next spatialize
+	ch->rightvol = ch->master_vol;		// unless the game isn't running
+
+	if (entchannel < CHAN_AMBIENT && entityNum == listener_number) {	//only do it for body sounds not local sounds
+		ch->master_vol = SOUND_MAXVOL * SOUND_FMAXVOL;	//this won't be attenuated so let it scale down
+	}
+	if ( entchannel == CHAN_VOICE || entchannel == CHAN_VOICE_ATTEN || entchannel == CHAN_VOICE_GLOBAL ) 
+	{
+		s_entityWavVol[ ch->entnum ] = -1;	//we've started the sound but it's silent for now
+	}
+
+	if (sfx->pMP3StreamHeader)
+	{
+		memcpy(&ch->MP3StreamHeader,sfx->pMP3StreamHeader,	sizeof(ch->MP3StreamHeader));
+		//ch->iMP3SlidingDecodeWritePos = 0; // These will be zero from the memset in S_PickChannel(), but keep them here for reference...
+		//ch->iMP3SlidingDecodeWindowPos= 0; //
+	}
+	else
+	{
+		memset(&ch->MP3StreamHeader,0,						sizeof(ch->MP3StreamHeader));
+	}
+}
+
+/*
+==================
+S_StartLocalSound
+==================
+*/
+void S_StartLocalSound( sfxHandle_t sfxHandle, int channelNum ) {
+	if ( !s_soundStarted || s_soundMuted ) {
+		return;
+	}
+
+	if ( sfxHandle < 0 || sfxHandle >= s_numSfx ) {
+		Com_Error( ERR_DROP, "S_StartLocalSound: handle %i out of range", sfxHandle );
+	}
+
+	S_StartSound (NULL, listener_number, (soundChannel_t)channelNum, sfxHandle );
+}
+
+
+/*
+==================
+S_StartLocalLoopingSound
+==================
+*/
+void S_StartLocalLoopingSound( sfxHandle_t sfxHandle) {
+	vec3_t nullVec = {0,0,0};
+
+	if ( !s_soundStarted || s_soundMuted ) {
+		return;
+	}
+
+	if ( sfxHandle < 0 || sfxHandle >= s_numSfx ) {
+		Com_Error( ERR_DROP, "S_StartLocalLoopingSound: handle %i out of range", sfxHandle );
+	}
+
+	S_AddLoopingSound( listener_number, nullVec, nullVec, sfxHandle );
+
+}
+
+// returns length in milliseconds of supplied sound effect...  (else 0 for bad handle now)
+//
+float S_GetSampleLengthInMilliSeconds( sfxHandle_t sfxHandle)
+{
+	sfx_t *sfx;
+
+	if (!s_soundStarted)
+	{	//we have no sound, so let's just make a reasonable guess
+		return 512 * 1000;
+	}
+
+	if ( sfxHandle < 0 || sfxHandle >= s_numSfx )
+		return 0.0f;
+
+	sfx = &s_knownSfx[ sfxHandle ];
+
+	float f = (float)sfx->iSoundLengthInSamples / (float)dma.speed;
+
+	return (f * 1000);
+}
+
+
+/*
+==================
+S_ClearSoundBuffer
+
+If we are about to perform file access, clear the buffer
+so sound doesn't stutter.
+==================
+*/
+void S_ClearSoundBuffer( void ) {
+	int		clear;
+		
+	if ( !s_soundStarted || s_soundMuted ) {
+		return;
+	}
+#if 0	//this causes scripts to freak when the sounds get cut...
+	// clear all the sounds so they don't
+	// start back up after the load finishes
+	memset( s_channels, 0, sizeof( s_channels ) );
+	// clear out the lip synching override array
+	memset(s_entityWavVol, 0,sizeof(s_entityWavVol));
+#endif
+	s_rawend = 0;
+
+	if (!s_UseOpenAL)
+	{
+		if (dma.samplebits == 8)
+			clear = 0x80;
+		else
+			clear = 0;
+
+		SNDDMA_BeginPainting ();
+		if (dma.buffer)
+			memset(dma.buffer, clear, dma.samples * dma.samplebits/8);
+		SNDDMA_Submit ();
+	}
+	else
+	{
+		s_paintedtime = 0;
+		s_soundtime = 0;
+	}
+}
+
+
+// kinda kludgy way to stop a special-use sfx_t playing...
+//
+void S_CIN_StopSound(sfxHandle_t sfxHandle)
+{
+	if ( sfxHandle < 0 || sfxHandle >= s_numSfx ) {
+		Com_Error( ERR_DROP, "S_CIN_StopSound: handle %i out of range", sfxHandle );
+	}
+
+	sfx_t *sfx = &s_knownSfx[ sfxHandle ];
+	channel_t *ch = s_channels;
+	int i;
+
+	for ( i = 0; i < MAX_CHANNELS ; i++, ch++ ) 
+	{
+		if ( !ch->thesfx || (ch->leftvol<0.25 && ch->rightvol<0.25 )) {
+			continue;
+		}
+		if (ch->thesfx == sfx)
+		{
+			if (s_UseOpenAL)
+			{
+				alSourceStop(s_channels[i].alSource);
+			}
+			SND_FreeSFXMem(ch->thesfx);	// heh, may as well...
+			ch->thesfx = NULL;
+			memset(&ch->MP3StreamHeader, 0, sizeof(MP3STREAM));
+			ch->bLooping = false;
+			ch->bProcessed = false;
+			ch->bPlaying = false;
+			ch->bStreaming = false;
+			break;
+		}
+	}
+}
+
+
+/*
+==================
+S_StopAllSounds
+==================
+*/
+void S_StopSounds(void)
+{
+	int i; //, j;
+	channel_t *ch;
+
+	if ( !s_soundStarted ) {
+		return;
+	}
+
+	// stop looping sounds
+	S_ClearLoopingSounds();
+
+	// clear all the s_channels
+	if (s_UseOpenAL)
+	{
+		ch = s_channels;
+		for (i = 0; i < s_numChannels; i++, ch++)
+		{
+			alSourceStop(s_channels[i].alSource);
+			alSourcei(s_channels[i].alSource, AL_BUFFER, NULL);
+			ch->thesfx = NULL;
+			memset(&ch->MP3StreamHeader, 0, sizeof(MP3STREAM));
+			ch->bLooping = false;
+			ch->bProcessed = false;
+			ch->bPlaying = false;
+			ch->bStreaming = false;
+		}
+	}
+	else
+	{
+		memset(s_channels, 0, sizeof(s_channels));
+	}
+
+	// clear out the lip synching override array
+	memset(s_entityWavVol, 0,sizeof(s_entityWavVol));
+
+	S_ClearSoundBuffer ();
+}
+
+/*
+==================
+S_StopAllSounds
+ and music
+==================
+*/
+void S_StopAllSounds(void) {
+	if ( !s_soundStarted ) {
+		return;
+	}
+	// stop the background music
+	S_StopBackgroundTrack();
+
+	S_StopSounds();
+}
+
+/*
+==============================================================
+
+continuous looping sounds are added each frame
+
+==============================================================
+*/
+
+/*
+==================
+S_ClearLoopingSounds
+
+==================
+*/
+void S_ClearLoopingSounds( void )
+{
+	int i;
+
+	if (s_UseOpenAL)
+	{
+		for (i = 0; i < MAX_LOOP_SOUNDS; i++)
+			loopSounds[i].bProcessed = false;
+	}
+	numLoopSounds = 0;
+
+}
+
+/*
+==================
+S_AddLoopingSound
+
+Called during entity generation for a frame
+Include velocity in case I get around to doing doppler...
+==================
+*/
+void S_AddLoopingSound( int entityNum, const vec3_t origin, const vec3_t velocity, sfxHandle_t sfxHandle, soundChannel_t chan ) {
+	/*const*/ sfx_t *sfx;
+
+  	if ( !s_soundStarted || s_soundMuted ) {
+		return;
+	}
+	if ( numLoopSounds >= MAX_LOOP_SOUNDS ) {
+		//assert(numLoopSounds<MAX_LOOP_SOUNDS);
+#ifndef FINAL_BUILD
+		Com_Printf( "S_AddLoopingSound: MAX_LOOP_SOUNDS\n");
+#endif
+		return;
+	}
+
+	if ( sfxHandle < 0 || sfxHandle >= s_numSfx ) {
+		Com_Error( ERR_DROP, "S_AddLoopingSound: handle %i out of range", sfxHandle );
+	}
+
+	sfx = &s_knownSfx[ sfxHandle ];
+	if (sfx->bInMemory == qfalse){
+		S_memoryLoad(sfx);
+	}
+	SND_TouchSFX(sfx);
+
+	if ( !sfx->iSoundLengthInSamples ) {
+		Com_Error( ERR_DROP, "%s has length 0", sfx->sSoundName );
+	}
+	assert(!sfx->pMP3StreamHeader);
+	VectorCopy( origin, loopSounds[numLoopSounds].origin );
+//	VectorCopy( velocity, loopSounds[numLoopSounds].velocity );
+	loopSounds[numLoopSounds].sfx = sfx;
+	loopSounds[numLoopSounds].volume = SOUND_MAXVOL;
+	loopSounds[numLoopSounds].entnum = entityNum;
+	loopSounds[numLoopSounds].entchan = chan;
+	numLoopSounds++;
+}
+
+
+/*
+==================
+S_AddAmbientLoopingSound
+==================
+*/
+void S_AddAmbientLoopingSound( const vec3_t origin, unsigned char volume, sfxHandle_t sfxHandle ) 
+{
+	/*const*/ sfx_t *sfx;
+
+	if ( !s_soundStarted || s_soundMuted ) {
+		return;
+	}
+	if ( numLoopSounds >= MAX_LOOP_SOUNDS ) {
+		return;
+	}
+
+	if (s_UseOpenAL)
+	{
+		if (volume == 0)
+			return;
+	}
+
+	if ( sfxHandle < 0 || sfxHandle >= s_numSfx ) {
+		Com_Error( ERR_DROP, "S_StartSound: handle %i out of range", sfxHandle );
+	}
+
+	sfx = &s_knownSfx[ sfxHandle ];
+	if (sfx->bInMemory == qfalse){
+		S_memoryLoad(sfx);
+	}
+	SND_TouchSFX(sfx);
+
+	if ( !sfx->iSoundLengthInSamples ) {
+		Com_Error( ERR_DROP, "%s has length 0", sfx->sSoundName );
+	}
+	VectorCopy( origin, loopSounds[numLoopSounds].origin );
+	loopSounds[numLoopSounds].sfx = sfx;
+	assert(!sfx->pMP3StreamHeader);
+	
+	//TODO: Calculate the distance falloff
+	loopSounds[numLoopSounds].volume = volume;
+	numLoopSounds++;
+}
+
+
+
+/*
+==================
+S_AddLoopSounds
+
+Spatialize all of the looping sounds.
+All sounds are on the same cycle, so any duplicates can just
+sum up the channel multipliers.
+==================
+*/
+void S_AddLoopSounds (void) 
+{
+	int			i, j;
+	int			left, right, left_total, right_total;
+	channel_t	*ch;
+	loopSound_t	*loop, *loop2;
+	static int	loopFrame;
+
+	loopFrame++;
+	for ( i = 0 ; i < numLoopSounds ; i++) {
+		loop = &loopSounds[i];
+		if ( loop->mergeFrame == loopFrame ) {
+			continue;	// already merged into an earlier sound
+		}
+
+		// find the total contribution of all sounds of this type
+		left_total = right_total = 0;
+
+		for ( j = i ; j < numLoopSounds ; j++) {
+			loop2 = &loopSounds[j];
+			if ( loop2->sfx != loop->sfx ) {
+				continue;
+			}
+			loop2->mergeFrame = loopFrame;	// don't check this again later
+
+			S_SpatializeOrigin( loop2->origin, loop2->volume, &left, &right, loop2->entchan);
+
+			left_total += left;
+			right_total += right;
+		}
+
+		if (left_total == 0 && right_total == 0)
+			continue;		// not audible
+
+		// allocate a channel
+		ch = S_PickChannel(0, 0);
+		if (!ch)
+			return;
+
+		if (left_total > SOUND_MAXVOL)
+			left_total = SOUND_MAXVOL;
+		if (right_total > SOUND_MAXVOL)
+			right_total = SOUND_MAXVOL;
+		ch->leftvol = left_total;
+		ch->rightvol = right_total;
+		ch->loopSound = qtrue;	// remove next frame
+		ch->thesfx = loop->sfx;
+
+		// you cannot use MP3 files here because they offer only streaming access, not random
+		//
+		if (loop->sfx->pMP3StreamHeader)
+		{				
+			Com_Error( ERR_DROP, "S_AddLoopSounds(): Cannot use streamed MP3 files here for random access (%s)\n",loop->sfx->sSoundName );
+		}
+		else
+		{
+			memset(&ch->MP3StreamHeader,0,						sizeof(ch->MP3StreamHeader));
+		}
+	}
+}
+
+//=============================================================================
+
+/*
+=================
+S_ByteSwapRawSamples
+
+If raw data has been loaded in little endien binary form, this must be done.
+If raw data was calculated, as with ADPCM, this should not be called.
+=================
+*/
+static void S_ByteSwapRawSamples( int samples, int width, int s_channels, const byte *data ) {
+	int		i;
+
+	if ( width != 2 ) {
+		return;
+	}
+	if ( LittleShort( 256 ) == 256 ) {
+		return;
+	}
+
+	if ( s_channels == 2 ) {
+		samples <<= 1;
+	}
+	for ( i = 0 ; i < samples ; i++ ) {
+		((short *)data)[i] = LittleShort( ((short *)data)[i] );
+	}
+}
+
+
+portable_samplepair_t *S_GetRawSamplePointer() {
+	return s_rawsamples;
+}
+
+
+/*
+============
+S_RawSamples
+
+Music streaming
+============
+*/
+void S_RawSamples( int samples, int rate, int width, int s_channels, const byte *data, float volume, qboolean bFirstOrOnlyUpdateThisFrame )
+{
+	int		i;
+	int		src, dst;
+	float	scale;
+	int		intVolume;
+
+	if ( !s_soundStarted || s_soundMuted ) {
+		return;
+	}
+
+	intVolume = 256 * volume;
+
+	if ( s_rawend < s_soundtime ) {
+		Com_DPrintf( "S_RawSamples: resetting minimum: %i < %i\n", s_rawend, s_soundtime );
+		s_rawend = s_soundtime;
+	}
+
+	scale = (float)rate / dma.speed;
+
+//Com_Printf ("%i < %i < %i\n", s_soundtime, s_paintedtime, s_rawend);
+	if (s_channels == 2 && width == 2)
+	{
+		if (scale == 1.0)
+		{	// optimized case
+			if (bFirstOrOnlyUpdateThisFrame)
+			{
+				for (i=0 ; i<samples ; i++)
+				{
+					dst = s_rawend&(MAX_RAW_SAMPLES-1);
+					s_rawend++;
+					s_rawsamples[dst].left = ((short *)data)[i*2] * intVolume;
+					s_rawsamples[dst].right = ((short *)data)[i*2+1] * intVolume;
+				}
+			}
+			else
+			{
+				for (i=0 ; i<samples ; i++)
+				{
+					dst = s_rawend&(MAX_RAW_SAMPLES-1);
+					s_rawend++;
+					s_rawsamples[dst].left  += ((short *)data)[i*2] * intVolume;
+					s_rawsamples[dst].right += ((short *)data)[i*2+1] * intVolume;
+				}
+			}
+		}
+		else
+		{
+			if (bFirstOrOnlyUpdateThisFrame)
+			{
+				for (i=0 ; ; i++)
+				{
+					src = i*scale;
+					if (src >= samples)
+						break;
+					dst = s_rawend&(MAX_RAW_SAMPLES-1);
+					s_rawend++;
+					s_rawsamples[dst].left = ((short *)data)[src*2] * intVolume;
+					s_rawsamples[dst].right = ((short *)data)[src*2+1] * intVolume;
+				}
+			}
+			else
+			{
+				for (i=0 ; ; i++)
+				{
+					src = i*scale;
+					if (src >= samples)
+						break;
+					dst = s_rawend&(MAX_RAW_SAMPLES-1);
+					s_rawend++;
+					s_rawsamples[dst].left  += ((short *)data)[src*2] * intVolume;
+					s_rawsamples[dst].right += ((short *)data)[src*2+1] * intVolume;
+				}
+			}
+		}
+	}
+	else if (s_channels == 1 && width == 2)
+	{
+		if (bFirstOrOnlyUpdateThisFrame)
+		{
+			for (i=0 ; ; i++)
+			{
+				src = i*scale;
+				if (src >= samples)
+					break;
+				dst = s_rawend&(MAX_RAW_SAMPLES-1);
+				s_rawend++;
+				s_rawsamples[dst].left = ((short *)data)[src] * intVolume;
+				s_rawsamples[dst].right = ((short *)data)[src] * intVolume;
+			}
+		}
+		else
+		{
+			for (i=0 ; ; i++)
+			{
+				src = i*scale;
+				if (src >= samples)
+					break;
+				dst = s_rawend&(MAX_RAW_SAMPLES-1);
+				s_rawend++;
+				s_rawsamples[dst].left  += ((short *)data)[src] * intVolume;
+				s_rawsamples[dst].right += ((short *)data)[src] * intVolume;
+			}
+		}
+	}
+	else if (s_channels == 2 && width == 1)
+	{
+		intVolume *= 256;
+
+		if (bFirstOrOnlyUpdateThisFrame)
+		{
+			for (i=0 ; ; i++)
+			{
+				src = i*scale;
+				if (src >= samples)
+					break;
+				dst = s_rawend&(MAX_RAW_SAMPLES-1);
+				s_rawend++;
+				s_rawsamples[dst].left = ((char *)data)[src*2] * intVolume;
+				s_rawsamples[dst].right = ((char *)data)[src*2+1] * intVolume;
+			}
+		}
+		else
+		{
+			for (i=0 ; ; i++)
+			{
+				src = i*scale;
+				if (src >= samples)
+					break;
+				dst = s_rawend&(MAX_RAW_SAMPLES-1);
+				s_rawend++;
+				s_rawsamples[dst].left  += ((char *)data)[src*2] * intVolume;
+				s_rawsamples[dst].right += ((char *)data)[src*2+1] * intVolume;
+			}
+		}
+	}
+	else if (s_channels == 1 && width == 1)
+	{
+		intVolume *= 256;
+
+		if (bFirstOrOnlyUpdateThisFrame)
+		{
+			for (i=0 ; ; i++)
+			{
+				src = i*scale;
+				if (src >= samples)
+					break;
+				dst = s_rawend&(MAX_RAW_SAMPLES-1);
+				s_rawend++;
+				s_rawsamples[dst].left = (((byte *)data)[src]-128) * intVolume;
+				s_rawsamples[dst].right = (((byte *)data)[src]-128) * intVolume;
+			}
+		}
+		else
+		{
+			for (i=0 ; ; i++)
+			{
+				src = i*scale;
+				if (src >= samples)
+					break;
+				dst = s_rawend&(MAX_RAW_SAMPLES-1);
+				s_rawend++;
+				s_rawsamples[dst].left  += (((byte *)data)[src]-128) * intVolume;
+				s_rawsamples[dst].right += (((byte *)data)[src]-128) * intVolume;
+			}
+		}
+	}
+
+	if ( s_rawend > s_soundtime + MAX_RAW_SAMPLES ) {
+		Com_DPrintf( "S_RawSamples: overflowed %i > %i\n", s_rawend, s_soundtime );
+	}
+}
+
+//=============================================================================
+
+/*
+=====================
+S_UpdateEntityPosition
+
+let the sound system know where an entity currently is
+======================
+*/
+void S_UpdateEntityPosition( int entityNum, const vec3_t origin )
+{
+	ALfloat pos[3];
+	channel_t *ch;
+	int i;
+
+	if ( entityNum < 0 || entityNum > MAX_GENTITIES ) {
+		Com_Error( ERR_DROP, "S_UpdateEntityPosition: bad entitynum %i", entityNum );
+	}
+
+	if (s_UseOpenAL)
+	{
+		if (entityNum == 0)
+			return;
+
+		ch = s_channels + 1;
+		for (i = 1; i < s_numChannels; i++, ch++)
+		{
+			if ((s_channels[i].bPlaying) & (s_channels[i].entnum == entityNum) & (!s_channels[i].bLooping))
+			{
+				// Ignore position updates for CHAN_VOICE_GLOBAL
+				if (ch->entchannel != CHAN_VOICE_GLOBAL && ch->entchannel != CHAN_ANNOUNCER)
+				{
+					pos[0] = origin[0];
+					pos[1] = origin[2];
+					pos[2] = -origin[1];
+					alSourcefv(s_channels[i].alSource, AL_POSITION, pos);
+
+					UpdateEAXBuffer(ch);
+				}
+
+/*				pos[0] = origin[0];
+				pos[1] = origin[2];
+				pos[2] = -origin[1];
+				alSourcefv(s_channels[i].alSource, AL_POSITION, pos);
+	
+				if ((s_bEALFileLoaded) && !( ch->entchannel == CHAN_VOICE || ch->entchannel == CHAN_VOICE_ATTEN || ch->entchannel == CHAN_VOICE_GLOBAL ) )
+				{
+					UpdateEAXBuffer(ch);
+				}
+*/
+			}
+		}
+	}
+
+	VectorCopy( origin, s_entityPosition[entityNum] );
+}
+
+
+// Given a current wav we are playing, and our position within it, lets figure out its volume...
+//
+// (this is mostly Jake's code from EF1, which explains a lot...:-)
+//
+static int next_amplitude = 0;
+static int S_CheckAmplitude(channel_t	*ch, const int s_oldpaintedtime )
+{
+	// now, is this a cycle - or have we just started a new sample - where we should update the backup table, and write this value
+	// into the new table? or should we just take the value FROM the back up table and feed it out.
+	assert( ch->startSample != START_SAMPLE_IMMEDIATE );
+	if ( ch->startSample == s_oldpaintedtime || (next_amplitude < s_soundtime) )//(ch->startSample == START_SAMPLE_IMMEDIATE)//!s_entityWavVol_back[ch->entnum] 
+	{
+		int	sample;
+		int	sample_total = 0;
+		int	count = 0;
+		short *current_pos_s;
+//		char *current_pos_c;
+		int	offset = 0;
+
+		// if we haven't started the sample yet, we must be at the beginning
+		current_pos_s = ((short*)ch->thesfx->pSoundData);
+//		current_pos_c = ((char*)ch->thesfx->data);
+
+		//if (ch->startSample != START_SAMPLE_IMMEDIATE)
+		//{
+			// figure out where we are in the sample right now.
+			offset = s_oldpaintedtime - ch->startSample;//s_paintedtime
+			current_pos_s += offset;
+//			current_pos_c += offset;
+		//}
+		
+		// scan through 10 samples 100( at 11hz or 200 at 22hz) samples apart.
+		//
+		for (int i=0; i<10; i++)
+		{				
+			//
+			// have we run off the end?
+			if ((offset + (i*100)) > ch->thesfx->iSoundLengthInSamples)
+			{
+				break;
+			}
+//			if (ch->thesfx->width == 1)
+//			{
+//				sample = current_pos_c[i*100];
+//			}
+//			else
+			{					
+				switch (ch->thesfx->eSoundCompressionMethod)
+				{					
+					case ct_16:
+					{
+						sample = LittleShort(current_pos_s[i*100]);
+					}
+					break;
+
+					case ct_MP3:
+					{
+						const int iIndex = (i*100) + ((offset * /*ch->thesfx->width*/2) - ch->iMP3SlidingDecodeWindowPos);
+						const short* pwSamples = (short*) (ch->MP3SlidingDecodeBuffer + iIndex);
+
+						sample = LittleShort(*pwSamples);						
+					}
+					break;
+
+					default:			
+					{
+						assert(0);
+						sample = 0;
+					}
+					break;
+				}
+				
+//				if (sample < 0)
+//					sample = -sample;
+				sample = sample>>8;
+			}
+			// square it for better accuracy
+			sample_total += (sample * sample);
+			count++;
+		}
+		
+		// if we are already done with this sample, then its silence
+		if (!count)
+		{
+			return(0);
+		}
+		sample_total /= count;
+
+		// I hate doing this, but its the simplest way
+		if (sample_total < ch->thesfx->fVolRange * s_lip_threshold_1->value)
+		{
+		// tell the scripts that are relying on this that we are still going, but actually silent right now.
+			sample = -1;
+		}
+		else
+		if (sample_total < ch->thesfx->fVolRange * s_lip_threshold_2->value)
+		{
+			sample = 1;
+		}
+		else
+		if (sample_total < ch->thesfx->fVolRange * s_lip_threshold_3->value)
+		{
+			sample = 2;
+		}
+		else
+		if (sample_total < ch->thesfx->fVolRange * s_lip_threshold_4->value)
+		{
+			sample = 3;
+		}
+		else
+		{
+			sample = 4;
+		}
+
+//		OutputDebugString(va("Returning sample %d\n",sample));
+
+		// store away the value we got into the back up table
+		s_entityWavVol_back[ ch->entnum ] = sample;
+		return (sample);
+	}
+	// no, just get last value calculated from backup table
+	assert( s_entityWavVol_back[ch->entnum] );
+	return (s_entityWavVol_back[ ch->entnum]);
+}
+/*
+============
+S_Respatialize
+
+Change the volumes of all the playing sounds for changes in their positions
+============
+*/
+void S_Respatialize( int entityNum, const vec3_t head, vec3_t axis[3], qboolean inwater )
+{
+	EAXOCCLUSIONPROPERTIES eaxOCProp;
+	EAXACTIVEFXSLOTS eaxActiveSlots;
+	unsigned int ulEnvironment;
+	int			i;
+	channel_t	*ch;
+
+	if ( !s_soundStarted || s_soundMuted ) {
+		return; 
+	}
+
+	if (s_UseOpenAL)
+	{
+		listener_pos[0] = head[0];
+		listener_pos[1] = head[2];
+		listener_pos[2] = -head[1];
+		alListenerfv(AL_POSITION, listener_pos);
+
+		listener_ori[0] = axis[0][0];
+		listener_ori[1] = axis[0][2];
+		listener_ori[2] = -axis[0][1];
+		listener_ori[3] = axis[2][0];
+		listener_ori[4] = axis[2][2];
+		listener_ori[5] = -axis[2][1];
+		alListenerfv(AL_ORIENTATION, listener_ori);
+
+		// Update EAX effects here
+		if (s_bEALFileLoaded)
+		{
+			// Check if the Listener is underwater
+			if (inwater)
+			{
+				// Check if we have already applied Underwater effect
+				if (!s_bInWater)
+				{
+					// New underwater fix
+					for (i = 0; i < EAX_MAX_FXSLOTS; i++)
+					{
+						s_FXSlotInfo[i].lEnvID = -1;
+					}
+
+					// Load underwater reverb effect into FX Slot 0, and set this as the Primary FX Slot
+					ulEnvironment = EAX_ENVIRONMENT_UNDERWATER;
+					s_eaxSet(&EAXPROPERTYID_EAX40_FXSlot0, EAXREVERB_ENVIRONMENT,
+						NULL, &ulEnvironment, sizeof(unsigned int));
+					s_EnvironmentID = 999;
+
+					s_eaxSet(&EAXPROPERTYID_EAX40_Context, EAXCONTEXT_PRIMARYFXSLOTID, NULL, (ALvoid*)&EAXPROPERTYID_EAX40_FXSlot0,
+						sizeof(GUID));
+
+					// Occlude all sounds into this environment, and mute all their sends to other reverbs
+					eaxOCProp.lOcclusion = -3000;
+					eaxOCProp.flOcclusionLFRatio = 0.0f;
+					eaxOCProp.flOcclusionRoomRatio = 1.37f;
+					eaxOCProp.flOcclusionDirectRatio = 1.0f;
+
+					eaxActiveSlots.guidActiveFXSlots[0] = EAX_NULL_GUID;
+					eaxActiveSlots.guidActiveFXSlots[1] = EAX_PrimaryFXSlotID;
+
+					ch = s_channels + 1;
+					for (i = 1; i < s_numChannels; i++, ch++)
+					{
+						// New underwater fix
+						s_channels[i].lSlotID = -1;
+
+						s_eaxSet(&EAXPROPERTYID_EAX40_Source, EAXSOURCE_OCCLUSIONPARAMETERS,
+							ch->alSource, &eaxOCProp, sizeof(EAXOCCLUSIONPROPERTIES));
+
+						s_eaxSet(&EAXPROPERTYID_EAX40_Source, EAXSOURCE_ACTIVEFXSLOTID, ch->alSource,
+							&eaxActiveSlots, 2*sizeof(GUID));
+					}
+
+					s_bInWater = true;
+				}
+			}
+			else
+			{
+				// Not underwater ... check if the underwater effect is still present
+				if (s_bInWater)
+				{
+					s_bInWater = false;
+
+					// Remove underwater Reverb effect, and reset Occlusion / Obstruction amount on all Sources
+					UpdateEAXListener();
+
+					ch = s_channels + 1;
+					for (i = 1; i < s_numChannels; i++, ch++)
+					{
+						UpdateEAXBuffer(ch);
+					}
+				}
+				else
+				{
+					UpdateEAXListener();
+				}
+			}
+		}
+	}
+	else
+	{
+		listener_number = entityNum;
+		VectorCopy(head, listener_origin);
+		VectorCopy(axis[0], listener_axis[0]);
+		VectorCopy(axis[1], listener_axis[1]);
+		VectorCopy(axis[2], listener_axis[2]);
+
+		// update spatialization for dynamic sounds	
+		ch = s_channels;
+		for ( i = 0 ; i < MAX_CHANNELS ; i++, ch++ ) {
+			if ( !ch->thesfx ) {
+				continue;
+			}
+			if ( ch->loopSound ) {	// loopSounds are regenerated fresh each frame
+				Channel_Clear(ch);	// memset (ch, 0, sizeof(*ch));
+				continue;
+			}
+
+			// anything coming from the view entity will always be full volume
+			if (ch->entnum == listener_number || ch->entchannel == CHAN_VOICE_GLOBAL || ch->entchannel == CHAN_ANNOUNCER) {
+				ch->leftvol = ch->master_vol;
+				ch->rightvol = ch->master_vol;
+			} else {
+				const vec3_t	*origin;
+				if (ch->fixed_origin) {
+					origin = &ch->origin;
+				} else {
+					origin = &s_entityPosition[ ch->entnum ];
+				}
+
+				S_SpatializeOrigin (*origin, (float)ch->master_vol, &ch->leftvol, &ch->rightvol, ch->entchannel);
+			}
+
+			//NOTE: Made it so that voice sounds keep playing, even out of range
+			//		so that tasks waiting for sound completion keep proper timing
+			if ( !( ch->entchannel == CHAN_VOICE || ch->entchannel == CHAN_VOICE_ATTEN || ch->entchannel == CHAN_VOICE_GLOBAL ) && !ch->leftvol && !ch->rightvol ) {
+				Channel_Clear(ch);	// memset (ch, 0, sizeof(*ch));
+				continue;
+			}
+		}
+
+		// add loopsounds
+		S_AddLoopSounds ();
+	}
+
+	return;
+}
+
+
+/*
+========================
+S_ScanChannelStarts
+
+Returns qtrue if any new sounds were started since the last mix
+========================
+*/
+qboolean S_ScanChannelStarts( void ) {
+	channel_t		*ch;
+	int				i;
+	qboolean		newSamples;
+
+	newSamples = qfalse;
+	ch = s_channels;
+	for (i=0; i<MAX_CHANNELS ; i++, ch++) {
+		if ( !ch->thesfx ) {
+			continue;
+		}
+		if ( ch->loopSound ) {
+			continue;
+		}
+
+		// if this channel was just started this frame,
+		// set the sample count to it begins mixing
+		// into the very first sample
+		if ( ch->startSample == START_SAMPLE_IMMEDIATE ) {
+			ch->startSample = s_paintedtime;
+			newSamples = qtrue;
+			continue;
+		}
+
+		// if it is completely finished by now, clear it
+		if ( ch->startSample + ch->thesfx->iSoundLengthInSamples <= s_paintedtime ) {
+			ch->thesfx = NULL;
+			continue;
+		}
+	}
+
+	return newSamples;
+}
+
+// this is now called AFTER the DMA painting, since it's only the painter calls that cause the MP3s to be unpacked,
+//	and therefore to have data readable by the lip-sync volume calc code.
+//
+void S_DoLipSynchs( const s_oldpaintedtime )
+{
+	channel_t		*ch;
+	int				i;
+	qboolean		newSamples;
+
+	// clear out the lip synching override array for this frame
+	memset(s_entityWavVol, 0,(MAX_GENTITIES * 4));
+
+	newSamples = qfalse;
+	ch = s_channels;
+	for (i=0; i<MAX_CHANNELS ; i++, ch++) {
+		if ( !ch->thesfx ) {
+			continue;
+		}
+		if ( ch->loopSound ) {
+			continue;
+		}
+
+		// if we are playing a sample that should override the lip texture on its owning model, lets figure out
+		// what the amplitude is, stick it in a table, then return it 
+		if ( ch->entchannel == CHAN_VOICE || ch->entchannel == CHAN_VOICE_ATTEN || ch->entchannel == CHAN_VOICE_GLOBAL )
+		{
+			// go away and work out amplitude for this sound we are playing right now.
+			s_entityWavVol[ ch->entnum ] = S_CheckAmplitude( ch, s_oldpaintedtime );
+			if ( s_show->integer == 3 ) {
+				Com_Printf( "(%i)%i %s vol = %i\n", ch->entnum, i, ch->thesfx->sSoundName, s_entityWavVol[ ch->entnum ] );
+			}
+		}
+	}
+
+	if (next_amplitude < s_soundtime)	{
+		next_amplitude = s_soundtime + 800;
+	}
+}
+
+/*
+============
+S_Update
+
+Called once each time through the main loop
+============
+*/
+void S_Update( void ) {
+	int			i;
+	channel_t	*ch;
+
+	if ( !s_soundStarted || s_soundMuted ) {
+		return;
+	}
+
+	//
+	// debugging output
+	//
+	if ( s_show->integer == 2 ) {
+		//int total = 0;
+		//int totalMeg =0;
+		ch = s_channels;
+		for (i=0 ; i<MAX_CHANNELS; i++, ch++) {
+			if ( ch->thesfx && (ch->leftvol || ch->rightvol) ) {				
+				Com_Printf ("(%i) %3i %3i %s\n", ch->entnum, ch->leftvol, ch->rightvol, ch->thesfx->sSoundName);
+				//total++;
+				//totalMeg += Z_Size(ch->thesfx->pSoundData);
+				//if (ch->thesfx->pMP3StreamHeader)
+				//{
+				//	totalMeg += sizeof(*ch->thesfx->pMP3StreamHeader);
+				//}
+			}
+		}
+		
+		//if (total)
+		//	Com_Printf ("----(%i)---- painted: %i, SND %.2fMB\n", total, s_paintedtime, totalMeg/1024.0f/1024.0f);
+	}
+
+	// The Open AL code, handles background music in the S_UpdateRawSamples function
+	if (!s_UseOpenAL)
+	{
+		// add raw data from streamed samples
+		S_UpdateBackgroundTrack();
+	}
+
+	// mix some sound
+	S_Update_();
+}
+
+void S_GetSoundtime(void)
+{
+	int		samplepos;
+	static	int		buffers;
+	static	int		oldsamplepos;
+	int		fullsamples;
+	
+	fullsamples = dma.samples / dma.channels;
+
+	// it is possible to miscount buffers if it has wrapped twice between
+	// calls to S_Update.  Oh well.
+	samplepos = SNDDMA_GetDMAPos();
+	if (samplepos < oldsamplepos)
+	{
+		buffers++;					// buffer wrapped
+		
+		if (s_paintedtime > 0x40000000)
+		{	// time to chop things off to avoid 32 bit limits
+			buffers = 0;
+			s_paintedtime = fullsamples;
+			S_StopAllSounds ();
+		}
+	}
+	oldsamplepos = samplepos;
+
+	s_soundtime = buffers*fullsamples + samplepos/dma.channels;
+
+#if 0
+// check to make sure that we haven't overshot
+	if (s_paintedtime < s_soundtime)
+	{
+		Com_DPrintf ("S_Update_ : overflow\n");
+		s_paintedtime = s_soundtime;
+	}
+#endif
+
+	if ( dma.submission_chunk < 256 ) {
+		s_paintedtime = (int)(s_soundtime + s_mixPreStep->value * dma.speed);
+	} else {
+		s_paintedtime = s_soundtime + dma.submission_chunk;
+	}
+}
+
+
+void S_Update_(void) {
+	unsigned        endtime;
+	int				samps;
+	channel_t		*ch;
+	int i,j;
+	int			source;
+	float		pos[3];
+#ifdef _DEBUG
+	char szString[256];
+#endif
+
+	if ( !s_soundStarted || s_soundMuted ) {
+		return;
+	}
+
+	if (s_UseOpenAL)
+	{
+		UpdateSingleShotSounds();
+
+		ch = s_channels + 1;
+		for ( i = 1; i < MAX_CHANNELS ; i++, ch++ )
+		{	
+			if ( !ch->thesfx || (ch->bPlaying))
+				continue;
+
+			source = ch - s_channels;
+
+			if (ch->entchannel == CHAN_VOICE_GLOBAL || ch->entchannel == CHAN_ANNOUNCER)
+			{
+				// Always play these sounds at 0,0,-1 (in front of listener)
+				pos[0] = 0.0f;
+				pos[1] = 0.0f;
+				pos[2] = -1.0f;
+
+				alSourcefv(s_channels[source].alSource, AL_POSITION, pos);
+				alSourcei(s_channels[source].alSource, AL_LOOPING, AL_FALSE);
+				alSourcei(s_channels[source].alSource, AL_SOURCE_RELATIVE, AL_TRUE);
+				if (ch->entchannel == CHAN_ANNOUNCER)
+				{
+					alSourcef(s_channels[source].alSource, AL_GAIN, ((float)(ch->master_vol) * s_volume->value) / 255.0f);
+				}
+				else
+				{
+					alSourcef(s_channels[source].alSource, AL_GAIN, ((float)(ch->master_vol) * s_volumeVoice->value) / 255.0f);
+				}
+			}
+			else
+			{
+				// Get position of source
+				if (ch->fixed_origin)
+				{
+					pos[0] = ch->origin[0];
+					pos[1] = ch->origin[2];
+					pos[2] = -ch->origin[1];
+					alSourcei(s_channels[source].alSource, AL_SOURCE_RELATIVE, AL_FALSE);
+				}
+				else
+				{
+					if (ch->entnum == listener_number)
+					{
+						pos[0] = 0.0f;
+						pos[1] = 0.0f;
+						pos[2] = 0.0f;
+						alSourcei(s_channels[source].alSource, AL_SOURCE_RELATIVE, AL_TRUE);
+					}
+					else
+					{
+						// Get position of Entity
+						if (ch->bLooping)
+						{
+							pos[0] = loopSounds[ ch->entnum ].origin[0];
+							pos[1] = loopSounds[ ch->entnum ].origin[2];
+							pos[2] = -loopSounds[ ch->entnum ].origin[1];
+						}
+						else
+						{
+							pos[0] = s_entityPosition[ch->entnum][0];
+							pos[1] = s_entityPosition[ch->entnum][2];
+							pos[2] = -s_entityPosition[ch->entnum][1];
+						}
+						alSourcei(s_channels[source].alSource, AL_SOURCE_RELATIVE, AL_FALSE);
+					}
+				}
+		
+				alSourcefv(s_channels[source].alSource, AL_POSITION, pos);
+				alSourcei(s_channels[source].alSource, AL_LOOPING, AL_FALSE);
+
+				if (ch->entchannel == CHAN_VOICE)
+				{
+					// Reduced fall-off (Large Reference Distance), affected by Voice Volume
+					alSourcef(s_channels[source].alSource, AL_REFERENCE_DISTANCE, DEFAULT_VOICE_REF_DISTANCE);
+					alSourcef(s_channels[source].alSource, AL_GAIN, ((float)(ch->master_vol) * s_volumeVoice->value) / 255.0f);
+				}
+				else if (ch->entchannel == CHAN_VOICE_ATTEN)
+				{
+					// Normal fall-off, affected by Voice Volume
+					alSourcef(s_channels[source].alSource, AL_REFERENCE_DISTANCE, DEFAULT_REF_DISTANCE);
+					alSourcef(s_channels[source].alSource, AL_GAIN, ((float)(ch->master_vol) * s_volumeVoice->value) / 255.0f);
+				}
+				else if (ch->entchannel == CHAN_LESS_ATTEN)
+				{
+					// Reduced fall-off, affected by Sound Effect Volume
+					alSourcef(s_channels[source].alSource, AL_REFERENCE_DISTANCE, DEFAULT_VOICE_REF_DISTANCE);
+					alSourcef(s_channels[source].alSource, AL_GAIN, ((float)(ch->master_vol) * s_volume->value) / 255.f);
+				}
+				else
+				{
+					// Normal fall-off, affect by Sound Effect Volume
+					alSourcef(s_channels[source].alSource, AL_REFERENCE_DISTANCE, DEFAULT_REF_DISTANCE);
+					alSourcef(s_channels[source].alSource, AL_GAIN, ((float)(ch->master_vol) * s_volume->value) / 255.f);
+				}
+			}
+
+			if (s_bEALFileLoaded)
+				UpdateEAXBuffer(ch);
+
+			int nBytesDecoded = 0;
+			int nTotalBytesDecoded = 0;
+			int nBuffersToAdd = 0;
+
+			if (ch->thesfx->pMP3StreamHeader)
+			{
+				memcpy(&ch->MP3StreamHeader, ch->thesfx->pMP3StreamHeader,	sizeof(ch->MP3StreamHeader));
+				ch->iMP3SlidingDecodeWritePos = 0;
+				ch->iMP3SlidingDecodeWindowPos= 0;
+
+				// Reset streaming buffers status's
+				for (i = 0; i < NUM_STREAMING_BUFFERS; i++)
+					ch->buffers[i].Status = UNQUEUED;
+
+				// Decode (STREAMING_BUFFER_SIZE / 1152) MP3 frames for each of the NUM_STREAMING_BUFFERS AL Buffers
+				for (i = 0; i < NUM_STREAMING_BUFFERS; i++)
+				{
+					nTotalBytesDecoded = 0;
+					
+					for (j = 0; j < (STREAMING_BUFFER_SIZE / 1152); j++)
+					{
+						nBytesDecoded = C_MP3Stream_Decode(&ch->MP3StreamHeader, 0);	// added ,0 ?
+						memcpy(ch->buffers[i].Data + nTotalBytesDecoded, ch->MP3StreamHeader.bDecodeBuffer, nBytesDecoded);
+						if (ch->entchannel == CHAN_VOICE || ch->entchannel == CHAN_VOICE_ATTEN || ch->entchannel == CHAN_VOICE_GLOBAL )
+						{
+							if (ch->thesfx->lipSyncData)
+							{
+								ch->thesfx->lipSyncData[(i*NUM_STREAMING_BUFFERS)+j] = S_MP3PreProcessLipSync(ch, (short *)(ch->MP3StreamHeader.bDecodeBuffer));
+							}
+							else
+							{
+#ifdef _DEBUG
+								sprintf(szString, "Missing lip-sync info. for %s\n", ch->thesfx->sSoundName);
+								OutputDebugString(szString);
+#endif
+							}
+						}
+						nTotalBytesDecoded += nBytesDecoded;
+					}
+
+					if (nTotalBytesDecoded != STREAMING_BUFFER_SIZE)
+					{
+						memset(ch->buffers[i].Data + nTotalBytesDecoded, 0, (STREAMING_BUFFER_SIZE - nTotalBytesDecoded));
+						break;
+					}
+				}
+
+				if (i >= NUM_STREAMING_BUFFERS)
+					nBuffersToAdd = NUM_STREAMING_BUFFERS;
+				else
+					nBuffersToAdd = i + 1;
+
+				// Make sure queue is empty first
+				alSourcei(s_channels[source].alSource, AL_BUFFER, NULL);
+
+				for (i = 0; i < nBuffersToAdd; i++)
+				{
+					// Copy decoded data to AL Buffer
+					alBufferData(ch->buffers[i].BufferID, AL_FORMAT_MONO16, ch->buffers[i].Data, STREAMING_BUFFER_SIZE, 22050);
+		
+					// Queue AL Buffer on Source
+					alSourceQueueBuffers(s_channels[source].alSource, 1, &(ch->buffers[i].BufferID));
+					if (alGetError() == AL_NO_ERROR)
+					{
+						ch->buffers[i].Status = QUEUED;
+					}
+				}
+
+				// Clear error state, and check for successful Play call
+				alGetError();
+				alSourcePlay(s_channels[source].alSource);
+				if (alGetError() == AL_NO_ERROR)
+					s_channels[source].bPlaying = true;
+
+				ch->bStreaming = true;
+
+				if ( ch->entchannel == CHAN_VOICE || ch->entchannel == CHAN_VOICE_ATTEN || ch->entchannel == CHAN_VOICE_GLOBAL )
+				{
+					if (ch->thesfx->lipSyncData)
+					{
+						// Record start time for Lip-syncing
+						s_channels[source].iStartTime = timeGetTime();
+
+						// Prepare lipsync value(s)
+						s_entityWavVol[ ch->entnum ] = ch->thesfx->lipSyncData[0];
+					}
+					else
+					{
+#ifdef _DEBUG
+						sprintf(szString, "Missing lip-sync info. for %s\n", ch->thesfx->sSoundName);
+						OutputDebugString(szString);
+#endif
+					}
+				}
+
+				return;
+			}
+			else
+			{
+				// Attach buffer to source
+				alSourcei(s_channels[source].alSource, AL_BUFFER, ch->thesfx->Buffer);
+
+				ch->bStreaming = false;
+
+				// Clear error state, and check for successful Play call
+				alGetError();
+				alSourcePlay(s_channels[source].alSource);
+				if (alGetError() == AL_NO_ERROR)
+					s_channels[source].bPlaying = true;
+
+				if ( ch->entchannel == CHAN_VOICE || ch->entchannel == CHAN_VOICE_ATTEN || ch->entchannel == CHAN_VOICE_GLOBAL )
+				{
+					if (ch->thesfx->lipSyncData)
+					{
+						// Record start time for Lip-syncing
+						s_channels[source].iStartTime = timeGetTime();
+
+						// Prepare lipsync value(s)
+						s_entityWavVol[ ch->entnum ] = ch->thesfx->lipSyncData[0];
+					}
+					else
+					{
+#ifdef _DEBUG
+						sprintf(szString, "Missing lip-sync info. for %s\n", ch->thesfx->sSoundName);
+						OutputDebugString(szString);
+#endif
+					}
+				}
+			}
+		}
+
+		S_SetLipSyncs();
+
+		UpdateLoopingSounds();
+
+		AL_UpdateRawSamples();
+	}
+	else
+	{
+		// Updates s_soundtime
+		S_GetSoundtime();
+
+		const int s_oldpaintedtime = s_paintedtime;
+
+		// clear any sound effects that end before the current time,
+		// and start any new sounds
+		S_ScanChannelStarts();
+
+		// mix ahead of current position
+		endtime = (int)(s_soundtime + s_mixahead->value * dma.speed);
+
+		// mix to an even submission block size
+		endtime = (endtime + dma.submission_chunk-1)
+			& ~(dma.submission_chunk-1);
+
+		// never mix more than the complete buffer
+		samps = dma.samples >> (dma.channels-1);
+		if (endtime - s_soundtime > samps)
+			endtime = s_soundtime + samps;
+
+
+		SNDDMA_BeginPainting ();
+
+		S_PaintChannels (endtime);
+
+		SNDDMA_Submit ();
+
+		S_DoLipSynchs( s_oldpaintedtime );
+	}
+}
+
+
+void UpdateSingleShotSounds()
+{
+	int i, j, k;
+	ALint state;
+	ALint processed;
+	channel_t *ch;
+#ifdef _DEBUG
+	char szString[256];
+#endif
+
+	// Firstly, check if any single-shot sounds have completed, or if they need more data (for streaming Sources),
+	// and/or if any of the currently playing (non-Ambient) looping sounds need to be stopped
+	ch = s_channels + 1;
+	for (i = 1; i < s_numChannels; i++, ch++)
+	{
+		ch->bProcessed = false;
+		if ((s_channels[i].bPlaying) && (!ch->bLooping))
+		{	
+			// Single-shot
+			if (s_channels[i].bStreaming == false)
+			{
+				alGetSourcei(s_channels[i].alSource, AL_SOURCE_STATE, &state);
+				if (state == AL_STOPPED)
+				{
+					s_channels[i].thesfx = NULL;
+					s_channels[i].bPlaying = false;
+				}
+			}
+			else
+			{	
+				// Process streaming sample
+
+				// Procedure :-
+				// if more data to play
+				//		if any UNQUEUED Buffers
+				//			fill them with data
+				//		(else ?)
+				//			get number of buffers processed
+				//			fill them with data
+				//		restart playback if it has stopped (buffer underrun)
+				// else
+				//		free channel
+				
+				int nBytesDecoded;
+
+				if (ch->thesfx->pMP3StreamHeader)
+				{
+					if (ch->MP3StreamHeader.iSourceBytesRemaining == 0)
+					{
+						// Finished decoding data - if the source has finished playing then we're done
+						alGetSourcei(ch->alSource, AL_SOURCE_STATE, &state);
+						if (state == AL_STOPPED)
+						{
+							// Attach NULL buffer to Source to remove any buffers left in the queue
+							alSourcei(ch->alSource, AL_BUFFER, NULL);
+							ch->thesfx = NULL;
+							ch->bPlaying = false;
+						}
+						// Move on to next channel ...
+						continue;
+					}
+
+					// Check to see if any Buffers have been processed
+					alGetSourcei(ch->alSource, AL_BUFFERS_PROCESSED, &processed);
+
+					ALuint buffer;
+					while (processed)
+					{
+						alSourceUnqueueBuffers(ch->alSource, 1, &buffer);			
+						for (j = 0; j < NUM_STREAMING_BUFFERS; j++)
+						{
+							if (ch->buffers[j].BufferID == buffer)
+							{
+								ch->buffers[j].Status = UNQUEUED;
+								break;
+							}
+						}
+						processed--;
+					}
+
+					int nTotalBytesDecoded = 0;
+
+					for (j = 0; j < NUM_STREAMING_BUFFERS; j++)
+					{
+						if ((ch->buffers[j].Status == UNQUEUED) & (ch->MP3StreamHeader.iSourceBytesRemaining > 0))
+						{
+							nTotalBytesDecoded = 0;
+		
+							for (k = 0; k < (STREAMING_BUFFER_SIZE / 1152); k++)
+							{
+								nBytesDecoded = C_MP3Stream_Decode(&ch->MP3StreamHeader, 0); // added ,0
+
+								if (nBytesDecoded > 0)
+								{
+									memcpy(ch->buffers[j].Data + nTotalBytesDecoded, ch->MP3StreamHeader.bDecodeBuffer, nBytesDecoded);
+
+									if (ch->entchannel == CHAN_VOICE || ch->entchannel == CHAN_VOICE_ATTEN || ch->entchannel == CHAN_VOICE_GLOBAL )
+									{
+										if (ch->thesfx->lipSyncData)
+										{
+											ch->thesfx->lipSyncData[(j*4)+k] = S_MP3PreProcessLipSync(ch, (short *)(ch->buffers[j].Data));
+										}
+										else
+										{
+#ifdef _DEBUG
+											sprintf(szString, "Missing lip-sync info. for %s\n", ch->thesfx->sSoundName);
+											OutputDebugString(szString);
+#endif
+										}
+									}
+									nTotalBytesDecoded += nBytesDecoded;
+								}
+								else
+								{
+									// Make sure that iSourceBytesRemaining is 0
+									if (ch->MP3StreamHeader.iSourceBytesRemaining != 0)
+									{
+										ch->MP3StreamHeader.iSourceBytesRemaining = 0;
+										break;
+									}
+								}
+							}
+
+							if (nTotalBytesDecoded != STREAMING_BUFFER_SIZE)
+							{
+								memset(ch->buffers[j].Data + nTotalBytesDecoded, 0, (STREAMING_BUFFER_SIZE - nTotalBytesDecoded));
+
+								// Move data to buffer
+								alBufferData(ch->buffers[j].BufferID, AL_FORMAT_MONO16, ch->buffers[j].Data, STREAMING_BUFFER_SIZE, 22050);
+
+								// Queue Buffer on Source
+								alSourceQueueBuffers(ch->alSource, 1, &(ch->buffers[j].BufferID));
+
+								// Update status of Buffer
+								ch->buffers[j].Status = QUEUED;
+
+								break;
+							}
+							else
+							{
+								// Move data to buffer
+								alBufferData(ch->buffers[j].BufferID, AL_FORMAT_MONO16, ch->buffers[j].Data, STREAMING_BUFFER_SIZE, 22050);
+
+								// Queue Buffer on Source
+								alSourceQueueBuffers(ch->alSource, 1, &(ch->buffers[j].BufferID));
+								
+								// Update status of Buffer
+								ch->buffers[j].Status = QUEUED;
+							}
+						}
+					}
+
+					// Get state of Buffer
+					alGetSourcei(ch->alSource, AL_SOURCE_STATE, &state);
+					if (state != AL_PLAYING)
+					{
+						alSourcePlay(ch->alSource);
+#ifdef _DEBUG
+						char szString[256];
+						sprintf(szString,"[%d] Restarting playback of single-shot streaming MP3 sample - still have %d bytes to decode\n", i, ch->MP3StreamHeader.iSourceBytesRemaining);
+						OutputDebugString(szString);
+#endif
+					}
+				}
+			}
+		}
+	}
+}
+
+
+
+
+void UpdateLoopingSounds()
+{
+	int i,j;
+	ALuint source;
+	channel_t *ch;
+	loopSound_t	*loop;
+	float pos[3];
+
+	// First check to see if any of the looping sounds are already playing at the correct positions
+	ch = s_channels + 1;
+	for (i = 1; i < s_numChannels; i++, ch++)
+	{
+		if (ch->bLooping && s_channels[i].bPlaying)
+		{
+			for (j = 0; j < numLoopSounds; j++)
+			{
+				loop = &loopSounds[j];
+
+				// If this channel is playing the right sound effect at the right position then mark this channel and looping sound
+				// as processed
+				if ((loop->bProcessed == false) && (ch->thesfx == loop->sfx) )
+				{
+					if ( (loop->origin[0] == listener_pos[0]) && (loop->origin[1] == -listener_pos[2])
+						&& (loop->origin[2] == listener_pos[1]) )
+					{
+						// Assume that this sound is head relative
+						if (!loop->bRelative)
+						{
+							// Set position to 0,0,0 and turn on Head Relative Mode
+							float pos[3];
+							pos[0] = 0.f;
+							pos[1] = 0.f;
+							pos[2] = 0.f;
+
+							alSourcefv(s_channels[i].alSource, AL_POSITION, pos);
+							alSourcei(s_channels[i].alSource, AL_SOURCE_RELATIVE, AL_TRUE);
+							loop->bRelative = true;
+						}
+
+						// Make sure Gain is set correctly
+						if (ch->master_vol != loop->volume)
+						{
+							ch->master_vol = loop->volume;
+							alSourcef(s_channels[i].alSource, AL_GAIN, ((float)(ch->master_vol) * s_volume->value) / 255.f);
+						}
+
+						ch->bProcessed = true;
+						loop->bProcessed = true;
+					}	
+					else if ((loop->bProcessed == false) && (ch->thesfx == loop->sfx) && (!memcmp(ch->origin, loop->origin, sizeof(ch->origin))))
+					{
+						// Match !
+						ch->bProcessed = true;
+						loop->bProcessed = true;
+
+						// Make sure Gain is set correctly
+						if (ch->master_vol != loop->volume)
+						{
+							ch->master_vol = loop->volume;
+							alSourcef(s_channels[i].alSource, AL_GAIN, ((float)(ch->master_vol) * s_volume->value) / 255.f);
+						}
+
+						break;
+					}
+				}
+			}
+		}
+	}
+
+	// Next check if the correct looping sound is playing, but at the wrong position
+	ch = s_channels + 1;
+	for (i = 1; i < s_numChannels; i++, ch++)
+	{
+		if ((ch->bLooping) && (ch->bProcessed == false) && s_channels[i].bPlaying)
+		{
+			for (j = 0; j < numLoopSounds; j++)
+			{
+				loop = &loopSounds[j];
+
+				if ((loop->bProcessed == false) && (ch->thesfx == loop->sfx))
+				{
+					// Same sound - wrong position
+					ch->origin[0] = loop->origin[0];
+					ch->origin[1] = loop->origin[1];
+					ch->origin[2] = loop->origin[2];
+
+					pos[0] = loop->origin[0];
+					pos[1] = loop->origin[2];
+					pos[2] = -loop->origin[1];
+					alSourcefv(s_channels[i].alSource, AL_POSITION, pos);
+
+					ch->master_vol = loop->volume;
+					alSourcef(s_channels[i].alSource, AL_GAIN, ((float)(ch->master_vol) * s_volume->value) / 255.f);
+
+					if (s_bEALFileLoaded)
+						UpdateEAXBuffer(ch);
+
+					ch->bProcessed = true;
+					loop->bProcessed = true;
+					break;
+				}
+			}
+		}
+	}
+
+	// If any non-procesed looping sounds are still playing on a channel, they can be removed as they are no longer
+	// required
+	ch = s_channels + 1;
+	for (i = 1; i < s_numChannels; i++, ch++)
+	{
+		if (s_channels[i].bPlaying && ch->bLooping && !ch->bProcessed)
+		{
+			// Sound no longer needed
+			alSourceStop(s_channels[i].alSource);
+			ch->thesfx = NULL;
+			ch->bPlaying = false;
+		}
+	}
+
+#ifdef _DEBUG
+	alGetError();
+#endif
+	// Finally if there are any non-processed sounds left, we need to try and play them
+	for (j = 0; j < numLoopSounds; j++)
+	{
+		loop = &loopSounds[j];
+
+		if (loop->bProcessed == false)
+		{
+			ch = S_PickChannel(0,0);
+
+			ch->master_vol = loop->volume;
+			ch->entnum = loop->entnum;
+			ch->entchannel = loop->entchan;
+			ch->thesfx = loop->sfx;
+			ch->bLooping = true;
+
+			// Check if the Source is positioned at exactly the same location as the listener
+			if ( (loop->origin[0] == listener_pos[0]) && (loop->origin[1] == -listener_pos[2])
+						&& (loop->origin[2] == listener_pos[1]) )
+			{
+				// Assume that this sound is head relative
+				loop->bRelative = true;
+				ch->origin[0] = 0.f;
+				ch->origin[1] = 0.f;
+				ch->origin[2] = 0.f;
+			}
+			else
+			{
+				ch->origin[0] = loop->origin[0];
+				ch->origin[1] = loop->origin[1];
+				ch->origin[2] = loop->origin[2];
+				loop->bRelative = false;
+			}
+			
+			ch->fixed_origin = loop->bRelative;
+			pos[0] = ch->origin[0];
+			pos[1] = ch->origin[2];
+			pos[2] = -ch->origin[1];
+
+			source = ch - s_channels;
+			alSourcei(s_channels[source].alSource, AL_BUFFER, ch->thesfx->Buffer);
+			alSourcefv(s_channels[source].alSource, AL_POSITION, pos);
+			alSourcei(s_channels[source].alSource, AL_LOOPING, AL_TRUE);
+			alSourcef(s_channels[source].alSource, AL_GAIN, ((float)(ch->master_vol) * s_volume->value) / 255.0f);
+			alSourcei(s_channels[source].alSource, AL_SOURCE_RELATIVE, ch->fixed_origin ? AL_TRUE : AL_FALSE);
+			if (ch->entchannel == CHAN_LESS_ATTEN)
+			{	// Reduced fall-off
+				alSourcef(s_channels[source].alSource, AL_REFERENCE_DISTANCE, DEFAULT_VOICE_REF_DISTANCE);
+			}
+			else
+			{
+				alSourcef(s_channels[source].alSource, AL_REFERENCE_DISTANCE, DEFAULT_REF_DISTANCE);
+			}
+			if (s_bEALFileLoaded)
+				UpdateEAXBuffer(ch);
+
+			alGetError();
+			alSourcePlay(s_channels[source].alSource);
+			if (alGetError() == AL_NO_ERROR)
+				s_channels[source].bPlaying = true;
+		}
+	}
+}
+
+
+
+
+
+void AL_UpdateRawSamples()
+{
+	ALuint buffer;
+	ALint size;
+	ALint processed;
+	ALint state;
+	int i,j,src;
+
+#ifdef _DEBUG
+	// Clear Open AL Error
+	alGetError();
+#endif
+
+	S_UpdateBackgroundTrack();
+
+	// Find out how many buffers have been processed (played) by the Source
+	alGetSourcei(s_channels[0].alSource, AL_BUFFERS_PROCESSED, &processed);
+
+	while (processed)
+	{
+		// Unqueue each buffer, determine the length of the buffer, and then delete it
+		alSourceUnqueueBuffers(s_channels[0].alSource, 1, &buffer);
+		alGetBufferi(buffer, AL_SIZE, &size);
+		alDeleteBuffers(1, &buffer);
+		
+		// Update sg.soundtime (+= number of samples played (number of bytes / 4))
+		s_soundtime += (size >> 2);
+
+		processed--;
+	}
+
+	// Add new data to a new Buffer and queue it on the Source
+	if (s_rawend > s_paintedtime)
+	{
+		size = (s_rawend - s_paintedtime)<<2;
+		if (size > (MAX_RAW_SAMPLES<<2))
+		{
+			OutputDebugString("UpdateRawSamples :- Raw Sample buffer has overflowed !!!\n");
+			size = MAX_RAW_SAMPLES<<2;
+			s_paintedtime = s_rawend - MAX_RAW_SAMPLES;
+		}
+
+		// Copy samples from RawSamples to audio buffer (sg.rawdata)
+		for (i = s_paintedtime, j = 0; i < s_rawend; i++, j+=2)
+		{
+			src = i & (MAX_RAW_SAMPLES - 1);
+			s_rawdata[j] = (short)(s_rawsamples[src].left>>8);
+			s_rawdata[j+1] = (short)(s_rawsamples[src].right>>8);
+		}
+
+		// Need to generate more than 1 buffer for music playback
+		// iterations = 0;
+		// largestBufferSize = (MAX_RAW_SAMPLES / 4) * 4
+		// while (size)
+		//	generate a buffer
+		//	if size > largestBufferSize
+		//		copy sg.rawdata + ((iterations * largestBufferSize)>>1) to buffer
+		//		size -= largestBufferSize
+		//	else
+		//		copy remainder
+		//		size = 0
+		//	queue the buffer
+		//  iterations++;
+
+		int iterations = 0;
+		int largestBufferSize = MAX_RAW_SAMPLES;	// in bytes (== quarter of Raw Samples data)
+		while (size)
+		{
+			alGenBuffers(1, &buffer);
+
+			if (size > largestBufferSize)
+			{
+				alBufferData(buffer, AL_FORMAT_STEREO16, (char*)(s_rawdata + ((iterations * largestBufferSize)>>1)), largestBufferSize, 22050);
+				size -= largestBufferSize;
+			}
+			else
+			{
+				alBufferData(buffer, AL_FORMAT_STEREO16, (char*)(s_rawdata + ((iterations * largestBufferSize)>>1)), size, 22050);
+				size = 0;
+			}
+
+			alSourceQueueBuffers(s_channels[0].alSource, 1, &buffer);
+			iterations++;
+		}
+
+		// Update paintedtime
+		s_paintedtime = s_rawend;
+		
+		// Check that the Source is actually playing
+		alGetSourcei(s_channels[0].alSource, AL_SOURCE_STATE, &state);
+		if (state != AL_PLAYING)
+		{
+			// Stopped playing ... due to buffer underrun
+			// Unqueue any buffers still on the Source (they will be PROCESSED), and restart playback
+			alGetSourcei(s_channels[0].alSource, AL_BUFFERS_PROCESSED, &processed);
+			while (processed)
+			{
+				alSourceUnqueueBuffers(s_channels[0].alSource, 1, &buffer);
+				processed--;
+				alGetBufferi(buffer, AL_SIZE, &size);
+				alDeleteBuffers(1, &buffer);
+		
+				// Update sg.soundtime (+= number of samples played (number of bytes / 4))
+				s_soundtime += (size >> 2);
+			}
+
+#ifdef _DEBUG
+			OutputDebugString("Restarting / Starting playback of Raw Samples\n");
+#endif
+			alSourcePlay(s_channels[0].alSource);
+		}
+	}
+
+#ifdef _DEBUG
+	if (alGetError() != AL_NO_ERROR)
+		OutputDebugString("OAL Error : UpdateRawSamples\n");
+#endif
+}
+
+
+int S_MP3PreProcessLipSync(channel_t *ch, short *data)
+{
+	int i;
+	int sample;
+	int sampleTotal = 0;
+
+	for (i = 0; i < 576; i += 100)
+	{
+		sample = LittleShort(data[i]);
+		sample = sample >> 8;
+		sampleTotal += sample * sample;
+	}
+
+	sampleTotal /= 6;
+
+	if (sampleTotal < ch->thesfx->fVolRange * s_lip_threshold_1->value)
+		sample = -1;
+	else if (sampleTotal < ch->thesfx->fVolRange * s_lip_threshold_2->value)
+		sample = 1;
+	else if (sampleTotal < ch->thesfx->fVolRange * s_lip_threshold_3->value)
+		sample = 2;
+	else if (sampleTotal < ch->thesfx->fVolRange * s_lip_threshold_4->value)
+		sample = 3;
+	else
+		sample = 4;
+
+	return sample;
+}
+
+
+void S_SetLipSyncs()
+{
+	int i;
+	unsigned int samples;
+	int currentTime, timePlayed;
+	channel_t *ch;
+#ifdef _DEBUG
+	char szString[256];
+#endif
+
+	currentTime = timeGetTime();
+
+	memset(s_entityWavVol, 0, sizeof(s_entityWavVol));
+
+	ch = s_channels + 1;
+	for (i = 1; i < s_numChannels; i++, ch++)
+	{
+		if ((!ch->thesfx)||(!ch->bPlaying))
+			continue;
+		
+		if ( ch->entchannel == CHAN_VOICE || ch->entchannel == CHAN_VOICE_ATTEN || ch->entchannel == CHAN_VOICE_GLOBAL )
+		{
+			// Calculate how much time has passed since the sample was started
+			timePlayed = currentTime - ch->iStartTime;
+
+			if (ch->thesfx->eSoundCompressionMethod==ct_16)
+			{
+				// There is a new computed lip-sync value every 1000 samples - so find out how many samples
+				// have been played and lookup the value in the lip-sync table
+				samples = (timePlayed * 22050) / 1000;
+
+				if (ch->thesfx->lipSyncData == NULL)
+				{
+#ifdef _DEBUG
+					sprintf(szString, "Missing lip-sync info. for %s\n", ch->thesfx->sSoundName);
+					OutputDebugString(szString);
+#endif
+				}
+				
+				if ((ch->thesfx->lipSyncData) && (samples < ch->thesfx->iSoundLengthInSamples))
+				{
+					s_entityWavVol[ ch->entnum ] = ch->thesfx->lipSyncData[samples / 1000];
+
+//					Com_Printf("%s,  total samples = %d, current sample = %d, lip type = %d \n", ch->thesfx->sSoundName, ch->thesfx->iSoundLengthInSamples, samples, s_entityWavVol[ ch->entnum ] );
+					if ( s_show->integer == 3 ) 
+					{
+						Com_Printf( "(%i)%i %s vol = %i\n", ch->entnum, i, ch->thesfx->sSoundName, s_entityWavVol[ ch->entnum ] );
+					}
+				}
+			}
+			else
+			{
+				// MP3
+
+				// There is a new computed lip-sync value every 576 samples - so find out how many samples
+				// have been played and lookup the value in the lip-sync table
+				samples = (timePlayed * 22050) / 1000;
+
+				if (ch->thesfx->lipSyncData == NULL)
+				{
+#ifdef _DEBUG
+					sprintf(szString, "Missing lip-sync info. for %s\n", ch->thesfx->sSoundName);
+					OutputDebugString(szString);
+#endif
+				}
+
+				if ((ch->thesfx->lipSyncData) && (samples < ch->thesfx->iSoundLengthInSamples))
+				{
+					s_entityWavVol[ ch->entnum ] = ch->thesfx->lipSyncData[(samples / 576) % 16];
+
+					if ( s_show->integer == 3 ) 
+					{
+						Com_Printf( "(%i)%i %s vol = %i\n", ch->entnum, i, ch->thesfx->sSoundName, s_entityWavVol[ ch->entnum ] );
+					}
+				}
+			}
+		}
+	}
+}
+
+
+/*
+===============================================================================
+
+console functions
+
+===============================================================================
+*/
+
+static void S_Play_f( void ) {
+	int 	i;
+	sfxHandle_t	h;
+	char name[256];
+	
+	i = 1;
+	while ( i<Cmd_Argc() ) {
+		if ( !strrchr(Cmd_Argv(i), '.') ) {
+			Com_sprintf( name, sizeof(name), "%s.wav", Cmd_Argv(1) );
+		} else {
+			Q_strncpyz( name, Cmd_Argv(i), sizeof(name) );
+		}
+		h = S_RegisterSound( name );
+		if( h ) {
+			S_StartLocalSound( h, CHAN_LOCAL_SOUND );
+		}
+		i++;
+	}
+}
+
+static void S_Music_f( void ) {
+	int		c;
+
+	c = Cmd_Argc();
+
+	if ( c == 2 ) {
+		S_StartBackgroundTrack( Cmd_Argv(1), Cmd_Argv(1), qfalse );
+	} else if ( c == 3 ) {
+		S_StartBackgroundTrack( Cmd_Argv(1), Cmd_Argv(2), qfalse );		
+	} else {
+		Com_Printf ("music <musicfile> [loopfile]\n");
+		return;
+	}
+}
+
+// a debug function, but no harm to leave in...
+//
+static void S_SetDynamicMusic_f(void)
+{
+	int c = Cmd_Argc();
+
+	if ( c == 2 ) 
+	{
+		if (bMusic_IsDynamic)
+		{
+			// don't need to check existance of 'explore' or 'action' music, since music wouldn't
+			//	be counted as dynamic if either were missing, but other types are optional...
+			//
+			if (!Q_stricmp(Cmd_Argv(1),"explore"))
+			{
+				S_SetDynamicMusicState( eBGRNDTRACK_EXPLORE );
+				return;
+			}
+			else
+			if (!Q_stricmp(Cmd_Argv(1),"action"))
+			{
+				S_SetDynamicMusicState( eBGRNDTRACK_ACTION );
+				return;
+			}
+			else
+			if (!Q_stricmp(Cmd_Argv(1),"silence"))
+			{
+				S_SetDynamicMusicState( eBGRNDTRACK_SILENCE );
+				return;
+			}
+			else
+			if (!Q_stricmp(Cmd_Argv(1),"boss"))
+			{
+				if (tMusic_Info[ eBGRNDTRACK_BOSS ].bExists)
+				{
+					S_SetDynamicMusicState( eBGRNDTRACK_BOSS );
+				}
+				else
+				{
+					Com_Printf("No 'boss' music defined in current dynamic set\n");
+				}
+				return;
+			}
+			else
+			if (!Q_stricmp(Cmd_Argv(1),"death"))
+			{
+				if (tMusic_Info[ eBGRNDTRACK_DEATH ].bExists)
+				{
+					S_SetDynamicMusicState( eBGRNDTRACK_DEATH );
+				}
+				else
+				{
+					Com_Printf("No 'death' music defined in current dynamic set\n");
+				}
+				return;
+			}
+		}
+		else
+		{
+			DynamicMusicInfoPrint();	// print "inactive" string
+			return;
+		}
+	}
+
+	// show usage...
+	//
+	Com_Printf("Usage: s_dynamic <explore/action/silence/boss/death>\n");
+	DynamicMusicInfoPrint();
+}
+
+
+// this table needs to be in-sync with the typedef'd enum "SoundCompressionMethod_t"...	-ste
+//
+static const char *sSoundCompressionMethodStrings[ct_NUMBEROF] = 
+{
+	"16b",	// ct_16
+	"mp3"	// ct_MP3
+};
+void S_SoundList_f( void ) {
+	int		i;
+	sfx_t	*sfx;
+	int		size, total;
+	int		iVariantCap = -1;	// for %d-inquiry stuff
+	int		iTotalBytes = 0;
+
+	qboolean bWavOnly = qfalse;
+	qboolean bShouldBeMP3 = qfalse;
+
+	if ( Cmd_Argc() == 2 ) 
+	{
+		if (!stricmp(Cmd_Argv(1), "shouldbeMP3"))
+		{
+			bShouldBeMP3 = qtrue;
+		}
+		else
+		if (!stricmp(Cmd_Argv(1), "wavonly"))
+		{
+			bWavOnly = qtrue;
+		}
+		else
+		{
+			if (!stricmp(Cmd_Argv(1), "1"))
+			{
+				iVariantCap = 1;
+			}
+			else
+			if (!stricmp(Cmd_Argv(1), "2"))
+			{
+				iVariantCap = 2;
+			}
+			else
+			if (!stricmp(Cmd_Argv(1), "3"))
+			{
+				iVariantCap = 3;
+			}
+		}		
+	}
+	else
+	{
+		Com_Printf("( additional (mutually exclusive) options available:\n'wavonly', 'ShouldBeMP3', '1'/'2'/'3' for %%d-variant capping )\n" );
+	}
+
+
+
+	total = 0;
+
+	Com_Printf("\n");
+	Com_Printf("                    InMemory?\n");
+	Com_Printf("                    |\n");
+	Com_Printf("                    |  LevelLastUsedOn\n");
+	Com_Printf("                    |  |\n");
+	Com_Printf("                    |  |\n");
+	Com_Printf(" Slot   Smpls Type  |  |   Name\n");
+//	Com_Printf(" Slot   Smpls Type  InMem?   Name\n");
+
+	for (sfx=s_knownSfx, i=0 ; i<s_numSfx ; i++, sfx++) 
+	{
+		extern cvar_t *cv_MP3overhead;
+		qboolean bMP3DumpOverride = bShouldBeMP3 && cv_MP3overhead && !sfx->bDefaultSound && !sfx->pMP3StreamHeader && sfx->pSoundData && (Z_Size(sfx->pSoundData) > cv_MP3overhead->integer);
+
+		if (bMP3DumpOverride || (!bShouldBeMP3 && (!bWavOnly || sfx->eSoundCompressionMethod == ct_16)))
+		{
+			qboolean bDumpThisOne = qtrue;
+			if (iVariantCap >= 1 && iVariantCap <= 3)
+			{
+				int iStrLen = strlen(sfx->sSoundName);
+				if (iStrLen > 2)	// crash-safety, jic.
+				{
+					char c  = sfx->sSoundName[iStrLen-1];
+					char c2 = sfx->sSoundName[iStrLen-2];
+					if (!isdigit(c2) // quick-avoid of stuff like "pain75"
+						&& isdigit(c) && atoi(va("%c",c)) > iVariantCap)
+					{
+						// need to see if this %d-variant should be omitted, in other words if there's a %1 version then skip this...
+						//
+						char sFindName[MAX_QPATH];
+						Q_strncpyz(sFindName,sfx->sSoundName,sizeof(sFindName));
+						sFindName[iStrLen-1] = '1';
+						int i2;
+						sfx_t *sfx2;
+						for (sfx2 = s_knownSfx, i2=0 ; i2<s_numSfx ; i2++, sfx2++) 
+						{
+							if (!stricmp(sFindName,sfx2->sSoundName))
+							{
+								bDumpThisOne = qfalse;	// found a %1-variant of this, so use variant capping and ignore this sfx_t
+								break;
+							}
+						}
+					}
+				}
+			}
+
+			size = sfx->iSoundLengthInSamples;
+			if (sfx->bDefaultSound)
+			{
+				Com_Printf("%5d Missing file: \"%s\"\n", i, sfx->sSoundName );
+			}
+			else
+			{
+				if (bDumpThisOne)
+				{
+					iTotalBytes += (sfx->bInMemory && sfx->pSoundData) ? Z_Size(sfx->pSoundData) : 0;
+					iTotalBytes += (sfx->bInMemory && sfx->pMP3StreamHeader) ? sizeof(*sfx->pMP3StreamHeader) : 0;
+					total		+=  sfx->bInMemory ? size : 0;				
+				}
+				Com_Printf("%5d %7i [%s] %s %2d %s", i, size, sSoundCompressionMethodStrings[sfx->eSoundCompressionMethod], sfx->bInMemory?"y":"n", sfx->iLastLevelUsedOn, sfx->sSoundName );
+
+				if (!bDumpThisOne)
+				{
+					Com_Printf("   ( Skipping, variant capped )");
+					//OutputDebugString(va("Variant capped: %s\n",sfx->sSoundName));
+				}
+				Com_Printf("\n");
+			}
+		}
+	}
+	Com_Printf(" Slot   Smpls Type  In? Lev  Name\n");
+
+
+	Com_Printf ("Total resident samples: %i %s ( not mem usage, see 'meminfo' ).\n", total, bWavOnly?"(WAV only)":"");
+	Com_Printf ("%d out of %d sfx_t slots used\n", s_numSfx, MAX_SFX);
+	Com_Printf ("%.2fMB bytes used when counting sfx_t->pSoundData + MP3 headers (if any)\n", (float)iTotalBytes / 1024.0f / 1024.0f);
+	S_DisplayFreeMemory();
+}
+
+
+/*
+===============================================================================
+
+background music functions
+
+===============================================================================
+*/
+
+int	FGetLittleLong( fileHandle_t f ) {
+	int		v;
+
+	FS_Read( &v, sizeof(v), f );
+
+	return LittleLong( v);
+}
+
+int	FGetLittleShort( fileHandle_t f ) {
+	short	v;
+
+	FS_Read( &v, sizeof(v), f );
+
+	return LittleShort( v);
+}
+
+// returns the length of the data in the chunk, or 0 if not found
+int S_FindWavChunk( fileHandle_t f, char *chunk ) {
+	char	name[5];
+	int		len;
+	int		r;
+
+	name[4] = 0;
+	len = 0;
+	r = FS_Read( name, 4, f );
+	if ( r != 4 ) {
+		return 0;
+	}
+	len = FGetLittleLong( f );
+	if ( len < 0 || len > 0xfffffff ) {
+		len = 0;
+		return 0;
+	}
+	len = (len + 1 ) & ~1;		// pad to word boundary
+//	s_nextWavChunk += len + 8;
+
+	if ( strcmp( name, chunk ) ) {
+		return 0;
+	}
+	return len;
+}
+
+// fixme: need to move this into qcommon sometime?, but too much stuff altered by other people and I won't be able
+//	to compile again for ages if I check that out...
+//
+// DO NOT replace this with a call to FS_FileExists, that's for checking about writing out, and doesn't work for this.
+//
+qboolean S_FileExists( const char *psFilename )
+{
+	fileHandle_t fhTemp;
+
+	FS_FOpenFileRead (psFilename, &fhTemp, qtrue);	// qtrue so I can fclose the handle without closing a PAK
+	if (!fhTemp) 
+		return qfalse;
+	
+	FS_FCloseFile(fhTemp);
+	return qtrue;
+}
+
+// some stuff for streaming MP3 files from disk (not pleasant, but nothing about MP3 is, other than compression ratios...)
+//
+static void MP3MusicStream_Reset(MusicInfo_t *pMusicInfo)
+{
+	pMusicInfo->iMP3MusicStream_DiskReadPos		= 0;
+	pMusicInfo->iMP3MusicStream_DiskWindowPos	= 0;
+}
+
+//
+// return is where the decoder should read from...
+//
+static byte *MP3MusicStream_ReadFromDisk(MusicInfo_t *pMusicInfo, int iReadOffset, int iReadBytesNeeded)
+{
+	if (iReadOffset < pMusicInfo->iMP3MusicStream_DiskWindowPos)
+	{
+		assert(0);											// should never happen
+		return pMusicInfo->byMP3MusicStream_DiskBuffer;		// ...but return something safe anyway
+	}
+
+	while (iReadOffset + iReadBytesNeeded > pMusicInfo->iMP3MusicStream_DiskReadPos)
+	{
+		int iBytesRead = FS_Read( pMusicInfo->byMP3MusicStream_DiskBuffer + (pMusicInfo->iMP3MusicStream_DiskReadPos - pMusicInfo->iMP3MusicStream_DiskWindowPos), iMP3MusicStream_DiskBytesToRead, pMusicInfo->s_backgroundFile );
+
+		pMusicInfo->iMP3MusicStream_DiskReadPos += iBytesRead;
+
+		if (iBytesRead != iMP3MusicStream_DiskBytesToRead)	// quietly ignore any requests to read past file end
+		{
+			break;		// we need to do this because the disk read code can't know how much source data we need to
+						//	read for a given number of requested output bytes, so we'll always be asking for too many
+		}
+	}
+
+	// if reached halfway point in buffer (approx 20k), backscroll it...
+	//
+	if (pMusicInfo->iMP3MusicStream_DiskReadPos - pMusicInfo->iMP3MusicStream_DiskWindowPos > iMP3MusicStream_DiskBufferSize/2)
+	{
+		int iMoveSrcOffset = iReadOffset - pMusicInfo->iMP3MusicStream_DiskWindowPos;		
+		int iMoveCount     = (pMusicInfo->iMP3MusicStream_DiskReadPos - pMusicInfo->iMP3MusicStream_DiskWindowPos ) - iMoveSrcOffset;
+		memmove( &pMusicInfo->byMP3MusicStream_DiskBuffer, &pMusicInfo->byMP3MusicStream_DiskBuffer[iMoveSrcOffset], iMoveCount);
+		pMusicInfo->iMP3MusicStream_DiskWindowPos += iMoveSrcOffset;
+	}
+
+	return pMusicInfo->byMP3MusicStream_DiskBuffer + (iReadOffset - pMusicInfo->iMP3MusicStream_DiskWindowPos);
+}
+
+
+// does NOT set s_rawend!...
+//
+static void S_StopBackgroundTrack_Actual( MusicInfo_t *pMusicInfo ) 
+{
+	if ( pMusicInfo->s_backgroundFile ) 
+	{
+		if ( pMusicInfo->s_backgroundFile != -1)
+		{
+			Sys_EndStreamedFile( pMusicInfo->s_backgroundFile );
+			FS_FCloseFile( pMusicInfo->s_backgroundFile );
+		}
+		pMusicInfo->s_backgroundFile = 0;	
+	}
+}
+
+static void FreeMusic( MusicInfo_t *pMusicInfo )
+{
+	if (pMusicInfo->pLoadedData)
+	{
+		Z_Free(pMusicInfo->pLoadedData);
+		pMusicInfo->pLoadedData		= NULL;		// these two MUST be kept as valid/invalid together
+		pMusicInfo->sLoadedDataName[0]= '\0';	// 
+		pMusicInfo->iLoadedDataLen	= 0;
+	}
+}
+
+// called only by snd_shutdown (from snd_restart or app exit)
+//
+void S_UnCacheDynamicMusic( void )
+{
+	for (int i = eBGRNDTRACK_DATABEGIN; i != eBGRNDTRACK_DATAEND; i++)
+	{
+		FreeMusic( &tMusic_Info[i]);
+	}
+}
+
+static qboolean S_StartBackgroundTrack_Actual( MusicInfo_t *pMusicInfo, qboolean qbDynamic, const char *intro, const char *loop )
+{
+	int		len;
+	char	dump[16];
+	char	name[MAX_QPATH];
+
+	Q_strncpyz( sMusic_BackgroundLoop, loop, sizeof( sMusic_BackgroundLoop ));	
+
+	Q_strncpyz( name, intro, sizeof( name ) - 4 );	// this seems to be so that if the filename hasn't got an extension
+													//	but doesn't have the room to append on either then you'll just
+													//	get the "soft" fopen() error, rather than the ERR_DROP you'd get
+													//	if COM_DefaultExtension didn't have room to add it on.
+	COM_DefaultExtension( name, sizeof( name ), ".mp3" );
+
+	// close the background track, but DON'T reset s_rawend (or remaining music bits that haven't been output yet will be cut off)
+	//
+	S_StopBackgroundTrack_Actual( pMusicInfo );
+
+	pMusicInfo->bIsMP3 = qfalse;
+
+	if ( !intro[0] ) {
+		return qfalse;
+	}
+
+	// new bit, if file requested is not same any loaded one (if prev was in-mem), ditch it...
+	//
+	if (Q_stricmp(name, pMusicInfo->sLoadedDataName))
+	{
+		FreeMusic( pMusicInfo );
+	}
+
+	if (!Q_stricmpn(name+(strlen(name)-4),".mp3",4))
+	{
+		if (pMusicInfo->pLoadedData)
+		{				
+			pMusicInfo->s_backgroundFile = -1;
+		}
+		else
+		{
+			pMusicInfo->iLoadedDataLen = FS_FOpenFileRead( name, &pMusicInfo->s_backgroundFile, qtrue );
+		}
+
+		if (!pMusicInfo->s_backgroundFile)
+		{
+			Com_Printf( S_COLOR_RED"Couldn't open music file %s\n", name );
+			return qfalse;
+		}
+
+		MP3MusicStream_Reset( pMusicInfo );
+
+		byte *pbMP3DataSegment	= NULL;
+		int iInitialMP3ReadSize = 8192;		// fairly arbitrary, whatever size this is then the decoder is allowed to
+											// scan up to halfway of it to find floating headers, so don't make it 
+											// too small. 8k works fine.
+		qboolean bMusicSucceeded = qfalse;
+		if (qbDynamic)
+		{	
+			if (!pMusicInfo->pLoadedData)
+			{
+				pMusicInfo->pLoadedData = (byte *) Z_Malloc(pMusicInfo->iLoadedDataLen, TAG_SND_DYNAMICMUSIC, qfalse);
+
+				S_ClearSoundBuffer();
+				FS_Read(pMusicInfo->pLoadedData, pMusicInfo->iLoadedDataLen, pMusicInfo->s_backgroundFile);
+				Q_strncpyz(pMusicInfo->sLoadedDataName, name, sizeof(pMusicInfo->sLoadedDataName));
+			}
+
+			// enable the rest of the code to work as before...
+			//
+			pbMP3DataSegment	= pMusicInfo->pLoadedData;
+			iInitialMP3ReadSize = pMusicInfo->iLoadedDataLen;
+		}
+		else
+		{
+			pbMP3DataSegment = MP3MusicStream_ReadFromDisk(pMusicInfo, 0, iInitialMP3ReadSize);
+		}
+
+		if (MP3_IsValid(name, pbMP3DataSegment, iInitialMP3ReadSize, qtrue /*bStereoDesired*/))
+		{
+			// init stream struct...
+			//
+			memset(&pMusicInfo->streamMP3_Bgrnd,0,sizeof(pMusicInfo->streamMP3_Bgrnd));
+			char *psError = C_MP3Stream_DecodeInit( &pMusicInfo->streamMP3_Bgrnd, pbMP3DataSegment, pMusicInfo->iLoadedDataLen,
+													dma.speed,
+													16,		// sfx->width * 8,
+													qtrue	// bStereoDesired
+													);
+
+
+			if (psError == NULL)
+			{
+				// init sfx struct & setup the few fields I actually need...
+				//
+				memset(	   &pMusicInfo->sfxMP3_Bgrnd,0,sizeof(pMusicInfo->sfxMP3_Bgrnd));
+				//			pMusicInfo->sfxMP3_Bgrnd.width					= 2;			// read by MP3_GetSamples()
+							pMusicInfo->sfxMP3_Bgrnd.iSoundLengthInSamples	= 0x7FFFFFFF;	// max possible +ve int, since music finishes when decoder stops
+							pMusicInfo->sfxMP3_Bgrnd.pMP3StreamHeader		= &pMusicInfo->streamMP3_Bgrnd;
+				Q_strncpyz( pMusicInfo->sfxMP3_Bgrnd.sSoundName, name, sizeof(pMusicInfo->sfxMP3_Bgrnd.sSoundName) );
+
+				if (qbDynamic)
+				{
+					MP3Stream_InitPlayingTimeFields ( &pMusicInfo->streamMP3_Bgrnd, name, pbMP3DataSegment, pMusicInfo->iLoadedDataLen, qtrue);
+				}
+
+				pMusicInfo->s_backgroundInfo.format		= WAV_FORMAT_MP3;	// not actually used this way, but just ensures we don't match one of the legit formats
+				pMusicInfo->s_backgroundInfo.channels	= 2;		// always, for our MP3s when used for music (else 1 for FX)
+				pMusicInfo->s_backgroundInfo.rate		= dma.speed;
+				pMusicInfo->s_backgroundInfo.width		= 2;		// always, for our MP3s
+				pMusicInfo->s_backgroundInfo.samples	= pMusicInfo->sfxMP3_Bgrnd.iSoundLengthInSamples;
+				pMusicInfo->s_backgroundSamples			= pMusicInfo->sfxMP3_Bgrnd.iSoundLengthInSamples;
+
+				memset(&pMusicInfo->chMP3_Bgrnd,0,sizeof(pMusicInfo->chMP3_Bgrnd));
+						pMusicInfo->chMP3_Bgrnd.thesfx = &pMusicInfo->sfxMP3_Bgrnd;
+				memcpy(&pMusicInfo->chMP3_Bgrnd.MP3StreamHeader, pMusicInfo->sfxMP3_Bgrnd.pMP3StreamHeader, sizeof(*pMusicInfo->sfxMP3_Bgrnd.pMP3StreamHeader));				
+
+				if (qbDynamic)
+				{					
+					if (pMusicInfo->s_backgroundFile != -1)
+					{
+						FS_FCloseFile( pMusicInfo->s_backgroundFile );
+						pMusicInfo->s_backgroundFile = -1;	// special mp3 value for "valid, but not a real file"
+					}
+				}
+				
+				pMusicInfo->bIsMP3 = qtrue;
+				bMusicSucceeded = qtrue;
+			}
+			else
+			{
+				Com_Printf(S_COLOR_RED"Error streaming file %s: %s\n", name, psError);
+				if (pMusicInfo->s_backgroundFile != -1)
+				{
+					FS_FCloseFile( pMusicInfo->s_backgroundFile );
+				}
+				pMusicInfo->s_backgroundFile = 0;
+			}
+		}
+		else
+		{
+			// MP3_IsValid() will already have printed any errors via Com_Printf at this point...
+			//			
+			if (pMusicInfo->s_backgroundFile != -1)
+			{
+				FS_FCloseFile( pMusicInfo->s_backgroundFile );
+			}
+			pMusicInfo->s_backgroundFile = 0;
+		}
+		
+		return bMusicSucceeded;
+	}
+	else	// not an mp3 file
+	{
+		//
+		// open up a wav file and get all the info
+		//
+		FS_FOpenFileRead( name, &pMusicInfo->s_backgroundFile, qtrue );
+		if ( !pMusicInfo->s_backgroundFile ) {
+			Com_Printf( S_COLOR_YELLOW "WARNING: couldn't open music file %s\n", name );
+			return qfalse;
+		}
+
+		// skip the riff wav header
+
+		FS_Read(dump, 12, pMusicInfo->s_backgroundFile);
+
+		if ( !S_FindWavChunk( pMusicInfo->s_backgroundFile, "fmt " ) ) {
+			Com_Printf( S_COLOR_YELLOW "WARNING: No fmt chunk in %s\n", name );
+			FS_FCloseFile( pMusicInfo->s_backgroundFile );
+			pMusicInfo->s_backgroundFile = 0;
+			return qfalse;
+		}
+
+		// save name for soundinfo
+		pMusicInfo->s_backgroundInfo.format = FGetLittleShort( pMusicInfo->s_backgroundFile );
+		pMusicInfo->s_backgroundInfo.channels = FGetLittleShort( pMusicInfo->s_backgroundFile );
+		pMusicInfo->s_backgroundInfo.rate = FGetLittleLong( pMusicInfo->s_backgroundFile );
+		FGetLittleLong(  pMusicInfo->s_backgroundFile );
+		FGetLittleShort(  pMusicInfo->s_backgroundFile );
+		pMusicInfo->s_backgroundInfo.width = FGetLittleShort( pMusicInfo->s_backgroundFile ) / 8;
+
+		if ( pMusicInfo->s_backgroundInfo.format != WAV_FORMAT_PCM ) {
+			FS_FCloseFile( pMusicInfo->s_backgroundFile );
+			pMusicInfo->s_backgroundFile = 0;
+			Com_Printf(S_COLOR_YELLOW "WARNING: Not a microsoft PCM format wav: %s\n", name);
+			return qfalse;
+		}
+
+		if ( pMusicInfo->s_backgroundInfo.channels != 2 || pMusicInfo->s_backgroundInfo.rate != 22050 ) {
+			Com_Printf(S_COLOR_YELLOW "WARNING: music file %s is not 22k stereo\n", name );
+		}
+
+		if ( ( len = S_FindWavChunk( pMusicInfo->s_backgroundFile, "data" ) ) == 0 ) {
+			FS_FCloseFile( pMusicInfo->s_backgroundFile );
+			pMusicInfo->s_backgroundFile = 0;
+			Com_Printf(S_COLOR_YELLOW "WARNING: No data chunk in %s\n", name);
+			return qfalse;
+		}
+
+		pMusicInfo->s_backgroundInfo.samples = len / (pMusicInfo->s_backgroundInfo.width * pMusicInfo->s_backgroundInfo.channels);
+
+		pMusicInfo->s_backgroundSamples = pMusicInfo->s_backgroundInfo.samples;
+
+		//
+		// start the background streaming
+		//
+		Sys_BeginStreamedFile( pMusicInfo->s_backgroundFile, 0x10000 );
+	}
+
+	return qtrue;
+}
+
+
+static void S_SwitchDynamicTracks( MusicState_e eOldState, MusicState_e eNewState, qboolean bNewTrackStartsFullVolume )
+{
+	// copy old track into fader...
+	//
+	tMusic_Info[ eBGRNDTRACK_FADE ] = tMusic_Info[ eOldState ];
+//	tMusic_Info[ eBGRNDTRACK_FADE ].bActive = qtrue;	// inherent
+//	tMusic_Info[ eBGRNDTRACK_FADE ].bExists = qtrue;	// inherent
+	tMusic_Info[ eBGRNDTRACK_FADE ].iXFadeVolumeSeekTime= Sys_Milliseconds();
+	tMusic_Info[ eBGRNDTRACK_FADE ].iXFadeVolumeSeekTo	= 0;
+	//
+	// ... and deactivate...
+	//
+	tMusic_Info[ eOldState ].bActive = qfalse;
+	//
+	// set new track to either full volume or fade up...
+	//
+	tMusic_Info[eNewState].bActive				= qtrue;
+	tMusic_Info[eNewState].iXFadeVolumeSeekTime	= Sys_Milliseconds();
+	tMusic_Info[eNewState].iXFadeVolumeSeekTo	= 255;
+	tMusic_Info[eNewState].iXFadeVolume			= bNewTrackStartsFullVolume ? 255 : 0;
+
+	eMusic_StateActual = eNewState;
+
+
+	if (s_debugdynamic->integer)
+	{
+		LPCSTR	psNewStateString = Music_BaseStateToString( eNewState, qtrue );
+				psNewStateString = psNewStateString?psNewStateString:"<unknown>";
+
+		Com_Printf( S_COLOR_MAGENTA "S_SwitchDynamicTracks( \"%s\" )\n", psNewStateString );
+	}
+}
+
+// called by both the config-string parser and the console-command state-changer...
+//
+// This either changes the music right now (copying track structures etc), or leaves the new state as pending
+//	so it gets picked up by the general music player if in a transition that can't be overridden...
+//
+static void S_SetDynamicMusicState( MusicState_e eNewState )
+{
+	if (eMusic_StateRequest != eNewState)
+	{
+		eMusic_StateRequest  = eNewState;
+
+		if (s_debugdynamic->integer)
+		{
+			LPCSTR	psNewStateString = Music_BaseStateToString( eNewState, qtrue );
+					psNewStateString = psNewStateString?psNewStateString:"<unknown>";
+
+			Com_Printf( S_COLOR_MAGENTA "S_SetDynamicMusicState( Request: \"%s\" )\n", psNewStateString );
+		}		
+	}
+}
+
+
+static void S_HandleDynamicMusicStateChange( void )
+{
+	if (eMusic_StateRequest != eMusic_StateActual)
+	{
+		// check whether or not the new request can be honoured, given what's currently playing...
+		//
+		if (Music_StateCanBeInterrupted( eMusic_StateActual, eMusic_StateRequest ))
+		{
+			LP_MP3STREAM pMP3StreamActual = &tMusic_Info[ eMusic_StateActual ].chMP3_Bgrnd.MP3StreamHeader;
+
+			switch (eMusic_StateRequest)
+			{
+				case eBGRNDTRACK_EXPLORE:	// ... from action or silence
+				{
+					switch (eMusic_StateActual)
+					{
+						case eBGRNDTRACK_ACTION:	// action->explore
+						{
+							// find the transition track to play, and the entry point for explore when we get there,
+							//	and also see if we're at a permitted exit point to switch at all...
+							//
+							float fPlayingTimeElapsed = MP3Stream_GetPlayingTimeInSeconds( pMP3StreamActual ) - MP3Stream_GetRemainingTimeInSeconds( pMP3StreamActual );
+
+							// supply:
+							//
+							// playing point in float seconds
+							// enum of track being queried
+							//
+							// get:
+							//
+							// enum of transition track to switch to
+							// float time of entry point of new track *after* transition
+
+							MusicState_e	eTransition;
+							float			fNewTrackEntryTime = 0.0f;
+							if (Music_AllowedToTransition( fPlayingTimeElapsed, eBGRNDTRACK_ACTION, &eTransition, &fNewTrackEntryTime))
+							{
+								S_SwitchDynamicTracks( eMusic_StateActual, eTransition, qfalse );	// qboolean bNewTrackStartsFullVolume
+
+								tMusic_Info[eTransition].Rewind();
+								tMusic_Info[eTransition].bTrackSwitchPending	= qtrue;
+								tMusic_Info[eTransition].eTS_NewState			= eMusic_StateRequest;
+								tMusic_Info[eTransition].fTS_NewTime			= fNewTrackEntryTime;
+							}
+						}
+						break;						
+
+						case eBGRNDTRACK_SILENCE:	// silence->explore
+						{
+							S_SwitchDynamicTracks( eMusic_StateActual, eMusic_StateRequest, qfalse );	// qboolean bNewTrackStartsFullVolume
+
+//							float fEntryTime = Music_GetRandomEntryTime( eMusic_StateRequest );
+//							tMusic_Info[ eMusic_StateRequest ].SeekTo(fEntryTime);
+							tMusic_Info[ eMusic_StateRequest ].Rewind();
+						}
+						break;
+
+						default:	// trying to transition from some state I wasn't aware you could transition from (shouldn't happen), so ignore
+						{
+							assert(0); 
+							S_SwitchDynamicTracks( eMusic_StateActual, eBGRNDTRACK_SILENCE, qfalse );	// qboolean bNewTrackStartsFullVolume
+						}
+						break;
+					}
+				}
+				break;
+
+				case eBGRNDTRACK_SILENCE:	// from explore or action
+				{
+					switch (eMusic_StateActual)
+					{
+						case eBGRNDTRACK_ACTION:	// action->silence
+						case eBGRNDTRACK_EXPLORE:	// explore->silence
+						{
+							// find the transition track to play, and the entry point for explore when we get there,
+							//	and also see if we're at a permitted exit point to switch at all...
+							//
+							float fPlayingTimeElapsed = MP3Stream_GetPlayingTimeInSeconds( pMP3StreamActual ) - MP3Stream_GetRemainingTimeInSeconds( pMP3StreamActual );
+
+							MusicState_e	eTransition;
+							float			fNewTrackEntryTime = 0.0f;
+							if (Music_AllowedToTransition( fPlayingTimeElapsed, eMusic_StateActual, &eTransition, &fNewTrackEntryTime))
+							{
+								S_SwitchDynamicTracks( eMusic_StateActual, eTransition, qfalse );	// qboolean bNewTrackStartsFullVolume
+
+								tMusic_Info[eTransition].Rewind();
+								tMusic_Info[eTransition].bTrackSwitchPending	= qtrue;
+								tMusic_Info[eTransition].eTS_NewState			= eMusic_StateRequest;
+								tMusic_Info[eTransition].fTS_NewTime			= 0.0f;	//fNewTrackEntryTime;  irrelevant when switching to silence
+							}
+						}
+						break;
+
+						default:		// some unhandled type switching to silence
+							assert(0);	// fall through since boss case just does silence->switch anyway
+
+						case eBGRNDTRACK_BOSS:	// boss->silence
+						{
+							S_SwitchDynamicTracks( eMusic_StateActual, eBGRNDTRACK_SILENCE, qfalse );	// qboolean bNewTrackStartsFullVolume
+						}
+						break;
+					}
+				}
+				break;
+
+				case eBGRNDTRACK_ACTION:	// anything->action
+				{
+					switch (eMusic_StateActual)
+					{
+						case eBGRNDTRACK_SILENCE:	// silence->action
+						{
+							S_SwitchDynamicTracks( eMusic_StateActual, eMusic_StateRequest, qfalse );	// qboolean bNewTrackStartsFullVolume
+							tMusic_Info[ eMusic_StateRequest ].Rewind();
+						}
+						break;
+
+						default:	// !silence->action
+						{
+							S_SwitchDynamicTracks( eMusic_StateActual, eMusic_StateRequest, qtrue );	// qboolean bNewTrackStartsFullVolume
+							float fEntryTime = Music_GetRandomEntryTime( eMusic_StateRequest );
+							tMusic_Info[ eMusic_StateRequest ].SeekTo(fEntryTime);
+						}
+						break;
+					}
+				}
+				break;
+
+				case eBGRNDTRACK_BOSS:
+				{	
+					S_SwitchDynamicTracks( eMusic_StateActual, eMusic_StateRequest, qfalse );	// qboolean bNewTrackStartsFullVolume
+					//
+					// ( no need to fast forward or rewind, boss track is only entered into once, at start, and can't exit )
+					//
+				}
+				break;
+
+				case eBGRNDTRACK_DEATH:
+				{	
+					S_SwitchDynamicTracks( eMusic_StateActual, eMusic_StateRequest, qtrue );	// qboolean bNewTrackStartsFullVolume
+					//
+					// ( no need to fast forward or rewind, death track is only entered into once, at start, and can't exit or loop)
+					//
+				}
+				break;
+
+				default: assert(0); break;	// unknown new mode request, so just ignore it
+			}
+		}
+	}
+}
+
+
+
+static char gsIntroMusic[MAX_QPATH]={0};
+static char gsLoopMusic [MAX_QPATH]={0};
+
+void S_RestartMusic( void ) 
+{
+	if (s_soundStarted && !s_soundMuted )
+	{
+		//if (gsIntroMusic[0] || gsLoopMusic[0])	// dont test this anymore (but still *use* them), they're blank for JK2 dynamic-music levels anyway
+		{
+			MusicState_e ePrevState	= eMusic_StateRequest;
+			S_StartBackgroundTrack( gsIntroMusic, gsLoopMusic, qfalse );	// ( default music start will set the state to EXPLORE )
+			S_SetDynamicMusicState( ePrevState );					// restore to prev state
+		}
+	}
+}
+
+// Basic logic here is to see if the intro file specified actually exists, and if so, then it's not dynamic music,
+//	When called by the cgame start it loads up, then stops the playback (because of stutter issues), so that when the
+//	actual snapshot is received and the real play request is processed the data has already been loaded so will be quicker.
+//
+// to be honest, although the code still plays WAVs some of the file-check logic only works for MP3s, so if you ever want
+//	to use WAV music you'll have to do some tweaking below (but I've got other things to do so it'll have to wait - Ste)
+//
+void S_StartBackgroundTrack( const char *intro, const char *loop, qboolean bCalledByCGameStart )
+{
+	bMusic_IsDynamic = qfalse;
+
+	if (!s_soundStarted)
+	{	//we have no sound, so don't even bother trying
+		return;
+	}
+
+	if ( !intro ) {
+		intro = "";
+	}
+	if ( !loop || !loop[0] ) {
+		loop = intro;
+	}
+
+	Q_strncpyz(gsIntroMusic,intro, sizeof(gsIntroMusic));
+	Q_strncpyz(gsLoopMusic, loop,  sizeof(gsLoopMusic));
+
+	char sNameIntro[MAX_QPATH];
+	char sNameLoop [MAX_QPATH];
+	Q_strncpyz(sNameIntro,	intro,	sizeof(sNameIntro));
+	Q_strncpyz(sNameLoop,	loop,	sizeof(sNameLoop));
+
+	COM_DefaultExtension( sNameIntro, sizeof( sNameIntro ), ".mp3" );
+	COM_DefaultExtension( sNameLoop,  sizeof( sNameLoop),	".mp3" );
+
+	// if dynamic music not allowed, then just stream the explore music instead of playing dynamic...
+	//
+	if (!s_allowDynamicMusic->integer && Music_DynamicDataAvailable(intro))	// "intro", NOT "sName" (i.e. don't use version with ".mp3" extension)
+	{
+		LPCSTR psMusicName = Music_GetFileNameForState( eBGRNDTRACK_DATABEGIN );
+		if (psMusicName && S_FileExists( psMusicName ))
+		{
+			Q_strncpyz(sNameIntro,psMusicName,sizeof(sNameIntro));
+			Q_strncpyz(sNameLoop, psMusicName,sizeof(sNameLoop ));
+		}
+	}
+
+	// conceptually we always play the 'intro'[/sName] track, intro-to-loop transition is handled in UpdateBackGroundTrack().
+	//
+	if ( (strstr(sNameIntro,"/") && S_FileExists( sNameIntro )) )	// strstr() check avoids extra file-exists check at runtime if reverting from streamed music to dynamic since literal files all need at least one slash in their name (eg "music/blah")
+	{
+		LPCSTR psLoopName = S_FileExists( sNameLoop ) ? sNameLoop : sNameIntro;
+		Com_DPrintf("S_StartBackgroundTrack: Found/using non-dynamic music track '%s' (loop: '%s')\n", sNameIntro, psLoopName);
+		S_StartBackgroundTrack_Actual( &tMusic_Info[eBGRNDTRACK_NONDYNAMIC], bMusic_IsDynamic, sNameIntro, psLoopName );
+	}
+	else
+	{
+		if (Music_DynamicDataAvailable(intro))	// "intro", NOT "sName" (i.e. don't use version with ".mp3" extension)
+		{
+			extern const char *Music_GetLevelSetName(void);
+			Q_strncpyz(sInfoOnly_CurrentDynamicMusicSet, Music_GetLevelSetName(), sizeof(sInfoOnly_CurrentDynamicMusicSet));
+			for (int i = eBGRNDTRACK_DATABEGIN; i != eBGRNDTRACK_DATAEND; i++)
+			{
+				qboolean bOk = qfalse;
+				LPCSTR psMusicName = Music_GetFileNameForState( (MusicState_e) i);
+				if (psMusicName && (!Q_stricmp(tMusic_Info[i].sLoadedDataName, psMusicName) || S_FileExists( psMusicName )) )
+				{
+					bOk = S_StartBackgroundTrack_Actual( &tMusic_Info[i], qtrue, psMusicName, loop );
+				}
+				
+				tMusic_Info[i].bExists = bOk;
+
+				if (!tMusic_Info[i].bExists)
+				{
+					FreeMusic( &tMusic_Info[i] );
+				}
+			}
+
+			//
+			// default all tracks to OFF first (and set any other vars)
+			//
+			for (i=0; i<eBGRNDTRACK_NUMBEROF; i++)
+			{
+				tMusic_Info[i].bActive				= qfalse;
+				tMusic_Info[i].bTrackSwitchPending	= qfalse;
+				tMusic_Info[i].fSmoothedOutVolume	= 0.25f;
+			}
+
+			if (tMusic_Info[eBGRNDTRACK_EXPLORE].bExists &&
+				tMusic_Info[eBGRNDTRACK_ACTION ].bExists
+				)
+			{
+				Com_DPrintf("S_StartBackgroundTrack: Found dynamic music tracks\n");
+				bMusic_IsDynamic = qtrue;
+
+				//
+				// ... then start the default music state...
+				//
+				eMusic_StateActual = eMusic_StateRequest = eBGRNDTRACK_EXPLORE;
+
+				MusicInfo_t *pMusicInfo = &tMusic_Info[ eMusic_StateActual ];
+
+				pMusicInfo->bActive				= qtrue;
+				pMusicInfo->iXFadeVolumeSeekTime= Sys_Milliseconds();
+				pMusicInfo->iXFadeVolumeSeekTo	= 255;
+				pMusicInfo->iXFadeVolume		= 0;			
+				
+	//#ifdef _DEBUG
+	//			float fRemaining = MP3Stream_GetPlayingTimeInSeconds( &pMusicInfo->chMP3_Bgrnd.MP3StreamHeader);
+	//#endif
+			}
+			else
+			{
+				Com_Printf( S_COLOR_RED "Dynamic music did not have both 'action' and 'explore' versions, inhibiting...\n");
+				S_StopBackgroundTrack();
+			}
+		}
+		else
+		{
+			if (sNameIntro[0]!='.')	// blank name with ".mp3" or whatever attached - no error print out
+			{
+				Com_Printf( S_COLOR_RED "Unable to find music \"%s\" as explicit track or dynamic music entry!\n",sNameIntro);
+				S_StopBackgroundTrack();
+			}
+		}
+	}	
+
+	if (bCalledByCGameStart)
+	{
+		S_StopBackgroundTrack();
+	}
+}
+
+void S_StopBackgroundTrack( void )
+{
+	for (int i=0; i<eBGRNDTRACK_NUMBEROF; i++)
+	{
+		S_StopBackgroundTrack_Actual( &tMusic_Info[i] );
+	}
+
+	s_rawend = 0;
+}
+
+
+
+// qboolean return is true only if we're changing from a streamed intro to a dynamic loop...
+//
+static qboolean S_UpdateBackgroundTrack_Actual( MusicInfo_t *pMusicInfo, qboolean bFirstOrOnlyMusicTrack, float fDefaultVolume) 
+{
+	int		bufferSamples;
+	int		fileSamples;
+	byte	raw[30000];		// just enough to fit in a mac stack frame  (note that MP3 doesn't use full size of it)
+	int		fileBytes;
+	int		r;
+
+	float fMasterVol = fDefaultVolume; // s_musicVolume->value;
+
+	if (bMusic_IsDynamic)
+	{
+		// step xfade volume...
+		//
+		if ( pMusicInfo->iXFadeVolume != pMusicInfo->iXFadeVolumeSeekTo )
+		{
+			int iFadeMillisecondsElapsed = Sys_Milliseconds() - pMusicInfo->iXFadeVolumeSeekTime;
+
+			if (iFadeMillisecondsElapsed > (fDYNAMIC_XFADE_SECONDS * 1000))
+			{
+				pMusicInfo->iXFadeVolume = pMusicInfo->iXFadeVolumeSeekTo;
+			}
+			else
+			{
+				pMusicInfo->iXFadeVolume = (int) (255.0f * ((float)iFadeMillisecondsElapsed/(fDYNAMIC_XFADE_SECONDS * 1000.0f)));
+				if (pMusicInfo->iXFadeVolumeSeekTo == 0)	// bleurgh
+					pMusicInfo->iXFadeVolume = 255 - pMusicInfo->iXFadeVolume;
+			}
+		}
+		fMasterVol *= (float)((float)pMusicInfo->iXFadeVolume / 255.0f);
+	}
+
+// this is to work around an obscure issue to do with sliding decoder windows and amounts being requested, since the
+//	original MP3 stream-decoder wrapper was designed to work with audio-paintbuffer sized pieces... Basically 30000
+//	is far too big for the window decoder to handle in one request because of the time-travel issue associated with
+//	normal sfx buffer painting, and allowing sufficient sliding room, even though the music file never goes back in time.
+//
+#define SIZEOF_RAW_BUFFER_FOR_MP3 4096
+#define RAWSIZE (pMusicInfo->bIsMP3?SIZEOF_RAW_BUFFER_FOR_MP3:sizeof(raw))
+
+	if ( !pMusicInfo->s_backgroundFile ) {
+		return qfalse;
+	}	
+
+	pMusicInfo->fSmoothedOutVolume = (pMusicInfo->fSmoothedOutVolume + fMasterVol)/2.0f;
+//	OutputDebugString(va("%f\n",pMusicInfo->fSmoothedOutVolume));
+
+	// don't bother playing anything if musicvolume is 0
+	if ( pMusicInfo->fSmoothedOutVolume <= 0 ) {
+		return qfalse;
+	}
+
+	// see how many samples should be copied into the raw buffer
+	if ( s_rawend < s_soundtime ) {
+		s_rawend = s_soundtime;
+	}
+
+	while ( s_rawend < s_soundtime + MAX_RAW_SAMPLES ) 
+	{
+		bufferSamples = MAX_RAW_SAMPLES - (s_rawend - s_soundtime);
+
+		// decide how much data needs to be read from the file
+		fileSamples = bufferSamples * pMusicInfo->s_backgroundInfo.rate / dma.speed;
+
+		// don't try and read past the end of the file
+		if ( fileSamples > pMusicInfo->s_backgroundSamples ) {
+			fileSamples = pMusicInfo->s_backgroundSamples;
+		}
+
+		// our max buffer size
+		fileBytes = fileSamples * (pMusicInfo->s_backgroundInfo.width * pMusicInfo->s_backgroundInfo.channels);
+		if (fileBytes > RAWSIZE ) {
+			fileBytes = RAWSIZE;
+			fileSamples = fileBytes / (pMusicInfo->s_backgroundInfo.width * pMusicInfo->s_backgroundInfo.channels);
+		}
+
+		qboolean qbForceFinish = qfalse;
+		if (pMusicInfo->bIsMP3)
+		{
+			int iStartingSampleNum = pMusicInfo->chMP3_Bgrnd.thesfx->iSoundLengthInSamples - pMusicInfo->s_backgroundSamples;	// but this IS relevant
+			// Com_Printf(S_COLOR_YELLOW "Requesting MP3 samples: sample %d\n",iStartingSampleNum);
+
+
+			if (pMusicInfo->s_backgroundFile == -1)
+			{
+				// in-mem...
+				//
+				qbForceFinish = (MP3Stream_GetSamples( &pMusicInfo->chMP3_Bgrnd, iStartingSampleNum, fileBytes/2, (short*) raw, qtrue ))?qfalse:qtrue;				
+
+				//Com_Printf(S_COLOR_YELLOW "Music time remaining: %f seconds\n", MP3Stream_GetRemainingTimeInSeconds( &pMusicInfo->chMP3_Bgrnd.MP3StreamHeader ));				
+			}
+			else
+			{
+				// streaming an MP3 file instead... (note that the 'fileBytes' request size isn't that relevant for MP3s, 
+				//										since code here can't know how much the MP3 needs to decompress)
+				//
+				byte *pbScrolledStreamData = MP3MusicStream_ReadFromDisk(pMusicInfo, pMusicInfo->chMP3_Bgrnd.MP3StreamHeader.iSourceReadIndex, fileBytes);
+
+				pMusicInfo->chMP3_Bgrnd.MP3StreamHeader.pbSourceData = pbScrolledStreamData - pMusicInfo->chMP3_Bgrnd.MP3StreamHeader.iSourceReadIndex;
+
+				qbForceFinish = (MP3Stream_GetSamples( &pMusicInfo->chMP3_Bgrnd, iStartingSampleNum, fileBytes/2, (short*) raw, qtrue ))?qfalse:qtrue;
+			}
+		}
+		else
+		{
+			// streaming a WAV off disk...
+			//
+			r = Sys_StreamedRead( raw, 1, fileBytes, pMusicInfo->s_backgroundFile );
+			if ( r != fileBytes ) {
+				Com_Printf(S_COLOR_RED"StreamedRead failure on music track\n");
+				S_StopBackgroundTrack();
+				return qfalse;
+			}
+
+			// byte swap if needed (do NOT do for MP3 decoder, that has an internal big/little endian handler)
+			//
+			S_ByteSwapRawSamples( fileSamples, pMusicInfo->s_backgroundInfo.width, pMusicInfo->s_backgroundInfo.channels, raw );
+		}
+
+		// add to raw buffer
+		S_RawSamples(	fileSamples, pMusicInfo->s_backgroundInfo.rate, 
+						pMusicInfo->s_backgroundInfo.width, pMusicInfo->s_backgroundInfo.channels, raw, pMusicInfo->fSmoothedOutVolume,
+						bFirstOrOnlyMusicTrack
+					);
+
+		pMusicInfo->s_backgroundSamples -= fileSamples;
+		if ( !pMusicInfo->s_backgroundSamples || qbForceFinish ) 
+		{
+			// loop the music, or play the next piece if we were on the intro...
+			//	(but not for dynamic, that can only be used for loop music)
+			//
+			if (bMusic_IsDynamic)	// needs special logic for this, different call
+			{
+				pMusicInfo->Rewind();
+			}
+			else
+			{
+				// for non-dynamic music we need to check if "sMusic_BackgroundLoop" is an actual filename,
+				//	or if it's a dynamic music specifier (which can't literally exist), in which case it should set
+				//	a return flag then exit...
+				//
+				char sTestName[MAX_QPATH*2];// *2 so COM_DefaultExtension doesn't do an ERR_DROP if there was no space
+											//	for an extension, since this is a "soft" test				
+				Q_strncpyz( sTestName, sMusic_BackgroundLoop, sizeof(sTestName));
+				COM_DefaultExtension(sTestName, sizeof(sTestName), ".mp3");
+
+				if (S_FileExists( sTestName ))
+				{
+					S_StartBackgroundTrack_Actual( pMusicInfo, qfalse, sMusic_BackgroundLoop, sMusic_BackgroundLoop );
+				}
+				else
+				{
+					// proposed file doesn't exist, but this may be a dynamic track we're wanting to loop, 
+					//	so exit with a special flag...
+					//
+					return qtrue;
+				}
+			}
+			if ( !pMusicInfo->s_backgroundFile ) 
+			{
+				return qfalse;		// loop failed to restart
+			}
+		}
+	}
+
+#undef SIZEOF_RAW_BUFFER_FOR_MP3
+#undef RAWSIZE
+
+	return qfalse;
+}
+
+
+// used to be just for dynamic, but now even non-dynamic music has to know whether it should be silent or not...
+//
+static LPCSTR S_Music_GetRequestedState(void)
+{
+	int iStringOffset = cl.gameState.stringOffsets[CS_DYNAMIC_MUSIC_STATE];
+	if (iStringOffset)
+	{
+		LPCSTR psCommand = cl.gameState.stringData+iStringOffset; 
+
+		return psCommand;
+	}
+	
+	return NULL;
+}
+
+
+// scan the configstring to see if there's been a state-change requested...
+// (note that even if the state doesn't change it still gets here, so do a same-state check for applying)
+//
+// then go on to do transition handling etc...
+//
+static void S_CheckDynamicMusicState(void)
+{
+	LPCSTR psCommand = S_Music_GetRequestedState();
+
+	if (psCommand)
+	{
+		MusicState_e eNewState;
+
+		if ( !Q_stricmpn( psCommand, "silence", 7) )
+		{				
+			eNewState = eBGRNDTRACK_SILENCE;
+		}
+		else if ( !Q_stricmpn( psCommand, "action", 6) )
+		{
+			eNewState = eBGRNDTRACK_ACTION;
+		}
+		else if ( !Q_stricmpn( psCommand, "boss", 4) )
+		{
+			// special case, boss music is optional and may not be defined...
+			//
+			if (tMusic_Info[ eBGRNDTRACK_BOSS ].bExists)
+			{
+				eNewState = eBGRNDTRACK_BOSS;
+			}
+			else
+			{
+				// ( leave it playing current track )
+				//
+				eNewState = eMusic_StateActual;
+			}
+		}
+		else if ( !Q_stricmpn( psCommand, "death", 5) )
+		{
+			// special case, death music is optional and may not be defined...
+			//
+			if (tMusic_Info[ eBGRNDTRACK_DEATH ].bExists)
+			{
+				eNewState = eBGRNDTRACK_DEATH;
+			}
+			else
+			{
+				// ( leave it playing current track, typically either boss or action )
+				//
+				eNewState = eMusic_StateActual;
+			}
+		}
+		else
+		{
+			// seems a reasonable default...
+			//
+			eNewState = eBGRNDTRACK_EXPLORE;
+		}
+		
+		S_SetDynamicMusicState( eNewState );
+	}
+
+	S_HandleDynamicMusicStateChange();
+}
+
+static void S_UpdateBackgroundTrack( void )
+{
+	if (bMusic_IsDynamic)
+	{
+		if (s_debugdynamic->integer == 2)
+		{
+			DynamicMusicInfoPrint();
+		}
+				
+		S_CheckDynamicMusicState();
+		
+		if (eMusic_StateActual != eBGRNDTRACK_SILENCE)
+		{
+			MusicInfo_t *pMusicInfoCurrent = &tMusic_Info[ (eMusic_StateActual == eBGRNDTRACK_FADE)?eBGRNDTRACK_EXPLORE:eMusic_StateActual ];
+			MusicInfo_t *pMusicInfoFadeOut = &tMusic_Info[ eBGRNDTRACK_FADE ];
+
+			if ( pMusicInfoCurrent->s_backgroundFile == -1)
+			{
+				int iRawEnd = s_rawend;
+				S_UpdateBackgroundTrack_Actual( pMusicInfoCurrent, qtrue, s_musicVolume->value );
+
+	/*			static int iPrevFrontVol = 0;
+				if (iPrevFrontVol != pMusicInfoCurrent->iXFadeVolume)
+				{
+					iPrevFrontVol  = pMusicInfoCurrent->iXFadeVolume;
+					Com_Printf("front vol = %d\n",pMusicInfoCurrent->iXFadeVolume);
+				}
+	*/
+				if (pMusicInfoFadeOut->bActive)
+				{
+					s_rawend = iRawEnd;
+					S_UpdateBackgroundTrack_Actual( pMusicInfoFadeOut, qfalse, s_musicVolume->value );	// inactive-checked internally
+	/*
+					static int iPrevFadeVol = 0;
+					if (iPrevFadeVol != pMusicInfoFadeOut->iXFadeVolume)
+					{
+						iPrevFadeVol  = pMusicInfoFadeOut->iXFadeVolume;
+						Com_Printf("fade vol = %d\n",pMusicInfoFadeOut->iXFadeVolume);
+					}
+	*/
+					//
+					// only do this for the fader!...
+					//
+					if (pMusicInfoFadeOut->iXFadeVolume == 0)
+					{
+						pMusicInfoFadeOut->bActive = qfalse;
+					}
+				}
+				
+				float fRemainingTimeInSeconds = MP3Stream_GetRemainingTimeInSeconds( &pMusicInfoCurrent->chMP3_Bgrnd.MP3StreamHeader );
+				// Com_Printf("Remaining: %3.3f\n",fRemainingTimeInSeconds);
+
+				if ( fRemainingTimeInSeconds < fDYNAMIC_XFADE_SECONDS*2 )
+				{
+					// now either loop current track, switch if finishing a transition, or stop if finished a death...
+					//
+					if (pMusicInfoCurrent->bTrackSwitchPending)
+					{
+						pMusicInfoCurrent->bTrackSwitchPending = qfalse;	// ack
+						S_SwitchDynamicTracks( eMusic_StateActual, pMusicInfoCurrent->eTS_NewState, qfalse);	// qboolean bNewTrackStartsFullVolume
+						if (tMusic_Info[ pMusicInfoCurrent->eTS_NewState ].bExists)	// don't do this if switching to silence
+						{							
+							tMusic_Info[ pMusicInfoCurrent->eTS_NewState ].SeekTo(pMusicInfoCurrent->fTS_NewTime);
+						}					
+					}
+					else
+					{
+						// normal looping, so set rewind current track, set volume to 0 and fade up to full (unless death track playing, then stays quiet)
+						//	(while fader copy of end-section fades down)
+						//
+						// copy current track to fader...
+						//
+						*pMusicInfoFadeOut = *pMusicInfoCurrent;	// struct copy
+						pMusicInfoFadeOut->iXFadeVolumeSeekTime	= Sys_Milliseconds();
+						pMusicInfoFadeOut->iXFadeVolumeSeekTo	= 0;
+						//
+						pMusicInfoCurrent->Rewind();
+						pMusicInfoCurrent->iXFadeVolumeSeekTime	= Sys_Milliseconds();
+						pMusicInfoCurrent->iXFadeVolumeSeekTo	= (eMusic_StateActual == eBGRNDTRACK_DEATH) ? 0: 255;
+						pMusicInfoCurrent->iXFadeVolume			= 0;
+					}
+				}
+			}
+		}
+		else
+		{
+			// special case, when foreground music is shut off but fader still running to fade off previous track...
+			//
+			MusicInfo_t *pMusicInfoFadeOut = &tMusic_Info[ eBGRNDTRACK_FADE ];
+			if (pMusicInfoFadeOut->bActive)
+			{
+				S_UpdateBackgroundTrack_Actual( pMusicInfoFadeOut, qtrue, s_musicVolume->value );
+				if (pMusicInfoFadeOut->iXFadeVolume == 0)
+				{
+					pMusicInfoFadeOut->bActive = qfalse;
+				}
+			}	
+		}
+	}
+	else
+	{
+		// standard / non-dynamic one-track music...
+		//
+		LPCSTR psCommand = S_Music_GetRequestedState();	// special check just for "silence" case...
+		qboolean bShouldBeSilent = (psCommand && !stricmp(psCommand,"silence"));
+		float fDesiredVolume = bShouldBeSilent ? 0.0f : s_musicVolume->value;
+		//
+		// internal to this code is a volume-smoother...
+		//
+		qboolean bNewTrackDesired = S_UpdateBackgroundTrack_Actual(&tMusic_Info[eBGRNDTRACK_NONDYNAMIC], qtrue, fDesiredVolume);
+
+		if (bNewTrackDesired)
+		{
+			S_StartBackgroundTrack( sMusic_BackgroundLoop, sMusic_BackgroundLoop, qfalse );
+		}
+	}
+}
+
+
+cvar_t *s_soundpoolmegs = NULL;
+
+
+// currently passing in sfx as a param in case I want to do something with it later.
+//
+byte *SND_malloc(int iSize, sfx_t *sfx) 
+{
+	byte *pData = (byte *) Z_Malloc(iSize, TAG_SND_RAWDATA, qfalse);	// don't bother asking for zeroed mem
+
+	// if "s_soundpoolmegs" is < 0, then the -ve of the value is the maximum amount of sounds we're allowed to have loaded...
+	//
+	if (s_soundpoolmegs && s_soundpoolmegs->integer < 0)
+	{
+		while ( (Z_MemSize(TAG_SND_RAWDATA) + Z_MemSize(TAG_SND_MP3STREAMHDR)) > ((-s_soundpoolmegs->integer) * 1024 * 1024))		
+		{
+			int iBytesFreed = SND_FreeOldestSound(sfx);
+			if (iBytesFreed == 0)
+				break;	// sanity
+		}
+	}
+
+	return pData;
+}
+
+
+// called once-only in EXE lifetime...
+//
+void SND_setup() 
+{		 
+	s_soundpoolmegs = Cvar_Get("s_soundpoolmegs", "25", CVAR_ARCHIVE);
+	if (Sys_LowPhysicalMemory() )
+	{
+		Cvar_Set("s_soundpoolmegs", "0");
+	}
+	
+//	Com_Printf("Sound memory manager started\n");
+}
+
+
+// ask how much mem an sfx has allocated...
+//
+static int SND_MemUsed(sfx_t *sfx)
+{
+	int iSize = 0;
+	if (sfx->pSoundData){
+		iSize += Z_Size(sfx->pSoundData);
+	}
+
+	if (sfx->pMP3StreamHeader) {
+		iSize += Z_Size(sfx->pMP3StreamHeader);
+	}
+
+	return iSize;
+}
+
+// free any allocated sfx mem...
+//
+// now returns # bytes freed to help with z_malloc()-fail recovery
+//
+static int SND_FreeSFXMem(sfx_t *sfx)
+{
+	int iBytesFreed = 0;
+
+	if (s_UseOpenAL)
+	{
+		alGetError();
+		if (sfx->Buffer)
+		{
+			alDeleteBuffers(1, &(sfx->Buffer));
+#ifdef _DEBUG
+			char szString[256];
+			if (alGetError() != AL_NO_ERROR)
+			{
+				sprintf(szString, "Failed to delete AL Buffer (%s) ... !\n", sfx->sSoundName);
+				OutputDebugString(szString);
+			}
+#endif
+			sfx->Buffer = 0;
+		}
+
+		if (sfx->lipSyncData)
+		{
+			iBytesFreed +=	Z_Free(	sfx->lipSyncData);
+									sfx->lipSyncData = NULL;
+		}
+	}
+
+	if (						sfx->pSoundData) {
+		iBytesFreed +=	Z_Free(	sfx->pSoundData );
+								sfx->pSoundData = NULL;
+	}
+
+	sfx->bInMemory = false;	
+
+	if (						sfx->pMP3StreamHeader) {
+		iBytesFreed +=	Z_Free(	sfx->pMP3StreamHeader );
+								sfx->pMP3StreamHeader = NULL;
+	}
+
+	return iBytesFreed;
+}
+
+void S_DisplayFreeMemory() 
+{
+	int iSoundDataSize = Z_MemSize ( TAG_SND_RAWDATA ) + Z_MemSize( TAG_SND_MP3STREAMHDR );
+	int iMusicDataSize = Z_MemSize ( TAG_SND_DYNAMICMUSIC );
+
+	if (iSoundDataSize || iMusicDataSize)
+	{
+		Com_Printf("\n%.2fMB audio data:  ( %.2fMB WAV/MP3 ) + ( %.2fMB Music )\n",
+					((float)(iSoundDataSize+iMusicDataSize))/1024.0f/1024.0f,
+										((float)(iSoundDataSize))/1024.0f/1024.0f,
+																((float)(iMusicDataSize))/1024.0f/1024.0f
+					);
+
+		// now count up amount used on this level...
+		//
+		iSoundDataSize = 0;
+		for (int i=1; i<s_numSfx; i++)
+		{
+			sfx_t *sfx = &s_knownSfx[i];
+
+			if (sfx->iLastLevelUsedOn == RE_RegisterMedia_GetLevel()){
+				iSoundDataSize += SND_MemUsed(sfx);
+			}
+		}
+
+		Com_Printf("%.2fMB in sfx_t alloc data (WAV/MP3) loaded this level\n",(float)iSoundDataSize/1024.0f/1024.0f);
+	}
+}
+
+void SND_TouchSFX(sfx_t *sfx)
+{
+	sfx->iLastTimeUsed		= Com_Milliseconds()+1;
+	sfx->iLastLevelUsedOn	= RE_RegisterMedia_GetLevel();
+}
+
+
+// currently this is only called during snd_shutdown or snd_restart
+//
+void S_FreeAllSFXMem(void)
+{
+	for (int i=1 ; i < s_numSfx ; i++)	// start @ 1 to skip freeing default sound
+	{
+		SND_FreeSFXMem(&s_knownSfx[i]);
+	}
+}
+
+// returns number of bytes freed up...
+//
+// new param is so we can be usre of not freeing ourselves (without having to rely on possible uninitialised timers etc)
+//
+int SND_FreeOldestSound(sfx_t *pButNotThisOne /* = NULL */) 
+{	
+	int iBytesFreed = 0;
+	sfx_t *sfx;
+
+	int	iOldest = Com_Milliseconds();
+	int	iUsed	= 0;
+
+	// start on 1 so we never dump the default sound...
+	//
+	for (int i=1 ; i < s_numSfx ; i++) 
+	{
+		sfx = &s_knownSfx[i];
+
+		if (sfx != pButNotThisOne)
+		{
+			if (!sfx->bDefaultSound && sfx->bInMemory && sfx->iLastTimeUsed < iOldest) 
+			{
+				// new bit, we can't throw away any sfx_t struct in use by a channel, else the paint code will crash...
+				//
+				for (int iChannel=0; iChannel<MAX_CHANNELS; iChannel++)
+				{
+					channel_t *ch = & s_channels[iChannel];
+
+					if (ch->thesfx == sfx)
+						break;	// damn, being used
+				}
+				if (iChannel == MAX_CHANNELS)
+				{
+					// this sfx_t struct wasn't used by any channels, so we can lose it...
+					//			
+					iUsed = i;
+					iOldest = sfx->iLastTimeUsed;
+				}
+			}
+		}
+	}
+
+	if (iUsed)
+	{
+		sfx = &s_knownSfx[ iUsed ];
+	
+		Com_DPrintf("SND_FreeOldestSound: freeing sound %s\n", sfx->sSoundName);
+	
+		iBytesFreed = SND_FreeSFXMem(sfx);
+	}
+
+	return iBytesFreed;
+}
+int SND_FreeOldestSound(void)
+{
+	return SND_FreeOldestSound(NULL);	// I had to add a void-arg version of this because of link issues, sigh
+}
+
+
+// just before we drop into a level, ensure the audio pool is under whatever the maximum
+//	pool size is (but not by dropping out sounds used by the current level)...
+//
+// returns qtrue if at least one sound was dropped out, so z_malloc-fail recovery code knows if anything changed
+//
+extern qboolean gbInsideLoadSound;
+qboolean SND_RegisterAudio_LevelLoadEnd(qboolean bDeleteEverythingNotUsedThisLevel /* 99% qfalse */)
+{
+	qboolean bAtLeastOneSoundDropped = qfalse;
+
+	Com_DPrintf( "SND_RegisterAudio_LevelLoadEnd():\n");
+
+	if (gbInsideLoadSound)
+	{
+		Com_DPrintf( "(Inside S_LoadSound (z_malloc recovery?), exiting...\n");
+	}
+	else
+	{
+		int iLoadedAudioBytes	 = Z_MemSize ( TAG_SND_RAWDATA ) + Z_MemSize( TAG_SND_MP3STREAMHDR );
+		const int iMaxAudioBytes = s_soundpoolmegs->integer * 1024 * 1024;
+
+		for (int i=1; i<s_numSfx && ( iLoadedAudioBytes > iMaxAudioBytes || bDeleteEverythingNotUsedThisLevel) ; i++) // i=1 so we never page out default sound
+		{
+			sfx_t *sfx = &s_knownSfx[i];
+
+			if (sfx->bInMemory)
+			{
+				qboolean bDeleteThis = qfalse;
+
+				if (bDeleteEverythingNotUsedThisLevel)
+				{
+					bDeleteThis = (sfx->iLastLevelUsedOn != RE_RegisterMedia_GetLevel());
+				}
+				else
+				{
+					bDeleteThis = (sfx->iLastLevelUsedOn < RE_RegisterMedia_GetLevel());
+				}
+
+				if (bDeleteThis)
+				{
+					Com_DPrintf( "Dumping sfx_t \"%s\"\n",sfx->sSoundName);			
+
+					if (SND_FreeSFXMem(sfx))
+					{
+						bAtLeastOneSoundDropped = qtrue;
+					}
+
+					iLoadedAudioBytes = Z_MemSize ( TAG_SND_RAWDATA ) + Z_MemSize( TAG_SND_MP3STREAMHDR );					
+				}
+			}
+		}
+	}
+
+	Com_DPrintf( "SND_RegisterAudio_LevelLoadEnd(): Ok\n");	
+
+	return bAtLeastOneSoundDropped;
+}
+
+
+/****************************************************************************************************\
+*
+*	EAX Related
+*
+\****************************************************************************************************/
+
+/*
+	Initialize the EAX Manager
+*/
+void InitEAXManager()
+{
+	LPEAXMANAGERCREATE lpEAXManagerCreateFn;
+	EAXFXSLOTPROPERTIES FXSlotProp;
+	GUID	Effect;
+	GUID	FXSlotGuids[4];
+	int i;
+
+	s_bEALFileLoaded = false;
+
+	// Check for EAX 4.0 support
+	s_bEAX = alIsExtensionPresent((ALubyte*)"EAX4.0");
+	
+	if (s_bEAX)
+	{
+		Com_Printf("Found EAX 4.0 native support\n");
+	}
+	else
+	{
+		// Support for EAXUnified (automatic translation of EAX 4.0 calls into EAX 3.0)
+		if ((alIsExtensionPresent((ALubyte*)"EAX3.0")) && (alIsExtensionPresent((ALubyte*)"EAX4.0Emulated")))
+		{
+			s_bEAX = AL_TRUE;
+			Com_Printf("Found EAX 4.0 EMULATION support\n");
+		}
+	}
+
+	if (s_bEAX)
+	{
+		s_eaxSet = (EAXSet)alGetProcAddress((ALubyte*)"EAXSet");
+		if (s_eaxSet == NULL)
+			s_bEAX = false;
+		s_eaxGet = (EAXGet)alGetProcAddress((ALubyte*)"EAXGet");
+		if (s_eaxGet == NULL)
+			s_bEAX = false;
+	}
+
+	// If we have detected EAX support, then try and load the EAX Manager DLL
+	if (s_bEAX)
+	{
+		s_hEAXManInst = LoadLibrary("EAXMan.dll");
+		if (s_hEAXManInst)
+		{
+			lpEAXManagerCreateFn = (LPEAXMANAGERCREATE)GetProcAddress(s_hEAXManInst, "EaxManagerCreate");
+			if (lpEAXManagerCreateFn)
+			{
+				if (lpEAXManagerCreateFn(&s_lpEAXManager)==EM_OK)
+				{
+					// Configure our EAX 4.0 Effect Slots
+
+					s_NumFXSlots = 0;
+					for (i = 0; i < EAX_MAX_FXSLOTS; i++)
+					{
+						s_FXSlotInfo[i].FXSlotGuid = EAX_NULL_GUID;
+						s_FXSlotInfo[i].lEnvID = -1;
+					}
+
+					FXSlotGuids[0] = EAXPROPERTYID_EAX40_FXSlot0;
+					FXSlotGuids[1] = EAXPROPERTYID_EAX40_FXSlot1;
+					FXSlotGuids[2] = EAXPROPERTYID_EAX40_FXSlot2;
+					FXSlotGuids[3] = EAXPROPERTYID_EAX40_FXSlot3;
+
+					// For each effect slot, try and load a reverb and lock the slot
+					FXSlotProp.guidLoadEffect = EAX_REVERB_EFFECT;
+					FXSlotProp.lVolume = 0;
+					FXSlotProp.lLock = EAXFXSLOT_LOCKED;
+					FXSlotProp.ulFlags = EAXFXSLOTFLAGS_ENVIRONMENT;
+
+					for (i = 0; i < EAX_MAX_FXSLOTS; i++)
+					{
+						if (s_eaxSet(&FXSlotGuids[i], EAXFXSLOT_ALLPARAMETERS, NULL, &FXSlotProp, sizeof(EAXFXSLOTPROPERTIES))==AL_NO_ERROR)
+						{
+							// We can use this slot
+							s_FXSlotInfo[s_NumFXSlots].FXSlotGuid = FXSlotGuids[i];
+							s_NumFXSlots++;
+						}
+						else
+						{
+							// If this slot already contains a reverb, then we will use it anyway (Slot 0 will
+							// be in this category).  (It probably means that Slot 0 is locked)
+							if (s_eaxGet(&FXSlotGuids[i], EAXFXSLOT_LOADEFFECT, NULL, &Effect, sizeof(GUID))==AL_NO_ERROR)
+							{
+								if (Effect == EAX_REVERB_EFFECT)
+								{
+									// We can use this slot
+									// Make sure the environment flag is on
+									s_eaxSet(&FXSlotGuids[i], EAXFXSLOT_FLAGS, NULL, &FXSlotProp.ulFlags, sizeof(unsigned long));
+									s_FXSlotInfo[s_NumFXSlots].FXSlotGuid = FXSlotGuids[i];
+									s_NumFXSlots++;
+								}
+							}
+						}
+					}
+
+					return;
+				}
+			}
+		}
+	}
+
+	// If the EAXManager library was loaded (and there was a problem), then unload it
+	if (s_hEAXManInst)
+	{
+		FreeLibrary(s_hEAXManInst);
+		s_hEAXManInst = NULL;
+	}
+
+	s_lpEAXManager = NULL;
+	s_bEAX = false;
+
+	return;
+}
+
+/*
+	Release the EAX Manager
+*/
+void ReleaseEAXManager()
+{
+	s_bEAX = false;
+
+	UnloadEALFile();
+
+	if (s_lpEAXManager)
+	{
+		s_lpEAXManager->Release();
+		s_lpEAXManager = NULL;
+	}
+	if (s_hEAXManInst)
+	{
+		FreeLibrary(s_hEAXManInst);
+		s_hEAXManInst = NULL;
+	}
+}
+
+
+/*
+	Try to load the given .eal file
+*/
+static bool LoadEALFile(char *szEALFilename)
+{
+	char		*ealData = NULL;
+	HRESULT		hr;
+	long		i, j, lID, lEnvID;
+	EMPOINT		EMPoint;
+	char		szAperture[128];
+	char		szFullEALFilename[MAX_QPATH];
+	long		lNumInst, lNumInstA, lNumInstB;
+	bool		bLoaded = false;
+	bool		bValid = true;
+	int			result;
+	char		szString[256];
+	
+	if ((!s_lpEAXManager) || (!s_bEAX))
+		return false;
+
+	if (strstr(szEALFilename, "nomap"))
+		return false;
+
+	s_EnvironmentID = 0xFFFFFFFF;
+
+	// Assume there is no aperture information in the .eal file
+	s_lpEnvTable = NULL;
+
+	// Load EAL file from PAK file
+	result = FS_ReadFile(szEALFilename, (void **)&ealData);
+
+	if ((ealData) && (result != -1))
+	{
+		hr = s_lpEAXManager->LoadDataSet(ealData, EMFLAG_LOADFROMMEMORY);
+	
+		// Unload EAL file
+		FS_FreeFile (ealData);
+	
+		if (hr == EM_OK)
+		{
+			Com_DPrintf("Loaded %s by Quake loader\n", szEALFilename);
+			bLoaded = true;
+		}
+	}
+	else
+	{
+		// Failed to load via Quake loader, try manually
+		Com_sprintf(szFullEALFilename, MAX_QPATH, "base/%s", szEALFilename);
+		if (SUCCEEDED(s_lpEAXManager->LoadDataSet(szFullEALFilename, 0)))
+		{
+			Com_DPrintf("Loaded %s by EAXManager\n", szEALFilename);
+			bLoaded = true;
+		}
+	}
+
+	if (bLoaded)
+	{
+		// For a valid eal file ... need to find 'Center' tag, record num of instances,  and then find
+		// the right number of instances of 'Aperture0a' and 'Aperture0b'.
+
+		if (s_lpEAXManager->GetSourceID("Center", &lID)==EM_OK)
+		{
+			if (s_lpEAXManager->GetSourceNumInstances(lID, &s_lNumEnvironments)==EM_OK)
+			{
+				if (s_lpEAXManager->GetSourceID("Aperture0a", &lID)==EM_OK)
+				{
+					if (s_lpEAXManager->GetSourceNumInstances(lID, &lNumInst)==EM_OK)
+					{
+						if (lNumInst == s_lNumEnvironments)
+						{
+							if (s_lpEAXManager->GetSourceID("Aperture0b", &lID)==EM_OK)
+							{
+								if (s_lpEAXManager->GetSourceNumInstances(lID, &lNumInst)==EM_OK)
+								{
+									if (lNumInst == s_lNumEnvironments)
+									{
+										// Check equal numbers of ApertureXa and ApertureXb
+										i = 1;
+										while (true)
+										{
+											lNumInstA = lNumInstB = 0;
+
+											sprintf(szAperture,"Aperture%da",i);
+											if ((s_lpEAXManager->GetSourceID(szAperture, &lID)==EM_OK) && (s_lpEAXManager->GetSourceNumInstances(lID, &lNumInstA)==EM_OK))
+											{
+												sprintf(szAperture,"Aperture%db",i);
+												s_lpEAXManager->GetSourceID(szAperture, &lID);
+												s_lpEAXManager->GetSourceNumInstances(lID, &lNumInstB);
+
+												if (lNumInstA!=lNumInstB)
+												{
+													Com_DPrintf( S_COLOR_YELLOW "Invalid EAL file - %d Aperture%da tags, and %d Aperture%db tags\n", lNumInstA, i, lNumInstB, i);
+													bValid = false;
+												}
+											}
+											else
+											{
+												break;
+											}
+
+											i++;
+										}
+
+										if (bValid)
+										{
+											s_lpEnvTable = (LPENVTABLE)Z_Malloc(s_lNumEnvironments * sizeof(ENVTABLE), TAG_NEWDEL, qtrue);
+										}
+									}
+									else
+										Com_DPrintf( S_COLOR_YELLOW "Invalid EAL File - expected %d instances of Aperture0b, found %d\n", s_lNumEnvironments, lNumInst);
+								}
+								else
+									Com_DPrintf( S_COLOR_YELLOW "EAXManager- failed GetSourceNumInstances()\n");
+							}
+							else
+								Com_DPrintf( S_COLOR_YELLOW "Invalid EAL File - no instances of 'Aperture0b' source-tag\n");
+						}
+						else
+							Com_DPrintf( S_COLOR_YELLOW "Invalid EAL File - found %d instances of the 'Center' tag, but only %d instances of 'Aperture0a'\n", s_lNumEnvironments, lNumInst);
+					}
+					else
+						Com_DPrintf( S_COLOR_YELLOW "EAXManager- failed GetSourceNumInstances()\n");
+				}
+				else
+					Com_DPrintf( S_COLOR_YELLOW "Invalid EAL File - no instances of 'Aperture0a' source-tag\n");
+			}
+			else
+				Com_DPrintf( S_COLOR_YELLOW "EAXManager- failed GetSourceNumInstances()\n");
+		}
+		else
+			Com_DPrintf( S_COLOR_YELLOW "Invalid EAL File - no instances of 'Center' source-tag\n");
+
+
+		if (s_lpEnvTable)
+		{
+			i = 0;
+			while (true)
+			{
+				sprintf(szAperture, "Aperture%da", i);
+				if (s_lpEAXManager->GetSourceID(szAperture, &lID)==EM_OK)
+				{
+					if (s_lpEAXManager->GetSourceNumInstances(lID, &lNumInst)==EM_OK)
+					{
+						for (j = 0; j < s_lNumEnvironments; j++)
+						{
+							s_lpEnvTable[j].bUsed = false;
+						}
+
+						for (j = 0; j < lNumInst; j++)
+						{
+							if (s_lpEAXManager->GetSourceInstancePos(lID, j, &EMPoint)==EM_OK)
+							{
+								if (s_lpEAXManager->GetListenerDynamicAttributes(0, &EMPoint, &lEnvID, 0)==EM_OK)
+								{
+									if ((lEnvID >= 0) && (lEnvID < s_lNumEnvironments))
+									{
+										assert(s_lpEnvTable[lEnvID].ulNumApertures < 64);
+										if (!s_lpEnvTable[lEnvID].bUsed)
+										{
+											s_lpEnvTable[lEnvID].bUsed = true;
+											s_lpEnvTable[lEnvID].Aperture[s_lpEnvTable[lEnvID].ulNumApertures].vPos1[0] = EMPoint.fX;
+											s_lpEnvTable[lEnvID].Aperture[s_lpEnvTable[lEnvID].ulNumApertures].vPos1[1] = EMPoint.fY;
+											s_lpEnvTable[lEnvID].Aperture[s_lpEnvTable[lEnvID].ulNumApertures].vPos1[2] = EMPoint.fZ;
+										}
+										else
+										{
+											s_lpEAXManager->GetEnvironmentName(lEnvID, szString, 256);
+											Com_DPrintf( S_COLOR_YELLOW "Found more than one occurance of Aperture%da in %s sub-space\n", i, szString);
+											Com_DPrintf( S_COLOR_YELLOW "One tag at %.3f,%.3f,%.3f, other at %.3f,%.3f,%.3f\n", EMPoint.fX, EMPoint.fY, EMPoint.fZ,
+												s_lpEnvTable[lEnvID].Aperture[s_lpEnvTable[lEnvID].ulNumApertures].vPos1[0], s_lpEnvTable[lEnvID].Aperture[s_lpEnvTable[lEnvID].ulNumApertures].vPos1[1],
+												s_lpEnvTable[lEnvID].Aperture[s_lpEnvTable[lEnvID].ulNumApertures].vPos1[2]);
+											bValid = false;
+										}
+									}
+									else
+									{
+										if (lEnvID==-1)
+											Com_DPrintf( S_COLOR_YELLOW "%s (%.3f,%.3f,%.3f) in Default Environment - please remove\n", szAperture, EMPoint.fX, EMPoint.fY, EMPoint.fZ);
+										else
+											Com_DPrintf( S_COLOR_YELLOW "Detected more reverb presets than zones - please delete unused presets\n");
+										bValid = false;
+									}
+								}
+							}
+						}
+					}
+				}
+				else
+				{
+					break;
+				}
+
+				if (bValid)
+				{
+					sprintf(szAperture, "Aperture%db", i);
+					if (s_lpEAXManager->GetSourceID(szAperture, &lID)==EM_OK)
+					{
+						if (s_lpEAXManager->GetSourceNumInstances(lID, &lNumInst)==EM_OK)
+						{
+							for (j = 0; j < s_lNumEnvironments; j++)
+							{
+								s_lpEnvTable[j].bUsed = false;
+							}
+
+							for (j = 0; j < lNumInst; j++)
+							{
+								if (s_lpEAXManager->GetSourceInstancePos(lID, j, &EMPoint)==EM_OK)
+								{
+									if (s_lpEAXManager->GetListenerDynamicAttributes(0, &EMPoint, &lEnvID, 0)==EM_OK)
+									{
+										if ((lEnvID >= 0) && (lEnvID < s_lNumEnvironments))
+										{
+											if (!s_lpEnvTable[lEnvID].bUsed)
+											{
+												s_lpEnvTable[lEnvID].bUsed = true;
+												s_lpEnvTable[lEnvID].Aperture[s_lpEnvTable[lEnvID].ulNumApertures].vPos2[0] = EMPoint.fX;
+												s_lpEnvTable[lEnvID].Aperture[s_lpEnvTable[lEnvID].ulNumApertures].vPos2[1] = EMPoint.fY;
+												s_lpEnvTable[lEnvID].Aperture[s_lpEnvTable[lEnvID].ulNumApertures].vPos2[2] = EMPoint.fZ;
+											}
+											else
+											{
+												s_lpEAXManager->GetEnvironmentName(lEnvID, szString, 256);
+												Com_DPrintf( S_COLOR_YELLOW "Found more than one occurance of Aperture%db in %s sub-space\n", i, szString);
+												bValid = false;
+											}
+
+											// Calculate center position of aperture (average of 2 points)
+
+											s_lpEnvTable[lEnvID].Aperture[s_lpEnvTable[lEnvID].ulNumApertures].vCenter[0] =
+												(s_lpEnvTable[lEnvID].Aperture[s_lpEnvTable[lEnvID].ulNumApertures].vPos1[0] +
+												s_lpEnvTable[lEnvID].Aperture[s_lpEnvTable[lEnvID].ulNumApertures].vPos2[0]) / 2;
+
+											s_lpEnvTable[lEnvID].Aperture[s_lpEnvTable[lEnvID].ulNumApertures].vCenter[1] =
+												(s_lpEnvTable[lEnvID].Aperture[s_lpEnvTable[lEnvID].ulNumApertures].vPos1[1] +
+												s_lpEnvTable[lEnvID].Aperture[s_lpEnvTable[lEnvID].ulNumApertures].vPos2[1]) / 2;
+
+											s_lpEnvTable[lEnvID].Aperture[s_lpEnvTable[lEnvID].ulNumApertures].vCenter[2] =
+												(s_lpEnvTable[lEnvID].Aperture[s_lpEnvTable[lEnvID].ulNumApertures].vPos1[2] +
+												s_lpEnvTable[lEnvID].Aperture[s_lpEnvTable[lEnvID].ulNumApertures].vPos2[2]) / 2;
+
+											s_lpEnvTable[lEnvID].ulNumApertures++;
+											assert(s_lpEnvTable[lEnvID].ulNumApertures < 64);
+										}
+										else
+										{
+											if (lEnvID==-1)
+												Com_DPrintf( S_COLOR_YELLOW "%s (%.3f,%.3f,%.3f) in Default Environment - please remove\n", szAperture, EMPoint.fX, EMPoint.fY, EMPoint.fZ);
+											else
+												Com_DPrintf( S_COLOR_YELLOW "Detected more reverb presets than zones - please delete unused presets\n");
+											bValid = false;
+										}
+									}
+								}
+							}
+						}
+					}
+				}
+
+				if (!bValid)
+				{
+					// Found a problem
+					Com_DPrintf( S_COLOR_YELLOW "EAX legacy behaviour invoked (one reverb)\n");
+
+					Z_Free(s_lpEnvTable);
+					s_lpEnvTable = NULL;
+					break;
+				}
+
+				i++;
+			}
+		}
+		else
+		{
+			Com_DPrintf( S_COLOR_YELLOW "EAX legacy behaviour invoked (one reverb)\n");
+		}
+
+		return true;
+	}
+
+	
+	Com_DPrintf( S_COLOR_YELLOW "Failed to load %s\n", szEALFilename);
+	return false;
+}
+
+/*
+	Unload current .eal file
+*/
+static void UnloadEALFile()
+{
+	HRESULT hr;
+
+	if ((!s_lpEAXManager) || (!s_bEAX))
+		return;
+
+	hr = s_lpEAXManager->FreeDataSet(0);
+	s_bEALFileLoaded = false;
+
+	if (s_lpEnvTable)
+	{
+		Z_Free(s_lpEnvTable);
+		s_lpEnvTable = NULL;
+	}
+
+	return;
+}
+
+/*
+	Updates the current EAX Reverb setting, based on the location of the listener
+*/
+static void UpdateEAXListener()
+{
+	EMPOINT ListPos, ListOri;
+	EMPOINT EMAperture;
+	EMPOINT EMSourcePoint;
+	long lID, lSourceID, lApertureNum;
+	int i, j, k;
+	float flDistance, flNearest;
+	EAXREVERBPROPERTIES Reverb;
+	bool bFound;
+	long lVolume;
+	long lCurTime;
+	channel_t	*ch;
+	EAXVECTOR	LR, LP1, LP2, Pan;
+	REVERBDATA ReverbData[3]; // Hardcoded to three (maximum no of reverbs)
+#ifdef DISPLAY_CLOSEST_ENVS
+	char szEnvName[256];
+#endif
+
+	if ((!s_lpEAXManager) || (!s_bEAX))
+		return;
+	
+	lCurTime = timeGetTime();
+
+	if ((s_lLastEnvUpdate + ENV_UPDATE_RATE) < lCurTime)
+	{
+		// Update closest reverbs
+		s_lLastEnvUpdate = lCurTime;
+
+		// No panning information in .eal file, or we only have 1 FX Slot to use, revert to legacy
+		// behaviour (i.e only one reverb)
+		if ((!s_lpEnvTable) || (s_NumFXSlots==1))
+		{
+			// Convert Listener co-ordinate to left-handed system
+			ListPos.fX = listener_pos[0];
+			ListPos.fY = listener_pos[1];
+			ListPos.fZ = -listener_pos[2];
+
+			if (SUCCEEDED(s_lpEAXManager->GetListenerDynamicAttributes(0, &ListPos, &lID, EMFLAG_LOCKPOSITION)))
+			{
+				if (lID != s_EnvironmentID)
+				{
+#ifdef DISPLAY_CLOSEST_ENVS
+					if (SUCCEEDED(s_lpEAXManager->GetEnvironmentName(lID, szEnvName, 256)))
+						Com_Printf("Changing to '%s' zone !\n", szEnvName);
+#endif
+					// Get EAX Preset info.
+					if (SUCCEEDED(s_lpEAXManager->GetEnvironmentAttributes(lID, &s_eaxLPCur)))
+					{
+						// Override
+						s_eaxLPCur.flAirAbsorptionHF = 0.0f;
+
+						// Set Environment
+						s_eaxSet(&EAXPROPERTYID_EAX40_FXSlot0, EAXREVERB_ALLPARAMETERS,
+							NULL, &s_eaxLPCur, sizeof(EAXREVERBPROPERTIES));
+
+						s_EnvironmentID = lID;
+					}
+				}
+			}
+
+			return;
+		}
+
+		// Convert Listener position and orientation to left-handed system
+		ListPos.fX = listener_pos[0];
+		ListPos.fY = listener_pos[1];
+		ListPos.fZ = -listener_pos[2];
+
+		ListOri.fX = listener_ori[0];
+		ListOri.fY = listener_ori[1];
+		ListOri.fZ = -listener_ori[2];
+
+		// Need to find closest s_NumFXSlots (including the Listener's slot)
+
+		if (s_lpEAXManager->GetListenerDynamicAttributes(0, &ListPos, &lID, EMFLAG_LOCKPOSITION)==EM_OK)
+		{
+			if (lID == -1)
+			{
+				// Found default environment
+//				Com_Printf( S_COLOR_YELLOW "Listener in default environment - ignoring zone !\n");
+				return;
+			}
+
+			ReverbData[0].lEnvID = -1;
+			ReverbData[0].lApertureNum = -1;
+			ReverbData[0].flDist = FLT_MAX;
+
+			ReverbData[1].lEnvID = -1;
+			ReverbData[1].lApertureNum = -1;
+			ReverbData[1].flDist = FLT_MAX;
+
+			ReverbData[2].lEnvID = lID;
+			ReverbData[2].lApertureNum = -1;
+			ReverbData[2].flDist = 0.0f;
+
+			for (i = 0; i < s_lNumEnvironments; i++)
+			{
+				// Ignore Environment id lID as this one will always be used
+				if (i != lID)
+				{
+					flNearest = FLT_MAX;
+					lApertureNum = 0;	//shut up compile warning
+
+					for (j = 0; j < s_lpEnvTable[i].ulNumApertures; j++)
+					{
+						EMAperture.fX = s_lpEnvTable[i].Aperture[j].vCenter[0];
+						EMAperture.fY = s_lpEnvTable[i].Aperture[j].vCenter[1];
+						EMAperture.fZ = s_lpEnvTable[i].Aperture[j].vCenter[2];
+
+						flDistance = CalcDistance(EMAperture, ListPos);
+
+						if (flDistance < flNearest)
+						{
+							flNearest = flDistance;
+							lApertureNum = j;
+						}
+					}
+
+					// Now have closest point for this Environment - see if this is closer than any others
+
+					if (flNearest < ReverbData[1].flDist)
+					{
+						if (flNearest < ReverbData[0].flDist)
+						{
+							ReverbData[1] = ReverbData[0];
+							ReverbData[0].flDist = flNearest;
+							ReverbData[0].lApertureNum = lApertureNum;
+							ReverbData[0].lEnvID = i;
+						}
+						else
+						{
+							ReverbData[1].flDist = flNearest;
+							ReverbData[1].lApertureNum = lApertureNum;
+							ReverbData[1].lEnvID = i;
+						}
+					}
+				}
+			}
+
+		}
+
+#ifdef DISPLAY_CLOSEST_ENVS
+		char szEnvName1[256] = {0};
+		char szEnvName2[256] = {0};
+		char szEnvName3[256] = {0};
+
+		s_lpEAXManager->GetEnvironmentName(ReverbData[0].lEnvID, szEnvName1, 256);
+		s_lpEAXManager->GetEnvironmentName(ReverbData[1].lEnvID, szEnvName2, 256);
+		s_lpEAXManager->GetEnvironmentName(ReverbData[2].lEnvID, szEnvName3, 256);
+
+		Com_Printf("Closest zones are %s, %s (Listener in %s)\n", szEnvName1,
+			szEnvName2, szEnvName3);
+#endif
+
+		// Mute any reverbs no longer required ...
+
+		for (i = 0; i < s_NumFXSlots; i++)
+		{
+			if ((s_FXSlotInfo[i].lEnvID != -1) && (s_FXSlotInfo[i].lEnvID != ReverbData[0].lEnvID) && (s_FXSlotInfo[i].lEnvID != ReverbData[1].lEnvID)
+				&& (s_FXSlotInfo[i].lEnvID != ReverbData[2].lEnvID))
+			{
+				// This environment is no longer needed
+
+				// Mute it
+				lVolume = -10000;
+				if (s_eaxSet(&s_FXSlotInfo[i].FXSlotGuid, EAXFXSLOT_VOLUME, NULL, &lVolume, sizeof(long))!=AL_NO_ERROR)
+					OutputDebugString("Failed to Mute FX Slot\n");
+
+				// If any source is sending to this Slot ID then we need to stop them sending to the slot
+				for (j = 1; j < s_numChannels; j++)
+				{
+					if (s_channels[j].lSlotID == i)
+					{
+						if (s_eaxSet(&EAXPROPERTYID_EAX40_Source, EAXSOURCE_ACTIVEFXSLOTID, s_channels[j].alSource, (void*)&EAX_NULL_GUID, sizeof(GUID))!=AL_NO_ERROR)
+						{
+							OutputDebugString("Failed to set Source ActiveFXSlotID to NULL\n");
+						}
+
+						s_channels[j].lSlotID = -1;
+					}
+				}
+
+				assert(s_FXSlotInfo[i].lEnvID < s_lNumEnvironments && s_FXSlotInfo[i].lEnvID >= 0);
+				if (s_FXSlotInfo[i].lEnvID < s_lNumEnvironments && s_FXSlotInfo[i].lEnvID >= 0)
+				{
+					s_lpEnvTable[s_FXSlotInfo[i].lEnvID].lFXSlotID = -1;
+				}
+				s_FXSlotInfo[i].lEnvID = -1;
+			}
+		}
+
+
+		// Make sure all the reverbs we want are being rendered, if not, find an empty slot
+		// and apply appropriate reverb settings
+		for (j = 0; j < 3; j++)
+		{
+			bFound = false;
+
+			for (i = 0; i < s_NumFXSlots; i++)
+			{
+				if (s_FXSlotInfo[i].lEnvID == ReverbData[j].lEnvID)
+				{
+					bFound = true;
+					break;
+				}
+			}
+
+			if (!bFound)
+			{
+				// Find the first available slot and use that one
+				for (i = 0; i < s_NumFXSlots; i++)
+				{
+					if (s_FXSlotInfo[i].lEnvID == -1)
+					{
+						// Found slot 
+
+						// load reverb here
+
+						// Retrieve reverb properties from EAX Manager
+						if (s_lpEAXManager->GetEnvironmentAttributes(ReverbData[j].lEnvID, &Reverb)==EM_OK)
+						{
+							// Override Air Absorption HF
+							Reverb.flAirAbsorptionHF = 0.0f;
+
+							s_eaxSet(&s_FXSlotInfo[i].FXSlotGuid, EAXREVERB_ALLPARAMETERS, NULL, &Reverb, sizeof(EAXREVERBPROPERTIES));
+
+							// See if any Sources are in this environment, if they are, enable their sends
+							ch = s_channels + 1;
+							for (k = 1; k < s_numChannels; k++, ch++)
+							{
+								if (ch->fixed_origin)
+								{
+									// Converting from Quake -> DS3D (for EAGLE) ... swap Y and Z
+									EMSourcePoint.fX = ch->origin[0];
+									EMSourcePoint.fY = ch->origin[2];
+									EMSourcePoint.fZ = ch->origin[1];
+								}
+								else
+								{
+									if (ch->entnum == listener_number)
+									{
+										// Source at same position as listener
+										// Probably won't be any Occlusion / Obstruction effect -- unless the listener is underwater
+										// Converting from Open AL -> DS3D (for EAGLE) ... invert Z
+										EMSourcePoint.fX = listener_pos[0];
+										EMSourcePoint.fY = listener_pos[1];
+										EMSourcePoint.fZ = -listener_pos[2];
+									}
+									else
+									{
+										// Get position of Entity
+										// Converting from Quake -> DS3D (for EAGLE) ... swap Y and Z
+										EMSourcePoint.fX = loopSounds[ ch->entnum ].origin[0];
+										EMSourcePoint.fY = loopSounds[ ch->entnum ].origin[2];
+										EMSourcePoint.fZ = loopSounds[ ch->entnum ].origin[1];
+									}
+								}
+
+								// Get Source Environment point
+								if (s_lpEAXManager->GetListenerDynamicAttributes(0, &EMSourcePoint, &lSourceID, 0)!=EM_OK)
+									OutputDebugString("Failed to get environment zone for Source\n");
+
+								if (lSourceID == i)
+								{
+									if (s_eaxSet(&EAXPROPERTYID_EAX40_Source, EAXSOURCE_ACTIVEFXSLOTID, ch->alSource, (void*)&(s_FXSlotInfo[i].FXSlotGuid), sizeof(GUID))!=AL_NO_ERROR)
+									{
+										OutputDebugString("Failed to set Source ActiveFXSlotID to new environment\n");
+									}
+
+									ch->lSlotID = i;
+								}
+							}
+
+							assert(ReverbData[j].lEnvID < s_lNumEnvironments && ReverbData[j].lEnvID >= 0);
+							if (ReverbData[j].lEnvID < s_lNumEnvironments && ReverbData[j].lEnvID >= 0)
+							{
+								s_FXSlotInfo[i].lEnvID = ReverbData[j].lEnvID;
+								s_lpEnvTable[ReverbData[j].lEnvID].lFXSlotID = i;
+							}
+
+							break;
+						}
+					}
+				}
+			}
+		}
+
+		// Make sure Primary FX Slot ID is set correctly
+		if (s_EnvironmentID != ReverbData[2].lEnvID)
+		{
+			s_eaxSet(&EAXPROPERTYID_EAX40_Context, EAXCONTEXT_PRIMARYFXSLOTID, NULL, &(s_FXSlotInfo[s_lpEnvTable[ReverbData[2].lEnvID].lFXSlotID].FXSlotGuid), sizeof(GUID));
+			s_EnvironmentID = ReverbData[2].lEnvID;
+		}
+
+		// Have right reverbs loaded ... now to pan them and adjust volume
+
+
+		// We need to rotate the vector from the Listener to the reverb Aperture by minus the listener
+		// orientation
+
+		// Need dot product of Listener Orientation and the straight ahead vector (0, 0, 1)
+
+		// Since both vectors are already normalized, and two terms cancel out (0's), the angle
+		// is the arc cosine of the z component of the Listener Orientation
+
+		float flTheta = (float)acos(ListOri.fZ);
+
+		// If the Listener Orientation is to the left of straight ahead, then invert the angle
+		if (ListOri.fX < 0)
+			flTheta = -flTheta;
+
+		float flSin = (float)sin(-flTheta);
+		float flCos = (float)cos(-flTheta);
+
+		for (i = 0; i < min(s_NumFXSlots,s_lNumEnvironments); i++)
+		{
+			if (s_FXSlotInfo[i].lEnvID == s_EnvironmentID)
+			{
+				// Listener's environment
+
+				// Find the closest Aperture in *this* environment
+
+				flNearest = FLT_MAX;
+				lApertureNum = 0;	//shut up compile warning
+
+				for (j = 0; j < s_lpEnvTable[s_EnvironmentID].ulNumApertures; j++)
+				{
+					EMAperture.fX = s_lpEnvTable[s_EnvironmentID].Aperture[j].vCenter[0];
+					EMAperture.fY = s_lpEnvTable[s_EnvironmentID].Aperture[j].vCenter[1];
+					EMAperture.fZ = s_lpEnvTable[s_EnvironmentID].Aperture[j].vCenter[2];
+
+					flDistance = CalcDistance(EMAperture, ListPos);
+
+					if (flDistance < flNearest)
+					{
+						flNearest = flDistance;
+						lApertureNum = j;
+					}
+				}
+
+				// Have closest environment, work out pan vector direction
+
+				LR.x = s_lpEnvTable[s_EnvironmentID].Aperture[lApertureNum].vCenter[0] - ListPos.fX;
+				LR.y = s_lpEnvTable[s_EnvironmentID].Aperture[lApertureNum].vCenter[1] - ListPos.fY;
+				LR.z = s_lpEnvTable[s_EnvironmentID].Aperture[lApertureNum].vCenter[2] - ListPos.fZ;
+
+				Pan.x = (LR.x * flCos) + (LR.z * flSin);
+				Pan.y = 0.0f;
+				Pan.z = (LR.x * -flSin) + (LR.z * flCos);
+
+				Normalize(&Pan);
+
+
+				// Adjust magnitude ...
+
+				// Magnitude is based on the angle subtended by the aperture, so compute the angle between
+				// the vector from the Listener to Pos1 of the aperture, and the vector from the
+				// Listener to Pos2 of the aperture.
+
+				
+				LP1.x = s_lpEnvTable[s_EnvironmentID].Aperture[lApertureNum].vPos1[0] - ListPos.fX;
+				LP1.y = s_lpEnvTable[s_EnvironmentID].Aperture[lApertureNum].vPos1[1] - ListPos.fY;
+				LP1.z = s_lpEnvTable[s_EnvironmentID].Aperture[lApertureNum].vPos1[2] - ListPos.fZ;
+
+				LP2.x = s_lpEnvTable[s_EnvironmentID].Aperture[lApertureNum].vPos2[0] - ListPos.fX;
+				LP2.y = s_lpEnvTable[s_EnvironmentID].Aperture[lApertureNum].vPos2[1] - ListPos.fY;
+				LP2.z = s_lpEnvTable[s_EnvironmentID].Aperture[lApertureNum].vPos2[2] - ListPos.fZ;
+
+				Normalize(&LP1);
+				Normalize(&LP2);
+
+				float flGamma = acos((LP1.x * LP2.x) + (LP1.y * LP2.y) + (LP1.z * LP2.z));
+
+				// We want opposite magnitude (because we are 'in' this environment)
+				float flMagnitude = 1.0f - ((2.0f * (float)sin(flGamma/2.0f)) / flGamma);
+
+				// Negative (because pan should be 180 degrees)
+				Pan.x *= -flMagnitude;
+				Pan.y *= -flMagnitude;
+				Pan.z *= -flMagnitude;
+
+				if (s_eaxSet(&s_FXSlotInfo[i].FXSlotGuid, EAXREVERB_REVERBPAN, NULL, &Pan, sizeof(EAXVECTOR))!=AL_NO_ERROR)
+					OutputDebugString("Failed to set Listener Reverb Pan\n");
+
+				if (s_eaxSet(&s_FXSlotInfo[i].FXSlotGuid, EAXREVERB_REFLECTIONSPAN, NULL, &Pan, sizeof(EAXVECTOR))!=AL_NO_ERROR)
+					OutputDebugString("Failed to set Listener Reflections Pan\n");
+			}
+			else
+			{
+				// Find out which Reverb this is
+				if (ReverbData[0].lEnvID == s_FXSlotInfo[i].lEnvID)
+					k = 0;
+				else
+					k = 1;
+
+				LR.x = s_lpEnvTable[ReverbData[k].lEnvID].Aperture[ReverbData[k].lApertureNum].vCenter[0] - ListPos.fX;
+				LR.y = s_lpEnvTable[ReverbData[k].lEnvID].Aperture[ReverbData[k].lApertureNum].vCenter[1] - ListPos.fY;
+				LR.z = s_lpEnvTable[ReverbData[k].lEnvID].Aperture[ReverbData[k].lApertureNum].vCenter[2] - ListPos.fZ;
+
+				// Rotate the vector
+
+				Pan.x = (LR.x * flCos) + (LR.z * flSin);
+				Pan.y = 0.0f;
+				Pan.z = (LR.x * -flSin) + (LR.z * flCos);
+
+				Normalize(&Pan);
+
+				// Adjust magnitude ...
+
+				// Magnitude is based on the angle subtended by the aperture, so compute the angle between
+				// the vector from the Listener to Pos1 of the aperture, and the vector from the
+				// Listener to Pos2 of the aperture.
+
+				
+				LP1.x = s_lpEnvTable[ReverbData[k].lEnvID].Aperture[ReverbData[k].lApertureNum].vPos1[0] - ListPos.fX;
+				LP1.y = s_lpEnvTable[ReverbData[k].lEnvID].Aperture[ReverbData[k].lApertureNum].vPos1[1] - ListPos.fY;
+				LP1.z = s_lpEnvTable[ReverbData[k].lEnvID].Aperture[ReverbData[k].lApertureNum].vPos1[2] - ListPos.fZ;
+
+				LP2.x = s_lpEnvTable[ReverbData[k].lEnvID].Aperture[ReverbData[k].lApertureNum].vPos2[0] - ListPos.fX;
+				LP2.y = s_lpEnvTable[ReverbData[k].lEnvID].Aperture[ReverbData[k].lApertureNum].vPos2[1] - ListPos.fY;
+				LP2.z = s_lpEnvTable[ReverbData[k].lEnvID].Aperture[ReverbData[k].lApertureNum].vPos2[2] - ListPos.fZ;
+
+				Normalize(&LP1);
+				Normalize(&LP2);
+
+				float flGamma = acos((LP1.x * LP2.x) + (LP1.y * LP2.y) + (LP1.z * LP2.z));
+				float flMagnitude = (2.0f * (float)sin(flGamma/2.0f)) / flGamma;
+
+				Pan.x *= flMagnitude;
+				Pan.y *= flMagnitude;
+				Pan.z *= flMagnitude;
+
+				if (s_eaxSet(&s_FXSlotInfo[i].FXSlotGuid, EAXREVERB_REVERBPAN, NULL, &Pan, sizeof(EAXVECTOR))!=AL_NO_ERROR)
+					OutputDebugString("Failed to set Reverb Pan\n");
+
+				if (s_eaxSet(&s_FXSlotInfo[i].FXSlotGuid, EAXREVERB_REFLECTIONSPAN, NULL, &Pan, sizeof(EAXVECTOR))!=AL_NO_ERROR)
+					OutputDebugString("Failed to set Reflections Pan\n");
+			}
+		}
+
+		for (i = 0; i < s_NumFXSlots; i++)
+		{
+			if (s_FXSlotInfo[i].lEnvID == s_EnvironmentID)
+			{
+				lVolume = 0;
+				if (s_eaxSet(&s_FXSlotInfo[i].FXSlotGuid, EAXFXSLOT_VOLUME, NULL, &lVolume, sizeof(long))!=AL_NO_ERROR)
+					OutputDebugString("Failed to set Listener's FX Slot Volume to 0\n");
+			}
+			else
+			{
+				// This will change to lower the volume based on distance from aperture ...
+				lVolume = -600;
+				if (s_eaxSet(&s_FXSlotInfo[i].FXSlotGuid, EAXFXSLOT_VOLUME, NULL, &lVolume, sizeof(long))!=AL_NO_ERROR)
+					OutputDebugString("Failed to set FX Slot Volume to 0\n");
+			}
+		}
+	}
+
+	return;
+}
+
+/*
+	Updates the EAX Buffer related effects on the given Source
+*/
+static void UpdateEAXBuffer(channel_t *ch)
+{
+	HRESULT hr;
+	EMPOINT EMSourcePoint;
+	EMPOINT EMVirtualSourcePoint;
+	EAXOBSTRUCTIONPROPERTIES eaxOBProp;
+	EAXOCCLUSIONPROPERTIES eaxOCProp;
+	int i;
+	long lSourceID;
+
+	// If EAX Manager is not initialized, or there is no EAX support, or the listener
+	// is underwater, return
+	if ((!s_lpEAXManager) || (!s_bEAX) || (s_bInWater))
+		return;
+	
+	// Set Occlusion Direct Ratio to the default value (it won't get set by the current version of
+	// EAX Manager)
+	eaxOCProp.flOcclusionDirectRatio = EAXSOURCE_DEFAULTOCCLUSIONDIRECTRATIO;
+
+	// Convert Source co-ordinate to left-handed system
+	if (ch->fixed_origin)
+	{
+		// Converting from Quake -> DS3D (for EAGLE) ... swap Y and Z
+		EMSourcePoint.fX = ch->origin[0];
+		EMSourcePoint.fY = ch->origin[2];
+		EMSourcePoint.fZ = ch->origin[1];
+	}
+	else
+	{
+		if (ch->entnum == listener_number)
+		{
+			// Source at same position as listener
+			// Probably won't be any Occlusion / Obstruction effect -- unless the listener is underwater
+			// Converting from Open AL -> DS3D (for EAGLE) ... invert Z
+			EMSourcePoint.fX = listener_pos[0];
+			EMSourcePoint.fY = listener_pos[1];
+			EMSourcePoint.fZ = -listener_pos[2];
+		}
+		else
+		{
+			// Get position of Entity
+			// Converting from Quake -> DS3D (for EAGLE) ... swap Y and Z
+			if (ch->bLooping)
+			{
+				EMSourcePoint.fX = loopSounds[ ch->entnum ].origin[0];
+				EMSourcePoint.fY = loopSounds[ ch->entnum ].origin[2];
+				EMSourcePoint.fZ = loopSounds[ ch->entnum ].origin[1];
+			}
+			else
+			{
+				EMSourcePoint.fX = s_entityPosition[ch->entnum][0];
+				EMSourcePoint.fY = s_entityPosition[ch->entnum][2];
+				EMSourcePoint.fZ = s_entityPosition[ch->entnum][1];
+			}
+		}
+	}
+
+	long lExclusion;
+
+	// Just determine what environment the source is in
+	if (s_lpEAXManager->GetListenerDynamicAttributes(0, &EMSourcePoint, &lSourceID, 0)==EM_OK)
+	{
+		// See if a Slot is rendering this environment
+		for (i = 0; i < s_NumFXSlots; i++)
+		{
+			if (s_FXSlotInfo[i].lEnvID == lSourceID)
+			{
+				// If the Source is not sending to this slot, then enable the send now
+				if (ch->lSlotID != i)
+				{
+					// Set this
+					if (s_eaxSet(&EAXPROPERTYID_EAX40_Source, EAXSOURCE_ACTIVEFXSLOTID, ch->alSource, &s_FXSlotInfo[i].FXSlotGuid, sizeof(GUID))!=AL_NO_ERROR)
+						OutputDebugString("UpdateEAXBuffer = failed to set ActiveFXSlotID\n");
+
+					ch->lSlotID = i;
+				}
+
+				break;
+			}
+		}
+	}
+	else
+	{
+		OutputDebugString("UpdateEAXBuffer::Failed to get Source environment zone\n");
+	}
+
+	// Add some Exclusion to sounds that are not located in the Listener's environment
+	if (s_FXSlotInfo[ch->lSlotID].lEnvID == s_EnvironmentID)
+	{
+		lExclusion = 0;
+		if (s_eaxSet(&EAXPROPERTYID_EAX40_Source, EAXSOURCE_EXCLUSION, ch->alSource, &lExclusion, sizeof(long))!=AL_NO_ERROR)
+			OutputDebugString("UpdateEAXBuffer : Failed to set exclusion to 0\n");
+	}
+	else
+	{
+		lExclusion = -1000;
+		if (s_eaxSet(&EAXPROPERTYID_EAX40_Source, EAXSOURCE_EXCLUSION, ch->alSource, &lExclusion, sizeof(long))!=AL_NO_ERROR)
+			OutputDebugString("UpdateEAXBuffer : Failed to set exclusion to -1000\n");
+	}
+
+	if ((ch->entchannel == CHAN_VOICE) || (ch->entchannel == CHAN_VOICE_ATTEN) || (ch->entchannel == CHAN_VOICE_GLOBAL))
+	{
+		// Remove any Occlusion + Obstruction
+		eaxOBProp.lObstruction = EAXSOURCE_DEFAULTOBSTRUCTION;
+		eaxOBProp.flObstructionLFRatio = EAXSOURCE_DEFAULTOBSTRUCTIONLFRATIO;
+
+		eaxOCProp.lOcclusion = EAXSOURCE_DEFAULTOCCLUSION;
+		eaxOCProp.flOcclusionLFRatio = EAXSOURCE_DEFAULTOCCLUSIONLFRATIO;
+		eaxOCProp.flOcclusionRoomRatio = EAXSOURCE_DEFAULTOCCLUSIONROOMRATIO;
+		eaxOCProp.flOcclusionDirectRatio = EAXSOURCE_DEFAULTOCCLUSIONDIRECTRATIO;
+
+		s_eaxSet(&EAXPROPERTYID_EAX40_Source, EAXSOURCE_OBSTRUCTIONPARAMETERS,
+			ch->alSource, &eaxOBProp, sizeof(EAXOBSTRUCTIONPROPERTIES));
+
+		s_eaxSet(&EAXPROPERTYID_EAX40_Source, EAXSOURCE_OCCLUSIONPARAMETERS,
+			ch->alSource, &eaxOCProp, sizeof(EAXOCCLUSIONPROPERTIES));
+	}
+	else
+	{
+		// Check for Occlusion + Obstruction
+		hr = s_lpEAXManager->GetSourceDynamicAttributes(0, &EMSourcePoint, &eaxOBProp.lObstruction, &eaxOBProp.flObstructionLFRatio,
+			&eaxOCProp.lOcclusion, &eaxOCProp.flOcclusionLFRatio, &eaxOCProp.flOcclusionRoomRatio, &EMVirtualSourcePoint, 0);
+		if (hr == EM_OK)
+		{	
+			// Set EAX effect !
+			s_eaxSet(&EAXPROPERTYID_EAX40_Source, EAXSOURCE_OBSTRUCTIONPARAMETERS,
+				ch->alSource, &eaxOBProp, sizeof(EAXOBSTRUCTIONPROPERTIES));
+
+			s_eaxSet(&EAXPROPERTYID_EAX40_Source, EAXSOURCE_OCCLUSIONPARAMETERS,
+				ch->alSource, &eaxOCProp, sizeof(EAXOCCLUSIONPROPERTIES));
+		}
+	}
+
+	return;
+}
+
+float CalcDistance(EMPOINT A, EMPOINT B)
+{
+	return (float)sqrt(sqr(A.fX - B.fX)+sqr(A.fY - B.fY) + sqr(A.fZ - B.fZ));
+}
diff --git a/code/client/snd_dma_console.cpp b/code/client/snd_dma_console.cpp
new file mode 100644
index 0000000..e2faaf4
--- /dev/null
+++ b/code/client/snd_dma_console.cpp
@@ -0,0 +1,3090 @@
+/*****************************************************************************
+ * name:		snd_dma.c
+ *
+ * desc:		main control for any streaming sound output device
+ *
+ *
+ *****************************************************************************/
+// leave this as first line for PCH reasons...
+//
+// #include "../server/exe_headers.h"
+
+#include "snd_local_console.h"
+#include "snd_music.h"
+
+// #include "../../toolbox/zlib/zlib.h"
+
+#include "../client/client.h"
+#include "../qcommon/fixedmap.h"
+
+#ifdef _XBOX
+#include <Xtl.h>
+#endif
+
+#ifdef _GAMECUBE
+typedef const char* LPCSTR;
+#endif
+
+// Maps CRCs to offsets
+struct LipFileInfo
+{
+	unsigned long crc;
+	unsigned long offset;
+};
+static VVFixedMap< unsigned int, unsigned int >* s_lipSyncMap = NULL;
+static char *s_lipSyncData = NULL;
+
+static void S_Play_f(void);
+#ifndef _JK2MP
+static void S_PlayEx_f(void);
+#endif
+static void S_SoundList_f(void);
+static void S_Music_f(void);
+
+void S_Update_();
+void S_StopAllSounds(void);
+static void S_UpdateBackgroundTrack( void );
+unsigned int S_HashName( const char *name );
+static int SND_FreeSFXMem(sfx_t *sfx);
+
+/*static void S_FreeAllSFXMem(void);
+static void S_UnCacheDynamicMusic( void );
+*/
+extern unsigned long crc32(unsigned long crc, const unsigned char *buf, unsigned long len);
+
+extern int Sys_GetFileCodeSize(int code);
+
+extern void Sys_StreamInit(void);
+extern void Sys_StreamShutdown(void);
+
+qboolean SND_RegisterAudio_Clean(void);
+void S_KillEntityChannel(int entnum, int chan);
+
+//////////////////////////
+//
+// vars for bgrnd music track...
+//
+typedef struct
+{	
+	//
+	// disk-load stuff
+	//
+	char		sLoadedDataName[MAX_QPATH];
+	int			iFileCode;
+	int			iFileSeekTo;
+	bool		bLoaded;
+	//
+	// remaining dynamic fields...
+	//
+	int			iXFadeVolumeSeekTime;
+	int			iXFadeVolumeSeekTo;	// when changing this, set the above timer to Sys_Milliseconds(). 
+									//	Note that this should be thought of more as an up/down bool rather than as a 
+									//	number now, in other words set it only to 0 or 255. I'll probably change this
+									//	to actually be a bool later.
+	int			iXFadeVolume;		// 0 = silent, 255 = max mixer vol, though still modulated via overall music_volume 
+	float		fSmoothedOutVolume;
+	qboolean	bActive;			// whether playing or not
+	qboolean	bExists;			// whether was even loaded for this level (ie don't try and start playing it)
+	//
+	// new dynamic fields...
+	//
+	qboolean		bTrackSwitchPending;
+	qboolean		bLooping;
+	MusicState_e	eTS_NewState;
+	float			fTS_NewTime;
+	//
+	// Generic...
+	//
+	int				s_backgroundSize;
+	int				s_backgroundBPS;
+
+	void Rewind()
+	{
+		iFileSeekTo = 0;
+	}
+
+	void SeekTo(float fTime)
+	{
+		iFileSeekTo = (int)((float)(s_backgroundBPS) * fTime);
+	}
+
+	float TotalTime(void)
+	{
+		return (float)(s_backgroundSize) / (float)(s_backgroundBPS);
+	}
+
+	float PlayTime(void)
+	{
+		ALfloat playTime;
+		alGetStreamf(AL_TIME, &playTime);
+		return playTime;
+	}
+
+	float ElapsedTime(void)
+	{
+		return fmod(PlayTime(), TotalTime());
+	}
+} MusicInfo_t;
+
+static void S_SetDynamicMusicState( MusicState_e musicState );
+
+#define fDYNAMIC_XFADE_SECONDS (1.f)
+
+static MusicInfo_t	tMusic_Info[eBGRNDTRACK_NUMBEROF]	= {0};
+static qboolean		bMusic_IsDynamic					= qfalse;
+static MusicState_e	eMusic_StateActual					= eBGRNDTRACK_EXPLORE;	// actual state, can be any enum
+static MusicState_e	eMusic_StateRequest					= eBGRNDTRACK_EXPLORE;	// requested state, can only be explore, action, boss, or silence
+static char			sMusic_BackgroundLoop[MAX_QPATH]	= {0};	// only valid for non-dynamic music
+static char			sInfoOnly_CurrentDynamicMusicSet[64];	// any old reasonable size, only has to fit stuff like "kejim_post"
+//
+//////////////////////////
+
+// =======================================================================
+// Internal sound data & structures
+// =======================================================================
+ 
+// only begin attenuating sound volumes when outside the FULLVOLUME range
+#define		SOUND_FULLVOLUME	256
+
+#define		SOUND_ATTENUATE		0.0008f
+#define		VOICE_ATTENUATE		0.004f
+
+// This number has dramatic affects on volume.  QA has
+// determined that 100 is too quiet in some spots and
+// 200 is too loud in others.  Modify with care...
+#define		SOUND_REF_DIST_BASE	150.f
+
+#define		SOUND_UPDATE_TIME	100
+
+const float	SOUND_FMAXVOL=0.75;//1.0;
+const int	SOUND_MAXVOL=255;
+
+int					s_soundStarted;
+qboolean			s_soundMuted;
+int					s_loopEnabled;
+int					s_updateTime;
+
+struct listener_t
+{
+	ALuint handle;
+	ALfloat pos[3];
+	ALfloat orient[6];
+	int entnum;
+};
+
+#define SND_MAX_LISTENERS 1
+static listener_t s_listeners[SND_MAX_LISTENERS];
+static int s_numListeners;
+
+static int			s_numChannels;			// Number of AL Sources == Num of Channels
+
+#ifdef _XBOX
+#	define	MAX_CHANNELS_2D 64
+#	define	MAX_CHANNELS_3D 64
+#else
+#	define	MAX_CHANNELS_2D 30
+#	define	MAX_CHANNELS_3D 30
+#endif
+
+#define MAX_CHANNELS (MAX_CHANNELS_2D + MAX_CHANNELS_3D)
+static channel_t*   s_channels;
+
+#define	MAX_SFX 2048
+#define INVALID_CODE 0
+static sfx_t* s_sfxBlock;
+static int* s_sfxCodes;
+
+static bool s_registered = false;
+static int s_defaultSound = 0;
+
+typedef struct 
+{ 
+	int				volume;
+	vec3_t			origin;
+	sfx_t			*sfx;
+	int				entnum;
+	int				entchannel;
+	bool			bProcessed;
+	bool			bMarked;
+} loopSound_t;
+
+#define	MAX_LOOP_SOUNDS 32
+static int numLoopSounds;
+static loopSound_t* loopSounds;
+
+int* s_entityWavVol = NULL;
+
+cvar_t		*s_effects_volume;
+cvar_t		*s_music_volume;
+cvar_t		*s_voice_volume;
+cvar_t		*s_testsound;
+cvar_t		*s_allowDynamicMusic;
+cvar_t		*s_show;
+cvar_t		*s_separation;
+cvar_t		*s_CPUType;
+cvar_t		*s_debugdynamic;
+cvar_t		*s_soundpoolmegs;
+cvar_t		*s_language;	// note that this is distinct from "g_language"
+
+
+
+void S_SoundInfo_f(void) {	
+	Com_Printf("----- Sound Info -----\n" );
+
+	if (!s_soundStarted) {
+		Com_Printf ("sound system not started\n");
+	} else {
+		if ( s_soundMuted ) {
+			Com_Printf ("sound system is muted\n");
+		}
+	}
+	S_DisplayFreeMemory();
+	Com_Printf("----------------------\n" );
+}
+
+
+
+/*
+================
+S_Init
+================
+*/
+void S_Init( void ) {
+	ALCcontext *ALCContext = NULL;
+	ALCdevice *ALCDevice = NULL;
+	cvar_t	*cv;
+
+	Com_Printf("\n------- sound initialization -------\n");
+
+	AS_Init();
+
+	s_effects_volume = Cvar_Get ("s_effects_volume", "0.5", CVAR_ARCHIVE);
+	s_voice_volume= Cvar_Get ("s_voice_volume", "1.0", CVAR_ARCHIVE);
+	s_music_volume = Cvar_Get ("s_music_volume", "0.25", CVAR_ARCHIVE);
+	s_separation = Cvar_Get ("s_separation", "0.5", CVAR_ARCHIVE);
+	s_allowDynamicMusic = Cvar_Get ("s_allowDynamicMusic", "1", CVAR_ARCHIVE);
+
+	s_show = Cvar_Get ("s_show", "0", CVAR_CHEAT);
+	s_testsound = Cvar_Get ("s_testsound", "0", CVAR_CHEAT);
+	s_debugdynamic = Cvar_Get("s_debugdynamic","0", CVAR_CHEAT);
+
+	s_CPUType = Cvar_Get("sys_cpuid","",0);
+	s_soundpoolmegs = Cvar_Get("s_soundpoolmegs", "6", CVAR_ARCHIVE);
+
+	s_language = Cvar_Get("s_language","english",CVAR_ARCHIVE | CVAR_NORESTART);
+
+	cv = Cvar_Get ("s_initsound", "1", CVAR_ROM);
+	if ( !cv->integer ) {
+		s_soundStarted = 0;	// needed in case you set s_initsound to 0 midgame then snd_restart (div0 err otherwise later)
+		Com_Printf ("not initializing.\n");
+		Com_Printf("------------------------------------\n");
+		return;
+	}
+
+	Cmd_AddCommand("play", S_Play_f);
+#ifndef _JK2MP
+	Cmd_AddCommand("playex", S_PlayEx_f);
+#endif
+	Cmd_AddCommand("music", S_Music_f);
+	Cmd_AddCommand("soundlist", S_SoundList_f);
+	Cmd_AddCommand("soundinfo", S_SoundInfo_f);
+	Cmd_AddCommand("soundstop", S_StopAllSounds);
+
+	s_entityWavVol = new int[MAX_GENTITIES];
+	
+	// clear out the lip synching override array
+	memset(s_entityWavVol, 0, sizeof(int) * MAX_GENTITIES);
+
+	ALCDevice = alcOpenDevice((ALubyte*)"DirectSound3D");
+	if (!ALCDevice)
+		return;
+
+	//Create context(s)
+	ALCContext = alcCreateContext(ALCDevice, NULL);
+	if (!ALCContext)
+		return;
+
+	//Set active context
+	alcMakeContextCurrent(ALCContext);		
+	if (alcGetError(ALCDevice) != ALC_NO_ERROR)
+		return;
+
+	s_channels = new channel_t[MAX_CHANNELS];
+	
+	s_sfxBlock = new sfx_t[MAX_SFX];
+	s_sfxCodes = new int[MAX_SFX];
+	memset(s_sfxCodes, INVALID_CODE, sizeof(int) * MAX_SFX);
+
+	loopSounds = new loopSound_t[MAX_LOOP_SOUNDS];
+
+	S_StopAllSounds();
+
+	s_soundStarted = 1;
+	s_soundMuted = 1;
+	s_loopEnabled = 0;
+	s_updateTime = 0;
+
+	S_SoundInfo_f();
+
+	memset(s_channels, 0, sizeof(channel_t) * MAX_CHANNELS);
+	s_numChannels = 0;
+	
+	// create music channel
+	alGenStream();
+
+	Com_Printf("------------------------------------\n");
+
+	S_InitLoad();
+
+	// Load all the lipsync index data first:
+	void *buffer;
+	int len = FS_ReadFile("lipdata.idx", &buffer);
+	if( len == -1 )
+		Com_Error(ERR_DROP, "ERROR: No lip sync index file\n");
+	int numLipFiles = len / sizeof(LipFileInfo);
+	LipFileInfo *lbuf = (LipFileInfo *)buffer;
+	s_lipSyncMap = new VVFixedMap< unsigned int, unsigned int >(numLipFiles);
+	for( int i = 0; i < numLipFiles; ++i )
+		s_lipSyncMap->Insert(lbuf[i].offset, lbuf[i].crc);
+	FS_FreeFile(buffer);
+
+	// Now load the actual lip sync data
+	len = FS_ReadFile("lipdata.dat", &buffer);
+	if( len == -1 )
+		Com_Error(ERR_DROP, "ERROR: No lip sync data file\n");
+	s_lipSyncData = new char[len];
+	memcpy(s_lipSyncData, buffer, len);
+	FS_FreeFile(buffer);
+}
+
+// only called from snd_restart. QA request...
+//
+void S_ReloadAllUsedSounds(void)
+{
+	if (s_soundStarted && !s_soundMuted )
+	{
+		// new bit, reload all soundsthat are used on the current level->..
+		//
+		for (int i = 0; i < MAX_SFX; ++i)
+		{
+			if (s_sfxCodes[i] == INVALID_CODE || s_sfxCodes[i] == s_defaultSound) continue;
+
+			sfx_t *sfx = &s_sfxBlock[i];
+
+			if ((sfx->iFlags & SFX_FLAG_UNLOADED) && 
+				!(sfx->iFlags & (SFX_FLAG_DEFAULT | SFX_FLAG_DEMAND)))
+			{
+				S_StartLoadSound(sfx);
+			}
+		}
+	}
+}
+
+// =======================================================================
+// Shutdown sound engine
+// =======================================================================
+
+void S_Shutdown( void )
+{
+	ALCcontext	*ALCContext;
+	ALCdevice	*ALCDevice;
+	int			i;
+
+	delete [] s_entityWavVol;
+	s_entityWavVol = NULL;
+
+	if ( !s_soundStarted ) {
+		return;
+	}
+
+	alDeleteStream();
+
+	// Release all the AL Sources (including Music channel (Source 0))
+	for (i = 0; i < s_numChannels; i++)
+	{
+		alDeleteSources(1, &(s_channels[i].alSource));
+	}
+
+	S_FreeAllSFXMem();
+	S_UnCacheDynamicMusic();
+	
+	// Release listeners
+	for (i = 0; i < s_numListeners; ++i)
+	{
+		alDeleteListeners(1, &s_listeners[i].handle);
+	}
+	s_numListeners = 0;
+	
+	delete [] s_channels;
+	delete [] s_sfxBlock;
+	delete [] s_sfxCodes;
+	delete [] loopSounds;
+
+	// Get active context
+	ALCContext = alcGetCurrentContext();
+	// Get device for active context
+	ALCDevice = alcGetContextsDevice(ALCContext);
+	// Release context(s)
+	alcDestroyContext(ALCContext);
+	// Close device
+	alcCloseDevice(ALCDevice);
+	
+	s_numChannels = 0;
+	s_soundStarted = 0;
+
+	Cmd_RemoveCommand("play");
+	Cmd_RemoveCommand("music");
+	Cmd_RemoveCommand("stopsound");
+	Cmd_RemoveCommand("soundlist");
+	Cmd_RemoveCommand("soundinfo");
+	AS_Free();
+	S_CloseLoad();
+}
+
+
+
+/*
+	Mutes / Unmutes all OpenAL sound
+*/
+void S_AL_MuteAllSounds(qboolean bMute)
+{
+	if (!s_soundStarted) return;
+	if (bMute) alGain(0.f);
+	else alGain(1.f);
+}
+
+void S_SetVolume(float volume)
+{
+	if (!s_soundStarted) return;
+	alGain(volume);
+	alUpdate();
+}
+
+
+
+
+
+// =======================================================================
+// Load a sound
+// =======================================================================
+/*
+==================
+S_FixMusicFileExtension
+==================
+*/
+char* S_FixMusicFileName(const char* name)
+{
+	static char xname[MAX_QPATH];
+
+#if defined(_XBOX)
+	const char* ext = "wxb";
+#elif defined(_WINDOWS)
+	const char* ext = "wav";
+#elif defined(_GAMECUBE)
+	const char* ext = "adp";
+#endif
+
+	Q_strncpyz(xname, name, sizeof(xname));
+	if (xname[strlen(xname) - 4] != '.')
+	{
+		strcat(xname, ".");
+		strcat(xname, ext);
+	}
+	else
+	{
+		int len = strlen(xname);
+		xname[len-3] = ext[0];
+		xname[len-2] = ext[1];
+		xname[len-1] = ext[2];
+	}
+
+#ifdef _GAMECUBE
+	if (!strncmp("music/", xname, 6) ||
+		!strncmp("music\\", xname, 6))
+	{
+		char chan_name[MAX_QPATH];
+
+		/*
+		ALint is_stereo;
+		alGeti(AL_STEREO, &is_stereo);
+
+		sprintf(chan_name,"music-%s/%s", 
+			is_stereo ? "stereo" : "mono", &xname[6]);
+		strcpy(xname, chan_name);
+		*/
+
+		sprintf(chan_name,"music-stereo/%s", &xname[6]);
+		strcpy(xname, chan_name);
+	}
+#endif
+	
+	return xname;
+}
+
+
+/*
+==================
+S_HashName
+==================
+*/
+unsigned int S_HashName( const char *name ) {
+	if (!name) {
+		Com_Error (ERR_FATAL, "S_HashName: NULL\n");
+	}
+	if (!name[0]) {
+		Com_Error (ERR_FATAL, "S_HashName: empty name\n");
+	}
+
+	if (strlen(name) >= MAX_QPATH) {
+		Com_Error (ERR_FATAL, "Sound name too long: %s", name);
+	}
+
+	char sSoundNameNoExt[MAX_QPATH];
+	COM_StripExtension(name,sSoundNameNoExt);
+
+	Q_strlwr(sSoundNameNoExt);
+	for (int i = 0; i < strlen(sSoundNameNoExt); ++i)
+	{
+		if (sSoundNameNoExt[i] == '\\') sSoundNameNoExt[i] = '/';
+	}
+
+	return crc32(0, (const byte *)sSoundNameNoExt, strlen(sSoundNameNoExt));
+}
+
+/*
+===================
+S_DisableSounds
+
+Disables sounds until the next S_BeginRegistration.
+This is called when the hunk is cleared and the sounds
+are no longer valid.
+===================
+*/
+void S_DisableSounds( void ) {
+	if (!s_soundStarted) return;
+	S_StopAllSounds();
+	SND_RegisterAudio_Clean(); // unregister sounds
+	s_soundMuted = qtrue;
+}
+
+void S_SetLoopState( qboolean s ) {
+	if (!s_soundStarted) return;
+	s_loopEnabled = s;
+}
+
+void S_CreateSources( void ) {
+	int i;
+
+	// Remove any old sources
+	for (i = 0; i < s_numChannels; ++i)
+	{
+		alDeleteSources(1, &s_channels[i].alSource);
+	}
+	s_numChannels = 0;
+
+	// Create as many AL Sources (up to Max) as possible
+	int limit = MAX_CHANNELS_2D + MAX_CHANNELS_3D / s_numListeners;
+	for (i = 0; i < limit; i++)
+	{
+		if (i < MAX_CHANNELS_2D)
+		{
+			alGenSources2D(1, &s_channels[i].alSource);
+			s_channels[i].b2D = true;
+		}
+		else
+		{
+			alGenSources3D(1, &s_channels[i].alSource);
+			s_channels[i].b2D = false;
+		}
+
+		if (alGetError() != AL_NO_ERROR)
+		{
+			// Reached limit of sources
+			break;
+		}
+
+		if (!s_channels[i].b2D)
+		{
+			alSourcef(s_channels[i].alSource, AL_REFERENCE_DISTANCE, SOUND_REF_DIST_BASE);
+		}
+
+		s_numChannels++;
+	}
+
+	assert(s_numChannels > MAX_CHANNELS_2D);
+}
+
+/*
+=====================
+S_BeginRegistration
+
+=====================
+*/
+void S_BeginRegistration( void )
+{
+	if (!s_soundStarted) return;
+
+	int i;
+	int num_listeners = 1;
+
+	// Turn sound back on.
+	s_soundMuted = qfalse;
+
+	// Create listeners
+	assert(num_listeners <= SND_MAX_LISTENERS);
+	if (num_listeners < s_numListeners)
+	{
+		// remove some listeners
+		for (i = num_listeners; i < s_numListeners; ++i)
+		{
+			alDeleteListeners(1, &s_listeners[i].handle);
+		}
+
+		s_numListeners = num_listeners;
+	
+		S_CreateSources();
+	}
+	else if (num_listeners > s_numListeners)
+	{
+		// add some listeners
+		for (i = s_numListeners; i < num_listeners; ++i)
+		{
+			memset(&s_listeners[i], 0, sizeof(listener_t));
+			s_listeners[i].entnum = i;
+			s_listeners[i].orient[2] = -1;
+			s_listeners[i].orient[4] = 1;
+			alGenListeners(1, &s_listeners[i].handle);
+			alListenerfv(s_listeners[i].handle, AL_POSITION, s_listeners[i].pos);
+			alListenerfv(s_listeners[i].handle, AL_ORIENTATION, s_listeners[i].orient);
+		}
+		
+		s_numListeners = num_listeners;
+		
+		S_CreateSources();
+	}
+
+	S_SetLoopState(qtrue);
+
+	if (!s_registered) {
+		s_defaultSound = S_RegisterSound("sound/null.wav");
+		S_LoadSound(s_defaultSound);
+		s_registered = true;
+	}
+}
+
+/*
+==================
+S_LookupSfx
+==================
+*/
+sfxHandle_t S_LookupSfx(int hash) 
+{
+	for (int i = 0; i < MAX_SFX; ++i)
+	{
+		if (s_sfxCodes[i] == hash)
+		{
+			return i;
+		}
+	}
+	return -1;
+}
+
+/*
+==================
+S_AllocSfx
+==================
+*/
+sfxHandle_t S_AllocSfx(int hash) 
+{
+	for (int i = 0; i < MAX_SFX; ++i)
+	{
+		if (s_sfxCodes[i] == INVALID_CODE)
+		{
+			s_sfxCodes[i] = hash;
+			return i;
+		}
+	}
+	return -1;
+}
+
+extern void	COM_StripExtension( const char *in, char *out );
+extern char *FS_BuildOSPath( const char *qpath );
+
+// Convert pathname to filecode
+int Lip_GetFileCode(const char* name)
+{
+	// Get system level path
+	char* osname = FS_BuildOSPath(name);
+
+	// Generate hash for file name
+	strlwr(osname);
+	unsigned int code = crc32(0, (const unsigned char *)osname, strlen(osname));
+
+	return code;
+}
+
+static void	S_LoadLips(sfx_t* thesfx, const char* name)
+{
+	// Sanity checks
+	if( !s_lipSyncData || !s_lipSyncMap )
+		return;
+
+	// get the lipfile name -> turn it into a crc
+	char lipfile[MAX_QPATH];
+	COM_StripExtension(name,lipfile);
+	strcat(lipfile,".lip");
+	unsigned int code = Lip_GetFileCode( lipfile );
+
+	// Lookup in the fixed map
+	unsigned int *pOffset = s_lipSyncMap->Find(code);
+	if( !pOffset )
+		return;
+
+	// OK. Set the pointer to the right data
+	thesfx->pLipSyncData = s_lipSyncData + *pOffset;
+}
+
+
+
+/*
+==================
+S_RegisterSound
+
+Creates a default buzz sound if the file can't be loaded
+==================
+*/
+sfxHandle_t	S_RegisterSound(const char *name)
+{
+	sfx_t *sfx;
+	unsigned int hash;
+	sfxHandle_t handle;
+
+	if (!s_soundStarted) {
+		return 0;
+	}
+
+	if ( strlen( name ) >= MAX_QPATH || !name[0] ) {		
+		Com_Printf( S_COLOR_RED"Sound name exceeds MAX_QPATH - %s\n", name );
+		return s_defaultSound;
+	}
+
+	/* Temporary fix for levels that try to precache music and play them as sfx */
+	if (strstr(name, "MUSIC"))
+	{
+		Com_Printf( "WARNING: Trying to play music file %s through S_StartSound!\n", name );
+		return s_defaultSound;
+	}
+
+	hash = S_HashName( name );
+	handle = S_LookupSfx(hash);
+	
+	if (handle < 0)
+	{
+		handle = S_AllocSfx(hash);
+
+		if (handle < 0)
+			Com_Error (ERR_DROP, "No free sound channels");
+
+		sfx = &s_sfxBlock[handle];
+		memset(sfx, 0, sizeof(sfx_t));
+
+		if (strlen(name) < 5 || name[0] == '*') sfx->iFileCode = -1;
+		else sfx->iFileCode = S_GetFileCode(name);
+
+		sfx->iFlags |= SFX_FLAG_UNLOADED;
+	}
+	else
+	{
+		sfx = &s_sfxBlock[handle];
+	}
+
+	SND_TouchSFX(sfx);
+
+	if ( sfx->iFileCode == -1 ) sfx->iFlags |= SFX_FLAG_DEFAULT;
+
+	sfx->pLipSyncData = NULL;
+
+	if (strstr(name, "chars") ||
+		strstr(name, "chr_d") ||
+		strstr(name, "chr_f") ||
+		strstr(name, "CHARS"))
+	{
+		sfx->iFlags |= SFX_FLAG_VOICE;
+		sfx->iFlags |= SFX_FLAG_DEMAND;
+
+		// load up the lip sync data
+		S_LoadLips(sfx, name);
+	}
+
+	if ( sfx->iFlags & SFX_FLAG_DEFAULT )
+	{
+		sfx->iFlags |= SFX_FLAG_RESIDENT;
+		return s_defaultSound;
+	}
+
+	//can be uncommented for debugging if soundname is used
+	//also uncomment sSoundName from sfx_t
+	//sfx->sSoundName = CopyString(name);
+
+	return handle;
+}
+
+
+//=============================================================================
+channel_t *S_FindFurthestChannel(void)
+{
+	int			ch_idx;
+	channel_t	*ch;
+	channel_t	*ch_firstToDie = NULL;
+	int			li_idx;
+	listener_t	*li;
+	int			longestDist = -1;
+	int			dist;
+
+	for (li_idx = 0, li = s_listeners; li_idx < s_numListeners; ++li_idx, ++li)
+	{
+		for (ch_idx = MAX_CHANNELS_2D, ch = s_channels + ch_idx; 
+		ch_idx < s_numChannels; ch_idx++, ch++)
+		{				
+			dist = 
+				((li->pos[0] - ch->origin[0]) * (li->pos[0] - ch->origin[0])) +
+				((li->pos[1] - ch->origin[1]) * (li->pos[1] - ch->origin[1])) +
+				((li->pos[2] - ch->origin[2]) * (li->pos[2] - ch->origin[2]));
+			
+			if (dist > longestDist)
+			{
+				longestDist = dist;
+				ch_firstToDie = ch;
+			}
+		}
+	}
+
+	return ch_firstToDie;
+}
+
+static bool IsListenerEnt(int entnum)
+{
+	for (int i = 0; i < s_numListeners; ++i)
+	{
+		if (s_listeners[i].entnum == entnum) return true;
+	}
+	return false;
+}
+
+/*
+=================
+S_PickChannel
+=================
+*/
+channel_t *S_PickChannel(int entnum, int entchannel, bool is2D, sfx_t* sfx)
+{
+	int			ch_idx;
+	channel_t	*ch, *ch_firstToDie;
+	bool	foundChan = false;
+
+	if ( entchannel < 0 ) 
+	{
+		Com_Error (ERR_DROP, "S_PickChannel: entchannel<0");
+	}
+
+	// Check for replacement sound, or find the best one to replace
+
+    ch_firstToDie = s_channels;
+	unsigned int age = 0xFFFFFFFF;
+
+	for (ch_idx = 0, ch = s_channels + ch_idx; ch_idx < s_numChannels; ch_idx++, ch++)
+	{
+		// Special check to prevent 2d voices from being played
+		// twice in 2 player games...
+		if (is2D && ch->b2D && 
+			sfx == ch->thesfx && 
+			ch->bPlaying && 
+			(sfx->iFlags & SFX_FLAG_VOICE))
+		{
+			return NULL;
+		}
+		
+		// See if the channel is free
+		if (!ch->thesfx && is2D == ch->b2D && ch->iLastPlayTime < age)
+		{
+			ch_firstToDie = ch;
+			age = ch->iLastPlayTime;
+			foundChan = true;
+		}
+	}
+
+	if (!foundChan)
+	{
+		for (ch_idx = 0, ch = s_channels + ch_idx; ch_idx < s_numChannels; ch_idx++, ch++)
+		{
+			if ( (ch->entnum == entnum) && 
+				(ch->entchannel == entchannel) && 
+				(ch->entchannel != CHAN_AMBIENT) && 
+				(!IsListenerEnt(ch->entnum)) &&
+				(ch->b2D == is2D) &&
+				(!ch_firstToDie->thesfx || 
+				!(ch_firstToDie->thesfx->iFlags & SFX_FLAG_LOADING)) ) 
+			{
+				// Same entity and same type of sound effect (entchannel)
+				ch_firstToDie = ch;
+				foundChan = true;
+				break;
+			}
+		}
+	}
+
+	if (!foundChan)
+	{
+		if (is2D)
+		{
+			// Find random sound effect
+			ch_firstToDie = s_channels + (rand() % MAX_CHANNELS_2D);
+		}
+		else
+		{
+			// Find sound effect furthest from listeners
+			ch_firstToDie = S_FindFurthestChannel();
+		}
+	}
+
+	assert(ch_firstToDie->b2D == is2D);
+
+	if (ch_firstToDie->thesfx && ch_firstToDie->thesfx->iFlags & SFX_FLAG_LOADING)
+	{
+		// If the sound is loading, just give up...
+		return NULL;
+	}
+	
+	if (ch_firstToDie->bPlaying)
+	{
+#ifdef _XBOX
+		// We have an insane amount of channels on the Xbox
+		// and stopping one is a blocking operation.  Let's
+		// just assume that no one will care if a sound is
+		// dropped when over 100 are already playing...
+		return NULL;
+#else
+		// Stop sound
+		alSourceStop(ch_firstToDie->alSource);
+		ch_firstToDie->bPlaying = false;
+#endif
+	}
+
+	// Reset channel variables
+	alSourcei(ch_firstToDie->alSource, AL_BUFFER, 0);
+	ch_firstToDie->thesfx = NULL;
+	ch_firstToDie->bLooping = false;
+	
+    return ch_firstToDie;
+}
+
+
+
+// =======================================================================
+// Start a sound effect
+// =======================================================================
+
+static void SetChannelOrigin(channel_t *ch, const vec3_t origin, int entityNum)
+{
+	if (origin) 
+	{
+		ch->origin[0] = origin[0];
+		ch->origin[1] = origin[1];
+		ch->origin[2] = origin[2];
+	}
+	else
+	{
+		vec3_t pos;
+
+		extern void G_EntityPosition( int i, vec3_t ret );
+		G_EntityPosition(entityNum, pos);
+		
+		ch->origin[0] = pos[0];
+		ch->origin[1] = pos[1];
+		ch->origin[2] = pos[2];
+	}
+
+	ch->bOriginDirty = true;
+}
+
+/*
+====================
+S_StartAmbientSound
+
+Starts an ambient, 'one-shot" sound.
+====================
+*/
+
+void S_StartAmbientSound( const vec3_t origin, int entityNum, unsigned char volume, sfxHandle_t sfxHandle )
+{
+	channel_t	*ch;
+	/*const*/ sfx_t *sfx;
+
+	if ( !s_soundStarted || s_soundMuted ) {
+		return;
+	}
+	if ( sfxHandle < 0 || sfxHandle > MAX_SFX || s_sfxCodes[sfxHandle] == INVALID_CODE ) {
+		return;
+	}
+	if ( !origin && ( entityNum < 0 || entityNum > MAX_GENTITIES ) ) {
+		Com_Error( ERR_DROP, "S_StartAmbientSound: bad entitynum %i", entityNum );
+	}
+
+	sfx = &s_sfxBlock[sfxHandle];
+	if (sfx->iFlags & SFX_FLAG_UNLOADED){
+		S_StartLoadSound(sfx);
+	}	
+	SND_TouchSFX(sfx);
+
+	// pick a channel to play on
+	bool is2D = false;
+	for (int i = 0; i < s_numListeners; ++i)
+	{
+		if ((entityNum == s_listeners[i].entnum && !origin) ||
+			(origin &&
+			origin[0] == s_listeners[i].pos[0] &&
+			origin[1] == s_listeners[i].pos[1] &&
+			origin[2] == s_listeners[i].pos[2]))
+		{
+			is2D = true;
+			break;
+		}
+	}
+
+	ch = S_PickChannel( entityNum, CHAN_AMBIENT, is2D, NULL );
+	if (!ch) {
+		return;
+	}
+	
+	if (!is2D)
+	{
+		SetChannelOrigin(ch, origin, entityNum);
+	}
+
+	ch->master_vol = volume;
+	ch->fLastVolume = -1;
+	ch->entnum = entityNum;
+	ch->entchannel = CHAN_AMBIENT;
+	ch->thesfx = sfx;
+}
+
+/*
+====================
+S_MuteSound
+
+Mutes sound on specified channel for specified entity.
+This seems to be implemented quite incorrectly on PC. I
+think the following is what this function should do...
+
+Perhaps we should actually be changing the volume on all
+the channels that meet our criteria, but for now we'll just
+kill the sounds and hope it does what is expected.
+====================
+*/
+void S_MuteSound(int entityNum, int entchannel) 
+{
+	S_KillEntityChannel( entityNum, entchannel );
+
+/*
+	if (!s_soundStarted) {
+		return;
+	}
+
+	//I guess this works.
+	channel_t *ch = S_PickChannel( entityNum, entchannel );
+
+	if (!ch)
+	{
+		return;
+	}
+
+	ch->master_vol = 0;
+	ch->entnum = 0;
+	ch->entchannel = 0;
+	ch->thesfx = 0;
+	ch->startSample = 0;
+
+	ch->leftvol = 0;
+	ch->rightvol = 0;
+*/
+}
+
+/*
+====================
+S_StartSound
+
+Validates the parms and ques the sound up
+if pos is NULL, the sound will be dynamically sourced from the entity
+Entchannel 0 will never override a playing sound
+====================
+*/
+void S_StartSound(const vec3_t origin, int entityNum, int entchannel, sfxHandle_t sfxHandle ) 
+{
+	channel_t	*ch;
+	/*const*/ sfx_t *sfx;
+
+	if ( !s_soundStarted || s_soundMuted ) {
+		return;
+	}
+
+	if ( sfxHandle < 0 || sfxHandle > MAX_SFX || s_sfxCodes[sfxHandle] == INVALID_CODE ) {
+		return;
+	}
+
+	if ( !origin && ( entityNum < 0 || entityNum > MAX_GENTITIES ) ) {
+		Com_Error( ERR_DROP, "S_StartSound: bad entitynum %i", entityNum );
+	}
+
+	sfx = &s_sfxBlock[sfxHandle];
+
+	if (sfx->iFlags & SFX_FLAG_UNLOADED){
+		S_StartLoadSound(sfx);
+	}
+	SND_TouchSFX(sfx);
+
+	// pick a channel to play on
+	bool is2D = false;
+	for (int i = 0; i < s_numListeners; ++i)
+	{
+		if ((entityNum == s_listeners[i].entnum && !origin) ||
+			(origin &&
+			origin[0] == s_listeners[i].pos[0] &&
+			origin[1] == s_listeners[i].pos[1] &&
+			origin[2] == s_listeners[i].pos[2]))
+		{
+			is2D = true;
+			break;
+		}
+	}
+	
+	ch = S_PickChannel( entityNum, entchannel, is2D, sfx );
+	if (!ch) {
+		return;
+	}
+
+	if (!is2D)
+	{
+		SetChannelOrigin(ch, origin, entityNum);
+	}
+		
+	if (entchannel == CHAN_AUTO && (sfx->iFlags & SFX_FLAG_VOICE)) {
+		entchannel = CHAN_VOICE; // Compensate of the incompetance of others. Yeah. ;)
+//		entchannel = CHAN_VOICE_ATTEN; // Super hack to put Rancor noises on a different channel E3!
+	}
+
+	ch->master_vol = SOUND_MAXVOL;	//FIXME: Um.. control?
+	ch->fLastVolume = -1;
+	ch->entnum = entityNum;
+	ch->entchannel = entchannel;
+	ch->thesfx = sfx;
+
+	if (entchannel < CHAN_AMBIENT && IsListenerEnt(ch->entnum))
+	{
+		ch->master_vol = SOUND_MAXVOL * SOUND_FMAXVOL;	//this won't be attenuated so let it scale down
+	}
+	if ( entchannel == CHAN_VOICE || entchannel == CHAN_VOICE_ATTEN || entchannel == CHAN_VOICE_GLOBAL ) 
+	{
+		s_entityWavVol[ ch->entnum ] = -1;	//we've started the sound but it's silent for now
+	}
+}
+
+/*
+==================
+S_StartLocalSound
+==================
+*/
+void S_StartLocalSound( sfxHandle_t sfxHandle, int channelNum ) {
+	if ( !s_soundStarted || s_soundMuted ) {
+		return;
+	}
+
+	// Play a 2D sound -- doesn't matter which listener we use
+	S_StartSound (NULL, 0, channelNum, sfxHandle );
+}
+
+
+/*
+==================
+S_StartLocalLoopingSound
+==================
+*/
+void S_StartLocalLoopingSound( sfxHandle_t sfxHandle) {
+	vec3_t nullVec = {0,0,0};
+
+	if ( !s_soundStarted || s_soundMuted ) {
+		return;
+	}
+
+	// Play a 2D sound -- doesn't matter which listener we use
+	S_AddLoopingSound( 0, nullVec, nullVec, sfxHandle, CHAN_AMBIENT );
+
+}
+
+// Kill an voice sounds from an entity
+void S_KillEntityChannel(int entnum, int chan)
+{
+	int i;
+	channel_t *ch;
+
+	if ( !s_soundStarted ) {
+		return;
+	}
+
+	if ( entnum < s_numListeners && chan == CHAN_VOICE ) {
+		// don't kill player death sounds
+		return;
+	}
+
+	ch = s_channels;
+	for (i = 0; i < s_numChannels; i++, ch++)
+	{
+		if (ch->bPlaying &&
+			ch->entnum == entnum &&
+			ch->entchannel == chan)
+		{
+			alSourceStop(ch->alSource);
+			ch->bPlaying = false;
+	
+			alSourcei(ch->alSource, AL_BUFFER, 0);
+			if(ch->thesfx)
+				ch->thesfx->pLipSyncData = NULL;
+			ch->thesfx = NULL;
+			ch->bLooping = false;
+		}
+	}
+}
+
+/*
+==================
+S_StopLoopingSound
+
+Stops all active looping sounds on a specified entity.
+Sort of a slow method though, isn't there some better way?
+==================
+*/
+void S_StopLoopingSound( int entnum )
+{
+	if (!s_soundStarted) {
+		return;
+	}
+
+	int i = 0;
+
+	while (i < numLoopSounds)
+	{
+		if (loopSounds[i].entnum == entnum)
+		{
+			int x = i+1;
+			while (x < numLoopSounds)
+			{
+				memcpy(&loopSounds[x-1], &loopSounds[x], sizeof(loopSounds[x]));
+				x++;
+			}
+			numLoopSounds--;
+		}
+		i++;
+	}
+}
+
+// returns length in milliseconds of supplied sound effect...  (else 0 for bad handle now)
+//
+float S_GetSampleLengthInMilliSeconds( sfxHandle_t sfxHandle)
+{
+	sfx_t *sfx;
+
+	if (!s_soundStarted)
+	{	//we have no sound, so let's just make a reasonable guess
+		return 512;
+	}
+
+	if ( s_sfxCodes[sfxHandle] == INVALID_CODE ) {
+		return 0.0f;
+	}
+
+	sfx = &s_sfxBlock[sfxHandle];
+
+	int size = Sys_GetFileCodeSize(sfx->iFileCode);
+	if (size < 0) return 0;
+
+	return 1000 * size / (22050 / 2);
+}
+
+/*
+==================
+S_LoadSound
+==================
+*/
+void S_LoadSound( sfxHandle_t sfxHandle ) 
+{
+	/*const*/ sfx_t *sfx;
+
+	if ( !s_soundStarted || s_soundMuted ) {
+		return;
+	}
+
+	if ( sfxHandle < 0 || sfxHandle > MAX_SFX || s_sfxCodes[sfxHandle] == INVALID_CODE ) {
+		return;
+	}
+
+	sfx = &s_sfxBlock[sfxHandle];
+
+	if (sfx->iFlags & SFX_FLAG_UNLOADED){
+		S_StartLoadSound(sfx);
+
+		extern void S_DrainRawSoundData(void);
+		S_DrainRawSoundData();
+	}
+}
+
+/*
+==================
+S_ClearSoundBuffer
+
+If we are about to perform file access, clear the buffer
+so sound doesn't stutter.
+==================
+*/
+void S_ClearSoundBuffer( void ) {
+	if ( !s_soundStarted || s_soundMuted ) {
+		return;
+	}
+}
+
+
+/*
+==================
+S_StopAllSounds
+==================
+*/
+void S_StopSounds(void)
+{
+	int i; //, j;
+	channel_t *ch;
+
+	if ( !s_soundStarted ) {
+		return;
+	}
+
+	// stop looping sounds
+	S_ClearLoopingSounds();
+
+	// clear all the s_channels
+	ch = s_channels;
+	for (i = 0; i < s_numChannels; i++, ch++)
+	{
+		if (ch->bPlaying)
+		{
+			alSourceStop(ch->alSource);
+			ch->bPlaying = false;
+		}
+	
+		// free lip sync data
+		if(ch->thesfx)
+			ch->thesfx->pLipSyncData = NULL;
+
+		alSourcei(ch->alSource, AL_BUFFER, 0);
+		ch->thesfx = NULL;
+		ch->bLooping = false;
+	}
+
+	// clear out the lip synching override array
+	memset(s_entityWavVol, 0, sizeof(int) * MAX_GENTITIES);
+
+	S_ClearSoundBuffer ();
+}
+
+/*
+==================
+S_StopAllSounds
+ and music
+==================
+*/
+void S_StopAllSounds(void) {
+	if ( !s_soundStarted ) {
+		return;
+	}
+	// stop the background music
+	S_StopBackgroundTrack();
+
+	S_StopSounds();
+}
+
+/*
+==============================================================
+
+continuous looping sounds are added each frame
+
+==============================================================
+*/
+
+/*
+==================
+S_ClearLoopingSounds
+
+==================
+*/
+void S_ClearLoopingSounds( void )
+{
+	if ( !s_soundStarted ) {
+		return;
+	}
+
+	int i;
+
+	for (i = 0; i < MAX_LOOP_SOUNDS; i++)
+	{
+		loopSounds[i].bProcessed = false;
+		loopSounds[i].bMarked = false;
+		loopSounds[i].sfx = NULL;
+	}
+
+	numLoopSounds = 0;
+}
+
+/*
+==================
+S_AddLoopingSound
+
+Called during entity generation for a frame
+==================
+*/
+void S_AddLoopingSound( int entityNum, const vec3_t origin, const vec3_t velocity, sfxHandle_t sfxHandle, int chan ) {
+	/*const*/ sfx_t *sfx;
+
+  	if ( !s_soundStarted || s_soundMuted || !s_loopEnabled ) {
+		return;
+	}
+	if ( numLoopSounds >= MAX_LOOP_SOUNDS ) {
+		return;
+	}
+
+	if ( sfxHandle < 0 || sfxHandle > MAX_SFX || s_sfxCodes[sfxHandle] == INVALID_CODE ) {
+		return;
+	}
+
+	sfx = &s_sfxBlock[sfxHandle];
+	if (sfx->iFlags & SFX_FLAG_UNLOADED){
+		S_StartLoadSound(sfx);
+	}
+	SND_TouchSFX(sfx);
+
+	loopSounds[numLoopSounds].origin[0] = origin[0];
+	loopSounds[numLoopSounds].origin[1] = origin[1];
+	loopSounds[numLoopSounds].origin[2] = origin[2];
+
+	loopSounds[numLoopSounds].sfx = sfx;
+	loopSounds[numLoopSounds].volume = SOUND_MAXVOL;
+	loopSounds[numLoopSounds].entnum = entityNum;
+	loopSounds[numLoopSounds].entchannel = chan;
+	numLoopSounds++;
+}
+
+
+/*
+==================
+S_AddAmbientLoopingSound
+==================
+*/
+void S_AddAmbientLoopingSound( const vec3_t origin, unsigned char volume, sfxHandle_t sfxHandle ) 
+{
+	/*const*/ sfx_t *sfx;
+
+	if ( !s_soundStarted || s_soundMuted || !s_loopEnabled ) {
+		return;
+	}
+	if ( numLoopSounds >= MAX_LOOP_SOUNDS ) {
+		return;
+	}
+
+	if (volume == 0)
+		return;
+
+	if ( sfxHandle < 0 || sfxHandle > MAX_SFX || s_sfxCodes[sfxHandle] == INVALID_CODE ) {
+		return;
+	}
+
+	sfx = &s_sfxBlock[sfxHandle];
+	if (sfx->iFlags & SFX_FLAG_UNLOADED){
+		S_StartLoadSound(sfx);
+	}
+	SND_TouchSFX(sfx);
+
+	loopSounds[numLoopSounds].origin[0] = origin[0];
+	loopSounds[numLoopSounds].origin[1] = origin[1];
+	loopSounds[numLoopSounds].origin[2] = origin[2];
+	
+	loopSounds[numLoopSounds].sfx = sfx;	
+	loopSounds[numLoopSounds].volume = volume;
+	loopSounds[numLoopSounds].entnum = -1;
+	numLoopSounds++;
+}
+
+
+
+
+/*
+=====================
+S_UpdateEntityPosition
+
+let the sound system know where an entity currently is
+======================
+*/
+void S_UpdateEntityPosition( int entityNum, const vec3_t origin )
+{
+	if ( !s_soundStarted ) {
+		return;
+	}
+
+	channel_t *ch;
+	int i;
+
+	if ( entityNum < 0 || entityNum > MAX_GENTITIES ) {
+		Com_Error( ERR_DROP, "S_UpdateEntityPosition: bad entitynum %i", entityNum );
+	}
+
+	if (entityNum == 0)
+		return;
+	
+	ch = s_channels;
+	for (i = 0; i < s_numChannels; i++, ch++)
+	{
+		if ((ch->bPlaying) && 
+			(ch->entnum == entityNum) &&
+			(!ch->b2D))
+		{
+			if (ch->origin[0] != origin[0] ||
+				ch->origin[1] != origin[1] ||
+				ch->origin[2] != origin[2])
+			{
+				ch->origin[0] = origin[0];
+				ch->origin[1] = origin[1];
+				ch->origin[2] = origin[2];
+				ch->bOriginDirty = true;
+			}
+		}
+	}
+}
+
+
+/*
+============
+S_Respatialize
+
+Change the volumes of all the playing sounds for changes in their positions
+============
+*/
+void S_Respatialize( int entityNum, const vec3_t head, vec3_t axis[3], qboolean inwater )
+{
+	if ( !s_soundStarted || s_soundMuted ) {
+		return; 
+	}
+
+	int index = 0;
+
+#if 0	
+	extern qboolean g_isMultiplayer;
+	if ( g_isMultiplayer ) {
+		index = entityNum;
+	}
+#endif
+
+	if ( index >= s_numListeners ) {
+		return;
+	}
+
+	listener_t *li = &s_listeners[index];
+
+	li->entnum = entityNum;
+	
+	li->pos[0] = head[0];
+	li->pos[1] = head[1];
+	li->pos[2] = head[2];
+	alListenerfv(li->handle, AL_POSITION, li->pos);
+	
+	li->orient[0] = axis[0][0];
+	li->orient[1] = axis[0][1];
+	li->orient[2] = axis[0][2];
+	li->orient[3] = axis[2][0];
+	li->orient[4] = axis[2][1];
+	li->orient[5] = axis[2][2];
+	
+	alListenerfv(li->handle, AL_ORIENTATION, li->orient);
+}
+
+/*
+============
+S_Update
+
+Called once each time through the main loop
+============
+*/
+void S_Update( void ) {
+	if ( !s_soundStarted ) {
+		return;
+	}
+
+	// don't update too often
+	int now = Sys_Milliseconds();
+	if (now - s_updateTime < SOUND_UPDATE_TIME) {
+		return;
+	}
+	s_updateTime = now;
+	
+	if ( s_soundMuted ) {
+		alUpdate();
+		return;
+	}
+
+	// finish up any pending loads
+	S_UpdateLoading();
+
+	// update the music stream
+	S_UpdateBackgroundTrack();
+
+	// mix some sound
+	S_Update_();
+
+	alUpdate();
+}
+
+static void UpdatePosition(channel_t *ch)
+{
+	if ( !ch->b2D )
+	{
+		if ( ch->bLooping && ch->bPlaying )
+		{
+			loopSound_t	*loop = &loopSounds[ch->loopChannel];
+			if ( loop->origin[0] != ch->origin[0] ||
+				loop->origin[1] != ch->origin[1] ||
+				loop->origin[2] != ch->origin[2] )
+			{
+				ch->origin[0] = loop->origin[0];
+				ch->origin[1] = loop->origin[1];
+				ch->origin[2] = loop->origin[2];
+				ch->bOriginDirty = true;
+			}
+		}
+		
+		if ( ch->bOriginDirty )
+		{
+			alSourcefv(ch->alSource, AL_POSITION, ch->origin);
+			ch->bOriginDirty = false;
+		}
+	}
+}
+
+static void UpdateGain(channel_t *ch)
+{
+	float v = 0.f;
+
+	if ( ch->bLooping && ch->bPlaying )
+	{
+		loopSound_t	*loop = &loopSounds[ch->loopChannel];
+		if ( loop->volume != ch->master_vol )
+		{
+			ch->master_vol = loop->volume;
+		}
+	}
+	
+	if ( ch->entchannel == CHAN_ANNOUNCER ||
+		ch->entchannel == CHAN_VOICE || 
+		ch->entchannel == CHAN_VOICE_ATTEN || 
+		ch->entchannel == CHAN_VOICE_GLOBAL )
+	{
+		v = ((float)(ch->master_vol) * s_voice_volume->value) / 255.0f;
+	}
+	else if ( ch->entchannel == CHAN_MUSIC )
+	{
+		v = ((float)(ch->master_vol) * s_music_volume->value) / 255.f;
+	}
+	else
+	{
+		v = ((float)(ch->master_vol) * s_effects_volume->value) / 255.f;
+	}
+	
+	if ( ch->fLastVolume != v)
+	{
+		alSourcef(ch->alSource, AL_GAIN, v);
+		ch->fLastVolume = v;
+	}
+}
+
+static void UpdatePlayState(channel_t *ch)
+{
+	if (!ch->bPlaying) return;
+
+	if (ch->bLooping)
+	{
+		// Looping sound
+		loopSound_t	*loop = &loopSounds[ch->loopChannel];
+		
+		if (loop->bProcessed == false && loop->sfx != NULL &&
+			(loop->sfx == ch->thesfx ||
+			(loop->sfx->iFlags & SFX_FLAG_DEFAULT)))
+		{
+			// Playing
+			loop->bProcessed = true;
+		}
+		else
+		{
+			// Sound no longer needed
+			alSourceStop(ch->alSource);
+			alSourcei(ch->alSource, AL_BUFFER, 0);
+			ch->thesfx = NULL;
+			ch->bPlaying = false;
+		}
+	}
+	else
+	{
+		// Single shot sound
+		ALint state;
+		alGetSourcei(ch->alSource, AL_SOURCE_STATE, &state);
+		if (state == AL_STOPPED)
+		{
+			alSourcei(ch->alSource, AL_BUFFER, 0);
+			ch->thesfx = NULL;
+			ch->bPlaying = false;
+		}
+	}
+}
+
+static void UpdateAttenuation(channel_t *ch)
+{
+	if (!ch->b2D)
+	{
+		/*
+		if ( ch->entchannel == CHAN_VOICE || ch->entchannel == CHAN_VOICE_ATTEN || ch->entchannel == CHAN_VOICE_GLOBAL )
+		{
+			alSourcef(ch->alSource, AL_REFERENCE_DISTANCE, 1500.0f);
+		}
+		else
+		{
+			alSourcef(ch->alSource, AL_REFERENCE_DISTANCE, 400.0f);
+		}
+		*/
+#if 0
+		extern qboolean g_isMultiplayer;
+		if (!g_isMultiplayer)
+		{
+#endif
+			switch (ch->entchannel)
+			{
+			case CHAN_VOICE:
+				alSourcef(ch->alSource, AL_REFERENCE_DISTANCE, SOUND_REF_DIST_BASE * 3.f);
+				break;
+			case CHAN_LESS_ATTEN:
+				alSourcef(ch->alSource, AL_REFERENCE_DISTANCE, SOUND_REF_DIST_BASE * 8.f);
+				break;
+			case CHAN_VOICE_ATTEN:
+				alSourcef(ch->alSource, AL_REFERENCE_DISTANCE, SOUND_REF_DIST_BASE * 1.35f);
+				break;
+			case CHAN_VOICE_GLOBAL:
+				alSourcef(ch->alSource, AL_REFERENCE_DISTANCE, SOUND_REF_DIST_BASE * 100.f);
+				break;
+			default:
+				alSourcef(ch->alSource, AL_REFERENCE_DISTANCE, SOUND_REF_DIST_BASE);
+				break;
+			}
+#if 0
+		}
+		else
+		{
+			alSourcef(ch->alSource, AL_REFERENCE_DISTANCE, SOUND_REF_DIST_BASE * 2.f);
+		}
+#endif
+	}
+}
+
+static void PlaySingleShot(channel_t *ch)
+{
+	alSourcei(ch->alSource, AL_LOOPING, AL_FALSE);
+	
+	UpdateAttenuation(ch);
+	UpdatePosition(ch);
+	
+	// Attach buffer to source
+	alSourcei(ch->alSource, AL_BUFFER, ch->thesfx->Buffer);
+	
+	// Clear error state, and check for successful Play call
+	alGetError();
+	alSourcePlay(ch->alSource);
+	if (alGetError() == AL_NO_ERROR)
+	{
+		ch->bPlaying = true;
+		ch->iLastPlayTime = Sys_Milliseconds();
+	}
+}
+
+void UpdateLoopingSounds()
+{
+	// Look for non-processed loops that are ready to play
+	for (int j = 0; j < numLoopSounds; j++)
+	{
+		loopSound_t	*loop = &loopSounds[j];
+		
+		{
+			// merge all loops with the same sfx into a single loop
+			float num = 1;
+			for (int k = j+1; k < numLoopSounds; ++k)
+			{
+				if (loopSounds[k].sfx == loop->sfx)
+				{
+					loop->origin[0] += loopSounds[k].origin[0];
+					loop->origin[1] += loopSounds[k].origin[1];
+					loop->origin[2] += loopSounds[k].origin[2];
+					loop->volume += loopSounds[k].volume;
+					loopSounds[k].bProcessed = true;
+					num += 1;
+				}
+			}
+
+			loop->origin[0] /= num;
+			loop->origin[1] /= num;
+			loop->origin[2] /= num;
+			loop->volume /= (int)num;
+		}
+
+		if (loop->bProcessed == false && (loop->sfx->iFlags & SFX_FLAG_RESIDENT))
+		{
+			// play the loop
+			bool is2D = false;
+			for (int i = 0; i < s_numListeners; ++i)
+			{
+				if (loop->entnum == s_listeners[i].entnum ||
+					(loop->origin[0] == s_listeners[i].pos[0] &&
+					loop->origin[1] == s_listeners[i].pos[1] &&
+					loop->origin[2] == s_listeners[i].pos[2]))
+				{
+					is2D = true;
+					break;
+				}
+			}
+
+			channel_t *ch = S_PickChannel(0, 0, is2D, NULL);
+			if (!ch) continue;
+
+			ch->master_vol = loop->volume;
+			ch->fLastVolume = -1;
+			ch->entnum = loop->entnum;
+			ch->entchannel = loop->entchannel;
+			ch->thesfx = loop->sfx;
+			ch->loopChannel = j;
+			ch->bLooping = true;
+			
+			ch->origin[0] = loop->origin[0];
+			ch->origin[1] = loop->origin[1];
+			ch->origin[2] = loop->origin[2];
+			ch->bOriginDirty = true;
+
+			alSourcei(ch->alSource, AL_LOOPING, AL_TRUE);
+			alSourcei(ch->alSource, AL_BUFFER, ch->thesfx->Buffer);
+			UpdateAttenuation(ch);
+			UpdatePosition(ch);
+			UpdateGain(ch);
+			
+			alGetError();
+			alSourcePlay(ch->alSource);
+			if (alGetError() == AL_NO_ERROR)
+			{
+				ch->bPlaying = true;
+				ch->iLastPlayTime = Sys_Milliseconds();
+			}
+		}
+	}
+}
+
+static void SyncChannelLoops(void)
+{
+	channel_t		*ch;
+	int				i, j;
+
+	// Try to match up channels with looping sounds
+	// (The order of sounds in loopSounds can change
+	// frame to frame.)
+	ch = s_channels;
+	for ( i = 0; i < s_numChannels ; i++, ch++ )
+	{
+		if ( ch->bPlaying && ch->bLooping )
+		{
+			for ( j = 0; j < numLoopSounds; ++j )
+			{
+				if ( ch->thesfx == loopSounds[j].sfx && 
+					!loopSounds[j].bMarked )
+				{
+					ch->loopChannel = j;
+					loopSounds[j].bMarked = true;
+					break;
+				}
+			}
+		}
+	}
+}
+
+void _UpdateLipSyncData( channel_t*	ch)
+{
+	int		samples;
+	int		currentTime;
+	int		timePlayed;
+	int		length;
+	char*	data;
+
+	if (ch->thesfx->pLipSyncData == NULL)
+	{
+		//Com_Printf("Missing lip-sync info: %s\n", ch->thesfx->sSoundName);
+		return;
+	}
+
+	// Get current time
+	currentTime = Sys_Milliseconds();
+
+	// Calculate how much time has passed since the sample was started
+	timePlayed = currentTime - ch->iLastPlayTime;
+
+	// There is a new computed lip-sync value every 1000 samples - so find out how many samples
+	// have been played and lookup the value in the lip-sync table
+	samples = (timePlayed * 22050) / 1000;
+
+	// Get the number of total samples in this sound
+	length	= *(int*)ch->thesfx->pLipSyncData;
+
+	// Get a ptr to the lipsync data
+	data	= (char*)((int*)ch->thesfx->pLipSyncData + 1);
+
+	if ((ch->thesfx->pLipSyncData) && (samples < length))
+	{
+		int p = samples / 500 ;
+		short t;
+
+		if(p%2 == 0 )
+		{
+			t = data[p/2];
+			t = t >> 4;
+			if(t == 0)
+				t = -1;
+
+			s_entityWavVol[ ch->entnum ] = t;		// want left 4 bits
+		}
+		else
+		{
+			t = data[p/2] & 0x0f;
+			if(t == 0)
+				t = -1;
+			s_entityWavVol[ ch->entnum ] = t;	// want right 4 bits
+		}
+		//Com_Printf("%s,  total samples = %d, current sample = %d, lip index = %d, lip type = %d \n", ch->thesfx->sSoundName, length, samples, p/2, s_entityWavVol[ ch->entnum ] );
+	}
+
+}
+
+void S_Update_(void)
+{
+	channel_t		*ch;
+	int				i;
+
+	if ( !s_soundStarted || s_soundMuted ) {
+		return;
+	}
+	
+	memset(s_entityWavVol, 0, sizeof(int) * MAX_GENTITIES);
+
+	SyncChannelLoops();
+
+	ch = s_channels;
+	for ( i = 0; i < s_numChannels ; i++, ch++ )
+	{	
+		if ( !ch->thesfx ) continue;
+
+		if ( ch->thesfx->iFlags & SFX_FLAG_UNLOADED )
+		{
+			// if the sound is not going to be loaded, force the 
+			// playing flag high, stop the source, and hope that 
+			// the update code cleans it up...
+			ch->bPlaying = true;
+			alSourceStop(ch->alSource);
+			continue;
+		}
+		
+		if ( ch->entchannel == CHAN_VOICE || 
+			ch->entchannel == CHAN_VOICE_ATTEN || 
+			ch->entchannel == CHAN_VOICE_GLOBAL )
+		{
+			//s_entityWavVol[ch->entnum] = ch->bPlaying ? 4 : -1;
+			if(ch->bPlaying)
+			{
+				_UpdateLipSyncData(ch);
+			}
+			else
+			{
+				s_entityWavVol[ch->entnum] = -1;
+			}
+
+		}
+
+		if ( !(ch->thesfx->iFlags & SFX_FLAG_RESIDENT) ) continue;
+
+		UpdatePosition(ch);
+		UpdateGain(ch);
+
+		if ( ch->bPlaying )
+		{
+			UpdatePlayState(ch);
+		}
+		else
+		{
+			PlaySingleShot(ch);
+		}
+	}
+
+	UpdateLoopingSounds();
+}
+
+
+
+/*
+===============================================================================
+
+console functions
+
+===============================================================================
+*/
+
+static void S_Play_f( void ) {
+	int 	i;
+	sfxHandle_t	h;
+	char name[256];
+	
+	i = 1;
+	while ( i<Cmd_Argc() ) {
+		if ( !strrchr(Cmd_Argv(i), '.') ) {
+			Com_sprintf( name, sizeof(name), "%s.wav", Cmd_Argv(1) );
+		} else {
+			Q_strncpyz( name, Cmd_Argv(i), sizeof(name) );
+		}
+		h = S_RegisterSound( name );
+		if( h ) {
+			S_StartLocalSound( h, CHAN_LOCAL_SOUND );
+		}
+		i++;
+	}
+}
+
+/*
+ * Crazy expanded play function:
+ * playex <file name> xOffset yOffset zOffset channel
+ */
+#ifndef _JK2MP
+static void S_PlayEx_f( void ) {
+	sfxHandle_t	h;
+	char		name[256] = { 0 };
+	vec3_t		origin;
+	int			entchannel;
+
+	if (Cmd_Argc() < 6)
+		return;
+
+	Q_strncpyz( name, Cmd_Argv(1), sizeof(name) );
+	h = S_RegisterSound( name );
+	if (!h)
+		return;
+
+	extern void G_EntityPosition( int i, vec3_t ret );
+	G_EntityPosition(0, origin);
+
+	origin[0] += atof(Cmd_Argv(2));
+	origin[1] += atof(Cmd_Argv(3));
+	origin[2] += atof(Cmd_Argv(4));
+
+	entchannel = atoi(Cmd_Argv(5));
+
+	S_StartSound(origin, 0, entchannel, h);
+}
+#endif
+
+static void S_Music_f( void ) {
+	int		c;
+
+	c = Cmd_Argc();
+
+	if ( c == 2 ) {
+		S_StartBackgroundTrack( Cmd_Argv(1), Cmd_Argv(1), qfalse );
+	} else if ( c == 3 ) {
+		S_StartBackgroundTrack( Cmd_Argv(1), Cmd_Argv(2), qfalse );		
+	} else {
+		Com_Printf ("music <musicfile> [loopfile]\n");
+		return;
+	}
+}
+
+void S_SoundList_f( void ) {
+}
+
+
+/*
+===============================================================================
+
+background music functions
+
+===============================================================================
+*/
+
+// fixme: need to move this into qcommon sometime?, but too much stuff altered by other people and I won't be able
+//	to compile again for ages if I check that out...
+//
+// DO NOT replace this with a call to FS_FileExists, that's for checking about writing out, and doesn't work for this.
+//
+qboolean S_MusicFileExists( const char *psFilename )
+{
+	fileHandle_t fhTemp;
+
+	char* pLoadName = S_FixMusicFileName(psFilename);
+	
+	FS_FOpenFileRead (pLoadName, &fhTemp, qtrue);	// qtrue so I can fclose the handle without closing a PAK
+	if (!fhTemp) 
+		return qfalse;
+	
+	FS_FCloseFile(fhTemp);
+	return qtrue;
+}
+
+static void S_StopBackgroundTrack_Actual( MusicInfo_t *pMusicInfo ) 
+{
+	pMusicInfo->bLoaded = false;
+	pMusicInfo->Rewind();
+	alStreamStop();
+}
+
+static void FreeMusic( MusicInfo_t *pMusicInfo )
+{
+	pMusicInfo->sLoadedDataName[0] = '\0';
+}
+
+// called only by snd_shutdown (from snd_restart or app exit)
+//
+static void S_UnCacheDynamicMusic( void )
+{
+	for (int i = eBGRNDTRACK_DATABEGIN; i != eBGRNDTRACK_DATAEND; i++)
+	{
+		FreeMusic( &tMusic_Info[i]);
+	}
+}
+
+static qboolean S_StartBackgroundTrack_Actual( MusicInfo_t *pMusicInfo, qboolean qbDynamic, const char *intro, const char *loop )
+{
+	Q_strncpyz( sMusic_BackgroundLoop, loop, sizeof( sMusic_BackgroundLoop ));	
+
+	char* name = S_FixMusicFileName(intro);
+
+	if ( !intro[0] ) {
+		S_StopBackgroundTrack_Actual( pMusicInfo );
+		return qfalse;
+	}
+
+	// new bit, if file requested is not same any loaded one (if prev was in-mem), ditch it...
+	//
+	if (Q_stricmp(name, pMusicInfo->sLoadedDataName))
+	{
+		FreeMusic( pMusicInfo );
+	}
+
+	//
+	// open up a wav file and get all the info
+	//
+	fileHandle_t handle;
+	int len = FS_FOpenFileRead( name, &handle, qtrue );
+	if ( !handle ) {
+		Com_Printf( S_COLOR_YELLOW "WARNING: couldn't open music file %s\n", name );
+		S_StopBackgroundTrack_Actual( pMusicInfo );
+		return qfalse;
+	}
+	
+#if defined(_XBOX) || defined(_WINDOWS)
+	// read enough of the file to get the header...
+	byte buffer[128];
+	FS_Read(buffer, sizeof(buffer), handle);
+	FS_FCloseFile( handle );
+
+	wavinfo_t info = GetWavInfo(buffer);
+	if ( info.size == 0 ) {
+		Com_Printf(S_COLOR_YELLOW "WARNING: Invalid format in %s\n", name);
+		S_StopBackgroundTrack_Actual( pMusicInfo );
+		return qfalse;
+	}
+	
+	pMusicInfo->s_backgroundSize = info.size;
+	pMusicInfo->s_backgroundBPS = info.rate * info.width / 8;
+	if (info.format == AL_FORMAT_STEREO4)
+	{
+		pMusicInfo->s_backgroundBPS <<= 1;
+	}
+#elif defined(_GAMECUBE)
+	FS_FCloseFile( handle );
+	pMusicInfo->s_backgroundSize = len;
+	pMusicInfo->s_backgroundBPS = 48000 * 4 / 8 * 2;
+#endif
+	
+	Q_strncpyz(pMusicInfo->sLoadedDataName, intro, sizeof(pMusicInfo->sLoadedDataName));
+	pMusicInfo->iFileCode = Sys_GetFileCode(name);
+	pMusicInfo->bLoaded = true;
+	
+	return qtrue;
+}
+
+static void S_SwitchDynamicTracks( MusicState_e eOldState, MusicState_e eNewState, qboolean bNewTrackStartsFullVolume )
+{
+	// copy old track into fader...
+	//
+	tMusic_Info[ eBGRNDTRACK_FADE ] = tMusic_Info[ eOldState ];
+	tMusic_Info[ eBGRNDTRACK_FADE ].iXFadeVolumeSeekTime= Sys_Milliseconds();
+	tMusic_Info[ eBGRNDTRACK_FADE ].iXFadeVolumeSeekTo	= 0;
+	//
+	// ... and deactivate...
+	//
+	tMusic_Info[ eOldState ].bActive = qfalse;
+	//
+	// set new track to either full volume or fade up...
+	//
+	tMusic_Info[eNewState].bActive				= qtrue;
+	tMusic_Info[eNewState].iXFadeVolumeSeekTime	= Sys_Milliseconds();
+	tMusic_Info[eNewState].iXFadeVolumeSeekTo	= 255;
+	tMusic_Info[eNewState].iXFadeVolume			= bNewTrackStartsFullVolume ? 255 : 0;
+	
+	eMusic_StateActual = eNewState;
+
+	// sanity check
+	if (tMusic_Info[eNewState].iFileSeekTo >= tMusic_Info[eNewState].s_backgroundSize)
+	{
+		tMusic_Info[eNewState].iFileSeekTo = 0;
+	}
+}
+
+// called by both the config-string parser and the console-command state-changer...
+//
+// This either changes the music right now (copying track structures etc), or leaves the new state as pending
+//	so it gets picked up by the general music player if in a transition that can't be overridden...
+//
+static void S_SetDynamicMusicState( MusicState_e eNewState )
+{
+	if (eMusic_StateRequest != eNewState)
+	{
+		eMusic_StateRequest  = eNewState;
+
+		if (s_debugdynamic->integer)
+		{
+			LPCSTR	psNewStateString = Music_BaseStateToString( eNewState, qtrue );
+					psNewStateString = psNewStateString?psNewStateString:"<unknown>";
+
+			Com_Printf( S_COLOR_MAGENTA "S_SetDynamicMusicState( Request: \"%s\" )\n", psNewStateString );
+		}		
+	}
+}
+
+
+static void S_HandleDynamicMusicStateChange( void )
+{
+	if (eMusic_StateRequest != eMusic_StateActual)
+	{
+		// check whether or not the new request can be honoured, given what's currently playing...
+		//
+		if (Music_StateCanBeInterrupted( eMusic_StateActual, eMusic_StateRequest ))
+		{
+			switch (eMusic_StateRequest)
+			{
+				case eBGRNDTRACK_EXPLORE:	// ... from action or silence
+				{
+					switch (eMusic_StateActual)
+					{
+						case eBGRNDTRACK_ACTION:	// action->explore
+						{
+							// find the transition track to play, and the entry point for explore when we get there,
+							//	and also see if we're at a permitted exit point to switch at all...
+							//
+							float fPlayingTimeElapsed = tMusic_Info[ eMusic_StateActual ].ElapsedTime();
+
+							// supply:
+							//
+							// playing point in float seconds
+							// enum of track being queried
+							//
+							// get:
+							//
+							// enum of transition track to switch to
+							// float time of entry point of new track *after* transition
+
+							MusicState_e	eTransition;
+							float			fNewTrackEntryTime = 0.0f;
+							if (Music_AllowedToTransition( fPlayingTimeElapsed, eBGRNDTRACK_ACTION, &eTransition, &fNewTrackEntryTime))
+							{
+								tMusic_Info[eTransition].Rewind();
+								tMusic_Info[eTransition].bTrackSwitchPending	= qtrue;
+								tMusic_Info[eTransition].bLooping				= qfalse;
+								tMusic_Info[eTransition].eTS_NewState			= eMusic_StateRequest;
+								tMusic_Info[eTransition].fTS_NewTime			= fNewTrackEntryTime;
+
+								S_SwitchDynamicTracks( eMusic_StateActual, eTransition, qfalse );	// qboolean bNewTrackStartsFullVolume
+							}
+						}
+						break;						
+
+						case eBGRNDTRACK_SILENCE:	// silence->explore
+						{
+							tMusic_Info[ eMusic_StateRequest ].Rewind();
+							S_SwitchDynamicTracks( eMusic_StateActual, eMusic_StateRequest, qfalse );	// qboolean bNewTrackStartsFullVolume
+						}
+						break;
+
+						default:	// trying to transition from some state I wasn't aware you could transition from (shouldn't happen), so ignore
+						{
+							assert(0); 
+							S_SwitchDynamicTracks( eMusic_StateActual, eBGRNDTRACK_SILENCE, qfalse );	// qboolean bNewTrackStartsFullVolume
+						}
+						break;
+					}
+				}
+				break;
+
+				case eBGRNDTRACK_SILENCE:	// from explore or action
+				{
+					switch (eMusic_StateActual)
+					{
+						case eBGRNDTRACK_ACTION:	// action->silence
+						case eBGRNDTRACK_EXPLORE:	// explore->silence
+						{
+							// find the transition track to play, and the entry point for explore when we get there,
+							//	and also see if we're at a permitted exit point to switch at all...
+							//
+							float fPlayingTimeElapsed = tMusic_Info[ eMusic_StateActual ].ElapsedTime();
+
+							MusicState_e	eTransition;
+							float			fNewTrackEntryTime = 0.0f;
+							if (Music_AllowedToTransition( fPlayingTimeElapsed, eMusic_StateActual, &eTransition, &fNewTrackEntryTime))
+							{
+								tMusic_Info[eTransition].Rewind();
+								tMusic_Info[eTransition].bTrackSwitchPending	= qtrue;
+								tMusic_Info[eTransition].bLooping				= qfalse;
+								tMusic_Info[eTransition].eTS_NewState			= eMusic_StateRequest;
+								tMusic_Info[eTransition].fTS_NewTime			= 0.0f;	//fNewTrackEntryTime;  irrelevant when switching to silence
+
+								S_SwitchDynamicTracks( eMusic_StateActual, eTransition, qfalse );	// qboolean bNewTrackStartsFullVolume
+							}
+						}
+						break;
+
+						default:		// some unhandled type switching to silence
+							assert(0);	// fall through since boss case just does silence->switch anyway
+
+						case eBGRNDTRACK_BOSS:	// boss->silence
+						{
+							tMusic_Info[eBGRNDTRACK_SILENCE].Rewind();
+							S_SwitchDynamicTracks( eMusic_StateActual, eBGRNDTRACK_SILENCE, qfalse );	// qboolean bNewTrackStartsFullVolume
+						}
+						break;
+					}
+				}
+				break;
+
+				case eBGRNDTRACK_ACTION:	// anything->action
+				{
+					switch (eMusic_StateActual)
+					{
+						case eBGRNDTRACK_SILENCE:	// silence->action
+						{
+							tMusic_Info[ eMusic_StateRequest ].Rewind();
+							S_SwitchDynamicTracks( eMusic_StateActual, eMusic_StateRequest, qfalse );	// qboolean bNewTrackStartsFullVolume
+						}
+						break;
+
+						default:	// !silence->action
+						{
+							float fEntryTime = Music_GetRandomEntryTime( eMusic_StateRequest );
+							tMusic_Info[ eMusic_StateRequest ].SeekTo(fEntryTime);
+							S_SwitchDynamicTracks( eMusic_StateActual, eMusic_StateRequest, qfalse );	// qboolean bNewTrackStartsFullVolume
+						}
+						break;
+					}
+				}
+				break;
+
+				case eBGRNDTRACK_BOSS:
+				{	
+					tMusic_Info[eMusic_StateRequest].Rewind();
+					S_SwitchDynamicTracks( eMusic_StateActual, eMusic_StateRequest, qfalse );	// qboolean bNewTrackStartsFullVolume
+				}
+				break;
+
+				case eBGRNDTRACK_DEATH:
+				{	
+					tMusic_Info[eMusic_StateRequest].Rewind();
+					S_SwitchDynamicTracks( eMusic_StateActual, eMusic_StateRequest, qtrue );	// qboolean bNewTrackStartsFullVolume
+				}
+				break;
+
+				default: assert(0); break;	// unknown new mode request, so just ignore it
+			}
+		}
+	}
+}
+
+
+
+static char gsIntroMusic[MAX_QPATH]={0};
+static char gsLoopMusic [MAX_QPATH]={0};
+
+void S_RestartMusic( void ) 
+{
+	if (s_soundStarted && !s_soundMuted )
+	{
+		S_StartBackgroundTrack( gsIntroMusic, gsLoopMusic, qfalse );	// ( default music start will set the state to EXPLORE )
+		S_SetDynamicMusicState( eMusic_StateRequest );					// restore to prev state
+	}
+}
+
+
+// Basic logic here is to see if the intro file specified actually exists, and if so, then it's not dynamic music,
+//	When called by the cgame start it loads up, then stops the playback (because of stutter issues), so that when the
+//	actual snapshot is received and the real play request is processed the data has already been loaded so will be quicker.
+//
+void S_StartBackgroundTrack( const char *intro, const char *loop, qboolean bCalledByCGameStart )
+{
+	bMusic_IsDynamic = qfalse;
+
+	if (!s_soundStarted)
+	{	//we have no sound, so don't even bother trying
+		return;
+	}
+
+	if ( !intro ) {
+		intro = "";
+	}
+	if ( !loop || !loop[0] ) {
+		loop = intro;
+	}
+
+	Q_strncpyz(gsIntroMusic,intro, sizeof(gsIntroMusic));
+	Q_strncpyz(gsLoopMusic, loop,  sizeof(gsLoopMusic));
+
+	char sName[MAX_QPATH];
+	Q_strncpyz(sName,intro,sizeof(sName));
+
+	COM_DefaultExtension( sName, sizeof( sName ), ".wxb" );
+
+	// if dynamic music not allowed, then just stream the explore music instead of playing dynamic...
+	//
+	if (!s_allowDynamicMusic->integer && Music_DynamicDataAvailable(intro))	// "intro", NOT "sName" (i.e. don't use version with ".wxb" extension)
+	{
+		LPCSTR psMusicName = Music_GetFileNameForState( eBGRNDTRACK_DATABEGIN );
+		if (psMusicName && S_MusicFileExists( psMusicName ))
+		{
+			Q_strncpyz(sName,psMusicName,sizeof(sName));
+		}
+	}
+
+	// conceptually we always play the 'intro'[/sName] track, intro-to-loop transition is handled in UpdateBackGroundTrack().
+	//
+	if ( (strstr(sName,"/") && S_MusicFileExists( sName )) )	// strstr() check avoids extra file-exists check at runtime if reverting from streamed music to dynamic since literal files all need at least one slash in their name (eg "music/blah")
+	{
+		Com_DPrintf("S_StartBackgroundTrack: Found/using non-dynamic music track '%s'\n", sName);
+		tMusic_Info[eBGRNDTRACK_NONDYNAMIC].bLooping = qtrue;
+		S_StartBackgroundTrack_Actual( &tMusic_Info[eBGRNDTRACK_NONDYNAMIC], bMusic_IsDynamic, sName, sName );
+	}
+	else
+	{
+		if (Music_DynamicDataAvailable(intro))	// "intro", NOT "sName" (i.e. don't use version with ".wxb" extension)
+		{
+			int i;
+			extern const char *Music_GetLevelSetName(void);
+			Q_strncpyz(sInfoOnly_CurrentDynamicMusicSet, Music_GetLevelSetName(), sizeof(sInfoOnly_CurrentDynamicMusicSet));
+			for (i = eBGRNDTRACK_DATABEGIN; i != eBGRNDTRACK_DATAEND; i++)
+			{
+				qboolean bOk = qfalse;
+				LPCSTR psMusicName = Music_GetFileNameForState( (MusicState_e) i);
+				if (psMusicName && (!Q_stricmp(tMusic_Info[i].sLoadedDataName, psMusicName) || S_MusicFileExists( psMusicName )) )
+				{
+					bOk = S_StartBackgroundTrack_Actual( &tMusic_Info[i], qtrue, psMusicName, loop );
+				}
+				
+				tMusic_Info[i].bExists = bOk;
+
+				if (!tMusic_Info[i].bExists)
+				{
+					FreeMusic( &tMusic_Info[i] );
+				}
+			}
+
+			//
+			// default all tracks to OFF first (and set any other vars)
+			//
+			for (i=0; i<eBGRNDTRACK_NUMBEROF; i++)
+			{
+				tMusic_Info[i].bActive				= qfalse;
+				tMusic_Info[i].bTrackSwitchPending	= qfalse;
+				tMusic_Info[i].bLooping				= qtrue;
+				tMusic_Info[i].fSmoothedOutVolume	= 0.25f;
+			}
+
+			tMusic_Info[eBGRNDTRACK_DEATH].bLooping		= qfalse;
+
+			if (tMusic_Info[eBGRNDTRACK_EXPLORE].bExists &&
+				tMusic_Info[eBGRNDTRACK_ACTION ].bExists
+				)
+			{
+				Com_DPrintf("S_StartBackgroundTrack: Found dynamic music tracks\n");
+				bMusic_IsDynamic = qtrue;
+
+				//
+				// ... then start the default music state...
+				//
+				eMusic_StateActual = eMusic_StateRequest = eBGRNDTRACK_EXPLORE;
+
+				MusicInfo_t *pMusicInfo = &tMusic_Info[ eMusic_StateActual ];
+
+				pMusicInfo->bActive				= qtrue;
+				pMusicInfo->iXFadeVolumeSeekTime= Sys_Milliseconds();
+				pMusicInfo->iXFadeVolumeSeekTo	= 255;
+				pMusicInfo->iXFadeVolume		= 0;			
+			}
+			else
+			{
+				Com_Printf( S_COLOR_RED "Dynamic music did not have both 'action' and 'explore' versions, inhibiting...\n");
+				S_StopBackgroundTrack();
+			}
+		}
+		else
+		{
+			if (sName[0]!='.')	// blank name with ".wxb" or whatever attached - no error print out
+			{
+				Com_Printf( S_COLOR_RED "Unable to find music \"%s\" as explicit track or dynamic music entry!\n",sName);
+				S_StopBackgroundTrack();
+			}
+		}
+	}	
+
+	if (bCalledByCGameStart)
+	{
+		S_StopBackgroundTrack();
+	}
+}
+
+void S_StopBackgroundTrack( void )
+{
+	for (int i=0; i<eBGRNDTRACK_NUMBEROF; i++)
+	{
+		S_StopBackgroundTrack_Actual( &tMusic_Info[i] );
+	}
+}
+
+
+
+// qboolean return is true only if we're changing from a streamed intro to a dynamic loop...
+//
+static qboolean S_UpdateBackgroundTrack_Actual( MusicInfo_t *pMusicInfo, qboolean bFirstOrOnlyMusicTrack, float fDefaultVolume) 
+{
+	float fMasterVol = fDefaultVolume; // s_musicVolume->value;
+
+	if (bMusic_IsDynamic)
+	{
+		// step xfade volume...
+		//
+		if ( pMusicInfo->iXFadeVolume != pMusicInfo->iXFadeVolumeSeekTo )
+		{
+			int iFadeMillisecondsElapsed = Sys_Milliseconds() - pMusicInfo->iXFadeVolumeSeekTime;
+
+			if (iFadeMillisecondsElapsed > (fDYNAMIC_XFADE_SECONDS * 1000))
+			{
+				pMusicInfo->iXFadeVolume = pMusicInfo->iXFadeVolumeSeekTo;
+			}
+			else
+			{
+				pMusicInfo->iXFadeVolume = (int) (255.0f * ((float)iFadeMillisecondsElapsed/(fDYNAMIC_XFADE_SECONDS * 1000.0f)));
+				if (pMusicInfo->iXFadeVolumeSeekTo == 0)	// bleurgh
+					pMusicInfo->iXFadeVolume = 255 - pMusicInfo->iXFadeVolume;
+			}
+		}
+		fMasterVol *= (float)((float)pMusicInfo->iXFadeVolume / 255.0f);
+	}
+
+	if ( pMusicInfo->bLoaded == false ) {
+		return qfalse;
+	}
+
+	pMusicInfo->fSmoothedOutVolume = (pMusicInfo->fSmoothedOutVolume + fMasterVol)/2.0f;
+
+	alStreamf(AL_GAIN, pMusicInfo->fSmoothedOutVolume);
+
+	// don't bother playing anything if musicvolume is 0
+	if ( pMusicInfo->fSmoothedOutVolume <= 0 ) {
+		return qfalse;
+	}
+
+	// start playing if necessary
+	if ( pMusicInfo->bLooping )
+	{
+		ALint state;
+		alGetStreami(AL_SOURCE_STATE, &state);
+		if ( state != AL_PLAYING )
+		{
+			alStreamPlay(pMusicInfo->iFileSeekTo, 
+				pMusicInfo->iFileCode, 
+				pMusicInfo->bLooping);
+		}
+	}
+
+	if ( pMusicInfo->PlayTime() >= pMusicInfo->TotalTime() ) 
+	{
+		// loop the music, or play the next piece if we were on the intro...
+		//	(but not for dynamic, that can only be used for loop music)
+		//
+		if (bMusic_IsDynamic)	// needs special logic for this, different call
+		{
+			pMusicInfo->Rewind();
+		}
+		else
+		{
+			// for non-dynamic music we need to check if "sMusic_BackgroundLoop" is an actual filename,
+			//	or if it's a dynamic music specifier (which can't literally exist), in which case it should set
+			//	a return flag then exit...
+			//
+			char sTestName[MAX_QPATH*2];// *2 so COM_DefaultExtension doesn't do an ERR_DROP if there was no space
+			//	for an extension, since this is a "soft" test				
+			Q_strncpyz( sTestName, sMusic_BackgroundLoop, sizeof(sTestName));
+			COM_DefaultExtension(sTestName, sizeof(sTestName), ".mp3");
+			
+			if (S_MusicFileExists( sTestName ))
+			{
+				// Restart the music
+				alStreamStop();
+				alStreamPlay(pMusicInfo->iFileSeekTo, 
+					pMusicInfo->iFileCode, 
+					pMusicInfo->bLooping);
+			}
+			else
+			{
+				// proposed file doesn't exist, but this may be a dynamic track we're wanting to loop, 
+				//	so exit with a special flag...
+				//
+				return qtrue;
+			}
+		}
+	}
+
+	return qfalse;
+}
+
+
+// used to be just for dynamic, but now even non-dynamic music has to know whether it should be silent or not...
+//
+static LPCSTR S_Music_GetRequestedState(void)
+{
+// This doesn't do anything in MP - just return NULL
+#ifndef _JK2MP
+	int iStringOffset = cl.gameState.stringOffsets[CS_DYNAMIC_MUSIC_STATE];
+	if (iStringOffset)
+	{
+		LPCSTR psCommand = cl.gameState.stringData+iStringOffset; 
+
+		return psCommand;
+	}
+#endif
+
+	return NULL;
+}
+
+
+// scan the configstring to see if there's been a state-change requested...
+// (note that even if the state doesn't change it still gets here, so do a same-state check for applying)
+//
+// then go on to do transition handling etc...
+//
+static void S_CheckDynamicMusicState(void)
+{
+	LPCSTR psCommand = S_Music_GetRequestedState();
+
+	if (psCommand)
+	{
+		MusicState_e eNewState;
+
+		if ( !Q_stricmpn( psCommand, "silence", 7) )
+		{				
+			eNewState = eBGRNDTRACK_SILENCE;
+		}
+		else if ( !Q_stricmpn( psCommand, "action", 6) )
+		{
+			eNewState = eBGRNDTRACK_ACTION;
+		}
+		else if ( !Q_stricmpn( psCommand, "boss", 4) )
+		{
+			// special case, boss music is optional and may not be defined...
+			//
+			if (tMusic_Info[ eBGRNDTRACK_BOSS ].bExists)
+			{
+				eNewState = eBGRNDTRACK_BOSS;
+			}
+			else
+			{
+				// ( leave it playing current track )
+				//
+				eNewState = eMusic_StateActual;
+			}
+		}
+		else if ( !Q_stricmpn( psCommand, "death", 5) )
+		{
+			// special case, death music is optional and may not be defined...
+			//
+			if (tMusic_Info[ eBGRNDTRACK_DEATH ].bExists)
+			{
+				eNewState = eBGRNDTRACK_DEATH;
+			}
+			else
+			{
+				// ( leave it playing current track, typically either boss or action )
+				//
+				eNewState = eMusic_StateActual;
+			}
+		}
+		else
+		{
+			// seems a reasonable default...
+			//
+			eNewState = eBGRNDTRACK_EXPLORE;
+		}
+		
+		S_SetDynamicMusicState( eNewState );
+	}
+
+	S_HandleDynamicMusicStateChange();
+}
+
+static void S_UpdateBackgroundTrack( void )
+{
+	if (bMusic_IsDynamic)
+	{
+		S_CheckDynamicMusicState();
+		
+		if (eMusic_StateActual != eBGRNDTRACK_SILENCE)
+		{
+			MusicInfo_t *pMusicInfoCurrent = &tMusic_Info[ (eMusic_StateActual == eBGRNDTRACK_FADE)?eBGRNDTRACK_EXPLORE:eMusic_StateActual ];
+			MusicInfo_t *pMusicInfoFadeOut = &tMusic_Info[ eBGRNDTRACK_FADE ];
+
+			if ( pMusicInfoCurrent->bLoaded )
+			{
+				float fRemainingTimeInSeconds = 1000000;
+
+				if (pMusicInfoFadeOut->bActive)
+				{
+					S_UpdateBackgroundTrack_Actual( pMusicInfoFadeOut, qfalse, s_music_volume->value );	// inactive-checked internally
+
+					//
+					// only do this for the fader!...
+					//
+					if (pMusicInfoFadeOut->iXFadeVolume == 0)
+					{
+						pMusicInfoFadeOut->bActive = qfalse;
+
+						// play if we have a file
+						if (pMusicInfoCurrent->iFileCode)
+						{
+							alStreamPlay(pMusicInfoCurrent->iFileSeekTo, 
+								pMusicInfoCurrent->iFileCode,
+								pMusicInfoCurrent->bLooping);
+							
+							pMusicInfoCurrent->iXFadeVolumeSeekTime = Sys_Milliseconds();
+						}
+						else
+						{
+							alStreamStop();
+						}
+					}
+				}
+				else
+				{
+					S_UpdateBackgroundTrack_Actual( pMusicInfoCurrent, qtrue, s_music_volume->value );
+					fRemainingTimeInSeconds = pMusicInfoCurrent->TotalTime() - pMusicInfoCurrent->ElapsedTime();
+				}
+				
+				if ( fRemainingTimeInSeconds < fDYNAMIC_XFADE_SECONDS*2 )
+				{
+					// now either loop current track, switch if finishing a transition, or stop if finished a death...
+					//
+					if (pMusicInfoCurrent->bTrackSwitchPending)
+					{
+						pMusicInfoCurrent->bTrackSwitchPending = qfalse;	// ack
+						tMusic_Info[ pMusicInfoCurrent->eTS_NewState ].SeekTo(pMusicInfoCurrent->fTS_NewTime);
+						S_SwitchDynamicTracks( eMusic_StateActual, pMusicInfoCurrent->eTS_NewState, qfalse);	// qboolean bNewTrackStartsFullVolume
+					}
+					else
+					{
+						// normal looping, so set rewind current track, set volume to 0 and fade up to full (unless death track playing, then stays quiet)
+						//	(while fader copy of end-section fades down)
+						//
+						// copy current track to fader...
+						//
+						*pMusicInfoFadeOut = *pMusicInfoCurrent;	// struct copy
+						pMusicInfoFadeOut->iXFadeVolumeSeekTime	= Sys_Milliseconds();
+						pMusicInfoFadeOut->iXFadeVolumeSeekTo	= 0;
+						//
+						pMusicInfoCurrent->Rewind();
+						pMusicInfoCurrent->iXFadeVolumeSeekTime	= Sys_Milliseconds();
+						pMusicInfoCurrent->iXFadeVolumeSeekTo	= (eMusic_StateActual == eBGRNDTRACK_DEATH) ? 0: 255;
+						pMusicInfoCurrent->iXFadeVolume			= 0;
+					}
+				}
+			}
+		}
+		else
+		{
+			// special case, when foreground music is shut off but fader still running to fade off previous track...
+			//
+			MusicInfo_t *pMusicInfoFadeOut = &tMusic_Info[ eBGRNDTRACK_FADE ];
+			if (pMusicInfoFadeOut->bActive)
+			{
+				S_UpdateBackgroundTrack_Actual( pMusicInfoFadeOut, qtrue, s_music_volume->value );
+				if (pMusicInfoFadeOut->iXFadeVolume == 0)
+				{
+					pMusicInfoFadeOut->bActive = qfalse;
+					alStreamStop();
+				}
+			}	
+		}
+	}
+	else
+	{
+		// standard / non-dynamic one-track music...
+		//
+		LPCSTR psCommand = S_Music_GetRequestedState();	// special check just for "silence" case...
+		qboolean bShouldBeSilent = (psCommand && !Q_stricmp(psCommand,"silence"));
+		float fDesiredVolume = bShouldBeSilent ? 0.0f : s_music_volume->value;
+		//
+		// internal to this code is a volume-smoother...
+		//
+		qboolean bNewTrackDesired = S_UpdateBackgroundTrack_Actual(&tMusic_Info[eBGRNDTRACK_NONDYNAMIC], qtrue, fDesiredVolume);
+
+		if (bNewTrackDesired)
+		{
+			S_StartBackgroundTrack( sMusic_BackgroundLoop, sMusic_BackgroundLoop, qfalse );
+		}
+	}
+}
+
+// Called from MusicFree in snd_music to prevent pending state changes from
+// crashing after the level finishes loading, but before new music level data
+// has been read. Not sure if this fixes the bug, but it seems good.
+void S_AvertMusicDisaster(void)
+{
+	eMusic_StateRequest = eMusic_StateActual;
+}
+
+
+int SND_GetMemoryUsed(void)
+{
+	ALint used;
+	alGeti(AL_MEMORY_USED, &used);
+	return used;
+}
+
+void SND_update(sfx_t *sfx) 
+{
+	while ( SND_GetMemoryUsed() > (s_soundpoolmegs->integer * 1024 * 1024 * 3 / 4))
+	{
+		int iBytesFreed = SND_FreeOldestSound(sfx);
+		if (iBytesFreed == 0)
+			break;	// sanity
+	}
+}
+
+
+// free any allocated sfx mem...
+//
+// now returns # bytes freed to help with z_malloc()-fail recovery
+//
+static int SND_FreeSFXMem(sfx_t *sfx)
+{
+	int iOrgMem = SND_GetMemoryUsed();
+
+	alGetError();
+	if (sfx->Buffer)
+	{
+		alDeleteBuffers(1, &(sfx->Buffer));
+		sfx->Buffer = 0;
+	}
+
+	sfx->iFlags &= ~(SFX_FLAG_RESIDENT | SFX_FLAG_LOADING);
+	sfx->iFlags |= SFX_FLAG_UNLOADED;
+
+	return iOrgMem - SND_GetMemoryUsed();
+}
+
+void S_DisplayFreeMemory() 
+{
+}
+
+void SND_TouchSFX(sfx_t *sfx)
+{
+	sfx->iLastTimeUsed		= Com_Milliseconds()+1;
+}
+
+
+// currently this is only called during snd_shutdown or snd_restart
+//
+static void S_FreeAllSFXMem(void)
+{
+	for (int i = 0; i < MAX_SFX; ++i)
+	{
+		if (s_sfxCodes[i] != INVALID_CODE && i != s_defaultSound)
+		{
+			SND_FreeSFXMem(&s_sfxBlock[i]);
+		}
+	}
+}
+
+// returns number of bytes freed up...
+//
+// new param is so we can be usre of not freeing ourselves (without having to rely on possible uninitialised timers etc)
+//
+int SND_FreeOldestSound(sfx_t *pButNotThisOne /* = NULL */) 
+{	
+	int iBytesFreed = 0;
+	sfx_t *sfx;
+
+	int	iOldest = Com_Milliseconds();
+	int	iUsed	= 0;
+	bool bDemandLoad = false;
+
+	// start on 1 so we never dump the default sound...
+	//
+	for (int i = 0; i < MAX_SFX; ++i)
+	{
+		if (s_sfxCodes[i] == INVALID_CODE || i == s_defaultSound) continue;
+
+		sfx = &s_sfxBlock[i];
+
+		if (sfx != pButNotThisOne)
+		{
+			// Don't throw out the default sound, sounds that
+			// are not in memory, or sounds newer then the oldest.
+			// Also, throw out demand load sounds first.
+			//
+			if (!(sfx->iFlags & SFX_FLAG_DEFAULT) && 
+				(sfx->iFlags & SFX_FLAG_RESIDENT) && 
+				(!bDemandLoad || (sfx->iFlags & SFX_FLAG_DEMAND)) &&
+				sfx->iLastTimeUsed < iOldest) 
+			{
+				// new bit, we can't throw away any sfx_t struct in use by a channel, 
+				// else the paint code will crash...
+				//
+				int iChannel;
+				for (iChannel=0; iChannel<s_numChannels; iChannel++)
+				{
+					channel_t *ch = & s_channels[iChannel];
+
+					if (ch->thesfx == sfx)
+						break;	// damn, being used
+				}
+				if (iChannel == s_numChannels)
+				{
+					// this sfx_t struct wasn't used by any channels, so we can lose it...
+					//			
+					iUsed = i;
+					iOldest = sfx->iLastTimeUsed;
+					bDemandLoad = (sfx->iFlags & SFX_FLAG_DEMAND);
+				}
+			}
+		}
+	}
+
+	if (iUsed)
+	{
+		sfx = &s_sfxBlock[ iUsed ];
+		iBytesFreed = SND_FreeSFXMem(sfx);
+	}
+
+	return iBytesFreed;
+}
+int SND_FreeOldestSound(void)
+{
+	return SND_FreeOldestSound(NULL);	// I had to add a void-arg version of this because of link issues, sigh
+}
+
+
+// just before we drop into a level, ensure the audio pool is under whatever the maximum
+//	pool size is (but not by dropping out sounds used by the current level)...
+//
+// returns qtrue if at least one sound was dropped out, so z_malloc-fail recovery code knows if anything changed
+//
+qboolean SND_RegisterAudio_Clean(void)
+{
+	if ( !s_soundStarted ) {
+		return qfalse;
+	}
+
+	qboolean bAtLeastOneSoundDropped = qfalse;
+
+	Com_DPrintf( "SND_RegisterAudio_Clean():\n");
+
+	extern void S_DrainRawSoundData(void);
+	S_DrainRawSoundData();
+
+	{
+		for (int i = 0;	i < MAX_SFX; ++i)
+		{
+			if (s_sfxCodes[i] == INVALID_CODE || i == s_defaultSound) continue;
+
+			sfx_t *sfx = &s_sfxBlock[i];
+
+			if (sfx->iFlags & (SFX_FLAG_RESIDENT | SFX_FLAG_DEMAND))
+			{
+				qboolean bDeleteThis = qtrue;
+				//if (bDeleteThis)
+				{
+					int iChannel;
+					for (iChannel=0; iChannel<s_numChannels; iChannel++)
+					{
+						if (s_channels[iChannel].thesfx == sfx)
+						{
+							bDeleteThis = false;
+							break;
+						}
+					}
+					
+					if (bDeleteThis)
+					{
+						if (!(sfx->iFlags & SFX_FLAG_DEFAULT) &&
+							(sfx->iFlags & SFX_FLAG_RESIDENT) && 
+							SND_FreeSFXMem(sfx))
+						{
+							bAtLeastOneSoundDropped = qtrue;
+						}
+						if (sfx->iFlags & SFX_FLAG_DEMAND)
+						{
+							s_sfxCodes[i] = INVALID_CODE;
+						}
+					}
+				}
+			}
+		}
+	}
+
+	Com_DPrintf( "SND_RegisterAudio_Clean(): Ok\n");	
+
+	return bAtLeastOneSoundDropped;
+}
+
+qboolean SND_RegisterAudio_LevelLoadEnd(qboolean bDeleteEverythingNotUsedThisLevel /* 99% qfalse */)
+{
+        return qfalse;
+}
+
+qboolean S_FileExists( const char *psFilename )
+{
+	// This is only really used for music. Need to swap .mp3 with .wxb on Xbox
+	char *fixedName = S_FixMusicFileName(psFilename);
+
+	// VVFIXME : This can be done better?
+	fileHandle_t fhTemp;
+
+	FS_FOpenFileRead (fixedName, &fhTemp, qtrue);	// qtrue so I can fclose the handle without closing a PAK
+	if (!fhTemp) 
+		return qfalse;
+	
+	FS_FCloseFile(fhTemp);
+	return qtrue;
+}
+
diff --git a/code/client/snd_local.h b/code/client/snd_local.h
new file mode 100644
index 0000000..839709b
--- /dev/null
+++ b/code/client/snd_local.h
@@ -0,0 +1,228 @@
+// snd_local.h -- private sound definations
+
+#ifndef SND_LOCAL_H
+#define SND_LOCAL_H
+
+#include "../game/q_shared.h"
+#include "../qcommon/qcommon.h"
+#include "snd_public.h"
+#include "../mp3code/mp3struct.h"
+
+// Open AL Specific
+#include "openal\al.h"
+#include "openal\alc.h"
+#include "eax\eax.h"
+#include "eax\eaxman.h"
+
+// Added for Open AL to know when to mute all sounds (e.g when app. loses focus)
+void S_AL_MuteAllSounds(qboolean bMute);
+
+
+//from SND_AMBIENT
+extern void AS_Init( void );
+extern void AS_Free( void );
+
+
+#define	PAINTBUFFER_SIZE	1024
+
+
+// !!! if this is changed, the asm code must change !!!
+typedef struct {
+	int			left;	// the final values will be clamped to +/- 0x00ffff00 and shifted down
+	int			right;
+} portable_samplepair_t;
+
+
+// keep this enum in sync with the table "sSoundCompressionMethodStrings"	-ste
+//
+typedef enum
+{
+	ct_16 = 0,		// formerly ct_NONE in EF1, now indicates 16-bit samples (the default)
+	ct_MP3,			
+	//
+	ct_NUMBEROF		// used only for array sizing
+
+} SoundCompressionMethod_t;
+
+
+typedef struct sfx_s {
+	short			*pSoundData;
+	bool			bDefaultSound;			// couldn't be loaded, so use buzz
+	bool			bInMemory;				// not in Memory, set qtrue when loaded, and qfalse when its buffers are freed up because of being old, so can be reloaded
+	short			iLastLevelUsedOn;		// used for cacheing purposes
+	SoundCompressionMethod_t eSoundCompressionMethod;	
+	MP3STREAM		*pMP3StreamHeader;		// NULL ptr unless this sfx_t is an MP3. Use Z_Malloc and Z_Free
+	int 			iSoundLengthInSamples;	// length in samples, always kept as 16bit now so this is #shorts (watch for stereo later for music?)
+	char 			sSoundName[MAX_QPATH];
+	int				iLastTimeUsed;
+	float			fVolRange;				// used to set the highest volume this sample has at load time - used for lipsynching
+
+	// Open AL
+	ALuint		Buffer;
+	char		*lipSyncData;
+
+	struct sfx_s	*next;					// only used because of hash table when registering
+} sfx_t;
+
+typedef struct {
+	int			channels;
+	int			samples;				// mono samples in buffer
+	int			submission_chunk;		// don't mix less than this #
+	int			samplebits;
+	int			speed;
+	byte		*buffer;
+} dma_t;
+
+
+#define START_SAMPLE_IMMEDIATE	0x7fffffff
+
+// Open AL specific
+typedef struct
+{
+	ALuint	BufferID;
+	ALuint	Status;
+	char	*Data;
+} STREAMINGBUFFER;
+
+#define NUM_STREAMING_BUFFERS	4
+#define STREAMING_BUFFER_SIZE	4608		// 4 decoded MP3 frames
+
+#define QUEUED		1
+#define UNQUEUED	2
+
+
+typedef struct
+{
+// back-indented fields new in TA codebase, will re-format when MP3 code finished -ste
+// note: field missing in TA: qboolean	loopSound;		// from an S_AddLoopSound call, cleared each frame
+//
+	int				startSample;	// START_SAMPLE_IMMEDIATE = set immediately on next mix
+	int				entnum;			// to allow overriding a specific sound
+	soundChannel_t	entchannel;		// to allow overriding a specific sound
+	int				leftvol;		// 0-255 volume after spatialization
+	int				rightvol;		// 0-255 volume after spatialization
+	int				master_vol;		// 0-255 volume before spatialization
+
+
+	vec3_t		origin;			// only use if fixed_origin is set
+
+	qboolean	fixed_origin;	// use origin instead of fetching entnum's origin
+	sfx_t		*thesfx;		// sfx structure
+	qboolean	loopSound;		// from an S_AddLoopSound call, cleared each frame
+	//
+	MP3STREAM	MP3StreamHeader;
+	byte		MP3SlidingDecodeBuffer[50000/*12000*/];	// typical back-request = -3072, so roughly double is 6000 (safety), then doubled again so the 6K pos is in the middle of the buffer)
+	int			iMP3SlidingDecodeWritePos;
+	int			iMP3SlidingDecodeWindowPos;
+
+
+	// Open AL specific
+	bool	bLooping;	// Signifies if this channel / source is playing a looping sound
+//	bool	bAmbient;	// Signifies if this channel / source is playing a looping ambient sound
+	bool	bProcessed;	// Signifies if this channel / source has been processed
+	bool	bStreaming;	// Set to true if the data needs to be streamed (MP3 or dialogue)
+	STREAMINGBUFFER	buffers[NUM_STREAMING_BUFFERS];	// AL Buffers for streaming
+	ALuint		alSource;		// Open AL Source
+	bool		bPlaying;		// Set to true when a sound is playing on this channel / source
+	int			iStartTime;		// Time playback of Source begins
+	int			lSlotID;		// ID of Slot rendering Source's environment (enables a send to this FXSlot)
+} channel_t;
+
+
+#define	WAV_FORMAT_PCM		1
+#define WAV_FORMAT_ADPCM	2	// not actually implemented, but is the value that you get in a header
+#define WAV_FORMAT_MP3		3	// not actually used this way, but just ensures we don't match one of the legit formats
+
+
+typedef struct {
+	int			format;
+	int			rate;
+	int			width;
+	int			channels;
+	int			samples;
+	int			dataofs;		// chunk starts this many bytes from file start
+} wavinfo_t;
+
+
+
+/*
+====================================================================
+
+  SYSTEM SPECIFIC FUNCTIONS
+
+====================================================================
+*/
+
+// initializes cycling through a DMA buffer and returns information on it
+qboolean SNDDMA_Init(void);
+
+// gets the current DMA position
+int		SNDDMA_GetDMAPos(void);
+
+// shutdown the DMA xfer.
+void	SNDDMA_Shutdown(void);
+
+void	SNDDMA_BeginPainting (void);
+
+void	SNDDMA_Submit(void);
+
+//====================================================================
+
+#define	MAX_CHANNELS			32
+extern	channel_t   s_channels[MAX_CHANNELS];
+
+extern	int		s_paintedtime;
+extern	int		s_rawend;
+extern	vec3_t	listener_origin;
+extern	vec3_t	listener_forward;
+extern	vec3_t	listener_right;
+extern	vec3_t	listener_up;
+extern	dma_t	dma;
+
+#define	MAX_RAW_SAMPLES	16384
+extern	portable_samplepair_t	s_rawsamples[MAX_RAW_SAMPLES];
+portable_samplepair_t *S_GetRawSamplePointer();	// TA added this, but it just returns the s_rawsamples[] array above. Oh well...
+
+extern cvar_t	*s_volume;
+extern cvar_t	*s_volumeVoice;
+extern cvar_t	*s_nosound;
+extern cvar_t	*s_khz;
+extern cvar_t	*s_allowDynamicMusic;
+extern cvar_t	*s_show;
+extern cvar_t	*s_mixahead;
+
+extern cvar_t	*s_testsound;
+extern cvar_t	*s_separation;
+
+wavinfo_t GetWavinfo (const char *name, byte *wav, int wavlength);
+
+qboolean S_LoadSound( sfx_t *sfx );
+
+
+void S_PaintChannels(int endtime);
+
+// picks a channel based on priorities, empty slots, number of channels
+channel_t *S_PickChannel(int entnum, int entchannel);
+
+// spatializes a channel
+void S_Spatialize(channel_t *ch);
+
+
+//////////////////////////////////
+//
+// new stuff from TA codebase
+
+byte	*SND_malloc(int iSize, sfx_t *sfx);
+void	 SND_setup();
+int		 SND_FreeOldestSound(sfx_t *pButNotThisOne = NULL);
+void	 SND_TouchSFX(sfx_t *sfx);
+
+void S_DisplayFreeMemory(void);
+void S_memoryLoad(sfx_t *sfx);
+//
+//////////////////////////////////
+
+#include "cl_mp3.h"
+
+#endif	// #ifndef SND_LOCAL_H
+
diff --git a/code/client/snd_local_console.h b/code/client/snd_local_console.h
new file mode 100644
index 0000000..542d0e3
--- /dev/null
+++ b/code/client/snd_local_console.h
@@ -0,0 +1,128 @@
+// snd_local.h -- private sound definations
+
+#ifndef SND_LOCAL_H
+#define SND_LOCAL_H
+
+// Following #define is ONLY for MP JKA code.
+// They want to keep qboolean pure enum in that code, so all
+// sound code uses sboolean.
+#define sboolean int
+
+#include "../game/q_shared.h"
+#include "../qcommon/qcommon.h"
+#include "snd_public.h"
+#include "../mp3code/mp3struct.h"
+
+#include "openal/al.h"
+#include "openal/alc.h"
+
+typedef int streamHandle_t;
+
+//from SND_AMBIENT
+extern void AS_Init( void );
+extern void AS_Free( void );
+
+typedef struct {
+	int			format;
+	int			size;
+	int			width;
+	int			rate;
+	int			samples;
+} wavinfo_t;
+
+extern wavinfo_t GetWavInfo(byte *data);
+
+
+#define SFX_FLAG_UNLOADED	(1 << 0)
+#define SFX_FLAG_LOADING	(1 << 1)
+#define SFX_FLAG_RESIDENT	(1 << 2)
+#define SFX_FLAG_DEFAULT	(1 << 3)
+#define SFX_FLAG_DEMAND		(1 << 4)
+#define SFX_FLAG_VOICE		(1 << 5)
+
+typedef struct sfx_s {
+	int				iFlags;
+	int 			iSoundLength;			// length in bytes
+	int				iLastTimeUsed;			// last time sound was played in ms
+	int				iFileCode;				// CRC of the file name
+	streamHandle_t	iStreamHandle;			// handle to the sound file when reading
+	void*			pSoundData;				// buffer to hold sound as we are loading it
+	char*			pLipSyncData;			// buffer to hold lip sync information on characters
+											// store the total number of samples in the first 4 bytes
+											// followed by the actual lipsync data in the remaining bytes
+	ALuint			Buffer;
+
+	//char*			sSoundName;				// added for debugging
+} sfx_t;
+
+typedef struct
+{
+	int			entnum;			// to allow overriding a specific sound
+	int			entchannel;		// to allow overriding a specific sound
+	int			master_vol;		// 0-255 volume before spatialization
+	float		fLastVolume;	// 0-1 last volume sent to AL
+
+	vec3_t		origin;			// sound location
+	bool		bOriginDirty;	// does the AL position need to be updated
+	
+	sfx_t		*thesfx;		// sfx structure
+
+	int			loopChannel;	// index into loopSounds (if appropriate)
+
+	bool		bPlaying;		// Set to true when a sound is playing on this channel / source
+	bool		b2D;			// Signifies a 2d sound
+	bool		bLooping;		// Signifies if this channel / source is playing a looping sound
+	ALuint		alSource;		// Open AL Source
+
+	unsigned int iLastPlayTime;	// Last time a sound was played on this channel
+} channel_t;
+
+extern cvar_t	*s_nosound;
+extern cvar_t	*s_allowDynamicMusic;
+extern cvar_t	*s_show;
+
+extern cvar_t	*s_testsound;
+extern cvar_t	*s_separation;
+
+extern int*	s_entityWavVol;
+
+int Sys_GetFileCode( const char* sSoundName );
+int S_GetFileCode( const char* sSoundName );
+
+qboolean S_StartLoadSound( sfx_t *sfx );
+qboolean S_EndLoadSound( sfx_t *sfx );
+
+void S_InitLoad(void);
+void S_CloseLoad(void);
+void S_UpdateLoading(void);
+
+// New stuff from VV
+void S_LoadSound( sfxHandle_t sfxHandle );
+
+// picks a channel based on priorities, empty slots, number of channels
+channel_t *S_PickChannel(int entnum, int entchannel);
+
+//////////////////////////////////
+//
+// new stuff from TA codebase
+
+void	 SND_update(sfx_t *sfx);
+void	 SND_setup();
+int		 SND_FreeOldestSound(sfx_t *pButNotThisOne = NULL);
+void	 SND_TouchSFX(sfx_t *sfx);
+
+void S_DisplayFreeMemory(void);
+void S_memoryLoad(sfx_t *sfx);
+void S_PreProcessLipSync(sfx_t *sfx);
+
+bool Sys_StreamIsReading(streamHandle_t handle);
+int  Sys_StreamOpen(int code, streamHandle_t *handle);
+bool Sys_StreamRead(void* buffer, int size, int pos, streamHandle_t handle);
+void Sys_StreamClose(streamHandle_t handle);
+bool Sys_StreamIsError(streamHandle_t handle);
+
+//
+//////////////////////////////////
+
+#endif	// #ifndef SND_LOCAL_H
+
diff --git a/code/client/snd_mem.cpp b/code/client/snd_mem.cpp
new file mode 100644
index 0000000..2543585
--- /dev/null
+++ b/code/client/snd_mem.cpp
@@ -0,0 +1,1015 @@
+// snd_mem.c: sound caching
+
+
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+#include "snd_local.h"
+#include "cl_mp3.h"
+
+// Open AL
+void S_PreProcessLipSync(sfx_t *sfx);
+extern int s_UseOpenAL;
+/*
+===============================================================================
+
+WAV loading
+
+===============================================================================
+*/
+
+byte	*data_p;
+byte 	*iff_end;
+byte 	*last_chunk;
+byte 	*iff_data;
+int 	iff_chunk_len;
+extern sfx_t		s_knownSfx[];
+extern	int			s_numSfx;
+
+extern cvar_t		*s_lip_threshold_1;
+extern cvar_t		*s_lip_threshold_2;
+extern cvar_t		*s_lip_threshold_3;
+extern cvar_t		*s_lip_threshold_4;
+
+short GetLittleShort(void)
+{
+	short val = 0;
+	val = *data_p;
+	val = (short)(val + (*(data_p+1)<<8));
+	data_p += 2;
+	return val;
+}
+
+int GetLittleLong(void)
+{
+	int val = 0;
+	val = *data_p;
+	val = val + (*(data_p+1)<<8);
+	val = val + (*(data_p+2)<<16);
+	val = val + (*(data_p+3)<<24);
+	data_p += 4;
+	return val;
+}
+
+void FindNextChunk(char *name)
+{
+	while (1)
+	{
+		data_p=last_chunk;
+
+		if (data_p >= iff_end)
+		{	// didn't find the chunk
+			data_p = NULL;
+			return;
+		}
+		
+		data_p += 4;
+		iff_chunk_len = GetLittleLong();
+		if (iff_chunk_len < 0)
+		{
+			data_p = NULL;
+			return;
+		}
+		data_p -= 8;
+		last_chunk = data_p + 8 + ( (iff_chunk_len + 1) & ~1 );
+		if (!strncmp((char *)data_p, name, 4))
+			return;
+	}
+}
+
+void FindChunk(char *name)
+{
+	last_chunk = iff_data;
+	FindNextChunk (name);
+}
+
+
+void DumpChunks(void)
+{
+	char	str[5];
+	
+	str[4] = 0;
+	data_p=iff_data;
+	do
+	{
+		memcpy (str, data_p, 4);
+		data_p += 4;
+		iff_chunk_len = GetLittleLong();
+		Com_Printf ("0x%x : %s (%d)\n", (int)(data_p - 4), str, iff_chunk_len);
+		data_p += (iff_chunk_len + 1) & ~1;
+	} while (data_p < iff_end);
+}
+
+/*
+============
+GetWavinfo
+============
+*/
+wavinfo_t GetWavinfo (const char *name, byte *wav, int wavlength)
+{
+	wavinfo_t	info;
+	int		samples;
+
+	memset (&info, 0, sizeof(info));
+
+	if (!wav)
+		return info;
+		
+	iff_data = wav;
+	iff_end = wav + wavlength;
+
+// find "RIFF" chunk
+	FindChunk("RIFF");
+	if (!(data_p && !strncmp((char *)data_p+8, "WAVE", 4)))
+	{
+		Com_Printf("Missing RIFF/WAVE chunks\n");
+		return info;
+	}
+
+// get "fmt " chunk
+	iff_data = data_p + 12;
+// DumpChunks ();
+
+	FindChunk("fmt ");
+	if (!data_p)
+	{
+		Com_Printf("Missing fmt chunk\n");
+		return info;
+	}
+	data_p += 8;
+	info.format = GetLittleShort();
+	info.channels = GetLittleShort();
+	info.rate = GetLittleLong();
+	data_p += 4+2;
+	info.width = GetLittleShort() / 8;
+
+	if (info.format != 1)
+	{
+		Com_Printf("Microsoft PCM format only\n");
+		return info;
+	}
+
+
+// find data chunk
+	FindChunk("data");
+	if (!data_p)
+	{
+		Com_Printf("Missing data chunk\n");
+		return info;
+	}
+
+	data_p += 4;
+	samples = GetLittleLong () / info.width;
+
+	if (info.samples)
+	{
+		if (samples < info.samples)
+			Com_Error (ERR_DROP, "Sound %s has a bad loop length", name);
+	}
+	else
+		info.samples = samples;
+
+	info.dataofs = data_p - wav;
+
+
+	return info;
+}
+
+
+/*
+================
+ResampleSfx
+
+resample / decimate to the current source rate
+================
+*/
+void ResampleSfx (sfx_t *sfx, int iInRate, int iInWidth, byte *pData)
+{
+	int		iOutCount;
+	int		iSrcSample;
+	float	fStepScale;
+	int		i;
+	int		iSample;
+	unsigned int uiSampleFrac, uiFracStep;	// uiSampleFrac MUST be unsigned, or large samples (eg music tracks) crash
+	
+	fStepScale = (float)iInRate / dma.speed;	// this is usually 0.5, 1, or 2
+
+	// When stepscale is > 1 (we're downsampling), we really ought to run a low pass filter on the samples
+
+	iOutCount = (int)(sfx->iSoundLengthInSamples / fStepScale);
+	sfx->iSoundLengthInSamples = iOutCount;
+
+	sfx->pSoundData = (short *) SND_malloc( sfx->iSoundLengthInSamples*2 ,sfx );
+
+	sfx->fVolRange	= 0;
+	uiSampleFrac	= 0;
+	uiFracStep		= (int)(fStepScale*256);
+
+	for (i=0 ; i<sfx->iSoundLengthInSamples ; i++)
+	{
+		iSrcSample = uiSampleFrac >> 8;
+		uiSampleFrac += uiFracStep;
+		if (iInWidth == 2) {
+			iSample = LittleShort ( ((short *)pData)[iSrcSample] );			
+		} else {
+			iSample = (int)( (unsigned char)(pData[iSrcSample]) - 128) << 8;			
+		}
+
+		sfx->pSoundData[i] = (short)iSample;
+
+		// work out max vol for this sample...
+		//
+		if (iSample < 0)
+			iSample = -iSample;
+		if (sfx->fVolRange < (iSample >> 8) )
+		{
+			sfx->fVolRange =  iSample >> 8;
+		}
+	}
+}
+
+
+//=============================================================================
+
+
+void S_LoadSound_Finalize(wavinfo_t	*info, sfx_t *sfx, byte *data)
+{				   
+	float	stepscale	= (float)info->rate / dma.speed;	
+	int		len			= (int)(info->samples / stepscale);
+
+	len *= info->width;
+
+	sfx->eSoundCompressionMethod = ct_16;
+	sfx->iSoundLengthInSamples	 = info->samples;
+	ResampleSfx( sfx, info->rate, info->width, data + info->dataofs );	
+}
+
+
+
+
+
+// maybe I'm re-inventing the wheel, here, but I can't see any functions that already do this, so...
+//
+char *Filename_WithoutPath(const char *psFilename)
+{
+	static char sString[MAX_QPATH];	// !!
+	const char *p = strrchr(psFilename,'\\');
+
+  	if (!p++)
+		p=psFilename;
+
+	strcpy(sString,p);
+
+	return sString;
+
+}
+
+// returns (eg) "\dir\name" for "\dir\name.bmp"
+//
+char *Filename_WithoutExt(const char *psFilename)
+{
+	static char sString[MAX_QPATH];	// !
+
+	strcpy(sString,psFilename);
+
+	char *p = strrchr(sString,'.');		
+	char *p2= strrchr(sString,'\\');
+
+	// special check, make sure the first suffix we found from the end wasn't just a directory suffix (eg on a path'd filename with no extension anyway)
+	//
+	if (p && (p2==0 || (p2 && p>p2)))
+		*p=0;	
+
+	return sString;
+
+}
+
+
+
+int iFilesFound;
+int iFilesUpdated;
+int iErrors;
+qboolean qbForceRescan;
+qboolean qbForceStereo;
+string strErrors;
+
+void R_CheckMP3s( const char *psDir )
+{
+//	Com_Printf(va("Scanning Dir: %s\n",psDir));
+	Com_Printf(".");	// stops useful info scrolling off screen
+
+	char	**sysFiles, **dirFiles;
+	int		numSysFiles, i, numdirs;
+
+	dirFiles = FS_ListFiles( psDir, "/", &numdirs);
+	if (numdirs > 2)
+	{
+		for (i=2;i<numdirs;i++)
+		{
+			char	sDirName[MAX_QPATH];
+			sprintf(sDirName, "%s\\%s", psDir, dirFiles[i]);
+			R_CheckMP3s(sDirName);
+		}
+	}
+
+	sysFiles = FS_ListFiles( psDir, ".mp3", &numSysFiles );
+	for(i=0; i<numSysFiles; i++)
+	{
+		char	sFilename[MAX_QPATH];
+		sprintf(sFilename,"%s\\%s", psDir, sysFiles[i]);		
+			
+		Com_Printf("%sFound file: %s",!i?"\n":"",sFilename);
+
+		iFilesFound++;
+
+		// read it in...
+		//
+		byte *pbData = NULL;
+		int iSize = FS_ReadFile( sFilename, (void **)&pbData);
+
+		if (pbData)
+		{
+			id3v1_1* pTAG;
+
+			// do NOT check 'qbForceRescan' here as an opt, because we need to actually fill in 'pTAG' if there is one...
+			//
+			qboolean qbTagNeedsUpdating = (/* qbForceRescan || */ !MP3_ReadSpecialTagInfo(pbData, iSize, &pTAG))?qtrue:qfalse;
+
+			if (pTAG == NULL || qbTagNeedsUpdating || qbForceRescan)
+			{
+				Com_Printf(" ( Updating )\n");
+
+				// I need to scan this file to get the volume...
+				//
+				// For EF1 I used a temp sfx_t struct, but I can't do that now with this new alloc scheme,
+				//	I have to ask for it legally, so I'll keep re-using one, and restoring it's name after use.
+				//	(slightly dodgy, but works ok if no-one else changes stuff)
+				//
+				//sfx_t SFX = {0};
+				extern sfx_t *S_FindName( const char *name );
+				//
+				static sfx_t *pSFX = NULL;
+				const char sReservedSFXEntrynameForMP3[] = "reserved_for_mp3";	// ( strlen() < MAX_QPATH )
+
+				if (pSFX == NULL)	// once only
+				{
+					pSFX = S_FindName(sReservedSFXEntrynameForMP3);	// always returns, else ERR_FATAL					
+				}
+
+				if (MP3_IsValid(sFilename,pbData, iSize, qbForceStereo))
+				{
+					wavinfo_t info;
+
+					int iRawPCMDataSize = MP3_GetUnpackedSize(sFilename, pbData, iSize, qtrue, qbForceStereo);
+
+					if (iRawPCMDataSize)	// should always be true, unless file is fucked, in which case, stop this conversion process
+					{
+						float fMaxVol = 128;	// any old default
+						int iActualUnpackedSize = iRawPCMDataSize;	// default, override later if not doing music
+
+						if (!qbForceStereo)	// no point for stereo files, which are for music and therefore no lip-sync
+						{
+							byte *pbUnpackBuffer = (byte *) Z_Malloc( iRawPCMDataSize+10, TAG_TEMP_WORKSPACE, qfalse );	// won't return if fails
+
+							iActualUnpackedSize = MP3_UnpackRawPCM( sFilename, pbData, iSize, pbUnpackBuffer );
+							if (iActualUnpackedSize != iRawPCMDataSize)
+							{
+								Com_Error(ERR_DROP, "******* Whoah! MP3 %s unpacked to %d bytes, but size calc said %d!\n",sFilename,iActualUnpackedSize,iRawPCMDataSize);
+							}
+						
+							// fake up a WAV structure so I can use the other post-load sound code such as volume calc for lip-synching
+							//
+							MP3_FakeUpWAVInfo( sFilename, pbData, iSize, iActualUnpackedSize,
+												// these params are all references...
+												info.format, info.rate, info.width, info.channels, info.samples, info.dataofs
+												);
+
+							S_LoadSound_Finalize(&info, pSFX, pbUnpackBuffer);	// all this just for lipsynch. Oh well.
+
+							fMaxVol = pSFX->fVolRange;
+
+							// free sfx->data...
+							//
+							{
+								#ifndef INT_MIN
+								#define INT_MIN     (-2147483647 - 1) /* minimum (signed) int value */
+								#endif
+								//
+								pSFX->iLastTimeUsed = INT_MIN;		// force this to be oldest sound file, therefore disposable...
+								pSFX->bInMemory = true;
+								SND_FreeOldestSound();		// ... and do the disposal
+
+								// now set our temp SFX struct back to default name so nothing else accidentally uses it...
+								//
+								strcpy(pSFX->sSoundName, sReservedSFXEntrynameForMP3);
+								pSFX->bDefaultSound = false;								
+							}
+
+//							OutputDebugString(va("File: \"%s\"   MaxVol %f\n",sFilename,pSFX->fVolRange));
+
+							// other stuff...
+							//
+							Z_Free(pbUnpackBuffer);
+						}
+
+						// well, time to update the file now...
+						//
+						fileHandle_t f = FS_FOpenFileWrite( sFilename );
+						if (f)
+						{
+							// write the file back out, but omitting the tag if there was one...
+							//
+							int iWritten = FS_Write(pbData, iSize-(pTAG?sizeof(*pTAG):0), f);
+
+							if (iWritten)
+							{
+								// make up a new tag if we didn't find one in the original file...
+								//
+								id3v1_1 TAG;
+								if (!pTAG)
+								{
+									pTAG = &TAG;
+									memset(&TAG,0,sizeof(TAG));
+									strncpy(pTAG->id,"TAG",3);
+								}
+
+								strncpy(pTAG->title,	Filename_WithoutPath(Filename_WithoutExt(sFilename)), sizeof(pTAG->title));
+								strncpy(pTAG->artist,	"Raven Software",						sizeof(pTAG->artist)	);
+								strncpy(pTAG->year,		"2002",									sizeof(pTAG->year)		);
+								strncpy(pTAG->comment,	va("%s %g",sKEY_MAXVOL,fMaxVol),		sizeof(pTAG->comment)	);
+								strncpy(pTAG->album,	va("%s %d",sKEY_UNCOMP,iActualUnpackedSize),sizeof(pTAG->album)	);
+								
+								if (FS_Write( pTAG, sizeof(*pTAG), f ))	// NZ = success
+								{
+									iFilesUpdated++;
+								}
+								else
+								{
+									Com_Printf("*********** Failed write to file \"%s\"!\n",sFilename);
+									iErrors++;
+									strErrors += va("Failed to write: \"%s\"\n",sFilename);
+								}
+							}
+							else
+							{
+								Com_Printf("*********** Failed write to file \"%s\"!\n",sFilename);
+								iErrors++;
+								strErrors += va("Failed to write: \"%s\"\n",sFilename);
+							}
+							FS_FCloseFile( f );
+						}
+						else
+						{
+							Com_Printf("*********** Failed to re-open for write \"%s\"!\n",sFilename);
+							iErrors++;
+							strErrors += va("Failed to re-open for write: \"%s\"\n",sFilename);
+						}					
+					}
+					else
+					{
+						Com_Error(ERR_DROP, "******* This MP3 should be deleted: \"%s\"\n",sFilename);
+					}
+				}
+				else
+				{
+					Com_Printf("*********** File was not a valid MP3!: \"%s\"\n",sFilename);
+					iErrors++;
+					strErrors += va("Not game-legal MP3 format: \"%s\"\n",sFilename);
+				}
+			}
+			else
+			{
+				Com_Printf(" ( OK )\n");
+			}
+
+			FS_FreeFile( pbData );
+		}
+	}
+	FS_FreeFileList( sysFiles );
+	FS_FreeFileList( dirFiles );
+}
+
+// this console-function is for development purposes, and makes sure that sound/*.mp3 /s have tags in them
+//	specifying stuff like their max volume (and uncompressed size) etc...
+//
+void S_MP3_CalcVols_f( void )
+{
+	char sStartDir[MAX_QPATH] = {"sound"};
+	const char sUsage[] = "Usage: mp3_calcvols [-rescan] <startdir>\ne.g. mp3_calcvols sound/chars";
+
+	if (Cmd_Argc() == 1 || Cmd_Argc()>4)	// 3 optional arguments
+	{
+		Com_Printf(sUsage);
+		return;
+	}
+
+	S_StopAllSounds();
+
+
+	qbForceRescan = qfalse;
+	qbForceStereo = qfalse;
+	iFilesFound		= 0;
+	iFilesUpdated	= 0;
+	iErrors			= 0;
+	strErrors		= "";
+
+	for (int i=1; i<Cmd_Argc(); i++)
+	{
+		if (Cmd_Argv(i)[0] == '-')
+		{
+			if (!Q_stricmp(Cmd_Argv(i),"-rescan"))
+			{
+				qbForceRescan = qtrue;
+			}
+			else
+			if (!Q_stricmp(Cmd_Argv(i),"-stereo"))
+			{
+				qbForceStereo = qtrue;
+			}
+			else
+			{
+				// unknown switch...
+				//
+				Com_Printf(sUsage);
+				return;
+			}
+			continue;
+		}
+		strcpy(sStartDir,Cmd_Argv(i));
+	}
+
+	Com_Printf(va("Starting Scan for Updates in Dir: %s\n",sStartDir));
+	R_CheckMP3s( sStartDir );
+
+	Com_Printf("\n%d files found/scanned, %d files updated      ( %d errors total)\n",iFilesFound,iFilesUpdated,iErrors);
+
+	if (iErrors)
+	{
+		Com_Printf("\nBad Files:\n%s\n",strErrors.c_str());
+	}
+}
+
+
+
+
+
+// adjust filename for foreign languages and WAV/MP3 issues. 
+//
+// returns qfalse if failed to load, else fills in *pData
+//
+extern	cvar_t	*com_buildScript;
+static qboolean S_LoadSound_FileLoadAndNameAdjuster(char *psFilename, byte **pData, int *piSize, int iNameStrlen)
+{
+	char *psVoice = strstr(psFilename,"chars");
+	if (psVoice)
+	{
+		// cache foreign voices...
+		//		
+		if (com_buildScript->integer)
+		{
+			fileHandle_t hFile;
+			//German
+			strncpy(psVoice,"chr_d",5);	// same number of letters as "chars"
+			FS_FOpenFileRead(psFilename, &hFile, qfalse);		//cache the wav
+			if (!hFile)
+			{
+				strcpy(&psFilename[iNameStrlen-3],"mp3");		//not there try mp3
+				FS_FOpenFileRead(psFilename, &hFile, qfalse);	//cache the mp3
+			}
+			if (hFile)
+			{
+				FS_FCloseFile(hFile);
+			}
+			strcpy(&psFilename[iNameStrlen-3],"wav");	//put it back to wav
+
+			//French
+			strncpy(psVoice,"chr_f",5);	// same number of letters as "chars"
+			FS_FOpenFileRead(psFilename, &hFile, qfalse);		//cache the wav
+			if (!hFile)
+			{
+				strcpy(&psFilename[iNameStrlen-3],"mp3");		//not there try mp3
+				FS_FOpenFileRead(psFilename, &hFile, qfalse);	//cache the mp3
+			}
+			if (hFile)
+			{
+				FS_FCloseFile(hFile);
+			}
+			strcpy(&psFilename[iNameStrlen-3],"wav");	//put it back to wav
+
+			//Spanish
+			strncpy(psVoice,"chr_e",5);	// same number of letters as "chars"
+			FS_FOpenFileRead(psFilename, &hFile, qfalse);		//cache the wav
+			if (!hFile)
+			{
+				strcpy(&psFilename[iNameStrlen-3],"mp3");		//not there try mp3
+				FS_FOpenFileRead(psFilename, &hFile, qfalse);	//cache the mp3
+			}
+			if (hFile)
+			{
+				FS_FCloseFile(hFile);
+			}
+			strcpy(&psFilename[iNameStrlen-3],"wav");	//put it back to wav
+
+			strncpy(psVoice,"chars",5);	//put it back to chars
+		}
+
+		// account for foreign voices...
+		//		
+		extern cvar_t* s_language;
+		if (s_language && stricmp("DEUTSCH",s_language->string)==0)
+		{				
+			strncpy(psVoice,"chr_d",5);	// same number of letters as "chars"
+		}
+		else if (s_language && stricmp("FRANCAIS",s_language->string)==0)
+		{				
+			strncpy(psVoice,"chr_f",5);	// same number of letters as "chars"
+		}
+		else if (s_language && stricmp("ESPANOL",s_language->string)==0)
+		{				
+			strncpy(psVoice,"chr_e",5);	// same number of letters as "chars"
+		}
+		else
+		{
+			psVoice = NULL;	// use this ptr as a flag as to whether or not we substituted with a foreign version
+		}
+	}
+
+	*piSize = FS_ReadFile( psFilename, (void **)pData );	// try WAV
+	if ( !*pData ) {
+		psFilename[iNameStrlen-3] = 'm';
+		psFilename[iNameStrlen-2] = 'p';
+		psFilename[iNameStrlen-1] = '3';
+		*piSize = FS_ReadFile( psFilename, (void **)pData );	// try MP3
+
+		if ( !*pData ) 
+		{
+			//hmmm, not found, ok, maybe we were trying a foreign noise ("arghhhhh.mp3" that doesn't matter?) but it
+			// was missing?   Can't tell really, since both types are now in sound/chars. Oh well, fall back to English for now...
+			
+			if (psVoice)	// were we trying to load foreign?
+			{
+				// yep, so fallback to re-try the english...
+				//				
+#ifndef FINAL_BUILD
+				Com_Printf(S_COLOR_YELLOW "Foreign file missing: \"%s\"! (using English...)\n",psFilename);
+#endif
+
+				strncpy(psVoice,"chars",5);
+
+				psFilename[iNameStrlen-3] = 'w';
+				psFilename[iNameStrlen-2] = 'a';
+				psFilename[iNameStrlen-1] = 'v';
+				*piSize = FS_ReadFile( psFilename, (void **)pData );	// try English WAV
+				if ( !*pData ) 
+				{						
+					psFilename[iNameStrlen-3] = 'm';
+					psFilename[iNameStrlen-2] = 'p';
+					psFilename[iNameStrlen-1] = '3';
+					*piSize = FS_ReadFile( psFilename, (void **)pData );	// try English MP3
+				}
+			}
+
+			if (!*pData)
+			{
+				return qfalse;	// sod it, give up...
+			}
+		}
+	}
+
+	return qtrue;
+}
+
+
+// returns qtrue if this dir is allowed to keep loaded MP3s, else qfalse if they should be WAV'd instead...
+//
+// note that this is passed the original, un-language'd name
+//
+// (I was going to remove this, but on kejim_post I hit an assert because someone had got an ambient sound when the
+//	perimter fence goes online that was an MP3, then it tried to get added as looping. Presumably it sounded ok or
+//	they'd have noticed, but we therefore need to stop other levels using those. "sound/ambience" I can check for,
+//	but doors etc could be anything. Sigh...)
+//
+static qboolean S_LoadSound_DirIsAllowedToKeepMP3s(const char *psFilename)
+{
+	const char *psAllowedDirs[] = 
+	{
+		"sound/chars/",
+//		"sound/chr_d/"	// no need for this now, or any other language, since we'll always compare against english
+	};
+
+	int i;
+	for (i=0; i< (sizeof(psAllowedDirs) / sizeof(psAllowedDirs[0])); i++)
+	{
+		if (strnicmp(psFilename, psAllowedDirs[i], strlen(psAllowedDirs[i]))==0)
+			return qtrue;	// found a dir that's allowed to keep MP3s
+	}
+
+	return qfalse;
+}
+
+
+
+/*
+==============
+S_LoadSound
+
+The filename may be different than sfx->name in the case
+of a forced fallback of a player specific sound	(or of a wav/mp3 substitution now -Ste)
+==============
+*/
+qboolean gbInsideLoadSound = qfalse;
+static qboolean S_LoadSound_Actual( sfx_t *sfx )
+{
+	byte	*data;
+	short	*samples;
+	wavinfo_t	info;
+	int		size;
+	char	*psExt;
+	char	sLoadName[MAX_QPATH];
+	ALuint  Buffer;
+	
+	int		len = strlen(sfx->sSoundName);
+	if (len<5)
+	{
+		return qfalse;
+	}
+
+	// player specific sounds are never directly loaded...
+	//
+	if ( sfx->sSoundName[0] == '*') {
+		return qfalse;
+	}
+	// make up a local filename to try wav/mp3 substitutes...
+	//	
+	Q_strncpyz(sLoadName, sfx->sSoundName, sizeof(sLoadName));	
+	strlwr( sLoadName );
+	//
+	// Ensure name has an extension (which it must have, but you never know), and get ptr to it...
+	//
+	psExt = &sLoadName[strlen(sLoadName)-4];
+	if (*psExt != '.')
+	{
+		//Com_Printf( "WARNING: soundname '%s' does not have 3-letter extension\n",sLoadName);
+		COM_DefaultExtension(sLoadName,sizeof(sLoadName),".wav");	// so psExt below is always valid
+		psExt = &sLoadName[strlen(sLoadName)-4];
+		len = strlen(sLoadName);
+	}
+
+	if (!S_LoadSound_FileLoadAndNameAdjuster(sLoadName, &data, &size, len))
+	{
+		return qfalse;
+	}
+
+	SND_TouchSFX(sfx);
+//=========
+	if (strnicmp(psExt,".mp3",4)==0)
+	{
+		// load MP3 file instead...
+		//		
+		if (MP3_IsValid(sLoadName,data, size, qfalse))
+		{
+			int iRawPCMDataSize = MP3_GetUnpackedSize(sLoadName,data,size,qfalse,qfalse);
+			
+			if (S_LoadSound_DirIsAllowedToKeepMP3s(sfx->sSoundName)	// NOT sLoadName, this uses original un-languaged name
+				&&
+				MP3Stream_InitFromFile(sfx, data, size, sLoadName, iRawPCMDataSize + 2304 /* + 1 MP3 frame size, jic */,qfalse)				
+				)
+			{
+//				Com_DPrintf("(Keeping file \"%s\" as MP3)\n",sLoadName);
+
+				if (s_UseOpenAL)
+				{
+					// Create space for lipsync data (4 lip sync values per streaming AL buffer)
+					if (strstr(sfx->sSoundName, "chars") )
+						sfx->lipSyncData = (char *)Z_Malloc(16, TAG_SND_RAWDATA, false);
+					else
+						sfx->lipSyncData = NULL;
+				}
+			}
+			else
+			{
+				// small file, not worth keeping as MP3 since it would increase in size (with MP3 header etc)...
+				//
+				Com_DPrintf("S_LoadSound: Unpacking MP3 file \"%s\" to wav.\n",sLoadName);
+				//
+				// unpack and convert into WAV...
+				//
+				{
+					byte *pbUnpackBuffer = (byte *) Z_Malloc( iRawPCMDataSize+10 +2304 /* <g> */, TAG_TEMP_WORKSPACE, qfalse );	// won't return if fails
+					
+					{
+						int iResultBytes = MP3_UnpackRawPCM( sLoadName, data, size, pbUnpackBuffer, qfalse );
+
+						if (iResultBytes!= iRawPCMDataSize){
+							Com_Printf(S_COLOR_YELLOW"**** MP3 %s final unpack size %d different to previous value %d\n",sLoadName,iResultBytes,iRawPCMDataSize);
+							//assert (iResultBytes == iRawPCMDataSize);
+						}
+
+
+						// fake up a WAV structure so I can use the other post-load sound code such as volume calc for lip-synching
+						//
+						// (this is a bit crap really, but it lets me drop through into existing code)...
+						//
+						MP3_FakeUpWAVInfo( sLoadName, data, size, iResultBytes,
+											// these params are all references...
+											info.format, info.rate, info.width, info.channels, info.samples, info.dataofs,
+											qfalse
+										);
+
+						S_LoadSound_Finalize(&info,sfx,pbUnpackBuffer);
+
+						// Open AL
+						if (s_UseOpenAL)
+						{
+							if (strstr(sfx->sSoundName, "chars"))
+							{
+								sfx->lipSyncData = (char *)Z_Malloc((sfx->iSoundLengthInSamples / 1000) + 1, TAG_SND_RAWDATA, false);
+								S_PreProcessLipSync(sfx);
+							}
+							else
+								sfx->lipSyncData = NULL;
+
+							// Clear Open AL Error state
+							alGetError();
+
+							// Generate AL Buffer
+							alGenBuffers(1, &Buffer);
+							if (alGetError() == AL_NO_ERROR)
+							{
+								// Copy audio data to AL Buffer
+								alBufferData(Buffer, AL_FORMAT_MONO16, sfx->pSoundData, sfx->iSoundLengthInSamples*2, 22050);
+								if (alGetError() == AL_NO_ERROR)
+								{
+									sfx->Buffer = Buffer;
+									Z_Free(sfx->pSoundData);
+									sfx->pSoundData = NULL;
+								}
+							}
+						}
+
+						Z_Free(pbUnpackBuffer);
+					}
+				}
+			}
+		}
+		else
+		{
+			// MP3_IsValid() will already have printed any errors via Com_Printf at this point...
+			//			
+			FS_FreeFile (data);
+			return qfalse;
+		}
+	}
+	else
+	{
+		// loading a WAV, presumably...
+
+//=========
+
+		info = GetWavinfo( sLoadName, data, size );
+		if ( info.channels != 1 ) {
+			Com_Printf ("%s is a stereo wav file\n", sLoadName);
+			FS_FreeFile (data);
+			return qfalse;
+		}
+
+/*		if ( info.width == 1 ) {
+			Com_Printf(S_COLOR_YELLOW "WARNING: %s is a 8 bit wav file\n", sLoadName);
+		}
+
+		if ( info.rate != 22050 ) {
+			Com_Printf(S_COLOR_YELLOW "WARNING: %s is not a 22kHz wav file\n", sLoadName);
+		}
+*/
+		samples = (short *)Z_Malloc(info.samples * sizeof(short) * 2, TAG_TEMP_WORKSPACE, qfalse);
+
+		sfx->eSoundCompressionMethod = ct_16;
+		sfx->iSoundLengthInSamples	 = info.samples;
+		sfx->pSoundData = NULL;
+		ResampleSfx( sfx, info.rate, info.width, data + info.dataofs );
+
+		// Open AL
+		if (s_UseOpenAL)
+		{
+			if ((strstr(sfx->sSoundName, "chars")) || (strstr(sfx->sSoundName, "CHARS")))
+			{
+				sfx->lipSyncData = (char *)Z_Malloc((sfx->iSoundLengthInSamples / 1000) + 1, TAG_SND_RAWDATA, false);
+				S_PreProcessLipSync(sfx);
+			}
+			else
+				sfx->lipSyncData = NULL;
+
+			// Clear Open AL Error State
+			alGetError();
+
+			// Generate AL Buffer
+			alGenBuffers(1, &Buffer);
+			if (alGetError() == AL_NO_ERROR)
+			{
+				// Copy audio data to AL Buffer
+				alBufferData(Buffer, AL_FORMAT_MONO16, sfx->pSoundData, sfx->iSoundLengthInSamples*2, 22050);
+				if (alGetError() == AL_NO_ERROR)
+				{
+					// Store AL Buffer in sfx struct, and release sample data
+					sfx->Buffer = Buffer;
+					Z_Free(sfx->pSoundData);
+					sfx->pSoundData = NULL;
+				}
+			}
+		}
+
+		Z_Free(samples);
+	}
+	
+	FS_FreeFile( data );
+
+	return qtrue;
+}
+
+
+// wrapper function for above so I can guarantee that we don't attempt any audio-dumping during this call because
+//	of a z_malloc() fail recovery...
+//
+qboolean S_LoadSound( sfx_t *sfx )
+{
+	gbInsideLoadSound = qtrue;	// !!!!!!!!!!!!!
+		
+		qboolean bReturn = S_LoadSound_Actual( sfx );
+
+	gbInsideLoadSound = qfalse;	// !!!!!!!!!!!!!
+
+	return bReturn;
+}
+
+
+/*
+	Precalculate the lipsync values for the whole sample
+*/
+void S_PreProcessLipSync(sfx_t *sfx)
+{
+	int i, j;
+	int sample;
+	int sampleTotal = 0;
+
+	j = 0;
+	for (i = 0; i < sfx->iSoundLengthInSamples; i += 100)
+	{
+		sample = LittleShort(sfx->pSoundData[i]);
+
+		sample = sample >> 8;
+		sampleTotal += sample * sample;
+		if (((i + 100) % 1000) == 0)
+		{
+			sampleTotal /= 10;
+
+			if (sampleTotal < sfx->fVolRange *  s_lip_threshold_1->value)
+			{
+				// tell the scripts that are relying on this that we are still going, but actually silent right now.
+				sample = -1;
+			}
+			else if (sampleTotal < sfx->fVolRange * s_lip_threshold_2->value)
+				sample = 1;
+			else if (sampleTotal < sfx->fVolRange * s_lip_threshold_3->value)
+				sample = 2;
+			else if (sampleTotal < sfx->fVolRange * s_lip_threshold_4->value)
+				sample = 3;
+			else
+				sample = 4;
+			
+			sfx->lipSyncData[j] = sample;
+			j++;
+
+			sampleTotal = 0;
+		}
+	}
+
+	if ((i % 1000) == 0)
+		return;
+
+	i -= 100;
+	i = i % 1000;
+	i = i / 100;
+	// Process last < 1000 samples
+	if (i != 0)
+		sampleTotal /= i;
+	else
+		sampleTotal = 0;
+
+	if (sampleTotal < sfx->fVolRange * s_lip_threshold_1->value)
+	{
+		// tell the scripts that are relying on this that we are still going, but actually silent right now.
+		sample = -1;
+	}
+	else if (sampleTotal < sfx->fVolRange * s_lip_threshold_2->value)
+		sample = 1;
+	else if (sampleTotal < sfx->fVolRange * s_lip_threshold_3->value)
+		sample = 2;
+	else if (sampleTotal < sfx->fVolRange * s_lip_threshold_4->value)
+		sample = 3;
+	else
+		sample = 4;
+			
+	sfx->lipSyncData[j] = sample;
+}
+
diff --git a/code/client/snd_mem_console.cpp b/code/client/snd_mem_console.cpp
new file mode 100644
index 0000000..476cdc1
--- /dev/null
+++ b/code/client/snd_mem_console.cpp
@@ -0,0 +1,359 @@
+// snd_mem.c: sound caching
+
+
+// leave this as first line for PCH reasons...
+//
+// #include "../server/exe_headers.h"
+
+#include "snd_local_console.h"
+
+#ifdef _XBOX
+#include <xtl.h>
+#endif
+
+#define SND_MAX_LOADS 48
+static sfx_t** s_LoadList = NULL;
+static int s_LoadListSize = 0;
+qboolean gbInsideLoadSound = qfalse;	// Needed to link VVFIXME
+
+extern int Sys_GetFileCode(const char *name);
+
+//Drain sound main memory into ARAM.
+void S_DrainRawSoundData(void)
+{
+	extern int s_soundStarted;
+	if (!s_soundStarted) return;
+
+	do
+	{
+		S_UpdateLoading();
+
+#ifdef _GAMECUBE
+		extern void ERR_DiscFail(bool);
+		ERR_DiscFail(true);
+#endif
+	} 
+	while (s_LoadListSize);
+}
+
+
+
+/*
+============
+GetWavInfo
+============
+*/
+wavinfo_t GetWavInfo(byte *data)
+{
+	wavinfo_t info;
+	memset(&info, 0, sizeof(wavinfo_t));
+
+	if (!data) return info;
+
+#ifdef _GAMECUBE
+	if (*(short*)&data[14] != 0)
+	{
+		// invalid type, abort
+		return info;
+	}
+
+	info.format = AL_FORMAT_MONO4;
+	info.width = 4;
+	info.size = ((*(int*)&data[20]) >> 1) + 96;
+	info.rate = *(int*)&data[8];
+#else
+	int dataofs = 0;
+	if (strncmp((char *)&data[dataofs + 0], "RIFF", 4) ||
+		strncmp((char *)&data[dataofs + 8], "WAVE", 4))
+	{
+		// invalid type, abort
+		return info;
+	}
+	dataofs += 12; // done with riff chunk
+
+	WAVEFORMATEX* wav = (WAVEFORMATEX*)&data[dataofs + 8];
+	info.format = wav->nChannels == 1 ? AL_FORMAT_MONO4 : AL_FORMAT_STEREO4;
+	info.rate = wav->nSamplesPerSec;
+	info.width = wav->wBitsPerSample;
+	dataofs += sizeof(WAVEFORMATEX) + wav->cbSize + 8; // done with fmt chunk
+	
+	info.size = *(int*)&data[dataofs + 4];
+	info.samples = (info.size * 2);
+
+	dataofs += 8; // done with data chunk
+#endif
+
+	return info;
+}
+
+// adjust filename for foreign languages and WAV/MP3 issues. 
+//
+static qboolean S_LoadSound_FileNameAdjuster(char *psFilename)
+{
+#if defined(_XBOX)
+	const char* ext = "wxb";
+#elif defined(_WINDOWS)
+	const char* ext = "wav";
+#elif defined(_GAMECUBE)
+	const char* ext = "wgc";
+#endif
+	
+	int len = strlen(psFilename);
+#if 0
+	char *psVoice = strstr(psFilename,"chars");
+	if (psVoice)
+	{
+		// account for foreign voices...
+		//		
+		extern cvar_t* sp_language;
+		if (sp_language && sp_language->integer==SP_LANGUAGE_GERMAN)
+		{				
+			strncpy(psVoice,"chr_d",5);	// same number of letters as "chars"
+		}
+		else
+		if (sp_language && sp_language->integer==SP_LANGUAGE_FRENCH)
+		{				
+			strncpy(psVoice,"chr_f",5);	// same number of letters as "chars"
+		}
+		else
+		{
+			psVoice = NULL;	// use this ptr as a flag as to whether or not we substituted with a foreign version
+		}
+	}
+#else
+	char *psVoice = NULL;
+#endif
+
+	psFilename[len-3] = ext[0];
+	psFilename[len-2] = ext[1];
+	psFilename[len-1] = ext[2];
+	int code = Sys_GetFileCode( psFilename );
+
+	if ( code == -1 )
+	{
+		//hmmm, not found, ok, maybe we were trying a foreign noise ("arghhhhh.mp3" that doesn't matter?) but it
+		// was missing?   Can't tell really, since both types are now in sound/chars. Oh well, fall back to English for now...
+		
+		if (psVoice)	// were we trying to load foreign?
+		{
+			// yep, so fallback to re-try the english...
+			//
+			strncpy(psVoice,"chars",5);
+			
+			psFilename[len-3] = ext[0];
+			psFilename[len-2] = ext[1];
+			psFilename[len-1] = ext[2];
+			code = Sys_GetFileCode( psFilename );
+		}
+	}
+
+	return code;
+}
+
+/*
+==============
+S_GetFileCode
+==============
+*/
+int S_GetFileCode( const char* sSoundName )
+{
+	char	sLoadName[MAX_QPATH];
+
+	// make up a local filename to try wav/mp3 substitutes...
+	//	
+	Q_strncpyz(sLoadName, sSoundName, sizeof(sLoadName));	
+	Q_strlwr( sLoadName );
+
+	// make sure we have an extension...
+	//
+	if (sLoadName[strlen(sLoadName) - 4] != '.')
+	{
+		strcat(sLoadName, ".xxx");
+	}
+
+	return S_LoadSound_FileNameAdjuster(sLoadName);
+}
+
+/*
+============
+S_UpdateLoading
+============
+*/
+void S_UpdateLoading(void) {
+	for ( int i = 0; i < SND_MAX_LOADS; ++i )
+	{
+		if ( s_LoadList[i] &&
+			(s_LoadList[i]->iFlags & SFX_FLAG_LOADING) &&
+			!Sys_StreamIsReading(s_LoadList[i]->iStreamHandle) )
+		{
+			S_EndLoadSound(s_LoadList[i]);
+			s_LoadList[i] = NULL;
+			--s_LoadListSize;
+		}
+	}
+}
+
+/*
+==============
+S_BeginLoadSound
+==============
+*/
+qboolean S_StartLoadSound( sfx_t *sfx )
+{
+	assert(sfx->iFlags & SFX_FLAG_UNLOADED);
+	sfx->iFlags &= ~SFX_FLAG_UNLOADED;
+	
+	// Valid file?
+	if (sfx->iFileCode == -1)
+	{
+		sfx->iFlags |= SFX_FLAG_RESIDENT | SFX_FLAG_DEFAULT;
+		return qfalse;
+	}
+
+	// Finish up any pending loads
+	do
+	{
+		S_UpdateLoading();
+	} 
+	while (s_LoadListSize >= SND_MAX_LOADS);
+
+	// Open the file
+	sfx->iSoundLength = Sys_StreamOpen(sfx->iFileCode, &sfx->iStreamHandle);
+	if ( sfx->iSoundLength <= 0 )
+	{
+		sfx->iFlags |= SFX_FLAG_RESIDENT | SFX_FLAG_DEFAULT;
+		return qfalse;
+	}
+
+#ifdef _GAMECUBE
+	// Allocate a buffer to read into...
+	sfx->pSoundData = Z_Malloc(sfx->iSoundLength + 64, TAG_SND_RAWDATA,
+			qtrue, 32);
+#else
+	// Allocate a buffer to read into...
+	sfx->pSoundData = Z_Malloc(sfx->iSoundLength, TAG_SND_RAWDATA, qtrue, 32);
+#endif
+
+	// Setup the background read
+	if ( !sfx->pSoundData || 
+			!Sys_StreamRead(sfx->pSoundData, sfx->iSoundLength, 0, 
+				sfx->iStreamHandle) )
+	{
+		if(sfx->pSoundData) {
+			Z_Free(sfx->pSoundData);
+		}
+		Sys_StreamClose(sfx->iStreamHandle);
+		sfx->iFlags |= SFX_FLAG_RESIDENT | SFX_FLAG_DEFAULT;
+		return qfalse;
+	}
+	sfx->iFlags |= SFX_FLAG_LOADING;
+
+	// add sound to load list
+	for (int i = 0; i < SND_MAX_LOADS; ++i)
+	{
+		if (!s_LoadList[i])
+		{
+			s_LoadList[i] = sfx;
+			++s_LoadListSize;
+			break;
+		}
+	}
+
+	return qtrue;
+}
+
+/*
+==============
+S_EndLoadSound
+==============
+*/
+qboolean S_EndLoadSound( sfx_t *sfx )
+{
+	wavinfo_t	info;
+	byte*		data;
+	ALuint		Buffer;
+
+	assert(sfx->iFlags & SFX_FLAG_LOADING);
+	sfx->iFlags &= ~SFX_FLAG_LOADING;
+
+	// was the read successful?
+	if (Sys_StreamIsError(sfx->iStreamHandle))
+	{
+#if defined(FINAL_BUILD)
+		/*
+		extern void ERR_DiscFail(bool);
+		ERR_DiscFail(false);
+		*/
+#endif
+		Sys_StreamClose(sfx->iStreamHandle);
+		Z_Free(sfx->pSoundData);
+		sfx->iFlags |= SFX_FLAG_RESIDENT | SFX_FLAG_DEFAULT;
+		return qfalse;
+	}
+
+	Sys_StreamClose(sfx->iStreamHandle);
+	SND_TouchSFX(sfx);
+
+	sfx->iLastTimeUsed = Com_Milliseconds()+1;	// why +1? Hmmm, leave it for now I guess	
+
+	// loading a WAV, presumably...
+	data = (byte*)sfx->pSoundData;
+	info = GetWavInfo( data );
+
+	if (info.size == 0)
+	{
+		Z_Free(sfx->pSoundData);
+		sfx->iFlags |= SFX_FLAG_RESIDENT | SFX_FLAG_DEFAULT;
+		return qfalse;
+	}
+	
+	sfx->iSoundLength = info.size;
+
+	// make sure we have enough space for the sound
+	SND_update(sfx);
+
+	// Clear Open AL Error State
+	alGetError();
+
+	// Generate AL Buffer
+	alGenBuffers(1, &Buffer);
+
+	// Copy audio data to AL Buffer
+	alBufferData(Buffer, info.format, data, 
+		sfx->iSoundLength, info.rate);
+	if (alGetError() != AL_NO_ERROR)
+	{
+		Z_Free(sfx->pSoundData);
+		sfx->iFlags |= SFX_FLAG_UNLOADED;
+		return qfalse;
+	}
+	
+	sfx->Buffer = Buffer;
+
+#ifdef _GAMECUBE
+	Z_Free(sfx->pSoundData);
+#endif
+	sfx->iFlags |= SFX_FLAG_RESIDENT;
+
+	return qtrue;
+}
+
+/*
+============
+S_InitLoad
+============
+*/
+void S_InitLoad(void) {
+	s_LoadList = new sfx_t*[SND_MAX_LOADS];
+	memset(s_LoadList, 0, SND_MAX_LOADS * sizeof(sfx_t*));
+	s_LoadListSize = 0;
+}
+
+/*
+============
+S_CloseLoad
+============
+*/
+void S_CloseLoad(void) {
+	delete [] s_LoadList;
+}
diff --git a/code/client/snd_mix.cpp b/code/client/snd_mix.cpp
new file mode 100644
index 0000000..d1846c8
--- /dev/null
+++ b/code/client/snd_mix.cpp
@@ -0,0 +1,471 @@
+// snd_mix.c -- portable code to mix sounds for snd_dma.c
+
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+
+
+#include "snd_local.h"
+
+portable_samplepair_t paintbuffer[PAINTBUFFER_SIZE];
+int 	*snd_p, snd_linear_count, snd_vol;
+short	*snd_out;
+
+
+
+
+#if !(defined __linux__ && defined __i386__)
+#if	!id386
+
+
+void S_WriteLinearBlastStereo16 (void)
+{
+	int		i;
+	int		val;
+
+	for (i=0 ; i<snd_linear_count ; i+=2)
+	{
+		val = snd_p[i]>>8;
+		if (val > 0x7fff)
+			snd_out[i] = 0x7fff;
+		else if (val < (short)0x8000)
+			snd_out[i] = (short)0x8000;
+		else
+			snd_out[i] = val;
+
+		val = snd_p[i+1]>>8;
+		if (val > 0x7fff)
+			snd_out[i+1] = 0x7fff;
+		else if (val < (short)0x8000)
+			snd_out[i+1] = (short)0x8000;
+		else
+			snd_out[i+1] = val;
+	}
+}
+#else
+unsigned int uiMMXAvailable = 0;	// leave as 32 bit
+__declspec( naked ) void S_WriteLinearBlastStereo16 (void)
+{
+	__asm {
+
+ push edi
+ push ebx
+
+ mov ecx,ds:dword ptr[snd_linear_count]		// snd_linear_count is always even at this point, but not nec. mult of 4
+ mov ebx,ds:dword ptr[snd_p]
+ mov edi,ds:dword ptr[snd_out]
+
+ cmp		[uiMMXAvailable], dword ptr 0 
+ je			NoMMX
+
+// writes 8 items (128 bits) per loop pass...
+//   
+ cmp		ecx,8
+ jb			NoMMX	 
+
+LWLBLoopTop_MMX:
+
+ movq		mm1,[-8+ebx+ecx*4]
+ movq		mm0,[-16+ebx+ecx*4]
+ movq		mm3,[-24+ebx+ecx*4]
+ movq		mm2,[-32+ebx+ecx*4]
+ psrad		mm0,8
+ psrad		mm1,8
+ psrad		mm2,8
+ psrad		mm3,8
+ packssdw	mm0,mm1
+ packssdw	mm2,mm3
+ movq		[-8+edi+ecx*2],mm0
+ movq		[-16+edi+ecx*2],mm2
+ 
+ sub		ecx,8
+ cmp		ecx,8
+ jae		LWLBLoopTop_MMX
+
+ emms
+		
+ // now deal with any remaining count...
+ //
+ jecxz		LExit
+
+NoMMX:  
+ 
+// writes 2 items (32 bits) per loop pass...
+//
+LWLBLoopTop:
+ mov eax,ds:dword ptr[-8+ebx+ecx*4]
+ sar eax,8
+ cmp eax,07FFFh
+ jg LClampHigh
+ cmp eax,0FFFF8000h
+ jnl LClampDone
+ mov eax,0FFFF8000h
+ jmp LClampDone
+LClampHigh:
+ mov eax,07FFFh
+LClampDone:
+ mov edx,ds:dword ptr[-4+ebx+ecx*4]
+ sar edx,8
+ cmp edx,07FFFh
+ jg LClampHigh2
+ cmp edx,0FFFF8000h
+ jnl LClampDone2
+ mov edx,0FFFF8000h
+ jmp LClampDone2
+LClampHigh2:
+ mov edx,07FFFh
+LClampDone2:
+ shl edx,16
+ and eax,0FFFFh
+ or edx,eax
+ mov ds:dword ptr[-4+edi+ecx*2],edx
+
+ sub ecx,2
+ jnz LWLBLoopTop
+
+LExit:
+ pop ebx
+ pop edi
+ ret
+	}
+}
+
+#endif
+#endif
+
+
+void S_TransferStereo16 (unsigned long *pbuf, int endtime)
+{
+	int		lpos;
+	int		ls_paintedtime;
+	
+	snd_p = (int *) paintbuffer;
+	ls_paintedtime = s_paintedtime;
+
+	while (ls_paintedtime < endtime)
+	{
+	// handle recirculating buffer issues
+		lpos = ls_paintedtime & ((dma.samples>>1)-1);
+
+		snd_out = (short *) pbuf + (lpos<<1);
+
+		snd_linear_count = (dma.samples>>1) - lpos;
+		if (ls_paintedtime + snd_linear_count > endtime)
+			snd_linear_count = endtime - ls_paintedtime;
+
+		snd_linear_count <<= 1;
+
+	// write a linear blast of samples
+		S_WriteLinearBlastStereo16 ();
+
+		snd_p += snd_linear_count;
+		ls_paintedtime += (snd_linear_count>>1);
+	}
+}
+
+/*
+===================
+S_TransferPaintBuffer
+
+===================
+*/
+void S_TransferPaintBuffer(int endtime)
+{
+	int 	out_idx;
+	int 	count;
+	int 	out_mask;
+	int 	*p;
+	int 	step;
+	int		val;
+	unsigned long *pbuf;
+
+	pbuf = (unsigned long *)dma.buffer;
+
+
+	if ( s_testsound->integer ) {
+		int		i;
+		int		count;
+
+		// write a fixed sine wave
+		count = (endtime - s_paintedtime);
+		for (i=0 ; i<count ; i++)
+			paintbuffer[i].left = paintbuffer[i].right = (int)(sin((s_paintedtime+i)*0.1)*20000*256);
+	}
+
+
+	if (dma.samplebits == 16 && dma.channels == 2)
+	{	// optimized case
+		S_TransferStereo16 (pbuf, endtime);
+	}
+	else
+	{	// general case
+		p = (int *) paintbuffer;
+		count = (endtime - s_paintedtime) * dma.channels;
+		out_mask = dma.samples - 1; 
+		out_idx = s_paintedtime * dma.channels & out_mask;
+		step = 3 - dma.channels;
+
+		if (dma.samplebits == 16)
+		{
+			short *out = (short *) pbuf;
+			while (count--)
+			{
+				val = *p >> 8;
+				p+= step;
+				if (val > 0x7fff)
+					val = 0x7fff;
+				else if (val < (short)0x8000)
+					val = (short)0x8000;
+				out[out_idx] = (short)val;
+				out_idx = (out_idx + 1) & out_mask;
+			}
+		}
+		else if (dma.samplebits == 8)
+		{
+			unsigned char *out = (unsigned char *) pbuf;
+			while (count--)
+			{
+				val = *p >> 8;
+				p+= step;
+				if (val > 0x7fff)
+					val = 0x7fff;
+				else if (val < (short)0x8000)
+					val = (short)0x8000;
+				out[out_idx] = (short)((val>>8) + 128);
+				out_idx = (out_idx + 1) & out_mask;
+			}
+		}
+	}
+}
+
+
+/*
+===============================================================================
+
+CHANNEL MIXING
+
+===============================================================================
+*/
+static void S_PaintChannelFrom16( channel_t *ch, const sfx_t *sfx, int count, int sampleOffset, int bufferOffset ) 
+{
+	portable_samplepair_t	*pSamplesDest;	
+	int iData;
+
+
+	int iLeftVol	= ch->leftvol  * snd_vol;
+	int iRightVol	= ch->rightvol * snd_vol;
+
+	pSamplesDest	= &paintbuffer[ bufferOffset ];
+	
+	for ( int i=0 ; i<count ; i++ ) 
+	{
+		iData = sfx->pSoundData[ sampleOffset++ ];
+
+		pSamplesDest[i].left  += (iData * iLeftVol )>>8;
+		pSamplesDest[i].right += (iData * iRightVol)>>8;
+	}
+}
+
+
+void S_PaintChannelFromMP3( channel_t *ch, const sfx_t *sc, int count, int sampleOffset, int bufferOffset ) 
+{
+	int data;
+	int leftvol, rightvol;
+	signed short *sfx;
+	int	i;
+	portable_samplepair_t	*samp;
+	static short tempMP3Buffer[PAINTBUFFER_SIZE];
+
+	MP3Stream_GetSamples( ch, sampleOffset, count, tempMP3Buffer, qfalse );	// qfalse = not stereo
+
+	leftvol = ch->leftvol*snd_vol;
+	rightvol = ch->rightvol*snd_vol;
+	sfx = tempMP3Buffer;
+
+	samp = &paintbuffer[ bufferOffset ];
+
+
+	while ( count & 3 ) {
+		data = *sfx;
+		samp->left += (data * leftvol)>>8;
+		samp->right += (data * rightvol)>>8;
+
+		sfx++;
+		samp++;
+		count--;
+	}
+
+	for ( i=0 ; i<count ; i += 4 ) {
+		data = sfx[i];
+		samp[i].left += (data * leftvol)>>8;
+		samp[i].right += (data * rightvol)>>8;
+
+		data = sfx[i+1];
+		samp[i+1].left += (data * leftvol)>>8;
+		samp[i+1].right += (data * rightvol)>>8;
+
+		data = sfx[i+2];
+		samp[i+2].left += (data * leftvol)>>8;
+		samp[i+2].right += (data * rightvol)>>8;
+
+		data = sfx[i+3];
+		samp[i+3].left += (data * leftvol)>>8;
+		samp[i+3].right += (data * rightvol)>>8;
+	}
+}
+
+
+// subroutinised to save code dup (called twice)	-ste
+//
+void ChannelPaint(channel_t *ch, sfx_t *sc, int count, int sampleOffset, int bufferOffset)
+{
+	switch (sc->eSoundCompressionMethod)
+	{
+		case ct_16:		
+			
+			S_PaintChannelFrom16		(ch, sc, count, sampleOffset, bufferOffset);
+			break;
+
+		case ct_MP3:
+
+			S_PaintChannelFromMP3		(ch, sc, count, sampleOffset, bufferOffset);
+			break;
+
+		default:
+
+			assert(0);	// debug aid, ignored in release. FIXME: Should we ERR_DROP here for badness-catch?
+			break;
+	}
+}
+
+
+
+void S_PaintChannels( int endtime ) {
+	int 	i;
+	int 	end;
+	channel_t *ch;
+	sfx_t	*sc;
+	int		ltime, count;
+	int		sampleOffset;
+	int	normal_vol,voice_vol;
+
+	snd_vol = normal_vol = s_volume->value*256.0f;
+	voice_vol  = (s_volumeVoice->value*256.0f);
+
+//Com_Printf ("%i to %i\n", s_paintedtime, endtime);
+	while ( s_paintedtime < endtime ) {
+		// if paintbuffer is smaller than DMA buffer
+		// we may need to fill it multiple times
+		end = endtime;
+		if ( endtime - s_paintedtime > PAINTBUFFER_SIZE ) {
+			end = s_paintedtime + PAINTBUFFER_SIZE;
+		}
+
+		// clear the paint buffer to either music or zeros
+		if ( s_rawend < s_paintedtime ) {
+			if ( s_rawend ) {
+				//Com_DPrintf ("background sound underrun\n");
+			}
+			memset(paintbuffer, 0, (end - s_paintedtime) * sizeof(portable_samplepair_t));
+		} else {
+			// copy from the streaming sound source
+			int		s;
+			int		stop;
+
+			stop = (end < s_rawend) ? end : s_rawend;
+
+			for ( i = s_paintedtime ; i < stop ; i++ ) {
+				s = i&(MAX_RAW_SAMPLES-1);
+				paintbuffer[i-s_paintedtime] = s_rawsamples[s];
+			}
+//		if (i != end)
+//			Com_Printf ("partial stream\n");
+//		else
+//			Com_Printf ("full stream\n");
+			for ( ; i < end ; i++ ) {
+				paintbuffer[i-s_paintedtime].left =
+				paintbuffer[i-s_paintedtime].right = 0;
+			}
+		}
+
+		// paint in the channels.
+		ch = s_channels;
+		for ( i = 0; i < MAX_CHANNELS ; i++, ch++ ) {		
+			if ( !ch->thesfx || (ch->leftvol<0.25 && ch->rightvol<0.25 )) {
+				continue;
+			}
+
+			if ( ch->entchannel == CHAN_VOICE || ch->entchannel == CHAN_VOICE_ATTEN || ch->entchannel == CHAN_VOICE_GLOBAL )
+				snd_vol = voice_vol;
+			else
+				snd_vol = normal_vol;
+
+			ltime = s_paintedtime;
+			sc = ch->thesfx;
+
+			// we might have to make 2 passes if it is
+			//	a looping sound effect and the end of 
+			//	the sameple is hit...
+			//
+			do
+			{
+				if (ch->loopSound) {
+					sampleOffset = ltime % sc->iSoundLengthInSamples;
+				} else {
+					sampleOffset = ltime - ch->startSample;
+				}
+				
+				count = end - ltime;
+				if ( sampleOffset + count > sc->iSoundLengthInSamples ) {
+					count = sc->iSoundLengthInSamples - sampleOffset;
+				}
+
+				if ( count > 0 ) {
+					ChannelPaint(ch, sc, count, sampleOffset, ltime - s_paintedtime);
+					ltime += count;
+				}
+			} while ( ltime < end && ch->loopSound );
+		}
+/* temprem
+		// paint in the looped channels.
+		ch = loop_channels;
+		for ( i = 0; i < numLoopChannels ; i++, ch++ ) {		
+			if ( !ch->thesfx || (!ch->leftvol && !ch->rightvol )) {
+				continue;
+			}
+
+			{
+
+				ltime = s_paintedtime;
+				sc = ch->thesfx;
+
+				if (sc->soundData==NULL || sc->soundLength==0) {
+					continue;
+				}
+				// we might have to make two passes if it
+				// is a looping sound effect and the end of
+				// the sample is hit
+				do {
+					sampleOffset = (ltime % sc->soundLength);
+
+					count = end - ltime;
+					if ( sampleOffset + count > sc->soundLength ) {
+						count = sc->soundLength - sampleOffset;
+					}
+
+					if ( count > 0 ) 
+					{
+						ChannelPaint(ch, sc, count, sampleOffset, ltime - s_paintedtime);
+						ltime += count;
+					}
+
+				} while ( ltime < end);
+			}
+		}
+*/
+		// transfer out according to DMA format
+		S_TransferPaintBuffer( end );
+		s_paintedtime = end;
+	}
+}
diff --git a/code/client/snd_music.cpp b/code/client/snd_music.cpp
new file mode 100644
index 0000000..5cbc58d
--- /dev/null
+++ b/code/client/snd_music.cpp
@@ -0,0 +1,1155 @@
+// Filename:-	snd_music.cpp
+//
+//  Stuff to parse in special x-fade music format and handle blending etc
+
+//Anything above this #include will be ignored by the compiler
+#include "../server/exe_headers.h"
+
+
+#include "../qcommon/sstring.h"
+#include <algorithm>
+
+#ifdef _XBOX
+#include "snd_local_console.h"
+#include <xtl.h>
+#else
+#include "snd_local.h"
+#include "cl_mp3.h"
+#endif
+
+//
+#include "snd_music.h"
+
+extern qboolean S_FileExists( const char *psFilename );
+
+#ifdef _XBOX
+extern void Z_SetNewDeleteTemporary(bool bTemp);
+#endif
+
+#define sKEY_MUSICFILES	"musicfiles"
+#define sKEY_ENTRY		"entry"
+#define sKEY_EXIT		"exit"
+#define sKEY_MARKER		"marker"
+#define sKEY_TIME		"time"
+#define sKEY_NEXTFILE	"nextfile"
+#define sKEY_NEXTMARK	"nextmark"
+#define sKEY_LEVELMUSIC	"levelmusic"
+#define sKEY_EXPLORE	"explore"
+#define sKEY_ACTION		"action"
+#define sKEY_BOSS		"boss"
+#define sKEY_DEATH		"death"
+#define sKEY_USES		"uses"
+#define sKEY_USEBOSS	"useboss"
+
+#define sKEY_PLACEHOLDER "placeholder"	// ignore these
+
+#define sFILENAME_DMS	"ext_data/dms.dat"
+
+
+#define MUSIC_PARSE_ERROR(_string)		Music_Parse_Error(_string)	// only use during parse, not run-time use, and bear in mid that data is zapped after error message, so exit any loops immediately
+#define MUSIC_PARSE_WARNING(_string)	Music_Parse_Warning(_string)
+
+typedef struct
+{
+	sstring_t	sNextFile;
+	sstring_t	sNextMark;		// blank if used for an explore piece, name of marker point to enter new file at
+
+} MusicExitPoint_t;
+
+struct MusicExitTime_t	// need to declare this way for operator < below
+{
+	float		fTime;
+	int			iExitPoint;
+
+	// I'm defining this '<' operator so STL's sort algorithm will work
+	//
+	bool operator < (const MusicExitTime_t& _X) const {return (fTime < _X.fTime);}
+};
+
+// it's possible for all 3 of these to be empty if it's boss or death music
+//
+typedef vector	<MusicExitPoint_t>	MusicExitPoints_t;
+typedef vector	<MusicExitTime_t>	MusicExitTimes_t;
+typedef map		<sstring_t, float>	MusicEntryTimes_t;	// key eg "marker1"
+
+typedef struct
+{
+	sstring_t			sFileNameBase;
+	MusicEntryTimes_t	MusicEntryTimes;
+	MusicExitPoints_t	MusicExitPoints;
+	MusicExitTimes_t	MusicExitTimes;
+
+} MusicFile_t;
+
+typedef map <sstring_t, MusicFile_t>	MusicData_t;			// string is "explore", "action", "boss" etc
+										MusicData_t* MusicData = NULL;
+// there are now 2 of these, because of the new "uses" keyword...
+//
+sstring_t	gsLevelNameForLoad;		// eg "kejim_base", formed from literal BSP name, but also used as dir name for music paths
+sstring_t	gsLevelNameForCompare;	// eg "kejim_base", formed from literal BSP name, but also used as dir name for music paths
+sstring_t	gsLevelNameForBossLoad;	// eg "kejim_base', special case for enabling boss music to come from a different dir - sigh....
+
+void Music_Free(void)
+{
+#ifdef _XBOX
+	// Prevents pending state changes from crashing the game after
+	// level loads, but before new music data has been parsed.
+	extern void S_AvertMusicDisaster(void);
+	S_AvertMusicDisaster();
+#endif
+
+	if (MusicData)
+	{
+#ifdef _XBOX
+		delete MusicData;
+#else
+		MusicData->clear();
+#endif
+	}
+	MusicData = NULL;
+}
+
+// some sort of error in the music data...
+//
+static void Music_Parse_Error(LPCSTR psError)
+{
+	Com_Printf(S_COLOR_RED "Error parsing music data ( in \"%s\" ):\n%s\n",sFILENAME_DMS,psError);
+	MusicData->clear();
+}
+
+// something to just mention if interested...
+//
+static void Music_Parse_Warning(LPCSTR psError)
+{
+	extern cvar_t *s_debugdynamic;
+	if (s_debugdynamic && s_debugdynamic->integer)
+	{
+		Com_Printf(S_COLOR_YELLOW "%s", psError);
+	}	
+}
+
+// the 2nd param here is pretty kludgy (sigh), and only used for testing for the "boss" type.
+// Unfortunately two of the places that calls this doesn't have much other access to the state other than
+//	a string, not an enum, so for those cases they only pass in BOSS or EXPLORE, so don't rely on it totally.
+//
+static LPCSTR Music_BuildFileName(LPCSTR psFileNameBase, MusicState_e eMusicState )
+{
+	static sstring_t sFileName;
+
+	//HACK!
+	if (eMusicState == eBGRNDTRACK_DEATH)
+	{
+		return "music/death_music.mp3";
+	}
+
+	LPCSTR psDirName = (eMusicState == eBGRNDTRACK_BOSS) ? gsLevelNameForBossLoad.c_str() : gsLevelNameForLoad.c_str();	
+
+	sFileName = va("music/%s/%s.mp3",psDirName,psFileNameBase);
+	return sFileName.c_str();
+}
+
+// this MUST return NULL for non-base states unless doing debug-query
+const char *Music_BaseStateToString( MusicState_e eMusicState, qboolean bDebugPrintQuery /* = qfalse */ )
+{
+	switch (eMusicState)
+	{
+		case eBGRNDTRACK_EXPLORE:	return "explore";
+		case eBGRNDTRACK_ACTION:	return "action";
+		case eBGRNDTRACK_BOSS:		return "boss";
+		case eBGRNDTRACK_SILENCE:	return "silence";	// not used in this module, but snd_dma uses it now it's de-static'd
+		case eBGRNDTRACK_DEATH:		return "death";
+
+		// info only, not map<> lookup keys (unlike above)...
+		//
+		case eBGRNDTRACK_ACTIONTRANS0:		if (bDebugPrintQuery) return "action_tr0";
+		case eBGRNDTRACK_ACTIONTRANS1:		if (bDebugPrintQuery) return "action_tr1";
+		case eBGRNDTRACK_ACTIONTRANS2:		if (bDebugPrintQuery) return "action_tr2";
+		case eBGRNDTRACK_ACTIONTRANS3:		if (bDebugPrintQuery) return "action_tr3";
+		case eBGRNDTRACK_EXPLORETRANS0:		if (bDebugPrintQuery) return "explore_tr0";
+		case eBGRNDTRACK_EXPLORETRANS1:		if (bDebugPrintQuery) return "explore_tr1";
+		case eBGRNDTRACK_EXPLORETRANS2:		if (bDebugPrintQuery) return "explore_tr2";
+		case eBGRNDTRACK_EXPLORETRANS3:		if (bDebugPrintQuery) return "explore_tr3";
+		case eBGRNDTRACK_FADE:				if (bDebugPrintQuery) return "fade";
+	}
+
+	return NULL;
+}
+
+static qboolean Music_ParseMusic(CGenericParser2 &Parser, MusicData_t *MusicData, CGPGroup *pgMusicFiles, LPCSTR psMusicName, LPCSTR psMusicNameKey, MusicState_e eMusicState)
+{
+	qboolean bReturn = qfalse;
+
+#ifdef _XBOX
+	Z_SetNewDeleteTemporary(true);
+#endif
+	MusicFile_t MusicFile;
+#ifdef _XBOX
+	Z_SetNewDeleteTemporary(false);
+#endif
+
+	CGPGroup *pgMusicFile = pgMusicFiles->FindSubGroup(psMusicName);
+	if (pgMusicFile)
+	{
+		// read subgroups...  
+		//
+		qboolean bEntryFound = qfalse;
+		qboolean bExitFound  = qfalse;
+		//
+		// (read entry points first, so I can check exit points aren't too close in time)
+		//
+		CGPGroup *pEntryGroup = pgMusicFile->FindSubGroup(sKEY_ENTRY);
+		if (pEntryGroup)
+		{
+			// read entry points...
+			//
+			for (CGPValue *pValue = pEntryGroup->GetPairs(); pValue; pValue = pValue->GetNext())
+			{
+				LPCSTR psKey	= pValue->GetName();
+				LPCSTR psValue	= pValue->GetTopValue();
+
+				//if (!strncmp(psKey,sKEY_MARKER,strlen(sKEY_MARKER)))	// for now, assume anything is a marker
+				{
+					MusicFile.MusicEntryTimes[psKey] = atof(psValue);
+					bEntryFound = qtrue;						// harmless to keep setting
+				}
+			}
+		}
+
+		for (CGPGroup *pGroup = pgMusicFile->GetSubGroups(); pGroup; pGroup = pGroup->GetNext())
+		{
+			LPCSTR psGroupName = pGroup->GetName();
+
+			if (!strcmp(psGroupName,sKEY_ENTRY))
+			{
+				// skip entry points, I've already read them in above
+				//
+			}
+			else
+			if (!strcmp(psGroupName,sKEY_EXIT))
+			{
+				int iThisExitPointIndex = MusicFile.MusicExitPoints.size();	// must eval this first, so unaffected by push_back etc
+				//
+				// read this set of exit points...
+				//
+				MusicExitPoint_t MusicExitPoint;
+				for (CGPValue *pValue = pGroup->GetPairs(); pValue; pValue = pValue->GetNext())
+				{
+					LPCSTR psKey	= pValue->GetName();
+					LPCSTR psValue	= pValue->GetTopValue();
+
+					if (!strcmp(psKey,sKEY_NEXTFILE))
+					{
+						MusicExitPoint.sNextFile = psValue;
+						bExitFound  = qtrue;	// harmless to keep setting
+					}
+					else
+					if (!strcmp(psKey,sKEY_NEXTMARK))
+					{
+						MusicExitPoint.sNextMark = psValue;
+					}
+					else
+					if (!strncmp(psKey,sKEY_TIME,strlen(sKEY_TIME)))
+					{
+						MusicExitTime_t MusicExitTime;
+										MusicExitTime.fTime		= atof(psValue);
+										MusicExitTime.iExitPoint= iThisExitPointIndex;
+
+						// new check, don't keep this this exit point if it's within 1.5 seconds either way of an entry point...
+						//
+						qboolean bTooCloseToEntryPoint = qfalse;
+						for (MusicEntryTimes_t::iterator itEntryTimes = MusicFile.MusicEntryTimes.begin(); itEntryTimes != MusicFile.MusicEntryTimes.end(); ++itEntryTimes)
+						{
+							float fThisEntryTime = (*itEntryTimes).second;
+
+							if (Q_fabs(fThisEntryTime - MusicExitTime.fTime) < 1.5f)
+							{
+//								bTooCloseToEntryPoint = qtrue;	// not sure about this, ignore for now
+								break;
+							}
+						}
+						if (!bTooCloseToEntryPoint)
+						{
+#ifdef _XBOX
+							Z_SetNewDeleteTemporary(true);
+#endif
+							MusicFile.MusicExitTimes.push_back(MusicExitTime);
+#ifdef _XBOX
+							Z_SetNewDeleteTemporary(false);
+#endif
+						}
+					}
+				}
+
+#ifdef _XBOX
+				Z_SetNewDeleteTemporary(true);
+#endif
+				MusicFile.MusicExitPoints.push_back(MusicExitPoint);
+#ifdef _XBOX
+				Z_SetNewDeleteTemporary(false);
+#endif
+				int iNumExitPoints = MusicFile.MusicExitPoints.size();
+
+				// error checking...
+				//
+				switch (eMusicState)
+				{
+					case eBGRNDTRACK_EXPLORE:	
+						if (iNumExitPoints > iMAX_EXPLORE_TRANSITIONS)
+						{
+							MUSIC_PARSE_ERROR( va("\"%s\" has > %d %s transitions defined!\n",psMusicName,iMAX_EXPLORE_TRANSITIONS,psMusicNameKey) );
+							return qfalse;
+						}
+						break;
+
+					case eBGRNDTRACK_ACTION:
+						if (iNumExitPoints > iMAX_ACTION_TRANSITIONS)
+						{
+							MUSIC_PARSE_ERROR( va("\"%s\" has > %d %s transitions defined!\n",psMusicName,iMAX_ACTION_TRANSITIONS,psMusicNameKey) );
+							return qfalse;
+						}
+						break;
+
+					case eBGRNDTRACK_BOSS:
+					case eBGRNDTRACK_DEATH:
+
+						MUSIC_PARSE_ERROR( va("\"%s\" has %s transitions defined, this is not allowed!\n",psMusicName,psMusicNameKey) );
+						break;					
+				}
+			}
+		}
+
+		// for now, assume everything was ok unless some obvious things are missing...
+		//
+		bReturn = qtrue;
+
+		if (eMusicState != eBGRNDTRACK_BOSS && eMusicState != eBGRNDTRACK_DEATH)	// boss & death pieces can omit entry/exit stuff
+		{
+			if (!bEntryFound)
+			{
+				MUSIC_PARSE_ERROR(va("Unable to find subgroup \"%s\" in group \"%s\"\n",sKEY_ENTRY,psMusicName));
+				bReturn = qfalse;
+			}
+			if (!bExitFound)
+			{
+				MUSIC_PARSE_ERROR(va("Unable to find subgroup \"%s\" in group \"%s\"\n",sKEY_EXIT,psMusicName));
+				bReturn = qfalse;
+			}
+		}
+	}
+	else
+	{
+		MUSIC_PARSE_ERROR(va("Unable to find musicfiles entry \"%s\"\n",psMusicName));
+	}
+
+	if (bReturn)
+	{
+		MusicFile.sFileNameBase  = psMusicName; 
+		(*MusicData)[ psMusicNameKey ] = MusicFile;
+	}
+
+	return bReturn;
+}
+
+
+
+
+// I only need this because GP2 can't cope with trailing whitespace (for !@#$%^'s sake!!!!)...
+//
+// (output buffer will always be just '\n' seperated, regardless of possible "\r\n" pairs)
+//
+// (remember to Z_Free() the returned char * when done with it!!!)
+//
+static char *StripTrailingWhiteSpaceOnEveryLine(char *pText)
+{
+#ifdef _XBOX
+	Z_SetNewDeleteTemporary(true);
+#endif
+	string strNewText;
+
+	while (*pText)
+	{
+		char sOneLine[1024];	// BTO: was 16k
+
+		// find end of line...
+		//				
+		char *pThisLineEnd = pText;
+		while (*pThisLineEnd && *pThisLineEnd != '\r' && ((pThisLineEnd-pText) < sizeof(sOneLine)-1))
+		{
+			pThisLineEnd++;
+		}	
+
+		int iCharsToCopy = pThisLineEnd - pText;
+		strncpy(sOneLine, pText, iCharsToCopy);
+				sOneLine[iCharsToCopy]='\0';
+		pText += iCharsToCopy;
+		while (*pText == '\n' || *pText == '\r') pText++;
+
+		// trim trailing...
+		//
+		qboolean bTrimmed = qfalse;
+		do
+		{
+			bTrimmed = qfalse;
+			int iStrLen = strlen(sOneLine);
+
+			if (iStrLen)
+			{
+				if (sOneLine[iStrLen-1] == '\t' || sOneLine[iStrLen-1] == ' ')
+				{
+					sOneLine[iStrLen-1] = '\0';
+					bTrimmed = qtrue;
+				}
+			}
+		}
+		while (bTrimmed);
+		
+		strNewText += sOneLine;
+		strNewText += "\n";
+	}
+
+	char  *pNewText = (char *) Z_Malloc( strlen(strNewText.c_str())+1,
+								TAG_TEMP_WORKSPACE,
+								qfalse);
+	strcpy(pNewText, strNewText.c_str());
+#ifdef _XBOX
+	Z_SetNewDeleteTemporary(false);
+#endif
+	return pNewText;
+}
+
+
+// called from SV_SpawnServer, but before map load and music start etc.
+//
+// This just initialises the Lucas music structs so the background music player can interrogate them...
+//
+sstring_t gsLevelNameFromServer;
+void Music_SetLevelName(const char *psLevelName)
+{	
+	gsLevelNameFromServer = psLevelName;	
+}
+
+static qboolean Music_ParseLeveldata(const char *psLevelName)
+{
+	qboolean bReturn = qfalse;
+
+	if (MusicData == NULL)
+	{
+#ifdef _XBOX
+		MusicData = new MusicData_t;
+#else
+		// sorry vv, false leaks make it hard to find true leaks
+		static MusicData_t singleton;
+		MusicData = &singleton;
+#endif
+	}
+	
+	// already got this data?
+	//
+	if (MusicData->size() && !Q_stricmp(psLevelName,gsLevelNameForCompare.c_str()))
+	{
+		return qtrue;
+	}
+	
+	MusicData->clear();	
+
+	char sLevelName[MAX_QPATH];
+	Q_strncpyz(sLevelName,psLevelName,sizeof(sLevelName));
+	
+	gsLevelNameForLoad		= sLevelName;	// harmless to init here even if we fail to parse dms.dat file	
+	gsLevelNameForCompare	= sLevelName;	// harmless to init here even if we fail to parse dms.dat file	
+	gsLevelNameForBossLoad	= sLevelName;	// harmless to init here even if we fail to parse dms.dat file	
+
+	char *pText = NULL;
+	/*int iTotalBytesLoaded = */FS_ReadFile(sFILENAME_DMS, (void **)&pText );			
+	if (pText) 
+	{
+		char *psStrippedText = StripTrailingWhiteSpaceOnEveryLine(pText);		
+		CGenericParser2 Parser;
+		char *psDataPtr = psStrippedText;	// because ptr gets advanced, so we supply a clone that GP can alter
+		if (Parser.Parse(&psDataPtr, true))
+		{
+			CGPGroup *pFileGroup = Parser.GetBaseParseGroup();
+			if (pFileGroup)
+			{
+				CGPGroup *pgMusicFiles = pFileGroup->FindSubGroup(sKEY_MUSICFILES);
+				if (pgMusicFiles)
+				{
+					CGPGroup *pgLevelMusic = pFileGroup->FindSubGroup(sKEY_LEVELMUSIC);
+
+					if (pgLevelMusic)
+					{
+						CGPGroup *pgThisLevelMusic = NULL;
+						//
+						// check for new USE keyword...
+						//
+						int iSanityLimit = 0;
+						sstring_t sSearchName(sLevelName);
+
+						while (sSearchName.c_str()[0] && iSanityLimit < 10)
+						{
+							gsLevelNameForLoad		= sSearchName;
+							gsLevelNameForBossLoad	= sSearchName;
+							pgThisLevelMusic = pgLevelMusic->FindSubGroup(sSearchName.c_str());
+
+							if (pgThisLevelMusic)
+							{
+								CGPValue *pValue = pgThisLevelMusic->FindPair(sKEY_USES);
+								if (pValue)
+								{
+									// re-search using the USE param...
+									//									
+									sSearchName = pValue->GetTopValue();
+									iSanityLimit++;
+//									Com_DPrintf("Using \"%s\"\n",sSearchName.c_str());
+								}
+								else
+								{
+									// no new USE keyword found...
+									//
+									sSearchName = "";
+								}
+							}
+							else
+							{
+								// level entry not found...
+								//
+								break;
+							}
+						}
+
+						// now go ahead and use the final music set we've decided on...
+						//
+						if (pgThisLevelMusic && iSanityLimit < 10)
+						{
+							// these are optional fields, so see which ones we find...
+							//
+							LPCSTR psName_Explore = NULL;
+							LPCSTR psName_Action  = NULL;
+							LPCSTR psName_Boss	  = NULL;
+							LPCSTR psName_Death	  = NULL;
+							//
+							LPCSTR psName_UseBoss = NULL;
+
+							for (CGPValue *pValue = pgThisLevelMusic->GetPairs(); pValue; pValue = pValue->GetNext())
+							{
+								LPCSTR psKey	= pValue->GetName();
+								LPCSTR psValue	= pValue->GetTopValue();								
+
+								if (Q_stricmp(psValue,sKEY_PLACEHOLDER))	// ignore "placeholder" items
+								{
+									if (!Q_stricmp(psKey,sKEY_EXPLORE))
+									{
+										psName_Explore = psValue;
+									}
+									else
+									if (!Q_stricmp(psKey,sKEY_ACTION))
+									{
+										psName_Action  = psValue;
+									}
+									else
+									if (!Q_stricmp(psKey,sKEY_USEBOSS))
+									{
+										psName_UseBoss = psValue;
+									}
+									else
+									if (!Q_stricmp(psKey,sKEY_BOSS))
+									{
+										psName_Boss = psValue;
+									}
+									else
+									if (!Q_stricmp(psKey,sKEY_DEATH))
+									{
+										psName_Death = psValue;
+									}
+								}
+							}
+									
+							bReturn = qtrue;	// defualt to ON now, so I can turn it off if "useboss" fails
+
+							if (psName_UseBoss)
+							{
+								CGPGroup *pgLevelMusicOfBoss = pgLevelMusic->FindSubGroup(psName_UseBoss);
+								if (pgLevelMusicOfBoss)
+								{
+									CGPValue *pValueBoss = pgLevelMusicOfBoss->FindPair(sKEY_BOSS);
+									if (pValueBoss)
+									{	
+										psName_Boss = pValueBoss->GetTopValue();
+										gsLevelNameForBossLoad = psName_UseBoss;
+									}
+									else
+									{
+										MUSIC_PARSE_ERROR(va("'useboss' \"%s\" has no \"boss\" entry!\n",psName_UseBoss));
+										bReturn = qfalse;
+									}
+								}
+								else
+								{
+									MUSIC_PARSE_ERROR(va("Unable to find 'useboss' entry \"%s\"\n",psName_UseBoss));									
+									bReturn = qfalse;
+								}
+							}
+
+
+							// done this way in case I want to conditionally pass any bools depending on music type...
+							//
+							if (bReturn && psName_Explore)
+							{
+								bReturn = Music_ParseMusic(Parser, MusicData, pgMusicFiles, psName_Explore,	sKEY_EXPLORE, eBGRNDTRACK_EXPLORE);
+							}
+							if (bReturn && psName_Action)
+							{
+								bReturn = Music_ParseMusic(Parser, MusicData, pgMusicFiles, psName_Action,	sKEY_ACTION,  eBGRNDTRACK_ACTION);
+							}
+							if (bReturn && psName_Boss)
+							{
+								bReturn = Music_ParseMusic(Parser, MusicData, pgMusicFiles, psName_Boss,	sKEY_BOSS,    eBGRNDTRACK_BOSS);
+							}
+							if (bReturn /*&& psName_Death*/)	// LAST MINUTE HACK!!, always force in some death music!!!!
+							{
+								//bReturn = Music_ParseMusic(Parser, MusicData, pgMusicFiles, psName_Death,	sKEY_DEATH,   eBGRNDTRACK_DEATH);
+
+								MusicFile_t m;
+											m.sFileNameBase = "death_music";
+								(*MusicData)[ sKEY_DEATH ] = m;
+							}
+						}
+						else
+						{
+							MUSIC_PARSE_WARNING(va("Unable to find entry for \"%s\" in \"%s\"\n",sLevelName,sFILENAME_DMS));
+						}
+					}
+					else
+					{
+						MUSIC_PARSE_ERROR(va("Unable to find subgroup \"%s\"\n",sKEY_LEVELMUSIC));
+					}
+				}
+				else
+				{
+					MUSIC_PARSE_ERROR(va("Unable to find subgroup \"%s\"\n",sKEY_MUSICFILES));
+				}
+			}
+			else
+			{
+				MUSIC_PARSE_ERROR( "Error calling GP2.GetBaseParseGroup()\n" );
+			}
+		}
+		else
+		{
+			MUSIC_PARSE_ERROR( "Error using GP to parse file\n" );
+		}
+
+		Z_Free(psStrippedText);
+		FS_FreeFile( pText );
+	}
+	else
+	{
+		MUSIC_PARSE_ERROR( "Unable to even read main file\n" );	// file name specified in error message
+	}
+
+	if (bReturn)
+	{
+		// sort exit points, and do some error checking...
+		//
+		for (MusicData_t::iterator itMusicData = MusicData->begin(); itMusicData != MusicData->end(); ++itMusicData)
+		{
+			LPCSTR psMusicStateType	= (*itMusicData).first.c_str();
+			MusicFile_t &MusicFile	= (*itMusicData).second;
+
+			// kludge up an enum, only interested in boss or not at the moment, so...
+			//
+			MusicState_e eMusicState = !stricmp(psMusicStateType,"boss") ? eBGRNDTRACK_BOSS : !stricmp(psMusicStateType,"death") ? eBGRNDTRACK_DEATH : eBGRNDTRACK_EXPLORE;
+
+			if (!MusicFile.MusicExitTimes.empty())
+			{
+				sort(MusicFile.MusicExitTimes.begin(),MusicFile.MusicExitTimes.end());
+			}
+
+			// check music exists...
+			//
+			LPCSTR psMusicFileName = Music_BuildFileName( MusicFile.sFileNameBase.c_str(), eMusicState );
+			if (!S_FileExists( psMusicFileName ))
+			{
+				MUSIC_PARSE_ERROR(va("Music file \"%s\" not found!\n",psMusicFileName));
+				return qfalse;		// have to return, because music data destroyed now
+			}
+
+			// check all transition music pieces exist, and that entry points into new pieces after transitions also exist...
+			//
+			for (int iExitPoint=0; iExitPoint < MusicFile.MusicExitPoints.size(); iExitPoint++)
+			{
+				MusicExitPoint_t &MusicExitPoint = MusicFile.MusicExitPoints[ iExitPoint ];
+
+				LPCSTR psTransitionFileName = Music_BuildFileName( MusicExitPoint.sNextFile.c_str(), eMusicState );
+				if (!S_FileExists( psTransitionFileName ))
+				{
+					MUSIC_PARSE_ERROR(va("Transition file \"%s\" (entry \"%s\" ) not found!\n",psTransitionFileName, MusicExitPoint.sNextFile.c_str()));
+					return qfalse;		// have to return, because music data destroyed now
+				}
+
+				LPCSTR psNextMark = MusicExitPoint.sNextMark.c_str();
+				if (strlen(psNextMark))	// always NZ ptr
+				{
+					// then this must be "action" music under current rules...
+					//					
+					assert( !strcmp(psMusicStateType, Music_BaseStateToString(eBGRNDTRACK_ACTION) ? Music_BaseStateToString(eBGRNDTRACK_ACTION):"") );
+					//
+					// does this marker exist in the explore piece?
+					//					
+					MusicData_t::iterator itExploreMusicData = MusicData->find( Music_BaseStateToString(eBGRNDTRACK_EXPLORE) );
+					if (itExploreMusicData != MusicData->end())
+					{
+						MusicFile_t &MusicFile_Explore = (*itExploreMusicData).second;
+
+						if (!MusicFile_Explore.MusicEntryTimes.count(psNextMark))
+						{
+							MUSIC_PARSE_ERROR( va("Unable to find entry point \"%s\" in description for \"%s\"\n",psNextMark,MusicFile_Explore.sFileNameBase.c_str()) );
+							return qfalse;		// have to return, because music data destroyed now
+						}
+					}
+					else
+					{
+						MUSIC_PARSE_ERROR( va("Unable to find %s piece to match \"%s\"\n", Music_BaseStateToString(eBGRNDTRACK_EXPLORE), MusicFile.sFileNameBase.c_str() ) );
+						return qfalse;		// have to return, because music data destroyed now
+					}
+				}
+			}
+		}
+	}
+	
+#ifdef _DEBUG
+/*
+	// dump the whole thing out to prove it was read in ok...
+	//
+	if (bReturn)
+	{
+		for (MusicData_t::iterator itMusicData = MusicData->begin(); itMusicData != MusicData->end(); ++itMusicData)
+		{
+			LPCSTR psMusicState		= (*itMusicData).first.c_str();
+			MusicFile_t &MusicFile	= (*itMusicData).second;
+
+			OutputDebugString(va("Music State:  \"%s\",  File: \"%s\"\n",psMusicState, MusicFile.sFileNameBase.c_str()));
+
+			// entry times...
+			//
+			for (MusicEntryTimes_t::iterator itEntryTimes = MusicFile.MusicEntryTimes.begin(); itEntryTimes != MusicFile.MusicEntryTimes.end(); ++itEntryTimes)
+			{
+				LPCSTR	psMarkerName	= (*itEntryTimes).first.c_str();
+				float	fEntryTime		= (*itEntryTimes).second;
+
+				OutputDebugString(va("Entry time for \"%s\": %f\n", psMarkerName, fEntryTime));
+			}
+
+			// exit points...
+			//
+			for (int i=0; i<MusicFile.MusicExitPoints.size(); i++)
+			{
+				MusicExitPoint_t &MusicExitPoint = MusicFile.MusicExitPoints[i];
+
+				OutputDebugString(va("Exit point %d:	sNextFile: \"%s\", sNextMark: \"%s\"\n",i,MusicExitPoint.sNextFile.c_str(),MusicExitPoint.sNextMark.c_str()));
+			}
+
+			// exit times...
+			//
+			for (i=0; i<MusicFile.MusicExitTimes.size(); i++)
+			{
+				MusicExitTime_t &MusicExitTime = MusicFile.MusicExitTimes[i];
+				
+				OutputDebugString(va("Exit time %d:		fTime: %f, iExitPoint: %d\n",i,MusicExitTime.fTime,MusicExitTime.iExitPoint));
+			}
+		}
+	}
+*/
+#endif
+
+	return bReturn;
+}
+
+
+// returns ptr to music file, or NULL for error/missing...
+//
+static MusicFile_t *Music_GetBaseMusicFile( LPCSTR psMusicState )	// where psMusicState is (eg) "explore", "action" or "boss"
+{
+	MusicData_t::iterator it = MusicData->find( psMusicState );
+	if (it != MusicData->end())
+	{
+		MusicFile_t *pMusicFile = &(*it).second;
+		return pMusicFile;
+	}
+
+	return NULL;
+}
+
+static MusicFile_t *Music_GetBaseMusicFile( MusicState_e eMusicState )
+{
+	LPCSTR	psMusicStateString = Music_BaseStateToString( eMusicState );
+	if ( psMusicStateString )
+	{
+		return Music_GetBaseMusicFile( psMusicStateString );
+	}
+
+	return NULL;
+}
+
+
+// where label is (eg) "kejim_base"...
+//
+qboolean Music_DynamicDataAvailable(const char *psDynamicMusicLabel)
+{		
+	char sLevelName[MAX_QPATH];
+	Q_strncpyz(sLevelName,COM_SkipPath( const_cast<char*>( (psDynamicMusicLabel&&psDynamicMusicLabel[0])?psDynamicMusicLabel:gsLevelNameFromServer.c_str() ) ),sizeof(sLevelName));
+	strlwr(sLevelName);
+
+	if (strlen(sLevelName))	// avoid error messages when there's no music waiting to be played and we try and restart it...
+	{
+		if (Music_ParseLeveldata(sLevelName))
+		{
+			return !!(	Music_GetBaseMusicFile( eBGRNDTRACK_EXPLORE ) &&
+						Music_GetBaseMusicFile(	eBGRNDTRACK_ACTION	)
+						);
+		}
+	}
+
+	return qfalse;
+}
+
+LPCSTR Music_GetFileNameForState( MusicState_e eMusicState)
+{
+	MusicFile_t *pMusicFile = NULL;
+	switch (eMusicState)
+	{
+		case eBGRNDTRACK_EXPLORE:
+		case eBGRNDTRACK_ACTION:
+		case eBGRNDTRACK_BOSS:
+		case eBGRNDTRACK_DEATH:
+
+			pMusicFile = Music_GetBaseMusicFile( eMusicState );
+			if (pMusicFile)
+			{
+				return Music_BuildFileName( pMusicFile->sFileNameBase.c_str(), eMusicState );
+			}
+			break;
+
+		case eBGRNDTRACK_ACTIONTRANS0:
+		case eBGRNDTRACK_ACTIONTRANS1:
+		case eBGRNDTRACK_ACTIONTRANS2:
+		case eBGRNDTRACK_ACTIONTRANS3:
+
+			pMusicFile = Music_GetBaseMusicFile( eBGRNDTRACK_ACTION );
+			if (pMusicFile)
+			{
+				int iTransNum = eMusicState - eBGRNDTRACK_ACTIONTRANS0;
+				if (iTransNum < pMusicFile->MusicExitPoints.size())
+				{
+					return Music_BuildFileName( pMusicFile->MusicExitPoints[iTransNum].sNextFile.c_str(), eMusicState );
+				}
+			}
+			break;
+
+		case eBGRNDTRACK_EXPLORETRANS0:
+		case eBGRNDTRACK_EXPLORETRANS1:
+		case eBGRNDTRACK_EXPLORETRANS2:
+		case eBGRNDTRACK_EXPLORETRANS3:
+
+			pMusicFile = Music_GetBaseMusicFile( eBGRNDTRACK_EXPLORE );
+			if (pMusicFile)
+			{
+				int iTransNum = eMusicState - eBGRNDTRACK_EXPLORETRANS0;
+				if (iTransNum < pMusicFile->MusicExitPoints.size())
+				{
+					return Music_BuildFileName( pMusicFile->MusicExitPoints[iTransNum].sNextFile.c_str(), eMusicState );
+				}
+			}
+			break;
+
+		default:
+			#ifndef FINAL_BUILD
+			assert(0);	// duh....what state are they asking for?
+			Com_Printf( S_COLOR_RED "Music_GetFileNameForState( %d ) unhandled case!\n",eMusicState );
+			#endif
+			break;
+	}
+
+	return NULL;
+}
+
+
+
+qboolean Music_StateIsTransition( MusicState_e eMusicState )
+{
+	return (eMusicState >= eBGRNDTRACK_FIRSTTRANSITION &&
+			eMusicState <= eBGRNDTRACK_LASTTRANSITION
+			);
+}
+
+
+qboolean Music_StateCanBeInterrupted( MusicState_e eMusicState, MusicState_e eProposedMusicState )
+{
+	// death music can interrupt anything...
+	//
+	if (eProposedMusicState == eBGRNDTRACK_DEATH)
+		return qtrue;
+	//
+	// ... and can't be interrupted once started...(though it will internally-switch to silence at the end, rather than loop)
+	//
+	if (eMusicState == eBGRNDTRACK_DEATH)
+	{
+		return qfalse;
+	}
+
+	// boss music can interrupt anything (other than death, but that's already handled above)...
+	//
+	if (eProposedMusicState == eBGRNDTRACK_BOSS)
+		return qtrue;
+	//
+	// ... and can't be interrupted once started...
+	//
+	if (eMusicState == eBGRNDTRACK_BOSS)
+	{
+		// ...except by silence (or death, but again, that's already handled above)
+		//
+		if (eProposedMusicState == eBGRNDTRACK_SILENCE)	 
+			return qtrue;	
+
+		return qfalse;
+	}
+
+	// action music can interrupt anything (after boss & death filters above)...
+	//
+	if (eProposedMusicState == eBGRNDTRACK_ACTION)
+		return qtrue;
+
+	// nothing can interrupt a transition (after above filters)...
+	//
+	if (Music_StateIsTransition( eMusicState ))
+		return qfalse;
+
+	// current state is therefore interruptable...
+	//
+	return qtrue;
+}
+
+
+
+// returns qtrue if music is allowed to transition out of current state, based on current play position...
+// (doesn't bother returning final state after transition (eg action->transition->explore) becuase it's fairly obvious)
+//
+// supply:
+//
+// playing point in float seconds
+// enum of track being queried
+//
+// get:
+//
+// enum of transition track to switch to
+// float time of entry point of new track *after* transition
+//
+qboolean Music_AllowedToTransition( float			fPlayingTimeElapsed,
+									MusicState_e	eMusicState,
+									//
+									MusicState_e	*peTransition /* = NULL */,
+									float			*pfNewTrackEntryTime /* = NULL */
+									)
+{
+	const float fTimeEpsilon = 0.3f;	// arb., how close we have to be to an exit point to take it.
+										//		if set too high then music change is sloppy
+										//		if set too low[/precise] then we might miss an exit if client fps is poor
+
+
+	MusicFile_t *pMusicFile = Music_GetBaseMusicFile( eMusicState );	
+	if (pMusicFile && !pMusicFile->MusicExitTimes.empty())
+	{
+		MusicExitTime_t	T;
+						T.fTime = fPlayingTimeElapsed;
+
+		// since a MusicExitTimes_t item is a sorted array, we can use the equal_range algorithm...
+		//
+		pair <MusicExitTimes_t::iterator, MusicExitTimes_t::iterator> itp = equal_range( pMusicFile->MusicExitTimes.begin(), pMusicFile->MusicExitTimes.end(), T);
+		if (itp.first != pMusicFile->MusicExitTimes.begin())
+			itp.first--;	// encompass the one before, in case we've just missed an exit point by < fTimeEpsilon
+		if (itp.second!= pMusicFile->MusicExitTimes.end())
+			itp.second++;	// increase range to one beyond, so we can do normal STL being/end looping below
+		for (MusicExitTimes_t::iterator it = itp.first; it != itp.second; ++it)
+		{
+			MusicExitTimes_t::iterator pExitTime = it;
+			
+			if ( Q_fabs(pExitTime->fTime - fPlayingTimeElapsed) <= fTimeEpsilon )
+			{
+				// got an exit point!, work out feedback params...
+				//
+				int iExitPoint = pExitTime->iExitPoint;
+				//
+				// the two params to give back...
+				//
+				MusicState_e	eFeedBackTransition			= eBGRNDTRACK_EXPLORETRANS0;	// any old default
+				float			fFeedBackNewTrackEntryTime	= 0.0f;
+				//
+				// check legality in case of crap data...
+				//
+				if (iExitPoint < pMusicFile->MusicExitPoints.size())
+				{
+					MusicExitPoint_t &ExitPoint = pMusicFile->MusicExitPoints[ iExitPoint ];
+
+					switch (eMusicState)
+					{
+						case eBGRNDTRACK_EXPLORE:
+						{
+							assert(iExitPoint < iMAX_EXPLORE_TRANSITIONS);	// already been checked, but sanity
+							assert(!ExitPoint.sNextMark.c_str()[0]);		// simple error checking, but harmless if tripped. explore transitions go to silence, hence no entry time for [silence] state after transition
+
+							eFeedBackTransition = (MusicState_e) (eBGRNDTRACK_EXPLORETRANS0 + iExitPoint);
+						}
+						break;
+
+						case eBGRNDTRACK_ACTION:
+						{
+							assert(iExitPoint < iMAX_ACTION_TRANSITIONS);	// already been checked, but sanity
+
+							// if there's an entry marker point defined...
+							//
+							if (ExitPoint.sNextMark.c_str()[0])
+							{
+								MusicData_t::iterator itExploreMusicData = MusicData->find( Music_BaseStateToString(eBGRNDTRACK_EXPLORE) );
+								//
+								// find "explore" music...
+								//
+								if (itExploreMusicData != MusicData->end())
+								{
+									MusicFile_t &MusicFile_Explore = (*itExploreMusicData).second;
+									//
+									// find the entry marker within the music and read the time there...
+									//
+									MusicEntryTimes_t::iterator itEntryTime = MusicFile_Explore.MusicEntryTimes.find( ExitPoint.sNextMark.c_str() );
+									if (itEntryTime != MusicFile_Explore.MusicEntryTimes.end())
+									{
+										fFeedBackNewTrackEntryTime = (*itEntryTime).second;										
+										eFeedBackTransition = (MusicState_e) (eBGRNDTRACK_ACTIONTRANS0 + iExitPoint);
+									}
+									else
+									{
+										#ifndef FINAL_BUILD
+										assert(0);	// sanity, should have been caught elsewhere, but harmless to do this
+										Com_Printf( S_COLOR_RED "Music_AllowedToTransition() unable to find entry marker \"%s\" in \"%s\"",ExitPoint.sNextMark.c_str(), MusicFile_Explore.sFileNameBase.c_str());
+										#endif
+										return qfalse;
+									}
+								}
+								else
+								{
+									#ifndef FINAL_BUILD
+									assert(0);	// sanity, should have been caught elsewhere, but harmless to do this
+									Com_Printf( S_COLOR_RED "Music_AllowedToTransition() unable to find %s version of \"%s\"\n",Music_BaseStateToString(eBGRNDTRACK_EXPLORE), pMusicFile->sFileNameBase.c_str());
+									#endif
+									return qfalse;
+								}
+							}
+							else
+							{
+								eFeedBackTransition			= eBGRNDTRACK_ACTIONTRANS0;
+								fFeedBackNewTrackEntryTime	= 0.0f;		// already set to this, but FYI
+							}
+						}
+						break;
+
+						default:
+						{
+							#ifndef FINAL_BUILD
+							assert(0);
+							Com_Printf( S_COLOR_RED "Music_AllowedToTransition(): No code to transition from music type %d\n",eMusicState);
+							#endif
+							return qfalse;
+						}
+						break;
+					}
+				}
+				else
+				{
+					#ifndef FINAL_BUILD
+					assert(0);
+					Com_Printf( S_COLOR_RED "Music_AllowedToTransition(): Illegal exit point %d, max = %d (music: \"%s\")\n",iExitPoint, pMusicFile->MusicExitPoints.size()-1, pMusicFile->sFileNameBase.c_str() );
+					#endif
+					return qfalse;
+				}
+
+
+				// feed back answers...
+				//
+				if ( peTransition)
+				{
+					*peTransition = eFeedBackTransition;
+				}
+
+				if ( pfNewTrackEntryTime )
+				{
+					*pfNewTrackEntryTime = fFeedBackNewTrackEntryTime;
+				}
+
+				return qtrue;
+			}
+		}
+	}
+
+	return qfalse;
+}
+
+
+// typically used to get a (predefined) random entry point for the action music, but will work on any defined type with entry points, 
+//	defaults safely to 0.0f if no info available...
+//
+float Music_GetRandomEntryTime( MusicState_e eMusicState )
+{
+	MusicData_t::iterator itMusicData = MusicData->find( Music_BaseStateToString( eMusicState ) );
+	if (itMusicData != MusicData->end())
+	{
+		MusicFile_t &MusicFile = (*itMusicData).second;
+
+		if (MusicFile.MusicEntryTimes.size())	// make sure at least one defined, else default to start
+		{
+			// Quake's random number generator isn't very good, so instead of this:
+			//
+			// int iRandomEntryNum = Q_irand(0, (MusicFile.MusicEntryTimes.size()-1) );
+			//
+			// ... I'll do this (ensuring we don't get the same result on two consecutive calls, but without while-loop)...
+			//
+			static int	iPrevRandomNumber = -1;
+			static int	iCallCount = 0;
+						iCallCount++;
+			int iRandomEntryNum = (rand()+iCallCount) % (MusicFile.MusicEntryTimes.size());	// legal range
+			if (iRandomEntryNum == iPrevRandomNumber && MusicFile.MusicEntryTimes.size()>1)
+			{
+				iRandomEntryNum += 1;
+				iRandomEntryNum %= (MusicFile.MusicEntryTimes.size());
+			}
+			iPrevRandomNumber = iRandomEntryNum;
+
+//			OutputDebugString(va("Music_GetRandomEntryTime(): Entry %d\n",iRandomEntryNum));
+
+			for (MusicEntryTimes_t::iterator itEntryTime = MusicFile.MusicEntryTimes.begin(); itEntryTime != MusicFile.MusicEntryTimes.end(); ++itEntryTime)
+			{
+				if (!iRandomEntryNum--)
+				{
+					return (*itEntryTime).second;										
+				}
+			}
+		}
+	}
+
+	return 0.0f;
+}
+
+// info only, used in "soundinfo" command...
+//
+const char *Music_GetLevelSetName(void)
+{
+	if (Q_stricmp(gsLevelNameForCompare.c_str(), gsLevelNameForLoad.c_str()))
+	{
+		// music remap via USES command...
+		//
+		return va("%s -> %s",gsLevelNameForCompare.c_str(), gsLevelNameForLoad.c_str());
+	}
+
+	return gsLevelNameForLoad.c_str();
+}
+
+///////////////// eof /////////////////////
+
diff --git a/code/client/snd_music.h b/code/client/snd_music.h
new file mode 100644
index 0000000..57914d7
--- /dev/null
+++ b/code/client/snd_music.h
@@ -0,0 +1,67 @@
+// Filename:-	snd_music.h
+//
+//
+
+
+
+#ifndef SND_MUSIC_H
+#define SND_MUSIC_H
+
+// if you change this enum, you MUST update the #defines below
+typedef enum 
+{
+//( eBGRNDTRACK_DATABEGIN )			// begin-label for FOR loops
+	//
+	eBGRNDTRACK_EXPLORE = 0,		// for normal walking around
+	eBGRNDTRACK_ACTION,				// for excitement	
+	eBGRNDTRACK_BOSS,				// (optional) for final encounter
+	eBGRNDTRACK_DEATH,				// (optional) death "flourish"
+	eBGRNDTRACK_ACTIONTRANS0,		// transition from action to explore
+	eBGRNDTRACK_ACTIONTRANS1,		// "
+	eBGRNDTRACK_ACTIONTRANS2,		// "
+	eBGRNDTRACK_ACTIONTRANS3,		// "
+	eBGRNDTRACK_EXPLORETRANS0,		// transition from explore to silence
+	eBGRNDTRACK_EXPLORETRANS1,		// "
+	eBGRNDTRACK_EXPLORETRANS2,		// "
+	eBGRNDTRACK_EXPLORETRANS3,		// "
+	//
+//(	eBGRNDTRACK_DATAEND ),			// tracks from this point on are for logic or copies, do NOT free them.
+	//
+	eBGRNDTRACK_NONDYNAMIC,			// used for when music is just streaming, not part of dynamic stuff (used to be defined as same as explore entry, but this allows playing music in between 2 invokations of the same dynamic music without midleve reload, and also faster level transitioning if two consecutive dynamic sections use same DMS.DAT entries. Are you still reading this far?
+	eBGRNDTRACK_SILENCE,			// silence (more of a logic thing than an actual track at the moment)
+	eBGRNDTRACK_FADE,				// the xfade channel
+	//
+	eBGRNDTRACK_NUMBEROF
+
+} MusicState_e;
+
+#define iMAX_ACTION_TRANSITIONS		4	// these can be increased easily enough, I just need to know about them
+#define iMAX_EXPLORE_TRANSITIONS	4	//
+
+#define eBGRNDTRACK_DATABEGIN	eBGRNDTRACK_EXPLORE	// label for FOR() loops (not in enum, else debugger shows in instead of the explore one unless I declare them backwards, which is gay)
+#define eBGRNDTRACK_DATAEND		eBGRNDTRACK_NONDYNAMIC // tracks from this point on are for logic or copies, do NOT free them.
+
+#define eBGRNDTRACK_FIRSTTRANSITION	eBGRNDTRACK_ACTIONTRANS0	// used for "are we in transition mode" check
+#define eBGRNDTRACK_LASTTRANSITION	eBGRNDTRACK_EXPLORETRANS3	//
+
+
+void		Music_SetLevelName			( const char *psLevelName );
+qboolean	Music_DynamicDataAvailable	( const char *psDynamicMusicLabel );
+const char *Music_GetFileNameForState	( MusicState_e eMusicState );
+qboolean	Music_StateIsTransition		( MusicState_e eMusicState );
+qboolean	Music_StateCanBeInterrupted	( MusicState_e eMusicState, MusicState_e eProposedMusicState );
+float		Music_GetRandomEntryTime	( MusicState_e eMusicState );
+
+#ifdef		MP3STUFF_KNOWN
+qboolean	Music_AllowedToTransition	( float fPlayingTimeElapsed, MusicState_e eMusicState, MusicState_e	*peTransition = NULL, float *pfNewTrackEntryTime = NULL);
+#endif
+
+const char *Music_BaseStateToString		( MusicState_e eMusicState, qboolean bDebugPrintQuery = qfalse);
+
+
+#endif	// #ifndef SND_MUSIC_H
+
+
+//////////////// eof /////////////////
+
+
diff --git a/code/client/snd_public.h b/code/client/snd_public.h
new file mode 100644
index 0000000..1e3b5a3
--- /dev/null
+++ b/code/client/snd_public.h
@@ -0,0 +1,55 @@
+#ifndef _SND_PUBLIC_H
+#define _SND_PUBLIC_H
+
+void S_Init( void );
+void S_Shutdown( void );
+
+// if origin is NULL, the sound will be dynamically sourced from the entity
+void S_AddAmbientLoopingSound( const vec3_t origin, unsigned char volume, sfxHandle_t sfxHandle );
+void S_StartAmbientSound( const vec3_t origin, int entityNum, unsigned char volume, sfxHandle_t sfxHandle );
+void S_StartSound( const vec3_t origin, int entnum, soundChannel_t entchannel, sfxHandle_t sfx );
+void S_StartLocalSound( sfxHandle_t sfx, int channelNum );
+void S_StartLocalLoopingSound( sfxHandle_t sfx);
+
+void S_UnCacheDynamicMusic( void );
+void S_RestartMusic( void );
+void S_StartBackgroundTrack( const char *intro, const char *loop, qboolean bCalledByCGameStart );
+void S_StopBackgroundTrack( void );
+float S_GetSampleLengthInMilliSeconds( sfxHandle_t sfxHandle);
+
+// cinematics and voice-over-network will send raw samples
+// 1.0 volume will be direct output of source samples
+void S_RawSamples( int samples, int rate, int width, int s_channels, const byte *data, float volume, qboolean bFirstOrOnlyUpdateThisFrame );
+// stop all sounds
+void S_StopSounds(void);	// from snd_dma.cpp
+// stop all sounds and the background track
+void S_StopAllSounds( void );
+
+// scan all MP3s in the sound dir and add maxvol info if necessary.
+void S_MP3_CalcVols_f( void );
+
+// all continuous looping sounds must be added before calling S_Update
+void S_ClearLoopingSounds( void );
+void S_AddLoopingSound( int entityNum, const vec3_t origin, const vec3_t velocity, sfxHandle_t sfx, soundChannel_t chan = CHAN_AUTO );
+
+// recompute the reletive volumes for all running sounds
+// relative to the given entityNum / orientation
+void S_Respatialize( int entityNum, const vec3_t origin, vec3_t axis[3], qboolean inwater );
+
+// let the sound system know where an entity currently is
+void S_UpdateEntityPosition( int entityNum, const vec3_t origin );
+
+void S_Update( void );
+
+void S_DisableSounds( void );
+
+void S_BeginRegistration( void );
+
+// RegisterSound will allways return a valid sample, even if it
+// has to create a placeholder.  This prevents continuous filesystem
+// checks for missing files
+sfxHandle_t	S_RegisterSound( const char *sample );
+
+void S_FreeAllSFXMem(void);
+
+#endif
diff --git a/code/client/vmachine.cpp b/code/client/vmachine.cpp
new file mode 100644
index 0000000..cb5f43b
--- /dev/null
+++ b/code/client/vmachine.cpp
@@ -0,0 +1,39 @@
+// vmachine.cpp -- wrapper to fake virtual machine for client
+
+#include "vmachine.h"
+#pragma warning (disable : 4514)
+/*
+==============================================================
+
+VIRTUAL MACHINE
+
+==============================================================
+*/
+int	VM_Call( int callnum, ... )
+{
+//	assert (cgvm.entryPoint);
+	
+	if (cgvm.entryPoint)
+	{
+		return cgvm.entryPoint( (&callnum)[0], (&callnum)[1], (&callnum)[2], (&callnum)[3],
+			(&callnum)[4], (&callnum)[5], (&callnum)[6], (&callnum)[7],
+			(&callnum)[8],  (&callnum)[9] );
+	}
+	
+	return -1;
+}
+
+/*
+============
+VM_DllSyscall
+
+we pass this to the cgame dll to call back into the client
+============
+*/
+extern int CL_CgameSystemCalls( int *args );
+extern int CL_UISystemCalls( int *args );
+
+int VM_DllSyscall( int arg, ... ) {
+//	return cgvm->systemCall( &arg );
+	return CL_CgameSystemCalls( &arg );
+}
diff --git a/code/client/vmachine.h b/code/client/vmachine.h
new file mode 100644
index 0000000..78f27ca
--- /dev/null
+++ b/code/client/vmachine.h
@@ -0,0 +1,93 @@
+// vmachine.h -- virtual machine header for client
+#ifndef __VMACHINE_H__
+#define __VMACHINE_H__
+
+/*
+==================================================================
+
+functions exported to the main executable
+
+==================================================================
+*/
+
+typedef enum {
+	CG_INIT,
+	CG_SHUTDOWN,
+	CG_CONSOLE_COMMAND,
+	CG_DRAW_ACTIVE_FRAME,
+	CG_CROSSHAIR_PLAYER,
+	CG_CAMERA_POS,
+	CG_CAMERA_ANG,
+/*
+Ghoul2 Insert Start
+*/
+
+	CG_RESIZE_G2_BOLT,
+	CG_RESIZE_G2,
+	CG_RESIZE_G2_BONE,
+	CG_RESIZE_G2_SURFACE,
+	CG_RESIZE_G2_TEMPBONE,
+/*
+Ghoul2 Insert End
+*/
+	CG_DRAW_DATAPAD_HUD,
+	CG_DRAW_DATAPAD_OBJECTIVES,
+	CG_DRAW_DATAPAD_WEAPONS,
+	CG_DRAW_DATAPAD_INVENTORY,
+	CG_DRAW_DATAPAD_FORCEPOWERS
+
+} cgameExport_t;
+
+/*
+==============================================================
+
+VIRTUAL MACHINE
+
+==============================================================
+*/
+struct vm_s {
+	int			(*entryPoint)( int callNum, ... );
+};
+
+typedef struct vm_s vm_t;
+
+extern	vm_t	cgvm;	// interface to cgame dll or vm
+extern	vm_t	uivm;	// interface to ui dll or vm
+
+extern int	VM_Call( int callnum, ... );
+extern int VM_DllSyscall( int arg, ... );
+extern void CL_ShutdownCGame(void);
+
+#include "../game/q_shared.h"
+
+/*
+================
+VM_Create
+
+it will attempt to load as a system dll
+================
+*/
+extern void *Sys_LoadCgame( int (**entryPoint)(int, ...), int (*systemcalls)(int, ...) );
+
+inline void *VM_Create( const char *module) 
+{
+	void *res;
+	// try to load as a system dll
+	if (!Q_stricmp("cl", module))
+	{
+		res = Sys_LoadCgame( &cgvm.entryPoint, VM_DllSyscall );
+		if ( !res) 
+		{
+			//Com_Printf( "Failed.\n" );
+			return 0;
+		}
+	}
+	else 
+	{
+		res = 0;
+	}
+
+	return res;
+}
+
+#endif //__VMACHINE_H__
\ No newline at end of file
diff --git a/code/client/vssver.scc b/code/client/vssver.scc
new file mode 100644
index 0000000..a1696a0
Binary files /dev/null and b/code/client/vssver.scc differ
diff --git a/code/ff/IFC/FeelitAPI.h b/code/ff/IFC/FeelitAPI.h
new file mode 100644
index 0000000..bf50294
--- /dev/null
+++ b/code/ff/IFC/FeelitAPI.h
@@ -0,0 +1,1228 @@
+/**********************************************************************
+	Copyright (c) 1997-2000 Immersion Corporation
+
+	Permission to use, copy, modify, distribute, and sell this
+	software and its documentation may be granted without fee;
+	interested parties are encouraged to request permission from
+		Immersion Corporation
+		2158 Paragon Drive
+		San Jose, CA 95131
+		408-467-1900
+
+	IMMERSION DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+	INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.
+	IN NO EVENT SHALL IMMERSION BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+	CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+	LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+	NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+	CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+  FILE:		FeelitAPI.h
+
+  PURPOSE:	Feelit API
+
+  STARTED:	09/08/97
+
+  NOTES/REVISIONS:
+
+  23-May-2000   MPR     Added support for querying the number of effects that can be 
+                        downloaded to a device (FEELIT_PROPNUMEFFECTS and FEELIT_PROP_NUMEFFECTS).  
+                        Added a new device subtype, FEELIT_DEVICETYPEMOUSE_VIBRATION_FF.
+                        Removed FEELIT_DEVICETYPE_HID.
+
+  06-Jun-2000   MPR     Added FEELIT_PROP_DEVICEID.
+
+  08-Jun-2000   MPR     Added MAKE_FEELIT_DEVICE_TYPE_DWORD.
+
+**********************************************************************/
+
+#ifndef __FEELITAPI_INCLUDED__
+#define __FEELITAPI_INCLUDED__
+
+#ifndef FEELIT_VERSION
+#define FEELIT_VERSION         0x0103
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef _WIN32
+#define COM_NO_WINDOWS_H
+#include <objbase.h>
+#endif
+
+/****************************************************************************
+ *
+ *      Class IDs
+ *
+ ****************************************************************************/
+
+DEFINE_GUID(CLSID_Feelit,		0x5959df60,0x2911,0x11d1,0xb0,0x49,0x00,0x20,0xaf,0x30,0x26,0x9a);
+DEFINE_GUID(CLSID_FeelitDevice,	0x5959df61,0x2911,0x11d1,0xb0,0x49,0x00,0x20,0xaf,0x30,0x26,0x9a);
+
+
+/****************************************************************************
+ *
+ *      Interfaces
+ *
+ ****************************************************************************/
+
+DEFINE_GUID(IID_IFeelit,		0x5959df62,0x2911,0x11d1,0xb0,0x49,0x00,0x20,0xaf,0x30,0x26,0x9a);
+DEFINE_GUID(IID_IFeelitDevice,	0x5959df63,0x2911,0x11d1,0xb0,0x49,0x00,0x20,0xaf,0x30,0x26,0x9a);
+DEFINE_GUID(IID_IFeelitEffect,	0x5959df64,0x2911,0x11d1,0xb0,0x49,0x00,0x20,0xaf,0x30,0x26,0x9a);
+DEFINE_GUID(IID_IFeelitConfig,  0x900c39e0,0xcc5c,0x11d2,0x8c,0x5d,0x00,0x10,0x5a,0x17,0x8a,0xd1);
+
+
+/****************************************************************************
+ *
+ *      Predefined object types
+ *
+ ****************************************************************************/
+
+DEFINE_GUID(GUID_Feelit_XAxis,   0x5959df65,0x2911,0x11d1,0xb0,0x49,0x00,0x20,0xaf,0x30,0x26,0x9a);
+DEFINE_GUID(GUID_Feelit_YAxis,   0x5959df66,0x2911,0x11d1,0xb0,0x49,0x00,0x20,0xaf,0x30,0x26,0x9a);
+DEFINE_GUID(GUID_Feelit_ZAxis,   0x5959df67,0x2911,0x11d1,0xb0,0x49,0x00,0x20,0xaf,0x30,0x26,0x9a);
+DEFINE_GUID(GUID_Feelit_RxAxis,  0x5959df68,0x2911,0x11d1,0xb0,0x49,0x00,0x20,0xaf,0x30,0x26,0x9a);
+DEFINE_GUID(GUID_Feelit_RyAxis,  0x5959df69,0x2911,0x11d1,0xb0,0x49,0x00,0x20,0xaf,0x30,0x26,0x9a);
+DEFINE_GUID(GUID_Feelit_RzAxis,  0x5959df6a,0x2911,0x11d1,0xb0,0x49,0x00,0x20,0xaf,0x30,0x26,0x9a);
+DEFINE_GUID(GUID_Feelit_Slider,  0x5959df6b,0x2911,0x11d1,0xb0,0x49,0x00,0x20,0xaf,0x30,0x26,0x9a);
+
+DEFINE_GUID(GUID_Feelit_Button,  0x5959df6c,0x2911,0x11d1,0xb0,0x49,0x00,0x20,0xaf,0x30,0x26,0x9a);
+DEFINE_GUID(GUID_Feelit_Key,     0x5959df6d,0x2911,0x11d1,0xb0,0x49,0x00,0x20,0xaf,0x30,0x26,0x9a);
+
+DEFINE_GUID(GUID_Feelit_POV,     0x5959df6e,0x2911,0x11d1,0xb0,0x49,0x00,0x20,0xaf,0x30,0x26,0x9a);
+
+DEFINE_GUID(GUID_Feelit_Unknown, 0x5959df6f,0x2911,0x11d1,0xb0,0x49,0x00,0x20,0xaf,0x30,0x26,0x9a);
+
+
+/****************************************************************************
+ *
+ *      Predefined Product GUIDs
+ *
+ ****************************************************************************/
+
+DEFINE_GUID(GUID_Feelit_Mouse,   0x99bb5400,0x2b94,0x11d1,0xb0,0x49,0x00,0x20,0xaf,0x30,0x26,0x9a);
+
+/****************************************************************************
+ *
+ *      Force feedback effects
+ *
+ ****************************************************************************/
+
+
+/* Constant Force */
+DEFINE_GUID(GUID_Feelit_ConstantForce,0x5959df71,0x2911,0x11d1,0xb0,0x49,0x00,0x20,0xaf,0x30,0x26,0x9a);
+
+/* Ramp Force */
+DEFINE_GUID(GUID_Feelit_RampForce,	0x5959df72,0x2911,0x11d1,0xb0,0x49,0x00,0x20,0xaf,0x30,0x26,0x9a);
+
+/* Periodic Effects */
+DEFINE_GUID(GUID_Feelit_Square,      0x5959df73,0x2911,0x11d1,0xb0,0x49,0x00,0x20,0xaf,0x30,0x26,0x9a);
+DEFINE_GUID(GUID_Feelit_Sine,        0x5959df74,0x2911,0x11d1,0xb0,0x49,0x00,0x20,0xaf,0x30,0x26,0x9a);
+DEFINE_GUID(GUID_Feelit_Triangle,    0x5959df75,0x2911,0x11d1,0xb0,0x49,0x00,0x20,0xaf,0x30,0x26,0x9a);
+DEFINE_GUID(GUID_Feelit_SawtoothUp,	0x5959df76,0x2911,0x11d1,0xb0,0x49,0x00,0x20,0xaf,0x30,0x26,0x9a);
+DEFINE_GUID(GUID_Feelit_SawtoothDown,0x5959df77,0x2911,0x11d1,0xb0,0x49,0x00,0x20,0xaf,0x30,0x26,0x9a);
+
+
+/* Conditions */
+DEFINE_GUID(GUID_Feelit_Spring,      0x5959df78,0x2911,0x11d1,0xb0,0x49,0x00,0x20,0xaf,0x30,0x26,0x9a);
+DEFINE_GUID(GUID_Feelit_DeviceSpring,0x5959df83,0x2911,0x11d1,0xb0,0x49,0x00,0x20,0xaf,0x30,0x26,0x9a);
+DEFINE_GUID(GUID_Feelit_Damper,      0x5959df79,0x2911,0x11d1,0xb0,0x49,0x00,0x20,0xaf,0x30,0x26,0x9a);
+DEFINE_GUID(GUID_Feelit_Inertia,     0x5959df7a,0x2911,0x11d1,0xb0,0x49,0x00,0x20,0xaf,0x30,0x26,0x9a);
+DEFINE_GUID(GUID_Feelit_Friction,    0x5959df7b,0x2911,0x11d1,0xb0,0x49,0x00,0x20,0xaf,0x30,0x26,0x9a);
+DEFINE_GUID(GUID_Feelit_Texture,		0x5959df7c,0x2911,0x11d1,0xb0,0x49,0x00,0x20,0xaf,0x30,0x26,0x9a);
+DEFINE_GUID(GUID_Feelit_Grid,		0x5959df7d,0x2911,0x11d1,0xb0,0x49,0x00,0x20,0xaf,0x30,0x26,0x9a);
+
+/* Enclosures */
+DEFINE_GUID(GUID_Feelit_Enclosure,	0x5959df7f,0x2911,0x11d1,0xb0,0x49,0x00,0x20,0xaf,0x30,0x26,0x9a);
+DEFINE_GUID(GUID_Feelit_Ellipse,	    0x5959df82,0x2911,0x11d1,0xb0,0x49,0x00,0x20,0xaf,0x30,0x26,0x9a);
+
+/* Custom Force */
+DEFINE_GUID(GUID_Feelit_CustomForce, 0x5959df7e,0x2911,0x11d1,0xb0,0x49,0x00,0x20,0xaf,0x30,0x26,0x9a);
+
+/****************************************************************************
+ *
+ *      Interfaces and Structures...
+ *
+ ****************************************************************************/
+
+
+/****************************************************************************
+ *
+ *      IFeelitEffect
+ *
+ ****************************************************************************/
+
+#define FEELIT_FEFFECTTYPE_ALL					0x00000000
+
+#define FEELIT_FEFFECTTYPE_CONSTANTFORCE		0x00000001
+#define FEELIT_FEFFECTTYPE_RAMPFORCE			0x00000002
+#define FEELIT_FEFFECTTYPE_PERIODIC				0x00000003
+#define FEELIT_FEFFECTTYPE_CONDITION			0x00000004
+#define FEELIT_FEFFECTTYPE_ENCLOSURE			0x00000005
+#define FEELIT_FEFFECTTYPE_ELLIPSE				0x00000006
+#define FEELIT_FEFFECTTYPE_TEXTURE				0x00000007
+#define FEELIT_FEFFECTTYPE_CUSTOMFORCE			0x000000F0
+#define FEELIT_FEFFECTTYPE_HARDWARE				0x000000FF
+
+#define FEELIT_FEFFECTTYPE_FFATTACK				0x00000200
+#define FEELIT_FEFFECTTYPE_FFFADE				0x00000400
+#define FEELIT_FEFFECTTYPE_SATURATION			0x00000800
+#define FEELIT_FEFFECTTYPE_POSNEGCOEFFICIENTS	0x00001000
+#define FEELIT_FEFFECTTYPE_POSNEGSATURATION		0x00002000
+#define FEELIT_FEFFECTTYPE_DEADBAND				0x00004000
+
+#define FEELIT_EFFECTTYPE_GETTYPE(n)             LOBYTE(n)
+#define FEELIT_EFFECTTYPE_GETFLAGS(n)            ( n & 0xFFFFFF00 )
+
+#define FEELIT_DEGREES                  100
+#define FEELIT_FFNOMINALMAX             10000
+#define FEELIT_SECONDS                  1000000
+
+typedef struct FEELIT_CONSTANTFORCE {
+    LONG  lMagnitude;	/* Magnitude of the effect, in the range -10000 to 10000 */
+} FEELIT_CONSTANTFORCE, *LPFEELIT_CONSTANTFORCE;
+typedef const FEELIT_CONSTANTFORCE *LPCFEELIT_CONSTANTFORCE;
+
+typedef struct FEELIT_RAMPFORCE {
+    LONG  lStart;	/* Magnitude at start of effect. Range -10000 to 10000 */
+    LONG  lEnd;		/* Magnitude at end of effect. Range -10000 to 10000 */
+} FEELIT_RAMPFORCE, *LPFEELIT_RAMPFORCE;
+typedef const FEELIT_RAMPFORCE *LPCFEELIT_RAMPFORCE;
+
+typedef struct FEELIT_PERIODIC {
+    DWORD dwMagnitude;  /* Magnitude of the effect, in the range 0 to 10000 */
+    LONG  lOffset;		/* Force will be gen'd in range lOffset - dwMagnitude to lOffset + dwMagnitude */
+    DWORD dwPhase;		/* Position in cycle at wich playback begins. Range 0 - 35,999 */
+    DWORD dwPeriod;		/* Period (length of one cycle) of the effect in microseconds */
+} FEELIT_PERIODIC, *LPFEELIT_PERIODIC;
+typedef const FEELIT_PERIODIC *LPCFEELIT_PERIODIC;
+
+typedef struct FEELIT_CONDITION {
+    LONG  lCenter;				/* Center-point in screen coords. Axis depends on that in FEELIT_EFFECT */
+    LONG  lPositiveCoefficient;	/* Coef. on pos. side of the offset. Range -10000 to 10000 */
+    LONG  lNegativeCoefficient;	/* Coef. on neg. side of the offset. Range -10000 to 10000 */
+    DWORD dwPositiveSaturation; /* Max force output on pos. side of offset. Range 0 to 10000 */
+    DWORD dwNegativeSaturation;	/* Max force output on neg. side of offset. Range 0 to 10000 */
+    LONG  lDeadBand;			/* Region around lOffset where condition is not active. Range 0 to 10000 */
+} FEELIT_CONDITION, *LPFEELIT_CONDITION;
+typedef const FEELIT_CONDITION *LPCFEELIT_CONDITION;
+
+typedef struct FEELIT_TEXTURE {
+    DWORD dwSize;			    /* sizeof(FEELIT_TEXTURE)   */
+    LONG lOffset;				/* Offset in screen coords of first texture from left or top edge */
+    LONG lPosBumpMag;			/* Magnitude of bumps felt when mouse travels in positive direction */
+    DWORD dwPosBumpWidth;		/* Width of bumps felt when mouse travels in positive direction */
+    DWORD dwPosBumpSpacing;		/* Center-to-Center spacing of bumps felt when mouse travels in positive direction */
+    LONG lNegBumpMag;	        /* Magnitude of bumps felt when mouse travels in negative direction */
+    DWORD dwNegBumpWidth;		/* Width of bumps felt when mouse travels in negative direction */
+    DWORD dwNegBumpSpacing;		/* Center-to-Center spacing of bumps felt when mouse travels in negative direction */
+} FEELIT_TEXTURE, *LPFEELIT_TEXTURE;
+typedef const FEELIT_TEXTURE *LPCFEELIT_TEXTURE;
+
+typedef struct FEELIT_CUSTOMFORCE {
+    DWORD cChannels;		/* No. of channels (axes) affected by this force */
+    DWORD dwSamplePeriod;	/* Sample period in microseconds */
+    DWORD cSamples;			/* Total number of samples in the rglForceData */
+    LPLONG rglForceData;	/* long[cSamples]. Array of force values. Channels are interleaved */
+} FEELIT_CUSTOMFORCE, *LPFEELIT_CUSTOMFORCE;
+typedef const FEELIT_CUSTOMFORCE *LPCFEELIT_CUSTOMFORCE;
+
+typedef struct FEELIT_ENVELOPE {
+    DWORD dwSize;			/* sizeof(FEELIT_ENVELOPE)   */
+    DWORD dwAttackLevel;	/* Ampl. for start of env., rel. to baseline. Range 0 to 10000 */
+    DWORD dwAttackTime;     /* Time, in microseconds, to reach sustain level */
+    DWORD dwFadeLevel;		/* Ampl. for end of env., rel. to baseline. Range 0 to 10000 */
+    DWORD dwFadeTime;       /* Time, in microseconds, to reach fade level */
+} FEELIT_ENVELOPE, *LPFEELIT_ENVELOPE;
+typedef const FEELIT_ENVELOPE *LPCFEELIT_ENVELOPE;
+
+typedef struct FEELIT_EFFECT {
+    DWORD dwSize;                   /* sizeof(FEELIT_EFFECT) */
+	GUID guidEffect;			    /* Effect Identifier    */
+	DWORD dwFlags;                  /* FEELIT_FEFFECT_*      */
+    DWORD dwDuration;               /* Microseconds         */
+    DWORD dwSamplePeriod;           /* RESERVED             */
+    DWORD dwGain;					/* RESERVED             */
+    DWORD dwTriggerButton;          /* RESERVED             */
+    DWORD dwTriggerRepeatInterval;  /* RESERVED             */
+    DWORD cAxes;                    /* Number of axes       */
+    LPDWORD rgdwAxes;               /* Array of axes        */
+    LPLONG rglDirection;            /* Array of directions  */
+    LPFEELIT_ENVELOPE lpEnvelope;   /* Optional             */
+    DWORD cbTypeSpecificParams;     /* Size of params       */
+    LPVOID lpvTypeSpecificParams;   /* Pointer to params    */
+	 DWORD dwStartDelay;             /* Microseconds delay    */
+} FEELIT_EFFECT, *LPFEELIT_EFFECT;
+typedef const FEELIT_EFFECT *LPCFEELIT_EFFECT;
+
+
+/* Effect Flags */
+#define FEELIT_FEFFECT_OBJECTIDS             0x00000001
+#define FEELIT_FEFFECT_OBJECTOFFSETS         0x00000002
+#define FEELIT_FEFFECT_CARTESIAN             0x00000010
+#define FEELIT_FEFFECT_POLAR                 0x00000020
+#define FEELIT_FEFFECT_SPHERICAL             0x00000040
+
+/* Parameter Flags */
+#define FEELIT_FPARAM_DURATION               0x00000001
+#define FEELIT_FPARAM_SAMPLEPERIOD           0x00000002
+#define FEELIT_FPARAM_GAIN                   0x00000004
+#define FEELIT_FPARAM_TRIGGERBUTTON          0x00000008
+#define FEELIT_FPARAM_TRIGGERREPEATINTERVAL  0x00000010
+#define FEELIT_FPARAM_AXES                   0x00000020
+#define FEELIT_FPARAM_DIRECTION              0x00000040
+#define FEELIT_FPARAM_ENVELOPE               0x00000080
+#define FEELIT_FPARAM_TYPESPECIFICPARAMS     0x00000100
+#define FEELIT_FPARAM_STARTDELAY             0x00000200
+#define FEELIT_FPARAM_ALLPARAMS              0x000003FF
+#define FEELIT_FPARAM_START                  0x20000000
+#define FEELIT_FPARAM_NORESTART              0x40000000
+#define FEELIT_FPARAM_NODOWNLOAD             0x80000000
+
+#define FEELIT_PARAM_NOTRIGGER               0xFFFFFFFF
+
+/* Start Flags */
+#define FEELIT_FSTART_SOLO                   0x00000001
+#define FEELIT_FSTART_NODOWNLOAD             0x80000000
+
+/* Status Flags */
+#define FEELIT_FSTATUS_PLAYING               0x00000001
+#define FEELIT_FSTATUS_EMULATED              0x00000002
+
+/* Stiffness Mask Flags */
+#define FEELIT_FSTIFF_NONE				0x00000000
+#define FEELIT_FSTIFF_OUTERLEFTWALL		0x00000001
+#define FEELIT_FSTIFF_INNERLEFTWALL		0x00000002
+#define FEELIT_FSTIFF_INNERRIGHTWALL	0x00000004
+#define FEELIT_FSTIFF_OUTERRIGHTWALL	0x00000008
+#define FEELIT_FSTIFF_OUTERTOPWALL		0x00000010
+#define FEELIT_FSTIFF_INNERTOPWALL		0x00000020
+#define FEELIT_FSTIFF_INNERBOTTOMWALL	0x00000040
+#define FEELIT_FSTIFF_OUTERBOTTOMWALL	0x00000080
+#define FEELIT_FSTIFF_OUTERANYWALL		( FEELIT_FSTIFF_OUTERTOPWALL | FEELIT_FSTIFF_OUTERBOTTOMWALL | FEELIT_FSTIFF_OUTERLEFTWALL | FEELIT_FSTIFF_OUTERRIGHTWALL )
+#define FEELIT_FSTIFF_INBOUNDANYWALL	FEELIT_FSTIFF_OUTERANYWALL
+#define FEELIT_FSTIFF_INNERANYWALL		( FEELIT_FSTIFF_INNERTOPWALL | FEELIT_FSTIFF_INNERBOTTOMWALL | FEELIT_FSTIFF_INNERLEFTWALL | FEELIT_FSTIFF_INNERRIGHTWALL )
+#define FEELIT_FSTIFF_OUTBOUNDANYWALL	FEELIT_FSTIFF_INNERANYWALL
+#define FEELIT_FSTIFF_ANYWALL			( FEELIT_FSTIFF_OUTERANYWALL | FEELIT_FSTIFF_INNERANYWALL )
+
+/* Clipping Mask Flags */
+#define FEELIT_FCLIP_NONE				0x00000000
+#define FEELIT_FCLIP_OUTERLEFTWALL		0x00000001
+#define FEELIT_FCLIP_INNERLEFTWALL		0x00000002
+#define FEELIT_FCLIP_INNERRIGHTWALL		0x00000004
+#define FEELIT_FCLIP_OUTERRIGHTWALL		0x00000008
+#define FEELIT_FCLIP_OUTERTOPWALL		0x00000010
+#define FEELIT_FCLIP_INNERTOPWALL		0x00000020
+#define FEELIT_FCLIP_INNERBOTTOMWALL	0x00000040
+#define FEELIT_FCLIP_OUTERBOTTOMWALL	0x00000080
+#define FEELIT_FCLIP_OUTERANYWALL		( FEELIT_FCLIP_OUTERTOPWALL | FEELIT_FCLIP_OUTERBOTTOMWALL | FEELIT_FCLIP_OUTERLEFTWALL | FEELIT_FCLIP_OUTERRIGHTWALL )
+#define FEELIT_FCLIP_INNERANYWALL		( FEELIT_FCLIP_INNERTOPWALL | FEELIT_FCLIP_INNERBOTTOMWALL | FEELIT_FCLIP_INNERLEFTWALL | FEELIT_FCLIP_INNERRIGHTWALL )
+#define FEELIT_FCLIP_ANYWALL			( FEELIT_FCLIP_OUTERANYWALL | FEELIT_FCLIP_INNERANYWALL )
+
+typedef struct FEELIT_EFFESCAPE {
+    DWORD   dwSize;			/* sizeof( FEELIT_EFFESCAPE ) */
+    DWORD   dwCommand;		/* Driver-specific command number */
+    LPVOID  lpvInBuffer;	/* Buffer containing data required to perform the operation */
+    DWORD   cbInBuffer;		/* Size, in bytes, of lpvInBuffer */
+    LPVOID  lpvOutBuffer;	/* Buffer in which the operation's output data is returned */
+    DWORD   cbOutBuffer;	/* Size, in bytes, of lpvOutBuffer */
+} FEELIT_EFFESCAPE, *LPFEELIT_EFFESCAPE;
+
+
+#undef INTERFACE
+#define INTERFACE IFeelitEffect
+
+DECLARE_INTERFACE_(IFeelitEffect, IUnknown)
+{
+    /*** IUnknown methods ***/
+    STDMETHOD(QueryInterface)(THIS_ REFIID riid, LPVOID * ppvObj) PURE;
+    STDMETHOD_(ULONG,AddRef)(THIS) PURE;
+    STDMETHOD_(ULONG,Release)(THIS) PURE;
+
+    /*** IFeelitEffect methods ***/
+    STDMETHOD(GetEffectGuid)(THIS_ LPGUID) PURE;
+    STDMETHOD(GetParameters)(THIS_ LPFEELIT_EFFECT,DWORD) PURE;
+    STDMETHOD(SetParameters)(THIS_ LPCFEELIT_EFFECT,DWORD) PURE;
+    STDMETHOD(Start)(THIS_ DWORD,DWORD) PURE;
+    STDMETHOD(Stop)(THIS) PURE;
+    STDMETHOD(GetEffectStatus)(THIS_ LPDWORD) PURE;
+    STDMETHOD(Download)(THIS) PURE;
+    STDMETHOD(Unload)(THIS) PURE;
+    STDMETHOD(Escape)(THIS_ LPFEELIT_EFFESCAPE) PURE;
+};
+
+typedef struct IFeelitEffect *LPIFEELIT_EFFECT;
+
+
+#if !defined(__cplusplus) || defined(CINTERFACE)
+#define IFeelitEffect_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IFeelitEffect_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IFeelitEffect_Release(p) (p)->lpVtbl->Release(p)
+#define IFeelitEffect_GetEffectGuid(p,a) (p)->lpVtbl->GetEffectGuid(p,a)
+#define IFeelitEffect_GetParameters(p,a,b) (p)->lpVtbl->GetParameters(p,a,b)
+#define IFeelitEffect_SetParameters(p,a,b) (p)->lpVtbl->SetParameters(p,a,b)
+#define IFeelitEffect_Start(p,a,b) (p)->lpVtbl->Start(p,a,b)
+#define IFeelitEffect_Stop(p) (p)->lpVtbl->Stop(p)
+#define IFeelitEffect_GetEffectStatus(p,a) (p)->lpVtbl->GetEffectStatus(p,a)
+#define IFeelitEffect_Download(p) (p)->lpVtbl->Download(p)
+#define IFeelitEffect_Unload(p) (p)->lpVtbl->Unload(p)
+#define IFeelitEffect_Escape(p,a) (p)->lpVtbl->Escape(p,a)
+#else
+#define IFeelitEffect_QueryInterface(p,a,b) (p)->QueryInterface(a,b)
+#define IFeelitEffect_AddRef(p) (p)->AddRef()
+#define IFeelitEffect_Release(p) (p)->Release()
+#define IFeelitEffect_GetEffectGuid(p,a) (p)->GetEffectGuid(a)
+#define IFeelitEffect_GetParameters(p,a,b) (p)->GetParameters(a,b)
+#define IFeelitEffect_SetParameters(p,a,b) (p)->SetParameters(a,b)
+#define IFeelitEffect_Start(p,a,b) (p)->Start(a,b)
+#define IFeelitEffect_Stop(p) (p)->Stop()
+#define IFeelitEffect_GetEffectStatus(p,a) (p)->GetEffectStatus(a)
+#define IFeelitEffect_Download(p) (p)->Download()
+#define IFeelitEffect_Unload(p) (p)->Unload()
+#define IFeelitEffect_Escape(p,a) (p)->Escape(a)
+#endif
+
+
+typedef struct FEELIT_ENCLOSURE {
+    DWORD dwSize;                       /* sizeof(FEELIT_ENCLOSURE) */
+    RECT rectBoundary;                  /* Rectangle defining the boundaries of the effect, in screen coords */
+    DWORD dwTopAndBottomWallThickness;  /* Thickness (pixels) of top/bottom walls. Must be < rectOutside.Height()/2 */
+    DWORD dwLeftAndRightWallThickness;  /* Thickness (pixels) of left/right walls. Must be < rectOutside.Width()/2 */
+    LONG lTopAndBottomWallStiffness;    /* Stiffness of horizontal borders */
+    LONG lLeftAndRightWallStiffness;    /* Stiffness of vertical borders */
+    DWORD dwStiffnessMask;              /* Borders where stiffness is turned on (FEELIT_FSTIFF*) */
+    DWORD dwClippingMask;               /* Borders where clipping is turned on  (FEELIT_FCLIP*) */
+    DWORD dwTopAndBottomWallSaturation; /* Saturation level of spring effect for top/bottom borders */
+    DWORD dwLeftAndRightWallSaturation; /* Saturation level of spring effect for left/right borders */
+    LPIFEELIT_EFFECT piInsideEffect;    /* Interface pointer to effect active in inner area of the enclosure */
+} FEELIT_ENCLOSURE, *LPFEELIT_ENCLOSURE;
+typedef const FEELIT_ENCLOSURE *LPCFEELIT_ENCLOSURE;
+
+
+typedef struct FEELIT_ELLIPSE {
+    DWORD dwSize;                       /* sizeof(FEELIT_ELLIPSE) */
+    RECT  rectBoundary;                 /* Rectangle which circumscribes the ellipse (screen coords) */
+    DWORD dwWallThickness;              /* Thickness (pixels) of ellipse wall at its thickest point */
+    LONG lStiffness;                    /* Stiffness of ellipse borders */
+    DWORD dwStiffnessMask;              /* Borders where stiffness is turned on (FEELIT_FSTIFF*) */
+    DWORD dwClippingMask;               /* Borders where clipping is turned on  (FEELIT_FCLIP*) */
+    DWORD dwSaturation;                 /* Saturation level of spring effect for ellipse borders */
+    LPIFEELIT_EFFECT piInsideEffect;    /* Interface pointer to effect active in inner area of the ellipse */
+} FEELIT_ELLIPSE, *LPFEELIT_ELLIPSE;
+typedef const FEELIT_ELLIPSE *LPCFEELIT_ELLIPSE;
+
+
+/****************************************************************************
+ *
+ *      IFeelitDevice
+ *
+ ****************************************************************************/
+
+/* Device types */
+#define FEELIT_DEVICETYPE_DEVICE    1
+#define FEELIT_DEVICETYPE_MOUSE     2
+
+/* Device subtypes */
+#define FEELIT_DEVICETYPEMOUSE_UNKNOWN          1
+#define FEELIT_DEVICETYPEMOUSE_TRADITIONAL_FF   2
+#define FEELIT_DEVICETYPEMOUSE_VIBRATION_FF     3
+
+/* Device type macros */
+#define GET_FEELIT_DEVICE_TYPE(dwDevType)    LOBYTE(dwDevType)
+#define GET_FEELIT_DEVICE_SUBTYPE(dwDevType) HIBYTE(dwDevType)
+#define MAKE_FEELIT_DEVICE_TYPE_DWORD(ucDevType, ucDevSubtype)  (((DWORD) ((BYTE) ucDevSubtype << 8)) | (BYTE) ucDevType)
+
+typedef struct FEELIT_DEVCAPS {
+    DWORD   dwSize;					/* sizeof( FEELIT_DEVCAPS ) */
+    DWORD   dwFlags;				/* FEELIT_FDEVCAPS_* */
+    DWORD   dwDevType;				/* FEELIT_DEVICETYPE* */
+    DWORD   dwAxes;					/* No. of axes available on the device */
+    DWORD   dwButtons;				/* No. of buttons available on the device */
+    DWORD   dwPOVs;					/* No. of point-of-view controllers on the device */
+    DWORD   dwFFSamplePeriod;		/* Min. time btwn playback of consec. raw force commands */
+    DWORD   dwFFMinTimeResolution;	/* Min. time, in microseconds, the device can resolve */
+    DWORD   dwFirmwareRevision;		/* Firmware revision number of the device */
+    DWORD   dwHardwareRevision;		/* Hardware revision number of the device */
+    DWORD   dwFFDriverVersion;		/* Version number of the device driver */
+} FEELIT_DEVCAPS, *LPFEELIT_DEVCAPS;
+typedef const FEELIT_DEVCAPS *LPCFEELIT_DEVCAPS;
+
+/* Device capabilities flags */
+#define FEELIT_FDEVCAPS_ATTACHED           0x00000001
+#define FEELIT_FDEVCAPS_POLLEDDEVICE       0x00000002
+#define FEELIT_FDEVCAPS_EMULATED           0x00000004
+#define FEELIT_FDEVCAPS_POLLEDDATAFORMAT   0x00000008
+#define FEELIT_FDEVCAPS_FORCEFEEDBACK      0x00000100
+#define FEELIT_FDEVCAPS_FFATTACK           0x00000200
+#define FEELIT_FDEVCAPS_FFFADE             0x00000400
+#define FEELIT_FDEVCAPS_SATURATION         0x00000800
+#define FEELIT_FDEVCAPS_POSNEGCOEFFICIENTS 0x00001000
+#define FEELIT_FDEVCAPS_POSNEGSATURATION   0x00002000
+#define FEELIT_FDEVCAPS_DEADBAND           0x00004000
+
+
+/* Data Format Type Flags */
+
+#define FEELIT_FOBJDATAFMT_ALL               0x00000000
+
+#define FEELIT_FOBJDATAFMT_RELAXIS           0x00000001
+#define FEELIT_FOBJDATAFMT_ABSAXIS           0x00000002
+#define FEELIT_FOBJDATAFMT_AXIS              0x00000003
+
+#define FEELIT_FOBJDATAFMT_PSHBUTTON         0x00000004
+#define FEELIT_FOBJDATAFMT_TGLBUTTON         0x00000008
+#define FEELIT_FOBJDATAFMT_BUTTON            0x0000000C
+
+#define FEELIT_FOBJDATAFMT_POV               0x00000010
+
+#define FEELIT_FOBJDATAFMT_COLLECTION        0x00000040
+#define FEELIT_FOBJDATAFMT_NODATA            0x00000080
+#define FEELIT_FOBJDATAFMT_FFACTUATOR        0x01000000
+#define FEELIT_FOBJDATAFMT_FFEFFECTTRIGGER   0x02000000
+#define FEELIT_FOBJDATAFMT_NOCOLLECTION      0x00FFFF00
+
+#define FEELIT_FOBJDATAFMT_ANYINSTANCE       0x00FFFF00
+#define FEELIT_FOBJDATAFMT_INSTANCEMASK      FEELIT_FOBJDATAFMT_ANYINSTANCE
+
+
+/* Data Format Type Macros */
+#define FEELIT_OBJDATAFMT_MAKEINSTANCE(n)	((WORD)(n) << 8)
+#define FEELIT_OBJDATAFMT_GETTYPE(n)			LOBYTE(n)
+#define FEELIT_OBJDATAFMT_GETINSTANCE(n)		LOWORD((n) >> 8)
+#define FEELIT_OBJDATAFMT_ENUMCOLLECTION(n)	((WORD)(n) << 8)
+
+
+typedef struct _FEELIT_OBJECTDATAFORMAT {
+    const GUID *pguid;	/* Unique ID for the axis, button, or other input source. */
+    DWORD   dwOfs;		/* Offset in data packet where input source data is stored */
+    DWORD   dwType;		/* Device type describing the object. (FEELIT_FOBJDATAFMT_*) */
+    DWORD   dwFlags;	/* Aspect flags.  Zero or more of FEELIT_FDEVOBJINST_ASPECT* */
+} FEELIT_OBJECTDATAFORMAT, *LPFEELIT_OBJECTDATAFORMAT;
+typedef const FEELIT_OBJECTDATAFORMAT *LPCFEELIT_OBJECTDATAFORMAT;
+
+typedef struct _FEELIT_DATAFORMAT {
+    DWORD   dwSize;		/* sizeof( FEELIT_DATAFORMAT ) */
+    DWORD   dwObjSize;	/* sizeof( FEELIT_OBJECTDATAFORMAT ) */
+    DWORD   dwFlags;	/* One of FEELIT_FDATAFORMAT_* */
+    DWORD   dwDataSize;	/* Size, in bytes, of data packet returned by the device */
+    DWORD   dwNumObjs;	/* Number of object in the rgodf array */
+    LPFEELIT_OBJECTDATAFORMAT rgodf;	/* Ptr to array of FEELIT_OBJECTDATAFORMAT */
+} FEELIT_DATAFORMAT, *LPFEELIT_DATAFORMAT;
+typedef const FEELIT_DATAFORMAT *LPCFEELIT_DATAFORMAT;
+
+/* Data Format Flags */
+#define FEELIT_FDATAFORMAT_ABSAXIS            0x00000001
+#define FEELIT_FDATAFORMAT_RELAXIS            0x00000002
+
+/* Predefined Data Formats */
+extern const FEELIT_DATAFORMAT c_dfFeelitMouse;
+
+typedef struct FEELIT_DEVICEOBJECTINSTANCE {
+    DWORD   dwSize;					/* sizeof( FEELIT_DEVICEOBJECTINSTANCE ) */
+    GUID    guidType;				/* Optional unique ID indicating object type */
+    DWORD   dwOfs;					/* Offset within data format for data from this object */
+    DWORD   dwType;					/* Device type describing the object. (FEELIT_FOBJDATAFMT_*) */
+    DWORD   dwFlags;				/* Zero or more of FEELIT_FDEVOBJINST_* */
+    CHAR    tszName[MAX_PATH];		/* Name of object (e.g. "X-Axis") */
+    DWORD   dwFFMaxForce;			/* Mag. of max force created by actuator for this object */
+    DWORD   dwFFForceResolution;	/* Force resolution of the actuator for this object */
+    WORD    wCollectionNumber;		/* RESERVED */
+    WORD    wDesignatorIndex;		/* RESERVED */
+    WORD    wUsagePage;				/* HID usage page associated with the object */
+    WORD    wUsage;					/* HID usage associated with the object */
+    DWORD   dwDimension;			/* Dimensional units in which object's value is reported */
+    WORD    wExponent;				/* Exponent to associate with the demension */
+    WORD    wReserved;
+} FEELIT_DEVICEOBJECTINSTANCE, *LPFEELIT_DEVICEOBJECTINSTANCE;
+typedef const FEELIT_DEVICEOBJECTINSTANCE  *LPCFEELIT_DEVICEOBJECTINSTANCE;
+
+typedef BOOL (FAR PASCAL * LPFEELIT_ENUMDEVICEOBJECTSCALLBACK)(LPCFEELIT_DEVICEOBJECTINSTANCE, LPVOID);
+
+/* Device Object Instance Flags */
+#define FEELIT_FDEVOBJINST_FFACTUATOR        0x00000001
+#define FEELIT_FDEVOBJINST_FFEFFECTTRIGGER   0x00000002
+#define FEELIT_FDEVOBJINST_POLLED            0x00008000
+#define FEELIT_FDEVOBJINST_ASPECTPOSITION    0x00000100
+#define FEELIT_FDEVOBJINST_ASPECTVELOCITY    0x00000200
+#define FEELIT_FDEVOBJINST_ASPECTACCEL       0x00000300
+#define FEELIT_FDEVOBJINST_ASPECTFORCE       0x00000400
+#define FEELIT_FDEVOBJINST_ASPECTMASK        0x00000F00
+
+typedef struct FEELIT_PROPHEADER {
+    DWORD   dwSize;			/* Size of enclosing struct, to which this struct is header */
+    DWORD   dwHeaderSize;	/* sizeof ( FEELIT_PROPHEADER ) */
+    DWORD   dwObj;			/* Object for which the property is to be accessed */
+    DWORD   dwHow;			/* Specifies how dwObj is interpreted. ( FEELIT_FPROPHEADER_* ) */
+} FEELIT_PROPHEADER, *LPFEELIT_PROPHEADER;
+typedef const FEELIT_PROPHEADER *LPCFEELIT_PROPHEADER;
+
+/* Prop header flags */
+#define FEELIT_FPROPHEADER_DEVICE             0
+#define FEELIT_FPROPHEADER_BYOFFSET           1
+#define FEELIT_FPROPHEADER_BYID               2
+
+typedef struct FEELIT_PROPDWORD {
+    FEELIT_PROPHEADER feelitph;	/* Feelit property header struct */
+    DWORD   dwData;				/* Property-specific value being retrieved */
+} FEELIT_PROPDWORD, *LPFEELIT_PROPDWORD;
+typedef const FEELIT_PROPDWORD *LPCFEELIT_PROPDWORD;
+
+typedef struct FEELIT_PROPRANGE {
+    FEELIT_PROPHEADER feelitph;	/* Feelit property header struct */
+    LONG    lMin;				/* Lower limit of range, inclusive */
+    LONG    lMax;				/* Upper limit of range, inclusive */
+} FEELIT_PROPRANGE, *LPFEELIT_PROPRANGE;
+typedef const FEELIT_PROPRANGE *LPCFEELIT_PROPRANGE;
+
+#define FEELIT_PROPRANGE_NOMIN       ((LONG)0x80000000)
+#define FEELIT_PROPRANGE_NOMAX       ((LONG)0x7FFFFFFF)
+
+
+#ifdef __cplusplus
+#define MAKE_FEELIT_PROP(prop)    (*(const GUID *)(prop))
+#else
+#define MAKE_FEELIT_PROP(prop)    ((REFGUID)(prop))
+#endif
+
+#define FEELIT_PROP_BUFFERSIZE       MAKE_FEELIT_PROP(1)
+#define FEELIT_PROP_AXISMODE         MAKE_FEELIT_PROP(2)
+#define FEELIT_PROP_GRANULARITY      MAKE_FEELIT_PROP(3)
+#define FEELIT_PROP_RANGE            MAKE_FEELIT_PROP(4)
+#define FEELIT_PROP_DEADZONE         MAKE_FEELIT_PROP(5)
+#define FEELIT_PROP_SATURATION       MAKE_FEELIT_PROP(6)
+#define FEELIT_PROP_FFGAIN           MAKE_FEELIT_PROP(7)
+#define FEELIT_PROP_FFLOAD           MAKE_FEELIT_PROP(8)
+#define FEELIT_PROP_AUTOCENTER       MAKE_FEELIT_PROP(9)
+#define FEELIT_PROP_CALIBRATIONMODE  MAKE_FEELIT_PROP(10)
+#define FEELIT_PROP_DEVICEGAIN       MAKE_FEELIT_PROP(11)
+#define FEELIT_PROP_BALLISTICS       MAKE_FEELIT_PROP(12)
+#define FEELIT_PROP_SCREENSIZE       MAKE_FEELIT_PROP(13)
+#define FEELIT_PROP_ABSOLUTEMODE     MAKE_FEELIT_PROP(14)
+#define FEELIT_PROP_DEVICEMODE       MAKE_FEELIT_PROP(15)
+#define FEELIT_PROP_NUMEFFECTS       MAKE_FEELIT_PROP(16)
+#define FEELIT_PROP_DEVICEID         MAKE_FEELIT_PROP(17)
+
+#define FEELIT_PROPAXISMODE_ABS      0
+#define FEELIT_PROPAXISMODE_REL      1
+
+#define FEELIT_PROPAUTOCENTER_OFF    0
+#define FEELIT_PROPAUTOCENTER_ON     1
+
+#define FEELIT_PROPCALIBRATIONMODE_COOKED    0
+#define FEELIT_PROPCALIBRATIONMODE_RAW       1
+
+// Device configuration/control, for use by control panels
+typedef struct FEELIT_PROPBALLISTICS {
+    FEELIT_PROPHEADER feelitph;	/* Feelit property header struct */
+    INT   Sensitivity;			/* Property-specific value */
+    INT   LowThreshhold;		/* Property-specific value */
+    INT   HighThreshhold;		/* Property-specific value */
+} FEELIT_PROPBALLISTICS, *LPFEELIT_PROPBALLISTICS;
+typedef const FEELIT_PROPBALLISTICS *LPCFEELIT_PROPBALLISTICS;
+
+typedef struct FEELIT_PROPSCREENSIZE {
+    FEELIT_PROPHEADER feelitph;	/* Feelit property header struct */
+    DWORD   dwXScreenSize;		/* Max X screen coord value */
+    DWORD   dwYScreenSize;		/* Max Y screen coord value */
+} FEELIT_PROPSCREENSIZE, *LPFEELIT_PROPSCREENSIZE;
+typedef const FEELIT_PROPSCREENSIZE *LPCFEELIT_PROPSCREENSIZE;
+
+typedef struct FEELIT_PROPABSOLUTEMODE {
+	FEELIT_PROPHEADER feelitph;	/* Feelit property header struct */
+	BOOL bAbsMode;				/* TRUE for Absolute mode FALSE for Relative mode */
+} FEELIT_PROPABSOLUTEMODE, *LPFEELIT_PROPABSOLUTEMODE;
+typedef const FEELIT_PROPABSOLUTEMODE *LPCFEELIT_PROPABSOLUTEMODE;
+
+#define FEELIT_PROPDEVICEMODE_MOUSE       1			
+#define FEELIT_PROPDEVICEMODE_JOYSTICK    2
+
+// Number of effects.  This is the number of effects (not the number of effect types)
+// that can be downloaded to a device.  dwTotalEffects includes any caching cababilities
+// of the driver.  dwHardwareEffects is strictly the number of effects that can be
+// stored in the device hardware.  Pay attention to dwHardwareEffects only if you're
+// worried about optimizing for speed.
+typedef struct FEELIT_PROPNUMEFFECTS {
+    FEELIT_PROPHEADER feelitph;	/* Feelit property header struct */
+    DWORD   dwTotalEffects;	    /* Total number of effects a device driver can support */
+    DWORD   dwHardwareEffects;	/* Number of effects the device hardware can hold */
+} FEELIT_PROPNUMEFFECTS, *LPFEELIT_PROPNUMEFFECTS;
+typedef const FEELIT_PROPNUMEFFECTS *LPCFEELIT_PROPNUMEFFECTS;
+
+
+typedef struct FEELIT_DEVICEOBJECTDATA {
+    DWORD   dwOfs;			/* Offset into current data format of this data's object */
+    DWORD   dwData;			/* Data obtained from the device */
+    DWORD   dwTimeStamp;	/* Tick count, in milliseconds, at which event was generated */
+    DWORD   dwSequence;		/* Sequence number for this event */
+} FEELIT_DEVICEOBJECTDATA, *LPFEELIT_DEVICEOBJECTDATA;
+typedef const FEELIT_DEVICEOBJECTDATA *LPCFEELIT_DEVICEOBJECTDATA;
+
+#define FEELIT_SEQUENCE_COMPARE(dwSequence1, cmp, dwSequence2) \
+                        ((int)((dwSequence1) - (dwSequence2)) cmp 0)
+
+/* GetDeviceData Flags */
+#define FEELIT_FGETDEVDATA_PEEK          0x00000001
+
+/* Cooperative Level Flags */
+#define FEELIT_FCOOPLEVEL_EXCLUSIVE			    0x00000001
+#define FEELIT_FCOOPLEVEL_NONEXCLUSIVE		    0x00000002
+#define FEELIT_FCOOPLEVEL_FOREGROUND			0x00000004
+#define FEELIT_FCOOPLEVEL_BACKGROUND			0x00000008
+
+typedef struct FEELIT_DEVICEINSTANCE {
+    DWORD   dwSize;						/* sizeof ( FEELIT_DEVICEINSTANCE ) */
+    GUID    guidInstance;				/* Unique id for instance of device */
+    GUID    guidProduct;				/* Unique id for the product */
+    DWORD   dwDevType;					/* Device type (FEELIT_DEVICETYPE*) */
+    CHAR    tszInstanceName[MAX_PATH];	/* Friendly name for the instance (e.g. "Feelit Mouse 1") */
+    CHAR    tszProductName[MAX_PATH];	/* Friendly name for the product (e.g. "Feelit Mouse") */
+    GUID    guidFFDriver;				/* Unique id for the driver being used for force feedback */
+    WORD    wUsagePage;					/* HID usage page code (if the device driver is a HID device) */
+    WORD    wUsage;						/* HID usage code (if the device driver is a HID device) */
+} FEELIT_DEVICEINSTANCE, *LPFEELIT_DEVICEINSTANCE;
+typedef const FEELIT_DEVICEINSTANCE  *LPCFEELIT_DEVICEINSTANCE;
+
+#define FEELIT_FCOMMAND_RESET            0x00000001
+#define FEELIT_FCOMMAND_STOPALL          0x00000002
+#define FEELIT_FCOMMAND_PAUSE            0x00000004
+#define FEELIT_FCOMMAND_CONTINUE         0x00000008
+#define FEELIT_FCOMMAND_SETACTUATORSON   0x00000010
+#define FEELIT_FCOMMAND_SETACTUATORSOFF  0x00000020
+
+#define FEELIT_FDEVICESTATE_EMPTY            0x00000001
+#define FEELIT_FDEVICESTATE_STOPPED          0x00000002
+#define FEELIT_FDEVICESTATE_PAUSED           0x00000004
+#define FEELIT_FDEVICESTATE_ACTUATORSON      0x00000010
+#define FEELIT_FDEVICESTATE_ACTUATORSOFF     0x00000020
+#define FEELIT_FDEVICESTATE_POWERON          0x00000040
+#define FEELIT_FDEVICESTATE_POWEROFF         0x00000080
+#define FEELIT_FDEVICESTATE_SAFETYSWITCHON   0x00000100
+#define FEELIT_FDEVICESTATE_SAFETYSWITCHOFF  0x00000200
+#define FEELIT_FDEVICESTATE_USERFFSWITCHON   0x00000400
+#define FEELIT_FDEVICESTATE_USERFFSWITCHOFF  0x00000800
+#define FEELIT_FDEVICESTATE_DEVICELOST       0x80000000
+
+typedef struct FEELIT_EFFECTINFO {
+    DWORD   dwSize;				/* sizeof( FEELIT_EFFECTINFO ) */
+    GUID    guid;				/* Unique ID of the effect */
+    DWORD   dwEffType;			/* Zero or more of FEELIT_FEFFECTTYPE_* */
+    DWORD   dwStaticParams;		/* All params supported. Zero or more of FEELIT_FPARAM_* */
+    DWORD   dwDynamicParams;	/* Params modifiable while effect playing. (FEELIT_FPARAM_*) */
+    CHAR    tszName[MAX_PATH];	/* Name of effect (e.g. "Enclosure" ) */
+} FEELIT_EFFECTINFO, *LPFEELIT_EFFECTINFO;
+typedef const FEELIT_EFFECTINFO  *LPCFEELIT_EFFECTINFO;
+
+typedef BOOL (FAR PASCAL * LPFEELIT_ENUMEFFECTSCALLBACK)(LPCFEELIT_EFFECTINFO, LPVOID);
+typedef BOOL (FAR PASCAL * LPFEELIT_ENUMCREATEDEFFECTOBJECTSCALLBACK)(LPFEELIT_EFFECT, LPVOID);
+
+
+/*
+				Feelit Events
+
+Feelit events are defined using a FEELIT_EVENT struct.  They are created by 
+passing the struct to CreateFeelitEvent, which returns an HFEELITEVENT handle.
+Feelit notifies clients that Feelit Event has triggered by sending a message to
+the window handle associated with the event.  Window handles are associated with
+events using the hWndEventHandler param. of the FEELIT_EVENT struct. The window 
+message that Feelit sends to notify of an event, contains information in the
+WPARAM and LPARAM as described below.
+
+DURING INITIALIZATION:
+const UINT g_wmFeelitEvent = RegisterWindowMessage( FEELIT_EVENT_MSG_STRING );
+
+IN MESSAGE LOOP:
+if ( msgID == g_wmFeelitEvent )
+{
+    WORD wRef = LOWORD(wParam);				// 16-bit app-defined event id
+    WORD wfTriggers = HIWORD(wParam);		// Trigger Flags
+    short xForce = (short) LOWORD(lParam);	// Force applied along X-axis
+    short yForce = (short) HIWORD(lParam);	// Force applied along Y-axis
+}
+
+*/
+
+#define FEELIT_EVENT_MSG_STRING  "FEELIT_EVENT_MSG"
+
+typedef HANDLE HFEELITEVENT, *LPHFEELITEVENT;		/* Handle type used to manage Feelit Events */
+
+typedef struct FEELIT_EVENT {
+   DWORD dwSize;                   /* sizeof(FEELIT_EVENT) */
+   HWND hWndEventHandler;			/* Handle of window to which event msgs are sent */
+   WORD wRef;						/* 16-bit app-defined value to identify the event to the app */
+   DWORD dwEventTriggerMask;		/* Mask specifying events which trigger the callback  (FEELIT_FTRIG*) */
+   LPIFEELIT_EFFECT	piEffect;		/* Effect, if any, that this event is associated with */
+} FEELIT_EVENT, *LPFEELIT_EVENT;
+
+typedef const FEELIT_EVENT *LPCFEELIT_EVENT;
+
+
+/* Event Trigger Flags */
+
+#define FEELIT_FTRIG_NONE			0x00000000
+#define FEELIT_FTRIG_ENTER 		    0x00000001
+#define FEELIT_FTRIG_EXIT      	    0x00000002
+#define FEELIT_FTRIG_OUTER		    0x00000004
+#define FEELIT_FTRIG_INBOUND		FEELIT_FTRIG_OUTER
+#define FEELIT_FTRIG_INNER  	    0x00000008
+#define FEELIT_FTRIG_OUTBOUND  	    FEELIT_FTRIG_INNER
+#define FEELIT_FTRIG_TOPWALL		0x00000010
+#define FEELIT_FTRIG_BOTTOMWALL	    0x00000020
+#define FEELIT_FTRIG_LEFTWALL		0x00000040
+#define FEELIT_FTRIG_RIGHTWALL	    0x00000080
+#define FEELIT_FTRIG_ANYWALL		( FEELIT_FTRIG_TOPWALL | FEELIT_FTRIG_BOTTOMWALL | FEELIT_FTRIG_LEFTWALL | FEELIT_FTRIG_RIGHTWALL )
+#define FEELIT_FTRIG_ONENTERANY		( FEELIT_FTRIG_ENTER | FEELIT_FTRIG_ANYWALL )
+#define FEELIT_FTRIG_ONEXITANY		( FEELIT_FTRIG_EXIT | FEELIT_FTRIG_ANYWALL )
+#define FEELIT_FTRIG_ONOUTERANY		( FEELIT_FTRIG_OUTER | FEELIT_FTRIG_ANYWALL )
+#define FEELIT_FTRIG_ONINBOUNDANY	FEELIT_FTRIG_ONOUTERANY
+#define FEELIT_FTRIG_ONINNERANY		( FEELIT_FTRIG_INNER | FEELIT_FTRIG_ANYWALL )
+#define FEELIT_FTRIG_ONOUTBOUNDANY	FEELIT_FTRIG_ONINNERANY
+#define FEELIT_FTRIG_ONANYENCLOSURE ( FEELIT_FTRIG_ONENTERANY | FEELIT_FTRIG_ONEXITANY | FEELIT_FTRIG_ONOUTERANY | FEELIT_FTRIG_ONINNERANY )
+
+#define FEELIT_FTRIG_ONSCROLL			0x0000100
+#define FEELIT_FTRIG_ONEFFECTCOMPLETION	0x0000200
+
+#undef INTERFACE
+#define INTERFACE IFeelitDevice
+
+DECLARE_INTERFACE_(IFeelitDevice, IUnknown)
+{
+    /*** IUnknown methods ***/
+    STDMETHOD(QueryInterface)(THIS_ REFIID riid, LPVOID * ppvObj) PURE;
+    STDMETHOD_(ULONG,AddRef)(THIS) PURE;
+    STDMETHOD_(ULONG,Release)(THIS) PURE;
+
+    /*** IFeelitDevice methods ***/
+    STDMETHOD(GetCapabilities)(THIS_ LPFEELIT_DEVCAPS) PURE;
+    STDMETHOD(EnumObjects)(THIS_ LPFEELIT_ENUMDEVICEOBJECTSCALLBACK,LPVOID,DWORD) PURE;
+    STDMETHOD(GetProperty)(THIS_ REFGUID,LPFEELIT_PROPHEADER) PURE;
+    STDMETHOD(SetProperty)(THIS_ REFGUID,LPCFEELIT_PROPHEADER) PURE;
+    STDMETHOD(Acquire)(THIS) PURE;
+    STDMETHOD(Unacquire)(THIS) PURE;
+    STDMETHOD(GetDeviceState)(THIS_ DWORD,LPVOID) PURE;
+    STDMETHOD(GetDeviceData)(THIS_ DWORD,LPFEELIT_DEVICEOBJECTDATA,LPDWORD,DWORD) PURE;
+    STDMETHOD(SetDataFormat)(THIS_ LPCFEELIT_DATAFORMAT) PURE;
+    STDMETHOD(SetEventNotification)(THIS_ HANDLE) PURE;
+    STDMETHOD(SetCooperativeLevel)(THIS_ HWND,DWORD) PURE;
+    STDMETHOD(GetObjectInfo)(THIS_ LPFEELIT_DEVICEOBJECTINSTANCE,DWORD,DWORD) PURE;
+    STDMETHOD(GetDeviceInfo)(THIS_ LPFEELIT_DEVICEINSTANCE) PURE;
+    STDMETHOD(RunControlPanel)(THIS_ HWND,DWORD) PURE;
+    STDMETHOD(CreateEffect)(THIS_ LPCFEELIT_EFFECT,LPIFEELIT_EFFECT *,LPUNKNOWN) PURE;
+    STDMETHOD(EnumEffects)(THIS_ LPFEELIT_ENUMEFFECTSCALLBACK,LPVOID,DWORD) PURE;
+    STDMETHOD(GetEffectInfo)(THIS_ LPFEELIT_EFFECTINFO,REFGUID) PURE;
+    STDMETHOD(GetForceFeedbackState)(THIS_ LPDWORD) PURE;
+    STDMETHOD(SendForceFeedbackCommand)(THIS_ DWORD) PURE;
+    STDMETHOD(EnumCreatedEffectObjects)(THIS_ LPFEELIT_ENUMCREATEDEFFECTOBJECTSCALLBACK,LPVOID,DWORD) PURE;
+    STDMETHOD(Escape)(THIS_ LPFEELIT_EFFESCAPE) PURE;
+    STDMETHOD(Poll)(THIS) PURE;
+    STDMETHOD(SendDeviceData)(THIS_ DWORD,LPFEELIT_DEVICEOBJECTDATA,LPDWORD,DWORD) PURE;
+    STDMETHOD(CreateFeelitEvent)(THIS_ LPCFEELIT_EVENT,LPHFEELITEVENT) PURE;
+    STDMETHOD(DestroyFeelitEvent)(THIS_ HFEELITEVENT) PURE;
+    STDMETHOD(EnableFeelitEvent)(THIS_ HFEELITEVENT,BOOL) PURE;
+    STDMETHOD(SetEventNotificationPeriodicity)(THIS_ DWORD) PURE;
+};
+
+typedef struct IFeelitDevice *LPIFEELIT_DEVICE;
+
+#if !defined(__cplusplus) || defined(CINTERFACE)
+#define IFeelitDevice_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IFeelitDevice_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IFeelitDevice_Release(p) (p)->lpVtbl->Release(p)
+#define IFeelitDevice_GetCapabilities(p,a) (p)->lpVtbl->GetCapabilities(p,a)
+#define IFeelitDevice_EnumObjects(p,a,b,c) (p)->lpVtbl->EnumObjects(p,a,b,c)
+#define IFeelitDevice_GetProperty(p,a,b) (p)->lpVtbl->GetProperty(p,a,b)
+#define IFeelitDevice_SetProperty(p,a,b) (p)->lpVtbl->SetProperty(p,a,b)
+#define IFeelitDevice_Acquire(p) (p)->lpVtbl->Acquire(p)
+#define IFeelitDevice_Unacquire(p) (p)->lpVtbl->Unacquire(p)
+#define IFeelitDevice_GetDeviceState(p,a,b) (p)->lpVtbl->GetDeviceState(p,a,b)
+#define IFeelitDevice_GetDeviceData(p,a,b,c,d) (p)->lpVtbl->GetDeviceData(p,a,b,c,d)
+#define IFeelitDevice_SetDataFormat(p,a) (p)->lpVtbl->SetDataFormat(p,a)
+#define IFeelitDevice_SetEventNotification(p,a) (p)->lpVtbl->SetEventNotification(p,a)
+#define IFeelitDevice_SetCooperativeLevel(p,a,b) (p)->lpVtbl->SetCooperativeLevel(p,a,b)
+#define IFeelitDevice_GetObjectInfo(p,a,b,c) (p)->lpVtbl->GetObjectInfo(p,a,b,c)
+#define IFeelitDevice_GetDeviceInfo(p,a) (p)->lpVtbl->GetDeviceInfo(p,a)
+#define IFeelitDevice_RunControlPanel(p,a,b) (p)->lpVtbl->RunControlPanel(p,a,b)
+#define IFeelitDevice_CreateEffect(p,a,b,c,d) (p)->lpVtbl->CreateEffect(p,a,b,c,d)
+#define IFeelitDevice_EnumEffects(p,a,b,c) (p)->lpVtbl->EnumEffects(p,a,b,c)
+#define IFeelitDevice_GetEffectInfo(p,a,b) (p)->lpVtbl->GetEffectInfo(p,a,b)
+#define IFeelitDevice_GetForceFeedbackState(p,a) (p)->lpVtbl->GetForceFeedbackState(p,a)
+#define IFeelitDevice_SendForceFeedbackCommand(p,a) (p)->lpVtbl->SendForceFeedbackCommand(p,a)
+#define IFeelitDevice_EnumCreatedEffectObjects(p,a,b,c) (p)->lpVtbl->EnumCreatedEffectObjects(p,a,b,c)
+#define IFeelitDevice_Escape(p,a) (p)->lpVtbl->Escape(p,a)
+#define IFeelitDevice_Poll(p) (p)->lpVtbl->Poll(p)
+#define IFeelitDevice_SendDeviceData(p,a,b,c,d) (p)->lpVtbl->SendDeviceData(p,a,b,c,d)
+#define IFeelitDevice_CreateFeelitEvent(p,a,b) (p)->lpVtbl->CreateFeelitEvent(p,a,b)
+#define IFeelitDevice_DestroyFeelitEvent(p,a) (p)->lpVtbl->DestroyFeelitEvent(p,a)
+#define IFeelitDevice_EnableFeelitEvent(p,a,b) (p)->lpVtbl->EnableFeelitEvent(p,a,b)
+#define IFeelitDevice_SetEventNotificationPeriodicity(p,a) (p)->lpVtbl->SetEventNotificationPeriodicity(p,a)
+#else
+#define IFeelitDevice_QueryInterface(p,a,b) (p)->QueryInterface(a,b)
+#define IFeelitDevice_AddRef(p) (p)->AddRef()
+#define IFeelitDevice_Release(p) (p)->Release()
+#define IFeelitDevice_GetCapabilities(p,a) (p)->GetCapabilities(a)
+#define IFeelitDevice_EnumObjects(p,a,b,c) (p)->EnumObjects(a,b,c)
+#define IFeelitDevice_GetProperty(p,a,b) (p)->GetProperty(a,b)
+#define IFeelitDevice_SetProperty(p,a,b) (p)->SetProperty(a,b)
+#define IFeelitDevice_Acquire(p) (p)->Acquire()
+#define IFeelitDevice_Unacquire(p) (p)->Unacquire()
+#define IFeelitDevice_GetDeviceState(p,a,b) (p)->GetDeviceState(a,b)
+#define IFeelitDevice_GetDeviceData(p,a,b,c,d) (p)->GetDeviceData(a,b,c,d)
+#define IFeelitDevice_SetDataFormat(p,a) (p)->SetDataFormat(a)
+#define IFeelitDevice_SetEventNotification(p,a) (p)->SetEventNotification(a)
+#define IFeelitDevice_SetCooperativeLevel(p,a,b) (p)->SetCooperativeLevel(a,b)
+#define IFeelitDevice_GetObjectInfo(p,a,b,c) (p)->GetObjectInfo(a,b,c)
+#define IFeelitDevice_GetDeviceInfo(p,a) (p)->GetDeviceInfo(a)
+#define IFeelitDevice_RunControlPanel(p,a,b) (p)->RunControlPanel(a,b)
+#define IFeelitDevice_CreateEffect(p,a,b,c,d) (p)->CreateEffect(a,b,c,d)
+#define IFeelitDevice_EnumEffects(p,a,b,c) (p)->EnumEffects(a,b,c)
+#define IFeelitDevice_GetEffectInfo(p,a,b) (p)->GetEffectInfo(a,b)
+#define IFeelitDevice_GetForceFeedbackState(p,a) (p)->GetForceFeedbackState(a)
+#define IFeelitDevice_SendForceFeedbackCommand(p,a) (p)->SendForceFeedbackCommand(a)
+#define IFeelitDevice_EnumCreatedEffectObjects(p,a,b,c) (p)->EnumCreatedEffectObjects(a,b,c)
+#define IFeelitDevice_Escape(p,a) (p)->Escape(a)
+#define IFeelitDevice_Poll(p) (p)->Poll()
+#define IFeelitDevice_SendDeviceData(p,a,b,c,d) (p)->SendDeviceData(a,b,c,d)
+#define IFeelitDevice_CreateFeelitEvent(p,a,b) (p)->CreateFeelitEvent(a,b)
+#define IFeelitDevice_DestroyFeelitEvent(p,a) (p)->DestroyFeelitEvent(a)
+#define IFeelitDevice_EnableFeelitEvent(p,a,b) (p)->EnableFeelitEvent(a,b)
+#define IFeelitDevice_SetEventNotificationPeriodicity(p,a) (p)->SetEventNotificationPeriodicity(a)
+#endif
+
+/****************************************************************************
+ *
+ *      Mouse State
+ *
+ ****************************************************************************/
+
+typedef struct _FEELIT_MOUSESTATE {
+    LONG    lXpos;
+    LONG    lYpos;
+    LONG    lZpos;
+    LONG    lXforce;
+    LONG    lYforce;
+    LONG    lZforce;
+    BYTE    rgbButtons[4];
+} FEELIT_MOUSESTATE, *LPFEELIT_MOUSESTATE;
+
+#define FEELIT_MOUSEOFFSET_XAXIS		FIELD_OFFSET(FEELIT_MOUSESTATE, lXpos)
+#define FEELIT_MOUSEOFFSET_YAXIS     FIELD_OFFSET(FEELIT_MOUSESTATE, lYpos)
+#define FEELIT_MOUSEOFFSET_ZAXIS     FIELD_OFFSET(FEELIT_MOUSESTATE, lZpos)
+#define FEELIT_MOUSEOFFSET_XFORCE    FIELD_OFFSET(FEELIT_MOUSESTATE, lXforce)
+#define FEELIT_MOUSEOFFSET_YFORCE    FIELD_OFFSET(FEELIT_MOUSESTATE, lYforce)
+#define FEELIT_MOUSEOFFSET_ZFORCE    FIELD_OFFSET(FEELIT_MOUSESTATE, lZforce)
+#define FEELIT_MOUSEOFFSET_BUTTON0	(FIELD_OFFSET(FEELIT_MOUSESTATE, rgbButtons) + 0)
+#define FEELIT_MOUSEOFFSET_BUTTON1	(FIELD_OFFSET(FEELIT_MOUSESTATE, rgbButtons) + 1)
+#define FEELIT_MOUSEOFFSET_BUTTON2	(FIELD_OFFSET(FEELIT_MOUSESTATE, rgbButtons) + 2)
+#define FEELIT_MOUSEOFFSET_BUTTON3	(FIELD_OFFSET(FEELIT_MOUSESTATE, rgbButtons) + 3)
+
+
+/****************************************************************************
+ *
+ *  IFeelit
+ *
+ ****************************************************************************/
+
+#define FEELIT_ENUM_STOP             0
+#define FEELIT_ENUM_CONTINUE         1
+
+typedef BOOL (FAR PASCAL * LPFEELIT_ENUMDEVICESCALLBACK)(LPCFEELIT_DEVICEINSTANCE, LPVOID);
+
+#define FEELIT_FENUMDEV_ALLDEVICES       0x00000000
+#define FEELIT_FENUMDEV_ATTACHEDONLY     0x00000001
+#define FEELIT_FENUMDEV_FORCEFEEDBACK    0x00000100
+
+#undef INTERFACE
+#define INTERFACE IFeelit
+
+DECLARE_INTERFACE_(IFeelit, IUnknown)
+{
+    /*** IUnknown methods ***/
+    STDMETHOD(QueryInterface)(THIS_ REFIID riid, LPVOID * ppvObj) PURE;
+    STDMETHOD_(ULONG,AddRef)(THIS) PURE;
+    STDMETHOD_(ULONG,Release)(THIS) PURE;
+
+    /*** IFeelit methods ***/
+    STDMETHOD(CreateDevice)(THIS_ REFGUID,LPIFEELIT_DEVICE *,LPUNKNOWN) PURE;
+    STDMETHOD(EnumDevices)(THIS_ DWORD,LPFEELIT_ENUMDEVICESCALLBACK,LPVOID,DWORD) PURE;
+    STDMETHOD(GetDeviceStatus)(THIS_ REFGUID) PURE;
+    STDMETHOD(RunControlPanel)(THIS_ HWND,DWORD) PURE;
+    STDMETHOD(Initialize)(THIS_ HINSTANCE,DWORD) PURE;
+};
+
+typedef struct IFeelit *LPIFEELIT;
+
+#if !defined(__cplusplus) || defined(CINTERFACE)
+#define IFeelit_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IFeelit_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IFeelit_Release(p) (p)->lpVtbl->Release(p)
+#define IFeelit_CreateDevice(p,a,b,c) (p)->lpVtbl->CreateDevice(p,a,b,c)
+#define IFeelit_EnumDevices(p,a,b,c,d) (p)->lpVtbl->EnumDevices(p,a,b,c,d)
+#define IFeelit_GetDeviceStatus(p,a) (p)->lpVtbl->GetDeviceStatus(p,a)
+#define IFeelit_RunControlPanel(p,a,b) (p)->lpVtbl->RunControlPanel(p,a,b)
+#define IFeelit_Initialize(p,a,b) (p)->lpVtbl->Initialize(p,a,b)
+#define IFeelit_FindDevice(p,a,b,c) (p)->lpVtbl->FindDevice(p,a,b,c)
+#endif
+
+extern HRESULT WINAPI FeelitCreateA(HINSTANCE hinst, DWORD dwVersion, LPIFEELIT *ppFeelit, LPUNKNOWN punkOuter);
+#define FeelitCreate FeelitCreateA
+
+
+/****************************************************************************
+ *
+ *  Return Codes
+ *
+ ****************************************************************************/
+
+/*
+ *  The operation completed successfully.
+ */
+#define FEELIT_RESULT_OK                           S_OK
+
+/*
+ *  The device exists but is not currently attached.
+ */
+#define FEELIT_RESULT_NOTATTACHED                  S_FALSE
+
+/*
+ *  The device buffer overflowed.  Some input was lost.
+ */
+#define FEELIT_RESULT_BUFFEROVERFLOW               S_FALSE
+
+/*
+ *  The change in device properties had no effect.
+ */
+#define FEELIT_RESULT_PROPNOEFFECT                 S_FALSE
+
+/*
+ *  The operation had no effect.
+ */
+#define FEELIT_RESULT_NOEFFECT                     S_FALSE
+
+/*
+ *  The device is a polled device.  As a result, device buffering
+ *  will not collect any data and event notifications will not be
+ *  signalled until GetDeviceState is called.
+ */
+#define FEELIT_RESULT_POLLEDDEVICE                 ((HRESULT)0x00000002L)
+
+/*
+ *  The parameters of the effect were successfully updated by
+ *  IFeelitEffect::SetParameters, but the effect was not
+ *  downloaded because the device is not exclusively acquired
+ *  or because the FEELIT_FPARAM_NODOWNLOAD flag was passed.
+ */
+#define FEELIT_RESULT_DOWNLOADSKIPPED              ((HRESULT)0x00000003L)
+
+/*
+ *  The parameters of the effect were successfully updated by
+ *  IFeelitEffect::SetParameters, but in order to change
+ *  the parameters, the effect needed to be restarted.
+ */
+#define FEELIT_RESULT_EFFECTRESTARTED              ((HRESULT)0x00000004L)
+
+/*
+ *  The parameters of the effect were successfully updated by
+ *  IFeelitEffect::SetParameters, but some of them were
+ *  beyond the capabilities of the device and were truncated.
+ */
+#define FEELIT_RESULT_TRUNCATED                    ((HRESULT)0x00000008L)
+
+/*
+ *  Equal to FEELIT_RESULT_EFFECTRESTARTED | FEELIT_RESULT_TRUNCATED.
+ */
+#define FEELIT_RESULT_TRUNCATEDANDRESTARTED        ((HRESULT)0x0000000CL)
+
+/*
+ *  The application requires a newer version of Feelit.
+ */
+#define FEELIT_ERROR_OLDFEELITVERSION     \
+    MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, ERROR_OLD_WIN_VERSION)
+
+/*
+ *  The application was written for an unsupported prerelease version
+ *  of Feelit.
+ */
+#define FEELIT_ERROR_BETAFEELITVERSION    \
+    MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, ERROR_RMODE_APP)
+
+/*
+ *  The object could not be created due to an incompatible driver version
+ *  or mismatched or incomplete driver components.
+ */
+#define FEELIT_ERROR_BADDRIVERVER              \
+    MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, ERROR_BAD_DRIVER_LEVEL)
+
+/*
+ * The device or device instance or effect is not registered with Feelit.
+ */
+#define FEELIT_ERROR_DEVICENOTREG              REGDB_E_CLASSNOTREG
+
+/*
+ * The requested object does not exist.
+ */
+#define FEELIT_ERROR_NOTFOUND                  \
+    MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, ERROR_FILE_NOT_FOUND)
+
+/*
+ * The requested object does not exist.
+ */
+#define FEELIT_ERROR_OBJECTNOTFOUND            \
+    MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, ERROR_FILE_NOT_FOUND)
+
+/*
+ * An invalid parameter was passed to the returning function,
+ * or the object was not in a state that admitted the function
+ * to be called.
+ */
+#define FEELIT_ERROR_INVALIDPARAM              E_INVALIDARG
+
+/*
+ * The specified interface is not supported by the object
+ */
+#define FEELIT_ERROR_NOINTERFACE               E_NOINTERFACE
+
+/*
+ * An undetermined error occured inside the Feelit subsystem
+ */
+#define FEELIT_ERROR_GENERIC                   E_FAIL
+
+/*
+ * The Feelit subsystem couldn't allocate sufficient memory to complete the
+ * caller's request.
+ */
+#define FEELIT_ERROR_OUTOFMEMORY               E_OUTOFMEMORY
+
+/*
+ * The function called is not supported at this time
+ */
+#define FEELIT_ERROR_UNSUPPORTED               E_NOTIMPL
+
+/*
+ * This object has not been initialized
+ */
+#define FEELIT_ERROR_NOTINITIALIZED            \
+    MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, ERROR_NOT_READY)
+
+/*
+ * This object is already initialized
+ */
+#define FEELIT_ERROR_ALREADYINITIALIZED        \
+    MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, ERROR_ALREADY_INITIALIZED)
+
+/*
+ * This object does not support aggregation
+ */
+#define FEELIT_ERROR_NOAGGREGATION             CLASS_E_NOAGGREGATION
+
+/*
+ * Another app has a higher priority level, preventing this call from
+ * succeeding.
+ */
+#define FEELIT_ERROR_OTHERAPPHASPRIO           E_ACCESSDENIED
+
+/*
+ * Access to the device has been lost.  It must be re-acquired.
+ */
+#define FEELIT_ERROR_INPUTLOST                 \
+    MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, ERROR_READ_FAULT)
+
+/*
+ * The operation cannot be performed while the device is acquired.
+ */
+#define FEELIT_ERROR_ACQUIRED                  \
+    MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, ERROR_BUSY)
+
+/*
+ * The operation cannot be performed unless the device is acquired.
+ */
+#define FEELIT_ERROR_NOTACQUIRED               \
+    MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, ERROR_INVALID_ACCESS)
+
+/*
+ * The specified property cannot be changed.
+ */
+#define FEELIT_ERROR_READONLY                  E_ACCESSDENIED
+
+/*
+ * The device already has an event notification associated with it.
+ */
+#define FEELIT_ERROR_HANDLEEXISTS              E_ACCESSDENIED
+
+/*
+ * Data is not yet available.
+ */
+#ifndef E_PENDING
+#define E_PENDING                       0x80070007L
+#endif
+
+/*
+ * Unable to perform the requested operation because the user
+ * does not have sufficient privileges.
+ */
+#define FEELIT_ERROR_INSUFFICIENTPRIVS         0x80040200L
+
+/*
+ * The device is full.
+ */
+#define FEELIT_ERROR_DEVICEFULL                0x80040201L
+
+/*
+ * Not all the requested information fit into the buffer.
+ */
+#define FEELIT_ERROR_MOREDATA                  0x80040202L
+
+/*
+ * The effect is not downloaded.
+ */
+#define FEELIT_ERROR_NOTDOWNLOADED             0x80040203L
+
+/*
+ *  The device cannot be reinitialized because there are still effects
+ *  attached to it.
+ */
+#define FEELIT_ERROR_HASEFFECTS                0x80040204L
+
+/*
+ *  The operation cannot be performed unless the device is acquired
+ *  in FEELIT_FCOOPLEVEL_EXCLUSIVE mode.
+ */
+#define FEELIT_ERROR_NOTEXCLUSIVEACQUIRED      0x80040205L
+
+/*
+ *  The effect could not be downloaded because essential information
+ *  is missing.  For example, no axes have been associated with the
+ *  effect, or no type-specific information has been created.
+ */
+#define FEELIT_ERROR_INCOMPLETEEFFECT          0x80040206L
+
+/*
+ *  Attempted to read buffered device data from a device that is
+ *  not buffered.
+ */
+#define FEELIT_ERROR_NOTBUFFERED               0x80040207L
+
+/*
+ *  An attempt was made to modify parameters of an effect while it is
+ *  playing.  Not all hardware devices support altering the parameters
+ *  of an effect while it is playing.
+ */
+#define FEELIT_ERROR_EFFECTPLAYING             0x80040208L
+
+/*
+ *  An internal error occurred (inside the API or the driver)
+ */
+#define FEELIT_ERROR_INTERNAL             0x80040209L
+
+/*
+ *  Effect set referenced by a command is not the active set
+ */
+#define FEELIT_ERROR_INACTIVE             0x8004020AL
+
+#ifdef __cplusplus
+};
+#endif
+
+
+#endif  /* __FEELITAPI_INCLUDED__ */
+
diff --git a/code/ff/IFC/IFC.h b/code/ff/IFC/IFC.h
new file mode 100644
index 0000000..36fcf4c
--- /dev/null
+++ b/code/ff/IFC/IFC.h
@@ -0,0 +1,79 @@
+/**********************************************************************
+	Copyright (c) 1997 - 2000 Immersion Corporation
+
+	Permission to use, copy, modify, distribute, and sell this
+	software and its documentation may be granted without fee;
+	interested parties are encouraged to request permission from
+		Immersion Corporation
+		801 Fox Lane
+		San Jose, CA 95131
+		408-467-1900
+
+	IMMERSION DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+	INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.
+	IN NO EVENT SHALL IMMERSION BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+	CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+	LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+	NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+	CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+  FILE:		IFC.h
+
+  PURPOSE:	Class Types for the Force Foundation Classes
+
+  STARTED:	10/29/97
+
+  NOTES/REVISIONS:
+     3/2/99 jrm (Jeff Mallett): Force-->Feel renaming
+
+**********************************************************************/
+
+
+#if !defined(AFX_IFC_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_)
+#define AFX_IFC_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_
+
+#if _MSC_VER >= 1000
+#pragma once
+#endif // _MSC_VER >= 1000
+
+
+#include "ImmBox.h"
+#include "ImmCondition.h"
+#include "ImmConstant.h"
+#include "ImmDamper.h"
+#include "ImmDevice.h"
+#include "ImmDevices.h"
+#include "ImmDXDevice.h"
+#include "ImmEffect.h"
+#include "ImmEllipse.h"
+#include "ImmEnclosure.h"
+#include "ImmMouse.h"
+#include "ImmFriction.h"
+#include "ImmGrid.h"
+#include "ImmInertia.h"
+#include "ImmPeriodic.h"
+#include "ImmProjects.h"
+#include "ImmRamp.h"
+#include "ImmSpring.h"
+#include "ImmTexture.h"
+#include "IFCErrors.h"
+
+
+#endif // !defined(AFX_IFC_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/code/ff/IFC/IFC22.dll b/code/ff/IFC/IFC22.dll
new file mode 100644
index 0000000..44331c8
Binary files /dev/null and b/code/ff/IFC/IFC22.dll differ
diff --git a/code/ff/IFC/IFC22.lib b/code/ff/IFC/IFC22.lib
new file mode 100644
index 0000000..662c436
Binary files /dev/null and b/code/ff/IFC/IFC22.lib differ
diff --git a/code/ff/IFC/IFCErrors.h b/code/ff/IFC/IFCErrors.h
new file mode 100644
index 0000000..b25ff71
--- /dev/null
+++ b/code/ff/IFC/IFCErrors.h
@@ -0,0 +1,181 @@
+/**********************************************************************
+	Copyright (c) 1999 - 2000 Immersion Corporation
+
+	Permission to use, copy, modify, distribute, and sell this
+	software and its documentation may be granted without fee;
+	interested parties are encouraged to request permission from
+		Immersion Corporation
+		801 Fox Lane
+		San Jose, CA 95131
+		408-467-1900
+
+	IMMERSION DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+	INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.
+	IN NO EVENT SHALL IMMERSION BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+	CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+	LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+	NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+	CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+  FILE:		IFCErrors.h
+
+  PURPOSE:	Error codes returned in IFC; Error handling in IFC
+
+  STARTED:	2/28/99 by Jeff Mallett
+
+  NOTES/REVISIONS:
+     3/2/99 jrm (Jeff Mallett): Force-->Feel renaming
+	 3/6/99 jrm: Added user error handling control
+	 3/15/99 jrm: __declspec(dllimport/dllexport) the whole class
+
+**********************************************************************/
+
+
+#if !defined(IFCERRORS_H__INCLUDED_)
+#define IFCERRORS_H__INCLUDED_
+
+#if _MSC_VER >= 1000
+#pragma once
+#endif // _MSC_VER >= 1000
+
+#ifndef _IFCDLL_
+#define DLLIFC __declspec(dllimport)
+#else
+#define DLLIFC __declspec(dllexport)
+#endif
+
+#include <winerror.h>
+#include "ImmBaseTypes.h"
+
+
+/****************************************************************************
+ *
+ *      Error Codes
+ *
+ ****************************************************************************/
+
+typedef enum {
+    IFC_ERR_OK							=   0,
+
+	IFC_ERR_UNKNOWN_ERROR				=   1,
+
+	IFC_ERR_ALLOCATION_FAILED			=   2,
+	IFC_ERR_INVALID_PARAMETER			=   3,
+	IFC_ERR_NULL_PARAMETER				=   4,
+	IFC_ERR_WRONG_FORM					=   5,
+
+	IFC_ERR_DEVICE_IS_NULL				=   6,
+	IFC_ERR_INVALID_GUID				=   7,
+	IFC_ERR_EFFECT_NOT_INITIALIZED		=   8,
+
+	IFC_ERR_CANT_INITIALIZE_DEVICE		=   9,
+
+	IFC_ERR_CANT_CREATE_EFFECT			=  10,
+	IFC_ERR_CANT_CREATE_EFFECT_FROM_IFR	=  11,
+	IFC_ERR_NO_EFFECTS_FOUND			=  12,
+	IFC_ERR_EFFECT_IS_COMPOUND			=  13,
+
+	IFC_ERR_PROJECT_ALREADY_OPEN		=  14,
+	IFC_ERR_PROJECT_NOT_OPEN			=  15,
+
+	IFC_ERR_NO_DX7_DEVICE				=  16,
+	IFC_ERR_CANT_WRITE_IFR				=  17,
+
+	IFC_ERR_DINPUT_NOT_FOUND			=  18,
+	IFC_ERR_IMMAPI_NOT_FOUND			=  19,
+
+	IFC_ERR_FILE_NOT_FOUND				=  20,
+	IFC_ERR_NO_VERSION_INFO				=  21
+
+} IFC_ERROR_CODE;
+
+typedef enum {
+	IFC_OUTPUT_ERR_TO_DEBUG				= 0x0001,
+	IFC_OUTPUT_ERR_TO_DIALOG			= 0x0002
+} IFC_ERROR_HANDLING_FLAGS;
+
+
+/****************************************************************************
+ *
+ *      Macros
+ *
+ ****************************************************************************/
+
+//
+// ------ PUBLIC MACROS ------ 
+//
+#define IFC_GET_LAST_ERROR			CIFCErrors::GetLastErrorCode()
+#define IFC_SET_ERROR_HANDLING		CIFCErrors::SetErrorHandling
+
+
+//
+// ------ PRIVATE MACROS ------ 
+//
+#if (IFC_VERSION >= 0x0110)
+ #define IFC_SET_ERROR(err)			CIFCErrors::SetErrorCode(err, __FILE__, __LINE__)
+#else
+ #define IFC_SET_ERROR(err)			CIFCErrors::SetErrorCode(err)
+#endif
+#define IFC_CLEAR_ERROR				IFC_SET_ERROR(IFC_ERR_OK)
+
+
+
+/****************************************************************************
+ *
+ *      CIFCErrors
+ *
+ ****************************************************************************/
+// All members are static.  Don't bother instantiating an object of this class.
+
+//
+// ------ PUBLIC INTERFACE ------ 
+//
+        
+class DLLIFC CIFCErrors
+{
+    //
+    // ATTRIBUTES
+    //
+
+	public:
+
+	static HRESULT
+	GetLastErrorCode()
+		{ return m_Err; }
+
+	static void
+	SetErrorHandling(unsigned long dwFlags)
+		{ m_dwErrHandlingFlags = dwFlags; }
+
+
+//
+// ------ PRIVATE INTERFACE ------ 
+//
+
+	// Internally used by IFC classes
+	static void
+	SetErrorCode(
+		HRESULT err
+#if (IFC_VERSION >= 0x0110)
+		, const char *sFile, int nLine
+#endif
+		);
+
+    //
+    // HELPERS
+    //
+
+	protected:
+
+    //
+    // INTERNAL DATA
+    //
+
+	private:
+
+	static HRESULT m_Err;
+	static unsigned long m_dwErrHandlingFlags;
+};
+
+
+#endif // IFCERRORS_H__INCLUDED_
diff --git a/code/ff/IFC/ImmBaseTypes.h b/code/ff/IFC/ImmBaseTypes.h
new file mode 100644
index 0000000..b58298f
--- /dev/null
+++ b/code/ff/IFC/ImmBaseTypes.h
@@ -0,0 +1,359 @@
+/**********************************************************************
+	Copyright (c) 1997 - 2000 Immersion Corporation
+
+	Permission to use, copy, modify, distribute, and sell this
+	software and its documentation may be granted without fee;
+	interested parties are encouraged to request permission from
+		Immersion Corporation
+		801 Fox Lane
+		San Jose, CA 95131
+		408-467-1900
+
+	IMMERSION DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+	INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.
+	IN NO EVENT SHALL IMMERSION BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+	CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+	LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+	NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+	CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+  FILE:		ImmBaseTypes.h
+
+  PURPOSE:	Base Types for Feelit API Foundation Classes
+
+  STARTED:	10/29/97
+
+  NOTES/REVISIONS:
+     3/2/99 jrm (Jeff Mallett): Force-->Feel renaming
+
+**********************************************************************/
+
+
+#if !defined(AFX_IMMBASETYPES_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_)
+#define AFX_IMMBASETYPES_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_
+
+#if _MSC_VER >= 1000
+#pragma once
+#endif // _MSC_VER >= 1000
+
+//#include <windows.h>
+#include "FeelitApi.h"
+
+// Version 0x0100 -- IFC10
+// Version 0x0101 -- IFC10p Special release: contains CImmProject::DestroyEffect
+// Version 0x0110 -- IFC21 (and IFC20?)
+#ifndef IFC_VERSION
+ #define IFC_VERSION         0x0110
+#endif
+
+//#if (IFC_VERSION >= 0x0101)
+ // This means that a user can call delete on a CImmCompoundEffect
+ // object that was allocated through a CImmProject::CreateEffect()
+ // and all will be well.
+// #define PROTECT_AGAINST_DELETION
+//#endif
+
+#if (IFC_VERSION >= 0x0110)
+ #define IFC_START_DELAY
+ #define IFC_EFFECT_CACHING
+#endif
+
+//	Add define for DirectInput Device emulating FEELit Device
+#define FEELIT_DEVICETYPE_DIRECTINPUT	3
+
+
+//================================================================
+// TYPE WRAPPERS
+//================================================================
+
+//
+// IMM --> FEELIT Wrappers
+//
+#define IMM_VERSION			FEELIT_VERSION
+
+#define IMM_DEVICETYPE_DEVICE		FEELIT_DEVICETYPE_DEVICE
+#define IMM_DEVICETYPE_MOUSE		FEELIT_DEVICETYPE_MOUSE
+#define IMM_DEVICETYPE_HID			FEELIT_DEVICETYPE_HID 
+#define IMM_DEVICETYPE_DIRECTINPUT	FEELIT_DEVICETYPE_DIRECTINPUT
+
+#define IMM_EFFECT		FEELIT_EFFECT
+#define LPIMM_EFFECT	LPFEELIT_EFFECT
+#define LPCIMM_EFFECT	LPCFEELIT_EFFECT
+
+#define IMM_CONDITION     FEELIT_CONDITION
+#define LPIMM_CONDITION   LPFEELIT_CONDITION
+#define LPCIMM_CONDITION  LPCFEELIT_CONDITION
+
+#define IMM_CONSTANTFORCE     FEELIT_CONSTANTFORCE
+#define LPIMM_CONSTANTFORCE   LPFEELIT_CONSTANTFORCE
+#define LPCIMM_CONSTANTFORCE  LPCFEELIT_CONSTANTFORCE
+
+#define IMM_ELLIPSE		   FEELIT_ELLIPSE
+#define LPIMM_ELLIPSE	   LPFEELIT_ELLIPSE
+#define LPCIMM_ELLIPSE	   LPCFEELIT_ELLIPSE
+
+#define IMM_ENCLOSURE     FEELIT_ENCLOSURE
+#define LPIMM_ENCLOSURE   LPFEELIT_ENCLOSURE
+#define LPCIMM_ENCLOSURE  LPCFEELIT_ENCLOSURE
+
+#define IMM_PERIODIC      FEELIT_PERIODIC
+#define LPIMM_PERIODIC    LPFEELIT_PERIODIC
+#define LPCIMM_PERIODIC   LPCFEELIT_PERIODIC
+
+#define IMM_RAMPFORCE     FEELIT_RAMPFORCE
+#define LPIMM_RAMPFORCE   LPFEELIT_RAMPFORCE
+#define LPCIMM_RAMPFORCE  LPCFEELIT_RAMPFORCE
+
+#define IMM_TEXTURE       FEELIT_TEXTURE
+#define LPIMM_TEXTURE     LPFEELIT_TEXTURE
+#define LPCIMM_TEXTURE    LPCFEELIT_TEXTURE
+
+#define IMM_ENVELOPE      FEELIT_ENVELOPE
+#define LPIMM_ENVELOPE    LPFEELIT_ENVELOPE
+#define LPCIMM_ENVELOPE   LPCFEELIT_ENVELOPE
+
+#define LPIIMM_API        LPIFEELIT
+#define LPIIMM_EFFECT     LPIFEELIT_EFFECT
+#define LPIIMM_DEVICE     LPIFEELIT_DEVICE
+
+#define IMM_CUSTOMFORCE     FEELIT_CUSTOMFORCE
+#define LPIMM_CUSTOMFORCE   LPFEELIT_CUSTOMFORCE
+#define LPCIMM_CUSTOMFORCE  LPCFEELIT_CUSTOMFORCE
+
+#define LPIMM_ENUMDEVICESCALLBACK	LPFEELIT_ENUMDEVICESCALLBACK
+
+/* Effect Types */
+#define IMM_EFFECTTYPE_ALL	FEELIT_FEFFECTTYPE_ALL					
+
+#define IMM_EFFECTTYPE_CONSTANTFORCE	FEELIT_FEFFECTTYPE_CONSTANTFORCE		
+#define IMM_EFFECTTYPE_RAMPFORCE		FEELIT_FEFFECTTYPE_RAMPFORCE		
+#define IMM_EFFECTTYPE_PERIODIC			FEELIT_FEFFECTTYPE_PERIODIC		
+#define IMM_EFFECTTYPE_CONDITION		FEELIT_FEFFECTTYPE_CONDITION	
+#define IMM_EFFECTTYPE_ENCLOSURE		FEELIT_FEFFECTTYPE_ENCLOSURE	
+#define IMM_EFFECTTYPE_ELLIPSE			FEELIT_FEFFECTTYPE_ELLIPSE	
+#define IMM_EFFECTTYPE_TEXTURE			FEELIT_FEFFECTTYPE_TEXTURE		
+#define IMM_EFFECTTYPE_COMPOUND			0x00000008		
+#define IMM_EFFECTTYPE_CUSTOMFORCE		FEELIT_FEFFECTTYPE_CUSTOMFORCE		
+#define IMM_EFFECTTYPE_HARDWARE			FEELIT_FEFFECTTYPE_HARDWARE		
+
+#define IMM_EFFECTTYPE_FFATTACK				FEELIT_FEFFECTTYPE_FFATTACK	
+#define IMM_EFFECTTYPE_FFFADE				FEELIT_FEFFECTTYPE_FFFADE		
+#define IMM_EFFECTTYPE_SATURATION			FEELIT_FEFFECTTYPE_SATURATION	
+#define IMM_EFFECTTYPE_POSNEGCOEFFICIENTS	FEELIT_FEFFECTTYPE_POSNEGCOEFFICIENTS
+#define IMM_EFFECTTYPE_POSNEGSATURATION		FEELIT_FEFFECTTYPE_POSNEGSATURATION	
+#define IMM_EFFECTTYPE_DEADBAND				FEELIT_FEFFECTTYPE_DEADBAND			
+
+/* Units */
+#define IMM_DEGREES			FEELIT_DEGREES        
+#define IMM_FFNOMINALMAX	FEELIT_FFNOMINALMAX     
+#define IMM_SECONDS			FEELIT_SECONDS   
+
+/* Start Flags */
+#define IMM_START_SOLO			FEELIT_FSTART_SOLO             
+#define IMM_START_NODOWNLOAD	FEELIT_FSTART_NODOWNLOAD          
+
+/* Status Flags */
+#define IMM_STATUS_PLAYING		FEELIT_FSTATUS_PLAYING         
+#define IMM_STATUS_EMULATED		FEELIT_FSTATUS_EMULATED            
+
+/* Stiffness Mask Flags */
+#define IMM_STIFF_NONE				FEELIT_FSTIFF_NONE			
+#define IMM_STIFF_OUTERLEFTWALL		FEELIT_FSTIFF_OUTERLEFTWALL	
+#define IMM_STIFF_INNERLEFTWALL		FEELIT_FSTIFF_INNERLEFTWALL	
+#define IMM_STIFF_INNERRIGHTWALL	FEELIT_FSTIFF_INNERRIGHTWALL	
+#define IMM_STIFF_OUTERRIGHTWALL	FEELIT_FSTIFF_OUTERRIGHTWALL
+#define IMM_STIFF_OUTERTOPWALL		FEELIT_FSTIFF_OUTERTOPWALL
+#define IMM_STIFF_INNERTOPWALL		FEELIT_FSTIFF_INNERTOPWALL	
+#define IMM_STIFF_INNERBOTTOMWALL	FEELIT_FSTIFF_INNERBOTTOMWALL
+#define IMM_STIFF_OUTERBOTTOMWALL	FEELIT_FSTIFF_OUTERBOTTOMWALL	
+#define IMM_STIFF_OUTERANYWALL		FEELIT_FSTIFF_OUTERANYWALL
+#define IMM_STIFF_INBOUNDANYWALL	FEELIT_FSTIFF_INBOUNDANYWALL
+#define IMM_STIFF_INNERANYWALL		FEELIT_FSTIFF_INNERANYWALL
+#define IMM_STIFF_OUTBOUNDANYWALL	FEELIT_FSTIFF_OUTBOUNDANYWALL
+#define IMM_STIFF_ANYWALL			FEELIT_FSTIFF_ANYWALL
+
+/* Clipping Mask Flags */
+#define IMM_CLIP_NONE				FEELIT_FCLIP_NONE		
+#define IMM_CLIP_OUTERLEFTWALL		FEELIT_FCLIP_OUTERLEFTWALL
+#define IMM_CLIP_INNERLEFTWALL		FEELIT_FCLIP_INNERLEFTWALL
+#define IMM_CLIP_INNERRIGHTWALL		FEELIT_FCLIP_INNERRIGHTWALL
+#define IMM_CLIP_OUTERRIGHTWALL		FEELIT_FCLIP_OUTERRIGHTWALL
+#define IMM_CLIP_OUTERTOPWALL		FEELIT_FCLIP_OUTERTOPWALL
+#define IMM_CLIP_INNERTOPWALL		FEELIT_FCLIP_INNERTOPWALL
+#define IMM_CLIP_INNERBOTTOMWALL	FEELIT_FCLIP_INNERBOTTOMWALL
+#define IMM_CLIP_OUTERBOTTOMWALL	FEELIT_FCLIP_OUTERBOTTOMWALL
+#define IMM_CLIP_OUTERANYWALL		FEELIT_FCLIP_OUTERANYWALL
+#define IMM_CLIP_INNERANYWALL		FEELIT_FCLIP_INNERANYWALL
+#define IMM_CLIP_ANYWALL			FEELIT_FCLIP_ANYWALL
+
+/* Device capabilities Stuct */
+#define IMM_DEVCAPS		FEELIT_DEVCAPS
+#define LPIMM_DEVCAPS	LPFEELIT_DEVCAPS
+#define LPCIMM_DEVCAPS	LPCFEELIT_DEVCAPS
+
+/* Device capabilities flags */
+#define IMM_DEVCAPS_ATTACHED			FEELIT_FDEVCAPS_ATTACHED
+#define IMM_DEVCAPS_POLLEDDEVICE		FEELIT_FDEVCAPS_POLLEDDEVICE
+#define IMM_DEVCAPS_EMULATED			FEELIT_FDEVCAPS_EMULATED
+#define IMM_DEVCAPS_POLLEDDATAFORMAT	FEELIT_FDEVCAPS_POLLEDDATAFORMAT
+#define IMM_DEVCAPS_FORCEFEEDBACK		FEELIT_FDEVCAPS_FORCEFEEDBACK
+#define IMM_DEVCAPS_FFATTACK			FEELIT_FDEVCAPS_FFATTACK
+#define IMM_DEVCAPS_FFFADE				FEELIT_FDEVCAPS_FFFADE
+#define IMM_DEVCAPS_SATURATION			FEELIT_FDEVCAPS_SATURATION
+#define IMM_DEVCAPS_POSNEGCOEFFICIENTS	FEELIT_FDEVCAPS_POSNEGCOEFFICIENTS
+#define IMM_DEVCAPS_POSNEGSATURATION	FEELIT_FDEVCAPS_POSNEGSATURATION
+#define IMM_DEVCAPS_DEADBAND			FEELIT_FDEVCAPS_DEADBAND
+
+#define LPIMM_DEVICEINSTANCE              LPFEELIT_DEVICEINSTANCE       
+#define LPCIMM_DEVICEOBJECTINSTANCE       LPCFEELIT_DEVICEOBJECTINSTANCE
+#define LPCIMM_EFFECTINFO                 LPCFEELIT_EFFECTINFO          
+
+#define IMM_PARAM_DURATION               FEELIT_FPARAM_DURATION             
+#define IMM_PARAM_SAMPLEPERIOD           FEELIT_FPARAM_SAMPLEPERIOD         
+#define IMM_PARAM_GAIN                   FEELIT_FPARAM_GAIN                 
+#define IMM_PARAM_TRIGGERBUTTON          FEELIT_FPARAM_TRIGGERBUTTON        
+#define IMM_PARAM_TRIGGERREPEATINTERVAL  FEELIT_FPARAM_TRIGGERREPEATINTERVAL
+#define IMM_PARAM_AXES                   FEELIT_FPARAM_AXES                 
+#define IMM_PARAM_DIRECTION              FEELIT_FPARAM_DIRECTION            
+#define IMM_PARAM_ENVELOPE               FEELIT_FPARAM_ENVELOPE             
+#define IMM_PARAM_TYPESPECIFICPARAMS     FEELIT_FPARAM_TYPESPECIFICPARAMS  
+#define IMM_PARAM_STARTDELAY             FEELIT_FPARAM_STARTDELAY 
+#define IMM_PARAM_ALLPARAMS              FEELIT_FPARAM_ALLPARAMS            
+#define IMM_PARAM_START                  FEELIT_FPARAM_START                
+#define IMM_PARAM_NORESTART              FEELIT_FPARAM_NORESTART            
+#define IMM_PARAM_NODOWNLOAD             FEELIT_FPARAM_NODOWNLOAD           
+
+#define IMM_EFFECT_OBJECTIDS             FEELIT_FEFFECT_OBJECTIDS      
+#define IMM_EFFECT_OBJECTOFFSETS         FEELIT_FEFFECT_OBJECTOFFSETS  
+#define IMM_EFFECT_CARTESIAN             FEELIT_FEFFECT_CARTESIAN      
+#define IMM_EFFECT_POLAR                 FEELIT_FEFFECT_POLAR          
+#define IMM_EFFECT_SPHERICAL             FEELIT_FEFFECT_SPHERICAL      
+
+#define IMM_PARAM_NOTRIGGER              FEELIT_PARAM_NOTRIGGER
+
+/* Offsets */
+#define IMM_MOUSEOFFSET_XAXIS   FEELIT_MOUSEOFFSET_XAXIS
+#define IMM_MOUSEOFFSET_YAXIS   FEELIT_MOUSEOFFSET_YAXIS
+#define IMM_MOUSEOFFSET_ZAXIS   FEELIT_MOUSEOFFSET_ZAXIS
+#define IMM_MOUSEOFFSET_XFORCE	FEELIT_MOUSEOFFSET_XFORCE
+#define IMM_MOUSEOFFSET_YFORCE	FEELIT_MOUSEOFFSET_YFORCE
+#define IMM_MOUSEOFFSET_ZFORCE	FEELIT_MOUSEOFFSET_ZFORCE
+#define IMM_MOUSEOFFSET_BUTTON0	FEELIT_MOUSEOFFSET_BUTTON0
+#define IMM_MOUSEOFFSET_BUTTON1	FEELIT_MOUSEOFFSET_BUTTON1
+#define IMM_MOUSEOFFSET_BUTTON2	FEELIT_MOUSEOFFSET_BUTTON2
+#define IMM_MOUSEOFFSET_BUTTON3	FEELIT_MOUSEOFFSET_BUTTON3
+
+/* Cooperative Level Flags */
+#define IMM_COOPLEVEL_FOREGROUND	FEELIT_FCOOPLEVEL_FOREGROUND
+#define IMM_COOPLEVEL_BACKGROUND	FEELIT_FCOOPLEVEL_BACKGROUND
+
+/* Enumeration codes */
+#define IMM_ENUM_STOP		FEELIT_ENUM_STOP
+#define IMM_ENUM_CONTINUE	FEELIT_ENUM_CONTINUE
+
+#define IMM_ENUMDEV_ALLDEVICES		FEELIT_FENUMDEV_ALLDEVICES
+#define IMM_ENUMDEV_ATTACHEDONLY	FEELIT_FENUMDEV_ATTACHEDONLY
+#define IMM_ENUMDEV_FORCEFEEDBACK	FEELIT_FENUMDEV_FORCEFEEDBACK
+
+/* Return values */
+#define IMM_RESULT_OK						FEELIT_RESULT_OK 
+#define IMM_RESULT_NOTATTACHED				FEELIT_RESULT_NOTATTACHED
+#define IMM_RESULT_BUFFEROVERFLOW			FEELIT_RESULT_BUFFEROVERFLOW
+#define IMM_RESULT_PROPNOEFFECT				FEELIT_RESULT_PROPNOEFFECT
+#define IMM_RESULT_NOEFFECT					FEELIT_RESULT_NOEFFECT
+#define IMM_RESULT_POLLEDDEVICE				FEELIT_RESULT_POLLEDDEVICE
+#define IMM_RESULT_DOWNLOADSKIPPED			FEELIT_RESULT_DOWNLOADSKIPPED
+#define IMM_RESULT_EFFECTRESTARTED			FEELIT_RESULT_EFFECTRESTARTED
+#define IMM_RESULT_TRUNCATED				FEELIT_RESULT_TRUNCATED
+#define IMM_RESULT_TRUNCATEDANDRESTARTED	FEELIT_RESULT_TRUNCATEDANDRESTARTED
+#define IMM_ERROR_OLDFEELITVERSION			FEELIT_ERROR_OLDFEELITVERSION
+#define IMM_ERROR_BETAFEELITVERSION			FEELIT_ERROR_BETAFEELITVERSION
+#define IMM_ERROR_BADDRIVERVER				FEELIT_ERROR_BADDRIVERVER
+#define IMM_ERROR_DEVICENOTREG				FEELIT_ERROR_DEVICENOTREG
+#define IMM_ERROR_NOTFOUND					FEELIT_ERROR_NOTFOUND
+#define IMM_ERROR_OBJECTNOTFOUND			FEELIT_ERROR_OBJECTNOTFOUND
+#define IMM_ERROR_INVALIDPARAM				FEELIT_ERROR_INVALIDPARAM
+#define IMM_ERROR_NOINTERFACE				FEELIT_ERROR_NOINTERFACE
+#define IMM_ERROR_GENERIC					FEELIT_ERROR_GENERIC
+#define IMM_ERROR_OUTOFMEMORY				FEELIT_ERROR_OUTOFMEMORY
+#define IMM_ERROR_UNSUPPORTED				FEELIT_ERROR_UNSUPPORTED
+#define IMM_ERROR_NOTINITIALIZED			FEELIT_ERROR_NOTINITIALIZED
+#define IMM_ERROR_ALREADYINITIALIZED		FEELIT_ERROR_ALREADYINITIALIZED
+#define IMM_ERROR_NOAGGREGATION				FEELIT_ERROR_NOAGGREGATION
+#define IMM_ERROR_OTHERAPPHASPRIO			FEELIT_ERROR_OTHERAPPHASPRIO
+#define IMM_ERROR_INPUTLOST					FEELIT_ERROR_INPUTLOST
+#define IMM_ERROR_ACQUIRED					FEELIT_ERROR_ACQUIRED				
+#define IMM_ERROR_NOTACQUIRED				FEELIT_ERROR_NOTACQUIRED
+#define IMM_ERROR_READONLY					FEELIT_ERROR_READONLY
+#define IMM_ERROR_HANDLEEXISTS				FEELIT_ERROR_HANDLEEXISTS
+#define IMM_ERROR_INSUFFICIENTPRIVS			FEELIT_ERROR_INSUFFICIENTPRIVS
+#define IMM_ERROR_DEVICEFULL				FEELIT_ERROR_DEVICEFULL
+#define IMM_ERROR_MOREDATA					FEELIT_ERROR_MOREDATA
+#define IMM_ERROR_NOTDOWNLOADED				FEELIT_ERROR_NOTDOWNLOADED
+#define IMM_ERROR_HASEFFECTS				FEELIT_ERROR_HASEFFECTS
+#define IMM_ERROR_NOTEXCLUSIVEACQUIRED		FEELIT_ERROR_NOTEXCLUSIVEACQUIRED
+#define IMM_ERROR_INCOMPLETEEFFECT			FEELIT_ERROR_INCOMPLETEEFFECT
+#define IMM_ERROR_NOTBUFFERED				FEELIT_ERROR_NOTBUFFERED
+#define IMM_ERROR_EFFECTPLAYING				FEELIT_ERROR_EFFECTPLAYING
+#define	IMM_ERROR_INTERNAL					FEELIT_ERROR_INTERNAL
+#define IMM_ERROR_INACTIVE					FEELIT_ERROR_INACTIVE
+
+//================================================================
+// GUID WRAPPERS
+//================================================================
+
+//
+// Immersion --> Feelit Wrappers
+//
+#define GUID_Imm_ConstantForce	GUID_Feelit_ConstantForce
+#define GUID_Imm_RampForce		GUID_Feelit_RampForce
+#define GUID_Imm_Square			GUID_Feelit_Square
+#define GUID_Imm_Sine			GUID_Feelit_Sine
+#define GUID_Imm_Triangle		GUID_Feelit_Triangle
+#define GUID_Imm_SawtoothUp		GUID_Feelit_SawtoothUp
+#define GUID_Imm_SawtoothDown	GUID_Feelit_SawtoothDown
+#define GUID_Imm_Spring			GUID_Feelit_Spring
+#define GUID_Imm_DeviceSpring	GUID_Feelit_DeviceSpring
+#define GUID_Imm_Damper			GUID_Feelit_Damper
+#define GUID_Imm_Inertia		GUID_Feelit_Inertia
+#define GUID_Imm_Friction		GUID_Feelit_Friction
+#define GUID_Imm_Texture		GUID_Feelit_Texture
+#define GUID_Imm_Grid			GUID_Feelit_Grid
+#define GUID_Imm_Enclosure		GUID_Feelit_Enclosure
+#define GUID_Imm_Ellipse		GUID_Feelit_Ellipse
+#define GUID_Imm_CustomForce	GUID_Feelit_CustomForce
+
+#define CLSID_Imm			CLSID_Feelit
+#define CLSID_ImmDevice		CLSID_FeelitDevice
+#define GUID_Imm_XAxis		GUID_Feelit_XAxis
+#define GUID_Imm_YAxis		GUID_Feelit_YAxis
+#define GUID_Imm_ZAxis		GUID_Feelit_ZAxis
+#define GUID_Imm_RxAxis		GUID_Feelit_RxAxis
+#define GUID_Imm_RyAxis		GUID_Feelit_RyAxis
+#define GUID_Imm_RzAxis		GUID_Feelit_RzAxis
+#define GUID_Imm_Slider		GUID_Feelit_Slider
+#define GUID_Imm_Button		GUID_Feelit_Button
+#define GUID_Imm_Key		GUID_Feelit_Key
+#define GUID_Imm_POV		GUID_Feelit_POV
+#define GUID_Imm_Unknown	GUID_Feelit_Unknown
+#define GUID_Imm_Mouse		GUID_Feelit_Mouse
+
+
+#endif // !defined(AFX_IMMBASETYPES_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/code/ff/IFC/ImmBox.h b/code/ff/IFC/ImmBox.h
new file mode 100644
index 0000000..12eebbf
--- /dev/null
+++ b/code/ff/IFC/ImmBox.h
@@ -0,0 +1,170 @@
+/**********************************************************************
+	Copyright (c) 1997 - 2000 Immersion Corporation
+
+	Permission to use, copy, modify, distribute, and sell this
+	software and its documentation may be granted without fee;
+	interested parties are encouraged to request permission from
+		Immersion Corporation
+		801 Fox Lane
+		San Jose, CA 95131
+		408-467-1900
+
+	IMMERSION DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+	INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.
+	IN NO EVENT SHALL IMMERSION BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+	CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+	LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+	NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+	CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+  FILE:		ImmBox.h
+
+  PURPOSE:	Box Class for Immersion Foundation Classes
+
+  STARTED:	11/04/97
+
+  NOTES/REVISIONS:
+     3/2/99 jrm (Jeff Mallett): Force-->Feel renaming
+	 3/15/99 jrm: __declspec(dllimport/dllexport) the whole class
+	 11/15/99 sdr (Steve Rank): Converted to IFC
+
+**********************************************************************/
+
+
+#if !defined(AFX_IMMBOX_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_)
+#define AFX_IMMBOX_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_
+
+#if _MSC_VER >= 1000
+#pragma once
+#endif // _MSC_VER >= 1000
+
+#ifndef _IFCDLL_
+#define DLLIFC __declspec(dllimport)
+#else
+#define DLLIFC __declspec(dllexport)
+#endif
+
+#include "ImmBaseTypes.h"
+#include "ImmEffect.h"
+#include "ImmEnclosure.h"
+
+
+
+//================================================================
+// Constants
+//================================================================
+
+const POINT IMM_BOX_MOUSE_POS_AT_START = { MAXLONG, MAXLONG };
+
+#define     IMM_BOX_DEFAULT_STIFFNESS      5000
+#define     IMM_BOX_DEFAULT_WIDTH          10
+#define     IMM_BOX_DEFAULT_HEIGHT         IMM_ENCLOSURE_HEIGHT_AUTO
+#define     IMM_BOX_DEFAULT_WALL_WIDTH     IMM_ENCLOSURE_WALL_WIDTH_AUTO
+
+#define     IMM_BOX_DEFAULT_CENTER_POINT   IMM_BOX_MOUSE_POS_AT_START
+
+
+
+
+//================================================================
+// CImmBox
+//================================================================
+
+//
+// ------ PUBLIC INTERFACE ------ 
+//
+
+class DLLIFC CImmBox : public CImmEnclosure
+{
+    //
+    // CONSTRUCTOR/DESCTRUCTOR
+    //
+
+    public:
+    
+    // Constructor
+	CImmBox();
+
+	// Destructor
+	virtual
+	~CImmBox();
+
+
+    //
+    // ATTRIBUTES
+    //
+
+    public:
+
+
+    BOOL
+    ChangeParameters( 
+        POINT pntCenter,
+        LONG lStiffness = IMM_EFFECT_DONT_CHANGE,
+        DWORD dwWidth = IMM_EFFECT_DONT_CHANGE,
+        DWORD dwHeight = IMM_EFFECT_DONT_CHANGE,
+        DWORD dwWallWidth = IMM_EFFECT_DONT_CHANGE,
+        CImmEffect* pInsideEffect = (CImmEffect*) IMM_EFFECT_DONT_CHANGE  
+        );
+
+    BOOL
+	ChangeParameters( 
+        LPCRECT pRectOutside,
+        LONG lStiffness = IMM_EFFECT_DONT_CHANGE,
+        DWORD dwWallWidth = IMM_EFFECT_DONT_CHANGE,
+        CImmEffect* pInsideEffect = (CImmEffect*) IMM_EFFECT_DONT_CHANGE  
+        );
+
+
+    //
+    // OPERATIONS
+    //
+
+    public:
+
+
+    BOOL 
+	Initialize( 
+        CImmDevice* pDevice, 
+        DWORD dwWidth = IMM_ENCLOSURE_DEFAULT_WIDTH,
+        DWORD dwHeight = IMM_ENCLOSURE_DEFAULT_HEIGHT,
+        LONG lStiffness = IMM_BOX_DEFAULT_STIFFNESS,
+        DWORD dwWallWidth = IMM_BOX_DEFAULT_WALL_WIDTH,
+        POINT pntCenter = IMM_BOX_DEFAULT_CENTER_POINT,
+        CImmEffect* pInsideEffect = NULL,
+		DWORD dwNoDownload = 0  
+        );
+
+
+    BOOL 
+	Initialize( 
+        CImmDevice* pDevice, 
+        LPCRECT pRectOutside,
+        LONG lStiffness = IMM_BOX_DEFAULT_STIFFNESS,
+        DWORD dwWallWidth = IMM_BOX_DEFAULT_WALL_WIDTH,
+        CImmEffect* pInsideEffect = NULL,
+		DWORD dwNoDownload = 0  
+        );
+
+
+//
+// ------ PRIVATE INTERFACE ------ 
+//
+        
+    //
+    // HELPERS
+    //
+
+    protected:
+
+
+    //
+    // INTERNAL DATA
+    //
+    
+    protected:
+
+};
+
+
+#endif // !defined(AFX_IMMBOX_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_)
diff --git a/code/ff/IFC/ImmCompoundEffect.h b/code/ff/IFC/ImmCompoundEffect.h
new file mode 100644
index 0000000..9a39b3c
--- /dev/null
+++ b/code/ff/IFC/ImmCompoundEffect.h
@@ -0,0 +1,228 @@
+/**********************************************************************
+	Copyright (c) 1999 - 2000 Immersion Corporation
+
+	Permission to use, copy, modify, distribute, and sell this
+	software and its documentation may be granted without fee;
+	interested parties are encouraged to request permission from
+		Immersion Corporation
+		801 Fox Lane
+		San Jose, CA 95131
+		408-467-1900
+
+	IMMERSION DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+	INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.
+	IN NO EVENT SHALL IMMERSION BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+	CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+	LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+	NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+	CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+  FILE:		ImmCompoundEffect.h
+
+  PURPOSE:	Manages Compound Effects for Force Foundation Classes
+
+  STARTED:	2/24/99 by Jeff Mallett
+
+  NOTES/REVISIONS:
+     3/2/99 jrm (Jeff Mallett): Force-->Feel renaming
+	 3/15/99 jrm: __declspec(dllimport/dllexport) the whole class
+
+**********************************************************************/
+
+
+#include "ImmBaseTypes.h"
+#include "ImmEffect.h"
+
+#include "ImmIFR.h"
+
+#if !defined(__FEELCOMPOUNDEFFECT_H)
+#define __FEELCOMPOUNDEFFECT_H
+
+#if _MSC_VER >= 1000
+#pragma once
+#endif // _MSC_VER >= 1000
+
+#ifndef _IFCDLL_
+#define DLLIFC __declspec(dllimport)
+#else
+#define DLLIFC __declspec(dllexport)
+#endif
+
+/*
+**  IMM_FFE_FILEEFFECT - struct used by DX7 to read and write to FFE
+**  files.  This struct is different from DIFILEEFFECT due to the use
+**  of the non const LPDIEFFECT.  An LPDIEFFECT is needed to be able to
+**  collect information from IFC class objects.  This should be defined
+**  elsewhere, but no more appropriate header currently exists.
+*/
+typedef struct IMM_FFE_FILEEFFECT{
+    DWORD       dwSize;
+    GUID        GuidEffect;
+    LPDIEFFECT  lpDiEffect;
+    CHAR        szFriendlyName[MAX_PATH];                    
+}IMM_FFE_FILEEFFECT, *LPIMM_FFE_FILEEFFECT;
+
+//================================================================
+// CImmCompoundEffect
+//================================================================
+// Represents a compound effect, such as might be created in
+// Immersion Studio.  Contains an array of effect objects.
+// Methods iterate over component effects, passing the message
+// to each one.
+// Also, has stuff for being used by CImmProject:
+//   * next pointer so can be put on a linked list
+//   * force name
+
+//
+// ------ PUBLIC INTERFACE ------ 
+//
+
+class DLLIFC CImmCompoundEffect
+{
+    //
+    // CONSTRUCTOR/DESTRUCTOR
+    //
+
+public://###	protected:
+	// Constructs a CImmCompoundEffect
+	// Don't try to construct a CImmCompoundEffect yourself.
+    // Instead let CImmProject construct it for you.
+	CImmCompoundEffect(
+		IFREffect **hEffects,
+		long nEffects,
+		LPCSTR pEffectName
+		);
+
+	public:
+
+	~CImmCompoundEffect();
+
+
+    //
+    // ATTRIBUTES
+    //
+
+	public:
+
+	long
+	GetNumberOfContainedEffects() const
+		{ return m_nEffects; }
+    
+	const char *
+	GetName() const
+		{ return m_lpszName; }
+
+	GENERIC_EFFECT_PTR
+	GetContainedEffect(
+		long index
+		);
+
+	GENERIC_EFFECT_PTR
+	GetContainedEffect(
+		LPCSTR lpszEffectName
+		);
+
+	DWORD
+	GetEffectType();
+
+	//
+    // OPERATIONS
+    //
+
+	public:
+
+	// Start all the contained effects
+	BOOL Start(
+		DWORD dwIterations = IMM_EFFECT_DONT_CHANGE,
+		DWORD dwFlags = 0
+		);
+
+	// Stop all the contained effects
+	BOOL Stop();
+
+
+//
+// ------ PRIVATE INTERFACE ------ 
+//
+
+    //
+    // HELPERS
+    //
+
+    protected:
+
+	BOOL initialize(
+		CImmDevice* pDevice,
+		IFREffect **hEffects,
+		DWORD dwNoDownload
+		);
+
+	BOOL
+	set_contained_effect(
+		GENERIC_EFFECT_PTR pObject,
+		int index = 0
+		);
+
+	BOOL
+	set_name(
+		const char *lpszName
+		);
+
+	void
+	set_next(
+		CImmCompoundEffect *pNext
+		)
+		{ m_pNext = pNext; }
+
+	CImmCompoundEffect *
+	get_next() const
+		{ return m_pNext; }
+	
+	void
+	set_objID(
+		GUID* pobjID
+		)
+	{ m_objID = *pobjID; }
+
+	BOOL
+	set_contained_obj_IDs(
+		GUID *guidList
+		);
+
+	int
+	buffer_ifr_object(TCHAR* pData);
+
+	BOOL
+	get_ffe_object(LPIMM_FFE_FILEEFFECT pffeObject);
+
+
+    //
+    // FRIENDS
+    //
+
+	public:
+
+	friend class CImmProject;
+
+
+    //
+    // INTERNAL DATA
+    //
+
+	protected:
+
+	GENERIC_EFFECT_PTR *m_paEffects; // Array of force class object pointers
+	long m_nEffects; // Number of effects in m_paEffects
+
+	private:
+
+	char *m_lpszName; // Name of the compound effect
+	GUID m_objID;
+	GUID *m_pContainedObjIDs; 
+	CImmCompoundEffect *m_pNext; // Next compound effect in the project
+#ifdef PROTECT_AGAINST_DELETION
+	CImmProject *m_pOwningProject;
+#endif
+};
+
+#endif
diff --git a/code/ff/IFC/ImmCondition.h b/code/ff/IFC/ImmCondition.h
new file mode 100644
index 0000000..6943365
--- /dev/null
+++ b/code/ff/IFC/ImmCondition.h
@@ -0,0 +1,451 @@
+/**********************************************************************
+	Copyright (c) 1997 - 2000 Immersion Corporation
+
+	Permission to use, copy, modify, distribute, and sell this
+	software and its documentation may be granted without fee;
+	interested parties are encouraged to request permission from
+		Immersion Corporation
+		801 Fox Lane
+		San Jose, CA 95131
+		408-467-1900
+
+	IMMERSION DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+	INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.
+	IN NO EVENT SHALL IMMERSION BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+	CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+	LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+	NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+	CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+  FILE:		ImmCondition.h
+
+  PURPOSE:	Immersion Foundation Classes Base Condition Effect
+  
+  STARTED:	Oct.10.97
+
+  NOTES/REVISIONS:
+     Mar.02.99 jrm (Jeff Mallett): Force-->Feel renaming
+	 Mar.02.99 jrm: Added GetIsCompatibleGUID
+	 Mar.15.99 jrm: __declspec(dllimport/dllexport) the whole class
+	 Nov.15.99 efw (Evan Wies): Converted to IFC
+
+**********************************************************************/
+
+
+#if !defined(AFX_IMMCondition_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_)
+#define AFX_IMMCondition_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_
+
+#if _MSC_VER >= 1000
+#pragma once
+#endif // _MSC_VER >= 1000
+
+#ifndef _IFCDLL_
+#define DLLIFC __declspec(dllimport)
+#else
+#define DLLIFC __declspec(dllexport)
+#endif
+
+#include "ImmBaseTypes.h"
+#include "ImmEffect.h"
+
+
+
+//================================================================
+// Constants
+//================================================================
+
+const POINT IMM_CONDITION_PT_NULL = { 0, 0 };
+
+#define     IMM_CONDITION_DEFAULT_COEFFICIENT    2500
+#define     IMM_CONDITION_DEFAULT_SATURATION     10000
+#define     IMM_CONDITION_DEFAULT_DEADBAND       100
+#define     IMM_CONDITION_DEFAULT_CENTER_POINT   IMM_EFFECT_MOUSE_POS_AT_START
+#define     IMM_CONDITION_DEFAULT_DURATION       INFINITE
+
+typedef enum {
+	IC_NULL = 0,
+	IC_POSITIVE_COEFFICIENT,
+	IC_NEGATIVE_COEFFICIENT,
+	IC_POSITIVE_SATURATION,
+	IC_NEGATIVE_SATURATION,
+	IC_DEAD_BAND,
+	IC_AXIS,
+	IC_CENTER,
+	IC_DIRECTION_X,
+	IC_DIRECTION_Y,
+	IC_ANGLE,
+	IC_CONDITION_X,
+	IC_CONDITION_Y
+} IC_ArgumentType;
+
+#define IC_CONDITION	IC_CONDITION_X
+
+
+
+//================================================================
+// CImmCondition
+//================================================================
+
+//
+// ------ PUBLIC INTERFACE ------ 
+//
+
+class DLLIFC CImmCondition : public CImmEffect
+{
+    //
+    // CONSTRUCTOR/DESCTRUCTOR
+    //
+
+    public:
+    
+    // Constructor
+	CImmCondition(
+		const GUID& rguidEffect
+		);
+
+	// Destructor
+	virtual
+	~CImmCondition();
+
+
+    //
+    // ATTRIBUTES
+    //
+
+    public:
+
+	virtual BOOL
+	GetIsCompatibleGUID(
+		GUID &guid
+		);
+
+	virtual DWORD GetEffectType()
+		{ return IMM_EFFECTTYPE_CONDITION; }
+
+    // Use this form for single-axis and dual-axis effects
+	BOOL
+    ChangeConditionParams( 
+        LPCIMM_CONDITION pConditionX,
+        LPCIMM_CONDITION pConditionY
+        );
+
+    // Use this form for directional effects
+    BOOL
+	ChangeConditionParams( 
+        LPCIMM_CONDITION pCondition,
+        LONG lDirectionX,
+        LONG lDirectionY
+        );
+
+    // Use this form for directional effects
+    BOOL
+	ChangeConditionParamsPolar( 
+        LPCIMM_CONDITION pCondition,
+        LONG lAngle
+        );
+
+    // Use this form for single-axis, dual-axis, or directional effects
+    BOOL
+	ChangeConditionParamsX( 
+        LONG lPositiveCoefficient,
+        LONG lNegativeCoefficient = IMM_EFFECT_DONT_CHANGE,
+        DWORD dwPositiveSaturation = IMM_EFFECT_DONT_CHANGE,
+        DWORD dwNegativeSaturation = IMM_EFFECT_DONT_CHANGE,
+        LONG lDeadBand = IMM_EFFECT_DONT_CHANGE,
+        POINT pntCenter = IMM_EFFECT_DONT_CHANGE_POINT,
+        LONG lDirectionX = IMM_EFFECT_DONT_CHANGE,
+        LONG lDirectionY = IMM_EFFECT_DONT_CHANGE
+        );
+
+    BOOL
+	ChangeConditionParamsPolarX( 
+        LONG lPositiveCoefficient,
+        LONG lNegativeCoefficient,
+        DWORD dwPositiveSaturation,
+        DWORD dwNegativeSaturation,
+        LONG lDeadBand,
+        POINT pntCenter,
+        LONG lAngle
+        );
+
+    BOOL
+	ChangeConditionParamsY( 
+        LONG lPositiveCoefficient,
+        LONG lNegativeCoefficient = IMM_EFFECT_DONT_CHANGE,
+        DWORD dwPositiveSaturation = IMM_EFFECT_DONT_CHANGE,
+        DWORD dwNegativeSaturation = IMM_EFFECT_DONT_CHANGE,
+        LONG lDeadBand = IMM_EFFECT_DONT_CHANGE,
+        POINT pntCenter = IMM_EFFECT_DONT_CHANGE_POINT,
+        LONG lDirectionX = IMM_EFFECT_DONT_CHANGE,
+        LONG lDirectionY = IMM_EFFECT_DONT_CHANGE
+        );
+
+    BOOL
+	ChangeConditionParamsPolarY( 
+        LONG lPositiveCoefficient,
+        LONG lNegativeCoefficient,
+        DWORD dwPositiveSaturation,
+        DWORD dwNegativeSaturation,
+        LONG lDeadBand,
+        POINT pntCenter,
+        LONG lAngle
+        );
+
+    // Use this form for single-axis, dual-axis symetrical, or directional effects
+    BOOL
+	ChangeConditionParams( 
+        LONG lPositiveCoefficient,
+        LONG lNegativeCoefficient = IMM_EFFECT_DONT_CHANGE,
+        DWORD dwPositiveSaturation = IMM_EFFECT_DONT_CHANGE,
+        DWORD dwNegativeSaturation = IMM_EFFECT_DONT_CHANGE,
+        LONG lDeadBand = IMM_EFFECT_DONT_CHANGE,
+        POINT pntCenter = IMM_EFFECT_DONT_CHANGE_POINT,
+        LONG lDirectionX = IMM_EFFECT_DONT_CHANGE,
+        LONG lDirectionY = IMM_EFFECT_DONT_CHANGE
+        );
+
+    BOOL
+	ChangeConditionParamsPolar( 
+        LONG lPositiveCoefficient,
+        LONG lNegativeCoefficient,
+        DWORD dwPositiveSaturation,
+        DWORD dwNegativeSaturation,
+        LONG lDeadBand,
+        POINT pntCenter,
+        LONG lAngle
+        );
+
+	BOOL ChangePositiveCoefficientX( LONG lPositiveCoefficient );
+	BOOL ChangeNegativeCoefficientX( LONG lNegativeCoefficient );
+	BOOL ChangePositiveSaturationX( DWORD dwPositiveSaturation );
+	BOOL ChangeNegativeSaturationX( DWORD dwNegativeSaturation );
+	BOOL ChangeDeadBandX( LONG lDeadBand );
+
+	BOOL ChangePositiveCoefficientY( LONG lPositiveCoefficient );
+	BOOL ChangeNegativeCoefficientY( LONG lNegativeCoefficient );
+	BOOL ChangePositiveSaturationY( DWORD dwPositiveSaturation );
+	BOOL ChangeNegativeSaturationY( DWORD dwNegativeSaturation );
+	BOOL ChangeDeadBandY( LONG lDeadBand );
+
+	BOOL ChangePositiveCoefficient(	LONG lPositiveCoefficient );
+	BOOL ChangeNegativeCoefficient(	LONG lNegativeCoefficient );
+	BOOL ChangePositiveSaturation( DWORD dwPositiveSaturation );
+	BOOL ChangeNegativeSaturation( DWORD dwNegativeSaturation );
+	BOOL ChangeDeadBand( LONG lDeadBand	);
+
+    BOOL
+	SetCenter( 
+        POINT pntCenter 
+        );
+
+	BOOL 
+	ChangeConditionParams2(
+		IC_ArgumentType type,
+		...
+	);
+
+	BOOL GetPositiveCoefficientX( LONG &lPositiveCoefficient );
+	BOOL GetNegativeCoefficientX( LONG &lNegativeCoefficient );
+	BOOL GetPositiveSaturationX( DWORD &dwPositiveSaturation );
+	BOOL GetNegativeSaturationX( DWORD &dwNegativeSaturation );
+	BOOL GetDeadBandX( LONG &lDeadBand );
+
+	BOOL GetPositiveCoefficientY( LONG &lPositiveCoefficient );
+	BOOL GetNegativeCoefficientY( LONG &lNegativeCoefficient );
+	BOOL GetPositiveSaturationY( DWORD &dwPositiveSaturation );
+	BOOL GetNegativeSaturationY( DWORD &dwNegativeSaturation );
+	BOOL GetDeadBandY( LONG &lDeadBand );
+
+	BOOL GetAxis( DWORD &dwfAxis );
+    BOOL GetCenter( POINT &pntCenter );
+
+    //
+    // OPERATIONS
+    //
+
+    public:
+
+	virtual BOOL
+	Initialize( 
+		CImmDevice* pDevice, 
+		const IMM_EFFECT &effect,
+		DWORD dwNoDownload = 0
+		);
+
+	// Use this form for single-axis and dual-axis effects
+    BOOL 
+	InitCondition( 
+        CImmDevice* pDevice, 
+        LPCIMM_CONDITION pConditionX,
+        LPCIMM_CONDITION pConditionY,
+        BOOL bUseDeviceCoordinates = FALSE,
+		DWORD dwNoDownload = 0
+		);
+
+
+    // Use this form for directional effects
+    BOOL 
+	InitCondition( 
+        CImmDevice* pDevice, 
+        LPCIMM_CONDITION pCondition,
+        LONG lDirectionX,
+        LONG lDirectionY,
+        BOOL bUseDeviceCoordinates = FALSE,
+		DWORD dwNoDownload = 0
+		);
+
+
+    // Use this form for directional effects
+    BOOL 
+    InitConditionPolar( 
+        CImmDevice* pDevice, 
+        LPCIMM_CONDITION pCondition,
+        LONG lAngle,
+        BOOL bUseDeviceCoordinates = FALSE,
+		DWORD dwNoDownload = 0
+		);
+
+
+    // Use this form for single-axis, dual-axis symetrical, or directional effects
+    BOOL 
+    InitCondition( 
+        CImmDevice* pDevice, 
+        LONG lPositiveCoefficient = IMM_CONDITION_DEFAULT_COEFFICIENT,
+        LONG lNegativeCoefficient = IMM_CONDITION_DEFAULT_COEFFICIENT,
+        DWORD dwPositiveSaturation = IMM_CONDITION_DEFAULT_SATURATION,
+        DWORD dwNegativeSaturation = IMM_CONDITION_DEFAULT_SATURATION,
+        LONG lDeadBand = IMM_CONDITION_DEFAULT_DEADBAND,
+        DWORD dwfAxis = IMM_EFFECT_AXIS_BOTH,
+        POINT pntCenter = IMM_CONDITION_DEFAULT_CENTER_POINT,
+        LONG lDirectionX = IMM_EFFECT_DEFAULT_DIRECTION_X,
+        LONG lDirectionY = IMM_EFFECT_DEFAULT_DIRECTION_Y,
+        BOOL bUseDeviceCoordinates = FALSE,
+		DWORD dwNoDownload = 0
+		);
+
+    // Use this form for directional effects
+    BOOL 
+    InitConditionPolar( 
+        CImmDevice* pDevice, 
+        LONG lPositiveCoefficient = IMM_CONDITION_DEFAULT_COEFFICIENT,
+        LONG lNegativeCoefficient = IMM_CONDITION_DEFAULT_COEFFICIENT,
+        DWORD dwPositiveSaturation = IMM_CONDITION_DEFAULT_SATURATION,
+        DWORD dwNegativeSaturation = IMM_CONDITION_DEFAULT_SATURATION,
+        LONG lDeadBand = IMM_CONDITION_DEFAULT_DEADBAND,
+        POINT pntCenter = IMM_CONDITION_DEFAULT_CENTER_POINT,
+        LONG lAngle = IMM_EFFECT_DEFAULT_ANGLE,
+        BOOL bUseDeviceCoordinates = FALSE,
+		DWORD dwNoDownload = 0
+		);
+
+
+    virtual BOOL
+    Start(
+        DWORD dwIterations = 1,
+        DWORD dwFlags = 0,
+		BOOL bAllowStartDelayEmulation = true
+        );
+
+        
+//
+// ------ PRIVATE INTERFACE ------ 
+//
+
+    //
+    // HELPERS
+    //
+
+    protected:
+
+	void
+	convert_line_point_to_offset(
+		POINT pntOnLine
+		);
+
+    BOOL
+    set_parameters( 
+        DWORD dwfAxis,
+        DWORD dwfCoordinates,
+        LONG lDirection0,
+        LONG lDirection1,
+        LPCIMM_CONDITION pConditionX, 
+        LPCIMM_CONDITION pConditionY
+        );
+
+    BOOL
+    set_parameters( 
+        DWORD dwfAxis,
+        DWORD dwfCoordinates,
+        LONG lDirection0,
+        LONG lDirection1,
+        LONG lPositiveCoefficient,
+        LONG lNegativeCoefficient,
+        DWORD dwPositiveSaturation,
+        DWORD dwNegativeSaturation,
+        LONG lDeadBand,
+        POINT pntCenter
+        );
+
+	DWORD
+	change_parameters( 
+		LONG lDirection0,
+		LONG lDirection1,
+		LONG lPositiveCoefficient,
+		LONG lNegativeCoefficient,
+		DWORD dwPositiveSaturation,
+		DWORD dwNegativeSaturation,
+		LONG lDeadBand,
+		POINT pntCenter,
+		int fAxis
+		);
+
+	DWORD
+	change_parameters( 
+		LONG lDirection0,
+		LONG lDirection1,
+		LPCIMM_CONDITION pConditionX, 
+		LPCIMM_CONDITION pConditionY
+		);
+	
+	int
+	buffer_ifr_data(
+		TCHAR* pData
+		);
+
+	BOOL
+	get_ffe_data(
+		LPDIEFFECT pdiEffect
+		);
+
+    //
+    // INTERNAL DATA
+    //
+
+    IMM_CONDITION m_aCondition[2];
+    DWORD m_dwfAxis;
+    BOOL m_bUseMousePosAtStart;
+    
+    protected:
+	    BOOL m_bUseDeviceCoordinates;
+
+};
+
+
+//
+// INLINES
+//
+
+inline BOOL
+CImmCondition::GetIsCompatibleGUID(GUID &guid)
+{
+	return  IsEqualGUID(guid, GUID_Imm_Spring) ||
+			IsEqualGUID(guid, GUID_Imm_DeviceSpring) ||
+			IsEqualGUID(guid, GUID_Imm_Damper) ||
+			IsEqualGUID(guid, GUID_Imm_Inertia) ||
+			IsEqualGUID(guid, GUID_Imm_Friction) ||
+			IsEqualGUID(guid, GUID_Imm_Texture) ||
+			IsEqualGUID(guid, GUID_Imm_Grid);
+}
+
+#endif // !defined(AFX_IMMCondition_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_)
+
diff --git a/code/ff/IFC/ImmConstant.h b/code/ff/IFC/ImmConstant.h
new file mode 100644
index 0000000..6110dd2
--- /dev/null
+++ b/code/ff/IFC/ImmConstant.h
@@ -0,0 +1,219 @@
+/**********************************************************************
+	Copyright (c) 1997 - 2000 Immersion Corporation
+
+	Permission to use, copy, modify, distribute, and sell this
+	software and its documentation may be granted without fee;
+	interested parties are encouraged to request permission from
+		Immersion Corporation
+		801 Fox Lane
+		San Jose, CA 95131
+		408-467-1900
+
+	IMMERSION DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+	INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.
+	IN NO EVENT SHALL IMMERSION BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+	CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+	LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+	NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+	CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+  FILE:		ImmConstant.h
+
+  PURPOSE:	Base Constant Class for Immersion Foundation Classes
+
+  STARTED:	11/03/97
+
+  NOTES/REVISIONS:
+     3/2/99 jrm (Jeff Mallett): Force-->Feel renaming
+	 3/2/99 jrm: Added GetIsCompatibleGUID
+	 3/15/99 jrm: __declspec(dllimport/dllexport) the whole class
+	 11/15/99 sdr (Steve Rank): Converted to IFC
+**********************************************************************/
+
+
+#if !defined(AFX_IMMCONSTANT_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_)
+#define AFX_IMMCONSTANT_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_
+
+#if _MSC_VER >= 1000
+#pragma once
+#endif // _MSC_VER >= 1000
+
+#ifndef _IFCDLL_
+#define DLLIFC __declspec(dllimport)
+#else
+#define DLLIFC __declspec(dllexport)
+#endif
+
+#include "ImmBaseTypes.h"
+#include "ImmEffect.h"
+
+
+
+//================================================================
+// Constants
+//================================================================
+
+const POINT IMM_CONSTANT_DEFAULT_DIRECTION = { 1, 0 };
+#define     IMM_CONSTANT_DEFAULT_DURATION       1000 // Milliseconds
+#define     IMM_CONSTANT_DEFAULT_MAGNITUDE      5000
+
+
+
+//================================================================
+// CImmConstant
+//================================================================
+
+//
+// ------ PUBLIC INTERFACE ------ 
+//
+
+class DLLIFC CImmConstant : public CImmEffect
+{
+    //
+    // CONSTRUCTOR/DESTRUCTOR
+    //
+
+    public:
+    
+    // Constructor
+	CImmConstant();
+
+	// Destructor
+	virtual
+	~CImmConstant();
+
+
+    //
+    // ATTRIBUTES
+    //
+
+    public:
+
+	virtual BOOL
+	GetIsCompatibleGUID(
+		GUID &guid
+		);
+
+	virtual DWORD GetEffectType()
+		{ return IMM_EFFECTTYPE_CONSTANTFORCE; }
+
+	BOOL
+    ChangeParameters( 
+        LONG lDirectionX,
+        LONG lDirectionY,
+        DWORD dwDuration = IMM_EFFECT_DONT_CHANGE,
+        LONG lMagnitude = IMM_EFFECT_DONT_CHANGE,
+        LPIMM_ENVELOPE pEnvelope = (LPIMM_ENVELOPE) IMM_EFFECT_DONT_CHANGE_PTR
+        );
+
+    BOOL
+    ChangeParametersPolar( 
+        LONG lAngle,
+        DWORD dwDuration = IMM_EFFECT_DONT_CHANGE,
+        LONG lMagnitude = IMM_EFFECT_DONT_CHANGE,
+        LPIMM_ENVELOPE pEnvelope = (LPIMM_ENVELOPE) IMM_EFFECT_DONT_CHANGE_PTR
+        );
+
+	BOOL ChangeMagnitude( LONG lMagnitude );
+	BOOL GetMagnitude( LONG &lMagnitude );
+
+    //
+    // OPERATIONS
+    //
+
+    public:
+
+	virtual BOOL
+	Initialize( 
+		CImmDevice* pDevice, 
+		const IMM_EFFECT &effect,
+		DWORD dwNoDownload = 0
+    );
+
+    virtual
+	BOOL
+    Initialize( 
+        CImmDevice* pDevice, 
+        LONG lDirectionX = IMM_EFFECT_DEFAULT_DIRECTION_X,
+        LONG lDirectionY = IMM_EFFECT_DEFAULT_DIRECTION_Y,
+        DWORD dwDuration = IMM_CONSTANT_DEFAULT_DURATION,
+        LONG lMagnitude = IMM_CONSTANT_DEFAULT_MAGNITUDE,
+        LPIMM_ENVELOPE pEnvelope = NULL,
+		DWORD dwNoDownload = 0
+        );
+
+    virtual
+	BOOL
+    InitializePolar( 
+        CImmDevice* pDevice, 
+        LONG lAngle = IMM_EFFECT_DEFAULT_ANGLE,
+        DWORD dwDuration = IMM_CONSTANT_DEFAULT_DURATION,
+        LONG lMagnitude = IMM_CONSTANT_DEFAULT_MAGNITUDE,
+        LPIMM_ENVELOPE pEnvelope = NULL,
+		DWORD dwNoDownload = 0
+        );
+
+        
+//
+// ------ PRIVATE INTERFACE ------ 
+//
+
+    //
+    // HELPERS
+    //
+
+    protected:
+
+    BOOL
+    set_parameters( 
+        DWORD dwfCoordinates,
+        LONG lDirection0,
+        LONG lDirection1,
+        DWORD dwDuration,
+        LONG lMagnitude,
+        LPIMM_ENVELOPE pEnvelope
+        );
+
+	DWORD
+	change_parameters( 
+    LONG lDirection0,
+    LONG lDirection1,
+    DWORD dwDuration,
+    LONG lMagnitude,
+    LPIMM_ENVELOPE pEnvelope
+    );
+
+	int
+	buffer_ifr_data(
+		TCHAR* pData
+		);
+
+	BOOL
+	get_ffe_data(
+		LPDIEFFECT pdiEffect
+		);
+
+    //
+    // INTERNAL DATA
+    //
+
+    IMM_CONSTANTFORCE m_ConstantForce;
+    
+    protected:
+
+};
+
+
+
+//
+// INLINES
+//
+
+inline BOOL
+CImmConstant::GetIsCompatibleGUID(GUID &guid)
+{
+	return IsEqualGUID(guid, GUID_Imm_ConstantForce);
+}
+
+
+#endif // !defined(AFX_IMMCONSTANT_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_)
diff --git a/code/ff/IFC/ImmDXDevice.h b/code/ff/IFC/ImmDXDevice.h
new file mode 100644
index 0000000..d754799
--- /dev/null
+++ b/code/ff/IFC/ImmDXDevice.h
@@ -0,0 +1,148 @@
+/**********************************************************************
+	Copyright (c) 1997 - 2000 Immersion Corporation
+
+	Permission to use, copy, modify, distribute, and sell this
+	software and its documentation may be granted without fee;
+	interested parties are encouraged to request permission from
+		Immersion Corporation
+		801 Fox Lane
+		San Jose, CA 95131
+		408-467-1900
+
+	IMMERSION DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+	INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.
+	IN NO EVENT SHALL IMMERSION BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+	CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+	LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+	NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+	CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+  FILE:		ImmDXDevice.h
+
+  PURPOSE:	Abstraction of DirectX Force Feedback device
+
+  STARTED:	10/10/97
+
+  NOTES/REVISIONS:
+     3/2/99 jrm (Jeff Mallett): Force-->Feel renaming
+	 3/15/99 jrm: __declspec(dllimport/dllexport) the whole class
+
+**********************************************************************/
+
+#ifndef ImmDXDevice_h
+#define ImmDXDevice_h
+
+#ifndef _IFCDLL_
+#define DLLIFC __declspec(dllimport)
+#else
+#define DLLIFC __declspec(dllexport)
+#endif
+
+#include "ImmDevice.h"
+
+
+//================================================================
+// CImmDXDevice
+//================================================================
+
+//
+// ------ PUBLIC INTERFACE ------ 
+//
+
+class DLLIFC CImmDXDevice : public CImmDevice
+{
+
+    //
+    // CONSTRUCTOR/DESCTRUCTOR
+    //
+
+    public:
+    
+    // Constructor
+	CImmDXDevice();
+
+	// Destructor
+    virtual
+	~CImmDXDevice();
+
+
+    //
+    // ATTRIBUTES
+    //
+
+    public:
+
+	virtual LPIIMM_API
+    GetAPI() 
+	{ return (LPIIMM_API) m_piApi; } // actually LPDIRECTINPUT
+
+	virtual LPIIMM_DEVICE
+    GetDevice() 
+	{ return (LPIIMM_DEVICE) m_piDevice; } // actually LPDIRECTINPUTDEVICE2
+
+	virtual DWORD GetProductType();
+
+	virtual BOOL GetDriverVersion(
+		DWORD &dwFFDriverVersion, 
+		DWORD &dwFirmwareRevision, 
+		DWORD &dwHardwareRevision);
+
+	virtual int GetProductName(LPTSTR lpszProductName, int nMaxCount);
+	virtual int GetProductGUIDString(LPTSTR lpszGUID, int nMaxCount);
+	virtual GUID GetProductGUID();
+
+    //
+    // OPERATIONS
+    //
+
+	public:
+
+	BOOL
+	Initialize(
+		HANDLE hinstApp,
+		HANDLE hwndApp,
+		LPDIRECTINPUT pDI = NULL,
+		LPDIRECTINPUTDEVICE2 piDevice = NULL,
+		BOOL bEnumerate = TRUE
+		);
+
+	virtual BOOL
+	GetCurrentPosition( long &lXPos, long &lYPos );
+
+//
+// ------ PRIVATE INTERFACE ------ 
+//
+
+	//
+	// HELPERS
+	//
+
+	protected:
+
+	virtual void
+	reset();
+
+	friend class CImmDevices;
+	static BOOL CALLBACK
+    devices_enum_proc(
+        LPDIDEVICEINSTANCE pImmDevInst, 
+        LPVOID pv
+        );
+
+
+    //
+    // INTERNAL DATA
+    //
+
+    protected:
+
+		// TODO: these are unused... delete them in future rev
+	BOOL m_bpDIPreExist;
+	BOOL m_bpDIDevicePreExist;
+		// end of useless variables
+
+	LPDIRECTINPUT m_piApi;
+	LPDIRECTINPUTDEVICE2 m_piDevice;
+};
+
+#endif // ForceDXDevice_h
diff --git a/code/ff/IFC/ImmDamper.h b/code/ff/IFC/ImmDamper.h
new file mode 100644
index 0000000..68000db
--- /dev/null
+++ b/code/ff/IFC/ImmDamper.h
@@ -0,0 +1,185 @@
+/**********************************************************************
+	Copyright (c) 1997 - 2000 Immersion Corporation
+
+	Permission to use, copy, modify, distribute, and sell this
+	software and its documentation may be granted without fee;
+	interested parties are encouraged to request permission from
+		Immersion Corporation
+		801 Fox Lane
+		San Jose, CA 95131
+		408-467-1900
+
+	IMMERSION DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+	INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.
+	IN NO EVENT SHALL IMMERSION BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+	CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+	LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+	NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+	CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+  FILE:		ImmDamper.h
+
+  PURPOSE:	Immersion Foundation Classes Damper Effect
+  
+  STARTED:	Oct.14.97
+
+  NOTES/REVISIONS:
+     Mar.02.99 jrm (Jeff Mallett): Force-->Feel renaming
+	 Mar.02.99 jrm: Added GetIsCompatibleGUID
+	 Mar.15.99 jrm: __declspec(dllimport/dllexport) the whole class
+	 Nov.15.99 efw (Evan Wies): Converted to IFC
+
+**********************************************************************/
+
+
+#if !defined(AFX_IMMDamper_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_)
+#define AFX_IMMDamper_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_
+
+#if _MSC_VER >= 1000
+#pragma once
+#endif // _MSC_VER >= 1000
+
+#ifndef _IFCDLL_
+#define DLLIFC __declspec(dllimport)
+#else
+#define DLLIFC __declspec(dllexport)
+#endif
+
+#include <windows.h>
+#include "ImmCondition.h"
+
+
+//================================================================
+// Constants
+//================================================================
+
+#define     IMM_DAMPER_DEFAULT_VISCOSITY      2500
+#define     IMM_DAMPER_DEFAULT_SATURATION     10000
+#define     IMM_DAMPER_DEFAULT_MIN_VELOCITY   0
+
+
+
+//================================================================
+// CImmDamper
+//================================================================
+
+//
+// ------ PUBLIC INTERFACE ------ 
+//
+
+class DLLIFC CImmDamper : public CImmCondition
+{
+    //
+    // CONSTRUCTOR/DESTRUCTOR
+    //
+
+    public:
+    
+    // Constructor
+	CImmDamper();
+
+	// Destructor
+	virtual ~CImmDamper();
+
+
+    //
+    // ATTRIBUTES
+    //
+
+    public:
+
+	virtual BOOL
+	GetIsCompatibleGUID(
+		GUID &guid
+		);
+
+    BOOL
+    ChangeParameters( 
+        LONG lViscosity,
+        DWORD dwSaturation = IMM_EFFECT_DONT_CHANGE,
+        DWORD dwMinVelocity = IMM_EFFECT_DONT_CHANGE,
+        LONG lDirectionX = IMM_EFFECT_DONT_CHANGE,
+        LONG lDirectionY = IMM_EFFECT_DONT_CHANGE
+        );
+
+    BOOL
+    ChangeParametersPolar( 
+        LONG lViscosity,
+        DWORD dwSaturation,
+        DWORD dwMinVelocity,
+        LONG lAngle
+        );
+
+	BOOL ChangeViscosity( LONG lViscosity );
+
+	BOOL ChangeMinVelocityX( DWORD dwMinVelocity );
+	BOOL ChangeMinVelocityY( DWORD dwMinVelocity );
+	//For setting both axes to the same value
+	BOOL ChangeMinVelocity( DWORD dwMinVelocity );
+
+	BOOL GetViscosity( LONG &lViscosity );
+
+	BOOL GetMinVelocityX( DWORD &dwMinVelocity );
+	BOOL GetMinVelocityY( DWORD &dwMinVelocity );
+
+    //
+    // OPERATIONS
+    //
+
+    public:
+
+    virtual BOOL 
+    Initialize( 
+        CImmDevice* pDevice, 
+        DWORD dwViscosity = IMM_DAMPER_DEFAULT_VISCOSITY,
+        DWORD dwSaturation = IMM_DAMPER_DEFAULT_SATURATION,
+        DWORD dwMinVelocity = IMM_DAMPER_DEFAULT_MIN_VELOCITY,
+        DWORD dwfAxis = IMM_EFFECT_AXIS_BOTH,
+        LONG lDirectionX = IMM_EFFECT_DEFAULT_DIRECTION_X,
+        LONG lDirectionY = IMM_EFFECT_DEFAULT_DIRECTION_Y,
+		DWORD dwNoDownload = 0
+        );
+
+    virtual BOOL 
+    InitializePolar( 
+        CImmDevice* pDevice, 
+        DWORD dwViscosity,
+        DWORD dwSaturation,
+        DWORD dwMinVelocity,
+        LONG lAngle,
+		DWORD dwNoDownload = 0
+        );
+
+
+//
+// ------ PRIVATE INTERFACE ------ 
+//
+        
+    //
+    // HELPERS
+    //
+
+    protected:
+
+    //
+    // INTERNAL DATA
+    //
+    
+    protected:
+
+};
+
+
+
+//
+// INLINES
+//
+
+inline BOOL
+CImmDamper::GetIsCompatibleGUID(GUID &guid)
+{
+	return IsEqualGUID(guid, GUID_Imm_Damper);
+}
+
+
+#endif // !defined(AFX_IMMDamper_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_)
diff --git a/code/ff/IFC/ImmDevice.h b/code/ff/IFC/ImmDevice.h
new file mode 100644
index 0000000..38959d8
--- /dev/null
+++ b/code/ff/IFC/ImmDevice.h
@@ -0,0 +1,281 @@
+/**********************************************************************
+	Copyright (c) 1997 - 2000 Immersion Corporation
+
+	Permission to use, copy, modify, distribute, and sell this
+	software and its documentation may be granted without fee;
+	interested parties are encouraged to request permission from
+		Immersion Corporation
+		801 Fox Lane
+		San Jose, CA 95131
+		408-467-1900
+
+	IMMERSION DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+	INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.
+	IN NO EVENT SHALL IMMERSION BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+	CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+	LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+	NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+	CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+  FILE:		ImmDevice.h
+
+  PURPOSE:	Abstract Base Device Class for Force Foundation Classes
+
+  STARTED:	10/10/97
+
+  NOTES/REVISIONS:
+     3/2/99 jrm (Jeff Mallett): Force-->Feel renaming
+	 3/15/99 jrm: __declspec(dllimport/dllexport) the whole class
+	 3/16/99 jrm: Made abstract. Moved functionality to CImmMouse/CImmDXDevice
+
+**********************************************************************/
+
+#if !defined(AFX_FORCEDEVICE_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_)
+#define AFX_FORCEDEVICE_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_
+
+#if _MSC_VER >= 1000
+#pragma once
+#endif // _MSC_VER >= 1000
+
+#ifndef _IFCDLL_
+#define DLLIFC __declspec(dllimport)
+#else
+#define DLLIFC __declspec(dllexport)
+#endif
+
+#define DIRECTINPUT_VERSION 0x0800 //[ 0x0300 | 0x0500 | 0x0700 | 0x0800 ]
+#include <dinput.h>
+#include "ImmBaseTypes.h"
+
+#ifdef IFC_EFFECT_CACHING
+ #include "ImmEffectSuite.h"
+#endif
+
+
+//================================================================
+// Device and Technology types
+//================================================================
+
+//Company IDs
+const DWORD IMM_OTHERPARTNER	=0x01000000;
+const DWORD IMM_IMMERSION		=0x02000000;
+const DWORD IMM_ACTLABS			=0x03000000;
+const DWORD IMM_ANKO			=0x04000000;
+const DWORD IMM_AVB				=0x05000000;
+const DWORD IMM_BOEDER			=0x06000000;
+const DWORD IMM_CHPRODUCTS		=0x07000000;
+const DWORD IMM_CHIC			=0x08000000;
+const DWORD IMM_GUILLEMOT		=0x09000000;
+const DWORD IMM_GENIUS			=0x0a000000;
+const DWORD IMM_HAPP			=0x0b000000;
+const DWORD IMM_INTERACT		=0x0c000000;
+const DWORD IMM_INTERACTIVEIO	=0x0d000000;
+const DWORD IMM_KYE				=0x0e000000;
+const DWORD IMM_LMP				=0x0f000000;
+const DWORD IMM_LOGITECH		=0x10000000;
+const DWORD IMM_MADCATZ			=0x11000000;
+const DWORD IMM_MICROSOFT		=0x12000000;
+const DWORD IMM_PADIX			=0x13000000;
+const DWORD IMM_PRIMAX			=0x14000000;
+const DWORD IMM_QUANTUM3D		=0x15000000;
+const DWORD IMM_ROCKFIRE		=0x16000000;
+const DWORD IMM_SCT				=0x17000000;
+const DWORD IMM_SMELECTRONIC	=0x18000000;
+const DWORD IMM_SYSGRATION		=0x19000000;
+const DWORD IMM_THRUSTMASTER	=0x1a000000;
+const DWORD IMM_TRUST			=0x1b000000;
+const DWORD IMM_VIKINGS			=0x1c000000;
+
+// Device IDs
+const DWORD IMM_OTHERDEVICE		=0x00000001;
+const DWORD IMM_JOYSTICK		=0x00000002;
+const DWORD IMM_WHEEL			=0x00000003;
+const DWORD IMM_GAMEPAD			=0x00000004;
+const DWORD IMM_ABSMOUSE		=0x00000005;
+const DWORD IMM_RELMOUSE		=0x00000006;
+
+//Technology IDs
+//Note that these are bit masks
+const DWORD IMM_OTHERTECH		=0x00000001;
+const DWORD IMM_FULLFF			=0x00000002;
+const DWORD IMM_IHDFF			=0x00000004;
+const DWORD IMM_VIBROFF			=0x00000008;
+
+//Product Types (not to be confused with product GUIDs)
+const DWORD IMM_JOYSTICK_FULLFF	= MAKELONG(IMM_FULLFF, IMM_JOYSTICK);
+const DWORD IMM_WHEEL_FULLFF	= MAKELONG(IMM_FULLFF, IMM_WHEEL); 
+const DWORD IMM_GAMEPAD_FULLFF	= MAKELONG(IMM_FULLFF, IMM_GAMEPAD);
+const DWORD IMM_ABSMOUSE_FULLFF	= MAKELONG(IMM_FULLFF, IMM_ABSMOUSE);
+
+const DWORD IMM_JOYSTICK_IHDFF	= MAKELONG(IMM_IHDFF, IMM_JOYSTICK);
+const DWORD IMM_WHEEL_IHDFF		= MAKELONG(IMM_IHDFF, IMM_WHEEL);
+const DWORD IMM_GAMEPAD_IHDFF	= MAKELONG(IMM_IHDFF, IMM_GAMEPAD);
+const DWORD IMM_RELMOUSE_IHDFF	= MAKELONG(IMM_IHDFF, IMM_RELMOUSE);
+
+const DWORD IMM_JOYSTICK_VIBROFF= MAKELONG(IMM_VIBROFF, IMM_JOYSTICK);
+const DWORD IMM_WHEEL_VIBROFF	= MAKELONG(IMM_VIBROFF, IMM_WHEEL);
+const DWORD IMM_GAMEPAD_VIBROFF	= MAKELONG(IMM_VIBROFF, IMM_GAMEPAD);
+const DWORD IMM_RELMOUSE_VIBROFF= MAKELONG(IMM_VIBROFF, IMM_RELMOUSE);
+
+//================================================================
+// CImmDevice
+//================================================================
+
+//
+// ------ PUBLIC INTERFACE ------ 
+//
+
+class DLLIFC CImmDevice  
+{
+    //
+    // CONSTRUCTOR/DESCTRUCTOR
+    //
+
+    public:
+    
+    // Constructor
+	CImmDevice();
+
+	// Destructor
+	virtual
+	~CImmDevice();
+
+
+    //
+    // ATTRIBUTES
+    //
+
+    public:
+
+	virtual LPIIMM_API
+    GetAPI() 
+		= 0; // pure virtual function
+
+	virtual LPIIMM_DEVICE // Will actually return LPDIRECTINPUTDEVICE2 for DX supported device
+    GetDevice()
+		= 0; // pure virtual function
+
+	DWORD
+    GetDeviceType() const
+		{ return m_dwDeviceType; }
+
+	virtual DWORD GetProductType() = 0;
+	virtual BOOL GetDriverVersion(
+		DWORD &dwFFDriverVersion, 
+		DWORD &dwFirmwareRevision, 
+		DWORD &dwHardwareRevision) 
+		= 0;
+
+	virtual int GetProductName(LPTSTR lpszProductName, int nMaxCount) = 0;
+	virtual int GetProductGUIDString(LPTSTR lpszGUID, int nMaxCount) = 0;
+	virtual GUID GetProductGUID() = 0;
+
+	static BOOL GetIFCVersion(DWORD &dwMajor, DWORD &dwMinor, DWORD &dwBuild, DWORD &dwBuildMinor);
+	static BOOL GetImmAPIVersion(DWORD &dwMajor, DWORD &dwMinor, DWORD &dwBuild, DWORD &dwBuildMinor);
+	static BOOL GetDXVersion(DWORD &dwMajor, DWORD &dwMinor, DWORD &dwBuild, DWORD &dwBuildMinor);
+
+    //
+    // OPERATIONS
+    //
+
+    public:
+
+	static CImmDevice *
+	CreateDevice(HINSTANCE hinstApp, HWND hwndApp);
+	
+	virtual BOOL
+	GetCurrentPosition( long &lXPos, long &lYPos )
+		= 0; // pure virtual function
+
+    virtual BOOL 
+    ChangeScreenResolution( 
+		BOOL bAutoSet,
+		DWORD dwXScreenSize = 0,
+		DWORD dwYScreenSize = 0
+		);
+
+	// The default state is using standard Win32 Mouse messages (e.g., WM_MOUSEMOVE)  
+	// and functions (e.g, GetCursorPos).  Call only to switch to relative mode
+	// if not using standard Win32 Mouse services (e.g., DirectInput) for mouse
+	// input.  
+	BOOL
+	UsesWin32MouseServices(
+		BOOL bWin32MouseServ
+		);
+
+	// Another syntax for SwitchToAbsoluteMode.
+	// The default is Absolute mode.  Call only to switch to Relative mode or
+	// to switch back to Absolute mode.
+	virtual BOOL
+	SwitchToAbsoluteMode(
+		BOOL bAbsMode
+		);
+
+//
+// ------ PRIVATE INTERFACE ------ 
+//
+
+    //
+    // CACHING
+    //
+
+#ifdef IFC_EFFECT_CACHING
+	public:
+
+	void Cache_AddEffect(CImmEffect *pImmEffect);
+	void Cache_RemoveEffect(const CImmEffect *pImmEffect);
+	void Cache_SwapOutEffect();
+
+    protected:
+
+	void Cache_LoadEffectSuite(CImmEffectSuite *pSuite, BOOL bCreateOnDevice);
+	void Cache_UnloadEffectSuite(CImmEffectSuite *pSuite, BOOL bUnloadFromDevice);
+
+	CEffectList m_Cache; // List of all effects created on device
+#endif
+
+    //
+    // HELPERS
+    //
+
+    protected:
+
+    // Performs device preparation by setting the device's parameters
+    virtual BOOL 
+    prepare_device();
+
+    virtual void
+	reset()
+		= 0; // pure virtual function
+
+	static BOOL CALLBACK
+    enum_didevices_proc(
+        LPDIDEVICEINSTANCE pImmDevInst, 
+        LPVOID pv
+        );
+
+	static BOOL CALLBACK
+    enum_devices_proc(
+        LPIMM_DEVICEINSTANCE pImmDevInst, 
+        LPVOID pv
+        );
+
+	void
+	detach_effects();
+
+    //
+    // INTERNAL DATA
+    //
+
+    protected:
+	
+	BOOL m_bInitialized;
+    DWORD m_dwDeviceType;
+	GUID m_guidDevice;
+	BOOL m_bGuidValid;
+	DWORD m_dwProductType;
+
+};
+
+
+#endif // !defined(AFX_FORCEDEVICE_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_)
diff --git a/code/ff/IFC/ImmDevices.h b/code/ff/IFC/ImmDevices.h
new file mode 100644
index 0000000..bd89210
--- /dev/null
+++ b/code/ff/IFC/ImmDevices.h
@@ -0,0 +1,156 @@
+/**********************************************************************
+	Copyright (c) 2000 Immersion Corporation
+
+	Permission to use, copy, modify, distribute, and sell this
+	software and its documentation may be granted without fee;
+	interested parties are encouraged to request permission from
+		Immersion Corporation
+		801 Fox Lane
+		San Jose, CA 95131
+		408-467-1900
+
+	IMMERSION DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+	INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.
+	IN NO EVENT SHALL IMMERSION BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+	CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+	LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+	NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+	CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+  FILE:		ImmDevices.h
+
+  PURPOSE:	Abstract Base Device Class for Immersion Foundation Classes
+
+  STARTED:	3/29/00
+
+  NOTES/REVISIONS:
+     3/29/00 jrm (Jeff Mallett): Started
+
+**********************************************************************/
+
+#if !defined(AFX_FORCEDEVICES_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_)
+#define AFX_FORCEDEVICES_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_
+
+#if _MSC_VER >= 1000
+#pragma once
+#endif // _MSC_VER >= 1000
+
+#ifndef _IFCDLL_
+#define DLLIFC __declspec(dllimport)
+#else
+#define DLLIFC __declspec(dllexport)
+#endif
+
+#include "ImmBaseTypes.h"
+
+
+
+typedef enum {
+	IMM_ENUMERATE_IMM_DEVICES = 0x00000001,
+	IMM_ENUMERATE_DX_DEVICES  = 0x00000002,
+	IMM_ENUMERATE_ALL         = 0xFFFFFFFF
+} IMM_ENUMERATE;
+
+typedef enum {
+	IMM_NO_PREFERENCE      = 0x00000000,
+	IMM_PREFER_IMM_DEVICES = 0x00000001,
+	IMM_PREFER_DX_DEVICES  = 0x00000002
+} IMM_ENUMERATE_PREFERENCE;
+
+class CImmDevices;
+class CInitializeEnum {
+public:
+	HANDLE m_hinstApp;
+	HANDLE m_hwndApp;
+	DWORD m_dwCooperativeFlag;
+	CImmDevices *m_pDevices;
+	long m_lMaximumDevices;
+};
+
+//================================================================
+// CImmDevices
+//================================================================
+
+typedef class CImmDevice * IMM_DEVICE_PTR;
+
+
+//
+// ------ PUBLIC INTERFACE ------ 
+//
+
+class DLLIFC CImmDevices {
+
+    //
+    // CONSTRUCTOR/DESCTRUCTOR
+    //
+
+    public:
+
+	CImmDevices();
+	~CImmDevices();
+
+
+    //
+    // ATTRIBUTES
+    //
+
+    public:
+
+	long
+	GetNumDevices()
+		{ return m_lNumDevices; }
+
+	IMM_DEVICE_PTR
+	GetDevice(long lIndex);
+
+
+    //
+    // OPERATIONS
+    //
+
+    public:
+
+	void
+	AddDevice(IMM_DEVICE_PTR pDevice);
+
+	long
+	CreateDevices(
+		HINSTANCE hinstApp,
+		HWND hwndApp,
+		long lMaximumDevices = -1, // means "all"
+		IMM_ENUMERATE type = IMM_ENUMERATE_ALL,
+		IMM_ENUMERATE_PREFERENCE preference = IMM_NO_PREFERENCE
+		);
+
+
+//
+// ------ PRIVATE INTERFACE ------ 
+//
+
+    //
+    // HELPERS
+    //
+
+protected:
+
+	BOOL
+	enumerate_dx_devices(CInitializeEnum *pIE);
+
+	BOOL
+	enumerate_imm_devices(CInitializeEnum *pIE);
+
+	void
+	clean_up();
+
+    //
+    // INTERNAL DATA
+    //
+    
+    protected:
+
+	long m_lNumDevices;
+	IMM_DEVICE_PTR *m_DeviceArray;
+};
+
+#endif // !defined(AFX_FORCEDEVICE_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_)
+
diff --git a/code/ff/IFC/ImmEffect.h b/code/ff/IFC/ImmEffect.h
new file mode 100644
index 0000000..dfeceea
--- /dev/null
+++ b/code/ff/IFC/ImmEffect.h
@@ -0,0 +1,440 @@
+/**********************************************************************
+	Copyright (c) 1997 - 2000 Immersion Corporation
+
+	Permission to use, copy, modify, distribute, and sell this
+	software and its documentation may be granted without fee;
+	interested parties are encouraged to request permission from
+		Immersion Corporation
+		801 Fox Lane
+		San Jose, CA 95131
+		408-467-1900
+
+	IMMERSION DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+	INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.
+	IN NO EVENT SHALL IMMERSION BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+	CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+	LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+	NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+	CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+  FILE:		ImmEffect.h
+
+  PURPOSE:	Immersion Foundation Classes Base Effect
+  
+  STARTED:	Oct.10.97
+
+  NOTES/REVISIONS:
+     Mar.02.99 jrm (Jeff Mallett): Force-->Feel renaming
+	 Mar.02.99 jrm: Added GetIsCompatibleGUID and feel_to_DI_GUID
+	 Mar.15.99 jrm: __declspec(dllimport/dllexport) the whole class
+	 Nov.15.99 efw (Evan Wies): Converted to IFC
+
+**********************************************************************/
+
+
+#if !defined(AFX_IMMEffect_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_)
+#define AFX_IMMEffect_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_
+
+#if _MSC_VER >= 1000
+#pragma once
+#endif // _MSC_VER >= 1000
+
+#ifndef _IFCDLL_
+#define DLLIFC __declspec(dllimport)
+#else
+#define DLLIFC __declspec(dllexport)
+#endif
+
+#include "ImmBaseTypes.h"
+#include "ImmDevice.h"
+class CImmProject;
+
+//================================================================
+// Constants
+//================================================================
+
+#define     IMM_EFFECT_AXIS_X             1
+#define     IMM_EFFECT_AXIS_Y             2
+#define     IMM_EFFECT_AXIS_BOTH          3
+#define     IMM_EFFECT_AXIS_DIRECTIONAL   4
+#define     IMM_EFFECT_DONT_CHANGE        MINLONG
+#define     IMM_EFFECT_DONT_CHANGE_PTR    MAXDWORD
+const POINT IMM_EFFECT_DONT_CHANGE_POINT	= { 0xFFFFFFFF, 0xFFFFFFFF };
+const POINT IMM_EFFECT_MOUSE_POS_AT_START	= { MAXLONG, MAXLONG };
+
+#define     IMM_EFFECT_DEFAULT_ENVELOPE   	NULL
+#define     IMM_EFFECT_DEFAULT_DIRECTION_X	1
+#define     IMM_EFFECT_DEFAULT_DIRECTION_Y	1
+#define     IMM_EFFECT_DEFAULT_ANGLE		0
+
+// GENERIC_EFFECT_PTR
+// This is really a pointer to a child of CImmEffect.
+typedef class CImmEffect * 	GENERIC_EFFECT_PTR;
+
+
+//================================================================
+// CImmEffect
+//================================================================
+
+//
+// ------ PUBLIC INTERFACE ------ 
+//
+
+class DLLIFC CImmEffect  
+{
+    //
+    // CONSTRUCTOR/DESTRUCTOR
+    //
+
+    public:
+    
+    // Constructor
+	CImmEffect(
+		const GUID& rguidEffect
+		);
+
+	// Destructor
+	virtual
+	~CImmEffect();
+
+    //
+    // ATTRIBUTES
+    //
+
+    public:
+
+	LPIIMM_EFFECT
+    GetEffect() 
+		{ return m_piImmEffect; }
+
+	CImmDevice* 
+	GetDevice() 
+		{ return m_pImmDevice; }
+
+    BOOL 
+    GetStatus(
+		DWORD* pdwStatus
+		);
+
+	void
+	GetParameters(IMM_EFFECT &Effect);
+	BOOL GetEnvelope( LPIMM_ENVELOPE pEnvelope );
+
+	BOOL GetDuration( DWORD &dwDuration );
+	BOOL GetGain( DWORD &dwGain );
+	BOOL GetStartDelay(	DWORD &dwStartDelay );
+	BOOL GetTriggerButton( DWORD &dwTriggerButton );
+	BOOL GetTriggerRepeatInterval( DWORD &dwTriggerRepeatInterval );
+	BOOL GetDirection( LONG &lDirectionX, LONG &lDirectionY );
+	BOOL GetDirection( LONG &lAngle );
+
+	BOOL GetIterations( DWORD &dwIterations );
+
+    GUID
+	GetGUID()
+		{ return m_guidEffect; }
+
+	virtual BOOL
+	GetIsCompatibleGUID(
+		GUID & /* guid */
+		)
+		{ return true; }
+ 
+	virtual DWORD GetEffectType()
+	{ return 0;	}
+	
+	LPCSTR
+	GetName()
+		{ return m_lpszName; }
+
+	// Allocates an object of the correct IFC class from the given GUID
+	static GENERIC_EFFECT_PTR
+	NewObjectFromGUID(
+		GUID &guid
+		);
+
+    BOOL
+    ChangeBaseParams( 
+        LONG lDirectionX,
+        LONG lDirectionY,
+        DWORD dwDuration = IMM_EFFECT_DONT_CHANGE,
+        LPIMM_ENVELOPE pEnvelope = (LPIMM_ENVELOPE) IMM_EFFECT_DONT_CHANGE_PTR,
+        DWORD dwSamplePeriod = IMM_EFFECT_DONT_CHANGE,
+        DWORD dwGain = IMM_EFFECT_DONT_CHANGE,
+        DWORD dwTriggerButton = IMM_EFFECT_DONT_CHANGE,
+        DWORD dwTriggerRepeatInterval = IMM_EFFECT_DONT_CHANGE
+#ifdef IFC_START_DELAY
+		,DWORD dwStartDelay = IMM_EFFECT_DONT_CHANGE // milliseconds
+#endif
+		);
+
+    BOOL
+    ChangeBaseParamsPolar( 
+        LONG lAngle,
+        DWORD dwDuration = IMM_EFFECT_DONT_CHANGE, // milliseconds
+        LPIMM_ENVELOPE pEnvelope = (LPIMM_ENVELOPE) IMM_EFFECT_DONT_CHANGE_PTR,
+        DWORD dwSamplePeriod = IMM_EFFECT_DONT_CHANGE,
+        DWORD dwGain = IMM_EFFECT_DONT_CHANGE,
+        DWORD dwTriggerButton = IMM_EFFECT_DONT_CHANGE,
+        DWORD dwTriggerRepeatInterval = IMM_EFFECT_DONT_CHANGE
+#ifdef IFC_START_DELAY
+		,DWORD dwStartDelay = IMM_EFFECT_DONT_CHANGE // milliseconds
+#endif
+		);
+
+    BOOL
+    ChangeDirection( 
+        LONG lDirectionX,
+        LONG lDirectionY 
+		);
+
+    BOOL
+    ChangeDirection( 
+        LONG lAngle
+        );
+
+	BOOL
+	ChangeDuration(
+		DWORD dwDuration
+		);
+
+	BOOL
+	ChangeGain(
+		DWORD dwGain
+		);
+
+	BOOL 
+	ChangeStartDelay(
+		DWORD dwStartDelay
+		);
+
+	BOOL 
+	ChangeTriggerButton(
+		DWORD dwTriggerButton
+		);
+
+	BOOL 
+	ChangeTriggerRepeatInterval(
+		DWORD dwTriggerRepeatInterval
+		);
+
+	BOOL 
+	ChangeIterations(
+		DWORD dwIterations
+		);
+
+    BOOL
+    ChangeEnvelope(
+        DWORD dwAttackLevel,
+        DWORD dwAttackTime, // microseconds
+        DWORD dwFadeLevel,
+        DWORD dwFadeTime // microseconds
+        );
+
+    BOOL
+    ChangeEnvelope(
+        LPIMM_ENVELOPE pEnvelope
+        );
+
+
+    //
+    // OPERATIONS
+    //
+
+    public:
+
+    virtual BOOL
+    Initialize( 
+        CImmDevice* pDevice, 
+        const IMM_EFFECT &effect,
+		DWORD dwNoDownload = 0
+        );
+
+	virtual BOOL 
+	InitializeFromProject(
+		CImmProject &project,
+		LPCSTR lpszEffectName,
+		CImmDevice* pDevice = NULL,
+		DWORD dwNoDownload = 0
+	);
+
+	virtual BOOL 
+	Start(
+        DWORD dwIterations = IMM_EFFECT_DONT_CHANGE,
+        DWORD dwFlags = 0
+#ifdef IFC_START_DELAY
+		, BOOL bAllowStartDelayEmulation = true
+#endif
+        );
+
+    virtual BOOL 
+    Stop();
+   
+
+//
+// ------ PRIVATE INTERFACE ------ 
+//
+
+	//
+    // CACHING
+    //
+
+#ifdef IFC_EFFECT_CACHING
+
+	public:
+
+	friend class CEffectList;
+	friend class CImmCompoundEffect;
+
+	BOOL GetIsPlaying();
+	BOOL GetIsTriggered() const;
+	short GetPriority() const { return m_Priority; }
+	void SetPriority(short priority) { m_Priority = priority; }
+	virtual HRESULT Unload();
+	virtual void Reload();
+
+	//Althought public, this should only be used internally.
+	BOOL
+	set_outside_effect( 
+		CImmEffect* pImmOutsideEffect 
+		);
+
+	BOOL
+	get_is_inside_effect()
+		{ return m_bIsInsideEffect; }
+
+	public:
+
+	ECacheState m_CacheState; // effect's status in the cache
+	BOOL m_bInCurrentSuite; // is the effect in the currently loaded suite?
+	short m_Priority; // Priority within suite: higher number is higher priority
+	DWORD m_dwLastStarted; // when last started (0 = never) or when param change made on device
+	DWORD m_dwLastStopped; // when last stopped (0 = not since last start)
+	DWORD m_dwLastLoaded; // when last loaded with CImmEffectSuite::Load or Create
+
+    protected:
+
+	CImmDevice *m_pImmDevice; // ### Use instead of m_piImmDevice
+#endif
+
+	//
+    // HELPERS
+    //
+    protected:
+
+#ifdef IFC_START_DELAY
+	void EmulateStartDelay(
+		DWORD dwIterations,
+		DWORD dwNoDownload
+		);
+#endif
+
+#ifdef IFC_EFFECT_CACHING
+	public: // initalize needs to be called by CImmDevice
+#endif
+   BOOL 
+    initialize( 
+        CImmDevice* pDevice,
+		DWORD dwNoDownload
+        );
+#ifdef IFC_EFFECT_CACHING
+	protected:
+#endif
+
+	HRESULT
+	set_parameters_on_device(
+		DWORD dwFlags
+		);
+
+	BOOL
+	set_name(
+		const char *lpszName
+		);
+
+	void 
+	imm_to_DI_GUID( 
+		GUID &guid
+		);
+
+	void 
+	DI_to_imm_GUID( 
+		GUID &guid
+		);
+
+    void
+    reset();
+
+    void
+    reset_effect_struct();
+
+	void
+	reset_device();
+
+	void
+	buffer_direction(
+		TCHAR** pData
+		);
+
+	void
+	buffer_long_param(
+		TCHAR** pData, 
+		LPCSTR lpszKey, 
+		long lDefault, 
+		long lValue
+		);
+
+	void
+	buffer_dword_param(
+		TCHAR** pData, 
+		LPCSTR lpszKey, 
+		DWORD dwDefault, 
+		DWORD dwValue
+		);
+
+	virtual int
+	buffer_ifr_data(
+		TCHAR* pData
+		);
+
+	virtual BOOL
+	get_ffe_data(
+		LPDIEFFECT pdiEffect
+		);
+
+
+    //
+    // INTERNAL DATA
+    //
+
+    protected:
+
+    IMM_EFFECT m_Effect;
+    DWORD m_dwaAxes[2];
+    LONG m_laDirections[2];
+	IMM_ENVELOPE m_Envelope;
+
+    GUID m_guidEffect;
+    BOOL m_bIsPlaying;
+	DWORD m_dwDeviceType;
+    LPIIMM_DEVICE m_piImmDevice; // Might also be holding LPDIRECTINPUTDEVICE2
+    LPIIMM_EFFECT m_piImmEffect;
+	DWORD m_cAxes; // Number of axes
+	DWORD m_dwNoDownload;
+	DWORD m_dwIterations;
+	char *m_lpszName; // Name of this effect primative
+
+	// Needed for co-ordinating events for Enclosures/Ellipes and the inside effects.
+	BOOL m_bIsInsideEffect;
+	CImmEffect* m_pOutsideEffect;
+
+#ifdef IFC_START_DELAY
+	public:
+	// Prevents access to dangling pointer when this is deleted
+	// All relevent code may be removed when all hardware and drivers support start delay
+	CImmEffect **m_ppTimerRef; // pointer to pointer to this.
+#endif
+};
+
+
+#endif // !defined(AFX_ImmEffect_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_)
+
diff --git a/code/ff/IFC/ImmEffectSuite.h b/code/ff/IFC/ImmEffectSuite.h
new file mode 100644
index 0000000..e1ed622
--- /dev/null
+++ b/code/ff/IFC/ImmEffectSuite.h
@@ -0,0 +1,103 @@
+
+/**********************************************************************
+	Copyright (c) 1999 - 2000 Immersion Corporation
+
+	Permission to use, copy, modify, distribute, and sell this
+	software and its documentation may be granted without fee;
+	interested parties are encouraged to request permission from
+		Immersion Corporation
+		801 Fox Lane
+		San Jose, CA 95131
+		408-467-1900
+
+	IMMERSION DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+	INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.
+	IN NO EVENT SHALL IMMERSION BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+	CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+	LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+	NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+	CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+  FILE:		ImmEffectSuite.h
+
+  PURPOSE:	Caching of effects
+
+  STARTED:	6/16/99 Jeff Mallett
+
+  NOTES/REVISIONS:
+
+**********************************************************************/
+
+#if !defined(AFX_FEELEFFECTSUITE_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_)
+#define AFX_FEELEFFECTSUITE_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_
+
+#if _MSC_VER >= 1000
+#pragma once
+#endif // _MSC_VER >= 1000
+
+#ifndef _IFCDLL_
+#define DLLIFC __declspec(dllimport)
+#else
+#define DLLIFC __declspec(dllexport)
+#endif
+
+#include "ImmBaseTypes.h"
+
+#ifdef IFC_EFFECT_CACHING
+
+class CImmDevice; //#include "ImmDevice.h"
+class CImmEffect; //#include "ImmEffect.h"
+
+typedef enum {
+	IMMCACHE_NOT_ON_DEVICE,
+	IMMCACHE_ON_DEVICE,
+	IMMCACHE_SWAPPED_OUT
+} ECacheState;
+
+
+//================================================================
+// CEffectList, CEffectListElement
+//================================================================
+
+class DLLIFC CEffectListElement
+{
+public:
+	CEffectListElement() : m_pImmEffect(NULL), m_pNext(NULL) { }
+
+	CImmEffect *m_pImmEffect;
+	CEffectListElement *m_pNext;
+};
+
+class DLLIFC CEffectList
+{
+public:
+	CEffectList() : m_pFirstEffect(NULL) { }
+	~CEffectList();
+	BOOL AddEffect(CImmEffect *pImmEffect);
+	BOOL RemoveEffect(const CImmEffect *pImmEffect);
+	void ClearDevice(CImmDevice *pImmDevice);
+
+	CEffectListElement *m_pFirstEffect;
+};
+
+
+//================================================================
+// CImmEffectSuite
+//================================================================
+
+class CImmEffectSuite
+{
+public:
+	CImmEffectSuite() : m_bCurrentSuite(false) { }
+	CEffectListElement *GetFirstEffect();
+	void AddEffect(CImmEffect *pImmEffect);
+	void RemoveEffect(CImmEffect *pImmEffect);
+	void SetPriorities(short priority);
+
+	BOOL m_bCurrentSuite; // Is the suite the "current suite"?
+private:
+	CEffectList m_EffectList; // List of effects in suite
+};
+
+#endif // IFC_EFFECT_CACHING
+#endif // !defined(AFX_FEELEFFECTSUITE_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_)
diff --git a/code/ff/IFC/ImmEllipse.h b/code/ff/IFC/ImmEllipse.h
new file mode 100644
index 0000000..155d416
--- /dev/null
+++ b/code/ff/IFC/ImmEllipse.h
@@ -0,0 +1,295 @@
+/**********************************************************************
+	Copyright (c) 1997 - 2000 Immersion Corporation
+
+	Permission to use, copy, modify, distribute, and sell this
+	software and its documentation may be granted without fee;
+	interested parties are encouraged to request permission from
+		Immersion Corporation
+		801 Fox Lane
+		San Jose, CA 95131
+		408-467-1900
+
+	IMMERSION DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+	INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.
+	IN NO EVENT SHALL IMMERSION BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+	CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+	LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+	NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+	CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+  FILE:		ImmEllipse.h
+
+  PURPOSE:	Base Ellipse Class for Immersion Foundation Classes
+
+  STARTED:	10/29/97
+
+  NOTES/REVISIONS:
+     3/2/99 jrm (Jeff Mallett): Force-->Feel renaming
+	 3/2/99 jrm: Added GetIsCompatibleGUID
+	 3/15/99 jrm: __declspec(dllimport/dllexport) the whole class
+	 11/15/99 sdr (Steve Rank): Converted to IFC
+
+**********************************************************************/
+
+
+#if !defined(AFX_IMMELLIPSE_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_)
+#define AFX_IMMELLIPSE_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_
+
+#if _MSC_VER >= 1000
+#pragma once
+#endif // _MSC_VER >= 1000
+
+#ifndef _IFCDLL_
+#define DLLIFC __declspec(dllimport)
+#else
+#define DLLIFC __declspec(dllexport)
+#endif
+
+#include "ImmBaseTypes.h"
+#include "ImmEffect.h"
+
+
+
+//================================================================
+// Constants
+//================================================================
+
+#define     IMM_ELLIPSE_DEFAULT_STIFFNESS      5000
+#define     IMM_ELLIPSE_DEFAULT_SATURATION     10000
+#define     IMM_ELLIPSE_DEFAULT_WIDTH          10
+#define     IMM_ELLIPSE_HEIGHT_AUTO            MAXDWORD
+#define     IMM_ELLIPSE_DEFAULT_HEIGHT         IMM_ELLIPSE_HEIGHT_AUTO
+#define     IMM_ELLIPSE_WALL_WIDTH_AUTO        MAXDWORD
+#define     IMM_ELLIPSE_DEFAULT_WALL_WIDTH     IMM_ELLIPSE_WALL_WIDTH_AUTO
+#define     IMM_ELLIPSE_DEFAULT_STIFFNESS_MASK IMM_STIFF_ANYWALL
+#define     IMM_ELLIPSE_DEFAULT_CLIPPING_MASK  IMM_CLIP_NONE
+
+#define     IMM_ELLIPSE_DEFAULT_CENTER_POINT   IMM_EFFECT_MOUSE_POS_AT_START
+
+
+
+
+
+//================================================================
+// CImmEllipse
+//================================================================
+
+//
+// ------ PUBLIC INTERFACE ------ 
+//
+
+class DLLIFC CImmEllipse : public CImmEffect
+{
+    //
+    // CONSTRUCTOR/DESCTRUCTOR
+    //
+
+    public:
+    
+    // Constructor
+	CImmEllipse();
+
+	// Destructor
+	virtual
+	~CImmEllipse();
+
+
+    //
+    // ATTRIBUTES
+    //
+
+    public:
+
+	virtual BOOL
+	GetIsCompatibleGUID(
+		GUID &guid
+		);
+
+	virtual DWORD GetEffectType()
+		{ return IMM_EFFECTTYPE_ELLIPSE; }
+
+    BOOL
+    ChangeParameters( 
+        POINT pntCenter,
+        DWORD dwWidth = IMM_EFFECT_DONT_CHANGE,
+        DWORD dwHeight = IMM_EFFECT_DONT_CHANGE,
+        LONG lStiffness = IMM_EFFECT_DONT_CHANGE,
+        DWORD dwWallThickness = IMM_EFFECT_DONT_CHANGE,
+        DWORD dwSaturation = IMM_EFFECT_DONT_CHANGE,
+        DWORD dwStiffnessMask = IMM_EFFECT_DONT_CHANGE,
+        DWORD dwClippingMask = IMM_EFFECT_DONT_CHANGE,
+        CImmEffect* pInsideEffect = (CImmEffect*) IMM_EFFECT_DONT_CHANGE,
+		LONG lAngle = IMM_EFFECT_DONT_CHANGE
+        );
+
+    BOOL
+    ChangeParameters( 
+        LPCRECT pRectOutside,
+        LONG lStiffness = IMM_EFFECT_DONT_CHANGE,
+        DWORD dwWallThickness = IMM_EFFECT_DONT_CHANGE,
+        DWORD dwSaturation = IMM_EFFECT_DONT_CHANGE,
+        DWORD dwStiffnessMask = IMM_EFFECT_DONT_CHANGE,
+        DWORD dwClippingMask = IMM_EFFECT_DONT_CHANGE,
+        CImmEffect* pInsideEffect = (CImmEffect*) IMM_EFFECT_DONT_CHANGE,  
+		LONG lAngle = IMM_EFFECT_DONT_CHANGE
+        );
+
+	
+	BOOL ChangeStiffness	( LONG lStiffness );
+	BOOL ChangeWallThickness( DWORD dwThickness	);
+	BOOL ChangeSaturation	( DWORD dwSaturation );
+	BOOL ChangeStiffnessMask( DWORD dwStiffnessMask );
+	BOOL ChangeClippingMask	( DWORD dwClippingMask );
+	BOOL ChangeInsideEffect	( CImmEffect* pInsideEffect );
+
+    BOOL
+    ChangeRect( 
+        LPCRECT pRect 
+        );
+
+
+    BOOL
+    ChangeCenter( 
+        POINT pntCenter 
+        );
+
+
+    BOOL
+    ChangeCenter( 
+        LONG x, 
+        LONG y 
+        );
+
+	BOOL GetStiffness	( LONG &lStiffness );
+	BOOL GetWallThickness( DWORD &dwThickness	);
+	BOOL GetSaturation	( DWORD &dwSaturation );
+	BOOL GetStiffnessMask( DWORD &dwStiffnessMask );
+	BOOL GetClippingMask	( DWORD &dwClippingMask );
+
+	BOOL GetRect( RECT* pRect );
+	BOOL GetCenter( POINT &pntCenter );
+	BOOL GetCenter( LONG &x, LONG &y);
+
+	CImmEffect* GetInsideEffect();
+
+    //
+    // OPERATIONS
+    //
+
+    public:
+
+	virtual BOOL
+	Initialize( 
+		CImmDevice* pDevice, 
+		const IMM_EFFECT &effect,
+		DWORD dwNoDownload = 0
+    );
+
+    BOOL 
+    Initialize( 
+        CImmDevice* pDevice, 
+        DWORD dwWidth = IMM_ELLIPSE_DEFAULT_WIDTH,
+        DWORD dwHeight = IMM_ELLIPSE_DEFAULT_HEIGHT,
+        LONG lStiffness = IMM_ELLIPSE_DEFAULT_STIFFNESS,
+        DWORD dwWallWidth = IMM_ELLIPSE_DEFAULT_WALL_WIDTH,
+        DWORD dwSaturation = IMM_ELLIPSE_DEFAULT_SATURATION,
+        DWORD dwStiffnessMask = IMM_ELLIPSE_DEFAULT_STIFFNESS_MASK,
+        DWORD dwClippingMask = IMM_ELLIPSE_DEFAULT_CLIPPING_MASK,
+        POINT pntCenter = IMM_ELLIPSE_DEFAULT_CENTER_POINT,
+        CImmEffect* pInsideEffect = NULL,  
+		LONG lAngle = IMM_EFFECT_DEFAULT_ANGLE,
+		DWORD dwNoDownload = 0
+        );
+
+
+    BOOL 
+    Initialize( 
+        CImmDevice* pDevice, 
+        LPCRECT pRectOutside,
+        LONG lStiffness = IMM_ELLIPSE_DEFAULT_STIFFNESS,
+        DWORD dwWallWidth = IMM_ELLIPSE_DEFAULT_WALL_WIDTH,
+        DWORD dwSaturation = IMM_ELLIPSE_DEFAULT_SATURATION,
+        DWORD dwStiffnessMask = IMM_ELLIPSE_DEFAULT_STIFFNESS_MASK,
+        DWORD dwClippingMask = IMM_ELLIPSE_DEFAULT_CLIPPING_MASK,
+        CImmEffect* pInsideEffect = NULL,  
+ 		LONG lAngle = IMM_EFFECT_DEFAULT_ANGLE,
+		DWORD dwNoDownload = 0
+        );
+
+
+    virtual BOOL 
+	Start(
+        DWORD dwIterations = 1,
+        DWORD dwFlags = 0, 
+		BOOL bAllowStartDelayEmulation = true
+		);
+
+	HRESULT Unload();
+	void Reload();
+
+        
+//
+// ------ PRIVATE INTERFACE ------ 
+//
+
+    //
+    // HELPERS
+    //
+
+    protected:
+
+    BOOL
+        set_parameters( 
+        LPCRECT pRectOutside,
+        LONG lStiffness,
+        DWORD dwWallWidth,
+        DWORD dwSaturation,
+        DWORD dwStiffnessMask,
+        DWORD dwClippingMask,
+        CImmEffect* pInsideEffect,
+		LONG lAngle
+        );
+	
+	DWORD
+	change_parameters( 
+		LPCRECT prectBoundary,
+		LONG lStiffness,
+		DWORD dwWallThickness,
+		DWORD dwSaturation,
+		DWORD dwStiffnessMask,
+		DWORD dwClippingMask,
+		CImmEffect* pInsideEffect,
+		LONG lAngle
+		);
+	
+	int
+	buffer_ifr_data(
+		TCHAR* pData
+		);
+
+    //
+    // INTERNAL DATA
+    //
+    
+    protected:
+
+    IMM_ELLIPSE m_ellipse;
+    BOOL m_bUseMousePosAtStart;
+
+	// Needed for co-ordinating events for Enclosures/Ellipes and the inside effects.
+	CImmEffect*	m_pInsideEffect;
+};
+
+
+
+//
+// INLINES
+//
+
+inline BOOL
+CImmEllipse::GetIsCompatibleGUID(GUID &guid)
+{
+	return IsEqualGUID(guid, GUID_Imm_Ellipse);
+}
+
+#endif // !defined(AFX_IMMELLIPSE_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_)
diff --git a/code/ff/IFC/ImmEnclosure.h b/code/ff/IFC/ImmEnclosure.h
new file mode 100644
index 0000000..4697b28
--- /dev/null
+++ b/code/ff/IFC/ImmEnclosure.h
@@ -0,0 +1,325 @@
+/**********************************************************************
+	Copyright (c) 1997 - 2000 Immersion Corporation
+
+	Permission to use, copy, modify, distribute, and sell this
+	software and its documentation may be granted without fee;
+	interested parties are encouraged to request permission from
+		Immersion Corporation
+		801 Fox Lane
+		San Jose, CA 95131
+		408-467-1900
+
+	IMMERSION DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+	INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.
+	IN NO EVENT SHALL IMMERSION BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+	CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+	LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+	NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+	CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+  FILE:		ImmEnclosure.h
+
+  PURPOSE:	Base Enclosure Class for Immersion Foundation Classes
+
+  STARTED:	10/29/97
+
+  NOTES/REVISIONS:
+     3/2/99 jrm (Jeff Mallett): Force-->Feel renaming
+	 3/2/99 jrm: Added GetIsCompatibleGUID
+	 3/15/99 jrm: __declspec(dllimport/dllexport) the whole class
+	 11/15/99 sdr (Steve Rank): Converted to IFC
+
+**********************************************************************/
+
+
+#if !defined(AFX_IMMENCLOSURE_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_)
+#define AFX_IMMENCLOSURE_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_
+
+#if _MSC_VER >= 1000
+#pragma once
+#endif // _MSC_VER >= 1000
+
+#ifndef _IFCDLL_
+#define DLLIFC __declspec(dllimport)
+#else
+#define DLLIFC __declspec(dllexport)
+#endif
+
+#include "ImmBaseTypes.h"
+#include "ImmEffect.h"
+
+
+//================================================================
+// Constants
+//================================================================
+
+
+#define     IMM_ENCLOSURE_DEFAULT_STIFFNESS      5000
+#define     IMM_ENCLOSURE_DEFAULT_SATURATION     10000
+#define     IMM_ENCLOSURE_DEFAULT_WIDTH          10
+#define     IMM_ENCLOSURE_HEIGHT_AUTO            MAXDWORD
+#define     IMM_ENCLOSURE_DEFAULT_HEIGHT         IMM_ENCLOSURE_HEIGHT_AUTO
+#define     IMM_ENCLOSURE_WALL_WIDTH_AUTO        MAXDWORD
+#define     IMM_ENCLOSURE_DEFAULT_WALL_WIDTH     IMM_ENCLOSURE_WALL_WIDTH_AUTO
+#define     IMM_ENCLOSURE_DEFAULT_STIFFNESS_MASK IMM_STIFF_ANYWALL
+#define     IMM_ENCLOSURE_DEFAULT_CLIPPING_MASK  IMM_CLIP_NONE
+
+#define     IMM_ENCLOSURE_DEFAULT_CENTER_POINT   IMM_EFFECT_MOUSE_POS_AT_START
+
+
+
+
+
+//================================================================
+// CImmEnclosure
+//================================================================
+
+//
+// ------ PUBLIC INTERFACE ------ 
+//
+
+class DLLIFC CImmEnclosure : public CImmEffect
+{
+    //
+    // CONSTRUCTOR/DESCTRUCTOR
+    //
+
+    public:
+    
+    // Constructor
+	CImmEnclosure();
+
+	// Destructor
+	virtual
+	~CImmEnclosure();
+
+
+    //
+    // ATTRIBUTES
+    //
+
+    public:
+
+	virtual BOOL
+	GetIsCompatibleGUID(
+		GUID &guid
+		);
+
+	virtual DWORD GetEffectType()
+		{ return IMM_EFFECTTYPE_ENCLOSURE; }
+
+    BOOL
+    ChangeParameters( 
+        POINT pntCenter,
+        DWORD dwWidth = IMM_EFFECT_DONT_CHANGE,
+        DWORD dwHeight = IMM_EFFECT_DONT_CHANGE,
+        LONG lTopAndBottomWallStiffness = IMM_EFFECT_DONT_CHANGE,
+        LONG lLeftAndRightWallStiffness = IMM_EFFECT_DONT_CHANGE,
+        DWORD dwTopAndBottomWallWallWidth = IMM_EFFECT_DONT_CHANGE,
+        DWORD dwLeftAndRightWallWallWidth = IMM_EFFECT_DONT_CHANGE,
+        DWORD dwTopAndBottomWallSaturation = IMM_EFFECT_DONT_CHANGE,
+        DWORD dwLeftAndRightWallSaturation = IMM_EFFECT_DONT_CHANGE,
+        DWORD dwStiffnessMask = IMM_EFFECT_DONT_CHANGE,
+        DWORD dwClippingMask = IMM_EFFECT_DONT_CHANGE,
+        CImmEffect* pInsideEffect = (CImmEffect*) IMM_EFFECT_DONT_CHANGE,  
+		LONG lAngle = IMM_EFFECT_DONT_CHANGE
+        );
+
+    BOOL
+    ChangeParameters( 
+        LPCRECT pRectOutside,
+        LONG lTopAndBottomWallStiffness = IMM_EFFECT_DONT_CHANGE,
+        LONG lLeftAndRightWallStiffness = IMM_EFFECT_DONT_CHANGE,
+        DWORD dwTopAndBottomWallWallThickness = IMM_EFFECT_DONT_CHANGE,
+        DWORD dwLeftAndRightWallWallThickness = IMM_EFFECT_DONT_CHANGE,
+        DWORD dwTopAndBottomWallSaturation = IMM_EFFECT_DONT_CHANGE,
+        DWORD dwLeftAndRightWallSaturation = IMM_EFFECT_DONT_CHANGE,
+        DWORD dwStiffnessMask = IMM_EFFECT_DONT_CHANGE,
+        DWORD dwClippingMask = IMM_EFFECT_DONT_CHANGE,
+        CImmEffect* pInsideEffect = (CImmEffect*) IMM_EFFECT_DONT_CHANGE,  
+		LONG lAngle = IMM_EFFECT_DONT_CHANGE
+        );
+
+	BOOL ChangeTopAndBottomWallStiffness ( LONG lTopAndBottomWallStiffness );
+	BOOL ChangeLeftAndRightWallStiffness ( LONG lLeftAndRightWallStiffness );
+	BOOL ChangeTopAndBottomWallThickness ( DWORD dwTopAndBottomWallThickness );
+	BOOL ChangeLeftAndRightWallThickness ( DWORD dwLeftAndRightWallThickness );
+	BOOL ChangeTopAndBottomWallSaturation( DWORD dwTopAndBottomWallSaturation );
+	BOOL ChangeLeftAndRightWallSaturation( DWORD dwLeftAndRightWallSaturation );
+	BOOL ChangeStiffnessMask			 ( DWORD dwStiffnessMask );
+	BOOL ChangeClippingMask				 ( DWORD dwClippingMask );
+	BOOL ChangeInsideEffect				 ( CImmEffect* pInsideEffect );
+
+    BOOL
+    ChangeRect( 
+        LPCRECT pRect 
+        );
+
+
+    BOOL
+    ChangeCenter( 
+        POINT pntCenter 
+        );
+
+
+    BOOL
+    ChangeCenter( 
+        LONG x, 
+        LONG y 
+        );
+
+	BOOL
+	ShowRect(
+		BOOL bRectOn
+		);
+
+	BOOL GetTopAndBottomWallStiffness ( LONG &lTopAndBottomWallStiffness );
+	BOOL GetLeftAndRightWallStiffness ( LONG &lLeftAndRightWallStiffness );
+	BOOL GetTopAndBottomWallThickness ( DWORD &dwTopAndBottomWallThickness );
+	BOOL GetLeftAndRightWallThickness ( DWORD &dwLeftAndRightWallThickness );
+	BOOL GetTopAndBottomWallSaturation ( DWORD &dwTopAndBottomWallSaturation );
+	BOOL GetLeftAndRightWallSaturation ( DWORD &dwLeftAndRightWallSaturation );
+	BOOL GetStiffnessMask ( DWORD &dwStiffnessMask );
+	BOOL GetClippingMask ( DWORD &dwClippingMask );
+	
+	BOOL GetRect( RECT* pRect );
+	BOOL GetCenter( POINT &pntCenter );
+	BOOL GetCenter( LONG &x, LONG &y);
+
+	CImmEffect* GetInsideEffect ();
+
+    //
+    // OPERATIONS
+    //
+
+    public:
+
+	virtual BOOL
+	Initialize( 
+		CImmDevice* pDevice, 
+		const IMM_EFFECT &effect,
+		DWORD dwNoDownload = 0
+    );
+
+    BOOL 
+    Initialize( 
+        CImmDevice* pDevice, 
+        DWORD dwWidth = IMM_ENCLOSURE_DEFAULT_WIDTH,
+        DWORD dwHeight = IMM_ENCLOSURE_DEFAULT_HEIGHT,
+        LONG lTopAndBottomWallStiffness = IMM_ENCLOSURE_DEFAULT_STIFFNESS,
+        LONG lLeftAndRightWallStiffness = IMM_ENCLOSURE_DEFAULT_STIFFNESS,
+        DWORD dwTopAndBottomWallWallWidth = IMM_ENCLOSURE_DEFAULT_WALL_WIDTH,
+        DWORD dwLeftAndRightWallWallWidth = IMM_ENCLOSURE_DEFAULT_WALL_WIDTH,
+        DWORD dwTopAndBottomWallSaturation = IMM_ENCLOSURE_DEFAULT_SATURATION,
+        DWORD dwLeftAndRightWallSaturation = IMM_ENCLOSURE_DEFAULT_SATURATION,
+        DWORD dwStiffnessMask = IMM_ENCLOSURE_DEFAULT_STIFFNESS_MASK,
+        DWORD dwClippingMask = IMM_ENCLOSURE_DEFAULT_CLIPPING_MASK,
+        POINT pntCenter = IMM_ENCLOSURE_DEFAULT_CENTER_POINT,
+        CImmEffect* pInsideEffect = NULL,  
+		LONG lAngle = IMM_EFFECT_DEFAULT_ANGLE,
+		DWORD dwNoDownload = 0
+        );
+
+
+    BOOL 
+    Initialize( 
+        CImmDevice* pDevice, 
+        LPCRECT pRectOutside,
+        LONG lTopAndBottomWallStiffness = IMM_ENCLOSURE_DEFAULT_STIFFNESS,
+        LONG lLeftAndRightWallStiffness = IMM_ENCLOSURE_DEFAULT_STIFFNESS,
+        DWORD dwTopAndBottomWallWallWidth = IMM_ENCLOSURE_DEFAULT_WALL_WIDTH,
+        DWORD dwLeftAndRightWallWallWidth = IMM_ENCLOSURE_DEFAULT_WALL_WIDTH,
+        DWORD dwTopAndBottomWallSaturation = IMM_ENCLOSURE_DEFAULT_SATURATION,
+        DWORD dwLeftAndRightWallSaturation = IMM_ENCLOSURE_DEFAULT_SATURATION,
+        DWORD dwStiffnessMask = IMM_ENCLOSURE_DEFAULT_STIFFNESS_MASK,
+        DWORD dwClippingMask = IMM_ENCLOSURE_DEFAULT_CLIPPING_MASK,
+        CImmEffect* pInsideEffect = NULL,  
+		LONG lAngle = IMM_EFFECT_DEFAULT_ANGLE,
+		DWORD dwNoDownload = 0
+        );
+
+
+    virtual BOOL 
+	Start(
+        DWORD dwIterations = 1,
+        DWORD dwFlags = 0, 
+		BOOL bAllowStartDelayEmulation = true
+		);
+
+	virtual BOOL
+	Stop();
+        
+	HRESULT Unload();
+	void Reload();
+
+//
+// ------ PRIVATE INTERFACE ------ 
+//
+
+    //
+    // HELPERS
+    //
+
+    protected:
+
+    BOOL
+    set_parameters( 
+        LPCRECT pRectOutside,
+        LONG lTopAndBottomWallStiffness,
+        LONG lLeftAndRightWallStiffness,
+        DWORD dwTopAndBottomWallWallWidth,
+        DWORD dwLeftAndRightWallWallWidth,
+        DWORD dwTopAndBottomWallSaturation,
+        DWORD dwLeftAndRightWallSaturation,
+        DWORD dwStiffnessMask,
+        DWORD dwClippingMask,
+        CImmEffect* pInsideEffect,  
+		LONG lAngle
+        );
+
+	DWORD
+	change_parameters( 
+		LPCRECT prectBoundary,
+		LONG lTopAndBottomWallStiffness,
+		LONG lLeftAndRightWallStiffness,
+		DWORD dwTopAndBottomWallThickness,
+		DWORD dwLeftAndRightWallThickness,
+		DWORD dwTopAndBottomWallSaturation,
+		DWORD dwLeftAndRightWallSaturation,
+		DWORD dwStiffnessMask,
+		DWORD dwClippingMask,
+		CImmEffect* pInsideEffect,
+		LONG lAngle
+		);	
+
+	int
+	buffer_ifr_data(
+		TCHAR* pData
+		);
+
+    //
+    // INTERNAL DATA
+    //
+    
+    protected:
+
+    IMM_ENCLOSURE m_enclosure;
+    BOOL m_bUseMousePosAtStart;
+
+	// Needed for co-ordinating events for Enclosures/Ellipes and the inside effects.
+	CImmEffect*	m_pInsideEffect;
+
+};
+
+
+//
+// INLINES
+//
+
+inline BOOL
+CImmEnclosure::GetIsCompatibleGUID(GUID &guid)
+{
+	return IsEqualGUID(guid, GUID_Imm_Enclosure);
+}
+
+#endif // !defined(AFX_IMMENCLOSURE_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_)
diff --git a/code/ff/IFC/ImmFriction.h b/code/ff/IFC/ImmFriction.h
new file mode 100644
index 0000000..fe97302
--- /dev/null
+++ b/code/ff/IFC/ImmFriction.h
@@ -0,0 +1,176 @@
+/**********************************************************************
+	Copyright (c) 1997 - 2000 Immersion Corporation
+
+	Permission to use, copy, modify, distribute, and sell this
+	software and its documentation may be granted without fee;
+	interested parties are encouraged to request permission from
+		Immersion Corporation
+		801 Fox Lane
+		San Jose, CA 95131
+		408-467-1900
+
+	IMMERSION DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+	INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.
+	IN NO EVENT SHALL IMMERSION BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+	CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+	LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+	NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+	CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+  FILE:		ImmFriction.h
+
+  PURPOSE:	Immersion Foundation Classes Friction Effect
+  
+  STARTED:	Dec.29.97
+
+  NOTES/REVISIONS:
+     Mar.02.99 jrm (Jeff Mallett): Force-->Feel renaming
+	 Mar.02.99 jrm: Added GetIsCompatibleGUID
+	 Mar.15.99 jrm: __declspec(dllimport/dllexport) the whole class
+	 Nov.15.99 efw (Evan Wies): Converted to IFC
+
+**********************************************************************/
+
+
+#if !defined(AFX_ImmFriction_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_)
+#define AFX_ImmFriction_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_
+
+#if _MSC_VER >= 1000
+#pragma once
+#endif // _MSC_VER >= 1000
+
+#ifndef _IFCDLL_
+#define DLLIFC __declspec(dllimport)
+#else
+#define DLLIFC __declspec(dllexport)
+#endif
+
+#include <windows.h>
+#include "ImmCondition.h"
+
+
+//================================================================
+// Constants
+//================================================================
+
+#define     IMM_FRICTION_DEFAULT_COEFFICIENT    2500
+#define     IMM_FRICTION_DEFAULT_MIN_VELOCITY   0
+
+
+//================================================================
+// CImmFriction
+//================================================================
+
+//
+// ------ PUBLIC INTERFACE ------ 
+//
+
+class DLLIFC CImmFriction : public CImmCondition
+{
+    //
+    // CONSTRUCTOR/DESTRUCTOR
+    //
+
+    public:
+    
+    // Constructor
+	CImmFriction();
+
+	// Destructor
+	virtual
+	~CImmFriction();
+
+
+    //
+    // ATTRIBUTES
+    //
+
+    public:
+
+	virtual BOOL
+	GetIsCompatibleGUID(
+		GUID &guid
+		);
+
+    BOOL
+    ChangeParameters( 
+        DWORD dwCoefficient,
+        DWORD dwMinVelocity = IMM_EFFECT_DONT_CHANGE,
+        LONG lDirectionX = IMM_EFFECT_DONT_CHANGE,
+        LONG lDirectionY = IMM_EFFECT_DONT_CHANGE
+        );
+
+    BOOL
+    ChangeParametersPolar( 
+        DWORD dwCoefficient,
+        DWORD dwMinVelocity,
+        LONG lAngle
+        );
+
+	BOOL ChangeMinVelocityX( DWORD dwMinVelocity );
+	BOOL ChangeMinVelocityY( DWORD dwMinVelocity );
+	//For setting both axes to the same value
+	BOOL ChangeMinVelocity( DWORD dwMinVelocity );
+
+	BOOL GetMinVelocityX( DWORD &dwMinVelocity );
+	BOOL GetMinVelocityY( DWORD &dwMinVelocity );
+
+    //
+    // OPERATIONS
+    //
+
+    public:
+
+    virtual BOOL 
+    Initialize( 
+        CImmDevice* pDevice, 
+        DWORD dwCoefficient = IMM_FRICTION_DEFAULT_COEFFICIENT,
+        DWORD dwMinVelocity = IMM_FRICTION_DEFAULT_MIN_VELOCITY,
+        DWORD dwfAxis = IMM_EFFECT_AXIS_BOTH,
+        LONG lDirectionX = IMM_EFFECT_DEFAULT_DIRECTION_X,
+        LONG lDirectionY = IMM_EFFECT_DEFAULT_DIRECTION_Y,
+		DWORD dwNoDownload = 0
+        );
+
+    virtual BOOL 
+    InitializePolar( 
+        CImmDevice* pDevice, 
+        DWORD dwCoefficient,
+        DWORD dwMinVelocity,
+        LONG lAngle,
+		DWORD dwNoDownload = 0
+        );
+
+        
+//
+// ------ PRIVATE INTERFACE ------ 
+//
+
+    //
+    // HELPERS
+    //
+
+    protected:
+
+    //
+    // INTERNAL DATA
+    //
+    
+    protected:
+
+};
+
+
+
+//
+// INLINES
+//
+
+inline BOOL
+CImmFriction::GetIsCompatibleGUID(GUID &guid)
+{
+	return IsEqualGUID(guid, GUID_Imm_Friction);
+}
+
+
+#endif // !defined(AFX_ImmFriction_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_)
diff --git a/code/ff/IFC/ImmGrid.h b/code/ff/IFC/ImmGrid.h
new file mode 100644
index 0000000..c91c152
--- /dev/null
+++ b/code/ff/IFC/ImmGrid.h
@@ -0,0 +1,179 @@
+/**********************************************************************
+	Copyright (c) 1997 - 2000 Immersion Corporation
+
+	Permission to use, copy, modify, distribute, and sell this
+	software and its documentation may be granted without fee;
+	interested parties are encouraged to request permission from
+		Immersion Corporation
+		801 Fox Lane
+		San Jose, CA 95131
+		408-467-1900
+
+	IMMERSION DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+	INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.
+	IN NO EVENT SHALL IMMERSION BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+	CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+	LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+	NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+	CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+  FILE:		ImmGrid.h
+
+  PURPOSE:	Immersion Foundation Classes Grid Effect
+
+  STARTED:	Dec.11.97
+
+  NOTES/REVISIONS:
+     Mar.02.99 jrm (Jeff Mallett): Force-->Feel renaming
+	 Mar.02.99 jrm: Added GetIsCompatibleGUID
+	 Mar.02.99 jrm: __declspec(dllimport/dllexport) the whole class
+	 Nov.15.99 efw (Evan Wies): Converted to IFC
+
+**********************************************************************/
+
+
+#if !defined(AFX_IMMGrid_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_)
+#define AFX_IMMGrid_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_
+
+#if _MSC_VER >= 1000
+#pragma once
+#endif // _MSC_VER >= 1000
+
+#ifndef _IFCDLL_
+#define DLLIFC __declspec(dllimport)
+#else
+#define DLLIFC __declspec(dllexport)
+#endif
+
+#include <windows.h>
+#include "ImmCondition.h"
+
+
+//================================================================
+// Constants
+//================================================================
+
+#define     IMM_GRID_DEFAULT_HORIZ_OFFSET     0  
+#define     IMM_GRID_DEFAULT_VERT_OFFSET      0
+#define     IMM_GRID_DEFAULT_HORIZ_SPACING    100
+#define     IMM_GRID_DEFAULT_VERT_SPACING     100
+#define     IMM_GRID_DEFAULT_NODE_STRENGTH    5000
+#define     IMM_GRID_DEFAULT_NODE_SATURATION  10000   
+
+
+
+//================================================================
+// CImmGrid
+//================================================================
+
+//
+// ------ PUBLIC INTERFACE ------ 
+//
+
+class DLLIFC CImmGrid : public CImmCondition
+{
+    //
+    // CONSTRUCTOR/DESTRUCTOR
+    //
+
+    public:
+    
+    // Constructor
+	CImmGrid();
+
+	// Destructor
+	virtual
+	~CImmGrid();
+
+
+    //
+    // ATTRIBUTES
+    //
+
+    public:
+
+	virtual BOOL
+	GetIsCompatibleGUID(
+		GUID &guid
+		);
+
+    BOOL
+    ChangeParameters( 
+        DWORD dwHorizSpacing,
+        DWORD dwVertSpacing = IMM_EFFECT_DONT_CHANGE,
+        LONG  lHorizNodeStrength = IMM_EFFECT_DONT_CHANGE,
+        LONG  lVertNodeStrength = IMM_EFFECT_DONT_CHANGE,
+        LONG  lHorizOffset = IMM_EFFECT_DONT_CHANGE,
+        LONG  lVertOffset = IMM_EFFECT_DONT_CHANGE,
+        DWORD dwHorizNodeSaturation = IMM_EFFECT_DONT_CHANGE,
+        DWORD dwVertNodeSaturation = IMM_EFFECT_DONT_CHANGE
+        );
+
+	BOOL ChangeHSpacing( DWORD dwHorizSpacing );
+	BOOL ChangeVSpacing( DWORD dwVertSpacing );
+	BOOL ChangeHNodeStrength( LONG lHorizNodeStrength );
+	BOOL ChangeVNodeStrength( LONG lVertNodeStrength );
+	BOOL ChangeOffset( POINT pntOffset );
+	BOOL ChangeHNodeSaturation( DWORD dwHorizNodeSaturation );
+	BOOL ChangeVNodeSaturation( DWORD dwVertNodeSaturation );
+	
+	BOOL GetHSpacing( DWORD &dwHorizSpacing );
+	BOOL GetVSpacing( DWORD &dwVertSpacing );
+	BOOL GetHNodeStrength( LONG &lHorizNodeStrength );
+	BOOL GetVNodeStrength( LONG &lVertNodeStrength );
+	BOOL GetOffset( POINT &pntOffset );
+	BOOL GetHNodeSaturation( DWORD &dwHorizNodeSaturation );
+	BOOL GetVNodeSaturation( DWORD &dwVertNodeSaturation );
+
+    //
+    // OPERATIONS
+    //
+
+    public:
+
+    virtual BOOL 
+    Initialize( 
+        CImmDevice* pDevice, 
+        DWORD dwHorizSpacing = IMM_GRID_DEFAULT_HORIZ_SPACING,
+        DWORD dwVertSpacing = IMM_GRID_DEFAULT_VERT_SPACING,
+        LONG  lHorizNodeStrength = IMM_GRID_DEFAULT_NODE_STRENGTH,
+        LONG  lVertNodeStrength = IMM_GRID_DEFAULT_NODE_STRENGTH,
+        DWORD dwHorizOffset = IMM_GRID_DEFAULT_HORIZ_OFFSET,
+        DWORD dwVertOffset = IMM_GRID_DEFAULT_VERT_OFFSET,
+        DWORD dwHorizNodeSaturation = IMM_GRID_DEFAULT_NODE_SATURATION,
+        DWORD dwVertNodeSaturation = IMM_GRID_DEFAULT_NODE_SATURATION,
+		DWORD dwNoDownload = 0
+        );
+
+
+//
+// ------ PRIVATE INTERFACE ------ 
+//
+
+    //
+    // HELPERS
+    //
+
+    protected:
+
+    //
+    // INTERNAL DATA
+    //
+    
+    protected:
+
+};
+
+
+
+//
+// INLINES
+//
+
+inline BOOL
+CImmGrid::GetIsCompatibleGUID(GUID &guid)
+{
+	return IsEqualGUID(guid, GUID_Imm_Grid);
+}
+		
+#endif // !defined(AFX_IMMGrid_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_)
diff --git a/code/ff/IFC/ImmIFR.h b/code/ff/IFC/ImmIFR.h
new file mode 100644
index 0000000..b24db3f
--- /dev/null
+++ b/code/ff/IFC/ImmIFR.h
@@ -0,0 +1,308 @@
+/**********************************************************************
+	Copyright (c) 1999 - 2000 Immersion Corporation
+
+	Permission to use, copy, modify, distribute, and sell this
+	software and its documentation may be granted without fee;
+	interested parties are encouraged to request permission from
+		Immersion Corporation
+		801 Fox Lane
+		San Jose, CA 95131
+		408-467-1900
+
+	IMMERSION DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+	INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.
+	IN NO EVENT SHALL IMMERSION BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+	CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+	LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+	NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+	CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+  FILE:		FEELitIFR.h
+
+  PURPOSE:	Input/Output for IFR Files, FEELit version
+
+  STARTED:	
+
+  NOTES/REVISIONS:
+
+**********************************************************************/
+
+#if !defined( _IMMIFR_H_)
+#define _IMMIFR_H_
+
+#ifndef __FEELITAPI_INCLUDED__
+	#error include 'dinput.h' before including this file for structures.
+#endif /* !__DINPUT_INCLUDED__ */
+
+#define IFRAPI __stdcall
+
+#if !defined(_IFCDLL_)
+#define DLLAPI __declspec(dllimport)
+#else
+#define DLLAPI __declspec(dllexport)
+#endif
+
+#if defined __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+/*
+**  CONSTANTS
+*/
+
+/*
+**  RT_IMMERSION - Resource type for IFR projects stored as resources.
+**   This is the resource type looked for by IFLoadProjectResource().
+*/
+#define	RT_IMMERSION	((LPCSTR)"IMMERSION")
+
+
+/*
+**  TYPES/STRUCTURES
+*/
+
+/*
+**  HIFRPROJECT - used to identify a loaded project as a whole.
+**   individual objects within a project are uniquely referenced by name.
+**   Created by the IFLoadProject*() functions and released by IFReleaseProject().
+*/
+typedef	LPVOID HIFRPROJECT;
+
+/*
+**  IFREffect - contains the information needed to create a DI effect
+**   using IDirectInputEffect::CreateEffect(). An array of pointers to these
+**	 structures is allocated and returned by IFCreateEffectStructs().
+*/
+typedef struct {
+	GUID		guid;
+	DWORD		dwIterations;
+	char		*effectName;
+	LPIMM_EFFECT	lpDIEffect;
+} IFREffect;
+
+
+/*
+**  FUNCTION DECLARATIONS
+*/
+
+/*
+**  IFLoadProjectResource() - Load a project from a resource.
+**   hRsrcModule - handle of the module containing the project definition resource.
+**   pRsrcName - name or MAKEINTRESOURCE(id) identifier of resource to load.
+**   pDevice - device for which the project is being loaded. If NULL,
+**     effects will be created generically, and IFCreateEffects() will fail.
+**   Returns an identifier for the loaded project, or NULL if unsuccessful.
+*/
+DLLAPI
+HIFRPROJECT
+IFRAPI
+IFRLoadProjectResource(
+	HMODULE hRsrcModule,
+	LPCSTR pRsrcName,
+	LPIIMM_DEVICE pDevice );
+
+/*
+**  IFLoadProjectPointer() - Load a project from a pointer.
+**   pProject - points to a project definition.
+**   pDevice - device for which the project is being loaded. If NULL,
+**     effects will be created generically, and IFCreateEffects() will fail.
+**   Returns an identifier for the loaded project, or NULL if unsuccessful.
+*/
+DLLAPI
+HIFRPROJECT
+IFRAPI
+IFRLoadProjectPointer(
+	LPVOID pProject,
+	LPIIMM_DEVICE pDevice );
+
+/*
+**  IFLoadProjectFile() - Load a project from a file.
+**    pProjectFileName - points to a project file name.
+**    pDevice - device for which the project is being loaded. If NULL,
+**       effects will be created generically, and IFCreateEffects() will fail.
+**    Returns an identifier for the loaded project, or NULL if unsuccessful.
+*/
+DLLAPI
+HIFRPROJECT
+IFRAPI
+IFRLoadProjectFile(
+	LPCSTR pProjectFileName,
+	LPIIMM_DEVICE pDevice );
+
+/*
+**  IFRLoadProjectFromMemory() - Load a project from memory.
+**
+**    In cases where a file or resource is readily accessible, it may 
+**	  be necessary to pass IFR formated information through memory. 
+**
+**    pProjectDef - memory addres that contains information from an IFR file.
+**    pDevice - device for which the project is being loaded. If NULL,
+**       effects will be created generically, and IFRCreateEffects() will fail.
+**    Returns an identifier for the loaded project, or NULL if unsuccessful.
+*/
+DLLAPI 
+HIFRPROJECT 
+IFRAPI
+IFRLoadProjectFromMemory( 
+	LPVOID pProjectDef, 
+	LPIIMM_DEVICE pDevice );
+
+/*
+**  IFLoadProjectObjectPointer() - Load a project from a pointer to a single
+**     object definition (usually used only by the editor).
+**   pObject - points to an object definition.
+**   pDevice - device for which the project is being loaded. If NULL,
+**     effects will be created generically, and IFCreateEffects() will fail.
+**   Returns an identifier for the loaded project, or NULL if unsuccessful.
+*/
+DLLAPI
+HIFRPROJECT
+IFRAPI
+IFRLoadProjectObjectPointer(
+	LPVOID pObject,
+	LPIIMM_DEVICE pDevice );
+
+/*
+**  IFReleaseProject() - Release a loaded project.
+**   hProject - identifies the project to be released.
+**   Returns TRUE if the project is released, FALSE if it is an invalid project.
+*/
+DLLAPI
+BOOL
+IFRAPI
+IFRReleaseProject(
+	HIFRPROJECT hProject );
+
+/*
+**  IFCreateEffectStructs() - Create IFREffects for a named effect.
+**   hProject - identifies the project containing the object.
+**   pObjectName - name of the object for which to create structures.
+**   pNumEffects - if not NULL will be set to a count of the IFREffect
+**     structures in the array (not including the terminating NULL pointer.)
+**   Returns a pointer to the allocated array of pointers to IFREffect
+**     structures. The array is terminated with a NULL pointer. If the
+**     function fails, a NULL pointer is returned.
+*/
+DLLAPI
+IFREffect **
+IFRAPI
+IFRCreateEffectStructs(
+	HIFRPROJECT hProject,
+	LPCSTR pObjectName,
+	int *pNumEffects );
+
+DLLAPI
+IFREffect **
+IFRAPI
+IFRCreateEffectStructsByIndex(
+	HIFRPROJECT hProject,
+	int nObjectIndex,
+	int *pNumEffects );
+
+DLLAPI 
+int 
+IFRAPI
+IFRGetNumEffects( 
+	HIFRPROJECT hProject 
+	);
+
+DLLAPI
+LPCSTR
+IFRAPI
+IFRGetObjectNameByIndex(
+	HIFRPROJECT hProject,
+	int nObjectIndex );
+
+DLLAPI
+LPCSTR
+IFRAPI
+IFRGetObjectSoundPath(
+	HIFRPROJECT hProject,
+	LPCSTR pObjectName );
+
+DLLAPI
+DWORD
+IFRAPI
+IFRGetObjectType(
+	HIFRPROJECT hProject,
+	LPCSTR pObjectName );
+
+DLLAPI
+DWORD
+IFRAPI
+IFRGetObjectTypeByIndex(
+	HIFRPROJECT hProject,
+	int nObjectIndex );
+
+DLLAPI 
+LPCSTR 
+IFRAPI
+IFRGetObjectNameByGUID(
+	HIFRPROJECT hProject, 
+	GUID *pGUID );
+
+DLLAPI 
+GUID 
+IFRAPI
+IFRGetObjectID( 
+	HIFRPROJECT hProject, 
+	LPCSTR pObjectName);
+
+DLLAPI 
+GUID* 
+IFRAPI
+IFRGetContainedObjIDs( 
+	HIFRPROJECT hProject, 
+	LPCSTR pCompoundObjName);
+
+
+/*
+**  IFReleaseEffectStructs() - Release an array of IFREffects.
+**   hProject - identifies the project for which the effects were created.
+**   pEffects - points to the array of IFREffect pointers to be released.
+**   Returns TRUE if the array is released, FALSE if it is an invalid array.
+*/
+DLLAPI
+BOOL
+IFRAPI
+IFRReleaseEffectStructs(
+	HIFRPROJECT hProject,
+	IFREffect **pEffects );
+
+/*
+**  IFCreateEffects() - Creates the DirectInput effects using
+**     IDirectInput::CreateEffect().
+**   hProject - identifies the project containing the object.
+**   pObjectName - name of the object for which to create effects.
+**   pNumEffects - if not NULL will be set to a count of the IDirectInputEffect
+**     pointers in the array (not including the terminating NULL pointer.)
+**   Returns a pointer to the allocated array of pointers to IDirectInputEffects.
+**     The array is terminated with a NULL pointer. If the function fails,
+**     a NULL pointer is returned.
+*/
+DLLAPI
+LPIIMM_EFFECT *
+IFRAPI
+IFRCreateEffects(
+	HIFRPROJECT hProject,
+	LPCSTR pObjectName,
+	int *pNumEffects );
+
+/*
+**  IFReleaseEffects() - Releases an array of IDirectInputEffect structures.
+**   hProject - identifies the project for which the effects were created.
+**   pEffects - points to the array if IDirectInputEffect pointers to be released.
+**   Returns TRUE if the array is released, FALSE if it is an invalid array.
+*/
+DLLAPI
+BOOL
+IFRAPI
+IFRReleaseEffects(
+	HIFRPROJECT hProject,
+	LPIIMM_EFFECT *pEffects );
+
+#if defined __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* !IMMIFR_h */
diff --git a/code/ff/IFC/ImmInertia.h b/code/ff/IFC/ImmInertia.h
new file mode 100644
index 0000000..9a27cb3
--- /dev/null
+++ b/code/ff/IFC/ImmInertia.h
@@ -0,0 +1,183 @@
+/**********************************************************************
+	Copyright (c) 1997 - 2000 Immersion Corporation
+
+	Permission to use, copy, modify, distribute, and sell this
+	software and its documentation may be granted without fee;
+	interested parties are encouraged to request permission from
+		Immersion Corporation
+		801 Fox Lane
+		San Jose, CA 95131
+		408-467-1900
+
+	IMMERSION DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+	INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.
+	IN NO EVENT SHALL IMMERSION BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+	CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+	LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+	NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+	CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+  FILE:		ImmInertia.h
+
+  PURPOSE:	Immersion Foundation Classes Inertia Effect
+  
+  STARTED:	Dec.29.97
+
+  NOTES/REVISIONS:
+     Mar.02.99 jrm (Jeff Mallett): Force-->Feel renaming
+	 Mar.02.99 jrm: Added GetIsCompatibleGUID
+	 Mar.15.99 jrm: __declspec(dllimport/dllexport) the whole class
+	 Nov.15.99 efw (Evan Wies): Converted to IFC
+
+**********************************************************************/
+
+
+#if !defined(AFX_IMMInertia_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_)
+#define AFX_IMMInertia_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_
+
+#if _MSC_VER >= 1000
+#pragma once
+#endif // _MSC_VER >= 1000
+
+#ifndef _IFCDLL_
+#define DLLIFC __declspec(dllimport)
+#else
+#define DLLIFC __declspec(dllexport)
+#endif
+
+#include <windows.h>
+#include "ImmCondition.h"
+
+
+//================================================================
+// Constants
+//================================================================
+
+#define     IMM_INERTIA_DEFAULT_COEFFICIENT			2500
+#define     IMM_INERTIA_DEFAULT_SATURATION			10000
+#define     IMM_INERTIA_DEFAULT_MIN_ACCELERATION	0
+
+
+
+//================================================================
+// CImmInertia
+//================================================================
+
+//
+// ------ PUBLIC INTERFACE ------ 
+//
+
+class DLLIFC CImmInertia : public CImmCondition
+{
+    //
+    // CONSTRUCTOR/DESTRUCTOR
+    //
+
+    public:
+    
+    // Constructor
+	CImmInertia();
+
+	// Destructor
+	virtual
+	~CImmInertia();
+
+
+    //
+    // ATTRIBUTES
+    //
+
+    public:
+
+	virtual BOOL
+	GetIsCompatibleGUID(
+		GUID &guid
+		);
+
+    BOOL
+    ChangeParameters( 
+        DWORD dwCoefficient,
+        DWORD dwSaturation = IMM_EFFECT_DONT_CHANGE,
+        DWORD dwMinAcceleration = IMM_EFFECT_DONT_CHANGE,
+        LONG lDirectionX = IMM_EFFECT_DONT_CHANGE,
+        LONG lDirectionY = IMM_EFFECT_DONT_CHANGE
+        );
+
+    BOOL
+    ChangeParametersPolar( 
+        DWORD dwCoefficient,
+        DWORD dwSaturation,
+        DWORD dwMinAcceleration,
+        LONG lAngle
+        );
+
+    
+    BOOL ChangeMinAccelerationX( DWORD dwMinAcceleration ); 
+    BOOL ChangeMinAccelerationY( DWORD dwMinAcceleration ); 
+    BOOL ChangeMinAcceleration( DWORD dwMinAcceleration ); 
+
+    BOOL GetMinAccelerationX( DWORD &dwMinAcceleration ); 
+    BOOL GetMinAccelerationY( DWORD &dwMinAcceleration ); 
+
+    //
+    // OPERATIONS
+    //
+
+    public:
+
+    virtual BOOL 
+    Initialize( 
+        CImmDevice* pDevice, 
+        DWORD dwCoefficient = IMM_INERTIA_DEFAULT_COEFFICIENT,
+        DWORD dwSaturation = IMM_INERTIA_DEFAULT_SATURATION,
+        DWORD dwMinAcceleration = IMM_INERTIA_DEFAULT_MIN_ACCELERATION,
+        DWORD dwfAxis = IMM_EFFECT_AXIS_BOTH,
+        LONG lDirectionX = IMM_EFFECT_DEFAULT_DIRECTION_X,
+        LONG lDirectionY = IMM_EFFECT_DEFAULT_DIRECTION_Y,
+		DWORD dwNoDownload = 0
+        );
+
+    virtual BOOL 
+    InitializePolar( 
+        CImmDevice* pDevice, 
+        DWORD dwCoefficient,
+        DWORD dwSaturation,
+        DWORD dwMinAcceleration,
+        LONG lAngle,
+		DWORD dwNoDownload = 0
+        );
+
+
+//
+// ------ PRIVATE INTERFACE ------ 
+//
+        
+    //
+    // HELPERS
+    //
+
+    protected:
+
+    //
+    // INTERNAL DATA
+    //
+    
+    protected:
+
+};
+
+
+
+//
+// INLINES
+//
+
+inline BOOL
+CImmInertia::GetIsCompatibleGUID(GUID &guid)
+{
+	return IsEqualGUID(guid, GUID_Imm_Inertia);
+}
+
+
+#endif // !defined(AFX_IMMInertia_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_)
+
diff --git a/code/ff/IFC/ImmMouse.h b/code/ff/IFC/ImmMouse.h
new file mode 100644
index 0000000..e639718
--- /dev/null
+++ b/code/ff/IFC/ImmMouse.h
@@ -0,0 +1,164 @@
+/**********************************************************************
+	Copyright (c) 1997 - 2000 Immersion Corporation
+
+	Permission to use, copy, modify, distribute, and sell this
+	software and its documentation may be granted without fee;
+	interested parties are encouraged to request permission from
+		Immersion Corporation
+		801 Fox Lane
+		San Jose, CA 95131
+		408-467-1900
+
+	IMMERSION DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+	INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.
+	IN NO EVENT SHALL IMMERSION BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+	CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+	LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+	NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+	CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+  FILE:		ImmMouse.h
+
+  PURPOSE:	Abstraction of Feelit mouse device
+
+  STARTED:	10/10/97
+
+  NOTES/REVISIONS:
+     3/2/99 jrm (Jeff Mallett): Force-->Feel renaming
+	 3/15/99 jrm: __declspec(dllimport/dllexport) the whole class
+
+**********************************************************************/
+
+#ifndef ImmMouse_h
+#define ImmMouse_h
+
+#ifndef _IFCDLL_
+#define DLLIFC __declspec(dllimport)
+#else
+#define DLLIFC __declspec(dllexport)
+#endif
+
+#include "ImmDevice.h"
+
+
+//================================================================
+// CImmMouse
+//================================================================
+
+//
+// ------ PUBLIC INTERFACE ------ 
+//
+
+class DLLIFC CImmMouse : public CImmDevice
+{
+
+    //
+    // CONSTRUCTOR/DESCTRUCTOR
+    //
+
+    public:
+    
+    // Constructor
+	CImmMouse();
+
+	// Destructor
+    virtual 
+	~CImmMouse();
+
+
+    //
+    // ATTRIBUTES
+    //
+
+    public:
+
+	virtual LPIIMM_API
+    GetAPI() 
+		{ return m_piApi; }
+
+	virtual LPIIMM_DEVICE
+    GetDevice() 
+		{ return m_piDevice; }
+
+	virtual DWORD GetProductType();
+
+	virtual BOOL GetDriverVersion(
+		DWORD &dwFFDriverVersion, 
+		DWORD &dwFirmwareRevision, 
+		DWORD &dwHardwareRevision);
+
+	virtual int GetProductName(LPTSTR lpszProductName, int nMaxCount);
+	virtual int GetProductGUIDString(LPTSTR lpszGUID, int nMaxCount);
+	virtual GUID GetProductGUID();
+
+	BOOL 
+    HaveImmMouse() 
+		{ return m_piDevice != NULL; }
+
+
+    //
+    // OPERATIONS
+    //
+
+	public:
+
+	BOOL
+	Initialize(
+		HANDLE hinstApp,
+		HANDLE hwndApp,
+		DWORD dwCooperativeFlag = IMM_COOPLEVEL_FOREGROUND,
+		BOOL bEnumerate = TRUE
+		);
+
+	virtual BOOL 
+	ChangeScreenResolution(
+		BOOL bAutoSet,
+		DWORD dwXScreenSize = 0,
+		DWORD dwYScreenSize = 0
+		);
+
+	// Another syntax for SwitchToAbsoluteMode.
+	// The default is Absolute mode.  Call only to switch to Relative mode or
+	// to switch back to Absolute mode.
+	virtual BOOL
+	SwitchToAbsoluteMode(
+		BOOL bAbsMode
+		);
+
+	virtual BOOL
+	GetCurrentPosition( long &lXPos, long &lYPos );
+
+//
+// ------ PRIVATE INTERFACE ------ 
+//
+
+	//
+	// HELPERS
+	//
+
+	protected:
+
+	virtual void
+	reset();
+
+	virtual BOOL 
+	prepare_device();
+
+	friend class CImmDevices;
+	static BOOL CALLBACK
+    devices_enum_proc(
+        LPIMM_DEVICEINSTANCE pImmDevInst, 
+        LPVOID pv
+        );
+
+    //
+    // INTERNAL DATA
+    //
+
+    protected:
+
+    LPIIMM_API m_piApi;
+    LPIIMM_DEVICE m_piDevice;
+};
+
+#endif // ImmMouse_h
\ No newline at end of file
diff --git a/code/ff/IFC/ImmPeriodic.h b/code/ff/IFC/ImmPeriodic.h
new file mode 100644
index 0000000..096ed01
--- /dev/null
+++ b/code/ff/IFC/ImmPeriodic.h
@@ -0,0 +1,259 @@
+/**********************************************************************
+	Copyright (c) 1997 - 2000 Immersion Corporation
+
+	Permission to use, copy, modify, distribute, and sell this
+	software and its documentation may be granted without fee;
+	interested parties are encouraged to request permission from
+		Immersion Corporation
+		801 Fox Lane
+		San Jose, CA 95131
+		408-467-1900
+
+	IMMERSION DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+	INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.
+	IN NO EVENT SHALL IMMERSION BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+	CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+	LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+	NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+	CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+  FILE:		ImmPeriodic.h
+
+  PURPOSE:	Base Periodic Class for Immersion Foundation Classes
+
+  STARTED:	11/03/97
+
+  NOTES/REVISIONS:
+     3/2/99 jrm (Jeff Mallett): Force-->Feel renaming
+	 3/2/99 jrm: Added GetIsCompatibleGUID
+	 3/15/99 jrm: __declspec(dllimport/dllexport) the whole class
+	 11/15/99 sdr (Steve Rank): Converted to IFC
+
+**********************************************************************/
+
+
+#if !defined(AFX_IMMPERIODIC_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_)
+#define AFX_IMMPERIODIC_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_
+
+#if _MSC_VER >= 1000
+#pragma once
+#endif // _MSC_VER >= 1000
+
+#ifndef _IFCDLL_
+#define DLLIFC __declspec(dllimport)
+#else
+#define DLLIFC __declspec(dllexport)
+#endif
+
+#include "ImmBaseTypes.h"
+#include "ImmEffect.h"
+
+
+
+//================================================================
+// Constants
+//================================================================
+
+#define     IMM_PERIODIC_DEFAULT_DURATION       1000 // Milliseconds
+#define     IMM_PERIODIC_DEFAULT_MAGNITUDE      5000
+#define     IMM_PERIODIC_DEFAULT_PERIOD         100  // Milliseconds
+#define     IMM_PERIODIC_DEFAULT_OFFSET         0
+#define     IMM_PERIODIC_DEFAULT_PHASE          0    // Degrees
+#define     IMM_PERIODIC_DEFAULT_DIRECTION_X    1    // Pixels
+#define     IMM_PERIODIC_DEFAULT_DIRECTION_Y    0    // Pixels
+#define     IMM_PERIODIC_DEFAULT_ANGLE          9000 // 100ths of degrees
+
+
+
+
+//================================================================
+// CImmPeriodic
+//================================================================
+
+//
+// ------ PUBLIC INTERFACE ------ 
+//
+
+class DLLIFC CImmPeriodic : public CImmEffect
+{
+    //
+    // CONSTRUCTOR/DESTRUCTOR
+    //
+
+    public:
+    
+    // Constructors
+
+	// You may use this form if you will immediately initialize it
+	//   from an IFR file...
+	CImmPeriodic();
+
+	// Otherwise use this form...
+	CImmPeriodic(
+		const GUID& rguidEffect
+		);
+
+	// Destructor
+	virtual
+	~CImmPeriodic();
+
+
+    //
+    // ATTRIBUTES
+    //
+
+    public:
+
+	virtual BOOL
+	GetIsCompatibleGUID(
+		GUID &guid
+		);
+
+	virtual DWORD GetEffectType()
+		{ return IMM_EFFECTTYPE_PERIODIC; }
+
+    BOOL
+    ChangeParameters( 
+        DWORD dwMagnitude,
+        DWORD dwPeriod = IMM_EFFECT_DONT_CHANGE,
+        DWORD dwDuration = IMM_EFFECT_DONT_CHANGE,
+        LONG lDirectionX = IMM_EFFECT_DONT_CHANGE,
+        LONG lDirectionY = IMM_EFFECT_DONT_CHANGE,
+        LONG  lOffset = IMM_EFFECT_DONT_CHANGE,
+        DWORD dwPhase = IMM_EFFECT_DONT_CHANGE,
+        LPIMM_ENVELOPE pEnvelope = (LPIMM_ENVELOPE) IMM_EFFECT_DONT_CHANGE_PTR
+        );
+
+    BOOL
+    ChangeParametersPolar( 
+        DWORD dwMagnitude,
+        DWORD dwPeriod = IMM_EFFECT_DONT_CHANGE,
+        DWORD dwDuration = IMM_EFFECT_DONT_CHANGE,
+        LONG lAngle = IMM_EFFECT_DONT_CHANGE,
+        LONG  lOffset = IMM_EFFECT_DONT_CHANGE,
+        DWORD dwPhase = IMM_EFFECT_DONT_CHANGE,
+        LPIMM_ENVELOPE pEnvelope = (LPIMM_ENVELOPE) IMM_EFFECT_DONT_CHANGE_PTR
+        );
+
+	BOOL ChangeMagnitude( DWORD dwMagnitude );
+	BOOL ChangePeriod( DWORD dwPeriod );
+	BOOL ChangeOffset( LONG lOffset );
+	BOOL ChangePhase( DWORD dwPhase );
+
+	BOOL GetMagnitude( DWORD &dwMagnitude );
+	BOOL GetPeriod( DWORD &dwPeriod );
+	BOOL GetOffset( LONG &lOffset );
+	BOOL GetPhase( DWORD &dwPhase );
+
+    //
+    // OPERATIONS
+    //
+
+    public:
+
+	virtual BOOL
+	Initialize( 
+		CImmDevice* pDevice, 
+		const IMM_EFFECT &effect,
+		DWORD dwNoDownload = 0
+    );
+
+    virtual BOOL
+    Initialize( 
+        CImmDevice* pDevice, 
+        DWORD dwMagnitude = IMM_PERIODIC_DEFAULT_MAGNITUDE,
+        DWORD dwPeriod = IMM_PERIODIC_DEFAULT_PERIOD,
+        DWORD dwDuration = IMM_PERIODIC_DEFAULT_DURATION,
+        LONG lDirectionX = IMM_PERIODIC_DEFAULT_DIRECTION_X,
+        LONG lDirectionY = IMM_PERIODIC_DEFAULT_DIRECTION_Y,
+        LONG  lOffset = IMM_PERIODIC_DEFAULT_OFFSET,
+        DWORD dwPhase = IMM_PERIODIC_DEFAULT_PHASE,
+        LPIMM_ENVELOPE pEnvelope = NULL,
+		DWORD dwNoDownload = 0
+        );
+
+    virtual BOOL
+    InitializePolar( 
+        CImmDevice* pDevice, 
+        DWORD dwMagnitude = IMM_PERIODIC_DEFAULT_MAGNITUDE,
+        DWORD dwPeriod = IMM_PERIODIC_DEFAULT_PERIOD,
+        DWORD dwDuration = IMM_PERIODIC_DEFAULT_DURATION,
+        LONG lAngle = IMM_PERIODIC_DEFAULT_ANGLE,
+        LONG  lOffset = IMM_PERIODIC_DEFAULT_OFFSET,
+        DWORD dwPhase = IMM_PERIODIC_DEFAULT_PHASE,
+        LPIMM_ENVELOPE pEnvelope = NULL,
+		DWORD dwNoDownload = 0
+        );
+
+
+//
+// ------ PRIVATE INTERFACE ------ 
+//
+        
+    //
+    // HELPERS
+    //
+
+    protected:
+
+    BOOL
+    set_parameters( 
+        DWORD dwfCoordinates,
+        LONG lDirection0,
+        LONG lDirection1,
+        DWORD dwDuration,
+        DWORD dwMagnitude,
+        DWORD dwPeriod,
+        LONG  lOffset,
+        DWORD dwPhase,
+        LPIMM_ENVELOPE pEnvelope
+        );
+
+	DWORD
+	change_parameters( 
+		LONG lDirection0,
+		LONG lDirection1,
+		DWORD dwDuration,
+		DWORD dwMagnitude,
+		DWORD dwPeriod,
+		LONG  lOffset,
+		DWORD dwPhase,
+		LPIMM_ENVELOPE pEnvelope
+		);
+	
+	int
+	buffer_ifr_data(
+		TCHAR* pData
+		);
+	
+	BOOL
+	get_ffe_data(
+		LPDIEFFECT pdiEffect
+		);
+
+    //
+    // INTERNAL DATA
+    //
+
+	protected:
+
+    IMM_PERIODIC m_Periodic;
+    
+};
+
+
+//
+// INLINES
+//
+
+inline BOOL
+CImmPeriodic::GetIsCompatibleGUID(GUID &guid)
+{
+	return	IsEqualGUID(guid, GUID_Imm_Sine) ||
+			IsEqualGUID(guid, GUID_Imm_Square) ||
+			IsEqualGUID(guid, GUID_Imm_Triangle) ||
+			IsEqualGUID(guid, GUID_Imm_SawtoothUp) ||
+			IsEqualGUID(guid, GUID_Imm_SawtoothDown);
+}
+
+#endif // !defined(AFX_IMMPERIODIC_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_)
diff --git a/code/ff/IFC/ImmProjects.h b/code/ff/IFC/ImmProjects.h
new file mode 100644
index 0000000..e121023
--- /dev/null
+++ b/code/ff/IFC/ImmProjects.h
@@ -0,0 +1,392 @@
+/**********************************************************************
+	Copyright (c) 1999 - 2000 Immersion Corporation
+
+	Permission to use, copy, modify, distribute, and sell this
+	software and its documentation may be granted without fee;
+	interested parties are encouraged to request permission from
+		Immersion Corporation
+		801 Fox Lane
+		San Jose, CA 95131
+		408-467-1900
+
+	IMMERSION DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+	INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.
+	IN NO EVENT SHALL IMMERSION BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+	CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+	LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+	NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+	CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+  FILE:		ImmProjects.h
+
+  PURPOSE:	CImmProject
+               Manages a set of forces in a project.
+               There will be a project for each opened IFR file.
+			CImmProjects
+			   Manages a set of projects
+
+  STARTED:	2/22/99 by Jeff Mallett
+
+
+  NOTES/REVISIONS:
+     3/2/99 jrm (Jeff Mallett): Force-->Feel renaming
+	 3/15/99 jrm: __declspec(dllimport/dllexport) the whole class
+
+**********************************************************************/
+
+#ifndef	__IMM_PROJECTS_H
+#define __IMM_PROJECTS_H
+
+#if _MSC_VER >= 1000
+#pragma once
+#endif // _MSC_VER >= 1000
+
+#ifndef _IFCDLL_
+#define DLLIFC __declspec(dllimport)
+#else
+#define DLLIFC __declspec(dllexport)
+#endif
+
+
+#include "IFCErrors.h"
+#include "ImmBaseTypes.h"
+#include "ImmDevice.h"
+#include "ImmCompoundEffect.h"
+
+class CImmProjects;
+
+
+//================================================================
+// CImmProject
+//================================================================
+
+//
+// ------ PUBLIC INTERFACE ------ 
+//
+
+class DLLIFC CImmProject
+{
+    //
+    // CONSTRUCTOR/DESTRUCTOR
+    //
+
+	public:
+
+	CImmProject();
+
+	~CImmProject();
+
+	void
+	Close();
+
+
+    //
+    // ATTRIBUTES
+    //
+
+	public:
+
+	CImmDevice*
+	GetDevice() const
+		{ return m_pDevice; }
+
+	BOOL
+	GetIsOpen() const
+		{ return m_hProj != NULL; }
+
+	CImmCompoundEffect *
+	GetCreatedEffect(
+		LPCSTR lpszEffectName
+		);
+
+	CImmCompoundEffect *
+	GetCreatedEffect(
+		int nIndex
+		);
+
+	int
+	GetNumEffectsFromIFR();
+	
+	LPCSTR
+	GetEffectNameFromIFRbyIndex(
+		int nEffectIndex
+		);
+
+	LPCSTR
+	GetEffectSoundPathFromIFR(
+		LPCSTR lpszEffectName
+		);
+
+	DWORD 
+	GetEffectType(
+		LPCSTR lpszEffectName
+		);
+
+	DWORD
+	GetEffectTypeFromIFR(
+		LPCSTR lpszEffectName
+		);
+
+	DWORD
+	GetEffectTypeFromIFR(
+		int nEffectIndex
+		);
+
+	int
+	GetNumCreatedEffects()
+	{ return m_nCreatedEffects;} 
+
+    //
+    // OPERATIONS
+    //
+
+	public:
+
+	BOOL
+	Start(
+		LPCSTR lpszEffectName = NULL, 
+		DWORD dwIterations = IMM_EFFECT_DONT_CHANGE,
+		DWORD dwFlags = 0,
+		CImmDevice* pDevice = NULL
+		);
+
+	BOOL
+	Stop(
+		LPCSTR lpszEffectName = NULL
+		);
+
+	BOOL
+	OpenFile(
+		LPCSTR lpszFilePath,
+		CImmDevice *pDevice
+		);
+
+	BOOL
+	LoadProjectFromResource(
+		HMODULE hRsrcModule,
+		LPCSTR pRsrcName,
+		CImmDevice *pDevice
+		);
+
+	BOOL
+	LoadProjectFromMemory(
+		LPVOID pProjectDef,
+		CImmDevice *pDevice
+		);
+
+	BOOL
+	LoadProjectObjectPointer(
+		BYTE *pMem,
+		CImmDevice *pDevice
+		);
+
+	BOOL
+	WriteToFile(
+		LPCSTR lpszFilename
+		);
+
+	CImmCompoundEffect *
+	CreateEffect(
+		LPCSTR lpszEffectName,
+		CImmDevice* pDevice = NULL,
+		DWORD dwNoDownload = 0
+		);
+
+	CImmCompoundEffect *
+	CreateEffectByIndex(
+		int nEffectIndex,
+		CImmDevice* pDevice = NULL,
+		DWORD dwNoDownload = 0
+		);
+
+	CImmCompoundEffect *
+	AddEffect(
+		LPCSTR lpszEffectName,
+		GENERIC_EFFECT_PTR pObject
+		);
+
+#if (IFC_VERSION >= 0x0101)
+	void
+	DestroyEffect(
+		CImmCompoundEffect *pCompoundEffect
+		);
+#endif
+
+//
+// ------ PRIVATE INTERFACE ------ 
+//
+
+    //
+    // HELPERS
+    //
+
+    protected:
+
+	void
+	set_next(
+		CImmProject *pNext
+		)
+		{ m_pNext = pNext; }
+
+	CImmProject *
+	get_next() const
+		{ return m_pNext; }
+
+	void
+	append_effect_to_list(
+		CImmCompoundEffect* pEffect
+		);
+#if (IFC_VERSION >= 0x0101)
+	BOOL
+	remove_effect_from_list(
+		CImmCompoundEffect* pEffect
+		);
+#endif
+
+	IFREffect **
+	create_effect_structs(
+		LPCSTR lpszEffectName,
+		int &nEff
+		);
+
+	IFREffect **
+	create_effect_structs_by_index(
+		int nEffectIndex,
+		int &nEff
+		);
+
+	BOOL
+	release_effect_structs(
+		IFREffect **hEffects
+		);
+
+    //
+    // FRIENDS
+    //
+
+	public:
+
+	friend BOOL 
+		CImmEffect::InitializeFromProject(
+			CImmProject &project,
+			LPCSTR lpszEffectName,
+			CImmDevice* pDevice, /* = NULL */
+			DWORD dwNoDownload // = 0
+		);
+
+#ifdef PROTECT_AGAINST_DELETION
+	friend CImmCompoundEffect::~CImmCompoundEffect();
+#endif
+
+	friend class CImmProjects;
+
+    //
+    // INTERNAL DATA
+    //
+
+	protected:
+
+	HIFRPROJECT m_hProj;
+	DWORD m_dwProjectFileType;
+	CImmCompoundEffect* m_pCreatedEffects;
+	CImmDevice* m_pDevice;
+	LPDIRECTINPUT m_piDI7;
+	LPDIRECTINPUTDEVICE2 m_piDIDevice7;
+	TCHAR m_szProjectFileName[MAX_PATH];
+
+	int m_nCreatedEffects;
+
+	private:
+
+	CImmProject* m_pNext;
+};
+
+
+
+//================================================================
+// CImmProjects
+//================================================================
+
+//
+// ------ PUBLIC INTERFACE ------ 
+//
+
+class DLLIFC CImmProjects
+{
+    //
+    // CONSTRUCTOR/DESTRUCTOR
+    //
+
+	public:
+
+	CImmProjects() : m_pProjects(NULL) { }
+
+	~CImmProjects();
+
+	void
+	Close();
+
+
+    //
+    // ATTRIBUTES
+    //
+
+	public:
+
+	CImmProject *
+	GetProject(
+		int index = 0
+		);
+
+
+    //
+    // OPERATIONS
+    //
+
+	public:
+
+	BOOL
+	Stop();
+
+	long
+	OpenFile(
+		LPCSTR lpszFilePath,
+		CImmDevice *pDevice
+		);
+
+	long
+	LoadProjectFromResource(
+		HMODULE hRsrcModule,
+		LPCSTR pRsrcName,
+		CImmDevice *pDevice
+		);
+
+	long
+	LoadProjectFromMemory(
+		LPVOID pProjectDef,
+		CImmDevice *pDevice
+		);
+
+
+//
+// ------ PRIVATE INTERFACE ------ 
+//
+
+    //
+    // HELPERS
+    //
+
+    protected:
+
+
+    //
+    // INTERNAL DATA
+    //
+	protected:
+
+	CImmProject *m_pProjects;
+};
+
+
+
+#endif // __IMM_PROJECTS_H
diff --git a/code/ff/IFC/ImmRamp.h b/code/ff/IFC/ImmRamp.h
new file mode 100644
index 0000000..3d854bf
--- /dev/null
+++ b/code/ff/IFC/ImmRamp.h
@@ -0,0 +1,225 @@
+/**********************************************************************
+	Copyright (c) 1997 - 2000 Immersion Corporation
+
+	Permission to use, copy, modify, distribute, and sell this
+	software and its documentation may be granted without fee;
+	interested parties are encouraged to request permission from
+		Immersion Corporation
+		801 Fox Lane
+		San Jose, CA 95131
+		408-467-1900
+
+	IMMERSION DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+	INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.
+	IN NO EVENT SHALL IMMERSION BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+	CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+	LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+	NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+	CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+  FILE:		ImmRamp.h
+
+  PURPOSE:	Base Ramp Force Class for Immersion Foundation Classes
+
+  STARTED:	12/11/97
+
+  NOTES/REVISIONS:
+     3/2/99 jrm (Jeff Mallett): Force-->Feel renaming
+	 3/2/99 jrm: Added GetIsCompatibleGUID
+	 3/15/99 jrm: __declspec(dllimport/dllexport) the whole class
+	 11/15/99 sdr (Steve Rank): Converted to IFC
+
+**********************************************************************/
+
+
+#if !defined(AFX_IMMRAMP_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_)
+#define AFX_IMMRAMP_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_
+
+#if _MSC_VER >= 1000
+#pragma once
+#endif // _MSC_VER >= 1000
+
+#ifndef _IFCDLL_
+#define DLLIFC __declspec(dllimport)
+#else
+#define DLLIFC __declspec(dllexport)
+#endif
+
+#include "ImmBaseTypes.h"
+#include "ImmEffect.h"
+
+
+
+//================================================================
+// Constants
+//================================================================
+
+#define     IMM_RAMP_DEFAULT_DURATION			1000 // Milliseconds
+#define     IMM_RAMP_DEFAULT_MAGNITUDE_START	0
+#define     IMM_RAMP_DEFAULT_MAGNITUDE_END		10000
+
+
+
+//================================================================
+// CImmRamp
+//================================================================
+
+//
+// ------ PUBLIC INTERFACE ------ 
+//
+        
+class DLLIFC CImmRamp : public CImmEffect
+{
+    //
+    // CONSTRUCTOR/DESTRUCTOR
+    //
+
+    public:
+    
+    // Constructor
+	CImmRamp();
+
+	// Destructor
+	virtual
+	~CImmRamp();
+
+
+    //
+    // ATTRIBUTES
+    //
+
+    public:
+
+	virtual BOOL
+	GetIsCompatibleGUID(
+		GUID &guid
+		);
+
+	virtual DWORD GetEffectType()
+		{ return IMM_EFFECTTYPE_RAMPFORCE; }
+
+    BOOL
+    ChangeParameters( 
+        LONG lDirectionX,
+        LONG lDirectionY,
+        DWORD dwDuration = IMM_EFFECT_DONT_CHANGE,
+        LONG lMagStart = IMM_EFFECT_DONT_CHANGE,
+        LONG lMagEnd = IMM_EFFECT_DONT_CHANGE,
+        LPIMM_ENVELOPE pEnvelope = (LPIMM_ENVELOPE) IMM_EFFECT_DONT_CHANGE_PTR
+        );
+
+    BOOL
+    ChangeParametersPolar( 
+        LONG lAngle,
+        DWORD dwDuration = IMM_EFFECT_DONT_CHANGE,
+        LONG lMagStart = IMM_EFFECT_DONT_CHANGE,
+        LONG lMagEnd = IMM_EFFECT_DONT_CHANGE,
+        LPIMM_ENVELOPE pEnvelope = (LPIMM_ENVELOPE) IMM_EFFECT_DONT_CHANGE_PTR
+        );
+
+	BOOL ChangeStartMagnitude( LONG lMagStart );
+	BOOL ChangeEndMagnitude( LONG lMagEnd );
+
+	BOOL GetStartMagnitude( LONG &lMagStart );
+	BOOL GetEndMagnitude( LONG &lMagEnd );
+
+    //
+    // OPERATIONS
+    //
+
+    public:
+
+	virtual BOOL
+	Initialize( 
+		CImmDevice* pDevice, 
+		const IMM_EFFECT &effect,
+		DWORD dwFlags = 0
+    );
+
+    virtual BOOL
+    Initialize( 
+        CImmDevice* pDevice, 
+        LONG lDirectionX = IMM_EFFECT_DEFAULT_DIRECTION_X,
+        LONG lDirectionY = IMM_EFFECT_DEFAULT_DIRECTION_Y,
+        DWORD dwDuration = IMM_RAMP_DEFAULT_DURATION,
+        LONG lMagStart = IMM_RAMP_DEFAULT_MAGNITUDE_START,
+        LONG lMagEnd = IMM_RAMP_DEFAULT_MAGNITUDE_END,
+        LPIMM_ENVELOPE pEnvelope = NULL,
+		DWORD dwFlags = 0
+        );
+
+    virtual BOOL
+    InitializePolar( 
+        CImmDevice* pDevice, 
+        LONG lAngle = IMM_EFFECT_DEFAULT_ANGLE,
+        DWORD dwDuration = IMM_RAMP_DEFAULT_DURATION,
+        LONG lMagStart = IMM_RAMP_DEFAULT_MAGNITUDE_START,
+        LONG lMagEnd = IMM_RAMP_DEFAULT_MAGNITUDE_END,
+        LPIMM_ENVELOPE pEnvelope = NULL,
+		DWORD dwFlags = 0
+        );
+
+
+//
+// ------ PRIVATE INTERFACE ------ 
+//
+        
+    //
+    // HELPERS
+    //
+
+    protected:
+
+    BOOL
+    set_parameters( 
+        DWORD dwfCoordinates,
+        LONG lDirection0,
+        LONG lDirection1,
+        DWORD dwDuration,
+        LONG lMagStart,
+        LONG lMagEnd,
+        LPIMM_ENVELOPE pEnvelope
+        );
+
+	DWORD
+	change_parameters( 
+		LONG lDirection0,
+		LONG lDirection1,
+		DWORD dwDuration,
+		LONG lMagStart,
+		LONG lMagEnd,
+		LPIMM_ENVELOPE pEnvelope
+		);
+	
+	int
+	buffer_ifr_data(
+		TCHAR* pData
+		);
+	
+	BOOL
+	get_ffe_data(
+		LPDIEFFECT pdiEffect
+		);
+
+    //
+    // INTERNAL DATA
+    //
+
+    protected:
+
+    IMM_RAMPFORCE m_RampForce;
+    
+};
+
+
+//
+// INLINES
+//
+
+inline BOOL
+CImmRamp::GetIsCompatibleGUID(GUID &guid)
+{
+	return IsEqualGUID(guid, GUID_Imm_RampForce);
+}
+
+#endif // !defined(AFX_IMMRAMP_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_)
diff --git a/code/ff/IFC/ImmSpring.h b/code/ff/IFC/ImmSpring.h
new file mode 100644
index 0000000..1d48317
--- /dev/null
+++ b/code/ff/IFC/ImmSpring.h
@@ -0,0 +1,183 @@
+/**********************************************************************
+	Copyright (c) 1997 - 2000 Immersion Corporation
+
+	Permission to use, copy, modify, distribute, and sell this
+	software and its documentation may be granted without fee;
+	interested parties are encouraged to request permission from
+		Immersion Corporation
+		801 Fox Lane
+		San Jose, CA 95131
+		408-467-1900
+
+	IMMERSION DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+	INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.
+	IN NO EVENT SHALL IMMERSION BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+	CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+	LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+	NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+	CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+  FILE:		ImmSpring.h
+
+  PURPOSE:	Immersion Foundation Classes Spring Effect
+  
+  STARTED:	Oct.10.97
+
+  NOTES/REVISIONS:
+     Mar.02.99 jrm (Jeff Mallett): Force-->Feel renaming
+	 Mar.02.99 jrm: Added GetIsCompatibleGUID
+	 Mar.15.99 jrm: __declspec(dllimport/dllexport) the whole class
+	 Nov.15.99 efw (Evan Wies): Converted to IFC
+
+**********************************************************************/
+
+
+#if !defined(AFX_IMMSpring_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_)
+#define AFX_IMMSpring_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_
+
+#if _MSC_VER >= 1000
+#pragma once
+#endif // _MSC_VER >= 1000
+
+#ifndef _IFCDLL_
+#define DLLIFC __declspec(dllimport)
+#else
+#define DLLIFC __declspec(dllexport)
+#endif
+
+#include <windows.h>
+#include "ImmCondition.h"
+
+
+//================================================================
+// Constants
+//================================================================
+
+#define     IMM_SPRING_DEFAULT_STIFFNESS      2500
+#define     IMM_SPRING_DEFAULT_SATURATION     10000
+#define     IMM_SPRING_DEFAULT_DEADBAND       100
+#define     IMM_SPRING_DEFAULT_CENTER_POINT   IMM_EFFECT_MOUSE_POS_AT_START
+#define     IMM_SPRING_DEFAULT_DIRECTION_X    1
+#define     IMM_SPRING_DEFAULT_DIRECTION_Y    0
+#define     IMM_SPRING_DEFAULT_ANGLE          0
+
+
+//================================================================
+// CImmSpring
+//================================================================
+
+//
+// ------ PUBLIC INTERFACE ------ 
+//
+        
+class DLLIFC CImmSpring : public CImmCondition
+{
+    //
+    // CONSTRUCTOR/DESTRUCTOR
+    //
+
+    public:
+    
+    // Constructor
+	CImmSpring();
+
+	// Destructor
+	virtual
+	~CImmSpring();
+
+
+    //
+    // ATTRIBUTES
+    //
+
+    public:
+
+	virtual BOOL
+	GetIsCompatibleGUID(
+		GUID &guid
+		);
+
+    BOOL
+    ChangeParameters( 
+        POINT pntCenter,
+        LONG lStiffness = IMM_EFFECT_DONT_CHANGE,
+        DWORD dwSaturation = IMM_EFFECT_DONT_CHANGE,
+        DWORD dwDeadband = IMM_EFFECT_DONT_CHANGE,
+        LONG lDirectionX = IMM_EFFECT_DONT_CHANGE,
+        LONG lDirectionY = IMM_EFFECT_DONT_CHANGE
+        );
+
+    BOOL
+    ChangeParametersPolar( 
+        POINT pntCenter,
+        LONG lStiffness,
+        DWORD dwSaturation,
+        DWORD dwDeadband,
+        LONG lAngle
+        );
+
+    //
+    // OPERATIONS
+    //
+
+    public:
+
+    virtual BOOL 
+    Initialize( 
+        CImmDevice* pDevice, 
+        LONG lStiffness = IMM_SPRING_DEFAULT_STIFFNESS,
+        DWORD dwSaturation = IMM_SPRING_DEFAULT_SATURATION,
+        DWORD dwDeadband = IMM_SPRING_DEFAULT_DEADBAND,
+        DWORD dwfAxis = IMM_EFFECT_AXIS_BOTH, 
+        POINT pntCenter = IMM_SPRING_DEFAULT_CENTER_POINT,
+        LONG lDirectionX = IMM_SPRING_DEFAULT_DIRECTION_X,
+        LONG lDirectionY = IMM_SPRING_DEFAULT_DIRECTION_Y,
+		BOOL bUseDeviceCoordinates = FALSE,
+		DWORD dwNoDownload = 0
+		);
+
+    virtual BOOL 
+    InitializePolar( 
+        CImmDevice* pDevice, 
+        LONG lStiffness,
+        DWORD dwSaturation,
+        DWORD dwDeadband,
+        POINT pntCenter,
+        LONG lAngle,
+        BOOL bUseDeviceCoordinates = FALSE,
+		DWORD dwNoDownload = 0
+		);
+
+
+//
+// ------ PRIVATE INTERFACE ------ 
+//
+            
+    //
+    // HELPERS
+    //
+
+    protected:
+
+    //
+    // INTERNAL DATA
+    //
+    
+    protected:
+
+};
+
+
+
+//
+// INLINES
+//
+
+inline BOOL
+CImmSpring::GetIsCompatibleGUID(GUID &guid)
+{
+	return IsEqualGUID(guid, GUID_Imm_Spring);
+}
+
+#endif // !defined(AFX_IMMSpring_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_)
+
diff --git a/code/ff/IFC/ImmTexture.h b/code/ff/IFC/ImmTexture.h
new file mode 100644
index 0000000..df8bc38
--- /dev/null
+++ b/code/ff/IFC/ImmTexture.h
@@ -0,0 +1,407 @@
+/**********************************************************************
+	Copyright (c) 1997 - 2000 Immersion Corporation
+
+	Permission to use, copy, modify, distribute, and sell this
+	software and its documentation may be granted without fee;
+	interested parties are encouraged to request permission from
+		Immersion Corporation
+		801 Fox Lane
+		San Jose, CA 95131
+		408-467-1900
+
+	IMMERSION DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+	INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.
+	IN NO EVENT SHALL IMMERSION BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+	CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+	LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+	NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+	CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+  FILE:		ImmTexture.h
+
+  PURPOSE:	Texture Class for Feelit API Foundation Classes
+
+  STARTED:	2/27/98
+
+  NOTES/REVISIONS:
+     3/2/99 jrm (Jeff Mallett): Force-->Feel renaming
+	 3/2/99 jrm: Added GetIsCompatibleGUID
+	 3/15/99 jrm: __declspec(dllimport/dllexport) the whole class
+
+**********************************************************************/
+
+
+#if !defined(AFX_ImmTexture_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_)
+#define AFX_ImmTexture_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_
+
+#if _MSC_VER >= 1000
+#pragma once
+#endif // _MSC_VER >= 1000
+
+#ifndef _IFCDLL_
+#define DLLIFC __declspec(dllimport)
+#else
+#define DLLIFC __declspec(dllexport)
+#endif
+
+#include <windows.h>
+#include "ImmBaseTypes.h"
+#include "ImmEffect.h"
+
+
+
+//================================================================
+// Constants
+//================================================================
+
+const POINT IMM_TEXTURE_PT_NULL = { 0, 0 };
+const POINT IMM_TEXTURE_DEFAULT_OFFSET_POINT = { 0, 0};
+
+#define     IMM_TEXTURE_DEFAULT_MAGNITUDE        5000
+#define     IMM_TEXTURE_DEFAULT_WIDTH		       10
+#define     IMM_TEXTURE_DEFAULT_SPACING		   20
+
+
+//================================================================
+// CImmTexture
+//================================================================
+
+//
+// ------ PUBLIC INTERFACE ------ 
+//
+        
+class DLLIFC CImmTexture : public CImmEffect
+{
+    //
+    // CONSTRUCTOR/DESTRUCTOR
+    //
+
+    public:
+    
+    // Constructor
+	CImmTexture();
+
+	// Destructor
+	virtual
+	~CImmTexture();
+
+
+    //
+    // ATTRIBUTES
+    //
+
+    public:
+
+	virtual BOOL
+	GetIsCompatibleGUID(
+		GUID &guid
+		);
+
+	virtual DWORD GetEffectType()
+		{ return IMM_EFFECTTYPE_TEXTURE; }
+
+    // Use this form for single-axis and dual-axis effects
+    BOOL
+    ChangeTextureParams( 
+        LPCIMM_TEXTURE pTextureX,
+        LPCIMM_TEXTURE pTextureY
+        );
+
+    // Use this form for directional effects
+    BOOL
+    ChangeTextureParams( 
+        LPCIMM_TEXTURE pTexture,
+        LONG lDirectionX,
+        LONG lDirectionY
+        );
+
+    // Use this form for directional effects
+	BOOL
+    ChangeTextureParamsPolar( 
+        LPCIMM_TEXTURE pTexture,
+        LONG lAngle
+        );
+
+    // Use this form for single-axis, dual-axis symetrical, or directional effects
+    BOOL
+    ChangeTextureParams( 
+        LONG lPosBumpMag = IMM_EFFECT_DONT_CHANGE,
+        DWORD dwPosBumpWidth = IMM_EFFECT_DONT_CHANGE,
+        DWORD dwPosBumpSpacing = IMM_EFFECT_DONT_CHANGE,
+        LONG lNegBumpMag = IMM_EFFECT_DONT_CHANGE,
+        DWORD dwNegBumpWidth = IMM_EFFECT_DONT_CHANGE,
+        DWORD dwNegBumpSpacing = IMM_EFFECT_DONT_CHANGE,
+        POINT pntOffset = IMM_EFFECT_DONT_CHANGE_POINT,
+        LONG lDirectionX = IMM_EFFECT_DONT_CHANGE,
+        LONG lDirectionY = IMM_EFFECT_DONT_CHANGE
+        );
+
+    // Use this form for single-axis, dual-axis, or directional effects
+    BOOL
+    ChangeTextureParamsX( 
+        LONG lPosBumpMag = IMM_EFFECT_DONT_CHANGE,
+        DWORD dwPosBumpWidth = IMM_EFFECT_DONT_CHANGE,
+        DWORD dwPosBumpSpacing = IMM_EFFECT_DONT_CHANGE,
+        LONG lNegBumpMag = IMM_EFFECT_DONT_CHANGE,
+        DWORD dwNegBumpWidth = IMM_EFFECT_DONT_CHANGE,
+        DWORD dwNegBumpSpacing = IMM_EFFECT_DONT_CHANGE,
+        POINT pntOffset = IMM_EFFECT_DONT_CHANGE_POINT,
+        LONG lDirectionX = IMM_EFFECT_DONT_CHANGE,
+        LONG lDirectionY = IMM_EFFECT_DONT_CHANGE
+        );
+
+    BOOL
+    ChangeTextureParamsY( 
+        LONG lPosBumpMag = IMM_EFFECT_DONT_CHANGE,
+        DWORD dwPosBumpWidth = IMM_EFFECT_DONT_CHANGE,
+        DWORD dwPosBumpSpacing = IMM_EFFECT_DONT_CHANGE,
+        LONG lNegBumpMag = IMM_EFFECT_DONT_CHANGE,
+        DWORD dwNegBumpWidth = IMM_EFFECT_DONT_CHANGE,
+        DWORD dwNegBumpSpacing = IMM_EFFECT_DONT_CHANGE,
+        POINT pntOffset = IMM_EFFECT_DONT_CHANGE_POINT,
+        LONG lDirectionX = IMM_EFFECT_DONT_CHANGE,
+        LONG lDirectionY = IMM_EFFECT_DONT_CHANGE
+        );
+
+    // Use this form for single-axis, dual-axis symetrical, or directional effects
+    BOOL
+    ChangeTextureParamsPolar( 
+        LONG lPosBumpMag = IMM_EFFECT_DONT_CHANGE,
+        DWORD dwPosBumpWidth = IMM_EFFECT_DONT_CHANGE,
+        DWORD dwPosBumpSpacing = IMM_EFFECT_DONT_CHANGE,
+        LONG lNegBumpMag = IMM_EFFECT_DONT_CHANGE,
+        DWORD dwNegBumpWidth = IMM_EFFECT_DONT_CHANGE,
+        DWORD dwNegBumpSpacing = IMM_EFFECT_DONT_CHANGE,
+        POINT pntOffset = IMM_EFFECT_DONT_CHANGE_POINT,
+        LONG lAngle = IMM_EFFECT_DONT_CHANGE
+        );
+
+    // Use this form for single-axis, dual-axis, or directional effects
+    BOOL
+    ChangeTextureParamsPolarX( 
+        LONG lPosBumpMag = IMM_EFFECT_DONT_CHANGE,
+        DWORD dwPosBumpWidth = IMM_EFFECT_DONT_CHANGE,
+        DWORD dwPosBumpSpacing = IMM_EFFECT_DONT_CHANGE,
+        LONG lNegBumpMag = IMM_EFFECT_DONT_CHANGE,
+        DWORD dwNegBumpWidth = IMM_EFFECT_DONT_CHANGE,
+        DWORD dwNegBumpSpacing = IMM_EFFECT_DONT_CHANGE,
+        POINT pntOffset = IMM_EFFECT_DONT_CHANGE_POINT,
+        LONG lAngle = IMM_EFFECT_DONT_CHANGE
+        );
+
+    BOOL
+    ChangeTextureParamsPolarY( 
+        LONG lPosBumpMag = IMM_EFFECT_DONT_CHANGE,
+        DWORD dwPosBumpWidth = IMM_EFFECT_DONT_CHANGE,
+        DWORD dwPosBumpSpacing = IMM_EFFECT_DONT_CHANGE,
+        LONG lNegBumpMag = IMM_EFFECT_DONT_CHANGE,
+        DWORD dwNegBumpWidth = IMM_EFFECT_DONT_CHANGE,
+        DWORD dwNegBumpSpacing = IMM_EFFECT_DONT_CHANGE,
+        POINT pntOffset = IMM_EFFECT_DONT_CHANGE_POINT,
+        LONG lAngle = IMM_EFFECT_DONT_CHANGE
+        );
+
+    // Use these to change the the X Axis parameters for a dual-axis effect 
+	BOOL ChangePositiveBumpMagX( LONG lPosBumpMag );
+	BOOL ChangeNegativeBumpMagX( LONG lNegBumpMag );
+	BOOL ChangePositiveBumpSpacingX( DWORD dwPosBumpSpacing );
+	BOOL ChangeNegativeBumpSpacingX( DWORD dwNegBumpSpacing );
+	BOOL ChangePositiveBumpWidthX( DWORD dwPosBumpWidth );
+	BOOL ChangeNegativeBumpWidthX( DWORD dwNegBumpWidth );
+
+    // Use these to change the the Y Axis parameters for a dual-axis effect 
+	BOOL ChangePositiveBumpMagY( LONG lPosBumpMag );
+	BOOL ChangeNegativeBumpMagY( LONG lNegBumpMag );
+	BOOL ChangePositiveBumpSpacingY( DWORD dwPosBumpSpacing );
+	BOOL ChangeNegativeBumpSpacingY( DWORD dwNegBumpSpacing );
+	BOOL ChangePositiveBumpWidthY( DWORD dwPosBumpWidth );
+	BOOL ChangeNegativeBumpWidthY( DWORD dwNegBumpWidth );
+
+    // Use these to change the the parameters for a single-axis or 
+	// dual-axis symetrical effect 
+	BOOL ChangePositiveBumpMag( LONG lPosBumpMag );
+	BOOL ChangeNegativeBumpMag( LONG lNegBumpMag );
+	BOOL ChangePositiveBumpSpacing( DWORD dwPosBumpSpacing );
+	BOOL ChangeNegativeBumpSpacing( DWORD dwNegBumpSpacing );
+	BOOL ChangePositiveBumpWidth( DWORD dwPosBumpWidth );
+	BOOL ChangeNegativeBumpWidth( DWORD dwNegBumpWidth );
+
+	BOOL ChangeOffset( POINT pntOffset );
+
+	BOOL GetPositiveBumpMagX( LONG &lPosBumpMag );
+	BOOL GetNegativeBumpMagX( LONG &lNegBumpMag );
+	BOOL GetPositiveBumpSpacingX( DWORD &dwPosBumpSpacing );
+	BOOL GetNegativeBumpSpacingX( DWORD &dwNegBumpSpacing );
+	BOOL GetPositiveBumpWidthX( DWORD &dwPosBumpWidth );
+	BOOL GetNegativeBumpWidthX( DWORD &dwNegBumpWidth );
+	BOOL GetPositiveBumpMagY( LONG &lPosBumpMag );
+	BOOL GetNegativeBumpMagY( LONG &lNegBumpMag );
+	BOOL GetPositiveBumpSpacingY( DWORD &dwPosBumpSpacing );
+	BOOL GetNegativeBumpSpacingY( DWORD &dwNegBumpSpacing );
+	BOOL GetPositiveBumpWidthY( DWORD &dwPosBumpWidth );
+	BOOL GetNegativeBumpWidthY( DWORD &dwNegBumpWidth );
+	BOOL GetOffset( POINT &pntOffset );
+
+    //
+    // OPERATIONS
+    //
+
+    public:
+
+	virtual BOOL
+	Initialize( 
+		CImmDevice* pDevice, 
+		const IMM_EFFECT &effect,
+		DWORD dwNoDownload = 0
+    );
+
+    // Use this form for single-axis and dual-axis effects
+    BOOL 
+    InitTexture( 
+        CImmDevice* pDevice, 
+        LPCIMM_TEXTURE pTextureX,
+        LPCIMM_TEXTURE pTextureY,
+		DWORD dwNoDownload = 0
+        );
+
+
+    // Use this form for directional effects
+    BOOL 
+    InitTexture( 
+        CImmDevice* pDevice, 
+        LPCIMM_TEXTURE pTexture,
+        LONG lDirectionX,
+        LONG lDirectionY,
+		DWORD dwNoDownload = 0
+        );
+
+
+    // Use this form for directional effects
+    BOOL 
+    InitTexturePolar( 
+        CImmDevice* pDevice, 
+        LPCIMM_TEXTURE pTexture,
+        LONG lAngle,
+		DWORD dwNoDownload = 0
+        );
+
+
+    // Use this form for single-axis, dual-axis symetrical, or directional effects
+    BOOL 
+    InitTexture( 
+        CImmDevice* pDevice, 
+        LONG lPosBumpMag = IMM_TEXTURE_DEFAULT_MAGNITUDE,
+        DWORD dwPosBumpWidth = IMM_TEXTURE_DEFAULT_WIDTH,
+        DWORD dwPosBumpSpacing = IMM_TEXTURE_DEFAULT_SPACING,
+        LONG lNegBumpMag = IMM_TEXTURE_DEFAULT_MAGNITUDE,
+        DWORD dwNegBumpWidth = IMM_TEXTURE_DEFAULT_WIDTH,
+        DWORD dwNegBumpSpacing = IMM_TEXTURE_DEFAULT_SPACING,
+        DWORD dwfAxis = IMM_EFFECT_AXIS_BOTH,
+        POINT pntOffset = IMM_TEXTURE_DEFAULT_OFFSET_POINT,
+        LONG lDirectionX = IMM_EFFECT_DEFAULT_DIRECTION_X,
+        LONG lDirectionY = IMM_EFFECT_DEFAULT_DIRECTION_Y,
+		DWORD dwNoDownload = 0
+        );
+
+    // Use this form for directional effects
+    BOOL 
+    InitTexturePolar( 
+        CImmDevice* pDevice, 
+        LONG lPosBumpMag = IMM_TEXTURE_DEFAULT_MAGNITUDE,
+        DWORD dwPosBumpWidth = IMM_TEXTURE_DEFAULT_WIDTH,
+        DWORD dwPosBumpSpacing = IMM_TEXTURE_DEFAULT_SPACING,
+        LONG lNegBumpMag = IMM_TEXTURE_DEFAULT_MAGNITUDE,
+        DWORD dwNegBumpWidth = IMM_TEXTURE_DEFAULT_WIDTH,
+        DWORD dwNegBumpSpacing = IMM_TEXTURE_DEFAULT_SPACING,
+        POINT pntOffset = IMM_TEXTURE_DEFAULT_OFFSET_POINT,
+        LONG lAngle = IMM_EFFECT_DEFAULT_ANGLE,
+		DWORD dwNoDownload = 0
+        );
+
+
+//
+// ------ PRIVATE INTERFACE ------ 
+//
+                
+    //
+    // HELPERS
+    //
+
+    protected:
+
+    BOOL
+    set_parameters( 
+        DWORD dwfAxis,
+        DWORD dwfCoordinates,
+        LONG lDirection0,
+        LONG lDirection1,
+        LPCIMM_TEXTURE pTextureX,
+        LPCIMM_TEXTURE pTextureY
+        );
+
+    BOOL
+    set_parameters( 
+        DWORD dwfAxis,
+        DWORD dwfCoordinates,
+        LONG lDirection0,
+        LONG lDirection1,
+        LONG lPosBumpMag,
+        DWORD dwPosBumpWidth,
+        DWORD dwPosBumpSpacing,
+        LONG lNegBumpMag,
+        DWORD dwNegBumpWidth,
+        DWORD dwNegBumpSpacing,
+        POINT pntOffset
+        );
+
+	DWORD
+	change_parameters( 
+		LONG lDirection0,
+		LONG lDirection1,
+		LPCIMM_TEXTURE pTextureX, 
+		LPCIMM_TEXTURE pTextureY
+	    );
+
+	DWORD
+	change_parameters( 
+		LONG lDirection0,
+		LONG lDirection1,
+		LONG lPosBumpMag,
+		DWORD dwPosBumpWidth,
+		DWORD dwPosBumpSpacing,
+		LONG lNegBumpMag,
+		DWORD dwNegBumpWidth,
+		DWORD dwNegBumpSpacing,
+		POINT pntOffset,
+		int fAxis
+		);
+	
+	int
+	buffer_ifr_data(
+		TCHAR* pData
+		);
+
+    //
+    // INTERNAL DATA
+    //
+
+    IMM_TEXTURE m_aTexture[2];
+    DWORD m_dwfAxis;
+    
+    protected:
+
+};
+
+
+
+//
+// INLINES
+//
+
+inline BOOL
+CImmTexture::GetIsCompatibleGUID(GUID &guid)
+{
+	return IsEqualGUID(guid, GUID_Imm_Texture);
+}
+
+#endif // !defined(AFX_ImmTexture_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_)
diff --git a/code/ff/IFC/vssver.scc b/code/ff/IFC/vssver.scc
new file mode 100644
index 0000000..00bae12
Binary files /dev/null and b/code/ff/IFC/vssver.scc differ
diff --git a/code/ff/cl_ff.cpp b/code/ff/cl_ff.cpp
new file mode 100644
index 0000000..6becc34
--- /dev/null
+++ b/code/ff/cl_ff.cpp
@@ -0,0 +1,72 @@
+//#include "../server/exe_headers.h"
+#include "../client/client.h"
+
+#ifdef _IMMERSION
+
+#include "ff_public.h"
+#include "ff.h"
+#include "ff_snd.h"
+
+extern clientActive_t cl;
+
+void CL_InitFF( void )
+{
+	cvar_t *use_ff = Cvar_Get( "use_ff", "1", CVAR_ARCHIVE );
+
+	if (!use_ff
+	||	!use_ff->integer
+	||	!FF_Init()
+	){
+		FF_Shutdown();
+	}
+}
+
+void CL_ShutdownFF( void )
+{
+	FF_Shutdown();
+}
+
+qboolean IsLocalClient( int clientNum )
+{
+	return qboolean
+	(	clientNum == 0						//clientNum == cl.snap.ps.clientNum	
+	||	clientNum == FF_CLIENT_LOCAL		// assumed local
+	);
+}
+
+void CL_FF_Start( ffHandle_t ff, int clientNum )
+{
+	if ( IsLocalClient( clientNum ) )
+	{
+		//FF_Play( ff );	// plays instantly
+		FF_AddForce( ff );	// plays at end of frame
+	}
+}
+
+void CL_FF_Stop( ffHandle_t ff, int clientNum )
+{
+	if ( IsLocalClient( clientNum ) )
+	{
+		FF_Stop( ff );
+	}
+}
+
+/*
+void CL_FF_EnsurePlaying( ffHandle_t ff, int clientNum )
+{
+	if ( IsLocalClient( clientNum ) )
+	{
+		FF_EnsurePlaying( ff );
+	}
+}
+*/
+
+void CL_FF_AddLoopingForce( ffHandle_t ff, int clientNum )
+{
+	if ( IsLocalClient( clientNum ) )
+	{
+		FF_AddLoopingForce( ff );
+	}
+}
+
+#endif // _IMMERSION
\ No newline at end of file
diff --git a/code/ff/cl_ff.h b/code/ff/cl_ff.h
new file mode 100644
index 0000000..fed1963
--- /dev/null
+++ b/code/ff/cl_ff.h
@@ -0,0 +1,13 @@
+#ifndef __CL_FF_H
+#define __CL_FF_H
+
+#include "ff_public.h"
+
+void		CL_InitFF				( void );
+void		CL_ShutdownFF			( void );
+
+void		CL_FF_Start				( ffHandle_t ff, int clientNum = FF_CLIENT_LOCAL );
+void		CL_FF_Stop				( ffHandle_t ff, int clientNum = FF_CLIENT_LOCAL );
+void		CL_FF_AddLoopingForce	( ffHandle_t ff, int clientNum = FF_CLIENT_LOCAL );
+
+#endif // __CL_FF_H
diff --git a/code/ff/common_headers.h b/code/ff/common_headers.h
new file mode 100644
index 0000000..476b77c
--- /dev/null
+++ b/code/ff/common_headers.h
@@ -0,0 +1,50 @@
+#ifndef FF_COMMON_HEADERS_H
+#define FF_COMMON_HEADERS_H
+
+#ifdef _IMMERSION
+
+#include "ff_local.h"
+
+#pragma warning(disable : 4018)     // signed/unsigned mismatch
+#pragma warning(disable : 4032)
+#pragma warning(disable : 4051)
+#pragma warning(disable : 4057)		// slightly different base types
+#pragma warning(disable : 4100)		// unreferenced formal parameter
+#pragma warning(disable : 4115)
+#pragma warning(disable : 4125)		// decimal digit terminates octal escape sequence
+#pragma warning(disable : 4127)		// conditional expression is constant
+#pragma warning(disable : 4136)
+#pragma warning(disable : 4152)		// nonstandard extension, function/data pointer conversion in expression
+#pragma warning(disable : 4201)
+#pragma warning(disable : 4214)		// bitfields on type other than int
+#pragma warning(disable : 4244)		// conversion from double to float
+#pragma warning(disable : 4284)		// return type not UDT
+#pragma warning(disable : 4305)		// truncation from const double to float
+#pragma warning(disable : 4310)		// cast truncates constant value
+#pragma warning(disable : 4503)		// decorated name length truncated
+#pragma warning(disable : 4505) 	// unreferenced local function has been removed
+#pragma warning(disable : 4511)		// copy ctor could not be genned
+#pragma warning(disable : 4512)		// assignment op could not be genned
+#pragma warning(disable : 4514)		// unreffed inline removed
+#pragma warning(disable : 4663)		// c++ lang change
+#pragma warning(disable : 4710)		// not inlined
+#pragma warning(disable : 4711)		// selected for automatic inline expansion
+#pragma warning(disable : 4220)		// varargs matches remaining parameters
+#pragma warning(disable : 4786)		// identifier was truncated
+#pragma warning(disable : 4800)		// forcing value to bool 'true' or 'false' (performance warning)
+#pragma warning(disable : 4702)
+#pragma warning( push, 3 )
+#include <map>
+#include <string>
+#include <set>
+#include <vector>
+#pragma warning( pop )
+using namespace std;
+
+#include "ifc.h"
+#include "ff_utils.h"
+#include "ff_system.h"
+
+#endif // _IMMERSION
+
+#endif // FF_COMMON_HEADERS_H
diff --git a/code/ff/ff.cpp b/code/ff/ff.cpp
new file mode 100644
index 0000000..fefab0a
--- /dev/null
+++ b/code/ff/ff.cpp
@@ -0,0 +1,383 @@
+#include "common_headers.h"
+
+#ifdef _IMMERSION
+
+#define INITGUID	// this will need removing if already defined in someone else's module. Only one must exist in whole game
+
+//#include "ff.h"
+//#include "ff_ffset.h"
+//#include "ff_compound.h"
+//#include "ff_system.h"
+
+FFSystem gFFSystem;
+
+cvar_t	*use_ff;
+cvar_t	*ensureShake;
+cvar_t	*ff_developer;
+#ifdef FF_DELAY
+cvar_t	*ff_delay;
+#endif
+cvar_t	*ff_channels;
+
+static const char *_pass = "SUCCEEDED";
+static const char *_fail = "FAILED";
+
+const char *gChannelName[ FF_CHANNEL_MAX ] =
+{	"FF_CHANNEL_WEAPON"
+,	"FF_CHANNEL_MENU"
+,	"FF_CHANNEL_TOUCH"
+,	"FF_CHANNEL_DAMAGE"
+,	"FF_CHANNEL_BODY"
+,	"FF_CHANNEL_FORCE"
+,	"FF_CHANNEL_FOOT"
+};
+
+// Enable/Disable Com_Printf in FF_* functions
+#if( 1 )
+#ifdef FF_PRINT
+#define FF_PROLOGUE( name, string )			qboolean result = qfalse; if ( FF_IsAvailable() ) { if ( ff_developer && ff_developer->integer ) Com_Printf( "%s: \"%s\" ", #name, string );
+#define FF_PROLOGUE_NOQUOTE( name, string )	qboolean result = qfalse; if ( FF_IsAvailable() ) { if ( ff_developer && ff_developer->integer ) Com_Printf( "%s: %s ", #name, string );
+#define FF_EPILOGUE							FF_EPILOGUE_NORETURN; return result;
+#define FF_EPILOGUE_NORETURN				} if ( ff_developer && ff_developer->integer ) Com_Printf( "[%s]\n", ( result ? _pass : _fail ) );
+#define FF_RESULT( function )				result = qboolean( function );
+#else
+#define FF_PROLOGUE( name, string )			qboolean result = qfalse; if ( FF_IsAvailable() ) { 
+#define FF_PROLOGUE_NOQUOTE( name, string )	qboolean result = qfalse; if ( FF_IsAvailable() ) { 
+#define FF_EPILOGUE							FF_EPILOGUE_NORETURN; return result;
+#define FF_EPILOGUE_NORETURN				}
+#define FF_RESULT( function )				result = qboolean( function );
+#endif
+#else
+#define FF_PROLOGUE( name, string )			qboolean result = qfalse;
+#define FF_PROLOGUE_NOQUOTE( name, string )	qboolean result = qfalse;
+#define FF_EPILOGUE							return result;
+#define FF_EPILOGUE_NORETURN
+#define FF_RESULT( function )				result = qboolean( function );
+#endif
+
+////--------------
+/// FF_IsAvailable
+//------------------
+//	Test to see if force feedback is currently operating. This is almost useless.
+//	The only good it does currently is temporarily toggle effects on/off for users
+//	amusement... feedback on, feedback off, feedback on, feedback off. Results are
+//	instantaneous. FF_* calls basically skip themselves harmlessly.
+//
+//	Assumptions:
+//	*	External system unloads this module if no device is present.
+//	*	External system unloads this module if feedback is disabled when system (re)starts
+//
+//	Parameters:
+//		None
+//
+//	Returns:
+//	-	true: feedback currently enabled
+//	-	false: feedback currently disabled
+//
+qboolean FF_IsAvailable(void)
+{
+	return (use_ff && use_ff->integer && gFFSystem.IsInitialized()) ? qtrue : qfalse;
+}
+
+qboolean FF_IsInitialized(void)
+{
+	return gFFSystem.IsInitialized();
+}
+
+////-------
+/// FF_Init
+//-----------
+//	Initializes the force feedback system.
+//
+//	This function may be called multiple times to apply changes in cvars.
+//
+//	Assumptions:
+//	*	If FF_Init returns qfalse, caller calls FF_Shutdown
+//
+//	Parameters:
+//		None
+//
+//	Returns:
+//	-	qtrue: module initialized properly.
+//	-	qfalse: module experienced an error. Caller MUST call FF_Shutdown.
+//
+qboolean FF_Init( void )
+{
+	if ( !gFFSystem.IsInitialized() )
+	{
+		//
+		//	Console variable setup
+		//
+
+#ifdef FF_CONSOLECOMMAND
+		Cmd_AddCommand( "ff_stopall",	CMD_FF_StopAll		);
+		Cmd_AddCommand( "ff_info",		CMD_FF_Info			);
+#endif
+		use_ff				= Cvar_Get( "use_ff",				"1",	CVAR_ARCHIVE /*| CVAR_LATCH*/); 
+		ensureShake			= Cvar_Get( "ff_ensureShake",		"1",	CVAR_TEMP);
+		ff_developer		= Cvar_Get( "ff_developer",			"0",	CVAR_TEMP);
+		ff_channels			= Cvar_Get( "ff_channels",		FF_CHANNEL,	CVAR_ARCHIVE);
+#ifdef FF_DELAY
+		ff_delay			= Cvar_Get( "ff_delay",			FF_DELAY,	CVAR_ARCHIVE);
+#endif
+	}
+	
+	return qboolean // assumes external system will call FF_Shutdown in case of failure
+	(	ff_channels != NULL
+	&&	gFFSystem.Init( ff_channels->string )
+	);
+}
+
+////-----------
+/// FF_Shutdown
+//---------------
+//	Shut force feedback system down and free resources.
+//
+//	Assumptions:
+//	*	Always called if FF_Init returns qfalse. ALWAYS. (Or memory leaks occur)
+//	*	Never called twice in succession. (always in response to previous assumption)
+//
+//	Parameters:
+//		None
+//
+//	Returns:
+//		None
+//
+void FF_Shutdown(void)
+{
+#ifdef FF_CONSOLECOMMAND
+	Cmd_RemoveCommand( "ff_stopall" );
+	Cmd_RemoveCommand( "ff_info" );
+#endif
+
+	gFFSystem.Shutdown();
+}
+
+////-----------
+/// FF_Register
+//---------------
+//	Loads a named effect from an .ifr file through the game's file system. The handle
+//	returned is not tied to any particular device. The feedback system may even change
+//	which device receives the effect without the need to restart the external system.
+//	The is ONE EXCEPTION. If this module is not loaded when the registration phase
+//	passes, the external system will need to be restarted to register effects properly.
+//
+//	Parameters:
+//	*	name: effect name from .ifr (case-sensitive)
+//	*	channel: channel to output effect. A channel may play on 0+ devices.
+//	*	notfound: return a valid handle even if effect is not found
+//		- Allows temporary disabling of a channel in-game without losing effects
+//		- Only use with trusted effect names, not user input. See CMD_FF_Play.
+//
+//	Returns:
+//		Handle to loaded effect
+//
+ffHandle_t FF_Register( const char *name, int channel, qboolean notfound )
+{
+	ffHandle_t ff = FF_HANDLE_NULL;
+
+	// Removed console print... too much spam with AddLoopingForce.
+/*
+	FF_PROLOGUE( FF_Register, ( name ? name : "" ) );
+	ff = gFFSystem.Register( name, channel, notfound );
+	FF_RESULT( ff != FF_HANDLE_NULL );
+	FF_EPILOGUE_NORETURN;
+*/
+	if ( FF_IsAvailable() )
+		ff = gFFSystem.Register( name, channel, notfound );
+
+	return ff;
+}
+
+////----------------
+/// FF_EnsurePlaying
+//--------------------
+//	Starts an effect if the effect is not currently playing.
+//	Does not restart currently playing effects.
+//
+//	Parameters:
+//	*	ff: handle of an effect
+//
+//	Returns:
+//	-	qtrue: effect started
+//	-	qfalse: effect was not started
+//
+qboolean FF_EnsurePlaying(ffHandle_t ff)
+{
+	FF_PROLOGUE( FF_EnsurePlaying, gFFSystem.GetName( ff ) );
+	FF_RESULT( gFFSystem.EnsurePlaying( ff ) );
+	FF_EPILOGUE;
+}
+
+////-------
+/// FF_Play
+//-----------
+//	Start an effect on its registered channel.
+//
+//	Parameters
+//	*	ff: handle to an effect
+//
+//	Returns:
+//	-	qtrue: effect started
+//	-	qfalse: effect was not started
+//
+qboolean FF_Play(ffHandle_t ff)
+{
+	FF_PROLOGUE( FF_Play, gFFSystem.GetName( ff ) );
+	FF_RESULT( gFFSystem.Play( ff ) );
+	FF_EPILOGUE;
+}
+
+////----------
+/// FF_StopAll
+//--------------
+//	Stop all currently playing effects.
+//
+//	Parameters:
+//		None
+//
+//	Returns:
+//	-	qtrue: no errors occurred
+//	-	qfalse: an error occurred
+//
+qboolean FF_StopAll(void)
+{
+	FF_PROLOGUE( FF_StopAll, "" );
+	FF_RESULT( gFFSystem.StopAll() );
+	FF_EPILOGUE;
+}
+
+////-------
+/// FF_Stop
+//-----------
+//	Stop an effect. Only returns qfalse if there's an error
+//
+//	Parameters:
+//	*	ff: handle to a playing effect
+//
+//	Returns:
+//	-	qtrue: no errors occurred
+//	-	qfalse: an error occurred
+//
+qboolean FF_Stop(ffHandle_t ff)
+{
+	FF_PROLOGUE( FF_Stop, gFFSystem.GetName( ff ) );
+	FF_RESULT( gFFSystem.Stop( ff ) );
+	FF_EPILOGUE;
+}
+
+
+////--------
+/// FF_Shake
+//------------
+//	Shake the mouse (play the special "shake" effect) at a given strength
+//	for a given duration. The shake effect can be a compound containing
+//	multiple component effects, but each component effect's magnitude and
+//	duration will be set to the parameters passed in this function.
+//
+//	Parameters:
+//	*	intensity [0..10000] - Magnitude of effect
+//	*	duration [0..MAXINT] - Length of shake in milliseconds
+//
+//	Returns:
+//	-	qtrue: shake started
+//	-	qfalse: shake did not start
+//
+qboolean FF_Shake(int intensity, int duration)
+{
+	char message[64];
+	message[0] = 0;
+	sprintf( message, "intensity=%d, duration=%d", intensity, duration );
+	FF_PROLOGUE_NOQUOTE( FF_Shake, message );
+	FF_RESULT( gFFSystem.Shake( intensity, duration, qboolean( ensureShake->integer != qfalse ) ) );
+	FF_EPILOGUE;
+}
+
+#ifdef FF_CONSOLECOMMAND
+
+////--------------
+/// CMD_FF_StopAll
+//------------------
+//	Console function which stops all currently playing effects
+//
+//	Parameters:
+//		None
+//
+//	Returns:
+//		None
+//
+void CMD_FF_StopAll(void)
+{
+	// Display messages
+	if ( FF_StopAll() )
+	{
+		Com_Printf( "stopping all effects\n" );
+	}
+	else
+	{
+		Com_Printf( "failed to stop all effects\n" );
+	}
+}
+
+////-----------
+/// CMD_FF_Info
+//---------------
+//	Console function which displays various ff-system information.
+//
+//	Parameters:
+//	*	'devices'	display list of ff devices currently connected
+//	*	'channels'	display list of support ff channels
+//	*	'order'		display search order used by ff name-resolution system (ff_ffset.cpp)
+//	*	'files'		display currently loaded .ifr files sorted by device
+//	*	'effects'	display currently registered effects sorted by device
+//
+//	Returns:
+//		None
+//
+void CMD_FF_Info(void)
+{
+	TNameTable Unprocessed, Processed;
+	int i, max;
+
+	for
+	(	i = 1, max = Cmd_Argc()
+	;	i < max
+	;	i++
+	){
+		Unprocessed.push_back( Cmd_Argv( i ) );
+	}
+
+	if ( Unprocessed.size() == 0 )
+	{
+		
+		if ( ff_developer->integer )
+			Com_Printf( "Usage: ff_info [devices] [channels] [order] [files] [effects]\n" );
+		else
+			Com_Printf( "Usage: ff_info [devices] [channels]\n" );
+
+		return;
+	}
+
+	gFFSystem.Display( Unprocessed, Processed );
+
+	if ( Unprocessed.size() > 0 )
+	{
+		Com_Printf( "invalid parameters:" );
+		for
+		(	i = 0
+		;	i < Unprocessed.size()
+		;	i++
+		){
+			Com_Printf( " %s", Unprocessed[ i ].c_str() );
+		}
+
+		if ( ff_developer->integer )
+			Com_Printf( "Usage: ff_info [devices] [channels] [order] [files] [effects]\n" );
+		else
+			Com_Printf( "Usage: ff_info [devices] [channels]\n" );
+	}
+}
+
+#endif // FF_CONSOLECOMMAND
+
+#endif // _IMMERSION
\ No newline at end of file
diff --git a/code/ff/ff.h b/code/ff/ff.h
new file mode 100644
index 0000000..8321c1b
--- /dev/null
+++ b/code/ff/ff.h
@@ -0,0 +1,33 @@
+#ifndef __FF_H
+#define __FF_H
+
+#include "../ff/ff_public.h"
+
+#ifdef _FF
+
+//
+//	Externally visible functions
+//
+
+qboolean		FF_Init				(void);
+void			FF_Shutdown			(void);
+qboolean		FF_IsAvailable		(void);	
+qboolean		FF_IsInitialized	(void);
+ffHandle_t		FF_Register			(const char* ff, int channel, qboolean notfound = qtrue);
+qboolean		FF_Play				(ffHandle_t ff);
+qboolean		FF_EnsurePlaying	(ffHandle_t ff);
+qboolean		FF_Stop				(ffHandle_t ff);
+qboolean		FF_StopAll			(void);
+qboolean		FF_Shake			(int intensity, int duration);
+
+#ifdef FF_CONSOLECOMMAND
+typedef void (*xcommand_t) (void);
+void			CMD_FF_StopAll		(void);
+void			CMD_FF_Info			(void);
+#endif
+
+//ffExport_t* GetFFAPI ( int apiVersion, ffImport_t *ffimp );
+
+#endif // _FF
+
+#endif	// __FF_H
diff --git a/code/ff/ff_ChannelCompound.h b/code/ff/ff_ChannelCompound.h
new file mode 100644
index 0000000..1b9acda
--- /dev/null
+++ b/code/ff/ff_ChannelCompound.h
@@ -0,0 +1,64 @@
+#ifndef FF_CHANNELCOMPOUND_H
+#define FF_CHANNELCOMPOUND_H
+
+#include "ff_MultiCompound.h"
+
+////---------------
+///	ChannelCompound
+//-------------------
+//	Stored in THandleTable. This class associates MultiCompound with some arbitrary 'channel.'
+//	Further, this class assumes that its MultiEffects have the same name and are probably
+//	initialized on different devices. None of this is enforced at this time.
+//
+class ChannelCompound : public MultiCompound
+{
+protected:
+	int mChannel;
+public:
+	ChannelCompound( int channel = FF_CHANNEL_MAX ) 
+	:	MultiCompound()
+	{
+		mChannel = 
+		(	(channel >= 0 && channel < FF_CHANNEL_MAX)
+		?	channel
+		:	FF_CHANNEL_MAX
+		);
+	}
+
+	ChannelCompound( Set &compound, int channel = FF_CHANNEL_MAX )
+	:	MultiCompound( compound )
+	{
+		mChannel = 
+		(	(channel >= 0 && channel < FF_CHANNEL_MAX)
+		?	channel
+		:	FF_CHANNEL_MAX
+		);
+	}
+
+	int GetChannel() 
+	{
+		return mChannel;
+	}
+	const char *GetName()
+	{
+		return mSet.size() 
+		?	(*mSet.begin())->GetName()
+		:	NULL
+		;
+	}
+	qboolean operator == ( ChannelCompound &channelcompound )
+	{
+		return qboolean
+		(	mChannel == channelcompound.mChannel
+		&&	(*(MultiCompound*)this) == *(MultiCompound*)&channelcompound
+		);
+	}
+	qboolean operator != ( ChannelCompound &channelcompound )
+	{
+		return qboolean( !( (*this) == channelcompound ) );
+	}
+};
+
+typedef vector<ChannelCompound> THandleTable;
+
+#endif // FF_CHANNELCOMPOUND_H
diff --git a/code/ff/ff_ChannelSet.cpp b/code/ff/ff_ChannelSet.cpp
new file mode 100644
index 0000000..0f6f7d3
--- /dev/null
+++ b/code/ff/ff_ChannelSet.cpp
@@ -0,0 +1,162 @@
+#include "common_headers.h"
+
+#ifdef _IMMERSION
+
+extern const char *gChannelName[];
+
+////---------------------------
+/// FFChannelSet::ParseChannels
+//-------------------------------
+//	This is the worst hack of a parser ever devised.
+//
+qboolean FFChannelSet::ParseChannels( const char *channels )
+{
+	if ( !channels )
+		return qfalse;
+
+	int channel;
+	const char *pos;
+
+	for
+	(	pos = channels
+	;	pos && sscanf( pos, "%d", &channel ) == 1
+	;
+	){
+		int device;
+		char *endpos;
+		endpos = strchr( pos, ';' );
+
+		if ( channel >= 0 && channel < FF_CHANNEL_MAX )
+		{
+			for
+			(	pos = strchr( pos, ',' )
+			;	pos && ( !endpos || pos < endpos ) && sscanf( pos, " ,%d", &device ) == 1
+			;	pos = strchr( pos + 1, ',' )
+			){
+				if ( device >= 0 && device < mSet.size() )
+				{
+					for
+					(	ChannelIterator itChannel( mChannel, channel )
+					;	itChannel != mChannel.end()
+					&&	(**itChannel).second != device	// found duplicate
+					;	++itChannel
+					);
+
+					// Don't allow duplicates
+					if ( itChannel == mChannel.end() )
+					{
+						FFChannelSet::Channel::value_type Value( channel, device );
+						Value.second = device;
+						mChannel.insert( Value );
+					}
+				}
+			}
+		}
+
+		pos = ( endpos ? endpos + 1 : NULL);
+
+	}
+
+	// FIX ME -- return qfalse if there is a parse error
+	return qtrue;
+}
+
+////----------------------
+/// FFChannelSet::Register
+//--------------------------
+//
+//	Assumptions:
+//	*	'compound' is empty of effects and contains the desired channel prior to entry.
+//
+//	Parameters:
+//	*	compound: its channel parameter is an input. its effect set is filled with registered
+//		- effects. 'compound' should not contain any effects prior to this function call.
+//	*	name: effect name to register in each FFSet on the channel
+//	*	create: qtrue if FFSet should create the effect, qfalse if it should just look it up.
+//
+qboolean FFChannelSet::Register( ChannelCompound &compound, const char *name, qboolean create )
+{
+	for
+	(	ChannelIterator itChannel( mChannel, compound.GetChannel() )
+	;	itChannel != mChannel.end()
+	;	++itChannel
+	){
+		MultiEffect *Effect;
+		Effect = mSet[ (**itChannel).second ]->Register( name, create );
+		if ( Effect )
+			compound.GetSet().insert( Effect );
+	}
+
+	return qboolean( compound.GetSet().size() != 0 );
+}
+
+#ifdef FF_CONSOLECOMMAND
+
+void FFChannelSet::GetDisplayTokens( TNameTable &Tokens )
+{
+	FFMultiSet::GetDisplayTokens( Tokens );
+	Tokens.push_back( "channels" );
+	Tokens.push_back( "devices" );
+}
+
+
+void FFChannelSet::Display( TNameTable &Unprocessed, TNameTable &Processed )
+{
+	FFMultiSet::Display( Unprocessed, Processed );
+
+	for
+	(	TNameTable::iterator itName = Unprocessed.begin()
+	;	itName != Unprocessed.end()
+	;
+	){
+		if ( stricmp( "channels", (*itName).c_str() ) == 0 )
+		{
+			Com_Printf( "[available channels]\n" );
+
+			for
+			(	int i = 0
+			;	i < FF_CHANNEL_MAX
+			;	i++
+			){
+				Com_Printf( "%d) %s  devices:", i, gChannelName[ i ] );
+				for
+				(	ChannelIterator itChannel( mChannel, i )
+				;	itChannel != mChannel.end()
+				;	++itChannel
+				){
+					Com_Printf( " %d", (**itChannel).second );
+				}
+				Com_Printf( "\n" );
+			}
+
+			Processed.push_back( *itName );
+			itName = Unprocessed.erase( itName );
+		}
+		else if ( stricmp( "devices", (*itName).c_str() ) == 0 )
+		{
+			Com_Printf( "[initialized devices]\n" );
+
+			for
+			(	int i = 0
+			;	i < mDevices->GetNumDevices()
+			;	i++
+			){
+				char ProductName[ FF_MAX_PATH ];
+				ProductName[ 0 ] = 0;
+				mDevices->GetDevice( i )->GetProductName( ProductName, FF_MAX_PATH - 1 );
+				Com_Printf( "%d) %s\n", i, ProductName );
+			}
+
+			Processed.push_back( *itName );
+			itName = Unprocessed.erase( itName );
+		}
+		else
+		{
+			itName++;
+		}
+	}
+}
+
+#endif // FF_CONSOLECOMMAND
+
+#endif // _IMMERSION
\ No newline at end of file
diff --git a/code/ff/ff_ChannelSet.h b/code/ff/ff_ChannelSet.h
new file mode 100644
index 0000000..022d940
--- /dev/null
+++ b/code/ff/ff_ChannelSet.h
@@ -0,0 +1,59 @@
+#ifndef FF_CHANNELSET_H
+#define FF_CHANNELSET_H
+
+#include "ff_utils.h"
+#include "ff_MultiSet.h"
+#include "ff_ChannelCompound.h"
+
+//===[FFChannelSet]===================================================/////////////
+//
+//	An extension to FFMultiSet that operates on a subset of its
+//	elements specified by a channel. This channel may be inherent 
+//	to a ChannelCompound passed as a parameter.
+//
+//====================================================================/////////////
+
+class FFChannelSet : public FFMultiSet
+{
+public:
+	typedef multimap<int, int> Channel;
+protected:
+	Channel mChannel;
+	qboolean ParseChannels( const char *channels );
+public:
+	qboolean Init( FFConfigParser &config, const char *channels )
+	{
+		return qboolean
+		(	FFMultiSet::Init( config )					// Initialize devices
+		&&	ParseChannels( channels )					// Assign channels to devices
+		);
+	}
+	void clear()
+	{
+		mChannel.clear();
+		FFMultiSet::clear();
+	}
+	qboolean Register( ChannelCompound &compound, const char *name, qboolean create );
+
+	//
+	//	Optional
+	//
+#ifdef FF_ACCESSOR
+//	Channel& GetAll() { return mChannel; }
+#endif
+
+#ifdef FF_CONSOLECOMMAND
+	void Display( TNameTable &Unprocessed, TNameTable &Processed );
+	static void GetDisplayTokens( TNameTable &Tokens );
+#endif
+};
+
+class ChannelIterator : public multimapIterator<FFChannelSet::Channel>
+{
+public:
+	ChannelIterator( FFChannelSet::Channel &map, int channel )
+	:	multimapIterator<FFChannelSet::Channel>( map, channel )
+	{}
+};
+
+#endif // FF_CHANNELSET_H
\ No newline at end of file
diff --git a/code/ff/ff_ConfigParser.cpp b/code/ff/ff_ConfigParser.cpp
new file mode 100644
index 0000000..f8dd946
--- /dev/null
+++ b/code/ff/ff_ConfigParser.cpp
@@ -0,0 +1,483 @@
+#include "common_headers.h"
+
+#ifdef _IMMERSION
+
+//#include "ff_ConfigParser.h"
+//#include "ifc.h"
+//#include "ff_utils.h"
+
+////--------------------
+/// FFConfigParser::Init
+//------------------------
+//	Reads the force feedback configuration file. Call this once after the device
+//	is initialized.
+//
+//	Parameters:
+//	*	filename
+//
+//	Returns:
+//	*	qtrue - the effects set directory has been set according to the initialized
+//			device. (See base/fffx/fffx.cfg)
+//	*	qfalse - no effects set could be determined for this device.
+//
+qboolean FFConfigParser::Init( const char *filename )
+{
+	Clear();	// Always cleanup
+
+	return qboolean( filename && Parse( LoadFile( filename ) ) );
+}
+
+////---------------------
+/// FFConfigParser::Clear
+//-------------------------
+//
+//
+//	Parameters:
+//
+//	Returns:
+//
+void FFConfigParser::Clear( void )
+{
+	mMap.clear();
+	mDefaultSet.clear();
+}
+
+////---------------------
+/// FFConfigParser::Parse
+//-------------------------
+//
+//
+//	Parameters:
+//
+//	Returns:
+//
+qboolean FFConfigParser::Parse( void *file )
+{
+	qboolean result = qboolean( file != NULL );
+
+	if ( file )
+	{
+		const char *token = 0, *pos = (const char*)file;
+		for
+		(	token = COM_ParseExt( &pos, qtrue )
+		;	token[ 0 ]
+		&&	result // fail if any problem
+		;	token = COM_ParseExt( &pos, qtrue )
+		){
+			if ( !stricmp( token, "ffdefaults" ) )
+			{
+				result &= ParseDefaults( &pos );
+			}
+			else
+			if ( !stricmp( token, "ffsets" ) )
+			{
+				result &= ParseSets( &pos );
+			}
+			else
+			{
+				// unexpected field
+				result = qfalse;
+			}
+		}
+
+		FS_FreeFile( file );
+	}
+
+	return result;
+}
+
+////---------------------------------
+/// FFConfigParser::ParseDefaultBlock
+//-------------------------------------
+//
+//
+//	Parameters:
+//
+//	Returns:
+//
+qboolean FFConfigParser::ParseDefault( const char **pos, TDeviceType &defaultSet )
+{
+	qboolean result = qboolean( pos != NULL );
+
+	if ( pos )
+	{
+		char *token = COM_ParseExt( pos, qtrue );
+		if ( token[ 0 ] == '{' )
+		{
+			for
+			(	token = COM_ParseExt( pos, qtrue )
+			;	token[ 0 ]
+			&&	token[ 0 ] != '}'
+			&&	result // fail if any problem
+			;	token = COM_ParseExt( pos, qtrue )
+			){
+				int device = 0;
+
+				if ( sscanf( token, "%d", &device ) )
+				{
+					string &str = defaultSet[ device ];
+					if ( !str.size() )
+					{
+						str = COM_ParseExt( pos, qfalse );
+						result &= qboolean( str.size() > 0 );
+					}
+					else
+					{
+						result = qfalse;
+#ifdef FF_PRINT
+						ConsoleParseError
+						(	"Redefinition of DeviceType index"
+						,	token
+						);
+#endif
+					}
+				}
+				else
+				{
+					result = qfalse;
+#ifdef FF_PRINT
+					ConsoleParseError
+					(	"DeviceType field should begin with an integer"
+					,	token
+					);
+#endif
+				}
+			}
+		}
+	}
+
+	return result;
+}
+
+
+
+////----------------------------
+/// FFConfigParser::ParseDefault
+//--------------------------------
+//
+//
+//	Parameters:
+//
+//	Returns:
+//
+qboolean FFConfigParser::ParseDefaults( const char **pos )
+{
+	qboolean result = qboolean( pos != NULL );
+
+	if ( pos )
+	{
+		char *token = COM_ParseExt( pos, qtrue );
+		if ( token[ 0 ] == '{' )
+		{
+			for
+			(	token = COM_ParseExt( pos, qtrue )
+			;	token[ 0 ]
+			&&	token[ 0 ] != '}'
+			&&	result // fail if any problem
+			;	token = COM_ParseExt( pos, qtrue )
+			){
+				int techType = 0;
+
+				if ( sscanf( token, "%d", &techType ) )
+				{
+					TDeviceType &deviceType = mDefaultSet[ techType ];
+					if ( !deviceType.size() )
+					{
+						result &= ParseDefault( pos, deviceType );
+						mDefaultPriority.push_back( techType );
+					}
+					else
+					{
+						result = qfalse;
+#ifdef FF_PRINT
+						ConsoleParseError
+						(	"Redefinition of TechType index"
+						,	token
+						);
+#endif
+					}
+				}
+				else
+				{
+					result = qfalse;
+#ifdef FF_PRINT
+					ConsoleParseError
+					(	"TechType fields should begin with integers"
+					,	token
+					);
+#endif
+				}
+			}
+		}
+		else
+		{
+			// expected '{'
+			result = qfalse;
+		}
+	}
+
+	return result;
+}
+
+////--------------------------
+/// FFConfigParser::RightOfSet
+//------------------------------
+//
+//
+//	Parameters:
+//
+//	Returns:
+//
+const char* FFConfigParser::RightOfSet( const char *effectname )
+{
+	const char *s = effectname;
+
+	// Check through all set names and test effectname against it
+	for
+	(	TMap::iterator itMap = mMap.begin()
+	;	itMap != mMap.end() && s == effectname
+	;	itMap++
+	){
+		s = RightOf( effectname, (*itMap).first.c_str() );
+	}
+
+	return s ? s : effectname;
+}
+
+qboolean FFConfigParser::ParseSetDevices( const char **pos, TDevice &device )
+{
+	qboolean result = qboolean( pos != NULL );
+
+	if ( pos )
+	{
+		char *token = COM_ParseExt( pos, qtrue );
+		if ( token[ 0 ] == '{' )
+		{
+			for
+			(	token = COM_ParseExt( pos, qtrue )
+			;	token[ 0 ]
+			&&	token[ 0 ] != '}'
+			&&	result // fail if any problem
+			;	token = COM_ParseExt( pos, qtrue )
+			){
+				device.insert( token );
+			}
+
+			result = qboolean( token[ 0 ] != 0 );
+		}
+		else
+		{
+			// expected '{'
+			result = qfalse;
+		}
+	}
+
+	return result;
+}
+
+qboolean FFConfigParser::ParseSetIncludes( const char **pos, TInclude &include )
+{
+	qboolean result = qboolean( pos != NULL );
+
+	if ( pos )
+	{
+		char *token = COM_ParseExt( pos, qtrue );
+		if ( token[ 0 ] == '{' )
+		{
+			for
+			(	token = COM_ParseExt( pos, qtrue )
+			;	token[ 0 ]
+			&&	token[ 0 ] != '}'
+			&&	result // fail if any problem
+			;	token = COM_ParseExt( pos, qtrue )
+			){
+				include.push_back( token );
+			}
+
+			result = qboolean( token[ 0 ] != 0 );
+		}
+		else
+		{
+			// expected '{'
+			result = qfalse;
+		}
+	}
+
+	return result;
+}
+
+qboolean FFConfigParser::ParseSet( const char **pos, TData &data )
+{
+	qboolean result = qboolean( pos != NULL );
+
+	if ( pos )
+	{
+		const char *oldpos = *pos;	// allows set declarations with no attributes to have no "{}" 
+		char *token = COM_ParseExt( pos, qtrue );
+		if ( token[ 0 ] == '{' )
+		{
+			for
+			(	token = COM_ParseExt( pos, qtrue )
+			;	token[ 0 ]
+			&&	token[ 0 ] != '}'
+			&&	result // fail if any problem
+			;	token = COM_ParseExt( pos, qtrue )
+			){
+				if ( !stricmp( token, "includes" ) )
+				{
+					result &= ParseSetIncludes( pos, data.include );
+				}
+				else
+				if ( !stricmp( token, "devices" ) )
+				{
+					result &= ParseSetDevices( pos, data.device );
+				}
+				else
+				{
+					result = qfalse;
+#ifdef FF_PRINT
+					ConsoleParseError
+					(	"Invalid set parameter. Should be 'includes' or 'devices'"
+					,	token
+					);
+#endif
+				}
+			}
+		}
+		else
+		{
+			// expected '{'		(no longer expected!)
+			//result = qfalse;	(no longer an error!)
+			*pos = oldpos;
+		}
+	}
+
+	return result;
+}
+
+////-------------------------
+/// FFConfigParser::ParseSets
+//-----------------------------
+//
+//
+//	Parameters:
+//
+//	Returns:
+//
+qboolean FFConfigParser::ParseSets( const char **pos )
+{
+	qboolean result = qboolean( pos != NULL );
+	string			groupName;
+
+	if ( pos )
+	{
+		char *token = COM_ParseExt( pos, qtrue );
+		if ( token[ 0 ] == '{' )
+		{
+			for
+			(	token = COM_ParseExt( pos, qtrue )
+			;	token[ 0 ]
+			&&	token[ 0 ] != '}'
+			&&	result // fail if any problem
+			;	token = COM_ParseExt( pos, qtrue )
+			){
+				TData &data = mMap[ token ];
+				result &= ParseSet( pos, data );
+			}
+		}
+		else
+		{
+			// expected '{'
+			result = qfalse;
+		}
+	}
+
+	return result;
+}
+
+////---------------------------
+/// FFConfigParser::GetIncludes
+//-------------------------------
+//
+//
+//	Parameters:
+//
+//	Returns:
+//
+FFConfigParser::TInclude& FFConfigParser::GetIncludes( const char *name )
+{
+	TMap::iterator itMap = mMap.find( name );
+	if ( itMap != mMap.end() )
+		return (*itMap).second.include;
+
+	// No includes present
+	static TInclude emptyInclude;
+	return emptyInclude;
+}
+
+const char * FFConfigParser::GetFFSet( CImmDevice *Device )
+{
+	char devName[ FF_MAX_PATH ];
+	const char *ffset = NULL;
+
+	//
+	//	Check explicit name
+	//
+
+	devName[0] = 0;
+	Device->GetProductName( devName, FF_MAX_PATH - 1 );
+	for
+	(	TMap::iterator itmap = mMap.begin()
+	;	itmap != mMap.end()
+	;	itmap++
+	){
+		TDevice::iterator itdev;
+
+		itdev = (*itmap).second.device.find( devName );
+		if ( itdev != (*itmap).second.device.end() )
+			ffset = (*itmap).first.c_str();
+	}
+
+
+	//
+	//	Check device defaults
+	//
+
+	for
+	(	int i = 0
+	;	!ffset && i < mDefaultPriority.size()
+	;	i++
+	){
+		int defaultTechType;
+		DWORD	productType = Device->GetProductType();
+		WORD	deviceType	= HIWORD( productType );
+		WORD	techType	= LOWORD( productType );
+
+		defaultTechType = mDefaultPriority[ i ];
+
+		//
+		//	Check for minimum required features
+		//
+
+		if ( (techType & defaultTechType) >= defaultTechType )
+		{
+			//
+			//	Check that device exists in this technology section
+			//
+
+			TDeviceType::iterator itDeviceType = mDefaultSet[ defaultTechType ].find( deviceType );
+			if ( itDeviceType != mDefaultSet[ defaultTechType ].end() )
+			{
+				ffset = (*itDeviceType).second.c_str();
+			}
+		}
+
+		//
+		//	If not, try next technology section
+		//
+	}
+
+	return ffset;
+}
+
+#endif // _IMMERSION
\ No newline at end of file
diff --git a/code/ff/ff_ConfigParser.h b/code/ff/ff_ConfigParser.h
new file mode 100644
index 0000000..18b8d88
--- /dev/null
+++ b/code/ff/ff_ConfigParser.h
@@ -0,0 +1,51 @@
+#ifndef __FF_CONFIGPARSER_H
+#define __FF_CONFIGPARSER_H
+
+//#include "ff_public.h"	// in precompiled header
+
+//class CImmDevice;
+
+class FFConfigParser
+{
+public:
+	typedef vector<string> TInclude;
+	typedef set<string> TDevice;
+	typedef map<int, string> TDeviceType;
+	typedef map<int, TDeviceType> TTechType;
+	typedef vector<int> TDefaultPriority;
+
+	typedef struct
+	{
+		TInclude include;
+		TDevice device;
+	} TData;
+
+	typedef map<string, TData> TMap;
+
+protected:
+	TTechType mDefaultSet;
+	TDefaultPriority mDefaultPriority;
+	TMap mMap;					// Contains all effect sets by name
+
+	qboolean Parse( void *file );
+	qboolean ParseSets( const char **pos );
+	qboolean ParseSet( const char **pos, TData &data );
+	qboolean ParseSetIncludes( const char **pos, TInclude &include );
+	qboolean ParseSetDevices( const char **pos, TDevice &device );
+	qboolean ParseDefaults( const char **pos );
+	qboolean ParseDefault( const char **pos, TDeviceType &defaultSet );
+
+public:
+
+	qboolean Init( const char *filename/*, CImmDevice *Device = NULL*/ );
+	void Clear( void );
+
+//	const char* RightOfBase( const char *effectname );
+//	const char* RightOfGame( const char *effectname );
+	const char* RightOfSet( const char *effectname );
+
+	const char* GetFFSet( CImmDevice *Device );
+	TInclude& GetIncludes( const char *name = NULL );
+};
+
+#endif // __FF_CONFIGPARSER_H
diff --git a/code/ff/ff_HandleTable.cpp b/code/ff/ff_HandleTable.cpp
new file mode 100644
index 0000000..b75f82b
--- /dev/null
+++ b/code/ff/ff_HandleTable.cpp
@@ -0,0 +1,133 @@
+#include "common_headers.h"
+
+#ifdef _IMMERSION
+
+////----------------------
+/// FFHandleTable::Convert
+//--------------------------
+//
+//
+ffHandle_t FFHandleTable::Convert( ChannelCompound &compound, const char *name, qboolean create )
+{
+	ffHandle_t ff = FF_HANDLE_NULL;
+
+	//	Reserve a handle for effects that failed to create.
+	//	Rerouting channels to other devices may cause an effect to become lost.
+	//	This assumes that FF_Register is always called with legitimate effect names.
+	//	See CMD_FF_Play on how to handle possibly-bogus user input.
+	//	(It does not call this function)
+	if ( compound.GetSet().size() )
+		ff = Convert( compound );
+	else
+	{
+		for
+		(	FFHandleTable::RegFail::iterator itRegFail = mRegFail.begin()
+		;	itRegFail != mRegFail.end()
+		&&	(*itRegFail).second != name
+		;	itRegFail++
+		);
+
+		ff = 
+		(	itRegFail != mRegFail.end()
+		?	(*itRegFail).first
+		:	FF_HANDLE_NULL
+		);
+	}
+
+	if ( ff == FF_HANDLE_NULL )
+	{
+		mVector.push_back( compound );
+		ff = mVector.size() - 1;
+
+		// Remember effect name for future 'ff_restart' calls.
+		if ( create && !compound.GetSet().size() )
+			mRegFail[ ff ] = name;
+	}
+
+	return ff;
+}
+
+////----------------------
+/// FFHandleTable::Convert
+//--------------------------
+//	Looks for 'compound' in the table.
+//
+//	Assumes:
+//	*	'compound' is non-empty
+//
+//	Returns:
+//		ffHandle_t
+//
+ffHandle_t FFHandleTable::Convert( ChannelCompound &compound )
+{
+	for
+	(	int i = 1
+	;	i < mVector.size()
+	&&	mVector[ i ] != compound
+	;	i++
+	);
+
+	return
+	(	i < mVector.size()
+	?	i
+	:	FF_HANDLE_NULL
+	);
+}
+
+////-----------------------------
+/// FFHandleTable::GetFailedNames
+//---------------------------------
+//
+//
+qboolean FFHandleTable::GetFailedNames( TNameTable &NameTable )
+{
+	for
+	(	RegFail::iterator itRegFail = mRegFail.begin()
+	;	itRegFail != mRegFail.end()
+	;	itRegFail++
+	){
+		NameTable[ (*itRegFail).first ] = (*itRegFail).second;
+	}
+
+	return qboolean( mRegFail.size() != 0 );
+}
+
+////--------------------------
+/// FFHandleTable::GetChannels
+//------------------------------
+//
+//
+qboolean FFHandleTable::GetChannels( vector<int> &channel )
+{
+	//ASSERT( channel.size() >= mVector.size() );
+
+	for
+	(	int i = 1
+	;	i < mVector.size()
+	;	i++
+	){
+		channel[ i ] = mVector[ i ].GetChannel();
+	}
+
+	return qtrue;
+}
+
+const char *FFHandleTable::GetName( ffHandle_t ff )
+{
+	const char *result = NULL;
+
+	if ( !mVector[ ff ].IsEmpty() )
+	{
+		result = mVector[ ff ].GetName();
+	}
+	else
+	{
+		RegFail::iterator itRegFail = mRegFail.find( ff );
+		if ( itRegFail != mRegFail.end() )
+			result = (*itRegFail).second.c_str();
+	}
+
+	return result;
+}
+
+#endif // _IMMERSION
\ No newline at end of file
diff --git a/code/ff/ff_HandleTable.h b/code/ff/ff_HandleTable.h
new file mode 100644
index 0000000..c8171f4
--- /dev/null
+++ b/code/ff/ff_HandleTable.h
@@ -0,0 +1,61 @@
+#ifndef FF_HANDLETABLE_H
+#define FF_HANDLETABLE_H
+
+//===[FFHandleTable]==================================================/////////////
+//
+//	This table houses the master list of initialized effects. Indices
+//	into this table are handles used by external modules. This way
+//	effects may be reinitialized on other devices, removed entirely,
+//	and perused informatively at any time without invalidating pointers.
+//
+//====================================================================/////////////
+
+class FFHandleTable
+{
+public:
+	typedef vector<ChannelCompound> Vector;
+	typedef map<int, string> RegFail;
+protected:
+	Vector mVector;
+	RegFail mRegFail;
+public:
+	FFHandleTable()
+	:	mVector()
+	,	mRegFail()
+	{
+		//Init();				// guarantees operator [] always works
+	}
+	void Init()
+	{
+		ChannelCompound handle_null;
+		mVector.push_back( handle_null );
+	}
+	// Empties handle table except for FF_HANDLE_NULL
+	void clear()
+	{
+		mVector.clear();
+		mRegFail.clear();
+		//Init();				// guarantees operator [] always works
+	}
+	int size() 
+	{
+		return mVector.size();
+	}
+	ChannelCompound& operator [] ( ffHandle_t ff ) 
+	{
+		return mVector[ InRange<int>( ff, 0, mVector.size() - 1, FF_HANDLE_NULL ) ];
+	}
+	qboolean GetFailedNames( TNameTable &NameTable );
+	qboolean GetChannels( vector<int> &channels );
+	ffHandle_t Convert( ChannelCompound &compound, const char *name, qboolean create );
+	ffHandle_t Convert( ChannelCompound &compound );
+	const char *GetName( ffHandle_t ff );
+
+	//
+	//	Optional
+	//
+//	qboolean Lookup( set<ffHandle_t> &result, MultiEffect *effect, const char *name );
+//	qboolean Lookup( set<ffHandle_t> &result, set<MultiEffect*> &effect, const char *name );
+};
+
+#endif // FF_HANDLETABLE_H
\ No newline at end of file
diff --git a/code/ff/ff_MultiCompound.cpp b/code/ff/ff_MultiCompound.cpp
new file mode 100644
index 0000000..42eca88
--- /dev/null
+++ b/code/ff/ff_MultiCompound.cpp
@@ -0,0 +1,201 @@
+#include "common_headers.h"
+
+#ifdef _IMMERSION
+
+////------------------
+///	MultiCompound::Add
+//----------------------
+//	Insert a single compound effect if it does not already exist.
+//	Only fails when parameter is NULL.
+//
+qboolean MultiCompound::Add( MultiEffect *effect )
+{
+	return effect ? ( mSet.insert( effect ), qtrue ) : qfalse;
+}
+
+////------------------
+///	MultiCompound::Add
+//----------------------
+//	Merge set of compound effects with current set. NULL pointers are excluded.
+//	Returns false if set contains any NULL pointers. 
+//
+qboolean MultiCompound::Add( Set &effect )
+{
+	qboolean result = qtrue;
+
+	for 
+	(	Set::iterator itSet = effect.begin()
+	;	itSet != effect.end()
+	;	itSet++
+	){
+		result &= Add( *itSet );
+	}
+
+	return result;
+}
+
+////--------------------
+///	MultiCompound::Start
+//------------------------
+//	Analogous to CImmCompoundEffect::Start. Starts all contained compound effects.
+//	Returns false if any effect returns false.
+//
+qboolean MultiCompound::Start()
+{
+	qboolean result = qtrue;
+
+	for
+	(	Set::iterator itSet = mSet.begin()
+	;	itSet != mSet.end()
+	;	itSet++
+	){
+		result &= (*itSet)->Start();
+	}
+
+	return qboolean
+	(	result 
+	&&	mSet.size() != 0
+	);
+}
+
+qboolean MultiCompound::IsPlaying()
+{
+	for
+	(	Set::iterator itSet = mSet.begin()
+	;	itSet != mSet.end()
+	;	itSet++
+	){
+		if ( !(*itSet)->IsPlaying() )
+			return qfalse;
+	}
+
+	return qtrue;
+}
+
+////----------------------------
+///	MultiCompound::EnsurePlaying
+//--------------------------------
+//	Starts any contained compound effects if they are not currently playing.
+//	Returns false if any effect returns false or any are playing.
+//
+qboolean MultiCompound::EnsurePlaying()
+{
+	qboolean result = qtrue;
+
+	if ( !IsPlaying() )
+	{
+		for
+		(	Set::iterator itSet = mSet.begin()
+		;	itSet != mSet.end()
+		;	itSet++
+		){
+			result &= (*itSet)->Start();
+		}
+	}
+
+	return qboolean
+	(	result 
+	&&	mSet.size() != 0
+	);
+}
+
+////-------------------
+///	MultiCompound::Stop
+//-----------------------
+//	Analogous to CImmCompoundEffect::Stop. Stops all contained compound effects.
+//	Returns false if any effect returns false. 
+//
+qboolean MultiCompound::Stop()
+{
+	qboolean result = qtrue;
+
+	for
+	(	Set::iterator itSet = mSet.begin()
+	;	itSet != mSet.end()
+	;	itSet++
+	){
+		result &= qboolean( (*itSet)->Stop() );
+	}
+
+	return qboolean
+	(	result 
+	&&	mSet.size() != 0
+	);
+}
+
+////-----------------------------
+///	MultiCompound::ChangeDuration
+//---------------------------------
+//	Changes duration of all compounds.
+//	Returns false if any effect returns false. 
+//
+qboolean MultiCompound::ChangeDuration( DWORD Duration )
+{
+	qboolean result = qtrue;
+
+	for
+	(	Set::iterator itSet = mSet.begin()
+	;	itSet != mSet.end()
+	;	itSet++
+	){
+		result &= (*itSet)->ChangeDuration( Duration );
+	}
+
+	return qboolean
+	(	result 
+	&&	mSet.size() != 0
+	);
+}
+
+////-------------------------
+///	MultiCompound::ChangeGain
+//-----------------------------
+//	Changes gain of all compounds.
+//	Returns false if any effect returns false. 
+//
+qboolean MultiCompound::ChangeGain( DWORD Gain )
+{
+	qboolean result = qtrue;
+
+	for
+	(	Set::iterator itSet = mSet.begin()
+	;	itSet != mSet.end()
+	;	itSet++
+	){
+		result &= (*itSet)->ChangeGain( Gain );
+	}
+
+	return qboolean
+	(	result 
+	&&	mSet.size() != 0
+	);
+}
+
+////--------------------------
+///	MultiCompound::operator ==
+//------------------------------
+//	Returns qtrue if the sets are EXACTLY equal, including order. This is not good
+//	in general. (Fix me)
+//
+qboolean MultiCompound::operator == ( MultiCompound &compound )
+{
+	Set &other = compound.mSet;
+	qboolean result = qfalse;
+
+	if ( mSet.size() == other.size() )
+	{
+		for
+		(	Set::iterator itSet = mSet.begin(), itOther = other.begin()
+		;	itSet != mSet.end()
+		//&&	itOther != other.end()	// assumed since mSet.size() == other.size()
+		&&	(*itSet) == (*itOther)
+		;	itSet++, itOther++
+		);
+
+		result = qboolean( itSet == mSet.end() );
+	}
+
+	return result;
+}
+
+#endif // _IMMERSION
\ No newline at end of file
diff --git a/code/ff/ff_MultiCompound.h b/code/ff/ff_MultiCompound.h
new file mode 100644
index 0000000..466794f
--- /dev/null
+++ b/code/ff/ff_MultiCompound.h
@@ -0,0 +1,54 @@
+#ifndef FF_MULTICOMPOUND_H
+#define FF_MULTICOMPOUND_H
+
+//#include "common_headers.h"
+#include "ff_MultiEffect.h"
+
+////-------------
+///	MultiCompound
+//-----------------
+//	MultiCompound is a container for MultiEffect pointers.
+//	It is not a single, complex effect and should not be treated as such.
+//
+class MultiCompound
+{
+public:
+	typedef set<MultiEffect*> Set;
+protected:
+	Set mSet;
+public:
+	MultiCompound()
+	:	mSet() 
+	{}
+
+	MultiCompound( Set &compound ) 
+	:	mSet()
+	{
+		Add( compound );
+	}
+
+	Set& GetSet() { return mSet; }
+	qboolean Add( MultiEffect *Compound );
+	qboolean Add( Set &compound );
+
+	// CImmEffect iterations
+	qboolean Start();
+	qboolean Stop();
+	qboolean ChangeDuration( DWORD Duration );
+	qboolean ChangeGain( DWORD Gain );
+
+	// Utilities
+	qboolean IsEmpty() { return qboolean( mSet.size() == 0 ); }
+	qboolean operator == ( MultiCompound &compound );
+	qboolean operator != ( MultiCompound &compound )
+	{
+		return qboolean( !( (*this) == compound ) );
+	}
+
+	// Other iterations
+	qboolean IsPlaying();
+	qboolean EnsurePlaying();
+
+};
+
+#endif // FF_MULTICOMPOUND_H
\ No newline at end of file
diff --git a/code/ff/ff_MultiEffect.cpp b/code/ff/ff_MultiEffect.cpp
new file mode 100644
index 0000000..5f9107d
--- /dev/null
+++ b/code/ff/ff_MultiEffect.cpp
@@ -0,0 +1,281 @@
+#include "common_headers.h"
+
+#ifdef _IMMERSION
+
+////--------------------------
+///	MultiEffect::GetStartDelay
+//------------------------------
+//	Determines the shortest start delay.
+//
+qboolean MultiEffect::GetStartDelay( DWORD &StartDelay )
+{
+	StartDelay = MAXDWORD;
+	qboolean result = qtrue;
+
+	int i,max;
+	for
+	(	i = 0, max = GetNumberOfContainedEffects()
+	;	i < max
+	;	i++
+	){
+		DWORD CurrentStartDelay;
+		CImmEffect* pIE = GetContainedEffect( i );
+		if ( pIE
+		&&	 pIE->GetStartDelay( CurrentStartDelay )
+		){
+			StartDelay = Min( StartDelay, CurrentStartDelay );
+		}
+		else
+		{
+			result = qfalse;
+		}
+	}
+
+	return qboolean
+	(	result 
+	&&	max > 0
+	);
+}
+
+////------------------------
+///	MultiEffect::GetDelayEnd
+//----------------------------
+//	Computes end of earliest start delay. Compare this value with ::GetTickCount()
+//	to determine if any component waveform started playing on the device.
+//
+qboolean MultiEffect::GetDelayEnd( DWORD &DelayEnd )
+{
+	DelayEnd = MAXDWORD;
+	qboolean result = qtrue;
+
+	int i,max;
+	for
+	(	i = 0, max = GetNumberOfContainedEffects()
+	;	i < max
+	;	i++
+	){
+		DWORD StartDelay;
+		CImmEffect* pIE = GetContainedEffect( i );
+		if ( pIE 
+		&&	 pIE->GetStartDelay( StartDelay )
+		){
+			DelayEnd = Min( DelayEnd, StartDelay + pIE->m_dwLastStarted );
+		}
+		else
+		{
+			result = qfalse;
+		}
+	}
+
+	return qboolean
+	(	result 
+	&&	max > 0
+	);
+}
+
+////---------------------------
+///	MultiEffect::ChangeDuration
+//-------------------------------
+//	Analogous to CImmEffect::ChangeDuration. Changes duration of all component effects.
+//	Returns false if any effect returns false. Attempts to change duration of all effects
+//	regardless of individual return values.
+//
+qboolean MultiEffect::ChangeDuration( DWORD Duration )
+{
+	DWORD CurrentDuration;
+	qboolean result = GetDuration( CurrentDuration );
+
+	if ( result )
+	{
+		DWORD RelativeDuration = Duration - CurrentDuration;
+
+		int i,max;
+		for
+		(	i = 0, max = GetNumberOfContainedEffects()
+		;	i < max
+		;	i++
+		){
+			IMM_ENVELOPE Envelope = {0};
+			CImmEffect* pIE = GetContainedEffect( i );
+			result &= qboolean
+			(	pIE
+			&&	pIE->GetDuration( CurrentDuration )
+			&&	pIE->ChangeDuration( CurrentDuration + RelativeDuration )
+			&&	(	!pIE->GetEnvelope( &Envelope )
+				||	(	Envelope.dwAttackTime = ( CurrentDuration ? (DWORD)((float)Envelope.dwAttackTime * (float)Duration / (float)CurrentDuration) : 0 )
+					,	Envelope.dwFadeTime = ( CurrentDuration ? (DWORD)((float)Envelope.dwFadeTime * (float)Duration / (float)CurrentDuration) : 0 )
+					,	pIE->ChangeEnvelope( &Envelope )
+					)
+				)
+			);
+		}
+
+		result &= qboolean( max > 0 );
+	}
+
+	return result;
+}
+
+////-----------------------
+///	MultiEffect::ChangeGain
+//---------------------------
+//	Analogous to CImmEffect::ChangeGain. Changes gain of all component effects.
+//	Returns false if any effect returns false. Attempts to change gain of all effects
+//	regardless of individual return values.
+//
+qboolean MultiEffect::ChangeGain( DWORD Gain )
+{
+	DWORD CurrentGain;
+	qboolean result = GetGain( CurrentGain );
+
+	if ( result )
+	{
+		DWORD RelativeGain = Gain - CurrentGain;
+
+		int i,max;
+		for
+		(	i = 0, max = GetNumberOfContainedEffects()
+		;	i < max
+		;	i++
+		){
+			CImmEffect* pIE = GetContainedEffect( i );
+			result &= qboolean
+			(	pIE
+			&&	pIE->GetGain( CurrentGain )
+			&&	pIE->ChangeGain( CurrentGain + RelativeGain )
+			);
+		}
+
+		result &= qboolean( max > 0 );
+	}
+
+	return result;
+}
+
+////----------------------
+///	MultiEffect::GetStatus
+//--------------------------
+//	Analogous to CImmEffect::GetStatus. ORs all status flags from all component effects.
+//	Returns false if any effect returns false. Attempts to get status of all effects
+//	regardless of individual return values.
+//
+qboolean MultiEffect::GetStatus( DWORD &Status )
+{
+	Status = 0;
+	qboolean result = qtrue;
+
+	int i,max;
+	for
+	(	i = 0, max = GetNumberOfContainedEffects()
+	;	i < max
+	;	i++
+	){
+		DWORD CurrentStatus;
+		CImmEffect* pIE = GetContainedEffect( i );
+		if ( pIE
+		&&	 pIE->GetStatus( &CurrentStatus )
+		){
+			Status |= CurrentStatus;
+		}
+		else
+		{
+			result = qfalse;
+		}
+	}
+
+	return qboolean
+	(	result
+	&&	max > 0
+	);
+}
+
+qboolean MultiEffect::ChangeStartDelay( DWORD StartDelay )
+{
+	DWORD CurrentStartDelay;
+	qboolean result = GetStartDelay( CurrentStartDelay );
+
+	if ( result )
+	{
+		DWORD RelativeStartDelay = StartDelay - CurrentStartDelay;
+		
+		int i,max;
+		for
+		(	i = 0, max = GetNumberOfContainedEffects()
+		;	i < max
+		;	i++
+		){
+			CImmEffect* pIE = GetContainedEffect( i );
+			result &= qboolean
+			(	pIE
+			&&	pIE->GetStartDelay( CurrentStartDelay )
+			&&	pIE->ChangeStartDelay( CurrentStartDelay + RelativeStartDelay )
+			);
+		}
+
+		result &= qboolean( max > 0 );
+	}
+
+	return result;
+}
+
+qboolean MultiEffect::GetDuration( DWORD &Duration )
+{
+	Duration = 0;
+	qboolean result = qtrue;
+
+	int i,max;
+	for
+	(	i = 0, max = GetNumberOfContainedEffects()
+	;	i < max
+	;	i++
+	){
+		DWORD CurrentDuration;
+		CImmEffect* pIE = GetContainedEffect( i );
+		if ( pIE
+		&&	 pIE->GetDuration( CurrentDuration )
+		){
+			Duration = Max( Duration, CurrentDuration );
+		}
+		else
+		{
+			result = qfalse;
+		}
+	}
+
+	return qboolean
+	(	result
+	&&	max > 0
+	);
+}
+
+qboolean MultiEffect::GetGain( DWORD &Gain )
+{
+	Gain = 0;
+	qboolean result = qtrue;
+
+	int i,max;
+	for
+	(	i = 0, max = GetNumberOfContainedEffects()
+	;	i < max
+	;	i++
+	){
+		DWORD CurrentGain;
+		CImmEffect* pIE = GetContainedEffect( i );
+		if ( pIE
+		&&	 pIE->GetGain( CurrentGain )
+		){
+			Gain = Max( Gain, CurrentGain );
+		}
+		else
+		{
+			result = qfalse;
+		}
+	}
+
+	return qboolean
+	(	result
+	&&	max > 0
+	);
+}
+
+#endif // _IMMERSION
\ No newline at end of file
diff --git a/code/ff/ff_MultiEffect.h b/code/ff/ff_MultiEffect.h
new file mode 100644
index 0000000..a7594e2
--- /dev/null
+++ b/code/ff/ff_MultiEffect.h
@@ -0,0 +1,59 @@
+#ifndef MULTIEFFECT_H
+#define MULTIEFFECT_H
+
+//#include "common_headers.h"
+//#include "ifc.h"
+
+////-----------
+///	MultiEffect
+//---------------
+//	CImmCompoundEffect makes no assumption that its contained effects form a more
+//	complex, single effect. MultiEffect makes this assumption and provides member
+//	functions available in CImmEffect to operate on this "complex" effect.
+//
+//	Do not instantiate. (Do not call constructor)
+//	Instead, cast existing CImmCompoundEffect* to MultiEffect*
+//	Utility functions are specific to the needs of this system.
+//
+class MultiEffect : public CImmCompoundEffect
+{
+public:
+	// dummy constructor
+	MultiEffect() : CImmCompoundEffect( NULL, 0, NULL ) {}	// Never call (cast instead)
+
+	// CImmEffect extensions
+	qboolean GetStatus( DWORD &Status );
+	qboolean GetStartDelay( DWORD &StartDelay );
+	qboolean GetDuration( DWORD &Duration );
+	qboolean GetGain( DWORD &Gain );
+	qboolean ChangeDuration( DWORD Duration );
+	qboolean ChangeGain( DWORD Gain );
+	qboolean ChangeStartDelay( DWORD StartDelay );
+
+	// utility functions
+	qboolean GetDelayEnd( DWORD &DelayEnd );
+	qboolean IsBeyondStartDelay()
+	{
+		DWORD DelayEnd;
+		return qboolean
+		(	GetDelayEnd( DelayEnd )
+		&&	DelayEnd < ::GetTickCount()		// Does not account for counter overflow.
+		);
+	}
+	qboolean IsPlaying()
+	{
+		DWORD Status; 
+		return qboolean( GetStatus( Status ) && (Status & IMM_STATUS_PLAYING) );
+	}
+
+	// CImmCompoundEffect overrides
+	qboolean Start( DWORD dwIterations = IMM_EFFECT_DONT_CHANGE, DWORD dwFlags = 0 )
+	{
+		return qboolean
+		(	IsBeyondStartDelay()
+		&&	CImmCompoundEffect::Start( dwIterations, dwFlags )
+		);
+	}
+};
+
+#endif // MULTIEFFECT_H
\ No newline at end of file
diff --git a/code/ff/ff_MultiSet.cpp b/code/ff/ff_MultiSet.cpp
new file mode 100644
index 0000000..5041147
--- /dev/null
+++ b/code/ff/ff_MultiSet.cpp
@@ -0,0 +1,140 @@
+#include "common_headers.h"
+
+#ifdef _IMMERSION
+
+#include "..\win32\win_local.h"
+
+////----------------
+/// FFMultiSet::Init
+//--------------------
+//	Initializes all attached force feedback devices. An empty FFSet is created
+//	for each device. Each device will have its own copy of whatever .ifr file
+//	set 'config' specifies.
+//
+//	Always pair with clear()
+//
+qboolean FFMultiSet::Init( FFSystem::Config &config )
+{
+	mConfig = &config;
+
+#ifdef FF_PRINT
+	//Com_Printf( "Feedback devices:\n" );
+#endif
+
+	HINSTANCE hInstance = (HINSTANCE)g_wv.hInstance;
+	HWND hWnd = (HWND)g_wv.hWnd;
+
+	mDevices = new CImmDevices;
+	if ( mDevices && mDevices->CreateDevices( hInstance, hWnd ) )
+	{
+		for
+		(	int i = 0
+		;	i < mDevices->GetNumDevices()
+		;	i++
+		){
+			FFSet *ffSet = NULL;
+			ffSet = new FFSet( config, mDevices->GetDevice( i ) ); 
+			if ( ffSet )
+			{
+#ifdef FF_PRINT
+				char ProductName[ FF_MAX_PATH ];
+				*ProductName = 0;
+				mDevices->GetDevice( i )->GetProductName( ProductName, FF_MAX_PATH - 1 );
+				Com_Printf( "%d) %s\n", i, ProductName );
+#endif
+				mSet.push_back( ffSet );
+			}
+		}
+	}
+
+	return qboolean( mSet.size() );
+}
+
+////------------------------------
+/// FFMultiSet::GetRegisteredNames
+//----------------------------------
+//
+//
+qboolean FFMultiSet::GetRegisteredNames( TNameTable &NameTable )
+{
+	for
+	(	int i = 0
+	;	i < mSet.size()
+	;	i++
+	){
+		mSet[ i ]->GetRegisteredNames( NameTable );
+	}
+
+	return qtrue;
+}
+
+////-------------------
+/// FFMultiSet::StopAll
+//-----------------------
+//	Stops all effects in every FFSet.
+//	Returns qfalse if any return false.
+//
+qboolean FFMultiSet::StopAll()
+{
+	qboolean result = qtrue;
+
+	for
+	(	int i = 0
+	;	i < mSet.size()
+	;	i++
+	){
+		result &= mSet[ i ]->StopAll();
+	}
+
+	return result;
+}
+
+////-----------------
+/// FFMultiSet::clear
+//---------------------
+//	Cleans up.
+//
+void FFMultiSet::clear()
+{
+	mConfig = NULL;
+	for
+	(	int i = 0
+	;	i < mSet.size()
+	;	i++
+	){
+		DeletePointer( mSet[ i ] );
+	}
+	mSet.clear();
+	DeletePointer( mDevices );
+}
+
+#ifdef FF_CONSOLECOMMAND
+
+void FFMultiSet::GetDisplayTokens( TNameTable &Tokens )
+{
+	FFSet::GetDisplayTokens( Tokens );
+}
+
+////-------------------
+///	FFMultiSet::Display
+//-----------------------
+//
+//
+void FFMultiSet::Display( TNameTable &Unprocessed, TNameTable &Processed )
+{
+	for
+	(	int i = 0
+	;	i < mSet.size()
+	;	i++
+	){
+		TNameTable Temp1, Temp2;
+		Temp1.clear();
+		Temp2.clear();
+		Temp1.insert( Temp1.begin(), Processed.begin(), Processed.end() );
+		mSet[ i ]->Display( Temp1, Temp2 );
+	}
+}
+
+#endif // FF_CONSOLECOMMAND
+
+#endif // _IMMERSION
\ No newline at end of file
diff --git a/code/ff/ff_MultiSet.h b/code/ff/ff_MultiSet.h
new file mode 100644
index 0000000..b42cd99
--- /dev/null
+++ b/code/ff/ff_MultiSet.h
@@ -0,0 +1,43 @@
+#ifndef FF_MULTISET_H
+#define FF_MULTISET_H
+
+#include "ff_ffset.h"
+
+//===[FFMultiSet]=====================================================/////////////
+//
+//	A collection class of FFSet objects. These functions generally
+//	iterate over the entire set of FFSets, performing the same operation
+//	on all contained FFSets.
+//
+//====================================================================/////////////
+
+class FFMultiSet
+{
+public:
+	typedef vector<FFSet*> Set;
+protected:
+	FFConfigParser *mConfig;
+	Set mSet;
+	CImmDevices *mDevices;
+public:
+	qboolean Init( FFConfigParser &config );
+//	qboolean Lookup( set<MultiEffect*> &effect, const char *name );
+	qboolean GetRegisteredNames( TNameTable &NameTable );
+	qboolean StopAll();
+	void clear();
+
+	//
+	//	Optional
+	//
+#ifdef FF_ACCESSOR
+	Set& GetSets() { return mSet; }
+	CImmDevices* GetDevices() { return mDevices; }
+#endif
+
+#ifdef FF_CONSOLECOMMAND
+	void Display( TNameTable &Unprocessed, TNameTable &Processed );
+	static void GetDisplayTokens( TNameTable &Tokens );
+#endif
+};
+
+#endif // FF_MULTISET_H
\ No newline at end of file
diff --git a/code/ff/ff_console.cpp b/code/ff/ff_console.cpp
new file mode 100644
index 0000000..fe413c1
--- /dev/null
+++ b/code/ff/ff_console.cpp
@@ -0,0 +1,248 @@
+/*
+ * Stubs to allow linking with FF_ fnuctions declared.
+ * Brian Osman
+ */
+
+//JLFRUMBLE includes modified to avoid typename collision field_t MPSKIPPED
+#ifdef _JK2MP
+#include "../namespace_begin.h"
+#endif
+#include "../game/q_shared.h"
+#include "../qcommon/qcommon.h"
+#include "../client/keycodes.h"
+//#include "../client/client.h"
+#include "../client/fffx.h"
+#include "../win32/win_input.h"
+#ifdef _JK2MP
+#include "../namespace_end.h"
+#endif
+
+void FF_StopAll(void)
+{
+	Com_Printf("FF_StopAll: Please implement.\n");
+	// Do nothing
+}
+
+void FF_Stop(ffFX_e effect)
+{
+	Com_Printf("FF_Stop: Please implement fffx_id = %i\n",effect);
+	// Do nothing
+}
+
+void FF_EnsurePlaying(ffFX_e effect)
+{
+	Com_Printf("FF_EnsurePlaying: Please implement fffx_id = %i\n",effect);
+	// Do nothing
+}
+
+void FF_Play(ffFX_e effect)
+{
+	int s;	// script id
+	static int const_rumble[2] = {-1}; // script id for constant rumble
+	int client;
+
+	// super huge switch for rumble effects
+	switch(effect)
+	{
+	case fffx_AircraftCarrierTakeOff:
+	case fffx_BasketballDribble:
+	case fffx_CarEngineIdle:
+	case fffx_ChainsawIdle:
+	case fffx_ChainsawInAction:
+	case fffx_DieselEngineIdle:
+	case fffx_Jump:
+		s = IN_CreateRumbleScript(IN_GetMainController(), 2, true);
+		if (s != -1)
+		{
+			IN_AddRumbleState(s, 50000, 10000, 200);
+			IN_AddRumbleState(s, 0, 0, 10);
+			IN_ExecuteRumbleScript(s);
+		}
+		break;
+	case fffx_Land:
+		s = IN_CreateRumbleScript(IN_GetMainController(), 2, true);
+		if (s != -1)
+		{
+			IN_AddRumbleState(s, 50000, 10000, 200);
+			IN_AddRumbleState(s, 0, 0, 10);
+			IN_ExecuteRumbleScript(s);
+		}
+		break;
+	case fffx_MachineGun:
+		s = IN_CreateRumbleScript(IN_GetMainController(), 2, true);
+		if (s != -1)
+		{
+			IN_AddRumbleState(s, 56000, 20000, 230);
+			IN_AddRumbleState(s, 0, 0, 10);
+			IN_ExecuteRumbleScript(s);
+		}
+		break;
+	case fffx_Punched:
+	case fffx_RocketLaunch:
+
+	case fffx_SecretDoor:
+	case fffx_SwitchClick:	// used by saber
+		s = IN_CreateRumbleScript(IN_GetMainController(), 1, true);
+		if (s != -1)
+		{
+			IN_AddRumbleState(s, 30000, 10000, 120);
+			IN_ExecuteRumbleScript(s);
+		}
+		break;
+	case fffx_WindGust:
+	case fffx_WindShear:
+	case fffx_Pistol:
+		s = IN_CreateRumbleScript(IN_GetMainController(), 2, true);
+		if (s != -1)
+		{
+			IN_AddRumbleState(s, 50000, 10000, 200);
+			IN_AddRumbleState(s, 0, 0, 10);
+			IN_ExecuteRumbleScript(s);
+		}
+		break;
+	case fffx_Shotgun:
+	case fffx_Laser1:
+	case fffx_Laser2:
+	case fffx_Laser3:
+	case fffx_Laser4:
+	case fffx_Laser5:
+	case fffx_Laser6:
+	case fffx_OutOfAmmo:
+	case fffx_LightningGun:
+	case fffx_Missile:
+	case fffx_GatlingGun:
+		s = IN_CreateRumbleScript(IN_GetMainController(), 2, true);
+		if (s != -1)
+		{
+			IN_AddRumbleState(s, 39000, 0, 220);
+			IN_AddRumbleState(s, 0, 0, 10);
+			IN_ExecuteRumbleScript(s);
+		}
+		break;
+	case fffx_ShortPlasma:
+	case fffx_PlasmaCannon1:
+	case fffx_PlasmaCannon2:
+	case fffx_Cannon:
+	case fffx_FallingShort:
+	case fffx_FallingMedium:
+		s = IN_CreateRumbleScript(IN_GetMainController(), 1, true);
+		if (s != -1)
+		{
+			IN_AddRumbleState(s, 25000,10000, 230);
+			IN_ExecuteRumbleScript(s);
+		}
+		break;
+	case fffx_FallingFar:
+		s = IN_CreateRumbleScript(IN_GetMainController(), 1, true);
+		if (s != -1)
+		{
+			IN_AddRumbleState(s, 32000,10000, 230);
+			IN_ExecuteRumbleScript(s);
+		}
+		break;
+	case fffx_StartConst:
+		client = IN_GetMainController();
+		if(const_rumble[client] == -1)
+		{
+			const_rumble[client] = IN_CreateRumbleScript(IN_GetMainController(), 9, true);
+			if (const_rumble[client] != -1)
+			{
+				IN_AddEffectFade4(const_rumble[client], 0,0, 50000, 0, 2000);
+				IN_AddRumbleState(const_rumble[client], 50000, 0, 300);
+				IN_AddEffectFade4(const_rumble[client], 50000,50000, 0, 0, 1000);
+				IN_ExecuteRumbleScript(const_rumble[client]);
+			}
+		}
+		break;
+	case fffx_StopConst:
+		client = IN_GetMainController();
+		if (const_rumble[client] == -1)
+			return;
+		IN_KillRumbleScript(const_rumble[client]);
+		const_rumble[client] = -1;
+		break;
+	default:
+		Com_Printf("No rumble script is defined for fffx_id = %i\n",effect);
+		break;
+	}
+}
+
+/*********
+FF_XboxShake
+
+intensity	- speed of rumble
+duration	- length of rumble
+*********/
+#define	FF_SH_MIN_MOTOR_SPEED		20000
+#define	FF_SH_MOTOR_SPEED_MODIFIER	(65535 - FF_SH_MIN_MOTOR_SPEED)
+void FF_XboxShake(float intensity, int duration)
+{
+	int s;
+	s = IN_CreateRumbleScript(IN_GetMainController(), 1, true);
+	if (s != -1)
+	{
+		int speed;
+		// figure out the speed
+		speed = (FF_SH_MIN_MOTOR_SPEED) + (FF_SH_MOTOR_SPEED_MODIFIER * intensity);
+		
+		// Add the state and execute
+		IN_AddRumbleState(s, speed, speed, duration);
+		IN_ExecuteRumbleScript(s);
+	}
+}
+
+/*********
+FF_XboxDamage
+
+damage	- Amount of damage
+xpos	- x position for the damage ( -1.0 - 1.0 )
+
+The following function various the rumble based upon
+the amount of damage and the position of the damage.
+*********/
+#define FF_DA_MIN_MOTOR_SPEED		20000	// use this to vary the minimum intensity
+#define FF_DA_MOTOR_SPEED_MODIFIER	(65535 - FF_DA_MIN_MOTOR_SPEED)
+void FF_XboxDamage(int damage, float xpos)
+{
+	int s;
+	s = IN_CreateRumbleScript(IN_GetMainController(), 1, true);
+	if (s != -1)
+	{
+		int leftMotorSpeed;
+		int rightMotorSpeed;
+		int duration;
+		float per;
+
+		duration = 175;
+
+		// how much damage?
+		if(damage > 100)
+		{
+			per = 1.0;
+		}
+		else
+		{
+			per = damage/100;
+		}
+		
+		if(xpos >= -0.2 && xpos <= 0.2)	// damge to center
+		{
+			leftMotorSpeed = rightMotorSpeed = (FF_DA_MIN_MOTOR_SPEED)+(FF_DA_MOTOR_SPEED_MODIFIER * per);
+		}
+		else if(xpos > 0.2)	// damage to right
+		{
+			rightMotorSpeed = (FF_DA_MIN_MOTOR_SPEED)+(FF_DA_MOTOR_SPEED_MODIFIER * per);
+			leftMotorSpeed = 0;
+		}
+		else	// damage to left
+		{
+			leftMotorSpeed = (FF_DA_MIN_MOTOR_SPEED)+(FF_DA_MOTOR_SPEED_MODIFIER * per);;
+			rightMotorSpeed = 0;
+		}
+		
+		// Add the state and execute
+		IN_AddRumbleState(s, leftMotorSpeed, rightMotorSpeed, duration);
+		IN_ExecuteRumbleScript(s);
+	}
+}
+
diff --git a/code/ff/ff_ffset.cpp b/code/ff/ff_ffset.cpp
new file mode 100644
index 0000000..8b5065b
--- /dev/null
+++ b/code/ff/ff_ffset.cpp
@@ -0,0 +1,356 @@
+#include "common_headers.h"
+
+#ifdef _IMMERSION
+
+//#include "ff.h"
+//#include "ff_ffset.h"
+//#include "ff_compound.h"
+//#include "ff_system.h"
+
+extern cvar_t *ff_developer;
+#ifdef FF_DELAY
+extern cvar_t *ff_delay;
+#endif
+
+extern FFSystem gFFSystem;
+
+FFSet::FFSet( FFConfigParser &ConfigParser, CImmDevice *Device )
+:	mParser( ConfigParser )
+,	mDevice( Device )
+,	mInclude()
+,	mIncludePath()
+{
+	const char *setname = mParser.GetFFSet( mDevice );
+	if ( setname )
+	{
+		TProject temp;
+		mInclude.push_back( temp );
+		mIncludePath.push_back( setname );
+		InitIncludes( setname );
+	}
+}
+
+FFSet::~FFSet()
+{
+	for
+	(	TInclude::iterator itInclude = mInclude.begin()
+	;	itInclude != mInclude.end()
+	;	itInclude++
+	){
+		for
+		(	TProject::iterator itProject = (*itInclude).begin()
+		;	itProject != (*itInclude).end()
+		;	itProject++
+		){
+			DeletePointer( (*itProject).second );
+		}
+	}
+}
+
+void FFSet::InitIncludes( const char *setname )
+{
+	FFConfigParser::TInclude &include = mParser.GetIncludes( setname );
+
+	for	// each include listed in config file
+	(	int i = 0
+	;	i < include.size()
+	;	i++
+	){
+		for	// each include entered into current list
+		(	unsigned int j = 0
+		;	j < mIncludePath.size()
+		;	j++
+		){
+			if ( include[ i ] == mIncludePath[ j ] ) // exists in current list
+				break;
+		}
+
+		if ( j == mIncludePath.size() ) // does not exist in current list
+		{
+			TProject temp;
+			mInclude.push_back( temp );
+			mIncludePath.push_back( include[ i ] );
+			InitIncludes( include[ i ].c_str() ); // recurse
+		}
+	}
+}
+
+MultiEffect* FFSet::Register( const char *path, qboolean create )
+{
+	char outpath[ FF_MAX_PATH ];
+	MultiEffect* effect = NULL;
+
+	if ( FS_VerifyName( "FFSet::Register", path, outpath ) )
+	{
+		for	// each included set
+		(	int i = 0
+		;	i < mInclude.size() && !effect
+		;	i++
+		){
+			char setpath[ FF_MAX_PATH ], *afterincludepath;
+			// need to use explicit path if provided.
+			sprintf( setpath, "%s/%s", mIncludePath[ i ].c_str(), UncommonDirectory( path, mIncludePath[ i ].c_str() ) );
+			afterincludepath = setpath + mIncludePath[ i ].length() + 1;
+
+			for	// each possible file/effectname combination
+			(	int separator = _rcpos( afterincludepath, '/' )
+			;	separator >= 0 && !effect
+			;	separator = _rcpos( afterincludepath, '/', separator )
+			){
+				CImmProject *immProject;
+				char temp[4];
+
+				temp[0] = 0;
+				afterincludepath[separator] = 0;
+				if ( stricmp( afterincludepath + separator - 4, ".ifr" ) )
+				{
+					memcpy( temp, afterincludepath + separator + 1, 4 );
+					sprintf( afterincludepath + separator, ".ifr" );
+				}
+				
+				immProject = NULL;
+
+				TProject::iterator itProject = mInclude[ i ].find( afterincludepath );
+				if ( itProject != mInclude[ i ].end() )
+				{
+					immProject = (*itProject).second;
+				}
+				else if ( create )
+				{
+					void *buffer = LoadFile( setpath );
+					if ( buffer )
+					{
+						immProject = new CImmProject;
+
+						if ( immProject )
+						{
+							if ( !immProject->LoadProjectFromMemory( buffer, mDevice ) )
+							{
+								DeletePointer( immProject );
+#ifdef FF_PRINT
+								if ( ff_developer->integer ) 
+									Com_Printf( "...Corrupt or invalid file: %s\n", setpath );
+							}
+							else
+							{
+								if ( ff_developer->integer )
+									Com_Printf( "...Adding file \"%s\"\n", setpath );
+#endif FF_PRINT
+							}
+						}
+
+						FS_FreeFile( buffer );
+					}
+
+					mInclude[ i ][ afterincludepath ] = immProject;
+				}
+
+				if ( temp[ 0 ] )
+				{
+					afterincludepath[ separator ] = '/';
+					memcpy( afterincludepath + separator + 1, temp, 4 );
+				}
+
+				if ( immProject )
+				{
+					effect = (MultiEffect*)immProject->GetCreatedEffect( afterincludepath + separator + 1 );
+					if ( !effect && create )
+					{
+						effect = (MultiEffect*)immProject->CreateEffect( afterincludepath + separator + 1, mDevice, IMM_PARAM_NODOWNLOAD );
+#ifdef FF_DELAY
+						// Delay the effect (better sound synchronization)
+						if ( effect
+						&&	 ff_delay
+						//&&	 *ff_delay
+						){
+							effect->ChangeStartDelay( ff_delay->integer );
+						}
+#endif // FF_DELAY
+					}
+				}
+			}
+		}
+	}
+
+	return effect;
+}
+
+qboolean FFSet::StopAll( void )
+{
+	for
+	(	TInclude::iterator itInclude = mInclude.begin()
+	;	itInclude != mInclude.end()
+	;	itInclude++
+	){
+		for
+		(	TProject::iterator itProject = (*itInclude).begin()
+		;	itProject != (*itInclude).end()
+		;	itProject++
+		){
+			if ( (*itProject).second )
+				(*itProject).second->Stop();
+		}
+	}
+
+	return qtrue;
+}
+
+void FFSet::GetRegisteredNames( TNameTable &NameTable )
+{
+	FFSystem::Handle ffHandle = gFFSystem.GetHandles();
+
+	for
+	(	int IncludeIndex = 0
+	;	IncludeIndex < mInclude.size()
+	;	IncludeIndex++
+	){
+		for
+		(	TProject::iterator itProject = mInclude[ IncludeIndex ].begin()
+		;	itProject != mInclude[ IncludeIndex ].end()
+		;	itProject++
+		){
+			char effectname[ FF_MAX_PATH ];
+			int i;
+
+			if ( !(*itProject).second )
+				continue;
+			
+			i = 0;
+			
+			for
+			(	MultiEffect *Effect = (MultiEffect*)(*itProject).second->GetCreatedEffect( i )
+			;	Effect
+			;	Effect = (MultiEffect*)(*itProject).second->GetCreatedEffect( ++i )
+			){
+				sprintf( effectname, "%s/%s/%s", mIncludePath[ IncludeIndex ].c_str(), (*itProject).first.c_str(), Effect->GetName() );
+
+				for
+				(	int i = 0
+				;	i < ffHandle.size()
+				;	i++
+				){
+					ChannelCompound::Set &compound = ffHandle[ i ].GetSet();
+					if
+					(	NameTable[ i ].length() == 0
+					&&	compound.find( Effect ) != compound.end()
+					){
+						NameTable[ i ] = effectname;
+					}
+				}
+			}
+		}
+	}
+}
+
+////////////////////////////////////////////////
+
+#ifdef FF_CONSOLECOMMAND
+
+void FFSet::GetDisplayTokens( TNameTable &Tokens )
+{
+	if ( ff_developer->integer )
+	{
+		Tokens.push_back( "order" );
+		Tokens.push_back( "files" );
+	}
+}
+
+
+void FFSet::Display( TNameTable &Unprocessed, TNameTable &Processed )
+{
+	for
+	(	TNameTable::iterator itName = Unprocessed.begin()
+	;	itName != Unprocessed.end()
+	;
+	){
+		if ( stricmp( "order", (*itName).c_str() ) == 0 )
+		{
+			if ( ff_developer->integer )
+				DisplaySearchOrder();
+			//else
+			//	Com_Printf( "\"order\" only available when ff_developer is set\n" );
+
+			Processed.push_back( *itName );
+			itName = Unprocessed.erase( itName );
+		}
+		else
+		if ( stricmp( "files", (*itName).c_str() ) == 0 )
+		{
+			if ( ff_developer->integer )
+				DisplayLoadedFiles();
+			//else
+			//	Com_Printf( "\"files\" only available when ff_developer is set\n" );
+
+			Processed.push_back( *itName );
+			itName = Unprocessed.erase( itName );
+		}
+		else
+		{
+			itName++;
+		}
+	}
+
+}
+
+void FFSet::DisplaySearchOrder( void )
+{
+	char ProductName[ FF_MAX_PATH ];
+	*ProductName = 0;
+	mDevice->GetProductName( ProductName, FF_MAX_PATH - 1 );
+	Com_Printf( "[search order] -\"%s\"\n", ProductName );
+
+	for
+	(	int i = 0
+	;	i < mInclude.size()
+	;	i++
+	){
+		Com_Printf( "%d) %s\n", i, mIncludePath[ i ].c_str() );
+	}
+}
+
+void FFSet::DisplayLoadedFiles( void )
+{
+	int	total = 0;
+#ifdef _DEBUG
+	int nulltotal = 0;		// Variable to indicate how bad my algorithm is
+#endif
+
+	char ProductName[ FF_MAX_PATH ];
+	*ProductName = 0;
+	mDevice->GetProductName( ProductName, FF_MAX_PATH - 1 );
+	Com_Printf( "[loaded files] -\"%s\"\n", ProductName );
+
+	for
+	(	int i = 0
+	;	i < mInclude.size()
+	;	i++
+	){
+		for
+		(	TProject::iterator itProject = mInclude[ i ].begin()
+		;	itProject != mInclude[ i ].end()
+		;	itProject++
+		){
+			if ( (*itProject).second )
+			{
+				++total;
+				Com_Printf( "%s/%s\n", mIncludePath[ i ].c_str(), (*itProject).first.c_str() );
+			}
+#ifdef _DEBUG
+			else
+			{
+				++nulltotal;
+				Com_Printf( "%s/%s [null]\n", mIncludePath[ i ].c_str(), (*itProject).first.c_str() );
+			}
+#endif
+		}
+	}
+
+	Com_Printf( "Total: %d files\n", total );
+#ifdef _DEBUG
+	Com_Printf( "Total: %d null files\n", nulltotal );
+#endif
+}
+
+#endif // FF_CONSOLECOMMAND
+
+#endif // _IMMERSION
\ No newline at end of file
diff --git a/code/ff/ff_ffset.h b/code/ff/ff_ffset.h
new file mode 100644
index 0000000..1b34aab
--- /dev/null
+++ b/code/ff/ff_ffset.h
@@ -0,0 +1,64 @@
+#ifndef FFSET_H
+#define FFSET_H
+
+//#include "ff_ConfigParser.h"
+//#include "ff_utils.h"
+//#include "ff_compound.h"
+//class MultiEffect;
+//#include "ifc.h"
+//class CImmDevice;
+//class CImmProject;
+
+#include "ff_MultiEffect.h"
+
+class FFSet
+{
+	//
+	//	Types
+	//
+public:
+	typedef map<string, CImmProject*> TProject;
+	typedef vector<TProject> TInclude;
+	typedef vector<string> TIncludePath;
+
+	//
+	//	Variables
+	//
+protected:
+	TInclude mInclude;
+	TIncludePath mIncludePath;
+	CImmDevice *mDevice;
+	FFConfigParser &mParser;
+
+	//
+	//	Functions
+	//
+public:
+	FFSet( FFConfigParser &ConfigParser, CImmDevice *Device );
+	~FFSet();
+	MultiEffect* Register( const char *path, qboolean create = qtrue );
+	void GetRegisteredNames( TNameTable &NameTable );
+	qboolean StopAll( void );
+
+protected:
+	void InitIncludes( const char *setname = NULL );
+
+	//
+	//	Optional
+	//
+#ifdef FF_ACCESSOR
+public:
+	CImmDevice* GetDevice( void ) { return mDevice; }
+#endif
+
+#ifdef FF_CONSOLECOMMAND
+public:
+	void Display( TNameTable &Unprocessed, TNameTable &Processed );
+	void DisplaySearchOrder( void );
+	void DisplayLoadedFiles( void );
+	static void GetDisplayTokens( TNameTable &Tokens );
+#endif
+
+};
+
+#endif // FFSET_H
\ No newline at end of file
diff --git a/code/ff/ff_local.h b/code/ff/ff_local.h
new file mode 100644
index 0000000..7488e69
--- /dev/null
+++ b/code/ff/ff_local.h
@@ -0,0 +1,24 @@
+#ifndef FF_LOCAL_H
+#define FF_LOCAL_H
+
+#define FF_ACCESSOR
+#define FF_API_VERSION		1
+
+// Better sound synchronization
+// This is default value for cvar ff_delay. User may tweak this.
+#define FF_DELAY			"40"
+// Default: all channels output to primary device
+#define FF_CHANNEL "0,0;1,0;2,0;3,0;4,0;5,0"
+// Optional system features
+#define FF_PRINT
+#ifdef FF_PRINT
+#define FF_CONSOLECOMMAND
+#endif
+// (end) Optional system features
+
+#include "..\game\q_shared.h"	// includes ff_public.h
+#include "..\qcommon\qcommon.h"
+
+#define FF_MAX_PATH		MAX_QPATH
+
+#endif // FF_LOCAL_H
\ No newline at end of file
diff --git a/code/ff/ff_public.h b/code/ff/ff_public.h
new file mode 100644
index 0000000..96e2a1e
--- /dev/null
+++ b/code/ff/ff_public.h
@@ -0,0 +1,43 @@
+#ifndef __FF_PUBLIC_H
+#define __FF_PUBLIC_H
+
+#define FF_HANDLE_NULL		0
+#define FF_CLIENT_LOCAL		(-2)
+#define FF_CLIENT( client ) (FF_CLIENT_LOCAL - client)
+
+typedef int	ffHandle_t;
+
+/*
+enum FFChannel_e
+{	FF_CHANNEL_WEAPON
+,	FF_CHANNEL_MENU
+,	FF_CHANNEL_TOUCH
+,	FF_CHANNEL_DAMAGE
+,	FF_CHANNEL_VEHICLE
+,	FF_CHANNEL_MAX
+};
+*/
+#define FF_CHANNEL_WEAPON	0
+#define FF_CHANNEL_MENU		1
+#define FF_CHANNEL_TOUCH	2
+#define FF_CHANNEL_DAMAGE	3
+#define FF_CHANNEL_BODY		4
+#define FF_CHANNEL_FORCE	5
+#define FF_CHANNEL_FOOT		6
+#define FF_CHANNEL_MAX		7
+
+#ifdef _FF
+
+/*
+inline qboolean operator &= ( qboolean &lvalue, qboolean rvalue )
+{
+	lvalue = qboolean( (int)lvalue && (int)rvalue );
+	return lvalue;
+}
+*/
+
+#include "../ff/ff.h"		// basic system functions
+#include "../ff/ff_snd.h"	// sound system similarities
+#endif // _FF
+
+#endif // __FF_PUBLIC_H
\ No newline at end of file
diff --git a/code/ff/ff_snd.cpp b/code/ff/ff_snd.cpp
new file mode 100644
index 0000000..87f7112
--- /dev/null
+++ b/code/ff/ff_snd.cpp
@@ -0,0 +1,503 @@
+#include "common_headers.h"
+
+#ifdef _IMMERSION
+
+#include "ff_snd.h"
+#include "ff.h"
+
+extern FFSystem gFFSystem;
+
+#define FF_GAIN_STEP 500
+
+//
+//	Internal data structures
+//
+//	This whole system should mirror snd_dma.cpp to some degree.
+//	Right now, not much works.
+
+/*
+template<typename T>
+static T RelativeDistance( T Volume, T Min, T Max )
+{
+	if ( Min == Max )
+		if ( Volume < Min )
+			return 0.f;
+		else
+			return 1.f;
+
+	return (Volume - Min) / (Max - Min);
+};
+
+template<typename T>
+int Round( T value, int mod )
+{
+	int intval = (int)value;
+	int intmod = intval % mod;
+	int roundup = intmod >= mod / 2;
+
+	return
+	(	intval
+	?	roundup
+	?	intval + mod - intmod
+	:	intval - intmod
+	:	roundup
+	?	mod
+	:	0
+	);
+}
+*/
+
+class SndForce
+{
+public:
+	ffHandle_t mHandle;
+	int mRefs;
+	qboolean mPlaying;
+//	int mEntNum;
+//	vec3_t mOrigin;
+//	struct SDistanceLimits
+//	{	int	min;
+//		int max;
+//	}	mDistance;
+
+public:
+	void zero()
+	{
+		mHandle = FF_HANDLE_NULL;
+		mRefs = 0;
+		mPlaying = qfalse;
+//		mEntNum = 0;
+//		mDistance.min = 0;
+//		mDistance.max = 0;
+//		mOrigin[0] = 1.f;
+//		mOrigin[1] = 0.f;
+//		mOrigin[2] = 0.f;
+	}
+	SndForce()
+	{
+		zero();
+	}
+	SndForce( const SndForce &other )
+	{
+		memcpy( this, &other, sizeof(SndForce) );
+	}
+	SndForce( ffHandle_t handle/*, int entNum, const vec3_t origin, float maxDistance, float minDistance*/ )
+	:	mHandle( handle )
+	,	mRefs( 0 )
+	,	mPlaying( qfalse )
+//	,	mEntNum( entNum )
+	{
+//		mDistance.min = minDistance;
+//		mDistance.max = maxDistance;
+//		memcpy( mOrigin, origin, sizeof(mOrigin) );
+	}
+	void AddRef() 
+	{
+		++mRefs;
+	}
+	void SubRef()
+	{
+		--mRefs;
+	}
+	qboolean Update( void ) const
+	{
+		return qboolean
+		(	mRefs != 0
+		&&	(ChannelCompound*)mHandle
+		);
+	}
+/*	int GetGain()
+	{
+		float distance = 1.f - GetRelativeDistance();
+
+		return distance == 0.f
+		?	10000
+		:	Clamp<int>
+			(	Round<int>
+				(	distance * 10000
+				,	FF_GAIN_STEP
+				)
+			,	0
+			,	10000
+			)
+		;
+	}
+	float GetRelativeDistance()
+	{
+		return !mRefs
+		?	1.f
+		:	IsOrigin()
+		?	0.f
+		:	RelativeDistance<float>
+			(	sqrt
+				(	mOrigin[0] * mOrigin[0]
+				+	mOrigin[1] * mOrigin[1]
+				+	mOrigin[2] * mOrigin[2]
+				)
+			,	mDistance.min
+			,	mDistance.max
+			) / mRefs
+		;
+	}
+	qboolean IsOrigin()
+	{
+		return qboolean
+		(	!mOrigin[0]
+		&&	!mOrigin[1]
+		&&	!mOrigin[2]
+		);
+	}
+	void Respatialize( int entNum, const vec3_t origin )
+	{
+		extern vec3_t s_entityPosition[];
+
+		if ( mEntNum != entNum )
+		{
+			// Assumes all forces follow its entity and is centered on entity
+			mOrigin[0] = s_entityPosition[ entNum ][0] - origin[0];
+			mOrigin[1] = s_entityPosition[ entNum ][1] - origin[1];
+			mOrigin[2] = s_entityPosition[ entNum ][2] - origin[2];
+		}
+		else
+		{
+			memset( mOrigin, 0, sizeof(mOrigin) );
+		}
+	}*/
+	void operator += ( SndForce &other );
+};
+
+// Fancy comparator
+struct SndForceLess : public less<SndForce>
+{
+	bool operator() ( const SndForce &x, const SndForce &y )
+	{
+		return bool
+		(/* x.mEntNum < y.mEntNum
+		||*/x.mHandle < y.mHandle
+//		||	x.mOrigin < y.mOrigin		// uhhh... compare components
+		||	x.mPlaying < y.mPlaying
+		);
+	}
+};
+
+
+class LoopForce : public SndForce
+{
+public:
+	LoopForce(){}
+	LoopForce( const LoopForce &other )
+	{
+		memcpy( this, &other, sizeof(LoopForce) );
+	}
+	LoopForce( ffHandle_t handle/*int entNum, , const vec3_t origin, float maxDistance, float minDistance*/ )
+	:	SndForce( handle/*, entNum, origin, maxDistance, minDistance*/ )
+	{}
+
+	void Add( ffHandle_t ff/*, int entNum, const vec3_t origin*/ );
+//	void Respatialize( int entNum, const vec3_t origin );
+	qboolean Update( void )
+	{
+		qboolean result = SndForce::Update();
+		mRefs = 0;
+		return result;
+	}
+};
+
+class SndForceSet
+{
+public:
+	typedef set<SndForce, SndForceLess> PendingSet;
+	typedef map<ffHandle_t, SndForce> ActiveSet;
+	ActiveSet mActive;
+	PendingSet mPending;
+public:
+	void Add( ffHandle_t handle/*, int entNum, const vec3_t origin, float maxDistance, float minDistance*/ )
+	{
+		const_cast <SndForce&> (*mPending.insert( SndForce( handle/*, entNum, origin, maxDistance, minDistance*/ ) ).first).AddRef();
+	}
+	qboolean Update( void );
+/*	void Respatialize( int entNum, const vec3_t origin )
+	{
+		for
+		(	PendingSet::iterator itPending = mPending.begin()
+		;	itPending != mPending.end()
+		;	itPending++
+		){
+			(*itPending).Respatialize( entNum, origin );
+		}
+	}*/
+};
+
+class LoopForceSet 
+{
+public:
+	typedef set<LoopForce, SndForceLess> PendingSet;
+	typedef map<ffHandle_t, LoopForce> ActiveSet;
+	ActiveSet mActive;
+	PendingSet mPending;
+public:
+	void Add( ffHandle_t handle/*, int entNum, const vec3_t origin, float maxDistance, float minDistance*/ )
+	{
+		const_cast <LoopForce&>(*mPending.insert( LoopForce( handle/*, entNum, origin, maxDistance, minDistance*/ ) ).first).AddRef();
+	}
+	qboolean Update( void );
+/*	void Respatialize( int entNum, const vec3_t origin )
+	{
+		for
+		(	PendingSet::iterator itPending = mPending.begin()
+		;	itPending != mPending.end()
+		;	itPending++
+		){
+			(*itPending).Respatialize( entNum, origin );
+		}
+	}*/
+};
+
+class MasterForceSet
+{
+protected:
+	int mEntityNum;
+//	vec3_t mOrigin;
+	SndForceSet mSnd;
+	LoopForceSet mLoop;
+
+public:
+	void Add( ffHandle_t handle/*, int entNum, const vec3_t origin, float maxDistance, float minDistance*/ )
+	{
+		mSnd.Add( handle/*, entNum, origin, maxDistance, minDistance*/ );
+	}
+	void AddLoop( ffHandle_t handle/*, int entNum, const vec3_t origin, float maxDistance, float minDistance*/ )
+	{
+		mLoop.Add( handle/*, entNum, origin, maxDistance, minDistance*/ );
+	}
+/*	void Respatialize( int entNum, const vec3_t origin )
+	{
+		memcpy( mOrigin, origin, sizeof(mOrigin) );
+		mEntityNum = entNum;
+		mSnd.Respatialize( entNum, origin );
+		mLoop.Respatialize( entNum, origin );
+	}
+*/	void Update( void );
+};
+
+// 
+//	===================================================================================
+//
+
+static MasterForceSet _MasterForceSet;
+
+void FF_AddForce( ffHandle_t ff/*, int entNum, const vec3_t origin, float maxDistance, float minDistance*/ )
+{
+	_MasterForceSet.Add( ff/*, entNum, origin, maxDistance, minDistance*/ );
+}
+
+void FF_AddLoopingForce( ffHandle_t ff/*, int entNum, const vec3_t origin, float maxDistance, float minDistance*/ )
+{
+	_MasterForceSet.AddLoop( ff/*, entNum, origin, maxDistance, minDistance*/ );
+}
+/*
+void FF_Respatialize( int entNum, const vec3_t origin )
+{
+	_MasterForceSet.Respatialize( entNum, origin );
+}
+*/
+void FF_Update( void )
+{
+	_MasterForceSet.Update();
+}
+
+//
+//	===================================================================================
+//
+
+void MasterForceSet::Update()
+{
+	mSnd.Update();
+	mLoop.Update();
+}
+
+////-----------------
+/// LoopForce::Update
+//---------------------
+//	Starts/Stops/Updates looping forces.
+//	Call once per frame after all looping forces have been added and respatialized.
+//
+qboolean LoopForceSet::Update()
+{
+	ActiveSet::iterator itActive;
+	PendingSet::iterator itPending;
+
+	// Sum effects
+	ActiveSet active;
+	for
+	(	itPending = mPending.begin()
+	;	itPending != mPending.end()
+	;	itPending++
+	){
+		if ( (const_cast <LoopForce&> (*itPending)).Update() )
+		{
+			active[ (*itPending).mHandle ] += const_cast <LoopForce&> (*itPending) ;
+		}
+	}
+
+	// Stop and remove unreferenced effects 
+	for
+	(	itActive = mActive.begin()
+	;	itActive != mActive.end()
+	;	//itActive++
+	){
+		if ( active.find( (*itActive).first ) != active.end() )
+		{
+			itActive++;
+		}
+		else
+		{
+			SndForce &sndForce = (*itActive).second;
+			FF_Stop( sndForce.mHandle );
+			itActive = mActive.erase( itActive );
+		}
+	}
+
+	// Decide whether to start or update
+	for
+	(	itActive = active.begin()
+	;	itActive != active.end()
+	;	itActive++
+	){
+		SndForce &sndForce = mActive[ (*itActive).first ];
+		sndForce.mHandle = (*itActive).first;
+		if ( sndForce.mPlaying )
+		{
+			// Just update it
+
+//			if ( (*itActive).second.GetGain() != sndForce.GetGain() )
+//			{
+//				gFFSystem.ChangeGain( sndForce.mHandle, sndForce.GetGain() );
+//			}
+		}
+		else
+		{
+			// Update and start it
+
+//			gFFSystem.ChangeGain( sndForce.mHandle, sndForce.GetGain() );
+			FF_Play( sndForce.mHandle );
+			sndForce.mPlaying = qtrue;
+		}
+	}
+
+	mPending.clear();
+
+	return qtrue;
+}
+
+////-------------------
+/// SndForceSet::Update
+//-----------------------
+//
+//
+qboolean SndForceSet::Update()
+{
+	ActiveSet::iterator itActive;
+	PendingSet::iterator itPending;
+/*
+	// Remove finished effects from active //and pending sets
+	for
+	(	itActive = mActive.begin()
+	;	itActive != mActive.end()
+	;	//itActive++
+	){
+		if ( gFFSystem.IsPlaying( (*itActive).first ) )
+		{
+			++itActive;
+		}
+		else
+		{
+#if( 0 )
+			for
+			(	itPending = mPending.begin()
+			;	itPending != mPending.end()
+			;	itPending++
+			){
+				if 
+				(	(*itPending).mHandle == (*itActive).first
+				&&	(*itPending).mPlaying
+				){
+					itPending = mPending.erase( itPending );
+				}
+			}
+#endif
+			itActive = mActive.erase( itActive );
+		}
+	}
+*/
+	// Sum effects
+	ActiveSet start; 
+	for
+	(	itPending = mPending.begin()
+	;	itPending != mPending.end()
+	;	itPending++
+	){
+		if ( (*itPending).Update() )
+		{
+			start[ (*itPending).mHandle ] += const_cast <SndForce&> (*itPending);
+		}
+	}
+
+	// Decide whether to start ( no updating one-shots )
+	for
+	(	itActive = start.begin()
+	;	itActive != start.end()
+	;	itActive++
+	){
+/*		SndForce &sndForce = mActive[ (*itActive).first ];
+		sndForce.mHandle = (*itActive).first;
+		if ( (*itActive).second.GetGain() >= sndForce.GetGain() )
+		{
+			//gFFSystem.ChangeGain( sndForce.mHandle, sndForce.GetGain() );
+			FF_Start( sndForce.mHandle );
+			sndForce.mPlaying = qtrue;
+		}
+*/		FF_Play( (*itActive).first );
+	}
+
+	mPending.clear();
+
+	return qfalse;
+}
+
+void SndForce::operator += ( SndForce &other )
+{
+	/*
+	float dist = other.GetRelativeDistance();
+
+	if ( dist < 1.f )
+	{
+		float thisdist = GetRelativeDistance();
+
+		if ( thisdist < 1.f )
+		{
+			if ( dist == 0.f || thisdist == 0.f )
+			{
+				mOrigin[0] = 0.f;
+				mOrigin[1] = 0.f;
+				mOrigin[2] = 0.f;
+			}
+			else
+			{
+				// This is so shitty
+				mOrigin[0] *= dist;
+				mOrigin[1] *= dist;
+				mOrigin[2] *= dist;
+			}
+		}
+		else
+		{
+			memcpy( mOrigin, other.mOrigin, sizeof(mOrigin) );
+		}
+	*/
+
+		mRefs += other.mRefs;
+//	}
+}
+
+#endif // _IMMERSION
\ No newline at end of file
diff --git a/code/ff/ff_snd.h b/code/ff/ff_snd.h
new file mode 100644
index 0000000..c0cb1dd
--- /dev/null
+++ b/code/ff/ff_snd.h
@@ -0,0 +1,11 @@
+#ifndef FF_SND_H
+#define FF_SND_H
+
+#include "../ff/ff_public.h"
+
+void FF_AddForce( ffHandle_t ff/*, int entNum, const vec3_t origin, float maxDistance, float minDistance*/ );
+void FF_AddLoopingForce( ffHandle_t ff/*, int entNum, const vec3_t origin, float maxDistance, float minDistance*/ );
+//void FF_Respatialize( int entNum, const vec3_t origin );
+void FF_Update( void );
+
+#endif // FF_SND_H
\ No newline at end of file
diff --git a/code/ff/ff_system.cpp b/code/ff/ff_system.cpp
new file mode 100644
index 0000000..7e5e18e
--- /dev/null
+++ b/code/ff/ff_system.cpp
@@ -0,0 +1,151 @@
+#include "common_headers.h"
+
+#ifdef _IMMERSION
+
+//#include "ff.h"
+//#include "ff_ffset.h"
+//#include "ff_compound.h"
+//#include "ff_system.h"
+
+extern cvar_t *ff_developer;
+
+////--------------
+/// FFSystem::Init
+//------------------
+//
+//
+qboolean FFSystem::Init( const char *channels )
+{
+	// kludgy restart mechanism
+	typedef struct
+	{	TNameTable name;
+		vector<int> channel;
+	}	TRestartInfo;
+	TRestartInfo restart;
+
+	if ( mInitialized )
+	{
+		restart.name.resize( mHandle.size(), "" );
+		restart.channel.resize( mHandle.size(), FF_CHANNEL_MAX );
+
+		mChannel.GetRegisteredNames( restart.name );
+		mHandle.GetFailedNames( restart.name );
+		mHandle.GetChannels( restart.channel );
+
+		Shutdown();
+	}
+
+	mHandle.Init();
+
+	if ( mConfig.Init( "fffx/fffx.cfg" )			// Process config file
+	&&	 mChannel.Init( mConfig, channels ) )		// Init devices
+	{
+		if ( restart.name.size() > 1 )
+		{
+			for
+			(	int i = 1
+			;	i < restart.name.size()
+			;	i++
+			){	// ignore leading device-specific set name -- (may be switching devices)
+				Register( mConfig.RightOfSet( restart.name[ i ].c_str() ), restart.channel[ i ] );
+			}
+		}
+		else
+			ffShake = Register( "fffx/player/shake", FF_CHANNEL_BODY );
+
+		mInitialized = qtrue;
+	}
+
+	return mInitialized;
+}
+
+#ifdef FF_CONSOLECOMMAND
+
+void FFSystem::GetDisplayTokens( TNameTable &Tokens )
+{
+	FFChannelSet::GetDisplayTokens( Tokens );
+	if ( ff_developer->integer )
+	{
+		Tokens.push_back( "effects" );
+	}
+}
+
+void FFSystem::Display( TNameTable &Unprocessed, TNameTable &Processed )
+{
+	for
+	(	TNameTable::iterator itName = Unprocessed.begin()
+	;	itName != Unprocessed.end()
+	;
+	){
+		if ( stricmp( "effects", (*itName).c_str() ) == 0 )
+		{
+			if ( ff_developer->integer )
+			{
+				Com_Printf( "[registered effects]\n" );
+
+				TNameTable EffectNames;
+				int total = 0;
+				Channel::Set &ffSet = mChannel.GetSets();
+
+				for
+				(	int i = 0
+				;	i < ffSet.size()
+				;	i++
+				){
+					char ProductName[ FF_MAX_PATH ];
+					*ProductName = 0;
+					ffSet[ i ]->GetDevice()->GetProductName( ProductName, FF_MAX_PATH - 1 );
+					Com_Printf( "%s...\n", ProductName );
+
+					EffectNames.clear();
+					EffectNames.resize( mHandle.size(), "" );
+					ffSet[ i ]->GetRegisteredNames( EffectNames );
+
+					for
+					(	int j = 1
+					;	j < EffectNames.size()
+					;	j++
+					){
+						if ( EffectNames[ j ].length() )
+							Com_Printf( "%3d) \"%s\" channel=%d\n", total++, EffectNames[ j ].c_str(), mHandle[ j ].GetChannel() );
+					}
+				}
+
+				EffectNames.clear();
+				EffectNames.resize( mHandle.size(), "" );
+				
+				if ( mHandle.GetFailedNames( EffectNames ) )
+				{
+					Com_Printf( "Failed Registrants...\n" );
+					for
+					(	int j = 1
+					;	j < EffectNames.size()
+					;	j++
+					){
+						if ( EffectNames[ j ].length() )
+							Com_Printf( "%3d) \"%s\" channel=%d\n", total++, EffectNames[ j ].c_str(), mHandle[ j ].GetChannel() );
+					}
+				}
+			}
+			//else
+			//{
+			//	Com_Printf( "\"effects\" only available when ff_developer is set\n" );
+			//}
+
+			Processed.push_back( *itName );
+			itName = Unprocessed.erase( itName );
+		}
+		else
+		{
+			itName++;
+		}
+	}
+
+	mChannel.Display( Unprocessed, Processed );
+}
+
+#endif // FF_CONSOLECOMMAND
+
+#endif // _IMMERSION
+
+
diff --git a/code/ff/ff_system.h b/code/ff/ff_system.h
new file mode 100644
index 0000000..73c24c4
--- /dev/null
+++ b/code/ff/ff_system.h
@@ -0,0 +1,117 @@
+#ifndef FF_SYSTEM_H
+#define FF_SYSTEM_H
+
+//#include "ff_utils.h"
+//#include "ff_compound.h"
+//#include "ff_ffset.h"
+//#include "ff_configparser.h"
+
+#include "ff_ConfigParser.h"
+#include "ff_ChannelSet.h"
+#include "ff_HandleTable.h"
+
+//===[FFSystem]=======================================================/////////////
+//
+//	The main system for a single user with multiple channels for
+//	multiple simultaneous devices. All this is factored and 'classy'
+//	with the intent to make it more readable and easy to track bugs.
+//
+//	That's the intent, at least.
+//
+//====================================================================/////////////
+
+class FFSystem
+{
+public:
+	typedef FFConfigParser Config;
+	typedef FFChannelSet Channel;
+	typedef FFHandleTable Handle;
+protected:
+	Config mConfig;
+	Channel mChannel;
+	Handle mHandle;
+	qboolean mInitialized;
+	ffHandle_t ffShake;
+public:
+	qboolean Init( const char *channels );
+	void Shutdown()
+	{
+		mInitialized = qfalse;
+		mHandle.clear();
+		mChannel.clear();
+		mConfig.Clear();
+	}
+	ffHandle_t Register( const char *name, int channel, qboolean notfound = qtrue, qboolean create = qtrue )
+	{
+		ffHandle_t result = FF_HANDLE_NULL;
+		if ( name && name[ 0 ] )
+		{
+			ChannelCompound compound( channel );
+			mChannel.Register( compound, name, create );
+			result = mHandle.Convert( compound, name, notfound );
+		}
+		return result;
+	}
+	qboolean StopAll()
+	{
+		return mChannel.StopAll();
+	}
+	const char* GetName( ffHandle_t ff )
+	{
+		return mHandle.GetName( ff );
+	}
+	qboolean Stop( ffHandle_t ff )
+	{
+		return mHandle[ ff ].Stop();
+	}
+	qboolean Play( ffHandle_t ff )
+	{
+		return mHandle[ ff ].Start();
+	}
+	qboolean EnsurePlaying( ffHandle_t ff )
+	{
+		return mHandle[ ff ].EnsurePlaying();
+	}
+	qboolean Shake( int intensity, int duration, qboolean ensure = qtrue )
+	{
+		ChannelCompound &Compound = mHandle[ ffShake ];
+		Compound.ChangeDuration( duration );
+		Compound.ChangeGain( intensity );
+		return ensure 
+		?	EnsurePlaying( ffShake ) 
+		:	Compound.Start()
+		;
+	}
+	qboolean IsInitialized() { return mInitialized;	}
+	qboolean IsPlaying( ffHandle_t ff )
+	{
+		return mHandle[ ff ].IsPlaying();
+	}
+	qboolean ChangeGain( ffHandle_t ff, DWORD gain )
+	{
+		return mHandle[ ff ].ChangeGain( gain );
+	}
+
+	//
+	//	Optional
+	//
+//	qboolean Lookup( set<ffHandle_t> &result, const char *name )
+//	{
+//		set<MultiEffect*> effect;
+//		return
+//			mChannel.Lookup( effect, name )
+//		&&	mHandle.Lookup( result, effect, name );
+//	}
+
+#ifdef FF_ACCESSOR
+//	Channel& GetChannels() { return mChannel; }				// for CMD_FF_Info
+	Handle& GetHandles() { return mHandle; }				// for CMD_FF_Info
+#endif
+
+#ifdef FF_CONSOLECOMMAND
+	void Display( TNameTable &Unprocessed, TNameTable &Processed );
+	void GetDisplayTokens( TNameTable &Tokens );
+#endif
+};
+
+#endif // FF_SYSTEM_H
\ No newline at end of file
diff --git a/code/ff/ff_utils.cpp b/code/ff/ff_utils.cpp
new file mode 100644
index 0000000..1cb87ce
--- /dev/null
+++ b/code/ff/ff_utils.cpp
@@ -0,0 +1,105 @@
+#include "common_headers.h"
+
+#ifdef _IMMERSION
+
+//#include "ff_utils.h"
+
+extern cvar_t *ff_developer;
+
+//
+// Didn't know about strrchr. This is slightly different anyway.
+//
+int _rcpos( const char* string, char c, int pos )
+{
+	int length = strlen( string );
+	length = ( pos >= 0 && pos < length ? pos : length );
+	for ( int i = length - 1; i >= 0; i-- )
+		if ( string[i] == c )
+			return i;
+	return -1;
+}
+
+void* LoadFile( const char *filename )
+{
+	void *buffer;
+
+	int length = FS_ReadFile( filename, &buffer );
+
+	return length != -1 ? buffer : NULL;
+}
+
+const char *UncommonDirectory( const char *target, const char *comp )
+{
+	const char *pos = target;
+
+	for
+	(	int i = 0
+	;	target[ i ] && comp[ i ] && target[ i ] == comp[ i ]
+	;	i++
+	){
+		if ( target[ i ] == '/' )
+			pos = target + i + 1;
+	}
+
+	if ( !comp[ i ] && target[ i ] == '/' )
+		pos = target + i + 1;
+	else
+	if ( !target[ i ] && comp[ i ] == '/' )
+		pos = target + i;
+
+	return pos;
+}
+
+////-------
+/// RightOf
+//-----------
+//
+//
+//	Parameters:
+//
+//	Returns:
+//
+const char* RightOf( const char *str, const char *str2 )
+{
+	if ( !str || !str2 )
+		return NULL;
+
+	const char *s = str;
+	int len1 = strlen( str );
+	int len2 = strlen( str2 );
+
+	if ( (len2)
+	&&	 (len1 >= len2)
+	){
+		s = strstr( str, str2 );
+		if ( s )
+		{
+			if ( ((s == str) && (*(s + len2) == '/'))
+			||	 ((*(s - 1) == '/') && (*(s + len2) == '/'))
+			){
+				s += len2 + 1;
+			}
+		}
+	}
+
+	return s ? s : str;
+}
+
+#ifdef FF_PRINT
+
+void ConsoleParseError( const char *message, const char *line, int pos /*=0*/)
+{
+	if ( ff_developer && ff_developer->integer )
+	{
+		Com_Printf( "Parse error: %s\n%s\n%*c\n", message, line, pos + 1, '^' );
+	}
+}
+
+qboolean FS_VerifyName( const char *src, const char *name, char *out, int maxlen )
+{
+	return qtrue;
+}
+
+#endif // FF_PRINT
+
+#endif // _IMMERSION
\ No newline at end of file
diff --git a/code/ff/ff_utils.h b/code/ff/ff_utils.h
new file mode 100644
index 0000000..24fa14c
--- /dev/null
+++ b/code/ff/ff_utils.h
@@ -0,0 +1,154 @@
+#ifndef FF_UTILS_H
+#define FF_UTILS_H
+
+//#include "ff_public.h"
+
+template<typename Type>
+inline Type Clamp( Type arg, Type min, Type max )
+{;
+	if ( arg <= min )
+		return min;
+	else 
+	if ( arg > max )
+		return max;
+	return arg;
+}
+
+template<typename Type>
+inline Type Max( Type arg, Type arg2 )
+{
+	if ( arg < arg2 )
+		return arg2;
+	return arg;
+}
+
+template<typename Type>
+inline Type Min( Type arg, Type arg2 )
+{
+	if ( arg > arg2 )
+		return arg2;
+	return arg;
+}
+
+template<typename Type>
+inline Type InRange( Type arg, Type min, Type max, Type invalid )
+{
+	if ( arg < min || arg > max )
+		return invalid;
+	return arg;
+}
+
+typedef vector<string> TNameTable;
+
+int _rcpos( const char* string, char c, int pos = -1 );
+void* LoadFile( const char *filename );
+const char *UncommonDirectory( const char *target, const char *comp );
+const char* RightOf( const char *str, const char *str2 );
+
+template< class Type >
+void DeletePointer( Type &Pointer, const char *String = 0 )
+{
+	if ( Pointer )
+	{
+#ifdef FF_PRINT
+		if ( String )
+			Com_Printf( "%s\n", String );
+#endif
+		delete Pointer;
+		Pointer = NULL;
+	}
+}
+
+#ifdef FF_PRINT
+void ConsoleParseError( const char *message, const char *line, int pos = 0 );
+#endif
+
+qboolean FS_VerifyName( const char *src, const char *name, char *out, int maxlen = FF_MAX_PATH );
+
+//===[multimapIterator]================================================/////////////
+//
+//	Convenience class for iterating through a multimap. It's not actually
+//	all that convenient :(  It's slightly more intuitive than the
+//	actual multimap iteration logic.
+//
+//====================================================================/////////////
+
+template< class T >
+class multimapIterator
+{
+protected:
+	T::iterator mIt;
+	T &mMap;
+	T::key_type mKey;
+public:
+	multimapIterator( T &map, T::key_type key )
+	:	mMap( map )
+	,	mKey( key )
+	{
+		mIt = mMap.find( mKey );
+	}
+	multimapIterator& operator ++ ()
+	{
+		if ( mIt != mMap.end() )
+		{
+			mIt++;
+			if ( (*mIt).first != mKey )
+				mIt = mMap.end();
+		}
+		return *this;
+	}
+	qboolean operator != ( T::iterator it )
+	{
+		return qboolean( mIt != it );
+	}
+	qboolean operator == ( T::iterator it )
+	{
+		return qboolean( mIt == it );
+	}
+	T::iterator operator * ()
+	{
+		return mIt;				// must dereference twice to access first and second
+	}
+	T::iterator operator = ( T::iterator it )
+	{
+		mIt = it;
+		return mIt;
+	}
+	operator qboolean ()
+	{
+		return qboolean( mIt != mMap.end() );
+	}
+};
+
+/*
+template< class T >
+class multimapIteratorIterator
+{
+protected:
+	multimapIterator mIt;
+
+public:
+	multimapIteratorIterator( T &map )
+	:	mIt( map, map.begin() )
+	{
+	}
+	multimapIteratorIterator& operator ++ ()
+	{
+		for
+		(	T::iterator last = *mIt
+		;	mIt
+		;	last = mIt, ++mIt
+		);
+
+		mIt = ++last;
+
+		return *this;
+	}
+	multimapIterator& operator * ()
+	{
+		return mIt;
+	}
+};
+*/
+
+#endif // FF_UTILS_H
\ No newline at end of file
diff --git a/code/ff/vssver.scc b/code/ff/vssver.scc
new file mode 100644
index 0000000..5fadef8
Binary files /dev/null and b/code/ff/vssver.scc differ
diff --git a/code/game/AI_Animal.cpp b/code/game/AI_Animal.cpp
new file mode 100644
index 0000000..8bc3717
--- /dev/null
+++ b/code/game/AI_Animal.cpp
@@ -0,0 +1,390 @@
+// leave this line at the top of all AI_xxxx.cpp files for PCH reasons...
+#include "g_headers.h"
+
+	    
+#include "b_local.h"
+
+#include "..\Ratl\vector_vs.h"
+
+#define MAX_PACKS			10
+
+#define	LEAVE_PACK_DISTANCE	1000
+#define	JOIN_PACK_DISTANCE	800
+#define	WANDER_RANGE		1000
+#define	FRIGHTEN_DISTANCE	300
+
+extern qboolean G_PlayerSpawned( void );
+
+ratl::vector_vs<gentity_t*, MAX_PACKS>	mPacks;
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Update The Packs, Delete Dead Leaders, Join / Split Packs, Find MY Leader
+////////////////////////////////////////////////////////////////////////////////////////
+gentity_t* NPC_AnimalUpdateLeader(void)
+{
+	// Find The Closest Pack Leader, Not Counting Myself
+	//---------------------------------------------------
+	gentity_t*	closestLeader = 0;
+	float		closestDist = 0;
+	int			myLeaderNum = 0;
+	
+	for (int i=0; i<mPacks.size(); i++)
+	{
+		// Dump Dead Leaders
+		//-------------------
+		if (mPacks[i]==0 || mPacks[i]->health<=0)
+		{
+			if (mPacks[i]==NPC->client->leader)
+			{
+				NPC->client->leader = 0;
+			}
+
+			mPacks.erase_swap(i);
+
+			if (i>=mPacks.size())
+			{
+				closestLeader = 0;
+				break;
+			}
+		}
+
+		// Don't Count Self
+		//------------------
+		if (mPacks[i]==NPC)
+		{
+			myLeaderNum = i;
+			continue;
+		}
+
+		float	Dist = Distance(mPacks[i]->currentOrigin, NPC->currentOrigin);
+		if (!closestLeader || Dist<closestDist)
+		{
+			closestDist = Dist;
+			closestLeader = mPacks[i];
+		}
+	}
+
+	// In Joining Distance?
+	//----------------------
+	if (closestLeader && closestDist<JOIN_PACK_DISTANCE)
+	{
+		// Am I Already A Leader?
+		//------------------------
+		if (NPC->client->leader==NPC)
+		{
+			mPacks.erase_swap(myLeaderNum);		// Erase Myself From The Leader List
+		}
+
+		// Join The Pack!
+		//----------------
+		NPC->client->leader = closestLeader;
+	}
+
+
+	// Do I Have A Leader?
+	//---------------------
+	if (NPC->client->leader)
+	{
+		// AM I A Leader?
+		//----------------
+		if (NPC->client->leader!=NPC)
+		{
+			// If Our Leader Is Dead, Clear Him Out
+
+			if ( NPC->client->leader->health<=0 || NPC->client->leader->inuse == 0)
+			{
+				NPC->client->leader = 0;
+			}
+			
+			// If My Leader Isn't His Own Leader, Then, Use His Leader
+			//---------------------------------------------------------
+			else if (NPC->client->leader->client->leader!=NPC->client->leader)
+			{
+				// Eh.  Can this get more confusing?
+				NPC->client->leader = NPC->client->leader->client->leader;
+			}
+
+			// If Our Leader Is Too Far Away, Clear Him Out
+			//------------------------------------------------------
+			else if ( Distance(NPC->client->leader->currentOrigin, NPC->currentOrigin)>LEAVE_PACK_DISTANCE)
+			{
+				NPC->client->leader = 0;
+			}
+		}
+
+	}
+
+	// If We Couldn't Find A Leader, Then Become One
+	//-----------------------------------------------
+	else if (!mPacks.full())
+	{
+		NPC->client->leader = NPC;
+		mPacks.push_back(NPC);
+	}
+	return NPC->client->leader;
+}
+
+
+
+
+/*
+-------------------------
+NPC_BSAnimal_Default
+-------------------------
+*/
+void NPC_BSAnimal_Default( void )
+{
+	if (!NPC || !NPC->client)
+	{
+		return;
+	}
+
+	// Update Some Positions
+	//-----------------------
+	CVec3	CurrentLocation(NPC->currentOrigin);
+
+
+	// Update The Leader
+	//-------------------
+	gentity_t*	leader = NPC_AnimalUpdateLeader();
+
+
+	// Select Closest Threat Location
+	//--------------------------------
+	CVec3	ThreatLocation(0,0,0);
+	qboolean PlayerSpawned = G_PlayerSpawned();
+	if ( PlayerSpawned )
+	{//player is actually in the level now
+		ThreatLocation = player->currentOrigin;
+	}
+	int	alertEvent = NPC_CheckAlertEvents(qtrue, qtrue, -1, qfalse, AEL_MINOR, qfalse);
+	if ( alertEvent >= 0 )
+	{
+		alertEvent_t *event = &level.alertEvents[alertEvent];
+		if (event->owner!=NPC  &&  Distance(event->position, CurrentLocation.v)<event->radius)
+		{
+			ThreatLocation = event->position;
+		}
+	}
+
+
+
+//	float	DistToThreat	= CurrentLocation.Dist(ThreatLocation);
+//	float	DistFromHome	= CurrentLocation.Dist(mHome);
+
+
+
+	bool	EvadeThreat		= (level.time<NPCInfo->investigateSoundDebounceTime);
+	bool	CharmedDocile	= (level.time<NPCInfo->confusionTime);
+	bool	CharmedApproach = (level.time<NPCInfo->charmedTime);
+
+
+
+	// If Not Already Evading, Test To See If We Should "Know" About The Threat
+	//--------------------------------------------------------------------------
+/*	if (false && !EvadeThreat && PlayerSpawned && (DistToThreat<FRIGHTEN_DISTANCE))
+	{
+		CVec3	LookAim(NPC->currentAngles);
+		LookAim.AngToVec();
+		CVec3	MyPos(CurrentLocation);
+		MyPos -= ThreatLocation;
+		MyPos.SafeNorm();
+
+		float	DirectionSimilarity = MyPos.Dot(LookAim);
+
+		if (fabsf(DirectionSimilarity)<0.8f)
+		{
+			EvadeThreat = true;
+			NPCInfo->investigateSoundDebounceTime = level.time + Q_irand(0, 1000);
+			VectorCopy(ThreatLocation.v, NPCInfo->investigateGoal);
+		}
+	}*/
+
+
+
+
+
+	STEER::Activate(NPC);
+	{
+		// Charmed Approach - Walk TOWARD The Threat Location
+		//----------------------------------------------------
+		if (CharmedApproach)
+		{
+			NAV::GoTo(NPC, NPCInfo->investigateGoal);
+		}
+
+		// Charmed Docile - Stay Put
+		//---------------------------
+		else if (CharmedDocile)
+		{
+			NAV::ClearPath(NPC);
+			STEER::Stop(NPC);
+		}
+
+		// Run Away From This Threat
+		//---------------------------
+		else if (EvadeThreat)
+		{
+			NAV::ClearPath(NPC);
+			STEER::Flee(NPC, NPCInfo->investigateGoal);
+		}
+
+		// Normal Behavior
+		//-----------------
+		else
+		{
+			// Follow Our Pack Leader!
+			//-------------------------
+			if (leader && leader!=NPC)
+			{
+				float	followDist	= 100.0f;
+				float	curDist		= Distance(NPC->currentOrigin, leader->followPos);
+
+
+				// Update The Leader's Follow Position
+				//-------------------------------------
+				STEER::FollowLeader(NPC, leader, followDist);
+
+				bool	inSeekRange = (curDist<followDist*10.0f);
+				bool	onNbrPoints = (NAV::OnNeighboringPoints(NAV::GetNearestNode(NPC), leader->followPosWaypoint));
+				bool	leaderStop	= ((level.time - leader->lastMoveTime)>500);
+
+				// If Close Enough, Dump Any Existing Path
+				//-----------------------------------------
+				if (inSeekRange || onNbrPoints)
+				{
+					NAV::ClearPath(NPC);
+
+					// If The Leader Isn't Moving, Stop
+					//----------------------------------
+					if (leaderStop)
+					{
+						STEER::Stop(NPC);
+					}
+
+					// Otherwise, Try To Get To The Follow Position
+					//----------------------------------------------
+					else
+					{
+						STEER::Seek(NPC, leader->followPos, fabsf(followDist)/2.0f/*slowing distance*/, 1.0f/*wight*/, leader->resultspeed);
+					}
+				}
+
+				// Otherwise, Get A Path To The Follow Position
+				//----------------------------------------------
+				else
+				{
+					NAV::GoTo(NPC, leader->followPosWaypoint);
+				}
+				STEER::Separation(NPC, 4.0f);
+				STEER::AvoidCollisions(NPC, leader);
+			}
+
+			// Leader AI - Basically Wander
+			//------------------------------
+			else
+			{
+				// Are We Doing A Path?
+				//----------------------
+				bool	HasPath = NAV::HasPath(NPC);
+				if (HasPath)
+				{
+					HasPath = NAV::UpdatePath(NPC);
+					if (HasPath)
+					{
+						STEER::Path(NPC);	// Follow The Path
+						STEER::AvoidCollisions(NPC);
+					}
+				}
+
+				if (!HasPath)
+				{
+					// If Debounce Time Has Expired, Choose A New Sub State
+					//------------------------------------------------------
+					if (NPCInfo->investigateDebounceTime<level.time)
+					{
+						// Clear Out Flags From The Previous Substate
+						//--------------------------------------------
+						NPCInfo->aiFlags	&= ~NPCAI_OFF_PATH;
+						NPCInfo->aiFlags	&= ~NPCAI_WALKING;
+
+
+						// Pick Another Spot
+						//-------------------
+						int		NEXTSUBSTATE = Q_irand(0, 10);
+
+						bool	RandomPathNode = (NEXTSUBSTATE<8); //(NEXTSUBSTATE<9);  
+						bool	PathlessWander = (NEXTSUBSTATE<9); //false;				
+
+						
+
+						// Random Path Node
+						//------------------
+						if (RandomPathNode)
+						{
+							// Sometimes, Walk
+							//-----------------
+							if (Q_irand(0, 1)==0)
+							{
+								NPCInfo->aiFlags	|= NPCAI_WALKING;
+							}
+
+							NPCInfo->investigateDebounceTime = level.time + Q_irand(3000, 10000);
+							NAV::FindPath(NPC, NAV::ChooseRandomNeighbor(NAV::GetNearestNode(NPC)));//, mHome.v, WANDER_RANGE));
+						}
+
+						// Pathless Wandering
+						//--------------------
+						else if (PathlessWander)
+						{
+							// Sometimes, Walk
+							//-----------------
+							if (Q_irand(0, 1)==0)
+							{
+								NPCInfo->aiFlags	|= NPCAI_WALKING;
+							}
+
+							NPCInfo->investigateDebounceTime = level.time + Q_irand(3000, 10000);
+							NPCInfo->aiFlags |= NPCAI_OFF_PATH;
+						}
+
+						// Just Stand Here
+						//-----------------
+						else
+						{
+							NPCInfo->investigateDebounceTime = level.time + Q_irand(2000, 6000);
+							//NPC_SetAnim(NPC, SETANIM_BOTH, ((Q_irand(0, 1)==0)?(BOTH_GUARD_LOOKAROUND1):(BOTH_GUARD_IDLE1)), SETANIM_FLAG_NORMAL);
+						}
+					}
+
+					// Ok, So We Don't Have A Path, And Debounce Time Is Still Active, So We Are Either Wandering Or Looking Around
+					//--------------------------------------------------------------------------------------------------------------
+					else
+					{
+					//	if (DistFromHome>(WANDER_RANGE))
+					//	{
+					//		STEER::Seek(NPC, mHome);
+					//	}
+					//	else
+						{
+							if (NPCInfo->aiFlags & NPCAI_OFF_PATH)
+							{
+								STEER::Wander(NPC);
+								STEER::AvoidCollisions(NPC);
+							}
+							else
+							{
+								STEER::Stop(NPC);
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+	STEER::DeActivate(NPC, &ucmd); 
+
+	NPC_UpdateAngles( qtrue, qtrue );
+}
+
diff --git a/code/game/AI_AssassinDroid.cpp b/code/game/AI_AssassinDroid.cpp
new file mode 100644
index 0000000..07105ee
--- /dev/null
+++ b/code/game/AI_AssassinDroid.cpp
@@ -0,0 +1,197 @@
+// leave this line at the top of all AI_xxxx.cpp files for PCH reasons...
+#include "g_headers.h"
+
+//custom anims:
+	//both_attack1 - running attack
+	//both_attack2 - crouched attack
+	//both_attack3 - standing attack
+	//both_stand1idle1 - idle
+	//both_crouch2stand1 - uncrouch
+	//both_death4 - running death
+
+#define	ASSASSIN_SHIELD_SIZE	75
+#define TURN_ON					0x00000000
+#define TURN_OFF				0x00000100
+
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// 
+////////////////////////////////////////////////////////////////////////////////////////
+bool BubbleShield_IsOn()
+{
+	return (NPC->flags&FL_SHIELDED);
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// 
+////////////////////////////////////////////////////////////////////////////////////////
+void BubbleShield_TurnOn()
+{
+	if (!BubbleShield_IsOn())
+	{
+		NPC->flags |= FL_SHIELDED;
+		NPC->client->ps.powerups[PW_GALAK_SHIELD] = Q3_INFINITE;
+		gi.G2API_SetSurfaceOnOff( &NPC->ghoul2[NPC->playerModel], "force_shield", TURN_ON );
+	}
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// 
+////////////////////////////////////////////////////////////////////////////////////////
+void BubbleShield_TurnOff()
+{
+	if ( BubbleShield_IsOn())
+	{
+		NPC->flags &= ~FL_SHIELDED;
+		NPC->client->ps.powerups[PW_GALAK_SHIELD] = 0;
+		gi.G2API_SetSurfaceOnOff( &NPC->ghoul2[NPC->playerModel], "force_shield", TURN_OFF );
+	}
+}
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Push A Particular Ent
+////////////////////////////////////////////////////////////////////////////////////////
+void BubbleShield_PushEnt(gentity_t* pushed, vec3_t smackDir)
+{
+	G_Damage(pushed, NPC, NPC, smackDir, NPC->currentOrigin, (g_spskill->integer+1)*Q_irand( 5, 10), DAMAGE_NO_KNOCKBACK, MOD_ELECTROCUTE); 
+	G_Throw(pushed, smackDir, 10);
+
+	// Make Em Electric
+	//------------------
+ 	pushed->s.powerups |= (1 << PW_SHOCKED);
+	if (pushed->client)
+	{
+		pushed->client->ps.powerups[PW_SHOCKED] = level.time + 1000;
+	}
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Go Through All The Ents Within The Radius Of The Shield And Push Them
+////////////////////////////////////////////////////////////////////////////////////////
+void BubbleShield_PushRadiusEnts()
+{
+	int			numEnts;
+	gentity_t*	radiusEnts[128];
+	const float	radius = ASSASSIN_SHIELD_SIZE;
+	vec3_t		mins, maxs;
+	vec3_t		smackDir;
+	float		smackDist;
+
+	for (int i = 0; i < 3; i++ )
+	{
+		mins[i] = NPC->currentOrigin[i] - radius;
+		maxs[i] = NPC->currentOrigin[i] + radius;
+	}
+
+	numEnts = gi.EntitiesInBox(mins, maxs, radiusEnts, 128);
+	for (int entIndex=0; entIndex<numEnts; entIndex++)
+	{
+		// Only Clients
+		//--------------
+		if (!radiusEnts[entIndex] || !radiusEnts[entIndex]->client)
+		{
+			continue;
+		}
+
+		// Don't Push Away Other Assassin Droids
+		//---------------------------------------
+		if (radiusEnts[entIndex]->client->NPC_class==NPC->client->NPC_class)
+		{
+			continue;
+		}
+
+		// Should Have Already Pushed The Enemy If He Touched Us
+		//-------------------------------------------------------
+		if (NPC->enemy &&  NPCInfo->touchedByPlayer==NPC->enemy && radiusEnts[entIndex]==NPC->enemy)
+		{
+			continue;
+		}
+
+		// Do The Vector Distance Test
+		//-----------------------------
+		VectorSubtract(radiusEnts[entIndex]->currentOrigin, NPC->currentOrigin, smackDir);
+		smackDist = VectorNormalize(smackDir);
+		if (smackDist<radius)
+		{
+			BubbleShield_PushEnt(radiusEnts[entIndex], smackDir);
+		}
+	}
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// 
+////////////////////////////////////////////////////////////////////////////////////////
+void BubbleShield_Update()
+{
+	// Shields Go When You Die
+	//-------------------------
+	if (NPC->health<=0)
+	{
+		if (BubbleShield_IsOn())
+		{
+			BubbleShield_TurnOff();
+		}
+		return;
+	}
+
+
+	// Recharge Shields
+	//------------------
+ 	NPC->client->ps.stats[STAT_ARMOR] += 1;
+	if (NPC->client->ps.stats[STAT_ARMOR]>250)
+	{
+		NPC->client->ps.stats[STAT_ARMOR] = 250;
+	}
+
+
+
+
+	// If We Have Enough Armor And Are Not Shooting Right Now, Kick The Shield On
+	//----------------------------------------------------------------------------
+ 	if (NPC->client->ps.stats[STAT_ARMOR]>100 && TIMER_Done(NPC, "ShieldsDown"))
+	{
+		// Check On Timers To Raise And Lower Shields
+		//--------------------------------------------
+		if ((level.time - NPCInfo->enemyLastSeenTime)<1000 && TIMER_Done(NPC, "ShieldsUp"))
+		{
+			TIMER_Set(NPC, "ShieldsDown", 2000);		// Drop Shields
+			TIMER_Set(NPC, "ShieldsUp", Q_irand(4000, 5000));	// Then Bring Them Back Up For At Least 3 sec
+		} 
+
+		BubbleShield_TurnOn();
+		if (BubbleShield_IsOn())
+		{
+			// Update Our Shader Value
+			//-------------------------
+	 	 	NPC->client->renderInfo.customRGBA[0] = 
+			NPC->client->renderInfo.customRGBA[1] = 
+			NPC->client->renderInfo.customRGBA[2] =
+  			NPC->client->renderInfo.customRGBA[3] = (NPC->client->ps.stats[STAT_ARMOR] - 100);
+
+
+			// If Touched By An Enemy, ALWAYS Shove Them
+			//-------------------------------------------
+			if (NPC->enemy &&  NPCInfo->touchedByPlayer==NPC->enemy)
+			{
+				vec3_t dir;
+				VectorSubtract(NPC->enemy->currentOrigin, NPC->currentOrigin, dir);
+				VectorNormalize(dir);
+				BubbleShield_PushEnt(NPC->enemy, dir);
+			}
+
+			// Push Anybody Else Near
+			//------------------------
+			BubbleShield_PushRadiusEnts();
+		}
+	}
+
+
+	// Shields Gone
+	//--------------
+	else
+	{
+		BubbleShield_TurnOff();
+	}
+}
\ No newline at end of file
diff --git a/code/game/AI_Atst.cpp b/code/game/AI_Atst.cpp
new file mode 100644
index 0000000..3d77729
--- /dev/null
+++ b/code/game/AI_Atst.cpp
@@ -0,0 +1,315 @@
+// leave this line at the top of all AI_xxxx.cpp files for PCH reasons...
+#include "g_headers.h"
+
+	    
+#include "b_local.h"
+
+
+#define	MIN_MELEE_RANGE		640
+#define	MIN_MELEE_RANGE_SQR	( MIN_MELEE_RANGE * MIN_MELEE_RANGE )
+
+#define MIN_DISTANCE		128
+#define MIN_DISTANCE_SQR	( MIN_DISTANCE * MIN_DISTANCE )
+
+#define TURN_OFF			0x00000100//G2SURFACEFLAG_NODESCENDANTS
+
+#define LEFT_ARM_HEALTH 40
+#define RIGHT_ARM_HEALTH 40
+
+/*
+-------------------------
+NPC_ATST_Precache
+-------------------------
+*/
+void NPC_ATST_Precache(void)
+{
+	G_SoundIndex( "sound/chars/atst/atst_damaged1" );
+	G_SoundIndex( "sound/chars/atst/atst_damaged2" );
+
+	RegisterItem( FindItemForWeapon( WP_ATST_MAIN ));	//precache the weapon
+	RegisterItem( FindItemForWeapon( WP_BOWCASTER ));	//precache the weapon
+	RegisterItem( FindItemForWeapon( WP_ROCKET_LAUNCHER ));	//precache the weapon
+
+	G_EffectIndex( "env/med_explode2" );
+//	G_EffectIndex( "smaller_chunks" );
+	G_EffectIndex( "blaster/smoke_bolton" );
+	G_EffectIndex( "explosions/droidexplosion1" );
+}
+
+//-----------------------------------------------------------------
+static void ATST_PlayEffect( gentity_t *self, const int boltID, const char *fx )
+{
+	if ( boltID >=0 && fx && fx[0] )
+	{
+		mdxaBone_t	boltMatrix;
+		vec3_t		org, dir;
+
+		gi.G2API_GetBoltMatrix( self->ghoul2, self->playerModel, 
+					boltID,
+					&boltMatrix, self->currentAngles, self->currentOrigin, (cg.time?cg.time:level.time),
+					NULL, self->s.modelScale );
+
+		gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, org );
+		gi.G2API_GiveMeVectorFromMatrix( boltMatrix, NEGATIVE_Y, dir );
+
+		G_PlayEffect( fx, org, dir );
+	}
+}
+
+/*
+-------------------------
+G_ATSTCheckPain
+
+Called by NPC's and player in an ATST
+-------------------------
+*/
+
+void G_ATSTCheckPain( gentity_t *self, gentity_t *other, const vec3_t point, int damage, int mod,int hitLoc )
+{
+	int newBolt;
+	
+	if ( rand() & 1 )
+	{
+		G_SoundOnEnt( self, CHAN_LESS_ATTEN, "sound/chars/atst/atst_damaged1" );
+	}
+	else
+	{
+		G_SoundOnEnt( self, CHAN_LESS_ATTEN, "sound/chars/atst/atst_damaged2" );
+	}
+
+	if ((hitLoc==HL_ARM_LT) && (self->locationDamage[HL_ARM_LT] > LEFT_ARM_HEALTH))
+	{
+		if (self->locationDamage[hitLoc] >= LEFT_ARM_HEALTH)	// Blow it up?
+		{
+			newBolt = gi.G2API_AddBolt( &self->ghoul2[self->playerModel], "*flash3" );
+			if ( newBolt != -1 )
+			{
+//				G_PlayEffect( "small_chunks", self->playerModel, self->genericBolt1, self->s.number);
+				ATST_PlayEffect( self, self->genericBolt1, "env/med_explode2" );
+				G_PlayEffect( G_EffectIndex("blaster/smoke_bolton"), self->playerModel, newBolt, self->s.number, point);
+			}
+
+			gi.G2API_SetSurfaceOnOff( &self->ghoul2[self->playerModel], "head_light_blaster_cann", TURN_OFF );
+		}
+	}
+	else if ((hitLoc==HL_ARM_RT) && (self->locationDamage[HL_ARM_RT] > RIGHT_ARM_HEALTH))	// Blow it up?
+	{
+		if (self->locationDamage[hitLoc] >= RIGHT_ARM_HEALTH)
+		{			
+			newBolt = gi.G2API_AddBolt( &self->ghoul2[self->playerModel], "*flash4" );
+			if ( newBolt != -1 )
+			{
+//				G_PlayEffect( "small_chunks", self->playerModel, self->genericBolt2, self->s.number);
+				ATST_PlayEffect( self, self->genericBolt2, "env/med_explode2" );
+				G_PlayEffect( G_EffectIndex("blaster/smoke_bolton"), self->playerModel, newBolt, self->s.number, point);
+			}
+
+			gi.G2API_SetSurfaceOnOff( &self->ghoul2[self->playerModel], "head_concussion_charger", TURN_OFF );
+		}
+	}
+}
+/*
+-------------------------
+NPC_ATST_Pain
+-------------------------
+*/
+void NPC_ATST_Pain( gentity_t *self, gentity_t *inflictor, gentity_t *other, const vec3_t point, int damage, int mod,int hitLoc ) 
+{
+	G_ATSTCheckPain( self, other, point, damage, mod, hitLoc );
+	NPC_Pain( self, inflictor, other, point, damage, mod );
+}
+
+/*
+-------------------------
+ATST_Hunt
+-------------------------`
+*/
+void ATST_Hunt( qboolean visible, qboolean advance )
+{
+
+	if ( NPCInfo->goalEntity == NULL )
+	{//hunt
+		NPCInfo->goalEntity = NPC->enemy;
+	}
+
+	NPCInfo->combatMove = qtrue;
+
+	NPC_MoveToGoal( qtrue );
+
+}
+
+/*
+-------------------------
+ATST_Ranged
+-------------------------
+*/
+void ATST_Ranged( qboolean visible, qboolean advance, qboolean altAttack )
+{
+
+	if ( TIMER_Done( NPC, "atkDelay" ) && visible )	// Attack?
+	{
+		TIMER_Set( NPC, "atkDelay", Q_irand( 500, 3000 ) );
+
+		if (altAttack)
+		{
+			ucmd.buttons |= BUTTON_ATTACK|BUTTON_ALT_ATTACK;
+		}
+		else
+		{
+			ucmd.buttons |= BUTTON_ATTACK;
+		}
+	}
+
+	if ( NPCInfo->scriptFlags & SCF_CHASE_ENEMIES )
+	{
+		ATST_Hunt( visible, advance );
+	}
+}
+
+/*
+-------------------------
+ATST_Attack
+-------------------------
+*/
+void ATST_Attack( void )
+{
+	qboolean	altAttack=qfalse;
+	int			blasterTest,chargerTest,weapon;
+
+	if ( NPC_CheckEnemyExt() == qfalse )//!NPC->enemy )//
+	{
+		NPC->enemy = NULL;
+		return;
+	}
+
+	NPC_FaceEnemy( qtrue );
+
+	// Rate our distance to the target, and our visibilty
+	float		distance	= (int) DistanceHorizontalSquared( NPC->currentOrigin, NPC->enemy->currentOrigin );	
+	distance_e	distRate	= ( distance > MIN_MELEE_RANGE_SQR ) ? DIST_LONG : DIST_MELEE;
+	qboolean	visible		= NPC_ClearLOS( NPC->enemy );
+	qboolean	advance		= (qboolean)(distance > MIN_DISTANCE_SQR);
+
+	// If we cannot see our target, move to see it
+	if ( visible == qfalse )
+	{
+		if ( NPCInfo->scriptFlags & SCF_CHASE_ENEMIES )
+		{
+			ATST_Hunt( visible, advance );
+			return;
+		}
+	}
+
+	// Decide what type of attack to do
+	switch ( distRate )
+	{
+	case DIST_MELEE:
+		NPC_ChangeWeapon( WP_ATST_MAIN );
+		break;
+
+	case DIST_LONG:
+
+		NPC_ChangeWeapon( WP_ATST_SIDE );
+
+		// See if the side weapons are there
+		blasterTest = gi.G2API_GetSurfaceRenderStatus( &NPC->ghoul2[NPC->playerModel], "head_light_blaster_cann" );
+		chargerTest = gi.G2API_GetSurfaceRenderStatus( &NPC->ghoul2[NPC->playerModel], "head_concussion_charger" );
+
+		// It has both side weapons
+		if (!(blasterTest & TURN_OFF)  && !(chargerTest & TURN_OFF))
+		{
+			weapon = Q_irand( 0, 1);	// 0 is blaster, 1 is charger (ALT SIDE)
+
+			if (weapon)				// Fire charger
+			{
+				altAttack = qtrue;
+			}
+			else
+			{
+				altAttack = qfalse;
+			}
+
+		}
+		else if (!(blasterTest & TURN_OFF))	// Blaster is on
+		{
+			altAttack = qfalse;
+		}
+		else if (!(chargerTest & TURN_OFF))	// Blaster is on
+		{
+			altAttack = qtrue;
+		}
+		else 
+		{
+			NPC_ChangeWeapon( WP_NONE );
+		}
+		break;
+	}
+
+	NPC_FaceEnemy( qtrue );
+
+	ATST_Ranged( visible, advance,altAttack );
+}
+
+/*
+-------------------------
+ATST_Patrol
+-------------------------
+*/
+void ATST_Patrol( void )
+{
+	if ( NPC_CheckPlayerTeamStealth() )
+	{
+		NPC_UpdateAngles( qtrue, qtrue );
+		return;
+	}
+
+	//If we have somewhere to go, then do that
+	if (!NPC->enemy)
+	{
+		if ( UpdateGoal() )
+		{
+			ucmd.buttons |= BUTTON_WALKING;
+			NPC_MoveToGoal( qtrue );
+			NPC_UpdateAngles( qtrue, qtrue );
+		}
+	}
+
+}
+
+/*
+-------------------------
+ATST_Idle
+-------------------------
+*/
+void ATST_Idle( void )
+{
+
+	NPC_BSIdle();
+
+	NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_STAND1, SETANIM_FLAG_NORMAL );
+}
+
+/*
+-------------------------
+NPC_BSDroid_Default
+-------------------------
+*/
+void NPC_BSATST_Default( void )
+{
+	if ( NPC->enemy )
+	{
+		if( (NPCInfo->scriptFlags & SCF_CHASE_ENEMIES) )
+		{
+			NPCInfo->goalEntity = NPC->enemy;
+		}
+		ATST_Attack();
+	}
+	else if ( NPCInfo->scriptFlags & SCF_LOOK_FOR_ENEMIES )
+	{
+		ATST_Patrol();
+	} 
+	else
+	{
+		ATST_Idle();
+	}
+}
diff --git a/code/game/AI_BobaFett.cpp b/code/game/AI_BobaFett.cpp
new file mode 100644
index 0000000..b462a5e
--- /dev/null
+++ b/code/game/AI_BobaFett.cpp
@@ -0,0 +1,1244 @@
+////////////////////////////////////////////////////////////////////////////////////////
+// RAVEN SOFTWARE - STAR WARS: JK II
+//  (c) 2002 Activision
+//
+// Boba Fett
+// ---------
+// Ah yes, this file is pretty messy.  I've tried to move everything in here, but in fact
+// a lot of his AI occurs in the seeker and jedi AI files.  Some of these functions
+//
+//
+//
+////////////////////////////////////////////////////////////////////////////////////////
+#include "g_headers.h"
+#include "b_local.h"
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Forward References Of Functions
+////////////////////////////////////////////////////////////////////////////////////////
+void		Boba_Precache( void );
+void		Boba_DustFallNear(const vec3_t origin, int dustcount);
+void		Boba_ChangeWeapon(int wp);
+qboolean	Boba_StopKnockdown(gentity_t *self, gentity_t *pusher, const vec3_t pushDir, qboolean forceKnockdown = qfalse);
+
+// Flight Related Functions (also used by Rocket Trooper)
+//--------------------------------------------------------
+qboolean	Boba_Flying( gentity_t *self );
+void		Boba_FlyStart( gentity_t *self );
+void		Boba_FlyStop( gentity_t *self );
+
+// Called From NPC_Pain()
+//-----------------------------
+void		Boba_Pain( gentity_t *self, gentity_t *inflictor, int damage, int mod);
+
+
+// Local: Flame Thrower Weapon
+//-----------------------------
+void		Boba_FireFlameThrower( gentity_t *self );
+void		Boba_StopFlameThrower( gentity_t *self );
+void		Boba_StartFlameThrower( gentity_t *self );
+void		Boba_DoFlameThrower( gentity_t *self );
+
+// Local: Other Tactics
+//----------------------
+void		Boba_DoAmbushWait( gentity_t *self);
+void		Boba_DoSniper( gentity_t *self);
+
+// Local: Respawning 
+//-------------------
+bool		Boba_Respawn();
+
+// Called From Within AI_Jedi && AI_Seeker
+//-----------------------------------------
+void		Boba_Fire();
+void		Boba_FireDecide();
+
+// Local: Called From Tactics()
+//----------------------------
+void		Boba_TacticsSelect();
+bool		Boba_CanSeeEnemy( gentity_t *self );
+
+
+// Called From NPC_RunBehavior()
+//-------------------------------
+void		Boba_Update();		// Always Called First, Before Any Other Thinking
+bool		Boba_Tactics();		// If returns true, Jedi and Seeker AI not used
+bool		Boba_Flee();		// If returns true, Jedi and Seeker AI not used
+
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// External Functions 
+////////////////////////////////////////////////////////////////////////////////////////
+extern void		G_SoundAtSpot( vec3_t org, int soundIndex, qboolean broadcast );
+extern void		G_CreateG2AttachedWeaponModel( gentity_t *ent, const char *weaponModel, int boltNum, int weaponNum );
+extern void		ChangeWeapon( gentity_t *ent, int newWeapon );
+extern void		WP_ResistForcePush( gentity_t *self, gentity_t *pusher, qboolean noPenalty );
+extern void		ForceJump( gentity_t *self, usercmd_t *ucmd );
+extern void		G_Knockdown( gentity_t *self, gentity_t *attacker, const vec3_t pushDir, float strength, qboolean breakSaberLock );
+
+////////////////////////////////////////////////////////////////////////////////////////
+// External Data
+////////////////////////////////////////////////////////////////////////////////////////
+extern cvar_t*		g_bobaDebug;
+
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Boba Debug Output
+////////////////////////////////////////////////////////////////////////////////////////
+#ifndef FINAL_BUILD
+#if !defined(CTYPE_H_INC)
+	#include <ctype.h>
+	#define CTYPE_H_INC
+#endif
+
+#if !defined(STDARG_H_INC)
+	#include <stdarg.h>
+	#define STDARG_H_INC
+#endif
+
+#if !defined(STDIO_H_INC)
+	#include <stdio.h>
+	#define STDIO_H_INC
+#endif
+void	Boba_Printf(const char * format, ...)
+{
+	if (g_bobaDebug->integer==0)
+	{
+		return;
+	}
+
+	static char		string[2][1024];	// in case this is called by nested functions
+	static int		index = 0;
+	static char		nFormat[300];
+	char*			buf;
+
+	// Tack On The Standard Format Around The Given Format
+	//-----------------------------------------------------
+	sprintf(nFormat, "[BOBA %8d] %s\n", level.time, format);
+
+
+	// Resolve Remaining Elipsis Parameters Into Newly Formated String
+	//-----------------------------------------------------------------
+	buf = string[index & 1];
+	index++;
+
+	va_list		argptr;
+	va_start (argptr, format);
+	vsprintf (buf, nFormat, argptr);
+	va_end (argptr);
+
+	// Print It To Debug Output Console
+	//----------------------------------
+	gi.Printf(buf);
+}
+#else
+void	Boba_Printf(const char * format, ...)
+{
+}
+#endif
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Defines
+////////////////////////////////////////////////////////////////////////////////////////
+#define		BOBA_FLAMEDURATION			3000
+#define		BOBA_FLAMETHROWRANGE		128
+#define		BOBA_FLAMETHROWSIZE			40
+#define		BOBA_FLAMETHROWDAMAGEMIN	1//10
+#define		BOBA_FLAMETHROWDAMAGEMAX	5//40
+#define		BOBA_ROCKETRANGEMIN			300
+#define		BOBA_ROCKETRANGEMAX			2000
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Global Data 
+////////////////////////////////////////////////////////////////////////////////////////
+bool	BobaHadDeathScript = false;
+bool	BobaActive = false;
+vec3_t	BobaFootStepLoc;
+int		BobaFootStepCount = 0;
+
+vec3_t	AverageEnemyDirection;
+int		AverageEnemyDirectionSamples;
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Enums
+////////////////////////////////////////////////////////////////////////////////////////
+enum	EBobaTacticsState
+{
+	BTS_NONE,
+
+	// Attack 
+	//--------
+	BTS_RIFLE,			// Uses Jedi / Seeker Movement
+	BTS_MISSILE,		// Uses Jedi / Seeker Movement
+	BTS_SNIPER,			// Uses Special Movement Internal To This File
+	BTS_FLAMETHROW,		// Locked In Place
+
+	// Waiting
+	//---------
+	BTS_AMBUSHWAIT,		// Goto CP & Wait
+
+	BTS_MAX
+};
+
+
+
+
+
+
+
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// 
+////////////////////////////////////////////////////////////////////////////////////////
+void Boba_Precache( void )
+{
+	G_SoundIndex( "sound/chars/boba/bf_blast-off.wav" );
+	G_SoundIndex( "sound/chars/boba/bf_jetpack_lp.wav" );
+	G_SoundIndex( "sound/chars/boba/bf_land.wav" );
+	G_SoundIndex( "sound/weapons/boba/bf_flame.mp3" );
+	G_SoundIndex( "sound/player/footsteps/boot1" );
+	G_SoundIndex( "sound/player/footsteps/boot2" );
+	G_SoundIndex( "sound/player/footsteps/boot3" );
+	G_SoundIndex( "sound/player/footsteps/boot4" );
+	G_EffectIndex( "boba/jetSP" );
+	G_EffectIndex( "boba/fthrw" );
+	G_EffectIndex( "volumetric/black_smoke" );
+	G_EffectIndex( "chunks/dustFall" );
+
+	AverageEnemyDirectionSamples = 0;
+	VectorClear(AverageEnemyDirection);
+	BobaHadDeathScript			= false;
+	BobaActive					= true;
+	BobaFootStepCount			= 0;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// 
+////////////////////////////////////////////////////////////////////////////////////////
+void	Boba_DustFallNear(const vec3_t origin, int dustcount)
+{
+	if (!BobaActive)
+	{
+		return;
+	}
+
+	trace_t		testTrace;
+	vec3_t		testDirection;
+	vec3_t		testStartPos;
+	vec3_t		testEndPos;
+
+	VectorCopy(origin, testStartPos);
+	for (int i=0; i<dustcount; i++)
+	{
+		testDirection[0] = (random() * 2.0f) - 1.0f;
+		testDirection[1] = (random() * 2.0f) - 1.0f;
+		testDirection[2] = 1.0f;
+
+		VectorMA(origin, 1000.0f, testDirection, testEndPos);
+		gi.trace (&testTrace, origin, NULL, NULL, testEndPos, (player && player->inuse)?(0):(ENTITYNUM_NONE), MASK_SHOT );
+
+		if (!testTrace.startsolid && 
+			!testTrace.allsolid && 
+			testTrace.fraction>0.1f &&
+			testTrace.fraction<0.9f)
+		{
+			G_PlayEffect( "chunks/dustFall", testTrace.endpos, testTrace.plane.normal );
+		}
+	}
+} 
+
+////////////////////////////////////////////////////////////////////////////////////////
+// This is just a super silly wrapper around NPC_Change Weapon
+////////////////////////////////////////////////////////////////////////////////////////
+void Boba_ChangeWeapon( int wp )
+{
+	if ( NPC->s.weapon == wp )
+	{
+		return;
+	}
+	NPC_ChangeWeapon( wp );
+	G_AddEvent( NPC, EV_GENERAL_SOUND, G_SoundIndex( "sound/weapons/change.wav" ));
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Choose an "anti-knockdown" response
+////////////////////////////////////////////////////////////////////////////////////////
+qboolean Boba_StopKnockdown( gentity_t *self, gentity_t *pusher, const vec3_t pushDir, qboolean forceKnockdown )
+{
+	if ( self->client->NPC_class != CLASS_BOBAFETT )
+	{
+		return qfalse;
+	}
+
+	if ( self->client->moveType == MT_FLYSWIM )
+	{//can't knock me down when I'm flying
+		return qtrue;
+	}
+
+	vec3_t	pDir, fwd, right, ang = {0, self->currentAngles[YAW], 0};
+	float	fDot, rDot;
+	int		strafeTime = Q_irand( 1000, 2000 );
+
+	AngleVectors( ang, fwd, right, NULL );
+	VectorNormalize2( pushDir, pDir );
+	fDot = DotProduct( pDir, fwd );
+	rDot = DotProduct( pDir, right );
+
+	if ( Q_irand( 0, 2 ) )
+	{//flip or roll with it
+		usercmd_t	tempCmd;
+		if ( fDot >= 0.4f )
+		{
+			tempCmd.forwardmove = 127;
+			TIMER_Set( self, "moveforward", strafeTime );
+		}
+		else if ( fDot <= -0.4f )
+		{
+			tempCmd.forwardmove = -127;
+			TIMER_Set( self, "moveback", strafeTime );
+		}
+		else if ( rDot > 0 )
+		{
+			tempCmd.rightmove = 127;
+			TIMER_Set( self, "strafeRight", strafeTime );
+			TIMER_Set( self, "strafeLeft", -1 );
+		}
+		else
+		{
+			tempCmd.rightmove = -127;
+			TIMER_Set( self, "strafeLeft", strafeTime );
+			TIMER_Set( self, "strafeRight", -1 );
+		}
+		G_AddEvent( self, EV_JUMP, 0 );
+		if ( !Q_irand( 0, 1 ) )
+		{//flip
+			self->client->ps.forceJumpCharge = 280;//FIXME: calc this intelligently?
+			ForceJump( self, &tempCmd );
+		}
+		else
+		{//roll
+			TIMER_Set( self, "duck", strafeTime );
+		}
+		self->painDebounceTime = 0;//so we do something
+	}
+	else if ( !Q_irand( 0, 1 ) && forceKnockdown )
+	{//resist
+		WP_ResistForcePush( self, pusher, qtrue );
+	}
+	else
+	{//fall down
+		return qfalse;
+	}
+
+	return qtrue;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Is this entity flying
+////////////////////////////////////////////////////////////////////////////////////////
+qboolean Boba_Flying( gentity_t *self )
+{
+	assert(self && self->NPC && self->client && self->client->NPC_class==CLASS_BOBAFETT);
+	return ((qboolean)(self->client->moveType==MT_FLYSWIM));
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// 
+////////////////////////////////////////////////////////////////////////////////////////
+bool	Boba_CanSeeEnemy( gentity_t *self )
+{
+	assert(self && self->NPC && self->client && self->client->NPC_class==CLASS_BOBAFETT);
+ 	return ((level.time - self->NPC->enemyLastSeenTime)<1000);
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// 
+////////////////////////////////////////////////////////////////////////////////////////
+void	Boba_Pain( gentity_t *self, gentity_t *inflictor, int damage, int mod)
+{
+	if (mod==MOD_SABER && !(NPCInfo->aiFlags&NPCAI_FLAMETHROW))
+	{
+		TIMER_Set( self, "Boba_TacticsSelect", 0);	// Hurt By The Saber, Time To Try Something New
+	}
+	if (self->NPC->aiFlags&NPCAI_FLAMETHROW)
+	{
+		NPC_SetAnim( self, SETANIM_TORSO, BOTH_FORCELIGHTNING_HOLD, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+	 	self->client->ps.torsoAnimTimer  =	level.time - TIMER_Get(self, "falmeTime");
+	}
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// 
+////////////////////////////////////////////////////////////////////////////////////////
+void Boba_FlyStart( gentity_t *self )
+{//switch to seeker AI for a while
+	if ( TIMER_Done( self, "jetRecharge" ) 
+		&& !Boba_Flying( self ) )
+	{
+		self->client->ps.gravity = 0;
+		self->svFlags |= SVF_CUSTOM_GRAVITY;
+		self->client->moveType = MT_FLYSWIM;
+		//start jet effect
+		self->client->jetPackTime = level.time + Q_irand( 3000, 10000 );
+		if ( self->genericBolt1 != -1 )
+		{
+			G_PlayEffect( G_EffectIndex( "boba/jetSP" ), self->playerModel, self->genericBolt1, self->s.number, self->currentOrigin, qtrue, qtrue );
+		}
+		if ( self->genericBolt2 != -1 )
+		{
+			G_PlayEffect( G_EffectIndex( "boba/jetSP" ), self->playerModel, self->genericBolt2, self->s.number, self->currentOrigin, qtrue, qtrue );
+		}
+
+		//take-off sound
+		G_SoundOnEnt( self, CHAN_ITEM, "sound/chars/boba/bf_blast-off.wav" );
+		//jet loop sound
+		self->s.loopSound = G_SoundIndex( "sound/chars/boba/bf_jetpack_lp.wav" );
+		if ( self->NPC )
+		{
+			self->count = Q3_INFINITE; // SEEKER shot ammo count
+		}
+	}
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// 
+////////////////////////////////////////////////////////////////////////////////////////
+void Boba_FlyStop( gentity_t *self )
+{
+	self->client->ps.gravity = g_gravity->value;
+	self->svFlags &= ~SVF_CUSTOM_GRAVITY;
+	self->client->moveType = MT_RUNJUMP;
+	//Stop effect
+	self->client->jetPackTime = 0;
+	if ( self->genericBolt1 != -1 )
+	{
+		G_StopEffect( "boba/jetSP", self->playerModel, self->genericBolt1, self->s.number );
+	}
+	if ( self->genericBolt2 != -1 )
+	{
+		G_StopEffect( "boba/jetSP", self->playerModel, self->genericBolt2, self->s.number );
+	}
+
+	//stop jet loop sound
+	G_SoundOnEnt( self, CHAN_ITEM, "sound/chars/boba/bf_land.wav" );
+
+	self->s.loopSound = 0;
+	if ( self->NPC )
+	{
+		self->count = 0; // SEEKER shot ammo count
+		TIMER_Set( self, "jetRecharge", Q_irand( 1000, 5000 ) );
+		TIMER_Set( self, "jumpChaseDebounce", Q_irand( 500, 2000 ) );
+	}
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// This func actually does the damage inflicting traces
+////////////////////////////////////////////////////////////////////////////////////////
+void Boba_FireFlameThrower( gentity_t *self )
+{
+	trace_t		tr;
+	vec3_t		start, end, dir;
+	CVec3		traceMins(self->mins);
+	CVec3		traceMaxs(self->maxs);
+	gentity_t*	traceEnt	= NULL;  
+	int			damage		= Q_irand( BOBA_FLAMETHROWDAMAGEMIN, BOBA_FLAMETHROWDAMAGEMAX );
+
+  	AngleVectors(self->currentAngles, dir, 0, 0); 
+	dir[2] = 0.0f; 
+	VectorCopy(self->currentOrigin, start); 
+	traceMins *= 0.5f;
+	traceMaxs *= 0.5f; 
+	start[2] += 40.0f;
+
+	VectorMA( start, 150.0f, dir, end ); 
+
+	if (g_bobaDebug->integer)
+	{
+		CG_DrawEdge(start, end, EDGE_IMPACT_POSSIBLE);
+	}
+	gi.trace( &tr, start, self->mins, self->maxs, end, self->s.number, MASK_SHOT);
+
+	traceEnt = &g_entities[tr.entityNum];
+	if ( tr.entityNum < ENTITYNUM_WORLD && traceEnt->takedamage )
+	{
+		G_Damage( traceEnt, self, self, dir, tr.endpos, damage, DAMAGE_NO_ARMOR|DAMAGE_NO_KNOCKBACK|DAMAGE_NO_HIT_LOC|DAMAGE_IGNORE_TEAM, MOD_LAVA, HL_NONE );
+		if (traceEnt->health>0)
+		{
+//			G_Knockdown( traceEnt, self, dir, Q_irand(200, 330), qfalse);
+			G_Throw(traceEnt, dir, 30);
+		}
+	}
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// 
+////////////////////////////////////////////////////////////////////////////////////////
+void Boba_StopFlameThrower( gentity_t *self )
+{
+	if ((NPCInfo->aiFlags&NPCAI_FLAMETHROW))
+	{
+		self->NPC->aiFlags				&= ~NPCAI_FLAMETHROW;
+		self->client->ps.torsoAnimTimer  =	0;
+
+		TIMER_Set( self, "flameTime",			0);
+		TIMER_Set( self, "nextAttackDelay",		0);
+		TIMER_Set( self, "Boba_TacticsSelect",	0);
+
+	//	G_SoundOnEnt( self, CHAN_WEAPON, "sound/effects/flameoff.mp3" );
+		G_StopEffect( G_EffectIndex("boba/fthrw"), self->playerModel, self->genericBolt3, self->s.number);
+
+		Boba_Printf("FlameThrower OFF");
+	}
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// 
+////////////////////////////////////////////////////////////////////////////////////////
+void Boba_StartFlameThrower( gentity_t *self )
+{
+	if (!(NPCInfo->aiFlags&NPCAI_FLAMETHROW))
+	{
+		NPC_SetAnim( self, SETANIM_TORSO, BOTH_FORCELIGHTNING_HOLD, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+
+		self->NPC->aiFlags				|=  NPCAI_FLAMETHROW;
+	 	self->client->ps.torsoAnimTimer  =	BOBA_FLAMEDURATION;
+
+		TIMER_Set( self, "flameTime",			BOBA_FLAMEDURATION);
+		TIMER_Set( self, "nextAttackDelay",		BOBA_FLAMEDURATION);
+		TIMER_Set( self, "nextFlameDelay",		BOBA_FLAMEDURATION*2);
+		TIMER_Set( self, "Boba_TacticsSelect",	BOBA_FLAMEDURATION);
+
+		G_SoundOnEnt( self, CHAN_WEAPON, "sound/weapons/boba/bf_flame.mp3" );
+		G_PlayEffect( G_EffectIndex("boba/fthrw"), self->playerModel, self->genericBolt3, self->s.number, self->s.origin, 1 );
+
+		Boba_Printf("FlameThrower ON");
+	}
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// 
+////////////////////////////////////////////////////////////////////////////////////////
+void Boba_DoFlameThrower( gentity_t *self )
+{
+	if (!(NPCInfo->aiFlags&NPCAI_FLAMETHROW) && TIMER_Done(self, "nextAttackDelay"))
+	{
+		Boba_StartFlameThrower( self );
+	}
+
+	if ( (NPCInfo->aiFlags&NPCAI_FLAMETHROW))
+	{
+		Boba_FireFlameThrower( self );
+	}
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// 
+////////////////////////////////////////////////////////////////////////////////////////
+void		Boba_DoAmbushWait( gentity_t *self)
+{
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// 
+////////////////////////////////////////////////////////////////////////////////////////
+void		Boba_DoSniper( gentity_t *self)
+{
+	if (TIMER_Done(NPC, "PickNewSniperPoint"))
+	{
+		TIMER_Set(NPC, "PickNewSniperPoint", Q_irand(15000, 25000));
+ 		int		SniperPoint = NPC_FindCombatPoint(NPC->currentOrigin, 0, NPC->currentOrigin, CP_SNIPE|CP_CLEAR|CP_HAS_ROUTE|CP_TRYFAR|CP_HORZ_DIST_COLL, 0, -1);
+		if (SniperPoint!=-1)
+		{
+			NPC_SetCombatPoint(SniperPoint);
+			NPC_SetMoveGoal( NPC, level.combatPoints[SniperPoint].origin, 20, qtrue, SniperPoint );
+		}
+	}
+
+    if (Distance(NPC->currentOrigin, level.combatPoints[NPCInfo->combatPoint].origin)<50.0f)
+	{
+		Boba_FireDecide();
+	}
+
+
+	bool	IsOnAPath = !!NPC_MoveToGoal(qtrue);
+
+	// Resolve Blocked Problems
+	//--------------------------
+	if (NPCInfo->aiFlags&NPCAI_BLOCKED && 
+		NPC->client->moveType!=MT_FLYSWIM && 
+		((level.time - NPCInfo->blockedDebounceTime)>3000)
+		)
+	{
+		Boba_Printf("BLOCKED: Attempting Jump");
+		if (IsOnAPath)
+		{
+			if (!NPC_TryJump(NPCInfo->blockedTargetPosition))
+			{
+				Boba_Printf("  Failed");
+			}
+		}
+	}
+
+	NPC_FaceEnemy(qtrue);
+	NPC_UpdateAngles( qtrue, qtrue );
+}
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Call This function to make Boba actually shoot his current weapon
+////////////////////////////////////////////////////////////////////////////////////////
+void	Boba_Fire()
+{
+	WeaponThink(qtrue);
+
+	// If Actually Fired, Decide To Apply Alt Fire And Calc Next Attack Delay
+	//------------------------------------------------------------------------
+	if (ucmd.buttons&BUTTON_ATTACK)
+	{
+		switch (NPC->s.weapon)
+		{
+		case WP_ROCKET_LAUNCHER:
+			TIMER_Set( NPC, "nextAttackDelay", Q_irand(1000, 2000));
+
+			// Occasionally Shoot A Homing Missile
+			//-------------------------------------
+			if (!Q_irand(0,3))
+			{
+				ucmd.buttons &= ~BUTTON_ATTACK;
+				ucmd.buttons |=  BUTTON_ALT_ATTACK;
+				NPC->client->fireDelay = Q_irand( 1000, 3000 );
+			}
+			break;
+
+		case WP_DISRUPTOR:
+			TIMER_Set(NPC, "nextAttackDelay", Q_irand(1000, 4000));
+
+			// Occasionally Alt-Fire
+			//-----------------------
+			if (!Q_irand(0,3))
+			{
+				ucmd.buttons &= ~BUTTON_ATTACK;
+				ucmd.buttons |=  BUTTON_ALT_ATTACK;
+				NPC->client->fireDelay = Q_irand( 1000, 3000 );
+			}
+			break;
+
+		case WP_BLASTER:
+
+			if (TIMER_Done(NPC, "nextBlasterAltFireDecide"))
+			{
+ 			 	if (Q_irand(0, (NPC->count*2)+3)>2)
+				{
+			 		TIMER_Set(NPC, "nextBlasterAltFireDecide", Q_irand(3000, 8000));
+					if (!(NPCInfo->scriptFlags&SCF_ALT_FIRE))
+					{
+						Boba_Printf("ALT FIRE On");
+						NPCInfo->scriptFlags |= SCF_ALT_FIRE;
+						NPC_ChangeWeapon(WP_BLASTER);			// Update Delay Timers
+					}
+				}
+				else
+				{
+					TIMER_Set(NPC, "nextBlasterAltFireDecide", Q_irand(2000, 5000));
+					if ( (NPCInfo->scriptFlags&SCF_ALT_FIRE))
+					{
+						Boba_Printf("ALT FIRE Off");
+						NPCInfo->scriptFlags &=~SCF_ALT_FIRE;
+						NPC_ChangeWeapon(WP_BLASTER);			// Update Delay Timers
+					}
+				}
+			}
+
+			// Occasionally Alt Fire
+			//-----------------------
+			if (NPCInfo->scriptFlags&SCF_ALT_FIRE)
+			{
+				ucmd.buttons &= ~BUTTON_ATTACK;
+				ucmd.buttons |=  BUTTON_ALT_ATTACK;
+			}
+			break;
+		}
+	}
+}
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Call this function to see if Fett should fire his current weapon
+////////////////////////////////////////////////////////////////////////////////////////
+void Boba_FireDecide( void )
+{
+	// Any Reason Not To Shoot?
+	//--------------------------
+	if (!NPC ||											// Only NPCs
+		!NPC->client ||									// Only Clients
+		 NPC->client->NPC_class!=CLASS_BOBAFETT ||		// Only Boba
+		!NPC->enemy ||									// Only If There Is An Enemy
+		 NPC->s.weapon==WP_NONE ||						// Only If Using A Valid Weapon
+		!TIMER_Done(NPC, "nextAttackDelay") ||			// Only If Ready To Shoot Again
+		!Boba_CanSeeEnemy(NPC)							// Only If Enemy Recently Seen
+		)
+	{
+		return;
+	}
+
+	// Now Check Weapon Specific Parameters To See If We Should Shoot Or Not
+	//-----------------------------------------------------------------------
+	switch (NPC->s.weapon)
+	{
+	case WP_ROCKET_LAUNCHER:
+		if (Distance(NPC->currentOrigin, NPC->enemy->currentOrigin)>400.0f)
+		{
+			Boba_Fire();
+		}
+		break;
+
+	case WP_DISRUPTOR:
+		// TODO: Add Conditions Here
+		Boba_Fire();
+		break;
+
+	case WP_BLASTER:
+		// TODO: Add Conditions Here
+		Boba_Fire();
+		break;
+	}
+}
+
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Tactics avaliable to Boba Fett:
+// --------------------------------
+//	BTS_RIFLE,			// Uses Jedi / Seeker Movement
+//	BTS_MISSILE,		// Uses Jedi / Seeker Movement
+//	BTS_SNIPER,			// Uses Special Movement Internal To This File
+//	BTS_FLAMETHROW,		// Locked In Place
+//	BTS_AMBUSHWAIT,		// Goto CP & Wait
+//
+//
+// Weapons available to Boba Fett:
+// --------------------------------
+//	WP_NONE   (Flame Thrower)
+//	WP_ROCKET_LAUNCHER
+//	WP_BLASTER
+//	WP_DISRUPTOR
+//  
+////////////////////////////////////////////////////////////////////////////////////////
+void	Boba_TacticsSelect()
+{
+	// Don't Change Tactics For A Little While
+	//------------------------------------------
+	TIMER_Set(NPC, "Boba_TacticsSelect", Q_irand(8000, 15000));
+	int		nextState = NPCInfo->localState;
+
+
+	// Get Some Data That Will Help With The Selection Of The Next Tactic
+	//--------------------------------------------------------------------
+	bool	enemyAlive			= (NPC->enemy->health>0);
+	float	enemyDistance		= Distance(NPC->currentOrigin, NPC->enemy->currentOrigin);
+	bool	enemyInFlameRange	= (enemyDistance<BOBA_FLAMETHROWRANGE);
+	bool	enemyInRocketRange	= (enemyDistance>BOBA_ROCKETRANGEMIN && enemyDistance<BOBA_ROCKETRANGEMAX);
+	bool	enemyRecentlySeen	= Boba_CanSeeEnemy(NPC);
+
+
+	// Enemy Is Really Close
+	//-----------------------
+	if (!enemyAlive)
+	{
+		nextState = BTS_RIFLE;
+	}
+	else if (enemyInFlameRange)
+	{
+		// If It's Been Long Enough Since Our Last Flame Blast, Try To Torch The Enemy
+		//-----------------------------------------------------------------------------
+		if (TIMER_Done(NPC, "nextFlameDelay"))
+		{
+			nextState = BTS_FLAMETHROW;
+		}
+
+		// Otherwise, He's Probably Too Close, So Try To Get Clear Of Him
+		//----------------------------------------------------------------
+		else
+		{
+			nextState = BTS_RIFLE;
+		}
+	}
+
+	// Recently Saw The Enemy, Time For Some Good Ole Fighten!
+	//---------------------------------------------------------
+	else if (enemyRecentlySeen)
+	{
+		// At First, Boba will prefer to use his blaster against the player, but
+		//  the more times he is driven away (NPC->count), he will be less likely to
+		//  choose the blaster, and more likely to go for the missile launcher
+		nextState = (!enemyInRocketRange || Q_irand(0, NPC->count)<1)?(BTS_RIFLE):(BTS_MISSILE);
+	}
+
+	// Hmmm...  Havn't Seen The Player In A While, We Might Want To Try Something Sneaky
+	//-----------------------------------------------------------------------------------
+	else
+	{
+		bool	SnipePointsNear = false;		 // TODO
+		bool	AmbushPointNear = false;		 // TODO
+
+		if (Q_irand(0, NPC->count)>0)
+		{
+			int		SniperPoint = NPC_FindCombatPoint(NPC->currentOrigin, 0, NPC->currentOrigin, CP_SNIPE|CP_CLEAR|CP_HAS_ROUTE|CP_TRYFAR|CP_HORZ_DIST_COLL, 0, -1);
+			if (SniperPoint!=-1)
+			{
+				NPC_SetCombatPoint(SniperPoint);
+				NPC_SetMoveGoal( NPC, level.combatPoints[SniperPoint].origin, 20, qtrue, SniperPoint );
+				TIMER_Set(NPC, "PickNewSniperPoint", Q_irand(15000, 25000));
+				SnipePointsNear = true;
+			}
+		}
+
+
+ 		if (SnipePointsNear && TIMER_Done(NPC, "Boba_NoSniperTime"))
+		{
+			TIMER_Set(NPC, "Boba_NoSniperTime", 120000);				// Don't snipe again for a while
+			TIMER_Set(NPC, "Boba_TacticsSelect", Q_irand(35000, 45000));// More patience here
+			nextState = BTS_SNIPER;
+		}
+		else if (AmbushPointNear)
+		{
+			TIMER_Set(NPC, "Boba_TacticsSelect", Q_irand(15000, 25000));// More patience here
+			nextState = BTS_AMBUSHWAIT;
+		}
+		else
+		{
+			nextState = (!enemyInRocketRange || Q_irand(0, NPC->count)<1)?(BTS_RIFLE):(BTS_MISSILE);
+		}
+	}
+
+
+
+	// The Next State Has Been Selected, Now Change Weapon If Necessary 
+	//------------------------------------------------------------------
+	if (nextState!=NPCInfo->localState)
+	{
+		NPCInfo->localState = nextState;
+		switch (NPCInfo->localState)
+		{
+		case BTS_FLAMETHROW:
+			Boba_Printf("NEW TACTIC: Flame Thrower");
+			Boba_ChangeWeapon(WP_NONE);
+			Boba_DoFlameThrower(NPC);
+			break;
+
+		case BTS_RIFLE:
+			Boba_Printf("NEW TACTIC: Rifle");
+			Boba_ChangeWeapon(WP_BLASTER);
+			break;
+
+		case BTS_MISSILE:
+			Boba_Printf("NEW TACTIC: Rocket Launcher");
+			Boba_ChangeWeapon(WP_ROCKET_LAUNCHER);
+			break;
+
+		case BTS_SNIPER:
+			Boba_Printf("NEW TACTIC: Sniper");
+			Boba_ChangeWeapon(WP_DISRUPTOR);
+			break;
+
+		case BTS_AMBUSHWAIT:
+			Boba_Printf("NEW TACTIC: Ambush");
+			Boba_ChangeWeapon(WP_NONE);
+			break;
+		}
+	}
+}
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Tactics
+//
+// This function is called right after Update()
+// If returns true, Jedi and Seeker AI not used for movement
+//
+////////////////////////////////////////////////////////////////////////////////////////
+bool	Boba_Tactics()
+{
+	if (!NPC->enemy)
+	{
+		return false;
+	}
+
+	// Think About Changing Tactics
+	//------------------------------
+	if (TIMER_Done(NPC, "Boba_TacticsSelect"))
+	{
+		Boba_TacticsSelect();
+	}
+
+	// These Tactics Require Seeker & Jedi Movement
+	//----------------------------------------------
+	if (!NPCInfo->localState ||
+		 NPCInfo->localState==BTS_RIFLE || 
+		 NPCInfo->localState==BTS_MISSILE)
+	{
+		return false;
+	}
+
+	// Flame Thrower - Locked In Place
+	//---------------------------------
+	if (NPCInfo->localState==BTS_FLAMETHROW)
+	{
+		Boba_DoFlameThrower( NPC );
+	}
+
+	// Sniper - Move Around, And Take Shots
+	//--------------------------------------
+	else if (NPCInfo->localState==BTS_SNIPER)
+	{
+		Boba_DoSniper( NPC );
+	}
+
+	// Ambush Wait
+	//------------
+	else if (NPCInfo->localState==BTS_AMBUSHWAIT)
+	{
+		Boba_DoAmbushWait( NPC );
+	}
+
+
+	NPC_FacePosition( NPC->enemy->currentOrigin, qtrue);
+	NPC_UpdateAngles(qtrue, qtrue);
+
+	return true;			// Do Not Use Normal Jedi Or Seeker Movement
+}
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// 
+////////////////////////////////////////////////////////////////////////////////////////
+bool	Boba_Respawn()
+{
+	int cp = -1;
+
+	// Try To Predict Where The Enemy Is Going
+	//-----------------------------------------
+	if (AverageEnemyDirectionSamples && NPC->behaviorSet[BSET_DEATH]==0)
+	{
+		vec3_t	endPos;
+	 	VectorMA(NPC->enemy->currentOrigin, 1000.0f / (float)AverageEnemyDirectionSamples, AverageEnemyDirection, endPos);
+		cp = NPC_FindCombatPoint(endPos, 0, endPos, CP_FLEE|CP_TRYFAR|CP_HORZ_DIST_COLL, 0, -1);
+		Boba_Printf("Attempting Predictive Spawn Point");
+	}
+
+	// If That Failed, Try To Go Directly To The Enemy
+	//-------------------------------------------------
+	if (cp==-1)
+	{
+		cp = NPC_FindCombatPoint(NPC->enemy->currentOrigin, 0, NPC->enemy->currentOrigin, CP_FLEE|CP_TRYFAR|CP_HORZ_DIST_COLL, 0, -1);
+		Boba_Printf("Attempting Closest Current Spawn Point");
+	}
+
+	// If We've Found One, Go There
+	//------------------------------
+	if (cp!=-1)
+	{
+		NPC_SetCombatPoint( cp );
+		NPCInfo->surrenderTime = 0;
+		NPC->health = NPC->max_health;
+		NPC->svFlags &=~SVF_NOCLIENT;
+		NPC->count ++;										// This is the number of times spawned
+		G_SetOrigin(NPC, level.combatPoints[cp].origin);
+
+		AverageEnemyDirectionSamples = 0;
+		VectorClear(AverageEnemyDirection);
+
+		Boba_Printf("Found Spawn Point (%d)", cp);
+		return true;
+	}
+
+	assert(0);	// Yea, that's bad...
+	Boba_Printf("FAILED TO FIND SPAWN POINT");
+	return false;
+}
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// 
+////////////////////////////////////////////////////////////////////////////////////////
+void	Boba_Update()
+{
+	// Never Forget The Player... Never.
+	//-----------------------------------
+	if (player && player->inuse && !NPC->enemy)
+	{
+		G_SetEnemy(NPC, player);
+		NPC->svFlags				|= SVF_LOCKEDENEMY;	// Don't forget about the enemy once you've found him
+	}
+
+	// Hey, This Is Boba, He Tests The Trace All The Time
+	//----------------------------------------------------
+	if (NPC->enemy)
+	{
+		if (!(NPC->svFlags&SVF_NOCLIENT))
+		{
+			trace_t		testTrace;
+			vec3_t		eyes;
+			CalcEntitySpot( NPC, SPOT_HEAD_LEAN, eyes );
+			gi.trace (&testTrace, eyes, NULL, NULL, NPC->enemy->currentOrigin, NPC->s.number, MASK_SHOT);
+
+			bool	wasSeen = Boba_CanSeeEnemy(NPC);
+
+			if (!testTrace.startsolid && 
+				!testTrace.allsolid && 
+				testTrace.entityNum == NPC->enemy->s.number)
+			{
+				NPCInfo->enemyLastSeenTime	= level.time;
+				NPCInfo->enemyLastHeardTime	= level.time;
+				VectorCopy(NPC->enemy->currentOrigin, NPCInfo->enemyLastSeenLocation);
+				VectorCopy(NPC->enemy->currentOrigin, NPCInfo->enemyLastHeardLocation);
+			}
+			else if (gi.inPVS( NPC->enemy->currentOrigin, NPC->currentOrigin))
+			{
+				NPCInfo->enemyLastHeardTime	= level.time;
+				VectorCopy(NPC->enemy->currentOrigin, NPCInfo->enemyLastHeardLocation);
+			}
+
+			if (g_bobaDebug->integer)
+			{
+				bool	nowSeen = Boba_CanSeeEnemy(NPC);
+				if (!wasSeen && nowSeen)
+				{
+					Boba_Printf("Enemy Seen");
+				}
+				if (wasSeen && !nowSeen)
+				{
+					Boba_Printf("Enemy Lost");
+				}
+				CG_DrawEdge(NPC->currentOrigin, NPC->enemy->currentOrigin, (nowSeen)?(EDGE_IMPACT_SAFE):(EDGE_IMPACT_POSSIBLE));
+			}
+		}
+
+		if (!NPCInfo->surrenderTime)
+		{
+			if ((level.time - NPCInfo->enemyLastSeenTime)>20000 && TIMER_Done(NPC, "TooLongGoneRespawn"))
+			{
+				TIMER_Set(NPC, "TooLongGoneRespawn", 30000);	// Give him some time to get to you before trying again
+				Boba_Printf("Gone Too Long, Attempting Respawn Even Though Not Hiding");
+				Boba_Respawn();
+			}
+		}
+	}
+
+
+	// Make Sure He Always Appears In The Last Area With Full Health When His Death Script Is Turned On
+	//--------------------------------------------------------------------------------------------------
+	if (!BobaHadDeathScript && NPC->behaviorSet[BSET_DEATH]!=0)
+	{
+		if (!gi.inPVS(NPC->enemy->currentOrigin, NPC->currentOrigin))
+		{
+			Boba_Printf("Attempting Final Battle Spawn...");
+			if (Boba_Respawn())
+			{
+				BobaHadDeathScript = true;
+			}
+			else
+			{
+				Boba_Printf("Failed");
+			}
+		}
+	}
+
+
+
+	// Don't Forget To Turn Off That Flame Thrower, Mr. Fett - You're Waisting Precious Natural Gases
+	//------------------------------------------------------------------------------------------------
+	if ((NPCInfo->aiFlags&NPCAI_FLAMETHROW) && (TIMER_Done(NPC, "flameTime")))
+	{
+		Boba_StopFlameThrower(NPC);
+	}
+
+
+	// Occasionally A Jump Turns Into A Rocket Fly
+	//---------------------------------------------
+	if ( NPC->client->ps.groundEntityNum == ENTITYNUM_NONE 
+		&& NPC->client->ps.forceJumpZStart
+		&& !Q_irand( 0, 10 ) )
+	{//take off
+		Boba_FlyStart( NPC );
+	}
+
+
+	// If Hurting, Try To Run Away
+	//-----------------------------
+	if (!NPCInfo->surrenderTime && (NPC->health<NPC->max_health/10))
+	{
+		Boba_Printf("Time To Surrender, Searching For Flee Point");
+
+
+		// Find The Closest Flee Point That I Can Get To
+		//-----------------------------------------------
+		int cp = NPC_FindCombatPoint(NPC->currentOrigin, 0, NPC->currentOrigin, CP_FLEE|CP_HAS_ROUTE|CP_TRYFAR|CP_HORZ_DIST_COLL, 0, -1);
+		if (cp!=-1)
+		{
+			NPC_SetCombatPoint( cp );
+			NPC_SetMoveGoal( NPC, level.combatPoints[cp].origin, 8, qtrue, cp );
+			if (NPC->count<6)
+			{
+ 	 		 	NPCInfo->surrenderTime = level.time + Q_irand(5000, 10000) + 1000*(6-NPC->count);
+			}
+			else
+			{
+ 	 			NPCInfo->surrenderTime = level.time + Q_irand(5000, 10000);
+			}
+		}
+		else
+		{
+			Boba_Printf("  Failure");
+		}
+	}
+}
+
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// 
+////////////////////////////////////////////////////////////////////////////////////////
+bool	Boba_Flee()
+{
+	bool	EnemyRecentlySeen	= ((level.time - NPCInfo->enemyLastSeenTime)<10000);
+	bool	ReachedEscapePoint	= (Distance(level.combatPoints[NPCInfo->combatPoint].origin, NPC->currentOrigin)<50.0f);
+	bool	HasBeenGoneEnough	= (level.time>NPCInfo->surrenderTime || (level.time - NPCInfo->enemyLastSeenTime)>400000);
+
+
+	// Is It Time To Come Back For Some More?
+	//----------------------------------------
+ 	if (!EnemyRecentlySeen || ReachedEscapePoint)
+	{
+		NPC->svFlags |= SVF_NOCLIENT;
+		if (HasBeenGoneEnough)
+		{
+			if ((level.time - NPCInfo->enemyLastSeenTime)>400000)
+			{
+				Boba_Printf("  Gone Too Long, Attempting Respawn");
+			}
+
+			if (Boba_Respawn())
+			{
+				return true;
+			}
+		}
+	  	else if (ReachedEscapePoint && (NPCInfo->surrenderTime - level.time)>3000)
+		{
+ 			if (TIMER_Done(NPC, "SpookPlayerTimer"))
+			{
+				vec3_t		testDirection;
+				TIMER_Set(NPC, "SpookPlayerTimer", Q_irand(2000, 10000));
+				switch(Q_irand(0, 1))
+				{
+				case 0:
+					Boba_Printf("SPOOK: Dust");
+					Boba_DustFallNear(NPC->enemy->currentOrigin, Q_irand(1,2));
+					break;
+
+				case 1:
+					Boba_Printf("SPOOK: Footsteps");
+  					testDirection[0] =  (random() * 0.5f) - 1.0f;
+	 		 		testDirection[0] += (testDirection[0]>0.0f)?(0.5f):(-0.5f);
+					testDirection[1] = (random() * 0.5f) - 1.0f;
+					testDirection[1] += (testDirection[1]>0.0f)?(0.5f):(-0.5f);
+					testDirection[2] = 1.0f;
+		 	 		VectorMA(NPC->enemy->currentOrigin, 400.0f, testDirection, BobaFootStepLoc);
+
+					BobaFootStepCount = Q_irand(3,8);
+					break;
+				}
+			}
+
+			if (BobaFootStepCount && TIMER_Done(NPC, "BobaFootStepFakeTimer"))
+			{
+				TIMER_Set(NPC, "BobaFootStepFakeTimer", Q_irand(300, 800));
+				BobaFootStepCount --;
+				G_SoundAtSpot(BobaFootStepLoc, G_SoundIndex(va("sound/player/footsteps/boot%d", Q_irand(1,4))), qtrue);
+			}
+
+		 	if (TIMER_Done(NPC, "ResampleEnemyDirection") && NPC->enemy->resultspeed>10.0f)
+			{
+				TIMER_Set(NPC, "ResampleEnemyDirection", Q_irand(500, 1000));
+				AverageEnemyDirectionSamples ++;
+
+				vec3_t	moveDir;
+				VectorCopy(NPC->enemy->client->ps.velocity, moveDir);
+				VectorNormalize(moveDir);
+
+				VectorAdd(AverageEnemyDirection, moveDir, AverageEnemyDirection);
+			}
+
+	 		if (g_bobaDebug->integer && AverageEnemyDirectionSamples)
+			{
+				vec3_t	endPos;
+				VectorMA(NPC->enemy->currentOrigin, 500.0f / (float)AverageEnemyDirectionSamples, AverageEnemyDirection, endPos);
+				CG_DrawEdge(NPC->enemy->currentOrigin, endPos, EDGE_IMPACT_POSSIBLE);
+			}
+		}
+	}
+	else
+	{
+		NPCInfo->surrenderTime += 100;
+	}
+
+	// Finish The Flame Thrower First...
+	//-----------------------------------
+	if (NPCInfo->aiFlags&NPCAI_FLAMETHROW)
+	{
+		Boba_DoFlameThrower( NPC );
+		NPC_FacePosition( NPC->enemy->currentOrigin, qtrue);
+		NPC_UpdateAngles(qtrue, qtrue);
+		return true;
+	}
+
+	bool	IsOnAPath = !!NPC_MoveToGoal(qtrue);
+	if (!ReachedEscapePoint &&
+		NPCInfo->aiFlags&NPCAI_BLOCKED && 
+		NPC->client->moveType!=MT_FLYSWIM && 
+		((level.time - NPCInfo->blockedDebounceTime)>1000)
+		)
+	{
+		if (!Boba_CanSeeEnemy(NPC) && Distance(NPC->currentOrigin, level.combatPoints[NPCInfo->combatPoint].origin)<200)
+		{
+			Boba_Printf("BLOCKED: Just Teleporting There");
+			G_SetOrigin(NPC, level.combatPoints[NPCInfo->combatPoint].origin);
+		}
+		else
+		{
+			Boba_Printf("BLOCKED: Attempting Jump");
+
+			if (IsOnAPath)
+			{
+				if (NPC_TryJump(NPCInfo->blockedTargetPosition))
+				{
+				}
+				else
+				{
+					Boba_Printf("  Failed");
+				}
+			}
+			else if (EnemyRecentlySeen)
+			{
+				if (NPC_TryJump(NPCInfo->enemyLastSeenLocation))
+				{
+	 			}
+				else
+				{
+					Boba_Printf("  Failed");
+				}
+			}
+		}
+	}
+
+
+	NPC_UpdateAngles( qtrue, qtrue );
+	return true;
+}
\ No newline at end of file
diff --git a/code/game/AI_Civilian.cpp b/code/game/AI_Civilian.cpp
new file mode 100644
index 0000000..4715ef7
--- /dev/null
+++ b/code/game/AI_Civilian.cpp
@@ -0,0 +1,43 @@
+// leave this line at the top of all AI_xxxx.cpp files for PCH reasons...
+#include "g_headers.h"
+#include "Q3_Interface.h"
+
+extern qboolean NPC_CheckSurrender( void );
+extern void NPC_BehaviorSet_Default( int bState );
+
+void NPC_BSCivilian_Default( int bState )
+{
+	if ( NPC->enemy
+		&& NPC->s.weapon == WP_NONE 
+		&& NPC_CheckSurrender() )
+	{//surrendering, do nothing
+	}
+	else if ( NPC->enemy 
+		&& NPC->s.weapon == WP_NONE 
+		&& bState != BS_HUNT_AND_KILL 
+		&& !Q3_TaskIDPending( NPC, TID_MOVE_NAV ) )
+	{//if in battle and have no weapon, run away, fixme: when in BS_HUNT_AND_KILL, they just stand there
+		if ( !NPCInfo->goalEntity
+			|| bState != BS_FLEE //not fleeing
+			|| ( NPC_BSFlee()//have reached our flee goal
+				&& NPC->enemy//still have enemy (NPC_BSFlee checks enemy and can clear it)
+				&& DistanceSquared( NPC->currentOrigin, NPC->enemy->currentOrigin ) < 16384 )//enemy within 128
+			)
+		{//run away!
+			NPC_StartFlee( NPC->enemy, NPC->enemy->currentOrigin, AEL_DANGER_GREAT, 5000, 10000 );
+		}
+	}
+	else
+	{//not surrendering
+		//FIXME: if unarmed and a jawa/ugnuaght, constantly look for enemies/players to run away from?
+		//FIXME: if we have a weapon and an enemy, set out playerTeam to the opposite of our enemy..???
+		NPC_BehaviorSet_Default(bState);
+	}
+	if ( !VectorCompare( NPC->client->ps.moveDir, vec3_origin ) )
+	{//moving
+		if ( NPC->client->ps.legsAnim == BOTH_COWER1 )
+		{//stop cowering anim on legs
+			NPC->client->ps.legsAnimTimer = 0;
+		}
+	}
+}
\ No newline at end of file
diff --git a/code/game/AI_Default.cpp b/code/game/AI_Default.cpp
new file mode 100644
index 0000000..67a4dba
--- /dev/null
+++ b/code/game/AI_Default.cpp
@@ -0,0 +1,958 @@
+#include "g_headers.h"
+
+#include "Q3_Interface.h"
+
+//#include "anims.h"
+//extern int PM_AnimLength( int index, animNumber_t anim );
+//extern qboolean PM_HasAnimation( gentity_t *ent, int animation );
+//extern int PM_AnimLength( int index, animNumber_t anim );
+//#define	MAX_IDLE_ANIMS	8
+extern int g_crosshairEntNum;
+
+/*
+void NPC_LostEnemyDecideChase(void)
+
+  We lost our enemy and want to drop him but see if we should chase him if we are in the proper bState
+*/
+
+void NPC_LostEnemyDecideChase(void)
+{
+	switch( NPCInfo->behaviorState )
+	{
+	case BS_HUNT_AND_KILL:
+		//We were chasing him and lost him, so try to find him
+		if ( NPC->enemy == NPCInfo->goalEntity && NPC->enemy->lastWaypoint != WAYPOINT_NONE )
+		{//Remember his last valid Wp, then check it out
+			//FIXME: Should we only do this if there's no other enemies or we've got LOCKED_ENEMY on?
+			NPC_BSSearchStart( NPC->enemy->lastWaypoint, BS_SEARCH );
+		}
+		//If he's not our goalEntity, we're running somewhere else, so lose him
+		break;
+	default:
+		break;
+	}
+	G_ClearEnemy( NPC );
+}
+/*
+-------------------------
+NPC_StandIdle
+-------------------------
+*/
+
+void NPC_StandIdle( void )
+{
+/*
+	//Must be done with any other animations
+	if ( NPC->client->ps.legsAnimTimer != 0 )
+		return;
+
+	//Not ready to do another one
+	if ( TIMER_Done( NPC, "idleAnim" ) == false )
+		return;
+
+	int anim = NPC->client->ps.legsAnim;
+
+	if ( anim != BOTH_STAND1 && anim != BOTH_STAND2 )
+		return;
+
+	//FIXME: Account for STAND1 or STAND2 here and set the base anim accordingly
+	int	baseSeq = ( anim == BOTH_STAND1 ) ? BOTH_STAND1_RANDOM1 : BOTH_STAND2_RANDOM1;
+
+	//Must have at least one random idle animation
+	//NOTENOTE: This relies on proper ordering of animations, which SHOULD be okay
+	if ( PM_HasAnimation( NPC, baseSeq ) == false )
+		return;
+
+	int	newIdle = Q_irand( 0, MAX_IDLE_ANIMS-1 );
+
+	//FIXME: Technically this could never complete.. but that's not really too likely
+	while( 1 )
+	{
+		if ( PM_HasAnimation( NPC, baseSeq + newIdle ) )
+			break;
+
+		newIdle = Q_irand( 0, MAX_IDLE_ANIMS );
+	}
+	
+	//Start that animation going
+	NPC_SetAnim( NPC, SETANIM_BOTH, baseSeq + newIdle, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+	
+	int newTime = PM_AnimLength( NPC->client->clientInfo.animFileIndex, (animNumber_t) (baseSeq + newIdle) );
+
+	//Don't do this again for a random amount of time
+	TIMER_Set( NPC, "idleAnim", newTime + Q_irand( 2000, 10000 ) );
+*/
+}
+
+qboolean NPC_StandTrackAndShoot (gentity_t *NPC, qboolean canDuck)
+{
+	qboolean	attack_ok = qfalse;
+	qboolean	duck_ok = qfalse;
+	qboolean	faced = qfalse;
+	float		attack_scale = 1.0;
+
+	//First see if we're hurt bad- if so, duck
+	//FIXME: if even when ducked, we can shoot someone, we should.
+	//Maybe is can be shot even when ducked, we should run away to the nearest cover?
+	if ( canDuck )
+	{
+		if ( NPC->health < 20 )
+		{
+		//	if( NPC->svFlags&SVF_HEALING || random() )
+			if( random() )
+			{
+				duck_ok = qtrue;
+			}
+		}
+		else if ( NPC->health < 40 )
+		{
+//			if ( NPC->svFlags&SVF_HEALING )
+//			{//Medic is on the way, get down!
+//				duck_ok = qtrue;
+//			}
+			// no more borg
+///			if ( NPC->client->playerTeam!= TEAM_BORG )
+//			{//Borg don't care if they're about to die
+				//attack_scale will be a max of .66
+//				attack_scale = NPC->health/60;
+//			}
+		}
+	}
+
+	//NPC_CheckEnemy( qtrue, qfalse );
+
+	if ( !duck_ok )
+	{//made this whole part a function call
+		attack_ok = NPC_CheckCanAttack( attack_scale, qtrue );
+		faced = qtrue;
+	}
+
+	if ( canDuck && (duck_ok || (!attack_ok && client->fireDelay == 0)) && ucmd.upmove != -127 )
+	{//if we didn't attack check to duck if we're not already
+		if( !duck_ok )
+		{
+			if ( NPC->enemy->client )
+			{
+				if ( NPC->enemy->enemy == NPC )
+				{
+					if ( NPC->enemy->client->buttons & BUTTON_ATTACK )
+					{//FIXME: determine if enemy fire angles would hit me or get close
+						if ( NPC_CheckDefend( 1.0 ) )//FIXME: Check self-preservation?  Health?
+						{
+							duck_ok = qtrue;
+						}
+					}
+				}
+			}
+		}
+
+		if ( duck_ok )
+		{//duck and don't shoot
+			attack_ok = qfalse;
+			ucmd.upmove = -127;
+			NPCInfo->duckDebounceTime = level.time + 1000;//duck for a full second
+		}
+	}
+
+	return faced;
+}
+
+
+void NPC_BSIdle( void ) 
+{
+	//FIXME if there is no nav data, we need to do something else
+	// if we're stuck, try to move around it
+	if ( UpdateGoal() )
+	{
+		NPC_MoveToGoal( qtrue );
+	}
+
+	if ( ( ucmd.forwardmove == 0 ) && ( ucmd.rightmove == 0 ) && ( ucmd.upmove == 0 ) )
+	{
+//		NPC_StandIdle();
+	}
+
+	NPC_UpdateAngles( qtrue, qtrue );
+	ucmd.buttons |= BUTTON_WALKING;
+}
+
+void NPC_BSRun (void)
+{
+	//FIXME if there is no nav data, we need to do something else
+	// if we're stuck, try to move around it
+	if ( UpdateGoal() )
+	{
+		NPC_MoveToGoal( qtrue );
+	}
+
+	NPC_UpdateAngles( qtrue, qtrue );
+}
+
+void NPC_BSStandGuard (void)
+{
+	//FIXME: Use Snapshot info
+	if ( NPC->enemy == NULL )
+	{//Possible to pick one up by being shot
+		if( random() < 0.5 )
+		{
+			if(NPC->client->enemyTeam)
+			{
+				gentity_t *newenemy = NPC_PickEnemy(NPC, NPC->client->enemyTeam, (NPC->cantHitEnemyCounter < 10), (NPC->client->enemyTeam == TEAM_PLAYER), qtrue);
+				//only checks for vis if couldn't hit last enemy
+				if(newenemy)
+				{
+					G_SetEnemy( NPC, newenemy );
+				}
+			}
+		}
+	}
+
+	if ( NPC->enemy != NULL )
+	{
+		if( NPCInfo->tempBehavior == BS_STAND_GUARD )
+		{
+			NPCInfo->tempBehavior = BS_DEFAULT;
+		}
+		
+		if( NPCInfo->behaviorState == BS_STAND_GUARD )
+		{
+			NPCInfo->behaviorState = BS_STAND_AND_SHOOT;
+		}
+	}
+
+	NPC_UpdateAngles( qtrue, qtrue );
+}
+
+/*
+-------------------------
+NPC_BSHuntAndKill
+-------------------------
+*/
+
+void NPC_BSHuntAndKill( void )
+{
+	qboolean	turned = qfalse;
+	vec3_t		vec;
+	float		enemyDist;
+	visibility_t	oEVis;
+	int			curAnim;
+
+	NPC_CheckEnemy( NPCInfo->tempBehavior != BS_HUNT_AND_KILL, qfalse );//don't find new enemy if this is tempbehav
+
+	if ( NPC->enemy )
+	{
+		oEVis = enemyVisibility = NPC_CheckVisibility ( NPC->enemy, CHECK_FOV|CHECK_SHOOT );//CHECK_360|//CHECK_PVS|
+		if(enemyVisibility > VIS_PVS)
+		{
+			if ( !NPC_EnemyTooFar( NPC->enemy, 0, qtrue ) )
+			{//Enemy is close enough to shoot - FIXME: this next func does this also, but need to know here for info on whether ot not to turn later
+				NPC_CheckCanAttack( 1.0, qfalse );
+				turned = qtrue;
+			}
+		}
+
+		curAnim = NPC->client->ps.legsAnim;
+		if(curAnim != BOTH_ATTACK1 && curAnim != BOTH_ATTACK2 && curAnim != BOTH_ATTACK3 && curAnim != BOTH_MELEE1 && curAnim != BOTH_MELEE2 )
+		{//Don't move toward enemy if we're in a full-body attack anim
+			//FIXME, use IdealDistance to determin if we need to close distance
+			VectorSubtract(NPC->enemy->currentOrigin, NPC->currentOrigin, vec);
+			enemyDist = VectorLength(vec);
+			if( enemyDist > 48 && ((enemyDist*1.5)*(enemyDist*1.5) >= NPC_MaxDistSquaredForWeapon() ||
+				oEVis != VIS_SHOOT ||
+				//!(ucmd.buttons & BUTTON_ATTACK) || 
+				enemyDist > IdealDistance(NPC)*3 ) )
+			{//We should close in?
+				NPCInfo->goalEntity = NPC->enemy;
+
+				NPC_MoveToGoal( qtrue );
+			}
+			else if(enemyDist < IdealDistance(NPC))
+			{//We should back off?
+				//if(ucmd.buttons & BUTTON_ATTACK)
+				{
+					NPCInfo->goalEntity = NPC->enemy;
+					NPCInfo->goalRadius = 12;
+					NPC_MoveToGoal( qtrue );
+
+					ucmd.forwardmove *= -1;
+					ucmd.rightmove *= -1;
+					VectorScale( NPC->client->ps.moveDir, -1, NPC->client->ps.moveDir );
+
+					ucmd.buttons |= BUTTON_WALKING;
+				}
+			}//otherwise, stay where we are
+		}
+	}
+	else 
+	{//ok, stand guard until we find an enemy
+		if( NPCInfo->tempBehavior == BS_HUNT_AND_KILL )
+		{
+			NPCInfo->tempBehavior = BS_DEFAULT;
+		}
+		else
+		{
+			NPCInfo->tempBehavior = BS_STAND_GUARD;
+			NPC_BSStandGuard();
+		}
+		return;
+	}
+
+	if(!turned)
+	{
+		NPC_UpdateAngles(qtrue, qtrue);
+	}
+}
+
+void NPC_BSStandAndShoot (void)
+{
+	//FIXME:
+	//When our numbers outnumber enemies 3 to 1, or only one of them,
+	//go into hunt and kill mode
+
+	//FIXME:
+	//When they're all dead, go to some script or wander off to sickbay?
+	
+	if(NPC->client->playerTeam && NPC->client->enemyTeam)
+	{
+		//FIXME: don't realize this right away- or else enemies show up and we're standing around
+		/*
+		if( teamNumbers[NPC->enemyTeam] == 0 )
+		{//ok, stand guard until we find another enemy
+			//reset our rush counter
+			teamCounter[NPC->playerTeam] = 0;
+			NPCInfo->tempBehavior = BS_STAND_GUARD;
+			NPC_BSStandGuard();
+			return;
+		}*/
+		/*
+		//FIXME: whether to do this or not should be settable
+		else if( NPC->playerTeam != TEAM_BORG )//Borg don't rush
+		{
+		//FIXME: In case reinforcements show up, we should wait a few seconds
+		//and keep checking before rushing!
+		//Also: what if not everyone on our team is going after playerTeam?
+		//Also: our team count includes medics!
+			if(NPC->health > 25)
+			{//Can we rush the enemy?
+				if(teamNumbers[NPC->enemyTeam] == 1 ||
+					teamNumbers[NPC->playerTeam] >= teamNumbers[NPC->enemyTeam]*3)
+				{//Only one of them or we outnumber 3 to 1
+					if(teamStrength[NPC->playerTeam] >= 75 ||
+						(teamStrength[NPC->playerTeam] >= 50 && teamStrength[NPC->playerTeam] > teamStrength[NPC->enemyTeam]))
+					{//Our team is strong enough to rush
+						teamCounter[NPC->playerTeam]++;
+						if(teamNumbers[NPC->playerTeam] * 17 <= teamCounter[NPC->playerTeam])
+						{//ok, we waited 1.7 think cycles on average and everyone is go, let's do it!
+							//FIXME: Should we do this to everyone on our team?
+							NPCInfo->behaviorState = BS_HUNT_AND_KILL;
+							//FIXME: if the tide changes, we should retreat!
+							//FIXME: when do we reset the counter?
+							NPC_BSHuntAndKill ();
+							return;
+						}
+					}
+					else//Oops!  Something's wrong, reset the counter to rush
+						teamCounter[NPC->playerTeam] = 0;
+				}
+				else//Oops!  Something's wrong, reset the counter to rush
+					teamCounter[NPC->playerTeam] = 0;
+			}
+		}
+		*/
+	}
+
+	NPC_CheckEnemy(qtrue, qfalse);
+	
+	if(NPCInfo->duckDebounceTime > level.time && NPC->client->ps.weapon != WP_SABER )
+	{
+		ucmd.upmove = -127;
+		if(NPC->enemy)
+		{
+			NPC_CheckCanAttack(1.0, qtrue);
+		}
+		return;		
+	}
+
+	if(NPC->enemy)
+	{
+		if(!NPC_StandTrackAndShoot( NPC, qtrue ))
+		{//That func didn't update our angles
+			NPCInfo->desiredYaw = NPC->client->ps.viewangles[YAW];
+			NPCInfo->desiredPitch = NPC->client->ps.viewangles[PITCH];
+			NPC_UpdateAngles(qtrue, qtrue);
+		}
+	}
+	else
+	{
+		NPCInfo->desiredYaw = NPC->client->ps.viewangles[YAW];
+		NPCInfo->desiredPitch = NPC->client->ps.viewangles[PITCH];
+		NPC_UpdateAngles(qtrue, qtrue);
+//		NPC_BSIdle();//only moves if we have a goal
+	}
+}
+
+void NPC_BSRunAndShoot (void)
+{
+	/*if(NPC->playerTeam && NPC->enemyTeam)
+	{
+		//FIXME: don't realize this right away- or else enemies show up and we're standing around
+		if( teamNumbers[NPC->enemyTeam] == 0 )
+		{//ok, stand guard until we find another enemy
+			//reset our rush counter
+			teamCounter[NPC->playerTeam] = 0;
+			NPCInfo->tempBehavior = BS_STAND_GUARD;
+			NPC_BSStandGuard();
+			return;
+		}
+	}*/
+
+	//NOTE: are we sure we want ALL run and shoot people to move this way?
+	//Shouldn't it check to see if we have an enemy and our enemy is our goal?!
+	//Moved that check into NPC_MoveToGoal
+	//NPCInfo->combatMove = qtrue;
+
+	NPC_CheckEnemy( qtrue, qfalse );
+	
+	if ( NPCInfo->duckDebounceTime > level.time ) // && NPCInfo->hidingGoal )
+	{
+		ucmd.upmove = -127;
+		if ( NPC->enemy )
+		{
+			NPC_CheckCanAttack( 1.0, qfalse );
+		}
+		return;		
+	}
+
+	if ( NPC->enemy )
+	{
+		int monitor = NPC->cantHitEnemyCounter;
+		NPC_StandTrackAndShoot( NPC, qfalse );//(NPCInfo->hidingGoal != NULL) );
+
+		if ( !(ucmd.buttons & BUTTON_ATTACK) && ucmd.upmove >= 0 && NPC->cantHitEnemyCounter > monitor )
+		{//not crouching and not firing
+			vec3_t	vec;
+
+			VectorSubtract( NPC->enemy->currentOrigin, NPC->currentOrigin, vec );
+			vec[2] = 0;
+			if ( VectorLength( vec ) > 128 || NPC->cantHitEnemyCounter >= 10 )
+			{//run at enemy if too far away
+				//The cantHitEnemyCounter getting high has other repercussions
+				//100 (10 seconds) will make you try to pick a new enemy... 
+				//But we're chasing, so we clamp it at 50 here
+				if ( NPC->cantHitEnemyCounter > 60 )
+				{
+					NPC->cantHitEnemyCounter = 60;
+				}
+				
+				if ( NPC->cantHitEnemyCounter >= (NPCInfo->stats.aggression+1) * 10 )
+				{
+					NPC_LostEnemyDecideChase();
+				}
+
+				//chase and face
+				ucmd.angles[YAW] = 0;
+				ucmd.angles[PITCH] = 0;
+				NPCInfo->goalEntity = NPC->enemy;
+				NPCInfo->goalRadius = 12;
+				NPC_MoveToGoal( qtrue );
+				NPC_UpdateAngles(qtrue, qtrue);
+			}
+			else
+			{
+				//FIXME: this could happen if they're just on the other side
+				//of a thin wall or something else blocking out shot.  That
+				//would make us just stand there and not go around it...
+				//but maybe it's okay- might look like we're waiting for
+				//him to come out...?  
+				//Current solution: runs around if cantHitEnemyCounter gets
+				//to 10 (1 second).  
+			}
+		}
+		else
+		{//Clear the can't hit enemy counter here
+			NPC->cantHitEnemyCounter = 0;
+		}
+	}
+	else
+	{
+		if ( NPCInfo->tempBehavior == BS_HUNT_AND_KILL )
+		{//lost him, go back to what we were doing before
+			NPCInfo->tempBehavior = BS_DEFAULT;
+			return;
+		}
+
+//		NPC_BSRun();//only moves if we have a goal
+	}
+}
+
+//Simply turn until facing desired angles
+void NPC_BSFace (void)
+{
+	//FIXME: once you stop sending turning info, they reset to whatever their delta_angles was last????
+	//Once this is over, it snaps back to what it was facing before- WHY???
+	if( NPC_UpdateAngles ( qtrue, qtrue ) )
+	{
+		Q3_TaskIDComplete( NPC, TID_BSTATE );
+		
+		NPCInfo->desiredYaw = client->ps.viewangles[YAW];
+		NPCInfo->desiredPitch = client->ps.viewangles[PITCH];
+
+		NPCInfo->aimTime = 0;//ok to turn normally now
+	}
+}
+
+void NPC_BSPointShoot (qboolean shoot)
+{//FIXME: doesn't check for clear shot...
+	vec3_t	muzzle, dir, angles, org;
+
+	if ( !NPC->enemy || !NPC->enemy->inuse || (NPC->enemy->NPC && NPC->enemy->health <= 0) )
+	{//FIXME: should still keep shooting for a second or two after they actually die...
+		Q3_TaskIDComplete( NPC, TID_BSTATE );
+		goto finished;
+		return;
+	}
+
+	CalcEntitySpot(NPC, SPOT_WEAPON, muzzle);
+	CalcEntitySpot(NPC->enemy, SPOT_HEAD, org);//Was spot_org
+	//Head is a little high, so let's aim for the chest:
+	if ( NPC->enemy->client )
+	{
+		org[2] -= 12;//NOTE: is this enough?
+	}
+
+	VectorSubtract(org, muzzle, dir);
+	vectoangles(dir, angles);
+
+	switch( NPC->client->ps.weapon )
+	{
+	case WP_NONE:
+//	case WP_TRICORDER:
+	case WP_MELEE:
+	case WP_TUSKEN_STAFF:
+	case WP_SABER:
+		//don't do any pitch change if not holding a firing weapon
+		break;
+	default:
+		NPCInfo->desiredPitch = NPCInfo->lockedDesiredPitch = AngleNormalize360(angles[PITCH]);
+		break;
+	}
+
+	NPCInfo->desiredYaw = NPCInfo->lockedDesiredYaw = AngleNormalize360(angles[YAW]);
+
+	if ( NPC_UpdateAngles ( qtrue, qtrue ) )
+	{//FIXME: if angles clamped, this may never work!
+		//NPCInfo->shotTime = NPC->attackDebounceTime = 0;
+
+		if ( shoot )
+		{//FIXME: needs to hold this down if using a weapon that requires it, like phaser...
+			ucmd.buttons |= BUTTON_ATTACK;
+		}
+		
+		if ( !shoot || !(NPC->svFlags & SVF_LOCKEDENEMY) )
+		{//If locked_enemy is on, dont complete until it is destroyed...
+			Q3_TaskIDComplete( NPC, TID_BSTATE );
+			goto finished;
+		}
+	}
+	else if ( shoot && (NPC->svFlags & SVF_LOCKEDENEMY) )
+	{//shooting them till their dead, not aiming right at them yet...
+		/*
+		qboolean movingTarget = qfalse;
+
+		if ( NPC->enemy->client )
+		{
+			if ( VectorLengthSquared( NPC->enemy->client->ps.velocity ) )
+			{
+				movingTarget = qtrue;
+			}
+		}
+		else if ( VectorLengthSquared( NPC->enemy->s.pos.trDelta ) )
+		{
+			movingTarget = qtrue;
+		}
+
+		if (movingTarget )
+		*/
+		{
+			float	dist = VectorLength( dir );
+			float	yawMiss, yawMissAllow = NPC->enemy->maxs[0];
+			float	pitchMiss, pitchMissAllow = (NPC->enemy->maxs[2] - NPC->enemy->mins[2])/2;
+			
+			if ( yawMissAllow < 8.0f )
+			{
+				yawMissAllow = 8.0f;
+			}
+
+			if ( pitchMissAllow < 8.0f )
+			{
+				pitchMissAllow = 8.0f;
+			}
+
+			yawMiss = tan(DEG2RAD(AngleDelta ( NPC->client->ps.viewangles[YAW], NPCInfo->desiredYaw ))) * dist;
+			pitchMiss = tan(DEG2RAD(AngleDelta ( NPC->client->ps.viewangles[PITCH], NPCInfo->desiredPitch))) * dist;
+
+			if ( yawMissAllow >= yawMiss && pitchMissAllow > pitchMiss )
+			{
+				ucmd.buttons |= BUTTON_ATTACK;
+			}
+		}
+	}
+	
+	return;
+		
+finished:
+	NPCInfo->desiredYaw = client->ps.viewangles[YAW];
+	NPCInfo->desiredPitch = client->ps.viewangles[PITCH];
+
+	NPCInfo->aimTime = 0;//ok to turn normally now
+}
+
+/*
+void NPC_BSMove(void)
+Move in a direction, face another
+*/
+void NPC_BSMove(void)
+{
+	gentity_t	*goal = NULL;
+
+	NPC_CheckEnemy(qtrue, qfalse);
+	if(NPC->enemy)
+	{
+		NPC_CheckCanAttack(1.0, qfalse);
+	}
+	else
+	{
+		NPC_UpdateAngles(qtrue, qtrue);
+	}
+
+	goal = UpdateGoal();
+	if(goal)
+	{
+//		NPCInfo->moveToGoalMod = 1.0;
+
+		NPC_SlideMoveToGoal();
+	}
+}
+
+/*
+void NPC_BSShoot(void)
+Move in a direction, face another
+*/
+
+void NPC_BSShoot(void)
+{
+//	NPC_BSMove();
+
+	enemyVisibility = VIS_SHOOT;
+
+	if ( client->ps.weaponstate != WEAPON_READY && client->ps.weaponstate != WEAPON_FIRING ) 
+	{
+		client->ps.weaponstate = WEAPON_READY;
+	}
+
+	WeaponThink(qtrue);
+}
+
+/*
+void NPC_BSPatrol( void ) 
+
+  Same as idle, but you look for enemies every "vigilance"
+  using your angles, HFOV, VFOV and visrange, and listen for sounds within earshot...
+*/
+void NPC_BSPatrol( void ) 
+{
+	//int	alertEventNum;
+
+	if(level.time > NPCInfo->enemyCheckDebounceTime)
+	{
+		NPCInfo->enemyCheckDebounceTime = level.time + (NPCInfo->stats.vigilance * 1000);
+		NPC_CheckEnemy(qtrue, qfalse);
+		if(NPC->enemy)
+		{//FIXME: do anger script
+			NPCInfo->behaviorState = BS_HUNT_AND_KILL;
+			//NPC_AngerSound();
+			return;
+		}
+	}
+
+	//FIXME: Implement generic sound alerts
+	/*
+	alertEventNum = NPC_CheckAlertEvents( qtrue, qtrue );
+	if( alertEventNum != -1 )
+	{//If we heard something, see if we should check it out
+		if ( NPC_CheckInvestigate( alertEventNum ) )
+		{
+			return;
+		}
+	}
+	*/
+
+	NPCInfo->investigateSoundDebounceTime = 0;
+	//FIXME if there is no nav data, we need to do something else
+	// if we're stuck, try to move around it
+	if ( UpdateGoal() )
+	{
+		NPC_MoveToGoal( qtrue );
+	}
+
+	NPC_UpdateAngles( qtrue, qtrue );
+
+	ucmd.buttons |= BUTTON_WALKING;
+}
+
+/*
+void NPC_BSDefault(void)
+	uses various scriptflags to determine how an npc should behave
+*/
+extern void NPC_CheckGetNewWeapon( void );
+extern void NPC_BSST_Attack( void );
+
+void NPC_BSDefault( void ) 
+{
+//	vec3_t		enemyDir;
+//	float		enemyDist;
+//	float		shootDist;
+//	qboolean	enemyFOV = qfalse;
+//	qboolean	enemyShotFOV = qfalse;
+//	qboolean	enemyPVS = qfalse;
+//	vec3_t		enemyHead;
+//	vec3_t		muzzle;
+//	qboolean	enemyLOS = qfalse;
+//	qboolean	enemyCS = qfalse;
+	qboolean	move = qtrue;
+//	qboolean	shoot = qfalse;
+
+	
+	if( NPCInfo->scriptFlags & SCF_FIRE_WEAPON )
+	{
+		WeaponThink( qtrue );
+	}
+
+	if ( NPCInfo->scriptFlags & SCF_FORCED_MARCH )
+	{//being forced to walk
+		if( NPC->client->ps.torsoAnim != TORSO_SURRENDER_START )
+		{
+			NPC_SetAnim( NPC, SETANIM_TORSO, TORSO_SURRENDER_START, SETANIM_FLAG_HOLD );
+		}
+	}
+	//look for a new enemy if don't have one and are allowed to look, validate current enemy if have one
+	NPC_CheckEnemy( (NPCInfo->scriptFlags&SCF_LOOK_FOR_ENEMIES), qfalse );
+	if ( !NPC->enemy )
+	{//still don't have an enemy
+		if ( !(NPCInfo->scriptFlags&SCF_IGNORE_ALERTS) )
+		{//check for alert events
+			//FIXME: Check Alert events, see if we should investigate or just look at it
+			int alertEvent = NPC_CheckAlertEvents( qtrue, qtrue, -1, qtrue, AEL_DISCOVERED );
+
+			//There is an event to look at
+			if ( alertEvent >= 0 )//&& level.alertEvents[alertEvent].ID != NPCInfo->lastAlertID )
+			{//heard/saw something
+				if ( level.alertEvents[alertEvent].level >= AEL_DISCOVERED && (NPCInfo->scriptFlags&SCF_LOOK_FOR_ENEMIES) )
+				{//was a big event
+					if ( level.alertEvents[alertEvent].owner 
+						&& level.alertEvents[alertEvent].owner != NPC
+						&& level.alertEvents[alertEvent].owner->client 
+						&& level.alertEvents[alertEvent].owner->health >= 0 
+						&& level.alertEvents[alertEvent].owner->client->playerTeam == NPC->client->enemyTeam )
+					{//an enemy
+						G_SetEnemy( NPC, level.alertEvents[alertEvent].owner );
+					}
+				}
+				else
+				{//FIXME: investigate lesser events
+				}
+			}
+			//FIXME: also check our allies' condition?
+		}
+	}
+
+	if ( NPC->enemy && !(NPCInfo->scriptFlags&SCF_FORCED_MARCH) )
+	{
+		// just use the stormtrooper attack AI...
+		NPC_CheckGetNewWeapon();
+		if ( NPC->client->leader 
+			&& NPCInfo->goalEntity == NPC->client->leader 
+			&& !Q3_TaskIDPending( NPC, TID_MOVE_NAV ) )
+		{
+			NPC_ClearGoal();
+		}
+		NPC_BSST_Attack();
+		return;
+/*
+		//have an enemy
+		//FIXME: if one of these fails, meaning we can't shoot, do we really need to do the rest?
+		VectorSubtract( NPC->enemy->currentOrigin, NPC->currentOrigin, enemyDir );
+		enemyDist = VectorNormalize( enemyDir );
+		enemyDist *= enemyDist;
+		shootDist = NPC_MaxDistSquaredForWeapon();
+
+		enemyFOV = InFOV( NPC->enemy, NPC, NPCInfo->stats.hfov, NPCInfo->stats.vfov );
+		enemyShotFOV = InFOV( NPC->enemy, NPC, 20, 20 );
+		enemyPVS = gi.inPVS( NPC->enemy->currentOrigin, NPC->currentOrigin );
+
+		if ( enemyPVS )
+		{//in the pvs
+			trace_t	tr;
+
+			CalcEntitySpot( NPC->enemy, SPOT_HEAD, enemyHead );
+			enemyHead[2] -= Q_flrand( 0.0f, NPC->enemy->maxs[2]*0.5f );
+			CalcEntitySpot( NPC, SPOT_WEAPON, muzzle );
+			enemyLOS = NPC_ClearLOS( muzzle, enemyHead );
+
+			gi.trace ( &tr, muzzle, vec3_origin, vec3_origin, enemyHead, NPC->s.number, MASK_SHOT );
+			enemyCS = NPC_EvaluateShot( tr.entityNum, qtrue );
+		}
+		else
+		{//skip thr 2 traces since they would have to fail
+			enemyLOS = qfalse;
+			enemyCS = qfalse;
+		}
+		
+		if ( enemyCS && enemyShotFOV )
+		{//can hit enemy if we want
+			NPC->cantHitEnemyCounter = 0;
+		}
+		else
+		{//can't hit
+			NPC->cantHitEnemyCounter++;
+		}
+
+		if ( enemyCS && enemyShotFOV && enemyDist < shootDist )
+		{//can shoot
+			shoot = qtrue;
+			if ( NPCInfo->goalEntity == NPC->enemy )
+			{//my goal is my enemy and I have a clear shot, no need to chase right now
+				move = qfalse;
+			}
+		}
+		else
+		{//don't shoot yet, keep chasing
+			shoot = qfalse;
+			move = qtrue;
+		}
+
+		//shoot decision
+		if ( !(NPCInfo->scriptFlags&SCF_DONT_FIRE) )
+		{//try to shoot
+			if ( NPC->enemy )
+			{
+				if ( shoot )
+				{
+					if( !(NPCInfo->scriptFlags & SCF_FIRE_WEAPON) ) // we've already fired, no need to do it again here
+					{
+						WeaponThink( qtrue );
+					}
+				}
+			}
+		}
+
+		//chase decision
+		if ( NPCInfo->scriptFlags & SCF_CHASE_ENEMIES )
+		{//go after him
+			NPCInfo->goalEntity = NPC->enemy;
+			//FIXME: don't need to chase when have a clear shot and in range?
+			if ( !enemyCS && NPC->cantHitEnemyCounter > 60 )
+			{//haven't been able to shoot enemy for about 6 seconds, need to do something
+				//FIXME: combat points?  Just chase?
+				if ( enemyPVS )
+				{//in my PVS, just pick a combat point
+					//FIXME: implement
+				}
+				else
+				{//just chase him
+				}
+			}
+			//FIXME: in normal behavior, should we use combat Points?  Do we care?  Is anyone actually going to ever use this AI?
+		}
+		else if ( NPC->cantHitEnemyCounter > 60 )
+		{//pick a new one
+			NPC_CheckEnemy( qtrue, qfalse );
+		}
+		
+		if ( enemyPVS && enemyLOS )//&& !enemyShotFOV )
+		{//have a clear LOS to him//, but not looking at him
+			//Find the desired angles
+			vec3_t	angles;
+
+			GetAnglesForDirection( muzzle, enemyHead, angles );
+
+			NPCInfo->desiredYaw		= AngleNormalize180( angles[YAW] );
+			NPCInfo->desiredPitch	= AngleNormalize180( angles[PITCH] );
+		}
+		*/
+	}
+
+	if ( UpdateGoal() )
+	{//have a goal
+		if ( !NPC->enemy 
+			&& NPC->client->leader 
+			&& NPCInfo->goalEntity == NPC->client->leader 
+			&& !Q3_TaskIDPending( NPC, TID_MOVE_NAV ) )
+		{
+			NPC_BSFollowLeader();
+		}
+		else
+		{
+			//set angles
+			if ( (NPCInfo->scriptFlags & SCF_FACE_MOVE_DIR) || NPCInfo->goalEntity != NPC->enemy )
+			{//face direction of movement, NOTE: default behavior when not chasing enemy
+				NPCInfo->combatMove = qfalse;
+			}
+			else
+			{//face goal.. FIXME: what if have a navgoal but want to face enemy while moving?  Will this do that?
+				vec3_t	dir, angles;
+
+				NPCInfo->combatMove = qfalse;
+
+				VectorSubtract( NPCInfo->goalEntity->currentOrigin, NPC->currentOrigin, dir );
+				vectoangles( dir, angles );
+				NPCInfo->desiredYaw = angles[YAW];
+				if ( NPCInfo->goalEntity == NPC->enemy )
+				{
+					NPCInfo->desiredPitch = angles[PITCH];
+				}
+			}
+
+			//set movement
+			//override default walk/run behavior
+			//NOTE: redundant, done in NPC_ApplyScriptFlags
+			if ( NPCInfo->scriptFlags & SCF_RUNNING )
+			{
+				ucmd.buttons &= ~BUTTON_WALKING;
+			}
+			else if ( NPCInfo->scriptFlags & SCF_WALKING )
+			{
+				ucmd.buttons |= BUTTON_WALKING;
+			}
+			else if ( NPCInfo->goalEntity == NPC->enemy )
+			{
+				ucmd.buttons &= ~BUTTON_WALKING;
+			}
+			else
+			{
+				ucmd.buttons |= BUTTON_WALKING;
+			}
+
+			if ( NPCInfo->scriptFlags & SCF_FORCED_MARCH )
+			{//being forced to walk
+				if ( g_crosshairEntNum != NPC->s.number )
+				{//don't walk if player isn't aiming at me
+					move = qfalse;
+				}
+			}
+
+			if ( move )
+			{
+				//move toward goal
+				NPC_MoveToGoal( qtrue );
+			}
+		}
+	}
+	else if ( !NPC->enemy && NPC->client->leader )
+	{
+		NPC_BSFollowLeader();
+	}
+
+	//update angles
+	NPC_UpdateAngles( qtrue, qtrue );
+}
\ No newline at end of file
diff --git a/code/game/AI_Droid.cpp b/code/game/AI_Droid.cpp
new file mode 100644
index 0000000..c38efff
--- /dev/null
+++ b/code/game/AI_Droid.cpp
@@ -0,0 +1,556 @@
+// leave this line at the top of all AI_xxxx.cpp files for PCH reasons...
+#include "g_headers.h"
+
+	    
+#include "b_local.h"
+
+//static void R5D2_LookAround( void );
+float NPC_GetPainChance( gentity_t *self, int damage );
+
+#define TURN_OFF   0x00000100
+
+//Local state enums
+enum
+{
+	LSTATE_NONE = 0,
+	LSTATE_BACKINGUP,
+	LSTATE_SPINNING,
+	LSTATE_PAIN,
+	LSTATE_DROP
+};
+
+/*
+-------------------------
+R2D2_PartsMove
+-------------------------
+*/
+void R2D2_PartsMove(void)
+{
+	// Front 'eye' lense
+	if ( TIMER_Done(NPC,"eyeDelay") )
+	{
+		NPC->pos1[1] = AngleNormalize360( NPC->pos1[1]);
+
+		NPC->pos1[0]+=Q_irand( -20, 20 );	// Roll	
+		NPC->pos1[1]=Q_irand( -20, 20 );	
+		NPC->pos1[2]=Q_irand( -20, 20 );	
+
+		if (NPC->genericBone1)
+		{
+			gi.G2API_SetBoneAnglesIndex( &NPC->ghoul2[NPC->playerModel], NPC->genericBone1, NPC->pos1, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, NULL ); 
+		}
+		TIMER_Set( NPC, "eyeDelay", Q_irand( 100, 1000 ) );
+	}
+}
+
+/*
+-------------------------
+NPC_BSDroid_Idle
+-------------------------
+*/
+void Droid_Idle( void )
+{
+//	VectorCopy( NPCInfo->investigateGoal, lookPos );
+
+//	NPC_FacePosition( lookPos );
+}
+
+/*
+-------------------------
+R2D2_TurnAnims
+-------------------------
+*/
+void R2D2_TurnAnims ( void )
+{
+	float turndelta;
+	int		anim;
+
+	turndelta = AngleDelta(NPC->currentAngles[YAW], NPCInfo->desiredYaw);
+
+	if ((fabs(turndelta) > 20) && ((NPC->client->NPC_class == CLASS_R2D2) || (NPC->client->NPC_class == CLASS_R5D2)))
+	{
+		anim = NPC->client->ps.legsAnim;
+		if (turndelta<0)
+		{
+			if (anim != BOTH_TURN_LEFT1)
+			{
+				NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_TURN_LEFT1, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+			}
+		}
+		else
+		{
+			if (anim != BOTH_TURN_RIGHT1)
+			{
+				NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_TURN_RIGHT1, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+			}
+		}
+	}
+	else
+	{
+			NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_RUN1, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+	}
+
+}
+
+/*
+-------------------------
+Droid_Patrol
+-------------------------
+*/
+void Droid_Patrol( void )
+{
+
+	NPC->pos1[1] = AngleNormalize360( NPC->pos1[1]);
+
+	if ( NPC->client && NPC->client->NPC_class != CLASS_GONK )
+	{
+		R2D2_PartsMove();		// Get his eye moving.
+		R2D2_TurnAnims();
+	}
+
+	//If we have somewhere to go, then do that
+	if ( UpdateGoal() )
+	{
+		ucmd.buttons |= BUTTON_WALKING;
+		NPC_MoveToGoal( qtrue );
+
+		if( NPC->client && NPC->client->NPC_class == CLASS_MOUSE )
+		{
+			NPCInfo->desiredYaw += sin(level.time*.5) * 25; // Weaves side to side a little
+
+			if (TIMER_Done(NPC,"patrolNoise"))
+			{
+				G_SoundOnEnt( NPC, CHAN_AUTO, va("sound/chars/mouse/misc/mousego%d.wav", Q_irand(1, 3)) );
+
+				TIMER_Set( NPC, "patrolNoise", Q_irand( 2000, 4000 ) );
+			}
+		}
+		else if( NPC->client && NPC->client->NPC_class == CLASS_R2D2 )
+		{
+			if (TIMER_Done(NPC,"patrolNoise"))
+			{
+				G_SoundOnEnt( NPC, CHAN_AUTO, va("sound/chars/r2d2/misc/r2d2talk0%d.wav",	Q_irand(1, 3)) );
+
+				TIMER_Set( NPC, "patrolNoise", Q_irand( 2000, 4000 ) );
+			}
+		}
+		else if( NPC->client && NPC->client->NPC_class == CLASS_R5D2 )
+		{
+			if (TIMER_Done(NPC,"patrolNoise"))
+			{
+				G_SoundOnEnt( NPC, CHAN_AUTO, va("sound/chars/r5d2/misc/r5talk%d.wav", Q_irand(1, 4)) );
+
+				TIMER_Set( NPC, "patrolNoise", Q_irand( 2000, 4000 ) );
+			}
+		}
+		if( NPC->client && NPC->client->NPC_class == CLASS_GONK )
+		{
+			if (TIMER_Done(NPC,"patrolNoise"))
+			{
+				G_SoundOnEnt( NPC, CHAN_AUTO, va("sound/chars/gonk/misc/gonktalk%d.wav", Q_irand(1, 2)) );
+
+				TIMER_Set( NPC, "patrolNoise", Q_irand( 2000, 4000 ) );
+			}
+		}
+//		else
+//		{
+//			R5D2_LookAround();
+//		}
+	}
+
+	NPC_UpdateAngles( qtrue, qtrue );
+
+}
+
+/*
+-------------------------
+Droid_Run
+-------------------------
+*/
+void Droid_Run( void )
+{
+	R2D2_PartsMove();
+
+	if ( NPCInfo->localState == LSTATE_BACKINGUP )
+	{
+		ucmd.forwardmove = -127;
+		NPCInfo->desiredYaw += 5; 
+
+		NPCInfo->localState = LSTATE_NONE;	// So he doesn't constantly backup.
+	}
+	else 
+	{
+		ucmd.forwardmove = 64;
+		//If we have somewhere to go, then do that
+		if ( UpdateGoal() )
+		{
+			if (NPC_MoveToGoal( qfalse ))
+			{
+				NPCInfo->desiredYaw += sin(level.time*.5) * 5; // Weaves side to side a little
+			}
+		}
+	}
+
+	NPC_UpdateAngles( qtrue, qtrue );
+}
+
+/*
+-------------------------
+void Droid_Spin( void )
+-------------------------
+*/
+void Droid_Spin( void )
+{
+	vec3_t dir = {0,0,1};
+
+	R2D2_TurnAnims();
+
+						
+	// Head is gone, spin and spark
+	if ( NPC->client->NPC_class == CLASS_R5D2 )
+	{
+		// No head?
+		if (gi.G2API_GetSurfaceRenderStatus( &NPC->ghoul2[NPC->playerModel], "head" ))
+		{
+			if (TIMER_Done(NPC,"smoke") && !TIMER_Done(NPC,"droidsmoketotal"))
+			{
+				TIMER_Set( NPC, "smoke", 100);
+				G_PlayEffect( "volumetric/droid_smoke" , NPC->currentOrigin,dir);
+			}
+
+			if (TIMER_Done(NPC,"droidspark"))
+			{
+				TIMER_Set( NPC, "droidspark", Q_irand(100,500));
+				G_PlayEffect( "sparks/spark", NPC->currentOrigin,dir);
+			}
+
+			ucmd.forwardmove = Q_irand( -64, 64);
+
+			if (TIMER_Done(NPC,"roam"))
+			{	
+				TIMER_Set( NPC, "roam", Q_irand( 250, 1000 ) );
+				NPCInfo->desiredYaw = Q_irand( 0, 360 ); // Go in random directions
+			}
+		}
+		else
+		{
+			if (TIMER_Done(NPC,"roam"))
+			{
+				NPCInfo->localState = LSTATE_NONE;
+			}
+			else
+			{
+				NPCInfo->desiredYaw = AngleNormalize360(NPCInfo->desiredYaw + 40); // Spin around
+			}
+		}
+	}
+	else 
+	{
+		if (TIMER_Done(NPC,"roam"))
+		{
+			NPCInfo->localState = LSTATE_NONE;
+		}
+		else
+		{
+			NPCInfo->desiredYaw = AngleNormalize360(NPCInfo->desiredYaw + 40); // Spin around
+		}
+	}
+
+	NPC_UpdateAngles( qtrue, qtrue );
+}
+
+/*
+-------------------------
+NPC_BSDroid_Pain
+-------------------------
+*/
+void NPC_Droid_Pain( gentity_t *self, gentity_t *inflictor, gentity_t *other, const vec3_t point, int damage, int mod,int hitLoc ) 
+{
+	int		anim;
+	float	pain_chance;
+
+	if ( self->NPC && self->NPC->ignorePain )
+	{
+		return;
+	}
+	VectorCopy( self->NPC->lastPathAngles, self->s.angles );
+
+	if ( self->client->NPC_class == CLASS_R5D2 )
+	{
+		pain_chance = NPC_GetPainChance( self, damage );
+
+		// Put it in pain
+		if ( mod == MOD_DEMP2 || mod == MOD_DEMP2_ALT || random() < pain_chance )	// Spin around in pain? Demp2 always does this
+		{
+			// Health is between 0-30 or was hit by a DEMP2 so pop his head
+			if ( self->health < 30 || mod == MOD_DEMP2 || mod == MOD_DEMP2_ALT )
+			{
+				if (!(self->spawnflags & 2))	// Doesn't have to ALWAYSDIE
+				{
+					if ((self->NPC->localState != LSTATE_SPINNING) && 
+						(!gi.G2API_GetSurfaceRenderStatus( &self->ghoul2[self->playerModel], "head" )))
+					{
+						gi.G2API_SetSurfaceOnOff( &self->ghoul2[self->playerModel], "head", TURN_OFF );
+
+//						G_PlayEffect( "small_chunks" , self->currentOrigin );
+						G_PlayEffect( "chunks/r5d2head", self->currentOrigin );
+
+						self->s.powerups |= ( 1 << PW_SHOCKED );
+						self->client->ps.powerups[PW_SHOCKED] = level.time + 3000;
+
+						TIMER_Set( self, "droidsmoketotal", 5000);
+						TIMER_Set( self, "droidspark", 100);
+						self->NPC->localState = LSTATE_SPINNING;
+					}
+				}
+			}
+			// Just give him normal pain for a little while
+			else
+			{
+				anim = self->client->ps.legsAnim;
+
+				if ( anim == BOTH_STAND2 )	// On two legs?
+				{
+					anim = BOTH_PAIN1;
+				}
+				else						// On three legs
+				{
+					anim = BOTH_PAIN2;
+				}
+
+				NPC_SetAnim( self, SETANIM_BOTH, anim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+
+				// Spin around in pain
+				self->NPC->localState = LSTATE_SPINNING;
+				TIMER_Set( self, "roam", Q_irand(1000,2000));
+			} 
+		}
+	}
+	else if (self->client->NPC_class == CLASS_MOUSE)
+	{
+		if ( mod == MOD_DEMP2 || mod == MOD_DEMP2_ALT )
+		{
+			self->NPC->localState = LSTATE_SPINNING;
+			self->s.powerups |= ( 1 << PW_SHOCKED );
+			self->client->ps.powerups[PW_SHOCKED] = level.time + 3000;
+		}
+		else
+		{
+			self->NPC->localState = LSTATE_BACKINGUP;
+		}
+
+		self->NPC->scriptFlags &= ~SCF_LOOK_FOR_ENEMIES;
+	}
+	else if ((self->client->NPC_class == CLASS_R2D2))
+	{
+
+		pain_chance = NPC_GetPainChance( self, damage );
+
+		if ( mod == MOD_DEMP2 || mod == MOD_DEMP2_ALT || random() < pain_chance )	// Spin around in pain? Demp2 always does this
+		{
+			anim = self->client->ps.legsAnim;
+
+			if ( anim == BOTH_STAND2 )	// On two legs?
+			{
+				anim = BOTH_PAIN1;
+			}
+			else						// On three legs
+			{
+				anim = BOTH_PAIN2;
+			}
+
+			NPC_SetAnim( self, SETANIM_BOTH, anim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+
+			// Spin around in pain
+			self->NPC->localState = LSTATE_SPINNING;
+			TIMER_Set( self, "roam", Q_irand(1000,2000));
+		} 
+	}
+	else if ( self->client->NPC_class == CLASS_INTERROGATOR && ( mod == MOD_DEMP2 || mod == MOD_DEMP2_ALT ) && other )
+	{
+		vec3_t dir;
+
+		VectorSubtract( self->currentOrigin, other->currentOrigin, dir );
+		VectorNormalize( dir );
+
+		VectorMA( self->client->ps.velocity, 550, dir, self->client->ps.velocity );
+		self->client->ps.velocity[2] -= 127;
+	}
+
+	NPC_Pain( self, inflictor, other, point, damage, mod);
+}
+
+
+/*
+-------------------------
+Droid_Pain
+-------------------------
+*/
+void Droid_Pain(void)
+{
+	if (TIMER_Done(NPC,"droidpain"))	//He's done jumping around
+	{
+		NPCInfo->localState = LSTATE_NONE;
+	}
+}
+
+/*
+-------------------------
+NPC_Mouse_Precache
+-------------------------
+*/
+void NPC_Mouse_Precache( void )
+{
+	int	i;
+
+	for (i = 1; i < 4; i++)
+	{
+		G_SoundIndex( va( "sound/chars/mouse/misc/mousego%d.wav", i ) );
+	}
+
+	G_EffectIndex( "env/small_explode" );
+	G_SoundIndex( "sound/chars/mouse/misc/death1" );
+	G_SoundIndex( "sound/chars/mouse/misc/mouse_lp" );
+}
+
+/*
+-------------------------
+NPC_R5D2_Precache
+-------------------------
+*/
+void NPC_R5D2_Precache(void)
+{
+	for ( int i = 1; i < 5; i++)
+	{
+		G_SoundIndex( va( "sound/chars/r5d2/misc/r5talk%d.wav", i ) );
+	}
+	G_SoundIndex( "sound/chars/mark2/misc/mark2_explo" ); // ??
+	G_SoundIndex( "sound/chars/r2d2/misc/r2_move_lp2.wav" );
+	G_EffectIndex( "env/med_explode");
+	G_EffectIndex( "volumetric/droid_smoke" );
+	G_EffectIndex( "chunks/r5d2head");
+}
+
+/*
+-------------------------
+NPC_R2D2_Precache
+-------------------------
+*/
+void NPC_R2D2_Precache(void)
+{
+	for ( int i = 1; i < 4; i++)
+	{
+		G_SoundIndex( va( "sound/chars/r2d2/misc/r2d2talk0%d.wav", i ) );
+	}
+	G_SoundIndex( "sound/chars/mark2/misc/mark2_explo" ); // ??
+	G_SoundIndex( "sound/chars/r2d2/misc/r2_move_lp.wav" );
+	G_EffectIndex( "env/med_explode");
+}
+
+/*
+-------------------------
+NPC_Gonk_Precache
+-------------------------
+*/
+void NPC_Gonk_Precache( void )
+{
+	G_SoundIndex("sound/chars/gonk/misc/gonktalk1.wav");
+	G_SoundIndex("sound/chars/gonk/misc/gonktalk2.wav");
+
+	G_SoundIndex("sound/chars/gonk/misc/death1.wav");
+	G_SoundIndex("sound/chars/gonk/misc/death2.wav");
+	G_SoundIndex("sound/chars/gonk/misc/death3.wav");
+
+	G_EffectIndex( "env/med_explode");
+}
+
+/*
+-------------------------
+NPC_Protocol_Precache
+-------------------------
+*/
+void NPC_Protocol_Precache( void )
+{
+	G_SoundIndex( "sound/chars/mark2/misc/mark2_explo" );
+	G_EffectIndex( "env/med_explode");
+}
+
+/*
+static void R5D2_OffsetLook( float offset, vec3_t out )
+{
+	vec3_t	angles, forward, temp;
+
+	GetAnglesForDirection( NPC->currentOrigin, NPCInfo->investigateGoal, angles );
+	angles[YAW] += offset;
+	AngleVectors( angles, forward, NULL, NULL );
+	VectorMA( NPC->currentOrigin, 64, forward, out );
+	
+	CalcEntitySpot( NPC, SPOT_HEAD, temp );
+	out[2] = temp[2];
+}
+*/
+
+/*
+-------------------------
+R5D2_LookAround
+-------------------------
+*/
+/*
+static void R5D2_LookAround( void )
+{
+	vec3_t	lookPos;
+	float	perc = (float) ( level.time - NPCInfo->pauseTime ) / (float) NPCInfo->investigateDebounceTime;
+
+	//Keep looking at the spot
+	if ( perc < 0.25 )
+	{
+		VectorCopy( NPCInfo->investigateGoal, lookPos );
+	}
+	else if ( perc < 0.5f )		//Look up but straight ahead
+	{
+		R5D2_OffsetLook( 0.0f, lookPos );
+	}
+	else if ( perc < 0.75f )	//Look right
+	{
+		R5D2_OffsetLook( 45.0f, lookPos );
+	}
+	else	//Look left
+	{
+		R5D2_OffsetLook( -45.0f, lookPos );
+	}
+
+	NPC_FacePosition( lookPos );
+}
+
+*/
+
+/*
+-------------------------
+NPC_BSDroid_Default
+-------------------------
+*/
+void NPC_BSDroid_Default( void )
+{
+
+	if ( NPCInfo->localState == LSTATE_SPINNING )
+	{
+		Droid_Spin();
+	}
+	else if ( NPCInfo->localState == LSTATE_PAIN )
+	{
+		Droid_Pain();
+	}
+	else if ( NPCInfo->localState == LSTATE_DROP )
+	{
+		NPC_UpdateAngles( qtrue, qtrue );
+		ucmd.upmove = crandom() * 64;
+	}
+	else if ( NPCInfo->scriptFlags & SCF_LOOK_FOR_ENEMIES )
+	{
+		Droid_Patrol();
+	}
+	else
+	{
+		Droid_Run();
+	}
+}
diff --git a/code/game/AI_GalakMech.cpp b/code/game/AI_GalakMech.cpp
new file mode 100644
index 0000000..250d6ca
--- /dev/null
+++ b/code/game/AI_GalakMech.cpp
@@ -0,0 +1,743 @@
+////////////////////////////////////////////////////////////////////////////////////////
+// RAVEN SOFTWARE - STAR WARS: JK III
+//  (c) 2002 Activision
+//
+// April 3, 2003 - This file has been commandeered for use by AI vehicle pilots.
+//
+////////////////////////////////////////////////////////////////////////////////////////
+#include "g_headers.h"
+
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Includes
+////////////////////////////////////////////////////////////////////////////////////////
+#include "b_local.h"
+#include "anims.h"
+#include "g_navigator.h"
+#include "g_Vehicles.h"
+#if !defined(RATL_VECTOR_VS_INC)
+	#include "..\Ratl\vector_vs.h"
+#endif
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Defines
+////////////////////////////////////////////////////////////////////////////////////////
+#define			MAX_VEHICLES_REGISTERED	100
+
+#define			ATTACK_FWD				0.95f
+#define			ATTACK_SIDE				0.20f
+#define			AIM_SIDE				0.60f
+#define			FUTURE_PRED_DIST		20.0f
+#define			FUTURE_SIDE_DIST		60.0f
+#define			ATTACK_FLANK_SLOWING	1000.0f
+#define			RAM_DIST				150.0f
+#define			MIN_STAY_VIEWABLE_TIME	20000
+
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Externs
+////////////////////////////////////////////////////////////////////////////////////////
+extern Vehicle_t *G_IsRidingVehicle( gentity_t *ent );
+extern void G_SoundAtSpot( vec3_t org, int soundIndex, qboolean broadcast );
+
+
+
+trace_t													mPilotViewTrace;
+int														mPilotViewTraceCount;
+int														mActivePilotCount;
+ratl::vector_vs<gentity_t *, MAX_VEHICLES_REGISTERED>	mRegistered;
+
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+//
+////////////////////////////////////////////////////////////////////////////////////////
+void	Pilot_Reset(void)
+{
+	mPilotViewTraceCount = 0;
+	mActivePilotCount = 0;
+	mRegistered.clear();
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+//
+////////////////////////////////////////////////////////////////////////////////////////
+int		Pilot_ActivePilotCount()
+{
+	return mActivePilotCount;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+//
+////////////////////////////////////////////////////////////////////////////////////////
+void	Pilot_Update(void)
+{
+	mActivePilotCount = 0;
+	mRegistered.clear();
+	for (int i=0; i<ENTITYNUM_WORLD; i++)
+	{
+		if (g_entities[i].inuse && 
+			g_entities[i].client &&
+			g_entities[i].NPC && 
+			g_entities[i].NPC->greetEnt &&
+			g_entities[i].NPC->greetEnt->owner==(&g_entities[i])
+			)
+		{
+			mActivePilotCount++;
+		}
+		if ( g_entities[i].inuse && 
+			 g_entities[i].client &&
+			 g_entities[i].m_pVehicle &&
+			!g_entities[i].owner &&
+			 g_entities[i].health>0 &&
+			 g_entities[i].m_pVehicle->m_pVehicleInfo->type==VH_SPEEDER && 
+			!mRegistered.full())
+		{
+			mRegistered.push_back(&g_entities[i]);
+		}
+
+	}
+
+
+	if (player && 
+		player->inuse && 
+		TIMER_Done(player, "FlybySoundArchitectureDebounce"))
+	{
+    	TIMER_Set(player, "FlybySoundArchitectureDebounce", 300);
+
+		Vehicle_t*	pVeh = G_IsRidingVehicle(player);
+
+		if (pVeh && 
+			(pVeh->m_pVehicleInfo->soundFlyBy || pVeh->m_pVehicleInfo->soundFlyBy2) &&
+			//fabsf(pVeh->m_pParentEntity->currentAngles[2])<15.0f &&
+			VectorLength(pVeh->m_pParentEntity->client->ps.velocity)>500.0f)
+		{
+			vec3_t	projectedPosition;
+			vec3_t	projectedDirection;
+			vec3_t	projectedRight;
+			vec3_t	anglesNoRoll;
+
+			VectorCopy(pVeh->m_pParentEntity->currentAngles, anglesNoRoll);
+			anglesNoRoll[2] = 0;
+			AngleVectors(anglesNoRoll, projectedDirection, projectedRight, 0);
+
+			VectorMA(player->currentOrigin, 1.2f, pVeh->m_pParentEntity->client->ps.velocity, projectedPosition);
+			VectorMA(projectedPosition, Q_flrand(-200.0f, 200.0f), projectedRight, projectedPosition); 
+
+			gi.trace(&mPilotViewTrace, 
+				player->currentOrigin, 
+				0, 
+				0, 
+				projectedPosition, 
+				player->s.number, 
+ 				MASK_SHOT);
+
+			if ((mPilotViewTrace.allsolid==qfalse) && 
+				(mPilotViewTrace.startsolid==qfalse) && 
+				(mPilotViewTrace.fraction<0.99f) && 
+				(mPilotViewTrace.plane.normal[2]<0.5f) &&
+				(DotProduct(projectedDirection, mPilotViewTrace.plane.normal)<-0.5f)
+				)
+			{
+ 			//	CG_DrawEdge(player->currentOrigin, mPilotViewTrace.endpos, EDGE_IMPACT_POSSIBLE);
+ 		  		TIMER_Set(player, "FlybySoundArchitectureDebounce", Q_irand(1000, 2000));
+
+				int soundFlyBy = pVeh->m_pVehicleInfo->soundFlyBy;
+				if (pVeh->m_pVehicleInfo->soundFlyBy2 && (!soundFlyBy || !Q_irand(0,1)))
+				{
+					soundFlyBy = pVeh->m_pVehicleInfo->soundFlyBy2;
+				}
+				G_SoundAtSpot(mPilotViewTrace.endpos, soundFlyBy, qtrue);
+			}
+			else
+			{
+ 			//	CG_DrawEdge(player->currentOrigin, mPilotViewTrace.endpos, EDGE_IMPACT_SAFE);
+			}
+		}
+	}
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// 
+////////////////////////////////////////////////////////////////////////////////////////
+bool	Pilot_AnyVehiclesRegistered()
+{
+	return (!mRegistered.empty());
+}
+
+
+
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Vehicle Registration
+//
+// Any vehicles that can be ridden by NPCs should be registered here
+//
+////////////////////////////////////////////////////////////////////////////////////////
+void	Vehicle_Register(gentity_t *ent)
+{
+}
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Vehicle Remove From The List Of Valid
+////////////////////////////////////////////////////////////////////////////////////////
+void	Vehicle_Remove(gentity_t *ent)
+{
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Vehicle_Find
+//
+// Will look through all registered vehicles and choose the closest one that the given
+// entity can get to.
+//
+////////////////////////////////////////////////////////////////////////////////////////
+gentity_t*	Vehicle_Find(gentity_t *ent)
+{
+	gentity_t*		closest = 0;
+	float			closestDist = 0;
+	float			curDist = 0;
+
+
+	for (int i=0; i<mRegistered.size(); i++)
+	{
+		if (!mRegistered[i]->owner)
+		{
+			curDist = Distance(mRegistered[i]->currentOrigin, ent->currentOrigin);
+			if (curDist<1000 && (!closest || curDist<closestDist))
+			{
+				if (NAV::InSameRegion(ent, mRegistered[i]))
+				{
+					closest = mRegistered[i];
+					closestDist = curDist;
+				}
+			}
+		}
+	}
+
+	return closest;
+}
+
+
+
+void	Pilot_Update_Enemy();
+void	Pilot_Steer_Vehicle();
+void	Pilot_Goto_Vehicle();
+
+
+
+
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Pilot_MasterUpdate() - Master think function for Pilot NPCs
+//
+// Will return true if the character is either driving a vehicle or on his way to get
+// onto one.
+////////////////////////////////////////////////////////////////////////////////////////
+bool	Pilot_MasterUpdate()
+{
+	if (!NPC->enemy)
+	{
+		// If Still On A Vehicle, Jump Off
+		//---------------------------------
+		if (NPCInfo->greetEnt)
+		{
+			ucmd.upmove = 128.0f;
+
+			if (NPCInfo->greetEnt && NPCInfo->greetEnt->m_pVehicle && level.time<NPCInfo->confusionTime)
+			{
+				Vehicle_t*	pVeh	= NPCInfo->greetEnt->m_pVehicle;
+				if (!(pVeh->m_ulFlags&VEH_OUTOFCONTROL))
+		 		{
+					gentity_t*	parent	= pVeh->m_pParentEntity;
+					float		CurSpeed = VectorLength(parent->client->ps.velocity);
+					pVeh->m_pVehicleInfo->StartDeathDelay(pVeh, 10000);
+					pVeh->m_ulFlags |= (VEH_OUTOFCONTROL);
+					VectorScale(parent->client->ps.velocity, 1.25f, parent->pos3);
+					if (CurSpeed<pVeh->m_pVehicleInfo->speedMax)
+					{
+						VectorNormalize(parent->pos3);
+						if (fabsf(parent->pos3[2])<0.25f)
+						{
+							VectorScale(parent->pos3, (pVeh->m_pVehicleInfo->speedMax * 1.25f), parent->pos3);
+						}
+						else 
+						{
+							VectorScale(parent->client->ps.velocity, 1.25f, parent->pos3);
+						}
+					}
+				}
+			}
+
+			if (NPCInfo->greetEnt->owner==NPC)
+			{
+				return true;
+			}
+			NPCInfo->greetEnt = 0;
+		}
+
+		// Otherwise Nothing To See Here
+		//-------------------------------
+		return false;
+	}
+
+
+	// If We Already Have A Target Vehicle, Make Sure It Is Still Valid
+	//------------------------------------------------------------------
+	if (NPCInfo->greetEnt)
+	{
+		if (!NPCInfo->greetEnt->inuse || 
+			!NPCInfo->greetEnt->m_pVehicle || 
+			!NPCInfo->greetEnt->m_pVehicle->m_pVehicleInfo)
+		{
+			NPCInfo->greetEnt = Vehicle_Find(NPC);
+		}
+		else
+		{
+			if (NPCInfo->greetEnt->owner && NPCInfo->greetEnt->owner!=NPC)
+			{
+				NPCInfo->greetEnt = Vehicle_Find(NPC);
+			}
+		}
+	}
+
+	// If We Have An Enemy, Try To Find A Vehicle Nearby
+	//---------------------------------------------------
+	else
+	{
+		NPCInfo->greetEnt = Vehicle_Find(NPC);
+	}
+
+	// If No Vehicle Available, Continue As Usual
+	//--------------------------------------------
+	if (!NPCInfo->greetEnt)
+	{
+		return false;
+	}
+
+
+
+	if (NPCInfo->greetEnt->owner==NPC)
+	{
+		Pilot_Steer_Vehicle();
+	}
+	else
+	{
+		Pilot_Goto_Vehicle();
+	}
+
+	Pilot_Update_Enemy();
+	return true;
+}
+
+
+
+
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+//
+////////////////////////////////////////////////////////////////////////////////////////
+void	Pilot_Update_Enemy()
+{
+	if (!TIMER_Exists(NPC, "PilotRemoveTime"))
+	{
+		TIMER_Set(NPC, "PilotRemoveTime", MIN_STAY_VIEWABLE_TIME);
+	}
+
+	if (TIMER_Done(NPC, "NextPilotCheckEnemyTime"))
+	{
+		TIMER_Set(NPC, "NextPilotCheckEnemyTime", Q_irand(1000,2000));
+		if (NPC->enemy && Distance(NPC->currentOrigin, NPC->enemy->currentOrigin)>1000.0f)
+		{
+			mPilotViewTraceCount ++;
+			gi.trace(&mPilotViewTrace, 
+				NPC->currentOrigin, 
+				0, 
+				0, 
+				NPC->enemy->currentOrigin, 
+				NPC->s.number, 
+				MASK_SHOT);
+
+			if ((mPilotViewTrace.allsolid==qfalse) && 
+				(mPilotViewTrace.startsolid==qfalse ) && 
+				((mPilotViewTrace.entityNum==NPC->enemy->s.number)||(mPilotViewTrace.entityNum==NPC->enemy->s.m_iVehicleNum)))
+			{
+				TIMER_Set(NPC, "PilotRemoveTime", MIN_STAY_VIEWABLE_TIME);			
+			}
+		}
+		else
+		{
+			TIMER_Set(NPC, "PilotRemoveTime", MIN_STAY_VIEWABLE_TIME);
+		}
+	}
+
+	if (TIMER_Done(NPC, "PilotRemoveTime"))
+	{
+		if (NPCInfo->greetEnt->owner==NPC)
+		{
+			NPCInfo->greetEnt->e_ThinkFunc	= thinkF_G_FreeEntity;
+			NPCInfo->greetEnt->nextthink	= level.time;
+		}
+		NPC->e_ThinkFunc	= thinkF_G_FreeEntity;
+		NPC->nextthink		= level.time;
+	}
+}
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+//
+////////////////////////////////////////////////////////////////////////////////////////
+void	Pilot_Goto_Vehicle()
+{
+	STEER::Activate(NPC);
+	{
+		if (STEER::Reached(NPC, NPCInfo->greetEnt, 80.0f))
+		{
+			NPC_Use(NPCInfo->greetEnt, NPC, NPC);
+		}
+		else if (NAV::OnNeighboringPoints(NPC, NPCInfo->greetEnt))
+		{
+			STEER::Persue(NPC, NPCInfo->greetEnt, 50.0f, 0.0f, 30.0f, 0.0f, true);
+		}
+		else
+		{
+			if (!NAV::GoTo(NPC, NPCInfo->greetEnt))
+			{
+				STEER::Stop(NPC);
+			}
+		}
+	}
+	STEER::AvoidCollisions(NPC);
+	STEER::DeActivate(NPC, &ucmd);
+	NPC_UpdateAngles(qtrue, qtrue);
+}
+
+extern bool	VEH_StartStrafeRam(Vehicle_t *pVeh, bool Right);
+
+////////////////////////////////////////////////////////////////////////////////////////
+//
+////////////////////////////////////////////////////////////////////////////////////////
+void	Pilot_Steer_Vehicle()
+{
+	if (!NPC->enemy || !NPC->enemy->client)
+	{
+		return;
+	}
+
+
+
+
+
+
+// SETUP
+//=======
+	// Setup Actor Data
+	//------------------
+	CVec3		ActorPos(NPC->currentOrigin);
+	CVec3		ActorAngles(NPC->currentAngles);
+				ActorAngles[2]	= 0;
+	Vehicle_t*	ActorVeh		= NPCInfo->greetEnt->m_pVehicle;
+	bool		ActorInTurbo	= (ActorVeh->m_iTurboTime>level.time);
+	float		ActorSpeed		= (ActorVeh)?(VectorLength(ActorVeh->m_pParentEntity->client->ps.velocity)):(NPC->client->ps.speed);
+
+
+	// If my vehicle is spinning out of control, just hold on, we're going to die!!!!!
+	//---------------------------------------------------------------------------------
+	if (ActorVeh && (ActorVeh->m_ulFlags & VEH_OUTOFCONTROL))
+	{
+		if (NPC->client->ps.weapon!=WP_NONE)
+		{
+			NPC_ChangeWeapon(WP_NONE);
+		}
+		ucmd.buttons	&=~BUTTON_ATTACK;
+		ucmd.buttons	&=~BUTTON_ALT_ATTACK;
+		return;
+	}
+
+	CVec3		ActorDirection;
+				AngleVectors(ActorAngles.v, ActorDirection.v, 0, 0);
+
+	CVec3		ActorFuturePos(ActorPos);
+				ActorFuturePos.ScaleAdd(ActorDirection, FUTURE_PRED_DIST);
+
+	bool		ActorDoTurbo	= false;
+	bool		ActorAccelerate	= false;
+	bool		ActorAimAtTarget= true;
+	float		ActorYawOffset	= 0.0f;
+
+
+	// Setup Enemy Data
+	//------------------
+	CVec3		EnemyPos(NPC->enemy->currentOrigin);
+	CVec3		EnemyAngles(NPC->enemy->currentAngles);
+				EnemyAngles[2]	= 0;
+	Vehicle_t*	EnemyVeh		= (NPC->enemy->s.m_iVehicleNum)?(g_entities[NPC->enemy->s.m_iVehicleNum].m_pVehicle):(0);
+	bool		EnemyInTurbo	= (EnemyVeh && EnemyVeh->m_iTurboTime>level.time);
+	float		EnemySpeed		= (EnemyVeh)?(EnemyVeh->m_pParentEntity->client->ps.speed):(NPC->enemy->resultspeed);
+	bool		EnemySlideBreak	= (EnemyVeh && (EnemyVeh->m_ulFlags&VEH_SLIDEBREAKING || EnemyVeh->m_ulFlags&VEH_STRAFERAM));
+	bool		EnemyDead		= (NPC->enemy->health<=0);
+
+	bool		ActorFlank		= (NPCInfo->lastAvoidSteerSideDebouncer>level.time && EnemyVeh && EnemySpeed>10.0f);
+
+	CVec3		EnemyDirection;
+	CVec3		EnemyRight;
+				AngleVectors(EnemyAngles.v, EnemyDirection.v, EnemyRight.v, 0);
+
+	CVec3		EnemyFuturePos(EnemyPos);
+				EnemyFuturePos.ScaleAdd(EnemyDirection, FUTURE_PRED_DIST);
+
+	ESide		EnemySide		= ActorPos.LRTest(EnemyPos, EnemyFuturePos);
+	CVec3		EnemyFlankPos(EnemyFuturePos);
+				EnemyFlankPos.ScaleAdd(EnemyRight, (EnemySide==Side_Right)?(FUTURE_SIDE_DIST):(-FUTURE_SIDE_DIST));
+
+	// Debug Draw Enemy Data
+	//-----------------------
+	if (false)
+	{
+		CG_DrawEdge(EnemyPos.v,			EnemyFuturePos.v, EDGE_IMPACT_SAFE);
+		CG_DrawEdge(EnemyFuturePos.v,	EnemyFlankPos.v, EDGE_IMPACT_SAFE);
+	}
+
+
+	// Setup Move And Aim Directions
+	//-------------------------------
+	CVec3		MoveDirection((ActorFlank)?(EnemyFlankPos):(EnemyFuturePos));
+				MoveDirection	-= ActorPos;
+	float		MoveDistance	= MoveDirection.SafeNorm();
+	float		MoveAccuracy	= MoveDirection.Dot(ActorDirection);
+
+	CVec3		AimDirection(EnemyPos);
+				AimDirection	-= ActorPos;
+	float		AimDistance		= AimDirection.SafeNorm();
+	float		AimAccuracy		= AimDirection.Dot(ActorDirection);
+
+
+
+	if (!ActorFlank && TIMER_Done(NPC, "FlankAttackCheck"))
+	{
+		TIMER_Set(NPC, "FlankAttackCheck", Q_irand(1000, 3000));
+		if (MoveDistance<4000 && Q_irand(0, 1)==0)
+		{
+			NPCInfo->lastAvoidSteerSideDebouncer	= level.time + Q_irand(8000, 14000);
+		}
+	}
+
+
+
+	// Fly By Sounds
+	//---------------
+	if ((ActorVeh->m_pVehicleInfo->soundFlyBy || ActorVeh->m_pVehicleInfo->soundFlyBy2) &&
+		EnemyVeh &&
+		MoveDistance<800 &&
+		ActorSpeed>500.0f &&
+		TIMER_Done(NPC, "FlybySoundDebouncer")
+		)
+	{
+		if (EnemySpeed<100.0f || (ActorDirection.Dot(EnemyDirection)*(MoveDistance/800.0f))<-0.5f)
+		{
+			TIMER_Set(NPC, "FlybySoundDebouncer", 2000);
+			int soundFlyBy = ActorVeh->m_pVehicleInfo->soundFlyBy;
+			if (ActorVeh->m_pVehicleInfo->soundFlyBy2 && (!soundFlyBy || !Q_irand(0,1)))
+			{
+				soundFlyBy = ActorVeh->m_pVehicleInfo->soundFlyBy2;
+			}
+			G_Sound(ActorVeh->m_pParentEntity, soundFlyBy);		
+		}
+	}
+
+
+
+// FLY PAST BEHAVIOR
+//===================
+ 	if (EnemySlideBreak || !TIMER_Done(NPC, "MinHoldDirectionTime"))
+	{
+		if (TIMER_Done(NPC, "MinHoldDirectionTime"))
+		{ 
+			TIMER_Set(NPC, "MinHoldDirectionTime", 500);	// Hold For At Least 500 ms
+		}
+		ActorAccelerate		= true;							// Go
+		ActorAimAtTarget	= false;						// Don't Alter Our Aim Direction
+		ucmd.buttons		&=~BUTTON_VEH_SPEED;			// Let Normal Vehicle Controls Go
+	}
+
+
+// FLANKING BEHAVIOR
+//===================
+	else if (ActorFlank)
+	{
+  		ActorAccelerate	= true;
+		ActorDoTurbo	= (MoveDistance>2500 || EnemyInTurbo);
+		ucmd.buttons	|= BUTTON_VEH_SPEED;			// Tells PMove to use the ps.speed we calculate here, not the one from g_vehicles.c
+
+
+		// For Flanking, We Calculate The Speed By Hand, Rather Than Using Pure Accelerate / No Accelerate Functionality
+		//---------------------------------------------------------------------------------------------------------------
+		NPC->client->ps.speed = ActorVeh->m_pVehicleInfo->speedMax * ((ActorInTurbo)?(1.35f):(1.15f));
+
+
+		// If In Slowing Distance, Scale Down The Speed As We Approach Our Move Target
+		//-----------------------------------------------------------------------------
+		if (MoveDistance<ATTACK_FLANK_SLOWING)
+		{
+			NPC->client->ps.speed *= (MoveDistance/ATTACK_FLANK_SLOWING);
+			NPC->client->ps.speed += EnemySpeed;
+
+			// Match Enemy Speed
+			//-------------------
+			if (NPC->client->ps.speed<5.0f && EnemySpeed<5.0f)
+			{
+				NPC->client->ps.speed = EnemySpeed;
+			}
+
+			// Extra Slow Down When Out In Front
+			//-----------------------------------
+ 			if  (MoveAccuracy<0.0f)
+			{
+				NPC->client->ps.speed *= (MoveAccuracy + 1.0f);
+			}
+
+	
+			MoveDirection	*=        (MoveDistance/ATTACK_FLANK_SLOWING);
+			EnemyDirection	*= 1.0f - (MoveDistance/ATTACK_FLANK_SLOWING);
+			MoveDirection	+= EnemyDirection;
+
+			if (TIMER_Done(NPC, "RamCheck"))
+			{
+				TIMER_Set(NPC, "RamCheck", Q_irand(1000, 3000));
+				if (MoveDistance<RAM_DIST && Q_irand(0, 2)==0)
+				{
+					VEH_StartStrafeRam(ActorVeh, (EnemySide==Side_Left));
+				}
+			}
+		}
+	}
+
+
+// NORMAL CHASE BEHAVIOR
+//=======================
+	else
+	{
+		if (!EnemyVeh && AimAccuracy>0.99f && MoveDistance<500 && !EnemyDead)
+		{
+			ActorAccelerate = true;
+			ActorDoTurbo	= false;
+		}
+		else
+		{
+			ActorAccelerate = ((MoveDistance>500 && EnemySpeed>20.0f) || MoveDistance>1000);
+			ActorDoTurbo	= (MoveDistance>3000 && EnemySpeed>20.0f);
+		}
+		ucmd.buttons	&=~BUTTON_VEH_SPEED;
+	}
+
+
+
+
+// APPLY RESULTS
+//=======================
+	// Decide Turbo
+	//--------------
+	if (ActorDoTurbo || ActorInTurbo)
+	{
+		ucmd.buttons |= BUTTON_ALT_ATTACK;
+	}
+	else
+	{
+		ucmd.buttons &=~BUTTON_ALT_ATTACK;
+	}
+
+	// Decide Acceleration
+	//---------------------
+	ucmd.forwardmove = (ActorAccelerate)?(127):(0);
+
+
+
+	// Decide To Shoot
+	//-----------------
+	ucmd.buttons	&=~BUTTON_ATTACK;
+	ucmd.rightmove	= 0;
+ 	if (AimDistance<2000 && !EnemyDead)
+	{
+		// If Doing A Ram Attack
+		//-----------------------
+		if (ActorYawOffset!=0)
+		{
+			if (NPC->client->ps.weapon!=WP_NONE)
+			{
+				NPC_ChangeWeapon(WP_NONE);
+			}
+			ucmd.buttons	&=~BUTTON_ATTACK;
+		}
+ 		else if (AimAccuracy>ATTACK_FWD)
+		{
+			if (NPC->client->ps.weapon!=WP_NONE)
+			{
+				NPC_ChangeWeapon(WP_NONE);
+			}
+			ucmd.buttons	|= BUTTON_ATTACK;
+		}
+		else if (AimAccuracy<AIM_SIDE && AimAccuracy>-AIM_SIDE)
+		{
+			if (NPC->client->ps.weapon!=WP_BLASTER)
+			{
+				NPC_ChangeWeapon(WP_BLASTER);
+			}
+
+			if (AimAccuracy<ATTACK_SIDE && AimAccuracy>-ATTACK_SIDE)
+			{
+				//if (!TIMER_Done(NPC, "RiderAltAttack"))
+				//{
+				//	ucmd.buttons |= BUTTON_ALT_ATTACK;
+				//}
+				//else
+				//{
+                    ucmd.buttons |= BUTTON_ATTACK;
+
+			/*		if (TIMER_Done(NPC, "RiderAltAttackCheck"))
+					{
+						TIMER_Set(NPC, "RiderAltAttackCheck", Q_irand(1000, 3000));
+						if (Q_irand(0, 2)==0)
+						{
+							TIMER_Set(NPC, "RiderAltAttack", 300);
+						}
+					}*/
+				//}
+				WeaponThink(true);
+			}
+			ucmd.rightmove = (EnemySide==Side_Left)?( 127):(-127);
+		}
+		else
+		{
+			if (NPC->client->ps.weapon!=WP_NONE)
+			{
+				NPC_ChangeWeapon(WP_NONE);
+			}
+		}
+	}
+	else
+	{
+		if (NPC->client->ps.weapon!=WP_NONE)
+		{
+			NPC_ChangeWeapon(WP_NONE);
+		}
+	}
+
+
+	// Aim At Target
+	//---------------
+	if (ActorAimAtTarget)
+	{
+		MoveDirection.VecToAng();
+		NPCInfo->desiredPitch	= AngleNormalize360(MoveDirection[PITCH]);
+		NPCInfo->desiredYaw		= AngleNormalize360(MoveDirection[YAW] + ActorYawOffset);
+	}
+	NPC_UpdateAngles(qtrue, qtrue);
+}
+
diff --git a/code/game/AI_Glider.cpp b/code/game/AI_Glider.cpp
new file mode 100644
index 0000000..784d33d
--- /dev/null
+++ b/code/game/AI_Glider.cpp
@@ -0,0 +1,3 @@
+// leave this line at the top of all AI_xxxx.cpp files for PCH reasons...
+#include "g_headers.h"
+
diff --git a/code/game/AI_Grenadier.cpp b/code/game/AI_Grenadier.cpp
new file mode 100644
index 0000000..26bf55c
--- /dev/null
+++ b/code/game/AI_Grenadier.cpp
@@ -0,0 +1,669 @@
+// leave this line at the top of all AI_xxxx.cpp files for PCH reasons...
+#include "g_headers.h"
+
+
+#include "b_local.h"
+#include "g_nav.h"
+#include "anims.h"
+#include "g_navigator.h"
+
+extern void CG_DrawAlert( vec3_t origin, float rating );
+extern void G_AddVoiceEvent( gentity_t *self, int event, int speakDebounceTime );
+extern void NPC_TempLookTarget( gentity_t *self, int lookEntNum, int minLookTime, int maxLookTime );
+extern qboolean G_ExpandPointToBBox( vec3_t point, const vec3_t mins, const vec3_t maxs, int ignore, int clipmask );
+extern void NPC_AimAdjust( int change );
+extern qboolean FlyingCreature( gentity_t *ent );
+
+
+#define	MAX_VIEW_DIST		1024
+#define MAX_VIEW_SPEED		250
+#define	MAX_LIGHT_INTENSITY 255
+#define	MIN_LIGHT_THRESHOLD	0.1
+
+#define	DISTANCE_SCALE		0.25f
+#define	DISTANCE_THRESHOLD	0.075f
+#define	SPEED_SCALE			0.25f
+#define	FOV_SCALE			0.5f
+#define	LIGHT_SCALE			0.25f
+
+#define	REALIZE_THRESHOLD	0.6f
+#define CAUTIOUS_THRESHOLD	( REALIZE_THRESHOLD * 0.75 )
+
+qboolean NPC_CheckPlayerTeamStealth( void );
+
+static qboolean enemyLOS;
+static qboolean enemyCS;
+static qboolean faceEnemy;
+static qboolean move;
+static qboolean shoot;
+static float	enemyDist;
+
+//Local state enums
+enum
+{
+	LSTATE_NONE = 0,
+	LSTATE_UNDERFIRE,
+	LSTATE_INVESTIGATE,
+};
+
+void Grenadier_ClearTimers( gentity_t *ent )
+{
+	TIMER_Set( ent, "chatter", 0 );
+	TIMER_Set( ent, "duck", 0 );
+	TIMER_Set( ent, "stand", 0 );
+	TIMER_Set( ent, "shuffleTime", 0 );
+	TIMER_Set( ent, "sleepTime", 0 );
+	TIMER_Set( ent, "enemyLastVisible", 0 );
+	TIMER_Set( ent, "roamTime", 0 );
+	TIMER_Set( ent, "hideTime", 0 );
+	TIMER_Set( ent, "attackDelay", 0 );	//FIXME: Slant for difficulty levels
+	TIMER_Set( ent, "stick", 0 );
+	TIMER_Set( ent, "scoutTime", 0 );
+	TIMER_Set( ent, "flee", 0 );
+}
+
+void NPC_Grenadier_PlayConfusionSound( gentity_t *self )
+{//FIXME: make this a custom sound in sound set
+	if ( self->health > 0 )
+	{
+		G_AddVoiceEvent( self, Q_irand(EV_CONFUSE1, EV_CONFUSE3), 2000 );
+	}
+	//reset him to be totally unaware again
+	TIMER_Set( self, "enemyLastVisible", 0 );
+	TIMER_Set( self, "flee", 0 );
+	self->NPC->squadState = SQUAD_IDLE;
+	self->NPC->tempBehavior = BS_DEFAULT;
+	
+	//self->NPC->behaviorState = BS_PATROL;
+	G_ClearEnemy( self );//FIXME: or just self->enemy = NULL;?
+
+	self->NPC->investigateCount = 0;
+}
+
+
+/*
+-------------------------
+NPC_ST_Pain
+-------------------------
+*/
+
+void NPC_Grenadier_Pain( gentity_t *self, gentity_t *inflictor, gentity_t *other, vec3_t point, int damage, int mod ) 
+{
+	self->NPC->localState = LSTATE_UNDERFIRE;
+
+	TIMER_Set( self, "duck", -1 );
+	TIMER_Set( self, "stand", 2000 );
+
+	NPC_Pain( self, inflictor, other, point, damage, mod );
+
+	if ( !damage && self->health > 0 )
+	{//FIXME: better way to know I was pushed
+		G_AddVoiceEvent( self, Q_irand(EV_PUSHED1, EV_PUSHED3), 2000 );
+	}
+}
+
+/*
+-------------------------
+ST_HoldPosition
+-------------------------
+*/
+
+static void Grenadier_HoldPosition( void )
+{
+	NPC_FreeCombatPoint( NPCInfo->combatPoint, qtrue );
+	NPCInfo->goalEntity = NULL;
+	
+	/*if ( TIMER_Done( NPC, "stand" ) )
+	{//FIXME: what if can't shoot from this pos?
+		TIMER_Set( NPC, "duck", Q_irand( 2000, 4000 ) );
+	}
+	*/
+}
+
+/*
+-------------------------
+ST_Move
+-------------------------
+*/
+
+static qboolean Grenadier_Move( void )
+{
+	NPCInfo->combatMove = qtrue;//always move straight toward our goal
+
+	qboolean	moved = NPC_MoveToGoal( qtrue );
+//	navInfo_t	info;
+	
+	//Get the move info
+//	NAV_GetLastMove( info );
+
+	//FIXME: if we bump into another one of our guys and can't get around him, just stop!
+	//If we hit our target, then stop and fire!
+//	if ( info.flags & NIF_COLLISION ) 
+//	{
+//		if ( info.blocker == NPC->enemy )
+//		{
+//			Grenadier_HoldPosition();
+//		}
+//	}
+
+	//If our move failed, then reset
+	if ( moved == qfalse )
+	{//couldn't get to enemy
+		if ( (NPCInfo->scriptFlags&SCF_CHASE_ENEMIES) && NPC->client->ps.weapon == WP_THERMAL && NPCInfo->goalEntity && NPCInfo->goalEntity == NPC->enemy )
+		{//we were running after enemy
+			//Try to find a combat point that can hit the enemy
+			int cpFlags = (CP_CLEAR|CP_HAS_ROUTE);
+			if ( NPCInfo->scriptFlags&SCF_USE_CP_NEAREST )
+			{
+				cpFlags &= ~(CP_FLANK|CP_APPROACH_ENEMY|CP_CLOSEST);
+				cpFlags |= CP_NEAREST;
+			}
+			int cp = NPC_FindCombatPoint( NPC->currentOrigin, NPC->currentOrigin, NPC->currentOrigin, cpFlags, 32 );
+			if ( cp == -1 && !(NPCInfo->scriptFlags&SCF_USE_CP_NEAREST) )
+			{//okay, try one by the enemy
+				cp = NPC_FindCombatPoint( NPC->currentOrigin, NPC->currentOrigin, NPC->enemy->currentOrigin, CP_CLEAR|CP_HAS_ROUTE|CP_HORZ_DIST_COLL, 32 );
+			}
+			//NOTE: there may be a perfectly valid one, just not one within CP_COLLECT_RADIUS of either me or him...
+			if ( cp != -1 )
+			{//found a combat point that has a clear shot to enemy
+				NPC_SetCombatPoint( cp );
+				NPC_SetMoveGoal( NPC, level.combatPoints[cp].origin, 8, qtrue, cp );
+				return moved;
+			}
+		}
+		//just hang here
+		Grenadier_HoldPosition();
+	}
+
+	return moved;
+}
+
+/*
+-------------------------
+NPC_BSGrenadier_Patrol
+-------------------------
+*/
+
+void NPC_BSGrenadier_Patrol( void )
+{//FIXME: pick up on bodies of dead buddies?
+	if ( NPCInfo->confusionTime < level.time )
+	{
+		//Look for any enemies
+		if ( NPCInfo->scriptFlags&SCF_LOOK_FOR_ENEMIES )
+		{
+			if ( NPC_CheckPlayerTeamStealth() )
+			{
+				//NPCInfo->behaviorState = BS_HUNT_AND_KILL;//should be automatic now
+				//NPC_AngerSound();
+				NPC_UpdateAngles( qtrue, qtrue );
+				return;
+			}
+		}
+
+		if ( !(NPCInfo->scriptFlags&SCF_IGNORE_ALERTS) )
+		{
+			//Is there danger nearby
+			int alertEvent = NPC_CheckAlertEvents( qtrue, qtrue, -1, qfalse, AEL_SUSPICIOUS );
+			if ( NPC_CheckForDanger( alertEvent ) )
+			{
+				NPC_UpdateAngles( qtrue, qtrue );
+				return;
+			}
+			else
+			{//check for other alert events
+				//There is an event to look at
+				if ( alertEvent >= 0 )//&& level.alertEvents[alertEvent].ID != NPCInfo->lastAlertID )
+				{
+					//NPCInfo->lastAlertID = level.alertEvents[alertEvent].ID;
+					if ( level.alertEvents[alertEvent].level == AEL_DISCOVERED )
+					{
+						if ( level.alertEvents[alertEvent].owner && 
+							level.alertEvents[alertEvent].owner->client && 
+							level.alertEvents[alertEvent].owner->health >= 0 &&
+							level.alertEvents[alertEvent].owner->client->playerTeam == NPC->client->enemyTeam )
+						{//an enemy
+							G_SetEnemy( NPC, level.alertEvents[alertEvent].owner );
+							//NPCInfo->enemyLastSeenTime = level.time;
+							TIMER_Set( NPC, "attackDelay", Q_irand( 500, 2500 ) );
+						}
+					}
+					else
+					{//FIXME: get more suspicious over time?
+						//Save the position for movement (if necessary)
+						VectorCopy( level.alertEvents[alertEvent].position, NPCInfo->investigateGoal );
+						NPCInfo->investigateDebounceTime = level.time + Q_irand( 500, 1000 );
+						if ( level.alertEvents[alertEvent].level == AEL_SUSPICIOUS )
+						{//suspicious looks longer
+							NPCInfo->investigateDebounceTime += Q_irand( 500, 2500 );
+						}
+					}
+				}
+			}
+
+			if ( NPCInfo->investigateDebounceTime > level.time )
+			{//FIXME: walk over to it, maybe?  Not if not chase enemies
+				//NOTE: stops walking or doing anything else below
+				vec3_t	dir, angles;
+				float	o_yaw, o_pitch;
+				
+				VectorSubtract( NPCInfo->investigateGoal, NPC->client->renderInfo.eyePoint, dir );
+				vectoangles( dir, angles );
+				
+				o_yaw = NPCInfo->desiredYaw;
+				o_pitch = NPCInfo->desiredPitch;
+				NPCInfo->desiredYaw = angles[YAW];
+				NPCInfo->desiredPitch = angles[PITCH];
+				
+				NPC_UpdateAngles( qtrue, qtrue );
+
+				NPCInfo->desiredYaw = o_yaw;
+				NPCInfo->desiredPitch = o_pitch;
+				return;
+			}
+		}
+	}
+
+	//If we have somewhere to go, then do that
+	if ( UpdateGoal() )
+	{
+		ucmd.buttons |= BUTTON_WALKING;
+		NPC_MoveToGoal( qtrue );
+	}
+
+	NPC_UpdateAngles( qtrue, qtrue );
+}
+
+/*
+-------------------------
+NPC_BSGrenadier_Idle
+-------------------------
+*/
+/*
+void NPC_BSGrenadier_Idle( void )
+{
+	//FIXME: check for other alert events?
+
+	//Is there danger nearby?
+	if ( NPC_CheckForDanger( NPC_CheckAlertEvents( qtrue, qtrue, -1, qfalse, AEL_DANGER ) ) )
+	{
+		NPC_UpdateAngles( qtrue, qtrue );
+		return;
+	}
+
+	TIMER_Set( NPC, "roamTime", 2000 + Q_irand( 1000, 2000 ) );
+
+	NPC_UpdateAngles( qtrue, qtrue );
+}
+*/
+/*
+-------------------------
+ST_CheckMoveState
+-------------------------
+*/
+
+static void Grenadier_CheckMoveState( void )
+{
+	//See if we're a scout
+	if ( !(NPCInfo->scriptFlags & SCF_CHASE_ENEMIES) )//behaviorState == BS_STAND_AND_SHOOT )
+	{
+		if ( NPCInfo->goalEntity == NPC->enemy )
+		{
+			move = qfalse;
+			return;
+		}
+	}
+	//See if we're running away
+	else if ( NPCInfo->squadState == SQUAD_RETREAT )
+	{
+		if ( TIMER_Done( NPC, "flee" ) )
+		{
+			NPCInfo->squadState = SQUAD_IDLE;
+		}
+		else
+		{
+			faceEnemy = qfalse;
+		}
+	}
+	/*
+	else if ( NPCInfo->squadState == SQUAD_IDLE )
+	{
+		if ( !NPCInfo->goalEntity )
+		{
+			move = qfalse;
+			return;
+		}
+		//Should keep moving toward player when we're out of range... right?
+	}
+	*/
+
+	//See if we're moving towards a goal, not the enemy
+	if ( ( NPCInfo->goalEntity != NPC->enemy ) && ( NPCInfo->goalEntity != NULL ) )
+	{
+		//Did we make it?
+		if ( STEER::Reached(NPC, NPCInfo->goalEntity, 16, !!FlyingCreature(NPC)) || 
+			( NPCInfo->squadState == SQUAD_SCOUT && enemyLOS && enemyDist <= 10000 ) )
+		{
+			int	newSquadState = SQUAD_STAND_AND_SHOOT;
+			//we got where we wanted to go, set timers based on why we were running
+			switch ( NPCInfo->squadState )
+			{
+			case SQUAD_RETREAT://was running away
+				TIMER_Set( NPC, "duck", (NPC->max_health - NPC->health) * 100 );
+				TIMER_Set( NPC, "hideTime", Q_irand( 3000, 7000 ) );
+				newSquadState = SQUAD_COVER;
+				break;
+			case SQUAD_TRANSITION://was heading for a combat point
+				TIMER_Set( NPC, "hideTime", Q_irand( 2000, 4000 ) );
+				break;
+			case SQUAD_SCOUT://was running after player
+				break;
+			default:
+				break;
+			}
+			NPC_ReachedGoal();
+			//don't attack right away
+			TIMER_Set( NPC, "attackDelay", Q_irand( 250, 500 ) );	//FIXME: Slant for difficulty levels
+			//don't do something else just yet
+			TIMER_Set( NPC, "roamTime", Q_irand( 1000, 4000 ) );
+			//stop fleeing
+			if ( NPCInfo->squadState == SQUAD_RETREAT )
+			{
+				TIMER_Set( NPC, "flee", -level.time );
+				NPCInfo->squadState = SQUAD_IDLE;
+			}
+			return;
+		}
+
+		//keep going, hold of roamTimer until we get there
+		TIMER_Set( NPC, "roamTime", Q_irand( 4000, 8000 ) );
+	}
+
+	if ( !NPCInfo->goalEntity )
+	{
+		if ( NPCInfo->scriptFlags & SCF_CHASE_ENEMIES )
+		{
+			NPCInfo->goalEntity = NPC->enemy;
+			NPCInfo->goalRadius = (NPC->maxs[0]*1.5f);
+		}
+	}
+}
+
+/*
+-------------------------
+ST_CheckFireState
+-------------------------
+*/
+
+static void Grenadier_CheckFireState( void )
+{
+	if ( enemyCS )
+	{//if have a clear shot, always try
+		return;
+	}
+
+	if ( NPCInfo->squadState == SQUAD_RETREAT || NPCInfo->squadState == SQUAD_TRANSITION || NPCInfo->squadState == SQUAD_SCOUT )
+	{//runners never try to fire at the last pos
+		return;
+	}
+
+	if ( !VectorCompare( NPC->client->ps.velocity, vec3_origin ) )
+	{//if moving at all, don't do this
+		return;
+	}
+
+	//continue to fire on their last position
+	/*
+	if ( !Q_irand( 0, 1 ) && NPCInfo->enemyLastSeenTime && level.time - NPCInfo->enemyLastSeenTime < 4000 )
+	{
+		//Fire on the last known position
+		vec3_t	muzzle, dir, angles;
+
+		CalcEntitySpot( NPC, SPOT_WEAPON, muzzle );
+		VectorSubtract( NPCInfo->enemyLastSeenLocation, muzzle, dir );
+
+		VectorNormalize( dir );
+
+		vectoangles( dir, angles );
+
+		NPCInfo->desiredYaw		= angles[YAW];
+		NPCInfo->desiredPitch	= angles[PITCH];
+		//FIXME: they always throw toward enemy, so this will be very odd...
+		shoot = qtrue;
+		faceEnemy = qfalse;
+
+		return;
+	}
+	*/
+}
+
+qboolean Grenadier_EvaluateShot( int hit )
+{
+	if ( !NPC->enemy )
+	{
+		return qfalse;
+	}
+
+	if ( hit == NPC->enemy->s.number || (&g_entities[hit] != NULL && (g_entities[hit].svFlags&SVF_GLASS_BRUSH)) )
+	{//can hit enemy or will hit glass, so shoot anyway
+		return qtrue;
+	}
+	return qfalse;
+}
+
+/*
+-------------------------
+NPC_BSGrenadier_Attack
+-------------------------
+*/
+
+void NPC_BSGrenadier_Attack( void )
+{
+	//Don't do anything if we're hurt
+	if ( NPC->painDebounceTime > level.time )
+	{
+		NPC_UpdateAngles( qtrue, qtrue );
+		return;
+	}
+
+	//NPC_CheckEnemy( qtrue, qfalse );
+	//If we don't have an enemy, just idle
+	if ( NPC_CheckEnemyExt() == qfalse )//!NPC->enemy )//
+	{
+		NPC_BSGrenadier_Patrol();//FIXME: or patrol?
+		return;
+	}
+
+	if ( TIMER_Done( NPC, "flee" ) && NPC_CheckForDanger( NPC_CheckAlertEvents( qtrue, qtrue, -1, qfalse, AEL_DANGER ) ) )
+	{//going to run
+		NPC_UpdateAngles( qtrue, qtrue );
+		return;
+	}
+
+	if ( !NPC->enemy )
+	{//WTF?  somehow we lost our enemy?
+		NPC_BSGrenadier_Patrol();//FIXME: or patrol?
+		return;
+	}
+
+	enemyLOS = enemyCS = qfalse;
+	move = qtrue;
+	faceEnemy = qfalse;
+	shoot = qfalse;
+	enemyDist = DistanceSquared( NPC->enemy->currentOrigin, NPC->currentOrigin );
+
+	//See if we should switch to melee attack
+	if ( enemyDist < 16384 && (!NPC->enemy->client||NPC->enemy->client->ps.weapon != WP_SABER||(!NPC->enemy->client->ps.SaberActive())) )//128
+	{//enemy is close and not using saber
+		if ( NPC->client->ps.weapon == WP_THERMAL )
+		{//grenadier
+			trace_t	trace;
+			gi.trace ( &trace, NPC->currentOrigin, NPC->enemy->mins, NPC->enemy->maxs, NPC->enemy->currentOrigin, NPC->s.number, NPC->enemy->clipmask );
+			if ( !trace.allsolid && !trace.startsolid && (trace.fraction == 1.0 || trace.entityNum == NPC->enemy->s.number ) )
+			{//I can get right to him
+				//reset fire-timing variables
+				NPC_ChangeWeapon( WP_MELEE );
+				if ( !(NPCInfo->scriptFlags&SCF_CHASE_ENEMIES) )//NPCInfo->behaviorState == BS_STAND_AND_SHOOT )
+				{//FIXME: should we be overriding scriptFlags?
+					NPCInfo->scriptFlags |= SCF_CHASE_ENEMIES;//NPCInfo->behaviorState = BS_HUNT_AND_KILL;
+				}
+			}
+		}
+	}
+	else if ( enemyDist > 65536 || (NPC->enemy->client && NPC->enemy->client->ps.weapon == WP_SABER && NPC->enemy->client->ps.SaberActive()) )//256
+	{//enemy is far or using saber
+		if ( NPC->client->ps.weapon == WP_MELEE && (NPC->client->ps.stats[STAT_WEAPONS]&(1<<WP_THERMAL)) )
+		{//fisticuffs, make switch to thermal if have it
+			//reset fire-timing variables
+			NPC_ChangeWeapon( WP_THERMAL );
+		}
+	}
+
+	//can we see our target?
+	if ( NPC_ClearLOS( NPC->enemy ) )
+	{
+		NPCInfo->enemyLastSeenTime = level.time;
+		enemyLOS = qtrue;
+
+		if ( NPC->client->ps.weapon == WP_MELEE )
+		{
+			if ( enemyDist <= 4096 && InFOV( NPC->enemy->currentOrigin, NPC->currentOrigin, NPC->client->ps.viewangles, 90, 45 ) )//within 64 & infront
+			{
+				VectorCopy( NPC->enemy->currentOrigin, NPCInfo->enemyLastSeenLocation );
+				enemyCS = qtrue;
+			}
+		}
+		else if ( InFOV( NPC->enemy->currentOrigin, NPC->currentOrigin, NPC->client->ps.viewangles, 45, 90 ) )
+		{//in front of me 
+			//can we shoot our target?
+			//FIXME: how accurate/necessary is this check?
+			int hit = NPC_ShotEntity( NPC->enemy );
+			gentity_t *hitEnt = &g_entities[hit];
+			if ( hit == NPC->enemy->s.number 
+				|| ( hitEnt && hitEnt->client && hitEnt->client->playerTeam == NPC->client->enemyTeam ) )
+			{
+				VectorCopy( NPC->enemy->currentOrigin, NPCInfo->enemyLastSeenLocation );
+				float enemyHorzDist = DistanceHorizontalSquared( NPC->enemy->currentOrigin, NPC->currentOrigin );
+				if ( enemyHorzDist < 1048576 )
+				{//within 1024
+					enemyCS = qtrue;
+					NPC_AimAdjust( 2 );//adjust aim better longer we have clear shot at enemy
+				}
+				else
+				{
+					NPC_AimAdjust( 1 );//adjust aim better longer we can see enemy
+				}
+			}
+		}
+	}
+	else
+	{
+		NPC_AimAdjust( -1 );//adjust aim worse longer we cannot see enemy
+	}
+	/*
+	else if ( gi.inPVS( NPC->enemy->currentOrigin, NPC->currentOrigin ) )
+	{
+		NPCInfo->enemyLastSeenTime = level.time;
+		faceEnemy = qtrue;
+	}
+	*/
+
+	if ( enemyLOS )
+	{//FIXME: no need to face enemy if we're moving to some other goal and he's too far away to shoot?
+		faceEnemy = qtrue;
+	}
+
+	if ( enemyCS )
+	{
+		shoot = qtrue;
+		if ( NPC->client->ps.weapon == WP_THERMAL )
+		{//don't chase and throw
+			move = qfalse;
+		}
+		else if ( NPC->client->ps.weapon == WP_MELEE && enemyDist < (NPC->maxs[0]+NPC->enemy->maxs[0]+16)*(NPC->maxs[0]+NPC->enemy->maxs[0]+16) )
+		{//close enough
+			move = qfalse;
+		}
+	}//this should make him chase enemy when out of range...?
+
+	//Check for movement to take care of
+	Grenadier_CheckMoveState();
+
+	//See if we should override shooting decision with any special considerations
+	Grenadier_CheckFireState();
+
+	if ( move )
+	{//move toward goal
+		if ( NPCInfo->goalEntity )//&& ( NPCInfo->goalEntity != NPC->enemy || enemyDist > 10000 ) )//100 squared
+		{
+			move = Grenadier_Move();
+		}
+		else
+		{
+			move = qfalse;
+		}
+	}
+
+	if ( !move )
+	{
+		if ( !TIMER_Done( NPC, "duck" ) )
+		{
+			ucmd.upmove = -127;
+		}
+		//FIXME: what about leaning?
+	}
+	else
+	{//stop ducking!
+		TIMER_Set( NPC, "duck", -1 );
+	}
+
+	if ( !faceEnemy )
+	{//we want to face in the dir we're running
+		if ( move )
+		{//don't run away and shoot
+			NPCInfo->desiredYaw = NPCInfo->lastPathAngles[YAW];
+			NPCInfo->desiredPitch = 0;
+			shoot = qfalse;
+		}
+		NPC_UpdateAngles( qtrue, qtrue );
+	}
+	else// if ( faceEnemy )
+	{//face the enemy
+		NPC_FaceEnemy();
+	}
+
+	if ( NPCInfo->scriptFlags&SCF_DONT_FIRE )
+	{
+		shoot = qfalse;
+	}
+
+	//FIXME: don't shoot right away!
+	if ( shoot )
+	{//try to shoot if it's time
+		if ( TIMER_Done( NPC, "attackDelay" ) )
+		{	
+			if( !(NPCInfo->scriptFlags & SCF_FIRE_WEAPON) ) // we've already fired, no need to do it again here
+			{
+				WeaponThink( qtrue );
+				TIMER_Set( NPC, "attackDelay", NPCInfo->shotTime-level.time );
+			}
+			
+		}
+	}
+}
+
+void NPC_BSGrenadier_Default( void )
+{
+	if( NPCInfo->scriptFlags & SCF_FIRE_WEAPON )
+	{
+		WeaponThink( qtrue );
+	}
+
+	if( !NPC->enemy )
+	{//don't have an enemy, look for one
+		NPC_BSGrenadier_Patrol();
+	}
+	else//if ( NPC->enemy )
+	{//have an enemy
+		NPC_BSGrenadier_Attack();
+	}
+}
diff --git a/code/game/AI_HazardTrooper.cpp b/code/game/AI_HazardTrooper.cpp
new file mode 100644
index 0000000..45f8cda
--- /dev/null
+++ b/code/game/AI_HazardTrooper.cpp
@@ -0,0 +1,1571 @@
+////////////////////////////////////////////////////////////////////////////////////////
+// RAVEN SOFTWARE - STAR WARS: JK II
+//  (c) 2002 Activision
+//
+// Troopers
+//
+// TODO
+// ----
+//
+//
+//
+//
+// leave this line at the top of all AI_xxxx.cpp files for PCH reasons...
+////////////////////////////////////////////////////////////////////////////////////////
+#include "g_headers.h"
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Includes
+////////////////////////////////////////////////////////////////////////////////////////
+#include "b_local.h"
+#if !defined(RAVL_VEC_INC)
+	#include "..\Ravl\CVec.h"
+#endif
+#if !defined(RATL_ARRAY_VS_INC)
+	#include "..\Ratl\array_vs.h"
+#endif
+#if !defined(RATL_VECTOR_VS_INC)
+	#include "..\Ratl\vector_vs.h"
+#endif
+#if !defined(RATL_HANDLE_POOL_VS_INC)
+	#include "..\Ratl\handle_pool_vs.h"
+#endif
+#if !defined(RUFL_HSTRING_INC)
+	#include "..\Rufl\hstring.h"
+#endif
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Defines 
+////////////////////////////////////////////////////////////////////////////////////////
+#define		MAX_TROOPS				100
+#define		MAX_ENTS_PER_TROOP		7
+#define		MAX_TROOP_JOIN_DIST2	1000000  //1000 units
+#define		MAX_TROOP_MERGE_DIST2	250000   //500 units
+#define		TARGET_POS_VISITED		10000    //100 units
+
+
+bool NPC_IsTrooper(gentity_t* actor);
+
+enum
+{
+	SPEECH_CHASE,
+	SPEECH_CONFUSED,
+	SPEECH_COVER,
+	SPEECH_DETECTED,
+	SPEECH_GIVEUP,
+	SPEECH_LOOK,
+	SPEECH_LOST,
+	SPEECH_OUTFLANK,
+	SPEECH_ESCAPING,
+	SPEECH_SIGHT,
+	SPEECH_SOUND,
+	SPEECH_SUSPICIOUS,
+	SPEECH_YELL,
+	SPEECH_PUSHED
+};
+extern void G_AddVoiceEvent( gentity_t *self, int event, int speakDebounceTime );
+static void HT_Speech( gentity_t *self, int speechType, float failChance )
+{
+	if ( random() < failChance )
+	{
+		return;
+	}
+
+	if ( failChance >= 0 )
+	{//a negative failChance makes it always talk
+		if ( self->NPC->group )
+		{//group AI speech debounce timer
+			if ( self->NPC->group->speechDebounceTime > level.time )
+			{
+				return;
+			}
+			/*
+			else if ( !self->NPC->group->enemy )
+			{
+				if ( groupSpeechDebounceTime[self->client->playerTeam] > level.time )
+				{
+					return;
+				}
+			}
+			*/
+		}
+		else if ( !TIMER_Done( self, "chatter" ) )
+		{//personal timer
+			return;
+		}
+	}
+
+	TIMER_Set( self, "chatter", Q_irand( 2000, 4000 ) );
+
+	if ( self->NPC->blockedSpeechDebounceTime > level.time )
+	{
+		return;
+	}
+
+	switch( speechType )
+	{
+	case SPEECH_CHASE:
+		G_AddVoiceEvent( self, Q_irand(EV_CHASE1, EV_CHASE3), 2000 );
+		break;
+	case SPEECH_CONFUSED:
+		G_AddVoiceEvent( self, Q_irand(EV_CONFUSE1, EV_CONFUSE3), 2000 );
+		break;
+	case SPEECH_COVER:
+		G_AddVoiceEvent( self, Q_irand(EV_COVER1, EV_COVER5), 2000 );
+		break;
+	case SPEECH_DETECTED:
+		G_AddVoiceEvent( self, Q_irand(EV_DETECTED1, EV_DETECTED5), 2000 );
+		break;
+	case SPEECH_GIVEUP:
+		G_AddVoiceEvent( self, Q_irand(EV_GIVEUP1, EV_GIVEUP4), 2000 );
+		break;
+	case SPEECH_LOOK:
+		G_AddVoiceEvent( self, Q_irand(EV_LOOK1, EV_LOOK2), 2000 );
+		break;
+	case SPEECH_LOST:
+		G_AddVoiceEvent( self, EV_LOST1, 2000 );
+		break;
+	case SPEECH_OUTFLANK:
+		G_AddVoiceEvent( self, Q_irand(EV_OUTFLANK1, EV_OUTFLANK2), 2000 );
+		break;
+	case SPEECH_ESCAPING:
+		G_AddVoiceEvent( self, Q_irand(EV_ESCAPING1, EV_ESCAPING3), 2000 );
+		break;
+	case SPEECH_SIGHT:
+		G_AddVoiceEvent( self, Q_irand(EV_SIGHT1, EV_SIGHT3), 2000 );
+		break;
+	case SPEECH_SOUND:
+		G_AddVoiceEvent( self, Q_irand(EV_SOUND1, EV_SOUND3), 2000 );
+		break;
+	case SPEECH_SUSPICIOUS:
+		G_AddVoiceEvent( self, Q_irand(EV_SUSPICIOUS1, EV_SUSPICIOUS5), 2000 );
+		break;
+	case SPEECH_YELL:
+		G_AddVoiceEvent( self, Q_irand( EV_ANGER1, EV_ANGER3 ), 2000 );
+		break;
+	case SPEECH_PUSHED:
+		G_AddVoiceEvent( self, Q_irand( EV_PUSHED1, EV_PUSHED3 ), 2000 );
+		break;
+	default:
+		break;
+	}
+
+	self->NPC->blockedSpeechDebounceTime = level.time + 2000;
+}
+
+
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// The Troop
+//
+// Troopers primarly derive their behavior from cooperation as a collective group of
+// individuals.  They join Troops, each of which has a leader responsible for direcing
+// the movement of the rest of the group.
+//
+////////////////////////////////////////////////////////////////////////////////////////
+class	CTroop
+{
+	////////////////////////////////////////////////////////////////////////////////////
+	// Various Troop Wide Data
+	////////////////////////////////////////////////////////////////////////////////////
+	int				mTroopHandle;
+	int				mTroopTeam;
+	bool			mTroopReform;
+
+	float			mFormSpacingFwd;
+	float			mFormSpacingRight;
+	float			mSurroundFanAngle;
+
+public:
+	bool	Empty()					{return mActors.empty();}
+	int		Team()					{return mTroopTeam;}
+	int		Handle()				{return mTroopHandle;}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Initialize - Clear out all data, all actors, reset all variables
+	////////////////////////////////////////////////////////////////////////////////////
+	void	Initialize(int TroopHandle=0)
+	{
+		mActors.clear();
+		mTarget			= 0;
+		mState			= TS_NONE;
+		mTroopHandle	= TroopHandle;
+		mTroopTeam		= 0;
+		mTroopReform	= false;
+	}
+	////////////////////////////////////////////////////////////////////////////////////
+	// DistanceSq - Quick Operation to see how far an ent is from the rest of the troop
+	////////////////////////////////////////////////////////////////////////////////////
+	float	DistanceSq(gentity_t* ent)
+	{
+		if (mActors.size())
+		{
+			return DistanceSquared(ent->currentOrigin, mActors[0]->currentOrigin);
+		}
+		return 0.0f;
+	}
+
+
+
+
+
+
+
+
+
+
+private:
+	////////////////////////////////////////////////////////////////////////////////////
+	// The Actors
+	//
+	// Actors are all the troopers who belong to the group, their positions in this
+	// vector affect their positions in the troop, whith the first actor as the leader
+	////////////////////////////////////////////////////////////////////////////////////
+	ratl::vector_vs<gentity_t*, MAX_ENTS_PER_TROOP>	mActors;
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// MakeActorLeader - Move A Given Index To A Leader Position
+	////////////////////////////////////////////////////////////////////////////////////
+	void		MakeActorLeader(int index)
+	{
+		if (index!=0)
+		{
+			mActors[0]->client->leader = 0;
+			mActors.swap(index, 0);
+		}
+		mActors[0]->client->leader = mActors[0];
+		if (mActors[0])
+		{
+			if (mActors[0]->client->NPC_class==CLASS_HAZARD_TROOPER)
+			{
+				mFormSpacingFwd		= 75.0f;
+				mFormSpacingRight	= 50.0f;
+			}
+			else
+			{
+				mFormSpacingFwd		= 75.0f;
+				mFormSpacingRight	= 20.0f;
+			}
+		}
+	}
+
+public:
+	////////////////////////////////////////////////////////////////////////////////////
+	// AddActor - Adds a new actor to the troop & automatically promote to leader
+	////////////////////////////////////////////////////////////////////////////////////
+	void	AddActor(gentity_t* actor)
+	{
+		assert(actor->NPC->troop==0 && !mActors.full());
+		actor->NPC->troop = mTroopHandle;
+		mActors.push_back(actor);
+		mTroopReform = true;
+		if ((mActors.size()==1) || (actor->NPC->rank > mActors[0]->NPC->rank))
+		{
+			MakeActorLeader(mActors.size()-1);
+		}
+		if (!mTroopTeam)
+		{
+			mTroopTeam = actor->client->playerTeam;
+		}
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// RemoveActor - Removes an actor from the troop & automatically promote leader
+	////////////////////////////////////////////////////////////////////////////////////
+	void	RemoveActor(gentity_t* actor)
+	{
+		assert(actor->NPC->troop==mTroopHandle);
+		int		bestNewLeader=-1;
+		int		numEnts = mActors.size();
+		bool	found = false;
+		mTroopReform = true;
+
+		// Find The Actor
+		//----------------
+		for (int i=0; i<numEnts; i++)
+		{
+			if (mActors[i]==actor)
+			{
+				found = true;
+				mActors.erase_swap(i);
+				numEnts --;
+				if (i==0 && !mActors.empty())
+				{
+					bestNewLeader = 0;
+				}
+			}
+
+			if (bestNewLeader>=0 && (mActors[i]->NPC->rank > mActors[bestNewLeader]->NPC->rank))
+			{
+				bestNewLeader = i;
+			}
+		}
+		if (!mActors.empty() && bestNewLeader>=0)
+		{
+			MakeActorLeader(bestNewLeader);
+		}
+
+		assert(found);
+		actor->NPC->troop = 0;
+	}
+
+	
+
+
+
+
+
+
+
+
+
+private:
+	////////////////////////////////////////////////////////////////////////////////////
+	// Enemy
+	//
+	// The troop has a collective enemy that it knows about, which is updated by all
+	// the members of the group;
+	////////////////////////////////////////////////////////////////////////////////////
+	gentity_t*		mTarget;
+	bool			mTargetVisable;
+	int				mTargetVisableStartTime;
+	int				mTargetVisableStopTime;
+	CVec3			mTargetVisablePosition;
+	int				mTargetIndex;
+	int				mTargetLastKnownTime;
+	CVec3			mTargetLastKnownPosition;
+	bool			mTargetLastKnownPositionVisited;
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// RegisterTarget - Records That the target is seen, when and where
+	////////////////////////////////////////////////////////////////////////////////////
+	void			RegisterTarget(gentity_t* target, int index, bool visable)
+	{
+		if (!mTarget)
+		{
+			HT_Speech(mActors[0], SPEECH_DETECTED, 0);
+		}
+		else if ((level.time - mTargetLastKnownTime)>8000)
+		{
+			HT_Speech(mActors[0], SPEECH_SIGHT, 0);
+		}
+
+		if (visable)
+		{
+			mTargetVisableStopTime = level.time;
+			if (!mTargetVisable)
+			{
+				mTargetVisableStartTime = level.time;
+			}
+
+ 			CalcEntitySpot(target, SPOT_HEAD, mTargetVisablePosition.v);
+			mTargetVisablePosition[2] -= 10.0f;
+		}
+
+		mTarget							= target;
+		mTargetVisable					= visable;
+		mTargetIndex					= index;
+		mTargetLastKnownTime			= level.time;
+		mTargetLastKnownPosition		= target->currentOrigin;
+		mTargetLastKnownPositionVisited = false;
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// RegisterTarget - Records That the target is seen, when and where
+	////////////////////////////////////////////////////////////////////////////////////
+	bool			TargetLastKnownPositionVisited()
+	{
+		if (!mTargetLastKnownPositionVisited)
+		{
+			float dist = DistanceSquared(mTargetLastKnownPosition.v, mActors[0]->currentOrigin);
+			mTargetLastKnownPositionVisited = (dist<TARGET_POS_VISITED);
+		}
+		return mTargetLastKnownPositionVisited;
+	}
+
+	float			ClampScale(float val)
+	{
+		if (val>1.0f)
+		{
+			val = 1.0f;
+		}
+		if (val<0.0f)
+		{
+			val = 0.0f;
+		}
+		return val;
+	}
+	
+	////////////////////////////////////////////////////////////////////////////////////
+	// Target Visibility
+	//
+	// Compute all factors that can add visibility to a target
+	////////////////////////////////////////////////////////////////////////////////////
+	float			TargetVisibility(gentity_t*	target)
+	{
+		float	Scale = 0.8f;
+		if (target->client && target->client->ps.weapon==WP_SABER && target->client->ps.SaberActive())
+		{
+			Scale += 0.1f;
+		}
+		return ClampScale(Scale);
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	//
+	////////////////////////////////////////////////////////////////////////////////////
+	float			TargetNoiseLevel(gentity_t*	target)
+	{
+		float	Scale = 0.1f;
+		Scale	+= target->resultspeed / (float)g_speed->integer;
+		if (target->client && target->client->ps.weapon==WP_SABER && target->client->ps.SaberActive())
+		{
+			Scale += 0.2f;
+		}
+		return ClampScale(Scale);
+	}
+
+
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Scan For Enemies
+	////////////////////////////////////////////////////////////////////////////////////
+	void			ScanForTarget(int scannerIndex)
+	{
+		gentity_t*		target;
+		int				targetIndex=0;
+		int				targetStop=ENTITYNUM_WORLD;
+		CVec3			targetPos;
+		CVec3			targetDirection;
+		float			targetDistance;
+		float			targetVisibility;
+		float			targetNoiseLevel;
+
+		gentity_t*		scanner					= mActors[scannerIndex];
+		gNPCstats_t*	scannerStats			= &(scanner->NPC->stats);
+		float			scannerMaxViewDist		= scannerStats->visrange;
+		float			scannerMinVisability	= 0.1f;//1.0f - scannerStats->vigilance;
+		float			scannerMaxHearDist		= scannerStats->earshot;
+		float			scannerMinNoiseLevel	= 0.3f;//1.0f - scannerStats->vigilance;
+		CVec3			scannerPos(scanner->currentOrigin);
+		CVec3			scannerFwd(scanner->currentAngles);
+		scannerFwd.AngToVec();
+
+		// If Existing Target, Only Check It
+		//-----------------------------------
+		if (mTarget)
+		{
+			targetIndex		= mTargetIndex;
+			targetStop		= mTargetIndex+1;
+		}
+
+		SaveNPCGlobals();
+		SetNPCGlobals(scanner);
+
+	
+		for (; targetIndex<targetStop; targetIndex++)
+		{
+			target				= &g_entities[targetIndex];
+			if (!NPC_ValidEnemy(target))
+			{
+				continue;
+			}
+
+			targetPos			= target->currentOrigin;
+			if (target->client && target->client->ps.leanofs)
+			{
+				targetPos		= target->client->renderInfo.eyePoint;
+			}
+
+			targetDirection		= (targetPos - scannerPos);
+			targetDistance		= targetDirection.SafeNorm();
+
+			// Can The Scanner SEE The Target?
+			//---------------------------------
+			if (targetDistance<scannerMaxViewDist)
+			{
+				targetVisibility	= TargetVisibility(target);
+				targetVisibility	*= targetDirection.Dot(scannerFwd);
+				if (targetVisibility>scannerMinVisability)
+				{
+					if (NPC_ClearLOS(targetPos.v))
+					{
+						RegisterTarget(target, targetIndex, true);
+						RestoreNPCGlobals();
+						return;
+					}
+				}
+			}
+
+			// Can The Scanner HEAR The Target?
+			//----------------------------------
+			if (targetDistance<scannerMaxHearDist)
+			{
+				targetNoiseLevel = TargetNoiseLevel(target);
+				targetNoiseLevel *= (1.0f - (targetDistance/scannerMaxHearDist));	// scale by distance
+				if (targetNoiseLevel>scannerMinNoiseLevel)
+				{
+					RegisterTarget(target, targetIndex, false);
+					RestoreNPCGlobals();
+					return;
+				}
+			}
+		}
+		RestoreNPCGlobals();
+	}
+
+
+
+
+
+
+
+
+private:
+	////////////////////////////////////////////////////////////////////////////////////
+	// Troop State
+	//
+	// The troop as a whole can be acting under a number of different "behavior states"
+	////////////////////////////////////////////////////////////////////////////////////
+	enum ETroopState
+	{
+		TS_NONE = 0,				// No troop wide activity active
+
+		TS_ADVANCE,		// CHOOSE A NEW ADVANCE TACTIC
+		TS_ADVANCE_REGROUP,			// All ents move into squad position
+		TS_ADVANCE_SEARCH,			// Slow advance, looking left to right, in formation
+		TS_ADVANCE_COVER,			// One at a time moves forward, goes off path, provides cover
+		TS_ADVANCE_FORMATION,		// In formation jog to goal location
+
+		TS_ATTACK,		// CHOOSE A NEW ATTACK TACTIC
+		TS_ATTACK_LINE,				// Form 2 lines, front kneel, back stand
+		TS_ATTACK_FLANK,			// Same As Line, except scouting group attemts to get around other side of target
+		TS_ATTACK_SURROUND,			// Get on all sides of target
+		TS_ATTACK_COVER,			//
+
+		TS_MAX
+	};
+	ETroopState		mState;
+
+	CVec3			mFormHead;
+	CVec3			mFormFwd;
+	CVec3			mFormRight;
+
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// TroopInFormation - A quick check to see if the troop is currently in formation
+	////////////////////////////////////////////////////////////////////////////////////
+	bool	TroopInFormation()
+	{
+		float	maxActorRangeSq = ((mActors.size()/2) + 2) * mFormSpacingFwd;
+		maxActorRangeSq *= maxActorRangeSq;
+		for (int actorIndex=1; actorIndex<mActors.size(); actorIndex++)
+		{
+			if (DistanceSq(mActors[actorIndex])>maxActorRangeSq)
+			{
+				return false;
+			}
+		}
+		return true;
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// SActorOrder
+	////////////////////////////////////////////////////////////////////////////////////
+	struct	SActorOrder
+	{
+		CVec3	mPosition;
+		int		mCombatPoint;
+		bool	mKneelAndShoot;
+	};
+	ratl::array_vs<SActorOrder, MAX_ENTS_PER_TROOP>		mOrders;
+
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// LeaderIssueAndUpdateOrders - Tell Everyone Where To Go
+	////////////////////////////////////////////////////////////////////////////////////
+	void	LeaderIssueAndUpdateOrders(ETroopState NextState)
+	{
+		int		actorIndex;
+		int		actorCount = mActors.size();
+
+		// Always Put Guys Closest To The Order Locations In Those Locations
+		//-------------------------------------------------------------------
+ 		for (int orderIndex=1; orderIndex<actorCount; orderIndex++)
+		{
+			// Don't re-assign points combat point related orders
+			//----------------------------------------------------
+			if (mOrders[orderIndex].mCombatPoint==-1)
+			{
+				int		closestActorIndex		= orderIndex;
+				float	closestActorDistance	= DistanceSquared(mOrders[orderIndex].mPosition.v, mActors[orderIndex]->currentOrigin);
+				float	currentDistance			= closestActorDistance;
+				for (actorIndex=orderIndex+1; actorIndex<actorCount; actorIndex++)
+				{
+					currentDistance = DistanceSquared(mOrders[orderIndex].mPosition.v, mActors[actorIndex]->currentOrigin);
+					if (currentDistance<closestActorDistance)
+					{
+						closestActorDistance = currentDistance;
+						closestActorIndex = actorIndex;
+					}
+				}
+				if (orderIndex!=closestActorIndex)
+				{
+					mActors.swap(orderIndex, closestActorIndex);
+				}
+			}
+		}
+
+		// Now Copy The Orders Out To The Actors
+		//---------------------------------------
+		for (actorIndex=1; actorIndex<actorCount; actorIndex++)
+		{
+			VectorCopy(mOrders[actorIndex].mPosition.v, mActors[actorIndex]->pos1);
+		}
+
+// PHASE I - VOICE COMMANDS & ANIMATIONS
+//=======================================
+		gentity_t*	leader	= mActors[0];
+
+		if (NextState!=mState)
+		{
+			if (mActors.size()>0)
+			{
+				switch (NextState)
+				{
+				case (TS_ADVANCE_REGROUP) : 
+					{
+						break;
+					}
+				case (TS_ADVANCE_SEARCH) : 
+					{
+						HT_Speech(leader, SPEECH_LOOK, 0); 
+						break;
+					}
+				case (TS_ADVANCE_COVER) : 
+					{
+						HT_Speech(leader, SPEECH_COVER, 0); 
+						NPC_SetAnim(leader, SETANIM_TORSO, TORSO_HANDSIGNAL4, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLDLESS);
+						break;
+					}
+				case (TS_ADVANCE_FORMATION) : 
+					{
+						HT_Speech(leader, SPEECH_ESCAPING, 0); 
+						break;
+					}
+
+
+				case (TS_ATTACK_LINE) : 
+					{
+						HT_Speech(leader, SPEECH_CHASE, 0); 
+						NPC_SetAnim(leader, SETANIM_TORSO, TORSO_HANDSIGNAL1, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLDLESS);
+						break;
+					}
+				case (TS_ATTACK_FLANK) : 
+					{
+						HT_Speech(leader, SPEECH_OUTFLANK, 0); 
+						NPC_SetAnim(leader, SETANIM_TORSO, TORSO_HANDSIGNAL3, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLDLESS);
+						break;
+					}
+				case (TS_ATTACK_SURROUND) : 
+					{
+						HT_Speech(leader, SPEECH_GIVEUP, 0); 
+						NPC_SetAnim(leader, SETANIM_TORSO, TORSO_HANDSIGNAL2, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLDLESS);
+						break;
+					}
+				case (TS_ATTACK_COVER) : 
+					{
+						HT_Speech(leader, SPEECH_COVER, 0); 
+						break;
+					}
+				default:
+					{
+					}
+				}
+			}
+		}
+
+		// If Attacking, And Not Forced To Reform, Don't Recalculate Orders
+		//------------------------------------------------------------------
+		else if (NextState>TS_ATTACK && !mTroopReform)
+		{
+			return;
+		}
+
+
+// PHASE II - COMPUTE THE NEW FORMATION HEAD, FORWARD, AND RIGHT VECTORS
+//=======================================================================
+		CVec3	PreviousFwd = mFormFwd;
+
+		mFormHead	= leader->currentOrigin;
+		mFormFwd	= (NAV::HasPath(leader))?(NAV::NextPosition(leader)):(mTargetLastKnownPosition);
+		mFormFwd	-= mFormHead;
+		mFormFwd[2] = 0;
+		mFormFwd	*= -1.0f;				// Form Forward Goes Behind The Leader
+		mFormFwd.Norm();
+
+		mFormRight	= mFormFwd;
+		mFormRight.Cross(CVec3::mZ);
+
+
+		// Scale Vectors By Spacing Distances
+		//------------------------------------
+		mFormFwd	*= mFormSpacingFwd;
+		mFormRight	*= mFormSpacingRight;
+
+		// If Attacking, Move Head Forward Some To Center On Target
+		//----------------------------------------------------------
+ 		if (NextState>TS_ATTACK)
+		{
+ 			if (!mTroopReform)
+			{
+				int	FwdNum = ((actorCount/2)+1);
+				for (int i=0; i<FwdNum; i++)
+				{
+					mFormHead -= mFormFwd;
+				}
+			}
+			trace_t	trace;
+
+			mOrders[0].mPosition = mFormHead;
+
+			gi.trace(&trace, 
+					mActors[0]->currentOrigin, 
+					mActors[0]->mins, 
+					mActors[0]->maxs, 
+					mOrders[0].mPosition.v, 
+					mActors[0]->s.number, 
+					mActors[0]->clipmask
+					);
+
+			if (trace.fraction<1.0f)
+			{
+				mOrders[0].mPosition = trace.endpos;
+			}
+		}
+		else
+		{
+			mOrders[0].mPosition = mTargetLastKnownPosition;
+		}
+	
+		VectorCopy(mOrders[0].mPosition.v, mActors[0]->pos1);
+
+		CVec3		FormTgtToHead(mFormHead);
+					FormTgtToHead -= mTargetLastKnownPosition;
+		/*float		FormTgtToHeadDist = */FormTgtToHead.SafeNorm();
+
+		CVec3		BaseAngleToHead(FormTgtToHead);
+					BaseAngleToHead.VecToAng();
+
+//		int			NumPerSide = mActors.size()/2;
+//		float		WidestAngle = FORMATION_SURROUND_FAN * (NumPerSide+1);
+
+
+
+// PHASE III - USE FORMATION VECTORS TO COMPUTE ORDERS FOR ALL ACTORS
+//====================================================================
+		for (actorIndex=1; actorIndex<actorCount; actorIndex++)
+		{
+			SaveNPCGlobals();
+			SetNPCGlobals(mActors[actorIndex]);
+
+			SActorOrder&	Order = mOrders[actorIndex];
+			float			FwdScale = (float)((int)((actorIndex+1)/2));
+			float			SideScale = ((actorIndex%2)==0)?(-1.0f):(1.0f);
+
+			if (mActors[actorIndex]->NPC->combatPoint!=-1)
+			{
+				NPC_FreeCombatPoint(mActors[actorIndex]->NPC->combatPoint, false);
+				mActors[actorIndex]->NPC->combatPoint = -1;
+			}
+
+
+			Order.mPosition		= mFormHead;
+			Order.mCombatPoint	= -1;
+			Order.mKneelAndShoot= false;
+
+
+			// Advance Orders
+			//----------------
+			if (NextState<TS_ATTACK)
+			{
+				if ((NextState==TS_ADVANCE_REGROUP) ||	(NextState==TS_ADVANCE_SEARCH) || (NextState==TS_ADVANCE_FORMATION))
+				{
+					Order.mPosition.ScaleAdd(mFormFwd,		FwdScale);
+					Order.mPosition.ScaleAdd(mFormRight,	SideScale);
+				}
+				else if (NextState==TS_ADVANCE_COVER)
+				{
+					// TODO: Take Turns Switching Who Is In Front
+					Order.mPosition.ScaleAdd(mFormFwd,		FwdScale);
+					Order.mPosition.ScaleAdd(mFormRight,	SideScale);
+				}
+			}
+
+			// Setup Initial Attack Orders
+			//-----------------------------
+			else
+			{
+				if (NextState==TS_ATTACK_LINE || (NextState==TS_ATTACK_FLANK && actorIndex<4))
+				{
+					Order.mPosition.ScaleAdd(mFormFwd,		FwdScale);
+					Order.mPosition.ScaleAdd(mFormRight,		SideScale);
+				}
+				else if (NextState==TS_ATTACK_FLANK && actorIndex>=4)
+				{
+					int		cpFlags = (CP_HAS_ROUTE|CP_AVOID_ENEMY|CP_CLEAR|CP_COVER|CP_FLANK|CP_APPROACH_ENEMY);
+					float	avoidDist = 128.0f;
+
+					Order.mCombatPoint = NPC_FindCombatPointRetry( 
+											mActors[actorIndex]->currentOrigin, 
+											mActors[actorIndex]->currentOrigin, 
+											mActors[actorIndex]->currentOrigin, 
+											&cpFlags, 
+											avoidDist, 
+											0);
+
+					if (Order.mCombatPoint!=-1 && (cpFlags&CP_CLEAR))
+					{
+						Order.mPosition = level.combatPoints[Order.mCombatPoint].origin;
+						NPC_SetCombatPoint(Order.mCombatPoint);
+					}
+					else
+					{
+						Order.mPosition.ScaleAdd(mFormFwd,		FwdScale);
+						Order.mPosition.ScaleAdd(mFormRight,		SideScale);
+					}
+				}
+				else if (NextState==TS_ATTACK_SURROUND)
+				{
+					Order.mPosition.ScaleAdd(mFormFwd,		FwdScale);
+					Order.mPosition.ScaleAdd(mFormRight,		SideScale);
+
+/*					CVec3	FanAngles = BaseAngleToHead;
+					FanAngles[YAW] += (SideScale * (WidestAngle-(FwdScale*FORMATION_SURROUND_FAN)));
+					FanAngles.AngToVec();
+
+					Order.mPosition = mTargetLastKnownPosition;
+					Order.mPosition.ScaleAdd(FanAngles,		FormTgtToHeadDist);
+*/
+				}
+				else if (NextState==TS_ATTACK_COVER)
+				{
+					Order.mPosition.ScaleAdd(mFormFwd,		FwdScale);
+					Order.mPosition.ScaleAdd(mFormRight,		SideScale);
+				}
+			}
+
+			if (NextState>=TS_ATTACK)
+			{
+				trace_t	trace;
+				CVec3	OrderUp(Order.mPosition);
+				OrderUp[2] += 10.0f;
+
+				gi.trace(&trace, 
+					Order.mPosition.v, 
+					mActors[actorIndex]->mins, 
+					mActors[actorIndex]->maxs, 
+					OrderUp.v, 
+					mActors[actorIndex]->s.number, 
+					CONTENTS_SOLID|CONTENTS_TERRAIN|CONTENTS_MONSTERCLIP|CONTENTS_BOTCLIP);
+
+				if (trace.startsolid || trace.allsolid)
+				{
+					int		cpFlags = (CP_HAS_ROUTE|CP_AVOID_ENEMY|CP_CLEAR|CP_COVER|CP_FLANK|CP_APPROACH_ENEMY);
+					float	avoidDist = 128.0f;
+
+					Order.mCombatPoint = NPC_FindCombatPointRetry( 
+											mActors[actorIndex]->currentOrigin, 
+											mActors[actorIndex]->currentOrigin, 
+											mActors[actorIndex]->currentOrigin, 
+											&cpFlags, 
+											avoidDist, 
+											0);
+
+					if (Order.mCombatPoint!=-1)
+					{
+						Order.mPosition = level.combatPoints[Order.mCombatPoint].origin;
+						NPC_SetCombatPoint(Order.mCombatPoint);
+					}
+					else
+					{
+						Order.mPosition = mOrders[0].mPosition;
+					}
+				}
+			}
+			RestoreNPCGlobals();
+		}
+
+		mTroopReform = false;
+		mState = NextState;
+ 	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// SufficientCoverNearby - Look at nearby combat points, see if there is enough
+	////////////////////////////////////////////////////////////////////////////////////
+	bool	SufficientCoverNearby()
+	{
+		// TODO: Evaluate Available Combat Points
+		return false;
+	}
+
+
+
+
+
+
+
+
+public:
+	////////////////////////////////////////////////////////////////////////////////////
+	// Update - This is the primary "think" function from the troop
+	////////////////////////////////////////////////////////////////////////////////////
+	void	Update()
+	{
+		if (mActors.empty())
+		{
+			return;
+		}
+		ScanForTarget(0 /*Q_irand(0, (mActors.size()-1))*/);
+		if (mTarget)
+		{
+			ETroopState NextState			= mState;
+			int			TimeSinceLastSeen	= (level.time - mTargetVisableStopTime);
+		//	int			TimeVisable			= (mTargetVisableStopTime - mTargetVisableStartTime);
+			bool		Attack				= (TimeSinceLastSeen<2000);
+
+			if (Attack)
+			{
+				// If Not Currently Attacking, Or We Want To Pick A New Attack Tactic
+				//--------------------------------------------------------------------
+				if (mState<TS_ATTACK /*|| TODO: Timer To Pick New Tactic */)
+				{
+					if (TroopInFormation())
+					{
+						NextState = (mActors.size()>4)?(TS_ATTACK_FLANK):(TS_ATTACK_LINE);
+					}
+					else
+					{
+						NextState = (SufficientCoverNearby())?(TS_ATTACK_COVER):(TS_ATTACK_SURROUND);
+					}
+				}
+			}
+			else
+			{
+				if (!TroopInFormation())
+				{
+					NextState = TS_ADVANCE_REGROUP;
+				}
+				else
+				{
+					if (TargetLastKnownPositionVisited())
+					{
+						NextState = TS_ADVANCE_SEARCH;
+					}
+					else
+					{
+						NextState = (TimeSinceLastSeen<10000)?(TS_ADVANCE_COVER):(TS_ADVANCE_FORMATION);
+					}
+				}
+			}
+			LeaderIssueAndUpdateOrders(NextState);
+			
+		}
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// MergeInto - Merges all actors into anther troop
+	////////////////////////////////////////////////////////////////////////////////////
+	void	MergeInto(CTroop& Other)
+	{
+		int	numEnts = mActors.size();
+		for (int i=0; i<numEnts; i++)
+		{
+			mActors[i]->client->leader = 0;
+			mActors[i]->NPC->troop = 0;
+			Other.AddActor(mActors[i]);
+		}
+		mActors.clear();
+
+		if (!Other.mTarget && mTarget)
+		{
+			Other.mTarget							= mTarget;
+			Other.mTargetIndex						= mTargetIndex;
+			Other.mTargetLastKnownPosition			= mTargetLastKnownPosition;
+			Other.mTargetLastKnownPositionVisited	= mTargetLastKnownPositionVisited;
+			Other.mTargetLastKnownTime				= mTargetLastKnownTime;
+			Other.mTargetVisableStartTime			= mTargetVisableStartTime;
+			Other.mTargetVisableStopTime			= mTargetVisableStopTime;
+			Other.mTargetVisable					= mTargetVisable;
+			Other.mTargetVisablePosition			= mTargetVisablePosition;
+			Other.LeaderIssueAndUpdateOrders(mState);
+		}
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// 
+	////////////////////////////////////////////////////////////////////////////////////
+	gentity_t*	TrackingTarget()
+	{
+		return mTarget;
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// 
+	////////////////////////////////////////////////////////////////////////////////////
+	gentity_t*	TroopLeader()
+	{
+		return  mActors[0];
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// 
+	////////////////////////////////////////////////////////////////////////////////////
+	int			TimeSinceSeenTarget()
+	{
+		return (level.time - mTargetVisableStopTime);
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// 
+	////////////////////////////////////////////////////////////////////////////////////
+	CVec3&		TargetVisablePosition()
+	{
+		return mTargetVisablePosition;
+	}
+
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// 
+	////////////////////////////////////////////////////////////////////////////////////
+	float		FormSpacingFwd()
+	{
+		return mFormSpacingFwd;
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// 
+	////////////////////////////////////////////////////////////////////////////////////
+	gentity_t*	TooCloseToTroopMember(gentity_t* actor)
+	{
+		for (int i=0; i<mActors.size(); i++)
+		{
+			// Only avoid guys ahead of us in the formation
+			//----------------------------------------------
+			if (actor==mActors[i])
+			{
+				return 0;
+			}
+		//	if (mActors[i]->resultspeed<10.0f) 
+		//	{
+		//		continue;
+		//	}
+
+			if (i==0)
+			{
+				if (Distance(actor->currentOrigin, mActors[i]->currentOrigin)<(mFormSpacingFwd*0.5f))
+				{
+					return mActors[i];
+				}
+			}
+			else
+			{
+				if (Distance(actor->currentOrigin, mActors[i]->currentOrigin)<(mFormSpacingFwd*0.5f))
+				{
+					return mActors[i];
+				}
+			}
+		}
+		assert("Somehow this actor is not actually in the troop..."==0);
+		return 0;
+	}
+};
+typedef		ratl::handle_pool_vs<CTroop, MAX_TROOPS>		TTroopPool;
+TTroopPool	mTroops;
+
+
+
+
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Erase All Data, Set To Default Vals Before Entities Spawn
+////////////////////////////////////////////////////////////////////////////////////////
+void		Troop_Reset()
+{
+	mTroops.clear();
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Entities Have Just Spawned, Initialize
+////////////////////////////////////////////////////////////////////////////////////////
+void		Troop_Initialize()
+{
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Global Update Of All Troops
+////////////////////////////////////////////////////////////////////////////////////////
+void		Troop_Update()
+{
+	for (TTroopPool::iterator i=mTroops.begin(); i!=mTroops.end(); i++)
+	{
+		i->Update();
+	}
+}
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Erase All Data, Set To Default Vals Before Entities Spawn
+////////////////////////////////////////////////////////////////////////////////////////
+void		Trooper_UpdateTroop(gentity_t* actor)
+{
+	// Try To Join A Troop
+	//---------------------
+	if (!actor->NPC->troop)
+	{
+		float					curDist = 0;
+		float					closestDist = 0;
+		TTroopPool::iterator	closestTroop = mTroops.end();
+		trace_t					trace;
+
+		for (TTroopPool::iterator iTroop=mTroops.begin(); iTroop!=mTroops.end(); iTroop++)
+		{
+			if (iTroop->Team()==actor->client->playerTeam)
+			{
+				curDist = iTroop->DistanceSq(actor);
+				if (curDist<MAX_TROOP_JOIN_DIST2 && (!closestDist || curDist<closestDist))
+				{
+					// Only Join A Troop If You Can See The Leader
+					//---------------------------------------------
+					gi.trace(&trace, 
+						actor->currentOrigin, 
+						actor->mins, 
+						actor->maxs, 
+						iTroop->TroopLeader()->currentOrigin, 
+						actor->s.number, 
+						CONTENTS_SOLID|CONTENTS_TERRAIN|CONTENTS_MONSTERCLIP|CONTENTS_BOTCLIP);
+
+					if (!trace.allsolid && 
+						!trace.startsolid && 
+						(trace.fraction>=1.0f || trace.entityNum==iTroop->TroopLeader()->s.number))
+					{
+						closestDist = curDist;
+						closestTroop = iTroop;
+					}
+				}
+			}
+		}
+
+		// If Found, Add The Actor To It
+		//--------------------------------
+		if (closestTroop!=mTroops.end())
+		{
+			closestTroop->AddActor(actor);
+		}
+
+		// If We Couldn't Find One, Create A New Troop
+		//---------------------------------------------
+		else if (!mTroops.full())
+		{
+			int	nTroopHandle = mTroops.alloc();
+			mTroops[nTroopHandle].Initialize(nTroopHandle);
+			mTroops[nTroopHandle].AddActor(actor);
+		}
+	}
+
+	// If This Is A Leader, Then He Is Responsible For Merging Troops
+	//----------------------------------------------------------------
+	else if (actor->client->leader==actor)
+	{
+		float					curDist = 0;
+		float					closestDist = 0;
+		TTroopPool::iterator	closestTroop = mTroops.end();
+
+		for (TTroopPool::iterator iTroop=mTroops.begin(); iTroop!=mTroops.end(); iTroop++)
+		{
+			curDist = iTroop->DistanceSq(actor);
+			if ((curDist<MAX_TROOP_MERGE_DIST2) && 
+				(!closestDist || curDist<closestDist) &&
+				(mTroops.index_to_handle(iTroop.index())!=actor->NPC->troop))
+			{
+				closestDist = curDist;
+				closestTroop = iTroop;
+			}
+		}
+
+		if (closestTroop!=mTroops.end())
+		{
+			int		oldTroopNum = actor->NPC->troop;
+			mTroops[oldTroopNum].MergeInto(*closestTroop);
+			mTroops.free(oldTroopNum);
+		}
+	}
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// 
+////////////////////////////////////////////////////////////////////////////////////////
+bool		Trooper_UpdateSmackAway(gentity_t* actor, gentity_t* target)
+{
+ 	if (actor->client->ps.legsAnim==BOTH_MELEE1)
+	{
+		if (TIMER_Done(actor, "Trooper_SmackAway"))
+		{
+			CVec3	ActorPos(actor->currentOrigin);
+			CVec3	ActorToTgt(target->currentOrigin);
+					ActorToTgt -= ActorPos;
+			float	ActorToTgtDist = ActorToTgt.SafeNorm();
+
+			if (ActorToTgtDist<100.0f)
+			{
+				G_Throw(target, ActorToTgt.v, 200.0f);
+			}
+		}
+		return true;
+	}
+	return false;
+}
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// 
+////////////////////////////////////////////////////////////////////////////////////////
+void		Trooper_SmackAway(gentity_t* actor, gentity_t* target)
+{
+	assert(actor && actor->NPC);
+ 	if (actor->client->ps.legsAnim!=BOTH_MELEE1)
+	{
+		NPC_SetAnim(actor, SETANIM_BOTH, BOTH_MELEE1, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD);
+		TIMER_Set(actor, "Trooper_SmackAway",			actor->client->ps.torsoAnimTimer/4.0f);
+	}
+}
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// 
+////////////////////////////////////////////////////////////////////////////////////////
+bool		Trooper_Kneeling(gentity_t* actor)
+{
+	return (actor->NPC->aiFlags&NPCAI_KNEEL || actor->client->ps.legsAnim==BOTH_STAND_TO_KNEEL);
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// 
+////////////////////////////////////////////////////////////////////////////////////////
+void		Trooper_KneelDown(gentity_t* actor)
+{
+	assert(actor && actor->NPC);
+	if (!Trooper_Kneeling(actor) && level.time>actor->NPC->kneelTime)
+	{
+		NPC_SetAnim(actor, SETANIM_BOTH, BOTH_STAND_TO_KNEEL, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD);
+		actor->NPC->aiFlags |=  NPCAI_KNEEL;
+		actor->NPC->kneelTime = level.time + Q_irand(3000, 6000);
+	}
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// 
+////////////////////////////////////////////////////////////////////////////////////////
+void		Trooper_StandUp(gentity_t* actor, bool always=false)
+{
+	assert(actor && actor->NPC);
+	if (Trooper_Kneeling(actor) && (always || level.time>actor->NPC->kneelTime))
+	{
+		actor->NPC->aiFlags &= ~NPCAI_KNEEL;
+		NPC_SetAnim(actor, SETANIM_BOTH, BOTH_KNEEL_TO_STAND, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD);
+		actor->NPC->kneelTime = level.time + Q_irand(3000, 6000);
+	}
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// 
+////////////////////////////////////////////////////////////////////////////////////////
+int			Trooper_CanHitTarget(gentity_t* actor, gentity_t* target, CTroop& troop, float& MuzzleToTargetDistance, CVec3& MuzzleToTarget)
+{
+	trace_t	tr;
+	CVec3	MuzzlePoint(actor->currentOrigin);
+	 		CalcEntitySpot(actor, SPOT_WEAPON, MuzzlePoint.v);
+
+			MuzzleToTarget = troop.TargetVisablePosition();
+			MuzzleToTarget			-= MuzzlePoint;
+			MuzzleToTargetDistance	= MuzzleToTarget.SafeNorm();
+
+
+	CVec3	MuzzleDirection(actor->currentAngles);
+			MuzzleDirection.AngToVec();
+
+	// Aiming In The Right Direction?
+	//--------------------------------
+	if (MuzzleDirection.Dot(MuzzleToTarget)>0.95)
+	{
+		// Clear Line Of Sight To Target?
+		//--------------------------------
+		gi.trace(&tr, MuzzlePoint.v, NULL, NULL, troop.TargetVisablePosition().v, actor->s.number, MASK_SHOT);
+		if (tr.startsolid || tr.allsolid)
+		{
+			return ENTITYNUM_NONE;
+		}
+		if (tr.entityNum==target->s.number || tr.fraction>0.9f)
+		{
+			return target->s.number;
+		}
+		return tr.entityNum;
+	}
+	return ENTITYNUM_NONE;
+}
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Run The Per Trooper Update
+////////////////////////////////////////////////////////////////////////////////////////
+void		Trooper_Think(gentity_t* actor)
+{
+	gentity_t* target = (actor->NPC->troop)?(mTroops[actor->NPC->troop].TrackingTarget()):(0);
+	if (target)
+	{
+		G_SetEnemy(actor, target);
+
+		CTroop&		troop		= mTroops[actor->NPC->troop];
+		bool		AtPos		= STEER::Reached(actor, actor->pos1, 10.0f);
+		int			traceTgt	= ENTITYNUM_NONE;
+		bool		traced		= false;
+		bool		inSmackAway	= false;
+
+		float		MuzzleToTargetDistance = 0.0f;
+		CVec3		MuzzleToTarget;
+
+		if (actor->NPC->combatPoint!=-1)
+		{
+			traceTgt	= Trooper_CanHitTarget(actor, target, troop, MuzzleToTargetDistance, MuzzleToTarget); 
+			traced		= true;
+			if (traceTgt==target->s.number)
+			{
+				AtPos = true;
+			}
+		}
+		
+
+		// Smack!
+		//-------
+		if (Trooper_UpdateSmackAway(actor, target))
+		{
+			traced		= true;
+			AtPos		= true;
+			inSmackAway = true;
+		}
+
+
+		if (false)
+		{
+			CG_DrawEdge(actor->currentOrigin, actor->pos1, EDGE_IMPACT_SAFE);
+		}
+
+		// If There, Stop Moving
+		//-----------------------
+		STEER::Activate(actor);
+		{
+	 		gentity_t*	fleeFrom = troop.TooCloseToTroopMember(actor);
+
+			// If Too Close To The Leader, Get Out Of His Way
+			//------------------------------------------------
+			if (fleeFrom)
+			{
+				STEER::Flee(actor, fleeFrom->currentOrigin, 1.0f);			
+				AtPos = false;
+			}
+
+
+			// If In Position, Stop Moving
+			//-----------------------------
+			if (AtPos)
+			{
+ 				NAV::ClearPath(actor);
+				STEER::Stop(actor);
+			}
+
+			// Otherwise, Try To Get To Position
+			//-----------------------------------
+			else 
+			{
+				Trooper_StandUp(actor, true);
+
+				// If Close Enough, Persue Our Target Directly
+				//---------------------------------------------
+				bool moveSuccess = STEER::GoTo(NPC,  actor->pos1, 10.0f, false);
+
+				// Otherwise
+				//-----------
+				if (!moveSuccess)
+				{
+					moveSuccess = NAV::GoTo(NPC, actor->pos1);
+				}
+
+				// If No Way To Get To Position, Stay Here
+				//-----------------------------------------
+				if (!moveSuccess || (level.time - actor->lastMoveTime)>4000)
+				{
+					AtPos = true;
+				}
+			}
+		}
+		STEER::DeActivate(actor, &ucmd);
+
+
+	
+
+		// If There And Target Was Recently Visable
+		//------------------------------------------
+		if (AtPos && (troop.TimeSinceSeenTarget()<1500))
+		{
+			if (!traced)
+			{
+				traceTgt = Trooper_CanHitTarget(actor, target, troop, MuzzleToTargetDistance, MuzzleToTarget); 
+			}
+
+			// Shoot!
+			//--------
+			if (traceTgt==target->s.number)
+			{
+				if (actor->s.weapon==WP_BLASTER)
+				{
+					ucmd.buttons	|= BUTTON_ALT_ATTACK;
+				}
+				WeaponThink(qtrue);
+			}
+			else if (!inSmackAway)
+			{
+				// Otherwise, If Kneeling, Get Up!
+				//---------------------------------
+				if (Trooper_Kneeling(actor))
+				{
+					Trooper_StandUp(actor);
+				}
+
+				// If The Enemy Is Close Enough, Smack Him Away
+				//----------------------------------------------
+				else if (MuzzleToTargetDistance<40.0f)
+				{
+					Trooper_SmackAway(actor, target);
+				}
+
+				// If We Would Have It A Friend, Ask Him To Kneel
+				//------------------------------------------------
+				else if (traceTgt!=ENTITYNUM_NONE && 
+							traceTgt!=ENTITYNUM_WORLD && 
+							g_entities[traceTgt].client &&
+							g_entities[traceTgt].NPC &&
+							g_entities[traceTgt].client->playerTeam==actor->client->playerTeam &&
+							NPC_IsTrooper(&g_entities[traceTgt]) &&
+							g_entities[traceTgt].resultspeed<1.0f && 
+							!(g_entities[traceTgt].NPC->aiFlags & NPCAI_KNEEL))
+				{
+					Trooper_KneelDown(&g_entities[traceTgt]);
+				}
+			}
+
+
+			// Convert To Angles And Set That As Our Desired Look Direction
+			//--------------------------------------------------------------
+ 			if (MuzzleToTargetDistance>100)
+			{
+ 				MuzzleToTarget.VecToAng();
+
+				NPCInfo->desiredYaw		= MuzzleToTarget[YAW];
+				NPCInfo->desiredPitch	= MuzzleToTarget[PITCH];
+			}
+			else
+			{
+				MuzzleToTarget  = troop.TargetVisablePosition();
+				MuzzleToTarget.v[2] -= 20.0f;					// Aim Lower
+				MuzzleToTarget	-= actor->currentOrigin;
+				MuzzleToTarget.SafeNorm();
+ 				MuzzleToTarget.VecToAng();
+
+				NPCInfo->desiredYaw		= MuzzleToTarget[YAW];
+				NPCInfo->desiredPitch	= MuzzleToTarget[PITCH];
+			}
+		}
+
+		NPC_UpdateFiringAngles( qtrue, qtrue );
+		NPC_UpdateAngles( qtrue, qtrue );
+
+		if (Trooper_Kneeling(actor))
+		{
+			ucmd.upmove = -127;			// Set Crouch Height
+		}
+	}
+
+
+
+
+	else
+	{
+		NPC_BSST_Default();
+	}
+}
+
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+/*
+-------------------------
+NPC_BehaviorSet_Trooper
+-------------------------
+*/
+////////////////////////////////////////////////////////////////////////////////////////
+void NPC_BehaviorSet_Trooper( int bState )
+{
+	Trooper_UpdateTroop(NPC);
+	switch( bState )
+	{
+	case BS_STAND_GUARD:
+	case BS_PATROL:
+	case BS_STAND_AND_SHOOT:
+	case BS_HUNT_AND_KILL:
+	case BS_DEFAULT:
+		Trooper_Think(NPC);
+		break;
+
+	case BS_INVESTIGATE:
+		NPC_BSST_Investigate();
+		break;
+
+	case BS_SLEEP:
+		NPC_BSST_Sleep();
+		break;
+
+	default:
+		Trooper_Think(NPC);
+		break;
+	}
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// IsTrooper - return true if you want a given actor to use trooper AI
+////////////////////////////////////////////////////////////////////////////////////////
+bool NPC_IsTrooper(gentity_t* actor)
+{
+	return (
+		actor && 
+		actor->NPC && 
+		actor->s.weapon &&
+		!!(actor->NPC->scriptFlags&SCF_NO_GROUPS)// && 
+//		 !(actor->NPC->scriptFlags&SCF_CHASE_ENEMIES) 
+		 );
+}
+
+void NPC_LeaveTroop(gentity_t* actor)
+{
+	assert(actor->NPC->troop);
+	int wasInTroop = actor->NPC->troop;
+	mTroops[actor->NPC->troop].RemoveActor(actor);
+	if (mTroops[wasInTroop].Empty())
+	{
+		mTroops.free(wasInTroop);
+	}
+}
+
+
diff --git a/code/game/AI_Howler.cpp b/code/game/AI_Howler.cpp
new file mode 100644
index 0000000..c7227a8
--- /dev/null
+++ b/code/game/AI_Howler.cpp
@@ -0,0 +1,852 @@
+// leave this line at the top of all AI_xxxx.cpp files for PCH reasons...
+#include "g_headers.h"
+
+	    
+#include "b_local.h"
+
+// These define the working combat range for these suckers
+#define MIN_DISTANCE		54
+#define MIN_DISTANCE_SQR	( MIN_DISTANCE * MIN_DISTANCE )
+
+#define MAX_DISTANCE		128
+#define MAX_DISTANCE_SQR	( MAX_DISTANCE * MAX_DISTANCE )
+
+#define LSTATE_CLEAR		0
+#define LSTATE_WAITING		1
+#define LSTATE_FLEE			2
+#define LSTATE_BERZERK		3
+
+#define HOWLER_RETREAT_DIST	300.0f
+#define HOWLER_PANIC_HEALTH	10
+
+extern void G_UcmdMoveForDir( gentity_t *self, usercmd_t *cmd, vec3_t dir );
+extern void G_GetBoltPosition( gentity_t *self, int boltIndex, vec3_t pos, int modelIndex = 0 );
+extern int PM_AnimLength( int index, animNumber_t anim );
+extern qboolean NAV_DirSafe( gentity_t *self, vec3_t dir, float dist );
+extern void G_Knockdown( gentity_t *self, gentity_t *attacker, const vec3_t pushDir, float strength, qboolean breakSaberLock );
+extern float NPC_EntRangeFromBolt( gentity_t *targEnt, int boltIndex );
+extern int NPC_GetEntsNearBolt( gentity_t **radiusEnts, float radius, int boltIndex, vec3_t boltOrg );
+extern qboolean PM_InKnockDown( playerState_t *ps );
+extern qboolean PM_HasAnimation( gentity_t *ent, int animation );
+
+static void Howler_Attack( float enemyDist, qboolean howl = qfalse );
+/*
+-------------------------
+NPC_Howler_Precache
+-------------------------
+*/
+void NPC_Howler_Precache( void )
+{
+	int i;
+	//G_SoundIndex( "sound/chars/howler/howl.mp3" );
+	G_EffectIndex( "howler/sonic" );
+	G_SoundIndex( "sound/chars/howler/howl.mp3" );
+	for ( i = 1; i < 3; i++ )
+	{
+		G_SoundIndex( va( "sound/chars/howler/idle_hiss%d.mp3", i ) );
+	}
+	for ( i = 1; i < 6; i++ )
+	{
+		G_SoundIndex( va( "sound/chars/howler/howl_talk%d.mp3", i ) );
+		G_SoundIndex( va( "sound/chars/howler/howl_yell%d.mp3", i ) );
+	}
+}
+
+void Howler_ClearTimers( gentity_t *self )
+{
+	//clear all my timers
+	TIMER_Set( self, "flee", -level.time );
+	TIMER_Set( self, "retreating", -level.time );
+	TIMER_Set( self, "standing", -level.time );
+	TIMER_Set( self, "walking", -level.time );
+	TIMER_Set( self, "running", -level.time );
+	TIMER_Set( self, "aggressionDecay", -level.time );
+	TIMER_Set( self, "speaking", -level.time );
+}
+
+static qboolean NPC_Howler_Move( int randomJumpChance = 0 )
+{
+	if ( !TIMER_Done( NPC, "standing" ) )
+	{//standing around
+		return qfalse;
+	}
+	if ( NPC->client->ps.groundEntityNum == ENTITYNUM_NONE )
+	{//in air, don't do anything
+		return qfalse;
+	}
+	if ( (!NPC->enemy&&TIMER_Done( NPC, "running" )) || !TIMER_Done( NPC, "walking" ) )
+	{
+		ucmd.buttons |= BUTTON_WALKING;
+	}
+	if ( (!randomJumpChance||Q_irand( 0, randomJumpChance ))
+		&& NPC_MoveToGoal( qtrue ) )
+	{
+		if ( VectorCompare( NPC->client->ps.moveDir, vec3_origin )
+			|| !NPC->client->ps.speed )
+		{//uh.... wtf?  Got there?
+			if ( NPCInfo->goalEntity )
+			{
+				NPC_FaceEntity( NPCInfo->goalEntity, qfalse );
+			}
+			else
+			{
+				NPC_UpdateAngles( qfalse, qtrue );
+			}
+			return qtrue;
+		}
+		//TEMP: don't want to strafe
+		VectorClear( NPC->client->ps.moveDir );
+		ucmd.rightmove = 0.0f;
+//		Com_Printf( "Howler moving %d\n",ucmd.forwardmove );
+		//if backing up, go slow...
+		if ( ucmd.forwardmove < 0.0f )
+		{
+			ucmd.buttons |= BUTTON_WALKING;
+			//if ( NPC->client->ps.speed > NPCInfo->stats.walkSpeed )
+			{//don't walk faster than I'm allowed to
+				NPC->client->ps.speed = NPCInfo->stats.walkSpeed;
+			}
+		}
+		else
+		{
+			if ( (ucmd.buttons&BUTTON_WALKING) )
+			{
+				NPC->client->ps.speed = NPCInfo->stats.walkSpeed;
+			}
+			else
+			{
+				NPC->client->ps.speed = NPCInfo->stats.runSpeed;
+			}
+		}
+		NPCInfo->lockedDesiredYaw = NPCInfo->desiredYaw = NPCInfo->lastPathAngles[YAW];
+		NPC_UpdateAngles( qfalse, qtrue );
+	}
+	else if ( NPCInfo->goalEntity )
+	{//couldn't get where we wanted to go, try to jump there
+		NPC_FaceEntity( NPCInfo->goalEntity, qfalse );
+		NPC_TryJump( NPCInfo->goalEntity, 400.0f, -256.0f );
+	}
+	return qtrue;
+}
+/*
+-------------------------
+Howler_Idle
+-------------------------
+*/
+static void Howler_Idle( void )
+{
+}
+
+
+/*
+-------------------------
+Howler_Patrol
+-------------------------
+*/
+static void Howler_Patrol( void )
+{
+	NPCInfo->localState = LSTATE_CLEAR;
+
+	//If we have somewhere to go, then do that
+	if ( UpdateGoal() )
+	{
+		NPC_Howler_Move( 100 );
+	}
+
+	vec3_t dif;
+	VectorSubtract( g_entities[0].currentOrigin, NPC->currentOrigin, dif );
+
+	if ( VectorLengthSquared( dif ) < 256 * 256 )
+	{
+		G_SetEnemy( NPC, &g_entities[0] );
+	}
+
+	if ( NPC_CheckEnemyExt( qtrue ) == qfalse )
+	{
+		Howler_Idle();
+		return;
+	}
+
+	Howler_Attack( 0.0f, qtrue );
+}
+ 
+/*
+-------------------------
+Howler_Move
+-------------------------
+*/
+static qboolean Howler_Move( qboolean visible )
+{
+	if ( NPCInfo->localState != LSTATE_WAITING )
+	{
+		NPCInfo->goalEntity = NPC->enemy;
+		NPCInfo->goalRadius = MAX_DISTANCE;	// just get us within combat range
+		return NPC_Howler_Move( 30 );
+	}
+	return qfalse;
+}
+
+//---------------------------------------------------------
+static void Howler_TryDamage( int damage, qboolean tongue, qboolean knockdown )
+{
+	vec3_t	start, end, dir;
+	trace_t	tr;
+
+	if ( tongue )
+	{
+		G_GetBoltPosition( NPC, NPC->genericBolt1, start );
+		G_GetBoltPosition( NPC, NPC->genericBolt2, end );
+		VectorSubtract( end, start, dir );
+		float dist = VectorNormalize( dir );
+		VectorMA( start, dist+16, dir, end );
+	}
+	else
+	{
+		VectorCopy( NPC->currentOrigin, start );
+		AngleVectors( NPC->currentAngles, dir, NULL, NULL );
+		VectorMA( start, MIN_DISTANCE*2, dir, end );
+	}
+
+#ifndef FINAL_BUILD
+	if ( d_saberCombat->integer > 1 )
+	{
+		G_DebugLine(start, end, 1000, 0x000000ff, qtrue);
+	}
+#endif
+	// Should probably trace from the mouth, but, ah well.
+	gi.trace( &tr, start, vec3_origin, vec3_origin, end, NPC->s.number, MASK_SHOT );
+
+	if ( tr.entityNum < ENTITYNUM_WORLD )
+	{//hit *something*
+		gentity_t *victim = &g_entities[tr.entityNum];
+		if ( !victim->client
+			|| victim->client->NPC_class != CLASS_HOWLER )
+		{//not another howler
+
+			if ( knockdown && victim->client )
+			{//only do damage if victim isn't knocked down.  If he isn't, knock him down
+				if ( PM_InKnockDown( &victim->client->ps ) )
+				{
+					return;
+				}
+			}
+			//FIXME: some sort of damage effect (claws and tongue are cutting you... blood?)
+			G_Damage( victim, NPC, NPC, dir, tr.endpos, damage, DAMAGE_NO_KNOCKBACK, MOD_MELEE );
+			if ( knockdown && victim->health > 0 )
+			{//victim still alive
+				G_Knockdown( victim, NPC, NPC->client->ps.velocity, 500, qfalse );
+			}
+		}
+	}
+}
+
+static void Howler_Howl( void )
+{
+	gentity_t	*radiusEnts[ 128 ];
+	int			numEnts;
+	const float	radius = (NPC->spawnflags&1)?256:128;
+	const float	halfRadSquared = ((radius/2)*(radius/2));
+	const float	radiusSquared = (radius*radius);
+	float		distSq;
+	int			i;
+	vec3_t		boltOrg;
+
+	AddSoundEvent( NPC, NPC->currentOrigin, 512, AEL_DANGER, qfalse, qtrue );
+
+	numEnts = NPC_GetEntsNearBolt( radiusEnts, radius, NPC->handLBolt, boltOrg );
+
+	for ( i = 0; i < numEnts; i++ )
+	{
+		if ( !radiusEnts[i]->inuse )
+		{
+			continue;
+		}
+		
+		if ( radiusEnts[i] == NPC )
+		{//Skip the rancor ent
+			continue;
+		}
+		
+		if ( radiusEnts[i]->client == NULL )
+		{//must be a client
+			continue;
+		}
+
+		if ( radiusEnts[i]->client->NPC_class == CLASS_HOWLER )
+		{//other howlers immune
+			continue;
+		}
+
+		distSq = DistanceSquared( radiusEnts[i]->currentOrigin, boltOrg );
+		if ( distSq <= radiusSquared )
+		{
+			if ( distSq < halfRadSquared )
+			{//close enough to do damage, too
+				if ( Q_irand( 0, g_spskill->integer ) )
+				{//does no damage on easy, does 1 point every other frame on medium, more often on hard
+					G_Damage( radiusEnts[i], NPC, NPC, vec3_origin, NPC->currentOrigin, 1, DAMAGE_NO_KNOCKBACK, MOD_IMPACT );
+				}
+			}
+			if ( radiusEnts[i]->health > 0 
+				&& radiusEnts[i]->client
+				&& radiusEnts[i]->client->NPC_class != CLASS_RANCOR
+				&& radiusEnts[i]->client->NPC_class != CLASS_ATST 
+				&& !PM_InKnockDown( &radiusEnts[i]->client->ps ) )
+			{
+				if ( PM_HasAnimation( radiusEnts[i], BOTH_SONICPAIN_START ) )
+				{
+					if ( radiusEnts[i]->client->ps.torsoAnim != BOTH_SONICPAIN_START 
+						&& radiusEnts[i]->client->ps.torsoAnim != BOTH_SONICPAIN_HOLD )
+					{
+						NPC_SetAnim( radiusEnts[i], SETANIM_LEGS, BOTH_SONICPAIN_START, SETANIM_FLAG_NORMAL );
+						NPC_SetAnim( radiusEnts[i], SETANIM_TORSO, BOTH_SONICPAIN_START, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+						radiusEnts[i]->client->ps.torsoAnimTimer += 100;
+						radiusEnts[i]->client->ps.weaponTime = radiusEnts[i]->client->ps.torsoAnimTimer;
+					}
+					else if ( radiusEnts[i]->client->ps.torsoAnimTimer <= 100 )
+					{//at the end of the sonic pain start or hold anim
+						NPC_SetAnim( radiusEnts[i], SETANIM_LEGS, BOTH_SONICPAIN_HOLD, SETANIM_FLAG_NORMAL );
+						NPC_SetAnim( radiusEnts[i], SETANIM_TORSO, BOTH_SONICPAIN_HOLD, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+						radiusEnts[i]->client->ps.torsoAnimTimer += 100; 
+						radiusEnts[i]->client->ps.weaponTime = radiusEnts[i]->client->ps.torsoAnimTimer;
+					}
+				}
+				/*
+				else if ( distSq < halfRadSquared 
+					&& radiusEnts[i]->client->ps.groundEntityNum != ENTITYNUM_NONE 
+					&& !Q_irand( 0, 10 ) )//FIXME: base on skill
+				{//within range
+					G_Knockdown( radiusEnts[i], NPC, vec3_origin, 500, qfalse );
+				}
+				*/
+			}
+		}
+	}
+
+	float playerDist = NPC_EntRangeFromBolt( player, NPC->genericBolt1 );
+	if ( playerDist < 256.0f )
+	{
+		CGCam_Shake( 1.0f*playerDist/128.0f, 200 );
+	}
+}
+
+//------------------------------
+static void Howler_Attack( float enemyDist, qboolean howl )
+{
+	int dmg = (NPCInfo->localState==LSTATE_BERZERK)?5:2;
+
+	if ( !TIMER_Exists( NPC, "attacking" ))
+	{
+		int attackAnim = BOTH_GESTURE1;
+		// Going to do an attack
+		if ( NPC->enemy && NPC->enemy->client && PM_InKnockDown( &NPC->enemy->client->ps )
+			&& enemyDist <= MIN_DISTANCE )
+		{
+			attackAnim = BOTH_ATTACK2;
+		}
+		else if ( !Q_irand( 0, 4 ) || howl )
+		{//howl attack
+			//G_SoundOnEnt( NPC, CHAN_VOICE, "sound/chars/howler/howl.mp3" );
+		}
+		else if ( enemyDist > MIN_DISTANCE && Q_irand( 0, 1 ) )
+		{//lunge attack
+			//jump foward
+			vec3_t	fwd, yawAng = {0, NPC->client->ps.viewangles[YAW], 0};
+			AngleVectors( yawAng, fwd, NULL, NULL );
+			VectorScale( fwd, (enemyDist*3.0f), NPC->client->ps.velocity );
+			NPC->client->ps.velocity[2] = 200;
+			NPC->client->ps.groundEntityNum = ENTITYNUM_NONE;
+			
+			attackAnim = BOTH_ATTACK1;
+		}
+		else
+		{//tongue attack
+			attackAnim = BOTH_ATTACK2;
+		}
+
+		NPC_SetAnim( NPC, SETANIM_BOTH, attackAnim, SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLD | SETANIM_FLAG_RESTART );
+		if ( NPCInfo->localState == LSTATE_BERZERK )
+		{//attack again right away
+			TIMER_Set( NPC, "attacking", NPC->client->ps.legsAnimTimer );
+		}
+		else
+		{
+			TIMER_Set( NPC, "attacking", NPC->client->ps.legsAnimTimer + Q_irand( 0, 1500 ) );//FIXME: base on skill
+			TIMER_Set( NPC, "standing", -level.time );
+			TIMER_Set( NPC, "walking", -level.time );
+			TIMER_Set( NPC, "running", NPC->client->ps.legsAnimTimer + 5000 );
+		}
+
+		TIMER_Set( NPC, "attack_dmg", 200 ); // level two damage
+	}
+
+	// Need to do delayed damage since the attack animations encapsulate multiple mini-attacks
+	switch ( NPC->client->ps.legsAnim )
+	{
+	case BOTH_ATTACK1:
+	case BOTH_MELEE1:
+		if ( NPC->client->ps.legsAnimTimer > 650//more than 13 frames left
+			&& PM_AnimLength( NPC->client->clientInfo.animFileIndex, (animNumber_t)NPC->client->ps.legsAnim ) - NPC->client->ps.legsAnimTimer >= 800 )//at least 16 frames into anim
+		{
+			Howler_TryDamage( dmg, qfalse, qfalse );
+		}
+		break;
+	case BOTH_ATTACK2:
+	case BOTH_MELEE2:
+		if ( NPC->client->ps.legsAnimTimer > 350//more than 7 frames left
+			&& PM_AnimLength( NPC->client->clientInfo.animFileIndex, (animNumber_t)NPC->client->ps.legsAnim ) - NPC->client->ps.legsAnimTimer >= 550 )//at least 11 frames into anim
+		{
+			Howler_TryDamage( dmg, qtrue, qfalse );
+		}
+		break;
+	case BOTH_GESTURE1:
+		{
+			if ( NPC->client->ps.legsAnimTimer > 1800//more than 36 frames left
+				&& PM_AnimLength( NPC->client->clientInfo.animFileIndex, (animNumber_t)NPC->client->ps.legsAnim ) - NPC->client->ps.legsAnimTimer >= 950 )//at least 19 frames into anim
+			{
+				Howler_Howl();
+				if ( !NPC->count )
+				{
+					G_PlayEffect( G_EffectIndex( "howler/sonic" ), NPC->playerModel, NPC->genericBolt1, NPC->s.number, NPC->currentOrigin, 4750, qtrue );
+					G_SoundOnEnt( NPC, CHAN_VOICE, "sound/chars/howler/howl.mp3" );
+					NPC->count = 1;
+				}
+			}
+		}
+		break;
+	default:
+		//anims seem to get reset after a load, so just stop attacking and it will restart as needed.
+		TIMER_Remove( NPC, "attacking" );
+		break;
+	}
+
+	// Just using this to remove the attacking flag at the right time
+	TIMER_Done2( NPC, "attacking", qtrue );
+}
+
+//----------------------------------
+static void Howler_Combat( void )
+{
+	qboolean	faced = qfalse;
+	float		distance;	
+	qboolean	advance = qfalse;
+	if ( NPC->client->ps.groundEntityNum == ENTITYNUM_NONE )
+	{//not on the ground
+		if ( NPC->client->ps.legsAnim == BOTH_JUMP1
+			|| NPC->client->ps.legsAnim == BOTH_INAIR1 )
+		{//flying through the air with the greatest of ease, etc
+			Howler_TryDamage( 10, qfalse, qfalse );
+		}
+	}
+	else
+	{//not in air, see if we should attack or advance
+		// If we cannot see our target or we have somewhere to go, then do that
+		if ( !NPC_ClearLOS( NPC->enemy ) )//|| UpdateGoal( ))
+		{
+			NPCInfo->goalEntity = NPC->enemy;
+			NPCInfo->goalRadius = MAX_DISTANCE;	// just get us within combat range
+
+			if ( NPCInfo->localState == LSTATE_BERZERK )
+			{
+				NPC_Howler_Move( 3 );
+			}
+			else
+			{
+				NPC_Howler_Move( 10 );
+			}
+			NPC_UpdateAngles( qfalse, qtrue );
+			return;
+		}
+
+		distance = DistanceHorizontal( NPC->currentOrigin, NPC->enemy->currentOrigin );	
+
+		if ( NPC->enemy && NPC->enemy->client && PM_InKnockDown( &NPC->enemy->client->ps ) )
+		{//get really close to knocked down enemies
+			advance = (qboolean)( distance > MIN_DISTANCE ? qtrue : qfalse  );
+		}
+		else
+		{
+			advance = (qboolean)( distance > MAX_DISTANCE ? qtrue : qfalse  );//MIN_DISTANCE
+		}
+
+		if (( advance || NPCInfo->localState == LSTATE_WAITING ) && TIMER_Done( NPC, "attacking" )) // waiting monsters can't attack
+		{
+			if ( TIMER_Done2( NPC, "takingPain", qtrue ))
+			{
+				NPCInfo->localState = LSTATE_CLEAR;
+			}
+			else if ( TIMER_Done( NPC, "standing" ) )
+			{
+				faced = Howler_Move( 1 );
+			}
+		}
+		else
+		{
+			Howler_Attack( distance );
+		}
+	}
+
+	if ( !faced )
+	{
+		if ( //TIMER_Done( NPC, "standing" ) //not just standing there
+			//!advance //not moving
+			TIMER_Done( NPC, "attacking" ) )// not attacking
+		{//not standing around
+			// Sometimes I have problems with facing the enemy I'm attacking, so force the issue so I don't look dumb
+			NPC_FaceEnemy( qtrue );
+		}
+		else
+		{
+			NPC_UpdateAngles( qfalse, qtrue );
+		}
+	}
+}
+
+/*
+-------------------------
+NPC_Howler_Pain
+-------------------------
+*/
+void NPC_Howler_Pain( gentity_t *self, gentity_t *inflictor, gentity_t *other, const vec3_t point, int damage, int mod,int hitLoc ) 
+{
+	if ( !self || !self->NPC )
+	{
+		return;
+	}
+
+	if ( self->NPC->localState != LSTATE_BERZERK )//damage >= 10 )
+	{
+		self->NPC->stats.aggression += damage;
+		self->NPC->localState = LSTATE_WAITING;
+
+		TIMER_Remove( self, "attacking" );
+
+		VectorCopy( self->NPC->lastPathAngles, self->s.angles );
+
+		//if ( self->client->ps.legsAnim == BOTH_GESTURE1 )
+		{
+			G_StopEffect( G_EffectIndex( "howler/sonic" ), self->playerModel, self->genericBolt1, self->s.number );
+		}
+
+		NPC_SetAnim( self, SETANIM_BOTH, BOTH_PAIN1, SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLD );
+		TIMER_Set( self, "takingPain", self->client->ps.legsAnimTimer );//2900 );
+
+		if ( self->health > HOWLER_PANIC_HEALTH )
+		{//still have some health left
+			if ( Q_irand( 0, self->max_health ) > self->health )//FIXME: or check damage?
+			{//back off!
+				TIMER_Set( self, "standing", -level.time );
+				TIMER_Set( self, "running", -level.time );
+				TIMER_Set( self, "walking", -level.time );
+				TIMER_Set( self, "retreating", Q_irand( 1000, 5000 ) );
+			}
+			else
+			{//go after him!
+				TIMER_Set( self, "standing", -level.time );
+				TIMER_Set( self, "running", self->client->ps.legsAnimTimer+Q_irand(3000,6000) );
+				TIMER_Set( self, "walking", -level.time );
+				TIMER_Set( self, "retreating", -level.time );
+			}
+		}
+		else if ( self->NPC )
+		{//panic!
+			if ( Q_irand( 0, 1 ) )
+			{//berzerk
+				self->NPC->localState = LSTATE_BERZERK;
+			}
+			else
+			{//flee
+				self->NPC->localState = LSTATE_FLEE;
+				TIMER_Set( self, "flee", Q_irand( 10000, 30000 ) );
+			}
+		}
+	}
+}
+
+
+/*
+-------------------------
+NPC_BSHowler_Default
+-------------------------
+*/
+void NPC_BSHowler_Default( void )
+{
+	if ( NPC->client->ps.legsAnim != BOTH_GESTURE1 )
+	{
+		NPC->count = 0;
+	}
+	//FIXME: if in jump, do damage in front and maybe knock them down?
+	if ( !TIMER_Done( NPC, "attacking" ) )
+	{
+		if ( NPC->enemy )
+		{
+			//NPC_FaceEnemy( qfalse );
+			Howler_Attack( Distance( NPC->enemy->currentOrigin, NPC->currentOrigin ) );
+		}
+		else
+		{
+			//NPC_UpdateAngles( qfalse, qtrue );
+			Howler_Attack( 0.0f );
+		}
+		NPC_UpdateAngles( qfalse, qtrue );
+		return;
+	}
+
+	if ( NPC->enemy )
+	{
+		if ( NPCInfo->stats.aggression > 0 )
+		{
+			if ( TIMER_Done( NPC, "aggressionDecay" ) )
+			{
+				NPCInfo->stats.aggression--;
+				TIMER_Set( NPC, "aggressionDecay", 500 );
+			}
+		}
+		if ( !TIMER_Done( NPC, "flee" ) 
+			&& NPC_BSFlee() )	//this can clear ENEMY
+		{//successfully trying to run away
+			return;
+		}
+		if ( NPC->enemy == NULL)
+		{
+			NPC_UpdateAngles( qfalse, qtrue );
+			return;
+		}
+		if ( NPCInfo->localState == LSTATE_FLEE )
+		{//we were fleeing, now done (either timer ran out or we cannot flee anymore
+			if ( NPC_ClearLOS( NPC->enemy ) )
+			{//if enemy is still around, go berzerk
+				NPCInfo->localState = LSTATE_BERZERK;
+			}
+			else
+			{//otherwise, lick our wounds?
+				NPCInfo->localState = LSTATE_CLEAR;
+				TIMER_Set( NPC, "standing", Q_irand( 3000, 10000 ) );
+			}
+		}
+		else if ( NPCInfo->localState == LSTATE_BERZERK )
+		{//go nuts!
+		}
+		else if ( NPCInfo->stats.aggression >= Q_irand( 75, 125 ) )
+		{//that's it, go nuts!
+			NPCInfo->localState = LSTATE_BERZERK;
+		}
+		else if ( !TIMER_Done( NPC, "retreating" ) )
+		{//trying to back off
+			NPC_FaceEnemy( qtrue );
+			if ( NPC->client->ps.speed > NPCInfo->stats.walkSpeed )
+			{
+				NPC->client->ps.speed = NPCInfo->stats.walkSpeed;
+			}
+			ucmd.buttons |= BUTTON_WALKING;
+			if ( Distance( NPC->enemy->currentOrigin, NPC->currentOrigin ) < HOWLER_RETREAT_DIST )
+			{//enemy is close
+				vec3_t moveDir;
+				AngleVectors( NPC->currentAngles, moveDir, NULL, NULL );
+				VectorScale( moveDir, -1, moveDir );
+				if ( !NAV_DirSafe( NPC, moveDir, 8 ) )
+				{//enemy is backing me up against a wall or ledge!  Start to get really mad!
+					NPCInfo->stats.aggression += 2;
+				}
+				else
+				{//back off
+					ucmd.forwardmove = -127;
+				}
+				//enemy won't leave me alone, get mad...
+				NPCInfo->stats.aggression++;
+			}
+			return;
+		}
+		else if ( TIMER_Done( NPC, "standing" ) )
+		{//not standing around
+			if ( !(NPCInfo->last_ucmd.forwardmove)
+				&& !(NPCInfo->last_ucmd.rightmove) )
+			{//stood last frame
+				if ( TIMER_Done( NPC, "walking" ) 
+					&& TIMER_Done( NPC, "running" ) )
+				{//not walking or running
+					if ( Q_irand( 0, 2 ) )
+					{//run for a while
+						TIMER_Set( NPC, "walking", Q_irand( 4000, 8000 ) );
+					}
+					else
+					{//walk for a bit
+						TIMER_Set( NPC, "running", Q_irand( 2500, 5000 ) );
+					}
+				}
+			}
+			else if ( (NPCInfo->last_ucmd.buttons&BUTTON_WALKING) )
+			{//walked last frame
+				if ( TIMER_Done( NPC, "walking" ) )
+				{//just finished walking
+					if ( Q_irand( 0, 5 ) || DistanceSquared( NPC->enemy->currentOrigin, NPC->currentOrigin ) < MAX_DISTANCE_SQR )
+					{//run for a while
+						TIMER_Set( NPC, "running", Q_irand( 4000, 20000 ) );
+					}
+					else
+					{//stand for a bit
+						TIMER_Set( NPC, "standing", Q_irand( 2000, 6000 ) );
+					}
+				}
+			}
+			else
+			{//ran last frame
+				if ( TIMER_Done( NPC, "running" ) )
+				{//just finished running
+					if ( Q_irand( 0, 8 ) || DistanceSquared( NPC->enemy->currentOrigin, NPC->currentOrigin ) < MAX_DISTANCE_SQR )
+					{//walk for a while
+						TIMER_Set( NPC, "walking", Q_irand( 3000, 10000 ) );
+					}
+					else
+					{//stand for a bit
+						TIMER_Set( NPC, "standing", Q_irand( 2000, 6000 ) );
+					}
+				}
+			}
+		}
+		if ( NPC_ValidEnemy( NPC->enemy ) == qfalse )
+		{
+			TIMER_Remove( NPC, "lookForNewEnemy" );//make them look again right now
+			if ( !NPC->enemy->inuse || level.time - NPC->enemy->s.time > Q_irand( 10000, 15000 ) )
+			{//it's been a while since the enemy died, or enemy is completely gone, get bored with him
+				NPC->enemy = NULL;
+				Howler_Patrol();
+				NPC_UpdateAngles( qtrue, qtrue );
+				return;
+			}
+		}
+		if ( TIMER_Done( NPC, "lookForNewEnemy" ) )
+		{
+			gentity_t *sav_enemy = NPC->enemy;//FIXME: what about NPC->lastEnemy?
+			NPC->enemy = NULL;
+			gentity_t *newEnemy = NPC_CheckEnemy( NPCInfo->confusionTime < level.time, qfalse, qfalse );
+			NPC->enemy = sav_enemy;
+			if ( newEnemy && newEnemy != sav_enemy )
+			{//picked up a new enemy!
+				NPC->lastEnemy = NPC->enemy;
+				G_SetEnemy( NPC, newEnemy );
+				if ( NPC->enemy != NPC->lastEnemy )
+				{//clear this so that we only sniff the player the first time we pick them up
+					NPC->useDebounceTime = 0;
+				}
+				//hold this one for at least 5-15 seconds
+				TIMER_Set( NPC, "lookForNewEnemy", Q_irand( 5000, 15000 ) );
+			}
+			else
+			{//look again in 2-5 secs
+				TIMER_Set( NPC, "lookForNewEnemy", Q_irand( 2000, 5000 ) );
+			}
+		}
+		Howler_Combat();
+		if ( TIMER_Done( NPC, "speaking" ) )
+		{
+			if ( !TIMER_Done( NPC, "standing" )
+				|| !TIMER_Done( NPC, "retreating" ))
+			{
+				G_SoundOnEnt( NPC, CHAN_VOICE, va( "sound/chars/howler/idle_hiss%d.mp3", Q_irand( 1, 2 ) ) );
+			}
+			else if ( !TIMER_Done( NPC, "walking" ) 
+				|| NPCInfo->localState == LSTATE_FLEE )
+			{
+				G_SoundOnEnt( NPC, CHAN_VOICE, va( "sound/chars/howler/howl_talk%d.mp3", Q_irand( 1, 5 ) ) );
+			}
+			else
+			{
+				G_SoundOnEnt( NPC, CHAN_VOICE, va( "sound/chars/howler/howl_yell%d.mp3", Q_irand( 1, 5 ) ) );
+			}
+			if ( NPCInfo->localState == LSTATE_BERZERK
+				|| NPCInfo->localState == LSTATE_FLEE )
+			{
+				TIMER_Set( NPC, "speaking", Q_irand( 1000, 4000 ) );
+			}
+			else
+			{
+				TIMER_Set( NPC, "speaking", Q_irand( 3000, 8000 ) );
+			}
+		}
+		return;
+	}
+	else
+	{
+		if ( TIMER_Done( NPC, "speaking" ) )
+		{
+			if ( !Q_irand( 0, 3 ) )
+			{
+				G_SoundOnEnt( NPC, CHAN_VOICE, va( "sound/chars/howler/idle_hiss%d.mp3", Q_irand( 1, 2 ) ) );
+			}
+			else
+			{
+				G_SoundOnEnt( NPC, CHAN_VOICE, va( "sound/chars/howler/howl_talk%d.mp3", Q_irand( 1, 5 ) ) );
+			}
+			TIMER_Set( NPC, "speaking", Q_irand( 4000, 12000 ) );
+		}
+		if ( NPCInfo->stats.aggression > 0 )
+		{
+			if ( TIMER_Done( NPC, "aggressionDecay" ) )
+			{
+				NPCInfo->stats.aggression--;
+				TIMER_Set( NPC, "aggressionDecay", 200 );
+			}
+		}
+		if ( TIMER_Done( NPC, "standing" ) )
+		{//not standing around
+			if ( !(NPCInfo->last_ucmd.forwardmove)
+				&& !(NPCInfo->last_ucmd.rightmove) )
+			{//stood last frame
+				if ( TIMER_Done( NPC, "walking" ) 
+					&& TIMER_Done( NPC, "running" ) )
+				{//not walking or running
+					if ( NPCInfo->goalEntity )
+					{//have somewhere to go
+						if ( Q_irand( 0, 2 ) )
+						{//walk for a while
+							TIMER_Set( NPC, "walking", Q_irand( 3000, 10000 ) );
+						}
+						else
+						{//run for a bit
+							TIMER_Set( NPC, "running", Q_irand( 2500, 5000 ) );
+						}
+					}
+				}
+			}
+			else if ( (NPCInfo->last_ucmd.buttons&BUTTON_WALKING) )
+			{//walked last frame
+				if ( TIMER_Done( NPC, "walking" ) )
+				{//just finished walking
+					if ( Q_irand( 0, 3 ) )
+					{//run for a while
+						TIMER_Set( NPC, "running", Q_irand( 3000, 6000 ) );
+					}
+					else
+					{//stand for a bit
+						TIMER_Set( NPC, "standing", Q_irand( 2500, 5000 ) );
+					}
+				}
+			}
+			else
+			{//ran last frame
+				if ( TIMER_Done( NPC, "running" ) )
+				{//just finished running
+					if ( Q_irand( 0, 2 ) )
+					{//walk for a while
+						TIMER_Set( NPC, "walking", Q_irand( 6000, 15000 ) );
+					}
+					else
+					{//stand for a bit
+						TIMER_Set( NPC, "standing", Q_irand( 4000, 6000 ) );
+					}
+				}
+			}
+		}
+		if ( NPCInfo->scriptFlags & SCF_LOOK_FOR_ENEMIES )
+		{
+			Howler_Patrol();
+		}
+		else
+		{
+			Howler_Idle();
+		}
+	}
+
+	NPC_UpdateAngles( qfalse, qtrue );
+}
diff --git a/code/game/AI_ImperialProbe.cpp b/code/game/AI_ImperialProbe.cpp
new file mode 100644
index 0000000..edf76b0
--- /dev/null
+++ b/code/game/AI_ImperialProbe.cpp
@@ -0,0 +1,597 @@
+// leave this line at the top of all AI_xxxx.cpp files for PCH reasons...
+#include "g_headers.h"
+
+
+#include "b_local.h"
+#include "g_nav.h"
+
+gentity_t *CreateMissile( vec3_t org, vec3_t dir, float vel, int life, gentity_t *owner, qboolean altFire = qfalse );
+extern gitem_t	*FindItemForAmmo( ammo_t ammo );
+
+//Local state enums
+enum
+{
+	LSTATE_NONE = 0,
+	LSTATE_BACKINGUP,
+	LSTATE_SPINNING,
+	LSTATE_PAIN,
+	LSTATE_DROP
+};
+
+void ImperialProbe_Idle( void );
+
+void NPC_Probe_Precache(void)
+{
+	for ( int i = 1; i < 4; i++)
+	{
+		G_SoundIndex( va( "sound/chars/probe/misc/probetalk%d", i ) );
+	}
+	G_SoundIndex( "sound/chars/probe/misc/probedroidloop" );
+	G_SoundIndex("sound/chars/probe/misc/anger1");
+	G_SoundIndex("sound/chars/probe/misc/fire");
+
+	G_EffectIndex( "chunks/probehead" );
+	G_EffectIndex( "env/med_explode2" );
+	G_EffectIndex( "explosions/probeexplosion1");
+	G_EffectIndex( "bryar/muzzle_flash" );
+
+	RegisterItem( FindItemForAmmo( AMMO_BLASTER ));
+	RegisterItem( FindItemForWeapon( WP_BRYAR_PISTOL ) );
+}
+/*
+-------------------------
+Hunter_MaintainHeight
+-------------------------
+*/
+
+#define VELOCITY_DECAY	0.85f
+
+void ImperialProbe_MaintainHeight( void )
+{	
+	float	dif;
+//	vec3_t	endPos;
+//	trace_t	trace;
+
+	// Update our angles regardless
+	NPC_UpdateAngles( qtrue, qtrue );
+
+	// If we have an enemy, we should try to hover at about enemy eye level
+	if ( NPC->enemy )
+	{
+		// Find the height difference
+		dif = NPC->enemy->currentOrigin[2] - NPC->currentOrigin[2]; 
+
+		// cap to prevent dramatic height shifts
+		if ( fabs( dif ) > 8 )
+		{
+			if ( fabs( dif ) > 16 )
+			{
+				dif = ( dif < 0 ? -16 : 16 );
+			}
+
+			NPC->client->ps.velocity[2] = (NPC->client->ps.velocity[2]+dif)/2;
+		}
+	}
+	else
+	{
+		gentity_t *goal = NULL;
+
+		if ( NPCInfo->goalEntity )	// Is there a goal?
+		{
+			goal = NPCInfo->goalEntity;
+		}
+		else
+		{
+			goal = NPCInfo->lastGoalEntity;
+		}
+		if ( goal )
+		{
+			dif = goal->currentOrigin[2] - NPC->currentOrigin[2];
+
+			if ( fabs( dif ) > 24 )
+			{
+				ucmd.upmove = ( ucmd.upmove < 0 ? -4 : 4 );
+			}
+			else
+			{
+				if ( NPC->client->ps.velocity[2] )
+				{
+					NPC->client->ps.velocity[2] *= VELOCITY_DECAY;
+
+					if ( fabs( NPC->client->ps.velocity[2] ) < 2 )
+					{
+						NPC->client->ps.velocity[2] = 0;
+					}
+				}
+			}
+		}
+		// Apply friction
+		else if ( NPC->client->ps.velocity[2] )
+		{
+			NPC->client->ps.velocity[2] *= VELOCITY_DECAY;
+
+			if ( fabs( NPC->client->ps.velocity[2] ) < 1 )
+			{
+				NPC->client->ps.velocity[2] = 0;
+			}
+		}
+
+		// Stay at a given height until we take on an enemy
+/*		VectorSet( endPos, NPC->currentOrigin[0], NPC->currentOrigin[1], NPC->currentOrigin[2] - 512 );
+		gi.trace( &trace, NPC->currentOrigin, NULL, NULL, endPos, NPC->s.number, MASK_SOLID );
+
+		if ( trace.fraction != 1.0f )
+		{
+			float	length = ( trace.fraction * 512 );
+
+			if ( length < 80 )
+			{
+				ucmd.upmove = 32;
+			}
+			else if ( length > 120 )
+			{
+				ucmd.upmove = -32;
+			}
+			else
+			{ 
+				if ( NPC->client->ps.velocity[2] )
+				{
+					NPC->client->ps.velocity[2] *= VELOCITY_DECAY;
+
+					if ( fabs( NPC->client->ps.velocity[2] ) < 1 )
+					{
+						NPC->client->ps.velocity[2] = 0;
+					}
+				}
+			}
+		} */
+	}
+
+	// Apply friction
+	if ( NPC->client->ps.velocity[0] )
+	{
+		NPC->client->ps.velocity[0] *= VELOCITY_DECAY;
+
+		if ( fabs( NPC->client->ps.velocity[0] ) < 1 )
+		{
+			NPC->client->ps.velocity[0] = 0;
+		}
+	}
+
+	if ( NPC->client->ps.velocity[1] )
+	{
+		NPC->client->ps.velocity[1] *= VELOCITY_DECAY;
+
+		if ( fabs( NPC->client->ps.velocity[1] ) < 1 )
+		{
+			NPC->client->ps.velocity[1] = 0;
+		}
+	}
+}
+
+/*
+-------------------------
+ImperialProbe_Strafe
+-------------------------
+*/
+
+#define HUNTER_STRAFE_VEL	256
+#define HUNTER_STRAFE_DIS	200
+#define HUNTER_UPWARD_PUSH	32
+
+void ImperialProbe_Strafe( void )
+{
+	int		dir;
+	vec3_t	end, right;
+	trace_t	tr;
+
+	AngleVectors( NPC->client->renderInfo.eyeAngles, NULL, right, NULL );
+
+	// Pick a random strafe direction, then check to see if doing a strafe would be
+	//	reasonable valid
+	dir = ( rand() & 1 ) ? -1 : 1;
+	VectorMA( NPC->currentOrigin, HUNTER_STRAFE_DIS * dir, right, end );
+
+	gi.trace( &tr, NPC->currentOrigin, NULL, NULL, end, NPC->s.number, MASK_SOLID );
+
+	// Close enough
+	if ( tr.fraction > 0.9f )
+	{
+		VectorMA( NPC->client->ps.velocity, HUNTER_STRAFE_VEL * dir, right, NPC->client->ps.velocity );
+
+		// Add a slight upward push
+		NPC->client->ps.velocity[2] += HUNTER_UPWARD_PUSH;
+
+		// Set the strafe start time so we can do a controlled roll
+		NPC->fx_time = level.time;
+		NPCInfo->standTime = level.time + 3000 + random() * 500;
+	}
+}
+
+/*
+-------------------------
+ImperialProbe_Hunt
+-------------------------`
+*/
+
+#define HUNTER_FORWARD_BASE_SPEED	10
+#define HUNTER_FORWARD_MULTIPLIER	5
+
+void ImperialProbe_Hunt( qboolean visible, qboolean advance )
+{
+	float	distance, speed;
+	vec3_t	forward;
+
+	NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_RUN1, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+
+	//If we're not supposed to stand still, pursue the player
+	if ( NPCInfo->standTime < level.time )
+	{
+		// Only strafe when we can see the player
+		if ( visible )
+		{
+			ImperialProbe_Strafe();
+			return;
+		}
+	}
+
+	//If we don't want to advance, stop here
+	if ( advance == qfalse )
+		return;
+
+	//Only try and navigate if the player is visible
+	if ( visible == qfalse )
+	{
+		// Move towards our goal
+		NPCInfo->goalEntity = NPC->enemy;
+		NPCInfo->goalRadius = 12;
+
+		NPC_MoveToGoal(qtrue);
+		return;
+	}
+	else
+	{
+		VectorSubtract( NPC->enemy->currentOrigin, NPC->currentOrigin, forward );
+		distance = VectorNormalize( forward );
+	}
+
+	speed = HUNTER_FORWARD_BASE_SPEED + HUNTER_FORWARD_MULTIPLIER * g_spskill->integer;
+	VectorMA( NPC->client->ps.velocity, speed, forward, NPC->client->ps.velocity );
+}
+
+/*
+-------------------------
+ImperialProbe_FireBlaster
+-------------------------
+*/
+void ImperialProbe_FireBlaster(void)
+{
+	vec3_t	muzzle1,enemy_org1,delta1,angleToEnemy1;
+	static	vec3_t	forward, vright, up;
+	static	vec3_t	muzzle;
+	gentity_t	*missile;
+	mdxaBone_t	boltMatrix;
+
+	//FIXME: use {0, NPC->client->ps.legsYaw, 0}
+	gi.G2API_GetBoltMatrix( NPC->ghoul2, NPC->playerModel, 
+				NPC->genericBolt1,
+				&boltMatrix, NPC->currentAngles, NPC->currentOrigin, (cg.time?cg.time:level.time),
+				NULL, NPC->s.modelScale );
+
+	gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, muzzle1 );
+
+	G_PlayEffect( "bryar/muzzle_flash", muzzle1 );
+
+	G_Sound( NPC, G_SoundIndex( "sound/chars/probe/misc/fire" ));
+
+	if (NPC->health)
+	{
+		CalcEntitySpot( NPC->enemy, SPOT_CHEST, enemy_org1 );
+		enemy_org1[0]+= Q_irand(0,10);
+		enemy_org1[1]+= Q_irand(0,10);
+		VectorSubtract (enemy_org1, muzzle1, delta1);
+		vectoangles ( delta1, angleToEnemy1 );
+		AngleVectors (angleToEnemy1, forward, vright, up);
+	}
+	else
+	{
+		AngleVectors (NPC->currentAngles, forward, vright, up);
+	}
+
+	missile = CreateMissile( muzzle1, forward, 1600, 10000, NPC );
+
+	missile->classname = "bryar_proj";
+	missile->s.weapon = WP_BRYAR_PISTOL;
+
+	if ( g_spskill->integer <= 1 )
+	{
+		missile->damage = 5;
+	}
+	else 
+	{
+		missile->damage = 10;
+	}
+
+
+	missile->dflags = DAMAGE_DEATH_KNOCKBACK;
+	missile->methodOfDeath = MOD_ENERGY;
+	missile->clipmask = MASK_SHOT | CONTENTS_LIGHTSABER;
+
+}
+
+/*
+-------------------------
+ImperialProbe_Ranged
+-------------------------
+*/
+void ImperialProbe_Ranged( qboolean visible, qboolean advance )
+{
+	int	delay_min,delay_max;
+
+	if ( TIMER_Done( NPC, "attackDelay" ) )	// Attack?
+	{
+
+		if ( g_spskill->integer == 0 )
+		{
+			delay_min = 500;
+			delay_max = 3000;
+		}
+		else if ( g_spskill->integer > 1 )
+		{
+			delay_min = 500;
+			delay_max = 2000;
+		}
+		else
+		{
+			delay_min = 300;
+			delay_max = 1500;
+		}
+
+		TIMER_Set( NPC, "attackDelay", Q_irand( 500, 3000 ) );
+		ImperialProbe_FireBlaster();
+//		ucmd.buttons |= BUTTON_ATTACK;
+	}
+
+	if ( NPCInfo->scriptFlags & SCF_CHASE_ENEMIES )
+	{
+		ImperialProbe_Hunt( visible, advance );
+	}
+}
+
+/*
+-------------------------
+ImperialProbe_AttackDecision
+-------------------------
+*/
+
+#define	MIN_MELEE_RANGE		320
+#define	MIN_MELEE_RANGE_SQR	( MIN_MELEE_RANGE * MIN_MELEE_RANGE )
+
+#define MIN_DISTANCE		128
+#define MIN_DISTANCE_SQR	( MIN_DISTANCE * MIN_DISTANCE )
+
+void ImperialProbe_AttackDecision( void )
+{
+	// Always keep a good height off the ground
+	ImperialProbe_MaintainHeight();
+
+	//randomly talk
+	if ( TIMER_Done(NPC,"patrolNoise") )
+	{
+		if (TIMER_Done(NPC,"angerNoise"))
+		{
+			G_SoundOnEnt( NPC, CHAN_AUTO, va("sound/chars/probe/misc/probetalk%d", Q_irand(1, 3)) );
+
+			TIMER_Set( NPC, "patrolNoise", Q_irand( 4000, 10000 ) );
+		}
+	}
+
+	// If we don't have an enemy, just idle
+	if ( NPC_CheckEnemyExt() == qfalse )
+	{
+		ImperialProbe_Idle();
+		return;
+	}
+
+	NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_RUN1, SETANIM_FLAG_NORMAL);
+
+	// Rate our distance to the target, and our visibilty
+	float		distance	= (int) DistanceHorizontalSquared( NPC->currentOrigin, NPC->enemy->currentOrigin );	
+//	distance_e	distRate	= ( distance > MIN_MELEE_RANGE_SQR ) ? DIST_LONG : DIST_MELEE;
+	qboolean	visible		= NPC_ClearLOS( NPC->enemy );
+	qboolean	advance		= (qboolean)(distance > MIN_DISTANCE_SQR);
+
+	// If we cannot see our target, move to see it
+	if ( visible == qfalse )
+	{
+		if ( NPCInfo->scriptFlags & SCF_CHASE_ENEMIES )
+		{
+			ImperialProbe_Hunt( visible, advance );
+			return;
+		}
+	}
+
+	// Sometimes I have problems with facing the enemy I'm attacking, so force the issue so I don't look dumb
+	NPC_FaceEnemy( qtrue );
+
+	// Decide what type of attack to do
+	ImperialProbe_Ranged( visible, advance );
+}
+
+/*
+-------------------------
+NPC_BSDroid_Pain
+-------------------------
+*/
+void NPC_Probe_Pain( gentity_t *self, gentity_t *inflictor, gentity_t *other, const vec3_t point, int damage, int mod,int hitLoc ) 
+{
+	float	pain_chance;
+	
+	VectorCopy( self->NPC->lastPathAngles, self->s.angles );
+
+	if ( self->health < 30 || mod == MOD_DEMP2 || mod == MOD_DEMP2_ALT ) // demp2 always messes them up real good
+	{
+		vec3_t endPos;
+		trace_t	trace;
+
+		VectorSet( endPos, self->currentOrigin[0], self->currentOrigin[1], self->currentOrigin[2] - 128 );
+		gi.trace( &trace, self->currentOrigin, NULL, NULL, endPos, self->s.number, MASK_SOLID );
+
+		if ( trace.fraction == 1.0f || mod == MOD_DEMP2 ) // demp2 always does this
+		{
+			if (self->client->clientInfo.headModel != 0)
+			{
+				vec3_t origin;
+
+				VectorCopy(self->currentOrigin,origin);
+				origin[2] +=50;
+//				G_PlayEffect( "small_chunks", origin );
+				G_PlayEffect( "chunks/probehead", origin );
+				G_PlayEffect( "env/med_explode2", origin );
+				self->client->clientInfo.headModel = 0;
+				self->client->moveType = MT_RUNJUMP;
+				self->client->ps.gravity = g_gravity->value*.1;
+			}
+			
+			if ( (mod == MOD_DEMP2 || mod == MOD_DEMP2_ALT) && other )
+			{
+				vec3_t dir;
+
+				NPC_SetAnim( self, SETANIM_BOTH, BOTH_PAIN1, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD);
+
+				VectorSubtract( self->currentOrigin, other->currentOrigin, dir );
+				VectorNormalize( dir );
+
+				VectorMA( self->client->ps.velocity, 550, dir, self->client->ps.velocity );
+				self->client->ps.velocity[2] -= 127;
+			}
+
+			self->s.powerups |= ( 1 << PW_SHOCKED );
+			self->client->ps.powerups[PW_SHOCKED] = level.time + 3000;
+
+			self->NPC->localState = LSTATE_DROP;
+		} 
+	}
+	else
+	{
+		pain_chance = NPC_GetPainChance( self, damage );
+
+		if ( random() < pain_chance )	// Spin around in pain?
+		{
+			NPC_SetAnim( self, SETANIM_BOTH, BOTH_PAIN1, SETANIM_FLAG_OVERRIDE);
+		}	
+	}
+
+	NPC_Pain( self, inflictor, other, point, damage, mod);
+}
+
+/*
+-------------------------
+ImperialProbe_Idle
+-------------------------
+*/
+
+void ImperialProbe_Idle( void )
+{
+	ImperialProbe_MaintainHeight();
+
+	NPC_BSIdle();
+}
+
+/*
+-------------------------
+NPC_BSImperialProbe_Patrol
+-------------------------
+*/
+void ImperialProbe_Patrol( void )
+{
+	ImperialProbe_MaintainHeight();
+
+	if ( NPC_CheckPlayerTeamStealth() )
+	{
+		NPC_UpdateAngles( qtrue, qtrue );
+		return;
+	}
+
+	//If we have somewhere to go, then do that
+	if (!NPC->enemy)
+	{
+		NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_RUN1, SETANIM_FLAG_NORMAL );
+
+		if ( UpdateGoal() )
+		{
+			//start loop sound once we move
+			NPC->s.loopSound = G_SoundIndex( "sound/chars/probe/misc/probedroidloop" );
+			ucmd.buttons |= BUTTON_WALKING;
+			NPC_MoveToGoal( qtrue );
+		}
+		//randomly talk
+		if (TIMER_Done(NPC,"patrolNoise"))
+		{
+			G_SoundOnEnt( NPC, CHAN_AUTO, va("sound/chars/probe/misc/probetalk%d", Q_irand(1, 3)) );
+
+			TIMER_Set( NPC, "patrolNoise", Q_irand( 2000, 4000 ) );
+		}
+	}
+	else	// He's got an enemy. Make him angry.
+	{
+		G_SoundOnEnt( NPC, CHAN_AUTO, "sound/chars/probe/misc/anger1" );
+		TIMER_Set( NPC, "angerNoise", Q_irand( 2000, 4000 ) );
+		//NPCInfo->behaviorState = BS_HUNT_AND_KILL;
+	}
+
+	NPC_UpdateAngles( qtrue, qtrue );
+}
+
+/*
+-------------------------
+ImperialProbe_Wait
+-------------------------
+*/
+void ImperialProbe_Wait(void)
+{
+	if ( NPCInfo->localState == LSTATE_DROP )
+	{
+		vec3_t endPos;
+		trace_t	trace;
+
+		NPCInfo->desiredYaw = AngleNormalize360( NPCInfo->desiredYaw + 25 );
+
+		VectorSet( endPos, NPC->currentOrigin[0], NPC->currentOrigin[1], NPC->currentOrigin[2] - 32 );
+		gi.trace( &trace, NPC->currentOrigin, NULL, NULL, endPos, NPC->s.number, MASK_SOLID );
+
+		if ( trace.fraction != 1.0f )
+		{
+			G_Damage(NPC, NPC->enemy, NPC->enemy, NULL, NULL, 2000, 0,MOD_UNKNOWN); 
+		} 
+	}
+
+	NPC_UpdateAngles( qtrue, qtrue );
+}
+
+/*
+-------------------------
+NPC_BSImperialProbe_Default
+-------------------------
+*/
+void NPC_BSImperialProbe_Default( void )
+{
+
+	if ( NPC->enemy )
+	{
+		NPCInfo->goalEntity = NPC->enemy;
+		ImperialProbe_AttackDecision();
+	}
+	else if ( NPCInfo->scriptFlags & SCF_LOOK_FOR_ENEMIES )
+	{
+		ImperialProbe_Patrol();
+	}
+	else if ( NPCInfo->localState == LSTATE_DROP )
+	{
+		ImperialProbe_Wait();
+	}
+	else
+	{
+		ImperialProbe_Idle();
+	}
+}
diff --git a/code/game/AI_Interrogator.cpp b/code/game/AI_Interrogator.cpp
new file mode 100644
index 0000000..37486a7
--- /dev/null
+++ b/code/game/AI_Interrogator.cpp
@@ -0,0 +1,456 @@
+// leave this line at the top of all AI_xxxx.cpp files for PCH reasons...
+#include "g_headers.h"
+
+
+#include "b_local.h"
+#include "g_nav.h"
+
+void Interrogator_Idle( void );
+void DeathFX( gentity_t *ent );
+
+enum
+{
+LSTATE_BLADESTOP=0,
+LSTATE_BLADEUP,
+LSTATE_BLADEDOWN,
+};
+
+/*
+-------------------------
+NPC_Interrogator_Precache
+-------------------------
+*/
+void NPC_Interrogator_Precache(gentity_t *self)
+{
+	G_SoundIndex( "sound/chars/interrogator/misc/torture_droid_lp" );
+	G_SoundIndex("sound/chars/mark1/misc/anger.wav");
+	G_SoundIndex( "sound/chars/probe/misc/talk");
+	G_SoundIndex( "sound/chars/interrogator/misc/torture_droid_inject" );
+	G_SoundIndex( "sound/chars/interrogator/misc/int_droid_explo" );
+	G_EffectIndex( "explosions/droidexplosion1" );
+}
+/*
+-------------------------
+Interrogator_die
+-------------------------
+*/
+void Interrogator_die( gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int mod,int dFlags,int hitLoc )
+{
+	self->client->ps.velocity[2] = -100;
+	/*
+	self->locationDamage[HL_NONE] += damage;
+	if (self->locationDamage[HL_NONE] > 40)
+	{
+		DeathFX(self);
+		self->client->ps.eFlags |= EF_NODRAW;
+		self->contents = CONTENTS_CORPSE;
+	}
+	else
+	*/
+	{
+		self->client->moveType = MT_WALK;
+		self->client->ps.velocity[0] = Q_irand( -10, -20 );
+		self->client->ps.velocity[1] = Q_irand( -10, -20 );
+		self->client->ps.velocity[2] = -100;
+	}
+	//self->takedamage = qfalse;
+	//self->client->ps.eFlags |= EF_NODRAW;
+	//self->contents = 0;
+	return;
+}
+
+/*
+-------------------------
+Interrogator_PartsMove
+-------------------------
+*/
+void Interrogator_PartsMove(void)
+{
+	// Syringe
+	if ( TIMER_Done(NPC,"syringeDelay") )
+	{
+		NPC->pos1[1] = AngleNormalize360( NPC->pos1[1]);
+
+		if ((NPC->pos1[1] < 60) || (NPC->pos1[1] > 300))
+		{
+			NPC->pos1[1]+=Q_irand( -20, 20 );	// Pitch	
+		}
+		else if (NPC->pos1[1] > 180)
+		{
+			NPC->pos1[1]=Q_irand( 300, 360 );	// Pitch	
+		}
+		else 
+		{
+			NPC->pos1[1]=Q_irand( 0, 60 );	// Pitch	
+		}
+
+		gi.G2API_SetBoneAnglesIndex( &NPC->ghoul2[NPC->playerModel], NPC->genericBone1, NPC->pos1, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, NULL ); 
+		TIMER_Set( NPC, "syringeDelay", Q_irand( 100, 1000 ) );
+	}
+
+	// Scalpel
+	if ( TIMER_Done(NPC,"scalpelDelay") )
+	{
+		// Change pitch
+		if ( NPCInfo->localState == LSTATE_BLADEDOWN )	// Blade is moving down
+		{
+			NPC->pos2[0]-= 30;
+			if (NPC->pos2[0] < 180)
+			{
+				NPC->pos2[0] = 180;
+				NPCInfo->localState = LSTATE_BLADEUP;	// Make it move up
+			}
+		}
+		else											// Blade is coming back up
+		{
+			NPC->pos2[0]+= 30;
+			if (NPC->pos2[0] >= 360)
+			{
+				NPC->pos2[0] = 360;
+				NPCInfo->localState = LSTATE_BLADEDOWN;	// Make it move down
+				TIMER_Set( NPC, "scalpelDelay", Q_irand( 100, 1000 ) );
+			}
+		}
+
+		NPC->pos2[0] = AngleNormalize360( NPC->pos2[0]);
+		gi.G2API_SetBoneAnglesIndex( &NPC->ghoul2[NPC->playerModel], NPC->genericBone2, NPC->pos2, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, NULL ); 
+	}
+
+	// Claw
+	NPC->pos3[1] += Q_irand( 10, 30 );
+	NPC->pos3[1] = AngleNormalize360( NPC->pos3[1]);
+	gi.G2API_SetBoneAnglesIndex( &NPC->ghoul2[NPC->playerModel], NPC->genericBone3, NPC->pos3, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, NULL ); 
+
+}
+
+#define VELOCITY_DECAY	0.85f
+#define HUNTER_UPWARD_PUSH	2
+
+/*
+-------------------------
+Interrogator_MaintainHeight
+-------------------------
+*/
+void Interrogator_MaintainHeight( void )
+{	
+	float	dif;
+//	vec3_t	endPos;
+//	trace_t	trace;
+
+	NPC->s.loopSound = G_SoundIndex( "sound/chars/interrogator/misc/torture_droid_lp" );
+	// Update our angles regardless
+	NPC_UpdateAngles( qtrue, qtrue );
+
+	// If we have an enemy, we should try to hover at about enemy eye level
+	if ( NPC->enemy )
+	{
+		// Find the height difference
+		dif = (NPC->enemy->currentOrigin[2] + NPC->enemy->maxs[2]) - NPC->currentOrigin[2]; 
+
+		// cap to prevent dramatic height shifts
+		if ( fabs( dif ) > 2 )
+		{
+			if ( fabs( dif ) > 16 )
+			{
+				dif = ( dif < 0 ? -16 : 16 );
+			}
+
+			NPC->client->ps.velocity[2] = (NPC->client->ps.velocity[2]+dif)/2;
+		}
+	}
+	else
+	{
+		gentity_t *goal = NULL;
+
+		if ( NPCInfo->goalEntity )	// Is there a goal?
+		{
+			goal = NPCInfo->goalEntity;
+		}
+		else
+		{
+			goal = NPCInfo->lastGoalEntity;
+		}
+		if ( goal )
+		{
+			dif = goal->currentOrigin[2] - NPC->currentOrigin[2];
+
+			if ( fabs( dif ) > 24 )
+			{
+				ucmd.upmove = ( ucmd.upmove < 0 ? -4 : 4 );
+			}
+			else
+			{
+				if ( NPC->client->ps.velocity[2] )
+				{
+					NPC->client->ps.velocity[2] *= VELOCITY_DECAY;
+
+					if ( fabs( NPC->client->ps.velocity[2] ) < 2 )
+					{
+						NPC->client->ps.velocity[2] = 0;
+					}
+				}
+			}
+		}
+		// Apply friction
+		else if ( NPC->client->ps.velocity[2] )
+		{
+			NPC->client->ps.velocity[2] *= VELOCITY_DECAY;
+
+			if ( fabs( NPC->client->ps.velocity[2] ) < 1 )
+			{
+				NPC->client->ps.velocity[2] = 0;
+			}
+		}
+	}
+
+	// Apply friction
+	if ( NPC->client->ps.velocity[0] )
+	{
+		NPC->client->ps.velocity[0] *= VELOCITY_DECAY;
+
+		if ( fabs( NPC->client->ps.velocity[0] ) < 1 )
+		{
+			NPC->client->ps.velocity[0] = 0;
+		}
+	}
+
+	if ( NPC->client->ps.velocity[1] )
+	{
+		NPC->client->ps.velocity[1] *= VELOCITY_DECAY;
+
+		if ( fabs( NPC->client->ps.velocity[1] ) < 1 )
+		{
+			NPC->client->ps.velocity[1] = 0;
+		}
+	}
+}
+
+#define HUNTER_STRAFE_VEL	32
+#define HUNTER_STRAFE_DIS	200
+/*
+-------------------------
+Interrogator_Strafe
+-------------------------
+*/
+void Interrogator_Strafe( void )
+{
+	int		dir;
+	vec3_t	end, right;
+	trace_t	tr;
+	float	dif;
+
+	AngleVectors( NPC->client->renderInfo.eyeAngles, NULL, right, NULL );
+
+	// Pick a random strafe direction, then check to see if doing a strafe would be
+	//	reasonable valid
+	dir = ( rand() & 1 ) ? -1 : 1;
+	VectorMA( NPC->currentOrigin, HUNTER_STRAFE_DIS * dir, right, end );
+
+	gi.trace( &tr, NPC->currentOrigin, NULL, NULL, end, NPC->s.number, MASK_SOLID );
+
+	// Close enough
+	if ( tr.fraction > 0.9f )
+	{
+		VectorMA( NPC->client->ps.velocity, HUNTER_STRAFE_VEL * dir, right, NPC->client->ps.velocity );
+
+		// Add a slight upward push
+		if ( NPC->enemy )
+		{
+			// Find the height difference
+			dif = (NPC->enemy->currentOrigin[2] + 32) - NPC->currentOrigin[2]; 
+
+			// cap to prevent dramatic height shifts
+			if ( fabs( dif ) > 8 )
+			{
+				dif = ( dif < 0 ? -HUNTER_UPWARD_PUSH : HUNTER_UPWARD_PUSH );
+			}
+
+			NPC->client->ps.velocity[2] += dif;
+
+		}
+
+		// Set the strafe start time 
+		NPC->fx_time = level.time;
+		NPCInfo->standTime = level.time + 3000 + random() * 500;
+	}
+}
+
+/*
+-------------------------
+Interrogator_Hunt
+-------------------------`
+*/
+
+#define HUNTER_FORWARD_BASE_SPEED	10
+#define HUNTER_FORWARD_MULTIPLIER	2
+
+void Interrogator_Hunt( qboolean visible, qboolean advance )
+{
+	float	distance, speed;
+	vec3_t	forward;
+
+	Interrogator_PartsMove();
+
+	NPC_FaceEnemy(qfalse);
+
+	//If we're not supposed to stand still, pursue the player
+	if ( NPCInfo->standTime < level.time )
+	{
+		// Only strafe when we can see the player
+		if ( visible )
+		{
+			Interrogator_Strafe();
+			if ( NPCInfo->standTime > level.time )
+			{//successfully strafed
+				return;
+			}
+		}
+	}
+
+	//If we don't want to advance, stop here
+	if ( advance == qfalse )
+		return;
+
+	//Only try and navigate if the player is visible
+	if ( visible == qfalse )
+	{
+		// Move towards our goal
+		NPCInfo->goalEntity = NPC->enemy;
+		NPCInfo->goalRadius = 12;
+
+		NPC_MoveToGoal(qtrue);
+		return;
+
+	}
+	else
+	{
+		VectorSubtract( NPC->enemy->currentOrigin, NPC->currentOrigin, forward );
+		distance = VectorNormalize( forward );
+	}
+
+	speed = HUNTER_FORWARD_BASE_SPEED + HUNTER_FORWARD_MULTIPLIER * g_spskill->integer;
+	VectorMA( NPC->client->ps.velocity, speed, forward, NPC->client->ps.velocity );
+}
+
+#define MIN_DISTANCE		64
+
+/*
+-------------------------
+Interrogator_Melee
+-------------------------
+*/
+void Interrogator_Melee( qboolean visible, qboolean advance )
+{
+	if ( TIMER_Done( NPC, "attackDelay" ) )	// Attack?
+	{
+		// Make sure that we are within the height range before we allow any damage to happen
+		if ( NPC->currentOrigin[2] >= NPC->enemy->currentOrigin[2]+NPC->enemy->mins[2] && NPC->currentOrigin[2]+NPC->mins[2]+8 < NPC->enemy->currentOrigin[2]+NPC->enemy->maxs[2] )
+		{
+			TIMER_Set( NPC, "attackDelay", Q_irand( 500, 3000 ) );
+			G_Damage( NPC->enemy, NPC, NPC, 0, 0, 2, DAMAGE_NO_KNOCKBACK, MOD_MELEE );
+
+			NPC->enemy->client->poisonDamage = 18;
+			NPC->enemy->client->poisonTime = level.time + 1000;
+
+			// Drug our enemy up and do the wonky vision thing
+			gentity_t *tent = G_TempEntity( NPC->enemy->currentOrigin, EV_DRUGGED );
+			tent->owner = NPC->enemy;
+
+			G_Sound( NPC, G_SoundIndex( "sound/chars/interrogator/misc/torture_droid_inject.mp3" ));
+		}
+	}
+
+	if ( NPCInfo->scriptFlags & SCF_CHASE_ENEMIES )
+	{
+		Interrogator_Hunt( visible, advance );
+	}
+}
+
+/*
+-------------------------
+Interrogator_Attack
+-------------------------
+*/
+void Interrogator_Attack( void )
+{
+	// Always keep a good height off the ground
+	Interrogator_MaintainHeight();
+
+	//randomly talk
+	if ( TIMER_Done(NPC,"patrolNoise") )
+	{
+		if (TIMER_Done(NPC,"angerNoise"))
+		{
+			G_SoundOnEnt( NPC, CHAN_AUTO, va("sound/chars/probe/misc/talk.wav",	Q_irand(1, 3)) );
+
+			TIMER_Set( NPC, "patrolNoise", Q_irand( 4000, 10000 ) );
+		}
+	}
+
+	// If we don't have an enemy, just idle
+	if ( NPC_CheckEnemyExt() == qfalse )
+	{
+		Interrogator_Idle();
+		return;
+	}
+
+	// Rate our distance to the target, and our visibilty
+	float		distance	= (int) DistanceHorizontalSquared( NPC->currentOrigin, NPC->enemy->currentOrigin );	
+	qboolean	visible		= NPC_ClearLOS( NPC->enemy );
+	qboolean	advance		= (qboolean)(distance > MIN_DISTANCE*MIN_DISTANCE );
+
+	if ( !visible )
+	{
+		advance = qtrue;
+	}
+	if ( NPCInfo->scriptFlags & SCF_CHASE_ENEMIES )
+	{
+		Interrogator_Hunt( visible, advance );
+	}
+
+	NPC_FaceEnemy( qtrue );
+
+	if (!advance)
+	{
+		Interrogator_Melee( visible, advance );
+	}
+}
+
+/*
+-------------------------
+Interrogator_Idle
+-------------------------
+*/
+void Interrogator_Idle( void )
+{
+	if ( NPC_CheckPlayerTeamStealth() )
+	{
+		G_SoundOnEnt( NPC, CHAN_AUTO, "sound/chars/mark1/misc/anger.wav" );
+		NPC_UpdateAngles( qtrue, qtrue );
+		return;
+	}
+
+	Interrogator_MaintainHeight();
+
+	NPC_BSIdle();
+}
+
+/*
+-------------------------
+NPC_BSInterrogator_Default
+-------------------------
+*/
+void NPC_BSInterrogator_Default( void )
+{
+	//NPC->e_DieFunc = dieF_Interrogator_die;
+
+	if ( NPC->enemy )
+	{
+		Interrogator_Attack();
+	}
+	else
+	{
+		Interrogator_Idle();
+	}
+
+}
\ No newline at end of file
diff --git a/code/game/AI_Jedi.cpp b/code/game/AI_Jedi.cpp
new file mode 100644
index 0000000..ec59a0b
--- /dev/null
+++ b/code/game/AI_Jedi.cpp
@@ -0,0 +1,7609 @@
+// leave this line at the top of all AI_xxxx.cpp files for PCH reasons...
+#include "g_headers.h"
+
+
+#include "b_local.h"
+#include "g_nav.h"
+#include "anims.h"
+#include "wp_saber.h"
+
+//Externs
+extern qboolean G_ValidEnemy( gentity_t *self, gentity_t *enemy );
+extern void CG_DrawAlert( vec3_t origin, float rating );
+extern void G_AddVoiceEvent( gentity_t *self, int event, int speakDebounceTime );
+extern qboolean InFront( vec3_t spot, vec3_t from, vec3_t fromAngles, float threshHold = 0.0f );
+extern void G_StartMatrixEffect( gentity_t *ent, int meFlags = 0, int length = 1000, float timeScale = 0.0f, int spinTime = 0 );
+extern void ForceJump( gentity_t *self, usercmd_t *ucmd );
+extern void NPC_ClearLookTarget( gentity_t *self );
+extern void NPC_SetLookTarget( gentity_t *self, int entNum, int clearTime );
+extern void NPC_TempLookTarget( gentity_t *self, int lookEntNum, int minLookTime, int maxLookTime );
+extern qboolean G_ExpandPointToBBox( vec3_t point, const vec3_t mins, const vec3_t maxs, int ignore, int clipmask );
+extern qboolean NPC_CheckEnemyStealth( void );
+extern gitem_t	*FindItemForAmmo( ammo_t ammo );
+extern void ForceLightning( gentity_t *self );
+extern void ForceHeal( gentity_t *self );
+extern void ForceRage( gentity_t *self );
+extern void ForceProtect( gentity_t *self );
+extern void ForceAbsorb( gentity_t *self );
+extern qboolean ForceDrain2( gentity_t *self );
+extern int WP_MissileBlockForBlock( int saberBlock );
+extern qboolean WP_ForcePowerUsable( gentity_t *self, forcePowers_t forcePower, int overrideAmt );
+extern qboolean WP_ForcePowerAvailable( gentity_t *self, forcePowers_t forcePower, int overrideAmt );
+extern void WP_ForcePowerStop( gentity_t *self, forcePowers_t forcePower );
+extern void WP_KnockdownTurret( gentity_t *self, gentity_t *pas );
+extern void WP_DeactivateSaber( gentity_t *self, qboolean clearLength = qfalse );
+extern int PM_AnimLength( int index, animNumber_t anim );
+extern qboolean PM_SaberInStart( int move );
+extern qboolean PM_SaberInSpecialAttack( int anim );
+extern qboolean PM_SaberInAttack( int move );
+extern qboolean PM_SaberInBounce( int move );
+extern qboolean PM_SaberInParry( int move );
+extern qboolean PM_SaberInKnockaway( int move );
+extern qboolean PM_SaberInBrokenParry( int move );
+extern qboolean PM_SaberInDeflect( int move );
+extern qboolean PM_SpinningSaberAnim( int anim );
+extern qboolean PM_FlippingAnim( int anim );
+extern qboolean PM_RollingAnim( int anim );
+extern qboolean PM_InKnockDown( playerState_t *ps );
+extern qboolean PM_InRoll( playerState_t *ps );
+extern qboolean PM_InGetUp( playerState_t *ps );
+extern qboolean PM_InSpecialJump( int anim );
+extern qboolean PM_SuperBreakWinAnim( int anim );
+extern qboolean PM_InOnGroundAnim ( playerState_t *ps );
+extern qboolean PM_DodgeAnim( int anim );
+extern qboolean PM_DodgeHoldAnim( int anim );
+extern qboolean PM_InAirKickingAnim( int anim );
+extern qboolean PM_KickingAnim( int anim );
+extern qboolean PM_StabDownAnim( int anim );
+extern qboolean PM_SuperBreakLoseAnim( int anim );
+extern qboolean PM_SaberInKata( saberMoveName_t saberMove );
+extern qboolean PM_InRollIgnoreTimer( playerState_t *ps );
+extern qboolean PM_PainAnim( int anim );
+extern qboolean G_CanKickEntity( gentity_t *self, gentity_t *target );
+extern saberMoveName_t G_PickAutoKick( gentity_t *self, gentity_t *enemy, qboolean storeMove );
+extern saberMoveName_t G_PickAutoMultiKick( gentity_t *self, qboolean allowSingles, qboolean storeMove );
+extern qboolean NAV_DirSafe( gentity_t *self, vec3_t dir, float dist );
+extern qboolean NAV_MoveDirSafe( gentity_t *self, usercmd_t *cmd, float distScale = 1.0f );
+extern float NPC_EnemyRangeFromBolt( int boltIndex );
+extern qboolean WP_SabersCheckLock2( gentity_t *attacker, gentity_t *defender, sabersLockMode_t lockMode );
+extern void G_Knockdown( gentity_t *self, gentity_t *attacker, const vec3_t pushDir, float strength, qboolean breakSaberLock );
+extern qboolean G_EntIsBreakable( int entityNum, gentity_t *breaker );
+extern qboolean PM_LockedAnim( int anim );
+extern qboolean G_ClearLineOfSight(const vec3_t point1, const vec3_t point2, int ignore, int clipmask);
+
+extern cvar_t	*g_saberRealisticCombat;
+extern cvar_t	*d_slowmodeath;
+extern cvar_t	*g_saberNewControlScheme;
+extern int parryDebounce[];
+
+//Locals
+static void Jedi_Aggression( gentity_t *self, int change );
+qboolean Jedi_WaitingAmbush( gentity_t *self );
+void Tavion_SithSwordRecharge( void );
+qboolean Rosh_BeingHealed( gentity_t *self );
+
+static qboolean enemy_in_striking_range = qfalse;
+static int	jediSpeechDebounceTime[TEAM_NUM_TEAMS];//used to stop several jedi from speaking all at once
+
+void NPC_CultistDestroyer_Precache( void )
+{
+	G_SoundIndex( "sound/movers/objects/green_beam_lp2.wav" );
+	G_EffectIndex( "force/destruction_exp" );
+}
+
+void NPC_ShadowTrooper_Precache( void )
+{
+	RegisterItem( FindItemForAmmo( AMMO_FORCE ) );
+	G_SoundIndex( "sound/chars/shadowtrooper/cloak.wav" );
+	G_SoundIndex( "sound/chars/shadowtrooper/decloak.wav" );
+}
+
+void NPC_Rosh_Dark_Precache( void )
+{
+	G_EffectIndex( "force/kothos_recharge.efx" );
+	G_EffectIndex( "force/kothos_beam.efx" );
+}
+
+void Jedi_ClearTimers( gentity_t *ent )
+{
+	TIMER_Set( ent, "roamTime", 0 );
+	TIMER_Set( ent, "chatter", 0 );
+	TIMER_Set( ent, "strafeLeft", 0 );
+	TIMER_Set( ent, "strafeRight", 0 );
+	TIMER_Set( ent, "noStrafe", 0 );
+	TIMER_Set( ent, "walking", 0 );
+	TIMER_Set( ent, "taunting", 0 );
+	TIMER_Set( ent, "parryTime", 0 );
+	TIMER_Set( ent, "parryReCalcTime", 0 );
+	TIMER_Set( ent, "forceJumpChasing", 0 );
+	TIMER_Set( ent, "jumpChaseDebounce", 0 );
+	TIMER_Set( ent, "moveforward", 0 );
+	TIMER_Set( ent, "moveback", 0 );
+	TIMER_Set( ent, "movenone", 0 );
+	TIMER_Set( ent, "moveright", 0 );
+	TIMER_Set( ent, "moveleft", 0 );
+	TIMER_Set( ent, "movecenter", 0 );
+	TIMER_Set( ent, "saberLevelDebounce", 0 );
+	TIMER_Set( ent, "noRetreat", 0 );
+	TIMER_Set( ent, "holdLightning", 0 );
+	TIMER_Set( ent, "gripping", 0 );
+	TIMER_Set( ent, "draining", 0 );
+	TIMER_Set( ent, "noturn", 0 );
+	TIMER_Set( ent, "specialEvasion", 0 );
+}
+
+qboolean Jedi_CultistDestroyer( gentity_t *self )
+{ 
+	if ( !self || !self->client )
+	{
+		return qfalse;
+	}
+	//FIXME: just make a flag, dude!
+	if ( self->client->NPC_class == CLASS_REBORN
+		&& self->s.weapon == WP_MELEE
+		&& Q_stricmp( "cultist_destroyer", self->NPC_type ) == 0 )
+	{
+		return qtrue;
+	}
+	return qfalse;
+}
+
+void Jedi_PlayBlockedPushSound( gentity_t *self )
+{
+	if ( !self->s.number )
+	{
+		G_AddVoiceEvent( self, EV_PUSHFAIL, 3000 );
+	}
+	else if ( self->health > 0 && self->NPC && self->NPC->blockedSpeechDebounceTime < level.time )
+	{
+		G_AddVoiceEvent( self, EV_PUSHFAIL, 3000 );
+		self->NPC->blockedSpeechDebounceTime = level.time + 3000;
+	}
+}
+
+void Jedi_PlayDeflectSound( gentity_t *self )
+{
+	if ( !self->s.number )
+	{
+		G_AddVoiceEvent( self, Q_irand( EV_DEFLECT1, EV_DEFLECT3 ), 3000 );
+	}
+	else if ( self->health > 0 && self->NPC && self->NPC->blockedSpeechDebounceTime < level.time )
+	{
+		G_AddVoiceEvent( self, Q_irand( EV_DEFLECT1, EV_DEFLECT3 ), 3000 );
+		self->NPC->blockedSpeechDebounceTime = level.time + 3000;
+	}
+}
+
+void NPC_Jedi_PlayConfusionSound( gentity_t *self )
+{
+	if ( self->health > 0 )
+	{
+		if ( self->client 
+			&& ( self->client->NPC_class == CLASS_ALORA 
+				|| self->client->NPC_class == CLASS_TAVION 
+				|| self->client->NPC_class == CLASS_DESANN ) )
+		{
+			G_AddVoiceEvent( self, Q_irand( EV_CONFUSE1, EV_CONFUSE3 ), 2000 );
+		}
+		else if ( Q_irand( 0, 1 ) )
+		{
+			G_AddVoiceEvent( self, Q_irand( EV_TAUNT1, EV_TAUNT3 ), 2000 );
+		}
+		else
+		{
+			G_AddVoiceEvent( self, Q_irand( EV_GLOAT1, EV_GLOAT3 ), 2000 );
+		}
+	}
+}
+
+qboolean Jedi_StopKnockdown( gentity_t *self, gentity_t *pusher, const vec3_t pushDir )
+{
+	if ( self->s.number < MAX_CLIENTS || !self->NPC )
+	{//only NPCs
+		return qfalse;
+	}
+
+	if ( self->client->ps.forcePowerLevel[FP_LEVITATION] < FORCE_LEVEL_1 )
+	{//only force-users
+		return qfalse;
+	}
+
+	if ( self->client->moveType == MT_FLYSWIM )
+	{//can't knock me down when I'm flying
+		return qtrue;
+	}
+
+	if ( self->NPC && (self->NPC->aiFlags&NPCAI_BOSS_CHARACTER) )
+	{//bosses always get out of a knockdown
+	}
+	else if ( Q_irand( 0, RANK_CAPTAIN+5 ) > self->NPC->rank )
+	{//lower their rank, the more likely they are fall down
+		return qfalse;
+	}
+
+	vec3_t	pDir, fwd, right, ang = {0, self->currentAngles[YAW], 0};
+	float	fDot, rDot;
+	int		strafeTime = Q_irand( 1000, 2000 );
+
+	AngleVectors( ang, fwd, right, NULL );
+	VectorNormalize2( pushDir, pDir );
+	fDot = DotProduct( pDir, fwd );
+	rDot = DotProduct( pDir, right );
+
+	//flip or roll with it
+	usercmd_t	tempCmd;
+	if ( fDot >= 0.4f )
+	{
+		tempCmd.forwardmove = 127;
+		TIMER_Set( self, "moveforward", strafeTime );
+	}
+	else if ( fDot <= -0.4f )
+	{
+		tempCmd.forwardmove = -127;
+		TIMER_Set( self, "moveback", strafeTime );
+	}
+	else if ( rDot > 0 )
+	{
+		tempCmd.rightmove = 127;
+		TIMER_Set( self, "strafeRight", strafeTime );
+		TIMER_Set( self, "strafeLeft", -1 );
+	}
+	else
+	{
+		tempCmd.rightmove = -127;
+		TIMER_Set( self, "strafeLeft", strafeTime );
+		TIMER_Set( self, "strafeRight", -1 );
+	}
+	G_AddEvent( self, EV_JUMP, 0 );
+	if ( !Q_irand( 0, 1 ) )
+	{//flip
+		self->client->ps.forceJumpCharge = 280;//FIXME: calc this intelligently?
+		ForceJump( self, &tempCmd );
+	}
+	else
+	{//roll
+		TIMER_Set( self, "duck", strafeTime );
+	}
+	self->painDebounceTime = 0;//so we do something
+
+	return qtrue;
+}
+extern void Boba_FireDecide( void );
+extern void RT_FireDecide( void );
+extern void Boba_FlyStart( gentity_t *self );
+
+
+
+
+
+//===============================================================================================
+//TAVION BOSS
+//===============================================================================================
+void NPC_TavionScepter_Precache( void )
+{
+	G_EffectIndex( "scepter/beam_warmup.efx" );
+	G_EffectIndex( "scepter/beam.efx" );
+	G_EffectIndex( "scepter/slam_warmup.efx" );
+	G_EffectIndex( "scepter/slam.efx" );
+	G_EffectIndex( "scepter/impact.efx" );
+	G_SoundIndex( "sound/weapons/scepter/loop.wav" );
+	G_SoundIndex( "sound/weapons/scepter/slam_warmup.wav" );
+	G_SoundIndex( "sound/weapons/scepter/beam_warmup.wav" );
+}
+
+void NPC_TavionSithSword_Precache( void )
+{
+	G_EffectIndex( "scepter/recharge.efx" );
+	G_EffectIndex( "scepter/invincibility.efx" );
+	G_EffectIndex( "scepter/sword.efx" );
+	G_SoundIndex( "sound/weapons/scepter/recharge.wav" );
+}
+
+void Tavion_ScepterDamage( void )
+{
+	if ( !NPC->ghoul2.size() 
+		|| NPC->weaponModel[1] <= 0 )
+	{
+		return;
+	}
+
+	if ( NPC->genericBolt1 != -1 )
+	{
+		int curTime = (cg.time?cg.time:level.time);
+		qboolean hit = qfalse;
+		int	lastHit = ENTITYNUM_NONE;
+		for ( int time = curTime-25; time <= curTime+25&&!hit; time += 25 )
+		{
+			mdxaBone_t	boltMatrix;
+			vec3_t		tip, dir, base, angles={0,NPC->currentAngles[YAW],0};
+			trace_t		trace;
+
+			gi.G2API_GetBoltMatrix( NPC->ghoul2, NPC->weaponModel[1], 
+						NPC->genericBolt1,
+						&boltMatrix, angles, NPC->currentOrigin, time,
+						NULL, NPC->s.modelScale );
+			gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, base );
+			gi.G2API_GiveMeVectorFromMatrix( boltMatrix, NEGATIVE_X, dir );
+			VectorMA( base, 512, dir, tip );
+	#ifndef FINAL_BUILD
+			if ( d_saberCombat->integer > 1 )
+			{
+				G_DebugLine(base, tip, 1000, 0x000000ff, qtrue);
+			}
+	#endif
+			gi.trace( &trace, base, vec3_origin, vec3_origin, tip, NPC->s.number, MASK_SHOT, G2_RETURNONHIT, 10 );
+			if ( trace.fraction < 1.0f )
+			{//hit something
+				gentity_t *traceEnt = &g_entities[trace.entityNum];
+
+				//FIXME: too expensive!
+				//if ( time == curTime )
+				{//UGH
+					G_PlayEffect( G_EffectIndex( "scepter/impact.efx" ), trace.endpos, trace.plane.normal );
+				}
+
+				if ( traceEnt->takedamage 
+					&& trace.entityNum != lastHit
+					&& (!traceEnt->client || traceEnt == NPC->enemy || traceEnt->client->NPC_class != NPC->client->NPC_class) )
+				{//smack
+					int dmg = Q_irand( 10, 20 )*(g_spskill->integer+1);//NOTE: was 6-12
+					//FIXME: debounce?
+					//FIXME: do dismemberment
+					G_Damage( traceEnt, NPC, NPC, vec3_origin, trace.endpos, dmg, DAMAGE_NO_KNOCKBACK, MOD_SABER );//MOD_MELEE );
+					if ( traceEnt->client )
+					{
+						if ( !Q_irand( 0, 2 ) )
+						{
+							G_AddVoiceEvent( NPC, Q_irand( EV_CONFUSE1, EV_CONFUSE2 ), 10000 );
+						}
+						else
+						{
+							G_AddVoiceEvent( NPC, EV_JDETECTED3, 10000 );
+						}
+						G_Throw( traceEnt, dir, Q_flrand( 50, 80 ) );
+						if ( traceEnt->health > 0 && !Q_irand( 0, 2 ) )//FIXME: base on skill!
+						{//do pain on enemy
+							G_Knockdown( traceEnt, NPC, dir, 300, qtrue );
+						}
+					}
+					hit = qtrue;
+					lastHit = trace.entityNum;
+				}
+			}
+		}
+	}
+}
+
+void Tavion_ScepterSlam( void )
+{
+	if ( !NPC->ghoul2.size() 
+		|| NPC->weaponModel[1] <= 0 )
+	{
+		return;
+	}
+
+	int	boltIndex = gi.G2API_AddBolt(&NPC->ghoul2[NPC->weaponModel[1]], "*weapon");
+	if ( boltIndex != -1 )
+	{
+		mdxaBone_t	boltMatrix;
+		vec3_t		handle, bottom, angles={0,NPC->currentAngles[YAW],0};
+		trace_t		trace;
+		gentity_t	*radiusEnts[ 128 ];
+		int			numEnts;
+		const float	radius = 300.0f;
+		const float	halfRad = (radius/2);
+		float		dist;
+		int			i;
+		vec3_t		mins, maxs, entDir;
+
+		gi.G2API_GetBoltMatrix( NPC->ghoul2, NPC->weaponModel[1], 
+					boltIndex,
+					&boltMatrix, angles, NPC->currentOrigin, (cg.time?cg.time:level.time),
+					NULL, NPC->s.modelScale );
+		gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, handle );
+		VectorCopy( handle, bottom );
+		bottom[2] -= 128.0f;
+
+		gi.trace( &trace, handle, vec3_origin, vec3_origin, bottom, NPC->s.number, MASK_SHOT, G2_RETURNONHIT, 10 );
+		G_PlayEffect( G_EffectIndex( "scepter/slam.efx" ), trace.endpos, trace.plane.normal );
+		
+		//Setup the bbox to search in
+		for ( i = 0; i < 3; i++ )
+		{
+			mins[i] = trace.endpos[i] - radius;
+			maxs[i] = trace.endpos[i] + radius;
+		}
+
+		//Get the number of entities in a given space
+		numEnts = gi.EntitiesInBox( mins, maxs, radiusEnts, 128 );
+
+		for ( i = 0; i < numEnts; i++ )
+		{
+			if ( !radiusEnts[i]->inuse )
+			{
+				continue;
+			}
+			
+			if ( (radiusEnts[i]->flags&FL_NO_KNOCKBACK) )
+			{//don't throw them back
+				continue;
+			}
+
+			if ( radiusEnts[i] == NPC )
+			{//Skip myself
+				continue;
+			}
+			
+			if ( radiusEnts[i]->client == NULL )
+			{//must be a client
+				if ( G_EntIsBreakable( radiusEnts[i]->s.number, NPC ) )
+				{//damage breakables within range, but not as much
+					G_Damage( radiusEnts[i], NPC, NPC, vec3_origin, radiusEnts[i]->currentOrigin, 100, 0, MOD_EXPLOSIVE_SPLASH );
+				}
+				continue;
+			}
+
+			if ( (radiusEnts[i]->client->ps.eFlags&EF_HELD_BY_RANCOR) 
+				|| (radiusEnts[i]->client->ps.eFlags&EF_HELD_BY_WAMPA) )
+			{//can't be one being held
+				continue;
+			}
+			
+			VectorSubtract( radiusEnts[i]->currentOrigin, trace.endpos, entDir );
+			dist = VectorNormalize( entDir );
+			if ( dist <= radius )
+			{
+				if ( dist < halfRad )
+				{//close enough to do damage, too
+					G_Damage( radiusEnts[i], NPC, NPC, vec3_origin, radiusEnts[i]->currentOrigin, Q_irand( 20, 30 ), DAMAGE_NO_KNOCKBACK, MOD_EXPLOSIVE_SPLASH );
+				}
+				if ( radiusEnts[i]->client
+					&& radiusEnts[i]->client->NPC_class != CLASS_RANCOR
+					&& radiusEnts[i]->client->NPC_class != CLASS_ATST )
+				{
+					float throwStr = 0.0f; 
+					if ( g_spskill->integer > 1 )
+					{
+						throwStr = 10.0f+((radius-dist)/2.0f);
+						if ( throwStr > 150.0f )
+						{
+							throwStr = 150.0f;
+						}
+					}
+					else
+					{
+						throwStr = 10.0f+((radius-dist)/4.0f);
+						if ( throwStr > 85.0f )
+						{
+							throwStr = 85.0f;
+						}
+					}
+					entDir[2] += 0.1f;
+					VectorNormalize( entDir );
+					G_Throw( radiusEnts[i], entDir, throwStr );
+					if ( radiusEnts[i]->health > 0 )
+					{
+						if ( dist < halfRad
+							|| radiusEnts[i]->client->ps.groundEntityNum != ENTITYNUM_NONE )
+						{//within range of my fist or within ground-shaking range and not in the air
+							G_Knockdown( radiusEnts[i], NPC, vec3_origin, 500, qtrue );
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+void Tavion_StartScepterBeam( void )
+{
+	G_PlayEffect( G_EffectIndex( "scepter/beam_warmup.efx" ), NPC->weaponModel[1], NPC->genericBolt1, NPC->s.number, NPC->currentOrigin, 0, qtrue );
+	G_SoundOnEnt( NPC, CHAN_ITEM, "sound/weapons/scepter/beam_warmup.wav" );
+	NPC->client->ps.legsAnimTimer = NPC->client->ps.torsoAnimTimer = 0;
+	NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_SCEPTER_START, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+	NPC->client->ps.torsoAnimTimer += 200;
+	NPC->painDebounceTime = level.time + NPC->client->ps.torsoAnimTimer;
+	NPC->client->ps.pm_time = NPC->client->ps.torsoAnimTimer;
+	NPC->client->ps.pm_flags |= PMF_TIME_KNOCKBACK;
+	VectorClear( NPC->client->ps.velocity );
+	VectorClear( NPC->client->ps.moveDir );
+}
+
+void Tavion_StartScepterSlam( void )
+{
+	G_PlayEffect( G_EffectIndex( "scepter/slam_warmup.efx" ), NPC->weaponModel[1], NPC->genericBolt1, NPC->s.number, NPC->currentOrigin, 0, qtrue );
+	G_SoundOnEnt( NPC, CHAN_ITEM, "sound/weapons/scepter/slam_warmup.wav" );
+	NPC->client->ps.legsAnimTimer = NPC->client->ps.torsoAnimTimer = 0;
+	NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_TAVION_SCEPTERGROUND, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+	NPC->painDebounceTime = level.time + NPC->client->ps.torsoAnimTimer;
+	NPC->client->ps.pm_time = NPC->client->ps.torsoAnimTimer;
+	NPC->client->ps.pm_flags |= PMF_TIME_KNOCKBACK;
+	VectorClear( NPC->client->ps.velocity );
+	VectorClear( NPC->client->ps.moveDir );
+	NPC->count = 0;
+}
+
+void Tavion_SithSwordRecharge( void )
+{
+	if ( NPC->client->ps.torsoAnim != BOTH_TAVION_SWORDPOWER 
+		&& NPC->count 
+		&& TIMER_Done( NPC, "rechargeDebounce" ) 
+		&& NPC->weaponModel[0] != -1 )
+	{
+		NPC->s.loopSound = G_SoundIndex( "sound/weapons/scepter/recharge.wav" );
+		int	boltIndex = gi.G2API_AddBolt(&NPC->ghoul2[NPC->weaponModel[0]], "*weapon");
+		NPC->client->ps.legsAnimTimer = NPC->client->ps.torsoAnimTimer = 0;
+		NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_TAVION_SWORDPOWER, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+		G_PlayEffect( G_EffectIndex( "scepter/recharge.efx" ), NPC->weaponModel[0], boltIndex, NPC->s.number, NPC->currentOrigin, NPC->client->ps.torsoAnimTimer, qtrue );
+		NPC->painDebounceTime = level.time + NPC->client->ps.torsoAnimTimer;
+		NPC->client->ps.pm_time = NPC->client->ps.torsoAnimTimer;
+		NPC->client->ps.pm_flags |= PMF_TIME_KNOCKBACK;
+		VectorClear( NPC->client->ps.velocity );
+		VectorClear( NPC->client->ps.moveDir );
+		NPC->client->ps.powerups[PW_INVINCIBLE] = level.time + NPC->client->ps.torsoAnimTimer + 10000;
+		G_PlayEffect( G_EffectIndex( "scepter/invincibility.efx" ), NPC->playerModel, 0, NPC->s.number, NPC->currentOrigin, NPC->client->ps.torsoAnimTimer + 10000, qfalse );
+		TIMER_Set( NPC, "rechargeDebounce", NPC->client->ps.torsoAnimTimer + 10000 + Q_irand(10000,20000) );
+		NPC->count--;
+		//now you have a chance of killing her
+		NPC->flags &= ~FL_UNDYING;
+	}
+}
+
+//======================================================================================
+//END TAVION BOSS
+//======================================================================================
+
+void Jedi_Cloak( gentity_t *self )
+{
+	if ( self && self->client )
+	{
+		if ( !self->client->ps.powerups[PW_CLOAKED] )
+		{//cloak
+			self->client->ps.powerups[PW_CLOAKED] = Q3_INFINITE;
+			self->client->ps.powerups[PW_UNCLOAKING] = level.time + 2000;
+			//FIXME: debounce attacks?
+			//FIXME: temp sound
+			G_SoundOnEnt( self, CHAN_ITEM, "sound/chars/shadowtrooper/cloak.wav" );
+		}
+	}
+}
+
+void Jedi_Decloak( gentity_t *self )
+{
+	if ( self && self->client )
+	{
+		if ( self->client->ps.powerups[PW_CLOAKED] )
+		{//Uncloak
+			self->client->ps.powerups[PW_CLOAKED] = 0;
+			self->client->ps.powerups[PW_UNCLOAKING] = level.time + 2000;
+			//FIXME: temp sound
+			G_SoundOnEnt( self, CHAN_ITEM, "sound/chars/shadowtrooper/decloak.wav" );
+		}
+	}
+}
+
+void Jedi_CheckCloak( void )
+{
+	if ( NPC 
+		&& NPC->client 
+		&& NPC->client->NPC_class == CLASS_SHADOWTROOPER
+		&& Q_stricmpn("shadowtrooper", NPC->NPC_type, 13 ) == 0 )
+	{
+		if ( NPC->client->ps.SaberActive() ||
+			NPC->health <= 0 || 
+			NPC->client->ps.saberInFlight ||
+			(NPC->client->ps.eFlags&EF_FORCE_GRIPPED) ||
+			(NPC->client->ps.eFlags&EF_FORCE_DRAINED) ||
+			NPC->painDebounceTime > level.time )
+		{//can't be cloaked if saber is on, or dead or saber in flight or taking pain or being gripped
+			Jedi_Decloak( NPC );
+		}
+		else if ( NPC->health > 0 
+			&& !NPC->client->ps.saberInFlight 
+			&& !(NPC->client->ps.eFlags&EF_FORCE_GRIPPED) 
+			&& !(NPC->client->ps.eFlags&EF_FORCE_DRAINED) 
+			&& NPC->painDebounceTime < level.time )
+		{//still alive, have saber in hand, not taking pain and not being gripped
+			Jedi_Cloak( NPC );
+		}
+	}
+}
+/*
+==========================================================================================
+AGGRESSION
+==========================================================================================
+*/
+static void Jedi_Aggression( gentity_t *self, int change )
+{
+	int	upper_threshold, lower_threshold;
+
+	self->NPC->stats.aggression += change;
+	
+	//FIXME: base this on initial NPC stats
+	if ( self->client->playerTeam == TEAM_PLAYER )
+	{//good guys are less aggressive
+		upper_threshold = 7;
+		lower_threshold = 1;
+	}
+	else
+	{//bad guys are more aggressive
+		if ( self->client->NPC_class == CLASS_DESANN )
+		{
+			upper_threshold = 20;
+			lower_threshold = 5;
+		}
+		else
+		{
+			upper_threshold = 10;
+			lower_threshold = 3;
+		}
+	}
+
+	if ( self->NPC->stats.aggression > upper_threshold )
+	{
+		self->NPC->stats.aggression = upper_threshold;
+	}
+	else if ( self->NPC->stats.aggression < lower_threshold )
+	{
+		self->NPC->stats.aggression = lower_threshold;
+	}
+	//Com_Printf( "(%d) %s agg %d change: %d\n", level.time, self->NPC_type, self->NPC->stats.aggression, change );
+}
+
+static void Jedi_AggressionErosion( int amt )
+{
+	if ( TIMER_Done( NPC, "roamTime" ) )
+	{//the longer we're not alerted and have no enemy, the more our aggression goes down
+		TIMER_Set( NPC, "roamTime", Q_irand( 2000, 5000 ) );
+		Jedi_Aggression( NPC, amt );
+	}
+	
+	if ( NPCInfo->stats.aggression < 4 || (NPCInfo->stats.aggression < 6&&NPC->client->NPC_class == CLASS_DESANN))
+	{//turn off the saber
+		WP_DeactivateSaber( NPC );
+	}
+}
+
+void NPC_Jedi_RateNewEnemy( gentity_t *self, gentity_t *enemy )
+{
+	float healthAggression;
+	float weaponAggression;
+
+	switch( enemy->s.weapon )
+	{
+	case WP_SABER:
+		healthAggression = (float)self->health/200.0f*6.0f;
+		weaponAggression = 7;//go after him
+		break;
+	case WP_BLASTER:
+		if ( DistanceSquared( self->currentOrigin, enemy->currentOrigin ) < 65536 )//256 squared
+		{
+			healthAggression = (float)self->health/200.0f*8.0f;
+			weaponAggression = 8;//go after him
+		}
+		else
+		{
+			healthAggression = 8.0f - ((float)self->health/200.0f*8.0f);
+			weaponAggression = 2;//hang back for a second
+		}
+		break;
+	default:
+		healthAggression = (float)self->health/200.0f*8.0f;
+		weaponAggression = 6;//approach
+		break;
+	}
+	//Average these with current aggression
+	int newAggression = ceil( (healthAggression + weaponAggression + (float)self->NPC->stats.aggression )/3.0f);
+	//Com_Printf( "(%d) new agg %d - new enemy\n", level.time, newAggression );
+	Jedi_Aggression( self, newAggression - self->NPC->stats.aggression );
+
+	//don't taunt right away
+	TIMER_Set( self, "chatter", Q_irand( 4000, 7000 ) );
+}
+
+static void Jedi_Rage( void )
+{
+	Jedi_Aggression( NPC, 10 - NPCInfo->stats.aggression + Q_irand( -2, 2 ) );
+	TIMER_Set( NPC, "roamTime", 0 );
+	TIMER_Set( NPC, "chatter", 0 );
+	TIMER_Set( NPC, "walking", 0 );
+	TIMER_Set( NPC, "taunting", 0 );
+	TIMER_Set( NPC, "jumpChaseDebounce", 0 );
+	TIMER_Set( NPC, "movenone", 0 );
+	TIMER_Set( NPC, "movecenter", 0 );
+	TIMER_Set( NPC, "noturn", 0 );
+	ForceRage( NPC );
+}
+
+void Jedi_RageStop( gentity_t *self )
+{
+	if ( self->NPC )
+	{//calm down and back off
+		TIMER_Set( self, "roamTime", 0 );
+		Jedi_Aggression( self, Q_irand( -5, 0 ) );
+	}
+}
+/*
+==========================================================================================
+SPEAKING
+==========================================================================================
+*/
+
+static qboolean Jedi_BattleTaunt( void )
+{
+	if ( TIMER_Done( NPC, "chatter" ) 
+		&& !Q_irand( 0, 3 ) 
+		&& NPCInfo->blockedSpeechDebounceTime < level.time 
+		&& jediSpeechDebounceTime[NPC->client->playerTeam] < level.time )
+	{
+		int event = -1;
+		if ( NPC->enemy 
+			&& NPC->enemy->client 
+			&& (NPC->enemy->client->NPC_class == CLASS_RANCOR
+				|| NPC->enemy->client->NPC_class == CLASS_WAMPA
+				|| NPC->enemy->client->NPC_class == CLASS_SAND_CREATURE) )
+		{//never taunt these mindless creatures
+			//NOTE: howlers?  tusken?  etc?  Only reborn?
+		}
+		else
+		{
+			if ( NPC->client->playerTeam == TEAM_PLAYER 
+				&& NPC->enemy && NPC->enemy->client && NPC->enemy->client->NPC_class == CLASS_JEDI )
+			{//a jedi fighting a jedi - training
+				if ( NPC->client->NPC_class == CLASS_JEDI && NPCInfo->rank == RANK_COMMANDER )
+				{//only trainer taunts
+					event = EV_TAUNT1;
+				}
+			}
+			else
+			{//reborn or a jedi fighting an enemy
+				event = Q_irand( EV_TAUNT1, EV_TAUNT3 );
+			}
+			if ( event != -1 )
+			{
+				G_AddVoiceEvent( NPC, event, 3000 );
+				jediSpeechDebounceTime[NPC->client->playerTeam] = NPCInfo->blockedSpeechDebounceTime = level.time + 6000;
+				if ( (NPCInfo->aiFlags&NPCAI_ROSH) )
+				{
+					TIMER_Set( NPC, "chatter", Q_irand( 8000, 20000 ) );
+				}
+				else
+				{
+					TIMER_Set( NPC, "chatter", Q_irand( 5000, 10000 ) );
+				}
+
+				if ( NPC->enemy && NPC->enemy->NPC && NPC->enemy->s.weapon == WP_SABER && NPC->enemy->client && NPC->enemy->client->NPC_class == CLASS_JEDI )
+				{//Have the enemy jedi say something in response when I'm done?
+				}
+				return qtrue;
+			}
+		}
+	}
+	return qfalse;
+}
+
+/*
+==========================================================================================
+MOVEMENT
+==========================================================================================
+*/
+static qboolean Jedi_ClearPathToSpot( vec3_t dest, int impactEntNum )
+{
+	trace_t	trace;
+	vec3_t	mins, start, end, dir;
+	float	dist, drop;
+
+	//Offset the step height
+	VectorSet( mins, NPC->mins[0], NPC->mins[1], NPC->mins[2] + STEPSIZE );
+	
+	gi.trace( &trace, NPC->currentOrigin, mins, NPC->maxs, dest, NPC->s.number, NPC->clipmask );
+
+	//Do a simple check
+	if ( trace.allsolid || trace.startsolid )
+	{//inside solid
+		return qfalse;
+	}
+
+	if ( trace.fraction < 1.0f )
+	{//hit something
+		if ( impactEntNum != ENTITYNUM_NONE && trace.entityNum == impactEntNum )
+		{//hit what we're going after
+			return qtrue;
+		}
+		else
+		{
+			return qfalse;
+		}
+	}
+
+	//otherwise, clear path in a straight line.  
+	//Now at intervals of my size, go along the trace and trace down STEPSIZE to make sure there is a solid floor.
+	VectorSubtract( dest, NPC->currentOrigin, dir );
+	dist = VectorNormalize( dir );
+	if ( dest[2] > NPC->currentOrigin[2] )
+	{//going up, check for steps
+		drop = STEPSIZE;
+	}
+	else
+	{//going down or level, check for moderate drops
+		drop = 64;
+	}
+	for ( float i = NPC->maxs[0]*2; i < dist; i += NPC->maxs[0]*2 )
+	{//FIXME: does this check the last spot, too?  We're assuming that should be okay since the enemy is there?
+		VectorMA( NPC->currentOrigin, i, dir, start );
+		VectorCopy( start, end );
+		end[2] -= drop;
+		gi.trace( &trace, start, mins, NPC->maxs, end, NPC->s.number, NPC->clipmask );//NPC->mins?
+		if ( trace.fraction < 1.0f || trace.allsolid || trace.startsolid )
+		{//good to go
+			continue;
+		}
+		//no floor here! (or a long drop?)
+		return qfalse;
+	}
+	//we made it!
+	return qtrue;
+}
+
+qboolean NPC_MoveDirClear( int forwardmove, int rightmove, qboolean reset )
+{
+	vec3_t	forward, right, testPos, angles, mins;
+	trace_t	trace;
+	float	fwdDist, rtDist;
+	float	bottom_max = -STEPSIZE*4 - 1;
+
+	if ( !forwardmove && !rightmove )
+	{//not even moving
+		//gi.Printf( "%d skipping walk-cliff check (not moving)\n", level.time );
+		return qtrue;
+	}
+
+	if ( ucmd.upmove > 0 || NPC->client->ps.forceJumpCharge )
+	{//Going to jump
+		//gi.Printf( "%d skipping walk-cliff check (going to jump)\n", level.time );
+		return qtrue;
+	}
+
+	if ( NPC->client->ps.groundEntityNum == ENTITYNUM_NONE )
+	{//in the air
+		//gi.Printf( "%d skipping walk-cliff check (in air)\n", level.time );
+		return qtrue;
+	}
+	/*
+	if ( fabs( AngleDelta( NPC->currentAngles[YAW], NPCInfo->desiredYaw ) ) < 5.0 )//!ucmd.angles[YAW] )
+	{//Not turning much, don't do this
+		//NOTE: Should this not happen only if you're not turning AT ALL?
+		//	You could be turning slowly but moving fast, so that would
+		//	still let you walk right off a cliff...
+		//NOTE: Or maybe it is a good idea to ALWAYS do this, regardless
+		//	of whether ot not we're turning?  But why would we be walking
+		//  straight into a wall or off	a cliff unless we really wanted to?
+		return;
+	}
+	*/
+
+	//FIXME: to really do this right, we'd have to actually do a pmove to predict where we're
+	//going to be... maybe this should be a flag and pmove handles it and sets a flag so AI knows
+	//NEXT frame?  Or just incorporate current velocity, runspeed and possibly friction?
+	VectorCopy( NPC->mins, mins );
+	mins[2] += STEPSIZE;
+	angles[PITCH] = angles[ROLL] = 0;
+	angles[YAW] = NPC->client->ps.viewangles[YAW];//Add ucmd.angles[YAW]?
+	AngleVectors( angles, forward, right, NULL );
+	fwdDist = ((float)forwardmove)/2.0f;
+	rtDist = ((float)rightmove)/2.0f;
+	VectorMA( NPC->currentOrigin, fwdDist, forward, testPos );
+	VectorMA( testPos, rtDist, right, testPos );
+	gi.trace( &trace, NPC->currentOrigin, mins, NPC->maxs, testPos, NPC->s.number, NPC->clipmask|CONTENTS_BOTCLIP );
+	if ( trace.allsolid || trace.startsolid )
+	{//hmm, trace started inside this brush... how do we decide if we should continue?
+		//FIXME: what do we do if we start INSIDE a CONTENTS_BOTCLIP? Try the trace again without that in the clipmask?
+		if ( reset )
+		{
+			trace.fraction = 1.0f;
+		}
+		VectorCopy( testPos, trace.endpos );
+		//return qtrue;
+	}
+	if ( trace.fraction < 0.6 )
+	{//Going to bump into something very close, don't move, just turn
+		if ( (NPC->enemy && trace.entityNum == NPC->enemy->s.number) || (NPCInfo->goalEntity && trace.entityNum == NPCInfo->goalEntity->s.number) )
+		{//okay to bump into enemy or goal
+			//gi.Printf( "%d bump into enemy/goal okay\n", level.time );
+			return qtrue;
+		}
+		else if ( reset )
+		{//actually want to screw with the ucmd
+			//gi.Printf( "%d avoiding walk into wall (entnum %d)\n", level.time, trace.entityNum );
+			ucmd.forwardmove = 0;
+			ucmd.rightmove = 0;
+			VectorClear( NPC->client->ps.moveDir );
+		}
+		return qfalse;
+	}
+
+	if ( NPCInfo->goalEntity )
+	{
+		if ( NPCInfo->goalEntity->currentOrigin[2] < NPC->currentOrigin[2] )
+		{//goal is below me, okay to step off at least that far plus stepheight
+			bottom_max += NPCInfo->goalEntity->currentOrigin[2] - NPC->currentOrigin[2];
+		}
+	}
+	VectorCopy( trace.endpos, testPos );
+	testPos[2] += bottom_max;
+
+	gi.trace( &trace, trace.endpos, mins, NPC->maxs, testPos, NPC->s.number, NPC->clipmask );
+
+	//FIXME:Should we try to see if we can still get to our goal using the waypoint network from this trace.endpos?
+	//OR: just put NPC clip brushes on these edges (still fall through when die)
+
+	if ( trace.allsolid || trace.startsolid )
+	{//Not going off a cliff
+		//gi.Printf( "%d walk off cliff okay (droptrace in solid)\n", level.time );
+		return qtrue;
+	}
+
+	if ( trace.fraction < 1.0 )
+	{//Not going off a cliff
+		//FIXME: what if plane.normal is sloped?  We'll slide off, not land... plus this doesn't account for slide-movement... 
+		//gi.Printf( "%d walk off cliff okay will hit entnum %d at dropdist of %4.2f\n", level.time, trace.entityNum, (trace.fraction*bottom_max) );
+		return qtrue;
+	}
+
+	//going to fall at least bottom_max, don't move, just turn... is this bad, though?  What if we want them to drop off?
+	if ( reset )
+	{//actually want to screw with the ucmd
+		//gi.Printf( "%d avoiding walk off cliff\n", level.time );
+		ucmd.forwardmove *= -1.0;//= 0;
+		ucmd.rightmove *= -1.0;//= 0;
+		VectorScale( NPC->client->ps.moveDir, -1, NPC->client->ps.moveDir );
+	}
+	return qfalse;
+}
+/*
+-------------------------
+Jedi_HoldPosition
+-------------------------
+*/
+
+static void Jedi_HoldPosition( void )
+{
+	//NPCInfo->squadState = SQUAD_STAND_AND_SHOOT;
+	NPCInfo->goalEntity = NULL;
+	
+	/*
+	if ( TIMER_Done( NPC, "stand" ) )
+	{
+		TIMER_Set( NPC, "duck", Q_irand( 2000, 4000 ) );
+	}
+	*/
+}
+
+/*
+-------------------------
+Jedi_Move
+-------------------------
+*/
+
+static qboolean Jedi_Move( gentity_t *goal, qboolean retreat )
+{
+	NPCInfo->combatMove = qtrue;
+	NPCInfo->goalEntity = goal;
+
+	qboolean	moved = NPC_MoveToGoal( qtrue );
+	if (!moved)
+	{
+		Jedi_HoldPosition();
+	}
+
+	// NAV_TODO: Put Retreate Behavior Here
+	//FIXME: temp retreat behavior- should really make this toward a safe spot or maybe to outflank enemy
+	if ( retreat )
+	{//FIXME: should we trace and make sure we can go this way?  Or somehow let NPC_MoveToGoal know we want to retreat and have it handle it?
+		ucmd.forwardmove *= -1;
+		ucmd.rightmove *= -1;
+		//we clear moveDir here so the Jedi's ucmd-driven movement does do not enter checks
+		VectorClear( NPC->client->ps.moveDir );
+		//VectorScale( NPC->client->ps.moveDir, -1, NPC->client->ps.moveDir );
+	}
+	return moved;
+}
+
+static qboolean Jedi_Hunt( void )
+{
+	//gi.Printf( "Hunting\n" );
+	//if we're at all interested in fighting, go after him
+	if ( NPCInfo->stats.aggression > 1 )
+	{//approach enemy
+		NPCInfo->combatMove = qtrue;
+		if ( !(NPCInfo->scriptFlags&SCF_CHASE_ENEMIES) )
+		{
+			NPC_UpdateAngles( qtrue, qtrue );
+			return qtrue;
+		}
+		else
+		{
+		/*	if ( NPCInfo->goalEntity == NULL )
+			{//hunt
+				NPCInfo->goalEntity = NPC->enemy;
+			}
+			if (NPC->client && NPC->client->NPC_class==CLASS_BOBAFETT)
+			{
+				NPCInfo->goalEntity = NPC->enemy;
+			}*/ 
+//			NPC_SetMoveGoal(NPC, NPC->enemy->currentOrigin, 40.0f, false, 0, NPC->enemy);
+			NPCInfo->goalEntity = NPC->enemy; 
+			NPCInfo->goalRadius = 40.0f; 
+
+			//Jedi_Move( NPC->enemy, qfalse );
+			if ( NPC_MoveToGoal( qfalse ) )
+			{
+				NPC_UpdateAngles( qtrue, qtrue );
+				return qtrue;
+			}
+		}
+	}
+	return qfalse;
+}
+
+/*
+static qboolean Jedi_Track( void )
+{
+	//if we're at all interested in fighting, go after him
+	if ( NPCInfo->stats.aggression > 1 )
+	{//approach enemy
+		NPCInfo->combatMove = qtrue;
+		NPC_SetMoveGoal( NPC, NPCInfo->enemyLastSeenLocation, 16, qtrue );
+		if ( NPC_MoveToGoal( qfalse ) )
+		{
+			NPC_UpdateAngles( qtrue, qtrue );
+			return qtrue;
+		}
+	}
+	return qfalse;
+}
+*/
+
+static void Jedi_StartBackOff( void )
+{ 
+	TIMER_Set( NPC, "roamTime", -level.time );
+	TIMER_Set( NPC, "strafeLeft", -level.time );
+	TIMER_Set( NPC, "strafeRight", -level.time );
+	TIMER_Set( NPC, "walking", -level.time );
+	TIMER_Set( NPC, "moveforward", -level.time );
+	TIMER_Set( NPC, "movenone", -level.time );
+	TIMER_Set( NPC, "moveright", -level.time );
+	TIMER_Set( NPC, "moveleft", -level.time );
+	TIMER_Set( NPC, "movecenter", -level.time );
+	TIMER_Set( NPC, "moveback", 1000 );
+	ucmd.forwardmove = -127; 
+	ucmd.rightmove = 0;
+	ucmd.upmove = 0;
+	if ( d_JediAI->integer )
+	{
+		Com_Printf( "%s backing off from spin attack!\n", NPC->NPC_type );
+	}
+	TIMER_Set( NPC, "specialEvasion", 1000 );
+	TIMER_Set( NPC, "noRetreat", -level.time );
+	if ( PM_PainAnim(NPC->client->ps.legsAnim) )
+	{
+		NPC->client->ps.legsAnimTimer = 0;
+	}
+	VectorClear( NPC->client->ps.moveDir );
+}
+
+static qboolean Jedi_Retreat( void )
+{
+	if ( !TIMER_Done( NPC, "noRetreat" ) )
+	{//don't actually move
+		return qfalse;
+	}
+	//FIXME: when retreating, we should probably see if we can retreat 
+	//in the direction we want.  If not...?  Evade?
+	//gi.Printf( "Retreating\n" );
+	return Jedi_Move( NPC->enemy, qtrue );
+}
+
+static qboolean Jedi_Advance( void )
+{
+	if ( (NPCInfo->aiFlags&NPCAI_HEAL_ROSH) )
+	{
+		return qfalse;
+	}
+	if ( !NPC->client->ps.saberInFlight )
+	{
+		NPC->client->ps.SaberActivate();
+	}
+	//gi.Printf( "Advancing\n" );
+	return Jedi_Move( NPC->enemy, qfalse );
+		
+	//TIMER_Set( NPC, "roamTime", Q_irand( 2000, 4000 ) );
+	//TIMER_Set( NPC, "attackDelay", Q_irand( 250, 500 ) );
+	//TIMER_Set( NPC, "duck", 0 );
+}
+
+static void Jedi_AdjustSaberAnimLevel( gentity_t *self, int newLevel )
+{	
+	if ( !self || !self->client )
+	{
+		return;
+	}
+	//FIXME: each NPC shold have a unique pattern of behavior for the order in which they
+	if ( self->client->playerTeam == TEAM_ENEMY )
+	{
+		//FIXME: CLASS_CULTIST + self->NPC->rank instead of these Q_stricmps?
+		if ( !Q_stricmp( "cultist_saber_all", self->NPC_type )
+			|| !Q_stricmp( "cultist_saber_all_throw", self->NPC_type ) )
+		{//use any, regardless of rank, etc.
+		}
+		else if ( !Q_stricmp( "cultist_saber", self->NPC_type )
+				|| !Q_stricmp( "cultist_saber_throw", self->NPC_type ) )
+		{//fast only
+			self->client->ps.saberAnimLevel = SS_FAST;
+		}
+		else if ( !Q_stricmp( "cultist_saber_med", self->NPC_type )
+					|| !Q_stricmp( "cultist_saber_med_throw", self->NPC_type ) )
+		{//med only
+			self->client->ps.saberAnimLevel = SS_MEDIUM;
+		}
+		else if ( !Q_stricmp( "cultist_saber_strong", self->NPC_type )
+				|| !Q_stricmp( "cultist_saber_strong_throw", self->NPC_type ) )
+		{//strong only
+			self->client->ps.saberAnimLevel = SS_STRONG;
+		}
+		else
+		{//regular reborn
+			if ( self->NPC->rank == RANK_CIVILIAN || self->NPC->rank == RANK_LT_JG )
+			{//grunt and fencer always uses quick attacks
+				self->client->ps.saberAnimLevel = SS_FAST;
+				return;
+			}
+			if ( self->NPC->rank == RANK_CREWMAN 
+				|| self->NPC->rank == RANK_ENSIGN )
+			{//acrobat & force-users always use medium attacks
+				self->client->ps.saberAnimLevel = SS_MEDIUM;
+				return;
+			}
+			/*
+			if ( self->NPC->rank == RANK_LT )
+			{//boss always uses strong attacks
+				self->client->ps.saberAnimLevel = SS_STRONG;
+				return;
+			}
+			*/
+		}
+	}
+	if ( newLevel < SS_FAST )
+	{
+		newLevel = SS_FAST;
+	}
+	else if ( newLevel > SS_STAFF )
+	{
+		newLevel = SS_STAFF;
+	}
+	//use the different attacks, how often they switch and under what circumstances
+	if ( !(self->client->ps.saberStylesKnown&(1<<newLevel)) )
+	{//don't know that style, sorry
+		return;
+	}
+	else
+	{//go ahead and set it
+		self->client->ps.saberAnimLevel = newLevel;
+	}
+
+	if ( d_JediAI->integer )
+	{
+		switch ( self->client->ps.saberAnimLevel )
+		{
+		case SS_FAST:
+			gi.Printf( S_COLOR_GREEN"%s Saber Attack Set: fast\n", self->NPC_type );
+			break;
+		case SS_MEDIUM:
+			gi.Printf( S_COLOR_YELLOW"%s Saber Attack Set: medium\n", self->NPC_type );
+			break;
+		case SS_STRONG:
+			gi.Printf( S_COLOR_RED"%s Saber Attack Set: strong\n", self->NPC_type );
+			break;
+		}
+	}
+}
+
+static void Jedi_CheckDecreaseSaberAnimLevel( void )
+{
+	if ( !NPC->client->ps.weaponTime && !(ucmd.buttons&(BUTTON_ATTACK|BUTTON_ALT_ATTACK|BUTTON_FORCE_FOCUS)) )
+	{//not attacking
+		if ( TIMER_Done( NPC, "saberLevelDebounce" ) && !Q_irand( 0, 10 ) )
+		{
+			//Jedi_AdjustSaberAnimLevel( NPC, (NPC->client->ps.saberAnimLevel-1) );//drop
+			Jedi_AdjustSaberAnimLevel( NPC, Q_irand( SS_FAST, SS_STRONG ));//random
+			TIMER_Set( NPC, "saberLevelDebounce", Q_irand( 3000, 10000 ) );
+		}
+	}
+	else
+	{
+		TIMER_Set( NPC, "saberLevelDebounce", Q_irand( 1000, 5000 ) );
+	}
+}
+
+static qboolean Jedi_DecideKick( void )
+{
+	if ( PM_InKnockDown( &NPC->client->ps ) )
+	{
+		return qfalse;
+	}
+	if ( PM_InRoll( &NPC->client->ps ) )
+	{
+		return qfalse;
+	}
+	if ( PM_InGetUp( &NPC->client->ps ) )
+	{
+		return qfalse;
+	}
+	if ( !NPC->enemy || (NPC->enemy->s.number < MAX_CLIENTS&&NPC->enemy->health<=0) )
+	{//have no enemy or enemy is a dead player
+		return qfalse;
+	}
+	//FIXME: check FP_SABER_OFFENSE?
+	//FIXME: check for saber staff style only?
+	//FIXME: g_spskill?
+	if ( Q_irand( 0, RANK_CAPTAIN+5 ) > NPCInfo->rank )
+	{//low chance, based on rank
+		return qfalse;
+	}
+	if ( Q_irand( 0, 10 ) > NPCInfo->stats.aggression )
+	{//the madder the better
+		return qfalse;
+	}
+	if ( !TIMER_Done( NPC, "kickDebounce" ) )
+	{//just did one
+		return qfalse;
+	}
+	//go for it!
+	return qtrue;
+}
+
+void Kyle_GrabEnemy( void )
+{
+	WP_SabersCheckLock2( NPC, NPC->enemy, (sabersLockMode_t)Q_irand(LOCK_KYLE_GRAB1,LOCK_KYLE_GRAB2) );//LOCK_KYLE_GRAB3
+	TIMER_Set( NPC, "grabEnemyDebounce", NPC->client->ps.torsoAnimTimer + Q_irand( 4000, 20000 ) );
+}
+
+void Kyle_TryGrab( void )
+{
+	NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_KYLE_GRAB, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+	NPC->client->ps.torsoAnimTimer += 200;
+	NPC->client->ps.weaponTime = NPC->client->ps.torsoAnimTimer;
+	NPC->client->ps.saberMove = NPC->client->ps.saberMoveNext = LS_READY;
+	VectorClear( NPC->client->ps.velocity );
+	VectorClear( NPC->client->ps.moveDir );
+	ucmd.rightmove = ucmd.forwardmove = ucmd.upmove = 0;
+	NPC->painDebounceTime = level.time + NPC->client->ps.torsoAnimTimer;
+	//WTF?
+	NPC->client->ps.SaberDeactivate();
+}
+
+qboolean Kyle_CanDoGrab( void )
+{
+	if ( NPC->client->NPC_class == CLASS_KYLE && (NPC->spawnflags&1) )
+	{//Boss Kyle
+		if ( NPC->enemy && NPC->enemy->client )
+		{//have a valid enemy
+			if ( TIMER_Done( NPC, "grabEnemyDebounce" ) )
+			{//okay to grab again
+				if ( NPC->client->ps.groundEntityNum != ENTITYNUM_NONE
+					&& NPC->enemy->client->ps.groundEntityNum != ENTITYNUM_NONE )
+				{//me and enemy are on ground
+					if ( !PM_InOnGroundAnim( &NPC->enemy->client->ps ) )
+					{
+						if ( (NPC->client->ps.weaponTime <= 200||NPC->client->ps.torsoAnim==BOTH_KYLE_GRAB)
+							&& !NPC->client->ps.saberInFlight )
+						{
+							if ( fabs(NPC->enemy->currentOrigin[2]-NPC->currentOrigin[2])<=8.0f )
+							{//close to same level of ground
+								if ( DistanceSquared( NPC->enemy->currentOrigin, NPC->currentOrigin ) <= 10000.0f )
+								{
+									return qtrue;
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+	return qfalse;
+}
+
+static void Jedi_CombatDistance( int enemy_dist )
+{//FIXME: for many of these checks, what we really want is horizontal distance to enemy
+	if ( Jedi_CultistDestroyer( NPC ) )
+	{//destroyer
+		Jedi_Advance();
+		//always run, regardless of what navigation tells us to do!
+		NPC->client->ps.speed = NPCInfo->stats.runSpeed;
+		ucmd.buttons &= ~BUTTON_WALKING;
+		return;
+	}
+	if ( enemy_dist < 128 
+		&& NPC->enemy
+		&& NPC->enemy->client
+		&& (NPC->enemy->client->ps.torsoAnim == BOTH_SPINATTACK6
+			|| NPC->enemy->client->ps.torsoAnim == BOTH_SPINATTACK7 ) )
+	{//whoa, back off!!!
+		if ( Q_irand( -3, NPCInfo->rank ) > RANK_CREWMAN )
+		{
+			Jedi_StartBackOff();
+			return;
+		}
+	}
+	if ( NPC->client->ps.forcePowersActive&(1<<FP_GRIP) &&
+		NPC->client->ps.forcePowerLevel[FP_GRIP] > FORCE_LEVEL_1 )
+	{//when gripping, don't move
+		return;
+	}
+	else if ( !TIMER_Done( NPC, "gripping" ) )
+	{//stopped gripping, clear timers just in case
+		TIMER_Set( NPC, "gripping", -level.time );
+		TIMER_Set( NPC, "attackDelay", Q_irand( 0, 1000 ) );
+	}
+	
+	if ( NPC->client->ps.forcePowersActive&(1<<FP_DRAIN) &&
+		NPC->client->ps.forcePowerLevel[FP_DRAIN] > FORCE_LEVEL_1 )
+	{//when draining, don't move
+		return;
+	}
+	else if ( !TIMER_Done( NPC, "draining" ) )
+	{//stopped draining, clear timers just in case
+		TIMER_Set( NPC, "draining", -level.time );
+		TIMER_Set( NPC, "attackDelay", Q_irand( 0, 1000 ) );
+	}
+
+	if ( NPC->client->NPC_class == CLASS_BOBAFETT )
+	{
+		if ( !TIMER_Done( NPC, "flameTime" ) )
+		{
+			if ( enemy_dist > 50 )
+			{
+				Jedi_Advance();
+			}
+			else if ( enemy_dist <= 0 )
+			{
+				Jedi_Retreat();
+			}
+		}
+		else if ( enemy_dist < 200 )
+		{
+			Jedi_Retreat();
+		}
+		else if ( enemy_dist > 1024 )
+		{
+			Jedi_Advance();
+		}
+	}
+	else if ( NPC->client->ps.legsAnim == BOTH_ALORA_SPIN_THROW )
+	{//don't move at all
+		//FIXME: sabers need trails
+	}
+	else if ( NPC->client->ps.torsoAnim == BOTH_KYLE_GRAB )
+	{//see if we grabbed enemy
+		if ( NPC->client->ps.torsoAnimTimer <= 200 )
+		{
+			if ( Kyle_CanDoGrab()
+				&& NPC_EnemyRangeFromBolt( NPC->handRBolt ) <= 72.0f )
+			{//grab him!
+				Kyle_GrabEnemy();
+				return;
+			}
+			else
+			{
+				NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_KYLE_MISS, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+				NPC->client->ps.weaponTime = NPC->client->ps.torsoAnimTimer;
+				return;
+			}
+		}
+		//else just sit here?
+		return;
+	}
+	else if ( NPC->client->ps.saberInFlight &&
+		!PM_SaberInBrokenParry( NPC->client->ps.saberMove )
+		&& NPC->client->ps.saberBlocked != BLOCKED_PARRY_BROKEN )
+	{//maintain distance
+		if ( enemy_dist < NPC->client->ps.saberEntityDist )
+		{
+			Jedi_Retreat();
+		}
+		else if ( enemy_dist > NPC->client->ps.saberEntityDist && enemy_dist > 100 )
+		{
+			Jedi_Advance();
+		}
+		if ( NPC->client->ps.weapon == WP_SABER //using saber
+			&& NPC->client->ps.saberEntityState == SES_LEAVING  //not returning yet
+			&& NPC->client->ps.forcePowerLevel[FP_SABERTHROW] > FORCE_LEVEL_1 //2nd or 3rd level lightsaber
+			&& !(NPC->client->ps.forcePowersActive&(1 << FP_SPEED))
+			&& !(NPC->client->ps.saberEventFlags&SEF_INWATER) )//saber not in water
+		{//hold it out there
+			ucmd.buttons |= BUTTON_ALT_ATTACK;
+			//FIXME: time limit?
+		}
+	}
+	else if ( !TIMER_Done( NPC, "taunting" ) )
+	{
+		if ( enemy_dist <= 64 )
+		{//he's getting too close
+			ucmd.buttons |= BUTTON_ATTACK;
+			if ( !NPC->client->ps.saberInFlight )
+			{
+				NPC->client->ps.SaberActivate();
+			}
+			TIMER_Set( NPC, "taunting", -level.time );
+		}
+		else if ( NPC->client->ps.torsoAnim == BOTH_GESTURE1 && NPC->client->ps.torsoAnimTimer < 2000 )
+		{//we're almost done with our special taunt
+			//FIXME: this doesn't always work, for some reason
+			if ( !NPC->client->ps.saberInFlight )
+			{
+				NPC->client->ps.SaberActivate();
+			}
+		}
+	}
+	else if ( NPC->client->ps.saberEventFlags&SEF_LOCK_WON )
+	{//we won a saber lock, press the advantage
+		if ( enemy_dist > 0 )
+		{//get closer so we can hit!
+			Jedi_Advance();
+		}
+		if ( enemy_dist > 128 )
+		{//lost 'em
+			NPC->client->ps.saberEventFlags &= ~SEF_LOCK_WON;
+		}
+		if ( NPC->enemy->painDebounceTime + 2000 < level.time )
+		{//the window of opportunity is gone
+			NPC->client->ps.saberEventFlags &= ~SEF_LOCK_WON;
+		}
+		//don't strafe?
+		TIMER_Set( NPC, "strafeLeft", -1 );
+		TIMER_Set( NPC, "strafeRight", -1 );
+	}
+	else if ( NPC->enemy->client 
+		&& NPC->enemy->s.weapon == WP_SABER 
+		&& NPC->enemy->client->ps.saberLockTime > level.time 
+		&& NPC->client->ps.saberLockTime < level.time )
+	{//enemy is in a saberLock and we are not
+		if ( enemy_dist < 64 )
+		{//FIXME: maybe just pick another enemy?
+			Jedi_Retreat();
+		}
+	}
+	else if ( NPC->enemy->s.weapon == WP_TURRET 
+		&& !Q_stricmp( "PAS", NPC->enemy->classname ) 
+		&& NPC->enemy->s.apos.trType == TR_STATIONARY )
+	{
+		if ( enemy_dist > forcePushPullRadius[FORCE_LEVEL_1] - 16 )
+		{
+			Jedi_Advance();
+		}
+		int	testlevel;
+		if ( NPC->client->ps.forcePowerLevel[FP_PUSH] < FORCE_LEVEL_1 )
+		{//
+			testlevel = FORCE_LEVEL_1;
+		}
+		else
+		{
+			testlevel = NPC->client->ps.forcePowerLevel[FP_PUSH];
+		}
+		if ( enemy_dist < forcePushPullRadius[testlevel] - 16 )
+		{//close enough to push
+			if ( InFront( NPC->enemy->currentOrigin, NPC->client->renderInfo.eyePoint, NPC->client->renderInfo.eyeAngles, 0.6f ) )
+			{//knock it down
+				WP_KnockdownTurret( NPC, NPC->enemy );
+				//do the forcethrow call just for effect
+				ForceThrow( NPC, qfalse );
+			}
+		}
+	}
+	else if ( enemy_dist <= 64 
+		&& ((NPCInfo->scriptFlags&SCF_DONT_FIRE)||(!Q_stricmp("Yoda",NPC->NPC_type)&&!Q_irand(0,10))) )
+	{//can't use saber and they're in striking range
+		if ( !Q_irand( 0, 5 ) && InFront( NPC->enemy->currentOrigin, NPC->currentOrigin, NPC->client->ps.viewangles, 0.2f ) )
+		{
+			if ( ((NPCInfo->scriptFlags&SCF_DONT_FIRE)||NPC->max_health - NPC->health > NPC->max_health*0.25f)//lost over 1/4 of our health or not firing
+				&& WP_ForcePowerUsable( NPC, FP_DRAIN, 20 )//know how to drain and have enough power
+				&& !Q_irand( 0, 2 ) )
+			{//drain
+				TIMER_Set( NPC, "draining", 3000 );
+				TIMER_Set( NPC, "attackDelay", 3000 );
+				Jedi_Advance();
+				return;
+			}
+			else
+			{
+				if ( Jedi_DecideKick() )
+				{//let's try a kick
+					if ( G_PickAutoMultiKick( NPC, qfalse, qtrue ) != LS_NONE
+						|| (G_CanKickEntity(NPC, NPC->enemy ) && G_PickAutoKick( NPC, NPC->enemy, qtrue ) != LS_NONE ) )
+					{//kicked!
+						TIMER_Set( NPC, "kickDebounce", Q_irand( 3000, 10000 ) );
+						return;
+					}
+				}
+				ForceThrow( NPC, qfalse );
+			}
+		}
+		Jedi_Retreat();
+	}
+	else if ( enemy_dist <= 64 
+		&& NPC->max_health - NPC->health > NPC->max_health*0.25f//lost over 1/4 of our health
+		&& NPC->client->ps.forcePowersKnown&(1<<FP_DRAIN) //know how to drain
+		&& WP_ForcePowerAvailable( NPC, FP_DRAIN, 20 )//have enough power
+		&& !Q_irand( 0, 10 ) 
+		&& InFront( NPC->enemy->currentOrigin, NPC->currentOrigin, NPC->client->ps.viewangles, 0.2f ) )
+	{
+		TIMER_Set( NPC, "draining", 3000 );
+		TIMER_Set( NPC, "attackDelay", 3000 );
+		Jedi_Advance();
+		return;
+	}
+	else if ( enemy_dist <= -16 )
+	{//we're too damn close!
+		if ( !Q_irand( 0, 30 )
+			&& Kyle_CanDoGrab() )
+		{
+			Kyle_TryGrab();
+			return;
+		}
+		else if ( NPC->client->ps.stats[STAT_WEAPONS]&(1<<WP_SCEPTER) 
+			&& !Q_irand( 0, 20 ) )
+		{
+			Tavion_StartScepterSlam();
+			return;
+		}
+		if ( Jedi_DecideKick() )
+		{//let's try a kick
+			if ( G_PickAutoMultiKick( NPC, qfalse, qtrue ) != LS_NONE
+				|| (G_CanKickEntity(NPC, NPC->enemy ) && G_PickAutoKick( NPC, NPC->enemy, qtrue ) != LS_NONE ) )
+			{//kicked!
+				TIMER_Set( NPC, "kickDebounce", Q_irand( 3000, 10000 ) );
+				return;
+			}
+		}
+		Jedi_Retreat();
+	}
+	else if ( enemy_dist <= 0 )
+	{//we're within striking range
+		//if we are attacking, see if we should stop
+		if ( NPCInfo->stats.aggression < 4 )
+		{//back off and defend
+			if ( !Q_irand( 0, 30 )
+				&& Kyle_CanDoGrab() )
+			{
+				Kyle_TryGrab();
+				return;
+			}
+			else if ( NPC->client->ps.stats[STAT_WEAPONS]&(1<<WP_SCEPTER) 
+				&& !Q_irand( 0, 20 ) )
+			{
+				Tavion_StartScepterSlam();
+				return;
+			}
+			if ( Jedi_DecideKick() )
+			{//let's try a kick
+				if ( G_PickAutoMultiKick( NPC, qfalse, qtrue ) != LS_NONE
+					|| (G_CanKickEntity(NPC, NPC->enemy ) && G_PickAutoKick( NPC, NPC->enemy, qtrue ) != LS_NONE ) )
+				{//kicked!
+					TIMER_Set( NPC, "kickDebounce", Q_irand( 3000, 10000 ) );
+					return;
+				}
+			}
+			Jedi_Retreat();
+		}
+	}
+	else if ( enemy_dist > 256 )
+	{//we're way out of range
+		qboolean usedForce = qfalse;
+		if ( NPCInfo->stats.aggression < Q_irand( 0, 20 ) 
+			&& NPC->health < NPC->max_health*0.75f 
+			&& !Q_irand( 0, 2 ) )
+		{
+			if ( NPC->enemy 
+				&& NPC->enemy->s.number < MAX_CLIENTS
+				&& NPC->client->NPC_class!=CLASS_KYLE
+				&& ((NPCInfo->aiFlags&NPCAI_BOSS_CHARACTER)
+					|| NPC->client->NPC_class==CLASS_SHADOWTROOPER) 
+				&& Q_irand(0, 3-g_spskill->integer) )
+			{//hmm, bosses should do this less against the player
+			}
+			else if ( NPC->client->ps.saber[0].type == SABER_SITH_SWORD 
+				&& NPC->weaponModel[0] != -1 )
+			{
+				Tavion_SithSwordRecharge();
+				usedForce = qtrue;
+			}
+			else if ( (NPC->client->ps.forcePowersKnown&(1<<FP_HEAL)) != 0 
+				&& (NPC->client->ps.forcePowersActive&(1<<FP_HEAL)) == 0 
+				&& Q_irand( 0, 1 ) )
+			{
+				ForceHeal( NPC );
+				usedForce = qtrue;
+				//FIXME: check level of heal and know not to move or attack when healing
+			}
+			else if ( (NPC->client->ps.forcePowersKnown&(1<<FP_PROTECT)) != 0 
+				&& (NPC->client->ps.forcePowersActive&(1<<FP_PROTECT)) == 0
+				&& Q_irand( 0, 1 ) )
+			{
+				ForceProtect( NPC );
+				usedForce = qtrue;
+			}
+			else if ( (NPC->client->ps.forcePowersKnown&(1<<FP_ABSORB)) != 0 
+				&& (NPC->client->ps.forcePowersActive&(1<<FP_ABSORB)) == 0
+				&& Q_irand( 0, 1 ) )
+			{
+				ForceAbsorb( NPC );
+				usedForce = qtrue;
+			}
+			else if ( (NPC->client->ps.forcePowersKnown&(1<<FP_RAGE)) != 0 
+				&& (NPC->client->ps.forcePowersActive&(1<<FP_RAGE)) == 0
+				&& Q_irand( 0, 1 ) )
+			{
+				Jedi_Rage();
+				usedForce = qtrue;
+			}
+			//FIXME: what about things like mind tricks and force sight?
+		}
+		if ( enemy_dist > 384 )
+		{//FIXME: check for enemy facing away and/or moving away
+			if ( !Q_irand( 0, 10 ) && NPCInfo->blockedSpeechDebounceTime < level.time && jediSpeechDebounceTime[NPC->client->playerTeam] < level.time )
+			{
+				if ( NPC_ClearLOS( NPC->enemy ) )
+				{
+					G_AddVoiceEvent( NPC, Q_irand( EV_JCHASE1, EV_JCHASE3 ), 3000 );
+				}
+				jediSpeechDebounceTime[NPC->client->playerTeam] = NPCInfo->blockedSpeechDebounceTime = level.time + 3000;
+			}
+		}
+		//Unless we're totally hiding, go after him
+		if ( NPCInfo->stats.aggression > 0 )
+		{//approach enemy
+			if ( !usedForce )
+			{
+				if ( NPC->enemy
+					&& NPC->enemy->client
+					&& (NPC->enemy->client->ps.torsoAnim == BOTH_SPINATTACK6
+						|| NPC->enemy->client->ps.torsoAnim == BOTH_SPINATTACK7 ) )
+				{//stay put!
+				}
+				else
+				{
+					Jedi_Advance();
+				}
+			}
+		}
+	}
+	/*
+	else if ( enemy_dist < 96 && NPC->enemy && NPC->enemy->client && NPC->enemy->client->ps.groundEntityNum == ENTITYNUM_NONE )
+	{//too close and in air, so retreat
+		Jedi_Retreat();
+	}
+	*/
+	//FIXME: enemy_dist calc needs to include all blade lengths, and include distance from hand to start of blade....
+	else if ( enemy_dist > 50 )//FIXME: not hardcoded- base on our reach (modelScale?) and saberLengthMax
+	{//we're out of striking range and we are allowed to attack
+		//first, check some tactical force power decisions 
+		if ( NPC->enemy && NPC->enemy->client && (NPC->enemy->client->ps.eFlags&EF_FORCE_GRIPPED) )
+		{//They're being gripped, rush them!
+			if ( NPC->enemy->client->ps.groundEntityNum != ENTITYNUM_NONE )
+			{//they're on the ground, so advance
+				if ( TIMER_Done( NPC, "parryTime" ) || NPCInfo->rank > RANK_LT )
+				{//not parrying
+					if ( enemy_dist > 200 || !(NPCInfo->scriptFlags&SCF_DONT_FIRE) )
+					{//far away or allowed to use saber
+						Jedi_Advance();
+					}
+				}
+			}
+			if ( (NPCInfo->rank >= RANK_LT_JG||WP_ForcePowerUsable( NPC, FP_SABERTHROW, 0 ))
+				&& !Q_irand( 0, 5 ) 
+				&& !(NPC->client->ps.forcePowersActive&(1 << FP_SPEED))
+				&& !(NPC->client->ps.saberEventFlags&SEF_INWATER) )//saber not in water
+			{//throw saber
+				ucmd.buttons |= BUTTON_ALT_ATTACK;
+			}
+		}
+		else if ( NPC->enemy && NPC->enemy->client && //valid enemy
+			NPC->enemy->client->ps.saberInFlight && NPC->enemy->client->ps.saber[0].Active() && //enemy throwing saber
+			!NPC->client->ps.weaponTime && //I'm not busy
+			WP_ForcePowerAvailable( NPC, FP_GRIP, 0 ) && //I can use the power
+			!Q_irand( 0, 10 ) && //don't do it all the time, averages to 1 check a second
+			Q_irand( 0, 6 ) < g_spskill->integer && //more likely on harder diff
+			Q_irand( RANK_CIVILIAN, RANK_CAPTAIN ) < NPCInfo->rank //more likely against harder enemies
+			&& InFOV( NPC->enemy->currentOrigin, NPC->currentOrigin, NPC->client->ps.viewangles, 20, 30 ) )
+		{//They're throwing their saber, grip them!
+			//taunt
+			if ( TIMER_Done( NPC, "chatter" ) && jediSpeechDebounceTime[NPC->client->playerTeam] < level.time && NPCInfo->blockedSpeechDebounceTime < level.time )
+			{
+				G_AddVoiceEvent( NPC, Q_irand( EV_TAUNT1, EV_TAUNT3 ), 3000 );
+				jediSpeechDebounceTime[NPC->client->playerTeam] = NPCInfo->blockedSpeechDebounceTime = level.time + 3000;
+				if ( (NPCInfo->aiFlags&NPCAI_ROSH) )
+				{
+					TIMER_Set( NPC, "chatter", 6000 );
+				}
+				else
+				{
+					TIMER_Set( NPC, "chatter", 3000 );
+				}
+			}
+
+			//grip
+			TIMER_Set( NPC, "gripping", 3000 );
+			TIMER_Set( NPC, "attackDelay", 3000 );
+		}
+		else
+		{
+			if ( NPC->enemy && NPC->enemy->client && (NPC->enemy->client->ps.forcePowersActive&(1<<FP_GRIP)) )
+			{//They're choking someone, probably an ally, run at them and do some sort of attack
+				if ( NPC->enemy->client->ps.groundEntityNum != ENTITYNUM_NONE )
+				{//they're on the ground, so advance
+					if ( TIMER_Done( NPC, "parryTime" ) || NPCInfo->rank > RANK_LT )
+					{//not parrying
+						if ( enemy_dist > 200 || !(NPCInfo->scriptFlags&SCF_DONT_FIRE) )
+						{//far away or allowed to use saber
+							Jedi_Advance();
+						}
+					}
+				}
+			}
+			if ( NPC->client->NPC_class == CLASS_KYLE
+				&& (NPC->spawnflags&1)
+				&& (NPC->enemy&&NPC->enemy->client&&!NPC->enemy->client->ps.saberInFlight)
+				&& TIMER_Done( NPC, "kyleTakesSaber" )
+				&& !Q_irand( 0, 20 ) )
+			{
+				ForceThrow( NPC, qtrue );
+			}
+			else if ( NPC->client->ps.stats[STAT_WEAPONS]&(1<<WP_SCEPTER) 
+				&& !Q_irand( 0, 20 ) )
+			{
+				Tavion_StartScepterBeam();
+				return;
+			}
+			else
+			{
+				int chanceScale = 0;
+				if ( NPC->client->NPC_class == CLASS_KYLE && (NPC->spawnflags&1) )
+				{
+					chanceScale = 4;
+				}
+				else if ( NPC->enemy 
+					&& NPC->enemy->s.number < MAX_CLIENTS
+					&& ((NPCInfo->aiFlags&NPCAI_BOSS_CHARACTER)
+						|| NPC->client->NPC_class==CLASS_SHADOWTROOPER) )
+				{//hmm, bosses do this less against player
+					chanceScale = 8 - g_spskill->integer*2; 
+				}
+				else if ( NPC->client->NPC_class == CLASS_DESANN 
+					|| !Q_stricmp("Yoda",NPC->NPC_type) )
+					//|| (NPC->client->NPC_class == CLASS_CULTIST && NPC->client->ps.weapon == WP_NONE) )//force-only cultists use force a lot
+				{
+					chanceScale = 1;
+				}
+				else if ( NPCInfo->rank == RANK_ENSIGN )
+				{
+					chanceScale = 2;
+				}
+				else if ( NPCInfo->rank >= RANK_LT_JG )
+				{
+					chanceScale = 5;
+				}
+				if ( chanceScale 
+					&& (enemy_dist > Q_irand( 100, 200 ) || (NPCInfo->scriptFlags&SCF_DONT_FIRE) || (!Q_stricmp("Yoda",NPC->NPC_type)&&!Q_irand(0,3)) )
+					&& enemy_dist < 500 
+					&& (Q_irand( 0, chanceScale*10 )<5 || (NPC->enemy->client && NPC->enemy->client->ps.weapon != WP_SABER && !Q_irand( 0, chanceScale ) ) ) )
+				{//else, randomly try some kind of attack every now and then
+					//FIXME: Cultist fencers don't have any of these fancy powers
+					//			the only thing they might be able to do is throw their saber
+					if ( (NPCInfo->rank == RANK_ENSIGN //old reborn crap
+							|| NPCInfo->rank > RANK_LT_JG //old reborn crap
+						/*
+							|| WP_ForcePowerUsable( NPC, FP_PULL, 0 )
+							|| WP_ForcePowerUsable( NPC, FP_LIGHTNING, 0 )
+							|| WP_ForcePowerUsable( NPC, FP_DRAIN, 0 ) 
+							|| WP_ForcePowerUsable( NPC, FP_GRIP, 0 ) 
+							|| WP_ForcePowerUsable( NPC, FP_SABERTHROW, 0 )
+						*/
+						)
+						&& (!Q_irand( 0, 1 ) || NPC->s.weapon != WP_SABER) )
+					{
+						if ( WP_ForcePowerUsable( NPC, FP_PULL, 0 ) && !Q_irand( 0, 2 ) )
+						{
+							//force pull the guy to me!
+							//FIXME: check forcePushRadius[NPC->client->ps.forcePowerLevel[FP_PUSH]]
+							ForceThrow( NPC, qtrue );
+							//maybe strafe too?
+							TIMER_Set( NPC, "duck", enemy_dist*3 );
+							if ( Q_irand( 0, 1 ) )
+							{
+								ucmd.buttons |= BUTTON_ATTACK;
+							}
+						}
+						else if ( WP_ForcePowerUsable( NPC, FP_LIGHTNING, 0 ) 
+							&& ((NPCInfo->scriptFlags&SCF_DONT_FIRE)&&Q_stricmp("cultist_lightning",NPC->NPC_type) || Q_irand( 0, 1 )) )
+						{
+							ForceLightning( NPC );
+							if ( NPC->client->ps.forcePowerLevel[FP_LIGHTNING] > FORCE_LEVEL_1 )
+							{
+								NPC->client->ps.weaponTime = Q_irand( 1000, 3000+(g_spskill->integer*500) );
+								TIMER_Set( NPC, "holdLightning", NPC->client->ps.weaponTime );
+							}
+							TIMER_Set( NPC, "attackDelay", NPC->client->ps.weaponTime );
+						}
+						else if ( NPC->health < NPC->max_health * 0.75f
+							&& Q_irand( FORCE_LEVEL_0, NPC->client->ps.forcePowerLevel[FP_DRAIN] ) > FORCE_LEVEL_1
+							&& WP_ForcePowerUsable( NPC, FP_DRAIN, 0 ) 
+							&& ((NPCInfo->scriptFlags&SCF_DONT_FIRE)&&Q_stricmp("cultist_drain",NPC->NPC_type) || Q_irand( 0, 1 )) )
+						{
+							ForceDrain2( NPC );
+							NPC->client->ps.weaponTime = Q_irand( 1000, 3000+(g_spskill->integer*500) );
+							TIMER_Set( NPC, "draining", NPC->client->ps.weaponTime );
+							TIMER_Set( NPC, "attackDelay", NPC->client->ps.weaponTime );
+						}
+						else if ( WP_ForcePowerUsable( NPC, FP_GRIP, 0 )
+							&& NPC->enemy && InFOV( NPC->enemy->currentOrigin, NPC->currentOrigin, NPC->client->ps.viewangles, 20, 30 ) )
+						{
+							//taunt
+							if ( TIMER_Done( NPC, "chatter" ) && jediSpeechDebounceTime[NPC->client->playerTeam] < level.time && NPCInfo->blockedSpeechDebounceTime < level.time )
+							{
+								G_AddVoiceEvent( NPC, Q_irand( EV_TAUNT1, EV_TAUNT3 ), 3000 );
+								jediSpeechDebounceTime[NPC->client->playerTeam] = NPCInfo->blockedSpeechDebounceTime = level.time + 3000;
+								if ( (NPCInfo->aiFlags&NPCAI_ROSH) )
+								{
+									TIMER_Set( NPC, "chatter", 6000 );
+								}
+								else
+								{
+									TIMER_Set( NPC, "chatter", 3000 );
+								}
+							}
+
+							//grip
+							TIMER_Set( NPC, "gripping", 3000 );
+							TIMER_Set( NPC, "attackDelay", 3000 );
+						}
+						else
+						{
+							if ( WP_ForcePowerUsable( NPC, FP_SABERTHROW, 0 ) 
+								&& !(NPC->client->ps.forcePowersActive&(1 << FP_SPEED))
+								&& !(NPC->client->ps.saberEventFlags&SEF_INWATER) )//saber not in water
+							{//throw saber
+								ucmd.buttons |= BUTTON_ALT_ATTACK;
+							}
+						}
+					}
+					else
+					{
+						if ( (NPCInfo->rank >= RANK_LT_JG||WP_ForcePowerUsable( NPC, FP_SABERTHROW, 0 ))
+							&& !(NPC->client->ps.forcePowersActive&(1 << FP_SPEED))
+							&& !(NPC->client->ps.saberEventFlags&SEF_INWATER) )//saber not in water
+						{//throw saber
+							ucmd.buttons |= BUTTON_ALT_ATTACK;
+						}
+					}
+				}
+				//see if we should advance now
+				else if ( NPCInfo->stats.aggression > 5 )
+				{//approach enemy
+					if ( TIMER_Done( NPC, "parryTime" ) || NPCInfo->rank > RANK_LT )
+					{//not parrying
+						if ( !NPC->enemy->client || NPC->enemy->client->ps.groundEntityNum != ENTITYNUM_NONE )
+						{//they're on the ground, so advance
+							if ( enemy_dist > 200 || !(NPCInfo->scriptFlags&SCF_DONT_FIRE) )
+							{//far away or allowed to use saber
+								Jedi_Advance();
+							}
+						}
+					}
+				}
+				else
+				{//maintain this distance?
+					//walk?
+				}
+			}
+		}
+	}
+	else
+	{//we're not close enough to attack, but not far enough away to be safe
+		if ( !Q_irand( 0, 30 ) 
+			&& Kyle_CanDoGrab() )
+		{
+			Kyle_TryGrab();
+			return;
+		}
+		if ( NPCInfo->stats.aggression < 4 )
+		{//back off and defend
+			if ( Jedi_DecideKick() )
+			{//let's try a kick
+				if ( G_PickAutoMultiKick( NPC, qfalse, qtrue ) != LS_NONE
+					|| (G_CanKickEntity(NPC, NPC->enemy ) && G_PickAutoKick( NPC, NPC->enemy, qtrue ) != LS_NONE ) )
+				{//kicked!
+					TIMER_Set( NPC, "kickDebounce", Q_irand( 3000, 10000 ) );
+					return;
+				}
+			}
+			Jedi_Retreat();
+		}
+		else if ( NPCInfo->stats.aggression > 5 )
+		{//try to get closer
+			if ( enemy_dist > 0 && !(NPCInfo->scriptFlags&SCF_DONT_FIRE))
+			{//we're allowed to use our lightsaber, get closer
+				if ( TIMER_Done( NPC, "parryTime" ) || NPCInfo->rank > RANK_LT )
+				{//not parrying
+					if ( !NPC->enemy->client || NPC->enemy->client->ps.groundEntityNum != ENTITYNUM_NONE )
+					{//they're on the ground, so advance
+						Jedi_Advance();
+					}
+				}
+			}
+		}
+		else
+		{//agression is 4 or 5... somewhere in the middle
+			//what do we do here?  Nothing?
+			//Move forward and back?
+		}
+	}
+	//if really really mad, rage!
+	if ( NPCInfo->stats.aggression > Q_irand( 5, 15 )
+		&& NPC->health < NPC->max_health*0.75f 
+		&& !Q_irand( 0, 2 ) )
+	{
+		if ( (NPC->client->ps.forcePowersKnown&(1<<FP_RAGE)) != 0 
+			&& (NPC->client->ps.forcePowersActive&(1<<FP_RAGE)) == 0 )
+		{
+			Jedi_Rage();
+		}
+	}
+}
+
+static qboolean Jedi_Strafe( int strafeTimeMin, int strafeTimeMax, int nextStrafeTimeMin, int nextStrafeTimeMax, qboolean walking )
+{
+	if ( Jedi_CultistDestroyer( NPC ) )
+	{//never strafe
+		return qfalse;
+	}
+	if ( NPC->client->ps.saberEventFlags&SEF_LOCK_WON && NPC->enemy && NPC->enemy->painDebounceTime > level.time )
+	{//don't strafe if pressing the advantage of winning a saberLock
+		return qfalse;
+	}
+	if ( TIMER_Done( NPC, "strafeLeft" ) && TIMER_Done( NPC, "strafeRight" ) )
+	{
+		qboolean strafed = qfalse;
+		//TODO: make left/right choice a tactical decision rather than random:
+		//		try to keep own back away from walls and ledges, 
+		//		try to keep enemy's back to a ledge or wall
+		//		Maybe try to strafe toward designer-placed "safe spots" or "goals"?
+		int	strafeTime = Q_irand( strafeTimeMin, strafeTimeMax );
+
+		if ( Q_irand( 0, 1 ) )
+		{
+			if ( NPC_MoveDirClear( ucmd.forwardmove, -127, qfalse ) )
+			{
+				TIMER_Set( NPC, "strafeLeft", strafeTime );
+				strafed = qtrue;
+			}
+			else if ( NPC_MoveDirClear( ucmd.forwardmove, 127, qfalse ) )
+			{
+				TIMER_Set( NPC, "strafeRight", strafeTime );
+				strafed = qtrue;
+			}
+		}
+		else
+		{
+			if ( NPC_MoveDirClear( ucmd.forwardmove, 127, qfalse  ) )
+			{
+				TIMER_Set( NPC, "strafeRight", strafeTime );
+				strafed = qtrue;
+			}
+			else if ( NPC_MoveDirClear( ucmd.forwardmove, -127, qfalse  ) )
+			{
+				TIMER_Set( NPC, "strafeLeft", strafeTime );
+				strafed = qtrue;
+			}
+		}
+
+		if ( strafed )
+		{
+			TIMER_Set( NPC, "noStrafe", strafeTime + Q_irand( nextStrafeTimeMin, nextStrafeTimeMax ) );
+			if ( walking )
+			{//should be a slow strafe
+				TIMER_Set( NPC, "walking", strafeTime );
+			}
+			return qtrue;
+		}
+	}
+	return qfalse;
+}
+
+/*
+static void Jedi_FaceEntity( gentity_t *self, gentity_t *other, qboolean doPitch )
+{
+	vec3_t		entPos;
+	vec3_t		muzzle;
+
+	//Get the positions
+	CalcEntitySpot( other, SPOT_ORIGIN, entPos );
+
+	//Get the positions
+	CalcEntitySpot( self, SPOT_HEAD_LEAN, muzzle );//SPOT_HEAD
+
+	//Find the desired angles
+	vec3_t	angles;
+
+	GetAnglesForDirection( muzzle, entPos, angles );
+
+	self->NPC->desiredYaw		= AngleNormalize360( angles[YAW] );
+	if ( doPitch )
+	{
+		self->NPC->desiredPitch	= AngleNormalize360( angles[PITCH] );
+	}
+}
+*/
+
+/*
+qboolean Jedi_DodgeEvasion( gentity_t *self, gentity_t *shooter, trace_t *tr, int hitLoc )
+
+Jedi will play a dodge anim, blur, and make the force speed noise.
+
+Right now used to dodge instant-hit weapons.
+
+FIXME: possibly call this for saber melee evasion and/or missile evasion?
+FIXME: possibly let player do this too?
+*/
+qboolean Jedi_DodgeEvasion( gentity_t *self, gentity_t *shooter, trace_t *tr, int hitLoc )
+{
+	int	dodgeAnim = -1;
+
+	if ( !self || !self->client || self->health <= 0 )
+	{
+		return qfalse;
+	}
+
+	if ( self->client->ps.groundEntityNum == ENTITYNUM_NONE )
+	{//can't dodge in mid-air
+		return qfalse;
+	}
+
+	if ( self->client->ps.pm_time && (self->client->ps.pm_flags&PMF_TIME_KNOCKBACK) )
+	{//in some effect that stops me from moving on my own
+		return qfalse;
+	}
+
+	if ( self->enemy == shooter )
+	{//FIXME: make it so that we are better able to dodge shots from my current enemy
+	}
+	if ( self->s.number )
+	{//if an NPC, check game skill setting
+		/*
+		if ( self->NPC && (self->NPC->aiFlags&NPCAI_BOSS_CHARACTER) )
+		{//those NPCs are "bosses" and always succeed
+			if ( Q_irand( 0, 2 ) > g_spskill->integer )
+			{//more of a chance of failing the dodge on lower difficulty
+				return qfalse;
+			}
+			//FIXME: check my overall skill (rank) to determine if I should be able to dodge it?
+			//check force speed power level to determine if I should be able to dodge it
+			if ( Q_irand( 0, 3 ) > self->client->ps.forcePowerLevel[FP_SPEED] )
+			{//more likely to fail on lower force speed level, but NPCs are generally better at it than the player
+				return qfalse;
+			}
+		}
+		*/
+	}
+	else
+	{//the player
+		if ( !(self->client->ps.forcePowersActive&(1<<FP_SPEED)) )
+		{//not already in speed
+			if ( !WP_ForcePowerUsable( self, FP_SPEED, 0 ) )
+			{//make sure we have it and have enough force power
+				return qfalse;
+			}
+		}
+		//check force speed power level to determine if I should be able to dodge it
+		if ( Q_irand( 1, 10 ) > self->client->ps.forcePowerLevel[FP_SPEED] )
+		{//more likely to fail on lower force speed level
+			return qfalse;
+		}
+	}
+
+	if ( hitLoc == HL_NONE )
+	{
+		if ( tr )
+		{
+			for ( int z = 0; z < MAX_G2_COLLISIONS; z++ )
+			{
+				if ( tr->G2CollisionMap[z].mEntityNum == -1 )
+				{//actually, completely break out of this for loop since nothing after this in the aray should ever be valid either
+					continue;//break;//
+				}
+
+				CCollisionRecord &coll	= tr->G2CollisionMap[z];
+				G_GetHitLocFromSurfName( &g_entities[coll.mEntityNum], gi.G2API_GetSurfaceName( &g_entities[coll.mEntityNum].ghoul2[coll.mModelIndex], coll.mSurfaceIndex ), &hitLoc, coll.mCollisionPosition, NULL, NULL, MOD_UNKNOWN );
+				//only want the first
+				break;
+			}
+		}
+	}
+
+	switch( hitLoc )
+	{
+	case HL_NONE:
+		return qfalse;
+		break;
+
+	case HL_FOOT_RT:
+	case HL_FOOT_LT:
+	case HL_LEG_RT:
+	case HL_LEG_LT:
+	case HL_WAIST:
+		if ( !self->s.number )
+		{//don't force the player to jump
+			return qfalse;
+		}
+		else
+		{
+			if ( !self->enemy && G_ValidEnemy(self,shooter))
+			{
+				G_SetEnemy( self, shooter );
+			}
+			if ( self->NPC 
+				&& ((self->NPC->scriptFlags&SCF_NO_ACROBATICS) || PM_InKnockDown( &self->client->ps ) ) )
+			{
+				return qfalse;
+			}
+			if ( self->client 
+				&& (self->client->ps.forceRageRecoveryTime > level.time || (self->client->ps.forcePowersActive&(1<<FP_RAGE))) )
+			{//no fancy dodges when raging or recovering
+				return qfalse;
+			}
+			if ( self->client->NPC_class == CLASS_BOBAFETT && !Q_irand(0,1))
+			{
+				return qfalse; // half the time he dodges
+			}
+
+
+			if ( self->client->NPC_class == CLASS_BOBAFETT 
+				|| (self->client->NPC_class == CLASS_REBORN && self->s.weapon != WP_SABER)
+				|| self->client->NPC_class == CLASS_ROCKETTROOPER )
+			{
+				self->client->ps.forceJumpCharge = 280;//FIXME: calc this intelligently?
+			}
+			else
+			{
+				self->client->ps.forceJumpCharge = 320;//FIXME: calc this intelligently?
+				WP_ForcePowerStop( self, FP_GRIP );
+			}
+			return qtrue;
+		}
+		break;
+
+	case HL_BACK_RT:
+		dodgeAnim = BOTH_DODGE_FL;
+		break;
+	case HL_CHEST_RT:
+		dodgeAnim = BOTH_DODGE_BL;
+		break;
+	case HL_BACK_LT:
+		dodgeAnim = BOTH_DODGE_FR;
+		break;
+	case HL_CHEST_LT:
+		dodgeAnim = BOTH_DODGE_BR;
+		break;
+	case HL_BACK:
+	case HL_CHEST:
+		dodgeAnim = Q_irand( BOTH_DODGE_FL, BOTH_DODGE_R );
+		break;
+	case HL_ARM_RT:
+	case HL_HAND_RT:
+		dodgeAnim = BOTH_DODGE_L;
+		break;
+	case HL_ARM_LT:
+	case HL_HAND_LT:
+		dodgeAnim = BOTH_DODGE_R;
+		break;
+	case HL_HEAD:
+		dodgeAnim = Q_irand( BOTH_DODGE_FL, BOTH_DODGE_BR );
+		break;
+	}
+
+	if ( dodgeAnim != -1 )
+	{
+		int extraHoldTime = 0;//Q_irand( 5, 40 ) * 50;
+		/*
+		int type = SETANIM_TORSO;
+		if ( VectorCompare( self->client->ps.velocity, vec3_origin ) )
+		{//not moving
+			type = SETANIM_BOTH;
+		}
+		*/
+		if ( self->s.number < MAX_CLIENTS )
+		{//player
+			if ( (self->client->ps.forcePowersActive&(1<<FP_SPEED)) )
+			{//in speed
+				if ( PM_DodgeAnim( self->client->ps.torsoAnim ) 
+					&& !PM_DodgeHoldAnim( self->client->ps.torsoAnim ) )
+				{//already in a dodge
+					//use the hold pose, don't start it all over again
+					dodgeAnim = BOTH_DODGE_HOLD_FL+(dodgeAnim-BOTH_DODGE_FL);
+					extraHoldTime = 200;
+				}
+			}
+		}
+
+		//set the dodge anim we chose
+		NPC_SetAnim( self, SETANIM_BOTH, dodgeAnim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );//type
+		if ( extraHoldTime && self->client->ps.torsoAnimTimer < extraHoldTime )
+		{
+			self->client->ps.torsoAnimTimer += extraHoldTime;
+		}
+		//if ( type == SETANIM_BOTH )
+		{
+			self->client->ps.legsAnimTimer = self->client->ps.torsoAnimTimer;
+		}
+
+		if ( self->s.number )
+		{//NPC
+			//maybe force them to stop moving in this case?
+			self->client->ps.pm_time = self->client->ps.torsoAnimTimer + Q_irand( 100, 1000 );
+			self->client->ps.pm_flags |= PMF_TIME_KNOCKBACK;
+			//do force speed effect
+			self->client->ps.forcePowersActive |= (1 << FP_SPEED);
+			self->client->ps.forcePowerDuration[FP_SPEED] = level.time + self->client->ps.torsoAnimTimer;
+			//sound
+			G_Sound( self, G_SoundIndex( "sound/weapons/force/speed.wav" ) );
+		}
+		else
+		{//player
+			ForceSpeed( self, 500 );
+		}
+
+		WP_ForcePowerStop( self, FP_GRIP );
+		if ( !self->enemy && G_ValidEnemy( self, shooter) )
+		{
+			G_SetEnemy( self, shooter );
+			if ( self->s.number )
+			{
+				Jedi_Aggression( self, 10 );
+			}
+		}
+		return qtrue;
+	}
+	return qfalse;
+}
+
+evasionType_t Jedi_CheckFlipEvasions( gentity_t *self, float rightdot, float zdiff )
+{
+	if ( self->NPC && (self->NPC->scriptFlags&SCF_NO_ACROBATICS) )
+	{
+		return EVASION_NONE;
+	}
+	if ( self->client )
+	{
+		if ( self->client->NPC_class == CLASS_BOBAFETT )
+		{//boba can't flip
+			return EVASION_NONE;
+		}
+		if ( self->client->ps.forceRageRecoveryTime > level.time	
+			|| (self->client->ps.forcePowersActive&(1<<FP_RAGE)) )
+		{//no fancy dodges when raging
+			return EVASION_NONE;
+		}
+	}
+
+	//Check for:
+	//ARIALS/CARTWHEELS
+	//WALL-RUNS
+	//WALL-FLIPS
+	//FIXME: if facing a wall, do forward wall-walk-backflip
+	//FIXME: add new JKA ones
+
+//FIXMEFIXMEFIXMEFIXMEFIXMEFIXMEFIXMEFIXMEFIXMEFIXMEFIXMEFIXMEFIXMEFIXMEFIXMEFIXMEFIXMEFIXME
+//
+//Make these check for do not enter and ledges!!!
+//
+//FIXMEFIXMEFIXMEFIXMEFIXMEFIXMEFIXMEFIXMEFIXMEFIXMEFIXMEFIXMEFIXMEFIXMEFIXMEFIXMEFIXMEFIXME
+
+	if ( self->client->ps.legsAnim == BOTH_WALL_RUN_LEFT || self->client->ps.legsAnim == BOTH_WALL_RUN_RIGHT )
+	{//already running on a wall
+		vec3_t right, fwdAngles = {0, self->client->ps.viewangles[YAW], 0};
+		int		anim = -1;
+
+		AngleVectors( fwdAngles, NULL, right, NULL );
+
+		float animLength = PM_AnimLength( self->client->clientInfo.animFileIndex, (animNumber_t)self->client->ps.legsAnim );
+		if ( self->client->ps.legsAnim == BOTH_WALL_RUN_LEFT && rightdot < 0 )
+		{//I'm running on a wall to my left and the attack is on the left
+			if ( animLength - self->client->ps.legsAnimTimer > 400
+				&& self->client->ps.legsAnimTimer > 400 )
+			{//not at the beginning or end of the anim
+				anim = BOTH_WALL_RUN_LEFT_FLIP;
+			}
+		}
+		else if ( self->client->ps.legsAnim == BOTH_WALL_RUN_RIGHT && rightdot > 0 )
+		{//I'm running on a wall to my right and the attack is on the right
+			if ( animLength - self->client->ps.legsAnimTimer > 400
+				&& self->client->ps.legsAnimTimer > 400 )
+			{//not at the beginning or end of the anim
+				anim = BOTH_WALL_RUN_RIGHT_FLIP;
+			}
+		}
+		if ( anim != -1 )
+		{//flip off the wall!
+			//FIXME: check the direction we will flip towards for do-not-enter/walls/drops?
+			//NOTE: we presume there is still a wall there!
+			if ( anim == BOTH_WALL_RUN_LEFT_FLIP )
+			{
+				self->client->ps.velocity[0] *= 0.5f;
+				self->client->ps.velocity[1] *= 0.5f;
+				VectorMA( self->client->ps.velocity, 150, right, self->client->ps.velocity );
+			}
+			else if ( anim == BOTH_WALL_RUN_RIGHT_FLIP )
+			{
+				self->client->ps.velocity[0] *= 0.5f;
+				self->client->ps.velocity[1] *= 0.5f;
+				VectorMA( self->client->ps.velocity, -150, right, self->client->ps.velocity );
+			}
+			int parts = SETANIM_LEGS;
+			if ( !self->client->ps.weaponTime )
+			{
+				parts = SETANIM_BOTH;
+			}
+			NPC_SetAnim( self, parts, anim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+			self->client->ps.pm_flags |= (PMF_JUMPING|PMF_SLOW_MO_FALL);
+			G_AddEvent( self, EV_JUMP, 0 );
+			return EVASION_OTHER;
+		}
+	}
+	else if ( self->client->NPC_class != CLASS_DESANN //desann doesn't do these kind of frilly acrobatics
+		&& (self->NPC->rank == RANK_CREWMAN || self->NPC->rank >= RANK_LT) 
+		&& Q_irand( 0, 1 ) 
+		&& !PM_InRoll( &self->client->ps )
+		&& !PM_InKnockDown( &self->client->ps )
+		&& !PM_SaberInSpecialAttack( self->client->ps.torsoAnim ) )
+	{
+		vec3_t fwd, right, traceto, mins = {self->mins[0],self->mins[1],self->mins[2]+STEPSIZE}, maxs = {self->maxs[0],self->maxs[1],24}, fwdAngles = {0, self->client->ps.viewangles[YAW], 0};
+		trace_t	trace;
+
+		AngleVectors( fwdAngles, fwd, right, NULL );
+
+		int parts = SETANIM_BOTH, anim;
+		float	speed, checkDist;
+
+		if ( PM_SaberInAttack( self->client->ps.saberMove )
+			|| PM_SaberInStart( self->client->ps.saberMove ) )
+		{
+			parts = SETANIM_LEGS;
+		}
+		if ( rightdot >= 0 )
+		{
+			if ( Q_irand( 0, 1 ) )
+			{
+				anim = BOTH_ARIAL_LEFT;
+			}
+			else
+			{
+				anim = BOTH_CARTWHEEL_LEFT;
+			}
+			checkDist = -128;
+			speed = -200;
+		}
+		else
+		{
+			if ( Q_irand( 0, 1 ) )
+			{
+				anim = BOTH_ARIAL_RIGHT;
+			}
+			else
+			{
+				anim = BOTH_CARTWHEEL_RIGHT;
+			}
+			checkDist = 128;
+			speed = 200;
+		}
+		//trace in the dir that we want to go
+		VectorMA( self->currentOrigin, checkDist, right, traceto );
+		gi.trace( &trace, self->currentOrigin, mins, maxs, traceto, self->s.number, CONTENTS_SOLID|CONTENTS_MONSTERCLIP|CONTENTS_BOTCLIP );
+		if ( trace.fraction >= 1.0f )
+		{//it's clear, let's do it
+			//FIXME: check for drops?
+			NPC_SetAnim( self, parts, anim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+			self->client->ps.weaponTime = self->client->ps.legsAnimTimer;//don't attack again until this anim is done
+			vec3_t fwdAngles, jumpRt;
+			VectorCopy( self->client->ps.viewangles, fwdAngles );
+			fwdAngles[PITCH] = fwdAngles[ROLL] = 0;
+			//do the flip
+			AngleVectors( fwdAngles, NULL, jumpRt, NULL );
+			VectorScale( jumpRt, speed, self->client->ps.velocity );
+			self->client->ps.forceJumpCharge = 0;//so we don't play the force flip anim
+			self->client->ps.velocity[2] = 200;
+			self->client->ps.forceJumpZStart = self->currentOrigin[2];//so we don't take damage if we land at same height
+			self->client->ps.pm_flags |= PMF_JUMPING;
+			if ( self->client->NPC_class == CLASS_BOBAFETT 
+				 || (self->client->NPC_class == CLASS_REBORN && self->s.weapon != WP_SABER) )
+			{
+				G_AddEvent( self, EV_JUMP, 0 );
+			}
+			else
+			{
+				G_SoundOnEnt( self, CHAN_BODY, "sound/weapons/force/jump.wav" );
+			}
+			//ucmd.upmove = 0;
+			return EVASION_CARTWHEEL;
+		}
+		else if ( !(trace.contents&CONTENTS_BOTCLIP) )
+		{//hit a wall, not a do-not-enter brush
+			//FIXME: before we check any of these jump-type evasions, we should check for headroom, right?
+			//Okay, see if we can flip *off* the wall and go the other way
+			vec3_t	idealNormal;
+			VectorSubtract( self->currentOrigin, traceto, idealNormal );
+			VectorNormalize( idealNormal );
+			gentity_t *traceEnt = &g_entities[trace.entityNum];
+			if ( (trace.entityNum<ENTITYNUM_WORLD&&traceEnt&&traceEnt->s.solid!=SOLID_BMODEL) || DotProduct( trace.plane.normal, idealNormal ) > 0.7f )
+			{//it's a ent of some sort or it's a wall roughly facing us
+				float bestCheckDist = 0;
+				//hmm, see if we're moving forward
+				if ( DotProduct( self->client->ps.velocity, fwd ) < 200 )
+				{//not running forward very fast
+					//check to see if it's okay to move the other way
+					if ( (trace.fraction*checkDist) <= 32 )
+					{//wall on that side is close enough to wall-flip off of or wall-run on
+						bestCheckDist = checkDist;
+						checkDist *= -1.0f;
+						VectorMA( self->currentOrigin, checkDist, right, traceto );
+						//trace in the dir that we want to go
+						gi.trace( &trace, self->currentOrigin, mins, maxs, traceto, self->s.number, CONTENTS_SOLID|CONTENTS_MONSTERCLIP|CONTENTS_BOTCLIP );
+						if ( trace.fraction >= 1.0f )
+						{//it's clear, let's do it
+							//FIXME: check for drops?
+							//turn the cartwheel into a wallflip in the other dir
+							if ( rightdot > 0 )
+							{
+								anim = BOTH_WALL_FLIP_LEFT;
+								self->client->ps.velocity[0] = self->client->ps.velocity[1] = 0;
+								VectorMA( self->client->ps.velocity, 150, right, self->client->ps.velocity );
+							}
+							else
+							{
+								anim = BOTH_WALL_FLIP_RIGHT;
+								self->client->ps.velocity[0] = self->client->ps.velocity[1] = 0;
+								VectorMA( self->client->ps.velocity, -150, right, self->client->ps.velocity );
+							}
+							self->client->ps.velocity[2] = forceJumpStrength[FORCE_LEVEL_2]/2.25f;
+							//animate me
+							int parts = SETANIM_LEGS;
+							if ( !self->client->ps.weaponTime )
+							{
+								parts = SETANIM_BOTH;
+							}
+							NPC_SetAnim( self, parts, anim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+							self->client->ps.forceJumpZStart = self->currentOrigin[2];//so we don't take damage if we land at same height
+							self->client->ps.pm_flags |= (PMF_JUMPING|PMF_SLOW_MO_FALL);
+							if ( self->client->NPC_class == CLASS_BOBAFETT 
+								|| (self->client->NPC_class == CLASS_REBORN && self->s.weapon != WP_SABER))
+							{
+								G_AddEvent( self, EV_JUMP, 0 );
+							}
+							else
+							{
+								G_SoundOnEnt( self, CHAN_BODY, "sound/weapons/force/jump.wav" );
+							}
+							return EVASION_OTHER;
+						}
+						else 
+						{//boxed in on both sides
+							if ( DotProduct( self->client->ps.velocity, fwd ) < 0 )
+							{//moving backwards
+								return EVASION_NONE;
+							}
+							if ( (trace.fraction*checkDist) <= 32 && (trace.fraction*checkDist) < bestCheckDist )
+							{
+								bestCheckDist = checkDist;
+							}
+						}
+					}
+					else
+					{//too far from that wall to flip or run off it, check other side
+						checkDist *= -1.0f;
+						VectorMA( self->currentOrigin, checkDist, right, traceto );
+						//trace in the dir that we want to go
+						gi.trace( &trace, self->currentOrigin, mins, maxs, traceto, self->s.number, CONTENTS_SOLID|CONTENTS_MONSTERCLIP|CONTENTS_BOTCLIP );
+						if ( (trace.fraction*checkDist) <= 32 )
+						{//wall on this side is close enough
+							bestCheckDist = checkDist;
+						}
+						else
+						{//neither side has a wall within 32
+							return EVASION_NONE;
+						}
+					}
+				}
+				//Try wall run?
+				if ( bestCheckDist )
+				{//one of the walls was close enough to wall-run on
+					//FIXME: check for long enough wall and a drop at the end?
+					if ( bestCheckDist > 0 )
+					{//it was to the right
+						anim = BOTH_WALL_RUN_RIGHT;
+					}
+					else
+					{//it was to the left
+						anim = BOTH_WALL_RUN_LEFT;
+					}
+					self->client->ps.velocity[2] = forceJumpStrength[FORCE_LEVEL_2]/2.25f;
+					//animate me
+					int parts = SETANIM_LEGS;
+					if ( !self->client->ps.weaponTime )
+					{
+						parts = SETANIM_BOTH;
+					}
+					NPC_SetAnim( self, parts, anim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+					self->client->ps.forceJumpZStart = self->currentOrigin[2];//so we don't take damage if we land at same height
+					self->client->ps.pm_flags |= (PMF_JUMPING|PMF_SLOW_MO_FALL);
+					if ( self->client->NPC_class == CLASS_BOBAFETT 
+						|| (self->client->NPC_class == CLASS_REBORN && self->s.weapon != WP_SABER))
+					{
+						G_AddEvent( self, EV_JUMP, 0 );
+					}
+					else
+					{
+						G_SoundOnEnt( self, CHAN_BODY, "sound/weapons/force/jump.wav" );
+					}
+					return EVASION_OTHER;
+				}
+				//else check for wall in front, do backflip off wall
+			}
+		}
+	}
+	return EVASION_NONE;
+}
+
+int Jedi_ReCalcParryTime( gentity_t *self, evasionType_t evasionType )
+{
+	if ( !self->client )
+	{
+		return 0;
+	}
+	if ( !self->s.number )
+	{//player 
+		return parryDebounce[self->client->ps.forcePowerLevel[FP_SABER_DEFENSE]];
+	}
+	else if ( self->NPC )
+	{
+		/*
+		if ( !g_saberRealisticCombat->integer 
+			&& ( g_spskill->integer == 2 || (g_spskill->integer == 1 && (self->client->NPC_class == CLASS_TAVION||self->client->NPC_class == CLASS_ALORA) ) ) )
+		{
+			if ( (self->client->NPC_class == CLASS_TAVION||self->client->NPC_class == CLASS_ALORA) )
+			{
+				return 0;
+			}
+			else
+			{
+				return Q_irand( 0, 150 );
+			}
+		}
+		else
+		*/
+		{
+			int	baseTime;
+			if ( evasionType == EVASION_DODGE )
+			{
+				baseTime = self->client->ps.torsoAnimTimer;
+			}
+			else if ( evasionType == EVASION_CARTWHEEL )
+			{
+				baseTime = self->client->ps.torsoAnimTimer;
+			}
+			else if ( self->client->ps.saberInFlight )
+			{
+				baseTime = Q_irand( 1, 3 ) * 50;
+			}
+			else
+			{
+				/*
+				baseTime = 1000;
+
+				switch ( g_spskill->integer )
+				{
+				case 0:
+					baseTime = 1500;
+					break;
+				case 1:
+					baseTime = 1000;
+					break;
+				case 2:
+				default:
+					baseTime = 500;
+					break;
+				}
+				*/
+				if ( 1 )//g_saberRealisticCombat->integer )
+				{
+					baseTime = 500;
+
+					switch ( g_spskill->integer )
+					{
+					case 0:
+						baseTime = 400;//was 500
+						break;
+					case 1:
+						baseTime = 200;//was 300
+						break;
+					case 2:
+					default:
+						baseTime = 100;
+						break;
+					}
+				}
+				else
+				{
+					baseTime = 150;//500;
+
+					switch ( g_spskill->integer )
+					{
+					case 0:
+						baseTime = 200;//500;
+						break;
+					case 1:
+						baseTime = 100;//300;
+						break;
+					case 2:
+					default:
+						baseTime = 50;//100;
+						break;
+					}
+				}
+
+				if ( self->client->NPC_class == CLASS_ALORA 
+					|| self->client->NPC_class == CLASS_SHADOWTROOPER
+					|| self->client->NPC_class == CLASS_TAVION )
+				{//Tavion & Alora are faster
+					baseTime = ceil(baseTime/2.0f);
+				}
+				else if ( self->NPC->rank >= RANK_LT_JG )
+				{//fencers, bosses, shadowtroopers, luke, desann, et al use the norm
+					if ( Q_irand( 0, 2 ) )
+					{//medium speed parry
+						baseTime = baseTime;
+					}
+					else
+					{//with the occasional fast parry
+						baseTime = ceil(baseTime/2.0f);
+					}
+				}
+				else if ( self->NPC->rank == RANK_CIVILIAN )
+				{//grunts are slowest
+					baseTime = baseTime*Q_irand(1,3);
+				}
+				else if ( self->NPC->rank == RANK_CREWMAN )
+				{//acrobats aren't so bad
+					if ( evasionType == EVASION_PARRY
+						|| evasionType == EVASION_DUCK_PARRY
+						|| evasionType == EVASION_JUMP_PARRY )
+					{//slower with parries
+						baseTime = baseTime*Q_irand(1,2);
+					}
+					else
+					{//faster with acrobatics
+						//baseTime = baseTime;
+					}
+				}
+				else
+				{//force users are kinda slow
+					baseTime = baseTime*Q_irand(1,2);
+				}
+				if ( evasionType == EVASION_DUCK || evasionType == EVASION_DUCK_PARRY )
+				{
+					baseTime += 250;//300;//100;
+				}
+				else if ( evasionType == EVASION_JUMP || evasionType == EVASION_JUMP_PARRY )
+				{
+					baseTime += 400;//500;//50;
+				}
+				else if ( evasionType == EVASION_OTHER )
+				{
+					baseTime += 50;//100;
+				}
+				else if ( evasionType == EVASION_FJUMP )
+				{
+					baseTime += 300;//400;//100;
+				}
+			}
+			
+			return baseTime;
+		}
+	}
+	return 0;
+}
+
+qboolean Jedi_QuickReactions( gentity_t *self )
+{
+	if ( ( self->client->NPC_class == CLASS_JEDI && NPCInfo->rank == RANK_COMMANDER ) ||
+		self->client->NPC_class == CLASS_SHADOWTROOPER || self->client->NPC_class == CLASS_ALORA || self->client->NPC_class == CLASS_TAVION ||
+		(self->client->ps.forcePowerLevel[FP_SABER_DEFENSE]>FORCE_LEVEL_1&&g_spskill->integer>1) ||
+		(self->client->ps.forcePowerLevel[FP_SABER_DEFENSE]>FORCE_LEVEL_2&&g_spskill->integer>0) )
+	{
+		return qtrue;
+	}
+	return qfalse;
+}
+
+qboolean Jedi_SaberBusy( gentity_t *self )
+{
+	if ( self->client->ps.torsoAnimTimer > 300 
+	&& ( (PM_SaberInAttack( self->client->ps.saberMove )&&self->client->ps.saberAnimLevel==SS_STRONG) 
+		|| PM_SpinningSaberAnim( self->client->ps.torsoAnim ) 
+		|| PM_SaberInSpecialAttack( self->client->ps.torsoAnim ) 
+		//|| PM_SaberInBounce( self->client->ps.saberMove ) 
+		|| PM_SaberInBrokenParry( self->client->ps.saberMove ) 
+		//|| PM_SaberInDeflect( self->client->ps.saberMove ) 
+		|| PM_FlippingAnim( self->client->ps.torsoAnim ) 
+		|| PM_RollingAnim( self->client->ps.torsoAnim ) ) )
+	{//my saber is not in a parrying position
+		return qtrue;
+	}
+	return qfalse;
+}
+
+qboolean Jedi_InNoAIAnim( gentity_t *self )
+{
+	if ( !self || !self->client )
+	{//wtf???
+		return qtrue;
+	}
+
+	if ( NPCInfo->rank >= RANK_COMMANDER )
+	{//boss-level guys can multitask, the rest need to chill out during special moves
+		return qfalse;
+	}
+
+	if ( PM_KickingAnim( NPC->client->ps.legsAnim )
+		||PM_StabDownAnim( NPC->client->ps.legsAnim )
+		||PM_InAirKickingAnim( NPC->client->ps.legsAnim )
+		||PM_InRollIgnoreTimer( &NPC->client->ps )
+		||PM_SaberInKata((saberMoveName_t)NPC->client->ps.saberMove)
+		||PM_SuperBreakWinAnim( NPC->client->ps.torsoAnim )
+		||PM_SuperBreakLoseAnim( NPC->client->ps.torsoAnim ) )
+	{
+		return qtrue;
+	}
+
+	switch ( self->client->ps.legsAnim )
+	{
+	case BOTH_BUTTERFLY_LEFT:
+	case BOTH_BUTTERFLY_RIGHT:
+	case BOTH_BUTTERFLY_FL1:
+	case BOTH_BUTTERFLY_FR1:
+	case BOTH_FLIP_F:			
+	case BOTH_FLIP_B:			
+	case BOTH_FLIP_L:			
+	case BOTH_FLIP_R:			
+	case BOTH_DODGE_FL:			
+	case BOTH_DODGE_FR:			
+	case BOTH_DODGE_BL:			
+	case BOTH_DODGE_BR:			
+	case BOTH_DODGE_L:			
+	case BOTH_DODGE_R:			
+	case BOTH_DODGE_HOLD_FL:
+	case BOTH_DODGE_HOLD_FR:
+	case BOTH_DODGE_HOLD_BL:
+	case BOTH_DODGE_HOLD_BR:
+	case BOTH_DODGE_HOLD_L:
+	case BOTH_DODGE_HOLD_R:
+	case BOTH_FORCEWALLRUNFLIP_START:
+	case BOTH_JUMPATTACK6:
+	case BOTH_JUMPATTACK7:
+	case BOTH_JUMPFLIPSLASHDOWN1:
+	case BOTH_JUMPFLIPSTABDOWN:
+	case BOTH_FORCELEAP2_T__B_:
+	case BOTH_ROLL_STAB:
+	case BOTH_SPINATTACK6:
+	case BOTH_SPINATTACK7:
+	case BOTH_PULL_IMPALE_STAB:
+	case BOTH_PULL_IMPALE_SWING:
+	case BOTH_A6_FB:
+	case BOTH_A6_LR:
+	case BOTH_A7_HILT:
+		return qtrue;
+		break;
+	}
+	return qfalse;
+}
+
+void Jedi_CheckJumpEvasionSafety( gentity_t *self, usercmd_t *cmd, evasionType_t evasionType )
+{
+	if ( evasionType != EVASION_OTHER//not a FlipEvasion, which does it's own safety checks
+		&& NPC->client->ps.groundEntityNum != ENTITYNUM_NONE ) 
+	{//on terra firma right now
+		if ( NPC->client->ps.velocity[2] > 0 
+			|| NPC->client->ps.forceJumpCharge 
+			|| cmd->upmove > 0 )
+		{//going to jump
+			if ( !NAV_MoveDirSafe( NPC, cmd, NPC->client->ps.speed*10.0f ) )
+			{//we can't jump in the dir we're pushing in
+				//cancel the evasion
+				NPC->client->ps.velocity[2] = NPC->client->ps.forceJumpCharge = 0;
+				cmd->upmove = 0;
+				if ( d_JediAI->integer )
+				{
+					Com_Printf( S_COLOR_RED"jump not safe, cancelling!" );
+				}
+			}
+			else if ( NPC->client->ps.velocity[0] || NPC->client->ps.velocity[1] )
+			{//sliding
+				vec3_t jumpDir;
+				float jumpDist = VectorNormalize2( NPC->client->ps.velocity, jumpDir );
+				if ( !NAV_DirSafe( NPC, jumpDir, jumpDist ) )
+				{//this jump combined with our momentum would send us into a do not enter brush, so cancel it
+					//cancel the evasion
+					NPC->client->ps.velocity[2] = NPC->client->ps.forceJumpCharge = 0;
+					cmd->upmove = 0;
+					if ( d_JediAI->integer )
+					{
+						Com_Printf( S_COLOR_RED"jump not safe, cancelling!\n" );
+					}
+				}
+			}
+			if ( d_JediAI->integer )
+			{
+				Com_Printf( S_COLOR_GREEN"jump checked, is safe\n" );
+			}
+		}
+	}
+}
+/*
+-------------------------
+Jedi_SaberBlock
+
+Pick proper block anim
+
+FIXME: Based on difficulty level/enemy saber combat skill, make this decision-making more/less effective
+
+NOTE: always blocking projectiles in this func!
+
+-------------------------
+*/
+extern qboolean G_FindClosestPointOnLineSegment( const vec3_t start, const vec3_t end, const vec3_t from, vec3_t result );
+evasionType_t Jedi_SaberBlockGo( gentity_t *self, usercmd_t *cmd, vec3_t pHitloc, vec3_t phitDir, gentity_t *incoming, float dist = 0.0f )
+{
+	vec3_t hitloc, hitdir, diff, fwdangles={0,0,0}, right;
+	float rightdot;
+	float zdiff;
+	int	  duckChance = 0;
+	int	  dodgeAnim = -1;
+	qboolean	saberBusy = qfalse, evaded = qfalse;
+	evasionType_t	evasionType = EVASION_NONE;
+
+	if ( !self || !self->client )
+	{
+		return EVASION_NONE;
+	}
+
+	if ( PM_LockedAnim( self->client->ps.torsoAnim ) 
+		&& self->client->ps.torsoAnimTimer )
+	{//Never interrupt these...
+		return EVASION_NONE;
+	}
+	if ( PM_InSpecialJump( self->client->ps.legsAnim )
+		&& PM_SaberInSpecialAttack( self->client->ps.torsoAnim ) )
+	{
+		return EVASION_NONE;
+	}
+
+	if ( Jedi_InNoAIAnim( self ) )
+	{
+		return EVASION_NONE;
+	}
+
+
+	//FIXME: if we don't have our saber in hand, pick the force throw option or a jump or strafe!
+	//FIXME: reborn don't block enough anymore
+	if ( !incoming )
+	{
+		VectorCopy( pHitloc, hitloc );
+		VectorCopy( phitDir, hitdir );
+		//FIXME: maybe base this on rank some?  And/or g_spskill?
+		if ( self->client->ps.saberInFlight )
+		{//DOH!  do non-saber evasion!
+			saberBusy = qtrue;
+		}
+		/*
+		else if ( Jedi_QuickReactions( self ) )
+		{//jedi trainer and tavion are must faster at parrying and can do it whenever they like
+			//Also, on medium, all level 3 people can parry any time and on hard, all level 2 or 3 people can parry any time
+		}
+		*/
+		else
+		{
+			saberBusy = Jedi_SaberBusy( self );
+		}
+	}
+	else
+	{	
+		if ( incoming->s.weapon == WP_SABER )
+		{//flying lightsaber, face it!
+			//FIXME: for this to actually work, we'd need to call update angles too?
+			//Jedi_FaceEntity( self, incoming, qtrue );
+		}
+		VectorCopy( incoming->currentOrigin, hitloc );
+		VectorNormalize2( incoming->s.pos.trDelta, hitdir );
+	}
+
+	VectorSubtract( hitloc, self->client->renderInfo.eyePoint, diff );
+	diff[2] = 0;
+	//VectorNormalize( diff );
+	fwdangles[1] = self->client->ps.viewangles[1];
+	// Ultimately we might care if the shot was ahead or behind, but for now, just quadrant is fine.
+	AngleVectors( fwdangles, NULL, right, NULL );
+
+	rightdot = DotProduct(right, diff);// + Q_flrand(-0.10f,0.10f);
+	//totalHeight = self->client->renderInfo.eyePoint[2] - self->absmin[2];
+	zdiff = hitloc[2] - self->client->renderInfo.eyePoint[2];// + Q_irand(-6,6);
+	
+	qboolean doDodge = qfalse;
+	qboolean alwaysDodgeOrRoll = qfalse;
+	if ( self->client->NPC_class == CLASS_BOBAFETT )
+	{
+		saberBusy = qtrue;
+		doDodge = qtrue;
+		alwaysDodgeOrRoll = qtrue;
+	}
+	else
+	{
+		if ( self->client->NPC_class == CLASS_REBORN && self->s.weapon != WP_SABER )
+		{
+			saberBusy = qtrue;
+			alwaysDodgeOrRoll = qtrue;
+		}
+		//see if we can dodge if need-be
+		if ( (dist>16&&(Q_irand( 0, 2 )||saberBusy)) 
+			|| self->client->ps.saberInFlight 
+			|| !self->client->ps.SaberActive() 
+			|| (self->client->NPC_class == CLASS_REBORN && self->s.weapon != WP_SABER) )
+		{//either it will miss by a bit (and 25% chance) OR our saber is not in-hand OR saber is off
+			if ( self->NPC && (self->NPC->rank == RANK_CREWMAN || self->NPC->rank >= RANK_LT_JG) )
+			{//acrobat or fencer or above
+				if ( self->client->ps.groundEntityNum != ENTITYNUM_NONE &&//on the ground
+					!(self->client->ps.pm_flags&PMF_DUCKED)&&cmd->upmove>=0&&TIMER_Done( self, "duck" )//not ducking
+					&& !PM_InRoll( &self->client->ps )//not rolling
+					&& !PM_InKnockDown( &self->client->ps )//not knocked down
+					&& ( self->client->ps.saberInFlight ||
+						(self->client->NPC_class == CLASS_REBORN && self->s.weapon != WP_SABER) ||
+						(!PM_SaberInAttack( self->client->ps.saberMove )//not attacking
+						&& !PM_SaberInStart( self->client->ps.saberMove )//not starting an attack
+						&& !PM_SpinningSaberAnim( self->client->ps.torsoAnim )//not in a saber spin
+						&& !PM_SaberInSpecialAttack( self->client->ps.torsoAnim ))//not in a special attack
+						)
+					)
+				{//need to check all these because it overrides both torso and legs with the dodge
+					doDodge = qtrue;
+				}
+			}
+		}
+	}
+
+	qboolean doRoll = qfalse;
+	if (	( self->client->NPC_class == CLASS_BOBAFETT //boba fett
+				|| (self->client->NPC_class == CLASS_REBORN && self->s.weapon != WP_SABER) //non-saber reborn (cultist)
+			)
+			&& !Q_irand( 0, 2 ) 
+		)
+	{
+		doRoll = qtrue;
+	}
+
+	// Figure out what quadrant the block was in.
+	if ( d_JediAI->integer )
+	{
+		gi.Printf( "(%d) evading attack from height %4.2f, zdiff: %4.2f, rightdot: %4.2f\n", level.time, hitloc[2]-self->absmin[2],zdiff,rightdot);
+	}
+
+	//UL = > -1//-6
+	//UR = > -6//-9
+	//TOP = > +6//+4
+	//FIXME: take FP_SABER_DEFENSE into account here somehow?
+	if ( zdiff >= -5 )//was 0
+	{
+		if ( incoming || !saberBusy || alwaysDodgeOrRoll )
+		{
+			if ( rightdot > 12 
+				|| (rightdot > 3 && zdiff < 5) 
+				|| (!incoming&&fabs(hitdir[2])<0.25f) )//was normalized, 0.3
+			{//coming from right
+				if ( doDodge )
+				{
+					if ( doRoll )
+					{//roll!
+						TIMER_Start( self, "duck", Q_irand( 500, 1500 ) );
+						TIMER_Start( self, "strafeLeft", Q_irand( 500, 1500 ) );
+						TIMER_Set( self, "strafeRight", 0 );
+						evasionType = EVASION_DUCK;
+						evaded = qtrue;
+					}
+					else if ( Q_irand( 0, 1 ) )
+					{
+						dodgeAnim = BOTH_DODGE_FL;
+					}
+					else
+					{
+						dodgeAnim = BOTH_DODGE_BL;
+					}
+				}
+				else
+				{
+					self->client->ps.saberBlocked = BLOCKED_UPPER_RIGHT;
+					evasionType = EVASION_PARRY;
+					if ( self->client->ps.groundEntityNum != ENTITYNUM_NONE )
+					{
+						if ( zdiff > 5 )
+						{
+							TIMER_Start( self, "duck", Q_irand( 500, 1500 ) );
+							evasionType = EVASION_DUCK_PARRY;
+							evaded = qtrue;
+							if ( d_JediAI->integer )
+							{
+								gi.Printf( "duck " );
+							}
+						}
+						else
+						{
+							duckChance = 6;
+						}
+					}
+				}
+				if ( d_JediAI->integer )
+				{
+					gi.Printf( "UR block\n" );
+				}
+			}
+			else if ( rightdot < -12 
+				|| (rightdot < -3 && zdiff < 5) 
+				|| (!incoming&&fabs(hitdir[2])<0.25f) )//was normalized, -0.3
+			{//coming from left
+				if ( doDodge )
+				{
+					if ( doRoll )
+					{
+						TIMER_Start( self, "duck", Q_irand( 500, 1500 ) );
+						TIMER_Start( self, "strafeRight", Q_irand( 500, 1500 ) );
+						TIMER_Set( self, "strafeLeft", 0 );
+						evasionType = EVASION_DUCK;
+						evaded = qtrue;
+					}
+					else if ( Q_irand( 0, 1 ) )
+					{
+						dodgeAnim = BOTH_DODGE_FR;
+					}
+					else
+					{
+						dodgeAnim = BOTH_DODGE_BR;
+					}
+				}
+				else
+				{
+					self->client->ps.saberBlocked = BLOCKED_UPPER_LEFT;
+					evasionType = EVASION_PARRY;
+					if ( self->client->ps.groundEntityNum != ENTITYNUM_NONE )
+					{
+						if ( zdiff > 5 )
+						{
+							TIMER_Start( self, "duck", Q_irand( 500, 1500 ) );
+							evasionType = EVASION_DUCK_PARRY;
+							evaded = qtrue;
+							if ( d_JediAI->integer )
+							{
+								gi.Printf( "duck " );
+							}
+						}
+						else
+						{
+							duckChance = 6;
+						}
+					}
+				}
+				if ( d_JediAI->integer )
+				{
+					gi.Printf( "UL block\n" );
+				}
+			}
+			else
+			{
+				self->client->ps.saberBlocked = BLOCKED_TOP;
+				evasionType = EVASION_PARRY;
+				if ( self->client->ps.groundEntityNum != ENTITYNUM_NONE )
+				{
+					duckChance = 4;
+				}
+				if ( d_JediAI->integer )
+				{
+					gi.Printf( "TOP block\n" );
+				}
+			}
+			evaded = qtrue;
+		}
+		else
+		{
+			if ( self->client->ps.groundEntityNum != ENTITYNUM_NONE )
+			{
+				//duckChance = 2;
+				TIMER_Start( self, "duck", Q_irand( 500, 1500 ) );
+				evasionType = EVASION_DUCK;
+				evaded = qtrue;
+				if ( d_JediAI->integer )
+				{
+					gi.Printf( "duck " );
+				}
+			}
+		}
+	}
+	//LL = -22//= -18 to -39
+	//LR = -23//= -20 to -41
+	else if ( zdiff > -22 )//was-15 )
+	{
+		if ( 1 )//zdiff < -10 )
+		{//hmm, pretty low, but not low enough to use the low block, so we need to duck
+			if ( self->client->ps.groundEntityNum != ENTITYNUM_NONE )
+			{
+				//duckChance = 2;
+				TIMER_Start( self, "duck", Q_irand( 500, 1500 ) );
+				evasionType = EVASION_DUCK;
+				evaded = qtrue;
+				if ( d_JediAI->integer )
+				{
+					gi.Printf( "duck " );
+				}
+			}
+			else
+			{//in air!  Ducking does no good
+			}
+		}
+		if ( incoming || !saberBusy || alwaysDodgeOrRoll )
+		{
+			if ( rightdot > 8 || (rightdot > 3 && zdiff < -11) )//was normalized, 0.2
+			{
+				if ( doDodge )
+				{
+					if ( doRoll )
+					{//roll!
+						TIMER_Start( self, "strafeLeft", Q_irand( 500, 1500 ) );
+						TIMER_Set( self, "strafeRight", 0 );
+					}
+					else 
+					{
+						dodgeAnim = BOTH_DODGE_L;
+					}
+				}
+				else
+				{
+					self->client->ps.saberBlocked = BLOCKED_UPPER_RIGHT;
+					if ( evasionType == EVASION_DUCK )
+					{
+						evasionType = EVASION_DUCK_PARRY;
+					}
+					else
+					{
+						evasionType = EVASION_PARRY;
+					}
+				}
+				if ( d_JediAI->integer )
+				{
+					gi.Printf( "mid-UR block\n" );
+				}
+			}
+			else if ( rightdot < -8 || (rightdot < -3 && zdiff < -11) )//was normalized, -0.2
+			{
+				if ( doDodge )
+				{
+					if ( doRoll )
+					{//roll!
+						TIMER_Start( self, "strafeLeft", Q_irand( 500, 1500 ) );
+						TIMER_Set( self, "strafeRight", 0 );
+					}
+					else 
+					{
+						dodgeAnim = BOTH_DODGE_R;
+					}
+				}
+				else
+				{
+					self->client->ps.saberBlocked = BLOCKED_UPPER_LEFT;
+					if ( evasionType == EVASION_DUCK )
+					{
+						evasionType = EVASION_DUCK_PARRY;
+					}
+					else
+					{
+						evasionType = EVASION_PARRY;
+					}
+				}
+				if ( d_JediAI->integer )
+				{
+					gi.Printf( "mid-UL block\n" );
+				}
+			}
+			else
+			{
+				self->client->ps.saberBlocked = BLOCKED_TOP;
+				if ( evasionType == EVASION_DUCK )
+				{
+					evasionType = EVASION_DUCK_PARRY;
+				}
+				else
+				{
+					evasionType = EVASION_PARRY;
+				}
+				if ( d_JediAI->integer )
+				{
+					gi.Printf( "mid-TOP block\n" );
+				}
+			}
+			evaded = qtrue;
+		}
+	}
+	else
+	{
+		if ( saberBusy || (zdiff < -36 && ( zdiff < -44 || !Q_irand( 0, 2 ) ) ) )//was -30 and -40//2nd one was -46
+		{//jump!
+			if ( self->client->ps.groundEntityNum == ENTITYNUM_NONE )
+			{//already in air, duck to pull up legs
+				TIMER_Start( self, "duck", Q_irand( 500, 1500 ) );
+				evasionType = EVASION_DUCK;
+				evaded = qtrue;
+				if ( d_JediAI->integer )
+				{
+					gi.Printf( "legs up\n" );
+				}
+				if ( incoming || !saberBusy )
+				{
+					//since the jump may be cleared if not safe, set a lower block too
+					if ( rightdot >= 0 )
+					{
+						self->client->ps.saberBlocked = BLOCKED_LOWER_RIGHT;
+						evasionType = EVASION_DUCK_PARRY;
+						if ( d_JediAI->integer )
+						{
+							gi.Printf( "LR block\n" );
+						}
+					}
+					else
+					{
+						self->client->ps.saberBlocked = BLOCKED_LOWER_LEFT;
+						evasionType = EVASION_DUCK_PARRY;
+						if ( d_JediAI->integer )
+						{
+							gi.Printf( "LL block\n" );
+						}
+					}
+					evaded = qtrue;
+				}
+			}
+			else 
+			{//gotta jump!
+				if ( self->NPC && (self->NPC->rank == RANK_CREWMAN || self->NPC->rank > RANK_LT_JG ) &&
+					(!Q_irand( 0, 10 ) || (!Q_irand( 0, 2 ) && (cmd->forwardmove || cmd->rightmove))) )
+				{//superjump
+					//FIXME: check the jump, if can't, then block
+					if ( self->NPC 
+						&& !(self->NPC->scriptFlags&SCF_NO_ACROBATICS) 
+						&& self->client->ps.forceRageRecoveryTime < level.time
+						&& !(self->client->ps.forcePowersActive&(1<<FP_RAGE)) 
+						&& !PM_InKnockDown( &self->client->ps ) )
+					{
+						self->client->ps.forceJumpCharge = 320;//FIXME: calc this intelligently
+						evasionType = EVASION_FJUMP;
+						evaded = qtrue;
+						if ( d_JediAI->integer )
+						{
+							gi.Printf( "force jump + " );
+						}
+					}
+				}
+				else
+				{//normal jump
+					//FIXME: check the jump, if can't, then block
+					if ( self->NPC 
+						&& !(self->NPC->scriptFlags&SCF_NO_ACROBATICS) 
+						&& self->client->ps.forceRageRecoveryTime < level.time
+						&& !(self->client->ps.forcePowersActive&(1<<FP_RAGE)) )
+					{
+						if ( (self->client->NPC_class == CLASS_BOBAFETT 
+								|| (self->client->NPC_class == CLASS_REBORN && self->s.weapon != WP_SABER)
+							)
+							&& !Q_irand( 0, 1 ) )
+						{//flip!
+							if ( rightdot > 0 )
+							{
+								TIMER_Start( self, "strafeLeft", Q_irand( 500, 1500 ) );
+								TIMER_Set( self, "strafeRight", 0 );
+								TIMER_Set( self, "walking", 0 );
+							}
+							else
+							{
+								TIMER_Start( self, "strafeRight", Q_irand( 500, 1500 ) );
+								TIMER_Set( self, "strafeLeft", 0 );
+								TIMER_Set( self, "walking", 0 );
+							}
+						}
+						else
+						{
+							if ( self == NPC )
+							{
+								cmd->upmove = 127;
+							}
+							else
+							{
+								self->client->ps.velocity[2] = JUMP_VELOCITY;
+							}
+						}
+						evasionType = EVASION_JUMP;
+						evaded = qtrue;
+						if ( d_JediAI->integer )
+						{
+							gi.Printf( "jump + " );
+						}
+					}
+					if ( self->client->NPC_class == CLASS_ALORA 
+						|| self->client->NPC_class == CLASS_SHADOWTROOPER
+						|| self->client->NPC_class == CLASS_TAVION )
+					{
+						if ( !incoming 
+							&& self->client->ps.groundEntityNum < ENTITYNUM_NONE 
+							&& !Q_irand( 0, 2 ) )
+						{
+							if ( !PM_SaberInAttack( self->client->ps.saberMove )
+								&& !PM_SaberInStart( self->client->ps.saberMove ) 
+								&& !PM_InRoll( &self->client->ps )
+								&& !PM_InKnockDown( &self->client->ps )
+								&& !PM_SaberInSpecialAttack( self->client->ps.torsoAnim ) )
+							{//do the butterfly!
+								int butterflyAnim;
+								if ( self->client->NPC_class == CLASS_ALORA 
+									&& !Q_irand( 0, 2 ) )
+								{
+									butterflyAnim = BOTH_ALORA_SPIN;
+								}
+								else if ( Q_irand( 0, 1 ) )
+								{
+									butterflyAnim = BOTH_BUTTERFLY_LEFT;
+								}
+								else
+								{
+									butterflyAnim = BOTH_BUTTERFLY_RIGHT;
+								}
+								evasionType = EVASION_CARTWHEEL;
+								NPC_SetAnim( self, SETANIM_BOTH, butterflyAnim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+								self->client->ps.velocity[2] = 225;
+								self->client->ps.forceJumpZStart = self->currentOrigin[2];//so we don't take damage if we land at same height
+								self->client->ps.pm_flags |= PMF_JUMPING|PMF_SLOW_MO_FALL;
+								self->client->ps.SaberActivateTrail( 300 );//FIXME: reset this when done!
+								/*
+								if ( self->client->NPC_class == CLASS_BOBAFETT
+									|| (self->client->NPC_class == CLASS_REBORN && self->s.weapon != WP_SABER) )
+								{
+									G_AddEvent( self, EV_JUMP, 0 );
+								}
+								else
+								*/
+								{
+									G_SoundOnEnt( self, CHAN_BODY, "sound/weapons/force/jump.wav" );
+								}
+								cmd->upmove = 0;
+								saberBusy = qtrue;
+								evaded = qtrue;
+							}
+						}
+					}
+				}
+				if ( ((evasionType = Jedi_CheckFlipEvasions( self, rightdot, zdiff ))!=EVASION_NONE) )
+				{
+					if ( d_slowmodeath->integer > 5 && self->enemy && !self->enemy->s.number )
+					{
+						G_StartMatrixEffect( self );
+					}
+					saberBusy = qtrue;
+					evaded = qtrue;
+				}
+				else if ( incoming || !saberBusy )
+				{
+					//since the jump may be cleared if not safe, set a lower block too
+					if ( rightdot >= 0 )
+					{
+						self->client->ps.saberBlocked = BLOCKED_LOWER_RIGHT;
+						if ( evasionType == EVASION_JUMP )
+						{
+							evasionType = EVASION_JUMP_PARRY;
+						}
+						else if ( evasionType == EVASION_NONE )
+						{
+							evasionType = EVASION_PARRY;
+						}
+						if ( d_JediAI->integer )
+						{
+							gi.Printf( "LR block\n" );
+						}
+					}
+					else
+					{
+						self->client->ps.saberBlocked = BLOCKED_LOWER_LEFT;
+						if ( evasionType == EVASION_JUMP )
+						{
+							evasionType = EVASION_JUMP_PARRY;
+						}
+						else if ( evasionType == EVASION_NONE )
+						{
+							evasionType = EVASION_PARRY;
+						}
+						if ( d_JediAI->integer )
+						{
+							gi.Printf( "LL block\n" );
+						}
+					}
+					evaded = qtrue;
+				}
+			}
+		}
+		else
+		{
+			if ( incoming || !saberBusy )
+			{
+				if ( rightdot >= 0 )
+				{
+					self->client->ps.saberBlocked = BLOCKED_LOWER_RIGHT;
+					evasionType = EVASION_PARRY;
+					if ( d_JediAI->integer )
+					{
+						gi.Printf( "LR block\n" );
+					}
+				}
+				else
+				{
+					self->client->ps.saberBlocked = BLOCKED_LOWER_LEFT;
+					evasionType = EVASION_PARRY;
+					if ( d_JediAI->integer )
+					{
+						gi.Printf( "LL block\n" );
+					}
+				}
+				if ( incoming && incoming->s.weapon == WP_SABER )
+				{//thrown saber!
+					if ( self->NPC && (self->NPC->rank == RANK_CREWMAN || self->NPC->rank > RANK_LT_JG ) &&
+						(!Q_irand( 0, 10 ) || (!Q_irand( 0, 2 ) && (cmd->forwardmove || cmd->rightmove))) )
+					{//superjump
+						//FIXME: check the jump, if can't, then block
+						if ( self->NPC 
+							&& !(self->NPC->scriptFlags&SCF_NO_ACROBATICS) 
+							&& self->client->ps.forceRageRecoveryTime < level.time
+							&& !(self->client->ps.forcePowersActive&(1<<FP_RAGE)) 
+							&& !PM_InKnockDown( &self->client->ps ) )
+						{
+							self->client->ps.forceJumpCharge = 320;//FIXME: calc this intelligently
+							evasionType = EVASION_FJUMP;
+							if ( d_JediAI->integer )
+							{
+								gi.Printf( "force jump + " );
+							}
+						}
+					}
+					else
+					{//normal jump
+						//FIXME: check the jump, if can't, then block
+						if ( self->NPC 
+							&& !(self->NPC->scriptFlags&SCF_NO_ACROBATICS) 
+							&& self->client->ps.forceRageRecoveryTime < level.time
+							&& !(self->client->ps.forcePowersActive&(1<<FP_RAGE)))
+						{
+							if ( self == NPC )
+							{
+								cmd->upmove = 127;
+							}
+							else
+							{
+								self->client->ps.velocity[2] = JUMP_VELOCITY;
+							}
+							evasionType = EVASION_JUMP_PARRY;
+							if ( d_JediAI->integer )
+							{
+								gi.Printf( "jump + " );
+							}
+						}
+					}
+				}
+				evaded = qtrue;
+			}
+		}
+	}
+	if ( evasionType == EVASION_NONE )
+	{
+		return EVASION_NONE;
+	}
+//=======================================================================================
+	//see if it's okay to jump
+	Jedi_CheckJumpEvasionSafety( self, cmd, evasionType );
+//=======================================================================================
+	//stop taunting
+	TIMER_Set( self, "taunting", 0 );
+	//stop gripping
+	TIMER_Set( self, "gripping", -level.time );
+	WP_ForcePowerStop( self, FP_GRIP );
+	//stop draining
+	TIMER_Set( self, "draining", -level.time );
+	WP_ForcePowerStop( self, FP_DRAIN );
+
+	if ( dodgeAnim != -1 )
+	{//dodged
+		evasionType = EVASION_DODGE;
+		NPC_SetAnim( self, SETANIM_BOTH, dodgeAnim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+		self->client->ps.weaponTime = self->client->ps.torsoAnimTimer;
+		//force them to stop moving in this case
+		self->client->ps.pm_time = self->client->ps.torsoAnimTimer;
+		//FIXME: maybe make a sound?  Like a grunt?  EV_JUMP?
+		self->client->ps.pm_flags |= PMF_TIME_KNOCKBACK;
+		//dodged, not block
+		if ( d_slowmodeath->integer > 5 && self->enemy && !self->enemy->s.number )
+		{
+			G_StartMatrixEffect( self );
+		}
+	}
+	else
+	{
+		if ( duckChance )
+		{
+			if ( !Q_irand( 0, duckChance ) )
+			{
+				TIMER_Start( self, "duck", Q_irand( 500, 1500 ) );
+				if ( evasionType == EVASION_PARRY )
+				{
+					evasionType = EVASION_DUCK_PARRY;
+				}
+				else
+				{
+					evasionType = EVASION_DUCK;
+				}
+				/*
+				if ( d_JediAI->integer )
+				{
+					gi.Printf( "duck " );
+				}
+				*/
+			}
+		}
+
+		if ( incoming )
+		{
+			self->client->ps.saberBlocked = WP_MissileBlockForBlock( self->client->ps.saberBlocked );
+		}
+
+	}
+	//if ( self->client->ps.saberBlocked != BLOCKED_NONE )
+	{
+		int parryReCalcTime = Jedi_ReCalcParryTime( self, evasionType );
+		if ( self->client->ps.forcePowerDebounce[FP_SABER_DEFENSE] < level.time + parryReCalcTime )
+		{
+			self->client->ps.forcePowerDebounce[FP_SABER_DEFENSE] = level.time + parryReCalcTime;
+		}
+	}
+	return evasionType;
+}
+
+static evasionType_t Jedi_CheckEvadeSpecialAttacks( void )
+{ 
+	if ( !NPC
+		|| !NPC->client )
+	{
+		return EVASION_NONE;
+	}
+
+	if ( !NPC->enemy
+		|| NPC->enemy->health <= 0 
+		|| !NPC->enemy->client )
+	{//don't keep blocking him once he's dead (or if not a client)
+		return EVASION_NONE;
+	}
+
+	if ( NPC->enemy->s.number >= MAX_CLIENTS )
+	{//only do these against player
+		return EVASION_NONE;
+	}
+
+	if ( !TIMER_Done( NPC, "specialEvasion" ) )
+	{//still evading from last time
+		return EVASION_NONE;
+	}
+
+	if ( NPC->enemy->client->ps.torsoAnim == BOTH_SPINATTACK6
+		|| NPC->enemy->client->ps.torsoAnim == BOTH_SPINATTACK7 )
+	{//back away from these
+		if ( (NPCInfo->aiFlags&NPCAI_BOSS_CHARACTER)
+			|| NPC->client->NPC_class == CLASS_SHADOWTROOPER
+			|| NPC->client->NPC_class == CLASS_ALORA
+			|| Q_irand( 0, NPCInfo->rank ) > RANK_LT_JG ) 
+		{//see if we should back off
+			if ( InFront( NPC->currentOrigin, NPC->enemy->currentOrigin, NPC->enemy->currentAngles ) )
+			{//facing me
+				float minSafeDistSq = (NPC->maxs[0]*1.5f+NPC->enemy->maxs[0]*1.5f+NPC->enemy->client->ps.SaberLength()+24.0f);
+				minSafeDistSq *= minSafeDistSq; 
+				if ( DistanceSquared( NPC->currentOrigin, NPC->enemy->currentOrigin ) < minSafeDistSq )
+				{//back off!
+					Jedi_StartBackOff();
+					return EVASION_OTHER;
+				}
+			}
+		}
+	}
+	else
+	{//check some other attacks?
+		//check roll-stab
+		if ( NPC->enemy->client->ps.torsoAnim == BOTH_ROLL_STAB
+			|| (NPC->enemy->client->ps.torsoAnim == BOTH_ROLL_F && ((NPC->enemy->client->pers.lastCommand.buttons&BUTTON_ATTACK)||(NPC->enemy->client->ps.pm_flags&PMF_ATTACK_HELD)) ) )
+		{//either already in a roll-stab or may go into one
+			if ( (NPCInfo->aiFlags&NPCAI_BOSS_CHARACTER)
+				|| NPC->client->NPC_class == CLASS_SHADOWTROOPER
+				|| NPC->client->NPC_class == CLASS_ALORA
+				|| Q_irand( -3, NPCInfo->rank ) > RANK_LT_JG )
+			{//see if we should evade
+				vec3_t yawOnlyAngles = {0, NPC->enemy->currentAngles[YAW], 0 };
+				if ( InFront( NPC->currentOrigin, NPC->enemy->currentOrigin, yawOnlyAngles, 0.25f ) )
+				{//facing me
+					float minSafeDistSq = (NPC->maxs[0]*1.5f+NPC->enemy->maxs[0]*1.5f+NPC->enemy->client->ps.SaberLength()+24.0f);
+					minSafeDistSq *= minSafeDistSq;
+					float distSq = DistanceSquared( NPC->currentOrigin, NPC->enemy->currentOrigin );
+					if ( distSq < minSafeDistSq )
+					{//evade!
+						qboolean doJump = ( NPC->enemy->client->ps.torsoAnim == BOTH_ROLL_STAB || distSq < 3000.0f );//not much time left, just jump!
+						if ( (NPCInfo->scriptFlags&SCF_NO_ACROBATICS)
+							|| !doJump )
+						{//roll?
+							vec3_t enemyRight, dir2Me;
+
+							AngleVectors( yawOnlyAngles, NULL, enemyRight, NULL );
+							VectorSubtract( NPC->currentOrigin, NPC->enemy->currentOrigin, dir2Me );
+							VectorNormalize( dir2Me );
+							float dot = DotProduct( enemyRight, dir2Me );
+
+							ucmd.forwardmove = 0;
+							TIMER_Start( NPC, "duck", Q_irand( 500, 1500 ) );
+							ucmd.upmove = -127;
+							//NOTE: this *assumes* I'm facing him!
+							if ( dot > 0 )
+							{//I'm to his right
+								if ( !NPC_MoveDirClear( 0, -127, qfalse  ) )
+								{//fuck, jump instead
+									doJump = qtrue;
+								}
+								else
+								{
+									TIMER_Start( NPC, "strafeLeft", Q_irand( 500, 1500 ) );
+									TIMER_Set( NPC, "strafeRight", 0 );
+									ucmd.rightmove = -127;
+									if ( d_JediAI->integer )
+									{
+										Com_Printf( "%s rolling left from roll-stab!\n", NPC->NPC_type );
+									}
+									if ( NPC->client->ps.groundEntityNum != ENTITYNUM_NONE )
+									{//fuck it, just force it
+										NPC_SetAnim(NPC,SETANIM_BOTH,BOTH_ROLL_L,SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD);
+										G_AddEvent( NPC, EV_ROLL, 0 );
+										NPC->client->ps.saberMove = LS_NONE;
+									}
+								}
+							}
+							else
+							{//I'm to his left
+								if ( !NPC_MoveDirClear( 0, 127, qfalse  ) )
+								{//fuck, jump instead
+									doJump = qtrue;
+								}
+								else
+								{
+									TIMER_Start( NPC, "strafeRight", Q_irand( 500, 1500 ) );
+									TIMER_Set( NPC, "strafeLeft", 0 );
+									ucmd.rightmove = 127;
+									if ( d_JediAI->integer )
+									{
+										Com_Printf( "%s rolling right from roll-stab!\n", NPC->NPC_type );
+									}
+									if ( NPC->client->ps.groundEntityNum != ENTITYNUM_NONE )
+									{//fuck it, just force it
+										NPC_SetAnim(NPC,SETANIM_BOTH,BOTH_ROLL_R,SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD);
+										G_AddEvent( NPC, EV_ROLL, 0 );
+										NPC->client->ps.saberMove = LS_NONE;
+									}
+								}
+							}
+							if ( !doJump )
+							{
+								TIMER_Set( NPC, "specialEvasion", 3000 );
+								return EVASION_DUCK;
+							}
+						}
+						//didn't roll, do jump
+						if ( NPC->s.weapon != WP_SABER
+							|| (NPCInfo->aiFlags&NPCAI_BOSS_CHARACTER)
+							|| NPC->client->NPC_class == CLASS_SHADOWTROOPER
+							|| NPC->client->NPC_class == CLASS_ALORA
+							|| Q_irand( -3, NPCInfo->rank ) > RANK_CREWMAN )
+						{//superjump
+							NPC->client->ps.forceJumpCharge = 320;//FIXME: calc this intelligently
+							if ( Q_irand( 0, 2 ) )
+							{//make it a backflip
+								ucmd.forwardmove = -127;
+								TIMER_Set( NPC, "roamTime", -level.time );
+								TIMER_Set( NPC, "strafeLeft", -level.time );
+								TIMER_Set( NPC, "strafeRight", -level.time );
+								TIMER_Set( NPC, "walking", -level.time );
+								TIMER_Set( NPC, "moveforward", -level.time );
+								TIMER_Set( NPC, "movenone", -level.time );
+								TIMER_Set( NPC, "moveright", -level.time );
+								TIMER_Set( NPC, "moveleft", -level.time );
+								TIMER_Set( NPC, "movecenter", -level.time );
+								TIMER_Set( NPC, "moveback", Q_irand( 500, 1000 ) );
+								if ( d_JediAI->integer )
+								{
+									Com_Printf( "%s backflipping from roll-stab!\n", NPC->NPC_type );
+								}
+							}
+							else
+							{
+								if ( d_JediAI->integer )
+								{
+									Com_Printf( "%s force-jumping over roll-stab!\n", NPC->NPC_type );
+								}
+							}
+							TIMER_Set( NPC, "specialEvasion", 3000 );
+							return EVASION_FJUMP;
+						}
+						else
+						{//normal jump
+							ucmd.upmove = 127;
+							if ( d_JediAI->integer )
+							{
+								Com_Printf( "%s jumping over roll-stab!\n", NPC->NPC_type );
+							}
+							TIMER_Set( NPC, "specialEvasion", 2000 );
+							return EVASION_JUMP;
+						}
+					}
+				}
+			}
+		}
+	}
+	return EVASION_NONE;
+}
+
+extern float ShortestLineSegBewteen2LineSegs( vec3_t start1, vec3_t end1, vec3_t start2, vec3_t end2, vec3_t close_pnt1, vec3_t close_pnt2 );
+extern int WPDEBUG_SaberColor( saber_colors_t saberColor );
+static qboolean Jedi_SaberBlock( void )
+{
+	vec3_t hitloc, saberTipOld, saberTip, top, bottom, axisPoint, saberPoint, dir;//saberBase, 
+	vec3_t pointDir, baseDir, tipDir, saberHitPoint, saberMins={-4,-4,-4}, saberMaxs={4,4,4};
+	float	pointDist, baseDirPerc;
+	float	dist, bestDist = Q3_INFINITE;
+	int		saberNum = 0, bladeNum = 0;
+	int		closestSaberNum = 0, closestBladeNum = 0;
+
+	//FIXME: reborn don't block enough anymore
+	/*
+	//maybe do this on easy only... or only on grunt-level reborn
+	if ( NPC->client->ps.weaponTime )
+	{//i'm attacking right now
+		return qfalse;
+	}
+	*/
+
+	if ( !TIMER_Done( NPC, "parryReCalcTime" ) )
+	{//can't do our own re-think of which parry to use yet
+		return qfalse;
+	}
+
+	if ( NPC->client->ps.forcePowerDebounce[FP_SABER_DEFENSE] > level.time )
+	{//can't move the saber to another position yet
+		return qfalse;
+	}
+	
+	/*
+	if ( NPCInfo->rank < RANK_LT_JG && Q_irand( 0, (2 - g_spskill->integer) ) )
+	{//lower rank reborn have a random chance of not doing it at all
+		NPC->client->ps.forcePowerDebounce[FP_SABER_DEFENSE] = level.time + 300;
+		return qfalse;
+	}
+	*/
+
+	if ( NPC->enemy->health <= 0 || !NPC->enemy->client )
+	{//don't keep blocking him once he's dead (or if not a client)
+		return qfalse;
+	}
+	/*
+	//VectorMA( NPC->enemy->client->renderInfo.muzzlePoint, NPC->enemy->client->ps.saberLength, NPC->enemy->client->renderInfo.muzzleDir, saberTip );
+	//VectorMA( NPC->enemy->client->renderInfo.muzzlePointNext, NPC->enemy->client->ps.saberLength, NPC->enemy->client->renderInfo.muzzleDirNext, saberTipNext );
+	VectorMA( NPC->enemy->client->renderInfo.muzzlePointOld, NPC->enemy->client->ps.saberLength, NPC->enemy->client->renderInfo.muzzleDirOld, saberTipOld );
+	VectorMA( NPC->enemy->client->renderInfo.muzzlePoint, NPC->enemy->client->ps.saberLength, NPC->enemy->client->renderInfo.muzzleDir, saberTip );
+
+	VectorSubtract( NPC->enemy->client->renderInfo.muzzlePoint, NPC->enemy->client->renderInfo.muzzlePointOld, dir );//get the dir
+	VectorAdd( dir, NPC->enemy->client->renderInfo.muzzlePoint, saberBase );//extrapolate
+
+	VectorSubtract( saberTip, saberTipOld, dir );//get the dir
+	VectorAdd( dir, saberTip, saberTipOld );//extrapolate
+
+	VectorCopy( NPC->currentOrigin, top );
+	top[2] = NPC->absmax[2];
+	VectorCopy( NPC->currentOrigin, bottom );
+	bottom[2] = NPC->absmin[2];
+
+	float dist = ShortestLineSegBewteen2LineSegs( saberBase, saberTipOld, bottom, top, saberPoint, axisPoint );
+	if ( 0 )//dist > NPC->maxs[0]*4 )//was *3
+	{//FIXME: sometimes he reacts when you're too far away to actually hit him
+		if ( d_JediAI->integer )
+		{
+			gi.Printf( "enemy saber dist: %4.2f\n", dist );
+		}
+		TIMER_Set( NPC, "parryTime", -1 );
+		return qfalse;
+	}
+
+	//get the actual point of impact
+	trace_t	tr;
+	gi.trace( &tr, saberPoint, vec3_origin, vec3_origin, axisPoint, NPC->enemy->s.number, MASK_SHOT, G2_RETURNONHIT, 10 );
+	if ( tr.allsolid || tr.startsolid )
+	{//estimate
+		VectorSubtract( saberPoint, axisPoint, dir );
+		VectorNormalize( dir );
+		VectorMA( axisPoint, NPC->maxs[0]*1.22, dir, hitloc );
+	}
+	else
+	{
+		VectorCopy( tr.endpos, hitloc );
+	}
+	*/
+	
+	//FIXME: need to check against both sabers/blades now!...?
+
+	for ( saberNum = 0; saberNum < MAX_SABERS; saberNum++ )
+	{
+		for ( bladeNum = 0; bladeNum < NPC->enemy->client->ps.saber[saberNum].numBlades; bladeNum++ )
+		{
+			if ( NPC->enemy->client->ps.saber[saberNum].type != SABER_NONE
+				&& NPC->enemy->client->ps.saber[saberNum].blade[bladeNum].length > 0 )
+			{//valid saber and this blade is on
+				VectorMA( NPC->enemy->client->ps.saber[saberNum].blade[bladeNum].muzzlePointOld, NPC->enemy->client->ps.saber[saberNum].blade[bladeNum].length, NPC->enemy->client->ps.saber[saberNum].blade[bladeNum].muzzleDirOld, saberTipOld );
+				VectorMA( NPC->enemy->client->ps.saber[saberNum].blade[bladeNum].muzzlePoint, NPC->enemy->client->ps.saber[saberNum].blade[bladeNum].length, NPC->enemy->client->ps.saber[saberNum].blade[bladeNum].muzzleDir, saberTip );
+
+				VectorCopy( NPC->currentOrigin, top );
+				top[2] = NPC->absmax[2];
+				VectorCopy( NPC->currentOrigin, bottom );
+				bottom[2] = NPC->absmin[2];
+
+				dist = ShortestLineSegBewteen2LineSegs( NPC->enemy->client->ps.saber[saberNum].blade[bladeNum].muzzlePoint, saberTip, bottom, top, saberPoint, axisPoint );
+				if ( dist < bestDist )
+				{
+					bestDist = dist;
+					closestSaberNum = saberNum;
+					closestBladeNum = bladeNum;
+				}
+			}
+		}
+	}
+
+	if ( bestDist > NPC->maxs[0]*5 )//was *3
+	{//FIXME: sometimes he reacts when you're too far away to actually hit him
+		if ( d_JediAI->integer )
+		{
+			Com_Printf( S_COLOR_RED"enemy saber dist: %4.2f\n", bestDist );
+		}
+		/*
+		if ( bestDist < 300 //close
+			&& !Jedi_QuickReactions( NPC )//quick reaction people can interrupt themselves
+			&& (PM_SaberInStart( NPC->enemy->client->ps.saberMove ) || BG_SaberInAttack( NPC->enemy->client->ps.saberMove )) )//enemy is swinging at me
+		{//he's swinging at me and close enough to be a threat, don't start an attack right now
+			TIMER_Set( NPC, "parryTime", 100 );
+		}
+		else
+		*/
+		{
+			TIMER_Set( NPC, "parryTime", -1 );
+		}
+		return qfalse;
+	}
+
+	dist = bestDist;
+	
+	if ( d_JediAI->integer )
+	{
+		Com_Printf( S_COLOR_GREEN"enemy saber dist: %4.2f\n", dist );
+	}
+	
+	//now use the closest blade for my evasion check
+	VectorMA( NPC->enemy->client->ps.saber[closestSaberNum].blade[closestBladeNum].muzzlePointOld, NPC->enemy->client->ps.saber[closestSaberNum].blade[closestBladeNum].length, NPC->enemy->client->ps.saber[closestSaberNum].blade[closestBladeNum].muzzleDirOld, saberTipOld );
+	VectorMA( NPC->enemy->client->ps.saber[closestSaberNum].blade[closestBladeNum].muzzlePoint, NPC->enemy->client->ps.saber[closestSaberNum].blade[closestBladeNum].length, NPC->enemy->client->ps.saber[closestSaberNum].blade[closestBladeNum].muzzleDir, saberTip );
+
+	VectorCopy( NPC->currentOrigin, top );
+	top[2] = NPC->absmax[2];
+	VectorCopy( NPC->currentOrigin, bottom );
+	bottom[2] = NPC->absmin[2];
+
+	dist = ShortestLineSegBewteen2LineSegs( NPC->enemy->client->ps.saber[closestSaberNum].blade[closestBladeNum].muzzlePoint, saberTip, bottom, top, saberPoint, axisPoint );
+	VectorSubtract( saberPoint, NPC->enemy->client->ps.saber[closestSaberNum].blade[closestBladeNum].muzzlePoint, pointDir );
+	pointDist = VectorLength( pointDir );
+	
+	if ( NPC->enemy->client->ps.saber[closestSaberNum].blade[closestBladeNum].length <= 0 )
+	{
+		baseDirPerc = 0.5f;
+	}
+	else
+	{
+		baseDirPerc = pointDist/NPC->enemy->client->ps.saber[closestSaberNum].blade[closestBladeNum].length;
+	}
+	VectorSubtract( NPC->enemy->client->ps.saber[closestSaberNum].blade[closestBladeNum].muzzlePoint, NPC->enemy->client->ps.saber[closestSaberNum].blade[closestBladeNum].muzzlePointOld, baseDir );
+	VectorSubtract( saberTip, saberTipOld, tipDir );
+	VectorScale( baseDir, baseDirPerc, baseDir );
+	VectorMA( baseDir, 1.0f-baseDirPerc, tipDir, dir );
+	VectorMA( saberPoint, 200, dir, hitloc );
+
+	//get the actual point of impact
+	trace_t	tr;
+	gi.trace( &tr, saberPoint, saberMins, saberMaxs, hitloc, NPC->enemy->s.number, CONTENTS_BODY );//, G2_RETURNONHIT, 10 );
+	if ( tr.allsolid || tr.startsolid || tr.fraction >= 1.0f )
+	{//estimate
+		vec3_t	dir2Me;
+		VectorSubtract( axisPoint, saberPoint, dir2Me );
+		dist = VectorNormalize( dir2Me );
+		if ( DotProduct( dir, dir2Me ) < 0.2f )
+		{//saber is not swinging in my direction
+			/*
+			if ( dist < 300 //close
+				&& !Jedi_QuickReactions( NPC )//quick reaction people can interrupt themselves
+				&& (PM_SaberInStart( NPC->enemy->client->ps.saberMove ) || PM_SaberInAttack( NPC->enemy->client->ps.saberMove )) )//enemy is swinging at me
+			{//he's swinging at me and close enough to be a threat, don't start an attack right now
+				TIMER_Set( NPC, "parryTime", 100 );
+			}
+			else
+			*/
+			{
+				TIMER_Set( NPC, "parryTime", -1 );
+			}
+			return qfalse;
+		}
+		ShortestLineSegBewteen2LineSegs( saberPoint, hitloc, bottom, top, saberHitPoint, hitloc );
+		/*
+		VectorSubtract( saberPoint, axisPoint, dir );
+		VectorNormalize( dir );
+		VectorMA( axisPoint, NPC->maxs[0]*1.22, dir, hitloc );
+		*/
+	}
+	else
+	{
+		VectorCopy( tr.endpos, hitloc );
+	}
+	
+	if ( d_JediAI->integer )
+	{
+		G_DebugLine( saberPoint, hitloc, FRAMETIME, WPDEBUG_SaberColor( NPC->enemy->client->ps.saber[closestSaberNum].blade[closestBladeNum].color ), qtrue );
+	}
+
+	//FIXME: if saber is off and/or we have force speed and want to be really cocky, 
+	//		and the swing misses by some amount, we can use the dodges here... :)
+	evasionType_t	evasionType;
+	if ( (evasionType=Jedi_SaberBlockGo( NPC, &ucmd, hitloc, dir, NULL, dist )) != EVASION_NONE )
+	{//did some sort of evasion
+		if ( evasionType != EVASION_DODGE )
+		{//(not dodge)
+			if ( !NPC->client->ps.saberInFlight )
+			{//make sure saber is on
+				NPC->client->ps.SaberActivate();
+			}
+
+			//debounce our parry recalc time
+			int parryReCalcTime = Jedi_ReCalcParryTime( NPC, evasionType );
+			TIMER_Set( NPC, "parryReCalcTime", Q_irand( 0, parryReCalcTime ) );
+			if ( d_JediAI->integer )
+			{
+				gi.Printf( "Keep parry choice until: %d\n", level.time + parryReCalcTime );
+			}
+
+			//determine how long to hold this anim
+			if ( TIMER_Done( NPC, "parryTime" ) )
+			{
+				if ( NPC->client->NPC_class == CLASS_TAVION 
+					|| NPC->client->NPC_class == CLASS_SHADOWTROOPER
+					|| NPC->client->NPC_class == CLASS_ALORA )
+				{
+					TIMER_Set( NPC, "parryTime", Q_irand( parryReCalcTime/2, parryReCalcTime*1.5 ) );
+				}
+				else if ( NPCInfo->rank >= RANK_LT_JG )
+				{//fencers and higher hold a parry less
+					TIMER_Set( NPC, "parryTime", parryReCalcTime );
+				}
+				else
+				{//others hold it longer
+					TIMER_Set( NPC, "parryTime", Q_irand( 1, 2 )*parryReCalcTime );
+				}
+			}
+		}
+		else
+		{//dodged
+			int dodgeTime = NPC->client->ps.torsoAnimTimer;
+			if ( NPCInfo->rank > RANK_LT_COMM && NPC->client->NPC_class != CLASS_DESANN )
+			{//higher-level guys can dodge faster
+				dodgeTime -= 200;
+			}
+			TIMER_Set( NPC, "parryReCalcTime", dodgeTime );
+			TIMER_Set( NPC, "parryTime", dodgeTime );
+		}
+	}
+	if ( evasionType != EVASION_DUCK_PARRY
+		&& evasionType != EVASION_JUMP_PARRY
+		&& evasionType != EVASION_JUMP
+		&& evasionType != EVASION_DUCK
+		&& evasionType != EVASION_FJUMP )
+	{
+		if ( Jedi_CheckEvadeSpecialAttacks() != EVASION_NONE )
+		{//got a new evasion!
+			//see if it's okay to jump 
+			Jedi_CheckJumpEvasionSafety( NPC, &ucmd, evasionType );
+		}
+	}
+	return qtrue;
+}
+/*
+-------------------------
+Jedi_EvasionSaber
+
+defend if other is using saber and attacking me!
+-------------------------
+*/
+static void Jedi_EvasionSaber( vec3_t enemy_movedir, float enemy_dist, vec3_t enemy_dir )
+{
+	vec3_t	dirEnemy2Me;
+	int		evasionChance = 30;//only step aside 30% if he's moving at me but not attacking
+	qboolean	enemy_attacking = qfalse;
+	qboolean	throwing_saber = qfalse;
+	qboolean	shooting_lightning = qfalse;
+
+	if ( !NPC->enemy->client )
+	{
+		return;
+	}
+	else if ( NPC->enemy->client 
+		&& NPC->enemy->s.weapon == WP_SABER 
+		&& NPC->enemy->client->ps.saberLockTime > level.time )
+	{//don't try to block/evade an enemy who is in a saberLock
+		return;
+	}
+	else if ( (NPC->client->ps.saberEventFlags&SEF_LOCK_WON) 
+		&& NPC->enemy->painDebounceTime > level.time )
+	{//pressing the advantage of winning a saber lock
+		return;
+	}
+
+	if ( NPC->enemy->client->ps.saberInFlight && !TIMER_Done( NPC, "taunting" ) )
+	{//if he's throwing his saber, stop taunting
+		TIMER_Set( NPC, "taunting", -level.time );
+		if ( !NPC->client->ps.saberInFlight )
+		{
+			NPC->client->ps.SaberActivate();
+		}
+	}
+
+	if ( TIMER_Done( NPC, "parryTime" ) )
+	{
+		if ( NPC->client->ps.saberBlocked != BLOCKED_ATK_BOUNCE &&
+			NPC->client->ps.saberBlocked != BLOCKED_PARRY_BROKEN )
+		{//wasn't blocked myself
+			NPC->client->ps.saberBlocked = BLOCKED_NONE;
+		}
+	}
+
+	if ( NPC->enemy->client->ps.weaponTime && NPC->enemy->client->ps.weaponstate == WEAPON_FIRING )
+	{
+		if ( (!NPC->client->ps.saberInFlight || (NPC->client->ps.dualSabers&&NPC->client->ps.saber[1].Active()) )
+			&& Jedi_SaberBlock() )
+		{
+			return;
+		}
+	}
+	else if ( Jedi_CheckEvadeSpecialAttacks() != EVASION_NONE )
+	{
+		return;
+	}
+
+
+	VectorSubtract( NPC->currentOrigin, NPC->enemy->currentOrigin, dirEnemy2Me );
+	VectorNormalize( dirEnemy2Me );
+
+	if ( NPC->enemy->client->ps.weaponTime && NPC->enemy->client->ps.weaponstate == WEAPON_FIRING )
+	{//enemy is attacking
+		enemy_attacking = qtrue;
+		evasionChance = 90;
+	}
+
+	if ( (NPC->enemy->client->ps.forcePowersActive&(1<<FP_LIGHTNING) ) )
+	{//enemy is shooting lightning
+		enemy_attacking = qtrue;
+		shooting_lightning = qtrue;
+		evasionChance = 50;
+	}
+
+	if ( NPC->enemy->client->ps.saberInFlight 
+		&& NPC->enemy->client->ps.saberEntityNum != ENTITYNUM_NONE 
+		&& NPC->enemy->client->ps.saberEntityState != SES_RETURNING )
+	{//enemy is shooting lightning
+		enemy_attacking = qtrue;
+		throwing_saber = qtrue;
+	}
+
+	//FIXME: this needs to take skill and rank(reborn type) into account much more
+	if ( Q_irand( 0, 100 ) < evasionChance )
+	{//check to see if he's coming at me
+		float facingAmt;
+		if ( VectorCompare( enemy_movedir, vec3_origin ) || shooting_lightning || throwing_saber )
+		{//he's not moving (or he's using a ranged attack), see if he's facing me
+			vec3_t	enemy_fwd;
+			AngleVectors( NPC->enemy->client->ps.viewangles, enemy_fwd, NULL, NULL );
+			facingAmt = DotProduct( enemy_fwd, dirEnemy2Me );
+		}
+		else
+		{//he's moving
+			facingAmt = DotProduct( enemy_movedir, dirEnemy2Me );
+		}
+			
+		if ( Q_flrand( 0.25, 1 ) < facingAmt )
+		{//coming at/facing me!  
+			int whichDefense = 0;
+			/*if ( NPC->client->NPC_class == CLASS_SABOTEUR )
+			{
+				int sabDef = Q_irand( 0, 3 );
+				if ( sabDef )
+				{//25% chance of trying normal jedi defense logic
+					whichDefense = 100;
+				}
+				else
+				{
+					if ( sabDef == 1 )
+					{//25% chance of strafing
+						Jedi_Strafe( 300, 1000, 0, 1000, qfalse );
+					}
+					else
+					{//50% chance of trying to dodge/roll/jump using jedi missile evasion logic
+						Jedi_SaberBlock();
+					}
+					return;
+				}
+			}
+			else */if ( NPC->client->ps.weaponTime 
+				|| NPC->client->ps.saberInFlight 
+				|| NPC->client->NPC_class == CLASS_BOBAFETT 
+				|| (NPC->client->NPC_class == CLASS_REBORN && NPC->s.weapon != WP_SABER)
+				|| NPC->client->NPC_class == CLASS_ROCKETTROOPER )
+			{//I'm attacking or recovering from a parry, can only try to strafe/jump right now
+				if ( Q_irand( 0, 10 ) < NPCInfo->stats.aggression )
+				{
+					return;
+				}
+				whichDefense = 100;
+			}
+			else
+			{
+				if ( shooting_lightning )
+				{//check for lightning attack
+					//only valid defense is strafe and/or jump
+					whichDefense = 100;
+				}
+				else if ( throwing_saber )
+				{//he's thrown his saber!  See if it's coming at me
+					float	saberDist;
+					vec3_t	saberDir2Me;
+					vec3_t	saberMoveDir;
+					gentity_t *saber = &g_entities[NPC->enemy->client->ps.saberEntityNum];
+					VectorSubtract( NPC->currentOrigin, saber->currentOrigin, saberDir2Me );
+					saberDist = VectorNormalize( saberDir2Me );
+					VectorCopy( saber->s.pos.trDelta, saberMoveDir );
+					VectorNormalize( saberMoveDir );
+					if ( !Q_irand( 0, 3 ) )
+					{
+						//Com_Printf( "(%d) raise agg - enemy threw saber\n", level.time );
+						Jedi_Aggression( NPC, 1 );
+					}
+					if ( DotProduct( saberMoveDir, saberDir2Me ) > 0.5 )
+					{//it's heading towards me
+						if ( saberDist < 100 )
+						{//it's close
+							whichDefense = Q_irand( 3, 6 );
+						}
+						else if ( saberDist < 200 )
+						{//got some time, yet, try pushing
+							whichDefense = Q_irand( 0, 8 );
+						}
+					}
+				}
+				if ( whichDefense )
+				{//already chose one
+				}
+				else if ( enemy_dist > 80 || !enemy_attacking )
+				{//he's pretty far, or not swinging, just strafe
+					if ( VectorCompare( enemy_movedir, vec3_origin ) )
+					{//if he's not moving, not swinging and far enough away, no evasion necc.
+						return;
+					}
+					if ( Q_irand( 0, 10 ) < NPCInfo->stats.aggression )
+					{
+						return;
+					}
+					whichDefense = 100;
+				}
+				else
+				{//he's getting close and swinging at me
+					vec3_t	fwd;
+					//see if I'm facing him
+					AngleVectors( NPC->client->ps.viewangles, fwd, NULL, NULL );
+					if ( DotProduct( enemy_dir, fwd ) < 0.5 )
+					{//I'm not really facing him, best option is to strafe
+						whichDefense = Q_irand( 5, 16 );
+					}
+					else if ( enemy_dist < 56 )
+					{//he's very close, maybe we should be more inclined to block or throw
+						whichDefense = Q_irand( NPCInfo->stats.aggression, 12 );
+					}
+					else
+					{
+						whichDefense = Q_irand( 2, 16 );
+					}
+				}
+			}
+
+			if ( whichDefense >= 4 && whichDefense <= 12 )
+			{//would try to block
+				if ( NPC->client->ps.saberInFlight )
+				{//can't, saber in not in hand, so fall back to strafe/jump
+					whichDefense = 100;
+				}
+			}
+
+			switch( whichDefense )
+			{
+			case 0:
+			case 1:
+			case 2:
+			case 3:
+				//use jedi force push? or kick?
+				//FIXME: try to do this if health low or enemy back to a cliff?
+				if ( Jedi_DecideKick()//let's try a kick
+					&& ( G_PickAutoMultiKick( NPC, qfalse, qtrue ) != LS_NONE 
+						|| (G_CanKickEntity(NPC, NPC->enemy )&&G_PickAutoKick( NPC, NPC->enemy, qtrue )!=LS_NONE) 
+						)
+					)
+				{//kicked
+					TIMER_Set( NPC, "kickDebounce", Q_irand( 3000, 10000 ) );
+				}
+				else if ( (NPCInfo->rank == RANK_ENSIGN || NPCInfo->rank > RANK_LT_JG) && TIMER_Done( NPC, "parryTime" ) )
+				{//FIXME: check forcePushRadius[NPC->client->ps.forcePowerLevel[FP_PUSH]]
+					ForceThrow( NPC, qfalse );
+				}
+				break;
+			case 4:
+			case 5:
+			case 6:
+			case 7:
+			case 8:
+			case 9:
+			case 10:
+			case 11:
+			case 12:
+				//try to parry the blow
+				//gi.Printf( "blocking\n" );
+				Jedi_SaberBlock();
+				break;
+			default:
+				//Evade!
+				//start a strafe left/right if not already
+				if ( !Q_irand( 0, 5 ) || !Jedi_Strafe( 300, 1000, 0, 1000, qfalse ) )
+				{//certain chance they will pick an alternative evasion
+					//if couldn't strafe, try a different kind of evasion...
+					if ( Jedi_DecideKick() && G_CanKickEntity(NPC, NPC->enemy ) && G_PickAutoKick( NPC, NPC->enemy, qtrue ) != LS_NONE )
+					{//kicked!
+						TIMER_Set( NPC, "kickDebounce", Q_irand( 3000, 10000 ) );
+					}
+					else if ( shooting_lightning || throwing_saber || enemy_dist < 80 )
+					{
+						//FIXME: force-jump+forward - jump over the guy!
+						if ( shooting_lightning || (!Q_irand( 0, 2 ) && NPCInfo->stats.aggression < 4 && TIMER_Done( NPC, "parryTime" ) ) )
+						{
+							if ( (NPCInfo->rank == RANK_ENSIGN || NPCInfo->rank > RANK_LT_JG) && !shooting_lightning && Q_irand( 0, 2 ) )
+							{//FIXME: check forcePushRadius[NPC->client->ps.forcePowerLevel[FP_PUSH]]
+								ForceThrow( NPC, qfalse );
+							}
+							else if ( (NPCInfo->rank==RANK_CREWMAN||NPCInfo->rank>RANK_LT_JG) 
+								&& !(NPCInfo->scriptFlags&SCF_NO_ACROBATICS) 
+								&& NPC->client->ps.forceRageRecoveryTime < level.time
+								&& !(NPC->client->ps.forcePowersActive&(1<<FP_RAGE)) 
+								&& !PM_InKnockDown( &NPC->client->ps ) )
+							{//FIXME: make this a function call?
+								//FIXME: check for clearance, safety of landing spot?
+								NPC->client->ps.forceJumpCharge = 480;
+								//Don't jump again for another 2 to 5 seconds
+								TIMER_Set( NPC, "jumpChaseDebounce", Q_irand( 2000, 5000 ) );
+								if ( Q_irand( 0, 2 ) )
+								{
+									ucmd.forwardmove = 127;
+									VectorClear( NPC->client->ps.moveDir );
+								}
+								else
+								{
+									ucmd.forwardmove = -127;
+									VectorClear( NPC->client->ps.moveDir );
+								}
+								//FIXME: if this jump is cleared, we can't block... so pick a random lower block?
+								if ( Q_irand( 0, 1 ) )//FIXME: make intelligent
+								{
+									NPC->client->ps.saberBlocked = BLOCKED_LOWER_RIGHT;
+								}
+								else
+								{
+									NPC->client->ps.saberBlocked = BLOCKED_LOWER_LEFT;
+								}
+							}
+						}
+						else if ( enemy_attacking )
+						{
+							Jedi_SaberBlock();
+						}
+					}
+				}
+				else
+				{//strafed
+					if ( d_JediAI->integer )
+					{
+						gi.Printf( "def strafe\n" );
+					}
+					if ( !(NPCInfo->scriptFlags&SCF_NO_ACROBATICS) 
+						&& NPC->client->ps.forceRageRecoveryTime < level.time
+						&& !(NPC->client->ps.forcePowersActive&(1<<FP_RAGE)) 
+						&& (NPCInfo->rank == RANK_CREWMAN || NPCInfo->rank > RANK_LT_JG ) 
+						&& !PM_InKnockDown( &NPC->client->ps )
+						&& !Q_irand( 0, 5 ) )
+					{//FIXME: make this a function call?
+						//FIXME: check for clearance, safety of landing spot?
+						if ( NPC->client->NPC_class == CLASS_BOBAFETT 
+							|| (NPC->client->NPC_class == CLASS_REBORN && NPC->s.weapon != WP_SABER)
+							|| NPC->client->NPC_class == CLASS_ROCKETTROOPER )
+						{
+							NPC->client->ps.forceJumpCharge = 280;//FIXME: calc this intelligently?
+						}
+						else
+						{
+							NPC->client->ps.forceJumpCharge = 320;
+						}
+						//Don't jump again for another 2 to 5 seconds
+						TIMER_Set( NPC, "jumpChaseDebounce", Q_irand( 2000, 5000 ) );
+					}
+				}
+				break;
+			}
+		
+			//turn off slow walking no matter what
+			TIMER_Set( NPC, "walking", -level.time );
+			TIMER_Set( NPC, "taunting", -level.time );
+		}
+	}
+}
+/*
+-------------------------
+Jedi_Flee
+-------------------------
+*/
+/*
+
+static qboolean Jedi_Flee( void )
+{
+	return qfalse;
+}
+*/
+
+
+/*
+==========================================================================================
+INTERNAL AI ROUTINES
+==========================================================================================
+*/
+gentity_t *Jedi_FindEnemyInCone( gentity_t *self, gentity_t *fallback, float minDot )
+{
+	vec3_t forward, mins, maxs, dir;
+	float	dist, bestDist = Q3_INFINITE;
+	gentity_t	*enemy = fallback;
+	gentity_t	*check = NULL;
+	gentity_t	*entityList[MAX_GENTITIES];
+	int			e, numListedEntities;
+	trace_t		tr;
+
+	if ( !self->client )
+	{
+		return enemy;
+	}
+
+	AngleVectors( self->client->ps.viewangles, forward, NULL, NULL );
+
+	for ( e = 0 ; e < 3 ; e++ ) 
+	{
+		mins[e] = self->currentOrigin[e] - 1024;
+		maxs[e] = self->currentOrigin[e] + 1024;
+	}
+	numListedEntities = gi.EntitiesInBox( mins, maxs, entityList, MAX_GENTITIES );
+
+	for ( e = 0 ; e < numListedEntities ; e++ ) 
+	{
+		check = entityList[e];
+		if ( check == self )
+		{//me
+			continue;
+		}
+		if ( !(check->inuse) )
+		{//freed
+			continue;
+		}
+		if ( !check->client )
+		{//not a client - FIXME: what about turrets?
+			continue;
+		}
+		if ( check->client->playerTeam != self->client->enemyTeam )
+		{//not an enemy - FIXME: what about turrets?
+			continue;
+		}
+		if ( check->health <= 0 )
+		{//dead
+			continue;
+		}
+
+		if ( !gi.inPVS( check->currentOrigin, self->currentOrigin ) )
+		{//can't potentially see them
+			continue;
+		}
+
+		VectorSubtract( check->currentOrigin, self->currentOrigin, dir );
+		dist = VectorNormalize( dir );
+
+		if ( DotProduct( dir, forward ) < minDot )
+		{//not in front
+			continue;
+		}
+
+		//really should have a clear LOS to this thing...
+		gi.trace( &tr, self->currentOrigin, vec3_origin, vec3_origin, check->currentOrigin, self->s.number, MASK_SHOT );
+		if ( tr.fraction < 1.0f && tr.entityNum != check->s.number )
+		{//must have clear shot
+			continue;
+		}
+
+		if ( dist < bestDist )
+		{//closer than our last best one
+			dist = bestDist;
+			enemy = check;
+		}
+	}
+	return enemy;
+}
+
+static void Jedi_SetEnemyInfo( vec3_t enemy_dest, vec3_t enemy_dir, float *enemy_dist, vec3_t enemy_movedir, float *enemy_movespeed, int prediction )
+{
+	if ( !NPC || !NPC->enemy )
+	{//no valid enemy
+		return;
+	}
+	if ( !NPC->enemy->client )
+	{
+		VectorClear( enemy_movedir );
+		*enemy_movespeed = 0;
+		VectorCopy( NPC->enemy->currentOrigin, enemy_dest );
+		enemy_dest[2] += NPC->enemy->mins[2] + 24;//get it's origin to a height I can work with
+		VectorSubtract( enemy_dest, NPC->currentOrigin, enemy_dir );
+		//FIXME: enemy_dist calc needs to include all blade lengths, and include distance from hand to start of blade....
+		*enemy_dist = VectorNormalize( enemy_dir );// - (NPC->client->ps.saberLengthMax + NPC->maxs[0]*1.5 + 16);
+	}
+	else
+	{//see where enemy is headed
+		VectorCopy( NPC->enemy->client->ps.velocity, enemy_movedir );
+		*enemy_movespeed = VectorNormalize( enemy_movedir );
+		//figure out where he'll be, say, 3 frames from now
+		VectorMA( NPC->enemy->currentOrigin, *enemy_movespeed * 0.001 * prediction, enemy_movedir, enemy_dest );
+		//figure out what dir the enemy's estimated position is from me and how far from the tip of my saber he is
+		VectorSubtract( enemy_dest, NPC->currentOrigin, enemy_dir );//NPC->client->renderInfo.muzzlePoint
+		//FIXME: enemy_dist calc needs to include all blade lengths, and include distance from hand to start of blade....
+		*enemy_dist = VectorNormalize( enemy_dir ) - (NPC->client->ps.SaberLengthMax() + NPC->maxs[0]*1.5 + 16);
+		//FIXME: keep a group of enemies around me and use that info to make decisions...
+		//		For instance, if there are multiple enemies, evade more, push them away
+		//		and use medium attacks.  If enemies are using blasters, switch to fast.
+		//		If one jedi enemy, use strong attacks.  Use grip when fighting one or
+		//		two enemies, use lightning spread when fighting multiple enemies, etc.
+		//		Also, when kill one, check rest of group instead of walking up to victim.
+	}
+	//init this to false
+	enemy_in_striking_range = qfalse;
+	if ( *enemy_dist <= 0.0f )
+	{
+		enemy_in_striking_range = qtrue;
+	}
+	else
+	{//if he's too far away, see if he's at least facing us or coming towards us
+		if ( *enemy_dist <= 32.0f )
+		{//has to be facing us
+			vec3_t eAngles = {0,NPC->currentAngles[YAW],0};
+			if ( InFOV( NPC->currentOrigin, NPC->enemy->currentOrigin, eAngles, 30, 90 ) )
+			{//in striking range
+				enemy_in_striking_range = qtrue;
+			}
+		}
+		if ( *enemy_dist >= 64.0f )
+		{//we have to be approaching each other
+			float vDot = 1.0f;
+			if ( !VectorCompare( NPC->client->ps.velocity, vec3_origin ) )
+			{//I am moving, see if I'm moving toward the enemy
+				vec3_t	eDir;
+				VectorSubtract( NPC->enemy->currentOrigin, NPC->currentOrigin, eDir );
+				VectorNormalize( eDir );
+				vDot = DotProduct( eDir, NPC->client->ps.velocity );
+			}
+			else if ( NPC->enemy->client && !VectorCompare( NPC->enemy->client->ps.velocity, vec3_origin ) )
+			{//I'm not moving, but the enemy is, see if he's moving towards me
+				vec3_t	meDir;
+				VectorSubtract( NPC->currentOrigin, NPC->enemy->currentOrigin, meDir );
+				VectorNormalize( meDir );
+				vDot = DotProduct( meDir, NPC->enemy->client->ps.velocity );
+			}
+			else
+			{//neither of us is moving, below check will fail, so just return
+				return;
+			}
+			if ( vDot >= *enemy_dist )
+			{//moving towards each other
+				enemy_in_striking_range = qtrue;
+			}
+		}
+	}
+}
+
+void NPC_EvasionSaber( void )
+{
+	if ( ucmd.upmove <= 0//not jumping
+		&& (!ucmd.upmove || !ucmd.rightmove) )//either just ducking or just strafing (i.e.: not rolling
+	{//see if we need to avoid their saber
+		vec3_t	enemy_dir, enemy_movedir, enemy_dest;
+		float	enemy_dist, enemy_movespeed;
+		//set enemy
+		Jedi_SetEnemyInfo( enemy_dest, enemy_dir, &enemy_dist, enemy_movedir, &enemy_movespeed, 300 );
+		Jedi_EvasionSaber( enemy_movedir, enemy_dist, enemy_dir );
+	}
+}
+
+extern float WP_SpeedOfMissileForWeapon( int wp, qboolean alt_fire );
+static void Jedi_FaceEnemy( qboolean doPitch )
+{
+	vec3_t	enemy_eyes, eyes, angles;
+
+	if ( NPC == NULL )
+		return;
+
+	if ( NPC->enemy == NULL )
+		return;
+
+	if ( NPC->client->ps.forcePowersActive & (1<<FP_GRIP) &&
+		NPC->client->ps.forcePowerLevel[FP_GRIP] > FORCE_LEVEL_1 )
+	{//don't update?
+		NPCInfo->desiredPitch = NPC->client->ps.viewangles[PITCH];
+		NPCInfo->desiredYaw = NPC->client->ps.viewangles[YAW];
+		return;
+	}
+	CalcEntitySpot( NPC, SPOT_HEAD, eyes );
+
+	CalcEntitySpot( NPC->enemy, SPOT_HEAD, enemy_eyes );
+
+	if ( NPC->client->NPC_class == CLASS_BOBAFETT 
+		&& TIMER_Done( NPC, "flameTime" )
+		&& NPC->s.weapon != WP_NONE
+		&& NPC->s.weapon != WP_DISRUPTOR
+		&& (NPC->s.weapon != WP_ROCKET_LAUNCHER||!(NPCInfo->scriptFlags&SCF_ALT_FIRE))
+		&& NPC->s.weapon != WP_THERMAL
+		&& NPC->s.weapon != WP_TRIP_MINE
+		&& NPC->s.weapon != WP_DET_PACK
+		&& NPC->s.weapon != WP_STUN_BATON
+		&& NPC->s.weapon != WP_MELEE )
+	{//boba leads his enemy
+		if ( NPC->health < NPC->max_health*0.5f )
+		{//lead
+			float missileSpeed = WP_SpeedOfMissileForWeapon( NPC->s.weapon, ((qboolean)(NPCInfo->scriptFlags&SCF_ALT_FIRE)) );
+			if ( missileSpeed )
+			{
+				float eDist = Distance( eyes, enemy_eyes );
+				eDist /= missileSpeed;//How many seconds it will take to get to the enemy
+				VectorMA( enemy_eyes, eDist*Q_flrand(0.95f,1.25f), NPC->enemy->client->ps.velocity, enemy_eyes );
+			}
+		}
+	}
+
+	//Find the desired angles
+	if ( !NPC->client->ps.saberInFlight 
+		&& (NPC->client->ps.legsAnim == BOTH_A2_STABBACK1 
+			|| NPC->client->ps.legsAnim == BOTH_CROUCHATTACKBACK1
+			|| NPC->client->ps.legsAnim == BOTH_ATTACK_BACK
+			|| NPC->client->ps.legsAnim == BOTH_A7_KICK_B )
+		)
+	{//point *away*
+		GetAnglesForDirection( enemy_eyes, eyes, angles );
+	}
+	else if ( NPC->client->ps.legsAnim == BOTH_A7_KICK_R )
+	{//keep enemy to right
+	}
+	else if ( NPC->client->ps.legsAnim == BOTH_A7_KICK_L )
+	{//keep enemy to left
+	}
+	else if ( NPC->client->ps.legsAnim == BOTH_A7_KICK_RL 
+		|| NPC->client->ps.legsAnim == BOTH_A7_KICK_BF 
+		|| NPC->client->ps.legsAnim == BOTH_A7_KICK_S )
+	{//???
+	}
+	else
+	{//point towards him
+		GetAnglesForDirection( eyes, enemy_eyes, angles );
+	}
+
+	NPCInfo->desiredYaw	= AngleNormalize360( angles[YAW] );
+	/*
+	if ( NPC->client->ps.saberBlocked == BLOCKED_UPPER_LEFT )
+	{//temp hack- to make up for poor coverage on left side
+		NPCInfo->desiredYaw += 30;
+	}
+	*/
+
+	if ( doPitch )
+	{
+		NPCInfo->desiredPitch = AngleNormalize360( angles[PITCH] );
+		if ( NPC->client->ps.saberInFlight )
+		{//tilt down a little
+			NPCInfo->desiredPitch += 10;
+		}
+	}
+	//FIXME: else desiredPitch = 0?  Or keep previous?
+}
+
+static void Jedi_DebounceDirectionChanges( void )
+{
+	//FIXME: check these before making fwd/back & right/left decisions?
+	//Time-debounce changes in forward/back dir
+	if ( ucmd.forwardmove > 0 )
+	{
+		if ( !TIMER_Done( NPC, "moveback" ) || !TIMER_Done( NPC, "movenone" ) )
+		{
+			ucmd.forwardmove = 0;
+			//now we have to normalize the total movement again
+			if ( ucmd.rightmove > 0 )
+			{
+				ucmd.rightmove = 127;
+			}
+			else if ( ucmd.rightmove < 0 )
+			{
+				ucmd.rightmove = -127;
+			}
+			VectorClear( NPC->client->ps.moveDir );
+			TIMER_Set( NPC, "moveback", -level.time );
+			if ( TIMER_Done( NPC, "movenone" ) )
+			{
+				TIMER_Set( NPC, "movenone", Q_irand( 1000, 2000 ) );
+			}
+		}
+		else if ( TIMER_Done( NPC, "moveforward" ) )
+		{//FIXME: should be if it's zero?
+			if ( TIMER_Done( NPC, "lastmoveforward" ) )
+			{
+				int holdDirTime = Q_irand( 500, 2000 );
+				TIMER_Set( NPC, "moveforward", holdDirTime );
+				//so we don't keep doing this over and over again - new nav stuff makes them coast to a stop, so they could be just slowing down from the last "moveback" timer's ending...
+				TIMER_Set( NPC, "lastmoveforward", holdDirTime + Q_irand(1000,2000) );
+			}
+		}
+		else
+		{//NOTE: edge checking should stop me if this is bad... but what if it sends us colliding into the enemy?
+			//if being forced to move forward, do a full-speed moveforward
+			ucmd.forwardmove = 127;
+			VectorClear( NPC->client->ps.moveDir );
+		}
+	}
+	else if ( ucmd.forwardmove < 0 )
+	{
+		if ( !TIMER_Done( NPC, "moveforward" ) || !TIMER_Done( NPC, "movenone" ) )
+		{
+			ucmd.forwardmove = 0;
+			//now we have to normalize the total movement again
+			if ( ucmd.rightmove > 0 )
+			{
+				ucmd.rightmove = 127;
+			}
+			else if ( ucmd.rightmove < 0 )
+			{
+				ucmd.rightmove = -127;
+			}
+			VectorClear( NPC->client->ps.moveDir );
+			TIMER_Set( NPC, "moveforward", -level.time );
+			if ( TIMER_Done( NPC, "movenone" ) )
+			{
+				TIMER_Set( NPC, "movenone", Q_irand( 1000, 2000 ) );
+			}
+		}
+		else if ( TIMER_Done( NPC, "moveback" ) )
+		{//FIXME: should be if it's zero?
+			if ( TIMER_Done( NPC, "lastmoveback" ) )
+			{
+				int holdDirTime = Q_irand( 500, 2000 );
+				TIMER_Set( NPC, "moveback", holdDirTime );
+				//so we don't keep doing this over and over again - new nav stuff makes them coast to a stop, so they could be just slowing down from the last "moveback" timer's ending...
+				TIMER_Set( NPC, "lastmoveback", holdDirTime + Q_irand(1000,2000) );
+			}
+		}
+		else
+		{//NOTE: edge checking should stop me if this is bad...
+			//if being forced to move back, do a full-speed moveback
+			ucmd.forwardmove = -127;
+			VectorClear( NPC->client->ps.moveDir );
+		}
+	}
+	else if ( !TIMER_Done( NPC, "moveforward" ) )
+	{//NOTE: edge checking should stop me if this is bad... but what if it sends us colliding into the enemy?
+		ucmd.forwardmove = 127;
+		VectorClear( NPC->client->ps.moveDir );
+	}
+	else if ( !TIMER_Done( NPC, "moveback" ) )
+	{//NOTE: edge checking should stop me if this is bad...
+		ucmd.forwardmove = -127;
+		VectorClear( NPC->client->ps.moveDir );
+	}
+	//Time-debounce changes in right/left dir
+	if ( ucmd.rightmove > 0 )
+	{
+		if ( !TIMER_Done( NPC, "moveleft" ) || !TIMER_Done( NPC, "movecenter" ) )
+		{
+			ucmd.rightmove = 0;
+			//now we have to normalize the total movement again
+			if ( ucmd.forwardmove > 0 )
+			{
+				ucmd.forwardmove = 127;
+			}
+			else if ( ucmd.forwardmove < 0 )
+			{
+				ucmd.forwardmove = -127;
+			}
+			VectorClear( NPC->client->ps.moveDir );
+			TIMER_Set( NPC, "moveleft", -level.time );
+			if ( TIMER_Done( NPC, "movecenter" ) )
+			{
+				TIMER_Set( NPC, "movecenter", Q_irand( 1000, 2000 ) );
+			}
+		}
+		else if ( TIMER_Done( NPC, "moveright" ) )
+		{//FIXME: should be if it's zero?
+			if ( TIMER_Done( NPC, "lastmoveright" ) )
+			{
+				int holdDirTime = Q_irand( 250, 1500 );
+				TIMER_Set( NPC, "moveright", holdDirTime );
+				//so we don't keep doing this over and over again - new nav stuff makes them coast to a stop, so they could be just slowing down from the last "moveback" timer's ending...
+				TIMER_Set( NPC, "lastmoveright", holdDirTime + Q_irand(1000,2000) );
+			}
+		}
+		else
+		{//NOTE: edge checking should stop me if this is bad...
+			//if being forced to move back, do a full-speed moveright
+			ucmd.rightmove = 127;
+			VectorClear( NPC->client->ps.moveDir );
+		}
+	}
+	else if ( ucmd.rightmove < 0 )
+	{
+		if ( !TIMER_Done( NPC, "moveright" ) || !TIMER_Done( NPC, "movecenter" ) )
+		{
+			ucmd.rightmove = 0;
+			//now we have to normalize the total movement again
+			if ( ucmd.forwardmove > 0 )
+			{
+				ucmd.forwardmove = 127;
+			}
+			else if ( ucmd.forwardmove < 0 )
+			{
+				ucmd.forwardmove = -127;
+			}
+			VectorClear( NPC->client->ps.moveDir );
+			TIMER_Set( NPC, "moveright", -level.time );
+			if ( TIMER_Done( NPC, "movecenter" ) )
+			{
+				TIMER_Set( NPC, "movecenter", Q_irand( 1000, 2000 ) );
+			}
+		}
+		else if ( TIMER_Done( NPC, "moveleft" ) )
+		{//FIXME: should be if it's zero?
+			if ( TIMER_Done( NPC, "lastmoveleft" ) )
+			{
+				int holdDirTime = Q_irand( 250, 1500 );
+				TIMER_Set( NPC, "moveleft", holdDirTime );
+				//so we don't keep doing this over and over again - new nav stuff makes them coast to a stop, so they could be just slowing down from the last "moveback" timer's ending...
+				TIMER_Set( NPC, "lastmoveleft", holdDirTime + Q_irand(1000,2000) );
+			}
+		}
+		else
+		{//NOTE: edge checking should stop me if this is bad...
+			//if being forced to move back, do a full-speed moveleft
+			ucmd.rightmove = -127;
+			VectorClear( NPC->client->ps.moveDir );
+		}
+	}
+	else if ( !TIMER_Done( NPC, "moveright" ) )
+	{//NOTE: edge checking should stop me if this is bad... 
+		ucmd.rightmove = 127;
+		VectorClear( NPC->client->ps.moveDir );
+	}
+	else if ( !TIMER_Done( NPC, "moveleft" ) )
+	{//NOTE: edge checking should stop me if this is bad...
+		ucmd.rightmove = -127;
+		VectorClear( NPC->client->ps.moveDir );
+	}
+}
+
+static void Jedi_TimersApply( void )
+{
+	//use careful anim/slower movement if not already moving
+	if ( !ucmd.forwardmove && !TIMER_Done( NPC, "walking" ) )
+	{
+		ucmd.buttons |= (BUTTON_WALKING);
+	}
+
+	if ( !TIMER_Done( NPC, "taunting" ) )
+	{
+		ucmd.buttons |= (BUTTON_WALKING);
+	}
+
+	if ( !ucmd.rightmove )
+	{//only if not already strafing
+		//FIXME: if enemy behind me and turning to face enemy, don't strafe in that direction, too
+		if ( !TIMER_Done( NPC, "strafeLeft" ) )
+		{
+			if ( NPCInfo->desiredYaw > NPC->client->ps.viewangles[YAW] + 60 )
+			{//we want to turn left, don't apply the strafing
+			}
+			else
+			{//go ahead and strafe left
+				ucmd.rightmove = -127;
+				VectorClear( NPC->client->ps.moveDir );
+			}
+		}
+		else if ( !TIMER_Done( NPC, "strafeRight" ) )
+		{
+			if ( NPCInfo->desiredYaw < NPC->client->ps.viewangles[YAW] - 60 )
+			{//we want to turn right, don't apply the strafing
+			}
+			else
+			{//go ahead and strafe left
+				ucmd.rightmove = 127;
+				VectorClear( NPC->client->ps.moveDir );
+			}
+		}
+	}
+
+	Jedi_DebounceDirectionChanges();
+
+	if ( !TIMER_Done( NPC, "gripping" ) )
+	{//FIXME: what do we do if we ran out of power?  NPC's can't?
+		//FIXME: don't keep turning to face enemy or we'll end up spinning around
+		ucmd.buttons |= BUTTON_FORCEGRIP;
+	}
+
+	if ( !TIMER_Done( NPC, "draining" ) )
+	{//FIXME: what do we do if we ran out of power?  NPC's can't?
+		//FIXME: don't keep turning to face enemy or we'll end up spinning around
+		ucmd.buttons |= BUTTON_FORCE_DRAIN;
+	}
+
+	if ( !TIMER_Done( NPC, "holdLightning" ) )
+	{//hold down the lightning key
+		ucmd.buttons |= BUTTON_FORCE_LIGHTNING;
+	}
+}
+
+static void Jedi_CombatTimersUpdate( int enemy_dist )
+{
+	if ( Jedi_CultistDestroyer( NPC ) )
+	{
+		Jedi_Aggression( NPC, 5 );
+		return;
+	}
+//===START MISSING CODE=================================================================
+	if ( TIMER_Done( NPC, "roamTime" ) )
+	{
+		TIMER_Set( NPC, "roamTime", Q_irand( 2000, 5000 ) );
+		//okay, now mess with agression
+		if ( NPC->enemy && NPC->enemy->client )
+		{
+			switch( NPC->enemy->client->ps.weapon )
+			{
+			//FIXME: add new weapons
+			case WP_SABER:
+				//If enemy has a lightsaber, always close in
+				if ( !NPC->enemy->client->ps.SaberActive() )
+				{//fool!  Standing around unarmed, charge!
+					//Com_Printf( "(%d) raise agg - enemy saber off\n", level.time );
+					Jedi_Aggression( NPC, 2 );
+				}
+				else
+				{
+					//Com_Printf( "(%d) raise agg - enemy saber\n", level.time );
+					Jedi_Aggression( NPC, 1 );
+				}
+				break;
+			case WP_BLASTER:
+			case WP_BRYAR_PISTOL:
+			case WP_BLASTER_PISTOL:
+			case WP_DISRUPTOR:
+			case WP_BOWCASTER:
+			case WP_REPEATER:
+			case WP_DEMP2:
+			case WP_FLECHETTE:
+			case WP_ROCKET_LAUNCHER:
+			case WP_CONCUSSION:
+				//if he has a blaster, move in when:
+				//They're not shooting at me
+				if ( NPC->enemy->attackDebounceTime < level.time )
+				{//does this apply to players?
+					//Com_Printf( "(%d) raise agg - enemy not shooting ranged weap\n", level.time );
+					Jedi_Aggression( NPC, 1 );
+				}
+				//He's closer than a dist that gives us time to deflect
+				if ( enemy_dist < 256 )
+				{
+					//Com_Printf( "(%d) raise agg - enemy ranged weap- too close\n", level.time );
+					Jedi_Aggression( NPC, 1 );
+				}
+				break;
+			default:
+				break;
+			}
+		}
+	}
+
+	if ( TIMER_Done( NPC, "noStrafe" ) && TIMER_Done( NPC, "strafeLeft" ) && TIMER_Done( NPC, "strafeRight" ) )
+	{
+		//FIXME: Maybe more likely to do this if aggression higher?  Or some other stat?
+		if ( !Q_irand( 0, 4 ) )
+		{//start a strafe
+			if ( Jedi_Strafe( 1000, 3000, 0, 4000, qtrue ) )
+			{
+				if ( d_JediAI->integer )
+				{
+					gi.Printf( "off strafe\n" );
+				}
+			}
+		}
+		else
+		{//postpone any strafing for a while
+			TIMER_Set( NPC, "noStrafe", Q_irand( 1000, 3000 ) );
+		}
+	}
+//===END MISSING CODE=================================================================
+	if ( NPC->client->ps.saberEventFlags )
+	{//some kind of saber combat event is still pending
+		int newFlags = NPC->client->ps.saberEventFlags;
+		if ( NPC->client->ps.saberEventFlags&SEF_PARRIED )
+		{//parried
+			TIMER_Set( NPC, "parryTime", -1 );
+			/*
+			if ( NPCInfo->rank >= RANK_LT_JG )
+			{
+				NPC->client->ps.forcePowerDebounce[FP_SABER_DEFENSE] = level.time + 100;
+			}
+			else
+			{
+				NPC->client->ps.forcePowerDebounce[FP_SABER_DEFENSE] = level.time + 500;
+			}
+			*/
+			if ( NPC->enemy && (!NPC->enemy->client||PM_SaberInKnockaway( NPC->enemy->client->ps.saberMove )) )
+			{//advance!
+				Jedi_Aggression( NPC, 1 );//get closer
+				Jedi_AdjustSaberAnimLevel( NPC, (NPC->client->ps.saberAnimLevel-1) );//use a faster attack
+			}
+			else
+			{
+				if ( !Q_irand( 0, 1 ) )//FIXME: dependant on rank/diff?
+				{
+					//Com_Printf( "(%d) drop agg - we parried\n", level.time );
+					Jedi_Aggression( NPC, -1 );
+				}
+				if ( !Q_irand( 0, 1 ) )
+				{
+					Jedi_AdjustSaberAnimLevel( NPC, (NPC->client->ps.saberAnimLevel-1) );
+				}
+			}
+			if ( d_JediAI->integer )
+			{
+				gi.Printf( "(%d) PARRY: agg %d, no parry until %d\n", level.time, NPCInfo->stats.aggression, level.time + 100 );
+			}
+			newFlags &= ~SEF_PARRIED;
+		}
+		if ( !NPC->client->ps.weaponTime && (NPC->client->ps.saberEventFlags&SEF_HITENEMY) )//hit enemy
+		{//we hit our enemy last time we swung, drop our aggression
+			if ( !Q_irand( 0, 1 ) )//FIXME: dependant on rank/diff?
+			{
+				//Com_Printf( "(%d) drop agg - we hit enemy\n", level.time );
+				Jedi_Aggression( NPC, -1 );
+				if ( d_JediAI->integer )
+				{
+					gi.Printf( "(%d) HIT: agg %d\n", level.time, NPCInfo->stats.aggression );
+				}
+				if ( !Q_irand( 0, 3 ) 
+					&& NPCInfo->blockedSpeechDebounceTime < level.time 
+					&& jediSpeechDebounceTime[NPC->client->playerTeam] < level.time 
+					&& NPC->painDebounceTime < level.time - 1000 )
+				{
+					G_AddVoiceEvent( NPC, Q_irand( EV_GLOAT1, EV_GLOAT3 ), 3000 );
+					jediSpeechDebounceTime[NPC->client->playerTeam] = NPCInfo->blockedSpeechDebounceTime = level.time + 3000;
+				}
+			}
+			if ( !Q_irand( 0, 2 ) )
+			{
+				Jedi_AdjustSaberAnimLevel( NPC, (NPC->client->ps.saberAnimLevel+1) );
+			}
+			newFlags &= ~SEF_HITENEMY;
+		}
+		if ( (NPC->client->ps.saberEventFlags&SEF_BLOCKED) )
+		{//was blocked whilst attacking
+			if ( PM_SaberInBrokenParry( NPC->client->ps.saberMove )
+				|| NPC->client->ps.saberBlocked == BLOCKED_PARRY_BROKEN )
+			{
+				//Com_Printf( "(%d) drop agg - we were knock-blocked\n", level.time );
+				if ( NPC->client->ps.saberInFlight )
+				{//lost our saber, too!!!
+					Jedi_Aggression( NPC, -5 );//really really really should back off!!!
+				}
+				else
+				{
+					Jedi_Aggression( NPC, -2 );//really should back off!
+				}
+				Jedi_AdjustSaberAnimLevel( NPC, (NPC->client->ps.saberAnimLevel+1) );//use a stronger attack
+				if ( d_JediAI->integer )
+				{
+					gi.Printf( "(%d) KNOCK-BLOCKED: agg %d\n", level.time, NPCInfo->stats.aggression );
+				}
+			}
+			else
+			{
+				if ( !Q_irand( 0, 2 ) )//FIXME: dependant on rank/diff?
+				{
+					//Com_Printf( "(%d) drop agg - we were blocked\n", level.time );
+					Jedi_Aggression( NPC, -1 );
+					if ( d_JediAI->integer )
+					{
+						gi.Printf( "(%d) BLOCKED: agg %d\n", level.time, NPCInfo->stats.aggression );
+					}
+				}
+				if ( !Q_irand( 0, 1 ) )
+				{
+					Jedi_AdjustSaberAnimLevel( NPC, (NPC->client->ps.saberAnimLevel+1) );
+				}
+			}
+			newFlags &= ~SEF_BLOCKED;
+			//FIXME: based on the type of parry the enemy is doing and my skill,
+			//		choose an attack that is likely to get around the parry?
+			//		right now that's generic in the saber animation code, auto-picks
+			//		a next anim for me, but really should be AI-controlled.
+		}
+		if ( NPC->client->ps.saberEventFlags&SEF_DEFLECTED )
+		{//deflected a shot
+			newFlags &= ~SEF_DEFLECTED;
+			if ( !Q_irand( 0, 3 ) )
+			{
+				Jedi_AdjustSaberAnimLevel( NPC, (NPC->client->ps.saberAnimLevel-1) );
+			}
+		}
+		if ( NPC->client->ps.saberEventFlags&SEF_HITWALL )
+		{//hit a wall
+			newFlags &= ~SEF_HITWALL;
+		}
+		if ( NPC->client->ps.saberEventFlags&SEF_HITOBJECT )
+		{//hit some other damagable object
+			if ( !Q_irand( 0, 3 ) )
+			{
+				Jedi_AdjustSaberAnimLevel( NPC, (NPC->client->ps.saberAnimLevel-1) );
+			}
+			newFlags &= ~SEF_HITOBJECT;
+		}
+		NPC->client->ps.saberEventFlags = newFlags;
+	}
+}
+
+static void Jedi_CombatIdle( int enemy_dist )
+{
+	if ( !TIMER_Done( NPC, "parryTime" ) )
+	{
+		return;
+	}
+	if ( NPC->client->ps.saberInFlight )
+	{//don't do this idle stuff if throwing saber
+		return;
+	}
+	if ( NPC->client->ps.forcePowersActive&(1<<FP_RAGE) 
+		|| NPC->client->ps.forceRageRecoveryTime > level.time )
+	{//never taunt while raging or recovering from rage
+		return;
+	}
+	if ( NPC->client->ps.stats[STAT_WEAPONS]&(1<<WP_SCEPTER) )
+	{//never taunt when holding scepter
+		return;
+	}
+	if ( NPC->client->ps.saber[0].type == SABER_SITH_SWORD )
+	{//never taunt when holding sith sword
+		return;
+	}
+	//FIXME: make these distance numbers defines?
+	if ( enemy_dist >= 64 )
+	{//FIXME: only do this if standing still?
+		//based on aggression, flaunt/taunt
+		int chance = 20;
+		if ( NPC->client->NPC_class == CLASS_SHADOWTROOPER )
+		{
+			chance = 10;
+		}
+		//FIXME: possibly throw local objects at enemy?
+		if ( Q_irand( 2, chance ) < NPCInfo->stats.aggression )
+		{
+			if ( TIMER_Done( NPC, "chatter" ) )
+			{//FIXME: add more taunt behaviors
+				//FIXME: sometimes he turns it off, then turns it right back on again???
+				if ( enemy_dist > 200 
+					&& NPC->client->NPC_class != CLASS_BOBAFETT
+					&& (NPC->client->NPC_class != CLASS_REBORN || NPC->s.weapon == WP_SABER)
+					&& NPC->client->NPC_class != CLASS_ROCKETTROOPER
+					&& NPC->client->ps.SaberActive() 
+					&& !Q_irand( 0, 5 ) )
+				{//taunt even more, turn off the saber
+					//FIXME: don't do this if health low?
+					if ( NPC->client->ps.saberAnimLevel != SS_STAFF
+						&& NPC->client->ps.saberAnimLevel != SS_DUAL )
+					{//those taunts leave saber on
+						WP_DeactivateSaber( NPC );
+					}
+					//Don't attack for a bit
+					NPCInfo->stats.aggression = 3;
+					//FIXME: maybe start strafing?
+					//debounce this
+					if ( NPC->client->playerTeam != TEAM_PLAYER && !Q_irand( 0, 1 ))
+					{
+						NPC->client->ps.taunting = level.time + 100;
+						TIMER_Set( NPC, "chatter", Q_irand( 5000, 10000 ) );
+						TIMER_Set( NPC, "taunting", 5500 );
+					}
+					else
+					{
+						Jedi_BattleTaunt();
+						TIMER_Set( NPC, "taunting", Q_irand( 5000, 10000 ) );
+					}
+				}
+				else if ( Jedi_BattleTaunt() )
+				{//FIXME: pick some anims
+				}
+			}
+		}
+	}
+}
+
+extern qboolean PM_SaberInParry( int move );
+static qboolean Jedi_AttackDecide( int enemy_dist )
+{
+	if ( !TIMER_Done( NPC, "allyJediDelay" ) )
+	{
+		return qfalse;
+	}
+
+	if ( Jedi_CultistDestroyer( NPC ) )
+	{//destroyer
+		if ( enemy_dist <= 32 )
+		{//go boom!
+			//float?
+			//VectorClear( NPC->client->ps.velocity );
+			//NPC->client->ps.gravity = 0;
+			//NPC->svFlags |= SVF_CUSTOM_GRAVITY;
+			//NPC->client->moveType = MT_FLYSWIM;
+			//NPC->flags |= FL_NO_KNOCKBACK;
+			NPC->flags |= FL_GODMODE;
+			NPC->takedamage = qfalse;
+
+			NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_FORCE_RAGE, SETANIM_FLAG_HOLD|SETANIM_FLAG_OVERRIDE );
+			NPC->client->ps.forcePowersActive |= ( 1 << FP_RAGE );
+			NPC->painDebounceTime = NPC->useDebounceTime = level.time + NPC->client->ps.torsoAnimTimer;
+			return qtrue;
+		}
+		return qfalse;
+	}
+	if ( NPC->enemy->client 
+		&& NPC->enemy->s.weapon == WP_SABER 
+		&& NPC->enemy->client->ps.saberLockTime > level.time 
+		&& NPC->client->ps.saberLockTime < level.time )
+	{//enemy is in a saberLock and we are not
+		return qfalse;
+	}
+
+	if ( NPC->client->ps.saberEventFlags&SEF_LOCK_WON )
+	{//we won a saber lock, press the advantage with an attack!
+		int	chance = 0;
+		if ( (NPCInfo->aiFlags&NPCAI_BOSS_CHARACTER) )
+		{//desann and luke
+			chance = 20;
+		}
+		else if ( NPC->client->NPC_class == CLASS_TAVION 
+			|| NPC->client->NPC_class == CLASS_ALORA )
+		{//tavion
+			chance = 10;
+		}
+		else if ( NPC->client->NPC_class == CLASS_SHADOWTROOPER )
+		{//shadowtrooper
+			chance = 5;
+		}
+		else if ( NPC->client->NPC_class == CLASS_REBORN && NPCInfo->rank == RANK_LT_JG ) 
+		{//fencer
+			chance = 5;
+		}
+		else
+		{
+			chance = NPCInfo->rank;
+		}
+		if ( Q_irand( 0, 30 ) < chance )
+		{//based on skill with some randomness
+			NPC->client->ps.saberEventFlags &= ~SEF_LOCK_WON;//clear this now that we are using the opportunity
+			TIMER_Set( NPC, "noRetreat", Q_irand( 500, 2000 ) );
+			//FIXME: check enemy_dist?
+			NPC->client->ps.weaponTime = NPCInfo->shotTime = NPC->attackDebounceTime = 0;
+			//NPC->client->ps.forcePowerDebounce[FP_SABER_DEFENSE] = level.time + 500;
+			NPC->client->ps.saberBlocked = BLOCKED_NONE;
+			WeaponThink( qtrue );
+			return qtrue;
+		}
+	}
+
+	if ( NPC->client->NPC_class == CLASS_TAVION || 
+		NPC->client->NPC_class == CLASS_ALORA ||
+		NPC->client->NPC_class == CLASS_SHADOWTROOPER ||
+		( NPC->client->NPC_class == CLASS_REBORN && NPCInfo->rank == RANK_LT_JG ) ||
+		( NPC->client->NPC_class == CLASS_JEDI && NPCInfo->rank == RANK_COMMANDER ) )
+	{//tavion, fencers, jedi trainer are all good at following up a parry with an attack
+		if ( ( PM_SaberInParry( NPC->client->ps.saberMove ) || PM_SaberInKnockaway( NPC->client->ps.saberMove ) )
+			&& NPC->client->ps.saberBlocked != BLOCKED_PARRY_BROKEN )
+		{//try to attack straight from a parry
+			NPC->client->ps.weaponTime = NPCInfo->shotTime = NPC->attackDebounceTime = 0;
+			//NPC->client->ps.forcePowerDebounce[FP_SABER_DEFENSE] = level.time + 500;
+			NPC->client->ps.saberBlocked = BLOCKED_NONE;
+			Jedi_AdjustSaberAnimLevel( NPC, SS_FAST );//try to follow-up with a quick attack
+			WeaponThink( qtrue );
+			return qtrue;
+		}
+	}
+
+	//try to hit them if we can
+	if ( !enemy_in_striking_range )
+	{
+		return qfalse;
+	}
+
+	if ( !TIMER_Done( NPC, "parryTime" ) )
+	{
+		return qfalse;
+	}
+
+	if ( (NPCInfo->scriptFlags&SCF_DONT_FIRE) )
+	{//not allowed to attack
+		return qfalse;
+	}
+
+	if ( !(ucmd.buttons&BUTTON_ATTACK) 
+		&& !(ucmd.buttons&BUTTON_ALT_ATTACK) 
+		&& !(ucmd.buttons&BUTTON_FORCE_FOCUS) )
+	{//not already attacking
+		//Try to attack
+		WeaponThink( qtrue );
+	}
+	
+	//FIXME:  Maybe try to push enemy off a ledge?
+
+	//close enough to step forward
+
+	//FIXME: an attack debounce timer other than the phaser debounce time?
+	//		or base it on aggression?
+
+	if ( ucmd.buttons&BUTTON_ATTACK && !NPC_Jumping())
+	{//attacking
+		/*
+		if ( enemy_dist > 32 && NPCInfo->stats.aggression >= 4 )
+		{//move forward if we're too far away and we're chasing him
+			ucmd.forwardmove = 127;
+		}
+		else if ( enemy_dist < 0 )
+		{//move back if we're too close
+			ucmd.forwardmove = -127;
+		}
+		*/
+		//FIXME: based on the type of parry/attack the enemy is doing and my skill,
+		//		choose an attack that is likely to get around the parry?
+		//		right now that's generic in the saber animation code, auto-picks
+		//		a next anim for me, but really should be AI-controlled.
+		//FIXME: have this interact with/override above strafing code?
+		if ( !ucmd.rightmove )
+		{//not already strafing
+			if ( !Q_irand( 0, 3 ) )
+			{//25% chance of doing this
+				vec3_t  right, dir2enemy;
+
+				AngleVectors( NPC->currentAngles, NULL, right, NULL );
+				VectorSubtract( NPC->enemy->currentOrigin, NPC->currentAngles, dir2enemy );
+				if ( DotProduct( right, dir2enemy ) > 0 )
+				{//he's to my right, strafe left
+					ucmd.rightmove = -127;
+					VectorClear( NPC->client->ps.moveDir );
+				}
+				else
+				{//he's to my left, strafe right
+					ucmd.rightmove = 127;
+					VectorClear( NPC->client->ps.moveDir );
+				}
+			}
+		}
+		return qtrue;
+	}
+
+	return qfalse;
+}
+
+
+extern void G_UcmdMoveForDir( gentity_t *self, usercmd_t *cmd, vec3_t dir );
+extern qboolean PM_KickingAnim( int anim );
+static void Jedi_CheckEnemyMovement( float enemy_dist )
+{
+	if ( !NPC->enemy || !NPC->enemy->client )
+	{
+		return;
+	}
+
+	if ( !(NPCInfo->aiFlags&NPCAI_BOSS_CHARACTER) )
+	{
+		if ( PM_KickingAnim( NPC->enemy->client->ps.legsAnim )
+			&& NPC->client->ps.groundEntityNum != ENTITYNUM_NONE
+			//FIXME: I'm relatively close to him
+			&& (NPC->enemy->client->ps.legsAnim == BOTH_A7_KICK_RL
+				|| NPC->enemy->client->ps.legsAnim == BOTH_A7_KICK_BF
+				|| NPC->enemy->client->ps.legsAnim == BOTH_A7_KICK_S
+				|| (NPC->enemy->enemy && NPC->enemy->enemy == NPC))
+			)
+		{//run into the kick!
+			ucmd.forwardmove = ucmd.rightmove = ucmd.upmove = 0;
+			VectorClear( NPC->client->ps.moveDir );
+			Jedi_Advance();
+		}
+		else if ( NPC->enemy->client->ps.torsoAnim == BOTH_A7_HILT
+				&& NPC->client->ps.groundEntityNum != ENTITYNUM_NONE )
+		{//run into the hilt bash
+			//FIXME : only if in front!
+			ucmd.forwardmove = ucmd.rightmove = ucmd.upmove = 0;
+			VectorClear( NPC->client->ps.moveDir );
+			Jedi_Advance();
+		}
+		else if ( (NPC->enemy->client->ps.torsoAnim == BOTH_A6_FB
+					|| NPC->enemy->client->ps.torsoAnim == BOTH_A6_LR)
+				&& NPC->client->ps.groundEntityNum != ENTITYNUM_NONE )
+		{//run into the attack
+			//FIXME : only if on R/L or F/B?
+			ucmd.forwardmove = ucmd.rightmove = ucmd.upmove = 0;
+			VectorClear( NPC->client->ps.moveDir );
+			Jedi_Advance();
+		}
+		else if ( NPC->enemy->enemy && NPC->enemy->enemy == NPC )
+		{//enemy is mad at *me*
+			if ( NPC->enemy->client->ps.legsAnim == BOTH_JUMPFLIPSLASHDOWN1
+				|| NPC->enemy->client->ps.legsAnim == BOTH_JUMPFLIPSTABDOWN
+				|| NPC->enemy->client->ps.legsAnim == BOTH_FLIP_ATTACK7 )
+			{//enemy is flipping over me
+				if ( Q_irand( 0, NPCInfo->rank ) < RANK_LT )
+				{//be nice and stand still for him...
+					ucmd.forwardmove = ucmd.rightmove = ucmd.upmove = 0;
+					VectorClear( NPC->client->ps.moveDir );
+					NPC->client->ps.forceJumpCharge = 0;
+					TIMER_Set( NPC, "strafeLeft", -1 );
+					TIMER_Set( NPC, "strafeRight", -1 );
+					TIMER_Set( NPC, "noStrafe", Q_irand( 500, 1000 ) );
+					TIMER_Set( NPC, "movenone", Q_irand( 500, 1000 ) );
+					TIMER_Set( NPC, "movecenter", Q_irand( 500, 1000 ) );
+				}
+			}
+			else if ( NPC->enemy->client->ps.legsAnim == BOTH_WALL_FLIP_BACK1 
+				|| NPC->enemy->client->ps.legsAnim == BOTH_WALL_FLIP_RIGHT 
+				|| NPC->enemy->client->ps.legsAnim == BOTH_WALL_FLIP_LEFT 
+				|| NPC->enemy->client->ps.legsAnim == BOTH_WALL_RUN_LEFT_FLIP 
+				|| NPC->enemy->client->ps.legsAnim == BOTH_WALL_RUN_RIGHT_FLIP )
+			{//he's flipping off a wall
+				if ( NPC->enemy->client->ps.groundEntityNum == ENTITYNUM_NONE )
+				{//still in air
+					if ( enemy_dist < 256 )
+					{//close
+						if ( Q_irand( 0, NPCInfo->rank ) < RANK_LT )
+						{//be nice and stand still for him...
+							/*
+							ucmd.forwardmove = ucmd.rightmove = ucmd.upmove = 0;
+							VectorClear( NPC->client->ps.moveDir );
+							NPC->client->ps.forceJumpCharge = 0;
+							TIMER_Set( NPC, "strafeLeft", -1 );
+							TIMER_Set( NPC, "strafeRight", -1 );
+							TIMER_Set( NPC, "noStrafe", Q_irand( 500, 1000 ) );
+							TIMER_Set( NPC, "movenone", Q_irand( 500, 1000 ) );
+							TIMER_Set( NPC, "movecenter", Q_irand( 500, 1000 ) );
+							TIMER_Set( NPC, "noturn", Q_irand( 200, 500 ) );
+							*/
+							//stop current movement
+							ucmd.forwardmove = ucmd.rightmove = ucmd.upmove = 0;
+							VectorClear( NPC->client->ps.moveDir );
+							NPC->client->ps.forceJumpCharge = 0;
+							TIMER_Set( NPC, "strafeLeft", -1 );
+							TIMER_Set( NPC, "strafeRight", -1 );
+							TIMER_Set( NPC, "noStrafe", Q_irand( 500, 1000 ) );
+							TIMER_Set( NPC, "noturn", Q_irand( 250, 500 )*(3-g_spskill->integer) );
+
+							vec3_t enemyFwd, dest, dir;
+
+							VectorCopy( NPC->enemy->client->ps.velocity, enemyFwd );
+							VectorNormalize( enemyFwd );
+							VectorMA( NPC->enemy->currentOrigin, -64, enemyFwd, dest );
+							VectorSubtract( dest, NPC->currentOrigin, dir );
+							if ( VectorNormalize( dir ) > 32 )
+							{
+								G_UcmdMoveForDir( NPC, &ucmd, dir );
+							}
+							else
+							{
+								TIMER_Set( NPC, "movenone", Q_irand( 500, 1000 ) );
+								TIMER_Set( NPC, "movecenter", Q_irand( 500, 1000 ) );
+							}
+						}
+					}
+				}
+			}
+			else if ( NPC->enemy->client->ps.legsAnim == BOTH_A2_STABBACK1 )
+			{//he's stabbing backwards
+				if ( enemy_dist < 256 && enemy_dist > 64 )
+				{//close
+					if ( !InFront( NPC->currentOrigin, NPC->enemy->currentOrigin, NPC->enemy->currentAngles, 0.0f ) )
+					{//behind him
+						if ( !Q_irand( 0, NPCInfo->rank ) )
+						{//be nice and stand still for him...
+							//stop current movement
+							ucmd.forwardmove = ucmd.rightmove = ucmd.upmove = 0;
+							VectorClear( NPC->client->ps.moveDir );
+							NPC->client->ps.forceJumpCharge = 0;
+							TIMER_Set( NPC, "strafeLeft", -1 );
+							TIMER_Set( NPC, "strafeRight", -1 );
+							TIMER_Set( NPC, "noStrafe", Q_irand( 500, 1000 ) );
+
+							vec3_t enemyFwd, dest, dir;
+
+							AngleVectors( NPC->enemy->currentAngles, enemyFwd, NULL, NULL );
+							VectorMA( NPC->enemy->currentOrigin, -32, enemyFwd, dest );
+							VectorSubtract( dest, NPC->currentOrigin, dir );
+							if ( VectorNormalize( dir ) > 64 )
+							{
+								G_UcmdMoveForDir( NPC, &ucmd, dir );
+							}
+							else
+							{
+								TIMER_Set( NPC, "movenone", Q_irand( 500, 1000 ) );
+								TIMER_Set( NPC, "movecenter", Q_irand( 500, 1000 ) );
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+	//FIXME: also:
+	//		If enemy doing wall flip, keep running forward
+	//		If enemy doing back-attack and we're behind him keep running forward toward his back, don't strafe
+}
+
+static void Jedi_CheckJumps( void )
+{
+	if ( (NPCInfo->scriptFlags&SCF_NO_ACROBATICS) )
+	{
+		NPC->client->ps.forceJumpCharge = 0;
+		ucmd.upmove = 0;
+		return;
+	}
+	//FIXME: should probably check this before AI decides that best move is to jump?  Otherwise, they may end up just standing there and looking dumb
+	//FIXME: all this work and he still jumps off ledges... *sigh*... need CONTENTS_BOTCLIP do-not-enter brushes...?
+	vec3_t	jumpVel = {0,0,0};
+
+	if ( NPC->client->ps.forceJumpCharge )
+	{
+		//gi.Printf( "(%d) force jump\n", level.time );
+		WP_GetVelocityForForceJump( NPC, jumpVel, &ucmd );
+	}
+	else if ( ucmd.upmove > 0 )
+	{
+		//gi.Printf( "(%d) regular jump\n", level.time );
+		VectorCopy( NPC->client->ps.velocity, jumpVel );
+		jumpVel[2] = JUMP_VELOCITY;
+	}
+	else
+	{
+		return;
+	}
+	
+	//NOTE: for now, we clear ucmd.forwardmove & ucmd.rightmove while in air to avoid jumps going awry...
+	if ( !jumpVel[0] && !jumpVel[1] )//FIXME: && !ucmd.forwardmove && !ucmd.rightmove?
+	{//we assume a jump straight up is safe
+		//gi.Printf( "(%d) jump straight up is safe\n", level.time );
+		return;
+	}
+	//Now predict where this is going
+	//in steps, keep evaluating the trajectory until the new z pos is <= than current z pos, trace down from there
+	trace_t	trace;
+	trajectory_t	tr;
+	vec3_t	lastPos, testPos, bottom;
+	int		elapsedTime;
+
+	VectorCopy( NPC->currentOrigin, tr.trBase );
+	VectorCopy( jumpVel, tr.trDelta );
+	tr.trType = TR_GRAVITY;
+	tr.trTime = level.time;
+	VectorCopy( NPC->currentOrigin, lastPos );
+	
+	//This may be kind of wasteful, especially on long throws... use larger steps?  Divide the travelTime into a certain hard number of slices?  Trace just to apex and down?
+	for ( elapsedTime = 500; elapsedTime <= 4000; elapsedTime += 500 )
+	{
+		EvaluateTrajectory( &tr, level.time + elapsedTime, testPos );
+		//FIXME: account for PM_AirMove if ucmd.forwardmove and/or ucmd.rightmove is non-zero...
+		if ( testPos[2] < lastPos[2] )
+		{//going down, don't check for BOTCLIP
+			gi.trace( &trace, lastPos, NPC->mins, NPC->maxs, testPos, NPC->s.number, NPC->clipmask );//FIXME: include CONTENTS_BOTCLIP?
+		}
+		else
+		{//going up, check for BOTCLIP
+			gi.trace( &trace, lastPos, NPC->mins, NPC->maxs, testPos, NPC->s.number, NPC->clipmask|CONTENTS_BOTCLIP );
+		}
+		if ( trace.allsolid || trace.startsolid )
+		{//WTF?
+			//FIXME: what do we do when we start INSIDE the CONTENTS_BOTCLIP?  Do the trace again without that clipmask?
+			goto jump_unsafe;
+			return;
+		}
+		if ( trace.fraction < 1.0f )
+		{//hit something
+			if ( trace.contents & CONTENTS_BOTCLIP )
+			{//hit a do-not-enter brush
+				goto jump_unsafe;
+				return;
+			}
+			//FIXME: trace through func_glass?
+			break;
+		}
+		VectorCopy( testPos, lastPos );
+	}
+	//okay, reached end of jump, now trace down from here for a floor
+	VectorCopy( trace.endpos, bottom );
+	if ( bottom[2] > NPC->currentOrigin[2] )
+	{//only care about dist down from current height or lower
+		bottom[2] = NPC->currentOrigin[2];
+	}
+	else if ( NPC->currentOrigin[2] - bottom[2] > 400 )
+	{//whoa, long drop, don't do it!
+		//probably no floor at end of jump, so don't jump
+		goto jump_unsafe;
+		return;
+	}
+	bottom[2] -= 128;
+	gi.trace( &trace, trace.endpos, NPC->mins, NPC->maxs, bottom, NPC->s.number, NPC->clipmask );
+	if ( trace.allsolid || trace.startsolid || trace.fraction < 1.0f )
+	{//hit ground!
+		if ( trace.entityNum < ENTITYNUM_WORLD )
+		{//landed on an ent
+			gentity_t *groundEnt = &g_entities[trace.entityNum];
+			if ( groundEnt->svFlags&SVF_GLASS_BRUSH )
+			{//don't land on breakable glass!
+				goto jump_unsafe;
+				return;
+			}
+		}
+		//gi.Printf( "(%d) jump is safe\n", level.time );
+		return;
+	}
+jump_unsafe:
+	//probably no floor at end of jump, so don't jump
+	//gi.Printf( "(%d) unsafe jump cleared\n", level.time );
+	NPC->client->ps.forceJumpCharge = 0;
+	ucmd.upmove = 0;
+}
+
+extern void RT_JetPackEffect( int duration );
+void RT_CheckJump( void )
+{
+	int jumpEntNum = ENTITYNUM_NONE;
+	vec3_t	jumpPos = {0,0,0};
+
+	if ( !NPCInfo->goalEntity )
+	{
+		if ( NPC->enemy )
+		{
+			//FIXME: debounce this?
+			if ( TIMER_Done( NPC, "roamTime" ) 
+				&& Q_irand( 0, 9 ) )
+			{//okay to try to find another spot to be
+				int cpFlags = (CP_CLEAR|CP_HAS_ROUTE);//must have a clear shot at enemy
+				float enemyDistSq = DistanceHorizontalSquared( NPC->currentOrigin, NPC->enemy->currentOrigin );
+				//FIXME: base these ranges on weapon
+				if ( enemyDistSq > (2048*2048) )
+				{//hmm, close in?
+					cpFlags |= CP_APPROACH_ENEMY;
+				}
+				else if ( enemyDistSq < (256*256) )
+				{//back off!
+					cpFlags |= CP_RETREAT;
+				}
+				int sendFlags = cpFlags;
+				int cp = NPC_FindCombatPointRetry( NPC->currentOrigin, 
+											NPC->currentOrigin, 
+											NPC->currentOrigin,
+											&sendFlags, 
+											256, 
+											NPCInfo->lastFailedCombatPoint );
+				if ( cp == -1 )
+				{//try again, no route needed since we can rocket-jump to it!
+					cpFlags &= ~CP_HAS_ROUTE;
+					cp = NPC_FindCombatPointRetry( NPC->currentOrigin, 
+												NPC->currentOrigin, 
+												NPC->currentOrigin,
+												&cpFlags,
+												256, 
+												NPCInfo->lastFailedCombatPoint );
+				}
+				if ( cp != -1 )
+				{
+					NPC_SetMoveGoal( NPC, level.combatPoints[cp].origin, 8, qtrue, cp );
+				}
+				else
+				{//FIXME: okay to do this if have good close-range weapon...
+					//FIXME: should we really try to go right for him?!
+					//NPCInfo->goalEntity = NPC->enemy;
+					jumpEntNum = NPC->enemy->s.number;
+					VectorCopy( NPC->enemy->currentOrigin, jumpPos );
+					//return;
+				}
+				TIMER_Set( NPC, "roamTime", Q_irand( 3000, 12000 ) );
+			}
+			else
+			{//FIXME: okay to do this if have good close-range weapon...
+				//FIXME: should we really try to go right for him?!
+				//NPCInfo->goalEntity = NPC->enemy;
+				jumpEntNum = NPC->enemy->s.number;
+				VectorCopy( NPC->enemy->currentOrigin, jumpPos );
+				//return;
+			}
+		}
+		else
+		{
+			return;
+		}
+	}
+	else
+	{
+		jumpEntNum = NPCInfo->goalEntity->s.number;
+		VectorCopy( NPCInfo->goalEntity->currentOrigin, jumpPos );
+	}
+	vec3_t vec2Goal;
+	VectorSubtract( jumpPos, NPC->currentOrigin, vec2Goal );
+	if ( fabs( vec2Goal[2] ) < 32 )
+	{//not a big height diff, see how far it is
+		vec2Goal[2] = 0;
+		if ( VectorLengthSquared( vec2Goal ) < (256*256) )
+		{//too close!  Don't rocket-jump to it...
+			return;
+		}
+	}
+	//If we can't get straight at him
+	if ( !Jedi_ClearPathToSpot( jumpPos, jumpEntNum ) )
+	{//hunt him down
+		if ( (NPC_ClearLOS( NPC->enemy )||NPCInfo->enemyLastSeenTime>level.time-500) 
+			&& InFOV( jumpPos, NPC->currentOrigin, NPC->client->ps.viewangles, 20, 60 ) )
+		{
+			if ( NPC_TryJump( jumpPos ) )	// Rocket Trooper
+			{//just do the jetpack effect for a litte bit
+				RT_JetPackEffect( Q_irand( 800, 1500) );
+				return;
+			}
+		}
+
+		if ( Jedi_Hunt() && !(NPCInfo->aiFlags&NPCAI_BLOCKED) )//FIXME: have to do this because they can ping-pong forever
+		{//can macro-navigate to him
+			return;
+		}
+		else
+		{//FIXME: try to find a waypoint that can see enemy, jump from there
+			if ( STEER::HasBeenBlockedFor(NPC, 2000) )
+			{//try to jump to the blockedTargetPosition
+				if ( NPC_TryJump(NPCInfo->blockedTargetPosition) )	// Rocket Trooper
+				{//just do the jetpack effect for a litte bit
+					RT_JetPackEffect( Q_irand( 800, 1500) );
+				}
+			}
+		}
+	}
+}
+////////////////////////////////////////////////////////////////////////////////////////
+// 
+////////////////////////////////////////////////////////////////////////////////////////
+static void Jedi_Combat( void )
+{
+	vec3_t	enemy_dir, enemy_movedir, enemy_dest;
+	float	enemy_dist, enemy_movespeed;
+	qboolean	enemy_lost = qfalse;
+	trace_t	trace;
+
+	//See where enemy will be 300 ms from now
+	Jedi_SetEnemyInfo( enemy_dest, enemy_dir, &enemy_dist, enemy_movedir, &enemy_movespeed, 300 );
+
+	if ( NPC_Jumping( ) )
+	{//I'm in the middle of a jump, so just see if I should attack
+		Jedi_AttackDecide( enemy_dist );
+		return;
+	}
+
+	if ( TIMER_Done( NPC, "allyJediDelay" ) )
+	{
+		if ( !(NPC->client->ps.forcePowersActive&(1<<FP_GRIP)) || NPC->client->ps.forcePowerLevel[FP_GRIP] < FORCE_LEVEL_2 )
+		{//not gripping
+			//If we can't get straight at him
+			if ( !Jedi_ClearPathToSpot( enemy_dest, NPC->enemy->s.number ) )
+			{//hunt him down
+				//gi.Printf( "No Clear Path\n" );
+				if ( (NPC_ClearLOS( NPC->enemy )||NPCInfo->enemyLastSeenTime>level.time-500) && NPC_FaceEnemy( qtrue ) )//( NPCInfo->rank == RANK_CREWMAN || NPCInfo->rank > RANK_LT_JG ) && 
+				{
+					//try to jump to him?
+					/*
+					vec3_t end;
+					VectorCopy( NPC->currentOrigin, end );
+					end[2] += 36;
+					gi.trace( &trace, NPC->currentOrigin, NPC->mins, NPC->maxs, end, NPC->s.number, NPC->clipmask|CONTENTS_BOTCLIP );
+					if ( !trace.allsolid && !trace.startsolid && trace.fraction >= 1.0 )
+					{
+						vec3_t angles, forward;
+						VectorCopy( NPC->client->ps.viewangles, angles );
+						angles[0] = 0;
+						AngleVectors( angles, forward, NULL, NULL );
+						VectorMA( end, 64, forward, end );
+						gi.trace( &trace, NPC->currentOrigin, NPC->mins, NPC->maxs, end, NPC->s.number, NPC->clipmask|CONTENTS_BOTCLIP );
+						if ( !trace.allsolid && !trace.startsolid )
+						{
+							if ( trace.fraction >= 1.0 || trace.plane.normal[2] > 0 )
+							{
+								ucmd.upmove = 127;
+								ucmd.forwardmove = 127;
+								return;
+							}
+						}
+					}
+					*/
+					//FIXME: about every 1 second calc a velocity, 
+					//run a loop of traces with evaluate trajectory 
+					//for gravity with my size, see if it makes it...
+					//this will also catch misacalculations that send you off ledges!
+					//gi.Printf( "Considering Jump\n" );
+					if (NPC->client && NPC->client->NPC_class==CLASS_BOBAFETT)
+					{
+						Boba_FireDecide();
+					}
+				/*	else if ( NPC_TryJump( NPC->enemy ) )	// Jedi, can see enemy, but can't get to him
+					{//FIXME: what about jumping to his enemyLastSeenLocation?
+						return;
+					}*/
+				}
+
+				//Check for evasion
+				if ( TIMER_Done( NPC, "parryTime" ) )
+				{//finished parrying
+					if ( NPC->client->ps.saberBlocked != BLOCKED_ATK_BOUNCE &&
+						NPC->client->ps.saberBlocked != BLOCKED_PARRY_BROKEN )
+					{//wasn't blocked myself
+						NPC->client->ps.saberBlocked = BLOCKED_NONE;
+					}
+				}
+				if ( Jedi_Hunt() && !(NPCInfo->aiFlags&NPCAI_BLOCKED) )//FIXME: have to do this because they can ping-pong forever
+				{//can macro-navigate to him
+					if ( enemy_dist < 384 && !Q_irand( 0, 10 ) && NPCInfo->blockedSpeechDebounceTime < level.time && jediSpeechDebounceTime[NPC->client->playerTeam] < level.time && !NPC_ClearLOS( NPC->enemy ) )
+					{
+						G_AddVoiceEvent( NPC, Q_irand( EV_JLOST1, EV_JLOST3 ), 3000 );
+						jediSpeechDebounceTime[NPC->client->playerTeam] = NPCInfo->blockedSpeechDebounceTime = level.time + 3000;
+					}
+					if (NPC->client && NPC->client->NPC_class==CLASS_BOBAFETT)
+					{
+						Boba_FireDecide();
+					}
+
+					return;
+				}
+				//well, try to head for his last seen location
+		/*
+				else if ( Jedi_Track() )
+				{
+					return;
+				}
+		*/		else
+				{//FIXME: try to find a waypoint that can see enemy, jump from there
+				/*	if ( STEER::HasBeenBlockedFor(NPC, 3000) )
+					{//try to jump to the blockedDest
+						if (NPCInfo->blockedTargetEntity)
+						{
+							NPC_TryJump(NPCInfo->blockedTargetEntity);	// commented Out
+						}
+						else
+						{
+							NPC_TryJump(NPCInfo->blockedTargetPosition);// commented Out
+						}
+					}*/
+
+					enemy_lost = qtrue;
+				}
+			}
+		}
+		//else, we can see him or we can't track him at all
+
+		//every few seconds, decide if we should we advance or retreat?
+		Jedi_CombatTimersUpdate( enemy_dist );
+
+		//We call this even if lost enemy to keep him moving and to update the taunting behavior
+		//maintain a distance from enemy appropriate for our aggression level
+		Jedi_CombatDistance( enemy_dist );
+	}
+
+	//if ( !enemy_lost )
+ 	if (NPC->client->NPC_class != CLASS_BOBAFETT)
+	{
+		//Update our seen enemy position
+		if ( !NPC->enemy->client || ( NPC->enemy->client->ps.groundEntityNum != ENTITYNUM_NONE && NPC->client->ps.groundEntityNum != ENTITYNUM_NONE ) )
+		{
+			VectorCopy( NPC->enemy->currentOrigin, NPCInfo->enemyLastSeenLocation );
+		}
+		NPCInfo->enemyLastSeenTime = level.time;
+	}
+
+	//Turn to face the enemy
+	if ( TIMER_Done( NPC, "noturn" ) && !NPC_Jumping() )
+	{
+		Jedi_FaceEnemy( qtrue );
+	}
+	NPC_UpdateAngles( qtrue, qtrue );
+	
+	//Check for evasion
+	if ( TIMER_Done( NPC, "parryTime" ) )
+	{//finished parrying
+		if ( NPC->client->ps.saberBlocked != BLOCKED_ATK_BOUNCE &&
+			NPC->client->ps.saberBlocked != BLOCKED_PARRY_BROKEN )
+		{//wasn't blocked myself
+			NPC->client->ps.saberBlocked = BLOCKED_NONE;
+		}
+	}
+	if ( NPC->enemy->s.weapon == WP_SABER )
+	{
+		Jedi_EvasionSaber( enemy_movedir, enemy_dist, enemy_dir );
+	}
+	else
+	{//do we need to do any evasion for other kinds of enemies?
+	}
+
+	//apply strafing/walking timers, etc.
+	Jedi_TimersApply();
+
+	if ( TIMER_Done( NPC, "allyJediDelay" ) )
+	{
+		if ( ( !NPC->client->ps.saberInFlight || (NPC->client->ps.saberAnimLevel == SS_DUAL && NPC->client->ps.saber[1].Active()) )
+			&& (!(NPC->client->ps.forcePowersActive&(1<<FP_GRIP))||NPC->client->ps.forcePowerLevel[FP_GRIP] < FORCE_LEVEL_2) )
+		{//not throwing saber or using force grip
+			//see if we can attack
+			if ( !Jedi_AttackDecide( enemy_dist ) )
+			{//we're not attacking, decide what else to do
+				Jedi_CombatIdle( enemy_dist );
+				//FIXME: lower aggression when actually strike offensively?  Or just when do damage?
+			}
+			else
+			{//we are attacking
+				//stop taunting
+				TIMER_Set( NPC, "taunting", -level.time );
+			}
+		}
+		else
+		{
+		}
+		if ( NPC->client->NPC_class == CLASS_BOBAFETT )
+		{
+			Boba_FireDecide();
+		}
+		else if ( NPC->client->NPC_class == CLASS_ROCKETTROOPER )
+		{
+			RT_FireDecide();
+		}
+	}
+
+	//Check for certain enemy special moves
+	Jedi_CheckEnemyMovement( enemy_dist );
+	//Make sure that we don't jump off ledges over long drops
+	Jedi_CheckJumps();
+	//Just make sure we don't strafe into walls or off cliffs
+
+	if ( VectorCompare( NPC->client->ps.moveDir, vec3_origin )//stomped the NAV system's moveDir
+		&& !NPC_MoveDirClear( ucmd.forwardmove, ucmd.rightmove, qtrue ) )//check ucmd-driven movement
+	{//uh-oh, we are going to fall or hit something
+		/*
+		navInfo_t	info;
+		//Get the move info
+		NAV_GetLastMove( info );
+		if ( !(info.flags & NIF_MACRO_NAV) )
+		{//micro-navigation told us to step off a ledge, try using macronav for now
+			NPC_MoveToGoal( qfalse );
+		}
+		*/
+		//reset the timers.
+		TIMER_Set( NPC, "strafeLeft", 0 );
+		TIMER_Set( NPC, "strafeRight", 0 );
+	}
+}
+
+
+/*
+==========================================================================================
+EXTERNALLY CALLED BEHAVIOR STATES
+==========================================================================================
+*/
+
+/*
+-------------------------
+NPC_Jedi_Pain
+-------------------------
+*/
+
+void NPC_Jedi_Pain( gentity_t *self, gentity_t *inflictor, gentity_t *other, const vec3_t point, int damage, int mod,int hitLoc ) 
+{
+	//FIXME: base the actual aggression add/subtract on health?
+	//FIXME: don't do this more than once per frame?
+	//FIXME: when take pain, stop force gripping....?
+	if ( other->s.weapon == WP_SABER )
+	{//back off
+		TIMER_Set( self, "parryTime", -1 );
+		if ( self->client->NPC_class == CLASS_DESANN || !Q_stricmp("Yoda",self->NPC_type) )
+		{//less for Desann
+			self->client->ps.forcePowerDebounce[FP_SABER_DEFENSE] = level.time + (3-g_spskill->integer)*50;
+		}
+		else if ( self->NPC->rank >= RANK_LT_JG )
+		{
+			self->client->ps.forcePowerDebounce[FP_SABER_DEFENSE] = level.time + (3-g_spskill->integer)*100;//300
+		}
+		else
+		{
+			self->client->ps.forcePowerDebounce[FP_SABER_DEFENSE] = level.time + (3-g_spskill->integer)*200;//500
+		}
+		if ( !Q_irand( 0, 3 ) )
+		{//ouch... maybe switch up which saber power level we're using
+			Jedi_AdjustSaberAnimLevel( self, Q_irand( SS_FAST, SS_STRONG ) );
+		}
+		if ( !Q_irand( 0, 1 ) )//damage > 20 || self->health < 40 || 
+		{
+			//Com_Printf( "(%d) drop agg - hit by saber\n", level.time );
+			Jedi_Aggression( self, -1 );
+		}
+		if ( d_JediAI->integer )
+		{
+			gi.Printf( "(%d) PAIN: agg %d, no parry until %d\n", level.time, self->NPC->stats.aggression, level.time+500 );
+		}
+		//for testing only
+		// Figure out what quadrant the hit was in.
+		if ( d_JediAI->integer )
+		{
+			vec3_t	diff, fwdangles, right;
+
+			VectorSubtract( point, self->client->renderInfo.eyePoint, diff );
+			diff[2] = 0;
+			fwdangles[1] = self->client->ps.viewangles[1];
+			AngleVectors( fwdangles, NULL, right, NULL );
+			float rightdot = DotProduct(right, diff);
+			float zdiff = point[2] - self->client->renderInfo.eyePoint[2];
+		
+			gi.Printf( "(%d) saber hit at height %4.2f, zdiff: %4.2f, rightdot: %4.2f\n", level.time, point[2]-self->absmin[2],zdiff,rightdot);
+		}
+	}
+	else
+	{//attack
+		//Com_Printf( "(%d) raise agg - hit by ranged\n", level.time );
+		Jedi_Aggression( self, 1 );
+	}
+
+	self->NPC->enemyCheckDebounceTime = 0;
+
+	WP_ForcePowerStop( self, FP_GRIP );
+
+	NPC_Pain( self, inflictor, other, point, damage, mod );
+
+	if ( !damage && self->health > 0 )
+	{//FIXME: better way to know I was pushed
+		G_AddVoiceEvent( self, Q_irand(EV_PUSHED1, EV_PUSHED3), 2000 );
+	}
+
+	//drop me from the ceiling if I'm on it
+	if ( Jedi_WaitingAmbush( self ) )
+	{
+		self->client->noclip = false;
+	}
+	if ( self->client->ps.legsAnim == BOTH_CEILING_CLING )
+	{
+		NPC_SetAnim( self, SETANIM_LEGS, BOTH_CEILING_DROP, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+	}
+	if ( self->client->ps.torsoAnim == BOTH_CEILING_CLING )
+	{
+		NPC_SetAnim( self, SETANIM_TORSO, BOTH_CEILING_DROP, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+	}
+
+	//check special defenses
+	if ( other 
+		&& other->client 
+		&& !OnSameTeam( self, other ))
+	{//hit by a client
+		//FIXME: delay this until *after* the pain anim?
+		if ( mod == MOD_FORCE_GRIP
+			|| mod == MOD_FORCE_LIGHTNING
+			|| mod == MOD_FORCE_DRAIN )
+		{//see if we should turn on absorb
+			if ( (self->client->ps.forcePowersKnown&(1<<FP_ABSORB)) != 0 
+				&& (self->client->ps.forcePowersActive&(1<<FP_ABSORB)) == 0 )
+			{//know absorb and not already using it
+				if ( other->s.number >= MAX_CLIENTS //enemy is an NPC
+					|| Q_irand( 0, g_spskill->integer+1 ) )//enemy is player
+				{
+					if ( Q_irand( 0, self->NPC->rank ) > RANK_ENSIGN )
+					{
+						if ( !Q_irand( 0, 5 ) )
+						{
+							ForceAbsorb( self );
+						}
+					}
+				}
+			}
+		}
+		else if ( damage > Q_irand( 5, 20 ) )
+		{//respectable amount of normal damage
+			if ( (self->client->ps.forcePowersKnown&(1<<FP_PROTECT)) != 0 
+				&& (self->client->ps.forcePowersActive&(1<<FP_PROTECT)) == 0 )
+			{//know protect and not already using it
+				if ( other->s.number >= MAX_CLIENTS //enemy is an NPC
+					|| Q_irand( 0, g_spskill->integer+1 ) )//enemy is player
+				{
+					if ( Q_irand( 0, self->NPC->rank ) > RANK_ENSIGN )
+					{ 
+						if ( !Q_irand( 0, 1 ) )
+						{
+							if ( other->s.number < MAX_CLIENTS
+								&& ((self->NPC->aiFlags&NPCAI_BOSS_CHARACTER)
+									|| self->client->NPC_class==CLASS_SHADOWTROOPER) 
+								&& Q_irand(0, 6-g_spskill->integer) ) 
+							{ 
+							}
+							else
+							{
+								ForceProtect( self );
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+qboolean Jedi_CheckDanger( void )
+{
+	int alertEvent = NPC_CheckAlertEvents( qtrue, qtrue );
+	if ( level.alertEvents[alertEvent].level >= AEL_DANGER )
+	{//run away!
+		if ( !level.alertEvents[alertEvent].owner 
+			|| !level.alertEvents[alertEvent].owner->client 
+			|| (level.alertEvents[alertEvent].owner!=NPC&&level.alertEvents[alertEvent].owner->client->playerTeam!=NPC->client->playerTeam) )
+		{//no owner
+			return qfalse;
+		}
+		G_SetEnemy( NPC, level.alertEvents[alertEvent].owner );
+		NPCInfo->enemyLastSeenTime = level.time;
+		TIMER_Set( NPC, "attackDelay", Q_irand( 500, 2500 ) );
+		return qtrue;
+	}
+	return qfalse;
+}
+
+extern int g_crosshairEntNum;
+qboolean Jedi_CheckAmbushPlayer( void )
+{
+	if ( !player || !player->client )
+	{
+		return qfalse;
+	}
+
+	if ( !NPC_ValidEnemy( player ) )
+	{
+		return qfalse;
+	}
+
+	if ( NPC->client->ps.powerups[PW_CLOAKED] || g_crosshairEntNum != NPC->s.number )
+	{//if I'm not cloaked and the player's crosshair is on me, I will wake up, otherwise do this stuff down here...
+		if ( !gi.inPVS( player->currentOrigin, NPC->currentOrigin ) )
+		{//must be in same room
+			return qfalse;
+		}
+		else
+		{
+			if ( !NPC->client->ps.powerups[PW_CLOAKED] )
+			{
+				NPC_SetLookTarget( NPC, 0, 0 );
+			}
+		}
+		float target_dist, zDiff = NPC->currentOrigin[2]-player->currentOrigin[2];
+		if ( zDiff <= 0 || zDiff > 512 )
+		{//never ambush if they're above me or way way below me
+			return qfalse;
+		}
+
+		//If the target is this close, then wake up regardless
+		if ( (target_dist = DistanceHorizontalSquared( player->currentOrigin, NPC->currentOrigin )) > 4096 )
+		{//closer than 64 - always ambush
+			if ( target_dist > 147456 )
+			{//> 384, not close enough to ambush
+				return qfalse;
+			}
+			//Check FOV first
+			if ( NPC->client->ps.powerups[PW_CLOAKED] )
+			{
+				if ( InFOV( player, NPC, 30, 90 ) == qfalse )
+				{
+					return qfalse;
+				}
+			}
+			else
+			{
+				if ( InFOV( player, NPC, 45, 90 ) == qfalse )
+				{
+					return qfalse;
+				}
+			}
+		}
+
+		if ( !NPC_ClearLOS( player ) )
+		{
+			return qfalse;
+		}
+	}
+
+	G_SetEnemy( NPC, player );
+	NPCInfo->enemyLastSeenTime = level.time;
+	TIMER_Set( NPC, "attackDelay", Q_irand( 500, 2500 ) );
+	return qtrue;
+}
+
+void Jedi_Ambush( gentity_t *self )
+{
+	self->client->noclip = false;
+	self->client->ps.pm_flags |= PMF_JUMPING|PMF_SLOW_MO_FALL;
+	NPC_SetAnim( self, SETANIM_BOTH, BOTH_CEILING_DROP, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+	self->client->ps.weaponTime = NPC->client->ps.torsoAnimTimer;
+	if ( self->client->NPC_class != CLASS_BOBAFETT 
+		&& self->client->NPC_class != CLASS_ROCKETTROOPER )
+	{
+		self->client->ps.SaberActivate();
+	}
+	Jedi_Decloak( self );
+	G_AddVoiceEvent( self, Q_irand( EV_ANGER1, EV_ANGER3 ), 1000 );
+}
+
+qboolean Jedi_WaitingAmbush( gentity_t *self )
+{
+	if ( (self->spawnflags&JSF_AMBUSH) && self->client->noclip )
+	{
+		return qtrue;
+	}
+	return qfalse;
+}
+/*
+-------------------------
+Jedi_Patrol
+-------------------------
+*/
+
+static void Jedi_Patrol( void )
+{
+	NPC->client->ps.saberBlocked = BLOCKED_NONE;
+
+	if ( Jedi_WaitingAmbush( NPC ) )
+	{//hiding on the ceiling
+		NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_CEILING_CLING, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+		if ( NPCInfo->scriptFlags&SCF_LOOK_FOR_ENEMIES )
+		{//look for enemies
+			if ( Jedi_CheckAmbushPlayer() || Jedi_CheckDanger() )
+			{//found him!
+				Jedi_Ambush( NPC );
+				NPC_UpdateAngles( qtrue, qtrue );
+				return;
+			}
+		}
+	}
+	else if ( NPCInfo->scriptFlags&SCF_LOOK_FOR_ENEMIES )//NPCInfo->scriptFlags & SCF_CHASE_ENEMIES )
+	{//look for enemies
+		gentity_t *best_enemy = NULL;
+		float	best_enemy_dist = Q3_INFINITE;
+		for ( int i = 0; i < ENTITYNUM_WORLD; i++ )
+		{
+			gentity_t *enemy = &g_entities[i];
+			float	enemy_dist;
+			if ( enemy && enemy->client && NPC_ValidEnemy( enemy ))
+			{
+				if ( gi.inPVS( NPC->currentOrigin, enemy->currentOrigin ) )
+				{//we could potentially see him
+					enemy_dist = DistanceSquared( NPC->currentOrigin, enemy->currentOrigin );
+					if ( enemy->s.number == 0 || enemy_dist < best_enemy_dist )
+					{
+						//if the enemy is close enough, or threw his saber, take him as the enemy
+						//FIXME: what if he throws a thermal detonator?
+						//FIXME: use jediSpeechDebounceTime[NPC->client->playerTeam] < level.time ) check for anger sound
+						if ( enemy_dist < (220*220) || ( NPCInfo->investigateCount>= 3 && NPC->client->ps.SaberActive() ) )
+						{
+							G_SetEnemy( NPC, enemy );
+							//NPCInfo->behaviorState = BS_HUNT_AND_KILL;//should be auto now
+							NPCInfo->stats.aggression = 3;
+							break;
+						}
+						else if ( enemy->client->ps.saberInFlight && enemy->client->ps.SaberActive() )
+						{//threw his saber, see if it's heading toward me and close enough to consider a threat
+							float	saberDist;
+							vec3_t	saberDir2Me;
+							vec3_t	saberMoveDir;
+							gentity_t *saber = &g_entities[enemy->client->ps.saberEntityNum];
+							VectorSubtract( NPC->currentOrigin, saber->currentOrigin, saberDir2Me );
+							saberDist = VectorNormalize( saberDir2Me );
+							VectorCopy( saber->s.pos.trDelta, saberMoveDir );
+							VectorNormalize( saberMoveDir );
+							if ( DotProduct( saberMoveDir, saberDir2Me ) > 0.5 )
+							{//it's heading towards me
+								if ( saberDist < 200 )
+								{//incoming!
+									G_SetEnemy( NPC, enemy );
+									//NPCInfo->behaviorState = BS_HUNT_AND_KILL;//should be auto now
+									NPCInfo->stats.aggression = 3;
+									break;
+								}
+							}
+						}
+						best_enemy_dist = enemy_dist;
+						best_enemy = enemy;
+					}
+				}
+			}
+		}
+		if ( !NPC->enemy )
+		{//still not mad
+			if ( !best_enemy )
+			{
+				//Com_Printf( "(%d) drop agg - no enemy (patrol)\n", level.time );
+				Jedi_AggressionErosion(-1);
+				//FIXME: what about alerts?  But not if ignore alerts
+			}
+			else
+			{//have one to consider
+				if ( NPC_ClearLOS( best_enemy ) )
+				{//we have a clear (of architecture) LOS to him
+					if ( (NPCInfo->aiFlags&NPCAI_NO_JEDI_DELAY) )
+					{//just get mad right away
+						if ( DistanceHorizontalSquared( NPC->currentOrigin, best_enemy->currentOrigin ) < (1024*1024) )
+						{
+							G_SetEnemy( NPC, best_enemy );
+							NPCInfo->stats.aggression = 20;
+						}
+					}
+					else if ( best_enemy->s.number )
+					{//just attack
+						G_SetEnemy( NPC, best_enemy );
+						NPCInfo->stats.aggression = 3;
+					}
+					else if ( NPC->client->NPC_class != CLASS_BOBAFETT )
+					{//the player, toy with him
+						//get progressively more interested over time
+						if ( TIMER_Done( NPC, "watchTime" ) )
+						{//we want to pick him up in stages
+							if ( TIMER_Get( NPC, "watchTime" ) == -1 )
+							{//this is the first time, we'll ignore him for a couple seconds
+								TIMER_Set( NPC, "watchTime", Q_irand( 3000, 5000 ) );
+								goto finish;
+							}
+							else
+							{//okay, we've ignored him, now start to notice him
+								if ( !NPCInfo->investigateCount )
+								{
+									G_AddVoiceEvent( NPC, Q_irand( EV_JDETECTED1, EV_JDETECTED3 ), 3000 );
+								}
+								NPCInfo->investigateCount++;
+								TIMER_Set( NPC, "watchTime", Q_irand( 4000, 10000 ) );
+							}
+						}
+						//while we're waiting, do what we need to do
+						if ( best_enemy_dist < (440*440) || NPCInfo->investigateCount >= 2 )
+						{//stage three: keep facing him
+							NPC_FaceEntity( best_enemy, qtrue );
+							if ( best_enemy_dist < (330*330) )
+							{//stage four: turn on the saber
+								if ( !NPC->client->ps.saberInFlight )
+								{
+									NPC->client->ps.SaberActivate();
+								}
+							}
+						}
+						else if ( best_enemy_dist < (550*550) || NPCInfo->investigateCount == 1 )
+						{//stage two: stop and face him every now and then
+							if ( TIMER_Done( NPC, "watchTime" ) )
+							{
+								NPC_FaceEntity( best_enemy, qtrue );
+							}
+						}
+						else
+						{//stage one: look at him.
+							NPC_SetLookTarget( NPC, best_enemy->s.number, 0 );
+						}
+					}
+				}
+				else if ( TIMER_Done( NPC, "watchTime" ) )
+				{//haven't seen him in a bit, clear the lookTarget
+					NPC_ClearLookTarget( NPC );
+				}
+			}
+		}
+	}
+finish:
+	//If we have somewhere to go, then do that
+	if ( UpdateGoal() )
+	{
+		ucmd.buttons |= BUTTON_WALKING;
+		//Jedi_Move( NPCInfo->goalEntity );
+		NPC_MoveToGoal( qtrue );
+	}
+
+	NPC_UpdateAngles( qtrue, qtrue );
+
+	if ( NPC->enemy )
+	{//just picked one up
+		NPCInfo->enemyCheckDebounceTime = level.time + Q_irand( 3000, 10000 );
+	}
+}
+
+qboolean Jedi_CanPullBackSaber( gentity_t *self )
+{
+	if ( self->client->ps.saberBlocked == BLOCKED_PARRY_BROKEN && !TIMER_Done( self, "parryTime" ) )
+	{
+		return qfalse;
+	}
+
+	if ( self->client->NPC_class == CLASS_SHADOWTROOPER
+		|| self->client->NPC_class == CLASS_ALORA
+		|| ( self->NPC && (self->NPC->aiFlags&NPCAI_BOSS_CHARACTER) ) )
+	{
+		return qtrue;
+	}
+
+	if ( self->painDebounceTime > level.time )//|| self->client->ps.weaponTime > 0 )
+	{
+		return qfalse;
+	}
+
+	return qtrue;
+}
+/*
+-------------------------
+NPC_BSJedi_FollowLeader
+-------------------------
+*/
+extern qboolean NAV_CheckAhead( gentity_t *self, vec3_t end, trace_t &trace, int clipmask );
+
+void NPC_BSJedi_FollowLeader( void )
+{
+	NPC->client->ps.saberBlocked = BLOCKED_NONE;
+	if ( !NPC->enemy )
+	{
+		//Com_Printf( "(%d) drop agg - no enemy (follow)\n", level.time );
+		Jedi_AggressionErosion(-1);
+	}
+	
+	//did we drop our saber?  If so, go after it!
+	if ( NPC->client->ps.saberInFlight )
+	{//saber is not in hand
+		if ( NPC->client->ps.saberEntityNum < ENTITYNUM_NONE && NPC->client->ps.saberEntityNum > 0 )//player is 0
+		{//
+			if ( g_entities[NPC->client->ps.saberEntityNum].s.pos.trType == TR_STATIONARY )
+			{//fell to the ground, try to pick it up... 
+				if ( Jedi_CanPullBackSaber( NPC ) )
+				{
+					//FIXME: if it's on the ground and we just pulled it back to us, should we
+					//		stand still for a bit to make sure it gets to us...?
+					//		otherwise we could end up running away from it while it's on its
+					//		way back to us and we could lose it again.
+					NPC->client->ps.saberBlocked = BLOCKED_NONE;
+					NPCInfo->goalEntity = &g_entities[NPC->client->ps.saberEntityNum];
+					ucmd.buttons |= BUTTON_ATTACK;
+					if ( NPC->enemy && NPC->enemy->health > 0 )
+					{//get our saber back NOW!
+						if ( !NPC_MoveToGoal( qtrue ) )//Jedi_Move( NPCInfo->goalEntity, qfalse );
+						{//can't nav to it, try jumping to it
+							NPC_FaceEntity( NPCInfo->goalEntity, qtrue );
+							NPC_TryJump( NPCInfo->goalEntity );
+						}
+						NPC_UpdateAngles( qtrue, qtrue );
+						return;
+					}
+				}
+			}
+		}
+	}
+
+	//try normal movement
+	NPC_BSFollowLeader();
+
+
+	if (!NPC->enemy &&  
+		NPC->health < NPC->max_health && 
+		(NPC->client->ps.forcePowersKnown&(1<<FP_HEAL)) != 0  &&
+        (NPC->client->ps.forcePowersActive&(1<<FP_HEAL)) == 0 &&
+		TIMER_Done(NPC, "FollowHealDebouncer"))
+	{
+		if (Q_irand(0,3)==0)
+		{
+			TIMER_Set(NPC, "FollowHealDebouncer", Q_irand(12000, 18000));
+			ForceHeal( NPC );
+		}
+		else
+		{
+			TIMER_Set(NPC, "FollowHealDebouncer", Q_irand(1000, 2000));
+		}
+	}
+
+}
+
+qboolean Jedi_CheckKataAttack( void )
+{
+	if ( NPCInfo->rank >= RANK_LT_COMM )
+	{//only top-level guys and bosses do this
+		if ( (ucmd.buttons&BUTTON_ATTACK) )
+		{//attacking
+			if ( (g_saberNewControlScheme->integer 
+				&& !(ucmd.buttons&BUTTON_FORCE_FOCUS) )
+				||(!g_saberNewControlScheme->integer 
+				&& !(ucmd.buttons&BUTTON_ALT_ATTACK) ) )
+			{//not already going to do a kata move somehow
+				if ( NPC->client->ps.groundEntityNum != ENTITYNUM_NONE )
+				{//on the ground
+					if ( ucmd.upmove <= 0 && NPC->client->ps.forceJumpCharge <= 0 )
+					{//not going to try to jump
+						/*
+						if ( (NPCInfo->scriptFlags&SCF_NO_ACROBATICS) )
+						{//uh-oh, no jumping moves!
+							if ( NPC->client->ps.saberAnimLevel == SS_STAFF )
+							{//this kata move has a jump in it...
+								return qfalse;
+							}
+						}
+						*/
+
+						if ( Q_irand( 0, g_spskill->integer+1 ) //50% chance on easy, 66% on medium, 75% on hard
+							&& !Q_irand( 0, 9 ) )//10% chance overall
+						{//base on skill level
+							ucmd.upmove = 0;
+							VectorClear( NPC->client->ps.moveDir );
+							if ( g_saberNewControlScheme->integer )
+							{
+								ucmd.buttons |= BUTTON_FORCE_FOCUS;
+							}
+							else
+							{
+								ucmd.buttons |= BUTTON_ALT_ATTACK;
+							}
+							return qtrue;
+						}
+					}
+				}
+			}
+		}
+	}
+	return qfalse;
+}
+
+
+/*
+-------------------------
+Jedi_Attack
+-------------------------
+*/
+
+static void Jedi_Attack( void )
+{
+	//Don't do anything if we're in a pain anim
+	if ( NPC->painDebounceTime > level.time )
+	{
+		if ( Q_irand( 0, 1 ) )
+		{
+			Jedi_FaceEnemy( qtrue );
+		}
+		NPC_UpdateAngles( qtrue, qtrue );
+		if ( NPC->client->ps.torsoAnim == BOTH_KYLE_GRAB )
+		{//see if we grabbed enemy
+			if ( NPC->client->ps.torsoAnimTimer <= 200 )
+			{
+				if ( Kyle_CanDoGrab()
+					&& NPC_EnemyRangeFromBolt( NPC->handRBolt ) < 88.0f )
+				{//grab him!
+					Kyle_GrabEnemy();
+					return;
+				}
+				else
+				{
+					NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_KYLE_MISS, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+					NPC->client->ps.weaponTime = NPC->client->ps.torsoAnimTimer;
+					return;
+				}
+			}
+			//else just sit here?
+		}
+		return;
+	}
+
+	if ( NPC->client->ps.saberLockTime > level.time )
+	{
+		//FIXME: maybe kick out of saberlock?
+		//maybe if I'm losing I should try to force-push out of it?  Very rarely, though...
+		if ( NPC->client->ps.forcePowerLevel[FP_PUSH] > FORCE_LEVEL_2 
+			&& NPC->client->ps.saberLockTime < level.time + 5000 
+			&& !Q_irand( 0, 10 ))
+		{
+			ForceThrow( NPC, qfalse );
+		}
+		//based on my skill, hit attack button every other to every several frames in order to push enemy back
+		else
+		{
+			float chance;
+		
+			if ( NPC->client->NPC_class == CLASS_DESANN || !Q_stricmp("Yoda",NPC->NPC_type) )
+			{
+				if ( g_spskill->integer )
+				{
+					chance = 4.0f;//he pushes *hard*
+				}
+				else
+				{
+					chance = 3.0f;//he pushes *hard*
+				}
+			}
+			else if ( NPC->client->NPC_class == CLASS_TAVION 
+				|| NPC->client->NPC_class == CLASS_SHADOWTROOPER
+				|| NPC->client->NPC_class == CLASS_ALORA
+				|| (NPC->client->NPC_class == CLASS_KYLE&&(NPC->spawnflags&1)) )
+			{
+				chance = 2.0f+g_spskill->value;//from 2 to 4
+			}
+			else
+			{//the escalation in difficulty is nice, here, but cap it so it doesn't get *impossible* on hard
+				float maxChance	= (float)(RANK_LT)/2.0f+3.0f;//5?
+				if ( !g_spskill->value )
+				{
+					chance = (float)(NPCInfo->rank)/2.0f;
+				}
+				else
+				{
+					chance = (float)(NPCInfo->rank)/2.0f+1.0f;
+				}
+				if ( chance > maxChance )
+				{
+					chance = maxChance;
+				}
+			}
+			if ( (NPCInfo->aiFlags&NPCAI_BOSS_CHARACTER) )
+			{ 
+				chance += Q_irand(0,2); 
+			}
+			else if ( (NPCInfo->aiFlags&NPCAI_SUBBOSS_CHARACTER) )
+			{
+				chance += Q_irand(-1,1);
+			}
+			if ( Q_flrand( -4.0f, chance ) >= 0.0f && !(NPC->client->ps.pm_flags&PMF_ATTACK_HELD) )
+			{
+				ucmd.buttons |= BUTTON_ATTACK;
+			}
+		}
+		NPC_UpdateAngles( qtrue, qtrue );
+		return;
+	}
+	//did we drop our saber?  If so, go after it!
+	if ( NPC->client->ps.saberInFlight )
+	{//saber is not in hand
+		if ( NPC->client->ps.saberEntityNum < ENTITYNUM_NONE && NPC->client->ps.saberEntityNum > 0 )//player is 0
+		{//
+			if ( g_entities[NPC->client->ps.saberEntityNum].s.pos.trType == TR_STATIONARY )
+			{//fell to the ground, try to pick it up
+				if ( Jedi_CanPullBackSaber( NPC ) )
+				{
+					NPC->client->ps.saberBlocked = BLOCKED_NONE;
+					NPCInfo->goalEntity = &g_entities[NPC->client->ps.saberEntityNum];
+					ucmd.buttons |= BUTTON_ATTACK;
+					if ( NPC->enemy && NPC->enemy->health > 0 )
+					{//get our saber back NOW!
+						Jedi_Move( NPCInfo->goalEntity, qfalse );
+						NPC_UpdateAngles( qtrue, qtrue );
+						if ( NPC->enemy->s.weapon == WP_SABER )
+						{//be sure to continue evasion
+							vec3_t	enemy_dir, enemy_movedir, enemy_dest;
+							float	enemy_dist, enemy_movespeed;
+							Jedi_SetEnemyInfo( enemy_dest, enemy_dir, &enemy_dist, enemy_movedir, &enemy_movespeed, 300 );
+							Jedi_EvasionSaber( enemy_movedir, enemy_dist, enemy_dir );
+						}
+						return;
+					}
+				}
+			}
+		}
+	}
+	//see if our enemy was killed by us, gloat and turn off saber after cool down.
+	//FIXME: don't do this if we have other enemies to fight...?
+	if ( NPC->enemy )
+	{
+		if ( NPC->enemy->health <= 0 
+			&& NPC->enemy->enemy == NPC 
+			&& (NPC->client->playerTeam != TEAM_PLAYER||(NPC->client->NPC_class==CLASS_KYLE&&(NPC->spawnflags&1)&&NPC->enemy==player)) )//good guys don't gloat (unless it's Kyle having just killed his student
+		{//my enemy is dead and I killed him
+			NPCInfo->enemyCheckDebounceTime = 0;//keep looking for others
+
+			if ( NPC->client->NPC_class == CLASS_BOBAFETT 
+				|| (NPC->client->NPC_class == CLASS_REBORN && NPC->s.weapon != WP_SABER)
+				|| NPC->client->NPC_class == CLASS_ROCKETTROOPER )
+			{
+				if ( NPCInfo->walkDebounceTime < level.time && NPCInfo->walkDebounceTime >= 0 )
+				{
+					TIMER_Set( NPC, "gloatTime", 10000 );
+					NPCInfo->walkDebounceTime = -1;
+				}
+				if ( !TIMER_Done( NPC, "gloatTime" ) )
+				{
+					if ( DistanceHorizontalSquared( NPC->client->renderInfo.eyePoint, NPC->enemy->currentOrigin ) > 4096 && (NPCInfo->scriptFlags&SCF_CHASE_ENEMIES) )//64 squared
+					{
+						NPCInfo->goalEntity = NPC->enemy;
+						Jedi_Move( NPC->enemy, qfalse );
+						ucmd.buttons |= BUTTON_WALKING;
+					}
+					else
+					{
+						TIMER_Set( NPC, "gloatTime", 0 );
+					}
+				}
+				else if ( NPCInfo->walkDebounceTime == -1 )
+				{
+					NPCInfo->walkDebounceTime = -2;
+					G_AddVoiceEvent( NPC, Q_irand( EV_VICTORY1, EV_VICTORY3 ), 3000 );
+					jediSpeechDebounceTime[NPC->client->playerTeam] = level.time + 3000;
+					NPCInfo->desiredPitch = 0;
+					NPCInfo->goalEntity = NULL;
+				}
+				Jedi_FaceEnemy( qtrue );
+				NPC_UpdateAngles( qtrue, qtrue );
+				return;
+			}
+			else
+			{
+				if ( !TIMER_Done( NPC, "parryTime" ) )
+				{
+					TIMER_Set( NPC, "parryTime", -1 );
+					NPC->client->ps.forcePowerDebounce[FP_SABER_DEFENSE] = level.time + 500;
+				}
+				NPC->client->ps.saberBlocked = BLOCKED_NONE;
+				if ( NPC->client->ps.SaberActive() || NPC->client->ps.saberInFlight )
+				{//saber is still on (or we're trying to pull it back), count down erosion and keep facing the enemy
+					//FIXME: need to stop this from happening over and over again when they're blocking their victim's saber
+					//FIXME: turn off saber sooner so we get cool walk anim?
+					//Com_Printf( "(%d) drop agg - enemy dead\n", level.time );
+					Jedi_AggressionErosion(-3);
+					if ( !NPC->client->ps.SaberActive() && !NPC->client->ps.saberInFlight )
+					{//turned off saber (in hand), gloat
+						G_AddVoiceEvent( NPC, Q_irand( EV_VICTORY1, EV_VICTORY3 ), 3000 );
+						jediSpeechDebounceTime[NPC->client->playerTeam] = level.time + 3000;
+						NPCInfo->desiredPitch = 0;
+						NPCInfo->goalEntity = NULL;
+					}
+					TIMER_Set( NPC, "gloatTime", 10000 );
+				}
+				if ( NPC->client->ps.SaberActive() || NPC->client->ps.saberInFlight || !TIMER_Done( NPC, "gloatTime" ) )
+				{//keep walking
+					if ( DistanceHorizontalSquared( NPC->client->renderInfo.eyePoint, NPC->enemy->currentOrigin ) > 4096 && (NPCInfo->scriptFlags&SCF_CHASE_ENEMIES) )//64 squared
+					{
+						NPCInfo->goalEntity = NPC->enemy;
+						Jedi_Move( NPC->enemy, qfalse );
+						ucmd.buttons |= BUTTON_WALKING;
+					}
+					else
+					{//got there
+						if ( NPC->health < NPC->max_health )
+						{
+							if ( NPC->client->ps.saber[0].type == SABER_SITH_SWORD 
+								&& NPC->weaponModel[0] != -1 )
+							{
+								Tavion_SithSwordRecharge();
+							}
+							else if ( (NPC->client->ps.forcePowersKnown&(1<<FP_HEAL)) != 0 
+								&& (NPC->client->ps.forcePowersActive&(1<<FP_HEAL)) == 0 )
+							{
+								ForceHeal( NPC );
+							}
+						}
+					}
+					Jedi_FaceEnemy( qtrue );
+					NPC_UpdateAngles( qtrue, qtrue );
+					return;
+				}
+			}
+		}
+	}
+
+	//If we don't have an enemy, just idle
+	if ( NPC->enemy->s.weapon == WP_TURRET && !Q_stricmp( "PAS", NPC->enemy->classname ) )
+	{
+		if ( NPC->enemy->count <= 0 )
+		{//it's out of ammo
+			if ( NPC->enemy->activator && NPC_ValidEnemy( NPC->enemy->activator ) )
+			{
+				gentity_t *turretOwner = NPC->enemy->activator;
+				G_ClearEnemy( NPC );
+				G_SetEnemy( NPC, turretOwner );
+			}
+			else
+			{
+				G_ClearEnemy( NPC );
+			}
+		}
+	}
+	if ( NPC->enemy->NPC  
+		&& NPC->enemy->NPC->charmedTime > level.time )
+	{//my enemy was charmed
+		if ( OnSameTeam( NPC, NPC->enemy ) )
+		{//has been charmed to be on my team
+			G_ClearEnemy( NPC );
+		}
+	}
+	if ( NPC->client->playerTeam == TEAM_ENEMY
+		&& NPC->client->enemyTeam == TEAM_PLAYER
+		&& NPC->enemy
+		&& NPC->enemy->client
+		&& NPC->enemy->client->playerTeam != NPC->client->enemyTeam 
+		&& OnSameTeam( NPC, NPC->enemy ) 
+		&& !(NPC->svFlags&SVF_LOCKEDENEMY) )
+	{//an evil jedi somehow got another evil NPC as an enemy, they were probably charmed and it's run out now
+		if ( !NPC_ValidEnemy( NPC->enemy ) )
+		{
+			G_ClearEnemy( NPC );
+		}
+	}
+	NPC_CheckEnemy( qtrue, qtrue );
+
+	if ( !NPC->enemy )
+	{
+		NPC->client->ps.saberBlocked = BLOCKED_NONE;
+		if ( NPCInfo->tempBehavior == BS_HUNT_AND_KILL )
+		{//lost him, go back to what we were doing before
+			NPCInfo->tempBehavior = BS_DEFAULT;
+			NPC_UpdateAngles( qtrue, qtrue );
+			return;
+		}
+		Jedi_Patrol();//was calling Idle... why?
+		return;
+	}
+
+	//always face enemy if have one
+	NPCInfo->combatMove = qtrue;
+
+	//Track the player and kill them if possible
+	Jedi_Combat();
+
+	if ( !(NPCInfo->scriptFlags&SCF_CHASE_ENEMIES) 
+		|| ((NPC->client->ps.forcePowersActive&(1<<FP_HEAL))&&NPC->client->ps.forcePowerLevel[FP_HEAL]<FORCE_LEVEL_2))
+	{//this is really stupid, but okay...
+		ucmd.forwardmove = 0;
+		ucmd.rightmove = 0;
+		if ( ucmd.upmove > 0 )
+		{
+			ucmd.upmove = 0;
+		}
+		NPC->client->ps.forceJumpCharge = 0;
+		VectorClear( NPC->client->ps.moveDir );
+	}
+
+	//NOTE: for now, we clear ucmd.forwardmove & ucmd.rightmove while in air to avoid jumps going awry...
+	if ( NPC->client->ps.groundEntityNum == ENTITYNUM_NONE )
+	{//don't push while in air, throws off jumps!
+		//FIXME: if we are in the air over a drop near a ledge, should we try to push back towards the ledge?
+		ucmd.forwardmove = 0;
+		ucmd.rightmove = 0;
+		VectorClear( NPC->client->ps.moveDir );
+	}
+
+	if ( !TIMER_Done( NPC, "duck" ) )
+	{
+		ucmd.upmove = -127;
+	}
+
+	if ( NPC->client->NPC_class != CLASS_BOBAFETT
+		&& (NPC->client->NPC_class != CLASS_REBORN || NPC->s.weapon == WP_SABER)
+		&& NPC->client->NPC_class != CLASS_ROCKETTROOPER )
+	{
+		if ( PM_SaberInBrokenParry( NPC->client->ps.saberMove ) || NPC->client->ps.saberBlocked == BLOCKED_PARRY_BROKEN )
+		{//just make sure they don't pull their saber to them if they're being blocked
+			ucmd.buttons &= ~BUTTON_ATTACK;
+		}
+	}
+
+	if( (NPCInfo->scriptFlags&SCF_DONT_FIRE) //not allowed to attack
+		|| ((NPC->client->ps.forcePowersActive&(1<<FP_HEAL))&&NPC->client->ps.forcePowerLevel[FP_HEAL]<FORCE_LEVEL_3)
+		|| ((NPC->client->ps.saberEventFlags&SEF_INWATER)&&!NPC->client->ps.saberInFlight) )//saber in water
+	{
+		ucmd.buttons &= ~(BUTTON_ATTACK|BUTTON_ALT_ATTACK|BUTTON_FORCE_FOCUS);
+	}
+
+	if ( (NPCInfo->scriptFlags&SCF_NO_ACROBATICS) )
+	{
+		ucmd.upmove = 0;
+		NPC->client->ps.forceJumpCharge = 0;
+	}
+
+	if ( NPC->client->NPC_class != CLASS_BOBAFETT
+		&& (NPC->client->NPC_class != CLASS_REBORN || NPC->s.weapon == WP_SABER)
+		&& NPC->client->NPC_class != CLASS_ROCKETTROOPER )
+	{
+		Jedi_CheckDecreaseSaberAnimLevel();
+	}
+
+	if ( ucmd.buttons & BUTTON_ATTACK && NPC->client->playerTeam == TEAM_ENEMY )
+	{
+		if ( Q_irand( 0, NPC->client->ps.saberAnimLevel ) > 0 
+			&& Q_irand( 0, NPC->max_health+10 ) > NPC->health 
+			&& !Q_irand( 0, 3 ))
+		{//the more we're hurt and the stronger the attack we're using, the more likely we are to make a anger noise when we swing
+			G_AddVoiceEvent( NPC, Q_irand( EV_COMBAT1, EV_COMBAT3 ), 1000 );
+		}
+	}
+
+	//Check for trying a kata move
+	//FIXME: what about force-pull attacks?
+	if ( Jedi_CheckKataAttack() )
+	{//doing a kata attack
+	}
+	else
+	{//check other special combat behavior
+		if ( NPC->client->NPC_class != CLASS_BOBAFETT 
+			&& (NPC->client->NPC_class != CLASS_REBORN || NPC->s.weapon == WP_SABER)
+			&& NPC->client->NPC_class != CLASS_ROCKETTROOPER )
+		{
+			if ( NPC->client->NPC_class == CLASS_TAVION 
+				|| NPC->client->NPC_class == CLASS_SHADOWTROOPER
+				|| NPC->client->NPC_class == CLASS_ALORA
+				|| (g_spskill->integer && ( NPC->client->NPC_class == CLASS_DESANN || NPCInfo->rank >= Q_irand( RANK_CREWMAN, RANK_CAPTAIN ))))
+			{//Tavion will kick in force speed if the player does...
+				if ( NPC->enemy 
+					&& !NPC->enemy->s.number 
+					&& NPC->enemy->client 
+					&& (NPC->enemy->client->ps.forcePowersActive & (1<<FP_SPEED)) 
+					&& !(NPC->client->ps.forcePowersActive & (1<<FP_SPEED)) )
+				{
+					int chance = 0;
+					switch ( g_spskill->integer )
+					{
+					case 0:
+						chance = 9;
+					case 1:
+						chance = 3;
+					case 2:
+						chance = 1;
+						break;
+					}
+					if ( !Q_irand( 0, chance ) )
+					{
+						ForceSpeed( NPC );
+					}
+				}
+			}
+		}
+		//Sometimes Alora flips towards you instead of runs
+		if ( NPC->client->NPC_class == CLASS_ALORA )
+		{
+			if ( (ucmd.buttons&BUTTON_ALT_ATTACK) )
+			{//chance of doing a special dual saber throw
+				if ( NPC->client->ps.saberAnimLevel == SS_DUAL
+					&& !NPC->client->ps.saberInFlight )
+				{
+					if ( Distance( NPC->enemy->currentOrigin, NPC->currentOrigin ) >= 120 )
+					{
+						NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_ALORA_SPIN_THROW, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD, 0 );
+						NPC->client->ps.weaponTime = NPC->client->ps.torsoAnimTimer;
+						//FIXME: don't move
+						//FIXME: sabers need trails and sounds
+					}
+				}
+			}
+			else if ( NPC->enemy
+				&& ucmd.forwardmove > 0 
+				&& fabs((float)ucmd.rightmove) < 32
+				&& !(ucmd.buttons&BUTTON_WALKING)
+				&& !(ucmd.buttons&BUTTON_ATTACK)
+				&& NPC->client->ps.saberMove == LS_READY
+				&& NPC->client->ps.legsAnim == BOTH_RUN_DUAL )
+			{//running at us, not attacking
+				if ( Distance( NPC->enemy->currentOrigin, NPC->currentOrigin ) > 80 )
+				{
+					if ( NPC->client->ps.legsAnim == BOTH_FLIP_F
+						|| NPC->client->ps.legsAnim == BOTH_ALORA_FLIP_1
+						|| NPC->client->ps.legsAnim == BOTH_ALORA_FLIP_2
+						|| NPC->client->ps.legsAnim == BOTH_ALORA_FLIP_3 )
+					{
+						if ( NPC->client->ps.legsAnimTimer <= 200 && Q_irand( 0, 2 ) )
+						{//go ahead and start anotther
+							NPC_SetAnim( NPC, SETANIM_BOTH, Q_irand(BOTH_ALORA_FLIP_1,BOTH_ALORA_FLIP_3), SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD, 0 );
+						}
+					}
+					else if ( !Q_irand( 0, 6 ) )
+					{
+						NPC_SetAnim( NPC, SETANIM_BOTH, Q_irand(BOTH_ALORA_FLIP_1,BOTH_ALORA_FLIP_3), SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD, 0 );
+					}
+				}
+			}
+		}
+	}
+
+	if ( VectorCompare( NPC->client->ps.moveDir, vec3_origin )
+		&& (ucmd.forwardmove||ucmd.rightmove) )
+	{//using ucmds to move this turn, not NAV
+		if ( (ucmd.buttons&BUTTON_WALKING) )
+		{//FIXME: NAV system screws with speed directly, so now I have to re-set it myself!
+			NPC->client->ps.speed = NPCInfo->stats.walkSpeed;
+		}
+		else
+		{
+			NPC->client->ps.speed = NPCInfo->stats.runSpeed;
+		}
+	}
+}
+
+qboolean Rosh_BeingHealed( gentity_t *self )
+{
+	if ( self
+		&& self->NPC 
+		&& self->client
+		&& (self->NPC->aiFlags&NPCAI_ROSH) 
+		&& (self->flags&FL_UNDYING)
+		&& ( self->health == 1 //need healing
+			|| self->client->ps.powerups[PW_INVINCIBLE] > level.time ) )//being healed
+	{
+		return qtrue;
+	}
+	return qfalse;
+}
+
+qboolean Rosh_TwinPresent( gentity_t *self )
+{
+	gentity_t *foundTwin = G_Find( NULL, FOFS(NPC_type), "DKothos" );
+	if ( !foundTwin 
+		|| foundTwin->health < 0 )
+	{
+		foundTwin = G_Find( NULL, FOFS(NPC_type), "VKothos" );
+	}
+	if ( !foundTwin 
+		|| foundTwin->health < 0 )
+	{//oh well, both twins are dead...
+		return qfalse;
+	}
+	return qtrue;
+}
+
+qboolean Rosh_TwinNearBy( gentity_t *self )
+{
+	gentity_t *foundTwin = G_Find( NULL, FOFS(NPC_type), "DKothos" );
+	if ( !foundTwin 
+		|| foundTwin->health < 0 )
+	{
+		foundTwin = G_Find( NULL, FOFS(NPC_type), "VKothos" );
+	}
+	if ( !foundTwin 
+		|| foundTwin->health < 0 )
+	{//oh well, both twins are dead...
+		return qfalse;
+	}
+	if ( self->client
+		&& foundTwin->client )
+	{
+		if ( Distance( self->currentOrigin, foundTwin->currentOrigin ) <= 512.0f 
+			&& G_ClearLineOfSight( self->client->renderInfo.eyePoint, foundTwin->client->renderInfo.eyePoint, foundTwin->s.number, MASK_OPAQUE ) )
+		{
+			//make them look charge me for a bit while I do this
+			TIMER_Set( self, "chargeMeUp", Q_irand( 2000, 4000 ) );
+			return qtrue;
+		}
+	}
+	return qfalse;
+}
+
+qboolean Kothos_HealRosh( void )
+{
+	if ( NPC->client
+		&& NPC->client->leader
+		&& NPC->client->leader->client )
+	{
+		if ( DistanceSquared( NPC->client->leader->currentOrigin, NPC->currentOrigin ) <= (256*256)
+			&& G_ClearLineOfSight( NPC->client->leader->client->renderInfo.eyePoint, NPC->client->renderInfo.eyePoint, NPC->s.number, MASK_OPAQUE ) )
+		{
+			//NPC_FaceEntity( NPC->client->leader, qtrue );
+			NPC_SetAnim( NPC, SETANIM_TORSO, BOTH_FORCE_2HANDEDLIGHTNING_HOLD, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+			NPC->client->ps.torsoAnimTimer = 1000;
+			
+			//FIXME: unique effect and sound
+			//NPC->client->ps.eFlags |= EF_POWERING_ROSH;
+			if ( NPC->ghoul2.size() )
+			{
+				mdxaBone_t	boltMatrix;
+				vec3_t		fxOrg, fxDir, angles={0,NPC->currentAngles[YAW],0};
+
+				gi.G2API_GetBoltMatrix( NPC->ghoul2, NPC->playerModel, 
+							(Q_irand(0,1)?NPC->handLBolt:NPC->handRBolt),
+							&boltMatrix, angles, NPC->currentOrigin, (cg.time?cg.time:level.time),
+							NULL, NPC->s.modelScale );
+				gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, fxOrg );
+				VectorSubtract( NPC->client->leader->currentOrigin, fxOrg, fxDir );
+				VectorNormalize( fxDir );
+				G_PlayEffect( G_EffectIndex( "force/kothos_beam.efx" ), fxOrg, fxDir );
+			}
+			//BEG HACK LINE
+			gentity_t *tent = G_TempEntity( NPC->currentOrigin, EV_KOTHOS_BEAM );
+			tent->svFlags |= SVF_BROADCAST;
+			tent->s.otherEntityNum = NPC->s.number;
+			tent->s.otherEntityNum2 = NPC->client->leader->s.number;
+			//END HACK LINE
+
+			NPC->client->leader->health += Q_irand( 1+g_spskill->integer*2, 4+g_spskill->integer*3 );//from 1-5 to 4-10
+			if ( NPC->client->leader->client )
+			{
+				if ( NPC->client->leader->client->ps.legsAnim == BOTH_FORCEHEAL_START 
+					&& NPC->client->leader->health >= NPC->client->leader->max_health )
+				{//let him get up now
+					NPC_SetAnim( NPC->client->leader, SETANIM_BOTH, BOTH_FORCEHEAL_STOP, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+					//FIXME: temp effect
+					G_PlayEffect( G_EffectIndex( "force/kothos_recharge.efx" ), NPC->client->leader->playerModel, 0, NPC->client->leader->s.number, NPC->client->leader->currentOrigin, NPC->client->leader->client->ps.torsoAnimTimer, qfalse );
+					//make him invincible while we recharge him
+					NPC->client->leader->client->ps.powerups[PW_INVINCIBLE] = level.time + NPC->client->leader->client->ps.torsoAnimTimer;
+					NPC->client->leader->NPC->ignorePain = qfalse;
+					NPC->client->leader->health = NPC->client->leader->max_health;
+				}
+				else
+				{
+					G_PlayEffect( G_EffectIndex( "force/kothos_recharge.efx" ), NPC->client->leader->playerModel, 0, NPC->client->leader->s.number, NPC->client->leader->currentOrigin, 500, qfalse );
+					NPC->client->leader->client->ps.powerups[PW_INVINCIBLE] = level.time + 500;
+				}
+			}
+			//decrement
+			NPC->count--;
+			if ( !NPC->count )
+			{
+				TIMER_Set( NPC, "healRoshDebounce", Q_irand( 5000, 10000 ) );
+				NPC->count = 100;
+			}
+			//now protect me, too
+			if ( g_spskill->integer )
+			{//not on easy
+				G_PlayEffect( G_EffectIndex( "force/kothos_recharge.efx" ), NPC->playerModel, 0, NPC->s.number, NPC->currentOrigin, 500, qfalse );
+				NPC->client->ps.powerups[PW_INVINCIBLE] = level.time + 500;
+			}
+			return qtrue;
+		}
+	}
+	return qfalse;
+}
+
+void Kothos_PowerRosh( void )
+{
+	if ( NPC->client
+		&& NPC->client->leader )
+	{
+		if ( Distance( NPC->client->leader->currentOrigin, NPC->currentOrigin ) <= 512.0f 
+			&& G_ClearLineOfSight( NPC->client->leader->client->renderInfo.eyePoint, NPC->client->renderInfo.eyePoint, NPC->s.number, MASK_OPAQUE ) )
+		{
+			NPC_FaceEntity( NPC->client->leader, qtrue );
+			NPC_SetAnim( NPC, SETANIM_TORSO, BOTH_FORCELIGHTNING_HOLD, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+			NPC->client->ps.torsoAnimTimer = 500;
+			//FIXME: unique effect and sound
+			//NPC->client->ps.eFlags |= EF_POWERING_ROSH;
+			G_PlayEffect( G_EffectIndex( "force/kothos_beam.efx" ), NPC->playerModel, NPC->handLBolt, NPC->s.number, NPC->currentOrigin, 500, qfalse );
+			if ( NPC->client->leader->client )
+			{//hmm, give him some force?
+				NPC->client->leader->client->ps.forcePower++;
+			}
+		}
+	}
+}
+
+qboolean Kothos_Retreat( void )
+{
+	STEER::Activate( NPC );
+	STEER::Evade( NPC, NPC->enemy );
+	STEER::AvoidCollisions( NPC, NPC->client->leader );
+	STEER::DeActivate( NPC, &ucmd );
+	if ( (NPCInfo->aiFlags&NPCAI_BLOCKED) )
+	{
+		if ( level.time - NPCInfo->blockedDebounceTime > 1000 )
+		{
+			return qfalse;
+		}
+	}
+	return qtrue;
+}
+
+#define TWINS_DANGER_DIST_EASY (128.0f*128.0f)
+#define TWINS_DANGER_DIST_MEDIUM (192.0f*192.0f)
+#define TWINS_DANGER_DIST_HARD (256.0f*256.0f)
+float Twins_DangerDist( void )
+{
+	switch ( g_spskill->integer )
+	{
+	case 0:
+		return TWINS_DANGER_DIST_EASY;
+		break;
+	case 1:
+		return TWINS_DANGER_DIST_MEDIUM;
+		break;
+	case 2:
+	default:
+		return TWINS_DANGER_DIST_HARD;
+		break;
+	}
+}
+
+qboolean Jedi_InSpecialMove( void )
+{
+	if ( NPC->client->ps.torsoAnim == BOTH_KYLE_PA_1
+		|| NPC->client->ps.torsoAnim == BOTH_KYLE_PA_2 
+		|| NPC->client->ps.torsoAnim == BOTH_KYLE_PA_3 
+		|| NPC->client->ps.torsoAnim == BOTH_PLAYER_PA_1
+		|| NPC->client->ps.torsoAnim == BOTH_PLAYER_PA_2
+		|| NPC->client->ps.torsoAnim == BOTH_PLAYER_PA_3
+		|| NPC->client->ps.torsoAnim == BOTH_FORCE_DRAIN_GRAB_END
+		|| NPC->client->ps.torsoAnim == BOTH_FORCE_DRAIN_GRABBED )
+	{
+		NPC_UpdateAngles( qtrue, qtrue );
+		return qtrue;
+	}
+
+	if ( Jedi_InNoAIAnim( NPC ) )
+	{//in special anims, don't do force powers or attacks, just face the enemy
+		if ( NPC->enemy )
+		{
+			NPC_FaceEnemy( qtrue );
+		}
+		else
+		{
+			NPC_UpdateAngles( qtrue, qtrue );
+		}
+		return qtrue;
+	}
+
+	/*
+	if ( NPC->client->ps.forceGripEntityNum < ENTITYNUM_WORLD
+		&& (NPC->client->ps.forcePowersActive&(1<<FP_GRIP))
+		&& NPC->client->ps.forcePowerLevel[FP_GRIP] > FORCE_LEVEL_2 )
+	{//stop facing the enemy, just use your current angles
+		NPC_UpdateAngles( qtrue, qtrue );
+	}
+	*/
+
+	if ( NPC->client->ps.torsoAnim == BOTH_FORCE_DRAIN_GRAB_START
+		|| NPC->client->ps.torsoAnim == BOTH_FORCE_DRAIN_GRAB_HOLD )
+	{
+		if ( !TIMER_Done( NPC, "draining" ) )
+		{//FIXME: what do we do if we ran out of power?  NPC's can't?
+			//FIXME: don't keep turning to face enemy or we'll end up spinning around
+			ucmd.buttons |= BUTTON_FORCE_DRAIN;
+		}
+		NPC_UpdateAngles( qtrue, qtrue );
+		return qtrue;
+	}
+
+	if ( NPC->client->ps.torsoAnim == BOTH_TAVION_SWORDPOWER )
+	{
+		NPC->health += Q_irand( 1, 2 ); 
+		if ( NPC->health > NPC->max_health )
+		{
+			NPC->health = NPC->max_health;
+		}
+		NPC_UpdateAngles( qtrue, qtrue );
+		return qtrue;
+	}
+
+	if ( NPC->client->ps.torsoAnim == BOTH_SCEPTER_START )
+	{
+		if ( NPC->client->ps.torsoAnimTimer <= 100 )
+		{//go into the hold
+			NPC->s.loopSound = G_SoundIndex( "sound/weapons/scepter/loop.wav" );
+			G_PlayEffect( G_EffectIndex( "scepter/beam.efx" ), NPC->weaponModel[1], NPC->genericBolt1, NPC->s.number, NPC->currentOrigin, 10000, qtrue );
+			NPC->client->ps.legsAnimTimer = NPC->client->ps.torsoAnimTimer = 0;
+			NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_SCEPTER_HOLD, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+			NPC->client->ps.torsoAnimTimer += 200;
+			NPC->painDebounceTime = level.time + NPC->client->ps.torsoAnimTimer;
+			NPC->client->ps.pm_time = NPC->client->ps.torsoAnimTimer;
+			NPC->client->ps.pm_flags |= PMF_TIME_KNOCKBACK;
+			VectorClear( NPC->client->ps.velocity );
+			VectorClear( NPC->client->ps.moveDir );
+		}
+		if ( NPC->enemy )
+		{
+			NPC_FaceEnemy( qtrue );
+		}
+		else
+		{
+			NPC_UpdateAngles( qtrue, qtrue );
+		}
+		return qtrue;
+	}
+	else if ( NPC->client->ps.torsoAnim == BOTH_SCEPTER_HOLD )
+	{
+		if ( NPC->client->ps.torsoAnimTimer <= 100 )
+		{
+			NPC->s.loopSound = 0;
+			G_StopEffect( G_EffectIndex( "scepter/beam.efx" ), NPC->weaponModel[1], NPC->genericBolt1, NPC->s.number );
+			NPC->client->ps.legsAnimTimer = NPC->client->ps.torsoAnimTimer = 0;
+			NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_SCEPTER_STOP, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+			NPC->painDebounceTime = level.time + NPC->client->ps.torsoAnimTimer;
+			NPC->client->ps.pm_time = NPC->client->ps.torsoAnimTimer;
+			NPC->client->ps.pm_flags |= PMF_TIME_KNOCKBACK;
+			VectorClear( NPC->client->ps.velocity );
+			VectorClear( NPC->client->ps.moveDir );
+		}
+		else
+		{
+			Tavion_ScepterDamage();
+		}
+		if ( NPC->enemy )
+		{
+			NPC_FaceEnemy( qtrue );
+		}
+		else
+		{
+			NPC_UpdateAngles( qtrue, qtrue );
+		}
+		return qtrue;
+	}
+	else if ( NPC->client->ps.torsoAnim == BOTH_SCEPTER_STOP )
+	{
+		if ( NPC->enemy )
+		{
+			NPC_FaceEnemy( qtrue );
+		}
+		else
+		{
+			NPC_UpdateAngles( qtrue, qtrue );
+		}
+		return qtrue;
+	}
+	else if ( NPC->client->ps.torsoAnim == BOTH_TAVION_SCEPTERGROUND )
+	{
+		if ( NPC->client->ps.torsoAnimTimer <= 1200 
+			&& !NPC->count ) 
+		{
+			Tavion_ScepterSlam();
+			NPC->count = 1;
+		} 
+		NPC_UpdateAngles( qtrue, qtrue );
+		return qtrue;
+	}
+
+	if ( Jedi_CultistDestroyer( NPC ) )
+	{
+		if ( !NPC->takedamage )
+		{//ready to explode
+			if ( NPC->useDebounceTime <= level.time )
+			{
+				//this should damage everyone - FIXME: except other destroyers?
+				NPC->client->playerTeam = TEAM_FREE;//FIXME: will this destroy wampas, tusken & rancors?
+				WP_Explode( NPC );
+				return qtrue;
+			}
+			if ( NPC->enemy )
+			{
+				NPC_FaceEnemy( qfalse );
+			}
+			return qtrue;
+		}
+	}
+
+	if ( NPC->client->NPC_class == CLASS_REBORN )
+	{
+		if ( (NPCInfo->aiFlags&NPCAI_HEAL_ROSH) )
+		{
+			if ( !NPC->client->leader )
+			{//find Rosh
+				NPC->client->leader = G_Find( NULL, FOFS(NPC_type), "rosh_dark" );
+			}
+			//NPC->client->ps.eFlags &= ~EF_POWERING_ROSH;
+			if ( NPC->client->leader )
+			{
+				qboolean helpingRosh = qfalse;
+				NPC->flags |= FL_LOCK_PLAYER_WEAPONS;
+				NPC->client->leader->flags |= FL_UNDYING;
+				if ( NPC->client->leader->client )
+				{
+					NPC->client->leader->client->ps.forcePowersKnown |= FORCE_POWERS_ROSH_FROM_TWINS;
+				}
+				if ( NPC->client->leader->client->ps.legsAnim == BOTH_FORCEHEAL_START
+					&& TIMER_Done( NPC, "healRoshDebounce" ) )
+				{
+					if ( Kothos_HealRosh() )
+					{
+						helpingRosh = qtrue;
+					}
+					else
+					{//can't get to him!
+						NPC_BSJedi_FollowLeader();
+						NPC_UpdateAngles( qtrue, qtrue );
+						return qtrue;
+					}
+				}
+
+				/*
+				if ( !helpingRosh 
+					&& !TIMER_Done( NPC->client->leader, "chargeMeUp" ) 
+					&& NPC->client->leader->health > 0)
+				{
+					Kothos_PowerRosh();
+					helpingRosh = qtrue;
+				}
+				*/
+
+				if ( helpingRosh )
+				{
+					WP_ForcePowerStop( NPC, FP_LIGHTNING );
+					WP_ForcePowerStop( NPC, FP_DRAIN );
+					WP_ForcePowerStop( NPC, FP_GRIP );
+					NPC_FaceEntity( NPC->client->leader, qtrue );
+					return qtrue;
+				}
+				else if ( NPC->enemy && DistanceSquared( NPC->enemy->currentOrigin, NPC->currentOrigin ) < Twins_DangerDist() )
+				{
+					if ( NPC->enemy && Kothos_Retreat() )
+					{
+						NPC_FaceEnemy( qtrue );
+						//NPC_UpdateAngles( qtrue, qtrue );
+						if ( TIMER_Done( NPC, "attackDelay" ) )
+						{
+							if ( NPC->painDebounceTime > level.time  
+								|| (NPC->health < 100 && Q_irand(-20, (g_spskill->integer+1)*10) > 0 )
+								|| !Q_irand( 0, 80-(g_spskill->integer*20) ) )
+							{
+								NPC->flags &= ~FL_LOCK_PLAYER_WEAPONS;
+								switch ( Q_irand( 0, 7+g_spskill->integer ) )//on easy: no lightning
+								{
+								case 0:
+								case 1:
+								case 2:
+								case 3:
+									ForceThrow( NPC, qfalse, qfalse );
+									NPC->client->ps.weaponTime = Q_irand( 1000, 3000 )+(2-g_spskill->integer)*1000;
+									if ( NPC->painDebounceTime <= level.time 
+										&& NPC->health >= 100 )
+									{
+										TIMER_Set( NPC, "attackDelay", NPC->client->ps.weaponTime );
+									}
+									break;
+								case 4:
+								case 5:
+									ForceDrain2( NPC );
+									NPC->client->ps.weaponTime = Q_irand( 3000, 6000 )+(2-g_spskill->integer)*2000;
+									TIMER_Set( NPC, "draining", NPC->client->ps.weaponTime );
+									if ( NPC->painDebounceTime <= level.time 
+										&& NPC->health >= 100 )
+									{
+										TIMER_Set( NPC, "attackDelay", NPC->client->ps.weaponTime );
+									}
+									break;
+								case 6:
+								case 7:
+									if ( NPC->enemy && InFOV( NPC->enemy->currentOrigin, NPC->currentOrigin, NPC->client->ps.viewangles, 20, 30 ) )
+									{
+										NPC->client->ps.weaponTime = Q_irand( 3000, 6000 )+(2-g_spskill->integer)*2000;
+										TIMER_Set( NPC, "gripping", 3000 );
+										if ( NPC->painDebounceTime <= level.time 
+											&& NPC->health >= 100 )
+										{
+											TIMER_Set( NPC, "attackDelay", NPC->client->ps.weaponTime );
+										}
+									}
+									break;
+								case 8:
+								case 9:
+								default:
+									ForceLightning( NPC );
+									if ( NPC->client->ps.forcePowerLevel[FP_LIGHTNING] > FORCE_LEVEL_1 )
+									{
+										NPC->client->ps.weaponTime = Q_irand( 3000, 6000 )+(2-g_spskill->integer)*2000;
+										TIMER_Set( NPC, "holdLightning", NPC->client->ps.weaponTime );
+									}
+									if ( NPC->painDebounceTime <= level.time 
+										&& NPC->health >= 100 )
+									{
+										TIMER_Set( NPC, "attackDelay", NPC->client->ps.weaponTime );
+									}
+									break;
+								}
+							}
+						}
+						else
+						{
+							NPC->flags &= ~FL_LOCK_PLAYER_WEAPONS;
+						}
+						Jedi_TimersApply();
+						return qtrue;
+					}
+					else
+					{
+						NPC->flags &= ~FL_LOCK_PLAYER_WEAPONS;
+					}
+				}
+				else if ( !G_ClearLOS( NPC, NPC->client->leader ) 
+					|| DistanceSquared( NPC->currentOrigin, NPC->client->leader->currentOrigin ) > (512*512) )
+				{//can't see Rosh or too far away, catch up with him
+					if ( !TIMER_Done( NPC, "attackDelay" ) )
+					{
+						NPC->flags &= ~FL_LOCK_PLAYER_WEAPONS;
+					}
+					NPC_BSJedi_FollowLeader();
+					NPC_UpdateAngles( qtrue, qtrue );
+					return qtrue;
+				}
+				else
+				{
+					if ( !TIMER_Done( NPC, "attackDelay" ) )
+					{
+						NPC->flags &= ~FL_LOCK_PLAYER_WEAPONS;
+					}
+					STEER::Activate( NPC );
+					STEER::Stop( NPC );
+					STEER::DeActivate( NPC, &ucmd );
+					NPC_FaceEnemy( qtrue );
+					//NPC_UpdateAngles( qtrue, qtrue );
+					return qtrue;
+					//NPC_BSJedi_FollowLeader();
+				}
+			}
+			NPC_UpdateAngles( qtrue, qtrue );
+			//NPC->client->ps.eFlags &= ~EF_POWERING_ROSH;
+			//G_StopEffect( G_EffectIndex( "force/kothos_beam.efx" ), NPC->playerModel, NPC->handLBolt, NPC->s.number );
+		}
+		else if ( (NPCInfo->aiFlags&NPCAI_ROSH) )
+		{
+			if ( (NPC->flags&FL_UNDYING) )
+			{//Vil and/or Dasariah still around to heal me
+				if ( NPC->health == 1 //need healing
+					|| NPC->client->ps.powerups[PW_INVINCIBLE] > level.time )//being healed
+				{//FIXME: custom anims
+					if ( Rosh_TwinPresent( NPC ) )
+					{
+						if ( !NPC->client->ps.weaponTime )
+						{//not attacking
+							if ( NPC->client->ps.legsAnim != BOTH_FORCEHEAL_START 
+								&& NPC->client->ps.legsAnim != BOTH_FORCEHEAL_STOP )
+							{//get down and wait for Vil or Dasariah to help us
+								//FIXME: sound?
+								NPC->client->ps.legsAnimTimer = NPC->client->ps.torsoAnimTimer = 0;
+								NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_FORCEHEAL_START, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+								NPC->client->ps.torsoAnimTimer = NPC->client->ps.legsAnimTimer = -1;
+								NPC->client->ps.SaberDeactivate();
+								NPCInfo->ignorePain = qtrue;
+							}
+						}
+						NPC->client->ps.saberBlocked = BLOCKED_NONE;
+						NPC->client->ps.saberMove = NPC->client->ps.saberMoveNext = LS_NONE;
+						NPC->painDebounceTime = level.time + 500;
+						NPC->client->ps.pm_time = 500;
+						NPC->client->ps.pm_flags |= PMF_TIME_KNOCKBACK;
+						VectorClear( NPC->client->ps.velocity );
+						VectorClear( NPC->client->ps.moveDir );
+						return qtrue;
+					}
+				}
+			}
+		}
+	}
+
+	if ( PM_SuperBreakWinAnim( NPC->client->ps.torsoAnim ) )
+	{
+		NPC_FaceEnemy( qtrue );
+		if ( NPC->client->ps.groundEntityNum != ENTITYNUM_NONE )
+		{
+			VectorClear( NPC->client->ps.velocity );
+		}
+		VectorClear( NPC->client->ps.moveDir );
+		ucmd.rightmove = ucmd.forwardmove = ucmd.upmove = 0;
+		return qtrue;
+	}
+
+	return qfalse;
+}
+
+extern void NPC_BSST_Patrol( void );
+extern void NPC_BSSniper_Default( void );
+extern void G_UcmdMoveForDir( gentity_t *self, usercmd_t *cmd, vec3_t dir );
+void NPC_BSJedi_Default( void )
+{
+	if ( Jedi_InSpecialMove() )
+	{
+		return;
+	}
+
+	Jedi_CheckCloak();
+
+	if( !NPC->enemy )
+	{//don't have an enemy, look for one
+		if ( NPC->client->NPC_class == CLASS_BOBAFETT 
+			|| (NPC->client->NPC_class == CLASS_REBORN && NPC->s.weapon != WP_SABER)
+			|| NPC->client->NPC_class == CLASS_ROCKETTROOPER )
+		{
+			NPC_BSST_Patrol();
+		}
+		else
+		{
+			Jedi_Patrol();
+		}
+	}
+	else//if ( NPC->enemy )
+	{//have an enemy
+		if ( Jedi_WaitingAmbush( NPC ) )
+		{//we were still waiting to drop down - must have had enemy set on me outside my AI
+			Jedi_Ambush( NPC );
+		}
+
+		if ( Jedi_CultistDestroyer( NPC ) 
+			&& !NPCInfo->charmedTime )
+		{//destroyer
+			//permanent effect
+			NPCInfo->charmedTime = Q3_INFINITE;
+			NPC->client->ps.forcePowersActive |= ( 1 << FP_RAGE );
+			NPC->client->ps.forcePowerDuration[FP_RAGE] = Q3_INFINITE;
+			//NPC->client->ps.eFlags |= EF_FORCE_DRAINED;
+			//FIXME: precache me!
+			NPC->s.loopSound = G_SoundIndex( "sound/movers/objects/green_beam_lp2.wav" );//test/charm.wav" );
+		}
+
+		Jedi_Attack();
+		//if we have multiple-jedi combat, probably need to keep checking (at certain debounce intervals) for a better (closer, more active) enemy and switch if needbe...
+		if ( ((!ucmd.buttons&&!NPC->client->ps.forcePowersActive)||(NPC->enemy&&NPC->enemy->health<=0)) && NPCInfo->enemyCheckDebounceTime < level.time )
+		{//not doing anything (or walking toward a vanquished enemy - fixme: always taunt the player?), not using force powers and it's time to look again
+			//FIXME: build a list of all local enemies (since we have to find best anyway) for other AI factors- like when to use group attacks, determine when to change tactics, when surrounded, when blocked by another in the enemy group, etc.  Should we build this group list or let the enemies maintain their own list and we just access it?
+			gentity_t *sav_enemy = NPC->enemy;//FIXME: what about NPC->lastEnemy?
+			NPC->enemy = NULL;
+			gentity_t *newEnemy = NPC_CheckEnemy( NPCInfo->confusionTime < level.time, qfalse, qfalse );
+			NPC->enemy = sav_enemy;
+			if ( newEnemy && newEnemy != sav_enemy )
+			{//picked up a new enemy!
+				NPC->lastEnemy = NPC->enemy;
+				G_SetEnemy( NPC, newEnemy );
+			}
+			NPCInfo->enemyCheckDebounceTime = level.time + Q_irand( 1000, 3000 );
+		}
+	}
+	if ( NPC->client->ps.saber[0].type == SABER_SITH_SWORD 
+		&& NPC->weaponModel[0] != -1 )
+	{
+		if ( NPC->health < 100 
+			&& !Q_irand( 0, 20 ) )
+		{
+			Tavion_SithSwordRecharge();
+		}
+	}
+}
\ No newline at end of file
diff --git a/code/game/AI_Mark1.cpp b/code/game/AI_Mark1.cpp
new file mode 100644
index 0000000..dff596f
--- /dev/null
+++ b/code/game/AI_Mark1.cpp
@@ -0,0 +1,746 @@
+// leave this line at the top of all AI_xxxx.cpp files for PCH reasons...
+#include "g_headers.h"
+#include "b_local.h"
+#include "g_nav.h"
+
+#define	MIN_MELEE_RANGE				320
+#define	MIN_MELEE_RANGE_SQR			( MIN_MELEE_RANGE * MIN_MELEE_RANGE )
+
+#define MIN_DISTANCE				128
+#define MIN_DISTANCE_SQR			( MIN_DISTANCE * MIN_DISTANCE )
+
+#define TURN_OFF					0x00000100
+
+#define LEFT_ARM_HEALTH				40
+#define RIGHT_ARM_HEALTH			40
+#define AMMO_POD_HEALTH				40
+
+#define	BOWCASTER_VELOCITY			1300
+#define	BOWCASTER_NPC_DAMAGE_EASY	12
+#define	BOWCASTER_NPC_DAMAGE_NORMAL	24
+#define	BOWCASTER_NPC_DAMAGE_HARD	36
+#define BOWCASTER_SIZE				2
+#define BOWCASTER_SPLASH_DAMAGE		0
+#define BOWCASTER_SPLASH_RADIUS		0
+
+//Local state enums
+enum
+{
+	LSTATE_NONE = 0,
+	LSTATE_ASLEEP,
+	LSTATE_WAKEUP,
+	LSTATE_FIRED0,
+	LSTATE_FIRED1,
+	LSTATE_FIRED2,
+	LSTATE_FIRED3,
+	LSTATE_FIRED4,
+};
+
+qboolean NPC_CheckPlayerTeamStealth( void );
+gentity_t *CreateMissile( vec3_t org, vec3_t dir, float vel, int life, gentity_t *owner, qboolean altFire = qfalse );
+void Mark1_BlasterAttack(qboolean advance);
+void DeathFX( gentity_t *ent );
+extern gitem_t	*FindItemForAmmo( ammo_t ammo );
+
+/*
+-------------------------
+NPC_Mark1_Precache
+-------------------------
+*/
+void NPC_Mark1_Precache(void)
+{
+	G_SoundIndex( "sound/chars/mark1/misc/mark1_wakeup");
+	G_SoundIndex( "sound/chars/mark1/misc/shutdown");
+	G_SoundIndex( "sound/chars/mark1/misc/walk");
+	G_SoundIndex( "sound/chars/mark1/misc/run");
+	G_SoundIndex( "sound/chars/mark1/misc/death1");
+	G_SoundIndex( "sound/chars/mark1/misc/death2");
+	G_SoundIndex( "sound/chars/mark1/misc/anger");
+	G_SoundIndex( "sound/chars/mark1/misc/mark1_fire");
+	G_SoundIndex( "sound/chars/mark1/misc/mark1_pain");
+	G_SoundIndex( "sound/chars/mark1/misc/mark1_explo");
+
+//	G_EffectIndex( "small_chunks");
+	G_EffectIndex( "env/med_explode2");
+	G_EffectIndex( "explosions/probeexplosion1");
+	G_EffectIndex( "blaster/smoke_bolton");
+	G_EffectIndex( "bryar/muzzle_flash");
+	G_EffectIndex( "explosions/droidexplosion1" );
+
+	RegisterItem( FindItemForAmmo( 	AMMO_METAL_BOLTS));
+	RegisterItem( FindItemForAmmo( AMMO_BLASTER ));
+	RegisterItem( FindItemForWeapon( WP_BOWCASTER ));
+	RegisterItem( FindItemForWeapon( WP_BRYAR_PISTOL ));
+}
+
+/*
+-------------------------
+NPC_Mark1_Part_Explode
+-------------------------
+*/
+void NPC_Mark1_Part_Explode( gentity_t *self, int bolt )
+{
+	if ( bolt >=0 )
+	{
+		mdxaBone_t	boltMatrix;
+		vec3_t		org, dir;
+
+		gi.G2API_GetBoltMatrix( self->ghoul2, self->playerModel, 
+					bolt,
+					&boltMatrix, self->currentAngles, self->currentOrigin, (cg.time?cg.time:level.time),
+					NULL, self->s.modelScale );
+
+		gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, org );
+		gi.G2API_GiveMeVectorFromMatrix( boltMatrix, NEGATIVE_Y, dir );
+
+		G_PlayEffect( "env/med_explode2", org, dir );
+		G_PlayEffect( G_EffectIndex("blaster/smoke_bolton"), self->playerModel, bolt, self->s.number, org );
+	}
+}
+
+/*
+-------------------------
+Mark1_Idle
+-------------------------
+*/
+void Mark1_Idle( void )
+{
+
+	NPC_BSIdle();
+
+	NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_SLEEP1, SETANIM_FLAG_NORMAL );
+}
+
+/*
+-------------------------
+Mark1Dead_FireRocket
+- Shoot the left weapon, the multi-blaster
+-------------------------
+*/
+void Mark1Dead_FireRocket (void)
+{
+	mdxaBone_t	boltMatrix;
+	vec3_t	muzzle1,muzzle_dir;
+
+	int	damage	= 50;
+
+	gi.G2API_GetBoltMatrix( NPC->ghoul2, NPC->playerModel, 
+				NPC->genericBolt5,
+				&boltMatrix, NPC->currentAngles, NPC->currentOrigin, (cg.time?cg.time:level.time),
+				NULL, NPC->s.modelScale );
+
+	gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, muzzle1 );
+	gi.G2API_GiveMeVectorFromMatrix( boltMatrix, NEGATIVE_Y, muzzle_dir );
+
+	G_PlayEffect( "bryar/muzzle_flash", muzzle1, muzzle_dir );
+
+	G_Sound( NPC, G_SoundIndex("sound/chars/mark1/misc/mark1_fire"));
+
+	gentity_t *missile = CreateMissile( muzzle1, muzzle_dir, BOWCASTER_VELOCITY, 10000, NPC );
+
+	missile->classname = "bowcaster_proj";
+	missile->s.weapon = WP_BOWCASTER;
+
+	VectorSet( missile->maxs, BOWCASTER_SIZE, BOWCASTER_SIZE, BOWCASTER_SIZE );
+	VectorScale( missile->maxs, -1, missile->mins );
+
+	missile->damage = damage;
+	missile->dflags = DAMAGE_DEATH_KNOCKBACK;
+	missile->methodOfDeath = MOD_ENERGY;
+	missile->clipmask = MASK_SHOT | CONTENTS_LIGHTSABER;
+	missile->splashDamage = BOWCASTER_SPLASH_DAMAGE;
+	missile->splashRadius = BOWCASTER_SPLASH_RADIUS;
+
+	// we don't want it to bounce
+	missile->bounceCount = 0;
+
+}
+
+/*
+-------------------------
+Mark1Dead_FireBlaster
+- Shoot the left weapon, the multi-blaster
+-------------------------
+*/
+void Mark1Dead_FireBlaster (void)
+{
+	vec3_t	muzzle1,muzzle_dir;
+	gentity_t	*missile;
+	mdxaBone_t	boltMatrix;
+	int			bolt;
+
+	bolt = NPC->genericBolt1; 
+
+	gi.G2API_GetBoltMatrix( NPC->ghoul2, NPC->playerModel, 
+				bolt,
+				&boltMatrix, NPC->currentAngles, NPC->currentOrigin, (cg.time?cg.time:level.time),
+				NULL, NPC->s.modelScale );
+
+	gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, muzzle1 );
+	gi.G2API_GiveMeVectorFromMatrix( boltMatrix, NEGATIVE_Y, muzzle_dir );
+
+	G_PlayEffect( "bryar/muzzle_flash", muzzle1, muzzle_dir );
+
+	missile = CreateMissile( muzzle1, muzzle_dir, 1600, 10000, NPC );
+
+	G_Sound( NPC, G_SoundIndex("sound/chars/mark1/misc/mark1_fire"));
+
+	missile->classname = "bryar_proj";
+	missile->s.weapon = WP_BRYAR_PISTOL;
+
+	missile->damage = 1;
+	missile->dflags = DAMAGE_DEATH_KNOCKBACK;
+	missile->methodOfDeath = MOD_ENERGY;
+	missile->clipmask = MASK_SHOT | CONTENTS_LIGHTSABER;
+
+}
+
+/*
+-------------------------
+Mark1_die
+-------------------------
+*/
+void Mark1_die( gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int mod,int dFlags,int hitLoc )
+{
+	/*
+	int	anim;
+
+	// Is he dead already?
+	anim = self->client->ps.legsAnim;
+	if (((anim==BOTH_DEATH1) || (anim==BOTH_DEATH2)) && (self->client->ps.torsoAnimTimer==0)) 
+	{	// This is because self->health keeps getting zeroed out. HL_NONE acts as health in this case.
+		self->locationDamage[HL_NONE] += damage;
+		if (self->locationDamage[HL_NONE] > 50)
+		{
+			DeathFX(self);
+			self->client->ps.eFlags |= EF_NODRAW;
+			self->contents = CONTENTS_CORPSE;
+			// G_FreeEntity( self ); // Is this safe?  I can't see why we'd mark it nodraw and then just leave it around??
+			self->e_ThinkFunc = thinkF_G_FreeEntity;
+			self->nextthink = level.time + FRAMETIME;
+		}
+		return;
+	}
+	*/
+
+	G_Sound( self, G_SoundIndex(va("sound/chars/mark1/misc/death%d.wav",Q_irand( 1, 2))));
+
+	// Choose a death anim
+	if (Q_irand( 1, 10) > 5)
+	{
+		NPC_SetAnim( self, SETANIM_BOTH, BOTH_DEATH2, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+	}
+	else
+	{
+		NPC_SetAnim( self, SETANIM_BOTH, BOTH_DEATH1, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+	}
+}
+
+/*
+-------------------------
+Mark1_dying
+-------------------------
+*/
+void Mark1_dying( gentity_t *self )
+{
+	int	num,newBolt;
+
+	if (self->client->ps.torsoAnimTimer>0)
+	{
+		if (TIMER_Done(self,"dyingExplosion"))
+		{
+			num = Q_irand( 1, 3);
+
+			// Find place to generate explosion
+			if (num == 1)
+			{
+				num = Q_irand( 8, 10);
+				newBolt = gi.G2API_AddBolt( &self->ghoul2[self->playerModel], va("*flash%d",num) );
+				NPC_Mark1_Part_Explode(self,newBolt);
+			}
+			else
+			{
+				num = Q_irand( 1, 6);
+				newBolt = gi.G2API_AddBolt( &self->ghoul2[self->playerModel], va("*torso_tube%d",num) );
+				NPC_Mark1_Part_Explode(self,newBolt);
+				gi.G2API_SetSurfaceOnOff( &self->ghoul2[self->playerModel], va("torso_tube%d",num), TURN_OFF );
+			}
+
+			TIMER_Set( self, "dyingExplosion", Q_irand( 300, 1000 ) );
+		}
+
+
+//		int		dir;
+//		vec3_t	right;
+
+		// Shove to the side
+//		AngleVectors( self->client->renderInfo.eyeAngles, NULL, right, NULL );
+//		VectorMA( self->client->ps.velocity, -80, right, self->client->ps.velocity );
+
+		// See which weapons are there
+		// Randomly fire blaster
+		if (!gi.G2API_GetSurfaceRenderStatus( &self->ghoul2[self->playerModel], "l_arm" ))	// Is the blaster still on the model?
+		{
+			if (Q_irand( 1, 5) == 1)
+			{
+				SaveNPCGlobals();
+				SetNPCGlobals( self );
+				Mark1Dead_FireBlaster();
+				RestoreNPCGlobals();
+			}
+		}
+
+		// Randomly fire rocket
+		if (!gi.G2API_GetSurfaceRenderStatus( &self->ghoul2[self->playerModel], "r_arm" ))	// Is the rocket still on the model?
+		{
+			if (Q_irand( 1, 10) == 1)
+			{
+				SaveNPCGlobals();
+				SetNPCGlobals( self );
+				Mark1Dead_FireRocket();
+				RestoreNPCGlobals();
+			}
+		}
+	}
+
+}
+
+/*
+-------------------------
+NPC_Mark1_Pain
+- look at what was hit and see if it should be removed from the model.
+-------------------------
+*/
+void NPC_Mark1_Pain( gentity_t *self, gentity_t *inflictor, gentity_t *other, const vec3_t point, int damage, int mod,int hitLoc ) 
+{
+	int newBolt,i,chance;
+	
+	NPC_Pain( self, inflictor, other, point, damage, mod );
+
+	G_Sound( self, G_SoundIndex("sound/chars/mark1/misc/mark1_pain"));
+
+	// Hit in the CHEST???
+	if (hitLoc==HL_CHEST)
+	{
+		chance = Q_irand( 1, 4);
+	
+		if ((chance == 1) && (damage > 5))
+		{
+			NPC_SetAnim( self, SETANIM_BOTH, BOTH_PAIN1, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+		}
+	}
+	// Hit in the left arm?
+	else if ((hitLoc==HL_ARM_LT) && (self->locationDamage[HL_ARM_LT] > LEFT_ARM_HEALTH))
+	{
+		if (self->locationDamage[hitLoc] >= LEFT_ARM_HEALTH)	// Blow it up?
+		{
+			newBolt = gi.G2API_AddBolt( &self->ghoul2[self->playerModel], "*flash3" );
+			if ( newBolt != -1 )
+			{
+				NPC_Mark1_Part_Explode(self,newBolt);
+			}
+
+			gi.G2API_SetSurfaceOnOff( &self->ghoul2[self->playerModel], "l_arm", TURN_OFF );
+		}
+	}
+	// Hit in the right arm?
+	else if ((hitLoc==HL_ARM_RT) && (self->locationDamage[HL_ARM_RT] > RIGHT_ARM_HEALTH))	// Blow it up?
+	{
+		if (self->locationDamage[hitLoc] >= RIGHT_ARM_HEALTH)
+		{			
+			newBolt = gi.G2API_AddBolt( &self->ghoul2[self->playerModel], "*flash4" );
+			if ( newBolt != -1 )
+			{
+//				G_PlayEffect( "small_chunks", self->playerModel, self->genericBolt2, self->s.number);
+				NPC_Mark1_Part_Explode( self, newBolt );
+			}
+
+			gi.G2API_SetSurfaceOnOff( &self->ghoul2[self->playerModel], "r_arm", TURN_OFF );
+		}
+	}
+	// Check ammo pods
+	else
+	{
+		for (i=0;i<6;i++)
+		{
+			if ((hitLoc==HL_GENERIC1+i) && (self->locationDamage[HL_GENERIC1+i] > AMMO_POD_HEALTH))	// Blow it up?
+			{
+				if (self->locationDamage[hitLoc] >= AMMO_POD_HEALTH)
+				{			
+					newBolt = gi.G2API_AddBolt( &self->ghoul2[self->playerModel], va("*torso_tube%d",(i+1)) );
+					if ( newBolt != -1 )
+					{
+						NPC_Mark1_Part_Explode(self,newBolt);
+					}
+					gi.G2API_SetSurfaceOnOff( &self->ghoul2[self->playerModel], va("torso_tube%d",(i+1)), TURN_OFF );
+					NPC_SetAnim( self, SETANIM_BOTH, BOTH_PAIN1, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+					break;
+				}
+			}
+		}
+	}
+
+	// Are both guns shot off?
+	if ((gi.G2API_GetSurfaceRenderStatus( &self->ghoul2[self->playerModel], "l_arm" )) &&
+		(gi.G2API_GetSurfaceRenderStatus( &self->ghoul2[self->playerModel], "r_arm" )))
+	{
+		G_Damage(self,NULL,NULL,NULL,NULL,self->health,0,MOD_UNKNOWN);
+	}
+
+}
+
+/*
+-------------------------
+Mark1_Hunt
+- look for enemy.
+-------------------------`
+*/
+void Mark1_Hunt(void)
+{
+
+	if ( NPCInfo->goalEntity == NULL )
+	{
+		NPCInfo->goalEntity = NPC->enemy;
+	}
+
+	NPC_FaceEnemy( qtrue );
+
+	NPCInfo->combatMove = qtrue;
+	NPC_MoveToGoal( qtrue );
+}
+
+/*
+-------------------------
+Mark1_FireBlaster
+- Shoot the left weapon, the multi-blaster
+-------------------------
+*/
+void Mark1_FireBlaster(void)
+{
+	vec3_t	muzzle1,enemy_org1,delta1,angleToEnemy1;
+	static	vec3_t	forward, vright, up;
+	static	vec3_t	muzzle;
+	gentity_t	*missile;
+	mdxaBone_t	boltMatrix;
+	int			bolt;
+
+	// Which muzzle to fire from?
+	if ((NPCInfo->localState <= LSTATE_FIRED0) || (NPCInfo->localState == LSTATE_FIRED4)) 
+	{
+		NPCInfo->localState = LSTATE_FIRED1;
+		bolt = NPC->genericBolt1; 
+	}
+	else if (NPCInfo->localState == LSTATE_FIRED1)
+	{
+		NPCInfo->localState = LSTATE_FIRED2;
+		bolt = NPC->genericBolt2; 
+	}
+	else if (NPCInfo->localState == LSTATE_FIRED2)
+	{
+		NPCInfo->localState = LSTATE_FIRED3;
+		bolt = NPC->genericBolt3; 
+	}
+	else
+	{
+		NPCInfo->localState = LSTATE_FIRED4;
+		bolt = NPC->genericBolt4; 
+	}
+
+	gi.G2API_GetBoltMatrix( NPC->ghoul2, NPC->playerModel, 
+				bolt,
+				&boltMatrix, NPC->currentAngles, NPC->currentOrigin, (cg.time?cg.time:level.time),
+				NULL, NPC->s.modelScale );
+
+	gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, muzzle1 );
+
+	if (NPC->health)
+	{
+		CalcEntitySpot( NPC->enemy, SPOT_HEAD, enemy_org1 );
+		VectorSubtract (enemy_org1, muzzle1, delta1);
+		vectoangles ( delta1, angleToEnemy1 );
+		AngleVectors (angleToEnemy1, forward, vright, up);
+	}
+	else
+	{
+		AngleVectors (NPC->currentAngles, forward, vright, up);
+	}
+
+	G_PlayEffect( "bryar/muzzle_flash", muzzle1, forward );
+
+	G_Sound( NPC, G_SoundIndex("sound/chars/mark1/misc/mark1_fire"));
+
+	missile = CreateMissile( muzzle1, forward, 1600, 10000, NPC );
+
+	missile->classname = "bryar_proj";
+	missile->s.weapon = WP_BRYAR_PISTOL;
+
+	missile->damage = 1;
+	missile->dflags = DAMAGE_DEATH_KNOCKBACK;
+	missile->methodOfDeath = MOD_ENERGY;
+	missile->clipmask = MASK_SHOT | CONTENTS_LIGHTSABER;
+
+}
+
+/*
+-------------------------
+Mark1_BlasterAttack
+-------------------------
+*/
+void Mark1_BlasterAttack(qboolean advance )
+{
+	int chance;
+
+	if ( TIMER_Done( NPC, "attackDelay" ) )	// Attack?
+	{
+		chance = Q_irand( 1, 5);
+	
+		NPCInfo->burstCount++;
+
+		if (NPCInfo->burstCount<3)	// Too few shots this burst?
+		{
+			chance = 2;				// Force it to keep firing.
+		}
+		else if (NPCInfo->burstCount>12)	// Too many shots fired this burst?
+		{
+			NPCInfo->burstCount = 0;
+			chance = 1;				// Force it to stop firing.
+		}
+
+		// Stop firing.
+		if (chance == 1)
+		{
+			NPCInfo->burstCount = 0;
+			TIMER_Set( NPC, "attackDelay", Q_irand( 1000, 3000) );
+			NPC->client->ps.torsoAnimTimer=0;						// Just in case the firing anim is running.
+		}
+		else
+		{
+			if (TIMER_Done( NPC, "attackDelay2" ))	// Can't be shooting every frame.
+			{
+				TIMER_Set( NPC, "attackDelay2", Q_irand( 50, 50) );
+				Mark1_FireBlaster();
+ 				NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_ATTACK1, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+			}
+			return;
+		}
+	}
+	else if (advance)
+	{
+		if ( NPC->client->ps.torsoAnim == BOTH_ATTACK1 )
+		{
+			NPC->client->ps.torsoAnimTimer=0;						// Just in case the firing anim is running.
+		}
+		Mark1_Hunt();
+	}
+	else	// Make sure he's not firing.
+	{
+		if ( NPC->client->ps.torsoAnim == BOTH_ATTACK1 )
+		{
+			NPC->client->ps.torsoAnimTimer=0;						// Just in case the firing anim is running.
+		}
+	}
+}
+
+/*
+-------------------------
+Mark1_FireRocket
+-------------------------
+*/
+void Mark1_FireRocket(void)
+{
+	mdxaBone_t	boltMatrix;
+	vec3_t	muzzle1,enemy_org1,delta1,angleToEnemy1;
+	static	vec3_t	forward, vright, up;
+
+	int	damage	= 50;
+
+	gi.G2API_GetBoltMatrix( NPC->ghoul2, NPC->playerModel, 
+				NPC->genericBolt5,
+				&boltMatrix, NPC->currentAngles, NPC->currentOrigin, (cg.time?cg.time:level.time),
+				NULL, NPC->s.modelScale );
+
+	gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, muzzle1 );
+
+//	G_PlayEffect( "blaster/muzzle_flash", muzzle1 );
+
+	CalcEntitySpot( NPC->enemy, SPOT_HEAD, enemy_org1 );
+	VectorSubtract (enemy_org1, muzzle1, delta1);
+	vectoangles ( delta1, angleToEnemy1 );
+	AngleVectors (angleToEnemy1, forward, vright, up);
+
+	G_Sound( NPC, G_SoundIndex("sound/chars/mark1/misc/mark1_fire" ));
+
+	gentity_t *missile = CreateMissile( muzzle1, forward, BOWCASTER_VELOCITY, 10000, NPC );
+
+	missile->classname = "bowcaster_proj";
+	missile->s.weapon = WP_BOWCASTER;
+
+	VectorSet( missile->maxs, BOWCASTER_SIZE, BOWCASTER_SIZE, BOWCASTER_SIZE );
+	VectorScale( missile->maxs, -1, missile->mins );
+
+	missile->damage = damage;
+	missile->dflags = DAMAGE_DEATH_KNOCKBACK;
+	missile->methodOfDeath = MOD_ENERGY;
+	missile->clipmask = MASK_SHOT | CONTENTS_LIGHTSABER;
+	missile->splashDamage = BOWCASTER_SPLASH_DAMAGE;
+	missile->splashRadius = BOWCASTER_SPLASH_RADIUS;
+
+	// we don't want it to bounce
+	missile->bounceCount = 0;
+
+}
+
+/*
+-------------------------
+Mark1_RocketAttack
+-------------------------
+*/
+void Mark1_RocketAttack( qboolean advance )
+{
+	if ( TIMER_Done( NPC, "attackDelay" ) )	// Attack?
+	{
+		TIMER_Set( NPC, "attackDelay", Q_irand( 1000, 3000) );
+ 		NPC_SetAnim( NPC, SETANIM_TORSO, BOTH_ATTACK2, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+		Mark1_FireRocket();
+	}
+	else if (advance)
+	{
+		Mark1_Hunt();
+	}
+}
+
+/*
+-------------------------
+Mark1_AttackDecision
+-------------------------
+*/
+void Mark1_AttackDecision( void )
+{
+	int blasterTest,rocketTest;
+
+	//randomly talk
+	if ( TIMER_Done(NPC,"patrolNoise") )
+	{
+		if (TIMER_Done(NPC,"angerNoise"))
+		{
+//			G_Sound( NPC, G_SoundIndex(va("sound/chars/mark1/misc/talk%d.wav",	Q_irand(1, 4))));
+			TIMER_Set( NPC, "patrolNoise", Q_irand( 4000, 10000 ) );
+		}
+	}
+
+	// Enemy is dead or he has no enemy.
+	if ((NPC->enemy->health<1) || ( NPC_CheckEnemyExt() == qfalse ))
+	{
+		NPC->enemy = NULL;
+		return;
+	}
+
+	// Rate our distance to the target and visibility
+	float		distance	= (int) DistanceHorizontalSquared( NPC->currentOrigin, NPC->enemy->currentOrigin );	
+	distance_e	distRate	= ( distance > MIN_MELEE_RANGE_SQR ) ? DIST_LONG : DIST_MELEE;
+	qboolean	visible		= NPC_ClearLOS( NPC->enemy );
+	qboolean	advance		= (qboolean)(distance > MIN_DISTANCE_SQR);
+
+	// If we cannot see our target, move to see it
+	if ((!visible) || (!NPC_FaceEnemy(qtrue)))
+	{
+		Mark1_Hunt();
+		return;
+	}
+
+	// See if the side weapons are there
+	blasterTest = gi.G2API_GetSurfaceRenderStatus( &NPC->ghoul2[NPC->playerModel], "l_arm" );
+	rocketTest = gi.G2API_GetSurfaceRenderStatus( &NPC->ghoul2[NPC->playerModel], "r_arm" );
+
+	// It has both side weapons
+	if (!blasterTest  && !rocketTest)
+	{
+		;	// So do nothing.
+	}
+	else if (blasterTest)
+	{
+		distRate = DIST_LONG;
+	}
+	else if (rocketTest)
+	{
+		distRate = DIST_MELEE;
+	}
+	else	// It should never get here, but just in case
+	{ 
+		NPC->health = 0;
+		NPC->client->ps.stats[STAT_HEALTH] = 0;
+		GEntity_DieFunc(NPC, NPC, NPC, 100, MOD_UNKNOWN);
+	}
+
+	// We can see enemy so shoot him if timers let you.
+	NPC_FaceEnemy( qtrue );
+
+	if (distRate == DIST_MELEE)
+	{
+		Mark1_BlasterAttack(advance);
+	}
+	else if (distRate == DIST_LONG)
+	{
+		Mark1_RocketAttack(advance);
+	}
+}
+
+/*
+-------------------------
+Mark1_Patrol
+-------------------------
+*/
+void Mark1_Patrol( void )
+{
+	if ( NPC_CheckPlayerTeamStealth() )
+	{
+		G_Sound( NPC, G_SoundIndex("sound/chars/mark1/misc/mark1_wakeup"));
+		NPC_UpdateAngles( qtrue, qtrue );
+		return;
+	}
+
+	//If we have somewhere to go, then do that
+	if (!NPC->enemy)
+	{
+		if ( UpdateGoal() )
+		{
+			ucmd.buttons |= BUTTON_WALKING;
+			NPC_MoveToGoal( qtrue );
+			NPC_UpdateAngles( qtrue, qtrue );
+		}
+
+		//randomly talk
+//		if (TIMER_Done(NPC,"patrolNoise"))
+//		{
+//			G_Sound( NPC, G_SoundIndex(va("sound/chars/mark1/misc/talk%d.wav",	Q_irand(1, 4))));
+//
+//			TIMER_Set( NPC, "patrolNoise", Q_irand( 2000, 4000 ) );
+//		}
+	}
+
+}
+
+
+/*
+-------------------------
+NPC_BSMark1_Default
+-------------------------
+*/
+void NPC_BSMark1_Default( void )
+{
+	//NPC->e_DieFunc = dieF_Mark1_die;
+
+	if ( NPC->enemy )
+	{
+		NPCInfo->goalEntity = NPC->enemy;
+		Mark1_AttackDecision();
+	}
+	else if ( NPCInfo->scriptFlags & SCF_LOOK_FOR_ENEMIES )
+	{
+		Mark1_Patrol();
+	}
+	else
+	{
+		Mark1_Idle();
+	}
+}
\ No newline at end of file
diff --git a/code/game/AI_Mark2.cpp b/code/game/AI_Mark2.cpp
new file mode 100644
index 0000000..c853603
--- /dev/null
+++ b/code/game/AI_Mark2.cpp
@@ -0,0 +1,358 @@
+// leave this line at the top of all AI_xxxx.cpp files for PCH reasons...
+#include "g_headers.h"
+
+
+#include "b_local.h"
+#include "g_nav.h"
+
+//#define AMMO_POD_HEALTH				40
+#define AMMO_POD_HEALTH				1
+#define TURN_OFF					0x00000100
+
+#define VELOCITY_DECAY		0.25
+#define MAX_DISTANCE		256
+#define MAX_DISTANCE_SQR	( MAX_DISTANCE * MAX_DISTANCE )
+#define MIN_DISTANCE		24
+#define MIN_DISTANCE_SQR	( MIN_DISTANCE * MIN_DISTANCE )
+
+extern gitem_t	*FindItemForAmmo( ammo_t ammo );
+
+//Local state enums
+enum
+{
+	LSTATE_NONE = 0,
+	LSTATE_DROPPINGDOWN,
+	LSTATE_DOWN,
+	LSTATE_RISINGUP,
+};
+
+gentity_t *CreateMissile( vec3_t org, vec3_t dir, float vel, int life, gentity_t *owner, qboolean altFire = qfalse );
+
+void NPC_Mark2_Precache( void )
+{
+	G_SoundIndex( "sound/chars/mark2/misc/mark2_explo" );// blows up on death
+	G_SoundIndex( "sound/chars/mark2/misc/mark2_pain" );
+	G_SoundIndex( "sound/chars/mark2/misc/mark2_fire" );
+	G_SoundIndex( "sound/chars/mark2/misc/mark2_move_lp" );
+
+	G_EffectIndex( "explosions/droidexplosion1" );
+	G_EffectIndex( "env/med_explode2" );
+	G_EffectIndex( "blaster/smoke_bolton" );
+	G_EffectIndex( "bryar/muzzle_flash" );
+
+	RegisterItem( FindItemForWeapon( WP_BRYAR_PISTOL ));
+	RegisterItem( FindItemForAmmo( 	AMMO_METAL_BOLTS));
+	RegisterItem( FindItemForAmmo( AMMO_POWERCELL ));
+	RegisterItem( FindItemForAmmo( AMMO_BLASTER ));
+}
+
+/*
+-------------------------
+NPC_Mark2_Part_Explode
+-------------------------
+*/
+void NPC_Mark2_Part_Explode( gentity_t *self, int bolt )
+{
+	if ( bolt >=0 )
+	{
+		mdxaBone_t	boltMatrix;
+		vec3_t		org, dir;
+
+		gi.G2API_GetBoltMatrix( self->ghoul2, self->playerModel, 
+					bolt,
+					&boltMatrix, self->currentAngles, self->currentOrigin, (cg.time?cg.time:level.time),
+					NULL, self->s.modelScale );
+
+		gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, org );
+		gi.G2API_GiveMeVectorFromMatrix( boltMatrix, NEGATIVE_Y, dir );
+
+		G_PlayEffect( "env/med_explode2", org, dir );
+		G_PlayEffect( G_EffectIndex("blaster/smoke_bolton"), self->playerModel, bolt, self->s.number, org);
+	}
+
+	self->count++;	// Count of pods blown off
+}
+
+/*
+-------------------------
+NPC_Mark2_Pain
+- look at what was hit and see if it should be removed from the model.
+-------------------------
+*/
+void NPC_Mark2_Pain( gentity_t *self, gentity_t *inflictor, gentity_t *other, const vec3_t point, int damage, int mod,int hitLoc ) 
+{
+	int newBolt,i;
+	
+	NPC_Pain( self, inflictor, other, point, damage, mod );
+
+	for (i=0;i<3;i++)
+	{
+		if ((hitLoc==HL_GENERIC1+i) && (self->locationDamage[HL_GENERIC1+i] > AMMO_POD_HEALTH))	// Blow it up?
+		{
+			if (self->locationDamage[hitLoc] >= AMMO_POD_HEALTH)
+			{			
+				newBolt = gi.G2API_AddBolt( &self->ghoul2[self->playerModel], va("torso_canister%d",(i+1)) );
+				if ( newBolt != -1 )
+				{
+					NPC_Mark2_Part_Explode(self,newBolt);
+				}
+				gi.G2API_SetSurfaceOnOff( &self->ghoul2[self->playerModel], va("torso_canister%d",(i+1)), TURN_OFF );
+				break;
+			}
+		}
+	}
+
+	G_Sound( self, G_SoundIndex( "sound/chars/mark2/misc/mark2_pain" ));
+
+	// If any pods were blown off, kill him
+	if (self->count > 0)
+	{
+		G_Damage( self, NULL, NULL, NULL, NULL, self->health, DAMAGE_NO_PROTECTION, MOD_UNKNOWN );
+	}
+}
+
+/*
+-------------------------
+Mark2_Hunt
+-------------------------
+*/
+void Mark2_Hunt(void)
+{
+	if ( NPCInfo->goalEntity == NULL )
+	{
+		NPCInfo->goalEntity = NPC->enemy;
+	}
+
+	// Turn toward him before moving towards him.
+	NPC_FaceEnemy( qtrue );
+
+	NPCInfo->combatMove = qtrue;
+	NPC_MoveToGoal( qtrue );
+}
+
+/*
+-------------------------
+Mark2_FireBlaster
+-------------------------
+*/
+void Mark2_FireBlaster(qboolean advance)
+{
+	vec3_t	muzzle1,enemy_org1,delta1,angleToEnemy1;
+	static	vec3_t	forward, vright, up;
+	static	vec3_t	muzzle;
+	gentity_t	*missile;
+	mdxaBone_t	boltMatrix;
+
+	gi.G2API_GetBoltMatrix( NPC->ghoul2, NPC->playerModel, 
+				NPC->genericBolt1,
+				&boltMatrix, NPC->currentAngles, NPC->currentOrigin, (cg.time?cg.time:level.time),
+				NULL, NPC->s.modelScale );
+
+	gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, muzzle1 );
+
+	if (NPC->health)
+	{
+		CalcEntitySpot( NPC->enemy, SPOT_HEAD, enemy_org1 );
+		VectorSubtract (enemy_org1, muzzle1, delta1);
+		vectoangles ( delta1, angleToEnemy1 );
+		AngleVectors (angleToEnemy1, forward, vright, up);
+	}
+	else
+	{
+		AngleVectors (NPC->currentAngles, forward, vright, up);
+	}
+
+	G_PlayEffect( "bryar/muzzle_flash", muzzle1, forward );
+
+	G_Sound( NPC, G_SoundIndex("sound/chars/mark2/misc/mark2_fire"));
+
+	missile = CreateMissile( muzzle1, forward, 1600, 10000, NPC );
+
+	missile->classname = "bryar_proj";
+	missile->s.weapon = WP_BRYAR_PISTOL;
+
+	missile->damage = 1;
+	missile->dflags = DAMAGE_DEATH_KNOCKBACK;
+	missile->methodOfDeath = MOD_ENERGY;
+	missile->clipmask = MASK_SHOT | CONTENTS_LIGHTSABER;
+
+}
+
+/*
+-------------------------
+Mark2_BlasterAttack
+-------------------------
+*/
+void Mark2_BlasterAttack(qboolean advance)
+{
+	if ( TIMER_Done( NPC, "attackDelay" ) )	// Attack?
+	{
+		if (NPCInfo->localState == LSTATE_NONE)	// He's up so shoot less often.
+		{
+			TIMER_Set( NPC, "attackDelay", Q_irand( 500, 2000) );
+		}
+		else
+		{
+			TIMER_Set( NPC, "attackDelay", Q_irand( 100, 500) );
+		}
+		Mark2_FireBlaster(advance);
+		return;
+	}
+	else if (advance)
+	{
+		Mark2_Hunt();
+	}
+}
+
+/*
+-------------------------
+Mark2_AttackDecision
+-------------------------
+*/
+void Mark2_AttackDecision( void )
+{
+	NPC_FaceEnemy( qtrue );
+
+	float		distance	= (int) DistanceHorizontalSquared( NPC->currentOrigin, NPC->enemy->currentOrigin );	
+	qboolean	visible		= NPC_ClearLOS( NPC->enemy );
+	qboolean	advance		= (qboolean)(distance > MIN_DISTANCE_SQR);
+
+	// He's been ordered to get up
+	if (NPCInfo->localState == LSTATE_RISINGUP)
+	{
+		NPC->flags &= ~FL_SHIELDED;
+		NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_RUN1START, SETANIM_FLAG_HOLD|SETANIM_FLAG_OVERRIDE );
+		if ((NPC->client->ps.legsAnimTimer==0) && 
+			NPC->client->ps.torsoAnim == BOTH_RUN1START )
+		{
+			NPCInfo->localState = LSTATE_NONE;	// He's up again.
+		}
+		return;
+	}
+
+	// If we cannot see our target, move to see it
+	if ((!visible) || (!NPC_FaceEnemy(qtrue)))
+	{
+		// If he's going down or is down, make him get up
+		if ((NPCInfo->localState == LSTATE_DOWN) || (NPCInfo->localState == LSTATE_DROPPINGDOWN))
+		{
+			if ( TIMER_Done( NPC, "downTime" ) )	// Down being down?? (The delay is so he doesn't pop up and down when the player goes in and out of range)
+			{
+				NPCInfo->localState = LSTATE_RISINGUP;
+				NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_RUN1STOP, SETANIM_FLAG_HOLD|SETANIM_FLAG_OVERRIDE );
+				TIMER_Set( NPC, "runTime", Q_irand( 3000, 8000) );	// So he runs for a while before testing to see if he should drop down.
+			}
+		}
+		else
+		{
+			Mark2_Hunt();
+		}
+		return;
+	}
+
+	// He's down but he could advance if he wants to.
+	if ((advance) && (TIMER_Done( NPC, "downTime" )) && (NPCInfo->localState == LSTATE_DOWN))
+	{
+		NPCInfo->localState = LSTATE_RISINGUP;
+		NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_RUN1STOP, SETANIM_FLAG_HOLD|SETANIM_FLAG_OVERRIDE );
+		TIMER_Set( NPC, "runTime", Q_irand( 3000, 8000) );	// So he runs for a while before testing to see if he should drop down.
+	}
+
+	NPC_FaceEnemy( qtrue );
+
+	// Dropping down to shoot
+	if (NPCInfo->localState == LSTATE_DROPPINGDOWN)
+	{
+		NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_RUN1STOP, SETANIM_FLAG_HOLD|SETANIM_FLAG_OVERRIDE );
+		TIMER_Set( NPC, "downTime", Q_irand( 3000, 9000) );
+
+		if ((NPC->client->ps.legsAnimTimer==0) && NPC->client->ps.torsoAnim == BOTH_RUN1STOP )
+		{
+			NPC->flags |= FL_SHIELDED;
+			NPCInfo->localState = LSTATE_DOWN;
+		}
+	}
+	// He's down and shooting
+	else if (NPCInfo->localState == LSTATE_DOWN)
+	{
+//		NPC->flags |= FL_SHIELDED;//only damagable by lightsabers and missiles
+
+		Mark2_BlasterAttack(qfalse);
+	}
+	else if (TIMER_Done( NPC, "runTime" ))	// Lowering down to attack. But only if he's done running at you.
+	{
+		NPCInfo->localState = LSTATE_DROPPINGDOWN;
+	}
+	else if (advance)
+	{
+		// We can see enemy so shoot him if timer lets you.
+		Mark2_BlasterAttack(advance);
+	}
+}
+
+
+/*
+-------------------------
+Mark2_Patrol
+-------------------------
+*/
+void Mark2_Patrol( void )
+{
+	if ( NPC_CheckPlayerTeamStealth() )
+	{
+//		G_Sound( NPC, G_SoundIndex("sound/chars/mark1/misc/anger.wav"));
+		NPC_UpdateAngles( qtrue, qtrue );
+		return;
+	}
+
+	//If we have somewhere to go, then do that
+	if (!NPC->enemy)
+	{
+		if ( UpdateGoal() )
+		{
+			ucmd.buttons |= BUTTON_WALKING;
+			NPC_MoveToGoal( qtrue );
+			NPC_UpdateAngles( qtrue, qtrue );
+		}
+
+		//randomly talk
+		if (TIMER_Done(NPC,"patrolNoise"))
+		{
+//			G_Sound( NPC, G_SoundIndex(va("sound/chars/mark1/misc/talk%d.wav",	Q_irand(1, 4))));
+
+			TIMER_Set( NPC, "patrolNoise", Q_irand( 2000, 4000 ) );
+		}
+	}
+}
+
+/*
+-------------------------
+Mark2_Idle
+-------------------------
+*/
+void Mark2_Idle( void )
+{
+	NPC_BSIdle();
+}
+
+/*
+-------------------------
+NPC_BSMark2_Default
+-------------------------
+*/
+void NPC_BSMark2_Default( void )
+{
+	if ( NPC->enemy )
+	{
+		NPCInfo->goalEntity = NPC->enemy;
+		Mark2_AttackDecision();
+	}
+	else if ( NPCInfo->scriptFlags & SCF_LOOK_FOR_ENEMIES )
+	{
+		Mark2_Patrol();
+	}
+	else
+	{
+		Mark2_Idle();
+	}
+}
diff --git a/code/game/AI_MineMonster.cpp b/code/game/AI_MineMonster.cpp
new file mode 100644
index 0000000..c00006d
--- /dev/null
+++ b/code/game/AI_MineMonster.cpp
@@ -0,0 +1,269 @@
+// leave this line at the top of all AI_xxxx.cpp files for PCH reasons...
+#include "g_headers.h"
+
+	    
+#include "b_local.h"
+
+
+// These define the working combat range for these suckers
+#define MIN_DISTANCE		54
+#define MIN_DISTANCE_SQR	( MIN_DISTANCE * MIN_DISTANCE )
+
+#define MAX_DISTANCE		128
+#define MAX_DISTANCE_SQR	( MAX_DISTANCE * MAX_DISTANCE )
+
+#define LSTATE_CLEAR		0
+#define LSTATE_WAITING		1
+
+/*
+-------------------------
+NPC_MineMonster_Precache
+-------------------------
+*/
+void NPC_MineMonster_Precache( void )
+{
+	for ( int i = 0; i < 4; i++ )
+	{
+		G_SoundIndex( va("sound/chars/mine/misc/bite%i.wav", i+1 ));
+		G_SoundIndex( va("sound/chars/mine/misc/miss%i.wav", i+1 ));
+	}
+}
+
+
+/*
+-------------------------
+MineMonster_Idle
+-------------------------
+*/
+void MineMonster_Idle( void )
+{
+	if ( UpdateGoal() )
+	{
+		ucmd.buttons &= ~BUTTON_WALKING;
+		NPC_MoveToGoal( qtrue );
+	}
+}
+
+
+/*
+-------------------------
+MineMonster_Patrol
+-------------------------
+*/
+void MineMonster_Patrol( void )
+{
+	NPCInfo->localState = LSTATE_CLEAR;
+
+	//If we have somewhere to go, then do that
+	if ( UpdateGoal() )
+	{
+		ucmd.buttons &= ~BUTTON_WALKING;
+		NPC_MoveToGoal( qtrue );
+	}
+
+	vec3_t dif;
+	VectorSubtract( g_entities[0].currentOrigin, NPC->currentOrigin, dif );
+
+	if ( VectorLengthSquared( dif ) < 256 * 256 )
+	{
+		G_SetEnemy( NPC, &g_entities[0] );
+	}
+
+	if ( NPC_CheckEnemyExt( qtrue ) == qfalse )
+	{
+		MineMonster_Idle();
+		return;
+	}
+}
+ 
+/*
+-------------------------
+MineMonster_Move
+-------------------------
+*/
+void MineMonster_Move( qboolean visible )
+{
+	if ( NPCInfo->localState != LSTATE_WAITING )
+	{
+		NPCInfo->goalEntity = NPC->enemy;
+		NPC_MoveToGoal( qtrue );
+		NPCInfo->goalRadius = MAX_DISTANCE;	// just get us within combat range
+	}
+}
+
+//---------------------------------------------------------
+void MineMonster_TryDamage( gentity_t *enemy, int damage )
+{
+	vec3_t	end, dir;
+	trace_t	tr;
+
+	if ( !enemy )
+	{
+		return;
+	}
+
+	AngleVectors( NPC->client->ps.viewangles, dir, NULL, NULL );
+	VectorMA( NPC->currentOrigin, MIN_DISTANCE, dir, end );
+
+	// Should probably trace from the mouth, but, ah well.
+	gi.trace( &tr, NPC->currentOrigin, vec3_origin, vec3_origin, end, NPC->s.number, MASK_SHOT );
+
+	if ( tr.entityNum >= 0 && tr.entityNum < ENTITYNUM_NONE )
+	{
+		G_Damage( &g_entities[tr.entityNum], NPC, NPC, dir, tr.endpos, damage, DAMAGE_NO_KNOCKBACK, MOD_MELEE );
+		G_SoundOnEnt( NPC, CHAN_VOICE_ATTEN, va("sound/chars/mine/misc/bite%i.wav", Q_irand(1,4)));
+	}
+	else
+	{
+		G_SoundOnEnt( NPC, CHAN_VOICE_ATTEN, va("sound/chars/mine/misc/miss%i.wav", Q_irand(1,4)));
+	}
+}
+
+//------------------------------
+void MineMonster_Attack( void )
+{
+	if ( !TIMER_Exists( NPC, "attacking" ))
+	{
+		// usually try and play a jump attack if the player somehow got above them....or just really rarely
+		if ( NPC->enemy && ((NPC->enemy->currentOrigin[2] - NPC->currentOrigin[2] > 10 && random() > 0.1f ) 
+						|| random() > 0.8f ))
+		{
+			// Going to do ATTACK4
+			TIMER_Set( NPC, "attacking", 1750 + random() * 200 );
+			NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_ATTACK4, SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLD );
+
+			TIMER_Set( NPC, "attack2_dmg", 950 ); // level two damage
+		}
+		else if ( random() > 0.5f )
+		{
+			if ( random() > 0.8f )
+			{
+				// Going to do ATTACK3, (rare)
+				TIMER_Set( NPC, "attacking", 850 );
+				NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_ATTACK3, SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLD );
+
+				TIMER_Set( NPC, "attack2_dmg", 400 ); // level two damage
+			}
+			else
+			{
+				// Going to do ATTACK1
+				TIMER_Set( NPC, "attacking", 850 );
+				NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_ATTACK1, SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLD );
+
+				TIMER_Set( NPC, "attack1_dmg", 450 ); // level one damage
+			}
+		}
+		else
+		{
+			// Going to do ATTACK2
+			TIMER_Set( NPC, "attacking", 1250 );
+			NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_ATTACK2, SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLD );
+
+			TIMER_Set( NPC, "attack1_dmg", 700 ); // level one damage
+		}
+	}
+	else
+	{
+		// Need to do delayed damage since the attack animations encapsulate multiple mini-attacks
+		if ( TIMER_Done2( NPC, "attack1_dmg", qtrue ))
+		{
+			MineMonster_TryDamage( NPC->enemy, 5 );
+		}
+		else if ( TIMER_Done2( NPC, "attack2_dmg", qtrue ))
+		{
+			MineMonster_TryDamage( NPC->enemy, 10 );
+		}
+	}
+
+	// Just using this to remove the attacking flag at the right time
+	TIMER_Done2( NPC, "attacking", qtrue );
+}
+
+//----------------------------------
+void MineMonster_Combat( void )
+{
+	// If we cannot see our target or we have somewhere to go, then do that
+	if ( !NPC_ClearLOS( NPC->enemy ) || UpdateGoal( ))
+	{
+		NPCInfo->combatMove = qtrue;
+		NPCInfo->goalEntity = NPC->enemy;
+		NPCInfo->goalRadius = MAX_DISTANCE;	// just get us within combat range
+
+		NPC_MoveToGoal( qtrue );
+		return;
+	}
+
+	// Sometimes I have problems with facing the enemy I'm attacking, so force the issue so I don't look dumb
+	NPC_FaceEnemy( qtrue );
+
+	float	distance	= DistanceHorizontalSquared( NPC->currentOrigin, NPC->enemy->currentOrigin );	
+
+	qboolean	advance = (qboolean)( distance > MIN_DISTANCE_SQR ? qtrue : qfalse  );
+
+	if (( advance || NPCInfo->localState == LSTATE_WAITING ) && TIMER_Done( NPC, "attacking" )) // waiting monsters can't attack
+	{
+		if ( TIMER_Done2( NPC, "takingPain", qtrue ))
+		{
+			NPCInfo->localState = LSTATE_CLEAR;
+		}
+		else
+		{
+			MineMonster_Move( 1 );
+		}
+	}
+	else
+	{
+		MineMonster_Attack();
+	}
+}
+
+/*
+-------------------------
+NPC_MineMonster_Pain
+-------------------------
+*/
+void NPC_MineMonster_Pain( gentity_t *self, gentity_t *inflictor, gentity_t *other, const vec3_t point, int damage, int mod,int hitLoc ) 
+{
+	G_AddEvent( self, EV_PAIN, floor((float)self->health/self->max_health*100.0f) );
+
+	if ( damage >= 10 )
+	{
+		TIMER_Remove( self, "attacking" );
+		TIMER_Remove( self, "attacking1_dmg" );
+		TIMER_Remove( self, "attacking2_dmg" );
+		TIMER_Set( self, "takingPain", 1350 );
+
+		VectorCopy( self->NPC->lastPathAngles, self->s.angles );
+
+		NPC_SetAnim( self, SETANIM_BOTH, BOTH_PAIN1, SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLD );
+
+		if ( self->NPC )
+		{
+			self->NPC->localState = LSTATE_WAITING;
+		}
+	}
+}
+
+
+/*
+-------------------------
+NPC_BSMineMonster_Default
+-------------------------
+*/
+void NPC_BSMineMonster_Default( void )
+{
+	if ( NPC->enemy )
+	{
+		MineMonster_Combat();
+	}
+	else if ( NPCInfo->scriptFlags & SCF_LOOK_FOR_ENEMIES )
+	{
+		MineMonster_Patrol();
+	}
+	else
+	{
+		MineMonster_Idle();
+	}
+
+	NPC_UpdateAngles( qtrue, qtrue );
+}
diff --git a/code/game/AI_Rancor.cpp b/code/game/AI_Rancor.cpp
new file mode 100644
index 0000000..fea3c4f
--- /dev/null
+++ b/code/game/AI_Rancor.cpp
@@ -0,0 +1,1684 @@
+// leave this line at the top of all AI_xxxx.cpp files for PCH reasons...
+#include "g_headers.h"
+
+	    
+#include "b_local.h"
+
+// These define the working combat range for these suckers
+#define MIN_DISTANCE		128
+#define MIN_DISTANCE_SQR	( MIN_DISTANCE * MIN_DISTANCE )
+
+#define MAX_DISTANCE		1024
+#define MAX_DISTANCE_SQR	( MAX_DISTANCE * MAX_DISTANCE )
+
+#define LSTATE_CLEAR		0
+#define LSTATE_WAITING		1
+
+#define SPF_RANCOR_MUTANT	1
+#define SPF_RANCOR_FASTKILL	2
+
+extern qboolean G_EntIsBreakable( int entityNum, gentity_t *breaker );
+extern cvar_t	*g_dismemberment;
+extern cvar_t	*g_bobaDebug;
+
+void Rancor_Attack( float distance, qboolean doCharge, qboolean aimAtBlockedEntity );
+/*
+-------------------------
+NPC_Rancor_Precache
+-------------------------
+*/
+void NPC_Rancor_Precache( void )
+{
+	int i;
+	for ( i = 1; i < 5; i ++ )
+	{
+		G_SoundIndex( va("sound/chars/rancor/snort_%d.wav", i) );
+	}
+	G_SoundIndex( "sound/chars/rancor/swipehit.wav" );
+	G_SoundIndex( "sound/chars/rancor/chomp.wav" );
+}
+
+void NPC_MutantRancor_Precache( void )
+{
+	G_SoundIndex( "sound/chars/rancor/breath_start.wav" );
+	G_SoundIndex( "sound/chars/rancor/breath_loop.wav" );
+	G_EffectIndex( "mrancor/breath" );
+}
+//FIXME: initialize all my timers
+
+qboolean Rancor_CheckAhead( vec3_t end )
+{
+	trace_t	trace;
+	int clipmask = NPC->clipmask|CONTENTS_BOTCLIP;
+
+	//make sure our goal isn't underground (else the trace will fail)
+	vec3_t	bottom = {end[0],end[1],end[2]+NPC->mins[2]};
+	gi.trace( &trace, end, vec3_origin, vec3_origin, bottom, NPC->s.number, NPC->clipmask );
+	if ( trace.fraction < 1.0f )
+	{//in the ground, raise it up
+		end[2] -= NPC->mins[2]*(1.0f-trace.fraction)-0.125f;
+	}
+
+	gi.trace( &trace, NPC->currentOrigin, NPC->mins, NPC->maxs, end, NPC->s.number, clipmask );
+
+	if ( trace.startsolid&&(trace.contents&CONTENTS_BOTCLIP) )
+	{//started inside do not enter, so ignore them
+		clipmask &= ~CONTENTS_BOTCLIP;
+		gi.trace( &trace, NPC->currentOrigin, NPC->mins, NPC->maxs, end, NPC->s.number, clipmask );
+	}
+	//Do a simple check
+	if ( ( trace.allsolid == qfalse ) && ( trace.startsolid == qfalse ) && ( trace.fraction == 1.0f ) )
+		return qtrue;
+
+	if ( trace.entityNum < ENTITYNUM_WORLD
+		&& G_EntIsBreakable( trace.entityNum, NPC ) )
+	{//breakable brush in our way, break it
+	//	NPCInfo->blockedEntity = &g_entities[trace.entityNum];
+		return qtrue;
+	}
+
+	//Aw screw it, always try to go straight at him if we can at all
+	if ( trace.fraction >= 0.25f )
+		return qtrue;
+
+	//FIXME: if something in the way that's not the world, set blocked ent
+	return qfalse;
+}
+
+/*
+-------------------------
+Rancor_Idle
+-------------------------
+*/
+void Rancor_Idle( void )
+{
+	NPCInfo->localState = LSTATE_CLEAR;
+
+	//If we have somewhere to go, then do that
+	if ( UpdateGoal() )
+	{
+		ucmd.buttons &= ~BUTTON_WALKING;
+		NPC_MoveToGoal( qtrue );
+	}
+}
+
+
+qboolean Rancor_CheckRoar( gentity_t *self )
+{
+	if ( !self->wait )
+	{//haven't ever gotten mad yet
+		self->wait = 1;//do this only once
+		NPC_SetAnim( self, SETANIM_BOTH, BOTH_STAND1TO2, SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLD );
+		TIMER_Set( self, "rageTime", self->client->ps.legsAnimTimer );
+		return qtrue;
+	}
+	return qfalse;
+}
+/*
+-------------------------
+Rancor_Patrol
+-------------------------
+*/
+void Rancor_Patrol( void )
+{
+	NPCInfo->localState = LSTATE_CLEAR;
+
+	//If we have somewhere to go, then do that
+	if ( UpdateGoal() )
+	{
+		ucmd.buttons &= ~BUTTON_WALKING;
+		NPC_MoveToGoal( qtrue );
+	}
+
+	if ( NPC_CheckEnemyExt( qtrue ) == qfalse )
+	{
+		Rancor_Idle();
+		return;
+	}
+	Rancor_CheckRoar( NPC );
+	TIMER_Set( NPC, "lookForNewEnemy", Q_irand( 5000, 15000 ) );
+}
+ 
+/*
+-------------------------
+Rancor_Move
+-------------------------
+*/
+void Rancor_Move( qboolean visible )
+{
+	if ( NPCInfo->localState != LSTATE_WAITING )
+	{
+		NPCInfo->goalEntity = NPC->enemy;
+		NPCInfo->goalRadius = NPC->maxs[0]+(MIN_DISTANCE*NPC->s.modelScale[0]);	// just get us within combat range
+		//FIXME: for some reason, if NPC_MoveToGoal fails, it sets my angles to my lastPathAngles, which I don't want
+		float savYaw = NPCInfo->desiredYaw;
+		bool	savWalking = !!(ucmd.buttons&BUTTON_WALKING);
+		if ( !NPC_MoveToGoal( qtrue ) )
+		{//can't macro-nav, just head right for him
+			//FIXME: if something in the way that's not the world, set blocked ent
+			vec3_t dest;
+			VectorCopy( NPCInfo->goalEntity->currentOrigin, dest );
+			if ( Rancor_CheckAhead( dest ) )
+			{//use our temp move straight to goal check
+				if (!savWalking)
+				{
+					ucmd.buttons &= ~BUTTON_WALKING;				// Unset from MoveToGoal()
+				}
+				STEER::Activate(NPC);
+				STEER::Seek(NPC, dest);
+				STEER::AvoidCollisions(NPC);
+				STEER::DeActivate(NPC, &ucmd);
+				/*
+				VectorSubtract( dest, NPC->currentOrigin, NPC->client->ps.moveDir );
+				NPC->client->ps.speed = VectorNormalize( NPC->client->ps.moveDir );
+				NPCInfo->desiredYaw = vectoyaw( NPC->client->ps.moveDir );
+				if ( (ucmd.buttons&BUTTON_WALKING) && NPC->client->ps.speed > NPCInfo->stats.walkSpeed )
+				{
+					NPC->client->ps.speed = NPCInfo->stats.walkSpeed;
+				}
+				else
+				{
+					if ( NPC->client->ps.speed < NPCInfo->stats.walkSpeed )
+					{
+						NPC->client->ps.speed = NPCInfo->stats.walkSpeed;
+					}
+					if ( !(ucmd.buttons&BUTTON_WALKING) && NPC->client->ps.speed < NPCInfo->stats.runSpeed )
+					{
+						NPC->client->ps.speed = NPCInfo->stats.runSpeed;
+					}
+					else if ( NPC->client->ps.speed > NPCInfo->stats.runSpeed )
+					{
+						NPC->client->ps.speed = NPCInfo->stats.runSpeed;
+					}
+				}
+				*/
+			}
+			else
+			{//all else fails, look at him
+			//	gi.Printf("Fail\n");
+				NPCInfo->lockedDesiredYaw = NPCInfo->desiredYaw = savYaw;
+			/*	if ( !NPCInfo->blockedEntity )
+				{//not already trying to break a breakable somewhere
+					if ( NPC->enemy && NPC->enemy->client && NPC->enemy->client->ps.groundEntityNum < ENTITYNUM_WORLD )
+					{//hmm, maybe he's on a breakable brush?
+						if ( G_EntIsBreakable( NPC->enemy->client->ps.groundEntityNum, NPC ) )
+						{//break it!
+							gentity_t *breakable = &g_entities[NPC->enemy->client->ps.groundEntityNum];
+							int		sanityCheck = 0;
+							//FiXME: and if he's on a stack of 3 breakables?
+							//FIXME: See if the breakable has a targetname, if so see if the thing targeting it is a breakable, if so, etc...
+							while ( sanityCheck < 20 && breakable && breakable->targetname )
+							{
+								gentity_t *breakableNext = NULL;
+								while ( sanityCheck < 20 && (breakableNext = G_Find( breakableNext, FOFS(target), breakable->targetname )) != NULL )
+								{
+									if ( breakableNext && G_EntIsBreakable( breakableNext->s.number, NPC ) )
+									{
+										breakable = breakableNext;
+										break;
+									}
+									else
+									{
+										sanityCheck++;
+									}
+								}
+								if ( !breakableNext )
+								{//not targetted by another breakable that we can break
+									break;
+								}
+								else
+								{
+									sanityCheck++;
+								}
+							}
+							NPCInfo->blockedEntity = breakable;
+						}
+					}
+				}*/
+				if ( !NPCInfo->blockedEntity && NPC->enemy && gi.inPVS(NPC->currentOrigin, NPC->enemy->currentOrigin))
+				{//nothing to destroy?  just go straight at goal dest
+					qboolean horzClose = qfalse;
+					if (!savWalking)
+					{
+						ucmd.buttons &= ~BUTTON_WALKING;				// Unset from MoveToGoal()
+					}
+
+					if ( DistanceHorizontal( NPC->enemy->currentOrigin, NPC->currentOrigin ) < (NPC->maxs[0]+(MIN_DISTANCE*NPC->s.modelScale[0])) )
+					{//close, just look at him
+						horzClose = qtrue;
+						NPC_FaceEnemy( qtrue );
+					}
+					else
+					{//try to move  towards him
+						STEER::Activate(NPC);
+						STEER::Seek(NPC, dest);
+						STEER::AvoidCollisions(NPC);
+						STEER::DeActivate(NPC, &ucmd);
+					}
+					//let him know he should attack at random out of frustration?
+					if ( NPCInfo->goalEntity == NPC->enemy )
+					{
+						if ( TIMER_Done( NPC, "attacking" ) 
+							&& TIMER_Done( NPC, "frustrationAttack" ) )
+						{
+							float enemyDist = Distance( dest, NPC->currentOrigin );
+							if ( (!horzClose||!Q_irand(0,5))
+								&& Q_irand( 0, 1 ) )
+							{
+								Rancor_Attack( enemyDist, qtrue, qfalse );
+							}
+							else
+							{
+								Rancor_Attack( enemyDist, qfalse, qfalse );
+							}
+							if ( horzClose )
+							{
+								TIMER_Set( NPC, "frustrationAttack", Q_irand( 2000, 5000 ) );
+							}
+							else
+							{
+								TIMER_Set( NPC, "frustrationAttack", Q_irand( 5000, 15000 ) );
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+//---------------------------------------------------------
+extern void G_Knockdown( gentity_t *self, gentity_t *attacker, const vec3_t pushDir, float strength, qboolean breakSaberLock );
+extern qboolean G_DoDismemberment( gentity_t *self, vec3_t point, int mod, int damage, int hitLoc, qboolean force = qfalse );
+extern float NPC_EntRangeFromBolt( gentity_t *targEnt, int boltIndex );
+extern int NPC_GetEntsNearBolt( gentity_t **radiusEnts, float radius, int boltIndex, vec3_t boltOrg );
+
+void Rancor_DropVictim( gentity_t *self )
+{
+	//FIXME: if Rancor dies, it should drop its victim.
+	//FIXME: if Rancor is removed, it must remove its victim.
+	//FIXME: if in BOTH_HOLD_DROP, throw them a little, too?
+	if ( self->activator )
+	{
+		if ( self->activator->client )
+		{
+			self->activator->client->ps.eFlags &= ~EF_HELD_BY_RANCOR;
+		}
+		self->activator->activator = NULL;
+		if ( self->activator->health <= 0 )
+		{
+			if ( self->activator->s.number )
+			{//never free player
+				if ( self->count == 1 )
+				{//in my hand, just drop them
+					if ( self->activator->client )
+					{
+						self->activator->client->ps.legsAnimTimer = self->activator->client->ps.torsoAnimTimer = 0;
+						//FIXME: ragdoll?
+					}
+				}
+				else
+				{
+					G_FreeEntity( self->activator );
+				}
+			}
+			else
+			{
+				self->activator->s.eFlags |= EF_NODRAW;
+				if ( self->activator->client )
+				{
+					self->activator->client->ps.eFlags |= EF_NODRAW;
+				}
+				self->activator->clipmask &= ~CONTENTS_BODY;
+			}
+		}
+		else
+		{
+			if ( self->activator->NPC )
+			{//start thinking again
+				self->activator->NPC->nextBStateThink = level.time;
+			}
+			//clear their anim and let them fall
+			self->activator->client->ps.legsAnimTimer = self->activator->client->ps.torsoAnimTimer = 0;
+		}
+		if ( self->enemy == self->activator )
+		{
+			self->enemy = NULL;
+		}
+		if ( self->activator->s.number == 0 )
+		{//don't attack the player again for a bit
+			TIMER_Set( self, "attackDebounce", Q_irand( 2000, 4000+((2-g_spskill->integer)*2000) ) );
+		}
+		self->activator = NULL;
+	}
+	self->count = 0;//drop him
+}
+
+void Rancor_Swing( int boltIndex, qboolean tryGrab )
+{
+	gentity_t	*radiusEnts[ 128 ];
+	int			numEnts;
+	const float	radius = (NPC->spawnflags&SPF_RANCOR_MUTANT)?200:88;
+	const float	radiusSquared = (radius*radius);
+	int			i;
+	vec3_t		boltOrg;
+	vec3_t		originUp;
+
+	VectorCopy(NPC->currentOrigin, originUp);
+	originUp[2] += (NPC->maxs[2]*0.75f);
+
+	numEnts = NPC_GetEntsNearBolt( radiusEnts, radius, boltIndex, boltOrg );
+
+	//if ( NPCInfo->blockedEntity && G_EntIsBreakable( NPCInfo->blockedEntity->s.number, NPC ) )
+	{//attacking a breakable brush
+		//HMM... maybe always do this?
+		//if boltOrg inside a breakable brush, damage it
+		trace_t trace;
+		gi.trace( &trace, NPC->pos3, vec3_origin, vec3_origin, boltOrg, NPC->s.number, CONTENTS_SOLID|CONTENTS_BODY );
+#ifndef FINAL_BUILD
+		if ( g_bobaDebug->integer > 0 )
+		{
+			G_DebugLine(NPC->pos3, boltOrg, 1000, 0x000000ff, qtrue);
+		}
+#endif
+		//remember pos3 for the trace from last hand pos to current hand pos next time
+		VectorCopy( boltOrg, NPC->pos3 );
+		//FIXME: also do a trace TO the bolt from where we are...?
+		if ( G_EntIsBreakable( trace.entityNum, NPC ) )
+		{
+			G_Damage( &g_entities[trace.entityNum], NPC, NPC, vec3_origin, boltOrg, 100, 0, MOD_MELEE );
+		}
+		else
+		{//fuck, do an actual line trace, I guess...
+			gi.trace( &trace, originUp, vec3_origin, vec3_origin, boltOrg, NPC->s.number, CONTENTS_SOLID|CONTENTS_BODY );
+#ifndef FINAL_BUILD
+			if ( g_bobaDebug->integer > 0 )
+			{
+				G_DebugLine(originUp, boltOrg, 1000, 0x000000ff, qtrue);
+			}
+#endif
+			if ( G_EntIsBreakable( trace.entityNum, NPC ) )
+			{
+				G_Damage( &g_entities[trace.entityNum], NPC, NPC, vec3_origin, boltOrg, 200, 0, MOD_MELEE );
+			}
+		}
+	}
+
+	for ( i = 0; i < numEnts; i++ )
+	{
+		if ( !radiusEnts[i]->inuse )
+		{
+			continue;
+		}
+		
+		if ( radiusEnts[i] == NPC )
+		{//Skip the rancor ent
+			continue;
+		}
+		
+		if ( radiusEnts[i]->client == NULL )
+		{//must be a client
+			continue;
+		}
+
+		if ( (radiusEnts[i]->client->ps.eFlags&EF_HELD_BY_RANCOR) 
+			||(radiusEnts[i]->client->ps.eFlags&EF_HELD_BY_WAMPA) )
+		{//can't be one already being held
+			continue;
+		}
+
+		if ( (radiusEnts[i]->s.eFlags&EF_NODRAW) )
+		{//not if invisible
+			continue;
+		}
+		/*
+		if ( !radiusEnts[i]->contents )
+		{//not if non-solid
+			continue;
+		}
+		*/
+		
+		if ( DistanceSquared( radiusEnts[i]->currentOrigin, boltOrg ) <= radiusSquared )
+		{
+			if ( !gi.inPVS( radiusEnts[i]->currentOrigin, NPC->currentOrigin ) )
+			{//don't grab anything that's in another PVS
+				continue;
+			}
+			/*
+			qboolean skipGrab = qfalse;
+			if ( tryGrab//want to grab
+				&& (NPC->spawnflags&SPF_RANCOR_FASTKILL)//mutant rancor
+				&& radiusEnts[i]->s.number >= MAX_CLIENTS //not the player
+				&& Q_irand( 0, 1 ) )//50% chance
+			{//don't grab them, just smack them away
+				skipGrab = qtrue;
+			}
+			*/
+			if ( tryGrab 
+				//&& !skipGrab
+				&& NPC->count != 1 //don't have one in hand or in mouth already - FIXME: allow one in hand and any number in mouth!
+				&& radiusEnts[i]->client->NPC_class != CLASS_RANCOR
+				&& radiusEnts[i]->client->NPC_class != CLASS_GALAKMECH
+				&& radiusEnts[i]->client->NPC_class != CLASS_ATST
+				&& radiusEnts[i]->client->NPC_class != CLASS_GONK
+				&& radiusEnts[i]->client->NPC_class != CLASS_R2D2
+				&& radiusEnts[i]->client->NPC_class != CLASS_R5D2
+				&& radiusEnts[i]->client->NPC_class != CLASS_MARK1
+				&& radiusEnts[i]->client->NPC_class != CLASS_MARK2
+				&& radiusEnts[i]->client->NPC_class != CLASS_MOUSE
+				&& radiusEnts[i]->client->NPC_class != CLASS_PROBE
+				&& radiusEnts[i]->client->NPC_class != CLASS_SEEKER
+				&& radiusEnts[i]->client->NPC_class != CLASS_REMOTE
+				&& radiusEnts[i]->client->NPC_class != CLASS_SENTRY
+				&& radiusEnts[i]->client->NPC_class != CLASS_INTERROGATOR
+				&& radiusEnts[i]->client->NPC_class != CLASS_VEHICLE )
+			{//grab
+				if ( NPC->count == 2 )
+				{//have one in my mouth, remove him
+					TIMER_Remove( NPC, "clearGrabbed" );
+					Rancor_DropVictim( NPC );
+				}
+				NPC->enemy = radiusEnts[i];//make him my new best friend
+				radiusEnts[i]->client->ps.eFlags |= EF_HELD_BY_RANCOR;
+				//FIXME: this makes it so that the victim can't hit us with shots!  Just use activator or something
+				radiusEnts[i]->activator = NPC; // kind of dumb, but when we are locked to the Rancor, we are owned by it.
+				NPC->activator = radiusEnts[i];//remember him
+				NPC->count = 1;//in my hand
+				//wait to attack
+				TIMER_Set( NPC, "attacking", NPC->client->ps.legsAnimTimer + Q_irand(500, 2500) );
+				if ( radiusEnts[i]->health > 0 )
+				{//do pain on enemy
+					GEntity_PainFunc( radiusEnts[i], NPC, NPC, radiusEnts[i]->currentOrigin, 0, MOD_CRUSH );
+				}
+				else if ( radiusEnts[i]->client )
+				{
+					NPC_SetAnim( radiusEnts[i], SETANIM_BOTH, BOTH_SWIM_IDLE1, SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLD );
+				}
+			}
+			else
+			{//smack
+				G_Sound( radiusEnts[i], G_SoundIndex( "sound/chars/rancor/swipehit.wav" ) );
+				//actually push the enemy
+				vec3_t pushDir;
+				/*
+				//VectorSubtract( radiusEnts[i]->currentOrigin, boltOrg, pushDir );
+				VectorSubtract( radiusEnts[i]->currentOrigin, NPC->currentOrigin, pushDir );
+				pushDir[2] = Q_flrand( 100, 200 );
+				VectorNormalize( pushDir );
+				*/
+				if ( (NPC->spawnflags&SPF_RANCOR_FASTKILL) 
+					&& radiusEnts[i]->s.number >= MAX_CLIENTS )
+				{
+					G_Damage( radiusEnts[i], NPC, NPC, vec3_origin, boltOrg, radiusEnts[i]->health+1000, (DAMAGE_NO_KNOCKBACK|DAMAGE_NO_PROTECTION), MOD_MELEE );
+				}
+				vec3_t angs;
+				VectorCopy( NPC->client->ps.viewangles, angs );
+				angs[YAW] += Q_flrand( 25, 50 );
+				angs[PITCH] = Q_flrand( -25, -15 );
+				AngleVectors( angs, pushDir, NULL, NULL );
+				if ( radiusEnts[i]->client->NPC_class != CLASS_RANCOR
+					&& radiusEnts[i]->client->NPC_class != CLASS_ATST
+					&& !(radiusEnts[i]->flags&FL_NO_KNOCKBACK) )
+				{
+					G_Throw( radiusEnts[i], pushDir, 250 );
+					if ( radiusEnts[i]->health > 0 )
+					{//do pain on enemy
+						G_Knockdown( radiusEnts[i], NPC, pushDir, 100, qtrue );
+					}
+				}
+			}
+		}
+	}
+}
+
+void Rancor_Smash( void )
+{
+	gentity_t	*radiusEnts[ 128 ];
+	int			numEnts;
+	const float	radius = (NPC->spawnflags&SPF_RANCOR_MUTANT)?256:128;
+	const float	halfRadSquared = ((radius/2)*(radius/2));
+	const float	radiusSquared = (radius*radius);
+	float		distSq;
+	int			i;
+	vec3_t		boltOrg;
+
+	AddSoundEvent( NPC, NPC->currentOrigin, 512, AEL_DANGER, qfalse, qtrue );
+
+	numEnts = NPC_GetEntsNearBolt( radiusEnts, radius, NPC->handLBolt, boltOrg );
+
+	//if ( NPCInfo->blockedEntity && G_EntIsBreakable( NPCInfo->blockedEntity->s.number, NPC ) )
+	{//attacking a breakable brush
+		//HMM... maybe always do this?
+		//if boltOrg inside a breakable brush, damage it
+		trace_t trace;
+		gi.trace( &trace, boltOrg, vec3_origin, vec3_origin, NPC->pos3, NPC->s.number, CONTENTS_SOLID|CONTENTS_BODY );
+#ifndef FINAL_BUILD
+		if ( g_bobaDebug->integer > 0 )
+		{
+			G_DebugLine(NPC->pos3, boltOrg, 1000, 0x000000ff, qtrue);
+		}
+#endif
+		//remember pos3 for the trace from last hand pos to current hand pos next time
+		VectorCopy( boltOrg, NPC->pos3 );
+		//FIXME: also do a trace TO the bolt from where we are...?
+		if ( G_EntIsBreakable( trace.entityNum, NPC ) )
+		{
+			G_Damage( &g_entities[trace.entityNum], NPC, NPC, vec3_origin, boltOrg, 200, 0, MOD_MELEE );
+		}
+		else
+		{//fuck, do an actual line trace, I guess...
+			gi.trace( &trace, NPC->currentOrigin, vec3_origin, vec3_origin, boltOrg, NPC->s.number, CONTENTS_SOLID|CONTENTS_BODY );
+#ifndef FINAL_BUILD
+			if ( g_bobaDebug->integer > 0 )
+			{
+				G_DebugLine(NPC->currentOrigin, boltOrg, 1000, 0x000000ff, qtrue);
+			}
+#endif
+			if ( G_EntIsBreakable( trace.entityNum, NPC ) )
+			{
+				G_Damage( &g_entities[trace.entityNum], NPC, NPC, vec3_origin, boltOrg, 200, 0, MOD_MELEE );
+			}
+		}
+	}
+
+	for ( i = 0; i < numEnts; i++ )
+	{
+		if ( !radiusEnts[i]->inuse )
+		{
+			continue;
+		}
+		
+		if ( radiusEnts[i] == NPC )
+		{//Skip the rancor ent
+			continue;
+		}
+		
+		if ( radiusEnts[i]->client == NULL )
+		{//must be a client
+			if ( G_EntIsBreakable( radiusEnts[i]->s.number, NPC ) )
+			{//damage breakables within range, but not as much
+				if ( !Q_irand( 0, 1 ) )
+				{
+					G_Damage( radiusEnts[i], NPC, NPC, vec3_origin, radiusEnts[i]->currentOrigin, 100, 0, MOD_MELEE );
+				}
+			}
+			continue;
+		}
+
+		if ( (radiusEnts[i]->client->ps.eFlags&EF_HELD_BY_RANCOR) )
+		{//can't be one being held
+			continue;
+		}
+
+		if ( (radiusEnts[i]->s.eFlags&EF_NODRAW) )
+		{//not if invisible
+			continue;
+		}
+		
+		distSq = DistanceSquared( radiusEnts[i]->currentOrigin, boltOrg );
+		if ( distSq <= radiusSquared )
+		{
+			if ( distSq < halfRadSquared )
+			{//close enough to do damage, too
+				G_Sound( radiusEnts[i], G_SoundIndex( "sound/chars/rancor/swipehit.wav" ) );
+				if ( (NPC->spawnflags&SPF_RANCOR_FASTKILL) 
+					&& radiusEnts[i]->s.number >= MAX_CLIENTS )
+				{
+					G_Damage( radiusEnts[i], NPC, NPC, vec3_origin, boltOrg, radiusEnts[i]->health+1000, (DAMAGE_NO_KNOCKBACK|DAMAGE_NO_PROTECTION), MOD_MELEE );
+				}
+				else if ( (NPC->spawnflags&SPF_RANCOR_MUTANT) )//FIXME: a flag or something would be better
+				{//more damage
+					G_Damage( radiusEnts[i], NPC, NPC, vec3_origin, radiusEnts[i]->currentOrigin, Q_irand( 40, 55 ), DAMAGE_NO_KNOCKBACK, MOD_MELEE );
+				}
+				else
+				{
+					G_Damage( radiusEnts[i], NPC, NPC, vec3_origin, radiusEnts[i]->currentOrigin, Q_irand( 10, 25 ), DAMAGE_NO_KNOCKBACK, MOD_MELEE );
+				}
+			}
+			if ( radiusEnts[i]->health > 0 
+				&& radiusEnts[i]->client
+				&& radiusEnts[i]->client->NPC_class != CLASS_RANCOR
+				&& radiusEnts[i]->client->NPC_class != CLASS_ATST )
+			{
+				if ( distSq < halfRadSquared 
+					|| radiusEnts[i]->client->ps.groundEntityNum != ENTITYNUM_NONE )
+				{//within range of my fist or withing ground-shaking range and not in the air
+					if ( (NPC->spawnflags&SPF_RANCOR_MUTANT) )
+					{
+						G_Knockdown( radiusEnts[i], NPC, vec3_origin, 500, qtrue );
+					}
+					else
+					{
+						G_Knockdown( radiusEnts[i], NPC, vec3_origin, Q_irand( 200, 350), qtrue );
+					}
+				}
+			}
+		}
+	}
+}
+
+void Rancor_Bite( void )
+{
+	gentity_t	*radiusEnts[ 128 ];
+	int			numEnts;
+	const float	radius = 100;
+	const float	radiusSquared = (radius*radius);
+	int			i;
+	vec3_t		boltOrg;
+
+	numEnts = NPC_GetEntsNearBolt( radiusEnts, radius, NPC->gutBolt, boltOrg );
+
+	for ( i = 0; i < numEnts; i++ )
+	{
+		if ( !radiusEnts[i]->inuse )
+		{
+			continue;
+		}
+		
+		if ( radiusEnts[i] == NPC )
+		{//Skip the rancor ent
+			continue;
+		}
+		
+		if ( radiusEnts[i]->client == NULL )
+		{//must be a client
+			continue;
+		}
+
+		if ( (radiusEnts[i]->client->ps.eFlags&EF_HELD_BY_RANCOR) )
+		{//can't be one already being held
+			continue;
+		}
+
+		if ( (radiusEnts[i]->s.eFlags&EF_NODRAW) )
+		{//not if invisible
+			continue;
+		}
+		
+		if ( DistanceSquared( radiusEnts[i]->currentOrigin, boltOrg ) <= radiusSquared )
+		{
+			if ( (NPC->spawnflags&SPF_RANCOR_FASTKILL) 
+				&& radiusEnts[i]->s.number >= MAX_CLIENTS )
+			{
+				G_Damage( radiusEnts[i], NPC, NPC, vec3_origin, radiusEnts[i]->currentOrigin, radiusEnts[i]->health+1000, (DAMAGE_NO_KNOCKBACK|DAMAGE_NO_PROTECTION), MOD_MELEE );
+			}
+			else if ( (NPC->spawnflags&SPF_RANCOR_MUTANT) )
+			{//more damage
+				G_Damage( radiusEnts[i], NPC, NPC, vec3_origin, radiusEnts[i]->currentOrigin, Q_irand( 35, 50 ), DAMAGE_NO_KNOCKBACK, MOD_MELEE );
+			}
+			else
+			{
+				G_Damage( radiusEnts[i], NPC, NPC, vec3_origin, radiusEnts[i]->currentOrigin, Q_irand( 15, 30 ), DAMAGE_NO_KNOCKBACK, MOD_MELEE );
+			}
+			if ( radiusEnts[i]->health <= 0 && radiusEnts[i]->client )
+			{//killed them, chance of dismembering
+				if ( !Q_irand( 0, 1 ) )
+				{//bite something off
+					int hitLoc = HL_WAIST;
+					if ( g_dismemberment->integer != 113811381138 )
+					{
+						hitLoc = Q_irand( HL_WAIST, HL_HAND_LT );
+					}
+					else
+					{
+						hitLoc = Q_irand( HL_WAIST, HL_HEAD );
+					}
+					if ( hitLoc == HL_HEAD )
+					{
+						NPC_SetAnim( radiusEnts[i], SETANIM_BOTH, BOTH_DEATH17, SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLD );
+					}
+					else if ( hitLoc == HL_WAIST )
+					{
+						NPC_SetAnim( radiusEnts[i], SETANIM_BOTH, BOTH_DEATHBACKWARD2, SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLD );
+					}
+					radiusEnts[i]->client->dismembered = false;
+					//FIXME: the limb should just disappear, cuz I ate it
+					G_DoDismemberment( radiusEnts[i], radiusEnts[i]->currentOrigin, MOD_SABER, 1000, hitLoc, qtrue );
+				}
+			}
+			G_Sound( radiusEnts[i], G_SoundIndex( "sound/chars/rancor/chomp.wav" ) );
+		}
+	}
+}
+//------------------------------
+extern gentity_t *TossClientItems( gentity_t *self );
+void Rancor_Attack( float distance, qboolean doCharge, qboolean aimAtBlockedEntity )
+{
+	if ( !TIMER_Exists( NPC, "attacking" ) 
+		&& TIMER_Done( NPC, "attackDebounce" ) )
+	{
+		if ( NPC->count == 2 && NPC->activator )
+		{
+		}
+		else if ( NPC->count == 1 && NPC->activator )
+		{//holding enemy
+			if ( (!(NPC->spawnflags&SPF_RANCOR_FASTKILL) ||NPC->activator->s.number<MAX_CLIENTS)
+				&& NPC->activator->health > 0 
+				&& Q_irand( 0, 1 ) )
+			{//quick bite
+				NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_ATTACK1, SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLD );
+				TIMER_Set( NPC, "attack_dmg", 450 );
+			}
+			else
+			{//full eat
+				NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_ATTACK3, SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLD );
+				TIMER_Set( NPC, "attack_dmg", 900 );
+				//Make victim scream in fright
+				if ( NPC->activator->health > 0 && NPC->activator->client )
+				{
+					G_AddEvent( NPC->activator, Q_irand(EV_DEATH1, EV_DEATH3), 0 );
+					NPC_SetAnim( NPC->activator, SETANIM_TORSO, BOTH_FALLDEATH1, SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLD );
+					if ( NPC->activator->NPC )
+					{//no more thinking for you
+						TossClientItems( NPC );
+						NPC->activator->NPC->nextBStateThink = Q3_INFINITE;
+					}
+				}
+			}
+		}
+		else if ( NPC->enemy->health > 0 && doCharge )
+		{//charge
+			if ( !Q_irand( 0, 3 ) )
+			{
+				NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_ATTACK5, SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLD );
+				TIMER_Set( NPC, "attack_dmg", 1250 );
+				if ( NPC->enemy && NPC->enemy->s.number == 0 )
+				{//don't attack the player again for a bit
+					TIMER_Set( NPC, "attackDebounce", NPC->client->ps.legsAnimTimer + Q_irand( 2000, 4000+((2-g_spskill->integer)*2000) ) );
+				}
+			}
+			else if ( (NPC->spawnflags&SPF_RANCOR_MUTANT) )
+			{//breath attack
+				int breathAnim = BOTH_ATTACK4;
+				gentity_t *checkEnt = NULL;
+				vec3_t	center;
+				if ( NPC->enemy && NPC->enemy->inuse )
+				{
+					checkEnt = NPC->enemy;
+					VectorCopy( NPC->enemy->currentOrigin, center );
+				}
+				else if ( NPCInfo->blockedEntity && NPCInfo->blockedEntity->inuse )
+				{
+					checkEnt = NPCInfo->blockedEntity;
+					//if it has an origin brush, use it...
+					if ( VectorCompare( NPCInfo->blockedEntity->s.origin, vec3_origin ) )
+					{//no origin brush, calc center
+						VectorAdd( NPCInfo->blockedEntity->mins, NPCInfo->blockedEntity->maxs, center );
+						VectorScale( center, 0.5f, center );
+					}
+					else
+					{//use origin brush as center
+						VectorCopy( NPCInfo->blockedEntity->s.origin, center );
+					}
+				}
+				if ( checkEnt )
+				{
+					float zHeightRelative = center[2]-NPC->currentOrigin[2];
+					if ( zHeightRelative >= (128.0f*NPC->s.modelScale[2]) )
+					{
+						breathAnim = BOTH_ATTACK7;
+					}
+					else if ( zHeightRelative >= (64.0f*NPC->s.modelScale[2]) )
+					{
+						breathAnim = BOTH_ATTACK6;
+					}
+				}
+				NPC_SetAnim( NPC, SETANIM_BOTH, breathAnim, SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLD );
+				//start effect here
+				G_PlayEffect( G_EffectIndex( "mrancor/breath" ), NPC->playerModel, NPC->gutBolt, NPC->s.number, NPC->currentOrigin, (NPC->client->ps.legsAnimTimer-500), qfalse );
+				TIMER_Set( NPC, "breathAttack", NPC->client->ps.legsAnimTimer-500 );
+				G_SoundOnEnt( NPC, CHAN_WEAPON, "sound/chars/rancor/breath_start.wav" );
+				NPC->s.loopSound = G_SoundIndex( "sound/chars/rancor/breath_loop.wav" );
+				if ( NPC->enemy && NPC->enemy->s.number == 0 )
+				{//don't attack the player again for a bit
+					TIMER_Set( NPC, "attackDebounce", NPC->client->ps.legsAnimTimer + Q_irand( 2000, 4000+((2-g_spskill->integer)*2000) ) );
+				}
+			}
+			else
+			{
+				NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_MELEE2, SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLD );
+				TIMER_Set( NPC, "attack_dmg", 1250 );
+				vec3_t	fwd, yawAng ={0, NPC->client->ps.viewangles[YAW], 0};
+				AngleVectors( yawAng, fwd, NULL, NULL );
+				VectorScale( fwd, distance*1.5f, NPC->client->ps.velocity );
+				NPC->client->ps.velocity[2] = 150;
+				NPC->client->ps.groundEntityNum = ENTITYNUM_NONE;
+				if ( NPC->enemy && NPC->enemy->s.number == 0 )
+				{//don't attack the player again for a bit
+					TIMER_Set( NPC, "attackDebounce", NPC->client->ps.legsAnimTimer + Q_irand( 2000, 4000+((2-g_spskill->integer)*2000) ) );
+				}
+			}
+		}
+		else if ( !Q_irand(0, 1) 
+			/*&& (NPC->spawnflags&SPF_RANCOR_MUTANT)*/ )
+		{//mutant rancor can smash
+			NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_MELEE1, SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLD );
+			TIMER_Set( NPC, "attack_dmg", 900 );
+			//init pos3 for the trace from last hand pos to current hand pos
+			VectorCopy( NPC->currentOrigin, NPC->pos3 );
+		}
+		else if ( (NPC->spawnflags&SPF_RANCOR_MUTANT)
+			|| distance >= NPC->maxs[0]+(MIN_DISTANCE*NPC->s.modelScale[0])-64.0f )
+		{//try to grab
+			int grabAnim = BOTH_ATTACK2;
+			gentity_t *checkEnt = NULL;
+			vec3_t	center;
+			if ( (!aimAtBlockedEntity||!NPCInfo->blockedEntity) && NPC->enemy && NPC->enemy->inuse )
+			{
+				checkEnt = NPC->enemy;
+				VectorCopy( NPC->enemy->currentOrigin, center );
+			}
+			else if ( NPCInfo->blockedEntity && NPCInfo->blockedEntity->inuse )
+			{
+				checkEnt = NPCInfo->blockedEntity;
+				//if it has an origin brush, use it...
+				if ( VectorCompare( NPCInfo->blockedEntity->s.origin, vec3_origin ) )
+				{//no origin brush, calc center
+					VectorAdd( NPCInfo->blockedEntity->mins, NPCInfo->blockedEntity->maxs, center );
+					VectorScale( center, 0.5f, center );
+				}
+				else
+				{//use origin brush as center
+					VectorCopy( NPCInfo->blockedEntity->s.origin, center );
+				}
+			}
+			if ( checkEnt )
+			{
+				float zHeightRelative = center[2]-NPC->currentOrigin[2];
+				if ( zHeightRelative >= (128.0f*NPC->s.modelScale[2]) )
+				{
+					grabAnim = BOTH_ATTACK11;
+				}
+				else if ( zHeightRelative >= (64.0f*NPC->s.modelScale[2]) )
+				{
+					grabAnim = BOTH_ATTACK10;
+				}
+			}
+			NPC_SetAnim( NPC, SETANIM_BOTH, grabAnim, SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLD );
+			TIMER_Set( NPC, "attack_dmg", 800 );
+			if ( NPC->enemy && NPC->enemy->s.number == 0 )
+			{//don't attack the player again for a bit
+				TIMER_Set( NPC, "attackDebounce", NPC->client->ps.legsAnimTimer + Q_irand( 2000, 4000+((2-g_spskill->integer)*2000) ) );
+			}
+			//init pos3 for the trace from last hand pos to current hand pos
+			VectorCopy( NPC->currentOrigin, NPC->pos3 );
+		}
+		else
+		{
+			//FIXME: back up?
+			ucmd.forwardmove = -64;
+			//FIXME: check for walls/ledges?
+			return;
+		}
+
+		TIMER_Set( NPC, "attacking", NPC->client->ps.legsAnimTimer + random() * 200 );
+	}
+
+	// Need to do delayed damage since the attack animations encapsulate multiple mini-attacks
+	float playerDist;
+
+	if ( TIMER_Done2( NPC, "attack_dmg", qtrue ) )
+	{
+		switch ( NPC->client->ps.legsAnim )
+		{
+		case BOTH_MELEE1:
+			Rancor_Smash();
+			playerDist = NPC_EntRangeFromBolt( player, NPC->handLBolt );
+			if ( (NPC->spawnflags&SPF_RANCOR_MUTANT) )
+			{
+				if ( playerDist < 512 )
+				{
+					CGCam_Shake( 1.0f*playerDist/256, 1000 );
+				}
+			}
+			else
+			{
+				if ( playerDist < 256 )
+				{
+					CGCam_Shake( 1.0f*playerDist/128.0f, 1000 );
+				}
+			}
+			break;
+		case BOTH_MELEE2:
+			Rancor_Bite();
+			TIMER_Set( NPC, "attack_dmg2", 450 );
+			break;
+		case BOTH_ATTACK1:
+			if ( NPC->count == 1 && NPC->activator )
+			{
+				if ( (NPC->spawnflags&SPF_RANCOR_FASTKILL) 
+					&& NPC->activator->s.number >= MAX_CLIENTS )
+				{
+					G_Damage( NPC->activator, NPC, NPC, vec3_origin, NPC->activator->currentOrigin, NPC->activator->health+1000, (DAMAGE_NO_KNOCKBACK|DAMAGE_NO_PROTECTION), MOD_MELEE );
+				}
+				else if ( (NPC->spawnflags&SPF_RANCOR_MUTANT) )//FIXME: a flag or something would be better
+				{//more damage
+					G_Damage( NPC->activator, NPC, NPC, vec3_origin, NPC->activator->currentOrigin, Q_irand( 55, 70 ), DAMAGE_NO_KNOCKBACK, MOD_MELEE );
+				}
+				else
+				{
+					G_Damage( NPC->activator, NPC, NPC, vec3_origin, NPC->activator->currentOrigin, Q_irand( 25, 40 ), DAMAGE_NO_KNOCKBACK, MOD_MELEE );
+				}
+				if ( NPC->activator->health <= 0 )
+				{//killed him
+					if ( g_dismemberment->integer == 113811381138 )
+					{//make it look like we bit his head off
+						NPC->activator->client->dismembered = false;
+						G_DoDismemberment( NPC->activator, NPC->activator->currentOrigin, MOD_SABER, 1000, HL_HEAD, qtrue );
+					}
+					NPC_SetAnim( NPC->activator, SETANIM_BOTH, BOTH_SWIM_IDLE1, SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLD );
+				}
+				G_Sound( NPC->activator, G_SoundIndex( "sound/chars/rancor/chomp.wav" ) );
+			}
+			break;
+		case BOTH_ATTACK2:
+		case BOTH_ATTACK10:
+		case BOTH_ATTACK11:
+			//try to grab
+			Rancor_Swing( NPC->handRBolt, qtrue );
+			break;
+		case BOTH_ATTACK3:
+			if ( NPC->count == 1 && NPC->activator )
+			{
+				//cut in half
+				if ( NPC->activator->client )
+				{
+					NPC->activator->client->dismembered = false;
+					G_DoDismemberment( NPC->activator, NPC->enemy->currentOrigin, MOD_SABER, 1000, HL_WAIST, qtrue );
+				}
+				//KILL
+				G_Damage( NPC->activator, NPC, NPC, vec3_origin, NPC->activator->currentOrigin, NPC->enemy->health+1000, DAMAGE_NO_PROTECTION|DAMAGE_NO_ARMOR|DAMAGE_NO_KNOCKBACK|DAMAGE_NO_HIT_LOC, MOD_MELEE, HL_NONE );
+				if ( NPC->activator->client )
+				{
+					NPC_SetAnim( NPC->activator, SETANIM_BOTH, BOTH_SWIM_IDLE1, SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLD );
+				}
+				TIMER_Set( NPC, "attack_dmg2", 1350 );
+				G_Sound( NPC->activator, G_SoundIndex( "sound/chars/rancor/swipehit.wav" ) );
+				G_AddEvent( NPC->activator, EV_JUMP, NPC->activator->health );
+			}
+			break;
+		}
+	}
+	else if ( TIMER_Done2( NPC, "attack_dmg2", qtrue ) )
+	{
+		switch ( NPC->client->ps.legsAnim )
+		{
+		case BOTH_MELEE1:
+			break;
+		case BOTH_MELEE2:
+			Rancor_Bite();
+			break;
+		case BOTH_ATTACK1:
+			break;
+		case BOTH_ATTACK2:
+			break;
+		case BOTH_ATTACK3:
+			if ( NPC->count == 1 && NPC->activator )
+			{//swallow victim
+				G_Sound( NPC->activator, G_SoundIndex( "sound/chars/rancor/chomp.wav" ) );
+				//FIXME: sometimes end up with a live one in our mouths?
+				//just make sure they're dead
+				if ( NPC->activator->health > 0 )
+				{
+					//cut in half
+					NPC->activator->client->dismembered = false;
+					G_DoDismemberment( NPC->activator, NPC->enemy->currentOrigin, MOD_SABER, 1000, HL_WAIST, qtrue );
+					//KILL
+					G_Damage( NPC->activator, NPC, NPC, vec3_origin, NPC->activator->currentOrigin, NPC->enemy->health+1000, DAMAGE_NO_PROTECTION|DAMAGE_NO_ARMOR|DAMAGE_NO_KNOCKBACK|DAMAGE_NO_HIT_LOC, MOD_MELEE, HL_NONE );
+					NPC_SetAnim( NPC->activator, SETANIM_BOTH, BOTH_SWIM_IDLE1, SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLD );
+					G_AddEvent( NPC->activator, EV_JUMP, NPC->activator->health );
+				}
+				NPC->count = 2;
+				TIMER_Set( NPC, "clearGrabbed", 2600 );
+			}
+			break;
+		}
+	}
+
+	// Just using this to remove the attacking flag at the right time
+	TIMER_Done2( NPC, "attacking", qtrue );
+}
+
+//----------------------------------
+void Rancor_Combat( void )
+{
+	if ( NPC->count )
+	{//holding my enemy
+		NPCInfo->enemyLastSeenTime = level.time;
+		if ( TIMER_Done2( NPC, "takingPain", qtrue ))
+		{
+			NPCInfo->localState = LSTATE_CLEAR;
+		}
+		else if ( (NPC->spawnflags&SPF_RANCOR_FASTKILL) 
+			&& NPC->activator
+			&& NPC->activator->s.number >= MAX_CLIENTS )
+		{
+			Rancor_Attack( 0, qfalse, qfalse );
+		}
+		else if ( NPC->useDebounceTime >= level.time 
+			&& NPC->activator )
+		{//just sniffing the guy
+			if ( NPC->useDebounceTime <= level.time + 100
+				&& NPC->client->ps.legsAnim != BOTH_HOLD_DROP)
+			{//just about done, drop him
+				NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_HOLD_DROP, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+				TIMER_Set( NPC, "attacking", NPC->client->ps.legsAnimTimer+(Q_irand(500,1000)*(3-g_spskill->integer)) );
+			}
+		}
+		else
+		{
+			if ( !NPC->useDebounceTime 
+				&& NPC->activator 
+				&& NPC->activator->s.number < MAX_CLIENTS )
+			{//first time I pick the player, just sniff them
+				if ( TIMER_Done(NPC,"attacking") )
+				{//ready to attack
+					NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_HOLD_SNIFF, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+					NPC->useDebounceTime = level.time + NPC->client->ps.legsAnimTimer + Q_irand( 500, 2000 );
+				}
+			}
+			else
+			{
+				Rancor_Attack( 0, qfalse, qfalse );
+			}
+		}
+		NPC_UpdateAngles( qtrue, qtrue );
+		return;
+	}
+
+	NPCInfo->goalRadius = NPC->maxs[0]+(MAX_DISTANCE*NPC->s.modelScale[0]);	// just get us within combat range
+
+	// If we cannot see our target or we have somewhere to go, then do that
+	if ( !NPC_ClearLOS( NPC->enemy ) || UpdateGoal( ))
+	{
+		NPCInfo->combatMove = qtrue;
+		NPCInfo->goalEntity = NPC->enemy;
+
+		Rancor_Move( qfalse );
+		return;
+	}
+
+	NPCInfo->enemyLastSeenTime = level.time;
+	// Sometimes I have problems with facing the enemy I'm attacking, so force the issue so I don't look dumb
+	NPC_FaceEnemy( qtrue );
+
+	float	distance	= Distance( NPC->currentOrigin, NPC->enemy->currentOrigin );	
+
+	qboolean	advance = (qboolean)( distance > (NPC->maxs[0]+(MIN_DISTANCE*NPC->s.modelScale[0])) ? qtrue : qfalse  );
+	qboolean	doCharge = qfalse;
+
+	if ( advance )
+	{//have to get closer
+		if ( (NPC->spawnflags&SPF_RANCOR_MUTANT)
+			&& (!NPC->enemy||!NPC->enemy->client) )
+		{//don't do breath attack vs. bbrushes
+		}
+		else
+		{
+			vec3_t	yawOnlyAngles = {0, NPC->currentAngles[YAW], 0};
+			if ( NPC->enemy->health > 0
+				&& fabs(distance-(250.0f*NPC->s.modelScale[0])) <= (80.0f*NPC->s.modelScale[0])
+				&& InFOV( NPC->enemy->currentOrigin, NPC->currentOrigin, yawOnlyAngles, 30, 30 ) )
+			{
+				int chance = 9;
+				if ( (NPC->spawnflags&SPF_RANCOR_MUTANT) )
+				{//higher chance of doing breath attack
+					chance = 5-g_spskill->integer;
+				}
+				if ( !Q_irand( 0, chance ) )
+				{//go for the charge
+					doCharge = qtrue;
+					advance = qfalse;
+				}
+			}
+		}
+	}
+
+	if (( advance || NPCInfo->localState == LSTATE_WAITING ) && TIMER_Done( NPC, "attacking" )) // waiting monsters can't attack
+	{
+		if ( TIMER_Done2( NPC, "takingPain", qtrue ))
+		{
+			NPCInfo->localState = LSTATE_CLEAR;
+		}
+		else
+		{
+			Rancor_Move( 1 );
+		}
+	}
+	else
+	{
+		Rancor_Attack( distance, doCharge, qfalse );
+	}
+}
+
+/*
+-------------------------
+NPC_Rancor_Pain
+-------------------------
+*/
+void NPC_Rancor_Pain( gentity_t *self, gentity_t *inflictor, gentity_t *other, const vec3_t point, int damage, int mod,int hitLoc ) 
+{
+	qboolean hitByRancor = qfalse;
+	
+	if ( self->NPC && self->NPC->ignorePain )
+	{
+		return;
+	}
+	if ( !TIMER_Done( self, "breathAttack" ) )
+	{//nothing interrupts breath attack
+		return;
+	}
+
+	TIMER_Remove( self, "confusionTime" );
+
+	if ( other&&other->client&&other->client->NPC_class==CLASS_RANCOR )
+	{
+		hitByRancor = qtrue;
+	}
+	if ( other 
+		&& other->inuse 
+		&& other != self->enemy
+		&& !(other->flags&FL_NOTARGET) )
+	{
+		if ( !self->count )
+		{
+			if ( (!other->s.number&&!Q_irand(0,3))
+				|| !self->enemy
+				|| self->enemy->health == 0
+				|| (self->enemy->client&&self->enemy->client->NPC_class == CLASS_RANCOR)
+				|| (!Q_irand(0, 4 ) && DistanceSquared( other->currentOrigin, self->currentOrigin ) < DistanceSquared( self->enemy->currentOrigin, self->currentOrigin )) ) 
+			{//if my enemy is dead (or attacked by player) and I'm not still holding/eating someone, turn on the attacker
+				//FIXME: if can't nav to my enemy, take this guy if I can nav to him
+				self->lastEnemy = self->enemy;
+				G_SetEnemy( self, other );
+				if ( self->enemy != self->lastEnemy )
+				{//clear this so that we only sniff the player the first time we pick them up
+					self->useDebounceTime = 0;
+				}
+				TIMER_Set( self, "lookForNewEnemy", Q_irand( 5000, 15000 ) );
+				if ( hitByRancor )
+				{//stay mad at this Rancor for 2-5 secs before looking for other enemies
+					TIMER_Set( self, "rancorInfight", Q_irand( 2000, 5000 ) );
+				}
+
+			}
+		}
+	}
+	if ( (hitByRancor|| (self->count==1&&self->activator&&!Q_irand(0,4)) || Q_irand( 0, 200 ) < damage )//hit by rancor, hit while holding live victim, or took a lot of damage
+		&& self->client->ps.legsAnim != BOTH_STAND1TO2
+		&& TIMER_Done( self, "takingPain" ) )
+	{
+		if ( !Rancor_CheckRoar( self ) )
+		{
+			if ( self->client->ps.legsAnim != BOTH_MELEE1
+				&& self->client->ps.legsAnim != BOTH_MELEE2
+				&& self->client->ps.legsAnim != BOTH_ATTACK2
+				&& self->client->ps.legsAnim != BOTH_ATTACK10
+				&& self->client->ps.legsAnim != BOTH_ATTACK11 )
+			{//cant interrupt one of the big attack anims
+				/*
+				if ( self->count != 1 
+					|| other == self->activator
+					|| (self->client->ps.legsAnim != BOTH_ATTACK1&&self->client->ps.legsAnim != BOTH_ATTACK3) )
+				*/
+				{//if going to bite our victim, only victim can interrupt that anim
+					if ( self->health > 100 || hitByRancor )
+					{
+						TIMER_Remove( self, "attacking" );
+
+						VectorCopy( self->NPC->lastPathAngles, self->s.angles );
+
+						if ( self->count == 1 )
+						{
+							NPC_SetAnim( self, SETANIM_BOTH, BOTH_PAIN2, SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLD );
+						}
+						else
+						{
+							NPC_SetAnim( self, SETANIM_BOTH, BOTH_PAIN1, SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLD );
+						}
+						TIMER_Set( self, "takingPain", self->client->ps.legsAnimTimer+Q_irand(0, 500*(2-g_spskill->integer)) );
+
+						if ( self->NPC )
+						{
+							self->NPC->localState = LSTATE_WAITING;
+						}
+					}
+				}
+			}
+		}
+		//let go
+		/*
+		if ( !Q_irand( 0, 3 ) && self->count == 1 )
+		{
+			Rancor_DropVictim( self );
+		}
+		*/
+	}
+}
+
+void Rancor_CheckDropVictim( void )
+{
+	if ( (NPC->spawnflags&SPF_RANCOR_FASTKILL) 
+		&& NPC->activator->s.number >= MAX_CLIENTS )
+	{
+		return;
+	}
+	vec3_t mins={NPC->activator->mins[0]-1,NPC->activator->mins[1]-1,0};
+	vec3_t maxs={NPC->activator->maxs[0]+1,NPC->activator->maxs[1]+1,1};
+	vec3_t start={NPC->activator->currentOrigin[0],NPC->activator->currentOrigin[1],NPC->activator->absmin[2]}; 
+	vec3_t end={NPC->activator->currentOrigin[0],NPC->activator->currentOrigin[1],NPC->activator->absmax[2]-1}; 
+	trace_t	trace;
+	gi.trace( &trace, start, mins, maxs, end, NPC->activator->s.number, NPC->activator->clipmask );
+	if ( !trace.allsolid && !trace.startsolid && trace.fraction >= 1.0f )
+	{
+		Rancor_DropVictim( NPC );
+	}
+}
+
+qboolean Rancor_AttackBBrush( void )
+{
+	trace_t	trace;
+	vec3_t center;
+	vec3_t dir2Brush, end;
+	float	checkDist = 64.0f;//32.0f;
+
+	if ( VectorCompare( NPCInfo->blockedEntity->s.origin, vec3_origin ) )
+	{//no origin brush, calc center
+		VectorAdd( NPCInfo->blockedEntity->mins, NPCInfo->blockedEntity->maxs, center );
+		VectorScale( center, 0.5f, center );
+	}
+	else
+	{
+		VectorCopy( NPCInfo->blockedEntity->s.origin, center );
+	}
+	if ( NAVDEBUG_showCollision )
+	{
+		CG_DrawEdge( NPC->currentOrigin, center, EDGE_IMPACT_POSSIBLE );
+	}
+	center[2] = NPC->currentOrigin[2];//we can't fly, so let's ignore z diff
+	NPC_FacePosition( center, qfalse );
+	//see if we're close to it
+	VectorSubtract( center, NPC->currentOrigin, dir2Brush );
+	float brushSize = ((NPCInfo->blockedEntity->maxs[0] - NPCInfo->blockedEntity->mins[0])*0.5f+(NPCInfo->blockedEntity->maxs[1] - NPCInfo->blockedEntity->mins[1])*0.5f) * 0.5f;
+	float dist2Brush = VectorNormalize( dir2Brush )-(NPC->maxs[0])-brushSize;
+	if ( dist2Brush < (MIN_DISTANCE*NPC->s.modelScale[0]) )
+	{//close enough to just hit it
+		trace.fraction = 0.0f;
+		trace.entityNum = NPCInfo->blockedEntity->s.number;
+	}
+	else
+	{
+		VectorMA( NPC->currentOrigin, checkDist, dir2Brush, end );
+		gi.trace( &trace, NPC->currentOrigin, NPC->mins, NPC->maxs, end, NPC->s.number, NPC->clipmask );
+		if ( trace.allsolid || trace.startsolid )
+		{//wtf?
+			NPCInfo->blockedEntity = NULL;
+			return qfalse;
+		}
+	}
+	if ( trace.fraction >= 1.0f //too far away
+		|| trace.entityNum != NPCInfo->blockedEntity->s.number )//OR blocked by something else
+	{//keep moving towards it
+		ucmd.buttons &= ~BUTTON_WALKING;				// Unset from MoveToGoal()
+		STEER::Activate(NPC);
+		STEER::Seek(NPC, center);
+		STEER::AvoidCollisions(NPC);
+		STEER::DeActivate(NPC, &ucmd);
+		/*
+		VectorCopy( dir2Brush, NPC->client->ps.moveDir );
+		if ( NPC->client->ps.speed < NPCInfo->stats.walkSpeed )
+		{
+			NPC->client->ps.speed = NPCInfo->stats.walkSpeed;
+			ucmd.buttons |= BUTTON_WALKING;
+		}
+		*/
+		//NPCInfo->enemyLastSeenTime = level.time;
+		//let the function that called us know that we called NAV ourselves
+	}
+ 	else if ( trace.entityNum == NPCInfo->blockedEntity->s.number )
+	{//close enough, smash it!
+		Rancor_Attack( (trace.fraction*checkDist), qfalse, qtrue );//FIXME: maybe charge at it, smash through?
+		TIMER_Remove( NPC, "attackDebounce" );//don't wait on these
+		NPCInfo->enemyLastSeenTime = level.time;
+	}
+	else
+	{
+		//Com_Printf( S_COLOR_RED"RANCOR cannot reach intended breakable %s, blocked by %s\n", NPC->blockedEntity->targetname, g_entities[trace.entityNum].classname );
+		if ( G_EntIsBreakable( trace.entityNum, NPC ) )
+		{//oh, well, smash that, then
+			//G_SetEnemy( NPC, &g_entities[trace.entityNum] );
+			gentity_t*	prevblockedEnt = NPCInfo->blockedEntity;
+			NPCInfo->blockedEntity = &g_entities[trace.entityNum];
+			Rancor_Attack( (trace.fraction*checkDist), qfalse, qtrue );//FIXME: maybe charge at it, smash through?
+			TIMER_Remove( NPC, "attackDebounce" );//don't wait on these
+			NPCInfo->enemyLastSeenTime = level.time;
+			NPCInfo->blockedEntity = prevblockedEnt;
+		}
+		else
+		{
+			NPCInfo->blockedEntity = NULL;
+			return qfalse;
+		}
+	}
+	return qtrue;
+}
+
+void Rancor_FireBreathAttack( void )
+{
+	int		damage	= Q_irand( 10, 15 );
+	trace_t		tr;
+	gentity_t	*traceEnt = NULL;
+	mdxaBone_t	boltMatrix;
+	vec3_t		start, end, dir, traceMins = {-4, -4, -4}, traceMaxs = {4, 4, 4};
+	vec3_t		rancAngles = {0,NPC->client->ps.viewangles[YAW],0};
+
+	gi.G2API_GetBoltMatrix( NPC->ghoul2, NPC->playerModel, NPC->gutBolt,
+			&boltMatrix, rancAngles, NPC->currentOrigin, (cg.time?cg.time:level.time),
+			NULL, NPC->s.modelScale );
+
+	gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, start );
+	gi.G2API_GiveMeVectorFromMatrix( boltMatrix, NEGATIVE_Z, dir );
+	VectorMA( start, 512, dir, end );
+
+	gi.trace( &tr, start, traceMins, traceMaxs, end, NPC->s.number, MASK_SHOT );
+
+	traceEnt = &g_entities[tr.entityNum];
+	if ( tr.entityNum < ENTITYNUM_WORLD 
+		&& traceEnt->takedamage 
+		&& traceEnt->client )
+	{//breath attack only does damage to living things
+		G_Damage( traceEnt, NPC, NPC, dir, tr.endpos, damage*2, DAMAGE_NO_ARMOR|DAMAGE_NO_KNOCKBACK|DAMAGE_NO_HIT_LOC|DAMAGE_IGNORE_TEAM, MOD_LAVA, HL_NONE );
+	}
+	if ( tr.fraction < 1.0f )
+	{//hit something, do radius damage
+		G_RadiusDamage( tr.endpos, NPC, damage, 250, NPC, MOD_LAVA );
+	}
+}
+
+void Rancor_CheckAnimDamage( void )
+{
+	if ( NPC->client->ps.legsAnim == BOTH_ATTACK2
+		|| NPC->client->ps.legsAnim == BOTH_ATTACK10
+		|| NPC->client->ps.legsAnim == BOTH_ATTACK11 )
+	{
+		if ( NPC->client->ps.legsAnimTimer >= 1200 && NPC->client->ps.legsAnimTimer <= 1350 )
+		{
+			if ( Q_irand( 0, 2 ) )
+			{
+				Rancor_Swing( NPC->handRBolt, qfalse );
+			}
+			else
+			{
+				Rancor_Swing( NPC->handRBolt, qtrue );
+			}
+		}
+		else if ( NPC->client->ps.legsAnimTimer >= 1100 && NPC->client->ps.legsAnimTimer <= 1550 )
+		{
+			Rancor_Swing( NPC->handRBolt, qtrue );
+		}
+	}
+	else if ( NPC->client->ps.legsAnim == BOTH_ATTACK5 )
+	{
+		if ( NPC->client->ps.legsAnimTimer >= 750 && NPC->client->ps.legsAnimTimer <= 1300 )
+		{
+			Rancor_Swing( NPC->handLBolt, qfalse );
+		}
+		else if ( NPC->client->ps.legsAnimTimer >= 1700 && NPC->client->ps.legsAnimTimer <= 2300 )
+		{
+			Rancor_Swing( NPC->handRBolt, qfalse );
+		}
+	}
+}
+/*
+-------------------------
+NPC_BSRancor_Default
+-------------------------
+*/
+void NPC_BSRancor_Default( void )
+{ 
+	AddSightEvent( NPC, NPC->currentOrigin, 1024, AEL_DANGER_GREAT, 50 );
+
+	if (NPCInfo->blockedEntity && TIMER_Done(NPC, "blockedEntityIgnore"))
+	{
+		if (!TIMER_Exists(NPC, "blockedEntityTimeOut"))
+		{
+			TIMER_Set(NPC, "blockedEntityTimeOut", 5000);
+		}
+		else if (TIMER_Done(NPC, "blockedEntityTimeOut"))
+		{
+			TIMER_Remove(NPC, "blockedEntityTimeOut");
+			TIMER_Set(NPC, "blockedEntityIgnore", 25000);
+			NPCInfo->blockedEntity = NULL;
+		}
+	}
+	else
+	{
+		TIMER_Remove(NPC, "blockedEntityTimeOut");
+		TIMER_Remove(NPC, "blockedEntityIgnore");
+	}
+
+	Rancor_CheckAnimDamage();
+
+	if ( !TIMER_Done( NPC, "breathAttack" ) )
+	{//doing breath attack, just do damage
+		Rancor_FireBreathAttack();
+		NPC_UpdateAngles( qtrue, qtrue );
+		return;
+	}
+	else if ( NPC->client->ps.legsAnim == BOTH_ATTACK4
+		|| NPC->client->ps.legsAnim == BOTH_ATTACK6
+		|| NPC->client->ps.legsAnim == BOTH_ATTACK7 )
+	{
+		G_StopEffect( G_EffectIndex( "mrancor/breath" ), NPC->playerModel, NPC->gutBolt, NPC->s.number );
+		NPC->s.loopSound = 0;
+	}
+
+	if ( TIMER_Done2( NPC, "clearGrabbed", qtrue ) )
+	{
+		Rancor_DropVictim( NPC );
+	}
+	else if ( (NPC->client->ps.legsAnim == BOTH_PAIN2 || NPC->client->ps.legsAnim == BOTH_HOLD_DROP )
+		&& NPC->count == 1 
+		&& NPC->activator )
+	{
+		Rancor_CheckDropVictim();
+	}
+	if ( !TIMER_Done( NPC, "rageTime" ) )
+	{//do nothing but roar first time we see an enemy
+		AddSoundEvent( NPC, NPC->currentOrigin, 1024, AEL_DANGER_GREAT, qfalse, qfalse );
+		NPC_FaceEnemy( qtrue );
+		return;
+	}
+
+	if ( NPCInfo->localState == LSTATE_WAITING 
+		&& TIMER_Done2( NPC, "takingPain", qtrue ) )
+	{//was not doing anything because we were taking pain, but pain is done now, so clear it...
+		NPCInfo->localState = LSTATE_CLEAR;
+	}
+
+	if ( !TIMER_Done( NPC, "confusionTime" ) )
+	{
+		NPC_UpdateAngles( qtrue, qtrue );
+		return;
+	}
+
+	if ( NPC->enemy )
+	{
+		if ( NPC->enemy->client //enemy is a client
+			&& (NPC->enemy->client->NPC_class == CLASS_UGNAUGHT || NPC->enemy->client->NPC_class == CLASS_JAWA )//enemy is a lowly jawa or ugnaught
+			&& NPC->enemy->enemy != NPC//enemy's enemy is not me
+			&& (!NPC->enemy->enemy || !NPC->enemy->enemy->client || NPC->enemy->enemy->client->NPC_class!=CLASS_RANCOR) )//enemy's enemy is not a client or is not a rancor (which is as scary as me anyway)
+		{//they should be scared of ME and no-one else
+			G_SetEnemy( NPC->enemy, NPC );
+		}
+		if ( TIMER_Done(NPC,"angrynoise") )
+		{
+			G_SoundOnEnt( NPC, CHAN_AUTO, va("sound/chars/rancor/anger%d.wav", Q_irand(1, 3)) );
+
+			TIMER_Set( NPC, "angrynoise", Q_irand( 5000, 10000 ) );
+		}
+		else
+		{
+			AddSoundEvent( NPC, NPC->currentOrigin, 512, AEL_DANGER_GREAT, qfalse, qfalse );
+		}
+		if ( NPC->count == 2 && NPC->client->ps.legsAnim == BOTH_ATTACK3 )
+		{//we're still chewing our enemy up
+			NPC_UpdateAngles( qtrue, qtrue );
+			return;
+		}
+		//else, if he's in our hand, we eat, else if he's on the ground, we keep attacking his dead body for a while
+		if( NPC->enemy->client && NPC->enemy->client->NPC_class == CLASS_RANCOR )
+		{//got mad at another Rancor, look for a valid enemy
+			if ( TIMER_Done( NPC, "rancorInfight" ) )
+			{
+				NPC_CheckEnemyExt( qtrue );
+			}
+		}
+		else if ( !NPC->count )
+		{
+			if ( NPCInfo->blockedEntity )
+			{//something in our way
+				if ( !NPCInfo->blockedEntity->inuse )
+				{//was destroyed
+					NPCInfo->blockedEntity = NULL;
+				}
+				else
+				{
+					//a breakable?
+					if ( G_EntIsBreakable( NPCInfo->blockedEntity->s.number, NPC ) )
+					{//breakable brush
+						if ( !Rancor_AttackBBrush() )
+						{//didn't move inside that func, so call move here...?
+							Rancor_Move( 1 );
+						}
+						NPC_UpdateAngles( qtrue, qtrue );
+						return;
+					}
+					else
+					{//if it's a client and in our way, get mad at it!
+						if ( NPCInfo->blockedEntity != NPC->enemy
+							&& NPCInfo->blockedEntity->client 
+							&& NPC_ValidEnemy( NPCInfo->blockedEntity )
+							&& !Q_irand( 0, 9 ) )
+						{
+							G_SetEnemy( NPC, NPCInfo->blockedEntity );
+							//look again in 2-5 secs
+							TIMER_Set( NPC, "lookForNewEnemy", Q_irand( 2000, 5000 ) );
+							NPCInfo->blockedEntity = NULL;
+						}
+					}
+				}
+			}
+			if ( NPC_ValidEnemy( NPC->enemy ) == qfalse )
+			{
+				TIMER_Remove( NPC, "lookForNewEnemy" );//make them look again right now
+				if ( !NPC->enemy->inuse 
+					|| level.time - NPC->enemy->s.time > Q_irand( 10000, 15000 ) 
+					|| (NPC->spawnflags&SPF_RANCOR_FASTKILL) )//don't linger on dead bodies
+				{//it's been a while since the enemy died, or enemy is completely gone, get bored with him
+					if ( (NPC->spawnflags&SPF_RANCOR_MUTANT)
+						&& player && player->health >= 0 )
+					{//all else failing, always go after the player
+						NPC->lastEnemy = NPC->enemy;
+						G_SetEnemy( NPC, player );
+						if ( NPC->enemy != NPC->lastEnemy )
+						{//clear this so that we only sniff the player the first time we pick them up
+							NPC->useDebounceTime = 0;
+						}
+					}
+					else
+					{
+						NPC->enemy = NULL;
+						Rancor_Patrol();
+						NPC_UpdateAngles( qtrue, qtrue );
+						return;
+					}
+				}
+			}
+			if ( TIMER_Done( NPC, "lookForNewEnemy" ) )
+			{
+				gentity_t *sav_enemy = NPC->enemy;//FIXME: what about NPC->lastEnemy?
+				NPC->enemy = NULL;
+				gentity_t *newEnemy = NPC_CheckEnemy( NPCInfo->confusionTime < level.time, qfalse, qfalse );
+				NPC->enemy = sav_enemy;
+				if ( newEnemy && newEnemy != sav_enemy )
+				{//picked up a new enemy!
+					NPC->lastEnemy = NPC->enemy;
+					G_SetEnemy( NPC, newEnemy );
+					if ( NPC->enemy != NPC->lastEnemy )
+					{//clear this so that we only sniff the player the first time we pick them up
+						NPC->useDebounceTime = 0;
+					}
+					//hold this one for at least 5-15 seconds
+					TIMER_Set( NPC, "lookForNewEnemy", Q_irand( 5000, 15000 ) );
+				}
+				else
+				{//look again in 2-5 secs
+					TIMER_Set( NPC, "lookForNewEnemy", Q_irand( 2000, 5000 ) );
+				}
+			}
+		}
+		Rancor_Combat();
+		if ( TIMER_Done( NPC, "attacking" )
+			&& TIMER_Done( NPC, "takingpain" )
+			&& TIMER_Done( NPC, "confusionDebounce" )
+			&& NPCInfo->localState == LSTATE_CLEAR 
+			&& !NPC->count )
+		{//not busy
+			if ( !ucmd.forwardmove
+				&& !ucmd.rightmove
+				&& VectorCompare( NPC->client->ps.moveDir, vec3_origin ) )
+			{//not moving
+				if ( level.time - NPCInfo->enemyLastSeenTime > 5000 )
+				{//haven't seen an enemy in a while
+					if ( !Q_irand( 0, 20 ) )
+					{
+						if ( Q_irand( 0, 1 ) )
+						{
+							NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_GUARD_IDLE1, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+						}
+						else
+						{
+							NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_GUARD_LOOKAROUND1, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+						}
+						TIMER_Set( NPC, "confusionTime", NPC->client->ps.legsAnimTimer );
+						TIMER_Set( NPC, "confusionDebounce", NPC->client->ps.legsAnimTimer+Q_irand( 4000, 8000 ) );
+					}
+				}
+			}
+		}
+	}
+	else 
+	{
+		if ( TIMER_Done(NPC,"idlenoise") )
+		{
+			G_SoundOnEnt( NPC, CHAN_AUTO, va("sound/chars/rancor/snort_%d.wav", Q_irand(1, 4)) );
+
+			TIMER_Set( NPC, "idlenoise", Q_irand( 2000, 4000 ) );
+			AddSoundEvent( NPC, NPC->currentOrigin, 384, AEL_DANGER, qfalse, qfalse );
+		}
+		if ( NPCInfo->scriptFlags & SCF_LOOK_FOR_ENEMIES )
+		{
+			Rancor_Patrol();
+			if ( !NPC->enemy && NPC->wait )
+			{//we've been mad before and can't find an enemy
+				if ( (NPC->spawnflags&SPF_RANCOR_MUTANT)
+					&& player && player->health >= 0 )
+				{//all else failing, always go after the player
+					NPC->lastEnemy = NPC->enemy;
+					G_SetEnemy( NPC, player );
+					if ( NPC->enemy != NPC->lastEnemy )
+					{//clear this so that we only sniff the player the first time we pick them up
+						NPC->useDebounceTime = 0;
+					}
+				}
+			}
+		}
+		else
+		{
+			Rancor_Idle();
+		}
+	}
+
+	NPC_UpdateAngles( qtrue, qtrue );
+}
diff --git a/code/game/AI_Remote.cpp b/code/game/AI_Remote.cpp
new file mode 100644
index 0000000..400981f
--- /dev/null
+++ b/code/game/AI_Remote.cpp
@@ -0,0 +1,389 @@
+// leave this line at the top of all AI_xxxx.cpp files for PCH reasons...
+#include "g_headers.h"
+
+
+#include "b_local.h"
+#include "g_nav.h"
+
+gentity_t *CreateMissile( vec3_t org, vec3_t dir, float vel, int life, gentity_t *owner, qboolean altFire = qfalse );
+void Remote_Strafe( void );
+
+#define VELOCITY_DECAY	0.85f
+
+
+//Local state enums
+enum
+{
+	LSTATE_NONE = 0,
+};
+
+void Remote_Idle( void );
+
+void NPC_Remote_Precache(void)
+{
+	G_SoundIndex("sound/chars/remote/misc/fire.wav");
+	G_SoundIndex( "sound/chars/remote/misc/hiss.wav");
+	G_EffectIndex( "env/small_explode");
+}
+
+/*
+-------------------------
+NPC_Remote_Pain
+-------------------------
+*/
+void NPC_Remote_Pain( gentity_t *self, gentity_t *inflictor, gentity_t *other, const vec3_t point, int damage, int mod,int hitLoc ) 
+{
+	SaveNPCGlobals();
+	SetNPCGlobals( self );
+	Remote_Strafe();
+	RestoreNPCGlobals();
+
+	NPC_Pain( self, inflictor, other, point, damage, mod );
+}
+
+/*
+-------------------------
+Remote_MaintainHeight
+-------------------------
+*/
+void Remote_MaintainHeight( void )
+{	
+	float	dif;
+
+	// Update our angles regardless
+	NPC_UpdateAngles( qtrue, qtrue );
+
+	if ( NPC->client->ps.velocity[2] )
+	{
+		NPC->client->ps.velocity[2] *= VELOCITY_DECAY;
+
+		if ( fabs( NPC->client->ps.velocity[2] ) < 2 )
+		{
+			NPC->client->ps.velocity[2] = 0;
+		}
+	}
+	// If we have an enemy, we should try to hover at or a little below enemy eye level
+	if ( NPC->enemy )
+	{
+		if (TIMER_Done( NPC, "heightChange"))
+		{
+			TIMER_Set( NPC,"heightChange",Q_irand( 1000, 3000 ));
+
+			// Find the height difference
+			dif = (NPC->enemy->currentOrigin[2] +  Q_irand( 0, NPC->enemy->maxs[2]+8 )) - NPC->currentOrigin[2]; 
+
+			// cap to prevent dramatic height shifts
+			if ( fabs( dif ) > 2 )
+			{
+				if ( fabs( dif ) > 24 )
+				{
+					dif = ( dif < 0 ? -24 : 24 );
+				}
+				dif *= 10;
+				NPC->client->ps.velocity[2] = (NPC->client->ps.velocity[2]+dif)/2;
+				NPC->fx_time = level.time;
+				G_Sound( NPC, G_SoundIndex("sound/chars/remote/misc/hiss.wav"));
+			}
+		}
+	}
+	else
+	{
+		gentity_t *goal = NULL;
+
+		if ( NPCInfo->goalEntity )	// Is there a goal?
+		{
+			goal = NPCInfo->goalEntity;
+		}
+		else
+		{
+			goal = NPCInfo->lastGoalEntity;
+		}
+		if ( goal )
+		{
+			dif = goal->currentOrigin[2] - NPC->currentOrigin[2];
+
+			if ( fabs( dif ) > 24 )
+			{
+				dif = ( dif < 0 ? -24 : 24 );
+				NPC->client->ps.velocity[2] = (NPC->client->ps.velocity[2]+dif)/2;
+			}
+		}
+	}
+
+	// Apply friction
+	if ( NPC->client->ps.velocity[0] )
+	{
+		NPC->client->ps.velocity[0] *= VELOCITY_DECAY;
+
+		if ( fabs( NPC->client->ps.velocity[0] ) < 1 )
+		{
+			NPC->client->ps.velocity[0] = 0;
+		}
+	}
+
+	if ( NPC->client->ps.velocity[1] )
+	{
+		NPC->client->ps.velocity[1] *= VELOCITY_DECAY;
+
+		if ( fabs( NPC->client->ps.velocity[1] ) < 1 )
+		{
+			NPC->client->ps.velocity[1] = 0;
+		}
+	}
+}
+
+#define REMOTE_STRAFE_VEL	256
+#define REMOTE_STRAFE_DIS	200
+#define REMOTE_UPWARD_PUSH	32
+
+/*
+-------------------------
+Remote_Strafe
+-------------------------
+*/
+void Remote_Strafe( void )
+{
+	int		dir;
+	vec3_t	end, right;
+	trace_t	tr;
+
+	AngleVectors( NPC->client->renderInfo.eyeAngles, NULL, right, NULL );
+
+	// Pick a random strafe direction, then check to see if doing a strafe would be
+	//	reasonable valid
+	dir = ( rand() & 1 ) ? -1 : 1;
+	VectorMA( NPC->currentOrigin, REMOTE_STRAFE_DIS * dir, right, end );
+
+	gi.trace( &tr, NPC->currentOrigin, NULL, NULL, end, NPC->s.number, MASK_SOLID );
+
+	// Close enough
+	if ( tr.fraction > 0.9f )
+	{
+		VectorMA( NPC->client->ps.velocity, REMOTE_STRAFE_VEL * dir, right, NPC->client->ps.velocity );
+
+		G_Sound( NPC, G_SoundIndex("sound/chars/remote/misc/hiss.wav"));
+
+		// Add a slight upward push
+		NPC->client->ps.velocity[2] += REMOTE_UPWARD_PUSH;
+
+		// Set the strafe start time so we can do a controlled roll
+		NPC->fx_time = level.time;
+		NPCInfo->standTime = level.time + 3000 + random() * 500;
+	}
+}
+
+#define REMOTE_FORWARD_BASE_SPEED	10
+#define REMOTE_FORWARD_MULTIPLIER	5
+
+/*
+-------------------------
+Remote_Hunt
+-------------------------
+*/
+void Remote_Hunt( qboolean visible, qboolean advance, qboolean retreat )
+{
+	float	distance, speed;
+	vec3_t	forward;
+
+	//If we're not supposed to stand still, pursue the player
+	if ( NPCInfo->standTime < level.time )
+	{
+		// Only strafe when we can see the player
+		if ( visible )
+		{
+			Remote_Strafe();
+			return;
+		}
+	}
+
+	//If we don't want to advance, stop here
+	if ( advance == qfalse && visible == qtrue )
+		return;
+
+	//Only try and navigate if the player is visible
+	if ( visible == qfalse )
+	{
+		// Move towards our goal
+		NPCInfo->goalEntity = NPC->enemy;
+		NPCInfo->goalRadius = 12;
+
+		NPC_MoveToGoal(qtrue);
+		return;
+
+	}
+	else
+	{
+		VectorSubtract( NPC->enemy->currentOrigin, NPC->currentOrigin, forward );
+		distance = VectorNormalize( forward );
+	}
+
+	speed = REMOTE_FORWARD_BASE_SPEED + REMOTE_FORWARD_MULTIPLIER * g_spskill->integer;
+	if ( retreat == qtrue )
+	{
+		speed *= -1;
+	}
+	VectorMA( NPC->client->ps.velocity, speed, forward, NPC->client->ps.velocity );
+}
+
+
+/*
+-------------------------
+Remote_Fire
+-------------------------
+*/
+void Remote_Fire (void)
+{
+	vec3_t	delta1, enemy_org1, muzzle1;
+	vec3_t	angleToEnemy1;
+	static	vec3_t	forward, vright, up;
+	static	vec3_t	muzzle;
+	gentity_t	*missile;
+
+	CalcEntitySpot( NPC->enemy, SPOT_HEAD, enemy_org1 );
+	VectorCopy( NPC->currentOrigin, muzzle1 );
+	
+	VectorSubtract (enemy_org1, muzzle1, delta1);
+
+	vectoangles ( delta1, angleToEnemy1 );
+	AngleVectors (angleToEnemy1, forward, vright, up);
+
+	missile = CreateMissile( NPC->currentOrigin, forward, 1000, 10000, NPC );
+
+	G_PlayEffect( "bryar/muzzle_flash", NPC->currentOrigin, forward );
+
+	missile->classname = "briar";
+	missile->s.weapon = WP_BRYAR_PISTOL;
+
+	missile->damage = 10;
+	missile->dflags = DAMAGE_DEATH_KNOCKBACK;
+	missile->methodOfDeath = MOD_ENERGY;
+	missile->clipmask = MASK_SHOT | CONTENTS_LIGHTSABER;
+
+}
+
+/*
+-------------------------
+Remote_Ranged
+-------------------------
+*/
+void Remote_Ranged( qboolean visible, qboolean advance, qboolean retreat )
+{
+
+	if ( TIMER_Done( NPC, "attackDelay" ) )	// Attack?
+	{
+		TIMER_Set( NPC, "attackDelay", Q_irand( 500, 3000 ) );
+		Remote_Fire();
+	}
+
+	if ( NPCInfo->scriptFlags & SCF_CHASE_ENEMIES )
+	{
+		Remote_Hunt( visible, advance, retreat );
+	}
+}
+
+#define	MIN_MELEE_RANGE		320
+#define	MIN_MELEE_RANGE_SQR	( MIN_MELEE_RANGE * MIN_MELEE_RANGE )
+
+#define MIN_DISTANCE		80
+#define MIN_DISTANCE_SQR	( MIN_DISTANCE * MIN_DISTANCE )
+
+/*
+-------------------------
+Remote_Attack
+-------------------------
+*/
+void Remote_Attack( void )
+{
+	if ( TIMER_Done(NPC,"spin") )
+	{
+		TIMER_Set( NPC, "spin", Q_irand( 250, 1500 ) );
+		NPCInfo->desiredYaw += Q_irand( -200, 200 ); 
+	}
+	// Always keep a good height off the ground
+	Remote_MaintainHeight();
+
+	// If we don't have an enemy, just idle
+	if ( NPC_CheckEnemyExt() == qfalse )
+	{
+		Remote_Idle();
+		return;
+	}
+
+	// Rate our distance to the target, and our visibilty
+	float		distance	= (int) DistanceHorizontalSquared( NPC->currentOrigin, NPC->enemy->currentOrigin );	
+//	distance_e	distRate	= ( distance > MIN_MELEE_RANGE_SQR ) ? DIST_LONG : DIST_MELEE;
+	qboolean	visible		= NPC_ClearLOS( NPC->enemy );
+	float		idealDist	= MIN_DISTANCE_SQR+(MIN_DISTANCE_SQR*Q_flrand( 0, 1 ));
+	qboolean	advance		= (qboolean)(distance > idealDist*1.25);
+	qboolean	retreat		= (qboolean)(distance < idealDist*0.75);
+
+	// If we cannot see our target, move to see it
+	if ( visible == qfalse )
+	{
+		if ( NPCInfo->scriptFlags & SCF_CHASE_ENEMIES )
+		{
+			Remote_Hunt( visible, advance, retreat );
+			return;
+		}
+	}
+
+	Remote_Ranged( visible, advance, retreat );
+
+}
+
+/*
+-------------------------
+Remote_Idle
+-------------------------
+*/
+void Remote_Idle( void )
+{
+	Remote_MaintainHeight();
+
+	NPC_BSIdle();
+}
+
+/*
+-------------------------
+Remote_Patrol
+-------------------------
+*/
+void Remote_Patrol( void )
+{
+	Remote_MaintainHeight();
+
+	//If we have somewhere to go, then do that
+	if (!NPC->enemy)
+	{
+		if ( UpdateGoal() )
+		{
+			//start loop sound once we move
+			ucmd.buttons |= BUTTON_WALKING;
+			NPC_MoveToGoal( qtrue );
+		}
+	}
+
+	NPC_UpdateAngles( qtrue, qtrue );
+}
+
+
+/*
+-------------------------
+NPC_BSRemote_Default
+-------------------------
+*/
+void NPC_BSRemote_Default( void )
+{
+	if ( NPC->enemy )
+	{
+		Remote_Attack();
+	}
+	else if ( NPCInfo->scriptFlags & SCF_LOOK_FOR_ENEMIES )
+	{
+		Remote_Patrol();
+	}
+	else
+	{
+		Remote_Idle();
+	}
+}
\ No newline at end of file
diff --git a/code/game/AI_RocketTrooper.cpp b/code/game/AI_RocketTrooper.cpp
new file mode 100644
index 0000000..5b68a70
--- /dev/null
+++ b/code/game/AI_RocketTrooper.cpp
@@ -0,0 +1,908 @@
+#include "g_headers.h"
+#include "b_local.h"
+//#include "g_nav.h"
+//#include "anims.h"
+//#include "wp_saber.h"
+extern qboolean PM_FlippingAnim( int anim );
+extern void NPC_BSST_Patrol( void );
+
+extern void RT_FlyStart( gentity_t *self );
+extern qboolean Q3_TaskIDPending( gentity_t *ent, taskID_t taskType );
+
+#define VELOCITY_DECAY		0.7f
+
+#define RT_FLYING_STRAFE_VEL	60
+#define RT_FLYING_STRAFE_DIS	200
+#define RT_FLYING_UPWARD_PUSH	150
+
+#define RT_FLYING_FORWARD_BASE_SPEED	50
+#define RT_FLYING_FORWARD_MULTIPLIER	10
+
+void RT_Precache( void )
+{
+	G_SoundIndex( "sound/chars/boba/bf_blast-off.wav" );
+	G_SoundIndex( "sound/chars/boba/bf_jetpack_lp.wav" );
+	G_SoundIndex( "sound/chars/boba/bf_land.wav" );
+	G_EffectIndex( "rockettrooper/flameNEW" );
+	G_EffectIndex( "rockettrooper/light_cone" );//extern this?  At least use a different one
+}
+
+extern void NPC_BehaviorSet_Stormtrooper( int bState );
+void RT_RunStormtrooperAI( void )
+{
+	int bState;
+	//Execute our bState
+	if(NPCInfo->tempBehavior)
+	{//Overrides normal behavior until cleared
+		bState = NPCInfo->tempBehavior;
+	}
+	else
+	{
+		if(!NPCInfo->behaviorState)
+			NPCInfo->behaviorState = NPCInfo->defaultBehavior;
+
+		bState = NPCInfo->behaviorState;
+	}
+	NPC_BehaviorSet_Stormtrooper( bState );
+}
+
+void RT_FireDecide( void )
+{
+	qboolean enemyLOS = qfalse;
+	qboolean enemyCS = qfalse;
+	qboolean enemyInFOV = qfalse;
+	//qboolean move = qtrue;
+	qboolean faceEnemy = qfalse;
+	qboolean shoot = qfalse;
+	qboolean hitAlly = qfalse;
+	vec3_t	impactPos;
+	float	enemyDist;
+
+	if ( NPC->client->ps.groundEntityNum == ENTITYNUM_NONE 
+		&& NPC->client->ps.forceJumpZStart
+		&& !PM_FlippingAnim( NPC->client->ps.legsAnim )
+		&& !Q_irand( 0, 10 ) )
+	{//take off
+		RT_FlyStart( NPC );
+	}
+
+	if ( !NPC->enemy )
+	{
+		return;
+	}
+
+	VectorClear( impactPos );
+	enemyDist = DistanceSquared( NPC->currentOrigin, NPC->enemy->currentOrigin );
+
+	vec3_t	enemyDir, shootDir;
+	VectorSubtract( NPC->enemy->currentOrigin, NPC->currentOrigin, enemyDir );
+	VectorNormalize( enemyDir );
+	AngleVectors( NPC->client->ps.viewangles, shootDir, NULL, NULL );
+	float dot = DotProduct( enemyDir, shootDir );
+	if ( dot > 0.5f ||( enemyDist * (1.0f-dot)) < 10000 )
+	{//enemy is in front of me or they're very close and not behind me
+		enemyInFOV = qtrue;
+	}
+
+	if ( enemyDist < MIN_ROCKET_DIST_SQUARED )//128
+	{//enemy within 128
+		if ( (NPC->client->ps.weapon == WP_FLECHETTE || NPC->client->ps.weapon == WP_REPEATER) && 
+			(NPCInfo->scriptFlags & SCF_ALT_FIRE) )
+		{//shooting an explosive, but enemy too close, switch to primary fire
+			NPCInfo->scriptFlags &= ~SCF_ALT_FIRE;
+			//FIXME: we can never go back to alt-fire this way since, after this, we don't know if we were initially supposed to use alt-fire or not...
+		}
+	}
+
+	//can we see our target?
+	if ( TIMER_Done( NPC, "nextAttackDelay" ) && TIMER_Done( NPC, "flameTime" ) )
+	{
+		if ( NPC_ClearLOS( NPC->enemy ) )
+		{
+			NPCInfo->enemyLastSeenTime = level.time;
+			enemyLOS = qtrue;
+
+			if ( NPC->client->ps.weapon == WP_NONE )
+			{
+				enemyCS = qfalse;//not true, but should stop us from firing
+			}
+			else
+			{//can we shoot our target?
+				if ( (NPC->client->ps.weapon == WP_ROCKET_LAUNCHER 
+					|| (NPC->client->ps.weapon == WP_CONCUSSION && !(NPCInfo->scriptFlags&SCF_ALT_FIRE))
+					|| (NPC->client->ps.weapon == WP_FLECHETTE && (NPCInfo->scriptFlags&SCF_ALT_FIRE))) && enemyDist < MIN_ROCKET_DIST_SQUARED )//128*128
+				{
+					enemyCS = qfalse;//not true, but should stop us from firing
+					hitAlly = qtrue;//us!
+					//FIXME: if too close, run away!
+				}
+				else if ( enemyInFOV )
+				{//if enemy is FOV, go ahead and check for shooting
+					int hit = NPC_ShotEntity( NPC->enemy, impactPos );
+					gentity_t *hitEnt = &g_entities[hit];
+
+					if ( hit == NPC->enemy->s.number 
+						|| ( hitEnt && hitEnt->client && hitEnt->client->playerTeam == NPC->client->enemyTeam )
+						|| ( hitEnt && hitEnt->takedamage && ((hitEnt->svFlags&SVF_GLASS_BRUSH)||hitEnt->health < 40||NPC->s.weapon == WP_EMPLACED_GUN) ) )
+					{//can hit enemy or enemy ally or will hit glass or other minor breakable (or in emplaced gun), so shoot anyway
+						enemyCS = qtrue;
+						//NPC_AimAdjust( 2 );//adjust aim better longer we have clear shot at enemy
+						VectorCopy( NPC->enemy->currentOrigin, NPCInfo->enemyLastSeenLocation );
+					}
+					else
+					{//Hmm, have to get around this bastard
+						//NPC_AimAdjust( 1 );//adjust aim better longer we can see enemy
+						if ( hitEnt && hitEnt->client && hitEnt->client->playerTeam == NPC->client->playerTeam )
+						{//would hit an ally, don't fire!!!
+							hitAlly = qtrue;
+						}
+						else
+						{//Check and see where our shot *would* hit... if it's not close to the enemy (within 256?), then don't fire
+						}
+					}
+				}
+				else
+				{
+					enemyCS = qfalse;//not true, but should stop us from firing
+				}
+			}
+		}
+		else if ( gi.inPVS( NPC->enemy->currentOrigin, NPC->currentOrigin ) )
+		{
+			NPCInfo->enemyLastSeenTime = level.time;
+			faceEnemy = qtrue;
+			//NPC_AimAdjust( -1 );//adjust aim worse longer we cannot see enemy
+		}
+
+		if ( NPC->client->ps.weapon == WP_NONE )
+		{
+			faceEnemy = qfalse;
+			shoot = qfalse;
+		}
+		else
+		{
+			if ( enemyLOS )
+			{//FIXME: no need to face enemy if we're moving to some other goal and he's too far away to shoot?
+				faceEnemy = qtrue;
+			}
+			if ( enemyCS )
+			{
+				shoot = qtrue;
+			}
+		}
+
+		if ( !enemyCS )
+		{//if have a clear shot, always try
+			//See if we should continue to fire on their last position
+			//!TIMER_Done( NPC, "stick" ) || 
+			if ( !hitAlly //we're not going to hit an ally
+				&& enemyInFOV //enemy is in our FOV //FIXME: or we don't have a clear LOS?
+				&& NPCInfo->enemyLastSeenTime > 0 )//we've seen the enemy
+			{
+				if ( level.time - NPCInfo->enemyLastSeenTime < 10000 )//we have seem the enemy in the last 10 seconds
+				{
+					if ( !Q_irand( 0, 10 ) )
+					{
+						//Fire on the last known position
+						vec3_t	muzzle, dir, angles;
+						qboolean tooClose = qfalse;
+						qboolean tooFar = qfalse;
+
+						CalcEntitySpot( NPC, SPOT_HEAD, muzzle );
+						if ( VectorCompare( impactPos, vec3_origin ) )
+						{//never checked ShotEntity this frame, so must do a trace...
+							trace_t tr;
+							//vec3_t	mins = {-2,-2,-2}, maxs = {2,2,2};
+							vec3_t	forward, end;
+							AngleVectors( NPC->client->ps.viewangles, forward, NULL, NULL );
+							VectorMA( muzzle, 8192, forward, end );
+							gi.trace( &tr, muzzle, vec3_origin, vec3_origin, end, NPC->s.number, MASK_SHOT );
+							VectorCopy( tr.endpos, impactPos );
+						}
+
+						//see if impact would be too close to me
+						float distThreshold = 16384/*128*128*/;//default
+						switch ( NPC->s.weapon )
+						{
+						case WP_ROCKET_LAUNCHER:
+						case WP_FLECHETTE:
+						case WP_THERMAL:
+						case WP_TRIP_MINE:
+						case WP_DET_PACK:
+							distThreshold = 65536/*256*256*/;
+							break;
+						case WP_REPEATER:
+							if ( NPCInfo->scriptFlags&SCF_ALT_FIRE )
+							{
+								distThreshold = 65536/*256*256*/;
+							}
+							break;
+						case WP_CONCUSSION:
+							if ( !(NPCInfo->scriptFlags&SCF_ALT_FIRE) )
+							{
+								distThreshold = 65536/*256*256*/;
+							}
+							break;
+						default:
+							break;
+						}
+
+						float dist = DistanceSquared( impactPos, muzzle );
+
+						if ( dist < distThreshold )
+						{//impact would be too close to me
+							tooClose = qtrue;
+						}
+						else if ( level.time - NPCInfo->enemyLastSeenTime > 5000 ||
+							(NPCInfo->group && level.time - NPCInfo->group->lastSeenEnemyTime > 5000 ))
+						{//we've haven't seen them in the last 5 seconds
+							//see if it's too far from where he is
+							distThreshold = 65536/*256*256*/;//default
+							switch ( NPC->s.weapon )
+							{
+							case WP_ROCKET_LAUNCHER:
+							case WP_FLECHETTE:
+							case WP_THERMAL:
+							case WP_TRIP_MINE:
+							case WP_DET_PACK:
+								distThreshold = 262144/*512*512*/;
+								break;
+							case WP_REPEATER:
+								if ( NPCInfo->scriptFlags&SCF_ALT_FIRE )
+								{
+									distThreshold = 262144/*512*512*/;
+								}
+								break;
+							case WP_CONCUSSION:
+								if ( !(NPCInfo->scriptFlags&SCF_ALT_FIRE) )
+								{
+									distThreshold = 262144/*512*512*/;
+								}
+								break;
+							default:
+								break;
+							}
+							dist = DistanceSquared( impactPos, NPCInfo->enemyLastSeenLocation );
+							if ( dist > distThreshold )
+							{//impact would be too far from enemy
+								tooFar = qtrue;
+							}
+						}
+
+						if ( !tooClose && !tooFar )
+						{//okay too shoot at last pos
+							VectorSubtract( NPCInfo->enemyLastSeenLocation, muzzle, dir );
+							VectorNormalize( dir );
+							vectoangles( dir, angles );
+
+							NPCInfo->desiredYaw		= angles[YAW];
+							NPCInfo->desiredPitch	= angles[PITCH];
+
+							shoot = qtrue;
+							faceEnemy = qfalse;
+						}
+					}
+				}
+			}
+		}
+
+		//FIXME: don't shoot right away!
+		if ( NPC->client->fireDelay )
+		{
+			if ( NPC->s.weapon == WP_ROCKET_LAUNCHER
+				|| (NPC->s.weapon == WP_CONCUSSION&&!(NPCInfo->scriptFlags&SCF_ALT_FIRE)) )
+			{
+				if ( !enemyLOS || !enemyCS )
+				{//cancel it
+					NPC->client->fireDelay = 0;
+				}
+				else
+				{//delay our next attempt
+					TIMER_Set( NPC, "nextAttackDelay", Q_irand( 1000, 3000 ) );//FIXME: base on g_spskill
+				}
+			}
+		}
+		else if ( shoot )
+		{//try to shoot if it's time
+			if ( TIMER_Done( NPC, "nextAttackDelay" ) )
+			{
+				if( !(NPCInfo->scriptFlags & SCF_FIRE_WEAPON) ) // we've already fired, no need to do it again here
+				{
+					WeaponThink( qtrue );
+				}
+				//NASTY
+				int altChance = 6;//FIXME: base on g_spskill
+				if ( NPC->s.weapon == WP_ROCKET_LAUNCHER )
+				{
+					if ( (ucmd.buttons&BUTTON_ATTACK) 
+						&& !Q_irand( 0, altChance ) )
+					{//every now and then, shoot a homing rocket
+						ucmd.buttons &= ~BUTTON_ATTACK;
+						ucmd.buttons |= BUTTON_ALT_ATTACK;
+						NPC->client->fireDelay = Q_irand( 1000, 3000 );//FIXME: base on g_spskill
+					}
+				}
+				else if ( NPC->s.weapon == WP_CONCUSSION )
+				{
+					if ( (ucmd.buttons&BUTTON_ATTACK) 
+						&& Q_irand( 0, altChance*5 ) )
+					{//fire the beam shot
+						ucmd.buttons &= ~BUTTON_ATTACK;
+						ucmd.buttons |= BUTTON_ALT_ATTACK;
+						TIMER_Set( NPC, "nextAttackDelay", Q_irand( 1500, 2500 ) );//FIXME: base on g_spskill
+					}
+					else
+					{//fire the rocket-like shot
+						TIMER_Set( NPC, "nextAttackDelay", Q_irand( 3000, 5000 ) );//FIXME: base on g_spskill
+					}
+				}
+			}
+		}
+	}
+}
+
+//=====================================================================================
+//FLYING behavior 
+//=====================================================================================
+qboolean RT_Flying( gentity_t *self )
+{
+	return ((qboolean)(self->client->moveType==MT_FLYSWIM));
+}
+
+void RT_FlyStart( gentity_t *self )
+{//switch to seeker AI for a while
+	if ( TIMER_Done( self, "jetRecharge" ) 
+		&& !RT_Flying( self ) )
+	{
+		self->client->ps.gravity = 0;
+		self->svFlags |= SVF_CUSTOM_GRAVITY;
+		self->client->moveType = MT_FLYSWIM;
+		//Inform NPC_HandleAIFlags we want to fly
+		self->NPC->aiFlags |= NPCAI_FLY;
+		self->lastInAirTime = level.time;
+		
+		//start jet effect
+		self->client->jetPackTime = Q3_INFINITE;
+		if ( self->genericBolt1 != -1 )
+		{
+			G_PlayEffect( G_EffectIndex( "rockettrooper/flameNEW" ), self->playerModel, self->genericBolt1, self->s.number, self->currentOrigin, qtrue, qtrue );
+		}
+		if ( self->genericBolt2 != -1 )
+		{
+			G_PlayEffect( G_EffectIndex( "rockettrooper/flameNEW" ), self->playerModel, self->genericBolt2, self->s.number, self->currentOrigin, qtrue, qtrue );
+		}
+
+		//take-off sound
+		G_SoundOnEnt( self, CHAN_ITEM, "sound/chars/boba/bf_blast-off.wav" );
+		//jet loop sound
+		self->s.loopSound = G_SoundIndex( "sound/chars/boba/bf_jetpack_lp.wav"  );
+		if ( self->NPC )
+		{
+			self->count = Q3_INFINITE; // SEEKER shot ammo count
+		}
+	}
+}
+
+void RT_FlyStop( gentity_t *self )
+{
+	self->client->ps.gravity = g_gravity->value;
+	self->svFlags &= ~SVF_CUSTOM_GRAVITY;
+	self->client->moveType = MT_RUNJUMP;
+	//Stop the effect
+	self->client->jetPackTime = 0;
+	if ( self->genericBolt1 != -1 )
+	{
+		G_StopEffect("rockettrooper/flameNEW", self->playerModel, self->genericBolt1, self->s.number );
+	}
+	if ( self->genericBolt2 != -1 )
+	{
+		G_StopEffect("rockettrooper/flameNEW", self->playerModel, self->genericBolt2, self->s.number );
+	}
+	//stop jet loop sound
+	self->s.loopSound = 0;
+	G_SoundOnEnt( self, CHAN_ITEM, "sound/chars/boba/bf_land.wav" );
+
+	if ( self->NPC )
+	{
+		self->count = 0; // SEEKER shot ammo count
+		TIMER_Set( self, "jetRecharge", Q_irand( 1000, 5000 ) );
+		TIMER_Set( self, "jumpChaseDebounce", Q_irand( 500, 2000 ) );
+	}
+}
+
+void RT_JetPackEffect( int duration )
+{
+	if ( NPC->genericBolt1 != -1 )
+	{
+		G_PlayEffect( G_EffectIndex( "rockettrooper/flameNEW" ), NPC->playerModel, NPC->genericBolt1, NPC->s.number, NPC->currentOrigin, duration, qtrue );
+	}
+	if ( NPC->genericBolt2 != -1 )
+	{
+		G_PlayEffect( G_EffectIndex( "rockettrooper/flameNEW" ), NPC->playerModel, NPC->genericBolt2, NPC->s.number, NPC->currentOrigin, duration, qtrue );
+	}
+
+	//take-off sound
+	G_SoundOnEnt( NPC, CHAN_ITEM, "sound/chars/boba/bf_blast-off.wav" );
+}
+
+void RT_Flying_ApplyFriction( float frictionScale )
+{
+	if ( NPC->client->ps.velocity[0] )
+	{
+		NPC->client->ps.velocity[0] *= VELOCITY_DECAY;///frictionScale;
+
+		if ( fabs( NPC->client->ps.velocity[0] ) < 1 )
+		{
+			NPC->client->ps.velocity[0] = 0;
+		}
+	}
+
+	if ( NPC->client->ps.velocity[1] )
+	{
+		NPC->client->ps.velocity[1] *= VELOCITY_DECAY;///frictionScale;
+
+		if ( fabs( NPC->client->ps.velocity[1] ) < 1 )
+		{
+			NPC->client->ps.velocity[1] = 0;
+		}
+	}
+}
+
+void RT_Flying_MaintainHeight( void )
+{	
+	float	dif = 0;
+
+	// Update our angles regardless
+	NPC_UpdateAngles( qtrue, qtrue );
+
+	if ( NPC->forcePushTime > level.time )
+	{//if being pushed, we don't have control over our movement
+		return;
+	}
+
+	if ( (NPC->client->ps.pm_flags&PMF_TIME_KNOCKBACK) )
+	{//don't slow down for a bit
+		if ( NPC->client->ps.pm_time > 0 )
+		{
+			VectorScale( NPC->client->ps.velocity, 0.9f, NPC->client->ps.velocity );
+			return;
+		}
+	}
+
+	/*
+	if ( (NPC->client->ps.eFlags&EF_FORCE_GRIPPED) )
+	{
+		RT_Flying_ApplyFriction( 3.0f );
+		return;
+	}
+	*/
+	// If we have an enemy, we should try to hover at or a little below enemy eye level
+	if ( NPC->enemy 
+		&& (!Q3_TaskIDPending( NPC, TID_MOVE_NAV ) || !NPCInfo->goalEntity ) )
+	{
+		if (TIMER_Done( NPC, "heightChange" ))
+		{
+			TIMER_Set( NPC,"heightChange",Q_irand( 1000, 3000 ));
+			
+			float enemyZHeight = NPC->enemy->currentOrigin[2];
+			if ( NPC->enemy->client 
+				&& NPC->enemy->client->ps.groundEntityNum == ENTITYNUM_NONE
+				&& (NPC->enemy->client->ps.forcePowersActive&(1<<FP_LEVITATION)) )
+			{//so we don't go up when they force jump up at us
+				enemyZHeight = NPC->enemy->client->ps.forceJumpZStart;
+			}
+
+			// Find the height difference
+			dif = (enemyZHeight +  Q_flrand( NPC->enemy->maxs[2]/2, NPC->enemy->maxs[2]+8 )) - NPC->currentOrigin[2]; 
+
+			float	difFactor = 10.0f;
+
+			// cap to prevent dramatic height shifts
+			if ( fabs( dif ) > 2*difFactor )
+			{
+				if ( fabs( dif ) > 20*difFactor )
+				{
+					dif = ( dif < 0 ? -20*difFactor : 20*difFactor );
+				}
+
+				NPC->client->ps.velocity[2] = (NPC->client->ps.velocity[2]+dif)/2;
+			}
+			NPC->client->ps.velocity[2] *= Q_flrand( 0.85f, 1.25f );
+		}
+		else
+		{//don't get too far away from height of enemy...
+			float enemyZHeight = NPC->enemy->currentOrigin[2];
+			if ( NPC->enemy->client 
+				&& NPC->enemy->client->ps.groundEntityNum == ENTITYNUM_NONE
+				&& (NPC->enemy->client->ps.forcePowersActive&(1<<FP_LEVITATION)) )
+			{//so we don't go up when they force jump up at us
+				enemyZHeight = NPC->enemy->client->ps.forceJumpZStart;
+			}
+			dif = NPC->currentOrigin[2] - (enemyZHeight+64);
+			float maxHeight = 200;
+			float hDist = DistanceHorizontal( NPC->enemy->currentOrigin, NPC->currentOrigin );
+			if ( hDist < 512 )
+			{
+				maxHeight *= hDist/512;
+			}
+			if ( dif > maxHeight )
+			{
+				if ( NPC->client->ps.velocity[2] > 0 )//FIXME: or: we can't see him anymore
+				{//slow down
+					if ( NPC->client->ps.velocity[2] )
+					{
+						NPC->client->ps.velocity[2] *= VELOCITY_DECAY;
+
+						if ( fabs( NPC->client->ps.velocity[2] ) < 2 )
+						{
+							NPC->client->ps.velocity[2] = 0;
+						}
+					}
+				}
+				else
+				{//start coming back down
+					NPC->client->ps.velocity[2] -= 4;
+				}
+			}
+			else if ( dif < -200 && NPC->client->ps.velocity[2] < 0 )//we're way below him
+			{
+				if ( NPC->client->ps.velocity[2] < 0 )//FIXME: or: we can't see him anymore
+				{//slow down
+					if ( NPC->client->ps.velocity[2] )
+					{
+						NPC->client->ps.velocity[2] *= VELOCITY_DECAY;
+
+						if ( fabs( NPC->client->ps.velocity[2] ) > -2 )
+						{
+							NPC->client->ps.velocity[2] = 0;
+						}
+					}
+				}
+				else
+				{//start going back up
+					NPC->client->ps.velocity[2] += 4;
+				}
+			}
+		}
+	}
+	else
+	{
+		gentity_t *goal = NULL;
+
+		if ( NPCInfo->goalEntity )	// Is there a goal?
+		{
+			goal = NPCInfo->goalEntity;
+		}
+		else
+		{
+			goal = NPCInfo->lastGoalEntity;
+		}
+		if ( goal )
+		{
+			dif = goal->currentOrigin[2] - NPC->currentOrigin[2];
+		}
+		else if ( VectorCompare( NPC->pos1, vec3_origin ) )
+		{//have a starting position as a reference point
+			dif = NPC->pos1[2] - NPC->currentOrigin[2];
+		}
+
+		if ( fabs( dif ) > 24 )
+		{
+			ucmd.upmove = ( ucmd.upmove < 0 ? -4 : 4 );
+		}
+		else
+		{
+			if ( NPC->client->ps.velocity[2] )
+			{
+				NPC->client->ps.velocity[2] *= VELOCITY_DECAY;
+
+				if ( fabs( NPC->client->ps.velocity[2] ) < 2 )
+				{
+					NPC->client->ps.velocity[2] = 0;
+				}
+			}
+		}
+	}
+
+	// Apply friction
+	RT_Flying_ApplyFriction( 1.0f );
+}
+
+void RT_Flying_Strafe( void )
+{
+	int		side;
+	vec3_t	end, right, dir;
+	trace_t	tr;
+
+	if ( random() > 0.7f 
+		|| !NPC->enemy 
+		|| !NPC->enemy->client )
+	{
+		// Do a regular style strafe
+		AngleVectors( NPC->client->renderInfo.eyeAngles, NULL, right, NULL );
+
+		// Pick a random strafe direction, then check to see if doing a strafe would be
+		//	reasonably valid
+		side = ( rand() & 1 ) ? -1 : 1;
+		VectorMA( NPC->currentOrigin, RT_FLYING_STRAFE_DIS * side, right, end );
+
+		gi.trace( &tr, NPC->currentOrigin, NULL, NULL, end, NPC->s.number, MASK_SOLID );
+
+		// Close enough
+		if ( tr.fraction > 0.9f )
+		{
+			float vel = RT_FLYING_STRAFE_VEL+Q_flrand(-20,20);
+			VectorMA( NPC->client->ps.velocity, vel*side, right, NPC->client->ps.velocity );
+			if ( !Q_irand( 0, 3 ) )
+			{
+				// Add a slight upward push
+				float upPush = RT_FLYING_UPWARD_PUSH;
+				if ( NPC->client->ps.velocity[2] < 300 )
+				{
+					if ( NPC->client->ps.velocity[2] < 300+upPush )
+					{
+						NPC->client->ps.velocity[2] += upPush;
+					}
+					else
+					{
+						NPC->client->ps.velocity[2] = 300;
+					}
+				}
+			}
+
+			NPCInfo->standTime = level.time + 1000 + random() * 500;
+		}
+	}
+	else
+	{
+		// Do a strafe to try and keep on the side of their enemy
+		AngleVectors( NPC->enemy->client->renderInfo.eyeAngles, dir, right, NULL );
+
+		// Pick a random side
+		side = ( rand() & 1 ) ? -1 : 1;
+		float	stDis = RT_FLYING_STRAFE_DIS*2.0f;
+		VectorMA( NPC->enemy->currentOrigin, stDis * side, right, end );
+
+		// then add a very small bit of random in front of/behind the player action
+		VectorMA( end, crandom() * 25, dir, end );
+
+		gi.trace( &tr, NPC->currentOrigin, NULL, NULL, end, NPC->s.number, MASK_SOLID );
+
+		// Close enough
+		if ( tr.fraction > 0.9f )
+		{
+			float vel = (RT_FLYING_STRAFE_VEL*4)+Q_flrand(-20,20);
+			VectorSubtract( tr.endpos, NPC->currentOrigin, dir );
+			dir[2] *= 0.25; // do less upward change
+			float dis = VectorNormalize( dir );
+			if ( dis > vel )
+			{
+				dis = vel;
+			}
+			// Try to move the desired enemy side
+			VectorMA( NPC->client->ps.velocity, dis, dir, NPC->client->ps.velocity );
+
+			if ( !Q_irand( 0, 3 ) )
+			{
+				float upPush = RT_FLYING_UPWARD_PUSH;
+				// Add a slight upward push
+				if ( NPC->client->ps.velocity[2] < 300 )
+				{
+					if ( NPC->client->ps.velocity[2] < 300+upPush )
+					{
+						NPC->client->ps.velocity[2] += upPush;
+					}
+					else
+					{
+						NPC->client->ps.velocity[2] = 300;
+					}
+				}
+				else if ( NPC->client->ps.velocity[2] > 300 )
+				{
+					NPC->client->ps.velocity[2] = 300;
+				}
+			}
+
+			NPCInfo->standTime = level.time + 2500 + random() * 500;
+		}
+	}
+}
+
+void RT_Flying_Hunt( qboolean visible, qboolean advance )
+{
+	float	distance, speed;
+	vec3_t	forward;
+
+	if ( NPC->forcePushTime >= level.time )
+		//|| (NPC->client->ps.eFlags&EF_FORCE_GRIPPED) )
+	{//if being pushed, we don't have control over our movement
+		NPC->delay = 0;
+		return;
+	}
+	NPC_FaceEnemy( qtrue );
+
+	// If we're not supposed to stand still, pursue the player
+	if ( NPCInfo->standTime < level.time )
+	{
+		// Only strafe when we can see the player
+		if ( visible )
+		{
+			NPC->delay = 0;
+			RT_Flying_Strafe();
+			return;
+		}
+	}
+
+	// If we don't want to advance, stop here
+	if ( advance  )
+	{
+		// Only try and navigate if the player is visible
+		if ( visible == qfalse )
+		{
+			// Move towards our goal
+			NPCInfo->goalEntity = NPC->enemy;
+			NPCInfo->goalRadius = 24;
+
+			NPC->delay = 0;
+			NPC_MoveToGoal(qtrue);
+			return;
+
+		}
+	}
+	//else move straight at/away from him
+	VectorSubtract( NPC->enemy->currentOrigin, NPC->currentOrigin, forward );
+	forward[2] *= 0.1f;
+	distance = VectorNormalize( forward );
+
+	speed = RT_FLYING_FORWARD_BASE_SPEED + RT_FLYING_FORWARD_MULTIPLIER * g_spskill->integer;
+	if ( advance && distance < Q_flrand( 256, 3096 ) )
+	{
+		NPC->delay = 0;
+		VectorMA( NPC->client->ps.velocity, speed, forward, NPC->client->ps.velocity );
+	}
+	else if ( distance < Q_flrand( 0, 128 ) )
+	{
+		if ( NPC->health <= 50 )
+		{//always back off
+			NPC->delay = 0;
+		}
+		else if ( !TIMER_Done( NPC, "backoffTime" ) )
+		{//still backing off from end of last delay
+			NPC->delay = 0;
+		}
+		else if ( !NPC->delay )
+		{//start a new delay
+			NPC->delay = Q_irand( 0, 10+(20*(2-g_spskill->integer)) );
+		}
+		else
+		{//continue the current delay
+			NPC->delay--;
+		}
+		if ( !NPC->delay )
+		{//delay done, now back off for a few seconds!
+			TIMER_Set( NPC, "backoffTime", Q_irand( 2000, 5000 ) );
+			VectorMA( NPC->client->ps.velocity, speed*-2, forward, NPC->client->ps.velocity );
+		}
+	}
+	else
+	{
+		NPC->delay = 0;
+	}
+}
+
+void RT_Flying_Ranged( qboolean visible, qboolean advance )
+{
+	if ( NPCInfo->scriptFlags & SCF_CHASE_ENEMIES )
+	{
+		RT_Flying_Hunt( visible, advance );
+	}
+}
+
+void RT_Flying_Attack( void )
+{
+	// Always keep a good height off the ground
+	RT_Flying_MaintainHeight();
+
+	// Rate our distance to the target, and our visibilty
+	float		distance	= DistanceHorizontalSquared( NPC->currentOrigin, NPC->enemy->currentOrigin );	
+	qboolean	visible		= NPC_ClearLOS( NPC->enemy );
+	qboolean	advance		= (qboolean)(distance>(256.0f*256.0f));
+
+	// If we cannot see our target, move to see it
+	if ( visible == qfalse )
+	{
+		if ( NPCInfo->scriptFlags & SCF_CHASE_ENEMIES )
+		{
+			RT_Flying_Hunt( visible, advance );
+			return;
+		}
+	}
+
+	RT_Flying_Ranged( visible, advance );
+}
+
+void RT_Flying_Think( void )
+{
+	if ( Q3_TaskIDPending( NPC, TID_MOVE_NAV ) 
+		&& UpdateGoal() )
+	{//being scripted to go to a certain spot, don't maintain height
+		if ( NPC_MoveToGoal( qtrue ) )
+		{//we could macro-nav to our goal
+			if ( NPC->enemy && NPC->enemy->health && NPC->enemy->inuse )
+			{
+				NPC_FaceEnemy( qtrue );
+				RT_FireDecide();
+			}
+		}
+		else
+		{//frick, no where to nav to, keep us in the air!
+			RT_Flying_MaintainHeight();
+		}
+		return;
+	}
+
+	if ( NPC->random == 0.0f )
+	{
+		// used to offset seekers around a circle so they don't occupy the same spot.  This is not a fool-proof method.
+		NPC->random = random() * 6.3f; // roughly 2pi
+	}
+
+	if ( NPC->enemy && NPC->enemy->health && NPC->enemy->inuse )
+	{
+		RT_Flying_Attack();
+		RT_FireDecide();
+		return;
+	}
+	else
+	{
+		RT_Flying_MaintainHeight();
+		RT_RunStormtrooperAI();
+		return;
+	}
+}
+
+
+//=====================================================================================
+//ON GROUND WITH ENEMY behavior
+//=====================================================================================
+
+
+//=====================================================================================
+//DEFAULT behavior
+//=====================================================================================
+extern void RT_CheckJump( void );
+void NPC_BSRT_Default( void )
+{
+	//FIXME: custom pain and death funcs:
+		//pain3 is in air
+		//die in air is both_falldeath1
+		//attack1 is on ground, attack2 is in air
+
+	//FIXME: this doesn't belong here
+	if ( NPC->client->ps.groundEntityNum != ENTITYNUM_NONE )
+	{
+		if ( NPCInfo->rank >= RANK_LT )//&& !Q_irand( 0, 50 ) )
+		{//officers always stay in the air
+			NPC->client->ps.velocity[2] = Q_irand( 50, 125 );
+			NPC->NPC->aiFlags |= NPCAI_FLY;	//fixme also, Inform NPC_HandleAIFlags we want to fly
+		}
+	}
+
+	if ( RT_Flying( NPC ) )
+	{//FIXME: only officers need do this, right?
+		RT_Flying_Think();
+	}
+	else if ( NPC->enemy != NULL )
+	{//rocketrooper on ground with enemy
+		UpdateGoal();
+		RT_RunStormtrooperAI();
+		RT_CheckJump();
+		//NPC_BSST_Default();//FIXME: add missile avoidance
+		//RT_Hunt();//NPC_BehaviorSet_Jedi( bState );
+	}
+	else
+	{//shouldn't have gotten in here
+		RT_RunStormtrooperAI();
+		//NPC_BSST_Patrol();
+	}
+}
\ No newline at end of file
diff --git a/code/game/AI_SaberDroid.cpp b/code/game/AI_SaberDroid.cpp
new file mode 100644
index 0000000..03c49cc
--- /dev/null
+++ b/code/game/AI_SaberDroid.cpp
@@ -0,0 +1,443 @@
+// leave this line at the top of all AI_xxxx.cpp files for PCH reasons...
+#include "g_headers.h"
+
+// leave this line at the top of all AI_xxxx.cpp files for PCH reasons...
+#include "g_headers.h"
+
+
+#include "b_local.h"
+#include "g_nav.h"
+#include "anims.h"
+#include "g_navigator.h"
+#include "wp_saber.h"
+
+//extern void G_AddVoiceEvent( gentity_t *self, int event, int speakDebounceTime );
+extern void WP_DeactivateSaber( gentity_t *self, qboolean clearLength = qfalse );
+extern int PM_AnimLength( int index, animNumber_t anim );
+
+qboolean NPC_CheckPlayerTeamStealth( void );
+
+static qboolean enemyLOS;
+static qboolean enemyCS;
+static qboolean faceEnemy;
+static qboolean move;
+static qboolean shoot;
+static float	enemyDist;
+
+/*
+void NPC_SaberDroid_PlayConfusionSound( gentity_t *self )
+{//FIXME: make this a custom sound in sound set
+	if ( self->health > 0 )
+	{
+		G_AddVoiceEvent( self, Q_irand(EV_CONFUSE1, EV_CONFUSE3), 2000 );
+	}
+	//reset him to be totally unaware again
+	TIMER_Set( self, "enemyLastVisible", 0 );
+	TIMER_Set( self, "flee", 0 );
+	self->NPC->squadState = SQUAD_IDLE;
+	self->NPC->tempBehavior = BS_DEFAULT;
+	
+	//self->NPC->behaviorState = BS_PATROL;
+	G_ClearEnemy( self );//FIXME: or just self->enemy = NULL;?
+
+	self->NPC->investigateCount = 0;
+}
+*/
+
+/*
+-------------------------
+ST_Move
+-------------------------
+*/
+
+static qboolean SaberDroid_Move( void )
+{
+	NPCInfo->combatMove = qtrue;//always move straight toward our goal
+	UpdateGoal();
+	if ( !NPCInfo->goalEntity )
+	{
+		NPCInfo->goalEntity = NPC->enemy;
+	}
+	NPCInfo->goalRadius = 30.0f;
+
+	qboolean	moved = NPC_MoveToGoal( qtrue );
+//	navInfo_t	info;
+	
+	//Get the move info
+//	NAV_GetLastMove( info );
+
+	//FIXME: if we bump into another one of our guys and can't get around him, just stop!
+	//If we hit our target, then stop and fire!
+//	if ( info.flags & NIF_COLLISION ) 
+//	{
+//		if ( info.blocker == NPC->enemy )
+//		{
+//			SaberDroid_HoldPosition();
+//		}
+//	}
+
+	//If our move failed, then reset
+	/*
+	if ( moved == qfalse )
+	{//couldn't get to enemy
+		//just hang here
+		SaberDroid_HoldPosition();
+	}
+	*/
+
+	return moved;
+}
+
+/*
+-------------------------
+NPC_BSSaberDroid_Patrol
+-------------------------
+*/
+
+void NPC_BSSaberDroid_Patrol( void )
+{//FIXME: pick up on bodies of dead buddies?
+	if ( NPCInfo->confusionTime < level.time )
+	{
+		//Look for any enemies
+		if ( NPCInfo->scriptFlags&SCF_LOOK_FOR_ENEMIES )
+		{
+			if ( NPC_CheckPlayerTeamStealth() )
+			{
+				//NPCInfo->behaviorState = BS_HUNT_AND_KILL;//should be automatic now
+				//NPC_AngerSound();
+				NPC_UpdateAngles( qtrue, qtrue );
+				return;
+			}
+		}
+
+		if ( !(NPCInfo->scriptFlags&SCF_IGNORE_ALERTS) )
+		{
+			//Is there danger nearby
+			int alertEvent = NPC_CheckAlertEvents( qtrue, qtrue, -1, qfalse, AEL_SUSPICIOUS );
+			//There is an event to look at
+			if ( alertEvent >= 0 )//&& level.alertEvents[alertEvent].ID != NPCInfo->lastAlertID )
+			{
+				//NPCInfo->lastAlertID = level.alertEvents[alertEvent].ID;
+				if ( level.alertEvents[alertEvent].level >= AEL_DISCOVERED )
+				{
+					if ( level.alertEvents[alertEvent].owner && 
+						level.alertEvents[alertEvent].owner->client && 
+						level.alertEvents[alertEvent].owner->health >= 0 &&
+						level.alertEvents[alertEvent].owner->client->playerTeam == NPC->client->enemyTeam )
+					{//an enemy
+						G_SetEnemy( NPC, level.alertEvents[alertEvent].owner );
+						//NPCInfo->enemyLastSeenTime = level.time;
+						TIMER_Set( NPC, "attackDelay", Q_irand( 500, 2500 ) );
+					}
+				}
+				else
+				{//FIXME: get more suspicious over time?
+					//Save the position for movement (if necessary)
+					VectorCopy( level.alertEvents[alertEvent].position, NPCInfo->investigateGoal );
+					NPCInfo->investigateDebounceTime = level.time + Q_irand( 500, 1000 );
+					if ( level.alertEvents[alertEvent].level == AEL_SUSPICIOUS )
+					{//suspicious looks longer
+						NPCInfo->investigateDebounceTime += Q_irand( 500, 2500 );
+					}
+				}
+			}
+
+			if ( NPCInfo->investigateDebounceTime > level.time )
+			{//FIXME: walk over to it, maybe?  Not if not chase enemies
+				//NOTE: stops walking or doing anything else below
+				vec3_t	dir, angles;
+				float	o_yaw, o_pitch;
+				
+				VectorSubtract( NPCInfo->investigateGoal, NPC->client->renderInfo.eyePoint, dir );
+				vectoangles( dir, angles );
+				
+				o_yaw = NPCInfo->desiredYaw;
+				o_pitch = NPCInfo->desiredPitch;
+				NPCInfo->desiredYaw = angles[YAW];
+				NPCInfo->desiredPitch = angles[PITCH];
+				
+				NPC_UpdateAngles( qtrue, qtrue );
+
+				NPCInfo->desiredYaw = o_yaw;
+				NPCInfo->desiredPitch = o_pitch;
+				return;
+			}
+		}
+	}
+
+	//If we have somewhere to go, then do that
+	if ( UpdateGoal() )
+	{
+		ucmd.buttons |= BUTTON_WALKING;
+		NPC_MoveToGoal( qtrue );
+	}
+	else if ( !NPC->client->ps.weaponTime
+		&& TIMER_Done( NPC, "attackDelay" )
+		&& TIMER_Done( NPC, "inactiveDelay" ) )
+	{
+		if ( NPC->client->ps.SaberActive() )
+		{
+			WP_DeactivateSaber( NPC, qfalse );
+			NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_TURNOFF, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+		}
+	}
+
+	NPC_UpdateAngles( qtrue, qtrue );
+}
+
+int SaberDroid_PowerLevelForSaberAnim( gentity_t *self )
+{
+	switch ( self->client->ps.legsAnim )
+	{
+	case BOTH_A2_TR_BL:
+		if ( self->client->ps.torsoAnimTimer <= 200 )
+		{//end of anim
+			return FORCE_LEVEL_0;
+		}
+		else if ( PM_AnimLength( self->client->clientInfo.animFileIndex, (animNumber_t)self->client->ps.legsAnim ) - self->client->ps.torsoAnimTimer < 200 )
+		{//beginning of anim
+			return FORCE_LEVEL_0;
+		}
+		return FORCE_LEVEL_2;
+		break;
+	case BOTH_A1_BL_TR:
+		if ( self->client->ps.torsoAnimTimer <= 300 )
+		{//end of anim
+			return FORCE_LEVEL_0;
+		}
+		else if ( PM_AnimLength( self->client->clientInfo.animFileIndex, (animNumber_t)self->client->ps.legsAnim ) - self->client->ps.torsoAnimTimer < 200 )
+		{//beginning of anim
+			return FORCE_LEVEL_0;
+		}
+		return FORCE_LEVEL_1;
+		break;
+	case BOTH_A1__L__R:
+		if ( self->client->ps.torsoAnimTimer <= 250 )
+		{//end of anim
+			return FORCE_LEVEL_0;
+		}
+		else if ( PM_AnimLength( self->client->clientInfo.animFileIndex, (animNumber_t)self->client->ps.legsAnim ) - self->client->ps.torsoAnimTimer < 150 )
+		{//beginning of anim
+			return FORCE_LEVEL_0;
+		}
+		return FORCE_LEVEL_1;
+		break;
+	case BOTH_A3__L__R:
+		if ( self->client->ps.torsoAnimTimer <= 200 )
+		{//end of anim
+			return FORCE_LEVEL_0;
+		}
+		else if ( PM_AnimLength( self->client->clientInfo.animFileIndex, (animNumber_t)self->client->ps.legsAnim ) - self->client->ps.torsoAnimTimer < 300 )
+		{//beginning of anim
+			return FORCE_LEVEL_0;
+		}
+		return FORCE_LEVEL_3;
+		break;
+	}
+	return FORCE_LEVEL_0;
+}
+
+/*
+-------------------------
+NPC_BSSaberDroid_Attack
+-------------------------
+*/
+
+void NPC_SaberDroid_PickAttack( void )
+{
+	int attackAnim = Q_irand( 0, 3 );
+	switch ( attackAnim )
+	{
+	case 0:
+	default:
+		attackAnim = BOTH_A2_TR_BL;
+		NPC->client->ps.saberMove = LS_A_TR2BL;
+		NPC->client->ps.saberAnimLevel = SS_MEDIUM;
+		break;
+	case 1:
+		attackAnim = BOTH_A1_BL_TR;
+		NPC->client->ps.saberMove = LS_A_BL2TR;
+		NPC->client->ps.saberAnimLevel = SS_FAST;
+		break;
+	case 2:
+		attackAnim = BOTH_A1__L__R;
+		NPC->client->ps.saberMove = LS_A_L2R;
+		NPC->client->ps.saberAnimLevel = SS_FAST;
+		break;
+	case 3:
+		attackAnim = BOTH_A3__L__R;
+		NPC->client->ps.saberMove = LS_A_L2R;
+		NPC->client->ps.saberAnimLevel = SS_STRONG;
+		break;
+	}
+	NPC->client->ps.saberBlocking = saberMoveData[NPC->client->ps.saberMove].blocking;
+	if ( saberMoveData[NPC->client->ps.saberMove].trailLength > 0 )
+	{
+		NPC->client->ps.SaberActivateTrail( saberMoveData[NPC->client->ps.saberMove].trailLength ); // saber trail lasts for 75ms...feel free to change this if you want it longer or shorter
+	}
+	else
+	{
+		NPC->client->ps.SaberDeactivateTrail( 0 );
+	}
+
+	NPC_SetAnim( NPC, SETANIM_BOTH, attackAnim, SETANIM_FLAG_HOLD|SETANIM_FLAG_OVERRIDE );
+	NPC->client->ps.torsoAnim = NPC->client->ps.legsAnim;//need to do this because we have no anim split but saber code checks torsoAnim
+	NPC->client->ps.weaponTime = NPC->client->ps.torsoAnimTimer = NPC->client->ps.legsAnimTimer;
+	NPC->client->ps.weaponstate = WEAPON_FIRING;
+}
+
+void NPC_BSSaberDroid_Attack( void )
+{
+	//Don't do anything if we're hurt
+	if ( NPC->painDebounceTime > level.time )
+	{
+		NPC_UpdateAngles( qtrue, qtrue );
+		return;
+	}
+
+	//NPC_CheckEnemy( qtrue, qfalse );
+	//If we don't have an enemy, just idle
+	if ( NPC_CheckEnemyExt() == qfalse )//!NPC->enemy )//
+	{
+		NPC->enemy = NULL;
+		NPC_BSSaberDroid_Patrol();//FIXME: or patrol?
+		return;
+	}
+
+	if ( !NPC->enemy )
+	{//WTF?  somehow we lost our enemy?
+		NPC_BSSaberDroid_Patrol();//FIXME: or patrol?
+		return;
+	}
+
+	enemyLOS = enemyCS = qfalse;
+	move = qtrue;
+	faceEnemy = qfalse;
+	shoot = qfalse;
+	enemyDist = DistanceSquared( NPC->enemy->currentOrigin, NPC->currentOrigin );
+
+	//can we see our target?
+	if ( NPC_ClearLOS( NPC->enemy ) )
+	{
+		NPCInfo->enemyLastSeenTime = level.time;
+		enemyLOS = qtrue;
+
+		if ( enemyDist <= 4096 && InFOV( NPC->enemy->currentOrigin, NPC->currentOrigin, NPC->client->ps.viewangles, 90, 45 ) )//within 64 & infront
+		{
+			VectorCopy( NPC->enemy->currentOrigin, NPCInfo->enemyLastSeenLocation );
+			enemyCS = qtrue;
+		}
+	}
+	/*
+	else if ( gi.inPVS( NPC->enemy->currentOrigin, NPC->currentOrigin ) )
+	{
+		NPCInfo->enemyLastSeenTime = level.time;
+		faceEnemy = qtrue;
+	}
+	*/
+
+	if ( enemyLOS )
+	{//FIXME: no need to face enemy if we're moving to some other goal and he's too far away to shoot?
+		faceEnemy = qtrue;
+	}
+
+	if ( !TIMER_Done( NPC, "taunting" ) )
+	{
+		move = qfalse;
+	}
+	else if ( enemyCS )
+	{
+		shoot = qtrue;
+		if ( enemyDist < (NPC->maxs[0]+NPC->enemy->maxs[0]+32)*(NPC->maxs[0]+NPC->enemy->maxs[0]+32) )
+		{//close enough
+			move = qfalse;
+		}
+	}//this should make him chase enemy when out of range...?
+
+	if ( NPC->client->ps.legsAnimTimer 
+		&& NPC->client->ps.legsAnim != BOTH_A3__L__R )//this one is a running attack
+	{//in the middle of a held, stationary anim, can't move
+		move = qfalse;
+	}
+
+	if ( move )
+	{//move toward goal
+		move = SaberDroid_Move();
+		if ( move )
+		{//if we had to chase him, be sure to attack as soon as possible
+			TIMER_Set( NPC, "attackDelay", NPC->client->ps.weaponTime );
+		}
+	}
+
+	if ( !faceEnemy )
+	{//we want to face in the dir we're running
+		if ( move )
+		{//don't run away and shoot
+			NPCInfo->desiredYaw = NPCInfo->lastPathAngles[YAW];
+			NPCInfo->desiredPitch = 0;
+			shoot = qfalse;
+		}
+		NPC_UpdateAngles( qtrue, qtrue );
+	}
+	else// if ( faceEnemy )
+	{//face the enemy
+		NPC_FaceEnemy();
+	}
+
+	if ( NPCInfo->scriptFlags&SCF_DONT_FIRE )
+	{
+		shoot = qfalse;
+	}
+	
+	//FIXME: need predicted blocking?
+	//FIXME: don't shoot right away!
+	if ( shoot )
+	{//try to shoot if it's time
+		if ( TIMER_Done( NPC, "attackDelay" ) )
+		{	
+			if( !(NPCInfo->scriptFlags & SCF_FIRE_WEAPON) ) // we've already fired, no need to do it again here
+			{
+				NPC_SaberDroid_PickAttack();
+				if ( NPCInfo->rank > RANK_CREWMAN )
+				{
+					TIMER_Set( NPC, "attackDelay", NPC->client->ps.weaponTime+Q_irand(0, 1000) );
+				}
+				else
+				{
+					TIMER_Set( NPC, "attackDelay", NPC->client->ps.weaponTime+Q_irand( 0, 1000 )+(Q_irand( 0, (3-g_spskill->integer)*2 )*500) );
+				}
+			}
+		}
+	}
+}
+
+void NPC_BSSD_Default( void )
+{
+	if( !NPC->enemy )
+	{//don't have an enemy, look for one
+		NPC_BSSaberDroid_Patrol();
+	}
+	else//if ( NPC->enemy )
+	{//have an enemy
+		if ( !NPC->client->ps.SaberActive() )
+		{
+			NPC->client->ps.SaberActivate();
+			if ( NPC->client->ps.legsAnim == BOTH_TURNOFF
+				|| NPC->client->ps.legsAnim == BOTH_STAND1 )
+			{
+				NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_TURNON, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+			}
+		}
+
+		NPC_BSSaberDroid_Attack();
+		TIMER_Set( NPC, "inactiveDelay", Q_irand( 2000, 4000 ) );
+	}
+	if ( !NPC->client->ps.weaponTime )
+	{
+		NPC->client->ps.saberMove = LS_READY;
+		NPC->client->ps.saberBlocking = saberMoveData[LS_READY].blocking;
+		NPC->client->ps.SaberDeactivateTrail( 0 );
+		NPC->client->ps.saberAnimLevel = SS_MEDIUM;
+		NPC->client->ps.weaponstate = WEAPON_READY;
+	}
+}
\ No newline at end of file
diff --git a/code/game/AI_SandCreature.cpp b/code/game/AI_SandCreature.cpp
new file mode 100644
index 0000000..f4ffde6
--- /dev/null
+++ b/code/game/AI_SandCreature.cpp
@@ -0,0 +1,818 @@
+// leave this line at the top of all AI_xxxx.cpp files for PCH reasons...
+#include "g_headers.h"
+   
+#include "b_local.h"
+
+extern void G_Knockdown( gentity_t *self, gentity_t *attacker, const vec3_t pushDir, float strength, qboolean breakSaberLock );
+
+#define MIN_ATTACK_DIST_SQ	128
+#define MIN_MISS_DIST		100
+#define MIN_MISS_DIST_SQ	(MIN_MISS_DIST*MIN_MISS_DIST)
+#define MAX_MISS_DIST		500
+#define MAX_MISS_DIST_SQ	(MAX_MISS_DIST*MAX_MISS_DIST)
+#define MIN_SCORE			-37500 //speed of (50*50) - dist of (200*200)
+
+void SandCreature_Precache( void )
+{
+	int i;
+	G_EffectIndex( "env/sand_dive" );
+	G_EffectIndex( "env/sand_spray" );
+	G_EffectIndex( "env/sand_move" );
+	G_EffectIndex( "env/sand_move_breach" );
+	//G_EffectIndex( "env/sand_attack_breach" );
+	for ( i = 1; i < 4; i++ )
+	{
+		G_SoundIndex( va( "sound/chars/sand_creature/voice%d.mp3", i ) );
+	}
+	G_SoundIndex( "sound/chars/sand_creature/slither.wav" );
+}
+
+void SandCreature_ClearTimers( gentity_t *ent )
+{
+	TIMER_Set( NPC, "speaking", -level.time );
+	TIMER_Set( NPC, "breaching", -level.time );
+	TIMER_Set( NPC, "breachDebounce", -level.time );
+	TIMER_Set( NPC, "pain", -level.time );
+	TIMER_Set( NPC, "attacking", -level.time );
+	TIMER_Set( NPC, "missDebounce", -level.time );
+}
+
+void NPC_SandCreature_Die( gentity_t *self, gentity_t *inflictor, gentity_t *other, const vec3_t point, int damage, int mod,int hitLoc )
+{
+	//FIXME: somehow make him solid when he dies?
+}
+
+void NPC_SandCreature_Pain( gentity_t *self, gentity_t *inflictor, gentity_t *other, const vec3_t point, int damage, int mod,int hitLoc )
+{
+	if ( TIMER_Done( self, "pain" ) )
+	{
+		//FIXME: effect and sound
+		//FIXME: shootable during this anim?
+		NPC_SetAnim( self, SETANIM_LEGS, Q_irand(BOTH_ATTACK1,BOTH_ATTACK2), SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD|SETANIM_FLAG_RESTART );
+		G_AddEvent( self, EV_PAIN, Q_irand( 0, 100 ) );
+		TIMER_Set( self, "pain", self->client->ps.legsAnimTimer + Q_irand( 500, 2000 ) );	
+		float playerDist = Distance( player->currentOrigin, self->currentOrigin );
+		if ( playerDist < 256 )
+		{
+			CGCam_Shake( 1.0f*playerDist/128.0f, self->client->ps.legsAnimTimer );
+		}
+	}
+	self->enemy = self->NPC->goalEntity = NULL;
+}
+
+void SandCreature_MoveEffect( void )
+{
+	vec3_t	up = {0,0,1};
+	vec3_t	org = {NPC->currentOrigin[0], NPC->currentOrigin[1], NPC->absmin[2]+2};
+
+	float playerDist = Distance( player->currentOrigin, NPC->currentOrigin );
+	if ( playerDist < 256 )
+	{
+		CGCam_Shake( 0.75f*playerDist/256.0f, 250 );
+	}
+	
+	if ( level.time-NPC->client->ps.lastStationary > 2000 )
+	{//first time moving for at least 2 seconds
+		//clear speakingtime
+		TIMER_Set( NPC, "speaking", -level.time );
+	}
+
+	if ( TIMER_Done( NPC, "breaching" ) 
+		&& TIMER_Done( NPC, "breachDebounce" )
+		&& TIMER_Done( NPC, "pain" )
+		&& TIMER_Done( NPC, "attacking" )
+		&& !Q_irand( 0, 10 ) )
+	{//Breach!
+		//FIXME: only do this while moving forward?
+		trace_t	trace;
+		//make him solid here so he can be hit/gets blocked on stuff. Check clear first.
+		gi.trace( &trace, NPC->currentOrigin, NPC->mins, NPC->maxs, NPC->currentOrigin, NPC->s.number, MASK_NPCSOLID );
+		if ( !trace.allsolid && !trace.startsolid )
+		{
+			NPC->clipmask = MASK_NPCSOLID;//turn solid for a little bit
+			NPC->contents = CONTENTS_BODY;
+			//NPC->takedamage = qtrue;//can be shot?
+
+			//FIXME: Breach sound?
+			//FIXME: Breach effect?
+			NPC_SetAnim( NPC, SETANIM_LEGS, BOTH_WALK2, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD|SETANIM_FLAG_RESTART );
+			TIMER_Set( NPC, "breaching", NPC->client->ps.legsAnimTimer );
+			TIMER_Set( NPC, "breachDebounce", NPC->client->ps.legsAnimTimer+Q_irand( 0, 10000 ) );
+		}
+	}
+	if ( !TIMER_Done( NPC, "breaching" ) )
+	{//different effect when breaching
+		//FIXME: make effect
+		G_PlayEffect( G_EffectIndex( "env/sand_move_breach" ), org, up );
+	}
+	else
+	{
+		G_PlayEffect( G_EffectIndex( "env/sand_move" ), org, up );
+	}
+	NPC->s.loopSound = G_SoundIndex( "sound/chars/sand_creature/slither.wav" );
+}
+
+qboolean SandCreature_CheckAhead( vec3_t end )
+{
+	trace_t	trace;
+	int clipmask = NPC->clipmask|CONTENTS_BOTCLIP;
+
+	//make sure our goal isn't underground (else the trace will fail)
+	vec3_t	bottom = {end[0],end[1],end[2]+NPC->mins[2]};
+	gi.trace( &trace, end, vec3_origin, vec3_origin, bottom, NPC->s.number, NPC->clipmask );
+	if ( trace.fraction < 1.0f )
+	{//in the ground, raise it up
+		end[2] -= NPC->mins[2]*(1.0f-trace.fraction)-0.125f;
+	}
+
+	gi.trace( &trace, NPC->currentOrigin, NPC->mins, NPC->maxs, end, NPC->s.number, clipmask );
+
+	if ( trace.startsolid&&(trace.contents&CONTENTS_BOTCLIP) )
+	{//started inside do not enter, so ignore them
+		clipmask &= ~CONTENTS_BOTCLIP;
+		gi.trace( &trace, NPC->currentOrigin, NPC->mins, NPC->maxs, end, NPC->s.number, clipmask );
+	}
+	//Do a simple check
+	if ( ( trace.allsolid == qfalse ) && ( trace.startsolid == qfalse ) && ( trace.fraction == 1.0f ) )
+		return qtrue;
+
+	if ( trace.plane.normal[2] >= MIN_WALK_NORMAL )
+	{
+		return qtrue;
+	}
+
+	//This is a work around
+	float	radius = ( NPC->maxs[0] > NPC->maxs[1] ) ? NPC->maxs[0] : NPC->maxs[1];
+	float	dist = Distance( NPC->currentOrigin, end );
+	float	tFrac = 1.0f - ( radius / dist );
+
+	if ( trace.fraction >= tFrac )
+		return qtrue;
+
+	return qfalse;
+}
+
+qboolean SandCreature_Move( void )
+{
+	qboolean moved = qfalse;
+	//FIXME should ignore doors..?
+	vec3_t dest;
+	VectorCopy( NPCInfo->goalEntity->currentOrigin, dest );
+	//Sand Creatures look silly using waypoints when they can go straight to the goal
+	if ( SandCreature_CheckAhead( dest ) )
+	{//use our temp move straight to goal check
+		VectorSubtract( dest, NPC->currentOrigin, NPC->client->ps.moveDir );
+		NPC->client->ps.speed = VectorNormalize( NPC->client->ps.moveDir );
+		if ( (ucmd.buttons&BUTTON_WALKING) && NPC->client->ps.speed > NPCInfo->stats.walkSpeed )
+		{
+			NPC->client->ps.speed = NPCInfo->stats.walkSpeed;
+		}
+		else
+		{
+			if ( NPC->client->ps.speed < NPCInfo->stats.walkSpeed )
+			{
+				NPC->client->ps.speed = NPCInfo->stats.walkSpeed;
+			}
+			if ( !(ucmd.buttons&BUTTON_WALKING) && NPC->client->ps.speed < NPCInfo->stats.runSpeed )
+			{
+				NPC->client->ps.speed = NPCInfo->stats.runSpeed;
+			}
+			else if ( NPC->client->ps.speed > NPCInfo->stats.runSpeed )
+			{
+				NPC->client->ps.speed = NPCInfo->stats.runSpeed;
+			}
+		}
+		moved = qtrue;
+	}
+	else
+	{
+		moved = NPC_MoveToGoal( qtrue );
+	}
+	if ( moved && NPC->radius )
+	{
+		vec3_t	newPos;
+		float curTurfRange, newTurfRange;
+		curTurfRange = DistanceHorizontal( NPC->currentOrigin, NPC->s.origin );
+		VectorMA( NPC->currentOrigin, NPC->client->ps.speed/100.0f, NPC->client->ps.moveDir, newPos );
+		newTurfRange = DistanceHorizontal( newPos, NPC->s.origin );
+		if ( newTurfRange > NPC->radius && newTurfRange > curTurfRange )
+		{//would leave our range
+			//stop
+			NPC->client->ps.speed = 0.0f;
+			VectorClear( NPC->client->ps.moveDir );
+			ucmd.forwardmove = ucmd.rightmove = 0;
+			moved = qfalse;
+		}
+	}
+	return (moved);
+	//often erroneously returns false ???  something wrong with NAV...?
+}
+
+void SandCreature_Attack( qboolean miss )
+{
+	//FIXME: make it able to grab a thermal detonator, take it down, 
+	//		then have it explode inside them, killing them 
+	//		(or, do damage, making them stick half out of the ground and
+	//		screech for a bit, giving you a chance to run for it!)
+
+	//FIXME: effect and sound
+	//FIXME: shootable during this anim?
+	if ( !NPC->enemy->client )
+	{
+		NPC_SetAnim( NPC, SETANIM_LEGS, BOTH_ATTACK1, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD|SETANIM_FLAG_RESTART );
+	}
+	else
+	{
+		NPC_SetAnim( NPC, SETANIM_LEGS, Q_irand( BOTH_ATTACK1, BOTH_ATTACK2 ), SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD|SETANIM_FLAG_RESTART );
+	}
+	//don't do anything else while in this anim
+	TIMER_Set( NPC, "attacking", NPC->client->ps.legsAnimTimer );
+	float playerDist = Distance( player->currentOrigin, NPC->currentOrigin );
+	if ( playerDist < 256 )
+	{
+		//FIXME: tone this down
+		CGCam_Shake( 0.75f*playerDist/128.0f, NPC->client->ps.legsAnimTimer );
+	} 
+
+	if ( miss )
+	{//purposely missed him, chance of knocking him down
+		//FIXME: if, during the attack anim, I do end up catching him close to my mouth, then snatch him anyway...
+		if ( NPC->enemy && NPC->enemy->client )
+		{
+			vec3_t dir2Enemy;
+			VectorSubtract( NPC->enemy->currentOrigin, NPC->currentOrigin, dir2Enemy );
+			if ( dir2Enemy[2] < 30 )
+			{
+				dir2Enemy[2] = 30;
+			}
+			if ( g_spskill->integer > 0 )
+			{
+				float enemyDist = VectorNormalize( dir2Enemy );
+				//FIXME: tone this down, smaller radius
+				if ( enemyDist < 200 && NPC->enemy->client->ps.groundEntityNum != ENTITYNUM_NONE )
+				{
+					float throwStr = ((200-enemyDist)*0.4f)+20;
+					if ( throwStr > 45 )
+					{
+						throwStr = 45;
+					}
+					G_Throw( NPC->enemy, dir2Enemy, throwStr );
+					if ( g_spskill->integer > 1 )
+					{//knock them down, too
+						if ( NPC->enemy->health > 0 
+							&& Q_flrand( 50, 150 ) > enemyDist )
+						{//knock them down
+							G_Knockdown( NPC->enemy, NPC, dir2Enemy, 300, qtrue );
+							if ( NPC->enemy->s.number < MAX_CLIENTS )
+							{//make the player look up at me
+								vec3_t vAng;
+								vectoangles( dir2Enemy, vAng );
+								VectorSet( vAng, AngleNormalize180(vAng[PITCH])*-1, NPC->enemy->client->ps.viewangles[YAW], 0 );
+								SetClientViewAngle( NPC->enemy, vAng );
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+	else
+	{
+		NPC->enemy->activator = NPC; // kind of dumb, but when we are locked to the Rancor, we are owned by it.
+		NPC->activator = NPC->enemy;//remember him
+		//this guy isn't going anywhere anymore
+		NPC->enemy->contents = 0;
+		NPC->enemy->clipmask = 0;
+
+		if ( NPC->activator->client )
+		{
+			NPC->activator->client->ps.SaberDeactivate();
+			NPC->activator->client->ps.eFlags |= EF_HELD_BY_SAND_CREATURE;
+			if ( NPC->activator->health > 0 && NPC->activator->client )
+			{
+				G_AddEvent( NPC->activator, Q_irand(EV_DEATH1, EV_DEATH3), 0 );
+				NPC_SetAnim( NPC->activator, SETANIM_LEGS, BOTH_SWIM_IDLE1, SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLD );
+				NPC_SetAnim( NPC->activator, SETANIM_TORSO, BOTH_FALLDEATH1, SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLD );
+				TossClientItems( NPC );
+				if ( NPC->activator->NPC )
+				{//no more thinking for you
+					NPC->activator->NPC->nextBStateThink = Q3_INFINITE;
+				}
+			}
+			/*
+			if ( !NPC->activator->s.number )
+			{
+				cg.overrides.active |= (CG_OVERRIDE_3RD_PERSON_CDP|CG_OVERRIDE_3RD_PERSON_RNG);
+				cg.overrides.thirdPersonCameraDamp = 0;
+				cg.overrides.thirdPersonRange = 120;
+			}
+			*/
+		}
+		else
+		{
+			NPC->activator->s.eFlags |= EF_HELD_BY_SAND_CREATURE;
+		}
+	}
+}
+
+float SandCreature_EntScore( gentity_t *ent )
+{
+	float moveSpeed, dist;
+
+	if ( ent->client )
+	{
+		moveSpeed = VectorLengthSquared( ent->client->ps.velocity );
+	}
+	else
+	{
+		moveSpeed = VectorLengthSquared( ent->s.pos.trDelta );
+	}
+	dist = DistanceSquared( NPC->currentOrigin, ent->currentOrigin );
+	return (moveSpeed-dist);
+}
+
+void SandCreature_SeekEnt( gentity_t *bestEnt, float score )
+{
+	NPCInfo->enemyLastSeenTime = level.time;
+	VectorCopy( bestEnt->currentOrigin, NPCInfo->enemyLastSeenLocation );
+	NPC_SetMoveGoal( NPC, NPCInfo->enemyLastSeenLocation, 0, qfalse );
+	if ( score > MIN_SCORE )
+	{
+		NPC->enemy = bestEnt;
+	}
+}
+
+void SandCreature_CheckMovingEnts( void )
+{
+	gentity_t	*radiusEnts[ 128 ];
+	int			numEnts;
+	const float	radius = NPCInfo->stats.earshot;
+	int			i;
+	vec3_t		mins, maxs;
+
+	for ( i = 0; i < 3; i++ )
+	{
+		mins[i] = NPC->currentOrigin[i] - radius;
+		maxs[i] = NPC->currentOrigin[i] + radius;
+	}
+
+	numEnts = gi.EntitiesInBox( mins, maxs, radiusEnts, 128 );
+	int bestEnt = -1;
+	float bestScore = 0;
+	float checkScore;
+
+	for ( i = 0; i < numEnts; i++ )
+	{
+		if ( !radiusEnts[i]->inuse )
+		{
+			continue;
+		}
+		
+		if ( radiusEnts[i] == NPC )
+		{//Skip the rancor ent
+			continue;
+		}
+		
+		if ( radiusEnts[i]->client == NULL )
+		{//must be a client
+			if ( radiusEnts[i]->s.eType != ET_MISSILE
+				|| radiusEnts[i]->s.weapon != WP_THERMAL )
+			{//not a thermal detonator
+				continue;
+			}
+		}
+		else
+		{
+			if ( (radiusEnts[i]->client->ps.eFlags&EF_HELD_BY_RANCOR) )
+			{//can't be one being held
+				continue;
+			}
+
+			if ( (radiusEnts[i]->client->ps.eFlags&EF_HELD_BY_WAMPA) )
+			{//can't be one being held
+				continue;
+			}
+
+			if ( (radiusEnts[i]->client->ps.eFlags&EF_HELD_BY_SAND_CREATURE) )
+			{//can't be one being held
+				continue;
+			}
+
+			if ( (radiusEnts[i]->s.eFlags&EF_NODRAW) )
+			{//not if invisible
+				continue;
+			}
+	
+			if ( radiusEnts[i]->client->ps.groundEntityNum != ENTITYNUM_WORLD )
+			{//not on the ground
+				continue;
+			}
+
+			if ( radiusEnts[i]->client->NPC_class == CLASS_SAND_CREATURE )
+			{
+				continue;
+			}
+		}
+
+		if ( (radiusEnts[i]->flags&FL_NOTARGET) )
+		{
+			continue;
+		}
+		/*
+		if ( radiusEnts[i]->client && (radiusEnts[i]->client->NPC_class == CLASS_RANCOR || radiusEnts[i]->client->NPC_class == CLASS_ATST ) )
+		{//can't grab rancors or atst's
+			continue;
+		}
+		*/
+		checkScore = SandCreature_EntScore( radiusEnts[i] );
+		//FIXME: take mass into account too?  What else?
+		if ( checkScore > bestScore )
+		{
+			bestScore = checkScore;
+			bestEnt = i;
+		}
+	}
+	if ( bestEnt != -1 )
+	{
+		SandCreature_SeekEnt( radiusEnts[bestEnt], bestScore );
+	}
+}
+
+void SandCreature_SeekAlert( int alertEvent )
+{
+	alertEvent_t *alert = &level.alertEvents[alertEvent];
+
+	//FIXME: check for higher alert status or closer than last location?
+	NPCInfo->enemyLastSeenTime = level.time;
+	VectorCopy( alert->position, NPCInfo->enemyLastSeenLocation );
+	NPC_SetMoveGoal( NPC, NPCInfo->enemyLastSeenLocation, 0, qfalse );
+}
+
+void SandCreature_CheckAlerts( void )
+{
+	if ( !(NPCInfo->scriptFlags&SCF_IGNORE_ALERTS) )
+	{
+		int alertEvent = NPC_CheckAlertEvents( qfalse, qtrue, NPCInfo->lastAlertID, qfalse, AEL_MINOR, qtrue );
+
+		//There is an event to look at
+		if ( alertEvent >= 0 )
+		{
+			//if ( level.alertEvents[alertEvent].ID != NPCInfo->lastAlertID )
+			{
+				SandCreature_SeekAlert( alertEvent );
+			}
+		}
+	}
+}
+
+float SandCreature_DistSqToGoal( qboolean goalIsEnemy )
+{
+	float goalDistSq;
+	if ( !NPCInfo->goalEntity || goalIsEnemy )
+	{
+		if ( !NPC->enemy )
+		{
+			return Q3_INFINITE;
+		}
+		NPCInfo->goalEntity = NPC->enemy;
+	}
+
+	if ( NPCInfo->goalEntity->client )
+	{
+		goalDistSq = DistanceSquared( NPC->currentOrigin, NPCInfo->goalEntity->currentOrigin );
+	}
+	else
+	{
+		vec3_t gOrg;
+		VectorCopy( NPCInfo->goalEntity->currentOrigin, gOrg );
+		gOrg[2] -= (NPC->mins[2]-NPCInfo->goalEntity->mins[2]);//moves the gOrg up/down to make it's origin seem at the proper height as if it had my mins
+		goalDistSq = DistanceSquared( NPC->currentOrigin, gOrg );
+	}
+	return goalDistSq;
+}
+
+void SandCreature_Chase( void )
+{
+	if ( !NPC->enemy->inuse )
+	{//freed
+		NPC->enemy = NULL;
+		return;
+	}
+	
+	if ( (NPC->svFlags&SVF_LOCKEDENEMY) )
+	{//always know where he is
+		NPCInfo->enemyLastSeenTime = level.time;
+	}
+
+	if ( !(NPC->svFlags&SVF_LOCKEDENEMY) )
+	{
+		if ( level.time-NPCInfo->enemyLastSeenTime > 10000 )
+		{
+			NPC->enemy = NULL;
+			return;
+		}
+	}
+
+	if ( NPC->enemy->client )
+	{
+		if ( (NPC->enemy->client->ps.eFlags&EF_HELD_BY_SAND_CREATURE)
+			|| (NPC->enemy->client->ps.eFlags&EF_HELD_BY_RANCOR)
+			|| (NPC->enemy->client->ps.eFlags&EF_HELD_BY_WAMPA) )
+		{//was picked up by another monster, forget about him
+			NPC->enemy = NULL;
+			NPC->svFlags &= ~SVF_LOCKEDENEMY;
+			return;
+		}
+	}
+	//chase the enemy
+	if ( NPC->enemy->client 
+		&& NPC->enemy->client->ps.groundEntityNum != ENTITYNUM_WORLD 
+		&& !(NPC->svFlags&SVF_LOCKEDENEMY) )
+	{//off the ground!
+		//FIXME: keep moving in the dir we were moving for a little bit...
+	}
+	else
+	{
+		float enemyScore = SandCreature_EntScore( NPC->enemy );
+		if ( enemyScore < MIN_SCORE 
+			&& !(NPC->svFlags&SVF_LOCKEDENEMY) )
+		{//too slow or too far away
+		}
+		else
+		{
+			float moveSpeed;
+			if ( NPC->enemy->client )
+			{
+				moveSpeed = VectorLengthSquared( NPC->enemy->client->ps.velocity );
+			}
+			else
+			{
+				moveSpeed = VectorLengthSquared( NPC->enemy->s.pos.trDelta );
+			}
+			if ( moveSpeed )
+			{//he's still moving, update my goalEntity's origin
+				SandCreature_SeekEnt( NPC->enemy, 0 );
+				NPCInfo->enemyLastSeenTime = level.time;
+			}
+		}
+	}
+
+	if ( (level.time-NPCInfo->enemyLastSeenTime) > 5000 
+		&& !(NPC->svFlags&SVF_LOCKEDENEMY) )
+	{//enemy hasn't moved in about 5 seconds, see if there's anything else of interest
+		SandCreature_CheckAlerts();
+		SandCreature_CheckMovingEnts();
+	}
+
+	float enemyDistSq = SandCreature_DistSqToGoal( qtrue );
+
+	//FIXME: keeps chasing goalEntity even when it's already reached it...?
+	if ( enemyDistSq >= MIN_ATTACK_DIST_SQ//NPCInfo->goalEntity &&
+		&& (level.time-NPCInfo->enemyLastSeenTime) <= 3000 )
+	{//sensed enemy (or something) less than 3 seconds ago
+		ucmd.buttons &= ~BUTTON_WALKING;
+		if ( SandCreature_Move() )
+		{
+			SandCreature_MoveEffect();
+		}
+	}
+	else if ( (level.time-NPCInfo->enemyLastSeenTime) <= 5000 
+		&& !(NPC->svFlags&SVF_LOCKEDENEMY) )
+	{//NOTE: this leaves a 2-second dead zone in which they'll just sit there unless their enemy moves
+		//If there is an event we might be interested in if we weren't still interested in our enemy
+		if ( NPC_CheckAlertEvents( qfalse, qtrue, NPCInfo->lastAlertID, qfalse, AEL_MINOR, qtrue ) >= 0 )
+		{//just stir
+			SandCreature_MoveEffect();
+		}
+	}
+
+	if ( enemyDistSq < MIN_ATTACK_DIST_SQ )
+	{
+		if ( NPC->enemy->client )
+		{
+			NPC->client->ps.viewangles[YAW] = NPC->enemy->client->ps.viewangles[YAW];
+		}
+		if ( TIMER_Done( NPC, "breaching" ) )
+		{
+			//okay to attack
+			SandCreature_Attack( qfalse );
+		}
+	}
+	else if ( enemyDistSq < MAX_MISS_DIST_SQ 
+		&& enemyDistSq > MIN_MISS_DIST_SQ
+		&& NPC->enemy->client 
+		&& TIMER_Done( NPC, "breaching" )
+		&& TIMER_Done( NPC, "missDebounce" )
+		&& !VectorCompare( NPC->pos1, NPC->currentOrigin ) //so we don't come up again in the same spot
+		&& !Q_irand( 0, 10 ) )
+	{
+		if ( !(NPC->svFlags&SVF_LOCKEDENEMY) )
+		{
+			//miss them
+			SandCreature_Attack( qtrue );
+			VectorCopy( NPC->currentOrigin, NPC->pos1 );
+			TIMER_Set( NPC, "missDebounce", Q_irand( 3000, 10000 ) );
+		}
+	}
+}
+
+void SandCreature_Hunt( void )
+{
+	SandCreature_CheckAlerts();
+	SandCreature_CheckMovingEnts();
+	//If we have somewhere to go, then do that
+	//FIXME: keeps chasing goalEntity even when it's already reached it...?
+	if ( NPCInfo->goalEntity 
+		&& SandCreature_DistSqToGoal( qfalse ) >= MIN_ATTACK_DIST_SQ )
+	{
+		ucmd.buttons |= BUTTON_WALKING;
+		if ( SandCreature_Move() )
+		{
+			SandCreature_MoveEffect();
+		}
+	}
+	else
+	{
+		NPC_ReachedGoal();
+	}
+}
+
+void SandCreature_Sleep( void )
+{
+	SandCreature_CheckAlerts();
+	SandCreature_CheckMovingEnts();
+	//FIXME: keeps chasing goalEntity even when it's already reached it!
+	if ( NPCInfo->goalEntity 
+		&& SandCreature_DistSqToGoal( qfalse ) >= MIN_ATTACK_DIST_SQ )
+	{
+		ucmd.buttons |= BUTTON_WALKING;
+		if ( SandCreature_Move() )
+		{
+			SandCreature_MoveEffect();
+		}
+	}
+	else
+	{
+		NPC_ReachedGoal();
+	}
+	/*
+	if ( UpdateGoal() )
+	{
+		ucmd.buttons |= BUTTON_WALKING;
+		//FIXME: Sand Creatures look silly using waypoints when they can go straight to the goal
+		if ( SandCreature_Move() )
+		{
+			SandCreature_MoveEffect();
+		}
+	}
+	*/
+}
+
+void	SandCreature_PushEnts()
+{
+  	int			numEnts;
+	gentity_t*	radiusEnts[128];
+	const float	radius = 70;
+	vec3_t		mins, maxs;
+	vec3_t		smackDir;
+	float		smackDist;
+
+	for (int i = 0; i < 3; i++ )
+	{
+		mins[i] = NPC->currentOrigin[i] - radius;
+		maxs[i] = NPC->currentOrigin[i] + radius;
+	}
+
+	numEnts = gi.EntitiesInBox(mins, maxs, radiusEnts, 128);
+	for (int entIndex=0; entIndex<numEnts; entIndex++)
+	{
+		// Only Clients
+		//--------------
+		if (!radiusEnts[entIndex] || !radiusEnts[entIndex]->client || radiusEnts[entIndex]==NPC)
+		{
+			continue;
+		}
+
+		// Do The Vector Distance Test
+		//-----------------------------
+		VectorSubtract(radiusEnts[entIndex]->currentOrigin, NPC->currentOrigin, smackDir);
+		smackDist = VectorNormalize(smackDir);
+		if (smackDist<radius)
+		{
+ 			G_Throw(radiusEnts[entIndex], smackDir, 90);
+		}
+	}
+}
+
+void NPC_BSSandCreature_Default( void )
+{
+	qboolean visible = qfalse;
+	
+	//clear it every frame, will be set if we actually move this frame...
+	NPC->s.loopSound = 0;
+
+	if ( NPC->health > 0 && TIMER_Done( NPC, "breaching" ) )
+	{//go back to non-solid mode
+		if ( NPC->contents )
+		{
+			NPC->contents = 0;
+		}
+		if ( NPC->clipmask == MASK_NPCSOLID )
+		{
+			NPC->clipmask = CONTENTS_SOLID|CONTENTS_MONSTERCLIP;
+		}
+		if ( TIMER_Done( NPC, "speaking" ) )
+		{
+			G_SoundOnEnt( NPC, CHAN_VOICE, va( "sound/chars/sand_creature/voice%d.mp3", Q_irand( 1, 3 ) ) );
+			TIMER_Set( NPC, "speaking", Q_irand( 3000, 10000 ) );
+		}
+	}
+	else
+	{//still in breaching anim
+		visible = qtrue;
+		//FIXME: maybe push things up/away and maybe knock people down when doing this?
+		//FIXME: don't turn while breaching?
+		//FIXME: move faster while breaching?
+		//NOTE: shaking now done whenever he moves
+	}
+
+	//FIXME: when in start and end of attack/pain anims, need ground disturbance effect around him
+	// NOTENOTE: someone stubbed this code in, so I figured I'd use it.  The timers are all weird, ie, magic numbers that sort of work, 
+	//	but maybe I'll try and figure out real values later if I have time.
+	if ( NPC->client->ps.legsAnim == BOTH_ATTACK1
+		|| NPC->client->ps.legsAnim == BOTH_ATTACK2 ) 
+	{//FIXME: get start and end frame numbers for this effect for each of these anims
+		vec3_t	up={0,0,1};
+		vec3_t org;
+		VectorCopy( NPC->currentOrigin, org );
+		org[2] -= 40; 
+		if ( NPC->client->ps.legsAnimTimer > 3700 )
+		{
+//			G_PlayEffect( G_EffectIndex( "env/sand_dive"  ), NPC->currentOrigin, up );
+			G_PlayEffect( G_EffectIndex( "env/sand_spray"  ), org, up );
+		}
+		else if ( NPC->client->ps.legsAnimTimer > 1600 	&& NPC->client->ps.legsAnimTimer < 1900 )
+		{
+			G_PlayEffect( G_EffectIndex( "env/sand_spray"  ), org, up );
+		}
+		//G_PlayEffect( G_EffectIndex( "env/sand_attack_breach" ), org, up );
+	}
+	
+
+	if ( !TIMER_Done( NPC, "pain" ) )
+	{
+		visible = qtrue;
+	}
+	else if ( !TIMER_Done( NPC, "attacking" ) )
+	{
+		visible = qtrue;
+	}
+	else
+	{
+		if ( NPC->activator )
+		{//kill and remove the guy we ate
+			//FIXME: want to play ...?  What was I going to say?
+			NPC->activator->health = 0;
+			GEntity_DieFunc( NPC->activator, NPC, NPC, 1000, MOD_MELEE, 0, HL_NONE );
+			if ( NPC->activator->s.number )
+			{
+				G_FreeEntity( NPC->activator );
+			}
+			else
+			{//can't remove the player, just make him invisible
+				NPC->client->ps.eFlags |= EF_NODRAW;
+			}
+			NPC->activator = NPC->enemy = NPCInfo->goalEntity = NULL;
+		}
+
+		if ( NPC->enemy )
+		{
+			SandCreature_Chase();
+		}
+		else if ( (level.time - NPCInfo->enemyLastSeenTime) < 5000 )//FIXME: should make this able to be variable
+		{//we were alerted recently, move towards there and look for footsteps, etc.
+			SandCreature_Hunt();
+		}
+		else
+		{//no alerts, sleep and wake up only by alerts
+			//FIXME: keeps chasing goalEntity even when it's already reached it!
+			SandCreature_Sleep();
+		}
+	}
+	NPC_UpdateAngles( qtrue, qtrue );
+	if ( !visible )
+	{
+		NPC->client->ps.eFlags |= EF_NODRAW;
+		NPC->s.eFlags |= EF_NODRAW;
+	}
+	else
+	{
+		NPC->client->ps.eFlags &= ~EF_NODRAW;
+		NPC->s.eFlags &= ~EF_NODRAW;
+
+		SandCreature_PushEnts();
+	}
+}
+
+//FIXME: need pain behavior of sticking up through ground, writhing and screaming
+//FIXME: need death anim like pain, but flopping aside and staying above ground...
\ No newline at end of file
diff --git a/code/game/AI_Seeker.cpp b/code/game/AI_Seeker.cpp
new file mode 100644
index 0000000..489b81e
--- /dev/null
+++ b/code/game/AI_Seeker.cpp
@@ -0,0 +1,539 @@
+// leave this line at the top of all AI_xxxx.cpp files for PCH reasons...
+#include "g_headers.h"
+
+
+#include "b_local.h"
+#include "g_nav.h"
+
+extern void NPC_BSST_Patrol( void );
+extern void Boba_FireDecide( void );
+extern gentity_t *CreateMissile( vec3_t org, vec3_t dir, float vel, int life, gentity_t *owner, qboolean altFire = qfalse );
+
+void Seeker_Strafe( void );
+
+#define VELOCITY_DECAY		0.7f
+
+#define	MIN_MELEE_RANGE		320
+#define	MIN_MELEE_RANGE_SQR	( MIN_MELEE_RANGE * MIN_MELEE_RANGE )
+
+#define MIN_DISTANCE		80
+#define MIN_DISTANCE_SQR	( MIN_DISTANCE * MIN_DISTANCE )
+
+#define SEEKER_STRAFE_VEL	100
+#define SEEKER_STRAFE_DIS	200
+#define SEEKER_UPWARD_PUSH	32
+
+#define SEEKER_FORWARD_BASE_SPEED	10
+#define SEEKER_FORWARD_MULTIPLIER	2
+
+#define SEEKER_SEEK_RADIUS			1024
+
+//------------------------------------
+void NPC_Seeker_Precache(void)
+{
+	G_SoundIndex("sound/chars/seeker/misc/fire.wav");
+	G_SoundIndex( "sound/chars/seeker/misc/hiss.wav");
+	G_EffectIndex( "env/small_explode");
+}
+
+//------------------------------------
+void NPC_Seeker_Pain( gentity_t *self, gentity_t *inflictor, gentity_t *other, const vec3_t point, int damage, int mod,int hitLoc ) 
+{
+	if ( !(self->svFlags & SVF_CUSTOM_GRAVITY ))
+	{//void G_Damage( gentity_t *targ, gentity_t *inflictor, gentity_t *attacker, vec3_t dir, vec3_t point, int damage, int dflags, int mod, int hitLoc=HL_NONE );
+		G_Damage( self, NULL, NULL, vec3_origin, (float*)vec3_origin, 999, 0, MOD_FALLING );
+	}
+
+	SaveNPCGlobals();
+	SetNPCGlobals( self );
+	Seeker_Strafe();
+	RestoreNPCGlobals();
+	NPC_Pain( self, inflictor, other, point, damage, mod );
+}
+
+//------------------------------------
+void Seeker_MaintainHeight( void )
+{	
+	float	dif;
+
+	// Update our angles regardless
+	NPC_UpdateAngles( qtrue, qtrue );
+
+	// If we have an enemy, we should try to hover at or a little below enemy eye level
+	if ( NPC->enemy )
+	{
+		if (TIMER_Done( NPC, "heightChange" ))
+		{
+			TIMER_Set( NPC,"heightChange",Q_irand( 1000, 3000 ));
+
+			// Find the height difference
+			dif = (NPC->enemy->currentOrigin[2] +  Q_flrand( NPC->enemy->maxs[2]/2, NPC->enemy->maxs[2]+8 )) - NPC->currentOrigin[2]; 
+
+			float	difFactor = 1.0f;
+			if ( NPC->client->NPC_class == CLASS_BOBAFETT )
+			{
+				if ( TIMER_Done( NPC, "flameTime" ) )
+				{
+					difFactor = 10.0f;
+				}
+			}
+
+			// cap to prevent dramatic height shifts
+			if ( fabs( dif ) > 2*difFactor )
+			{
+				if ( fabs( dif ) > 24*difFactor )
+				{
+					dif = ( dif < 0 ? -24*difFactor : 24*difFactor );
+				}
+
+				NPC->client->ps.velocity[2] = (NPC->client->ps.velocity[2]+dif)/2;
+			}
+			if ( NPC->client->NPC_class == CLASS_BOBAFETT )
+			{
+				NPC->client->ps.velocity[2] *= Q_flrand( 0.85f, 3.0f );
+			}
+		}
+	}
+	else
+	{
+		gentity_t *goal = NULL;
+
+		if ( NPCInfo->goalEntity )	// Is there a goal?
+		{
+			goal = NPCInfo->goalEntity;
+		}
+		else
+		{
+			goal = NPCInfo->lastGoalEntity;
+		}
+		if ( goal )
+		{
+			dif = goal->currentOrigin[2] - NPC->currentOrigin[2];
+
+			if ( fabs( dif ) > 24 )
+			{
+				ucmd.upmove = ( ucmd.upmove < 0 ? -4 : 4 );
+			}
+			else
+			{
+				if ( NPC->client->ps.velocity[2] )
+				{
+					NPC->client->ps.velocity[2] *= VELOCITY_DECAY;
+
+					if ( fabs( NPC->client->ps.velocity[2] ) < 2 )
+					{
+						NPC->client->ps.velocity[2] = 0;
+					}
+				}
+			}
+		}
+	}
+
+	// Apply friction
+	if ( NPC->client->ps.velocity[0] )
+	{
+		NPC->client->ps.velocity[0] *= VELOCITY_DECAY;
+
+		if ( fabs( NPC->client->ps.velocity[0] ) < 1 )
+		{
+			NPC->client->ps.velocity[0] = 0;
+		}
+	}
+
+	if ( NPC->client->ps.velocity[1] )
+	{
+		NPC->client->ps.velocity[1] *= VELOCITY_DECAY;
+
+		if ( fabs( NPC->client->ps.velocity[1] ) < 1 )
+		{
+			NPC->client->ps.velocity[1] = 0;
+		}
+	}
+}
+
+//------------------------------------
+void Seeker_Strafe( void )
+{
+	int		side;
+	vec3_t	end, right, dir;
+	trace_t	tr;
+
+	if ( random() > 0.7f || !NPC->enemy || !NPC->enemy->client )
+	{
+		// Do a regular style strafe
+		AngleVectors( NPC->client->renderInfo.eyeAngles, NULL, right, NULL );
+
+		// Pick a random strafe direction, then check to see if doing a strafe would be
+		//	reasonably valid
+		side = ( rand() & 1 ) ? -1 : 1;
+		VectorMA( NPC->currentOrigin, SEEKER_STRAFE_DIS * side, right, end );
+
+		gi.trace( &tr, NPC->currentOrigin, NULL, NULL, end, NPC->s.number, MASK_SOLID );
+
+		// Close enough
+		if ( tr.fraction > 0.9f )
+		{
+			float vel = SEEKER_STRAFE_VEL;
+			float upPush = SEEKER_UPWARD_PUSH;
+			if ( NPC->client->NPC_class != CLASS_BOBAFETT )
+			{
+				G_Sound( NPC, G_SoundIndex( "sound/chars/seeker/misc/hiss" ));
+			}
+			else
+			{
+				vel *= 3.0f;
+				upPush *= 4.0f;
+			}
+			VectorMA( NPC->client->ps.velocity, vel*side, right, NPC->client->ps.velocity );
+			// Add a slight upward push
+			NPC->client->ps.velocity[2] += upPush;
+
+			NPCInfo->standTime = level.time + 1000 + random() * 500;
+		}
+	}
+	else
+	{
+		// Do a strafe to try and keep on the side of their enemy
+		AngleVectors( NPC->enemy->client->renderInfo.eyeAngles, dir, right, NULL );
+
+		// Pick a random side
+		side = ( rand() & 1 ) ? -1 : 1;
+		float	stDis = SEEKER_STRAFE_DIS;
+		if ( NPC->client->NPC_class == CLASS_BOBAFETT )
+		{
+			stDis *= 2.0f;
+		}
+		VectorMA( NPC->enemy->currentOrigin, stDis * side, right, end );
+
+		// then add a very small bit of random in front of/behind the player action
+		VectorMA( end, crandom() * 25, dir, end );
+
+		gi.trace( &tr, NPC->currentOrigin, NULL, NULL, end, NPC->s.number, MASK_SOLID );
+
+		// Close enough
+		if ( tr.fraction > 0.9f )
+		{
+			VectorSubtract( tr.endpos, NPC->currentOrigin, dir );
+			dir[2] *= 0.25; // do less upward change
+			float dis = VectorNormalize( dir );
+
+			// Try to move the desired enemy side
+			VectorMA( NPC->client->ps.velocity, dis, dir, NPC->client->ps.velocity );
+
+			float upPush = SEEKER_UPWARD_PUSH;
+			if ( NPC->client->NPC_class != CLASS_BOBAFETT )
+			{
+				G_Sound( NPC, G_SoundIndex( "sound/chars/seeker/misc/hiss" ));
+			}
+			else
+			{
+				upPush *= 4.0f;
+			}
+
+			// Add a slight upward push
+			NPC->client->ps.velocity[2] += upPush;
+
+			NPCInfo->standTime = level.time + 2500 + random() * 500;
+		}
+	}
+}
+
+//------------------------------------
+void Seeker_Hunt( qboolean visible, qboolean advance )
+{
+	float	distance, speed;
+	vec3_t	forward;
+
+	NPC_FaceEnemy( qtrue );
+
+	// If we're not supposed to stand still, pursue the player
+	if ( NPCInfo->standTime < level.time )
+	{
+		// Only strafe when we can see the player
+		if ( visible )
+		{
+			Seeker_Strafe();
+			return;
+		}
+	}
+
+	// If we don't want to advance, stop here
+	if ( advance == qfalse )
+	{
+		return;
+	}
+
+	// Only try and navigate if the player is visible
+	if ( visible == qfalse )
+	{
+		// Move towards our goal
+		NPCInfo->goalEntity = NPC->enemy;
+		NPCInfo->goalRadius = 24;
+
+		NPC_MoveToGoal(qtrue);
+		return;
+
+	}
+	else
+	{
+		VectorSubtract( NPC->enemy->currentOrigin, NPC->currentOrigin, forward );
+		distance = VectorNormalize( forward );
+	}
+
+	speed = SEEKER_FORWARD_BASE_SPEED + SEEKER_FORWARD_MULTIPLIER * g_spskill->integer;
+	VectorMA( NPC->client->ps.velocity, speed, forward, NPC->client->ps.velocity );
+}
+
+//------------------------------------
+void Seeker_Fire( void )
+{
+	vec3_t		dir, enemy_org, muzzle;
+	gentity_t	*missile;
+
+	CalcEntitySpot( NPC->enemy, SPOT_HEAD, enemy_org );
+	VectorSubtract( enemy_org, NPC->currentOrigin, dir );
+	VectorNormalize( dir );
+
+	// move a bit forward in the direction we shall shoot in so that the bolt doesn't poke out the other side of the seeker
+	VectorMA( NPC->currentOrigin, 15, dir, muzzle );
+
+	missile = CreateMissile( muzzle, dir, 1000, 10000, NPC );
+
+	G_PlayEffect( "blaster/muzzle_flash", NPC->currentOrigin, dir );
+
+	missile->classname = "blaster";
+	missile->s.weapon = WP_BLASTER;
+
+	missile->damage = 5;
+	missile->dflags = DAMAGE_DEATH_KNOCKBACK;
+	missile->methodOfDeath = MOD_ENERGY;
+	missile->clipmask = MASK_SHOT | CONTENTS_LIGHTSABER;
+}
+
+//------------------------------------
+void Seeker_Ranged( qboolean visible, qboolean advance )
+{
+	if ( NPC->client->NPC_class != CLASS_BOBAFETT )
+	{
+		if ( NPC->count > 0 )
+		{
+			if ( TIMER_Done( NPC, "attackDelay" ))	// Attack?
+			{
+				TIMER_Set( NPC, "attackDelay", Q_irand( 250, 2500 ));
+				Seeker_Fire();
+				NPC->count--;
+			}
+		}
+		else
+		{
+			// out of ammo, so let it die...give it a push up so it can fall more and blow up on impact
+	//		NPC->client->ps.gravity = 900;
+	//		NPC->svFlags &= ~SVF_CUSTOM_GRAVITY;
+	//		NPC->client->ps.velocity[2] += 16;
+			G_Damage( NPC, NPC, NPC, NULL, NULL, 999, 0, MOD_UNKNOWN );
+		}
+	}
+
+	if ( NPCInfo->scriptFlags & SCF_CHASE_ENEMIES )
+	{
+		Seeker_Hunt( visible, advance );
+	}
+} 
+
+//------------------------------------
+void Seeker_Attack( void )
+{
+	// Always keep a good height off the ground
+	Seeker_MaintainHeight();
+
+	// Rate our distance to the target, and our visibilty
+	float		distance	= DistanceHorizontalSquared( NPC->currentOrigin, NPC->enemy->currentOrigin );	
+	qboolean	visible		= NPC_ClearLOS( NPC->enemy );
+	qboolean	advance		= (qboolean)(distance > MIN_DISTANCE_SQR);
+
+	if ( NPC->client->NPC_class == CLASS_BOBAFETT )
+	{
+		advance = (qboolean)(distance>(200.0f*200.0f));
+	}
+
+	// If we cannot see our target, move to see it
+	if ( visible == qfalse )
+	{
+		if ( NPCInfo->scriptFlags & SCF_CHASE_ENEMIES )
+		{
+			Seeker_Hunt( visible, advance );
+			return;
+		}
+	}
+
+	Seeker_Ranged( visible, advance );
+}
+
+//------------------------------------
+void Seeker_FindEnemy( void )
+{
+	int			numFound;
+	float		dis, bestDis = SEEKER_SEEK_RADIUS * SEEKER_SEEK_RADIUS + 1;
+	vec3_t		mins, maxs;
+	gentity_t	*entityList[MAX_GENTITIES], *ent, *best = NULL;
+
+	VectorSet( maxs, SEEKER_SEEK_RADIUS, SEEKER_SEEK_RADIUS, SEEKER_SEEK_RADIUS );
+	VectorScale( maxs, -1, mins );
+
+	numFound = gi.EntitiesInBox( mins, maxs, entityList, MAX_GENTITIES );
+
+	for ( int i = 0 ; i < numFound ; i++ ) 
+	{
+		ent = entityList[i];
+
+		if ( ent->s.number == NPC->s.number || !ent->client || !ent->NPC || ent->health <= 0 || !ent->inuse )
+		{
+			continue;
+		}
+
+		if ( ent->client->playerTeam == NPC->client->playerTeam || ent->client->playerTeam == TEAM_NEUTRAL ) // don't attack same team or bots
+		{
+			continue;
+		}
+
+		// try to find the closest visible one
+		if ( !NPC_ClearLOS( ent ))
+		{
+			continue;
+		}
+
+		dis = DistanceHorizontalSquared( NPC->currentOrigin, ent->currentOrigin );
+
+		if ( dis <= bestDis )
+		{
+			bestDis = dis;
+			best = ent;
+		}
+	}
+
+	if ( best )
+	{
+		// used to offset seekers around a circle so they don't occupy the same spot.  This is not a fool-proof method.
+		NPC->random = random() * 6.3f; // roughly 2pi
+
+		NPC->enemy = best;
+	}
+}
+
+//------------------------------------
+void Seeker_FollowPlayer( void )
+{
+	Seeker_MaintainHeight();
+
+	float	dis	= DistanceHorizontalSquared( NPC->currentOrigin, g_entities[0].currentOrigin );
+	vec3_t	pt, dir;
+	
+	float	minDistSqr = MIN_DISTANCE_SQR;
+
+	if ( NPC->client->NPC_class == CLASS_BOBAFETT )
+	{
+		if ( TIMER_Done( NPC, "flameTime" ) )
+		{
+			minDistSqr = 200*200;
+		}
+	}
+
+	if ( dis < minDistSqr )
+	{
+		// generally circle the player closely till we take an enemy..this is our target point
+		if ( NPC->client->NPC_class == CLASS_BOBAFETT )
+		{
+			pt[0] = g_entities[0].currentOrigin[0] + cos( level.time * 0.001f + NPC->random ) * 250;
+			pt[1] = g_entities[0].currentOrigin[1] + sin( level.time * 0.001f + NPC->random ) * 250;
+			if ( NPC->client->jetPackTime < level.time )
+			{
+				pt[2] = NPC->currentOrigin[2] - 64;
+			}
+			else
+			{
+				pt[2] = g_entities[0].currentOrigin[2] + 200;
+			}
+		}
+		else
+		{
+			pt[0] = g_entities[0].currentOrigin[0] + cos( level.time * 0.001f + NPC->random ) * 56;
+			pt[1] = g_entities[0].currentOrigin[1] + sin( level.time * 0.001f + NPC->random ) * 56;
+			pt[2] = g_entities[0].currentOrigin[2] + 40;
+		}
+
+		VectorSubtract( pt, NPC->currentOrigin, dir );
+		VectorMA( NPC->client->ps.velocity, 0.8f, dir, NPC->client->ps.velocity );
+	}
+	else
+	{
+		if ( NPC->client->NPC_class != CLASS_BOBAFETT )
+		{
+			if ( TIMER_Done( NPC, "seekerhiss" ))
+			{
+				TIMER_Set( NPC, "seekerhiss", 1000 + random() * 1000 );
+				G_Sound( NPC, G_SoundIndex( "sound/chars/seeker/misc/hiss" ));
+			}
+		}
+
+		// Hey come back!
+		NPCInfo->goalEntity = &g_entities[0];
+		NPCInfo->goalRadius = 32;
+		NPC_MoveToGoal( qtrue );
+		NPC->owner = &g_entities[0];
+	}
+
+	if ( NPCInfo->enemyCheckDebounceTime < level.time )
+	{
+		// check twice a second to find a new enemy
+		Seeker_FindEnemy();
+		NPCInfo->enemyCheckDebounceTime = level.time + 500;
+	}
+
+	NPC_UpdateAngles( qtrue, qtrue );
+}
+
+//------------------------------------
+void NPC_BSSeeker_Default( void )
+{
+	if ( in_camera )
+	{
+		if ( NPC->client->NPC_class != CLASS_BOBAFETT )
+		{
+			// cameras make me commit suicide....
+			G_Damage( NPC, NPC, NPC, NULL, NULL, 999, 0, MOD_UNKNOWN );
+		}
+	}
+
+	if ( NPC->random == 0.0f )
+	{
+		// used to offset seekers around a circle so they don't occupy the same spot.  This is not a fool-proof method.
+		NPC->random = random() * 6.3f; // roughly 2pi
+	}
+
+	if ( NPC->enemy && NPC->enemy->health && NPC->enemy->inuse )
+	{
+		if ( NPC->client->NPC_class != CLASS_BOBAFETT 
+			&& ( NPC->enemy->s.number == 0 || ( NPC->enemy->client && NPC->enemy->client->NPC_class == CLASS_SEEKER )) )
+		{
+			//hacked to never take the player as an enemy, even if the player shoots at it
+			NPC->enemy = NULL;
+		}
+		else
+		{
+			Seeker_Attack();
+			if ( NPC->client->NPC_class == CLASS_BOBAFETT )
+			{
+				Boba_FireDecide();
+			}
+			return;
+		}
+	}
+	else if ( NPC->client->NPC_class == CLASS_BOBAFETT )
+	{
+		NPC_BSST_Patrol();
+		return;
+	}
+
+	// In all other cases, follow the player and look for enemies to take on
+	Seeker_FollowPlayer();
+}
\ No newline at end of file
diff --git a/code/game/AI_Sentry.cpp b/code/game/AI_Sentry.cpp
new file mode 100644
index 0000000..69ec9b1
--- /dev/null
+++ b/code/game/AI_Sentry.cpp
@@ -0,0 +1,569 @@
+// leave this line at the top of all AI_xxxx.cpp files for PCH reasons...
+#include "g_headers.h"
+
+
+#include "b_local.h"
+#include "g_nav.h"
+
+gentity_t *CreateMissile( vec3_t org, vec3_t dir, float vel, int life, gentity_t *owner, qboolean altFire = qfalse );
+extern gitem_t	*FindItemForAmmo( ammo_t ammo );
+
+#define MIN_DISTANCE		256
+#define MIN_DISTANCE_SQR	( MIN_DISTANCE * MIN_DISTANCE )
+
+#define SENTRY_FORWARD_BASE_SPEED	10
+#define SENTRY_FORWARD_MULTIPLIER	5
+
+#define SENTRY_VELOCITY_DECAY	0.85f
+#define SENTRY_STRAFE_VEL		256
+#define SENTRY_STRAFE_DIS		200
+#define SENTRY_UPWARD_PUSH		32
+#define SENTRY_HOVER_HEIGHT		24
+
+//Local state enums
+enum
+{
+	LSTATE_NONE = 0,
+	LSTATE_ASLEEP,
+	LSTATE_WAKEUP,
+	LSTATE_ACTIVE,
+	LSTATE_POWERING_UP,
+	LSTATE_ATTACKING,
+};
+
+/*
+-------------------------
+NPC_Sentry_Precache
+-------------------------
+*/
+void NPC_Sentry_Precache(void)
+{
+	G_SoundIndex( "sound/chars/sentry/misc/sentry_explo" );
+	G_SoundIndex( "sound/chars/sentry/misc/sentry_pain" );
+	G_SoundIndex( "sound/chars/sentry/misc/sentry_shield_open" );
+	G_SoundIndex( "sound/chars/sentry/misc/sentry_shield_close" );
+	G_SoundIndex( "sound/chars/sentry/misc/sentry_hover_1_lp" );
+	G_SoundIndex( "sound/chars/sentry/misc/sentry_hover_2_lp" );
+
+	for ( int i = 1; i < 4; i++)
+	{
+		G_SoundIndex( va( "sound/chars/sentry/misc/talk%d", i ) );
+	}
+
+	G_EffectIndex( "bryar/muzzle_flash");
+	G_EffectIndex( "env/med_explode");
+
+	RegisterItem( FindItemForAmmo( AMMO_BLASTER ));
+}
+
+/*
+================
+sentry_use
+================
+*/
+void sentry_use( gentity_t *self, gentity_t *other, gentity_t *activator)
+{
+	G_ActivateBehavior(self,BSET_USE);
+
+	self->flags &= ~FL_SHIELDED;
+	NPC_SetAnim( self, SETANIM_BOTH, BOTH_POWERUP1, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+//	self->NPC->localState = LSTATE_WAKEUP;
+	self->NPC->localState = LSTATE_ACTIVE;
+}
+
+/*
+-------------------------
+NPC_Sentry_Pain
+-------------------------
+*/
+void NPC_Sentry_Pain( gentity_t *self, gentity_t *inflictor, gentity_t *other, const vec3_t point, int damage, int mod,int hitLoc ) 
+{		
+	NPC_Pain( self, inflictor, other, point, damage, mod );
+
+	if ( mod == MOD_DEMP2 || mod == MOD_DEMP2_ALT )
+	{
+		self->NPC->burstCount = 0;
+		TIMER_Set( self, "attackDelay", Q_irand( 9000, 12000) );
+		self->flags |= FL_SHIELDED;
+		NPC_SetAnim( self, SETANIM_BOTH, BOTH_FLY_SHIELDED, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+		G_SoundOnEnt( self, CHAN_AUTO, "sound/chars/sentry/misc/sentry_pain" );		
+
+		self->NPC->localState = LSTATE_ACTIVE;
+	}
+
+	// You got hit, go after the enemy
+//	if (self->NPC->localState == LSTATE_ASLEEP)
+//	{
+//		G_Sound( self, G_SoundIndex("sound/chars/sentry/misc/shieldsopen.wav"));
+//
+//		self->flags &= ~FL_SHIELDED;
+//		NPC_SetAnim( self, SETANIM_BOTH, BOTH_POWERUP1, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+//		self->NPC->localState = LSTATE_WAKEUP;
+//	}
+}
+
+/*
+-------------------------
+Sentry_Fire
+-------------------------
+*/
+void Sentry_Fire (void)
+{
+	vec3_t	muzzle;
+	static	vec3_t	forward, vright, up;
+	gentity_t	*missile;
+	mdxaBone_t	boltMatrix;
+	int			bolt;
+
+	NPC->flags &= ~FL_SHIELDED;
+
+	if ( NPCInfo->localState == LSTATE_POWERING_UP )
+	{
+		if ( TIMER_Done( NPC, "powerup" ))
+		{
+			NPCInfo->localState = LSTATE_ATTACKING;
+			NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_ATTACK1, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+		}
+		else
+		{
+			// can't do anything right now
+			return;
+		}
+	}
+	else if ( NPCInfo->localState == LSTATE_ACTIVE )
+	{
+		NPCInfo->localState = LSTATE_POWERING_UP;
+
+		G_SoundOnEnt( NPC, CHAN_AUTO, "sound/chars/sentry/misc/sentry_shield_open" );		
+		NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_POWERUP1, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+		TIMER_Set( NPC, "powerup", 250 );
+		return;
+	}
+	else if ( NPCInfo->localState != LSTATE_ATTACKING )
+	{
+		// bad because we are uninitialized
+		NPCInfo->localState = LSTATE_ACTIVE;
+		return;
+	}
+
+	// Which muzzle to fire from?
+	int which = NPCInfo->burstCount % 3;
+	switch( which )
+	{
+	case 0:
+		bolt = NPC->genericBolt1; 
+		break;
+	case 1:
+		bolt = NPC->genericBolt2; 
+		break;
+	case 2:
+	default:
+		bolt = NPC->genericBolt3; 
+	}
+
+	gi.G2API_GetBoltMatrix( NPC->ghoul2, NPC->playerModel, 
+				bolt,
+				&boltMatrix, NPC->currentAngles, NPC->currentOrigin, (cg.time?cg.time:level.time),
+				NULL, NPC->s.modelScale );
+
+	gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, muzzle );
+
+	AngleVectors( NPC->currentAngles, forward, vright, up );
+//	G_Sound( NPC, G_SoundIndex("sound/chars/sentry/misc/shoot.wav"));
+
+	G_PlayEffect( "bryar/muzzle_flash", muzzle, forward );
+
+	missile = CreateMissile( muzzle, forward, 1600, 10000, NPC );
+
+	missile->classname = "bryar_proj";
+	missile->s.weapon = WP_BRYAR_PISTOL;
+
+	missile->dflags = DAMAGE_DEATH_KNOCKBACK;
+	missile->methodOfDeath = MOD_ENERGY;
+	missile->clipmask = MASK_SHOT | CONTENTS_LIGHTSABER;
+
+	NPCInfo->burstCount++;
+	NPC->attackDebounceTime = level.time + 50;
+	missile->damage = 5;
+
+	// now scale for difficulty
+	if ( g_spskill->integer == 0 )
+	{
+		NPC->attackDebounceTime += 200;
+		missile->damage = 1;
+	}
+	else if ( g_spskill->integer == 1 )
+	{
+		NPC->attackDebounceTime += 100;
+		missile->damage = 3;
+	}
+}
+
+/*
+-------------------------
+Sentry_MaintainHeight
+-------------------------
+*/
+void Sentry_MaintainHeight( void )
+{	
+	float	dif;
+
+	NPC->s.loopSound = G_SoundIndex( "sound/chars/sentry/misc/sentry_hover_1_lp" );
+
+	// Update our angles regardless
+	NPC_UpdateAngles( qtrue, qtrue );
+
+	// If we have an enemy, we should try to hover at about enemy eye level
+	if ( NPC->enemy )
+	{
+		// Find the height difference
+		dif = (NPC->enemy->currentOrigin[2]+NPC->enemy->maxs[2]) - NPC->currentOrigin[2]; 
+
+		// cap to prevent dramatic height shifts
+		if ( fabs( dif ) > 8 )
+		{
+			if ( fabs( dif ) > SENTRY_HOVER_HEIGHT )
+			{
+				dif = ( dif < 0 ? -24 : 24 );
+			}
+
+			NPC->client->ps.velocity[2] = (NPC->client->ps.velocity[2]+dif)/2;
+		}
+	}
+	else
+	{
+		gentity_t *goal = NULL;
+
+		if ( NPCInfo->goalEntity )	// Is there a goal?
+		{
+			goal = NPCInfo->goalEntity;
+		}
+		else
+		{
+			goal = NPCInfo->lastGoalEntity;
+		}
+
+		if (goal)
+		{
+			dif = goal->currentOrigin[2] - NPC->currentOrigin[2];
+
+			if ( fabs( dif ) > SENTRY_HOVER_HEIGHT )
+			{
+				ucmd.upmove = ( ucmd.upmove < 0 ? -4 : 4 );
+			}
+			else
+			{
+				if ( NPC->client->ps.velocity[2] )
+				{
+					NPC->client->ps.velocity[2] *= SENTRY_VELOCITY_DECAY;
+
+					if ( fabs( NPC->client->ps.velocity[2] ) < 2 )
+					{
+						NPC->client->ps.velocity[2] = 0;
+					}
+				}
+			}
+		}
+		// Apply friction to Z
+		else if ( NPC->client->ps.velocity[2] )
+		{
+			NPC->client->ps.velocity[2] *= SENTRY_VELOCITY_DECAY;
+
+			if ( fabs( NPC->client->ps.velocity[2] ) < 1 )
+			{
+				NPC->client->ps.velocity[2] = 0;
+			}
+		}
+	}
+
+	// Apply friction
+	if ( NPC->client->ps.velocity[0] )
+	{
+		NPC->client->ps.velocity[0] *= SENTRY_VELOCITY_DECAY;
+
+		if ( fabs( NPC->client->ps.velocity[0] ) < 1 )
+		{
+			NPC->client->ps.velocity[0] = 0;
+		}
+	}
+
+	if ( NPC->client->ps.velocity[1] )
+	{
+		NPC->client->ps.velocity[1] *= SENTRY_VELOCITY_DECAY;
+
+		if ( fabs( NPC->client->ps.velocity[1] ) < 1 )
+		{
+			NPC->client->ps.velocity[1] = 0;
+		}
+	}
+
+	NPC_FaceEnemy( qtrue );
+}
+
+/*
+-------------------------
+Sentry_Idle
+-------------------------
+*/
+void Sentry_Idle( void )
+{
+	Sentry_MaintainHeight();
+
+	// Is he waking up?
+	if (NPCInfo->localState == LSTATE_WAKEUP)
+	{
+		if (NPC->client->ps.torsoAnimTimer<=0)
+		{
+			NPCInfo->scriptFlags |= SCF_LOOK_FOR_ENEMIES;
+			NPCInfo->burstCount = 0;
+		}
+	}
+	else
+	{
+		NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_SLEEP1, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+		NPC->flags |= FL_SHIELDED;
+
+		NPC_BSIdle();
+	}
+}
+
+/*
+-------------------------
+Sentry_Strafe
+-------------------------
+*/
+void Sentry_Strafe( void )
+{
+	int		dir;
+	vec3_t	end, right;
+	trace_t	tr;
+
+	AngleVectors( NPC->client->renderInfo.eyeAngles, NULL, right, NULL );
+
+	// Pick a random strafe direction, then check to see if doing a strafe would be
+	//	reasonable valid
+	dir = ( rand() & 1 ) ? -1 : 1;
+	VectorMA( NPC->currentOrigin, SENTRY_STRAFE_DIS * dir, right, end );
+
+	gi.trace( &tr, NPC->currentOrigin, NULL, NULL, end, NPC->s.number, MASK_SOLID );
+
+	// Close enough
+	if ( tr.fraction > 0.9f )
+	{
+		VectorMA( NPC->client->ps.velocity, SENTRY_STRAFE_VEL * dir, right, NPC->client->ps.velocity );
+
+		// Add a slight upward push
+		NPC->client->ps.velocity[2] += SENTRY_UPWARD_PUSH;
+
+		// Set the strafe start time so we can do a controlled roll
+		NPC->fx_time = level.time;
+		NPCInfo->standTime = level.time + 3000 + random() * 500;
+	}
+}
+
+/*
+-------------------------
+Sentry_Hunt
+-------------------------
+*/
+void Sentry_Hunt( qboolean visible, qboolean advance )
+{
+	float	distance, speed;
+	vec3_t	forward;
+
+	//If we're not supposed to stand still, pursue the player
+	if ( NPCInfo->standTime < level.time )
+	{
+		// Only strafe when we can see the player
+		if ( visible )
+		{
+			Sentry_Strafe();
+			return;
+		}
+	}
+
+	//If we don't want to advance, stop here
+	if ( !advance && visible )
+		return;
+
+	//Only try and navigate if the player is visible
+	if ( visible == qfalse )
+	{
+		// Move towards our goal
+		NPCInfo->goalEntity = NPC->enemy;
+		NPCInfo->goalRadius = 12;
+
+		NPC_MoveToGoal(qtrue);
+		return;
+	}
+	else
+	{
+		VectorSubtract( NPC->enemy->currentOrigin, NPC->currentOrigin, forward );
+		distance = VectorNormalize( forward );
+	}
+
+	speed = SENTRY_FORWARD_BASE_SPEED + SENTRY_FORWARD_MULTIPLIER * g_spskill->integer;
+	VectorMA( NPC->client->ps.velocity, speed, forward, NPC->client->ps.velocity );
+}
+
+/*
+-------------------------
+Sentry_RangedAttack
+-------------------------
+*/
+void Sentry_RangedAttack( qboolean visible, qboolean advance )
+{
+	if ( TIMER_Done( NPC, "attackDelay" ) && NPC->attackDebounceTime < level.time && visible )	// Attack?
+	{
+		if ( NPCInfo->burstCount > 6 )
+		{
+			if ( !NPC->fly_sound_debounce_time )
+			{//delay closing down to give the player an opening
+				NPC->fly_sound_debounce_time = level.time + Q_irand( 500, 2000 );
+			}
+			else if ( NPC->fly_sound_debounce_time < level.time )
+			{
+				NPCInfo->localState = LSTATE_ACTIVE;
+				NPC->fly_sound_debounce_time = NPCInfo->burstCount = 0;
+				TIMER_Set( NPC, "attackDelay", Q_irand( 2000, 3500) );
+				NPC->flags |= FL_SHIELDED;
+				NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_FLY_SHIELDED, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+				G_SoundOnEnt( NPC, CHAN_AUTO, "sound/chars/sentry/misc/sentry_shield_close" );
+			}
+		}
+		else
+		{
+			Sentry_Fire();
+		}
+	}
+
+	if ( NPCInfo->scriptFlags & SCF_CHASE_ENEMIES )
+	{
+		Sentry_Hunt( visible, advance );
+	}
+}
+
+/*
+-------------------------
+Sentry_AttackDecision
+-------------------------
+*/
+void Sentry_AttackDecision( void )
+{
+	// Always keep a good height off the ground
+	Sentry_MaintainHeight();
+
+	NPC->s.loopSound = G_SoundIndex( "sound/chars/sentry/misc/sentry_hover_2_lp" );
+
+	//randomly talk
+	if ( TIMER_Done(NPC,"patrolNoise") )
+	{
+		if (TIMER_Done(NPC,"angerNoise"))
+		{
+			G_SoundOnEnt( NPC, CHAN_AUTO, va("sound/chars/sentry/misc/talk%d", Q_irand(1, 3)) );
+
+			TIMER_Set( NPC, "patrolNoise", Q_irand( 4000, 10000 ) );
+		}
+	}
+
+	// He's dead.
+	if (NPC->enemy->health<1)
+	{
+		NPC->enemy = NULL;
+		Sentry_Idle();
+		return;
+	}
+
+	// If we don't have an enemy, just idle
+	if ( NPC_CheckEnemyExt() == qfalse )
+	{
+		Sentry_Idle();
+		return;
+	}
+
+	// Rate our distance to the target and visibilty
+	float		distance	= (int) DistanceHorizontalSquared( NPC->currentOrigin, NPC->enemy->currentOrigin );	
+	qboolean	visible		= NPC_ClearLOS( NPC->enemy );
+	qboolean	advance		= (qboolean)(distance > MIN_DISTANCE_SQR);
+
+	// If we cannot see our target, move to see it
+	if ( visible == qfalse )
+	{
+		if ( NPCInfo->scriptFlags & SCF_CHASE_ENEMIES )
+		{
+			Sentry_Hunt( visible, advance );
+			return;
+		}
+	}
+
+	NPC_FaceEnemy( qtrue );
+
+	Sentry_RangedAttack( visible, advance );
+}
+
+qboolean NPC_CheckPlayerTeamStealth( void );
+
+/*
+-------------------------
+NPC_Sentry_Patrol
+-------------------------
+*/
+void NPC_Sentry_Patrol( void )
+{
+	Sentry_MaintainHeight();
+
+	//If we have somewhere to go, then do that
+	if (!NPC->enemy)
+	{
+		if ( NPC_CheckPlayerTeamStealth() )
+		{
+			//NPC_AngerSound();
+			NPC_UpdateAngles( qtrue, qtrue );
+			return;
+		}
+
+		if ( UpdateGoal() )
+		{
+			//start loop sound once we move
+			ucmd.buttons |= BUTTON_WALKING;
+			NPC_MoveToGoal( qtrue );
+		}
+
+		//randomly talk
+		if (TIMER_Done(NPC,"patrolNoise"))
+		{
+			G_SoundOnEnt( NPC, CHAN_AUTO, va("sound/chars/sentry/misc/talk%d", Q_irand(1, 3)) );
+
+			TIMER_Set( NPC, "patrolNoise", Q_irand( 2000, 4000 ) );
+		}
+	}
+
+	NPC_UpdateAngles( qtrue, qtrue );
+}
+
+/*
+-------------------------
+NPC_BSSentry_Default
+-------------------------
+*/
+void NPC_BSSentry_Default( void )
+{
+	if ( NPC->targetname )
+	{
+		NPC->e_UseFunc = useF_sentry_use;
+	}
+
+	if (( NPC->enemy ) && (NPCInfo->localState != LSTATE_WAKEUP))
+	{
+		// Don't attack if waking up or if no enemy
+		Sentry_AttackDecision();
+	}
+	else if ( NPCInfo->scriptFlags & SCF_LOOK_FOR_ENEMIES )
+	{
+		NPC_Sentry_Patrol();
+	}
+	else
+	{
+		Sentry_Idle();
+	}
+}
diff --git a/code/game/AI_Sniper.cpp b/code/game/AI_Sniper.cpp
new file mode 100644
index 0000000..4aad139
--- /dev/null
+++ b/code/game/AI_Sniper.cpp
@@ -0,0 +1,911 @@
+// leave this line at the top of all AI_xxxx.cpp files for PCH reasons...
+#include "g_headers.h"
+
+
+#include "b_local.h"
+#include "g_nav.h"
+#include "anims.h"
+#include "g_navigator.h"
+
+extern void CG_DrawAlert( vec3_t origin, float rating );
+extern void G_AddVoiceEvent( gentity_t *self, int event, int speakDebounceTime );
+extern void NPC_TempLookTarget( gentity_t *self, int lookEntNum, int minLookTime, int maxLookTime );
+extern qboolean G_ExpandPointToBBox( vec3_t point, const vec3_t mins, const vec3_t maxs, int ignore, int clipmask );
+extern qboolean FlyingCreature( gentity_t *ent );
+extern void Saboteur_Cloak( gentity_t *self );
+
+//extern	CNavigator	navigator;
+
+#define	SPF_NO_HIDE			2
+
+#define	MAX_VIEW_DIST		1024
+#define MAX_VIEW_SPEED		250
+#define	MAX_LIGHT_INTENSITY 255
+#define	MIN_LIGHT_THRESHOLD	0.1
+
+#define	DISTANCE_SCALE		0.25f
+#define	DISTANCE_THRESHOLD	0.075f
+#define	SPEED_SCALE			0.25f
+#define	FOV_SCALE			0.5f
+#define	LIGHT_SCALE			0.25f
+
+#define	REALIZE_THRESHOLD	0.6f
+#define CAUTIOUS_THRESHOLD	( REALIZE_THRESHOLD * 0.75 )
+
+extern void NPC_Tusken_Taunt( void );
+qboolean NPC_CheckPlayerTeamStealth( void );
+
+static qboolean enemyLOS;
+static qboolean enemyCS;
+static qboolean faceEnemy;
+static qboolean move;
+static qboolean shoot;
+static float	enemyDist;
+
+//Local state enums
+enum
+{
+	LSTATE_NONE = 0,
+	LSTATE_UNDERFIRE,
+	LSTATE_INVESTIGATE,
+};
+
+void Sniper_ClearTimers( gentity_t *ent )
+{
+	TIMER_Set( ent, "chatter", 0 );
+	TIMER_Set( ent, "duck", 0 );
+	TIMER_Set( ent, "stand", 0 );
+	TIMER_Set( ent, "shuffleTime", 0 );
+	TIMER_Set( ent, "sleepTime", 0 );
+	TIMER_Set( ent, "enemyLastVisible", 0 );
+	TIMER_Set( ent, "roamTime", 0 );
+	TIMER_Set( ent, "hideTime", 0 );
+	TIMER_Set( ent, "attackDelay", 0 );	//FIXME: Slant for difficulty levels
+	TIMER_Set( ent, "stick", 0 );
+	TIMER_Set( ent, "scoutTime", 0 );
+	TIMER_Set( ent, "flee", 0 );
+	TIMER_Set( ent, "taunting", 0 );
+}
+
+void NPC_Sniper_PlayConfusionSound( gentity_t *self )
+{//FIXME: make this a custom sound in sound set
+	if ( self->health > 0 )
+	{
+		G_AddVoiceEvent( self, Q_irand(EV_CONFUSE1, EV_CONFUSE3), 2000 );
+	}
+	//reset him to be totally unaware again
+	TIMER_Set( self, "enemyLastVisible", 0 );
+	TIMER_Set( self, "flee", 0 );
+	self->NPC->squadState = SQUAD_IDLE;
+	self->NPC->tempBehavior = BS_DEFAULT;
+
+	//self->NPC->behaviorState = BS_PATROL;
+	G_ClearEnemy( self );//FIXME: or just self->enemy = NULL;?
+
+	self->NPC->investigateCount = 0;
+}
+
+
+/*
+-------------------------
+NPC_ST_Pain
+-------------------------
+*/
+
+void NPC_Sniper_Pain( gentity_t *self, gentity_t *inflictor, gentity_t *other, vec3_t point, int damage, int mod ) 
+{
+	self->NPC->localState = LSTATE_UNDERFIRE;
+
+	if ( self->client->NPC_class == CLASS_SABOTEUR )
+	{
+		Saboteur_Decloak( self );
+	}
+	TIMER_Set( self, "duck", -1 );
+	TIMER_Set( self, "stand", 2000 );
+
+	NPC_Pain( self, inflictor, other, point, damage, mod );
+
+	if ( !damage && self->health > 0 )
+	{//FIXME: better way to know I was pushed
+		G_AddVoiceEvent( self, Q_irand(EV_PUSHED1, EV_PUSHED3), 2000 );
+	}
+}
+
+/*
+-------------------------
+ST_HoldPosition
+-------------------------
+*/
+
+static void Sniper_HoldPosition( void )
+{
+	NPC_FreeCombatPoint( NPCInfo->combatPoint, qtrue );
+	NPCInfo->goalEntity = NULL;
+	
+	/*if ( TIMER_Done( NPC, "stand" ) )
+	{//FIXME: what if can't shoot from this pos?
+		TIMER_Set( NPC, "duck", Q_irand( 2000, 4000 ) );
+	}
+	*/
+}
+
+/*
+-------------------------
+ST_Move
+-------------------------
+*/
+
+static qboolean Sniper_Move( void )
+{
+	NPCInfo->combatMove = qtrue;//always move straight toward our goal
+
+	qboolean	moved = NPC_MoveToGoal( qtrue );
+//	navInfo_t	info;
+	
+	//Get the move info
+//	NAV_GetLastMove( info );
+
+	//FIXME: if we bump into another one of our guys and can't get around him, just stop!
+	//If we hit our target, then stop and fire!
+//	if ( info.flags & NIF_COLLISION ) 
+//	{
+//		if ( info.blocker == NPC->enemy )
+//		{
+//			Sniper_HoldPosition();
+//		}
+//	}
+
+	//If our move failed, then reset
+	if ( moved == qfalse )
+	{//couldn't get to enemy
+		if ( (NPCInfo->scriptFlags&SCF_CHASE_ENEMIES) && NPCInfo->goalEntity && NPCInfo->goalEntity == NPC->enemy )
+		{//we were running after enemy
+			//Try to find a combat point that can hit the enemy
+			int cpFlags = (CP_CLEAR|CP_HAS_ROUTE);
+			if ( NPCInfo->scriptFlags&SCF_USE_CP_NEAREST )
+			{
+				cpFlags &= ~(CP_FLANK|CP_APPROACH_ENEMY|CP_CLOSEST);
+				cpFlags |= CP_NEAREST;
+			}
+			int cp = NPC_FindCombatPoint( NPC->currentOrigin, NPC->currentOrigin, NPC->currentOrigin, cpFlags, 32 );
+			if ( cp == -1 && !(NPCInfo->scriptFlags&SCF_USE_CP_NEAREST) )
+			{//okay, try one by the enemy
+				cp = NPC_FindCombatPoint( NPC->currentOrigin, NPC->currentOrigin, NPC->enemy->currentOrigin, CP_CLEAR|CP_HAS_ROUTE|CP_HORZ_DIST_COLL, 32 );
+			}
+			//NOTE: there may be a perfectly valid one, just not one within CP_COLLECT_RADIUS of either me or him...
+			if ( cp != -1 )
+			{//found a combat point that has a clear shot to enemy
+				NPC_SetCombatPoint( cp );
+				NPC_SetMoveGoal( NPC, level.combatPoints[cp].origin, 8, qtrue, cp );
+				return moved;
+			}
+		}
+		//just hang here
+		Sniper_HoldPosition();
+	}
+
+	return moved;
+}
+
+/*
+-------------------------
+NPC_BSSniper_Patrol
+-------------------------
+*/
+
+void NPC_BSSniper_Patrol( void )
+{//FIXME: pick up on bodies of dead buddies?
+	NPC->count = 0;
+
+	if ( NPCInfo->confusionTime < level.time )
+	{
+		//Look for any enemies
+		if ( NPCInfo->scriptFlags&SCF_LOOK_FOR_ENEMIES )
+		{
+			if ( NPC_CheckPlayerTeamStealth() )
+			{
+				//NPCInfo->behaviorState = BS_HUNT_AND_KILL;//Should be auto now
+				//NPC_AngerSound();
+				NPC_UpdateAngles( qtrue, qtrue );
+				return;
+			}
+		}
+
+		if ( !(NPCInfo->scriptFlags&SCF_IGNORE_ALERTS) )
+		{
+			//Is there danger nearby
+			int alertEvent = NPC_CheckAlertEvents( qtrue, qtrue, -1, qfalse, AEL_SUSPICIOUS );
+			if ( NPC_CheckForDanger( alertEvent ) )
+			{
+				NPC_UpdateAngles( qtrue, qtrue );
+				return;
+			}
+			else
+			{//check for other alert events
+				//There is an event to look at
+				if ( alertEvent >= 0 )//&& level.alertEvents[alertEvent].ID != NPCInfo->lastAlertID )
+				{
+					//NPCInfo->lastAlertID = level.alertEvents[alertEvent].ID;
+					if ( level.alertEvents[alertEvent].level == AEL_DISCOVERED )
+					{
+						if ( level.alertEvents[alertEvent].owner && 
+							level.alertEvents[alertEvent].owner->client && 
+							level.alertEvents[alertEvent].owner->health >= 0 &&
+							level.alertEvents[alertEvent].owner->client->playerTeam == NPC->client->enemyTeam )
+						{//an enemy
+							G_SetEnemy( NPC, level.alertEvents[alertEvent].owner );
+							//NPCInfo->enemyLastSeenTime = level.time;
+							TIMER_Set( NPC, "attackDelay", Q_irand( (6-NPCInfo->stats.aim)*100, (6-NPCInfo->stats.aim)*500 ) );
+						}
+					}
+					else
+					{//FIXME: get more suspicious over time?
+						//Save the position for movement (if necessary)
+						//FIXME: sound?
+						VectorCopy( level.alertEvents[alertEvent].position, NPCInfo->investigateGoal );
+						NPCInfo->investigateDebounceTime = level.time + Q_irand( 500, 1000 );
+						if ( level.alertEvents[alertEvent].level == AEL_SUSPICIOUS )
+						{//suspicious looks longer
+							NPCInfo->investigateDebounceTime += Q_irand( 500, 2500 );
+						}
+					}
+				}
+			}
+
+			if ( NPCInfo->investigateDebounceTime > level.time )
+			{//FIXME: walk over to it, maybe?  Not if not chase enemies flag
+				//NOTE: stops walking or doing anything else below
+				vec3_t	dir, angles;
+				float	o_yaw, o_pitch;
+				
+				VectorSubtract( NPCInfo->investigateGoal, NPC->client->renderInfo.eyePoint, dir );
+				vectoangles( dir, angles );
+				
+				o_yaw = NPCInfo->desiredYaw;
+				o_pitch = NPCInfo->desiredPitch;
+				NPCInfo->desiredYaw = angles[YAW];
+				NPCInfo->desiredPitch = angles[PITCH];
+				
+				NPC_UpdateAngles( qtrue, qtrue );
+
+				NPCInfo->desiredYaw = o_yaw;
+				NPCInfo->desiredPitch = o_pitch;
+				return;
+			}
+		}
+	}
+
+	//If we have somewhere to go, then do that
+	if ( UpdateGoal() )
+	{
+		ucmd.buttons |= BUTTON_WALKING;
+		NPC_MoveToGoal( qtrue );
+	}
+
+	NPC_UpdateAngles( qtrue, qtrue );
+}
+
+/*
+-------------------------
+NPC_BSSniper_Idle
+-------------------------
+*/
+/*
+void NPC_BSSniper_Idle( void )
+{
+	//reset our shotcount
+	NPC->count = 0;
+
+	//FIXME: check for other alert events?
+
+	//Is there danger nearby?
+	if ( NPC_CheckForDanger( NPC_CheckAlertEvents( qtrue, qtrue ) ) )
+	{
+		NPC_UpdateAngles( qtrue, qtrue );
+		return;
+	}
+
+	TIMER_Set( NPC, "roamTime", 2000 + Q_irand( 1000, 2000 ) );
+
+	NPC_UpdateAngles( qtrue, qtrue );
+}
+*/
+/*
+-------------------------
+ST_CheckMoveState
+-------------------------
+*/
+
+static void Sniper_CheckMoveState( void )
+{
+	//See if we're a scout
+	if ( !(NPCInfo->scriptFlags & SCF_CHASE_ENEMIES) )//NPCInfo->behaviorState == BS_STAND_AND_SHOOT )
+	{
+		if ( NPCInfo->goalEntity == NPC->enemy )
+		{
+			move = qfalse;
+			return;
+		}
+	}
+	//See if we're running away
+	else if ( NPCInfo->squadState == SQUAD_RETREAT )
+	{
+		if ( TIMER_Done( NPC, "flee" ) )
+		{
+			NPCInfo->squadState = SQUAD_IDLE;
+		}
+		else
+		{
+			faceEnemy = qfalse;
+		}
+	}
+	else if ( NPCInfo->squadState == SQUAD_IDLE )
+	{
+		if ( !NPCInfo->goalEntity )
+		{
+			move = qfalse;
+			return;
+		}
+	}
+
+	if ( !TIMER_Done( NPC, "taunting" ) )
+	{//no move while taunting
+		move = qfalse;
+		return;
+	}
+
+	//See if we're moving towards a goal, not the enemy
+	if ( ( NPCInfo->goalEntity != NPC->enemy ) && ( NPCInfo->goalEntity != NULL ) )
+	{
+		//Did we make it?
+		if ( STEER::Reached(NPC, NPCInfo->goalEntity, 16, !!FlyingCreature(NPC)) || 
+			( NPCInfo->squadState == SQUAD_SCOUT && enemyLOS && enemyDist <= 10000 ) )
+		{
+			int	newSquadState = SQUAD_STAND_AND_SHOOT;
+			//we got where we wanted to go, set timers based on why we were running
+			switch ( NPCInfo->squadState )
+			{
+			case SQUAD_RETREAT://was running away
+				if ( NPC->client->NPC_class == CLASS_SABOTEUR )
+				{
+					Saboteur_Cloak( NPC );
+				}
+				TIMER_Set( NPC, "duck", (NPC->max_health - NPC->health) * 100 );
+				TIMER_Set( NPC, "hideTime", Q_irand( 3000, 7000 ) );
+				newSquadState = SQUAD_COVER;
+				break;
+			case SQUAD_TRANSITION://was heading for a combat point
+				TIMER_Set( NPC, "hideTime", Q_irand( 2000, 4000 ) );
+				break;
+			case SQUAD_SCOUT://was running after player
+				break;
+			default:
+				break;
+			}
+			NPC_ReachedGoal();
+			//don't attack right away
+			TIMER_Set( NPC, "attackDelay", Q_irand( (6-NPCInfo->stats.aim)*50, (6-NPCInfo->stats.aim)*100 ) );	//FIXME: Slant for difficulty levels, too?
+			//don't do something else just yet
+			TIMER_Set( NPC, "roamTime", Q_irand( 1000, 4000 ) );
+			//stop fleeing
+			if ( NPCInfo->squadState == SQUAD_RETREAT )
+			{
+				TIMER_Set( NPC, "flee", -level.time );
+				NPCInfo->squadState = SQUAD_IDLE;
+			}
+			return;
+		}
+
+		//keep going, hold of roamTimer until we get there
+		TIMER_Set( NPC, "roamTime", Q_irand( 4000, 8000 ) );
+	}
+}
+
+static void Sniper_ResolveBlockedShot( void )
+{
+	if ( TIMER_Done( NPC, "duck" ) )
+	{//we're not ducking
+		if ( TIMER_Done( NPC, "roamTime" ) )
+		{//not roaming
+			//FIXME: try to find another spot from which to hit the enemy
+			if ( (NPCInfo->scriptFlags&SCF_CHASE_ENEMIES) && (!NPCInfo->goalEntity || NPCInfo->goalEntity == NPC->enemy) )
+			{//we were running after enemy
+				//Try to find a combat point that can hit the enemy
+				int cpFlags = (CP_CLEAR|CP_HAS_ROUTE);
+				if ( NPCInfo->scriptFlags&SCF_USE_CP_NEAREST )
+				{
+					cpFlags &= ~(CP_FLANK|CP_APPROACH_ENEMY|CP_CLOSEST);
+					cpFlags |= CP_NEAREST;
+				}
+				int cp = NPC_FindCombatPoint( NPC->currentOrigin, NPC->currentOrigin, NPC->currentOrigin, cpFlags, 32 );
+				if ( cp == -1 && !(NPCInfo->scriptFlags&SCF_USE_CP_NEAREST) )
+				{//okay, try one by the enemy
+					cp = NPC_FindCombatPoint( NPC->currentOrigin, NPC->currentOrigin, NPC->enemy->currentOrigin, CP_CLEAR|CP_HAS_ROUTE|CP_HORZ_DIST_COLL, 32 );
+				}
+				//NOTE: there may be a perfectly valid one, just not one within CP_COLLECT_RADIUS of either me or him...
+				if ( cp != -1 )
+				{//found a combat point that has a clear shot to enemy
+					NPC_SetCombatPoint( cp );
+					NPC_SetMoveGoal( NPC, level.combatPoints[cp].origin, 8, qtrue, cp );
+					TIMER_Set( NPC, "duck", -1 );
+					if ( NPC->client->NPC_class == CLASS_SABOTEUR )
+					{
+						Saboteur_Decloak( NPC );
+					}
+					TIMER_Set( NPC, "attackDelay", Q_irand( 1000, 3000 ) );
+					return;
+				}
+			}
+		}
+	}
+	/*
+	else
+	{//maybe we should stand
+		if ( TIMER_Done( NPC, "stand" ) )
+		{//stand for as long as we'll be here
+			TIMER_Set( NPC, "stand", Q_irand( 500, 2000 ) );
+			return;
+		}
+	}
+	//Hmm, can't resolve this by telling them to duck or telling me to stand
+	//We need to move!
+	TIMER_Set( NPC, "roamTime", -1 );
+	TIMER_Set( NPC, "stick", -1 );
+	TIMER_Set( NPC, "duck", -1 );
+	TIMER_Set( NPC, "attackDelay", Q_irand( 1000, 3000 ) );
+	*/
+}
+
+/*
+-------------------------
+ST_CheckFireState
+-------------------------
+*/
+
+static void Sniper_CheckFireState( void )
+{
+	if ( enemyCS )
+	{//if have a clear shot, always try
+		return;
+	}
+
+	if ( NPCInfo->squadState == SQUAD_RETREAT || NPCInfo->squadState == SQUAD_TRANSITION || NPCInfo->squadState == SQUAD_SCOUT )
+	{//runners never try to fire at the last pos
+		return;
+	}
+
+	if ( !VectorCompare( NPC->client->ps.velocity, vec3_origin ) )
+	{//if moving at all, don't do this
+		return;
+	}
+
+	if ( !TIMER_Done( NPC, "taunting" ) )
+	{//no shoot while taunting
+		return;
+	}
+
+	//continue to fire on their last position
+	if ( !Q_irand( 0, 1 ) 
+		&& NPCInfo->enemyLastSeenTime 
+		&& level.time - NPCInfo->enemyLastSeenTime < ((5-NPCInfo->stats.aim)*1000) )//FIXME: incorporate skill too?
+	{
+		if ( !VectorCompare( vec3_origin, NPCInfo->enemyLastSeenLocation ) )
+		{
+			//Fire on the last known position
+			vec3_t	muzzle, dir, angles;
+
+			CalcEntitySpot( NPC, SPOT_WEAPON, muzzle );
+			VectorSubtract( NPCInfo->enemyLastSeenLocation, muzzle, dir );
+
+			VectorNormalize( dir );
+
+			vectoangles( dir, angles );
+
+			NPCInfo->desiredYaw		= angles[YAW];
+			NPCInfo->desiredPitch	= angles[PITCH];
+
+			shoot = qtrue;
+			//faceEnemy = qfalse;
+		}
+		return;
+	}
+	else if ( level.time - NPCInfo->enemyLastSeenTime > 10000 )
+	{//next time we see him, we'll miss few times first
+		NPC->count = 0;
+	}
+}
+
+qboolean Sniper_EvaluateShot( int hit )
+{
+	if ( !NPC->enemy )
+	{
+		return qfalse;
+	}
+
+	gentity_t *hitEnt = &g_entities[hit];
+	if ( hit == NPC->enemy->s.number 
+		|| ( hitEnt && hitEnt->client && hitEnt->client->playerTeam == NPC->client->enemyTeam )
+		|| ( hitEnt && hitEnt->takedamage && ((hitEnt->svFlags&SVF_GLASS_BRUSH)||hitEnt->health < 40||NPC->s.weapon == WP_EMPLACED_GUN) )
+		|| ( hitEnt && (hitEnt->svFlags&SVF_GLASS_BRUSH)) )
+	{//can hit enemy or will hit glass, so shoot anyway
+		return qtrue;
+	}
+	return qfalse;
+}
+
+void Sniper_FaceEnemy( void )
+{
+	//FIXME: the ones behind kill holes are facing some arbitrary direction and not firing
+	//FIXME: If actually trying to hit enemy, don't fire unless enemy is at least in front of me?
+	//FIXME: need to give designers option to make them not miss first few shots
+	if ( NPC->enemy )
+	{
+		vec3_t	muzzle, target, angles, forward, right, up;
+		//Get the positions
+		AngleVectors( NPC->client->ps.viewangles, forward, right, up );
+		CalcMuzzlePoint( NPC, forward, right, up, muzzle, 0 );
+		//CalcEntitySpot( NPC, SPOT_WEAPON, muzzle );
+		CalcEntitySpot( NPC->enemy, SPOT_ORIGIN, target );
+
+		if ( enemyDist > 65536 && NPCInfo->stats.aim < 5 )//is 256 squared, was 16384 (128*128)
+		{
+			if ( NPC->count < (5-NPCInfo->stats.aim) )
+			{//miss a few times first
+				if ( shoot && TIMER_Done( NPC, "attackDelay" ) && level.time >= NPCInfo->shotTime )
+				{//ready to fire again
+					qboolean	aimError = qfalse;
+					qboolean	hit = qtrue;
+					int			tryMissCount = 0;
+					trace_t		trace;
+
+					GetAnglesForDirection( muzzle, target, angles );
+					AngleVectors( angles, forward, right, up );
+
+					while ( hit && tryMissCount < 10 )
+					{
+						tryMissCount++;
+						if ( !Q_irand( 0, 1 ) )
+						{
+							aimError = qtrue;
+							if ( !Q_irand( 0, 1 ) )
+							{
+								VectorMA( target, NPC->enemy->maxs[2]*Q_flrand(1.5, 4), right, target );
+							}
+							else
+							{
+								VectorMA( target, NPC->enemy->mins[2]*Q_flrand(1.5, 4), right, target );
+							}
+						}
+						if ( !aimError || !Q_irand( 0, 1 ) )
+						{
+							if ( !Q_irand( 0, 1 ) )
+							{
+								VectorMA( target, NPC->enemy->maxs[2]*Q_flrand(1.5, 4), up, target );
+							}
+							else
+							{
+								VectorMA( target, NPC->enemy->mins[2]*Q_flrand(1.5, 4), up, target );
+							}
+						}
+						gi.trace( &trace, muzzle, vec3_origin, vec3_origin, target, NPC->s.number, MASK_SHOT );
+						hit = Sniper_EvaluateShot( trace.entityNum );
+					}
+					NPC->count++;
+				}
+				else
+				{
+					if ( !enemyLOS )
+					{
+						NPC_UpdateAngles( qtrue, qtrue );
+						return;
+					}
+				}
+			}
+			else
+			{//based on distance, aim value, difficulty and enemy movement, miss
+				//FIXME: incorporate distance as a factor?
+				int missFactor = 8-(NPCInfo->stats.aim+g_spskill->integer) * 3;
+				if ( missFactor > ENEMY_POS_LAG_STEPS )
+				{
+					missFactor = ENEMY_POS_LAG_STEPS;
+				}
+				else if ( missFactor < 0 )
+				{//???
+					missFactor = 0 ;
+				}
+				VectorCopy( NPCInfo->enemyLaggedPos[missFactor], target );
+			}
+			GetAnglesForDirection( muzzle, target, angles );
+		}
+		else
+		{
+			target[2] += Q_flrand( 0, NPC->enemy->maxs[2] );
+			//CalcEntitySpot( NPC->enemy, SPOT_HEAD_LEAN, target );
+			GetAnglesForDirection( muzzle, target, angles );
+		}
+
+		NPCInfo->desiredYaw		= AngleNormalize360( angles[YAW] );
+		NPCInfo->desiredPitch	= AngleNormalize360( angles[PITCH] );
+	}
+	NPC_UpdateAngles( qtrue, qtrue );
+}
+
+void Sniper_UpdateEnemyPos( void )
+{
+	int index;
+	for ( int i = MAX_ENEMY_POS_LAG-ENEMY_POS_LAG_INTERVAL; i >= 0; i -= ENEMY_POS_LAG_INTERVAL )
+	{
+		index = i/ENEMY_POS_LAG_INTERVAL;
+		if ( !index )
+		{
+			CalcEntitySpot( NPC->enemy, SPOT_HEAD_LEAN, NPCInfo->enemyLaggedPos[index] );
+			NPCInfo->enemyLaggedPos[index][2] -= Q_flrand( 2, 16 );
+		}
+		else
+		{
+			VectorCopy( NPCInfo->enemyLaggedPos[index-1], NPCInfo->enemyLaggedPos[index] );
+		}
+	}
+}
+
+/*
+-------------------------
+NPC_BSSniper_Attack
+-------------------------
+*/
+
+void Sniper_StartHide( void )
+{
+	int duckTime = Q_irand( 2000, 5000 );
+	
+	TIMER_Set( NPC, "duck", duckTime );
+	if ( NPC->client->NPC_class == CLASS_SABOTEUR )
+	{
+		Saboteur_Cloak( NPC );
+	}
+	TIMER_Set( NPC, "watch", 500 );
+	TIMER_Set( NPC, "attackDelay", duckTime + Q_irand( 500, 2000 ) );
+}
+
+void NPC_BSSniper_Attack( void )
+{
+	//Don't do anything if we're hurt
+	if ( NPC->painDebounceTime > level.time )
+	{
+		NPC_UpdateAngles( qtrue, qtrue );
+		return;
+	}
+
+	//NPC_CheckEnemy( qtrue, qfalse );
+	//If we don't have an enemy, just idle
+	if ( NPC_CheckEnemyExt() == qfalse )//!NPC->enemy )//
+	{
+		NPC_BSSniper_Patrol();//FIXME: or patrol?
+		return;
+	}
+
+	if ( TIMER_Done( NPC, "flee" ) && NPC_CheckForDanger( NPC_CheckAlertEvents( qtrue, qtrue, -1, qfalse, AEL_DANGER ) ) )
+	{//going to run
+		NPC_UpdateAngles( qtrue, qtrue );
+		return;
+	}
+
+	if ( !NPC->enemy )
+	{//WTF?  somehow we lost our enemy?
+		NPC_BSSniper_Patrol();//FIXME: or patrol?
+		return;
+	}
+
+	enemyLOS = enemyCS = qfalse;
+	move = qtrue;
+	faceEnemy = qfalse;
+	shoot = qfalse;
+	enemyDist = DistanceSquared( NPC->currentOrigin, NPC->enemy->currentOrigin );
+	if ( enemyDist < 16384 )//128 squared
+	{//too close, so switch to primary fire
+		if ( NPC->client->ps.weapon == WP_DISRUPTOR
+			|| NPC->client->ps.weapon == WP_TUSKEN_RIFLE )
+		{//sniping... should be assumed
+			if ( NPCInfo->scriptFlags & SCF_ALT_FIRE )
+			{//use primary fire
+				trace_t	trace;
+				gi.trace ( &trace, NPC->enemy->currentOrigin, NPC->enemy->mins, NPC->enemy->maxs, NPC->currentOrigin, NPC->enemy->s.number, NPC->enemy->clipmask );
+				if ( !trace.allsolid && !trace.startsolid && (trace.fraction == 1.0 || trace.entityNum == NPC->s.number ) )
+				{//he can get right to me
+					NPCInfo->scriptFlags &= ~SCF_ALT_FIRE;
+					//reset fire-timing variables
+					NPC_ChangeWeapon( NPC->client->ps.weapon );
+					NPC_UpdateAngles( qtrue, qtrue );
+					return;
+				}
+			}
+			//FIXME: switch back if he gets far away again?
+		}
+	}
+	else if ( enemyDist > 65536 )//256 squared
+	{
+		if ( NPC->client->ps.weapon == WP_DISRUPTOR
+			|| NPC->client->ps.weapon == WP_TUSKEN_RIFLE )
+		{//sniping... should be assumed
+			if ( !(NPCInfo->scriptFlags&SCF_ALT_FIRE) )
+			{//use primary fire
+				NPCInfo->scriptFlags |= SCF_ALT_FIRE;
+				//reset fire-timing variables
+				NPC_ChangeWeapon( NPC->client->ps.weapon );
+				NPC_UpdateAngles( qtrue, qtrue );
+				return;
+			}
+		}
+	}
+
+	Sniper_UpdateEnemyPos();
+	//can we see our target?
+	if ( NPC_ClearLOS( NPC->enemy ) )//|| (NPCInfo->stats.aim >= 5 && gi.inPVS( NPC->client->renderInfo.eyePoint, NPC->enemy->currentOrigin )) )
+	{
+		NPCInfo->enemyLastSeenTime = level.time;
+		VectorCopy( NPC->enemy->currentOrigin, NPCInfo->enemyLastSeenLocation );
+		enemyLOS = qtrue;
+		float maxShootDist = NPC_MaxDistSquaredForWeapon();
+		if ( enemyDist < maxShootDist )
+		{
+			vec3_t fwd, right, up, muzzle, end;
+			trace_t	tr;
+			AngleVectors( NPC->client->ps.viewangles, fwd, right, up );
+			CalcMuzzlePoint( NPC, fwd, right, up, muzzle, 0 );
+			VectorMA( muzzle, 8192, fwd, end );
+			gi.trace ( &tr, muzzle, NULL, NULL, end, NPC->s.number, MASK_SHOT, G2_RETURNONHIT, 0 );
+
+			int hit = tr.entityNum;
+			//can we shoot our target?
+			if ( Sniper_EvaluateShot( hit ) )
+			{
+				enemyCS = qtrue;
+			}
+		}
+	}
+	/*
+	else if ( gi.inPVS( NPC->enemy->currentOrigin, NPC->currentOrigin ) )
+	{
+		NPCInfo->enemyLastSeenTime = level.time;
+		faceEnemy = qtrue;
+	}
+	*/
+
+	if ( enemyLOS )
+	{//FIXME: no need to face enemy if we're moving to some other goal and he's too far away to shoot?
+		faceEnemy = qtrue;
+	}
+
+	if ( !TIMER_Done( NPC, "taunting" ) )
+	{
+		move = qfalse;
+		shoot = qfalse;
+	}
+	else if ( enemyCS )
+	{
+		shoot = qtrue;
+	}
+	else if ( level.time - NPCInfo->enemyLastSeenTime > 3000 )
+	{//Hmm, have to get around this bastard... FIXME: this NPCInfo->enemyLastSeenTime builds up when ducked seems to make them want to run when they uncrouch
+		Sniper_ResolveBlockedShot();
+	}
+	else if ( NPC->client->ps.weapon == WP_TUSKEN_RIFLE && !Q_irand( 0, 100 ) )
+	{//start a taunt
+		NPC_Tusken_Taunt();
+		TIMER_Set( NPC, "duck", -1 );
+		move = qfalse;
+	}
+
+	//Check for movement to take care of
+	Sniper_CheckMoveState();
+
+	//See if we should override shooting decision with any special considerations
+	Sniper_CheckFireState();
+
+	if ( move )
+	{//move toward goal
+		if ( NPCInfo->goalEntity )//&& ( NPCInfo->goalEntity != NPC->enemy || enemyDist > 10000 ) )//100 squared
+		{
+			move = Sniper_Move();
+		}
+		else
+		{
+			move = qfalse;
+		}
+	}
+
+	if ( !move )
+	{
+		if ( !TIMER_Done( NPC, "duck" ) )
+		{
+			if ( TIMER_Done( NPC, "watch" ) )
+			{//not while watching
+				ucmd.upmove = -127;
+				if ( NPC->client->NPC_class == CLASS_SABOTEUR )
+				{
+					Saboteur_Cloak( NPC );
+				}
+			}
+		}
+		//FIXME: what about leaning?
+		//FIXME: also, when stop ducking, start looking, if enemy can see me, chance of ducking back down again
+	}
+	else
+	{//stop ducking!
+		TIMER_Set( NPC, "duck", -1 );
+		if ( NPC->client->NPC_class == CLASS_SABOTEUR )
+		{
+			Saboteur_Decloak( NPC );
+		}
+	}
+
+	if ( TIMER_Done( NPC, "duck" ) 
+		&& TIMER_Done( NPC, "watch" ) 
+		&& (TIMER_Get( NPC, "attackDelay" )-level.time) > 1000 
+		&& NPC->attackDebounceTime < level.time )
+	{
+		if ( enemyLOS && (NPCInfo->scriptFlags&SCF_ALT_FIRE) )
+		{
+			if ( NPC->fly_sound_debounce_time < level.time )
+			{
+				NPC->fly_sound_debounce_time = level.time + 2000;
+			}
+		}
+	}
+
+	if ( !faceEnemy )
+	{//we want to face in the dir we're running
+		if ( move )
+		{//don't run away and shoot
+			NPCInfo->desiredYaw = NPCInfo->lastPathAngles[YAW];
+			NPCInfo->desiredPitch = 0;
+			shoot = qfalse;
+		}
+		NPC_UpdateAngles( qtrue, qtrue );
+	}
+	else// if ( faceEnemy )
+	{//face the enemy
+		Sniper_FaceEnemy();
+	}
+
+	if ( NPCInfo->scriptFlags&SCF_DONT_FIRE )
+	{
+		shoot = qfalse;
+	}
+
+	//FIXME: don't shoot right away!
+	if ( shoot )
+	{//try to shoot if it's time
+		if ( TIMER_Done( NPC, "attackDelay" ) )
+		{
+			WeaponThink( qtrue );
+			if ( ucmd.buttons&(BUTTON_ATTACK|BUTTON_ALT_ATTACK) )
+			{
+				G_SoundOnEnt( NPC, CHAN_WEAPON, "sound/null.wav" );
+			}
+
+			//took a shot, now hide
+			if ( !(NPC->spawnflags&SPF_NO_HIDE) && !Q_irand( 0, 1 ) )
+			{
+				//FIXME: do this if in combat point and combat point has duck-type cover... also handle lean-type cover
+				Sniper_StartHide();
+			}
+			else
+			{
+				TIMER_Set( NPC, "attackDelay", NPCInfo->shotTime-level.time );
+			}
+		}
+	}
+}
+
+void NPC_BSSniper_Default( void )
+{
+	if( !NPC->enemy )
+	{//don't have an enemy, look for one
+		NPC_BSSniper_Patrol();
+	}
+	else//if ( NPC->enemy )
+	{//have an enemy
+		NPC_BSSniper_Attack();
+	}
+}
diff --git a/code/game/AI_Stormtrooper.cpp b/code/game/AI_Stormtrooper.cpp
new file mode 100644
index 0000000..149c8c4
--- /dev/null
+++ b/code/game/AI_Stormtrooper.cpp
@@ -0,0 +1,2722 @@
+// leave this line at the top of all AI_xxxx.cpp files for PCH reasons...
+#include "g_headers.h"
+
+
+#include "b_local.h"
+#include "g_nav.h"
+#include "anims.h"
+#include "g_navigator.h"
+
+extern void CG_DrawAlert( vec3_t origin, float rating );
+extern void G_AddVoiceEvent( gentity_t *self, int event, int speakDebounceTime );
+extern void AI_GroupUpdateSquadstates( AIGroupInfo_t *group, gentity_t *member, int newSquadState );
+extern qboolean AI_GroupContainsEntNum( AIGroupInfo_t *group, int entNum );
+extern void AI_GroupUpdateEnemyLastSeen( AIGroupInfo_t *group, vec3_t spot );
+extern void AI_GroupUpdateClearShotTime( AIGroupInfo_t *group );
+extern void NPC_TempLookTarget( gentity_t *self, int lookEntNum, int minLookTime, int maxLookTime );
+extern qboolean G_ExpandPointToBBox( vec3_t point, const vec3_t mins, const vec3_t maxs, int ignore, int clipmask );
+extern void ChangeWeapon( gentity_t *ent, int newWeapon );
+extern void NPC_CheckGetNewWeapon( void );
+extern qboolean Q3_TaskIDPending( gentity_t *ent, taskID_t taskType );
+extern int GetTime ( int lastTime );
+extern void NPC_AimAdjust( int change );
+extern qboolean FlyingCreature( gentity_t *ent );
+extern void NPC_EvasionSaber( void );
+extern qboolean RT_Flying( gentity_t *self );
+
+//extern	CNavigator	navigator;
+extern	cvar_t		*d_asynchronousGroupAI;
+
+#define	MAX_VIEW_DIST		1024
+#define MAX_VIEW_SPEED		250
+#define	MAX_LIGHT_INTENSITY 255
+#define	MIN_LIGHT_THRESHOLD	0.1
+#define	ST_MIN_LIGHT_THRESHOLD 30
+#define	ST_MAX_LIGHT_THRESHOLD 180
+#define	DISTANCE_THRESHOLD	0.075f
+#define	MIN_TURN_AROUND_DIST_SQ	(10000)	//(100 squared) don't stop running backwards if your goal is less than 100 away
+#define SABER_AVOID_DIST	128.0f//256.0f
+#define SABER_AVOID_DIST_SQ (SABER_AVOID_DIST*SABER_AVOID_DIST)
+
+#define	DISTANCE_SCALE		0.35f	//These first three get your base detection rating, ideally add up to 1
+#define	FOV_SCALE			0.40f	//
+#define	LIGHT_SCALE			0.25f	//
+
+#define	SPEED_SCALE			0.25f	//These next two are bonuses
+#define	TURNING_SCALE		0.25f	//
+
+#define	REALIZE_THRESHOLD	0.6f
+#define CAUTIOUS_THRESHOLD	( REALIZE_THRESHOLD * 0.75 )
+
+qboolean NPC_CheckPlayerTeamStealth( void );
+
+static qboolean enemyLOS;
+static qboolean enemyCS;
+static qboolean enemyInFOV;
+static qboolean hitAlly;
+static qboolean faceEnemy;
+static qboolean move;
+static qboolean shoot;
+static float	enemyDist;
+static vec3_t	impactPos;
+
+int groupSpeechDebounceTime[TEAM_NUM_TEAMS];//used to stop several group AI from speaking all at once
+
+void NPC_Saboteur_Precache( void )
+{
+	G_SoundIndex( "sound/chars/shadowtrooper/cloak.wav" );
+	G_SoundIndex( "sound/chars/shadowtrooper/decloak.wav" );
+}
+
+void Saboteur_Decloak( gentity_t *self, int uncloakTime )
+{
+	if ( self && self->client )
+	{
+		if ( self->client->ps.powerups[PW_CLOAKED] && TIMER_Done(self, "decloakwait"))
+		{//Uncloak
+			self->client->ps.powerups[PW_CLOAKED] = 0;
+			self->client->ps.powerups[PW_UNCLOAKING] = level.time + 2000;
+			//FIXME: temp sound
+			G_SoundOnEnt( self, CHAN_ITEM, "sound/chars/shadowtrooper/decloak.wav" );
+			TIMER_Set( self, "nocloak", uncloakTime );
+
+			// Can't Recloak
+			//self->NPC->aiFlags	&= ~NPCAI_SHIELDS;
+		}
+	}
+}
+
+void Saboteur_Cloak( gentity_t *self )
+{
+	if ( self && self->client && self->NPC )
+	{//FIXME: need to have this timer set once first?
+		if ( TIMER_Done( self, "nocloak" ) )
+		{//not sitting around waiting to cloak again
+			if ( !(self->NPC->aiFlags&NPCAI_SHIELDS) )
+			{//not allowed to cloak, actually
+				Saboteur_Decloak( self );
+			}
+			else if ( !self->client->ps.powerups[PW_CLOAKED] )
+			{//cloak
+				self->client->ps.powerups[PW_CLOAKED] = Q3_INFINITE;
+				self->client->ps.powerups[PW_UNCLOAKING] = level.time + 2000;
+				//FIXME: debounce attacks?
+				//FIXME: temp sound
+				G_SoundOnEnt( self, CHAN_ITEM, "sound/chars/shadowtrooper/cloak.wav" );
+			}
+		}
+	}
+}
+
+
+
+//Local state enums
+enum
+{
+	LSTATE_NONE = 0,
+	LSTATE_UNDERFIRE,
+	LSTATE_INVESTIGATE,
+};
+
+void ST_AggressionAdjust( gentity_t *self, int change )
+{
+	int	upper_threshold, lower_threshold;
+
+	self->NPC->stats.aggression += change;
+	
+	//FIXME: base this on initial NPC stats
+	if ( self->client->playerTeam == TEAM_PLAYER )
+	{//good guys are less aggressive
+		upper_threshold = 7;
+		lower_threshold = 1;
+	}
+	else
+	{//bad guys are more aggressive
+		upper_threshold = 10;
+		lower_threshold = 3;
+	}
+
+	if ( self->NPC->stats.aggression > upper_threshold )
+	{
+		self->NPC->stats.aggression = upper_threshold;
+	}
+	else if ( self->NPC->stats.aggression < lower_threshold )
+	{
+		self->NPC->stats.aggression = lower_threshold;
+	}
+}
+
+void ST_ClearTimers( gentity_t *ent )
+{
+	TIMER_Set( ent, "chatter", 0 );
+	TIMER_Set( ent, "duck", 0 );
+	TIMER_Set( ent, "stand", 0 );
+	TIMER_Set( ent, "shuffleTime", 0 );
+	TIMER_Set( ent, "sleepTime", 0 );
+	TIMER_Set( ent, "enemyLastVisible", 0 );
+	TIMER_Set( ent, "roamTime", 0 );
+	TIMER_Set( ent, "hideTime", 0 );
+	TIMER_Set( ent, "attackDelay", 0 );	//FIXME: Slant for difficulty levels
+	TIMER_Set( ent, "stick", 0 );
+	TIMER_Set( ent, "scoutTime", 0 );
+	TIMER_Set( ent, "flee", 0 );
+	TIMER_Set( ent, "interrogating", 0 );
+	TIMER_Set( ent, "verifyCP", 0 );
+	TIMER_Set( ent, "strafeRight", 0 );
+	TIMER_Set( ent, "strafeLeft", 0 );
+}
+
+enum
+{
+	SPEECH_CHASE,
+	SPEECH_CONFUSED,
+	SPEECH_COVER,
+	SPEECH_DETECTED,
+	SPEECH_GIVEUP,
+	SPEECH_LOOK,
+	SPEECH_LOST,
+	SPEECH_OUTFLANK,
+	SPEECH_ESCAPING,
+	SPEECH_SIGHT,
+	SPEECH_SOUND,
+	SPEECH_SUSPICIOUS,
+	SPEECH_YELL,
+	SPEECH_PUSHED
+};
+
+static void ST_Speech( gentity_t *self, int speechType, float failChance )
+{
+	if ( random() < failChance )
+	{
+		return;
+	}
+
+	if ( failChance >= 0 )
+	{//a negative failChance makes it always talk
+		if ( self->NPC->group )
+		{//group AI speech debounce timer
+			if ( self->NPC->group->speechDebounceTime > level.time )
+			{
+				return;
+			}
+			/*
+			else if ( !self->NPC->group->enemy )
+			{
+				if ( groupSpeechDebounceTime[self->client->playerTeam] > level.time )
+				{
+					return;
+				}
+			}
+			*/
+		}
+		else if ( !TIMER_Done( self, "chatter" ) )
+		{//personal timer
+			return;
+		}
+		else if ( groupSpeechDebounceTime[self->client->playerTeam] > level.time )
+		{//for those not in group AI
+			//FIXME: let certain speech types interrupt others?  Let closer NPCs interrupt farther away ones?
+			return;
+		}
+	}
+
+	if ( self->NPC->group )
+	{//So they don't all speak at once...
+		//FIXME: if they're not yet mad, they have no group, so distracting a group of them makes them all speak!
+		self->NPC->group->speechDebounceTime = level.time + Q_irand( 2000, 4000 );
+	}
+	else
+	{
+		TIMER_Set( self, "chatter", Q_irand( 2000, 4000 ) );
+	}
+	groupSpeechDebounceTime[self->client->playerTeam] = level.time + Q_irand( 2000, 4000 );
+
+	if ( self->NPC->blockedSpeechDebounceTime > level.time )
+	{
+		return;
+	}
+
+	switch( speechType )
+	{
+	case SPEECH_CHASE:
+		G_AddVoiceEvent( self, Q_irand(EV_CHASE1, EV_CHASE3), 2000 );
+		break;
+	case SPEECH_CONFUSED:
+		G_AddVoiceEvent( self, Q_irand(EV_CONFUSE1, EV_CONFUSE3), 2000 );
+		break;
+	case SPEECH_COVER:
+		G_AddVoiceEvent( self, Q_irand(EV_COVER1, EV_COVER5), 2000 );
+		break;
+	case SPEECH_DETECTED:
+		G_AddVoiceEvent( self, Q_irand(EV_DETECTED1, EV_DETECTED5), 2000 );
+		break;
+	case SPEECH_GIVEUP:
+		G_AddVoiceEvent( self, Q_irand(EV_GIVEUP1, EV_GIVEUP4), 2000 );
+		break;
+	case SPEECH_LOOK:
+		G_AddVoiceEvent( self, Q_irand(EV_LOOK1, EV_LOOK2), 2000 );
+		break;
+	case SPEECH_LOST:
+		G_AddVoiceEvent( self, EV_LOST1, 2000 );
+		break;
+	case SPEECH_OUTFLANK:
+		G_AddVoiceEvent( self, Q_irand(EV_OUTFLANK1, EV_OUTFLANK2), 2000 );
+		break;
+	case SPEECH_ESCAPING:
+		G_AddVoiceEvent( self, Q_irand(EV_ESCAPING1, EV_ESCAPING3), 2000 );
+		break;
+	case SPEECH_SIGHT:
+		G_AddVoiceEvent( self, Q_irand(EV_SIGHT1, EV_SIGHT3), 2000 );
+		break;
+	case SPEECH_SOUND:
+		G_AddVoiceEvent( self, Q_irand(EV_SOUND1, EV_SOUND3), 2000 );
+		break;
+	case SPEECH_SUSPICIOUS:
+		G_AddVoiceEvent( self, Q_irand(EV_SUSPICIOUS1, EV_SUSPICIOUS5), 2000 );
+		break;
+	case SPEECH_YELL:
+		G_AddVoiceEvent( self, Q_irand( EV_ANGER1, EV_ANGER3 ), 2000 );
+		break;
+	case SPEECH_PUSHED:
+		G_AddVoiceEvent( self, Q_irand( EV_PUSHED1, EV_PUSHED3 ), 2000 );
+		break;
+	default:
+		break;
+	}
+
+	self->NPC->blockedSpeechDebounceTime = level.time + 2000;
+}
+
+void ST_MarkToCover( gentity_t *self )
+{
+	if ( !self || !self->NPC )
+	{
+		return;
+	}
+	self->NPC->localState = LSTATE_UNDERFIRE;
+	TIMER_Set( self, "attackDelay", Q_irand( 500, 2500 ) );
+	ST_AggressionAdjust( self, -3 );
+	if ( self->NPC->group && self->NPC->group->numGroup > 1 )
+	{
+		ST_Speech( self, SPEECH_COVER, 0 );//FIXME: flee sound?
+	}
+}
+
+void ST_StartFlee( gentity_t *self, gentity_t *enemy, vec3_t dangerPoint, int dangerLevel, int minTime, int maxTime )
+{
+	if ( !self || !self->NPC )
+	{
+		return;
+	}
+	G_StartFlee( self, enemy, dangerPoint, dangerLevel, minTime, maxTime );
+	if ( self->NPC->group && self->NPC->group->numGroup > 1 )
+	{
+		ST_Speech( self, SPEECH_COVER, 0 );//FIXME: flee sound?
+	}
+}
+/*
+-------------------------
+NPC_ST_Pain
+-------------------------
+*/
+
+void NPC_ST_Pain( gentity_t *self, gentity_t *inflictor, gentity_t *other, const vec3_t point, int damage, int mod,int hitLoc ) 
+{
+	self->NPC->localState = LSTATE_UNDERFIRE;
+
+	TIMER_Set( self, "duck", -1 );
+	TIMER_Set( self, "hideTime", -1 );
+	TIMER_Set( self, "stand", 2000 );
+
+	NPC_Pain( self, inflictor, other, point, damage, mod, hitLoc );
+
+	if ( !damage && self->health > 0 )
+	{//FIXME: better way to know I was pushed
+		G_AddVoiceEvent( self, Q_irand(EV_PUSHED1, EV_PUSHED3), 2000 );
+	}
+}
+
+/*
+-------------------------
+ST_HoldPosition
+-------------------------
+*/
+
+static void ST_HoldPosition( void )
+{
+	if ( NPCInfo->squadState == SQUAD_RETREAT )
+	{
+		TIMER_Set( NPC, "flee", -level.time );
+	}
+	TIMER_Set( NPC, "verifyCP", Q_irand( 1000, 3000 ) );//don't look for another one for a few seconds
+	NPC_FreeCombatPoint( NPCInfo->combatPoint, qtrue );
+	//NPCInfo->combatPoint = -1;//???
+	if ( !Q3_TaskIDPending( NPC, TID_MOVE_NAV ) )
+	{//don't have a script waiting for me to get to my point, okay to stop trying and stand
+		AI_GroupUpdateSquadstates( NPCInfo->group, NPC, SQUAD_STAND_AND_SHOOT );
+		NPCInfo->goalEntity = NULL;
+	}
+
+}
+
+void NPC_ST_SayMovementSpeech( void )
+{
+	if ( !NPCInfo->movementSpeech )
+	{
+		return;
+	}
+	if ( NPCInfo->group && 
+		NPCInfo->group->commander && 
+		NPCInfo->group->commander->client && 
+		NPCInfo->group->commander->client->NPC_class == CLASS_IMPERIAL && 
+		!Q_irand( 0, 3 ) )
+	{//imperial (commander) gives the order
+		ST_Speech( NPCInfo->group->commander, NPCInfo->movementSpeech, NPCInfo->movementSpeechChance );
+	}
+	else
+	{//really don't want to say this unless we can actually get there...
+		ST_Speech( NPC, NPCInfo->movementSpeech, NPCInfo->movementSpeechChance );
+	}
+
+	NPCInfo->movementSpeech = 0;
+	NPCInfo->movementSpeechChance = 0.0f;
+}
+
+void NPC_ST_StoreMovementSpeech( int speech, float chance )
+{
+	NPCInfo->movementSpeech = speech;
+	NPCInfo->movementSpeechChance = chance;
+}
+/*
+-------------------------
+ST_Move
+-------------------------
+*/
+void ST_TransferMoveGoal( gentity_t *self, gentity_t *other );
+static qboolean ST_Move( void )
+{
+	NPCInfo->combatMove = qtrue;//always move straight toward our goal
+
+	qboolean	moved = NPC_MoveToGoal( qtrue );
+	if (moved==qfalse)
+	{
+		ST_HoldPosition();
+	}
+
+	NPC_ST_SayMovementSpeech();
+
+	return moved;
+}
+
+
+/*
+-------------------------
+NPC_ST_SleepShuffle
+-------------------------
+*/
+
+static void NPC_ST_SleepShuffle( void )
+{
+	//Play an awake script if we have one
+	if ( G_ActivateBehavior( NPC, BSET_AWAKE) )
+	{
+		return;
+	}
+
+	//Automate some movement and noise
+	if ( TIMER_Done( NPC, "shuffleTime" ) )
+	{
+		
+		//TODO: Play sleeping shuffle animation
+
+		//int	soundIndex = Q_irand( 0, 1 );
+
+		/*
+		switch ( soundIndex )
+		{
+		case 0:
+			G_Sound( NPC, G_SoundIndex("sound/chars/imperialsleeper1/scav4/hunh.mp3") );
+			break;
+
+		case 1:
+			G_Sound( NPC, G_SoundIndex("sound/chars/imperialsleeper3/scav4/tryingtosleep.wav") );
+			break;
+		}
+		*/
+
+		TIMER_Set( NPC, "shuffleTime", 4000 );
+		TIMER_Set( NPC, "sleepTime", 2000 );
+		return;
+	}
+
+	//They made another noise while we were stirring, see if we can see them
+	if ( TIMER_Done( NPC, "sleepTime" ) )
+	{
+		NPC_CheckPlayerTeamStealth();
+		TIMER_Set( NPC, "sleepTime", 2000 );
+	}
+}
+
+/*
+-------------------------
+NPC_ST_Sleep
+-------------------------
+*/
+
+void NPC_BSST_Sleep( void )
+{
+	int alertEvent = NPC_CheckAlertEvents( qfalse, qtrue );//only check sounds since we're alseep!
+
+	//There is an event we heard
+	if ( alertEvent >= 0 )
+	{
+		//See if it was enough to wake us up
+		if ( level.alertEvents[alertEvent].level == AEL_DISCOVERED && (NPCInfo->scriptFlags&SCF_LOOK_FOR_ENEMIES) )
+		{
+			if ( &g_entities[0] && g_entities[0].health > 0 )
+			{
+				G_SetEnemy( NPC, &g_entities[0] );
+				return;
+			}
+		}
+
+		//Otherwise just stir a bit
+		NPC_ST_SleepShuffle();
+		return;
+	}
+}
+
+/*
+-------------------------
+NPC_CheckEnemyStealth
+-------------------------
+*/
+
+qboolean NPC_CheckEnemyStealth( gentity_t *target )
+{
+	float		target_dist, minDist = 40;//any closer than 40 and we definitely notice
+
+	//In case we aquired one some other way
+	if ( NPC->enemy != NULL )
+		return qtrue;
+
+	//Ignore notarget
+	if ( target->flags & FL_NOTARGET )
+		return qfalse;
+
+	if ( target->health <= 0 )
+	{
+		return qfalse;
+	}
+
+	if ( target->client->ps.weapon == WP_SABER && target->client->ps.SaberActive() && !target->client->ps.saberInFlight )
+	{//if target has saber in hand and activated, we wake up even sooner even if not facing him
+		minDist = 100;
+	}
+
+	target_dist = DistanceSquared( target->currentOrigin, NPC->currentOrigin );
+	//If the target is this close, then wake up regardless
+	if ( !(target->client->ps.pm_flags&PMF_DUCKED)//not ducking
+		&& (NPCInfo->scriptFlags&SCF_LOOK_FOR_ENEMIES)//looking for enemies
+		&& target_dist < (minDist*minDist) )//closer than minDist
+	{
+		G_SetEnemy( NPC, target );
+		NPCInfo->enemyLastSeenTime = level.time;
+		TIMER_Set( NPC, "attackDelay", Q_irand( 500, 2500 ) );
+		return qtrue;
+	}
+
+	float	maxViewDist			= MAX_VIEW_DIST;
+
+//	if ( NPCInfo->stats.visrange > maxViewDist )
+	{//FIXME: should we always just set maxViewDist to this?
+		maxViewDist = NPCInfo->stats.visrange;
+	}
+
+	if ( target_dist > (maxViewDist*maxViewDist) )
+	{//out of possible visRange
+		return qfalse;
+	}
+
+	//Check FOV first
+	if ( InFOV( target, NPC, NPCInfo->stats.hfov, NPCInfo->stats.vfov ) == qfalse )
+		return qfalse;
+
+	qboolean clearLOS = ( target->client->ps.leanofs ) ? NPC_ClearLOS( target->client->renderInfo.eyePoint ) : NPC_ClearLOS( target );
+
+	//Now check for clear line of vision
+	if ( clearLOS )
+	{
+		if ( target->client->NPC_class == CLASS_ATST )
+		{//can't miss 'em!
+			G_SetEnemy( NPC, target );
+			TIMER_Set( NPC, "attackDelay", Q_irand( 500, 2500 ) );
+			return qtrue;
+		}
+		vec3_t	targ_org			= {target->currentOrigin[0],target->currentOrigin[1],target->currentOrigin[2]+target->maxs[2]-4};
+		float	hAngle_perc			= NPC_GetHFOVPercentage( targ_org, NPC->client->renderInfo.eyePoint, NPC->client->renderInfo.eyeAngles, NPCInfo->stats.hfov );
+		float	vAngle_perc			= NPC_GetVFOVPercentage( targ_org, NPC->client->renderInfo.eyePoint, NPC->client->renderInfo.eyeAngles, NPCInfo->stats.vfov );
+
+		//Scale them vertically some, and horizontally pretty harshly
+		vAngle_perc *= vAngle_perc;//( vAngle_perc * vAngle_perc );
+		hAngle_perc *= ( hAngle_perc * hAngle_perc );
+
+		//Cap our vertical vision severely
+		//if ( vAngle_perc <= 0.3f ) // was 0.5f
+		//	return qfalse;
+
+		//Assess the player's current status
+		target_dist			= Distance( target->currentOrigin, NPC->currentOrigin );
+
+		float	target_speed		= VectorLength( target->client->ps.velocity );
+		int		target_crouching	= ( target->client->usercmd.upmove < 0 );
+		float	dist_rating			= ( target_dist / maxViewDist );
+		float	speed_rating		= ( target_speed / MAX_VIEW_SPEED );
+		float	turning_rating		= AngleDelta( target->client->ps.viewangles[PITCH], target->lastAngles[PITCH] )/180.0f + AngleDelta( target->client->ps.viewangles[YAW], target->lastAngles[YAW] )/180.0f;
+		float	light_level			= ( target->lightLevel / MAX_LIGHT_INTENSITY );
+		float	FOV_perc			= 1.0f - ( hAngle_perc + vAngle_perc ) * 0.5f;	//FIXME: Dunno about the average...
+		float	vis_rating			= 0.0f;
+		
+		//Too dark
+		if ( light_level < MIN_LIGHT_THRESHOLD )
+			return qfalse;
+
+		//Too close?
+		if ( dist_rating < DISTANCE_THRESHOLD )
+		{
+			G_SetEnemy( NPC, target );
+			TIMER_Set( NPC, "attackDelay", Q_irand( 500, 2500 ) );
+			return qtrue;
+		}
+
+		//Out of range
+		if ( dist_rating > 1.0f )
+			return qfalse;
+		
+		//Cap our speed checks
+		if ( speed_rating > 1.0f )
+			speed_rating = 1.0f;
+		
+
+		//Calculate the distance, fov and light influences
+		//...Visibilty linearly wanes over distance
+		float dist_influence	= DISTANCE_SCALE * ( ( 1.0f - dist_rating ) );
+		//...As the percentage out of the FOV increases, straight perception suffers on an exponential scale
+		float fov_influence		= FOV_SCALE * ( 1.0f - FOV_perc );
+		//...Lack of light hides, abundance of light exposes
+		float light_influence	= ( light_level - 0.5f ) * LIGHT_SCALE;
+		
+		//Calculate our base rating
+		float target_rating		= dist_influence + fov_influence + light_influence;
+		
+		//Now award any final bonuses to this number
+		int contents = gi.pointcontents( targ_org, target->s.number );
+		if ( contents&CONTENTS_WATER )
+		{
+			int myContents = gi.pointcontents( NPC->client->renderInfo.eyePoint, NPC->s.number );
+			if ( !(myContents&CONTENTS_WATER) )
+			{//I'm not in water
+				if ( NPC->client->NPC_class == CLASS_SWAMPTROOPER )
+				{//these guys can see in in/through water pretty well
+					vis_rating = 0.10f;//10% bonus
+				}
+				else
+				{
+					vis_rating = 0.35f;//35% bonus
+				}
+			}
+			else
+			{//else, if we're both in water
+				if ( NPC->client->NPC_class == CLASS_SWAMPTROOPER )
+				{//I can see him just fine
+				}
+				else
+				{
+					vis_rating = 0.15f;//15% bonus
+				}
+			}
+		}
+		else 
+		{//not in water
+			if ( contents&CONTENTS_FOG )
+			{
+				vis_rating = 0.15f;//15% bonus
+			}
+		}
+
+		target_rating *= (1.0f - vis_rating);
+
+		//...Motion draws the eye quickly
+		target_rating += speed_rating * SPEED_SCALE;
+		target_rating += turning_rating * TURNING_SCALE;
+		//FIXME: check to see if they're animating, too?  But can we do something as simple as frame != oldframe?
+
+		//...Smaller targets are harder to indentify
+		if ( target_crouching )
+		{
+			target_rating *= 0.9f;	//10% bonus
+		}	
+	
+		//If he's violated the threshold, then realize him
+		//float difficulty_scale = 1.0f + (2.0f-g_spskill->value);//if playing on easy, 20% harder to be seen...?
+		float realize, cautious;
+		if ( NPC->client->NPC_class == CLASS_SWAMPTROOPER )
+		{//swamptroopers can see much better
+			realize = (float)CAUTIOUS_THRESHOLD/**difficulty_scale*/;
+			cautious = (float)CAUTIOUS_THRESHOLD * 0.75f/**difficulty_scale*/;
+		}
+		else
+		{
+			realize = (float)REALIZE_THRESHOLD/**difficulty_scale*/;
+			cautious = (float)CAUTIOUS_THRESHOLD * 0.75f/**difficulty_scale*/;
+		}
+
+		if ( target_rating > realize && (NPCInfo->scriptFlags&SCF_LOOK_FOR_ENEMIES) )
+		{
+			G_SetEnemy( NPC, target );
+			NPCInfo->enemyLastSeenTime = level.time;
+			TIMER_Set( NPC, "attackDelay", Q_irand( 500, 2500 ) );
+			return qtrue;
+		}
+
+		//If he's above the caution threshold, then realize him in a few seconds unless he moves to cover
+		if ( target_rating > cautious && !(NPCInfo->scriptFlags&SCF_IGNORE_ALERTS) )
+		{//FIXME: ambushing guys should never talk
+			if ( TIMER_Done( NPC, "enemyLastVisible" ) )
+			{//If we haven't already, start the counter
+				int	lookTime = Q_irand( 4500, 8500 );
+				//NPCInfo->timeEnemyLastVisible = level.time + 2000;
+				TIMER_Set( NPC, "enemyLastVisible", lookTime );
+				//TODO: Play a sound along the lines of, "Huh?  What was that?"
+				ST_Speech( NPC, SPEECH_SIGHT, 0 );
+				NPC_TempLookTarget( NPC, target->s.number, lookTime, lookTime );
+				//FIXME: set desired yaw and pitch towards this guy?
+			}
+			else if ( TIMER_Get( NPC, "enemyLastVisible" ) <= level.time + 500 && (NPCInfo->scriptFlags&SCF_LOOK_FOR_ENEMIES) )	//FIXME: Is this reliable?
+			{
+				if ( NPCInfo->rank < RANK_LT && !Q_irand( 0, 2 ) )
+				{
+					int	interrogateTime = Q_irand( 2000, 4000 );
+					ST_Speech( NPC, SPEECH_SUSPICIOUS, 0 );
+					TIMER_Set( NPC, "interrogating", interrogateTime );
+					G_SetEnemy( NPC, target );
+					NPCInfo->enemyLastSeenTime = level.time;
+					TIMER_Set( NPC, "attackDelay", interrogateTime );
+					TIMER_Set( NPC, "stand", interrogateTime );
+				}
+				else
+				{
+					G_SetEnemy( NPC, target );
+					NPCInfo->enemyLastSeenTime = level.time;
+					//FIXME: ambush guys (like those popping out of water) shouldn't delay...
+					TIMER_Set( NPC, "attackDelay", Q_irand( 500, 2500 ) );
+					TIMER_Set( NPC, "stand", Q_irand( 500, 2500 ) );
+				}
+				return qtrue;
+			}
+
+			return qfalse;
+		}
+	}
+
+	return qfalse;
+}
+
+qboolean NPC_CheckPlayerTeamStealth( void )
+{
+	/*
+	//NOTENOTE: For now, all stealh checks go against the player, since
+	//			he is the main focus.  Squad members and rivals do not
+	//			fall into this category and will be ignored.
+
+	NPC_CheckEnemyStealth( &g_entities[0] );	//Change this pointer to assess other entities
+	*/
+	gentity_t *enemy;
+	for ( int i = 0; i < ENTITYNUM_WORLD; i++ )
+	{
+		if(!PInUse(i))
+			continue;
+		enemy = &g_entities[i];
+		if ( enemy 
+			&& enemy->client 
+			&& NPC_ValidEnemy( enemy ) )
+		{
+			if ( NPC_CheckEnemyStealth( enemy ) )	//Change this pointer to assess other entities
+			{
+				return qtrue;
+			}
+		}
+	}
+	return qfalse;
+}
+
+qboolean NPC_CheckEnemiesInSpotlight( void )
+{
+	gentity_t	*entityList[MAX_GENTITIES];
+	gentity_t	*enemy, *suspect = NULL;
+	int			i, numListedEntities;
+	vec3_t		mins, maxs;
+
+	for ( i = 0 ; i < 3 ; i++ ) 
+	{
+		mins[i] = NPC->client->renderInfo.eyePoint[i] - NPC->speed;
+		maxs[i] = NPC->client->renderInfo.eyePoint[i] + NPC->speed;
+	}
+
+	numListedEntities = gi.EntitiesInBox( mins, maxs, entityList, MAX_GENTITIES );
+	
+	for ( i = 0; i < numListedEntities; i++ ) 
+	{
+		if(!PInUse(i))
+			continue;
+
+		enemy = entityList[i];
+
+		if ( enemy && enemy->client && NPC_ValidEnemy( enemy ) && enemy->client->playerTeam == NPC->client->enemyTeam )
+		{//valid ent & client, valid enemy, on the target team
+			//check to see if they're in my FOV
+			if ( InFOV( enemy->currentOrigin, NPC->client->renderInfo.eyePoint, NPC->client->renderInfo.eyeAngles, NPCInfo->stats.hfov, NPCInfo->stats.vfov ) )
+			{//in my cone
+				//check to see that they're close enough
+				if ( DistanceSquared( NPC->client->renderInfo.eyePoint, enemy->currentOrigin )-256/*fudge factor: 16 squared*/ <= NPC->speed*NPC->speed )
+				{//within range
+					//check to see if we have a clear trace to them
+					if ( G_ClearLOS( NPC, enemy ) )
+					{//clear LOS
+						//make sure their light level is at least my beam's brightness
+						//FIXME: HOW?
+						//enemy->lightLevel / MAX_LIGHT_INTENSITY
+						
+						//good enough, take him!
+						//FIXME: pick closest one?
+						//FIXME: have the graduated noticing like other NPCs? (based on distance, FOV dot, etc...)
+						G_SetEnemy( NPC, enemy );
+						TIMER_Set( NPC, "attackDelay", Q_irand( 500, 2500 ) );
+						return qtrue;
+					}
+				}
+			}
+			if ( InFOV( enemy->currentOrigin, NPC->client->renderInfo.eyePoint, NPC->client->renderInfo.eyeAngles, 90, NPCInfo->stats.vfov*3 ) )
+			{//one to look at if we don't get an enemy
+				if ( G_ClearLOS( NPC, enemy ) )
+				{//clear LOS
+					if ( suspect == NULL || DistanceSquared( NPC->client->renderInfo.eyePoint, enemy->currentOrigin ) < DistanceSquared( NPC->client->renderInfo.eyePoint, suspect->currentOrigin ) )
+					{//remember him
+						suspect = enemy;
+					}
+				}
+			}
+		}
+	}
+	if ( suspect && Q_flrand( 0, NPCInfo->stats.visrange*NPCInfo->stats.visrange ) > DistanceSquared( NPC->client->renderInfo.eyePoint, suspect->currentOrigin ) )
+	{//hey!  who's that?
+		if ( TIMER_Done( NPC, "enemyLastVisible" ) )
+		{//If we haven't already, start the counter
+			int	lookTime = Q_irand( 4500, 8500 );
+			//NPCInfo->timeEnemyLastVisible = level.time + 2000;
+			TIMER_Set( NPC, "enemyLastVisible", lookTime );
+			//TODO: Play a sound along the lines of, "Huh?  What was that?"
+			ST_Speech( NPC, SPEECH_SIGHT, 0 );
+			//set desired yaw and pitch towards this guy?
+			//FIXME: this is permanent, they will never look away... *sigh*
+			NPC_FacePosition( suspect->currentOrigin, qtrue );
+			//FIXME: they still need some sort of eye/head tag/bone that can turn?
+			//NPC_TempLookTarget( NPC, suspect->s.number, lookTime, lookTime );
+		}
+		else if ( TIMER_Get( NPC, "enemyLastVisible" ) <= level.time + 500 
+			&& (NPCInfo->scriptFlags&SCF_LOOK_FOR_ENEMIES) )	//FIXME: Is this reliable?
+		{
+			if ( !Q_irand( 0, 2 ) )
+			{
+				int	interrogateTime = Q_irand( 2000, 4000 );
+				ST_Speech( NPC, SPEECH_SUSPICIOUS, 0 );
+				TIMER_Set( NPC, "interrogating", interrogateTime );
+				//G_SetEnemy( NPC, target );
+				//NPCInfo->enemyLastSeenTime = level.time;
+				//TIMER_Set( NPC, "attackDelay", interrogateTime );
+				//TIMER_Set( NPC, "stand", interrogateTime );
+				//set desired yaw and pitch towards this guy?
+				//FIXME: this is permanent, they will never look away... *sigh*
+				NPC_FacePosition( suspect->currentOrigin, qtrue );
+				//FIXME: they still need some sort of eye/head tag/bone that can turn?
+				//NPC_TempLookTarget( NPC, suspect->s.number, interrogateTime, interrogateTime );
+			}
+		}
+	}
+	return qfalse;
+}
+/*
+-------------------------
+NPC_ST_InvestigateEvent
+-------------------------
+*/
+
+#define	MAX_CHECK_THRESHOLD	1
+
+static qboolean NPC_ST_InvestigateEvent( int eventID, bool extraSuspicious )
+{
+	//If they've given themselves away, just take them as an enemy
+	if ( NPCInfo->confusionTime < level.time )
+	{
+		if ( level.alertEvents[eventID].level == AEL_DISCOVERED && (NPCInfo->scriptFlags&SCF_LOOK_FOR_ENEMIES) )
+		{
+			//NPCInfo->lastAlertID = level.alertEvents[eventID].ID;
+			if ( !level.alertEvents[eventID].owner || 
+				!level.alertEvents[eventID].owner->client || 
+				level.alertEvents[eventID].owner->health <= 0 ||
+				level.alertEvents[eventID].owner->client->playerTeam != NPC->client->enemyTeam )
+			{//not an enemy
+				return qfalse;
+			}
+			//FIXME: what if can't actually see enemy, don't know where he is... should we make them just become very alert and start looking for him?  Or just let combat AI handle this... (act as if you lost him)
+			//ST_Speech( NPC, SPEECH_CHARGE, 0 );
+			G_SetEnemy( NPC, level.alertEvents[eventID].owner );
+			NPCInfo->enemyLastSeenTime = level.time;
+			TIMER_Set( NPC, "attackDelay", Q_irand( 500, 2500 ) );
+			if ( level.alertEvents[eventID].type == AET_SOUND )
+			{//heard him, didn't see him, stick for a bit
+				TIMER_Set( NPC, "roamTime", Q_irand( 500, 2500 ) );
+			}
+			return qtrue;
+		}
+	}
+
+	//don't look at the same alert twice
+	/*
+	if ( level.alertEvents[eventID].ID == NPCInfo->lastAlertID )
+	{
+		return qfalse;
+	}
+	NPCInfo->lastAlertID = level.alertEvents[eventID].ID;
+	*/
+
+	//Must be ready to take another sound event
+	/*
+	if ( NPCInfo->investigateSoundDebounceTime > level.time )
+	{
+		return qfalse;
+	}
+	*/
+
+	if ( level.alertEvents[eventID].type == AET_SIGHT )
+	{//sight alert, check the light level
+		if ( level.alertEvents[eventID].light < Q_irand( ST_MIN_LIGHT_THRESHOLD, ST_MAX_LIGHT_THRESHOLD ) )
+		{//below my threshhold of potentially seeing
+			return qfalse;
+		}
+	}
+
+	//Save the position for movement (if necessary)
+	VectorCopy( level.alertEvents[eventID].position, NPCInfo->investigateGoal );
+
+	//First awareness of it
+	NPCInfo->investigateCount += ( extraSuspicious ) ? 2 : 1;
+
+	//Clamp the value
+	if ( NPCInfo->investigateCount > 4 )
+		NPCInfo->investigateCount = 4;
+
+	//See if we should walk over and investigate
+	if ( level.alertEvents[eventID].level > AEL_MINOR && NPCInfo->investigateCount > 1 && (NPCInfo->scriptFlags&SCF_CHASE_ENEMIES) )
+	{
+		//make it so they can walk right to this point and look at it rather than having to use combatPoints
+		if ( G_ExpandPointToBBox( NPCInfo->investigateGoal, NPC->mins, NPC->maxs, NPC->s.number, ((NPC->clipmask&~CONTENTS_BODY)|CONTENTS_BOTCLIP) ) )
+		{//we were able to move the investigateGoal to a point in which our bbox would fit
+			//drop the goal to the ground so we can get at it
+			vec3_t	end;
+			trace_t	trace;
+			VectorCopy( NPCInfo->investigateGoal, end );
+			end[2] -= 512;//FIXME: not always right?  What if it's even higher, somehow?
+			gi.trace( &trace, NPCInfo->investigateGoal, NPC->mins, NPC->maxs, end, ENTITYNUM_NONE, ((NPC->clipmask&~CONTENTS_BODY)|CONTENTS_BOTCLIP) );
+			if ( trace.fraction >= 1.0f )
+			{//too high to even bother
+				//FIXME: look at them???
+			}
+			else
+			{
+				VectorCopy( trace.endpos, NPCInfo->investigateGoal );
+				NPC_SetMoveGoal( NPC, NPCInfo->investigateGoal, 16, qtrue );
+				NPCInfo->localState = LSTATE_INVESTIGATE;
+			}
+		}
+		else
+		{
+			int id = NPC_FindCombatPoint( NPCInfo->investigateGoal, NPCInfo->investigateGoal, NPCInfo->investigateGoal, CP_INVESTIGATE|CP_HAS_ROUTE, 0 );
+
+			if ( id != -1 )
+			{
+				NPC_SetMoveGoal( NPC, level.combatPoints[id].origin, 16, qtrue, id );
+				NPCInfo->localState = LSTATE_INVESTIGATE;
+			}
+		}
+		//Say something
+		//FIXME: only if have others in group... these should be responses?
+		if ( NPCInfo->investigateDebounceTime+NPCInfo->pauseTime > level.time )
+		{//was already investigating
+			if ( NPCInfo->group && 
+				NPCInfo->group->commander && 
+				NPCInfo->group->commander->client && 
+				NPCInfo->group->commander->client->NPC_class == CLASS_IMPERIAL && 
+				!Q_irand( 0, 3 ) )
+			{
+				ST_Speech( NPCInfo->group->commander, SPEECH_LOOK, 0 );//FIXME: "I'll go check it out" type sounds
+			}
+			else
+			{
+				ST_Speech( NPC, SPEECH_LOOK, 0 );//FIXME: "I'll go check it out" type sounds
+			}
+		}
+		else
+		{
+			if ( level.alertEvents[eventID].type == AET_SIGHT )
+			{
+				ST_Speech( NPC, SPEECH_SIGHT, 0 );
+			}
+			else if ( level.alertEvents[eventID].type == AET_SOUND )
+			{
+				ST_Speech( NPC, SPEECH_SOUND, 0 );
+			}
+		}
+		//Setup the debounce info
+		NPCInfo->investigateDebounceTime		= NPCInfo->investigateCount * 5000;
+		NPCInfo->investigateSoundDebounceTime	= level.time + 2000;
+		NPCInfo->pauseTime						= level.time;
+	}
+	else
+	{//just look?
+		//Say something
+		if ( level.alertEvents[eventID].type == AET_SIGHT )
+		{
+			ST_Speech( NPC, SPEECH_SIGHT, 0 );
+		}
+		else if ( level.alertEvents[eventID].type == AET_SOUND )
+		{
+			ST_Speech( NPC, SPEECH_SOUND, 0 );
+		}
+		//Setup the debounce info
+		NPCInfo->investigateDebounceTime		= NPCInfo->investigateCount * 1000;
+		NPCInfo->investigateSoundDebounceTime	= level.time + 1000;
+		NPCInfo->pauseTime						= level.time;
+		VectorCopy( level.alertEvents[eventID].position, NPCInfo->investigateGoal );
+		if ( NPC->client->NPC_class == CLASS_ROCKETTROOPER 
+			&& !RT_Flying( NPC ) )
+		{
+			//if ( !Q_irand( 0, 2 ) )
+			{//look around
+				NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_GUARD_LOOKAROUND1, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+			}
+		}
+	}
+
+	if ( level.alertEvents[eventID].level >= AEL_DANGER )
+	{
+		NPCInfo->investigateDebounceTime = Q_irand( 500, 2500 );
+	}
+
+	//Start investigating
+	NPCInfo->tempBehavior = BS_INVESTIGATE;
+	return qtrue;
+}
+
+/*
+-------------------------
+ST_OffsetLook
+-------------------------
+*/
+
+static void ST_OffsetLook( float offset, vec3_t out )
+{
+	vec3_t	angles, forward, temp;
+
+	GetAnglesForDirection( NPC->currentOrigin, NPCInfo->investigateGoal, angles );
+	angles[YAW] += offset;
+	AngleVectors( angles, forward, NULL, NULL );
+	VectorMA( NPC->currentOrigin, 64, forward, out );
+	
+	CalcEntitySpot( NPC, SPOT_HEAD, temp );
+	out[2] = temp[2];
+}
+
+/*
+-------------------------
+ST_LookAround
+-------------------------
+*/
+
+static void ST_LookAround( void )
+{
+	vec3_t	lookPos;
+	float	perc = (float) ( level.time - NPCInfo->pauseTime ) / (float) NPCInfo->investigateDebounceTime;
+
+	//Keep looking at the spot
+	if ( perc < 0.25 )
+	{
+		VectorCopy( NPCInfo->investigateGoal, lookPos );
+	}
+	else if ( perc < 0.5f )		//Look up but straight ahead
+	{
+		ST_OffsetLook( 0.0f, lookPos );
+	}
+	else if ( perc < 0.75f )	//Look right
+	{
+		ST_OffsetLook( 45.0f, lookPos );
+	}
+	else	//Look left
+	{
+		ST_OffsetLook( -45.0f, lookPos );
+	}
+
+	NPC_FacePosition( lookPos );
+}
+
+/*
+-------------------------
+NPC_BSST_Investigate
+-------------------------
+*/
+
+void NPC_BSST_Investigate( void )
+{
+	//get group- mainly for group speech debouncing, but may use for group scouting/investigating AI, too
+	AI_GetGroup( NPC );
+
+	if( NPCInfo->scriptFlags & SCF_FIRE_WEAPON )
+	{
+		WeaponThink( qtrue );
+	}
+
+	if ( NPCInfo->confusionTime < level.time )
+	{
+		if ( NPCInfo->scriptFlags&SCF_LOOK_FOR_ENEMIES )
+		{
+			//Look for an enemy
+			if ( NPC_CheckPlayerTeamStealth() )
+			{
+				//NPCInfo->behaviorState	= BS_HUNT_AND_KILL;//should be auto now
+				ST_Speech( NPC, SPEECH_DETECTED, 0 );
+				NPCInfo->tempBehavior	= BS_DEFAULT;
+				NPC_UpdateAngles( qtrue, qtrue );
+				return;
+			}
+		}
+	}
+
+	if ( !(NPCInfo->scriptFlags&SCF_IGNORE_ALERTS) )
+	{
+		int alertEvent = NPC_CheckAlertEvents( qtrue, qtrue, NPCInfo->lastAlertID );
+
+		//There is an event to look at
+		if ( alertEvent >= 0 )
+		{
+			if ( NPCInfo->confusionTime < level.time )
+			{
+				if ( NPC_CheckForDanger( alertEvent ) )
+				{//running like hell
+					ST_Speech( NPC, SPEECH_COVER, 0 );//FIXME: flee sound?
+					return;
+				}
+			}
+
+			//if ( level.alertEvents[alertEvent].ID != NPCInfo->lastAlertID )
+			{
+				NPC_ST_InvestigateEvent( alertEvent, qtrue );
+			}
+		}
+	}
+
+	//If we're done looking, then just return to what we were doing
+	if ( ( NPCInfo->investigateDebounceTime + NPCInfo->pauseTime ) < level.time )
+	{
+		NPCInfo->tempBehavior = BS_DEFAULT;
+		NPCInfo->goalEntity = UpdateGoal();
+		
+		NPC_UpdateAngles( qtrue, qtrue );
+		//Say something
+		ST_Speech( NPC, SPEECH_GIVEUP, 0 );
+		return;
+	}
+
+	//FIXME: else, look for new alerts
+
+	//See if we're searching for the noise's origin
+	if ( NPCInfo->localState == LSTATE_INVESTIGATE && (NPCInfo->goalEntity!=NULL) )
+	{
+		//See if we're there
+		if ( !STEER::Reached(NPC, NPCInfo->goalEntity, 32, !!FlyingCreature(NPC)) )
+		{
+			ucmd.buttons |= BUTTON_WALKING;
+
+			//Try and move there
+			if ( NPC_MoveToGoal( qtrue )  )
+			{
+				//Bump our times
+				NPCInfo->investigateDebounceTime	= NPCInfo->investigateCount * 5000;
+				NPCInfo->pauseTime					= level.time;
+
+				NPC_UpdateAngles( qtrue, qtrue );
+				return;
+			}
+		}
+
+		//Otherwise we're done or have given up
+		//Say something
+		//ST_Speech( NPC, SPEECH_LOOK, 0.33f );
+		NPCInfo->localState = LSTATE_NONE;
+	}
+
+	//Look around
+	ST_LookAround();
+}
+
+/*
+-------------------------
+NPC_BSST_Patrol
+-------------------------
+*/
+
+void NPC_BSST_Patrol( void )
+{//FIXME: pick up on bodies of dead buddies?
+	
+	//Not a scriptflag, but...
+	if ( NPC->client->NPC_class == CLASS_ROCKETTROOPER && (NPC->client->ps.eFlags&EF_SPOTLIGHT) )
+	{//using spotlight search mode
+		vec3_t	eyeFwd, end, mins={-2,-2,-2}, maxs={2,2,2};
+		trace_t	trace;
+		AngleVectors( NPC->client->renderInfo.eyeAngles, eyeFwd, NULL, NULL );
+		VectorMA( NPC->client->renderInfo.eyePoint, NPCInfo->stats.visrange, eyeFwd, end ); 
+		//get server-side trace impact point
+		gi.trace( &trace, NPC->client->renderInfo.eyePoint, mins, maxs, end, NPC->s.number, MASK_OPAQUE|CONTENTS_BODY|CONTENTS_CORPSE );
+		NPC->speed = (trace.fraction*NPCInfo->stats.visrange);
+		if ( NPCInfo->scriptFlags&SCF_LOOK_FOR_ENEMIES )
+		{
+			//FIXME: do a FOV cone check, then a trace
+			if ( trace.entityNum < ENTITYNUM_WORLD )
+			{//hit something
+				//try cheap check first
+				gentity_t *enemy = &g_entities[trace.entityNum];
+				if ( enemy && enemy->client && NPC_ValidEnemy( enemy ) && enemy->client->playerTeam == NPC->client->enemyTeam )
+				{
+					G_SetEnemy( NPC, enemy );
+					TIMER_Set( NPC, "attackDelay", Q_irand( 500, 2500 ) );
+					//NPCInfo->behaviorState = BS_HUNT_AND_KILL;//should be auto now
+					//NPC_AngerSound();
+					NPC_UpdateAngles( qtrue, qtrue );
+					return;
+				}
+			}
+			//FIXME: maybe do a quick check of ents within the spotlight's radius?
+			//hmmm, look around
+			if ( NPC_CheckEnemiesInSpotlight() )
+			{
+				//NPCInfo->behaviorState = BS_HUNT_AND_KILL;//should be auto now
+				//NPC_AngerSound();
+				NPC_UpdateAngles( qtrue, qtrue );
+				return;
+			}
+		}
+	}
+	else
+	{
+		//get group- mainly for group speech debouncing, but may use for group scouting/investigating AI, too
+		AI_GetGroup( NPC );
+
+		if ( NPCInfo->confusionTime < level.time )
+		{
+			//Look for any enemies
+			if ( NPCInfo->scriptFlags&SCF_LOOK_FOR_ENEMIES )
+			{
+				if ( NPC_CheckPlayerTeamStealth() )
+				{
+					//NPCInfo->behaviorState = BS_HUNT_AND_KILL;//should be auto now
+					//NPC_AngerSound();
+					NPC_UpdateAngles( qtrue, qtrue );
+					return;
+				}
+			}
+		}
+	}
+
+	if ( !(NPCInfo->scriptFlags&SCF_IGNORE_ALERTS) )
+	{
+		int alertEvent = NPC_CheckAlertEvents( qtrue, qtrue );
+
+		//There is an event to look at
+		if ( alertEvent >= 0 )
+		{
+			if ( NPC_CheckForDanger( alertEvent ) )
+			{//going to run?
+				ST_Speech( NPC, SPEECH_COVER, 0 );
+				return;
+			}
+			else if (NPC->client->NPC_class==CLASS_BOBAFETT)
+			{
+				//NPCInfo->lastAlertID = level.alertEvents[eventID].ID;
+				if ( !level.alertEvents[alertEvent].owner || 
+					!level.alertEvents[alertEvent].owner->client || 
+					level.alertEvents[alertEvent].owner->health <= 0 ||
+					level.alertEvents[alertEvent].owner->client->playerTeam != NPC->client->enemyTeam )
+				{//not an enemy
+					return;
+				}
+				//FIXME: what if can't actually see enemy, don't know where he is... should we make them just become very alert and start looking for him?  Or just let combat AI handle this... (act as if you lost him)
+				//ST_Speech( NPC, SPEECH_CHARGE, 0 );
+				G_SetEnemy( NPC, level.alertEvents[alertEvent].owner );
+				NPCInfo->enemyLastSeenTime = level.time;
+				TIMER_Set( NPC, "attackDelay", Q_irand( 500, 2500 ) );
+				return;
+			}
+			else if ( NPC_ST_InvestigateEvent( alertEvent, qfalse ) )
+			{//actually going to investigate it
+				NPC_UpdateAngles( qtrue, qtrue );
+				return;
+			}
+		}
+	}
+
+	//If we have somewhere to go, then do that
+	if ( UpdateGoal() )
+	{
+		ucmd.buttons |= BUTTON_WALKING;
+		//ST_Move( NPCInfo->goalEntity );
+		NPC_MoveToGoal( qtrue );
+	}
+	else// if ( !(NPCInfo->scriptFlags&SCF_IGNORE_ALERTS) )
+	{
+		if ( NPC->client->NPC_class != CLASS_IMPERIAL && NPC->client->NPC_class != CLASS_IMPWORKER )
+		{//imperials do not look around
+			if ( TIMER_Done( NPC, "enemyLastVisible" ) )
+			{//nothing suspicious, look around
+				if ( !Q_irand( 0, 30 ) )
+				{
+					NPCInfo->desiredYaw = NPC->s.angles[1] + Q_irand( -90, 90 );
+				}
+				if ( !Q_irand( 0, 30 ) )
+				{
+					NPCInfo->desiredPitch = Q_irand( -20, 20 );
+				}
+			}
+		}
+	}
+
+	NPC_UpdateAngles( qtrue, qtrue );
+	//TEMP hack for Imperial stand anim
+	if ( NPC->client->NPC_class == CLASS_IMPERIAL 
+		|| NPC->client->NPC_class == CLASS_IMPWORKER )
+	{//hack
+		if ( NPC->client->ps.weapon != WP_CONCUSSION )
+		{//not Rax
+			if ( ucmd.forwardmove || ucmd.rightmove || ucmd.upmove )
+			{//moving
+		
+				if( (!NPC->client->ps.torsoAnimTimer) || (NPC->client->ps.torsoAnim == BOTH_STAND4) ) 			
+				{
+					if ( (ucmd.buttons&BUTTON_WALKING) && !(NPCInfo->scriptFlags&SCF_RUNNING) )
+					{//not running, only set upper anim
+						//  No longer overrides scripted anims
+						NPC_SetAnim( NPC, SETANIM_TORSO, BOTH_STAND4, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+						NPC->client->ps.torsoAnimTimer = 200;
+					}
+				}
+			}
+			else
+			{//standing still, set both torso and legs anim
+				//  No longer overrides scripted anims
+				if( ( !NPC->client->ps.torsoAnimTimer || (NPC->client->ps.torsoAnim == BOTH_STAND4) ) &&
+					( !NPC->client->ps.legsAnimTimer  || (NPC->client->ps.legsAnim == BOTH_STAND4) ) )
+				{
+					NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_STAND4, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+					NPC->client->ps.torsoAnimTimer = NPC->client->ps.legsAnimTimer = 200;
+				}
+			}
+			//FIXME: this is a disgusting hack that is supposed to make the Imperials start with their weapon holstered- need a better way
+			if ( NPC->client->ps.weapon != WP_NONE )
+			{
+				ChangeWeapon( NPC, WP_NONE );
+				NPC->client->ps.weapon = WP_NONE;
+				NPC->client->ps.weaponstate = WEAPON_READY;
+				G_RemoveWeaponModels( NPC );
+			}
+		}
+	}
+}
+
+/*
+-------------------------
+NPC_BSST_Idle
+-------------------------
+*/
+/*
+void NPC_BSST_Idle( void )
+{
+	int alertEvent = NPC_CheckAlertEvents( qtrue, qtrue );
+
+	//There is an event to look at
+	if ( alertEvent >= 0 )
+	{
+		NPC_ST_InvestigateEvent( alertEvent, qfalse );
+		NPC_UpdateAngles( qtrue, qtrue );
+		return;
+	}
+
+	TIMER_Set( NPC, "roamTime", 2000 + Q_irand( 1000, 2000 ) );
+
+	NPC_UpdateAngles( qtrue, qtrue );
+}
+*/
+/*
+-------------------------
+ST_CheckMoveState
+-------------------------
+*/
+
+static void ST_CheckMoveState( void )
+{
+	if ( Q3_TaskIDPending( NPC, TID_MOVE_NAV ) )
+	{//moving toward a goal that a script is waiting on, so don't stop for anything!
+		move = qtrue;
+	}
+	else if ( NPC->client->NPC_class == CLASS_ROCKETTROOPER
+		&& NPC->client->ps.groundEntityNum == ENTITYNUM_NONE )
+	{//no squad stuff
+		return;
+	}
+//	else if ( NPC->NPC->scriptFlags&SCF_NO_GROUPS )
+	{
+		move = qtrue;
+	}
+	//See if we're a scout
+
+	//See if we're moving towards a goal, not the enemy
+	if ( ( NPCInfo->goalEntity != NPC->enemy ) && ( NPCInfo->goalEntity != NULL ) )
+	{
+		//Did we make it?
+		if ( STEER::Reached(NPC, NPCInfo->goalEntity, 16, !!FlyingCreature(NPC)) || 
+			(enemyLOS && (NPCInfo->aiFlags&NPCAI_STOP_AT_LOS) && !Q3_TaskIDPending(NPC, TID_MOVE_NAV))
+			)
+		{//either hit our navgoal or our navgoal was not a crucial (scripted) one (maybe a combat point) and we're scouting and found our enemy
+			int	newSquadState = SQUAD_STAND_AND_SHOOT;
+			//we got where we wanted to go, set timers based on why we were running
+			switch ( NPCInfo->squadState )
+			{
+			case SQUAD_RETREAT://was running away
+				//done fleeing, obviously
+				TIMER_Set( NPC, "duck", (NPC->max_health - NPC->health) * 100 );
+				TIMER_Set( NPC, "hideTime", Q_irand( 3000, 7000 ) );
+				TIMER_Set( NPC, "flee", -level.time );
+				newSquadState = SQUAD_COVER;
+				break;
+			case SQUAD_TRANSITION://was heading for a combat point
+				TIMER_Set( NPC, "hideTime", Q_irand( 2000, 4000 ) );
+				break;
+			case SQUAD_SCOUT://was running after player
+				break;
+			default:
+				break;
+			}
+			AI_GroupUpdateSquadstates( NPCInfo->group, NPC, newSquadState );
+			NPC_ReachedGoal();
+			//don't attack right away
+			TIMER_Set( NPC, "attackDelay", Q_irand( 250, 500 ) );	//FIXME: Slant for difficulty levels
+			//don't do something else just yet
+
+			// THIS IS THE ONE TRUE PLACE WHERE ROAM TIME IS SET
+			TIMER_Set( NPC, "roamTime", Q_irand( 8000, 15000 ) );//Q_irand( 1000, 4000 ) );
+			if (Q_irand(0, 3)==0)
+			{
+				TIMER_Set( NPC, "duck", Q_irand(5000, 10000) );		// just reached our goal, chance of ducking now
+			}
+			return;
+		}
+
+		//keep going, hold of roamTimer until we get there
+		TIMER_Set( NPC, "roamTime", Q_irand( 8000, 9000 ) );
+	}
+}
+
+void ST_ResolveBlockedShot( int hit )
+{
+	int	stuckTime;
+	//figure out how long we intend to stand here, max
+	if ( TIMER_Get( NPC, "roamTime" ) > TIMER_Get( NPC, "stick" ) )
+	{
+		stuckTime = TIMER_Get( NPC, "roamTime" )-level.time;
+	}
+	else
+	{
+		stuckTime = TIMER_Get( NPC, "stick" )-level.time;
+	}
+
+	if ( TIMER_Done( NPC, "duck" ) )
+	{//we're not ducking
+		if ( AI_GroupContainsEntNum( NPCInfo->group, hit ) )
+		{
+			gentity_t *member = &g_entities[hit];
+			if ( TIMER_Done( member, "duck" ) )
+			{//they aren't ducking
+				if ( TIMER_Done( member, "stand" ) )
+				{//they're not being forced to stand
+					//tell them to duck at least as long as I'm not moving
+					TIMER_Set( member, "duck", stuckTime );	// tell my friend to duck so I can shoot over his head
+					return;
+				}
+			}
+		}
+	}
+	else
+	{//maybe we should stand
+		if ( TIMER_Done( NPC, "stand" ) )
+		{//stand for as long as we'll be here
+			TIMER_Set( NPC, "stand", stuckTime );
+			return;
+		}
+	}
+	//Hmm, can't resolve this by telling them to duck or telling me to stand
+	//We need to move!
+	TIMER_Set( NPC, "roamTime", -1 );
+	TIMER_Set( NPC, "stick", -1 );
+	TIMER_Set( NPC, "duck", -1 );
+	TIMER_Set( NPC, "attakDelay", Q_irand( 1000, 3000 ) );
+}
+
+/*
+-------------------------
+ST_CheckFireState
+-------------------------
+*/
+
+static void ST_CheckFireState( void )
+{
+	if ( enemyCS )
+	{//if have a clear shot, always try
+		return;
+	}
+
+	if ( NPCInfo->squadState == SQUAD_RETREAT || NPCInfo->squadState == SQUAD_TRANSITION || NPCInfo->squadState == SQUAD_SCOUT )
+	{//runners never try to fire at the last pos
+		return;
+	}
+
+	if ( !VectorCompare( NPC->client->ps.velocity, vec3_origin ) )
+	{//if moving at all, don't do this
+		return;
+	}
+
+	//See if we should continue to fire on their last position
+	//!TIMER_Done( NPC, "stick" ) || 
+	if ( !hitAlly //we're not going to hit an ally
+		&& enemyInFOV //enemy is in our FOV //FIXME: or we don't have a clear LOS?
+		&& NPCInfo->enemyLastSeenTime > 0 //we've seen the enemy
+		&& NPCInfo->group //have a group
+		&& (NPCInfo->group->numState[SQUAD_RETREAT]>0||NPCInfo->group->numState[SQUAD_TRANSITION]>0||NPCInfo->group->numState[SQUAD_SCOUT]>0) )//laying down covering fire
+	{
+		if ( level.time - NPCInfo->enemyLastSeenTime < 10000 &&//we have seem the enemy in the last 10 seconds
+			(!NPCInfo->group || level.time - NPCInfo->group->lastSeenEnemyTime < 10000 ))//we are not in a group or the group has seen the enemy in the last 10 seconds
+		{
+			if ( !Q_irand( 0, 10 ) )
+			{
+				//Fire on the last known position
+				vec3_t	muzzle, dir, angles;
+				qboolean tooClose = qfalse;
+				qboolean tooFar = qfalse;
+
+				CalcEntitySpot( NPC, SPOT_HEAD, muzzle );
+				if ( VectorCompare( impactPos, vec3_origin ) )
+				{//never checked ShotEntity this frame, so must do a trace...
+					trace_t tr;
+					//vec3_t	mins = {-2,-2,-2}, maxs = {2,2,2};
+					vec3_t	forward, end;
+					AngleVectors( NPC->client->ps.viewangles, forward, NULL, NULL );
+					VectorMA( muzzle, 8192, forward, end );
+					gi.trace( &tr, muzzle, vec3_origin, vec3_origin, end, NPC->s.number, MASK_SHOT );
+					VectorCopy( tr.endpos, impactPos );
+				}
+
+				//see if impact would be too close to me
+				float distThreshold = 16384/*128*128*/;//default
+				switch ( NPC->s.weapon )
+				{
+				case WP_ROCKET_LAUNCHER:
+				case WP_FLECHETTE:
+				case WP_THERMAL:
+				case WP_TRIP_MINE:
+				case WP_DET_PACK:
+					distThreshold = 65536/*256*256*/;
+					break;
+				case WP_REPEATER:
+					if ( NPCInfo->scriptFlags&SCF_ALT_FIRE )
+					{
+						distThreshold = 65536/*256*256*/;
+					}
+					break;
+				case WP_CONCUSSION:
+					if ( !(NPCInfo->scriptFlags&SCF_ALT_FIRE) )
+					{
+						distThreshold = 65536/*256*256*/;
+					}
+					break;
+				default:
+					break;
+				}
+
+				float dist = DistanceSquared( impactPos, muzzle );
+
+				if ( dist < distThreshold )
+				{//impact would be too close to me
+					tooClose = qtrue;
+				}
+				else if ( level.time - NPCInfo->enemyLastSeenTime > 5000 ||
+					(NPCInfo->group && level.time - NPCInfo->group->lastSeenEnemyTime > 5000 ))
+				{//we've haven't seen them in the last 5 seconds
+					//see if it's too far from where he is
+					distThreshold = 65536/*256*256*/;//default
+					switch ( NPC->s.weapon )
+					{
+					case WP_ROCKET_LAUNCHER:
+					case WP_FLECHETTE:
+					case WP_THERMAL:
+					case WP_TRIP_MINE:
+					case WP_DET_PACK:
+						distThreshold = 262144/*512*512*/;
+						break;
+					case WP_REPEATER:
+						if ( NPCInfo->scriptFlags&SCF_ALT_FIRE )
+						{
+							distThreshold = 262144/*512*512*/;
+						}
+						break;
+					case WP_CONCUSSION:
+						if ( !(NPCInfo->scriptFlags&SCF_ALT_FIRE) )
+						{
+							distThreshold = 262144/*512*512*/;
+						}
+						break;
+					default:
+						break;
+					}
+					dist = DistanceSquared( impactPos, NPCInfo->enemyLastSeenLocation );
+					if ( dist > distThreshold )
+					{//impact would be too far from enemy
+						tooFar = qtrue;
+					}
+				}
+
+				if ( !tooClose && !tooFar )
+				{//okay too shoot at last pos
+					VectorSubtract( NPCInfo->enemyLastSeenLocation, muzzle, dir );
+					VectorNormalize( dir );
+					vectoangles( dir, angles );
+
+					NPCInfo->desiredYaw		= angles[YAW];
+					NPCInfo->desiredPitch	= angles[PITCH];
+
+					shoot = qtrue;
+					faceEnemy = qfalse;
+					//AI_GroupUpdateSquadstates( NPCInfo->group, NPC, SQUAD_STAND_AND_SHOOT );
+					return;
+				}
+			}
+		}
+	}
+}
+
+void ST_TrackEnemy( gentity_t *self, vec3_t enemyPos )
+{
+	//clear timers
+	TIMER_Set( self, "attackDelay", Q_irand( 1000, 2000 ) );
+	//TIMER_Set( self, "duck", -1 );
+	TIMER_Set( self, "stick", Q_irand( 500, 1500 ) );
+	TIMER_Set( self, "stand", -1 );
+	TIMER_Set( self, "scoutTime", TIMER_Get( self, "stick" )-level.time+Q_irand(5000, 10000) );
+	//leave my combat point
+	NPC_FreeCombatPoint( self->NPC->combatPoint );
+	//go after his last seen pos
+	NPC_SetMoveGoal( self, enemyPos, 100.0f, qfalse );
+	if (Q_irand(0,3)==0)
+	{
+		NPCInfo->aiFlags |= NPCAI_STOP_AT_LOS;
+	}
+}
+
+int ST_ApproachEnemy( gentity_t *self )
+{
+	TIMER_Set( self, "attackDelay", Q_irand( 250, 500 ) );
+	//TIMER_Set( self, "duck", -1 );
+	TIMER_Set( self, "stick", Q_irand( 1000, 2000 ) );
+	TIMER_Set( self, "stand", -1 );
+	TIMER_Set( self, "scoutTime", TIMER_Get( self, "stick" )-level.time+Q_irand(5000, 10000) );
+	//leave my combat point
+	NPC_FreeCombatPoint( self->NPC->combatPoint );
+	//return the relevant combat point flags
+	return (CP_CLEAR|CP_CLOSEST);
+}
+
+void ST_HuntEnemy( gentity_t *self )
+{
+	//TIMER_Set( NPC, "attackDelay", Q_irand( 250, 500 ) );//Disabled this for now, guys who couldn't hunt would never attack
+	//TIMER_Set( NPC, "duck", -1 );
+	TIMER_Set( NPC, "stick", Q_irand( 250, 1000 ) );
+	TIMER_Set( NPC, "stand", -1 );
+	TIMER_Set( NPC, "scoutTime", TIMER_Get( NPC, "stick" )-level.time+Q_irand(5000, 10000) );
+	//leave my combat point
+	NPC_FreeCombatPoint( NPCInfo->combatPoint );
+	//go directly after the enemy
+	if ( NPCInfo->scriptFlags & SCF_CHASE_ENEMIES )
+	{
+		self->NPC->goalEntity = NPC->enemy;
+	}
+}
+
+void ST_TransferTimers( gentity_t *self, gentity_t *other )
+{
+	TIMER_Set( other, "attackDelay", TIMER_Get( self, "attackDelay" )-level.time );
+	TIMER_Set( other, "duck", TIMER_Get( self, "duck" )-level.time );
+	TIMER_Set( other, "stick", TIMER_Get( self, "stick" )-level.time );
+	TIMER_Set( other, "scoutTime", TIMER_Get( self, "scoutTime" )-level.time );
+	TIMER_Set( other, "roamTime", TIMER_Get( self, "roamTime" )-level.time );
+	TIMER_Set( other, "stand", TIMER_Get( self, "stand" )-level.time );
+	TIMER_Set( self, "attackDelay", -1 );
+	TIMER_Set( self, "duck", -1 );
+	TIMER_Set( self, "stick", -1 );
+	TIMER_Set( self, "scoutTime", -1 );
+	TIMER_Set( self, "roamTime", -1 );
+	TIMER_Set( self, "stand", -1 );
+}
+
+void ST_TransferMoveGoal( gentity_t *self, gentity_t *other )
+{
+	if ( Q3_TaskIDPending( self, TID_MOVE_NAV ) )
+	{//can't transfer movegoal when a script we're running is waiting to complete
+		return;
+	}
+	if ( self->NPC->combatPoint != -1 )
+	{//I've got a combatPoint I'm going to, give it to him
+		self->NPC->lastFailedCombatPoint = other->NPC->combatPoint = self->NPC->combatPoint;
+		self->NPC->combatPoint = -1;
+	}
+	else
+	{//I must be going for a goal, give that to him instead
+		if ( self->NPC->goalEntity == self->NPC->tempGoal )
+		{
+			NPC_SetMoveGoal( other, self->NPC->tempGoal->currentOrigin, self->NPC->goalRadius, ((self->NPC->tempGoal->svFlags&SVF_NAVGOAL)?true:false) );
+		}
+		else
+		{
+			other->NPC->goalEntity = self->NPC->goalEntity;
+		}
+	}
+	//give him my squadstate
+	AI_GroupUpdateSquadstates( self->NPC->group, other, NPCInfo->squadState );
+
+	//give him my timers and clear mine
+	ST_TransferTimers( self, other );
+
+	//now make me stand around for a second or two at least
+	AI_GroupUpdateSquadstates( self->NPC->group, self, SQUAD_STAND_AND_SHOOT );
+	TIMER_Set( self, "stand", Q_irand( 1000, 3000 ) );
+}
+
+int ST_GetCPFlags( void )
+{
+	int cpFlags = 0;
+	if ( NPC && NPCInfo->group )
+	{
+		if ( NPC == NPCInfo->group->commander && NPC->client->NPC_class == CLASS_IMPERIAL )
+		{//imperials hang back and give orders
+			if ( NPCInfo->group->numGroup > 1 && Q_irand( -3, NPCInfo->group->numGroup ) > 1 )
+			{//FIXME: make sure he;s giving orders with these lines
+				if ( Q_irand( 0, 1 ) )
+				{
+					ST_Speech( NPC, SPEECH_CHASE, 0.5 );
+				}
+				else
+				{
+					ST_Speech( NPC, SPEECH_YELL, 0.5 );
+				}
+			}
+			cpFlags = (CP_CLEAR|CP_COVER|CP_AVOID|CP_SAFE|CP_RETREAT);
+		}
+		else if ( NPCInfo->group->morale < 0 )
+		{//hide
+			cpFlags = (CP_COVER|CP_AVOID|CP_SAFE|CP_RETREAT);
+			/*
+			if ( NPC->client->NPC_class == CLASS_SABOTEUR && !Q_irand( 0, 3 ) )
+			{
+				Saboteur_Cloak( NPC );
+			}
+			*/
+		}
+/*		else if ( NPCInfo->group->morale < NPCInfo->group->numGroup )
+		{//morale is low for our size
+			int moraleDrop = NPCInfo->group->numGroup - NPCInfo->group->morale;
+			if ( moraleDrop < -6 )
+			{//flee (no clear shot needed)
+				cpFlags = (CP_FLEE|CP_RETREAT|CP_COVER|CP_AVOID|CP_SAFE);
+			}
+			else if ( moraleDrop < -3 )
+			{//retreat (no clear shot needed)
+				cpFlags = (CP_RETREAT|CP_COVER|CP_AVOID|CP_SAFE);
+			}
+			else if ( moraleDrop < 0 )
+			{//cover (no clear shot needed)
+				cpFlags = (CP_COVER|CP_AVOID|CP_SAFE);
+			}
+		}*/
+		else
+		{
+			int moraleBoost = NPCInfo->group->morale - NPCInfo->group->numGroup;
+			if ( moraleBoost > 20 )
+			{//charge to any one and outflank (no cover needed)
+				cpFlags = (CP_CLEAR|CP_FLANK|CP_APPROACH_ENEMY);
+				//Saboteur_Decloak( NPC );
+			}
+			else if ( moraleBoost > 15 )
+			{//charge to closest one (no cover needed)
+				cpFlags = (CP_CLEAR|CP_CLOSEST|CP_APPROACH_ENEMY);
+				/*
+				if ( NPC->client->NPC_class == CLASS_SABOTEUR && !Q_irand( 0, 3 ) )
+				{
+					Saboteur_Decloak( NPC );
+				}
+				*/
+			}
+			else if ( moraleBoost > 10 )
+			{//charge closer (no cover needed)
+				cpFlags = (CP_CLEAR|CP_APPROACH_ENEMY);
+				/*
+				if ( NPC->client->NPC_class == CLASS_SABOTEUR && !Q_irand( 0, 6 ) )
+				{
+					Saboteur_Decloak( NPC );
+				}
+				*/
+			}
+		}
+	}
+	if ( !cpFlags )
+	{
+		//at some medium level of morale
+		switch( Q_irand( 0, 3 ) )
+		{
+		case 0://just take the nearest one
+			cpFlags = (CP_CLEAR|CP_COVER|CP_NEAREST);
+			break;
+		case 1://take one closer to the enemy
+			cpFlags = (CP_CLEAR|CP_COVER|CP_APPROACH_ENEMY);
+			break;
+		case 2://take the one closest to the enemy
+			cpFlags = (CP_CLEAR|CP_COVER|CP_CLOSEST|CP_APPROACH_ENEMY);
+			break;
+		case 3://take the one on the other side of the enemy
+			cpFlags = (CP_CLEAR|CP_COVER|CP_FLANK|CP_APPROACH_ENEMY);
+			break;
+		}
+	}
+	if ( NPC && (NPCInfo->scriptFlags&SCF_USE_CP_NEAREST) )
+	{
+		cpFlags &= ~(CP_FLANK|CP_APPROACH_ENEMY|CP_CLOSEST);
+		cpFlags |= CP_NEAREST;
+	}
+	return cpFlags;
+}
+
+/*
+-------------------------
+ST_Commander
+
+  Make decisions about who should go where, etc.
+
+FIXME: leader (group-decision-making) AI?
+FIXME: need alternate routes!
+FIXME: more group voice interaction
+FIXME: work in pairs?
+
+-------------------------
+*/
+void ST_Commander( void )
+{
+	int		i;//, j;
+	int		cp, cpFlags_org, cpFlags;
+	AIGroupInfo_t	*group = NPCInfo->group;
+	gentity_t	*member;//, *buddy;
+	qboolean	runner = qfalse;
+	qboolean	enemyLost = qfalse;
+	qboolean	scouting = qfalse;
+	int			squadState;
+	float		avoidDist;
+
+	group->processed = qtrue;
+
+	if ( group->enemy == NULL || group->enemy->client == NULL )
+	{//hmm, no enemy...?!
+		return;
+	}
+
+	//FIXME: have this group commander check the enemy group (if any) and see if they have 
+	//		superior numbers.  If they do, fall back rather than advance.  If you have
+	//		superior numbers, advance on them.
+	//FIXME: find the group commander and have him occasionally give orders when there is speech
+	//FIXME: start fleeing when only a couple of you vs. a lightsaber, possibly give up if the only one left
+
+	SaveNPCGlobals();
+
+	if ( group->lastSeenEnemyTime < level.time - 180000 )
+	{//dissolve the group
+		ST_Speech( NPC, SPEECH_LOST, 0.0f );
+		group->enemy->waypoint = NAV::GetNearestNode(group->enemy);
+		for ( i = 0; i < group->numGroup; i++ )
+		{
+			member = &g_entities[group->member[i].number];
+			SetNPCGlobals( member );
+			if ( Q3_TaskIDPending( NPC, TID_MOVE_NAV ) )
+			{//running somewhere that a script requires us to go, don't break from that
+				continue;
+			}
+			if ( !(NPCInfo->scriptFlags&SCF_CHASE_ENEMIES) )
+			{//not allowed to move on my own
+				continue;
+			}
+			//Lost enemy for three minutes?  go into search mode?
+			G_ClearEnemy( NPC );
+			NPC->waypoint = NAV::GetNearestNode(group->enemy);
+			if ( NPC->waypoint == WAYPOINT_NONE )
+			{
+				NPCInfo->behaviorState = BS_DEFAULT;//BS_PATROL;
+			}
+			else if ( group->enemy->waypoint == WAYPOINT_NONE || (NAV::EstimateCostToGoal( NPC->waypoint, group->enemy->waypoint ) >= Q3_INFINITE) )
+			{
+				NPC_BSSearchStart( NPC->waypoint, BS_SEARCH );
+			}
+			else
+			{
+				NPC_BSSearchStart( group->enemy->waypoint, BS_SEARCH );
+			}
+		}
+		group->enemy = NULL;
+		RestoreNPCGlobals();
+		return;
+	}
+
+
+
+
+	//see if anyone is running
+	if ( group->numState[SQUAD_SCOUT] > 0 || 
+		group->numState[SQUAD_TRANSITION] > 0 || 
+		group->numState[SQUAD_RETREAT] > 0 )
+	{//someone is running
+		runner = qtrue;
+	}
+
+	if ( /*!runner &&*/ group->lastSeenEnemyTime > level.time - 32000 && group->lastSeenEnemyTime < level.time - 30000 )
+	{//no-one has seen the enemy for 30 seconds// and no-one is running after him
+		if ( group->commander && !Q_irand( 0, 1 ) )
+		{
+			ST_Speech( group->commander, SPEECH_ESCAPING, 0.0f );
+		}
+		else
+		{
+			ST_Speech( NPC, SPEECH_ESCAPING, 0.0f );
+		}
+		//don't say this again
+		NPCInfo->blockedSpeechDebounceTime = level.time + 3000;
+	}
+
+	if ( group->lastSeenEnemyTime < level.time - 7000 )
+	{//no-one has seen the enemy for at least 10 seconds!  Should send a scout
+		enemyLost = qtrue;
+	}
+
+	//Go through the list:
+
+	//Everyone should try to get to a combat point if possible
+	int	curMemberNum, lastMemberNum;
+	if ( d_asynchronousGroupAI->integer )
+	{//do one member a turn
+		group->activeMemberNum++;
+		if ( group->activeMemberNum >= group->numGroup )
+		{
+			group->activeMemberNum = 0;
+		}
+		curMemberNum = group->activeMemberNum;
+		lastMemberNum = curMemberNum + 1;
+	}
+	else
+	{
+		curMemberNum = 0;
+		lastMemberNum = group->numGroup;
+	}
+	for ( i = curMemberNum; i < lastMemberNum; i++ )
+	{
+		//reset combat point flags
+		cp = -1;
+		cpFlags = 0;
+		squadState = SQUAD_IDLE;
+		avoidDist = 0;
+		scouting = qfalse;
+
+		//get the next guy
+		member = &g_entities[group->member[i].number];
+		if ( !member->enemy )
+		{//don't include guys that aren't angry
+			continue;
+		}
+		SetNPCGlobals( member );
+
+		if ( !TIMER_Done( NPC, "flee" ) )
+		{//running away
+			continue;
+		}
+
+		if ( Q3_TaskIDPending( NPC, TID_MOVE_NAV ) )
+		{//running somewhere that a script requires us to go
+			continue;
+		}
+
+		if ( NPC->s.weapon == WP_NONE 
+			&& NPCInfo->goalEntity 
+			&& NPCInfo->goalEntity == NPCInfo->tempGoal
+			&& NPCInfo->goalEntity->s.eType == ET_ITEM )
+		{//running to pick up a gun, don't do other logic
+			continue;
+		}
+
+		
+		if ( !(NPCInfo->scriptFlags&SCF_CHASE_ENEMIES) )
+		{//not allowed to do combat-movement
+			continue;
+		}
+
+
+		if ( NPC->client->ps.weapon == WP_NONE )
+		{//weaponless, should be hiding
+			if ( NPCInfo->goalEntity == NULL || NPCInfo->goalEntity->enemy == NULL || NPCInfo->goalEntity->enemy->s.eType != ET_ITEM )
+			{//not running after a pickup
+				if ( TIMER_Done( NPC, "hideTime" ) || (DistanceSquared( group->enemy->currentOrigin, NPC->currentOrigin ) < 65536 && NPC_ClearLOS( NPC->enemy )) )
+				{//done hiding or enemy near and can see us
+					//er, start another flee I guess?
+					NPC_StartFlee( NPC->enemy, NPC->enemy->currentOrigin, AEL_DANGER_GREAT, 5000, 10000 );
+				}//else, just hang here
+			}
+			continue;
+		}
+				
+		if (enemyLost && NAV::InSameRegion(NPC, NPC->enemy->currentOrigin))
+		{
+			ST_TrackEnemy( NPC, NPC->enemy->currentOrigin );
+			continue;
+		}
+
+		if (!NPC->enemy)
+		{
+			continue;
+		}
+
+
+		// Check To See We Have A Clear Shot To The Enemy Every Couple Seconds
+		//---------------------------------------------------------------------
+		if (TIMER_Done( NPC, "checkGrenadeTooCloseDebouncer" ))
+		{ 
+			TIMER_Set (NPC, "checkGrenadeTooCloseDebouncer", Q_irand(300, 600));
+
+			vec3_t		mins;
+			vec3_t		maxs;
+			bool		fled = false;
+			gentity_t*	ent;
+
+			gentity_t	*entityList[MAX_GENTITIES];
+
+			for (int i = 0 ; i < 3 ; i++ ) 
+			{
+				mins[i] = NPC->currentOrigin[i] - 200;
+				maxs[i] = NPC->currentOrigin[i] + 200;
+			}
+
+			int	numListedEntities = gi.EntitiesInBox( mins, maxs, entityList, MAX_GENTITIES );
+
+			for (int e = 0 ; e < numListedEntities ; e++ ) 
+			{
+				ent = entityList[ e ];
+
+				if (ent == NPC)
+					continue;
+				if (ent->owner == NPC)
+					continue;
+				if ( !(ent->inuse) )
+					continue;
+				if ( ent->s.eType == ET_MISSILE )
+				{
+					if ( ent->s.weapon == WP_THERMAL )
+					{//a thermal 
+						if ( ent->has_bounced && (!ent->owner || !OnSameTeam(ent->owner, NPC)))
+						{//bounced and an enemy thermal
+							ST_Speech( NPC, SPEECH_COVER, 0 );//FIXME: flee sound?
+							NPC_StartFlee(NPC->enemy, ent->currentOrigin, AEL_DANGER_GREAT, 1000, 2000);
+							fled = true;
+//							cpFlags |= (CP_CLEAR|CP_COVER);	// NOPE, Can't See The Enemy, So Find A New Combat Point
+							TIMER_Set (NPC, "checkGrenadeTooCloseDebouncer", Q_irand(2000, 4000));
+							break;
+						}
+					}
+				}
+			}
+			if (fled)
+			{
+				continue;
+			}
+		}
+
+
+		// Check To See We Have A Clear Shot To The Enemy Every Couple Seconds
+		//---------------------------------------------------------------------
+		if (TIMER_Done( NPC, "checkEnemyVisDebouncer" ))
+		{
+			TIMER_Set (NPC, "checkEnemyVisDebouncer", Q_irand(3000, 7000));
+			if (!NPC_ClearLOS(NPC->enemy))
+			{
+				cpFlags |= (CP_CLEAR|CP_COVER);	// NOPE, Can't See The Enemy, So Find A New Combat Point
+			}
+		}
+
+		// Check To See If The Enemy Is Too Close For Comfort
+		//----------------------------------------------------
+		if (NPC->client->NPC_class!=CLASS_ASSASSIN_DROID)
+		{
+			if (TIMER_Done(NPC, "checkEnemyTooCloseDebouncer"))
+			{
+				TIMER_Set (NPC, "checkEnemyTooCloseDebouncer", Q_irand(1000, 6000));
+
+				float distThreshold = 16384/*128*128*/;//default
+				switch ( NPC->s.weapon )
+				{
+				case WP_ROCKET_LAUNCHER:
+				case WP_FLECHETTE:
+				case WP_THERMAL:
+				case WP_TRIP_MINE:
+				case WP_DET_PACK:
+					distThreshold = 65536/*256*256*/;
+					break;
+				case WP_REPEATER:
+					if ( NPCInfo->scriptFlags&SCF_ALT_FIRE )
+					{
+						distThreshold = 65536/*256*256*/;
+					}
+					break;
+				case WP_CONCUSSION:
+					if ( !(NPCInfo->scriptFlags&SCF_ALT_FIRE) )
+					{
+						distThreshold = 65536/*256*256*/;
+					}
+					break;
+				default:
+					break;
+				}
+	
+				if ( DistanceSquared( group->enemy->currentOrigin, NPC->currentOrigin ) < distThreshold )
+				{
+					cpFlags |= (CP_CLEAR|CP_COVER);
+				}
+			}
+		}
+
+
+		//clear the local state
+		NPCInfo->localState = LSTATE_NONE;
+
+		cpFlags &= ~CP_NEAREST;
+		//Assign combat points
+		if ( cpFlags )
+		{//we want to run to a combat point
+			//always avoid enemy when picking combat points, and we always want to be able to get there
+			cpFlags		|= CP_AVOID_ENEMY|CP_HAS_ROUTE|CP_TRYFAR;
+			avoidDist	 = 200;
+			cpFlags_org  = cpFlags;			//remember what we *wanted* to do...
+
+			//now get a combat point
+			if ( cp == -1 )
+			{//may have had sone set above
+				cp = NPC_FindCombatPointRetry( NPC->currentOrigin, NPC->currentOrigin, NPC->currentOrigin, &cpFlags, avoidDist, NPCInfo->lastFailedCombatPoint );
+			}
+
+			//see if we got a valid one
+			if ( cp != -1 )
+			{//found a combat point
+				//let others know that someone is now running
+				runner = qtrue;
+				//don't change course again until we get to where we're going
+				TIMER_Set( NPC, "roamTime", Q3_INFINITE );
+
+
+				NPC_SetCombatPoint( cp );
+				NPC_SetMoveGoal( NPC, level.combatPoints[cp].origin, 8, qtrue, cp );
+
+				// If Successfully
+				if ((cpFlags&CP_FLANK) || ((cpFlags&CP_COVER) && (cpFlags&CP_CLEAR)))
+				{
+				}
+				else if (Q_irand(0,3)==0)
+				{
+					NPCInfo->aiFlags |= NPCAI_STOP_AT_LOS;
+				}
+
+				//okay, try a move right now to see if we can even get there
+				if ( (cpFlags&CP_FLANK) )
+				{
+					if ( group->numGroup > 1 )
+					{
+						NPC_ST_StoreMovementSpeech( SPEECH_OUTFLANK, -1 );
+					}
+				}
+				else if ( (cpFlags&CP_COVER) && !(cpFlags&CP_CLEAR) )
+				{//going into hiding
+					NPC_ST_StoreMovementSpeech( SPEECH_COVER, -1 );
+				}
+				else
+				{
+					if ( !Q_irand( 0, 20 ) )
+					{//hell, we're loading the sounds, use them every now and then!
+						if ( Q_irand( 0, 1 ) )
+						{
+							NPC_ST_StoreMovementSpeech( SPEECH_OUTFLANK, -1 );
+						}
+						else
+						{
+							NPC_ST_StoreMovementSpeech( SPEECH_ESCAPING, -1 );
+						}
+					}
+				}
+			}
+		}
+	}
+
+	RestoreNPCGlobals();
+	return;
+}
+
+extern void G_Knockdown( gentity_t *self, gentity_t *attacker, const vec3_t pushDir, float strength, qboolean breakSaberLock );
+void Noghri_StickTrace( void )
+{
+	if ( !NPC->ghoul2.size() 
+		|| NPC->weaponModel[0] <= 0 )
+	{
+		return;
+	}
+
+	int			boltIndex = gi.G2API_AddBolt(&NPC->ghoul2[NPC->weaponModel[0]], "*weapon");
+	if ( boltIndex != -1 )
+	{
+		int curTime = (cg.time?cg.time:level.time);
+		qboolean hit = qfalse;
+		int	lastHit = ENTITYNUM_NONE;
+		for ( int time = curTime-25; time <= curTime+25&&!hit; time += 25 )
+		{
+			mdxaBone_t	boltMatrix;
+			vec3_t		tip, dir, base, angles={0,NPC->currentAngles[YAW],0};
+			vec3_t		mins={-2,-2,-2},maxs={2,2,2};
+			trace_t		trace;
+
+			gi.G2API_GetBoltMatrix( NPC->ghoul2, NPC->weaponModel[0], 
+						boltIndex,
+						&boltMatrix, angles, NPC->currentOrigin, time,
+						NULL, NPC->s.modelScale );
+			gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, base );
+			gi.G2API_GiveMeVectorFromMatrix( boltMatrix, POSITIVE_Y, dir );
+			VectorMA( base, 48, dir, tip );
+	#ifndef FINAL_BUILD
+			if ( d_saberCombat->integer > 1 )
+			{
+				G_DebugLine(base, tip, FRAMETIME, 0x000000ff, qtrue);
+			}
+	#endif
+			gi.trace( &trace, base, mins, maxs, tip, NPC->s.number, MASK_SHOT, G2_RETURNONHIT, 10 );
+			if ( trace.fraction < 1.0f && trace.entityNum != lastHit )
+			{//hit something
+				gentity_t *traceEnt = &g_entities[trace.entityNum];
+				if ( traceEnt->takedamage 
+					&& (!traceEnt->client || traceEnt == NPC->enemy || traceEnt->client->NPC_class != NPC->client->NPC_class) )
+				{//smack
+					int dmg = Q_irand( 12, 20 );//FIXME: base on skill!
+					//FIXME: debounce?
+					G_Sound( traceEnt, G_SoundIndex( va( "sound/weapons/tusken_staff/stickhit%d.wav", Q_irand( 1, 4 ) ) ) );
+					G_Damage( traceEnt, NPC, NPC, vec3_origin, trace.endpos, dmg, DAMAGE_NO_KNOCKBACK, MOD_MELEE );
+					if ( traceEnt->health > 0 && dmg > 17 )
+					{//do pain on enemy
+						G_Knockdown( traceEnt, NPC, dir, 300, qtrue );
+					}
+					lastHit = trace.entityNum;
+					hit = qtrue;
+				}
+			}
+		}
+	}
+}
+/*
+-------------------------
+NPC_BSST_Attack
+-------------------------
+*/
+
+void NPC_BSST_Attack( void )
+{
+	//Don't do anything if we're hurt
+	if ( NPC->painDebounceTime > level.time )
+	{
+		NPC_UpdateAngles( qtrue, qtrue );
+		return;
+	}
+
+	//NPC_CheckEnemy( qtrue, qfalse );
+	//If we don't have an enemy, just idle
+	if ( NPC_CheckEnemyExt() == qfalse )//!NPC->enemy )//
+	{
+		if( NPC->client->playerTeam == TEAM_PLAYER )
+		{
+			NPC_BSPatrol();
+		}
+		else
+		{
+			NPC_BSST_Patrol();//FIXME: or patrol?
+		}
+		return;
+	}
+
+	//FIXME: put some sort of delay into the guys depending on how they saw you...?
+
+	//Get our group info
+	if ( TIMER_Done( NPC, "interrogating" ) )
+	{
+		AI_GetGroup( NPC );//, 45, 512, NPC->enemy );
+	}
+	else
+	{
+		//FIXME: when done interrogating, I should send out a team alert!
+	}
+
+	if ( NPCInfo->group )
+	{//I belong to a squad of guys - we should *always* have a group
+		if ( !NPCInfo->group->processed )
+		{//I'm the first ent in my group, I'll make the command decisions
+#if	AI_TIMERS
+			int	startTime = GetTime(0);
+#endif//	AI_TIMERS
+			ST_Commander();
+#if	AI_TIMERS
+			int commTime = GetTime ( startTime );
+			if ( commTime > 20 )
+			{
+				gi.Printf( S_COLOR_RED"ERROR: Commander time: %d\n", commTime );
+			}
+			else if ( commTime > 10 )
+			{
+				gi.Printf( S_COLOR_YELLOW"WARNING: Commander time: %d\n", commTime );
+			}
+			else if ( commTime > 2 )
+			{
+				gi.Printf( S_COLOR_GREEN"Commander time: %d\n", commTime );
+			}
+#endif//	AI_TIMERS
+		}
+	}
+	else if ( TIMER_Done( NPC, "flee" ) && NPC_CheckForDanger( NPC_CheckAlertEvents( qtrue, qtrue, -1, qfalse, AEL_DANGER ) ) )
+	{//not already fleeing, and going to run
+		ST_Speech( NPC, SPEECH_COVER, 0 );
+		NPC_UpdateAngles( qtrue, qtrue );
+		return;
+	}
+
+	if ( !NPC->enemy )
+	{//WTF?  somehow we lost our enemy?
+		NPC_BSST_Patrol();//FIXME: or patrol?
+		return;
+	}
+
+	if (NPCInfo->goalEntity && NPCInfo->goalEntity!=NPC->enemy)
+	{
+        NPCInfo->goalEntity = UpdateGoal();
+	}
+
+
+	enemyLOS = enemyCS = enemyInFOV = qfalse;
+	move = qtrue;
+	faceEnemy = qfalse;
+	shoot = qfalse;
+	hitAlly = qfalse;
+	VectorClear( impactPos );
+	enemyDist = DistanceSquared( NPC->currentOrigin, NPC->enemy->currentOrigin );
+
+	vec3_t	enemyDir, shootDir;
+	VectorSubtract( NPC->enemy->currentOrigin, NPC->currentOrigin, enemyDir );
+	VectorNormalize( enemyDir );
+	AngleVectors( NPC->client->ps.viewangles, shootDir, NULL, NULL );
+	float dot = DotProduct( enemyDir, shootDir );
+	if ( dot > 0.5f ||( enemyDist * (1.0f-dot)) < 10000 )
+	{//enemy is in front of me or they're very close and not behind me
+		enemyInFOV = qtrue;
+	}
+
+	if ( enemyDist < MIN_ROCKET_DIST_SQUARED )//128
+	{//enemy within 128
+		if ( (NPC->client->ps.weapon == WP_FLECHETTE || NPC->client->ps.weapon == WP_REPEATER) && 
+			(NPCInfo->scriptFlags & SCF_ALT_FIRE) )
+		{//shooting an explosive, but enemy too close, switch to primary fire
+			NPCInfo->scriptFlags &= ~SCF_ALT_FIRE;
+			//FIXME: we can never go back to alt-fire this way since, after this, we don't know if we were initially supposed to use alt-fire or not...
+		}
+	}
+	else if ( enemyDist > 65536 )//256 squared
+	{
+		if ( NPC->client->ps.weapon == WP_DISRUPTOR )
+		{//sniping... 
+			if ( !(NPCInfo->scriptFlags&SCF_ALT_FIRE) )
+			{//use primary fire
+				NPCInfo->scriptFlags |= SCF_ALT_FIRE;
+				//reset fire-timing variables
+				NPC_ChangeWeapon( NPC->client->ps.weapon );
+				NPC_UpdateAngles( qtrue, qtrue );
+				return;
+			}
+		}
+	}
+
+	//can we see our target?
+	if ( NPC_ClearLOS( NPC->enemy ) )
+	{
+		AI_GroupUpdateEnemyLastSeen( NPCInfo->group, NPC->enemy->currentOrigin );
+		NPCInfo->enemyLastSeenTime = level.time;
+		enemyLOS = qtrue;
+
+		if ( NPC->client->ps.weapon == WP_NONE )
+		{
+			enemyCS = qfalse;//not true, but should stop us from firing
+			NPC_AimAdjust( -1 );//adjust aim worse longer we have no weapon
+		}
+		else
+		{//can we shoot our target?
+			if ((enemyDist < MIN_ROCKET_DIST_SQUARED) &&
+				((level.time - NPC->lastMoveTime)<5000) &&
+				(
+				(NPC->client->ps.weapon == WP_ROCKET_LAUNCHER 
+				|| (NPC->client->ps.weapon == WP_CONCUSSION && !(NPCInfo->scriptFlags&SCF_ALT_FIRE))
+				|| (NPC->client->ps.weapon == WP_FLECHETTE && (NPCInfo->scriptFlags&SCF_ALT_FIRE)))))
+			{
+				enemyCS = qfalse;//not true, but should stop us from firing
+				hitAlly = qtrue;//us!
+				//FIXME: if too close, run away!
+			}
+			else if ( enemyInFOV )
+			{//if enemy is FOV, go ahead and check for shooting
+				int hit = NPC_ShotEntity( NPC->enemy, impactPos );
+				gentity_t *hitEnt = &g_entities[hit];
+
+				if ( hit == NPC->enemy->s.number 
+					|| ( hitEnt && hitEnt->client && hitEnt->client->playerTeam == NPC->client->enemyTeam )
+					|| ( hitEnt && hitEnt->takedamage && ((hitEnt->svFlags&SVF_GLASS_BRUSH)||hitEnt->health < 40||NPC->s.weapon == WP_EMPLACED_GUN) ) )
+				{//can hit enemy or enemy ally or will hit glass or other minor breakable (or in emplaced gun), so shoot anyway
+					AI_GroupUpdateClearShotTime( NPCInfo->group );
+					enemyCS = qtrue;
+					NPC_AimAdjust( 2 );//adjust aim better longer we have clear shot at enemy
+					VectorCopy( NPC->enemy->currentOrigin, NPCInfo->enemyLastSeenLocation );
+				}
+				else
+				{//Hmm, have to get around this bastard
+					NPC_AimAdjust( 1 );//adjust aim better longer we can see enemy
+					ST_ResolveBlockedShot( hit );
+					if ( hitEnt && hitEnt->client && hitEnt->client->playerTeam == NPC->client->playerTeam )
+					{//would hit an ally, don't fire!!!
+						hitAlly = qtrue;
+					}
+					else
+					{//Check and see where our shot *would* hit... if it's not close to the enemy (within 256?), then don't fire
+					}
+				}
+			}
+			else
+			{
+				enemyCS = qfalse;//not true, but should stop us from firing
+			}
+		}
+	}
+	else if ( gi.inPVS( NPC->enemy->currentOrigin, NPC->currentOrigin ) )
+	{
+		NPCInfo->enemyLastSeenTime = level.time;
+		faceEnemy = qtrue;
+		NPC_AimAdjust( -1 );//adjust aim worse longer we cannot see enemy
+	}
+
+	if ( NPC->client->ps.weapon == WP_NONE )
+	{
+		faceEnemy = qfalse;
+		shoot = qfalse;
+	}
+	else
+	{
+		if ( enemyLOS )
+		{//FIXME: no need to face enemy if we're moving to some other goal and he's too far away to shoot?
+			faceEnemy = qtrue;
+		}
+		if ( enemyCS )
+		{
+			shoot = qtrue;
+		}
+	}
+
+	//Check for movement to take care of
+	ST_CheckMoveState();
+
+	//See if we should override shooting decision with any special considerations
+	ST_CheckFireState();
+
+	if ( faceEnemy )
+	{//face the enemy
+		NPC_FaceEnemy( qtrue );
+	}
+
+	if ( !(NPCInfo->scriptFlags&SCF_CHASE_ENEMIES) )
+	{//not supposed to chase my enemies
+		if ( NPCInfo->goalEntity == NPC->enemy )
+		{//goal is my entity, so don't move
+			move = qfalse;
+		}
+	}
+	else if (NPC->NPC->scriptFlags&SCF_NO_GROUPS)
+	{
+			//	NPCInfo->goalEntity = UpdateGoal();
+
+ 		NPCInfo->goalEntity = (enemyLOS)?(0):(NPC->enemy);
+	}
+
+	if ( NPC->client->fireDelay && NPC->s.weapon == WP_ROCKET_LAUNCHER )
+	{
+		move = qfalse;
+	}
+
+	if ( !ucmd.rightmove )
+	{//only if not already strafing for some strange reason...?
+		//NOTE: these are never set here, but can be set in AI_Jedi.cpp for those NPCs who are sort of Stormtrooper/Jedi hybrids
+		//NOTE: this stomps navigation movement entirely!
+		//FIXME: if enemy behind me and turning to face enemy, don't strafe in that direction, too
+		if ( !TIMER_Done( NPC, "strafeLeft" ) )
+		{
+			/*
+			if ( NPCInfo->desiredYaw > NPC->client->ps.viewangles[YAW] + 60 )
+			{//we want to turn left, don't apply the strafing
+			}
+			else
+			*/
+			{//go ahead and strafe left
+				ucmd.rightmove = -127;
+				//re-check the duck as we might want to be rolling
+				VectorClear( NPC->client->ps.moveDir );
+				move = qfalse;
+			}
+		}
+		else if ( !TIMER_Done( NPC, "strafeRight" ) )
+		{
+			/*if ( NPCInfo->desiredYaw < NPC->client->ps.viewangles[YAW] - 60 )
+			{//we want to turn right, don't apply the strafing
+			}
+			else
+			*/
+			{//go ahead and strafe left
+				ucmd.rightmove = 127;
+				VectorClear( NPC->client->ps.moveDir );
+				move = qfalse;
+			}
+		}
+	}
+
+	if ( NPC->client->ps.legsAnim == BOTH_GUARD_LOOKAROUND1 )
+	{//don't move when doing silly look around thing
+		move = qfalse;
+	}
+	if ( move )
+	{//move toward goal
+		if ( NPCInfo->goalEntity )//&& ( NPCInfo->goalEntity != NPC->enemy || enemyDist > 10000 ) )//100 squared
+		{
+			move = ST_Move();
+			if ( (NPC->client->NPC_class != CLASS_ROCKETTROOPER||NPC->s.weapon!=WP_ROCKET_LAUNCHER||enemyDist<MIN_ROCKET_DIST_SQUARED)//rockettroopers who use rocket launchers turn around and run if you get too close (closer than 128)
+				&& ucmd.forwardmove <= -32 )
+			{//moving backwards at least 45 degrees
+				if ( NPCInfo->goalEntity 
+					&& DistanceSquared( NPCInfo->goalEntity->currentOrigin, NPC->currentOrigin ) > MIN_TURN_AROUND_DIST_SQ )
+				{//don't stop running backwards if your goal is less than 100 away
+					if ( TIMER_Done( NPC, "runBackwardsDebounce" ) )
+					{//not already waiting for next run backwards
+						if ( !TIMER_Exists( NPC, "runningBackwards" ) )
+						{//start running backwards
+							TIMER_Set( NPC, "runningBackwards", Q_irand( 500, 1000 ) );//Q_irand( 2000, 3500 ) );
+						}
+						else if ( TIMER_Done2( NPC, "runningBackwards", qtrue ) )
+						{//done running backwards
+							TIMER_Set( NPC, "runBackwardsDebounce", Q_irand( 3000, 5000 ) );
+						}
+					}
+				}
+			}
+			else
+			{//not running backwards
+				//TIMER_Remove( NPC, "runningBackwards" );
+			}
+		}
+		else
+		{
+			move = qfalse;
+		}
+	}
+
+	if ( !move )
+	{
+		if (NPC->client->NPC_class != CLASS_ASSASSIN_DROID)
+		{
+			if ( !TIMER_Done( NPC, "duck" ) )
+			{
+				ucmd.upmove = -127;
+			}
+		}
+		//FIXME: what about leaning?
+	}
+	else
+	{//stop ducking!
+		TIMER_Set( NPC, "duck", -1 );
+	}
+	
+	if ( NPC->client->NPC_class == CLASS_REBORN//cultist using a gun
+		&& NPCInfo->rank >= RANK_LT_COMM //commando or better
+		&& NPC->enemy->s.weapon == WP_SABER )//fighting a saber-user
+	{//commando saboteur vs. jedi/reborn
+		//see if we need to avoid their saber
+		NPC_EvasionSaber();
+	}
+
+	if ( //!TIMER_Done( NPC, "flee" ) ||
+		(move&&!TIMER_Done( NPC, "runBackwardsDebounce" )) )
+	{//running away
+		faceEnemy = qfalse;
+	}
+
+	//FIXME: check scf_face_move_dir here?
+
+	if ( !faceEnemy )
+	{//we want to face in the dir we're running
+		if ( !move )
+		{//if we haven't moved, we should look in the direction we last looked?
+			VectorCopy( NPC->client->ps.viewangles, NPCInfo->lastPathAngles );
+		}
+		NPCInfo->desiredYaw = NPCInfo->lastPathAngles[YAW];
+		NPCInfo->desiredPitch = 0;
+		NPC_UpdateAngles( qtrue, qtrue );
+		if ( move )
+		{//don't run away and shoot
+			shoot = qfalse;
+		}
+	}
+
+	if ( NPCInfo->scriptFlags & SCF_DONT_FIRE )
+	{
+		shoot = qfalse;
+	}
+
+	if ( NPC->enemy && NPC->enemy->enemy )
+	{
+		if ( NPC->enemy->s.weapon == WP_SABER && NPC->enemy->enemy->s.weapon == WP_SABER )
+		{//don't shoot at an enemy jedi who is fighting another jedi, for fear of injuring one or causing rogue blaster deflections (a la Obi Wan/Vader duel at end of ANH)
+			shoot = qfalse;
+		}
+	}
+	//FIXME: don't shoot right away!
+	if ( NPC->client->fireDelay )
+	{
+		if ( NPC->client->NPC_class == CLASS_SABOTEUR )
+		{
+			Saboteur_Decloak( NPC );
+		}
+		if ( NPC->s.weapon == WP_ROCKET_LAUNCHER 
+			|| (NPC->s.weapon==WP_CONCUSSION&&!(NPCInfo->scriptFlags&SCF_ALT_FIRE)) )
+		{
+			if ( !enemyLOS || !enemyCS )
+			{//cancel it
+				NPC->client->fireDelay = 0;
+			}
+			else
+			{//delay our next attempt
+				TIMER_Set( NPC, "attackDelay", Q_irand( 3000, 5000 ) );
+			}
+		}
+	}
+	else if ( shoot )
+	{//try to shoot if it's time
+		if ( NPC->client->NPC_class == CLASS_SABOTEUR )
+		{
+			Saboteur_Decloak( NPC );
+		}
+		if ( TIMER_Done( NPC, "attackDelay" ) )
+		{
+			if( !(NPCInfo->scriptFlags & SCF_FIRE_WEAPON) ) // we've already fired, no need to do it again here
+			{
+				WeaponThink( qtrue );
+			}
+			//NASTY
+			if ( NPC->s.weapon == WP_ROCKET_LAUNCHER )
+			{
+				if ( (ucmd.buttons&BUTTON_ATTACK) 
+					&& !move
+					&& g_spskill->integer > 1 
+					&& !Q_irand( 0, 3 ) )
+				{//every now and then, shoot a homing rocket
+					ucmd.buttons &= ~BUTTON_ATTACK;
+					ucmd.buttons |= BUTTON_ALT_ATTACK;
+					NPC->client->fireDelay = Q_irand( 1000, 2500 );
+				}
+			}
+			else if ( NPC->s.weapon == WP_NOGHRI_STICK 
+				&& enemyDist < (48*48) )//?
+			{
+				ucmd.buttons &= ~BUTTON_ATTACK;
+				ucmd.buttons |= BUTTON_ALT_ATTACK;
+				NPC->client->fireDelay = Q_irand( 1500, 2000 );
+			}
+		}
+	}
+	else
+	{
+		if ( NPC->attackDebounceTime < level.time )
+		{
+			if ( NPC->client->NPC_class == CLASS_SABOTEUR )
+			{
+				Saboteur_Cloak( NPC );
+			}
+		}
+	}
+}
+
+extern qboolean G_TuskenAttackAnimDamage( gentity_t *self );
+void NPC_BSST_Default( void )
+{
+	if( NPCInfo->scriptFlags & SCF_FIRE_WEAPON )
+	{
+		WeaponThink( qtrue );
+	}
+	
+	if ( NPC->s.weapon == WP_NOGHRI_STICK )
+	{
+		if ( G_TuskenAttackAnimDamage( NPC ) )
+		{
+			Noghri_StickTrace();
+		}
+	}
+
+	if( !NPC->enemy )
+	{//don't have an enemy, look for one
+		NPC_BSST_Patrol();
+	}
+	else //if ( NPC->enemy )
+	{//have an enemy
+		if ( NPC->enemy->client //enemy is a client
+			&& (NPC->enemy->client->NPC_class == CLASS_UGNAUGHT || NPC->enemy->client->NPC_class == CLASS_JAWA )//enemy is a lowly jawa or ugnaught
+			&& NPC->enemy->enemy != NPC//enemy's enemy is not me
+			&& (!NPC->enemy->enemy || !NPC->enemy->enemy->client || (NPC->enemy->enemy->client->NPC_class!=CLASS_RANCOR&&NPC->enemy->enemy->client->NPC_class!=CLASS_WAMPA)) )//enemy's enemy is not a client or is not a wampa or rancor (which is scarier than me)
+		{//they should be scared of ME and no-one else
+			G_SetEnemy( NPC->enemy, NPC );
+		}
+		NPC_CheckGetNewWeapon();
+		NPC_BSST_Attack();
+	}
+}
diff --git a/code/game/AI_Tusken.cpp b/code/game/AI_Tusken.cpp
new file mode 100644
index 0000000..204ced7
--- /dev/null
+++ b/code/game/AI_Tusken.cpp
@@ -0,0 +1,512 @@
+// leave this line at the top of all AI_xxxx.cpp files for PCH reasons...
+#include "g_headers.h"
+
+
+#include "b_local.h"
+#include "g_nav.h"
+#include "anims.h"
+#include "g_navigator.h"
+
+extern void CG_DrawAlert( vec3_t origin, float rating );
+extern void G_AddVoiceEvent( gentity_t *self, int event, int speakDebounceTime );
+extern void NPC_TempLookTarget( gentity_t *self, int lookEntNum, int minLookTime, int maxLookTime );
+extern qboolean G_ExpandPointToBBox( vec3_t point, const vec3_t mins, const vec3_t maxs, int ignore, int clipmask );
+extern void NPC_AimAdjust( int change );
+extern qboolean FlyingCreature( gentity_t *ent );
+extern int PM_AnimLength( int index, animNumber_t anim );
+
+
+#define	MAX_VIEW_DIST		1024
+#define MAX_VIEW_SPEED		250
+#define	MAX_LIGHT_INTENSITY 255
+#define	MIN_LIGHT_THRESHOLD	0.1
+
+#define	DISTANCE_SCALE		0.25f
+#define	DISTANCE_THRESHOLD	0.075f
+#define	SPEED_SCALE			0.25f
+#define	FOV_SCALE			0.5f
+#define	LIGHT_SCALE			0.25f
+
+#define	REALIZE_THRESHOLD	0.6f
+#define CAUTIOUS_THRESHOLD	( REALIZE_THRESHOLD * 0.75 )
+
+qboolean NPC_CheckPlayerTeamStealth( void );
+
+static qboolean enemyLOS;
+static qboolean enemyCS;
+static qboolean faceEnemy;
+static qboolean move;
+static qboolean shoot;
+static float	enemyDist;
+
+//Local state enums
+enum
+{
+	LSTATE_NONE = 0,
+	LSTATE_UNDERFIRE,
+	LSTATE_INVESTIGATE,
+};
+
+/*
+-------------------------
+NPC_Tusken_Precache
+-------------------------
+*/
+void NPC_Tusken_Precache( void )
+{
+	int i;
+	for ( i = 1; i < 5; i ++ )
+	{
+		G_SoundIndex( va( "sound/weapons/tusken_staff/stickhit%d.wav", i ) );
+	}
+}
+
+void Tusken_ClearTimers( gentity_t *ent )
+{
+	TIMER_Set( ent, "chatter", 0 );
+	TIMER_Set( ent, "duck", 0 );
+	TIMER_Set( ent, "stand", 0 );
+	TIMER_Set( ent, "shuffleTime", 0 );
+	TIMER_Set( ent, "sleepTime", 0 );
+	TIMER_Set( ent, "enemyLastVisible", 0 );
+	TIMER_Set( ent, "roamTime", 0 );
+	TIMER_Set( ent, "hideTime", 0 );
+	TIMER_Set( ent, "attackDelay", 0 );	//FIXME: Slant for difficulty levels
+	TIMER_Set( ent, "stick", 0 );
+	TIMER_Set( ent, "scoutTime", 0 );
+	TIMER_Set( ent, "flee", 0 );
+	TIMER_Set( ent, "taunting", 0 );
+}
+
+void NPC_Tusken_PlayConfusionSound( gentity_t *self )
+{//FIXME: make this a custom sound in sound set
+	if ( self->health > 0 )
+	{
+		G_AddVoiceEvent( self, Q_irand(EV_CONFUSE1, EV_CONFUSE3), 2000 );
+	}
+	//reset him to be totally unaware again
+	TIMER_Set( self, "enemyLastVisible", 0 );
+	TIMER_Set( self, "flee", 0 );
+	self->NPC->squadState = SQUAD_IDLE;
+	self->NPC->tempBehavior = BS_DEFAULT;
+	
+	//self->NPC->behaviorState = BS_PATROL;
+	G_ClearEnemy( self );//FIXME: or just self->enemy = NULL;?
+
+	self->NPC->investigateCount = 0;
+}
+
+
+/*
+-------------------------
+NPC_ST_Pain
+-------------------------
+*/
+
+void NPC_Tusken_Pain( gentity_t *self, gentity_t *inflictor, gentity_t *other, vec3_t point, int damage, int mod ) 
+{
+	self->NPC->localState = LSTATE_UNDERFIRE;
+
+	TIMER_Set( self, "duck", -1 );
+	TIMER_Set( self, "stand", 2000 );
+
+	NPC_Pain( self, inflictor, other, point, damage, mod );
+
+	if ( !damage && self->health > 0 )
+	{//FIXME: better way to know I was pushed
+		G_AddVoiceEvent( self, Q_irand(EV_PUSHED1, EV_PUSHED3), 2000 );
+	}
+}
+
+/*
+-------------------------
+ST_HoldPosition
+-------------------------
+*/
+
+static void Tusken_HoldPosition( void )
+{
+	NPC_FreeCombatPoint( NPCInfo->combatPoint, qtrue );
+	NPCInfo->goalEntity = NULL;
+}
+
+/*
+-------------------------
+ST_Move
+-------------------------
+*/
+
+static qboolean Tusken_Move( void )
+{
+	NPCInfo->combatMove = qtrue;//always move straight toward our goal
+
+	qboolean	moved = NPC_MoveToGoal( qtrue );
+
+	//If our move failed, then reset
+	if ( moved == qfalse )
+	{//couldn't get to enemy
+		//just hang here
+		Tusken_HoldPosition();
+	}
+
+	return moved;
+}
+
+/*
+-------------------------
+NPC_BSTusken_Patrol
+-------------------------
+*/
+
+void NPC_BSTusken_Patrol( void )
+{//FIXME: pick up on bodies of dead buddies?
+	if ( NPCInfo->confusionTime < level.time )
+	{
+		//Look for any enemies
+		if ( NPCInfo->scriptFlags&SCF_LOOK_FOR_ENEMIES )
+		{
+			if ( NPC_CheckPlayerTeamStealth() )
+			{
+				//NPC_AngerSound();
+				NPC_UpdateAngles( qtrue, qtrue );
+				return;
+			}
+		}
+
+		if ( !(NPCInfo->scriptFlags&SCF_IGNORE_ALERTS) )
+		{
+			//Is there danger nearby
+			int alertEvent = NPC_CheckAlertEvents( qtrue, qtrue, -1, qfalse, AEL_SUSPICIOUS );
+			if ( NPC_CheckForDanger( alertEvent ) )
+			{
+				NPC_UpdateAngles( qtrue, qtrue );
+				return;
+			}
+			else
+			{//check for other alert events
+				//There is an event to look at
+				if ( alertEvent >= 0 )//&& level.alertEvents[alertEvent].ID != NPCInfo->lastAlertID )
+				{
+					//NPCInfo->lastAlertID = level.alertEvents[alertEvent].ID;
+					if ( level.alertEvents[alertEvent].level == AEL_DISCOVERED )
+					{
+						if ( level.alertEvents[alertEvent].owner && 
+							level.alertEvents[alertEvent].owner->client && 
+							level.alertEvents[alertEvent].owner->health >= 0 &&
+							level.alertEvents[alertEvent].owner->client->playerTeam == NPC->client->enemyTeam )
+						{//an enemy
+							G_SetEnemy( NPC, level.alertEvents[alertEvent].owner );
+							//NPCInfo->enemyLastSeenTime = level.time;
+							TIMER_Set( NPC, "attackDelay", Q_irand( 500, 2500 ) );
+						}
+					}
+					else
+					{//FIXME: get more suspicious over time?
+						//Save the position for movement (if necessary)
+						VectorCopy( level.alertEvents[alertEvent].position, NPCInfo->investigateGoal );
+						NPCInfo->investigateDebounceTime = level.time + Q_irand( 500, 1000 );
+						if ( level.alertEvents[alertEvent].level == AEL_SUSPICIOUS )
+						{//suspicious looks longer
+							NPCInfo->investigateDebounceTime += Q_irand( 500, 2500 );
+						}
+					}
+				}
+			}
+
+			if ( NPCInfo->investigateDebounceTime > level.time )
+			{//FIXME: walk over to it, maybe?  Not if not chase enemies
+				//NOTE: stops walking or doing anything else below
+				vec3_t	dir, angles;
+				float	o_yaw, o_pitch;
+				
+				VectorSubtract( NPCInfo->investigateGoal, NPC->client->renderInfo.eyePoint, dir );
+				vectoangles( dir, angles );
+				
+				o_yaw = NPCInfo->desiredYaw;
+				o_pitch = NPCInfo->desiredPitch;
+				NPCInfo->desiredYaw = angles[YAW];
+				NPCInfo->desiredPitch = angles[PITCH];
+				
+				NPC_UpdateAngles( qtrue, qtrue );
+
+				NPCInfo->desiredYaw = o_yaw;
+				NPCInfo->desiredPitch = o_pitch;
+				return;
+			}
+		}
+	}
+
+	//If we have somewhere to go, then do that
+	if ( UpdateGoal() )
+	{
+		ucmd.buttons |= BUTTON_WALKING;
+		NPC_MoveToGoal( qtrue );
+	}
+
+	NPC_UpdateAngles( qtrue, qtrue );
+}
+
+
+void NPC_Tusken_Taunt( void )
+{
+	NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_TUSKENTAUNT1, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+	TIMER_Set( NPC, "taunting", NPC->client->ps.torsoAnimTimer );
+	TIMER_Set( NPC, "duck", -1 );
+}
+
+/*
+-------------------------
+NPC_BSTusken_Attack
+-------------------------
+*/
+
+void NPC_BSTusken_Attack( void )
+{
+// IN PAIN
+//---------
+	if ( NPC->painDebounceTime > level.time )
+	{
+		NPC_UpdateAngles( qtrue, qtrue );
+		return;
+	}
+
+// IN FLEE
+//---------
+	if ( TIMER_Done( NPC, "flee" ) && NPC_CheckForDanger( NPC_CheckAlertEvents( qtrue, qtrue, -1, qfalse, AEL_DANGER ) ) )
+	{
+		NPC_UpdateAngles( qtrue, qtrue );
+		return;
+	}
+
+
+
+// UPDATE OUR ENEMY
+//------------------
+	if (NPC_CheckEnemyExt()==qfalse || !NPC->enemy)
+	{
+		NPC_BSTusken_Patrol();
+		return;
+	}
+	enemyDist	= Distance(NPC->enemy->currentOrigin, NPC->currentOrigin);
+
+	// Is The Current Enemy A Jawa?
+	//------------------------------
+	if (NPC->enemy->client && NPC->enemy->client->NPC_class==CLASS_JAWA)
+	{
+		// Make Sure His Enemy Is Me
+		//---------------------------
+		if (NPC->enemy->enemy!=NPC)
+		{
+			G_SetEnemy(NPC->enemy, NPC);
+		}
+
+		// Should We Forget About Our Current Enemy And Go After The Player?
+		//-------------------------------------------------------------------
+		if ((player) &&															// If There Is A Player Pointer
+			(player!=NPC->enemy) &&												// The Player Is Not Currently My Enemy
+			(Distance(player->currentOrigin, NPC->currentOrigin)<130.0f) &&		// The Player Is Close Enough
+			(NAV::InSameRegion(NPC, player))									// And In The Same Region
+			)
+		{
+			G_SetEnemy(NPC, player);
+		}
+	}
+
+	// Update Our Last Seen Time
+	//---------------------------
+	if (NPC_ClearLOS(NPC->enemy))
+	{
+		NPCInfo->enemyLastSeenTime = level.time;
+	}
+
+
+
+	// Check To See If We Are In Attack Range
+	//----------------------------------------
+ 	float	boundsMin	= (NPC->maxs[0]+NPC->enemy->maxs[0]);
+ 	float	lungeRange	= (boundsMin + 65.0f);
+	float	strikeRange = (boundsMin + 40.0f);
+	bool	meleeRange	= (enemyDist<lungeRange);
+	bool	meleeWeapon	= (NPC->client->ps.weapon!=WP_TUSKEN_RIFLE);
+	bool	canSeeEnemy = ((level.time - NPCInfo->enemyLastSeenTime)<3000);
+
+	// Check To Start Taunting
+	//-------------------------
+ 	if (canSeeEnemy && !meleeRange && TIMER_Done(NPC, "tuskenTauntCheck"))
+	{
+		TIMER_Set(NPC, "tuskenTauntCheck", Q_irand(2000, 6000));
+		if (!Q_irand(0,3))
+		{
+			NPC_Tusken_Taunt();
+		}
+	}
+
+
+	if (TIMER_Done(NPC, "taunting"))
+	{
+		// Should I Attack?
+		//------------------
+		if (meleeRange || (!meleeWeapon && canSeeEnemy))
+		{
+			if (!(NPCInfo->scriptFlags&SCF_FIRE_WEAPON) && 	// If This Flag Is On, It Calls Attack From Elsewhere
+				!(NPCInfo->scriptFlags&SCF_DONT_FIRE) &&	// If This Flag Is On, Don't Fire At All
+				 (TIMER_Done(NPC, "attackDelay"))
+				)
+			{
+				ucmd.buttons &= ~BUTTON_ALT_ATTACK;
+
+				// If Not In Strike Range, Do Lunge, Or If We Don't Have The Staff, Just Shoot Normally
+				//--------------------------------------------------------------------------------------
+				if (enemyDist > strikeRange)
+				{
+					ucmd.buttons |= BUTTON_ALT_ATTACK;
+				}
+
+				WeaponThink( qtrue );
+				TIMER_Set(NPC, "attackDelay", NPCInfo->shotTime-level.time);
+			}
+
+			if ( !TIMER_Done( NPC, "duck" ) )
+			{
+				ucmd.upmove = -127;
+			}
+		}
+
+		// Or Should I Move?
+		//-------------------
+		else if (NPCInfo->scriptFlags & SCF_CHASE_ENEMIES)
+		{
+			NPCInfo->goalEntity = NPC->enemy;
+			NPCInfo->goalRadius = lungeRange;
+			Tusken_Move();
+		}
+	}
+
+
+// UPDATE ANGLES
+//---------------
+	if (canSeeEnemy)
+	{
+		NPC_FaceEnemy(qtrue);
+	}
+	NPC_UpdateAngles(qtrue, qtrue);
+}
+
+extern void G_Knockdown( gentity_t *self, gentity_t *attacker, const vec3_t pushDir, float strength, qboolean breakSaberLock );
+void Tusken_StaffTrace( void )
+{
+	if ( !NPC->ghoul2.size() 
+		|| NPC->weaponModel[0] <= 0 )
+	{
+		return;
+	}
+
+	int			boltIndex = gi.G2API_AddBolt(&NPC->ghoul2[NPC->weaponModel[0]], "*weapon");
+	if ( boltIndex != -1 )
+	{
+		int curTime = (cg.time?cg.time:level.time);
+		qboolean hit = qfalse;
+		int	lastHit = ENTITYNUM_NONE;
+		for ( int time = curTime-25; time <= curTime+25&&!hit; time += 25 )
+		{
+			mdxaBone_t	boltMatrix;
+			vec3_t		tip, dir, base, angles={0,NPC->currentAngles[YAW],0};
+			vec3_t		mins={-2,-2,-2},maxs={2,2,2};
+			trace_t		trace;
+
+			gi.G2API_GetBoltMatrix( NPC->ghoul2, NPC->weaponModel[0], 
+						boltIndex,
+						&boltMatrix, angles, NPC->currentOrigin, time,
+						NULL, NPC->s.modelScale );
+			gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, base );
+			gi.G2API_GiveMeVectorFromMatrix( boltMatrix, NEGATIVE_Y, dir );
+			VectorMA( base, -20, dir, base );
+			VectorMA( base, 78, dir, tip );
+	#ifndef FINAL_BUILD
+			if ( d_saberCombat->integer > 1 )
+			{
+				G_DebugLine(base, tip, 1000, 0x000000ff, qtrue);
+			}
+	#endif
+			gi.trace( &trace, base, mins, maxs, tip, NPC->s.number, MASK_SHOT, G2_RETURNONHIT, 10 );
+			if ( trace.fraction < 1.0f && trace.entityNum != lastHit )
+			{//hit something
+				gentity_t *traceEnt = &g_entities[trace.entityNum];
+				if ( traceEnt->takedamage 
+					&& (!traceEnt->client || traceEnt == NPC->enemy || traceEnt->client->NPC_class != NPC->client->NPC_class) )
+				{//smack
+					int dmg = Q_irand( 5, 10 ) * (g_spskill->integer+1);
+
+					//FIXME: debounce?
+					G_Sound( traceEnt, G_SoundIndex( va( "sound/weapons/tusken_staff/stickhit%d.wav", Q_irand( 1, 4 ) ) ) );
+					G_Damage( traceEnt, NPC, NPC, vec3_origin, trace.endpos, dmg, DAMAGE_NO_KNOCKBACK, MOD_MELEE );
+					if ( traceEnt->health > 0 
+						&& ( (traceEnt->client&&traceEnt->client->NPC_class==CLASS_JAWA&&!Q_irand(0,1))
+							|| dmg > 19 ) )//FIXME: base on skill!
+					{//do pain on enemy
+						G_Knockdown( traceEnt, NPC, dir, 300, qtrue );
+					}
+					lastHit = trace.entityNum;
+					hit = qtrue;
+				}
+			}
+		}
+	}
+}
+
+qboolean G_TuskenAttackAnimDamage( gentity_t *self )
+{
+ 	if (self->client->ps.torsoAnim==BOTH_TUSKENATTACK1 ||
+		self->client->ps.torsoAnim==BOTH_TUSKENATTACK2 ||
+		self->client->ps.torsoAnim==BOTH_TUSKENATTACK3 ||
+		self->client->ps.torsoAnim==BOTH_TUSKENLUNGE1)
+	{
+		float		current	  = 0.0f;
+		int			end		  = 0;
+		int			start	  = 0;
+		if (!!gi.G2API_GetBoneAnimIndex(&
+					self->ghoul2[self->playerModel], 
+					self->lowerLumbarBone, 
+					level.time, 
+					&current, 
+					&start, 
+					&end, 
+					NULL,
+					NULL,
+					NULL))
+		{
+ 			float percentComplete = (current-start)/(end-start);
+			//gi.Printf("%f\n", percentComplete);
+			switch (self->client->ps.torsoAnim)
+			{
+			case BOTH_TUSKENATTACK1: return (percentComplete>0.3 && percentComplete<0.7);
+			case BOTH_TUSKENATTACK2: return (percentComplete>0.3 && percentComplete<0.7);
+			case BOTH_TUSKENATTACK3: return (percentComplete>0.1 && percentComplete<0.5);
+			case BOTH_TUSKENLUNGE1:  return (percentComplete>0.3 && percentComplete<0.5);
+			}
+		}
+	}
+	return qfalse;
+}
+
+void NPC_BSTusken_Default( void )
+{
+	if( NPCInfo->scriptFlags & SCF_FIRE_WEAPON )
+	{
+		WeaponThink( qtrue );
+	}
+
+	if ( G_TuskenAttackAnimDamage( NPC ) )
+	{
+		Tusken_StaffTrace();
+	}
+
+	if( !NPC->enemy )
+	{//don't have an enemy, look for one
+		NPC_BSTusken_Patrol();
+	}
+	else//if ( NPC->enemy )
+	{//have an enemy
+		NPC_BSTusken_Attack();
+	}
+}
diff --git a/code/game/AI_Utils.cpp b/code/game/AI_Utils.cpp
new file mode 100644
index 0000000..ed3d098
--- /dev/null
+++ b/code/game/AI_Utils.cpp
@@ -0,0 +1,1055 @@
+// These utilities are meant for strictly non-player, non-team NPCs.  
+// These functions are in their own file because they are only intended
+// for use with NPCs who's logic has been overriden from the original
+// AI code, and who's code resides in files with the AI_ prefix.
+
+// leave this line at the top of all AI_xxxx.cpp files for PCH reasons...
+#include "g_headers.h"
+
+
+
+#include "b_local.h"
+#include "g_nav.h"
+#include "g_navigator.h"
+
+#define	MAX_RADIUS_ENTS		128
+#define	DEFAULT_RADIUS		45
+
+//extern	CNavigator	navigator;
+extern cvar_t		*d_noGroupAI;
+qboolean AI_ValidateGroupMember( AIGroupInfo_t *group, gentity_t *member );
+
+/*
+-------------------------
+AI_GetGroupSize
+-------------------------
+*/
+
+int	AI_GetGroupSize( vec3_t origin, int radius, team_t playerTeam, gentity_t *avoid )
+{
+	gentity_t	*radiusEnts[ MAX_RADIUS_ENTS ];
+	vec3_t		mins, maxs;
+	int			numEnts, realCount = 0;
+
+	//Setup the bbox to search in
+	for ( int i = 0; i < 3; i++ )
+	{
+		mins[i] = origin[i] - radius;
+		maxs[i] = origin[i] + radius;
+	}
+
+	//Get the number of entities in a given space
+	numEnts = gi.EntitiesInBox( mins, maxs, radiusEnts, MAX_RADIUS_ENTS );
+
+	//Cull this list
+	for ( int j = 0; j < numEnts; j++ )
+	{
+		//Validate clients
+		if ( radiusEnts[ j ]->client == NULL )
+			continue;
+
+		//Skip the requested avoid ent if present
+		if ( ( avoid != NULL ) && ( radiusEnts[ j ] == avoid ) )
+			continue;
+
+		//Must be on the same team
+		if ( radiusEnts[ j ]->client->playerTeam != playerTeam )
+			continue;
+
+		//Must be alive
+		if ( radiusEnts[ j ]->health <= 0 )
+			continue;
+
+		realCount++;
+	}
+
+	return realCount;
+}
+
+//Overload
+
+int AI_GetGroupSize( gentity_t *ent, int radius )
+{
+	if ( ( ent == NULL ) || ( ent->client == NULL ) )
+		return -1;
+
+	return AI_GetGroupSize( ent->currentOrigin, radius, ent->client->playerTeam, ent );
+}
+
+void AI_SetClosestBuddy( AIGroupInfo_t *group )
+{
+	int	i, j;
+	int	dist, bestDist;
+
+	for ( i = 0; i < group->numGroup; i++ )
+	{
+		group->member[i].closestBuddy = ENTITYNUM_NONE;
+
+		bestDist = Q3_INFINITE;
+		for ( j = 0; j < group->numGroup; j++ )
+		{
+			dist = DistanceSquared( g_entities[group->member[i].number].currentOrigin, g_entities[group->member[j].number].currentOrigin );
+			if ( dist < bestDist )
+			{
+				bestDist = dist;
+				group->member[i].closestBuddy = group->member[j].number;
+			}
+		}
+	}
+}
+
+void AI_SortGroupByPathCostToEnemy( AIGroupInfo_t *group )
+{
+	AIGroupMember_t bestMembers[MAX_GROUP_MEMBERS];
+	int				i, j, k;
+	qboolean		sort = qfalse;
+
+	if ( group->enemy != NULL )
+	{//FIXME: just use enemy->waypoint?
+		group->enemyWP = NAV::GetNearestNode(group->enemy);
+	}
+	else
+	{
+		group->enemyWP = WAYPOINT_NONE;
+	}
+
+	for ( i = 0; i < group->numGroup; i++ )
+	{
+		if ( group->enemyWP == WAYPOINT_NONE )
+		{//FIXME: just use member->waypoint?
+			group->member[i].waypoint = WAYPOINT_NONE;
+			group->member[i].pathCostToEnemy = Q3_INFINITE;
+		}
+		else
+		{//FIXME: just use member->waypoint?
+			group->member[i].waypoint = NAV::GetNearestNode(group->enemy);
+			if ( group->member[i].waypoint != WAYPOINT_NONE )
+			{
+				group->member[i].pathCostToEnemy = NAV::EstimateCostToGoal( group->member[i].waypoint, group->enemyWP );
+				//at least one of us has a path, so do sorting
+				sort = qtrue;
+			}
+			else
+			{
+				group->member[i].pathCostToEnemy = Q3_INFINITE;
+			}
+		}
+	}
+	//Now sort
+	if ( sort )
+	{
+		//initialize bestMembers data
+		for ( j = 0; j < group->numGroup; j++ )
+		{
+			bestMembers[j].number = ENTITYNUM_NONE;
+		}
+
+		for ( i = 0; i < group->numGroup; i++ )
+		{
+			for ( j = 0; j < group->numGroup; j++ )
+			{
+				if ( bestMembers[j].number != ENTITYNUM_NONE )
+				{//slot occupied
+					if ( group->member[i].pathCostToEnemy < bestMembers[j].pathCostToEnemy )
+					{//this guy has a shorter path than the one currenly in this spot, bump him and put myself in here
+						for ( k = group->numGroup; k > j; k++ )
+						{
+							memcpy( &bestMembers[k], &bestMembers[k-1], sizeof( bestMembers[k] ) );
+						}
+						memcpy( &bestMembers[j], &group->member[i], sizeof( bestMembers[j] ) );
+						break;
+					}
+				}
+				else
+				{//slot unoccupied, reached end of list, throw self in here
+					memcpy( &bestMembers[j], &group->member[i], sizeof( bestMembers[j] ) );
+					break;
+				}
+			}
+		}
+
+		//Okay, now bestMembers is a sorted list, just copy it into group->members
+		for ( i = 0; i < group->numGroup; i++ )
+		{
+			memcpy( &group->member[i], &bestMembers[i], sizeof( group->member[i] ) );
+		}
+	}
+}
+
+qboolean AI_FindSelfInPreviousGroup( gentity_t *self )
+{//go through other groups made this frame and see if any of those contain me already
+	int	i, j;
+	for ( i = 0; i < MAX_FRAME_GROUPS; i++ )
+	{
+		if ( level.groups[i].numGroup )//&& level.groups[i].enemy != NULL )
+		{//check this one
+			for ( j = 0; j < level.groups[i].numGroup; j++ )
+			{
+				if ( level.groups[i].member[j].number == self->s.number )
+				{
+					self->NPC->group = &level.groups[i];
+					return qtrue;
+				}
+			}
+		}
+	}
+	return qfalse;
+}
+
+void AI_InsertGroupMember( AIGroupInfo_t *group, gentity_t *member )
+{
+	//okay, you know what?  Check this damn group and make sure we're not already in here!
+	for ( int i = 0; i < group->numGroup; i++ )
+	{
+		if ( group->member[i].number == member->s.number )
+		{//already in here
+			break;
+		}
+	}
+	if ( i < group->numGroup )
+	{//found him in group already
+	}
+	else
+	{//add him in
+		group->member[group->numGroup++].number = member->s.number;
+		group->numState[member->NPC->squadState]++;
+	}
+	if ( !group->commander || (member->NPC->rank > group->commander->NPC->rank) )
+	{//keep track of highest rank
+		group->commander = member;
+	}
+	member->NPC->group = group;
+}
+
+qboolean AI_TryJoinPreviousGroup( gentity_t *self )
+{//go through other groups made this frame and see if any of those have the same enemy as me... if so, add me in!
+	int	i;
+	for ( i = 0; i < MAX_FRAME_GROUPS; i++ )
+	{
+		if ( level.groups[i].numGroup 
+			&& level.groups[i].numGroup < (MAX_GROUP_MEMBERS - 1) 
+			//&& level.groups[i].enemy != NULL 
+			&& level.groups[i].enemy == self->enemy )
+		{//has members, not full and has my enemy
+			if ( AI_ValidateGroupMember( &level.groups[i], self ) )
+			{//I am a valid member for this group
+				AI_InsertGroupMember( &level.groups[i], self );
+				return qtrue;
+			}
+		}
+	}
+	return qfalse;
+}
+
+qboolean AI_GetNextEmptyGroup( gentity_t *self )
+{
+	if ( AI_FindSelfInPreviousGroup( self ) )
+	{//already in one, no need to make a new one
+		return qfalse;
+	}
+
+	if ( AI_TryJoinPreviousGroup( self ) )
+	{//try to just put us in one that already exists
+		return qfalse;
+	}
+	
+	//okay, make a whole new one, then
+	for ( int i = 0; i < MAX_FRAME_GROUPS; i++ )
+	{
+		if ( !level.groups[i].numGroup )
+		{//make a new one
+			self->NPC->group = &level.groups[i];
+			return qtrue;
+		}
+	}
+
+	//if ( i >= MAX_FRAME_GROUPS )
+	{//WTF?  Out of groups!
+		self->NPC->group = NULL;
+		return qfalse;
+	}
+}
+
+qboolean AI_ValidateNoEnemyGroupMember( AIGroupInfo_t *group, gentity_t *member )
+{
+	if ( !group )
+	{
+		return qfalse;
+	}
+	vec3_t center;
+	if ( group->commander )
+	{
+		VectorCopy( group->commander->currentOrigin, center );
+	}
+	else
+	{//hmm, just pick the first member
+		if ( group->member[0].number < 0 || group->member[0].number >= ENTITYNUM_WORLD )
+		{
+			return qfalse;
+		}
+		VectorCopy( g_entities[group->member[0].number].currentOrigin, center );
+	}
+	//FIXME: maybe it should be based on the center of the mass of the group, not the commander?
+	if ( DistanceSquared( center, member->currentOrigin ) > 147456/*384*384*/ )
+	{
+		return qfalse;
+	}
+	if ( !gi.inPVS( member->currentOrigin, center ) )
+	{//not within PVS of the group enemy
+		return qfalse;
+	}
+	return qtrue;
+}
+
+qboolean AI_ValidateGroupMember( AIGroupInfo_t *group, gentity_t *member )
+{
+	//Validate ents
+	if ( member == NULL )
+		return qfalse;
+
+	//Validate clients
+	if ( member->client == NULL )
+		return qfalse;
+
+	//Validate NPCs
+	if ( member->NPC == NULL )
+		return qfalse;
+
+	//must be aware
+	if ( member->NPC->confusionTime > level.time )
+		return qfalse;
+
+	//must be allowed to join groups
+	if ( member->NPC->scriptFlags&SCF_NO_GROUPS )
+		return qfalse;
+
+	//Must not be in another group
+	if ( member->NPC->group != NULL && member->NPC->group != group )
+	{//FIXME: if that group's enemy is mine, why not absorb that group into mine?
+		return qfalse;
+	}
+
+	//Must be alive
+	if ( member->health <= 0 )
+		return qfalse;
+
+	//can't be in an emplaced gun
+	if( member->s.eFlags & EF_LOCKED_TO_WEAPON )
+		return qfalse;
+
+	if( member->s.eFlags & EF_HELD_BY_RANCOR )
+		return qfalse;
+
+	if( member->s.eFlags & EF_HELD_BY_SAND_CREATURE )
+		return qfalse;
+
+	if( member->s.eFlags & EF_HELD_BY_WAMPA )
+		return qfalse;
+
+	//Must be on the same team
+	if ( member->client->playerTeam != group->team )
+		return qfalse;
+
+	if ( member->client->ps.weapon == WP_SABER ||//!= self->s.weapon )
+		member->client->ps.weapon == WP_THERMAL ||
+		member->client->ps.weapon == WP_DISRUPTOR ||
+		member->client->ps.weapon == WP_EMPLACED_GUN ||
+		member->client->ps.weapon == WP_BOT_LASER ||		// Probe droid	- Laser blast
+		member->client->ps.weapon == WP_MELEE ||
+		member->client->ps.weapon == WP_TURRET ||			// turret guns 
+		member->client->ps.weapon == WP_ATST_MAIN ||
+		member->client->ps.weapon == WP_ATST_SIDE ||
+		member->client->ps.weapon == WP_TIE_FIGHTER )
+	{//not really a squad-type guy
+		return qfalse;
+	}
+
+	if ( member->client->NPC_class == CLASS_ATST ||
+		member->client->NPC_class == CLASS_PROBE ||
+		member->client->NPC_class == CLASS_SEEKER ||
+		member->client->NPC_class == CLASS_REMOTE ||
+		member->client->NPC_class == CLASS_SENTRY ||
+		member->client->NPC_class == CLASS_INTERROGATOR ||
+		member->client->NPC_class == CLASS_MINEMONSTER ||
+		member->client->NPC_class == CLASS_HOWLER ||
+		member->client->NPC_class == CLASS_RANCOR ||
+		member->client->NPC_class == CLASS_MARK1 ||
+		member->client->NPC_class == CLASS_MARK2 )
+	{//these kinds of enemies don't actually use this group AI
+		return qfalse;
+	}
+
+	//should have same enemy
+	if ( member->enemy != group->enemy )
+	{
+		if ( member->enemy != NULL )
+		{//he's fighting someone else, leave him out
+			return qfalse;
+		}
+		if ( !gi.inPVS( member->currentOrigin, group->enemy->currentOrigin ) )
+		{//not within PVS of the group enemy
+			return qfalse;
+		}
+	}
+	else if ( group->enemy == NULL )
+	{//if the group is a patrol group, only take those within the room and radius
+		if ( !AI_ValidateNoEnemyGroupMember( group, member ) )
+		{
+			return qfalse;
+		}
+	}
+	//must be actually in combat mode
+	if ( !TIMER_Done( member, "interrogating" ) )
+		return qfalse;
+	//FIXME: need to have a route to enemy and/or clear shot?
+	return qtrue;
+}
+
+/*
+-------------------------
+AI_GetGroup
+-------------------------
+*/
+//#define MAX_WAITERS	128
+void AI_GetGroup( gentity_t *self )
+{
+	int	i;
+	gentity_t	*member;//, *waiter;
+	//int	waiters[MAX_WAITERS];
+
+	if ( !self || !self->NPC )
+	{
+		return;
+	}
+
+	if ( d_noGroupAI->integer )
+	{
+		self->NPC->group = NULL;
+		return;
+	}
+
+	if ( !self->client )
+	{
+		self->NPC->group = NULL;
+		return;
+	}
+
+	if ( self->NPC->scriptFlags&SCF_NO_GROUPS )
+	{
+		self->NPC->group = NULL;
+		return;
+	}
+
+	if ( self->enemy && (!self->enemy->client || (level.time - self->NPC->enemyLastSeenTime > 7000 )))
+	{
+		self->NPC->group = NULL;
+		return;
+	}
+
+	if ( !AI_GetNextEmptyGroup( self ) )
+	{//either no more groups left or we're already in a group built earlier
+		return;
+	}
+
+	//create a new one
+	memset( self->NPC->group, 0, sizeof( AIGroupInfo_t ) );
+
+	self->NPC->group->enemy = self->enemy;
+	self->NPC->group->team = self->client->playerTeam;
+	self->NPC->group->processed = qfalse;
+	self->NPC->group->commander = self;
+	self->NPC->group->memberValidateTime = level.time + 2000;
+	self->NPC->group->activeMemberNum = 0;
+
+	if ( self->NPC->group->enemy )
+	{
+		self->NPC->group->lastSeenEnemyTime = level.time;
+		self->NPC->group->lastClearShotTime = level.time;
+		VectorCopy( self->NPC->group->enemy->currentOrigin, self->NPC->group->enemyLastSeenPos );
+	}
+
+//	for ( i = 0, member = &g_entities[0]; i < globals.num_entities ; i++, member++)
+	for ( i = 0; i < globals.num_entities ; i++)
+	{
+		if(!PInUse(i))
+			continue;
+		member = &g_entities[i];
+
+		if ( !AI_ValidateGroupMember( self->NPC->group, member ) )
+		{//FIXME: keep track of those who aren't angry yet and see if we should wake them after we assemble the core group
+			continue;
+		}
+		
+		//store it
+		AI_InsertGroupMember( self->NPC->group, member );
+
+		if ( self->NPC->group->numGroup >= (MAX_GROUP_MEMBERS - 1) )
+		{//full
+			break;
+		}
+	}
+
+	/*
+	//now go through waiters and see if any should join the group
+	//NOTE:  Some should hang back and probably not attack, so we can ambush
+	//NOTE: only do this if calling for reinforcements?
+	for ( i = 0; i < numWaiters; i++ )
+	{
+		waiter = &g_entities[waiters[i]];
+	
+		for ( j = 0; j < self->NPC->group->numGroup; j++ )
+		{
+			member = &g_entities[self->NPC->group->member[j];
+
+			if ( gi.inPVS( waiter->currentOrigin, member->currentOrigin ) )
+			{//this waiter is within PVS of a current member
+			}
+		}
+	}
+	*/
+
+	if ( self->NPC->group->numGroup <= 0 )
+	{//none in group
+		self->NPC->group = NULL;
+		return;
+	}
+
+	AI_SortGroupByPathCostToEnemy( self->NPC->group );
+	AI_SetClosestBuddy( self->NPC->group );
+}
+
+void AI_SetNewGroupCommander( AIGroupInfo_t *group )
+{
+	gentity_t *member = NULL;
+	group->commander = NULL;
+	for ( int i = 0; i < group->numGroup; i++ )
+	{
+		member = &g_entities[group->member[i].number];
+
+		if ( !group->commander || (member && member->NPC && group->commander->NPC && member->NPC->rank > group->commander->NPC->rank) )
+		{//keep track of highest rank
+			group->commander = member;
+		}
+	}
+}
+
+void AI_DeleteGroupMember( AIGroupInfo_t *group, int memberNum )
+{
+	if ( group->commander && group->commander->s.number == group->member[memberNum].number )
+	{
+		group->commander = NULL;
+	}
+	if ( g_entities[group->member[memberNum].number].NPC )
+	{
+		g_entities[group->member[memberNum].number].NPC->group = NULL;
+	}
+	for ( int i = memberNum; i < (group->numGroup-1); i++ )
+	{
+		memcpy( &group->member[i], &group->member[i+1], sizeof( group->member[i] ) );
+	}
+	if ( memberNum < group->activeMemberNum )
+	{
+		group->activeMemberNum--;
+		if ( group->activeMemberNum < 0 )
+		{
+			group->activeMemberNum = 0;
+		}
+	}
+	group->numGroup--;
+	if ( group->numGroup < 0 )
+	{
+		group->numGroup = 0;
+	}
+	AI_SetNewGroupCommander( group );
+}
+
+void AI_DeleteSelfFromGroup( gentity_t *self )
+{
+	//FIXME: if killed, keep track of how many in group killed?  To affect morale?
+	for ( int i = 0; i < self->NPC->group->numGroup; i++ )
+	{
+		if ( self->NPC->group->member[i].number == self->s.number )
+		{
+			AI_DeleteGroupMember( self->NPC->group, i );
+			return;
+		}
+	}
+}
+
+extern void ST_AggressionAdjust( gentity_t *self, int change );
+extern void ST_MarkToCover( gentity_t *self );
+extern void ST_StartFlee( gentity_t *self, gentity_t *enemy, vec3_t dangerPoint, int dangerLevel, int minTime, int maxTime );
+void AI_GroupMemberKilled( gentity_t *self )
+{
+/*	AIGroupInfo_t *group = self->NPC->group;
+	gentity_t	*member;
+	qboolean	noflee = qfalse;
+
+	if ( !group )
+	{//what group?
+		return;
+	}
+	if ( !self || !self->NPC || self->NPC->rank < RANK_ENSIGN )
+	{//I'm not an officer, let's not really care for now
+		return;
+	}
+	//temporarily drop group morale for a few seconds
+	group->moraleAdjust -= self->NPC->rank;
+	//go through and drop aggression on my teammates (more cover, worse aim)
+	for ( int i = 0; i < group->numGroup; i++ )
+	{
+		member = &g_entities[group->member[i].number];
+		if ( member == self )
+		{
+			continue;
+		}
+		if ( member->NPC->rank > RANK_ENSIGN )
+		{//officers do not panic
+			noflee = qtrue;
+		}
+		else
+		{
+			ST_AggressionAdjust( member, -1 );
+			member->NPC->currentAim -= Q_irand( 0, 10 );//Q_irand( 0, 2);//drop their aim accuracy
+		}
+	}
+	//okay, if I'm the group commander, make everyone else flee
+	if ( group->commander != self )
+	{//I'm not the commander... hmm, should maybe a couple flee... maybe those near me?
+		return;
+	}
+	//now see if there is another of sufficient rank to keep them from fleeing
+	if ( !noflee )
+	{
+		self->NPC->group->speechDebounceTime = 0;
+		for ( int i = 0; i < group->numGroup; i++ )
+		{
+			member = &g_entities[group->member[i].number];
+			if ( member == self )
+			{
+				continue;
+			}
+			if ( member->NPC->rank < RANK_ENSIGN )
+			{//grunt
+				if ( group->enemy && DistanceSquared( member->currentOrigin, group->enemy->currentOrigin ) < 65536 )//256*256
+				{//those close to enemy run away!
+					ST_StartFlee( member, group->enemy, member->currentOrigin, AEL_DANGER_GREAT, 3000, 5000 );
+				}
+				else if ( DistanceSquared( member->currentOrigin, self->currentOrigin ) < 65536 )
+				{//those close to me run away!
+					ST_StartFlee( member, group->enemy, member->currentOrigin, AEL_DANGER_GREAT, 3000, 5000 );
+				}
+				else
+				{//else, maybe just a random chance
+					if ( Q_irand( 0, self->NPC->rank ) > member->NPC->rank )
+					{//lower rank they are, higher rank I am, more likely they are to flee
+						ST_StartFlee( member, group->enemy, member->currentOrigin, AEL_DANGER_GREAT, 3000, 5000 );
+					}
+					else
+					{
+						ST_MarkToCover( member );
+					}
+				}
+				member->NPC->currentAim -= Q_irand( 1, 15 ); //Q_irand( 1, 3 );//drop their aim accuracy even more
+			}
+			member->NPC->currentAim -= Q_irand( 1, 15 ); //Q_irand( 1, 3 );//drop their aim accuracy even more
+		}
+	}*/
+}
+
+void AI_GroupUpdateEnemyLastSeen( AIGroupInfo_t *group, vec3_t spot )
+{
+	if ( !group )
+	{
+		return;
+	}
+	group->lastSeenEnemyTime = level.time;
+	VectorCopy( spot, group->enemyLastSeenPos );
+}
+
+void AI_GroupUpdateClearShotTime( AIGroupInfo_t *group )
+{
+	if ( !group )
+	{
+		return;
+	}
+	group->lastClearShotTime = level.time;
+}
+
+void AI_GroupUpdateSquadstates( AIGroupInfo_t *group, gentity_t *member, int newSquadState )
+{
+	if ( !group )
+	{
+		member->NPC->squadState = newSquadState;
+		return;
+	}
+
+	for ( int i = 0; i < group->numGroup; i++ )
+	{
+		if ( group->member[i].number == member->s.number )
+		{
+			group->numState[member->NPC->squadState]--;
+			member->NPC->squadState = newSquadState;
+			group->numState[member->NPC->squadState]++;
+			return;
+		}
+	}
+}
+
+qboolean AI_RefreshGroup( AIGroupInfo_t *group )
+{
+	gentity_t	*member;
+	int			i;//, j;
+
+	//see if we should merge with another group
+	for ( i = 0; i < MAX_FRAME_GROUPS; i++ ) 
+	{
+		if ( &level.groups[i] == group )
+		{
+			break;
+		}
+		else
+		{
+			if ( level.groups[i].enemy == group->enemy )
+			{//2 groups with same enemy
+				if ( level.groups[i].numGroup+group->numGroup < (MAX_GROUP_MEMBERS - 1) )
+				{//combining the members would fit in one group
+					qboolean deleteWhenDone = qtrue;
+					//combine the members of mine into theirs
+					for ( int j = 0; j < group->numGroup; j++ )
+					{
+						member = &g_entities[group->member[j].number];
+						if ( level.groups[i].enemy == NULL )
+						{//special case for groups without enemies, must be in range
+							if ( !AI_ValidateNoEnemyGroupMember( &level.groups[i], member ) )
+							{
+								deleteWhenDone = qfalse;
+								continue;
+							}
+						}
+						//remove this member from this group
+						AI_DeleteGroupMember( group, j );
+						//keep marker at same place since we deleted this guy and shifted everyone up one
+						j--;
+						//add them to the earlier group
+						AI_InsertGroupMember( &level.groups[i], member );
+					}
+					//return and delete this group
+					if ( deleteWhenDone )
+					{
+						return qfalse;
+					}
+				}
+			}
+		}
+	}
+	//clear numStates
+	for ( i = 0; i < NUM_SQUAD_STATES; i++ )
+	{
+		group->numState[i] = 0;
+	}
+
+	//go through group and validate each membership
+	group->commander = NULL;
+	for ( i = 0; i < group->numGroup; i++ )
+	{
+		/*
+		//this checks for duplicate copies of one member in a group
+		for ( j = 0; j < group->numGroup; j++ )
+		{
+			if ( i != j )
+			{
+				if ( group->member[i].number == group->member[j].number )
+				{
+					break;
+				}
+			}
+		}
+		if ( j < group->numGroup )
+		{//found a dupe!
+			gi.Printf( S_COLOR_RED"ERROR: member %s(%d) a duplicate group member!!!\n", g_entities[group->member[i].number].targetname, group->member[i].number );
+			AI_DeleteGroupMember( group, i );
+			i--;
+			continue;
+		}
+		*/
+		member = &g_entities[group->member[i].number];
+
+		//Must be alive
+		if ( member->health <= 0 )
+		{
+			AI_DeleteGroupMember( group, i );
+			//keep marker at same place since we deleted this guy and shifted everyone up one
+			i--;
+		}
+		else if ( group->memberValidateTime < level.time && !AI_ValidateGroupMember( group, member ) )
+		{
+			//remove this one from the group
+			AI_DeleteGroupMember( group, i );
+			//keep marker at same place since we deleted this guy and shifted everyone up one
+			i--;
+		}
+		else
+		{//membership is valid
+			//keep track of squadStates
+			group->numState[member->NPC->squadState]++;
+			if ( !group->commander || member->NPC->rank > group->commander->NPC->rank )
+			{//keep track of highest rank
+				group->commander = member;
+			}
+		}
+	}
+	if ( group->memberValidateTime < level.time )
+	{
+		group->memberValidateTime = level.time + Q_irand( 500, 2500 );
+	}
+	//Now add any new guys as long as we're not full
+	/*
+	for ( i = 0, member = &g_entities[0]; i < globals.num_entities && group->numGroup < (MAX_GROUP_MEMBERS - 1); i++, member++)
+	{
+		if ( !AI_ValidateGroupMember( group, member ) )
+		{//FIXME: keep track of those who aren't angry yet and see if we should wake them after we assemble the core group
+			continue;
+		}
+		if ( member->NPC->group == group )
+		{//DOH, already in our group
+			continue;
+		}
+
+		//store it
+		AI_InsertGroupMember( group, member );
+	}
+	*/
+
+	//calc the morale of this group
+	group->morale = group->moraleAdjust;
+	for ( i = 0; i < group->numGroup; i++ )
+	{
+		member = &g_entities[group->member[i].number];
+		if ( member->NPC->rank < RANK_ENSIGN )
+		{//grunts
+			group->morale++;
+		}
+		else
+		{
+			group->morale += member->NPC->rank;
+		}
+		if ( group->commander && debugNPCAI->integer )
+		{
+			G_DebugLine( group->commander->currentOrigin, member->currentOrigin, FRAMETIME, 0x00ff00ff, qtrue );
+		}
+	}
+	if ( group->enemy )
+	{//modify morale based on enemy health and weapon
+		if ( group->enemy->health < 10 )
+		{
+			group->morale += 10;
+		}
+		else if ( group->enemy->health < 25 )
+		{
+			group->morale += 5;
+		}
+		else if ( group->enemy->health < 50 )
+		{
+			group->morale += 2;
+		}
+		switch( group->enemy->s.weapon )
+		{
+		case WP_SABER:
+			group->morale -= 5;
+			break;
+		case WP_BRYAR_PISTOL:
+		case WP_BLASTER_PISTOL:
+			group->morale += 3;
+			break;
+		case WP_DISRUPTOR:
+			group->morale += 2;
+			break;
+		case WP_REPEATER:
+			group->morale -= 1;
+			break;
+		case WP_FLECHETTE:
+			group->morale -= 2;
+			break;
+		case WP_ROCKET_LAUNCHER:
+			group->morale -= 10;
+			break;
+		case WP_CONCUSSION:
+			group->morale -= 12;
+			break;
+		case WP_THERMAL:
+			group->morale -= 5;
+			break;
+		case WP_TRIP_MINE:
+			group->morale -= 3;
+			break;
+		case WP_DET_PACK:
+			group->morale -= 10;
+			break;
+		case WP_MELEE:			// Any ol' melee attack
+			group->morale += 20;
+			break;
+		case WP_STUN_BATON:
+			group->morale += 10;
+			break;
+		case WP_EMPLACED_GUN:
+			group->morale -= 8;
+			break;
+		case WP_ATST_MAIN:
+			group->morale -= 8;
+			break;
+		case WP_ATST_SIDE:
+			group->morale -= 20;
+			break;
+		}
+	}
+	if ( group->moraleDebounce < level.time )
+	{//slowly degrade whatever moraleAdjusters we may have
+		if ( group->moraleAdjust > 0 )
+		{
+			group->moraleAdjust--;
+		}
+		else if ( group->moraleAdjust < 0 )
+		{
+			group->moraleAdjust++;
+		}
+		group->moraleDebounce = level.time + 1000;//FIXME: define?
+	}
+	//mark this group as not having been run this frame
+	group->processed = qfalse;
+
+	return (group->numGroup>0);
+}
+
+void AI_UpdateGroups( void )
+{
+	if ( d_noGroupAI->integer )
+	{
+		return;
+	}
+	//Clear all Groups
+	for ( int i = 0; i < MAX_FRAME_GROUPS; i++ ) 
+	{
+		if ( !level.groups[i].numGroup || AI_RefreshGroup( &level.groups[i] ) == qfalse )//level.groups[i].enemy == NULL || 
+		{
+			memset( &level.groups[i], 0, sizeof( level.groups[i] ) );
+		}
+	}
+}
+
+qboolean AI_GroupContainsEntNum( AIGroupInfo_t *group, int entNum )
+{
+	if ( !group )
+	{
+		return qfalse;
+	}
+	for ( int i = 0; i < group->numGroup; i++ )
+	{
+		if ( group->member[i].number == entNum )
+		{
+			return qtrue;
+		}
+	}
+	return qfalse;
+}
+//Overload 
+
+/*
+void AI_GetGroup( AIGroupInfo_t &group, gentity_t *ent, int radius )
+{
+	if ( ent->client == NULL )
+		return;
+
+	vec3_t	temp, angles;
+
+	//FIXME: This is specialized code.. move?
+	if ( ent->enemy )
+	{
+		VectorSubtract( ent->enemy->currentOrigin, ent->currentOrigin, temp );
+		VectorNormalize( temp );	//FIXME: Needed?
+		vectoangles( temp, angles );
+	}
+	else
+	{
+		VectorCopy( ent->currentAngles, angles );
+	}
+
+	AI_GetGroup( group, ent->currentOrigin, ent->currentAngles, DEFAULT_RADIUS, radius, ent->client->playerTeam, ent, ent->enemy );
+}
+*/
+
+/*
+-------------------------
+AI_DistributeAttack
+-------------------------
+*/
+
+#define	MAX_RADIUS_ENTS		128
+
+gentity_t *AI_DistributeAttack( gentity_t *attacker, gentity_t *enemy, team_t team, int threshold )
+{
+	//Don't take new targets
+	if ( NPC->svFlags & SVF_LOCKEDENEMY )
+		return enemy;
+
+	int	numSurrounding = AI_GetGroupSize( enemy->currentOrigin, 48, team, attacker );
+
+	//First, see if we should look for the player
+	if ( enemy != &g_entities[0] )
+	{
+		int	aroundPlayer = AI_GetGroupSize( g_entities[0].currentOrigin, 48, team, attacker );
+
+		//See if we're above our threshold
+		if ( aroundPlayer < threshold )
+		{
+			return &g_entities[0];
+		}
+	}
+
+	//See if our current enemy is still ok
+	if ( numSurrounding < threshold )
+		return enemy;
+
+	//Otherwise we need to take a new enemy if possible
+	vec3_t	mins, maxs;
+
+	//Setup the bbox to search in
+	for ( int i = 0; i < 3; i++ )
+	{
+		mins[i] = enemy->currentOrigin[i] - 512;
+		maxs[i] = enemy->currentOrigin[i] + 512;
+	}
+
+	//Get the number of entities in a given space
+	gentity_t	*radiusEnts[ MAX_RADIUS_ENTS ];
+
+	int numEnts = gi.EntitiesInBox( mins, maxs, radiusEnts, MAX_RADIUS_ENTS );
+
+	//Cull this list
+	for ( int j = 0; j < numEnts; j++ )
+	{
+		//Validate clients
+		if ( radiusEnts[ j ]->client == NULL )
+			continue;
+
+		//Skip the requested avoid ent if present
+		if ( ( radiusEnts[ j ] == enemy ) )
+			continue;
+
+		//Must be on the same team
+		if ( radiusEnts[ j ]->client->playerTeam != enemy->client->playerTeam )
+			continue;
+
+		//Must be alive
+		if ( radiusEnts[ j ]->health <= 0 )
+			continue;
+
+		//Must not be overwhelmed
+		if ( AI_GetGroupSize( radiusEnts[j]->currentOrigin, 48, team, attacker ) > threshold )
+			continue;
+
+		return radiusEnts[j];
+	}
+
+	return NULL;
+}
diff --git a/code/game/AI_Wampa.cpp b/code/game/AI_Wampa.cpp
new file mode 100644
index 0000000..1c2b1a1
--- /dev/null
+++ b/code/game/AI_Wampa.cpp
@@ -0,0 +1,904 @@
+// leave this line at the top of all AI_xxxx.cpp files for PCH reasons...
+#include "g_headers.h"
+
+	    
+#include "b_local.h"
+
+// These define the working combat range for these suckers
+#define MIN_DISTANCE		48
+#define MIN_DISTANCE_SQR	( MIN_DISTANCE * MIN_DISTANCE )
+
+#define MAX_DISTANCE		1024
+#define MAX_DISTANCE_SQR	( MAX_DISTANCE * MAX_DISTANCE )
+
+#define LSTATE_CLEAR		0
+#define LSTATE_WAITING		1
+
+float enemyDist = 0;
+extern qboolean NAV_CheckAhead( gentity_t *self, vec3_t end, trace_t &trace, int clipmask );
+extern int PM_AnimLength( int index, animNumber_t anim );
+extern cvar_t	*g_dismemberment;
+/*
+-------------------------
+NPC_Wampa_Precache
+-------------------------
+*/
+void NPC_Wampa_Precache( void )
+{
+	/*
+	int i;
+	for ( i = 1; i < 4; i ++ )
+	{
+		G_SoundIndex( va("sound/chars/wampa/growl%d.wav", i) );
+	}
+	for ( i = 1; i < 3; i ++ )
+	{
+		G_SoundIndex( va("sound/chars/wampa/snort%d.wav", i) );
+	}
+	*/
+	G_SoundIndex( "sound/chars/rancor/swipehit.wav" );
+	//G_SoundIndex( "sound/chars/wampa/chomp.wav" );
+}
+
+
+/*
+-------------------------
+Wampa_Idle
+-------------------------
+*/
+void Wampa_Idle( void )
+{
+	NPCInfo->localState = LSTATE_CLEAR;
+
+	//If we have somewhere to go, then do that
+	if ( UpdateGoal() )
+	{
+		ucmd.buttons &= ~BUTTON_WALKING;
+		NPC_MoveToGoal( qtrue );
+	}
+}
+
+qboolean Wampa_CheckRoar( gentity_t *self )
+{
+	if ( self->wait < level.time )
+	{
+		self->wait = level.time + Q_irand( 5000, 20000 );
+		NPC_SetAnim( self, SETANIM_BOTH, Q_irand(BOTH_GESTURE1,BOTH_GESTURE2), (SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD) );
+		TIMER_Set( self, "rageTime", self->client->ps.legsAnimTimer );
+		return qtrue;
+	}
+	return qfalse;
+}
+/*
+-------------------------
+Wampa_Patrol
+-------------------------
+*/
+void Wampa_Patrol( void )
+{
+	NPCInfo->localState = LSTATE_CLEAR;
+
+	//If we have somewhere to go, then do that
+	if ( UpdateGoal() )
+	{
+		ucmd.buttons |= BUTTON_WALKING;
+		NPC_MoveToGoal( qtrue );
+	}
+
+	if ( NPC_CheckEnemyExt( qtrue ) == qfalse )
+	{
+		Wampa_Idle();
+		return;
+	}
+	Wampa_CheckRoar( NPC );
+	TIMER_Set( NPC, "lookForNewEnemy", Q_irand( 5000, 15000 ) );
+}
+ 
+/*
+-------------------------
+Wampa_Move
+-------------------------
+*/
+void Wampa_Move( qboolean visible )
+{
+	if ( NPCInfo->localState != LSTATE_WAITING )
+	{
+		NPCInfo->goalEntity = NPC->enemy;
+
+		trace_t	trace;
+		if ( !NAV_CheckAhead( NPC, NPCInfo->goalEntity->currentOrigin, trace, (NPC->clipmask|CONTENTS_BOTCLIP) ) )
+		{
+			if ( !NPC_MoveToGoal( qfalse ) )
+			{
+				STEER::Activate(NPC);
+				STEER::Seek(NPC, NPCInfo->goalEntity->currentOrigin);
+				STEER::AvoidCollisions(NPC);
+				STEER::DeActivate(NPC, &ucmd);
+			}
+		}
+		NPCInfo->goalRadius = MIN_DISTANCE;//MAX_DISTANCE;	// just get us within combat range
+
+		if ( NPC->enemy )
+		{//pick correct movement speed and anim
+			//run by default
+			ucmd.buttons &= ~BUTTON_WALKING;
+			if ( !TIMER_Done( NPC, "runfar" ) 
+				|| !TIMER_Done( NPC, "runclose" ) )
+			{//keep running with this anim & speed for a bit
+			}
+			else if ( !TIMER_Done( NPC, "walk" ) )
+			{//keep walking for a bit
+				ucmd.buttons |= BUTTON_WALKING;
+			}
+			else if ( visible && enemyDist > 350 && NPCInfo->stats.runSpeed == 200 )//180 )
+			{//fast run, all fours
+				//BOTH_RUN1
+				NPCInfo->stats.runSpeed = 300;
+				TIMER_Set( NPC, "runfar", Q_irand( 4000, 8000 ) );
+				if ( NPC->client->ps.legsAnim == BOTH_RUN2 )
+				{
+					NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_RUN2TORUN1, SETANIM_FLAG_HOLD );
+				}
+			}
+			else if ( enemyDist > 200 && NPCInfo->stats.runSpeed == 300 )
+			{//slow run, upright
+				//BOTH_RUN2
+				NPCInfo->stats.runSpeed = 200;//180;
+				TIMER_Set( NPC, "runclose", Q_irand( 5000, 10000 ) );
+				if ( NPC->client->ps.legsAnim == BOTH_RUN1 )
+				{
+					NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_RUN1TORUN2, SETANIM_FLAG_HOLD );
+				}
+			}
+			else if ( enemyDist < 100 )
+			{//walk
+				NPCInfo->stats.runSpeed = 200;//180;
+				ucmd.buttons |= BUTTON_WALKING;
+				TIMER_Set( NPC, "walk", Q_irand( 6000, 12000 ) );
+			}
+		}
+	}
+}
+
+//---------------------------------------------------------
+extern void G_Knockdown( gentity_t *self, gentity_t *attacker, const vec3_t pushDir, float strength, qboolean breakSaberLock );
+extern qboolean G_DoDismemberment( gentity_t *self, vec3_t point, int mod, int damage, int hitLoc, qboolean force = qfalse );
+extern int NPC_GetEntsNearBolt( gentity_t **radiusEnts, float radius, int boltIndex, vec3_t boltOrg );
+
+void Wampa_Slash( int boltIndex, qboolean backhand )
+{
+	gentity_t	*radiusEnts[ 128 ];
+	int			numEnts;
+	const float	radius = 88;
+	const float	radiusSquared = (radius*radius);
+	int			i;
+	vec3_t		boltOrg;
+	int			damage = (backhand)?Q_irand(10,15):Q_irand(20,30);
+
+	numEnts = NPC_GetEntsNearBolt( radiusEnts, radius, boltIndex, boltOrg );
+
+	for ( i = 0; i < numEnts; i++ )
+	{
+		if ( !radiusEnts[i]->inuse )
+		{
+			continue;
+		}
+		
+		if ( radiusEnts[i] == NPC )
+		{//Skip the wampa ent
+			continue;
+		}
+		
+		if ( radiusEnts[i]->client == NULL )
+		{//must be a client
+			continue;
+		}
+
+		if ( DistanceSquared( radiusEnts[i]->currentOrigin, boltOrg ) <= radiusSquared )
+		{
+			//smack
+			G_Damage( radiusEnts[i], NPC, NPC, vec3_origin, radiusEnts[i]->currentOrigin, damage, ((backhand)?0:DAMAGE_NO_KNOCKBACK), MOD_MELEE );
+			if ( backhand )
+			{
+				//actually push the enemy
+				vec3_t pushDir;
+				vec3_t angs;
+				VectorCopy( NPC->client->ps.viewangles, angs );
+				angs[YAW] += Q_flrand( 25, 50 );
+				angs[PITCH] = Q_flrand( -25, -15 );
+				AngleVectors( angs, pushDir, NULL, NULL );
+				if ( radiusEnts[i]->client->NPC_class != CLASS_WAMPA
+					&& radiusEnts[i]->client->NPC_class != CLASS_RANCOR
+					&& radiusEnts[i]->client->NPC_class != CLASS_ATST
+					&& !(radiusEnts[i]->flags&FL_NO_KNOCKBACK) )
+				{
+					G_Throw( radiusEnts[i], pushDir, 65 );
+					if ( radiusEnts[i]->health > 0 && Q_irand( 0, 1 ) )
+					{//do pain on enemy
+						G_Knockdown( radiusEnts[i], NPC, pushDir, 300, qtrue );
+					}
+				}
+			}
+			else if ( radiusEnts[i]->health <= 0 && radiusEnts[i]->client )
+			{//killed them, chance of dismembering
+				if ( !Q_irand( 0, 1 ) )
+				{//bite something off
+					int hitLoc = HL_WAIST;
+					if ( g_dismemberment->integer != 113811381138 )
+					{
+						hitLoc = Q_irand( HL_WAIST, HL_HAND_LT );
+					}
+					else
+					{
+						hitLoc = Q_irand( HL_WAIST, HL_HEAD );
+					}
+					if ( hitLoc == HL_HEAD )
+					{
+						NPC_SetAnim( radiusEnts[i], SETANIM_BOTH, BOTH_DEATH17, SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLD );
+					}
+					else if ( hitLoc == HL_WAIST )
+					{
+						NPC_SetAnim( radiusEnts[i], SETANIM_BOTH, BOTH_DEATHBACKWARD2, SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLD );
+					}
+					radiusEnts[i]->client->dismembered = false;
+					//FIXME: the limb should just disappear, cuz I ate it
+					G_DoDismemberment( radiusEnts[i], radiusEnts[i]->currentOrigin, MOD_SABER, 1000, hitLoc, qtrue );
+				}
+			}
+			else if ( !Q_irand( 0, 3 ) && radiusEnts[i]->health > 0 )
+			{//one out of every 4 normal hits does a knockdown, too
+				vec3_t pushDir;
+				vec3_t angs;
+				VectorCopy( NPC->client->ps.viewangles, angs );
+				angs[YAW] += Q_flrand( 25, 50 );
+				angs[PITCH] = Q_flrand( -25, -15 );
+				AngleVectors( angs, pushDir, NULL, NULL );
+				G_Knockdown( radiusEnts[i], NPC, pushDir, 35, qtrue );
+			}
+			G_Sound( radiusEnts[i], G_SoundIndex( "sound/chars/rancor/swipehit.wav" ) );
+		}
+	}
+}
+
+//------------------------------
+void Wampa_Attack( float distance, qboolean doCharge )
+{
+	if ( !TIMER_Exists( NPC, "attacking" ) )
+	{
+		if ( !Q_irand(0, 3) && !doCharge )
+		{//double slash
+			NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_ATTACK1, SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLD );
+			TIMER_Set( NPC, "attack_dmg", 750 );
+		}
+		else if ( doCharge || (distance > 270 && distance < 430 && !Q_irand(0, 1)) )
+		{//leap
+			NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_ATTACK2, SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLD );
+			TIMER_Set( NPC, "attack_dmg", 500 );
+			vec3_t	fwd, yawAng ={0, NPC->client->ps.viewangles[YAW], 0};
+			AngleVectors( yawAng, fwd, NULL, NULL );
+			VectorScale( fwd, distance*1.5f, NPC->client->ps.velocity );
+			NPC->client->ps.velocity[2] = 150;
+			NPC->client->ps.groundEntityNum = ENTITYNUM_NONE;
+		}
+		else if ( distance < 100 )//&& !Q_irand( 0, 4 ) )
+		{//grab
+			NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_HOLD_START, SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLD );
+			NPC->client->ps.legsAnimTimer += 200;
+			TIMER_Set( NPC, "attack_dmg", 250 );
+		}
+		else
+		{//backhand
+			NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_ATTACK3, SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLD );
+			TIMER_Set( NPC, "attack_dmg", 250 );
+		}
+
+		TIMER_Set( NPC, "attacking", NPC->client->ps.legsAnimTimer + random() * 200 );
+		//allow us to re-evaluate our running speed/anim
+		TIMER_Set( NPC, "runfar", -1 );
+		TIMER_Set( NPC, "runclose", -1 );
+		TIMER_Set( NPC, "walk", -1 );
+	}
+
+	// Need to do delayed damage since the attack animations encapsulate multiple mini-attacks
+
+	if ( TIMER_Done2( NPC, "attack_dmg", qtrue ) )
+	{
+		switch ( NPC->client->ps.legsAnim )
+		{
+		case BOTH_ATTACK1:
+			Wampa_Slash( NPC->handRBolt, qfalse );
+			//do second hit
+			TIMER_Set( NPC, "attack_dmg2", 100 );
+			break;
+		case BOTH_ATTACK2:
+			Wampa_Slash( NPC->handRBolt, qfalse );
+			TIMER_Set( NPC, "attack_dmg2", 100 );
+			break;
+		case BOTH_ATTACK3:
+			Wampa_Slash( NPC->handLBolt, qtrue );
+			break;
+		}
+	}
+	else if ( TIMER_Done2( NPC, "attack_dmg2", qtrue ) )
+	{
+		switch ( NPC->client->ps.legsAnim )
+		{
+		case BOTH_ATTACK1:
+			Wampa_Slash( NPC->handLBolt, qfalse );
+			break;
+		case BOTH_ATTACK2:
+			Wampa_Slash( NPC->handLBolt, qfalse );
+			break;
+		}
+	}
+
+	// Just using this to remove the attacking flag at the right time
+	TIMER_Done2( NPC, "attacking", qtrue );
+
+	if ( NPC->client->ps.legsAnim == BOTH_ATTACK1 && distance > (NPC->maxs[0]+MIN_DISTANCE) )
+	{//okay to keep moving
+		ucmd.buttons |= BUTTON_WALKING;
+		Wampa_Move( 1 );
+	}
+}
+
+//----------------------------------
+void Wampa_Combat( void )
+{
+	// If we cannot see our target or we have somewhere to go, then do that
+	if ( !NPC_ClearLOS( NPC->enemy ) )
+	{
+		if ( !Q_irand( 0, 10 ) )
+		{
+			if ( Wampa_CheckRoar( NPC ) )
+			{
+				return;
+			}
+		}
+		NPCInfo->combatMove = qtrue;
+		NPCInfo->goalEntity = NPC->enemy;
+		NPCInfo->goalRadius = MIN_DISTANCE;//MAX_DISTANCE;	// just get us within combat range
+
+		Wampa_Move( 0 );
+		return;
+	}
+	/*
+	else if ( UpdateGoal() )
+	{
+		NPCInfo->combatMove = qtrue;
+		NPCInfo->goalEntity = NPC->enemy;
+		NPCInfo->goalRadius = MIN_DISTANCE;//MAX_DISTANCE;	// just get us within combat range
+
+		Wampa_Move( 1 );
+		return;
+	}*/
+
+	// Sometimes I have problems with facing the enemy I'm attacking, so force the issue so I don't look dumb
+	//FIXME: always seems to face off to the left or right?!!!!
+	NPC_FaceEnemy( qtrue );
+
+	float distance	= enemyDist = Distance( NPC->currentOrigin, NPC->enemy->currentOrigin );	
+
+	qboolean	advance = (qboolean)( distance > (NPC->maxs[0]+MIN_DISTANCE) ? qtrue : qfalse  );
+	qboolean	doCharge = qfalse;
+
+	if ( advance )
+	{//have to get closer
+		vec3_t	yawOnlyAngles = {0, NPC->currentAngles[YAW], 0};
+		if ( NPC->enemy->health > 0//enemy still alive
+			&& fabs(distance-350) <= 80 //enemy anywhere from 270 to 430 away
+			&& InFOV( NPC->enemy->currentOrigin, NPC->currentOrigin, yawOnlyAngles, 20, 20 ) )//enemy generally in front
+		{//10% chance of doing charge anim
+			if ( !Q_irand( 0, 6 ) )
+			{//go for the charge
+				doCharge = qtrue;
+				advance = qfalse;
+			}
+		}
+	}
+
+	if (( advance || NPCInfo->localState == LSTATE_WAITING ) && TIMER_Done( NPC, "attacking" )) // waiting monsters can't attack
+	{
+		if ( TIMER_Done2( NPC, "takingPain", qtrue ))
+		{
+			NPCInfo->localState = LSTATE_CLEAR;
+		}
+		else
+		{
+			Wampa_Move( 1 );
+		}
+	}
+	else
+	{
+		if ( !Q_irand( 0, 15 ) )
+		{//FIXME: only do this if we just damaged them or vice-versa?
+			if ( Wampa_CheckRoar( NPC ) )
+			{
+				return;
+			}
+		}
+		Wampa_Attack( distance, doCharge );
+	}
+}
+
+/*
+-------------------------
+NPC_Wampa_Pain
+-------------------------
+*/
+void NPC_Wampa_Pain( gentity_t *self, gentity_t *inflictor, gentity_t *other, const vec3_t point, int damage, int mod,int hitLoc ) 
+{
+	qboolean hitByWampa = qfalse;
+	if ( self->count )
+	{//FIXME: need pain anim
+		NPC_SetAnim( self, SETANIM_BOTH, BOTH_STAND2TO1, SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLD );
+		TIMER_Set( self, "takingPain", self->client->ps.legsAnimTimer );
+		TIMER_Set(self,"attacking",-level.time);
+		return;
+	}
+	if ( other&&other->client&&other->client->NPC_class==CLASS_WAMPA )
+	{
+		hitByWampa = qtrue;
+	}
+	if ( other 
+		&& other->inuse 
+		&& other != self->enemy
+		&& !(other->flags&FL_NOTARGET) )
+	{
+		if ( (!other->s.number&&!Q_irand(0,3))
+			|| !self->enemy
+			|| self->enemy->health == 0
+			|| (self->enemy->client&&self->enemy->client->NPC_class == CLASS_WAMPA)
+			|| (!Q_irand(0, 4 ) && DistanceSquared( other->currentOrigin, self->currentOrigin ) < DistanceSquared( self->enemy->currentOrigin, self->currentOrigin )) ) 
+		{//if my enemy is dead (or attacked by player) and I'm not still holding/eating someone, turn on the attacker
+			//FIXME: if can't nav to my enemy, take this guy if I can nav to him
+			self->lastEnemy = other;
+			G_SetEnemy( self, other );
+			if ( self->enemy != self->lastEnemy )
+			{//clear this so that we only sniff the player the first time we pick them up
+				self->useDebounceTime = 0;
+			}
+			TIMER_Set( self, "lookForNewEnemy", Q_irand( 5000, 15000 ) );
+			if ( hitByWampa )
+			{//stay mad at this Wampa for 2-5 secs before looking for other enemies
+				TIMER_Set( self, "wampaInfight", Q_irand( 2000, 5000 ) );
+			}
+		}
+	}
+	if ( (hitByWampa|| Q_irand( 0, 100 ) < damage )//hit by wampa, hit while holding live victim, or took a lot of damage
+		&& self->client->ps.legsAnim != BOTH_GESTURE1
+		&& self->client->ps.legsAnim != BOTH_GESTURE2
+		&& TIMER_Done( self, "takingPain" ) )
+	{
+		if ( !Wampa_CheckRoar( self ) )
+		{
+			if ( self->client->ps.legsAnim != BOTH_ATTACK1
+				&& self->client->ps.legsAnim != BOTH_ATTACK2
+				&& self->client->ps.legsAnim != BOTH_ATTACK3 )
+			{//cant interrupt one of the big attack anims
+				if ( self->health > 100 || hitByWampa )
+				{
+					TIMER_Remove( self, "attacking" );
+
+					VectorCopy( self->NPC->lastPathAngles, self->s.angles );
+
+					if ( !Q_irand( 0, 1 ) )
+					{
+						NPC_SetAnim( self, SETANIM_BOTH, BOTH_PAIN2, SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLD );
+					}
+					else
+					{
+						NPC_SetAnim( self, SETANIM_BOTH, BOTH_PAIN1, SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLD );
+					}
+					TIMER_Set( self, "takingPain", self->client->ps.legsAnimTimer+Q_irand(0, 500*(2-g_spskill->integer)) );
+					TIMER_Set(self,"attacking",-level.time);
+					//allow us to re-evaluate our running speed/anim
+					TIMER_Set( self, "runfar", -1 );
+					TIMER_Set( self, "runclose", -1 );
+					TIMER_Set( self, "walk", -1 );
+
+					if ( self->NPC )
+					{
+						self->NPC->localState = LSTATE_WAITING;
+					}
+				}
+			}
+		}
+	}
+}
+
+void Wampa_DropVictim( gentity_t *self )
+{
+	//FIXME: if Wampa dies, it should drop its victim.
+	//FIXME: if Wampa is removed, it must remove its victim.
+	//FIXME: if in BOTH_HOLD_DROP, throw them a little, too?
+	if ( self->health > 0 )
+	{
+		NPC_SetAnim( self, SETANIM_BOTH, BOTH_STAND2TO1, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+	}
+	TIMER_Set(self,"attacking",-level.time);
+	if ( self->activator )
+	{
+		if ( self->activator->client )
+		{
+			self->activator->client->ps.eFlags &= ~EF_HELD_BY_WAMPA;
+		}
+		self->activator->activator = NULL;
+		NPC_SetAnim( self->activator, SETANIM_BOTH, BOTH_RELEASED, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+		self->activator->client->ps.legsAnimTimer += 500;
+		self->activator->client->ps.weaponTime = self->activator->client->ps.torsoAnimTimer = self->activator->client->ps.legsAnimTimer;
+		if ( self->activator->health > 0 )
+		{
+			if ( self->activator->NPC )
+			{//start thinking again
+				self->activator->NPC->nextBStateThink = level.time;
+			}
+			if ( self->activator->client && self->activator->s.number < MAX_CLIENTS )
+			{
+				vec3_t vicAngles = {30,AngleNormalize180(self->client->ps.viewangles[YAW]+180),0};
+				SetClientViewAngle( self->activator, vicAngles );
+			}
+		}
+		else
+		{
+			if ( self->enemy == self->activator )
+			{
+				self->enemy = NULL;
+			}
+			self->activator->clipmask &= ~CONTENTS_BODY;
+		}
+		self->activator = NULL;
+	}
+	self->count = 0;//drop him
+}
+
+qboolean Wampa_CheckDropVictim( gentity_t *self, qboolean excludeMe )
+{
+	if ( !self
+		|| !self->activator )
+	{
+		return qtrue;
+	}
+	vec3_t mins={self->activator->mins[0]-1,self->activator->mins[1]-1,0};
+	vec3_t maxs={self->activator->maxs[0]+1,self->activator->maxs[1]+1,1};
+	vec3_t start={self->activator->currentOrigin[0],self->activator->currentOrigin[1],self->activator->absmin[2]}; 
+	vec3_t end={self->activator->currentOrigin[0],self->activator->currentOrigin[1],self->activator->absmax[2]-1}; 
+	trace_t	trace;
+	if ( excludeMe )
+	{
+		gi.unlinkentity( self );
+	}
+	gi.trace( &trace, start, mins, maxs, end, self->activator->s.number, self->activator->clipmask );
+	if ( excludeMe )
+	{
+		gi.linkentity( self );
+	}
+	if ( !trace.allsolid && !trace.startsolid && trace.fraction >= 1.0f )
+	{
+		Wampa_DropVictim( self );
+		return qtrue;
+	}
+	if ( excludeMe )
+	{//victim stuck in wall
+		if ( self->NPC )
+		{//turn
+			self->NPC->desiredYaw += Q_irand( -30, 30 );
+			self->NPC->lockedDesiredYaw = self->NPC->desiredYaw;
+		}
+	}
+	return qfalse;
+}
+
+extern float NPC_EnemyRangeFromBolt( int boltIndex );
+qboolean Wampa_TryGrab( void )
+{
+	const float	radius = 64.0f;
+
+	if ( !NPC->enemy 
+		|| !NPC->enemy->client
+		|| NPC->enemy->health <= 0 )
+	{
+		return qfalse;
+	}
+	
+	float enemyDist = NPC_EnemyRangeFromBolt( NPC->handRBolt );
+	if ( enemyDist <= radius
+		&& !NPC->count //don't have one in hand already
+		&& NPC->enemy->client->NPC_class != CLASS_RANCOR
+		&& NPC->enemy->client->NPC_class != CLASS_GALAKMECH
+		&& NPC->enemy->client->NPC_class != CLASS_ATST
+		&& NPC->enemy->client->NPC_class != CLASS_GONK
+		&& NPC->enemy->client->NPC_class != CLASS_R2D2
+		&& NPC->enemy->client->NPC_class != CLASS_R5D2
+		&& NPC->enemy->client->NPC_class != CLASS_MARK1
+		&& NPC->enemy->client->NPC_class != CLASS_MARK2
+		&& NPC->enemy->client->NPC_class != CLASS_MOUSE
+		&& NPC->enemy->client->NPC_class != CLASS_PROBE
+		&& NPC->enemy->client->NPC_class != CLASS_SEEKER
+		&& NPC->enemy->client->NPC_class != CLASS_REMOTE
+		&& NPC->enemy->client->NPC_class != CLASS_SENTRY
+		&& NPC->enemy->client->NPC_class != CLASS_INTERROGATOR
+		&& NPC->enemy->client->NPC_class != CLASS_VEHICLE )
+	{//grab
+		NPC->enemy = NPC->enemy;//make him my new best friend
+		NPC->enemy->client->ps.eFlags |= EF_HELD_BY_WAMPA;
+		//FIXME: this makes it so that the victim can't hit us with shots!  Just use activator or something
+		NPC->enemy->activator = NPC; // kind of dumb, but when we are locked to the Rancor, we are owned by it.
+		NPC->activator = NPC->enemy;//remember him
+		NPC->count = 1;//in my hand
+		//wait to attack
+		TIMER_Set( NPC, "attacking", NPC->client->ps.legsAnimTimer + Q_irand(500, 2500) );
+		NPC_SetAnim( NPC->enemy, SETANIM_BOTH, BOTH_GRABBED, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+		NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_HOLD_END, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+		TIMER_Set( NPC, "takingPain", -level.time );
+		return qtrue;
+	}
+	else if ( enemyDist < radius*2.0f )
+	{//smack
+		G_Sound( NPC->enemy, G_SoundIndex( "sound/chars/rancor/swipehit.wav" ) );
+		//actually push the enemy
+		vec3_t pushDir;
+		vec3_t angs;
+		VectorCopy( NPC->client->ps.viewangles, angs );
+		angs[YAW] += Q_flrand( 25, 50 );
+		angs[PITCH] = Q_flrand( -25, -15 );
+		AngleVectors( angs, pushDir, NULL, NULL );
+		if ( NPC->enemy->client->NPC_class != CLASS_RANCOR
+			&& NPC->enemy->client->NPC_class != CLASS_ATST
+			&& !(NPC->enemy->flags&FL_NO_KNOCKBACK) )
+		{
+			G_Throw( NPC->enemy, pushDir, Q_irand( 30, 70 ) );
+			if ( NPC->enemy->health > 0 )
+			{//do pain on enemy
+				G_Knockdown( NPC->enemy, NPC, pushDir, 300, qtrue );
+			}
+		}
+	}
+	return qfalse;
+}
+
+/*
+-------------------------
+NPC_BSWampa_Default
+-------------------------
+*/
+void NPC_BSWampa_Default( void )
+{
+	//NORMAL ANIMS
+	//	stand1 = normal stand
+	//	walk1 = normal, non-angry walk
+	//	walk2 = injured
+	//	run1 = far away run
+	//	run2 = close run
+	//VICTIM ANIMS
+	//	grabswipe = melee1 - sweep out and grab
+	//	stand2 attack = attack4 - while holding victim, swipe at him
+	//	walk3_drag = walk5 - walk with drag
+	//	stand2 = hold victim
+	//	stand2to1 = drop victim
+	if ( NPC->client->ps.legsAnim == BOTH_HOLD_START )
+	{
+		NPC_FaceEnemy( qtrue );
+		if ( NPC->client->ps.legsAnimTimer < 200 )
+		{//see if he's there to grab
+			if ( !Wampa_TryGrab() )
+			{
+				NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_HOLD_MISS, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+			}
+		}
+		return;
+	}
+
+
+	if ( NPC->count )
+	{
+		if ( !NPC->activator 
+			|| !NPC->activator->client )
+		{//wtf?
+			NPC->count = 0;
+			NPC->activator = NULL;
+		}
+		else
+		{
+			if ( NPC->client->ps.legsAnim == BOTH_HOLD_DROP )
+			{
+				if ( NPC->client->ps.legsAnimTimer < PM_AnimLength(NPC->client->clientInfo.animFileIndex, (animNumber_t)NPC->client->ps.legsAnim)-500 )
+				{//at least half a second into the anim
+					if ( Wampa_CheckDropVictim( NPC, qfalse ) )
+					{
+						TIMER_Set( NPC, "attacking", 1000+(Q_irand(500,1000)*(3-g_spskill->integer)) );
+					}
+				}
+			}
+			else if ( !TIMER_Done( NPC, "takingPain" ) )
+			{
+				Wampa_CheckDropVictim( NPC, qfalse );
+			}
+			else if ( NPC->activator->health <= 0 )
+			{
+				if ( TIMER_Done(NPC,"sniffCorpse") )
+				{
+					Wampa_CheckDropVictim( NPC, qfalse );
+				}
+			}
+			else if ( NPC->useDebounceTime >= level.time 
+				&& NPC->activator )
+			{//just sniffing the guy
+				if ( NPC->useDebounceTime <= level.time + 100 
+					&& NPC->client->ps.legsAnim != BOTH_HOLD_DROP)
+				{//just about done, drop him
+					NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_HOLD_DROP, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+					TIMER_Set( NPC, "attacking", NPC->client->ps.legsAnimTimer+500 );
+				}
+			}
+			else
+			{
+				if ( !NPC->useDebounceTime 
+					&& NPC->activator 
+					&& NPC->activator->s.number < MAX_CLIENTS )
+				{//first time I pick the player, just sniff them
+					if ( TIMER_Done(NPC,"attacking") )
+					{//ready to attack
+						NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_HOLD_SNIFF, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+						NPC->useDebounceTime = level.time + NPC->client->ps.legsAnimTimer + Q_irand( 500, 2000 );
+					}
+				}
+				else
+				{
+					if ( TIMER_Done(NPC,"attacking") )
+					{//ready to attack
+						NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_HOLD_ATTACK/*BOTH_ATTACK4*/, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+						TIMER_Set(NPC,"grabAttackDamage",1400);
+						TIMER_Set(NPC,"attacking",NPC->client->ps.legsAnimTimer+Q_irand(3000,10000));
+					}
+
+					if ( NPC->client->ps.legsAnim == BOTH_HOLD_ATTACK )
+					{
+						if ( NPC->client->ps.legsAnimTimer )
+						{
+							if ( TIMER_Done2(NPC,"grabAttackDamage",qtrue) )
+							{
+								G_Sound( NPC->activator, G_SoundIndex( "sound/chars/rancor/swipehit.wav" ) );
+								G_Damage( NPC->activator, NPC, NPC, vec3_origin, NPC->activator->currentOrigin, Q_irand( 25, 40 ), (DAMAGE_NO_KNOCKBACK|DAMAGE_NO_ARMOR), MOD_MELEE );
+								if ( NPC->activator->health <= 0 )
+								{//killed them, chance of dismembering
+									int hitLoc = HL_WAIST;
+									if ( g_dismemberment->integer != 113811381138 )
+									{
+										hitLoc = Q_irand( HL_WAIST, HL_HAND_LT );
+									}
+									else
+									{
+										hitLoc = Q_irand( HL_WAIST, HL_HEAD );
+									}
+									NPC->activator->client->dismembered = false;
+									//FIXME: the limb should just disappear, cuz I ate it
+									G_DoDismemberment( NPC->activator, NPC->activator->currentOrigin, MOD_SABER, 1000, hitLoc, qtrue );
+									TIMER_Set( NPC, "sniffCorpse", Q_irand( 2000, 5000 ) );
+								}
+								NPC_SetAnim( NPC->activator, SETANIM_BOTH, BOTH_HANG_PAIN, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+							}
+						}
+						else
+						{
+							NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_HOLD_IDLE/*BOTH_ATTACK4*/, SETANIM_FLAG_NORMAL );
+						}
+					}
+					else if ( NPC->client->ps.legsAnim == BOTH_STAND2TO1
+						&& !NPC->client->ps.legsAnimTimer )
+					{
+						NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_HOLD_IDLE, SETANIM_FLAG_NORMAL );
+					}
+				}
+			}
+		}
+
+		NPC_UpdateAngles( qtrue, qtrue );
+		return;
+	}
+
+	if ( NPCInfo->localState == LSTATE_WAITING 
+		&& TIMER_Done2( NPC, "takingPain", qtrue ) )
+	{//was not doing anything because we were taking pain, but pain is done now, so clear it...
+		NPCInfo->localState = LSTATE_CLEAR;
+	}
+
+	if ( !TIMER_Done( NPC, "rageTime" ) )
+	{//do nothing but roar first time we see an enemy
+		NPC_FaceEnemy( qtrue );
+		return;
+	}
+	if ( NPC->enemy )
+	{
+		if ( NPC->enemy->client //enemy is a client
+			&& (NPC->enemy->client->NPC_class == CLASS_UGNAUGHT || NPC->enemy->client->NPC_class == CLASS_JAWA )//enemy is a lowly jawa or ugnaught
+			&& NPC->enemy->enemy != NPC//enemy's enemy is not me
+			&& (!NPC->enemy->enemy || !NPC->enemy->enemy->client || NPC->enemy->enemy->client->NPC_class!=CLASS_RANCOR) )//enemy's enemy is not a client or is not a rancor (which is scarier than me)
+		{//they should be scared of ME and no-one else
+			G_SetEnemy( NPC->enemy, NPC );
+		}
+		if ( !TIMER_Done(NPC,"attacking") )
+		{//in middle of attack
+			//face enemy
+			NPC_FaceEnemy( qtrue );
+			//continue attack logic
+			enemyDist = Distance( NPC->currentOrigin, NPC->enemy->currentOrigin );
+			Wampa_Attack( enemyDist, qfalse );
+			return;
+		}
+		else
+		{
+			if ( TIMER_Done(NPC,"angrynoise") )
+			{
+				G_SoundOnEnt( NPC, CHAN_AUTO, va("sound/chars/wampa/misc/anger%d.wav", Q_irand(1, 2)) );
+
+				TIMER_Set( NPC, "angrynoise", Q_irand( 5000, 10000 ) );
+			}
+			//else, if he's in our hand, we eat, else if he's on the ground, we keep attacking his dead body for a while
+			if( NPC->enemy->client && NPC->enemy->client->NPC_class == CLASS_WAMPA )
+			{//got mad at another Wampa, look for a valid enemy
+				if ( TIMER_Done( NPC, "wampaInfight" ) )
+				{
+					NPC_CheckEnemyExt( qtrue );
+				}
+			}
+			else
+			{
+				if ( NPC_ValidEnemy( NPC->enemy ) == qfalse )
+				{
+					TIMER_Remove( NPC, "lookForNewEnemy" );//make them look again right now
+					if ( !NPC->enemy->inuse || level.time - NPC->enemy->s.time > Q_irand( 10000, 15000 ) )
+					{//it's been a while since the enemy died, or enemy is completely gone, get bored with him
+						NPC->enemy = NULL;
+						Wampa_Patrol();
+						NPC_UpdateAngles( qtrue, qtrue );
+						return;
+					}
+				}
+				if ( TIMER_Done( NPC, "lookForNewEnemy" ) )
+				{
+					gentity_t *sav_enemy = NPC->enemy;//FIXME: what about NPC->lastEnemy?
+					NPC->enemy = NULL;
+					gentity_t *newEnemy = NPC_CheckEnemy( NPCInfo->confusionTime < level.time, qfalse, qfalse );
+					NPC->enemy = sav_enemy;
+					if ( newEnemy && newEnemy != sav_enemy )
+					{//picked up a new enemy!
+						NPC->lastEnemy = NPC->enemy;
+						G_SetEnemy( NPC, newEnemy );
+						if ( NPC->enemy != NPC->lastEnemy )
+						{//clear this so that we only sniff the player the first time we pick them up
+							NPC->useDebounceTime = 0;
+						}
+						//hold this one for at least 5-15 seconds
+						TIMER_Set( NPC, "lookForNewEnemy", Q_irand( 5000, 15000 ) );
+					}
+					else
+					{//look again in 2-5 secs
+						TIMER_Set( NPC, "lookForNewEnemy", Q_irand( 2000, 5000 ) );
+					}
+				}
+			}
+			Wampa_Combat();
+			return;
+		}
+	}
+	else 
+	{
+		if ( TIMER_Done(NPC,"idlenoise") )
+		{
+			G_SoundOnEnt( NPC, CHAN_AUTO, "sound/chars/wampa/misc/anger3.wav" );
+
+			TIMER_Set( NPC, "idlenoise", Q_irand( 2000, 4000 ) );
+		}
+		if ( NPCInfo->scriptFlags & SCF_LOOK_FOR_ENEMIES )
+		{
+			Wampa_Patrol();
+		}
+		else
+		{
+			Wampa_Idle();
+		}
+	}
+
+	NPC_UpdateAngles( qtrue, qtrue );
+}
diff --git a/code/game/AnimalNPC.c b/code/game/AnimalNPC.c
new file mode 100644
index 0000000..124dc5e
--- /dev/null
+++ b/code/game/AnimalNPC.c
@@ -0,0 +1,1065 @@
+// leave this line at the top for all g_xxxx.cpp files...
+#include "g_headers.h"
+
+//seems to be a compiler bug, it doesn't clean out the #ifdefs between dif-compiles
+//or something, so the headers spew errors on these defs from the previous compile.
+//this fixes that. -rww
+#ifdef _JK2MP
+//get rid of all the crazy defs we added for this file
+#undef currentAngles
+#undef currentOrigin
+#undef mins
+#undef maxs
+#undef legsAnimTimer
+#undef torsoAnimTimer
+#undef bool
+#undef false
+#undef true
+
+#undef sqrtf
+#undef Q_flrand
+
+#undef MOD_EXPLOSIVE
+#endif
+
+#ifdef _JK2 //SP does not have this preprocessor for game like MP does
+#ifndef _JK2MP
+#define _JK2MP
+#endif
+#endif
+
+#ifndef _JK2MP //if single player
+#ifndef QAGAME //I don't think we have a QAGAME define
+#define QAGAME //but define it cause in sp we're always in the game
+#endif
+#endif
+
+#ifdef QAGAME //including game headers on cgame is FORBIDDEN ^_^
+#include "g_local.h"
+#elif defined _JK2MP
+#include "bg_public.h"
+#endif
+
+#ifndef _JK2MP
+#include "g_functions.h"
+#include "g_vehicles.h"
+#include "..\game\wp_saber.h"
+#else
+#include "bg_vehicles.h"
+#endif
+
+#ifdef _JK2MP
+//this is really horrible, but it works! just be sure not to use any locals or anything
+//with these names (exluding bool, false, true). -rww
+#define currentAngles r.currentAngles
+#define currentOrigin r.currentOrigin
+#define mins r.mins
+#define maxs r.maxs
+#define legsAnimTimer legsTimer
+#define torsoAnimTimer torsoTimer
+#define bool qboolean
+#define false qfalse
+#define true qtrue
+
+#define sqrtf sqrt
+#define Q_flrand flrand
+
+#define MOD_EXPLOSIVE MOD_SUICIDE
+#else
+#define bgEntity_t gentity_t
+#endif
+
+#ifdef QAGAME //we only want a few of these functions for BG
+
+extern float DotToSpot( vec3_t spot, vec3_t from, vec3_t fromAngles );
+extern vmCvar_t	cg_thirdPersonAlpha;
+extern vec3_t playerMins;
+extern vec3_t playerMaxs;
+extern cvar_t	*g_speederControlScheme;
+
+#ifdef _JK2MP
+#include "../namespace_begin.h"
+#endif
+extern void PM_SetAnim(pmove_t	*pm,int setAnimParts,int anim,int setAnimFlags, int blendTime);
+extern int PM_AnimLength( int index, animNumber_t anim );
+#ifdef _JK2MP
+#include "../namespace_end.h"
+#endif
+
+#ifndef	_JK2MP
+extern void CG_ChangeWeapon( int num );
+#endif
+
+extern void Vehicle_SetAnim(gentity_t *ent,int setAnimParts,int anim,int setAnimFlags, int iBlend);
+extern void G_Knockdown( gentity_t *self, gentity_t *attacker, const vec3_t pushDir, float strength, qboolean breakSaberLock );
+extern void G_VehicleTrace( trace_t *results, const vec3_t start, const vec3_t tMins, const vec3_t tMaxs, const vec3_t end, int passEntityNum, int contentmask );
+
+// Update death sequence.
+static void DeathUpdate( Vehicle_t *pVeh )
+{
+	if ( level.time >= pVeh->m_iDieTime )
+	{
+		// If the vehicle is not empty.
+		if ( pVeh->m_pVehicleInfo->Inhabited( pVeh ) )
+		{
+			pVeh->m_pVehicleInfo->EjectAll( pVeh );
+		}
+		else
+		{
+			// Waste this sucker.
+		}
+
+		// Die now...
+/*		else
+		{
+			vec3_t	mins, maxs, bottom;
+			trace_t	trace;
+
+			if ( pVeh->m_pVehicleInfo->explodeFX )
+			{
+				G_PlayEffect( pVeh->m_pVehicleInfo->explodeFX, parent->currentOrigin );
+				//trace down and place mark
+				VectorCopy( parent->currentOrigin, bottom );
+				bottom[2] -= 80;
+				gi.trace( &trace, parent->currentOrigin, vec3_origin, vec3_origin, bottom, parent->s.number, CONTENTS_SOLID );
+				if ( trace.fraction < 1.0f )
+				{
+					VectorCopy( trace.endpos, bottom );
+					bottom[2] += 2;
+					G_PlayEffect( "ships/ship_explosion_mark", trace.endpos );
+				}
+			}
+
+			parent->takedamage = qfalse;//so we don't recursively damage ourselves
+			if ( pVeh->m_pVehicleInfo->explosionRadius > 0 && pVeh->m_pVehicleInfo->explosionDamage > 0 )
+			{
+				VectorCopy( parent->mins, mins );
+				mins[2] = -4;//to keep it off the ground a *little*
+				VectorCopy( parent->maxs, maxs );
+				VectorCopy( parent->currentOrigin, bottom );
+				bottom[2] += parent->mins[2] - 32;
+				gi.trace( &trace, parent->currentOrigin, mins, maxs, bottom, parent->s.number, CONTENTS_SOLID );
+				G_RadiusDamage( trace.endpos, NULL, pVeh->m_pVehicleInfo->explosionDamage, pVeh->m_pVehicleInfo->explosionRadius, NULL, MOD_EXPLOSIVE );//FIXME: extern damage and radius or base on fuel
+			}
+
+			parent->e_ThinkFunc = thinkF_G_FreeEntity;
+			parent->nextthink = level.time + FRAMETIME;
+		}*/
+	}
+}
+
+// Like a think or move command, this updates various vehicle properties.
+static bool Update( Vehicle_t *pVeh, const usercmd_t *pUcmd )
+{
+	return g_vehicleInfo[VEHICLE_BASE].Update( pVeh, pUcmd );
+}
+#endif //QAGAME
+
+#ifdef _JK2MP
+#include "../namespace_begin.h"
+#endif
+
+//MP RULE - ALL PROCESSMOVECOMMANDS FUNCTIONS MUST BE BG-COMPATIBLE!!!
+//If you really need to violate this rule for SP, then use ifdefs.
+//By BG-compatible, I mean no use of game-specific data - ONLY use
+//stuff available in the MP bgEntity (in SP, the bgEntity is #defined
+//as a gentity, but the MP-compatible access restrictions are based
+//on the bgEntity structure in the MP codebase) -rww
+// ProcessMoveCommands the Vehicle.
+static void ProcessMoveCommands( Vehicle_t *pVeh )
+{
+	/************************************************************************************/
+	/*	BEGIN	Here is where we move the vehicle (forward or back or whatever). BEGIN	*/
+	/************************************************************************************/
+
+	//Client sets ucmds and such for speed alterations
+	float speedInc, speedIdleDec, speedIdle, speedIdleAccel, speedMin, speedMax;
+	float fWalkSpeedMax;
+	int		curTime;
+	bgEntity_t *parent = pVeh->m_pParentEntity;
+#ifdef _JK2MP
+	playerState_t *parentPS = parent->playerState;
+#else
+	playerState_t *parentPS = &parent->client->ps;
+#endif
+
+#ifndef _JK2MP//SP
+	curTime = level.time;
+#elif QAGAME//MP GAME
+	curTime = level.time;
+#elif CGAME//MP CGAME
+	//FIXME: pass in ucmd?  Not sure if this is reliable...
+	curTime = pm->cmd.serverTime;
+#endif
+
+
+#ifndef _JK2MP //bad for prediction - fixme
+	// Bucking so we can't do anything.
+	if ( pVeh->m_ulFlags & VEH_BUCKING || pVeh->m_ulFlags & VEH_FLYING || pVeh->m_ulFlags & VEH_CRASHING )
+	{
+//#ifdef QAGAME //this was in Update above
+//		((gentity_t *)parent)->client->ps.speed = 0;
+//#endif
+		parentPS->speed = 0;
+		return;
+	}
+#endif
+	speedIdleDec = pVeh->m_pVehicleInfo->decelIdle * pVeh->m_fTimeModifier;
+	speedMax = pVeh->m_pVehicleInfo->speedMax;
+
+	speedIdle = pVeh->m_pVehicleInfo->speedIdle;
+	speedIdleAccel = pVeh->m_pVehicleInfo->accelIdle * pVeh->m_fTimeModifier;
+	speedMin = pVeh->m_pVehicleInfo->speedMin;
+
+
+
+	if ( pVeh->m_pPilot /*&& (pilotPS->weapon == WP_NONE || pilotPS->weapon == WP_MELEE )*/ &&
+		(pVeh->m_ucmd.buttons & BUTTON_ALT_ATTACK) && pVeh->m_pVehicleInfo->turboSpeed )
+	{
+		if ((curTime - pVeh->m_iTurboTime)>pVeh->m_pVehicleInfo->turboRecharge)
+		{
+			pVeh->m_iTurboTime = (curTime + pVeh->m_pVehicleInfo->turboDuration);
+#ifndef _JK2MP //kill me now
+			if (pVeh->m_pVehicleInfo->soundTurbo)
+			{
+				G_SoundIndexOnEnt(pVeh->m_pParentEntity, CHAN_AUTO, pVeh->m_pVehicleInfo->soundTurbo);
+			}
+#endif
+			parentPS->speed = pVeh->m_pVehicleInfo->turboSpeed;	// Instantly Jump To Turbo Speed
+		}
+	}
+
+	if ( curTime < pVeh->m_iTurboTime )
+	{
+		speedMax = pVeh->m_pVehicleInfo->turboSpeed;
+	}
+	else
+	{
+		speedMax = pVeh->m_pVehicleInfo->speedMax;
+	}
+
+#ifdef _JK2MP
+	if ( !parentPS->m_iVehicleNum  )
+#else
+	if ( !pVeh->m_pVehicleInfo->Inhabited( pVeh ) )
+#endif
+	{//drifts to a stop
+		speedInc = speedIdle * pVeh->m_fTimeModifier;
+		VectorClear( parentPS->moveDir );
+		//m_ucmd.forwardmove = 127;
+		parentPS->speed = 0;
+	}
+	else
+	{
+		speedInc = pVeh->m_pVehicleInfo->acceleration * pVeh->m_fTimeModifier;
+	}
+
+	if ( parentPS->speed || parentPS->groundEntityNum == ENTITYNUM_NONE  ||
+		 pVeh->m_ucmd.forwardmove || pVeh->m_ucmd.upmove > 0 )
+	{ 
+		if ( pVeh->m_ucmd.forwardmove > 0 && speedInc )
+		{
+			parentPS->speed += speedInc;
+		}
+		else if ( pVeh->m_ucmd.forwardmove < 0 )
+		{
+			if ( parentPS->speed > speedIdle )
+			{
+				parentPS->speed -= speedInc;
+			}
+			else if ( parentPS->speed > speedMin )
+			{
+				parentPS->speed -= speedIdleDec;
+			}
+		}
+		// No input, so coast to stop.
+		else if ( parentPS->speed > 0.0f )
+		{
+			parentPS->speed -= speedIdleDec;
+			if ( parentPS->speed < 0.0f )
+			{
+				parentPS->speed = 0.0f;
+			}
+		}
+		else if ( parentPS->speed < 0.0f )
+		{
+			parentPS->speed += speedIdleDec;
+			if ( parentPS->speed > 0.0f )
+			{
+				parentPS->speed = 0.0f;
+			}
+		}
+	}
+	else
+	{
+		if ( pVeh->m_ucmd.forwardmove < 0 )
+		{
+			pVeh->m_ucmd.forwardmove = 0;
+		}
+		if ( pVeh->m_ucmd.upmove < 0 )
+		{
+			pVeh->m_ucmd.upmove = 0;
+		}
+
+		//pVeh->m_ucmd.rightmove = 0;
+
+		/*if ( !pVeh->m_pVehicleInfo->strafePerc 
+			|| (!g_speederControlScheme->value && !parent->s.number) )
+		{//if in a strafe-capable vehicle, clear strafing unless using alternate control scheme
+			pVeh->m_ucmd.rightmove = 0;
+		}*/
+	}
+
+	fWalkSpeedMax = speedMax * 0.275f;
+	if ( curTime>pVeh->m_iTurboTime && (pVeh->m_ucmd.buttons & BUTTON_WALKING) && parentPS->speed > fWalkSpeedMax )
+	{
+		parentPS->speed = fWalkSpeedMax;
+	}
+	else if ( parentPS->speed > speedMax )
+	{
+		parentPS->speed = speedMax;
+	}
+	else if ( parentPS->speed < speedMin )
+	{
+		parentPS->speed = speedMin;
+	}
+
+	/********************************************************************************/
+	/*	END Here is where we move the vehicle (forward or back or whatever). END	*/
+	/********************************************************************************/
+}
+
+//MP RULE - ALL PROCESSORIENTCOMMANDS FUNCTIONS MUST BE BG-COMPATIBLE!!!
+//If you really need to violate this rule for SP, then use ifdefs.
+//By BG-compatible, I mean no use of game-specific data - ONLY use
+//stuff available in the MP bgEntity (in SP, the bgEntity is #defined
+//as a gentity, but the MP-compatible access restrictions are based
+//on the bgEntity structure in the MP codebase) -rww
+// ProcessOrientCommands the Vehicle.
+static void ProcessOrientCommands( Vehicle_t *pVeh )
+{
+	/********************************************************************************/
+	/*	BEGIN	Here is where make sure the vehicle is properly oriented.	BEGIN	*/
+	/********************************************************************************/
+	bgEntity_t *parent = pVeh->m_pParentEntity;
+	playerState_t *parentPS, *riderPS;
+	
+#ifdef _JK2MP
+	bgEntity_t *rider = NULL;
+	if (parent->s.owner != ENTITYNUM_NONE)
+	{
+		rider = PM_BGEntForNum(parent->s.owner); //&g_entities[parent->r.ownerNum];
+	}
+#else
+	gentity_t *rider = parent->owner;
+#endif
+
+	// Bucking so we can't do anything.
+#ifndef _JK2MP //bad for prediction - fixme
+	if ( pVeh->m_ulFlags & VEH_BUCKING || pVeh->m_ulFlags & VEH_FLYING || pVeh->m_ulFlags & VEH_CRASHING )
+	{
+		return;
+	}
+#endif
+
+#ifdef _JK2MP
+	if ( !rider )
+#else
+	if ( !rider || !rider->client )
+#endif
+	{
+		rider = parent;
+	}
+
+
+
+#ifdef _JK2MP
+	parentPS = parent->playerState;
+	riderPS = rider->playerState;
+#else
+	parentPS = &parent->client->ps;
+	riderPS = &rider->client->ps;
+#endif
+
+	if (rider)
+	{
+#ifdef _JK2MP
+	float angDif = AngleSubtract(pVeh->m_vOrientation[YAW], riderPS->viewangles[YAW]);
+	if (parentPS && parentPS->speed)
+	{
+		float s = parentPS->speed;
+		float maxDif = pVeh->m_pVehicleInfo->turningSpeed*4.0f; //magic number hackery
+		if (s < 0.0f)
+		{
+			s = -s;
+		}
+		angDif *= s/pVeh->m_pVehicleInfo->speedMax;
+		if (angDif > maxDif)
+		{
+			angDif = maxDif;
+		}
+		else if (angDif < -maxDif)
+		{
+			angDif = -maxDif;
+		}
+		pVeh->m_vOrientation[YAW] = AngleNormalize180(pVeh->m_vOrientation[YAW] - angDif*(pVeh->m_fTimeModifier*0.2f));
+	}
+#else
+		pVeh->m_vOrientation[YAW] = riderPS->viewangles[YAW];
+#endif
+	}
+
+
+/*	speed = VectorLength( parentPS->velocity );
+
+	// If the player is the rider...
+	if ( rider->s.number < MAX_CLIENTS )
+	{//FIXME: use the vehicle's turning stat in this calc
+		pVeh->m_vOrientation[YAW] = riderPS->viewangles[YAW];
+	}
+	else
+	{
+		float turnSpeed = pVeh->m_pVehicleInfo->turningSpeed;
+		if ( !pVeh->m_pVehicleInfo->turnWhenStopped 
+			&& !parentPS->speed )//FIXME: or !pVeh->m_ucmd.forwardmove?
+		{//can't turn when not moving
+			//FIXME: or ramp up to max turnSpeed?
+			turnSpeed = 0.0f;
+		}
+#ifdef _JK2MP
+		if (rider->s.eType == ET_NPC)
+#else
+		if ( !rider || rider->NPC )
+#endif
+		{//help NPCs out some
+			turnSpeed *= 2.0f;
+#ifdef _JK2MP
+			if (parentPS->speed > 200.0f)
+#else
+			if ( parent->client->ps.speed > 200.0f )
+#endif
+			{
+				turnSpeed += turnSpeed * parentPS->speed/200.0f*0.05f;
+			}
+		}
+		turnSpeed *= pVeh->m_fTimeModifier;
+
+		//default control scheme: strafing turns, mouselook aims
+		if ( pVeh->m_ucmd.rightmove < 0 )
+		{
+			pVeh->m_vOrientation[YAW] += turnSpeed;
+		}
+		else if ( pVeh->m_ucmd.rightmove > 0 )
+		{
+			pVeh->m_vOrientation[YAW] -= turnSpeed;
+		}
+
+		if ( pVeh->m_pVehicleInfo->malfunctionArmorLevel && pVeh->m_iArmor <= pVeh->m_pVehicleInfo->malfunctionArmorLevel )
+		{//damaged badly
+		}
+	}*/
+
+	/********************************************************************************/
+	/*	END	Here is where make sure the vehicle is properly oriented.	END			*/
+	/********************************************************************************/
+}
+
+#ifdef _JK2MP //temp hack til mp speeder controls are sorted -rww
+void AnimalProcessOri(Vehicle_t *pVeh)
+{
+	ProcessOrientCommands(pVeh);
+}
+#endif
+
+#ifdef QAGAME //back to our game-only functions
+// This function makes sure that the vehicle is properly animated.
+/*
+static void AnimalTailSwipe(Vehicle_t* pVeh, gentity_t *parent, gentity_t *pilot)
+{
+	trace_t	trace;
+	vec3_t angles;
+	vec3_t vRoot, vTail;
+	vec3_t	lMins, lMaxs;
+	mdxaBone_t	boltMatrix;
+	int iRootBone;
+	int iRootTail;
+
+	VectorSet(angles, 0, parent->currentAngles[YAW], 0);
+	VectorSet(lMins, parent->mins[0]-1, parent->mins[1]-1, 0);
+	VectorSet(lMaxs, parent->maxs[0]+1, parent->maxs[1]+1, 1);
+#ifdef _JK2MP
+	iRootBone = trap_G2API_AddBolt( parent->ghoul2, 0, "tail_01" );
+	iRootTail = trap_G2API_AddBolt( parent->ghoul2, 0, "tail_04" );
+
+	// Get the positions of the root of the tail and the tail end of it.
+	trap_G2API_GetBoltMatrix( parent->ghoul2, 0, iRootBone,
+				&boltMatrix, angles, parent->currentOrigin, level.time,
+				NULL, parent->modelScale );
+	BG_GiveMeVectorFromMatrix( &boltMatrix, ORIGIN, vRoot );
+
+	trap_G2API_GetBoltMatrix( parent->ghoul2, 0, iRootTail,
+				&boltMatrix, angles, parent->currentOrigin, level.time,
+				NULL, parent->modelScale );
+	BG_GiveMeVectorFromMatrix( &boltMatrix, ORIGIN, vTail );
+#else
+	iRootBone = gi.G2API_GetBoneIndex( &parent->ghoul2[parent->playerModel], "tail_01", qtrue );
+	iRootTail = gi.G2API_GetBoneIndex( &parent->ghoul2[parent->playerModel], "tail_04", qtrue );
+
+	// Get the positions of the root of the tail and the tail end of it.
+	gi.G2API_GetBoltMatrix( parent->ghoul2, parent->playerModel, iRootBone,
+				&boltMatrix, angles, parent->currentOrigin, (cg.time?cg.time:level.time),
+				NULL, parent->s.modelScale );
+	gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, vRoot );
+
+	gi.G2API_GetBoltMatrix( parent->ghoul2, parent->playerModel, iRootTail,
+				&boltMatrix, angles, parent->currentOrigin, (cg.time?cg.time:level.time),
+				NULL, parent->s.modelScale );
+	gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, vTail );
+#endif
+
+	// Trace from the root of the tail to the very end.
+	G_VehicleTrace( &trace, vRoot, lMins, lMaxs, vTail, parent->s.number, MASK_NPCSOLID );
+	if ( trace.fraction < 1.0f )
+	{
+		if ( ENTITYNUM_NONE != trace.entityNum && g_entities[trace.entityNum].client &&
+#ifndef _JK2MP //no rancor in jk2mp (at least not currently)
+			g_entities[trace.entityNum].client->NPC_class != CLASS_RANCOR &&
+#else //and in mp want to check inuse
+			g_entities[trace.entityNum].inuse &&
+#endif
+			g_entities[trace.entityNum].client->NPC_class != CLASS_VEHICLE )
+		{
+			vec3_t pushDir;
+			vec3_t angs;
+			int iDamage = 10;
+			// Get the direction we're facing.
+			VectorCopy( parent->client->ps.viewangles, angs );
+			// Add some fudge.
+			angs[YAW] += Q_flrand( 5, 15 );
+			angs[PITCH] = Q_flrand( -20, -10 );
+			AngleVectors( angs, pushDir, NULL, NULL );
+			// Reverse direction.
+			pushDir[YAW] = -pushDir[YAW];
+
+			// Smack this ho down.
+#ifdef _JK2MP
+			G_Sound( &g_entities[trace.entityNum], CHAN_AUTO, G_SoundIndex( "sound/chars/rancor/swipehit.wav" ) );
+#else
+			G_Sound( &g_entities[trace.entityNum], G_SoundIndex( "sound/chars/rancor/swipehit.wav" ) );
+#endif
+			G_Throw( &g_entities[trace.entityNum], pushDir, 50 );
+
+			if ( g_entities[trace.entityNum].health > 0 )
+			{
+				// Knock down and dish out some hurt.
+				gentity_t *hit = &g_entities[trace.entityNum];
+#ifdef _JK2MP
+				if (BG_KnockDownable(&hit->client->ps))
+				{
+					hit->client->ps.forceHandExtend = HANDEXTEND_KNOCKDOWN;
+					hit->client->ps.forceHandExtendTime = pm->cmd.serverTime + 1100;
+					hit->client->ps.forceDodgeAnim = 0; //this toggles between 1 and 0, when it's 1 we should play the get up anim
+
+					hit->client->ps.otherKiller = pilot->s.number;
+					hit->client->ps.otherKillerTime = level.time + 5000;
+					hit->client->ps.otherKillerDebounceTime = level.time + 100;
+
+					hit->client->ps.velocity[0] = pushDir[0]*80;
+					hit->client->ps.velocity[1] = pushDir[1]*80;
+					hit->client->ps.velocity[2] = 100;
+				}
+#else
+				G_Knockdown( hit, parent, pushDir, 300, qtrue );
+#endif
+				G_Damage( hit, parent, parent, NULL, NULL, iDamage, DAMAGE_NO_KNOCKBACK | DAMAGE_IGNORE_TEAM, MOD_MELEE );
+				//G_PlayEffect( pVeh->m_pVehicleInfo->explodeFX, parent->currentOrigin );
+			}// Not Dead
+		}// Not Rancor & In USe
+	}// Trace Hit Anything?
+}
+*/
+static void AnimateVehicle( Vehicle_t *pVeh )
+{
+	animNumber_t	Anim = BOTH_VT_IDLE; 
+	int				iFlags = SETANIM_FLAG_NORMAL, iBlend = 300;
+	gentity_t *		pilot = (gentity_t *)pVeh->m_pPilot;
+	gentity_t *		parent = (gentity_t *)pVeh->m_pParentEntity;
+	playerState_t *	pilotPS;
+	playerState_t *	parentPS;
+	float			fSpeedPercToMax;
+
+#ifdef _JK2MP
+	pilotPS = (pilot)?(pilot->playerState):(0);
+	parentPS = parent->playerState;
+#else
+	pilotPS = (pilot)?(&pilot->client->ps):(0);
+	parentPS = &parent->client->ps;
+#endif
+
+	// We're dead (boarding is reused here so I don't have to make another variable :-).
+	if ( parent->health <= 0 ) 
+	{
+		if ( pVeh->m_iBoarding != -999 )	// Animate the death just once!
+		{
+			pVeh->m_iBoarding = -999;
+			iFlags = SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLD; 
+
+			// FIXME! Why do you keep repeating over and over!!?!?!? Bastard!
+			//Vehicle_SetAnim( parent, SETANIM_LEGS, BOTH_VT_DEATH1, iFlags, iBlend );
+		}
+		return;
+	}
+
+	// If they're bucking, play the animation and leave...
+	if ( parent->client->ps.legsAnim == BOTH_VT_BUCK )
+	{
+		// Done with animation? Erase the flag.
+		if ( parent->client->ps.legsAnimTimer <= 0 )
+		{
+			pVeh->m_ulFlags &= ~VEH_BUCKING;
+		}
+		else
+		{
+			return;
+		}
+	}
+	else if ( pVeh->m_ulFlags & VEH_BUCKING )
+	{
+		iFlags = SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLD;
+		Anim = BOTH_VT_BUCK;
+		iBlend = 500;
+		Vehicle_SetAnim( parent, SETANIM_LEGS, BOTH_VT_BUCK, iFlags, iBlend );
+		return;
+	}
+
+	// Boarding animation.
+	if ( pVeh->m_iBoarding != 0 )
+	{
+		// We've just started boarding, set the amount of time it will take to finish boarding.
+		if ( pVeh->m_iBoarding < 0 )
+		{
+			int iAnimLen;
+
+			// Boarding from left...
+			if ( pVeh->m_iBoarding == -1 )
+			{
+				Anim = BOTH_VT_MOUNT_L;
+			}
+			else if ( pVeh->m_iBoarding == -2 )
+			{
+				Anim = BOTH_VT_MOUNT_R;
+			}
+			else if ( pVeh->m_iBoarding == -3 )
+			{
+				Anim = BOTH_VT_MOUNT_B;
+			}
+
+			// Set the delay time (which happens to be the time it takes for the animation to complete).
+			// NOTE: Here I made it so the delay is actually 70% (0.7f) of the animation time.
+#ifdef _JK2MP
+			iAnimLen = BG_AnimLength( parent->localAnimIndex, Anim ) * 0.7f;
+#else
+			iAnimLen = PM_AnimLength( parent->client->clientInfo.animFileIndex, Anim ) * 0.7f;
+#endif
+			pVeh->m_iBoarding = level.time + iAnimLen;
+
+			// Set the animation, which won't be interrupted until it's completed.
+			// TODO: But what if he's killed? Should the animation remain persistant???
+			iFlags = SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLD;
+
+			Vehicle_SetAnim( parent, SETANIM_LEGS, Anim, iFlags, iBlend );
+			if (pilot)
+			{
+				Vehicle_SetAnim(pilot, SETANIM_BOTH, Anim, iFlags, iBlend );
+			}
+			return;
+		}
+		// Otherwise we're done.
+		else if ( pVeh->m_iBoarding <= level.time )
+		{
+			pVeh->m_iBoarding = 0;
+		}
+	}
+
+	// Percentage of maximum speed relative to current speed.
+	//float fSpeed = VectorLength( client->ps.velocity );
+	fSpeedPercToMax = parent->client->ps.speed / pVeh->m_pVehicleInfo->speedMax; 
+
+
+	// Going in reverse...
+	if ( fSpeedPercToMax < -0.01f )
+	{
+		Anim = BOTH_VT_WALK_REV;
+		iBlend = 600;
+	}
+	else
+	{
+		bool		Turbo		= (fSpeedPercToMax>0.0f && level.time<pVeh->m_iTurboTime);
+		bool		Walking		= (fSpeedPercToMax>0.0f && ((pVeh->m_ucmd.buttons&BUTTON_WALKING) || fSpeedPercToMax<=0.275f));
+		bool		Running		= (fSpeedPercToMax>0.275f);
+
+
+		// Remove Crashing Flag
+		//----------------------
+		pVeh->m_ulFlags &= ~VEH_CRASHING;
+
+		if (Turbo)
+		{// Kicked In Turbo
+			iBlend	= 50;
+			iFlags	= SETANIM_FLAG_OVERRIDE;
+			Anim	= BOTH_VT_TURBO;
+		}
+		else
+		{// No Special Moves
+			iBlend	= 300;
+ 			iFlags	= SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLDLESS;
+			Anim	= (Walking)?(BOTH_VT_WALK_FWD  ):((Running)?(BOTH_VT_RUN_FWD  ):(BOTH_VT_IDLE1));
+		}
+	}
+	Vehicle_SetAnim( parent, SETANIM_LEGS, Anim, iFlags, iBlend );
+}
+
+//rwwFIXMEFIXME: This is all going to have to be predicted I think, or it will feel awful
+//and lagged
+// This function makes sure that the rider's in this vehicle are properly animated.
+static void AnimateRiders( Vehicle_t *pVeh )
+{
+	animNumber_t Anim = BOTH_VT_IDLE;
+	int iFlags = SETANIM_FLAG_NORMAL, iBlend = 500;
+	gentity_t *pilot = (gentity_t *)pVeh->m_pPilot;
+	gentity_t *parent = (gentity_t *)pVeh->m_pParentEntity;
+	playerState_t *pilotPS;
+	playerState_t *parentPS;
+	float fSpeedPercToMax;
+
+#ifdef _JK2MP
+	pilotPS = pVeh->m_pPilot->playerState;
+	parentPS = pVeh->m_pPilot->playerState;
+#else
+	pilotPS = &pVeh->m_pPilot->client->ps;
+	parentPS = &pVeh->m_pParentEntity->client->ps;
+#endif
+
+	// Boarding animation.
+	if ( pVeh->m_iBoarding != 0 )
+	{
+		return;
+	}
+
+	// Percentage of maximum speed relative to current speed.
+	fSpeedPercToMax = parent->client->ps.speed / pVeh->m_pVehicleInfo->speedMax;
+
+/*	// Going in reverse...
+#ifdef _JK2MP //handled in pmove in mp
+	if (0)
+#else
+	if ( fSpeedPercToMax < -0.01f )
+#endif
+	{
+		Anim = BOTH_VT_WALK_REV;
+		iBlend = 600;
+		bool		HasWeapon	= ((pilotPS->weapon != WP_NONE) && (pilotPS->weapon != WP_MELEE));
+		if (HasWeapon)
+		{
+			if (pVeh->m_pPilot->s.number<MAX_CLIENTS)
+			{
+				CG_ChangeWeapon(WP_NONE);
+			}
+
+			pVeh->m_pPilot->client->ps.weapon = WP_NONE;
+			G_RemoveWeaponModels(pVeh->m_pPilot);
+		}
+	}
+	else
+*/
+	{
+		bool		HasWeapon	= ((pilotPS->weapon != WP_NONE) && (pilotPS->weapon != WP_MELEE));
+		bool		Attacking	= (HasWeapon && !!(pVeh->m_ucmd.buttons&BUTTON_ATTACK));
+		bool		Right		= (pVeh->m_ucmd.rightmove>0);
+		bool		Left		= (pVeh->m_ucmd.rightmove<0);
+		bool		Turbo		= (fSpeedPercToMax>0.0f && level.time<pVeh->m_iTurboTime);
+		bool		Walking		= (fSpeedPercToMax>0.0f && ((pVeh->m_ucmd.buttons&BUTTON_WALKING) || fSpeedPercToMax<=0.275f));
+		bool		Running		= (fSpeedPercToMax>0.275f);
+		EWeaponPose	WeaponPose	= WPOSE_NONE;
+
+
+		// Remove Crashing Flag
+		//----------------------
+		pVeh->m_ulFlags &= ~VEH_CRASHING;
+
+
+		// Put Away Saber When It Is Not Active
+		//--------------------------------------
+#ifndef _JK2MP
+		if (HasWeapon && 
+			(pVeh->m_pPilot->s.number>=MAX_CLIENTS || (cg.weaponSelectTime+500)<cg.time) &&
+			(pilotPS->weapon==WP_SABER && (Turbo || !pilotPS->SaberActive())))
+		{
+			if (pVeh->m_pPilot->s.number<MAX_CLIENTS)
+			{
+				CG_ChangeWeapon(WP_NONE);
+			}
+
+			pVeh->m_pPilot->client->ps.weapon = WP_NONE;
+			G_RemoveWeaponModels(pVeh->m_pPilot);
+		}
+#endif
+
+		// Don't Interrupt Attack Anims
+		//------------------------------
+#ifdef _JK2MP
+		if (pilotPS->weaponTime>0)
+		{
+			return;
+		}
+#else		
+		if (pilotPS->torsoAnim>=BOTH_VT_ATL_S && pilotPS->torsoAnim<=BOTH_VT_ATF_G)
+		{
+			float		bodyCurrent	  = 0.0f;
+			int			bodyEnd		  = 0;
+			if (!!gi.G2API_GetBoneAnimIndex(&pVeh->m_pPilot->ghoul2[pVeh->m_pPilot->playerModel], pVeh->m_pPilot->rootBone, level.time, &bodyCurrent, NULL, &bodyEnd, NULL, NULL, NULL))
+			{
+				if (bodyCurrent<=((float)(bodyEnd)-1.5f))
+				{
+					return;
+				}
+			}
+		}
+#endif
+
+		// Compute The Weapon Pose
+		//--------------------------
+		if (pilotPS->weapon==WP_BLASTER)
+		{
+			WeaponPose = WPOSE_BLASTER;
+		}
+		else if (pilotPS->weapon==WP_SABER)
+		{
+			if ( (pVeh->m_ulFlags&VEH_SABERINLEFTHAND) && pilotPS->torsoAnim==BOTH_VT_ATL_TO_R_S)
+			{
+				pVeh->m_ulFlags	&= ~VEH_SABERINLEFTHAND;
+			}
+			if (!(pVeh->m_ulFlags&VEH_SABERINLEFTHAND) && pilotPS->torsoAnim==BOTH_VT_ATR_TO_L_S)
+			{
+				pVeh->m_ulFlags	|=  VEH_SABERINLEFTHAND;
+			}
+			WeaponPose = (pVeh->m_ulFlags&VEH_SABERINLEFTHAND)?(WPOSE_SABERLEFT):(WPOSE_SABERRIGHT);
+		}
+		
+
+ 		if (Attacking && WeaponPose)
+		{// Attack!
+			iBlend	= 100;
+ 			iFlags	= SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD|SETANIM_FLAG_RESTART;
+
+			if (Turbo)
+			{
+				Right = true;
+				Left = false;
+			}
+
+			// Auto Aiming
+			//===============================================
+			if (!Left && !Right)		// Allow player strafe keys to override
+			{
+#ifndef _JK2MP
+				if (pVeh->m_pPilot->enemy)
+				{
+					vec3_t	toEnemy;
+					float	toEnemyDistance;
+					vec3_t	actorRight;
+					float	actorRightDot;
+
+					VectorSubtract(pVeh->m_pPilot->currentOrigin, pVeh->m_pPilot->enemy->currentOrigin, toEnemy);
+					toEnemyDistance = VectorNormalize(toEnemy);
+
+					AngleVectors(pVeh->m_pParentEntity->currentAngles, 0, actorRight, 0);
+					actorRightDot = DotProduct(toEnemy, actorRight);
+
+	 				if (fabsf(actorRightDot)>0.5f || pilotPS->weapon==WP_SABER)
+					{
+						Left	= (actorRightDot>0.0f);
+						Right	= !Left;
+					}
+					else
+					{
+						Right = Left = false;
+					}
+				}
+				else
+#endif
+				if (pilotPS->weapon==WP_SABER && !Left && !Right)
+				{
+					Left = (WeaponPose==WPOSE_SABERLEFT);
+					Right	= !Left;
+				}
+			}
+
+
+			if (Left)
+			{// Attack Left
+				switch(WeaponPose)
+				{
+				case WPOSE_BLASTER:		Anim = BOTH_VT_ATL_G;		break;
+				case WPOSE_SABERLEFT:	Anim = BOTH_VT_ATL_S;		break;
+				case WPOSE_SABERRIGHT:	Anim = BOTH_VT_ATR_TO_L_S;	break;
+				default:				assert(0);
+				}
+			}
+			else if (Right)
+			{// Attack Right
+				switch(WeaponPose)
+				{
+				case WPOSE_BLASTER:		Anim = BOTH_VT_ATR_G;		break;
+				case WPOSE_SABERLEFT:	Anim = BOTH_VT_ATL_TO_R_S;	break;
+				case WPOSE_SABERRIGHT:	Anim = BOTH_VT_ATR_S;		break;
+				default:				assert(0);
+				}
+			}
+			else
+			{// Attack Ahead
+				switch(WeaponPose)
+				{
+				case WPOSE_BLASTER:		Anim = BOTH_VT_ATF_G;		break;
+				default:				assert(0);
+				}
+			}
+		}
+		else if (Turbo)
+		{// Kicked In Turbo
+			iBlend	= 50;
+			iFlags	= SETANIM_FLAG_OVERRIDE;
+			Anim	= BOTH_VT_TURBO;
+		}
+		else
+		{// No Special Moves
+			iBlend	= 300;
+ 			iFlags	= SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLDLESS;
+
+			if (WeaponPose==WPOSE_NONE)
+			{
+				if (Walking)
+				{
+					Anim = BOTH_VT_WALK_FWD;
+				}
+				else if (Running)
+				{
+					Anim = BOTH_VT_RUN_FWD;
+				}
+				else
+				{
+					Anim = BOTH_VT_IDLE1;//(Q_irand(0,1)==0)?(BOTH_VT_IDLE):(BOTH_VT_IDLE1);
+				}
+			}
+			else
+			{
+				switch(WeaponPose)
+				{
+				case WPOSE_BLASTER:		Anim = BOTH_VT_IDLE_G;			break;
+				case WPOSE_SABERLEFT:	Anim = BOTH_VT_IDLE_SL;			break;
+				case WPOSE_SABERRIGHT:	Anim = BOTH_VT_IDLE_SR;			break;
+				default:				assert(0);
+				}
+			}
+		}// No Special Moves
+	}
+
+	Vehicle_SetAnim( pilot, SETANIM_BOTH, Anim, iFlags, iBlend );
+}
+#endif //QAGAME
+
+#ifndef QAGAME
+void AttachRidersGeneric( Vehicle_t *pVeh );
+#endif
+
+//on the client this function will only set up the process command funcs
+void G_SetAnimalVehicleFunctions( vehicleInfo_t *pVehInfo )
+{
+#ifdef QAGAME
+	pVehInfo->AnimateVehicle			=		AnimateVehicle;
+	pVehInfo->AnimateRiders				=		AnimateRiders;
+//	pVehInfo->ValidateBoard				=		ValidateBoard;
+//	pVehInfo->SetParent					=		SetParent;
+//	pVehInfo->SetPilot					=		SetPilot;
+//	pVehInfo->AddPassenger				=		AddPassenger;
+//	pVehInfo->Animate					=		Animate;
+//	pVehInfo->Board						=		Board;
+//	pVehInfo->Eject						=		Eject;
+//	pVehInfo->EjectAll					=		EjectAll;
+//	pVehInfo->StartDeathDelay			=		StartDeathDelay;
+	pVehInfo->DeathUpdate				=		DeathUpdate;
+//	pVehInfo->RegisterAssets			=		RegisterAssets;
+//	pVehInfo->Initialize				=		Initialize;
+	pVehInfo->Update					=		Update;
+//	pVehInfo->UpdateRider				=		UpdateRider;
+#endif //QAGAME
+	pVehInfo->ProcessMoveCommands		=		ProcessMoveCommands;
+	pVehInfo->ProcessOrientCommands		=		ProcessOrientCommands;
+
+#ifndef QAGAME //cgame prediction attachment func
+	pVehInfo->AttachRiders				=		AttachRidersGeneric;
+#endif
+//	pVehInfo->AttachRiders				=		AttachRiders;
+//	pVehInfo->Ghost						=		Ghost;
+//	pVehInfo->UnGhost					=		UnGhost;
+//	pVehInfo->Inhabited					=		Inhabited;
+}
+
+// Following is only in game, not in namespace
+#ifdef _JK2MP
+#include "../namespace_end.h"
+#endif
+
+#ifdef QAGAME
+extern void G_AllocateVehicleObject(Vehicle_t **pVeh);
+#endif
+
+#ifdef _JK2MP
+#include "../namespace_begin.h"
+#endif
+
+// Create/Allocate a new Animal Vehicle (initializing it as well).
+//this is a BG function too in MP so don't un-bg-compatibilify it -rww
+void G_CreateAnimalNPC( Vehicle_t **pVeh, const char *strAnimalType )
+{
+	// Allocate the Vehicle.
+#ifdef _JK2MP
+#ifdef QAGAME
+	//these will remain on entities on the client once allocated because the pointer is
+	//never stomped. on the server, however, when an ent is freed, the entity struct is
+	//memset to 0, so this memory would be lost..
+    G_AllocateVehicleObject(pVeh);
+#else
+	if (!*pVeh)
+	{ //only allocate a new one if we really have to
+		(*pVeh) = (Vehicle_t *) BG_Alloc( sizeof(Vehicle_t) );
+	}
+#endif
+	memset(*pVeh, 0, sizeof(Vehicle_t));
+	(*pVeh)->m_pVehicleInfo = &g_vehicleInfo[BG_VehicleGetIndex( strAnimalType )];
+#else
+	(*pVeh) = (Vehicle_t *) gi.Malloc( sizeof(Vehicle_t), TAG_G_ALLOC, qtrue );
+	(*pVeh)->m_pVehicleInfo = &g_vehicleInfo[BG_VehicleGetIndex( strAnimalType )];
+#endif
+}
+
+#ifdef _JK2MP
+
+#include "../namespace_end.h"
+
+//get rid of all the crazy defs we added for this file
+#undef currentAngles
+#undef currentOrigin
+#undef mins
+#undef maxs
+#undef legsAnimTimer
+#undef torsoAnimTimer
+#undef bool
+#undef false
+#undef true
+
+#undef sqrtf
+#undef Q_flrand
+
+#undef MOD_EXPLOSIVE
+#endif
diff --git a/code/game/FighterNPC.c b/code/game/FighterNPC.c
new file mode 100644
index 0000000..baf3bc8
--- /dev/null
+++ b/code/game/FighterNPC.c
@@ -0,0 +1,1751 @@
+// leave this line at the top for all g_xxxx.cpp files...
+#include "g_headers.h"
+
+//seems to be a compiler bug, it doesn't clean out the #ifdefs between dif-compiles
+//or something, so the headers spew errors on these defs from the previous compile.
+//this fixes that. -rww
+#ifdef _JK2MP
+//get rid of all the crazy defs we added for this file
+#undef currentAngles
+#undef currentOrigin
+#undef mins
+#undef maxs
+#undef legsAnimTimer
+#undef torsoAnimTimer
+#undef bool
+#undef false
+#undef true
+
+#undef sqrtf
+#undef Q_flrand
+
+#undef MOD_EXPLOSIVE
+#endif
+
+#ifdef _JK2 //SP does not have this preprocessor for game like MP does
+#ifndef _JK2MP
+#define _JK2MP
+#endif
+#endif
+
+#ifndef _JK2MP //if single player
+#ifndef QAGAME //I don't think we have a QAGAME define
+#define QAGAME //but define it cause in sp we're always in the game
+#endif
+#endif
+
+#ifdef QAGAME //including game headers on cgame is FORBIDDEN ^_^
+#include "g_local.h"
+#elif defined _JK2MP
+#include "bg_public.h"
+#endif
+
+#ifndef _JK2MP
+#include "g_functions.h"
+#include "g_vehicles.h"
+#else
+#include "bg_vehicles.h"
+#endif
+
+#ifdef _JK2MP
+//this is really horrible, but it works! just be sure not to use any locals or anything
+//with these names (exluding bool, false, true). -rww
+#define currentAngles r.currentAngles
+#define currentOrigin r.currentOrigin
+#define mins r.mins
+#define maxs r.maxs
+#define legsAnimTimer legsTimer
+#define torsoAnimTimer torsoTimer
+#define bool qboolean
+#define false qfalse
+#define true qtrue
+
+#define sqrtf sqrt
+#define Q_flrand flrand
+
+#define MOD_EXPLOSIVE MOD_SUICIDE
+#else
+#define bgEntity_t gentity_t
+#endif
+
+extern float DotToSpot( vec3_t spot, vec3_t from, vec3_t fromAngles );
+#ifdef QAGAME //SP or gameside MP
+extern vmCvar_t	cg_thirdPersonAlpha;
+extern vec3_t playerMins;
+extern vec3_t playerMaxs;
+extern cvar_t	*g_speederControlScheme;
+extern void ChangeWeapon( gentity_t *ent, int newWeapon );
+extern void PM_SetAnim(pmove_t	*pm,int setAnimParts,int anim,int setAnimFlags, int blendTime);
+extern int PM_AnimLength( int index, animNumber_t anim );
+extern void G_VehicleTrace( trace_t *results, const vec3_t start, const vec3_t tMins, const vec3_t tMaxs, const vec3_t end, int passEntityNum, int contentmask );
+#endif
+
+extern qboolean BG_UnrestrainedPitchRoll( playerState_t *ps, Vehicle_t *pVeh );
+
+#ifdef _JK2MP
+
+#include "../namespace_begin.h"
+
+extern void BG_SetAnim(playerState_t *ps, animation_t *animations, int setAnimParts,int anim,int setAnimFlags, int blendTime);
+extern int BG_GetTime(void);
+#endif
+
+extern void BG_ExternThisSoICanRecompileInDebug( Vehicle_t *pVeh, playerState_t *riderPS );
+
+//this stuff has got to be predicted, so..
+bool BG_FighterUpdate(Vehicle_t *pVeh, const usercmd_t *pUcmd, vec3_t trMins, vec3_t trMaxs, float gravity,
+					  void (*traceFunc)( trace_t *results, const vec3_t start, const vec3_t lmins, const vec3_t lmaxs, const vec3_t end, int passEntityNum, int contentMask ))
+{
+	vec3_t		bottom;
+	playerState_t *parentPS;
+	qboolean	isDead = qfalse;
+#ifdef QAGAME //don't do this on client
+	// Make sure the riders are not visible or collidable.
+	pVeh->m_pVehicleInfo->Ghost( pVeh, pVeh->m_pPilot );
+#endif
+
+
+#ifdef _JK2MP
+	parentPS = pVeh->m_pParentEntity->playerState;
+#else
+	parentPS = &pVeh->m_pParentEntity->client->ps;
+#endif
+
+	if (!parentPS)
+	{
+		Com_Error(ERR_DROP, "NULL PS in BG_FighterUpdate (%s)", pVeh->m_pVehicleInfo->name);
+		return false;
+	}
+
+	// If we have a pilot, take out gravity (it's a flying craft...).
+	if ( pVeh->m_pPilot )
+	{
+		parentPS->gravity = 0;
+#ifndef _JK2MP //don't need this flag in mp, I.. guess
+		pVeh->m_pParentEntity->svFlags |= SVF_CUSTOM_GRAVITY;
+#endif
+	}
+	else
+	{
+#ifndef _JK2MP //don't need this flag in mp, I.. guess
+		pVeh->m_pParentEntity->svFlags &= ~SVF_CUSTOM_GRAVITY;
+#else //in MP set grav back to normal gravity
+		if (pVeh->m_pVehicleInfo->gravity)
+		{
+			parentPS->gravity = pVeh->m_pVehicleInfo->gravity;
+		}
+		else
+		{ //it doesn't have gravity specified apparently
+			parentPS->gravity = gravity;
+		}
+#endif
+	}
+
+#ifdef _JK2MP
+	isDead = (qboolean)((parentPS->eFlags&EF_DEAD)!=0);
+#else
+	isDead = (parentPS->stats[STAT_HEALTH] <= 0 );
+#endif
+
+	/*
+	if ( isDead || 
+		(pVeh->m_pVehicleInfo->surfDestruction &&
+			pVeh->m_iRemovedSurfaces ) )
+	{//can't land if dead or spiralling out of control
+		pVeh->m_LandTrace.fraction = 1.0f;
+		pVeh->m_LandTrace.contents = pVeh->m_LandTrace.surfaceFlags = 0;
+		VectorClear( pVeh->m_LandTrace.plane.normal );
+		pVeh->m_LandTrace.allsolid = qfalse;
+		pVeh->m_LandTrace.startsolid = qfalse;
+	}
+	else
+	{
+	*/
+	//argh, no, I need to have a way to see when they impact the ground while damaged. -rww
+
+		// Check to see if the fighter has taken off yet (if it's a certain height above ground).
+		VectorCopy( parentPS->origin, bottom );
+		bottom[2] -= pVeh->m_pVehicleInfo->landingHeight;
+
+		traceFunc( &pVeh->m_LandTrace, parentPS->origin, trMins, trMaxs, bottom, pVeh->m_pParentEntity->s.number, (MASK_NPCSOLID&~CONTENTS_BODY) );
+	//}
+
+	return true;
+}
+
+#ifdef QAGAME //ONLY in SP or on server, not cgame
+
+// Like a think or move command, this updates various vehicle properties.
+static bool Update( Vehicle_t *pVeh, const usercmd_t *pUcmd )
+{
+	assert(pVeh->m_pParentEntity);
+	if (!BG_FighterUpdate(pVeh, pUcmd, ((gentity_t *)pVeh->m_pParentEntity)->mins,
+		((gentity_t *)pVeh->m_pParentEntity)->maxs, 
+#ifdef _JK2MP
+		g_gravity.value,
+#else
+		g_gravity->value,
+#endif
+		G_VehicleTrace))
+	{
+		return false;
+	}
+
+	if ( !g_vehicleInfo[VEHICLE_BASE].Update( pVeh, pUcmd ) )
+	{
+		return false;
+	}
+
+	return true;
+}
+
+// Board this Vehicle (get on). The first entity to board an empty vehicle becomes the Pilot.
+static bool Board( Vehicle_t *pVeh, bgEntity_t *pEnt )
+{
+	if ( !g_vehicleInfo[VEHICLE_BASE].Board( pVeh, pEnt ) )
+		return false;
+
+	// Set the board wait time (they won't be able to do anything, including getting off, for this amount of time).
+	pVeh->m_iBoarding = level.time + 1500;
+
+	return true;
+}
+
+// Eject an entity from the vehicle.
+static bool Eject( Vehicle_t *pVeh, bgEntity_t *pEnt, qboolean forceEject )
+{
+	if ( g_vehicleInfo[VEHICLE_BASE].Eject( pVeh, pEnt, forceEject ) )
+	{
+		return true;
+	}
+	
+	return false;
+}
+
+#endif //end game-side only
+
+//method of decrementing the given angle based on the given taking variable frame times into account
+static float PredictedAngularDecrement(float scale, float timeMod, float originalAngle)
+{
+	float fixedBaseDec = originalAngle*0.05f;
+	float r = 0.0f;
+
+	if (fixedBaseDec < 0.0f)
+	{
+		fixedBaseDec = -fixedBaseDec;
+	}
+	
+	fixedBaseDec *= (1.0f+(1.0f-scale));
+
+	if (fixedBaseDec < 0.1f)
+	{ //don't increment in incredibly small fractions, it would eat up unnecessary bandwidth.
+		fixedBaseDec = 0.1f;
+	}
+
+	fixedBaseDec *= (timeMod*0.1f);
+	if (originalAngle > 0.0f)
+	{ //subtract
+		r = (originalAngle-fixedBaseDec);
+		if (r < 0.0f)
+		{
+			r = 0.0f;
+		}
+	}
+	else if (originalAngle < 0.0f)
+	{ //add
+		r = (originalAngle+fixedBaseDec);
+		if (r > 0.0f)
+		{
+			r = 0.0f;
+		}
+	}
+
+	return r;
+}
+
+#ifdef QAGAME//only do this check on GAME side, because if it's CGAME, it's being predicted, and it's only predicted if the local client is the driver
+qboolean FighterIsInSpace( gentity_t *gParent )
+{
+	if ( gParent 
+		&& gParent->client 
+		&& gParent->client->inSpaceIndex
+		&& gParent->client->inSpaceIndex < ENTITYNUM_WORLD )
+	{
+		return qtrue;
+	}
+	return qfalse;
+}
+#endif
+
+qboolean FighterOverValidLandingSurface( Vehicle_t *pVeh )
+{
+	if ( pVeh->m_LandTrace.fraction < 1.0f //ground present
+		&& pVeh->m_LandTrace.plane.normal[2] >= MIN_LANDING_SLOPE )//flat enough
+		//FIXME: also check for a certain surface flag ... "landing zones"?
+	{
+		return qtrue;
+	}
+	return qfalse;
+}
+
+qboolean FighterIsLanded( Vehicle_t *pVeh, playerState_t *parentPS )
+{
+	if ( FighterOverValidLandingSurface( pVeh )
+		&& !parentPS->speed )//stopped
+	{
+		return qtrue;
+	}
+	return qfalse;
+}
+
+qboolean FighterIsLanding( Vehicle_t *pVeh, playerState_t *parentPS )
+{
+
+	if ( FighterOverValidLandingSurface( pVeh )
+#ifdef QAGAME//only do this check on GAME side, because if it's CGAME, it's being predicted, and it's only predicted if the local client is the driver
+		&& pVeh->m_pVehicleInfo->Inhabited( pVeh )//has to have a driver in order to be capable of landing
+#endif
+		&& (pVeh->m_ucmd.forwardmove < 0||pVeh->m_ucmd.upmove<0) //decelerating or holding crouch button
+		&& parentPS->speed <= MIN_LANDING_SPEED )//going slow enough to start landing - was using pVeh->m_pVehicleInfo->speedIdle, but that's still too fast
+	{
+		return qtrue;
+	}
+	return qfalse;
+}
+
+qboolean FighterIsLaunching( Vehicle_t *pVeh, playerState_t *parentPS )
+{
+
+	if ( FighterOverValidLandingSurface( pVeh )
+#ifdef QAGAME//only do this check on GAME side, because if it's CGAME, it's being predicted, and it's only predicted if the local client is the driver
+		&& pVeh->m_pVehicleInfo->Inhabited( pVeh )//has to have a driver in order to be capable of landing
+#endif
+		&& pVeh->m_ucmd.upmove > 0 //trying to take off
+		&& parentPS->speed <= 200.0f )//going slow enough to start landing - was using pVeh->m_pVehicleInfo->speedIdle, but that's still too fast
+	{
+		return qtrue;
+	}
+	return qfalse;
+}
+
+qboolean FighterSuspended( Vehicle_t *pVeh, playerState_t *parentPS )
+{
+#ifdef QAGAME//only do this check on GAME side, because if it's CGAME, it's being predicted, and it's only predicted if the local client is the driver
+	if (!pVeh->m_pPilot//empty
+		&& !parentPS->speed//not moving
+		&& pVeh->m_ucmd.forwardmove <= 0//not trying to go forward for whatever reason
+		&& pVeh->m_pParentEntity != NULL
+		&& (((gentity_t *)pVeh->m_pParentEntity)->spawnflags&2) )//SUSPENDED spawnflag is on
+	{
+		return qtrue;
+	}
+	return qfalse;
+#elif CGAME
+	return qfalse;
+#endif
+}
+
+#ifdef CGAME
+extern void trap_S_StartSound( vec3_t origin, int entityNum, int entchannel, sfxHandle_t sfx ); //cg_syscalls.c
+extern sfxHandle_t trap_S_RegisterSound( const char *sample); //cg_syscalls.c
+#endif
+
+//MP RULE - ALL PROCESSMOVECOMMANDS FUNCTIONS MUST BE BG-COMPATIBLE!!!
+//If you really need to violate this rule for SP, then use ifdefs.
+//By BG-compatible, I mean no use of game-specific data - ONLY use
+//stuff available in the MP bgEntity (in SP, the bgEntity is #defined
+//as a gentity, but the MP-compatible access restrictions are based
+//on the bgEntity structure in the MP codebase) -rww
+// ProcessMoveCommands the Vehicle.
+#define FIGHTER_MIN_TAKEOFF_FRACTION 0.7f
+static void ProcessMoveCommands( Vehicle_t *pVeh )
+{
+	/************************************************************************************/
+	/*	BEGIN	Here is where we move the vehicle (forward or back or whatever). BEGIN	*/
+	/************************************************************************************/
+
+	//Client sets ucmds and such for speed alterations
+	float speedInc, speedIdleDec, speedIdle, speedIdleAccel, speedMin, speedMax;
+	bgEntity_t *parent = pVeh->m_pParentEntity;
+	qboolean isLandingOrLaunching = qfalse;
+#ifndef _JK2MP//SP
+	int curTime = level.time;
+#elif QAGAME//MP GAME
+	int curTime = level.time;
+#elif CGAME//MP CGAME
+	//FIXME: pass in ucmd?  Not sure if this is reliable...
+	int curTime = pm->cmd.serverTime;
+#endif
+
+#ifdef _JK2MP
+	playerState_t *parentPS = parent->playerState;
+#else
+	playerState_t *parentPS = &parent->client->ps;
+#endif
+
+#ifdef _JK2MP
+	if ( parentPS->hyperSpaceTime
+		&& curTime - parentPS->hyperSpaceTime < HYPERSPACE_TIME )
+	{//Going to Hyperspace
+		//totally override movement
+		float timeFrac = ((float)(curTime-parentPS->hyperSpaceTime))/HYPERSPACE_TIME;
+		if ( timeFrac < HYPERSPACE_TELEPORT_FRAC )
+		{//for first half, instantly jump to top speed!
+			if ( !(parentPS->eFlags2&EF2_HYPERSPACE) )
+			{//waiting to face the right direction, do nothing
+				parentPS->speed = 0.0f;
+			}
+			else
+			{
+				if ( parentPS->speed < HYPERSPACE_SPEED )
+				{//just started hyperspace
+//MIKE: This is going to play the sound twice for the predicting client, I suggest using
+//a predicted event or only doing it game-side. -rich
+#ifdef QAGAME//MP GAME-side
+					//G_EntitySound( ((gentity_t *)(pVeh->m_pParentEntity)), CHAN_LOCAL, pVeh->m_pVehicleInfo->soundHyper );
+#elif CGAME//MP CGAME-side
+					trap_S_StartSound( NULL, pm->ps->clientNum, CHAN_LOCAL, pVeh->m_pVehicleInfo->soundHyper );
+#endif			
+				}
+
+				parentPS->speed = HYPERSPACE_SPEED;
+			}
+		}
+		else
+		{//slow from top speed to 200...
+			parentPS->speed = 200.0f + ((1.0f-timeFrac)*(1.0f/HYPERSPACE_TELEPORT_FRAC)*(HYPERSPACE_SPEED-200.0f));
+			//don't mess with acceleration, just pop to the high velocity
+			if ( VectorLength( parentPS->velocity ) < parentPS->speed )
+			{
+				VectorScale( parentPS->moveDir, parentPS->speed, parentPS->velocity );
+			}
+		}
+		return;
+	}
+#endif
+
+	if ( pVeh->m_iDropTime >= curTime )
+	{//no speed, just drop
+		parentPS->speed = 0.0f;
+		parentPS->gravity = 800;
+		return;
+	}
+
+	isLandingOrLaunching = (FighterIsLanding( pVeh, parentPS )||FighterIsLaunching( pVeh, parentPS ));
+
+	// If we are hitting the ground, just allow the fighter to go up and down.
+	if ( isLandingOrLaunching//going slow enough to start landing
+		&& (pVeh->m_ucmd.forwardmove<=0||pVeh->m_LandTrace.fraction<=FIGHTER_MIN_TAKEOFF_FRACTION) )//not trying to accelerate away already (or: you are trying to, but not high enough off the ground yet)
+	{//FIXME: if start to move forward and fly over something low while still going relatively slow, you may try to land even though you don't mean to...
+		//float fInvFrac = 1.0f - pVeh->m_LandTrace.fraction; 
+
+		if ( pVeh->m_ucmd.upmove > 0 )
+		{
+#ifdef _JK2MP
+			if ( parentPS->velocity[2] <= 0 
+				&& pVeh->m_pVehicleInfo->soundTakeOff )
+			{//taking off for the first time
+#ifdef QAGAME//MP GAME-side
+				G_EntitySound( ((gentity_t *)(pVeh->m_pParentEntity)), CHAN_AUTO, pVeh->m_pVehicleInfo->soundTakeOff );
+#endif
+			}
+#endif
+			parentPS->velocity[2] += pVeh->m_pVehicleInfo->acceleration * pVeh->m_fTimeModifier;// * ( /*fInvFrac **/ 1.5f );
+		}
+		else if ( pVeh->m_ucmd.upmove < 0 )
+		{
+			parentPS->velocity[2] -= pVeh->m_pVehicleInfo->acceleration * pVeh->m_fTimeModifier;// * ( /*fInvFrac **/ 1.8f );
+		}
+		else if ( pVeh->m_ucmd.forwardmove < 0 )
+		{
+			if ( pVeh->m_LandTrace.fraction != 0.0f ) 
+			{
+				parentPS->velocity[2] -= pVeh->m_pVehicleInfo->acceleration * pVeh->m_fTimeModifier;
+			}
+
+			if ( pVeh->m_LandTrace.fraction <= FIGHTER_MIN_TAKEOFF_FRACTION )
+			{
+				//pVeh->m_pParentEntity->client->ps.velocity[0] *= pVeh->m_LandTrace.fraction;
+				//pVeh->m_pParentEntity->client->ps.velocity[1] *= pVeh->m_LandTrace.fraction;
+
+				//remember to always base this stuff on the time modifier! otherwise, you create
+				//framerate-dependancy issues and break prediction in MP -rww
+				//parentPS->velocity[2] *= pVeh->m_LandTrace.fraction;
+				//it's not an angle, but hey
+				parentPS->velocity[2] = PredictedAngularDecrement(pVeh->m_LandTrace.fraction, pVeh->m_fTimeModifier*5.0f, parentPS->velocity[2]);
+			
+				parentPS->speed = 0;
+			}
+		}
+
+		// Make sure they don't pitch as they near the ground.
+		//pVeh->m_vOrientation[PITCH] *= 0.7f;
+		pVeh->m_vOrientation[PITCH] = PredictedAngularDecrement(0.7f, pVeh->m_fTimeModifier*10.0f, pVeh->m_vOrientation[PITCH]);
+
+		return;
+	}
+
+	if ( (pVeh->m_ucmd.upmove > 0) && pVeh->m_pVehicleInfo->turboSpeed )
+	{
+		if ((curTime - pVeh->m_iTurboTime)>pVeh->m_pVehicleInfo->turboRecharge)
+		{
+			pVeh->m_iTurboTime = (curTime + pVeh->m_pVehicleInfo->turboDuration);
+			if (pVeh->m_pVehicleInfo->iTurboStartFX)
+			{
+				int i;
+				for (i=0; i<MAX_VEHICLE_EXHAUSTS; i++)
+				{
+					if (pVeh->m_iExhaustTag[i]==-1)
+					{
+						break;
+					}
+					#ifndef _JK2MP//SP
+						G_PlayEffect(pVeh->m_pVehicleInfo->iTurboStartFX, pVeh->m_pParentEntity->playerModel, pVeh->m_iExhaustTag[i], pVeh->m_pParentEntity->s.number, pVeh->m_pParentEntity->currentOrigin );
+					#else
+						//TODO: MP Play Effect?
+					#endif
+				}
+			}
+			//NOTE: turbo sound can't be part of effect if effect is played on every muzzle!
+			if ( pVeh->m_pVehicleInfo->soundTurbo )
+			{
+#ifndef _JK2MP//SP
+				G_SoundIndexOnEnt( pVeh->m_pParentEntity, CHAN_AUTO, pVeh->m_pVehicleInfo->soundTurbo );
+#elif QAGAME//MP GAME-side
+				G_EntitySound( ((gentity_t *)(pVeh->m_pParentEntity)), CHAN_AUTO, pVeh->m_pVehicleInfo->soundTurbo );
+#elif CGAME//MP CGAME-side
+				//trap_S_StartSound( NULL, pVeh->m_pParentEntity->s.number, CHAN_AUTO, pVeh->m_pVehicleInfo->soundTurbo );
+#endif		
+			}
+		}
+	}
+	speedInc = pVeh->m_pVehicleInfo->acceleration * pVeh->m_fTimeModifier;
+	if ( curTime < pVeh->m_iTurboTime )
+	{//going turbo speed
+		speedMax = pVeh->m_pVehicleInfo->turboSpeed;
+		//double our acceleration
+		speedInc *= 2.0f;
+		//force us to move forward
+		pVeh->m_ucmd.forwardmove = 127;
+#ifdef _JK2MP//SP can cheat and just check m_iTurboTime directly... :)
+		//add flag to let cgame know to draw the iTurboFX effect
+		parentPS->eFlags |= EF_JETPACK_ACTIVE;
+#endif
+	}
+	/*
+	//FIXME: if turbotime is up and we're waiting for it to recharge, should our max speed drop while we recharge?
+	else if ( (curTime - pVeh->m_iTurboTime)<3000 )
+	{//still waiting for the recharge
+		speedMax = pVeh->m_pVehicleInfo->speedMax*0.75;
+	}
+	*/
+	else
+	{//normal max speed
+		speedMax = pVeh->m_pVehicleInfo->speedMax;
+#ifdef _JK2MP//SP can cheat and just check m_iTurboTime directly... :)
+		if ( (parentPS->eFlags&EF_JETPACK_ACTIVE) )
+		{//stop cgame from playing the turbo exhaust effect
+			parentPS->eFlags &= ~EF_JETPACK_ACTIVE;
+		}
+#endif
+	}
+	speedIdleDec = pVeh->m_pVehicleInfo->decelIdle * pVeh->m_fTimeModifier;
+	speedIdle = pVeh->m_pVehicleInfo->speedIdle;
+	speedIdleAccel = pVeh->m_pVehicleInfo->accelIdle * pVeh->m_fTimeModifier;
+	speedMin = pVeh->m_pVehicleInfo->speedMin;
+
+	if ( (parentPS->brokenLimbs&(1<<SHIPSURF_DAMAGE_BACK_HEAVY)) )
+	{//engine has taken heavy damage
+		speedMax *= 0.8f;//at 80% speed
+	}
+	else if ( (parentPS->brokenLimbs&(1<<SHIPSURF_DAMAGE_BACK_LIGHT)) )
+	{//engine has taken light damage
+		speedMax *= 0.6f;//at 60% speed
+	}
+
+	if (pVeh->m_iRemovedSurfaces
+		|| parentPS->electrifyTime>=curTime)
+	{ //go out of control
+		parentPS->speed += speedInc;
+		//Why set forwardmove?  PMove code doesn't use it... does it?
+		pVeh->m_ucmd.forwardmove = 127;
+	}
+#ifdef QAGAME //well, the thing is always going to be inhabited if it's being predicted!
+	else if ( FighterSuspended( pVeh, parentPS ) )
+	{
+		parentPS->speed = 0;
+		pVeh->m_ucmd.forwardmove = 0;
+	}
+	else if ( !pVeh->m_pVehicleInfo->Inhabited( pVeh ) 
+		&& parentPS->speed > 0 )
+	{//pilot jumped out while we were moving forward (not landing or landed) so just keep the throttle locked
+		//Why set forwardmove?  PMove code doesn't use it... does it?
+		pVeh->m_ucmd.forwardmove = 127;
+	}
+#endif
+	else if ( ( parentPS->speed || parentPS->groundEntityNum == ENTITYNUM_NONE  ||
+		 pVeh->m_ucmd.forwardmove || pVeh->m_ucmd.upmove > 0 ) && pVeh->m_LandTrace.fraction >= 0.05f ) 
+	{
+		if ( pVeh->m_ucmd.forwardmove > 0 && speedInc )
+		{
+			parentPS->speed += speedInc;
+			pVeh->m_ucmd.forwardmove = 127;
+		}
+		else if ( pVeh->m_ucmd.forwardmove < 0 
+			|| pVeh->m_ucmd.upmove < 0 )
+		{//decelerating or braking
+			if ( pVeh->m_ucmd.upmove < 0 )
+			{//braking (trying to land?), slow down faster
+				if ( pVeh->m_ucmd.forwardmove )
+				{//decelerator + brakes
+					speedInc += pVeh->m_pVehicleInfo->braking;
+					speedIdleDec += pVeh->m_pVehicleInfo->braking;
+				}
+				else
+				{//just brakes
+					speedInc = speedIdleDec = pVeh->m_pVehicleInfo->braking;
+				}
+			}
+			if ( parentPS->speed > speedIdle )
+			{
+				parentPS->speed -= speedInc;
+			}
+			else if ( parentPS->speed > speedMin )
+			{
+				if ( FighterOverValidLandingSurface( pVeh ) )
+				{//there's ground below us and we're trying to slow down, slow down faster
+					parentPS->speed -= speedInc;
+				}
+				else
+				{
+					parentPS->speed -= speedIdleDec;
+					if ( parentPS->speed < MIN_LANDING_SPEED )
+					{//unless you can land, don't drop below the landing speed!!!  This way you can't come to a dead stop in mid-air
+						parentPS->speed = MIN_LANDING_SPEED;
+					}
+				}
+			}
+			if ( pVeh->m_pVehicleInfo->type == VH_FIGHTER )
+			{
+				pVeh->m_ucmd.forwardmove = 127;
+			}
+			else if ( speedMin >= 0 )
+			{
+				pVeh->m_ucmd.forwardmove = 0;
+			}
+		}
+		//else not accel, decel or braking
+		else if ( pVeh->m_pVehicleInfo->throttleSticks )
+		{//we're using a throttle that sticks at current speed
+			if ( parentPS->speed <= MIN_LANDING_SPEED )
+			{//going less than landing speed
+				if ( FighterOverValidLandingSurface( pVeh ) )
+				{//close to ground and not going very fast
+					//slow to a stop if within landing height and not accel/decel/braking
+					if ( parentPS->speed > 0 )
+					{//slow down
+						parentPS->speed -= speedIdleDec;
+					}
+					else if ( parentPS->speed < 0 )
+					{//going backwards, slow down
+						parentPS->speed += speedIdleDec;
+					}
+				}
+				else
+				{//not over a valid landing surf, but going too slow
+					//speed up to idle speed if not over a valid landing surf and not accel/decel/braking
+					if ( parentPS->speed < speedIdle )
+					{
+						parentPS->speed += speedIdleAccel;
+						if ( parentPS->speed > speedIdle )
+						{
+							parentPS->speed = speedIdle;
+						}
+					}
+				}
+			}
+		}
+		else
+		{//then speed up or slow down to idle speed
+			//accelerate to cruising speed only, otherwise, just coast
+			// If they've launched, apply some constant motion.
+			if ( (pVeh->m_LandTrace.fraction >= 1.0f //no ground
+					|| pVeh->m_LandTrace.plane.normal[2] < MIN_LANDING_SLOPE )//or can't land on ground below us
+				&& speedIdle > 0 ) 
+			{//not above ground and have an idle speed
+				//float fSpeed = pVeh->m_pParentEntity->client->ps.speed;
+				if ( parentPS->speed < speedIdle )
+				{
+					parentPS->speed += speedIdleAccel;
+					if ( parentPS->speed > speedIdle )
+					{
+						parentPS->speed = speedIdle;
+					}
+				}
+				else if ( parentPS->speed > 0 )
+				{//slow down
+					parentPS->speed -= speedIdleDec;
+
+					if ( parentPS->speed < speedIdle )
+					{
+						parentPS->speed = speedIdle;
+					}
+				}
+			}
+			else//either close to ground or no idle speed
+			{//slow to a stop if no idle speed or within landing height and not accel/decel/braking
+				if ( parentPS->speed > 0 )
+				{//slow down
+					parentPS->speed -= speedIdleDec;
+				}
+				else if ( parentPS->speed < 0 )
+				{//going backwards, slow down
+					parentPS->speed += speedIdleDec;
+				}
+			}
+		}
+	}
+	else
+	{
+		if ( pVeh->m_ucmd.forwardmove < 0 )
+		{
+			pVeh->m_ucmd.forwardmove = 0;
+		}
+		if ( pVeh->m_ucmd.upmove < 0 )
+		{
+			pVeh->m_ucmd.upmove = 0;
+		}
+
+#ifndef _JK2MP
+		if ( !pVeh->m_pVehicleInfo->strafePerc || (!g_speederControlScheme->value && !pVeh->m_pParentEntity->s.number) )
+		{//if in a strafe-capable vehicle, clear strafing unless using alternate control scheme
+			pVeh->m_ucmd.rightmove = 0;
+		}
+#endif
+	}
+
+#if 1//This is working now, but there are some transitional jitters... Rich?
+//STRAFING==============================================================================
+	if ( pVeh->m_pVehicleInfo->strafePerc 
+#ifdef QAGAME//only do this check on GAME side, because if it's CGAME, it's being predicted, and it's only predicted if the local client is the driver
+		&& pVeh->m_pVehicleInfo->Inhabited( pVeh )//has to have a driver in order to be capable of landing
+#endif
+		&& !pVeh->m_iRemovedSurfaces
+		&& parentPS->electrifyTime<curTime
+		&& (pVeh->m_LandTrace.fraction >= 1.0f//no grounf
+			||pVeh->m_LandTrace.plane.normal[2] < MIN_LANDING_SLOPE//can't land here
+			||parentPS->speed>MIN_LANDING_SPEED)//going too fast to land
+		&& pVeh->m_ucmd.rightmove )
+	{//strafe
+		vec3_t vAngles, vRight;
+		float strafeSpeed = (pVeh->m_pVehicleInfo->strafePerc*speedMax)*5.0f;
+		VectorCopy( pVeh->m_vOrientation, vAngles );
+		vAngles[PITCH] = vAngles[ROLL] = 0;
+		AngleVectors( vAngles, NULL, vRight, NULL );
+
+		if ( pVeh->m_ucmd.rightmove > 0 )
+		{//strafe right
+			//FIXME: this will probably make it possible to cheat and
+			//		go faster than max speed if you keep turning and strafing...
+			if ( pVeh->m_fStrafeTime > -MAX_STRAFE_TIME )
+			{//can strafe right for 2 seconds
+				float curStrafeSpeed = DotProduct( parentPS->velocity, vRight );
+				if ( curStrafeSpeed > 0.0f )
+				{//if > 0, already strafing right
+					strafeSpeed -= curStrafeSpeed;//so it doesn't add up
+				}
+				if ( strafeSpeed > 0 )
+				{
+					VectorMA( parentPS->velocity, strafeSpeed*pVeh->m_fTimeModifier, vRight, parentPS->velocity );
+				}
+				pVeh->m_fStrafeTime -= 50*pVeh->m_fTimeModifier;
+			}
+		}
+		else
+		{//strafe left
+			if ( pVeh->m_fStrafeTime < MAX_STRAFE_TIME )
+			{//can strafe left for 2 seconds
+				float curStrafeSpeed = DotProduct( parentPS->velocity, vRight );
+				if ( curStrafeSpeed < 0.0f )
+				{//if < 0, already strafing left
+					strafeSpeed += curStrafeSpeed;//so it doesn't add up
+				}
+				if ( strafeSpeed > 0 )
+				{
+					VectorMA( parentPS->velocity, -strafeSpeed*pVeh->m_fTimeModifier, vRight, parentPS->velocity );
+				}
+				pVeh->m_fStrafeTime += 50*pVeh->m_fTimeModifier;
+			}
+		}
+		//strafing takes away from forward speed?  If so, strafePerc above should use speedMax
+		//parentPS->speed *= (1.0f-pVeh->m_pVehicleInfo->strafePerc);
+	}
+	else//if ( pVeh->m_fStrafeTime )
+	{
+		if ( pVeh->m_fStrafeTime > 0 )
+		{
+			pVeh->m_fStrafeTime -= 50*pVeh->m_fTimeModifier;
+			if ( pVeh->m_fStrafeTime < 0 )
+			{
+				pVeh->m_fStrafeTime = 0.0f;
+			}
+		}
+		else if ( pVeh->m_fStrafeTime < 0 )
+		{
+			pVeh->m_fStrafeTime += 50*pVeh->m_fTimeModifier;
+			if ( pVeh->m_fStrafeTime > 0 )
+			{
+				pVeh->m_fStrafeTime = 0.0f;
+			}
+		}
+	}
+//STRAFING==============================================================================
+#endif
+
+	if ( parentPS->speed > speedMax )
+	{
+		parentPS->speed = speedMax;
+	}
+	else if ( parentPS->speed < speedMin )
+	{
+		parentPS->speed = speedMin;
+	}
+
+#ifdef QAGAME//FIXME: get working in GAME and CGAME
+	if ((pVeh->m_vOrientation[PITCH]*0.1f) > 10.0f)
+	{ //pitched downward, increase speed more and more based on our tilt
+		if ( FighterIsInSpace( (gentity_t *)parent ) )
+		{//in space, do nothing with speed base on pitch...
+		}
+		else
+		{
+			//really should only do this when on a planet
+			float mult = pVeh->m_vOrientation[PITCH]*0.1f;
+			if (mult < 1.0f)
+			{
+				mult = 1.0f;
+			}
+			parentPS->speed = PredictedAngularDecrement(mult, pVeh->m_fTimeModifier*10.0f, parentPS->speed);
+		}
+	}
+
+	if (pVeh->m_iRemovedSurfaces
+		|| parentPS->electrifyTime>=curTime)
+	{ //going down
+		if ( FighterIsInSpace( (gentity_t *)parent ) )
+		{//we're in a valid trigger_space brush
+			//simulate randomness
+			if ( !(parent->s.number&3) )
+			{//even multiple of 3, don't do anything
+				parentPS->gravity = 0;
+			}
+			else if ( !(parent->s.number&2) )
+			{//even multiple of 2, go up
+				parentPS->gravity = -500.0f;
+				parentPS->velocity[2] = 80.0f;
+			}
+			else
+			{//odd number, go down
+				parentPS->gravity = 500.0f;
+				parentPS->velocity[2] = -80.0f;
+			}
+		}
+		else
+		{//over a planet
+			parentPS->gravity = 500.0f;
+			parentPS->velocity[2] = -80.0f;
+		}
+	}
+	else if ( FighterSuspended( pVeh, parentPS ) )
+	{
+		parentPS->gravity = 0;
+	}
+	else if ( (!parentPS->speed||parentPS->speed < speedIdle) && pVeh->m_ucmd.upmove <= 0 )
+	{//slowing down or stopped and not trying to take off
+		if ( FighterIsInSpace( (gentity_t *)parent ) )
+		{//we're in space, stopping doesn't make us drift downward
+			if ( FighterOverValidLandingSurface( pVeh ) )
+			{//well, there's something below us to land on, so go ahead and lower us down to it
+				parentPS->gravity = (speedIdle - parentPS->speed)/4;
+			}
+		}
+		else
+		{//over a planet
+			parentPS->gravity = (speedIdle - parentPS->speed)/4;
+		}
+	}
+	else
+	{
+		parentPS->gravity = 0;
+	}
+#else//FIXME: get above checks working in GAME and CGAME
+	parentPS->gravity = 0;
+#endif
+
+	/********************************************************************************/
+	/*	END Here is where we move the vehicle (forward or back or whatever). END	*/
+	/********************************************************************************/
+}
+
+extern void BG_VehicleTurnRateForSpeed( Vehicle_t *pVeh, float speed, float *mPitchOverride, float *mYawOverride );
+static void FighterWingMalfunctionCheck( Vehicle_t *pVeh, playerState_t *parentPS )
+{
+	float mPitchOverride = 1.0f;
+	float mYawOverride = 1.0f;
+	BG_VehicleTurnRateForSpeed( pVeh, parentPS->speed, &mPitchOverride, &mYawOverride );
+	//check right wing damage
+	if ( (parentPS->brokenLimbs&(1<<SHIPSURF_DAMAGE_RIGHT_HEAVY)) )
+	{//right wing has taken heavy damage
+		pVeh->m_vOrientation[ROLL] += (sin( pVeh->m_ucmd.serverTime*0.001 )+1.0f)*pVeh->m_fTimeModifier*mYawOverride*50.0f;
+	}
+	else if ( (parentPS->brokenLimbs&(1<<SHIPSURF_DAMAGE_RIGHT_LIGHT)) )
+	{//right wing has taken light damage
+		pVeh->m_vOrientation[ROLL] += (sin( pVeh->m_ucmd.serverTime*0.001 )+1.0f)*pVeh->m_fTimeModifier*mYawOverride*12.5f;
+	}
+
+	//check left wing damage
+	if ( (parentPS->brokenLimbs&(1<<SHIPSURF_DAMAGE_LEFT_HEAVY)) )
+	{//left wing has taken heavy damage
+		pVeh->m_vOrientation[ROLL] -= (sin( pVeh->m_ucmd.serverTime*0.001 )+1.0f)*pVeh->m_fTimeModifier*mYawOverride*50.0f;
+	}
+	else if ( (parentPS->brokenLimbs&(1<<SHIPSURF_DAMAGE_LEFT_LIGHT)) )
+	{//left wing has taken light damage
+		pVeh->m_vOrientation[ROLL] -= (sin( pVeh->m_ucmd.serverTime*0.001 )+1.0f)*pVeh->m_fTimeModifier*mYawOverride*12.5f;
+	}
+
+}
+
+static void FighterNoseMalfunctionCheck( Vehicle_t *pVeh, playerState_t *parentPS )
+{
+	float mPitchOverride = 1.0f;
+	float mYawOverride = 1.0f;
+	BG_VehicleTurnRateForSpeed( pVeh, parentPS->speed, &mPitchOverride, &mYawOverride );
+	//check nose damage
+	if ( (parentPS->brokenLimbs&(1<<SHIPSURF_DAMAGE_FRONT_HEAVY)) )
+	{//nose has taken heavy damage
+		//pitch up and down over time
+		pVeh->m_vOrientation[PITCH] += sin( pVeh->m_ucmd.serverTime*0.001 )*pVeh->m_fTimeModifier*mPitchOverride*50.0f;
+	}
+	else if ( (parentPS->brokenLimbs&(1<<SHIPSURF_DAMAGE_FRONT_LIGHT)) )
+	{//nose has taken heavy damage
+		//pitch up and down over time
+		pVeh->m_vOrientation[PITCH] += sin( pVeh->m_ucmd.serverTime*0.001 )*pVeh->m_fTimeModifier*mPitchOverride*20.0f;
+	}
+}
+
+static void FighterDamageRoutine( Vehicle_t *pVeh, bgEntity_t *parent, playerState_t *parentPS, playerState_t *riderPS, qboolean isDead )
+{
+ 	if ( !pVeh->m_iRemovedSurfaces )
+	{//still in one piece
+		if ( pVeh->m_pParentEntity && isDead )
+		{//death spiral
+			pVeh->m_ucmd.upmove = 0;
+			//FIXME: don't bias toward pitching down when not in space
+			/*
+			if ( FighterIsInSpace( pVeh->m_pParentEntity ) )
+			{
+			}
+			else
+			*/
+			if ( !(pVeh->m_pParentEntity->s.number%3) )
+			{//NOT everyone should do this
+				pVeh->m_vOrientation[PITCH] += pVeh->m_fTimeModifier; 
+				if ( !BG_UnrestrainedPitchRoll( riderPS, pVeh ) )
+				{
+					if ( pVeh->m_vOrientation[PITCH] > 60.0f )  
+					{
+						pVeh->m_vOrientation[PITCH] = 60.0f;
+					}
+				}
+			}
+			else if ( !(pVeh->m_pParentEntity->s.number%2) )
+			{
+				pVeh->m_vOrientation[PITCH] -= pVeh->m_fTimeModifier; 
+				if ( !BG_UnrestrainedPitchRoll( riderPS, pVeh ) )
+				{
+					if ( pVeh->m_vOrientation[PITCH] > -60.0f )  
+					{
+						pVeh->m_vOrientation[PITCH] = -60.0f;
+					}
+				}
+			}
+			if ( (pVeh->m_pParentEntity->s.number%2) )
+			{
+				pVeh->m_vOrientation[YAW] += pVeh->m_fTimeModifier;
+				pVeh->m_vOrientation[ROLL] += pVeh->m_fTimeModifier*4.0f;
+			}
+			else
+			{
+				pVeh->m_vOrientation[YAW] -= pVeh->m_fTimeModifier;
+				pVeh->m_vOrientation[ROLL] -= pVeh->m_fTimeModifier*4.0f;
+			}
+		}
+		return;
+	}
+
+	//if we get into here we have at least one broken piece
+	pVeh->m_ucmd.upmove = 0;
+	
+	//if you're off the ground and not suspended, pitch down
+	//FIXME: not in space!
+	if ( pVeh->m_LandTrace.fraction >= 0.1f )
+	{
+		if ( !FighterSuspended( pVeh, parentPS ) )
+		{
+			//pVeh->m_ucmd.forwardmove = 0;
+			//FIXME: don't bias towards pitching down when in space...
+			if ( !(pVeh->m_pParentEntity->s.number%2) )
+			{//NOT everyone should do this
+				pVeh->m_vOrientation[PITCH] += pVeh->m_fTimeModifier; 
+				if ( !BG_UnrestrainedPitchRoll( riderPS, pVeh ) )
+				{
+					if ( pVeh->m_vOrientation[PITCH] > 60.0f )  
+					{
+						pVeh->m_vOrientation[PITCH] = 60.0f;
+					}
+				}
+			}
+			else if ( !(pVeh->m_pParentEntity->s.number%3) )
+			{
+				pVeh->m_vOrientation[PITCH] -= pVeh->m_fTimeModifier; 
+				if ( !BG_UnrestrainedPitchRoll( riderPS, pVeh ) )
+				{
+					if ( pVeh->m_vOrientation[PITCH] > -60.0f )  
+					{
+						pVeh->m_vOrientation[PITCH] = -60.0f;
+					}
+				}
+			}
+			//else: just keep going forward
+		}
+	}
+#ifdef QAGAME
+	if ( pVeh->m_LandTrace.fraction < 1.0f )
+	{ //if you land at all when pieces of your ship are missing, then die
+		gentity_t *parent = (gentity_t *)pVeh->m_pParentEntity;
+		gentity_t *killer = parent;
+#ifdef _JK2MP//only have this info in MP...
+		if (parent->client->ps.otherKiller < ENTITYNUM_WORLD &&
+			parent->client->ps.otherKillerTime > level.time)
+		{
+			gentity_t *potentialKiller = &g_entities[parent->client->ps.otherKiller];
+
+			if (potentialKiller->inuse && potentialKiller->client)
+			{ //he's valid I guess
+				killer = potentialKiller;
+			}
+		}
+#endif
+		G_Damage(parent, killer, killer, vec3_origin, parent->client->ps.origin, 99999, DAMAGE_NO_ARMOR, MOD_SUICIDE);
+	}
+#endif
+
+	if ( ((pVeh->m_iRemovedSurfaces & SHIPSURF_BROKEN_C) ||
+		(pVeh->m_iRemovedSurfaces & SHIPSURF_BROKEN_D)) &&
+		((pVeh->m_iRemovedSurfaces & SHIPSURF_BROKEN_E) ||
+		(pVeh->m_iRemovedSurfaces & SHIPSURF_BROKEN_F)) )
+	{ //wings on both side broken
+		float factor = 2.0f;
+		if ((pVeh->m_iRemovedSurfaces & SHIPSURF_BROKEN_E) &&
+			(pVeh->m_iRemovedSurfaces & SHIPSURF_BROKEN_F) &&
+			(pVeh->m_iRemovedSurfaces & SHIPSURF_BROKEN_C) &&
+			(pVeh->m_iRemovedSurfaces & SHIPSURF_BROKEN_D))
+		{ //all wings broken
+			factor *= 2.0f;
+		}
+
+		if ( !(pVeh->m_pParentEntity->s.number%4)||!(pVeh->m_pParentEntity->s.number%5) )
+		{//won't yaw, so increase roll factor
+			factor *= 4.0f;
+		}
+
+		pVeh->m_vOrientation[ROLL] += (pVeh->m_fTimeModifier*factor); //do some spiralling
+	}
+	else if ((pVeh->m_iRemovedSurfaces & SHIPSURF_BROKEN_C) ||
+		(pVeh->m_iRemovedSurfaces & SHIPSURF_BROKEN_D))
+	{ //left wing broken
+		float factor = 2.0f;
+		if ((pVeh->m_iRemovedSurfaces & SHIPSURF_BROKEN_C) &&
+			(pVeh->m_iRemovedSurfaces & SHIPSURF_BROKEN_D))
+		{ //if both are broken..
+			factor *= 2.0f;
+		}
+
+		if ( !(pVeh->m_pParentEntity->s.number%4)||!(pVeh->m_pParentEntity->s.number%5) )
+		{//won't yaw, so increase roll factor
+			factor *= 4.0f;
+		}
+
+		pVeh->m_vOrientation[ROLL] += factor*pVeh->m_fTimeModifier;
+	}
+	else if ((pVeh->m_iRemovedSurfaces & SHIPSURF_BROKEN_E) ||
+		(pVeh->m_iRemovedSurfaces & SHIPSURF_BROKEN_F))
+	{ //right wing broken
+		float factor = 2.0f;
+		if ((pVeh->m_iRemovedSurfaces & SHIPSURF_BROKEN_E) &&
+			(pVeh->m_iRemovedSurfaces & SHIPSURF_BROKEN_F))
+		{ //if both are broken..
+			factor *= 2.0f;
+		}
+
+		if ( !(pVeh->m_pParentEntity->s.number%4)||!(pVeh->m_pParentEntity->s.number%5) )
+		{//won't yaw, so increase roll factor
+			factor *= 4.0f;
+		}
+
+		pVeh->m_vOrientation[ROLL] -= factor*pVeh->m_fTimeModifier;
+	}
+}
+
+#ifdef _JK2MP
+void FighterYawAdjust(Vehicle_t *pVeh, playerState_t *riderPS, playerState_t *parentPS)
+{
+	float angDif = AngleSubtract(pVeh->m_vOrientation[YAW], riderPS->viewangles[YAW]);
+
+	if (parentPS && parentPS->speed)
+	{
+		float s = parentPS->speed;
+		float maxDif = pVeh->m_pVehicleInfo->turningSpeed*0.8f; //magic number hackery
+
+		if (s < 0.0f)
+		{
+			s = -s;
+		}
+		angDif *= s/pVeh->m_pVehicleInfo->speedMax;
+		if (angDif > maxDif)
+		{
+			angDif = maxDif;
+		}
+		else if (angDif < -maxDif)
+		{
+			angDif = -maxDif;
+		}
+		pVeh->m_vOrientation[YAW] = AngleNormalize180(pVeh->m_vOrientation[YAW] - angDif*(pVeh->m_fTimeModifier*0.2f));
+	}
+}
+
+void FighterPitchAdjust(Vehicle_t *pVeh, playerState_t *riderPS, playerState_t *parentPS)
+{
+	float angDif = AngleSubtract(pVeh->m_vOrientation[PITCH], riderPS->viewangles[PITCH]);
+
+	if (parentPS && parentPS->speed)
+	{
+		float s = parentPS->speed;
+		float maxDif = pVeh->m_pVehicleInfo->turningSpeed*0.8f; //magic number hackery
+
+		if (s < 0.0f)
+		{
+			s = -s;
+		}
+		angDif *= s/pVeh->m_pVehicleInfo->speedMax;
+		if (angDif > maxDif)
+		{
+			angDif = maxDif;
+		}
+		else if (angDif < -maxDif)
+		{
+			angDif = -maxDif;
+		}
+		pVeh->m_vOrientation[PITCH] = AngleNormalize360(pVeh->m_vOrientation[PITCH] - angDif*(pVeh->m_fTimeModifier*0.2f));
+	}
+}
+#endif
+
+//MP RULE - ALL PROCESSORIENTCOMMANDS FUNCTIONS MUST BE BG-COMPATIBLE!!!
+//If you really need to violate this rule for SP, then use ifdefs.
+//By BG-compatible, I mean no use of game-specific data - ONLY use
+//stuff available in the MP bgEntity (in SP, the bgEntity is #defined
+//as a gentity, but the MP-compatible access restrictions are based
+//on the bgEntity structure in the MP codebase) -rww
+// ProcessOrientCommands the Vehicle.
+static void ProcessOrientCommands( Vehicle_t *pVeh )
+{
+	/********************************************************************************/
+	/*	BEGIN	Here is where make sure the vehicle is properly oriented.	BEGIN	*/
+	/********************************************************************************/
+
+	bgEntity_t *parent = pVeh->m_pParentEntity;
+	playerState_t *parentPS, *riderPS;
+	float angleTimeMod;
+#ifdef QAGAME
+	const float groundFraction = 0.1f;
+#endif
+	float	curRoll = 0.0f;
+	qboolean isDead = qfalse;
+	qboolean isLandingOrLanded = qfalse;
+#ifndef _JK2MP//SP
+	int curTime = level.time;
+#elif QAGAME//MP GAME
+	int curTime = level.time;
+#elif CGAME//MP CGAME
+	//FIXME: pass in ucmd?  Not sure if this is reliable...
+	int curTime = pm->cmd.serverTime;
+#endif
+
+#ifdef _JK2MP
+	bgEntity_t *rider = NULL;
+	if (parent->s.owner != ENTITYNUM_NONE)
+	{
+		rider = PM_BGEntForNum(parent->s.owner); //&g_entities[parent->r.ownerNum];
+	}
+#else
+	gentity_t *rider = parent->owner;
+#endif
+
+#ifdef _JK2MP
+	if ( !rider )
+#else
+	if ( !rider || !rider->client )
+#endif
+	{
+		rider = parent;
+	}
+
+#ifdef _JK2MP
+	parentPS = parent->playerState;
+	riderPS = rider->playerState;
+	isDead = (qboolean)((parentPS->eFlags&EF_DEAD)!=0);
+#else
+	parentPS = &parent->client->ps;
+	riderPS = &rider->client->ps;
+	isDead = (parentPS->stats[STAT_HEALTH] <= 0 );
+#endif
+
+#ifdef _JK2MP
+	if ( parentPS->hyperSpaceTime
+		&& (curTime - parentPS->hyperSpaceTime) < HYPERSPACE_TIME )
+	{//Going to Hyperspace
+		VectorCopy( riderPS->viewangles, pVeh->m_vOrientation );
+		VectorCopy( riderPS->viewangles, parentPS->viewangles );
+		return;
+	}
+#endif
+	
+	if ( pVeh->m_iDropTime >= curTime )
+	{//you can only YAW during this
+		parentPS->viewangles[YAW] = pVeh->m_vOrientation[YAW] = riderPS->viewangles[YAW];
+		return;
+	}
+
+	angleTimeMod = pVeh->m_fTimeModifier;
+
+	if ( isDead || parentPS->electrifyTime>=curTime ||
+		(pVeh->m_pVehicleInfo->surfDestruction &&
+		pVeh->m_iRemovedSurfaces &&
+		(pVeh->m_iRemovedSurfaces & SHIPSURF_BROKEN_C) &&
+		(pVeh->m_iRemovedSurfaces & SHIPSURF_BROKEN_D) &&
+		(pVeh->m_iRemovedSurfaces & SHIPSURF_BROKEN_E) &&
+		(pVeh->m_iRemovedSurfaces & SHIPSURF_BROKEN_F)) )
+	{ //do some special stuff for when all the wings are torn off
+		FighterDamageRoutine(pVeh, parent, parentPS, riderPS, isDead);
+		pVeh->m_vOrientation[ROLL] = AngleNormalize180( pVeh->m_vOrientation[ROLL] );
+		return;
+	}
+
+	if ( !BG_UnrestrainedPitchRoll( riderPS, pVeh ) )
+	{
+		pVeh->m_vOrientation[ROLL] = PredictedAngularDecrement(0.95f, angleTimeMod*2.0f, pVeh->m_vOrientation[ROLL]);
+	}
+
+	isLandingOrLanded = (FighterIsLanding( pVeh, parentPS )||FighterIsLanded( pVeh, parentPS ));
+
+	if (!isLandingOrLanded)
+	{ //don't do this stuff while landed.. I guess. I don't want ships spinning in place, looks silly.
+		int m = 0;
+		float aVelDif;
+		float dForVel;
+
+		FighterWingMalfunctionCheck( pVeh, parentPS );
+
+		while (m < 3)
+		{
+			aVelDif = pVeh->m_vFullAngleVelocity[m];
+
+			if (aVelDif != 0.0f)
+			{
+				dForVel = (aVelDif*0.1f)*pVeh->m_fTimeModifier;
+				if (dForVel > 1.0f || dForVel < -1.0f)
+				{
+					pVeh->m_vOrientation[m] += dForVel;
+					pVeh->m_vOrientation[m] = AngleNormalize180(pVeh->m_vOrientation[m]);
+					if (m == PITCH)
+					{ //don't pitch downward into ground even more.
+						if (pVeh->m_vOrientation[m] > 90.0f && (pVeh->m_vOrientation[m]-dForVel) < 90.0f)
+						{
+							pVeh->m_vOrientation[m] = 90.0f;
+							pVeh->m_vFullAngleVelocity[m] = -pVeh->m_vFullAngleVelocity[m];
+						}
+					}
+					if (riderPS)
+					{
+						riderPS->viewangles[m] = pVeh->m_vOrientation[m];
+					}
+					pVeh->m_vFullAngleVelocity[m] -= dForVel;
+				}
+				else
+				{
+					pVeh->m_vFullAngleVelocity[m] = 0.0f;
+				}
+			}
+
+			m++;
+		}
+	}
+	else
+	{ //clear decr/incr angles once landed.
+		VectorClear(pVeh->m_vFullAngleVelocity);
+	}
+
+	curRoll = pVeh->m_vOrientation[ROLL];
+
+	// If we're landed, we shouldn't be able to do anything but take off.
+	if ( isLandingOrLanded //going slow enough to start landing
+		&& !pVeh->m_iRemovedSurfaces 
+		&& parentPS->electrifyTime<curTime)//not spiraling out of control
+	{
+		if ( parentPS->speed > 0.0f )
+		{//Uh... what?  Why?
+			if ( pVeh->m_LandTrace.fraction < 0.3f )
+			{
+				pVeh->m_vOrientation[PITCH] = 0.0f;
+			}
+			else
+			{
+				pVeh->m_vOrientation[PITCH] = PredictedAngularDecrement(0.83f, angleTimeMod*10.0f, pVeh->m_vOrientation[PITCH]);
+			}
+		}
+		if ( pVeh->m_LandTrace.fraction > 0.1f 
+			|| pVeh->m_LandTrace.plane.normal[2] < MIN_LANDING_SLOPE )
+		{//off the ground, at least (or not on a valid landing surf)
+			// Dampen the turn rate based on the current height.
+#ifdef _JK2MP
+			FighterYawAdjust(pVeh, riderPS, parentPS);
+#else
+			pVeh->m_vOrientation[YAW] = riderPS->viewangles[YAW];//*pVeh->m_LandTrace.fraction;
+#endif
+		}
+	}
+	else if ( (pVeh->m_iRemovedSurfaces||parentPS->electrifyTime>=curTime)//spiralling out of control
+		&& (!(pVeh->m_pParentEntity->s.number%4)||!(pVeh->m_pParentEntity->s.number%5)) )
+	{//no yaw control
+	}
+	else if ( pVeh->m_pPilot && pVeh->m_pPilot->s.number < MAX_CLIENTS && parentPS->speed > 0.0f )//&& !( pVeh->m_ucmd.forwardmove > 0 && pVeh->m_LandTrace.fraction != 1.0f ) )   
+	{
+		if ( BG_UnrestrainedPitchRoll( riderPS, pVeh ) )
+		{
+			VectorCopy( riderPS->viewangles, pVeh->m_vOrientation );
+			VectorCopy( riderPS->viewangles, parentPS->viewangles );
+#ifdef _JK2MP
+			//BG_ExternThisSoICanRecompileInDebug( pVeh, riderPS );
+#endif
+
+			curRoll = pVeh->m_vOrientation[ROLL];
+
+			FighterNoseMalfunctionCheck( pVeh, parentPS );
+
+			//VectorCopy( pVeh->m_vOrientation, parentPS->viewangles );
+		}
+		else
+		{
+			/*
+			float fTurnAmt[3];
+			//PITCH
+			fTurnAmt[PITCH] = riderPS->viewangles[PITCH] * 0.08f;
+			//YAW
+			fTurnAmt[YAW] = riderPS->viewangles[YAW] * 0.065f;
+			fTurnAmt[YAW] *= fTurnAmt[YAW];
+			// Dampen the turn rate based on the current height.
+			if ( riderPS->viewangles[YAW] < 0 )
+			{//must keep it negative because squaring a negative makes it positive
+				fTurnAmt[YAW] = -fTurnAmt[YAW];
+			}
+			fTurnAmt[YAW] *= pVeh->m_LandTrace.fraction;
+			//ROLL
+			fTurnAmt[2] = 0.0f;
+			*/
+
+			//Actal YAW
+#ifdef _JK2MP
+			FighterYawAdjust(pVeh, riderPS, parentPS);
+#else
+			pVeh->m_vOrientation[YAW] = riderPS->viewangles[YAW];
+#endif
+
+			// If we are not hitting the ground, allow the fighter to pitch up and down.
+			if ( !FighterOverValidLandingSurface( pVeh ) 
+				|| parentPS->speed > MIN_LANDING_SPEED )
+			//if ( ( pVeh->m_LandTrace.fraction >= 1.0f || pVeh->m_ucmd.forwardmove != 0 ) && pVeh->m_LandTrace.fraction >= 0.0f )
+			{
+				float fYawDelta;
+
+#ifdef _JK2MP
+				FighterPitchAdjust(pVeh, riderPS, parentPS);
+#else
+				pVeh->m_vOrientation[PITCH] = riderPS->viewangles[PITCH]; 
+#endif
+
+				FighterNoseMalfunctionCheck( pVeh, parentPS );
+
+				// Adjust the roll based on the turn amount and dampen it a little.
+				fYawDelta = AngleSubtract(pVeh->m_vOrientation[YAW], pVeh->m_vPrevOrientation[YAW]); //pVeh->m_vOrientation[YAW] - pVeh->m_vPrevOrientation[YAW];
+				if ( fYawDelta > 8.0f ) 
+				{
+					fYawDelta = 8.0f;
+				}
+				else if ( fYawDelta < -8.0f )
+				{
+					fYawDelta = -8.0f;
+				}
+				curRoll -= fYawDelta;
+
+				curRoll = PredictedAngularDecrement(0.93f, angleTimeMod*2.0f, curRoll);
+				//cap it reasonably
+				//NOTE: was hardcoded to 40.0f, now using extern data
+				if ( pVeh->m_pVehicleInfo->rollLimit != -1 )
+				{
+					if (curRoll > pVeh->m_pVehicleInfo->rollLimit )
+					{
+						curRoll = pVeh->m_pVehicleInfo->rollLimit;
+					}
+					else if (curRoll < -pVeh->m_pVehicleInfo->rollLimit)
+					{
+						curRoll = -pVeh->m_pVehicleInfo->rollLimit;
+					}
+				}
+			}
+		}
+	}
+
+	// If you are directly impacting the ground, even out your pitch.
+	if ( isLandingOrLanded )    
+	{//only if capable of landing
+		if ( !isDead 
+			&& parentPS->electrifyTime<curTime
+			&& (!pVeh->m_pVehicleInfo->surfDestruction || !pVeh->m_iRemovedSurfaces ) )
+		{//not crashing or spiralling out of control...
+			if ( pVeh->m_vOrientation[PITCH] > 0 )
+			{
+				pVeh->m_vOrientation[PITCH] = PredictedAngularDecrement(0.2f, angleTimeMod*10.0f, pVeh->m_vOrientation[PITCH]);
+			}
+			else
+			{
+				pVeh->m_vOrientation[PITCH] = PredictedAngularDecrement(0.75f, angleTimeMod*10.0f, pVeh->m_vOrientation[PITCH]);
+			}
+		}
+	}
+
+
+/*
+//NOTE: all this is redundant now since we have the FighterDamageRoutine func...
+#ifdef _JK2MP //...yeah. Need to send armor across net for prediction to work.
+	if ( isDead )
+#else
+	if ( pVeh->m_iArmor <= 0 )
+#endif
+	{//going to explode
+		//FIXME: maybe make it erratically jerk or spin or start and stop?
+#ifndef _JK2MP
+		if ( g_speederControlScheme->value > 0 || !rider || rider->s.number )
+#else
+		if (1)
+#endif
+		{
+			pVeh->m_ucmd.rightmove = Q_irand( -64, 64 );
+		}
+		else
+		{
+			pVeh->m_ucmd.rightmove = 0;
+		}
+		pVeh->m_ucmd.forwardmove = Q_irand( -32, 127 );
+		pVeh->m_ucmd.upmove = Q_irand( -127, 127 );
+		pVeh->m_vOrientation[YAW] += Q_flrand( -10, 10 );
+		pVeh->m_vOrientation[PITCH] += pVeh->m_fTimeModifier; 
+		if ( pVeh->m_vOrientation[PITCH] > 60.0f )  
+		{
+			pVeh->m_vOrientation[PITCH] = 60.0f;
+		}
+		if ( pVeh->m_LandTrace.fraction != 0.0f )
+		{
+			parentPS->velocity[2] -= pVeh->m_pVehicleInfo->acceleration * pVeh->m_fTimeModifier;
+		}
+	}
+*/
+	// If no one is in this vehicle and it's up in the sky, pitch it forward as it comes tumbling down.
+#ifdef QAGAME //never gonna happen on client anyway, we can't be getting predicted unless the predicting client is boarded
+ 	if ( !pVeh->m_pVehicleInfo->Inhabited( pVeh ) 
+		&& pVeh->m_LandTrace.fraction >= groundFraction 
+		&& !FighterIsInSpace( (gentity_t *)parent ) 
+		&& !FighterSuspended( pVeh, parentPS ) )
+	{
+		pVeh->m_ucmd.upmove = 0;
+		//pVeh->m_ucmd.forwardmove = 0;
+		pVeh->m_vOrientation[PITCH] += pVeh->m_fTimeModifier; 
+		if ( !BG_UnrestrainedPitchRoll( riderPS, pVeh ) )
+		{
+			if ( pVeh->m_vOrientation[PITCH] > 60.0f )  
+			{
+				pVeh->m_vOrientation[PITCH] = 60.0f;
+			}
+		}
+	}
+#endif
+
+	if ( !pVeh->m_fStrafeTime )
+	{//use that roll
+		pVeh->m_vOrientation[ROLL] = curRoll;
+		//NOTE: this seems really backwards...
+		if ( pVeh->m_vOrientation[ROLL] )
+		{ //continually adjust the yaw based on the roll..
+			if ( (pVeh->m_iRemovedSurfaces||parentPS->electrifyTime>=curTime)//spiralling out of control
+				&& (!(pVeh->m_pParentEntity->s.number%4)||!(pVeh->m_pParentEntity->s.number%5)) )
+			{//leave YAW alone
+			}
+			else
+			{
+				if ( !BG_UnrestrainedPitchRoll( riderPS, pVeh ) )
+				{
+					pVeh->m_vOrientation[YAW] -= ((pVeh->m_vOrientation[ROLL])*0.05f)*pVeh->m_fTimeModifier;
+				}
+			}
+		}
+	}
+	else
+	{//add in strafing roll
+		float strafeRoll = (pVeh->m_fStrafeTime/MAX_STRAFE_TIME)*pVeh->m_pVehicleInfo->rollLimit;//pVeh->m_pVehicleInfo->bankingSpeed*
+		float strafeDif = AngleSubtract(strafeRoll, pVeh->m_vOrientation[ROLL]);
+		pVeh->m_vOrientation[ROLL] += (strafeDif*0.1f)*pVeh->m_fTimeModifier;
+		if ( !BG_UnrestrainedPitchRoll( riderPS, pVeh ) )
+		{//cap it reasonably
+			if ( pVeh->m_pVehicleInfo->rollLimit != -1 
+				&& !pVeh->m_iRemovedSurfaces 
+				&& parentPS->electrifyTime<curTime)
+			{
+				if (pVeh->m_vOrientation[ROLL] > pVeh->m_pVehicleInfo->rollLimit )
+				{
+					pVeh->m_vOrientation[ROLL] = pVeh->m_pVehicleInfo->rollLimit;
+				}
+				else if (pVeh->m_vOrientation[ROLL] < -pVeh->m_pVehicleInfo->rollLimit)
+				{
+					pVeh->m_vOrientation[ROLL] = -pVeh->m_pVehicleInfo->rollLimit;
+				}
+			}
+		}
+	}
+
+	if (pVeh->m_pVehicleInfo->surfDestruction)
+	{
+		FighterDamageRoutine(pVeh, parent, parentPS, riderPS, isDead);
+	}
+	pVeh->m_vOrientation[ROLL] = AngleNormalize180( pVeh->m_vOrientation[ROLL] );
+	/********************************************************************************/
+	/*	END	Here is where make sure the vehicle is properly oriented.	END			*/
+	/********************************************************************************/
+}
+
+#ifdef QAGAME //ONLY in SP or on server, not cgame
+
+extern void PM_SetAnim(pmove_t	*pm,int setAnimParts,int anim,int setAnimFlags, int blendTime);
+
+// This function makes sure that the vehicle is properly animated.
+static void AnimateVehicle( Vehicle_t *pVeh )
+{
+	int Anim = -1; 
+	int iFlags = SETANIM_FLAG_NORMAL, iBlend = 300;
+	qboolean isLanding = qfalse, isLanded = qfalse;
+#ifdef _JK2MP
+	playerState_t *parentPS = pVeh->m_pParentEntity->playerState;
+#else
+	playerState_t *parentPS = &pVeh->m_pParentEntity->client->ps;
+#endif
+#ifndef _JK2MP//SP
+	//nothing
+#elif QAGAME//MP GAME
+	int curTime = level.time;
+#elif CGAME//MP CGAME
+	//FIXME: pass in ucmd?  Not sure if this is reliable...
+	int curTime = pm->cmd.serverTime;
+#endif
+
+#ifdef _JK2MP
+	if ( parentPS->hyperSpaceTime
+		&& curTime - parentPS->hyperSpaceTime < HYPERSPACE_TIME )
+	{//Going to Hyperspace
+		//close the wings (FIXME: makes sense on X-Wing, not Shuttle?)
+		if ( pVeh->m_ulFlags & VEH_WINGSOPEN )
+		{
+			pVeh->m_ulFlags &= ~VEH_WINGSOPEN;
+			Anim = BOTH_WINGS_CLOSE;
+		}
+	}
+	else
+#endif
+	{
+		isLanding = FighterIsLanding( pVeh, parentPS );
+		isLanded = FighterIsLanded( pVeh, parentPS );
+
+		// if we're above launch height (way up in the air)... 
+		if ( !isLanding && !isLanded ) 
+		{
+			if ( !( pVeh->m_ulFlags & VEH_WINGSOPEN ) )
+			{
+				pVeh->m_ulFlags |= VEH_WINGSOPEN;
+				pVeh->m_ulFlags &= ~VEH_GEARSOPEN;
+				Anim = BOTH_WINGS_OPEN;
+			}
+		}
+		// otherwise we're below launch height and still taking off.
+		else
+		{
+			if ( (pVeh->m_ucmd.forwardmove < 0 || pVeh->m_ucmd.upmove < 0||isLanded)
+				&& pVeh->m_LandTrace.fraction <= 0.4f
+				&& pVeh->m_LandTrace.plane.normal[2] >= MIN_LANDING_SLOPE )
+			{//already landed or trying to land and close to ground
+				// Open gears.
+				if ( !( pVeh->m_ulFlags & VEH_GEARSOPEN ) )
+				{
+#ifdef _JK2MP
+					if ( pVeh->m_pVehicleInfo->soundLand )
+					{//just landed?
+#ifdef QAGAME//MP GAME-side
+						G_EntitySound( ((gentity_t *)(pVeh->m_pParentEntity)), CHAN_AUTO, pVeh->m_pVehicleInfo->soundLand );
+#elif CGAME//MP CGAME-side
+						//trap_S_StartSound( NULL, pVeh->m_pParentEntity->s.number, CHAN_AUTO, pVeh->m_pVehicleInfo->soundLand );
+#endif
+					}
+#endif
+					pVeh->m_ulFlags |= VEH_GEARSOPEN;
+					Anim = BOTH_GEARS_OPEN;
+				}
+			}
+			else
+			{//trying to take off and almost halfway off the ground
+				// Close gears (if they're open).
+				if ( pVeh->m_ulFlags & VEH_GEARSOPEN )
+				{
+					pVeh->m_ulFlags &= ~VEH_GEARSOPEN;
+					Anim = BOTH_GEARS_CLOSE;
+					//iFlags = SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLD; 
+				}
+				// If gears are closed, and we are below launch height, close the wings.
+				else
+				{
+					if ( pVeh->m_ulFlags & VEH_WINGSOPEN )
+					{
+						pVeh->m_ulFlags &= ~VEH_WINGSOPEN;
+						Anim = BOTH_WINGS_CLOSE;
+					}
+				}
+			}
+		}
+	}
+
+	if ( Anim != -1 )
+	{
+		#ifdef _JK2MP
+			BG_SetAnim(pVeh->m_pParentEntity->playerState, bgAllAnims[pVeh->m_pParentEntity->localAnimIndex].anims,
+				SETANIM_BOTH, Anim, iFlags, iBlend);
+		#else
+			NPC_SetAnim( pVeh->m_pParentEntity, SETANIM_BOTH, Anim, iFlags, iBlend );
+		#endif
+	}
+}
+
+// This function makes sure that the rider's in this vehicle are properly animated.
+static void AnimateRiders( Vehicle_t *pVeh )
+{
+}
+
+#endif //game-only
+
+#ifndef QAGAME
+void AttachRidersGeneric( Vehicle_t *pVeh );
+#endif
+
+void G_SetFighterVehicleFunctions( vehicleInfo_t *pVehInfo )
+{
+#ifdef QAGAME //ONLY in SP or on server, not cgame
+	pVehInfo->AnimateVehicle			=		AnimateVehicle;
+	pVehInfo->AnimateRiders				=		AnimateRiders;
+//	pVehInfo->ValidateBoard				=		ValidateBoard;
+//	pVehInfo->SetParent					=		SetParent;
+//	pVehInfo->SetPilot					=		SetPilot;
+//	pVehInfo->AddPassenger				=		AddPassenger;
+//	pVehInfo->Animate					=		Animate;
+	pVehInfo->Board						=		Board;
+	pVehInfo->Eject						=		Eject;
+//	pVehInfo->EjectAll					=		EjectAll;
+//	pVehInfo->StartDeathDelay			=		StartDeathDelay;
+//	pVehInfo->DeathUpdate				=		DeathUpdate;
+//	pVehInfo->RegisterAssets			=		RegisterAssets;
+//	pVehInfo->Initialize				=		Initialize;
+	pVehInfo->Update					=		Update;
+//	pVehInfo->UpdateRider				=		UpdateRider;
+#endif //game-only
+	pVehInfo->ProcessMoveCommands		=		ProcessMoveCommands;
+	pVehInfo->ProcessOrientCommands		=		ProcessOrientCommands;
+
+#ifndef QAGAME //cgame prediction attachment func
+	pVehInfo->AttachRiders				=		AttachRidersGeneric;
+#endif
+//	pVehInfo->AttachRiders				=		AttachRiders;
+//	pVehInfo->Ghost						=		Ghost;
+//	pVehInfo->UnGhost					=		UnGhost;
+//	pVehInfo->Inhabited					=		Inhabited;
+}
+
+// Following is only in game, not in namespace
+#ifdef _JK2MP
+#include "../namespace_end.h"
+#endif
+
+#ifdef QAGAME
+extern void G_AllocateVehicleObject(Vehicle_t **pVeh);
+#endif
+
+#ifdef _JK2MP
+#include "../namespace_begin.h"
+#endif
+
+// Create/Allocate a new Animal Vehicle (initializing it as well).
+void G_CreateFighterNPC( Vehicle_t **pVeh, const char *strType )
+{
+	// Allocate the Vehicle.
+#ifdef _JK2MP
+#ifdef QAGAME
+	//these will remain on entities on the client once allocated because the pointer is
+	//never stomped. on the server, however, when an ent is freed, the entity struct is
+	//memset to 0, so this memory would be lost..
+    G_AllocateVehicleObject(pVeh);
+#else
+	if (!*pVeh)
+	{ //only allocate a new one if we really have to
+		(*pVeh) = (Vehicle_t *) BG_Alloc( sizeof(Vehicle_t) );
+	}
+#endif
+	memset(*pVeh, 0, sizeof(Vehicle_t));
+#else
+	(*pVeh) = (Vehicle_t *) gi.Malloc( sizeof(Vehicle_t), TAG_G_ALLOC, qtrue );
+#endif
+	(*pVeh)->m_pVehicleInfo = &g_vehicleInfo[BG_VehicleGetIndex( strType )];
+}
+
+#ifdef _JK2MP
+
+#include "../namespace_end.h"
+
+//get rid of all the crazy defs we added for this file
+#undef currentAngles
+#undef currentOrigin
+#undef mins
+#undef maxs
+#undef legsAnimTimer
+#undef torsoAnimTimer
+#undef bool
+#undef false
+#undef true
+
+#undef sqrtf
+#undef Q_flrand
+
+#undef MOD_EXPLOSIVE
+#endif
diff --git a/code/game/G_Timer.cpp b/code/game/G_Timer.cpp
new file mode 100644
index 0000000..65e8f46
--- /dev/null
+++ b/code/game/G_Timer.cpp
@@ -0,0 +1,397 @@
+// leave this line at the top for all g_xxxx.cpp files...
+#include "g_headers.h"
+
+#include "G_Local.h"
+#include "../rufl/hstring.h"
+
+#define MAX_GTIMERS	16384
+
+typedef struct gtimer_s
+{
+	hstring id;				// Use handle strings, so that things work after loading
+	int time;
+	struct gtimer_s *next;	// In either free list or current list
+} gtimer_t;
+
+gtimer_t g_timerPool[ MAX_GTIMERS ];
+gtimer_t *g_timers[ MAX_GENTITIES ];
+gtimer_t *g_timerFreeList;
+
+
+static int TIMER_GetCount(int num)
+{
+	gtimer_t *p = g_timers[num];
+	int count = 0;
+
+	while (p)
+	{
+		count++;
+		p = p->next;
+	}
+	
+	return count;
+}	
+
+
+/*
+-------------------------
+TIMER_RemoveHelper
+
+Scans an entities timer list to remove a given
+timer from the list and put it on the free list
+
+Doesn't do much error checking, only called below
+-------------------------
+*/
+static void TIMER_RemoveHelper( int num, gtimer_t *timer )
+{
+	gtimer_t *p = g_timers[num];
+
+	// Special case: first timer in list
+	if (p == timer)
+	{
+		g_timers[num] = g_timers[num]->next;
+		p->next = g_timerFreeList;
+		g_timerFreeList = p;
+		return;
+	}
+
+	// Find the predecessor
+	while (p->next != timer)
+	{
+		p = p->next;
+	}
+
+	// Rewire
+	p->next = p->next->next;
+	timer->next = g_timerFreeList;
+	g_timerFreeList = timer;
+	return;
+}
+
+
+
+
+/*
+-------------------------
+TIMER_Clear
+-------------------------
+*/
+
+void TIMER_Clear( void )
+{
+	int i;
+	for (i = 0; i < MAX_GENTITIES; i++)
+	{
+		g_timers[i] = NULL;
+	}
+
+	for (i = 0; i < MAX_GTIMERS - 1; i++)
+	{
+		g_timerPool[i].next = &g_timerPool[i+1];
+	}
+	g_timerPool[MAX_GTIMERS-1].next = NULL;
+	g_timerFreeList = &g_timerPool[0];
+}
+
+/*
+-------------------------
+TIMER_Clear
+-------------------------
+*/
+
+void TIMER_Clear( int idx )
+{
+	// rudimentary safety checks, might be other things to check?
+	if ( idx >= 0 && idx < MAX_GENTITIES )
+	{
+		gtimer_t *p = g_timers[idx];
+
+		// No timers at all -> do nothing
+		if (!p)
+		{
+			return;
+		}
+
+		// Find the end of this ents timer list
+		while (p->next)
+		{
+			p = p->next;
+		}
+
+		// Splice the lists
+		p->next = g_timerFreeList;
+		g_timerFreeList = g_timers[idx];
+		g_timers[idx] = NULL;
+		return;
+	}
+}
+
+
+/*
+-------------------------
+TIMER_Save
+-------------------------
+*/
+
+void TIMER_Save( void )
+{
+	int			j;
+	gentity_t	*ent;
+
+	for ( j = 0, ent = &g_entities[0]; j < MAX_GENTITIES; j++, ent++ )
+	{
+		unsigned char numTimers = TIMER_GetCount(j);
+
+		if ( !ent->inuse && numTimers)
+		{
+//			Com_Printf( "WARNING: ent with timers not inuse\n" );
+			assert(numTimers);
+			TIMER_Clear( j );
+			numTimers = 0;
+		}
+
+		//Write out the timer information
+		gi.AppendToSaveGame('TIME', (void *)&numTimers, sizeof(numTimers));
+	
+		gtimer_t *p = g_timers[j];
+		assert ((numTimers && p) || (!numTimers && !p));
+
+		while(p)
+		{
+			const char	*timerID = p->id.c_str();
+			const int	length = strlen(timerID) + 1;
+			const int	time = p->time - level.time;	//convert this back to delta so we can use SET after loading
+
+			assert( length < 1024 );//This will cause problems when loading the timer if longer
+
+			//Write out the id string
+			gi.AppendToSaveGame('TMID', (void *) timerID, length);
+
+			//Write out the timer data
+			gi.AppendToSaveGame('TDTA', (void *) &time, sizeof( time ) );
+			p = p->next;
+		}
+	}
+}
+
+/*
+-------------------------
+TIMER_Load
+-------------------------
+*/
+
+void TIMER_Load( void )
+{
+	int j;
+	gentity_t	*ent;
+
+	for ( j = 0, ent = &g_entities[0]; j < MAX_GENTITIES; j++, ent++ )
+	{
+		unsigned char numTimers;
+
+		gi.ReadFromSaveGame( 'TIME', (void *)&numTimers, sizeof(numTimers) );
+
+		//Read back all entries
+		for ( int i = 0; i < numTimers; i++ )
+		{
+			int		time;
+			char	tempBuffer[1024];	// Still ugly. Setting ourselves up for 007 AUF all over again. =)
+
+			assert (sizeof(g_timers[0]->time) == sizeof(time) );//make sure we're reading the same size as we wrote
+
+			//Read the id string and time
+			gi.ReadFromSaveGame( 'TMID', (char *) tempBuffer, 0 );
+			gi.ReadFromSaveGame( 'TDTA', (void *) &time, sizeof( time ) );
+
+			//this is odd, we saved all the timers in the autosave, but not all the ents are spawned yet from an auto load, so skip it
+			if (ent->inuse)
+			{	//Restore it
+				TIMER_Set(ent, tempBuffer, time);
+			}
+		}
+	}
+}
+
+
+static gtimer_t *TIMER_GetNew(int num, const char *identifier)
+{
+	assert(num < ENTITYNUM_MAX_NORMAL);//don't want timers on NONE or the WORLD
+	gtimer_t *p = g_timers[num];
+
+	// Search for an existing timer with this name
+	while (p)
+	{
+		if (p->id == identifier)
+		{ // Found it
+			return p;
+		}
+
+		p = p->next;
+	}
+
+	// No existing timer with this name was found, so grab one from the free list
+	if (!g_timerFreeList)
+	{//oh no, none free!
+		assert(g_timerFreeList);
+		return NULL;
+	}
+
+	p = g_timerFreeList;
+	g_timerFreeList = g_timerFreeList->next;
+	p->next = g_timers[num];
+	g_timers[num] = p;
+	return p;
+}
+
+
+gtimer_t *TIMER_GetExisting(int num, const char *identifier)
+{
+	gtimer_t *p = g_timers[num];
+
+	while (p)
+	{
+		if (p->id == identifier)
+		{ // Found it
+			return p;
+		}
+
+		p = p->next;
+	}
+	
+	return NULL;
+}	
+
+
+
+/*
+-------------------------
+TIMER_Set
+-------------------------
+*/
+
+void TIMER_Set( gentity_t *ent, const char *identifier, int duration )
+{
+	assert(ent->inuse);
+	gtimer_t *timer = TIMER_GetNew(ent->s.number, identifier);
+
+	if (timer)
+	{
+		timer->id	= identifier;
+		timer->time = level.time + duration;
+	}
+}
+
+/*
+-------------------------
+TIMER_Get
+-------------------------
+*/
+
+int	TIMER_Get( gentity_t *ent, const char *identifier )
+{
+	gtimer_t *timer = TIMER_GetExisting(ent->s.number, identifier);
+
+	if (!timer)
+	{
+		return -1;
+	}
+
+	return timer->time;
+}
+
+/*
+-------------------------
+TIMER_Done
+-------------------------
+*/
+
+qboolean TIMER_Done( gentity_t *ent, const char *identifier )
+{
+	gtimer_t *timer = TIMER_GetExisting(ent->s.number, identifier);
+
+	if (!timer)
+	{
+		return qtrue;
+	}
+
+	return (timer->time < level.time);
+}
+
+/*
+-------------------------
+TIMER_Done2
+
+Returns false if timer has been 
+started but is not done...or if 
+timer was never started
+-------------------------
+*/
+
+qboolean TIMER_Done2( gentity_t *ent, const char *identifier, qboolean remove )
+{
+	gtimer_t *timer = TIMER_GetExisting(ent->s.number, identifier);
+	qboolean res;
+
+	if (!timer)
+	{
+		return qfalse;
+	}
+
+	res = (timer->time < level.time);
+
+	if (res && remove)
+	{
+		// Put it back on the free list
+		TIMER_RemoveHelper(ent->s.number, timer);
+	}
+
+	return res;
+}
+
+/*
+-------------------------
+TIMER_Exists
+-------------------------
+*/
+qboolean TIMER_Exists( gentity_t *ent, const char *identifier )
+{
+	return (qboolean)TIMER_GetExisting(ent->s.number, identifier);
+}
+
+
+
+/*
+-------------------------
+TIMER_Remove
+Utility to get rid of any timer
+-------------------------
+*/
+void TIMER_Remove( gentity_t *ent, const char *identifier )
+{
+	gtimer_t *timer = TIMER_GetExisting(ent->s.number, identifier);
+
+	if (!timer)
+	{
+		return;
+	}
+
+	// Put it back on the free list
+	TIMER_RemoveHelper(ent->s.number, timer);
+}
+
+/*
+-------------------------
+TIMER_Start
+-------------------------
+*/
+
+qboolean TIMER_Start( gentity_t *self, const char *identifier, int duration )
+{
+	if ( TIMER_Done( self, identifier ) )
+	{
+		TIMER_Set( self, identifier, duration );
+		return qtrue;
+	}
+	return qfalse;
+}
diff --git a/code/game/NPC.cpp b/code/game/NPC.cpp
new file mode 100644
index 0000000..a51a1f2
--- /dev/null
+++ b/code/game/NPC.cpp
@@ -0,0 +1,2724 @@
+//
+// NPC.cpp - generic functions
+//
+
+// leave this line at the top for all NPC_xxxx.cpp files...
+#include "g_headers.h"
+
+
+
+#include "b_local.h"
+#include "anims.h"
+#include "g_functions.h"
+#include "say.h"
+#include "Q3_Interface.h"
+#include "g_vehicles.h"
+
+extern vec3_t playerMins;
+extern vec3_t playerMaxs;
+//extern void PM_SetAnimFinal(int *torsoAnim,int *legsAnim,int type,int anim,int priority,int *torsoAnimTimer,int *legsAnimTimer,gentity_t *gent);
+extern void PM_SetTorsoAnimTimer( gentity_t *ent, int *torsoAnimTimer, int time );
+extern void PM_SetLegsAnimTimer( gentity_t *ent, int *legsAnimTimer, int time );
+extern void NPC_BSNoClip ( void );
+extern void G_AddVoiceEvent( gentity_t *self, int event, int speakDebounceTime );
+extern void NPC_ApplyRoff (void);
+extern void NPC_TempLookTarget ( gentity_t *self, int lookEntNum, int minLookTime, int maxLookTime );
+extern void NPC_CheckPlayerAim ( void );
+extern void NPC_CheckAllClear ( void );
+extern void G_AddVoiceEvent( gentity_t *self, int event, int speakDebounceTime );
+extern qboolean NPC_CheckLookTarget( gentity_t *self );
+extern void NPC_SetLookTarget( gentity_t *self, int entNum, int clearTime );
+extern void Mark1_dying( gentity_t *self );
+extern void NPC_BSCinematic( void );
+extern int GetTime ( int lastTime );
+extern void G_CheckCharmed( gentity_t *self );
+extern qboolean Boba_Flying( gentity_t *self );
+extern qboolean RT_Flying( gentity_t *self );
+extern qboolean Jedi_CultistDestroyer( gentity_t *self );
+extern void Boba_Update();
+extern bool Boba_Flee();
+extern bool Boba_Tactics();
+extern void BubbleShield_Update();
+extern qboolean PM_LockedAnim( int anim );
+
+extern cvar_t	*g_dismemberment;
+extern cvar_t	*g_saberRealisticCombat;
+extern cvar_t	*g_corpseRemovalTime;
+
+//Local Variables
+// ai debug cvars
+cvar_t		*debugNPCAI;			// used to print out debug info about the bot AI
+cvar_t		*debugNPCFreeze;		// set to disable bot ai and temporarily freeze them in place
+cvar_t		*debugNPCName;
+cvar_t		*d_saberCombat;
+cvar_t		*d_JediAI;
+cvar_t		*d_noGroupAI;
+cvar_t		*d_asynchronousGroupAI;
+cvar_t		*d_slowmodeath;
+
+extern qboolean	stop_icarus;
+
+gentity_t		*NPC;
+gNPC_t			*NPCInfo;
+gclient_t		*client;
+usercmd_t		ucmd;
+visibility_t	enemyVisibility;
+
+void NPC_SetAnim(gentity_t	*ent,int setAnimParts,int anim,int setAnimFlags, int iBlend);
+static bState_t G_CurrentBState( gNPC_t *gNPC );
+
+extern int eventClearTime;
+
+void CorpsePhysics( gentity_t *self )
+{
+	// run the bot through the server like it was a real client
+	memset( &ucmd, 0, sizeof( ucmd ) );
+	ClientThink( self->s.number, &ucmd );
+	VectorCopy( self->s.origin, self->s.origin2 );
+	
+	//FIXME: match my pitch and roll for the slope of my groundPlane
+	if ( self->client->ps.groundEntityNum != ENTITYNUM_NONE && !(self->flags&FL_DISINTEGRATED) )
+	{//on the ground
+		//FIXME: check 4 corners
+		pitch_roll_for_slope( self );
+	}
+
+	if ( eventClearTime == level.time + ALERT_CLEAR_TIME )
+	{//events were just cleared out so add me again
+		if ( !(self->client->ps.eFlags&EF_NODRAW) )
+		{
+			AddSightEvent( self->enemy, self->currentOrigin, 384, AEL_DISCOVERED );
+		}
+	}
+
+	if ( level.time - self->s.time > 3000 )
+	{//been dead for 3 seconds
+		if ( g_dismemberment->integer != 113811381138 && !g_saberRealisticCombat->integer )
+		{//can't be dismembered once dead
+			if ( self->client->NPC_class != CLASS_PROTOCOL )
+			{
+				self->client->dismembered = true;
+			}
+		}
+	}
+
+	if ( level.time - self->s.time > 500 )
+	{//don't turn "nonsolid" until about 1 second after actual death
+
+		if ((self->client->NPC_class != CLASS_MARK1) && (self->client->NPC_class != CLASS_INTERROGATOR))	// The Mark1 & Interrogator stays solid.
+		{
+			self->contents = CONTENTS_CORPSE;
+		}
+
+		if ( self->message )
+		{
+			self->contents |= CONTENTS_TRIGGER;
+		}
+	}
+}
+
+/*
+----------------------------------------
+NPC_RemoveBody
+
+Determines when it's ok to ditch the corpse
+----------------------------------------
+*/
+#define REMOVE_DISTANCE		128
+#define REMOVE_DISTANCE_SQR (REMOVE_DISTANCE * REMOVE_DISTANCE)
+extern qboolean InFOVFromPlayerView ( gentity_t *ent, int hFOV, int vFOV );
+qboolean G_OkayToRemoveCorpse( gentity_t *self )
+{
+	//if we're still on a vehicle, we won't remove ourselves until we get ejected
+	if ( self->client && self->client->NPC_class != CLASS_VEHICLE && self->s.m_iVehicleNum != 0 )
+	{
+		Vehicle_t *pVeh = g_entities[self->s.m_iVehicleNum].m_pVehicle;
+		if ( pVeh )
+		{
+			if ( !pVeh->m_pVehicleInfo->Eject( pVeh, self, qtrue ) )
+			{//dammit, still can't get off the vehicle...
+				return qfalse;
+			}
+		}
+		else
+		{
+			assert(0);
+#ifndef FINAL_BUILD
+			Com_Printf(S_COLOR_RED"ERROR: Dead pilot's vehicle removed while corpse was riding it (pilot: %s)???\n",self->targetname);
+#endif
+		}
+	}
+
+	if ( self->message )
+	{//I still have a key
+		return qfalse;
+	}
+	
+	if ( IIcarusInterface::GetIcarus()->IsRunning( self->m_iIcarusID ) )
+	{//still running a script
+		return qfalse;
+	}
+
+	if ( self->activator 
+		&& self->activator->client 
+		&& ((self->activator->client->ps.eFlags&EF_HELD_BY_RANCOR)
+			|| (self->activator->client->ps.eFlags&EF_HELD_BY_SAND_CREATURE)
+			|| (self->activator->client->ps.eFlags&EF_HELD_BY_WAMPA)) )
+	{//still holding a victim?
+		return qfalse;
+	}
+
+	if ( self->client 
+		&& ((self->client->ps.eFlags&EF_HELD_BY_RANCOR) 
+			|| (self->client->ps.eFlags&EF_HELD_BY_SAND_CREATURE) 
+			|| (self->client->ps.eFlags&EF_HELD_BY_WAMPA) ) )
+	{//being held by a creature
+		return qfalse;
+	}
+
+	if ( self->client->ps.heldByClient < ENTITYNUM_WORLD )
+	{//being dragged
+		return qfalse;
+	}
+
+	//okay, well okay to remove us...?
+	return qtrue;
+}
+
+void NPC_RemoveBody( gentity_t *self )
+{
+	self->nextthink = level.time + FRAMETIME/2;
+
+	//run physics at 20fps
+	CorpsePhysics( self );
+
+	if ( self->NPC->nextBStateThink <= level.time )
+	{//run logic at 10 fps
+		if( self->m_iIcarusID != IIcarusInterface::ICARUS_INVALID && !stop_icarus )
+		{
+			IIcarusInterface::GetIcarus()->Update( self->m_iIcarusID );
+		}
+		self->NPC->nextBStateThink = level.time + FRAMETIME;
+
+		if ( !G_OkayToRemoveCorpse( self ) )
+		{
+			return;
+		}
+
+		// I don't consider this a hack, it's creative coding . . . 
+		// I agree, very creative... need something like this for ATST and GALAKMECH too!
+		if (self->client->NPC_class == CLASS_MARK1)
+		{
+			Mark1_dying( self );
+		}
+
+		// Since these blow up, remove the bounding box.
+		if ( self->client->NPC_class == CLASS_REMOTE 
+			|| self->client->NPC_class == CLASS_SENTRY
+			|| self->client->NPC_class == CLASS_PROBE
+			|| self->client->NPC_class == CLASS_INTERROGATOR
+			|| self->client->NPC_class == CLASS_PROBE
+			|| self->client->NPC_class == CLASS_MARK2 )
+		{
+			G_FreeEntity( self );
+			return;
+		}
+
+		//FIXME: don't ever inflate back up?
+		self->maxs[2] = self->client->renderInfo.eyePoint[2] - self->currentOrigin[2] + 4;
+		if ( self->maxs[2] < -8 )
+		{
+			self->maxs[2] = -8;
+		}
+
+		if ( (self->NPC->aiFlags&NPCAI_HEAL_ROSH) )
+		{//kothos twins' bodies are never removed
+			return;
+		}
+
+		if ( self->client->NPC_class == CLASS_GALAKMECH )
+		{//never disappears
+			return;
+		}
+
+		if ( self->NPC && self->NPC->timeOfDeath <= level.time )
+		{
+			self->NPC->timeOfDeath = level.time + 1000;
+			// Only do all of this nonsense for Scav boys ( and girls )
+		///	if ( self->client->playerTeam == TEAM_SCAVENGERS || self->client->playerTeam == TEAM_KLINGON 
+		//		|| self->client->playerTeam == TEAM_HIROGEN || self->client->playerTeam == TEAM_MALON )
+			// should I check NPC_class here instead of TEAM ? - dmv
+			if( self->client->playerTeam == TEAM_ENEMY || self->client->NPC_class == CLASS_PROTOCOL )
+			{
+				self->nextthink = level.time + FRAMETIME; // try back in a second
+
+				if ( DistanceSquared( g_entities[0].currentOrigin, self->currentOrigin ) <= REMOVE_DISTANCE_SQR )
+				{
+					return;
+				}
+
+				if ( (InFOVFromPlayerView( self, 110, 90 )) ) // generous FOV check
+				{
+					if ( (NPC_ClearLOS( &g_entities[0], self->currentOrigin )) )
+					{
+						return;
+					}
+				}
+			}
+
+			//FIXME: there are some conditions - such as heavy combat - in which we want
+			//			to remove the bodies... but in other cases it's just weird, like
+			//			when they're right behind you in a closed room and when they've been
+			//			placed as dead NPCs by a designer...
+			//			For now we just assume that a corpse with no enemy was 
+			//			placed in the map as a corpse
+			if ( self->enemy )
+			{
+				if ( self->client && self->client->ps.saberEntityNum > 0 && self->client->ps.saberEntityNum < ENTITYNUM_WORLD )
+				{
+					gentity_t *saberent = &g_entities[self->client->ps.saberEntityNum];
+					if ( saberent )
+					{
+						G_FreeEntity( saberent );
+					}
+				}
+				G_FreeEntity( self );
+			}
+		}
+	}
+}
+
+/*
+----------------------------------------
+NPC_RemoveBody
+
+Determines when it's ok to ditch the corpse
+----------------------------------------
+*/
+
+int BodyRemovalPadTime( gentity_t *ent )
+{
+	int	time;
+
+	if ( !ent || !ent->client )
+		return 0;
+/*
+	switch ( ent->client->playerTeam )
+	{
+	case TEAM_KLINGON:	// no effect, we just remove them when the player isn't looking
+	case TEAM_SCAVENGERS:
+	case TEAM_HIROGEN:
+	case TEAM_MALON:
+	case TEAM_IMPERIAL:
+	case TEAM_STARFLEET:
+		time = 10000; // 15 secs.
+		break;
+
+	case TEAM_BORG:
+		time = 2000;
+		break;
+
+	case TEAM_STASIS:
+		return qtrue;
+		break;
+
+	case TEAM_FORGE:
+		time = 1000;
+		break;
+
+	case TEAM_BOTS:
+//		if (!Q_stricmp( ent->NPC_type, "mouse" ))
+//		{
+			time = 0;
+//		}
+//		else
+//		{
+//			time = 10000;
+//		}
+		break;
+
+	case TEAM_8472:
+		time = 2000;
+		break;
+
+	default:
+		// never go away
+		time = Q3_INFINITE;
+		break;
+	}
+*/
+	// team no longer indicates species/race, so in this case we'd use NPC_class, but
+	switch( ent->client->NPC_class )
+	{
+	case CLASS_MOUSE:
+	case CLASS_GONK:
+	case CLASS_R2D2:
+	case CLASS_R5D2:
+	//case CLASS_PROTOCOL:
+	case CLASS_MARK1:
+	case CLASS_MARK2:
+	case CLASS_PROBE:
+	case CLASS_SEEKER:
+	case CLASS_REMOTE:
+	case CLASS_SENTRY:
+	case CLASS_INTERROGATOR:
+		time = 0;
+		break;
+	default:
+		// never go away
+		if ( g_corpseRemovalTime->integer <= 0 )
+		{
+			time = Q3_INFINITE;
+		}
+		else
+		{
+			time = g_corpseRemovalTime->integer*1000;
+		}
+		break;
+
+	}
+	
+
+	return time;
+}
+
+
+/*
+----------------------------------------
+NPC_RemoveBodyEffect
+
+Effect to be applied when ditching the corpse
+----------------------------------------
+*/
+
+static void NPC_RemoveBodyEffect(void)
+{
+//	vec3_t		org;
+//	gentity_t	*tent;
+
+	if ( !NPC || !NPC->client || (NPC->s.eFlags & EF_NODRAW) )
+		return;
+/*
+	switch(NPC->client->playerTeam)
+	{
+	case TEAM_STARFLEET:
+		//FIXME: Starfleet beam out
+		break;
+
+	case TEAM_BOTS:
+//		VectorCopy( NPC->currentOrigin, org );
+//		org[2] -= 16;
+//		tent = G_TempEntity( org, EV_BOT_EXPLODE );
+//		tent->owner = NPC;
+
+		break;
+
+	default:
+		break;
+	}
+*/
+
+
+	// team no longer indicates species/race, so in this case we'd use NPC_class, but
+	
+	// stub code
+	switch(NPC->client->NPC_class)
+	{
+	case CLASS_PROBE:
+	case CLASS_SEEKER:
+	case CLASS_REMOTE:
+	case CLASS_SENTRY:
+	case CLASS_GONK:
+	case CLASS_R2D2:
+	case CLASS_R5D2:
+	//case CLASS_PROTOCOL:
+	case CLASS_MARK1:
+	case CLASS_MARK2:
+	case CLASS_INTERROGATOR:
+	case CLASS_ATST: // yeah, this is a little weird, but for now I'm listing all droids
+	//	VectorCopy( NPC->currentOrigin, org );
+	//	org[2] -= 16;
+	//	tent = G_TempEntity( org, EV_BOT_EXPLODE );
+	//	tent->owner = NPC;
+		break;
+	default:
+		break;
+	}
+
+
+}
+
+
+/*
+====================================================================
+void pitch_roll_for_slope (edict_t *forwhom, vec3_t *slope, vec3_t storeAngles )
+
+MG
+
+This will adjust the pitch and roll of a monster to match
+a given slope - if a non-'0 0 0' slope is passed, it will
+use that value, otherwise it will use the ground underneath
+the monster.  If it doesn't find a surface, it does nothinh\g
+and returns.
+====================================================================
+*/
+
+void pitch_roll_for_slope( gentity_t *forwhom, vec3_t pass_slope, vec3_t storeAngles )
+{
+	vec3_t	slope;
+	vec3_t	nvf, ovf, ovr, startspot, endspot, new_angles = { 0, 0, 0 };
+	float	pitch, mod, dot;
+
+	//if we don't have a slope, get one
+	if( !pass_slope || VectorCompare( vec3_origin, pass_slope ) )
+	{
+		trace_t trace;
+
+		VectorCopy( forwhom->currentOrigin, startspot );
+		startspot[2] += forwhom->mins[2] + 4;
+		VectorCopy( startspot, endspot );
+		endspot[2] -= 300;
+		gi.trace( &trace, forwhom->currentOrigin, vec3_origin, vec3_origin, endspot, forwhom->s.number, MASK_SOLID );
+//		if(trace_fraction>0.05&&forwhom.movetype==MOVETYPE_STEP)
+//			forwhom.flags(-)FL_ONGROUND;
+
+		if ( trace.fraction >= 1.0 )
+			return;
+
+		if( !( &trace.plane ) )
+			return;
+
+		if ( VectorCompare( vec3_origin, trace.plane.normal ) )
+			return;
+
+		VectorCopy( trace.plane.normal, slope );
+	}
+	else
+	{
+		VectorCopy( pass_slope, slope );
+	}
+
+	if ( forwhom->client && forwhom->client->NPC_class == CLASS_VEHICLE )
+	{//special code for vehicles
+		Vehicle_t *pVeh = forwhom->m_pVehicle;
+
+		vec3_t tempAngles;
+		tempAngles[PITCH] = tempAngles[ROLL] = 0;
+		tempAngles[YAW] = pVeh->m_vOrientation[YAW];
+		AngleVectors( tempAngles, ovf, ovr, NULL );
+	}
+	else
+	{
+		AngleVectors( forwhom->currentAngles, ovf, ovr, NULL );
+	}
+
+	vectoangles( slope, new_angles );
+	pitch = new_angles[PITCH] + 90;
+	new_angles[ROLL] = new_angles[PITCH] = 0;
+
+	AngleVectors( new_angles, nvf, NULL, NULL );
+
+	mod = DotProduct( nvf, ovr );
+
+	if ( mod<0 )
+		mod = -1;
+	else
+		mod = 1;
+
+	dot = DotProduct( nvf, ovf );
+
+	if ( storeAngles )
+	{
+		storeAngles[PITCH] = dot * pitch;
+		storeAngles[ROLL] = ((1-Q_fabs(dot)) * pitch * mod);
+	}
+	else if ( forwhom->client )
+	{
+		forwhom->client->ps.viewangles[PITCH] = dot * pitch;
+		forwhom->client->ps.viewangles[ROLL] = ((1-Q_fabs(dot)) * pitch * mod);
+		float oldmins2 = forwhom->mins[2];
+		forwhom->mins[2] = -24 + 12 * fabs(forwhom->client->ps.viewangles[PITCH])/180.0f;
+		//FIXME: if it gets bigger, move up
+		if ( oldmins2 > forwhom->mins[2] )
+		{//our mins is now lower, need to move up
+			//FIXME: trace?
+			forwhom->client->ps.origin[2] += (oldmins2 - forwhom->mins[2]);
+			forwhom->currentOrigin[2] = forwhom->client->ps.origin[2];
+			gi.linkentity( forwhom );
+		}
+	}
+	else
+	{
+		forwhom->currentAngles[PITCH] = dot * pitch;
+		forwhom->currentAngles[ROLL] = ((1-Q_fabs(dot)) * pitch * mod);
+	}
+}
+
+/*
+void NPC_PostDeathThink( void )
+{
+	float	mostdist;
+	trace_t trace1, trace2, trace3, trace4, movetrace;
+	vec3_t	org, endpos, startpos, forward, right;
+	int		whichtrace = 0;
+	float	cornerdist[4];
+	qboolean	frontbackbothclear = false;
+	qboolean	rightleftbothclear = false;
+
+	if( NPC->client->ps.groundEntityNum == ENTITYNUM_NONE || !VectorCompare( vec3_origin, NPC->client->ps.velocity ) )
+	{
+		if ( NPC->client->ps.groundEntityNum != ENTITYNUM_NONE && NPC->client->ps.friction == 1.0 )//check avelocity?
+		{
+			pitch_roll_for_slope( NPC );
+		}
+
+		return;
+	}
+
+	cornerdist[FRONT] = cornerdist[BACK] = cornerdist[RIGHT] = cornerdist[LEFT] = 0.0f;
+
+	mostdist = MIN_DROP_DIST;
+
+	AngleVectors( NPC->currentAngles, forward, right, NULL );
+	VectorCopy( NPC->currentOrigin, org );
+	org[2] += NPC->mins[2];
+
+	VectorMA( org, NPC->dead_size, forward, startpos );
+	VectorCopy( startpos, endpos );
+	endpos[2] -= 128;
+	gi.trace( &trace1, startpos, vec3_origin, vec3_origin, endpos, NPC->s.number, MASK_SOLID, );
+	if( !trace1.allsolid && !trace1.startsolid )
+	{
+		cornerdist[FRONT] = trace1.fraction;
+		if ( trace1.fraction > mostdist )
+		{
+			mostdist = trace1.fraction;
+			whichtrace = 1;
+		}
+	}
+
+	VectorMA( org, -NPC->dead_size, forward, startpos );
+	VectorCopy( startpos, endpos );
+	endpos[2] -= 128;
+	gi.trace( &trace2, startpos, vec3_origin, vec3_origin, endpos, NPC->s.number, MASK_SOLID );
+	if( !trace2.allsolid && !trace2.startsolid )
+	{
+		cornerdist[BACK] = trace2.fraction;
+		if ( trace2.fraction > mostdist )
+		{
+			mostdist = trace2.fraction;
+			whichtrace = 2;
+		}
+	}
+
+	VectorMA( org, NPC->dead_size/2, right, startpos );
+	VectorCopy( startpos, endpos );
+	endpos[2] -= 128;
+	gi.trace( &trace3, startpos, vec3_origin, vec3_origin, endpos, NPC->s.number, MASK_SOLID );
+	if ( !trace3.allsolid && !trace3.startsolid )
+	{
+		cornerdist[RIGHT] = trace3.fraction;
+		if ( trace3.fraction>mostdist )
+		{
+			mostdist = trace3.fraction;
+			whichtrace = 3;
+		}
+	}
+
+	VectorMA( org, -NPC->dead_size/2, right, startpos );
+	VectorCopy( startpos, endpos );
+	endpos[2] -= 128;
+	gi.trace( &trace4, startpos, vec3_origin, vec3_origin, endpos, NPC->s.number, MASK_SOLID );
+	if ( !trace4.allsolid && !trace4.startsolid )
+	{
+		cornerdist[LEFT] = trace4.fraction;
+		if ( trace4.fraction > mostdist )
+		{
+			mostdist = trace4.fraction;
+			whichtrace = 4;
+		}
+	}
+	
+	//OK!  Now if two opposite sides are hanging, use a third if any, else, do nothing
+	if ( cornerdist[FRONT] > MIN_DROP_DIST && cornerdist[BACK] > MIN_DROP_DIST )
+		frontbackbothclear = true;
+
+	if ( cornerdist[RIGHT] > MIN_DROP_DIST && cornerdist[LEFT] > MIN_DROP_DIST )
+		rightleftbothclear = true;
+
+	if ( frontbackbothclear && rightleftbothclear )
+		return;
+
+	if ( frontbackbothclear )
+	{
+		if ( cornerdist[RIGHT] > MIN_DROP_DIST )
+			whichtrace = 3;
+		else if ( cornerdist[LEFT] > MIN_DROP_DIST )
+			whichtrace = 4;
+		else
+			return;
+	}
+
+	if ( rightleftbothclear )
+	{
+		if ( cornerdist[FRONT] > MIN_DROP_DIST )
+			whichtrace = 1;
+		else if ( cornerdist[BACK] > MIN_DROP_DIST )
+			whichtrace = 2;
+		else
+			return;
+	}
+	
+	switch ( whichtrace )
+	{//check for stuck
+	case 1:
+		VectorMA( NPC->currentOrigin, NPC->maxs[0], forward, endpos );
+		gi.trace( &movetrace, NPC->currentOrigin, NPC->mins, NPC->maxs, endpos, NPC->s.number, MASK_MONSTERSOLID );
+		if ( movetrace.allsolid || movetrace.startsolid || movetrace.fraction < 1.0 )
+			if ( canmove( movetrace.ent ) )
+				whichtrace = -1;
+			else
+				whichtrace = 0;
+		break;
+	case 2:
+		VectorMA( NPC->currentOrigin, -NPC->maxs[0], forward, endpos );
+		gi.trace( &movetrace, NPC->currentOrigin, NPC->mins, NPC->maxs, endpos, NPC->s.number, MASK_MONSTERSOLID );
+		if ( movetrace.allsolid || movetrace.startsolid || movetrace.fraction < 1.0 )
+			if ( canmove( movetrace.ent ) )
+				whichtrace = -1;
+			else
+				whichtrace = 0;
+		break;
+	case 3:
+		VectorMA( NPC->currentOrigin, NPC->maxs[0], right, endpos );
+		gi.trace( &movetrace, NPC->currentOrigin, NPC->mins, NPC->maxs, endpos, NPC->s.number, MASK_MONSTERSOLID );
+		if ( movetrace.allsolid || movetrace.startsolid || movetrace.fraction < 1.0 )
+			if ( canmove( movetrace.ent ) )
+				whichtrace = -1;
+			else
+				whichtrace = 0;
+		break;
+	case 4:
+		VectorMA( NPC->currentOrigin, -NPC->maxs[0], right, endpos );
+		gi.trace( &movetrace, NPC->currentOrigin, NPC->mins, NPC->maxs, endpos, NPC->s.number, MASK_MONSTERSOLID );
+		if (movetrace.allsolid || movetrace.startsolid || movetrace.fraction < 1.0 )
+			if ( canmove( movetrace.ent ) )
+				whichtrace = -1;
+			else
+				whichtrace = 0;
+		break;
+	}
+	
+	switch ( whichtrace )
+	{
+	case 1:
+		VectorMA( NPC->client->ps.velocity, 200, forward, NPC->client->ps.velocity );
+		if ( trace1.fraction >= 0.9 )
+		{
+//can't anymore, origin not in center of deathframe!
+//			NPC->avelocity[PITCH] = -300;
+			NPC->client->ps.friction = 1.0;
+		}
+		else
+		{
+			pitch_roll_for_slope( NPC, &trace1.plane.normal );
+			NPC->client->ps.friction = trace1.plane.normal[2] * 0.1;
+		}
+		return;
+		break;
+		
+	case 2:
+		VectorMA( NPC->client->ps.velocity, -200, forward, NPC->client->ps.velocity );
+		if(trace2.fraction >= 0.9)
+		{
+//can't anymore, origin not in center of deathframe!
+//			NPC->avelocity[PITCH] = 300;
+			NPC->client->ps.friction = 1.0;
+		}
+		else
+		{
+			pitch_roll_for_slope( NPC, &trace2.plane.normal );
+			NPC->client->ps.friction = trace2.plane.normal[2] * 0.1;
+		}
+		return;
+		break;
+		
+	case 3:
+		VectorMA( NPC->client->ps.velocity, 200, right, NPC->client->ps.velocity );
+		if ( trace3.fraction >= 0.9 )
+		{
+//can't anymore, origin not in center of deathframe!
+//			NPC->avelocity[ROLL] = -300;
+			NPC->client->ps.friction = 1.0;
+		}
+		else
+		{
+			pitch_roll_for_slope( NPC, &trace3.plane.normal );
+			NPC->client->ps.friction = trace3.plane.normal[2] * 0.1;
+		}
+		return;
+		break;
+		
+	case 4:
+		VectorMA( NPC->client->ps.velocity, -200, right, NPC->client->ps.velocity );
+		if ( trace4.fraction >= 0.9 )
+		{
+//can't anymore, origin not in center of deathframe!
+//			NPC->avelocity[ROLL] = 300;
+			NPC->client->ps.friction = 1.0;
+		}
+		else
+		{
+			pitch_roll_for_slope( NPC, &trace4.plane.normal );
+			NPC->client->ps.friction = trace4.plane.normal[2] * 0.1;
+		}
+		return;
+		break;
+	}
+
+	//on solid ground
+	if ( whichtrace == -1 )
+	{
+		return;
+	}
+	NPC->client->ps.friction = 1.0;
+
+	//VectorClear( NPC->avelocity );
+	pitch_roll_for_slope( NPC );
+
+	//gi.linkentity (NPC);
+}
+*/
+
+/*
+----------------------------------------
+DeadThink
+----------------------------------------
+*/
+static void DeadThink ( void ) 
+{
+	trace_t	trace;
+	//HACKHACKHACKHACKHACK
+	//We should really have a seperate G2 bounding box (seperate from the physics bbox) for G2 collisions only
+	//FIXME: don't ever inflate back up?
+	//GAH!  With Ragdoll, they get stuck in the ceiling
+	float oldMaxs2 = NPC->maxs[2];
+	NPC->maxs[2] = NPC->client->renderInfo.eyePoint[2] - NPC->currentOrigin[2] + 4;
+	if ( NPC->maxs[2] < -8 )
+	{
+		NPC->maxs[2] = -8;
+	}
+	if ( NPC->maxs[2] > oldMaxs2 )
+	{//inflating maxs, make sure we're not inflating into solid
+		gi.trace (&trace, NPC->currentOrigin, NPC->mins, NPC->maxs, NPC->currentOrigin, NPC->s.number, NPC->clipmask );
+		if ( trace.allsolid )
+		{//must be inflating
+			NPC->maxs[2] = oldMaxs2;
+		}
+	}
+	/*
+	{
+		if ( VectorCompare( NPC->client->ps.velocity, vec3_origin ) )
+		{//not flying through the air
+			if ( NPC->mins[0] > -32 )
+			{
+				NPC->mins[0] -= 1;
+				gi.trace (&trace, NPC->currentOrigin, NPC->mins, NPC->maxs, NPC->currentOrigin, NPC->s.number, NPC->clipmask );
+				if ( trace.allsolid )
+				{
+					NPC->mins[0] += 1;
+				}
+			}
+			if ( NPC->maxs[0] < 32 )
+			{
+				NPC->maxs[0] += 1;
+				gi.trace (&trace, NPC->currentOrigin, NPC->mins, NPC->maxs, NPC->currentOrigin, NPC->s.number, NPC->clipmask );
+				if ( trace.allsolid )
+				{
+					NPC->maxs[0] -= 1;
+				}
+			}
+			if ( NPC->mins[1] > -32 )
+			{
+				NPC->mins[1] -= 1;
+				gi.trace (&trace, NPC->currentOrigin, NPC->mins, NPC->maxs, NPC->currentOrigin, NPC->s.number, NPC->clipmask );
+				if ( trace.allsolid )
+				{
+					NPC->mins[1] += 1;
+				}
+			}
+			if ( NPC->maxs[1] < 32 )
+			{
+				NPC->maxs[1] += 1;
+				gi.trace (&trace, NPC->currentOrigin, NPC->mins, NPC->maxs, NPC->currentOrigin, NPC->s.number, NPC->clipmask );
+				if ( trace.allsolid )
+				{
+					NPC->maxs[1] -= 1;
+				}
+			}
+		}
+	}
+	//HACKHACKHACKHACKHACK
+	*/
+
+
+	//FIXME: tilt and fall off of ledges?
+	//NPC_PostDeathThink();
+
+	/*
+	if ( !NPCInfo->timeOfDeath && NPC->client != NULL && NPCInfo != NULL ) 
+	{
+		//haven't finished death anim yet and were NOT given a specific amount of time to wait before removal
+		int				legsAnim	= NPC->client->ps.legsAnim;
+		animation_t		*animations	= knownAnimFileSets[NPC->client->clientInfo.animFileIndex].animations;
+
+		NPC->bounceCount = -1; // This is a cheap hack for optimizing the pointcontents check below
+
+		//ghoul doesn't tell us this anymore
+		//if ( NPC->client->renderInfo.legsFrame == animations[legsAnim].firstFrame + (animations[legsAnim].numFrames - 1) )
+		{
+			//reached the end of the death anim
+			NPCInfo->timeOfDeath = level.time + BodyRemovalPadTime( NPC );
+		}
+	}
+	else
+	*/
+	{
+		//death anim done (or were given a specific amount of time to wait before removal), wait the requisite amount of time them remove
+		if ( level.time >= NPCInfo->timeOfDeath + BodyRemovalPadTime( NPC ) )
+		{
+			if ( NPC->client->ps.eFlags & EF_NODRAW )
+			{
+				if ( !IIcarusInterface::GetIcarus()->IsRunning( NPC->m_iIcarusID ) )
+				{
+					NPC->e_ThinkFunc = thinkF_G_FreeEntity;
+					NPC->nextthink = level.time + FRAMETIME;
+				}
+			}
+			else
+			{
+				// Start the body effect first, then delay 400ms before ditching the corpse
+				NPC_RemoveBodyEffect();
+
+				//FIXME: keep it running through physics somehow?
+				NPC->e_ThinkFunc = thinkF_NPC_RemoveBody;
+				NPC->nextthink = level.time + FRAMETIME/2;
+			//	if ( NPC->client->playerTeam == TEAM_FORGE )
+			//		NPCInfo->timeOfDeath = level.time + FRAMETIME * 8;
+			//	else if ( NPC->client->playerTeam == TEAM_BOTS )
+				class_t	npc_class = NPC->client->NPC_class;
+				// check for droids
+				if ( npc_class == CLASS_SEEKER || npc_class == CLASS_REMOTE || npc_class == CLASS_PROBE || npc_class == CLASS_MOUSE ||
+					 npc_class == CLASS_GONK || npc_class == CLASS_R2D2 || npc_class == CLASS_R5D2 ||
+					 npc_class == CLASS_MARK2 || npc_class == CLASS_SENTRY )//npc_class == CLASS_PROTOCOL ||
+				{
+					NPC->client->ps.eFlags |= EF_NODRAW;
+					NPCInfo->timeOfDeath = level.time + FRAMETIME * 8;
+				}
+				else
+				{
+					NPCInfo->timeOfDeath = level.time + FRAMETIME * 4;
+				}
+			}
+			return;
+		}
+	}
+
+	// If the player is on the ground and the resting position contents haven't been set yet...(BounceCount tracks the contents)
+	if ( NPC->bounceCount < 0 && NPC->s.groundEntityNum >= 0 )
+	{
+		// if client is in a nodrop area, make him/her nodraw
+		int contents = NPC->bounceCount = gi.pointcontents( NPC->currentOrigin, -1 );
+
+		if ( ( contents & CONTENTS_NODROP ) ) 
+		{
+			NPC->client->ps.eFlags |= EF_NODRAW;
+		}
+	}
+
+	CorpsePhysics( NPC );
+}
+
+/*
+===============
+SetNPCGlobals
+
+local function to set globals used throughout the AI code
+===============
+*/
+void SetNPCGlobals( gentity_t *ent ) 
+{
+	NPC = ent;
+	NPCInfo = ent->NPC;
+	client = ent->client;
+	memset( &ucmd, 0, sizeof( usercmd_t ) );
+}
+
+gentity_t	*_saved_NPC;
+gNPC_t		*_saved_NPCInfo;
+gclient_t	*_saved_client;
+usercmd_t	_saved_ucmd;
+
+void SaveNPCGlobals() 
+{
+	_saved_NPC = NPC;
+	_saved_NPCInfo = NPCInfo;
+	_saved_client = client;
+	memcpy( &_saved_ucmd, &ucmd, sizeof( usercmd_t ) );
+}
+
+void RestoreNPCGlobals() 
+{
+	NPC = _saved_NPC;
+	NPCInfo = _saved_NPCInfo;
+	client = _saved_client;
+	memcpy( &ucmd, &_saved_ucmd, sizeof( usercmd_t ) );
+}
+
+//We MUST do this, other funcs were using NPC illegally when "self" wasn't the global NPC
+void ClearNPCGlobals( void ) 
+{
+	NPC = NULL;
+	NPCInfo = NULL;
+	client = NULL;
+}
+//===============
+
+extern	qboolean	showBBoxes;
+vec3_t NPCDEBUG_RED = {1.0, 0.0, 0.0};
+vec3_t NPCDEBUG_GREEN = {0.0, 1.0, 0.0};
+vec3_t NPCDEBUG_BLUE = {0.0, 0.0, 1.0};
+vec3_t NPCDEBUG_LIGHT_BLUE = {0.3f, 0.7f, 1.0};
+extern void CG_Cube( vec3_t mins, vec3_t maxs, vec3_t color, float alpha );
+extern void CG_Line( vec3_t start, vec3_t end, vec3_t color, float alpha );
+extern void CG_Cylinder( vec3_t start, vec3_t end, float radius, vec3_t color );
+
+void NPC_ShowDebugInfo (void)
+{
+	if ( showBBoxes )
+	{
+		gentity_t	*found = NULL;
+		vec3_t		mins, maxs;
+
+		//do player, too
+		VectorAdd( player->currentOrigin, player->mins, mins );
+		VectorAdd( player->currentOrigin, player->maxs, maxs );
+		CG_Cube( mins, maxs, NPCDEBUG_RED, 0.25 );
+		//do NPCs
+		while( (found = G_Find( found, FOFS(classname), "NPC" ) ) != NULL )
+		{
+			if ( gi.inPVS( found->currentOrigin, g_entities[0].currentOrigin ) )
+			{
+				VectorAdd( found->currentOrigin, found->mins, mins );
+				VectorAdd( found->currentOrigin, found->maxs, maxs );
+				CG_Cube( mins, maxs, NPCDEBUG_RED, 0.25 );
+			}
+		}
+	}
+}
+
+void NPC_ApplyScriptFlags (void)
+{
+	if ( NPCInfo->scriptFlags & SCF_CROUCHED )
+	{
+		if ( NPCInfo->charmedTime > level.time && (ucmd.forwardmove || ucmd.rightmove) )
+		{//ugh, if charmed and moving, ignore the crouched command
+		}
+		else
+		{
+			ucmd.upmove = -127;
+		}
+	}
+
+	if(NPCInfo->scriptFlags & SCF_RUNNING)
+	{
+		ucmd.buttons &= ~BUTTON_WALKING;
+	}
+	else if(NPCInfo->scriptFlags & SCF_WALKING)
+	{
+		if ( NPCInfo->charmedTime > level.time && (ucmd.forwardmove || ucmd.rightmove) )
+		{//ugh, if charmed and moving, ignore the walking command
+		}
+		else
+		{
+			ucmd.buttons |= BUTTON_WALKING;
+		}
+	}
+/*
+	if(NPCInfo->scriptFlags & SCF_CAREFUL)
+	{
+		ucmd.buttons |= BUTTON_CAREFUL;
+	}
+*/
+	if(NPCInfo->scriptFlags & SCF_LEAN_RIGHT)
+	{
+		ucmd.buttons |= BUTTON_USE;
+		ucmd.rightmove = 127;
+		ucmd.forwardmove = 0;
+		ucmd.upmove = 0;
+	}
+	else if(NPCInfo->scriptFlags & SCF_LEAN_LEFT)
+	{
+		ucmd.buttons |= BUTTON_USE;
+		ucmd.rightmove = -127;
+		ucmd.forwardmove = 0;
+		ucmd.upmove = 0;
+	}
+
+	if ( (NPCInfo->scriptFlags & SCF_ALT_FIRE) && (ucmd.buttons & BUTTON_ATTACK) )
+	{//Use altfire instead
+		ucmd.buttons |= BUTTON_ALT_ATTACK;
+	}
+
+	// only removes NPC when it's safe too (Player is out of PVS)
+	if( NPCInfo->scriptFlags & SCF_SAFE_REMOVE )
+	{
+		// take from BSRemove
+		if( !gi.inPVS( NPC->currentOrigin, g_entities[0].currentOrigin ) )//FIXME: use cg.vieworg?
+		{
+			G_UseTargets2( NPC, NPC, NPC->target3 );
+			NPC->s.eFlags |= EF_NODRAW;
+			NPC->svFlags &= ~SVF_NPC;
+			NPC->s.eType = ET_INVISIBLE;
+			NPC->contents = 0;
+			NPC->health = 0;
+			NPC->targetname = NULL;
+
+			//Disappear in half a second
+			NPC->e_ThinkFunc = thinkF_G_FreeEntity;
+			NPC->nextthink = level.time + FRAMETIME;
+		}//FIXME: else allow for out of FOV???
+
+	}
+}
+
+
+extern qboolean JET_Flying( gentity_t *self );
+extern void JET_FlyStart( gentity_t *self );
+extern void JET_FlyStop( gentity_t *self );
+
+void NPC_HandleAIFlags (void)
+{
+	// Update Guys With Jet Packs
+	//----------------------------
+	if (NPCInfo->scriptFlags & SCF_FLY_WITH_JET)
+	{
+		bool	ShouldFly  = !!(NPCInfo->aiFlags & NPCAI_FLY);
+		bool	IsFlying   = !!(JET_Flying(NPC));
+		bool	IsInTheAir = (NPC->client->ps.groundEntityNum==ENTITYNUM_NONE);
+
+		if (IsFlying)
+		{
+			// Don't Stop Flying Until Near The Ground
+			//-----------------------------------------
+			if (IsInTheAir)
+			{
+				vec3_t	ground;
+				trace_t	trace;
+				VectorCopy(NPC->currentOrigin, ground);
+				ground[2] -= 60.0f;
+                gi.trace(&trace, NPC->currentOrigin, 0, 0, ground, NPC->s.number, NPC->clipmask);
+
+				IsInTheAir	= (!trace.allsolid && !trace.startsolid && trace.fraction>0.9f);
+			}
+
+			// If Flying, Remember The Last Time
+			//-----------------------------------
+			if (IsInTheAir)
+			{
+				NPC->lastInAirTime = level.time;
+				ShouldFly = true;
+			}
+
+
+			// Auto Turn Off Jet Pack After 1 Second On The Ground
+			//-----------------------------------------------------
+			else if (!ShouldFly && (level.time - NPC->lastInAirTime)>3000)
+			{
+				NPCInfo->aiFlags &= ~NPCAI_FLY;
+			}
+		}
+
+
+		// If We Should Be Flying And Are Not, Start Er Up
+		//-------------------------------------------------
+		if (ShouldFly && !IsFlying)
+		{
+			JET_FlyStart(NPC);				// EVENTUALLY, Remove All Other Calls
+		}
+
+		// Otherwise, If Needed, Shut It Off
+		//-----------------------------------
+		else if (!ShouldFly && IsFlying)
+		{
+			JET_FlyStop(NPC);				// EVENTUALLY, Remove All Other Calls
+		}
+	}
+
+	//FIXME: make these flags checks a function call like NPC_CheckAIFlagsAndTimers
+	if ( NPCInfo->aiFlags & NPCAI_LOST )
+	{//Print that you need help!
+		//FIXME: shouldn't remove this just yet if cg_draw needs it
+		NPCInfo->aiFlags &= ~NPCAI_LOST;
+		
+		/*
+		if ( showWaypoints )
+		{
+			Quake3Game()->DebugPrint(WL_WARNING, "%s can't navigate to target %s (my wp: %d, goal wp: %d)\n", NPC->targetname, NPCInfo->goalEntity->targetname, NPC->waypoint, NPCInfo->goalEntity->waypoint );
+		}
+		*/
+
+		if ( NPCInfo->goalEntity && NPCInfo->goalEntity == NPC->enemy )
+		{//We can't nav to our enemy
+			//Drop enemy and see if we should search for him
+			NPC_LostEnemyDecideChase();
+		}
+	}
+
+	//been told to play a victory sound after a delay
+	if ( NPCInfo->greetingDebounceTime && NPCInfo->greetingDebounceTime < level.time )
+	{
+		G_AddVoiceEvent( NPC, Q_irand(EV_VICTORY1, EV_VICTORY3), Q_irand( 2000, 4000 ) );
+		NPCInfo->greetingDebounceTime = 0;
+	}
+
+	if ( NPCInfo->ffireCount > 0 )
+	{
+		if ( NPCInfo->ffireFadeDebounce < level.time )
+		{
+			NPCInfo->ffireCount--;
+			//Com_Printf( "drop: %d < %d\n", NPCInfo->ffireCount, 3+((2-g_spskill->integer)*2) );
+			NPCInfo->ffireFadeDebounce = level.time + 3000;
+		}
+	}
+}
+
+void NPC_AvoidWallsAndCliffs (void)
+{
+/*
+	vec3_t	forward, right, testPos, angles, mins;
+	trace_t	trace;
+	float	fwdDist, rtDist;
+	//FIXME: set things like this forward dir once at the beginning
+	//of a frame instead of over and over again
+	if ( NPCInfo->aiFlags & NPCAI_NO_COLL_AVOID )
+	{
+		return;
+	}
+
+	if ( ucmd.upmove > 0 || NPC->client->ps.groundEntityNum == ENTITYNUM_NONE )
+	{//Going to jump or in the air
+		return;
+	}
+
+	if ( !ucmd.forwardmove && !ucmd.rightmove )
+	{
+		return;
+	}
+
+	if ( fabs( AngleDelta( NPC->currentAngles[YAW], NPCInfo->desiredYaw ) ) < 5.0 )//!ucmd.angles[YAW] )
+	{//Not turning much, don't do this
+		//NOTE: Should this not happen only if you're not turning AT ALL?
+		//	You could be turning slowly but moving fast, so that would
+		//	still let you walk right off a cliff...
+		//NOTE: Or maybe it is a good idea to ALWAYS do this, regardless
+		//	of whether ot not we're turning?  But why would we be walking
+		//  straight into a wall or off	a cliff unless we really wanted to?
+		return;
+	}
+
+	VectorCopy( NPC->mins, mins );
+	mins[2] += STEPSIZE;
+	angles[YAW] = NPC->client->ps.viewangles[YAW];//Add ucmd.angles[YAW]?
+	AngleVectors( angles, forward, right, NULL );
+	fwdDist = ((float)ucmd.forwardmove)/16.0f;
+	rtDist = ((float)ucmd.rightmove)/16.0f;
+	VectorMA( NPC->currentOrigin, fwdDist, forward, testPos );
+	VectorMA( testPos, rtDist, right, testPos );
+	gi.trace( &trace, NPC->currentOrigin, mins, NPC->maxs, testPos, NPC->s.number, NPC->clipmask );
+	if ( trace.allsolid || trace.startsolid || trace.fraction < 1.0 )
+	{//Going to bump into something, don't move, just turn
+		ucmd.forwardmove = 0;
+		ucmd.rightmove = 0;
+		return;
+	}
+
+	VectorCopy(trace.endpos, testPos);
+	testPos[2] -= 128;
+
+	gi.trace( &trace, trace.endpos, mins, NPC->maxs, testPos, NPC->s.number, NPC->clipmask );
+	if ( trace.allsolid || trace.startsolid || trace.fraction < 1.0 )
+	{//Not going off a cliff
+		return;
+	}
+
+	//going to fall at least 128, don't move, just turn... is this bad, though?  What if we want them to drop off?
+	ucmd.forwardmove = 0;
+	ucmd.rightmove = 0;
+	return;
+*/
+}
+
+void NPC_CheckAttackScript(void)
+{
+	if(!(ucmd.buttons & BUTTON_ATTACK))
+	{
+		return;
+	}
+
+	G_ActivateBehavior(NPC, BSET_ATTACK);
+}
+
+float NPC_MaxDistSquaredForWeapon (void);
+void NPC_CheckAttackHold(void)
+{
+	vec3_t		vec;
+
+	// If they don't have an enemy they shouldn't hold their attack anim.
+	if ( !NPC->enemy )
+	{
+		NPCInfo->attackHoldTime = 0;
+		return;
+	}
+
+	//FIXME: need to tie this into AI somehow?
+	VectorSubtract(NPC->enemy->currentOrigin, NPC->currentOrigin, vec);
+	if( VectorLengthSquared(vec) > NPC_MaxDistSquaredForWeapon() )
+	{
+		NPCInfo->attackHoldTime = 0;
+	}
+	else if( NPCInfo->attackHoldTime && NPCInfo->attackHoldTime > level.time )
+	{
+		ucmd.buttons |= BUTTON_ATTACK;
+	}
+	else if ( ( NPCInfo->attackHold ) && ( ucmd.buttons & BUTTON_ATTACK ) )
+	{
+		NPCInfo->attackHoldTime = level.time + NPCInfo->attackHold;
+	}
+	else
+	{
+		NPCInfo->attackHoldTime = 0;
+	}
+}
+
+/*
+void NPC_KeepCurrentFacing(void)
+
+Fills in a default ucmd to keep current angles facing
+*/
+void NPC_KeepCurrentFacing(void)
+{
+	if(!ucmd.angles[YAW])
+	{
+		ucmd.angles[YAW] = ANGLE2SHORT( client->ps.viewangles[YAW] ) - client->ps.delta_angles[YAW];
+	}
+
+	if(!ucmd.angles[PITCH])
+	{
+		ucmd.angles[PITCH] = ANGLE2SHORT( client->ps.viewangles[PITCH] ) - client->ps.delta_angles[PITCH];
+	}
+}
+
+/*
+-------------------------
+NPC_BehaviorSet_Charmed
+-------------------------
+*/
+
+void NPC_BehaviorSet_Charmed( int bState )
+{
+	switch( bState )
+	{
+	case BS_FOLLOW_LEADER://# 40: Follow your leader and shoot any enemies you come across
+		NPC_BSFollowLeader();
+		break;
+	case BS_REMOVE:
+		NPC_BSRemove();
+		break;
+	case BS_SEARCH:			//# 43: Using current waypoint as a base, search the immediate branches of waypoints for enemies
+		NPC_BSSearch();
+		break;
+	case BS_WANDER:			//# 46: Wander down random waypoint paths
+		NPC_BSWander();
+		break;
+	case BS_FLEE:
+		NPC_BSFlee();
+		break;
+	default:
+	case BS_DEFAULT://whatever
+		NPC_BSDefault();
+		break;
+	}
+}
+/*
+-------------------------
+NPC_BehaviorSet_Default
+-------------------------
+*/
+
+void NPC_BehaviorSet_Default( int bState )
+{
+	switch( bState )
+	{
+	case BS_ADVANCE_FIGHT://head toward captureGoal, shoot anything that gets in the way
+		NPC_BSAdvanceFight ();
+		break;
+	case BS_SLEEP://Follow a path, looking for enemies
+		NPC_BSSleep ();
+		break;
+	case BS_FOLLOW_LEADER://# 40: Follow your leader and shoot any enemies you come across
+		NPC_BSFollowLeader();
+		break;
+	case BS_JUMP:			//41: Face navgoal and jump to it.
+		NPC_BSJump();
+		break;
+	case BS_REMOVE:
+		NPC_BSRemove();
+		break;
+	case BS_SEARCH:			//# 43: Using current waypoint as a base, search the immediate branches of waypoints for enemies
+		NPC_BSSearch();
+		break;
+	case BS_NOCLIP:
+		NPC_BSNoClip();
+		break;
+	case BS_WANDER:			//# 46: Wander down random waypoint paths
+		NPC_BSWander();
+		break;
+	case BS_FLEE:
+		NPC_BSFlee();
+		break;
+	case BS_WAIT:
+		NPC_BSWait();
+		break;
+	case BS_CINEMATIC:
+		NPC_BSCinematic();
+		break;
+	default:
+	case BS_DEFAULT://whatever
+		NPC_BSDefault();
+		break;
+	}
+}
+
+/*
+-------------------------
+NPC_BehaviorSet_Interrogator
+-------------------------
+*/
+void NPC_BehaviorSet_Interrogator( int bState )
+{
+	switch( bState )
+	{
+	case BS_STAND_GUARD:
+	case BS_PATROL:
+	case BS_STAND_AND_SHOOT:
+	case BS_HUNT_AND_KILL:
+	case BS_DEFAULT:
+		NPC_BSInterrogator_Default();
+		break;
+	default:
+		NPC_BehaviorSet_Default( bState );
+		break;
+	}
+}
+
+void NPC_BSImperialProbe_Attack( void );
+void NPC_BSImperialProbe_Patrol( void );
+void NPC_BSImperialProbe_Wait(void);
+
+/*
+-------------------------
+NPC_BehaviorSet_ImperialProbe
+-------------------------
+*/
+void NPC_BehaviorSet_ImperialProbe( int bState )
+{
+	switch( bState )
+	{
+	case BS_STAND_GUARD:
+	case BS_PATROL:
+	case BS_STAND_AND_SHOOT:
+	case BS_HUNT_AND_KILL:
+	case BS_DEFAULT:
+		NPC_BSImperialProbe_Default();
+		break;
+	default:
+		NPC_BehaviorSet_Default( bState );
+		break;
+	}
+}
+
+
+void NPC_BSSeeker_Default( void );
+
+/*
+-------------------------
+NPC_BehaviorSet_Seeker
+-------------------------
+*/
+void NPC_BehaviorSet_Seeker( int bState )
+{
+	switch( bState )
+	{
+	case BS_STAND_GUARD:
+	case BS_PATROL:
+	case BS_STAND_AND_SHOOT:
+	case BS_HUNT_AND_KILL:
+	case BS_DEFAULT:
+	default:
+		NPC_BSSeeker_Default();
+		break;
+	}
+}
+
+void NPC_BSRemote_Default( void );
+
+/*
+-------------------------
+NPC_BehaviorSet_Remote
+-------------------------
+*/
+void NPC_BehaviorSet_Remote( int bState )
+{
+	switch( bState )
+	{
+	case BS_STAND_GUARD:
+	case BS_PATROL:
+	case BS_STAND_AND_SHOOT:
+	case BS_HUNT_AND_KILL:
+	case BS_DEFAULT:
+		NPC_BSRemote_Default();
+		break; 
+	default:
+		NPC_BehaviorSet_Default( bState );
+		break;
+	}
+}
+
+void NPC_BSSentry_Default( void );
+
+/*
+-------------------------
+NPC_BehaviorSet_Sentry
+-------------------------
+*/
+void NPC_BehaviorSet_Sentry( int bState )
+{
+	switch( bState )
+	{
+	case BS_STAND_GUARD:
+	case BS_PATROL:
+	case BS_STAND_AND_SHOOT:
+	case BS_HUNT_AND_KILL:
+	case BS_DEFAULT:
+		NPC_BSSentry_Default();
+		break; 
+	default:
+		NPC_BehaviorSet_Default( bState );
+		break;
+	}
+}
+
+/*
+-------------------------
+NPC_BehaviorSet_Grenadier
+-------------------------
+*/
+void NPC_BehaviorSet_Grenadier( int bState )
+{
+	switch( bState )
+	{
+	case BS_STAND_GUARD:
+	case BS_PATROL:
+	case BS_STAND_AND_SHOOT:
+	case BS_HUNT_AND_KILL:
+	case BS_DEFAULT:
+		NPC_BSGrenadier_Default();
+		break;
+
+	default:
+		NPC_BehaviorSet_Default( bState );
+		break;
+	}
+}
+
+/*
+-------------------------
+NPC_BehaviorSet_Tusken
+-------------------------
+*/
+void NPC_BehaviorSet_Tusken( int bState )
+{
+	switch( bState )
+	{
+	case BS_STAND_GUARD:
+	case BS_PATROL:
+	case BS_STAND_AND_SHOOT:
+	case BS_HUNT_AND_KILL:
+	case BS_DEFAULT:
+		NPC_BSTusken_Default();
+		break;
+
+	default:
+		NPC_BehaviorSet_Default( bState );
+		break;
+	}
+}
+
+/*
+-------------------------
+NPC_BehaviorSet_Sniper
+-------------------------
+*/
+void NPC_BehaviorSet_Sniper( int bState )
+{
+	switch( bState )
+	{
+	case BS_STAND_GUARD:
+	case BS_PATROL:
+	case BS_STAND_AND_SHOOT:
+	case BS_HUNT_AND_KILL:
+	case BS_DEFAULT:
+		NPC_BSSniper_Default();
+		break;
+
+	default:
+		NPC_BehaviorSet_Default( bState );
+		break;
+	}
+}
+/*
+-------------------------
+NPC_BehaviorSet_Stormtrooper
+-------------------------
+*/
+
+void NPC_BehaviorSet_Stormtrooper( int bState )
+{
+	switch( bState )
+	{
+	case BS_STAND_GUARD:
+	case BS_PATROL:
+	case BS_STAND_AND_SHOOT:
+	case BS_HUNT_AND_KILL:
+	case BS_DEFAULT:
+		NPC_BSST_Default();
+		break;
+
+	case BS_INVESTIGATE:
+		NPC_BSST_Investigate();
+		break;
+
+	case BS_SLEEP:
+		NPC_BSST_Sleep();
+		break;
+
+	default:
+		NPC_BehaviorSet_Default( bState );
+		break;
+	}
+}
+
+/*
+-------------------------
+NPC_BehaviorSet_Jedi
+-------------------------
+*/
+
+void NPC_BehaviorSet_Jedi( int bState )
+{
+	switch( bState )
+	{
+	case BS_STAND_GUARD:
+	case BS_PATROL:
+	case BS_STAND_AND_SHOOT:
+	case BS_HUNT_AND_KILL:
+	case BS_INVESTIGATE://WTF???!!
+	case BS_DEFAULT:
+		NPC_BSJedi_Default();
+		break;
+
+	case BS_FOLLOW_LEADER:
+		NPC_BSJedi_FollowLeader();
+		break;
+
+	default:
+		NPC_BehaviorSet_Default( bState );
+		break;
+	}
+}
+
+qboolean G_JediInNormalAI( gentity_t *ent )
+{//NOTE: should match above func's switch!
+	//check our bState
+	bState_t bState = G_CurrentBState( ent->NPC );
+	switch ( bState )
+	{
+	case BS_STAND_GUARD:
+	case BS_PATROL:
+	case BS_STAND_AND_SHOOT:
+	case BS_HUNT_AND_KILL:
+	case BS_INVESTIGATE:
+	case BS_DEFAULT:
+	case BS_FOLLOW_LEADER:
+		return qtrue;
+		break;
+	}
+	return qfalse;
+}
+
+/*
+-------------------------
+NPC_BehaviorSet_Droid
+-------------------------
+*/
+void NPC_BehaviorSet_Droid( int bState )
+{
+	switch( bState )
+	{
+	case BS_DEFAULT:
+	case BS_STAND_GUARD:
+	case BS_PATROL:
+		NPC_BSDroid_Default();
+		break;
+	default:
+		NPC_BehaviorSet_Default( bState );
+		break;
+	}
+}
+
+/*
+-------------------------
+NPC_BehaviorSet_Mark1
+-------------------------
+*/
+void NPC_BehaviorSet_Mark1( int bState )
+{
+	switch( bState )
+	{
+	case BS_DEFAULT:
+	case BS_STAND_GUARD:
+	case BS_PATROL:
+		NPC_BSMark1_Default();
+		break;
+	default:
+		NPC_BehaviorSet_Default( bState );
+		break;
+	}
+}
+
+/*
+-------------------------
+NPC_BehaviorSet_Mark2
+-------------------------
+*/
+void NPC_BehaviorSet_Mark2( int bState )
+{
+	switch( bState )
+	{
+	case BS_DEFAULT:
+	case BS_PATROL:
+	case BS_STAND_AND_SHOOT:
+	case BS_HUNT_AND_KILL:
+		NPC_BSMark2_Default();
+		break;
+	default:
+		NPC_BehaviorSet_Default( bState );
+		break;
+	}
+}
+
+/*
+-------------------------
+NPC_BehaviorSet_ATST
+-------------------------
+*/
+void NPC_BehaviorSet_ATST( int bState )
+{
+	switch( bState )
+	{
+	case BS_DEFAULT:
+	case BS_PATROL:
+	case BS_STAND_AND_SHOOT:
+	case BS_HUNT_AND_KILL:
+		NPC_BSATST_Default();
+		break;
+	default:
+		NPC_BehaviorSet_Default( bState );
+		break;
+	}
+}
+
+/*
+-------------------------
+NPC_BehaviorSet_MineMonster
+-------------------------
+*/
+void NPC_BehaviorSet_MineMonster( int bState )
+{
+	switch( bState )
+	{
+	case BS_STAND_GUARD:
+	case BS_PATROL:
+	case BS_STAND_AND_SHOOT:
+	case BS_HUNT_AND_KILL:
+	case BS_DEFAULT:
+		NPC_BSMineMonster_Default();
+		break;
+	default:
+		NPC_BehaviorSet_Default( bState );
+		break;
+	}
+}
+
+/*
+-------------------------
+NPC_BehaviorSet_Howler
+-------------------------
+*/
+void NPC_BehaviorSet_Howler( int bState )
+{
+	switch( bState )
+	{
+	case BS_STAND_GUARD:
+	case BS_PATROL:
+	case BS_STAND_AND_SHOOT:
+	case BS_HUNT_AND_KILL:
+	case BS_DEFAULT:
+		NPC_BSHowler_Default();
+		break;
+	default:
+		NPC_BehaviorSet_Default( bState );
+		break;
+	}
+}
+
+/*
+-------------------------
+NPC_BehaviorSet_Rancor
+-------------------------
+*/
+void NPC_BehaviorSet_Rancor( int bState )
+{
+	switch( bState )
+	{
+	case BS_STAND_GUARD:
+	case BS_PATROL:
+	case BS_STAND_AND_SHOOT:
+	case BS_HUNT_AND_KILL:
+	case BS_DEFAULT:
+		NPC_BSRancor_Default();
+		break;
+	default:
+		NPC_BehaviorSet_Default( bState );
+		break;
+	}
+}
+
+/*
+-------------------------
+NPC_BehaviorSet_Wampa
+-------------------------
+*/
+void NPC_BehaviorSet_Wampa( int bState )
+{
+	switch( bState )
+	{
+	case BS_STAND_GUARD:
+	case BS_PATROL:
+	case BS_STAND_AND_SHOOT:
+	case BS_HUNT_AND_KILL:
+	case BS_DEFAULT:
+		NPC_BSWampa_Default();
+		break;
+	default:
+		NPC_BehaviorSet_Default( bState );
+		break;
+	}
+}
+
+/*
+-------------------------
+NPC_BehaviorSet_SandCreature
+-------------------------
+*/
+void NPC_BehaviorSet_SandCreature( int bState )
+{
+	switch( bState )
+	{
+	case BS_STAND_GUARD:
+	case BS_PATROL:
+	case BS_STAND_AND_SHOOT:
+	case BS_HUNT_AND_KILL:
+	case BS_DEFAULT:
+		NPC_BSSandCreature_Default();
+		break;
+	default:
+		NPC_BehaviorSet_Default( bState );
+		break;
+	}
+}
+
+/*
+-------------------------
+NPC_BehaviorSet_Droid
+-------------------------
+*/
+// Added 01/21/03 by AReis.
+void NPC_BehaviorSet_Animal( int bState )
+{
+	switch( bState )
+	{
+	case BS_DEFAULT:
+	case BS_STAND_GUARD:
+	case BS_PATROL:
+		NPC_BSAnimal_Default();
+
+		//NPC_BSDroid_Default();
+		break;
+	default:
+		NPC_BehaviorSet_Default( bState );
+		break;
+	}
+}
+
+/*
+-------------------------
+NPC_RunBehavior
+-------------------------
+*/
+extern void NPC_BSEmplaced( void );
+extern qboolean NPC_CheckSurrender( void );
+extern void NPC_BSRT_Default( void );
+extern void NPC_BSCivilian_Default( int bState );
+extern void NPC_BSSD_Default( void );
+extern void NPC_BehaviorSet_Trooper( int bState );
+extern bool NPC_IsTrooper( gentity_t *ent );
+extern bool Pilot_MasterUpdate();
+
+void NPC_RunBehavior( int team, int bState )
+{
+	qboolean dontSetAim = qfalse;
+
+	//
+	if ( bState == BS_CINEMATIC )
+	{
+		NPC_BSCinematic();
+	}
+	else if ( (NPCInfo->scriptFlags&SCF_PILOT) && Pilot_MasterUpdate())
+	{
+		return;
+	}
+	else if ( NPC_JumpBackingUp() )
+	{
+		return;
+	}
+	else if ( !TIMER_Done(NPC, "DEMP2_StunTime"))
+	{
+		NPC_UpdateAngles(qtrue, qtrue);
+		return;
+	}
+	else if ( NPC->client->ps.weapon == WP_EMPLACED_GUN )
+	{
+		NPC_BSEmplaced();
+		G_CheckCharmed( NPC );
+		return;
+	}
+	else if ( NPC->client->NPC_class == CLASS_HOWLER )
+	{
+		NPC_BehaviorSet_Howler( bState );
+		return;
+	}
+	else if ( Jedi_CultistDestroyer( NPC ) )
+	{
+		NPC_BSJedi_Default();
+		dontSetAim = qtrue;
+	}
+	else if ( NPC->client->NPC_class == CLASS_SABER_DROID )
+	{//saber droid
+		NPC_BSSD_Default();
+	}
+	else if ( NPC->client->ps.weapon == WP_SABER )
+	{//jedi
+		NPC_BehaviorSet_Jedi( bState );
+		dontSetAim = qtrue;
+	}
+	else if ( NPC->client->NPC_class == CLASS_REBORN && NPC->client->ps.weapon == WP_MELEE )
+	{//force-only reborn
+		NPC_BehaviorSet_Jedi( bState );
+		dontSetAim = qtrue;
+	}
+	else if ( NPC->client->NPC_class == CLASS_BOBAFETT )
+	{
+		Boba_Update();
+		if (NPCInfo->surrenderTime)
+		{
+			Boba_Flee();
+		}
+		else
+		{
+			if (!Boba_Tactics())
+			{
+				if ( Boba_Flying( NPC ) )
+				{
+					NPC_BehaviorSet_Seeker(bState);
+				}
+				else
+				{
+					NPC_BehaviorSet_Jedi( bState );
+				}
+			}
+		}
+		dontSetAim = qtrue;
+	}
+	else if ( NPC->client->NPC_class == CLASS_ROCKETTROOPER )
+	{//bounty hunter
+		if ( RT_Flying( NPC ) || NPC->enemy != NULL )
+		{
+			NPC_BSRT_Default();
+		}
+		else
+		{
+			NPC_BehaviorSet_Stormtrooper( bState );
+		}
+		G_CheckCharmed( NPC );
+		dontSetAim = qtrue;
+	}
+	else if ( NPC->client->NPC_class == CLASS_RANCOR )
+	{
+		NPC_BehaviorSet_Rancor( bState );
+	}
+	else if ( NPC->client->NPC_class == CLASS_SAND_CREATURE )
+	{
+		NPC_BehaviorSet_SandCreature( bState );
+	}
+	else if ( NPC->client->NPC_class == CLASS_WAMPA )
+	{
+		NPC_BehaviorSet_Wampa( bState );
+		G_CheckCharmed( NPC );
+	}
+	else if ( NPCInfo->scriptFlags & SCF_FORCED_MARCH )
+	{//being forced to march
+		NPC_BSDefault();
+	}
+	else if ( NPC->client->ps.weapon == WP_TUSKEN_RIFLE )
+	{
+		if ( (NPCInfo->scriptFlags & SCF_ALT_FIRE) )
+		{
+			NPC_BehaviorSet_Sniper( bState );
+			G_CheckCharmed( NPC );
+			return;
+		}
+		else
+		{
+			NPC_BehaviorSet_Tusken( bState );
+			G_CheckCharmed( NPC );
+			return;
+		}
+	}
+	else if ( NPC->client->ps.weapon == WP_TUSKEN_STAFF )
+	{
+		NPC_BehaviorSet_Tusken( bState );
+		G_CheckCharmed( NPC );
+		return;
+	}
+	else if ( NPC->client->ps.weapon == WP_NOGHRI_STICK )
+	{
+		NPC_BehaviorSet_Stormtrooper( bState );
+		G_CheckCharmed( NPC );
+	}
+	else
+	{
+		switch( team )
+		{
+		
+	//	case TEAM_SCAVENGERS:
+	//	case TEAM_IMPERIAL:
+	//	case TEAM_KLINGON:
+	//	case TEAM_HIROGEN:
+	//	case TEAM_MALON:
+		// not sure if TEAM_ENEMY is appropriate here, I think I should be using NPC_class to check for behavior - dmv
+		case TEAM_ENEMY:
+			// special cases for enemy droids
+			switch( NPC->client->NPC_class)
+			{
+			case CLASS_ATST:
+				NPC_BehaviorSet_ATST( bState );
+				return;
+			case CLASS_PROBE:
+				NPC_BehaviorSet_ImperialProbe(bState);
+				return;
+			case CLASS_REMOTE:
+				NPC_BehaviorSet_Remote( bState );
+				return;
+			case CLASS_SENTRY:
+				NPC_BehaviorSet_Sentry(bState);
+				return;
+			case CLASS_INTERROGATOR:
+				NPC_BehaviorSet_Interrogator( bState );
+				return;
+			case CLASS_MINEMONSTER:
+				NPC_BehaviorSet_MineMonster( bState );
+				return;
+			case CLASS_HOWLER:
+				NPC_BehaviorSet_Howler( bState );
+				return;
+			case CLASS_RANCOR:
+				NPC_BehaviorSet_Rancor( bState );
+				return;
+			case CLASS_SAND_CREATURE:
+				NPC_BehaviorSet_SandCreature( bState );
+				return;
+			case CLASS_MARK1:
+				NPC_BehaviorSet_Mark1( bState );
+				return;
+			case CLASS_MARK2:
+				NPC_BehaviorSet_Mark2( bState );
+				return;
+			}
+
+
+			if (NPC->client->NPC_class==CLASS_ASSASSIN_DROID)
+			{
+				BubbleShield_Update();
+			}
+
+			if (NPC_IsTrooper(NPC))
+			{
+				NPC_BehaviorSet_Trooper( bState);
+				return;
+			}
+
+			if ( NPC->enemy && NPC->client->ps.weapon == WP_NONE && bState != BS_HUNT_AND_KILL && !Q3_TaskIDPending( NPC, TID_MOVE_NAV ) )
+			{//if in battle and have no weapon, run away, fixme: when in BS_HUNT_AND_KILL, they just stand there
+				if ( bState != BS_FLEE )
+				{
+					NPC_StartFlee( NPC->enemy, NPC->enemy->currentOrigin, AEL_DANGER_GREAT, 5000, 10000 );
+				}
+				else
+				{
+					NPC_BSFlee();
+				}
+				return;
+			}
+			if ( NPC->client->ps.weapon == WP_SABER )
+			{//special melee exception
+				NPC_BehaviorSet_Default( bState );
+				return;
+			}
+			if ( NPC->client->ps.weapon == WP_DISRUPTOR && (NPCInfo->scriptFlags & SCF_ALT_FIRE) )
+			{//a sniper
+				NPC_BehaviorSet_Sniper( bState );
+				return;
+			}
+			if ( NPC->client->ps.weapon == WP_THERMAL 
+				|| NPC->client->ps.weapon == WP_MELEE )//FIXME: separate AI for melee fighters
+			{//a grenadier
+				NPC_BehaviorSet_Grenadier( bState );
+				return;
+			}
+			if ( NPC_CheckSurrender() )
+			{
+				return;
+			}
+			NPC_BehaviorSet_Stormtrooper( bState );
+			break;
+
+		case TEAM_NEUTRAL: 
+
+			// special cases for enemy droids
+			if ( NPC->client->NPC_class == CLASS_PROTOCOL )
+			{
+				NPC_BehaviorSet_Default(bState);
+			}
+			else if ( NPC->client->NPC_class == CLASS_UGNAUGHT 
+				|| NPC->client->NPC_class == CLASS_JAWA )
+			{//others, too?
+				NPC_BSCivilian_Default( bState );
+				return;
+			}
+			// Add special vehicle behavior here.
+			else if ( NPC->client->NPC_class == CLASS_VEHICLE )
+			{
+				Vehicle_t *pVehicle = NPC->m_pVehicle;
+				if ( !pVehicle->m_pPilot && pVehicle->m_iBoarding==0 )
+				{
+					if (pVehicle->m_pVehicleInfo->type == VH_ANIMAL)
+					{
+						NPC_BehaviorSet_Animal( bState );
+					}
+
+					// TODO: The only other case were we want a vehicle to do something specifically is
+					// perhaps in multiplayer where we want the shuttle to be able to lift off when not
+					// occupied and in a landing zone.
+				}
+			}
+			else
+			{
+				// Just one of the average droids
+				NPC_BehaviorSet_Droid( bState );
+			}
+			break;
+
+		default:
+			if ( NPC->client->NPC_class == CLASS_SEEKER )
+			{
+				NPC_BehaviorSet_Seeker(bState);
+			}
+			else
+			{
+				if ( NPCInfo->charmedTime > level.time )
+				{
+					NPC_BehaviorSet_Charmed( bState );
+				}
+				else
+				{
+					NPC_BehaviorSet_Default( bState );
+				}
+				G_CheckCharmed( NPC );
+				dontSetAim = qtrue;
+			}
+			break;
+		}
+	}
+}
+
+static bState_t G_CurrentBState( gNPC_t *gNPC )
+{
+	if ( gNPC->tempBehavior != BS_DEFAULT )
+	{//Overrides normal behavior until cleared
+		return (gNPC->tempBehavior);
+	}
+
+	if( gNPC->behaviorState == BS_DEFAULT )
+	{
+		gNPC->behaviorState = gNPC->defaultBehavior;
+	}
+
+	return (gNPC->behaviorState);
+}
+/*
+===============
+NPC_ExecuteBState
+
+  MCG
+
+NPC Behavior state thinking
+
+===============
+*/
+void NPC_ExecuteBState ( gentity_t *self)//, int msec ) 
+{
+	bState_t	bState;
+
+	NPC_HandleAIFlags();
+
+	//FIXME: these next three bits could be a function call, some sort of setup/cleanup func
+	//Lookmode must be reset every think cycle
+	if(NPC->delayScriptTime && NPC->delayScriptTime <= level.time)
+	{
+		G_ActivateBehavior( NPC, BSET_DELAYED);
+		NPC->delayScriptTime = 0;
+	}
+
+	//Clear this and let bState set it itself, so it automatically handles changing bStates... but we need a set bState wrapper func
+	NPCInfo->combatMove = qfalse;
+
+	//Execute our bState
+	bState = G_CurrentBState( NPCInfo );
+
+	//Pick the proper bstate for us and run it
+	NPC_RunBehavior( self->client->playerTeam, bState );
+	
+
+//	if(bState != BS_POINT_COMBAT && NPCInfo->combatPoint != -1)
+//	{
+		//level.combatPoints[NPCInfo->combatPoint].occupied = qfalse;
+		//NPCInfo->combatPoint = -1;
+//	}
+
+	//Here we need to see what the scripted stuff told us to do
+//Only process snapshot if independant and in combat mode- this would pick enemies and go after needed items
+//	ProcessSnapshot();
+
+//Ignore my needs if I'm under script control- this would set needs for items
+//	CheckSelf();
+
+	//Back to normal?  All decisions made?
+	
+	//FIXME: don't walk off ledges unless we can get to our goal faster that way, or that's our goal's surface
+	//NPCPredict();
+
+	if ( NPC->enemy )
+	{
+		if ( !NPC->enemy->inuse )
+		{//just in case bState doesn't catch this
+			G_ClearEnemy( NPC );
+		}
+	}
+
+	if ( NPC->client->ps.saberLockTime && NPC->client->ps.saberLockEnemy != ENTITYNUM_NONE )
+	{
+		NPC_SetLookTarget( NPC, NPC->client->ps.saberLockEnemy, level.time+1000 );
+	}
+	else if ( !NPC_CheckLookTarget( NPC ) )
+	{
+		if ( NPC->enemy )
+		{
+			NPC_SetLookTarget( NPC, NPC->enemy->s.number, 0 );
+		}
+	}
+
+	if ( NPC->enemy )
+	{
+		if(NPC->enemy->flags & FL_DONT_SHOOT)
+		{
+			ucmd.buttons &= ~BUTTON_ATTACK;
+			ucmd.buttons &= ~BUTTON_ALT_ATTACK;
+		}
+		else if ( NPC->client->playerTeam != TEAM_ENEMY //not an enemy
+			&& (NPC->client->playerTeam != TEAM_FREE || (NPC->client->NPC_class == CLASS_TUSKEN && Q_irand( 0, 4 )))//not a rampaging creature or I'm a tusken and I feel generous (temporarily)
+			&& NPC->enemy->NPC 
+			&& (NPC->enemy->NPC->surrenderTime > level.time || (NPC->enemy->NPC->scriptFlags&SCF_FORCED_MARCH)) )
+		{//don't shoot someone who's surrendering if you're a good guy
+			ucmd.buttons &= ~BUTTON_ATTACK;
+			ucmd.buttons &= ~BUTTON_ALT_ATTACK;
+		}
+
+		if(client->ps.weaponstate == WEAPON_IDLE)
+		{
+			client->ps.weaponstate = WEAPON_READY;
+		}
+	}
+	else 
+	{
+		if(client->ps.weaponstate == WEAPON_READY)
+		{
+			client->ps.weaponstate = WEAPON_IDLE;
+		}
+	}
+
+	if(!(ucmd.buttons & BUTTON_ATTACK) && NPC->attackDebounceTime > level.time)
+	{//We just shot but aren't still shooting, so hold the gun up for a while
+		if(client->ps.weapon == WP_SABER )
+		{//One-handed
+			NPC_SetAnim(NPC,SETANIM_TORSO,TORSO_WEAPONREADY1,SETANIM_FLAG_NORMAL);
+		}
+		else if(client->ps.weapon == WP_BRYAR_PISTOL)
+		{//Sniper pose
+			NPC_SetAnim(NPC,SETANIM_TORSO,TORSO_WEAPONREADY3,SETANIM_FLAG_NORMAL);
+		}
+		/*//FIXME: What's the proper solution here?
+		else
+		{//heavy weapon
+			NPC_SetAnim(NPC,SETANIM_TORSO,TORSO_WEAPONREADY3,SETANIM_FLAG_NORMAL);
+		}
+		*/
+	}	
+
+	NPC_CheckAttackHold();
+	NPC_ApplyScriptFlags();
+	
+	//cliff and wall avoidance
+	NPC_AvoidWallsAndCliffs();
+
+	// run the bot through the server like it was a real client
+//=== Save the ucmd for the second no-think Pmove ============================
+	ucmd.serverTime = level.time - 50;
+	memcpy( &NPCInfo->last_ucmd, &ucmd, sizeof( usercmd_t ) );
+	if ( !NPCInfo->attackHoldTime )
+	{
+		NPCInfo->last_ucmd.buttons &= ~(BUTTON_ATTACK|BUTTON_ALT_ATTACK|BUTTON_FORCE_FOCUS);//so we don't fire twice in one think
+	}
+//============================================================================
+	NPC_CheckAttackScript();
+	NPC_KeepCurrentFacing();
+
+	if ( !NPC->next_roff_time || NPC->next_roff_time < level.time )
+	{//If we were following a roff, we don't do normal pmoves.
+		ClientThink( NPC->s.number, &ucmd );
+	}
+	else
+	{
+		NPC_ApplyRoff();
+	}
+
+	// end of thinking cleanup
+	NPCInfo->touchedByPlayer = NULL;
+
+	NPC_CheckPlayerAim();
+	NPC_CheckAllClear();
+	
+	/*if( ucmd.forwardmove || ucmd.rightmove )
+	{
+		int	i, la = -1, ta = -1;
+
+		for(i = 0; i < MAX_ANIMATIONS; i++)
+		{
+			if( NPC->client->ps.legsAnim == i )
+			{
+				la = i;
+			}
+
+			if( NPC->client->ps.torsoAnim == i )
+			{
+				ta = i;
+			}
+			
+			if(la != -1 && ta != -1)
+			{
+				break;
+			}
+		}
+
+		if(la != -1 && ta != -1)
+		{//FIXME: should never play same frame twice or restart an anim before finishing it
+			gi.Printf("LegsAnim: %s(%d) TorsoAnim: %s(%d)\n", animTable[la].name, NPC->renderInfo.legsFrame, animTable[ta].name, NPC->client->renderInfo.torsoFrame);
+		}
+	}*/
+}
+
+void NPC_CheckInSolid(void)
+{
+	trace_t	trace;
+	vec3_t	point;
+	VectorCopy(NPC->currentOrigin, point);
+	point[2] -= 0.25;
+
+	gi.trace(&trace, NPC->currentOrigin, NPC->mins, NPC->maxs, point, NPC->s.number, NPC->clipmask);
+	if(!trace.startsolid && !trace.allsolid)
+	{
+		VectorCopy(NPC->currentOrigin, NPCInfo->lastClearOrigin);
+	}
+	else
+	{
+		if(VectorLengthSquared(NPCInfo->lastClearOrigin))
+		{
+//			gi.Printf("%s stuck in solid at %s: fixing...\n", NPC->script_targetname, vtos(NPC->currentOrigin));
+			G_SetOrigin(NPC, NPCInfo->lastClearOrigin);
+			gi.linkentity(NPC);
+		}
+	}
+}
+
+/*
+===============
+NPC_Think
+
+Main NPC AI - called once per frame
+===============
+*/
+#if	AI_TIMERS
+extern int AITime;
+#endif//	AI_TIMERS
+void NPC_Think ( gentity_t *self)//, int msec ) 
+{
+	vec3_t	oldMoveDir;
+
+	self->nextthink = level.time + FRAMETIME/2;
+
+	SetNPCGlobals( self );
+
+	memset( &ucmd, 0, sizeof( ucmd ) );
+
+	VectorCopy( self->client->ps.moveDir, oldMoveDir );
+	VectorClear( self->client->ps.moveDir );
+	// see if NPC ai is frozen
+	if ( debugNPCFreeze->integer || (NPC->svFlags&SVF_ICARUS_FREEZE) ) 
+	{
+		NPC_UpdateAngles( qtrue, qtrue );
+		ClientThink(self->s.number, &ucmd);
+		VectorCopy(self->s.origin, self->s.origin2 );
+		return;
+	}
+
+	if(!self || !self->NPC || !self->client)
+	{
+		return;
+	}
+
+	// dead NPCs have a special think, don't run scripts (for now)
+	//FIXME: this breaks deathscripts
+	if ( self->health <= 0 ) 
+	{
+		DeadThink();
+		if ( NPCInfo->nextBStateThink <= level.time )
+		{
+			if( self->m_iIcarusID != IIcarusInterface::ICARUS_INVALID && !stop_icarus )
+			{
+				IIcarusInterface::GetIcarus()->Update( self->m_iIcarusID );
+			}
+		}
+		return;
+	}
+
+	// TODO! Tauntaun's (and other creature vehicles?) think, we'll need to make an exception here to allow that.
+
+	if ( self->client 
+		&& self->client->NPC_class == CLASS_VEHICLE
+		&& self->NPC_type
+		&& ( !self->m_pVehicle->m_pVehicleInfo->Inhabited( self->m_pVehicle ) ) )
+	{//empty swoop logic
+		if ( self->owner )
+		{//still have attached owner, check and see if can forget him (so he can use me later)
+			vec3_t dir2owner;
+			VectorSubtract( self->owner->currentOrigin, self->currentOrigin, dir2owner );
+
+			gentity_t *oldOwner = self->owner;
+			self->owner = NULL;//clear here for that SpotWouldTelefrag check...?
+
+			if ( VectorLengthSquared( dir2owner ) > 128*128
+				|| !(self->clipmask&oldOwner->clipmask) 
+				|| (DotProduct( self->client->ps.velocity, oldOwner->client->ps.velocity ) < -200.0f &&!G_BoundsOverlap( self->absmin, self->absmin, oldOwner->absmin, oldOwner->absmax )) )
+			{//all clear, become solid to our owner now
+				gi.linkentity( self );
+			}
+			else
+			{//blocked, retain owner
+				self->owner = oldOwner;
+			}
+		}
+	}
+	if ( player->client->ps.viewEntity == self->s.number )
+	{//being controlled by player
+		if ( self->client )
+		{//make the noises
+			if ( TIMER_Done( self, "patrolNoise" ) && !Q_irand( 0, 20 ) )
+			{
+				switch( self->client->NPC_class )
+				{
+				case CLASS_R2D2:				// droid
+					G_SoundOnEnt(self, CHAN_AUTO, va("sound/chars/r2d2/misc/r2d2talk0%d.wav",Q_irand(1, 3)) );
+					break;
+				case CLASS_R5D2:				// droid
+					G_SoundOnEnt(self, CHAN_AUTO, va("sound/chars/r5d2/misc/r5talk%d.wav",Q_irand(1, 4)) );
+					break;
+				case CLASS_PROBE:				// droid
+					G_SoundOnEnt(self, CHAN_AUTO, va("sound/chars/probe/misc/probetalk%d.wav",Q_irand(1, 3)) );
+					break;
+				case CLASS_MOUSE:				// droid
+					G_SoundOnEnt(self, CHAN_AUTO, va("sound/chars/mouse/misc/mousego%d.wav",Q_irand(1, 3)) );
+					break;
+				case CLASS_GONK:				// droid
+					G_SoundOnEnt(self, CHAN_AUTO, va("sound/chars/gonk/misc/gonktalk%d.wav",Q_irand(1, 2)) );
+					break;
+				}
+				TIMER_Set( self, "patrolNoise", Q_irand( 2000, 4000 ) );
+			}
+		}
+		//FIXME: might want to at least make sounds or something?
+		//NPC_UpdateAngles(qtrue, qtrue);
+		//Which ucmd should we send?  Does it matter, since it gets overridden anyway?
+		NPCInfo->last_ucmd.serverTime = level.time - 50;
+		ClientThink( NPC->s.number, &ucmd );
+		VectorCopy(self->s.origin, self->s.origin2 );
+		return;
+	}
+
+	if ( NPCInfo->nextBStateThink <= level.time )
+	{
+#if	AI_TIMERS
+		int	startTime = GetTime(0);
+#endif//	AI_TIMERS
+		if ( NPC->s.eType != ET_PLAYER )
+		{//Something drastic happened in our script
+			return;
+		}
+
+		if ( NPC->s.weapon == WP_SABER && g_spskill->integer >= 2 && NPCInfo->rank > RANK_LT_JG )
+		{//Jedi think faster on hard difficulty, except low-rank (reborn)
+			NPCInfo->nextBStateThink = level.time + FRAMETIME/2;
+		}
+		else
+		{//Maybe even 200 ms?
+			NPCInfo->nextBStateThink = level.time + FRAMETIME;
+		}
+
+		//nextthink is set before this so something in here can override it
+		NPC_ExecuteBState( self );
+
+#if	AI_TIMERS
+		int addTime = GetTime( startTime );
+		if ( addTime > 50 )
+		{
+			gi.Printf( S_COLOR_RED"ERROR: NPC number %d, %s %s at %s, weaponnum: %d, using %d of AI time!!!\n", NPC->s.number, NPC->NPC_type, NPC->targetname, vtos(NPC->currentOrigin), NPC->s.weapon, addTime );
+		}
+		AITime += addTime;
+#endif//	AI_TIMERS
+	}
+	else
+	{
+		if ( NPC->client 
+			&& NPC->client->NPC_class == CLASS_ROCKETTROOPER
+			&& (NPC->client->ps.eFlags&EF_FORCE_GRIPPED)
+			&& NPC->client->moveType == MT_FLYSWIM
+			&& NPC->client->ps.groundEntityNum == ENTITYNUM_NONE )
+		{//reduce velocity
+			VectorScale( NPC->client->ps.velocity, 0.75f, NPC->client->ps.velocity );
+		}
+		VectorCopy( oldMoveDir, self->client->ps.moveDir );
+		//or use client->pers.lastCommand?
+		NPCInfo->last_ucmd.serverTime = level.time - 50;
+		if ( !NPC->next_roff_time || NPC->next_roff_time < level.time )
+		{//If we were following a roff, we don't do normal pmoves.
+			//FIXME: firing angles (no aim offset) or regular angles?
+			NPC_UpdateAngles(qtrue, qtrue);
+			memcpy( &ucmd, &NPCInfo->last_ucmd, sizeof( usercmd_t ) );
+			ClientThink(NPC->s.number, &ucmd);
+		}
+		else
+		{
+			NPC_ApplyRoff();
+		}
+		VectorCopy(self->s.origin, self->s.origin2 );
+	}
+	//must update icarus *every* frame because of certain animation completions in the pmove stuff that can leave a 50ms gap between ICARUS animation commands
+	if( self->m_iIcarusID != IIcarusInterface::ICARUS_INVALID && !stop_icarus )
+	{
+		IIcarusInterface::GetIcarus()->Update( self->m_iIcarusID );
+	}
+}
+
+void NPC_InitAI ( void ) 
+{
+	debugNPCAI = gi.cvar ( "d_npcai", "0", CVAR_CHEAT );
+	debugNPCFreeze = gi.cvar ( "d_npcfreeze", "0", CVAR_CHEAT);
+	d_JediAI = gi.cvar ( "d_JediAI", "0", CVAR_CHEAT );
+	d_noGroupAI = gi.cvar ( "d_noGroupAI", "0", CVAR_CHEAT );
+	d_asynchronousGroupAI = gi.cvar ( "d_asynchronousGroupAI", "1", CVAR_CHEAT );
+
+	//0 = never (BORING)
+	//1 = kyle only
+	//2 = kyle and last enemy jedi
+	//3 = kyle and any enemy jedi
+	//4 = kyle and last enemy in a group, special kicks
+	//5 = kyle and any enemy
+	//6 = also when kyle takes pain or enemy jedi dodges player saber swing or does an acrobatic evasion
+	// NOTE : I also create this in UI_Init()
+	d_slowmodeath = gi.cvar ( "d_slowmodeath", "3", CVAR_ARCHIVE );//save this setting
+
+	d_saberCombat = gi.cvar ( "d_saberCombat", "0", CVAR_CHEAT );
+}
+
+/*
+==================================
+void NPC_InitAnimTable( void )
+
+  Need to initialize this table.
+  If someone tried to play an anim
+  before table is filled in with
+  values, causes tasks that wait for
+  anim completion to never finish.
+  (frameLerp of 0 * numFrames of 0 = 0)
+==================================
+*/
+void NPC_InitAnimTable( void )
+{
+	for ( int i = 0; i < MAX_ANIM_FILES; i++ )
+	{
+		for ( int j = 0; j < MAX_ANIMATIONS; j++ )
+		{
+			level.knownAnimFileSets[i].animations[j].firstFrame = 0;
+			level.knownAnimFileSets[i].animations[j].frameLerp = 100;
+//			level.knownAnimFileSets[i].animations[j].initialLerp = 100;
+			level.knownAnimFileSets[i].animations[j].numFrames = 0;
+		}
+	}
+}
+
+extern int G_ParseAnimFileSet( const char *skeletonName, const char *modelName=0);
+void NPC_InitGame( void ) 
+{
+//	globals.NPCs = (gNPC_t *) gi.TagMalloc(game.maxclients * sizeof(game.bots[0]), TAG_GAME);
+	debugNPCName = gi.cvar ( "d_npc", "", 0  );
+	NPC_LoadParms();
+	NPC_InitAI();
+	NPC_InitAnimTable();
+	G_ParseAnimFileSet("_humanoid");	//GET THIS CACHED NOW BEFORE CGAME STARTS
+	/*
+	ResetTeamCounters();
+	for ( int team = TEAM_FREE; team < TEAM_NUM_TEAMS; team++ )
+	{
+		teamLastEnemyTime[team] = -10000;
+	}
+	*/
+}
+
+void NPC_SetAnim(gentity_t	*ent,int setAnimParts,int anim,int setAnimFlags, int iBlend)
+{	// FIXME : once torsoAnim and legsAnim are in the same structure for NCP and Players
+	// rename PM_SETAnimFinal to PM_SetAnim and have both NCP and Players call PM_SetAnim
+
+	if ( !ent )
+	{
+		return;
+	}
+
+	if ( ent->health > 0 )
+	{//don't lock anims if the guy is dead
+		if ( ent->client->ps.torsoAnimTimer
+			&& PM_LockedAnim( ent->client->ps.torsoAnim ) 
+			&& !PM_LockedAnim( anim ) )
+		{//nothing can override these special anims
+			setAnimParts &= ~SETANIM_TORSO;
+		}
+
+		if ( ent->client->ps.legsAnimTimer
+			&& PM_LockedAnim( ent->client->ps.legsAnim ) 
+			&& !PM_LockedAnim( anim ) )
+		{//nothing can override these special anims
+			setAnimParts &= ~SETANIM_LEGS;
+		}
+	}
+
+	if ( !setAnimParts )
+	{
+		return;
+	}
+
+	if(ent->client)
+	{//Players, NPCs
+		if (setAnimFlags&SETANIM_FLAG_OVERRIDE)
+		{		
+			if (setAnimParts & SETANIM_TORSO)
+			{
+				if( (setAnimFlags & SETANIM_FLAG_RESTART) || ent->client->ps.torsoAnim != anim )
+				{
+					PM_SetTorsoAnimTimer( ent, &ent->client->ps.torsoAnimTimer, 0 );
+				}
+			}
+			if (setAnimParts & SETANIM_LEGS)
+			{
+				if( (setAnimFlags & SETANIM_FLAG_RESTART) || ent->client->ps.legsAnim != anim )
+				{
+					PM_SetLegsAnimTimer( ent, &ent->client->ps.legsAnimTimer, 0 );
+				}
+			}
+		}
+
+		PM_SetAnimFinal(&ent->client->ps.torsoAnim,&ent->client->ps.legsAnim,setAnimParts,anim,setAnimFlags,
+			&ent->client->ps.torsoAnimTimer,&ent->client->ps.legsAnimTimer,ent, iBlend );
+	}
+	else
+	{//bodies, etc.
+		if (setAnimFlags&SETANIM_FLAG_OVERRIDE)
+		{		
+			if (setAnimParts & SETANIM_TORSO)
+			{
+				if( (setAnimFlags & SETANIM_FLAG_RESTART) || ent->s.torsoAnim != anim )
+				{
+					PM_SetTorsoAnimTimer( ent, &ent->s.torsoAnimTimer, 0 );
+				}
+			}
+			if (setAnimParts & SETANIM_LEGS)
+			{
+				if( (setAnimFlags & SETANIM_FLAG_RESTART) || ent->s.legsAnim != anim )
+				{
+					PM_SetLegsAnimTimer( ent, &ent->s.legsAnimTimer, 0 );
+				}
+			}
+		}
+
+		PM_SetAnimFinal(&ent->s.torsoAnim,&ent->s.legsAnim,setAnimParts,anim,setAnimFlags,
+			&ent->s.torsoAnimTimer,&ent->s.legsAnimTimer,ent);
+	}
+}
diff --git a/code/game/NPC_behavior.cpp b/code/game/NPC_behavior.cpp
new file mode 100644
index 0000000..13001cf
--- /dev/null
+++ b/code/game/NPC_behavior.cpp
@@ -0,0 +1,2067 @@
+//NPC_behavior.cpp
+/*
+FIXME - MCG:
+These all need to make use of the snapshots.  Write something that can look for only specific
+things in a snapshot or just go through the snapshot every frame and save the info in case
+we need it...
+*/
+
+// leave this line at the top for all NPC_xxxx.cpp files...
+#include "g_headers.h"
+#include "g_navigator.h"
+#include "Q3_Interface.h"
+
+extern cvar_t	*g_AIsurrender;
+extern	qboolean	showBBoxes;
+static vec3_t NPCDEBUG_BLUE = {0.0, 0.0, 1.0};
+extern void CG_Cube( vec3_t mins, vec3_t maxs, vec3_t color, float alpha );
+extern void NPC_CheckGetNewWeapon( void );
+extern qboolean PM_InKnockDown( playerState_t *ps );
+extern void NPC_AimAdjust( int change );
+extern qboolean G_StandardHumanoid( gentity_t *self );
+/*
+ void NPC_BSAdvanceFight (void)
+
+Advance towards your captureGoal and shoot anyone you can along the way.
+*/
+void NPC_BSAdvanceFight (void)
+{//FIXME: IMPLEMENT
+//Head to Goal if I can
+
+	//Make sure we're still headed where we want to capture
+	if ( NPCInfo->captureGoal )
+	{//FIXME: if no captureGoal, what do we do?
+		//VectorCopy( NPCInfo->captureGoal->currentOrigin, NPCInfo->tempGoal->currentOrigin );
+		//NPCInfo->goalEntity = NPCInfo->tempGoal;
+
+		NPC_SetMoveGoal( NPC, NPCInfo->captureGoal->currentOrigin, 16, qtrue );
+
+		NPCInfo->goalTime = level.time + 100000;
+	}
+
+//	NPC_BSRun();
+
+	NPC_CheckEnemy(qtrue, qfalse);
+
+	//FIXME: Need melee code
+	if( NPC->enemy )
+	{//See if we can shoot him
+		vec3_t		delta, forward;
+		vec3_t		angleToEnemy;
+		vec3_t		hitspot, muzzle, diff, enemy_org, enemy_head;
+		float		distanceToEnemy;
+		qboolean	attack_ok = qfalse;
+		qboolean	dead_on = qfalse;
+		float		attack_scale = 1.0;
+		float		aim_off;
+		float		max_aim_off = 64;
+
+		//Yaw to enemy
+		VectorMA(NPC->enemy->absmin, 0.5, NPC->enemy->maxs, enemy_org);
+		CalcEntitySpot( NPC, SPOT_WEAPON, muzzle );
+		
+		VectorSubtract (enemy_org, muzzle, delta);
+		vectoangles ( delta, angleToEnemy );
+		distanceToEnemy = VectorNormalize(delta);
+
+		if(!NPC_EnemyTooFar(NPC->enemy, distanceToEnemy*distanceToEnemy, qtrue))
+		{
+			attack_ok = qtrue;
+		}
+
+		if(attack_ok)
+		{
+			NPC_UpdateShootAngles(angleToEnemy, qfalse, qtrue);
+
+			NPCInfo->enemyLastVisibility = enemyVisibility;
+			enemyVisibility = NPC_CheckVisibility ( NPC->enemy, CHECK_FOV);//CHECK_360|//CHECK_PVS|
+
+			if(enemyVisibility == VIS_FOV)
+			{//He's in our FOV
+				
+				attack_ok = qtrue;
+				CalcEntitySpot( NPC->enemy, SPOT_HEAD, enemy_head);
+
+				if(attack_ok)
+				{
+					trace_t		tr;
+					gentity_t	*traceEnt;
+					//are we gonna hit him if we shoot at his center?
+					gi.trace ( &tr, muzzle, NULL, NULL, enemy_org, NPC->s.number, MASK_SHOT );
+					traceEnt = &g_entities[tr.entityNum];
+					if( traceEnt != NPC->enemy &&
+						(!traceEnt || !traceEnt->client || !NPC->client->enemyTeam || NPC->client->enemyTeam != traceEnt->client->playerTeam) )
+					{//no, so shoot for the head
+						attack_scale *= 0.75;
+						gi.trace ( &tr, muzzle, NULL, NULL, enemy_head, NPC->s.number, MASK_SHOT );
+						traceEnt = &g_entities[tr.entityNum];
+					}
+
+					VectorCopy( tr.endpos, hitspot );
+
+					if( traceEnt == NPC->enemy || (traceEnt->client && NPC->client->enemyTeam && NPC->client->enemyTeam == traceEnt->client->playerTeam) )
+					{
+						dead_on = qtrue;
+					}
+					else
+					{
+						attack_scale *= 0.5;
+						if(NPC->client->playerTeam)
+						{
+							if(traceEnt && traceEnt->client && traceEnt->client->playerTeam)
+							{
+								if(NPC->client->playerTeam == traceEnt->client->playerTeam)
+								{//Don't shoot our own team
+									attack_ok = qfalse;
+								}
+							}
+						}
+					}
+				}
+
+				if( attack_ok )
+				{
+					//ok, now adjust pitch aim
+					VectorSubtract (hitspot, muzzle, delta);
+					vectoangles ( delta, angleToEnemy );
+					NPC->NPC->desiredPitch = angleToEnemy[PITCH];
+					NPC_UpdateShootAngles(angleToEnemy, qtrue, qfalse);
+
+					if( !dead_on )
+					{//We're not going to hit him directly, try a suppressing fire
+						//see if where we're going to shoot is too far from his origin
+						AngleVectors (NPCInfo->shootAngles, forward, NULL, NULL);
+						VectorMA ( muzzle, distanceToEnemy, forward, hitspot);
+						VectorSubtract(hitspot, enemy_org, diff);
+						aim_off = VectorLength(diff);
+						if(aim_off > random() * max_aim_off)//FIXME: use aim value to allow poor aim?
+						{
+							attack_scale *= 0.75;
+							//see if where we're going to shoot is too far from his head
+							VectorSubtract(hitspot, enemy_head, diff);
+							aim_off = VectorLength(diff);
+							if(aim_off > random() * max_aim_off)
+							{
+								attack_ok = qfalse;
+							}
+						}
+						attack_scale *= (max_aim_off - aim_off + 1)/max_aim_off;
+					}
+				}
+			}
+		}
+
+		if( attack_ok )
+		{
+			if( NPC_CheckAttack( attack_scale ))
+			{//check aggression to decide if we should shoot
+				enemyVisibility = VIS_SHOOT;
+				WeaponThink(qtrue);
+			}
+			else
+				attack_ok = qfalse;
+		}
+//Don't do this- only for when stationary and trying to shoot an enemy
+//		else
+//			NPC->cantHitEnemyCounter++;
+	}
+	else
+	{//FIXME: 
+		NPC_UpdateShootAngles(NPC->client->ps.viewangles, qtrue, qtrue);
+	}
+
+	if(!ucmd.forwardmove && !ucmd.rightmove)
+	{//We reached our captureGoal
+		if( NPC->m_iIcarusID != IIcarusInterface::ICARUS_INVALID /*NPC->taskManager*/ )
+		{
+			Q3_TaskIDComplete( NPC, TID_BSTATE );
+		}
+	}
+}
+
+void Disappear(gentity_t *self)
+{
+//	ClientDisconnect(self);
+	self->s.eFlags |= EF_NODRAW;
+	self->e_ThinkFunc = thinkF_NULL;
+	self->nextthink = -1;
+}
+
+void MakeOwnerInvis (gentity_t *self);
+void BeamOut (gentity_t *self)
+{
+//	gentity_t *tent = G_Spawn();
+	
+/*
+	tent->owner = self;
+	tent->think = MakeOwnerInvis;
+	tent->nextthink = level.time + 1800;
+	//G_AddEvent( ent, EV_PLAYER_TELEPORT, 0 );
+	tent = G_TempEntity( self->client->pcurrentOrigin, EV_PLAYER_TELEPORT );
+*/
+	//fixme: doesn't actually go away!
+	self->nextthink = level.time + 1500;
+	self->e_ThinkFunc = thinkF_Disappear;
+	self->client->playerTeam = TEAM_FREE;
+	self->svFlags |= SVF_BEAMING;
+}
+
+void NPC_BSCinematic( void ) 
+{
+
+	if( NPCInfo->scriptFlags & SCF_FIRE_WEAPON )
+	{
+		WeaponThink( qtrue );
+	}
+	if (NPCInfo->scriptFlags&SCF_FIRE_WEAPON_NO_ANIM)
+	{
+		if (TIMER_Done(NPC, "NoAnimFireDelay"))
+		{
+			TIMER_Set(NPC, "NoAnimFireDelay", NPC_AttackDebounceForWeapon());
+			FireWeapon(NPC, (NPCInfo->scriptFlags&SCF_ALT_FIRE)) ;
+		}
+	}
+
+	if ( UpdateGoal() )
+	{//have a goalEntity
+		//move toward goal, should also face that goal
+		NPC_MoveToGoal( qtrue );
+	}
+
+	if ( NPCInfo->watchTarget )
+	{//have an entity which we want to keep facing
+		//NOTE: this will override any angles set by NPC_MoveToGoal
+		vec3_t eyes, viewSpot, viewvec, viewangles;
+
+		CalcEntitySpot( NPC, SPOT_HEAD_LEAN, eyes );
+		CalcEntitySpot( NPCInfo->watchTarget, SPOT_HEAD_LEAN, viewSpot );
+
+		VectorSubtract( viewSpot, eyes, viewvec );
+		
+		vectoangles( viewvec, viewangles );
+
+		NPCInfo->lockedDesiredYaw = NPCInfo->desiredYaw = viewangles[YAW];
+		NPCInfo->lockedDesiredPitch = NPCInfo->desiredPitch = viewangles[PITCH];
+	}
+
+	NPC_UpdateAngles( qtrue, qtrue );
+}
+
+void NPC_BSWait( void ) 
+{
+	NPC_UpdateAngles( qtrue, qtrue );
+}
+
+
+void NPC_BSInvestigate (void)
+{
+/*
+	//FIXME: maybe allow this to be set as a tempBState in a script?  Just specify the
+	//investigateGoal, investigateDebounceTime and investigateCount? (Needs a macro)
+	vec3_t		invDir, invAngles, spot;
+	gentity_t	*saveGoal;
+	//BS_INVESTIGATE would turn toward goal, maybe take a couple steps towards it,
+	//look for enemies, then turn away after your investigate counter was down-
+	//investigate counter goes up every time you set it...
+
+	if(level.time > NPCInfo->enemyCheckDebounceTime)
+	{
+		NPCInfo->enemyCheckDebounceTime = level.time + (NPCInfo->stats.vigilance * 1000);
+		NPC_CheckEnemy(qtrue, qfalse);
+		if(NPC->enemy)
+		{//FIXME: do anger script
+			NPCInfo->goalEntity = NPC->enemy;
+			NPCInfo->behaviorState = BS_RUN_AND_SHOOT;
+			NPCInfo->tempBehavior = BS_DEFAULT;
+			NPC_AngerSound();
+			return;
+		}
+	}
+
+	NPC_SetAnim( NPC, SETANIM_TORSO, TORSO_WEAPONREADY3, SETANIM_FLAG_NORMAL );
+
+	if(NPCInfo->stats.vigilance <= 1.0 && NPCInfo->eventOwner)
+	{
+		VectorCopy(NPCInfo->eventOwner->currentOrigin, NPCInfo->investigateGoal);
+	}
+
+	saveGoal = NPCInfo->goalEntity;
+	if(	level.time > NPCInfo->walkDebounceTime )
+	{
+		vec3_t	vec;
+
+		VectorSubtract(NPCInfo->investigateGoal, NPC->currentOrigin, vec);
+		vec[2] = 0;
+		if(VectorLength(vec) > 64)
+		{
+			if(Q_irand(0, 100) < NPCInfo->investigateCount)
+			{//take a full step
+				//NPCInfo->walkDebounceTime = level.time + 1400;
+				//actually finds length of my BOTH_WALK anim
+				NPCInfo->walkDebounceTime = PM_AnimLength( NPC->client->clientInfo.animFileIndex, BOTH_WALK1 );
+			}
+		}
+	}
+
+	if(	level.time < NPCInfo->walkDebounceTime )
+	{//walk toward investigateGoal
+		
+		/*
+		NPCInfo->goalEntity = NPCInfo->tempGoal;
+		VectorCopy(NPCInfo->investigateGoal, NPCInfo->tempGoal->currentOrigin);
+		*/
+
+/*		NPC_SetMoveGoal( NPC, NPCInfo->investigateGoal, 16, qtrue );
+
+		NPC_MoveToGoal( qtrue );
+
+		//FIXME: walk2?
+		NPC_SetAnim(NPC,SETANIM_LEGS,BOTH_WALK1,SETANIM_FLAG_NORMAL);
+
+		ucmd.buttons |= BUTTON_WALKING;
+	}
+	else
+	{
+
+		NPC_SetAnim(NPC,SETANIM_LEGS,BOTH_STAND1,SETANIM_FLAG_NORMAL);
+
+		if(NPCInfo->hlookCount > 30)
+		{
+			if(Q_irand(0, 10) > 7) 
+			{
+				NPCInfo->hlookCount = 0;
+			}
+		}
+		else if(NPCInfo->hlookCount < -30)
+		{
+			if(Q_irand(0, 10) > 7) 
+			{
+				NPCInfo->hlookCount = 0;
+			}
+		}
+		else if(NPCInfo->hlookCount == 0)
+		{
+			NPCInfo->hlookCount = Q_irand(-1, 1);
+		}
+		else if(Q_irand(0, 10) > 7) 
+		{
+			if(NPCInfo->hlookCount > 0)
+			{
+				NPCInfo->hlookCount++;
+			}
+			else//lookCount < 0
+			{
+				NPCInfo->hlookCount--;
+			}
+		}
+
+		if(NPCInfo->vlookCount >= 15)
+		{
+			if(Q_irand(0, 10) > 7) 
+			{
+				NPCInfo->vlookCount = 0;
+			}
+		}
+		else if(NPCInfo->vlookCount <= -15)
+		{
+			if(Q_irand(0, 10) > 7) 
+			{
+				NPCInfo->vlookCount = 0;
+			}
+		}
+		else if(NPCInfo->vlookCount == 0)
+		{
+			NPCInfo->vlookCount = Q_irand(-1, 1);
+		}
+		else if(Q_irand(0, 10) > 8) 
+		{
+			if(NPCInfo->vlookCount > 0)
+			{
+				NPCInfo->vlookCount++;
+			}
+			else//lookCount < 0
+			{
+				NPCInfo->vlookCount--;
+			}
+		}
+
+		//turn toward investigateGoal
+		CalcEntitySpot( NPC, SPOT_HEAD, spot );
+		VectorSubtract(NPCInfo->investigateGoal, spot, invDir);
+		VectorNormalize(invDir);
+		vectoangles(invDir, invAngles);
+		NPCInfo->desiredYaw = AngleNormalize360(invAngles[YAW] + NPCInfo->hlookCount);
+		NPCInfo->desiredPitch = AngleNormalize360(invAngles[PITCH] + NPCInfo->hlookCount);
+	}
+
+	NPC_UpdateAngles(qtrue, qtrue);
+
+	NPCInfo->goalEntity = saveGoal;
+
+	if(level.time > NPCInfo->investigateDebounceTime)
+	{
+		NPCInfo->tempBehavior = BS_DEFAULT;
+	}
+
+	NPC_CheckSoundEvents();
+	*/
+}
+
+qboolean NPC_CheckInvestigate( int alertEventNum )
+{
+	gentity_t	*owner = level.alertEvents[alertEventNum].owner;
+	int		invAdd = level.alertEvents[alertEventNum].level;
+	vec3_t	soundPos;
+	float	soundRad = level.alertEvents[alertEventNum].radius;
+	float	earshot = NPCInfo->stats.earshot;
+
+	VectorCopy( level.alertEvents[alertEventNum].position, soundPos );
+
+	//NOTE: Trying to preserve previous investigation behavior
+	if ( !owner )
+	{
+		return qfalse;
+	}
+
+	if ( owner->s.eType != ET_PLAYER && owner == NPCInfo->goalEntity ) 
+	{
+		return qfalse;
+	}
+
+	if ( owner->s.eFlags & EF_NODRAW ) 
+	{
+		return qfalse;
+	}
+
+	if ( owner->flags & FL_NOTARGET ) 
+	{
+		return qfalse;
+	}
+
+	if ( soundRad < earshot )
+	{
+		return qfalse;
+	}
+
+	//if(!gi.inPVSIgnorePortals(ent->currentOrigin, NPC->currentOrigin))//should we be able to hear through areaportals?
+	if ( !gi.inPVS( soundPos, NPC->currentOrigin ) )
+	{//can hear through doors?
+		return qfalse;
+	}
+
+	if ( owner->client && owner->client->playerTeam && NPC->client->playerTeam && owner->client->playerTeam != NPC->client->playerTeam )
+	{
+		if( (float)NPCInfo->investigateCount >= (NPCInfo->stats.vigilance*200) && owner )
+		{//If investigateCount == 10, just take it as enemy and go
+			if ( NPC_ValidEnemy( owner ) )
+			{//FIXME: run angerscript
+				G_SetEnemy( NPC, owner );
+				NPCInfo->goalEntity = NPC->enemy;
+				NPCInfo->goalRadius = 12;
+				NPCInfo->behaviorState = BS_HUNT_AND_KILL;
+				return qtrue;
+			}
+		}
+		else
+		{
+			NPCInfo->investigateCount += invAdd;
+		}
+		//run awakescript
+		G_ActivateBehavior(NPC, BSET_AWAKE);
+
+		/*
+		if ( Q_irand(0, 10) > 7 )
+		{
+			NPC_AngerSound();
+		}
+		*/
+
+		//NPCInfo->hlookCount = NPCInfo->vlookCount = 0;
+		NPCInfo->eventOwner = owner;
+		VectorCopy( soundPos, NPCInfo->investigateGoal );
+		if ( NPCInfo->investigateCount > 20 )
+		{
+			NPCInfo->investigateDebounceTime = level.time + 10000;
+		}
+		else
+		{
+			NPCInfo->investigateDebounceTime = level.time + (NPCInfo->investigateCount*500);
+		}
+		NPCInfo->tempBehavior = BS_INVESTIGATE;
+		return qtrue;
+	}
+
+	return qfalse;
+}
+
+
+/*
+void NPC_BSSleep( void ) 
+*/
+void NPC_BSSleep( void ) 
+{
+	int alertEvent = NPC_CheckAlertEvents( qtrue, qfalse );
+
+	//There is an event to look at
+	if ( alertEvent >= 0 )
+	{
+		G_ActivateBehavior(NPC, BSET_AWAKE);
+		return;
+	}
+
+	/*
+	if ( level.time > NPCInfo->enemyCheckDebounceTime )
+	{
+		if ( NPC_CheckSoundEvents() != -1 )
+		{//only 1 alert per second per 0.1 of vigilance
+			NPCInfo->enemyCheckDebounceTime = level.time + (NPCInfo->stats.vigilance * 10000);
+			G_ActivateBehavior(NPC, BSET_AWAKE);
+		}
+	}
+	*/
+}
+
+
+extern qboolean NPC_MoveDirClear( int forwardmove, int rightmove, qboolean reset );
+
+bool NPC_BSFollowLeader_UpdateLeader(void)
+{
+	if ( NPC->client->leader//have a leader
+		&& NPC->client->leader->s.number < MAX_CLIENTS //player
+		&& NPC->client->leader->client//player is a client
+		&& !NPC->client->leader->client->pers.enterTime )//player has not finished spawning in yet
+	{//don't do anything just yet, but don't clear the leader either
+		return false;
+	}
+
+	if (NPC->client->leader && NPC->client->leader->health<=0)
+	{
+		NPC->client->leader = NULL;
+	}
+
+	if ( !NPC->client->leader )
+	{//ok, stand guard until we find an enemy
+		if( NPCInfo->tempBehavior == BS_HUNT_AND_KILL )
+		{
+			NPCInfo->tempBehavior = BS_DEFAULT;
+		}
+		else
+		{
+			NPCInfo->tempBehavior = BS_STAND_GUARD;
+			NPC_BSStandGuard();
+		}
+		if ( NPCInfo->behaviorState == BS_FOLLOW_LEADER )
+		{
+			NPCInfo->behaviorState = BS_DEFAULT; 
+		}
+		if ( NPCInfo->defaultBehavior == BS_FOLLOW_LEADER )
+		{
+			NPCInfo->defaultBehavior = BS_DEFAULT; 
+		}
+		return false;
+	}
+	return true; 
+}
+
+
+void NPC_BSFollowLeader_UpdateEnemy(void)
+{
+	if ( !NPC->enemy  )
+	{//no enemy, find one
+		NPC_CheckEnemy( NPCInfo->confusionTime<level.time, qfalse );//don't find new enemy if this is tempbehav
+		if ( NPC->enemy )
+		{//just found one
+			NPCInfo->enemyCheckDebounceTime = level.time + Q_irand( 3000, 10000 );
+		}
+		else
+		{
+			if ( !(NPCInfo->scriptFlags&SCF_IGNORE_ALERTS) )
+			{
+				int eventID = NPC_CheckAlertEvents( qtrue, qtrue );
+				if ( eventID > -1 && level.alertEvents[eventID].level >= AEL_SUSPICIOUS && (NPCInfo->scriptFlags&SCF_LOOK_FOR_ENEMIES) )
+				{
+					//NPCInfo->lastAlertID = level.alertEvents[eventID].ID;
+					if ( !level.alertEvents[eventID].owner || 
+						!level.alertEvents[eventID].owner->client || 
+						level.alertEvents[eventID].owner->health <= 0 ||
+						level.alertEvents[eventID].owner->client->playerTeam != NPC->client->enemyTeam )
+					{//not an enemy
+					}
+					else
+					{
+						//FIXME: what if can't actually see enemy, don't know where he is... should we make them just become very alert and start looking for him?  Or just let combat AI handle this... (act as if you lost him)
+						G_SetEnemy( NPC, level.alertEvents[eventID].owner );
+						NPCInfo->enemyCheckDebounceTime = level.time + Q_irand( 3000, 10000 );
+						NPCInfo->enemyLastSeenTime = level.time;
+						TIMER_Set( NPC, "attackDelay", Q_irand( 500, 1000 ) );
+					}
+				}
+
+			}
+		}
+		if ( !NPC->enemy )
+		{
+			if ( NPC->client->leader 
+				&& NPC->client->leader->enemy 
+				&& NPC->client->leader->enemy != NPC
+				&& ( (NPC->client->leader->enemy->client&&NPC->client->leader->enemy->client->playerTeam==NPC->client->enemyTeam)
+					||(NPC->client->leader->enemy->svFlags&SVF_NONNPC_ENEMY&&NPC->client->leader->enemy->noDamageTeam==NPC->client->enemyTeam) )
+				&& NPC->client->leader->enemy->health > 0 )
+			{
+				G_SetEnemy( NPC, NPC->client->leader->enemy );
+				NPCInfo->enemyCheckDebounceTime = level.time + Q_irand( 3000, 10000 );
+				NPCInfo->enemyLastSeenTime = level.time;
+			}
+		}
+	}
+	else 
+	{
+		if ( NPC->enemy->health <= 0 || (NPC->enemy->flags&FL_NOTARGET) )
+		{
+			G_ClearEnemy( NPC );
+			if ( NPCInfo->enemyCheckDebounceTime > level.time + 1000 )
+			{
+				NPCInfo->enemyCheckDebounceTime = level.time + Q_irand( 1000, 2000 );
+			}
+		}
+		else if ( NPC->client->ps.weapon && NPCInfo->enemyCheckDebounceTime < level.time )
+		{
+			NPC_CheckEnemy( (NPCInfo->confusionTime<level.time||NPCInfo->tempBehavior!=BS_FOLLOW_LEADER), qfalse );//don't find new enemy if this is tempbehav
+		}
+	}
+}
+
+
+bool NPC_BSFollowLeader_AttackEnemy(void)
+{
+	if ( NPC->client->ps.weapon == WP_SABER )//|| NPCInfo->confusionTime>level.time )
+	{//lightsaber user or charmed enemy
+		if ( NPCInfo->tempBehavior != BS_FOLLOW_LEADER )
+		{//not already in a temp bState
+			//go after the guy
+			NPCInfo->tempBehavior = BS_HUNT_AND_KILL;
+			NPC_UpdateAngles(qtrue, qtrue);
+			return true;
+		}
+	}
+
+	enemyVisibility = NPC_CheckVisibility ( NPC->enemy, CHECK_FOV|CHECK_SHOOT );//CHECK_360|CHECK_PVS|
+	if ( enemyVisibility > VIS_PVS )
+	{//face
+		vec3_t	enemy_org, muzzle, delta, angleToEnemy;
+		float	distanceToEnemy;
+
+		CalcEntitySpot( NPC->enemy, SPOT_HEAD, enemy_org );
+		NPC_AimWiggle( enemy_org );
+
+		CalcEntitySpot( NPC, SPOT_WEAPON, muzzle );
+		
+		VectorSubtract( enemy_org, muzzle, delta);
+		vectoangles( delta, angleToEnemy );
+		distanceToEnemy = VectorNormalize( delta );
+
+		NPCInfo->desiredYaw = angleToEnemy[YAW];
+		NPCInfo->desiredPitch = angleToEnemy[PITCH];
+		NPC_UpdateFiringAngles( qtrue, qtrue );
+
+		if ( enemyVisibility >= VIS_SHOOT )
+		{//shoot
+			NPC_AimAdjust( 2 );
+			if ( NPC_GetHFOVPercentage( NPC->enemy->currentOrigin, NPC->currentOrigin, NPC->client->ps.viewangles, NPCInfo->stats.hfov ) > 0.6f 
+				&& NPC_GetHFOVPercentage( NPC->enemy->currentOrigin, NPC->currentOrigin, NPC->client->ps.viewangles, NPCInfo->stats.vfov ) > 0.5f )
+			{//actually withing our front cone
+				WeaponThink( qtrue );
+			}
+		}
+		else
+		{
+			NPC_AimAdjust( 1 );
+		}
+		
+		//NPC_CheckCanAttack(1.0, qfalse);
+	}
+	else
+	{
+		NPC_AimAdjust( -1 );
+	}
+	return false;
+}
+
+bool NPC_BSFollowLeader_CanAttack(void)
+{
+	 return (NPC->enemy 
+		&& NPC->client->ps.weapon 
+		&& !(NPCInfo->aiFlags&NPCAI_HEAL_ROSH) //Kothos twins never go after their enemy
+		);
+}
+
+bool NPC_BSFollowLeader_InFullBodyAttack(void)
+{
+	return (
+		NPC->client->ps.legsAnim==BOTH_ATTACK1 || 
+		NPC->client->ps.legsAnim==BOTH_ATTACK2 || 
+		NPC->client->ps.legsAnim==BOTH_ATTACK3 || 
+		NPC->client->ps.legsAnim==BOTH_MELEE1 || 
+		NPC->client->ps.legsAnim==BOTH_MELEE2
+		);
+}
+
+void NPC_BSFollowLeader_LookAtLeader(void)
+{
+	vec3_t	head, leaderHead, delta, angleToLeader;
+
+	CalcEntitySpot( NPC->client->leader, SPOT_HEAD, leaderHead );
+	CalcEntitySpot( NPC, SPOT_HEAD, head );
+	VectorSubtract (leaderHead, head, delta);
+	vectoangles ( delta, angleToLeader );
+	VectorNormalize(delta);
+	NPC->NPC->desiredYaw = angleToLeader[YAW];
+	NPC->NPC->desiredPitch = angleToLeader[PITCH];
+	
+	NPC_UpdateAngles(qtrue, qtrue);
+}
+
+void NPC_BSFollowLeader (void)
+{
+	// If In A Jump, Return
+	//----------------------
+	if (NPC_Jumping())
+	{
+		return;
+	}
+
+	// If There Is No Leader, Return
+	//-------------------------------
+	if (!NPC_BSFollowLeader_UpdateLeader())
+	{
+		return;
+	}
+
+	// Don't Do Anything Else If In A Full Body Attack
+	//-------------------------------------------------
+	if (NPC_BSFollowLeader_InFullBodyAttack())
+	{
+		return;
+	}
+
+	// Update The Enemy
+	//------------------
+	NPC_BSFollowLeader_UpdateEnemy();
+
+
+	// Do Any Attacking
+	//------------------
+	if (NPC_BSFollowLeader_CanAttack())
+	{
+		if (NPC_BSFollowLeader_AttackEnemy())
+		{
+			return;
+		}
+	}
+	else
+	{
+		NPC_BSFollowLeader_LookAtLeader();
+	}
+
+
+
+
+
+
+	float	followDist = (NPCInfo->followDist)?(NPCInfo->followDist):(110.0f);
+	bool	moveSuccess;
+
+ 	STEER::Activate(NPC);
+	{
+		if (NPC->client->leader->client && NPC->client->leader->client->ps.groundEntityNum!=ENTITYNUM_NONE)
+		{
+			// If Too Close, Back Away Some
+			//------------------------------
+			if (STEER::Reached(NPC, NPC->client->leader, 65.0f))    
+			{ 
+				STEER::Evade(NPC, NPC->client->leader);
+			}
+			else
+			{
+				// Attempt To Steer Directly To Our Goal
+				//---------------------------------------
+				moveSuccess = STEER::GoTo(NPC,  NPC->client->leader, followDist);
+
+				// Perhaps Not Close Enough?  Try To Use The Navigation Grid
+				//-----------------------------------------------------------
+				if (!moveSuccess)
+				{
+					moveSuccess = NAV::GoTo(NPC, NPC->client->leader);
+					if (!moveSuccess)
+					{
+						STEER::Stop(NPC);
+					}
+				}
+			}
+		}
+		else
+		{
+			STEER::Stop(NPC);
+		}
+	}
+	STEER::DeActivate(NPC, &ucmd);
+}
+
+
+
+#define	APEX_HEIGHT		200.0f
+#define	PARA_WIDTH		(sqrt(APEX_HEIGHT)+sqrt(APEX_HEIGHT))
+#define	JUMP_SPEED		200.0f
+void NPC_BSJump (void)
+{
+	vec3_t		dir, angles, p1, p2, apex;
+	float		time, height, forward, z, xy, dist, yawError, apexHeight;
+
+	if( !NPCInfo->goalEntity )
+	{//Should have task completed the navgoal
+		return;
+	}
+
+	if ( NPCInfo->jumpState != JS_JUMPING && NPCInfo->jumpState != JS_LANDING )
+	{
+		//Face navgoal
+		VectorSubtract(NPCInfo->goalEntity->currentOrigin, NPC->currentOrigin, dir);
+		vectoangles(dir, angles);
+		NPCInfo->desiredPitch = NPCInfo->lockedDesiredPitch = AngleNormalize360(angles[PITCH]);
+		NPCInfo->desiredYaw = NPCInfo->lockedDesiredYaw = AngleNormalize360(angles[YAW]);
+	}
+
+	NPC_UpdateAngles ( qtrue, qtrue );
+	yawError = AngleDelta ( NPC->client->ps.viewangles[YAW], NPCInfo->desiredYaw );
+	//We don't really care about pitch here
+
+	switch ( NPCInfo->jumpState )
+	{
+	case JS_FACING:
+		if ( yawError < MIN_ANGLE_ERROR )
+		{//Facing it, Start crouching
+			NPC_SetAnim(NPC, SETANIM_LEGS, BOTH_CROUCH1, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD);
+			NPCInfo->jumpState = JS_CROUCHING;
+		}
+		break;
+	case JS_CROUCHING:
+		if ( NPC->client->ps.legsAnimTimer > 0 )
+		{//Still playing crouching anim
+			return;
+		}
+
+		//Create a parabola
+
+		if ( NPC->currentOrigin[2] > NPCInfo->goalEntity->currentOrigin[2] )
+		{
+			VectorCopy( NPC->currentOrigin, p1 );
+			VectorCopy( NPCInfo->goalEntity->currentOrigin, p2 );
+		}
+		else if ( NPC->currentOrigin[2] < NPCInfo->goalEntity->currentOrigin[2] )
+		{
+			VectorCopy( NPCInfo->goalEntity->currentOrigin, p1 );
+			VectorCopy( NPC->currentOrigin, p2 );
+		}
+		else
+		{
+			VectorCopy( NPC->currentOrigin, p1 );
+			VectorCopy( NPCInfo->goalEntity->currentOrigin, p2 );
+		}
+
+		//z = xy*xy
+		VectorSubtract( p2, p1, dir );
+		dir[2] = 0;
+
+		//Get xy and z diffs
+		xy = VectorNormalize( dir );
+		z = p1[2] - p2[2];
+
+		apexHeight = APEX_HEIGHT/2;
+		/*
+		//Determine most desirable apex height
+		apexHeight = (APEX_HEIGHT * PARA_WIDTH/xy) + (APEX_HEIGHT * z/128);
+		if ( apexHeight < APEX_HEIGHT * 0.5 )
+		{
+			apexHeight = APEX_HEIGHT*0.5;
+		}
+		else if ( apexHeight > APEX_HEIGHT * 2 )
+		{
+			apexHeight = APEX_HEIGHT*2;
+		}
+		*/
+
+		//FIXME: length of xy will change curve of parabola, need to account for this
+		//somewhere... PARA_WIDTH
+		
+		z = (sqrt(apexHeight + z) - sqrt(apexHeight));
+
+		assert(z >= 0);
+
+//		gi.Printf("apex is %4.2f percent from p1: ", (xy-z)*0.5/xy*100.0f);
+
+		xy -= z;
+		xy *= 0.5;
+		
+		assert(xy > 0);
+
+		VectorMA( p1, xy, dir, apex );
+		apex[2] += apexHeight;
+	
+		VectorCopy(apex, NPC->pos1);
+		
+		//Now we have the apex, aim for it
+		height = apex[2] - NPC->currentOrigin[2];
+		time = sqrt( height / ( .5 * NPC->client->ps.gravity ) );
+		if ( !time ) 
+		{
+//			gi.Printf("ERROR no time in jump\n");
+			return;
+		}
+
+		// set s.origin2 to the push velocity
+		VectorSubtract ( apex, NPC->currentOrigin, NPC->client->ps.velocity );
+		NPC->client->ps.velocity[2] = 0;
+		dist = VectorNormalize( NPC->client->ps.velocity );
+
+		forward = dist / time;
+		VectorScale( NPC->client->ps.velocity, forward, NPC->client->ps.velocity );
+
+		NPC->client->ps.velocity[2] = time * NPC->client->ps.gravity;
+
+//		gi.Printf( "%s jumping %s, gravity at %4.0f percent\n", NPC->targetname, vtos(NPC->client->ps.velocity), NPC->client->ps.gravity/8.0f );
+
+		NPCInfo->jumpState = JS_JUMPING;
+		//FIXME: jumpsound?
+		break;
+	case JS_JUMPING:
+
+		if ( showBBoxes )
+		{
+			VectorAdd(NPC->mins, NPC->pos1, p1);
+			VectorAdd(NPC->maxs, NPC->pos1, p2);
+			CG_Cube( p1, p2, NPCDEBUG_BLUE, 0.5 );
+		}
+
+		if ( NPC->s.groundEntityNum != ENTITYNUM_NONE)
+		{//Landed, start landing anim
+			//FIXME: if the 
+			VectorClear(NPC->client->ps.velocity); 
+			NPC_SetAnim(NPC, SETANIM_BOTH, BOTH_LAND1, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD);
+			NPCInfo->jumpState = JS_LANDING;
+			//FIXME: landsound?
+		}
+		else if ( NPC->client->ps.legsAnimTimer > 0 )
+		{//Still playing jumping anim
+			//FIXME: apply jump velocity here, a couple frames after start, not right away
+			return;
+		}
+		else
+		{//still in air, but done with jump anim, play inair anim
+			NPC_SetAnim(NPC, SETANIM_BOTH, BOTH_INAIR1, SETANIM_FLAG_OVERRIDE);
+		}
+		break;
+	case JS_LANDING:
+		if ( NPC->client->ps.legsAnimTimer > 0 )
+		{//Still playing landing anim
+			return;
+		}
+		else
+		{
+			NPCInfo->jumpState = JS_WAITING;
+
+			NPCInfo->goalEntity = UpdateGoal();
+			// If he made it to his goal or his task is no longer pending.
+			if ( !NPCInfo->goalEntity || !Q3_TaskIDPending( NPC, TID_MOVE_NAV ) )
+			{
+				NPC_ClearGoal();
+				NPCInfo->goalTime = level.time;
+				NPCInfo->aiFlags &= ~NPCAI_MOVING;
+				ucmd.forwardmove = 0;
+				NPC->flags &= ~FL_NO_KNOCKBACK;
+				//Return that the goal was reached
+				Q3_TaskIDComplete( NPC, TID_MOVE_NAV );
+			}
+		}
+		break;
+	case JS_WAITING:
+	default:
+		NPCInfo->jumpState = JS_FACING;
+		break;
+	}
+}
+
+void NPC_BSRemove (void)
+{
+	NPC_UpdateAngles ( qtrue, qtrue );
+	if( !gi.inPVS( NPC->currentOrigin, g_entities[0].currentOrigin ) )//FIXME: use cg.vieworg?
+	{
+		G_UseTargets2( NPC, NPC, NPC->target3 );
+		NPC->s.eFlags |= EF_NODRAW;
+		NPC->svFlags &= ~SVF_NPC;
+		NPC->s.eType = ET_INVISIBLE;
+		NPC->contents = 0;
+		NPC->health = 0;
+		NPC->targetname = NULL;
+
+		//Disappear in half a second
+		NPC->e_ThinkFunc = thinkF_G_FreeEntity;
+		NPC->nextthink = level.time + FRAMETIME;
+	}//FIXME: else allow for out of FOV???
+}
+
+void NPC_BSSearch (void)
+{
+	NPC_CheckAlertEvents(qtrue, qtrue, -1, qfalse, AEL_DANGER, qfalse);
+	//FIXME: do something with these alerts...?
+	//FIXME: do the Stormtrooper alert reaction?  (investigation)
+	if ( (NPCInfo->scriptFlags&SCF_LOOK_FOR_ENEMIES)
+		&& NPC->client->enemyTeam != TEAM_NEUTRAL )
+	{//look for enemies
+		NPC_CheckEnemy(qtrue, qfalse);
+		if ( NPC->enemy )
+		{//found one
+			if( NPCInfo->tempBehavior == BS_SEARCH )
+			{//if tempbehavior, set tempbehavior to default
+				NPCInfo->tempBehavior = BS_DEFAULT;
+			}
+			else
+			{//if bState, change to run and shoot
+				NPCInfo->behaviorState = BS_DEFAULT;//BS_HUNT_AND_KILL;
+				//NPC_BSRunAndShoot();
+			}
+			return;
+		}
+	}
+
+	//FIXME: what if our goalEntity is not NULL and NOT our tempGoal - they must
+	//want us to do something else?  If tempBehavior, just default, else set
+	//to run and shoot...?
+
+	//FIXME: Reimplement
+
+	if ( !NPCInfo->investigateDebounceTime )
+	{//On our way to a tempGoal
+		float	minGoalReachedDistSquared = 32*32;
+		vec3_t	vec;
+
+		//Keep moving toward our tempGoal
+		NPCInfo->goalEntity = NPCInfo->tempGoal;
+
+		VectorSubtract ( NPCInfo->tempGoal->currentOrigin, NPC->currentOrigin, vec);
+		if ( vec[2] < 24 )
+		{
+			vec[2] = 0;
+		}
+
+		if ( NPCInfo->tempGoal->waypoint != WAYPOINT_NONE )
+		{
+			/*
+			//FIXME: can't get the radius...
+			float	wpRadSq = waypoints[NPCInfo->tempGoal->waypoint].radius * waypoints[NPCInfo->tempGoal->waypoint].radius;
+			if ( minGoalReachedDistSquared > wpRadSq )
+			{
+				minGoalReachedDistSquared = wpRadSq;
+			}
+			*/
+
+			minGoalReachedDistSquared = 32*32;//12*12;
+		}
+
+		if ( VectorLengthSquared( vec ) < minGoalReachedDistSquared )
+		{
+			//Close enough, just got there
+			NPC->waypoint = NAV::GetNearestNode(NPC);
+
+			if ( ( NPCInfo->homeWp == WAYPOINT_NONE ) || ( NPC->waypoint == WAYPOINT_NONE ) )
+			{
+				//Heading for or at an invalid waypoint, get out of this bState
+				if( NPCInfo->tempBehavior == BS_SEARCH )
+				{//if tempbehavior, set tempbehavior to default
+					NPCInfo->tempBehavior = BS_DEFAULT;
+				}
+				else
+				{//if bState, change to stand guard
+					NPCInfo->behaviorState = BS_STAND_GUARD;
+					NPC_BSRunAndShoot();
+				}
+				return;
+			}
+
+			if ( NPC->waypoint == NPCInfo->homeWp )
+			{
+				//Just Reached our homeWp, if this is the first time, run your lostenemyscript
+				if ( NPCInfo->aiFlags & NPCAI_ENROUTE_TO_HOMEWP )
+				{
+					NPCInfo->aiFlags &= ~NPCAI_ENROUTE_TO_HOMEWP;
+					G_ActivateBehavior( NPC, BSET_LOSTENEMY );
+				}
+
+			}
+
+			//gi.Printf("Got there.\n");
+			//gi.Printf("Looking...");
+			if( !Q_irand(0, 1) )
+			{
+				NPC_SetAnim(NPC, SETANIM_BOTH, BOTH_GUARD_LOOKAROUND1, SETANIM_FLAG_NORMAL);
+			}
+			else
+			{
+				NPC_SetAnim(NPC, SETANIM_BOTH, BOTH_GUARD_IDLE1, SETANIM_FLAG_NORMAL);
+			}
+			NPCInfo->investigateDebounceTime = level.time + Q_irand(3000, 10000);
+		}
+		else
+		{
+			NPC_MoveToGoal( qtrue );
+		}
+	}
+	else
+	{
+		//We're there
+		if ( NPCInfo->investigateDebounceTime > level.time )
+		{
+			//Still waiting around for a bit
+			//Turn angles every now and then to look around
+			if ( NPCInfo->tempGoal->waypoint != WAYPOINT_NONE )
+			{
+				if ( !Q_irand( 0, 30 ) )
+				{
+					// NAV_TODO: What if there are no neighbors?
+					vec3_t	branchPos, lookDir;
+
+					NAV::GetNodePosition(NAV::ChooseRandomNeighbor(NPCInfo->tempGoal->waypoint), branchPos);
+					
+					VectorSubtract( branchPos, NPCInfo->tempGoal->currentOrigin, lookDir );
+					NPCInfo->desiredYaw = AngleNormalize360( vectoyaw( lookDir ) + Q_flrand( -45, 45 ) );
+				}
+			}
+			//gi.Printf(".");
+		}
+		else
+		{//Just finished waiting
+			NPC->waypoint = NAV::GetNearestNode(NPC);
+
+			if ( NPC->waypoint == NPCInfo->homeWp )
+			{
+				// NAV_TODO: What if there are no neighbors?
+
+				int nextWp = NAV::ChooseRandomNeighbor(NPCInfo->tempGoal->waypoint);
+				NAV::GetNodePosition(nextWp, NPCInfo->tempGoal->currentOrigin);
+				NPCInfo->tempGoal->waypoint = nextWp;
+
+			}
+			else
+			{//At a branch, so return home
+				NAV::GetNodePosition(NPCInfo->homeWp, NPCInfo->tempGoal->currentOrigin);
+				NPCInfo->tempGoal->waypoint = NPCInfo->homeWp;
+			}
+
+			NPCInfo->investigateDebounceTime = 0;
+			//Start moving toward our tempGoal
+			NPCInfo->goalEntity = NPCInfo->tempGoal;
+			NPC_MoveToGoal( qtrue );
+		}
+	}
+
+	NPC_UpdateAngles( qtrue, qtrue );
+}
+
+/*
+-------------------------
+NPC_BSSearchStart
+-------------------------
+*/
+
+void NPC_BSSearchStart( int homeWp, bState_t bState )
+{
+	//FIXME: Reimplement
+	NPCInfo->homeWp = homeWp;
+	NPCInfo->tempBehavior = bState;
+	NPCInfo->aiFlags |= NPCAI_ENROUTE_TO_HOMEWP;
+	NPCInfo->investigateDebounceTime = 0;
+	NAV::GetNodePosition(homeWp, NPCInfo->tempGoal->currentOrigin);
+	NPCInfo->tempGoal->waypoint = homeWp;
+	//gi.Printf("\nHeading for wp %d...\n", NPCInfo->homeWp);
+}
+
+/*
+-------------------------
+NPC_BSNoClip
+
+  Use in extreme circumstances only
+-------------------------
+*/
+
+void NPC_BSNoClip ( void )
+{
+	if ( UpdateGoal() )
+	{
+		vec3_t	dir, forward, right, angles, up = {0, 0, 1};
+		float	fDot, rDot, uDot;
+
+		VectorSubtract( NPCInfo->goalEntity->currentOrigin, NPC->currentOrigin, dir );
+		
+		vectoangles( dir, angles );
+		NPCInfo->desiredYaw = angles[YAW];
+
+		AngleVectors( NPC->currentAngles, forward, right, NULL );
+
+		VectorNormalize( dir );
+
+		fDot = DotProduct(forward, dir) * 127;
+		rDot = DotProduct(right, dir) * 127;
+		uDot = DotProduct(up, dir) * 127;
+
+		ucmd.forwardmove = floor(fDot);
+		ucmd.rightmove = floor(rDot);
+		ucmd.upmove = floor(uDot);
+	}
+	else
+	{
+		//Cut velocity?
+		VectorClear( NPC->client->ps.velocity );
+	}
+
+	NPC_UpdateAngles( qtrue, qtrue );
+}
+
+void NPC_BSWander (void)
+{//FIXME: don't actually go all the way to the next waypoint, just move in fits and jerks...?
+
+	NPC_CheckAlertEvents(qtrue, qtrue, -1, qfalse, AEL_DANGER, qfalse);
+	//FIXME: do something with these alerts...?
+	//FIXME: do the Stormtrooper alert reaction?  (investigation)
+	if ( (NPCInfo->scriptFlags&SCF_LOOK_FOR_ENEMIES)
+		&& NPC->client->enemyTeam != TEAM_NEUTRAL )
+	{//look for enemies
+		NPC_CheckEnemy(qtrue, qfalse);
+		if ( NPC->enemy )
+		{//found one
+			if( NPCInfo->tempBehavior == BS_WANDER )
+			{//if tempbehavior, set tempbehavior to default
+				NPCInfo->tempBehavior = BS_DEFAULT;
+			}
+			else
+			{//if bState, change to run and shoot
+				NPCInfo->behaviorState = BS_DEFAULT;//BS_HUNT_AND_KILL;
+				//NPC_BSRunAndShoot();
+			}
+			return;
+		}
+	}
+
+	STEER::Activate(NPC);
+
+
+	// Are We Doing A Path?
+	//----------------------
+	bool	HasPath = NAV::HasPath(NPC);
+	if (HasPath)
+	{
+		HasPath = NAV::UpdatePath(NPC);
+		if (HasPath)
+		{
+			STEER::Path(NPC);	// Follow The Path
+			STEER::AvoidCollisions(NPC);
+
+			if ((NPCInfo->aiFlags&NPCAI_BLOCKED) &&	(level.time-NPCInfo->blockedDebounceTime)>1000)
+			{
+				HasPath = false;// find a new one
+			}
+		}
+	}
+
+	if (!HasPath)
+	{
+		// If Debounce Time Has Expired, Choose A New Sub State
+		//------------------------------------------------------
+	 	if (NPCInfo->investigateDebounceTime<level.time || 
+			((NPCInfo->aiFlags&NPCAI_BLOCKED) &&	(level.time-NPCInfo->blockedDebounceTime)>1000))
+		{
+			// Clear Out Flags From The Previous Substate
+			//--------------------------------------------
+			NPCInfo->aiFlags	&= ~NPCAI_OFF_PATH;
+			NPCInfo->aiFlags	&= ~NPCAI_WALKING;
+
+
+			// Pick Another Spot
+			//-------------------
+			int		NEXTSUBSTATE = Q_irand(0, 10);
+
+			bool	RandomPathNode = (NEXTSUBSTATE<9);  //(NEXTSUBSTATE<4);
+			bool	PathlessWander = false;				//(NEXTSUBSTATE<9)
+
+			
+
+			// Random Path Node
+			//------------------
+			if (RandomPathNode)
+			{
+				// Sometimes, Walk
+				//-----------------
+				if (Q_irand(0, 1)==0)
+				{
+					NPCInfo->aiFlags	|= NPCAI_WALKING;
+				}
+
+				NPCInfo->investigateDebounceTime = level.time + Q_irand(3000, 10000);
+				NAV::FindPath(NPC, NAV::ChooseRandomNeighbor(NAV::GetNearestNode(NPC)));
+			}
+
+			// Pathless Wandering
+			//--------------------
+			else if (PathlessWander)
+			{
+				// Sometimes, Walk
+				//-----------------
+				if (Q_irand(0, 1)==0)
+				{
+					NPCInfo->aiFlags	|= NPCAI_WALKING;
+				}
+
+				NPCInfo->investigateDebounceTime = level.time + Q_irand(3000, 10000);
+				NPCInfo->aiFlags |= NPCAI_OFF_PATH;
+			}
+
+			// Just Stand Here
+			//-----------------
+			else
+			{
+				NPCInfo->investigateDebounceTime = level.time + Q_irand(2000, 10000);
+				NPC_SetAnim(NPC, SETANIM_BOTH, ((Q_irand(0, 1)==0)?(BOTH_GUARD_LOOKAROUND1):(BOTH_GUARD_IDLE1)), SETANIM_FLAG_NORMAL);
+			}
+		}
+
+		// Ok, So We Don't Have A Path, And Debounce Time Is Still Active, So We Are Either Wandering Or Looking Around
+		//--------------------------------------------------------------------------------------------------------------
+		else
+		{
+			if (NPCInfo->aiFlags & NPCAI_OFF_PATH)
+			{
+				STEER::Wander(NPC);
+				STEER::AvoidCollisions(NPC);
+			}
+			else
+			{
+				STEER::Stop(NPC);
+			}
+		}
+	}
+	STEER::DeActivate(NPC, &ucmd);
+
+	NPC_UpdateAngles( qtrue, qtrue );
+	return;
+}
+
+/*
+void NPC_BSFaceLeader (void)
+{
+	vec3_t	head, leaderHead, delta, angleToLeader;
+
+	if ( !NPC->client->leader )
+	{//uh.... okay.
+		return;
+	}
+
+	CalcEntitySpot( NPC->client->leader, SPOT_HEAD, leaderHead );
+	CalcEntitySpot( NPC, SPOT_HEAD, head );
+	VectorSubtract( leaderHead, head, delta );
+	vectoangles( delta, angleToLeader );
+	VectorNormalize( delta );
+	NPC->NPC->desiredYaw = angleToLeader[YAW];
+	NPC->NPC->desiredPitch = angleToLeader[PITCH];
+	
+	NPC_UpdateAngles(qtrue, qtrue);
+}
+*/
+/*
+-------------------------
+NPC_BSFlee
+-------------------------
+*/
+extern void G_AddVoiceEvent( gentity_t *self, int event, int speakDebounceTime );
+extern void WP_DropWeapon( gentity_t *dropper, vec3_t velocity );
+extern void ChangeWeapon( gentity_t *ent, int newWeapon );
+extern int g_crosshairEntNum;
+qboolean NPC_CanSurrender( void )
+{
+	if ( NPC->client )
+	{
+		switch ( NPC->client->NPC_class )
+		{
+		case CLASS_ATST:
+		case CLASS_CLAW:
+		case CLASS_DESANN:
+		case CLASS_FISH:
+		case CLASS_FLIER2:
+		case CLASS_GALAK:
+		case CLASS_GLIDER:
+		case CLASS_GONK:				// droid
+		case CLASS_HOWLER:
+		case CLASS_RANCOR:
+		case CLASS_SAND_CREATURE:
+		case CLASS_WAMPA:
+		case CLASS_INTERROGATOR:		// droid 
+		case CLASS_JAN:				
+		case CLASS_JEDI:				
+		case CLASS_KYLE:
+		case CLASS_LANDO:			
+		case CLASS_LIZARD:
+		case CLASS_LUKE:				
+		case CLASS_MARK1:			// droid
+		case CLASS_MARK2:			// droid
+		case CLASS_GALAKMECH:		// droid
+		case CLASS_MINEMONSTER:
+		case CLASS_MONMOTHA:			
+		case CLASS_MORGANKATARN:
+		case CLASS_MOUSE:			// droid
+		case CLASS_MURJJ:
+		case CLASS_PROBE:			// droid
+		case CLASS_PROTOCOL:			// droid
+		case CLASS_R2D2:				// droid
+		case CLASS_R5D2:				// droid
+		case CLASS_REBORN:
+		case CLASS_REELO:
+		case CLASS_REMOTE:
+		case CLASS_SEEKER:			// droid
+		case CLASS_SENTRY:
+		case CLASS_SHADOWTROOPER:
+		case CLASS_SWAMP:
+		case CLASS_TAVION:
+		case CLASS_ALORA:
+		case CLASS_TUSKEN:
+		case CLASS_BOBAFETT:
+		case CLASS_ROCKETTROOPER:
+		case CLASS_SABER_DROID:
+		case CLASS_ASSASSIN_DROID:
+		case CLASS_HAZARD_TROOPER:
+		case CLASS_PLAYER:
+		case CLASS_VEHICLE:
+			return qfalse;
+			break;
+		}
+		if ( !G_StandardHumanoid( NPC ) )
+		{
+			return qfalse;
+		}
+		if ( NPC->client->ps.weapon == WP_SABER )
+		{
+			return qfalse;
+		}
+	}
+	if ( NPCInfo )
+	{
+		if ( (NPCInfo->aiFlags&NPCAI_BOSS_CHARACTER) )
+		{
+			return qfalse;
+		}
+		if ( (NPCInfo->aiFlags&NPCAI_SUBBOSS_CHARACTER) )
+		{
+			return qfalse;
+		}
+		if ( (NPCInfo->aiFlags&NPCAI_ROSH) )
+		{
+			return qfalse;
+		}
+		if ( (NPCInfo->aiFlags&NPCAI_HEAL_ROSH) )
+		{
+			return qfalse;
+		}
+	}
+	return qtrue;
+}
+
+void NPC_Surrender( void )
+{//FIXME: say "don't shoot!" if we weren't already surrendering
+	if ( NPC->client->ps.weaponTime || PM_InKnockDown( &NPC->client->ps ) )
+	{
+		return;
+	}
+	if ( !NPC_CanSurrender() )
+	{
+		return;
+	}
+	if ( NPC->s.weapon != WP_NONE && 
+		NPC->s.weapon != WP_MELEE &&
+		NPC->s.weapon != WP_SABER )
+	{
+		WP_DropWeapon( NPC, NULL );
+	}
+	if ( NPCInfo->surrenderTime < level.time - 5000 )
+	{//haven't surrendered for at least 6 seconds, tell them what you're doing
+		//FIXME: need real dialogue EV_SURRENDER
+		NPCInfo->blockedSpeechDebounceTime = 0;//make sure we say this
+		G_AddVoiceEvent( NPC, Q_irand( EV_PUSHED1, EV_PUSHED3 ), 3000 );
+	}
+
+	// Already Surrendering?  If So, Just Update Animations
+	//------------------------------------------------------
+	if (NPCInfo->surrenderTime>level.time)
+	{
+		if (NPC->client->ps.torsoAnim==BOTH_COWER1_START && NPC->client->ps.torsoAnimTimer<=100)
+		{
+		 	NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_COWER1, SETANIM_FLAG_HOLD|SETANIM_FLAG_OVERRIDE );
+	 	 	NPCInfo->surrenderTime = level.time + NPC->client->ps.torsoAnimTimer;
+		}
+ 		if (NPC->client->ps.torsoAnim==BOTH_COWER1 && NPC->client->ps.torsoAnimTimer<=100)
+		{
+			NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_COWER1_STOP, SETANIM_FLAG_HOLD|SETANIM_FLAG_OVERRIDE );
+		 	NPCInfo->surrenderTime = level.time + NPC->client->ps.torsoAnimTimer;
+		}
+	}
+
+	// New To The Surrender, So Start The Animation
+	//----------------------------------------------
+	else
+	{
+		if ( NPC->client->NPC_class == CLASS_JAWA && NPC->client->ps.weapon == WP_NONE )
+		{//an unarmed Jawa is very scared
+			NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_COWER1, SETANIM_FLAG_HOLD|SETANIM_FLAG_OVERRIDE );
+			//FIXME: stop doing this if decide to take off and run
+		}
+		else
+		{
+			// A Big Monster?  OR: Being Tracked By A Homing Rocket?  So Do The Cower Sequence
+			//------------------------------------------
+			if ( (NPC->enemy && NPC->enemy->client && NPC->enemy->client->NPC_class==CLASS_RANCOR) || !TIMER_Done( NPC, "rocketChasing" ) )
+			{
+				NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_COWER1_START, SETANIM_FLAG_HOLD|SETANIM_FLAG_OVERRIDE );
+			}
+
+			// Otherwise, Use The Old Surrender "Arms In Air" Animation
+			//----------------------------------------------------------
+			else
+			{
+				NPC_SetAnim( NPC, SETANIM_TORSO, TORSO_SURRENDER_START, SETANIM_FLAG_HOLD|SETANIM_FLAG_OVERRIDE );
+				NPC->client->ps.torsoAnimTimer = Q_irand(3000, 8000);				// Pretend the anim lasts longer
+			}
+		}
+	 	NPCInfo->surrenderTime = level.time + NPC->client->ps.torsoAnimTimer + 1000;
+	}
+}
+
+qboolean NPC_CheckSurrender( void )
+{
+	if ( !g_AIsurrender->integer 
+		&& NPC->client->NPC_class != CLASS_UGNAUGHT 
+		&& NPC->client->NPC_class != CLASS_JAWA )
+	{//not enabled
+		return qfalse;
+	}
+	if ( !Q3_TaskIDPending( NPC, TID_MOVE_NAV ) //not scripted to go somewhere
+		&& NPC->client->ps.groundEntityNum != ENTITYNUM_NONE //not in the air
+		&& !NPC->client->ps.weaponTime && !PM_InKnockDown( &NPC->client->ps )//not firing and not on the ground
+		&& NPC->enemy && NPC->enemy->client && NPC->enemy->enemy == NPC && NPC->enemy->s.weapon != WP_NONE && (NPC->enemy->s.weapon != WP_MELEE || (NPC->enemy->client->NPC_class == CLASS_RANCOR||NPC->enemy->client->NPC_class == CLASS_WAMPA) )//enemy is using a weapon or is a Rancor or Wampa
+		&& NPC->enemy->health > 20 && NPC->enemy->painDebounceTime < level.time - 3000 && NPC->enemy->client->ps.forcePowerDebounce[FP_SABER_DEFENSE] < level.time - 1000 )
+	{//don't surrender if scripted to run somewhere or if we're in the air or if we're busy or if we don't have an enemy or if the enemy is not mad at me or is hurt or not a threat or busy being attacked
+		//FIXME: even if not in a group, don't surrender if there are other enemies in the PVS and within a certain range?
+		if ( NPC->s.weapon != WP_ROCKET_LAUNCHER 
+			&& NPC->s.weapon != WP_CONCUSSION
+			&& NPC->s.weapon != WP_REPEATER
+			&& NPC->s.weapon != WP_FLECHETTE
+			&& NPC->s.weapon != WP_SABER )
+		{//jedi and heavy weapons guys never surrender
+			//FIXME: rework all this logic into some orderly fashion!!!
+			if ( NPC->s.weapon != WP_NONE )
+			{//they have a weapon so they'd have to drop it to surrender
+				//don't give up unless low on health
+				if ( NPC->health > 25 || NPC->health >= NPC->max_health )
+				{
+					return qfalse;
+				}
+				if ( g_crosshairEntNum == NPC->s.number && NPC->painDebounceTime > level.time )
+				{//if he just shot me, always give up
+					//fall through
+				}
+				else
+				{//don't give up unless facing enemy and he's very close
+					if ( !InFOV( player, NPC, 60, 30 ) )
+					{//I'm not looking at them
+						return qfalse;
+					}
+					else if ( DistanceSquared( NPC->currentOrigin, player->currentOrigin ) < 65536/*256*256*/ )
+					{//they're not close
+						return qfalse;
+					}
+					else if ( !gi.inPVS( NPC->currentOrigin, player->currentOrigin ) )
+					{//they're not in the same room
+						return qfalse;
+					}
+				}
+			}
+			if ( !NPCInfo->group || (NPCInfo->group && NPCInfo->group->numGroup <= 1) )
+			{//I'm alone but I was in a group//FIXME: surrender anyway if just melee or no weap?
+				if ( NPC->s.weapon == WP_NONE 
+					//NPC has a weapon
+					|| NPC->enemy == player
+					|| (NPC->enemy->s.weapon == WP_SABER&&NPC->enemy->client&&NPC->enemy->client->ps.SaberActive())
+					|| (NPC->enemy->NPC && NPC->enemy->NPC->group && NPC->enemy->NPC->group->numGroup > 2) )
+				{//surrender only if have no weapon or fighting a player or jedi or if we are outnumbered at least 3 to 1
+					if ( NPC->enemy == player )
+					{//player is the guy I'm running from
+						if ( g_crosshairEntNum == NPC->s.number )
+						{//give up if player is aiming at me
+							NPC_Surrender();
+							NPC_UpdateAngles( qtrue, qtrue );
+							return qtrue;
+						}
+						else if ( player->s.weapon == WP_SABER )
+						{//player is using saber
+							if ( InFOV( NPC, player, 60, 30 ) )
+							{//they're looking at me
+								if ( DistanceSquared( NPC->currentOrigin, player->currentOrigin ) < 16384/*128*128*/ )
+								{//they're close
+									if ( gi.inPVS( NPC->currentOrigin, player->currentOrigin ) )
+									{//they're in the same room
+										NPC_Surrender();
+										NPC_UpdateAngles( qtrue, qtrue );
+										return qtrue;
+									}
+								}
+							}
+						}
+					}
+					else if ( NPC->enemy )
+					{//???
+						//should NPC's surrender to others?
+						if ( InFOV( NPC, NPC->enemy, 30, 30 ) )
+						{//they're looking at me
+							float maxDist = (64+(NPC->maxs[0]*1.5)+(NPC->enemy->maxs[0]*1.5));
+							maxDist *= maxDist;
+							if ( DistanceSquared( NPC->currentOrigin, NPC->enemy->currentOrigin ) < maxDist )
+							{//they're close
+								if ( gi.inPVS( NPC->currentOrigin, NPC->enemy->currentOrigin ) )
+								{//they're in the same room
+									//FIXME: should player-team NPCs not fire on surrendered NPCs?
+									NPC_Surrender();
+									NPC_UpdateAngles( qtrue, qtrue );
+									return qtrue;
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+	return qfalse;
+}
+
+void NPC_JawaFleeSound( void )
+{
+	if ( NPC
+		&& NPC->client
+		&& NPC->client->NPC_class == CLASS_JAWA
+		&& !Q_irand( 0, 3 ) 
+		&& NPCInfo->blockedSpeechDebounceTime < level.time
+		&& !Q3_TaskIDPending(NPC, TID_CHAN_VOICE ) )
+	{//ooteenee!!!!  
+		//Com_Printf( "ooteenee!!!!\n" ); 
+		G_SoundOnEnt(NPC, CHAN_VOICE, "sound/chars/jawa/misc/ooh-tee-nee.wav" );
+		NPCInfo->blockedSpeechDebounceTime = level.time + 2000;
+	}
+}
+
+extern gentity_t *NPC_SearchForWeapons( void );
+extern qboolean G_CanPickUpWeapons( gentity_t *other );
+qboolean NPC_BSFlee( void )
+{
+	bool		enemyRecentlySeen	= false;
+	float		enemyTooCloseDist	= 50.0f;
+	bool		reachedEscapePoint	= false; 
+	bool		hasEscapePoint		= false;
+	bool		moveSuccess			= false;
+	bool		inSurrender			= (level.time<NPCInfo->surrenderTime);
+
+
+
+	// Check For Enemies And Alert Events
+	//------------------------------------
+	NPC_CheckEnemy(qtrue, qfalse);
+	NPC_CheckAlertEvents(qtrue, qtrue, -1, qfalse, AEL_DANGER, qfalse);
+	if (NPC->enemy && G_ClearLOS(NPC, NPC->enemy))
+	{
+		NPCInfo->enemyLastSeenTime = level.time;
+	}
+	enemyRecentlySeen = (NPC->enemy && (level.time - NPCInfo->enemyLastSeenTime)<3000);
+	if (enemyRecentlySeen)
+	{
+		if (NPC->enemy->client && NPC->enemy->client->NPC_class==CLASS_RANCOR)
+		{
+			enemyTooCloseDist = 400.0f;
+		}
+		enemyTooCloseDist += NPC->maxs[0] + NPC->enemy->maxs[0];
+	}
+
+
+	// Look For Weapons To Pick Up
+	//-----------------------------
+	if (enemyRecentlySeen &&						// Is There An Enemy Near?
+		NPC->client->NPC_class!=CLASS_PRISONER &&	// Prisoners can't pickup weapons
+		NPCInfo->rank>RANK_CIVILIAN &&				// Neither can civilians
+		TIMER_Done(NPC, "panic") &&					// Panic causes him to run for a bit, don't pickup weapons
+		TIMER_Done(NPC, "CheckForWeaponToPickup") && 
+		G_CanPickUpWeapons( NPC )					//Allowed To Pick Up Dropped Weapons
+		)
+	{
+		gentity_t *foundWeap = NPC_SearchForWeapons();
+
+		// Ok, There Is A Weapon!  Try Going To It!
+		//------------------------------------------
+		if (foundWeap && NAV::SafePathExists(NPC->currentOrigin, foundWeap->currentOrigin, NPC->enemy->currentOrigin, 150.0f))
+		{
+			NAV::ClearPath(NPC);				// Remove Any Old Path
+
+			NPCInfo->goalEntity = foundWeap;	// Change Our Target Goal
+			NPCInfo->goalRadius	= 30.0f;		// 30 good enough?
+
+			TIMER_Set(NPC, "CheckForWeaponToPickup", Q_irand(10000, 50000));
+		}
+
+		// Look Again Soon
+		//-----------------
+		else
+		{
+			TIMER_Set(NPC, "CheckForWeaponToPickup", Q_irand(1000, 5000));
+		}
+	}
+
+	// If Attempting To Get To An Entity That Is Gone, Clear The Pointer
+	//-------------------------------------------------------------------
+	if ( NPCInfo->goalEntity
+		&& !Q3_TaskIDPending(NPC, TID_MOVE_NAV)
+		&& NPC->enemy
+		&& Distance( NPCInfo->goalEntity->currentOrigin, NPC->enemy->currentOrigin ) < enemyTooCloseDist )
+	{
+		//our goal is too close to our enemy, dump it...
+		NPCInfo->goalEntity = NULL;
+	}
+	if (NPCInfo->goalEntity && !NPCInfo->goalEntity->inuse)
+	{
+		NPCInfo->goalEntity = 0;
+	}
+	hasEscapePoint		= (NPCInfo->goalEntity && NPCInfo->goalRadius!=0.0f);
+
+
+
+
+	STEER::Activate(NPC);
+	{
+		// Have We Reached The Escape Point?
+		//-----------------------------------
+		if (hasEscapePoint && STEER::Reached(NPC, NPCInfo->goalEntity, NPCInfo->goalRadius, false))
+		{
+			if (Q3_TaskIDPending(NPC, TID_MOVE_NAV))
+			{
+				Q3_TaskIDComplete(NPC, TID_MOVE_NAV);
+			}
+			reachedEscapePoint = true;
+		}
+
+
+		// If Super Close To The Enemy, Run In The Other Direction
+		//---------------------------------------------------------
+		if (enemyRecentlySeen && 
+			Distance(NPC->enemy->currentOrigin, NPC->currentOrigin)<enemyTooCloseDist)
+		{
+			STEER::Evade(NPC, NPC->enemy);
+			STEER::AvoidCollisions(NPC);
+		}
+
+		// If Already At The Escape Point, Or Surrendering, Don't Move
+		//-------------------------------------------------------------
+		else if (reachedEscapePoint || inSurrender)
+		{
+			STEER::Stop(NPC);
+		}
+		else
+		{
+			// Try To Get To The Escape Point
+			//--------------------------------
+			if (hasEscapePoint)
+			{
+				moveSuccess = STEER::GoTo(NPC, NPCInfo->goalEntity, true);
+				if (!moveSuccess)
+				{
+					moveSuccess = NAV::GoTo(NPC, NPCInfo->goalEntity, 0.3f);
+				}
+			}
+
+			// Cant Get To The Escape Point, So If There Is An Enemy
+			//-------------------------------------------------------
+			if (!moveSuccess && enemyRecentlySeen)
+			{
+				// Try To Get To The Farthest Combat Point From Him
+				//--------------------------------------------------
+				NAV::TNodeHandle Nbr = NAV::ChooseFarthestNeighbor(NPC, NPC->enemy->currentOrigin, 0.25f);
+				if (Nbr>0)
+				{
+					moveSuccess = STEER::GoTo(NPC, NAV::GetNodePosition(Nbr), true);
+					if (!moveSuccess)
+					{
+						moveSuccess = NAV::GoTo(NPC, Nbr, 0.3f);
+					}
+				}
+			}
+
+			// If We Still Can't (Or Don't Need To) Move, Just Stop
+			//------------------------------------------------------
+			if (!moveSuccess)
+			{
+				STEER::Stop(NPC);
+			}
+		}
+	}
+	STEER::DeActivate(NPC, &ucmd);
+
+
+	// Is There An Enemy Around?
+	//---------------------------
+	if (enemyRecentlySeen)
+	{
+		// Time To Surrender?
+		//--------------------
+		if ( TIMER_Done( NPC, "panic" ) )
+		{
+			//done panicking, time to realize we're dogmeat, if we haven't been able to flee for a few seconds
+			if ((level.time-NPC->lastMoveTime)>3000
+				&& (level.time-NPCInfo->surrenderTime) > 3000 )//and haven't just finished surrendering
+			{
+				NPC_FaceEnemy();
+				NPC_Surrender(); 
+ 			}
+		}
+ 
+		// Time To Choose A New Escape Point?
+		//------------------------------------
+		if ((!hasEscapePoint || reachedEscapePoint) && TIMER_Done(NPC, "FindNewEscapePointDebounce"))
+		{
+			TIMER_Set(NPC, "FindNewEscapePointDebounce", 2500);
+
+			int escapePoint = NPC_FindCombatPoint( 
+				NPC->currentOrigin, 
+				NPC->enemy->currentOrigin, 
+				NPC->currentOrigin, 
+				CP_COVER|CP_AVOID_ENEMY|CP_HAS_ROUTE, 
+				128 );
+			if (escapePoint!=-1)
+			{
+				NPC_JawaFleeSound();
+				NPC_SetCombatPoint(escapePoint);
+				NPC_SetMoveGoal(NPC, level.combatPoints[escapePoint].origin, 8, qtrue, escapePoint);
+			}
+		}
+	}
+
+
+	// If Only Temporarly In Flee, Think About Perhaps Returning To Combat
+	//---------------------------------------------------------------------
+	if (NPCInfo->tempBehavior==BS_FLEE &&
+		TIMER_Done(NPC, "flee") && 
+		NPC->s.weapon != WP_NONE && 
+		NPC->s.weapon != WP_MELEE
+		)
+	{
+ 		NPCInfo->tempBehavior = BS_DEFAULT;
+	}
+
+	// Always Update Angles
+	//----------------------
+	NPC_UpdateAngles( qtrue, qtrue );
+	if (reachedEscapePoint)
+	{
+		return qtrue;
+	}
+	return qfalse;
+}
+
+void NPC_StartFlee( gentity_t *enemy, vec3_t dangerPoint, int dangerLevel, int fleeTimeMin, int fleeTimeMax )
+{
+	if ( Q3_TaskIDPending( NPC, TID_MOVE_NAV ) )
+	{//running somewhere that a script requires us to go, don't interrupt that!
+		return;
+	}
+
+	if (NPCInfo->scriptFlags & SCF_DONT_FLEE )	// no flee for you
+	{
+		return;
+	}
+
+
+	//if have a fleescript, run that instead
+	if ( G_ActivateBehavior( NPC, BSET_FLEE ) )
+	{
+		return;
+	}
+
+	//FIXME: play a flee sound?  Appropriate to situation?
+	if ( enemy )
+	{
+		NPC_JawaFleeSound();
+		G_SetEnemy( NPC, enemy );
+	}
+
+
+	//FIXME: if don't have a weapon, find nearest one we have a route to and run for it?
+	int cp = -1;
+	if ( dangerLevel > AEL_DANGER || NPC->s.weapon == WP_NONE || ((!NPCInfo->group || NPCInfo->group->numGroup <= 1) && NPC->health <= 10 ) )
+	{//IF either great danger OR I have no weapon OR I'm alone and low on health, THEN try to find a combat point out of PVS
+		cp = NPC_FindCombatPoint( NPC->currentOrigin, dangerPoint, NPC->currentOrigin, CP_COVER|CP_AVOID|CP_HAS_ROUTE|CP_NO_PVS, 128 );
+	}
+	//FIXME: still happens too often...
+	if ( cp == -1 )
+	{//okay give up on the no PVS thing
+		cp = NPC_FindCombatPoint( NPC->currentOrigin, dangerPoint, NPC->currentOrigin, CP_COVER|CP_AVOID|CP_HAS_ROUTE, 128 );
+		if ( cp == -1 )
+		{//okay give up on the avoid
+			cp = NPC_FindCombatPoint( NPC->currentOrigin, dangerPoint, NPC->currentOrigin, CP_COVER|CP_HAS_ROUTE, 128 );
+			if ( cp == -1 )
+			{//okay give up on the cover
+				cp = NPC_FindCombatPoint( NPC->currentOrigin, dangerPoint, NPC->currentOrigin, CP_HAS_ROUTE, 128 );
+			}
+		}
+	}
+
+	//see if we got a valid one
+	if ( cp != -1 )
+	{//found a combat point
+		NPC_SetCombatPoint( cp );
+		NPC_SetMoveGoal( NPC, level.combatPoints[cp].origin, 8, qtrue, cp );
+	}
+	else
+	{//couldn't find a place to hide
+		//FIXME: re-implement the old BS_FLEE behavior of following any the waypoint edge 
+		//			that leads away from the danger point.
+		NPC_SetMoveGoal( NPC, NPC->currentOrigin, 0/*goalRadius*/, qtrue, cp );
+	}
+
+	if ( dangerLevel > AEL_DANGER//geat danger always makes people turn and run
+		|| NPC->s.weapon == WP_NONE	//melee/unarmed guys turn and run, others keep facing you and shooting
+		|| NPC->s.weapon == WP_MELEE 
+		|| NPC->s.weapon == WP_TUSKEN_STAFF )
+	{
+		NPCInfo->tempBehavior = BS_FLEE;//we don't want to do this forever!
+		//FIXME: only make it temp if you have a weapon?  Otherwise, permanent?
+	//	NPCInfo->behaviorState = BS_FLEE;
+	//	NPCInfo->tempBehavior = BS_DEFAULT;
+	}
+
+	//FIXME: localize this Timer?
+	TIMER_Set( NPC, "attackDelay", Q_irand( 500, 2500 ) );
+	//FIXME: is this always applicable?
+	NPCInfo->squadState = SQUAD_RETREAT;
+	TIMER_Set( NPC, "flee", Q_irand( fleeTimeMin, fleeTimeMax ) );
+	TIMER_Set( NPC, "panic", Q_irand( 1000, 4000 ) );//how long to wait before trying to nav to a dropped weapon
+	TIMER_Set( NPC, "duck", 0 );
+}
+
+void G_StartFlee( gentity_t *self, gentity_t *enemy, vec3_t dangerPoint, int dangerLevel, int fleeTimeMin, int fleeTimeMax )
+{
+	if ( !self->NPC )
+	{//player
+		return;
+	}
+	SaveNPCGlobals();
+	SetNPCGlobals( self );
+
+	NPC_StartFlee( enemy, dangerPoint, dangerLevel, fleeTimeMin, fleeTimeMax );
+
+	RestoreNPCGlobals();
+}
+
+void NPC_BSEmplaced( void )
+{
+	//Don't do anything if we're hurt
+	if ( NPC->painDebounceTime > level.time )
+	{
+		NPC_UpdateAngles( qtrue, qtrue );
+		return;
+	}
+
+	if( NPCInfo->scriptFlags & SCF_FIRE_WEAPON )
+	{
+		WeaponThink( qtrue );
+	}
+
+	//If we don't have an enemy, just idle
+	if ( NPC_CheckEnemyExt() == qfalse )
+	{
+		if ( !Q_irand( 0, 30 ) )
+		{
+			NPCInfo->desiredYaw = NPC->s.angles[1] + Q_irand( -90, 90 );
+		}
+		if ( !Q_irand( 0, 30 ) )
+		{
+			NPCInfo->desiredPitch = Q_irand( -20, 20 );
+		}
+		NPC_UpdateAngles( qtrue, qtrue );
+		return;
+	}
+
+	qboolean enemyLOS = qfalse;
+	qboolean enemyCS = qfalse;
+	qboolean faceEnemy = qfalse;
+	qboolean shoot = qfalse;
+	vec3_t	impactPos;
+
+	if ( NPC_ClearLOS( NPC->enemy ) )
+	{
+		enemyLOS = qtrue;
+
+		int hit = NPC_ShotEntity( NPC->enemy, impactPos );
+		gentity_t *hitEnt = &g_entities[hit];
+
+		if ( hit == NPC->enemy->s.number || ( hitEnt && hitEnt->takedamage ) )
+		{//can hit enemy or will hit glass or other minor breakable (or in emplaced gun), so shoot anyway
+			enemyCS = qtrue;
+			NPC_AimAdjust( 2 );//adjust aim better longer we have clear shot at enemy
+			VectorCopy( NPC->enemy->currentOrigin, NPCInfo->enemyLastSeenLocation );
+		}
+	}
+/*
+	else if ( gi.inPVS( NPC->enemy->currentOrigin, NPC->currentOrigin ) )
+	{
+		NPCInfo->enemyLastSeenTime = level.time;
+		faceEnemy = qtrue;
+		NPC_AimAdjust( -1 );//adjust aim worse longer we cannot see enemy
+	}
+*/
+
+	if ( enemyLOS )
+	{//FIXME: no need to face enemy if we're moving to some other goal and he's too far away to shoot?
+		faceEnemy = qtrue;
+	}
+	if ( enemyCS )
+	{
+		shoot = qtrue;
+	}
+
+	if ( faceEnemy )
+	{//face the enemy
+		NPC_FaceEnemy( qtrue );
+	}
+	else
+	{//we want to face in the dir we're running
+		NPC_UpdateAngles( qtrue, qtrue );
+	}
+
+	if ( NPCInfo->scriptFlags & SCF_DONT_FIRE )
+	{
+		shoot = qfalse;
+	}
+
+	if ( NPC->enemy && NPC->enemy->enemy )
+	{
+		if ( NPC->enemy->s.weapon == WP_SABER && NPC->enemy->enemy->s.weapon == WP_SABER )
+		{//don't shoot at an enemy jedi who is fighting another jedi, for fear of injuring one or causing rogue blaster deflections (a la Obi Wan/Vader duel at end of ANH)
+			shoot = qfalse;
+		}
+	}
+	if ( shoot )
+	{//try to shoot if it's time
+		if( !(NPCInfo->scriptFlags & SCF_FIRE_WEAPON) ) // we've already fired, no need to do it again here
+		{
+			WeaponThink( qtrue );
+		}
+	}
+}
\ No newline at end of file
diff --git a/code/game/NPC_combat.cpp b/code/game/NPC_combat.cpp
new file mode 100644
index 0000000..3ec1b5e
--- /dev/null
+++ b/code/game/NPC_combat.cpp
@@ -0,0 +1,3317 @@
+//NPC_combat.cpp
+
+// leave this line at the top for all NPC_xxxx.cpp files...
+#include "g_headers.h"
+
+
+
+#include "b_local.h"
+#include "g_nav.h"
+#include "g_navigator.h"
+#include "wp_saber.h"
+
+extern void G_AddVoiceEvent( gentity_t *self, int event, int speakDebounceTime );
+extern void G_SetEnemy( gentity_t *self, gentity_t *enemy );
+extern qboolean NPC_CheckLookTarget( gentity_t *self );
+extern void NPC_ClearLookTarget( gentity_t *self );
+extern void NPC_Jedi_RateNewEnemy( gentity_t *self, gentity_t *enemy );
+extern qboolean PM_DroidMelee( int npc_class );
+extern int delayedShutDown;
+extern qboolean G_ValidEnemy( gentity_t *self, gentity_t *enemy );
+
+void ChangeWeapon( gentity_t *ent, int newWeapon );
+
+void G_ClearEnemy (gentity_t *self)
+{
+	NPC_CheckLookTarget( self );
+
+	if ( self->enemy )
+	{
+		if ( ( G_ValidEnemy(self, self->enemy ) ) && ( self->svFlags & SVF_LOCKEDENEMY ) )
+		{
+			return;
+		}
+
+
+		if(	self->client && self->client->renderInfo.lookTarget == self->enemy->s.number )
+		{
+			NPC_ClearLookTarget( self );
+		}
+
+		if ( self->NPC && self->enemy == self->NPC->goalEntity )
+		{
+			self->NPC->goalEntity = NULL;
+		}
+		//FIXME: set last enemy?
+	}
+
+	self->enemy = NULL;
+}
+
+/*
+-------------------------
+NPC_AngerAlert
+-------------------------
+*/
+
+#define	ANGER_ALERT_RADIUS			512
+#define	ANGER_ALERT_SOUND_RADIUS	256
+
+void G_AngerAlert( gentity_t *self )
+{
+	if ( self && self->NPC && (self->NPC->scriptFlags&SCF_NO_GROUPS) )
+	{//I'm not a team playa...
+		return;
+	}
+	if ( !TIMER_Done( self, "interrogating" ) )
+	{//I'm interrogating, don't wake everyone else up yet... FIXME: this may never wake everyone else up, though!
+		return;
+	}
+	//FIXME: hmm.... with all the other new alerts now, is this still neccesary or even a good idea...?
+	G_AlertTeam( self, self->enemy, ANGER_ALERT_RADIUS, ANGER_ALERT_SOUND_RADIUS );	
+}
+
+/*
+-------------------------
+G_TeamEnemy
+-------------------------
+*/
+
+qboolean G_TeamEnemy( gentity_t *self )
+{//FIXME: Probably a better way to do this, is a linked list of your teammates already available?
+	int	i;
+	gentity_t	*ent;
+
+	if ( !self->client || self->client->playerTeam == TEAM_FREE )
+	{
+		return qfalse;
+	}
+	if ( self && self->NPC && (self->NPC->scriptFlags&SCF_NO_GROUPS) )
+	{//I'm not a team playa...
+		return qfalse;
+	}
+
+	for( i = 1; i < MAX_GENTITIES; i++ )
+	{
+		ent = &g_entities[i];
+
+		if ( ent == self )
+		{
+			continue;
+		}
+
+		if ( ent->health <= 0 )
+		{
+			continue;
+		}
+
+		if ( !ent->client )
+		{
+			continue;
+		}
+
+		if ( ent->client->playerTeam != self->client->playerTeam )
+		{//ent is not on my team
+			continue;
+		}
+
+		if ( ent->enemy )
+		{//they have an enemy
+			if ( !ent->enemy->client || ent->enemy->client->playerTeam != self->client->playerTeam )
+			{//the ent's enemy is either a normal ent or is a player/NPC that is not on my team
+				return qtrue;
+			}
+		}
+	}
+
+	return qfalse;
+}
+
+qboolean G_CheckSaberAllyAttackDelay( gentity_t *self, gentity_t *enemy )
+{
+	if ( !self || !self->enemy )
+	{
+		return qfalse;
+	}
+	if ( self->NPC 
+		&& self->client->leader == player
+		&& self->enemy
+		&& self->enemy->s.weapon != WP_SABER
+		&& self->s.weapon == WP_SABER )
+	{//assisting the player and I'm using a saber and my enemy is not
+		TIMER_Set( self, "allyJediDelay", -level.time );
+		//use the distance to the enemy to determine how long to delay
+		float distance = Distance( enemy->currentOrigin, self->currentOrigin );
+		if ( distance < 256 )
+		{
+			return qtrue;
+		}
+		int delay = 500;
+		if ( distance > 2048 )
+		{//the farther they are, the shorter the delay
+			delay = 5000-floor(distance);//(6-g_spskill->integer));
+			if ( delay < 500 )
+			{
+				delay = 500;
+			}
+		}
+		else
+		{//the close they are, the shorter the delay
+			delay = floor(distance*4);//(6-g_spskill->integer));
+			if ( delay > 5000 )
+			{
+				delay = 5000;
+			}
+		}
+		TIMER_Set( self, "allyJediDelay", delay );
+
+		return qtrue;
+	}
+	return qfalse;
+}
+
+void G_AttackDelay( gentity_t *self, gentity_t *enemy )
+{
+	if ( enemy && self->client && self->NPC )
+	{//delay their attack based on how far away they're facing from enemy
+		vec3_t		fwd, dir;
+		int			attDelay;
+
+		VectorSubtract( self->client->renderInfo.eyePoint, enemy->currentOrigin, dir );//purposely backwards
+		VectorNormalize( dir );
+		AngleVectors( self->client->renderInfo.eyeAngles, fwd, NULL, NULL );
+		//dir[2] = fwd[2] = 0;//ignore z diff?
+		
+		attDelay = (4-g_spskill->integer)*500;//initial: from 1000ms delay on hard to 2000ms delay on easy
+		if ( self->client->playerTeam == TEAM_PLAYER )
+		{//invert
+			attDelay = 2000-attDelay;
+		}
+		attDelay += floor( (DotProduct( fwd, dir )+1.0f) * 2000.0f );//add up to 4000ms delay if they're facing away
+
+		//FIXME: should distance matter, too?
+
+		//Now modify the delay based on NPC_class, weapon, and team
+		//NOTE: attDelay should be somewhere between 1000 to 6000 milliseconds
+		switch ( self->client->NPC_class )
+		{
+		case CLASS_IMPERIAL://they give orders and hang back
+			attDelay += Q_irand( 500, 1500 );
+			break;
+		case CLASS_STORMTROOPER://stormtroopers shoot sooner
+			if ( self->NPC->rank >= RANK_LT )
+			{//officers shoot even sooner
+				attDelay -= Q_irand( 500, 1500 );
+			}
+			else
+			{//normal stormtroopers don't have as fast reflexes as officers
+				attDelay -= Q_irand( 0, 1000 );
+			}
+			break;
+		case CLASS_SWAMPTROOPER://shoot very quickly?  What about guys in water?
+			attDelay -= Q_irand( 1000, 2000 );
+			break;
+		case CLASS_IMPWORKER://they panic, don't fire right away
+			attDelay += Q_irand( 1000, 2500 );
+			break;
+		case CLASS_TRANDOSHAN:
+			attDelay -= Q_irand( 500, 1500 );
+			break;
+		case CLASS_JAN:				
+		case CLASS_LANDO:			
+		case CLASS_PRISONER:
+		case CLASS_REBEL:
+			attDelay -= Q_irand( 500, 1500 );
+			break;
+		case CLASS_GALAKMECH:	
+		case CLASS_ATST:		
+			attDelay -= Q_irand( 1000, 2000 );
+			break;
+		case CLASS_REELO:
+		case CLASS_UGNAUGHT:
+		case CLASS_JAWA:
+			return;
+			break;
+		case CLASS_MINEMONSTER:
+		case CLASS_MURJJ:
+			return;
+			break;
+		case CLASS_INTERROGATOR:
+		case CLASS_PROBE:		
+		case CLASS_MARK1:		
+		case CLASS_MARK2:		
+		case CLASS_SENTRY:		
+			return;
+			break;
+		case CLASS_REMOTE:
+		case CLASS_SEEKER:
+			return;
+			break;
+		/*
+		case CLASS_GRAN:
+		case CLASS_RODIAN:
+		case CLASS_WEEQUAY:
+		case CLASS_TUSKEN:
+			break;
+		case CLASS_JEDI:				
+		case CLASS_SHADOWTROOPER:
+		case CLASS_TAVION:
+		case CLASS_REBORN:
+		case CLASS_LUKE:				
+		case CLASS_KYLE:				
+		case CLASS_DESANN:			
+			break;
+		*/
+		}
+
+		switch ( self->s.weapon )
+		{
+		case WP_NONE:
+		case WP_SABER:
+			return;
+			break;
+		case WP_BRYAR_PISTOL:
+			break;
+		case WP_BLASTER:
+			if ( self->NPC->scriptFlags & SCF_ALT_FIRE )
+			{//rapid-fire blasters
+				attDelay += Q_irand( 0, 500 );
+			}
+			else
+			{//regular blaster
+				attDelay -= Q_irand( 0, 500 );
+			}
+			break;
+		case WP_BOWCASTER:
+			attDelay += Q_irand( 0, 500 );
+			break;
+		case WP_REPEATER:
+			if ( !(self->NPC->scriptFlags&SCF_ALT_FIRE) )
+			{//rapid-fire blasters
+				attDelay += Q_irand( 0, 500 );
+			}
+			break;
+		case WP_FLECHETTE:
+			attDelay += Q_irand( 500, 1500 );
+			break;
+		case WP_ROCKET_LAUNCHER:
+			attDelay += Q_irand( 500, 1500 );
+			break;
+		case WP_CONCUSSION:
+			attDelay += Q_irand( 500, 1500 );
+			break;
+		case WP_BLASTER_PISTOL:	// apparently some enemy only version of the blaster
+			attDelay -= Q_irand( 500, 1500 );
+			break;
+		case WP_DISRUPTOR://sniper's don't delay?
+			return;
+			break;
+		case WP_THERMAL://grenade-throwing has a built-in delay
+			return;
+			break;
+		case WP_MELEE:			// Any ol' melee attack
+			return;
+			break;
+		case WP_EMPLACED_GUN:
+			return;
+			break;
+		case WP_TURRET:			// turret guns 
+			return;
+			break;
+		case WP_BOT_LASER:		// Probe droid	- Laser blast
+			return;
+			break;
+		case WP_NOGHRI_STICK:
+			attDelay += Q_irand( 0, 500 );
+			break;
+		/*
+		case WP_DEMP2:
+			break;
+		case WP_TRIP_MINE:
+			break;
+		case WP_DET_PACK:
+			break;
+		case WP_STUN_BATON:
+			break;
+		case WP_ATST_MAIN:
+			break;
+		case WP_ATST_SIDE:
+			break;
+		case WP_TIE_FIGHTER:
+			break;
+		case WP_RAPID_FIRE_CONC:
+			break;
+		*/
+		}
+
+		if ( self->client->playerTeam == TEAM_PLAYER )
+		{//clamp it
+			if ( attDelay > 2000 )
+			{
+				attDelay = 2000;
+			}
+		}
+
+		//don't shoot right away
+		if ( attDelay > 4000+((2-g_spskill->integer)*3000) )
+		{
+			attDelay = 4000+((2-g_spskill->integer)*3000);
+		}
+		TIMER_Set( self, "attackDelay", attDelay );//Q_irand( 1500, 4500 ) );
+		//don't move right away either
+		if ( attDelay > 4000 )
+		{
+			attDelay = 4000 - Q_irand(500, 1500);
+		}
+		else
+		{
+			attDelay -= Q_irand(500, 1500);
+		}
+
+		TIMER_Set( self, "roamTime", attDelay );//was Q_irand( 1000, 3500 );
+	}
+}
+/*
+-------------------------
+G_SetEnemy
+-------------------------
+*/
+extern gentity_t *G_CheckControlledTurretEnemy(gentity_t *self,  gentity_t *enemy, qboolean validate );
+
+void Saboteur_Cloak( gentity_t *self );
+void G_AimSet( gentity_t *self, int aim );
+void G_SetEnemy( gentity_t *self, gentity_t *enemy )
+{
+	int	event = 0;
+	
+	//Must be valid
+	if ( enemy == NULL )
+		return;
+
+	//Must be valid
+	if ( enemy->inuse == 0 )
+	{
+		return;
+	}
+
+	enemy = G_CheckControlledTurretEnemy(self, enemy, qtrue);
+	if (!enemy)
+	{
+		return;
+	}
+
+	//Don't take the enemy if in notarget
+	if ( enemy->flags & FL_NOTARGET )
+		return;
+
+	if ( !self->NPC )
+	{
+		self->enemy = enemy;
+		return;
+	}
+
+	if ( self->NPC->confusionTime > level.time )
+	{//can't pick up enemies if confused
+		return;
+	}
+
+#ifdef _DEBUG
+	if ( self->s.number )
+	{
+		assert( enemy != self );
+	}
+#endif// _DEBUG
+	
+//	if ( enemy->client && enemy->client->playerTeam == TEAM_DISGUISE )
+//	{//unmask the player
+//		enemy->client->playerTeam = TEAM_PLAYER;
+//	}
+	
+	if ( self->client && self->NPC && enemy->client && enemy->client->playerTeam == self->client->playerTeam )
+	{//Probably a damn script!
+		if ( self->NPC->charmedTime > level.time )
+		{//Probably a damn script!
+			return;
+		}
+	}
+
+	if ( self->NPC && self->client && self->client->ps.weapon == WP_SABER )
+	{
+		//when get new enemy, set a base aggression based on what that enemy is using, how far they are, etc.
+		NPC_Jedi_RateNewEnemy( self, enemy );
+	}
+
+	//NOTE: this is not necessarily true!
+	//self->NPC->enemyLastSeenTime = level.time;
+
+	if ( self->enemy == NULL )
+	{
+		//TEMP HACK: turn on our saber
+		if ( self->health > 0 )
+		{
+			self->client->ps.SaberActivate();
+		}
+
+		//FIXME: Have to do this to prevent alert cascading
+		G_ClearEnemy( self );
+		self->enemy = enemy;
+		if (self->client && self->client->NPC_class == CLASS_SABOTEUR)
+		{
+			Saboteur_Cloak(NPC);					// Cloak
+			TIMER_Set(self, "decloakwait", 3000);	// Wait 3 sec before decloak and attack
+		}
+
+
+		//Special case- if player is being hunted by his own people, set the player's team to team_free
+		if ( self->client->playerTeam == TEAM_PLAYER 
+			&& enemy->s.number == 0
+			&& enemy->client
+			&& enemy->client->playerTeam == TEAM_PLAYER )
+		{//make the player "evil" so that everyone goes after him
+			enemy->client->enemyTeam = TEAM_FREE;
+			enemy->client->playerTeam = TEAM_FREE;
+		}
+
+		//If have an anger script, run that instead of yelling
+		if( G_ActivateBehavior( self, BSET_ANGER ) )
+		{
+		}
+		else if ( self->client 
+			&& self->client->NPC_class == CLASS_KYLE
+			&& self->client->leader == player
+			&& !TIMER_Done( self, "kyleAngerSoundDebounce" ) )
+		{//don't yell that you have an enemy more than once every five seconds
+		}
+		else if ( self->client && enemy->client && self->client->playerTeam != enemy->client->playerTeam )
+		{
+			//FIXME: Use anger when entire team has no enemy.
+			//		 Basically, you're first one to notice enemies
+			if ( self->forcePushTime < level.time ) // not currently being pushed
+			{
+				if ( !G_TeamEnemy( self ) &&  self->client->NPC_class != CLASS_BOBAFETT)
+				{//team did not have an enemy previously
+					if ( self->NPC
+						&& self->client->playerTeam == TEAM_PLAYER
+						&& enemy->s.number < MAX_CLIENTS
+						&& self->client->clientInfo.customBasicSoundDir
+						&& self->client->clientInfo.customBasicSoundDir[0]
+						&& Q_stricmp( "jedi2", self->client->clientInfo.customBasicSoundDir ) == 0 )
+					{
+						switch ( Q_irand( 0, 2 ) )
+						{
+						case 0:
+							G_SoundOnEnt( self, CHAN_VOICE, "sound/chars/jedi2/28je2008.wav" );
+							break;
+						case 1:
+							G_SoundOnEnt( self, CHAN_VOICE, "sound/chars/jedi2/28je2009.wav" );
+							break;
+						case 2:
+							G_SoundOnEnt( self, CHAN_VOICE, "sound/chars/jedi2/28je2012.wav" );
+							break;
+						}
+						self->NPC->blockedSpeechDebounceTime = level.time + 2000;
+					}
+					else
+					{
+						if ( Q_irand( 0, 1 ))
+						{//hell, we're loading them, might as well use them!
+							event = Q_irand(EV_CHASE1, EV_CHASE3);
+						}
+						else
+						{
+							event = Q_irand(EV_ANGER1, EV_ANGER3);
+						}
+					}
+				}
+			}
+			
+			if ( event )
+			{//yell
+				if ( self->client 
+					&& self->client->NPC_class == CLASS_KYLE
+					&& self->client->leader == player )
+				{//don't yell that you have an enemy more than once every 4-8 seconds
+					TIMER_Set( self, "kyleAngerSoundDebounce", Q_irand( 4000, 8000 ) );
+				}
+				G_AddVoiceEvent( self, event, 2000 );
+			}
+		}
+		
+		if ( self->s.weapon == WP_BLASTER || self->s.weapon == WP_REPEATER ||
+			self->s.weapon == WP_THERMAL || self->s.weapon == WP_BLASTER_PISTOL 
+			|| self->s.weapon == WP_BOWCASTER )
+		{//Hmm, how about sniper and bowcaster?
+			//When first get mad, aim is bad
+			//Hmm, base on game difficulty, too?  Rank?
+			if ( self->client->playerTeam == TEAM_PLAYER )
+			{
+				G_AimSet( self, Q_irand( self->NPC->stats.aim - (5*(g_spskill->integer)), self->NPC->stats.aim - g_spskill->integer ) );
+			}
+			else
+			{
+				int minErr = 3;
+				int maxErr = 12;
+				if ( self->client->NPC_class == CLASS_IMPWORKER )
+				{
+					minErr = 15;
+					maxErr = 30;
+				}
+				else if ( self->client->NPC_class == CLASS_STORMTROOPER && self->NPC && self->NPC->rank <= RANK_CREWMAN )
+				{
+					minErr = 5;
+					maxErr = 15;
+				}
+
+				G_AimSet( self, Q_irand( self->NPC->stats.aim - (maxErr*(3-g_spskill->integer)), self->NPC->stats.aim - (minErr*(3-g_spskill->integer)) ) );
+			}
+		}
+		
+		//Alert anyone else in the area
+		if ( Q_stricmp( "desperado", self->NPC_type ) != 0 && Q_stricmp( "paladin", self->NPC_type ) != 0 )
+		{//special holodeck enemies exception
+			if ( !(self->client->ps.eFlags&EF_FORCE_GRIPPED) )
+			{//gripped people can't call for help
+				G_AngerAlert( self );
+			}
+		}
+
+		if ( !G_CheckSaberAllyAttackDelay( self, enemy ) )
+		{//not a saber ally holding back
+			//Stormtroopers don't fire right away!
+			G_AttackDelay( self, enemy );
+		}
+
+		//FIXME: this is a disgusting hack that is supposed to make the Imperials start with their weapon holstered- need a better way
+		if ( self->client->ps.weapon == WP_NONE && !Q_stricmpn( self->NPC_type, "imp", 3 ) && !(self->NPC->scriptFlags & SCF_FORCED_MARCH)  )
+		{
+			if ( self->client->ps.stats[STAT_WEAPONS] & ( 1 << WP_BLASTER ) )
+			{
+				ChangeWeapon( self, WP_BLASTER );
+				self->client->ps.weapon = WP_BLASTER;
+				self->client->ps.weaponstate = WEAPON_READY;
+				G_CreateG2AttachedWeaponModel( self, weaponData[WP_BLASTER].weaponMdl, self->handRBolt, 0 );
+			}
+			else if ( self->client->ps.stats[STAT_WEAPONS] & ( 1 << WP_BLASTER_PISTOL ) )
+			{
+				ChangeWeapon( self, WP_BLASTER_PISTOL );
+				self->client->ps.weapon = WP_BLASTER_PISTOL;
+				self->client->ps.weaponstate = WEAPON_READY;
+				G_CreateG2AttachedWeaponModel( self, weaponData[WP_BLASTER_PISTOL].weaponMdl, self->handRBolt, 0 );
+			}
+		}
+		return;
+	}
+	
+	//Otherwise, just picking up another enemy
+
+	if ( event )
+	{
+		G_AddVoiceEvent( self, event, 2000 );
+	}
+
+	//Take the enemy
+	G_ClearEnemy(self);
+	self->enemy = enemy;
+}
+
+
+/*
+int ChooseBestWeapon( void ) 
+{
+	int		n;
+	int		weapon;
+
+	// check weapons in the NPC's weapon preference order
+	for ( n = 0; n < MAX_WEAPONS; n++ ) 
+	{
+		weapon = NPCInfo->weaponOrder[n];
+
+		if ( weapon == WP_NONE ) 
+		{
+			break;
+		}
+
+		if ( !HaveWeapon( weapon ) ) 
+		{
+			continue;
+		}
+
+		if ( client->ps.ammo[weaponData[weapon].ammoIndex] ) 
+		{
+			return weapon;
+		}
+	}
+
+	// check weapons serially (mainly in case a weapon is not on the NPC's list)
+	for ( weapon = 1; weapon < WP_NUM_WEAPONS; weapon++ ) 
+	{
+		if ( !HaveWeapon( weapon ) ) 
+		{
+			continue;
+		}
+
+		if ( client->ps.ammo[weaponData[weapon].ammoIndex] ) 
+		{
+			return weapon;
+		}
+	}
+
+	return client->ps.weapon;
+}
+*/
+
+void ChangeWeapon( gentity_t *ent, int newWeapon ) 
+{
+	if ( !ent || !ent->client || !ent->NPC )
+	{
+		return;
+	}
+
+	ent->client->ps.weapon = newWeapon;
+	ent->NPC->shotTime = 0;
+	ent->NPC->burstCount = 0;
+	ent->NPC->attackHold = 0;
+	ent->NPC->currentAmmo = ent->client->ps.ammo[weaponData[newWeapon].ammoIndex];
+
+	switch ( newWeapon ) 
+	{
+	case WP_BRYAR_PISTOL://prifle
+		ent->NPC->aiFlags &= ~NPCAI_BURST_WEAPON;
+		ent->NPC->burstSpacing = 1000;//attackdebounce
+		break;
+
+	case WP_BLASTER_PISTOL:
+		ent->NPC->aiFlags &= ~NPCAI_BURST_WEAPON;
+		if ( ent->weaponModel[1] > 0 )
+		{//commando
+			ent->NPC->aiFlags |= NPCAI_BURST_WEAPON;
+			ent->NPC->burstMin = 4;
+			ent->NPC->burstMean = 8;
+			ent->NPC->burstMax = 12;
+			if ( g_spskill->integer == 0 )
+				ent->NPC->burstSpacing = 600;//attack debounce
+			else if ( g_spskill->integer == 1 )
+				ent->NPC->burstSpacing = 400;//attack debounce
+			else 
+				ent->NPC->burstSpacing = 250;//attack debounce
+		}
+		else if ( ent->client->NPC_class == CLASS_SABOTEUR )
+		{
+			if ( g_spskill->integer == 0 )
+				ent->NPC->burstSpacing = 900;//attack debounce
+			else if ( g_spskill->integer == 1 )
+				ent->NPC->burstSpacing = 600;//attack debounce
+			else 
+				ent->NPC->burstSpacing = 400;//attack debounce
+		}
+		else
+		{
+		//	ent->NPC->burstSpacing = 1000;//attackdebounce
+			if ( g_spskill->integer == 0 )
+				ent->NPC->burstSpacing = 1000;//attack debounce
+			else if ( g_spskill->integer == 1 )
+				ent->NPC->burstSpacing = 750;//attack debounce
+			else 
+				ent->NPC->burstSpacing = 500;//attack debounce
+		}
+		break;
+
+	case WP_BOT_LASER://probe attack
+		ent->NPC->aiFlags &= ~NPCAI_BURST_WEAPON;
+	//	ent->NPC->burstSpacing = 600;//attackdebounce
+		if ( g_spskill->integer == 0 )
+			ent->NPC->burstSpacing = 600;//attack debounce
+		else if ( g_spskill->integer == 1 )
+			ent->NPC->burstSpacing = 400;//attack debounce
+		else 
+			ent->NPC->burstSpacing = 200;//attack debounce
+		break;
+
+	case WP_SABER:
+		ent->NPC->aiFlags &= ~NPCAI_BURST_WEAPON;
+		ent->NPC->burstSpacing = 0;//attackdebounce
+		break;
+
+	case WP_DISRUPTOR:
+		ent->NPC->aiFlags &= ~NPCAI_BURST_WEAPON;
+		if ( ent->NPC->scriptFlags & SCF_ALT_FIRE )
+		{
+			switch( g_spskill->integer )
+			{
+			case 0:
+				ent->NPC->burstSpacing = 2500;//attackdebounce
+				break;
+			case 1:
+				ent->NPC->burstSpacing = 2000;//attackdebounce
+				break;
+			case 2:
+				ent->NPC->burstSpacing = 1500;//attackdebounce
+				break;
+			}
+		}
+		else
+		{
+			ent->NPC->burstSpacing = 1000;//attackdebounce
+		}
+		break;
+
+	case WP_TUSKEN_RIFLE:
+		ent->NPC->aiFlags &= ~NPCAI_BURST_WEAPON;
+		if ( ent->NPC->scriptFlags & SCF_ALT_FIRE )
+		{
+			switch( g_spskill->integer )
+			{
+			case 0:
+				ent->NPC->burstSpacing = 2500;//attackdebounce
+				break;
+			case 1:
+				ent->NPC->burstSpacing = 2000;//attackdebounce
+				break;
+			case 2:
+				ent->NPC->burstSpacing = 1500;//attackdebounce
+				break;
+			}
+		}
+		else
+		{
+			ent->NPC->burstSpacing = 1000;//attackdebounce
+		}
+		break;
+
+	case WP_BOWCASTER:
+		ent->NPC->aiFlags &= ~NPCAI_BURST_WEAPON;
+	//	ent->NPC->burstSpacing = 1000;//attackdebounce
+		if ( g_spskill->integer == 0 )
+			ent->NPC->burstSpacing = 1000;//attack debounce
+		else if ( g_spskill->integer == 1 )
+			ent->NPC->burstSpacing = 750;//attack debounce
+		else 
+			ent->NPC->burstSpacing = 500;//attack debounce
+		break;
+
+	case WP_REPEATER:
+		if ( ent->NPC->scriptFlags & SCF_ALT_FIRE )
+		{
+			ent->NPC->aiFlags &= ~NPCAI_BURST_WEAPON;
+			ent->NPC->burstSpacing = 2000;//attackdebounce
+		}
+		else
+		{
+			ent->NPC->aiFlags |= NPCAI_BURST_WEAPON;
+			ent->NPC->burstMin = 3;
+			ent->NPC->burstMean = 6;
+			ent->NPC->burstMax = 10;
+			if ( g_spskill->integer == 0 )
+				ent->NPC->burstSpacing = 1500;//attack debounce
+			else if ( g_spskill->integer == 1 )
+				ent->NPC->burstSpacing = 1000;//attack debounce
+			else 
+				ent->NPC->burstSpacing = 500;//attack debounce
+		}
+		break;
+
+	case WP_DEMP2:
+		ent->NPC->aiFlags &= ~NPCAI_BURST_WEAPON;
+		ent->NPC->burstSpacing = 1000;//attackdebounce
+		break;
+
+	case WP_FLECHETTE:
+		ent->NPC->aiFlags &= ~NPCAI_BURST_WEAPON;
+		if ( ent->NPC->scriptFlags & SCF_ALT_FIRE )
+		{
+			ent->NPC->burstSpacing = 2000;//attackdebounce
+		}
+		else
+		{
+			ent->NPC->burstSpacing = 1000;//attackdebounce
+		}
+		break;
+
+	case WP_ROCKET_LAUNCHER:
+		ent->NPC->aiFlags &= ~NPCAI_BURST_WEAPON;
+	//	ent->NPC->burstSpacing = 2500;//attackdebounce
+		if ( g_spskill->integer == 0 )
+			ent->NPC->burstSpacing = 2500;//attack debounce
+		else if ( g_spskill->integer == 1 )
+			ent->NPC->burstSpacing = 2000;//attack debounce
+		else 
+			ent->NPC->burstSpacing = 1500;//attack debounce
+		break;
+
+	case WP_CONCUSSION:
+		ent->NPC->aiFlags &= ~NPCAI_BURST_WEAPON;
+		if ( ent->NPC->scriptFlags & SCF_ALT_FIRE )
+		{//beam
+			ent->NPC->burstSpacing = 1200;//attackdebounce
+		}
+		else
+		{//rocket
+			if ( g_spskill->integer == 0 )
+				ent->NPC->burstSpacing = 2300;//attack debounce
+			else if ( g_spskill->integer == 1 )
+				ent->NPC->burstSpacing = 1800;//attack debounce
+			else 
+				ent->NPC->burstSpacing = 1200;//attack debounce
+		}
+		break;
+
+	case WP_THERMAL:
+		ent->NPC->aiFlags &= ~NPCAI_BURST_WEAPON;
+	//	ent->NPC->burstSpacing = 3000;//attackdebounce
+		if ( g_spskill->integer == 0 )
+//			ent->NPC->burstSpacing = 3000;//attack debounce
+			ent->NPC->burstSpacing = 4500;//attack debounce
+		else if ( g_spskill->integer == 1 )
+//			ent->NPC->burstSpacing = 2500;//attack debounce
+			ent->NPC->burstSpacing = 3000;//attack debounce
+		else 
+			ent->NPC->burstSpacing = 2000;//attack debounce
+		break;
+
+	/*
+	case WP_SABER:
+		ent->NPC->aiFlags |= NPCAI_BURST_WEAPON;
+		ent->NPC->burstMin = 5;//0.5 sec
+		ent->NPC->burstMean = 10;//1 second
+		ent->NPC->burstMax = 20;//3 seconds
+		ent->NPC->burstSpacing = 2000;//2 seconds
+		ent->NPC->attackHold = 1000;//Hold attack button for a 1-second burst
+		break;
+	
+	case WP_TRICORDER:
+		ent->NPC->aiFlags |= NPCAI_BURST_WEAPON;
+		ent->NPC->burstMin = 5;
+		ent->NPC->burstMean = 10;
+		ent->NPC->burstMax = 30;
+		ent->NPC->burstSpacing = 1000;
+		break;
+	*/
+
+	case WP_BLASTER:
+		if ( ent->NPC->scriptFlags & SCF_ALT_FIRE )
+		{
+			ent->NPC->aiFlags |= NPCAI_BURST_WEAPON;
+			ent->NPC->burstMin = 3;
+			ent->NPC->burstMean = 3;
+			ent->NPC->burstMax = 3;
+			if ( g_spskill->integer == 0 )
+				ent->NPC->burstSpacing = 1500;//attack debounce
+			else if ( g_spskill->integer == 1 )
+				ent->NPC->burstSpacing = 1000;//attack debounce
+			else 
+				ent->NPC->burstSpacing = 500;//attack debounce
+		}
+		else
+		{
+			ent->NPC->aiFlags &= ~NPCAI_BURST_WEAPON;
+			if ( g_spskill->integer == 0 )
+				ent->NPC->burstSpacing = 1000;//attack debounce
+			else if ( g_spskill->integer == 1 )
+				ent->NPC->burstSpacing = 750;//attack debounce
+			else 
+				ent->NPC->burstSpacing = 500;//attack debounce
+		//	ent->NPC->burstSpacing = 1000;//attackdebounce
+		}
+		break;
+
+	case WP_MELEE:
+	case WP_TUSKEN_STAFF:
+		ent->NPC->aiFlags &= ~NPCAI_BURST_WEAPON;
+		ent->NPC->burstSpacing = 1000;//attackdebounce
+		break;
+
+	case WP_ATST_MAIN:
+	case WP_ATST_SIDE:
+		ent->NPC->aiFlags &= ~NPCAI_BURST_WEAPON;
+	//	ent->NPC->burstSpacing = 1000;//attackdebounce
+			if ( g_spskill->integer == 0 )
+				ent->NPC->burstSpacing = 1000;//attack debounce
+			else if ( g_spskill->integer == 1 )
+				ent->NPC->burstSpacing = 750;//attack debounce
+			else 
+				ent->NPC->burstSpacing = 500;//attack debounce
+		break;
+
+	case WP_EMPLACED_GUN:
+		//FIXME: give some designer-control over this?
+		if ( ent->client && ent->client->NPC_class == CLASS_REELO )
+		{
+			ent->NPC->aiFlags &= ~NPCAI_BURST_WEAPON;
+			ent->NPC->burstSpacing = 1000;//attack debounce
+	//		if ( g_spskill->integer == 0 )
+	//			ent->NPC->burstSpacing = 300;//attack debounce
+	//		else if ( g_spskill->integer == 1 )
+	//			ent->NPC->burstSpacing = 200;//attack debounce
+	//		else 
+	//			ent->NPC->burstSpacing = 100;//attack debounce
+		}
+		else
+		{
+			ent->NPC->aiFlags |= NPCAI_BURST_WEAPON;
+			ent->NPC->burstMin = 2; // 3 shots, really
+			ent->NPC->burstMean = 2;
+			ent->NPC->burstMax = 2;
+
+			if ( ent->owner ) // if we have an owner, it should be the chair at this point...so query the chair for its shot debounce times, etc.
+			{
+				if ( g_spskill->integer == 0 )
+				{
+					ent->NPC->burstSpacing = ent->owner->wait + 400;//attack debounce
+					ent->NPC->burstMin = ent->NPC->burstMax = 1; // two shots
+				}
+				else if ( g_spskill->integer == 1 )
+				{
+					ent->NPC->burstSpacing = ent->owner->wait + 200;//attack debounce
+				}
+				else 
+				{
+					ent->NPC->burstSpacing = ent->owner->wait;//attack debounce
+				}
+			}
+			else
+			{
+				if ( g_spskill->integer == 0 )
+				{
+					ent->NPC->burstSpacing = 1200;//attack debounce
+					ent->NPC->burstMin = ent->NPC->burstMax = 1; // two shots
+				}
+				else if ( g_spskill->integer == 1 )
+				{
+					ent->NPC->burstSpacing = 1000;//attack debounce
+				}
+				else 
+				{
+					ent->NPC->burstSpacing = 800;//attack debounce
+				}
+			}
+		}
+		break;
+
+	case WP_NOGHRI_STICK:
+		ent->NPC->aiFlags &= ~NPCAI_BURST_WEAPON;
+		if ( g_spskill->integer == 0 )
+			ent->NPC->burstSpacing = 2250;//attack debounce
+		else if ( g_spskill->integer == 1 )
+			ent->NPC->burstSpacing = 1500;//attack debounce
+		else 
+			ent->NPC->burstSpacing = 750;//attack debounce
+		break;
+
+	default:
+		ent->NPC->aiFlags &= ~NPCAI_BURST_WEAPON;
+		break;
+	}
+}
+
+void NPC_ChangeWeapon( int newWeapon ) 
+{
+	qboolean	changing = qfalse;
+	if ( newWeapon != NPC->client->ps.weapon )
+	{
+		changing = qtrue;
+	}
+	if ( changing )
+	{
+		G_RemoveWeaponModels( NPC );
+	}
+	ChangeWeapon( NPC, newWeapon );
+	if ( changing && NPC->client->ps.weapon != WP_NONE )
+	{
+		if ( NPC->client->ps.weapon == WP_SABER )
+		{
+			WP_SaberAddG2SaberModels( NPC );
+		}
+		else
+		{
+			G_CreateG2AttachedWeaponModel( NPC, weaponData[NPC->client->ps.weapon].weaponMdl, NPC->handRBolt, 0 );
+		}
+	}
+}
+/*
+void NPC_ApplyWeaponFireDelay(void)
+How long, if at all, in msec the actual fire should delay from the time the attack was started
+*/
+void NPC_ApplyWeaponFireDelay(void)
+{	
+	if ( NPC->attackDebounceTime > level.time )
+	{//Just fired, if attacking again, must be a burst fire, so don't add delay
+		//NOTE: Borg AI uses attackDebounceTime "incorrectly", so this will always return for them!
+		return;
+	}
+	
+	switch(client->ps.weapon)
+	{
+	case WP_BOT_LASER:
+		NPCInfo->burstCount = 0;
+		client->fireDelay = 500;
+		break;
+
+	case WP_THERMAL:
+		if ( client->ps.clientNum )
+		{//NPCs delay... 
+			//FIXME: player should, too, but would feel weird in 1st person, even though it
+			//			would look right in 3rd person.  Really should have a wind-up anim
+			//			for player as he holds down the fire button to throw, then play
+			//			the actual throw when he lets go...
+			client->fireDelay = 700;
+		}
+		break;
+
+	case WP_MELEE:
+	case WP_TUSKEN_STAFF:
+		if ( !PM_DroidMelee( client->NPC_class ) )
+		{//FIXME: should be unique per melee anim
+			client->fireDelay = 300;
+		}
+		break;
+
+	case WP_TUSKEN_RIFLE:
+		if ( !(NPCInfo->scriptFlags&SCF_ALT_FIRE) )
+		{//FIXME: should be unique per melee anim
+			client->fireDelay = 300;
+		}
+		break;
+
+	default:
+		client->fireDelay = 0;
+		break;
+	}
+};
+
+/*
+-------------------------
+ShootThink
+-------------------------
+*/
+void ShootThink( void ) 
+{
+	int			delay;
+
+	ucmd.buttons &= ~BUTTON_ATTACK;
+/*
+	if ( enemyVisibility != VIS_SHOOT) 
+		return;
+*/
+
+	if ( client->ps.weapon == WP_NONE )
+		return;
+
+	if ( client->ps.weaponstate != WEAPON_READY && client->ps.weaponstate != WEAPON_FIRING && client->ps.weaponstate != WEAPON_IDLE) 
+		return;
+
+	if ( level.time < NPCInfo->shotTime ) 
+	{
+		return;
+	}
+
+	ucmd.buttons |= BUTTON_ATTACK;
+
+	NPCInfo->currentAmmo = client->ps.ammo[weaponData[client->ps.weapon].ammoIndex];	// checkme
+
+	NPC_ApplyWeaponFireDelay();
+
+	if ( NPCInfo->aiFlags & NPCAI_BURST_WEAPON ) 
+	{
+		if ( !NPCInfo->burstCount ) 
+		{
+			NPCInfo->burstCount = Q_irand( NPCInfo->burstMin, NPCInfo->burstMax );
+			/*
+			NPCInfo->burstCount = erandom( NPCInfo->burstMean );
+			if ( NPCInfo->burstCount < NPCInfo->burstMin ) 
+			{
+				NPCInfo->burstCount = NPCInfo->burstMin;
+			}
+			else if ( NPCInfo->burstCount > NPCInfo->burstMax ) 
+			{
+				NPCInfo->burstCount = NPCInfo->burstMax;
+			}
+			*/
+			delay = 0;
+		}
+		else 
+		{
+			NPCInfo->burstCount--;
+			if ( NPCInfo->burstCount == 0 ) 
+			{
+				delay = NPCInfo->burstSpacing + Q_irand(-150, 150);
+			}
+			else 
+			{
+				delay = 0;
+			}
+		}
+
+		if ( !delay )
+		{
+			// HACK: dirty little emplaced bits, but is done because it would otherwise require some sort of new variable...
+			if ( client->ps.weapon == WP_EMPLACED_GUN )
+			{
+				if ( NPC->owner ) // try and get the debounce values from the chair if we can
+				{
+					if ( g_spskill->integer == 0 )
+					{
+						delay = NPC->owner->random + 150;
+					}
+					else if ( g_spskill->integer == 1 )
+					{
+						delay = NPC->owner->random + 100;
+					}
+					else 
+					{
+						delay = NPC->owner->random;
+					}
+				}
+				else
+				{
+					if ( g_spskill->integer == 0 )
+					{
+						delay = 350;
+					}
+					else if ( g_spskill->integer == 1 )
+					{
+						delay = 300;
+					}
+					else 
+					{
+						delay = 200;
+					}
+				}
+			}
+		}
+	}
+	else 
+	{
+		delay = NPCInfo->burstSpacing + Q_irand(-150, 150);
+	}
+
+	NPCInfo->shotTime = level.time + delay;
+	NPC->attackDebounceTime = level.time + NPC_AttackDebounceForWeapon();
+}
+
+/*
+static void WeaponThink( qboolean inCombat ) 
+FIXME makes this so there's a delay from event that caused us to check to actually doing it
+
+Added: hacks for Borg
+*/
+void WeaponThink( qboolean inCombat ) 
+{
+	if ( client->ps.weaponstate == WEAPON_RAISING || client->ps.weaponstate == WEAPON_DROPPING ) 
+	{
+		ucmd.weapon = client->ps.weapon;
+		ucmd.buttons &= ~BUTTON_ATTACK;
+		return;
+	}
+
+	// can't shoot while shield is up
+	if (NPC->flags&FL_SHIELDED && NPC->client->NPC_class==CLASS_ASSASSIN_DROID)
+	{
+		return;
+	}
+
+	// Can't Fire While Cloaked
+	if (NPC->client && 
+		(NPC->client->ps.powerups[PW_CLOAKED] || (level.time<NPC->client->ps.powerups[PW_UNCLOAKING])))
+	{
+		return;
+	}
+
+
+//MCG - Begin
+	//For now, no-one runs out of ammo	
+	if ( NPC->client->ps.ammo[ weaponData[client->ps.weapon].ammoIndex ] < weaponData[client->ps.weapon].energyPerShot )
+	{ 
+		Add_Ammo( NPC, client->ps.weapon, weaponData[client->ps.weapon].energyPerShot*10 );
+	}
+	else if ( NPC->client->ps.ammo[ weaponData[client->ps.weapon].ammoIndex ] < weaponData[client->ps.weapon].altEnergyPerShot )
+	{
+		Add_Ammo( NPC, client->ps.weapon, weaponData[client->ps.weapon].altEnergyPerShot*5 );
+	}
+
+	/*if ( NPC->playerTeam == TEAM_BORG )
+	{//HACK!!!
+		if(!(NPC->client->ps.stats[STAT_WEAPONS] & ( 1 << WP_BORG_WEAPON )))
+			NPC->client->ps.stats[STAT_WEAPONS] |= ( 1 << WP_BORG_WEAPON );
+
+		if ( client->ps.weapon != WP_BORG_WEAPON ) 
+		{
+			NPC_ChangeWeapon( WP_BORG_WEAPON );
+			Add_Ammo (NPC, client->ps.weapon, 10);
+			NPCInfo->currentAmmo = client->ps.ammo[client->ps.weapon];
+		}
+	}
+	else */
+	
+	/*if ( NPC->client->playerTeam == TEAM_SCAVENGERS )
+	{//HACK!!!
+		if(!(NPC->client->ps.stats[STAT_WEAPONS] & ( 1 << WP_BLASTER )))
+			NPC->client->ps.stats[STAT_WEAPONS] |= ( 1 << WP_BLASTER );
+
+		if ( client->ps.weapon != WP_BLASTER )
+			 
+		{
+			NPC_ChangeWeapon( WP_BLASTER );
+			Add_Ammo (NPC, client->ps.weapon, 10);
+//			NPCInfo->currentAmmo = client->ps.ammo[client->ps.weapon];
+			NPCInfo->currentAmmo = client->ps.ammo[weaponData[client->ps.weapon].ammoIndex];	// checkme
+		}
+	}
+	else*/
+//MCG - End
+	{
+		// if the gun in our hands is out of ammo, we need to change
+		/*if ( client->ps.ammo[client->ps.weapon] == 0 ) 
+		{
+			NPCInfo->aiFlags |= NPCAI_CHECK_WEAPON;
+		}
+
+		if ( NPCInfo->aiFlags & NPCAI_CHECK_WEAPON ) 
+		{
+			NPCInfo->aiFlags &= ~NPCAI_CHECK_WEAPON;
+			bestWeapon = ChooseBestWeapon();
+			if ( bestWeapon != client->ps.weapon ) 
+			{
+				NPC_ChangeWeapon( bestWeapon );
+			}
+		}*/
+	}
+
+	ucmd.weapon = client->ps.weapon;
+	ShootThink();
+}
+
+/*
+HaveWeapon
+*/
+
+qboolean HaveWeapon( int weapon ) 
+{
+	return ( client->ps.stats[STAT_WEAPONS] & ( 1 << weapon ) );
+}
+
+qboolean EntIsGlass (gentity_t *check)
+{
+	if(check->classname &&
+		!Q_stricmp("func_breakable", check->classname) &&
+		check->count == 1 && check->health <= 100)
+	{
+		return qtrue;
+	}
+
+	return qfalse;
+}
+
+qboolean ShotThroughGlass (trace_t *tr, gentity_t *target, vec3_t spot, int mask)
+{
+	gentity_t	*hit = &g_entities[ tr->entityNum ];
+	if(hit != target && EntIsGlass(hit))
+	{//ok to shoot through breakable glass
+		int			skip = hit->s.number;
+		vec3_t		muzzle;
+
+		VectorCopy(tr->endpos, muzzle);
+		gi.trace (tr, muzzle, NULL, NULL, spot, skip, mask );
+		return qtrue;
+	}
+
+	return qfalse;
+}
+
+/*
+CanShoot
+determine if NPC can directly target enemy
+
+this function does not check teams, invulnerability, notarget, etc....
+
+Added: If can't shoot center, try head, if not, see if it's close enough to try anyway.
+*/
+qboolean CanShoot ( gentity_t *ent, gentity_t *shooter ) 
+{
+	trace_t		tr;
+	vec3_t		muzzle;
+	vec3_t		spot, diff;
+	gentity_t	*traceEnt;
+
+	CalcEntitySpot( shooter, SPOT_WEAPON, muzzle );
+	CalcEntitySpot( ent, SPOT_ORIGIN, spot );		//FIXME preferred target locations for some weapons (feet for R/L)
+
+	gi.trace ( &tr, muzzle, NULL, NULL, spot, shooter->s.number, MASK_SHOT );
+	traceEnt = &g_entities[ tr.entityNum ];
+
+	// point blank, baby!
+	if (tr.startsolid && (shooter->NPC) && (shooter->NPC->touchedByPlayer) ) 
+	{
+		traceEnt = shooter->NPC->touchedByPlayer;
+	}
+	
+	if ( ShotThroughGlass( &tr, ent, spot, MASK_SHOT ) )
+	{
+		traceEnt = &g_entities[ tr.entityNum ];
+	}
+
+	// shot is dead on
+	if ( traceEnt == ent ) 
+	{
+		return qtrue;
+	}
+//MCG - Begin
+	else
+	{//ok, can't hit them in center, try their head
+		CalcEntitySpot( ent, SPOT_HEAD, spot );
+		gi.trace ( &tr, muzzle, NULL, NULL, spot, shooter->s.number, MASK_SHOT );
+		traceEnt = &g_entities[ tr.entityNum ];
+		if ( traceEnt == ent) 
+		{
+			return qtrue;
+		}
+	}
+
+	//Actually, we should just check to fire in dir we're facing and if it's close enough,
+	//and we didn't hit someone on our own team, shoot
+	VectorSubtract(spot, tr.endpos, diff);
+	if(VectorLength(diff) < random() * 32)
+	{
+		return qtrue;
+	}
+//MCG - End
+	// shot would hit a non-client
+	if ( !traceEnt->client ) 
+	{
+		return qfalse;
+	}
+
+	// shot is blocked by another player
+
+	// he's already dead, so go ahead
+	if ( traceEnt->health <= 0 ) 
+	{
+		return qtrue;
+	}
+
+	// don't deliberately shoot a teammate
+	if ( traceEnt->client && ( traceEnt->client->playerTeam == shooter->client->playerTeam ) ) 
+	{
+		return qfalse;
+	}
+
+	// he's just in the wrong place, go ahead
+	return qtrue;
+}
+
+
+/*
+void NPC_CheckPossibleEnemy( gentity_t *other, visibility_t vis ) 
+
+Added: hacks for scripted NPCs
+*/
+void NPC_CheckPossibleEnemy( gentity_t *other, visibility_t vis ) 
+{
+	// is he is already our enemy?
+	if ( other == NPC->enemy ) 
+		return;
+
+	if ( other->flags & FL_NOTARGET ) 
+		return;
+
+	// we already have an enemy and this guy is in our FOV, see if this guy would be better
+	if ( NPC->enemy && vis == VIS_FOV ) 
+	{
+		if ( NPCInfo->enemyLastSeenTime - level.time < 2000 ) 
+		{
+			return;
+		}
+		if ( enemyVisibility == VIS_UNKNOWN ) 
+		{
+			enemyVisibility = NPC_CheckVisibility ( NPC->enemy, CHECK_360|CHECK_FOV );
+		}
+		if ( enemyVisibility == VIS_FOV ) 
+		{
+			return;
+		}
+	}
+
+	if ( !NPC->enemy )
+	{//only take an enemy if you don't have one yet
+		G_SetEnemy( NPC, other );
+	}
+
+	if ( vis == VIS_FOV ) 
+	{
+		NPCInfo->enemyLastSeenTime = level.time;
+		VectorCopy( other->currentOrigin, NPCInfo->enemyLastSeenLocation );
+		NPCInfo->enemyLastHeardTime = 0;
+		VectorClear( NPCInfo->enemyLastHeardLocation );
+	} 
+	else 
+	{
+		NPCInfo->enemyLastSeenTime = 0;
+		VectorClear( NPCInfo->enemyLastSeenLocation );
+		NPCInfo->enemyLastHeardTime = level.time;
+		VectorCopy( other->currentOrigin, NPCInfo->enemyLastHeardLocation );
+	}
+}
+
+
+//==========================================
+//MCG Added functions:
+//==========================================
+
+/*
+int NPC_AttackDebounceForWeapon (void)
+
+DOES NOT control how fast you can fire
+Only makes you keep your weapon up after you fire
+
+*/
+int NPC_AttackDebounceForWeapon (void)
+{
+	switch ( NPC->client->ps.weapon ) 
+	{
+/*
+	case WP_BLASTER://scav rifle
+		return 1000;
+		break;
+
+	case WP_BRYAR_PISTOL://prifle
+		return 3000;
+		break;
+
+	case WP_SABER:
+		return 100;
+		break;
+	
+
+	case WP_TRICORDER:
+		return 0;//tricorder
+		break;
+*/
+	case WP_SABER:
+		if ( NPC->client->NPC_class == CLASS_KYLE
+			&& (NPC->spawnflags&1) )
+		{
+			return Q_irand( 1500, 5000 );
+		}
+		else
+		{
+			return 0;
+		}
+		break;
+
+	case WP_BOT_LASER:
+		
+		if ( g_spskill->integer == 0 )
+			return 2000;
+
+		if ( g_spskill->integer == 1 )
+			return 1500;
+
+		return 1000;
+		break;
+
+	default:
+		return NPCInfo->burstSpacing + Q_irand(-100, 100);//was 100 by default
+		break;
+	}
+}
+
+//FIXME: need a mindist for explosive weapons
+float NPC_MaxDistSquaredForWeapon (void)
+{
+	if(NPCInfo->stats.shootDistance > 0)
+	{//overrides default weapon dist
+		return NPCInfo->stats.shootDistance * NPCInfo->stats.shootDistance;
+	}
+
+	switch ( NPC->s.weapon ) 
+	{
+	case WP_BLASTER://scav rifle
+		return 1024 * 1024;//should be shorter?
+		break;
+
+	case WP_BRYAR_PISTOL://prifle
+		return 1024 * 1024;
+		break;
+
+	case WP_BLASTER_PISTOL://prifle
+		return 1024 * 1024;
+		break;
+
+	case WP_DISRUPTOR://disruptor
+	case WP_TUSKEN_RIFLE:
+		if ( NPCInfo->scriptFlags & SCF_ALT_FIRE )
+		{
+			return ( 4096 * 4096 );
+		}
+		else
+		{
+			return 1024 * 1024;
+		}
+		break;
+/*
+	case WP_SABER:
+		return 1024 * 1024;
+		break;
+	
+
+	case WP_TRICORDER:
+		return 0;//tricorder
+		break;
+*/
+	case WP_SABER:
+		if ( NPC->client && NPC->client->ps.SaberLength() )
+		{//FIXME: account for whether enemy and I are heading towards each other!
+			return (NPC->client->ps.SaberLength() + NPC->maxs[0]*1.5)*(NPC->client->ps.SaberLength() + NPC->maxs[0]*1.5);
+		}
+		else
+		{
+			return 48*48;
+		}
+		break;
+
+	default:
+		return 1024 * 1024;//was 0
+		break;
+	}
+}
+
+
+
+qboolean NPC_EnemyTooFar(gentity_t *enemy, float dist, qboolean toShoot)
+{
+	vec3_t	vec;
+
+	
+	if ( !toShoot )
+	{//Not trying to actually press fire button with this check
+		if ( NPC->client->ps.weapon == WP_SABER )
+		{//Just have to get to him
+			return qfalse;
+		}
+	}
+	
+
+	if(!dist)
+	{
+		VectorSubtract(NPC->currentOrigin, enemy->currentOrigin, vec);
+		dist = VectorLengthSquared(vec);
+	}
+
+	if(dist > NPC_MaxDistSquaredForWeapon())
+		return qtrue;
+
+	return qfalse;
+}
+
+/*
+NPC_PickEnemy
+
+Randomly picks a living enemy from the specified team and returns it
+
+FIXME: For now, you MUST specify an enemy team
+
+If you specify choose closest, it will find only the closest enemy
+
+If you specify checkVis, it will return and enemy that is visible
+
+If you specify findPlayersFirst, it will try to find players first
+
+You can mix and match any of those options (example: find closest visible players first)
+
+FIXME: this should go through the snapshot and find the closest enemy
+*/
+gentity_t *NPC_PickEnemy( gentity_t *closestTo, int enemyTeam, qboolean checkVis, qboolean findPlayersFirst, qboolean findClosest )
+{
+	int			num_choices = 0;
+	int			choice[128];//FIXME: need a different way to determine how many choices?
+	gentity_t	*newenemy = NULL;
+	gentity_t	*closestEnemy = NULL;
+	int			entNum;
+	vec3_t		diff;
+	float		relDist;
+	float		bestDist = Q3_INFINITE;
+	qboolean	failed = qfalse;
+	int			visChecks = (CHECK_360|CHECK_FOV|CHECK_VISRANGE);
+	int			minVis = VIS_FOV;
+
+	if ( enemyTeam == TEAM_NEUTRAL )
+	{
+		return NULL;
+	}
+
+	if ( NPCInfo->behaviorState == BS_STAND_AND_SHOOT || 
+		NPCInfo->behaviorState == BS_HUNT_AND_KILL ) 
+	{//Formations guys don't require inFov to pick up a target
+		//These other behavior states are active battle states and should not
+		//use FOV.  FOV checks are for enemies who are patrolling, guarding, etc.
+		visChecks &= ~CHECK_FOV;
+		minVis = VIS_360;
+	}
+
+	if( findPlayersFirst )
+	{//try to find a player first
+		newenemy = &g_entities[0];
+		if( newenemy->client && !(newenemy->flags & FL_NOTARGET) && !(newenemy->s.eFlags & EF_NODRAW))
+		{
+			if( newenemy->health > 0 )
+			{
+				if( NPC_ValidEnemy( newenemy) )//enemyTeam == TEAM_PLAYER || newenemy->client->playerTeam == enemyTeam || ( enemyTeam == TEAM_PLAYER ) )
+				{//FIXME:  check for range and FOV or vis?
+					if( newenemy != NPC->lastEnemy )
+					{//Make sure we're not just going back and forth here
+						if ( gi.inPVS(newenemy->currentOrigin, NPC->currentOrigin) )
+						{
+							if(NPCInfo->behaviorState == BS_INVESTIGATE ||	NPCInfo->behaviorState == BS_PATROL)
+							{
+								if(!NPC->enemy)
+								{
+									if(!InVisrange(newenemy))
+									{
+										failed = qtrue;
+									}
+									else if(NPC_CheckVisibility ( newenemy, CHECK_360|CHECK_FOV|CHECK_VISRANGE ) != VIS_FOV)
+									{
+										failed = qtrue;
+									}
+								}
+							}
+
+							if ( !failed )
+							{
+								VectorSubtract( closestTo->currentOrigin, newenemy->currentOrigin, diff );
+								relDist = VectorLengthSquared(diff);
+								if ( newenemy->client->hiddenDist > 0 )
+								{
+									if( relDist > newenemy->client->hiddenDist*newenemy->client->hiddenDist )
+									{
+										//out of hidden range
+										if ( VectorLengthSquared( newenemy->client->hiddenDir ) )
+										{//They're only hidden from a certain direction, check
+											float	dot;
+											VectorNormalize( diff );
+											dot = DotProduct( newenemy->client->hiddenDir, diff ); 
+											if ( dot > 0.5 )
+											{//I'm not looking in the right dir toward them to see them 
+												failed = qtrue;
+											}
+											else
+											{
+												Debug_Printf(debugNPCAI, DEBUG_LEVEL_INFO, "%s saw %s trying to hide - hiddenDir %s targetDir %s dot %f\n", NPC->targetname, newenemy->targetname, vtos(newenemy->client->hiddenDir), vtos(diff), dot );
+											}
+										}
+										else
+										{
+											failed = qtrue;
+										}
+									}
+									else
+									{
+										Debug_Printf(debugNPCAI, DEBUG_LEVEL_INFO, "%s saw %s trying to hide - hiddenDist %f\n", NPC->targetname, newenemy->targetname, newenemy->client->hiddenDist );
+									}
+								}
+
+								if(!failed)
+								{
+									if(findClosest)
+									{
+										if(relDist < bestDist)
+										{
+											if(!NPC_EnemyTooFar(newenemy, relDist, qfalse))
+											{
+												if(checkVis)
+												{
+													if( NPC_CheckVisibility ( newenemy, visChecks ) == minVis )
+													{
+														bestDist = relDist;
+														closestEnemy = newenemy;
+													}
+												}
+												else
+												{
+													bestDist = relDist;
+													closestEnemy = newenemy;
+												}
+											}
+										}
+									}
+									else if(!NPC_EnemyTooFar(newenemy, 0, qfalse))
+									{
+										if(checkVis)
+										{
+											if( NPC_CheckVisibility ( newenemy, CHECK_360|CHECK_FOV|CHECK_VISRANGE ) == VIS_FOV )
+											{
+												choice[num_choices++] = newenemy->s.number;
+											}
+										}
+										else
+										{
+											choice[num_choices++] = newenemy->s.number;
+										}
+									}
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+
+	if (findClosest && closestEnemy)
+	{
+		return closestEnemy;
+	}
+
+	if (num_choices)
+	{
+		return &g_entities[ choice[rand() % num_choices] ];
+	}
+
+	/*
+	//FIXME: used to have an option to look *only* for the player... now...?  Still need it?
+	if ( enemyTeam == TEAM_PLAYER )
+	{//couldn't find the player
+		return NULL;
+	}
+	*/
+
+	num_choices = 0;
+	bestDist = Q3_INFINITE;
+	closestEnemy = NULL;
+
+	for ( entNum = 0; entNum < globals.num_entities; entNum++ )
+	{
+		newenemy = &g_entities[entNum];
+
+		if ( newenemy != NPC && (newenemy->client || newenemy->svFlags & SVF_NONNPC_ENEMY) && !(newenemy->flags & FL_NOTARGET) && !(newenemy->s.eFlags & EF_NODRAW))
+		{
+			if ( newenemy->health > 0 )
+			{
+				if ( (newenemy->client && NPC_ValidEnemy( newenemy))
+					|| (!newenemy->client && newenemy->noDamageTeam == enemyTeam) )
+				{//FIXME:  check for range and FOV or vis?
+					if ( NPC->client->playerTeam == TEAM_PLAYER && enemyTeam == TEAM_PLAYER )
+					{//player allies turning on ourselves?  How?
+						if ( newenemy->s.number )
+						{//only turn on the player, not other player allies
+							continue;
+						}
+					}
+
+					if ( newenemy != NPC->lastEnemy )
+					{//Make sure we're not just going back and forth here
+						if(!gi.inPVS(newenemy->currentOrigin, NPC->currentOrigin))
+						{
+							continue;
+						}
+
+						if ( NPCInfo->behaviorState == BS_INVESTIGATE || NPCInfo->behaviorState == BS_PATROL )
+						{
+							if ( !NPC->enemy )
+							{
+								if ( !InVisrange( newenemy ) )
+								{
+									continue;
+								}
+								else if ( NPC_CheckVisibility ( newenemy, CHECK_360|CHECK_FOV|CHECK_VISRANGE ) != VIS_FOV )
+								{
+									continue;
+								}
+							}
+						}
+
+						VectorSubtract( closestTo->currentOrigin, newenemy->currentOrigin, diff );
+						relDist = VectorLengthSquared(diff);
+						if ( newenemy->client && newenemy->client->hiddenDist > 0 )
+						{
+							if( relDist > newenemy->client->hiddenDist*newenemy->client->hiddenDist )
+							{
+								//out of hidden range
+								if ( VectorLengthSquared( newenemy->client->hiddenDir ) )
+								{//They're only hidden from a certain direction, check
+									float	dot;
+
+									VectorNormalize( diff );
+									dot = DotProduct( newenemy->client->hiddenDir, diff ); 
+									if ( dot > 0.5 )
+									{//I'm not looking in the right dir toward them to see them 
+										continue;
+									}
+									else
+									{
+										Debug_Printf(debugNPCAI, DEBUG_LEVEL_INFO, "%s saw %s trying to hide - hiddenDir %s targetDir %s dot %f\n", NPC->targetname, newenemy->targetname, vtos(newenemy->client->hiddenDir), vtos(diff), dot );
+									}
+								}
+								else
+								{
+									continue;
+								}
+							}
+							else
+							{
+								Debug_Printf(debugNPCAI, DEBUG_LEVEL_INFO, "%s saw %s trying to hide - hiddenDist %f\n", NPC->targetname, newenemy->targetname, newenemy->client->hiddenDist );
+							}
+						}
+
+						if ( findClosest )
+						{
+							if ( relDist < bestDist )
+							{
+								if ( !NPC_EnemyTooFar( newenemy, relDist, qfalse ) )
+								{
+									if ( checkVis )
+									{
+										//FIXME: NPCs need to be able to pick up other NPCs behind them,
+										//but for now, commented out because it was picking up enemies it shouldn't
+										//if ( NPC_CheckVisibility ( newenemy, CHECK_360|CHECK_VISRANGE ) >= VIS_360 )
+										if ( NPC_CheckVisibility ( newenemy, visChecks ) == minVis )
+										{
+											bestDist = relDist;
+											closestEnemy = newenemy;
+										}
+									}
+									else
+									{
+										bestDist = relDist;
+										closestEnemy = newenemy;
+									}
+								}
+							}
+						}
+						else if ( !NPC_EnemyTooFar( newenemy, 0, qfalse ) )
+						{
+							if ( checkVis )
+							{
+								//if( NPC_CheckVisibility ( newenemy, CHECK_360|CHECK_FOV|CHECK_VISRANGE ) == VIS_FOV )
+								if ( NPC_CheckVisibility ( newenemy, CHECK_360|CHECK_VISRANGE ) >= VIS_360 )
+								{
+									choice[num_choices++] = newenemy->s.number;
+								}
+							}
+							else
+							{
+								choice[num_choices++] = newenemy->s.number;
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+
+	
+	if (findClosest)
+	{//FIXME: you can pick up an enemy around a corner this way.
+		return closestEnemy;
+	}
+
+	if (!num_choices)
+	{
+		return NULL;
+	}
+
+	return &g_entities[ choice[rand() % num_choices] ];
+}
+
+/*
+gentity_t *NPC_PickAlly ( void )
+
+  Simply returns closest visible ally
+*/
+
+gentity_t *NPC_PickAlly ( qboolean facingEachOther, float range, qboolean ignoreGroup, qboolean movingOnly )
+{
+	gentity_t	*ally = NULL;
+	gentity_t	*closestAlly = NULL;
+	int			entNum;
+	vec3_t		diff;
+	float		relDist;
+	float		bestDist = range;
+
+	for ( entNum = 0; entNum < globals.num_entities; entNum++ )
+	{
+		ally = &g_entities[entNum];
+
+		if ( ally->client )
+		{
+			if ( ally->health > 0 )
+			{
+				if ( ally->client && ( ally->client->playerTeam == NPC->client->playerTeam ||
+					 NPC->client->playerTeam == TEAM_ENEMY ) )// && ally->client->playerTeam == TEAM_DISGUISE ) ) )
+				{//if on same team or if player is disguised as your team
+					if ( ignoreGroup )
+					{
+						if ( ally == NPC->client->leader )
+						{
+							//reject
+							continue;
+						}
+						if ( ally->client && ally->client->leader && ally->client->leader == NPC )
+						{
+							//reject
+							continue;
+						}
+					}
+
+					if(!gi.inPVS(ally->currentOrigin, NPC->currentOrigin))
+					{
+						continue;
+					}
+
+					if ( movingOnly && ally->client && NPC->client )
+					{//They have to be moving relative to each other
+						if ( !DistanceSquared( ally->client->ps.velocity, NPC->client->ps.velocity ) )
+						{
+							continue;
+						}
+					}
+
+					VectorSubtract( NPC->currentOrigin, ally->currentOrigin, diff );
+					relDist = VectorNormalize( diff );
+					if ( relDist < bestDist )
+					{
+						if ( facingEachOther )
+						{
+							vec3_t	vf;
+							float	dot;
+
+							AngleVectors( ally->client->ps.viewangles, vf, NULL, NULL );
+							VectorNormalize(vf);
+							dot = DotProduct(diff, vf);
+
+							if ( dot < 0.5 )
+							{//Not facing in dir to me
+								continue;
+							}
+							//He's facing me, am I facing him?
+							AngleVectors( NPC->client->ps.viewangles, vf, NULL, NULL );
+							VectorNormalize(vf);
+							dot = DotProduct(diff, vf);
+
+							if ( dot > -0.5 )
+							{//I'm not facing opposite of dir to me
+								continue;
+							}
+							//I am facing him
+						}
+
+						if ( NPC_CheckVisibility ( ally, CHECK_360|CHECK_VISRANGE ) >= VIS_360 )
+						{
+							bestDist = relDist;
+							closestAlly = ally;
+						}
+					}
+				}
+			}
+		}
+	}
+
+	
+	return closestAlly;
+}
+
+gentity_t *NPC_CheckEnemy( qboolean findNew, qboolean tooFarOk, qboolean setEnemy )
+{
+	qboolean	forcefindNew = qfalse;
+	gentity_t	*closestTo;
+	gentity_t	*newEnemy = NULL;
+	//FIXME: have a "NPCInfo->persistance" we can set to determine how long to try to shoot
+	//someone we can't hit?  Rather than hard-coded 10?
+
+	//FIXME they shouldn't recognize enemy's death instantly
+
+	//TEMP FIX:
+	//if(NPC->enemy->client)
+	//{
+	//	NPC->enemy->health = NPC->enemy->client->ps.stats[STAT_HEALTH];
+	//}
+
+	if ( NPC->enemy )
+	{
+		if ( !NPC->enemy->inuse )//|| NPC->enemy == NPC )//wtf?  NPCs should never get mad at themselves!
+		{
+			if ( setEnemy )
+			{
+				G_ClearEnemy( NPC );
+			}
+		}
+	}
+
+	if ( NPC->svFlags & SVF_IGNORE_ENEMIES )
+	{//We're ignoring all enemies for now
+		if ( setEnemy )
+		{
+			G_ClearEnemy( NPC );
+		}
+		return NULL;
+	}
+
+	// Kyle does not get new enemies if not close to his leader
+	if (NPC->client->NPC_class==CLASS_KYLE &&
+		NPC->client->leader &&
+		Distance(NPC->client->leader->currentOrigin, NPC->currentOrigin)>3000
+		)
+	{
+		if (NPC->enemy)
+		{
+			G_ClearEnemy( NPC );
+		}
+		return NULL;
+	}
+
+
+	if ( NPC->svFlags & SVF_LOCKEDENEMY )
+	{//keep this enemy until dead
+		if ( NPC->enemy )
+		{
+			if ( (!NPC->NPC && !(NPC->svFlags & SVF_NONNPC_ENEMY) ) || NPC->enemy->health > 0 )
+			{//Enemy never had health (a train or info_not_null, etc) or did and is now dead (NPCs, turrets, etc)
+				return NULL;
+			}
+		}
+		NPC->svFlags &= ~SVF_LOCKEDENEMY;
+	}
+
+	if ( NPC->enemy )
+	{
+		if ( NPC_EnemyTooFar(NPC->enemy, 0, qfalse) )
+		{
+			if(findNew)
+			{//See if there is a close one and take it if so, else keep this one
+				forcefindNew = qtrue;
+			}
+			else if(!tooFarOk)//FIXME: don't need this extra bool any more
+			{
+				if ( setEnemy )
+				{
+					G_ClearEnemy( NPC );
+				}
+			}
+		}
+		else if ( !gi.inPVS(NPC->currentOrigin, NPC->enemy->currentOrigin ) )
+		{//FIXME: should this be a line-of site check?
+			//FIXME: a lot of things check PVS AGAIN when deciding whether 
+			//or not to shoot, redundant!
+			//Should we lose the enemy?
+			//FIXME: if lose enemy, run lostenemyscript
+			if ( NPC->enemy->client && NPC->enemy->client->hiddenDist )
+			{//He ducked into shadow while we weren't looking
+				//Drop enemy and see if we should search for him
+				NPC_LostEnemyDecideChase();
+			}
+			else
+			{//If we're not chasing him, we need to lose him
+				//NOTE: since we no longer have bStates, really, this logic doesn't work, so never give him up
+
+				/*
+				switch( NPCInfo->behaviorState )
+				{
+				case BS_HUNT_AND_KILL:
+					//Okay to lose PVS, we're chasing them
+					break;
+				case BS_RUN_AND_SHOOT:
+				//FIXME: only do this if !(NPCInfo->scriptFlags&SCF_CHASE_ENEMY)
+					//If he's not our goalEntity, we're running somewhere else, so lose him
+					if ( NPC->enemy != NPCInfo->goalEntity )
+					{
+						G_ClearEnemy( NPC );
+					}
+					break;
+				default:
+					//We're not chasing him, so lose him as an enemy
+					G_ClearEnemy( NPC );
+					break;
+				}
+				*/
+			}
+		}
+	}
+
+	if ( NPC->enemy )
+	{
+		if ( NPC->enemy->health <= 0 || NPC->enemy->flags & FL_NOTARGET )
+		{
+			if ( setEnemy )
+			{
+				G_ClearEnemy( NPC );
+			}
+		}
+	}
+
+	closestTo = NPC;
+	//FIXME: check your defendEnt, if you have one, see if their enemy is different 
+	//than yours, or, if they don't have one, pick the closest enemy to THEM?
+	if ( NPCInfo->defendEnt )
+	{//Trying to protect someone
+		if ( NPCInfo->defendEnt->health > 0 )
+		{//Still alive, We presume we're close to them, navigation should handle this?
+			if ( NPCInfo->defendEnt->enemy )
+			{//They were shot or acquired an enemy
+				if ( NPC->enemy != NPCInfo->defendEnt->enemy )
+				{//They have a different enemy, take it!
+					newEnemy = NPCInfo->defendEnt->enemy;
+					if ( setEnemy )
+					{
+						G_SetEnemy( NPC, NPCInfo->defendEnt->enemy );
+					}
+				}
+			}
+			else if ( NPC->enemy == NULL )
+			{//We don't have an enemy, so find closest to defendEnt
+				closestTo = NPCInfo->defendEnt;
+			}
+		}
+	}
+
+	if (!NPC->enemy || ( NPC->enemy && NPC->enemy->health <= 0 ) || forcefindNew )
+	{//FIXME: NPCs that are moving after an enemy should ignore the can't hit enemy counter- that should only be for NPCs that are standing still
+		//NOTE: cantHitEnemyCounter >= 100 means we couldn't hit enemy for a full
+		//	10 seconds, so give up.  This means even if we're chasing him, we would
+		//	try to find another enemy after 10 seconds (assuming the cantHitEnemyCounter
+		//	is allowed to increment in a chasing bState)
+		qboolean	foundenemy = qfalse;
+
+		if(!findNew)
+		{
+			if ( setEnemy )
+			{
+				NPC->lastEnemy = NPC->enemy;
+				G_ClearEnemy(NPC);
+			}
+			return NULL;
+		}
+
+		//If enemy dead or unshootable, look for others on out enemy's team
+		if ( NPC->client->enemyTeam != TEAM_NEUTRAL)
+		{
+			//NOTE:  this only checks vis if can't hit enemy for 10 tries, which I suppose
+			//			means they need to find one that in more than just PVS
+			//newenemy = NPC_PickEnemy( closestTo, NPC->client->enemyTeam, (NPC->cantHitEnemyCounter > 10), qfalse, qtrue );//3rd parm was (NPC->enemyTeam == TEAM_STARFLEET)
+			//For now, made it so you ALWAYS have to check VIS
+			newEnemy = NPC_PickEnemy( closestTo, NPC->client->enemyTeam, qtrue, qfalse, qtrue );//3rd parm was (NPC->enemyTeam == TEAM_STARFLEET)
+			if ( newEnemy )
+			{
+				foundenemy = qtrue;
+				if ( setEnemy )
+				{
+					G_SetEnemy( NPC, newEnemy );
+				}
+			}
+		}
+		
+		//if ( !forcefindNew )
+		{
+			if ( !foundenemy )
+			{
+				if ( setEnemy )
+				{
+					NPC->lastEnemy = NPC->enemy;
+					G_ClearEnemy(NPC);
+				}
+			}
+			
+			NPC->cantHitEnemyCounter = 0;
+		}
+		//FIXME: if we can't find any at all, go into INdependant NPC AI, pursue and kill
+	}
+
+	if ( NPC->enemy && NPC->enemy->client ) 
+	{
+		if(NPC->enemy->client->playerTeam
+			&& NPC->enemy->client->playerTeam != TEAM_FREE)
+		{
+//			assert( NPC->client->playerTeam != NPC->enemy->client->playerTeam);
+			if( NPC->client->playerTeam != NPC->enemy->client->playerTeam 
+				&& NPC->client->enemyTeam != TEAM_FREE 
+				&& NPC->client->enemyTeam != NPC->enemy->client->playerTeam )
+			{
+				NPC->client->enemyTeam = NPC->enemy->client->playerTeam;
+			}
+		}
+	}
+	return newEnemy;
+}
+
+/*
+-------------------------
+NPC_ClearShot
+-------------------------
+*/
+
+qboolean NPC_ClearShot( gentity_t *ent )
+{
+	if ( ( NPC == NULL ) || ( ent == NULL ) )
+		return qfalse;
+
+	vec3_t	muzzle;
+	trace_t	tr;
+
+	CalcEntitySpot( NPC, SPOT_WEAPON, muzzle );
+
+	// add aim error
+	// use weapon instead of specific npc types, although you could add certain npc classes if you wanted
+//	if ( NPC->client->playerTeam == TEAM_SCAVENGERS )
+	if( NPC->s.weapon == WP_BLASTER || NPC->s.weapon == WP_BLASTER_PISTOL ) // any other guns to check for?
+	{
+		vec3_t	mins = { -2, -2, -2 };
+		vec3_t	maxs = {  2,  2,  2 };
+
+		gi.trace ( &tr, muzzle, mins, maxs, ent->currentOrigin, NPC->s.number, MASK_SHOT );
+	}
+	else
+	{
+		gi.trace ( &tr, muzzle, NULL, NULL, ent->currentOrigin, NPC->s.number, MASK_SHOT );
+	}
+	
+	if ( tr.startsolid || tr.allsolid )
+	{
+		return qfalse;
+	}
+
+	if ( tr.entityNum == ent->s.number ) 
+		return qtrue;
+	
+	return qfalse;
+}
+
+/*
+-------------------------
+NPC_ShotEntity
+-------------------------
+*/
+
+int NPC_ShotEntity( gentity_t *ent, vec3_t impactPos )
+{
+	if ( ( NPC == NULL ) || ( ent == NULL ) )
+		return qfalse;
+
+	vec3_t	muzzle;
+	vec3_t targ;
+	trace_t	tr;
+
+	if ( NPC->s.weapon == WP_THERMAL )
+	{//thermal aims from slightly above head
+		//FIXME: what about low-angle shots, rolling the thermal under something?
+		vec3_t	angles, forward, end;
+
+		CalcEntitySpot( NPC, SPOT_HEAD, muzzle );
+		VectorSet( angles, 0, NPC->client->ps.viewangles[1], 0 );
+		AngleVectors( angles, forward, NULL, NULL );
+		VectorMA( muzzle, 8, forward, end );
+		end[2] += 24;
+		gi.trace ( &tr, muzzle, vec3_origin, vec3_origin, end, NPC->s.number, MASK_SHOT );
+		VectorCopy( tr.endpos, muzzle );
+	}
+	else
+	{
+		CalcEntitySpot( NPC, SPOT_WEAPON, muzzle );
+	}
+	CalcEntitySpot( ent, SPOT_CHEST, targ );
+	
+	// add aim error
+	// use weapon instead of specific npc types, although you could add certain npc classes if you wanted
+//	if ( NPC->client->playerTeam == TEAM_SCAVENGERS )
+	if( NPC->s.weapon == WP_BLASTER || NPC->s.weapon == WP_BLASTER_PISTOL ) // any other guns to check for?
+	{
+		vec3_t	mins = { -2, -2, -2 };
+		vec3_t	maxs = {  2,  2,  2 };
+
+		gi.trace ( &tr, muzzle, mins, maxs, targ, NPC->s.number, MASK_SHOT );
+	}
+	else
+	{
+		gi.trace ( &tr, muzzle, NULL, NULL, targ, NPC->s.number, MASK_SHOT );
+	}
+	//FIXME: if using a bouncing weapon like the bowcaster, should we check the reflection of the wall, too?
+	if ( impactPos )
+	{//they want to know *where* the hit would be, too
+		VectorCopy( tr.endpos, impactPos );
+	}
+/* // NPCs should be able to shoot even if the muzzle would be inside their target
+	if ( tr.startsolid || tr.allsolid )
+	{
+		return ENTITYNUM_NONE;
+	}
+*/
+	return tr.entityNum;
+}
+
+qboolean NPC_EvaluateShot( int hit, qboolean glassOK )
+{
+	if ( !NPC->enemy )
+	{
+		return qfalse;
+	}
+
+	if ( hit == NPC->enemy->s.number || (&g_entities[hit] != NULL && (g_entities[hit].svFlags&SVF_GLASS_BRUSH)) )
+	{//can hit enemy or will hit glass, so shoot anyway
+		return qtrue;
+	}
+	return qfalse;
+}
+
+/*
+NPC_CheckAttack
+
+Simply checks aggression and returns true or false
+*/
+
+qboolean NPC_CheckAttack (float scale)
+{
+	if(!scale)
+		scale = 1.0;
+
+	if(((float)NPCInfo->stats.aggression) * scale < Q_flrand(0, 4))
+	{
+		return qfalse;
+	}
+
+	if(NPCInfo->shotTime > level.time)
+		return qfalse;
+
+	return qtrue;
+}
+
+/*
+NPC_CheckDefend
+
+Simply checks evasion and returns true or false
+*/
+
+qboolean NPC_CheckDefend (float scale)
+{
+	if(!scale)
+		scale = 1.0;
+
+	if((float)(NPCInfo->stats.evasion) > random() * 4 * scale)
+		return qtrue;
+
+	return qfalse;
+}
+
+
+//NOTE: BE SURE TO CHECK PVS BEFORE THIS!
+qboolean NPC_CheckCanAttack (float attack_scale, qboolean stationary)
+{
+	vec3_t		delta, forward;
+	vec3_t		angleToEnemy;
+	vec3_t		hitspot, muzzle, diff, enemy_org;//, enemy_head;
+	float		distanceToEnemy;
+	qboolean	attack_ok = qfalse;
+//	qboolean	duck_ok = qfalse;
+	qboolean	dead_on = qfalse;
+	float		aim_off;
+	float		max_aim_off = 128 - (16 * (float)NPCInfo->stats.aim);
+	trace_t		tr;
+	gentity_t	*traceEnt = NULL;
+
+	if(NPC->enemy->flags & FL_NOTARGET)
+	{
+		return qfalse;
+	}
+
+	//FIXME: only check to see if should duck if that provides cover from the
+	//enemy!!!
+	if(!attack_scale)
+	{
+		attack_scale = 1.0;
+	}
+	//Yaw to enemy
+	CalcEntitySpot( NPC->enemy, SPOT_HEAD, enemy_org );
+	NPC_AimWiggle( enemy_org );
+
+	CalcEntitySpot( NPC, SPOT_WEAPON, muzzle );
+	
+	VectorSubtract (enemy_org, muzzle, delta);
+	vectoangles ( delta, angleToEnemy );
+	distanceToEnemy = VectorNormalize(delta);
+
+	NPC->NPC->desiredYaw = angleToEnemy[YAW];
+	NPC_UpdateFiringAngles(qfalse, qtrue);
+
+	if( NPC_EnemyTooFar(NPC->enemy, distanceToEnemy*distanceToEnemy, qtrue) )
+	{//Too far away?  Do not attack
+		return qfalse;
+	}
+
+	if(client->fireDelay > 0)
+	{//already waiting for a shot to fire
+		NPC->NPC->desiredPitch = angleToEnemy[PITCH];
+		NPC_UpdateFiringAngles(qtrue, qfalse);
+		return qfalse;
+	}
+
+	if(NPCInfo->scriptFlags & SCF_DONT_FIRE)
+	{
+		return qfalse;
+	}
+
+	NPCInfo->enemyLastVisibility = enemyVisibility;
+	//See if they're in our FOV and we have a clear shot to them
+	enemyVisibility = NPC_CheckVisibility ( NPC->enemy, CHECK_360|CHECK_FOV);////CHECK_PVS|
+
+	if(enemyVisibility >= VIS_FOV)
+	{//He's in our FOV
+		
+		attack_ok = qtrue;
+		//CalcEntitySpot( NPC->enemy, SPOT_HEAD, enemy_head);
+
+		//Check to duck
+		if ( NPC->enemy->client )
+		{
+			if ( NPC->enemy->enemy == NPC )
+			{
+				if ( NPC->enemy->client->buttons & BUTTON_ATTACK )
+				{//FIXME: determine if enemy fire angles would hit me or get close
+					if ( NPC_CheckDefend( 1.0 ) )//FIXME: Check self-preservation?  Health?
+					{//duck and don't shoot
+						attack_ok = qfalse;
+						ucmd.upmove = -127;
+					}
+				}
+			}
+		}
+
+		if(attack_ok)
+		{
+			//are we gonna hit him
+			//NEW: use actual forward facing
+			AngleVectors( client->ps.viewangles, forward, NULL, NULL );
+			VectorMA( muzzle, distanceToEnemy, forward, hitspot );
+			gi.trace( &tr, muzzle, NULL, NULL, hitspot, NPC->s.number, MASK_SHOT );
+			ShotThroughGlass( &tr, NPC->enemy, hitspot, MASK_SHOT );
+			/*
+			//OLD: trace regardless of facing
+			gi.trace ( &tr, muzzle, NULL, NULL, enemy_org, NPC->s.number, MASK_SHOT );
+			ShotThroughGlass(&tr, NPC->enemy, enemy_org, MASK_SHOT);
+			*/
+
+			traceEnt = &g_entities[tr.entityNum];
+
+			/*
+			if( traceEnt != NPC->enemy &&//FIXME: if someone on our team is in the way, suggest that they duck if possible
+				(!traceEnt || !traceEnt->client || !NPC->client->enemyTeam || NPC->client->enemyTeam != traceEnt->client->playerTeam) )
+			{//no, so shoot for somewhere between the head and torso
+				//NOTE: yes, I know this looks weird, but it works
+				enemy_org[0] += 0.3*Q_flrand(NPC->enemy->mins[0], NPC->enemy->maxs[0]);
+				enemy_org[1] += 0.3*Q_flrand(NPC->enemy->mins[1], NPC->enemy->maxs[1]);
+				enemy_org[2] -= NPC->enemy->maxs[2]*Q_flrand(0.0f, 1.0f);
+
+				attack_scale *= 0.75;
+				gi.trace ( &tr, muzzle, NULL, NULL, enemy_org, NPC->s.number, MASK_SHOT );
+				ShotThroughGlass(&tr, NPC->enemy, enemy_org, MASK_SHOT);
+				traceEnt = &g_entities[tr.entityNum];
+			}
+			*/
+
+			VectorCopy( tr.endpos, hitspot );
+
+			if( traceEnt == NPC->enemy || (traceEnt->client && NPC->client->enemyTeam && NPC->client->enemyTeam == traceEnt->client->playerTeam) )
+			{
+				dead_on = qtrue;
+			}
+			else
+			{
+				attack_scale *= 0.5;
+				if(NPC->client->playerTeam)
+				{
+					if(traceEnt && traceEnt->client && traceEnt->client->playerTeam)
+					{
+						if(NPC->client->playerTeam == traceEnt->client->playerTeam)
+						{//Don't shoot our own team
+							attack_ok = qfalse;
+						}
+					}
+				}
+			}
+		}
+
+		if( attack_ok )
+		{
+			//ok, now adjust pitch aim
+			VectorSubtract (hitspot, muzzle, delta);
+			vectoangles ( delta, angleToEnemy );
+			NPC->NPC->desiredPitch = angleToEnemy[PITCH];
+			NPC_UpdateFiringAngles(qtrue, qfalse);
+
+			if( !dead_on )
+			{//We're not going to hit him directly, try a suppressing fire
+				//see if where we're going to shoot is too far from his origin
+				if(traceEnt && (traceEnt->health <= 30 || EntIsGlass(traceEnt)))
+				{//easy to kill - go for it
+					if(traceEnt->e_DieFunc == dieF_ExplodeDeath_Wait && traceEnt->splashDamage)
+					{//going to explode, don't shoot if close to self
+						VectorSubtract(NPC->currentOrigin, traceEnt->currentOrigin, diff);
+						if(VectorLengthSquared(diff) < traceEnt->splashRadius*traceEnt->splashRadius)
+						{//Too close to shoot!
+							attack_ok = qfalse;
+						}
+						else 
+						{//Hey, it might kill him, do it!
+							attack_scale *= 2;//
+						}
+					}
+				}
+				else
+				{
+					AngleVectors (client->ps.viewangles, forward, NULL, NULL);
+					VectorMA ( muzzle, distanceToEnemy, forward, hitspot);
+					VectorSubtract(hitspot, enemy_org, diff);
+					aim_off = VectorLength(diff);
+					if(aim_off > random() * max_aim_off)//FIXME: use aim value to allow poor aim?
+					{
+						attack_scale *= 0.75;
+						//see if where we're going to shoot is too far from his head
+						VectorSubtract(hitspot, enemy_org, diff);
+						aim_off = VectorLength(diff);
+						if(aim_off > random() * max_aim_off)
+						{
+							attack_ok = qfalse;
+						}
+					}
+					attack_scale *= (max_aim_off - aim_off + 1)/max_aim_off;
+				}
+			}
+		}
+	}
+	else
+	{//Update pitch anyway
+		NPC->NPC->desiredPitch = angleToEnemy[PITCH];
+		NPC_UpdateFiringAngles(qtrue, qfalse);
+	}
+
+	if( attack_ok )
+	{
+		if( NPC_CheckAttack( attack_scale ))
+		{//check aggression to decide if we should shoot
+			enemyVisibility = VIS_SHOOT;
+			WeaponThink(qtrue);
+		}
+		else
+			attack_ok = qfalse;
+	}
+
+	return attack_ok;
+}
+//========================================================================================
+//OLD id-style hunt and kill
+//========================================================================================
+/*
+IdealDistance
+
+determines what the NPC's ideal distance from it's enemy should
+be in the current situation
+*/
+float IdealDistance ( gentity_t *self ) 
+{
+	float	ideal;
+
+	ideal = 225 - 20 * NPCInfo->stats.aggression;
+	switch ( NPC->s.weapon ) 
+	{
+	case WP_ROCKET_LAUNCHER:
+		ideal += 200;
+		break;
+
+	case WP_CONCUSSION:
+		ideal += 200;
+		break;
+
+	case WP_THERMAL:
+		ideal += 50;
+		break;
+
+/*	case WP_TRICORDER:
+		ideal = 0;
+		break;
+*/
+	case WP_SABER:
+	case WP_BRYAR_PISTOL:
+	case WP_BLASTER_PISTOL:
+	case WP_BLASTER:
+	default:
+		break;
+	}
+
+	return ideal;
+}
+
+/*QUAKED point_combat (0.7 0 0.7) (-20 -20 -24) (20 20 45) DUCK FLEE INVESTIGATE SQUAD LEAN SNIPE
+NPCs in bState BS_COMBAT_POINT will find their closest empty combat_point
+
+DUCK - NPC will duck and fire from this point, NOT IMPLEMENTED?
+FLEE - Will choose this point when running
+INVESTIGATE - Will look here if a sound is heard near it
+SQUAD - NOT IMPLEMENTED
+LEAN - Lean-type cover, NOT IMPLEMENTED
+SNIPE - Snipers look for these first, NOT IMPLEMENTED
+*/
+
+void SP_point_combat( gentity_t *self )
+{
+	if(level.numCombatPoints >= MAX_COMBAT_POINTS)
+	{
+#ifndef FINAL_BUILD
+		gi.Printf(S_COLOR_RED"ERROR:  Too many combat points, limit is %d\n", MAX_COMBAT_POINTS);
+#endif
+		G_FreeEntity(self);
+		return;
+	}
+
+	self->s.origin[2] += 0.125;
+	G_SetOrigin(self, self->s.origin);
+	gi.linkentity(self);
+
+	if ( G_CheckInSolid( self, qtrue ) )
+	{
+#ifndef FINAL_BUILD
+		gi.Printf( S_COLOR_RED"ERROR: combat point at %s in solid!\n", vtos(self->currentOrigin) );
+#endif
+	}
+
+	VectorCopy( self->currentOrigin, level.combatPoints[level.numCombatPoints].origin );
+
+	level.combatPoints[level.numCombatPoints].flags = self->spawnflags;
+	level.combatPoints[level.numCombatPoints].occupied = qfalse;
+
+	level.numCombatPoints++;
+
+	NAV::SpawnedPoint(self, NAV::PT_COMBATNODE);
+
+	G_FreeEntity(self);
+};
+
+void CP_FindCombatPointWaypoints( void )
+{
+	for ( int i = 0; i < level.numCombatPoints; i++ )
+	{
+		level.combatPoints[i].waypoint = NAV::GetNearestNode(level.combatPoints[i].origin);
+		if ( level.combatPoints[i].waypoint == WAYPOINT_NONE )
+		{
+			assert(0);
+			level.combatPoints[i].waypoint = NAV::GetNearestNode(level.combatPoints[i].origin);
+			gi.Printf( S_COLOR_RED"ERROR: Combat Point at %s has no waypoint!\n", vtos(level.combatPoints[i].origin) );
+			delayedShutDown = level.time + 100;
+		}
+	}
+}
+
+
+/*
+-------------------------
+NPC_CollectCombatPoints
+-------------------------
+*/
+
+typedef	map< float, int >	combatPoint_m;
+
+static int NPC_CollectCombatPoints( const vec3_t origin, const float radius, combatPoint_m &points, const int flags )
+{
+	float	radiusSqr = (radius*radius);
+	float	distance;
+
+	//Collect all nearest
+	for ( int i = 0; i < level.numCombatPoints; i++ )
+	{
+		//Must be vacant
+		if ( level.combatPoints[i].occupied == (int) qtrue )
+			continue;
+
+		//If we want a duck space, make sure this is one
+		if ( ( flags & CP_DUCK ) && !( level.combatPoints[i].flags & CPF_DUCK ) )
+			continue;
+
+		//If we want a flee point, make sure this is one
+		if ( ( flags & CP_FLEE ) && !( level.combatPoints[i].flags & CPF_FLEE ) )
+			continue;
+
+		//If we want a snipe point, make sure this is one
+		if ( ( flags & CP_SNIPE ) && !( level.combatPoints[i].flags & CPF_SNIPE ) )
+			continue;
+
+		///Make sure this is an investigate combat point
+		if ( ( flags & CP_INVESTIGATE ) && ( level.combatPoints[i].flags & CPF_INVESTIGATE ) )
+			continue;
+		
+		//Squad points are only valid if we're looking for them
+		if ( ( level.combatPoints[i].flags & CPF_SQUAD ) && ( ( flags & CP_SQUAD ) == qfalse ) )
+			continue;
+
+		if ( flags&CP_NO_PVS )
+		{//must not be within PVS of mu current origin
+			if ( gi.inPVS( origin, level.combatPoints[i].origin ) )
+			{
+				continue;
+			}
+		}
+
+		if ( flags&CP_HORZ_DIST_COLL )
+		{
+			distance = 	DistanceHorizontalSquared( origin, level.combatPoints[i].origin );
+		}
+		else
+		{
+			distance = 	DistanceSquared( origin, level.combatPoints[i].origin );
+		}
+
+		if ( distance < radiusSqr )
+		{
+			//Using a map will sort nearest automatically
+			points[ distance ] = i;
+		}
+	}
+
+	return points.size();
+}
+
+/*
+-------------------------
+NPC_FindCombatPoint
+-------------------------
+*/
+
+#define	MIN_AVOID_DOT				0.7f
+#define MIN_AVOID_DISTANCE			128
+#define MIN_AVOID_DISTANCE_SQUARED	( MIN_AVOID_DISTANCE * MIN_AVOID_DISTANCE )
+#define	CP_COLLECT_RADIUS			512.0f
+
+int NPC_FindCombatPoint( const vec3_t position, const vec3_t avoidPosition, vec3_t destPosition, const int flags, float avoidDist, const int ignorePoint )
+{
+	combatPoint_m			points;
+	combatPoint_m::iterator	cpi;
+
+	int						best = -1;//, cost, bestCost = Q3_INFINITE, waypoint = WAYPOINT_NONE, destWaypoint = WAYPOINT_NONE;
+	trace_t					tr;
+	float					collRad = CP_COLLECT_RADIUS;
+	vec3_t					eDir2Me, eDir2CP, weaponOffset;
+	vec3_t					enemyPosition;
+	float					dotToCp;
+	float					distSqPointToNPC;
+	float					distSqPointToEnemy;
+	float					distSqPointToEnemyHoriz;
+	float					distSqPointToEnemyCheck;
+	float					distSqNPCToEnemy;
+	float					distSqNPCToEnemyHoriz;
+	float					distSqNPCToEnemyCheck;
+	float					visRangeSq = (NPCInfo->stats.visrange*NPCInfo->stats.visrange);
+	bool					useHorizDist = (NPC->s.weapon==WP_THERMAL) || (flags & CP_HORZ_DIST_COLL);
+
+	if (NPC->enemy)
+	{
+		VectorCopy(NPC->enemy->currentOrigin, enemyPosition);
+	}
+	else if (avoidPosition)
+	{
+		VectorCopy(avoidPosition, enemyPosition);
+	}
+	else if (destPosition)
+	{
+		VectorCopy(destPosition, enemyPosition);
+	}
+	else
+	{
+		VectorCopy(NPC->currentOrigin, enemyPosition);
+	}
+
+	if ( avoidDist <= 0 )
+	{
+		avoidDist = MIN_AVOID_DISTANCE_SQUARED;
+	}
+	else
+	{
+		avoidDist *= avoidDist;
+	}
+
+
+	//Collect our nearest points
+	if ( (flags & CP_NO_PVS) || (flags & CP_TRYFAR))
+	{//much larger radius since most will be dropped?
+		collRad = CP_COLLECT_RADIUS*4;
+	}
+	NPC_CollectCombatPoints( destPosition, collRad, points, flags );//position
+
+	for ( cpi = points.begin(); cpi != points.end(); cpi++ )
+	{
+		const int i = (*cpi).second;
+
+		//Must not be one we want to ignore
+		if ( i == ignorePoint )
+		{
+			continue;
+		}
+
+		//Get some distances for reasoning
+		distSqPointToNPC		= (*cpi).first;
+
+		distSqPointToEnemy		= DistanceSquared          (level.combatPoints[i].origin, enemyPosition);
+		distSqPointToEnemyHoriz	= DistanceHorizontalSquared(level.combatPoints[i].origin, enemyPosition);
+		distSqPointToEnemyCheck = (useHorizDist)?(distSqPointToEnemyHoriz):(distSqPointToEnemy);
+
+		distSqNPCToEnemy		= DistanceSquared          (NPC->currentOrigin, enemyPosition);
+		distSqNPCToEnemyHoriz	= DistanceHorizontalSquared(NPC->currentOrigin, enemyPosition);
+		distSqNPCToEnemyCheck	= (useHorizDist)?(distSqNPCToEnemyHoriz  ):(distSqNPCToEnemy);
+
+
+
+		//Ignore points that are farther than currently located
+		if ( (flags & CP_APPROACH_ENEMY) && (distSqPointToEnemyCheck > distSqNPCToEnemyCheck))
+		{
+			continue;
+		}
+
+		//Ignore points that are closer than currently located
+		if ( (flags & CP_RETREAT) && (distSqPointToEnemyCheck < distSqNPCToEnemyCheck))
+		{
+			continue;
+		}
+
+		//Ignore points that are out of vis range
+		if ( (flags & CP_CLEAR) && (distSqPointToEnemyCheck > visRangeSq))
+		{
+			continue;
+		}
+
+		//Avoid this position?
+		if ( avoidPosition && !(flags & CP_AVOID_ENEMY) && (flags & CP_AVOID) && (DistanceSquared(level.combatPoints[i].origin, avoidPosition)<avoidDist) )
+		{
+			continue;
+		}
+
+		//We want a point on other side of the enemy from current pos
+		if (flags & CP_FLANK )
+		{
+			VectorSubtract( position, enemyPosition, eDir2Me );
+			VectorNormalize( eDir2Me );
+
+			VectorSubtract( level.combatPoints[i].origin, enemyPosition, eDir2CP );
+			VectorNormalize( eDir2CP );
+
+			dotToCp = DotProduct( eDir2Me, eDir2CP );
+			
+			//Not far enough behind enemy from current pos
+			if ( dotToCp >= 0.4 )
+			{
+				continue;
+			}
+		}
+
+		//we must have a route to the combat point
+		if ( (flags & CP_HAS_ROUTE) && !NAV::InSameRegion(NPC, level.combatPoints[i].origin))
+		{
+			continue;
+		}
+
+
+		//See if we're trying to avoid our enemy
+		if (flags & CP_AVOID_ENEMY)
+		{
+			//Can't be too close to the enemy
+			if (distSqPointToEnemy<avoidDist)
+			{
+				continue;
+			}
+
+			// otherwise, if currently safe and the path is not safe, ignore this point
+	  		if (distSqNPCToEnemy>(avoidDist) &&
+ 				!NAV::SafePathExists(position, level.combatPoints[i].origin, enemyPosition, avoidDist))
+			{
+				continue;
+			}
+		}
+
+		//Okay, now make sure it's not blocked
+		gi.trace( &tr, level.combatPoints[i].origin, NPC->mins, NPC->maxs, level.combatPoints[i].origin, NPC->s.number, NPC->clipmask );
+		if ( tr.allsolid || tr.startsolid )
+		{
+			continue;
+		}
+
+		if (NPC->enemy)
+		{
+			// Ignore Points That Do Not Have A Clear LOS To The Player
+			if ( (flags & CP_CLEAR) )
+			{
+				CalcEntitySpot(NPC, SPOT_WEAPON, weaponOffset);
+				VectorSubtract(weaponOffset, NPC->currentOrigin, weaponOffset);
+				VectorAdd(weaponOffset, level.combatPoints[i].origin, weaponOffset);
+
+				if (NPC_ClearLOS(weaponOffset, NPC->enemy)==qfalse)
+				{
+					continue;
+				}
+			}
+
+			// Ignore points that are not behind cover
+			if ( (flags & CP_COVER) && NPC_ClearLOS(level.combatPoints[i].origin, NPC->enemy)==qtrue)
+			{
+				continue;
+			}
+		}
+
+		//they are sorted by this distance, so the first one to get this far is the closest
+		return i;
+	}
+
+	return best;
+}
+
+int NPC_FindCombatPointRetry( const vec3_t position, 
+							 const vec3_t avoidPosition, 
+							 vec3_t destPosition, 
+							 int *cpFlags, 
+							 float avoidDist, 
+							 const int ignorePoint )
+{
+	int cp = -1;
+	cp = NPC_FindCombatPoint( position, 
+								avoidPosition, 
+								destPosition, 
+								*cpFlags, 
+								avoidDist, 
+								ignorePoint );
+	while ( cp == -1 && (*cpFlags&~CP_HAS_ROUTE) != CP_ANY )
+	{//start "OR"ing out certain flags to see if we can find *any* point
+		if ( *cpFlags & CP_INVESTIGATE )
+		{//don't need to investigate
+			*cpFlags &= ~CP_INVESTIGATE;
+		}
+		else if ( *cpFlags & CP_SQUAD )
+		{//don't need to stick to squads
+			*cpFlags &= ~CP_SQUAD;
+		}
+		else if ( *cpFlags & CP_DUCK )
+		{//don't need to duck
+			*cpFlags &= ~CP_DUCK;
+		}
+		else if ( *cpFlags & CP_NEAREST )
+		{//don't need closest one to me
+			*cpFlags &= ~CP_NEAREST;
+		}
+		else if ( *cpFlags & CP_FLANK )
+		{//don't need to flank enemy
+			*cpFlags &= ~CP_FLANK;
+		}
+		else if ( *cpFlags & CP_SAFE )
+		{//don't need one that hasn't been shot at recently
+			*cpFlags &= ~CP_SAFE;
+		}
+		else if ( *cpFlags & CP_CLOSEST )
+		{//don't need to get closest to enemy
+			*cpFlags &= ~CP_CLOSEST;
+			//but let's try to approach at least
+			*cpFlags |= CP_APPROACH_ENEMY;
+		}
+		else if ( *cpFlags & CP_APPROACH_ENEMY )
+		{//don't need to approach enemy
+			*cpFlags &= ~CP_APPROACH_ENEMY;
+		}
+		else if ( *cpFlags & CP_COVER )
+		{//don't need cover
+			*cpFlags &= ~CP_COVER;
+			//but let's pick one that makes us duck
+			//*cpFlags |= CP_DUCK;
+		}
+	//	else if ( *cpFlags & CP_CLEAR )
+	//	{//don't need a clear shot to enemy
+	//		*cpFlags &= ~CP_CLEAR;
+	//	}
+	//	Never Give Up On Avoiding The Enemy
+	//	else if ( *cpFlags & CP_AVOID_ENEMY )
+	//	{//don't need to avoid enemy
+	//		*cpFlags &= ~CP_AVOID_ENEMY;
+	//	}
+		else if ( *cpFlags & CP_RETREAT )
+		{//don't need to retreat
+			*cpFlags &= ~CP_RETREAT;
+		}
+		else if ( *cpFlags &CP_FLEE )
+		{//don't need to flee
+			*cpFlags &= ~CP_FLEE;
+			//but at least avoid enemy and pick one that gives cover
+			*cpFlags |= (CP_COVER|CP_AVOID_ENEMY);
+		}
+		else if ( *cpFlags & CP_AVOID )
+		{//okay, even pick one right by me
+			*cpFlags &= ~CP_AVOID;
+		}
+		else if ( *cpFlags & CP_SHORTEST_PATH )
+		{//okay, don't need the one with the shortest path
+			*cpFlags &= ~CP_SHORTEST_PATH;
+		}
+		else
+		{//screw it, we give up!
+			return -1;
+			/*
+			if ( *cpFlags & CP_HAS_ROUTE )
+			{//NOTE: this is really an absolute worst case scenario - will go to the first cp on the map!
+				*cpFlags &= ~CP_HAS_ROUTE;
+			}
+			else
+			{//NOTE: this is really an absolute worst case scenario - will go to the first cp on the map!
+				*cpFlags = CP_ANY;
+			}
+			*/
+		}
+		//now try again
+		cp = NPC_FindCombatPoint( position, 
+									avoidPosition, 
+									destPosition, 
+									*cpFlags, 
+									avoidDist, 
+									ignorePoint );
+	} 
+	return cp;
+}
+/*
+-------------------------
+NPC_FindSquadPoint
+-------------------------
+*/
+
+int NPC_FindSquadPoint( vec3_t position )
+{
+	float	dist, nearestDist = (float)WORLD_SIZE*(float)WORLD_SIZE;
+	int		nearestPoint = -1;
+
+	//float			playerDist = DistanceSquared( g_entities[0].currentOrigin, NPC->currentOrigin );
+
+	for ( int i = 0; i < level.numCombatPoints; i++ )
+	{
+		//Squad points are only valid if we're looking for them
+		if ( ( level.combatPoints[i].flags & CPF_SQUAD ) == qfalse )
+			continue;
+
+		//Must be vacant
+		if ( level.combatPoints[i].occupied == qtrue )
+			continue;
+		
+		dist = DistanceSquared( position, level.combatPoints[i].origin );
+
+		//The point cannot take us past the player
+		//if ( dist > ( playerDist * DotProduct( dirToPlayer, playerDir ) ) )	//FIXME: Retain this
+		//	continue;
+
+		//See if this is closer than the others
+		if ( dist < nearestDist )
+		{
+			nearestPoint = i;
+			nearestDist = dist;
+		}
+	}
+
+	return nearestPoint;
+}
+
+/*
+-------------------------
+NPC_ReserveCombatPoint
+-------------------------
+*/
+
+qboolean NPC_ReserveCombatPoint( int combatPointID )
+{
+	//Make sure it's valid
+	if ( combatPointID > level.numCombatPoints )
+		return qfalse;
+
+	//Make sure it's not already occupied
+	if ( level.combatPoints[combatPointID].occupied )
+		return qfalse;
+
+	//Reserve it
+	level.combatPoints[combatPointID].occupied = qtrue;
+
+	return qtrue;
+}
+
+/*
+-------------------------
+NPC_FreeCombatPoint
+-------------------------
+*/
+
+qboolean NPC_FreeCombatPoint( int combatPointID, qboolean failed )
+{
+	if ( failed )
+	{//remember that this one failed for us
+		NPCInfo->lastFailedCombatPoint = combatPointID;
+	}
+	//Make sure it's valid
+	if ( combatPointID > level.numCombatPoints )
+		return qfalse;
+
+	//Make sure it's currently occupied
+	if ( level.combatPoints[combatPointID].occupied == qfalse )
+		return qfalse;
+
+	//Free it
+	level.combatPoints[combatPointID].occupied = qfalse;
+	
+	return qtrue;
+}
+
+/*
+-------------------------
+NPC_SetCombatPoint
+-------------------------
+*/
+
+qboolean NPC_SetCombatPoint( int combatPointID )
+{
+	if (combatPointID==NPCInfo->combatPoint)
+	{
+		return qtrue;
+	}
+
+	//Free a combat point if we already have one
+	if ( NPCInfo->combatPoint != -1 )
+	{
+		NPC_FreeCombatPoint( NPCInfo->combatPoint );
+	}
+
+	if ( NPC_ReserveCombatPoint( combatPointID ) == qfalse )
+		return qfalse;
+
+	NPCInfo->combatPoint = combatPointID;
+
+	return qtrue;
+}
+
+extern qboolean CheckItemCanBePickedUpByNPC( gentity_t *item, gentity_t *pickerupper );
+gentity_t *NPC_SearchForWeapons( void )
+{
+	gentity_t *found = g_entities, *bestFound = NULL;
+	float		dist, bestDist = Q3_INFINITE;
+	int i;
+//	for ( found = g_entities; found < &g_entities[globals.num_entities] ; found++)
+	for ( i = 0; i<globals.num_entities; i++)
+	{
+//		if ( !found->inuse )
+//		{
+//			continue;
+//		}
+		if(!PInUse(i))
+			continue;
+		
+		found=&g_entities[i];
+		
+		//FIXME: Also look for ammo_racks that have weapons on them?
+		if ( found->s.eType != ET_ITEM )
+		{
+			continue;
+		}
+		if ( found->item->giType != IT_WEAPON )
+		{
+			continue;
+		}
+		if ( found->s.eFlags & EF_NODRAW )
+		{
+			continue;
+		}
+		if ( CheckItemCanBePickedUpByNPC( found, NPC ) )
+		{
+			if ( gi.inPVS( found->currentOrigin, NPC->currentOrigin ) )
+			{
+				dist = DistanceSquared( found->currentOrigin, NPC->currentOrigin );
+				if ( dist < bestDist )
+				{
+					if (NAV::InSameRegion(NPC, found))
+					{//can nav to it
+						bestDist = dist;
+						bestFound = found;
+					}
+				}
+			}
+		}
+	}
+
+	return bestFound;
+}
+
+void NPC_SetPickUpGoal( gentity_t *foundWeap )
+{
+	vec3_t org;
+
+	//NPCInfo->goalEntity = foundWeap;
+	VectorCopy( foundWeap->currentOrigin, org );
+	org[2] += 24 - (foundWeap->mins[2]*-1);//adjust the origin so that I am on the ground
+	NPC_SetMoveGoal( NPC, org, foundWeap->maxs[0]*0.75, qfalse, -1, foundWeap );
+	NPCInfo->tempGoal->waypoint = foundWeap->waypoint;
+	NPCInfo->tempBehavior = BS_DEFAULT;
+	NPCInfo->squadState = SQUAD_TRANSITION;
+}
+
+extern void Q3_TaskIDComplete( gentity_t *ent, taskID_t taskType );
+extern qboolean G_CanPickUpWeapons( gentity_t *other );
+void NPC_CheckGetNewWeapon( void )
+{
+	if ( NPC->client 
+		&& !G_CanPickUpWeapons( NPC ) )
+	{//this NPC can't pick up weapons...
+		return;
+	}
+	if ( NPC->s.weapon == WP_NONE && NPC->enemy )
+	{//if running away because dropped weapon...
+		if ( NPCInfo->goalEntity 
+			&& NPCInfo->goalEntity == NPCInfo->tempGoal
+			&& NPCInfo->goalEntity->enemy
+			&& !NPCInfo->goalEntity->enemy->inuse )
+		{//maybe was running at a weapon that was picked up
+			NPC_ClearGoal();
+			Q3_TaskIDComplete( NPC, TID_MOVE_NAV );
+			//NPCInfo->goalEntity = NULL;
+		}
+		if ( TIMER_Done( NPC, "panic" ) && NPCInfo->goalEntity == NULL )
+		{//need a weapon, any lying around?
+			gentity_t *foundWeap = NPC_SearchForWeapons();
+			if ( foundWeap )
+			{
+				NPC_SetPickUpGoal( foundWeap );
+			}
+		}
+	}
+}
+
+void NPC_AimAdjust( int change )
+{
+	if ( !TIMER_Exists( NPC, "aimDebounce" ) )
+	{
+		int debounce = 500+(3-g_spskill->integer)*100;
+		TIMER_Set( NPC, "aimDebounce", Q_irand( debounce,debounce+1000 ) );
+		//int debounce = 1000+(3-g_spskill->integer)*500;
+		//TIMER_Set( NPC, "aimDebounce", Q_irand( debounce, debounce+2000 ) );
+		return;
+	}
+	if ( TIMER_Done( NPC, "aimDebounce" ) )
+	{
+		NPCInfo->currentAim += change;
+		if ( NPCInfo->currentAim > NPCInfo->stats.aim )
+		{//can never be better than max aim
+			NPCInfo->currentAim = NPCInfo->stats.aim;
+		}
+		else if ( NPCInfo->currentAim < -30 )
+		{//can never be worse than this
+			NPCInfo->currentAim = -30;
+		}
+
+		//Com_Printf( "%s new aim = %d\n", NPC->NPC_type, NPCInfo->currentAim );
+
+		int debounce = 500+(3-g_spskill->integer)*100;
+		TIMER_Set( NPC, "aimDebounce", Q_irand( debounce,debounce+1000 ) );
+		//int debounce = 1000+(3-g_spskill->integer)*500;
+		//TIMER_Set( NPC, "aimDebounce", Q_irand( debounce, debounce+2000 ) );
+	}
+}
+
+void G_AimSet( gentity_t *self, int aim )
+{
+	if ( self->NPC )
+	{
+		self->NPC->currentAim = aim;
+		//Com_Printf( "%s new aim = %d\n", self->NPC_type, self->NPC->currentAim );
+
+		int debounce = 500+(3-g_spskill->integer)*100;
+		TIMER_Set( self, "aimDebounce", Q_irand( debounce,debounce+1000 ) );
+	//	int debounce = 1000+(3-g_spskill->integer)*500;
+	//	TIMER_Set( self, "aimDebounce", Q_irand( debounce,debounce+2000 ) );
+	}
+}
diff --git a/code/game/NPC_goal.cpp b/code/game/NPC_goal.cpp
new file mode 100644
index 0000000..ed45184
--- /dev/null
+++ b/code/game/NPC_goal.cpp
@@ -0,0 +1,188 @@
+//b_goal.cpp
+// leave this line at the top for all NPC_xxxx.cpp files...
+#include "g_headers.h"
+
+
+
+
+#include "b_local.h"
+#include "Q3_Interface.h"
+
+extern qboolean FlyingCreature( gentity_t *ent );
+/*
+SetGoal
+*/
+
+void SetGoal( gentity_t *goal, float rating ) 
+{
+	NPCInfo->goalEntity = goal;
+//	NPCInfo->goalEntityNeed = rating;
+	NPCInfo->goalTime = level.time;
+	if ( goal ) 
+	{
+//		Debug_NPCPrintf( NPC, debugNPCAI, DEBUG_LEVEL_INFO, "NPC_SetGoal: %s @ %s (%f)\n", goal->classname, vtos( goal->currentOrigin), rating );
+	}
+	else 
+	{
+//		Debug_NPCPrintf( NPC, debugNPCAI, DEBUG_LEVEL_INFO, "NPC_SetGoal: NONE\n" );
+	}
+}
+
+
+/*
+NPC_SetGoal
+*/
+
+void NPC_SetGoal( gentity_t *goal, float rating ) 
+{
+	if ( goal == NPCInfo->goalEntity ) 
+	{
+		return;
+	}
+
+	if ( !goal ) 
+	{
+//		Debug_NPCPrintf( NPC, debugNPCAI, DEBUG_LEVEL_ERROR, "NPC_SetGoal: NULL goal\n" );
+		return;
+	}
+
+	if ( goal->client ) 
+	{
+//		Debug_NPCPrintf( NPC, debugNPCAI, DEBUG_LEVEL_ERROR, "NPC_SetGoal: goal is a client\n" );
+		return;
+	}
+
+	if ( NPCInfo->goalEntity ) 
+	{
+//		Debug_NPCPrintf( NPC, debugNPCAI, DEBUG_LEVEL_INFO, "NPC_SetGoal: push %s\n", NPCInfo->goalEntity->classname );
+		NPCInfo->lastGoalEntity = NPCInfo->goalEntity;
+//		NPCInfo->lastGoalEntityNeed = NPCInfo->goalEntityNeed;
+	}
+
+	SetGoal( goal, rating );
+}
+
+
+/*
+NPC_ClearGoal
+*/
+
+void NPC_ClearGoal( void ) 
+{
+	gentity_t	*goal;
+
+	if ( !NPCInfo->lastGoalEntity ) 
+	{
+		SetGoal( NULL, 0.0 );
+		return;
+	}
+
+	goal = NPCInfo->lastGoalEntity;
+	NPCInfo->lastGoalEntity = NULL;
+	if ( goal->inuse && !(goal->s.eFlags & EF_NODRAW) ) 
+	{
+//		Debug_NPCPrintf( NPC, debugNPCAI, DEBUG_LEVEL_INFO, "NPC_ClearGoal: pop %s\n", goal->classname );
+		SetGoal( goal, 0 );//, NPCInfo->lastGoalEntityNeed
+		return;
+	}
+
+	SetGoal( NULL, 0.0 );
+}
+
+/*
+-------------------------
+G_BoundsOverlap
+-------------------------
+*/
+
+qboolean G_BoundsOverlap(const vec3_t mins1, const vec3_t maxs1, const vec3_t mins2, const vec3_t maxs2)
+{//NOTE: flush up against counts as overlapping
+	if(mins1[0]>maxs2[0])
+		return qfalse;
+
+	if(mins1[1]>maxs2[1])
+		return qfalse;
+
+	if(mins1[2]>maxs2[2])
+		return qfalse;
+
+	if(maxs1[0]<mins2[0])
+		return qfalse;
+
+	if(maxs1[1]<mins2[1])
+		return qfalse;
+
+	if(maxs1[2]<mins2[2])
+		return qfalse;
+
+	return qtrue;
+}
+
+void NPC_ReachedGoal( void )
+{
+//	Debug_NPCPrintf( NPC, debugNPCAI, DEBUG_LEVEL_INFO, "UpdateGoal: reached goal entity\n" );
+	NPC_ClearGoal();
+	NPCInfo->goalTime = level.time;
+
+//MCG - Begin
+	NPCInfo->aiFlags &= ~NPCAI_MOVING;
+	ucmd.forwardmove = 0;
+	//Return that the goal was reached
+	Q3_TaskIDComplete( NPC, TID_MOVE_NAV );
+//MCG - End
+}
+/*
+ReachedGoal
+
+id removed checks against waypoints and is now checking surfaces
+*/
+qboolean ReachedGoal( gentity_t *goal ) 
+{
+
+	if ( NPCInfo->aiFlags & NPCAI_TOUCHED_GOAL ) 
+	{
+		NPCInfo->aiFlags &= ~NPCAI_TOUCHED_GOAL;
+		return qtrue;
+	}
+	return STEER::Reached(NPC, goal, NPCInfo->goalRadius, !!FlyingCreature(NPC));
+}
+
+/*
+static gentity_t *UpdateGoal( void ) 
+
+Id removed a lot of shit here... doesn't seem to handle waypoints independantly of goalentity
+
+In fact, doesn't seem to be any waypoint info on entities at all any more?
+
+MCG - Since goal is ALWAYS goalEntity, took out a lot of sending goal entity pointers around for no reason
+*/
+
+gentity_t *UpdateGoal( void ) 
+{
+	//FIXME: CREED should look at this
+	//		this func doesn't seem to be working correctly for the sand creature
+
+	gentity_t	*goal;
+
+	if ( !NPCInfo->goalEntity ) 
+	{
+		return NULL;
+	}
+
+	if ( !NPCInfo->goalEntity->inuse )
+	{//Somehow freed it, but didn't clear it
+		NPC_ClearGoal();
+		return NULL;
+	}
+
+	goal = NPCInfo->goalEntity;
+
+	if ( ReachedGoal( goal ) ) 
+	{
+		NPC_ReachedGoal();
+		goal = NULL;//so they don't keep trying to move to it
+	}//else if fail, need to tell script so?
+
+	return goal;
+}
+
diff --git a/code/game/NPC_misc.cpp b/code/game/NPC_misc.cpp
new file mode 100644
index 0000000..bb1a1f9
--- /dev/null
+++ b/code/game/NPC_misc.cpp
@@ -0,0 +1,79 @@
+//
+// NPC_misc.cpp
+//
+
+// leave this line at the top for all NPC_xxxx.cpp files...
+#include "g_headers.h"
+
+
+
+
+#include "b_local.h"
+#include "q_shared.h"
+/*
+Debug_Printf
+*/
+void Debug_Printf (cvar_t *cv, int debugLevel, char *fmt, ...)
+{
+	char		*color;
+	va_list		argptr;
+	char		msg[1024];
+
+	if (cv->value < debugLevel)
+		return;
+
+	if (debugLevel == DEBUG_LEVEL_DETAIL)
+		color = S_COLOR_WHITE;
+	else if (debugLevel == DEBUG_LEVEL_INFO)
+		color = S_COLOR_GREEN;
+	else if (debugLevel == DEBUG_LEVEL_WARNING)
+		color = S_COLOR_YELLOW;
+	else if (debugLevel == DEBUG_LEVEL_ERROR)
+		color = S_COLOR_RED;
+	else
+		color = S_COLOR_RED;
+
+	va_start (argptr,fmt);
+	vsprintf (msg, fmt, argptr);
+	va_end (argptr);
+
+	gi.Printf("%s%5i:%s", color, level.time, msg);
+}
+
+
+/*
+Debug_NPCPrintf
+*/
+void Debug_NPCPrintf (gentity_t *printNPC, cvar_t *cv, int debugLevel, char *fmt, ...)
+{
+	int			color;
+	va_list		argptr;
+	char		msg[1024];
+
+	if (cv->value < debugLevel)
+	{
+		return;
+	}
+
+	if ( debugNPCName->string[0] && Q_stricmp( debugNPCName->string, printNPC->targetname) != 0 ) 
+	{
+		return;
+	}
+
+	if (debugLevel == DEBUG_LEVEL_DETAIL)
+		color = COLOR_WHITE;
+	else if (debugLevel == DEBUG_LEVEL_INFO)
+		color = COLOR_GREEN;
+	else if (debugLevel == DEBUG_LEVEL_WARNING)
+		color = COLOR_YELLOW;
+	else if (debugLevel == DEBUG_LEVEL_ERROR)
+		color = COLOR_RED;
+	else
+		color = COLOR_RED;
+
+	va_start (argptr,fmt);
+	vsprintf (msg, fmt, argptr);
+	va_end (argptr);
+
+	gi.Printf ("%c%c%5i (%s) %s", Q_COLOR_ESCAPE, color, level.time, printNPC->targetname, msg);
+}
diff --git a/code/game/NPC_move.cpp b/code/game/NPC_move.cpp
new file mode 100644
index 0000000..1ef0b04
--- /dev/null
+++ b/code/game/NPC_move.cpp
@@ -0,0 +1,844 @@
+//
+// NPC_move.cpp
+//
+
+// leave this line at the top for all NPC_xxxx.cpp files...
+#include "g_headers.h"
+
+#include "b_local.h"
+#include "g_nav.h"
+#include "anims.h"
+
+extern qboolean NPC_ClearPathToGoal( vec3_t dir, gentity_t *goal );
+extern qboolean NAV_MoveDirSafe( gentity_t *self, usercmd_t *cmd, float distScale = 1.0f );
+
+void CG_Cylinder( vec3_t start, vec3_t end, float radius, vec3_t color );
+
+qboolean G_BoundsOverlap(const vec3_t mins1, const vec3_t maxs1, const vec3_t mins2, const vec3_t maxs2);
+extern int GetTime ( int lastTime );
+
+navInfo_t	frameNavInfo;
+extern qboolean FlyingCreature( gentity_t *ent );
+extern qboolean PM_InKnockDown( playerState_t *ps );
+
+extern cvar_t	*g_navSafetyChecks;
+
+extern qboolean Boba_Flying( gentity_t *self );
+extern qboolean PM_InRoll( playerState_t *ps );
+
+#define	APEX_HEIGHT		200.0f
+#define	PARA_WIDTH		(sqrt(APEX_HEIGHT)+sqrt(APEX_HEIGHT))
+#define	JUMP_SPEED		200.0f
+
+
+
+
+static qboolean NPC_TryJump();
+
+
+
+
+static qboolean NPC_Jump( vec3_t dest, int goalEntNum )
+{//FIXME: if land on enemy, knock him down & jump off again
+	float	targetDist, travelTime, impactDist, bestImpactDist = Q3_INFINITE;//fireSpeed, 
+	float originalShotSpeed, shotSpeed, speedStep = 50.0f, minShotSpeed = 30.0f, maxShotSpeed = 500.0f;
+	qboolean belowBlocked = qfalse, aboveBlocked = qfalse;
+	vec3_t	targetDir, shotVel, failCase; 
+	trace_t	trace;
+	trajectory_t	tr;
+	qboolean	blocked;
+	int		elapsedTime, timeStep = 250, hitCount = 0, aboveTries = 0, belowTries = 0, maxHits = 10;
+	vec3_t	lastPos, testPos, bottom;
+
+	VectorSubtract( dest, NPC->currentOrigin, targetDir );
+	targetDist = VectorNormalize( targetDir );
+	//make our shotSpeed reliant on the distance
+	originalShotSpeed = targetDist;//DistanceHorizontal( dest, NPC->currentOrigin )/2.0f;
+	if ( originalShotSpeed > maxShotSpeed )
+	{
+		originalShotSpeed = maxShotSpeed;
+	}
+	else if ( originalShotSpeed < minShotSpeed )
+	{
+		originalShotSpeed = minShotSpeed;
+	}
+	shotSpeed = originalShotSpeed;
+
+	while ( hitCount < maxHits )
+	{
+		VectorScale( targetDir, shotSpeed, shotVel );
+		travelTime = targetDist/shotSpeed;
+		shotVel[2] += travelTime * 0.5 * NPC->client->ps.gravity;
+
+		if ( !hitCount )		
+		{//save the first one as the worst case scenario
+			VectorCopy( shotVel, failCase );
+		}
+
+		if ( 1 )//tracePath )
+		{//do a rough trace of the path
+			blocked = qfalse;
+
+			VectorCopy( NPC->currentOrigin, tr.trBase );
+			VectorCopy( shotVel, tr.trDelta );
+			tr.trType = TR_GRAVITY;
+			tr.trTime = level.time;
+			travelTime *= 1000.0f;
+			VectorCopy( NPC->currentOrigin, lastPos );
+			
+			//This may be kind of wasteful, especially on long throws... use larger steps?  Divide the travelTime into a certain hard number of slices?  Trace just to apex and down?
+			for ( elapsedTime = timeStep; elapsedTime < floor(travelTime)+timeStep; elapsedTime += timeStep )
+			{
+				if ( (float)elapsedTime > travelTime )
+				{//cap it
+					elapsedTime = floor( travelTime );
+				}
+				EvaluateTrajectory( &tr, level.time + elapsedTime, testPos );
+				//FUCK IT, always check for do not enter...
+				gi.trace( &trace, lastPos, NPC->mins, NPC->maxs, testPos, NPC->s.number, NPC->clipmask|CONTENTS_BOTCLIP );
+				/*
+				if ( testPos[2] < lastPos[2] 
+					&& elapsedTime < floor( travelTime ) )
+				{//going down, haven't reached end, ignore botclip
+					gi.trace( &trace, lastPos, NPC->mins, NPC->maxs, testPos, NPC->s.number, NPC->clipmask );
+				}
+				else
+				{//going up, check for botclip
+					gi.trace( &trace, lastPos, NPC->mins, NPC->maxs, testPos, NPC->s.number, NPC->clipmask|CONTENTS_BOTCLIP );
+				}
+				*/
+
+				if ( trace.allsolid || trace.startsolid )
+				{//started in solid
+					if ( NAVDEBUG_showCollision )
+					{
+						CG_DrawEdge( lastPos, trace.endpos, EDGE_RED_TWOSECOND );
+					}
+					return qfalse;//you're hosed, dude
+				}
+				if ( trace.fraction < 1.0f )
+				{//hit something
+					if ( NAVDEBUG_showCollision )
+					{
+						CG_DrawEdge( lastPos, trace.endpos, EDGE_RED_TWOSECOND );	// TryJump
+					}
+					if ( trace.entityNum == goalEntNum )
+					{//hit the enemy, that's bad!
+						blocked = qtrue;
+						/*
+						if ( g_entities[goalEntNum].client && g_entities[goalEntNum].client->ps.groundEntityNum == ENTITYNUM_NONE )
+						{//bah, would collide in mid-air, no good
+							blocked = qtrue;
+						}
+						else
+						{//he's on the ground, good enough, I guess
+							//Hmm, don't want to land on him, though...?
+						}
+						*/
+						break;
+					}
+					else 
+					{
+						if ( trace.contents & CONTENTS_BOTCLIP )
+						{//hit a do-not-enter brush
+							blocked = qtrue;
+							break;
+						}
+						if ( trace.plane.normal[2] > 0.7 && DistanceSquared( trace.endpos, dest ) < 4096 )//hit within 64 of desired location, should be okay
+						{//close enough!
+							break;
+						}
+						else
+						{//FIXME: maybe find the extents of this brush and go above or below it on next try somehow?
+							impactDist = DistanceSquared( trace.endpos, dest );
+							if ( impactDist < bestImpactDist )
+							{
+								bestImpactDist = impactDist;
+								VectorCopy( shotVel, failCase );
+							}
+							blocked = qtrue;
+							break;
+						}
+					}
+				}
+				else
+				{
+					if ( NAVDEBUG_showCollision )
+					{
+						CG_DrawEdge( lastPos, testPos, EDGE_WHITE_TWOSECOND );	// TryJump
+					}
+				}
+				if ( elapsedTime == floor( travelTime ) )
+				{//reached end, all clear
+					if ( trace.fraction >= 1.0f )
+					{//hmm, make sure we'll land on the ground...
+						//FIXME: do we care how far below ourselves or our dest we'll land?
+						VectorCopy( trace.endpos, bottom );
+						bottom[2] -= 128;
+						gi.trace( &trace, trace.endpos, NPC->mins, NPC->maxs, bottom, NPC->s.number, NPC->clipmask );
+						if ( trace.fraction >= 1.0f )
+						{//would fall too far
+							blocked = qtrue;
+						}
+					}
+					break;
+				}
+				else
+				{
+					//all clear, try next slice
+					VectorCopy( testPos, lastPos );
+				}
+			}
+			if ( blocked )
+			{//hit something, adjust speed (which will change arc)
+				hitCount++;
+				//alternate back and forth between trying an arc slightly above or below the ideal
+				if ( (hitCount%2) && !belowBlocked )
+				{//odd
+					belowTries++;
+					shotSpeed = originalShotSpeed - (belowTries*speedStep);
+				}
+				else if ( !aboveBlocked )
+				{//even
+					aboveTries++;
+					shotSpeed = originalShotSpeed + (aboveTries*speedStep);
+				}
+				else
+				{//can't go any higher or lower
+					hitCount = maxHits;
+					break;
+				}
+				if ( shotSpeed > maxShotSpeed )
+				{
+					shotSpeed = maxShotSpeed;
+					aboveBlocked = qtrue;
+				}
+				else if ( shotSpeed < minShotSpeed )
+				{
+					shotSpeed = minShotSpeed;
+					belowBlocked = qtrue;
+				}
+			}
+			else
+			{//made it!
+				break;
+			}
+		}
+		else
+		{//no need to check the path, go with first calc
+			break;
+		}
+	}
+
+	if ( hitCount >= maxHits )
+	{//NOTE: worst case scenario, use the one that impacted closest to the target (or just use the first try...?)
+		return qfalse;
+		//NOTE: or try failcase?
+		//VectorCopy( failCase, NPC->client->ps.velocity );
+		//return qtrue;
+	}
+	VectorCopy( shotVel, NPC->client->ps.velocity );
+	return qtrue;
+}
+
+
+
+
+
+
+#define NPC_JUMP_PREP_BACKUP_DIST 34.0f
+
+trace_t		mJumpTrace;
+
+
+
+qboolean NPC_CanTryJump()
+{
+	if (!(NPCInfo->scriptFlags&SCF_NAV_CAN_JUMP)	||		// Can't Jump
+		(NPCInfo->scriptFlags&SCF_NO_ACROBATICS)	||		// If Can't Jump At All
+		(level.time<NPCInfo->jumpBackupTime)		||		// If Backing Up, Don't Try The Jump Again
+		(level.time<NPCInfo->jumpNextCheckTime)		||		// Don't Even Try To Jump Again For This Amount Of Time
+		(NPCInfo->jumpTime)							||		// Don't Jump If Already Going
+		(PM_InKnockDown(&NPC->client->ps))			||		// Don't Jump If In Knockdown
+		(PM_InRoll(&NPC->client->ps))				||		// ... Or Roll
+		(NPC->client->ps.groundEntityNum==ENTITYNUM_NONE)	// ... Or In The Air
+		)
+	{
+		return qfalse;
+	}
+	return qtrue;
+}
+
+qboolean NPC_TryJump(const vec3_t& pos,	float max_xy_dist, float max_z_diff)
+{
+	if (NPC_CanTryJump())
+	{
+		NPCInfo->jumpNextCheckTime	= level.time + Q_irand(1000, 2000);
+
+		VectorCopy(pos, NPCInfo->jumpDest);
+
+		// Can't Try To Jump At A Point In The Air
+		//-----------------------------------------
+		{
+			vec3_t	groundTest;
+			VectorCopy(pos, groundTest);
+			groundTest[2]	+= (NPC->mins[2]*3);
+			gi.trace(&mJumpTrace, NPCInfo->jumpDest, vec3_origin, vec3_origin, groundTest, NPC->s.number, NPC->clipmask );
+			if (mJumpTrace.fraction >= 1.0f)
+			{
+				return qfalse;	//no ground = no jump
+			}
+		}
+		NPCInfo->jumpTarget			= 0;
+		NPCInfo->jumpMaxXYDist		= (max_xy_dist)?(max_xy_dist):((NPC->client->NPC_class==CLASS_ROCKETTROOPER)?1200:750);
+		NPCInfo->jumpMazZDist		= (max_z_diff)?(max_z_diff):((NPC->client->NPC_class==CLASS_ROCKETTROOPER)?-1000:-450);
+		NPCInfo->jumpTime			= 0;
+		NPCInfo->jumpBackupTime		= 0;
+		return NPC_TryJump();
+	}
+	return qfalse;
+}
+
+qboolean NPC_TryJump(gentity_t *goal,	float max_xy_dist, float max_z_diff)
+{
+	if (NPC_CanTryJump())
+	{
+		NPCInfo->jumpNextCheckTime	= level.time + Q_irand(1000, 3000);
+
+		// Can't Jump At Targets In The Air
+		//---------------------------------
+		if (goal->client && goal->client->ps.groundEntityNum==ENTITYNUM_NONE)
+		{
+			return qfalse;
+		}
+		VectorCopy(goal->currentOrigin, NPCInfo->jumpDest);
+		NPCInfo->jumpTarget			= goal;
+		NPCInfo->jumpMaxXYDist		= (max_xy_dist)?(max_xy_dist):((NPC->client->NPC_class==CLASS_ROCKETTROOPER)?1200:750);
+		NPCInfo->jumpMazZDist		= (max_z_diff)?(max_z_diff):((NPC->client->NPC_class==CLASS_ROCKETTROOPER)?-1000:-400);
+		NPCInfo->jumpTime			= 0;
+		NPCInfo->jumpBackupTime		= 0;
+		return NPC_TryJump();
+	}
+	return qfalse;
+}
+
+void	 NPC_JumpAnimation()
+{
+	int	jumpAnim = BOTH_JUMP1;
+
+	if ( NPC->client->NPC_class == CLASS_BOBAFETT 
+		|| (NPC->client->NPC_class == CLASS_REBORN && NPC->s.weapon != WP_SABER)
+		|| NPC->client->NPC_class == CLASS_ROCKETTROOPER
+		||( NPCInfo->rank != RANK_CREWMAN && NPCInfo->rank <= RANK_LT_JG ) )
+	{//can't do acrobatics
+		jumpAnim = BOTH_FORCEJUMP1;
+	}
+	else if (NPC->client->NPC_class != CLASS_HOWLER)
+	{
+		if ( NPC->client->NPC_class == CLASS_ALORA && Q_irand( 0, 3 ) )
+		{
+			jumpAnim = Q_irand( BOTH_ALORA_FLIP_1, BOTH_ALORA_FLIP_3 );
+		}
+		else
+		{
+			jumpAnim = BOTH_FLIP_F;
+		}
+	}
+	NPC_SetAnim( NPC, SETANIM_BOTH, jumpAnim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+}
+
+extern void JET_FlyStart(gentity_t* actor);
+
+void	 NPC_JumpSound()
+{
+	if ( NPC->client->NPC_class == CLASS_HOWLER )
+	{
+		//FIXME: can I delay the actual jump so that it matches the anim...?
+	}
+	else if ( NPC->client->NPC_class == CLASS_BOBAFETT 
+		|| NPC->client->NPC_class == CLASS_ROCKETTROOPER )
+	{
+		// does this really need to be here?
+		JET_FlyStart(NPC);
+	}
+	else
+	{
+		G_SoundOnEnt( NPC, CHAN_BODY, "sound/weapons/force/jump.wav" );
+	}
+}
+
+qboolean NPC_TryJump()
+{
+	vec3_t	targetDirection;
+	float	targetDistanceXY;
+	float	targetDistanceZ;
+
+	// Get The Direction And Distances To The Target
+	//-----------------------------------------------
+	VectorSubtract(NPCInfo->jumpDest, NPC->currentOrigin, targetDirection);
+	targetDirection[2]	= 0.0f;
+	targetDistanceXY	= VectorNormalize(targetDirection);
+	targetDistanceZ		= NPCInfo->jumpDest[2] - NPC->currentOrigin[2];
+
+	if ((targetDistanceXY>NPCInfo->jumpMaxXYDist) ||
+		(targetDistanceZ<NPCInfo->jumpMazZDist))
+	{
+		return qfalse;
+	}
+
+
+	// Test To See If There Is A Wall Directly In Front Of Actor, If So, Backup Some
+	//-------------------------------------------------------------------------------
+	if (TIMER_Done(NPC, "jumpBackupDebounce"))
+	{
+		vec3_t	actorProjectedTowardTarget;
+		VectorMA(NPC->currentOrigin, NPC_JUMP_PREP_BACKUP_DIST, targetDirection, actorProjectedTowardTarget);
+		gi.trace(&mJumpTrace, NPC->currentOrigin, vec3_origin, vec3_origin, actorProjectedTowardTarget, NPC->s.number, NPC->clipmask);
+		if ((mJumpTrace.fraction < 1.0f) ||
+			(mJumpTrace.allsolid) ||
+			(mJumpTrace.startsolid))
+		{
+			if (NAVDEBUG_showCollision)
+			{
+				CG_DrawEdge(NPC->currentOrigin, actorProjectedTowardTarget, EDGE_RED_TWOSECOND);	// TryJump
+			}
+
+			// TODO: We may want to test to see if it is safe to back up here?
+			NPCInfo->jumpBackupTime = level.time + 1000;
+			TIMER_Set(NPC, "jumpBackupDebounce", 5000);
+			return qtrue;
+		}
+	}
+
+
+//	bool	Wounded					= (NPC->health < 150);
+//	bool	OnLowerLedge			= ((targetDistanceZ<-80.0f) && (targetDistanceZ>-200.0f));
+//	bool	WithinNormalJumpRange	= ((targetDistanceZ<32.0f)  && (targetDistanceXY<200.0f));
+	bool	WithinForceJumpRange	= ((fabsf(targetDistanceZ)>0) || (targetDistanceXY>128));
+
+/*	if (Wounded && OnLowerLedge)
+	{
+		ucmd.forwardmove	= 127;
+		VectorClear(NPC->client->ps.moveDir);
+		TIMER_Set(NPC, "duck", -level.time);
+		return qtrue;
+	}
+	
+	if (WithinNormalJumpRange)
+	{
+		ucmd.upmove			= 127;
+		ucmd.forwardmove	= 127;
+		VectorClear(NPC->client->ps.moveDir);
+		TIMER_Set(NPC, "duck", -level.time);
+		return qtrue;
+	}
+*/
+
+	if (!WithinForceJumpRange)
+	{
+		return qfalse;
+	}
+
+
+
+	// If There Is Any Chance That This Jump Will Land On An Enemy, Try 8 Different Traces Around The Target
+	//-------------------------------------------------------------------------------------------------------
+	if (NPCInfo->jumpTarget)
+	{
+		float	minSafeRadius	= (NPC->maxs[0]*1.5f) + (NPCInfo->jumpTarget->maxs[0]*1.5f);
+		float	minSafeRadiusSq	= (minSafeRadius * minSafeRadius);
+
+		if (DistanceSquared(NPCInfo->jumpDest, NPCInfo->jumpTarget->currentOrigin)<minSafeRadiusSq)
+		{
+			vec3_t	startPos;
+			vec3_t	floorPos;
+			VectorCopy(NPCInfo->jumpDest, startPos);
+
+			floorPos[2] = NPCInfo->jumpDest[2] + (NPC->mins[2]-32);
+
+			for (int sideTryCount=0; sideTryCount<8; sideTryCount++)
+			{
+				NPCInfo->jumpSide++;
+				if ( NPCInfo->jumpSide > 7 )
+				{
+					NPCInfo->jumpSide = 0;
+				}
+
+				switch ( NPCInfo->jumpSide )
+				{
+				case 0:
+					NPCInfo->jumpDest[0] = startPos[0] + minSafeRadius;
+					NPCInfo->jumpDest[1] = startPos[1];
+					break;
+				case 1:
+					NPCInfo->jumpDest[0] = startPos[0] + minSafeRadius;
+					NPCInfo->jumpDest[1] = startPos[1] + minSafeRadius;
+					break;
+				case 2:
+					NPCInfo->jumpDest[0] = startPos[0];
+					NPCInfo->jumpDest[1] = startPos[1] + minSafeRadius;
+					break;
+				case 3:
+					NPCInfo->jumpDest[0] = startPos[0] - minSafeRadius;
+					NPCInfo->jumpDest[1] = startPos[1] + minSafeRadius;
+					break;
+				case 4:
+					NPCInfo->jumpDest[0] = startPos[0] - minSafeRadius;
+					NPCInfo->jumpDest[1] = startPos[1];
+					break;
+				case 5:
+					NPCInfo->jumpDest[0] = startPos[0] - minSafeRadius;
+					NPCInfo->jumpDest[1] = startPos[1] - minSafeRadius;
+					break;
+				case 6:
+					NPCInfo->jumpDest[0] = startPos[0];
+					NPCInfo->jumpDest[1] = startPos[1] - minSafeRadius;
+					break;
+				case 7:
+					NPCInfo->jumpDest[0] = startPos[0] + minSafeRadius;
+					NPCInfo->jumpDest[1] = startPos[1] -=minSafeRadius;
+					break;
+				}
+
+				floorPos[0] = NPCInfo->jumpDest[0];
+				floorPos[1] = NPCInfo->jumpDest[1];
+
+				gi.trace(&mJumpTrace, NPCInfo->jumpDest, NPC->mins, NPC->maxs, floorPos, (NPCInfo->jumpTarget)?(NPCInfo->jumpTarget->s.number):(NPC->s.number), (NPC->clipmask|CONTENTS_BOTCLIP));
+				if ((mJumpTrace.fraction<1.0f) && 
+					(!mJumpTrace.allsolid) && 
+					(!mJumpTrace.startsolid))
+				{
+					break;
+				}
+
+				if ( NAVDEBUG_showCollision )
+				{
+					CG_DrawEdge( NPCInfo->jumpDest, floorPos, EDGE_RED_TWOSECOND );
+				}
+			}
+
+			// If All Traces Failed, Just Try Going Right Back At The Target Location
+			//------------------------------------------------------------------------
+			if ((mJumpTrace.fraction>=1.0f) || 
+				(mJumpTrace.allsolid) || 
+				(mJumpTrace.startsolid))
+			{
+				VectorCopy(startPos, NPCInfo->jumpDest);
+			}
+		}
+	}
+	
+	// Now, Actually Try The Jump To The Dest Target
+	//-----------------------------------------------
+	if (NPC_Jump(NPCInfo->jumpDest, (NPCInfo->jumpTarget)?(NPCInfo->jumpTarget->s.number):(NPC->s.number)))
+	{
+		// We Made IT!
+		//-------------
+		NPC_JumpAnimation();
+		NPC_JumpSound();
+
+		NPC->client->ps.forceJumpZStart		 = NPC->currentOrigin[2];
+		NPC->client->ps.pm_flags			|= PMF_JUMPING;
+		NPC->client->ps.weaponTime			 = NPC->client->ps.torsoAnimTimer;
+		NPC->client->ps.forcePowersActive	|= ( 1 << FP_LEVITATION );
+		ucmd.forwardmove					 = 0;
+		NPCInfo->jumpTime					 = 1;
+
+		VectorClear(NPC->client->ps.moveDir);
+		TIMER_Set(NPC, "duck", -level.time);
+
+		return qtrue;
+	}
+	return qfalse;
+}
+
+qboolean NPC_Jumping()
+{
+	if ( NPCInfo->jumpTime )
+	{
+		if ( !(NPC->client->ps.pm_flags & PMF_JUMPING )//forceJumpZStart )
+			&& !(NPC->client->ps.pm_flags&PMF_TRIGGER_PUSHED))
+		{//landed
+			NPCInfo->jumpTime = 0;
+		}
+		else
+		{
+		//	if (NPCInfo->jumpTarget)
+		//	{
+		//		NPC_FaceEntity(NPCInfo->jumpTarget, qtrue);
+		//	}
+		//	else
+			{
+				NPC_FacePosition(NPCInfo->jumpDest, qtrue);
+			}
+			return qtrue;
+		}
+	}
+	return qfalse;
+}
+
+qboolean NPC_JumpBackingUp()
+{
+	if (NPCInfo->jumpBackupTime)
+	{
+		if (level.time<NPCInfo->jumpBackupTime)
+		{
+			STEER::Activate(NPC);
+			STEER::Flee(NPC, NPCInfo->jumpDest);
+			STEER::DeActivate(NPC, &ucmd);
+			NPC_FacePosition(NPCInfo->jumpDest, qtrue);
+			NPC_UpdateAngles( qfalse, qtrue );
+			return qtrue;
+		}
+
+		NPCInfo->jumpBackupTime = 0;
+		return NPC_TryJump();
+	}
+	return false;
+}
+
+
+
+
+/*
+-------------------------
+NPC_CheckCombatMove
+-------------------------
+*/
+
+inline qboolean NPC_CheckCombatMove( void )
+{
+	//return NPCInfo->combatMove;
+	if ( ( NPCInfo->goalEntity && NPC->enemy && NPCInfo->goalEntity == NPC->enemy ) || ( NPCInfo->combatMove ) )
+	{
+		return qtrue;
+	}
+
+	if ( NPCInfo->goalEntity && NPCInfo->watchTarget )
+	{
+		if ( NPCInfo->goalEntity != NPCInfo->watchTarget )
+		{
+			return qtrue;
+		}
+	}
+
+	return qfalse;
+}
+
+/*
+-------------------------
+NPC_LadderMove
+-------------------------
+*/
+
+static void NPC_LadderMove( vec3_t dir )
+{
+	//FIXME: this doesn't guarantee we're facing ladder
+	//ALSO: Need to be able to get off at top
+	//ALSO: Need to play an anim
+	//ALSO: Need transitionary anims?
+	
+	if ( ( dir[2] > 0 ) || ( dir[2] < 0 && NPC->client->ps.groundEntityNum == ENTITYNUM_NONE ) )
+	{
+		//Set our movement direction
+		ucmd.upmove = (dir[2] > 0) ? 127 : -127;
+
+		//Don't move around on XY
+		ucmd.forwardmove = ucmd.rightmove = 0;
+	}
+}
+
+/*
+-------------------------
+NPC_GetMoveInformation
+-------------------------
+*/
+
+inline qboolean NPC_GetMoveInformation( vec3_t dir, float *distance )
+{
+	//NOTENOTE: Use path stacks!
+
+	//Make sure we have somewhere to go
+	if ( NPCInfo->goalEntity == NULL )
+		return qfalse;
+
+	//Get our move info
+	VectorSubtract( NPCInfo->goalEntity->currentOrigin, NPC->currentOrigin, dir );
+	*distance = VectorNormalize( dir );
+	
+	VectorCopy( NPCInfo->goalEntity->currentOrigin, NPCInfo->blockedTargetPosition );
+
+	return qtrue;
+}
+
+/*
+-------------------------
+NAV_GetLastMove
+-------------------------
+*/
+
+void NAV_GetLastMove( navInfo_t &info )
+{
+	info = frameNavInfo;
+}
+
+
+void G_UcmdMoveForDir( gentity_t *self, usercmd_t *cmd, vec3_t dir )
+{
+	vec3_t	forward, right;
+
+	AngleVectors( self->currentAngles, forward, right, NULL );
+
+	dir[2] = 0;
+	VectorNormalize( dir );
+	//NPCs cheat and store this directly because converting movement into a ucmd loses precision
+	VectorCopy( dir, self->client->ps.moveDir );
+
+	float fDot = DotProduct( forward, dir ) * 127.0f;
+	float rDot = DotProduct( right, dir ) * 127.0f;
+	//Must clamp this because DotProduct is not guaranteed to return a number within -1 to 1, and that would be bad when we're shoving this into a signed byte
+	if ( fDot > 127.0f )
+	{
+		fDot = 127.0f;
+	}
+	if ( fDot < -127.0f )
+	{
+		fDot = -127.0f;
+	}
+	if ( rDot > 127.0f )
+	{
+		rDot = 127.0f;
+	}
+	if ( rDot < -127.0f )
+	{
+		rDot = -127.0f;
+	}
+	cmd->forwardmove = floor(fDot);
+	cmd->rightmove = floor(rDot);
+
+	/*
+	vec3_t	wishvel;
+	for ( int i = 0 ; i < 3 ; i++ ) 
+	{
+		wishvel[i] = forward[i]*cmd->forwardmove + right[i]*cmd->rightmove;
+	}
+	VectorNormalize( wishvel );
+	if ( !VectorCompare( wishvel, dir ) )
+	{
+		Com_Printf( "PRECISION LOSS: %s != %s\n", vtos(wishvel), vtos(dir) );
+	}
+	*/
+}
+
+/*
+-------------------------
+NPC_MoveToGoal
+
+  Now assumes goal is goalEntity, was no reason for it to be otherwise
+-------------------------
+*/
+
+#if	AI_TIMERS
+extern int navTime;
+#endif//	AI_TIMERS
+qboolean NPC_MoveToGoal( qboolean tryStraight ) //FIXME: tryStraight not even used!  Stop passing it
+{
+#if	AI_TIMERS
+	int	startTime = GetTime(0);
+#endif//	AI_TIMERS
+	
+	if ( PM_InKnockDown( &NPC->client->ps ) || ( ( NPC->client->ps.legsAnim >= BOTH_PAIN1 ) && ( NPC->client->ps.legsAnim <= BOTH_PAIN18 ) && NPC->client->ps.legsAnimTimer > 0 ) )
+	{//If taking full body pain, don't move
+		return qtrue;
+	}
+
+	if( NPC->s.eFlags & EF_LOCKED_TO_WEAPON )
+	{//If in an emplaced gun, never try to navigate!
+		return qtrue;
+	}
+
+	if( NPC->s.eFlags & EF_HELD_BY_RANCOR )
+	{//If in a rancor's hand, never try to navigate!
+		return qtrue;
+	}
+	if( NPC->s.eFlags & EF_HELD_BY_WAMPA )
+	{//If in a wampa's hand, never try to navigate!
+		return qtrue;
+	}
+	if( NPC->s.eFlags & EF_HELD_BY_SAND_CREATURE )
+	{//If in a worm's mouth, never try to navigate!
+		return qtrue;
+	}
+
+	if ( NPC->watertype & CONTENTS_LADDER )
+	{//Do we still want to do this?
+		vec3_t	dir;
+		VectorSubtract( NPCInfo->goalEntity->currentOrigin, NPC->currentOrigin, dir );
+		VectorNormalize( dir );
+		NPC_LadderMove( dir );
+	}
+
+
+	bool	moveSuccess = true;
+	STEER::Activate(NPC);
+	{
+		// Attempt To Steer Directly To Our Goal
+		//---------------------------------------
+		moveSuccess = STEER::GoTo(NPC,  NPCInfo->goalEntity, NPCInfo->goalRadius);
+
+		// Perhaps Not Close Enough?  Try To Use The Navigation Grid
+		//-----------------------------------------------------------
+		if (!moveSuccess)
+		{
+			moveSuccess = NAV::GoTo(NPC, NPCInfo->goalEntity);
+			if (!moveSuccess)
+			{
+				STEER::Stop(NPC);
+			}
+		}
+	}
+	STEER::DeActivate(NPC, &ucmd);
+
+
+	#if	AI_TIMERS
+		navTime += GetTime( startTime );
+	#endif//	AI_TIMERS
+	return moveSuccess;
+}
+
+/*
+-------------------------
+void NPC_SlideMoveToGoal( void )
+
+  Now assumes goal is goalEntity, if want to use tempGoal, you set that before calling the func
+-------------------------
+*/
+qboolean NPC_SlideMoveToGoal( void )
+{
+	float	saveYaw = NPC->client->ps.viewangles[YAW];
+
+	NPCInfo->combatMove = qtrue;
+	
+	qboolean ret = NPC_MoveToGoal( qtrue );
+
+	NPCInfo->desiredYaw	= saveYaw;
+
+	return ret;
+}
+
+
+/*
+-------------------------
+NPC_ApplyRoff
+-------------------------
+*/
+
+void NPC_ApplyRoff(void)
+{
+	PlayerStateToEntityState( &NPC->client->ps, &NPC->s );
+	VectorCopy ( NPC->currentOrigin, NPC->lastOrigin );
+
+	// use the precise origin for linking
+	gi.linkentity(NPC);
+}
+
diff --git a/code/game/NPC_reactions.cpp b/code/game/NPC_reactions.cpp
new file mode 100644
index 0000000..ec4bf3c
--- /dev/null
+++ b/code/game/NPC_reactions.cpp
@@ -0,0 +1,1164 @@
+//NPC_reactions.cpp
+
+// leave this line at the top for all NPC_xxxx.cpp files...
+#include "g_headers.h"
+
+
+
+
+#include "b_local.h"
+#include "anims.h"
+#include "g_functions.h"
+#include "wp_saber.h"
+#include "g_Vehicles.h"
+
+extern qboolean G_CheckForStrongAttackMomentum( gentity_t *self );
+extern void G_AddVoiceEvent( gentity_t *self, int event, int speakDebounceTime );
+extern int PM_AnimLength( int index, animNumber_t anim );
+extern void cgi_S_StartSound( const vec3_t origin, int entityNum, int entchannel, sfxHandle_t sfx );
+extern qboolean Q3_TaskIDPending( gentity_t *ent, taskID_t taskType );
+extern int PM_PickAnim( gentity_t *self, int minAnim, int maxAnim );
+extern qboolean NPC_CheckLookTarget( gentity_t *self );
+extern void NPC_SetLookTarget( gentity_t *self, int entNum, int clearTime );
+extern qboolean Jedi_WaitingAmbush( gentity_t *self );
+extern void Jedi_Ambush( gentity_t *self );
+extern qboolean G_EntIsBreakable( int entityNum, gentity_t *breaker );
+
+extern qboolean PM_SaberInSpecialAttack( int anim );
+extern qboolean PM_SpinningSaberAnim( int anim );
+extern qboolean PM_SpinningAnim( int anim );
+extern qboolean PM_InKnockDown( playerState_t *ps );
+extern qboolean PM_CrouchAnim( int anim );
+extern qboolean PM_FlippingAnim( int anim );
+extern qboolean PM_RollingAnim( int anim );
+extern qboolean PM_InCartwheel( int anim );
+
+extern	cvar_t	*g_spskill;
+extern int	teamLastEnemyTime[];
+extern qboolean	stop_icarus;
+extern int killPlayerTimer;
+
+float g_crosshairEntDist = Q3_INFINITE;
+int g_crosshairSameEntTime = 0;
+int g_crosshairEntNum = ENTITYNUM_NONE;
+int g_crosshairEntTime = 0;
+/*
+-------------------------
+NPC_CheckAttacker
+-------------------------
+*/
+
+static void NPC_CheckAttacker( gentity_t *other, int mod )
+{
+	//FIXME: I don't see anything in here that would stop teammates from taking a teammate
+	//			as an enemy.  Ideally, there would be code before this to prevent that from
+	//			happening, but that is presumptuous.
+	
+	//valid ent - FIXME: a VALIDENT macro would be nice here
+	if ( !other )
+		return;
+
+	if ( other == NPC )
+		return;
+
+	if ( !other->inuse )
+		return;
+
+	//Don't take a target that doesn't want to be
+	if ( other->flags & FL_NOTARGET ) 
+		return;
+
+	if ( NPC->svFlags & SVF_LOCKEDENEMY )
+	{//IF LOCKED, CANNOT CHANGE ENEMY!!!!!
+		return;
+	}
+
+	//If we haven't taken a target, just get mad
+	if ( NPC->enemy == NULL )//was using "other", fixed to NPC
+	{
+		G_SetEnemy( NPC, other );
+		return;
+	}
+
+	//we have an enemy, see if he's dead
+	if ( NPC->enemy->health <= 0 )
+	{
+		G_ClearEnemy( NPC );
+		G_SetEnemy( NPC, other );
+		return;
+	}
+
+	//Don't take the same enemy again
+	if ( other == NPC->enemy )
+		return;
+
+	if ( NPC->client->ps.weapon == WP_SABER )
+	{//I'm a jedi
+		if ( mod == MOD_SABER )
+		{//I was hit by a saber  FIXME: what if this was a thrown saber?
+			//always switch to this enemy if I'm a jedi and hit by another saber
+			G_ClearEnemy( NPC );
+			G_SetEnemy( NPC, other );
+			return;
+		}
+	}
+	//Special case player interactions
+	if ( other == &g_entities[0] )
+	{
+		//Account for the skill level to skew the results
+		float	luckThreshold;
+
+		switch ( g_spskill->integer )
+		{
+		//Easiest difficulty, mild chance of picking up the player
+		case 0:
+			luckThreshold = 0.9f;
+			break;
+
+		//Medium difficulty, half-half chance of picking up the player
+		case 1:
+			luckThreshold = 0.5f;
+			break;
+
+		//Hardest difficulty, always turn on attacking player
+		case 2:
+		default:
+			luckThreshold = 0.0f;
+			break;
+		}
+
+		//Randomly pick up the target
+		if ( random() > luckThreshold )
+		{
+			G_ClearEnemy( other );
+			other->enemy = NPC;
+		}
+
+		return;
+	}
+}
+
+void NPC_SetPainEvent( gentity_t *self )
+{
+	if ( !self->NPC || !(self->NPC->aiFlags&NPCAI_DIE_ON_IMPACT) )
+	{
+	// no more borg
+	//	if( self->client->playerTeam != TEAM_BORG )
+	//	{
+			if ( !Q3_TaskIDPending( self, TID_CHAN_VOICE ) )
+			{
+				G_AddEvent( self, EV_PAIN, floor((float)self->health/self->max_health*100.0f) );
+			}
+	//	}
+	}
+}
+
+/*
+-------------------------
+NPC_GetPainChance
+-------------------------
+*/
+
+float NPC_GetPainChance( gentity_t *self, int damage )
+{
+	if ( !self->enemy )
+	{//surprised, always take pain
+		return 1.0f;
+	}
+
+	if ( damage > self->max_health/2.0f )
+	{
+		return 1.0f;
+	}
+
+	float pain_chance = (float)(self->max_health-self->health)/(self->max_health*2.0f) + (float)damage/(self->max_health/2.0f);
+	switch ( g_spskill->integer )
+	{
+	case 0:	//easy
+		//return 0.75f;
+		break;
+
+	case 1://med
+		pain_chance *= 0.5f;
+		//return 0.35f;
+		break;
+
+	case 2://hard
+	default:
+		pain_chance *= 0.1f;
+		//return 0.05f;
+		break;
+	}
+	//Com_Printf( "%s: %4.2f\n", self->NPC_type, pain_chance );
+	return pain_chance;
+}
+
+/*
+-------------------------
+NPC_ChoosePainAnimation
+-------------------------
+*/
+
+#define	MIN_PAIN_TIME	200
+
+extern int G_PickPainAnim( gentity_t *self, const vec3_t point, int damage, int hitLoc );
+void NPC_ChoosePainAnimation( gentity_t *self, gentity_t *other, const vec3_t point, int damage, int mod, int hitLoc, int voiceEvent = -1 )
+{
+	//If we've already taken pain, then don't take it again
+	if ( level.time < self->painDebounceTime && mod != MOD_ELECTROCUTE && mod != MOD_MELEE )
+	{//FIXME: if hit while recoving from losing a saber lock, we should still play a pain anim?
+		return;
+	}
+
+	int		pain_anim = -1;
+	float	pain_chance;
+	
+	if ( self->s.weapon == WP_THERMAL && self->client->fireDelay > 0 )
+	{//don't interrupt thermal throwing anim
+		return;
+	}
+	else if (self->client->ps.powerups[PW_GALAK_SHIELD])
+	{
+		return;
+	}
+	else if ( self->client->NPC_class == CLASS_GALAKMECH )
+	{
+		if ( hitLoc == HL_GENERIC1 )
+		{//hit the antenna!
+			pain_chance = 1.0f;
+			self->s.powerups |= ( 1 << PW_SHOCKED );
+			self->client->ps.powerups[PW_SHOCKED] = level.time + Q_irand( 500, 2500 );
+		}
+		else if ( self->client->ps.powerups[PW_GALAK_SHIELD] )
+		{//shield up
+			return;
+		}
+		else if ( self->health > 200 && damage < 100 )
+		{//have a *lot* of health
+			pain_chance = 0.05f;
+		}
+		else
+		{//the lower my health and greater the damage, the more likely I am to play a pain anim
+			pain_chance = (200.0f-self->health)/100.0f + damage/50.0f;
+		}
+	}
+	else if ( self->client && self->client->playerTeam == TEAM_PLAYER && other && !other->s.number )
+	{//ally shot by player always complains
+		pain_chance = 1.1f;
+	}
+	else 
+	{
+		if ( other && other->s.weapon == WP_SABER || mod == MOD_ELECTROCUTE || mod == MOD_CRUSH/*FIXME:MOD_FORCE_GRIP*/ )
+		{
+			if ( self->client->ps.weapon == WP_SABER 
+				&& other->s.number < MAX_CLIENTS )
+			{//hmm, shouldn't *always* react to damage from player if I have a saber 
+				pain_chance = 1.05f - ((self->NPC->rank)/(float)RANK_CAPTAIN); 
+			}
+			else
+			{
+				pain_chance = 1.0f;//always take pain from saber
+			}
+		}
+		else if ( mod == MOD_GAS )
+		{
+			pain_chance = 1.0f;
+		}
+		else if ( mod == MOD_MELEE )
+		{//higher in rank (skill) we are, less likely we are to be fazed by a punch
+			pain_chance = 1.0f - ((RANK_CAPTAIN-self->NPC->rank)/(float)RANK_CAPTAIN);
+		}
+		else if ( self->client->NPC_class == CLASS_PROTOCOL )
+		{
+			pain_chance = 1.0f;
+		}
+		else
+		{
+			pain_chance = NPC_GetPainChance( self, damage );
+		}
+		if ( self->client->NPC_class == CLASS_DESANN )
+		{
+			pain_chance *= 0.5f;
+		}
+	}
+
+	//See if we're going to flinch
+	if ( random() < pain_chance )
+	{
+		//Pick and play our animation
+		if ( (self->client->ps.eFlags&EF_FORCE_GRIPPED) )
+		{
+			G_AddVoiceEvent( self, Q_irand(EV_CHOKE1, EV_CHOKE3), 0 );
+		}
+		else if ( mod == MOD_GAS )
+		{
+			//SIGH... because our choke sounds are inappropriately long, I have to debounce them in code!
+			if ( TIMER_Done( self, "gasChokeSound" ) )
+			{
+				TIMER_Set( self, "gasChokeSound", Q_irand( 1000, 2000 ) );
+				G_AddVoiceEvent( self, Q_irand(EV_CHOKE1, EV_CHOKE3), 0 );
+			}
+		}
+		else if ( (self->client->ps.eFlags&EF_FORCE_DRAINED) )
+		{
+			NPC_SetPainEvent( self );
+		}
+		else
+		{//not being force-gripped or force-drained
+			if ( G_CheckForStrongAttackMomentum( self )
+				|| PM_SpinningAnim( self->client->ps.legsAnim )
+				|| PM_SaberInSpecialAttack( self->client->ps.torsoAnim )
+				|| PM_InKnockDown( &self->client->ps )
+				|| PM_RollingAnim( self->client->ps.legsAnim )
+				|| (PM_FlippingAnim( self->client->ps.legsAnim )&&!PM_InCartwheel( self->client->ps.legsAnim )) )
+			{//strong attacks, rolls, knockdowns, flips and spins cannot be interrupted by pain
+			}
+			else
+			{//play an anim
+				if ( self->client->NPC_class == CLASS_GALAKMECH )
+				{//only has 1 for now
+					//FIXME: never plays this, it seems...
+					pain_anim = BOTH_PAIN1;
+				}
+				else if ( mod == MOD_MELEE )
+				{
+					pain_anim = PM_PickAnim( self, BOTH_PAIN2, BOTH_PAIN3 );
+				}
+				else if ( self->s.weapon == WP_SABER )
+				{//temp HACK: these are the only 2 pain anims that look good when holding a saber
+					pain_anim = PM_PickAnim( self, BOTH_PAIN2, BOTH_PAIN3 );
+				}
+				else if ( mod != MOD_ELECTROCUTE )
+				{
+					pain_anim = G_PickPainAnim( self, point, damage, hitLoc );
+				}
+
+				if ( pain_anim == -1 )
+				{
+					pain_anim = PM_PickAnim( self, BOTH_PAIN1, BOTH_PAIN18 );
+				}
+				self->client->ps.saberAnimLevel = SS_FAST;//next attack must be a quick attack
+				self->client->ps.saberMove = LS_READY;//don't finish whatever saber move you may have been in
+				int parts = SETANIM_BOTH;
+				if ( PM_CrouchAnim( self->client->ps.legsAnim ) || PM_InCartwheel( self->client->ps.legsAnim ) )
+				{
+					parts = SETANIM_LEGS;
+				}
+				self->NPC->aiFlags &= ~NPCAI_KNEEL;
+				NPC_SetAnim( self, parts, pain_anim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+			}
+			if ( voiceEvent != -1 )
+			{
+				G_AddVoiceEvent( self, voiceEvent, Q_irand( 2000, 4000 ) );
+			}
+			else
+			{
+				NPC_SetPainEvent( self );
+			}
+		}
+		
+		//Setup the timing for it
+		if ( mod == MOD_ELECTROCUTE )
+		{
+			self->painDebounceTime = level.time + 4000;
+		}
+		self->painDebounceTime = level.time + PM_AnimLength( self->client->clientInfo.animFileIndex, (animNumber_t) pain_anim );
+		self->client->fireDelay = 0;
+	}
+}
+extern qboolean G_ValidEnemy( gentity_t *self, gentity_t *enemy );
+
+gentity_t *G_CheckControlledTurretEnemy(gentity_t *self, gentity_t *enemy, qboolean validate )
+{
+	if ( enemy->e_UseFunc == useF_emplaced_gun_use
+		|| enemy->e_UseFunc == useF_eweb_use )
+	{
+		if ( enemy->activator 
+			&& enemy->activator->client )
+		{//return the controller of the eweb/emplaced gun
+			if (validate==qfalse || !self->client || G_ValidEnemy(self, enemy))
+			{
+				return enemy->activator;
+			}
+		}
+		return NULL;
+	}
+	return enemy;
+}
+
+extern void		Boba_Pain( gentity_t *self, gentity_t *inflictor, int damage, int mod);
+/*
+===============
+NPC_Pain
+===============
+*/
+void NPC_Pain( gentity_t *self, gentity_t *inflictor, gentity_t *other, const vec3_t point, int damage, int mod, int hitLoc ) 
+{
+	team_t otherTeam = TEAM_FREE;
+	int		voiceEvent = -1;
+
+	if ( self->NPC == NULL ) 
+		return;
+
+	if ( other == NULL ) 
+		return;
+
+	//or just remove ->pain in player_die?
+	if ( self->client->ps.pm_type == PM_DEAD )
+		return;
+
+	if ( other == self ) 
+		return;
+
+	other = G_CheckControlledTurretEnemy(self, other, qfalse);
+	if (!other)
+	{
+		return;
+	}
+
+	//MCG: Ignore damage from your own team for now
+	if ( other->client )
+	{
+		otherTeam = other->client->playerTeam;
+	//	if ( otherTeam == TEAM_DISGUISE )
+	//	{
+	//		otherTeam = TEAM_PLAYER;
+	//	}
+	}
+
+	if ( self->client->playerTeam 
+		&& other->client 
+		&& otherTeam == self->client->playerTeam 
+		&& (!player->client->ps.viewEntity || other->s.number != player->client->ps.viewEntity)) 
+	{//hit by a teammate
+		if ( other != self->enemy && self != other->enemy )
+		{//we weren't already enemies
+			if ( self->enemy || other->enemy 
+				|| (other->s.number&&other->s.number!=player->client->ps.viewEntity) 
+				/*|| (!other->s.number&&Q_irand( 0, 3 ))*/ )
+			{//if one of us actually has an enemy already, it's okay, just an accident OR wasn't hit by player or someone controlled by player OR player hit ally and didn't get 25% chance of getting mad (FIXME:accumulate anger+base on diff?)
+				//FIXME: player should have to do a certain amount of damage to ally or hit them several times to make them mad
+				//Still run pain and flee scripts
+				if ( self->client && self->NPC )
+				{//Run any pain instructions
+					if ( self->health <= (self->max_health/3) && G_ActivateBehavior(self, BSET_FLEE) )
+					{
+						
+					}
+					else// if( VALIDSTRING( self->behaviorSet[BSET_PAIN] ) )
+					{
+						G_ActivateBehavior(self, BSET_PAIN);
+					}
+				}
+				if ( damage != -1 )
+				{//-1 == don't play pain anim
+					//Set our proper pain animation
+					if ( Q_irand( 0, 1 ) )
+					{
+						NPC_ChoosePainAnimation( self, other, point, damage, mod, hitLoc, EV_FFWARN );
+					}
+					else
+					{
+						NPC_ChoosePainAnimation( self, other, point, damage, mod, hitLoc );
+					}
+				}
+				return;
+			}
+			else if ( self->NPC && !other->s.number )//should be assumed, but...
+			{//dammit, stop that!
+				if ( self->NPC->charmedTime > level.time )
+				{//mindtricked
+					return;
+				}
+				else if ( self->NPC->ffireCount < 3+((2-g_spskill->integer)*2) )
+				{//not mad enough yet
+					//Com_Printf( "chck: %d < %d\n", self->NPC->ffireCount, 3+((2-g_spskill->integer)*2) );
+					if ( damage != -1 )
+					{//-1 == don't play pain anim
+						//Set our proper pain animation
+						if ( Q_irand( 0, 1 ) )
+						{
+							NPC_ChoosePainAnimation( self, other, point, damage, mod, hitLoc, EV_FFWARN );
+						}
+						else
+						{
+							NPC_ChoosePainAnimation( self, other, point, damage, mod, hitLoc );
+						}
+					}
+					return;
+				}
+				else if ( G_ActivateBehavior( self, BSET_FFIRE ) )
+				{//we have a specific script to run, so do that instead
+					return;
+				}
+				else
+				{//okay, we're going to turn on our ally, we need to set and lock our enemy and put ourselves in a bstate that lets us attack him (and clear any flags that would stop us)
+					self->NPC->blockedSpeechDebounceTime = 0;
+					voiceEvent = EV_FFTURN;
+					self->NPC->behaviorState = self->NPC->tempBehavior = self->NPC->defaultBehavior = BS_DEFAULT;
+					other->flags &= ~FL_NOTARGET;
+					self->svFlags &= ~(SVF_IGNORE_ENEMIES|SVF_ICARUS_FREEZE|SVF_NO_COMBAT_SOUNDS);
+					G_SetEnemy( self, other );
+					self->svFlags |= SVF_LOCKEDENEMY;
+					self->NPC->scriptFlags &= ~(SCF_DONT_FIRE|SCF_CROUCHED|SCF_WALKING|SCF_NO_COMBAT_TALK|SCF_FORCED_MARCH);
+					self->NPC->scriptFlags |= (SCF_CHASE_ENEMIES|SCF_NO_MIND_TRICK);
+					//NOTE: we also stop ICARUS altogether
+					stop_icarus = qtrue;
+					if ( !killPlayerTimer )
+					{
+						killPlayerTimer = level.time + 10000;
+					}
+				}
+			}
+		}
+	}
+
+	SaveNPCGlobals();
+	SetNPCGlobals( self );
+
+	//Do extra bits
+	if ( NPCInfo->ignorePain == qfalse )
+	{
+		NPCInfo->confusionTime = 0;//clear any charm or confusion, regardless
+		if ( NPC->ghoul2.size() && NPC->headBolt != -1 )
+		{
+			G_StopEffect("force/confusion", NPC->playerModel, NPC->headBolt, NPC->s.number );
+		}
+		if ( damage != -1 )
+		{//-1 == don't play pain anim
+			//Set our proper pain animation
+			NPC_ChoosePainAnimation( self, other, point, damage, mod, hitLoc, voiceEvent );
+		}
+		//Check to take a new enemy
+		if ( NPC->enemy != other && NPC != other )
+		{//not already mad at them
+			//if it's an eweb or emplaced gun, get mad at the owner, not the gun
+			NPC_CheckAttacker( other, mod );
+		}
+	}
+
+	//Attempt to run any pain instructions
+	if ( self->client && self->NPC )
+	{
+		//FIXME: This needs better heuristics perhaps
+		if(self->health <= (self->max_health/3) && G_ActivateBehavior(self, BSET_FLEE) )
+		{
+		}
+		else //if( VALIDSTRING( self->behaviorSet[BSET_PAIN] ) )
+		{
+			G_ActivateBehavior(self, BSET_PAIN);
+		}
+	}
+
+	//Attempt to fire any paintargets we might have
+	if( self->paintarget && self->paintarget[0] )
+	{
+		G_UseTargets2(self, other, self->paintarget);
+	}
+
+	if (self->client && self->client->NPC_class==CLASS_BOBAFETT)
+	{
+		Boba_Pain( self, inflictor, damage, mod);
+	}
+
+
+	RestoreNPCGlobals();
+}
+
+/*
+-------------------------
+NPC_Touch
+-------------------------
+*/
+extern qboolean INV_SecurityKeyGive( gentity_t *target, const char *keyname );
+void NPC_Touch(gentity_t *self, gentity_t *other, trace_t *trace) 
+{
+	if(!self->NPC)
+		return;
+
+	SaveNPCGlobals();
+	SetNPCGlobals( self );
+
+	if ( self->message && self->health <= 0 )
+	{//I am dead and carrying a key
+		if ( other && player && player->health > 0 && other == player )
+		{//player touched me
+			char *text;
+			qboolean	keyTaken;
+			//give him my key
+			if ( Q_stricmp( "goodie", self->message ) == 0 )
+			{//a goodie key
+				if ( (keyTaken = INV_GoodieKeyGive( other )) == qtrue )
+				{
+					text = "cp @SP_INGAME_TOOK_IMPERIAL_GOODIE_KEY";
+					G_AddEvent( other, EV_ITEM_PICKUP, (FindItemForInventory( INV_GOODIE_KEY )-bg_itemlist) );
+				}
+				else
+				{
+					text = "cp @SP_INGAME_CANT_CARRY_GOODIE_KEY";
+				}
+			}
+			else
+			{//a named security key
+				if ( (keyTaken = INV_SecurityKeyGive( player, self->message )) == qtrue )
+				{
+					text = "cp @SP_INGAME_TOOK_IMPERIAL_SECURITY_KEY";
+					G_AddEvent( other, EV_ITEM_PICKUP, (FindItemForInventory( INV_SECURITY_KEY )-bg_itemlist) );
+				}
+				else
+				{
+					text = "cp @SP_INGAME_CANT_CARRY_SECURITY_KEY";
+				}
+			}
+			if ( keyTaken )
+			{//remove my key
+				gi.G2API_SetSurfaceOnOff( &self->ghoul2[self->playerModel], "l_arm_key", 0x00000002 );
+				self->message = NULL;
+				self->client->ps.eFlags &= ~EF_FORCE_VISIBLE;	//remove sight flag
+				G_Sound( player, G_SoundIndex( "sound/weapons/key_pkup.wav" ) );
+			}
+			gi.SendServerCommand( NULL, text );
+		}
+	}
+
+	if ( other->client ) 
+	{//FIXME:  if pushing against another bot, both ucmd.rightmove = 127???
+		//Except if not facing one another...
+		if ( other->health > 0 ) 
+		{
+			NPCInfo->touchedByPlayer = other;
+		}
+
+		if ( other == NPCInfo->goalEntity ) 
+		{
+			NPCInfo->aiFlags |= NPCAI_TOUCHED_GOAL;
+		}
+
+		if( !(self->svFlags&SVF_LOCKEDENEMY) && !(self->svFlags&SVF_IGNORE_ENEMIES) && !(other->flags & FL_NOTARGET) )
+		{
+			if ( self->client->enemyTeam )
+			{//See if we bumped into an enemy
+				if ( other->client->playerTeam == self->client->enemyTeam )
+				{//bumped into an enemy
+					if( NPCInfo->behaviorState != BS_HUNT_AND_KILL && !NPCInfo->tempBehavior )
+					{//MCG - Begin: checking specific BS mode here, this is bad, a HACK
+						//FIXME: not medics?
+						if ( NPC->enemy != other )
+						{//not already mad at them
+							G_SetEnemy( NPC, other );
+						}
+		//				NPCInfo->tempBehavior = BS_HUNT_AND_KILL;
+					}
+				}
+			}
+		}
+
+		//FIXME: do this if player is moving toward me and with a certain dist?
+		/*
+		if ( other->s.number == 0 && self->client->playerTeam == other->client->playerTeam )
+		{
+			VectorAdd( self->client->pushVec, other->client->ps.velocity, self->client->pushVec );
+		}
+		*/
+	}
+	else 
+	{//FIXME: check for SVF_NONNPC_ENEMY flag here?
+		if ( other->health > 0 ) 
+		{
+			if ( NPC->enemy == other && (other->svFlags&SVF_NONNPC_ENEMY) )
+			{
+				NPCInfo->touchedByPlayer = other;
+			}
+		}
+
+		if ( other == NPCInfo->goalEntity ) 
+		{
+			NPCInfo->aiFlags |= NPCAI_TOUCHED_GOAL;
+		}
+	}
+
+	if ( NPC->client->NPC_class == CLASS_RANCOR )
+	{//rancor
+		if ( NPCInfo->blockedEntity != other && TIMER_Done(NPC, "blockedEntityIgnore")) 
+		{//blocked
+			//if ( G_EntIsBreakable( other->s.number, NPC ) )
+			{//bumped into another breakable, so take that one instead?
+				NPCInfo->blockedEntity = other;//???
+			}
+		}
+	}
+
+	RestoreNPCGlobals();
+}
+
+/*
+-------------------------
+NPC_TempLookTarget
+-------------------------
+*/
+
+void NPC_TempLookTarget( gentity_t *self, int lookEntNum, int minLookTime, int maxLookTime )
+{
+	if ( !self->client )
+	{
+		return;
+	}
+
+	if ( !minLookTime )
+	{
+		minLookTime = 1000;
+	}
+
+	if ( !maxLookTime )
+	{
+		maxLookTime = 1000;
+	}
+
+	if ( !NPC_CheckLookTarget( self ) )
+	{//Not already looking at something else
+		//Look at him for 1 to 3 seconds
+		NPC_SetLookTarget( self, lookEntNum, level.time + Q_irand( minLookTime, maxLookTime ) );
+	}
+}
+
+void NPC_Respond( gentity_t *self, int userNum )
+{
+	int event = -1;
+	/*
+
+	if ( Q_irand( 0, 1 ) )
+	{
+		event = Q_irand(EV_RESPOND1, EV_RESPOND3);
+	}
+	else
+	{
+		event = Q_irand(EV_BUSY1, EV_BUSY3);
+	}
+	*/
+
+	if ( !Q_irand( 0, 1 ) )
+	{//set looktarget to them for a second or two
+		NPC_TempLookTarget( self, userNum, 1000, 3000 );
+	}
+
+	//some last-minute hacked in responses
+	switch ( self->client->NPC_class )
+	{
+	case CLASS_JAN:
+		if ( self->enemy )
+		{
+			if ( !Q_irand( 0, 2 ) )
+			{
+				event = Q_irand( EV_CHASE1, EV_CHASE3 );
+			}
+			else if ( Q_irand( 0, 1 ) )
+			{
+				event = Q_irand( EV_OUTFLANK1, EV_OUTFLANK2 );
+			}
+			else
+			{
+				event = Q_irand( EV_COVER1, EV_COVER5 );
+			}
+		}
+		else if ( !Q_irand( 0, 2 ) )
+		{
+			event = EV_SUSPICIOUS4;
+		}
+		else if ( !Q_irand( 0, 1 ) )
+		{
+			event = EV_SOUND1;
+		}
+		else
+		{
+			event = EV_CONFUSE1;
+		}
+		break;
+	case CLASS_LANDO:
+		if ( self->enemy )
+		{
+			if ( !Q_irand( 0, 2 ) )
+			{
+				event = Q_irand( EV_CHASE1, EV_CHASE3 );
+			}
+			else if ( Q_irand( 0, 1 ) )
+			{
+				event = Q_irand( EV_OUTFLANK1, EV_OUTFLANK2 );
+			}
+			else
+			{
+				event = Q_irand( EV_COVER1, EV_COVER5 );
+			}
+		}
+		else if ( !Q_irand( 0, 6 ) )
+		{
+			event = EV_SIGHT2;
+		}
+		else if ( !Q_irand( 0, 5 ) )
+		{
+			event = EV_GIVEUP4;
+		}
+		else if ( Q_irand( 0, 4 ) > 1 )
+		{
+			event = Q_irand( EV_SOUND1, EV_SOUND3 );
+		}
+		else
+		{
+			event = Q_irand( EV_JDETECTED1, EV_JDETECTED2 );
+		}
+		break;
+	case CLASS_LUKE:
+		if ( self->enemy )
+		{
+			event = EV_COVER1;
+		}
+		else
+		{
+			event = Q_irand( EV_SOUND1, EV_SOUND3 );
+		}
+		break;
+	case CLASS_JEDI:
+	case CLASS_KYLE:
+		if ( !self->enemy )
+		{
+			/*
+			if ( !(self->svFlags&SVF_IGNORE_ENEMIES) 
+				&& (self->NPC->scriptFlags&SCF_LOOK_FOR_ENEMIES)
+				&& self->client->enemyTeam == TEAM_ENEMY )
+			{
+				event = Q_irand( EV_ANGER1, EV_ANGER3 );
+			}
+			else
+			*/
+			{
+				event = Q_irand( EV_CONFUSE1, EV_CONFUSE3 );
+			}
+		}
+		break;
+	case CLASS_PRISONER:
+		if ( self->enemy )
+		{
+			if ( Q_irand( 0, 1 ) )
+			{
+				event = Q_irand( EV_CHASE1, EV_CHASE3 );
+			}
+			else
+			{
+				event = Q_irand( EV_OUTFLANK1, EV_OUTFLANK2 );
+			}
+		}
+		else
+		{
+			event = Q_irand( EV_SOUND1, EV_SOUND3 );
+		}
+		break;
+	case CLASS_REBEL:
+		if ( self->enemy )
+		{
+			if ( !Q_irand( 0, 2 ) )
+			{
+				event = Q_irand( EV_CHASE1, EV_CHASE3 );
+			}
+			else
+			{
+				event = Q_irand( EV_DETECTED1, EV_DETECTED5 );
+			}
+		}
+		else
+		{
+			event = Q_irand( EV_SOUND1, EV_SOUND3 );
+		}
+		break;
+	case CLASS_BESPIN_COP:
+		if ( !Q_stricmp( "bespincop", self->NPC_type ) )
+		{//variant 1
+			if ( self->enemy )
+			{
+				if ( Q_irand( 0, 9 ) > 6 )
+				{
+					event = Q_irand( EV_CHASE1, EV_CHASE3 );
+				}
+				else if ( Q_irand( 0, 6 ) > 4 )
+				{
+					event = Q_irand( EV_OUTFLANK1, EV_OUTFLANK2 );
+				}
+				else
+				{
+					event = Q_irand( EV_COVER1, EV_COVER5 );
+				}
+			}
+			else if ( !Q_irand( 0, 3 ) )
+			{
+				event = Q_irand( EV_SIGHT2, EV_SIGHT3 );
+			}
+			else if ( !Q_irand( 0, 1 ) )
+			{
+				event = Q_irand( EV_SOUND1, EV_SOUND3 );
+			}
+			else if ( !Q_irand( 0, 2 ) )
+			{
+				event = EV_LOST1;
+			}
+			else if ( !Q_irand( 0, 1 ) )
+			{
+				event = EV_ESCAPING2;
+			}
+			else
+			{
+				event = EV_GIVEUP4;
+			}
+		}
+		else
+		{//variant2
+			if ( self->enemy )
+			{
+				if ( Q_irand( 0, 9 ) > 6 )
+				{
+					event = Q_irand( EV_CHASE1, EV_CHASE3 );
+				}
+				else if ( Q_irand( 0, 6 ) > 4 )
+				{
+					event = Q_irand( EV_OUTFLANK1, EV_OUTFLANK2 );
+				}
+				else
+				{
+					event = Q_irand( EV_COVER1, EV_COVER5 );
+				}
+			}
+			else if ( !Q_irand( 0, 3 ) )
+			{
+				event = Q_irand( EV_SIGHT1, EV_SIGHT2 );
+			}
+			else if ( !Q_irand( 0, 1 ) )
+			{
+				event = Q_irand( EV_SOUND1, EV_SOUND3 );
+			}
+			else if ( !Q_irand( 0, 2 ) )
+			{
+				event = EV_LOST1;
+			}
+			else if ( !Q_irand( 0, 1 ) )
+			{
+				event = EV_GIVEUP3;
+			}
+			else
+			{
+				event = EV_CONFUSE1;
+			}
+		}
+		break;
+	case CLASS_R2D2:				// droid
+		G_Sound(self, G_SoundIndex(va("sound/chars/r2d2/misc/r2d2talk0%d.wav",Q_irand(1, 3))));
+		break;
+	case CLASS_R5D2:				// droid
+		G_Sound(self, G_SoundIndex(va("sound/chars/r5d2/misc/r5talk%d.wav",Q_irand(1, 4))));
+		break;
+	case CLASS_MOUSE:				// droid
+		G_Sound(self, G_SoundIndex(va("sound/chars/mouse/misc/mousego%d.wav",Q_irand(1, 3))));
+		break;
+	case CLASS_GONK:				// droid
+		G_Sound(self, G_SoundIndex(va("sound/chars/gonk/misc/gonktalk%d.wav",Q_irand(1, 2))));
+		break;
+	case CLASS_JAWA:
+		G_SoundOnEnt(self, CHAN_VOICE, va("sound/chars/jawa/misc/chatter%d.wav",Q_irand(1, 6)) );
+		if ( self->NPC )
+		{
+			self->NPC->blockedSpeechDebounceTime = level.time + 2000;
+		}
+		break;
+	}
+	
+	if ( event != -1 )
+	{
+		//hack here because we reuse some "combat" and "extra" sounds
+		qboolean addFlag = (self->NPC->scriptFlags&SCF_NO_COMBAT_TALK);
+		self->NPC->scriptFlags &= ~SCF_NO_COMBAT_TALK;
+
+		G_AddVoiceEvent( self, event, 3000 );
+
+		if ( addFlag )
+		{
+			self->NPC->scriptFlags |= SCF_NO_COMBAT_TALK;
+		}
+	}
+}
+
+/*
+-------------------------
+NPC_UseResponse
+-------------------------
+*/
+
+void NPC_UseResponse( gentity_t *self, gentity_t *user, qboolean useWhenDone )
+{
+	if ( !self->NPC || !self->client )
+	{
+		return;
+	}
+
+	if ( user->s.number != 0 )
+	{//not used by the player
+		if ( useWhenDone )
+		{
+			G_ActivateBehavior( self, BSET_USE );
+		}
+		return;
+	}
+
+	if ( user->client && self->client->playerTeam != user->client->playerTeam && self->client->playerTeam != TEAM_NEUTRAL )
+	{//only those on the same team react
+		if ( useWhenDone )
+		{
+			G_ActivateBehavior( self, BSET_USE );
+		}
+		return;
+	}
+
+	if ( self->NPC->blockedSpeechDebounceTime > level.time )
+	{//I'm not responding right now
+		return;
+	}
+
+	if ( gi.VoiceVolume[self->s.number] )
+	{//I'm talking already
+		if ( !useWhenDone )
+		{//you're not trying to use me
+			return;
+		}
+	}
+
+	if ( useWhenDone )
+	{
+		G_ActivateBehavior( self, BSET_USE );
+	}
+	else
+	{
+		NPC_Respond( self, user->s.number );
+	}
+}
+
+/*
+-------------------------
+NPC_Use
+-------------------------
+*/
+extern void Add_Batteries( gentity_t *ent, int *count );
+
+void NPC_Use( gentity_t *self, gentity_t *other, gentity_t *activator ) 
+{
+	if (self->client->ps.pm_type == PM_DEAD)
+	{//or just remove ->pain in player_die?
+		return;
+	}
+
+	SaveNPCGlobals();
+	SetNPCGlobals( self );
+
+	if(self->client && self->NPC) 
+	{
+		// If this is a vehicle, let the other guy board it. Added 12/14/02 by AReis.
+		if ( self->client->NPC_class == CLASS_VEHICLE )
+		{
+			Vehicle_t *pVeh = self->m_pVehicle;
+
+			if ( pVeh && pVeh->m_pVehicleInfo && other && other->client )
+			{//safety
+				//if I used myself, eject everyone on me
+				if ( other == self )
+				{
+					pVeh->m_pVehicleInfo->EjectAll( pVeh );
+				}
+				// If other is already riding this vehicle (self), eject him.
+				else if ( other->owner == self )
+				{
+					pVeh->m_pVehicleInfo->Eject( pVeh, other, qfalse );
+				}
+				// Otherwise board this vehicle.
+				else
+				{
+					pVeh->m_pVehicleInfo->Board( pVeh, other );
+				}
+			}
+		}
+		else if ( Jedi_WaitingAmbush( NPC ) )
+		{
+			Jedi_Ambush( NPC );
+		}
+		//Run any use instructions
+		if ( activator && activator->s.number == 0 && self->client->NPC_class == CLASS_GONK )
+		{
+			// must be using the gonk, so attempt to give battery power.
+			// NOTE: this will steal up to MAX_BATTERIES for the activator, leaving the residual on the gonk for potential later use.
+			Add_Batteries( activator, &self->client->ps.batteryCharge );
+		}
+		// Not using MEDICs anymore
+/*
+		if ( self->NPC->behaviorState == BS_MEDIC_HIDE && activator->client )
+		{//Heal me NOW, dammit!
+			if ( activator->health < activator->max_health )
+			{//person needs help
+				if ( self->NPC->eventualGoal != activator )
+				{//not my current patient already
+					NPC_TakePatient( activator );
+					G_ActivateBehavior( self, BSET_USE );
+				}
+			}
+			else if ( !self->enemy && activator->s.number == 0 && !gi.VoiceVolume[self->s.number] && !(self->NPC->scriptFlags&SCF_NO_RESPONSE) )
+			{//I don't have an enemy and I'm not talking and I was used by the player
+				NPC_UseResponse( self, other, qfalse );
+			}
+		}
+*/
+//		else if ( self->behaviorSet[BSET_USE] )
+
+		if ( self->behaviorSet[BSET_USE] )
+		{
+			NPC_UseResponse( self, other, qtrue );
+		}
+//		else if ( isMedic( self ) )
+//		{//Heal me NOW, dammit!
+//			NPC_TakePatient( activator );
+//		}
+		else if ( !self->enemy 
+			//&& self->client->NPC_class == CLASS_VEHICLE
+			&& activator->s.number == 0 
+			&& !gi.VoiceVolume[self->s.number] 
+			&& !(self->NPC->scriptFlags&SCF_NO_RESPONSE) )
+		{//I don't have an enemy and I'm not talking and I was used by the player
+			NPC_UseResponse( self, other, qfalse );
+		}
+	}
+
+	RestoreNPCGlobals();
+}
+
+void NPC_CheckPlayerAim( void )
+{
+	//FIXME: need appropriate dialogue
+	/*
+	gentity_t *player = &g_entities[0];
+
+	if ( player && player->client && player->client->ps.weapon > (int)(WP_NONE) && player->client->ps.weapon < (int)(WP_TRICORDER) )
+	{//player has a weapon ready
+		if ( g_crosshairEntNum == NPC->s.number && level.time - g_crosshairEntTime < 200 
+			&& g_crosshairSameEntTime >= 3000 && g_crosshairEntDist < 256 )
+		{//if the player holds the crosshair on you for a few seconds
+			//ask them what the fuck they're doing
+			G_AddVoiceEvent( NPC, Q_irand( EV_FF_1A, EV_FF_1C ), 0 );
+		}
+	}
+	*/
+}
+
+void NPC_CheckAllClear( void )
+{
+	//FIXME: need to make this happen only once after losing enemies, not over and over again
+	/*
+	if ( NPC->client && !NPC->enemy && level.time - teamLastEnemyTime[NPC->client->playerTeam] > 10000 )
+	{//Team hasn't seen an enemy in 10 seconds
+		if ( !Q_irand( 0, 2 ) )
+		{
+			G_AddVoiceEvent( NPC, Q_irand(EV_SETTLE1, EV_SETTLE3), 3000 );
+		}
+	}
+	*/
+}
\ No newline at end of file
diff --git a/code/game/NPC_senses.cpp b/code/game/NPC_senses.cpp
new file mode 100644
index 0000000..fa17fd4
--- /dev/null
+++ b/code/game/NPC_senses.cpp
@@ -0,0 +1,1106 @@
+//NPC_senses.cpp
+
+// leave this line at the top for all NPC_xxxx.cpp files...
+#include "g_headers.h"
+
+
+
+
+#include "b_local.h"
+#ifdef _DEBUG
+	#include <float.h>
+#endif
+
+extern int eventClearTime;
+/*
+qboolean G_ClearLineOfSight(const vec3_t point1, const vec3_t point2, int ignore, int clipmask)
+
+returns true if can see from point 1 to 2, even through glass (1 pane)- doesn't work with portals
+*/
+qboolean G_ClearLineOfSight(const vec3_t point1, const vec3_t point2, int ignore, int clipmask)
+{
+	trace_t		tr;
+
+	gi.trace ( &tr, point1, NULL, NULL, point2, ignore, clipmask );
+	if ( tr.fraction == 1.0 ) 
+	{
+		return qtrue;
+	}
+
+	gentity_t	*hit = &g_entities[ tr.entityNum ];
+	if(EntIsGlass(hit))
+	{
+		vec3_t	newpoint1;
+		VectorCopy(tr.endpos, newpoint1);
+		gi.trace (&tr, newpoint1, NULL, NULL, point2, hit->s.number, clipmask );
+
+		if ( tr.fraction == 1.0 ) 
+		{
+			return qtrue;
+		}
+	}
+
+	return qfalse;
+}
+
+/*
+CanSee
+determine if NPC can see an entity
+
+This is a straight line trace check.  This function does not look at PVS or FOV,
+or take any AI related factors (for example, the NPC's reaction time) into account
+
+FIXME do we need fat and thin version of this?
+*/
+qboolean CanSee ( gentity_t *ent ) 
+{
+	trace_t		tr;
+	vec3_t		eyes;
+	vec3_t		spot;
+
+	CalcEntitySpot( NPC, SPOT_HEAD_LEAN, eyes );
+
+	CalcEntitySpot( ent, SPOT_ORIGIN, spot );
+	gi.trace ( &tr, eyes, NULL, NULL, spot, NPC->s.number, MASK_OPAQUE );
+	ShotThroughGlass (&tr, ent, spot, MASK_OPAQUE);
+	if ( tr.fraction == 1.0 ) 
+	{
+		return qtrue;
+	}
+
+	CalcEntitySpot( ent, SPOT_HEAD, spot );
+	gi.trace ( &tr, eyes, NULL, NULL, spot, NPC->s.number, MASK_OPAQUE );
+	ShotThroughGlass (&tr, ent, spot, MASK_OPAQUE);
+	if ( tr.fraction == 1.0 ) 
+	{
+		return qtrue;
+	}
+
+	CalcEntitySpot( ent, SPOT_LEGS, spot );
+	gi.trace ( &tr, eyes, NULL, NULL, spot, NPC->s.number, MASK_OPAQUE );
+	ShotThroughGlass (&tr, ent, spot, MASK_OPAQUE);
+	if ( tr.fraction == 1.0 ) 
+	{
+		return qtrue;
+	}
+
+	return qfalse;
+}
+
+qboolean InFront( vec3_t spot, vec3_t from, vec3_t fromAngles, float threshHold = 0.0f )
+{
+	vec3_t	dir, forward, angles;
+	float	dot;
+
+	VectorSubtract( spot, from, dir );
+	dir[2] = 0;
+	VectorNormalize( dir );
+
+	VectorCopy( fromAngles, angles );
+	angles[0] = 0;
+	AngleVectors( angles, forward, NULL, NULL );
+
+	dot = DotProduct( dir, forward );
+
+	return (dot > threshHold);
+}
+
+float DotToSpot( vec3_t spot, vec3_t from, vec3_t fromAngles )
+{
+	vec3_t	dir, forward, angles;
+	float	dot;
+
+	VectorSubtract( spot, from, dir );
+	dir[2] = 0;
+	VectorNormalize( dir );
+
+	VectorCopy( fromAngles, angles );
+	angles[0] = 0;
+	AngleVectors( angles, forward, NULL, NULL );
+
+	dot = DotProduct( dir, forward );
+
+	return dot;
+}
+/*
+InFOV
+
+IDEA: further off to side of FOV range, higher chance of failing even if technically in FOV,
+	keep core of 50% to sides as always succeeding
+*/
+
+//Position compares
+
+qboolean InFOV( vec3_t spot, vec3_t from, vec3_t fromAngles, int hFOV, int vFOV )
+{
+	vec3_t	deltaVector, angles, deltaAngles;
+
+	VectorSubtract ( spot, from, deltaVector );
+	vectoangles ( deltaVector, angles );
+	
+	deltaAngles[PITCH]	= AngleDelta ( fromAngles[PITCH], angles[PITCH] );
+	deltaAngles[YAW]	= AngleDelta ( fromAngles[YAW], angles[YAW] );
+
+	if ( fabs ( deltaAngles[PITCH] ) <= vFOV && fabs ( deltaAngles[YAW] ) <= hFOV ) 
+	{
+		return qtrue;
+	}
+
+	return qfalse;
+}
+
+//NPC to position
+
+qboolean InFOV( vec3_t origin, gentity_t *from, int hFOV, int vFOV ) 
+{
+	vec3_t	fromAngles, eyes;
+
+	if( from->client )
+	{
+		VectorCopy(from->client->ps.viewangles, fromAngles);
+	}
+	else
+	{
+		VectorCopy(from->s.angles, fromAngles);
+	}
+
+	CalcEntitySpot( from, SPOT_HEAD, eyes );
+
+	return InFOV( origin, eyes, fromAngles, hFOV, vFOV );
+}
+
+//Entity to entity
+qboolean InFOVFromPlayerView ( gentity_t *ent, int hFOV, int vFOV ) 
+{
+	vec3_t	eyes;
+	vec3_t	spot;
+	vec3_t	deltaVector;
+	vec3_t	angles, fromAngles;
+	vec3_t	deltaAngles;
+
+	if ( !player || !player->client )
+	{
+		return qfalse;
+	}
+	if ( cg.time )
+	{
+		VectorCopy( cg.refdefViewAngles, fromAngles );
+	}
+	else
+	{
+		VectorCopy( player->client->ps.viewangles, fromAngles );
+	}
+
+	if( cg.time )
+	{
+		VectorCopy( cg.refdef.vieworg, eyes );
+	}
+	else
+	{
+		CalcEntitySpot( player, SPOT_HEAD_LEAN, eyes );
+	}
+
+	CalcEntitySpot( ent, SPOT_ORIGIN, spot );
+	VectorSubtract ( spot, eyes, deltaVector);
+
+	vectoangles ( deltaVector, angles );
+	deltaAngles[PITCH] = AngleDelta ( fromAngles[PITCH], angles[PITCH] );
+	deltaAngles[YAW] = AngleDelta ( fromAngles[YAW], angles[YAW] );
+	if ( fabs ( deltaAngles[PITCH] ) <= vFOV && fabs ( deltaAngles[YAW] ) <= hFOV ) 
+	{
+		return qtrue;
+	}
+
+	CalcEntitySpot( ent, SPOT_HEAD, spot );
+	VectorSubtract ( spot, eyes, deltaVector);
+	vectoangles ( deltaVector, angles );
+	deltaAngles[PITCH] = AngleDelta ( fromAngles[PITCH], angles[PITCH] );
+	deltaAngles[YAW] = AngleDelta ( fromAngles[YAW], angles[YAW] );
+	if ( fabs ( deltaAngles[PITCH] ) <= vFOV && fabs ( deltaAngles[YAW] ) <= hFOV ) 
+	{
+		return qtrue;
+	}
+
+	CalcEntitySpot( ent, SPOT_LEGS, spot );
+	VectorSubtract ( spot, eyes, deltaVector);
+	vectoangles ( deltaVector, angles );
+	deltaAngles[PITCH] = AngleDelta ( fromAngles[PITCH], angles[PITCH] );
+	deltaAngles[YAW] = AngleDelta ( fromAngles[YAW], angles[YAW] );
+	if ( fabs ( deltaAngles[PITCH] ) <= vFOV && fabs ( deltaAngles[YAW] ) <= hFOV ) 
+	{
+		return qtrue;
+	}
+
+	return qfalse;
+}
+
+qboolean InFOV ( gentity_t *ent, gentity_t *from, int hFOV, int vFOV ) 
+{
+	vec3_t	eyes;
+	vec3_t	spot;
+	vec3_t	deltaVector;
+	vec3_t	angles, fromAngles;
+	vec3_t	deltaAngles;
+
+	if( from->client )
+	{
+		if( from->client->NPC_class != CLASS_RANCOR 
+			&& from->client->NPC_class != CLASS_WAMPA
+			&& !VectorCompare( from->client->renderInfo.eyeAngles, vec3_origin ) )
+		{//Actual facing of tag_head!
+			//NOTE: Stasis aliens may have a problem with this?
+			VectorCopy( from->client->renderInfo.eyeAngles, fromAngles );
+		}
+		else
+		{
+			VectorCopy( from->client->ps.viewangles, fromAngles );
+		}
+	}
+	else
+	{
+		VectorCopy(from->s.angles, fromAngles);
+	}
+
+	CalcEntitySpot( from, SPOT_HEAD_LEAN, eyes );
+
+	CalcEntitySpot( ent, SPOT_ORIGIN, spot );
+	VectorSubtract ( spot, eyes, deltaVector);
+
+	vectoangles ( deltaVector, angles );
+	deltaAngles[PITCH] = AngleDelta ( fromAngles[PITCH], angles[PITCH] );
+	deltaAngles[YAW] = AngleDelta ( fromAngles[YAW], angles[YAW] );
+	if ( fabs ( deltaAngles[PITCH] ) <= vFOV && fabs ( deltaAngles[YAW] ) <= hFOV ) 
+	{
+		return qtrue;
+	}
+
+	CalcEntitySpot( ent, SPOT_HEAD, spot );
+	VectorSubtract ( spot, eyes, deltaVector);
+	vectoangles ( deltaVector, angles );
+	deltaAngles[PITCH] = AngleDelta ( fromAngles[PITCH], angles[PITCH] );
+	deltaAngles[YAW] = AngleDelta ( fromAngles[YAW], angles[YAW] );
+	if ( fabs ( deltaAngles[PITCH] ) <= vFOV && fabs ( deltaAngles[YAW] ) <= hFOV ) 
+	{
+		return qtrue;
+	}
+
+	CalcEntitySpot( ent, SPOT_LEGS, spot );
+	VectorSubtract ( spot, eyes, deltaVector);
+	vectoangles ( deltaVector, angles );
+	deltaAngles[PITCH] = AngleDelta ( fromAngles[PITCH], angles[PITCH] );
+	deltaAngles[YAW] = AngleDelta ( fromAngles[YAW], angles[YAW] );
+	if ( fabs ( deltaAngles[PITCH] ) <= vFOV && fabs ( deltaAngles[YAW] ) <= hFOV ) 
+	{
+		return qtrue;
+	}
+
+	return qfalse;
+}
+
+qboolean InVisrange ( gentity_t *ent ) 
+{//FIXME: make a calculate visibility for ents that takes into account
+	//lighting, movement, turning, crouch/stand up, other anims, hide brushes, etc.
+	vec3_t	eyes;
+	vec3_t	spot;
+	vec3_t	deltaVector;
+	float	visrange = (NPCInfo->stats.visrange*NPCInfo->stats.visrange);
+
+	CalcEntitySpot( NPC, SPOT_HEAD_LEAN, eyes );
+
+	CalcEntitySpot( ent, SPOT_ORIGIN, spot );
+	VectorSubtract ( spot, eyes, deltaVector);
+
+	/*if(ent->client)
+	{
+		float	vel, avel;
+		if(ent->client->ps.velocity[0] || ent->client->ps.velocity[1] || ent->client->ps.velocity[2])
+		{
+			vel = VectorLength(ent->client->ps.velocity);
+			if(vel > 128)
+			{
+				visrange += visrange * (vel/256);
+			}
+		}
+
+		if(ent->avelocity[0] || ent->avelocity[1] || ent->avelocity[2])
+		{//FIXME: shouldn't they need to have line of sight to you to detect this?
+			avel = VectorLength(ent->avelocity);
+			if(avel > 15)
+			{
+				visrange += visrange * (avel/60);
+			}
+		}
+	}*/
+
+	if(VectorLengthSquared(deltaVector) > visrange)
+	{
+		return qfalse;
+	}
+
+	return qtrue;
+}
+
+/*
+NPC_CheckVisibility
+*/
+
+visibility_t NPC_CheckVisibility ( gentity_t *ent, int flags ) 
+{
+	// flags should never be 0
+	if ( !flags ) 
+	{
+		return VIS_NOT;
+	}
+
+	// check PVS
+	if ( flags & CHECK_PVS ) 
+	{
+		if ( !gi.inPVS ( ent->currentOrigin, NPC->currentOrigin ) ) 
+		{
+			return VIS_NOT;
+		}
+	}
+	if ( !(flags & (CHECK_360|CHECK_FOV|CHECK_SHOOT)) ) 
+	{
+		return VIS_PVS;
+	}
+
+	// check within visrange
+	if (flags & CHECK_VISRANGE)
+	{
+		if( !InVisrange ( ent ) ) 
+		{
+			return VIS_PVS;
+		}
+	}
+
+	// check 360 degree visibility
+	//Meaning has to be a direct line of site
+	if ( flags & CHECK_360 ) 
+	{
+		if ( !CanSee ( ent ) ) 
+		{
+			return VIS_PVS;
+		}
+	}
+	if ( !(flags & (CHECK_FOV|CHECK_SHOOT)) ) 
+	{
+		return VIS_360;
+	}
+
+	// check FOV
+	if ( flags & CHECK_FOV ) 
+	{
+		if ( !InFOV ( ent, NPC, NPCInfo->stats.hfov, NPCInfo->stats.vfov) ) 
+		{
+			return VIS_360;
+		}
+	}
+
+	if ( !(flags & CHECK_SHOOT) ) 
+	{
+		return VIS_FOV;
+	}
+
+	// check shootability
+	if ( flags & CHECK_SHOOT ) 
+	{
+		if ( !CanShoot ( ent, NPC ) ) 
+		{
+			return VIS_FOV;
+		}
+	}
+
+	return VIS_SHOOT;
+}
+
+/*
+-------------------------
+NPC_CheckSoundEvents
+-------------------------
+*/
+static int G_CheckSoundEvents( gentity_t *self, float maxHearDist, int ignoreAlert, qboolean mustHaveOwner, int minAlertLevel, qboolean onGroundOnly )
+{
+	int	bestEvent = -1;
+	int bestAlert = -1;
+	int	bestTime = -1;
+	float dist, radius;
+
+	maxHearDist *= maxHearDist;
+
+	for ( int i = 0; i < level.numAlertEvents; i++ )
+	{
+		//are we purposely ignoring this alert?
+		if ( level.alertEvents[i].ID == ignoreAlert )
+			continue;
+		//We're only concerned about sounds
+		if ( level.alertEvents[i].type != AET_SOUND )
+			continue;
+		//must be at least this noticable
+		if ( level.alertEvents[i].level < minAlertLevel )
+			continue;
+		//must have an owner?
+		if ( mustHaveOwner && !level.alertEvents[i].owner )
+			continue;
+		//must be on the ground?
+		if ( onGroundOnly && !level.alertEvents[i].onGround )
+			continue;
+
+		//Must be within range
+		dist = DistanceSquared( level.alertEvents[i].position, self->currentOrigin );
+
+		//can't hear it
+		if ( dist > maxHearDist )
+			continue;
+
+		if ( self->client && self->client->NPC_class != CLASS_SAND_CREATURE )
+		{//sand creatures hear all in within their earshot, regardless of quietness and alert sound radius!
+			radius = level.alertEvents[i].radius * level.alertEvents[i].radius;
+			if ( dist > radius )
+				continue;
+
+			if ( level.alertEvents[i].addLight )
+			{//a quiet sound, must have LOS to hear it
+				if ( G_ClearLOS( self, level.alertEvents[i].position ) == qfalse )
+				{//no LOS, didn't hear it
+					continue;
+				}
+			}
+		}
+
+		//See if this one takes precedence over the previous one
+		if ( level.alertEvents[i].level >= bestAlert //higher alert level
+			|| (level.alertEvents[i].level==bestAlert&&level.alertEvents[i].timestamp >= bestTime) )//same alert level, but this one is newer
+		{//NOTE: equal is better because it's later in the array
+			bestEvent = i;
+			bestAlert = level.alertEvents[i].level;
+			bestTime = level.alertEvents[i].timestamp;
+		}
+	}
+
+	return bestEvent;
+}
+
+float G_GetLightLevel( vec3_t pos, vec3_t fromDir )
+{
+	vec3_t	ambient={0}, directed, lightDir;
+	float	lightLevel;
+
+	cgi_R_GetLighting( pos, ambient, directed, lightDir );
+
+	lightLevel = VectorLength( ambient ) + (VectorLength( directed )*DotProduct( lightDir, fromDir ));
+
+	return lightLevel;
+}
+/*
+-------------------------
+NPC_CheckSightEvents
+-------------------------
+*/
+static int G_CheckSightEvents( gentity_t *self, int hFOV, int vFOV, float maxSeeDist, int ignoreAlert, qboolean mustHaveOwner, int minAlertLevel )
+{
+	int	bestEvent = -1;
+	int bestAlert = -1;
+	int	bestTime = -1;
+	float	dist, radius;
+
+	maxSeeDist *= maxSeeDist;
+	for ( int i = 0; i < level.numAlertEvents; i++ )
+	{
+		//are we purposely ignoring this alert?
+		if ( level.alertEvents[i].ID == ignoreAlert )
+			continue;
+		//We're only concerned about sounds
+		if ( level.alertEvents[i].type != AET_SIGHT )
+			continue;
+		//must be at least this noticable
+		if ( level.alertEvents[i].level < minAlertLevel )
+			continue;
+		//must have an owner?
+		if ( mustHaveOwner && !level.alertEvents[i].owner )
+			continue;
+
+		//Must be within range
+		dist = DistanceSquared( level.alertEvents[i].position, self->currentOrigin );
+
+		//can't see it
+		if ( dist > maxSeeDist )
+			continue;
+
+		radius = level.alertEvents[i].radius * level.alertEvents[i].radius;
+		if ( dist > radius )
+			continue;
+
+		//Must be visible
+		if ( InFOV( level.alertEvents[i].position, self, hFOV, vFOV ) == qfalse )
+			continue;
+
+		if ( G_ClearLOS( self, level.alertEvents[i].position ) == qfalse )
+			continue;
+
+		//FIXME: possibly have the light level at this point affect the 
+		//			visibility/alert level of this event?  Would also
+		//			need to take into account how bright the event
+		//			itself is.  A lightsaber would stand out more
+		//			in the dark... maybe pass in a light level that
+		//			is added to the actual light level at this position?
+
+		//See if this one takes precedence over the previous one
+		if ( level.alertEvents[i].level >= bestAlert //higher alert level
+			|| (level.alertEvents[i].level==bestAlert&&level.alertEvents[i].timestamp >= bestTime) )//same alert level, but this one is newer
+		{//NOTE: equal is better because it's later in the array
+			bestEvent = i;
+			bestAlert = level.alertEvents[i].level;
+			bestTime = level.alertEvents[i].timestamp;
+		}
+	}
+
+	return bestEvent;
+}
+
+qboolean G_RememberAlertEvent( gentity_t *self, int alertIndex )
+{
+	if ( !self || !self->NPC )
+	{//not a valid ent
+		return qfalse;
+	}
+
+	if ( alertIndex == -1 )
+	{//not a valid event
+		return qfalse;
+	}
+
+	// Get The Event Struct
+	//----------------------
+	alertEvent_t&	at = level.alertEvents[alertIndex];
+
+	if ( at.ID == self->NPC->lastAlertID )
+	{//already know this one
+		return qfalse;
+	}
+
+	if (at.owner==self)
+	{//don't care about events that I made
+		return false;
+	}
+
+	self->NPC->lastAlertID = at.ID;
+
+	// Now, If It Is Dangerous Enough, We Want To Register This With The Pathfinding System
+	//--------------------------------------------------------------------------------------
+	bool	IsDangerous = (at.level >= AEL_DANGER);
+	bool	IsFromNPC	= (at.owner && at.owner->client);
+	bool	IsFromEnemy = (IsFromNPC && at.owner->client->playerTeam!=self->client->playerTeam);
+
+	if (IsDangerous && (!IsFromNPC || IsFromEnemy))
+	{
+		NAV::RegisterDangerSense(self, alertIndex);
+	}
+
+	return qtrue;
+}
+/*
+-------------------------
+NPC_CheckAlertEvents
+
+    NOTE: Should all NPCs create alertEvents too so they can detect each other?
+-------------------------
+*/
+
+int G_CheckAlertEvents( gentity_t *self, qboolean checkSight, qboolean checkSound, float maxSeeDist, float maxHearDist, int ignoreAlert, qboolean mustHaveOwner, int minAlertLevel, qboolean onGroundOnly )
+{
+	if ( &g_entities[0] == NULL || g_entities[0].health <= 0 )
+	{
+		//player is dead
+		return -1;
+	}
+
+	int bestSoundEvent = -1;
+	int bestSightEvent = -1;
+	int bestSoundAlert = -1;
+	int bestSightAlert = -1;
+
+	if ( checkSound )
+	{
+		//get sound event
+		bestSoundEvent = G_CheckSoundEvents( self, maxHearDist, ignoreAlert, mustHaveOwner, minAlertLevel, onGroundOnly );
+		//get sound event alert level
+		if ( bestSoundEvent >= 0 )
+		{
+			bestSoundAlert = level.alertEvents[bestSoundEvent].level;
+		}
+	}
+
+	if ( checkSight )
+	{
+		//get sight event
+		if ( self->NPC )
+		{
+			bestSightEvent = G_CheckSightEvents( self, self->NPC->stats.hfov, self->NPC->stats.vfov, maxSeeDist, ignoreAlert, mustHaveOwner, minAlertLevel );
+		}
+		else
+		{
+			bestSightEvent = G_CheckSightEvents( self, 80, 80, maxSeeDist, ignoreAlert, mustHaveOwner, minAlertLevel );//FIXME: look at cg_view to get more accurate numbers?
+		}
+		//get sight event alert level
+		if ( bestSightEvent >= 0 )
+		{
+			bestSightAlert = level.alertEvents[bestSightEvent].level;
+		}
+
+		//return the one that has a higher alert (or sound if equal)
+		//FIXME:	This doesn't take the distance of the event into account
+
+		if ( bestSightEvent >= 0 && bestSightAlert > bestSoundAlert )
+		{//valid best sight event, more important than the sound event
+			//get the light level of the alert event for this checker
+			vec3_t	eyePoint, sightDir;
+			//get eye point
+			CalcEntitySpot( self, SPOT_HEAD_LEAN, eyePoint );
+			VectorSubtract( level.alertEvents[bestSightEvent].position, eyePoint, sightDir );
+			level.alertEvents[bestSightEvent].light = level.alertEvents[bestSightEvent].addLight + G_GetLightLevel( level.alertEvents[bestSightEvent].position, sightDir );
+			//return the sight event
+			if ( G_RememberAlertEvent( self, bestSightEvent ) )
+			{
+				return bestSightEvent;
+			}
+		}
+	}
+	//return the sound event
+	if ( G_RememberAlertEvent( self, bestSoundEvent ) )
+	{
+		return bestSoundEvent;
+	}
+	//no event or no new event
+	return -1;
+}
+
+int NPC_CheckAlertEvents( qboolean checkSight, qboolean checkSound, int ignoreAlert, qboolean mustHaveOwner, int minAlertLevel, qboolean onGroundOnly )
+{
+	return G_CheckAlertEvents( NPC, checkSight, checkSound, NPCInfo->stats.visrange, NPCInfo->stats.earshot, ignoreAlert, mustHaveOwner, minAlertLevel, onGroundOnly );
+}
+
+extern void WP_ForcePowerStop( gentity_t *self, forcePowers_t forcePower );
+
+qboolean G_CheckForDanger( gentity_t *self, int alertEvent )
+{//FIXME: more bStates need to call this?
+	if ( alertEvent == -1 )
+	{
+		return qfalse;
+	}
+
+	if ( level.alertEvents[alertEvent].level >= AEL_DANGER )
+	{//run away!
+		if ( !level.alertEvents[alertEvent].owner || !level.alertEvents[alertEvent].owner->client || (level.alertEvents[alertEvent].owner!=self&&level.alertEvents[alertEvent].owner->client->playerTeam!=self->client->playerTeam) )
+		{
+			if ( self->NPC )
+			{
+				if ( self->NPC->scriptFlags & SCF_DONT_FLEE )
+				{//can't flee
+					return qfalse;
+				}
+				else
+				{
+					if ( level.alertEvents[alertEvent].level >= AEL_DANGER_GREAT || self->s.weapon == WP_NONE || self->s.weapon == WP_MELEE )
+					{//flee for a longer period of time
+						NPC_StartFlee( level.alertEvents[alertEvent].owner, level.alertEvents[alertEvent].position, level.alertEvents[alertEvent].level, 3000, 6000 );
+					}
+					else if ( !Q_irand( 0, 10 ) )//FIXME: base on rank?  aggression?
+					{//just normal danger and I have a weapon, so just a 25% chance of fleeing only for a few seconds
+						//FIXME: used to just find a better combat point, need that functionality back
+						NPC_StartFlee( level.alertEvents[alertEvent].owner, level.alertEvents[alertEvent].position, level.alertEvents[alertEvent].level, 1000, 3000 );
+					}
+					else
+					{//didn't flee
+						TIMER_Set( NPC, "duck", 2000);	// something dangerous going on...
+						return qfalse;
+					}
+					return qtrue;
+				}
+			}
+			else
+			{
+				return qtrue;
+			}
+		}
+	}
+	return qfalse;
+}
+qboolean NPC_CheckForDanger( int alertEvent )
+{//FIXME: more bStates need to call this?
+	return G_CheckForDanger( NPC, alertEvent );
+}
+
+/*
+-------------------------
+AddSoundEvent
+-------------------------
+*/
+qboolean RemoveOldestAlert( void );
+void AddSoundEvent( gentity_t *owner, vec3_t position, float radius, alertEventLevel_e alertLevel, qboolean needLOS, qboolean onGround )
+{
+	//FIXME: Handle this in another manner?
+	if ( level.numAlertEvents >= MAX_ALERT_EVENTS )
+	{
+		if ( !RemoveOldestAlert() )
+		{//how could that fail?
+			return;
+		}
+	}
+	
+	if ( owner == NULL && alertLevel < AEL_DANGER )	//allows un-owned danger alerts
+		return;
+
+	//FIXME: why are Sand creatures suddenly crashlanding?
+	if ( owner && owner->client && owner->client->NPC_class == CLASS_SAND_CREATURE )
+	{
+		return;
+	}
+
+	//FIXME: if owner is not a player or player ally, and there are no player allies present,
+	//			perhaps we don't need to store the alert... unless we want the player to
+	//			react to enemy alert events in some way?
+
+#ifdef _DEBUG
+	assert( !_isnan(position[0]) && !_isnan(position[1]) && !_isnan(position[2]) );
+#endif
+	VectorCopy( position, level.alertEvents[ level.numAlertEvents ].position );
+
+	level.alertEvents[ level.numAlertEvents ].radius	= radius;
+	level.alertEvents[ level.numAlertEvents ].level		= alertLevel;
+	level.alertEvents[ level.numAlertEvents ].type		= AET_SOUND;
+	level.alertEvents[ level.numAlertEvents ].owner		= owner;
+	if ( needLOS )
+	{//a very low-level sound, when check this sound event, check for LOS
+		level.alertEvents[ level.numAlertEvents ].addLight	= 1;	//will force an LOS trace on this sound
+	}
+	else
+	{
+		level.alertEvents[ level.numAlertEvents ].addLight	= 0;	//will force an LOS trace on this sound
+	}
+	level.alertEvents[ level.numAlertEvents ].onGround = onGround;
+
+	level.alertEvents[ level.numAlertEvents ].ID		= ++level.curAlertID;
+	level.alertEvents[ level.numAlertEvents ].timestamp	= level.time;
+	level.numAlertEvents++;
+}
+
+/*
+-------------------------
+AddSightEvent
+-------------------------
+*/
+
+void AddSightEvent( gentity_t *owner, vec3_t position, float radius, alertEventLevel_e alertLevel, float addLight )
+{
+	//FIXME: Handle this in another manner?
+	if ( level.numAlertEvents >= MAX_ALERT_EVENTS )
+	{
+		if ( !RemoveOldestAlert() )
+		{//how could that fail?
+			return;
+		}
+	}
+
+	if ( owner == NULL && alertLevel < AEL_DANGER )	//allows un-owned danger alerts
+		return;
+
+	//FIXME: if owner is not a player or player ally, and there are no player allies present,
+	//			perhaps we don't need to store the alert... unless we want the player to
+	//			react to enemy alert events in some way?
+
+#ifdef _DEBUG
+	assert( !_isnan(position[0]) && !_isnan(position[1]) && !_isnan(position[2]) );
+#endif
+	VectorCopy( position, level.alertEvents[ level.numAlertEvents ].position );
+
+	level.alertEvents[ level.numAlertEvents ].radius	= radius;
+	level.alertEvents[ level.numAlertEvents ].level		= alertLevel;
+	level.alertEvents[ level.numAlertEvents ].type		= AET_SIGHT;
+	level.alertEvents[ level.numAlertEvents ].owner		= owner;		
+	level.alertEvents[ level.numAlertEvents ].addLight	= addLight;	//will get added to actual light at that point when it's checked
+	level.alertEvents[ level.numAlertEvents ].ID		= level.curAlertID++;
+	level.alertEvents[ level.numAlertEvents ].timestamp	= level.time;
+
+	level.numAlertEvents++;
+}
+
+/*
+-------------------------
+ClearPlayerAlertEvents
+-------------------------
+*/
+
+void ClearPlayerAlertEvents( void )
+{
+	int curNumAlerts = level.numAlertEvents;
+	//loop through them all (max 32)
+	for ( int i = 0; i < curNumAlerts; i++ )
+	{
+		//see if the event is old enough to delete
+		if ( level.alertEvents[i].timestamp && level.alertEvents[i].timestamp + ALERT_CLEAR_TIME < level.time )
+		{//this event has timed out
+			//drop the count
+			level.numAlertEvents--;
+			//shift the rest down
+			if ( level.numAlertEvents > 0 )
+			{//still have more in the array
+				if ( (i+1) < MAX_ALERT_EVENTS )
+				{
+					memmove( &level.alertEvents[i], &level.alertEvents[i+1], sizeof(alertEvent_t)*(MAX_ALERT_EVENTS-(i+1) ) );
+				}
+			}
+			else
+			{//just clear this one... or should we clear the whole array?
+				memset( &level.alertEvents[i], 0, sizeof( alertEvent_t ) );
+			}
+		}
+	}
+	//make sure this never drops below zero... if it does, something very very bad happened
+	assert( level.numAlertEvents >= 0 );
+
+	if ( eventClearTime < level.time )
+	{//this is just a 200ms debouncer so things that generate constant alerts (like corpses and missiles) add an alert every 200 ms
+		eventClearTime = level.time + ALERT_CLEAR_TIME;
+	}
+}
+
+qboolean RemoveOldestAlert( void )
+{
+	int	oldestEvent = -1, oldestTime = Q3_INFINITE;
+	//loop through them all (max 32)
+	for ( int i = 0; i < level.numAlertEvents; i++ )
+	{
+		//see if the event is old enough to delete
+		if ( level.alertEvents[i].timestamp < oldestTime )
+		{
+			oldestEvent = i;
+			oldestTime = level.alertEvents[i].timestamp;
+		}
+	}
+	if ( oldestEvent != -1 )
+	{
+		//drop the count
+		level.numAlertEvents--;
+		//shift the rest down
+		if ( level.numAlertEvents > 0 )
+		{//still have more in the array
+			if ( (oldestEvent+1) < MAX_ALERT_EVENTS )
+			{
+				memmove( &level.alertEvents[oldestEvent], &level.alertEvents[oldestEvent+1], sizeof(alertEvent_t)*(MAX_ALERT_EVENTS-(oldestEvent+1) ) );
+			}
+		}
+		else
+		{//just clear this one... or should we clear the whole array?
+			memset( &level.alertEvents[oldestEvent], 0, sizeof( alertEvent_t ) );
+		}
+	}
+	//make sure this never drops below zero... if it does, something very very bad happened
+	assert( level.numAlertEvents >= 0 );
+	//return true is have room for one now
+	return (level.numAlertEvents<MAX_ALERT_EVENTS);
+}
+
+/*
+-------------------------
+G_ClearLOS
+-------------------------
+*/
+
+// Position to position
+qboolean G_ClearLOS( gentity_t *self, const vec3_t start, const vec3_t end )
+{
+	trace_t		tr;
+	int			traceCount = 0;
+	
+	//FIXME: ENTITYNUM_NONE ok?
+	gi.trace ( &tr, start, NULL, NULL, end, ENTITYNUM_NONE, CONTENTS_OPAQUE/*CONTENTS_SOLID*//*(CONTENTS_SOLID|CONTENTS_MONSTERCLIP)*/ );
+	while ( tr.fraction < 1.0 && traceCount < 3 )
+	{//can see through 3 panes of glass
+		if ( tr.entityNum < ENTITYNUM_WORLD )
+		{
+			if ( &g_entities[tr.entityNum] != NULL && (g_entities[tr.entityNum].svFlags&SVF_GLASS_BRUSH) )
+			{//can see through glass, trace again, ignoring me
+				gi.trace ( &tr, tr.endpos, NULL, NULL, end, tr.entityNum, MASK_OPAQUE );
+				traceCount++;
+				continue;
+			}
+		}
+		return qfalse;
+	}
+
+	if ( tr.fraction == 1.0 ) 
+		return qtrue;
+
+	return qfalse;
+}
+
+//Entity to position
+qboolean G_ClearLOS( gentity_t *self, gentity_t *ent, const vec3_t end )
+{
+	vec3_t	eyes;
+
+	CalcEntitySpot( ent, SPOT_HEAD_LEAN, eyes );
+
+	return G_ClearLOS( self, eyes, end );
+}
+
+//Position to entity
+qboolean G_ClearLOS( gentity_t *self, const vec3_t start, gentity_t *ent )
+{
+	vec3_t		spot;
+
+	//Look for the chest first
+	CalcEntitySpot( ent, SPOT_ORIGIN, spot );
+
+	if ( G_ClearLOS( self, start, spot ) )
+		return qtrue;
+
+	//Look for the head next
+	CalcEntitySpot( ent, SPOT_HEAD_LEAN, spot );
+
+	if ( G_ClearLOS( self, start, spot ) )
+		return qtrue;
+
+	return qfalse;
+}
+
+//NPC's eyes to entity
+qboolean G_ClearLOS( gentity_t *self, gentity_t *ent ) 
+{
+	vec3_t	eyes;
+
+	//Calculate my position
+	CalcEntitySpot( self, SPOT_HEAD_LEAN, eyes );
+	
+	return G_ClearLOS( self, eyes, ent );
+}
+
+//NPC's eyes to position
+qboolean G_ClearLOS( gentity_t *self, const vec3_t end )
+{
+	vec3_t	eyes;
+
+	//Calculate the my position
+	CalcEntitySpot( self, SPOT_HEAD_LEAN, eyes );
+	
+	return G_ClearLOS( self, eyes, end );
+}
+
+/*
+-------------------------
+NPC_GetFOVPercentage
+-------------------------
+*/
+
+float NPC_GetHFOVPercentage( vec3_t spot, vec3_t from, vec3_t facing, float hFOV )
+{
+	vec3_t	deltaVector, angles;
+	float	delta;
+
+	VectorSubtract ( spot, from, deltaVector );
+
+	vectoangles ( deltaVector, angles );
+	
+	delta = fabs( AngleDelta ( facing[YAW], angles[YAW] ) );
+
+	if ( delta > hFOV )
+		return 0.0f; 
+
+	return ( ( hFOV - delta ) / hFOV );
+}
+
+/*
+-------------------------
+NPC_GetVFOVPercentage
+-------------------------
+*/
+
+float NPC_GetVFOVPercentage( vec3_t spot, vec3_t from, vec3_t facing, float vFOV )
+{
+	vec3_t	deltaVector, angles;
+	float	delta;
+
+	VectorSubtract ( spot, from, deltaVector );
+
+	vectoangles ( deltaVector, angles );
+	
+	delta = fabs( AngleDelta ( facing[PITCH], angles[PITCH] ) );
+
+	if ( delta > vFOV )
+		return 0.0f; 
+
+	return ( ( vFOV - delta ) / vFOV );
+}
+
+#define MAX_INTEREST_DIST	( 256 * 256 )
+/*
+-------------------------
+NPC_FindLocalInterestPoint 
+-------------------------
+*/
+
+int G_FindLocalInterestPoint( gentity_t *self )
+{
+	int		i, bestPoint = ENTITYNUM_NONE;
+	float	dist, bestDist = Q3_INFINITE;
+	vec3_t	diffVec, eyes;
+
+	CalcEntitySpot( self, SPOT_HEAD_LEAN, eyes );
+	for ( i = 0; i < level.numInterestPoints; i++ )
+	{
+		//Don't ignore portals?  If through a portal, need to look at portal!
+		if ( gi.inPVS( level.interestPoints[i].origin, eyes ) )
+		{
+			VectorSubtract( level.interestPoints[i].origin, eyes, diffVec );
+			if ( (fabs(diffVec[0]) + fabs(diffVec[1])) / 2 < 48 &&
+				fabs(diffVec[2]) > (fabs(diffVec[0]) + fabs(diffVec[1])) / 2 )
+			{//Too close to look so far up or down
+				continue;
+			}
+			dist = VectorLengthSquared( diffVec );
+			//Some priority to more interesting points
+			//dist -= ((int)level.interestPoints[i].lookMode * 5) * ((int)level.interestPoints[i].lookMode * 5);
+			if ( dist < MAX_INTEREST_DIST && dist < bestDist )
+			{
+				if ( G_ClearLineOfSight( eyes, level.interestPoints[i].origin, self->s.number, MASK_OPAQUE ) )
+				{
+					bestDist = dist;
+					bestPoint = i;
+				}
+			}
+		}
+	}
+	if ( bestPoint != ENTITYNUM_NONE && level.interestPoints[bestPoint].target )
+	{
+		G_UseTargets2( self, self, level.interestPoints[bestPoint].target );
+	}
+	return bestPoint;
+}
+
+/*QUAKED target_interest (1 0.8 0.5) (-4 -4 -4) (4 4 4)
+A point that a squadmate will look at if standing still
+
+target - thing to fire when someone looks at this thing
+*/
+
+void SP_target_interest( gentity_t *self )
+{//FIXME: rename point_interest
+	if(level.numInterestPoints >= MAX_INTEREST_POINTS)
+	{
+		gi.Printf("ERROR:  Too many interest points, limit is %d\n", MAX_INTEREST_POINTS);
+		G_FreeEntity(self);
+		return;
+	}
+
+	VectorCopy(self->currentOrigin, level.interestPoints[level.numInterestPoints].origin);
+
+	if(self->target && self->target[0])
+	{
+		level.interestPoints[level.numInterestPoints].target = G_NewString( self->target );
+	}
+
+	level.numInterestPoints++;
+
+	G_FreeEntity(self);
+}
diff --git a/code/game/NPC_sounds.cpp b/code/game/NPC_sounds.cpp
new file mode 100644
index 0000000..cb25924
--- /dev/null
+++ b/code/game/NPC_sounds.cpp
@@ -0,0 +1,118 @@
+//NPC_sounds.cpp
+
+// leave this line at the top for all NPC_xxxx.cpp files...
+#include "g_headers.h"
+
+
+
+
+#include "b_local.h"
+#include "Q3_Interface.h"
+
+/*
+void NPC_AngerSound (void)
+{
+	if(NPCInfo->investigateSoundDebounceTime)
+		return;
+
+	NPCInfo->investigateSoundDebounceTime = 1;
+
+//	switch((int)NPC->client->race)
+//	{
+//	case RACE_KLINGON:
+		//G_Sound(NPC, G_SoundIndex(va("sound/mgtest/klingon/talk%d.wav",	Q_irand(1, 4))));
+//		break;
+//	}
+}
+*/
+
+extern void G_SpeechEvent( gentity_t *self, int event );
+void G_AddVoiceEvent( gentity_t *self, int event, int speakDebounceTime )
+{
+	if ( !self->NPC )
+	{
+		return;
+	}
+
+	if ( !self->client || self->client->ps.pm_type >= PM_DEAD )
+	{
+		return;
+	}
+
+	if ( self->NPC->blockedSpeechDebounceTime > level.time )
+	{
+		return;
+	}
+
+	if ( Q3_TaskIDPending( self, TID_CHAN_VOICE ) )
+	{
+		return;
+	}
+
+	if ( self->client && self->client->NPC_class == CLASS_SABOTEUR )
+	{
+		if ( self->client->ps.powerups[PW_CLOAKED]
+			|| self->client->ps.powerups[PW_UNCLOAKING] > level.time )
+		{//I'm cloaked (or still decloaking), so don't talk and give away my position...
+			//don't make any combat voice noises, but still make pain and death sounds
+			if ( (event >= EV_ANGER1 && event <= EV_VICTORY3) 
+				|| (event >= EV_CHASE1 && event <= EV_SUSPICIOUS5) )
+			{
+				return;
+			}
+			
+			if ( event >= EV_GIVEUP1 && event <= EV_SUSPICIOUS5 )
+			{
+				return;
+			}
+		}
+	}	
+
+	if ( (self->NPC->scriptFlags&SCF_NO_COMBAT_TALK) && ( (event >= EV_ANGER1 && event <= EV_VICTORY3) || (event >= EV_CHASE1 && event <= EV_SUSPICIOUS5) ) )//(event < EV_FF_1A || event > EV_FF_3C) && (event < EV_RESPOND1 || event > EV_MISSION3) )
+	{
+		return;
+	}
+	
+	if ( (self->NPC->scriptFlags&SCF_NO_ALERT_TALK) && (event >= EV_GIVEUP1 && event <= EV_SUSPICIOUS5) )
+	{
+		return;
+	}
+	//FIXME: Also needs to check for teammates. Don't want
+	//		everyone babbling at once
+
+	//NOTE: was losing too many speech events, so we do it directly now, screw networking!
+	//G_AddEvent( self, event, 0 );
+	G_SpeechEvent( self, event );
+
+	//won't speak again for 5 seconds (unless otherwise specified)
+	self->NPC->blockedSpeechDebounceTime = level.time + ((speakDebounceTime==0) ? 5000 : speakDebounceTime);
+}
+
+void NPC_PlayConfusionSound( gentity_t *self )
+{
+	if ( self->health > 0 )
+	{
+		if ( self->enemy ||//was mad
+				!TIMER_Done( self, "enemyLastVisible" ) ||//saw something suspicious
+				self->client->renderInfo.lookTarget	== 0//was looking at player
+			)
+		{
+			self->NPC->blockedSpeechDebounceTime = 0;//make sure we say this
+			G_AddVoiceEvent( self, Q_irand( EV_CONFUSE2, EV_CONFUSE3 ), 2000 );
+		}
+		else if ( self->NPC && self->NPC->investigateDebounceTime+self->NPC->pauseTime > level.time )//was checking something out
+		{
+			self->NPC->blockedSpeechDebounceTime = 0;//make sure we say this
+			G_AddVoiceEvent( self, EV_CONFUSE1, 2000 );
+		}
+		//G_AddVoiceEvent( self, Q_irand(EV_CONFUSE1, EV_CONFUSE3), 2000 );
+	}
+	//reset him to be totally unaware again
+	TIMER_Set( self, "enemyLastVisible", 0 );
+	self->NPC->tempBehavior = BS_DEFAULT;
+	
+	//self->NPC->behaviorState = BS_PATROL;
+	G_ClearEnemy( self );//FIXME: or just self->enemy = NULL;?
+
+	self->NPC->investigateCount = 0;
+}
diff --git a/code/game/NPC_spawn.cpp b/code/game/NPC_spawn.cpp
new file mode 100644
index 0000000..91c0d55
--- /dev/null
+++ b/code/game/NPC_spawn.cpp
@@ -0,0 +1,4376 @@
+//b_spawn.cpp
+//added by MCG
+
+// leave this line at the top for all NPC_xxxx.cpp files...
+#include "g_headers.h"
+
+
+
+#include "Q3_Interface.h"
+#include "b_local.h"
+#include "anims.h"
+#include "g_functions.h"
+#include "wp_saber.h"
+#include "g_vehicles.h"
+
+extern qboolean G_CheckInSolid (gentity_t *self, qboolean fix);
+extern void ClientUserinfoChanged( int clientNum );
+extern qboolean SpotWouldTelefrag2( gentity_t *mover, vec3_t dest );
+extern void Jedi_Cloak( gentity_t *self );
+extern void Saboteur_Cloak( gentity_t *self );
+
+//extern void FX_BorgTeleport( vec3_t org );
+
+extern void G_MatchPlayerWeapon( gentity_t *ent );
+extern void Q3_SetParm (int entID, int parmNum, const char *parmValue);
+
+//extern void CG_ShimmeryThing_Spawner( vec3_t start, vec3_t end, float radius, qboolean taper, int duration );
+
+//extern void NPC_StasisSpawnEffect( gentity_t *ent );
+
+extern void PM_SetTorsoAnimTimer( gentity_t *ent, int *torsoAnimTimer, int time );
+extern void PM_SetLegsAnimTimer( gentity_t *ent, int *legsAnimTimer, int time );
+
+extern int WP_SaberInitBladeData( gentity_t *ent );
+extern void ST_ClearTimers( gentity_t *ent );
+extern void Jedi_ClearTimers( gentity_t *ent );
+extern void Howler_ClearTimers( gentity_t *self );
+#define	NSF_DROP_TO_FLOOR	16
+
+
+//void HirogenAlpha_Precache( void );
+
+/*
+-------------------------
+NPC_PainFunc
+-------------------------
+*/
+
+painFunc_t NPC_PainFunc( gentity_t *ent )
+{
+	painFunc_t	func;
+
+	if ( ent->client->ps.weapon == WP_SABER )
+	{
+		func = painF_NPC_Jedi_Pain;
+	}
+	else
+	{
+		// team no longer indicates race/species, use NPC_class to determine different npc types
+		/*
+		switch ( ent->client->playerTeam )
+		{
+		default:
+			func = painF_NPC_Pain;
+			break;
+		}
+		*/
+		switch( ent->client->NPC_class )
+		{
+		// troopers get special pain
+		case CLASS_SABOTEUR:
+		case CLASS_STORMTROOPER:
+		case CLASS_SWAMPTROOPER:
+		case CLASS_NOGHRI:
+			func = painF_NPC_ST_Pain;
+			break;
+
+		case CLASS_SEEKER:
+			func = painF_NPC_Seeker_Pain;
+			break;
+
+		case CLASS_REMOTE:
+			func = painF_NPC_Remote_Pain;
+			break;
+
+		case CLASS_MINEMONSTER:
+			func = painF_NPC_MineMonster_Pain;
+			break;
+
+		case CLASS_HOWLER:
+			func = painF_NPC_Howler_Pain;
+			break;
+
+		case CLASS_RANCOR:
+			func = painF_NPC_Rancor_Pain;
+			break;
+
+		case CLASS_WAMPA:
+			func = painF_NPC_Wampa_Pain;
+			break;
+
+		case CLASS_SAND_CREATURE:
+			func = painF_NPC_SandCreature_Pain;
+			break;
+
+		// all other droids, did I miss any?
+		case CLASS_GONK:
+		case CLASS_R2D2:
+		case CLASS_R5D2:
+		case CLASS_MOUSE:
+		case CLASS_PROTOCOL:
+		case CLASS_INTERROGATOR:
+			func = painF_NPC_Droid_Pain;
+			break;
+		case CLASS_PROBE:
+			func = painF_NPC_Probe_Pain;
+			break;
+
+		case CLASS_SENTRY:
+			func = painF_NPC_Sentry_Pain;
+			break;
+		case CLASS_MARK1:
+			func = painF_NPC_Mark1_Pain;
+			break;
+		case CLASS_MARK2:
+			func = painF_NPC_Mark2_Pain;
+			break;
+		case CLASS_ATST:  
+			func = painF_NPC_ATST_Pain;
+			break;
+		case CLASS_GALAKMECH:
+			func = painF_NPC_GM_Pain;
+			break;
+		// everyone else gets the normal pain func
+		default:
+			func = painF_NPC_Pain;
+			break;
+		}
+
+	}
+
+	return func;
+}
+
+
+/*
+-------------------------
+NPC_TouchFunc
+-------------------------
+*/
+
+touchFunc_t NPC_TouchFunc( gentity_t *ent )
+{
+	return touchF_NPC_Touch;
+}
+
+/*
+-------------------------
+NPC_SetMiscDefaultData
+-------------------------
+*/
+void G_ClassSetDontFlee( gentity_t *self )
+{
+	if ( !self || !self->client || !self->NPC )
+	{
+		return;
+	}
+	switch ( self->client->NPC_class )
+	{
+	case CLASS_ATST:
+	case CLASS_CLAW:
+	case CLASS_DESANN:
+	case CLASS_FISH:
+	case CLASS_FLIER2:
+	case CLASS_GALAK:
+	case CLASS_GLIDER:
+	case CLASS_RANCOR:
+	case CLASS_SAND_CREATURE:
+	case CLASS_INTERROGATOR:		// droid 
+	case CLASS_JAN:				
+	case CLASS_JEDI:				
+	case CLASS_KYLE:
+	case CLASS_LANDO:			
+	case CLASS_LIZARD:
+	case CLASS_LUKE:				
+	case CLASS_MARK1:			// droid
+	case CLASS_MARK2:			// droid
+	case CLASS_GALAKMECH:		// droid
+	case CLASS_MONMOTHA:			
+	case CLASS_MORGANKATARN:
+	case CLASS_MURJJ:
+	case CLASS_PROBE:			// droid
+	case CLASS_REBORN:
+	case CLASS_REELO:
+	case CLASS_REMOTE:
+	case CLASS_SEEKER:			// droid
+	case CLASS_SENTRY:
+	case CLASS_SHADOWTROOPER:
+	case CLASS_SWAMP:
+	case CLASS_TAVION:
+	case CLASS_ALORA:
+	case CLASS_BOBAFETT:
+	case CLASS_SABER_DROID:
+	case CLASS_ASSASSIN_DROID:
+	case CLASS_PLAYER:
+	case CLASS_VEHICLE:
+		self->NPC->scriptFlags |= SCF_DONT_FLEE;
+		break;
+	}
+	if ( (self->NPC->aiFlags&NPCAI_BOSS_CHARACTER) )
+	{
+		self->NPC->scriptFlags |= SCF_DONT_FLEE;
+	}
+	if ( (self->NPC->aiFlags&NPCAI_SUBBOSS_CHARACTER) )
+	{
+		self->NPC->scriptFlags |= SCF_DONT_FLEE;
+	}
+	if ( (self->NPC->aiFlags&NPCAI_ROSH) )
+	{
+		self->NPC->scriptFlags |= SCF_DONT_FLEE;
+	}
+	if ( (self->NPC->aiFlags&NPCAI_HEAL_ROSH) )
+	{
+		self->NPC->scriptFlags |= SCF_DONT_FLEE;
+	}
+}
+
+extern void	Vehicle_Register(gentity_t *ent);
+extern void RT_FlyStart( gentity_t *self );
+extern void SandCreature_ClearTimers( gentity_t *ent );
+void NPC_SetMiscDefaultData( gentity_t *ent )
+{
+	if ( ent->spawnflags & SFB_CINEMATIC )
+	{//if a cinematic guy, default us to wait bState
+		ent->NPC->behaviorState = BS_CINEMATIC;
+	}
+	if ( ent->client->NPC_class == CLASS_RANCOR )
+	{
+		if ( Q_stricmp( "mutant_rancor", ent->NPC_type ) == 0 )
+		{
+			ent->spawnflags |= 1;//just so I know it's a mutant rancor as opposed to a normal one
+			ent->NPC->aiFlags |= NPCAI_NAV_THROUGH_BREAKABLES;
+			ent->mass = 2000;
+		}
+		else
+		{
+			ent->NPC->aiFlags |= NPCAI_NAV_THROUGH_BREAKABLES;
+			ent->mass = 1000;
+		}
+		ent->flags |= FL_NO_KNOCKBACK;
+	}
+	else if ( ent->client->NPC_class == CLASS_SAND_CREATURE )
+	{//???
+		ent->clipmask = CONTENTS_SOLID|CONTENTS_MONSTERCLIP;//it can go through others
+		ent->contents = 0;//can't be hit?
+		ent->takedamage = qfalse;//can't be killed
+		ent->flags |= FL_NO_KNOCKBACK;
+		SandCreature_ClearTimers( ent );
+	}
+	else if ( ent->client->NPC_class == CLASS_BOBAFETT )
+	{//set some stuff, precache
+		ent->client->ps.forcePowersKnown |= ( 1 << FP_LEVITATION );
+		ent->client->ps.forcePowerLevel[FP_LEVITATION] = FORCE_LEVEL_3;
+		ent->client->ps.forcePower	= 100;
+		ent->NPC->scriptFlags		|= (SCF_NAV_CAN_FLY|SCF_FLY_WITH_JET|SCF_NAV_CAN_JUMP);
+		NPC->flags					|= FL_UNDYING;		// Can't Kill Boba
+	}
+	else if ( ent->client->NPC_class == CLASS_ROCKETTROOPER )
+	{//set some stuff, precache
+		ent->client->ps.forcePowersKnown |= ( 1 << FP_LEVITATION );
+		ent->client->ps.forcePowerLevel[FP_LEVITATION] = FORCE_LEVEL_3;
+		ent->client->ps.forcePower = 100;
+		ent->NPC->scriptFlags |= (SCF_NAV_CAN_FLY|SCF_FLY_WITH_JET|SCF_NAV_CAN_JUMP);//no groups, no combat points!
+		if ( Q_stricmp( "rockettrooper2Officer", ent->NPC_type ) == 0 )
+		{//start in the air, use spotlight
+			//ent->NPC->scriptFlags |= SCF_NO_GROUPS;
+			ent->NPC->scriptFlags &= ~SCF_FLY_WITH_JET;
+			RT_FlyStart( ent );
+			NPC_SetMoveGoal( ent, ent->currentOrigin, 16, qfalse, -1, NULL );
+			VectorCopy( ent->currentOrigin, ent->pos1 );
+		}
+		if ( (ent->spawnflags&2) )
+		{//spotlight
+			ent->client->ps.eFlags |= EF_SPOTLIGHT;
+		}
+	}
+	else if (ent->client->NPC_class == CLASS_SABER_DROID)
+	{
+		ent->flags |= FL_NO_KNOCKBACK;
+	}
+	else if ( ent->client->NPC_class == CLASS_SABOTEUR )
+	{//can cloak
+		ent->NPC->aiFlags |= NPCAI_SHIELDS;//give them the ability to cloak
+		if ( (ent->spawnflags&16) )
+		{//start cloaked
+			Saboteur_Cloak( ent );
+		}
+	}
+	else if ( ent->client->NPC_class == CLASS_ASSASSIN_DROID )
+	{
+		ent->client->ps.stats[STAT_ARMOR] = 250;	// start with full armor
+		if (ent->s.weapon==WP_BLASTER)
+		{
+			ent->NPC->scriptFlags |= SCF_ALT_FIRE;
+		}
+		ent->flags |= (FL_NO_KNOCKBACK);
+	}
+
+	if (ent->spawnflags&4096)
+	{
+		ent->NPC->scriptFlags |= SCF_NO_GROUPS;//don't use combat points or group AI
+	}
+
+	if ( Q_stricmp( "DKothos", ent->NPC_type ) == 0
+		|| Q_stricmp( "VKothos", ent->NPC_type ) == 0 )
+	{
+		ent->NPC->scriptFlags |= SCF_DONT_FIRE;
+		ent->NPC->aiFlags |= NPCAI_HEAL_ROSH;
+		ent->count = 100;
+	}
+	else if ( Q_stricmp( "rosh_dark", ent->NPC_type ) == 0 )
+	{
+		ent->NPC->aiFlags |= NPCAI_ROSH;
+	}
+
+	if ( Q_stricmpn( ent->NPC_type, "hazardtrooper", 13 ) == 0 )
+	{//hazard trooper
+		ent->NPC->scriptFlags |= SCF_NO_GROUPS;//don't use combat points or group AI
+		ent->flags |= (FL_SHIELDED|FL_NO_KNOCKBACK);//low-level shots bounce off, no knockback
+	}
+	if ( !Q_stricmp( "Yoda", ent->NPC_type ) )
+	{//FIXME: extern this into NPC.cfg?
+		ent->NPC->scriptFlags |= SCF_NO_FORCE;//force powers don't work on him
+		ent->NPC->aiFlags |= NPCAI_BOSS_CHARACTER;
+	}
+	if ( !Q_stricmp( "emperor", ent->NPC_type ) 
+		|| !Q_stricmp( "cultist_grip", ent->NPC_type )
+		|| !Q_stricmp( "cultist_drain", ent->NPC_type )
+		|| !Q_stricmp( "cultist_lightning", ent->NPC_type ))
+	{//FIXME: extern this into NPC.cfg?
+		ent->NPC->scriptFlags |= SCF_DONT_FIRE;//so he uses only force powers
+	}
+	if (!Q_stricmp( "Rax", ent->NPC_type ) )
+	{
+		ent->NPC->scriptFlags |= SCF_DONT_FLEE;
+	}
+	if ( !Q_stricmp( "cultist_destroyer", ent->NPC_type ) )
+	{
+		ent->splashDamage = 1000;
+		ent->splashRadius = 384;
+		//FIXME: precache these!
+		ent->fxID = G_EffectIndex( "force/destruction_exp" );
+		ent->NPC->scriptFlags |= (SCF_DONT_FLEE|SCF_IGNORE_ALERTS);
+		ent->NPC->ignorePain = qtrue;
+	}
+	if ( Q_stricmp( "chewie", ent->NPC_type ) )
+	{
+		//in case chewie ever loses his gun...
+		ent->NPC->aiFlags |= NPCAI_HEAVY_MELEE;
+	}
+	//==================
+	if ( ent->client->ps.saber[0].type != SABER_NONE 
+		&& (!(ent->NPC->aiFlags&NPCAI_MATCHPLAYERWEAPON)||!ent->weaponModel[0]) )
+	{//if I'm equipped with a saber, initialize it (them)
+		ent->client->ps.SaberDeactivate();
+		ent->client->ps.SetSaberLength( 0 );
+		WP_SaberInitBladeData( ent );
+		if ( ent->client->ps.weapon == WP_SABER )
+		{//this is our current weapon, add the models now
+			WP_SaberAddG2SaberModels( ent );
+		}
+		Jedi_ClearTimers( ent );
+	}
+	if ( ent->client->ps.forcePowersKnown != 0 )
+	{
+		WP_InitForcePowers( ent );
+		if (ent->client->ps.forcePowerLevel[FP_LEVITATION] > FORCE_LEVEL_0)
+		{
+			ent->NPC->scriptFlags |= SCF_NAV_CAN_JUMP;	// anyone who has any force jump can jump
+		}
+	}
+	if ( ent->client->NPC_class == CLASS_HOWLER )
+	{
+		Howler_ClearTimers( ent );
+		ent->NPC->scriptFlags |= SCF_NO_FALLTODEATH;
+		ent->flags |= FL_NO_IMPACT_DMG;
+		ent->NPC->scriptFlags |= SCF_NAV_CAN_JUMP;	// These jokers can jump
+	}
+	if ( ent->client->NPC_class == CLASS_DESANN
+		|| ent->client->NPC_class == CLASS_TAVION
+		|| ent->client->NPC_class == CLASS_LUKE
+		|| ent->client->NPC_class == CLASS_KYLE
+		|| Q_stricmp("tavion_scepter", ent->NPC_type ) == 0 
+		|| Q_stricmp("alora_dual", ent->NPC_type ) == 0 )
+	{
+		ent->NPC->aiFlags |= NPCAI_BOSS_CHARACTER;
+	}
+	else if ( Q_stricmp( "alora", ent->NPC_type ) == 0
+		|| Q_stricmp( "rosh_dark", ent->NPC_type ) == 0 )
+	{
+		ent->NPC->aiFlags |= NPCAI_SUBBOSS_CHARACTER;
+	}
+	if ( ent->client->NPC_class == CLASS_TUSKEN )
+	{
+		if ( g_spskill->integer > 1 )
+		{//on hard, tusken raiders are faster than you
+			ent->NPC->stats.runSpeed = 280;
+			ent->NPC->stats.walkSpeed = 65;
+		}
+	}
+	//***I'm not sure whether I should leave this as a TEAM_ switch, I think NPC_class may be more appropriate - dmv
+	switch(ent->client->playerTeam)
+	{
+	case TEAM_PLAYER:
+		//ent->flags |= FL_NO_KNOCKBACK;
+		if ( ent->client->NPC_class == CLASS_SEEKER )
+		{		
+			ent->NPC->defaultBehavior = BS_DEFAULT;
+			ent->client->ps.gravity = 0;
+			ent->svFlags |= SVF_CUSTOM_GRAVITY;
+			ent->client->moveType = MT_FLYSWIM;
+			ent->count = 30; // SEEKER shot ammo count
+			return;
+		}
+		else if ( ent->client->NPC_class == CLASS_JEDI 
+			|| ent->client->NPC_class == CLASS_KYLE
+			|| ent->client->NPC_class == CLASS_LUKE )
+		{//good jedi
+			ent->client->enemyTeam = TEAM_ENEMY;
+			if ( ent->spawnflags & JSF_AMBUSH )
+			{//ambusher
+				ent->NPC->scriptFlags |= SCF_IGNORE_ALERTS;
+				ent->client->noclip = true;//hang
+			}
+		}
+		else
+		{
+			if (ent->client->ps.weapon != WP_NONE
+				&& ent->client->ps.weapon != WP_SABER //sabers done above
+				&& (!(ent->NPC->aiFlags&NPCAI_MATCHPLAYERWEAPON)||!ent->weaponModel[0]) )//they do this themselves
+			{
+				G_CreateG2AttachedWeaponModel( ent, weaponData[ent->client->ps.weapon].weaponMdl, ent->handRBolt, 0 );
+			}
+			switch ( ent->client->ps.weapon )
+			{
+			case WP_BRYAR_PISTOL://FIXME: new weapon: imp blaster pistol
+			case WP_BLASTER_PISTOL:
+			case WP_DISRUPTOR:
+			case WP_BOWCASTER:
+			case WP_REPEATER:
+			case WP_DEMP2:
+			case WP_FLECHETTE:
+			case WP_ROCKET_LAUNCHER:
+			case WP_CONCUSSION:
+			default:
+				break;
+			case WP_THERMAL:
+			case WP_BLASTER:
+				//FIXME: health in NPCs.cfg, and not all blaster users are stormtroopers
+				//ent->health = 25;
+				//FIXME: not necc. a ST
+				ST_ClearTimers( ent );
+				if ( ent->NPC->rank >= RANK_LT || ent->client->ps.weapon == WP_THERMAL )
+				{//officers, grenade-throwers use alt-fire
+					//ent->health = 50;
+					//ent->NPC->scriptFlags |= SCF_ALT_FIRE;
+				}
+				break;
+			}
+		}
+		if ( ent->client->NPC_class == CLASS_PLAYER 
+			|| ent->client->NPC_class == CLASS_VEHICLE 
+			|| (ent->spawnflags & SFB_CINEMATIC) )
+		{
+			ent->NPC->defaultBehavior = BS_CINEMATIC;
+		}
+		else
+		{
+			ent->NPC->defaultBehavior = BS_FOLLOW_LEADER;
+			ent->client->leader = &g_entities[0];//player
+		}
+		break;
+
+	case TEAM_NEUTRAL: 
+
+		if ( Q_stricmp( ent->NPC_type, "gonk" ) == 0 ) 
+		{
+			// I guess we generically make them player usable
+			ent->svFlags |= SVF_PLAYER_USABLE;
+
+			// Not even sure if we want to give different levels of batteries?  ...Or even that these are the values we'd want to use.
+			switch ( g_spskill->integer )
+			{
+			case 0:	//	EASY
+				ent->client->ps.batteryCharge = MAX_BATTERIES * 0.8f; 
+				break;
+			case 1:	//	MEDIUM
+				ent->client->ps.batteryCharge = MAX_BATTERIES * 0.75f; 
+				break;
+			default :
+			case 2:	//	HARD
+				ent->client->ps.batteryCharge = MAX_BATTERIES * 0.5f; 
+				break;
+			}
+		}
+		break;
+
+	case TEAM_ENEMY:
+		{
+			ent->NPC->defaultBehavior = BS_DEFAULT;
+			if ( ent->client->NPC_class == CLASS_SHADOWTROOPER
+				&& Q_stricmpn("shadowtrooper", ent->NPC_type, 13 ) == 0 )
+			{//FIXME: a spawnflag?
+				Jedi_Cloak( ent );
+			}
+		 	if( ent->client->NPC_class == CLASS_TAVION ||
+				ent->client->NPC_class == CLASS_ALORA ||
+				(ent->client->NPC_class == CLASS_REBORN && ent->client->ps.weapon == WP_SABER) ||
+				ent->client->NPC_class == CLASS_DESANN ||
+				ent->client->NPC_class == CLASS_SHADOWTROOPER )
+			{
+				ent->client->enemyTeam = TEAM_PLAYER;
+				if ( ent->spawnflags & JSF_AMBUSH )
+				{//ambusher
+					ent->NPC->scriptFlags |= SCF_IGNORE_ALERTS;
+					ent->client->noclip = true;//hang
+				}
+			}
+			else if( ent->client->NPC_class == CLASS_PROBE || ent->client->NPC_class == CLASS_REMOTE ||
+						ent->client->NPC_class == CLASS_INTERROGATOR || ent->client->NPC_class == CLASS_SENTRY)
+			{		
+				ent->NPC->defaultBehavior = BS_DEFAULT;
+				ent->client->ps.gravity = 0;
+				ent->svFlags |= SVF_CUSTOM_GRAVITY;
+				ent->client->moveType = MT_FLYSWIM;
+			}
+			else 
+			{
+				if ( ent->client->ps.weapon != WP_NONE
+					&& ent->client->ps.weapon != WP_SABER//sabers done above
+					&& (!(ent->NPC->aiFlags&NPCAI_MATCHPLAYERWEAPON)||!ent->weaponModel[0]) )//they do this themselves
+				{
+					G_CreateG2AttachedWeaponModel( ent, weaponData[ent->client->ps.weapon].weaponMdl, ent->handRBolt, 0 );
+				}
+				switch ( ent->client->ps.weapon )
+				{
+				case WP_BRYAR_PISTOL:
+					break;
+				case WP_BLASTER_PISTOL:
+					NPCInfo->scriptFlags |= SCF_PILOT;
+					if ( ent->client->NPC_class == CLASS_REBORN
+						&& ent->NPC->rank >= RANK_LT_COMM
+						&& (!(ent->NPC->aiFlags&NPCAI_MATCHPLAYERWEAPON)||!ent->weaponModel[0]) )//they do this themselves
+					{//dual blaster pistols, so add the left-hand one, too
+						G_CreateG2AttachedWeaponModel( ent, weaponData[ent->client->ps.weapon].weaponMdl, ent->handLBolt, 1 );
+					}
+					break;
+				case WP_DISRUPTOR:
+					//Sniper
+					//ent->NPC->scriptFlags |= SCF_ALT_FIRE;//FIXME: use primary fire sometimes?  Up close?  Different class of NPC?
+					break;
+				case WP_BOWCASTER:
+					NPCInfo->scriptFlags |= SCF_PILOT;
+					break;
+				case WP_REPEATER:
+					NPCInfo->scriptFlags |= SCF_PILOT;
+					//machine-gunner
+					break;
+				case WP_DEMP2:
+					break;
+				case WP_FLECHETTE:
+					NPCInfo->scriptFlags |= SCF_PILOT;
+					//shotgunner
+					if ( !Q_stricmp( "stofficeralt", ent->NPC_type ) )
+					{
+						//ent->NPC->scriptFlags |= SCF_ALT_FIRE;
+					}
+					break;
+				case WP_ROCKET_LAUNCHER:
+					break;
+				case WP_CONCUSSION:
+					break;
+				case WP_THERMAL:
+					//Gran, use main, bouncy fire
+//					ent->NPC->scriptFlags |= SCF_ALT_FIRE;
+					break;
+				case WP_MELEE:
+					break;
+				case WP_NOGHRI_STICK:
+					break;
+				default:
+				case WP_BLASTER:
+					//FIXME: health in NPCs.cfg, and not all blaster users are stormtroopers
+					//FIXME: not necc. a ST
+					NPCInfo->scriptFlags |= SCF_PILOT;
+
+					ST_ClearTimers( ent );
+					if ( ent->NPC->rank >= RANK_COMMANDER )
+					{//commanders use alt-fire
+						//ent->NPC->scriptFlags |= SCF_ALT_FIRE;
+					}
+					if ( !Q_stricmp( "rodian2", ent->NPC_type ) )
+					{
+						//ent->NPC->scriptFlags |= SCF_ALT_FIRE;
+					}
+					break;
+				}
+			}
+		}
+		break;
+
+	default:
+		ent->NPC->defaultBehavior = BS_DEFAULT;
+		if ( ent->client->ps.weapon != WP_NONE 
+			&& ent->client->ps.weapon != WP_MELEE 
+			&& ent->client->ps.weapon != WP_SABER//sabers done above
+			&& (!(ent->NPC->aiFlags&NPCAI_MATCHPLAYERWEAPON)||!ent->weaponModel[0]) )//they do this themselves
+		{
+			G_CreateG2AttachedWeaponModel( ent, weaponData[ent->client->ps.weapon].weaponMdl, ent->handRBolt, 0 );
+		}
+		break;
+	}
+
+
+	if ( ent->client->NPC_class == CLASS_ATST || ent->client->NPC_class == CLASS_MARK1 ) // chris/steve/kevin requested that the mark1 be shielded also
+	{
+		ent->flags |= (FL_SHIELDED|FL_NO_KNOCKBACK);
+	}
+
+	// Set CAN FLY Flag for Navigation On The Following Classes
+	//----------------------------------------------------------
+	if (ent->client->NPC_class==CLASS_PROBE ||
+		ent->client->NPC_class==CLASS_REMOTE ||
+		ent->client->NPC_class==CLASS_SEEKER ||
+		ent->client->NPC_class==CLASS_SENTRY ||
+		ent->client->NPC_class==CLASS_GLIDER ||
+		ent->client->NPC_class==CLASS_IMPWORKER ||
+		ent->client->NPC_class==CLASS_BOBAFETT ||
+		ent->client->NPC_class==CLASS_ROCKETTROOPER 
+		)
+	{
+		ent->NPC->scriptFlags |= SCF_NAV_CAN_FLY;
+	}
+
+	if (ent->client->NPC_class==CLASS_VEHICLE)
+	{
+		Vehicle_Register(ent);
+	}
+
+	if ( ent->client->ps.stats[STAT_WEAPONS]&(1<<WP_SCEPTER) )
+	{
+		if ( !ent->weaponModel[1] )
+		{//we have the scepter, so put it in our left hand if we don't already have a second weapon
+			G_CreateG2AttachedWeaponModel( ent, weaponData[WP_SCEPTER].weaponMdl, ent->handLBolt, 1 );
+		}
+		ent->genericBolt1 = gi.G2API_AddBolt(&ent->ghoul2[ent->weaponModel[1]], "*flash");
+	}
+
+	if ( ent->client->ps.saber[0].type == SABER_SITH_SWORD )
+	{
+		ent->genericBolt1 = gi.G2API_AddBolt(&ent->ghoul2[ent->weaponModel[0]], "*flash");
+		G_PlayEffect( G_EffectIndex( "scepter/sword.efx" ), ent->weaponModel[0], ent->genericBolt1, ent->s.number, ent->currentOrigin, qtrue, qtrue );
+		//how many times can she recharge?
+		ent->count = g_spskill->integer*2;
+		//To make sure she can do it at least once
+		ent->flags |= FL_UNDYING;
+	}
+
+	if ( ent->client->ps.weapon == WP_NOGHRI_STICK 
+		&& ent->weaponModel[0] )
+	{
+		ent->genericBolt1 = gi.G2API_AddBolt(&ent->ghoul2[ent->weaponModel[0]], "*flash");
+	}
+
+	G_ClassSetDontFlee( ent );
+}
+
+/*
+-------------------------
+NPC_WeaponsForTeam
+-------------------------
+*/
+
+int NPC_WeaponsForTeam( team_t team, int spawnflags, const char *NPC_type )
+{
+	//*** not sure how to handle this, should I pass in class instead of team and go from there? - dmv
+	switch(team)
+	{
+	// no longer exists
+//	case TEAM_BORG:
+//		break;
+
+//	case TEAM_HIROGEN:
+//		if( Q_stricmp( "hirogenalpha", NPC_type ) == 0 )
+//			return ( 1 << WP_BLASTER);
+		//Falls through
+
+//	case TEAM_KLINGON:
+
+		//NOTENOTE: Falls through
+
+//	case TEAM_IMPERIAL:
+	case TEAM_ENEMY:
+		if ( Q_stricmp( "tavion", NPC_type ) == 0 || 
+			Q_stricmpn( "reborn", NPC_type, 6 ) == 0 || 
+			Q_stricmp( "desann", NPC_type ) == 0 || 
+			Q_stricmpn( "shadowtrooper", NPC_type, 13 ) == 0 )
+			return ( 1 << WP_SABER);
+//			return ( 1 << WP_IMPERIAL_BLADE);
+		//NOTENOTE: Falls through if not a knife user
+
+//	case TEAM_SCAVENGERS:
+//	case TEAM_MALON:
+		//FIXME: default weapon in npc config?
+		if ( Q_stricmpn( "stofficer", NPC_type, 9 ) == 0 )
+		{
+			return ( 1 << WP_FLECHETTE);
+		}
+		if ( Q_stricmp( "stcommander", NPC_type ) == 0 )
+		{
+			return ( 1 << WP_REPEATER);
+		}
+		if ( Q_stricmp( "swamptrooper", NPC_type ) == 0 )
+		{
+			return ( 1 << WP_FLECHETTE);
+		}
+		if ( Q_stricmp( "swamptrooper2", NPC_type ) == 0 )
+		{
+			return ( 1 << WP_REPEATER);
+		}
+		if ( Q_stricmp( "rockettrooper", NPC_type ) == 0 )
+		{
+			return ( 1 << WP_ROCKET_LAUNCHER);
+		}
+		if ( Q_stricmpn( "shadowtrooper", NPC_type, 13 ) == 0 )
+		{
+			return ( 1 << WP_SABER);//|( 1 << WP_RAPID_CONCUSSION)?
+		}
+		if ( Q_stricmp( "imperial", NPC_type ) == 0 )
+		{
+			return ( 1 << WP_BLASTER_PISTOL);
+		}
+		if ( Q_stricmpn( "impworker", NPC_type, 9 ) == 0 )
+		{
+			return ( 1 << WP_BLASTER_PISTOL);
+		}
+		if ( Q_stricmp( "stormpilot", NPC_type ) == 0 )
+		{
+			return ( 1 << WP_BLASTER_PISTOL);
+		}
+		if ( Q_stricmp( "galak", NPC_type ) == 0 )
+		{
+			return ( 1 << WP_BLASTER);
+		}
+		if ( Q_stricmp( "galak_mech", NPC_type ) == 0 )
+		{
+			return ( 1 << WP_REPEATER);
+		}
+		if ( Q_stricmpn( "ugnaught", NPC_type, 8 ) == 0 )
+		{
+			return WP_NONE;
+		}
+		if ( Q_stricmp( "granshooter", NPC_type ) == 0 )
+		{
+			return ( 1 << WP_BLASTER);
+		}
+		if ( Q_stricmp( "granboxer", NPC_type ) == 0 )
+		{
+			return ( 1 << WP_MELEE);
+		}
+		if ( Q_stricmpn( "gran", NPC_type, 4 ) == 0 )
+		{
+			return (( 1 << WP_THERMAL)|( 1 << WP_MELEE));
+		}
+		if ( Q_stricmp( "rodian", NPC_type ) == 0 )
+		{
+			return ( 1 << WP_DISRUPTOR);
+		}
+		if ( Q_stricmp( "rodian2", NPC_type ) == 0 )
+		{
+			return ( 1 << WP_BLASTER);
+		}
+
+		if (( Q_stricmp( "interrogator",NPC_type) == 0) || ( Q_stricmp( "sentry",NPC_type) == 0) || (Q_stricmpn( "protocol",NPC_type,8) == 0) )
+		{
+			return WP_NONE;
+		}
+
+		if ( Q_stricmpn( "weequay", NPC_type, 7 ) == 0 )
+		{
+			return ( 1 << WP_BOWCASTER);//|( 1 << WP_STAFF )(FIXME: new weap?)
+		}
+		if ( Q_stricmp( "impofficer", NPC_type ) == 0 )
+		{
+			return ( 1 << WP_BLASTER);
+		}
+		if ( Q_stricmp( "impcommander", NPC_type ) == 0 )
+		{
+			return ( 1 << WP_BLASTER);
+		}
+		if (( Q_stricmp( "probe", NPC_type ) == 0 ) || ( Q_stricmp( "seeker", NPC_type ) == 0 ))
+		{
+			return ( 1 << WP_BOT_LASER);
+		}	
+		if ( Q_stricmpn( "remote", NPC_type, 6 ) == 0 )
+		{
+			return ( 1 << WP_BOT_LASER );
+		}	
+		if ( Q_stricmp( "trandoshan", NPC_type ) == 0 )
+		{
+			return (1<<WP_REPEATER);
+		}
+		if ( Q_stricmp( "atst", NPC_type ) == 0 )
+		{
+			return (( 1 << WP_ATST_MAIN)|( 1 << WP_ATST_SIDE));
+		}
+		if ( Q_stricmp( "mark1", NPC_type ) == 0 )
+		{
+			return ( 1 << WP_BOT_LASER);
+		}
+		if ( Q_stricmp( "mark2", NPC_type ) == 0 )
+		{
+			return ( 1 << WP_BOT_LASER);
+		}
+		if ( Q_stricmp( "minemonster", NPC_type ) == 0 )
+		{
+			return (( 1 << WP_MELEE));
+		}
+		if ( Q_stricmp( "howler", NPC_type ) == 0 )
+		{
+			return (( 1 << WP_MELEE));
+		}
+		//Stormtroopers, etc.
+		return ( 1 << WP_BLASTER);
+		break;
+
+	case TEAM_PLAYER:
+		
+//		if(spawnflags & SFB_TRICORDER)
+//			return ( 1 << WP_TRICORDER);
+		
+		if(spawnflags & SFB_RIFLEMAN)
+			return ( 1 << WP_REPEATER);
+		
+		if(spawnflags & SFB_PHASER)
+			return ( 1 << WP_BLASTER_PISTOL);
+
+		if ( Q_stricmpn( "jedi", NPC_type, 4 ) == 0 || Q_stricmp( "luke", NPC_type ) == 0 )
+			return ( 1 << WP_SABER);
+
+		if ( Q_stricmpn( "prisoner", NPC_type, 8 ) == 0 
+			|| Q_stricmpn( "elder", NPC_type, 5 ) == 0 )
+		{
+			return WP_NONE;
+		}
+
+		if ( Q_stricmpn( "bespincop", NPC_type, 9 ) == 0 )
+		{
+			return ( 1 << WP_BLASTER_PISTOL);
+		}
+
+		if ( Q_stricmp( "MonMothma", NPC_type ) == 0 )
+		{
+			return WP_NONE;
+		}
+
+		//rebel
+		return ( 1 << WP_BLASTER);
+		break;
+
+	case TEAM_NEUTRAL:
+
+		if ( Q_stricmp( "mark1", NPC_type ) == 0 )
+		{
+			return WP_NONE;
+		}	
+		if ( Q_stricmp( "mark2", NPC_type ) == 0 )
+		{
+			return WP_NONE;
+		}	
+		if ( Q_stricmpn( "ugnaught", NPC_type, 8 ) == 0 )
+		{
+			return WP_NONE;
+		}	
+		if ( Q_stricmp( "bartender", NPC_type ) == 0 )
+		{
+			return WP_NONE;
+		}
+		if ( Q_stricmp( "morgankatarn", NPC_type ) == 0 )
+		{
+			return WP_NONE;
+		}
+	
+		break;
+
+	// these no longer exist
+//	case TEAM_FORGE:
+//		return ( 1 << WP_MELEE);
+//		break;
+
+//	case TEAM_STASIS:
+//		return ( 1 << WP_MELEE);
+//		break;
+
+//	case TEAM_PARASITE:
+//		break;
+
+//	case TEAM_8472:
+//		break;
+
+	default:
+		break;
+	}
+
+	return WP_NONE;
+}
+
+extern void ChangeWeapon( gentity_t *ent, int newWeapon );
+
+/*
+-------------------------
+NPC_SetWeapons
+-------------------------
+*/
+
+void NPC_SetWeapons( gentity_t *ent )
+{
+	int			bestWeap = WP_NONE;
+	int			weapons = NPC_WeaponsForTeam( ent->client->playerTeam, ent->spawnflags, ent->NPC_type );
+
+	ent->client->ps.stats[STAT_WEAPONS] = 0;
+	for ( int curWeap = WP_SABER; curWeap < WP_NUM_WEAPONS; curWeap++ )
+	{
+		if ( (weapons & ( 1 << curWeap )) )
+		{
+			ent->client->ps.stats[STAT_WEAPONS] |= ( 1 << curWeap );
+			RegisterItem( FindItemForWeapon( (weapon_t)(curWeap) ) );	//precache the weapon
+			ent->NPC->currentAmmo = ent->client->ps.ammo[weaponData[curWeap].ammoIndex] = 100;//FIXME: max ammo
+
+			if ( bestWeap == WP_SABER )
+			{
+				// still want to register other weapons -- force saber to be best weap
+				continue;
+			}
+
+			if ( curWeap == WP_MELEE )
+			{
+				if ( bestWeap == WP_NONE )
+				{// We'll only consider giving Melee since we haven't found anything better yet.
+					bestWeap = curWeap;
+				}
+			}
+			else if ( curWeap > bestWeap || bestWeap == WP_MELEE )
+			{
+				// This will never override saber as best weap.  Also will override WP_MELEE if something better comes later in the list
+				bestWeap = curWeap;
+			}
+		}
+	}
+
+	ent->client->ps.weapon = bestWeap;
+}
+
+/*
+-------------------------
+NPC_SpawnEffect
+
+  NOTE:  Make sure any effects called here have their models, tga's and sounds precached in
+			CG_RegisterNPCEffects in cg_player.cpp
+-------------------------
+*/
+
+static void NPC_SpawnEffect (gentity_t *ent)
+{
+}
+
+//--------------------------------------------------------------
+// NPC_SetFX_SpawnStates
+//
+// Set up any special parms for spawn effects
+//--------------------------------------------------------------
+void NPC_SetFX_SpawnStates( gentity_t *ent )
+{
+	ent->client->ps.gravity = g_gravity->value;
+}
+
+//--------------------------------------------------------------
+extern qboolean	stop_icarus;
+void NPC_Begin (gentity_t *ent)
+{
+	vec3_t	spawn_origin, spawn_angles;
+	gclient_t	*client;
+	usercmd_t	ucmd;
+	gentity_t	*spawnPoint = NULL;
+
+	memset( &ucmd, 0, sizeof( ucmd ) );
+
+	if ( !(ent->spawnflags & SFB_NOTSOLID) )
+	{//No NPCs should telefrag
+		if ( Q_stricmp( ent->NPC_type, "nullDriver") == 0 )
+		{//FIXME: should be a better way to check this
+		}
+		else if( SpotWouldTelefrag( ent, TEAM_FREE ) )//(team_t)(ent->client->playerTeam)
+		{
+			if ( ent->wait < 0 )
+			{//remove yourself
+				Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "NPC %s could not spawn, firing target3 (%s) and removing self\n", ent->targetname, ent->target3 );
+				//Fire off our target3
+				G_UseTargets2( ent, ent, ent->target3 );
+
+				//Kill us
+				ent->e_ThinkFunc = thinkF_G_FreeEntity;
+				ent->nextthink = level.time + 100;
+			}
+			else
+			{
+				Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "NPC %s at (%5.0f %5.0f %5.0f) couldn't spawn, waiting %4.2f secs to try again\n",
+					ent->targetname, ent->s.origin[0], ent->s.origin[1], ent->s.origin[2], ent->wait/1000.0f );
+				ent->e_ThinkFunc = thinkF_NPC_Begin;
+				ent->nextthink = level.time + ent->wait;//try again in half a second
+			}
+			return;
+		}
+	}
+	//Spawn effect
+	NPC_SpawnEffect( ent );
+
+	VectorCopy( ent->client->ps.origin, spawn_origin);
+	VectorCopy( ent->s.angles, spawn_angles);
+	spawn_angles[YAW] = ent->NPC->desiredYaw;
+
+	client = ent->client;
+
+	// increment the spawncount so the client will detect the respawn
+	client->ps.persistant[PERS_SPAWN_COUNT]++;
+
+	client->airOutTime = level.time + 12000;
+
+	client->ps.clientNum = ent->s.number;
+	// clear entity values
+
+	if ( ent->health )	// Was health supplied in map
+	{
+		ent->max_health = client->pers.maxHealth = client->ps.stats[STAT_MAX_HEALTH] = ent->health;
+	}
+	else if ( ent->NPC->stats.health )	// Was health supplied in NPC.cfg?
+	{
+		
+		if ( ent->client->NPC_class != CLASS_REBORN
+			&& ent->client->NPC_class != CLASS_SHADOWTROOPER 
+			//&& ent->client->NPC_class != CLASS_TAVION
+			//&& ent->client->NPC_class != CLASS_DESANN 
+			&& ent->client->NPC_class != CLASS_JEDI )
+		{// up everyone except jedi
+			if ( !Q_stricmp("tavion_sith_sword", ent->NPC_type )
+				|| !Q_stricmp("tavion_scepter", ent->NPC_type )
+				|| !Q_stricmp("kyle_boss", ent->NPC_type )
+				|| !Q_stricmp("alora_dual", ent->NPC_type )
+				|| !Q_stricmp("alora_boss", ent->NPC_type ) )
+			{//bosses are a bit different
+				ent->NPC->stats.health = ceil((float)ent->NPC->stats.health*0.75f + ((float)ent->NPC->stats.health/4.0f*g_spskill->value)); // 75% on easy, 100% on medium, 125% on hard
+			}
+			else
+			{
+				ent->NPC->stats.health += ent->NPC->stats.health/4 * g_spskill->integer; // 100% on easy, 125% on medium, 150% on hard
+			}
+		}
+		
+		ent->max_health = client->pers.maxHealth = client->ps.stats[STAT_MAX_HEALTH] = ent->NPC->stats.health;
+	}
+	else
+	{
+		ent->max_health = client->pers.maxHealth = client->ps.stats[STAT_MAX_HEALTH] = 100;
+	}
+
+	if ( !Q_stricmp( "rodian", ent->NPC_type ) )
+	{//sniper
+		//NOTE: this will get overridden by any aim settings in their spawnscripts
+		switch ( g_spskill->integer )
+		{
+		case 0:
+			ent->NPC->stats.aim = 1;
+			break;
+		case 1:
+			ent->NPC->stats.aim = Q_irand( 2, 3 );
+			break;
+		case 2:
+			ent->NPC->stats.aim = Q_irand( 3, 4 );
+			break;
+		}
+	}
+	else if ( ent->client->NPC_class == CLASS_STORMTROOPER
+		|| ent->client->NPC_class == CLASS_SWAMPTROOPER
+		|| ent->client->NPC_class == CLASS_IMPWORKER
+		|| !Q_stricmp( "rodian2", ent->NPC_type ) )
+	{//tweak yawspeed for these NPCs based on difficulty
+		switch ( g_spskill->integer )
+		{
+		case 0:
+			ent->NPC->stats.yawSpeed *= 0.75f;
+			if ( ent->client->NPC_class == CLASS_IMPWORKER )
+			{
+				ent->NPC->stats.aim -= Q_irand( 3, 6 );
+			}
+			break;
+		case 1:
+			if ( ent->client->NPC_class == CLASS_IMPWORKER )
+			{
+				ent->NPC->stats.aim -= Q_irand( 2, 4 );
+			}
+			break;
+		case 2:
+			ent->NPC->stats.yawSpeed *= 1.5f;
+			if ( ent->client->NPC_class == CLASS_IMPWORKER )
+			{
+				ent->NPC->stats.aim -= Q_irand( 0, 2 );
+			}
+			break;
+		}
+	}
+	else if ( ent->client->NPC_class == CLASS_REBORN
+		|| ent->client->NPC_class == CLASS_SHADOWTROOPER )
+	{
+		switch ( g_spskill->integer )
+		{
+		case 1:
+			ent->NPC->stats.yawSpeed *= 1.25f;
+			break;
+		case 2:
+			ent->NPC->stats.yawSpeed *= 1.5f;
+			break;
+		}
+	}
+
+
+	ent->s.groundEntityNum = ENTITYNUM_NONE;
+	ent->mass = 10;
+	ent->takedamage = qtrue;
+
+	/*ent->inuse = qtrue;
+	SetInUse(ent);
+	ent->m_iIcarusID = -1; // ICARUS_INVALID
+	*/
+	assert(ent->inuse);
+	assert(ent->m_iIcarusID==IIcarusInterface::ICARUS_INVALID); 
+
+	// CRITICAL NOTE! This was already done somewhere else and it was overwriting the previous value!!!
+	if ( !ent->classname || Q_stricmp( ent->classname, "noclass" ) == 0 )
+		ent->classname = "NPC";
+
+//	if ( ent->client->race == RACE_HOLOGRAM )
+//	{//can shoot through holograms, but not walk through them
+//		ent->contents = CONTENTS_PLAYERCLIP|CONTENTS_MONSTERCLIP|CONTENTS_ITEM;//contents_corspe to make them show up in ID and use traces
+//		ent->clipmask = MASK_NPCSOLID;
+//	} else
+	if(!(ent->spawnflags & SFB_NOTSOLID))
+	{
+		ent->contents = CONTENTS_BODY;
+		ent->clipmask = MASK_NPCSOLID;
+	}
+	else
+	{
+		ent->contents = 0;
+		ent->clipmask = MASK_NPCSOLID&~CONTENTS_BODY;
+	}
+	if(!ent->client->moveType)//Static?
+	{
+		ent->client->moveType = MT_RUNJUMP;
+	}
+	ent->e_DieFunc = dieF_player_die;
+	ent->waterlevel = 0;
+	ent->watertype = 0;
+	
+	//visible to player and NPCs
+	if ( ent->client->NPC_class != CLASS_R2D2 &&
+		ent->client->NPC_class != CLASS_R5D2 &&
+		ent->client->NPC_class != CLASS_MOUSE &&
+		ent->client->NPC_class != CLASS_GONK &&
+		ent->client->NPC_class != CLASS_PROTOCOL )
+	{
+		ent->flags &= ~FL_NOTARGET;
+	}
+	ent->s.eFlags &= ~EF_NODRAW;
+
+	NPC_SetFX_SpawnStates( ent );
+	
+	client->ps.friction = 6;
+
+	if ( ent->client->ps.weapon == WP_NONE )
+	{//not set by the NPCs.cfg
+		NPC_SetWeapons(ent);
+	}
+	//select the weapon
+	ent->NPC->currentAmmo = ent->client->ps.ammo[weaponData[ent->client->ps.weapon].ammoIndex];
+	ent->client->ps.weaponstate = WEAPON_IDLE;
+	ChangeWeapon( ent, ent->client->ps.weapon );
+
+	VectorCopy( spawn_origin, client->ps.origin );
+
+	// the respawned flag will be cleared after the attack and jump keys come up
+	client->ps.pm_flags |= PMF_RESPAWNED;
+
+	// clear entity state values
+	ent->s.eType = ET_PLAYER;
+//	ent->s.skinNum = ent - g_entities - 1;	// used as index to get custom models
+
+	VectorCopy (spawn_origin, ent->s.origin);
+//	ent->s.origin[2] += 1;	// make sure off ground
+
+	SetClientViewAngle( ent, spawn_angles );
+	client->renderInfo.lookTarget = ENTITYNUM_NONE;
+	//clear IK grabbing stuff
+	client->ps.heldClient = client->ps.heldByClient = ENTITYNUM_NONE;
+
+	if(!(ent->spawnflags & 64))
+	{
+		if ( Q_stricmp( ent->NPC_type, "nullDriver") == 0 )
+		{//FIXME: should be a better way to check this
+		}
+		else 
+		{	
+			G_KillBox( ent );
+		}
+		gi.linkentity (ent);
+	}
+
+	// don't allow full run speed for a bit
+	client->ps.pm_flags |= PMF_TIME_KNOCKBACK;
+	client->ps.pm_time = 100;
+
+	client->respawnTime = level.time;
+	client->latched_buttons = 0;
+
+	if ( ent->client->NPC_class != CLASS_VEHICLE )
+	{
+		// set default animations
+		NPC_SetAnim( ent, SETANIM_BOTH, BOTH_STAND1, SETANIM_FLAG_NORMAL );
+	}
+
+	if( spawnPoint )
+	{
+		// fire the targets of the spawn point
+		G_UseTargets( spawnPoint, ent );
+	}
+
+	//ICARUS include
+	// NOTE! Does this need to be called here? It seems to be getting called twice...
+	// Once before the level starts, then once again when the entity is spawned!
+	Quake3Game()->InitEntity( ent );
+
+//==NPC initialization
+	SetNPCGlobals( ent );
+
+	ent->enemy = NPCInfo->eventualGoal;
+	NPCInfo->timeOfDeath = 0;
+	NPCInfo->shotTime = 0;
+	NPC_ClearGoal();
+	NPC_ChangeWeapon( ent->client->ps.weapon );
+
+//==Final NPC initialization
+	ent->e_PainFunc  = NPC_PainFunc( ent ); //painF_NPC_Pain;
+	ent->e_TouchFunc = NPC_TouchFunc( ent ); //touchF_NPC_Touch;
+//	ent->NPC->side = 1;
+
+	ent->client->ps.ping = ent->NPC->stats.reactions * 50;
+
+	//MCG - Begin: NPC hacks
+	//FIXME: Set the team correctly
+	ent->client->ps.persistant[PERS_TEAM] = ent->client->playerTeam;
+
+	ent->e_UseFunc   = useF_NPC_Use;
+	ent->e_ThinkFunc = thinkF_NPC_Think;
+	ent->nextthink = level.time + FRAMETIME + Q_irand(0, 100);
+
+	NPC_SetMiscDefaultData( ent );
+	if ( ent->health <= 0 )
+	{
+		//ORIGINAL ID: health will count down towards max_health
+		ent->health = client->ps.stats[STAT_HEALTH] = ent->max_health;
+	}
+	else
+	{
+		client->ps.stats[STAT_HEALTH] = ent->max_health = ent->health;
+	}
+	ChangeWeapon( ent, ent->client->ps.weapon );//yes, again... sigh
+
+	if ( !(ent->spawnflags & SFB_STARTINSOLID) )
+	{//Not okay to start in solid
+		G_CheckInSolid( ent, qtrue );
+	}
+	VectorClear( ent->NPC->lastClearOrigin );
+
+	//Run a script if you have one assigned to you
+	if ( G_ActivateBehavior( ent, BSET_SPAWN ) )
+	{
+		if( ent->m_iIcarusID != IIcarusInterface::ICARUS_INVALID/*ent->taskManager*/ && !stop_icarus )
+		{
+			IIcarusInterface::GetIcarus()->Update( ent->m_iIcarusID );
+		}
+	}
+
+	VectorCopy( ent->currentOrigin, ent->client->renderInfo.eyePoint );
+
+	// run a client frame to drop exactly to the floor,
+	// initialize animations and other things
+	memset( &ucmd, 0, sizeof( ucmd ) );
+	_VectorCopy( client->pers.cmd_angles, ucmd.angles );
+	
+	ent->client->ps.groundEntityNum = ENTITYNUM_NONE;
+
+	if ( ent->NPC->aiFlags & NPCAI_MATCHPLAYERWEAPON )
+	{
+		G_MatchPlayerWeapon( ent );
+	}
+
+	ClientThink( ent->s.number, &ucmd );
+
+	gi.linkentity( ent );
+
+	if ( ent->client->playerTeam == TEAM_ENEMY || ent->client->playerTeam == TEAM_FREE )
+	{//valid enemy spawned
+		if ( !(ent->spawnflags&SFB_CINEMATIC) && ent->NPC->behaviorState != BS_CINEMATIC )
+		{//not a cinematic enemy
+			if ( g_entities[0].client )
+			{
+				g_entities[0].client->sess.missionStats.enemiesSpawned++;
+			}
+		}
+	}
+}
+
+/*
+-------------------------
+NPC_StasisSpawn_Go
+-------------------------
+*/
+/*	
+qboolean NPC_StasisSpawn_Go( gentity_t *ent )
+{
+	//Setup an owner pointer if we need it
+	if VALIDSTRING( ent->ownername )
+	{
+		ent->owner = G_Find( NULL, FOFS( targetname ), ent->ownername );
+		
+		if ( ( ent->owner ) && ( ent->owner->health <= 0 ) )
+		{//our spawner thing is broken
+			if ( ent->target2 && ent->target2[0] )
+			{
+				//Fire off our target2
+				G_UseTargets2( ent, ent, ent->target2 );
+
+				//Kill us
+				ent->e_ThinkFunc = thinkF_G_FreeEntity;
+				ent->nextthink = level.time + 100;
+			}
+			else
+			{
+				//Try to spawn again in one second
+				ent->e_ThinkFunc = thinkF_NPC_Spawn_Go;
+				ent->nextthink = level.time + 1000;
+			}
+			return qfalse;
+		}
+	}
+
+	//Test for an entity blocking the spawn
+	trace_t	tr;
+	gi.trace( &tr, ent->currentOrigin, ent->mins, ent->maxs, ent->currentOrigin, ent->s.number, MASK_NPCSOLID );
+
+	//Can't have anything in the way
+	if ( tr.allsolid || tr.startsolid )
+	{
+		ent->nextthink = level.time + 1000;
+		return qfalse;
+	}
+
+	return qtrue;
+}
+*/
+void NPC_DefaultScriptFlags( gentity_t *ent )
+{
+	if ( !ent || !ent->NPC )
+	{
+		return;
+	}
+	//Set up default script flags
+	ent->NPC->scriptFlags = (SCF_CHASE_ENEMIES|SCF_LOOK_FOR_ENEMIES);
+}
+
+#define MAX_SAFESPAWN_ENTS 4
+
+bool NPC_SafeSpawn( gentity_t *ent, float safeRadius )
+{
+	gentity_t	*radiusEnts[ MAX_SAFESPAWN_ENTS ];
+	vec3_t		safeMins, safeMaxs;
+	float		distance = 999999;
+	int			numEnts = 0;
+	float		safeRadiusSquared = safeRadius*safeRadius;
+
+	if (!ent)
+	{
+		return false;
+	}
+
+	//Setup the bbox to search in
+	for ( int i = 0; i < 3; i++ )
+	{
+		safeMins[i] = ent->currentOrigin[i] - safeRadius;
+		safeMaxs[i] = ent->currentOrigin[i] + safeRadius;
+	}
+
+	//Get a number of entities in a given space
+	numEnts = gi.EntitiesInBox( safeMins, safeMaxs, radiusEnts, MAX_SAFESPAWN_ENTS );
+
+	for ( i = 0; i < numEnts; i++ )
+	{
+		//Don't consider self
+		if ( radiusEnts[i] == ent )
+			continue;
+
+		if (radiusEnts[i]->NPC && (radiusEnts[i]->health == 0))
+		{
+			// ignore dead guys
+			continue;
+		}
+
+		distance = DistanceSquared( ent->currentOrigin, radiusEnts[i]->currentOrigin );
+
+		//Found one too close to us
+		if ( distance < safeRadiusSquared )
+		{
+			return false;
+		}
+	}
+	return true;
+}
+
+
+/*
+-------------------------
+NPC_Spawn_Go
+-------------------------
+*/
+
+gentity_t *NPC_Spawn_Do( gentity_t *ent, qboolean fullSpawnNow )
+{
+	gentity_t	*newent;
+	int			index;
+	vec3_t		saveOrg;
+
+/*	//Do extra code for stasis spawners
+	if ( Q_stricmp( ent->classname, "NPC_Stasis" ) == 0 )
+	{
+		if ( NPC_StasisSpawn_Go( ent ) == qfalse )
+			return;
+	}
+*/
+
+	// 4/18/03 kef -- don't let guys spawn into other guys
+	if (ent->spawnflags & 4096)
+	{
+		if (!NPC_SafeSpawn(ent, 64))
+		{
+			return NULL;
+		}
+	}
+
+	//Test for drop to floor
+	if ( ent->spawnflags & NSF_DROP_TO_FLOOR )
+	{
+		trace_t		tr;
+		vec3_t		bottom;
+
+		VectorCopy( ent->currentOrigin, saveOrg );
+		VectorCopy( ent->currentOrigin, bottom );
+		bottom[2] = MIN_WORLD_COORD;
+		gi.trace( &tr, ent->currentOrigin, ent->mins, ent->maxs, bottom, ent->s.number, MASK_NPCSOLID );
+		if ( !tr.allsolid && !tr.startsolid && tr.fraction < 1.0 )
+		{
+			G_SetOrigin( ent, tr.endpos );
+		}
+	}
+
+	//Check the spawner's count
+	if( ent->count != -1 )
+	{
+		ent->count--;
+		
+		if( ent->count <= 0 )
+		{
+			ent->e_UseFunc = useF_NULL;//never again
+			//will be removed below
+		}
+	}
+
+	newent = G_Spawn();
+
+	if ( newent == NULL ) 
+	{
+		gi.Printf ( S_COLOR_RED"ERROR: NPC G_Spawn failed\n" );
+		
+		if ( ent->spawnflags & NSF_DROP_TO_FLOOR )
+		{
+			G_SetOrigin( ent, saveOrg );
+		}
+		return NULL;
+	}
+
+	newent->client = (gclient_s *)gi.Malloc(sizeof(gclient_s), TAG_G_ALLOC, qtrue);
+	
+	newent->svFlags |= SVF_NPC;
+
+	if ( ent->NPC_type == NULL ) 
+	{
+		ent->NPC_type = "random";
+		newent->NPC_type = "random";
+	}
+	else
+	{
+		newent->NPC_type = strlwr( G_NewString( ent->NPC_type ) );	//get my own copy so i can free it when i die
+	}
+
+	newent->NPC = (gNPC_t*) gi.Malloc(sizeof(gNPC_t), TAG_G_ALLOC, qtrue);
+
+	newent->NPC->tempGoal = G_Spawn();
+	
+	newent->NPC->tempGoal->classname = "NPC_goal";
+	newent->NPC->tempGoal->owner = newent;
+	newent->NPC->tempGoal->svFlags |= SVF_NOCLIENT;
+
+//==NPC_Connect( newent, net_name );===================================
+
+	if ( ent->svFlags & SVF_NO_BASIC_SOUNDS )
+	{
+		newent->svFlags |= SVF_NO_BASIC_SOUNDS;
+	}
+	if ( ent->svFlags & SVF_NO_COMBAT_SOUNDS )
+	{
+		newent->svFlags |= SVF_NO_COMBAT_SOUNDS;
+	}
+	if ( ent->svFlags & SVF_NO_EXTRA_SOUNDS )
+	{
+		newent->svFlags |= SVF_NO_EXTRA_SOUNDS;
+	}
+	
+	if ( ent->message )
+	{//has a key
+		newent->message = G_NewString(ent->message);//copy the key name
+		newent->flags |= FL_NO_KNOCKBACK;//don't fall off ledges
+	}
+
+	// If this is a vehicle we need to see what kind it is so we properlly allocate it.
+	if ( Q_stricmp( ent->classname, "NPC_Vehicle" ) == 0 )
+	{
+		// Get the vehicle entry index.
+		int iVehIndex = BG_VehicleGetIndex( newent->NPC_type );
+
+		if ( iVehIndex == -1 )
+		{
+			Com_Printf( S_COLOR_RED"ERROR: Attempting to Spawn an unrecognized Vehicle! - %s\n", newent->NPC_type );
+			G_FreeEntity( newent );
+			if ( ent->spawnflags & NSF_DROP_TO_FLOOR )
+			{
+				G_SetOrigin( ent, saveOrg );
+			}
+            return NULL;
+		}
+		newent->soundSet = G_NewString(ent->soundSet);//get my own copy so i can free it when i die
+
+		// NOTE: If you change/add any of these, update NPC_Spawn_f for the new vehicle you
+		// want to be able to spawn in manually.
+
+		// See what kind of vehicle this is and allocate it properly.
+		switch( g_vehicleInfo[iVehIndex].type )
+		{
+			case VH_ANIMAL:
+				// Create the animal (making sure all it's data is initialized).
+				G_CreateAnimalNPC( &newent->m_pVehicle, newent->NPC_type );
+				break;
+
+			case VH_SPEEDER:
+				// Create the speeder (making sure all it's data is initialized).
+				G_CreateSpeederNPC( &newent->m_pVehicle, newent->NPC_type );
+				break;
+
+			case VH_FIGHTER:
+				// Create the fighter (making sure all it's data is initialized).
+				G_CreateFighterNPC( &newent->m_pVehicle, newent->NPC_type );
+				break;
+			case VH_WALKER:
+				// Create the animal (making sure all it's data is initialized).
+				G_CreateWalkerNPC( &newent->m_pVehicle, newent->NPC_type );
+				break;
+
+			default:
+				Com_Printf( S_COLOR_RED"ERROR: Attempting to Spawn an unrecognized Vehicle Type! - %s\n", newent->NPC_type );
+				G_FreeEntity( newent );
+				if ( ent->spawnflags & NSF_DROP_TO_FLOOR )
+				{
+					G_SetOrigin( ent, saveOrg );
+				}
+				return NULL;
+		}
+
+		//grab this from the spawner
+		if ( (ent->spawnflags&1) )
+		{//wants to explode when not in vis of player
+			newent->endFrame = ent->endFrame;
+		}
+
+		// Setup the vehicle.
+		newent->m_pVehicle->m_pParentEntity = newent;
+		newent->m_pVehicle->m_pVehicleInfo->Initialize( newent->m_pVehicle );
+		newent->client->NPC_class = CLASS_VEHICLE;
+
+	}
+	else
+	{
+		newent->client->ps.weapon = WP_NONE;//init for later check in NPC_Begin
+	}
+
+	newent->classname = "NPC";
+	VectorCopy(ent->s.origin, newent->s.origin);
+	VectorCopy(ent->s.origin, newent->client->ps.origin);
+	VectorCopy(ent->s.origin, newent->currentOrigin);
+	G_SetOrigin(newent, ent->s.origin);//just to be sure!
+	//NOTE: on vehicles, anything in the .npc file will STOMP data on the NPC that's set by the vehicle
+	if ( !NPC_ParseParms( ent->NPC_type, newent ) )
+	{
+		gi.Printf ( S_COLOR_RED "ERROR: Couldn't spawn NPC %s\n", ent->NPC_type );
+		G_FreeEntity( newent );
+		if ( ent->spawnflags & NSF_DROP_TO_FLOOR )
+		{
+			G_SetOrigin( ent, saveOrg );
+		}
+		return NULL;
+	}
+
+	if ( ent->NPC_type )
+	{
+		if ( !Q_stricmp( ent->NPC_type, "player" ) )
+		{// Or check NPC_type against player's NPC_type?
+			newent->NPC->aiFlags |= NPCAI_MATCHPLAYERWEAPON;
+		}
+		else if ( !Q_stricmp( ent->NPC_type, "test" ) )
+		{
+			int	n;
+			for ( n = 0; n < 1 ; n++) 
+			{
+				if ( !(g_entities[n].svFlags & SVF_NPC) && g_entities[n].client) 
+				{
+					VectorCopy(g_entities[n].s.origin, newent->s.origin);
+					newent->client->playerTeam = g_entities[n].client->playerTeam;
+					break;
+				}
+			}
+			newent->NPC->defaultBehavior = newent->NPC->behaviorState = BS_WAIT;
+	//		newent->svFlags |= SVF_NOPUSH;
+		}
+	}
+//=====================================================================
+	//set the info we want
+	newent->health = ent->health;
+	newent->wait = ent->wait;
+
+	//copy strings so we can safely free them
+	newent->script_targetname = G_NewString(ent->NPC_targetname);
+	newent->targetname = G_NewString(ent->NPC_targetname);
+	newent->target = G_NewString(ent->NPC_target);//death
+	newent->target2 = G_NewString(ent->target2);//knocked out death
+	newent->target3 = G_NewString(ent->target3);//???
+	newent->target4 = G_NewString(ent->target4);//ffire death
+	newent->paintarget = G_NewString(ent->paintarget);
+	newent->opentarget = G_NewString(ent->opentarget);
+	newent->radius = ent->radius;
+
+	newent->NPC->eventualGoal = ent->enemy;
+	
+	for( index = BSET_FIRST; index < NUM_BSETS; index++)
+	{
+		if ( ent->behaviorSet[index] )
+		{
+			newent->behaviorSet[index] = ent->behaviorSet[index];
+		}
+	}
+	
+	VectorCopy(ent->s.angles, newent->s.angles);
+	VectorCopy(ent->s.angles, newent->currentAngles);
+	VectorCopy(ent->s.angles, newent->client->ps.viewangles);
+	newent->NPC->desiredYaw =ent->s.angles[YAW];
+	
+	//gi.linkentity(newent);  //check: don't need this here?
+	newent->spawnflags = ent->spawnflags;
+
+//==New stuff=====================================================================
+	newent->s.eType	= ET_PLAYER;
+	
+	//FIXME: Call CopyParms
+	if ( ent->parms )
+	{
+		for ( int parmNum = 0; parmNum < MAX_PARMS; parmNum++ )
+		{
+			if ( ent->parms->parm[parmNum] && ent->parms->parm[parmNum][0] )
+			{
+				Q3_SetParm( newent->s.number, parmNum, ent->parms->parm[parmNum] );
+			}
+		}
+	}
+	//FIXME: copy cameraGroup, store mine in message or other string field
+
+	//set origin
+	newent->s.pos.trType = TR_INTERPOLATE;
+	newent->s.pos.trTime = level.time;
+	VectorCopy( newent->currentOrigin, newent->s.pos.trBase );
+	VectorClear( newent->s.pos.trDelta );
+	newent->s.pos.trDuration = 0;
+	//set angles
+	newent->s.apos.trType = TR_INTERPOLATE;
+	newent->s.apos.trTime = level.time;
+	VectorCopy( newent->currentOrigin, newent->s.apos.trBase );
+	VectorClear( newent->s.apos.trDelta );
+	newent->s.apos.trDuration = 0;
+	
+	newent->NPC->combatPoint = -1;
+	newent->NPC->aiFlags |= ent->bounceCount;//ai flags
+
+
+	newent->flags |= FL_NOTARGET;//So he's ignored until he's fully spawned
+	newent->s.eFlags |= EF_NODRAW;//So he's ignored until he's fully spawned
+
+	if ( fullSpawnNow )
+	{
+		newent->owner = ent->owner;
+	}
+	else
+	{
+		newent->e_ThinkFunc = thinkF_NPC_Begin;
+		newent->nextthink = level.time + FRAMETIME;
+	}
+	NPC_DefaultScriptFlags( newent );
+
+	gi.linkentity (newent);
+
+	if(ent->e_UseFunc == useF_NULL)
+	{
+		if( ent->target )
+		{//use any target we're pointed at
+			G_UseTargets ( ent, ent );
+		}
+		if(ent->closetarget)
+		{//last guy should fire this target when he dies
+			if (newent->target)
+			{//zap
+				gi.Free(newent->target);
+			}
+			newent->target = G_NewString(ent->closetarget);
+		}
+		G_FreeEntity( ent );//bye!
+	}
+	else if ( ent->spawnflags & NSF_DROP_TO_FLOOR )
+	{
+		G_SetOrigin( ent, saveOrg );
+	}
+	if ( fullSpawnNow )
+	{
+		NPC_Begin( newent );
+	}
+	return newent;
+}
+
+void NPC_Spawn_Go( gentity_t *ent )
+{
+	NPC_Spawn_Do( ent, qfalse );
+}
+
+/*
+-------------------------
+NPC_StasisSpawnEffect
+-------------------------
+*/
+/*
+void NPC_StasisSpawnEffect( gentity_t *ent )
+{
+	vec3_t		start, end, forward;
+	qboolean	taper;
+
+	//Floor or wall?
+	if ( ent->spawnflags & 1 )
+	{
+		AngleVectors( ent->s.angles, forward, NULL, NULL );
+		VectorMA( ent->currentOrigin,  24, forward, end );
+		VectorMA( ent->currentOrigin, -20, forward, start );
+		
+		start[2] += 64;
+		
+		taper = qtrue;
+	}
+	else
+	{
+		VectorCopy( ent->currentOrigin, start );
+		VectorCopy( start, end );
+		end[2] += 48;
+		taper = qfalse;
+	}
+
+	//Add the effect
+//	CG_ShimmeryThing_Spawner( start, end, 32, qtrue, 1000 );
+}
+*/
+/*
+-------------------------
+NPC_ShySpawn
+-------------------------
+*/
+
+#define SHY_THINK_TIME			1000
+#define SHY_SPAWN_DISTANCE		128
+#define SHY_SPAWN_DISTANCE_SQR	( SHY_SPAWN_DISTANCE * SHY_SPAWN_DISTANCE )
+
+void NPC_ShySpawn( gentity_t *ent )
+{
+	ent->nextthink = level.time + SHY_THINK_TIME;
+	ent->e_ThinkFunc = thinkF_NPC_ShySpawn;
+
+	if ( DistanceSquared( g_entities[0].currentOrigin, ent->currentOrigin ) <= SHY_SPAWN_DISTANCE_SQR )
+		return;
+
+	if ( (InFOV( ent, &g_entities[0], 80, 64 )) ) // FIXME: hardcoded fov
+		if ( (NPC_ClearLOS( &g_entities[0], ent->currentOrigin )) )
+			return;
+
+	// 4/18/03 kef -- don't let guys spawn into other guys
+	if (ent->spawnflags & 4096)
+	{
+		if (!NPC_SafeSpawn(ent, 64))
+		{
+			return;
+		}
+	}
+
+	ent->e_ThinkFunc = thinkF_NULL;
+	ent->nextthink = 0;
+
+	NPC_Spawn_Go( ent );
+}
+
+/*
+-------------------------
+NPC_Spawn
+-------------------------
+*/
+
+void NPC_Spawn ( gentity_t *ent, gentity_t *other, gentity_t *activator )
+{
+	//delay before spawning NPC
+	if (other->spawnflags&32)
+	{
+		ent->enemy = activator;
+	}
+	if( ent->delay )
+	{
+/*		//Stasis does an extra step
+		if ( Q_stricmp( ent->classname, "NPC_Stasis" ) == 0 )
+		{
+			if ( NPC_StasisSpawn_Go( ent ) == qfalse )
+				return;
+		}
+*/
+		if ( ent->spawnflags & 2048 )  // SHY
+			ent->e_ThinkFunc = thinkF_NPC_ShySpawn;
+		else
+			ent->e_ThinkFunc = thinkF_NPC_Spawn_Go;
+
+		ent->nextthink = level.time + ent->delay;
+	}
+	else
+	{
+		if ( ent->spawnflags & 2048 )  // SHY
+			NPC_ShySpawn( ent );
+		else
+			NPC_Spawn_Go( ent );
+	}
+}
+
+/*QUAKED NPC_spawner (1 0 0) (-16 -16 -24) (16 16 40) x x x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY SAFE
+
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+SAFE - Won't spawn if an entity is within 64 units
+
+NPC_type - name of NPC (in npcs.cfg) to spawn in
+
+targetname - name this NPC goes by for targetting
+target - NPC will fire this when it spawns it's last NPC (should this be when the last NPC it spawned dies?)
+target2 - Fired by stasis spawners when they try to spawn while their spawner model is broken
+target3 - Fired by spawner if they try to spawn and are blocked and have a wait < 0 (removes them)
+
+If targeted, will only spawn a NPC when triggered
+count - how many NPCs to spawn (only if targetted) default = 1
+delay - how long to wait to spawn after used
+wait - if trying to spawn and blocked, how many seconds to wait before trying again (default = 0.5, < 0 = never try again and fire target2)
+
+NPC_targetname - NPC's targetname AND script_targetname
+NPC_target - NPC's target to fire when killed
+NPC_target2 - NPC's target to fire when knocked out
+NPC_target4 - NPC's target to fire when killed by friendly fire
+NPC_type - type of NPC ("Borg" (default), "Xian", etc)
+health - starting health (default = 100)
+
+"noBasicSounds" - set to 1 to prevent loading and usage of basic sounds (pain, death, etc)
+"noCombatSounds" - set to 1 to prevent loading and usage of combat sounds (anger, victory, etc.)
+"noExtraSounds" - set to 1 to prevent loading and usage of "extra" sounds (chasing the enemy - detecting them, flanking them... also jedi combat sounds)
+
+spawnscript - default script to run once spawned (none by default)
+usescript - default script to run when used (none by default)
+awakescript - default script to run once awoken (none by default)
+angerscript - default script to run once angered (none by default)
+painscript - default script to run when hit (none by default)
+fleescript - default script to run when hit and below 50% health (none by default)
+deathscript - default script to run when killed (none by default)
+These strings can be used to activate behaviors instead of scripts - these are checked
+first and so no scripts should be names with these names:
+    default - 0: whatever
+	idle - 1: Stand around, do abolutely nothing
+	roam - 2: Roam around, collect stuff
+	walk - 3: Crouch-Walk toward their goals
+	run - 4: Run toward their goals
+	standshoot - 5: Stay in one spot and shoot- duck when neccesary
+	standguard - 6: Wait around for an enemy
+	patrol - 7: Follow a path, looking for enemies
+	huntkill - 8: Track down enemies and kill them
+	evade - 9: Run from enemies
+	evadeshoot - 10: Run from enemies, shoot them if they hit you
+	runshoot - 11: Run to your goal and shoot enemy when possible
+	defend - 12: Defend an entity or spot?
+	snipe - 13: Stay hidden, shoot enemy only when have perfect shot and back turned
+	combat - 14: Attack, evade, use cover, move about, etc.  Full combat AI - id NPC code
+	medic - 15: Go for lowest health buddy, hide and heal him.
+	takecover - 16: Find nearest cover from enemies
+	getammo - 17: Go get some ammo
+	advancefight - 18: Go somewhere and fight along the way
+	face - 19: turn until facing desired angles
+	wait - 20: do nothing
+	formation - 21: Maintain a formation
+	crouch - 22: Crouch-walk toward their goals
+
+delay - after spawned or triggered, how many seconds to wait to spawn the NPC
+*/
+//void NPC_PrecacheModels ( char *NPCName );
+extern qboolean	spawning;				// the G_Spawn*() functions are valid  (only turned on during one function)
+extern void	NPC_PrecacheByClassName(const char*);
+
+void SP_NPC_spawner( gentity_t *self)
+{
+	extern void NPC_PrecacheAnimationCFG( const char *NPC_type );
+	float	fDelay;
+
+	//register/precache the models needed for this NPC, not anymore
+	//self->classname = "NPC_spawner";
+
+	if(!self->count)
+	{
+		self->count = 1;
+	}
+
+	//NOTE: bounceCount is transferred to the spawned NPC's NPC->aiFlags
+	self->bounceCount = 0;
+
+	{
+		static	int	garbage;
+		//Stop loading of certain extra sounds
+		if ( G_SpawnInt( "noBasicSounds", "0", &garbage ) )
+		{
+			self->svFlags |= SVF_NO_BASIC_SOUNDS;
+		}
+		if ( G_SpawnInt( "noCombatSounds", "0", &garbage ) )
+		{
+			self->svFlags |= SVF_NO_COMBAT_SOUNDS;
+		}
+		if ( G_SpawnInt( "noExtraSounds", "0", &garbage ) )
+		{
+			self->svFlags |= SVF_NO_EXTRA_SOUNDS;
+		}
+		if ( G_SpawnInt( "nodelay", "0", &garbage ) )
+		{
+			self->bounceCount |= NPCAI_NO_JEDI_DELAY;
+		}
+	}
+
+
+	if ( !self->wait )
+	{
+		self->wait = 500;
+	}
+	else
+	{
+		self->wait *= 1000;//1 = 1 msec, 1000 = 1 sec
+	}
+
+	G_SpawnFloat( "delay", "0", &fDelay );
+	if ( fDelay )
+	{
+        self->delay = ceil(1000.0f*fDelay);//1 = 1 msec, 1000 = 1 sec
+	}
+
+	if ( self->delay > 0 )
+	{
+		self->svFlags |= SVF_NPC_PRECACHE;
+	}
+
+	//We have to load the animation.cfg now because spawnscripts are going to want to set anims and we need to know their length and if they're valid
+	NPC_PrecacheAnimationCFG( self->NPC_type );
+
+	if ( self->targetname )
+	{//Wait for triggering
+		self->e_UseFunc = useF_NPC_Spawn;
+		self->svFlags |= SVF_NPC_PRECACHE;//FIXME: precache my weapons somehow?
+		//NPC_PrecacheModels( self->NPC_type );
+	}
+	else
+	{
+		//NOTE: auto-spawners never check for shy spawning
+		if ( spawning )
+		{//in entity spawn stage - map starting up
+			self->e_ThinkFunc = thinkF_NPC_Spawn_Go;
+			self->nextthink = level.time + START_TIME_REMOVE_ENTS + 50;
+		}
+		else
+		{//else spawn right now
+			NPC_Spawn( self, self, self );
+		}
+	}
+
+	if (!(self->svFlags&SVF_NPC_PRECACHE))
+	{
+		NPC_PrecacheByClassName(self->NPC_type);
+	}
+
+	//FIXME: store cameraGroup somewhere else and apply to spawned NPCs' cameraGroup
+	//Or just don't include NPC_spawners in cameraGroupings
+
+	if ( self->message )
+	{//may drop a key, precache the key model and pickup sound
+		G_SoundIndex( "sound/weapons/key_pkup.wav" );
+		if ( !Q_stricmp( "goodie", self->message ) )
+		{
+			RegisterItem( FindItemForInventory( INV_GOODIE_KEY ) );
+		}
+		else
+		{
+			RegisterItem( FindItemForInventory( INV_SECURITY_KEY ) );
+		}
+	}
+}
+
+
+//=============================================================================================
+//VEHICLES
+//=============================================================================================
+/*QUAKED NPC_Vehicle (1 0 0) (-16 -16 -24) (16 16 32) NO_VIS_DIE x x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY SAFE
+set NPC_type to vehicle name in vehicles.dat
+
+NO_VIS_DIE - die after certain amount of time of not having a LOS to the Player (default time is 10 seconds, change by setting "noVisTime")
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+SAFE - Won't spawn if an entity is within 64 units
+
+"noVisTime" - how long to wait after spawning/last being seen by the player beforw blowing ourselves up (default is 10 seconds)
+"skin" - which skin to set "red" for example - If no skin it is random
+*/
+void NPC_VehicleSpawnUse( gentity_t *self, gentity_t *other, gentity_t *activator )
+{
+	G_VehicleSpawn( self );
+}
+
+void SP_NPC_Vehicle( gentity_t *self)
+{
+	if ( !self->NPC_type )
+	{
+		self->NPC_type = "swoop";
+	}
+
+	if ( !self->classname )
+	{
+		self->classname = "NPC_Vehicle";
+	}
+
+	G_SetOrigin( self, self->s.origin );
+	G_SetAngles( self, self->s.angles );
+	G_SpawnString("skin", "", &self->soundSet);
+
+	//grab this from the spawner
+	if ( (self->spawnflags&1) )
+	{//wants to explode when not in vis of player
+		if ( !self->endFrame )
+		{
+			self->endFrame = NO_PILOT_DIE_TIME;
+		}
+	}
+
+	if ( self->targetname )
+	{
+		self->svFlags |= SVF_NPC_PRECACHE;				// Precache The Bike when all other npcs are precached
+		self->e_UseFunc = useF_NPC_VehicleSpawnUse;
+		//we're not spawning until later, so precache us now
+		BG_VehicleGetIndex( self->NPC_type );
+	}
+	else
+	{
+		G_VehicleSpawn( self );
+	}
+}
+
+//=============================================================================================
+//CHARACTERS
+//=============================================================================================
+
+/*QUAKED NPC_Player (1 0 0) (-16 -16 -24) (16 16 32) x RIFLEMAN PHASER TRICORDER DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_Player( gentity_t *self)
+{
+	self->NPC_type = "Player";
+
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_Kyle (1 0 0) (-16 -16 -24) (16 16 32) BOSS x x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+BOSS - Uses Boss AI
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_Kyle( gentity_t *self)
+{
+	if ( (self->spawnflags&1) )
+	{
+		self->NPC_type = "Kyle_boss";
+	}
+	else
+	{
+		self->NPC_type = "Kyle";
+	}
+
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_Lando(1 0 0) (-16 -16 -24) (16 16 40) x x x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_Lando( gentity_t *self)
+{
+	self->NPC_type = "Lando";
+
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_Jan(1 0 0) (-16 -16 -24) (16 16 40) x x x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_Jan( gentity_t *self)
+{
+	self->NPC_type = "Jan";
+
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_Luke(1 0 0) (-16 -16 -24) (16 16 40) x x x x CEILING CINEMATIC NOTSOLID STARTINSOLID SHY
+CEILING - Sticks to the ceiling until he sees an enemy or takes pain
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_Luke( gentity_t *self)
+{
+	self->NPC_type = "Luke";
+
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_MonMothma(1 0 0) (-16 -16 -24) (16 16 40) x x x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_MonMothma( gentity_t *self)
+{
+	self->NPC_type = "MonMothma";
+
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_Rosh_Penin (1 0 0) (-16 -16 -24) (16 16 32) DARKSIDE NOFORCE x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+Good Rosh
+DARKSIDE - Evil Rosh
+NOFORCE - Can't jump, starts with no saber
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_Rosh_Penin( gentity_t *self)
+{
+	if ( (self->spawnflags&1) )
+	{
+		self->NPC_type = "rosh_dark";
+	}
+	else if ( (self->spawnflags&2) )
+	{
+		self->NPC_type = "rosh_penin_noforce";
+	}
+	else
+	{
+		self->NPC_type = "rosh_penin";
+	}
+
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_Tavion (1 0 0) (-16 -16 -24) (16 16 32) x x x x CEILING CINEMATIC NOTSOLID STARTINSOLID SHY
+CEILING - Sticks to the ceiling until he sees an enemy or takes pain
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_Tavion( gentity_t *self)
+{
+	self->NPC_type = "Tavion";
+
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_Tavion_New (1 0 0) (-16 -16 -24) (16 16 32) SCEPTER SITH_SWORD x x CEILING CINEMATIC NOTSOLID STARTINSOLID SHY
+Has a red lightsaber and force powers, uses her saber style from JK2
+
+SCEPTER - Has a red lightsaber and force powers, Ragnos' Scepter in left hand, uses dual saber style and occasionally attacks with Scepter
+SITH_SWORD - Has Ragnos' Sith Sword in right hand and force powers, uses strong style
+CEILING - Sticks to the ceiling until he sees an enemy or takes pain
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_Tavion_New( gentity_t *self)
+{
+	if ( (self->spawnflags&1) )
+	{
+		self->NPC_type = "tavion_scepter";
+	}
+	else if ( (self->spawnflags&2) )
+	{
+		self->NPC_type = "tavion_sith_sword";
+	}
+	else
+	{
+		self->NPC_type = "tavion_new";
+	}
+
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_Alora (1 0 0) (-16 -16 -24) (16 16 32) DUAL x x x CEILING CINEMATIC NOTSOLID STARTINSOLID SHY
+Lightsaber and level 2 force powers, 300 health
+
+DUAL - Dual sabers and level 3 force powers, 500 health
+CEILING - Sticks to the ceiling until he sees an enemy or takes pain
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_Alora( gentity_t *self)
+{
+	if ( (self->spawnflags&1) )
+	{
+		self->NPC_type = "alora_dual";
+	}
+	else
+	{
+		self->NPC_type = "alora";
+	}
+
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_Reelo(1 0 0) (-16 -16 -24) (16 16 40) x x x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_Reelo( gentity_t *self)
+{
+	self->NPC_type = "Reelo";
+
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_Galak(1 0 0) (-16 -16 -24) (16 16 40) MECH x x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+MECH - will be the armored Galak
+
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_Galak( gentity_t *self)
+{
+}
+
+/*QUAKED NPC_Desann(1 0 0) (-16 -16 -24) (16 16 40) x x x x CEILING CINEMATIC NOTSOLID STARTINSOLID SHY
+CEILING - Sticks to the ceiling until he sees an enemy or takes pain
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_Desann( gentity_t *self)
+{
+	self->NPC_type = "Desann";
+
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_Rax(1 0 0) (-16 -16 -24) (16 16 40) FUN x x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+FUN - Makes him magically the funnest thing ever in any game ever made. (actually does nothing, it'll just be fun by the power of suggestion).
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_Rax( gentity_t *self )
+{
+	self->NPC_type = "Rax";
+
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_BobaFett(1 0 0) (-16 -16 -24) (16 16 40) x x x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_BobaFett( gentity_t *self )
+{
+	self->NPC_type = "Boba_Fett";
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_Ragnos(1 0 0) (-16 -16 -24) (16 16 40) x x x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_Ragnos( gentity_t *self )
+{
+	self->NPC_type = "Ragnos";
+
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_Lannik_Racto(1 0 0) (-16 -16 -24) (16 16 40) x x x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_Lannik_Racto( gentity_t *self )
+{
+	self->NPC_type = "lannik_racto";
+
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_Kothos(1 0 0) (-16 -16 -24) (16 16 40) VIL x x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+VIL - spawns Vil Kothos instead of Dasariah (can anyone tell them apart anyway...?)
+
+Force only... will (eventually) be set up to re-inforce their leader (use SET_LEADER) by healing them, recharging them, keeping the player away, etc.
+
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_Kothos( gentity_t *self )
+{
+	if ( (self->spawnflags&1) )
+	{
+		self->NPC_type = "VKothos";
+	}
+	else
+	{
+		self->NPC_type = "DKothos";
+	}
+
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_Chewbacca(1 0 0) (-16 -16 -24) (16 16 40) x x x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_Chewbacca( gentity_t *self )
+{
+	self->NPC_type = "Chewie";
+
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_Bartender(1 0 0) (-16 -16 -24) (16 16 40) x x x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_Bartender( gentity_t *self)
+{
+	self->NPC_type = "Bartender";
+
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_MorganKatarn(1 0 0) (-16 -16 -24) (16 16 40) x x x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_MorganKatarn( gentity_t *self)
+{
+	self->NPC_type = "MorganKatarn";
+
+	SP_NPC_spawner( self );
+}
+
+//=============================================================================================
+//ALLIES
+//=============================================================================================
+
+/*QUAKED NPC_Jedi(1 0 0) (-16 -16 -24) (16 16 40) TRAINER MASTER RANDOM x CEILING CINEMATIC NOTSOLID STARTINSOLID SHY
+TRAINER - Special Jedi- instructor
+MASTER - Special Jedi- master
+RANDOM - creates a random Jedi student using the available player models/skins (excludes the current model of the player)
+CEILING - Sticks to the ceiling until he sees an enemy or takes pain
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+
+Ally Jedi NPC Buddy - tags along with player
+*/
+extern cvar_t	*g_char_model;
+void SP_NPC_Jedi( gentity_t *self)
+{
+	if(!self->NPC_type)
+	{
+		if ( self->spawnflags & 4 )
+		{//random!
+			int sanityCheck = 20;	//just in case
+			while ( sanityCheck-- )
+			{
+				switch( Q_irand( 0, 11 ) )
+				{
+				case 0:
+					self->NPC_type = "jedi_hf1";
+					break;
+				case 1:
+					self->NPC_type = "jedi_hf2";
+					break;
+				case 2:
+					self->NPC_type = "jedi_hm1";
+					break;
+				case 3:
+					self->NPC_type = "jedi_hm2";
+					break;
+				case 4:
+					self->NPC_type = "jedi_kdm1";
+					break;
+				case 5:
+					self->NPC_type = "jedi_kdm2";
+					break;
+				case 6:
+					self->NPC_type = "jedi_rm1";
+					break;
+				case 7:
+					self->NPC_type = "jedi_rm2";
+					break;
+				case 8:
+					self->NPC_type = "jedi_tf1";
+					break;
+				case 9:
+					self->NPC_type = "jedi_tf2";
+					break;
+				case 10:
+					self->NPC_type = "jedi_zf1";
+					break;
+				case 11:
+				default://just in case
+					self->NPC_type = "jedi_zf2";
+					break;
+				}
+				if ( strstr( self->NPC_type, g_char_model->string ) != NULL )
+				{//bah, we're using this one, try again
+					continue;
+				}
+				break;	//get out of the while
+			}
+		}
+		else if ( self->spawnflags & 2 )
+		{
+			self->NPC_type = "jedimaster";
+		}
+		else if ( self->spawnflags & 1 )
+		{
+			self->NPC_type = "jeditrainer";
+		}
+		else 
+		{
+			/*
+			if ( !Q_irand( 0, 2 ) )
+			{
+				self->NPC_type = "JediF";
+			}
+			else 
+			*/if ( Q_irand( 0, 1 ) )
+			{
+				self->NPC_type = "Jedi";
+			}
+			else
+			{
+				self->NPC_type = "Jedi2";
+			}
+		}
+	}
+
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_Prisoner(1 0 0) (-16 -16 -24) (16 16 40) ELDER x x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_Prisoner( gentity_t *self)
+{
+	if(!self->NPC_type)
+	{
+		if ( (self->spawnflags&1) )
+		{
+			if ( Q_irand( 0, 1 ) )
+			{
+				self->NPC_type = "elder";
+			}
+			else
+			{
+				self->NPC_type = "elder2";
+			}
+		}
+		else
+		{
+			if ( Q_irand( 0, 1 ) )
+			{
+				self->NPC_type = "Prisoner";
+			}
+			else
+			{
+				self->NPC_type = "Prisoner2";
+			}
+		}
+	}
+
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_Merchant(1 0 0) (-16 -16 -24) (16 16 40) x x x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_Merchant( gentity_t *self)
+{
+	self->NPC_type = "merchant";
+
+	SP_NPC_spawner( self );
+}
+/*QUAKED NPC_Rebel(1 0 0) (-16 -16 -24) (16 16 40) x x x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_Rebel( gentity_t *self)
+{
+	if(!self->NPC_type)
+	{
+		self->NPC_type = "Rebel";
+	}
+
+	SP_NPC_spawner( self );
+}
+
+//=============================================================================================
+//ENEMIES
+//=============================================================================================
+
+/*QUAKED NPC_Human_Merc(1 0 0) (-16 -16 -24) (16 16 40) BOWCASTER REPEATER FLECHETTE CONCUSSION DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+100 health, blaster rifle
+
+BOWCASTER - Starts with a Bowcaster
+REPEATER - Starts with a Repeater
+FLECHETTE - Starts with a Flechette gun
+CONCUSSION - Starts with a Concussion Rifle
+
+If you want them to start with any other kind of weapon, make a spawnscript for them that sets their weapon.
+
+"message" - turns on his key surface.  This is the name of the key you get when you walk over his body.  This must match the "message" field of the func_security_panel you want this key to open.  Set to "goodie" to have him carrying a goodie key that player can use to operate doors with "GOODIE" spawnflag.  NOTE: this overrides all the weapon spawnflags
+
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_Human_Merc( gentity_t *self)
+{
+	if ( !self->NPC_type )
+	{
+		if ( self->message )
+		{
+			self->NPC_type = "human_merc_key";
+		}
+		else if ( (self->spawnflags&1) )
+		{
+			self->NPC_type = "human_merc_bow";
+		}
+		else if ( (self->spawnflags&2) )
+		{
+			self->NPC_type = "human_merc_rep";
+		}
+		else if ( (self->spawnflags&4) )
+		{
+			self->NPC_type = "human_merc_flc";
+		}
+		else if ( (self->spawnflags&8) )
+		{
+			self->NPC_type = "human_merc_cnc";
+		}
+		else
+		{
+			self->NPC_type = "human_merc";
+		}
+	}
+	SP_NPC_spawner( self );
+}
+
+//TROOPERS=============================================================================
+
+/*QUAKED NPC_Stormtrooper(1 0 0) (-16 -16 -24) (16 16 40) OFFICER COMMANDER ALTOFFICER ROCKET DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY COMMANDO
+30 health, blaster
+
+OFFICER - 60 health, flechette
+COMMANDER - 60 health, heavy repeater
+ALTOFFICER - 60 health, alt-fire flechette (grenades)
+ROCKET - 60 health, rocket launcher
+
+COMMANDO - Causes character to use Hazard Trooper (move in formation AI)
+
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_Stormtrooper( gentity_t *self)
+{
+	if ( self->spawnflags & 8 )
+	{//rocketer
+		self->NPC_type = "rockettrooper";
+	}
+	else if ( self->spawnflags & 4 )
+	{//alt-officer
+		self->NPC_type = "stofficeralt";
+	}
+	else if ( self->spawnflags & 2 )
+	{//commander
+		self->NPC_type = "stcommander";
+	}
+	else if ( self->spawnflags & 1 )
+	{//officer
+		self->NPC_type = "stofficer";
+	}
+	else
+	{//regular trooper
+		if ( Q_irand( 0, 1 ) )
+		{
+			self->NPC_type = "StormTrooper";
+		}
+		else
+		{
+			self->NPC_type = "StormTrooper2";
+		}
+	}
+
+	SP_NPC_spawner( self );
+}
+void SP_NPC_StormtrooperOfficer( gentity_t *self)
+{
+	self->spawnflags |= 1;
+	SP_NPC_Stormtrooper( self );
+}
+/*QUAKED NPC_Snowtrooper(1 0 0) (-16 -16 -24) (16 16 40) x x x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+30 health, blaster
+
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_Snowtrooper( gentity_t *self)
+{
+	self->NPC_type = "snowtrooper";
+
+	SP_NPC_spawner( self );
+}
+/*QUAKED NPC_Tie_Pilot(1 0 0) (-16 -16 -24) (16 16 40) x x x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+30 health, blaster
+
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_Tie_Pilot( gentity_t *self)
+{
+	self->NPC_type = "stormpilot";
+
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_RocketTrooper(1 0 0) (-16 -16 -24) (16 16 40) OFFICER SPOTLIGHT x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+200 health, flies, rockets
+
+OFFICER - starts flying, uses concussion rifle instead of rockets
+SPOTLIGHT - uses a shoulder-mounted spotlight
+
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_RocketTrooper( gentity_t *self)
+{
+	if ( !self->NPC_type )
+	{
+		if ( (self->spawnflags&1) )
+		{
+			self->NPC_type = "rockettrooper2Officer";
+		}
+		else
+		{
+			self->NPC_type = "rockettrooper2";
+		}
+	}
+
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_HazardTrooper(1 0 0) (-16 -16 -24) (16 16 40) OFFICER CONCUSSION x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+250 health, repeater
+
+OFFICER - 400 health, flechette
+CONCUSSION - 400 health, concussion rifle
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_HazardTrooper( gentity_t *self)
+{
+	if ( !self->NPC_type )
+	{
+
+
+		if ( (self->spawnflags&1) )
+		{
+			self->NPC_type = "hazardtrooperofficer";
+		}
+		else if ( (self->spawnflags&2) )
+		{
+			self->NPC_type = "hazardtrooperconcussion";
+		}
+		else
+		{
+			self->NPC_type = "hazardtrooper";
+		}
+	}
+
+	SP_NPC_spawner( self );
+}
+
+//OTHERS=============================================================================
+
+/*QUAKED NPC_Ugnaught(1 0 0) (-16 -16 -24) (16 16 40) x x x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_Ugnaught( gentity_t *self)
+{
+	if ( !self->NPC_type )
+	{
+		if ( Q_irand( 0, 1 ) )
+		{
+			self->NPC_type = "Ugnaught";
+		}
+		else
+		{
+			self->NPC_type = "Ugnaught2";
+		}
+	}
+
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_Jawa(1 0 0) (-16 -16 -24) (16 16 40) ARMED x x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+ARMED - starts with the Jawa gun in-hand
+
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_Jawa( gentity_t *self)
+{
+	if ( !self->NPC_type )
+	{
+		if ( (self->spawnflags&1) )
+		{
+			self->NPC_type = "jawa_armed";
+		}
+		else
+		{
+			self->NPC_type = "jawa";
+		}
+	}
+
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_Gran(1 0 0) (-16 -16 -24) (16 16 40) SHOOTER BOXER x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+Uses grenade
+
+SHOOTER - uses blaster instead of 
+BOXER - uses fists only
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_Gran( gentity_t *self)
+{
+	if ( !self->NPC_type )
+	{
+		if ( self->spawnflags & 1 )
+		{
+			self->NPC_type = "granshooter";
+		}
+		else if ( self->spawnflags & 2 )
+		{
+			self->NPC_type = "granboxer";
+		}
+		else
+		{
+			if ( Q_irand( 0, 1 ) )
+			{
+				self->NPC_type = "gran";
+			}
+			else
+			{
+				self->NPC_type = "gran2";
+			}
+		}
+	}
+
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_Rodian(1 0 0) (-16 -16 -24) (16 16 40) BLASTER NO_HIDE x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+BLASTER uses a blaster instead of sniper rifle, different skin
+NO_HIDE (only applicable with snipers) does not duck and hide between shots
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_Rodian( gentity_t *self)
+{
+	if ( !self->NPC_type )
+	{
+		if ( self->spawnflags&1 )
+		{
+			self->NPC_type = "rodian2";
+		}
+		else
+		{
+			self->NPC_type = "rodian";
+		}
+	}
+
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_Weequay(1 0 0) (-16 -16 -24) (16 16 40) x x x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_Weequay( gentity_t *self)
+{
+	if ( !self->NPC_type )
+	{
+		switch ( Q_irand( 0, 3 ) )
+		{
+		case 0:
+			self->NPC_type = "Weequay";
+			break;
+		case 1:
+			self->NPC_type = "Weequay2";
+			break;
+		case 2:
+			self->NPC_type = "Weequay3";
+			break;
+		case 3:
+			self->NPC_type = "Weequay4";
+			break;
+		}
+	}
+
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_Trandoshan(1 0 0) (-16 -16 -24) (16 16 40) x x x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_Trandoshan( gentity_t *self)
+{
+	if ( !self->NPC_type )
+	{
+		self->NPC_type = "Trandoshan";
+	}
+
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_Tusken(1 0 0) (-16 -16 -24) (16 16 40) SNIPER x x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_Tusken( gentity_t *self)
+{
+	if ( !self->NPC_type )
+	{
+		if ( (self->spawnflags&1) )
+		{
+			self->NPC_type = "tuskensniper";
+		}
+		else
+		{
+			self->NPC_type = "tusken";
+		}
+	}
+
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_Noghri(1 0 0) (-16 -16 -24) (16 16 40) x x x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_Noghri( gentity_t *self)
+{
+	if ( !self->NPC_type )
+	{
+		self->NPC_type = "noghri";
+	}
+
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_SwampTrooper(1 0 0) (-16 -16 -24) (16 16 40) REPEATER x x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+REPEATER - Swaptrooper who uses the repeater
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_SwampTrooper( gentity_t *self)
+{
+	if ( !self->NPC_type )
+	{
+		if ( self->spawnflags & 1 )
+		{
+			self->NPC_type = "SwampTrooper2";
+		}
+		else
+		{
+			self->NPC_type = "SwampTrooper";
+		}
+	}
+
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_Imperial(1 0 0) (-16 -16 -24) (16 16 40) OFFICER COMMANDER x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+
+Greyshirt grunt, uses blaster pistol, 20 health.
+
+OFFICER - Brownshirt Officer, uses blaster rifle, 40 health
+COMMANDER - Blackshirt Commander, uses rapid-fire blaster rifle, 80 healt
+
+"message" - if a COMMANDER, turns on his key surface.  This is the name of the key you get when you walk over his body.  This must match the "message" field of the func_security_panel you want this key to open.  Set to "goodie" to have him carrying a goodie key that player can use to operate doors with "GOODIE" spawnflag.
+
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_Imperial( gentity_t *self)
+{
+	if ( !self->NPC_type )
+	{
+		if ( self->spawnflags & 1 )
+		{
+			self->NPC_type = "ImpOfficer";
+		}
+		else if ( self->spawnflags & 2 )
+		{
+			self->NPC_type = "ImpCommander";
+		}
+		else
+		{
+			self->NPC_type = "Imperial";
+		}
+	}
+
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_ImpWorker(1 0 0) (-16 -16 -24) (16 16 40) x x x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_ImpWorker( gentity_t *self)
+{
+	self->NPC_type = "ImpWorker";
+
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_BespinCop(1 0 0) (-16 -16 -24) (16 16 40) x x x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_BespinCop( gentity_t *self)
+{
+	if ( !self->NPC_type )
+	{
+		if ( !Q_irand( 0, 1 ) )
+		{
+			self->NPC_type = "BespinCop";
+		}
+		else
+		{
+			self->NPC_type = "BespinCop2";
+		}
+	}
+
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_Reborn(1 0 0) (-16 -16 -24) (16 16 40) FORCE FENCER ACROBAT BOSS CEILING CINEMATIC NOTSOLID STARTINSOLID SHY
+
+Default Reborn is A poor lightsaber fighter, acrobatic and uses no force powers.  40 health.
+
+FORCE - Uses force powers but is not the best lightsaber fighter and not acrobatic.  75 health.
+FENCER - A good lightsaber fighter, but not acrobatic and uses no force powers.  100 health.
+ACROBAT - quite acrobatic, but not the best lightsaber fighter and uses no force powers.  100 health.
+BOSS - quite acrobatic, good lightsaber fighter and uses force powers.  150 health.
+
+CEILING - Sticks to the ceiling until he sees an enemy or takes pain
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+
+nodelay - set to "1" to make the Reborn not stand around and taunt the player before attacking
+*/
+void SP_NPC_Reborn( gentity_t *self)
+{
+	if ( !self->NPC_type )
+	{
+		if ( self->spawnflags & 1 )
+		{
+			self->NPC_type = "rebornforceuser";
+		}
+		else if ( self->spawnflags & 2 )
+		{
+			self->NPC_type = "rebornfencer";
+		}
+		else if ( self->spawnflags & 4 )
+		{
+			self->NPC_type = "rebornacrobat";
+		}
+		else if ( self->spawnflags & 8 )
+		{
+			self->NPC_type = "rebornboss";
+		}
+		else
+		{
+			self->NPC_type = "reborn";
+		}
+	}
+	
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_Reborn_New(1 0 0) (-16 -16 -24) (16 16 40) DUAL STAFF WEAK MASTER CEILING CINEMATIC NOTSOLID STARTINSOLID SHY
+
+Reborn is an excellent lightsaber fighter, acrobatic and uses force powers.  Full-length red saber, 200 health.
+
+DUAL - Use 2 shorter sabers
+STAFF - Uses a saber staff
+WEAK - Is a bit less tough
+MASTER - Is SUPER tough
+CEILING - Sticks to the ceiling until he sees an enemy or takes pain
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+
+nodelay - set to "1" to make the Reborn not stand around and taunt the player before attacking
+*/
+void SP_NPC_Reborn_New( gentity_t *self)
+{
+	if ( !self->NPC_type )
+	{
+		if ( (self->spawnflags&8) )
+		{//tougher guys
+			if ( (self->spawnflags&1) )
+			{
+				self->NPC_type = "RebornMasterDual";
+			}
+			else if ( (self->spawnflags&2) )
+			{
+				self->NPC_type = "RebornMasterStaff";
+			}
+			else
+			{
+				self->NPC_type = "RebornMaster";
+			}
+		}
+		else if ( (self->spawnflags&4) )
+		{//weaker guys
+			if ( (self->spawnflags&1) )
+			{
+				self->NPC_type = "reborn_dual2";
+			}
+			else if ( (self->spawnflags&2) )
+			{
+				self->NPC_type = "reborn_staff2";
+			}
+			else
+			{
+				self->NPC_type = "reborn_new2";
+			}
+		}
+		else
+		{
+			if ( (self->spawnflags&1) )
+			{
+				self->NPC_type = "reborn_dual";
+			}
+			else if ( (self->spawnflags&2) )
+			{
+				self->NPC_type = "reborn_staff";
+			}
+			else
+			{
+				self->NPC_type = "reborn_new";
+			}
+		}
+	}
+	
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_Cultist_Saber(1 0 0) (-16 -16 -24) (16 16 40) MED STRONG ALL THROW CEILING CINEMATIC NOTSOLID STARTINSOLID SHY
+Uses a saber and no force powers.  100 health.
+
+default fencer uses fast style - weak, but can attack rapidly.  Good defense.
+
+MED - Uses medium style - average speed and attack strength, average defense.
+STRONG - Uses strong style, slower than others, but can do a lot of damage with one blow.  Weak defense.
+ALL - Knows all 3 styles, switches between them, good defense.
+THROW - can throw their saber (level 2) - reduces their defense some (can use this spawnflag alone or in combination with any *one* of the previous 3 spawnflags)
+
+CEILING - Sticks to the ceiling until he sees an enemy or takes pain
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+
+nodelay - set to "1" to make the Cultist not stand around and taunt the player before attacking
+*/
+void SP_NPC_Cultist_Saber( gentity_t *self)
+{
+	if ( !self->NPC_type )
+	{
+		if ( (self->spawnflags&1) )
+		{
+			if ( (self->spawnflags&8) )
+			{
+				self->NPC_type = "cultist_saber_med_throw";
+			}
+			else
+			{
+				self->NPC_type = "cultist_saber_med";
+			}
+		}
+		else if ( (self->spawnflags&2) )
+		{
+			if ( (self->spawnflags&8) )
+			{
+				self->NPC_type = "cultist_saber_strong_throw";
+			}
+			else
+			{
+				self->NPC_type = "cultist_saber_strong";
+			}
+		}
+		else if ( (self->spawnflags&2) )
+		{
+			if ( (self->spawnflags&8) )
+			{
+				self->NPC_type = "cultist_saber_all_throw";
+			}
+			else
+			{
+				self->NPC_type = "cultist_saber_all";
+			}
+		}
+		else
+		{
+			if ( (self->spawnflags&8) )
+			{
+				self->NPC_type = "cultist_saber_throw";
+			}
+			else
+			{
+				self->NPC_type = "cultist_saber";
+			}
+		}
+	}
+	
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_Cultist_Saber_Powers(1 0 0) (-16 -16 -24) (16 16 40) MED STRONG ALL THROW CEILING CINEMATIC NOTSOLID STARTINSOLID SHY
+Uses a saber and has a couple low-level powers.  150 health.
+
+default fencer uses fast style - weak, but can attack rapidly.  Good defense.
+
+MED - Uses medium style - average speed and attack strength, average defense.
+STRONG - Uses strong style, slower than others, but can do a lot of damage with one blow.  Weak defense.
+ALL - Knows all 3 styles, switches between them, good defense.
+THROW - can throw their saber (level 2) - reduces their defense some (can use this spawnflag alone or in combination with any *one* of the previous 3 spawnflags)
+
+CEILING - Sticks to the ceiling until he sees an enemy or takes pain
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+
+nodelay - set to "1" to make the Cultist not stand around and taunt the player before attacking
+*/
+void SP_NPC_Cultist_Saber_Powers( gentity_t *self)
+{
+	if ( !self->NPC_type )
+	{
+		if ( (self->spawnflags&1) )
+		{
+			if ( (self->spawnflags&8) )
+			{
+				self->NPC_type = "cultist_saber_med_throw2";
+			}
+			else
+			{
+				self->NPC_type = "cultist_saber_med2";
+			}
+		}
+		else if ( (self->spawnflags&2) )
+		{
+			if ( (self->spawnflags&8) )
+			{
+				self->NPC_type = "cultist_saber_strong_throw2";
+			}
+			else
+			{
+				self->NPC_type = "cultist_saber_strong2";
+			}
+		}
+		else if ( (self->spawnflags&2) )
+		{
+			if ( (self->spawnflags&8) )
+			{
+				self->NPC_type = "cultist_saber_all_throw2";
+			}
+			else
+			{
+				self->NPC_type = "cultist_saber_all2";
+			}
+		}
+		else
+		{
+			if ( (self->spawnflags&8) )
+			{
+				self->NPC_type = "cultist_saber_throw";
+			}
+			else
+			{
+				self->NPC_type = "cultist_saber2";
+			}
+		}
+	}
+	
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_Cultist(1 0 0) (-16 -16 -24) (16 16 40) SABER GRIP LIGHTNING DRAIN CEILING CINEMATIC NOTSOLID STARTINSOLID SHY
+
+Cultist uses a blaster and force powers.  40 health.
+
+SABER - Uses a saber and no force powers
+GRIP - Uses no weapon and grip, push and pull
+LIGHTNING - Uses no weapon and lightning and push
+DRAIN - Uses no weapons and drain and push
+
+CEILING - Sticks to the ceiling until he sees an enemy or takes pain
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+
+nodelay - set to "1" to make the Cultist not stand around and taunt the player before attacking
+*/
+void SP_NPC_Cultist( gentity_t *self)
+{
+	if ( !self->NPC_type )
+	{
+		if ( (self->spawnflags&1) )
+		{
+			self->NPC_type = NULL;
+			self->spawnflags = 0;//fast, no throw
+			switch ( Q_irand( 0, 2 ) )
+			{
+			case 0://medium
+				self->spawnflags |= 1;
+				break;
+			case 1://strong
+				self->spawnflags |= 2;
+				break;
+			case 2://all
+				self->spawnflags |= 4;
+				break;
+			}
+			if ( Q_irand( 0, 1 ) )
+			{//throw
+				self->spawnflags |= 8;
+			}
+			SP_NPC_Cultist_Saber( self );
+			return;
+		}
+		else if ( (self->spawnflags&2) )
+		{
+			self->NPC_type = "cultist_grip";
+		}
+		else if ( (self->spawnflags&4) )
+		{
+			self->NPC_type = "cultist_lightning";
+		}
+		else if ( (self->spawnflags&8) )
+		{
+			self->NPC_type = "cultist_drain";
+		}
+		else
+		{
+			self->NPC_type = "cultist";
+		}
+	}
+	
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_Cultist_Commando(1 0 0) (-16 -16 -24) (16 16 40) x x x x CEILING CINEMATIC NOTSOLID STARTINSOLID SHY
+
+Cultist uses dual blaster pistols and force powers.  40 health.
+
+CEILING - Sticks to the ceiling until he sees an enemy or takes pain
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+
+nodelay - set to "1" to make the Cultist not stand around and taunt the player before attacking
+*/
+void SP_NPC_Cultist_Commando( gentity_t *self)
+{
+	if ( !self->NPC_type )
+	{
+		self->NPC_type = "cultistcommando";
+	}
+	SP_NPC_spawner( self );
+}
+/*QUAKED NPC_Cultist_Destroyer(1 0 0) (-16 -16 -24) (16 16 40) x x x x CEILING CINEMATIC NOTSOLID STARTINSOLID SHY
+
+Cultist has no weapons, runs up to you chanting & building up a Force Destruction blast - when gets to you, screams & explodes
+
+CEILING - Sticks to the ceiling until he sees an enemy or takes pain
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_Cultist_Destroyer( gentity_t *self)
+{
+	self->NPC_type = "cultist_destroyer";
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_ShadowTrooper(1 0 0) (-16 -16 -24) (16 16 40) x x x x CEILING CINEMATIC NOTSOLID STARTINSOLID SHY
+CEILING - Sticks to the ceiling until he sees an enemy or takes pain
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+
+nodelay - set to "1" to make the Cultist not stand around and taunt the player before attacking
+*/
+void SP_NPC_ShadowTrooper( gentity_t *self)
+{
+	if(!self->NPC_type)
+	{
+		if ( !Q_irand( 0, 1 ) )
+		{
+			self->NPC_type = "ShadowTrooper";
+		}
+		else
+		{
+			self->NPC_type = "ShadowTrooper2";
+		}
+	}
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_Saboteur(1 0 0) (-16 -16 -24) (16 16 40) SNIPER PISTOL x x CLOAKED CINEMATIC NOTSOLID STARTINSOLID SHY
+Has a blaster rifle, can cloak and roll
+
+SNIPER - Has a sniper rifle, no acrobatics, but can dodge
+PISTOL - Just has a pistol, can roll
+COMMANDO - Has 2 pistols and can roll & dodge
+
+CLOAKED - Starts cloaked
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_Saboteur( gentity_t *self)
+{
+	if ( !self->NPC_type )
+	{
+		if ( (self->spawnflags&1) )
+		{
+			self->NPC_type = "saboteursniper";
+		}
+		else if ( (self->spawnflags&2) )
+		{
+			self->NPC_type = "saboteurpistol";
+		}
+		else if ( (self->spawnflags&4) )
+		{
+			self->NPC_type = "saboteurcommando";
+		}
+		else
+		{
+			self->NPC_type = "saboteur";
+		}
+	}
+	SP_NPC_spawner( self );
+}
+
+//=============================================================================================
+//MONSTERS
+//=============================================================================================
+
+/*QUAKED NPC_Monster_Murjj (1 0 0) (-12 -12 -24) (12 12 40) x x x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_Monster_Murjj( gentity_t *self)
+{
+	self->NPC_type = "Murjj";
+
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_Monster_Swamp (1 0 0) (-12 -12 -24) (12 12 40) x x x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_Monster_Swamp( gentity_t *self)
+{
+	self->NPC_type = "Swamp";
+
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_Monster_Howler (1 0 0) (-16 -16 -24) (16 16 8) x x x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_Monster_Howler( gentity_t *self)
+{
+	self->NPC_type = "howler";
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_Monster_Rancor (1 0 0) (-30 -30 -24) (30 30 136) MUTANT FASTKILL x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+2000 health, picks people up and eats them
+
+MUTANT - Bigger, meaner, nastier, Frencher.  Breath attack, pound attack.
+FASTKILL - Kills NPCs faster
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_Monster_Rancor( gentity_t *self)
+{
+	if ( (self->spawnflags&1) )
+	{
+		self->NPC_type = "mutant_rancor";
+	}
+	else
+	{
+		self->NPC_type = "rancor";
+	}
+
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_Monster_Mutant_Rancor (1 0 0) (-60 -60 -24) (60 60 360) x FASTKILL x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+Bigger, meaner, nastier, Frencher.  Breath attack, pound attack.
+
+FASTKILL - Kills NPCs faster
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_Monster_Mutant_Rancor( gentity_t *self)
+{
+	self->NPC_type = "mutant_rancor";
+
+	SP_NPC_spawner( self );
+}
+/*QUAKED NPC_Monster_Wampa (1 0 0) (-12 -12 -24) (12 12 40) x x x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_Monster_Wampa( gentity_t *self)
+{
+	self->NPC_type = "wampa";
+
+	SP_NPC_spawner( self );
+}
+/*QUAKED NPC_MineMonster (1 0 0) (-12 -12 -24) (12 12 40) x x x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_MineMonster( gentity_t *self)
+{
+	self->NPC_type = "minemonster";
+
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_Monster_Claw (1 0 0) (-12 -12 -24) (12 12 40) x x x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_Monster_Claw( gentity_t *self)
+{
+	self->NPC_type = "Claw";
+
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_Monster_Glider (1 0 0) (-12 -12 -24) (12 12 40) x x x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_Monster_Glider( gentity_t *self)
+{
+	self->NPC_type = "Glider";
+
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_Monster_Flier2 (1 0 0) (-12 -12 -24) (12 12 40) x x x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_Monster_Flier2( gentity_t *self)
+{
+	self->NPC_type = "Flier2";
+
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_Monster_Lizard (1 0 0) (-12 -12 -24) (12 12 40) x x x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_Monster_Lizard( gentity_t *self)
+{
+	self->NPC_type = "Lizard";
+
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_Monster_Fish (1 0 0) (-12 -12 -24) (12 12 40) x x x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_Monster_Fish( gentity_t *self)
+{
+	self->NPC_type = "Fish";
+
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_Monster_Sand_Creature (1 0 0) (-24 -24 -24) (24 24 0) FAST x x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+
+turfrange - if set, they will not go beyond this dist from their spawn position
+*/
+void SP_NPC_Monster_Sand_Creature( gentity_t *self)
+{
+	if ( (self->spawnflags&1) )
+	{
+		self->NPC_type = "sand_creature_fast";
+	}
+	else
+	{
+		self->NPC_type = "sand_creature";
+	}
+
+	SP_NPC_spawner( self );
+}
+
+//=============================================================================================
+//DROIDS
+//=============================================================================================
+
+/*QUAKED NPC_Droid_Interrogator (1 0 0) (-12 -12 -24) (12 12 0) x x x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_Droid_Interrogator( gentity_t *self)
+{
+	self->NPC_type = "interrogator";
+
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_Droid_Probe (1 0 0) (-12 -12 -24) (12 12 40) x x x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+
+Imperial Probe Droid - the multilegged floating droid that Han and Chewie shot on the ice planet Hoth
+*/
+void SP_NPC_Droid_Probe( gentity_t *self)
+{
+	self->NPC_type = "probe";
+
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_Droid_Mark1 (1 0 0) (-36 -36 -24) (36 36 80) x x x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+
+Big walking droid
+
+*/
+void SP_NPC_Droid_Mark1( gentity_t *self)
+{
+	self->NPC_type = "mark1";
+
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_Droid_Mark2 (1 0 0) (-12 -12 -24) (12 12 40) x x x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+
+Small rolling droid with one gun.
+
+*/
+void SP_NPC_Droid_Mark2( gentity_t *self)
+{
+	self->NPC_type = "mark2";
+
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_Droid_ATST (1 0 0) (-40 -40 -24) (40 40 248) x x x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_Droid_ATST( gentity_t *self)
+{
+	self->NPC_type = "atst";
+
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_Droid_Remote (1 0 0) (-4 -4 -24) (4 4 8) x x x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+
+Remote Droid - the floating round droid used by Obi Wan to train Luke about the force while on the Millenium Falcon.
+*/
+void SP_NPC_Droid_Remote( gentity_t *self)
+{
+	self->NPC_type = "remote_sp";
+
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_Droid_Seeker (1 0 0) (-4 -4 -24) (4 4 8) x x x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+
+Seeker Droid - floating round droids that shadow troopers spawn
+*/
+void SP_NPC_Droid_Seeker( gentity_t *self)
+{
+	self->NPC_type = "seeker";
+
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_Droid_Sentry (1 0 0) (-24 -24 -24) (24 24 40) x x x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+
+Sentry Droid - Large, armored floating Imperial droids with 3 forward-facing gun turrets
+*/
+void SP_NPC_Droid_Sentry( gentity_t *self)
+{
+	self->NPC_type = "sentry";
+
+	SP_NPC_spawner( self );
+
+}
+
+/*QUAKED NPC_Droid_Gonk (1 0 0) (-12 -12 -24) (12 12 40) x x x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+
+Gonk Droid - the droid that looks like a walking ice machine. Was in the Jawa land crawler, walking around talking to itself.
+
+NOTARGET by default
+*/
+void SP_NPC_Droid_Gonk( gentity_t *self)
+{
+	self->NPC_type = "gonk";
+
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_Droid_Mouse (1 0 0) (-12 -12 -24) (12 12 40) x x x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+
+Mouse Droid - small, box shaped droid, first seen on the Death Star. Chewie yelled at it and it backed up and ran away.
+
+NOTARGET by default
+*/
+void SP_NPC_Droid_Mouse( gentity_t *self)
+{
+	self->NPC_type = "mouse";
+
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_Droid_R2D2 (1 0 0) (-12 -12 -24) (12 12 40) IMPERIAL x x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+
+R2D2 Droid - you probably know this one already. 
+
+NOTARGET by default
+*/
+void SP_NPC_Droid_R2D2( gentity_t *self)
+{
+	if ( self->spawnflags&1 )
+	{//imperial skin
+		self->NPC_type = "r2d2_imp";
+	}
+	else
+	{
+		self->NPC_type = "r2d2";
+	}
+
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_Droid_R5D2 (1 0 0) (-12 -12 -24) (12 12 40) IMPERIAL ALWAYSDIE x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+ALWAYSDIE - won't go into spinning zombie AI when at low health.
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+
+R5D2 Droid - the droid originally chosen by Uncle Owen until it blew a bad motivator, and they took R2D2 instead.
+
+NOTARGET by default
+*/
+void SP_NPC_Droid_R5D2( gentity_t *self)
+{
+	if ( self->spawnflags&1 )
+	{//imperial skin
+		self->NPC_type = "r5d2_imp";
+	}
+	else
+	{
+		self->NPC_type = "r5d2";
+	}
+
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_Droid_Protocol (1 0 0) (-12 -12 -24) (12 12 40) IMPERIAL x x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+
+NOTARGET by default
+*/
+void SP_NPC_Droid_Protocol( gentity_t *self)
+{
+	if ( self->spawnflags&1 )
+	{//imperial skin
+		self->NPC_type = "protocol_imp";
+	}
+	else
+	{
+		self->NPC_type = "protocol";
+	}
+
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_Droid_Assassin (1 0 0) (-12 -12 -24) (12 12 40) x x x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_Droid_Assassin( gentity_t *self)
+{
+	if ( !self->NPC_type )
+	{
+		self->NPC_type = "assassin_droid";
+	}
+
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_Droid_Saber (1 0 0) (-12 -12 -24) (12 12 40) TRAINING x x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_Droid_Saber( gentity_t *self)
+{
+	if ( !self->NPC_type )
+	{
+		if ( (self->spawnflags&1) )
+		{
+			self->NPC_type = "saber_droid_training";
+		}
+		else
+		{
+			self->NPC_type = "saber_droid";
+		}
+	}
+
+	SP_NPC_spawner( self );
+}
+
+//NPC console commands
+/*
+NPC_Spawn_f
+*/
+
+static void NPC_Spawn_f(void) 
+{
+	gentity_t		*NPCspawner = G_Spawn();
+	vec3_t			forward, end;
+	trace_t			trace;
+	qboolean		isVehicle = qfalse;
+	
+	if(!NPCspawner)
+	{
+		gi.Printf( S_COLOR_RED"NPC_Spawn Error: Out of entities!\n" );
+		return;
+	}
+
+	NPCspawner->e_ThinkFunc = thinkF_G_FreeEntity;
+	NPCspawner->nextthink = level.time + FRAMETIME;
+	
+
+	char	*npc_type = gi.argv( 2 );
+	if (!npc_type )
+	{
+		gi.Printf( S_COLOR_RED"Error, expected:\n NPC spawn [NPC type (from NCPCs.cfg)]\n" );
+		return;
+	}
+
+	if ( !Q_stricmp( "vehicle", npc_type ) )
+	{//spawning a vehicle
+		isVehicle = qtrue;
+		npc_type = gi.argv( 3 );
+		if (!npc_type )
+		{
+			gi.Printf( S_COLOR_RED"Error, expected:\n NPC spawn vehicle [NPC type (from NCPCs.cfg)]\n" );
+			return;
+		}
+	}
+
+	//Spawn it at spot of first player
+	//FIXME: will gib them!
+	AngleVectors(g_entities[0].client->ps.viewangles, forward, NULL, NULL);
+	VectorNormalize(forward);
+	VectorMA(g_entities[0].currentOrigin, 64, forward, end);
+	gi.trace(&trace, g_entities[0].currentOrigin, NULL, NULL, end, 0, MASK_SOLID);
+	VectorCopy(trace.endpos, end);
+	end[2] -= 24;
+	gi.trace(&trace, trace.endpos, NULL, NULL, end, 0, MASK_SOLID);
+	VectorCopy(trace.endpos, end);
+	end[2] += 24;
+	G_SetOrigin(NPCspawner, end);
+	VectorCopy(NPCspawner->currentOrigin, NPCspawner->s.origin);
+	//set the yaw so that they face away from player
+	NPCspawner->s.angles[1] = g_entities[0].client->ps.viewangles[1];
+
+	gi.linkentity(NPCspawner);
+
+	NPCspawner->NPC_type = strlwr( G_NewString( npc_type ) );
+	NPCspawner->NPC_targetname = G_NewString(gi.argv( 3 ));
+
+	NPCspawner->count = 1;
+
+	NPCspawner->delay = 0;
+
+	NPCspawner->wait = 500;
+
+	//NPCspawner->spawnflags |= SFB_NOTSOLID;
+
+	//NPCspawner->playerTeam = TEAM_FREE;
+	//NPCspawner->behaviorSet[BSET_SPAWN] = "common/guard";
+
+	if ( isVehicle )
+	{//must let NPC spawn func know this is a vehicle we're trying to spawn
+		NPCspawner->classname = "NPC_Vehicle";
+	}
+
+	NPC_PrecacheByClassName(NPCspawner->NPC_type);
+	if ( !Q_stricmp( "kyle_boss", NPCspawner->NPC_type ))
+	{//bah
+		NPCspawner->spawnflags |= 1;
+	}
+
+	if ( !Q_stricmp( "key", NPCspawner->NPC_type ))
+	{//bah
+		NPCspawner->message = "key";
+		NPCspawner->NPC_type = "imperial";
+	}
+	if ( !Q_stricmp( "jedi_random", NPCspawner->NPC_type ) )
+	{//special case, for testing
+		NPCspawner->NPC_type = NULL;
+		NPCspawner->spawnflags |= 4;
+		SP_NPC_Jedi( NPCspawner );
+	}
+	else
+	{
+		NPC_Spawn( NPCspawner, NPCspawner, NPCspawner );
+	}
+}
+
+/*
+NPC_Kill_f
+*/
+
+void NPC_Kill_f( void ) 
+{
+	int			n;
+	gentity_t	*player;
+	char		*name;
+	team_t		killTeam = TEAM_FREE;
+	qboolean	killNonSF = qfalse;
+
+	name = gi.argv( 2 );
+
+	if ( !*name || !name[0] )
+	{
+		gi.Printf( S_COLOR_RED"Error, Expected:\n");
+		gi.Printf( S_COLOR_RED"NPC kill '[NPC targetname]' - kills NPCs with certain targetname\n" );
+		gi.Printf( S_COLOR_RED"or\n" );
+		gi.Printf( S_COLOR_RED"NPC kill 'all' - kills all NPCs\n" );
+		gi.Printf( S_COLOR_RED"or\n" );
+		gi.Printf( S_COLOR_RED"NPC team '[teamname]' - kills all NPCs of a certain team ('nonally' is all but your allies)\n" );
+		return;
+	}
+
+	if ( Q_stricmp( "team", name ) == 0 )
+	{
+		name = gi.argv( 3 );
+
+		if ( !*name || !name[0] )
+		{
+			gi.Printf( S_COLOR_RED"NPC_Kill Error: 'npc kill team' requires a team name!\n" );
+			gi.Printf( S_COLOR_RED"Valid team names are:\n");
+			for ( n = (TEAM_FREE + 1); n < TEAM_NUM_TEAMS; n++ )
+			{
+				gi.Printf( S_COLOR_RED"%s\n", GetStringForID( TeamTable, n ) );
+			}
+			gi.Printf( S_COLOR_RED"nonally - kills all but your teammates\n" );
+			return;
+		}
+
+		if ( Q_stricmp( "nonally", name ) == 0 )
+		{
+			killNonSF = qtrue;
+		}
+		else
+		{
+			killTeam = (team_t)GetIDForString( TeamTable, name );
+
+			if ( killTeam == -1 )
+			{
+				gi.Printf( S_COLOR_RED"NPC_Kill Error: team '%s' not recognized\n", name );
+				gi.Printf( S_COLOR_RED"Valid team names are:\n");
+				for ( n = (TEAM_FREE + 1); n < TEAM_NUM_TEAMS; n++ )
+				{
+					gi.Printf( S_COLOR_RED"%s\n", GetStringForID( TeamTable, n ) );
+				}
+				gi.Printf( S_COLOR_RED"nonally - kills all but your teammates\n" );
+				return;
+			}
+		}
+	}
+
+	for ( n = 1; n < ENTITYNUM_MAX_NORMAL; n++) 
+	{
+		player = &g_entities[n];
+		if (!player->inuse) {
+			continue;
+		}
+		if ( killNonSF )
+		{
+			if ( player )
+			{
+				if ( player->client )
+				{
+					if ( player->client->playerTeam != TEAM_PLAYER )
+					{
+						gi.Printf( S_COLOR_GREEN"Killing NPC %s named %s\n", player->NPC_type, player->targetname );
+						/*
+						if ( (player->flags&FL_UNDYING) )
+						{
+							G_Damage( player, NULL, NULL, NULL, NULL, player->health+10000, 0, MOD_UNKNOWN );
+						}
+						else
+						*/
+						{
+							player->health = 0;
+							GEntity_DieFunc(player, player, player, player->max_health, MOD_UNKNOWN);
+						}
+					}
+				}
+				else if ( player->NPC_type && player->classname && player->classname[0] && Q_stricmp( "NPC_starfleet", player->classname ) != 0 )
+				{//A spawner, remove it
+					gi.Printf( S_COLOR_GREEN"Removing NPC spawner %s with NPC named %s\n", player->NPC_type, player->NPC_targetname );
+					G_FreeEntity( player );
+					//FIXME: G_UseTargets2(player, player, player->NPC_target & player->target);?
+				}
+			}
+		}
+		else if ( player && player->NPC && player->client )
+		{
+			if ( killTeam != TEAM_FREE )
+			{
+				if ( player->client->playerTeam == killTeam )
+				{
+					gi.Printf( S_COLOR_GREEN"Killing NPC %s named %s\n", player->NPC_type, player->targetname );
+					/*
+					if ( (player->flags&FL_UNDYING) )
+					{
+						G_Damage( player, NULL, NULL, NULL, NULL, player->health+10000, 0, MOD_UNKNOWN );
+					}
+					else
+					*/
+					{
+						player->health = 0;
+						GEntity_DieFunc(player, player, player, player->max_health, MOD_UNKNOWN);
+					}
+				}
+			}
+			else if( (player->targetname && Q_stricmp( name, player->targetname ) == 0)
+				|| Q_stricmp( name, "all" ) == 0 )
+			{
+				gi.Printf( S_COLOR_GREEN"Killing NPC %s named %s\n", player->NPC_type, player->targetname );
+				player->client->ps.stats[STAT_HEALTH] = 0;
+				/*
+				if ( (player->flags&FL_UNDYING) )
+				{
+					G_Damage( player, NULL, NULL, NULL, NULL, player->health+10000, 0, MOD_UNKNOWN );
+				}
+				else
+				*/
+				{
+					player->health = 0;
+					GEntity_DieFunc(player, player, player, 100, MOD_UNKNOWN);
+				}
+			}
+		}
+		else if ( player && (player->svFlags&SVF_NPC_PRECACHE) )
+		{//a spawner
+			if( (player->targetname && Q_stricmp( name, player->targetname ) == 0)
+				|| Q_stricmp( name, "all" ) == 0 )
+			{
+				gi.Printf( S_COLOR_GREEN"Removing NPC spawner %s named %s\n", player->NPC_type, player->targetname );
+				G_FreeEntity( player );
+			}
+		}
+	}
+}
+
+void NPC_PrintScore( gentity_t *ent )
+{
+	gi.Printf( "%s: %d\n", ent->targetname, ent->client->ps.persistant[PERS_SCORE] );
+}
+
+/*
+Svcmd_NPC_f
+
+parse and dispatch bot commands
+*/
+qboolean	showBBoxes = qfalse;
+void Svcmd_NPC_f( void ) 
+{
+	char	*cmd;
+
+	cmd = gi.argv( 1 );
+
+	if ( !*cmd ) 
+	{
+		gi.Printf( "Valid NPC commands are:\n" );
+		gi.Printf( " spawn [NPC type (from *.npc files)]\n" );
+		gi.Printf( " spawn vehicle [NPC type (from *.npc files, only for NPCs that are CLASS_VEHICLE and have a .veh file)]\n" );
+		gi.Printf( " kill [NPC targetname] or [all(kills all NPCs)] or 'team [teamname]'\n" );
+		gi.Printf( " showbounds (draws exact bounding boxes of NPCs)\n" );
+		gi.Printf( " score [NPC targetname] (prints number of kills per NPC)\n" );
+	}
+	else if ( Q_stricmp( cmd, "spawn" ) == 0 ) 
+	{
+		NPC_Spawn_f();
+	}
+	else if ( Q_stricmp( cmd, "kill" ) == 0 ) 
+	{
+		NPC_Kill_f();
+	}
+	else if ( Q_stricmp( cmd, "showbounds" ) == 0 )
+	{//Toggle on and off
+		showBBoxes = showBBoxes ? qfalse : qtrue;
+	}
+	else if ( Q_stricmp ( cmd, "score" ) == 0 )
+	{
+		char		*cmd2 = gi.argv(2);
+		gentity_t *ent = NULL;
+
+		if ( !cmd2 || !cmd2[0] )
+		{//Show the score for all NPCs
+			gi.Printf( "SCORE LIST:\n" );
+			for ( int i = 0; i < ENTITYNUM_WORLD; i++ )
+			{
+				ent = &g_entities[i];
+				if ( !ent || !ent->client )
+				{
+					continue;
+				}
+				NPC_PrintScore( ent );
+			}
+		}
+		else
+		{
+			if ( (ent = G_Find( NULL, FOFS(targetname), cmd2 )) != NULL && ent->client )
+			{
+				NPC_PrintScore( ent );
+			}
+			else
+			{
+				gi.Printf( "ERROR: NPC score - no such NPC %s\n", cmd2 );
+			}
+		}
+	}
+}
diff --git a/code/game/NPC_stats.cpp b/code/game/NPC_stats.cpp
new file mode 100644
index 0000000..47e8c2e
--- /dev/null
+++ b/code/game/NPC_stats.cpp
@@ -0,0 +1,4014 @@
+//NPC_stats.cpp
+// leave this line at the top for all NPC_xxxx.cpp files...
+#include "g_headers.h"
+
+#include "b_local.h"
+#include "b_public.h"
+#include "anims.h"
+#include "wp_saber.h"
+#include "g_Vehicles.h"
+#if !defined(RUFL_HSTRING_INC)
+	#include "..\Rufl\hstring.h"
+#endif
+	#include "..\Ratl\string_vs.h"
+	#include "..\Rufl\hstring.h"
+	#include "..\Ratl\vector_vs.h"
+
+extern void WP_RemoveSaber( gentity_t *ent, int saberNum );
+extern qboolean NPCsPrecached;
+extern vec3_t playerMins;
+extern vec3_t playerMaxs;
+extern stringID_table_t WPTable[];
+
+#define		MAX_MODELS_PER_LEVEL	40
+
+#ifdef _XBOX
+using dllNamespace::hstring;
+#endif
+hstring		modelsAlreadyDone[MAX_MODELS_PER_LEVEL];
+
+
+stringID_table_t animEventTypeTable[] = 
+{
+	ENUM2STRING(AEV_SOUND),			//# animID AEV_SOUND framenum soundpath randomlow randomhi chancetoplay
+	ENUM2STRING(AEV_FOOTSTEP),		//# animID AEV_FOOTSTEP framenum footstepType
+	ENUM2STRING(AEV_EFFECT),		//# animID AEV_EFFECT framenum effectpath boltName
+	ENUM2STRING(AEV_FIRE),			//# animID AEV_FIRE framenum altfire chancetofire
+	ENUM2STRING(AEV_MOVE),			//# animID AEV_MOVE framenum forwardpush rightpush uppush
+	ENUM2STRING(AEV_SOUNDCHAN),		//# animID AEV_SOUNDCHAN framenum CHANNEL soundpath randomlow randomhi chancetoplay 
+	//must be terminated
+	NULL,-1
+};
+
+stringID_table_t footstepTypeTable[] = 
+{
+	ENUM2STRING(FOOTSTEP_R),
+	ENUM2STRING(FOOTSTEP_L),
+	ENUM2STRING(FOOTSTEP_HEAVY_R),
+	ENUM2STRING(FOOTSTEP_HEAVY_L),
+	//must be terminated
+	NULL,-1
+};
+
+stringID_table_t FPTable[] =
+{
+	ENUM2STRING(FP_HEAL),
+	ENUM2STRING(FP_LEVITATION),
+	ENUM2STRING(FP_SPEED),
+	ENUM2STRING(FP_PUSH),
+	ENUM2STRING(FP_PULL),
+	ENUM2STRING(FP_TELEPATHY),
+	ENUM2STRING(FP_GRIP),
+	ENUM2STRING(FP_LIGHTNING),
+	ENUM2STRING(FP_SABERTHROW),
+	ENUM2STRING(FP_SABER_DEFENSE),
+	ENUM2STRING(FP_SABER_OFFENSE),
+	//new Jedi Academy powers
+	ENUM2STRING(FP_RAGE),
+	ENUM2STRING(FP_PROTECT),
+	ENUM2STRING(FP_ABSORB),
+	ENUM2STRING(FP_DRAIN),
+	ENUM2STRING(FP_SEE),
+	"",	-1
+};
+
+
+stringID_table_t TeamTable[] =
+{
+	"free", TEAM_FREE,			// caution, some code checks a team_t via "if (!team_t_varname)" so I guess this should stay as entry 0, great or what? -slc
+	ENUM2STRING(TEAM_FREE),			// caution, some code checks a team_t via "if (!team_t_varname)" so I guess this should stay as entry 0, great or what? -slc
+	"player", TEAM_PLAYER,
+	ENUM2STRING(TEAM_PLAYER),
+	"enemy", TEAM_ENEMY,
+	ENUM2STRING(TEAM_ENEMY),
+	"neutral", TEAM_NEUTRAL,	// most droids are team_neutral, there are some exceptions like Probe,Seeker,Interrogator
+	ENUM2STRING(TEAM_NEUTRAL),	// most droids are team_neutral, there are some exceptions like Probe,Seeker,Interrogator
+	"",	-1
+};
+
+
+// this list was made using the model directories, this MUST be in the same order as the CLASS_ enum in teams.h
+stringID_table_t ClassTable[] =
+{
+	ENUM2STRING(CLASS_NONE),				// hopefully this will never be used by an npc), just covering all bases
+	ENUM2STRING(CLASS_ATST),				// technically droid...
+	ENUM2STRING(CLASS_BARTENDER),
+	ENUM2STRING(CLASS_BESPIN_COP),		
+	ENUM2STRING(CLASS_CLAW),
+	ENUM2STRING(CLASS_COMMANDO),
+	ENUM2STRING(CLASS_DESANN),			
+	ENUM2STRING(CLASS_FISH),
+	ENUM2STRING(CLASS_FLIER2),
+	ENUM2STRING(CLASS_GALAK),
+	ENUM2STRING(CLASS_GLIDER),
+	ENUM2STRING(CLASS_GONK),				// droid
+	ENUM2STRING(CLASS_GRAN),
+	ENUM2STRING(CLASS_HOWLER),
+	ENUM2STRING(CLASS_RANCOR),
+	ENUM2STRING(CLASS_SAND_CREATURE),
+	ENUM2STRING(CLASS_WAMPA),
+	ENUM2STRING(CLASS_IMPERIAL),
+	ENUM2STRING(CLASS_IMPWORKER),
+	ENUM2STRING(CLASS_INTERROGATOR),		// droid 
+	ENUM2STRING(CLASS_JAN),				
+	ENUM2STRING(CLASS_JEDI),				
+	ENUM2STRING(CLASS_KYLE),
+	ENUM2STRING(CLASS_LANDO),			
+	ENUM2STRING(CLASS_LIZARD),
+	ENUM2STRING(CLASS_LUKE),				
+	ENUM2STRING(CLASS_MARK1),			// droid
+	ENUM2STRING(CLASS_MARK2),			// droid
+	ENUM2STRING(CLASS_GALAKMECH),		// droid
+	ENUM2STRING(CLASS_MINEMONSTER),
+	ENUM2STRING(CLASS_MONMOTHA),			
+	ENUM2STRING(CLASS_MORGANKATARN),
+	ENUM2STRING(CLASS_MOUSE),			// droid
+	ENUM2STRING(CLASS_MURJJ),
+	ENUM2STRING(CLASS_PRISONER),
+	ENUM2STRING(CLASS_PROBE),			// droid
+	ENUM2STRING(CLASS_PROTOCOL),			// droid
+	ENUM2STRING(CLASS_R2D2),				// droid
+	ENUM2STRING(CLASS_R5D2),				// droid
+	ENUM2STRING(CLASS_REBEL),
+	ENUM2STRING(CLASS_REBORN),
+	ENUM2STRING(CLASS_REELO),
+	ENUM2STRING(CLASS_REMOTE),
+	ENUM2STRING(CLASS_RODIAN),
+	ENUM2STRING(CLASS_SEEKER),			// droid
+	ENUM2STRING(CLASS_SENTRY),
+	ENUM2STRING(CLASS_SHADOWTROOPER),
+	ENUM2STRING(CLASS_SABOTEUR),
+	ENUM2STRING(CLASS_STORMTROOPER),
+	ENUM2STRING(CLASS_SWAMP),
+	ENUM2STRING(CLASS_SWAMPTROOPER),
+	ENUM2STRING(CLASS_NOGHRI),
+	ENUM2STRING(CLASS_TAVION),
+	ENUM2STRING(CLASS_ALORA),
+	ENUM2STRING(CLASS_TRANDOSHAN),
+	ENUM2STRING(CLASS_UGNAUGHT),
+	ENUM2STRING(CLASS_JAWA),
+	ENUM2STRING(CLASS_WEEQUAY),
+	ENUM2STRING(CLASS_TUSKEN),
+	ENUM2STRING(CLASS_BOBAFETT),
+	ENUM2STRING(CLASS_ROCKETTROOPER),
+	ENUM2STRING(CLASS_SABER_DROID),
+	ENUM2STRING(CLASS_PLAYER),
+	ENUM2STRING(CLASS_ASSASSIN_DROID),
+	ENUM2STRING(CLASS_HAZARD_TROOPER),
+	ENUM2STRING(CLASS_VEHICLE),
+	"",	-1
+};
+
+/*
+NPC_ReactionTime
+*/
+//FIXME use grandom in here
+int NPC_ReactionTime ( void ) 
+{
+	return 200 * ( 6 - NPCInfo->stats.reactions );
+}
+
+//
+// parse support routines
+//
+
+qboolean G_ParseLiteral( const char **data, const char *string ) 
+{
+	const char	*token;
+
+	token = COM_ParseExt( data, qtrue );
+	if ( token[0] == 0 ) 
+	{
+		gi.Printf( "unexpected EOF\n" );
+		return qtrue;
+	}
+
+	if ( Q_stricmp( token, string ) ) 
+	{
+		gi.Printf( "required string '%s' missing\n", string );
+		return qtrue;
+	}
+
+	return qfalse;
+}
+
+//
+// NPC parameters file : ext_data/NPCs/*.npc*
+//
+#define MAX_NPC_DATA_SIZE 0x20000
+char	NPCParms[MAX_NPC_DATA_SIZE];
+
+/*
+static rank_t TranslateRankName( const char *name ) 
+
+  Should be used to determine pip bolt-ons
+*/
+static rank_t TranslateRankName( const char *name ) 
+{
+	if ( !Q_stricmp( name, "civilian" ) ) 
+	{
+		return RANK_CIVILIAN;
+	}
+
+	if ( !Q_stricmp( name, "crewman" ) ) 
+	{
+		return RANK_CREWMAN;
+	}
+	
+	if ( !Q_stricmp( name, "ensign" ) ) 
+	{
+		return RANK_ENSIGN;
+	}
+	
+	if ( !Q_stricmp( name, "ltjg" ) ) 
+	{
+		return RANK_LT_JG;
+	}
+	
+	if ( !Q_stricmp( name, "lt" ) ) 
+	{
+		return RANK_LT;
+	}
+	
+	if ( !Q_stricmp( name, "ltcomm" ) ) 
+	{
+		return RANK_LT_COMM;
+	}
+	
+	if ( !Q_stricmp( name, "commander" ) ) 
+	{
+		return RANK_COMMANDER;
+	}
+	
+	if ( !Q_stricmp( name, "captain" ) ) 
+	{
+		return RANK_CAPTAIN;
+	}
+
+	return RANK_CIVILIAN;
+}
+
+#ifdef _XBOX
+extern saber_colors_t TranslateSaberColor( const char *name );
+#else
+saber_colors_t TranslateSaberColor( const char *name ) 
+{
+	if ( !Q_stricmp( name, "red" ) ) 
+	{
+		return SABER_RED;
+	}
+	if ( !Q_stricmp( name, "orange" ) ) 
+	{
+		return SABER_ORANGE;
+	}
+	if ( !Q_stricmp( name, "yellow" ) ) 
+	{
+		return SABER_YELLOW;
+	}
+	if ( !Q_stricmp( name, "green" ) ) 
+	{
+		return SABER_GREEN;
+	}
+	if ( !Q_stricmp( name, "blue" ) ) 
+	{
+		return SABER_BLUE;
+	}
+	if ( !Q_stricmp( name, "purple" ) ) 
+	{
+		return SABER_PURPLE;
+	}
+	if ( !Q_stricmp( name, "random" ) ) 
+	{
+		return ((saber_colors_t)(Q_irand( SABER_ORANGE, SABER_PURPLE )));
+	}
+	return SABER_BLUE;
+}
+#endif
+
+/* static int MethodNameToNumber( const char *name ) {
+	if ( !Q_stricmp( name, "EXPONENTIAL" ) ) {
+		return METHOD_EXPONENTIAL;
+	}
+	if ( !Q_stricmp( name, "LINEAR" ) ) {
+		return METHOD_LINEAR;
+	}
+	if ( !Q_stricmp( name, "LOGRITHMIC" ) ) {
+		return METHOD_LOGRITHMIC;
+	}
+	if ( !Q_stricmp( name, "ALWAYS" ) ) {
+		return METHOD_ALWAYS;
+	}
+	if ( !Q_stricmp( name, "NEVER" ) ) {
+		return METHOD_NEVER;
+	}
+	return -1;
+}
+
+static int ItemNameToNumber( const char *name, int itemType ) {
+//	int		n;
+
+	for ( n = 0; n < bg_numItems; n++ ) {
+		if ( bg_itemlist[n].type != itemType ) {
+			continue;
+		}
+		if ( Q_stricmp( bg_itemlist[n].classname, name ) == 0 ) {
+			return bg_itemlist[n].tag;
+		}
+	}
+	return -1;
+}
+*/
+
+static int MoveTypeNameToEnum( const char *name ) 
+{
+	if(!Q_stricmp("runjump", name))
+	{
+		return MT_RUNJUMP;
+	}
+	else if(!Q_stricmp("walk", name))
+	{
+		return MT_WALK;
+	}
+	else if(!Q_stricmp("flyswim", name))
+	{
+		return MT_FLYSWIM;
+	}
+	else if(!Q_stricmp("static", name))
+	{
+		return MT_STATIC;
+	}
+
+	return MT_STATIC;
+}
+
+extern void CG_RegisterClientRenderInfo(clientInfo_t *ci, renderInfo_t *ri);
+extern void CG_RegisterClientModels (int entityNum);
+extern void CG_RegisterNPCCustomSounds( clientInfo_t *ci );
+//extern void CG_RegisterNPCEffects( team_t team );
+
+//#define CONVENIENT_ANIMATION_FILE_DEBUG_THING
+
+#ifdef CONVENIENT_ANIMATION_FILE_DEBUG_THING
+void SpewDebugStuffToFile(animation_t *bgGlobalAnimations)
+{
+	char BGPAFtext[40000];
+	fileHandle_t f;
+	int i = 0;
+
+	gi.FS_FOpenFile("file_of_debug_stuff_SP.txt", &f, FS_WRITE);
+
+	if (!f)
+	{
+		return;
+	}
+
+	BGPAFtext[0] = 0;
+
+	while (i < MAX_ANIMATIONS)
+	{
+		strcat(BGPAFtext, va("%i %i\n", i, bgGlobalAnimations[i].frameLerp));
+		i++;
+	}
+
+	gi.FS_Write(BGPAFtext, strlen(BGPAFtext), f);
+	gi.FS_FCloseFile(f);
+}
+#endif
+
+int CG_CheckAnimFrameForEventType( animevent_t *animEvents, int keyFrame, animEventType_t eventType, unsigned short modelIndex )
+{
+	for ( int i = 0; i < MAX_ANIM_EVENTS; i++ )
+	{
+		if ( animEvents[i].keyFrame == keyFrame )
+		{//there is an animevent on this frame already
+			if ( animEvents[i].eventType == eventType )
+			{//and it is of the same type
+				if ( animEvents[i].modelOnly == modelIndex )
+				{//and it is for the same model
+					return i;
+				}
+			}
+		}
+	}
+	//nope
+	return -1;
+}
+
+/*
+======================
+ParseAnimationEvtBlock
+======================
+*/
+static void ParseAnimationEvtBlock(int glaIndex, unsigned short modelIndex, const char* aeb_filename, animevent_t *animEvents, animation_t *animations, unsigned char &lastAnimEvent, const char **text_p, bool bIsFrameSkipped)
+{
+	const char		*token;
+	int				num, n, animNum, keyFrame, lowestVal, highestVal, curAnimEvent = 0;
+	animEventType_t	eventType;
+	char			stringData[MAX_QPATH];
+
+	// get past starting bracket
+	while(1) 
+	{
+		token = COM_Parse( text_p );
+		if ( !Q_stricmp( token, "{" ) ) 
+		{
+			break;
+		}
+	}
+
+	//NOTE: instead of a blind increment, increase the index
+	//			this way if we have an event on an anim that already
+	//			has an event of that type, it stomps it
+
+	// read information for each frame
+	while ( 1 ) 
+	{
+		if ( lastAnimEvent >= MAX_ANIM_EVENTS )
+		{
+			CG_Error( "ParseAnimationEvtBlock: number events in file %s > MAX_ANIM_EVENTS(%i)", aeb_filename, MAX_ANIM_EVENTS );
+		}
+		// Get base frame of sequence
+		token = COM_Parse( text_p );
+		if ( !token || !token[0]) 
+		{
+			break;
+		}
+
+		if ( !Q_stricmp( token, "}" ) )		// At end of block 
+		{
+			break;
+		}
+
+		//Compare to same table as animations used 
+		//	so we don't have to use actual numbers for animation first frames,
+		//	just need offsets.
+		//This way when animation numbers change, this table won't have to be updated,
+		//	at least not much.
+		animNum = GetIDForString(animTable, token);
+		if(animNum == -1)
+		{//Unrecognized ANIM ENUM name,
+			Com_Printf(S_COLOR_YELLOW"WARNING: Unknown ANIM %s in file %s\n", token, aeb_filename );
+			//skip this entry
+			SkipRestOfLine( text_p );
+			continue;
+		}
+
+		if ( animations[animNum].numFrames == 0 )
+		{//we don't use this anim
+#ifndef FINAL_BUILD
+			Com_Printf(S_COLOR_YELLOW"WARNING: %s: anim %s not used by this model\n", aeb_filename, token);
+#endif
+			//skip this entry
+			SkipRestOfLine( text_p );
+			continue;
+		}
+
+		token = COM_Parse( text_p );
+		eventType = (animEventType_t)GetIDForString(animEventTypeTable, token);
+		if ( eventType == AEV_NONE || eventType == -1 )
+		{//Unrecognized ANIM EVENT TYPE
+			Com_Printf(S_COLOR_RED"ERROR: Unknown EVENT %s in animEvent file %s\n", token, aeb_filename );
+			continue;
+		}
+
+		// Get offset to frame within sequence
+		token = COM_Parse( text_p );
+		if ( !token ) 
+		{
+			break;
+		}
+
+		keyFrame = atoi( token );
+		if ( bIsFrameSkipped && 
+			(animations[animNum].numFrames>2) // important, else frame 1 gets divided down and becomes frame 0. Carcass & Assimilate also work this way
+			)
+		{
+			keyFrame /= 2;	// if we ever use any other value in frame-skipping we'll have to figure out some way of reading it, since it's not stored anywhere
+		}
+		if(keyFrame >= animations[animNum].numFrames)
+		{
+			Com_Printf(S_COLOR_YELLOW"WARNING: Event out of range on %s in %s\n", GetStringForID(animTable,animNum), aeb_filename );
+			assert(keyFrame < animations[animNum].numFrames);
+			keyFrame = animations[animNum].numFrames-1;	//clamp it
+		}
+
+		//set our start frame
+		keyFrame += animations[animNum].firstFrame;
+
+		//see if this frame already has an event of this type on it, if so, overwrite it
+		curAnimEvent = CG_CheckAnimFrameForEventType( animEvents, keyFrame, eventType, modelIndex );
+		if ( curAnimEvent == -1 )
+		{//this anim frame doesn't already have an event of this type on it
+			curAnimEvent = lastAnimEvent;
+		}
+
+		//now that we know which event index we're going to plug the data into, start doing it
+		animEvents[curAnimEvent].eventType = eventType;
+		assert(keyFrame >= 0 && keyFrame < 65535);	//
+		animEvents[curAnimEvent].keyFrame = keyFrame;
+		animEvents[curAnimEvent].glaIndex = glaIndex;
+		animEvents[curAnimEvent].modelOnly = modelIndex;
+		int tempVal;
+
+		//now read out the proper data based on the type
+		switch ( animEvents[curAnimEvent].eventType )
+		{
+		case AEV_SOUNDCHAN:		//# animID AEV_SOUNDCHAN framenum CHANNEL soundpath randomlow randomhi chancetoplay
+			token = COM_Parse( text_p );
+			if ( !token ) 
+			{
+				break;
+			}
+			if ( stricmp( token, "CHAN_VOICE_ATTEN" ) == 0 )
+			{
+				animEvents[curAnimEvent].eventData[AED_SOUNDCHANNEL] = CHAN_VOICE_ATTEN;
+			}
+			else if ( stricmp( token, "CHAN_VOICE_GLOBAL" ) == 0 )
+			{
+				animEvents[curAnimEvent].eventData[AED_SOUNDCHANNEL] = CHAN_VOICE_GLOBAL;
+			}
+			else if ( stricmp( token, "CHAN_ANNOUNCER" ) == 0 )
+			{
+				animEvents[curAnimEvent].eventData[AED_SOUNDCHANNEL] = CHAN_ANNOUNCER;
+			}
+			else if ( stricmp( token, "CHAN_BODY" ) == 0 )
+			{
+				animEvents[curAnimEvent].eventData[AED_SOUNDCHANNEL] = CHAN_BODY;
+			}
+			else if ( stricmp( token, "CHAN_WEAPON" ) == 0 )
+			{
+				animEvents[curAnimEvent].eventData[AED_SOUNDCHANNEL] = CHAN_WEAPON;
+			}
+			else if ( stricmp( token, "CHAN_VOICE" ) == 0 )
+			{
+				animEvents[curAnimEvent].eventData[AED_SOUNDCHANNEL] = CHAN_VOICE;
+			} 
+			else
+			{
+				animEvents[curAnimEvent].eventData[AED_SOUNDCHANNEL] = CHAN_AUTO;
+			}
+			//fall through to normal sound
+		case AEV_SOUND:			//# animID AEV_SOUND framenum soundpath randomlow randomhi chancetoplay
+			//get soundstring
+			token = COM_Parse( text_p );
+			if ( !token ) 
+			{
+				break;
+			}
+			strcpy(stringData, token);
+			//get lowest value
+			token = COM_Parse( text_p );
+			if ( !token ) 
+			{//WARNING!  BAD TABLE!
+				break;
+			}
+			lowestVal = atoi( token );
+			//get highest value
+			token = COM_Parse( text_p );
+			if ( !token ) 
+			{//WARNING!  BAD TABLE!
+				break;
+			}
+			highestVal = atoi( token );
+			//Now precache all the sounds
+			//NOTE: If we can be assured sequential handles, we can store the first sound index and count
+			//		unfortunately, if these sounds were previously registered, we cannot be guaranteed sequential indices.  Thus an array
+			if(lowestVal && highestVal)
+			{
+				assert(highestVal - lowestVal < MAX_RANDOM_ANIM_SOUNDS);
+				for ( n = lowestVal, num = AED_SOUNDINDEX_START; n <= highestVal && num <= AED_SOUNDINDEX_END; n++, num++ )
+				{
+					animEvents[curAnimEvent].eventData[num] = G_SoundIndex( va( stringData, n ) );//cgi_S_RegisterSound
+				}
+				animEvents[curAnimEvent].eventData[AED_SOUND_NUMRANDOMSNDS] = num - 1;
+			}
+			else
+			{
+				animEvents[curAnimEvent].eventData[AED_SOUNDINDEX_START] = G_SoundIndex( stringData );//cgi_S_RegisterSound
+#if 0 //#ifndef FINAL_BUILD (only meaningfull if using S_RegisterSound
+				if ( !animEvents[curAnimEvent].eventData[AED_SOUNDINDEX_START] )
+				{//couldn't register it - file not found
+					Com_Printf( S_COLOR_RED "ParseAnimationSndBlock: sound %s does not exist (%s)!\n", stringData, *aeb_filename );
+				}
+#endif
+				animEvents[curAnimEvent].eventData[AED_SOUND_NUMRANDOMSNDS] = 0;
+			}
+			//get probability
+			token = COM_Parse( text_p );
+			if ( !token ) 
+			{//WARNING!  BAD TABLE!
+				break;
+			}
+			animEvents[curAnimEvent].eventData[AED_SOUND_PROBABILITY] = atoi( token );
+			break;
+		case AEV_FOOTSTEP:		//# animID AEV_FOOTSTEP framenum footstepType
+			//get footstep type
+			token = COM_Parse( text_p );
+			if ( !token ) 
+			{
+				break;
+			}		
+			animEvents[curAnimEvent].eventData[AED_FOOTSTEP_TYPE] = GetIDForString(footstepTypeTable, token);
+			//get probability
+			token = COM_Parse( text_p );
+			if ( !token ) 
+			{//WARNING!  BAD TABLE!
+				break;
+			}
+			animEvents[curAnimEvent].eventData[AED_FOOTSTEP_PROBABILITY] = atoi( token );
+			break;
+		case AEV_EFFECT:		//# animID AEV_EFFECT framenum effectpath boltName
+			//get effect index
+			token = COM_Parse( text_p );
+			if ( !token ) 
+			{
+				break;
+			}
+			if ( token[0] && Q_stricmp( "special", token ) == 0 )
+			{//special hard-coded effects
+				//let cgame know it's not a real effect
+				animEvents[curAnimEvent].eventData[AED_EFFECTINDEX] = -1;
+				//get the name of it
+				token = COM_Parse( text_p );
+				animEvents[curAnimEvent].stringData = G_NewString( token );
+			}
+			else
+			{//regular effect
+				tempVal = G_EffectIndex(token);
+				assert(tempVal > -32767 && tempVal < 32767);
+				animEvents[curAnimEvent].eventData[AED_EFFECTINDEX] = tempVal;
+				//get bolt index
+				token = COM_Parse( text_p );
+				if ( !token ) 
+				{
+					break;
+				}		
+				if ( Q_stricmp( "none", token ) != 0 && Q_stricmp( "NULL", token ) != 0 )
+				{//actually are specifying a bolt to use
+					animEvents[curAnimEvent].stringData = G_NewString( token );
+				}
+			}
+			//NOTE: this string will later be used to add a bolt and store the index, as below:
+			//animEvent->eventData[AED_BOLTINDEX] = gi.G2API_AddBolt( &cent->gent->ghoul2[cent->gent->playerModel], animEvent->stringData );
+			//get probability
+			token = COM_Parse( text_p );
+			if ( !token ) 
+			{//WARNING!  BAD TABLE!
+				break;
+			}
+			animEvents[curAnimEvent].eventData[AED_EFFECT_PROBABILITY] = atoi( token );
+			break;
+		case AEV_FIRE:			//# animID AEV_FIRE framenum altfire chancetofire
+			//get altfire
+			token = COM_Parse( text_p );
+			if ( !token ) 
+			{//WARNING!  BAD TABLE!
+				break;
+			}
+			animEvents[curAnimEvent].eventData[AED_FIRE_ALT] = atoi( token );
+			//get probability
+			token = COM_Parse( text_p );
+			if ( !token ) 
+			{//WARNING!  BAD TABLE!
+				break;
+			}
+			animEvents[curAnimEvent].eventData[AED_FIRE_PROBABILITY] = atoi( token );
+			break;
+		case AEV_MOVE:			//# animID AEV_MOVE framenum forwardpush rightpush uppush
+			//get forward push
+			token = COM_Parse( text_p );
+			if ( !token ) 
+			{//WARNING!  BAD TABLE!
+				break;
+			}
+			tempVal = atoi(token);
+			assert(tempVal > -32767 && tempVal < 32767);
+			animEvents[curAnimEvent].eventData[AED_MOVE_FWD] = tempVal;
+			//get right push
+			token = COM_Parse( text_p );
+			if ( !token ) 
+			{//WARNING!  BAD TABLE!
+				break;
+			}
+			tempVal = atoi(token);
+			assert(tempVal > -32767 && tempVal < 32767);
+			animEvents[curAnimEvent].eventData[AED_MOVE_RT] = tempVal;
+			//get upwards push
+			token = COM_Parse( text_p );
+			if ( !token ) 
+			{//WARNING!  BAD TABLE!
+				break;
+			}
+			tempVal = atoi(token);
+			assert(tempVal > -32767 && tempVal < 32767);
+			animEvents[curAnimEvent].eventData[AED_MOVE_UP] = tempVal;
+			break;
+		default:				//unknown?
+			SkipRestOfLine( text_p );
+			continue;
+			break;
+		}
+
+		if ( curAnimEvent == lastAnimEvent )
+		{
+			lastAnimEvent++;
+		}
+	}	
+}
+
+
+
+/*
+======================
+G_ParseAnimationEvtFile
+
+Read a configuration file containing animation events
+models/players/kyle/animevents.cfg, etc
+
+This file's presence is not required
+
+======================
+*/
+static
+void G_ParseAnimationEvtFile(int glaIndex, const char* eventsDirectory, int fileIndex, int iRealGLAIndex = -1, bool modelSpecific = false)
+{
+	int				len;
+	const char*		token;
+	char			text[80000];
+	const char*		text_p = text;
+	fileHandle_t	f;
+	char			eventsPath[MAX_QPATH];
+	int				modelIndex = 0;
+
+	assert(fileIndex>=0 && fileIndex<MAX_ANIM_FILES);
+
+	const char *psAnimFileInternalName = (iRealGLAIndex == -1 ? NULL : gi.G2API_GetAnimFileInternalNameIndex( iRealGLAIndex ));
+	bool bIsFrameSkipped = (psAnimFileInternalName && strlen(psAnimFileInternalName)>5 && !stricmp(&psAnimFileInternalName[strlen(psAnimFileInternalName)-5],"_skip"));
+
+	// Open The File, Make Sure It Is Safe
+	//-------------------------------------
+	Com_sprintf(eventsPath, MAX_QPATH, "models/players/%s/animevents.cfg", eventsDirectory);
+	len = cgi_FS_FOpenFile(eventsPath, &f, FS_READ);
+	if ( len <= 0 ) 
+	{//no file
+		return;
+	}
+	if ( len >= sizeof( text ) - 1 ) 
+	{
+		CG_Printf( "File %s too long\n", eventsPath );
+		return;
+	}
+
+	// Read It To The Buffer, Close The File
+	//---------------------------------------
+	cgi_FS_Read( text, len, f );
+	text[len] = 0;
+	cgi_FS_FCloseFile( f );
+
+
+	// Get The Pointers To The Anim Event Arrays
+	//-------------------------------------------
+	animFileSet_t&	afileset		= level.knownAnimFileSets[fileIndex];
+	animevent_t	*legsAnimEvents		= afileset.legsAnimEvents;
+	animevent_t	*torsoAnimEvents	= afileset.torsoAnimEvents;
+	animation_t	*animations			= afileset.animations;
+
+
+	if (modelSpecific)
+	{
+		hstring		modelName(eventsDirectory);
+		modelIndex = modelName.handle();
+	}
+
+
+	// read information for batches of sounds (UPPER or LOWER)
+	while ( 1 ) 
+	{
+		// Get base frame of sequence
+		token = COM_Parse( &text_p );
+		if ( !token || !token[0] ) 
+		{
+			break;
+		}
+
+		//these stomp anything set in the include file (if it's an event of the same type on the same frame)!
+		if ( !Q_stricmp(token,"UPPEREVENTS") )	// A batch of upper events
+		{
+			ParseAnimationEvtBlock(glaIndex, modelIndex, eventsPath, torsoAnimEvents, animations, afileset.torsoAnimEventCount, &text_p, bIsFrameSkipped); 
+		}
+
+		else if ( !Q_stricmp(token,"LOWEREVENTS") )	// A batch of lower events
+		{
+			ParseAnimationEvtBlock(glaIndex, modelIndex, eventsPath, legsAnimEvents, animations, afileset.legsAnimEventCount, &text_p, bIsFrameSkipped); 
+		}
+	}
+}
+
+/*
+======================
+G_ParseAnimationFile
+
+Read a configuration file containing animation coutns and rates
+models/players/visor/animation.cfg, etc
+
+======================
+*/
+qboolean G_ParseAnimationFile(int glaIndex, const char *skeletonName, int fileIndex) 
+{
+	char			text[80000];
+	int				len			= 0;
+	const char		*token		= 0;
+	float			fps			= 0;
+	const char*		text_p		= text;
+	int				animNum		= 0;
+	animation_t*	animations	= level.knownAnimFileSets[fileIndex].animations;
+	char			skeletonPath[MAX_QPATH];
+
+
+	// Read In The File To The Text Buffer, Make Sure Everything Is Safe To Continue
+	//-------------------------------------------------------------------------------
+	Com_sprintf(skeletonPath, MAX_QPATH, "models/players/%s/%s.cfg", skeletonName, skeletonName);
+	len = gi.RE_GetAnimationCFG(skeletonPath, text, sizeof(text));
+	if ( len <= 0 ) 
+	{
+		Com_sprintf(skeletonPath, MAX_QPATH, "models/players/%s/animation.cfg", skeletonName);
+		len = gi.RE_GetAnimationCFG(skeletonPath, text, sizeof(text));
+		if ( len <= 0 ) 
+		{
+			return qfalse;
+		}
+	}
+	if ( len >= sizeof( text ) - 1 ) 
+	{
+		G_Error( "G_ParseAnimationFile: File %s too long\n (%d > %d)", skeletonName, len, sizeof( text ) - 1);
+		return qfalse;
+	}
+
+
+
+	// Read In Each Token
+	//--------------------
+	while(1) 
+	{
+		token = COM_Parse( &text_p );
+
+		// If No Token, We've Reached The End Of The File
+		//------------------------------------------------
+		if ( !token || !token[0]) 
+		{
+			break;
+		}
+
+		// Get The Anim Number Converted From The First Token
+		//----------------------------------------------------
+		animNum = GetIDForString(animTable, token);
+		if(animNum == -1)
+		{
+#ifndef FINAL_BUILD
+			if (strcmp(token,"ROOT"))
+			{
+				Com_Printf(S_COLOR_RED"WARNING: Unknown token %s in %s\n", token, skeletonPath);
+			}
+#endif
+			//unrecognized animation so skip to end of line, 
+			while (token[0])
+			{
+				token = COM_ParseExt( &text_p, qfalse );	//returns empty string when next token is EOL
+			}
+			continue;
+		}
+
+		// GLAIndex
+		//----------
+		animations[animNum].glaIndex = glaIndex;	// Passed Into This Func
+
+		// First Frame
+		//-------------
+		token = COM_Parse( &text_p );
+		if ( !token ) 
+		{
+			break;
+		}
+		assert(atoi(token) >= 0 && atoi(token) < 65536);
+		animations[animNum].firstFrame = atoi( token );
+
+		// Num Frames
+		//------------
+		token = COM_Parse( &text_p );
+		if ( !token ) 
+		{
+			break;
+		}
+		assert(atoi(token) >= 0 && atoi(token) < 65536);
+		animations[animNum].numFrames = atoi( token );
+
+		// Loop Frames
+		//-------------
+		token = COM_Parse( &text_p );
+		if ( !token ) 
+		{
+			break;
+		}
+		assert(atoi(token) >= -1 && atoi(token) < 128);
+		animations[animNum].loopFrames = atoi( token );
+
+		// FPS
+		//-----
+		token = COM_Parse( &text_p );
+		if ( !token ) 
+		{
+			break;
+		}
+		fps = atof( token );
+		if ( fps == 0 ) 
+		{
+			fps = 1;//Don't allow divide by zero error
+		}
+
+		// Calculate Frame Lerp
+		//----------------------
+		int lerp;
+		if ( fps < 0 )
+		{//backwards
+			lerp = floor(1000.0f / fps);
+			assert(lerp > -32767 && lerp < 32767);
+			animations[animNum].frameLerp = lerp;
+			assert(animations[animNum].frameLerp <= 1);
+		}
+		else
+		{
+			lerp = ceil(1000.0f / fps);
+			assert(lerp > -32767 && lerp < 32767);
+			animations[animNum].frameLerp = lerp;
+			assert(animations[animNum].frameLerp >= 1);
+		}
+
+/*		lerp = ceil(1000.0f / Q_fabs(fps));
+		assert(lerp > -32767 && lerp < 32767);
+		animations[animNum].initialLerp = lerp;
+*/
+	}
+
+
+
+
+#ifdef CONVENIENT_ANIMATION_FILE_DEBUG_THING
+	if (strstr(af_filename, "humanoid"))
+	{
+		SpewDebugStuffToFile(animations);
+	}
+#endif
+
+	return qtrue;
+}
+
+
+
+
+////////////////////////////////////////////////////////////////////////
+// G_ParseAnimFileSet
+//
+// This function is responsible for building the animation file and 
+// the animation event file.
+//
+////////////////////////////////////////////////////////////////////////
+int		G_ParseAnimFileSet(const char *skeletonName, const char *modelName=0)
+{
+	int			fileIndex=0;
+
+
+	// Try To Find An Existing Skeleton File For This Animation Set
+	//--------------------------------------------------------------
+	for (fileIndex=0; fileIndex<level.numKnownAnimFileSets; fileIndex++)
+	{
+		if (Q_stricmp(level.knownAnimFileSets[fileIndex].filename, skeletonName)==0)
+		{
+			break;
+		}
+	}
+
+	// Ok, We Don't Already Have One, So Time To Create A New One And Initialize It
+	//------------------------------------------------------------------------------
+	if (fileIndex>=level.numKnownAnimFileSets)
+	{
+		if (level.numKnownAnimFileSets==MAX_ANIM_FILES)
+		{
+			G_Error( "G_ParseAnimFileSet: MAX_ANIM_FILES" );
+			return -1;
+		}
+
+		// Allocate A new File Set, And Get Some Shortcut Pointers
+		//---------------------------------------------------------
+		fileIndex = level.numKnownAnimFileSets;
+		level.numKnownAnimFileSets++;
+		strcpy(level.knownAnimFileSets[fileIndex].filename, skeletonName);
+
+		level.knownAnimFileSets[fileIndex].torsoAnimEventCount = 0;
+		level.knownAnimFileSets[fileIndex].legsAnimEventCount = 0;
+
+		animation_t*	animations		= level.knownAnimFileSets[fileIndex].animations;
+		animevent_t*	legsAnimEvents	= level.knownAnimFileSets[fileIndex].legsAnimEvents;
+		animevent_t*	torsoAnimEvents	= level.knownAnimFileSets[fileIndex].torsoAnimEvents;
+
+		int i, j;
+
+		// Initialize The Frames Information
+		//-----------------------------------
+		for(i=0; i<MAX_ANIMATIONS; i++)
+		{
+			animations[i].firstFrame	= 0;
+			animations[i].numFrames		= 0;
+			animations[i].loopFrames	= -1;
+			animations[i].frameLerp		= 100;
+//			animations[i].initialLerp	= 100;
+			animations[i].glaIndex		= 0;
+		}
+
+		// Initialize Animation Event Array
+		//----------------------------------
+		for(i=0; i<MAX_ANIM_EVENTS; i++)
+		{
+			torsoAnimEvents[i].eventType	= AEV_NONE;		//Type of event
+			legsAnimEvents[i].eventType		= AEV_NONE;
+			torsoAnimEvents[i].keyFrame		= (unsigned short)-1;	//65535 should never be a valid frame... :)
+			legsAnimEvents[i].keyFrame		= (unsigned short)-1;	//Frame to play event on
+			torsoAnimEvents[i].stringData	= NULL;			//we allow storage of one string, temporarily (in case we have to look up an index later, 
+			legsAnimEvents[i].stringData	= NULL;			//then make sure to set stringData to NULL so we only do the look-up once)
+			torsoAnimEvents[i].modelOnly	= 0;
+			legsAnimEvents[i].modelOnly		= 0;
+			torsoAnimEvents[i].glaIndex		= 0;
+			legsAnimEvents[i].glaIndex		= 0;
+
+			
+			for (j=0; j<AED_ARRAY_SIZE; j++)				//Unique IDs, can be soundIndex of sound file to play OR effect index or footstep type, etc.
+			{
+				torsoAnimEvents[i].eventData[j] = -1;
+				legsAnimEvents[i].eventData[j]	= -1;
+			}
+		}
+
+		// Get The Cinematic GLA Name
+		//----------------------------
+		if (stricmp(skeletonName, "_humanoid")==0)
+		{
+			const char* mapName = strrchr( level.mapname, '/' );
+			if (mapName)
+			{
+				mapName++;
+			}
+			else
+			{
+				mapName = level.mapname;
+			}
+			char  skeletonMapName[MAX_QPATH];
+			Com_sprintf(skeletonMapName, MAX_QPATH, "_humanoid_%s", mapName);
+			const int normalGLAIndex = gi.G2API_PrecacheGhoul2Model("models/players/_humanoid/_humanoid.gla");//double check this always comes first!
+
+			// Make Sure To Precache The GLAs (both regular and cinematic), And Remember Their Indicies
+			//------------------------------------------------------------------------------------------
+			G_ParseAnimationFile(0,    skeletonName, fileIndex);
+			G_ParseAnimationEvtFile(0, skeletonName, fileIndex, normalGLAIndex, false/*flag for model specific*/);	
+
+			const int cineGLAIndex = gi.G2API_PrecacheGhoul2Model( va("models/players/%s/%s.gla", skeletonMapName, skeletonMapName));
+			if (cineGLAIndex)
+			{
+				assert(cineGLAIndex == normalGLAIndex+1);
+				if (cineGLAIndex != normalGLAIndex+1)
+				{
+					Com_Error(ERR_DROP,"Cinematic GLA was not loaded after the normal GLA.  Cannot continue safely.");
+				}
+				G_ParseAnimationFile(1,    skeletonMapName, fileIndex);
+				G_ParseAnimationEvtFile(1, skeletonMapName, fileIndex, cineGLAIndex, false/*flag for model specific*/);
+			}
+		}
+		else
+		{
+			// non-humanoid...
+			//
+			// Make Sure To Precache The GLAs (both regular and cinematic), And Remember Their Indicies
+			//------------------------------------------------------------------------------------------
+			G_ParseAnimationFile(0,    skeletonName, fileIndex);
+			G_ParseAnimationEvtFile(0, skeletonName, fileIndex);
+		}
+	}
+
+	// Tack Any Additional Per Model Events
+	//--------------------------------------
+	if (modelName)
+	{
+		// Quick Search To See If We've Already Loaded This Model
+		//--------------------------------------------------------
+		int			curModel=0;
+		hstring		curModelName(modelName);
+		while (curModel<MAX_MODELS_PER_LEVEL && !modelsAlreadyDone[curModel].empty())
+		{
+			if (modelsAlreadyDone[curModel]==curModelName)
+			{
+				return fileIndex;
+			}
+			curModel++;
+		}
+
+		if (curModel == MAX_MODELS_PER_LEVEL)
+		{
+			Com_Error(ERR_DROP, "About to overflow modelsAlreadyDone, increase MAX_MODELS_PER_LEVEL\n");
+		}
+
+		// Nope, Ok, Record The Model As Found And Parse It's Event File
+		//---------------------------------------------------------------
+		modelsAlreadyDone[curModel]=curModelName;
+
+		// Only Do The Event File If The Model Is Not The Same As The Skeleton
+		//---------------------------------------------------------------------
+		if (stricmp(skeletonName, modelName)!=0)
+		{
+			const int iGLAIndexToCheckForSkip = (stricmp(skeletonName, "_humanoid")?-1:gi.G2API_PrecacheGhoul2Model("models/players/_humanoid/_humanoid.gla")); // ;-)
+
+			G_ParseAnimationEvtFile(0, modelName, fileIndex, iGLAIndexToCheckForSkip, true);	
+		}
+	}
+
+	return fileIndex;
+}
+
+#ifdef _XBOX
+// Utility to wipe the modelsAlreadyDone array, as it is never cleared
+void ClearModelsAlreadyDone(void)
+{
+	memset(modelsAlreadyDone, 0, sizeof(modelsAlreadyDone));
+}
+#endif
+
+extern cvar_t	*g_char_model;
+void G_LoadAnimFileSet( gentity_t *ent, const char *pModelName )
+{
+//load its animation config
+	char	animName[MAX_QPATH];
+	char	*GLAName, *modelName;
+	char	*slash = NULL;
+	char	*strippedName;
+	
+	if ( ent->playerModel == -1 )
+	{
+		return;
+	}
+	if ( Q_stricmp( "player", pModelName ) == 0 )
+	{//model is actually stored on console
+		modelName = g_char_model->string;
+	}
+	else
+	{
+		modelName = (char *)pModelName;
+	}
+	//get the location of the animation.cfg
+	GLAName = gi.G2API_GetGLAName( &ent->ghoul2[ent->playerModel] );
+	//now load and parse the animation.cfg, animevents.cfg and set the animFileIndex
+	if ( !GLAName) 
+	{
+		Com_Printf( S_COLOR_RED"Failed find animation file name models/players/%s\n", modelName );
+		strippedName="_humanoid";	//take a guess, maybe it's right?
+	}
+	else
+	{
+		Q_strncpyz( animName, GLAName, sizeof( animName ), qtrue );
+		slash = strrchr( animName, '/' );
+		if ( slash )
+		{
+			*slash = 0;
+		}
+		strippedName = COM_SkipPath( animName );
+	}
+
+	//now load and parse the animation.cfg, animevents.cfg and set the animFileIndex
+	ent->client->clientInfo.animFileIndex = G_ParseAnimFileSet(strippedName, modelName);
+
+	if (ent->client->clientInfo.animFileIndex<0) 
+	{
+		Com_Printf( S_COLOR_RED"Failed to load animation file set models/players/%s/animation.cfg\n", modelName );
+#ifndef FINAL_BUILD
+		Com_Error(ERR_FATAL, "Failed to load animation file set models/players/%s/animation.cfg\n", modelName);
+#endif
+	}
+}
+
+
+void NPC_PrecacheAnimationCFG( const char *NPC_type )
+{
+	char	filename[MAX_QPATH];
+	const char	*token;
+	const char	*value;
+	const char	*p;
+
+	if ( !Q_stricmp( "random", NPC_type ) )
+	{//sorry, can't precache a random just yet
+		return;
+	}
+
+	p = NPCParms;
+	COM_BeginParseSession();
+
+	// look for the right NPC
+	while ( p ) 
+	{
+		token = COM_ParseExt( &p, qtrue );
+		if ( token[0] == 0 )
+			return;
+
+		if ( !Q_stricmp( token, NPC_type ) ) 
+		{
+			break;
+		}
+
+		SkipBracedSection( &p );
+	}
+
+	if ( !p ) 
+	{
+		return;
+	}
+
+	if ( G_ParseLiteral( &p, "{" ) ) 
+	{
+		return;
+	}
+
+	// parse the NPC info block
+	while ( 1 ) 
+	{
+		token = COM_ParseExt( &p, qtrue );
+		if ( !token[0] ) 
+		{
+			gi.Printf( S_COLOR_RED"ERROR: unexpected EOF while parsing '%s'\n", NPC_type );
+			return;
+		}
+
+		if ( !Q_stricmp( token, "}" ) ) 
+		{
+			break;
+		}
+
+		// legsmodel
+		if ( !Q_stricmp( token, "legsmodel" ) ) 
+		{
+			if ( COM_ParseString( &p, &value ) ) 
+			{
+				continue;
+			}
+			//must copy data out of this pointer into a different part of memory because the funcs we're about to call will call COM_ParseExt
+			Q_strncpyz( filename, value, sizeof( filename ), qtrue );
+			G_ParseAnimFileSet( filename );
+			return;
+		}
+
+		// playerModel
+		if ( !Q_stricmp( token, "playerModel" ) ) 
+		{
+			if ( COM_ParseString( &p, &value ) ) 
+			{
+				continue;
+			}
+			char	animName[MAX_QPATH];
+			char	*GLAName;
+			char	*slash = NULL;
+			char	*strippedName;
+
+			int handle = gi.G2API_PrecacheGhoul2Model( va( "models/players/%s/model.glm", value ) );
+			if ( handle > 0 )//FIXME: isn't 0 a valid handle?
+			{
+				GLAName = gi.G2API_GetAnimFileNameIndex( handle );
+				if ( GLAName )
+				{
+					Q_strncpyz( animName, GLAName, sizeof( animName ), qtrue );
+					slash = strrchr( animName, '/' );
+					if ( slash )
+					{
+						*slash = 0;
+					}
+					strippedName = COM_SkipPath( animName );
+
+					//must copy data out of this pointer into a different part of memory because the funcs we're about to call will call COM_ParseExt
+					Q_strncpyz( filename, value, sizeof( filename ), qtrue );
+
+					G_ParseAnimFileSet(strippedName, filename);
+					return;
+				}
+			}
+		}
+	}
+}
+
+extern int NPC_WeaponsForTeam( team_t team, int spawnflags, const char *NPC_type );
+void NPC_PrecacheWeapons( team_t playerTeam, int spawnflags, char *NPCtype )
+{
+	int weapons = NPC_WeaponsForTeam( playerTeam, spawnflags, NPCtype );
+	gitem_t	*item;
+	for ( int curWeap = WP_SABER; curWeap < WP_NUM_WEAPONS; curWeap++ )
+	{
+		if ( (weapons & ( 1 << curWeap )) )
+		{
+			item = FindItemForWeapon( ((weapon_t)(curWeap)) );	//precache the weapon
+			CG_RegisterItemSounds( (item-bg_itemlist) );
+			CG_RegisterItemVisuals( (item-bg_itemlist) );
+			//precache the in-hand/in-world ghoul2 weapon model
+
+			char weaponModel[64];
+			
+			strcpy (weaponModel, weaponData[curWeap].weaponMdl);	
+			if (char *spot = strstr(weaponModel, ".md3") ) {
+				*spot = 0;
+				spot = strstr(weaponModel, "_w");//i'm using the in view weapon array instead of scanning the item list, so put the _w back on
+				if (!spot) {
+					strcat (weaponModel, "_w");
+				}
+				strcat (weaponModel, ".glm");	//and change to ghoul2
+			}
+			gi.G2API_PrecacheGhoul2Model( weaponModel ); // correct way is item->world_model
+		}
+	}
+}
+
+/*
+void NPC_PrecacheByClassName ( char *NPCName )
+
+This runs all the class specific precache functions
+
+*/
+
+extern void NPC_ShadowTrooper_Precache( void );
+extern void NPC_Gonk_Precache( void );
+extern void NPC_Mouse_Precache( void );
+extern void NPC_Seeker_Precache( void );
+extern void NPC_Remote_Precache( void );
+extern void	NPC_R2D2_Precache(void);
+extern void	NPC_R5D2_Precache(void);
+extern void NPC_Probe_Precache(void);
+extern void NPC_Interrogator_Precache(gentity_t *self);
+extern void NPC_MineMonster_Precache( void );
+extern void NPC_Howler_Precache( void );
+extern void NPC_Rancor_Precache( void );
+extern void NPC_MutantRancor_Precache( void );
+extern void NPC_Wampa_Precache( void );
+extern void NPC_ATST_Precache(void);
+extern void NPC_Sentry_Precache(void);
+extern void NPC_Mark1_Precache(void);
+extern void NPC_Mark2_Precache(void);
+extern void NPC_Protocol_Precache( void );
+extern void Boba_Precache( void );
+extern void RT_Precache( void );
+extern void SandCreature_Precache( void );
+extern void NPC_TavionScepter_Precache( void );
+extern void NPC_TavionSithSword_Precache( void );
+extern void NPC_Rosh_Dark_Precache( void );
+extern void NPC_Tusken_Precache( void );
+extern void NPC_Saboteur_Precache( void );
+extern void NPC_CultistDestroyer_Precache( void );
+void NPC_Jawa_Precache( void )
+{
+	for ( int i = 1; i < 7; i++ )
+	{
+		G_SoundIndex( va( "sound/chars/jawa/misc/chatter%d.wav", i ) );
+	}
+	G_SoundIndex( "sound/chars/jawa/misc/ooh-tee-nee.wav" );
+}
+
+void NPC_PrecacheByClassName( const char* type )
+{
+	if (!type || !type[0])
+	{
+		return;
+	}
+
+	if ( !Q_stricmp( "gonk", type))
+	{
+		NPC_Gonk_Precache();
+	}
+	else if ( !Q_stricmp( "mouse", type))
+	{
+		NPC_Mouse_Precache();
+	}
+	else if ( !Q_stricmpn( "r2d2", type, 4))
+	{
+		NPC_R2D2_Precache();
+	}
+	else if ( !Q_stricmp( "atst", type))
+	{
+		NPC_ATST_Precache();
+	}
+	else if ( !Q_stricmpn( "r5d2", type, 4))
+	{
+		NPC_R5D2_Precache();
+	}
+	else if ( !Q_stricmp( "mark1", type))
+	{
+		NPC_Mark1_Precache();
+	}
+	else if ( !Q_stricmp( "mark2", type))
+	{
+		NPC_Mark2_Precache();
+	}
+	else if ( !Q_stricmp( "interrogator", type))
+	{
+		NPC_Interrogator_Precache(NULL);
+	}
+	else if ( !Q_stricmp( "probe", type))
+	{
+		NPC_Probe_Precache();
+	}
+	else if ( !Q_stricmp( "seeker", type))
+	{
+		NPC_Seeker_Precache();
+	}
+	else if ( !Q_stricmpn( "remote", type, 6))
+	{
+		NPC_Remote_Precache();
+	}
+	else if ( !Q_stricmpn( "shadowtrooper", type, 13 ) )
+	{
+		NPC_ShadowTrooper_Precache();
+	}
+	else if ( !Q_stricmp( "minemonster", type ))
+	{
+		NPC_MineMonster_Precache();
+	}
+	else if ( !Q_stricmp( "howler", type ))
+	{
+		NPC_Howler_Precache();
+	}
+	else if ( !Q_stricmp( "rancor", type ))
+	{
+		NPC_Rancor_Precache();
+	}
+	else if ( !Q_stricmp( "mutant_rancor", type ))
+	{
+		NPC_Rancor_Precache();
+		NPC_MutantRancor_Precache();
+	}
+	else if ( !Q_stricmp( "wampa", type ))
+	{
+		NPC_Wampa_Precache();
+	}
+	else if ( !Q_stricmp( "sand_creature", type ))
+	{
+		SandCreature_Precache();
+	}
+	else if ( !Q_stricmp( "sentry", type ))
+	{
+		NPC_Sentry_Precache();
+	}
+	else if ( !Q_stricmp( "protocol", type ))
+	{
+		NPC_Protocol_Precache();
+	}
+	else if ( !Q_stricmp( "boba_fett", type ))
+	{
+		Boba_Precache();
+	}
+	else if ( !Q_stricmp( "rockettrooper2", type ))
+	{
+		RT_Precache();
+	}
+	else if ( !Q_stricmp( "rockettrooper2Officer", type ))
+	{
+		RT_Precache();
+	}
+	else if ( !Q_stricmp( "tavion_scepter", type ))
+	{
+		NPC_TavionScepter_Precache();
+	}
+	else if ( !Q_stricmp( "tavion_sith_sword", type ))
+	{
+		NPC_TavionSithSword_Precache();
+	}
+	else if ( !Q_stricmp( "rosh_dark", type ) )
+	{
+		NPC_Rosh_Dark_Precache();
+	}
+	else if ( !Q_stricmpn( "tusken", type, 6 ) )
+	{
+		NPC_Tusken_Precache();
+	}
+	else if ( !Q_stricmpn( "saboteur", type, 8 ) )
+	{
+		NPC_Saboteur_Precache();
+	}
+	else if ( !Q_stricmp( "cultist_destroyer", type ) )
+	{
+		NPC_CultistDestroyer_Precache();
+	}
+	else if ( !Q_stricmpn( "jawa", type, 4 ) )
+	{
+		NPC_Jawa_Precache();
+	}
+}
+
+
+
+/*
+void NPC_Precache ( char *NPCName )
+
+Precaches NPC skins, tgas and md3s.
+
+*/
+void NPC_Precache ( gentity_t *spawner )
+{
+	clientInfo_t	ci={0};
+	renderInfo_t	ri={0};
+	team_t			playerTeam = TEAM_FREE;
+	const char	*token;
+	const char	*value;
+	const char	*p;
+	char	*patch;
+	char	sound[MAX_QPATH];
+	qboolean	md3Model = qfalse;
+	char	playerModel[MAX_QPATH] = { 0 };
+	char	customSkin[MAX_QPATH];
+
+	if ( !Q_stricmp( "random", spawner->NPC_type ) )
+	{//sorry, can't precache a random just yet
+		return;
+	}
+
+	strcpy(customSkin,"default");
+
+	p = NPCParms;
+	COM_BeginParseSession();
+
+	// look for the right NPC
+	while ( p ) 
+	{
+		token = COM_ParseExt( &p, qtrue );
+		if ( token[0] == 0 )
+			return;
+
+		if ( !Q_stricmp( token, spawner->NPC_type ) ) 
+		{
+			break;
+		}
+
+		SkipBracedSection( &p );
+	}
+
+	if ( !p ) 
+	{
+		return;
+	}
+
+	if ( G_ParseLiteral( &p, "{" ) ) 
+	{
+		return;
+	}
+
+	// parse the NPC info block
+	while ( 1 ) 
+	{
+		token = COM_ParseExt( &p, qtrue );
+		if ( !token[0] ) 
+		{
+			gi.Printf( S_COLOR_RED"ERROR: unexpected EOF while parsing '%s'\n", spawner->NPC_type );
+			return;
+		}
+
+		if ( !Q_stricmp( token, "}" ) ) 
+		{
+			break;
+		}
+
+		// headmodel
+		if ( !Q_stricmp( token, "headmodel" ) ) 
+		{
+			if ( COM_ParseString( &p, &value ) ) 
+			{
+				continue;
+			}
+
+			if(!Q_stricmp("none", value))
+			{
+			}
+			else
+			{
+				Q_strncpyz( ri.headModelName, value, sizeof(ri.headModelName), qtrue);
+			}
+			md3Model = qtrue;
+			continue;
+		}
+		
+		// torsomodel
+		if ( !Q_stricmp( token, "torsomodel" ) ) 
+		{
+			if ( COM_ParseString( &p, &value ) ) 
+			{
+				continue;
+			}
+
+			if(!Q_stricmp("none", value))
+			{
+			}
+			else
+			{
+				Q_strncpyz( ri.torsoModelName, value, sizeof(ri.torsoModelName), qtrue);
+			}
+			md3Model = qtrue;
+			continue;
+		}
+
+		// legsmodel
+		if ( !Q_stricmp( token, "legsmodel" ) ) 
+		{
+			if ( COM_ParseString( &p, &value ) ) 
+			{
+				continue;
+			}
+			Q_strncpyz( ri.legsModelName, value, sizeof(ri.legsModelName), qtrue);			
+			md3Model = qtrue;
+			continue;
+		}
+
+		// playerModel
+		if ( !Q_stricmp( token, "playerModel" ) ) 
+		{
+			if ( COM_ParseString( &p, &value ) ) 
+			{
+				continue;
+			}
+			Q_strncpyz( playerModel, value, sizeof(playerModel), qtrue);			
+			md3Model = qfalse;
+			continue;
+		}
+
+		// customSkin
+		if ( !Q_stricmp( token, "customSkin" ) ) 
+		{
+			if ( COM_ParseString( &p, &value ) ) 
+			{
+				continue;
+			}
+			Q_strncpyz( customSkin, value, sizeof(customSkin), qtrue);			
+			continue;
+		}
+
+		// playerTeam
+		if ( !Q_stricmp( token, "playerTeam" ) ) 
+		{
+			if ( COM_ParseString( &p, &value ) ) 
+			{
+				continue;
+			}
+			playerTeam = (team_t)GetIDForString( TeamTable, token );
+			continue;
+		}
+
+	
+		// snd
+		if ( !Q_stricmp( token, "snd" ) ) {
+			if ( COM_ParseString( &p, &value ) ) {
+				continue;
+			}
+			if ( !(spawner->svFlags&SVF_NO_BASIC_SOUNDS) )
+			{
+				//FIXME: store this in some sound field or parse in the soundTable like the animTable...
+				Q_strncpyz( sound, value, sizeof( sound ) );
+				patch = strstr( sound, "/" );
+				if ( patch ) 
+				{
+					*patch = 0;
+				}
+				ci.customBasicSoundDir = G_NewString( sound );
+			}
+			continue;
+		}
+
+		// sndcombat
+		if ( !Q_stricmp( token, "sndcombat" ) ) {
+			if ( COM_ParseString( &p, &value ) ) {
+				continue;
+			}
+			if ( !(spawner->svFlags&SVF_NO_COMBAT_SOUNDS) )
+			{
+				//FIXME: store this in some sound field or parse in the soundTable like the animTable...
+				Q_strncpyz( sound, value, sizeof( sound ) );
+				patch = strstr( sound, "/" );
+				if ( patch ) 
+				{
+					*patch = 0;
+				}
+				ci.customCombatSoundDir = G_NewString( sound );
+			}
+			continue;
+		}
+		
+		// sndextra
+		if ( !Q_stricmp( token, "sndextra" ) ) {
+			if ( COM_ParseString( &p, &value ) ) {
+				continue;
+			}
+			if ( !(spawner->svFlags&SVF_NO_EXTRA_SOUNDS) )
+			{
+				//FIXME: store this in some sound field or parse in the soundTable like the animTable...
+				Q_strncpyz( sound, value, sizeof( sound ) );
+				patch = strstr( sound, "/" );
+				if ( patch ) 
+				{
+					*patch = 0;
+				}
+				ci.customExtraSoundDir = G_NewString( sound );
+			}
+			continue;
+		}
+
+		// sndjedi
+		if ( !Q_stricmp( token, "sndjedi" ) ) {
+			if ( COM_ParseString( &p, &value ) ) {
+				continue;
+			}
+			if ( !(spawner->svFlags&SVF_NO_EXTRA_SOUNDS) )
+			{
+				//FIXME: store this in some sound field or parse in the soundTable like the animTable...
+				Q_strncpyz( sound, value, sizeof( sound ) );
+				patch = strstr( sound, "/" );
+				if ( patch ) 
+				{
+					*patch = 0;
+				}
+				ci.customJediSoundDir = G_NewString( sound );
+			}
+			continue;
+		}
+
+		//cache weapons
+		if ( !Q_stricmp( token, "weapon" ) )
+		{
+			if ( COM_ParseString( &p, &value ) ) 
+			{
+				continue;
+			}
+			int weap = GetIDForString( WPTable, value );
+			if ( weap >= WP_NONE && weap < WP_NUM_WEAPONS )
+			{
+				if ( weap > WP_NONE )
+				{
+					RegisterItem( FindItemForWeapon( (weapon_t)(weap) ) );	//precache the weapon
+				}
+			}
+			continue;
+		}
+		//cache sabers
+		//saber name
+		if ( !Q_stricmp( token, "saber" ) ) 
+		{
+			if ( COM_ParseString( &p, &value ) ) 
+			{
+				continue;
+			}
+			char *saberName = G_NewString( value );
+			saberInfo_t saber;
+			WP_SaberParseParms( saberName, &saber );
+			if ( saber.model && saber.model[0] )
+			{
+				G_ModelIndex( saber.model );
+			}
+			if ( saber.skin && saber.skin[0] )
+			{
+				gi.RE_RegisterSkin( saber.skin );
+				G_SkinIndex( saber.skin );
+			}
+			continue;
+		}
+		
+		//second saber name
+		if ( !Q_stricmp( token, "saber2" ) ) 
+		{
+			if ( COM_ParseString( &p, &value ) ) 
+			{
+				continue;
+			}
+			char *saberName = G_NewString( value );
+			saberInfo_t saber;
+			WP_SaberParseParms( saberName, &saber );
+			if ( saber.model && saber.model[0] )
+			{
+				G_ModelIndex( saber.model );
+			}
+			if ( saber.skin && saber.skin[0] )
+			{
+				gi.RE_RegisterSkin( saber.skin );
+				G_SkinIndex( saber.skin );
+			}
+			continue;
+		}
+	}
+
+	if ( md3Model )
+	{
+		CG_RegisterClientRenderInfo( &ci, &ri );
+	}
+	else
+	{
+		char	skinName[MAX_QPATH];
+		//precache ghoul2 model
+		gi.G2API_PrecacheGhoul2Model( va( "models/players/%s/model.glm", playerModel ) );
+		//precache skin
+		if (strchr(customSkin, '|'))
+		{//three part skin
+			Com_sprintf( skinName, sizeof( skinName ), "models/players/%s/|%s", playerModel, customSkin );
+		}
+		else
+		{//standard skin
+			Com_sprintf( skinName, sizeof( skinName ), "models/players/%s/model_%s.skin", playerModel, customSkin );
+		}
+		// lets see if it's out there
+		gi.RE_RegisterSkin( skinName );
+	}
+
+	//precache this NPC's possible weapons
+	NPC_PrecacheWeapons( playerTeam, spawner->spawnflags, spawner->NPC_type );
+
+	// Anything else special about them
+	NPC_PrecacheByClassName( spawner->NPC_type );
+
+	CG_RegisterNPCCustomSounds( &ci );
+	//CG_RegisterNPCEffects( playerTeam );
+	//FIXME: Look for a "sounds" directory and precache death, pain, alert sounds
+}
+
+void NPC_BuildRandom( gentity_t *NPC )
+{
+}
+
+extern void G_MatchPlayerWeapon( gentity_t *ent );
+extern void G_InitPlayerFromCvars( gentity_t *ent );
+extern void G_SetG2PlayerModel( gentity_t * const ent, const char *modelName, const char *customSkin, const char *surfOff, const char *surfOn );
+qboolean NPC_ParseParms( const char *NPCName, gentity_t *NPC ) 
+{
+	const char	*token;
+	const char	*value;
+	const char	*p;
+	int		n;
+	float	f;
+	char	*patch;
+	char	sound[MAX_QPATH];
+	char	playerModel[MAX_QPATH];
+	char	customSkin[MAX_QPATH];
+	clientInfo_t	*ci = &NPC->client->clientInfo;
+	renderInfo_t	*ri = &NPC->client->renderInfo;
+	gNPCstats_t		*stats = NULL;
+	qboolean	md3Model = qtrue;
+	char	surfOff[1024]={0};
+	char	surfOn[1024]={0};
+	qboolean parsingPlayer = qfalse;
+
+	strcpy(customSkin,"default");
+	if ( !NPCName || !NPCName[0]) 
+	{
+		NPCName = "Player";
+	}
+
+	if ( !NPC->s.number && NPC->client != NULL )
+	{//player, only want certain data
+		parsingPlayer = qtrue;
+	}
+
+	if ( NPC->NPC )
+	{
+		stats = &NPC->NPC->stats;
+/*
+	NPC->NPC->allWeaponOrder[0]	= WP_BRYAR_PISTOL;
+	NPC->NPC->allWeaponOrder[1]	= WP_SABER;
+	NPC->NPC->allWeaponOrder[2]	= WP_IMOD;
+	NPC->NPC->allWeaponOrder[3]	= WP_SCAVENGER_RIFLE;
+	NPC->NPC->allWeaponOrder[4]	= WP_TRICORDER;
+	NPC->NPC->allWeaponOrder[6]	= WP_NONE;
+	NPC->NPC->allWeaponOrder[6]	= WP_NONE;
+	NPC->NPC->allWeaponOrder[7]	= WP_NONE;
+*/
+		// fill in defaults
+		stats->sex			= SEX_MALE;
+		stats->aggression	= 3;
+		stats->aim			= 3;
+		stats->earshot		= 1024;
+		stats->evasion		= 3;
+		stats->hfov			= 90;
+		stats->intelligence	= 3;
+		stats->move			= 3;
+		stats->reactions	= 3;
+		stats->vfov			= 60;
+		stats->vigilance	= 0.1f;
+		stats->visrange		= 1024;
+		if (g_entities[ENTITYNUM_WORLD].max_health && stats->visrange>g_entities[ENTITYNUM_WORLD].max_health)
+		{
+			stats->visrange	= g_entities[ENTITYNUM_WORLD].max_health;
+		}
+		stats->health		= 0;
+
+		stats->yawSpeed		= 90;
+		stats->walkSpeed	= 90;
+		stats->runSpeed		= 300;
+		stats->acceleration	= 15;//Increase/descrease speed this much per frame (20fps)
+	}
+	else
+	{
+		stats = NULL;
+	}
+
+	Q_strncpyz( ci->name, NPCName, sizeof( ci->name ) );
+	
+	NPC->playerModel = -1;
+	
+	//Set defaults
+	//FIXME: should probably put default torso and head models, but what about enemies
+	//that don't have any- like Stasis?
+	//Q_strncpyz( ri->headModelName,	DEFAULT_HEADMODEL,  sizeof(ri->headModelName),	qtrue);
+	//Q_strncpyz( ri->torsoModelName, DEFAULT_TORSOMODEL, sizeof(ri->torsoModelName),	qtrue);
+	//Q_strncpyz( ri->legsModelName,	DEFAULT_LEGSMODEL,  sizeof(ri->legsModelName),	qtrue);
+	ri->headModelName[0] = 0;
+	ri->torsoModelName[0]= 0;
+	ri->legsModelName[0] =0;
+
+	ri->headYawRangeLeft = 80;
+	ri->headYawRangeRight = 80;
+	ri->headPitchRangeUp = 45;
+	ri->headPitchRangeDown = 45;
+	ri->torsoYawRangeLeft = 60;
+	ri->torsoYawRangeRight = 60;
+	ri->torsoPitchRangeUp = 30;
+	ri->torsoPitchRangeDown = 50;
+
+	VectorCopy(playerMins, NPC->mins);
+	VectorCopy(playerMaxs, NPC->maxs);
+	NPC->client->crouchheight = CROUCH_MAXS_2;
+	NPC->client->standheight = DEFAULT_MAXS_2;
+
+	NPC->client->moveType		= MT_RUNJUMP;
+
+	NPC->client->dismemberProbHead = 100;
+	NPC->client->dismemberProbArms = 100;
+	NPC->client->dismemberProbHands = 100;
+	NPC->client->dismemberProbWaist = 100;
+	NPC->client->dismemberProbLegs = 100;
+
+	NPC->s.modelScale[0] = NPC->s.modelScale[1] = NPC->s.modelScale[2] = 1.0f;
+
+	*(int*)ri->customRGBA=-1;
+
+	if ( !Q_stricmp( "random", NPCName ) )
+	{//Randomly assemble an NPC
+		NPC_BuildRandom( NPC );
+	}
+	else
+	{
+		p = NPCParms;
+		COM_BeginParseSession();
+
+		// look for the right NPC
+		while ( p ) 
+		{
+			token = COM_ParseExt( &p, qtrue );
+			if ( token[0] == 0 )
+			{
+				return qfalse;
+			}
+
+			if ( !Q_stricmp( token, NPCName ) ) 
+			{
+				break;
+			}
+
+			SkipBracedSection( &p );
+		}
+		if ( !p ) 
+		{
+			return qfalse;
+		}
+
+		if ( G_ParseLiteral( &p, "{" ) ) 
+		{
+			return qfalse;
+		}
+			
+		// parse the NPC info block
+		while ( 1 ) 
+		{
+			token = COM_ParseExt( &p, qtrue );
+			if ( !token[0] ) 
+			{
+				gi.Printf( S_COLOR_RED"ERROR: unexpected EOF while parsing '%s'\n", NPCName );
+				return qfalse;
+			}
+
+			if ( !Q_stricmp( token, "}" ) ) 
+			{
+				break;
+			}
+	//===MODEL PROPERTIES===========================================================
+			// custom color
+			if ( !Q_stricmp( token, "customRGBA" ) ) 
+			{
+				if ( COM_ParseString( &p, &value ) ) 
+				{
+					continue;
+				}
+				
+				if ( !Q_stricmp( value, "random") )
+				{
+					ri->customRGBA[0]=Q_irand(0,255);
+					ri->customRGBA[1]=Q_irand(0,255);
+					ri->customRGBA[2]=Q_irand(0,255);
+					ri->customRGBA[3]=255;
+				} 
+				else if ( !Q_stricmp( value, "random1") )
+				{
+					ri->customRGBA[3]=255;
+					switch (Q_irand(0,5))
+					{
+					default:
+					case 0:
+						ri->customRGBA[0]=127;
+						ri->customRGBA[1]=153;
+						ri->customRGBA[2]=255;
+						break;
+					case 1:
+						ri->customRGBA[0]=177;
+						ri->customRGBA[1]=29;
+						ri->customRGBA[2]=13;
+						break;
+					case 2:
+						ri->customRGBA[0]=47;
+						ri->customRGBA[1]=90;
+						ri->customRGBA[2]=40;
+						break;
+					case 3:
+						ri->customRGBA[0]=181;
+						ri->customRGBA[1]=207;
+						ri->customRGBA[2]=255;
+						break;
+					case 4:
+						ri->customRGBA[0]=138;
+						ri->customRGBA[1]=83;
+						ri->customRGBA[2]=0;
+						break;
+					case 5:
+						ri->customRGBA[0]=254;
+						ri->customRGBA[1]=199;
+						ri->customRGBA[2]=14;
+						break;
+					}
+				} 
+				else if ( !Q_stricmp( value, "jedi_hf" ) )
+				{
+					ri->customRGBA[3]=255;
+					switch (Q_irand(0,7))
+					{
+					default:
+					case 0://red1
+						ri->customRGBA[0]=165;
+						ri->customRGBA[1]=48;
+						ri->customRGBA[2]=21;
+						break;
+					case 1://yellow1
+						ri->customRGBA[0]=254;
+						ri->customRGBA[1]=230;
+						ri->customRGBA[2]=132;
+						break;
+					case 2://bluegray
+						ri->customRGBA[0]=181;
+						ri->customRGBA[1]=207;
+						ri->customRGBA[2]=255;
+						break;
+					case 3://pink
+						ri->customRGBA[0]=233;
+						ri->customRGBA[1]=183;
+						ri->customRGBA[2]=208;
+						break;
+					case 4://lt blue
+						ri->customRGBA[0]=161;
+						ri->customRGBA[1]=226;
+						ri->customRGBA[2]=240;
+						break;
+					case 5://blue
+						ri->customRGBA[0]=101;
+						ri->customRGBA[1]=159;
+						ri->customRGBA[2]=255;
+						break;
+					case 6://orange
+						ri->customRGBA[0]=255;
+						ri->customRGBA[1]=157;
+						ri->customRGBA[2]=114;
+						break;
+					case 7://violet
+						ri->customRGBA[0]=216;
+						ri->customRGBA[1]=160;
+						ri->customRGBA[2]=255;
+						break;
+					}
+				}
+				else if ( !Q_stricmp( value, "jedi_hm" ) )
+				{
+					ri->customRGBA[3]=255;
+					switch (Q_irand(0,7))
+					{
+					default:
+					case 0://yellow
+						ri->customRGBA[0]=252;
+						ri->customRGBA[1]=243;
+						ri->customRGBA[2]=180;
+						break;
+					case 1://blue
+						ri->customRGBA[0]=69;
+						ri->customRGBA[1]=109;
+						ri->customRGBA[2]=255;
+						break;
+					case 2://gold
+						ri->customRGBA[0]=254;
+						ri->customRGBA[1]=197;
+						ri->customRGBA[2]=73;
+						break;
+					case 3://orange
+						ri->customRGBA[0]=178;
+						ri->customRGBA[1]=78;
+						ri->customRGBA[2]=18;
+						break;
+					case 4://bluegreen
+						ri->customRGBA[0]=112;
+						ri->customRGBA[1]=153;
+						ri->customRGBA[2]=161;
+						break;
+					case 5://blue2
+						ri->customRGBA[0]=123;
+						ri->customRGBA[1]=182;
+						ri->customRGBA[2]=255;
+						break;
+					case 6://green2
+						ri->customRGBA[0]=0;
+						ri->customRGBA[1]=88;
+						ri->customRGBA[2]=105;
+						break;
+					case 7://violet
+						ri->customRGBA[0]=138;
+						ri->customRGBA[1]=0;
+						ri->customRGBA[2]=0;
+						break;
+					}
+				}
+				else if ( !Q_stricmp( value, "jedi_kdm" ) )
+				{
+					ri->customRGBA[3]=255;
+					switch (Q_irand(0,8))
+					{
+					default:
+					case 0://blue
+						ri->customRGBA[0]=85;
+						ri->customRGBA[1]=120;
+						ri->customRGBA[2]=255;
+						break;
+					case 1://violet
+						ri->customRGBA[0]=173;
+						ri->customRGBA[1]=142;
+						ri->customRGBA[2]=219;
+						break;
+					case 2://brown1
+						ri->customRGBA[0]=254;
+						ri->customRGBA[1]=197;
+						ri->customRGBA[2]=73;
+						break;
+					case 3://orange
+						ri->customRGBA[0]=138;
+						ri->customRGBA[1]=83;
+						ri->customRGBA[2]=0;
+						break;
+					case 4://gold
+						ri->customRGBA[0]=254;
+						ri->customRGBA[1]=199;
+						ri->customRGBA[2]=14;
+						break;
+					case 5://blue2
+						ri->customRGBA[0]=68;
+						ri->customRGBA[1]=194;
+						ri->customRGBA[2]=217;
+						break;
+					case 6://red1
+						ri->customRGBA[0]=170;
+						ri->customRGBA[1]=3;
+						ri->customRGBA[2]=30;
+						break;
+					case 7://yellow1
+						ri->customRGBA[0]=225;
+						ri->customRGBA[1]=226;
+						ri->customRGBA[2]=144;
+						break;
+					case 8://violet2
+						ri->customRGBA[0]=167;
+						ri->customRGBA[1]=202;
+						ri->customRGBA[2]=255;
+						break;
+					}
+				}
+				else if ( !Q_stricmp( value, "jedi_rm" ) )
+				{
+					ri->customRGBA[3]=255;
+					switch (Q_irand(0,8))
+					{
+					default:
+					case 0://blue
+						ri->customRGBA[0]=127;
+						ri->customRGBA[1]=153;
+						ri->customRGBA[2]=255;
+						break;
+					case 1://green1
+						ri->customRGBA[0]=208;
+						ri->customRGBA[1]=249;
+						ri->customRGBA[2]=85;
+						break;
+					case 2://blue2
+						ri->customRGBA[0]=181;
+						ri->customRGBA[1]=207;
+						ri->customRGBA[2]=255;
+						break;
+					case 3://gold
+						ri->customRGBA[0]=138;
+						ri->customRGBA[1]=83;
+						ri->customRGBA[2]=0;
+						break;
+					case 4://gold
+						ri->customRGBA[0]=224;
+						ri->customRGBA[1]=171;
+						ri->customRGBA[2]=44;
+						break;
+					case 5://green2
+						ri->customRGBA[0]=49;
+						ri->customRGBA[1]=155;
+						ri->customRGBA[2]=131;
+						break;
+					case 6://red1
+						ri->customRGBA[0]=163;
+						ri->customRGBA[1]=79;
+						ri->customRGBA[2]=17;
+						break;
+					case 7://violet2
+						ri->customRGBA[0]=148;
+						ri->customRGBA[1]=104;
+						ri->customRGBA[2]=228;
+						break;
+					case 8://green3
+						ri->customRGBA[0]=138;
+						ri->customRGBA[1]=136;
+						ri->customRGBA[2]=0;
+						break;
+					}
+				}
+				else if ( !Q_stricmp( value, "jedi_tf" ) )
+				{
+					ri->customRGBA[3]=255;
+					switch (Q_irand(0,5))
+					{
+					default:
+					case 0://green1
+						ri->customRGBA[0]=255;
+						ri->customRGBA[1]=235;
+						ri->customRGBA[2]=100;
+						break;
+					case 1://blue1
+						ri->customRGBA[0]=62;
+						ri->customRGBA[1]=155;
+						ri->customRGBA[2]=255;
+						break;
+					case 2://red1
+						ri->customRGBA[0]=255;
+						ri->customRGBA[1]=110;
+						ri->customRGBA[2]=120;
+						break;
+					case 3://purple
+						ri->customRGBA[0]=180;
+						ri->customRGBA[1]=150;
+						ri->customRGBA[2]=255;
+						break;
+					case 4://flesh
+						ri->customRGBA[0]=255;
+						ri->customRGBA[1]=200;
+						ri->customRGBA[2]=212;
+						break;
+					case 5://base
+						ri->customRGBA[0]=255;
+						ri->customRGBA[1]=255;
+						ri->customRGBA[2]=255;
+						break;
+					}
+				}
+				else if ( !Q_stricmp( value, "jedi_zf" ) )
+				{
+					ri->customRGBA[3]=255;
+					switch (Q_irand(0,7))
+					{
+					default:
+					case 0://red1
+						ri->customRGBA[0]=204;
+						ri->customRGBA[1]=19;
+						ri->customRGBA[2]=21;
+						break;
+					case 1://orange1
+						ri->customRGBA[0]=255;
+						ri->customRGBA[1]=107;
+						ri->customRGBA[2]=40;
+						break;
+					case 2://pink1
+						ri->customRGBA[0]=255;
+						ri->customRGBA[1]=148;
+						ri->customRGBA[2]=155;
+						break;
+					case 3://gold
+						ri->customRGBA[0]=255;
+						ri->customRGBA[1]=164;
+						ri->customRGBA[2]=59;
+						break;
+					case 4://violet1
+						ri->customRGBA[0]=216;
+						ri->customRGBA[1]=160;
+						ri->customRGBA[2]=255;
+						break;
+					case 5://blue1
+						ri->customRGBA[0]=101;
+						ri->customRGBA[1]=159;
+						ri->customRGBA[2]=255;
+						break;
+					case 6://blue2
+						ri->customRGBA[0]=161;
+						ri->customRGBA[1]=226;
+						ri->customRGBA[2]=240;
+						break;
+					case 7://blue3
+						ri->customRGBA[0]=37;
+						ri->customRGBA[1]=155;
+						ri->customRGBA[2]=181;
+						break;
+					}
+				}
+				else 
+				{
+					ri->customRGBA[0]=atoi(value);
+					
+					if ( COM_ParseInt( &p, &n ) ) 
+					{
+						continue;
+					}
+					ri->customRGBA[1]=n;
+					
+					if ( COM_ParseInt( &p, &n ) ) 
+					{
+						continue;
+					}
+					ri->customRGBA[2]=n;
+					
+					if ( COM_ParseInt( &p, &n ) ) 
+					{
+						continue;
+					}
+					ri->customRGBA[3]=n;
+				}
+				continue;
+			}
+
+			// headmodel
+			if ( !Q_stricmp( token, "headmodel" ) ) 
+			{
+				if ( COM_ParseString( &p, &value ) ) 
+				{
+					continue;
+				}
+
+				if(!Q_stricmp("none", value))
+				{
+					ri->headModelName[0] = NULL;
+					//Zero the head clamp range so the torso & legs don't lag behind
+					ri->headYawRangeLeft = 
+					ri->headYawRangeRight = 
+					ri->headPitchRangeUp = 
+					ri->headPitchRangeDown = 0;
+				}
+				else
+				{
+					Q_strncpyz( ri->headModelName, value, sizeof(ri->headModelName), qtrue);
+				}
+				continue;
+			}
+			
+			// torsomodel
+			if ( !Q_stricmp( token, "torsomodel" ) ) 
+			{
+				if ( COM_ParseString( &p, &value ) ) 
+				{
+					continue;
+				}
+
+				if(!Q_stricmp("none", value))
+				{
+					ri->torsoModelName[0] = NULL;
+					//Zero the torso clamp range so the legs don't lag behind
+					ri->torsoYawRangeLeft = 
+					ri->torsoYawRangeRight = 
+					ri->torsoPitchRangeUp = 
+					ri->torsoPitchRangeDown = 0;
+				}
+				else
+				{
+					Q_strncpyz( ri->torsoModelName, value, sizeof(ri->torsoModelName), qtrue);
+				}
+				continue;
+			}
+
+			// legsmodel
+			if ( !Q_stricmp( token, "legsmodel" ) ) 
+			{
+				if ( COM_ParseString( &p, &value ) ) 
+				{
+					continue;
+				}
+				Q_strncpyz( ri->legsModelName, value, sizeof(ri->legsModelName), qtrue);			
+				//Need to do this here to get the right index
+				ci->animFileIndex = G_ParseAnimFileSet(ri->legsModelName);
+				continue;
+			}
+
+			// playerModel
+			if ( !Q_stricmp( token, "playerModel" ) ) 
+			{
+				if ( COM_ParseString( &p, &value ) ) 
+				{
+					continue;
+				}
+				Q_strncpyz( playerModel, value, sizeof(playerModel), qtrue);			
+				md3Model = qfalse;
+				continue;
+			}
+			
+			// customSkin
+			if ( !Q_stricmp( token, "customSkin" ) ) 
+			{
+				if ( COM_ParseString( &p, &value ) ) 
+				{
+					continue;
+				}
+				Q_strncpyz( customSkin, value, sizeof(customSkin), qtrue);			
+				continue;
+			}
+
+			// surfOff
+			if ( !Q_stricmp( token, "surfOff" ) ) 
+			{
+				if ( COM_ParseString( &p, &value ) ) 
+				{
+					continue;
+				}
+				if ( surfOff[0] )
+				{
+					strncat( (char *)surfOff, ",", sizeof(surfOff) );
+					strncat( (char *)surfOff, value, sizeof(surfOff) );
+				}
+				else
+				{
+					Q_strncpyz( surfOff, value, sizeof(surfOff), qtrue);
+				}
+				continue;
+			}
+			
+			// surfOn
+			if ( !Q_stricmp( token, "surfOn" ) ) 
+			{
+				if ( COM_ParseString( &p, &value ) ) 
+				{
+					continue;
+				}
+				if ( surfOn[0] )
+				{
+					strncat( (char *)surfOn, ",", sizeof(surfOn) );
+					strncat( (char *)surfOn, value, sizeof(surfOn) );
+				}
+				else
+				{
+					Q_strncpyz( surfOn, value, sizeof(surfOn), qtrue);
+				}
+				continue;
+			}
+			
+			//headYawRangeLeft
+			if ( !Q_stricmp( token, "headYawRangeLeft" ) ) 
+			{
+				if ( COM_ParseInt( &p, &n ) ) 
+				{
+					SkipRestOfLine( &p );
+					continue;
+				}
+				if ( n < 0 ) 
+				{
+					gi.Printf( S_COLOR_YELLOW"WARNING: bad %s in NPC '%s'\n", token, NPCName );
+					continue;
+				}
+				ri->headYawRangeLeft = n;
+				continue;
+			}
+
+			//headYawRangeRight
+			if ( !Q_stricmp( token, "headYawRangeRight" ) ) 
+			{
+				if ( COM_ParseInt( &p, &n ) ) 
+				{
+					SkipRestOfLine( &p );
+					continue;
+				}
+				if ( n < 0 ) 
+				{
+					gi.Printf( S_COLOR_YELLOW"WARNING: bad %s in NPC '%s'\n", token, NPCName );
+					continue;
+				}
+				ri->headYawRangeRight = n;
+				continue;
+			}
+
+			//headPitchRangeUp
+			if ( !Q_stricmp( token, "headPitchRangeUp" ) ) 
+			{
+				if ( COM_ParseInt( &p, &n ) ) 
+				{
+					SkipRestOfLine( &p );
+					continue;
+				}
+				if ( n < 0 ) 
+				{
+					gi.Printf( S_COLOR_YELLOW"WARNING: bad %s in NPC '%s'\n", token, NPCName );
+					continue;
+				}
+				ri->headPitchRangeUp = n;
+				continue;
+			}
+			
+			//headPitchRangeDown
+			if ( !Q_stricmp( token, "headPitchRangeDown" ) ) 
+			{
+				if ( COM_ParseInt( &p, &n ) ) 
+				{
+					SkipRestOfLine( &p );
+					continue;
+				}
+				if ( n < 0 ) 
+				{
+					gi.Printf( S_COLOR_YELLOW"WARNING: bad %s in NPC '%s'\n", token, NPCName );
+					continue;
+				}
+				ri->headPitchRangeDown = n;
+				continue;
+			}
+
+			//torsoYawRangeLeft
+			if ( !Q_stricmp( token, "torsoYawRangeLeft" ) ) 
+			{
+				if ( COM_ParseInt( &p, &n ) ) 
+				{
+					SkipRestOfLine( &p );
+					continue;
+				}
+				if ( n < 0 ) 
+				{
+					gi.Printf( S_COLOR_YELLOW"WARNING: bad %s in NPC '%s'\n", token, NPCName );
+					continue;
+				}
+				ri->torsoYawRangeLeft = n;
+				continue;
+			}
+
+			//torsoYawRangeRight
+			if ( !Q_stricmp( token, "torsoYawRangeRight" ) ) 
+			{
+				if ( COM_ParseInt( &p, &n ) ) 
+				{
+					SkipRestOfLine( &p );
+					continue;
+				}
+				if ( n < 0 ) 
+				{
+					gi.Printf( S_COLOR_YELLOW"WARNING: bad %s in NPC '%s'\n", token, NPCName );
+					continue;
+				}
+				ri->torsoYawRangeRight = n;
+				continue;
+			}
+
+			//torsoPitchRangeUp
+			if ( !Q_stricmp( token, "torsoPitchRangeUp" ) ) 
+			{
+				if ( COM_ParseInt( &p, &n ) ) 
+				{
+					SkipRestOfLine( &p );
+					continue;
+				}
+				if ( n < 0 ) 
+				{
+					gi.Printf( S_COLOR_YELLOW"WARNING: bad %s in NPC '%s'\n", token, NPCName );
+					continue;
+				}
+				ri->torsoPitchRangeUp = n;
+				continue;
+			}
+
+			//torsoPitchRangeDown
+			if ( !Q_stricmp( token, "torsoPitchRangeDown" ) ) 
+			{
+				if ( COM_ParseInt( &p, &n ) ) 
+				{
+					SkipRestOfLine( &p );
+					continue;
+				}
+				if ( n < 0 ) 
+				{
+					gi.Printf( S_COLOR_YELLOW"WARNING: bad %s in NPC '%s'\n", token, NPCName );
+					continue;
+				}
+				ri->torsoPitchRangeDown = n;
+				continue;
+			}
+
+			// Uniform XYZ scale
+			if ( !Q_stricmp( token, "scale" ) ) 
+			{
+				if ( COM_ParseInt( &p, &n ) ) 
+				{
+					SkipRestOfLine( &p );
+					continue;
+				}
+				if ( n < 0 ) 
+				{
+					gi.Printf(  "bad %s in NPC '%s'\n", token, NPCName );
+					continue;
+				}
+				if (n != 100)
+				{
+					NPC->s.modelScale[0] = NPC->s.modelScale[1] = NPC->s.modelScale[2] = n/100.0f;
+				}
+				continue;
+			}
+
+			//X scale
+			if ( !Q_stricmp( token, "scaleX" ) ) 
+			{
+				if ( COM_ParseInt( &p, &n ) ) 
+				{
+					SkipRestOfLine( &p );
+					continue;
+				}
+				if ( n < 0 ) 
+				{
+					gi.Printf(  "bad %s in NPC '%s'\n", token, NPCName );
+					continue;
+				}
+				if (n != 100)
+				{
+					NPC->s.modelScale[0] = n/100.0f;
+				}
+				continue;
+			}
+
+			//Y scale
+			if ( !Q_stricmp( token, "scaleY" ) ) 
+			{
+				if ( COM_ParseInt( &p, &n ) ) 
+				{
+					SkipRestOfLine( &p );
+					continue;
+				}
+				if ( n < 0 ) 
+				{
+					gi.Printf(  "bad %s in NPC '%s'\n", token, NPCName );
+					continue;
+				}
+				if (n != 100)
+				{
+					NPC->s.modelScale[1] = n/100.0f;
+				}
+				continue;
+			}
+
+			//Z scale
+			if ( !Q_stricmp( token, "scaleZ" ) ) 
+			{
+				if ( COM_ParseInt( &p, &n ) ) 
+				{
+					SkipRestOfLine( &p );
+					continue;
+				}
+				if ( n < 0 ) 
+				{
+					gi.Printf(  "bad %s in NPC '%s'\n", token, NPCName );
+					continue;
+				}
+				if (n != 100)
+				{
+					NPC->s.modelScale[2] = n/100.0f;
+				}
+				continue;
+			}
+
+	//===AI STATS=====================================================================
+			if ( !parsingPlayer )
+			{
+				// aggression
+				if ( !Q_stricmp( token, "aggression" ) ) {
+					if ( COM_ParseInt( &p, &n ) ) {
+						SkipRestOfLine( &p );
+						continue;
+					}
+					if ( n < 1 || n > 5 ) {
+						gi.Printf(  "bad %s in NPC '%s'\n", token, NPCName );
+						continue;
+					}
+					if ( NPC->NPC )
+					{
+						stats->aggression = n;
+					}
+					continue;
+				}
+
+				// aim
+				if ( !Q_stricmp( token, "aim" ) ) {
+					if ( COM_ParseInt( &p, &n ) ) {
+						SkipRestOfLine( &p );
+						continue;
+					}
+					if ( n < 1 || n > 5 ) {
+						gi.Printf( "bad %s in NPC '%s'\n", token, NPCName );
+						continue;
+					}
+					if ( NPC->NPC )
+					{
+						stats->aim = n;
+					}
+					continue;
+				}
+
+				// earshot
+				if ( !Q_stricmp( token, "earshot" ) ) {
+					if ( COM_ParseFloat( &p, &f ) ) {
+						SkipRestOfLine( &p );
+						continue;
+					}
+					if ( f < 0.0f ) 
+					{
+						gi.Printf( "bad %s in NPC '%s'\n", token, NPCName );
+						continue;
+					}
+					if ( NPC->NPC )
+					{
+						stats->earshot = f;
+					}
+					continue;
+				}
+
+				// evasion
+				if ( !Q_stricmp( token, "evasion" ) ) 
+				{
+					if ( COM_ParseInt( &p, &n ) ) 
+					{
+						SkipRestOfLine( &p );
+						continue;
+					}
+					if ( n < 1 || n > 5 ) 
+					{
+						gi.Printf( S_COLOR_YELLOW"WARNING: bad %s in NPC '%s'\n", token, NPCName );
+						continue;
+					}
+					if ( NPC->NPC )
+					{
+						stats->evasion = n;
+					}
+					continue;
+				}
+
+				// hfov
+				if ( !Q_stricmp( token, "hfov" ) ) {
+					if ( COM_ParseInt( &p, &n ) ) {
+						SkipRestOfLine( &p );
+						continue;
+					}
+					if ( n < 1 || n > 180 ) {
+						gi.Printf(  "bad %s in NPC '%s'\n", token, NPCName );
+						continue;
+					}
+					if ( NPC->NPC )
+					{
+						stats->hfov = n;// / 2;	//FIXME: Why was this being done?!
+					}
+					continue;
+				}
+
+				// intelligence
+				if ( !Q_stricmp( token, "intelligence" ) ) {
+					if ( COM_ParseInt( &p, &n ) ) {
+						SkipRestOfLine( &p );
+						continue;
+					}
+					if ( n < 1 || n > 5 ) {
+						gi.Printf(  "bad %s in NPC '%s'\n", token, NPCName );
+						continue;
+					}
+					if ( NPC->NPC )
+					{
+						stats->intelligence = n;
+					}
+					continue;
+				}
+				
+				// move
+				if ( !Q_stricmp( token, "move" ) ) {
+					if ( COM_ParseInt( &p, &n ) ) {
+						SkipRestOfLine( &p );
+						continue;
+					}
+					if ( n < 1 || n > 5 ) {
+						gi.Printf(  "bad %s in NPC '%s'\n", token, NPCName );
+						continue;
+					}
+					if ( NPC->NPC )
+					{
+						stats->move = n;
+					}
+					continue;
+				}
+
+				// reactions
+				if ( !Q_stricmp( token, "reactions" ) ) {
+					if ( COM_ParseInt( &p, &n ) ) {
+						SkipRestOfLine( &p );
+						continue;
+					}
+					if ( n < 1 || n > 5 ) {
+						gi.Printf( "bad %s in NPC '%s'\n", token, NPCName );
+						continue;
+					}
+					if ( NPC->NPC )
+					{
+						stats->reactions = n;
+					}
+					continue;
+				}
+
+				// shootDistance
+				if ( !Q_stricmp( token, "shootDistance" ) ) {
+					if ( COM_ParseFloat( &p, &f ) ) {
+						SkipRestOfLine( &p );
+						continue;
+					}
+					if ( f < 0.0f ) 
+					{
+						gi.Printf( "bad %s in NPC '%s'\n", token, NPCName );
+						continue;
+					}
+					if ( NPC->NPC )
+					{
+						stats->shootDistance = f;
+					}
+					continue;
+				}
+
+				// vfov
+				if ( !Q_stricmp( token, "vfov" ) ) {
+					if ( COM_ParseInt( &p, &n ) ) {
+						SkipRestOfLine( &p );
+						continue;
+					}
+					if ( n < 2 || n > 360 ) {
+						gi.Printf(  "bad %s in NPC '%s'\n", token, NPCName );
+						continue;
+					}
+					if ( NPC->NPC )
+					{
+						stats->vfov = n / 2;
+					}
+					continue;
+				}
+
+				// vigilance
+				if ( !Q_stricmp( token, "vigilance" ) ) {
+					if ( COM_ParseFloat( &p, &f ) ) {
+						SkipRestOfLine( &p );
+						continue;
+					}
+					if ( f < 0.0f ) 
+					{
+						gi.Printf( "bad %s in NPC '%s'\n", token, NPCName );
+						continue;
+					}
+					if ( NPC->NPC )
+					{
+						stats->vigilance = f;
+					}
+					continue;
+				}
+
+				// visrange
+				if ( !Q_stricmp( token, "visrange" ) ) {
+					if ( COM_ParseFloat( &p, &f ) ) {
+						SkipRestOfLine( &p );
+						continue;
+					}
+					if ( f < 0.0f ) 
+					{
+						gi.Printf( "bad %s in NPC '%s'\n", token, NPCName );
+						continue;
+					}
+					if ( NPC->NPC )
+					{
+						stats->visrange = f;
+						if (g_entities[ENTITYNUM_WORLD].max_health && stats->visrange>g_entities[ENTITYNUM_WORLD].max_health)
+						{
+							stats->visrange	= g_entities[ENTITYNUM_WORLD].max_health;
+						}
+					}
+					continue;
+				}
+
+				// race
+		//		if ( !Q_stricmp( token, "race" ) ) 
+		//		{
+		//			if ( COM_ParseString( &p, &value ) ) 
+		//			{
+		//				continue;
+		//			}
+		//			NPC->client->race = TranslateRaceName(value);
+		//			continue;
+		//		}
+
+				// rank
+				if ( !Q_stricmp( token, "rank" ) ) 
+				{
+					if ( COM_ParseString( &p, &value ) ) 
+					{
+						continue;
+					}
+					if ( NPC->NPC )
+					{
+						NPC->NPC->rank = TranslateRankName(value);
+					}
+					continue;
+				}
+			}
+
+			// health
+			if ( !Q_stricmp( token, "health" ) ) 
+			{
+				if ( COM_ParseInt( &p, &n ) ) 
+				{
+					SkipRestOfLine( &p );
+					continue;
+				}
+				if ( n < 0 ) 
+				{
+					gi.Printf( S_COLOR_YELLOW"WARNING: bad %s in NPC '%s'\n", token, NPCName );
+					continue;
+				}
+				if ( NPC->NPC )
+				{
+					stats->health = n;
+				}
+				else if ( parsingPlayer )
+				{
+					NPC->client->ps.stats[STAT_MAX_HEALTH] = NPC->client->pers.maxHealth = NPC->max_health = n;
+				}
+				continue;
+			}
+
+			// fullName
+			if ( !Q_stricmp( token, "fullName" ) ) 
+			{
+#ifndef FINAL_BUILD
+				gi.Printf( S_COLOR_YELLOW"WARNING: fullname ignored in NPC '%s'\n", NPCName );
+#endif
+				if ( COM_ParseString( &p, &value ) ) 
+				{
+					continue;
+				}
+				continue;
+			}
+
+			// playerTeam
+			if ( !Q_stricmp( token, "playerTeam" ) ) 
+			{
+				if ( COM_ParseString( &p, &value ) ) 
+				{
+					continue;
+				}
+				NPC->client->playerTeam = (team_t)GetIDForString( TeamTable, value );
+				continue;
+			}
+
+			// enemyTeam
+			if ( !Q_stricmp( token, "enemyTeam" ) ) 
+			{
+				if ( COM_ParseString( &p, &value ) ) 
+				{
+					continue;
+				}
+				NPC->client->enemyTeam = (team_t)GetIDForString( TeamTable, value );
+				continue;
+			}
+
+			// class
+			if ( !Q_stricmp( token, "class" ) ) 
+			{
+				if ( COM_ParseString( &p, &value ) ) 
+				{
+					continue;
+				}
+				NPC->client->NPC_class = (class_t)GetIDForString( ClassTable, value );
+
+				// No md3's for vehicles.
+				if ( NPC->client->NPC_class == CLASS_VEHICLE )
+				{
+					if ( !NPC->m_pVehicle )
+					{//you didn't spawn this guy right!
+						Com_Printf ( S_COLOR_RED "ERROR: Tried to spawn a vehicle NPC (%s) without using NPC_Vehicle or 'NPC spawn vehicle <vehiclename>'!!!  Bad, bad, bad!  Shame on you!\n", NPCName );
+						return qfalse;
+					}
+					md3Model = qfalse;
+				}
+
+				continue;
+			}
+
+			// dismemberment probability for head
+			if ( !Q_stricmp( token, "dismemberProbHead" ) ) {
+				if ( COM_ParseInt( &p, &n ) ) {
+					SkipRestOfLine( &p );
+					continue;
+				}
+				if ( n < 0 ) 
+				{
+					gi.Printf( "bad %s in NPC '%s'\n", token, NPCName );
+					continue;
+				}
+				if ( NPC->NPC )
+				{
+					NPC->client->dismemberProbHead = n;
+				}
+				continue;
+			}
+
+			// dismemberment probability for arms
+			if ( !Q_stricmp( token, "dismemberProbArms" ) ) {
+				if ( COM_ParseInt( &p, &n ) ) {
+					SkipRestOfLine( &p );
+					continue;
+				}
+				if ( n < 0 ) 
+				{
+					gi.Printf( "bad %s in NPC '%s'\n", token, NPCName );
+					continue;
+				}
+				if ( NPC->NPC )
+				{
+					NPC->client->dismemberProbArms = n;
+				}
+				continue;
+			}
+
+			// dismemberment probability for hands
+			if ( !Q_stricmp( token, "dismemberProbHands" ) ) {
+				if ( COM_ParseInt( &p, &n ) ) {
+					SkipRestOfLine( &p );
+					continue;
+				}
+				if ( n < 0 ) 
+				{
+					gi.Printf( "bad %s in NPC '%s'\n", token, NPCName );
+					continue;
+				}
+				if ( NPC->NPC )
+				{
+					NPC->client->dismemberProbHands = n;
+				}
+				continue;
+			}
+
+			// dismemberment probability for waist
+			if ( !Q_stricmp( token, "dismemberProbWaist" ) ) {
+				if ( COM_ParseInt( &p, &n ) ) {
+					SkipRestOfLine( &p );
+					continue;
+				}
+				if ( n < 0 ) 
+				{
+					gi.Printf( "bad %s in NPC '%s'\n", token, NPCName );
+					continue;
+				}
+				if ( NPC->NPC )
+				{
+					NPC->client->dismemberProbWaist = n;
+				}
+				continue;
+			}
+
+			// dismemberment probability for legs
+			if ( !Q_stricmp( token, "dismemberProbLegs" ) ) {
+				if ( COM_ParseInt( &p, &n ) ) {
+					SkipRestOfLine( &p );
+					continue;
+				}
+				if ( n < 0 ) 
+				{
+					gi.Printf( "bad %s in NPC '%s'\n", token, NPCName );
+					continue;
+				}
+				if ( NPC->NPC )
+				{
+					NPC->client->dismemberProbLegs = n;
+				}
+				continue;
+			}
+
+	//===MOVEMENT STATS============================================================
+			
+			if ( !Q_stricmp( token, "width" ) ) 
+			{
+				if ( COM_ParseInt( &p, &n ) ) 
+				{
+					continue;
+				}
+
+				NPC->mins[0] = NPC->mins[1] = -n;
+				NPC->maxs[0] = NPC->maxs[1] = n;
+				continue;
+			}
+
+			if ( !Q_stricmp( token, "height" ) ) 
+			{
+				if ( COM_ParseInt( &p, &n ) ) 
+				{
+					continue;
+				}
+
+				if ( NPC->client->NPC_class == CLASS_VEHICLE
+					&& NPC->m_pVehicle
+					&& NPC->m_pVehicle->m_pVehicleInfo
+					&& NPC->m_pVehicle->m_pVehicleInfo->type == VH_FIGHTER )
+				{//a flying vehicle's origin must be centered in bbox
+					NPC->maxs[2] = NPC->client->standheight = (n/2.0f);
+					NPC->mins[2] = -NPC->maxs[2];
+					NPC->s.origin[2] += (DEFAULT_MINS_2-NPC->mins[2])+0.125f;
+					VectorCopy(NPC->s.origin, NPC->client->ps.origin);
+					VectorCopy(NPC->s.origin, NPC->currentOrigin);
+					G_SetOrigin( NPC, NPC->s.origin );
+					gi.linkentity(NPC);
+				}
+				else
+				{
+					NPC->mins[2] = DEFAULT_MINS_2;//Cannot change
+					NPC->maxs[2] = NPC->client->standheight = n + DEFAULT_MINS_2;
+				}
+				NPC->s.radius = n;
+				continue;
+			}
+
+			if ( !Q_stricmp( token, "crouchheight" ) ) 
+			{
+				if ( COM_ParseInt( &p, &n ) ) 
+				{
+					continue;
+				}
+
+				NPC->client->crouchheight = n + DEFAULT_MINS_2;
+				continue;
+			}
+
+			if ( !parsingPlayer )
+			{
+				if ( !Q_stricmp( token, "movetype" ) ) 
+				{
+					if ( COM_ParseString( &p, &value ) ) 
+					{
+						continue;
+					}
+
+					NPC->client->moveType = (movetype_t)MoveTypeNameToEnum(value);
+					continue;
+				}
+					
+				// yawSpeed
+				if ( !Q_stricmp( token, "yawSpeed" ) ) {
+					if ( COM_ParseInt( &p, &n ) ) {
+						SkipRestOfLine( &p );
+						continue;
+					}
+					if ( n <= 0) {
+						gi.Printf(  "bad %s in NPC '%s'\n", token, NPCName );
+						continue;
+					}
+					if ( NPC->NPC )
+					{
+						stats->yawSpeed = ((float)(n));
+					}
+					continue;
+				}
+
+				// walkSpeed
+				if ( !Q_stricmp( token, "walkSpeed" ) ) 
+				{
+					if ( COM_ParseInt( &p, &n ) ) 
+					{
+						SkipRestOfLine( &p );
+						continue;
+					}
+					if ( n < 0 ) 
+					{
+						gi.Printf( S_COLOR_YELLOW"WARNING: bad %s in NPC '%s'\n", token, NPCName );
+						continue;
+					}
+					if ( NPC->NPC )
+					{
+						stats->walkSpeed = n;
+					}
+					continue;
+				}
+				
+				//runSpeed
+				if ( !Q_stricmp( token, "runSpeed" ) ) 
+				{
+					if ( COM_ParseInt( &p, &n ) ) 
+					{
+						SkipRestOfLine( &p );
+						continue;
+					}
+					if ( n < 0 ) 
+					{
+						gi.Printf( S_COLOR_YELLOW"WARNING: bad %s in NPC '%s'\n", token, NPCName );
+						continue;
+					}
+					if ( NPC->NPC )
+					{
+						stats->runSpeed = n;
+					}
+					continue;
+				}
+
+				//acceleration
+				if ( !Q_stricmp( token, "acceleration" ) ) 
+				{
+					if ( COM_ParseInt( &p, &n ) ) 
+					{
+						SkipRestOfLine( &p );
+						continue;
+					}
+					if ( n < 0 ) 
+					{
+						gi.Printf( S_COLOR_YELLOW"WARNING: bad %s in NPC '%s'\n", token, NPCName );
+						continue;
+					}
+					if ( NPC->NPC )
+					{
+						stats->acceleration = n;
+					}
+					continue;
+				}
+
+				//sex
+				if ( !Q_stricmp( token, "sex" ) ) 
+				{
+					if ( COM_ParseString( &p, &value ) ) 
+					{
+						SkipRestOfLine( &p );
+						continue;
+					}
+					if ( value[0] == 'm' )
+					{//male
+						stats->sex = SEX_MALE;
+					}
+					else if ( value[0] == 'n' )
+					{//neutral
+						stats->sex = SEX_NEUTRAL;
+					}
+					else if ( value[0] == 'a' )
+					{//asexual?
+						stats->sex = SEX_NEUTRAL;
+					}
+					else if ( value[0] == 'f' )
+					{//female
+						stats->sex = SEX_FEMALE;
+					}
+					else if ( value[0] == 's' )
+					{//shemale?
+						stats->sex = SEX_SHEMALE;
+					}
+					else if ( value[0] == 'h' )
+					{//hermaphrodite?
+						stats->sex = SEX_SHEMALE;
+					}
+					else if ( value[0] == 't' )
+					{//transsexual/transvestite?
+						stats->sex = SEX_SHEMALE;
+					}
+					continue;
+				}
+//===MISC===============================================================================
+				// default behavior
+				if ( !Q_stricmp( token, "behavior" ) ) 
+				{
+					if ( COM_ParseInt( &p, &n ) ) 
+					{
+						SkipRestOfLine( &p );
+						continue;
+					}
+					if ( n < BS_DEFAULT || n >= NUM_BSTATES ) 
+					{
+						gi.Printf( S_COLOR_YELLOW"WARNING: bad %s in NPC '%s'\n", token, NPCName );
+						continue;
+					}
+					if ( NPC->NPC )
+					{
+						NPC->NPC->defaultBehavior = (bState_t)(n);
+					}
+					continue;
+				}
+			}
+
+			// snd
+			if ( !Q_stricmp( token, "snd" ) ) 
+			{
+				if ( COM_ParseString( &p, &value ) ) 
+				{
+					continue;
+				}
+				if ( !(NPC->svFlags&SVF_NO_BASIC_SOUNDS) )
+				{
+					//FIXME: store this in some sound field or parse in the soundTable like the animTable...
+					Q_strncpyz( sound, value, sizeof( sound ) );
+					patch = strstr( sound, "/" );
+					if ( patch ) 
+					{
+						*patch = 0;
+					}
+					ci->customBasicSoundDir = G_NewString( sound );
+				}
+				continue;
+			}
+
+			// sndcombat
+			if ( !Q_stricmp( token, "sndcombat" ) ) 
+			{
+				if ( COM_ParseString( &p, &value ) ) 
+				{
+					continue;
+				}
+				if ( !(NPC->svFlags&SVF_NO_COMBAT_SOUNDS) )
+				{
+					//FIXME: store this in some sound field or parse in the soundTable like the animTable...
+					Q_strncpyz( sound, value, sizeof( sound ) );
+					patch = strstr( sound, "/" );
+					if ( patch ) 
+					{
+						*patch = 0;
+					}
+					ci->customCombatSoundDir = G_NewString( sound );
+				}
+				continue;
+			}
+			
+			// sndextra
+			if ( !Q_stricmp( token, "sndextra" ) ) 
+			{
+				if ( COM_ParseString( &p, &value ) ) 
+				{
+					continue;
+				}
+				if ( !(NPC->svFlags&SVF_NO_EXTRA_SOUNDS) )
+				{
+					//FIXME: store this in some sound field or parse in the soundTable like the animTable...
+					Q_strncpyz( sound, value, sizeof( sound ) );
+					patch = strstr( sound, "/" );
+					if ( patch ) 
+					{
+						*patch = 0;
+					}
+					ci->customExtraSoundDir = G_NewString( sound );
+				}
+				continue;
+			}
+
+			// sndjedi
+			if ( !Q_stricmp( token, "sndjedi" ) ) 
+			{
+				if ( COM_ParseString( &p, &value ) ) 
+				{
+					continue;
+				}
+				if ( !(NPC->svFlags&SVF_NO_EXTRA_SOUNDS) )
+				{
+					//FIXME: store this in some sound field or parse in the soundTable like the animTable...
+					Q_strncpyz( sound, value, sizeof( sound ) );
+					patch = strstr( sound, "/" );
+					if ( patch ) 
+					{
+						*patch = 0;
+					}
+					ci->customJediSoundDir = G_NewString( sound );
+				}
+				continue;
+			}
+
+			//New NPC/jedi stats:
+			//starting weapon
+			if ( !Q_stricmp( token, "weapon" ) ) 
+			{
+				if ( COM_ParseString( &p, &value ) ) 
+				{
+					continue;
+				}
+				//FIXME: need to precache the weapon, too?  (in above func)
+				int weap = GetIDForString( WPTable, value );
+				if ( weap >= WP_NONE && weap < WP_NUM_WEAPONS )
+				{
+					NPC->client->ps.weapon = weap;
+					NPC->client->ps.stats[STAT_WEAPONS] |= ( 1 << weap );
+					if ( weap > WP_NONE )
+					{
+						RegisterItem( FindItemForWeapon( (weapon_t)(weap) ) );	//precache the weapon
+						NPC->client->ps.ammo[weaponData[weap].ammoIndex] = ammoData[weaponData[weap].ammoIndex].max;
+					}
+				}
+				continue;
+			}
+			
+			if ( !parsingPlayer )
+			{
+				//altFire
+				if ( !Q_stricmp( token, "altFire" ) ) 
+				{
+					if ( COM_ParseInt( &p, &n ) ) 
+					{
+						SkipRestOfLine( &p );
+						continue;
+					}
+					if ( NPC->NPC )
+					{
+						if ( n != 0 )
+						{
+							NPC->NPC->scriptFlags |= SCF_ALT_FIRE;
+						}
+					}
+					continue;
+				}
+				//Other unique behaviors/numbers that are currently hardcoded?
+			}
+
+			//force powers
+			int fp = GetIDForString( FPTable, token );
+			if ( fp >= FP_FIRST && fp < NUM_FORCE_POWERS )
+			{
+				if ( COM_ParseInt( &p, &n ) ) 
+				{
+					SkipRestOfLine( &p );
+					continue;
+				}
+				//FIXME: need to precache the fx, too?  (in above func)
+				//cap
+				if ( n > 5 )
+				{
+					n = 5;
+				}
+				else if ( n < 0 )
+				{
+					n = 0;
+				}
+				if ( n )
+				{//set
+					NPC->client->ps.forcePowersKnown |= ( 1 << fp );
+				}
+				else
+				{//clear
+					NPC->client->ps.forcePowersKnown &= ~( 1 << fp );
+				}
+				NPC->client->ps.forcePowerLevel[fp] = n;
+				continue;
+			}
+
+			//max force power
+			if ( !Q_stricmp( token, "forcePowerMax" ) ) 
+			{
+				if ( COM_ParseInt( &p, &n ) ) 
+				{
+					SkipRestOfLine( &p );
+					continue;
+				}
+				NPC->client->ps.forcePowerMax = n;
+				continue;
+			}
+
+			//force regen rate - default is 100ms
+			if ( !Q_stricmp( token, "forceRegenRate" ) ) 
+			{
+				if ( COM_ParseInt( &p, &n ) ) 
+				{
+					SkipRestOfLine( &p );
+					continue;
+				}
+				NPC->client->ps.forcePowerRegenRate = n;
+				continue;
+			}
+
+			//force regen amount - default is 1 (points per second)
+			if ( !Q_stricmp( token, "forceRegenAmount" ) ) 
+			{
+				if ( COM_ParseInt( &p, &n ) ) 
+				{
+					SkipRestOfLine( &p );
+					continue;
+				}
+				NPC->client->ps.forcePowerRegenAmount = n;
+				continue;
+			}
+
+			//have a sabers.cfg and just name your saber in your NPCs.cfg/ICARUS script
+			//saber name
+			if ( !Q_stricmp( token, "saber" ) ) 
+			{
+				if ( COM_ParseString( &p, &value ) ) 
+				{
+					continue;
+				}
+				char *saberName = G_NewString( value );
+				WP_SaberParseParms( saberName, &NPC->client->ps.saber[0] );
+				//if it requires a specific style, make sure we know how to use it
+				if ( NPC->client->ps.saber[0].style )
+				{
+					NPC->client->ps.saberStylesKnown |= (1<<NPC->client->ps.saber[0].style);
+				}
+				continue;
+			}
+			
+			//second saber name
+			if ( !Q_stricmp( token, "saber2" ) ) 
+			{
+				if ( COM_ParseString( &p, &value ) ) 
+				{
+					continue;
+				}
+
+				if ( !NPC->client->ps.saber[0].twoHanded )
+				{//can't use a second saber if first one is a two-handed saber...?
+					char *saberName = G_NewString( value );
+					WP_SaberParseParms( saberName, &NPC->client->ps.saber[1] );
+					if ( NPC->client->ps.saber[1].style )
+					{
+						NPC->client->ps.saberStylesKnown |= (1<<NPC->client->ps.saber[1].style);
+					}
+					if ( NPC->client->ps.saber[1].twoHanded )
+					{//tsk tsk, can't use a twoHanded saber as second saber
+						WP_RemoveSaber( NPC, 1 );
+					}
+					else
+					{
+						NPC->client->ps.dualSabers = qtrue;
+					}
+				}
+				continue;
+			}
+
+			// saberColor
+			if ( !Q_stricmpn( token, "saberColor", 10) ) 
+			{
+				if ( !NPC->client )
+				{
+					continue;
+				}
+
+				if (strlen(token)==10)
+				{
+					if ( COM_ParseString( &p, &value ) ) 
+					{
+						continue;
+					}
+					saber_colors_t color = TranslateSaberColor( value );
+					for ( n = 0; n < MAX_BLADES; n++ )
+					{
+						NPC->client->ps.saber[0].blade[n].color = color;
+					}
+				}
+				else if (strlen(token)==11)
+				{
+					int index = atoi(&token[10])-1;
+					if (index > 7 || index < 1 )
+					{
+						gi.Printf( S_COLOR_YELLOW"WARNING: bad saberColor '%s' in %s\n", token, NPCName );
+						continue;
+					}
+					if ( COM_ParseString( &p, &value ) ) 
+					{
+						continue;
+					}
+					NPC->client->ps.saber[0].blade[index].color = TranslateSaberColor( value );
+				}
+				else
+				{
+					gi.Printf( S_COLOR_YELLOW"WARNING: bad saberColor '%s' in %s\n", token, NPCName );
+				}
+				continue;
+			}
+
+
+			if ( !Q_stricmpn( token, "saber2Color", 11 ) ) 
+			{
+				if ( !NPC->client )
+				{
+					continue;
+				}
+
+				if (strlen(token)==11)
+				{
+					if ( COM_ParseString( &p, &value ) ) 
+					{
+						continue;
+					}
+					saber_colors_t color = TranslateSaberColor( value );
+					for ( n = 0; n < MAX_BLADES; n++ )
+					{
+						NPC->client->ps.saber[1].blade[n].color = color;
+					}
+				}
+				else if (strlen(token)==12)
+				{
+					n = atoi(&token[11])-1;
+					if (n > 7 || n < 1 )
+					{
+						gi.Printf( S_COLOR_YELLOW"WARNING: bad saber2Color '%s' in %s\n", token, NPCName );
+						continue;
+					}
+					if ( COM_ParseString( &p, &value ) ) 
+					{
+						continue;
+					}
+					NPC->client->ps.saber[1].blade[n].color = TranslateSaberColor( value );
+				}
+				else
+				{
+					gi.Printf( S_COLOR_YELLOW"WARNING: bad saber2Color '%s' in %s\n", token, NPCName );
+				}
+				continue;
+			}
+
+
+			//saber length
+			if ( !Q_stricmpn( token, "saberLength", 11) ) 
+			{
+				if (strlen(token)==11)
+				{
+					n = -1;
+				}
+				else if (strlen(token)==12)
+				{
+					n = atoi(&token[11])-1;
+					if (n > 7 || n < 1 )
+					{
+						gi.Printf( S_COLOR_YELLOW"WARNING: bad saberLength '%s' in %s\n", token, NPCName );
+						continue;
+					}
+				}
+				else
+				{
+					gi.Printf( S_COLOR_YELLOW"WARNING: bad saberLength '%s' in %s\n", token, NPCName );
+					continue;
+				}
+
+				if ( COM_ParseFloat( &p, &f ) ) 
+				{
+					SkipRestOfLine( &p );
+					continue;
+				}
+				//cap
+				if ( f < 4.0f )
+				{
+					f = 4.0f;
+				}
+
+				if (n == -1)//do them all
+				{
+					for ( n = 0; n < MAX_BLADES; n++ )
+					{
+						NPC->client->ps.saber[0].blade[n].lengthMax = f;
+					}
+				} 
+				else //just one
+				{
+					NPC->client->ps.saber[0].blade[n].lengthMax = f;
+				}
+				continue;
+			}
+
+			if ( !Q_stricmpn( token, "saber2Length", 12) ) 
+			{
+				if (strlen(token)==12)
+				{
+					n = -1;
+				}
+				else if (strlen(token)==13)
+				{
+					n = atoi(&token[12])-1;
+					if (n > 7 || n < 1 )
+					{
+						gi.Printf( S_COLOR_YELLOW"WARNING: bad saber2Length '%s' in %s\n", token, NPCName );
+						continue;
+					}
+				}
+				else
+				{
+					gi.Printf( S_COLOR_YELLOW"WARNING: bad saber2Length '%s' in %s\n", token, NPCName );
+					continue;
+				}
+
+				if ( COM_ParseFloat( &p, &f ) ) 
+				{
+					SkipRestOfLine( &p );
+					continue;
+				}
+				//cap
+				if ( f < 4.0f )
+				{
+					f = 4.0f;
+				}
+
+				if (n == -1)//do them all
+				{
+					for ( n = 0; n < MAX_BLADES; n++ )
+					{
+						NPC->client->ps.saber[1].blade[n].lengthMax = f;
+					}
+				}
+				else //just one
+				{
+					NPC->client->ps.saber[1].blade[n].lengthMax = f;
+				}
+				continue;
+			}
+
+
+			//saber radius
+			if ( !Q_stricmpn( token, "saberRadius", 11 ) ) 
+			{
+				if (strlen(token)==11)
+				{
+					n = -1;
+				}
+				else if (strlen(token)==12)
+				{
+					n = atoi(&token[11])-1;
+					if (n > 7 || n < 1 )
+					{
+						gi.Printf( S_COLOR_YELLOW"WARNING: bad saberRadius '%s' in %s\n", token, NPCName );
+						continue;
+					}
+				}
+				else
+				{
+					gi.Printf( S_COLOR_YELLOW"WARNING: bad saberRadius '%s' in %s\n", token, NPCName );
+					continue;
+				}
+				
+				if ( COM_ParseFloat( &p, &f ) ) 
+				{
+					SkipRestOfLine( &p );
+					continue;
+				}
+				//cap
+				if ( f < 0.25f )
+				{
+					f = 0.25f;
+				}
+
+				if (n==-1)
+				{//NOTE: this fills in the rest of the blades with the same length by default
+					for ( n = 0; n < MAX_BLADES; n++ )
+					{
+						NPC->client->ps.saber[0].blade[n].radius = f;
+					}
+				}
+				else 
+				{
+					NPC->client->ps.saber[0].blade[n].radius = f;
+				}
+				continue;
+			}
+
+
+			if ( !Q_stricmpn( token, "saber2Radius", 12 ) ) 
+			{
+				if (strlen(token)==12)
+				{
+					n = -1;
+				}
+				else if (strlen(token)==13)
+				{
+					n = atoi(&token[12])-1;
+					if (n > 7 || n < 1 )
+					{
+						gi.Printf( S_COLOR_YELLOW"WARNING: bad saber2Radius '%s' in %s\n", token, NPCName );
+						continue;
+					}
+				}
+				else
+				{
+					gi.Printf( S_COLOR_YELLOW"WARNING: bad saber2Radius '%s' in %s\n", token, NPCName );
+					continue;
+				}
+
+				if ( COM_ParseFloat( &p, &f ) ) 
+				{
+					SkipRestOfLine( &p );
+					continue;
+				}
+				//cap
+				if ( f < 0.25f )
+				{
+					f = 0.25f;
+				}
+
+				if (n==-1)
+				{//NOTE: this fills in the rest of the blades with the same length by default
+					for ( n = 0; n < MAX_BLADES; n++ )
+					{
+						NPC->client->ps.saber[1].blade[n].radius = f;
+					}
+				}
+				else
+				{
+					NPC->client->ps.saber[1].blade[n].radius = f;
+				}
+				continue;
+			}
+
+			//ADD:
+			//saber sounds (on, off, loop)
+			//loop sound (like Vader's breathing or droid bleeps, etc.)
+
+			//starting saber style
+			if ( !Q_stricmp( token, "saberStyle" ) ) 
+			{
+				if ( COM_ParseInt( &p, &n ) ) 
+				{
+					SkipRestOfLine( &p );
+					continue;
+				}
+				//cap
+				if ( n > SS_STAFF )
+				{
+					n = SS_STAFF;
+				}
+				else if ( n < SS_FAST )
+				{
+					n = SS_FAST;
+				}
+				if ( n )
+				{//set
+					NPC->client->ps.saberStylesKnown |= ( 1 << n );
+				}
+				else
+				{//clear
+					NPC->client->ps.saberStylesKnown &= ~( 1 << n );
+				}
+				NPC->client->ps.saberAnimLevel = n;
+				if ( parsingPlayer )
+				{
+					cg.saberAnimLevelPending = n;
+				}
+				continue;
+			}
+
+			if ( !parsingPlayer )
+			{
+				gi.Printf( "WARNING: unknown keyword '%s' while parsing '%s'\n", token, NPCName );
+			}
+			SkipRestOfLine( &p );
+		}
+	}
+
+	ci->infoValid = qfalse;
+
+/*
+Ghoul2 Insert Start
+*/
+	if ( !md3Model )
+	{
+		NPC->weaponModel[0] = -1;
+		if ( Q_stricmp( "player", playerModel ) == 0 )
+		{//set the model from the console cvars
+			G_InitPlayerFromCvars( NPC );
+			//now set the weapon, etc.
+			G_MatchPlayerWeapon( NPC );
+			//NPC->NPC->aiFlags |= NPCAI_MATCHPLAYERWEAPON;//FIXME: may not always want this
+		}
+		else
+		{//do a normal model load
+
+			// If this is a vehicle, set the model name from the vehicle type array.
+			if ( NPC->client->NPC_class == CLASS_VEHICLE )
+			{
+				int iVehIndex = BG_VehicleGetIndex( NPC->NPC_type );
+				strcpy(customSkin, "default");	// Ignore any custom skin that may have come from the NPC File
+				Q_strncpyz( playerModel, g_vehicleInfo[iVehIndex].model, sizeof(playerModel), qtrue);
+				if ( g_vehicleInfo[iVehIndex].skin && g_vehicleInfo[iVehIndex].skin[0] )
+				{
+					bool	forceSkin = false;
+
+					// Iterate Over All Possible Skins
+					//---------------------------------
+					ratl::vector_vs<hstring, 15>	skinarray;
+					ratl::string_vs<256>			skins(g_vehicleInfo[iVehIndex].skin);
+					for (ratl::string_vs<256>::tokenizer i = skins.begin("|"); i!=skins.end(); i++)
+					{
+						if (NPC->soundSet && NPC->soundSet[0] && Q_stricmp(*i, NPC->soundSet)==0)
+						{
+							forceSkin = true;
+						}
+						skinarray.push_back(*i);
+					}
+
+					// Soundset Is The Designer Set Way To Supply A Skin
+					//---------------------------------------------------
+					if (forceSkin)
+					{
+						Q_strncpyz( customSkin, NPC->soundSet, sizeof(customSkin), qtrue);
+					}
+
+					// Otherwise Choose A Random Skin
+					//--------------------------------
+					else
+					{
+						if (NPC->soundSet && NPC->soundSet[0])
+						{
+							gi.Printf(S_COLOR_RED"WARNING: Unable to use skin (%s)", NPC->soundSet);
+						}
+						Q_strncpyz( customSkin, *skinarray[Q_irand(0, skinarray.size()-1)], sizeof(customSkin), qtrue);			
+					}
+					if (NPC->soundSet && gi.bIsFromZone(NPC->soundSet, TAG_G_ALLOC)) {
+						gi.Free(NPC->soundSet);	
+					}
+					NPC->soundSet = 0; // clear the pointer
+				}
+			}
+
+			G_SetG2PlayerModel( NPC, playerModel, customSkin, surfOff, surfOn );
+		}
+	}
+/*
+Ghoul2 Insert End
+*/
+	if(	NPCsPrecached )
+	{//Spawning in after initial precache, our models are precached, we just need to set our clientInfo
+		CG_RegisterClientModels( NPC->s.number );
+		CG_RegisterNPCCustomSounds( ci );
+		//CG_RegisterNPCEffects( NPC->client->playerTeam );
+	}
+
+	return qtrue;
+}
+
+void NPC_LoadParms( void ) 
+{
+	int			len, totallen, npcExtFNLen, fileCnt, i;
+	char		*buffer, *holdChar, *marker;
+	char		npcExtensionListBuf[2048];			//	The list of file names read in
+
+	//gi.Printf( "Parsing ext_data/npcs/*.npc definitions\n" );
+
+	//set where to store the first one
+	totallen = 0;
+	marker = NPCParms;
+	marker[0] = '\0';
+
+	//now load in the .npc definitions
+	fileCnt = gi.FS_GetFileList("ext_data/npcs", ".npc", npcExtensionListBuf, sizeof(npcExtensionListBuf) );
+
+	holdChar = npcExtensionListBuf;
+	for ( i = 0; i < fileCnt; i++, holdChar += npcExtFNLen + 1 ) 
+	{
+		npcExtFNLen = strlen( holdChar );
+
+		//gi.Printf( "Parsing %s\n", holdChar );
+
+		len = gi.FS_ReadFile( va( "ext_data/npcs/%s", holdChar), (void **) &buffer );
+
+		if ( len == -1 ) 
+		{
+			gi.Printf( "NPC_LoadParms: error reading file %s\n", holdChar );
+		}
+		else
+		{
+			if ( totallen && *(marker-1) == '}' )
+			{//don't let previous file end on a } because that must be a stand-alone token
+				strcat( marker, " " );
+				totallen++;
+				marker++; 
+			}
+			len = COM_Compress( buffer );
+
+			if ( totallen + len >= MAX_NPC_DATA_SIZE ) {
+				G_Error( "NPC_LoadParms: ran out of space before reading %s\n(you must make the .npc files smaller)", holdChar );
+			}
+			strcat( marker, buffer );
+			gi.FS_FreeFile( buffer );
+
+			totallen += len;
+			marker += len;
+		}
+	}
+}
diff --git a/code/game/NPC_utils.cpp b/code/game/NPC_utils.cpp
new file mode 100644
index 0000000..0333019
--- /dev/null
+++ b/code/game/NPC_utils.cpp
@@ -0,0 +1,1668 @@
+//NPC_utils.cpp
+
+// leave this line at the top for all NPC_xxxx.cpp files...
+#include "g_headers.h"
+
+
+
+
+#include "b_local.h"
+#include "Q3_Interface.h"
+
+extern Vehicle_t *G_IsRidingVehicle( gentity_t *pEnt );
+
+int	teamNumbers[TEAM_NUM_TEAMS];
+int	teamStrength[TEAM_NUM_TEAMS];
+int	teamCounter[TEAM_NUM_TEAMS];
+
+#define	VALID_ATTACK_CONE	2.0f	//Degrees
+void GetAnglesForDirection( const vec3_t p1, const vec3_t p2, vec3_t out );
+
+/*
+void CalcEntitySpot ( gentity_t *ent, spot_t spot, vec3_t point ) 
+
+Added: Uses shootAngles if a NPC has them
+
+*/
+extern void ViewHeightFix(const gentity_t *const ent);
+extern void AddLeanOfs(const gentity_t *const ent, vec3_t point);
+extern void SubtractLeanOfs(const gentity_t *const ent, vec3_t point);
+void CalcEntitySpot ( const gentity_t *ent, const spot_t spot, vec3_t point ) 
+{
+	vec3_t	forward, up, right;
+	vec3_t	start, end;
+	trace_t	tr;
+
+	if ( !ent )
+	{
+		return;
+	}
+	ViewHeightFix(ent);
+	switch ( spot ) 
+	{
+	case SPOT_ORIGIN:
+		if(VectorCompare(ent->currentOrigin, vec3_origin))
+		{//brush
+			VectorSubtract(ent->absmax, ent->absmin, point);//size
+			VectorMA(ent->absmin, 0.5, point, point);
+		}
+		else
+		{
+			VectorCopy ( ent->currentOrigin, point );
+		}
+		break;
+
+	case SPOT_CHEST:
+	case SPOT_HEAD:
+		if ( ent->client && VectorLengthSquared( ent->client->renderInfo.eyePoint ) && (ent->client->ps.viewEntity <= 0 || ent->client->ps.viewEntity >= ENTITYNUM_WORLD) )
+		{//Actual tag_head eyespot!
+			//FIXME: Stasis aliens may have a problem here...
+			VectorCopy( ent->client->renderInfo.eyePoint, point );
+			if ( ent->client->NPC_class == CLASS_ATST )
+			{//adjust up some
+				point[2] += 28;//magic number :)
+			}
+			if ( ent->NPC )
+			{//always aim from the center of my bbox, so we don't wiggle when we lean forward or backwards
+				point[0] = ent->currentOrigin[0];
+				point[1] = ent->currentOrigin[1];
+			}
+			else if ( !ent->s.number )
+			{
+				SubtractLeanOfs( ent, point );
+			}
+		}
+		else
+		{
+			VectorCopy ( ent->currentOrigin, point );
+			if ( ent->client ) 
+			{
+				point[2] += ent->client->ps.viewheight;
+			}
+		}
+		if ( spot == SPOT_CHEST && ent->client )
+		{
+			if ( ent->client->NPC_class != CLASS_ATST )
+			{//adjust up some
+				point[2] -= ent->maxs[2]*0.2f;
+			}
+		}
+		break;
+
+	case SPOT_HEAD_LEAN:
+		if ( ent->client && VectorLengthSquared( ent->client->renderInfo.eyePoint ) && (ent->client->ps.viewEntity <= 0 || ent->client->ps.viewEntity >= ENTITYNUM_WORLD) )
+		{//Actual tag_head eyespot!
+			//FIXME: Stasis aliens may have a problem here...
+			VectorCopy( ent->client->renderInfo.eyePoint, point );
+			if ( ent->client->NPC_class == CLASS_ATST )
+			{//adjust up some
+				point[2] += 28;//magic number :)
+			}
+			if ( ent->NPC )
+			{//always aim from the center of my bbox, so we don't wiggle when we lean forward or backwards
+				point[0] = ent->currentOrigin[0];
+				point[1] = ent->currentOrigin[1];
+			}
+			else if ( !ent->s.number )
+			{
+				SubtractLeanOfs( ent, point );
+			}
+			//NOTE: automatically takes leaning into account!
+		}
+		else
+		{
+			VectorCopy ( ent->currentOrigin, point );
+			if ( ent->client ) 
+			{
+				point[2] += ent->client->ps.viewheight;
+			}
+			//AddLeanOfs ( ent, point );
+		}
+		break;
+
+	//FIXME: implement...
+	//case SPOT_CHEST:
+		//Returns point 3/4 from tag_torso to tag_head?
+		//break;
+
+	case SPOT_LEGS:
+		VectorCopy ( ent->currentOrigin, point );
+		point[2] += (ent->mins[2] * 0.5);
+		break;
+
+	case SPOT_WEAPON:
+		if( ent->NPC && !VectorCompare( ent->NPC->shootAngles, vec3_origin ) && !VectorCompare( ent->NPC->shootAngles, ent->client->ps.viewangles ))
+		{
+			AngleVectors( ent->NPC->shootAngles, forward, right, up );
+		}
+		else
+		{
+			AngleVectors( ent->client->ps.viewangles, forward, right, up );
+		}
+		CalcMuzzlePoint( (gentity_t*)ent, forward, right, up, point, 0 );
+		//NOTE: automatically takes leaning into account!
+		break;
+
+	case SPOT_GROUND:
+		// if entity is on the ground, just use it's absmin
+		if ( ent->s.groundEntityNum != -1 ) 
+		{
+			VectorCopy( ent->currentOrigin, point );
+			point[2] = ent->absmin[2];
+			break;
+		}
+
+		// if it is reasonably close to the ground, give the point underneath of it
+		VectorCopy( ent->currentOrigin, start );
+		start[2] = ent->absmin[2];
+		VectorCopy( start, end );
+		end[2] -= 64;
+		gi.trace( &tr, start, ent->mins, ent->maxs, end, ent->s.number, MASK_PLAYERSOLID );
+		if ( tr.fraction < 1.0 ) 
+		{
+			VectorCopy( tr.endpos, point);
+			break;
+		}
+
+		// otherwise just use the origin
+		VectorCopy( ent->currentOrigin, point );
+		break;
+
+	default:
+		VectorCopy ( ent->currentOrigin, point );
+		break;
+	}
+}
+
+
+//===================================================================================
+
+/*
+qboolean NPC_UpdateAngles ( qboolean doPitch, qboolean doYaw ) 
+
+Added: option to do just pitch or just yaw
+
+Does not include "aim" in it's calculations
+
+FIXME: stop compressing angles into shorts!!!!
+*/
+extern cvar_t		*g_timescale;
+extern bool NPC_IsTrooper( gentity_t *ent );
+qboolean NPC_UpdateAngles ( qboolean doPitch, qboolean doYaw ) 
+{
+#if 1
+
+	float		error;
+	float		decay;
+	float		targetPitch = 0;
+	float		targetYaw = 0;
+	float		yawSpeed;
+	qboolean	exact = qtrue;
+
+	// if angle changes are locked; just keep the current angles
+	// aimTime isn't even set anymore... so this code was never reached, but I need a way to lock NPC's yaw, so instead of making a new SCF_ flag, just use the existing render flag... - dmv
+	if ( !NPC->enemy && ( (level.time < NPCInfo->aimTime) || NPC->client->renderInfo.renderFlags & RF_LOCKEDANGLE) ) 
+	{
+		if(doPitch)
+			targetPitch = NPCInfo->lockedDesiredPitch;
+
+		if(doYaw)
+			targetYaw = NPCInfo->lockedDesiredYaw;
+	}
+	else 
+	{
+		// we're changing the lockedDesired Pitch/Yaw below so it's lost it's original meaning, get rid of the lock flag
+		NPC->client->renderInfo.renderFlags &= ~RF_LOCKEDANGLE;
+
+		if(doPitch)
+		{
+			targetPitch = NPCInfo->desiredPitch;
+			NPCInfo->lockedDesiredPitch = NPCInfo->desiredPitch;
+		}
+
+		if(doYaw)
+		{
+			targetYaw = NPCInfo->desiredYaw;
+			NPCInfo->lockedDesiredYaw = NPCInfo->desiredYaw;
+		}			
+	}
+
+	if ( NPC->s.weapon == WP_EMPLACED_GUN )
+	{
+		// FIXME: this seems to do nothing, actually...
+		yawSpeed = 20;
+	}
+	else
+	{
+		if ( NPC->client->NPC_class == CLASS_ROCKETTROOPER 
+			&& !NPC->enemy )
+		{//just slowly lookin' around
+			yawSpeed = 1;
+		}
+		else
+		{
+			yawSpeed = NPCInfo->stats.yawSpeed;
+		}
+	}
+
+	if ( NPC->s.weapon == WP_SABER && NPC->client->ps.forcePowersActive&(1<<FP_SPEED) )
+	{
+		yawSpeed *= 1.0f/g_timescale->value;
+	}
+
+	if (!NPC_IsTrooper(NPC) 
+		&& NPC->enemy
+		&& !G_IsRidingVehicle( NPC ) 
+		&& NPC->client->NPC_class != CLASS_VEHICLE )
+	{
+		if (NPC->s.weapon==WP_BLASTER_PISTOL || 
+			NPC->s.weapon==WP_BLASTER || 
+			NPC->s.weapon==WP_BOWCASTER ||
+			NPC->s.weapon==WP_REPEATER ||
+			NPC->s.weapon==WP_FLECHETTE ||
+			NPC->s.weapon==WP_BRYAR_PISTOL ||
+			NPC->s.weapon==WP_NOGHRI_STICK)
+		{
+			yawSpeed *= 10.0f;
+		}
+	}
+	
+	if( doYaw )
+	{
+		// decay yaw error
+		error = AngleDelta ( NPC->client->ps.viewangles[YAW], targetYaw );
+		if( fabs(error) > MIN_ANGLE_ERROR )
+		{
+			if ( error ) 
+			{
+				exact = qfalse;
+
+				decay = 60.0 + yawSpeed * 3;
+				decay *= 50.0f / 1000.0f;//msec
+
+				if ( error < 0.0 ) 
+				{
+					error += decay;
+					if ( error > 0.0 ) 
+					{
+						error = 0.0;
+					}
+				}
+				else 
+				{
+					error -= decay;
+					if ( error < 0.0 ) 
+					{
+						error = 0.0;
+					}
+				}
+			}
+		}
+		
+		ucmd.angles[YAW] = ANGLE2SHORT( targetYaw + error ) - client->ps.delta_angles[YAW];
+	}
+
+	//FIXME: have a pitchSpeed?
+	if( doPitch )
+	{
+		// decay pitch error
+		error = AngleDelta ( NPC->client->ps.viewangles[PITCH], targetPitch );
+		if ( fabs(error) > MIN_ANGLE_ERROR )
+		{
+			if ( error ) 
+			{
+				exact = qfalse;
+
+				decay = 60.0 + yawSpeed * 3;
+				decay *= 50.0f / 1000.0f;//msec
+
+				if ( error < 0.0 ) 
+				{
+					error += decay;
+					if ( error > 0.0 ) 
+					{
+						error = 0.0;
+					}
+				}
+				else 
+				{
+					error -= decay;
+					if ( error < 0.0 ) 
+					{
+						error = 0.0;
+					}
+				}
+			}
+		}
+
+		ucmd.angles[PITCH] = ANGLE2SHORT( targetPitch + error ) - client->ps.delta_angles[PITCH];
+	}
+
+	ucmd.angles[ROLL] = ANGLE2SHORT ( NPC->client->ps.viewangles[ROLL] ) - client->ps.delta_angles[ROLL];
+
+	if ( exact && Q3_TaskIDPending( NPC, TID_ANGLE_FACE ) )
+	{
+		Q3_TaskIDComplete( NPC, TID_ANGLE_FACE );
+	}
+	return exact;
+
+#else
+
+	float		error;
+	float		decay;
+	float		targetPitch = 0;
+	float		targetYaw = 0;
+	float		yawSpeed;
+	//float		runningMod = NPCInfo->currentSpeed/100.0f;
+	qboolean	exact = qtrue;
+	qboolean	doSound = qfalse;
+
+	// if angle changes are locked; just keep the current angles
+	if ( level.time < NPCInfo->aimTime ) 
+	{
+		if(doPitch)
+			targetPitch = NPCInfo->lockedDesiredPitch;
+		if(doYaw)
+			targetYaw = NPCInfo->lockedDesiredYaw;
+	}
+	else 
+	{
+		if(doPitch)
+			targetPitch = NPCInfo->desiredPitch;
+		if(doYaw)
+			targetYaw = NPCInfo->desiredYaw;
+
+//		NPCInfo->aimTime = level.time + 250;
+		if(doPitch)
+			NPCInfo->lockedDesiredPitch = NPCInfo->desiredPitch;
+		if(doYaw)
+			NPCInfo->lockedDesiredYaw = NPCInfo->desiredYaw;
+	}
+
+	yawSpeed = NPCInfo->stats.yawSpeed;
+
+	if(doYaw)
+	{
+		// decay yaw error
+		error = AngleDelta ( NPC->client->ps.viewangles[YAW], targetYaw );
+		if( fabs(error) > MIN_ANGLE_ERROR )
+		{
+			/*
+			if(NPC->client->playerTeam == TEAM_BORG&&
+				NPCInfo->behaviorState != BS_FACE&&NPCInfo->tempBehavior!= BS_FACE)
+			{//HACK - borg turn more jittery
+				if ( error ) 
+				{
+					exact = qfalse;
+
+					decay = 60.0 + yawSpeed * 3;
+					decay *= 50.0 / 1000.0;//msec
+					//Snap to
+					if(fabs(error) > 10)
+					{
+						if(random() > 0.6)
+						{
+							doSound = qtrue;
+						}
+					}
+
+					if ( error < 0.0)//-10.0 ) 
+					{
+						error += decay;
+						if ( error > 0.0 ) 
+						{
+							error = 0.0;
+						}
+					}
+					else if ( error > 0.0)//10.0 ) 
+					{
+						error -= decay;
+						if ( error < 0.0 ) 
+						{
+							error = 0.0;
+						}
+					}
+				}
+			}
+			else*/
+			
+			if ( error ) 
+			{
+				exact = qfalse;
+
+				decay = 60.0 + yawSpeed * 3;
+				decay *= 50.0 / 1000.0;//msec
+
+				if ( error < 0.0 ) 
+				{
+					error += decay;
+					if ( error > 0.0 ) 
+					{
+						error = 0.0;
+					}
+				}
+				else 
+				{
+					error -= decay;
+					if ( error < 0.0 ) 
+					{
+						error = 0.0;
+					}
+				}
+			}
+		}
+		ucmd.angles[YAW] = ANGLE2SHORT( targetYaw + error ) - client->ps.delta_angles[YAW];
+	}
+
+	//FIXME: have a pitchSpeed?
+	if(doPitch)
+	{
+		// decay pitch error
+		error = AngleDelta ( NPC->client->ps.viewangles[PITCH], targetPitch );
+		if ( fabs(error) > MIN_ANGLE_ERROR )
+		{
+			/*
+			if(NPC->client->playerTeam == TEAM_BORG&&
+				NPCInfo->behaviorState != BS_FACE&&NPCInfo->tempBehavior!= BS_FACE)
+			{//HACK - borg turn more jittery
+				if ( error ) 
+				{
+					exact = qfalse;
+
+					decay = 60.0 + yawSpeed * 3;
+					decay *= 50.0 / 1000.0;//msec
+					//Snap to
+					if(fabs(error) > 10)
+					{
+						if(random() > 0.6)
+						{
+							doSound = qtrue;
+						}
+					}
+
+					if ( error < 0.0)//-10.0 ) 
+					{
+						error += decay;
+						if ( error > 0.0 ) 
+						{
+							error = 0.0;
+						}
+					}
+					else if ( error > 0.0)//10.0 ) 
+					{
+						error -= decay;
+						if ( error < 0.0 ) 
+						{
+							error = 0.0;
+						}
+					}
+				}
+			}
+			else*/
+			
+			if ( error ) 
+			{
+				exact = qfalse;
+
+				decay = 60.0 + yawSpeed * 3;
+				decay *= 50.0 / 1000.0;//msec
+
+				if ( error < 0.0 ) 
+				{
+					error += decay;
+					if ( error > 0.0 ) 
+					{
+						error = 0.0;
+					}
+				}
+				else 
+				{
+					error -= decay;
+					if ( error < 0.0 ) 
+					{
+						error = 0.0;
+					}
+				}
+			}
+		}
+		ucmd.angles[PITCH] = ANGLE2SHORT( targetPitch + error ) - client->ps.delta_angles[PITCH];
+	}
+
+	ucmd.angles[ROLL] = ANGLE2SHORT ( NPC->client->ps.viewangles[ROLL] ) - client->ps.delta_angles[ROLL];
+
+	/*
+	if(doSound)
+	{
+		G_Sound(NPC, G_SoundIndex(va("sound/enemies/borg/borgservo%d.wav", Q_irand(1, 8))));
+	}
+	*/
+
+	return exact;
+
+#endif
+
+}
+
+void NPC_AimWiggle( vec3_t enemy_org )
+{
+	//shoot for somewhere between the head and torso
+	//NOTE: yes, I know this looks weird, but it works
+	if ( NPCInfo->aimErrorDebounceTime < level.time )
+	{
+		NPCInfo->aimOfs[0] = 0.3*Q_flrand(NPC->enemy->mins[0], NPC->enemy->maxs[0]);
+		NPCInfo->aimOfs[1] = 0.3*Q_flrand(NPC->enemy->mins[1], NPC->enemy->maxs[1]);
+		if ( NPC->enemy->maxs[2] > 0 )
+		{
+			NPCInfo->aimOfs[2] = NPC->enemy->maxs[2]*Q_flrand(0.0f, -1.0f);
+		}
+	}
+	VectorAdd( enemy_org, NPCInfo->aimOfs, enemy_org );
+}
+
+/*
+qboolean NPC_UpdateFiringAngles ( qboolean doPitch, qboolean doYaw ) 
+
+  Includes aim when determining angles - so they don't always hit...
+  */
+qboolean NPC_UpdateFiringAngles ( qboolean doPitch, qboolean doYaw ) 
+{
+
+#if 0
+
+	float		diff;
+	float		error;
+	float		targetPitch = 0;
+	float		targetYaw = 0;
+	qboolean	exact = qtrue;
+
+	if ( level.time < NPCInfo->aimTime ) 
+	{
+		if( doPitch )
+			targetPitch = NPCInfo->lockedDesiredPitch;
+
+		if( doYaw )
+			targetYaw = NPCInfo->lockedDesiredYaw;
+	}
+	else 
+	{
+		if( doPitch )
+		{
+			targetPitch = NPCInfo->desiredPitch;
+			NPCInfo->lockedDesiredPitch = NPCInfo->desiredPitch;
+		}
+
+		if( doYaw )
+		{
+			targetYaw = NPCInfo->desiredYaw;
+			NPCInfo->lockedDesiredYaw = NPCInfo->desiredYaw;
+		}			
+	}
+
+	if( doYaw )
+	{
+		// add yaw error based on NPCInfo->aim value
+		error = ((float)(6 - NPCInfo->stats.aim)) * Q_flrand(-1, 1);
+
+		if(Q_irand(0, 1))
+			error *= -1;
+
+		diff = AngleDelta ( NPC->client->ps.viewangles[YAW], targetYaw );
+
+		if ( diff )
+			exact = qfalse;
+		
+		ucmd.angles[YAW] = ANGLE2SHORT( targetYaw + diff + error ) - client->ps.delta_angles[YAW];
+	}
+
+	if( doPitch )
+	{
+		// add pitch error based on NPCInfo->aim value
+		error = ((float)(6 - NPCInfo->stats.aim)) * Q_flrand(-1, 1);
+
+		diff = AngleDelta ( NPC->client->ps.viewangles[PITCH], targetPitch );
+
+		if ( diff )
+			exact = qfalse;
+		
+		ucmd.angles[PITCH] = ANGLE2SHORT( targetPitch + diff + error ) - client->ps.delta_angles[PITCH];
+	}
+
+	ucmd.angles[ROLL] = ANGLE2SHORT ( NPC->client->ps.viewangles[ROLL] ) - client->ps.delta_angles[ROLL];
+
+	return exact;
+	
+#else
+
+	float		error, diff;
+	float		decay;
+	float		targetPitch = 0;
+	float		targetYaw = 0;
+	qboolean	exact = qtrue;
+
+	// if angle changes are locked; just keep the current angles
+	if ( level.time < NPCInfo->aimTime ) 
+	{
+		if(doPitch)
+			targetPitch = NPCInfo->lockedDesiredPitch;
+		if(doYaw)
+			targetYaw = NPCInfo->lockedDesiredYaw;
+	}
+	else 
+	{
+		if(doPitch)
+			targetPitch = NPCInfo->desiredPitch;
+		if(doYaw)
+			targetYaw = NPCInfo->desiredYaw;
+
+//		NPCInfo->aimTime = level.time + 250;
+		if(doPitch)
+			NPCInfo->lockedDesiredPitch = NPCInfo->desiredPitch;
+		if(doYaw)
+			NPCInfo->lockedDesiredYaw = NPCInfo->desiredYaw;
+	}
+
+	if ( NPCInfo->aimErrorDebounceTime < level.time )
+	{
+		if ( Q_irand(0, 1 ) )
+		{
+			NPCInfo->lastAimErrorYaw = ((float)(6 - NPCInfo->stats.aim)) * Q_flrand(-1, 1);
+		}
+		if ( Q_irand(0, 1 ) )
+		{
+			NPCInfo->lastAimErrorPitch = ((float)(6 - NPCInfo->stats.aim)) * Q_flrand(-1, 1);
+		}
+		NPCInfo->aimErrorDebounceTime = level.time + Q_irand(250, 2000);
+	}
+
+	if(doYaw)
+	{
+		// decay yaw diff
+		diff = AngleDelta ( NPC->client->ps.viewangles[YAW], targetYaw );
+		
+		if ( diff) 
+		{
+			exact = qfalse;
+
+			decay = 60.0 + 80.0;
+			decay *= 50.0f / 1000.0f;//msec
+			if ( diff < 0.0 ) 
+			{
+				diff += decay;
+				if ( diff > 0.0 ) 
+				{
+					diff = 0.0;
+				}
+			}
+			else 
+			{
+				diff -= decay;
+				if ( diff < 0.0 ) 
+				{
+					diff = 0.0;
+				}
+			}
+		}
+				
+		// add yaw error based on NPCInfo->aim value
+		error = NPCInfo->lastAimErrorYaw;
+
+		/*
+		if(Q_irand(0, 1))
+		{
+			error *= -1;
+		}
+		*/
+
+		ucmd.angles[YAW] = ANGLE2SHORT( targetYaw + diff + error ) - client->ps.delta_angles[YAW];
+	}
+
+	if(doPitch)
+	{
+		// decay pitch diff
+		diff = AngleDelta ( NPC->client->ps.viewangles[PITCH], targetPitch );
+		if ( diff) 
+		{
+			exact = qfalse;
+
+			decay = 60.0 + 80.0;
+			decay *= 50.0f / 1000.0f;//msec
+			if ( diff < 0.0 ) 
+			{
+				diff += decay;
+				if ( diff > 0.0 ) 
+				{
+					diff = 0.0;
+				}
+			}
+			else 
+			{
+				diff -= decay;
+				if ( diff < 0.0 ) 
+				{
+					diff = 0.0;
+				}
+			}
+		}
+		
+		error = NPCInfo->lastAimErrorPitch;
+
+		ucmd.angles[PITCH] = ANGLE2SHORT( targetPitch + diff + error ) - client->ps.delta_angles[PITCH];
+	}
+
+	ucmd.angles[ROLL] = ANGLE2SHORT ( NPC->client->ps.viewangles[ROLL] ) - client->ps.delta_angles[ROLL];
+
+	return exact;
+
+#endif
+
+}
+//===================================================================================
+
+/*
+static void NPC_UpdateShootAngles (vec3_t angles, qboolean doPitch, qboolean doYaw ) 
+
+Does update angles on shootAngles
+*/
+
+void NPC_UpdateShootAngles (vec3_t angles, qboolean doPitch, qboolean doYaw ) 
+{//FIXME: shoot angles either not set right or not used!
+	float		error;
+	float		decay;
+	float		targetPitch = 0;
+	float		targetYaw = 0;
+
+	if(doPitch)
+		targetPitch = angles[PITCH];
+	if(doYaw)
+		targetYaw = angles[YAW];
+
+
+	if(doYaw)
+	{
+		// decay yaw error
+		error = AngleDelta ( NPCInfo->shootAngles[YAW], targetYaw );
+		if ( error ) 
+		{
+			decay = 60.0 + 80.0 * NPCInfo->stats.aim;
+			decay *= 100.0f / 1000.0f;//msec
+			if ( error < 0.0 ) 
+			{
+				error += decay;
+				if ( error > 0.0 ) 
+				{
+					error = 0.0;
+				}
+			}
+			else 
+			{
+				error -= decay;
+				if ( error < 0.0 ) 
+				{
+					error = 0.0;
+				}
+			}
+		}
+		NPCInfo->shootAngles[YAW] = targetYaw + error;
+	}
+
+	if(doPitch)
+	{
+		// decay pitch error
+		error = AngleDelta ( NPCInfo->shootAngles[PITCH], targetPitch );
+		if ( error ) 
+		{
+			decay = 60.0 + 80.0 * NPCInfo->stats.aim;
+			decay *= 100.0f / 1000.0f;//msec
+			if ( error < 0.0 ) 
+			{
+				error += decay;
+				if ( error > 0.0 ) 
+				{
+					error = 0.0;
+				}
+			}
+			else 
+			{
+				error -= decay;
+				if ( error < 0.0 ) 
+				{
+					error = 0.0;
+				}
+			}
+		}
+		NPCInfo->shootAngles[PITCH] = targetPitch + error;
+	}
+}
+
+/*
+void SetTeamNumbers (void)
+
+Sets the number of living clients on each team
+
+FIXME: Does not account for non-respawned players!
+FIXME: Don't include medics?
+*/
+void SetTeamNumbers (void)
+{
+	gentity_t	*found;
+	int			i;
+
+	for( i = 0; i < TEAM_NUM_TEAMS; i++ )
+	{
+		teamNumbers[i] = 0;
+		teamStrength[i] = 0;
+	}
+
+	for( i = 0; i < 1 ; i++ )
+	{
+		found = &g_entities[i];
+
+		if( found->client )
+		{
+			if( found->health > 0 )//FIXME: or if a player!
+			{
+				teamNumbers[found->client->playerTeam]++;
+				teamStrength[found->client->playerTeam] += found->health;
+			}
+		}
+	}
+
+	for( i = 0; i < TEAM_NUM_TEAMS; i++ )
+	{//Get the average health
+		teamStrength[i] = floor( ((float)(teamStrength[i])) / ((float)(teamNumbers[i])) );
+	}
+}
+
+extern stringID_table_t BSTable[];
+extern stringID_table_t BSETTable[];
+qboolean G_ActivateBehavior (gentity_t *self, int bset )
+{
+	bState_t	bSID = (bState_t)-1;
+	char *bs_name = NULL;
+
+	if ( !self )
+	{
+		return qfalse;
+	}
+
+	bs_name = self->behaviorSet[bset];
+	
+	if( !(VALIDSTRING( bs_name )) )
+	{
+		return qfalse;
+	}
+
+	if ( self->NPC )
+	{
+		bSID = (bState_t)(GetIDForString( BSTable, bs_name ));
+	}
+
+	if(bSID > -1)
+	{
+		self->NPC->tempBehavior = BS_DEFAULT;
+		self->NPC->behaviorState = bSID;
+		if ( bSID == BS_SEARCH || bSID == BS_WANDER )
+		{
+			//FIXME: Reimplement?
+			if( self->waypoint != WAYPOINT_NONE )
+			{
+				NPC_BSSearchStart( self->waypoint, bSID );
+			}
+			else
+			{
+				self->waypoint = NAV::GetNearestNode(self);
+				if( self->waypoint != WAYPOINT_NONE )
+				{
+					NPC_BSSearchStart( self->waypoint, bSID );
+				}
+			}
+		}
+	}
+	else
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_VERBOSE, "%s attempting to run bSet %s (%s)\n", self->targetname, GetStringForID( BSETTable, bset ), bs_name );
+		Quake3Game()->RunScript( self, bs_name );
+	}
+	return qtrue;
+}
+
+
+/*
+=============================================================================
+
+	Extended Functions
+
+=============================================================================
+*/
+
+/*
+-------------------------
+NPC_ValidEnemy
+-------------------------
+*/
+
+qboolean G_ValidEnemy( gentity_t *self, gentity_t *enemy )
+{
+	//Must be a valid pointer
+	if ( enemy == NULL )
+		return qfalse;
+
+	//Must not be me
+	if ( enemy == self )
+		return qfalse;
+
+	//Must not be deleted
+	if ( enemy->inuse == qfalse )
+		return qfalse;
+
+	//Must be alive
+	if ( enemy->health <= 0 )
+		return qfalse;
+
+	//In case they're in notarget mode
+	if ( enemy->flags & FL_NOTARGET )
+		return qfalse;
+
+	//Must be an NPC
+	if ( enemy->client == NULL )
+	{
+		if ( enemy->svFlags&SVF_NONNPC_ENEMY )
+		{//still potentially valid
+			if (self->client)
+			{
+				if ( enemy->noDamageTeam == self->client->playerTeam )
+				{
+					return qfalse;
+				}
+				else
+				{
+					return qtrue;
+				}
+			}
+			else
+			{
+				if ( enemy->noDamageTeam == self->noDamageTeam )
+				{
+					return qfalse;
+				}
+				else
+				{
+					return qtrue;
+				}
+			}
+		}
+		else
+		{
+			return qfalse;
+		}
+	}
+
+	if ( enemy->client->playerTeam == TEAM_FREE && enemy->s.number < MAX_CLIENTS )
+	{//An evil player, everyone attacks him
+		return qtrue;
+	}
+
+	//Can't be on the same team
+	if ( enemy->client->playerTeam == self->client->playerTeam )
+	{
+		return qfalse;
+	}
+
+	//if haven't seen him in a while, give up
+	//if ( NPCInfo->enemyLastSeenTime != 0 && level.time - NPCInfo->enemyLastSeenTime > 7000 )//FIXME: make a stat?
+	//	return qfalse;
+
+	if ( enemy->client->playerTeam == self->client->enemyTeam //simplest case: they're on my enemy team
+		|| (self->client->enemyTeam == TEAM_FREE && enemy->client->NPC_class != self->client->NPC_class )//I get mad at anyone and this guy isn't the same class as me
+		|| (enemy->client->NPC_class == CLASS_WAMPA && enemy->enemy )//a rampaging wampa
+		|| (enemy->client->NPC_class == CLASS_RANCOR && enemy->enemy )//a rampaging rancor
+		|| (enemy->client->playerTeam == TEAM_FREE && enemy->client->enemyTeam == TEAM_FREE && enemy->enemy && enemy->enemy->client && (enemy->enemy->client->playerTeam == self->client->playerTeam||(enemy->enemy->client->playerTeam != TEAM_ENEMY&&self->client->playerTeam==TEAM_PLAYER))) //enemy is a rampaging non-aligned creature who is attacking someone on our team or a non-enemy (this last condition is used only if we're a good guy - in effect, we protect the innocent)
+		)
+	{
+		return qtrue;
+	}
+	//all other cases = false?
+	return qfalse;
+}
+
+qboolean NPC_ValidEnemy( gentity_t *ent )
+{
+	return G_ValidEnemy( NPC, ent );
+}
+
+/*
+-------------------------
+NPC_TargetVisible
+-------------------------
+*/
+
+qboolean NPC_TargetVisible( gentity_t *ent )
+{
+	//Make sure we're in a valid range
+	if ( DistanceSquared( ent->currentOrigin, NPC->currentOrigin ) > ( NPCInfo->stats.visrange * NPCInfo->stats.visrange ) )
+		return qfalse;
+
+	//Check our FOV
+	if ( InFOV( ent, NPC, NPCInfo->stats.hfov, NPCInfo->stats.vfov ) == qfalse )
+		return qfalse;
+
+	//Check for sight
+	if ( NPC_ClearLOS( ent ) == qfalse )
+		return qfalse;
+
+	return qtrue;
+}
+
+/*
+-------------------------
+NPC_GetCheckDelta
+-------------------------
+*/
+
+/*
+#define	CHECK_TIME_BASE				250
+#define CHECK_TIME_BASE_SQUARED		( CHECK_TIME_BASE * CHECK_TIME_BASE )
+
+static int NPC_GetCheckDelta( void )
+{
+	if ( NPC_ValidEnemy( NPC->enemy ) == qfalse )
+	{
+		int distance = DistanceSquared( NPC->currentOrigin, g_entities[0].currentOrigin );
+
+		distance /= CHECK_TIME_BASE_SQUARED;
+
+		return ( CHECK_TIME_BASE * distance );
+	}
+
+	return 0;
+}
+*/
+
+/*
+-------------------------
+NPC_FindNearestEnemy
+-------------------------
+*/
+
+#define	MAX_RADIUS_ENTS			256	//NOTE: This can cause entities to be lost
+#define NEAR_DEFAULT_RADIUS		256
+extern gentity_t *G_CheckControlledTurretEnemy(gentity_t *self,  gentity_t *enemy, qboolean validate );
+
+int NPC_FindNearestEnemy( gentity_t *ent )
+{
+	gentity_t	*radiusEnts[ MAX_RADIUS_ENTS ];
+	gentity_t	*nearest;
+	vec3_t		mins, maxs;
+	int			nearestEntID = -1;
+	float		nearestDist = (float)WORLD_SIZE*(float)WORLD_SIZE;
+	float		distance;
+	int			numEnts, numChecks = 0;
+
+	//Setup the bbox to search in
+	for ( int i = 0; i < 3; i++ )
+	{
+		mins[i] = ent->currentOrigin[i] - NPCInfo->stats.visrange;
+		maxs[i] = ent->currentOrigin[i] + NPCInfo->stats.visrange;
+	}
+
+	//Get a number of entities in a given space
+	numEnts = gi.EntitiesInBox( mins, maxs, radiusEnts, MAX_RADIUS_ENTS );
+
+	for ( i = 0; i < numEnts; i++ )
+	{
+		nearest = G_CheckControlledTurretEnemy(ent, radiusEnts[i], qtrue);
+
+		//Don't consider self
+		if ( nearest == ent )
+			continue;
+
+		//Must be valid
+		if ( NPC_ValidEnemy( nearest ) == qfalse )
+			continue;
+
+		numChecks++;
+		//Must be visible
+		if ( NPC_TargetVisible( nearest ) == qfalse )
+			continue;
+
+		distance = DistanceSquared( ent->currentOrigin, nearest->currentOrigin );
+
+		//Found one closer to us
+		if ( distance < nearestDist )
+		{
+			nearestEntID = nearest->s.number;
+			nearestDist = distance;
+		}
+	}
+
+	return nearestEntID;
+}
+
+/*
+-------------------------
+NPC_PickEnemyExt
+-------------------------
+*/
+
+gentity_t *NPC_PickEnemyExt( qboolean checkAlerts = qfalse )
+{
+	//Check for Hazard Team status and remove this check
+	/*
+	if ( NPC->client->playerTeam != TEAM_STARFLEET )
+	{
+		//If we've found the player, return it
+		if ( NPC_FindPlayer() )
+			return &g_entities[0];
+	}
+	*/
+
+	//If we've asked for the closest enemy
+	int entID = NPC_FindNearestEnemy( NPC );
+
+	//If we have a valid enemy, use it
+	if ( entID >= 0 )
+		return &g_entities[entID];
+
+	if ( checkAlerts )
+	{
+		int alertEvent = NPC_CheckAlertEvents( qtrue, qtrue, -1, qtrue, AEL_DISCOVERED );
+
+		//There is an event to look at
+		if ( alertEvent >= 0 )
+		{
+			alertEvent_t *event = &level.alertEvents[alertEvent];
+
+			//Don't pay attention to our own alerts
+			if ( event->owner == NPC )
+				return NULL;
+
+			if ( event->level >= AEL_DISCOVERED )
+			{
+				//If it's the player, attack him
+				if ( event->owner == &g_entities[0] )
+					return event->owner;
+
+				//If it's on our team, then take its enemy as well
+				if ( ( event->owner->client ) && ( event->owner->client->playerTeam == NPC->client->playerTeam ) )
+					return event->owner->enemy;
+			}
+		}
+	}
+
+	return NULL;
+}
+
+/*
+-------------------------
+NPC_FindPlayer
+-------------------------
+*/
+
+qboolean NPC_FindPlayer( void )
+{
+	return NPC_TargetVisible( &g_entities[0] );
+}
+
+/*
+-------------------------
+NPC_CheckPlayerDistance
+-------------------------
+*/
+
+static qboolean NPC_CheckPlayerDistance( void )
+{
+	//Make sure we have an enemy
+	if ( NPC->enemy == NULL )
+		return qfalse;
+
+	//Only do this for non-players
+	if ( NPC->enemy->s.number == 0 )
+		return qfalse;
+
+	//must be set up to get mad at player
+	if ( !NPC->client || NPC->client->enemyTeam != TEAM_PLAYER )
+		return qfalse;
+
+	//Must be within our FOV
+	if ( InFOV( &g_entities[0], NPC, NPCInfo->stats.hfov, NPCInfo->stats.vfov ) == qfalse )
+		return qfalse;
+
+	float	distance = DistanceSquared( NPC->currentOrigin, NPC->enemy->currentOrigin );
+
+	if ( distance > DistanceSquared( NPC->currentOrigin, g_entities[0].currentOrigin ) )
+	{
+		G_SetEnemy( NPC, &g_entities[0] );
+		return qtrue;
+	}
+
+	return qfalse;
+}
+
+/*
+-------------------------
+NPC_FindEnemy
+-------------------------
+*/
+
+qboolean NPC_FindEnemy( qboolean checkAlerts = qfalse )
+{
+	//We're ignoring all enemies for now
+	if( NPC->svFlags & SVF_IGNORE_ENEMIES )
+	{
+		G_ClearEnemy( NPC );
+		return qfalse;
+	}
+
+	//we can't pick up any enemies for now
+	if( NPCInfo->confusionTime > level.time )
+	{
+		G_ClearEnemy( NPC );
+		return qfalse;
+	}
+
+	//Don't want a new enemy
+	if ( ( NPC_ValidEnemy( NPC->enemy ) ) && ( NPC->svFlags & SVF_LOCKEDENEMY ) )
+		return qtrue;
+
+	//See if the player is closer than our current enemy
+	if ( NPC->client->NPC_class != CLASS_RANCOR 
+		&& NPC->client->NPC_class != CLASS_WAMPA
+		&& NPC->client->NPC_class != CLASS_SAND_CREATURE
+		&& NPC_CheckPlayerDistance() )
+	{//rancors, wampas & sand creatures don't care if player is closer, they always go with closest
+		return qtrue;
+	}
+
+	//Otherwise, turn off the flag
+	NPC->svFlags &= ~SVF_LOCKEDENEMY;
+
+	//If we've gotten here alright, then our target it still valid
+	if ( NPC_ValidEnemy( NPC->enemy ) )
+		return qtrue;
+
+	gentity_t *newenemy = NPC_PickEnemyExt( checkAlerts );
+
+	//if we found one, take it as the enemy
+	if( NPC_ValidEnemy( newenemy ) )
+	{
+		G_SetEnemy( NPC, newenemy );
+		return qtrue;
+	}
+
+	G_ClearEnemy( NPC );
+	return qfalse;
+}
+
+/*
+-------------------------
+NPC_CheckEnemyExt
+-------------------------
+*/
+
+qboolean NPC_CheckEnemyExt( qboolean checkAlerts )
+{
+	//Make sure we're ready to think again
+/*
+	if ( NPCInfo->enemyCheckDebounceTime > level.time )
+		return qfalse;
+
+	//Get our next think time
+	NPCInfo->enemyCheckDebounceTime = level.time + NPC_GetCheckDelta();
+
+	//Attempt to find an enemy
+	return NPC_FindEnemy();
+*/
+	return NPC_FindEnemy( checkAlerts );
+}
+
+/*
+-------------------------
+NPC_FacePosition
+-------------------------
+*/
+
+qboolean NPC_FacePosition( vec3_t position, qboolean doPitch )
+{
+	vec3_t		muzzle;
+	qboolean	facing = qtrue;
+
+	//Get the positions
+	if ( NPC->client && (NPC->client->NPC_class == CLASS_RANCOR || NPC->client->NPC_class == CLASS_WAMPA || NPC->client->NPC_class == CLASS_SAND_CREATURE) )
+	{
+		CalcEntitySpot( NPC, SPOT_ORIGIN, muzzle );
+		muzzle[2] += NPC->maxs[2] * 0.75f;
+	}
+	else if ( NPC->client && NPC->client->NPC_class == CLASS_GALAKMECH )
+	{
+		CalcEntitySpot( NPC, SPOT_WEAPON, muzzle );
+	}
+	else
+	{
+		CalcEntitySpot( NPC, SPOT_HEAD_LEAN, muzzle );//SPOT_HEAD
+		if ( NPC->client->NPC_class == CLASS_ROCKETTROOPER )
+		{//*sigh*, look down more
+			position[2] -= 32;
+		}
+	}
+
+	//Find the desired angles
+	vec3_t	angles;
+
+	GetAnglesForDirection( muzzle, position, angles );
+
+	NPCInfo->desiredYaw		= AngleNormalize360( angles[YAW] );
+	NPCInfo->desiredPitch	= AngleNormalize360( angles[PITCH] );
+
+	if ( NPC->enemy && NPC->enemy->client && NPC->enemy->client->NPC_class == CLASS_ATST )
+	{
+		// FIXME: this is kind of dumb, but it was the easiest way to get it to look sort of ok
+		NPCInfo->desiredYaw	+= Q_flrand( -5, 5 ) + sin( level.time * 0.004f ) * 7;
+		NPCInfo->desiredPitch += Q_flrand( -2, 2 );
+	}
+	//Face that yaw
+	NPC_UpdateAngles( qtrue, qtrue );
+
+	//Find the delta between our goal and our current facing
+	float yawDelta = AngleNormalize360( NPCInfo->desiredYaw - ( SHORT2ANGLE( ucmd.angles[YAW] + client->ps.delta_angles[YAW] ) ) );
+	
+	//See if we are facing properly
+	if ( fabs( yawDelta ) > VALID_ATTACK_CONE )
+		facing = qfalse;
+
+	if ( doPitch )
+	{
+		//Find the delta between our goal and our current facing
+		float currentAngles = ( SHORT2ANGLE( ucmd.angles[PITCH] + client->ps.delta_angles[PITCH] ) );
+		float pitchDelta = NPCInfo->desiredPitch - currentAngles;
+		
+		//See if we are facing properly
+		if ( fabs( pitchDelta ) > VALID_ATTACK_CONE )
+			facing = qfalse;
+	}
+
+	return facing;
+}
+
+/*
+-------------------------
+NPC_FaceEntity
+-------------------------
+*/
+
+qboolean NPC_FaceEntity( gentity_t *ent, qboolean doPitch )
+{
+	vec3_t		entPos;
+
+	//Get the positions
+	CalcEntitySpot( ent, SPOT_HEAD_LEAN, entPos );
+
+	return NPC_FacePosition( entPos, doPitch );
+}
+
+/*
+-------------------------
+NPC_FaceEnemy
+-------------------------
+*/
+
+qboolean NPC_FaceEnemy( qboolean doPitch )
+{
+	if ( NPC == NULL )
+		return qfalse;
+
+	if ( NPC->enemy == NULL )
+		return qfalse;
+
+	return NPC_FaceEntity( NPC->enemy, doPitch );
+}
+
+/*
+-------------------------
+NPC_CheckCanAttackExt
+-------------------------
+*/
+
+qboolean NPC_CheckCanAttackExt( void )
+{
+	//We don't want them to shoot
+	if( NPCInfo->scriptFlags & SCF_DONT_FIRE )
+		return qfalse;
+
+	//Turn to face
+	if ( NPC_FaceEnemy( qtrue ) == qfalse )
+		return qfalse;
+
+	//Must have a clear line of sight to the target
+	if ( NPC_ClearShot( NPC->enemy ) == qfalse )
+		return qfalse;
+
+	return qtrue;
+}
+
+/*
+-------------------------
+NPC_ClearLookTarget
+-------------------------
+*/
+
+void NPC_ClearLookTarget( gentity_t *self )
+{
+	if ( !self->client )
+	{
+		return;
+	}
+
+	self->client->renderInfo.lookTarget = ENTITYNUM_NONE;//ENTITYNUM_WORLD;
+	self->client->renderInfo.lookTargetClearTime = 0;
+}
+
+/*
+-------------------------
+NPC_SetLookTarget
+-------------------------
+*/
+void NPC_SetLookTarget( gentity_t *self, int entNum, int clearTime )
+{
+	if ( !self->client )
+	{
+		return;
+	}
+
+	self->client->renderInfo.lookTarget = entNum;
+	self->client->renderInfo.lookTargetClearTime = clearTime;
+}
+
+/*
+-------------------------
+NPC_CheckLookTarget
+-------------------------
+*/
+qboolean NPC_CheckLookTarget( gentity_t *self )
+{
+	if ( self->client )
+	{
+		if ( self->client->renderInfo.lookTarget >= 0 && self->client->renderInfo.lookTarget < ENTITYNUM_WORLD )
+		{//within valid range
+			if ( (&g_entities[self->client->renderInfo.lookTarget] == NULL) || !g_entities[self->client->renderInfo.lookTarget].inuse )
+			{//lookTarget not inuse or not valid anymore
+				NPC_ClearLookTarget( self );
+			}
+			else if ( self->client->renderInfo.lookTargetClearTime && self->client->renderInfo.lookTargetClearTime < level.time )
+			{//Time to clear lookTarget
+				NPC_ClearLookTarget( self );
+			}
+			else if ( g_entities[self->client->renderInfo.lookTarget].client && self->enemy && (&g_entities[self->client->renderInfo.lookTarget] != self->enemy) )
+			{//should always look at current enemy if engaged in battle... FIXME: this could override certain scripted lookTargets...???
+				NPC_ClearLookTarget( self );
+			}
+			else
+			{
+				return qtrue;
+			}
+		}
+	}
+
+	return qfalse;
+}
+
+/*
+-------------------------
+NPC_CheckCharmed
+-------------------------
+*/
+extern void G_AddVoiceEvent( gentity_t *self, int event, int speakDebounceTime );
+void G_CheckCharmed( gentity_t *self )
+{
+	if ( self
+		&& self->client
+		&& self->client->playerTeam == TEAM_PLAYER 
+		&& self->NPC
+		&& self->NPC->charmedTime 
+		&& (self->NPC->charmedTime < level.time ||self->health <= 0) )
+	{//we were charmed, set us back!
+		//NOTE: presumptions here...
+		team_t	savTeam = self->client->enemyTeam;
+		self->client->enemyTeam = self->client->playerTeam;
+		self->client->playerTeam = savTeam;
+		self->client->leader = NULL;
+		self->NPC->charmedTime = 0;
+		if ( self->health > 0 )
+		{
+			if ( self->NPC->tempBehavior == BS_FOLLOW_LEADER )
+			{
+				self->NPC->tempBehavior = BS_DEFAULT;
+			}
+			G_ClearEnemy( self );
+			//say something to let player know you've snapped out of it
+			G_AddVoiceEvent( self, Q_irand(EV_CONFUSE1, EV_CONFUSE3), 2000 );
+		}
+	}
+
+}
+
+void G_GetBoltPosition( gentity_t *self, int boltIndex, vec3_t pos, int modelIndex = 0 )
+{
+	if ( !self || !self->ghoul2.size() )
+	{
+		return;
+	}
+	mdxaBone_t	boltMatrix;
+	vec3_t		result, angles={0,self->currentAngles[YAW],0};
+
+	gi.G2API_GetBoltMatrix( self->ghoul2, modelIndex, 
+				boltIndex,
+				&boltMatrix, angles, self->currentOrigin, (cg.time?cg.time:level.time),
+				NULL, self->s.modelScale );
+	if ( pos )
+	{
+        gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, result );
+		VectorCopy( result, pos );
+	}
+}
+
+float NPC_EntRangeFromBolt( gentity_t *targEnt, int boltIndex )
+{
+	vec3_t	org;
+
+	if ( !targEnt )
+	{
+		return Q3_INFINITE;
+	}
+
+	G_GetBoltPosition( NPC, boltIndex, org );
+
+	return (Distance( targEnt->currentOrigin, org ));
+}
+
+float NPC_EnemyRangeFromBolt( int boltIndex )
+{
+	return (NPC_EntRangeFromBolt( NPC->enemy, boltIndex ));
+}
+
+int G_GetEntsNearBolt( gentity_t *self, gentity_t **radiusEnts, float radius, int boltIndex, vec3_t boltOrg )
+{
+	vec3_t		mins, maxs;
+	int			i;
+
+	//get my handRBolt's position
+	vec3_t	org;
+
+	G_GetBoltPosition( self, boltIndex, org );
+
+	VectorCopy( org, boltOrg );
+
+	//Setup the bbox to search in
+	for ( i = 0; i < 3; i++ )
+	{
+		mins[i] = boltOrg[i] - radius;
+		maxs[i] = boltOrg[i] + radius;
+	}
+
+	//Get the number of entities in a given space
+	return (gi.EntitiesInBox( mins, maxs, radiusEnts, 128 ));
+}
+
+int NPC_GetEntsNearBolt( gentity_t **radiusEnts, float radius, int boltIndex, vec3_t boltOrg )
+{
+	return (G_GetEntsNearBolt( NPC, radiusEnts, radius, boltIndex, boltOrg ));
+}
+
+extern qboolean RT_Flying( gentity_t *self );
+extern void RT_FlyStart( gentity_t *self );
+extern void RT_FlyStop( gentity_t *self );
+extern qboolean Boba_Flying( gentity_t *self );
+extern void Boba_FlyStart( gentity_t *self );
+extern void Boba_FlyStop( gentity_t *self );
+
+qboolean JET_Flying( gentity_t *self )
+{
+	if ( !self || !self->client )
+	{
+		return qfalse;
+	}
+	if ( self->client->NPC_class == CLASS_BOBAFETT )
+	{
+		return (Boba_Flying(self));
+	}
+	else if ( self->client->NPC_class == CLASS_ROCKETTROOPER )
+	{
+		return (RT_Flying(self));
+	}
+	else
+	{
+		return qfalse;
+	}
+}
+
+void JET_FlyStart( gentity_t *self )
+{
+	if ( !self || !self->client )
+	{
+		return;
+	}
+	self->lastInAirTime = level.time;
+	if ( self->client->NPC_class == CLASS_BOBAFETT )
+	{
+		Boba_FlyStart( self );
+	}
+	else if ( self->client->NPC_class == CLASS_ROCKETTROOPER )
+	{
+		RT_FlyStart( self );
+	}
+}
+
+void JET_FlyStop( gentity_t *self )
+{
+	if ( !self || !self->client )
+	{
+		return;
+	}
+	if ( self->client->NPC_class == CLASS_BOBAFETT )
+	{
+		Boba_FlyStop( self );
+	}
+	else if ( self->client->NPC_class == CLASS_ROCKETTROOPER )
+	{
+		RT_FlyStop( self );
+	}
+}
diff --git a/code/game/Q3_Interface.cpp b/code/game/Q3_Interface.cpp
new file mode 100644
index 0000000..a153a03
--- /dev/null
+++ b/code/game/Q3_Interface.cpp
@@ -0,0 +1,11277 @@
+// ICARUS Engine Interface File
+//
+//	This file is the only section of the ICARUS systems that 
+//	is not directly portable from engine to engine.
+//
+//	-- jweier
+
+// leave this line at the top for PCH reasons...
+#include "g_headers.h"
+
+#include "g_local.h"
+#include "g_functions.h"
+#include "Q3_Interface.h"
+#include "anims.h"
+#include "b_local.h"
+#include "events.h"
+#include "g_nav.h"
+#include "..\cgame\cg_camera.h"
+#include "..\game\objectives.h"
+#include "g_roff.h"
+#include "..\cgame\cg_local.h"
+#include "wp_saber.h"
+#include "g_vehicles.h"
+
+extern	cvar_t	*com_buildScript;
+
+extern void InitMover( gentity_t *ent );
+extern void MatchTeam( gentity_t *teamLeader, int moverState, int time );
+//extern void SetMoverState( gentity_t *ent, moverState_t moverState, int time );
+extern void ChangeWeapon( gentity_t *ent, int newWeapon );
+extern char *G_GetLocationForEnt( gentity_t *ent );
+extern void NPC_BSSearchStart( int homeWp, bState_t bState );
+extern void InitMoverTrData( gentity_t *ent );
+extern qboolean SpotWouldTelefrag2( gentity_t *mover, vec3_t dest );
+extern cvar_t *g_sex;
+extern cvar_t *g_timescale;
+extern void G_SetEnemy( gentity_t *self, gentity_t *enemy );
+//extern void FX_BorgTeleport( vec3_t org );
+static void Q3_SetWeapon (int entID, const char *wp_name);
+static void Q3_SetItem (int entID, const char *item_name);
+extern void CG_ChangeWeapon( int num );
+extern int	TAG_GetOrigin2( const char *owner, const char *name, vec3_t origin );
+extern void G_TeamRetaliation ( gentity_t *targ, gentity_t *attacker, qboolean stopIcarus );
+extern void G_PlayDoorLoopSound( gentity_t *ent );
+extern void G_PlayDoorSound( gentity_t *ent, int type );
+extern void NPC_SetLookTarget( gentity_t *self, int entNum, int clearTime );
+extern void NPC_ClearLookTarget( gentity_t *self );
+extern void WP_SaberSetColor( gentity_t *ent, int saberNum, int bladeNum, char *colorName );
+extern void WP_SetSaber( gentity_t *ent, int saberNum, char *saberName );
+extern qboolean PM_HasAnimation( gentity_t *ent, int animation );
+extern void G_ChangePlayerModel( gentity_t *ent, const char *newModel );
+extern vehicleType_t TranslateVehicleName( char *name );
+extern void WP_SetSaberOrigin( gentity_t *self, vec3_t newOrg );
+extern void JET_FlyStart( gentity_t *self );
+extern void JET_FlyStop( gentity_t *self );
+extern void Rail_LockCenterOfTrack(const char* trackName);
+extern void Rail_UnLockCenterOfTrack(const char* trackName);
+extern void G_GetBoltPosition( gentity_t *self, int boltIndex, vec3_t pos, int modelIndex = 0 );
+extern qboolean G_DoDismemberment( gentity_t *self, vec3_t point, int mod, int damage, int hitLoc, qboolean force = qfalse );
+
+extern int	BMS_START;
+extern int	BMS_MID;
+extern int	BMS_END;
+extern cvar_t	*g_skippingcin;
+
+extern qboolean	stop_icarus;
+
+static void PrisonerObjCheck(const char *name,const char *data);
+
+#define stringIDExpand(str, strEnum)	str, strEnum, ENUM2STRING(strEnum)
+//#define stringIDExpand(str, strEnum)	str,strEnum
+
+/*
+stringID_table_t tagsTable [] = 
+{
+}
+*/
+
+stringID_table_t BSTable[] =
+{
+	ENUM2STRING(BS_DEFAULT),//# default behavior for that NPC
+	ENUM2STRING(BS_ADVANCE_FIGHT),//# Advance to captureGoal and shoot enemies if you can
+	ENUM2STRING(BS_SLEEP),//# Play awake script when startled by sound
+	ENUM2STRING(BS_FOLLOW_LEADER),//# Follow your leader and shoot any enemies you come across
+	ENUM2STRING(BS_JUMP),//# Face navgoal and jump to it.
+	ENUM2STRING(BS_SEARCH),//# Using current waypoint as a base), search the immediate branches of waypoints for enemies
+	ENUM2STRING(BS_WANDER),//# Wander down random waypoint paths
+	ENUM2STRING(BS_NOCLIP),//# Moves through walls), etc.
+	ENUM2STRING(BS_REMOVE),//# Waits for player to leave PVS then removes itself
+	ENUM2STRING(BS_CINEMATIC),//# Does nothing but face it's angles and move to a goal if it has one
+	ENUM2STRING(BS_FLEE),//# Run toward the nav goal, avoiding danger
+	//the rest are internal only
+	"",				-1,
+};
+
+
+
+stringID_table_t BSETTable[] =
+{
+	ENUM2STRING(BSET_SPAWN),//# script to use when first spawned
+	ENUM2STRING(BSET_USE),//# script to use when used
+	ENUM2STRING(BSET_AWAKE),//# script to use when awoken/startled
+	ENUM2STRING(BSET_ANGER),//# script to use when aquire an enemy
+	ENUM2STRING(BSET_ATTACK),//# script to run when you attack
+	ENUM2STRING(BSET_VICTORY),//# script to run when you kill someone
+	ENUM2STRING(BSET_LOSTENEMY),//# script to run when you can't find your enemy
+	ENUM2STRING(BSET_PAIN),//# script to use when take pain
+	ENUM2STRING(BSET_FLEE),//# script to use when take pain below 50% of health
+	ENUM2STRING(BSET_DEATH),//# script to use when killed
+	ENUM2STRING(BSET_DELAYED),//# script to run when self->delayScriptTime is reached
+	ENUM2STRING(BSET_BLOCKED),//# script to run when blocked by a friendly NPC or player
+	ENUM2STRING(BSET_BUMPED),//# script to run when bumped into a friendly NPC or player (can set bumpRadius)
+	ENUM2STRING(BSET_STUCK),//# script to run when blocked by a wall
+	ENUM2STRING(BSET_FFIRE),//# script to run when player shoots their own teammates
+	ENUM2STRING(BSET_FFDEATH),//# script to run when player kills a teammate
+	stringIDExpand("", BSET_INVALID),
+	"",				-1,
+};
+
+stringID_table_t WPTable[] =
+{
+	"NULL",WP_NONE,
+	ENUM2STRING(WP_NONE),
+	// Player weapons
+	ENUM2STRING(WP_SABER),				 // NOTE: lots of code assumes this is the first weapon (... which is crap) so be careful -Ste.
+	ENUM2STRING(WP_BLASTER_PISTOL),	// apparently some enemy only version of the blaster
+	ENUM2STRING(WP_BLASTER),
+	ENUM2STRING(WP_DISRUPTOR),
+	ENUM2STRING(WP_BOWCASTER),
+	ENUM2STRING(WP_REPEATER),
+	ENUM2STRING(WP_DEMP2),
+	ENUM2STRING(WP_FLECHETTE),
+	ENUM2STRING(WP_ROCKET_LAUNCHER),
+	ENUM2STRING(WP_THERMAL),
+	ENUM2STRING(WP_TRIP_MINE),
+	ENUM2STRING(WP_DET_PACK),
+	ENUM2STRING(WP_CONCUSSION),
+	ENUM2STRING(WP_MELEE),			// Any ol' melee attack
+	//NOTE: player can only have up to 16 weapons), anything after that is enemy only
+	ENUM2STRING(WP_STUN_BATON),
+	// NPC enemy weapons
+	ENUM2STRING(WP_BRYAR_PISTOL),
+	ENUM2STRING(WP_EMPLACED_GUN),
+	ENUM2STRING(WP_BOT_LASER),		// Probe droid	- Laser blast
+	ENUM2STRING(WP_TURRET),			// turret guns 
+	ENUM2STRING(WP_ATST_MAIN),
+	ENUM2STRING(WP_ATST_SIDE),
+	ENUM2STRING(WP_TIE_FIGHTER),
+	ENUM2STRING(WP_RAPID_FIRE_CONC),
+	ENUM2STRING(WP_JAWA),
+	ENUM2STRING(WP_TUSKEN_RIFLE),
+	ENUM2STRING(WP_TUSKEN_STAFF),
+	ENUM2STRING(WP_SCEPTER),
+	ENUM2STRING(WP_NOGHRI_STICK),
+	"", NULL
+};
+
+stringID_table_t INVTable[] =
+{
+	ENUM2STRING(INV_ELECTROBINOCULARS),
+	ENUM2STRING(INV_BACTA_CANISTER),
+	ENUM2STRING(INV_SEEKER),
+	ENUM2STRING(INV_LIGHTAMP_GOGGLES),
+	ENUM2STRING(INV_SENTRY),
+	"", NULL
+};
+
+stringID_table_t eventTable[] =
+{
+	//BOTH_h
+	//END
+	"",				EV_BAD,
+};
+
+stringID_table_t DMSTable[] =
+{
+	"NULL",-1,
+	ENUM2STRING(DM_AUTO),	//# let the game determine the dynamic music as normal
+	ENUM2STRING(DM_SILENCE),	//# stop the music
+	ENUM2STRING(DM_EXPLORE),	//# force the exploration music to play
+	ENUM2STRING(DM_ACTION),	//# force the action music to play
+	ENUM2STRING(DM_BOSS),	//# force the boss battle music to play (if there is any)
+	ENUM2STRING(DM_DEATH),	//# force the "player dead" music to play
+	"", -1
+};
+
+stringID_table_t HLTable[] =
+{
+	"NULL",-1,
+	ENUM2STRING(HL_FOOT_RT),
+	ENUM2STRING(HL_FOOT_LT),
+	ENUM2STRING(HL_LEG_RT),
+	ENUM2STRING(HL_LEG_LT),
+	ENUM2STRING(HL_WAIST),
+	ENUM2STRING(HL_BACK_RT),
+	ENUM2STRING(HL_BACK_LT),
+	ENUM2STRING(HL_BACK),
+	ENUM2STRING(HL_CHEST_RT),
+	ENUM2STRING(HL_CHEST_LT),
+	ENUM2STRING(HL_CHEST),
+	ENUM2STRING(HL_ARM_RT),
+	ENUM2STRING(HL_ARM_LT),
+	ENUM2STRING(HL_HAND_RT),
+	ENUM2STRING(HL_HAND_LT),
+	ENUM2STRING(HL_HEAD),
+	ENUM2STRING(HL_GENERIC1),
+	ENUM2STRING(HL_GENERIC2),
+	ENUM2STRING(HL_GENERIC3),
+	ENUM2STRING(HL_GENERIC4),
+	ENUM2STRING(HL_GENERIC5),
+	ENUM2STRING(HL_GENERIC6),
+	"", -1
+};
+
+stringID_table_t setTable[] =
+{
+	ENUM2STRING(SET_SPAWNSCRIPT),//0
+	ENUM2STRING(SET_USESCRIPT),
+	ENUM2STRING(SET_AWAKESCRIPT),
+	ENUM2STRING(SET_ANGERSCRIPT),
+	ENUM2STRING(SET_ATTACKSCRIPT),
+	ENUM2STRING(SET_VICTORYSCRIPT),
+	ENUM2STRING(SET_PAINSCRIPT),
+	ENUM2STRING(SET_FLEESCRIPT),
+	ENUM2STRING(SET_DEATHSCRIPT),
+	ENUM2STRING(SET_DELAYEDSCRIPT),
+	ENUM2STRING(SET_BLOCKEDSCRIPT),
+	ENUM2STRING(SET_FFIRESCRIPT),
+	ENUM2STRING(SET_FFDEATHSCRIPT),
+	ENUM2STRING(SET_MINDTRICKSCRIPT),
+	ENUM2STRING(SET_NO_MINDTRICK),
+	ENUM2STRING(SET_ORIGIN),
+	ENUM2STRING(SET_TELEPORT_DEST),
+	ENUM2STRING(SET_ANGLES),
+	ENUM2STRING(SET_XVELOCITY),
+	ENUM2STRING(SET_YVELOCITY),
+	ENUM2STRING(SET_ZVELOCITY),
+	ENUM2STRING(SET_Z_OFFSET),
+	ENUM2STRING(SET_ENEMY),
+	ENUM2STRING(SET_LEADER),
+	ENUM2STRING(SET_NAVGOAL),
+	ENUM2STRING(SET_ANIM_UPPER),
+	ENUM2STRING(SET_ANIM_LOWER),
+	ENUM2STRING(SET_ANIM_BOTH),
+	ENUM2STRING(SET_ANIM_HOLDTIME_LOWER),
+	ENUM2STRING(SET_ANIM_HOLDTIME_UPPER),
+	ENUM2STRING(SET_ANIM_HOLDTIME_BOTH),
+	ENUM2STRING(SET_PLAYER_TEAM),
+	ENUM2STRING(SET_ENEMY_TEAM),
+	ENUM2STRING(SET_BEHAVIOR_STATE),
+	ENUM2STRING(SET_BEHAVIOR_STATE),
+	ENUM2STRING(SET_HEALTH),
+	ENUM2STRING(SET_ARMOR),
+	ENUM2STRING(SET_DEFAULT_BSTATE),
+	ENUM2STRING(SET_CAPTURE),
+	ENUM2STRING(SET_DPITCH),
+	ENUM2STRING(SET_DYAW),
+	ENUM2STRING(SET_EVENT),
+	ENUM2STRING(SET_TEMP_BSTATE),
+	ENUM2STRING(SET_COPY_ORIGIN),
+	ENUM2STRING(SET_VIEWTARGET),
+	ENUM2STRING(SET_WEAPON),
+	ENUM2STRING(SET_ITEM),
+	ENUM2STRING(SET_WALKSPEED),
+	ENUM2STRING(SET_RUNSPEED),
+	ENUM2STRING(SET_YAWSPEED),
+	ENUM2STRING(SET_AGGRESSION),
+	ENUM2STRING(SET_AIM),
+	ENUM2STRING(SET_FRICTION),
+	ENUM2STRING(SET_GRAVITY),
+	ENUM2STRING(SET_IGNOREPAIN),
+	ENUM2STRING(SET_IGNOREENEMIES),
+	ENUM2STRING(SET_IGNOREALERTS),
+	ENUM2STRING(SET_DONTSHOOT),
+	ENUM2STRING(SET_DONTFIRE),
+	ENUM2STRING(SET_LOCKED_ENEMY),
+	ENUM2STRING(SET_NOTARGET),
+	ENUM2STRING(SET_LEAN),
+	ENUM2STRING(SET_CROUCHED),
+	ENUM2STRING(SET_WALKING),
+	ENUM2STRING(SET_RUNNING),
+	ENUM2STRING(SET_CHASE_ENEMIES),
+	ENUM2STRING(SET_LOOK_FOR_ENEMIES),
+	ENUM2STRING(SET_FACE_MOVE_DIR),
+	ENUM2STRING(SET_ALT_FIRE),
+	ENUM2STRING(SET_DONT_FLEE),
+	ENUM2STRING(SET_FORCED_MARCH),
+	ENUM2STRING(SET_NO_RESPONSE),
+	ENUM2STRING(SET_NO_COMBAT_TALK),
+	ENUM2STRING(SET_NO_ALERT_TALK),
+	ENUM2STRING(SET_UNDYING),
+	ENUM2STRING(SET_TREASONED),
+	ENUM2STRING(SET_DISABLE_SHADER_ANIM),
+	ENUM2STRING(SET_SHADER_ANIM),
+	ENUM2STRING(SET_INVINCIBLE),
+	ENUM2STRING(SET_NOAVOID),
+	ENUM2STRING(SET_SHOOTDIST),
+	ENUM2STRING(SET_TARGETNAME),
+	ENUM2STRING(SET_TARGET),
+	ENUM2STRING(SET_TARGET2),
+	ENUM2STRING(SET_LOCATION),
+	ENUM2STRING(SET_PAINTARGET),
+	ENUM2STRING(SET_TIMESCALE),
+	ENUM2STRING(SET_VISRANGE),
+	ENUM2STRING(SET_EARSHOT),
+	ENUM2STRING(SET_VIGILANCE),
+	ENUM2STRING(SET_HFOV),
+	ENUM2STRING(SET_VFOV),
+	ENUM2STRING(SET_DELAYSCRIPTTIME),
+	ENUM2STRING(SET_FORWARDMOVE),
+	ENUM2STRING(SET_RIGHTMOVE),
+	ENUM2STRING(SET_LOCKYAW),
+	ENUM2STRING(SET_SOLID),
+	ENUM2STRING(SET_CAMERA_GROUP),
+	ENUM2STRING(SET_CAMERA_GROUP_Z_OFS),
+	ENUM2STRING(SET_CAMERA_GROUP_TAG),
+	ENUM2STRING(SET_LOOK_TARGET),
+	ENUM2STRING(SET_ADDRHANDBOLT_MODEL),
+	ENUM2STRING(SET_REMOVERHANDBOLT_MODEL),
+	ENUM2STRING(SET_ADDLHANDBOLT_MODEL),
+	ENUM2STRING(SET_REMOVELHANDBOLT_MODEL),
+	ENUM2STRING(SET_FACEAUX),
+	ENUM2STRING(SET_FACEBLINK),
+	ENUM2STRING(SET_FACEBLINKFROWN),
+	ENUM2STRING(SET_FACEFROWN),
+	ENUM2STRING(SET_FACENORMAL),
+	ENUM2STRING(SET_FACEEYESCLOSED),
+	ENUM2STRING(SET_FACEEYESOPENED),
+	ENUM2STRING(SET_SCROLLTEXT),
+	ENUM2STRING(SET_LCARSTEXT),
+	ENUM2STRING(SET_CENTERTEXT),
+	ENUM2STRING(SET_SCROLLTEXTCOLOR),
+	ENUM2STRING(SET_CAPTIONTEXTCOLOR),
+	ENUM2STRING(SET_CENTERTEXTCOLOR),
+	ENUM2STRING(SET_PLAYER_USABLE),
+	ENUM2STRING(SET_STARTFRAME),
+	ENUM2STRING(SET_ENDFRAME),
+	ENUM2STRING(SET_ANIMFRAME),
+	ENUM2STRING(SET_LOOP_ANIM),
+	ENUM2STRING(SET_INTERFACE),
+	ENUM2STRING(SET_SHIELDS),
+	ENUM2STRING(SET_NO_KNOCKBACK),
+	ENUM2STRING(SET_INVISIBLE),
+	ENUM2STRING(SET_VAMPIRE),
+	ENUM2STRING(SET_FORCE_INVINCIBLE),
+	ENUM2STRING(SET_GREET_ALLIES),
+	ENUM2STRING(SET_PLAYER_LOCKED),
+	ENUM2STRING(SET_LOCK_PLAYER_WEAPONS),
+	ENUM2STRING(SET_NO_IMPACT_DAMAGE),
+	ENUM2STRING(SET_PARM1),
+	ENUM2STRING(SET_PARM2),
+	ENUM2STRING(SET_PARM3),
+	ENUM2STRING(SET_PARM4),
+	ENUM2STRING(SET_PARM5),
+	ENUM2STRING(SET_PARM6),
+	ENUM2STRING(SET_PARM7),
+	ENUM2STRING(SET_PARM8),
+	ENUM2STRING(SET_PARM9),
+	ENUM2STRING(SET_PARM10),
+	ENUM2STRING(SET_PARM11),
+	ENUM2STRING(SET_PARM12),
+	ENUM2STRING(SET_PARM13),
+	ENUM2STRING(SET_PARM14),
+	ENUM2STRING(SET_PARM15),
+	ENUM2STRING(SET_PARM16),
+	ENUM2STRING(SET_DEFEND_TARGET),
+	ENUM2STRING(SET_WAIT),
+	ENUM2STRING(SET_COUNT),
+	ENUM2STRING(SET_SHOT_SPACING),
+	ENUM2STRING(SET_VIDEO_PLAY),
+	ENUM2STRING(SET_VIDEO_FADE_IN),
+	ENUM2STRING(SET_VIDEO_FADE_OUT),
+	ENUM2STRING(SET_REMOVE_TARGET),
+	ENUM2STRING(SET_LOADGAME),
+	ENUM2STRING(SET_MENU_SCREEN),
+	ENUM2STRING(SET_OBJECTIVE_SHOW),
+	ENUM2STRING(SET_OBJECTIVE_HIDE),
+	ENUM2STRING(SET_OBJECTIVE_SUCCEEDED),
+	ENUM2STRING(SET_OBJECTIVE_SUCCEEDED_NO_UPDATE),
+	ENUM2STRING(SET_OBJECTIVE_FAILED),
+	ENUM2STRING(SET_MISSIONFAILED),
+	ENUM2STRING(SET_TACTICAL_SHOW),
+	ENUM2STRING(SET_TACTICAL_HIDE),
+	ENUM2STRING(SET_FOLLOWDIST),
+	ENUM2STRING(SET_SCALE),
+	ENUM2STRING(SET_OBJECTIVE_CLEARALL),
+	ENUM2STRING(SET_OBJECTIVE_LIGHTSIDE),
+	ENUM2STRING(SET_MISSIONSTATUSTEXT),
+	ENUM2STRING(SET_WIDTH),
+	ENUM2STRING(SET_CLOSINGCREDITS),
+	ENUM2STRING(SET_SKILL),
+	ENUM2STRING(SET_MISSIONSTATUSTIME),
+	ENUM2STRING(SET_FORCE_HEAL_LEVEL),
+	ENUM2STRING(SET_FORCE_JUMP_LEVEL),
+	ENUM2STRING(SET_FORCE_SPEED_LEVEL),
+	ENUM2STRING(SET_FORCE_PUSH_LEVEL),
+	ENUM2STRING(SET_FORCE_PULL_LEVEL),
+	ENUM2STRING(SET_FORCE_MINDTRICK_LEVEL),
+	ENUM2STRING(SET_FORCE_GRIP_LEVEL),
+	ENUM2STRING(SET_FORCE_LIGHTNING_LEVEL),
+	ENUM2STRING(SET_SABER_THROW),
+	ENUM2STRING(SET_SABER_DEFENSE),
+	ENUM2STRING(SET_SABER_OFFENSE),
+	ENUM2STRING(SET_FORCE_RAGE_LEVEL),
+	ENUM2STRING(SET_FORCE_PROTECT_LEVEL),
+	ENUM2STRING(SET_FORCE_ABSORB_LEVEL),
+	ENUM2STRING(SET_FORCE_DRAIN_LEVEL),
+	ENUM2STRING(SET_FORCE_SIGHT_LEVEL),
+	ENUM2STRING(SET_SABER1_COLOR1),
+	ENUM2STRING(SET_SABER1_COLOR2),
+	ENUM2STRING(SET_SABER2_COLOR1),
+	ENUM2STRING(SET_SABER2_COLOR2),
+	ENUM2STRING(SET_DISMEMBER_LIMB),
+
+	ENUM2STRING(SET_VIEWENTITY),
+	ENUM2STRING(SET_WATCHTARGET),
+	ENUM2STRING(SET_SABERACTIVE),
+
+	ENUM2STRING(SET_SABER1BLADEON),
+	ENUM2STRING(SET_SABER1BLADEOFF),
+	ENUM2STRING(SET_SABER2BLADEON),
+	ENUM2STRING(SET_SABER2BLADEOFF),
+
+	ENUM2STRING(SET_ADJUST_AREA_PORTALS),
+	ENUM2STRING(SET_DMG_BY_HEAVY_WEAP_ONLY),
+	ENUM2STRING(SET_SHIELDED),
+	ENUM2STRING(SET_NO_GROUPS),
+	ENUM2STRING(SET_FIRE_WEAPON),
+	ENUM2STRING(SET_FIRE_WEAPON_NO_ANIM),
+	ENUM2STRING(SET_SAFE_REMOVE),
+	ENUM2STRING(SET_BOBA_JET_PACK),
+	ENUM2STRING(SET_INACTIVE),
+	ENUM2STRING(SET_FUNC_USABLE_VISIBLE),
+	ENUM2STRING(SET_END_SCREENDISSOLVE),
+	ENUM2STRING(SET_LOOPSOUND),
+	ENUM2STRING(SET_ICARUS_FREEZE),
+	ENUM2STRING(SET_ICARUS_UNFREEZE),
+	ENUM2STRING(SET_SABER1),
+	ENUM2STRING(SET_SABER2),
+	ENUM2STRING(SET_PLAYERMODEL),
+	ENUM2STRING(SET_VEHICLE),
+	ENUM2STRING(SET_SECURITY_KEY),
+	ENUM2STRING(SET_DAMAGEENTITY),
+	ENUM2STRING(SET_USE_CP_NEAREST),
+	ENUM2STRING(SET_MORELIGHT),
+	ENUM2STRING(SET_CINEMATIC_SKIPSCRIPT),
+	ENUM2STRING(SET_RAILCENTERTRACKLOCKED),
+	ENUM2STRING(SET_RAILCENTERTRACKUNLOCKED),
+	ENUM2STRING(SET_NO_FORCE),
+	ENUM2STRING(SET_NO_FALLTODEATH),
+	ENUM2STRING(SET_DISMEMBERABLE),
+	ENUM2STRING(SET_NO_ACROBATICS),
+	ENUM2STRING(SET_MUSIC_STATE),
+	ENUM2STRING(SET_USE_SUBTITLES),
+	ENUM2STRING(SET_CLEAN_DAMAGING_ENTS),
+	ENUM2STRING(SET_HUD),
+	//JKA
+	ENUM2STRING(SET_NO_PVS_CULL),
+	ENUM2STRING(SET_CLOAK),
+	ENUM2STRING(SET_RENDER_CULL_RADIUS),
+	ENUM2STRING(SET_DISTSQRD_TO_PLAYER),
+	ENUM2STRING(SET_FORCE_HEAL),
+	ENUM2STRING(SET_FORCE_SPEED),
+	ENUM2STRING(SET_FORCE_PUSH),
+	ENUM2STRING(SET_FORCE_PUSH_FAKE),
+	ENUM2STRING(SET_FORCE_PULL),
+	ENUM2STRING(SET_FORCE_MIND_TRICK),
+	ENUM2STRING(SET_FORCE_GRIP),
+	ENUM2STRING(SET_FORCE_LIGHTNING),
+	ENUM2STRING(SET_FORCE_SABERTHROW),
+	ENUM2STRING(SET_FORCE_RAGE),
+	ENUM2STRING(SET_FORCE_PROTECT),
+	ENUM2STRING(SET_FORCE_ABSORB),
+	ENUM2STRING(SET_FORCE_DRAIN),
+	ENUM2STRING(SET_WINTER_GEAR),
+	ENUM2STRING(SET_NO_ANGLES),
+	ENUM2STRING(SET_SABER_ORIGIN),
+	ENUM2STRING(SET_SKIN),
+
+	"",	SET_,
+};
+
+qboolean COM_ParseString( char **data, char **s ); 
+
+//=======================================================================
+
+vec4_t textcolor_caption;
+vec4_t textcolor_center;
+vec4_t textcolor_scroll;
+
+/*
+-------------------------
+void Q3_SetTaskID( gentity_t *ent, taskID_t taskType, int taskID )
+-------------------------
+*/
+
+static void Q3_TaskIDSet( gentity_t *ent, taskID_t taskType, int taskID )
+{
+	if ( taskType < TID_CHAN_VOICE || taskType >= NUM_TIDS )
+	{
+		return;
+	}
+
+	//Might be stomping an old task, so complete and clear previous task if there was one
+	Q3_TaskIDComplete( ent, taskType );
+
+	ent->taskID[taskType] = taskID;
+}
+
+/*
+-------------------------
+SetTextColor
+-------------------------
+*/
+
+static void SetTextColor ( vec4_t textcolor,const char *color)
+{
+
+	if (Q_stricmp(color,"BLACK") == 0)
+	{
+		Vector4Copy( colorTable[CT_BLACK], textcolor );
+	}
+	else if (Q_stricmp(color,"RED") == 0)
+	{
+		Vector4Copy( colorTable[CT_RED], textcolor );
+	}
+	else if (Q_stricmp(color,"GREEN") == 0)
+	{
+		Vector4Copy( colorTable[CT_GREEN], textcolor );
+	}
+	else if (Q_stricmp(color,"YELLOW") == 0)
+	{
+		Vector4Copy( colorTable[CT_YELLOW], textcolor );
+	}
+	else if (Q_stricmp(color,"BLUE") == 0)
+	{
+		Vector4Copy( colorTable[CT_BLUE], textcolor );
+	}
+	else if (Q_stricmp(color,"CYAN") == 0)
+	{
+		Vector4Copy( colorTable[CT_CYAN], textcolor );
+	}
+	else if (Q_stricmp(color,"MAGENTA") == 0)
+	{
+		Vector4Copy( colorTable[CT_MAGENTA], textcolor );
+	}
+	else if (Q_stricmp(color,"WHITE") == 0)
+	{
+		Vector4Copy( colorTable[CT_WHITE], textcolor );
+	}
+	else 
+	{
+		Vector4Copy( colorTable[CT_WHITE], textcolor );
+	}
+
+	return;
+}
+
+/*
+-------------------------
+void Q3_ClearTaskID( int *taskID )
+
+WARNING: Clearing a taskID will make that task never finish unless you intend to
+			return the same taskID from somewhere else.
+-------------------------
+*/
+void Q3_TaskIDClear( int *taskID )
+{
+	*taskID = -1;
+}
+
+/*
+-------------------------
+qboolean Q3_TaskIDPending( gentity_t *ent, taskID_t taskType )
+-------------------------
+*/
+qboolean Q3_TaskIDPending( gentity_t *ent, taskID_t taskType )
+{
+	if ( ent->m_iIcarusID == IIcarusInterface::ICARUS_INVALID /*!ent->sequencer || !ent->taskManager*/ )
+	{
+		return qfalse;
+	}
+
+	if ( taskType < TID_CHAN_VOICE || taskType >= NUM_TIDS )
+	{
+		return qfalse;
+	}
+
+	if ( ent->taskID[taskType] >= 0 )//-1 is none
+	{
+		return qtrue;
+	}
+
+	return qfalse;
+}
+
+/*
+-------------------------
+void Q3_TaskIDComplete( gentity_t *ent, taskID_t taskType )
+-------------------------
+*/
+void Q3_TaskIDComplete( gentity_t *ent, taskID_t taskType )
+{
+	if ( taskType < TID_CHAN_VOICE || taskType >= NUM_TIDS )
+	{
+		return;
+	}
+
+	if ( ent->m_iIcarusID != IIcarusInterface::ICARUS_INVALID /*ent->taskManager*/ && Q3_TaskIDPending( ent, taskType ) )
+	{//Complete it
+		IIcarusInterface::GetIcarus()->Completed( ent->m_iIcarusID, ent->taskID[taskType] );
+
+		//See if any other tasks have the name number and clear them so we don't complete more than once
+		int	clearTask = ent->taskID[taskType];
+		for ( int tid = 0; tid < NUM_TIDS; tid++ )
+		{
+			if ( ent->taskID[tid] == clearTask )
+			{
+				Q3_TaskIDClear( &ent->taskID[tid] );
+			}
+		}
+
+		//clear it - should be cleared in for loop above
+		//Q3_TaskIDClear( &ent->taskID[taskType] );
+	}
+	//otherwise, wasn't waiting for a task to complete anyway
+}
+
+/*
+============
+Q3_CheckStringCounterIncrement
+  Description	: 
+  Return type	: static float 
+  Argument		: const char *string
+============
+*/
+static float Q3_CheckStringCounterIncrement( const char *string )
+{
+	char	*numString;
+	float	val = 0.0f;
+
+	if ( string[0] == '+' )
+	{//We want to increment whatever the value is by whatever follows the +
+		if ( string[1] )
+		{
+			numString = (char *)&string[1];
+			val = atof( numString );
+		}
+	}
+	else if ( string[0] == '-' )
+	{//we want to decrement
+		if ( string[1] )
+		{
+			numString = (char *)&string[1];
+			val = atof( numString ) * -1;
+		}
+	}
+
+	return val;
+}
+
+/*
+-------------------------
+Q3_GetAnimLower
+-------------------------
+*/
+static char *Q3_GetAnimLower( gentity_t *ent )
+{
+	if ( ent->client == NULL )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_GetAnimLower: attempted to read animation state off non-client!\n" );
+		return NULL;
+	}
+
+	int anim = ent->client->ps.legsAnim;
+
+	return (char *) GetStringForID( animTable, anim );
+}
+
+/*
+-------------------------
+Q3_GetAnimUpper
+-------------------------
+*/
+static char *Q3_GetAnimUpper( gentity_t *ent )
+{
+	if ( ent->client == NULL )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_GetAnimUpper: attempted to read animation state off non-client!\n" );
+		return NULL;
+	}
+
+	int anim = ent->client->ps.torsoAnim;
+
+	return (char *) GetStringForID( animTable, anim );
+}
+
+/*
+-------------------------
+Q3_GetAnimBoth
+-------------------------
+*/
+static char *Q3_GetAnimBoth( gentity_t *ent )
+{
+ 	char	*lowerName, *upperName;
+
+	lowerName = Q3_GetAnimLower( ent );
+	upperName = Q3_GetAnimUpper( ent );
+
+	if ( VALIDSTRING( lowerName ) == false )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_GetAnimBoth: NULL legs animation string found!\n" );
+		return NULL;
+	}
+
+	if ( VALIDSTRING( upperName ) == false )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_GetAnimBoth: NULL torso animation string found!\n" );
+		return NULL;
+	}
+
+	if ( stricmp( lowerName, upperName ) )
+	{
+#ifdef _DEBUG	// sigh, cut down on tester reports that aren't important
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_GetAnimBoth: legs and torso animations did not match : returning legs\n" );
+#endif
+	}
+
+	return lowerName;
+}
+
+/*
+-------------------------
+Q3_SetObjective
+-------------------------
+*/
+extern qboolean G_CheckPlayerDarkSide( void );
+static void Q3_SetObjective(const char *ObjEnum, int status)
+{
+	int objectiveID;
+	gclient_t	*client;
+	objectives_t	*objective;
+	int				*objectivesShown;
+
+	client = &level.clients[0];
+
+	objectiveID = GetIDForString( objectiveTable, ObjEnum );
+	objective = &client->sess.mission_objectives[objectiveID];
+	objectivesShown = &client->sess.missionObjectivesShown;
+
+
+	switch (status)
+	{
+	case SET_OBJ_HIDE :
+		objective->display = OBJECTIVE_HIDE;
+		break;
+	case SET_OBJ_SHOW :
+		objective->display = OBJECTIVE_SHOW;
+		objectivesShown++;
+		missionInfo_Updated = qtrue;	// Activate flashing text
+		break;
+	case SET_OBJ_PENDING :
+		objective->status = OBJECTIVE_STAT_PENDING;
+		if (objective->display != OBJECTIVE_HIDE)
+		{
+			objectivesShown++;
+			missionInfo_Updated = qtrue;	// Activate flashing text
+		}
+		break;
+	case SET_OBJ_SUCCEEDED :
+		objective->status = OBJECTIVE_STAT_SUCCEEDED;
+		if (objective->display != OBJECTIVE_HIDE)
+		{
+			objectivesShown++;
+			missionInfo_Updated = qtrue;	// Activate flashing text
+		}
+		break;
+	case SET_OBJ_FAILED :
+		objective->status = OBJECTIVE_STAT_FAILED;
+		if (objective->display != OBJECTIVE_HIDE)
+		{
+			objectivesShown++;
+			missionInfo_Updated = qtrue;	// Activate flashing text
+		}
+		break;
+	}
+
+	if ( objectiveID == LIGHTSIDE_OBJ
+		&& status == SET_OBJ_FAILED )
+	{//don't do this unless we just set that specific objective (just turned to the dark side) with this SET_OBJECTIVE command
+		G_CheckPlayerDarkSide();
+	}
+}
+
+
+/*
+-------------------------
+Q3_SetMissionFailed
+-------------------------
+*/
+extern void G_PlayerGuiltDeath( void );
+static void	Q3_SetMissionFailed(const char *TextEnum)
+{
+	gentity_t	*ent = &g_entities[0];
+
+	if ( ent->health >= 0 )
+	{
+		G_PlayerGuiltDeath();
+	}
+	ent->health = 0;
+	//FIXME: what about other NPCs?  Scripts?
+
+	// statusTextIndex is looked at on the client side. 
+	statusTextIndex = GetIDForString( missionFailedTable, TextEnum );
+	cg.missionStatusShow = qtrue;
+	if ( ent->client )
+	{//hold this screen up for at least 2 seconds
+		ent->client->respawnTime = level.time + 2000;
+	}
+}
+
+/*
+-------------------------
+Q3_SetStatusText
+-------------------------
+*/
+static void Q3_SetStatusText(const char *StatusTextEnum)
+{
+	int statusTextID;
+
+	statusTextID = GetIDForString( statusTextTable, StatusTextEnum );
+
+	switch (statusTextID)
+	{
+	case STAT_INSUBORDINATION:
+	case STAT_YOUCAUSEDDEATHOFTEAMMATE:
+	case STAT_DIDNTPROTECTTECH:
+	case STAT_DIDNTPROTECT7OF9:
+	case STAT_NOTSTEALTHYENOUGH:
+	case STAT_STEALTHTACTICSNECESSARY:
+	case STAT_WATCHYOURSTEP:
+	case STAT_JUDGEMENTMUCHDESIRED:
+		statusTextIndex = statusTextID;
+		break;
+	default:
+		assert(0);
+		break;
+	}
+}
+
+
+/*
+-------------------------
+Q3_ObjectiveClearAll
+-------------------------
+*/
+static void Q3_ObjectiveClearAll(void)
+{
+	client = &level.clients[0];
+	memset(client->sess.mission_objectives,0,sizeof(client->sess.mission_objectives));
+}
+
+/*
+=============
+Q3_SetCaptionTextColor
+
+Change color text prints in
+=============
+*/
+static void Q3_SetCaptionTextColor ( const char *color)
+{
+	SetTextColor(textcolor_caption,color);
+}
+
+/*
+=============
+Q3_SetCenterTextColor
+
+Change color text prints in
+=============
+*/
+static void Q3_SetCenterTextColor ( const char *color)
+{
+	SetTextColor(textcolor_center,color);
+}
+
+/*
+=============
+Q3_SetScrollTextColor
+
+Change color text prints in
+=============
+*/
+static void Q3_SetScrollTextColor ( const char *color)
+{
+	SetTextColor(textcolor_scroll,color);
+}
+
+/*
+=============
+Q3_ScrollText
+
+Prints a message in the center of the screen
+=============
+*/
+static void Q3_ScrollText ( const char *id)
+{
+	gi.SendServerCommand( NULL, "st \"%s\"", id);
+
+	return;
+}
+
+/*
+=============
+Q3_LCARSText
+
+Prints a message in the center of the screen giving it an LCARS frame around it
+=============
+*/
+static void Q3_LCARSText ( const char *id)
+{
+	gi.SendServerCommand( NULL, "lt \"%s\"", id);
+
+	return;
+}
+
+/*
+=============
+`
+
+Returns the sequencer of the entity by the given name
+=============
+*/
+/*static gentity_t *Q3_GetEntityByName( const char *name )
+{
+	gentity_t				*ent;
+	entitylist_t::iterator		ei;
+	char					temp[1024];
+
+	if ( name == NULL || name[0] == NULL )
+		return NULL;
+
+	strncpy( (char *) temp, name, sizeof(temp) );
+	temp[sizeof(temp)-1] = 0;
+
+	ei = ICARUS_EntList.find( strupr( (char *) temp ) );
+
+	if ( ei == ICARUS_EntList.end() )
+		return NULL;
+
+	ent = &g_entities[(*ei).second];
+
+	return ent;
+	// this now returns the ent instead of the sequencer -- dmv 06/27/01
+//	if (ent == NULL)
+//		return NULL;
+//	return ent->sequencer;
+}*/
+
+/*
+=============
+Q3_GetTime
+
+Get the current game time
+=============
+*/
+/*static DWORD Q3_GetTime( void )
+{
+	return level.time;
+}*/
+
+/*
+=============
+G_AddSexToPlayerString
+
+Take any string, look for "jaden_male/" replace with "jaden_fmle/" based on "sex"
+And: Take any string, look for "/mr_" replace with "/ms_" based on "sex" 
+returns qtrue if changed to ms
+=============
+*/
+static qboolean G_AddSexToPlayerString ( char *string, qboolean qDoBoth )
+{
+	char *start;
+
+	if VALIDSTRING( string ) {
+		if ( g_sex->string[0] == 'f' ) {
+			start = strstr( string, "jaden_male/" );
+			if ( start != NULL ) {
+				strncpy( start, "jaden_fmle", 10 );
+				return qtrue;
+			} else {
+				start = strrchr( string, '/' );		//get the last slash before the wav
+				if (start != NULL) {
+					if (!strncmp( start, "/mr_", 4) ) {
+						if (qDoBoth) {	//we want to change mr to ms
+							start[2] = 's';	//change mr to ms
+							return qtrue;
+						} else {	//IF qDoBoth
+							return qfalse;	//don't want this one
+						}
+					}
+				}	//IF found slash
+			}
+		}	//IF Female
+		else {	//i'm male
+			start = strrchr( string, '/' );		//get the last slash before the wav
+			if (start != NULL) {
+				if (!strncmp( start, "/ms_", 4) ) {
+					return qfalse;	//don't want this one
+				}
+			}	//IF found slash
+		}
+	}	//if VALIDSTRING
+	return qtrue;
+}
+
+
+/*
+
+/*
+=============
+Q3_SetAngles
+
+Sets the angles of an entity directly
+=============
+*/
+static void Q3_SetDYaw( int entID, float data );
+static void Q3_SetAngles( int entID, vec3_t angles )
+{
+	gentity_t	*ent = &g_entities[entID];
+
+	if ( !ent )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetAngles: bad ent %d\n", entID);
+		return;
+	}
+
+	if (ent->client)
+	{
+		SetClientViewAngle( ent, angles );
+		if ( ent->NPC )
+		{
+			Q3_SetDYaw( entID, angles[YAW] );
+		}
+	}
+	else
+	{
+		VectorCopy( angles, ent->s.angles );
+		VectorCopy( angles, ent->s.apos.trBase );
+		VectorCopy( angles, ent->currentAngles );
+	}
+	gi.linkentity( ent );
+}
+
+/*
+=============
+Q3_SetOrigin
+
+Sets the origin of an entity directly
+=============
+*/
+static void Q3_SetOrigin( int entID, vec3_t origin )
+{
+	gentity_t	*ent = &g_entities[entID];
+
+	if ( !ent )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetOrigin: bad ent %d\n", entID);
+		return;
+	}
+
+	gi.unlinkentity (ent);
+
+	if(ent->client)
+	{
+		VectorCopy(origin, ent->client->ps.origin);
+		VectorCopy(origin, ent->currentOrigin);
+		ent->client->ps.origin[2] += 1;
+
+		VectorClear (ent->client->ps.velocity);
+		ent->client->ps.pm_time = 160;		// hold time
+		ent->client->ps.pm_flags |= PMF_TIME_KNOCKBACK;
+		
+		ent->client->ps.eFlags ^= EF_TELEPORT_BIT;
+
+//		G_KillBox (ent);
+	}
+	else
+	{
+		G_SetOrigin( ent, origin );
+	}
+
+	gi.linkentity( ent );
+}
+
+
+/*
+============
+MoveOwner
+  Description	: 
+  Return type	: void 
+  Argument		: gentity_t *self
+============
+*/
+void MoveOwner( gentity_t *self )
+{
+	self->nextthink = level.time + FRAMETIME;
+	self->e_ThinkFunc = thinkF_G_FreeEntity;
+
+	if ( !self->owner || !self->owner->inuse )
+	{
+		return;
+	}
+
+	if ( SpotWouldTelefrag2( self->owner, self->currentOrigin ) )
+	{
+		self->e_ThinkFunc = thinkF_MoveOwner;
+	}
+	else
+	{
+		G_SetOrigin( self->owner, self->currentOrigin );
+		gi.linkentity( self->owner );
+		Q3_TaskIDComplete( self->owner, TID_MOVE_NAV );
+	}
+}
+
+
+/*
+=============
+Q3_SetTeleportDest
+
+Copies passed origin to ent running script once there is nothing there blocking the spot
+=============
+*/
+static qboolean Q3_SetTeleportDest( int entID, vec3_t org )
+{
+	gentity_t	*teleEnt = &g_entities[entID];
+
+	if ( teleEnt )
+	{
+		if ( SpotWouldTelefrag2( teleEnt, org ) )
+		{
+			gentity_t *teleporter = G_Spawn();
+
+			G_SetOrigin( teleporter, org );
+			gi.linkentity( teleporter );
+			teleporter->owner = teleEnt;
+
+			teleporter->e_ThinkFunc = thinkF_MoveOwner;
+			teleporter->nextthink = level.time + FRAMETIME;
+			
+			return qfalse;
+		}
+		else
+		{
+			G_SetOrigin( teleEnt, org );
+			gi.linkentity( teleEnt );
+		}
+	}
+
+	return qtrue;
+}
+
+/*
+=============
+Q3_SetCopyOrigin
+
+Copies origin of found ent into ent running script
+=============`
+*/
+static void Q3_SetCopyOrigin( int entID, const char *name )
+{
+	gentity_t	*found = G_Find( NULL, FOFS(targetname), (char *) name);
+
+	if(found)
+	{
+		Q3_SetOrigin( entID, found->currentOrigin );
+		SetClientViewAngle( &g_entities[entID], found->s.angles );
+	}
+	else
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetCopyOrigin: ent %s not found!\n", name);
+	}
+}
+
+/*
+=============
+Q3_SetVelocity
+
+Set the velocity of an entity directly
+=============
+*/
+static void Q3_SetVelocity( int entID, int axis, float speed )
+{
+	gentity_t	*found = &g_entities[entID];
+	//FIXME: Not supported
+	if(!found)
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetVelocity invalid entID %d\n", entID);
+		return;
+	}
+
+	if(!found->client)
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetVelocity: not a client %d\n", entID);
+		return;
+	}
+
+	//FIXME: add or set?
+	found->client->ps.velocity[axis] += speed;
+
+	found->client->ps.pm_time = 500;
+	found->client->ps.pm_flags |= PMF_TIME_KNOCKBACK;
+}
+
+/*
+============
+Q3_SetAdjustAreaPortals
+  Description	: 
+  Return type	: void 
+  Argument		:  int entID
+  Argument		: qboolean shields
+============
+*/
+static void Q3_SetAdjustAreaPortals( int entID, qboolean adjust )
+{
+	gentity_t	*ent  = &g_entities[entID];
+
+	if ( !ent )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetAdjustAreaPortals: invalid entID %d\n", entID);
+		return;
+	}
+
+	ent->svFlags = (adjust) ? (ent->svFlags|SVF_MOVER_ADJ_AREA_PORTALS) : (ent->svFlags&~SVF_MOVER_ADJ_AREA_PORTALS);
+}
+
+/*
+============
+Q3_SetDmgByHeavyWeapOnly
+  Description	: 
+  Return type	: void 
+  Argument		:  int entID
+  Argument		: qboolean dmg
+============
+*/
+static void Q3_SetDmgByHeavyWeapOnly( int entID, qboolean dmg )
+{
+	gentity_t	*ent  = &g_entities[entID];
+
+	if ( !ent )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetDmgByHeavyWeapOnly: invalid entID %d\n", entID);
+		return;
+	}
+	
+	ent->flags = (dmg) ? (ent->flags|FL_DMG_BY_HEAVY_WEAP_ONLY) : (ent->flags&~FL_DMG_BY_HEAVY_WEAP_ONLY);
+}
+
+/*
+============
+Q3_SetShielded
+  Description	: 
+  Return type	: void 
+  Argument		:  int entID
+  Argument		: qboolean dmg
+============
+*/
+static void Q3_SetShielded( int entID, qboolean dmg )
+{
+	gentity_t	*ent  = &g_entities[entID];
+
+	if ( !ent )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetShielded: invalid entID %d\n", entID);
+		return;
+	}
+	
+	ent->flags = (dmg) ? (ent->flags|FL_SHIELDED) : (ent->flags&~FL_SHIELDED);
+}
+
+/*
+============
+Q3_SetNoGroups
+  Description	: 
+  Return type	: void 
+  Argument		:  int entID
+  Argument		: qboolean dmg
+============
+*/
+static void Q3_SetNoGroups( int entID, qboolean noGroups )
+{
+	gentity_t	*ent  = &g_entities[entID];
+
+	if ( !ent )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetNoGroups: invalid entID %d\n", entID);
+		return;
+	}
+
+	if ( !ent->NPC )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetNoGroups: ent %s is not an NPC!\n", ent->targetname );
+		return;
+	}
+	
+	ent->NPC->scriptFlags = noGroups ? (ent->NPC->scriptFlags|SCF_NO_GROUPS) : (ent->NPC->scriptFlags&~SCF_NO_GROUPS);
+}
+
+/*
+=============
+moverCallback
+
+Utility function
+=============
+*/
+extern void misc_model_breakable_gravity_init( gentity_t *ent, qboolean dropToFloor );
+void moverCallback( gentity_t *ent )
+{
+	//complete the task
+	Q3_TaskIDComplete( ent, TID_MOVE_NAV );
+	
+	// play sound
+	ent->s.loopSound = 0;//stop looping sound
+	G_PlayDoorSound( ent, BMS_END );//play end sound
+
+	if ( ent->moverState == MOVER_1TO2 ) 
+	{//reached open
+		// reached pos2
+		MatchTeam( ent, MOVER_POS2, level.time );
+		//SetMoverState( ent, MOVER_POS2, level.time );
+	} 
+	else if ( ent->moverState == MOVER_2TO1 ) 
+	{//reached closed
+		MatchTeam( ent, MOVER_POS1, level.time );
+		//SetMoverState( ent, MOVER_POS1, level.time );
+		//close the portal
+		if ( ent->svFlags & SVF_MOVER_ADJ_AREA_PORTALS )
+		{
+			gi.AdjustAreaPortalState( ent, qfalse );
+		}
+	}
+
+	if ( ent->e_BlockedFunc == blockedF_Blocked_Mover )
+	{
+		ent->e_BlockedFunc = blockedF_NULL;
+	}
+
+	if ( !Q_stricmp( "misc_model_breakable", ent->classname ) && ent->physicsBounce )
+	{//a gravity-affected model
+		misc_model_breakable_gravity_init( ent, qfalse );
+	}
+}
+
+/*
+=============
+anglerCallback
+
+Utility function
+=============
+*/
+void anglerCallback( gentity_t *ent )
+{
+	//Complete the task
+	Q3_TaskIDComplete( ent, TID_ANGLE_FACE );
+
+	// play sound
+	ent->s.loopSound = 0;//stop looping sound
+	G_PlayDoorSound( ent, BMS_END );//play end sound
+
+	//Set the currentAngles, clear all movement
+	VectorMA( ent->s.apos.trBase, (ent->s.apos.trDuration*0.001f), ent->s.apos.trDelta, ent->currentAngles );
+	VectorCopy( ent->currentAngles, ent->s.apos.trBase );
+	VectorClear( ent->s.apos.trDelta );
+	ent->s.apos.trDuration = 1;
+	ent->s.apos.trType = TR_STATIONARY;
+	ent->s.apos.trTime = level.time;
+
+	//Stop thinking
+	ent->e_ReachedFunc = reachedF_NULL;
+	if ( ent->e_ThinkFunc == thinkF_anglerCallback )
+	{
+		ent->e_ThinkFunc = thinkF_NULL;
+	}
+
+	//link
+	gi.linkentity( ent );
+}
+
+/*
+=============
+moveAndRotateCallback
+
+Utility function
+=============
+*/
+void moveAndRotateCallback( gentity_t *ent )
+{
+	//stop turning
+	anglerCallback( ent );
+	//stop moving
+	moverCallback( ent );
+}
+
+void Blocked_Mover( gentity_t *ent, gentity_t *other ) {
+	// remove anything other than a client -- no longer the case
+
+	// don't remove security keys or goodie keys
+	if ( (other->s.eType == ET_ITEM) && (other->item->giTag >= INV_GOODIE_KEY && other->item->giTag <= INV_SECURITY_KEY) )
+	{
+		// should we be doing anything special if a key blocks it... move it somehow..?
+	}
+	// if your not a client, or your a dead client remove yourself...
+	else if ( other->s.number && (!other->client || (other->client && other->health <= 0 && other->contents == CONTENTS_CORPSE && !other->message)) )
+	{
+		if ( !IIcarusInterface::GetIcarus()->IsRunning( other->m_iIcarusID ) /*!other->taskManager || !other->taskManager->IsRunning()*/ )
+		{
+			// if an item or weapon can we do a little explosion..?
+			G_FreeEntity( other );
+			return;
+		}
+	}
+
+	if ( ent->damage ) {
+		G_Damage( other, ent, ent, NULL, NULL, ent->damage, 0, MOD_CRUSH );
+	}
+}
+
+/*
+=============
+Q3_Lerp2Start
+
+Lerps the origin of an entity to its starting position
+=============
+// NEEDED???
+*/
+/*static void Q3_Lerp2Start( int entID, int taskID, float duration )
+{
+	gentity_t	*ent = &g_entities[entID];
+
+	if(!ent)
+	{	
+		Quake3Game()->DebugPrint( WL_WARNING, "Q3_Lerp2Start: invalid entID %d\n", entID);
+		return;
+	}
+	
+	if ( ent->client || ent->NPC || Q_stricmp(ent->classname, "target_scriptrunner") == 0 )
+	{
+		Quake3Game()->DebugPrint( WL_ERROR, "Q3_Lerp2Start: ent %d is NOT a mover!\n", entID);
+		return;
+	}
+
+	if ( ent->s.eType != ET_MOVER )
+	{
+		ent->s.eType = ET_MOVER;
+	}
+
+	//FIXME: set up correctly!!!
+	ent->moverState = MOVER_2TO1;
+	ent->s.eType = ET_MOVER;
+	ent->e_ReachedFunc = reachedF_moverCallback;		//Callsback the the completion of the move
+	if ( ent->damage )
+	{
+		ent->e_BlockedFunc = blockedF_Blocked_Mover;
+	}
+
+	ent->s.pos.trDuration = duration * 10;	//In seconds
+	ent->s.pos.trTime = level.time;
+	
+	Q3_TaskIDSet( ent, TID_MOVE_NAV, taskID );
+	// starting sound
+	G_PlayDoorLoopSound( ent );
+	G_PlayDoorSound( ent, BMS_START );	//??
+
+	gi.linkentity( ent );
+}*/
+
+/*
+=============
+Q3_Lerp2End
+
+Lerps the origin of an entity to its ending position
+=============
+// NEEDED???
+*/
+/*static void Q3_Lerp2End( int entID, int taskID, float duration )
+{
+	gentity_t	*ent = &g_entities[entID];
+
+	if(!ent)
+	{
+		Quake3Game()->DebugPrint( WL_WARNING, "Q3_Lerp2End: invalid entID %d\n", entID);
+		return;
+	}
+	
+	if ( ent->client || ent->NPC || Q_stricmp(ent->classname, "target_scriptrunner") == 0 )
+	{
+		Quake3Game()->DebugPrint( WL_ERROR, "Q3_Lerp2End: ent %d is NOT a mover!\n", entID);
+		return;
+	}
+
+	if ( ent->s.eType != ET_MOVER )
+	{
+		ent->s.eType = ET_MOVER;
+	}
+
+	if ( ent->moverState == MOVER_POS1 )
+	{//open the portal
+		if ( ent->svFlags & SVF_MOVER_ADJ_AREA_PORTALS )
+		{
+			gi.AdjustAreaPortalState( ent, qtrue );
+		}
+	}
+
+	//FIXME: set up correctly!!!
+	ent->moverState = MOVER_1TO2;
+	ent->s.eType = ET_MOVER;
+	ent->e_ReachedFunc = reachedF_moverCallback;		//Callsback the the completion of the move
+	if ( ent->damage )
+	{
+		ent->e_BlockedFunc = blockedF_Blocked_Mover;
+	}
+
+	ent->s.pos.trDuration = duration * 10;	//In seconds
+	ent->s.time = level.time;
+	
+	Q3_TaskIDSet( ent, TID_MOVE_NAV, taskID );
+	// starting sound
+	G_PlayDoorLoopSound( ent );
+	G_PlayDoorSound( ent, BMS_START );	//??
+
+	gi.linkentity( ent );
+}*/
+
+/*
+=============
+Q3_Lerp2Pos
+
+Lerps the origin and angles of an entity to the destination values
+
+=============
+*/
+/*static void Q3_Lerp2Pos( int taskID, int entID, vec3_t origin, vec3_t angles, float duration )
+{
+	gentity_t	*ent = &g_entities[entID];
+	vec3_t		ang;
+	int			i;
+
+	if(!ent)
+	{
+		Quake3Game()->DebugPrint( WL_WARNING, "Q3_Lerp2Pos: invalid entID %d\n", entID);
+		return;
+	}
+	
+	if ( ent->client || ent->NPC || Q_stricmp(ent->classname, "target_scriptrunner") == 0 )
+	{
+		Quake3Game()->DebugPrint( WL_ERROR, "Q3_Lerp2Pos: ent %d is NOT a mover!\n", entID);
+		return;
+	}
+
+	if ( ent->s.eType != ET_MOVER )
+	{
+		ent->s.eType = ET_MOVER;
+	}
+
+	//Don't allow a zero duration
+	if ( duration == 0 )
+		duration = 1;
+
+	//
+	// Movement
+
+	moverState_t moverState = ent->moverState;
+
+	if ( moverState == MOVER_POS1 || moverState == MOVER_2TO1 )
+	{
+		VectorCopy( ent->currentOrigin, ent->pos1 );
+		VectorCopy( origin, ent->pos2 );
+
+		if ( moverState == MOVER_POS1 )
+		{//open the portal
+			if ( ent->svFlags & SVF_MOVER_ADJ_AREA_PORTALS )
+			{
+				gi.AdjustAreaPortalState( ent, qtrue );
+			}
+		}
+
+		moverState = MOVER_1TO2;
+	}
+	else /*if ( moverState == MOVER_POS2 || moverState == MOVER_1TO2 )*/
+/*	{
+		VectorCopy( ent->currentOrigin, ent->pos2 );
+		VectorCopy( origin, ent->pos1 );
+
+		moverState = MOVER_2TO1;
+	}
+
+	InitMoverTrData( ent );
+
+	ent->s.pos.trDuration = duration;
+
+	// start it going
+	MatchTeam( ent, moverState, level.time );
+	//SetMoverState( ent, moverState, level.time );
+
+	//Only do the angles if specified
+	if ( angles != NULL )
+	{
+		//
+		// Rotation
+
+		for ( i = 0; i < 3; i++ )
+		{
+			ang[i] = AngleDelta( angles[i], ent->currentAngles[i] );
+			ent->s.apos.trDelta[i] = ( ang[i] / ( duration * 0.001f ) );
+		}
+
+		VectorCopy( ent->currentAngles, ent->s.apos.trBase );
+
+		if ( ent->alt_fire )
+		{
+			ent->s.apos.trType = TR_LINEAR_STOP;
+		}
+		else
+		{
+			ent->s.apos.trType = TR_NONLINEAR_STOP;
+		}
+		ent->s.apos.trDuration = duration;
+
+		ent->s.apos.trTime = level.time;
+
+		ent->e_ReachedFunc = reachedF_moveAndRotateCallback;
+		Q3_TaskIDSet( ent, TID_ANGLE_FACE, taskID );
+	}
+	else
+	{
+		//Setup the last bits of information
+		ent->e_ReachedFunc  = reachedF_moverCallback;
+	}
+
+	if ( ent->damage )
+	{
+		ent->e_BlockedFunc = blockedF_Blocked_Mover;
+	}
+
+	Q3_TaskIDSet( ent, TID_MOVE_NAV, taskID );
+	// starting sound
+	G_PlayDoorLoopSound( ent );
+	G_PlayDoorSound( ent, BMS_START );	//??
+
+	gi.linkentity( ent );
+
+}*/
+
+/*
+=============
+Q3_Lerp2Origin
+
+Lerps the origin to the destination value
+=============
+*/
+static void Q3_Lerp2Origin( int taskID, int entID, vec3_t origin, float duration )
+{
+	gentity_t	*ent = &g_entities[entID];
+
+	if(!ent)
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_Lerp2Origin: invalid entID %d\n", entID);
+		return;
+	}
+	
+	if ( ent->client || ent->NPC || Q_stricmp(ent->classname, "target_scriptrunner") == 0 )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "Q3_Lerp2Origin: ent %d is NOT a mover!\n", entID);
+		return;
+	}
+
+	if ( ent->s.eType != ET_MOVER )
+	{
+		ent->s.eType = ET_MOVER;
+	}
+
+	moverState_t moverState = ent->moverState;
+
+	if ( moverState == MOVER_POS1 || moverState == MOVER_2TO1 )
+	{
+		VectorCopy( ent->currentOrigin, ent->pos1 );
+		VectorCopy( origin, ent->pos2 );
+
+		if ( moverState == MOVER_POS1 )
+		{//open the portal
+			if ( ent->svFlags & SVF_MOVER_ADJ_AREA_PORTALS )
+			{
+				gi.AdjustAreaPortalState( ent, qtrue );
+			}
+		}
+
+		moverState = MOVER_1TO2;
+	}
+	else if ( moverState == MOVER_POS2 || moverState == MOVER_1TO2 )
+	{
+		VectorCopy( ent->currentOrigin, ent->pos2 );
+		VectorCopy( origin, ent->pos1 );
+
+		moverState = MOVER_2TO1;
+	}
+
+	InitMoverTrData( ent );	//FIXME: This will probably break normal things that are being moved...
+
+	ent->s.pos.trDuration = duration;
+
+	// start it going
+	MatchTeam( ent, moverState, level.time );
+	//SetMoverState( ent, moverState, level.time );
+
+	ent->e_ReachedFunc  = reachedF_moverCallback;
+	if ( ent->damage )
+	{
+		ent->e_BlockedFunc = blockedF_Blocked_Mover;
+	}
+	if ( taskID != -1 )
+	{
+		Q3_TaskIDSet( ent, TID_MOVE_NAV, taskID );
+	}
+	// starting sound
+	G_PlayDoorLoopSound( ent );//start looping sound
+	G_PlayDoorSound( ent, BMS_START );	//play start sound
+
+	gi.linkentity( ent );
+}
+
+static void Q3_SetOriginOffset( int entID, int axis, float offset )
+{
+	gentity_t	*ent = &g_entities[entID];
+
+	if(!ent)
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetOriginOffset: invalid entID %d\n", entID);
+		return;
+	}
+	
+	if ( ent->client || ent->NPC || Q_stricmp(ent->classname, "target_scriptrunner") == 0 )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "Q3_SetOriginOffset: ent %d is NOT a mover!\n", entID);
+		return;
+	}
+
+	vec3_t origin;
+	VectorCopy( ent->s.origin, origin );
+	origin[axis] += offset;
+	float duration = 0;
+	if ( ent->speed )
+	{
+		duration = fabs(offset)/fabs(ent->speed)*1000.0f;
+	}
+	Q3_Lerp2Origin( -1, entID, origin, duration );
+}
+/*
+=============
+Q3_LerpAngles
+
+Lerps the angles to the destination value
+=============
+*/
+/*static void Q3_Lerp2Angles( int taskID, int entID, vec3_t angles, float duration )
+{
+	gentity_t	*ent = &g_entities[entID];
+	vec3_t		ang;
+	int			i;
+
+	if(!ent)
+	{
+		Quake3Game()->DebugPrint( WL_WARNING, "Q3_Lerp2Angles: invalid entID %d\n", entID);
+		return;
+	}
+	
+	if ( ent->client || ent->NPC || Q_stricmp(ent->classname, "target_scriptrunner") == 0 )
+	{
+		Quake3Game()->DebugPrint( WL_ERROR, "Q3_Lerp2Angles: ent %d is NOT a mover!\n", entID);
+		return;
+	}
+
+	//If we want an instant move, don't send 0...
+	ent->s.apos.trDuration = (duration>0) ? duration : 1;
+
+	for ( i = 0; i < 3; i++ )
+	{
+		ang [i] = AngleSubtract( angles[i], ent->currentAngles[i]);
+		ent->s.apos.trDelta[i] = ( ang[i] / ( ent->s.apos.trDuration * 0.001f ) );
+	}
+
+	VectorCopy( ent->currentAngles, ent->s.apos.trBase );
+
+	if ( ent->alt_fire )
+	{
+		ent->s.apos.trType = TR_LINEAR_STOP;
+	}
+	else
+	{
+		ent->s.apos.trType = TR_NONLINEAR_STOP;
+	}
+
+	ent->s.apos.trTime = level.time;
+	
+	Q3_TaskIDSet( ent, TID_ANGLE_FACE, taskID );
+
+	//ent->e_ReachedFunc = reachedF_NULL;
+	ent->e_ThinkFunc = thinkF_anglerCallback;
+	ent->nextthink = level.time + duration;
+
+	gi.linkentity( ent );
+}*/
+
+/*
+=============
+Q3_GetTag
+
+Gets the value of a tag by the give name
+=============
+*/
+/*static int	Q3_GetTag( int entID, const char *name, int lookup, vec3_t info )
+{
+	gentity_t	*ent = &g_entities[ entID ];
+
+	VALIDATEB( ent );
+
+	switch ( lookup )
+	{
+	case TYPE_ORIGIN:
+		//return TAG_GetOrigin( ent->targetname, name, info );
+		return TAG_GetOrigin( ent->ownername, name, info );
+		break;
+
+	case TYPE_ANGLES:
+		//return TAG_GetAngles( ent->targetname, name, info );
+		return TAG_GetAngles( ent->ownername, name, info );
+		break;	
+	}
+
+	return false;
+}*/
+
+/*
+=============
+Q3_SetNavGoal
+
+Sets the navigational goal of an entity
+=============
+*/
+static qboolean Q3_SetNavGoal( int entID, const char *name )
+{
+	gentity_t	*ent  = &g_entities[ entID ];
+	vec3_t		goalPos;
+
+	if ( !ent->health )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "Q3_SetNavGoal: tried to set a navgoal (\"%s\") on a corpse! \"%s\"\n", name, ent->script_targetname );
+		return qfalse;
+	}
+	if ( !ent->NPC )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "Q3_SetNavGoal: tried to set a navgoal (\"%s\") on a non-NPC: \"%s\"\n", name, ent->script_targetname );
+		return qfalse;
+	}
+	if ( !ent->NPC->tempGoal )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "Q3_SetNavGoal: tried to set a navgoal (\"%s\") on a dead NPC: \"%s\"\n", name, ent->script_targetname );
+		return qfalse;
+	}
+	if ( !ent->NPC->tempGoal->inuse )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "Q3_SetNavGoal: NPC's (\"%s\") navgoal is freed: \"%s\"\n", name, ent->script_targetname );
+		return qfalse;
+	}
+	if( Q_stricmp( "null", name) == 0
+		|| Q_stricmp( "NULL", name) == 0 )
+	{
+		ent->NPC->goalEntity = NULL;
+		Q3_TaskIDComplete( ent, TID_MOVE_NAV );
+		return qfalse;
+	}
+	else
+	{
+		//Get the position of the goal
+		if ( TAG_GetOrigin2( NULL, name, goalPos ) == false )
+		{
+			gentity_t	*targ = G_Find(NULL, FOFS(targetname), (char*)name);
+			if ( !targ )
+			{
+				Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "Q3_SetNavGoal: can't find NAVGOAL \"%s\"\n", name );
+				return qfalse;
+			}
+			else
+			{
+				ent->NPC->goalEntity = targ;
+				ent->NPC->goalRadius = sqrt(ent->maxs[0]+ent->maxs[0]) + sqrt(targ->maxs[0]+targ->maxs[0]);
+				ent->NPC->aiFlags &= ~NPCAI_TOUCHED_GOAL;
+			}
+		}
+		else
+		{
+			int	goalRadius = TAG_GetRadius( NULL, name );
+			NPC_SetMoveGoal( ent, goalPos, goalRadius, qtrue );
+			//We know we want to clear the lastWaypoint here
+			ent->NPC->goalEntity->lastWaypoint = WAYPOINT_NONE;
+			ent->NPC->aiFlags &= ~NPCAI_TOUCHED_GOAL;
+	#ifdef _DEBUG
+			//this is *only* for debugging navigation
+			ent->NPC->tempGoal->target = G_NewString( name );
+	#endif// _DEBUG
+		return qtrue;
+		}
+	}
+	return qfalse;
+}
+
+//-----------------------------------------------
+
+/*
+============
+SetLowerAnim
+  Description	: 
+  Return type	: static void 
+  Argument		:  int entID
+  Argument		: int animID
+============
+*/
+static void SetLowerAnim( int entID, int animID)
+{
+	gentity_t	*ent  = &g_entities[entID];
+
+	if ( !ent )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "SetLowerAnim: invalid entID %d\n", entID);
+		return;
+	}
+
+	if ( !ent->client )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "SetLowerAnim: ent %d is NOT a player or NPC!\n", entID);
+		return;
+	}
+
+	NPC_SetAnim(ent,SETANIM_LEGS,animID,SETANIM_FLAG_RESTART|SETANIM_FLAG_HOLD|SETANIM_FLAG_OVERRIDE);
+}
+
+
+/*
+============
+SetUpperAnim 
+  Description	: 
+  Return type	: static void 
+  Argument		:  int entID
+  Argument		: int animID
+============
+*/
+static void SetUpperAnim ( int entID, int animID)
+{
+	gentity_t	*ent  = &g_entities[entID];
+
+	if ( !ent )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "SetUpperAnim: invalid entID %d\n", entID);
+		return;
+	}
+
+	if ( !ent->client )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "SetLowerAnim: ent %d is NOT a player or NPC!\n", entID);
+		return;
+	}
+
+	NPC_SetAnim(ent,SETANIM_TORSO,animID,SETANIM_FLAG_RESTART|SETANIM_FLAG_HOLD|SETANIM_FLAG_OVERRIDE);
+}
+
+//-----------------------------------------------
+
+/*
+=============
+Q3_SetAnimUpper
+
+Sets the upper animation of an entity
+=============
+*/
+static qboolean Q3_SetAnimUpper( int entID, const char *anim_name )
+{
+	int			animID = 0;
+
+	animID = GetIDForString( animTable, anim_name );
+
+	if( animID == -1 )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetAnimUpper: unknown animation sequence '%s'\n", anim_name );
+		return qfalse;
+	}
+	
+	if ( !PM_HasAnimation( &g_entities[entID], animID ) )
+	{
+		return qfalse;
+	}
+
+	SetUpperAnim( entID, animID );
+	return qtrue;
+}
+
+
+/*
+=============
+Q3_SetAnimLower
+
+Sets the lower animation of an entity
+=============
+*/
+static qboolean Q3_SetAnimLower( int entID, const char *anim_name )
+{
+	int			animID = 0;
+
+	//FIXME: Setting duck anim does not actually duck!
+
+	animID = GetIDForString( animTable, anim_name );
+
+	if( animID == -1 )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetAnimLower: unknown animation sequence '%s'\n", anim_name );
+		return qfalse;
+	}
+	
+	if ( !PM_HasAnimation( &g_entities[entID], animID ) )
+	{
+		return qfalse;
+	}
+
+	SetLowerAnim( entID, animID );
+	return qtrue;
+}
+
+/*
+============
+Q3_SetAnimHoldTime
+  Description	: 
+  Return type	: static void 
+  Argument		:  int entID
+  Argument		: int int_data
+  Argument		: qboolean lower
+============
+*/
+extern void PM_SetTorsoAnimTimer( gentity_t *ent, int *torsoAnimTimer, int time );
+extern void PM_SetLegsAnimTimer( gentity_t *ent, int *legsAnimTimer, int time );
+static void Q3_SetAnimHoldTime( int entID, int int_data, qboolean lower )
+{
+	gentity_t	*ent  = &g_entities[entID];
+
+	if ( !ent )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetAnimHoldTime: invalid entID %d\n", entID);
+		return;
+	}
+
+	if ( !ent->client )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "Q3_SetAnimHoldTime: ent %d is NOT a player or NPC!\n", entID);
+		return;
+	}
+	
+	if(lower)
+	{
+		PM_SetLegsAnimTimer( ent, &ent->client->ps.legsAnimTimer, int_data );
+	}
+	else
+	{
+		PM_SetTorsoAnimTimer( ent, &ent->client->ps.torsoAnimTimer, int_data );
+	}
+}
+
+/*
+=============
+Q3_SetEnemy
+
+Sets the enemy of an entity
+=============
+*/
+static void Q3_SetEnemy( int entID, const char *name )
+{
+	gentity_t	*ent  = &g_entities[entID];
+
+	if ( !ent )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetEnemy: invalid entID %d\n", entID);
+		return;
+	}
+
+	if( !Q_stricmp("NONE", name) || !Q_stricmp("NULL", name))
+	{
+		if(ent->NPC)
+		{
+			G_ClearEnemy(ent);
+		}
+		else
+		{
+			ent->enemy = NULL;
+		}
+	}
+	else
+	{
+		gentity_t	*enemy = G_Find( NULL, FOFS(targetname), (char *) name);
+
+		if(enemy == NULL)
+		{
+			Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "Q3_SetEnemy: no such enemy: '%s'\n", name );
+			return;
+		}
+		/*else if(enemy->health <= 0)
+		{
+			//Quake3Game()->DebugPrint( WL_ERROR, "Q3_SetEnemy: ERROR - desired enemy has health %d\n", enemy->health );
+			return;
+		}*/
+		else
+		{
+			if(ent->NPC)
+			{
+				G_SetEnemy( ent, enemy );
+				ent->cantHitEnemyCounter = 0;
+			}
+			else
+			{
+				G_SetEnemy(ent, enemy);
+			}
+		}
+	}
+}
+
+
+/*
+=============
+Q3_SetLeader
+
+Sets the leader of an NPC
+=============
+*/
+static void Q3_SetLeader( int entID, const char *name )
+{
+	gentity_t	*ent  = &g_entities[entID];
+
+	if ( !ent )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetLeader: invalid entID %d\n", entID);
+		return;
+	}
+
+	if ( !ent->client )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "Q3_SetLeader: ent %d is NOT a player or NPC!\n", entID);
+		return;
+	}
+
+	if( !Q_stricmp("NONE", name) || !Q_stricmp("NULL", name))
+	{
+		ent->client->leader = NULL;
+	}
+	else
+	{
+		gentity_t	*leader = G_Find( NULL, FOFS(targetname), (char *) name);
+
+		if(leader == NULL)
+		{
+			//Quake3Game()->DebugPrint( WL_ERROR,"Q3_SetEnemy: unable to locate enemy: '%s'\n", name );
+			return;
+		}
+		else if(leader->health <= 0)
+		{
+			//Quake3Game()->DebugPrint( WL_ERROR,"Q3_SetEnemy: ERROR - desired enemy has health %d\n", enemy->health );
+			return;
+		}
+		else
+		{
+			ent->client->leader = leader;
+		}
+	}
+}
+
+stringID_table_t teamTable [] = 
+{
+	ENUM2STRING(TEAM_FREE),
+//	ENUM2STRING(TEAM_STARFLEET),
+//	ENUM2STRING(TEAM_BORG),
+//	ENUM2STRING(TEAM_PARASITE),
+//	ENUM2STRING(TEAM_SCAVENGERS),
+//	ENUM2STRING(TEAM_KLINGON),
+//	ENUM2STRING(TEAM_MALON),
+//	ENUM2STRING(TEAM_HIROGEN),
+//	ENUM2STRING(TEAM_IMPERIAL),
+//	ENUM2STRING(TEAM_STASIS),
+//	ENUM2STRING(TEAM_8472),
+//	ENUM2STRING(TEAM_BOTS),
+//	ENUM2STRING(TEAM_FORGE),
+//	ENUM2STRING(TEAM_DISGUISE),
+	ENUM2STRING(TEAM_PLAYER),
+	ENUM2STRING(TEAM_ENEMY),
+	ENUM2STRING(TEAM_NEUTRAL),
+	"", TEAM_FREE,
+};
+
+
+/*
+============
+Q3_SetPlayerTeam
+  Description	: 
+  Return type	: static void 
+  Argument		:  int entID
+  Argument		: const char *teamName
+============
+*/
+static void Q3_SetPlayerTeam( int entID, const char *teamName )
+{
+	gentity_t	*ent  = &g_entities[entID];
+	team_t		newTeam;
+
+	if ( !ent )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetPlayerTeam: invalid entID %d\n", entID);
+		return;
+	}
+
+	if ( !ent->client )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "Q3_SetPlayerTeam: ent %d is NOT a player or NPC!\n", entID);
+		return;
+	}
+
+	newTeam = (team_t)GetIDForString( teamTable, teamName );
+	ent->client->playerTeam = newTeam;
+}
+
+
+/*
+============
+Q3_SetEnemyTeam
+  Description	: 
+  Return type	: static void 
+  Argument		:  int entID
+  Argument		: const char *teamName
+============
+*/
+static void Q3_SetEnemyTeam( int entID, const char *teamName )
+{
+	gentity_t	*ent  = &g_entities[entID];
+
+	if ( !ent )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetEnemyTeam: invalid entID %d\n", entID);
+		return;
+	}
+
+	if ( !ent->client )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "Q3_SetEnemyTeam: ent %d is NOT a player or NPC!\n", entID);
+		return;
+	}
+	
+	ent->client->enemyTeam = (team_t)GetIDForString( teamTable, teamName );
+}
+
+
+/*
+============
+Q3_SetHealth
+  Description	: 
+  Return type	: static void 
+  Argument		:  int entID
+  Argument		: int data
+============
+*/
+static void Q3_SetHealth( int entID, int data )
+{
+	gentity_t	*ent  = &g_entities[entID];
+
+	if ( !ent )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetHealth: invalid entID %d\n", entID);
+		return;
+	}
+	
+	// FIXME : should we really let you set health on a dead guy?
+	// this close to gold I won't change it, but warn you about it
+	if( ent->health <= 0 )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetHealth: trying to set health on a dead guy! %d\n", entID);
+	}
+
+	if ( data < 0 )
+	{
+		data = 0;
+	}
+
+	ent->health = data;
+
+	// should adjust max if new health is higher than max
+	if ( ent->health > ent->max_health )
+	{
+		ent->max_health = ent->health;
+	}
+
+	if(!ent->client)
+	{
+		return;
+	}
+
+	ent->client->ps.stats[STAT_HEALTH] = data;
+	if ( ent->s.number == 0 )
+	{//clamp health to max		
+		if ( ent->client->ps.stats[STAT_HEALTH] > ent->client->ps.stats[STAT_MAX_HEALTH] )
+		{
+			ent->health = ent->client->ps.stats[STAT_HEALTH] = ent->client->ps.stats[STAT_MAX_HEALTH];
+		}
+		if ( data == 0 )
+		{//artificially "killing" the player", don't let him respawn right away
+			ent->client->ps.pm_type = PM_DEAD;
+			//delay respawn for 2 seconds
+			ent->client->respawnTime = level.time + 2000;
+			//stop all scripts
+			if (Q_stricmpn(level.mapname,"_holo",5)) {
+				stop_icarus = qtrue;
+			}
+			//make the team killable
+			//G_MakeTeamVulnerable();
+		}
+	}
+}
+
+/*
+============
+Q3_SetArmor
+  Description	: 
+  Return type	: static void 
+  Argument		:  int entID
+  Argument		: int data
+============
+*/
+static void Q3_SetArmor( int entID, int data )
+{
+	gentity_t	*ent  = &g_entities[entID];
+
+	if ( !ent )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetArmor: invalid entID %d\n", entID);
+		return;
+	}
+	
+	if(!ent->client)
+	{
+		return;
+	}
+
+	ent->client->ps.stats[STAT_ARMOR] = data;
+	if ( ent->s.number == 0 )
+	{//clamp armor to max_health
+		if ( ent->client->ps.stats[STAT_ARMOR] > ent->client->ps.stats[STAT_MAX_HEALTH] )
+		{
+			ent->client->ps.stats[STAT_ARMOR] = ent->client->ps.stats[STAT_MAX_HEALTH];
+		}
+	}
+}
+
+/*
+============
+Q3_SetBState
+  Description	: 
+  Return type	: static qboolean 
+  Argument		:  int entID
+  Argument		: const char *bs_name
+FIXME: this should be a general NPC wrapper function 
+	that is called ANY time	a bState is changed...
+============
+*/
+static qboolean Q3_SetBState( int entID, const char *bs_name )
+{
+	gentity_t	*ent  = &g_entities[entID];
+	bState_t	bSID;
+
+	if ( !ent )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetBState: invalid entID %d\n", entID);
+		return qtrue;
+	}
+	
+	if ( !ent->NPC )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "Q3_SetBState: '%s' is not an NPC\n", ent->targetname );
+		return qtrue;//ok to complete
+	}
+
+	bSID = (bState_t)(GetIDForString( BSTable, bs_name ));
+	if ( bSID > -1 )
+	{
+		if ( bSID == BS_SEARCH || bSID == BS_WANDER )
+		{
+			//FIXME: Reimplement
+			
+			if( ent->waypoint != WAYPOINT_NONE )
+			{
+				NPC_BSSearchStart( ent->waypoint, bSID );
+			}
+			else
+			{
+				ent->waypoint = NAV::GetNearestNode(ent);
+
+				if( ent->waypoint != WAYPOINT_NONE )
+				{
+					NPC_BSSearchStart( ent->waypoint, bSID );
+				}
+				else
+				{
+					Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "Q3_SetBState: '%s' is not in a valid waypoint to search from!\n", ent->targetname );
+					return qtrue;
+				}
+			}
+		}
+		
+
+		ent->NPC->tempBehavior = BS_DEFAULT;//need to clear any temp behaviour
+		if ( ent->NPC->behaviorState == BS_NOCLIP && bSID != BS_NOCLIP )
+		{//need to rise up out of the floor after noclipping
+			ent->currentOrigin[2] += 0.125;
+			G_SetOrigin( ent, ent->currentOrigin );
+			gi.linkentity( ent );
+		}
+		ent->NPC->behaviorState = bSID;
+		if ( bSID == BS_DEFAULT )
+		{
+			ent->NPC->defaultBehavior = bSID;
+		}
+	}
+
+	ent->NPC->aiFlags &= ~NPCAI_TOUCHED_GOAL;
+
+//	if ( bSID == BS_FLY )
+//	{//FIXME: need a set bState wrapper
+//		ent->client->moveType = MT_FLYSWIM;
+//	}
+//	else
+	{
+		//FIXME: these are presumptions!
+		//Q3_SetGravity( entID, g_gravity->value );
+		//ent->client->moveType = MT_RUNJUMP;
+	}
+
+	if ( bSID == BS_NOCLIP )
+	{
+		ent->client->noclip = true;
+	}
+	else
+	{
+		ent->client->noclip = false;
+	}
+
+/*
+	if ( bSID == BS_FACE || bSID == BS_POINT_AND_SHOOT || bSID == BS_FACE_ENEMY )
+	{
+		ent->NPC->aimTime = level.time + 5 * 1000;//try for 5 seconds
+		return qfalse;//need to wait for task complete message
+	}
+*/
+
+//	if ( bSID == BS_SNIPER || bSID == BS_ADVANCE_FIGHT )
+	if ( bSID == BS_ADVANCE_FIGHT )
+	{
+		return qfalse;//need to wait for task complete message
+	}
+
+/*
+	if ( bSID == BS_SHOOT || bSID == BS_POINT_AND_SHOOT )
+	{//Let them shoot right NOW
+		ent->NPC->shotTime = ent->attackDebounceTime = level.time;
+	}
+*/
+	if ( bSID == BS_JUMP )
+	{
+		ent->NPC->jumpState = JS_FACING;
+	}
+
+	return qtrue;//ok to complete
+}
+
+
+/*
+============
+Q3_SetTempBState
+  Description	: 
+  Return type	: static qboolean 
+  Argument		:  int entID
+  Argument		: const char *bs_name
+============
+*/
+static qboolean Q3_SetTempBState( int entID, const char *bs_name )
+{
+	gentity_t	*ent  = &g_entities[entID];
+	bState_t	bSID;
+
+	if ( !ent )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetTempBState: invalid entID %d\n", entID);
+		return qtrue;
+	}
+	
+	if ( !ent->NPC )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "Q3_SetTempBState: '%s' is not an NPC\n", ent->targetname );
+		return qtrue;//ok to complete
+	}
+
+	bSID = (bState_t)(GetIDForString( BSTable, bs_name ));
+	if ( bSID > -1 )
+	{
+		ent->NPC->tempBehavior = bSID;
+	}
+
+/*
+	if ( bSID == BS_FACE || bSID == BS_POINT_AND_SHOOT || bSID == BS_FACE_ENEMY )
+	{
+		ent->NPC->aimTime = level.time + 5 * 1000;//try for 5 seconds
+		return qfalse;//need to wait for task complete message
+	}
+*/
+
+/*
+	if ( bSID == BS_SHOOT || bSID == BS_POINT_AND_SHOOT )
+	{//Let them shoot right NOW
+		ent->NPC->shotTime = ent->attackDebounceTime = level.time;
+	}
+*/
+	return qtrue;//ok to complete
+}
+
+
+/*
+============
+Q3_SetDefaultBState
+  Description	: 
+  Return type	: static void 
+  Argument		:  int entID
+  Argument		: const char *bs_name
+============
+*/
+static void Q3_SetDefaultBState( int entID, const char *bs_name )
+{
+	gentity_t	*ent  = &g_entities[entID];
+	bState_t	bSID;
+
+	if ( !ent )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetDefaultBState: invalid entID %d\n", entID);
+		return;
+	}
+	
+	if ( !ent->NPC )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "Q3_SetDefaultBState: '%s' is not an NPC\n", ent->targetname );
+		return;
+	}
+
+	bSID = (bState_t)(GetIDForString( BSTable, bs_name ));
+	if ( bSID > -1 )
+	{
+		ent->NPC->defaultBehavior = bSID;
+	}
+}
+
+
+/*
+============
+Q3_SetDPitch
+  Description	: 
+  Return type	: static void 
+  Argument		:  int entID
+  Argument		: float data
+============
+*/
+static void Q3_SetDPitch( int entID, float data )
+{
+	gentity_t	*ent  = &g_entities[entID];
+
+	if ( !ent )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetDPitch: invalid entID %d\n", entID);
+		return;
+	}
+	
+	if ( !ent->NPC || !ent->client )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "Q3_SetDPitch: '%s' is not an NPC\n", ent->targetname );
+		return;
+	}
+	
+	int pitchMin = -ent->client->renderInfo.headPitchRangeUp + 1;
+	int pitchMax = ent->client->renderInfo.headPitchRangeDown - 1;
+
+	//clamp angle to -180 -> 180
+	data = AngleNormalize180( data );
+
+	//Clamp it to my valid range
+	if ( data < -1 )
+	{
+		if ( data < pitchMin )
+		{
+			data = pitchMin;
+		}
+	}
+	else if ( data > 1 )
+	{
+		if ( data > pitchMax )
+		{
+			data = pitchMax;
+		}
+	}
+
+	ent->NPC->lockedDesiredPitch = ent->NPC->desiredPitch = data;
+}
+
+
+/*
+============
+Q3_SetDYaw
+  Description	: 
+  Return type	: static void 
+  Argument		:  int entID
+  Argument		: float data
+============
+*/
+static void Q3_SetDYaw( int entID, float data )
+{
+	gentity_t	*ent  = &g_entities[entID];
+	
+	if ( !ent )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetDYaw: invalid entID %d\n", entID);
+		return;
+	}
+	
+	if ( !ent->NPC )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "Q3_SetDYaw: '%s' is not an NPC\n", ent->targetname );
+		return;
+	}
+
+	if(!ent->enemy)
+	{//don't mess with this if they're aiming at someone
+		ent->NPC->lockedDesiredYaw = ent->NPC->desiredYaw = ent->s.angles[1] = data;
+	}
+	else
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Could not set DYAW: '%s' has an enemy (%s)!\n", ent->targetname, ent->enemy->targetname );
+	}
+}
+
+
+/*
+============
+Q3_SetShootDist
+  Description	: 
+  Return type	: static void 
+  Argument		:  int entID
+  Argument		: float data
+============
+*/
+static void Q3_SetShootDist( int entID, float data )
+{
+	gentity_t	*ent  = &g_entities[entID];
+
+	if ( !ent )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetShootDist: invalid entID %d\n", entID);
+		return;
+	}
+	
+	if ( !ent->NPC )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "Q3_SetShootDist: '%s' is not an NPC\n", ent->targetname );
+		return;
+	}
+
+	ent->NPC->stats.shootDistance = data;
+}
+
+
+/*
+============
+Q3_SetVisrange
+  Description	: 
+  Return type	: static void 
+  Argument		:  int entID
+  Argument		: float data
+============
+*/
+static void Q3_SetVisrange( int entID, float data )
+{
+	gentity_t	*ent  = &g_entities[entID];
+
+	if ( !ent )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetVisrange: invalid entID %d\n", entID);
+		return;
+	}
+	
+	if ( !ent->NPC )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "Q3_SetVisrange: '%s' is not an NPC\n", ent->targetname );
+		return;
+	}
+
+	ent->NPC->stats.visrange = data;
+}
+
+
+/*
+============
+Q3_SetEarshot
+  Description	: 
+  Return type	: static void 
+  Argument		:  int entID
+  Argument		: float data
+============
+*/
+static void Q3_SetEarshot( int entID, float data )
+{
+	gentity_t	*ent  = &g_entities[entID];
+
+	if ( !ent )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetEarshot: invalid entID %d\n", entID);
+		return;
+	}
+	
+	if ( !ent->NPC )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "Q3_SetEarshot: '%s' is not an NPC\n", ent->targetname );
+		return;
+	}
+
+	ent->NPC->stats.earshot = data;
+}
+
+
+/*
+============
+Q3_SetVigilance
+  Description	: 
+  Return type	: static void 
+  Argument		:  int entID
+  Argument		: float data
+============
+*/
+static void Q3_SetVigilance( int entID, float data )
+{
+	gentity_t	*ent  = &g_entities[entID];
+
+	if ( !ent )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetVigilance: invalid entID %d\n", entID);
+		return;
+	}
+	
+	if ( !ent->NPC )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "Q3_SetVigilance: '%s' is not an NPC\n", ent->targetname );
+		return;
+	}
+
+	ent->NPC->stats.vigilance = data;
+}
+
+
+/*
+============
+Q3_SetVFOV
+  Description	: 
+  Return type	: static void 
+  Argument		:  int entID
+  Argument		: int data
+============
+*/
+static void Q3_SetVFOV( int entID, int data )
+{
+	gentity_t	*ent  = &g_entities[entID];
+
+	if ( !ent )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetVFOV: invalid entID %d\n", entID);
+		return;
+	}
+	
+	if ( !ent->NPC )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "Q3_SetVFOV: '%s' is not an NPC\n", ent->targetname );
+		return;
+	}
+
+	ent->NPC->stats.vfov = data;
+}
+
+
+/*
+============
+Q3_SetHFOV
+  Description	: 
+  Return type	: static void 
+  Argument		:  int entID
+  Argument		: int data
+============
+*/
+static void Q3_SetHFOV( int entID, int data )
+{
+	gentity_t	*ent  = &g_entities[entID];
+
+	if ( !ent )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetHFOV: invalid entID %d\n", entID);
+		return;
+	}
+	
+	if ( !ent->NPC )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "Q3_SetHFOV: '%s' is not an NPC\n", ent->targetname );
+		return;
+	}
+
+	ent->NPC->stats.hfov = data;
+}
+
+
+/*
+============
+Q3_SetWidth
+  Description	: 
+  Return type	: static void 
+  Argument		:  int entID
+  Argument		: float data
+============
+*/
+static void Q3_SetWidth( int entID, int data )
+{
+	gentity_t	*ent  = &g_entities[entID];
+	
+	if ( !ent )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetWidth: invalid entID %d\n", entID);
+		return;
+	}
+	
+	if ( !ent->NPC )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "Q3_SetWidth: '%s' is not an NPC\n", ent->targetname );
+		return;
+	}
+
+	ent->maxs[0] = ent->maxs[1] =  data;
+	ent->mins[0] = ent->mins[1] = -data;
+}
+
+/*
+============
+Q3_GetTimeScale
+  Description	: 
+  Return type	: static DWORD 
+  Argument		: void
+============
+*/
+// NEEDED???
+/*static DWORD Q3_GetTimeScale( void )
+{
+	//return	Q3_TIME_SCALE;
+	return g_timescale->value;
+}*/
+
+
+/*
+============
+Q3_SetTimeScale
+  Description	: 
+  Return type	: static void 
+  Argument		:  int entID
+  Argument		: const char *data
+============
+*/
+static void Q3_SetTimeScale( int entID, const char *data )
+{
+	// if we're skipping the script DO NOT allow timescale to be set (skipping needs it at 100)
+	if ( g_skippingcin->integer )
+	{
+		return;
+	}
+
+	gi.cvar_set("timescale", data);
+}
+
+
+/*
+============
+Q3_SetInvisible
+  Description	: 
+  Return type	: static void 
+  Argument		:  int entID
+  Argument		: qboolean invisible
+============
+*/
+static void Q3_SetInvisible( int entID, qboolean invisible )
+{
+	gentity_t	*self  = &g_entities[entID];
+
+	if ( !self )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetInvisible: invalid entID %d\n", entID);
+		return;
+	}
+	
+	if ( invisible )
+	{
+		self->s.eFlags |= EF_NODRAW;
+		if ( self->client )
+		{
+			self->client->ps.eFlags |= EF_NODRAW;
+		}
+		self->contents = 0;
+	}
+	else
+	{
+		self->s.eFlags &= ~EF_NODRAW;
+		if ( self->client )
+		{
+			self->client->ps.eFlags &= ~EF_NODRAW;
+		}
+	}
+}
+
+/*
+============
+Q3_SetVampire
+  Description	: 
+  Return type	: static void 
+  Argument		:  int entID
+  Argument		: qboolean vampire
+============
+*/
+static void Q3_SetVampire( int entID, qboolean vampire )
+{
+	gentity_t	*self  = &g_entities[entID];
+
+	if ( !self || !self->client )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetVampire: entID %d not a client\n", entID);
+		return;
+	}
+	
+	if ( vampire )
+	{
+		self->client->ps.powerups[PW_DISINT_2] = Q3_INFINITE;
+	}
+	else
+	{
+		self->client->ps.powerups[PW_DISINT_2] = 0;
+	}
+}
+/*
+============
+Q3_SetGreetAllies
+  Description	: 
+  Return type	: static void 
+  Argument		:  int entID
+  Argument		: qboolean greet
+============
+*/
+static void Q3_SetGreetAllies( int entID, qboolean greet )
+{
+	gentity_t	*self  = &g_entities[entID];
+
+	if ( !self )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetGreetAllies: invalid entID %d\n", entID);
+		return;
+	}
+	
+	if ( !self->NPC )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetGreetAllies: ent %s is not an NPC!\n", self->targetname );
+		return;
+	}
+
+	if ( greet )
+	{
+		self->NPC->aiFlags |= NPCAI_GREET_ALLIES;
+	}
+	else
+	{
+		self->NPC->aiFlags &= ~NPCAI_GREET_ALLIES;
+	}
+}
+
+
+/*
+============
+Q3_SetViewTarget 
+  Description	: 
+  Return type	: static void 
+  Argument		: int entID
+  Argument		: const char *name
+============
+*/
+static void Q3_SetViewTarget (int entID, const char *name)
+{
+	gentity_t	*self  = &g_entities[entID];
+	gentity_t	*viewtarget = G_Find( NULL, FOFS(targetname), (char *) name);
+	vec3_t		viewspot, selfspot, viewvec, viewangles;
+
+	if ( !self )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetViewTarget: invalid entID %d\n", entID);
+		return;
+	}
+	
+	if ( !self->client )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "Q3_SetViewTarget: '%s' is not a player/NPC!\n", self->targetname );
+		return;
+	}
+	
+	//FIXME: Exception handle here
+	if (viewtarget == NULL)
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetViewTarget: can't find ViewTarget: '%s'\n", name );
+		return;
+	}
+	
+	//FIXME: should we set behavior to BS_FACE and keep facing this ent as it moves
+	//around for a script-specified length of time...?
+	VectorCopy ( self->currentOrigin, selfspot );
+	selfspot[2] += self->client->ps.viewheight;
+
+	if ( viewtarget->client && (!g_skippingcin || !g_skippingcin->integer ) ) 
+	{
+		VectorCopy ( viewtarget->client->renderInfo.eyePoint, viewspot );
+	}
+	else
+	{
+		VectorCopy ( viewtarget->currentOrigin, viewspot );
+	}
+	
+	VectorSubtract( viewspot, selfspot, viewvec );
+	
+	vectoangles( viewvec, viewangles );
+
+	Q3_SetDYaw( entID, viewangles[YAW] );
+	if ( !g_skippingcin || !g_skippingcin->integer )
+	{
+		Q3_SetDPitch( entID, viewangles[PITCH] );
+	}
+}
+
+
+/*
+============
+Q3_SetWatchTarget 
+  Description	: 
+  Return type	: static void 
+  Argument		: int entID
+  Argument		: const char *name
+============
+*/
+static void Q3_SetWatchTarget (int entID, const char *name)
+{
+	gentity_t	*self  = &g_entities[entID];
+	gentity_t	*watchTarget = NULL;
+
+	if ( !self )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetWatchTarget: invalid entID %d\n", entID);
+		return;
+	}
+	
+	if ( !self->NPC )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "Q3_SetWatchTarget: '%s' is not an NPC!\n", self->targetname );
+		return;
+	}
+	
+	if ( Q_stricmp( "NULL", name ) == 0 || Q_stricmp( "NONE", name ) == 0 || ( self->targetname && (Q_stricmp( self->targetname, name ) == 0) ) )
+	{//clearing watchTarget
+		self->NPC->watchTarget = NULL;
+	}
+
+	watchTarget = G_Find( NULL, FOFS(targetname), (char *) name);
+	if ( watchTarget == NULL )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetWatchTarget: can't find WatchTarget: '%s'\n", name );
+		return;
+	}
+	
+	self->NPC->watchTarget = watchTarget;
+}
+
+void Q3_SetLoopSound(int entID, const char *name)
+{
+	sfxHandle_t	index;
+	gentity_t	*self  = &g_entities[entID];
+
+	if ( Q_stricmp( "NULL", name ) == 0 || Q_stricmp( "NONE", name )==0)
+	{
+		self->s.loopSound = 0;
+		return;
+	}
+
+	if ( self->s.eType == ET_MOVER )
+	{
+		index = cgi_S_RegisterSound( name );
+	}
+	else
+	{
+		index = G_SoundIndex( name );
+	}
+
+	if (index)
+	{
+		self->s.loopSound = index;
+	}
+	else
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetLoopSound: can't find sound file: '%s'\n", name );
+	}
+}
+
+void Q3_SetICARUSFreeze( int entID, const char *name, qboolean freeze )
+{
+	gentity_t	*self  = G_Find( NULL, FOFS(targetname), name );
+	if ( !self )
+	{//hmm, targetname failed, try script_targetname?
+		self = G_Find( NULL, FOFS(script_targetname), name );
+	}
+
+	if ( !self )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetICARUSFreeze: invalid ent %s\n", name);
+		return;
+	}
+	
+	if ( freeze )
+	{
+		self->svFlags |= SVF_ICARUS_FREEZE;
+	}
+	else
+	{
+		self->svFlags &= ~SVF_ICARUS_FREEZE;
+	}
+}
+
+/*
+============
+Q3_SetViewEntity
+  Description	: 
+  Return type	: static void 
+  Argument		: int entID
+  Argument		: const char *name
+============
+*/
+extern qboolean G_ClearViewEntity( gentity_t *ent );
+extern void G_SetViewEntity( gentity_t *self, gentity_t *viewEntity );
+void Q3_SetViewEntity(int entID, const char *name)
+{
+	gentity_t	*self  = &g_entities[entID];
+	gentity_t	*viewtarget = G_Find( NULL, FOFS(targetname), (char *) name);
+
+	if ( entID != 0 )
+	{//only valid on player
+		Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "Q3_SetViewEntity: only valid on player\n", entID);
+		return;
+	}
+
+	if ( !self )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "Q3_SetViewEntity: invalid entID %d\n", entID);
+		return;
+	}
+	
+	if ( !self->client )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "Q3_SetViewEntity: '%s' is not a player!\n", self->targetname );
+		return;
+	}
+
+	if ( !name )
+	{
+		G_ClearViewEntity( self );
+		return;
+	}
+	
+	if ( viewtarget == NULL )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetViewEntity: can't find ViewEntity: '%s'\n", name );
+		return;
+	}
+
+	G_SetViewEntity( self, viewtarget );
+}
+
+/*
+============
+Q3_SetWeapon 
+  Description	: 
+  Return type	: static void 
+  Argument		: int entID
+  Argument		: const char *wp_name
+============
+*/
+extern gentity_t *TossClientItems( gentity_t *self );
+void G_SetWeapon( gentity_t *self, int wp )
+{
+	qboolean	hadWeapon = qfalse;
+	
+	if ( !self->client )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "Q3_SetWeapon: '%s' is not a player/NPC!\n", self->targetname );
+		return;
+	}
+
+	if ( self->NPC )
+	{//since a script sets a weapon, we presume we don't want to auto-match the player's weapon anymore
+		self->NPC->aiFlags &= ~NPCAI_MATCHPLAYERWEAPON;
+	}
+
+	if(wp == WP_NONE)
+	{//no weapon
+		self->client->ps.weapon = WP_NONE;
+		G_RemoveWeaponModels( self );
+		if ( self->s.number < MAX_CLIENTS )
+		{//make sure the cgame-side knows this
+			CG_ChangeWeapon( wp );
+		}
+		return;
+	}
+
+	gitem_t *item = FindItemForWeapon( (weapon_t) wp);
+	RegisterItem( item );	//make sure the weapon is cached in case this runs at startup
+
+	if ( self->client->ps.stats[STAT_WEAPONS]&( 1 << wp ) )
+	{
+		hadWeapon = qtrue;
+	}
+	if ( self->NPC )
+	{//Should NPCs have only 1 weapon at a time?
+		self->client->ps.stats[STAT_WEAPONS] = ( 1 << wp );
+		self->client->ps.ammo[weaponData[wp].ammoIndex] = 999;
+
+		ChangeWeapon( self, wp );
+		self->client->ps.weapon = wp;
+		self->client->ps.weaponstate = WEAPON_READY;//WEAPON_RAISING;
+		G_AddEvent( self, EV_GENERAL_SOUND, G_SoundIndex( "sound/weapons/change.wav" ));
+	}
+	else
+	{
+		self->client->ps.stats[STAT_WEAPONS] |= ( 1 << wp );
+		self->client->ps.ammo[weaponData[wp].ammoIndex] = ammoData[weaponData[wp].ammoIndex].max;
+
+		G_AddEvent( self, EV_ITEM_PICKUP, (item - bg_itemlist) );
+		//force it to change
+		CG_ChangeWeapon( wp );
+		G_AddEvent( self, EV_GENERAL_SOUND, G_SoundIndex( "sound/weapons/change.wav" ));
+	}
+	G_RemoveWeaponModels( self );
+
+	if ( wp == WP_SABER )
+	{
+		if ( !hadWeapon )
+		{
+			WP_SaberInitBladeData( self );
+		}
+		WP_SaberAddG2SaberModels( self );
+	}
+	else
+	{
+		G_CreateG2AttachedWeaponModel( self, weaponData[wp].weaponMdl, self->handRBolt, 0 );
+	}
+}
+
+static void Q3_SetWeapon (int entID, const char *wp_name)
+{
+	gentity_t	*self  = &g_entities[entID];
+	int		wp = GetIDForString( WPTable, wp_name );
+
+	if ( !self )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetWeapon: invalid entID %d\n", entID);
+		return;
+	}
+
+	if ( !self->client )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "Q3_SetWeapon: '%s' is not a player/NPC!\n", self->targetname );
+		return;
+	}
+
+	if ( self->NPC )
+	{//since a script sets a weapon, we presume we don't want to auto-match the player's weapon anymore
+		self->NPC->aiFlags &= ~NPCAI_MATCHPLAYERWEAPON;
+	}
+
+	if(!Q_stricmp("drop", wp_name))
+	{//no weapon, drop it
+		TossClientItems( self );
+		self->client->ps.weapon = WP_NONE;
+		G_RemoveWeaponModels( self );
+		return;
+	}
+
+	G_SetWeapon( self, wp );
+}
+
+/*
+============
+Q3_SetItem 
+  Description	: 
+  Return type	: static void 
+  Argument		: int entID
+  Argument		: const char *wp_name
+============
+*/
+static void Q3_SetItem (int entID, const char *item_name)
+{
+	gentity_t	*self  = &g_entities[entID];
+	int		inv;
+
+	if ( !self )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetWeapon: invalid entID %d\n", entID);
+		return;
+	}
+	
+	if ( !self->client )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "Q3_SetWeapon: '%s' is not a player/NPC!\n", self->targetname );
+		return;
+	}
+
+	inv = GetIDForString( INVTable, item_name );
+
+	
+	gitem_t *item = FindItemForInventory(inv);
+	RegisterItem( item );	//make sure the item is cached in case this runs at startup
+
+//		G_AddEvent( self, EV_ITEM_PICKUP, (item - bg_itemlist) );
+//		G_AddEvent( self, EV_GENERAL_SOUND, G_SoundIndex( "sound/weapons/change.wav" ));
+
+	self->client->ps.stats[STAT_ITEMS] |= (1<<item->giTag);
+
+	if( (inv == INV_ELECTROBINOCULARS) || (inv == INV_LIGHTAMP_GOGGLES) )
+	{
+		self->client->ps.inventory[inv] = 1;
+		return;
+	} 
+	// else Bacta, seeker, sentry
+	if( self->client->ps.inventory[inv] < 5 )
+	{
+		self->client->ps.inventory[inv]++;
+	}
+}
+
+
+
+/*
+============
+Q3_SetWalkSpeed 
+  Description	: 
+  Return type	: static void 
+  Argument		: int entID
+  Argument		: int int_data
+============
+*/
+static void Q3_SetWalkSpeed (int entID, int int_data)
+{
+	gentity_t	*self  = &g_entities[entID];
+
+	if ( !self )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetWalkSpeed: invalid entID %d\n", entID);
+		return;
+	}
+	
+	if ( !self->NPC )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "Q3_SetWalkSpeed: '%s' is not an NPC!\n", self->targetname );
+		return;
+	}
+
+	if(int_data == 0)
+	{
+		self->NPC->stats.walkSpeed = self->client->ps.speed = 1;
+	}
+
+	self->NPC->stats.walkSpeed = self->client->ps.speed = int_data;
+}
+
+
+/*
+============
+Q3_SetRunSpeed 
+  Description	: 
+  Return type	: static void 
+  Argument		: int entID
+  Argument		: int int_data
+============
+*/
+static void Q3_SetRunSpeed (int entID, int int_data)
+{
+	gentity_t	*self  = &g_entities[entID];
+
+	if ( !self )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetRunSpeed: invalid entID %d\n", entID);
+		return;
+	}
+	
+	if ( !self->NPC )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "Q3_SetRunSpeed: '%s' is not an NPC!\n", self->targetname );
+		return;
+	}
+
+	if(int_data == 0)
+	{
+		self->NPC->stats.runSpeed = self->client->ps.speed = 1;
+	}
+
+	self->NPC->stats.runSpeed = self->client->ps.speed = int_data;
+}
+
+
+/*
+============
+Q3_SetYawSpeed 
+  Description	: 
+  Return type	: static void 
+  Argument		: int entID
+  Argument		: float float_data
+============
+*/
+static void Q3_SetYawSpeed (int entID, float float_data)
+{
+	gentity_t	*self  = &g_entities[entID];
+
+	if ( !self )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetYawSpeed: invalid entID %d\n", entID);
+		return;
+	}
+	
+	if ( !self->NPC )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "Q3_SetYawSpeed: '%s' is not an NPC!\n", self->targetname );
+		return;
+	}
+
+	self->NPC->stats.yawSpeed = float_data;
+}
+
+
+/*
+============
+Q3_SetAggression
+  Description	: 
+  Return type	: static void 
+  Argument		: int entID
+  Argument		: int int_data
+============
+*/
+static void Q3_SetAggression(int entID, int int_data)
+{
+	gentity_t	*self  = &g_entities[entID];
+
+
+	if ( !self )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetAggression: invalid entID %d\n", entID);
+		return;
+	}
+	
+	if ( !self->NPC )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "Q3_SetAggression: '%s' is not an NPC!\n", self->targetname );
+		return;
+	}
+
+	if(int_data < 1 || int_data > 5)
+		return;
+
+	self->NPC->stats.aggression = int_data;
+}
+
+
+/*
+============
+Q3_SetAim
+  Description	: 
+  Return type	: static void 
+  Argument		: int entID
+  Argument		: int int_data
+============
+*/
+static void Q3_SetAim(int entID, int int_data)
+{
+	gentity_t	*self  = &g_entities[entID];
+
+	if ( !self )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetAim: invalid entID %d\n", entID);
+		return;
+	}
+	
+	if ( !self->NPC )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "Q3_SetAim: '%s' is not an NPC!\n", self->targetname );
+		return;
+	}
+
+	if(int_data < 1 || int_data > 5)
+		return;
+
+	self->NPC->stats.aim = int_data;
+}
+
+
+/*
+============
+Q3_SetFriction
+  Description	: 
+  Return type	: static void 
+  Argument		: int entID
+  Argument		: int int_data
+============
+*/
+static void Q3_SetFriction(int entID, int int_data)
+{
+	gentity_t	*self  = &g_entities[entID];
+
+	if ( !self )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetFriction: invalid entID %d\n", entID);
+		return;
+	}
+	
+	if ( !self->client )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "Q3_SetFriction: '%s' is not an NPC/player!\n", self->targetname );
+		return;
+	}
+
+	self->client->ps.friction = int_data;
+}
+
+
+/*
+============
+Q3_SetGravity
+  Description	: 
+  Return type	: static void 
+  Argument		: int entID
+  Argument		: float float_data
+============
+*/
+static void Q3_SetGravity(int entID, float float_data)
+{
+	gentity_t	*self  = &g_entities[entID];
+
+	if ( !self )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetGravity: invalid entID %d\n", entID);
+		return;
+	}
+	
+	if ( !self->client )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "Q3_SetGravity: '%s' is not an NPC/player!\n", self->targetname );
+		return;
+	}
+
+	//FIXME: what if we want to return them to normal global gravity?
+	self->svFlags |= SVF_CUSTOM_GRAVITY;
+	self->client->ps.gravity = float_data;
+}
+
+
+/*
+============
+Q3_SetWait
+  Description	: 
+  Return type	: static void 
+  Argument		: int entID
+  Argument		: float float_data
+============
+*/
+static void Q3_SetWait(int entID, float float_data)
+{
+	gentity_t	*self  = &g_entities[entID];
+
+	if ( !self )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetWait: invalid entID %d\n", entID);
+		return;
+	}
+	
+	self->wait = float_data;
+}
+
+
+static void Q3_SetShotSpacing(int entID, int int_data)
+{
+	gentity_t	*self  = &g_entities[entID];
+
+	if ( !self )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetShotSpacing: invalid entID %d\n", entID);
+		return;
+	}
+	
+	if ( !self->NPC )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "Q3_SetShotSpacing: '%s' is not an NPC!\n", self->targetname );
+		return;
+	}
+
+	self->NPC->aiFlags &= ~NPCAI_BURST_WEAPON;
+	self->NPC->burstSpacing = int_data;
+}
+
+/*
+============
+Q3_SetFollowDist
+  Description	: 
+  Return type	: static void 
+  Argument		: int entID
+  Argument		: float float_data
+============
+*/
+static void Q3_SetFollowDist(int entID, float float_data)
+{
+	gentity_t	*self  = &g_entities[entID];
+
+	if ( !self )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetFollowDist: invalid entID %d\n", entID);
+		return;
+	}
+	
+	if ( !self->client || !self->NPC )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "Q3_SetFollowDist: '%s' is not an NPC!\n", self->targetname );
+		return;
+	}
+
+	self->NPC->followDist = float_data;
+}
+
+
+/*
+============
+Q3_SetScale
+  Description	: 
+  Return type	: static void 
+  Argument		: int entID
+  Argument		: float float_data
+============
+*/
+static void Q3_SetScale(int entID, float float_data)
+{
+	gentity_t	*self  = &g_entities[entID];
+
+	if ( !self )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetScale: invalid entID %d\n", entID);
+		return;
+	}
+	
+	self->s.scale = float_data;
+}
+
+
+/*
+============
+Q3_SetRenderCullRadius
+  Description	: allows NPCs to be drawn even when their origin is very far away from their model
+  Return type	: static void 
+  Argument		: int entID
+  Argument		: float float_data (the new radius for render culling)
+============
+*/
+static void Q3_SetRenderCullRadius(int entID, float float_data)
+{
+	gentity_t	*self  = &g_entities[entID];
+
+	if ( !self )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetRenderCullRadius: invalid entID %d\n", entID);
+		return;
+	}
+	
+	self->s.radius = float_data;
+}
+
+
+/*
+============
+Q3_SetCount
+  Description	: 
+  Return type	: static void 
+  Argument		: int entID
+  Argument		: const char *data
+============
+*/
+static void Q3_SetCount(int entID, const char *data)
+{
+	gentity_t	*self  = &g_entities[entID];
+	float		val = 0.0f;
+
+	//FIXME: use FOFS() stuff here to make a generic entity field setting?
+	if ( !self )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetCount: invalid entID %d\n", entID);
+		return;
+	}
+	
+	if ( (val = Q3_CheckStringCounterIncrement( data )) )
+	{
+		self->count += (int)(val);
+	}
+	else
+	{
+		self->count = atoi((char *) data);
+	}
+}
+
+
+/*
+============
+Q3_SetSquadName 
+  Description	: 
+  Return type	: static void 
+  Argument		: int entID
+  Argument		: const char *squadname
+============
+*/
+/*
+static void Q3_SetSquadName (int entID, const char *squadname)
+{
+	gentity_t	*self  = &g_entities[entID];
+
+	if ( !self )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetSquadName: invalid entID %d\n", entID);
+		return;
+	}
+	
+	if ( !self->client )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "Q3_SetSquadName: '%s' is not an NPC/player!\n", self->targetname );
+		return;
+	}
+
+	if(!Q_stricmp("NULL", ((char *)squadname)))
+	{
+		self->client->squadname = NULL;
+	}
+	else
+	{
+		self->client->squadname = G_NewString(squadname);
+	}
+}
+*/
+
+/*
+============
+Q3_SetTargetName 
+  Description	: 
+  Return type	: static void 
+  Argument		: int entID
+  Argument		: const char *targetname
+============
+*/
+static void Q3_SetTargetName (int entID, const char *targetname)
+{
+	gentity_t	*self  = &g_entities[entID];
+
+	if ( !self )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetTargetName: invalid entID %d\n", entID);
+		return;
+	}
+
+	if(!Q_stricmp("NULL", ((char *)targetname)))
+	{
+		self->targetname = NULL;
+	}
+	else
+	{
+		self->targetname = G_NewString( targetname );
+	}
+}
+
+
+/*
+============
+Q3_SetTarget 
+  Description	: 
+  Return type	: static void 
+  Argument		: int entID
+  Argument		: const char *target
+============
+*/
+static void Q3_SetTarget (int entID, const char *target)
+{
+	gentity_t	*self  = &g_entities[entID];
+
+	if ( !self )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetTarget: invalid entID %d\n", entID);
+		return;
+	}
+
+	if(!Q_stricmp("NULL", ((char *)target)))
+	{
+		self->target = NULL;
+	}
+	else
+	{
+		self->target = G_NewString( target );
+	}
+}
+
+/*
+============
+Q3_SetTarget2
+  Description	: 
+  Return type	: static void 
+  Argument		: int entID
+  Argument		: const char *target
+============
+*/
+static void Q3_SetTarget2 (int entID, const char *target2)
+{
+	gentity_t	*self  = &g_entities[entID];
+
+	if ( !self )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetTarget2: invalid entID %d\n", entID);
+		return;
+	}
+
+	if(!Q_stricmp("NULL", ((char *)target2)))
+	{
+		self->target2 = NULL;
+	}
+	else
+	{
+		self->target2 = G_NewString( target2 );
+	}
+}
+/*
+============
+Q3_SetRemoveTarget 
+  Description	: 
+  Return type	: static void 
+  Argument		: int entID
+  Argument		: const char *target
+============
+*/
+static void Q3_SetRemoveTarget (int entID, const char *target)
+{
+	gentity_t	*self  = &g_entities[entID];
+
+	if ( !self )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetRemoveTarget: invalid entID %d\n", entID);
+		return;
+	}
+
+	if ( !self->NPC )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "Q3_SetRemoveTarget: '%s' is not an NPC!\n", self->targetname );
+		return;
+	}
+
+	if( !Q_stricmp("NULL", ((char *)target)) )
+	{
+		self->target3 = NULL;
+	}
+	else
+	{
+		self->target3 = G_NewString( target );
+	}
+}
+
+
+/*
+============
+Q3_SetPainTarget 
+  Description	: 
+  Return type	: void 
+  Argument		: int entID
+  Argument		: const char *targetname
+============
+*/
+static void Q3_SetPainTarget (int entID, const char *targetname)
+{
+	gentity_t	*self  = &g_entities[entID];
+
+	if ( !self )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetPainTarget: invalid entID %d\n", entID);
+		return;
+	}
+
+	if(Q_stricmp("NULL", ((char *)targetname)) == 0)
+	{
+		self->paintarget = NULL;
+	}
+	else
+	{
+		self->paintarget = G_NewString((char *)targetname);
+	}
+}
+
+static void Q3_SetMusicState( const char *dms )
+{
+	int newDMS = GetIDForString( DMSTable, dms );
+	if ( newDMS != -1 )
+	{
+		level.dmState = newDMS;
+	}
+}
+
+static void Q3_SetForcePowerLevel ( int entID, int forcePower, int forceLevel )
+{
+	if ( forcePower < FP_FIRST || forceLevel >= NUM_FORCE_POWERS )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "Q3_SetForcePowerLevel: Force Power index %d out of range (%d-%d)\n", forcePower, FP_FIRST, (NUM_FORCE_POWERS-1) );
+		return;
+	}
+
+	if ( forceLevel < 0 || forceLevel >= NUM_FORCE_POWER_LEVELS )
+	{
+		if ( forcePower != FP_SABER_OFFENSE || forceLevel >= SS_NUM_SABER_STYLES )
+		{
+			Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "Q3_SetForcePowerLevel: Force power setting %d out of range (0-3)\n", forceLevel );
+			return;
+		}
+	}
+
+	gentity_t	*self  = &g_entities[entID];
+
+	if ( !self )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "Q3_SetForcePowerLevel: invalid entID %d\n", entID);
+		return;
+	}
+
+	if ( !self->client )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "Q3_SetForcePowerLevel: ent %s is not a player or NPC\n", self->targetname );
+		return;
+	}
+
+	if ((forceLevel > self->client->ps.forcePowerLevel[forcePower]) && (entID==0) && (forceLevel > 0))
+	{
+		if (0)
+		{
+			if (!cg_updatedDataPadForcePower1.integer)
+			{
+				missionInfo_Updated = qtrue;	// Activate flashing text
+				gi.cvar_set("cg_updatedDataPadForcePower1", va("%d",forcePower+1)); // The +1 is offset in the print routine. It ain't pretty, I know.
+				cg_updatedDataPadForcePower1.integer = forcePower+1;
+			}
+			else if (!cg_updatedDataPadForcePower2.integer)
+			{
+				missionInfo_Updated = qtrue;	// Activate flashing text
+				gi.cvar_set("cg_updatedDataPadForcePower2", va("%d",forcePower+1)); // The +1 is offset in the print routine. It ain't pretty, I know.
+				cg_updatedDataPadForcePower2.integer = forcePower+1;
+			}
+			else if (!cg_updatedDataPadForcePower3.integer)
+			{
+				missionInfo_Updated = qtrue;	// Activate flashing text
+				gi.cvar_set("cg_updatedDataPadForcePower3", va("%d",forcePower+1)); // The +1 is offset in the print routine. It ain't pretty, I know.
+				cg_updatedDataPadForcePower3.integer = forcePower+1;
+			}
+		}
+	}
+
+	self->client->ps.forcePowerLevel[forcePower] = forceLevel;
+	if ( forceLevel )
+	{
+		self->client->ps.forcePowersKnown |= ( 1 << forcePower );
+	}
+	else
+	{
+		self->client->ps.forcePowersKnown &= ~( 1 << forcePower );
+	}
+}
+
+extern qboolean G_InventorySelectable( int index,gentity_t *other);
+static void Q3_GiveSecurityKey( int entID, char *keyname )
+{
+	gentity_t	*other = &g_entities[entID];
+	int			i, original;
+
+	if ( !other )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "Q3_GiveSecurityKey: invalid entID %d\n", entID);
+		return;
+	}
+
+	if ( !other->client )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "Q3_GiveSecurityKey: ent %s is not a player or NPC\n", other->targetname );
+		return;
+	}
+
+	if ( !keyname || !keyname[0] || !Q_stricmp( "none", keyname ) || !Q_stricmp( "null", keyname ) )
+	{//remove the key
+		if ( other->message )
+		{//remove it
+			INV_SecurityKeyTake( other, other->message );
+		}
+		return;
+	}
+
+	other->client->ps.stats[STAT_ITEMS] |= (1<<INV_SECURITY_KEY);
+
+	//give the key
+	gi.SendServerCommand( NULL, "cp @SP_INGAME_YOU_TOOK_SECURITY_KEY" );
+	INV_SecurityKeyGive( other, keyname );
+	// Got a security key
+
+	// Set the inventory select, just in case it hasn't
+	original = cg.inventorySelect;
+	for ( i = 0 ; i < INV_MAX ; i++ ) 
+	{
+		if ((cg.inventorySelect < INV_ELECTROBINOCULARS) || (cg.inventorySelect >= INV_MAX))
+		{ 
+			cg.inventorySelect = (INV_MAX - 1); 
+		}
+		
+		if ( G_InventorySelectable( cg.inventorySelect,other ) ) 
+		{	
+			return;
+		}
+		cg.inventorySelect++;
+	}
+
+	cg.inventorySelect = original;
+}
+
+/*
+============
+Q3_SetParm
+  Description	: 
+  Return type	: void 
+  Argument		: int entID
+  Argument		: int parmNum
+  Argument		: const char *parmValue
+============
+*/
+void Q3_SetParm (int entID, int parmNum, const char *parmValue)
+{
+	gentity_t	*ent = &g_entities[entID];
+	float		val;
+
+	if ( !ent )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetParm: invalid entID %d\n", entID);
+		return;
+	}
+
+	if ( parmNum < 0 || parmNum >= MAX_PARMS )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "SET_PARM: parmNum %d out of range!\n", parmNum );
+		return;
+	}
+
+	if( !ent->parms )
+	{
+		ent->parms = (parms_t *)G_Alloc( sizeof(parms_t) );
+		memset( ent->parms, 0, sizeof(parms_t) );
+	}
+
+	if ( (val = Q3_CheckStringCounterIncrement( parmValue )) )
+	{
+		val += atof( ent->parms->parm[parmNum] );
+		sprintf( ent->parms->parm[parmNum], "%f", val );
+	}
+	else
+	{//Just copy the string
+		//copy only 16 characters
+		strncpy( ent->parms->parm[parmNum], parmValue, sizeof(ent->parms->parm[0]) );
+		//set the last charcter to null in case we had to truncate their passed string
+		if ( ent->parms->parm[parmNum][sizeof(ent->parms->parm[0]) - 1] != 0 )
+		{//Tried to set a string that is too long
+			ent->parms->parm[parmNum][sizeof(ent->parms->parm[0]) - 1] = 0;
+			Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "SET_PARM: parm%d string too long, truncated to '%s'!\n", parmNum, ent->parms->parm[parmNum] );
+		}
+	}
+}
+
+
+
+/*
+=============
+Q3_SetCaptureGoal
+
+Sets the capture spot goal of an entity
+=============
+*/
+static void Q3_SetCaptureGoal( int entID, const char *name )
+{
+	gentity_t	*ent  = &g_entities[entID];
+	gentity_t	*goal = G_Find( NULL, FOFS(targetname), (char *) name);
+
+	if ( !ent )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetCaptureGoal: invalid entID %d\n", entID);
+		return;
+	}
+	
+	if ( !ent->NPC )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "Q3_SetCaptureGoal: '%s' is not an NPC!\n", ent->targetname );
+		return;
+	}
+	
+	//FIXME: Exception handle here
+	if (goal == NULL)
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "Q3_SetCaptureGoal: can't find CaptureGoal target: '%s'\n", name );
+		return;
+	}
+
+	if(ent->NPC)
+	{
+		ent->NPC->captureGoal = goal;
+		ent->NPC->goalEntity = goal;
+		ent->NPC->goalTime = level.time + 100000;
+	}
+}
+
+/*
+=============
+Q3_SetEvent
+
+?
+=============
+*/
+static void Q3_SetEvent( int entID, const char *event_name )
+{
+	gentity_t	*ent  = &g_entities[entID];
+//	gentity_t	*tent  = NULL;
+	int			event;
+//	vec3_t		spot;
+
+	if ( !ent )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetEvent: invalid entID %d\n", entID);
+		return;
+	}
+	
+	event = GetIDForString( eventTable, event_name );
+	switch( event )
+	{
+/*
+	case EV_DISINTEGRATE:
+		if( VectorCompare( ent->currentOrigin, vec3_origin ) )
+		{//Brush with no origin
+			VectorSubtract( ent->absmax, ent->absmin, spot );
+			VectorMA( ent->absmin, 0.5, spot, spot );
+		}
+		else
+		{
+			VectorCopy( ent->currentOrigin, spot );
+			spot[2] += ent->maxs[2]/2;
+		}
+		tent = G_TempEntity( spot, EV_DISINTEGRATION );
+		tent->s.eventParm = PW_REGEN;
+		tent->owner = ent;
+		break;
+
+*/
+	case EV_BAD:
+	default:
+		//Quake3Game()->DebugPrint( IGameInterface::WL_ERROR,"Q3_SetEvent: Invalid Event %d\n", event );
+		return;
+		break;
+	}
+}
+
+/*
+============
+Q3_Use
+
+Uses an entity
+============
+*/
+/*static void Q3_Use( int entID, const char *target )
+{
+	gentity_t	*ent  = &g_entities[entID];
+	
+	if ( !ent )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_Use: invalid entID %d\n", entID);
+		return;
+	}
+
+	if( !target || !target[0] )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_Use: string is NULL!\n" );
+		return;
+	}
+
+	G_UseTargets2(ent, ent, target);
+}*/
+
+
+/*
+============
+Q3_SetBehaviorSet
+
+?
+============
+*/
+static qboolean Q3_SetBehaviorSet( int entID, int toSet, const char *scriptname)
+{
+	gentity_t	*ent  = &g_entities[entID];
+	bSet_t		bSet = BSET_INVALID;
+
+	if ( !ent )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetBehaviorSet: invalid entID %d\n", entID);
+		return qfalse;
+	}
+
+	switch(toSet)
+	{
+	case SET_SPAWNSCRIPT:
+		bSet = BSET_SPAWN;
+		break;
+	case SET_USESCRIPT:
+		bSet = BSET_USE;
+		break;
+	case SET_AWAKESCRIPT:
+		bSet = BSET_AWAKE;
+		break;
+	case SET_ANGERSCRIPT:
+		bSet = BSET_ANGER;
+		break;
+	case SET_ATTACKSCRIPT:
+		bSet = BSET_ATTACK;
+		break;
+	case SET_VICTORYSCRIPT:
+		bSet = BSET_VICTORY;
+		break;
+	case SET_LOSTENEMYSCRIPT:
+		bSet = BSET_LOSTENEMY;
+		break;
+	case SET_PAINSCRIPT:
+		bSet = BSET_PAIN;
+		break;
+	case SET_FLEESCRIPT:
+		bSet = BSET_FLEE;
+		break;
+	case SET_DEATHSCRIPT:
+		bSet = BSET_DEATH;
+		break;
+	case SET_DELAYEDSCRIPT:
+		bSet = BSET_DELAYED;
+		break;
+	case SET_BLOCKEDSCRIPT:
+		bSet = BSET_BLOCKED;
+		break;
+	case SET_FFIRESCRIPT:
+		bSet = BSET_FFIRE;
+		break;
+	case SET_FFDEATHSCRIPT:
+		bSet = BSET_FFDEATH;
+		break;
+	case SET_MINDTRICKSCRIPT:
+		bSet = BSET_MINDTRICK;
+		break;
+	}
+
+	if(bSet < BSET_SPAWN || bSet >= NUM_BSETS)
+	{
+		return qfalse;
+	}
+
+	if(!Q_stricmp("NULL", scriptname))
+	{
+		if ( ent->behaviorSet[bSet] != NULL )
+		{
+//			gi.TagFree( ent->behaviorSet[bSet] );
+		}
+
+		ent->behaviorSet[bSet] = NULL;
+		//memset( &ent->behaviorSet[bSet], 0, sizeof(ent->behaviorSet[bSet]) );
+	}
+	else
+	{
+		if ( scriptname )
+		{
+			if ( ent->behaviorSet[bSet] != NULL )
+			{
+//				gi.TagFree( ent->behaviorSet[bSet] );
+			}
+			
+			ent->behaviorSet[bSet] = G_NewString( (char *) scriptname );	//FIXME: This really isn't good...
+		}
+
+		//ent->behaviorSet[bSet] = scriptname;
+		//strncpy( (char *) &ent->behaviorSet[bSet], scriptname, MAX_BSET_LENGTH );
+	}
+	return qtrue;
+}
+
+/*
+============
+Q3_SetDelayScriptTime
+
+?
+============
+*/
+static void Q3_SetDelayScriptTime(int entID, int delayTime)
+{
+	gentity_t	*ent  = &g_entities[entID];
+
+	if ( !ent )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetDelayScriptTime: invalid entID %d\n", entID);
+		return;
+	}
+
+	ent->delayScriptTime = level.time + delayTime;
+}
+
+	
+/*
+============
+Q3_SetIgnorePain
+
+?
+============
+*/
+static void Q3_SetIgnorePain( int entID, qboolean data)
+{
+	gentity_t	*ent  = &g_entities[entID];
+
+	if ( !ent )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetIgnorePain: invalid entID %d\n", entID);
+		return;
+	}
+	
+	if ( !ent->NPC )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "Q3_SetIgnorePain: '%s' is not an NPC!\n", ent->targetname );
+		return;
+	}
+
+	ent->NPC->ignorePain = data;
+}
+
+/*
+============
+Q3_SetIgnoreEnemies
+
+?
+============
+*/
+static void Q3_SetIgnoreEnemies( int entID, qboolean data)
+{
+	gentity_t	*ent  = &g_entities[entID];
+
+	if ( !ent )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetIgnoreEnemies: invalid entID %d\n", entID);
+		return;
+	}
+	
+	if ( !ent->NPC )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "Q3_SetIgnoreEnemies: '%s' is not an NPC!\n", ent->targetname );
+		return;
+	}
+
+	if(data)
+	{
+		ent->svFlags |= SVF_IGNORE_ENEMIES;
+	}
+	else
+	{
+		ent->svFlags &= ~SVF_IGNORE_ENEMIES;
+	}
+}
+
+/*
+============
+Q3_SetIgnoreAlerts
+
+?
+============
+*/
+static void Q3_SetIgnoreAlerts( int entID, qboolean data)
+{
+	gentity_t	*ent  = &g_entities[entID];
+
+	if ( !ent )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetIgnoreAlerts: invalid entID %d\n", entID);
+		return;
+	}
+	
+	if ( !ent->NPC )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "Q3_SetIgnoreAlerts: '%s' is not an NPC!\n", ent->targetname );
+		return;
+	}
+
+	if(data)
+	{
+		ent->NPC->scriptFlags |= SCF_IGNORE_ALERTS;
+	}
+	else
+	{
+		ent->NPC->scriptFlags &= ~SCF_IGNORE_ALERTS;
+	}
+}
+
+
+/*
+============
+Q3_SetNoTarget
+
+?
+============
+*/
+static void Q3_SetNoTarget( int entID, qboolean data)
+{
+	gentity_t	*ent  = &g_entities[entID];
+
+	if ( !ent )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetNoTarget: invalid entID %d\n", entID);
+		return;
+	}
+
+	if(data)
+		ent->flags |= FL_NOTARGET;
+	else
+		ent->flags &= ~FL_NOTARGET;
+}
+
+/*
+============
+Q3_SetDontShoot
+
+?
+============
+*/
+static void Q3_SetDontShoot( int entID, qboolean add)
+{
+	gentity_t	*ent  = &g_entities[entID];
+
+	if ( !ent )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetDontShoot: invalid entID %d\n", entID);
+		return;
+	}
+
+	if(add)
+	{
+		ent->flags |= FL_DONT_SHOOT;
+	}
+	else
+	{
+		ent->flags &= ~FL_DONT_SHOOT;
+	}
+}
+
+/*
+============
+Q3_SetDontFire
+
+?
+============
+*/
+static void Q3_SetDontFire( int entID, qboolean add)
+{
+	gentity_t	*ent  = &g_entities[entID];
+
+	if ( !ent )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetDontFire: invalid entID %d\n", entID);
+		return;
+	}
+	
+	if ( !ent->NPC )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "Q3_SetDontFire: '%s' is not an NPC!\n", ent->targetname );
+		return;
+	}
+
+	if(add)
+	{
+		ent->NPC->scriptFlags |= SCF_DONT_FIRE;
+	}
+	else
+	{
+		ent->NPC->scriptFlags &= ~SCF_DONT_FIRE;
+	}
+}
+
+/*
+============
+Q3_SetFireWeapon
+
+?
+============
+*/
+static void Q3_SetFireWeapon(int entID, qboolean add)
+{
+	gentity_t	*ent  = &g_entities[entID];
+
+	if ( !ent )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_FireWeapon: invalid entID %d\n", entID);
+		return;
+	}
+	
+	if ( !ent->NPC )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "Q3_SetFireWeapon: '%s' is not an NPC!\n", ent->targetname );
+		return;
+	}
+
+	if(add)
+	{
+		ent->NPC->scriptFlags |= SCF_FIRE_WEAPON;
+	}
+	else
+	{
+		ent->NPC->scriptFlags &= ~SCF_FIRE_WEAPON;
+	}
+}
+
+/*
+============
+Q3_SetFireWeaponNoAnim
+
+?
+============
+*/
+static void Q3_SetFireWeaponNoAnim(int entID, qboolean add)
+{
+	gentity_t	*ent  = &g_entities[entID];
+
+	if ( !ent )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_FireWeaponNoAnim: invalid entID %d\n", entID);
+		return;
+	}
+	
+	if ( !ent->NPC )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "Q3_SetFireWeaponNoAnim: '%s' is not an NPC!\n", ent->targetname );
+		return;
+	}
+
+	if(add)
+	{
+		ent->NPC->scriptFlags |= SCF_FIRE_WEAPON_NO_ANIM;
+	}
+	else
+	{
+		ent->NPC->scriptFlags &= ~SCF_FIRE_WEAPON_NO_ANIM;
+	}
+}
+
+/*
+============
+Q3_SetSafeRemove
+
+If true, NPC will remove itself once player is not in PVS
+============
+*/
+static void Q3_SetSafeRemove(int entID, qboolean add)
+{
+	gentity_t	*ent  = &g_entities[entID];
+
+	if ( !ent )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetSafeRemove: invalid entID %d\n", entID);
+		return;
+	}
+	
+	if ( !ent->NPC )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "Q3_SetSafeRemove: '%s' is not an NPC!\n", ent->targetname );
+		return;
+	}
+
+	if(add)
+	{
+		ent->NPC->scriptFlags |= SCF_SAFE_REMOVE;
+	}
+	else
+	{
+		ent->NPC->scriptFlags &= ~SCF_SAFE_REMOVE;
+	}
+}
+
+/*
+============
+Q3_SetBobaJetPack
+
+Turn on/off Boba's jet pack
+============
+*/
+static void Q3_SetBobaJetPack(int entID, qboolean add)
+{
+	gentity_t	*ent  = &g_entities[entID];
+
+	if ( !ent )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetBobaJetPack: invalid entID %d\n", entID);
+		return;
+	}
+	
+	if ( !ent->NPC )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "Q3_SetBobaJetPack: '%s' is not an NPC!\n", ent->targetname );
+		return;
+	}
+	
+	// make sure we this is Boba Fett
+	if ( ent->client && ent->client->NPC_class != CLASS_BOBAFETT )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetBobaJetPack: '%s' is not Boba Fett!\n", ent->targetname );
+		return;
+	}
+	
+	if(add)
+	{
+		if ( ent->genericBolt1 != -1 )
+		{
+			G_PlayEffect( G_EffectIndex( "boba/jetSP" ), ent->playerModel, ent->genericBolt1, ent->s.number, ent->currentOrigin, qtrue, qtrue );
+		}
+		if ( ent->genericBolt2 != -1 )
+		{
+			G_PlayEffect( G_EffectIndex( "boba/jetSP" ), ent->playerModel, ent->genericBolt2, ent->s.number, ent->currentOrigin, qtrue, qtrue );
+		}
+		//take-off sound
+		G_SoundOnEnt( ent, CHAN_ITEM, "sound/chars/boba/bf_blast-off.wav" );
+		//jet loop sound
+		ent->s.loopSound = G_SoundIndex( "sound/chars/boba/bf_jetpack_lp.wav" );
+	}
+	else
+	{
+		if ( ent->genericBolt1 != -1 )
+		{
+			G_StopEffect( "boba/jetSP", ent->playerModel, ent->genericBolt1, ent->s.number );
+		}
+		if ( ent->genericBolt2 != -1 )
+		{
+			G_StopEffect( "boba/jetSP", ent->playerModel, ent->genericBolt2, ent->s.number );
+		}
+		//stop jet loop sound
+		ent->s.loopSound = 0;
+		G_SoundOnEnt( ent, CHAN_ITEM, "sound/chars/boba/bf_land.wav" );
+
+	}
+}
+/*
+============
+Q3_SetInactive
+
+?
+============
+*/
+static void Q3_SetInactive(int entID, qboolean add)
+{
+	gentity_t	*ent  = &g_entities[entID];
+
+	if ( !ent )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetInactive: invalid entID %d\n", entID);
+		return;
+	}
+	
+	if(add)
+	{
+		ent->svFlags |= SVF_INACTIVE;
+	}
+	else
+	{
+		ent->svFlags &= ~SVF_INACTIVE;
+	}
+}
+
+/*
+============
+Q3_SetFuncUsableVisible
+
+?
+============
+*/
+static void Q3_SetFuncUsableVisible(int entID, qboolean visible )
+{
+	gentity_t	*ent  = &g_entities[entID];
+
+	if ( !ent )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetFuncUsableVisible: invalid entID %d\n", entID);
+		return;
+	}
+	
+	// Yeah, I know that this doesn't even do half of what the func_usable use code does, but if I've got two things on top of each other...and only
+	//	one is visible at a time....and neither can ever be used......and finally, the shader on it has the shader_anim stuff going on....It doesn't seem
+	//	like I can easily use the other version without nasty side effects.
+	if( visible )
+	{
+		ent->svFlags &= ~SVF_NOCLIENT;
+		ent->s.eFlags &= ~EF_NODRAW;
+	}
+	else
+	{
+		ent->svFlags |= SVF_NOCLIENT;
+		ent->s.eFlags |= EF_NODRAW;
+	}
+}
+
+/*
+============
+Q3_SetLockedEnemy
+
+?
+============
+*/
+static void Q3_SetLockedEnemy ( int entID, qboolean locked)
+{
+	gentity_t	*ent  = &g_entities[entID];
+
+	if ( !ent )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetLockedEnemy: invalid entID %d\n", entID);
+		return;
+	}
+
+	if ( !ent->NPC )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "Q3_SetLockedEnemy: '%s' is not an NPC!\n", ent->targetname );
+		return;
+	}
+	
+	//FIXME: make an NPCAI_FLAG
+	if(locked)
+	{
+		ent->svFlags |= SVF_LOCKEDENEMY;
+	}
+	else
+	{
+		ent->svFlags &= ~SVF_LOCKEDENEMY;
+	}
+}
+
+char cinematicSkipScript[64];
+
+/*
+============
+Q3_SetCinematicSkipScript
+
+============
+*/
+static void Q3_SetCinematicSkipScript( char *scriptname )
+{
+
+	if(Q_stricmp("none", scriptname) == 0 || Q_stricmp("NULL", scriptname) == 0)
+	{
+		cinematicSkipScript[0] = 0;
+	}
+	else
+	{
+		Q_strncpyz(cinematicSkipScript,scriptname,sizeof(cinematicSkipScript));
+	}
+
+}
+
+/*
+============
+Q3_SetNoMindTrick
+
+?
+============
+*/
+static void Q3_SetNoMindTrick( int entID, qboolean add)
+{
+	gentity_t	*ent  = &g_entities[entID];
+
+	if ( !ent )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetNoMindTrick: invalid entID %d\n", entID);
+		return;
+	}
+
+	if ( !ent->NPC )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "Q3_SetNoMindTrick: '%s' is not an NPC!\n", ent->targetname );
+		return;
+	}
+
+	if(add)
+	{
+		ent->NPC->scriptFlags |= SCF_NO_MIND_TRICK;
+		ent->NPC->confusionTime = 0;
+		if ( ent->ghoul2.size() && ent->headBolt != -1 )
+		{
+			G_StopEffect("force/confusion", ent->playerModel, ent->headBolt, ent->s.number );
+		}
+	}
+	else
+	{
+		ent->NPC->scriptFlags &= ~SCF_NO_MIND_TRICK;
+	}
+}
+
+/*
+============
+Q3_SetCrouched
+
+?
+============
+*/
+static void Q3_SetCrouched( int entID, qboolean add)
+{
+	gentity_t	*ent  = &g_entities[entID];
+
+	if ( !ent )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetCrouched: invalid entID %d\n", entID);
+		return;
+	}
+
+	if ( !ent->NPC )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "Q3_SetCrouched: '%s' is not an NPC!\n", ent->targetname );
+		return;
+	}
+
+	if(add)
+	{
+		ent->NPC->scriptFlags |= SCF_CROUCHED;
+	}
+	else
+	{
+		ent->NPC->scriptFlags &= ~SCF_CROUCHED;
+	}
+}
+
+/*
+============
+Q3_SetWalking
+
+?
+============
+*/
+static void Q3_SetWalking( int entID, qboolean add)
+{
+	gentity_t	*ent  = &g_entities[entID];
+
+	if ( !ent )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetWalking: invalid entID %d\n", entID);
+		return;
+	}
+
+	if ( !ent->NPC )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "Q3_SetWalking: '%s' is not an NPC!\n", ent->targetname );
+		return;
+	}
+
+	if(add)
+	{
+		ent->NPC->scriptFlags |= SCF_WALKING;
+	}
+	else
+	{
+		ent->NPC->scriptFlags &= ~SCF_WALKING;
+	}
+}
+
+/*
+============
+Q3_SetRunning
+
+?
+============
+*/
+static void Q3_SetRunning( int entID, qboolean add)
+{
+	gentity_t	*ent  = &g_entities[entID];
+
+	if ( !ent )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetRunning: invalid entID %d\n", entID);
+		return;
+	}
+
+	if ( !ent->NPC )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "Q3_SetRunning: '%s' is not an NPC!\n", ent->targetname );
+		return;
+	}
+
+	if(add)
+	{
+		ent->NPC->scriptFlags |= SCF_RUNNING;
+	}
+	else
+	{
+		ent->NPC->scriptFlags &= ~SCF_RUNNING;
+	}
+}
+
+/*
+============
+Q3_SetForcedMarch
+
+?
+============
+*/
+static void Q3_SetForcedMarch( int entID, qboolean add)
+{
+	gentity_t	*ent  = &g_entities[entID];
+
+	if ( !ent )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetForcedMarch: invalid entID %d\n", entID);
+		return;
+	}
+
+	if ( !ent->NPC )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "Q3_SetForcedMarch: '%s' is not an NPC!\n", ent->targetname );
+		return;
+	}
+
+	if(add)
+	{
+		ent->NPC->scriptFlags |= SCF_FORCED_MARCH;
+	}
+	else
+	{
+		ent->NPC->scriptFlags &= ~SCF_FORCED_MARCH;
+	}
+}
+/*
+============
+Q3_SetChaseEnemies
+
+indicates whether the npc should chase after an enemy 
+============
+*/
+static void Q3_SetChaseEnemies( int entID, qboolean add)
+{
+	gentity_t	*ent  = &g_entities[entID];
+
+	if ( !ent )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetChaseEnemies: invalid entID %d\n", entID);
+		return;
+	}
+
+	if ( !ent->NPC )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "Q3_SetChaseEnemies: '%s' is not an NPC!\n", ent->targetname );
+		return;
+	}
+
+	if(add)
+	{
+		ent->NPC->scriptFlags |= SCF_CHASE_ENEMIES;
+	}
+	else
+	{
+		ent->NPC->scriptFlags &= ~SCF_CHASE_ENEMIES;
+	}
+}
+
+/*
+============
+Q3_SetLookForEnemies
+
+if set npc will be on the look out for potential enemies
+if not set, npc will ignore enemies
+============
+*/
+static void Q3_SetLookForEnemies( int entID, qboolean add)
+{
+	gentity_t	*ent  = &g_entities[entID];
+
+	if ( !ent )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetLookForEnemies: invalid entID %d\n", entID);
+		return;
+	}
+
+	if ( !ent->NPC )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "Q3_SetLookForEnemies: '%s' is not an NPC!\n", ent->targetname );
+		return;
+	}
+
+	if(add)
+	{
+		ent->NPC->scriptFlags |= SCF_LOOK_FOR_ENEMIES;
+	}
+	else
+	{
+		ent->NPC->scriptFlags &= ~SCF_LOOK_FOR_ENEMIES;
+	}
+}
+
+/*
+============
+Q3_SetFaceMoveDir
+
+============
+*/
+static void Q3_SetFaceMoveDir( int entID, qboolean add)
+{
+	gentity_t	*ent  = &g_entities[entID];
+
+	if ( !ent )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetFaceMoveDir: invalid entID %d\n", entID);
+		return;
+	}
+
+	if ( !ent->NPC )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "Q3_SetFaceMoveDir: '%s' is not an NPC!\n", ent->targetname );
+		return;
+	}
+
+	if(add)
+	{
+		ent->NPC->scriptFlags |= SCF_FACE_MOVE_DIR;
+	}
+	else
+	{
+		ent->NPC->scriptFlags &= ~SCF_FACE_MOVE_DIR;
+	}
+}
+
+/*
+============
+Q3_SetAltFire
+
+?
+============
+*/
+static void Q3_SetAltFire( int entID, qboolean add)
+{
+	gentity_t	*ent  = &g_entities[entID];
+
+	if ( !ent )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetAltFire: invalid entID %d\n", entID);
+		return;
+	}
+
+	if ( !ent->NPC )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "Q3_SetAltFire: '%s' is not an NPC!\n", ent->targetname );
+		return;
+	}
+
+	if(add)
+	{
+		ent->NPC->scriptFlags |= SCF_ALT_FIRE;
+	}
+	else
+	{
+		ent->NPC->scriptFlags &= ~SCF_ALT_FIRE;
+	}
+
+	ChangeWeapon( ent, 	ent->client->ps.weapon );
+
+}
+
+/*
+============
+Q3_SetDontFlee
+
+?
+============
+*/
+static void Q3_SetDontFlee( int entID, qboolean add)
+{
+	gentity_t	*ent  = &g_entities[entID];
+
+	if ( !ent )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetDontFlee: invalid entID %d\n", entID);
+		return;
+	}
+
+	if ( !ent->NPC )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "Q3_SetDontFlee: '%s' is not an NPC!\n", ent->targetname );
+		return;
+	}
+
+	if(add)
+	{
+		ent->NPC->scriptFlags |= SCF_DONT_FLEE;
+	}
+	else
+	{
+		ent->NPC->scriptFlags &= ~SCF_DONT_FLEE;
+	}
+}
+
+/*
+============
+Q3_SetNoResponse
+
+?
+============
+*/
+static void Q3_SetNoResponse( int entID, qboolean add)
+{
+	gentity_t	*ent  = &g_entities[entID];
+
+	if ( !ent )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetNoResponse: invalid entID %d\n", entID);
+		return;
+	}
+
+	if ( !ent->NPC )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "Q3_SetNoResponse: '%s' is not an NPC!\n", ent->targetname );
+		return;
+	}
+
+	if(add)
+	{
+		ent->NPC->scriptFlags |= SCF_NO_RESPONSE;
+	}
+	else
+	{
+		ent->NPC->scriptFlags &= ~SCF_NO_RESPONSE;
+	}
+}
+
+/*
+============
+Q3_SetCombatTalk
+
+?
+============
+*/
+static void Q3_SetCombatTalk( int entID, qboolean add)
+{
+	gentity_t	*ent  = &g_entities[entID];
+
+	if ( !ent )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetCombatTalk: invalid entID %d\n", entID);
+		return;
+	}
+
+	if ( !ent->NPC )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "Q3_SetCombatTalk: '%s' is not an NPC!\n", ent->targetname );
+		return;
+	}
+
+	if ( add )
+	{
+		ent->NPC->scriptFlags |= SCF_NO_COMBAT_TALK;
+	}
+	else
+	{
+		ent->NPC->scriptFlags &= ~SCF_NO_COMBAT_TALK;
+	}
+}
+
+/*
+============
+Q3_SetAlertTalk
+
+?
+============
+*/
+static void Q3_SetAlertTalk( int entID, qboolean add)
+{
+	gentity_t	*ent  = &g_entities[entID];
+
+	if ( !ent )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetAlertTalk: invalid entID %d\n", entID);
+		return;
+	}
+
+	if ( !ent->NPC )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "Q3_SetAlertTalk: '%s' is not an NPC!\n", ent->targetname );
+		return;
+	}
+
+	if ( add )
+	{
+		ent->NPC->scriptFlags |= SCF_NO_ALERT_TALK;
+	}
+	else
+	{
+		ent->NPC->scriptFlags &= ~SCF_NO_ALERT_TALK;
+	}
+}
+
+/*
+============
+Q3_SetUseCpNearest
+
+?
+============
+*/
+static void Q3_SetUseCpNearest( int entID, qboolean add)
+{
+	gentity_t	*ent  = &g_entities[entID];
+
+	if ( !ent )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetUseCpNearest: invalid entID %d\n", entID);
+		return;
+	}
+
+	if ( !ent->NPC )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "Q3_SetUseCpNearest: '%s' is not an NPC!\n", ent->targetname );
+		return;
+	}
+
+	if ( add )
+	{
+		ent->NPC->scriptFlags |= SCF_USE_CP_NEAREST;
+	}
+	else
+	{
+		ent->NPC->scriptFlags &= ~SCF_USE_CP_NEAREST;
+	}
+}
+
+/*
+============
+Q3_SetNoForce
+
+?
+============
+*/
+static void Q3_SetNoForce( int entID, qboolean add)
+{
+	gentity_t	*ent  = &g_entities[entID];
+
+	if ( !ent )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetNoForce: invalid entID %d\n", entID);
+		return;
+	}
+
+	if ( !ent->NPC )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "Q3_SetNoForce: '%s' is not an NPC!\n", ent->targetname );
+		return;
+	}
+
+	if ( add )
+	{
+		ent->NPC->scriptFlags |= SCF_NO_FORCE;
+	}
+	else
+	{
+		ent->NPC->scriptFlags &= ~SCF_NO_FORCE;
+	}
+}
+
+/*
+============
+Q3_SetNoAcrobatics
+
+?
+============
+*/
+static void Q3_SetNoAcrobatics( int entID, qboolean add)
+{
+	gentity_t	*ent  = &g_entities[entID];
+
+	if ( !ent )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetNoAcrobatics: invalid entID %d\n", entID);
+		return;
+	}
+
+	if ( !ent->NPC )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "Q3_SetNoAcrobatics: '%s' is not an NPC!\n", ent->targetname );
+		return;
+	}
+
+	if ( add )
+	{
+		ent->NPC->scriptFlags |= SCF_NO_ACROBATICS;
+	}
+	else
+	{
+		ent->NPC->scriptFlags &= ~SCF_NO_ACROBATICS;
+	}
+}
+
+/*
+============
+Q3_SetUseSubtitles
+
+?
+============
+*/
+static void Q3_SetUseSubtitles( int entID, qboolean add)
+{
+	gentity_t	*ent  = &g_entities[entID];
+
+	if ( !ent )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetUseSubtitles: invalid entID %d\n", entID);
+		return;
+	}
+
+	if ( !ent->NPC )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "Q3_SetUseSubtitles: '%s' is not an NPC!\n", ent->targetname );
+		return;
+	}
+
+	if ( add )
+	{
+		ent->NPC->scriptFlags |= SCF_USE_SUBTITLES;
+	}
+	else
+	{
+		ent->NPC->scriptFlags &= ~SCF_USE_SUBTITLES;
+	}
+}
+
+/*
+============
+Q3_SetNoFallToDeath
+
+?
+============
+*/
+static void Q3_SetNoFallToDeath( int entID, qboolean add)
+{
+	gentity_t	*ent  = &g_entities[entID];
+
+	if ( !ent )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetNoFallToDeath: invalid entID %d\n", entID);
+		return;
+	}
+
+	if ( !ent->NPC )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "Q3_SetNoFallToDeath: '%s' is not an NPC!\n", ent->targetname );
+		return;
+	}
+
+	if ( add )
+	{
+		ent->NPC->scriptFlags |= SCF_NO_FALLTODEATH;
+	}
+	else
+	{
+		ent->NPC->scriptFlags &= ~SCF_NO_FALLTODEATH;
+	}
+}
+
+/*
+============
+Q3_SetDismemberable
+
+?
+============
+*/
+static void Q3_SetDismemberable( int entID, qboolean dismemberable)
+{
+	gentity_t	*ent  = &g_entities[entID];
+
+	if ( !ent )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetDismemberable: invalid entID %d\n", entID);
+		return;
+	}
+
+	if ( !ent->client )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "Q3_SetDismemberable: '%s' is not an client!\n", ent->targetname );
+		return;
+	}
+
+	ent->client->dismembered = !dismemberable;
+}
+
+
+/*
+============
+Q3_SetMoreLight
+
+?
+============
+*/
+static void Q3_SetMoreLight( int entID, qboolean add )
+{
+	gentity_t	*ent  = &g_entities[entID];
+
+	if ( !ent )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetMoreLight: invalid entID %d\n", entID);
+		return;
+	}
+
+	if ( !ent->NPC )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "Q3_SetMoreLight: '%s' is not an NPC!\n", ent->targetname );
+		return;
+	}
+
+	if ( add )
+	{
+		ent->NPC->scriptFlags |= SCF_MORELIGHT;
+	}
+	else
+	{
+		ent->NPC->scriptFlags &= ~SCF_MORELIGHT;
+	}
+}
+
+/*
+============
+Q3_SetUndying
+
+?
+============
+*/
+static void Q3_SetUndying( int entID, qboolean undying)
+{
+	gentity_t	*ent  = &g_entities[entID];
+
+	if ( !ent )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetUndying: invalid entID %d\n", entID);
+		return;
+	}
+
+	if(undying)
+	{
+		ent->flags |= FL_UNDYING;
+	}
+	else
+	{
+		ent->flags &= ~FL_UNDYING;
+	}
+}
+
+/*
+============
+Q3_SetInvincible
+
+?
+============
+*/
+static void Q3_SetInvincible( int entID, qboolean invincible)
+{
+	gentity_t	*ent  = &g_entities[entID];
+
+	if ( !ent )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetInvincible: invalid entID %d\n", entID);
+		return;
+	}
+
+	if ( !Q_stricmp( "func_breakable", ent->classname ) )
+	{
+		if ( invincible )
+		{
+			ent->spawnflags |= 1;
+		}
+		else
+		{
+			ent->spawnflags &= ~1;
+		}
+		return;
+	}
+	
+	if ( invincible )
+	{
+		ent->flags |= FL_GODMODE;
+	}
+	else
+	{
+		ent->flags &= ~FL_GODMODE;
+	}
+}
+/*
+============
+Q3_SetForceInvincible
+  Description	: 
+  Return type	: static void 
+  Argument		:  int entID
+  Argument		: qboolean forceInv
+============
+*/
+static void Q3_SetForceInvincible( int entID, qboolean forceInv )
+{
+	gentity_t	*self  = &g_entities[entID];
+
+	if ( !self || !self->client )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetForceInvincible: entID %d not a client\n", entID);
+		return;
+	}
+	
+	Q3_SetInvincible( entID, forceInv );
+	if ( forceInv )
+	{
+		self->client->ps.powerups[PW_INVINCIBLE] = Q3_INFINITE;
+	}
+	else
+	{
+		self->client->ps.powerups[PW_INVINCIBLE] = 0;
+	}
+}
+
+/*
+============
+Q3_SetNoAvoid
+
+?
+============
+*/
+static void Q3_SetNoAvoid( int entID, qboolean noAvoid)
+{
+	gentity_t	*ent  = &g_entities[entID];
+
+	if ( !ent )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetNoAvoid: invalid entID %d\n", entID);
+		return;
+	}
+
+	if ( !ent->NPC )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "Q3_SetNoAvoid: '%s' is not an NPC!\n", ent->targetname );
+		return;
+	}
+
+	if(noAvoid)
+	{
+		ent->NPC->aiFlags |= NPCAI_NO_COLL_AVOID;
+	}
+	else
+	{
+		ent->NPC->aiFlags &= ~NPCAI_NO_COLL_AVOID;
+	}
+}
+
+/*
+============
+SolidifyOwner
+  Description	: 
+  Return type	: void 
+  Argument		: gentity_t *self
+============
+*/
+void SolidifyOwner( gentity_t *self )
+{
+	self->nextthink = level.time + FRAMETIME;
+	self->e_ThinkFunc = thinkF_G_FreeEntity;
+
+	if ( !self->owner || !self->owner->inuse )
+	{
+		return;
+	}
+
+	int oldContents = self->owner->contents;
+	self->owner->contents = CONTENTS_BODY;
+	if ( SpotWouldTelefrag2( self->owner, self->owner->currentOrigin ) )
+	{
+		self->owner->contents = oldContents;
+		self->e_ThinkFunc = thinkF_SolidifyOwner;
+	}
+	else
+	{
+		if ( self->owner->NPC && !(self->owner->spawnflags & SFB_NOTSOLID) )
+		{
+			self->owner->clipmask |= CONTENTS_BODY;
+		}
+		Q3_TaskIDComplete( self->owner, TID_RESIZE );
+	}
+}
+
+
+/*
+============
+Q3_SetSolid
+
+?
+============
+*/
+static qboolean Q3_SetSolid( int entID, qboolean solid)
+{
+	gentity_t	*ent  = &g_entities[entID];
+	
+	if ( !ent )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetSolid: invalid entID %d\n", entID);
+		return qtrue;
+	}
+
+	if ( solid )
+	{//FIXME: Presumption
+		int oldContents = ent->contents;
+		ent->contents = CONTENTS_BODY;
+		if ( SpotWouldTelefrag2( ent, ent->currentOrigin ) )
+		{
+			gentity_t *solidifier = G_Spawn();
+
+			solidifier->owner = ent;
+
+			solidifier->e_ThinkFunc = thinkF_SolidifyOwner;
+			solidifier->nextthink = level.time + FRAMETIME;
+			
+			ent->contents = oldContents;
+			return qfalse;
+		}
+		ent->clipmask |= CONTENTS_BODY;
+	}
+	else
+	{//FIXME: Presumption
+		if ( ent->s.eFlags & EF_NODRAW )
+		{//We're invisible too, so set contents to none
+			ent->contents = 0;
+		}
+		else
+		{
+			ent->contents = CONTENTS_CORPSE;
+		}
+		if ( ent->NPC )
+		{
+			if(!(ent->spawnflags & SFB_NOTSOLID))
+			{
+				ent->clipmask &= ~CONTENTS_BODY;
+			}
+		}
+	}
+	return qtrue;
+}
+/*
+============
+Q3_SetLean
+
+?
+============
+*/
+#define LEAN_NONE	0
+#define LEAN_RIGHT	1
+#define LEAN_LEFT	2
+static void Q3_SetLean( int entID, int lean)
+{
+	gentity_t	*ent  = &g_entities[entID];
+
+	if ( !ent )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetLean: invalid entID %d\n", entID);
+		return;
+	}
+
+	if ( !ent->NPC )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "Q3_SetLean: '%s' is not an NPC!\n", ent->targetname );
+		return;
+	}
+
+	if(lean == LEAN_RIGHT)
+	{
+		ent->NPC->scriptFlags |= SCF_LEAN_RIGHT;
+		ent->NPC->scriptFlags &= ~SCF_LEAN_LEFT;
+	}
+	else if(lean == LEAN_LEFT)
+	{
+		ent->NPC->scriptFlags |= SCF_LEAN_LEFT;
+		ent->NPC->scriptFlags &= ~SCF_LEAN_RIGHT;
+	}
+	else
+	{
+		ent->NPC->scriptFlags &= ~SCF_LEAN_LEFT;
+		ent->NPC->scriptFlags &= ~SCF_LEAN_RIGHT;
+	}
+}
+
+/*
+============
+Q3_SetForwardMove
+
+?
+============
+*/
+static void Q3_SetForwardMove( int entID, int fmoveVal)
+{
+	gentity_t	*ent  = &g_entities[entID];
+
+	if ( !ent )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetForwardMove: invalid entID %d\n", entID);
+		return;
+	}
+
+	if ( !ent->client )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "Q3_SetForwardMove: '%s' is not an NPC/player!\n", ent->targetname );
+		return;
+	}
+
+	ent->client->forced_forwardmove = fmoveVal;
+}
+
+/*
+============
+Q3_SetRightMove
+
+?
+============
+*/
+static void Q3_SetRightMove( int entID, int rmoveVal)
+{
+	gentity_t	*ent  = &g_entities[entID];
+
+	if ( !ent )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetRightMove: invalid entID %d\n", entID);
+		return;
+	}
+
+	if ( !ent->client )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "Q3_SetRightMove: '%s' is not an NPC/player!\n", ent->targetname );
+		return;
+	}
+
+	ent->client->forced_rightmove = rmoveVal;
+}
+
+/*
+============
+Q3_SetLockAngle
+
+?
+============
+*/
+static void Q3_SetLockAngle( int entID, const char *lockAngle)
+{
+	gentity_t	*ent  = &g_entities[entID];
+
+	if ( !ent )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetLockAngle: invalid entID %d\n", entID);
+		return;
+	}
+
+	if ( !ent->client )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "Q3_SetLockAngle: '%s' is not an NPC/player!\n", ent->targetname );
+		return;
+	}
+
+	if(Q_stricmp("off", lockAngle) == 0)
+	{//free it
+		ent->client->renderInfo.renderFlags &= ~RF_LOCKEDANGLE;
+	}
+	else
+	{
+		ent->client->renderInfo.renderFlags |= RF_LOCKEDANGLE;
+
+		
+		if(Q_stricmp("auto", lockAngle) == 0)
+		{//use current yaw
+			if( ent->NPC )	// I need this to work on NPCs, so their locked value
+			{
+				ent->NPC->lockedDesiredYaw =  NPC->client->ps.viewangles[YAW]; // could also set s.angles[1] and desiredYaw to this value...
+			}
+			else
+			{
+				ent->client->renderInfo.lockYaw = ent->client->ps.viewangles[YAW];
+			}
+		}
+		else
+		{//specified yaw
+			if( ent->NPC ) // I need this to work on NPCs, so their locked value
+			{
+				ent->NPC->lockedDesiredYaw = atof((char *)lockAngle); // could also set s.angles[1] and desiredYaw to this value...
+			}
+			else
+			{
+				ent->client->renderInfo.lockYaw = atof((char *)lockAngle);
+			}
+		}
+	}
+}
+
+
+/*
+============
+Q3_CameraGroup
+
+?
+============
+*/
+static void Q3_CameraGroup( int entID, char *camG)
+{
+	gentity_t	*ent  = &g_entities[entID];
+
+	if ( !ent )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_CameraGroup: invalid entID %d\n", entID);
+		return;
+	}
+
+	ent->cameraGroup = G_NewString(camG);
+}
+
+extern camera_t	client_camera;
+/*
+============
+Q3_CameraGroupZOfs
+
+?
+============
+*/
+static void Q3_CameraGroupZOfs( float camGZOfs )
+{
+	client_camera.cameraGroupZOfs = camGZOfs;
+}
+/*
+============
+Q3_CameraGroup
+
+?
+============
+*/
+static void Q3_CameraGroupTag( char *camGTag )
+{
+	Q_strncpyz( client_camera.cameraGroupTag, camGTag, sizeof(client_camera.cameraGroupTag) );
+}
+
+/*
+============
+Q3_RemoveRHandModel
+============
+*/
+static void Q3_RemoveRHandModel( int entID, char *addModel)
+{
+	gentity_t	*ent  = &g_entities[entID];
+
+	if ( ent->cinematicModel >= 0 )
+	{
+		gi.G2API_RemoveGhoul2Model(ent->ghoul2,ent->cinematicModel);
+	}
+}
+
+/*
+============
+Q3_AddRHandModel
+============
+*/
+static void Q3_AddRHandModel( int entID, char *addModel)
+{
+	gentity_t	*ent  = &g_entities[entID];
+
+	ent->cinematicModel = gi.G2API_InitGhoul2Model(ent->ghoul2, addModel, G_ModelIndex( addModel ));
+	if ( ent->cinematicModel != -1 )
+	{
+		// attach it to the hand
+		gi.G2API_AttachG2Model(&ent->ghoul2[ent->cinematicModel], &ent->ghoul2[ent->playerModel], 
+					ent->handRBolt, ent->playerModel);
+	}
+}
+
+/*
+============
+Q3_AddLHandModel
+============
+*/
+static void Q3_AddLHandModel( int entID, char *addModel)
+{
+	gentity_t	*ent  = &g_entities[entID];
+
+	ent->cinematicModel = gi.G2API_InitGhoul2Model(ent->ghoul2, addModel, G_ModelIndex( addModel ));
+	if ( ent->cinematicModel != -1 )
+	{
+		// attach it to the hand
+		gi.G2API_AttachG2Model(&ent->ghoul2[ent->cinematicModel], &ent->ghoul2[ent->playerModel], 
+					ent->handLBolt, ent->playerModel);
+	}
+}
+
+/*
+============
+Q3_RemoveLHandModel
+============
+*/
+static void Q3_RemoveLHandModel( int entID, char *addModel)
+{
+	gentity_t	*ent  = &g_entities[entID];
+
+	if ( ent->cinematicModel >= 0 )
+	{
+		gi.G2API_RemoveGhoul2Model(ent->ghoul2, ent->cinematicModel);
+	}
+}
+
+/*
+============
+Q3_LookTarget
+
+?
+============
+*/
+static void Q3_LookTarget( int entID, char *targetName)
+{
+	gentity_t	*ent  = &g_entities[entID];
+
+	if ( !ent )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_LookTarget: invalid entID %d\n", entID);
+		return;
+	}
+
+	if ( !ent->client )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "Q3_LookTarget: '%s' is not an NPC/player!\n", ent->targetname );
+		return;
+	}
+
+	if(Q_stricmp("none", targetName) == 0 || Q_stricmp("NULL", targetName) == 0)
+	{//clearing look target
+		NPC_ClearLookTarget( ent );
+		return;
+	}
+
+	gentity_t	*targ  = G_Find(NULL, FOFS(targetname), targetName);
+	if(!targ)
+	{
+		targ  = G_Find(NULL, FOFS(script_targetname), targetName);
+		if (!targ)
+		{
+			targ  = G_Find(NULL, FOFS(NPC_targetname), targetName);
+			if (!targ)
+			{
+				Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "Q3_LookTarget: Can't find ent %s\n", targetName );
+				return;
+			}
+		}
+	}
+
+	NPC_SetLookTarget( ent, targ->s.number, 0 );
+}
+
+/*
+============
+Q3_Face
+
+?
+============
+*/
+static void Q3_Face( int entID,int expression, float holdtime)
+{
+	gentity_t	*ent  = &g_entities[entID];
+
+	if ( !ent )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_Face: invalid entID %d\n", entID);
+		return;
+	}
+
+	if ( !ent->client )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "Q3_Face: '%s' is not an NPC/player!\n", ent->targetname );
+		return;
+	}
+	
+	//FIXME: change to milliseconds to be consistant!
+	holdtime *= 1000;
+
+	switch(expression)
+	{
+	case SET_FACEEYESCLOSED:
+		ent->client->facial_blink = 1;
+		break;
+	case SET_FACEEYESOPENED:
+		ent->client->facial_blink = -1;
+		break;
+	case SET_FACEBLINK:
+		ent->client->facial_timer = -(level.time + holdtime);
+		break;
+	case SET_FACEAUX:
+		ent->client->facial_timer = -(level.time + holdtime);
+		ent->client->facial_anim = FACE_ALERT;
+		break;
+	case SET_FACEBLINKFROWN:
+		ent->client->facial_blink = -(level.time + holdtime);
+//fall through
+	case SET_FACEFROWN:
+		ent->client->facial_timer = -(level.time + holdtime);
+		ent->client->facial_anim = FACE_FROWN;
+		break;
+
+	case SET_FACENORMAL:
+		ent->client->facial_timer = level.time + Q_flrand(6000.0, 10000.0);
+		ent->client->facial_blink = level.time + Q_flrand(3000.0, 5000.0);
+		break;
+	}
+
+}
+
+
+/*
+============
+Q3_SetPlayerUsable
+  Description	: 
+  Return type	: void 
+  Argument		:  int entID
+  Argument		: qboolean usable
+============
+*/
+static void Q3_SetPlayerUsable( int entID, qboolean usable )
+{
+	gentity_t	*ent  = &g_entities[entID];
+
+	if ( !ent )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetPlayerUsable: invalid entID %d\n", entID);
+		return;
+	}
+
+	if(usable)
+	{
+		ent->svFlags |= SVF_PLAYER_USABLE;
+	}
+	else
+	{
+		ent->svFlags &= ~SVF_PLAYER_USABLE;
+	}
+}
+
+/*
+============
+Q3_SetDisableShaderAnims
+  Description	: 
+  Return type	: static void 
+  Argument		:  int entID
+  Argument		: int disabled
+============
+*/
+static void Q3_SetDisableShaderAnims( int entID, int disabled )
+{
+	gentity_t *ent = &g_entities[entID];
+
+	if ( !ent )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetDisableShaderAnims: invalid entID %d\n", entID);
+		return;
+	}
+
+	if ( disabled )
+	{
+		ent->s.eFlags |= EF_DISABLE_SHADER_ANIM;
+	}
+	else
+	{
+		ent->s.eFlags &= ~EF_DISABLE_SHADER_ANIM;
+	}
+}
+
+/*
+============
+Q3_SetShaderAnim
+  Description	: 
+  Return type	: static void 
+  Argument		:  int entID
+  Argument		: int disabled
+============
+*/
+static void Q3_SetShaderAnim( int entID, int disabled )
+{
+	gentity_t *ent = &g_entities[entID];
+
+	if ( !ent )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetShaderAnim: invalid entID %d\n", entID);
+		return;
+	}
+
+	if ( disabled )
+	{
+		ent->s.eFlags |= EF_SHADER_ANIM;
+	}
+	else
+	{
+		ent->s.eFlags &= ~EF_SHADER_ANIM;
+	}
+}
+
+void Q3_SetBroadcast( int entID, qboolean broadcast )
+{
+	gentity_t *ent = &g_entities[entID];
+	if ( broadcast )
+	{
+		ent->svFlags |= SVF_BROADCAST;
+	}
+	else
+	{
+		ent->svFlags &= ~SVF_BROADCAST;
+	}
+}
+
+void Q3_SetForcePower( int entID, int forcePower, qboolean powerOn )
+{
+	gentity_t *ent = &g_entities[entID];
+	if ( !ent )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetForcePower: invalid entID %d\n", entID);
+		return;
+	}
+	if ( !ent->client )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetForcePower: ent # %d not a client!\n", entID );
+		return;
+	}
+	if ( powerOn )
+	{
+		ent->client->ps.forcePowersForced |= (1<<forcePower);
+	}
+	else
+	{
+		ent->client->ps.forcePowersForced &= ~(1<<forcePower);
+	}
+}
+
+/*
+============
+Q3_SetStartFrame
+  Description	: 
+  Return type	: static void 
+  Argument		:  int entID
+  Argument		: int startFrame
+============
+*/
+static void Q3_SetStartFrame( int entID, int startFrame )
+{
+	gentity_t	*ent  = &g_entities[entID];
+
+	if ( !ent )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetStartFrame: invalid entID %d\n", entID);
+		return;
+	}
+
+	if ( ent->client )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetLoopAnim: command not valid on players/NPCs!\n" );
+		return;
+	}
+
+	if ( startFrame >= 0 )
+	{
+		ent->s.frame = startFrame;
+		ent->startFrame = startFrame;
+	}
+}
+
+
+/*
+============
+Q3_SetEndFrame
+  Description	: 
+  Return type	: static void 
+  Argument		:  int entID
+  Argument		: int endFrame
+============
+*/
+static void Q3_SetEndFrame( int entID, int endFrame )
+{
+	gentity_t	*ent  = &g_entities[entID];
+
+	if ( !ent )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetEndFrame: invalid entID %d\n", entID);
+		return;
+	}
+
+	if ( ent->client )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetEndFrame: command not valid on players/NPCs!\n" );
+		return;
+	}
+
+	if ( endFrame >= 0 )
+	{
+		ent->endFrame = endFrame;
+	}
+}
+
+/*
+============
+Q3_SetAnimFrame
+  Description	: 
+  Return type	: static void 
+  Argument		:  int entID
+  Argument		: int startFrame
+============
+*/
+static void Q3_SetAnimFrame( int entID, int animFrame )
+{
+	gentity_t	*ent  = &g_entities[entID];
+
+	if ( !ent )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetAnimFrame: invalid entID %d\n", entID);
+		return;
+	}
+
+	if ( ent->client )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetAnimFrame: command not valid on players/NPCs!\n" );
+		return;
+	}
+
+	if ( animFrame >= ent->endFrame )
+	{
+		ent->s.frame = ent->endFrame;
+	}
+	else if ( animFrame >= ent->startFrame )
+	{
+		ent->s.frame = animFrame;
+	}
+	else
+	{
+		// FIXME/NOTE: Set s.frame anyway??
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetAnimFrame: value must be valid number between StartFrame and EndFrame.\n" );
+		return;
+	}
+}
+
+void InflateOwner( gentity_t *self )
+{
+	self->nextthink = level.time + FRAMETIME;
+	self->e_ThinkFunc = thinkF_G_FreeEntity;
+
+	if ( !self->owner || !self->owner->inuse )
+	{
+		return;
+	}
+
+	trace_t	trace;
+
+	gi.trace( &trace, self->currentOrigin, self->mins, self->maxs, self->currentOrigin, self->owner->s.number, self->owner->clipmask&~(CONTENTS_SOLID|CONTENTS_MONSTERCLIP) );
+	if ( trace.allsolid || trace.startsolid )
+	{
+		self->e_ThinkFunc = thinkF_InflateOwner;
+		return;
+	}
+
+	if ( Q3_TaskIDPending( self->owner, TID_RESIZE ) )
+	{
+		Q3_TaskIDComplete( self->owner, TID_RESIZE );
+
+		VectorCopy( self->mins, self->owner->mins );
+		VectorCopy( self->maxs, self->owner->maxs );
+		gi.linkentity( self->owner );
+	}
+}
+
+
+/*
+============
+Q3_SetLoopAnim
+  Description	: 
+  Return type	: void 
+  Argument		:  int entID
+  Argument		: qboolean loopAnim
+============
+*/
+static void Q3_SetLoopAnim( int entID, qboolean loopAnim )
+{
+	gentity_t	*ent  = &g_entities[entID];
+
+	if ( !ent )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetLoopAnim: invalid entID %d\n", entID);
+		return;
+	}
+
+	if ( ent->client )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetLoopAnim: command not valid on players/NPCs!\n" );
+		return;
+	}
+
+	ent->loopAnim = loopAnim;
+}
+
+
+/*
+============
+Q3_SetShields
+  Description	: 
+  Return type	: void 
+  Argument		:  int entID
+  Argument		: qboolean shields
+============
+*/
+static void Q3_SetShields( int entID, qboolean shields )
+{
+	gentity_t	*ent  = &g_entities[entID];
+
+	if ( !ent )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetShields: invalid entID %d\n", entID);
+		return;
+	}
+
+	if ( !ent->NPC )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "Q3_SetShields: '%s' is not an NPC!\n", ent->targetname );
+		return;
+	}
+
+	if ( shields )
+	{
+		ent->NPC->aiFlags |= NPCAI_SHIELDS;
+	}
+	else
+	{
+		ent->NPC->aiFlags &= ~NPCAI_SHIELDS;
+	}
+}
+
+/*
+============
+Q3_SetSaberActive
+  Description	: 
+  Return type	: void 
+  Argument		:  int entID
+  Argument		: qboolean shields
+============
+*/
+static void Q3_SetSaberActive( int entID, qboolean active )
+{
+	gentity_t	*ent  = &g_entities[entID];
+
+	if ( !ent )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetSaberActive: invalid entID %d\n", entID);
+		return;
+	}
+
+	if ( !ent->client )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "Q3_SetSaberActive: '%s' is not an player/NPC!\n", ent->targetname );
+		return;
+	}
+
+	if ( ent->client->ps.weapon != WP_SABER )
+	{
+		if ( (ent->client->ps.stats[STAT_WEAPONS]&(1<<WP_SABER)) )
+		{//change to it right now
+			if ( ent->NPC )
+			{
+				ChangeWeapon( ent, WP_SABER );
+			}
+			else
+			{
+				gitem_t *item = FindItemForWeapon( WP_SABER );
+				RegisterItem( item );	//make sure the weapon is cached in case this runs at startup
+				G_AddEvent( ent, EV_ITEM_PICKUP, (item - bg_itemlist) );
+				CG_ChangeWeapon( WP_SABER );
+			}
+			ent->client->ps.weapon = WP_SABER;
+			ent->client->ps.weaponstate = WEAPON_READY;
+			G_AddEvent( ent, EV_GENERAL_SOUND, G_SoundIndex( "sound/weapons/change.wav" ));
+		}
+		else
+		{
+			Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "Q3_SetSaberActive: '%s' is not using a saber!\n", ent->targetname );
+			return;
+		}
+	}
+	
+	if ( active )
+	{
+		ent->client->ps.SaberActivate();
+	}
+	else
+	{
+		ent->client->ps.SaberDeactivate();
+	}
+}
+
+/*
+============
+	Name: Q3_SetSaberBladeActive
+	Description: Make a specific blade of a specific Saber active or inactive.
+	Created: 10/02/02 by Aurelio Reis, Modified: 10/02/02 by Aurelio Reis
+	[in]	int entID		The ID of the Entity to modify.
+	[in]	int iSaber		Which Saber to modify.
+	[in]	int iBlade		Which blade to modify (0 - (NUM_BLADES - 1)).
+	[in]	bool bActive	Whether to make it active (default true) or inactive (false).
+	[return]	void
+============
+*/
+static void Q3_SetSaberBladeActive( int entID, int iSaber, int iBlade, qboolean bActive = qtrue )
+{
+	gentity_t	*ent  = &g_entities[entID];
+
+	if ( !ent )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetSaberBladeActive: invalid entID %d\n", entID);
+		return;
+	}
+
+	if ( !ent->client )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "Q3_SetSaberBladeActive: '%s' is not an player/NPC!\n", ent->targetname );
+		return;
+	}
+
+	if ( ent->client->ps.weapon != WP_SABER )
+	{
+		if ( (ent->client->ps.stats[STAT_WEAPONS]&(1<<WP_SABER)) )
+		{//change to it right now
+			if ( ent->NPC )
+			{
+				ChangeWeapon( ent, WP_SABER );
+			}
+			else
+			{
+				gitem_t *item = FindItemForWeapon( WP_SABER );
+				RegisterItem( item );	//make sure the weapon is cached in case this runs at startup
+				G_AddEvent( ent, EV_ITEM_PICKUP, (item - bg_itemlist) );
+				CG_ChangeWeapon( WP_SABER );
+			}
+			ent->client->ps.weapon = WP_SABER;
+			ent->client->ps.weaponstate = WEAPON_READY;
+			G_AddEvent( ent, EV_GENERAL_SOUND, G_SoundIndex( "sound/weapons/change.wav" ));
+		}
+		else
+		{
+			Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "Q3_SetSaberBladeActive: '%s' is not using a saber!\n", ent->targetname );
+			return;
+		}
+	}
+
+	// Activate the Blade.
+	ent->client->ps.SaberBladeActivate( iSaber, iBlade, bActive );
+}
+
+/*
+============
+Q3_SetNoKnockback
+  Description	: 
+  Return type	: void 
+  Argument		:  int entID
+  Argument		: qboolean noKnockback
+============
+*/
+static void Q3_SetNoKnockback( int entID, qboolean noKnockback )
+{
+	gentity_t	*ent  = &g_entities[entID];
+
+	if ( !ent )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetNoKnockback: invalid entID %d\n", entID);
+		return;
+	}
+
+	if ( noKnockback )
+	{
+		ent->flags |= FL_NO_KNOCKBACK;
+	}
+	else
+	{
+		ent->flags &= ~FL_NO_KNOCKBACK;
+	}
+}
+
+/*
+============
+Q3_SetCleanDamagingEnts
+  Description	: 
+  Return type	: void 
+============
+*/
+static void Q3_SetCleanDamagingEnts( void )
+{
+	gentity_t *ent = NULL;
+
+	for ( int i = 0; i < ENTITYNUM_WORLD; i++ )
+	{
+		if ( !PInUse( i ))
+		{
+			continue;
+		}
+
+		ent = &g_entities[i];
+
+		if ( ent )
+		{
+			if ( !ent->client && ( ent->s.weapon == WP_DET_PACK || ent->s.weapon == WP_TRIP_MINE || ent->s.weapon == WP_THERMAL ))
+			{
+				// check for a client, otherwise we could remove someone holding this weapon
+				G_FreeEntity( ent );
+			}
+			else if ( ent->s.weapon == WP_TURRET && ent->activator && ent->activator->s.number == 0 && !Q_stricmp( "PAS", ent->classname ))
+			{
+				// is a player owner personal assault sentry gun.
+				G_FreeEntity( ent );
+			}
+			else if ( ent->client && ent->client->NPC_class == CLASS_SEEKER )
+			{
+				// they blow up when they run out of ammo, so this may as well just do the same.
+				G_Damage( ent, ent, ent, NULL, NULL, 999, 0, MOD_UNKNOWN );
+			}
+		}
+	}
+}
+
+
+/*
+============
+Q3_SetInterface
+  Description	: 
+  Return type	: void 
+  Argument		:  int entID
+  Argument		: const char *data
+============
+*/
+static void Q3_SetInterface( int entID, const char *data )
+{
+	gi.cvar_set("cg_drawStatus", data);
+}
+
+/*
+============
+Q3_SetLocation
+  Description	: 
+  Return type	: qboolean 
+  Argument		:  int entID
+  Argument		: const char *location
+============
+*/
+static qboolean Q3_SetLocation( int entID, const char *location )
+{
+	gentity_t	*ent = &g_entities[entID];
+	char		*currentLoc;
+	
+	if ( !ent )
+	{
+		return qtrue;
+	}
+
+	currentLoc = G_GetLocationForEnt( ent );
+	if ( currentLoc && currentLoc[0] && Q_stricmp( location, currentLoc ) == 0 )
+	{
+		return qtrue;
+	}
+
+	ent->message = G_NewString( location );
+	return qfalse;
+}
+
+/*
+============
+Q3_SetPlayerLocked
+  Description	: 
+  Return type	: void 
+  Argument		:  int entID
+  Argument		: qboolean locked
+============
+*/
+qboolean	player_locked = qfalse;
+static void Q3_SetPlayerLocked( int entID, qboolean locked )
+{
+	gentity_t	*ent = &g_entities[0];
+
+	player_locked = locked;
+	if ( ent && ent->client )
+	{//stop him too
+		VectorClear(ent->client->ps.velocity);
+	}
+}
+
+/*
+============
+Q3_SetLockPlayerWeapons
+  Description	: 
+  Return type	: void 
+  Argument		:  int entID
+  Argument		: qboolean locked
+============
+*/
+static void Q3_SetLockPlayerWeapons( int entID, qboolean locked )
+{
+	gentity_t	*ent = &g_entities[0];
+
+	ent->flags &= ~FL_LOCK_PLAYER_WEAPONS;
+
+	if( locked )
+	{
+		ent->flags |= FL_LOCK_PLAYER_WEAPONS;
+	}
+	
+}
+
+
+/*
+============
+Q3_SetNoImpactDamage
+  Description	: 
+  Return type	: void 
+  Argument		:  int entID
+  Argument		: qboolean locked
+============
+*/
+static void Q3_SetNoImpactDamage( int entID, qboolean noImp )
+{
+	gentity_t	*ent  = &g_entities[entID];
+
+	if ( !ent )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_SetNoImpactDamage: invalid entID %d\n", entID);
+		return;
+	}
+
+	ent->flags &= ~FL_NO_IMPACT_DMG;
+
+	if( noImp )
+	{
+		ent->flags |= FL_NO_IMPACT_DMG;
+	}
+	
+}
+
+extern void CG_CameraAutoAim( const char *name );
+extern void CG_CameraAutoTrack( const char *name );
+
+/*
+============
+Q3_SetVar
+  Description	: 
+  Return type	: static void 
+  Argument		:  int taskID
+  Argument		: int entID
+  Argument		: const char *type_name
+  Argument		: const char *data
+============
+*/
+/*void SetVar( int taskID, int entID, const char *type_name, const char *data )
+{
+	int	vret = Q3_VariableDeclared( type_name ) ;
+	float	float_data;
+	float	val = 0.0f;
+
+	
+	if ( vret != VTYPE_NONE )
+	{
+		switch ( vret )
+		{
+		case VTYPE_FLOAT:
+			//Check to see if increment command
+			if ( (val = Q3_CheckStringCounterIncrement( data )) )
+			{
+				Q3_GetFloatVariable( type_name, &float_data );
+				float_data += val;
+			}
+			else
+			{
+				float_data = atof((char *) data);
+			}
+			Q3_SetFloatVariable( type_name, float_data );
+			break;
+
+		case VTYPE_STRING:
+			Q3_SetStringVariable( type_name, data );
+			break;
+
+		case VTYPE_VECTOR:
+			Q3_SetVectorVariable( type_name, (char *) data );
+			break;
+		}
+
+		return;
+	}
+
+	Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "%s variable or field not found!\n", type_name );
+}*/
+
+/*
+============
+Q3_RemoveEnt
+  Description	: 
+  Return type	: void 
+  Argument		: gentity_t *victim
+============
+*/
+static void Q3_RemoveEnt( gentity_t *victim )
+{
+	if (!victim || !victim->inuse)
+	{
+		return;
+	}
+
+	if( victim->client )
+	{
+		if ( victim->client->NPC_class == CLASS_VEHICLE )
+		{//eject everyone out of a vehicle that's about to remove itself
+			Vehicle_t *pVeh = victim->m_pVehicle;
+			if ( pVeh && pVeh->m_pVehicleInfo )
+			{
+				pVeh->m_pVehicleInfo->EjectAll( pVeh );
+			}
+		}
+		//ClientDisconnect(ent);
+		victim->s.eFlags |= EF_NODRAW;
+		victim->svFlags &= ~SVF_NPC;
+		victim->s.eType = ET_INVISIBLE;
+		victim->contents = 0;
+		victim->health = 0;
+		victim->targetname = NULL;
+
+		if ( victim->NPC && victim->NPC->tempGoal != NULL )
+		{
+			G_FreeEntity( victim->NPC->tempGoal );
+			victim->NPC->tempGoal = NULL;
+		}
+		if ( victim->client->ps.saberEntityNum != ENTITYNUM_NONE && victim->client->ps.saberEntityNum > 0 )
+		{
+			if ( g_entities[victim->client->ps.saberEntityNum].inuse )
+			{
+				G_FreeEntity( &g_entities[victim->client->ps.saberEntityNum] );
+			}
+			victim->client->ps.saberEntityNum = ENTITYNUM_NONE;
+		}
+		//Disappear in half a second
+		victim->e_ThinkFunc = thinkF_G_FreeEntity;
+		victim->nextthink = level.time + 500;
+		return;
+	}
+	else
+	{
+		victim->e_ThinkFunc = thinkF_G_FreeEntity;
+		victim->nextthink = level.time + 100;
+	}
+}
+
+/*
+============
+MakeOwnerInvis
+  Description	: 
+  Return type	: void 
+  Argument		: gentity_t *self
+============
+*/
+void MakeOwnerInvis(gentity_t *self)
+{
+	if(self->owner && self->owner->client)
+	{
+		self->owner->client->ps.powerups[PW_CLOAKED] = level.time + 500;
+	}
+
+	//HACKHGACLHACK!! - MCG
+	self->e_ThinkFunc = thinkF_RemoveOwner;
+	self->nextthink = level.time + 400;
+}
+
+
+/*
+============
+MakeOwnerEnergy
+  Description	: 
+  Return type	: void 
+  Argument		: gentity_t *self
+============
+*/
+void MakeOwnerEnergy(gentity_t *self)
+{
+	if(self->owner && self->owner->client)
+	{
+//		self->owner->client->ps.powerups[PW_QUAD] = level.time + 1000;
+	}
+
+	G_FreeEntity(self);
+}
+
+// NOTE! RemoveOwner() is a function used within the entity (a pointer to the function is
+// contained). This leads to a "funny" predicament: why is RemoveOwner() here???
+// NOTE NOTE! This is also true of Q3_Remove, which should be eliminated as soon as possible.
+/*
+============
+Q3_Remove
+  Description	: 
+  Return type	: void 
+  Argument		:  int entID
+  Argument		: const char *name
+============
+*/
+static void Q3_Remove( int entID, const char *name )
+{
+	gentity_t *ent = &g_entities[entID];
+	gentity_t	*victim = NULL;
+
+	if( !Q_stricmp( "self", name ) )
+	{
+		victim = ent;
+		if ( !victim )
+		{
+			Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_Remove: can't find %s\n", name );
+			return;
+		}
+		Q3_RemoveEnt( victim );
+	}
+	else if( !Q_stricmp( "enemy", name ) )
+	{
+		victim = ent->enemy;
+		if ( !victim )
+		{
+			Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_Remove: can't find %s\n", name );
+			return;
+		}
+		Q3_RemoveEnt( victim );
+	}
+	else
+	{
+		victim = G_Find( NULL, FOFS(targetname), (char *) name );
+		if ( !victim )
+		{
+			Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_Remove: can't find %s\n", name );
+			return;
+		}
+
+		while ( victim )
+		{
+			Q3_RemoveEnt( victim );
+			victim = G_Find( victim, FOFS(targetname), (char *) name );
+		}
+	}
+}
+
+/*
+============
+RemoveOwner
+  Description	: 
+  Return type	: void 
+  Argument		: gentity_t *self
+============
+*/
+void RemoveOwner (gentity_t *self)
+{
+	if ( self->owner && self->owner->inuse )
+	{//I have an owner and they heavn't been freed yet
+		Q3_Remove( self->owner->s.number, "self" );
+	}
+
+	G_FreeEntity( self );
+}
+
+void Q3_DismemberLimb( int entID, char *hitLocName )
+{
+	gentity_t	*self  = &g_entities[entID];
+	int		hitLoc = GetIDForString( HLTable, hitLocName );
+	vec3_t	point;
+
+	if ( !self )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_WARNING, "Q3_DismemberLimb: invalid entID %d\n", entID);
+		return;
+	}
+
+	if ( !self->client )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "Q3_DismemberLimb: '%s' is not a player/NPC!\n", self->targetname );
+		return;
+	}
+
+	if ( !self->ghoul2.size() )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "Q3_DismemberLimb: '%s' is not a ghoul model!\n", self->targetname );
+		return;
+	}
+
+	if ( hitLoc <= HL_NONE || hitLoc >= HL_MAX )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "Q3_DismemberLimb: '%s' is not a valid hit location!\n", hitLocName );
+		return;
+	}
+
+	switch ( hitLoc )
+	{
+	case HL_FOOT_RT:
+		VectorCopy( self->client->renderInfo.footRPoint, point );
+		break;
+	case HL_FOOT_LT:
+		VectorCopy( self->client->renderInfo.footLPoint, point );
+		break;
+	case HL_LEG_RT:
+		G_GetBoltPosition( self, self->kneeRBolt, point );
+		break;
+	case HL_LEG_LT:
+		G_GetBoltPosition( self, self->kneeLBolt, point );
+		break;
+	case HL_ARM_RT:
+	case HL_CHEST_RT:
+	case HL_BACK_LT:
+		G_GetBoltPosition( self, self->elbowRBolt, point );
+		break;
+	case HL_ARM_LT:
+	case HL_CHEST_LT:
+	case HL_BACK_RT:
+		G_GetBoltPosition( self, self->elbowLBolt, point );
+		break;
+	case HL_WAIST:
+	case HL_BACK:
+	case HL_CHEST:
+		VectorCopy( self->client->renderInfo.torsoPoint, point );
+		break;
+	case HL_HAND_RT:
+		VectorCopy( self->client->renderInfo.handRPoint, point );
+		break;
+	case HL_HAND_LT:
+		VectorCopy( self->client->renderInfo.handLPoint, point );
+		break;
+	case HL_HEAD:
+		VectorCopy( self->client->renderInfo.headPoint, point );
+		break;
+	case HL_GENERIC1:
+	case HL_GENERIC2:
+	case HL_GENERIC3:
+	case HL_GENERIC4:
+	case HL_GENERIC5:
+	case HL_GENERIC6:
+		VectorCopy( self->currentOrigin, point );
+		break;
+	}
+	G_DoDismemberment( self, point, MOD_SABER, 1000, hitLoc, qtrue );
+}
+/*
+-------------------------
+VariableDeclared
+-------------------------
+*/
+int CQuake3GameInterface::VariableDeclared( const char *name )
+{
+	//Check the strings
+	varString_m::iterator	vsi = m_varStrings.find( name );
+
+	if ( vsi != m_varStrings.end() )
+		return VTYPE_STRING;
+
+	//Check the floats
+	varFloat_m::iterator	vfi = m_varFloats.find( name );
+
+	if ( vfi != m_varFloats.end() )
+		return VTYPE_FLOAT;
+
+	//Check the vectors
+	varString_m::iterator	vvi = m_varVectors.find( name );
+
+	if ( vvi != m_varVectors.end() )
+		return VTYPE_VECTOR;
+
+	return VTYPE_NONE;
+}
+
+/*
+-------------------------
+SetVar
+-------------------------
+*/
+
+void CQuake3GameInterface::SetVar( int taskID, int entID, const char *type_name, const char *data )
+{
+	int	vret = VariableDeclared( type_name ) ;
+	float	float_data;
+	float	val = 0.0f;
+	
+	int favre=0;
+	if( Q_stricmp( type_name, "path_enemies_dead" )==0 )
+	{
+		favre=4;
+	}
+
+	if( Q_stricmp( type_name, "path_door_open" )==0 )
+	{
+		favre = 4;
+	}
+	
+	if ( vret != VTYPE_NONE )
+	{
+		switch ( vret )
+		{
+		case VTYPE_FLOAT:
+			//Check to see if increment command
+			if ( (val = Q3_CheckStringCounterIncrement( data )) )
+			{
+				GetFloatVariable( type_name, &float_data );
+				float_data += val;
+			}
+			else
+			{
+				float_data = atof((char *) data);
+			}
+			SetFloatVariable( type_name, float_data );
+			break;
+
+		case VTYPE_STRING:
+			SetStringVariable( type_name, data );
+			break;
+
+		case VTYPE_VECTOR:
+			SetVectorVariable( type_name, (char *) data );
+			break;
+		}
+
+		return;
+	}
+
+	DebugPrint( WL_ERROR, "%s variable or field not found!\n", type_name );
+}
+
+/*
+-------------------------
+GetFloatVariable
+-------------------------
+*/
+
+int CQuake3GameInterface::GetFloatVariable( const char *name, float *value )
+{
+	//Check the floats
+	varFloat_m::iterator	vfi = m_varFloats.find( name );
+
+	if ( vfi != m_varFloats.end() )
+	{
+		*value = (*vfi).second;
+		return true;
+	}
+
+	return false;
+}
+
+/*
+-------------------------
+GetStringVariable
+-------------------------
+*/
+
+int CQuake3GameInterface::GetStringVariable( const char *name, const char **value )
+{
+	//Check the strings
+	varString_m::iterator	vsi = m_varStrings.find( name );
+
+	if ( vsi != m_varStrings.end() )
+	{
+		*value = (const char *) ((*vsi).second).c_str();
+		return true;
+	}
+
+	return false;
+}
+
+/*
+-------------------------
+GetVectorVariable
+-------------------------
+*/
+
+int CQuake3GameInterface::GetVectorVariable( const char *name, vec3_t value )
+{
+	//Check the strings
+	varString_m::iterator	vvi = m_varVectors.find( name );
+
+	if ( vvi != m_varVectors.end() )
+	{
+		const char *str = ((*vvi).second).c_str();
+
+		sscanf( str, "%f %f %f", &value[0], &value[1], &value[2] );
+		return true;
+	}
+
+	return false;
+}
+
+/*
+-------------------------
+InitVariables
+-------------------------
+*/
+
+void CQuake3GameInterface::InitVariables( void )
+{
+	m_varStrings.clear();
+	m_varFloats.clear();
+	m_varVectors.clear();
+
+	if ( m_numVariables > 0 )
+		DebugPrint( WL_WARNING, "%d residual variables found!\n", m_numVariables );
+
+	m_numVariables = 0;
+}
+
+/*
+-------------------------
+SetVariable_Float
+-------------------------
+*/
+
+int CQuake3GameInterface::SetFloatVariable( const char *name, float value )
+{
+	//Check the floats
+	varFloat_m::iterator	vfi = m_varFloats.find( name );
+
+	if ( vfi == m_varFloats.end() )
+		return VTYPE_FLOAT;
+
+	(*vfi).second = value;
+	
+	return true;
+}
+
+/*
+-------------------------
+SetVariable_String
+-------------------------
+*/
+
+int CQuake3GameInterface::SetStringVariable( const char *name, const char *value )
+{
+	//Check the strings
+	varString_m::iterator	vsi = m_varStrings.find( name );
+
+	if ( vsi == m_varStrings.end() )
+		return false;
+
+	(*vsi).second = value;
+
+	return true;
+}
+
+/*
+-------------------------
+SetVariable_Vector
+-------------------------
+*/
+
+int CQuake3GameInterface::SetVectorVariable( const char *name, const char *value )
+{
+	//Check the strings
+	varString_m::iterator	vvi = m_varVectors.find( name );
+
+	if ( vvi == m_varVectors.end() )
+		return false;
+
+	(*vvi).second = value;
+
+	return true;
+}
+
+/*
+-------------------------
+VariableSaveFloats
+-------------------------
+*/
+
+void CQuake3GameInterface::VariableSaveFloats( varFloat_m &fmap )
+{
+	int numFloats = fmap.size();
+	gi.AppendToSaveGame( 'FVAR', &numFloats, sizeof( numFloats ) );
+
+	varFloat_m::iterator	vfi;
+	STL_ITERATE( vfi, fmap )
+	{
+		//Save out the map id
+		int	idSize = strlen( ((*vfi).first).c_str() );
+		
+		//Save out the real data
+		gi.AppendToSaveGame( 'FIDL', &idSize, sizeof( idSize ) );
+		gi.AppendToSaveGame( 'FIDS', (void *) ((*vfi).first).c_str(), idSize );
+
+		//Save out the float value
+		gi.AppendToSaveGame( 'FVAL', &((*vfi).second), sizeof( float ) );
+	}
+}
+
+/*
+-------------------------
+VariableSaveStrings
+-------------------------
+*/
+
+void CQuake3GameInterface::VariableSaveStrings( varString_m &smap )
+{
+	int numStrings = smap.size();
+	gi.AppendToSaveGame( 'SVAR', &numStrings, sizeof( numStrings ) );
+
+	varString_m::iterator	vsi;
+	STL_ITERATE( vsi, smap )
+	{
+		//Save out the map id
+		int	idSize = strlen( ((*vsi).first).c_str() );
+		
+		//Save out the real data
+		gi.AppendToSaveGame( 'SIDL', &idSize, sizeof( idSize ) );
+		gi.AppendToSaveGame( 'SIDS', (void *) ((*vsi).first).c_str(), idSize );
+
+		//Save out the string value
+		idSize = strlen( ((*vsi).second).c_str() );
+
+		gi.AppendToSaveGame( 'SVSZ', &idSize, sizeof( idSize ) );
+		gi.AppendToSaveGame( 'SVAL', (void *) ((*vsi).second).c_str(), idSize );
+	}
+}
+
+/*
+-------------------------
+VariableSave
+-------------------------
+*/
+
+int CQuake3GameInterface::VariableSave( void )
+{
+	VariableSaveFloats( m_varFloats );
+	VariableSaveStrings( m_varStrings );
+	VariableSaveStrings( m_varVectors);
+
+	return qtrue;
+}
+
+/*
+-------------------------
+VariableLoadFloats
+-------------------------
+*/
+
+void CQuake3GameInterface::VariableLoadFloats( varFloat_m &fmap )
+{
+	int		numFloats;
+	char	tempBuffer[1024];
+
+	gi.ReadFromSaveGame( 'FVAR', &numFloats, sizeof( numFloats ) );
+
+	for ( int i = 0; i < numFloats; i++ )
+	{
+		int idSize;
+		
+		gi.ReadFromSaveGame( 'FIDL', &idSize, sizeof( idSize ) );
+		gi.ReadFromSaveGame( 'FIDS', &tempBuffer, idSize );
+		tempBuffer[ idSize ] = 0;
+
+		float	val;
+
+		gi.ReadFromSaveGame( 'FVAL', &val, sizeof( float ) );
+
+		DeclareVariable( TK_FLOAT, (const char *) &tempBuffer );
+		SetFloatVariable( (const char *) &tempBuffer, val );
+	}
+}
+
+/*
+-------------------------
+VariableLoadStrings
+-------------------------
+*/
+
+void CQuake3GameInterface::VariableLoadStrings( int type, varString_m &fmap )
+{
+	int		numFloats;
+	char	tempBuffer[1024];
+	char	tempBuffer2[1024];
+
+	gi.ReadFromSaveGame( 'SVAR', &numFloats, sizeof( numFloats ) );
+
+	for ( int i = 0; i < numFloats; i++ )
+	{
+		int idSize;
+		
+		gi.ReadFromSaveGame( 'SIDL', &idSize, sizeof( idSize ) );
+		gi.ReadFromSaveGame( 'SIDS', &tempBuffer, idSize );
+		tempBuffer[ idSize ] = 0;
+
+		gi.ReadFromSaveGame( 'SVSZ', &idSize, sizeof( idSize ) );
+		gi.ReadFromSaveGame( 'SVAL', &tempBuffer2, idSize );
+		tempBuffer2[ idSize ] = 0;
+
+		switch ( type )
+		{
+		case TK_STRING:
+			DeclareVariable( TK_STRING, (const char *) &tempBuffer );
+			SetStringVariable( (const char *) &tempBuffer, (const char *) &tempBuffer2 );
+			break;
+
+		case TK_VECTOR:
+			DeclareVariable( TK_VECTOR, (const char *) &tempBuffer );
+			SetVectorVariable( (const char *) &tempBuffer, (const char *) &tempBuffer2 );
+			break;
+		}
+	}
+}
+
+/*
+-------------------------
+VariableLoad
+-------------------------
+*/
+
+int CQuake3GameInterface::VariableLoad( void )
+{
+	InitVariables();
+
+	VariableLoadFloats( m_varFloats );
+
+	VariableLoadStrings( TK_STRING, m_varStrings );
+
+	VariableLoadStrings( TK_VECTOR, m_varVectors);
+
+	return qfalse;
+}
+
+// Static Singleton Instance.
+CQuake3GameInterface *CQuake3GameInterface::m_pInstance = NULL;
+
+// Destructor.
+IGameInterface::~IGameInterface() {}
+
+int IGameInterface::s_IcarusFlavorsNeeded = 1;
+
+// Get this Interface Instance.
+IGameInterface *IGameInterface::GetGame( int flavor )
+{
+	// If no instance exists, create one...
+	if ( !CQuake3GameInterface::m_pInstance )
+	{
+		CQuake3GameInterface::m_pInstance = new CQuake3GameInterface();
+	}
+
+	return CQuake3GameInterface::m_pInstance;
+}
+
+// Destroy the game Instance.
+void IGameInterface::Destroy()
+{
+	if ( CQuake3GameInterface::m_pInstance )
+	{
+		delete CQuake3GameInterface::m_pInstance;
+		CQuake3GameInterface::m_pInstance = NULL;
+	}
+}
+
+// Constructor.
+CQuake3GameInterface::CQuake3GameInterface() : IGameInterface()
+{
+	m_ScriptList.clear();
+	m_EntityList.clear();
+
+	m_numVariables = 0;
+
+	m_entFilter = -1;
+
+	gclient_t* client = &level.clients[0];
+	memset(&client->sess, 0, sizeof(client->sess));
+}
+
+// Destructor.
+CQuake3GameInterface::~CQuake3GameInterface()
+{
+	scriptlist_t::iterator	iterScript;
+	entitylist_t::iterator	iterEntity;
+	gentity_t				*ent = &g_entities[0];
+
+	// Release all entities Icarus resources.
+	for ( int i = 0; i < globals.num_entities; i++, ent++ ) 
+	{
+		if ( !ent->inuse )
+			continue;
+		
+		FreeEntity( ent );
+	}
+
+	// Clear out all precached script's.
+	for ( iterScript = m_ScriptList.begin(); iterScript != m_ScriptList.end(); iterScript++ )
+	{
+		Free( (*iterScript).second->buffer );
+		delete (*iterScript).second;
+	}
+
+	m_ScriptList.clear();
+	m_EntityList.clear();
+}
+
+// Initialize an Entity by ID.
+bool CQuake3GameInterface::InitEntity( gentity_t *pEntity )
+{
+	//Make sure this is a fresh entity.
+	assert( pEntity->m_iIcarusID == IIcarusInterface::ICARUS_INVALID );
+
+	if ( pEntity->m_iIcarusID != IIcarusInterface::ICARUS_INVALID )
+		return false;
+
+	// Get an Icarus ID.
+	pEntity->m_iIcarusID = IIcarusInterface::GetIcarus()->GetIcarusID( pEntity->s.number );
+
+	// Initialize all taskIDs to -1
+	memset( &pEntity->taskID, -1, sizeof( pEntity->taskID ) );
+
+	// Add this entity to a map of valid associated entity's for quick retrieval later.
+	AssociateEntity( pEntity );
+
+	//Precache all the entity's scripts.
+	PrecacheEntity( pEntity );
+
+	return false;
+}
+
+// Free an Entity by ID.
+void CQuake3GameInterface::FreeEntity( gentity_t *pEntity )
+{
+	//Make sure the entity is valid
+	if ( pEntity->m_iIcarusID == IIcarusInterface::ICARUS_INVALID )
+		return;
+
+	// Remove the Entity from the Entity map so that when their g_entity index is reused,
+	// ICARUS doesn't try to affect the new (incorrect) pEntity.
+	if VALIDSTRING( pEntity->script_targetname )
+	{
+		char	temp[1024];
+		
+		strncpy( (char *) temp, pEntity->script_targetname, 1023 );
+		temp[ 1023 ] = 0;
+
+		entitylist_t::iterator it = m_EntityList.find( strupr(temp) );
+
+		if (it != m_EntityList.end())
+		{
+			m_EntityList.erase(it);
+		}
+	}
+
+	// Delete the Icarus ID, but lets not construct icarus to do it
+	if (IIcarusInterface::GetIcarus(0,false))
+	{
+		IIcarusInterface::GetIcarus()->DeleteIcarusID( pEntity->m_iIcarusID );
+	}
+}
+
+// Determines whether or not a Game Element needs ICARUS information.
+bool CQuake3GameInterface::ValidEntity( gentity_t *pEntity )
+{
+	int i;
+
+	// Targeted by a script.
+	if ( pEntity->script_targetname && pEntity->script_targetname[0] )
+		return true;
+
+	// Potentially able to call a script.
+	for ( i = 0; i < NUM_BSETS; i++ )
+	{
+		if VALIDSTRING( pEntity->behaviorSet[i] )
+		{
+			//Com_Printf( "WARNING: Entity %d (%s) has behaviorSet but no script_targetname -- using targetname\n", pEntity->s.number, pEntity->targetname );
+			pEntity->script_targetname = G_NewString(pEntity->targetname);
+			return true;
+		}
+	}
+
+	return false;
+}
+
+// Associate the entity's id and name so that it can be referenced later.
+void CQuake3GameInterface::AssociateEntity( gentity_t *pEntity )
+{
+	char	temp[1024];
+	
+	if ( VALIDSTRING( pEntity->script_targetname ) == false )
+		return;
+
+	strncpy( (char *) temp, pEntity->script_targetname, 1023 );
+	temp[ 1023 ] = 0;
+
+	m_EntityList[ strupr( (char *) temp ) ] = pEntity->s.number;
+}
+
+// Make a valid script name.
+int CQuake3GameInterface::MakeValidScriptName( char **strScriptName )
+{
+	if ( !Q_stricmp( *strScriptName, "NULL" ) || !Q_stricmp( *strScriptName, "default" ) )
+		return 0;
+
+	// ensure "scripts" (Q3_SCRIPT_DIR), which will be missing if this was called recursively...
+	// MAX_FILENAME_LENGTH should really be MAX_QPATH (and 64 bytes instead of 1024), but this fits the rest of the code
+	char sFilename[MAX_FILENAME_LENGTH];	
+
+	if ( !Q_stricmpn( *strScriptName, Q3_SCRIPT_DIR, strlen( Q3_SCRIPT_DIR ) ) )
+	{
+		Q_strncpyz( sFilename, *strScriptName, sizeof( sFilename ) );
+	}
+	else
+	{
+		Q_strncpyz( sFilename, va( "%s/%s", Q3_SCRIPT_DIR, *strScriptName ), sizeof( sFilename ) );
+	}
+
+	return 1;
+}
+	
+// First looks to see if a script has already been loaded, if so, return SCRIPT_ALREADYREGISTERED. If a script has
+// NOT been already cached, that script is loaded and the return is SCRIPT_REGISTERED. If a script could not
+// be found cached and could not be loaded we return SCRIPT_COULDNOTREGISTER.
+int CQuake3GameInterface::RegisterScript( const char *strFileName, void **ppBuf, int &iLength )
+{
+	// If the file name is invalid, leave.
+	if ( !strFileName || strFileName[0] == '\0' || !Q_stricmp( strFileName, "NULL" ) || !Q_stricmp( strFileName, "default" ) )
+		return SCRIPT_COULDNOTREGISTER;
+
+	// Ensure "scripts" (Q3_SCRIPT_DIR), which will be missing if this was called recursively...
+	// MAX_FILENAME_LENGTH should really be MAX_QPATH (and 64 bytes instead of 1024), but this fits the rest of the code
+	char sFilename[MAX_FILENAME_LENGTH];	
+
+	if ( !Q_stricmpn( strFileName, Q3_SCRIPT_DIR, strlen( Q3_SCRIPT_DIR ) ) )
+	{
+		Q_strncpyz( sFilename, strFileName, sizeof( sFilename ) );
+	}
+	else
+	{
+		Q_strncpyz( sFilename, va( "%s/%s", Q3_SCRIPT_DIR, strFileName ), sizeof( sFilename ) );
+	}
+
+	scriptlist_t::iterator	ei;
+	pscript_t	*pscript;
+
+	// Make sure this isn't already cached
+	ei = m_ScriptList.find( strFileName );
+
+	// If we found the script (didn't get to the end of the list), return true.
+	if ( ei != m_ScriptList.end() )
+	{
+		// Send back the script buffer info.
+		(*ppBuf)	= (*ei).second->buffer;
+		iLength		= (*ei).second->length;
+
+		return SCRIPT_ALREADYREGISTERED;
+	}
+
+	// Prepare the name with the extension.
+	char		newname[MAX_FILENAME_LENGTH];
+	sprintf((char *) newname, "%s%s", sFilename, IBI_EXT );	
+
+	qboolean qbIgnoreFileRead = qfalse;
+
+	// NOTENOTE: For the moment I've taken this back out, to avoid doubling the number of fopen()'s per file.
+/*#if 0//#ifndef FINAL_BUILD		
+	// small update here, if called during interrogate, don't let gi.FS_ReadFile() complain because it can't
+	//	find stuff like BS_RUN_AND_SHOOT as scriptname...   During FINALBUILD the message won't appear anyway, hence
+	//	the ifndef, this just cuts down on internal error reports while testing release mode...
+	//
+
+	if (bCalledDuringInterrogate)
+	{
+		fileHandle_t file;
+
+		gi.FS_FOpenFile( newname, &file, FS_READ );
+		
+		if ( file == NULL )
+		{
+			qbIgnoreFileRead = qtrue;	// warn disk code further down not to try FS_ReadFile()
+		}
+		else
+		{
+			gi.FS_FCloseFile( file );
+		}
+	}
+#endif*/
+
+	// Read the Script File into the Buffer.
+	char *pBuf = NULL;
+	iLength = qbIgnoreFileRead ? -1 : gi.FS_ReadFile( newname, (void **) &pBuf );
+
+	if ( iLength <= 0 )
+	{
+		// File not found, but keep quiet during interrogate stage, because of stuff like BS_RUN_AND_SHOOT as scriptname
+		//
+/*		if (!bCalledDuringInterrogate)	
+		{
+			Com_Printf(S_COLOR_RED"Could not open file '%s'\n", newname );
+		}*/
+		return SCRIPT_COULDNOTREGISTER;
+	}
+
+	// Allocate a new pscript (Script Buffer).
+	pscript = new pscript_t;
+
+	// Allocate a buffer of the size we need then mem copy over the buffer.
+	pscript->buffer = (char *)Malloc( iLength );
+	memcpy( pscript->buffer, pBuf, iLength );
+	pscript->length = iLength;
+
+	// We (mem)copied the data over so release the original buffer.
+	gi.FS_FreeFile( pBuf );
+	
+	// Keep track of the buffer still.
+	(*ppBuf) =  pscript->buffer;
+
+	// Add the Script Buffer to the STL map.
+	m_ScriptList[strFileName] = pscript;
+
+	return SCRIPT_REGISTERED;
+}
+
+// Precache all the resources needed by a Script and it's Entity (or vice-versa).
+int CQuake3GameInterface::PrecacheEntity( gentity_t *pEntity )
+{
+	extern stringID_table_t BSTable[];
+	int		i;
+
+	for ( i = 0; i < NUM_BSETS; i++ )
+	{
+		if ( pEntity->behaviorSet[i] == NULL )
+			continue;
+
+		if ( GetIDForString( BSTable, pEntity->behaviorSet[i] ) == -1 )
+		{//not a behavior set
+			char *pBuf = NULL;
+			int iLength = 0;
+
+			// Try to register this script.
+			if ( RegisterScript( pEntity->behaviorSet[i], (void **) &pBuf, iLength ) != SCRIPT_COULDNOTREGISTER )
+			{
+				assert( pBuf );
+				assert( iLength );
+
+				if ( pBuf != NULL && iLength > 0 )
+					// Tell Icarus to precache the script data.
+					IIcarusInterface::GetIcarus()->Precache( pBuf, iLength );
+			}
+			else
+				// otherwise try the next guy, maybe It will work.
+				continue;
+		}
+	}
+
+	return 0;
+}
+
+// Run the script.
+void CQuake3GameInterface::RunScript( const gentity_t *pEntity, const char *strScriptName )
+{
+	char *pBuf = NULL;
+	int iLength = 0;
+
+	switch( RegisterScript( strScriptName, (void **) &pBuf, iLength ) )
+	{
+		// If could not be loaded, leave!
+		case SCRIPT_COULDNOTREGISTER:
+			DebugPrint( WL_WARNING, "RunScript: Script was not found and could not be loaded!!! %s\n", strScriptName);
+			return;
+
+		// We loaded the script and registered it, so run it!
+		case SCRIPT_REGISTERED:
+		case SCRIPT_ALREADYREGISTERED:
+			assert( pBuf );
+			assert( iLength );
+			if ( IIcarusInterface::GetIcarus()->Run( pEntity->m_iIcarusID, pBuf, iLength ) != IIcarusInterface::ICARUS_INVALID )
+				DebugPrint( WL_VERBOSE, "%d Script %s executed by %s %s\n", level.time, (char *) strScriptName, pEntity->classname, pEntity->targetname );
+			return;
+	}
+}
+
+void CQuake3GameInterface::Svcmd( void )
+{
+	char	*cmd = gi.argv( 1 );
+
+	if ( Q_stricmp( cmd, "log" ) == 0 )
+	{
+		g_ICARUSDebug->integer = WL_DEBUG;
+		if ( VALIDSTRING( gi.argv( 2 ) ) )
+		{	
+			gentity_t	*ent = G_Find( NULL, FOFS( script_targetname ), gi.argv(2) );
+
+			if ( ent == NULL )
+			{	
+				Com_Printf( "Entity \"%s\" not found!\n", gi.argv(2) );
+				return;
+			}
+
+			//Start logging
+			Com_Printf("Logging ICARUS info for entity %s\n", gi.argv(2) );
+
+			m_entFilter		= ( ent->s.number == m_entFilter ) ? -1 : ent->s.number;
+		}
+	
+		Com_Printf("Logging ICARUS info for all entities\n");
+	}
+}
+
+// Get the current Game flavor.
+int		CQuake3GameInterface::GetFlavor()
+{
+	return 0;
+}
+
+// Reads in a file and attaches the script directory properly.
+int		CQuake3GameInterface::LoadFile( const char *name, void **buf )
+{
+	int iLength = 0;
+
+	// Register the Script (or retrieve it).
+	RegisterScript( name, buf, iLength );
+
+	return iLength;
+}
+
+// Prints a message in the center of the screen.
+void	CQuake3GameInterface::CenterPrint( const char *format, ... )
+{
+	va_list		argptr;
+	char		text[1024];
+
+	va_start (argptr, format);
+	vsprintf (text, format, argptr);
+	va_end (argptr);
+
+	// FIXME: added '!' so you can print something that's hasn't been precached, '@' searches only for precache text
+	// this is just a TEMPORARY placeholder until objectives are in!!!  -- dmv 11/26/01
+
+	if ((text[0] == '@') || text[0] == '!')	// It's a key
+	{
+		if( text[0] == '!')
+		{
+			gi.SendServerCommand( NULL, "cp \"%s\"", (text+1) );
+			return;
+		}
+
+		gi.SendServerCommand( NULL, "cp \"%s\"", text );
+	}
+
+	DebugPrint( WL_VERBOSE, "%s\n", text); 	// Just a developers note
+}
+
+// Print a debug message.
+void	CQuake3GameInterface::DebugPrint( e_DebugPrintLevel level, const char *format, ... )
+{
+	//Don't print messages they don't want to see
+	if ( g_ICARUSDebug->integer < level )
+		return;
+
+	va_list		argptr;
+	char		text[1024];
+
+	va_start (argptr, format);
+	vsprintf (text, format, argptr);
+	va_end (argptr);
+
+	//Add the color formatting
+	switch ( level )
+	{
+		case WL_ERROR:
+			Com_Printf ( S_COLOR_RED"ERROR: %s", text );
+			break;
+		
+		case WL_WARNING:
+			Com_Printf ( S_COLOR_YELLOW"WARNING: %s", text );
+			break;
+		
+		case WL_DEBUG:
+			{
+				int		entNum;
+				char	*buffer;
+
+				sscanf( text, "%d", &entNum );
+
+				if ( ( m_entFilter >= 0 ) && ( m_entFilter != entNum ) )
+					return;
+
+				buffer = (char *) text;
+				buffer += 5;
+
+				if ( ( entNum < 0 ) || ( entNum > MAX_GENTITIES ) )
+					entNum = 0;
+
+				Com_Printf ( S_COLOR_BLUE"DEBUG: %s(%d): %s\n", g_entities[entNum].script_targetname, entNum, buffer );
+				break;
+			}
+		default:
+		case WL_VERBOSE:
+			Com_Printf ( S_COLOR_GREEN"INFO: %s", text );
+			break;
+	}
+}
+
+//Gets the current time
+unsigned int CQuake3GameInterface::GetTime( void )
+{
+	return level.time;
+}
+
+//	 DWORD	CQuake3GameInterface::GetTimeScale(void ) {}
+
+// NOTE: This extern does not really fit here, fix later please...
+extern void G_SoundBroadcast( gentity_t *ent, int soundIndex );
+// Plays a sound from an entity.
+int 	CQuake3GameInterface::PlaySound( int taskID, int entID, const char *name, const char *channel )
+{
+	gentity_t		*ent = &g_entities[entID];
+	char			finalName[MAX_QPATH];
+	soundChannel_t	voice_chan = CHAN_VOICE; // set a default so the compiler doesn't bitch
+	qboolean		type_voice = qfalse;
+
+	Q_strncpyz( finalName, name, MAX_QPATH, 0 );
+	strlwr(finalName);
+	G_AddSexToPlayerString( finalName, qtrue );
+
+	COM_StripExtension( (const char *)finalName, finalName );
+
+	int soundHandle = G_SoundIndex( (char *) finalName );
+	bool bBroadcast = false;
+
+	if ( ( stricmp( channel, "CHAN_ANNOUNCER" ) == 0 ) || (ent->classname && Q_stricmp("target_scriptrunner", ent->classname ) == 0) ) {
+		bBroadcast = true;
+	}
+
+
+	// moved here from further down so I can easily check channel-type without code dup...
+	//
+	if ( stricmp( channel, "CHAN_VOICE" ) == 0 )
+	{
+		voice_chan = CHAN_VOICE;
+		type_voice = qtrue;
+	}
+	else if ( stricmp( channel, "CHAN_VOICE_ATTEN" ) == 0 )
+	{
+		voice_chan = CHAN_VOICE_ATTEN;
+		type_voice = qtrue;
+	}
+	else if ( stricmp( channel, "CHAN_VOICE_GLOBAL" ) == 0 ) // this should broadcast to everyone, put only casue animation on G_SoundOnEnt...
+	{
+		voice_chan = CHAN_VOICE_GLOBAL;
+		type_voice = qtrue;
+		bBroadcast = true;
+	}
+
+	// if we're in-camera, check for skipping cinematic and ifso, no subtitle print (since screen is not being
+	//	updated anyway during skipping). This stops leftover subtitles being left onscreen after unskipping.
+	//
+	if (!in_camera ||
+		(!g_skippingcin || !g_skippingcin->integer)
+		)	// paranoia towards project end <g>
+	{
+		// Text on
+		// certain NPC's we always want to use subtitles regardless of subtitle setting
+		if (g_subtitles->integer == 1 || (ent->NPC && (ent->NPC->scriptFlags & SCF_USE_SUBTITLES) ) ) // Show all text
+		{
+			if ( in_camera)	// Cinematic
+			{					
+				gi.SendServerCommand( NULL, "ct \"%s\" %i", finalName, soundHandle );
+			}
+			else //if (precacheWav[i].speaker==SP_NONE)	//  lower screen text
+			{
+				gentity_t		*ent2 = &g_entities[0];
+				// the numbers in here were either the original ones Bob entered (350), or one arrived at from checking the distance Chell stands at in stasis2 by the computer core that was submitted as a bug report...
+				//
+				if (bBroadcast || (DistanceSquared(ent->currentOrigin, ent2->currentOrigin) < ((voice_chan == CHAN_VOICE_ATTEN)?(350 * 350):(1200 * 1200)) ) )
+				{
+					gi.SendServerCommand( NULL, "ct \"%s\" %i", finalName, soundHandle );
+				}
+			}
+		}
+		// Cinematic only
+		else if (g_subtitles->integer == 2) // Show only talking head text and CINEMATIC
+		{
+			if ( in_camera)	// Cinematic text
+			{							
+				gi.SendServerCommand( NULL, "ct \"%s\" %i", finalName, soundHandle);
+			}
+		}
+	}
+
+	if ( type_voice )
+	{
+		if ( g_timescale->value > 1.0f )
+		{//Skip the damn sound!
+			return qtrue;
+		}
+		else
+		{
+			//This the voice channel
+			G_SoundOnEnt( ent, voice_chan, ((char *) finalName) );
+		}
+		//Remember we're waiting for this
+		Q3_TaskIDSet( ent, TID_CHAN_VOICE, taskID );
+		//do not task_return complete
+	//	if( voice_chan == CHAN_VOICE_GLOBAL )
+	//	{
+	//		G_SoundBroadcast( ent, soundHandle );
+	//	}
+		return qfalse;
+	}
+
+	if ( bBroadcast )
+	{//Broadcast the sound
+		G_SoundBroadcast( ent, soundHandle );
+	}
+	else
+	{
+		G_Sound( ent, soundHandle );
+	}
+
+	return qtrue;
+}
+
+// Lerps the origin and angles of an entity to the destination values.
+void	CQuake3GameInterface::Lerp2Pos( int taskID, int entID, vec3_t origin, vec3_t angles, float duration )
+{
+	gentity_t	*ent = &g_entities[entID];
+	vec3_t		ang;
+	int			i;
+
+	if(!ent)
+	{
+		DebugPrint( WL_WARNING, "Lerp2Pos: invalid entID %d\n", entID);
+		return;
+	}
+	
+	if ( ent->client || ent->NPC || Q_stricmp(ent->classname, "target_scriptrunner") == 0 )
+	{
+		DebugPrint( WL_ERROR, "Lerp2Pos: ent %d is NOT a mover!\n", entID);
+		return;
+	}
+
+	if ( ent->s.eType != ET_MOVER )
+	{
+		ent->s.eType = ET_MOVER;
+	}
+
+	//Don't allow a zero duration
+	if ( duration == 0 )
+		duration = 1;
+
+	//
+	// Movement
+
+	moverState_t moverState = ent->moverState;
+
+	if ( moverState == MOVER_POS1 || moverState == MOVER_2TO1 )
+	{
+		VectorCopy( ent->currentOrigin, ent->pos1 );
+		VectorCopy( origin, ent->pos2 );
+
+		if ( moverState == MOVER_POS1 )
+		{//open the portal
+			if ( ent->svFlags & SVF_MOVER_ADJ_AREA_PORTALS )
+			{
+				gi.AdjustAreaPortalState( ent, qtrue );
+			}
+		}
+
+		moverState = MOVER_1TO2;
+	}
+	else /*if ( moverState == MOVER_POS2 || moverState == MOVER_1TO2 )*/
+	{
+		VectorCopy( ent->currentOrigin, ent->pos2 );
+		VectorCopy( origin, ent->pos1 );
+
+		moverState = MOVER_2TO1;
+	}
+
+	InitMoverTrData( ent );
+
+	ent->s.pos.trDuration = duration;
+
+	// start it going
+	MatchTeam( ent, moverState, level.time );
+	//SetMoverState( ent, moverState, level.time );
+
+	//Only do the angles if specified
+	if ( angles != NULL )
+	{
+		//
+		// Rotation
+
+		for ( i = 0; i < 3; i++ )
+		{
+			ang[i] = AngleDelta( angles[i], ent->currentAngles[i] );
+			ent->s.apos.trDelta[i] = ( ang[i] / ( duration * 0.001f ) );
+		}
+
+		VectorCopy( ent->currentAngles, ent->s.apos.trBase );
+
+		if ( ent->alt_fire )
+		{
+			ent->s.apos.trType = TR_LINEAR_STOP;
+		}
+		else
+		{
+			ent->s.apos.trType = TR_NONLINEAR_STOP;
+		}
+		ent->s.apos.trDuration = duration;
+
+		ent->s.apos.trTime = level.time;
+
+		ent->e_ReachedFunc = reachedF_moveAndRotateCallback;
+		Q3_TaskIDSet( ent, TID_ANGLE_FACE, taskID );
+	}
+	else
+	{
+		//Setup the last bits of information
+		ent->e_ReachedFunc  = reachedF_moverCallback;
+	}
+
+	if ( ent->damage )
+	{
+		ent->e_BlockedFunc = blockedF_Blocked_Mover;
+	}
+
+	Q3_TaskIDSet( ent, TID_MOVE_NAV, taskID );
+	// starting sound
+	G_PlayDoorLoopSound( ent );
+	G_PlayDoorSound( ent, BMS_START );	//??
+
+	gi.linkentity( ent );
+}
+
+//	 void	CQuake3GameInterface::Lerp2Origin( int taskID, int entID, vec3_t origin, float duration ) {}
+
+// Lerps the angles to the destination value.
+void	CQuake3GameInterface::Lerp2Angles( int taskID, int entID, vec3_t angles, float duration )
+{
+	gentity_t	*ent = &g_entities[entID];
+	vec3_t		ang;
+	int			i;
+
+	if(!ent)
+	{
+		DebugPrint( WL_WARNING, "Lerp2Angles: invalid entID %d\n", entID);
+		return;
+	}
+	
+	if ( ent->client || ent->NPC || Q_stricmp(ent->classname, "target_scriptrunner") == 0 )
+	{
+		DebugPrint( WL_ERROR, "Lerp2Angles: ent %d is NOT a mover!\n", entID);
+		return;
+	}
+
+	//If we want an instant move, don't send 0...
+	ent->s.apos.trDuration = (duration>0) ? duration : 1;
+
+	for ( i = 0; i < 3; i++ )
+	{
+		ang [i] = AngleSubtract( angles[i], ent->currentAngles[i]);
+		ent->s.apos.trDelta[i] = ( ang[i] / ( ent->s.apos.trDuration * 0.001f ) );
+	}
+
+	VectorCopy( ent->currentAngles, ent->s.apos.trBase );
+
+	if ( ent->alt_fire )
+	{
+		ent->s.apos.trType = TR_LINEAR_STOP;
+	}
+	else
+	{
+		ent->s.apos.trType = TR_NONLINEAR_STOP;
+	}
+
+	ent->s.apos.trTime = level.time;
+	
+	Q3_TaskIDSet( ent, TID_ANGLE_FACE, taskID );
+
+	//ent->e_ReachedFunc = reachedF_NULL;
+	ent->e_ThinkFunc = thinkF_anglerCallback;
+	ent->nextthink = level.time + duration;
+
+	// starting sound
+	G_PlayDoorLoopSound( ent );
+	G_PlayDoorSound( ent, BMS_START );	//??
+
+	gi.linkentity( ent );
+}
+
+// Gets the value of a tag by the give name.
+int		CQuake3GameInterface::GetTag( int entID, const char *name, int lookup, vec3_t info )
+{
+	gentity_t	*ent = &g_entities[ entID ];
+
+	VALIDATEB( ent );
+
+	switch ( lookup )
+	{
+	case TYPE_ORIGIN:
+		//return TAG_GetOrigin( ent->targetname, name, info );
+		return TAG_GetOrigin( ent->ownername, name, info );
+		break;
+
+	case TYPE_ANGLES:
+		//return TAG_GetAngles( ent->targetname, name, info );
+		return TAG_GetAngles( ent->ownername, name, info );
+		break;	
+	}
+
+	return false;
+}
+
+//	 void	CQuake3GameInterface::Lerp2Start( int taskID, int entID, float duration ) {}
+//	 void	CQuake3GameInterface::Lerp2End( int taskID, int entID, float duration ) {}
+
+void	CQuake3GameInterface::Set( int taskID, int entID, const char *type_name, const char *data )
+{
+	gentity_t	*ent = &g_entities[entID];
+	float		float_data;
+	int			int_data, toSet;
+	vec3_t		vector_data;
+
+	//Set this for callbacks
+	toSet = GetIDForString( setTable, type_name );
+
+	//TODO: Throw in a showscript command that will list each command and what they're doing...
+	//		maybe as simple as printing that line of the script to the console preceeded by the person's name?
+	//		showscript can take any number of targetnames or "all"?  Groupname?
+	switch ( toSet )
+	{
+	case SET_ORIGIN:
+		sscanf( data, "%f %f %f", &vector_data[0], &vector_data[1], &vector_data[2] );
+		G_SetOrigin( ent, vector_data );
+		if ( Q_strncmp( "NPC_", ent->classname, 4 ) == 0 )
+		{//hack for moving spawners
+			VectorCopy( vector_data, ent->s.origin);
+		}
+		if ( ent->client )
+		{//clear jump start positions so we don't take damage when we land...
+			ent->client->ps.jumpZStart = ent->client->ps.forceJumpZStart = vector_data[2];
+		}
+		gi.linkentity( ent );
+		break;
+
+	case SET_TELEPORT_DEST:
+		sscanf( data, "%f %f %f", &vector_data[0], &vector_data[1], &vector_data[2] );
+		if ( !Q3_SetTeleportDest( entID, vector_data ) )
+		{
+			Q3_TaskIDSet( ent, TID_MOVE_NAV, taskID );
+			return;
+		}
+		break;
+
+	case SET_COPY_ORIGIN:
+		Q3_SetCopyOrigin( entID, (char *) data );
+		break;
+
+	case SET_ANGLES:
+		//Q3_SetAngles( entID, *(vec3_t *) data);
+		sscanf( data, "%f %f %f", &vector_data[0], &vector_data[1], &vector_data[2] );
+		Q3_SetAngles( entID, vector_data);
+		break;
+
+	case SET_XVELOCITY:
+		float_data = atof((char *) data);
+		Q3_SetVelocity( entID, 0, float_data);
+		break;
+	
+	case SET_YVELOCITY:
+		float_data = atof((char *) data);
+		Q3_SetVelocity( entID, 1, float_data);
+		break;
+
+	case SET_ZVELOCITY:
+		float_data = atof((char *) data);
+		Q3_SetVelocity( entID, 2, float_data);
+		break;
+
+	case SET_Z_OFFSET:
+		float_data = atof((char *) data);
+		Q3_SetOriginOffset( entID, 2, float_data);
+		break;
+
+	case SET_ENEMY:
+		Q3_SetEnemy( entID, (char *) data );
+		break;
+
+	case SET_LEADER:
+		Q3_SetLeader( entID, (char *) data );
+		break;
+
+	case SET_NAVGOAL:
+		if ( Q3_SetNavGoal( entID, (char *) data ) )
+		{
+			Q3_TaskIDSet( ent, TID_MOVE_NAV, taskID );
+			return;	//Don't call it back
+		}
+		break;
+
+	case SET_ANIM_UPPER:
+		if ( Q3_SetAnimUpper( entID, (char *) data ) )
+		{
+			Q3_TaskIDClear( &ent->taskID[TID_ANIM_BOTH] );//We only want to wait for the top
+			Q3_TaskIDSet( ent, TID_ANIM_UPPER, taskID );
+			return;	//Don't call it back
+		}
+		break;
+
+	case SET_ANIM_LOWER:
+		if ( Q3_SetAnimLower( entID, (char *) data ) )
+		{
+			Q3_TaskIDClear( &ent->taskID[TID_ANIM_BOTH] );//We only want to wait for the bottom
+			Q3_TaskIDSet( ent, TID_ANIM_LOWER, taskID );
+			return;	//Don't call it back
+		}
+		break;
+
+	case SET_ANIM_BOTH:
+		{
+			int	both = 0;
+			if ( Q3_SetAnimUpper( entID, (char *) data ) )
+			{
+				Q3_TaskIDSet( ent, TID_ANIM_UPPER, taskID );
+				both++;
+			}
+			else
+			{
+				DebugPrint( WL_ERROR, "SetAnimUpper: %s does not have anim %s!\n", ent->targetname, (char *)data );
+			}
+			if ( Q3_SetAnimLower( entID, (char *) data ) )
+			{
+				Q3_TaskIDSet( ent, TID_ANIM_LOWER, taskID );
+				both++;
+			}
+			else
+			{
+				DebugPrint( WL_ERROR, "SetAnimLower: %s does not have anim %s!\n", ent->targetname, (char *)data );
+			}
+			if ( both >= 2 )
+			{
+				Q3_TaskIDSet( ent, TID_ANIM_BOTH, taskID );
+			}
+			if ( both )
+			{
+				return;	//Don't call it back
+			}
+		}
+		break;
+	
+	case SET_ANIM_HOLDTIME_LOWER:
+		int_data = atoi((char *) data);
+		Q3_SetAnimHoldTime( entID, int_data, qtrue );
+		Q3_TaskIDClear( &ent->taskID[TID_ANIM_BOTH] );//We only want to wait for the bottom
+		Q3_TaskIDSet( ent, TID_ANIM_LOWER, taskID );
+		return;	//Don't call it back
+		break;
+
+	case SET_ANIM_HOLDTIME_UPPER:
+		int_data = atoi((char *) data);
+		Q3_SetAnimHoldTime( entID, int_data, qfalse );
+		Q3_TaskIDClear( &ent->taskID[TID_ANIM_BOTH] );//We only want to wait for the top
+		Q3_TaskIDSet( ent, TID_ANIM_UPPER, taskID );
+		return;	//Don't call it back
+		break;
+
+	case SET_ANIM_HOLDTIME_BOTH:
+		int_data = atoi((char *) data);
+		Q3_SetAnimHoldTime( entID, int_data, qfalse );
+		Q3_SetAnimHoldTime( entID, int_data, qtrue );
+		Q3_TaskIDSet( ent, TID_ANIM_BOTH, taskID );
+		Q3_TaskIDSet( ent, TID_ANIM_UPPER, taskID );
+		Q3_TaskIDSet( ent, TID_ANIM_LOWER, taskID );
+		return;	//Don't call it back
+		break;
+
+	case SET_PLAYER_TEAM:
+		Q3_SetPlayerTeam( entID, (char *) data );
+		break;
+
+	case SET_ENEMY_TEAM:
+		Q3_SetEnemyTeam( entID, (char *) data );
+		break;
+
+	case SET_HEALTH:
+		int_data = atoi((char *) data);
+		Q3_SetHealth( entID, int_data );
+		break;
+
+	case SET_ARMOR:
+		int_data = atoi((char *) data);
+		Q3_SetArmor( entID, int_data );
+		break;
+
+	case SET_BEHAVIOR_STATE:
+		if( !Q3_SetBState( entID, (char *) data ) )
+		{
+			Q3_TaskIDSet( ent, TID_BSTATE, taskID );
+			return;//don't complete
+		}
+		break;
+
+	case SET_DEFAULT_BSTATE:
+		Q3_SetDefaultBState( entID, (char *) data );
+		break;
+
+	case SET_TEMP_BSTATE:
+		if( !Q3_SetTempBState( entID, (char *) data ) )
+		{
+			Q3_TaskIDSet( ent, TID_BSTATE, taskID );
+			return;//don't complete
+		}
+		break;
+
+	case SET_CAPTURE:
+		Q3_SetCaptureGoal( entID, (char *) data );
+		break;
+
+	case SET_DPITCH://FIXME: make these set tempBehavior to BS_FACE and await completion?  Or set lockedDesiredPitch/Yaw and aimTime?
+		float_data = atof((char *) data);
+		Q3_SetDPitch( entID, float_data );
+		Q3_TaskIDSet( ent, TID_ANGLE_FACE, taskID );
+		return;
+		break;
+
+	case SET_DYAW:
+		float_data = atof((char *) data);
+		Q3_SetDYaw( entID, float_data );
+		Q3_TaskIDSet( ent, TID_ANGLE_FACE, taskID );
+		return;
+		break;
+
+	case SET_EVENT:
+		Q3_SetEvent( entID, (char *) data );
+		break;
+
+	case SET_VIEWTARGET:
+		Q3_SetViewTarget( entID, (char *) data );
+		Q3_TaskIDSet( ent, TID_ANGLE_FACE, taskID );
+		return;
+		break;
+
+	case SET_WATCHTARGET:
+		Q3_SetWatchTarget( entID, (char *) data );
+		break;
+
+	case SET_VIEWENTITY:
+		Q3_SetViewEntity( entID, (char *) data );
+		break;
+
+	case SET_LOOPSOUND:
+		Q3_SetLoopSound( entID, (char *) data );
+		break;
+
+	case SET_ICARUS_FREEZE:
+	case SET_ICARUS_UNFREEZE:
+		Q3_SetICARUSFreeze( entID, (char *) data, (toSet==SET_ICARUS_FREEZE) );
+		break;
+
+	case SET_WEAPON:
+		Q3_SetWeapon ( entID, (char *) data);
+		break;
+
+	case SET_ITEM:
+		Q3_SetItem ( entID, (char *) data);
+		break;
+
+	case SET_WALKSPEED:
+		int_data = atoi((char *) data);
+		Q3_SetWalkSpeed ( entID, int_data);
+		break;
+
+	case SET_RUNSPEED:
+		int_data = atoi((char *) data);
+		Q3_SetRunSpeed ( entID, int_data);
+		break;
+
+	case SET_WIDTH:
+		int_data = atoi((char *) data);
+		Q3_SetWidth( entID, int_data );
+		return;
+		break;
+
+	case SET_YAWSPEED:
+		float_data = atof((char *) data);
+		Q3_SetYawSpeed ( entID, float_data);
+		break;
+
+	case SET_AGGRESSION:
+		int_data = atoi((char *) data);
+		Q3_SetAggression ( entID, int_data);
+		break;
+
+	case SET_AIM:
+		int_data = atoi((char *) data);
+		Q3_SetAim ( entID, int_data);
+		break;
+
+	case SET_FRICTION:
+		int_data = atoi((char *) data);
+		Q3_SetFriction ( entID, int_data);
+		break;
+
+	case SET_GRAVITY:
+		float_data = atof((char *) data);
+		Q3_SetGravity ( entID, float_data);
+		break;
+
+	case SET_WAIT:
+		float_data = atof((char *) data);
+		Q3_SetWait( entID, float_data);
+		break;
+
+	case SET_FOLLOWDIST:
+		float_data = atof((char *) data);
+		Q3_SetFollowDist( entID, float_data);
+		break;
+
+	case SET_SCALE:
+		float_data = atof((char *) data);
+		Q3_SetScale( entID, float_data);
+		break;
+
+	case SET_RENDER_CULL_RADIUS:
+		float_data = atof((char *) data);
+		Q3_SetRenderCullRadius(entID, float_data);
+		break;
+
+	case SET_COUNT:
+		Q3_SetCount( entID, (char *) data);
+		break;
+
+	case SET_SHOT_SPACING:
+		int_data = atoi((char *) data);
+		Q3_SetShotSpacing( entID, int_data );
+		break;
+
+	case SET_IGNOREPAIN:
+		if(!stricmp("true", ((char *)data)))
+			Q3_SetIgnorePain( entID, qtrue);
+		else if(!stricmp("false", ((char *)data)))
+			Q3_SetIgnorePain( entID, qfalse);
+		break;
+
+	case SET_IGNOREENEMIES:
+		if(!stricmp("true", ((char *)data)))
+			Q3_SetIgnoreEnemies( entID, qtrue);
+		else if(!stricmp("false", ((char *)data)))
+			Q3_SetIgnoreEnemies( entID, qfalse);
+		break;
+
+	case SET_IGNOREALERTS:
+		if(!stricmp("true", ((char *)data)))
+			Q3_SetIgnoreAlerts( entID, qtrue);
+		else if(!stricmp("false", ((char *)data)))
+			Q3_SetIgnoreAlerts( entID, qfalse);
+		break;
+		
+	case SET_DONTSHOOT:
+		if(!stricmp("true", ((char *)data)))
+			Q3_SetDontShoot( entID, qtrue);
+		else if(!stricmp("false", ((char *)data)))
+			Q3_SetDontShoot( entID, qfalse);
+		break;
+	
+	case SET_DONTFIRE:
+		if(!stricmp("true", ((char *)data)))
+			Q3_SetDontFire( entID, qtrue);
+		else if(!stricmp("false", ((char *)data)))
+			Q3_SetDontFire( entID, qfalse);
+		break;
+
+	case SET_LOCKED_ENEMY:
+		if(!stricmp("true", ((char *)data)))
+			Q3_SetLockedEnemy( entID, qtrue);
+		else if(!stricmp("false", ((char *)data)))
+			Q3_SetLockedEnemy( entID, qfalse);
+		break;
+
+	case SET_NOTARGET:
+		if(!stricmp("true", ((char *)data)))
+			Q3_SetNoTarget( entID, qtrue);
+		else if(!stricmp("false", ((char *)data)))
+			Q3_SetNoTarget( entID, qfalse);
+		break;
+
+	case SET_LEAN:
+		if(!stricmp("right", ((char *)data)))
+			Q3_SetLean( entID, LEAN_RIGHT);
+		else if(!stricmp("left", ((char *)data)))
+			Q3_SetLean( entID, LEAN_LEFT);
+		else
+			Q3_SetLean( entID, LEAN_NONE);
+		break;
+
+	case SET_SHOOTDIST:
+		float_data = atof((char *) data);
+		Q3_SetShootDist( entID, float_data );
+		break;
+
+	case SET_TIMESCALE:
+		Q3_SetTimeScale( entID, (char *) data );
+		break;
+
+	case SET_VISRANGE:
+		float_data = atof((char *) data);
+		Q3_SetVisrange( entID, float_data );
+		break;
+	
+	case SET_EARSHOT:
+		float_data = atof((char *) data);
+		Q3_SetEarshot( entID, float_data );
+		break;
+	
+	case SET_VIGILANCE:
+		float_data = atof((char *) data);
+		Q3_SetVigilance( entID, float_data );
+		break;
+	
+	case SET_VFOV:
+		int_data = atoi((char *) data);
+		Q3_SetVFOV( entID, int_data );
+		break;
+
+	case SET_HFOV:
+		int_data = atoi((char *) data);
+		Q3_SetHFOV( entID, int_data );
+		break;
+
+	case SET_TARGETNAME:
+		Q3_SetTargetName( entID, (char *) data );
+		break;
+
+	case SET_TARGET:
+		Q3_SetTarget( entID, (char *) data );
+		break;
+
+	case SET_TARGET2:
+		Q3_SetTarget2( entID, (char *) data );
+		break;
+	
+	case SET_LOCATION:
+		if ( !Q3_SetLocation( entID, (char *) data ) )
+		{
+			Q3_TaskIDSet( ent, TID_LOCATION, taskID );
+			return;
+		}
+		break;
+
+	case SET_PAINTARGET:
+		Q3_SetPainTarget( entID, (char *) data );
+		break;
+
+	case SET_DEFEND_TARGET:
+		DebugPrint( WL_WARNING, "SetDefendTarget unimplemented\n", entID );
+		//Q3_SetEnemy( entID, (char *) data);
+		break;
+
+	case SET_PARM1:
+	case SET_PARM2:
+	case SET_PARM3:
+	case SET_PARM4:
+	case SET_PARM5:
+	case SET_PARM6:
+	case SET_PARM7:
+	case SET_PARM8:
+	case SET_PARM9:
+	case SET_PARM10:
+	case SET_PARM11:
+	case SET_PARM12:
+	case SET_PARM13:
+	case SET_PARM14:
+	case SET_PARM15:
+	case SET_PARM16:
+		Q3_SetParm( entID, (toSet-SET_PARM1), (char *) data );
+		break;
+
+	case SET_SPAWNSCRIPT:
+	case SET_USESCRIPT:
+	case SET_AWAKESCRIPT:
+	case SET_ANGERSCRIPT:
+	case SET_ATTACKSCRIPT:
+	case SET_VICTORYSCRIPT:
+	case SET_PAINSCRIPT:
+	case SET_FLEESCRIPT:
+	case SET_DEATHSCRIPT:
+	case SET_DELAYEDSCRIPT:
+	case SET_BLOCKEDSCRIPT:
+	case SET_FFIRESCRIPT:
+	case SET_FFDEATHSCRIPT:
+	case SET_MINDTRICKSCRIPT:
+		if( !Q3_SetBehaviorSet(entID, toSet, (char *) data) )
+			DebugPrint( WL_ERROR, "SetBehaviorSet: Invalid bSet %s\n", type_name );
+		break;
+
+	case SET_NO_MINDTRICK:
+		if(!stricmp("true", ((char *)data)))
+			Q3_SetNoMindTrick( entID, qtrue);
+		else
+			Q3_SetNoMindTrick( entID, qfalse);
+		break;
+
+	case SET_CINEMATIC_SKIPSCRIPT :
+		Q3_SetCinematicSkipScript((char *) data);
+		break;
+
+	case SET_RAILCENTERTRACKLOCKED :
+		Rail_LockCenterOfTrack((char *) data);
+		break;
+
+	case SET_RAILCENTERTRACKUNLOCKED :
+		Rail_UnLockCenterOfTrack((char *) data);
+		break;
+
+	case SET_DELAYSCRIPTTIME:
+		int_data = atoi((char *) data);
+		Q3_SetDelayScriptTime( entID, int_data );
+		break;
+
+	case SET_CROUCHED:
+		if(!stricmp("true", ((char *)data)))
+			Q3_SetCrouched( entID, qtrue);
+		else
+			Q3_SetCrouched( entID, qfalse);
+		break;
+
+	case SET_WALKING:
+		if(!stricmp("true", ((char *)data)))
+			Q3_SetWalking( entID, qtrue);	
+		else
+			Q3_SetWalking( entID, qfalse);	
+		break;
+
+	case SET_RUNNING:
+		if(!stricmp("true", ((char *)data)))
+			Q3_SetRunning( entID, qtrue);	
+		else
+			Q3_SetRunning( entID, qfalse);	
+		break;
+
+	case SET_CHASE_ENEMIES:
+		if(!stricmp("true", ((char *)data)))
+			Q3_SetChaseEnemies( entID, qtrue);	
+		else
+			Q3_SetChaseEnemies( entID, qfalse);	
+		break;
+
+	case SET_LOOK_FOR_ENEMIES:
+		if(!stricmp("true", ((char *)data)))
+			Q3_SetLookForEnemies( entID, qtrue);	
+		else
+			Q3_SetLookForEnemies( entID, qfalse);	
+		break;
+
+	case SET_FACE_MOVE_DIR:
+		if(!stricmp("true", ((char *)data)))
+			Q3_SetFaceMoveDir( entID, qtrue);	
+		else
+			Q3_SetFaceMoveDir( entID, qfalse);	
+		break;
+
+	case SET_ALT_FIRE:
+		if(!stricmp("true", ((char *)data)))
+			Q3_SetAltFire( entID, qtrue);	
+		else
+			Q3_SetAltFire( entID, qfalse);	
+		break;
+
+	case SET_DONT_FLEE:
+		if(!stricmp("true", ((char *)data)))
+			Q3_SetDontFlee( entID, qtrue);	
+		else
+			Q3_SetDontFlee( entID, qfalse);	
+		break;
+
+	case SET_FORCED_MARCH:
+		if(!stricmp("true", ((char *)data)))
+			Q3_SetForcedMarch( entID, qtrue);	
+		else
+			Q3_SetForcedMarch( entID, qfalse);	
+		break;
+
+	case SET_NO_RESPONSE:
+		if(!stricmp("true", ((char *)data)))
+			Q3_SetNoResponse( entID, qtrue);	
+		else
+			Q3_SetNoResponse( entID, qfalse);	
+		break;
+
+	case SET_NO_COMBAT_TALK:
+		if(!stricmp("true", ((char *)data)))
+			Q3_SetCombatTalk( entID, qtrue);	
+		else
+			Q3_SetCombatTalk( entID, qfalse);	
+		break;
+
+	case SET_NO_ALERT_TALK:
+		if(!stricmp("true", ((char *)data)))
+			Q3_SetAlertTalk( entID, qtrue);	
+		else
+			Q3_SetAlertTalk( entID, qfalse);	
+		break;
+
+	case SET_USE_CP_NEAREST:
+		if(!stricmp("true", ((char *)data)))
+			Q3_SetUseCpNearest( entID, qtrue);	
+		else
+			Q3_SetUseCpNearest( entID, qfalse);	
+		break;
+
+	case SET_NO_FORCE:
+		if(!stricmp("true", ((char *)data)))
+			Q3_SetNoForce( entID, qtrue);	
+		else
+			Q3_SetNoForce( entID, qfalse);	
+		break;
+
+	case SET_NO_ACROBATICS:
+		if(!stricmp("true", ((char *)data)))
+			Q3_SetNoAcrobatics( entID, qtrue);	
+		else
+			Q3_SetNoAcrobatics( entID, qfalse);	
+		break;
+
+	case SET_USE_SUBTITLES:
+		if(!stricmp("true", ((char *)data)))
+			Q3_SetUseSubtitles( entID, qtrue);	
+		else
+			Q3_SetUseSubtitles( entID, qfalse);	
+		break;
+
+	case SET_NO_FALLTODEATH:
+		if(!stricmp("true", ((char *)data)))
+			Q3_SetNoFallToDeath( entID, qtrue);	
+		else
+			Q3_SetNoFallToDeath( entID, qfalse);	
+		break;
+
+	case SET_DISMEMBERABLE:
+		if(!stricmp("true", ((char *)data)))
+			Q3_SetDismemberable( entID, qtrue);	
+		else
+			Q3_SetDismemberable( entID, qfalse);	
+		break;
+
+	case SET_MORELIGHT:
+		if(!stricmp("true", ((char *)data)))
+			Q3_SetMoreLight( entID, qtrue);	
+		else
+			Q3_SetMoreLight( entID, qfalse);	
+		break;
+
+
+	case SET_TREASONED:
+		DebugPrint( WL_VERBOSE, "SET_TREASONED is disabled, do not use\n" );
+		/*
+		G_TeamRetaliation( NULL, &g_entities[0], qfalse );
+		ffireLevel = FFIRE_LEVEL_RETALIATION;
+		*/
+		break;
+
+	case SET_UNDYING:
+		if(!stricmp("true", ((char *)data)))
+			Q3_SetUndying( entID, qtrue);	
+		else
+			Q3_SetUndying( entID, qfalse);	
+		break;
+
+	case SET_INVINCIBLE:
+		if(!stricmp("true", ((char *)data)))
+			Q3_SetInvincible( entID, qtrue);	
+		else
+			Q3_SetInvincible( entID, qfalse);	
+		break;
+
+	case SET_NOAVOID:
+		if(!stricmp("true", ((char *)data)))
+			Q3_SetNoAvoid( entID, qtrue);	
+		else
+			Q3_SetNoAvoid( entID, qfalse);	
+		break;
+
+	case SET_SOLID:
+		if(!stricmp("true", ((char *)data)))
+		{
+			if ( !Q3_SetSolid( entID, qtrue) )
+			{
+				Q3_TaskIDSet( ent, TID_RESIZE, taskID );
+				return;
+			}
+		}
+		else
+		{
+			Q3_SetSolid( entID, qfalse);
+		}
+		break;
+
+	case SET_INVISIBLE:
+		if( !stricmp("true", ((char *)data)) )
+			Q3_SetInvisible( entID, qtrue );
+		else
+			Q3_SetInvisible( entID, qfalse );
+		break;
+
+	case SET_VAMPIRE:
+		if( !stricmp("true", ((char *)data)) )
+			Q3_SetVampire( entID, qtrue );
+		else
+			Q3_SetVampire( entID, qfalse );
+		break;
+
+	case SET_FORCE_INVINCIBLE:
+		if( !stricmp("true", ((char *)data)) )
+			Q3_SetForceInvincible( entID, qtrue );
+		else
+			Q3_SetForceInvincible( entID, qfalse );
+		break;
+
+	case SET_GREET_ALLIES:
+		if( !stricmp("true", ((char *)data)) )
+			Q3_SetGreetAllies( entID, qtrue );
+		else
+			Q3_SetGreetAllies( entID, qfalse );
+		break;
+
+	case SET_PLAYER_LOCKED:
+		if( !stricmp("true", ((char *)data)) )
+			Q3_SetPlayerLocked( entID, qtrue );
+		else
+			Q3_SetPlayerLocked( entID, qfalse );
+		break;
+		
+	case SET_LOCK_PLAYER_WEAPONS:
+		if( !stricmp("true", ((char *)data)) )
+			Q3_SetLockPlayerWeapons( entID, qtrue );
+		else
+			Q3_SetLockPlayerWeapons( entID, qfalse );
+		break;
+
+	case SET_NO_IMPACT_DAMAGE:
+		if( !stricmp("true", ((char *)data)) )
+			Q3_SetNoImpactDamage( entID, qtrue );
+		else
+			Q3_SetNoImpactDamage( entID, qfalse );
+		break;
+
+	case SET_FORWARDMOVE:
+		int_data = atoi((char *) data);
+		Q3_SetForwardMove( entID, int_data);	
+		break;
+
+	case SET_RIGHTMOVE:
+		int_data = atoi((char *) data);
+		Q3_SetRightMove( entID, int_data);	
+		break;
+
+	case SET_LOCKYAW:
+		Q3_SetLockAngle( entID, data);	
+		break;
+	
+	case SET_CAMERA_GROUP:
+		Q3_CameraGroup(entID, (char *)data);
+		break;
+	case SET_CAMERA_GROUP_Z_OFS:
+		float_data = atof((char *) data);
+		Q3_CameraGroupZOfs( float_data );
+		break;
+	case SET_CAMERA_GROUP_TAG:
+		Q3_CameraGroupTag( (char *)data );
+		break;
+
+	//FIXME: put these into camera commands
+	case SET_LOOK_TARGET:
+		Q3_LookTarget(entID, (char *)data);
+		break;
+
+	case SET_ADDRHANDBOLT_MODEL:
+		Q3_AddRHandModel(entID, (char *)data);
+		break;
+
+	case SET_REMOVERHANDBOLT_MODEL:
+		Q3_RemoveRHandModel(entID, (char *)data);
+		break;
+
+	case SET_ADDLHANDBOLT_MODEL:
+		Q3_AddLHandModel(entID, (char *)data);
+		break;
+
+	case SET_REMOVELHANDBOLT_MODEL:
+		Q3_RemoveLHandModel(entID, (char *)data);
+		break;
+
+	case SET_FACEEYESCLOSED:
+	case SET_FACEEYESOPENED:
+	case SET_FACEAUX:
+	case SET_FACEBLINK:
+	case SET_FACEBLINKFROWN:
+	case SET_FACEFROWN:
+	case SET_FACENORMAL:
+		float_data = atof((char *) data);
+		Q3_Face(entID, toSet, float_data);
+		break;
+
+	case SET_SCROLLTEXT:
+		Q3_ScrollText( (char *)data );	
+		break;
+
+	case SET_LCARSTEXT:
+		Q3_LCARSText( (char *)data );	
+		break;
+
+	case SET_CENTERTEXT:
+		CenterPrint( (char *)data );
+		break;
+
+	case SET_CAPTIONTEXTCOLOR:
+		Q3_SetCaptionTextColor ( (char *)data );	
+		break;
+	case SET_CENTERTEXTCOLOR:
+		Q3_SetCenterTextColor ( (char *)data );	
+		break;
+	case SET_SCROLLTEXTCOLOR:
+		Q3_SetScrollTextColor ( (char *)data );	
+		break;
+
+	case SET_PLAYER_USABLE:
+		if(!stricmp("true", ((char *)data)))
+		{
+			Q3_SetPlayerUsable(entID, qtrue);
+		}
+		else
+		{
+			Q3_SetPlayerUsable(entID, qfalse);
+		}
+		break;
+
+	case SET_STARTFRAME:
+		int_data = atoi((char *) data);
+		Q3_SetStartFrame(entID, int_data);
+		break;
+	
+	case SET_ENDFRAME:
+		int_data = atoi((char *) data);
+		Q3_SetEndFrame(entID, int_data);
+
+		Q3_TaskIDSet( ent, TID_ANIM_BOTH, taskID );
+		return;
+		break;
+
+	case SET_ANIMFRAME:
+		int_data = atoi((char *) data);
+		Q3_SetAnimFrame(entID, int_data);
+		return;
+		break;
+		
+	case SET_LOOP_ANIM:
+		if(!stricmp("true", ((char *)data)))
+		{
+			Q3_SetLoopAnim(entID, qtrue);
+		}
+		else
+		{
+			Q3_SetLoopAnim(entID, qfalse);
+		}
+		break;
+
+	case SET_INTERFACE:
+		if(!stricmp("true", ((char *)data)))
+		{
+			Q3_SetInterface(entID, "1");
+		}
+		else
+		{
+			Q3_SetInterface(entID, "0");
+		}
+
+		break;
+
+	case SET_SHIELDS:
+		if(!stricmp("true", ((char *)data)))
+		{
+			Q3_SetShields(entID, qtrue);
+		}
+		else
+		{
+			Q3_SetShields(entID, qfalse);
+		}
+		break;
+	
+	case SET_SABERACTIVE:
+		if(!stricmp("true", ((char *)data)))
+		{
+			Q3_SetSaberActive( entID, qtrue );
+		}
+		else
+		{
+			Q3_SetSaberActive( entID, qfalse );
+		}
+		break;
+
+	// Created: 10/02/02 by Aurelio Reis, Modified: 10/02/02
+	// Make a specific Saber 1 Blade active.
+	case SET_SABER1BLADEON:
+		// Get which Blade to activate.
+		int_data = atoi((char *) data);
+		Q3_SetSaberBladeActive( entID, 0, int_data, qtrue );
+		break;
+
+	// Make a specific Saber 1 Blade inactive.
+	case SET_SABER1BLADEOFF:
+		// Get which Blade to deactivate.
+		int_data = atoi((char *) data);
+		Q3_SetSaberBladeActive( entID, 0, int_data, qfalse );
+		break;
+
+	// Make a specific Saber 2 Blade active.
+	case SET_SABER2BLADEON:
+		// Get which Blade to activate.
+		int_data = atoi((char *) data);
+		Q3_SetSaberBladeActive( entID, 1, int_data, qtrue );
+		break;
+
+	// Make a specific Saber 2 Blade inactive.
+	case SET_SABER2BLADEOFF:
+		// Get which Blade to deactivate.
+		int_data = atoi((char *) data);
+		Q3_SetSaberBladeActive( entID, 1, int_data, qfalse );
+		break;
+
+	case SET_DAMAGEENTITY:
+		int_data = atoi((char *) data);
+		G_Damage( ent, ent, ent, NULL, NULL, int_data, 0, MOD_UNKNOWN );
+		break;
+
+	case SET_SABER_ORIGIN:
+		sscanf( data, "%f %f %f", &vector_data[0], &vector_data[1], &vector_data[2] );
+		WP_SetSaberOrigin( ent, vector_data );
+		break;
+
+	case SET_ADJUST_AREA_PORTALS:
+		if(!stricmp("true", ((char *)data)))
+		{
+			Q3_SetAdjustAreaPortals( entID, qtrue );
+		}
+		else
+		{
+			Q3_SetAdjustAreaPortals( entID, qfalse );
+		}
+		break;
+	
+	case SET_DMG_BY_HEAVY_WEAP_ONLY:
+		if(!stricmp("true", ((char *)data)))
+		{
+			Q3_SetDmgByHeavyWeapOnly( entID, qtrue );
+		}
+		else
+		{
+			Q3_SetDmgByHeavyWeapOnly( entID, qfalse );
+		}
+		break;
+
+	case SET_SHIELDED:
+		if(!stricmp("true", ((char *)data)))
+		{
+			Q3_SetShielded( entID, qtrue );
+		}
+		else
+		{
+			Q3_SetShielded( entID, qfalse );
+		}
+		break;
+
+	case SET_NO_GROUPS:
+		if(!stricmp("true", ((char *)data)))
+		{
+			Q3_SetNoGroups( entID, qtrue );
+		}
+		else
+		{
+			Q3_SetNoGroups( entID, qfalse );
+		}
+		break;
+
+	case SET_FIRE_WEAPON:
+		if(!stricmp("true", ((char *)data)))
+		{
+			Q3_SetFireWeapon( entID, qtrue);
+		}
+		else if(!stricmp("false", ((char *)data)))
+		{
+			Q3_SetFireWeapon( entID, qfalse);
+		}
+		break;
+
+	case SET_FIRE_WEAPON_NO_ANIM:
+		if(!stricmp("true", ((char *)data)))
+		{
+			Q3_SetFireWeaponNoAnim( entID, qtrue);
+		}
+		else if(!stricmp("false", ((char *)data)))
+		{
+			Q3_SetFireWeaponNoAnim( entID, qfalse);
+		}
+		break;
+	case SET_SAFE_REMOVE:
+		if(!stricmp("true", ((char *)data)))
+		{
+			Q3_SetSafeRemove( entID, qtrue);
+		}
+		else if(!stricmp("false", ((char *)data)))
+		{
+			Q3_SetSafeRemove( entID, qfalse);
+		}
+		break;
+
+	case SET_BOBA_JET_PACK:
+		if(!stricmp("true", ((char *)data)))
+		{
+			Q3_SetBobaJetPack( entID, qtrue);
+		}
+		else if(!stricmp("false", ((char *)data)))
+		{
+			Q3_SetBobaJetPack( entID, qfalse);
+		}
+		break;
+
+	case SET_INACTIVE:
+		if(!stricmp("true", ((char *)data)))
+		{
+			Q3_SetInactive( entID, qtrue);
+		}
+		else if(!stricmp("false", ((char *)data)))
+		{
+			Q3_SetInactive( entID, qfalse);
+		}
+		else if(!stricmp("unlocked", ((char *)data)))
+		{
+extern void UnLockDoors(gentity_t *const ent);
+			UnLockDoors(&g_entities[entID]);
+		}
+		else if(!stricmp("locked", ((char *)data)))
+		{
+extern void LockDoors(gentity_t *const ent);
+			LockDoors(&g_entities[entID]);
+		}
+		break;
+
+	case SET_END_SCREENDISSOLVE:
+		gi.SendConsoleCommand( "endscreendissolve\n");
+		break;
+
+	case SET_FUNC_USABLE_VISIBLE:
+		if(!stricmp("true", ((char *)data)))
+		{
+			Q3_SetFuncUsableVisible( entID, qtrue);
+		}
+		else if(!stricmp("false", ((char *)data)))
+		{
+			Q3_SetFuncUsableVisible( entID, qfalse);
+		}
+		break;
+
+	case SET_NO_KNOCKBACK:
+		if(!stricmp("true", ((char *)data)))
+		{
+			Q3_SetNoKnockback(entID, qtrue);
+		}
+		else
+		{
+			Q3_SetNoKnockback(entID, qfalse);
+		}
+		break;
+
+	case SET_VIDEO_PLAY:
+		// don't do this check now, James doesn't want a scripted cinematic to also skip any Video cinematics as well,
+		//	the "timescale" and "skippingCinematic" cvars will be set back to normal in the Video code, so doing a
+		//	skip will now only skip one section of a multiple-part story (eg VOY1 bridge sequence)
+		//
+//		if ( g_timescale->value <= 1.0f )
+		{
+			gi.SendConsoleCommand( va("inGameCinematic %s\n", (char *)data) );
+		}
+		break;
+
+	case SET_VIDEO_FADE_IN:
+		if(!stricmp("true", ((char *)data)))
+		{
+			gi.cvar_set("cl_VidFadeUp", "1");
+		}
+		else
+		{
+			gi.cvar_set("cl_VidFadeUp", "0");
+		}
+		break;
+
+	case SET_VIDEO_FADE_OUT:
+		if(!stricmp("true", ((char *)data)))
+		{
+			gi.cvar_set("cl_VidFadeDown", "1");
+		}
+		else
+		{
+			gi.cvar_set("cl_VidFadeDown", "0");
+		}
+		break;
+	case SET_REMOVE_TARGET:
+		Q3_SetRemoveTarget( entID, (const char *) data );
+		break;
+
+	case SET_LOADGAME:
+		gi.SendConsoleCommand( va("load %s\n", (const char *) data ) );
+		break;
+
+	case SET_MENU_SCREEN:
+		//UI_SetActiveMenu( (const char *) data );
+		gi.SendConsoleCommand( va("uimenu %s\n", (char *)data) );		
+		break;
+
+	case SET_OBJECTIVE_SHOW:
+		missionInfo_Updated = qtrue;	// Activate flashing text
+		gi.cvar_set("cg_updatedDataPadObjective", "1"); 
+
+		Q3_SetObjective((const char *) data ,SET_OBJ_SHOW);
+		Q3_SetObjective((const char *) data ,SET_OBJ_PENDING);
+		break;
+	case SET_OBJECTIVE_HIDE:
+		Q3_SetObjective((const char *) data ,SET_OBJ_HIDE);
+		break;
+	case SET_OBJECTIVE_SUCCEEDED:
+		missionInfo_Updated = qtrue;	// Activate flashing text
+		gi.cvar_set("cg_updatedDataPadObjective", "1"); 
+		Q3_SetObjective((const char *) data ,SET_OBJ_SUCCEEDED);
+		break;
+	case SET_OBJECTIVE_SUCCEEDED_NO_UPDATE:
+		Q3_SetObjective((const char *) data ,SET_OBJ_SUCCEEDED);
+		break;
+	case SET_OBJECTIVE_FAILED:
+		Q3_SetObjective((const char *) data ,SET_OBJ_FAILED);
+		break;
+
+	case SET_OBJECTIVE_CLEARALL:
+		Q3_ObjectiveClearAll();
+		break;
+
+	case SET_MISSIONFAILED:
+		Q3_SetMissionFailed((const char *) data);
+		break;
+
+	case SET_MISSIONSTATUSTEXT:
+		Q3_SetStatusText((const char *) data);
+		break;
+		
+	case SET_MISSIONSTATUSTIME:
+		int_data = atoi((char *) data);
+		cg.missionStatusDeadTime = level.time + int_data;
+		break;
+
+	case SET_CLOSINGCREDITS:
+		gi.cvar_set("cg_endcredits", "1");
+		break;
+
+	case SET_SKILL:
+//		//can never be set
+		break;
+
+	case SET_DISABLE_SHADER_ANIM:
+		if(!stricmp("true", ((char *)data)))
+		{
+			Q3_SetDisableShaderAnims( entID, qtrue);
+		}
+		else
+		{
+			Q3_SetDisableShaderAnims( entID, qfalse);
+		}
+		break;
+
+	case SET_SHADER_ANIM:
+		if(!stricmp("true", ((char *)data)))
+		{
+			Q3_SetShaderAnim( entID, qtrue);
+		}
+		else
+		{
+			Q3_SetShaderAnim( entID, qfalse);
+		}
+		break;
+
+	case SET_MUSIC_STATE:
+		Q3_SetMusicState( (char *) data );
+		break;
+
+	case SET_CLEAN_DAMAGING_ENTS:
+		Q3_SetCleanDamagingEnts();
+		break;
+
+	case SET_HUD:
+		if(!stricmp("true", ((char *)data)))
+		{
+			gi.cvar_set("cg_drawHUD", "1");
+		}
+		else
+		{
+			gi.cvar_set("cg_drawHUD", "0");
+		}
+		break;
+
+	case SET_FORCE_HEAL_LEVEL:
+	case SET_FORCE_JUMP_LEVEL:
+	case SET_FORCE_SPEED_LEVEL:
+	case SET_FORCE_PUSH_LEVEL:
+	case SET_FORCE_PULL_LEVEL:
+	case SET_FORCE_MINDTRICK_LEVEL:
+	case SET_FORCE_GRIP_LEVEL:
+	case SET_FORCE_LIGHTNING_LEVEL:
+	case SET_SABER_THROW:
+	case SET_SABER_DEFENSE:
+	case SET_SABER_OFFENSE:
+	case SET_FORCE_RAGE_LEVEL:
+	case SET_FORCE_PROTECT_LEVEL:
+	case SET_FORCE_ABSORB_LEVEL:
+	case SET_FORCE_DRAIN_LEVEL:
+	case SET_FORCE_SIGHT_LEVEL:
+		int_data = atoi((char *) data);
+		Q3_SetForcePowerLevel( entID, (toSet-SET_FORCE_HEAL_LEVEL), int_data );
+		break;
+	
+	case SET_SABER1:
+	case SET_SABER2:
+		WP_SetSaber( &g_entities[entID], toSet-SET_SABER1, (char *)data );
+		break;
+
+	case SET_PLAYERMODEL:
+		G_ChangePlayerModel( &g_entities[entID], (const char *)data );
+		break;
+
+	// NOTE: Preconditions for entering a vehicle still exist. This is not assured to work. -Areis
+	case SET_VEHICLE:
+		Use( entID, (char *)data );
+//		G_DriveVehicle( &g_entities[entID], NULL, (char *)data );
+		break;
+	
+	case SET_SECURITY_KEY:
+		Q3_GiveSecurityKey( entID, (char *)data );
+		break;
+
+	case SET_SABER1_COLOR1:
+	case SET_SABER1_COLOR2:
+		WP_SaberSetColor( &g_entities[entID], 0, toSet-SET_SABER1_COLOR1, (char *)data );
+		break;
+	case SET_SABER2_COLOR1:
+	case SET_SABER2_COLOR2:
+		WP_SaberSetColor( &g_entities[entID], 1, toSet-SET_SABER2_COLOR1, (char *)data );
+		break;
+	case SET_DISMEMBER_LIMB:
+		Q3_DismemberLimb( entID, (char *)data );
+		break;
+	case SET_NO_PVS_CULL:
+		Q3_SetBroadcast( entID, (qboolean)(Q_stricmp("true",(char*)data)==0) );
+		break;
+	// Set a Saboteur to cloak (true) or un-cloak (false).
+	case SET_CLOAK:		// Created: 01/08/03 by AReis.
+//extern void Jedi_Cloak( gentity_t *self );
+extern void Saboteur_Cloak( gentity_t *self );
+		if( stricmp("true", ((char *)data)) == 0 )
+		{
+			Saboteur_Cloak( &g_entities[entID] );
+		}
+		else
+		{
+			Saboteur_Decloak( &g_entities[entID] );
+		}
+		break;
+	case SET_FORCE_HEAL:
+		Q3_SetForcePower( entID, FP_HEAL, (qboolean)(Q_stricmp("true",(char*)data)==0) );
+		break;
+	case SET_FORCE_SPEED:
+		Q3_SetForcePower( entID, FP_SPEED, (qboolean)(Q_stricmp("true",(char*)data)==0) );
+		break;
+	case SET_FORCE_PUSH:
+		Q3_SetForcePower( entID, FP_PUSH, (qboolean)(Q_stricmp("true",(char*)data)==0) );
+		break;
+	case SET_FORCE_PUSH_FAKE:
+		ForceThrow( &g_entities[entID], qfalse, qtrue );
+		break;
+	case SET_FORCE_PULL:
+		Q3_SetForcePower( entID, FP_PULL, (qboolean)(Q_stricmp("true",(char*)data)==0) );
+		break;
+	case SET_FORCE_MIND_TRICK:
+		Q3_SetForcePower( entID, FP_TELEPATHY, (qboolean)(Q_stricmp("true",(char*)data)==0) );
+		break;
+	case SET_FORCE_GRIP:
+		Q3_SetForcePower( entID, FP_GRIP, (qboolean)(Q_stricmp("true",(char*)data)==0) );
+		break;
+	case SET_FORCE_LIGHTNING:
+		Q3_SetForcePower( entID, FP_LIGHTNING, (qboolean)(Q_stricmp("true",(char*)data)==0) );
+		break;
+	case SET_FORCE_SABERTHROW:
+		Q3_SetForcePower( entID, FP_SABERTHROW, (qboolean)(Q_stricmp("true",(char*)data)==0) );
+		break;
+	case SET_FORCE_RAGE:
+		Q3_SetForcePower( entID, FP_RAGE, (qboolean)(Q_stricmp("true",(char*)data)==0) );
+		break;
+	case SET_FORCE_PROTECT:
+		Q3_SetForcePower( entID, FP_PROTECT, (qboolean)(Q_stricmp("true",(char*)data)==0) );
+		break;
+	case SET_FORCE_ABSORB:
+		Q3_SetForcePower( entID, FP_ABSORB, (qboolean)(Q_stricmp("true",(char*)data)==0) );
+		break;
+	case SET_FORCE_DRAIN:
+		Q3_SetForcePower( entID, FP_DRAIN, (qboolean)(Q_stricmp("true",(char*)data)==0) );
+		break;
+
+extern cvar_t	*g_char_model;
+extern cvar_t	*g_char_skin_head;
+extern cvar_t	*g_char_skin_torso;
+extern cvar_t	*g_char_skin_legs;
+	case SET_WINTER_GEAR:	// Created: 03/26/03 by AReis.
+	{
+		// If this is a (fake) Player NPC or this IS the Player...
+		if ( entID == 0 || ( ent->NPC_type && stricmp( ent->NPC_type, "player" ) == 0 ) )
+		{
+			char strSkin[MAX_QPATH];
+			// Set the Winter Gear Skin if true, otherwise set back to normal configuration.
+			if( stricmp( "true", ((char *)data) ) == 0 )
+			{
+				Com_sprintf( strSkin, sizeof( strSkin ), "models/players/%s/|%s|%s|%s", g_char_model->string, g_char_skin_head->string, "torso_g1", "lower_e1" );
+			}
+			else
+			{
+				Com_sprintf( strSkin, sizeof( strSkin ), "models/players/%s/|%s|%s|%s", g_char_model->string, g_char_skin_head->string, g_char_skin_torso->string, g_char_skin_legs->string );
+			}
+			int iSkinID = gi.RE_RegisterSkin( strSkin );
+			if ( iSkinID )
+			{
+				gi.G2API_SetSkin( &ent->ghoul2[ent->playerModel], G_SkinIndex( strSkin ), iSkinID );
+			}
+		}
+		break;
+	}
+	case SET_NO_ANGLES:
+		if ( entID >= 0 && entID < ENTITYNUM_WORLD )
+		{
+			if ( (Q_stricmp("true",(char*)data)==0) )
+			{
+				g_entities[entID].flags |= FL_NO_ANGLES;
+			}
+			else
+			{
+				g_entities[entID].flags &= ~FL_NO_ANGLES;
+			}
+		}
+		break;
+	case SET_SKIN:
+		// If this is a (fake) Player NPC or this IS the Player...
+		{//just blindly sets whatever skin you set!  include full path after "base/"... eg: "models/players/tavion_new/model_possessed.skin"
+			gentity_t *ent = &g_entities[entID];
+			if ( ent && ent->inuse && ent->ghoul2.size() )
+			{
+				int iSkinID = gi.RE_RegisterSkin( (char *)data );
+				if ( iSkinID )
+				{
+					gi.G2API_SetSkin( &ent->ghoul2[ent->playerModel], G_SkinIndex( (char *)data ), iSkinID );
+				}
+			}
+		}
+		break;
+
+	default:
+		//DebugPrint( WL_ERROR, "Set: '%s' is not a valid set field\n", type_name );
+		SetVar( taskID, entID, type_name, data );
+		PrisonerObjCheck(type_name,data);
+		break;
+	}
+
+	IIcarusInterface::GetIcarus()->Completed( ent->m_iIcarusID, taskID );
+}
+
+void CQuake3GameInterface::PrisonerObjCheck(const char *name,const char *data)
+{
+	float	float_data;
+	int		holdData;
+
+	if (!Q_stricmp("ui_prisonerobj_currtotal",name))
+	{
+		GetFloatVariable( name, &float_data );
+		holdData = (int) float_data;
+		gi.cvar_set("ui_prisonerobj_currtotal", va("%d",holdData));	
+	}
+	else if (!Q_stricmp("ui_prisonerobj_maxtotal",name))
+	{
+		gi.cvar_set("ui_prisonerobj_maxtotal", data);	
+	}
+
+}
+// Uses an entity.
+void	CQuake3GameInterface::Use( int entID, const char *name )
+{
+	gentity_t	*ent  = &g_entities[entID];
+	
+	if ( !ent )
+	{
+		DebugPrint( WL_WARNING, "Use: invalid entID %d\n", entID );
+		return;
+	}
+
+	if( !name || !name[0] )
+	{
+		DebugPrint( WL_WARNING, "Use: string is NULL!\n" );
+		return;
+	}
+
+	if ( ent->s.number == 0 && ent->client->NPC_class == CLASS_ATST )
+	{//a player trying to get out of his ATST
+		GEntity_UseFunc( ent->activator, ent, ent );
+		return;
+	}
+	/*
+	if ( ent->client )
+	{//put the button on him, too, since some other things (like getting out of a vehicle?) check for the use button directly...
+		ent->client->usercmd.buttons |= BUTTON_USE;
+	}
+	*/
+	G_UseTargets2( ent, ent, name );
+}
+
+void	CQuake3GameInterface::Activate( int entID, const char *name )
+{
+	Q3_SetInactive( entID, qtrue );
+}
+
+void	CQuake3GameInterface::Deactivate( int entID, const char *name )
+{
+	Q3_SetInactive( entID, qfalse );
+}
+
+// Kill an entity.
+void	CQuake3GameInterface::Kill( int entID, const char *name )
+{
+	gentity_t	*ent = &g_entities[entID];
+	gentity_t	*victim = NULL;
+	int			o_health;
+
+	if( !stricmp( name, "self") )
+	{
+		victim = ent;
+	}
+	else if( !stricmp( name, "enemy" ) )
+	{
+		victim = ent->enemy;
+	}
+	else
+	{
+		victim = G_Find (NULL, FOFS(targetname), (char *) name );
+	}
+
+	if ( !victim )
+	{
+		DebugPrint( WL_WARNING, "Kill: can't find %s\n", name);
+		return;
+	}
+
+	/*
+	if ( victim == ent )
+	{
+		DebugPrint( WL_ERROR, "Kill: entity %s trying to kill self - not allowed!\n", name);
+		return;
+	}
+	*/
+	if ( victim == ent )
+	{//don't ICARUS_FreeEnt me, I'm in the middle of a script!  (FIXME: shouldn't ICARUS handle this internally?)
+		victim->svFlags |= SVF_KILLED_SELF;
+	}
+
+	o_health = victim->health;
+	victim->health = 0;
+	if ( victim->client )
+	{
+		victim->flags |= FL_NO_KNOCKBACK;
+	}
+	//G_SetEnemy(victim, ent);
+	if( victim->e_DieFunc != dieF_NULL )	// check can be omitted
+	{
+		GEntity_DieFunc( victim, NULL, NULL, o_health, MOD_UNKNOWN );
+	}
+}
+
+// Remove an entity.
+void	CQuake3GameInterface::Remove( int entID, const char *name )
+{
+	gentity_t *ent = &g_entities[entID];
+	gentity_t	*victim = NULL;
+
+	if( !Q_stricmp( "self", name ) )
+	{
+		victim = ent;
+		if ( !victim )
+		{
+			DebugPrint( WL_WARNING, "Remove: can't find %s\n", name );
+			return;
+		}
+		Q3_RemoveEnt( victim );
+	}
+	else if( !Q_stricmp( "enemy", name ) )
+	{
+		victim = ent->enemy;
+		if ( !victim )
+		{
+			DebugPrint( WL_WARNING, "Remove: can't find %s\n", name );
+			return;
+		}
+		Q3_RemoveEnt( victim );
+	}
+	else
+	{
+		victim = G_Find( NULL, FOFS(targetname), (char *) name );
+		if ( !victim )
+		{
+			DebugPrint( WL_WARNING, "Remove: can't find %s\n", name );
+			return;
+		}
+
+		while ( victim )
+		{
+			Q3_RemoveEnt( victim );
+			victim = G_Find( victim, FOFS(targetname), (char *) name );
+		}
+	}
+}
+
+// Get a random (float) number.
+float	CQuake3GameInterface::Random( float min, float max )
+{
+	return ((rand() * (max - min)) / 32768.0F) + min;
+}
+
+void	CQuake3GameInterface::Play( int taskID, int entID, const char *type, const char *name )
+{
+	gentity_t *ent = &g_entities[entID];
+
+	if ( !stricmp( type, "PLAY_ROFF" ) )
+	{
+		// Try to load the requested ROFF
+		if ( G_LoadRoff( name ) )
+		{
+			ent->roff = G_NewString( name );
+
+			// Start the roff from the beginning
+			ent->roff_ctr = 0;
+
+			//Save this off for later
+			Q3_TaskIDSet( ent, TID_MOVE_NAV, taskID );
+
+			// Let the ROFF playing start.
+			ent->next_roff_time = level.time;
+
+			// These need to be initialised up front...
+			VectorCopy( ent->currentOrigin, ent->pos1 );
+			VectorCopy( ent->currentAngles, ent->pos2 );
+			gi.linkentity( ent );
+		}
+	}
+}
+
+//Camera functions
+void	CQuake3GameInterface::CameraPan( vec3_t angles, vec3_t dir, float duration )
+{
+	CGCam_Pan( angles, dir, duration );
+}
+
+void	CQuake3GameInterface::CameraMove( vec3_t origin, float duration )
+{
+	CGCam_Move( origin, duration );
+}
+
+void	CQuake3GameInterface::CameraZoom( float fov, float duration )
+{
+	CGCam_Zoom( fov, duration );
+}
+
+void	CQuake3GameInterface::CameraRoll( float angle, float duration )
+{
+	CGCam_Roll( angle, duration );
+}
+
+void	CQuake3GameInterface::CameraFollow( const char *name, float speed, float initLerp )
+{
+	CGCam_Follow( name, speed, initLerp );
+}
+
+void	CQuake3GameInterface::CameraTrack( const char *name, float speed, float initLerp )
+{
+	CGCam_Track( name, speed, initLerp );
+}
+
+void	CQuake3GameInterface::CameraDistance( float dist, float initLerp )
+{
+	CGCam_Distance( dist, initLerp );
+}
+
+void	CQuake3GameInterface::CameraFade( float sr, float sg, float sb, float sa, float dr, float dg, float db, float da, float duration )
+{
+	vec4_t	src, dst;
+
+	src[0] = sr;
+	src[1] = sg;
+	src[2] = sb;
+	src[3] = sa;
+
+	dst[0] = dr;
+	dst[1] = dg;
+	dst[2] = db;
+	dst[3] = da;
+
+	CGCam_Fade( src, dst, duration );
+}
+
+void	CQuake3GameInterface::CameraPath( const char *name )
+{
+	CGCam_StartRoff( G_NewString( name ) );
+}
+
+void	CQuake3GameInterface::CameraEnable( void )
+{
+	CGCam_Enable();
+}
+
+void	CQuake3GameInterface::CameraDisable( void )
+{
+	CGCam_Disable();
+}
+
+void	CQuake3GameInterface::CameraShake( float intensity, int duration )
+{
+	CGCam_Shake( intensity, duration );
+}
+
+int		CQuake3GameInterface::GetFloat( int entID, const char *name, float *value )
+{
+	gentity_t	*ent = &g_entities[entID];
+//	gclient_t	*client;
+
+	if ( !ent )
+	{
+		return false;
+	}
+
+	int toGet = GetIDForString( setTable, name );	//FIXME: May want to make a "getTable" as well
+	//FIXME: I'm getting really sick of these huge switch statements!
+
+	//NOTENOTE: return true if the value was correctly obtained
+	switch ( toGet )
+	{
+	case SET_PARM1:
+	case SET_PARM2:
+	case SET_PARM3:
+	case SET_PARM4:
+	case SET_PARM5:
+	case SET_PARM6:
+	case SET_PARM7:
+	case SET_PARM8:
+	case SET_PARM9:
+	case SET_PARM10:
+	case SET_PARM11:
+	case SET_PARM12:
+	case SET_PARM13:
+	case SET_PARM14:
+	case SET_PARM15:
+	case SET_PARM16:
+		if (ent->parms == NULL)
+		{
+			DebugPrint( WL_ERROR, "GET_PARM: %s %s did not have any parms set!\n", ent->classname, ent->targetname );
+			return false;	// would prefer qfalse, but I'm fitting in with what's here <sigh>
+		}
+		*value = atof( ent->parms->parm[toGet - SET_PARM1] );
+		break;
+	
+	case SET_COUNT:
+		*value = ent->count;
+		break;
+
+	case SET_HEALTH:
+		*value = ent->health;
+		break;
+
+	case SET_SKILL:
+		*value = g_spskill->integer;
+		break;
+
+	case SET_XVELOCITY://## %f="0.0" # Velocity along X axis
+		if ( ent->client == NULL )
+		{
+			DebugPrint( WL_WARNING, "GetFloat: SET_XVELOCITY, %s not a client\n", ent->targetname );
+			return false;
+		}
+		*value = ent->client->ps.velocity[0];
+		break;
+
+	case SET_YVELOCITY://## %f="0.0" # Velocity along Y axis
+		if ( ent->client == NULL )
+		{
+			DebugPrint( WL_WARNING, "GetFloat: SET_YVELOCITY, %s not a client\n", ent->targetname );
+			return false;
+		}
+		*value = ent->client->ps.velocity[1];
+		break;
+
+	case SET_ZVELOCITY://## %f="0.0" # Velocity along Z axis
+		if ( ent->client == NULL )
+		{
+			DebugPrint( WL_WARNING, "GetFloat: SET_ZVELOCITY, %s not a client\n", ent->targetname );
+			return false;
+		}
+		*value = ent->client->ps.velocity[2];
+		break;
+
+	case SET_Z_OFFSET:
+		*value = ent->currentOrigin[2] - ent->s.origin[2];
+		break;
+
+	case SET_DPITCH://## %f="0.0" # Pitch for NPC to turn to
+		if ( ent->NPC == NULL )
+		{
+			DebugPrint( WL_WARNING, "GetFloat: SET_DPITCH, %s not an NPC\n", ent->targetname );
+			return false;
+		}
+		*value = ent->NPC->desiredPitch;
+		break;
+
+	case SET_DYAW://## %f="0.0" # Yaw for NPC to turn to
+		if ( ent->NPC == NULL )
+		{
+			DebugPrint( WL_WARNING, "GetFloat: SET_DYAW, %s not an NPC\n", ent->targetname );
+			return false;
+		}
+		*value = ent->NPC->desiredPitch;
+		break;
+
+	case SET_WIDTH://## %f="0.0" # Width of NPC bounding box
+		if ( ent->NPC == NULL )
+		{
+			DebugPrint( WL_WARNING, "GetFloat: SET_WIDTH, %s not an NPC\n", ent->targetname );
+			return false;
+		}
+		*value = ent->mins[0];
+		break;
+	case SET_TIMESCALE://## %f="0.0" # Speed-up slow down game (0 - 1.0)
+		*value = g_timescale->value;
+		break;
+	case SET_CAMERA_GROUP_Z_OFS://## %s="NULL" # all ents with this cameraGroup will be focused on
+		return false;
+		break;
+
+	case SET_VISRANGE://## %f="0.0" # How far away NPC can see
+		if ( ent->NPC == NULL )
+		{
+			DebugPrint( WL_WARNING, "GetFloat: SET_VISRANGE, %s not an NPC\n", ent->targetname );
+			return false;
+		}
+		*value = ent->NPC->stats.visrange;
+		break;
+
+	case SET_EARSHOT://## %f="0.0" # How far an NPC can hear
+		if ( ent->NPC == NULL )
+		{
+			DebugPrint( WL_WARNING, "GetFloat: SET_EARSHOT, %s not an NPC\n", ent->targetname );
+			return false;
+		}
+		*value = ent->NPC->stats.earshot;
+		break;
+
+	case SET_VIGILANCE://## %f="0.0" # How often to look for enemies (0 - 1.0)
+		if ( ent->NPC == NULL )
+		{
+			DebugPrint( WL_WARNING, "GetFloat: SET_VIGILANCE, %s not an NPC\n", ent->targetname );
+			return false;
+		}
+		*value = ent->NPC->stats.vigilance;
+		break;
+
+	case SET_GRAVITY://## %f="0.0" # Change this ent's gravity - 800 default
+		if ( (ent->svFlags&SVF_CUSTOM_GRAVITY) && ent->client )
+		{
+			*value = ent->client->ps.gravity;
+		}
+		else
+		{
+			*value = g_gravity->value;
+		}
+		break;
+
+	case SET_FACEEYESCLOSED:
+	case SET_FACEEYESOPENED:
+	case SET_FACEAUX:		//## %f="0.0" # Set face to Aux expression for number of seconds
+	case SET_FACEBLINK:		//## %f="0.0" # Set face to Blink expression for number of seconds
+	case SET_FACEBLINKFROWN:	//## %f="0.0" # Set face to Blinkfrown expression for number of seconds
+	case SET_FACEFROWN:		//## %f="0.0" # Set face to Frown expression for number of seconds
+	case SET_FACENORMAL:		//## %f="0.0" # Set face to Normal expression for number of seconds
+		DebugPrint( WL_WARNING, "GetFloat: SET_FACE___ not implemented\n" );
+		return false;
+		break;
+	case SET_WAIT:		//## %f="0.0" # Change an entity's wait field
+		*value = ent->wait;
+		break;
+	case SET_FOLLOWDIST:		//## %f="0.0" # How far away to stay from leader in BS_FOLLOW_LEADER
+		if ( ent->NPC == NULL )
+		{
+			DebugPrint( WL_WARNING, "GetFloat: SET_FOLLOWDIST, %s not an NPC\n", ent->targetname );
+			return false;
+		}
+		*value = ent->NPC->followDist;
+		break;
+	//# #sep ints
+	case SET_ANIM_HOLDTIME_LOWER://## %d="0" # Hold lower anim for number of milliseconds
+		if ( ent->client == NULL )
+		{
+			DebugPrint( WL_WARNING, "GetFloat: SET_ANIM_HOLDTIME_LOWER, %s not a client\n", ent->targetname );
+			return false;
+		}
+		*value = ent->client->ps.legsAnimTimer;
+		break;
+	case SET_ANIM_HOLDTIME_UPPER://## %d="0" # Hold upper anim for number of milliseconds
+		if ( ent->client == NULL )
+		{
+			DebugPrint( WL_WARNING, "GetFloat: SET_ANIM_HOLDTIME_UPPER, %s not a client\n", ent->targetname );
+			return false;
+		}
+		*value = ent->client->ps.torsoAnimTimer;
+		break;
+	case SET_ANIM_HOLDTIME_BOTH://## %d="0" # Hold lower and upper anims for number of milliseconds
+		DebugPrint( WL_WARNING, "GetFloat: SET_ANIM_HOLDTIME_BOTH not implemented\n" );
+		return false;
+		break;
+	case SET_ARMOR://## %d="0" # Change armor
+		if ( ent->client == NULL )
+		{
+			DebugPrint( WL_WARNING, "GetFloat: SET_ARMOR, %s not a client\n", ent->targetname );
+			return false;
+		}
+		*value = ent->client->ps.stats[STAT_ARMOR];
+		break;
+	case SET_WALKSPEED://## %d="0" # Change walkSpeed
+		if ( ent->NPC == NULL )
+		{
+			DebugPrint( WL_WARNING, "GetFloat: SET_WALKSPEED, %s not an NPC\n", ent->targetname );
+			return false;
+		}
+		*value = ent->NPC->stats.walkSpeed;
+		break;
+	case SET_RUNSPEED://## %d="0" # Change runSpeed
+		if ( ent->NPC == NULL )
+		{
+			DebugPrint( WL_WARNING, "GetFloat: SET_RUNSPEED, %s not an NPC\n", ent->targetname );
+			return false;
+		}
+		*value = ent->NPC->stats.runSpeed;
+		break;
+	case SET_YAWSPEED://## %d="0" # Change yawSpeed
+		if ( ent->NPC == NULL )
+		{
+			DebugPrint( WL_WARNING, "GetFloat: SET_YAWSPEED, %s not an NPC\n", ent->targetname );
+			return false;
+		}
+		*value = ent->NPC->stats.yawSpeed;
+		break;
+	case SET_AGGRESSION://## %d="0" # Change aggression 1-5
+		if ( ent->NPC == NULL )
+		{
+			DebugPrint( WL_WARNING, "GetFloat: SET_AGGRESSION, %s not an NPC\n", ent->targetname );
+			return false;
+		}
+		*value = ent->NPC->stats.aggression;
+		break;
+	case SET_AIM://## %d="0" # Change aim 1-5
+		if ( ent->NPC == NULL )
+		{
+			DebugPrint( WL_WARNING, "GetFloat: SET_AIM, %s not an NPC\n", ent->targetname );
+			return false;
+		}
+		*value = ent->NPC->stats.aim;
+		break;
+	case SET_FRICTION://## %d="0" # Change ent's friction - 6 default
+		if ( ent->client == NULL )
+		{
+			DebugPrint( WL_WARNING, "GetFloat: SET_FRICTION, %s not a client\n", ent->targetname );
+			return false;
+		}
+		*value = ent->client->ps.friction;
+		break;
+	case SET_SHOOTDIST://## %d="0" # How far the ent can shoot - 0 uses weapon
+		if ( ent->NPC == NULL )
+		{
+			DebugPrint( WL_WARNING, "GetFloat: SET_SHOOTDIST, %s not an NPC\n", ent->targetname );
+			return false;
+		}
+		*value = ent->NPC->stats.shootDistance;
+		break;
+	case SET_HFOV://## %d="0" # Horizontal field of view
+		if ( ent->NPC == NULL )
+		{
+			DebugPrint( WL_WARNING, "GetFloat: SET_HFOV, %s not an NPC\n", ent->targetname );
+			return false;
+		}
+		*value = ent->NPC->stats.hfov;
+		break;
+	case SET_VFOV://## %d="0" # Vertical field of view
+		if ( ent->NPC == NULL )
+		{
+			DebugPrint( WL_WARNING, "GetFloat: SET_VFOV, %s not an NPC\n", ent->targetname );
+			return false;
+		}
+		*value = ent->NPC->stats.vfov;
+		break;
+	case SET_DELAYSCRIPTTIME://## %d="0" # How many seconds to wait before running delayscript
+		*value = ent->delayScriptTime - level.time;
+		break;
+	case SET_FORWARDMOVE://## %d="0" # NPC move forward -127(back) to 127
+		if ( ent->client == NULL )
+		{
+			DebugPrint( WL_WARNING, "GetFloat: SET_FORWARDMOVE, %s not a client\n", ent->targetname );
+			return false;
+		}
+		*value = ent->client->forced_forwardmove;
+		break;
+	case SET_RIGHTMOVE://## %d="0" # NPC move right -127(left) to 127
+		if ( ent->client == NULL )
+		{
+			DebugPrint( WL_WARNING, "GetFloat: SET_RIGHTMOVE, %s not a client\n", ent->targetname );
+			return false;
+		}
+		*value = ent->client->forced_rightmove;
+		break;
+	case SET_STARTFRAME:	//## %d="0" # frame to start animation sequence on
+		*value = ent->startFrame;
+		break;
+	case SET_ENDFRAME:	//## %d="0" # frame to end animation sequence on
+		*value = ent->endFrame;
+		break;
+	case SET_ANIMFRAME:	//## %d="0" # of current frame
+		*value = ent->s.frame;
+		break;
+
+	case SET_SHOT_SPACING://## %d="1000" # Time between shots for an NPC - reset to defaults when changes weapon
+		if ( ent->NPC == NULL )
+		{
+			DebugPrint( WL_WARNING, "GetFloat: SET_SHOT_SPACING, %s not an NPC\n", ent->targetname );
+			return false;
+		}
+		*value = ent->NPC->burstSpacing;
+		break;
+	case SET_MISSIONSTATUSTIME://## %d="0" # Amount of time until Mission Status should be shown after death
+		*value = cg.missionStatusDeadTime - level.time;
+		break;
+	//# #sep booleans
+	case SET_IGNOREPAIN://## %t="BOOL_TYPES" # Do not react to pain
+		if ( ent->NPC == NULL )
+		{
+			DebugPrint( WL_WARNING, "GetFloat: SET_IGNOREPAIN, %s not an NPC\n", ent->targetname );
+			return false;
+		}
+		*value = ent->NPC->ignorePain;
+		break;
+	case SET_IGNOREENEMIES://## %t="BOOL_TYPES" # Do not acquire enemies
+		*value = (ent->svFlags&SVF_IGNORE_ENEMIES);
+		break;
+	case SET_IGNOREALERTS://## Do not get enemy set by allies in area(ambush)
+		if ( ent->NPC == NULL )
+		{
+			DebugPrint( WL_WARNING, "GetFloat: SET_IGNOREALERTS, %s not an NPC\n", ent->targetname );
+			return false;
+		}
+		*value = (ent->NPC->scriptFlags&SCF_IGNORE_ALERTS);
+
+	case SET_DONTSHOOT://## %t="BOOL_TYPES" # Others won't shoot you
+		*value = (ent->flags&FL_DONT_SHOOT);
+		break;
+	case SET_NOTARGET://## %t="BOOL_TYPES" # Others won't pick you as enemy
+		*value = (ent->flags&FL_NOTARGET);
+		break;
+	case SET_DONTFIRE://## %t="BOOL_TYPES" # Don't fire your weapon
+		if ( ent->NPC == NULL )
+		{
+			DebugPrint( WL_WARNING, "GetFloat: SET_DONTFIRE, %s not an NPC\n", ent->targetname );
+			return false;
+		}
+		*value = (ent->NPC->scriptFlags&SCF_DONT_FIRE);
+		break;
+
+	case SET_LOCKED_ENEMY://## %t="BOOL_TYPES" # Keep current enemy until dead
+		*value = (ent->svFlags&SVF_LOCKEDENEMY);
+		break;
+	case SET_CROUCHED://## %t="BOOL_TYPES" # Force NPC to crouch
+		if ( ent->NPC == NULL )
+		{
+			DebugPrint( WL_WARNING, "GetFloat: SET_CROUCHED, %s not an NPC\n", ent->targetname );
+			return false;
+		}
+		*value = (ent->NPC->scriptFlags&SCF_CROUCHED);
+		break;
+	case SET_WALKING://## %t="BOOL_TYPES" # Force NPC to move at walkSpeed
+		if ( ent->NPC == NULL )
+		{
+			DebugPrint( WL_WARNING, "GetFloat: SET_WALKING, %s not an NPC\n", ent->targetname );
+			return false;
+		}
+		*value = (ent->NPC->scriptFlags&SCF_WALKING);
+		break;
+	case SET_RUNNING://## %t="BOOL_TYPES" # Force NPC to move at runSpeed
+		if ( ent->NPC == NULL )
+		{
+			DebugPrint( WL_WARNING, "GetFloat: SET_RUNNING, %s not an NPC\n", ent->targetname );
+			return false;
+		}
+		*value = (ent->NPC->scriptFlags&SCF_RUNNING);
+		break;
+	case SET_CHASE_ENEMIES://## %t="BOOL_TYPES" # NPC will chase after enemies
+		if ( ent->NPC == NULL )
+		{
+			DebugPrint( WL_WARNING, "GetFloat: SET_CHASE_ENEMIES, %s not an NPC\n", ent->targetname );
+			return false;
+		}
+		*value = (ent->NPC->scriptFlags&SCF_CHASE_ENEMIES);
+		break;
+	case SET_LOOK_FOR_ENEMIES://## %t="BOOL_TYPES" # NPC will be on the lookout for enemies
+		if ( ent->NPC == NULL )
+		{
+			DebugPrint( WL_WARNING, "GetFloat: SET_LOOK_FOR_ENEMIES, %s not an NPC\n", ent->targetname );
+			return false;
+		}
+		*value = (ent->NPC->scriptFlags&SCF_LOOK_FOR_ENEMIES);
+		break;
+	case SET_FACE_MOVE_DIR://## %t="BOOL_TYPES" # NPC will face in the direction it's moving
+		if ( ent->NPC == NULL )
+		{
+			DebugPrint( WL_WARNING, "GetFloat: SET_FACE_MOVE_DIR, %s not an NPC\n", ent->targetname );
+			return false;
+		}
+		*value = (ent->NPC->scriptFlags&SCF_FACE_MOVE_DIR);
+		break;
+	case SET_FORCED_MARCH://## %t="BOOL_TYPES" # Force NPC to move at runSpeed
+		if ( ent->NPC == NULL )
+		{
+			DebugPrint( WL_WARNING, "GetFloat: SET_FORCED_MARCH, %s not an NPC\n", ent->targetname );
+			return false;
+		}
+		*value = (ent->NPC->scriptFlags&SET_FORCED_MARCH);
+		break;
+	case SET_UNDYING://## %t="BOOL_TYPES" # Can take damage down to 1 but not die
+		*value = (ent->flags&FL_UNDYING);
+		break;
+	case SET_NOAVOID://## %t="BOOL_TYPES" # Will not avoid other NPCs or architecture
+		if ( ent->NPC == NULL )
+		{
+			DebugPrint( WL_WARNING, "GetFloat: SET_NOAVOID, %s not an NPC\n", ent->targetname );
+			return false;
+		}
+		*value = (ent->NPC->aiFlags&NPCAI_NO_COLL_AVOID);
+		break;
+
+	case SET_SOLID://## %t="BOOL_TYPES" # Make yourself notsolid or solid
+		*value = ent->contents;
+		break;
+	case SET_PLAYER_USABLE://## %t="BOOL_TYPES" # Can be activateby the player's "use" button
+		*value = (ent->svFlags&SVF_PLAYER_USABLE);
+		break;
+	case SET_LOOP_ANIM://## %t="BOOL_TYPES" # For non-NPCs: loop your animation sequence
+		*value = ent->loopAnim;
+		break;
+	case SET_INTERFACE://## %t="BOOL_TYPES" # Player interface on/off
+		DebugPrint( WL_WARNING, "GetFloat: SET_INTERFACE not implemented\n" );
+		return false;
+		break;
+	case SET_SHIELDS://## %t="BOOL_TYPES" # NPC has no shields (Borg do not adapt)
+		if ( ent->NPC == NULL )
+		{
+			DebugPrint( WL_WARNING, "GetFloat: SET_SHIELDS, %s not an NPC\n", ent->targetname );
+			return false;
+		}
+		*value = (ent->NPC->aiFlags&NPCAI_SHIELDS);
+	case SET_SABERACTIVE:
+		if ( ent->client == NULL )
+		{
+			DebugPrint( WL_WARNING, "GetFloat: SET_SABERACTIVE, %s not a client\n", ent->targetname );
+			return false;
+		}
+		*value = (ent->client->ps.SaberActive());
+		break;
+	case SET_INVISIBLE://## %t="BOOL_TYPES" # Makes an NPC not solid and not visible
+		*value = (ent->s.eFlags&EF_NODRAW);
+		break;
+	case SET_VAMPIRE://## %t="BOOL_TYPES" # Makes an NPC not solid and not visible
+		if ( !ent->client )
+		{
+			return false;
+		}
+		else
+		{
+			*value = (ent->client->ps.powerups[PW_DISINT_2]>level.time);
+		}
+		break;
+	case SET_FORCE_INVINCIBLE://## %t="BOOL_TYPES" # Makes an NPC not solid and not visible
+		if ( !ent->client )
+		{
+			return false;
+		}
+		else
+		{
+			*value = (ent->client->ps.powerups[PW_INVINCIBLE]>level.time);
+		}
+		break;
+	case SET_GREET_ALLIES://## %t="BOOL_TYPES" # Makes an NPC greet teammates
+		if ( ent->NPC == NULL )
+		{
+			DebugPrint( WL_WARNING, "GetFloat: SET_GREET_ALLIES, %s not an NPC\n", ent->targetname );
+			return false;
+		}
+		*value = (ent->NPC->aiFlags&NPCAI_GREET_ALLIES);
+		break;
+	case SET_VIDEO_FADE_IN://## %t="BOOL_TYPES" # Makes video playback fade in
+		DebugPrint( WL_WARNING, "GetFloat: SET_VIDEO_FADE_IN not implemented\n" );
+		return false;
+		break;
+	case SET_VIDEO_FADE_OUT://## %t="BOOL_TYPES" # Makes video playback fade out
+		DebugPrint( WL_WARNING, "GetFloat: SET_VIDEO_FADE_OUT not implemented\n" );
+		return false;
+		break;
+	case SET_PLAYER_LOCKED://## %t="BOOL_TYPES" # Makes it so player cannot move
+		*value = player_locked;
+		break;
+	case SET_LOCK_PLAYER_WEAPONS://## %t="BOOL_TYPES" # Makes it so player cannot switch weapons
+		*value = (ent->flags&FL_LOCK_PLAYER_WEAPONS);
+		break;
+	case SET_NO_IMPACT_DAMAGE://## %t="BOOL_TYPES" # Makes it so player cannot switch weapons
+		*value = (ent->flags&FL_NO_IMPACT_DMG);
+		break;
+	case SET_NO_KNOCKBACK://## %t="BOOL_TYPES" # Stops this ent from taking knockback from weapons
+		*value = (ent->flags&FL_NO_KNOCKBACK);
+		break;
+	case SET_ALT_FIRE://## %t="BOOL_TYPES" # Force NPC to use altfire when shooting
+		if ( ent->NPC == NULL )
+		{
+			DebugPrint( WL_WARNING, "GetFloat: SET_ALT_FIRE, %s not an NPC\n", ent->targetname );
+			return false;
+		}
+		*value = (ent->NPC->scriptFlags&SCF_ALT_FIRE);
+		break;
+	case SET_NO_RESPONSE://## %t="BOOL_TYPES" # NPCs will do generic responses when this is on (usescripts override generic responses as well)
+		if ( ent->NPC == NULL )
+		{
+			DebugPrint( WL_WARNING, "GetFloat: SET_NO_RESPONSE, %s not an NPC\n", ent->targetname );
+			return false;
+		}
+		*value = (ent->NPC->scriptFlags&SCF_NO_RESPONSE);
+		break;
+	case SET_INVINCIBLE://## %t="BOOL_TYPES" # Completely unkillable
+		*value = (ent->flags&FL_GODMODE);
+		break;
+	case SET_MISSIONSTATUSACTIVE:	//# Turns on Mission Status Screen
+		*value = cg.missionStatusShow;
+		break;
+	case SET_NO_COMBAT_TALK://## %t="BOOL_TYPES" # NPCs will not do their combat talking noises when this is on
+		if ( ent->NPC == NULL )
+		{
+			DebugPrint( WL_WARNING, "GetFloat: SET_NO_COMBAT_TALK, %s not an NPC\n", ent->targetname );
+			return false;
+		}
+		*value = (ent->NPC->scriptFlags&SCF_NO_COMBAT_TALK);
+		break;
+	case SET_NO_ALERT_TALK://## %t="BOOL_TYPES" # NPCs will not do their combat talking noises when this is on
+		if ( ent->NPC == NULL )
+		{
+			DebugPrint( WL_WARNING, "GetFloat: SET_NO_ALERT_TALK, %s not an NPC\n", ent->targetname );
+			return false;
+		}
+		*value = (ent->NPC->scriptFlags&SCF_NO_ALERT_TALK);
+		break;
+	case SET_USE_CP_NEAREST://## %t="BOOL_TYPES" # NPCs will use their closest combat points, not try and find ones next to the player, or flank player
+		if ( ent->NPC == NULL )
+		{
+			DebugPrint( WL_WARNING, "GetFloat: SET_USE_CP_NEAREST, %s not an NPC\n", ent->targetname );
+			return false;
+		}
+		*value = (ent->NPC->scriptFlags&SCF_USE_CP_NEAREST);
+		break;
+	case SET_DISMEMBERABLE://## %t="BOOL_TYPES" # NPC will not be affected by force powers
+		if ( ent->client == NULL )
+		{
+			DebugPrint( WL_WARNING, "GetFloat: SET_DISMEMBERABLE, %s not a client\n", ent->targetname );
+			return false;
+		}
+		*value = !(ent->client->dismembered);
+		break;
+	case SET_NO_FORCE:
+		if ( ent->NPC == NULL )
+		{
+			DebugPrint( WL_WARNING, "GetFloat: SET_NO_FORCE, %s not an NPC\n", ent->targetname );
+			return false;
+		}
+		*value = (ent->NPC->scriptFlags&SCF_NO_FORCE);
+		break;
+	case SET_NO_ACROBATICS:
+		if ( ent->NPC == NULL )
+		{
+			DebugPrint( WL_WARNING, "GetFloat: SET_NO_ACROBATICS, %s not an NPC\n", ent->targetname );
+			return false;
+		}
+		*value = (ent->NPC->scriptFlags&SCF_NO_ACROBATICS);
+		break;
+	case SET_USE_SUBTITLES:
+		if ( ent->NPC == NULL )
+		{
+			DebugPrint( WL_WARNING, "GetFloat: SET_USE_SUBTITLES, %s not an NPC\n", ent->targetname );
+			return false;
+		}
+		*value = (ent->NPC->scriptFlags&SCF_USE_SUBTITLES);
+		break;
+	case SET_NO_FALLTODEATH://## %t="BOOL_TYPES" # NPC will not be affected by force powers
+		if ( ent->NPC == NULL )
+		{
+			DebugPrint( WL_WARNING, "GetFloat: SET_NO_FALLTODEATH, %s not an NPC\n", ent->targetname );
+			return false;
+		}
+		*value = (ent->NPC->scriptFlags&SCF_NO_FALLTODEATH);
+		break;
+	case SET_MORELIGHT://## %t="BOOL_TYPES" # NPCs will use their closest combat points, not try and find ones next to the player, or flank player
+		if ( ent->NPC == NULL )
+		{
+			DebugPrint( WL_WARNING, "GetFloat: SET_MORELIGHT, %s not an NPC\n", ent->targetname );
+			return false;
+		}
+		*value = (ent->NPC->scriptFlags&SCF_MORELIGHT);
+		break;
+	case SET_TREASONED://## %t="BOOL_TYPES" # Player has turned on his own- scripts will stop: NPCs will turn on him and level changes load the brig
+		DebugPrint( WL_VERBOSE, "SET_TREASONED is disabled, do not use\n" );
+		*value = 0;//(ffireLevel>=FFIRE_LEVEL_RETALIATION);
+		break;
+	case SET_DISABLE_SHADER_ANIM:	//## %t="BOOL_TYPES" # Shaders won't animate
+		*value = (ent->s.eFlags & EF_DISABLE_SHADER_ANIM);
+		break;
+	case SET_SHADER_ANIM:	//## %t="BOOL_TYPES" # Shader will be under frame control
+		*value = (ent->s.eFlags & EF_SHADER_ANIM);
+		break;
+
+	case SET_OBJECTIVE_LIGHTSIDE:
+	{
+		*value = level.clients[0].sess.mission_objectives[LIGHTSIDE_OBJ].status;
+		break;
+	}
+
+	// kef 4/16/03 -- just trying to put together some scripted meta-AI for swoop riders
+	case SET_DISTSQRD_TO_PLAYER:
+		{
+			vec3_t distSquared;
+
+			VectorSubtract(player->currentOrigin, ent->s.origin, distSquared);
+			
+			*value = VectorLengthSquared(distSquared);
+			break;
+		}
+
+	default:
+		if ( VariableDeclared( name ) != VTYPE_FLOAT )
+			return false;
+
+		return GetFloatVariable( name, value );
+	}
+
+	return true;
+}
+
+int		CQuake3GameInterface::GetVector( int entID, const char *name, vec3_t value )
+{
+	gentity_t	*ent = &g_entities[entID];
+	if ( !ent )
+	{
+		return false;
+	}
+
+	int toGet = GetIDForString( setTable, name );	//FIXME: May want to make a "getTable" as well
+	//FIXME: I'm getting really sick of these huge switch statements!
+
+	//NOTENOTE: return true if the value was correctly obtained
+	switch ( toGet )
+	{
+	case SET_PARM1:
+	case SET_PARM2:
+	case SET_PARM3:
+	case SET_PARM4:
+	case SET_PARM5:
+	case SET_PARM6:
+	case SET_PARM7:
+	case SET_PARM8:
+	case SET_PARM9:
+	case SET_PARM10:
+	case SET_PARM11:
+	case SET_PARM12:
+	case SET_PARM13:
+	case SET_PARM14:
+	case SET_PARM15:
+	case SET_PARM16:
+		sscanf( ent->parms->parm[toGet - SET_PARM1], "%f %f %f", &value[0], &value[1], &value[2] );
+		break;
+
+	case SET_ORIGIN:
+		VectorCopy(ent->currentOrigin, value);
+		break;
+
+	case SET_ANGLES:
+		VectorCopy(ent->currentAngles, value);
+		break;
+	
+	case SET_TELEPORT_DEST://## %v="0.0 0.0 0.0" # Set origin here as soon as the area is clear
+		DebugPrint( WL_WARNING, "GetVector: SET_TELEPORT_DEST not implemented\n" );
+		return false;
+		break;
+
+	default:
+
+		if ( VariableDeclared( name ) != VTYPE_VECTOR )
+			return false;
+
+		return GetVectorVariable( name, value );
+	}
+
+	return true;
+}
+
+int		CQuake3GameInterface::GetString( int entID, const char *name, char **value )
+{
+	gentity_t	*ent = &g_entities[entID];
+	if ( !ent )
+	{
+		return false;
+	}
+
+	int toGet = GetIDForString( setTable, name );	//FIXME: May want to make a "getTable" as well
+
+	switch ( toGet )
+	{
+	case SET_ANIM_BOTH:
+		*value = (char *) Q3_GetAnimBoth( ent );
+
+		if ( VALIDSTRING( value ) == false )
+			return false;
+
+		break;
+
+	case SET_PARM1:
+	case SET_PARM2:
+	case SET_PARM3:
+	case SET_PARM4:
+	case SET_PARM5:
+	case SET_PARM6:
+	case SET_PARM7:
+	case SET_PARM8:
+	case SET_PARM9:
+	case SET_PARM10:
+	case SET_PARM11:
+	case SET_PARM12:
+	case SET_PARM13:
+	case SET_PARM14:
+	case SET_PARM15:
+	case SET_PARM16:
+		if ( ent->parms )
+		{
+			*value = (char *) ent->parms->parm[toGet - SET_PARM1];
+		}
+		else
+		{
+			DebugPrint( WL_WARNING, "GetString: invalid ent %s has no parms!\n", ent->targetname );
+			return false;
+		}
+		break;
+
+	case SET_TARGET:
+		*value = (char *) ent->target;
+		break;
+
+	case SET_LOCATION:
+		*value = G_GetLocationForEnt( ent );
+		if ( !value || !value[0] )
+		{
+			return false;
+		}
+		break;
+
+	//# #sep Scripts and other file paths
+	case SET_SPAWNSCRIPT://## %s="NULL" !!"W:\game\base\scripts\!!#*.txt" # Script to run when spawned //0 - do not change these, these are equal to BSET_SPAWN, etc
+		*value = ent->behaviorSet[BSET_SPAWN];
+		break;
+	case SET_USESCRIPT://## %s="NULL" !!"W:\game\base\scripts\!!#*.txt" # Script to run when used
+		*value = ent->behaviorSet[BSET_USE];
+		break;
+	case SET_AWAKESCRIPT://## %s="NULL" !!"W:\game\base\scripts\!!#*.txt" # Script to run when startled
+		*value = ent->behaviorSet[BSET_AWAKE];
+		break;
+	case SET_ANGERSCRIPT://## %s="NULL" !!"W:\game\base\scripts\!!#*.txt" # Script run when find an enemy for the first time
+		*value = ent->behaviorSet[BSET_ANGER];
+		break;
+	case SET_ATTACKSCRIPT://## %s="NULL" !!"W:\game\base\scripts\!!#*.txt" # Script to run when you shoot
+		*value = ent->behaviorSet[BSET_ATTACK];
+		break;
+	case SET_VICTORYSCRIPT://## %s="NULL" !!"W:\game\base\scripts\!!#*.txt" # Script to run when killed someone
+		*value = ent->behaviorSet[BSET_VICTORY];
+		break;
+	case SET_LOSTENEMYSCRIPT://## %s="NULL" !!"W:\game\base\scripts\!!#*.txt" # Script to run when you can't find your enemy
+		*value = ent->behaviorSet[BSET_LOSTENEMY];
+		break;
+	case SET_PAINSCRIPT://## %s="NULL" !!"W:\game\base\scripts\!!#*.txt" # Script to run when hit
+		*value = ent->behaviorSet[BSET_PAIN];
+		break;
+	case SET_FLEESCRIPT://## %s="NULL" !!"W:\game\base\scripts\!!#*.txt" # Script to run when hit and low health
+		*value = ent->behaviorSet[BSET_FLEE];
+		break;
+	case SET_DEATHSCRIPT://## %s="NULL" !!"W:\game\base\scripts\!!#*.txt" # Script to run when killed
+		*value = ent->behaviorSet[BSET_DEATH];
+		break;
+	case SET_DELAYEDSCRIPT://## %s="NULL" !!"W:\game\base\scripts\!!#*.txt" # Script to run after a delay
+		*value = ent->behaviorSet[BSET_DELAYED];
+		break;
+	case SET_BLOCKEDSCRIPT://## %s="NULL" !!"W:\game\base\scripts\!!#*.txt" # Script to run when blocked by teammate
+		*value = ent->behaviorSet[BSET_BLOCKED];
+		break;
+	case SET_FFIRESCRIPT://## %s="NULL" !!"W:\game\base\scripts\!!#*.txt" # Script to run when player has shot own team repeatedly
+		*value = ent->behaviorSet[BSET_FFIRE];
+		break;
+	case SET_FFDEATHSCRIPT://## %s="NULL" !!"W:\game\base\scripts\!!#*.txt" # Script to run when player kills a teammate
+		*value = ent->behaviorSet[BSET_FFDEATH];
+		break;
+
+	//# #sep Standard strings
+	case SET_ENEMY://## %s="NULL" # Set enemy by targetname
+		if ( ent->enemy != NULL )
+		{
+			*value = ent->enemy->targetname;
+		}
+		else return false;
+		break;
+	case SET_LEADER://## %s="NULL" # Set for BS_FOLLOW_LEADER
+		if ( ent->client == NULL )
+		{
+			DebugPrint( WL_WARNING, "GetString: SET_LEADER, %s not a client\n", ent->targetname );
+			return false;
+		}
+		else if ( ent->client->leader )
+		{
+			*value = ent->client->leader->targetname;
+		}
+		else return false;
+		break;
+	case SET_CAPTURE://## %s="NULL" # Set captureGoal by targetname
+		if ( ent->NPC == NULL )
+		{
+			DebugPrint( WL_WARNING, "GetString: SET_CAPTURE, %s not an NPC\n", ent->targetname );
+			return false;
+		}
+		else if ( ent->NPC->captureGoal != NULL )
+		{
+			*value = ent->NPC->captureGoal->targetname;
+		}
+		else return false;
+		break;
+
+	case SET_TARGETNAME://## %s="NULL" # Set/change your targetname
+		*value = ent->targetname;
+		break;
+	case SET_PAINTARGET://## %s="NULL" # Set/change what to use when hit
+		*value = ent->paintarget;
+		break;
+	case SET_PLAYERMODEL:
+		*value = ent->NPC_type;
+		break;
+	case SET_CAMERA_GROUP://## %s="NULL" # all ents with this cameraGroup will be focused on
+		*value = ent->cameraGroup;
+		break;
+	case SET_CAMERA_GROUP_TAG://## %s="NULL" # all ents with this cameraGroup will be focused on
+		return false;
+		break;
+	case SET_LOOK_TARGET://## %s="NULL" # object for NPC to look at
+		if ( ent->client == NULL )
+		{
+			DebugPrint( WL_WARNING, "GetString: SET_LOOK_TARGET, %s not a client\n", ent->targetname );
+			return false;
+		}
+		else
+		{
+			gentity_t *lookTarg = &g_entities[ent->client->renderInfo.lookTarget];
+			if ( lookTarg != NULL )
+			{
+				*value = lookTarg->targetname;
+			}
+			else return false;
+		}
+		break;
+	case SET_TARGET2://## %s="NULL" # Set/change your target2: on NPC's: this fires when they're knocked out by the red hypo
+		*value = ent->target2;
+		break;
+
+	case SET_REMOVE_TARGET://## %s="NULL" # Target that is fired when someone completes the BS_REMOVE behaviorState
+		*value = ent->target3;
+		break;
+	case SET_WEAPON:
+		if ( ent->client == NULL )
+		{
+			DebugPrint( WL_WARNING, "GetString: SET_WEAPON, %s not a client\n", ent->targetname );
+			return false;
+		}
+		else
+		{
+			*value = (char *)GetStringForID( WPTable, ent->client->ps.weapon );
+		}
+		break;
+
+	case SET_ITEM:
+		if ( ent->client == NULL )
+		{
+			DebugPrint( WL_WARNING, "GetString: SET_ITEM, %s not a client\n", ent->targetname );
+			return false;
+		}
+		else
+		{
+		//	*value = (char *)GetStringForID( WPTable, ent->client->ps.weapon );
+		}
+		break;
+	case SET_MUSIC_STATE:
+		*value = (char *)GetStringForID( DMSTable, level.dmState );
+		break;
+	//The below cannot be gotten
+	case SET_NAVGOAL://## %s="NULL" # *Move to this navgoal then continue script
+		DebugPrint( WL_WARNING, "GetString: SET_NAVGOAL not implemented\n" );
+		return false;
+		break;
+	case SET_VIEWTARGET://## %s="NULL" # Set angles toward ent by targetname
+		DebugPrint( WL_WARNING, "GetString: SET_VIEWTARGET not implemented\n" );
+		return false;
+		break;
+	case SET_WATCHTARGET://## %s="NULL" # Set angles toward ent by targetname
+		if ( ent && ent->NPC && ent->NPC->watchTarget )
+		{
+			*value = ent->NPC->watchTarget->targetname;
+		}
+		else
+		{
+			DebugPrint( WL_WARNING, "GetString: SET_WATCHTARGET no watchTarget!\n" );
+			return false;
+		}
+		break;
+	case SET_VIEWENTITY:
+		DebugPrint( WL_WARNING, "GetString: SET_VIEWENTITY not implemented\n" );
+		return false;
+		break;
+	case SET_CAPTIONTEXTCOLOR:	//## %s=""  # Color of text RED:WHITE:BLUE: YELLOW
+		DebugPrint( WL_WARNING, "GetString: SET_CAPTIONTEXTCOLOR not implemented\n" );
+		return false;
+		break;
+	case SET_CENTERTEXTCOLOR:	//## %s=""  # Color of text RED:WHITE:BLUE: YELLOW
+		DebugPrint( WL_WARNING, "GetString: SET_CENTERTEXTCOLOR not implemented\n" );
+		return false;
+		break;
+	case SET_SCROLLTEXTCOLOR:	//## %s=""  # Color of text RED:WHITE:BLUE: YELLOW
+		DebugPrint( WL_WARNING, "GetString: SET_SCROLLTEXTCOLOR not implemented\n" );
+		return false;
+		break;
+	case SET_COPY_ORIGIN://## %s="targetname"  # Copy the origin of the ent with targetname to your origin
+		DebugPrint( WL_WARNING, "GetString: SET_COPY_ORIGIN not implemented\n" );
+		return false;
+		break;
+	case SET_DEFEND_TARGET://## %s="targetname"  # This NPC will attack the target NPC's enemies
+		DebugPrint( WL_WARNING, "GetString: SET_COPY_ORIGIN not implemented\n" );
+		return false;
+		break;
+	case SET_VIDEO_PLAY://## %s="filename" !!"W:\game\base\video\!!#*.roq" # Play a Video (inGame)
+		DebugPrint( WL_WARNING, "GetString: SET_VIDEO_PLAY not implemented\n" );
+		return false;
+		break;
+	case SET_LOADGAME://## %s="exitholodeck" # Load the savegame that was auto-saved when you started the holodeck
+		DebugPrint( WL_WARNING, "GetString: SET_LOADGAME not implemented\n" );
+		return false;
+		break;
+	case SET_LOCKYAW://## %s="off"  # Lock legs to a certain yaw angle (or "off" or "auto" uses current)
+		DebugPrint( WL_WARNING, "GetString: SET_LOCKYAW not implemented\n" );
+		return false;
+		break;
+	case SET_SCROLLTEXT:	//## %s="" # key of text string to print
+		DebugPrint( WL_WARNING, "GetString: SET_SCROLLTEXT not implemented\n" );
+		return false;
+		break;
+	case SET_LCARSTEXT:	//## %s="" # key of text string to print in LCARS frame
+		DebugPrint( WL_WARNING, "GetString: SET_LCARSTEXT not implemented\n" );
+		return false;
+		break;
+
+	case SET_CENTERTEXT:
+		DebugPrint( WL_WARNING, "GetString: SET_CENTERTEXT not implemented\n" );
+		return false;
+		break;
+
+	default:
+		if ( VariableDeclared( name ) != VTYPE_STRING )
+			return false;
+
+		return GetStringVariable( name, (const char **) value );
+	}
+
+	return true;
+}
+
+int		CQuake3GameInterface::Evaluate( int p1Type, const char *p1, int p2Type, const char *p2, int operatorType )
+{
+	float	f1=0, f2=0;
+	vec3_t	v1, v2;
+	char	*c1=0, *c2=0;
+	int		i1=0, i2=0;
+
+	//Always demote to int on float to integer comparisons
+	if ( ( ( p1Type == TK_FLOAT ) && ( p2Type == TK_INT ) ) || ( ( p1Type == TK_INT ) && ( p2Type == TK_FLOAT ) ) )
+	{
+		p1Type = TK_INT;
+		p2Type = TK_INT;
+	}
+
+	//Cannot compare two disimilar types
+	if ( p1Type != p2Type )
+	{
+		DebugPrint( WL_ERROR, "Evaluate comparing two disimilar types!\n");
+		return false;
+	}
+
+	//Format the parameters
+	switch ( p1Type )
+	{
+	case TK_FLOAT:
+		sscanf( p1, "%f", &f1 );
+		sscanf( p2, "%f", &f2 );
+		break;
+
+	case TK_INT:
+		sscanf( p1, "%d", &i1 );
+		sscanf( p2, "%d", &i2 );
+		break;
+
+	case TK_VECTOR:
+		sscanf( p1, "%f %f %f", &v1[0], &v1[1], &v1[2] );
+		sscanf( p2, "%f %f %f", &v2[0], &v2[1], &v2[2] );
+		break;
+
+	case TK_STRING:
+	case TK_IDENTIFIER:
+		c1 = (char *) p1;
+		c2 = (char *) p2;
+		break;
+
+	default:
+		DebugPrint( WL_WARNING, "Evaluate unknown type used!\n");
+		return false;
+	}
+
+	//Compare them and return the result
+
+	//FIXME: YUCK!!!  Better way to do this?
+
+	switch ( operatorType )
+	{
+
+	//
+	//	EQUAL TO
+	//
+	case TK_EQUALS:
+
+		switch ( p1Type )
+		{
+		case TK_FLOAT:
+			return (int) ( f1 == f2 );
+			break;
+
+		case TK_INT:
+			return (int) ( i1 == i2 );
+			break;
+
+		case TK_VECTOR:
+			return (int) VectorCompare( v1, v2 );
+			break;
+
+		case TK_STRING:
+		case TK_IDENTIFIER:
+			return (int) !stricmp( c1, c2 );	//NOTENOTE: The script uses proper string comparison logic (ex. ( a == a ) == true )
+			break;
+
+		default:
+			DebugPrint( WL_ERROR, "Evaluate unknown type used!\n");
+			return false;
+		}
+
+		break;
+
+	//
+	//	GREATER THAN
+	//
+
+	case TK_GREATER_THAN:
+
+		switch ( p1Type )
+		{
+		case TK_FLOAT:
+			return (int) ( f1 > f2 );
+			break;
+
+		case TK_INT:
+			return (int) ( i1 > i2 );
+			break;
+
+		case TK_VECTOR:
+			DebugPrint( WL_ERROR, "Evaluate vector comparisons of type GREATER THAN cannot be performed!");
+			return false;
+			break;
+
+		case TK_STRING:
+		case TK_IDENTIFIER:
+			DebugPrint( WL_ERROR, "Evaluate string comparisons of type GREATER THAN cannot be performed!");
+			return false;
+			break;
+
+		default:
+			DebugPrint( WL_ERROR, "Evaluate unknown type used!\n");
+			return false;
+		}
+
+		break;
+
+	//
+	//	LESS THAN
+	//
+
+	case TK_LESS_THAN:
+
+		switch ( p1Type )
+		{
+		case TK_FLOAT:
+			return (int) ( f1 < f2 );
+			break;
+
+		case TK_INT:
+			return (int) ( i1 < i2 );
+			break;
+
+		case TK_VECTOR:
+			DebugPrint( WL_ERROR, "Evaluate vector comparisons of type LESS THAN cannot be performed!");
+			return false;
+			break;
+
+		case TK_STRING:
+		case TK_IDENTIFIER:
+			DebugPrint( WL_ERROR, "Evaluate string comparisons of type LESS THAN cannot be performed!");
+			return false;
+			break;
+
+		default:
+			DebugPrint( WL_ERROR, "Evaluate unknown type used!\n");
+			return false;
+		}
+
+		break;
+
+	//
+	//	NOT
+	//
+
+	case TK_NOT:	//NOTENOTE: Implied "NOT EQUAL TO"
+
+		switch ( p1Type )
+		{
+		case TK_FLOAT:
+			return (int) ( f1 != f2 );
+			break;
+
+		case TK_INT:
+			return (int) ( i1 != i2 );
+			break;
+
+		case TK_VECTOR:
+			return (int) !VectorCompare( v1, v2 );
+			break;
+
+		case TK_STRING:
+		case TK_IDENTIFIER:
+			return (int) stricmp( c1, c2 );
+			break;
+
+		default:
+			DebugPrint( WL_ERROR, "Evaluate unknown type used!\n");
+			return false;
+		}
+
+		break;
+	
+	//
+	//	GREATER THAN OR EQUAL TO
+	//
+
+	case TK_GE:
+
+		switch ( p1Type )
+		{
+		case TK_FLOAT:
+			return (int) ( f1 >= f2 );
+			break;
+
+		case TK_INT:
+			return (int) ( i1 >= i2 );
+			break;
+
+		case TK_VECTOR:
+			DebugPrint( WL_ERROR, "Evaluate vector comparisons of type GREATER THAN OR EQUAL TO cannot be performed!");
+			return false;
+			break;
+
+		case TK_STRING:
+		case TK_IDENTIFIER:
+			DebugPrint( WL_ERROR, "Evaluate string comparisons of type GREATER THAN OR EQUAL TO cannot be performed!");
+			return false;
+			break;
+
+		default:
+			DebugPrint( WL_ERROR, "Evaluate unknown type used!\n");
+			return false;
+		}
+
+		break;
+
+	//
+	//	LESS THAN OR EQUAL TO
+	//
+
+	case TK_LE:
+
+		switch ( p1Type )
+		{
+		case TK_FLOAT:
+			return (int) ( f1 <= f2 );
+			break;
+
+		case TK_INT:
+			return (int) ( i1 <= i2 );
+			break;
+
+		case TK_VECTOR:
+			DebugPrint( WL_ERROR, "Evaluate vector comparisons of type LESS THAN OR EQUAL TO cannot be performed!");
+			return false;
+			break;
+
+		case TK_STRING:
+		case TK_IDENTIFIER:
+			DebugPrint( WL_ERROR, "Evaluate string comparisons of type LESS THAN OR EQUAL TO cannot be performed!");
+			return false;
+			break;
+
+		default:
+			DebugPrint( WL_ERROR, "Evaluate unknown type used!\n");
+			return false;
+		}
+
+		break;
+
+	default:
+		DebugPrint( WL_ERROR, "Evaluate unknown operator used!\n");
+		break;
+	}
+
+	return false;
+}
+
+void	CQuake3GameInterface::DeclareVariable( int type, const char *name )
+{
+	//Cannot declare the same variable twice
+	if ( VariableDeclared( name ) != VTYPE_NONE )
+		return;
+
+	if ( m_numVariables > MAX_VARIABLES )
+	{
+		DebugPrint( WL_ERROR, "too many variables already declared, maximum is %d\n", MAX_VARIABLES );
+		return;
+	}
+
+	switch( type )
+	{
+	case TK_FLOAT:
+		m_varFloats[ name ] = 0.0f;
+		break;
+
+	case TK_STRING:		
+		m_varStrings[ name ] = "NULL";
+		break;
+
+
+	case TK_VECTOR:
+		m_varVectors[ name ] = "0.0 0.0 0.0";
+		break;
+
+	default:
+		DebugPrint( WL_ERROR, "unknown 'type' for declare() function!\n" );
+		return;
+		break;
+	}
+
+	m_numVariables++;
+}
+
+void	CQuake3GameInterface::FreeVariable( const char *name )
+{
+	//Check the strings
+	varString_m::iterator	vsi = m_varStrings.find( name );
+
+	if ( vsi != m_varStrings.end() )
+	{
+		m_varStrings.erase( vsi );
+		m_numVariables--;
+		return;
+	}
+
+	//Check the floats
+	varFloat_m::iterator	vfi = m_varFloats.find( name );
+
+	if ( vfi != m_varFloats.end() )
+	{
+		m_varFloats.erase( vfi );
+		m_numVariables--;
+		return;
+	}
+
+	//Check the strings
+	varString_m::iterator	vvi = m_varVectors.find( name );
+
+	if ( vvi != m_varVectors.end() )
+	{
+		m_varVectors.erase( vvi );
+		m_numVariables--;
+		return;
+	}
+}
+
+//Save / Load functions
+int		CQuake3GameInterface::WriteSaveData( unsigned long chid, void *data, int length )
+{
+	return gi.AppendToSaveGame( chid, data, length );
+}
+
+int		CQuake3GameInterface::ReadSaveData( unsigned long chid, void *address, int length, void **addressptr )
+{
+	return gi.ReadFromSaveGame( chid, address, length, addressptr );
+}
+
+int		CQuake3GameInterface::LinkGame( int entID, int icarusID )
+{
+	gentity_t	*pEntity = &g_entities[entID];
+
+	if ( pEntity == NULL )
+		return false;
+
+	// Set the icarus ID.
+	pEntity->m_iIcarusID = icarusID;
+
+	// Associate this Entity with the entity list.
+	AssociateEntity( pEntity );
+
+	return true;
+}
+
+// Access functions
+int		CQuake3GameInterface::CreateIcarus( int entID )
+{
+	gentity_t	*pEntity = &g_entities[entID];
+
+	// If the entity doesn't have an Icarus ID, obtain and assign a new one.
+	if ( pEntity->m_iIcarusID == IIcarusInterface::ICARUS_INVALID )
+		pEntity->m_iIcarusID = IIcarusInterface::GetIcarus()->GetIcarusID( entID );
+
+	return pEntity->m_iIcarusID;
+}
+
+//Polls the engine for the sequencer of the entity matching the name passed
+int		CQuake3GameInterface::GetByName( const char *name )
+{
+	gentity_t				*ent;
+	entitylist_t::iterator		ei;
+	char					temp[1024];
+
+	if ( name == NULL || name[0] == NULL )
+		return -1;
+
+	strncpy( (char *) temp, name, sizeof(temp) );
+	temp[sizeof(temp)-1] = 0;
+
+	ei = m_EntityList.find( strupr( (char *) temp ) );
+
+	if ( ei == m_EntityList.end() )
+		return -1;
+
+	ent = &g_entities[(*ei).second];
+
+	return ent->s.number;
+
+	// this now returns the ent instead of the sequencer -- dmv 06/27/01
+//	if (ent == NULL)
+//		return NULL;
+//	return ent->sequencer;
+}
+
+// (g_entities[m_ownerID].svFlags&SVF_ICARUS_FREEZE)
+// return -1 indicates invalid
+int		CQuake3GameInterface::IsFrozen( int entID )
+{
+	return (g_entities[entID].svFlags & SVF_ICARUS_FREEZE);
+}
+
+void	CQuake3GameInterface::Free(void* data)
+{
+	gi.Free( data );
+}
+
+void*	CQuake3GameInterface::Malloc( int size )
+{
+	return gi.Malloc( size, TAG_ICARUS, qtrue );
+}
+
+float	CQuake3GameInterface::MaxFloat(void)
+{
+	// CHANGE!
+	return 34000000;
+}
+
+// Script Precache functions.
+void	CQuake3GameInterface::PrecacheRoff( const char *name )
+{
+	G_LoadRoff( name );
+}
+
+void	CQuake3GameInterface::PrecacheScript( const char *name )
+{
+	char	newname[1024];	//static char newname[1024];
+	// Strip the extension since we want the real name of the script.
+	COM_StripExtension( name, (char *) newname );
+
+	char *pBuf = NULL;
+	int iLength = 0;
+
+	// Try to Register the Script.
+	switch( RegisterScript( newname, (void **) &pBuf, iLength ) )
+	{
+		// If the script has already been registered (or could not be loaded), leave!
+		case SCRIPT_COULDNOTREGISTER:
+			if ( !Q_stricmp( newname, "NULL" ) || !Q_stricmp( newname, "default" ) )
+			{//these are not real errors, suppress warning
+				return;	
+			}
+			Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "PrecacheScript: Failed to load %s!\n", newname );
+			assert(SCRIPT_COULDNOTREGISTER);
+			return;
+		case SCRIPT_ALREADYREGISTERED:
+			return;
+
+		// We loaded the script and registered it, so precache it through Icarus now.
+		case SCRIPT_REGISTERED:
+			IIcarusInterface::GetIcarus()->Precache( pBuf, iLength );
+			return;
+	}
+}
+
+void	CQuake3GameInterface::PrecacheSound( const char *name )
+{
+	char			finalName[MAX_QPATH];
+
+	Q_strncpyz( finalName, name, MAX_QPATH, 0 );
+	strlwr(finalName);
+	if (com_buildScript->integer)
+	{	//get the male sound first
+		G_SoundIndex( finalName );
+	}
+	G_AddSexToPlayerString( finalName, qtrue );	//now get female
+
+	G_SoundIndex( finalName );
+}
+
+void	CQuake3GameInterface::PrecacheFromSet( const char *setname, const char *filename )
+{
+	//JW NOTENOTE: This will not catch special case get() inlines! (There's not really a good way to do that)
+		
+	// Get the id for this set identifier then check against valid types.
+	switch ( GetIDForString( setTable, setname ) )
+	{
+		case SET_SPAWNSCRIPT:
+		case SET_USESCRIPT:
+		case SET_AWAKESCRIPT:
+		case SET_ANGERSCRIPT:
+		case SET_ATTACKSCRIPT:
+		case SET_VICTORYSCRIPT:
+		case SET_LOSTENEMYSCRIPT:
+		case SET_PAINSCRIPT:
+		case SET_FLEESCRIPT:
+		case SET_DEATHSCRIPT:
+		case SET_DELAYEDSCRIPT:
+		case SET_BLOCKEDSCRIPT:
+		case SET_FFIRESCRIPT:
+		case SET_FFDEATHSCRIPT:
+		case SET_MINDTRICKSCRIPT:
+		case SET_CINEMATIC_SKIPSCRIPT:
+			PrecacheScript(filename);
+			break;
+
+		case SET_LOOPSOUND:		//like ID_SOUND, but set's looping
+			G_SoundIndex( filename );
+			break;
+
+		case SET_VIDEO_PLAY:	//in game cinematic
+			if (com_buildScript->integer)
+			{
+				fileHandle_t file;
+				char	name[MAX_OSPATH];
+				
+				if (strstr( filename, "/") == NULL && strstr( filename, "\\") == NULL) {
+					Com_sprintf ( name, sizeof(name), "video/%s", filename );
+				} else {
+					Com_sprintf ( name, sizeof(name), "%s", filename );
+				}
+				COM_StripExtension( name, name );
+				COM_DefaultExtension( name, sizeof( name ), ".roq" );
+
+				gi.FS_FOpenFile( name, &file, FS_READ );	// trigger the file copy
+				if (file)
+				{
+					gi.FS_FCloseFile( file );
+				}
+			}
+			break;
+
+		case SET_ADDRHANDBOLT_MODEL:
+		case SET_ADDLHANDBOLT_MODEL:
+			{
+				gi.G2API_PrecacheGhoul2Model( filename );
+			}
+			break;
+		case SET_WEAPON:
+			{
+				const int wp = GetIDForString( WPTable, filename );
+				if (wp > 0) 
+				{
+					gitem_t *item = FindItemForWeapon( (weapon_t) wp);
+					RegisterItem( item );	//make sure the weapon is cached in case this runs at startup
+				}
+			}
+			break;
+
+		default:
+			break;
+	}
+}
+//////////////////////////////////////////////////////////////////////////
+/*				END Quake 3 Interface Declarations END					*/
+//////////////////////////////////////////////////////////////////////////
diff --git a/code/game/Q3_Interface.h b/code/game/Q3_Interface.h
new file mode 100644
index 0000000..98c7a2f
--- /dev/null
+++ b/code/game/Q3_Interface.h
@@ -0,0 +1,704 @@
+#ifndef __Q3_INTERFACE__
+#define __Q3_INTERFACE__
+
+#include "../Icarus/IcarusInterface.h"
+
+//NOTENOTE: The enums and tables in this file will obviously bitch if they are included multiple times, don't do that
+
+typedef enum //# setType_e
+{
+	//# #sep Parm strings
+	SET_PARM1 = 0,//## %s="" # Set entity parm1
+	SET_PARM2,//## %s="" # Set entity parm2
+	SET_PARM3,//## %s="" # Set entity parm3
+	SET_PARM4,//## %s="" # Set entity parm4
+	SET_PARM5,//## %s="" # Set entity parm5
+	SET_PARM6,//## %s="" # Set entity parm6
+	SET_PARM7,//## %s="" # Set entity parm7
+	SET_PARM8,//## %s="" # Set entity parm8
+	SET_PARM9,//## %s="" # Set entity parm9
+	SET_PARM10,//## %s="" # Set entity parm10
+	SET_PARM11,//## %s="" # Set entity parm11
+	SET_PARM12,//## %s="" # Set entity parm12
+	SET_PARM13,//## %s="" # Set entity parm13
+	SET_PARM14,//## %s="" # Set entity parm14
+	SET_PARM15,//## %s="" # Set entity parm15
+	SET_PARM16,//## %s="" # Set entity parm16
+
+	// NOTE!!! If you add any other SET_xxxxxxSCRIPT types, make sure you update the 'case' statements in 
+	//	ICARUS_InterrogateScript() (game/g_ICARUS.cpp), or the script-precacher won't find them.
+
+	//# #sep Scripts and other file paths
+	SET_SPAWNSCRIPT,//## %s="NULL" !!"W:\game\base\scripts\!!#*.txt" # Script to run when spawned //0 - do not change these, these are equal to BSET_SPAWN, etc
+	SET_USESCRIPT,//## %s="NULL" !!"W:\game\base\scripts\!!#*.txt" # Script to run when used
+	SET_AWAKESCRIPT,//## %s="NULL" !!"W:\game\base\scripts\!!#*.txt" # Script to run when startled
+	SET_ANGERSCRIPT,//## %s="NULL" !!"W:\game\base\scripts\!!#*.txt" # Script run when find an enemy for the first time
+	SET_ATTACKSCRIPT,//## %s="NULL" !!"W:\game\base\scripts\!!#*.txt" # Script to run when you shoot
+	SET_VICTORYSCRIPT,//## %s="NULL" !!"W:\game\base\scripts\!!#*.txt" # Script to run when killed someone
+	SET_LOSTENEMYSCRIPT,//## %s="NULL" !!"W:\game\base\scripts\!!#*.txt" # Script to run when you can't find your enemy
+	SET_PAINSCRIPT,//## %s="NULL" !!"W:\game\base\scripts\!!#*.txt" # Script to run when hit
+	SET_FLEESCRIPT,//## %s="NULL" !!"W:\game\base\scripts\!!#*.txt" # Script to run when hit and low health
+	SET_DEATHSCRIPT,//## %s="NULL" !!"W:\game\base\scripts\!!#*.txt" # Script to run when killed
+	SET_DELAYEDSCRIPT,//## %s="NULL" !!"W:\game\base\scripts\!!#*.txt" # Script to run after a delay
+	SET_BLOCKEDSCRIPT,//## %s="NULL" !!"W:\game\base\scripts\!!#*.txt" # Script to run when blocked by teammate
+	SET_FFIRESCRIPT,//## %s="NULL" !!"W:\game\base\scripts\!!#*.txt" # Script to run when player has shot own team repeatedly
+	SET_FFDEATHSCRIPT,//## %s="NULL" !!"W:\game\base\scripts\!!#*.txt" # Script to run when player kills a teammate
+	SET_MINDTRICKSCRIPT,//## %s="NULL" !!"W:\game\base\scripts\!!#*.txt" # Script to run when player kills a teammate
+	SET_VIDEO_PLAY,//## %s="filename" !!"W:\game\base\video\!!#*.roq" # Play a video (inGame)
+	SET_CINEMATIC_SKIPSCRIPT, //## %s="filename" !!"W:\game\base\scripts\!!#*.txt" # Script to run when skipping the running cinematic 
+	SET_RAILCENTERTRACKLOCKED, //## %s="targetname"  # Turn off the centered movers on the given track
+	SET_RAILCENTERTRACKUNLOCKED, //## %s="targetname"  # Turn on the centered movers on the given track
+	SET_SKIN,//## %s="models/players/???/model_default.skin" # just blindly sets whatever skin you set!  include full path after "base/"... eg: "models/players/tavion_new/model_possessed.skin"
+
+	//# #sep Standard strings
+	SET_ENEMY,//## %s="NULL" # Set enemy by targetname
+	SET_LEADER,//## %s="NULL" # Set for BS_FOLLOW_LEADER
+	SET_NAVGOAL,//## %s="NULL" # *Move to this navgoal then continue script
+	SET_CAPTURE,//## %s="NULL" # Set captureGoal by targetname
+	SET_VIEWTARGET,//## %s="NULL" # Set angles toward ent by targetname
+	SET_WATCHTARGET,//## %s="NULL" # Set angles toward ent by targetname, will *continue* to face them... only in BS_CINEMATIC
+	SET_TARGETNAME,//## %s="NULL" # Set/change your targetname
+	SET_PAINTARGET,//## %s="NULL" # Set/change what to use when hit
+	SET_CAMERA_GROUP,//## %s="NULL" # all ents with this cameraGroup will be focused on
+	SET_CAMERA_GROUP_TAG,//## %s="NULL" # What tag on all clients to try to track
+	SET_LOOK_TARGET,//## %s="NULL" # object for NPC to look at
+	SET_ADDRHANDBOLT_MODEL,			//## %s="NULL" # object to place on NPC right hand bolt
+	SET_REMOVERHANDBOLT_MODEL,		//## %s="NULL" # object to remove from NPC right hand bolt
+	SET_ADDLHANDBOLT_MODEL,			//## %s="NULL" # object to place on NPC left hand bolt
+	SET_REMOVELHANDBOLT_MODEL,		//## %s="NULL" # object to remove from NPC left hand bolt
+	SET_CAPTIONTEXTCOLOR,	//## %s=""  # Color of text RED,WHITE,BLUE, YELLOW
+	SET_CENTERTEXTCOLOR,	//## %s=""  # Color of text RED,WHITE,BLUE, YELLOW
+	SET_SCROLLTEXTCOLOR,	//## %s=""  # Color of text RED,WHITE,BLUE, YELLOW
+	SET_COPY_ORIGIN,//## %s="targetname"  # Copy the origin of the ent with targetname to your origin
+	SET_DEFEND_TARGET,//## %s="targetname"  # This NPC will attack the target NPC's enemies
+	SET_TARGET,//## %s="NULL" # Set/change your target
+	SET_TARGET2,//## %s="NULL" # Set/change your target2, on NPC's, this fires when they're knocked out by the red hypo
+	SET_LOCATION,//## %s="INVALID" # What trigger_location you're in - Can only be gotten, not set!
+	SET_REMOVE_TARGET,//## %s="NULL" # Target that is fired when someone completes the BS_REMOVE behaviorState
+	SET_LOADGAME,//## %s="exitholodeck" # Load the savegame that was auto-saved when you started the holodeck
+	SET_LOCKYAW,//## %s="off"  # Lock legs to a certain yaw angle (or "off" or "auto" uses current)
+	SET_VIEWENTITY,//## %s="NULL" # Make the player look through this ent's eyes - also shunts player movement control to this ent
+	SET_LOOPSOUND,//## %s="FILENAME" !!"W:\game\base\!!#sound\*.*" # Looping sound to play on entity
+	SET_ICARUS_FREEZE,//## %s="NULL" # Specify name of entity to freeze - !!!NOTE!!! since the ent is frozen, you must have some other entity unfreeze it!!!
+	SET_ICARUS_UNFREEZE,//## %s="NULL" # Specify name of entity to unfreeze
+	SET_SABER1,//## %s="none" # Name of a saber in sabers.cfg to use in first hand.  "none" removes current saber
+	SET_SABER2,//## %s="none" # Name of a saber in sabers.cfg to use in second hand.  "none" removes current saber
+	SET_PLAYERMODEL,//## %s="Kyle" # Name of an NPC config in NPC2.cfg to use for this ent
+	SET_VEHICLE,//## %s="speeder" # Name of an vehicle config in vehicles.cfg to make this ent drive
+	SET_SECURITY_KEY,// %s="keyname" # name of a security key to give to the player - don't place one in map, just give the name here and it handles the rest (use "null" to remove their current key)
+
+	SET_SCROLLTEXT,	//## %s="" # key of text string to print
+	SET_LCARSTEXT,	//## %s="" # key of text string to print in LCARS frame
+	SET_CENTERTEXT,	//## %s="" # key of text string to print in center of screen.
+
+	//# #sep vectors
+	SET_ORIGIN,//## %v="0.0 0.0 0.0" # Set origin explicitly or with TAG
+	SET_ANGLES,//## %v="0.0 0.0 0.0" # Set angles explicitly or with TAG
+	SET_TELEPORT_DEST,//## %v="0.0 0.0 0.0" # Set origin here as soon as the area is clear
+	SET_SABER_ORIGIN,//## %v="0.0 0.0 0.0" # Removes this ent's saber from their hand, turns it off, and places it at the specified location
+	
+	//# #sep floats
+	SET_XVELOCITY,//## %f="0.0" # Velocity along X axis
+	SET_YVELOCITY,//## %f="0.0" # Velocity along Y axis
+	SET_ZVELOCITY,//## %f="0.0" # Velocity along Z axis
+	SET_Z_OFFSET,//## %f="0.0" # Vertical offset from original origin... offset/ent's speed * 1000ms is duration
+	SET_DPITCH,//## %f="0.0" # Pitch for NPC to turn to
+	SET_DYAW,//## %f="0.0" # Yaw for NPC to turn to
+	SET_TIMESCALE,//## %f="0.0" # Speed-up slow down game (0 - 1.0)
+	SET_CAMERA_GROUP_Z_OFS,//## %s="NULL" # when following an ent with the camera, apply this z ofs
+	SET_VISRANGE,//## %f="0.0" # How far away NPC can see
+	SET_EARSHOT,//## %f="0.0" # How far an NPC can hear
+	SET_VIGILANCE,//## %f="0.0" # How often to look for enemies (0 - 1.0)
+	SET_GRAVITY,//## %f="0.0" # Change this ent's gravity - 800 default
+	SET_FACEAUX,		//## %f="0.0" # Set face to Aux expression for number of seconds
+	SET_FACEBLINK,		//## %f="0.0" # Set face to Blink expression for number of seconds
+	SET_FACEBLINKFROWN,	//## %f="0.0" # Set face to Blinkfrown expression for number of seconds
+	SET_FACEFROWN,		//## %f="0.0" # Set face to Frown expression for number of seconds
+	SET_FACENORMAL,		//## %f="0.0" # Set face to Normal expression for number of seconds
+	SET_FACEEYESCLOSED,	//## %f="0.0" # Set face to Eyes closed
+	SET_FACEEYESOPENED,	//## %f="0.0" # Set face to Eyes open
+	SET_WAIT,		//## %f="0.0" # Change an entity's wait field
+	SET_FOLLOWDIST,		//## %f="0.0" # How far away to stay from leader in BS_FOLLOW_LEADER
+	SET_SCALE,			//## %f="0.0" # Scale the entity model
+	SET_RENDER_CULL_RADIUS,			//## %f="40.0" # Used to ensure rendering for entities with geographically sprawling animations (world units)
+	SET_DISTSQRD_TO_PLAYER,			//## %f="0.0" # Only to be used in a 'get'. (Distance to player)*(Distance to player)
+
+	//# #sep ints
+	SET_ANIM_HOLDTIME_LOWER,//## %d="0" # Hold lower anim for number of milliseconds
+	SET_ANIM_HOLDTIME_UPPER,//## %d="0" # Hold upper anim for number of milliseconds
+	SET_ANIM_HOLDTIME_BOTH,//## %d="0" # Hold lower and upper anims for number of milliseconds
+	SET_HEALTH,//## %d="0" # Change health
+	SET_ARMOR,//## %d="0" # Change armor
+	SET_WALKSPEED,//## %d="0" # Change walkSpeed
+	SET_RUNSPEED,//## %d="0" # Change runSpeed
+	SET_YAWSPEED,//## %d="0" # Change yawSpeed
+	SET_AGGRESSION,//## %d="0" # Change aggression 1-5
+	SET_AIM,//## %d="0" # Change aim 1-5
+	SET_FRICTION,//## %d="0" # Change ent's friction - 6 default
+	SET_SHOOTDIST,//## %d="0" # How far the ent can shoot - 0 uses weapon
+	SET_HFOV,//## %d="0" # Horizontal field of view
+	SET_VFOV,//## %d="0" # Vertical field of view
+	SET_DELAYSCRIPTTIME,//## %d="0" # How many milliseconds to wait before running delayscript
+	SET_FORWARDMOVE,//## %d="0" # NPC move forward -127(back) to 127
+	SET_RIGHTMOVE,//## %d="0" # NPC move right -127(left) to 127
+	SET_STARTFRAME,	//## %d="0" # frame to start animation sequence on
+	SET_ENDFRAME,	//## %d="0" # frame to end animation sequence on
+	SET_ANIMFRAME,	//## %d="0" # frame to set animation sequence to
+	SET_COUNT,	//## %d="0" # Change an entity's count field
+	SET_SHOT_SPACING,//## %d="1000" # Time between shots for an NPC - reset to defaults when changes weapon
+	SET_MISSIONSTATUSTIME,//## %d="0" # Amount of time until Mission Status should be shown after death
+	SET_WIDTH,//## %d="0.0" # Width of NPC bounding box.
+	SET_SABER1BLADEON,//## %d="0.0" # Activate a specific blade of Saber 1 (0 - (MAX_BLADES - 1)).
+	SET_SABER1BLADEOFF,//## %d="0.0" # Deactivate a specific blade of Saber 1 (0 - (MAX_BLADES - 1)).
+	SET_SABER2BLADEON,//## %d="0.0" # Activate a specific blade of Saber 2 (0 - (MAX_BLADES - 1)).
+	SET_SABER2BLADEOFF,//## %d="0.0" # Deactivate a specific blade of Saber 2 (0 - (MAX_BLADES - 1)).
+	SET_DAMAGEENTITY,	//## %d="5" # Damage this entity with set amount.
+
+	//# #sep booleans
+	SET_IGNOREPAIN,//## %t="BOOL_TYPES" # Do not react to pain
+	SET_IGNOREENEMIES,//## %t="BOOL_TYPES" # Do not acquire enemies
+	SET_IGNOREALERTS,//## %t="BOOL_TYPES" # Do not get enemy set by allies in area(ambush)
+	SET_DONTSHOOT,//## %t="BOOL_TYPES" # Others won't shoot you
+	SET_NOTARGET,//## %t="BOOL_TYPES" # Others won't pick you as enemy
+	SET_DONTFIRE,//## %t="BOOL_TYPES" # Don't fire your weapon
+	SET_LOCKED_ENEMY,//## %t="BOOL_TYPES" # Keep current enemy until dead
+	SET_CROUCHED,//## %t="BOOL_TYPES" # Force NPC to crouch
+	SET_WALKING,//## %t="BOOL_TYPES" # Force NPC to move at walkSpeed
+	SET_RUNNING,//## %t="BOOL_TYPES" # Force NPC to move at runSpeed
+	SET_CHASE_ENEMIES,//## %t="BOOL_TYPES" # NPC will chase after enemies
+	SET_LOOK_FOR_ENEMIES,//## %t="BOOL_TYPES" # NPC will be on the lookout for enemies
+	SET_FACE_MOVE_DIR,//## %t="BOOL_TYPES" # NPC will face in the direction it's moving
+	SET_DONT_FLEE,//## %t="BOOL_TYPES" # NPC will not run from danger
+	SET_FORCED_MARCH,//## %t="BOOL_TYPES" # NPC will not move unless you aim at him
+	SET_UNDYING,//## %t="BOOL_TYPES" # Can take damage down to 1 but not die
+	SET_NOAVOID,//## %t="BOOL_TYPES" # Will not avoid other NPCs or architecture
+	SET_SOLID,//## %t="BOOL_TYPES" # Make yourself notsolid or solid
+	SET_PLAYER_USABLE,//## %t="BOOL_TYPES" # Can be activateby the player's "use" button
+	SET_LOOP_ANIM,//## %t="BOOL_TYPES" # For non-NPCs, loop your animation sequence
+	SET_INTERFACE,//## %t="BOOL_TYPES" # Player interface on/off
+	SET_SHIELDS,//## %t="BOOL_TYPES" # NPC has no shields (Borg do not adapt)
+	SET_INVISIBLE,//## %t="BOOL_TYPES" # Makes an NPC not solid and not visible
+	SET_VAMPIRE,//## %t="BOOL_TYPES" # Draws only in mirrors/portals
+	SET_FORCE_INVINCIBLE,//## %t="BOOL_TYPES" # Force Invincibility effect, also godmode
+	SET_GREET_ALLIES,//## %t="BOOL_TYPES" # Makes an NPC greet teammates
+	SET_VIDEO_FADE_IN,//## %t="BOOL_TYPES" # Makes video playback fade in
+	SET_VIDEO_FADE_OUT,//## %t="BOOL_TYPES" # Makes video playback fade out
+	SET_PLAYER_LOCKED,//## %t="BOOL_TYPES" # Makes it so player cannot move
+	SET_LOCK_PLAYER_WEAPONS,//## %t="BOOL_TYPES" # Makes it so player cannot switch weapons
+	SET_NO_IMPACT_DAMAGE,//## %t="BOOL_TYPES" # Stops this ent from taking impact damage
+	SET_NO_KNOCKBACK,//## %t="BOOL_TYPES" # Stops this ent from taking knockback from weapons
+	SET_ALT_FIRE,//## %t="BOOL_TYPES" # Force NPC to use altfire when shooting
+	SET_NO_RESPONSE,//## %t="BOOL_TYPES" # NPCs will do generic responses when this is on (usescripts override generic responses as well)
+	SET_INVINCIBLE,//## %t="BOOL_TYPES" # Completely unkillable
+	SET_MISSIONSTATUSACTIVE,	//# Turns on Mission Status Screen
+	SET_NO_COMBAT_TALK,//## %t="BOOL_TYPES" # NPCs will not do their combat talking noises when this is on
+	SET_NO_ALERT_TALK,//## %t="BOOL_TYPES" # NPCs will not do their combat talking noises when this is on
+	SET_TREASONED,//## %t="BOOL_TYPES" # Player has turned on his own- scripts will stop, NPCs will turn on him and level changes load the brig
+	SET_DISABLE_SHADER_ANIM,//## %t="BOOL_TYPES" # Allows turning off an animating shader in a script
+	SET_SHADER_ANIM,//## %t="BOOL_TYPES" # Sets a shader with an image map to be under frame control
+	SET_SABERACTIVE,//## %t="BOOL_TYPES" # Turns saber on/off
+	SET_ADJUST_AREA_PORTALS,//## %t="BOOL_TYPES" # Only set this on things you move with script commands that you *want* to open/close area portals.  Default is off.
+	SET_DMG_BY_HEAVY_WEAP_ONLY,//## %t="BOOL_TYPES" # When true, only a heavy weapon class missile/laser can damage this ent.
+	SET_SHIELDED,//## %t="BOOL_TYPES" # When true, ion_cannon is shielded from any kind of damage.
+	SET_NO_GROUPS,//## %t="BOOL_TYPES" # This NPC cannot alert groups or be part of a group
+	SET_FIRE_WEAPON,//## %t="BOOL_TYPES" # Makes NPC will hold down the fire button, until this is set to false
+	SET_FIRE_WEAPON_NO_ANIM,//## %t="BOOL_TYPES" # NPC will hold down the fire button, but they won't play firing anim
+	SET_SAFE_REMOVE,//## %t="BOOL_TYPES" # NPC will remove only when it's safe (Player is not in PVS)
+	SET_BOBA_JET_PACK,//## %t="BOOL_TYPES" # Turn on/off Boba Fett's Jet Pack
+	SET_NO_MINDTRICK,//## %t="BOOL_TYPES" # Makes NPC immune to jedi mind-trick
+	SET_INACTIVE,//## %t="BOOL_TYPES" # in lieu of using a target_activate or target_deactivate
+	SET_FUNC_USABLE_VISIBLE,//## %t="BOOL_TYPES" # provides an alternate way of changing func_usable to be visible or not, DOES NOT AFFECT SOLID
+	SET_SECRET_AREA_FOUND,//## %t="BOOL_TYPES" # Increment secret areas found counter
+	SET_END_SCREENDISSOLVE,//## %t="BOOL_TYPES" # End of game dissolve into star background and credits
+	SET_USE_CP_NEAREST,//## %t="BOOL_TYPES" # NPCs will use their closest combat points, not try and find ones next to the player, or flank player
+	SET_MORELIGHT,//## %t="BOOL_TYPES" # NPC will have a minlight of 96
+	SET_NO_FORCE,//## %t="BOOL_TYPES" # NPC will not be affected by force powers
+	SET_NO_FALLTODEATH,//## %t="BOOL_TYPES" # NPC will not scream and tumble and fall to hit death over large drops
+	SET_DISMEMBERABLE,//## %t="BOOL_TYPES" # NPC will not be dismemberable if you set this to false (default is true)
+	SET_NO_ACROBATICS,//## %t="BOOL_TYPES" # Jedi won't jump, roll or cartwheel
+	SET_USE_SUBTITLES,//## %t="BOOL_TYPES" # When true NPC will always display subtitle regardless of subtitle setting
+	SET_CLEAN_DAMAGING_ENTS,//## %t="BOOL_TYPES" # Removes entities that could muck up cinematics, explosives, turrets, seekers.
+	SET_HUD,//## %t="BOOL_TYPES" # Turns on/off HUD
+	//JKA
+	SET_NO_PVS_CULL,//## %t="BOOL_TYPES" # This entity will *always* be drawn - use only for special case cinematic NPCs that have anims that cover multiple rooms!!!
+	SET_CLOAK,		//## %t="BOOL_TYPES" # Set a Saboteur to cloak (true) or un-cloak (false).
+	SET_FORCE_HEAL,//## %t="BOOL_TYPES" # Causes this ent to start force healing at whatever level of force heal they have
+	SET_FORCE_SPEED,//## %t="BOOL_TYPES" # Causes this ent to start force speeding at whatever level of force speed they have (may not do anything for NPCs?)
+	SET_FORCE_PUSH,//## %t="BOOL_TYPES" # Causes this ent to do a force push at whatever level of force push they have - will not fail
+	SET_FORCE_PUSH_FAKE,//## %t="BOOL_TYPES" # Causes this ent to do a force push anim, sound and effect, will not push anything
+	SET_FORCE_PULL,//## %t="BOOL_TYPES" # Causes this ent to do a force push at whatever level of force push they have - will not fail
+	SET_FORCE_MIND_TRICK,//## %t="BOOL_TYPES" # Causes this ent to do a jedi mind trick at whatever level of mind trick they have (may not do anything for NPCs?)
+	SET_FORCE_GRIP,//## %t="BOOL_TYPES" # Causes this ent to grip their enemy at whatever level of grip they have (will grip until scripted to stop)
+	SET_FORCE_LIGHTNING,//## %t="BOOL_TYPES" # Causes this ent to lightning at whatever level of lightning they have (will lightning until scripted to stop)
+	SET_FORCE_SABERTHROW,//## %t="BOOL_TYPES" # Causes this ent to throw their saber at whatever level of saber throw they have (will throw saber until scripted to stop)
+	SET_FORCE_RAGE,//## %t="BOOL_TYPES" # Causes this ent to go into force rage at whatever level of force rage they have
+	SET_FORCE_PROTECT,//## %t="BOOL_TYPES" # Causes this ent to start a force protect at whatever level of force protect they have
+	SET_FORCE_ABSORB,//## %t="BOOL_TYPES" # Causes this ent to do start a force absorb at whatever level of force absorb they have
+	SET_FORCE_DRAIN,//## %t="BOOL_TYPES" # Causes this ent to start force draining their enemy at whatever level of force drain they have (will drain until scripted to stop)
+	SET_WINTER_GEAR, //## %t="BOOL_TYPES" # Set the player to wear his/her winter gear (skins torso_g1 and lower_e1), or restore the default skins.
+	SET_NO_ANGLES, //## %t="BOOL_TYPES" # This NPC/player will not have any bone angle overrides or pitch or roll (should only be used in cinematics)
+
+	//# #sep calls
+	SET_SKILL,//## %r%d="0" # Cannot set this, only get it - valid values are 0 through 3
+
+	//# #sep Special tables
+	SET_ANIM_UPPER,//## %t="ANIM_NAMES" # Torso and head anim
+	SET_ANIM_LOWER,//## %t="ANIM_NAMES" # Legs anim
+	SET_ANIM_BOTH,//## %t="ANIM_NAMES" # Set same anim on torso and legs
+	SET_PLAYER_TEAM,//## %t="TEAM_NAMES" # Your team
+	SET_ENEMY_TEAM,//## %t="TEAM_NAMES" # Team in which to look for enemies
+	SET_BEHAVIOR_STATE,//## %t="BSTATE_STRINGS" # Change current bState
+	SET_DEFAULT_BSTATE,//## %t="BSTATE_STRINGS" # Change fallback bState
+	SET_TEMP_BSTATE,//## %t="BSTATE_STRINGS" # Set/Chang a temp bState
+	SET_EVENT,//## %t="EVENT_NAMES" # Events you can initiate
+	SET_WEAPON,//## %t="WEAPON_NAMES" # Change/Stow/Drop weapon
+	SET_ITEM,//## %t="ITEM_NAMES" # Give items
+	SET_MUSIC_STATE,//## %t="MUSIC_STATES" # Set the state of the dynamic music
+
+	SET_FORCE_HEAL_LEVEL,//## %t="FORCE_LEVELS" # Change force power level
+	SET_FORCE_JUMP_LEVEL,//## %t="FORCE_LEVELS" # Change force power level
+	SET_FORCE_SPEED_LEVEL,//## %t="FORCE_LEVELS" # Change force power level
+	SET_FORCE_PUSH_LEVEL,//## %t="FORCE_LEVELS" # Change force power level
+	SET_FORCE_PULL_LEVEL,//## %t="FORCE_LEVELS" # Change force power level
+	SET_FORCE_MINDTRICK_LEVEL,//## %t="FORCE_LEVELS" # Change force power level
+	SET_FORCE_GRIP_LEVEL,//## %t="FORCE_LEVELS" # Change force power level
+	SET_FORCE_LIGHTNING_LEVEL,//## %t="FORCE_LEVELS" # Change force power level
+	SET_SABER_THROW,//## %t="FORCE_LEVELS" # Change force power level
+	SET_SABER_DEFENSE,//## %t="FORCE_LEVELS" # Change force power level
+	SET_SABER_OFFENSE,//## %t="SABER_STYLES" # Change force power level
+	SET_FORCE_RAGE_LEVEL,//## %t="FORCE_LEVELS" # Change force power level
+	SET_FORCE_PROTECT_LEVEL,//## %t="FORCE_LEVELS" # Change force power level
+	SET_FORCE_ABSORB_LEVEL,//## %t="FORCE_LEVELS" # Change force power level
+	SET_FORCE_DRAIN_LEVEL,//## %t="FORCE_LEVELS" # Change force power level
+	SET_FORCE_SIGHT_LEVEL,//## %t="FORCE_LEVELS" # Change force power level
+	SET_SABER1_COLOR1,		//## %t="SABER_COLORS" # Set color of first blade of first saber
+	SET_SABER1_COLOR2,		//## %t="SABER_COLORS" # Set color of second blade of first saber
+	SET_SABER2_COLOR1,		//## %t="SABER_COLORS" # Set color of first blade of first saber
+	SET_SABER2_COLOR2,		//## %t="SABER_COLORS" # Set color of second blade of first saber
+	SET_DISMEMBER_LIMB,		//## %t="HIT_LOCATIONS" # Cut off a part of a body and send the limb flying
+
+	SET_OBJECTIVE_SHOW,	//## %t="OBJECTIVES" # Show objective on mission screen
+	SET_OBJECTIVE_HIDE,	//## %t="OBJECTIVES" # Hide objective from mission screen
+	SET_OBJECTIVE_SUCCEEDED,//## %t="OBJECTIVES" # Mark objective as completed
+	SET_OBJECTIVE_SUCCEEDED_NO_UPDATE,//## %t="OBJECTIVES" # Mark objective as completed, no update sent to screen
+	SET_OBJECTIVE_FAILED,	//## %t="OBJECTIVES" # Mark objective as failed
+
+	SET_MISSIONFAILED,		//## %t="MISSIONFAILED" # Mission failed screen activates
+
+	SET_TACTICAL_SHOW,		//## %t="TACTICAL" # Show tactical info on mission objectives screen
+	SET_TACTICAL_HIDE,		//## %t="TACTICAL" # Hide tactical info on mission objectives screen
+	SET_OBJECTIVE_CLEARALL,	//## # Force all objectives to be hidden
+/*
+	SET_OBJECTIVEFOSTER,	
+*/
+	SET_OBJECTIVE_LIGHTSIDE,	//## # Used to get whether the player has chosen the light (succeeded) or dark (failed) side.
+
+	SET_MISSIONSTATUSTEXT,	//## %t="STATUSTEXT" # Text to appear in mission status screen
+	SET_MENU_SCREEN,//## %t="MENUSCREENS" # Brings up specified menu screen
+
+	SET_CLOSINGCREDITS,		//## # Show closing credits
+
+	//in-bhc tables
+	SET_LEAN,//## %t="LEAN_TYPES" # Lean left, right or stop leaning
+
+	//# #eol
+	SET_
+} setType_t;	
+
+
+// this enum isn't used directly by the game, it's mainly for BehavEd to scan for...
+//
+typedef enum //# playType_e
+{
+	//# #sep Types of file to play
+	PLAY_ROFF = 0,//## %s="filename" !!"W:\game\base\scripts\!!#*.rof" # Play a ROFF file
+
+	//# #eol
+	PLAY_NUMBEROF
+
+} playType_t;
+
+
+const	int	Q3_TIME_SCALE	= 1;	//MILLISECONDS
+
+extern char	cinematicSkipScript[64];
+
+//General
+extern	void		Q3_TaskIDClear( int *taskID );
+extern	qboolean	Q3_TaskIDPending( gentity_t *ent, taskID_t taskType );
+extern	void		Q3_TaskIDComplete( gentity_t *ent, taskID_t taskType );
+extern	void		Q3_DPrintf( const char *, ... );
+
+//Not referenced directly as script function - all are called through Q3_Set
+extern	void		Q3_SetAnimBoth( int entID, const char *anim_name );
+extern	void		Q3_SetVelocity( int entID, vec3_t angles );
+
+//////////////////////////////////////////////////////////////////////////
+/*		BEGIN Almost useless tokenizer and interpreter constants BEGIN	*/
+//////////////////////////////////////////////////////////////////////////
+#define MAX_STRING_LENGTH		256
+#define MAX_IDENTIFIER_LENGTH	128
+
+#define TKF_IGNOREDIRECTIVES			0x00000001		// skip over lines starting with #
+#define TKF_USES_EOL					0x00000002		// generate end of line tokens
+#define TKF_NODIRECTIVES				0x00000004		// don't treat # in any special way
+#define TKF_WANTUNDEFINED				0x00000008		// if token not found in symbols create undefined token
+#define TKF_WIDEUNDEFINEDSYMBOLS		0x00000010		// when undefined token encountered, accumulate until space
+#define TKF_RAWSYMBOLSONLY				0x00000020
+#define TKF_NUMERICIDENTIFIERSTART		0x00000040
+#define TKF_IGNOREKEYWORDS				0x00000080
+#define TKF_NOCASEKEYWORDS				0x00000100
+#define TKF_NOUNDERSCOREINIDENTIFIER	0x00000200
+#define TKF_NODASHINIDENTIFIER			0x00000400
+#define TKF_COMMENTTOKENS				0x00000800
+
+enum
+{
+	TKERR_NONE,
+	TKERR_UNKNOWN,
+	TKERR_BUFFERCREATE,
+	TKERR_UNRECOGNIZEDSYMBOL,
+	TKERR_DUPLICATESYMBOL,
+	TKERR_STRINGLENGTHEXCEEDED,
+	TKERR_IDENTIFIERLENGTHEXCEEDED,
+	TKERR_EXPECTED_INTEGER,
+	TKERR_EXPECTED_IDENTIFIER,
+	TKERR_EXPECTED_STRING,
+	TKERR_EXPECTED_CHAR,
+	TKERR_EXPECTED_FLOAT,
+	TKERR_UNEXPECTED_TOKEN,
+	TKERR_INVALID_DIRECTIVE,
+	TKERR_INCLUDE_FILE_NOTFOUND,
+	TKERR_UNMATCHED_DIRECTIVE,
+	TKERR_USERERROR,
+};
+
+enum
+{
+	TK_EOF = -1,
+	TK_UNDEFINED,
+	TK_COMMENT,
+	TK_EOL,
+	TK_CHAR,
+	TK_STRING,
+	TK_INT,
+	TK_INTEGER = TK_INT,
+	TK_FLOAT,
+	TK_IDENTIFIER,
+	TK_USERDEF,
+};
+
+//Token defines
+enum 
+{
+	TK_BLOCK_START = TK_USERDEF,
+	TK_BLOCK_END,
+	TK_VECTOR_START,
+	TK_VECTOR_END,
+	TK_OPEN_PARENTHESIS,
+	TK_CLOSED_PARENTHESIS,
+	TK_VECTOR,
+	TK_GREATER_THAN,
+	TK_LESS_THAN,
+	TK_EQUALS,
+	TK_NOT,
+
+	NUM_USER_TOKENS
+};
+
+//ID defines
+enum
+{
+	ID_AFFECT = NUM_USER_TOKENS,
+	ID_SOUND,
+	ID_MOVE,
+	ID_ROTATE,
+	ID_WAIT,
+	ID_BLOCK_START,
+	ID_BLOCK_END,
+	ID_SET,
+	ID_LOOP,
+	ID_LOOPEND,
+	ID_PRINT,
+	ID_USE,
+	ID_FLUSH,
+	ID_RUN,
+	ID_KILL,
+	ID_REMOVE,
+	ID_CAMERA,
+	ID_GET,
+	ID_RANDOM,
+	ID_IF,
+	ID_ELSE,
+	ID_REM,
+	ID_TASK,
+	ID_DO,
+	ID_DECLARE,
+	ID_FREE,
+	ID_DOWAIT,
+	ID_SIGNAL,
+	ID_WAITSIGNAL,
+	ID_PLAY,
+
+	ID_TAG,
+	ID_EOF,
+	NUM_IDS
+};
+
+//Type defines
+enum
+{
+	//Wait types
+	TYPE_WAIT_COMPLETE	 = NUM_IDS,
+	TYPE_WAIT_TRIGGERED,
+
+	//Set types
+	TYPE_ANGLES,
+	TYPE_ORIGIN,
+
+	//Affect types
+	TYPE_INSERT,	
+	TYPE_FLUSH,	
+	
+	//Camera types
+	TYPE_PAN,
+	TYPE_ZOOM,
+	TYPE_MOVE,
+	TYPE_FADE,
+	TYPE_PATH,
+	TYPE_ENABLE,
+	TYPE_DISABLE,
+	TYPE_SHAKE,
+	TYPE_ROLL,
+	TYPE_TRACK,
+	TYPE_DISTANCE,
+	TYPE_FOLLOW,
+		
+	//Variable type
+	TYPE_VARIABLE,
+
+	TYPE_EOF,
+
+	ID_CONTINUE,
+	ID_BREAK,
+	ID_ACTIVATE,
+	ID_DEACTIVATE,
+	ID_WHILE,
+	ID_WAITUNTIL,
+	ID_WAITAFFECT,
+	ID_TASKCOMPLETED,
+	ID_SIGNALCOUNT,
+	TK_GE,
+	TK_LE,
+
+	NUM_TYPES
+};
+
+enum
+{
+	MSG_COMPLETED,
+	MSG_EOF,
+	NUM_MESSAGES,
+};
+//////////////////////////////////////////////////////////////////////////
+/*						END Constants END								*/
+//////////////////////////////////////////////////////////////////////////
+
+//NOTENOTE: Only change this to re-point ICARUS to a new script directory
+// NOTE! A '/' (forward slash) should be checked for along with the script dir.
+#define Q3_SCRIPT_DIR	"scripts"
+
+#define MAX_FILENAME_LENGTH	256
+
+#define	IBI_EXT			".IBI"	//(I)nterpreted (B)lock (I)nstructions
+#define IBI_HEADER_ID	"IBI"
+
+//////////////////////////////////////////////////////////////////////////
+/*					BEGIN Quake 3 Game Interface BEGIN					*/
+//////////////////////////////////////////////////////////////////////////
+
+// The script data buffer.
+typedef struct pscript_s
+{
+	char	*buffer;
+	long	length;
+} pscript_t;
+
+// STL map type definitions for the Entity List and Script Buffer List.
+typedef	map < string, int, less<string>, allocator<int> >		entitylist_t;
+typedef map < string, pscript_t*, less<string>, allocator<pscript_t*> >	scriptlist_t;
+
+// STL map type definitions for the variable containers.
+typedef map < string, string >		varString_m;
+typedef map < string, float >		varFloat_m;
+
+
+// The Quake 3 Game Interface Class for Quake3 and Icarus to use.
+// Created: 10/08/02 by Aurelio Reis.
+class CQuake3GameInterface : public IGameInterface
+{
+private:
+	// A list of script buffers (to ensure we cache a script only once).
+	scriptlist_t		m_ScriptList;
+
+	// A list of Game Elements/Objects.
+	entitylist_t		m_EntityList;
+
+	// Variable stuff.
+	varString_m		m_varStrings;
+	varFloat_m		m_varFloats;
+	varString_m		m_varVectors;
+	int				m_numVariables;
+
+	int				m_entFilter;
+
+	// Register variables functions.
+	void SetVar( int taskID, int entID, const char *type_name, const char *data );
+	void VariableSaveFloats( varFloat_m &fmap );
+	void VariableSaveStrings( varString_m &smap );
+	void VariableLoadFloats( varFloat_m &fmap );
+	void VariableLoadStrings( int type, varString_m &fmap );
+	void InitVariables( void );
+	int  GetStringVariable( const char *name, const char **value );
+	int  GetFloatVariable( const char *name, float *value );
+	int  GetVectorVariable( const char *name, vec3_t value );
+	int  VariableDeclared( const char *name );
+	int  SetFloatVariable( const char *name, float value );
+	int  SetStringVariable( const char *name, const char *value );
+	int  SetVectorVariable( const char *name, const char *value );
+	void PrisonerObjCheck(const char *name,const char *data);
+
+public:
+	// Static Singleton Instance.
+	static CQuake3GameInterface *m_pInstance;
+
+	// Variable enums
+	enum { VTYPE_NONE = 0, VTYPE_FLOAT, VTYPE_STRING, VTYPE_VECTOR, MAX_VARIABLES = 32 };
+
+	// Register enums.
+	enum { SCRIPT_COULDNOTREGISTER = 0, SCRIPT_REGISTERED, SCRIPT_ALREADYREGISTERED };
+
+	// Constructor.
+	CQuake3GameInterface();
+
+	// Destructor (NOTE: Destroy the Game Interface BEFORE the Icarus Interface).
+	~CQuake3GameInterface();
+
+	// Initialize an Entity by ID.
+	bool InitEntity( gentity_t *pEntity );
+
+	// Free an Entity by ID (NOTE, if this is called while a script is running the game will crash!).
+	void FreeEntity( gentity_t *pEntity );
+
+	// Determines whether or not an Entity needs ICARUS information.
+	bool ValidEntity( gentity_t *pEntity );
+
+	// Associate the entity's id and name so that it can be referenced later.
+	void AssociateEntity( gentity_t *pEntity );
+
+	// Make a valid script name.
+	int MakeValidScriptName( char **strScriptName );
+	
+	// First looks to see if a script has already been loaded, if so, return SCRIPT_ALREADYREGISTERED. If a script has
+	// NOT been already cached, that script is loaded and the return is SCRIPT_REGISTERED. If a script could not
+	// be found cached and could not be loaded we return SCRIPT_COULDNOTREGISTER.
+	int RegisterScript( const char *strFileName, void **ppBuf, int &iLength );
+
+	// Precache all the resources needed by a Script and it's Entity (or vice-versa).
+	int PrecacheEntity( gentity_t *pEntity );
+	
+	// Run the script.
+	void RunScript( const gentity_t *pEntity, const char *strScriptName );
+
+	// Log Icarus Entity's?
+	void Svcmd( void );
+
+	// Clear the list of entitys.
+	void ClearEntityList() { m_EntityList.clear(); }
+
+	// Save all Variables.
+	int VariableSave( void );
+
+	// Load all Variables.
+	int VariableLoad( void );
+
+    // Overiddables.
+
+	// Get the current Game flavor.
+	int GetFlavor();
+
+	//General
+	int		LoadFile( const char *name, void **buf );
+	void	CenterPrint( const char *format, ... );
+	void	DebugPrint( e_DebugPrintLevel, const char *, ... );
+	unsigned int GetTime( void );							//Gets the current time
+	//DWORD	GetTimeScale(void );
+	int 	PlaySound( int taskID, int entID, const char *name, const char *channel );	
+	void	Lerp2Pos( int taskID, int entID, vec3_t origin, vec3_t angles, float duration );
+	//void	Lerp2Origin( int taskID, int entID, vec3_t origin, float duration );
+	void	Lerp2Angles( int taskID, int entID, vec3_t angles, float duration );
+	int		GetTag( int entID, const char *name, int lookup, vec3_t info );
+	//void	Lerp2Start( int taskID, int entID, float duration );
+	//void	Lerp2End( int taskID, int entID, float duration );
+	void	Set( int taskID, int entID, const char *type_name, const char *data );
+	void	Use( int entID, const char *name );
+	void	Activate( int entID, const char *name );
+	void	Deactivate( int entID, const char *name );
+	void	Kill( int entID, const char *name );
+	void	Remove( int entID, const char *name );
+	float	Random( float min, float max );
+	void	Play( int taskID, int entID, const char *type, const char *name );
+
+	//Camera functions
+	void	CameraPan( vec3_t angles, vec3_t dir, float duration );
+	void	CameraMove( vec3_t origin, float duration );
+	void	CameraZoom( float fov, float duration );
+	void	CameraRoll( float angle, float duration );
+	void	CameraFollow( const char *name, float speed, float initLerp );
+	void	CameraTrack( const char *name, float speed, float initLerp );
+	void	CameraDistance( float dist, float initLerp );
+	void	CameraFade( float sr, float sg, float sb, float sa, float dr, float dg, float db, float da, float duration );
+	void	CameraPath( const char *name );
+	void	CameraEnable( void );
+	void	CameraDisable( void );
+	void	CameraShake( float intensity, int duration );
+
+	int		GetFloat( int entID, const char *name, float *value );
+	int		GetVector( int entID, const char *name, vec3_t value );
+	int		GetString( int entID, const char *name, char **value );
+
+	int		Evaluate( int p1Type, const char *p1, int p2Type, const char *p2, int operatorType );
+
+	void	DeclareVariable( int type, const char *name );
+	void	FreeVariable( const char *name );
+
+	//Save / Load functions
+	int		WriteSaveData( unsigned long chid, void *data, int length );
+	int		ReadSaveData( unsigned long chid, void *address, int length, void **addressptr = NULL );
+	int		LinkGame( int entID, int icarusID );
+	
+	// Access functions
+	int		CreateIcarus( int entID);
+			//Polls the engine for the sequencer of the entity matching the name passed
+	int		GetByName( const char *name );
+	// (g_entities[m_ownerID].svFlags&SVF_ICARUS_FREEZE)	// return -1 indicates invalid
+	int		IsFrozen(int entID);
+	void	Free(void* data);
+	void	*Malloc( int size );
+	float	MaxFloat(void);
+
+	// Script precache functions.
+	void	PrecacheRoff( const char *name );
+	void	PrecacheScript( const char *name );
+	void	PrecacheSound( const char *name );
+	void	PrecacheFromSet( const char *setname, const char *filename );
+};
+
+// A Quick accessor function for accessing Quake 3 Interface specific functions.
+inline CQuake3GameInterface *Quake3Game() { return (CQuake3GameInterface *)IGameInterface::GetGame(); }
+
+//////////////////////////////////////////////////////////////////////////
+/*					END Quake 3 Game Interface END						*/
+//////////////////////////////////////////////////////////////////////////
+
+#endif	//__Q3_INTERFACE__
\ No newline at end of file
diff --git a/code/game/SpeederNPC.c b/code/game/SpeederNPC.c
new file mode 100644
index 0000000..50e0664
--- /dev/null
+++ b/code/game/SpeederNPC.c
@@ -0,0 +1,1180 @@
+// leave this line at the top for all g_xxxx.cpp files...
+#include "g_headers.h"
+
+//seems to be a compiler bug, it doesn't clean out the #ifdefs between dif-compiles
+//or something, so the headers spew errors on these defs from the previous compile.
+//this fixes that. -rww
+#ifdef _JK2MP
+//get rid of all the crazy defs we added for this file
+#undef currentAngles
+#undef currentOrigin
+#undef mins
+#undef maxs
+#undef legsAnimTimer
+#undef torsoAnimTimer
+#undef bool
+#undef false
+#undef true
+
+#undef sqrtf
+#undef Q_flrand
+
+#undef MOD_EXPLOSIVE
+#endif
+
+#ifdef _JK2 //SP does not have this preprocessor for game like MP does
+#ifndef _JK2MP
+#define _JK2MP
+#endif
+#endif
+
+#ifndef _JK2MP //if single player
+#ifndef QAGAME //I don't think we have a QAGAME define
+#define QAGAME //but define it cause in sp we're always in the game
+#endif
+#endif
+
+#ifdef QAGAME //including game headers on cgame is FORBIDDEN ^_^
+#include "g_local.h"
+#elif defined _JK2MP
+#include "bg_public.h"
+#endif
+
+#ifndef _JK2MP
+#include "g_functions.h"
+#include "g_vehicles.h"
+#include "..\game\wp_saber.h"
+#include "../cgame/cg_local.h"
+#else
+#include "bg_vehicles.h"
+#endif
+
+#ifdef _JK2MP
+//this is really horrible, but it works! just be sure not to use any locals or anything
+//with these names (exluding bool, false, true). -rww
+#define currentAngles r.currentAngles
+#define currentOrigin r.currentOrigin
+#define mins r.mins
+#define maxs r.maxs
+#define legsAnimTimer legsTimer
+#define torsoAnimTimer torsoTimer
+#define bool qboolean
+#define false qfalse
+#define true qtrue
+
+#define sqrtf sqrt
+#define Q_flrand flrand
+
+#define MOD_EXPLOSIVE MOD_SUICIDE
+#else
+#define bgEntity_t gentity_t
+extern void NPC_SetAnim(gentity_t	*ent,int setAnimParts,int anim,int setAnimFlags, int iBlend);
+#endif
+
+extern float DotToSpot( vec3_t spot, vec3_t from, vec3_t fromAngles );
+#ifdef QAGAME //SP or gameside MP
+extern vmCvar_t	cg_thirdPersonAlpha;
+extern vec3_t playerMins;
+extern vec3_t playerMaxs;
+extern cvar_t	*g_speederControlScheme;
+extern void ChangeWeapon( gentity_t *ent, int newWeapon );
+extern void PM_SetAnim(pmove_t	*pm,int setAnimParts,int anim,int setAnimFlags, int blendTime);
+extern int PM_AnimLength( int index, animNumber_t anim );
+#endif
+
+#ifdef _JK2MP
+
+#include "../namespace_begin.h"
+
+extern void BG_SetAnim(playerState_t *ps, animation_t *animations, int setAnimParts,int anim,int setAnimFlags, int blendTime);
+extern int BG_GetTime(void);
+#endif
+
+//Alright, actually, most of this file is shared between game and cgame for MP.
+//I would like to keep it this way, so when modifying for SP please keep in
+//mind the bgEntity restrictions imposed. -rww
+
+#define	STRAFERAM_DURATION	8
+#define	STRAFERAM_ANGLE		8
+
+
+#ifndef _JK2MP
+bool	VEH_StartStrafeRam(Vehicle_t *pVeh, bool Right)
+{
+	if (!(pVeh->m_ulFlags&VEH_STRAFERAM))
+	{
+		float	speed = VectorLength(pVeh->m_pParentEntity->client->ps.velocity);
+		if (speed>400.0f)
+		{
+			// Compute Pos3
+			//--------------
+			vec3_t	right;
+			AngleVectors(pVeh->m_vOrientation, 0, right, 0);
+ 			VectorMA(pVeh->m_pParentEntity->client->ps.velocity, (Right)?( speed):(-speed), right, pVeh->m_pParentEntity->pos3);
+
+			pVeh->m_ulFlags				|= VEH_STRAFERAM;
+			pVeh->m_fStrafeTime			 = (Right)?(STRAFERAM_DURATION):(-STRAFERAM_DURATION);
+
+			if (pVeh->m_iSoundDebounceTimer<level.time && Q_irand(0,1)==0)
+			{
+				int	shiftSound = Q_irand(1,4);
+				switch (shiftSound)
+				{
+				case 1: shiftSound=pVeh->m_pVehicleInfo->soundShift1; break;
+				case 2: shiftSound=pVeh->m_pVehicleInfo->soundShift2; break;
+				case 3: shiftSound=pVeh->m_pVehicleInfo->soundShift3; break;
+				case 4: shiftSound=pVeh->m_pVehicleInfo->soundShift4; break;
+				}
+				if (shiftSound)
+				{
+					pVeh->m_iSoundDebounceTimer = level.time + Q_irand(1000, 4000);
+					G_SoundIndexOnEnt( pVeh->m_pParentEntity, CHAN_AUTO, shiftSound);
+				}
+			}
+			return true;
+		}
+	}
+	return false;
+}
+#else
+bool	VEH_StartStrafeRam(Vehicle_t *pVeh, bool Right, int Duration)
+{
+	return false;
+}
+#endif
+
+
+#ifdef QAGAME //game-only.. for now
+// Like a think or move command, this updates various vehicle properties.
+bool Update( Vehicle_t *pVeh, const usercmd_t *pUcmd )
+{
+	if ( !g_vehicleInfo[VEHICLE_BASE].Update( pVeh, pUcmd ) )
+	{
+		return false;
+	}
+
+	// See whether this vehicle should be exploding.
+	if ( pVeh->m_iDieTime != 0 )
+	{
+		pVeh->m_pVehicleInfo->DeathUpdate( pVeh );
+	}
+
+	// Update move direction.
+#ifndef _JK2MP //this makes prediction unhappy, and rightfully so.
+	gentity_t *parent = (gentity_t *)pVeh->m_pParentEntity;
+
+	if ( pVeh->m_ulFlags & VEH_FLYING )
+	{
+		vec3_t vVehAngles;
+		VectorSet(vVehAngles, 0, pVeh->m_vOrientation[YAW], 0 );
+		AngleVectors( vVehAngles, parent->client->ps.moveDir, NULL, NULL );
+	}
+	else
+	{
+		vec3_t vVehAngles;
+		VectorSet(vVehAngles, pVeh->m_vOrientation[PITCH], pVeh->m_vOrientation[YAW], 0 );
+		AngleVectors( vVehAngles, parent->client->ps.moveDir, NULL, NULL );
+	}
+
+	// Check For A Strafe Ram
+	//------------------------
+	if (!(pVeh->m_ulFlags&VEH_STRAFERAM) && !(pVeh->m_ulFlags&VEH_FLYING))
+	{
+		// Started A Strafe
+		//------------------
+		if (pVeh->m_ucmd.rightmove && !pVeh->m_fStrafeTime)
+		{
+			pVeh->m_fStrafeTime = (pVeh->m_ucmd.rightmove>0)?(level.time):(-1*level.time);
+		}
+
+		// Ended A Strafe
+		//----------------
+		else if (!pVeh->m_ucmd.rightmove && pVeh->m_fStrafeTime)
+		{
+			// If It Was A Short Burst, Start The Strafe Ram
+			//-----------------------------------------------
+			if ((level.time - abs(pVeh->m_fStrafeTime))<300)
+			{
+				if (!VEH_StartStrafeRam(pVeh, (pVeh->m_fStrafeTime>0)))
+				{
+					pVeh->m_fStrafeTime = 0;
+				}
+			}
+
+			// Otherwise, Clear The Timer
+			//----------------------------
+			else
+			{
+				pVeh->m_fStrafeTime = 0;
+			}
+		}
+	}
+
+	// If Currently In A StrafeRam, Check To See If It Is Done (Timed Out)
+	//---------------------------------------------------------------------
+  	else if (!pVeh->m_fStrafeTime)
+	{
+		pVeh->m_ulFlags &=~VEH_STRAFERAM;
+	}
+
+
+	// Exhaust Effects Start And Stop When The Accelerator Is Pressed
+	//----------------------------------------------------------------
+	if (pVeh->m_pVehicleInfo->iExhaustFX)
+	{
+		// Start It On Each Exhaust Bolt
+		//-------------------------------
+		if (pVeh->m_ucmd.forwardmove && !(pVeh->m_ulFlags&VEH_ACCELERATORON))
+		{
+			pVeh->m_ulFlags |= VEH_ACCELERATORON;
+			for (int i=0; (i<MAX_VEHICLE_EXHAUSTS && pVeh->m_iExhaustTag[i]!=-1); i++)
+			{
+				G_PlayEffect(pVeh->m_pVehicleInfo->iExhaustFX, parent->playerModel, pVeh->m_iExhaustTag[i], parent->s.number, parent->currentOrigin, 1,	qtrue);
+			}
+		}
+
+		// Stop It On Each Exhaust Bolt
+		//------------------------------
+		else if (!pVeh->m_ucmd.forwardmove && (pVeh->m_ulFlags&VEH_ACCELERATORON))
+		{
+			pVeh->m_ulFlags &=~VEH_ACCELERATORON;
+			for (int i=0; (i<MAX_VEHICLE_EXHAUSTS && pVeh->m_iExhaustTag[i]!=-1); i++)
+			{
+				G_StopEffect(pVeh->m_pVehicleInfo->iExhaustFX, parent->playerModel, pVeh->m_iExhaustTag[i], parent->s.number);
+			}
+		}
+	}
+
+	if (!(pVeh->m_ulFlags&VEH_ARMORLOW) && (pVeh->m_iArmor <= pVeh->m_pVehicleInfo->armor/3))
+	{
+		pVeh->m_ulFlags |= VEH_ARMORLOW;
+
+	}
+
+	// Armor Gone Effects (Fire)
+	//---------------------------
+	if (pVeh->m_pVehicleInfo->iArmorGoneFX)
+	{
+		if (!(pVeh->m_ulFlags&VEH_ARMORGONE) && (pVeh->m_iArmor <= 0))
+		{
+			pVeh->m_ulFlags |= VEH_ARMORGONE;
+			G_PlayEffect(pVeh->m_pVehicleInfo->iArmorGoneFX, parent->playerModel, parent->crotchBolt, parent->s.number, parent->currentOrigin, 1, qtrue);
+			parent->s.loopSound = G_SoundIndex( "sound/vehicles/common/fire_lp.wav" );
+		}
+	}
+#endif
+
+	return true;
+}
+#endif //QAGAME
+
+//MP RULE - ALL PROCESSMOVECOMMANDS FUNCTIONS MUST BE BG-COMPATIBLE!!!
+//If you really need to violate this rule for SP, then use ifdefs.
+//By BG-compatible, I mean no use of game-specific data - ONLY use
+//stuff available in the MP bgEntity (in SP, the bgEntity is #defined
+//as a gentity, but the MP-compatible access restrictions are based
+//on the bgEntity structure in the MP codebase) -rww
+// ProcessMoveCommands the Vehicle.
+static void ProcessMoveCommands( Vehicle_t *pVeh )
+{
+	/************************************************************************************/
+	/*	BEGIN	Here is where we move the vehicle (forward or back or whatever). BEGIN	*/
+	/************************************************************************************/
+	//Client sets ucmds and such for speed alterations
+	float speedInc, speedIdleDec, speedIdle, speedIdleAccel, speedMin, speedMax;
+	playerState_t *parentPS;
+	playerState_t *pilotPS = NULL;
+	int	curTime;
+
+#ifdef _JK2MP
+	parentPS = pVeh->m_pParentEntity->playerState;
+	if (pVeh->m_pPilot)
+	{
+		pilotPS = pVeh->m_pPilot->playerState;
+	}
+#else
+	parentPS = &pVeh->m_pParentEntity->client->ps;
+	if (pVeh->m_pPilot)
+	{
+		pilotPS = &pVeh->m_pPilot->client->ps;
+	}
+#endif
+
+
+	// If we're flying, make us accelerate at 40% (about half) acceleration rate, and restore the pitch
+	// to origin (straight) position (at 5% increments). 
+	if ( pVeh->m_ulFlags & VEH_FLYING ) 
+	{
+		speedInc = pVeh->m_pVehicleInfo->acceleration * pVeh->m_fTimeModifier * 0.4f;
+	}
+#ifdef _JK2MP
+	else if ( !parentPS->m_iVehicleNum )
+#else
+	else if ( !pVeh->m_pVehicleInfo->Inhabited( pVeh ) )
+#endif
+	{//drifts to a stop
+		speedInc = 0;
+		//pVeh->m_ucmd.forwardmove = 127;
+	}
+	else
+	{
+		speedInc = pVeh->m_pVehicleInfo->acceleration * pVeh->m_fTimeModifier;
+	}
+	speedIdleDec = pVeh->m_pVehicleInfo->decelIdle * pVeh->m_fTimeModifier;
+
+#ifndef _JK2MP//SP
+	curTime = level.time;
+#elif QAGAME//MP GAME
+	curTime = level.time;
+#elif CGAME//MP CGAME
+	//FIXME: pass in ucmd?  Not sure if this is reliable...
+	curTime = pm->cmd.serverTime;
+#endif
+
+
+
+	if ( (pVeh->m_pPilot /*&& (pilotPS->weapon == WP_NONE || pilotPS->weapon == WP_MELEE )*/ &&
+		(pVeh->m_ucmd.buttons & BUTTON_ALT_ATTACK) && pVeh->m_pVehicleInfo->turboSpeed)
+#ifdef _JK2MP
+		||
+		(parentPS && parentPS->electrifyTime > curTime && pVeh->m_pVehicleInfo->turboSpeed) //make them go!
+#endif
+		)
+	{
+#ifdef _JK2MP
+		if ( (parentPS && parentPS->electrifyTime > curTime) ||
+			 (pVeh->m_pPilot->playerState &&
+			  (pVeh->m_pPilot->playerState->weapon == WP_MELEE ||
+			  (pVeh->m_pPilot->playerState->weapon == WP_SABER && pVeh->m_pPilot->playerState->saberHolstered))) )
+		{
+#endif
+			if ((curTime - pVeh->m_iTurboTime)>pVeh->m_pVehicleInfo->turboRecharge)
+			{
+				pVeh->m_iTurboTime = (curTime + pVeh->m_pVehicleInfo->turboDuration);
+				if (pVeh->m_pVehicleInfo->iTurboStartFX)
+				{
+					int i;
+					for (i=0; (i<MAX_VEHICLE_EXHAUSTS && pVeh->m_iExhaustTag[i]!=-1); i++)
+					{
+						#ifndef _JK2MP//SP
+							// Start The Turbo Fx Start
+							//--------------------------
+							G_PlayEffect(pVeh->m_pVehicleInfo->iTurboStartFX, pVeh->m_pParentEntity->playerModel, pVeh->m_iExhaustTag[i], pVeh->m_pParentEntity->s.number, pVeh->m_pParentEntity->currentOrigin );
+
+							// Start The Looping Effect
+							//--------------------------
+							if (pVeh->m_pVehicleInfo->iTurboFX)
+							{
+								G_PlayEffect(pVeh->m_pVehicleInfo->iTurboFX,	  pVeh->m_pParentEntity->playerModel, pVeh->m_iExhaustTag[i], pVeh->m_pParentEntity->s.number, pVeh->m_pParentEntity->currentOrigin, pVeh->m_pVehicleInfo->turboDuration, qtrue);
+							}
+
+						#else
+							#ifdef QAGAME
+								if (pVeh->m_pParentEntity &&
+									pVeh->m_pParentEntity->ghoul2 &&
+									pVeh->m_pParentEntity->playerState)
+								{ //fine, I'll use a tempent for this, but only because it's played only once at the start of a turbo.
+									vec3_t boltOrg, boltDir;
+									mdxaBone_t boltMatrix;
+
+									VectorSet(boltDir, 0.0f, pVeh->m_pParentEntity->playerState->viewangles[YAW], 0.0f);
+
+									trap_G2API_GetBoltMatrix(pVeh->m_pParentEntity->ghoul2, 0, pVeh->m_iExhaustTag[i], &boltMatrix, boltDir, pVeh->m_pParentEntity->playerState->origin, level.time, NULL, pVeh->m_pParentEntity->modelScale);
+									BG_GiveMeVectorFromMatrix(&boltMatrix, ORIGIN, boltOrg);
+									BG_GiveMeVectorFromMatrix(&boltMatrix, ORIGIN, boltDir);
+									G_PlayEffectID(pVeh->m_pVehicleInfo->iTurboStartFX, boltOrg, boltDir);
+								}
+							#endif
+						#endif
+					}
+				}
+	#ifndef _JK2MP //kill me now
+				if (pVeh->m_pVehicleInfo->soundTurbo)
+				{
+					G_SoundIndexOnEnt(pVeh->m_pParentEntity, CHAN_AUTO, pVeh->m_pVehicleInfo->soundTurbo);
+				}
+	#endif
+				parentPS->speed = pVeh->m_pVehicleInfo->turboSpeed;	// Instantly Jump To Turbo Speed
+			}
+#ifdef _JK2MP
+		}
+#endif
+	}
+
+	// Slide Breaking
+	if (pVeh->m_ulFlags&VEH_SLIDEBREAKING)
+	{
+		if (pVeh->m_ucmd.forwardmove>=0 
+#ifndef _JK2MP
+			|| ((level.time - pVeh->m_pParentEntity->lastMoveTime)>500)
+#endif
+			)
+		{
+			pVeh->m_ulFlags &= ~VEH_SLIDEBREAKING;
+		}
+		parentPS->speed = 0;
+	}
+	else if (
+		(curTime > pVeh->m_iTurboTime) && 
+		!(pVeh->m_ulFlags&VEH_FLYING) && 
+		pVeh->m_ucmd.forwardmove<0 && 
+		fabs(pVeh->m_vOrientation[ROLL])>25.0f)
+	{
+		pVeh->m_ulFlags |= VEH_SLIDEBREAKING;
+	}
+
+
+	if ( curTime < pVeh->m_iTurboTime )
+	{
+		speedMax = pVeh->m_pVehicleInfo->turboSpeed;
+		if (parentPS)
+		{
+			parentPS->eFlags |= EF_JETPACK_ACTIVE;
+		}
+	}
+	else
+	{
+		speedMax = pVeh->m_pVehicleInfo->speedMax;
+		if (parentPS)
+		{
+			parentPS->eFlags &= ~EF_JETPACK_ACTIVE;
+		}
+	}
+
+
+	speedIdle = pVeh->m_pVehicleInfo->speedIdle;
+	speedIdleAccel = pVeh->m_pVehicleInfo->accelIdle * pVeh->m_fTimeModifier;
+	speedMin = pVeh->m_pVehicleInfo->speedMin;
+
+	if ( parentPS->speed || parentPS->groundEntityNum == ENTITYNUM_NONE  ||
+		 pVeh->m_ucmd.forwardmove || pVeh->m_ucmd.upmove > 0 )
+	{ 
+		if ( pVeh->m_ucmd.forwardmove > 0 && speedInc )
+		{
+			parentPS->speed += speedInc;
+		}
+		else if ( pVeh->m_ucmd.forwardmove < 0 )
+		{
+			if ( parentPS->speed > speedIdle )
+			{
+				parentPS->speed -= speedInc;
+			}
+			else if ( parentPS->speed > speedMin )
+			{
+				parentPS->speed -= speedIdleDec;
+			}
+		}
+		// No input, so coast to stop.
+		else if ( parentPS->speed > 0.0f )
+		{
+			parentPS->speed -= speedIdleDec;
+			if ( parentPS->speed < 0.0f )
+			{
+				parentPS->speed = 0.0f;
+			}
+		}
+		else if ( parentPS->speed < 0.0f )
+		{
+			parentPS->speed += speedIdleDec;
+			if ( parentPS->speed > 0.0f )
+			{
+				parentPS->speed = 0.0f;
+			}
+		}
+	}
+	else
+	{
+		if ( !pVeh->m_pVehicleInfo->strafePerc 
+#ifdef _JK2MP
+			|| (0 && pVeh->m_pParentEntity->s.number < MAX_CLIENTS) )
+#else
+			|| (!g_speederControlScheme->value && !pVeh->m_pParentEntity->s.number) )
+#endif
+		{//if in a strafe-capable vehicle, clear strafing unless using alternate control scheme
+			//pVeh->m_ucmd.rightmove = 0;
+		}
+	}
+
+	if ( parentPS->speed > speedMax )
+	{
+		parentPS->speed = speedMax;
+	}
+	else if ( parentPS->speed < speedMin )
+	{
+		parentPS->speed = speedMin;
+	}
+
+#ifndef _JK2MP
+	// In SP, The AI Pilots Can Directly Control The Speed Of Their Bike In Order To
+	// Match The Speed Of The Person They Are Trying To Chase
+	//-------------------------------------------------------------------------------
+	if (pVeh->m_pPilot && (pVeh->m_ucmd.buttons&BUTTON_VEH_SPEED))
+	{
+		parentPS->speed = pVeh->m_pPilot->client->ps.speed;
+	}
+#endif
+
+
+	/********************************************************************************/
+	/*	END Here is where we move the vehicle (forward or back or whatever). END	*/
+	/********************************************************************************/
+}
+
+//MP RULE - ALL PROCESSORIENTCOMMANDS FUNCTIONS MUST BE BG-COMPATIBLE!!!
+//If you really need to violate this rule for SP, then use ifdefs.
+//By BG-compatible, I mean no use of game-specific data - ONLY use
+//stuff available in the MP bgEntity (in SP, the bgEntity is #defined
+//as a gentity, but the MP-compatible access restrictions are based
+//on the bgEntity structure in the MP codebase) -rww
+//Oh, and please, use "< MAX_CLIENTS" to check for "player" and not
+//"!s.number", this is a universal check that will work for both SP
+//and MP. -rww
+// ProcessOrientCommands the Vehicle.
+#ifdef _JK2MP //temp hack til mp speeder controls are sorted -rww
+extern void AnimalProcessOri(Vehicle_t *pVeh);
+#endif
+void ProcessOrientCommands( Vehicle_t *pVeh )
+{
+	/********************************************************************************/
+	/*	BEGIN	Here is where make sure the vehicle is properly oriented.	BEGIN	*/
+	/********************************************************************************/
+	playerState_t *riderPS;
+	playerState_t *parentPS;
+
+#ifdef _JK2MP
+	float angDif;
+
+	if (pVeh->m_pPilot)
+	{
+		riderPS = pVeh->m_pPilot->playerState;
+	}
+	else
+	{
+		riderPS = pVeh->m_pParentEntity->playerState;
+	}
+	parentPS = pVeh->m_pParentEntity->playerState;
+
+	//pVeh->m_vOrientation[YAW] = 0.0f;//riderPS->viewangles[YAW];
+	angDif = AngleSubtract(pVeh->m_vOrientation[YAW], riderPS->viewangles[YAW]);
+	if (parentPS && parentPS->speed)
+	{
+		float s = parentPS->speed;
+		float maxDif = pVeh->m_pVehicleInfo->turningSpeed*4.0f; //magic number hackery
+		if (s < 0.0f)
+		{
+			s = -s;
+		}
+		angDif *= s/pVeh->m_pVehicleInfo->speedMax;
+		if (angDif > maxDif)
+		{
+			angDif = maxDif;
+		}
+		else if (angDif < -maxDif)
+		{
+			angDif = -maxDif;
+		}
+		pVeh->m_vOrientation[YAW] = AngleNormalize180(pVeh->m_vOrientation[YAW] - angDif*(pVeh->m_fTimeModifier*0.2f));
+
+		if (parentPS->electrifyTime > pm->cmd.serverTime)
+		{ //do some crazy stuff
+			pVeh->m_vOrientation[YAW] += (sin(pm->cmd.serverTime/1000.0f)*3.0f)*pVeh->m_fTimeModifier;
+		}
+	}
+
+#else
+ 	gentity_t *rider = pVeh->m_pParentEntity->owner;
+	if ( !rider || !rider->client )
+	{
+		riderPS = &pVeh->m_pParentEntity->client->ps;
+	}
+	else
+	{
+		riderPS = &rider->client->ps;
+	}
+	parentPS = &pVeh->m_pParentEntity->client->ps;
+
+	if (pVeh->m_ulFlags & VEH_FLYING)
+	{
+		pVeh->m_vOrientation[YAW] += pVeh->m_vAngularVelocity;
+	}
+	else if (
+		(pVeh->m_ulFlags & VEH_SLIDEBREAKING) ||	// No Angles Control While Out Of Control 
+		(pVeh->m_ulFlags & VEH_OUTOFCONTROL) 		// No Angles Control While Out Of Control 
+		)
+	{
+		// Any ability to change orientation?
+	}
+	else if (
+		(pVeh->m_ulFlags & VEH_STRAFERAM)			// No Angles Control While Strafe Ramming
+		)
+	{
+		if (pVeh->m_fStrafeTime>0)
+		{
+			pVeh->m_fStrafeTime--;
+			pVeh->m_vOrientation[ROLL] += (pVeh->m_fStrafeTime<( STRAFERAM_DURATION/2))?(-STRAFERAM_ANGLE):( STRAFERAM_ANGLE);
+		}
+		else if (pVeh->m_fStrafeTime<0)
+		{
+			pVeh->m_fStrafeTime++;
+			pVeh->m_vOrientation[ROLL] += (pVeh->m_fStrafeTime>(-STRAFERAM_DURATION/2))?( STRAFERAM_ANGLE):(-STRAFERAM_ANGLE);
+		}
+	}
+	else
+	{
+		pVeh->m_vOrientation[YAW] = riderPS->viewangles[YAW];
+	}
+#endif
+
+	/********************************************************************************/
+	/*	END	Here is where make sure the vehicle is properly oriented.	END			*/
+	/********************************************************************************/
+}
+
+#ifdef QAGAME
+
+extern void PM_SetAnim(pmove_t	*pm,int setAnimParts,int anim,int setAnimFlags, int blendTime);
+extern int PM_AnimLength( int index, animNumber_t anim );
+
+// This function makes sure that the vehicle is properly animated.
+void AnimateVehicle( Vehicle_t *pVeh )
+{
+}
+
+#endif //QAGAME
+
+//rest of file is shared
+
+#ifndef	_JK2MP
+extern void CG_ChangeWeapon( int num );
+#endif
+
+
+#ifndef _JK2MP
+extern void G_StartMatrixEffect( gentity_t *ent, int meFlags = 0, int length = 1000, float timeScale = 0.0f, int spinTime = 0 );
+#endif
+
+
+//NOTE NOTE NOTE NOTE NOTE NOTE
+//I want to keep this function BG too, because it's fairly generic already, and it
+//would be nice to have proper prediction of animations. -rww
+// This function makes sure that the rider's in this vehicle are properly animated.
+void AnimateRiders( Vehicle_t *pVeh )
+{
+	animNumber_t Anim = BOTH_VS_IDLE;
+	float fSpeedPercToMax;
+	int iFlags = SETANIM_FLAG_NORMAL, iBlend = 300;
+	playerState_t *pilotPS;
+	playerState_t *parentPS;
+	int curTime;
+
+
+	// Boarding animation.
+	if ( pVeh->m_iBoarding != 0 )
+	{
+		// We've just started moarding, set the amount of time it will take to finish moarding.
+		if ( pVeh->m_iBoarding < 0 )
+		{
+			int iAnimLen;
+
+			// Boarding from left...
+			if ( pVeh->m_iBoarding == -1 )
+			{
+				Anim = BOTH_VS_MOUNT_L;
+			}
+			else if ( pVeh->m_iBoarding == -2 )
+			{
+				Anim = BOTH_VS_MOUNT_R;
+			}
+			else if ( pVeh->m_iBoarding == -3 )
+			{
+				Anim = BOTH_VS_MOUNTJUMP_L;
+			}
+			else if ( pVeh->m_iBoarding == VEH_MOUNT_THROW_LEFT)
+			{
+				iBlend = 0;
+				Anim = BOTH_VS_MOUNTTHROW_R;
+			}
+			else if ( pVeh->m_iBoarding == VEH_MOUNT_THROW_RIGHT)
+			{
+				iBlend = 0;
+				Anim = BOTH_VS_MOUNTTHROW_L;
+			}
+
+			// Set the delay time (which happens to be the time it takes for the animation to complete).
+			// NOTE: Here I made it so the delay is actually 40% (0.4f) of the animation time.
+#ifdef _JK2MP
+			iAnimLen = BG_AnimLength( pVeh->m_pPilot->localAnimIndex, Anim ) * 0.4f;
+			pVeh->m_iBoarding = BG_GetTime() + iAnimLen;
+#else
+ 			iAnimLen = PM_AnimLength( pVeh->m_pPilot->client->clientInfo.animFileIndex, Anim );// * 0.4f;
+			if (pVeh->m_iBoarding!=VEH_MOUNT_THROW_LEFT && pVeh->m_iBoarding!=VEH_MOUNT_THROW_RIGHT)
+			{
+				pVeh->m_iBoarding = level.time + (iAnimLen*0.4f);
+			}
+			else
+			{
+				pVeh->m_iBoarding = level.time + iAnimLen;
+			}
+#endif
+			// Set the animation, which won't be interrupted until it's completed.
+			// TODO: But what if he's killed? Should the animation remain persistant???
+			iFlags = SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLD;
+			
+#ifdef _JK2MP
+			BG_SetAnim(pVeh->m_pPilot->playerState, bgAllAnims[pVeh->m_pPilot->localAnimIndex].anims,
+				SETANIM_BOTH, Anim, iFlags, iBlend);
+#else
+			NPC_SetAnim( pVeh->m_pPilot, SETANIM_BOTH, Anim, iFlags, iBlend );
+			if (pVeh->m_pOldPilot)
+			{
+				iAnimLen = PM_AnimLength( pVeh->m_pPilot->client->clientInfo.animFileIndex, BOTH_VS_MOUNTTHROWEE);
+				NPC_SetAnim( pVeh->m_pOldPilot, SETANIM_BOTH, BOTH_VS_MOUNTTHROWEE, iFlags, iBlend );
+			}
+#endif
+		}
+
+#ifndef _JK2MP
+		if (pVeh->m_pOldPilot && pVeh->m_pOldPilot->client->ps.torsoAnimTimer<=0)
+		{
+			if (Q_irand(0, player->count)==0)
+			{
+				player->count++;
+ 				player->lastEnemy = pVeh->m_pOldPilot;
+				G_StartMatrixEffect(player, MEF_LOOK_AT_ENEMY|MEF_NO_RANGEVAR|MEF_NO_VERTBOB|MEF_NO_SPIN, 1000);
+			}
+
+ 			gentity_t*	oldPilot = pVeh->m_pOldPilot;
+			pVeh->m_pVehicleInfo->Eject(pVeh, pVeh->m_pOldPilot, qtrue);		// will set pointer to zero
+
+			// Kill Him
+			//----------
+			oldPilot->client->noRagTime = -1;	// no ragdoll for you
+			G_Damage(oldPilot, pVeh->m_pPilot, pVeh->m_pPilot, pVeh->m_pPilot->currentAngles, pVeh->m_pPilot->currentOrigin, 1000, 0, MOD_CRUSH);
+
+			// Compute THe Throw Direction As Backwards From The Vehicle's Velocity
+			//----------------------------------------------------------------------
+			vec3_t		throwDir;
+			VectorScale(pVeh->m_pParentEntity->client->ps.velocity, -1.0f, throwDir);
+			VectorNormalize(throwDir);
+			throwDir[2] += 0.3f;	// up a little
+
+			// Now Throw Him Out
+			//-------------------
+			G_Throw(oldPilot, throwDir, VectorLength(pVeh->m_pParentEntity->client->ps.velocity)/10.0f);
+			NPC_SetAnim(oldPilot, SETANIM_BOTH, BOTH_DEATHBACKWARD1, SETANIM_FLAG_OVERRIDE, iBlend );
+		}
+#endif
+
+		return;
+	}
+
+#ifdef _JK2MP //fixme
+	if (1) return;
+#endif
+
+#ifdef _JK2MP
+	pilotPS = pVeh->m_pPilot->playerState;
+	parentPS = pVeh->m_pPilot->playerState;
+#else
+	pilotPS = &pVeh->m_pPilot->client->ps;
+	parentPS = &pVeh->m_pParentEntity->client->ps;
+#endif
+
+#ifndef _JK2MP//SP
+	curTime = level.time;
+#elif QAGAME//MP GAME
+	curTime = level.time;
+#elif CGAME//MP CGAME
+	//FIXME: pass in ucmd?  Not sure if this is reliable...
+	curTime = pm->cmd.serverTime;
+#endif
+
+	// Percentage of maximum speed relative to current speed.
+	fSpeedPercToMax = parentPS->speed / pVeh->m_pVehicleInfo->speedMax;
+
+/*	// Going in reverse...
+#ifdef _JK2MP
+	if ( pVeh->m_ucmd.forwardmove < 0 && !(pVeh->m_ulFlags & VEH_SLIDEBREAKING))
+#else
+	if ( fSpeedPercToMax < -0.018f && !(pVeh->m_ulFlags & VEH_SLIDEBREAKING))
+#endif
+	{
+		Anim = BOTH_VS_REV;
+		iBlend = 500;
+		bool		HasWeapon	= ((pilotPS->weapon != WP_NONE) && (pilotPS->weapon != WP_MELEE));
+		if (HasWeapon)
+		{
+			if (pVeh->m_pPilot->s.number<MAX_CLIENTS)
+			{
+				CG_ChangeWeapon(WP_NONE);
+			}
+
+			pVeh->m_pPilot->client->ps.weapon = WP_NONE;
+			G_RemoveWeaponModels(pVeh->m_pPilot);
+		}
+	}
+	else 
+*/
+	{
+		bool		HasWeapon	= ((pilotPS->weapon != WP_NONE) && (pilotPS->weapon != WP_MELEE));
+		bool		Attacking	= (HasWeapon && !!(pVeh->m_ucmd.buttons&BUTTON_ATTACK));
+#ifdef _JK2MP //fixme: flying tends to spaz out a lot
+		bool		Flying		= false;
+		bool		Crashing	= false;
+#else
+		bool		Flying		= !!(pVeh->m_ulFlags & VEH_FLYING);
+		bool		Crashing	= !!(pVeh->m_ulFlags & VEH_CRASHING);
+#endif
+		bool		Right		= (pVeh->m_ucmd.rightmove>0);
+		bool		Left		= (pVeh->m_ucmd.rightmove<0);
+		bool		Turbo		= (curTime<pVeh->m_iTurboTime);
+		EWeaponPose	WeaponPose	= WPOSE_NONE;
+
+
+		// Remove Crashing Flag
+		//----------------------
+		pVeh->m_ulFlags &= ~VEH_CRASHING;
+
+
+		// Put Away Saber When It Is Not Active
+		//--------------------------------------
+#ifndef _JK2MP
+		if (HasWeapon && 
+			(pVeh->m_pPilot->s.number>=MAX_CLIENTS || (cg.weaponSelectTime+500)<cg.time) &&
+			(Turbo || (pilotPS->weapon==WP_SABER && !pilotPS->SaberActive())))
+		{
+			if (pVeh->m_pPilot->s.number<MAX_CLIENTS)
+			{
+				pVeh->m_pPilot->client->ps.stats[ STAT_WEAPONS ] |= 1;					// Riding means you get WP_NONE
+				CG_ChangeWeapon(WP_NONE);
+			}
+
+			pVeh->m_pPilot->client->ps.weapon = WP_NONE;
+			G_RemoveWeaponModels(pVeh->m_pPilot);
+		}
+#endif
+
+		// Don't Interrupt Attack Anims
+		//------------------------------
+#ifdef _JK2MP
+		if (pilotPS->weaponTime>0)
+		{
+			return;
+		}
+#else		
+		if (pilotPS->torsoAnim>=BOTH_VS_ATL_S && pilotPS->torsoAnim<=BOTH_VS_ATF_G)
+		{
+			float		bodyCurrent	  = 0.0f;
+			int			bodyEnd		  = 0;
+			if (!!gi.G2API_GetBoneAnimIndex(&pVeh->m_pPilot->ghoul2[pVeh->m_pPilot->playerModel], pVeh->m_pPilot->rootBone, level.time, &bodyCurrent, NULL, &bodyEnd, NULL, NULL, NULL))
+			{
+				if (bodyCurrent<=((float)(bodyEnd)-1.5f))
+				{
+					return;
+				}
+			}
+		}
+#endif
+
+		// Compute The Weapon Pose
+		//--------------------------
+		if (pilotPS->weapon==WP_BLASTER)
+		{
+			WeaponPose = WPOSE_BLASTER;
+		}
+		else if (pilotPS->weapon==WP_SABER)
+		{
+			if ( (pVeh->m_ulFlags&VEH_SABERINLEFTHAND) && pilotPS->torsoAnim==BOTH_VS_ATL_TO_R_S)
+			{
+				pVeh->m_ulFlags	&= ~VEH_SABERINLEFTHAND;
+			}
+			if (!(pVeh->m_ulFlags&VEH_SABERINLEFTHAND) && pilotPS->torsoAnim==BOTH_VS_ATR_TO_L_S)
+			{
+				pVeh->m_ulFlags	|=  VEH_SABERINLEFTHAND;
+			}
+			WeaponPose = (pVeh->m_ulFlags&VEH_SABERINLEFTHAND)?(WPOSE_SABERLEFT):(WPOSE_SABERRIGHT);
+		}
+		
+
+ 		if (Attacking && WeaponPose)
+		{// Attack!
+			iBlend	= 100;
+ 			iFlags	= SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD|SETANIM_FLAG_RESTART;
+	
+			// Auto Aiming
+			//===============================================
+			if (!Left && !Right)		// Allow player strafe keys to override
+			{
+#ifndef _JK2MP
+				if (pVeh->m_pPilot->enemy)
+				{
+					vec3_t	toEnemy;
+					float	toEnemyDistance;
+					vec3_t	actorRight;
+					float	actorRightDot;
+
+					VectorSubtract(pVeh->m_pPilot->currentOrigin, pVeh->m_pPilot->enemy->currentOrigin, toEnemy);
+					toEnemyDistance = VectorNormalize(toEnemy);
+
+					AngleVectors(pVeh->m_pParentEntity->currentAngles, 0, actorRight, 0);
+					actorRightDot = DotProduct(toEnemy, actorRight);
+
+	 				if (fabsf(actorRightDot)>0.5f || pilotPS->weapon==WP_SABER)
+					{
+						Left	= (actorRightDot>0.0f);
+						Right	= !Left;
+					}
+					else
+					{
+						Right = Left = false;
+					}
+				}
+				else 
+#endif
+				if (pilotPS->weapon==WP_SABER && !Left && !Right)
+				{
+					Left = (WeaponPose==WPOSE_SABERLEFT);
+					Right	= !Left;
+				}
+			}
+
+
+			if (Left)
+			{// Attack Left
+				switch(WeaponPose)
+				{
+				case WPOSE_BLASTER:		Anim = BOTH_VS_ATL_G;		break;
+				case WPOSE_SABERLEFT:	Anim = BOTH_VS_ATL_S;		break;
+				case WPOSE_SABERRIGHT:	Anim = BOTH_VS_ATR_TO_L_S;	break;
+				default:				assert(0);
+				}
+			}
+			else if (Right)
+			{// Attack Right
+				switch(WeaponPose)
+				{
+				case WPOSE_BLASTER:		Anim = BOTH_VS_ATR_G;		break;
+				case WPOSE_SABERLEFT:	Anim = BOTH_VS_ATL_TO_R_S;	break;
+				case WPOSE_SABERRIGHT:	Anim = BOTH_VS_ATR_S;		break;
+				default:				assert(0);
+				}
+			}
+			else
+			{// Attack Ahead
+				switch(WeaponPose)
+				{
+				case WPOSE_BLASTER:		Anim = BOTH_VS_ATF_G;		break;
+				default:				assert(0);
+				}
+			}
+
+		}
+		else if (Left && pVeh->m_ucmd.buttons&BUTTON_USE)
+		{// Look To The Left Behind
+			iBlend	= 400;
+			iFlags	= SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLD;
+			switch(WeaponPose)
+			{
+			case WPOSE_SABERLEFT:	Anim = BOTH_VS_IDLE_SL;		break;
+			case WPOSE_SABERRIGHT:	Anim = BOTH_VS_IDLE_SR;		break;
+			default:				Anim = BOTH_VS_LOOKLEFT;
+			}
+		}
+		else if (Right && pVeh->m_ucmd.buttons&BUTTON_USE)
+		{// Look To The Right Behind
+			iBlend	= 400;
+			iFlags	= SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLD;
+			switch(WeaponPose)
+			{
+			case WPOSE_SABERLEFT:	Anim = BOTH_VS_IDLE_SL;		break;
+			case WPOSE_SABERRIGHT:	Anim = BOTH_VS_IDLE_SR;		break;
+			default:				Anim = BOTH_VS_LOOKRIGHT;
+			}
+		}
+		else if (Turbo)
+		{// Kicked In Turbo
+			iBlend	= 50;
+			iFlags	= SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLDLESS;
+			Anim	= BOTH_VS_TURBO;
+		}
+		else if (Flying)
+		{// Off the ground in a jump
+			iBlend	= 800;
+			iFlags	= SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLD;
+
+			switch(WeaponPose)
+			{
+			case WPOSE_NONE:		Anim = BOTH_VS_AIR;			break;
+			case WPOSE_BLASTER:		Anim = BOTH_VS_AIR_G;		break;
+			case WPOSE_SABERLEFT:	Anim = BOTH_VS_AIR_SL;		break;
+			case WPOSE_SABERRIGHT:	Anim = BOTH_VS_AIR_SR;		break;
+			default:				assert(0);
+			}
+		}
+		else if (Crashing)
+		{// Hit the ground!
+			iBlend	= 100;
+			iFlags	= SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLDLESS;
+
+			switch(WeaponPose)
+			{
+			case WPOSE_NONE:		Anim = BOTH_VS_LAND;		break;
+			case WPOSE_BLASTER:		Anim = BOTH_VS_LAND_G;		break;
+			case WPOSE_SABERLEFT:	Anim = BOTH_VS_LAND_SL;		break;
+			case WPOSE_SABERRIGHT:	Anim = BOTH_VS_LAND_SR;		break;
+			default:				assert(0);
+			}
+		}
+		else
+		{// No Special Moves
+			iBlend	= 300;
+ 			iFlags	= SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLDLESS;
+
+			if (pVeh->m_vOrientation[ROLL] <= -20)
+			{// Lean Left
+				switch(WeaponPose)
+				{
+				case WPOSE_NONE:		Anim = BOTH_VS_LEANL;			break;
+				case WPOSE_BLASTER:		Anim = BOTH_VS_LEANL_G;			break;
+				case WPOSE_SABERLEFT:	Anim = BOTH_VS_LEANL_SL;		break;
+				case WPOSE_SABERRIGHT:	Anim = BOTH_VS_LEANL_SR;		break;
+				default:				assert(0);
+				}
+			}
+			else if (pVeh->m_vOrientation[ROLL] >= 20)
+			{// Lean Right
+				switch(WeaponPose)
+				{
+				case WPOSE_NONE:		Anim = BOTH_VS_LEANR;			break;
+				case WPOSE_BLASTER:		Anim = BOTH_VS_LEANR_G;			break;
+				case WPOSE_SABERLEFT:	Anim = BOTH_VS_LEANR_SL;		break;
+				case WPOSE_SABERRIGHT:	Anim = BOTH_VS_LEANR_SR;		break;
+				default:				assert(0);
+				}
+			}
+			else
+			{// No Lean
+				switch(WeaponPose)
+				{
+				case WPOSE_NONE:		Anim = BOTH_VS_IDLE;			break;
+				case WPOSE_BLASTER:		Anim = BOTH_VS_IDLE_G;			break;
+				case WPOSE_SABERLEFT:	Anim = BOTH_VS_IDLE_SL;			break;
+				case WPOSE_SABERRIGHT:	Anim = BOTH_VS_IDLE_SR;			break;
+				default:				assert(0);
+				}
+			}
+		}// No Special Moves
+	}// Going backwards?
+
+#ifdef _JK2MP
+	iFlags &= ~SETANIM_FLAG_OVERRIDE;
+	if (pVeh->m_pPilot->playerState->torsoAnim == Anim)
+	{
+		pVeh->m_pPilot->playerState->torsoTimer = BG_AnimLength(pVeh->m_pPilot->localAnimIndex, Anim);
+	}
+	if (pVeh->m_pPilot->playerState->legsAnim == Anim)
+	{
+		pVeh->m_pPilot->playerState->legsTimer = BG_AnimLength(pVeh->m_pPilot->localAnimIndex, Anim);
+	}
+	BG_SetAnim(pVeh->m_pPilot->playerState, bgAllAnims[pVeh->m_pPilot->localAnimIndex].anims,
+		SETANIM_BOTH, Anim, iFlags|SETANIM_FLAG_HOLD, iBlend);
+#else
+	NPC_SetAnim( pVeh->m_pPilot, SETANIM_BOTH, Anim, iFlags, iBlend );
+#endif
+}
+
+#ifndef QAGAME
+void AttachRidersGeneric( Vehicle_t *pVeh );
+#endif
+
+void G_SetSpeederVehicleFunctions( vehicleInfo_t *pVehInfo )
+{
+#ifdef QAGAME
+	pVehInfo->AnimateVehicle			=		AnimateVehicle;
+	pVehInfo->AnimateRiders				=		AnimateRiders;
+//	pVehInfo->ValidateBoard				=		ValidateBoard;
+//	pVehInfo->SetParent					=		SetParent;
+//	pVehInfo->SetPilot					=		SetPilot;
+//	pVehInfo->AddPassenger				=		AddPassenger;
+//	pVehInfo->Animate					=		Animate;
+//	pVehInfo->Board						=		Board;
+//	pVehInfo->Eject						=		Eject;
+//	pVehInfo->EjectAll					=		EjectAll;
+//	pVehInfo->StartDeathDelay			=		StartDeathDelay;
+//	pVehInfo->DeathUpdate				=		DeathUpdate;
+//	pVehInfo->RegisterAssets			=		RegisterAssets;
+//	pVehInfo->Initialize				=		Initialize;
+	pVehInfo->Update					=		Update;
+//	pVehInfo->UpdateRider				=		UpdateRider;
+#endif
+
+	//shared
+	pVehInfo->ProcessMoveCommands		=		ProcessMoveCommands;
+	pVehInfo->ProcessOrientCommands		=		ProcessOrientCommands;
+
+#ifndef QAGAME //cgame prediction attachment func
+	pVehInfo->AttachRiders				=		AttachRidersGeneric;
+#endif
+//	pVehInfo->AttachRiders				=		AttachRiders;
+//	pVehInfo->Ghost						=		Ghost;
+//	pVehInfo->UnGhost					=		UnGhost;
+//	pVehInfo->Inhabited					=		Inhabited;
+}
+
+// Following is only in game, not in namespace
+#ifdef _JK2MP
+#include "../namespace_end.h"
+#endif
+
+#ifdef QAGAME
+extern void G_AllocateVehicleObject(Vehicle_t **pVeh);
+#endif
+
+#ifdef _JK2MP
+#include "../namespace_begin.h"
+#endif
+
+// Create/Allocate a new Animal Vehicle (initializing it as well).
+void G_CreateSpeederNPC( Vehicle_t **pVeh, const char *strType )
+{
+#ifdef _JK2MP
+#ifdef QAGAME
+	//these will remain on entities on the client once allocated because the pointer is
+	//never stomped. on the server, however, when an ent is freed, the entity struct is
+	//memset to 0, so this memory would be lost..
+    G_AllocateVehicleObject(pVeh);
+#else
+	if (!*pVeh)
+	{ //only allocate a new one if we really have to
+		(*pVeh) = (Vehicle_t *) BG_Alloc( sizeof(Vehicle_t) );
+	}
+#endif
+	memset(*pVeh, 0, sizeof(Vehicle_t));
+	(*pVeh)->m_pVehicleInfo = &g_vehicleInfo[BG_VehicleGetIndex( strType )];
+#else
+	// Allocate the Vehicle.
+	(*pVeh) = (Vehicle_t *) gi.Malloc( sizeof(Vehicle_t), TAG_G_ALLOC, qtrue );
+	(*pVeh)->m_pVehicleInfo = &g_vehicleInfo[BG_VehicleGetIndex( strType )];
+#endif
+}
+
+#ifdef _JK2MP
+
+#include "../namespace_end.h"
+
+//get rid of all the crazy defs we added for this file
+#undef currentAngles
+#undef currentOrigin
+#undef mins
+#undef maxs
+#undef legsAnimTimer
+#undef torsoAnimTimer
+#undef bool
+#undef false
+#undef true
+
+#undef sqrtf
+#undef Q_flrand
+
+#undef MOD_EXPLOSIVE
+#endif
diff --git a/code/game/WalkerNPC.c b/code/game/WalkerNPC.c
new file mode 100644
index 0000000..92df1b7
--- /dev/null
+++ b/code/game/WalkerNPC.c
@@ -0,0 +1,573 @@
+// leave this line at the top for all g_xxxx.cpp files...
+#include "g_headers.h"
+
+//seems to be a compiler bug, it doesn't clean out the #ifdefs between dif-compiles
+//or something, so the headers spew errors on these defs from the previous compile.
+//this fixes that. -rww
+#ifdef _JK2MP
+//get rid of all the crazy defs we added for this file
+#undef currentAngles
+#undef currentOrigin
+#undef mins
+#undef maxs
+#undef legsAnimTimer
+#undef torsoAnimTimer
+#undef bool
+#undef false
+#undef true
+
+#undef sqrtf
+#undef Q_flrand
+
+#undef MOD_EXPLOSIVE
+#endif
+
+#ifdef _JK2 //SP does not have this preprocessor for game like MP does
+#ifndef _JK2MP
+#define _JK2MP
+#endif
+#endif
+
+#ifndef _JK2MP //if single player
+#ifndef QAGAME //I don't think we have a QAGAME define
+#define QAGAME //but define it cause in sp we're always in the game
+#endif
+#endif
+
+#ifdef QAGAME //including game headers on cgame is FORBIDDEN ^_^
+#include "g_local.h"
+#elif defined _JK2MP
+#include "bg_public.h"
+#endif
+
+#ifndef _JK2MP
+#include "g_functions.h"
+#include "g_vehicles.h"
+#else
+#include "bg_vehicles.h"
+#endif
+
+#ifdef _JK2MP
+//this is really horrible, but it works! just be sure not to use any locals or anything
+//with these names (exluding bool, false, true). -rww
+#define currentAngles r.currentAngles
+#define currentOrigin r.currentOrigin
+#define mins r.mins
+#define maxs r.maxs
+#define legsAnimTimer legsTimer
+#define torsoAnimTimer torsoTimer
+#define bool qboolean
+#define false qfalse
+#define true qtrue
+
+#define sqrtf sqrt
+#define Q_flrand flrand
+
+#define MOD_EXPLOSIVE MOD_SUICIDE
+#else
+#define bgEntity_t gentity_t
+#endif
+
+#ifdef QAGAME //we only want a few of these functions for BG
+
+extern float DotToSpot( vec3_t spot, vec3_t from, vec3_t fromAngles );
+extern vmCvar_t	cg_thirdPersonAlpha;
+extern vec3_t playerMins;
+extern vec3_t playerMaxs;
+extern cvar_t	*g_speederControlScheme;
+extern void PM_SetAnim(pmove_t	*pm,int setAnimParts,int anim,int setAnimFlags, int blendTime);
+extern int PM_AnimLength( int index, animNumber_t anim );
+extern void Vehicle_SetAnim(gentity_t *ent,int setAnimParts,int anim,int setAnimFlags, int iBlend);
+extern void G_Knockdown( gentity_t *self, gentity_t *attacker, const vec3_t pushDir, float strength, qboolean breakSaberLock );
+extern void G_VehicleTrace( trace_t *results, const vec3_t start, const vec3_t tMins, const vec3_t tMaxs, const vec3_t end, int passEntityNum, int contentmask );
+
+static void RegisterAssets( Vehicle_t *pVeh )
+{
+	//atst uses turret weapon
+#ifdef _JK2MP
+	RegisterItem(BG_FindItemForWeapon(WP_TURRET));
+#else
+	// PUT SOMETHING HERE...
+#endif
+
+	//call the standard RegisterAssets now
+	g_vehicleInfo[VEHICLE_BASE].RegisterAssets( pVeh );
+}
+
+// Like a think or move command, this updates various vehicle properties.
+/*
+static bool Update( Vehicle_t *pVeh, const usercmd_t *pUcmd )
+{
+	return g_vehicleInfo[VEHICLE_BASE].Update( pVeh, pUcmd );
+}
+*/
+
+// Board this Vehicle (get on). The first entity to board an empty vehicle becomes the Pilot.
+static bool Board( Vehicle_t *pVeh, bgEntity_t *pEnt )
+{
+	if ( !g_vehicleInfo[VEHICLE_BASE].Board( pVeh, pEnt ) )
+		return false;
+
+	// Set the board wait time (they won't be able to do anything, including getting off, for this amount of time).
+	pVeh->m_iBoarding = level.time + 1500;
+
+	return true;
+}
+#endif //QAGAME
+
+#ifdef _JK2MP
+#include "../namespace_begin.h"
+#endif
+
+//MP RULE - ALL PROCESSMOVECOMMANDS FUNCTIONS MUST BE BG-COMPATIBLE!!!
+//If you really need to violate this rule for SP, then use ifdefs.
+//By BG-compatible, I mean no use of game-specific data - ONLY use
+//stuff available in the MP bgEntity (in SP, the bgEntity is #defined
+//as a gentity, but the MP-compatible access restrictions are based
+//on the bgEntity structure in the MP codebase) -rww
+// ProcessMoveCommands the Vehicle.
+static void ProcessMoveCommands( Vehicle_t *pVeh )
+{
+	/************************************************************************************/
+	/*	BEGIN	Here is where we move the vehicle (forward or back or whatever). BEGIN	*/
+	/************************************************************************************/
+
+	//Client sets ucmds and such for speed alterations
+	float speedInc, speedIdleDec, speedIdle, speedIdleAccel, speedMin, speedMax;
+	float fWalkSpeedMax;
+	bgEntity_t *parent = pVeh->m_pParentEntity;
+#ifdef _JK2MP
+	playerState_t *parentPS = parent->playerState;
+#else
+	playerState_t *parentPS = &parent->client->ps;
+#endif
+
+	speedIdleDec = pVeh->m_pVehicleInfo->decelIdle * pVeh->m_fTimeModifier;
+	speedMax = pVeh->m_pVehicleInfo->speedMax;
+
+	speedIdle = pVeh->m_pVehicleInfo->speedIdle;
+	speedIdleAccel = pVeh->m_pVehicleInfo->accelIdle * pVeh->m_fTimeModifier;
+	speedMin = pVeh->m_pVehicleInfo->speedMin;
+
+#ifdef _JK2MP
+	if ( !parentPS->m_iVehicleNum  )
+#else
+	if ( !pVeh->m_pVehicleInfo->Inhabited( pVeh ) )
+#endif
+	{//drifts to a stop
+		speedInc = speedIdle * pVeh->m_fTimeModifier;
+		VectorClear( parentPS->moveDir );
+		//m_ucmd.forwardmove = 127;
+		parentPS->speed = 0;
+	}
+	else
+	{
+		speedInc = pVeh->m_pVehicleInfo->acceleration * pVeh->m_fTimeModifier;
+	}
+
+	if ( parentPS->speed || parentPS->groundEntityNum == ENTITYNUM_NONE  ||
+		 pVeh->m_ucmd.forwardmove || pVeh->m_ucmd.upmove > 0 )
+	{ 
+		if ( pVeh->m_ucmd.forwardmove > 0 && speedInc )
+		{
+			parentPS->speed += speedInc;
+		}
+		else if ( pVeh->m_ucmd.forwardmove < 0 )
+		{
+			if ( parentPS->speed > speedIdle )
+			{
+				parentPS->speed -= speedInc;
+			}
+			else if ( parentPS->speed > speedMin )
+			{
+				parentPS->speed -= speedIdleDec;
+			}
+		}
+		// No input, so coast to stop.
+		else if ( parentPS->speed > 0.0f )
+		{
+			parentPS->speed -= speedIdleDec;
+			if ( parentPS->speed < 0.0f )
+			{
+				parentPS->speed = 0.0f;
+			}
+		}
+		else if ( parentPS->speed < 0.0f )
+		{
+			parentPS->speed += speedIdleDec;
+			if ( parentPS->speed > 0.0f )
+			{
+				parentPS->speed = 0.0f;
+			}
+		}
+	}
+	else
+	{
+		if ( pVeh->m_ucmd.forwardmove < 0 )
+		{
+			pVeh->m_ucmd.forwardmove = 0;
+		}
+		if ( pVeh->m_ucmd.upmove < 0 )
+		{
+			pVeh->m_ucmd.upmove = 0;
+		}
+
+		pVeh->m_ucmd.rightmove = 0;
+
+		/*if ( !pVeh->m_pVehicleInfo->strafePerc 
+			|| (!g_speederControlScheme->value && !parent->s.number) )
+		{//if in a strafe-capable vehicle, clear strafing unless using alternate control scheme
+			pVeh->m_ucmd.rightmove = 0;
+		}*/
+	}
+
+	fWalkSpeedMax = speedMax * 0.275f;
+	if ( pVeh->m_ucmd.buttons & BUTTON_WALKING && parentPS->speed > fWalkSpeedMax )
+	{
+		parentPS->speed = fWalkSpeedMax;
+	}
+	else if ( parentPS->speed > speedMax )
+	{
+		parentPS->speed = speedMax;
+	}
+	else if ( parentPS->speed < speedMin )
+	{
+		parentPS->speed = speedMin;
+	}
+
+	/********************************************************************************/
+	/*	END Here is where we move the vehicle (forward or back or whatever). END	*/
+	/********************************************************************************/
+}
+
+#ifdef _JK2MP
+extern void FighterYawAdjust(Vehicle_t *pVeh, playerState_t *riderPS, playerState_t *parentPS); //FighterNPC.c
+extern void FighterPitchAdjust(Vehicle_t *pVeh, playerState_t *riderPS, playerState_t *parentPS); //FighterNPC.c
+#endif
+
+//MP RULE - ALL PROCESSORIENTCOMMANDS FUNCTIONS MUST BE BG-COMPATIBLE!!!
+//If you really need to violate this rule for SP, then use ifdefs.
+//By BG-compatible, I mean no use of game-specific data - ONLY use
+//stuff available in the MP bgEntity (in SP, the bgEntity is #defined
+//as a gentity, but the MP-compatible access restrictions are based
+//on the bgEntity structure in the MP codebase) -rww
+// ProcessOrientCommands the Vehicle.
+static void ProcessOrientCommands( Vehicle_t *pVeh )
+{
+	/********************************************************************************/
+	/*	BEGIN	Here is where make sure the vehicle is properly oriented.	BEGIN	*/
+	/********************************************************************************/
+	float speed;
+	bgEntity_t *parent = pVeh->m_pParentEntity;
+	playerState_t *parentPS, *riderPS;
+
+#ifdef _JK2MP
+	bgEntity_t *rider = NULL;
+	if (parent->s.owner != ENTITYNUM_NONE)
+	{
+		rider = PM_BGEntForNum(parent->s.owner); //&g_entities[parent->r.ownerNum];
+	}
+#else
+	gentity_t *rider = parent->owner;
+#endif
+
+#ifdef _JK2MP
+	if ( !rider )
+#else
+	if ( !rider || !rider->client )
+#endif
+	{
+		rider = parent;
+	}
+
+#ifdef _JK2MP
+	parentPS = parent->playerState;
+	riderPS = rider->playerState;
+#else
+	parentPS = &parent->client->ps;
+	riderPS = &rider->client->ps;
+#endif
+
+	speed = VectorLength( parentPS->velocity );
+
+	// If the player is the rider...
+	if ( rider->s.number < MAX_CLIENTS )
+	{//FIXME: use the vehicle's turning stat in this calc
+#ifdef _JK2MP
+		FighterYawAdjust(pVeh, riderPS, parentPS);
+		//FighterPitchAdjust(pVeh, riderPS, parentPS);
+		pVeh->m_vOrientation[PITCH] = riderPS->viewangles[PITCH];
+#else
+		pVeh->m_vOrientation[YAW] = riderPS->viewangles[YAW];
+		pVeh->m_vOrientation[PITCH] = riderPS->viewangles[PITCH];
+#endif
+	}
+	else
+	{
+		float turnSpeed = pVeh->m_pVehicleInfo->turningSpeed;
+		if ( !pVeh->m_pVehicleInfo->turnWhenStopped 
+			&& !parentPS->speed )//FIXME: or !pVeh->m_ucmd.forwardmove?
+		{//can't turn when not moving
+			//FIXME: or ramp up to max turnSpeed?
+			turnSpeed = 0.0f;
+		}
+#ifdef _JK2MP
+		if (rider->s.eType == ET_NPC)
+#else
+		if ( !rider || rider->NPC )
+#endif
+		{//help NPCs out some
+			turnSpeed *= 2.0f;
+#ifdef _JK2MP
+			if (parentPS->speed > 200.0f)
+#else
+			if ( parent->client->ps.speed > 200.0f )
+#endif
+			{
+				turnSpeed += turnSpeed * parentPS->speed/200.0f*0.05f;
+			}
+		}
+		turnSpeed *= pVeh->m_fTimeModifier;
+
+		//default control scheme: strafing turns, mouselook aims
+		if ( pVeh->m_ucmd.rightmove < 0 )
+		{
+			pVeh->m_vOrientation[YAW] += turnSpeed;
+		}
+		else if ( pVeh->m_ucmd.rightmove > 0 )
+		{
+			pVeh->m_vOrientation[YAW] -= turnSpeed;
+		}
+
+		if ( pVeh->m_pVehicleInfo->malfunctionArmorLevel && pVeh->m_iArmor <= pVeh->m_pVehicleInfo->malfunctionArmorLevel )
+		{//damaged badly
+		}
+	}
+
+	/********************************************************************************/
+	/*	END	Here is where make sure the vehicle is properly oriented.	END			*/
+	/********************************************************************************/
+}
+
+#ifdef QAGAME //back to our game-only functions
+// This function makes sure that the vehicle is properly animated.
+static void AnimateVehicle( Vehicle_t *pVeh )
+{
+	animNumber_t Anim = BOTH_STAND1; 
+	int iFlags = SETANIM_FLAG_NORMAL, iBlend = 300;
+	gentity_t *parent = (gentity_t *)pVeh->m_pParentEntity;
+	float fSpeedPercToMax;
+
+	// We're dead (boarding is reused here so I don't have to make another variable :-).
+	if ( parent->health <= 0 ) 
+	{
+		if ( pVeh->m_iBoarding != -999 )	// Animate the death just once!
+		{
+			pVeh->m_iBoarding = -999;
+			iFlags = SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLD; 
+
+			// FIXME! Why do you keep repeating over and over!!?!?!? Bastard!
+			//Vehicle_SetAnim( parent, SETANIM_LEGS, BOTH_VT_DEATH1, iFlags, iBlend );
+		}
+		return;
+	}
+
+// Following is redundant to g_vehicles.c
+//	if ( pVeh->m_iBoarding )
+//	{
+//		//we have no boarding anim
+//		if (pVeh->m_iBoarding < level.time)
+//		{ //we are on now
+//			pVeh->m_iBoarding = 0;
+//		}
+//		else
+//		{
+//			return;
+//		}
+//	}
+
+	// Percentage of maximum speed relative to current speed.
+	//float fSpeed = VectorLength( client->ps.velocity );
+	fSpeedPercToMax = parent->client->ps.speed / pVeh->m_pVehicleInfo->speedMax; 
+
+	// If we're moving...
+	if ( fSpeedPercToMax > 0.0f ) //fSpeedPercToMax >= 0.85f )
+	{  
+		float fYawDelta;
+
+		iBlend = 300;
+		iFlags = SETANIM_FLAG_OVERRIDE;
+		fYawDelta = pVeh->m_vPrevOrientation[YAW] - pVeh->m_vOrientation[YAW];
+
+		// NOTE: Mikes suggestion for fixing the stuttering walk (left/right) is to maintain the
+		// current frame between animations. I have no clue how to do this and have to work on other
+		// stuff so good luck to him :-p AReis
+
+		// If we're walking (or our speed is less than .275%)...
+		if ( ( pVeh->m_ucmd.buttons & BUTTON_WALKING ) || fSpeedPercToMax < 0.275f )
+		{ 
+			// Make them lean if we're turning.
+			/*if ( fYawDelta < -0.0001f )
+			{
+				Anim = BOTH_VT_WALK_FWD_L;
+			}
+			else if ( fYawDelta > 0.0001 )
+			{
+				Anim = BOTH_VT_WALK_FWD_R;
+			}
+			else*/
+			{
+				Anim = BOTH_WALK1;
+			}
+		}
+		// otherwise we're running.
+		else
+		{
+			// Make them lean if we're turning.
+			/*if ( fYawDelta < -0.0001f )
+			{
+				Anim = BOTH_VT_RUN_FWD_L;
+			}
+			else if ( fYawDelta > 0.0001 )
+			{
+				Anim = BOTH_VT_RUN_FWD_R;
+			}
+			else*/
+			{
+				Anim = BOTH_RUN1;
+			}
+		}
+	}
+	else
+	{
+		// Going in reverse...
+		if ( fSpeedPercToMax < -0.018f )
+		{
+			iFlags = SETANIM_FLAG_NORMAL;
+			Anim = BOTH_WALKBACK1;
+			iBlend = 500;
+		}
+		else
+		{
+			//int iChance = Q_irand( 0, 20000 ); 
+
+			// Every once in a while buck or do a different idle...
+			iFlags = SETANIM_FLAG_NORMAL | SETANIM_FLAG_RESTART | SETANIM_FLAG_HOLD; 
+			iBlend = 600;
+#ifdef _JK2MP
+			if (parent->client->ps.m_iVehicleNum)
+#else
+			if ( pVeh->m_pVehicleInfo->Inhabited( pVeh ) )
+#endif
+			{//occupado
+				Anim = BOTH_STAND1;
+			}
+			else
+			{//wide open for you, baby
+				Anim = BOTH_STAND2;
+			}
+		}
+	}
+
+	Vehicle_SetAnim( parent, SETANIM_LEGS, Anim, iFlags, iBlend );
+}
+
+//rwwFIXMEFIXME: This is all going to have to be predicted I think, or it will feel awful
+//and lagged
+#endif //QAGAME
+
+#ifndef QAGAME
+void AttachRidersGeneric( Vehicle_t *pVeh );
+#endif
+
+//on the client this function will only set up the process command funcs
+void G_SetWalkerVehicleFunctions( vehicleInfo_t *pVehInfo )
+{
+#ifdef QAGAME
+	pVehInfo->AnimateVehicle			=		AnimateVehicle;
+//	pVehInfo->AnimateRiders				=		AnimateRiders;
+//	pVehInfo->ValidateBoard				=		ValidateBoard;
+//	pVehInfo->SetParent					=		SetParent;
+//	pVehInfo->SetPilot					=		SetPilot;
+//	pVehInfo->AddPassenger				=		AddPassenger;
+//	pVehInfo->Animate					=		Animate;
+	pVehInfo->Board						=		Board;
+//	pVehInfo->Eject						=		Eject;
+//	pVehInfo->EjectAll					=		EjectAll;
+//	pVehInfo->StartDeathDelay			=		StartDeathDelay;
+//	pVehInfo->DeathUpdate				=		DeathUpdate;
+	pVehInfo->RegisterAssets			=		RegisterAssets;
+//	pVehInfo->Initialize				=		Initialize;
+//	pVehInfo->Update					=		Update;
+//	pVehInfo->UpdateRider				=		UpdateRider;
+#endif //QAGAME
+	pVehInfo->ProcessMoveCommands		=		ProcessMoveCommands;
+	pVehInfo->ProcessOrientCommands		=		ProcessOrientCommands;
+
+#ifndef QAGAME //cgame prediction attachment func
+	pVehInfo->AttachRiders				=		AttachRidersGeneric;
+#endif
+//	pVehInfo->AttachRiders				=		AttachRiders;
+//	pVehInfo->Ghost						=		Ghost;
+//	pVehInfo->UnGhost					=		UnGhost;
+//	pVehInfo->Inhabited					=		Inhabited;
+}
+
+// Following is only in game, not in namespace
+#ifdef _JK2MP
+#include "../namespace_end.h"
+#endif
+
+#ifdef QAGAME
+extern void G_AllocateVehicleObject(Vehicle_t **pVeh);
+#endif
+
+#ifdef _JK2MP
+#include "../namespace_begin.h"
+#endif
+
+// Create/Allocate a new Animal Vehicle (initializing it as well).
+//this is a BG function too in MP so don't un-bg-compatibilify it -rww
+void G_CreateWalkerNPC( Vehicle_t **pVeh, const char *strAnimalType )
+{
+	// Allocate the Vehicle.
+#ifdef _JK2MP
+#ifdef QAGAME
+	//these will remain on entities on the client once allocated because the pointer is
+	//never stomped. on the server, however, when an ent is freed, the entity struct is
+	//memset to 0, so this memory would be lost..
+    G_AllocateVehicleObject(pVeh);
+#else
+	if (!*pVeh)
+	{ //only allocate a new one if we really have to
+		(*pVeh) = (Vehicle_t *) BG_Alloc( sizeof(Vehicle_t) );
+	}
+#endif
+	memset(*pVeh, 0, sizeof(Vehicle_t));
+	(*pVeh)->m_pVehicleInfo = &g_vehicleInfo[BG_VehicleGetIndex( strAnimalType )];
+#else
+	(*pVeh) = (Vehicle_t *) gi.Malloc( sizeof(Vehicle_t), TAG_G_ALLOC, qtrue );
+	(*pVeh)->m_pVehicleInfo = &g_vehicleInfo[BG_VehicleGetIndex( strAnimalType )];
+#endif
+}
+
+#ifdef _JK2MP
+
+#include "../namespace_end.h"
+
+//get rid of all the crazy defs we added for this file
+#undef currentAngles
+#undef currentOrigin
+#undef mins
+#undef maxs
+#undef legsAnimTimer
+#undef torsoAnimTimer
+#undef bool
+#undef false
+#undef true
+
+#undef sqrtf
+#undef Q_flrand
+
+#undef MOD_EXPLOSIVE
+#endif
diff --git a/code/game/ai.h b/code/game/ai.h
new file mode 100644
index 0000000..8e3f758
--- /dev/null
+++ b/code/game/ai.h
@@ -0,0 +1,134 @@
+#ifndef __AI__
+#define __AI__
+
+//Distance ratings
+enum distance_e
+{
+	DIST_MELEE,
+	DIST_LONG,
+};
+
+//Attack types
+enum attack_e
+{
+	ATTACK_MELEE,
+	ATTACK_RANGE,
+};
+
+enum
+{
+	SQUAD_IDLE,					//No target found, waiting
+	SQUAD_STAND_AND_SHOOT,		//Standing in position and shoot (no cover)
+	SQUAD_RETREAT,				//Running away from combat
+	SQUAD_COVER,				//Under protective cover
+	SQUAD_TRANSITION,			//Moving between points, not firing
+	SQUAD_POINT,				//On point, laying down suppressive fire
+	SQUAD_SCOUT,				//Poking out to draw enemy
+	NUM_SQUAD_STATES,
+};
+
+//sigh... had to move in here for groupInfo
+typedef enum //# rank_e
+{
+	RANK_CIVILIAN,
+	RANK_CREWMAN,
+	RANK_ENSIGN,
+	RANK_LT_JG,
+	RANK_LT,
+	RANK_LT_COMM,
+	RANK_COMMANDER,
+	RANK_CAPTAIN
+} rank_t;
+
+qboolean NPC_CheckPlayerTeamStealth( void );
+
+//AI_GRENADIER
+void NPC_BSGrenadier_Default( void );
+
+//AI_TUSKEN
+void NPC_BSTusken_Default( void );
+
+//AI_SNIPER
+void NPC_BSSniper_Default( void );
+
+//AI_STORMTROOPER
+void Saboteur_Decloak( gentity_t *self, int uncloakTime = 2000 );
+void NPC_BSST_Investigate( void );
+void NPC_BSST_Default( void );
+void NPC_BSST_Sleep( void );
+
+//AI_JEDI
+void NPC_BSJedi_Investigate( void );
+void NPC_BSJedi_Default( void );
+void NPC_BSJedi_FollowLeader( void );
+
+// AI_DROID
+void NPC_BSDroid_Default( void );
+
+// AI_ImperialProbe
+void NPC_BSImperialProbe_Default( void );
+
+// AI_atst
+void NPC_BSATST_Default( void );
+
+void NPC_BSInterrogator_Default( void );
+
+// AI Mark 1
+void NPC_BSMark1_Default( void );
+
+// AI Mark 2
+void NPC_BSMark2_Default( void );
+
+//monsters
+void NPC_BSMineMonster_Default( void );
+void NPC_BSHowler_Default( void );
+void NPC_BSRancor_Default( void );
+void NPC_BSWampa_Default( void );
+void NPC_BSSandCreature_Default( void );
+
+// animals
+void NPC_BSAnimal_Default( void );
+
+//Utilities
+//Group AI
+#define	MAX_FRAME_GROUPS	32
+// !!!!!!!!!! LOADSAVE-affecting structure !!!!!!!!!!
+typedef struct AIGroupMember_s
+{
+	int	number;
+	int waypoint;
+	int pathCostToEnemy;
+	int	closestBuddy;
+} AIGroupMember_t;
+
+#define MAX_GROUP_MEMBERS 32
+// !!!!!!!!!! LOADSAVE-affecting structure !!!!!!!!!!
+typedef struct AIGroupInfo_s
+{
+	int			numGroup;
+	qboolean	processed;
+	team_t		team;
+	gentity_t	*enemy;
+	int			enemyWP;
+	int			speechDebounceTime;
+	int			lastClearShotTime;
+	int			lastSeenEnemyTime;
+	int			morale;
+	int			moraleAdjust;
+	int			moraleDebounce;
+	int			memberValidateTime;
+	int			activeMemberNum;
+	gentity_t	*commander;
+	vec3_t		enemyLastSeenPos;
+	int			numState[ NUM_SQUAD_STATES ];
+	AIGroupMember_t member[ MAX_GROUP_MEMBERS ];
+} AIGroupInfo_t;
+
+int	AI_GetGroupSize( vec3_t origin, int radius, team_t playerTeam, gentity_t *avoid = NULL );
+int AI_GetGroupSize( gentity_t *ent, int radius );
+
+void AI_GetGroup( gentity_t *self );
+
+gentity_t *AI_DistributeAttack( gentity_t *attacker, gentity_t *enemy, team_t team, int threshold );
+
+#endif	//__AI__
\ No newline at end of file
diff --git a/code/game/anims.h b/code/game/anims.h
new file mode 100644
index 0000000..7fb3e15
--- /dev/null
+++ b/code/game/anims.h
@@ -0,0 +1,1797 @@
+#ifndef __ANIMS_H__
+#define __ANIMS_H__
+// playerAnimations
+
+
+typedef enum //# animNumber_e
+{
+	//=================================================
+	//HEAD ANIMS
+	//=================================================
+	//# #sep Head-only anims
+	FACE_TALK0,			//# silent
+	FACE_TALK1,			//# quiet
+	FACE_TALK2,			//# semi-quiet
+	FACE_TALK3,			//# semi-loud
+	FACE_TALK4,			//# loud
+	FACE_ALERT,				//# 
+	FACE_SMILE,				//# 
+	FACE_FROWN,				//# 
+	FACE_DEAD,				//# 
+
+	//=================================================
+	//ANIMS IN WHICH UPPER AND LOWER OBJECTS ARE IN MD3
+	//=================================================
+	//# #sep BOTH_ DEATHS
+	BOTH_DEATH1,		//# First Death anim
+	BOTH_DEATH2,			//# Second Death anim
+	BOTH_DEATH3,			//# Third Death anim
+	BOTH_DEATH4,			//# Fourth Death anim
+	BOTH_DEATH5,			//# Fifth Death anim
+	BOTH_DEATH6,			//# Sixth Death anim
+	BOTH_DEATH7,			//# Seventh Death anim
+	BOTH_DEATH8,			//# 
+	BOTH_DEATH9,			//# 
+	BOTH_DEATH10,			//# 
+	BOTH_DEATH11,			//#
+	BOTH_DEATH12,			//# 
+	BOTH_DEATH13,			//# 
+	BOTH_DEATH14,			//# 
+	BOTH_DEATH15,			//# 
+	BOTH_DEATH16,			//# 
+	BOTH_DEATH17,			//# 
+	BOTH_DEATH18,			//# 
+	BOTH_DEATH19,			//# 
+	BOTH_DEATH20,			//# 
+	BOTH_DEATH21,			//# 
+	BOTH_DEATH22,			//# 
+	BOTH_DEATH23,			//# 
+	BOTH_DEATH24,			//# 
+	BOTH_DEATH25,			//# 
+
+	BOTH_DEATHFORWARD1,		//# First Death in which they get thrown forward
+	BOTH_DEATHFORWARD2,		//# Second Death in which they get thrown forward
+	BOTH_DEATHFORWARD3,		//# Tavion's falling in cin# 23
+	BOTH_DEATHBACKWARD1,	//# First Death in which they get thrown backward
+	BOTH_DEATHBACKWARD2,	//# Second Death in which they get thrown backward
+
+	BOTH_DEATH1IDLE,		//# Idle while close to death
+	BOTH_LYINGDEATH1,		//# Death to play when killed lying down
+	BOTH_STUMBLEDEATH1,		//# Stumble forward and fall face first death
+	BOTH_FALLDEATH1,		//# Fall forward off a high cliff and splat death - start
+	BOTH_FALLDEATH1INAIR,	//# Fall forward off a high cliff and splat death - loop
+	BOTH_FALLDEATH1LAND,	//# Fall forward off a high cliff and splat death - hit bottom
+	BOTH_DEATH_ROLL,		//# Death anim from a roll
+	BOTH_DEATH_FLIP,		//# Death anim from a flip
+	BOTH_DEATH_SPIN_90_R,	//# Death anim when facing 90 degrees right
+	BOTH_DEATH_SPIN_90_L,	//# Death anim when facing 90 degrees left
+	BOTH_DEATH_SPIN_180,	//# Death anim when facing backwards
+	BOTH_DEATH_LYING_UP,	//# Death anim when lying on back
+	BOTH_DEATH_LYING_DN,	//# Death anim when lying on front
+	BOTH_DEATH_FALLING_DN,	//# Death anim when falling on face
+	BOTH_DEATH_FALLING_UP,	//# Death anim when falling on back
+	BOTH_DEATH_CROUCHED,	//# Death anim when crouched
+	//# #sep BOTH_ DEAD POSES # Should be last frame of corresponding previous anims
+	BOTH_DEAD1,				//# First Death finished pose
+	BOTH_DEAD2,				//# Second Death finished pose
+	BOTH_DEAD3,				//# Third Death finished pose
+	BOTH_DEAD4,				//# Fourth Death finished pose
+	BOTH_DEAD5,				//# Fifth Death finished pose
+	BOTH_DEAD6,				//# Sixth Death finished pose
+	BOTH_DEAD7,				//# Seventh Death finished pose
+	BOTH_DEAD8,				//# 
+	BOTH_DEAD9,				//# 
+	BOTH_DEAD10,			//# 
+	BOTH_DEAD11,			//#
+	BOTH_DEAD12,			//# 
+	BOTH_DEAD13,			//# 
+	BOTH_DEAD14,			//# 
+	BOTH_DEAD15,			//# 
+	BOTH_DEAD16,			//# 
+	BOTH_DEAD17,			//# 
+	BOTH_DEAD18,			//# 
+	BOTH_DEAD19,			//# 
+	BOTH_DEAD20,			//# 
+	BOTH_DEAD21,			//# 
+	BOTH_DEAD22,			//# 
+	BOTH_DEAD23,			//# 
+	BOTH_DEAD24,			//# 
+	BOTH_DEAD25,			//# 
+	BOTH_DEADFORWARD1,		//# First thrown forward death finished pose
+	BOTH_DEADFORWARD2,		//# Second thrown forward death finished pose
+	BOTH_DEADBACKWARD1,		//# First thrown backward death finished pose
+	BOTH_DEADBACKWARD2,		//# Second thrown backward death finished pose
+	BOTH_LYINGDEAD1,		//# Killed lying down death finished pose
+	BOTH_STUMBLEDEAD1,		//# Stumble forward death finished pose
+	BOTH_FALLDEAD1LAND,		//# Fall forward and splat death finished pose
+	//# #sep BOTH_ DEAD TWITCH/FLOP # React to being shot from death poses
+	BOTH_DEADFLOP1,		//# React to being shot from First Death finished pose
+	BOTH_DEADFLOP2,		//# React to being shot from Second Death finished pose
+	BOTH_DISMEMBER_HEAD1,	//#
+	BOTH_DISMEMBER_TORSO1,	//#
+	BOTH_DISMEMBER_LLEG,	//#
+	BOTH_DISMEMBER_RLEG,	//#
+	BOTH_DISMEMBER_RARM,	//#
+	BOTH_DISMEMBER_LARM,	//#
+	//# #sep BOTH_ PAINS
+	BOTH_PAIN1,				//# First take pain anim
+	BOTH_PAIN2,				//# Second take pain anim
+	BOTH_PAIN3,				//# Third take pain anim
+	BOTH_PAIN4,				//# Fourth take pain anim
+	BOTH_PAIN5,				//# Fifth take pain anim - from behind
+	BOTH_PAIN6,				//# Sixth take pain anim - from behind
+	BOTH_PAIN7,				//# Seventh take pain anim - from behind
+	BOTH_PAIN8,				//# Eigth take pain anim - from behind
+	BOTH_PAIN9,				//# 
+	BOTH_PAIN10,			//# 
+	BOTH_PAIN11,			//# 
+	BOTH_PAIN12,			//# 
+	BOTH_PAIN13,			//# 
+	BOTH_PAIN14,			//# 
+	BOTH_PAIN15,			//# 
+	BOTH_PAIN16,			//# 
+	BOTH_PAIN17,			//# 
+	BOTH_PAIN18,			//# 
+
+	//# #sep BOTH_ ATTACKS
+	BOTH_ATTACK1,			//# Attack with stun baton
+	BOTH_ATTACK2,			//# Attack with one-handed pistol
+	BOTH_ATTACK3,			//# Attack with blaster rifle
+	BOTH_ATTACK4,			//# Attack with disruptor
+	BOTH_ATTACK5,			//# Another Rancor Attack
+	BOTH_ATTACK6,			//# Yet Another Rancor Attack
+	BOTH_ATTACK7,			//# Yet Another Rancor Attack
+	BOTH_ATTACK10,			//# Attack with thermal det
+	BOTH_ATTACK11,			//# "Attack" with tripmine and detpack
+	BOTH_MELEE1,			//# First melee attack
+	BOTH_MELEE2,			//# Second melee attack
+	BOTH_THERMAL_READY,		//# pull back with thermal
+	BOTH_THERMAL_THROW,		//# throw thermal
+	//* #sep BOTH_ SABER ANIMS
+	//Saber attack anims - power level 1
+	BOTH_A1_T__B_,	//# Fast weak vertical attack top to bottom
+	BOTH_A1__L__R,	//# Fast weak horizontal attack left to right
+	BOTH_A1__R__L,	//# Fast weak horizontal attack right to left
+	BOTH_A1_TL_BR,	//# Fast weak diagonal attack top left to botom right
+	BOTH_A1_BR_TL,	//# Fast weak diagonal attack top left to botom right
+	BOTH_A1_BL_TR,	//# Fast weak diagonal attack bottom left to top right
+	BOTH_A1_TR_BL,	//# Fast weak diagonal attack bottom left to right
+	//Saber Arc and Spin Transitions
+	BOTH_T1_BR__R,	//# Fast arc bottom right to right
+	BOTH_T1_BR_TL,	//# Fast weak spin bottom right to top left
+	BOTH_T1_BR__L,	//# Fast weak spin bottom right to left
+	BOTH_T1_BR_BL,	//# Fast weak spin bottom right to bottom left
+	BOTH_T1__R_TR,	//# Fast arc right to top right
+	BOTH_T1__R_TL,	//# Fast arc right to top left
+	BOTH_T1__R__L,	//# Fast weak spin right to left
+	BOTH_T1__R_BL,	//# Fast weak spin right to bottom left
+	BOTH_T1_TR_BR,	//# Fast arc top right to bottom right
+	BOTH_T1_TR_TL,	//# Fast arc top right to top left
+	BOTH_T1_TR__L,	//# Fast arc top right to left
+	BOTH_T1_TR_BL,	//# Fast weak spin top right to bottom left
+	BOTH_T1_T__BR,	//# Fast arc top to bottom right
+	BOTH_T1_T___R,	//# Fast arc top to right
+	BOTH_T1_T__TR,	//# Fast arc top to top right
+	BOTH_T1_T__TL,	//# Fast arc top to top left
+	BOTH_T1_T___L,	//# Fast arc top to left
+	BOTH_T1_T__BL,	//# Fast arc top to bottom left
+	BOTH_T1_TL_BR,	//# Fast weak spin top left to bottom right
+	BOTH_T1_TL_BL,	//# Fast arc top left to bottom left
+	BOTH_T1__L_BR,	//# Fast weak spin left to bottom right
+	BOTH_T1__L__R,	//# Fast weak spin left to right
+	BOTH_T1__L_TL,	//# Fast arc left to top left
+	BOTH_T1_BL_BR,	//# Fast weak spin bottom left to bottom right
+	BOTH_T1_BL__R,	//# Fast weak spin bottom left to right
+	BOTH_T1_BL_TR,	//# Fast weak spin bottom left to top right
+	BOTH_T1_BL__L,	//# Fast arc bottom left to left
+	//Saber Arc Transitions that use existing animations played backwards
+	BOTH_T1_BR_TR,	//# Fast arc bottom right to top right		(use: BOTH_T1_TR_BR)
+	BOTH_T1_BR_T_,	//# Fast arc bottom right to top			(use: BOTH_T1_T__BR)
+	BOTH_T1__R_BR,	//# Fast arc right to bottom right			(use: BOTH_T1_BR__R)
+	BOTH_T1__R_T_,	//# Fast ar right to top				(use: BOTH_T1_T___R)
+	BOTH_T1_TR__R,	//# Fast arc top right to right			(use: BOTH_T1__R_TR)
+	BOTH_T1_TR_T_,	//# Fast arc top right to top				(use: BOTH_T1_T__TR)
+	BOTH_T1_TL__R,	//# Fast arc top left to right			(use: BOTH_T1__R_TL)
+	BOTH_T1_TL_TR,	//# Fast arc top left to top right			(use: BOTH_T1_TR_TL)
+	BOTH_T1_TL_T_,	//# Fast arc top left to top				(use: BOTH_T1_T__TL)
+	BOTH_T1_TL__L,	//# Fast arc top left to left				(use: BOTH_T1__L_TL)
+	BOTH_T1__L_TR,	//# Fast arc left to top right			(use: BOTH_T1_TR__L)
+	BOTH_T1__L_T_,	//# Fast arc left to top				(use: BOTH_T1_T___L)
+	BOTH_T1__L_BL,	//# Fast arc left to bottom left			(use: BOTH_T1_BL__L)
+	BOTH_T1_BL_T_,	//# Fast arc bottom left to top			(use: BOTH_T1_T__BL)
+	BOTH_T1_BL_TL,	//# Fast arc bottom left to top left		(use: BOTH_T1_TL_BL)
+	//Saber Attack Start Transitions
+	BOTH_S1_S1_T_,	//# Fast plain transition from stance1 to top-to-bottom Fast weak attack
+	BOTH_S1_S1__L,	//# Fast plain transition from stance1 to left-to-right Fast weak attack
+	BOTH_S1_S1__R,	//# Fast plain transition from stance1 to right-to-left Fast weak attack
+	BOTH_S1_S1_TL,	//# Fast plain transition from stance1 to top-left-to-bottom-right Fast weak attack
+	BOTH_S1_S1_BR,	//# Fast plain transition from stance1 to bottom-right-to-top-left Fast weak attack
+	BOTH_S1_S1_BL,	//# Fast plain transition from stance1 to bottom-left-to-top-right Fast weak attack
+	BOTH_S1_S1_TR,	//# Fast plain transition from stance1 to top-right-to-bottom-left Fast weak attack
+	//Saber Attack Return Transitions
+	BOTH_R1_B__S1,	//# Fast plain transition from top-to-bottom Fast weak attack to stance1
+	BOTH_R1__L_S1,	//# Fast plain transition from left-to-right Fast weak attack to stance1
+	BOTH_R1__R_S1,	//# Fast plain transition from right-to-left Fast weak attack to stance1
+	BOTH_R1_TL_S1,	//# Fast plain transition from top-left-to-bottom-right Fast weak attack to stance1
+	BOTH_R1_BR_S1,	//# Fast plain transition from bottom-right-to-top-left Fast weak attack to stance1
+	BOTH_R1_BL_S1,	//# Fast plain transition from bottom-left-to-top-right Fast weak attack to stance1
+	BOTH_R1_TR_S1,	//# Fast plain transition from top-right-to-bottom-left Fast weak attack
+	//Saber Attack Bounces (first 4 frames of an attack, played backwards)
+	BOTH_B1_BR___,	//# Bounce-back if attack from BR is blocked
+	BOTH_B1__R___,	//# Bounce-back if attack from R is blocked
+	BOTH_B1_TR___,	//# Bounce-back if attack from TR is blocked
+	BOTH_B1_T____,	//# Bounce-back if attack from T is blocked
+	BOTH_B1_TL___,	//# Bounce-back if attack from TL is blocked
+	BOTH_B1__L___,	//# Bounce-back if attack from L is blocked
+	BOTH_B1_BL___,	//# Bounce-back if attack from BL is blocked
+	//Saber Attack Deflections (last 4 frames of an attack)
+	BOTH_D1_BR___,	//# Deflection toward BR
+	BOTH_D1__R___,	//# Deflection toward R
+	BOTH_D1_TR___,	//# Deflection toward TR
+	BOTH_D1_TL___,	//# Deflection toward TL
+	BOTH_D1__L___,	//# Deflection toward L
+	BOTH_D1_BL___,	//# Deflection toward BL
+	BOTH_D1_B____,	//# Deflection toward B
+	//Saber attack anims - power level 2
+	BOTH_A2_T__B_,	//# Fast weak vertical attack top to bottom
+	BOTH_A2__L__R,	//# Fast weak horizontal attack left to right
+	BOTH_A2__R__L,	//# Fast weak horizontal attack right to left
+	BOTH_A2_TL_BR,	//# Fast weak diagonal attack top left to botom right
+	BOTH_A2_BR_TL,	//# Fast weak diagonal attack top left to botom right
+	BOTH_A2_BL_TR,	//# Fast weak diagonal attack bottom left to top right
+	BOTH_A2_TR_BL,	//# Fast weak diagonal attack bottom left to right
+	//Saber Arc and Spin Transitions
+	BOTH_T2_BR__R,	//# Fast arc bottom right to right
+	BOTH_T2_BR_TL,	//# Fast weak spin bottom right to top left
+	BOTH_T2_BR__L,	//# Fast weak spin bottom right to left
+	BOTH_T2_BR_BL,	//# Fast weak spin bottom right to bottom left
+	BOTH_T2__R_TR,	//# Fast arc right to top right
+	BOTH_T2__R_TL,	//# Fast arc right to top left
+	BOTH_T2__R__L,	//# Fast weak spin right to left
+	BOTH_T2__R_BL,	//# Fast weak spin right to bottom left
+	BOTH_T2_TR_BR,	//# Fast arc top right to bottom right
+	BOTH_T2_TR_TL,	//# Fast arc top right to top left
+	BOTH_T2_TR__L,	//# Fast arc top right to left
+	BOTH_T2_TR_BL,	//# Fast weak spin top right to bottom left
+	BOTH_T2_T__BR,	//# Fast arc top to bottom right
+	BOTH_T2_T___R,	//# Fast arc top to right
+	BOTH_T2_T__TR,	//# Fast arc top to top right
+	BOTH_T2_T__TL,	//# Fast arc top to top left
+	BOTH_T2_T___L,	//# Fast arc top to left
+	BOTH_T2_T__BL,	//# Fast arc top to bottom left
+	BOTH_T2_TL_BR,	//# Fast weak spin top left to bottom right
+	BOTH_T2_TL_BL,	//# Fast arc top left to bottom left
+	BOTH_T2__L_BR,	//# Fast weak spin left to bottom right
+	BOTH_T2__L__R,	//# Fast weak spin left to right
+	BOTH_T2__L_TL,	//# Fast arc left to top left
+	BOTH_T2_BL_BR,	//# Fast weak spin bottom left to bottom right
+	BOTH_T2_BL__R,	//# Fast weak spin bottom left to right
+	BOTH_T2_BL_TR,	//# Fast weak spin bottom left to top right
+	BOTH_T2_BL__L,	//# Fast arc bottom left to left
+	//Saber Arc Transitions that use existing animations played backwards
+	BOTH_T2_BR_TR,	//# Fast arc bottom right to top right		(use: BOTH_T2_TR_BR)
+	BOTH_T2_BR_T_,	//# Fast arc bottom right to top			(use: BOTH_T2_T__BR)
+	BOTH_T2__R_BR,	//# Fast arc right to bottom right			(use: BOTH_T2_BR__R)
+	BOTH_T2__R_T_,	//# Fast ar right to top				(use: BOTH_T2_T___R)
+	BOTH_T2_TR__R,	//# Fast arc top right to right			(use: BOTH_T2__R_TR)
+	BOTH_T2_TR_T_,	//# Fast arc top right to top				(use: BOTH_T2_T__TR)
+	BOTH_T2_TL__R,	//# Fast arc top left to right			(use: BOTH_T2__R_TL)
+	BOTH_T2_TL_TR,	//# Fast arc top left to top right			(use: BOTH_T2_TR_TL)
+	BOTH_T2_TL_T_,	//# Fast arc top left to top				(use: BOTH_T2_T__TL)
+	BOTH_T2_TL__L,	//# Fast arc top left to left				(use: BOTH_T2__L_TL)
+	BOTH_T2__L_TR,	//# Fast arc left to top right			(use: BOTH_T2_TR__L)
+	BOTH_T2__L_T_,	//# Fast arc left to top				(use: BOTH_T2_T___L)
+	BOTH_T2__L_BL,	//# Fast arc left to bottom left			(use: BOTH_T2_BL__L)
+	BOTH_T2_BL_T_,	//# Fast arc bottom left to top			(use: BOTH_T2_T__BL)
+	BOTH_T2_BL_TL,	//# Fast arc bottom left to top left		(use: BOTH_T2_TL_BL)
+	//Saber Attack Start Transitions
+	BOTH_S2_S1_T_,	//# Fast plain transition from stance1 to top-to-bottom Fast weak attack
+	BOTH_S2_S1__L,	//# Fast plain transition from stance1 to left-to-right Fast weak attack
+	BOTH_S2_S1__R,	//# Fast plain transition from stance1 to right-to-left Fast weak attack
+	BOTH_S2_S1_TL,	//# Fast plain transition from stance1 to top-left-to-bottom-right Fast weak attack
+	BOTH_S2_S1_BR,	//# Fast plain transition from stance1 to bottom-right-to-top-left Fast weak attack
+	BOTH_S2_S1_BL,	//# Fast plain transition from stance1 to bottom-left-to-top-right Fast weak attack
+	BOTH_S2_S1_TR,	//# Fast plain transition from stance1 to top-right-to-bottom-left Fast weak attack
+	//Saber Attack Return Transitions
+	BOTH_R2_B__S1,	//# Fast plain transition from top-to-bottom Fast weak attack to stance1
+	BOTH_R2__L_S1,	//# Fast plain transition from left-to-right Fast weak attack to stance1
+	BOTH_R2__R_S1,	//# Fast plain transition from right-to-left Fast weak attack to stance1
+	BOTH_R2_TL_S1,	//# Fast plain transition from top-left-to-bottom-right Fast weak attack to stance1
+	BOTH_R2_BR_S1,	//# Fast plain transition from bottom-right-to-top-left Fast weak attack to stance1
+	BOTH_R2_BL_S1,	//# Fast plain transition from bottom-left-to-top-right Fast weak attack to stance1
+	BOTH_R2_TR_S1,	//# Fast plain transition from top-right-to-bottom-left Fast weak attack
+	//Saber Attack Bounces (first 4 frames of an attack, played backwards)
+	BOTH_B2_BR___,	//# Bounce-back if attack from BR is blocked
+	BOTH_B2__R___,	//# Bounce-back if attack from R is blocked
+	BOTH_B2_TR___,	//# Bounce-back if attack from TR is blocked
+	BOTH_B2_T____,	//# Bounce-back if attack from T is blocked
+	BOTH_B2_TL___,	//# Bounce-back if attack from TL is blocked
+	BOTH_B2__L___,	//# Bounce-back if attack from L is blocked
+	BOTH_B2_BL___,	//# Bounce-back if attack from BL is blocked
+	//Saber Attack Deflections (last 4 frames of an attack)
+	BOTH_D2_BR___,	//# Deflection toward BR
+	BOTH_D2__R___,	//# Deflection toward R
+	BOTH_D2_TR___,	//# Deflection toward TR
+	BOTH_D2_TL___,	//# Deflection toward TL
+	BOTH_D2__L___,	//# Deflection toward L
+	BOTH_D2_BL___,	//# Deflection toward BL
+	BOTH_D2_B____,	//# Deflection toward B
+	//Saber attack anims - power level 3
+	BOTH_A3_T__B_,	//# Fast weak vertical attack top to bottom
+	BOTH_A3__L__R,	//# Fast weak horizontal attack left to right
+	BOTH_A3__R__L,	//# Fast weak horizontal attack right to left
+	BOTH_A3_TL_BR,	//# Fast weak diagonal attack top left to botom right
+	BOTH_A3_BR_TL,	//# Fast weak diagonal attack top left to botom right
+	BOTH_A3_BL_TR,	//# Fast weak diagonal attack bottom left to top right
+	BOTH_A3_TR_BL,	//# Fast weak diagonal attack bottom left to right
+	//Saber Arc and Spin Transitions
+	BOTH_T3_BR__R,	//# Fast arc bottom right to right
+	BOTH_T3_BR_TL,	//# Fast weak spin bottom right to top left
+	BOTH_T3_BR__L,	//# Fast weak spin bottom right to left
+	BOTH_T3_BR_BL,	//# Fast weak spin bottom right to bottom left
+	BOTH_T3__R_TR,	//# Fast arc right to top right
+	BOTH_T3__R_TL,	//# Fast arc right to top left
+	BOTH_T3__R__L,	//# Fast weak spin right to left
+	BOTH_T3__R_BL,	//# Fast weak spin right to bottom left
+	BOTH_T3_TR_BR,	//# Fast arc top right to bottom right
+	BOTH_T3_TR_TL,	//# Fast arc top right to top left
+	BOTH_T3_TR__L,	//# Fast arc top right to left
+	BOTH_T3_TR_BL,	//# Fast weak spin top right to bottom left
+	BOTH_T3_T__BR,	//# Fast arc top to bottom right
+	BOTH_T3_T___R,	//# Fast arc top to right
+	BOTH_T3_T__TR,	//# Fast arc top to top right
+	BOTH_T3_T__TL,	//# Fast arc top to top left
+	BOTH_T3_T___L,	//# Fast arc top to left
+	BOTH_T3_T__BL,	//# Fast arc top to bottom left
+	BOTH_T3_TL_BR,	//# Fast weak spin top left to bottom right
+	BOTH_T3_TL_BL,	//# Fast arc top left to bottom left
+	BOTH_T3__L_BR,	//# Fast weak spin left to bottom right
+	BOTH_T3__L__R,	//# Fast weak spin left to right
+	BOTH_T3__L_TL,	//# Fast arc left to top left
+	BOTH_T3_BL_BR,	//# Fast weak spin bottom left to bottom right
+	BOTH_T3_BL__R,	//# Fast weak spin bottom left to right
+	BOTH_T3_BL_TR,	//# Fast weak spin bottom left to top right
+	BOTH_T3_BL__L,	//# Fast arc bottom left to left
+	//Saber Arc Transitions that use existing animations played backwards
+	BOTH_T3_BR_TR,	//# Fast arc bottom right to top right		(use: BOTH_T3_TR_BR)
+	BOTH_T3_BR_T_,	//# Fast arc bottom right to top			(use: BOTH_T3_T__BR)
+	BOTH_T3__R_BR,	//# Fast arc right to bottom right			(use: BOTH_T3_BR__R)
+	BOTH_T3__R_T_,	//# Fast ar right to top				(use: BOTH_T3_T___R)
+	BOTH_T3_TR__R,	//# Fast arc top right to right			(use: BOTH_T3__R_TR)
+	BOTH_T3_TR_T_,	//# Fast arc top right to top				(use: BOTH_T3_T__TR)
+	BOTH_T3_TL__R,	//# Fast arc top left to right			(use: BOTH_T3__R_TL)
+	BOTH_T3_TL_TR,	//# Fast arc top left to top right			(use: BOTH_T3_TR_TL)
+	BOTH_T3_TL_T_,	//# Fast arc top left to top				(use: BOTH_T3_T__TL)
+	BOTH_T3_TL__L,	//# Fast arc top left to left				(use: BOTH_T3__L_TL)
+	BOTH_T3__L_TR,	//# Fast arc left to top right			(use: BOTH_T3_TR__L)
+	BOTH_T3__L_T_,	//# Fast arc left to top				(use: BOTH_T3_T___L)
+	BOTH_T3__L_BL,	//# Fast arc left to bottom left			(use: BOTH_T3_BL__L)
+	BOTH_T3_BL_T_,	//# Fast arc bottom left to top			(use: BOTH_T3_T__BL)
+	BOTH_T3_BL_TL,	//# Fast arc bottom left to top left		(use: BOTH_T3_TL_BL)
+	//Saber Attack Start Transitions
+	BOTH_S3_S1_T_,	//# Fast plain transition from stance1 to top-to-bottom Fast weak attack
+	BOTH_S3_S1__L,	//# Fast plain transition from stance1 to left-to-right Fast weak attack
+	BOTH_S3_S1__R,	//# Fast plain transition from stance1 to right-to-left Fast weak attack
+	BOTH_S3_S1_TL,	//# Fast plain transition from stance1 to top-left-to-bottom-right Fast weak attack
+	BOTH_S3_S1_BR,	//# Fast plain transition from stance1 to bottom-right-to-top-left Fast weak attack
+	BOTH_S3_S1_BL,	//# Fast plain transition from stance1 to bottom-left-to-top-right Fast weak attack
+	BOTH_S3_S1_TR,	//# Fast plain transition from stance1 to top-right-to-bottom-left Fast weak attack
+	//Saber Attack Return Transitions
+	BOTH_R3_B__S1,	//# Fast plain transition from top-to-bottom Fast weak attack to stance1
+	BOTH_R3__L_S1,	//# Fast plain transition from left-to-right Fast weak attack to stance1
+	BOTH_R3__R_S1,	//# Fast plain transition from right-to-left Fast weak attack to stance1
+	BOTH_R3_TL_S1,	//# Fast plain transition from top-left-to-bottom-right Fast weak attack to stance1
+	BOTH_R3_BR_S1,	//# Fast plain transition from bottom-right-to-top-left Fast weak attack to stance1
+	BOTH_R3_BL_S1,	//# Fast plain transition from bottom-left-to-top-right Fast weak attack to stance1
+	BOTH_R3_TR_S1,	//# Fast plain transition from top-right-to-bottom-left Fast weak attack
+	//Saber Attack Bounces (first 4 frames of an attack, played backwards)
+	BOTH_B3_BR___,	//# Bounce-back if attack from BR is blocked
+	BOTH_B3__R___,	//# Bounce-back if attack from R is blocked
+	BOTH_B3_TR___,	//# Bounce-back if attack from TR is blocked
+	BOTH_B3_T____,	//# Bounce-back if attack from T is blocked
+	BOTH_B3_TL___,	//# Bounce-back if attack from TL is blocked
+	BOTH_B3__L___,	//# Bounce-back if attack from L is blocked
+	BOTH_B3_BL___,	//# Bounce-back if attack from BL is blocked
+	//Saber Attack Deflections (last 4 frames of an attack)
+	BOTH_D3_BR___,	//# Deflection toward BR
+	BOTH_D3__R___,	//# Deflection toward R
+	BOTH_D3_TR___,	//# Deflection toward TR
+	BOTH_D3_TL___,	//# Deflection toward TL
+	BOTH_D3__L___,	//# Deflection toward L
+	BOTH_D3_BL___,	//# Deflection toward BL
+	BOTH_D3_B____,	//# Deflection toward B
+	//Saber attack anims - power level 4  - Desann's
+	BOTH_A4_T__B_,	//# Fast weak vertical attack top to bottom
+	BOTH_A4__L__R,	//# Fast weak horizontal attack left to right
+	BOTH_A4__R__L,	//# Fast weak horizontal attack right to left
+	BOTH_A4_TL_BR,	//# Fast weak diagonal attack top left to botom right
+	BOTH_A4_BR_TL,	//# Fast weak diagonal attack top left to botom right
+	BOTH_A4_BL_TR,	//# Fast weak diagonal attack bottom left to top right
+	BOTH_A4_TR_BL,	//# Fast weak diagonal attack bottom left to right
+	//Saber Arc and Spin Transitions
+	BOTH_T4_BR__R,	//# Fast arc bottom right to right
+	BOTH_T4_BR_TL,	//# Fast weak spin bottom right to top left
+	BOTH_T4_BR__L,	//# Fast weak spin bottom right to left
+	BOTH_T4_BR_BL,	//# Fast weak spin bottom right to bottom left
+	BOTH_T4__R_TR,	//# Fast arc right to top right
+	BOTH_T4__R_TL,	//# Fast arc right to top left
+	BOTH_T4__R__L,	//# Fast weak spin right to left
+	BOTH_T4__R_BL,	//# Fast weak spin right to bottom left
+	BOTH_T4_TR_BR,	//# Fast arc top right to bottom right
+	BOTH_T4_TR_TL,	//# Fast arc top right to top left
+	BOTH_T4_TR__L,	//# Fast arc top right to left
+	BOTH_T4_TR_BL,	//# Fast weak spin top right to bottom left
+	BOTH_T4_T__BR,	//# Fast arc top to bottom right
+	BOTH_T4_T___R,	//# Fast arc top to right
+	BOTH_T4_T__TR,	//# Fast arc top to top right
+	BOTH_T4_T__TL,	//# Fast arc top to top left
+	BOTH_T4_T___L,	//# Fast arc top to left
+	BOTH_T4_T__BL,	//# Fast arc top to bottom left
+	BOTH_T4_TL_BR,	//# Fast weak spin top left to bottom right
+	BOTH_T4_TL_BL,	//# Fast arc top left to bottom left
+	BOTH_T4__L_BR,	//# Fast weak spin left to bottom right
+	BOTH_T4__L__R,	//# Fast weak spin left to right
+	BOTH_T4__L_TL,	//# Fast arc left to top left
+	BOTH_T4_BL_BR,	//# Fast weak spin bottom left to bottom right
+	BOTH_T4_BL__R,	//# Fast weak spin bottom left to right
+	BOTH_T4_BL_TR,	//# Fast weak spin bottom left to top right
+	BOTH_T4_BL__L,	//# Fast arc bottom left to left
+	//Saber Arc Transitions that use existing animations played backwards
+	BOTH_T4_BR_TR,	//# Fast arc bottom right to top right		(use: BOTH_T4_TR_BR)
+	BOTH_T4_BR_T_,	//# Fast arc bottom right to top			(use: BOTH_T4_T__BR)
+	BOTH_T4__R_BR,	//# Fast arc right to bottom right			(use: BOTH_T4_BR__R)
+	BOTH_T4__R_T_,	//# Fast ar right to top				(use: BOTH_T4_T___R)
+	BOTH_T4_TR__R,	//# Fast arc top right to right			(use: BOTH_T4__R_TR)
+	BOTH_T4_TR_T_,	//# Fast arc top right to top				(use: BOTH_T4_T__TR)
+	BOTH_T4_TL__R,	//# Fast arc top left to right			(use: BOTH_T4__R_TL)
+	BOTH_T4_TL_TR,	//# Fast arc top left to top right			(use: BOTH_T4_TR_TL)
+	BOTH_T4_TL_T_,	//# Fast arc top left to top				(use: BOTH_T4_T__TL)
+	BOTH_T4_TL__L,	//# Fast arc top left to left				(use: BOTH_T4__L_TL)
+	BOTH_T4__L_TR,	//# Fast arc left to top right			(use: BOTH_T4_TR__L)
+	BOTH_T4__L_T_,	//# Fast arc left to top				(use: BOTH_T4_T___L)
+	BOTH_T4__L_BL,	//# Fast arc left to bottom left			(use: BOTH_T4_BL__L)
+	BOTH_T4_BL_T_,	//# Fast arc bottom left to top			(use: BOTH_T4_T__BL)
+	BOTH_T4_BL_TL,	//# Fast arc bottom left to top left		(use: BOTH_T4_TL_BL)
+	//Saber Attack Start Transitions
+	BOTH_S4_S1_T_,	//# Fast plain transition from stance1 to top-to-bottom Fast weak attack
+	BOTH_S4_S1__L,	//# Fast plain transition from stance1 to left-to-right Fast weak attack
+	BOTH_S4_S1__R,	//# Fast plain transition from stance1 to right-to-left Fast weak attack
+	BOTH_S4_S1_TL,	//# Fast plain transition from stance1 to top-left-to-bottom-right Fast weak attack
+	BOTH_S4_S1_BR,	//# Fast plain transition from stance1 to bottom-right-to-top-left Fast weak attack
+	BOTH_S4_S1_BL,	//# Fast plain transition from stance1 to bottom-left-to-top-right Fast weak attack
+	BOTH_S4_S1_TR,	//# Fast plain transition from stance1 to top-right-to-bottom-left Fast weak attack
+	//Saber Attack Return Transitions
+	BOTH_R4_B__S1,	//# Fast plain transition from top-to-bottom Fast weak attack to stance1
+	BOTH_R4__L_S1,	//# Fast plain transition from left-to-right Fast weak attack to stance1
+	BOTH_R4__R_S1,	//# Fast plain transition from right-to-left Fast weak attack to stance1
+	BOTH_R4_TL_S1,	//# Fast plain transition from top-left-to-bottom-right Fast weak attack to stance1
+	BOTH_R4_BR_S1,	//# Fast plain transition from bottom-right-to-top-left Fast weak attack to stance1
+	BOTH_R4_BL_S1,	//# Fast plain transition from bottom-left-to-top-right Fast weak attack to stance1
+	BOTH_R4_TR_S1,	//# Fast plain transition from top-right-to-bottom-left Fast weak attack
+	//Saber Attack Bounces (first 4 frames of an attack, played backwards)
+	BOTH_B4_BR___,	//# Bounce-back if attack from BR is blocked
+	BOTH_B4__R___,	//# Bounce-back if attack from R is blocked
+	BOTH_B4_TR___,	//# Bounce-back if attack from TR is blocked
+	BOTH_B4_T____,	//# Bounce-back if attack from T is blocked
+	BOTH_B4_TL___,	//# Bounce-back if attack from TL is blocked
+	BOTH_B4__L___,	//# Bounce-back if attack from L is blocked
+	BOTH_B4_BL___,	//# Bounce-back if attack from BL is blocked
+	//Saber Attack Deflections (last 4 frames of an attack)
+	BOTH_D4_BR___,	//# Deflection toward BR
+	BOTH_D4__R___,	//# Deflection toward R
+	BOTH_D4_TR___,	//# Deflection toward TR
+	BOTH_D4_TL___,	//# Deflection toward TL
+	BOTH_D4__L___,	//# Deflection toward L
+	BOTH_D4_BL___,	//# Deflection toward BL
+	BOTH_D4_B____,	//# Deflection toward B
+	//Saber attack anims - power level 5  - Tavion's
+	BOTH_A5_T__B_,	//# Fast weak vertical attack top to bottom
+	BOTH_A5__L__R,	//# Fast weak horizontal attack left to right
+	BOTH_A5__R__L,	//# Fast weak horizontal attack right to left
+	BOTH_A5_TL_BR,	//# Fast weak diagonal attack top left to botom right
+	BOTH_A5_BR_TL,	//# Fast weak diagonal attack top left to botom right
+	BOTH_A5_BL_TR,	//# Fast weak diagonal attack bottom left to top right
+	BOTH_A5_TR_BL,	//# Fast weak diagonal attack bottom left to right
+	//Saber Arc and Spin Transitions
+	BOTH_T5_BR__R,	//# Fast arc bottom right to right
+	BOTH_T5_BR_TL,	//# Fast weak spin bottom right to top left
+	BOTH_T5_BR__L,	//# Fast weak spin bottom right to left
+	BOTH_T5_BR_BL,	//# Fast weak spin bottom right to bottom left
+	BOTH_T5__R_TR,	//# Fast arc right to top right
+	BOTH_T5__R_TL,	//# Fast arc right to top left
+	BOTH_T5__R__L,	//# Fast weak spin right to left
+	BOTH_T5__R_BL,	//# Fast weak spin right to bottom left
+	BOTH_T5_TR_BR,	//# Fast arc top right to bottom right
+	BOTH_T5_TR_TL,	//# Fast arc top right to top left
+	BOTH_T5_TR__L,	//# Fast arc top right to left
+	BOTH_T5_TR_BL,	//# Fast weak spin top right to bottom left
+	BOTH_T5_T__BR,	//# Fast arc top to bottom right
+	BOTH_T5_T___R,	//# Fast arc top to right
+	BOTH_T5_T__TR,	//# Fast arc top to top right
+	BOTH_T5_T__TL,	//# Fast arc top to top left
+	BOTH_T5_T___L,	//# Fast arc top to left
+	BOTH_T5_T__BL,	//# Fast arc top to bottom left
+	BOTH_T5_TL_BR,	//# Fast weak spin top left to bottom right
+	BOTH_T5_TL_BL,	//# Fast arc top left to bottom left
+	BOTH_T5__L_BR,	//# Fast weak spin left to bottom right
+	BOTH_T5__L__R,	//# Fast weak spin left to right
+	BOTH_T5__L_TL,	//# Fast arc left to top left
+	BOTH_T5_BL_BR,	//# Fast weak spin bottom left to bottom right
+	BOTH_T5_BL__R,	//# Fast weak spin bottom left to right
+	BOTH_T5_BL_TR,	//# Fast weak spin bottom left to top right
+	BOTH_T5_BL__L,	//# Fast arc bottom left to left
+	//Saber Arc Transitions that use existing animations played backwards
+	BOTH_T5_BR_TR,	//# Fast arc bottom right to top right		(use: BOTH_T5_TR_BR)
+	BOTH_T5_BR_T_,	//# Fast arc bottom right to top			(use: BOTH_T5_T__BR)
+	BOTH_T5__R_BR,	//# Fast arc right to bottom right			(use: BOTH_T5_BR__R)
+	BOTH_T5__R_T_,	//# Fast ar right to top				(use: BOTH_T5_T___R)
+	BOTH_T5_TR__R,	//# Fast arc top right to right			(use: BOTH_T5__R_TR)
+	BOTH_T5_TR_T_,	//# Fast arc top right to top				(use: BOTH_T5_T__TR)
+	BOTH_T5_TL__R,	//# Fast arc top left to right			(use: BOTH_T5__R_TL)
+	BOTH_T5_TL_TR,	//# Fast arc top left to top right			(use: BOTH_T5_TR_TL)
+	BOTH_T5_TL_T_,	//# Fast arc top left to top				(use: BOTH_T5_T__TL)
+	BOTH_T5_TL__L,	//# Fast arc top left to left				(use: BOTH_T5__L_TL)
+	BOTH_T5__L_TR,	//# Fast arc left to top right			(use: BOTH_T5_TR__L)
+	BOTH_T5__L_T_,	//# Fast arc left to top				(use: BOTH_T5_T___L)
+	BOTH_T5__L_BL,	//# Fast arc left to bottom left			(use: BOTH_T5_BL__L)
+	BOTH_T5_BL_T_,	//# Fast arc bottom left to top			(use: BOTH_T5_T__BL)
+	BOTH_T5_BL_TL,	//# Fast arc bottom left to top left		(use: BOTH_T5_TL_BL)
+	//Saber Attack Start Transitions
+	BOTH_S5_S1_T_,	//# Fast plain transition from stance1 to top-to-bottom Fast weak attack
+	BOTH_S5_S1__L,	//# Fast plain transition from stance1 to left-to-right Fast weak attack
+	BOTH_S5_S1__R,	//# Fast plain transition from stance1 to right-to-left Fast weak attack
+	BOTH_S5_S1_TL,	//# Fast plain transition from stance1 to top-left-to-bottom-right Fast weak attack
+	BOTH_S5_S1_BR,	//# Fast plain transition from stance1 to bottom-right-to-top-left Fast weak attack
+	BOTH_S5_S1_BL,	//# Fast plain transition from stance1 to bottom-left-to-top-right Fast weak attack
+	BOTH_S5_S1_TR,	//# Fast plain transition from stance1 to top-right-to-bottom-left Fast weak attack
+	//Saber Attack Return Transitions
+	BOTH_R5_B__S1,	//# Fast plain transition from top-to-bottom Fast weak attack to stance1
+	BOTH_R5__L_S1,	//# Fast plain transition from left-to-right Fast weak attack to stance1
+	BOTH_R5__R_S1,	//# Fast plain transition from right-to-left Fast weak attack to stance1
+	BOTH_R5_TL_S1,	//# Fast plain transition from top-left-to-bottom-right Fast weak attack to stance1
+	BOTH_R5_BR_S1,	//# Fast plain transition from bottom-right-to-top-left Fast weak attack to stance1
+	BOTH_R5_BL_S1,	//# Fast plain transition from bottom-left-to-top-right Fast weak attack to stance1
+	BOTH_R5_TR_S1,	//# Fast plain transition from top-right-to-bottom-left Fast weak attack
+	//Saber Attack Bounces (first 4 frames of an attack, played backwards)
+	BOTH_B5_BR___,	//# Bounce-back if attack from BR is blocked
+	BOTH_B5__R___,	//# Bounce-back if attack from R is blocked
+	BOTH_B5_TR___,	//# Bounce-back if attack from TR is blocked
+	BOTH_B5_T____,	//# Bounce-back if attack from T is blocked
+	BOTH_B5_TL___,	//# Bounce-back if attack from TL is blocked
+	BOTH_B5__L___,	//# Bounce-back if attack from L is blocked
+	BOTH_B5_BL___,	//# Bounce-back if attack from BL is blocked
+	//Saber Attack Deflections (last 4 frames of an attack)
+	BOTH_D5_BR___,	//# Deflection toward BR
+	BOTH_D5__R___,	//# Deflection toward R
+	BOTH_D5_TR___,	//# Deflection toward TR
+	BOTH_D5_TL___,	//# Deflection toward TL
+	BOTH_D5__L___,	//# Deflection toward L
+	BOTH_D5_BL___,	//# Deflection toward BL
+	BOTH_D5_B____,	//# Deflection toward B
+	//Saber attack anims - power level 6
+	BOTH_A6_T__B_,	//# Fast weak vertical attack top to bottom
+	BOTH_A6__L__R,	//# Fast weak horizontal attack left to right
+	BOTH_A6__R__L,	//# Fast weak horizontal attack right to left
+	BOTH_A6_TL_BR,	//# Fast weak diagonal attack top left to botom right
+	BOTH_A6_BR_TL,	//# Fast weak diagonal attack top left to botom right
+	BOTH_A6_BL_TR,	//# Fast weak diagonal attack bottom left to top right
+	BOTH_A6_TR_BL,	//# Fast weak diagonal attack bottom left to right
+	//Saber Arc and Spin Transitions
+	BOTH_T6_BR__R,	//# Fast arc bottom right to right
+	BOTH_T6_BR_TL,	//# Fast weak spin bottom right to top left
+	BOTH_T6_BR__L,	//# Fast weak spin bottom right to left
+	BOTH_T6_BR_BL,	//# Fast weak spin bottom right to bottom left
+	BOTH_T6__R_TR,	//# Fast arc right to top right
+	BOTH_T6__R_TL,	//# Fast arc right to top left
+	BOTH_T6__R__L,	//# Fast weak spin right to left
+	BOTH_T6__R_BL,	//# Fast weak spin right to bottom left
+	BOTH_T6_TR_BR,	//# Fast arc top right to bottom right
+	BOTH_T6_TR_TL,	//# Fast arc top right to top left
+	BOTH_T6_TR__L,	//# Fast arc top right to left
+	BOTH_T6_TR_BL,	//# Fast weak spin top right to bottom left
+	BOTH_T6_T__BR,	//# Fast arc top to bottom right
+	BOTH_T6_T___R,	//# Fast arc top to right
+	BOTH_T6_T__TR,	//# Fast arc top to top right
+	BOTH_T6_T__TL,	//# Fast arc top to top left
+	BOTH_T6_T___L,	//# Fast arc top to left
+	BOTH_T6_T__BL,	//# Fast arc top to bottom left
+	BOTH_T6_TL_BR,	//# Fast weak spin top left to bottom right
+	BOTH_T6_TL_BL,	//# Fast arc top left to bottom left
+	BOTH_T6__L_BR,	//# Fast weak spin left to bottom right
+	BOTH_T6__L__R,	//# Fast weak spin left to right
+	BOTH_T6__L_TL,	//# Fast arc left to top left
+	BOTH_T6_BL_BR,	//# Fast weak spin bottom left to bottom right
+	BOTH_T6_BL__R,	//# Fast weak spin bottom left to right
+	BOTH_T6_BL_TR,	//# Fast weak spin bottom left to top right
+	BOTH_T6_BL__L,	//# Fast arc bottom left to left
+	//Saber Arc Transitions that use existing animations played backwards
+	BOTH_T6_BR_TR,	//# Fast arc bottom right to top right		(use: BOTH_T6_TR_BR)
+	BOTH_T6_BR_T_,	//# Fast arc bottom right to top			(use: BOTH_T6_T__BR)
+	BOTH_T6__R_BR,	//# Fast arc right to bottom right			(use: BOTH_T6_BR__R)
+	BOTH_T6__R_T_,	//# Fast ar right to top				(use: BOTH_T6_T___R)
+	BOTH_T6_TR__R,	//# Fast arc top right to right			(use: BOTH_T6__R_TR)
+	BOTH_T6_TR_T_,	//# Fast arc top right to top				(use: BOTH_T6_T__TR)
+	BOTH_T6_TL__R,	//# Fast arc top left to right			(use: BOTH_T6__R_TL)
+	BOTH_T6_TL_TR,	//# Fast arc top left to top right			(use: BOTH_T6_TR_TL)
+	BOTH_T6_TL_T_,	//# Fast arc top left to top				(use: BOTH_T6_T__TL)
+	BOTH_T6_TL__L,	//# Fast arc top left to left				(use: BOTH_T6__L_TL)
+	BOTH_T6__L_TR,	//# Fast arc left to top right			(use: BOTH_T6_TR__L)
+	BOTH_T6__L_T_,	//# Fast arc left to top				(use: BOTH_T6_T___L)
+	BOTH_T6__L_BL,	//# Fast arc left to bottom left			(use: BOTH_T6_BL__L)
+	BOTH_T6_BL_T_,	//# Fast arc bottom left to top			(use: BOTH_T6_T__BL)
+	BOTH_T6_BL_TL,	//# Fast arc bottom left to top left		(use: BOTH_T6_TL_BL)
+	//Saber Attack Start Transitions
+	BOTH_S6_S6_T_,	//# Fast plain transition from stance1 to top-to-bottom Fast weak attack
+	BOTH_S6_S6__L,	//# Fast plain transition from stance1 to left-to-right Fast weak attack
+	BOTH_S6_S6__R,	//# Fast plain transition from stance1 to right-to-left Fast weak attack
+	BOTH_S6_S6_TL,	//# Fast plain transition from stance1 to top-left-to-bottom-right Fast weak attack
+	BOTH_S6_S6_BR,	//# Fast plain transition from stance1 to bottom-right-to-top-left Fast weak attack
+	BOTH_S6_S6_BL,	//# Fast plain transition from stance1 to bottom-left-to-top-right Fast weak attack
+	BOTH_S6_S6_TR,	//# Fast plain transition from stance1 to top-right-to-bottom-left Fast weak attack
+	//Saber Attack Return Transitions
+	BOTH_R6_B__S6,	//# Fast plain transition from top-to-bottom Fast weak attack to stance1
+	BOTH_R6__L_S6,	//# Fast plain transition from left-to-right Fast weak attack to stance1
+	BOTH_R6__R_S6,	//# Fast plain transition from right-to-left Fast weak attack to stance1
+	BOTH_R6_TL_S6,	//# Fast plain transition from top-left-to-bottom-right Fast weak attack to stance1
+	BOTH_R6_BR_S6,	//# Fast plain transition from bottom-right-to-top-left Fast weak attack to stance1
+	BOTH_R6_BL_S6,	//# Fast plain transition from bottom-left-to-top-right Fast weak attack to stance1
+	BOTH_R6_TR_S6,	//# Fast plain transition from top-right-to-bottom-left Fast weak attack
+	//Saber Attack Bounces (first 4 frames of an attack, played backwards)
+	BOTH_B6_BR___,	//# Bounce-back if attack from BR is blocked
+	BOTH_B6__R___,	//# Bounce-back if attack from R is blocked
+	BOTH_B6_TR___,	//# Bounce-back if attack from TR is blocked
+	BOTH_B6_T____,	//# Bounce-back if attack from T is blocked
+	BOTH_B6_TL___,	//# Bounce-back if attack from TL is blocked
+	BOTH_B6__L___,	//# Bounce-back if attack from L is blocked
+	BOTH_B6_BL___,	//# Bounce-back if attack from BL is blocked
+	//Saber Attack Deflections (last 4 frames of an attack)
+	BOTH_D6_BR___,	//# Deflection toward BR
+	BOTH_D6__R___,	//# Deflection toward R
+	BOTH_D6_TR___,	//# Deflection toward TR
+	BOTH_D6_TL___,	//# Deflection toward TL
+	BOTH_D6__L___,	//# Deflection toward L
+	BOTH_D6_BL___,	//# Deflection toward BL
+	BOTH_D6_B____,	//# Deflection toward B
+	//Saber attack anims - power level 7
+	BOTH_A7_T__B_,	//# Fast weak vertical attack top to bottom
+	BOTH_A7__L__R,	//# Fast weak horizontal attack left to right
+	BOTH_A7__R__L,	//# Fast weak horizontal attack right to left
+	BOTH_A7_TL_BR,	//# Fast weak diagonal attack top left to botom right
+	BOTH_A7_BR_TL,	//# Fast weak diagonal attack top left to botom right
+	BOTH_A7_BL_TR,	//# Fast weak diagonal attack bottom left to top right
+	BOTH_A7_TR_BL,	//# Fast weak diagonal attack bottom left to right
+	//Saber Arc and Spin Transitions
+	BOTH_T7_BR__R,	//# Fast arc bottom right to right
+	BOTH_T7_BR_TL,	//# Fast weak spin bottom right to top left
+	BOTH_T7_BR__L,	//# Fast weak spin bottom right to left
+	BOTH_T7_BR_BL,	//# Fast weak spin bottom right to bottom left
+	BOTH_T7__R_TR,	//# Fast arc right to top right
+	BOTH_T7__R_TL,	//# Fast arc right to top left
+	BOTH_T7__R__L,	//# Fast weak spin right to left
+	BOTH_T7__R_BL,	//# Fast weak spin right to bottom left
+	BOTH_T7_TR_BR,	//# Fast arc top right to bottom right
+	BOTH_T7_TR_TL,	//# Fast arc top right to top left
+	BOTH_T7_TR__L,	//# Fast arc top right to left
+	BOTH_T7_TR_BL,	//# Fast weak spin top right to bottom left
+	BOTH_T7_T__BR,	//# Fast arc top to bottom right
+	BOTH_T7_T___R,	//# Fast arc top to right
+	BOTH_T7_T__TR,	//# Fast arc top to top right
+	BOTH_T7_T__TL,	//# Fast arc top to top left
+	BOTH_T7_T___L,	//# Fast arc top to left
+	BOTH_T7_T__BL,	//# Fast arc top to bottom left
+	BOTH_T7_TL_BR,	//# Fast weak spin top left to bottom right
+	BOTH_T7_TL_BL,	//# Fast arc top left to bottom left
+	BOTH_T7__L_BR,	//# Fast weak spin left to bottom right
+	BOTH_T7__L__R,	//# Fast weak spin left to right
+	BOTH_T7__L_TL,	//# Fast arc left to top left
+	BOTH_T7_BL_BR,	//# Fast weak spin bottom left to bottom right
+	BOTH_T7_BL__R,	//# Fast weak spin bottom left to right
+	BOTH_T7_BL_TR,	//# Fast weak spin bottom left to top right
+	BOTH_T7_BL__L,	//# Fast arc bottom left to left
+	//Saber Arc Transitions that use existing animations played backwards
+	BOTH_T7_BR_TR,	//# Fast arc bottom right to top right		(use: BOTH_T7_TR_BR)
+	BOTH_T7_BR_T_,	//# Fast arc bottom right to top			(use: BOTH_T7_T__BR)
+	BOTH_T7__R_BR,	//# Fast arc right to bottom right			(use: BOTH_T7_BR__R)
+	BOTH_T7__R_T_,	//# Fast ar right to top				(use: BOTH_T7_T___R)
+	BOTH_T7_TR__R,	//# Fast arc top right to right			(use: BOTH_T7__R_TR)
+	BOTH_T7_TR_T_,	//# Fast arc top right to top				(use: BOTH_T7_T__TR)
+	BOTH_T7_TL__R,	//# Fast arc top left to right			(use: BOTH_T7__R_TL)
+	BOTH_T7_TL_TR,	//# Fast arc top left to top right			(use: BOTH_T7_TR_TL)
+	BOTH_T7_TL_T_,	//# Fast arc top left to top				(use: BOTH_T7_T__TL)
+	BOTH_T7_TL__L,	//# Fast arc top left to left				(use: BOTH_T7__L_TL)
+	BOTH_T7__L_TR,	//# Fast arc left to top right			(use: BOTH_T7_TR__L)
+	BOTH_T7__L_T_,	//# Fast arc left to top				(use: BOTH_T7_T___L)
+	BOTH_T7__L_BL,	//# Fast arc left to bottom left			(use: BOTH_T7_BL__L)
+	BOTH_T7_BL_T_,	//# Fast arc bottom left to top			(use: BOTH_T7_T__BL)
+	BOTH_T7_BL_TL,	//# Fast arc bottom left to top left		(use: BOTH_T7_TL_BL)
+	//Saber Attack Start Transitions
+	BOTH_S7_S7_T_,	//# Fast plain transition from stance1 to top-to-bottom Fast weak attack
+	BOTH_S7_S7__L,	//# Fast plain transition from stance1 to left-to-right Fast weak attack
+	BOTH_S7_S7__R,	//# Fast plain transition from stance1 to right-to-left Fast weak attack
+	BOTH_S7_S7_TL,	//# Fast plain transition from stance1 to top-left-to-bottom-right Fast weak attack
+	BOTH_S7_S7_BR,	//# Fast plain transition from stance1 to bottom-right-to-top-left Fast weak attack
+	BOTH_S7_S7_BL,	//# Fast plain transition from stance1 to bottom-left-to-top-right Fast weak attack
+	BOTH_S7_S7_TR,	//# Fast plain transition from stance1 to top-right-to-bottom-left Fast weak attack
+	//Saber Attack Return Transitions
+	BOTH_R7_B__S7,	//# Fast plain transition from top-to-bottom Fast weak attack to stance1
+	BOTH_R7__L_S7,	//# Fast plain transition from left-to-right Fast weak attack to stance1
+	BOTH_R7__R_S7,	//# Fast plain transition from right-to-left Fast weak attack to stance1
+	BOTH_R7_TL_S7,	//# Fast plain transition from top-left-to-bottom-right Fast weak attack to stance1
+	BOTH_R7_BR_S7,	//# Fast plain transition from bottom-right-to-top-left Fast weak attack to stance1
+	BOTH_R7_BL_S7,	//# Fast plain transition from bottom-left-to-top-right Fast weak attack to stance1
+	BOTH_R7_TR_S7,	//# Fast plain transition from top-right-to-bottom-left Fast weak attack
+	//Saber Attack Bounces (first 4 frames of an attack, played backwards)
+	BOTH_B7_BR___,	//# Bounce-back if attack from BR is blocked
+	BOTH_B7__R___,	//# Bounce-back if attack from R is blocked
+	BOTH_B7_TR___,	//# Bounce-back if attack from TR is blocked
+	BOTH_B7_T____,	//# Bounce-back if attack from T is blocked
+	BOTH_B7_TL___,	//# Bounce-back if attack from TL is blocked
+	BOTH_B7__L___,	//# Bounce-back if attack from L is blocked
+	BOTH_B7_BL___,	//# Bounce-back if attack from BL is blocked
+	//Saber Attack Deflections (last 4 frames of an attack)
+	BOTH_D7_BR___,	//# Deflection toward BR
+	BOTH_D7__R___,	//# Deflection toward R
+	BOTH_D7_TR___,	//# Deflection toward TR
+	BOTH_D7_TL___,	//# Deflection toward TL
+	BOTH_D7__L___,	//# Deflection toward L
+	BOTH_D7_BL___,	//# Deflection toward BL
+	BOTH_D7_B____,	//# Deflection toward B
+	//Saber parry anims
+	BOTH_P1_S1_T_,	//# Block shot/saber top
+	BOTH_P1_S1_TR,	//# Block shot/saber top right
+	BOTH_P1_S1_TL,	//# Block shot/saber top left
+	BOTH_P1_S1_BL,	//# Block shot/saber bottom left
+	BOTH_P1_S1_BR,	//# Block shot/saber bottom right
+	//Saber knockaway
+	BOTH_K1_S1_T_,	//# knockaway saber top
+	BOTH_K1_S1_TR,	//# knockaway saber top right
+	BOTH_K1_S1_TL,	//# knockaway saber top left
+	BOTH_K1_S1_BL,	//# knockaway saber bottom left
+	BOTH_K1_S1_B_,	//# knockaway saber bottom
+	BOTH_K1_S1_BR,	//# knockaway saber bottom right
+	//Saber attack knocked away
+	BOTH_V1_BR_S1,	//# BR attack knocked away
+	BOTH_V1__R_S1,	//# R attack knocked away
+	BOTH_V1_TR_S1,	//# TR attack knocked away
+	BOTH_V1_T__S1,	//# T attack knocked away
+	BOTH_V1_TL_S1,	//# TL attack knocked away
+	BOTH_V1__L_S1,	//# L attack knocked away
+	BOTH_V1_BL_S1,	//# BL attack knocked away
+	BOTH_V1_B__S1,	//# B attack knocked away
+	//Saber parry broken
+	BOTH_H1_S1_T_,	//# saber knocked down from top parry
+	BOTH_H1_S1_TR,	//# saber knocked down-left from TR parry
+	BOTH_H1_S1_TL,	//# saber knocked down-right from TL parry
+	BOTH_H1_S1_BL,	//# saber knocked up-right from BL parry
+	BOTH_H1_S1_B_,	//# saber knocked up over head from ready?
+	BOTH_H1_S1_BR,	//# saber knocked up-left from BR parry
+	//Dual Saber parry anims
+	BOTH_P6_S6_T_,	//# Block shot/saber top
+	BOTH_P6_S6_TR,	//# Block shot/saber top right
+	BOTH_P6_S6_TL,	//# Block shot/saber top left
+	BOTH_P6_S6_BL,	//# Block shot/saber bottom left
+	BOTH_P6_S6_BR,	//# Block shot/saber bottom right
+	//Dual Saber knockaway
+	BOTH_K6_S6_T_,	//# knockaway saber top
+	BOTH_K6_S6_TR,	//# knockaway saber top right
+	BOTH_K6_S6_TL,	//# knockaway saber top left
+	BOTH_K6_S6_BL,	//# knockaway saber bottom left
+	BOTH_K6_S6_B_,	//# knockaway saber bottom
+	BOTH_K6_S6_BR,	//# knockaway saber bottom right
+	//Dual Saber attack knocked away
+	BOTH_V6_BR_S6,	//# BR attack knocked away
+	BOTH_V6__R_S6,	//# R attack knocked away
+	BOTH_V6_TR_S6,	//# TR attack knocked away
+	BOTH_V6_T__S6,	//# T attack knocked away
+	BOTH_V6_TL_S6,	//# TL attack knocked away
+	BOTH_V6__L_S6,	//# L attack knocked away
+	BOTH_V6_BL_S6,	//# BL attack knocked away
+	BOTH_V6_B__S6,	//# B attack knocked away
+	//Dual Saber parry broken
+	BOTH_H6_S6_T_,	//# saber knocked down from top parry
+	BOTH_H6_S6_TR,	//# saber knocked down-left from TR parry
+	BOTH_H6_S6_TL,	//# saber knocked down-right from TL parry
+	BOTH_H6_S6_BL,	//# saber knocked up-right from BL parry
+	BOTH_H6_S6_B_,	//# saber knocked up over head from ready?
+	BOTH_H6_S6_BR,	//# saber knocked up-left from BR parry
+	//SaberStaff parry anims
+	BOTH_P7_S7_T_,	//# Block shot/saber top
+	BOTH_P7_S7_TR,	//# Block shot/saber top right
+	BOTH_P7_S7_TL,	//# Block shot/saber top left
+	BOTH_P7_S7_BL,	//# Block shot/saber bottom left
+	BOTH_P7_S7_BR,	//# Block shot/saber bottom right
+	//SaberStaff knockaway
+	BOTH_K7_S7_T_,	//# knockaway saber top
+	BOTH_K7_S7_TR,	//# knockaway saber top right
+	BOTH_K7_S7_TL,	//# knockaway saber top left
+	BOTH_K7_S7_BL,	//# knockaway saber bottom left
+	BOTH_K7_S7_B_,	//# knockaway saber bottom
+	BOTH_K7_S7_BR,	//# knockaway saber bottom right
+	//SaberStaff attack knocked away
+	BOTH_V7_BR_S7,	//# BR attack knocked away
+	BOTH_V7__R_S7,	//# R attack knocked away
+	BOTH_V7_TR_S7,	//# TR attack knocked away
+	BOTH_V7_T__S7,	//# T attack knocked away
+	BOTH_V7_TL_S7,	//# TL attack knocked away
+	BOTH_V7__L_S7,	//# L attack knocked away
+	BOTH_V7_BL_S7,	//# BL attack knocked away
+	BOTH_V7_B__S7,	//# B attack knocked away
+	//SaberStaff parry broken
+	BOTH_H7_S7_T_,	//# saber knocked down from top parry
+	BOTH_H7_S7_TR,	//# saber knocked down-left from TR parry
+	BOTH_H7_S7_TL,	//# saber knocked down-right from TL parry
+	BOTH_H7_S7_BL,	//# saber knocked up-right from BL parry
+	BOTH_H7_S7_B_,	//# saber knocked up over head from ready?
+	BOTH_H7_S7_BR,	//# saber knocked up-left from BR parry
+	//Sabers locked anims
+	//* #sep BOTH_ SABER LOCKED ANIMS
+	//BOTH_(DL, S, ST)_(DL, S, ST)_(T, S)_(L, B, SB)_1(_W, _L)
+//===Single locks==================================================================
+//SINGLE vs. DUAL
+	//side locks - I'm using a single and they're using dual
+	BOTH_LK_S_DL_S_B_1_L,	//normal break I lost
+	BOTH_LK_S_DL_S_B_1_W,	//normal break I won
+	BOTH_LK_S_DL_S_L_1,		//lock if I'm using single vs. a dual
+	BOTH_LK_S_DL_S_SB_1_L,	//super break I lost
+	BOTH_LK_S_DL_S_SB_1_W,	//super break I won
+	//top locks
+	BOTH_LK_S_DL_T_B_1_L,	//normal break I lost
+	BOTH_LK_S_DL_T_B_1_W,	//normal break I won
+	BOTH_LK_S_DL_T_L_1,		//lock if I'm using single vs. a dual
+	BOTH_LK_S_DL_T_SB_1_L,	//super break I lost
+	BOTH_LK_S_DL_T_SB_1_W,	//super break I won
+//SINGLE vs. STAFF
+	//side locks
+	BOTH_LK_S_ST_S_B_1_L,	//normal break I lost
+	BOTH_LK_S_ST_S_B_1_W,	//normal break I won
+	BOTH_LK_S_ST_S_L_1,		//lock if I'm using single vs. a staff
+	BOTH_LK_S_ST_S_SB_1_L,	//super break I lost
+	BOTH_LK_S_ST_S_SB_1_W,	//super break I won
+	//top locks
+	BOTH_LK_S_ST_T_B_1_L,	//normal break I lost
+	BOTH_LK_S_ST_T_B_1_W,	//normal break I won
+	BOTH_LK_S_ST_T_L_1,		//lock if I'm using single vs. a staff
+	BOTH_LK_S_ST_T_SB_1_L,	//super break I lost
+	BOTH_LK_S_ST_T_SB_1_W,	//super break I won
+//SINGLE vs. SINGLE
+	//side locks
+	BOTH_LK_S_S_S_B_1_L,	//normal break I lost
+	BOTH_LK_S_S_S_B_1_W,	//normal break I won
+	BOTH_LK_S_S_S_L_1,		//lock if I'm using single vs. a single and I initiated
+	BOTH_LK_S_S_S_SB_1_L,	//super break I lost
+	BOTH_LK_S_S_S_SB_1_W,	//super break I won
+	//top locks
+	BOTH_LK_S_S_T_B_1_L,	//normal break I lost
+	BOTH_LK_S_S_T_B_1_W,	//normal break I won
+	BOTH_LK_S_S_T_L_1,		//lock if I'm using single vs. a single and I initiated
+	BOTH_LK_S_S_T_SB_1_L,	//super break I lost
+	BOTH_LK_S_S_T_SB_1_W,	//super break I won
+//===Dual Saber locks==================================================================
+//DUAL vs. DUAL	
+	//side locks
+	BOTH_LK_DL_DL_S_B_1_L,	//normal break I lost
+	BOTH_LK_DL_DL_S_B_1_W,	//normal break I won
+	BOTH_LK_DL_DL_S_L_1,	//lock if I'm using dual vs. dual and I initiated
+	BOTH_LK_DL_DL_S_SB_1_L,	//super break I lost
+	BOTH_LK_DL_DL_S_SB_1_W,	//super break I won
+	//top locks
+	BOTH_LK_DL_DL_T_B_1_L,	//normal break I lost
+	BOTH_LK_DL_DL_T_B_1_W,	//normal break I won
+	BOTH_LK_DL_DL_T_L_1,	//lock if I'm using dual vs. dual and I initiated
+	BOTH_LK_DL_DL_T_SB_1_L,	//super break I lost
+	BOTH_LK_DL_DL_T_SB_1_W,	//super break I won
+//DUAL vs. STAFF
+	//side locks
+	BOTH_LK_DL_ST_S_B_1_L,	//normal break I lost
+	BOTH_LK_DL_ST_S_B_1_W,	//normal break I won
+	BOTH_LK_DL_ST_S_L_1,	//lock if I'm using dual vs. a staff
+	BOTH_LK_DL_ST_S_SB_1_L,	//super break I lost
+	BOTH_LK_DL_ST_S_SB_1_W,	//super break I won
+	//top locks
+	BOTH_LK_DL_ST_T_B_1_L,	//normal break I lost
+	BOTH_LK_DL_ST_T_B_1_W,	//normal break I won
+	BOTH_LK_DL_ST_T_L_1,	//lock if I'm using dual vs. a staff
+	BOTH_LK_DL_ST_T_SB_1_L,	//super break I lost
+	BOTH_LK_DL_ST_T_SB_1_W,	//super break I won
+//DUAL vs. SINGLE
+	//side locks
+	BOTH_LK_DL_S_S_B_1_L,	//normal break I lost
+	BOTH_LK_DL_S_S_B_1_W,	//normal break I won
+	BOTH_LK_DL_S_S_L_1,		//lock if I'm using dual vs. a single
+	BOTH_LK_DL_S_S_SB_1_L,	//super break I lost
+	BOTH_LK_DL_S_S_SB_1_W,	//super break I won
+	//top locks
+	BOTH_LK_DL_S_T_B_1_L,	//normal break I lost
+	BOTH_LK_DL_S_T_B_1_W,	//normal break I won
+	BOTH_LK_DL_S_T_L_1,		//lock if I'm using dual vs. a single
+	BOTH_LK_DL_S_T_SB_1_L,	//super break I lost
+	BOTH_LK_DL_S_T_SB_1_W,	//super break I won
+//===Saber Staff locks==================================================================
+//STAFF vs. DUAL
+	//side locks
+	BOTH_LK_ST_DL_S_B_1_L,	//normal break I lost
+	BOTH_LK_ST_DL_S_B_1_W,	//normal break I won
+	BOTH_LK_ST_DL_S_L_1,	//lock if I'm using staff vs. dual
+	BOTH_LK_ST_DL_S_SB_1_L,	//super break I lost
+	BOTH_LK_ST_DL_S_SB_1_W,	//super break I won
+	//top locks
+	BOTH_LK_ST_DL_T_B_1_L,	//normal break I lost
+	BOTH_LK_ST_DL_T_B_1_W,	//normal break I won
+	BOTH_LK_ST_DL_T_L_1,	//lock if I'm using staff vs. dual
+	BOTH_LK_ST_DL_T_SB_1_L,	//super break I lost
+	BOTH_LK_ST_DL_T_SB_1_W,	//super break I won
+//STAFF vs. STAFF
+	//side locks
+	BOTH_LK_ST_ST_S_B_1_L,	//normal break I lost
+	BOTH_LK_ST_ST_S_B_1_W,	//normal break I won
+	BOTH_LK_ST_ST_S_L_1,	//lock if I'm using staff vs. a staff and I initiated
+	BOTH_LK_ST_ST_S_SB_1_L,	//super break I lost
+	BOTH_LK_ST_ST_S_SB_1_W,	//super break I won
+	//top locks
+	BOTH_LK_ST_ST_T_B_1_L,	//normal break I lost
+	BOTH_LK_ST_ST_T_B_1_W,	//normal break I won
+	BOTH_LK_ST_ST_T_L_1,	//lock if I'm using staff vs. a staff and I initiated
+	BOTH_LK_ST_ST_T_SB_1_L,	//super break I lost
+	BOTH_LK_ST_ST_T_SB_1_W,	//super break I won
+//STAFF vs. SINGLE
+	//side locks
+	BOTH_LK_ST_S_S_B_1_L,	//normal break I lost
+	BOTH_LK_ST_S_S_B_1_W,	//normal break I won
+	BOTH_LK_ST_S_S_L_1,		//lock if I'm using staff vs. a single
+	BOTH_LK_ST_S_S_SB_1_L,	//super break I lost
+	BOTH_LK_ST_S_S_SB_1_W,	//super break I won
+	//top locks
+	BOTH_LK_ST_S_T_B_1_L,	//normal break I lost
+	BOTH_LK_ST_S_T_B_1_W,	//normal break I won
+	BOTH_LK_ST_S_T_L_1,		//lock if I'm using staff vs. a single
+	BOTH_LK_ST_S_T_SB_1_L,	//super break I lost
+	BOTH_LK_ST_S_T_SB_1_W,	//super break I won
+//Special cases for same saber style vs. each other (won't fit in nice 5-anim size lists above)
+	BOTH_LK_S_S_S_L_2,		//lock if I'm using single vs. a single and other intitiated
+	BOTH_LK_S_S_T_L_2,		//lock if I'm using single vs. a single and other initiated
+	BOTH_LK_DL_DL_S_L_2,	//lock if I'm using dual vs. dual and other initiated
+	BOTH_LK_DL_DL_T_L_2,	//lock if I'm using dual vs. dual and other initiated
+	BOTH_LK_ST_ST_S_L_2,	//lock if I'm using staff vs. a staff and other initiated
+	BOTH_LK_ST_ST_T_L_2,	//lock if I'm using staff vs. a staff and other initiated
+//===End Saber locks==================================================================
+	//old locks
+	BOTH_BF2RETURN,	//#
+	BOTH_BF2BREAK,	//#
+	BOTH_BF2LOCK,	//#
+	BOTH_BF1RETURN,	//#
+	BOTH_BF1BREAK,	//#
+	BOTH_BF1LOCK,	//#
+	BOTH_CWCIRCLE_R2__R_S1,	//#
+	BOTH_CCWCIRCLE_R2__L_S1,	//#
+	BOTH_CWCIRCLE_A2__L__R,	//#
+	BOTH_CCWCIRCLE_A2__R__L,	//#
+	BOTH_CWCIRCLEBREAK,	//#
+	BOTH_CCWCIRCLEBREAK,	//#
+	BOTH_CWCIRCLELOCK,	//#
+	BOTH_CCWCIRCLELOCK,	//#
+	//other saber anims
+	//* #sep BOTH_ SABER MISC ANIMS
+	BOTH_SABERFAST_STANCE,
+	BOTH_SABERSLOW_STANCE,
+	BOTH_SABERDUAL_STANCE,
+	BOTH_SABERSTAFF_STANCE,
+	BOTH_A2_STABBACK1,		//# Stab saber backward
+	BOTH_ATTACK_BACK,		//# Swing around backwards and attack
+	BOTH_JUMPFLIPSLASHDOWN1,//#
+	BOTH_JUMPFLIPSTABDOWN,//#
+	BOTH_FORCELEAP2_T__B_,//#
+	BOTH_LUNGE2_B__T_,//#
+	BOTH_CROUCHATTACKBACK1,//#
+	//New specials for JKA:
+	BOTH_JUMPATTACK6,//#
+	BOTH_JUMPATTACK7,//#
+	BOTH_SPINATTACK6,//#
+	BOTH_SPINATTACK7,//#
+	BOTH_S1_S6,//#	From stand1 to saberdual stance - turning on your dual sabers
+	BOTH_S6_S1,//#	From dualstaff stance to stand1 - turning off your dual sabers
+	BOTH_S1_S7,//#	From stand1 to saberstaff stance - turning on your saberstaff
+	BOTH_S7_S1,//#	From saberstaff stance to stand1 - turning off your saberstaff
+	BOTH_FORCELONGLEAP_START,
+	BOTH_FORCELONGLEAP_ATTACK,
+	BOTH_FORCELONGLEAP_LAND,
+	BOTH_FORCEWALLRUNFLIP_START,
+	BOTH_FORCEWALLRUNFLIP_END,
+	BOTH_FORCEWALLRUNFLIP_ALT,
+	BOTH_FORCEWALLREBOUND_FORWARD,
+	BOTH_FORCEWALLREBOUND_LEFT,
+	BOTH_FORCEWALLREBOUND_BACK,
+	BOTH_FORCEWALLREBOUND_RIGHT,
+	BOTH_FORCEWALLHOLD_FORWARD,
+	BOTH_FORCEWALLHOLD_LEFT,
+	BOTH_FORCEWALLHOLD_BACK,
+	BOTH_FORCEWALLHOLD_RIGHT,
+	BOTH_FORCEWALLRELEASE_FORWARD,
+	BOTH_FORCEWALLRELEASE_LEFT,
+	BOTH_FORCEWALLRELEASE_BACK,
+	BOTH_FORCEWALLRELEASE_RIGHT,
+	BOTH_A7_KICK_F,
+	BOTH_A7_KICK_B,
+	BOTH_A7_KICK_R,
+	BOTH_A7_KICK_L,
+	BOTH_A7_KICK_S,
+	BOTH_A7_KICK_BF,
+	BOTH_A7_KICK_BF_STOP,
+	BOTH_A7_KICK_RL,
+	BOTH_A7_KICK_F_AIR,
+	BOTH_A7_KICK_B_AIR,
+	BOTH_A7_KICK_R_AIR,
+	BOTH_A7_KICK_L_AIR,
+	BOTH_FLIP_ATTACK7,
+	BOTH_FLIP_HOLD7,
+	BOTH_FLIP_LAND,
+	BOTH_PULL_IMPALE_STAB,
+	BOTH_PULL_IMPALE_SWING,
+	BOTH_PULLED_INAIR_B,
+	BOTH_PULLED_INAIR_F,
+	BOTH_STABDOWN,
+	BOTH_STABDOWN_STAFF,
+	BOTH_STABDOWN_DUAL,
+	BOTH_A6_SABERPROTECT,
+	BOTH_A7_SOULCAL,
+	BOTH_A1_SPECIAL,
+	BOTH_A2_SPECIAL,
+	BOTH_A3_SPECIAL,
+	BOTH_ROLL_STAB,
+
+	//# #sep BOTH_ STANDING
+	BOTH_STAND1,			//# Standing idle, no weapon, hands down
+	BOTH_STAND1IDLE1,		//# Random standing idle
+	BOTH_STAND2,			//# Standing idle with a saber
+	BOTH_STAND2IDLE1,		//# Random standing idle
+	BOTH_STAND2IDLE2,		//# Random standing idle
+	BOTH_STAND3,			//# Standing idle with 2-handed weapon
+	BOTH_STAND3IDLE1,		//# Random standing idle
+	BOTH_STAND4,			//# hands clasp behind back
+	BOTH_STAND5,			//# standing idle, no weapon, hand down, back straight
+	BOTH_STAND5IDLE1,		//# Random standing idle
+	BOTH_STAND6,			//# one handed, gun at side, relaxed stand
+	BOTH_STAND8,			//# both hands on hips (male)
+	BOTH_STAND1TO2,			//# Transition from stand1 to stand2
+	BOTH_STAND2TO1,			//# Transition from stand2 to stand1
+	BOTH_STAND2TO4,			//# Transition from stand2 to stand4
+	BOTH_STAND4TO2,			//# Transition from stand4 to stand2
+	BOTH_STAND4TOATTACK2,	//# relaxed stand to 1-handed pistol ready
+	BOTH_STANDUP2,			//# Luke standing up from his meditation platform (cin # 37)
+	BOTH_STAND5TOSIT3,		//# transition from stand 5 to sit 3
+	BOTH_STAND1TOSTAND5,	//# Transition from stand1 to stand5
+	BOTH_STAND5TOSTAND1,	//# Transition from stand5 to stand1
+	BOTH_STAND5TOAIM,		//# Transition of Kye aiming his gun at Desann (cin #9) 
+	BOTH_STAND5STARTLEDLOOKLEFT,	//# Kyle turning to watch the bridge drop (cin #9) 
+	BOTH_STARTLEDLOOKLEFTTOSTAND5,	//# Kyle returning to stand 5 from watching the bridge drop (cin #9) 
+	BOTH_STAND5TOSTAND8,	//# Transition from stand5 to stand8
+	BOTH_STAND7TOSTAND8,	//# Tavion putting hands on back of chair (cin #11)
+	BOTH_STAND8TOSTAND5,	//# Transition from stand8 to stand5
+	BOTH_STAND9,			//# Kyle's standing idle, no weapon, hands down
+	BOTH_STAND9IDLE1,		//# Kyle's random standing idle
+	BOTH_STAND5SHIFTWEIGHT,	//# Weightshift from stand5 to side and back to stand5
+	BOTH_STAND5SHIFTWEIGHTSTART,	//# From stand5 to side
+	BOTH_STAND5SHIFTWEIGHTSTOP,		//# From side to stand5
+	BOTH_STAND5TURNLEFTSTART,		//# Start turning left from stand5
+	BOTH_STAND5TURNLEFTSTOP,		//# Stop turning left from stand5
+	BOTH_STAND5TURNRIGHTSTART,		//# Start turning right from stand5
+	BOTH_STAND5TURNRIGHTSTOP,		//# Stop turning right from stand5
+	BOTH_STAND5LOOK180LEFTSTART,	//# Start looking over left shoulder (cin #17)
+	BOTH_STAND5LOOK180LEFTSTOP,	//# Stop looking over left shoulder (cin #17)
+
+	BOTH_CONSOLE1START,		//# typing at a console
+	BOTH_CONSOLE1,			//# typing at a console
+	BOTH_CONSOLE1STOP,		//# typing at a console
+	BOTH_CONSOLE2START,		//# typing at a console with comm link in hand (cin #5) 
+	BOTH_CONSOLE2,			//# typing at a console with comm link in hand (cin #5) 
+	BOTH_CONSOLE2STOP,		//# typing at a console with comm link in hand (cin #5) 
+	BOTH_CONSOLE2HOLDCOMSTART,	//# lean in to type at console while holding comm link in hand (cin #5) 
+	BOTH_CONSOLE2HOLDCOMSTOP,	//# lean away after typing at console while holding comm link in hand (cin #5) 
+
+	BOTH_GUARD_LOOKAROUND1,	//# Cradling weapon and looking around
+	BOTH_GUARD_IDLE1,		//# Cradling weapon and standing
+	BOTH_GESTURE1,			//# Generic gesture, non-specific
+	BOTH_GESTURE2,			//# Generic gesture, non-specific
+	BOTH_WALK1TALKCOMM1,	//# Talking into coom link while walking
+	BOTH_TALK1,				//# Generic talk anim
+	BOTH_TALK2,				//# Generic talk anim
+	BOTH_TALKCOMM1START,	//# Start talking into a comm link
+	BOTH_TALKCOMM1,			//# Talking into a comm link
+	BOTH_TALKCOMM1STOP,		//# Stop talking into a comm link
+	BOTH_TALKGESTURE1,		//# Generic talk anim
+	
+	BOTH_HEADTILTLSTART,		//# Head tilt to left
+	BOTH_HEADTILTLSTOP,			//# Head tilt to left
+	BOTH_HEADTILTRSTART,		//# Head tilt to right
+	BOTH_HEADTILTRSTOP,			//# Head tilt to right
+	BOTH_HEADNOD,				//# Head shake YES
+	BOTH_HEADSHAKE,				//# Head shake NO
+	BOTH_SIT2HEADTILTLSTART,	//# Head tilt to left from seated position 2
+	BOTH_SIT2HEADTILTLSTOP,		//# Head tilt to left from seated position 2
+ 
+	BOTH_REACH1START,		//# Monmothma reaching for crystal
+	BOTH_REACH1STOP,		//# Monmothma reaching for crystal
+
+	BOTH_COME_ON1,				//# Jan gesturing to Kyle (cin #32a)
+	BOTH_STEADYSELF1,			//# Jan trying to keep footing (cin #32a)
+	BOTH_STEADYSELF1END,		//# Return hands to side from STEADSELF1 Kyle (cin#5)
+	BOTH_SILENCEGESTURE1,		//# Luke silencing Kyle with a raised hand (cin #37)
+	BOTH_REACHFORSABER1,		//# Luke holding hand out for Kyle's saber (cin #37)
+	BOTH_SABERKILLER1,			//# Tavion about to strike Jan with saber (cin #9)
+	BOTH_SABERKILLEE1,			//# Jan about to be struck by Tavion with saber (cin #9)
+	BOTH_HUGGER1,			//# Kyle hugging Jan (cin #29)
+	BOTH_HUGGERSTOP1,		//# Kyle stop hugging Jan but don't let her go (cin #29)
+	BOTH_HUGGEE1,			//# Jan being hugged (cin #29)
+	BOTH_HUGGEESTOP1,		//# Jan stop being hugged but don't let go (cin #29)
+
+	BOTH_SABERTHROW1START,		//# Desann throwing his light saber (cin #26)
+	BOTH_SABERTHROW1STOP,		//# Desann throwing his light saber (cin #26)
+	BOTH_SABERTHROW2START,		//# Kyle throwing his light saber (cin #32)
+	BOTH_SABERTHROW2STOP,		//# Kyle throwing his light saber (cin #32)
+
+	//# #sep BOTH_ SITTING/CROUCHING
+	BOTH_SIT1,				//# Normal chair sit.
+	BOTH_SIT2,				//# Lotus position.
+	BOTH_SIT3,				//# Sitting in tired position, elbows on knees
+
+	BOTH_SIT2TOSTAND5,		//# Transition from sit 2 to stand 5
+	BOTH_STAND5TOSIT2,		//# Transition from stand 5 to sit 2
+	BOTH_SIT2TOSIT4,		//# Trans from sit2 to sit4 (cin #12) Luke leaning back from lotus position.
+	BOTH_SIT3TOSTAND5,		//# transition from sit 3 to stand 5
+
+	BOTH_CROUCH1,			//# Transition from standing to crouch
+	BOTH_CROUCH1IDLE,		//# Crouching idle
+	BOTH_CROUCH1WALK,		//# Walking while crouched
+	BOTH_CROUCH1WALKBACK,	//# Walking while crouched
+	BOTH_UNCROUCH1,			//# Transition from crouch to standing
+	BOTH_CROUCH2TOSTAND1,	//# going from crouch2 to stand1
+	BOTH_CROUCH3,			//# Desann crouching down to Kyle (cin 9)
+	BOTH_UNCROUCH3,			//# Desann uncrouching down to Kyle (cin 9)
+	BOTH_CROUCH4,			//# Slower version of crouch1 for cinematics
+	BOTH_UNCROUCH4,			//# Slower version of uncrouch1 for cinematics
+
+	BOTH_GUNSIT1,			//# sitting on an emplaced gun.
+
+	// Swoop Vehicle animations.
+	//* #sep BOTH_ SWOOP ANIMS
+	BOTH_VS_MOUNT_L,			//# Mount from left		
+	BOTH_VS_DISMOUNT_L,			//# Dismount to left		
+	BOTH_VS_MOUNT_R,			//# Mount from  right (symmetry)		
+	BOTH_VS_DISMOUNT_R,			//# DISMOUNT TO  RIGHT (SYMMETRY)		
+
+	BOTH_VS_MOUNTJUMP_L,		//#
+	BOTH_VS_MOUNTTHROW,			//# Land on an occupied vehicle & throw off current pilot
+	BOTH_VS_MOUNTTHROW_L,		//# Land on an occupied vehicle & throw off current pilot
+	BOTH_VS_MOUNTTHROW_R,		//# Land on an occupied vehicle & throw off current pilot
+	BOTH_VS_MOUNTTHROWEE,		//# Current pilot getting thrown off by another guy
+
+	BOTH_VS_LOOKLEFT,			//# Turn & Look behind and to the left (no weapon)		
+	BOTH_VS_LOOKRIGHT,			//# Turn & Look behind and to the right (no weapon)		
+
+	BOTH_VS_TURBO,				//# Hit The Turbo Button
+
+	BOTH_VS_REV,				//# Player looks back as swoop reverses		
+
+	BOTH_VS_AIR,				//# Player stands up when swoop is airborn		
+	BOTH_VS_AIR_G,				//# "" with Gun
+	BOTH_VS_AIR_SL,				//# "" with Saber Left
+	BOTH_VS_AIR_SR,				//# "" with Saber Right
+
+	BOTH_VS_LAND,				//# Player bounces down when swoop lands		
+	BOTH_VS_LAND_G,				//#  "" with Gun
+	BOTH_VS_LAND_SL,			//#  "" with Saber Left
+	BOTH_VS_LAND_SR,			//#  "" with Saber Right
+
+	BOTH_VS_IDLE,				//# Sit
+	BOTH_VS_IDLE_G,				//# Sit (gun)
+	BOTH_VS_IDLE_SL,			//# Sit (saber left)		
+	BOTH_VS_IDLE_SR,			//# Sit (saber right)		
+
+	BOTH_VS_LEANL,				//# Lean left
+	BOTH_VS_LEANL_G,			//# Lean left (gun)		
+	BOTH_VS_LEANL_SL,			//# Lean left (saber left)		
+	BOTH_VS_LEANL_SR,			//# Lean left (saber right)		
+
+	BOTH_VS_LEANR,				//# Lean right		
+	BOTH_VS_LEANR_G,			//# Lean right (gun)		
+	BOTH_VS_LEANR_SL,			//# Lean right (saber left)		
+	BOTH_VS_LEANR_SR,			//# Lean right (saber right)		
+				
+	BOTH_VS_ATL_S,				//# Attack left with saber		
+	BOTH_VS_ATR_S,				//# Attack right with saber		
+	BOTH_VS_ATR_TO_L_S,			//# Attack toss saber from right to left hand
+	BOTH_VS_ATL_TO_R_S,			//# Attack toss saber from left to right hand
+	BOTH_VS_ATR_G,				//# Attack right with gun (90)		
+	BOTH_VS_ATL_G,				//# Attack left with gun (90)		
+	BOTH_VS_ATF_G,				//# Attack forward with gun		
+
+	BOTH_VS_PAIN1,				//# Pain
+
+	// Added 12/04/02 by Aurelio.
+	//* #sep BOTH_ TAUNTAUN ANIMS
+	BOTH_VT_MOUNT_L,		//# Mount from left	
+	BOTH_VT_MOUNT_R,		//# Mount from right
+	BOTH_VT_MOUNT_B,		//# Mount from air, behind
+	BOTH_VT_DISMOUNT,		//# Dismount for tauntaun
+	BOTH_VT_DISMOUNT_L,		//# Dismount to tauntauns left	
+	BOTH_VT_DISMOUNT_R,		//# Dismount to tauntauns right (symmetry)	
+
+	BOTH_VT_WALK_FWD,		//# Walk forward	
+	BOTH_VT_WALK_REV,		//# Walk backward	
+	BOTH_VT_WALK_FWD_L,		//# walk lean left
+	BOTH_VT_WALK_FWD_R,		//# Walk lean right
+	BOTH_VT_RUN_FWD,		//# Run forward	
+	BOTH_VT_RUN_REV,		//# Look backwards while running (not weapon specific)	
+	BOTH_VT_RUN_FWD_L,		//# Run lean left
+	BOTH_VT_RUN_FWD_R,		//# Run lean right
+
+	BOTH_VT_SLIDEF,			//# Tauntaun slides forward with abrupt stop	
+	BOTH_VT_AIR,			//# Tauntaun jump	
+	BOTH_VT_ATB,			//# Tauntaun tail swipe	
+	BOTH_VT_PAIN1,			//# Pain	
+	BOTH_VT_DEATH1,			//# Die	
+	BOTH_VT_STAND,			//# Stand still and breath	
+	BOTH_VT_BUCK,			//# Tauntaun bucking loop animation	
+
+	BOTH_VT_LAND,			//# Player bounces down when tauntaun lands	
+	BOTH_VT_TURBO,			//# Hit The Turbo Button
+	BOTH_VT_IDLE_SL,		//# Sit (saber left)		
+	BOTH_VT_IDLE_SR,		//# Sit (saber right)		
+
+	BOTH_VT_IDLE,			//# Sit with no weapon selected	
+	BOTH_VT_IDLE1,			//# Sit with no weapon selected	
+	BOTH_VT_IDLE_S,			//# Sit with saber selected	
+	BOTH_VT_IDLE_G,			//# Sit with gun selected	
+	BOTH_VT_IDLE_T,			//# Sit with thermal grenade selected
+
+	BOTH_VT_ATL_S,			//# Attack left with saber	
+	BOTH_VT_ATR_S,			//# Attack right with saber	
+	BOTH_VT_ATR_TO_L_S,		//# Attack toss saber from right to left hand
+	BOTH_VT_ATL_TO_R_S,		//# Attack toss saber from left to right hand
+	BOTH_VT_ATR_G,			//# Attack right with gun (90)	
+	BOTH_VT_ATL_G,			//# Attack left with gun (90)	
+	BOTH_VT_ATF_G,			//# Attack forward with gun	
+
+
+	// Added 2/26/02 by Aurelio.
+	//* #sep BOTH_ FIGHTER ANIMS
+	BOTH_GEARS_OPEN,
+	BOTH_GEARS_CLOSE,
+	BOTH_WINGS_OPEN,
+	BOTH_WINGS_CLOSE,
+
+	BOTH_DEATH14_UNGRIP,	//# Desann's end death (cin #35)
+	BOTH_DEATH14_SITUP,		//# Tavion sitting up after having been thrown (cin #23)
+	BOTH_KNEES1,			//# Tavion on her knees
+	BOTH_KNEES2,			//# Tavion on her knees looking down
+	BOTH_KNEES2TO1,			//# Transition of KNEES2 to KNEES1
+
+	//# #sep BOTH_ MOVING
+	BOTH_WALK1,				//# Normal walk
+	BOTH_WALK2,				//# Normal walk
+	BOTH_WALK_STAFF,		//# Walk with saberstaff turned on
+	BOTH_WALKBACK_STAFF,	//# Walk backwards with saberstaff turned on
+	BOTH_WALK_DUAL,			//# Walk with dual turned on
+	BOTH_WALKBACK_DUAL,		//# Walk backwards with dual turned on
+	BOTH_WALK5,				//# Tavion taunting Kyle (cin 22)
+	BOTH_WALK6,				//# Slow walk for Luke (cin 12)
+	BOTH_WALK7,				//# Fast walk
+	BOTH_RUN1,				//# Full run
+	BOTH_RUN1START,			//# Start into full run1
+	BOTH_RUN1STOP,			//# Stop from full run1
+	BOTH_RUN2,				//# Full run
+	BOTH_RUN1TORUN2,		//# Wampa run anim transition
+	BOTH_RUN2TORUN1,		//# Wampa run anim transition
+	BOTH_RUN4,				//# Jawa Run
+	BOTH_RUN_STAFF,			//# Run with saberstaff turned on
+	BOTH_RUNBACK_STAFF,		//# Run backwards with saberstaff turned on
+	BOTH_RUN_DUAL,			//# Run with dual turned on
+	BOTH_RUNBACK_DUAL,		//# Run backwards with dual turned on
+	BOTH_STRAFE_LEFT1,		//# Sidestep left, should loop
+	BOTH_STRAFE_RIGHT1,		//# Sidestep right, should loop
+	BOTH_RUNSTRAFE_LEFT1,	//# Sidestep left, should loop
+	BOTH_RUNSTRAFE_RIGHT1,	//# Sidestep right, should loop
+	BOTH_TURN_LEFT1,		//# Turn left, should loop
+	BOTH_TURN_RIGHT1,		//# Turn right, should loop
+	BOTH_TURNSTAND1,		//# Turn from STAND1 position
+	BOTH_TURNSTAND2,		//# Turn from STAND2 position
+	BOTH_TURNSTAND3,		//# Turn from STAND3 position
+	BOTH_TURNSTAND4,		//# Turn from STAND4 position
+	BOTH_TURNSTAND5,		//# Turn from STAND5 position
+	BOTH_TURNCROUCH1,		//# Turn from CROUCH1 position
+
+	BOTH_WALKBACK1,			//# Walk1 backwards
+	BOTH_WALKBACK2,			//# Walk2 backwards
+	BOTH_RUNBACK1,			//# Run1 backwards
+	BOTH_RUNBACK2,			//# Run1 backwards
+	
+	//# #sep BOTH_ JUMPING
+	BOTH_JUMP1,				//# Jump - wind-up and leave ground
+	BOTH_INAIR1,			//# In air loop (from jump)
+	BOTH_LAND1,				//# Landing (from in air loop)
+	BOTH_LAND2,				//# Landing Hard (from a great height)
+
+	BOTH_JUMPBACK1,			//# Jump backwards - wind-up and leave ground
+	BOTH_INAIRBACK1,		//# In air loop (from jump back)
+	BOTH_LANDBACK1,			//# Landing backwards(from in air loop)
+
+	BOTH_JUMPLEFT1,			//# Jump left - wind-up and leave ground
+	BOTH_INAIRLEFT1,		//# In air loop (from jump left)
+	BOTH_LANDLEFT1,			//# Landing left(from in air loop)
+
+	BOTH_JUMPRIGHT1,		//# Jump right - wind-up and leave ground
+	BOTH_INAIRRIGHT1,		//# In air loop (from jump right)
+	BOTH_LANDRIGHT1,		//# Landing right(from in air loop)
+
+	BOTH_FORCEJUMP1,		//# Jump - wind-up and leave ground
+	BOTH_FORCEINAIR1,		//# In air loop (from jump)
+	BOTH_FORCELAND1,		//# Landing (from in air loop)
+
+	BOTH_FORCEJUMPBACK1,	//# Jump backwards - wind-up and leave ground
+	BOTH_FORCEINAIRBACK1,	//# In air loop (from jump back)
+	BOTH_FORCELANDBACK1,	//# Landing backwards(from in air loop)
+
+	BOTH_FORCEJUMPLEFT1,	//# Jump left - wind-up and leave ground
+	BOTH_FORCEINAIRLEFT1,	//# In air loop (from jump left)
+	BOTH_FORCELANDLEFT1,	//# Landing left(from in air loop)
+
+	BOTH_FORCEJUMPRIGHT1,	//# Jump right - wind-up and leave ground
+	BOTH_FORCEINAIRRIGHT1,	//# In air loop (from jump right)
+	BOTH_FORCELANDRIGHT1,	//# Landing right(from in air loop)
+	//# #sep BOTH_ ACROBATICS
+	BOTH_FLIP_F,			//# Flip forward
+	BOTH_FLIP_B,			//# Flip backwards
+	BOTH_FLIP_L,			//# Flip left
+	BOTH_FLIP_R,			//# Flip right
+
+	BOTH_ROLL_F,			//# Roll forward
+	BOTH_ROLL_B,			//# Roll backward
+	BOTH_ROLL_L,			//# Roll left
+	BOTH_ROLL_R,			//# Roll right
+
+	BOTH_HOP_F,				//# quickstep forward
+	BOTH_HOP_B,				//# quickstep backwards
+	BOTH_HOP_L,				//# quickstep left
+	BOTH_HOP_R,				//# quickstep right
+
+	BOTH_DODGE_FL,			//# lean-dodge forward left
+	BOTH_DODGE_FR,			//# lean-dodge forward right
+	BOTH_DODGE_BL,			//# lean-dodge backwards left
+	BOTH_DODGE_BR,			//# lean-dodge backwards right
+	BOTH_DODGE_L,			//# lean-dodge left
+	BOTH_DODGE_R,			//# lean-dodge right
+	BOTH_DODGE_HOLD_FL,			//# lean-dodge pose forward left
+	BOTH_DODGE_HOLD_FR,			//# lean-dodge pose forward right
+	BOTH_DODGE_HOLD_BL,			//# lean-dodge pose backwards left
+	BOTH_DODGE_HOLD_BR,			//# lean-dodge pose backwards right
+	BOTH_DODGE_HOLD_L,			//# lean-dodge pose left
+	BOTH_DODGE_HOLD_R,			//# lean-dodge pose right
+
+	//MP taunt anims
+	BOTH_ENGAGETAUNT,
+	BOTH_BOW,
+	BOTH_MEDITATE,
+	BOTH_MEDITATE_END,
+	BOTH_SHOWOFF_FAST,
+	BOTH_SHOWOFF_MEDIUM,
+	BOTH_SHOWOFF_STRONG,
+	BOTH_SHOWOFF_DUAL,
+	BOTH_SHOWOFF_STAFF,
+	BOTH_VICTORY_FAST,
+	BOTH_VICTORY_MEDIUM,
+	BOTH_VICTORY_STRONG,
+	BOTH_VICTORY_DUAL,
+	BOTH_VICTORY_STAFF,
+	//other saber/acro anims
+	BOTH_ARIAL_LEFT,		//# 
+	BOTH_ARIAL_RIGHT,		//# 
+	BOTH_CARTWHEEL_LEFT,	//# 
+	BOTH_CARTWHEEL_RIGHT,	//# 
+	BOTH_FLIP_LEFT,			//# 
+	BOTH_FLIP_BACK1,		//# 
+	BOTH_FLIP_BACK2,		//# 
+	BOTH_FLIP_BACK3,		//# 
+	BOTH_BUTTERFLY_LEFT,	//# 
+	BOTH_BUTTERFLY_RIGHT,	//# 
+	BOTH_WALL_RUN_RIGHT,	//# 
+	BOTH_WALL_RUN_RIGHT_FLIP,//#
+	BOTH_WALL_RUN_RIGHT_STOP,//# 
+	BOTH_WALL_RUN_LEFT,		//# 
+	BOTH_WALL_RUN_LEFT_FLIP,//#
+	BOTH_WALL_RUN_LEFT_STOP,//# 
+	BOTH_WALL_FLIP_RIGHT,	//# 
+	BOTH_WALL_FLIP_LEFT,	//# 
+	BOTH_KNOCKDOWN1,		//# knocked backwards
+	BOTH_KNOCKDOWN2,		//# knocked backwards hard
+	BOTH_KNOCKDOWN3,		//#	knocked forwards
+	BOTH_KNOCKDOWN4,		//# knocked backwards from crouch
+	BOTH_KNOCKDOWN5,		//# dupe of 3 - will be removed
+	BOTH_GETUP1,			//#
+	BOTH_GETUP2,			//#
+	BOTH_GETUP3,			//#
+	BOTH_GETUP4,			//#
+	BOTH_GETUP5,			//#
+	BOTH_GETUP_CROUCH_F1,	//#
+	BOTH_GETUP_CROUCH_B1,	//#
+	BOTH_FORCE_GETUP_F1,	//#
+	BOTH_FORCE_GETUP_F2,	//#
+	BOTH_FORCE_GETUP_B1,	//#
+	BOTH_FORCE_GETUP_B2,	//#
+	BOTH_FORCE_GETUP_B3,	//#
+	BOTH_FORCE_GETUP_B4,	//#
+	BOTH_FORCE_GETUP_B5,	//#
+	BOTH_FORCE_GETUP_B6,	//#
+	BOTH_GETUP_BROLL_B,	//#
+	BOTH_GETUP_BROLL_F,	//#
+	BOTH_GETUP_BROLL_L,	//#
+	BOTH_GETUP_BROLL_R,	//#
+	BOTH_GETUP_FROLL_B,	//#
+	BOTH_GETUP_FROLL_F,	//#
+	BOTH_GETUP_FROLL_L,	//#
+	BOTH_GETUP_FROLL_R,	//#
+	BOTH_WALL_FLIP_BACK1,	//#
+	BOTH_WALL_FLIP_BACK2,	//#
+	BOTH_SPIN1,				//#
+	BOTH_CEILING_CLING,		//# clinging to ceiling
+	BOTH_CEILING_DROP,		//# dropping from ceiling cling
+
+	//TESTING
+	BOTH_FJSS_TR_BL,		//# jump spin slash tr to bl
+	BOTH_FJSS_TL_BR,		//# jump spin slash bl to tr
+	BOTH_RIGHTHANDCHOPPEDOFF,//#
+	BOTH_DEFLECTSLASH__R__L_FIN,//#
+	BOTH_BASHED1,//#
+	BOTH_ARIAL_F1,//#
+	BOTH_BUTTERFLY_FR1,//#
+	BOTH_BUTTERFLY_FL1,//#
+
+	//NEW SABER/JEDI/FORCE ANIMS
+	BOTH_BACK_FLIP_UP,	//# back flip up Bonus Animation!!!!	
+	BOTH_LOSE_SABER,	//# player losing saber (pulled from hand by force pull 4 - Kyle?)
+	BOTH_STAFF_TAUNT,	//# taunt saberstaff			
+	BOTH_DUAL_TAUNT,		//# taunt dual
+	BOTH_A6_FB,				//# dual attack front/back		
+	BOTH_A6_LR,				//# dual attack left/right
+	BOTH_A7_HILT,			//# saber knock (alt + stand still)
+	//Alora			
+	BOTH_ALORA_SPIN,		//#jump spin attack	death ballet	
+	BOTH_ALORA_FLIP_1,		//# gymnast move 1		
+	BOTH_ALORA_FLIP_2,		//# gymnast move 2		
+	BOTH_ALORA_FLIP_3,		//# gymnast move3		
+	BOTH_ALORA_FLIP_B,		//# gymnast move back		
+	BOTH_ALORA_SPIN_THROW,	//# dual saber throw		
+	BOTH_ALORA_SPIN_SLASH,	//# spin slash	special bonus animation!! :)	
+	BOTH_ALORA_TAUNT,		//# special taunt
+	//Rosh (Kothos battle)			
+	BOTH_ROSH_PAIN,	//# hurt animation (exhausted)		
+	BOTH_ROSH_HEAL,	//# healed/rejuvenated		
+	//Tavion			
+	BOTH_TAVION_SCEPTERGROUND, //# stabbing ground with sith sword shoots electricity everywhere
+	BOTH_TAVION_SWORDPOWER,//# Tavion doing the He-Man(tm) thing
+	BOTH_SCEPTER_START,	//#Point scepter and attack start
+	BOTH_SCEPTER_HOLD,	//#Point scepter and attack hold
+	BOTH_SCEPTER_STOP,	//#Point scepter and attack stop
+	//Kyle Boss			
+	BOTH_KYLE_GRAB,		//# grab
+	BOTH_KYLE_MISS,		//# miss
+	BOTH_KYLE_PA_1,		//# hold 1
+	BOTH_PLAYER_PA_1,	//# player getting held 1
+	BOTH_KYLE_PA_2,		//# hold 2
+	BOTH_PLAYER_PA_2,	//# player getting held 2
+	BOTH_PLAYER_PA_FLY,	//# player getting knocked back from punch at end of hold 1
+	BOTH_KYLE_PA_3,		//# hold 3
+	BOTH_PLAYER_PA_3,	//# player getting held 3
+	BOTH_PLAYER_PA_3_FLY,//# player getting thrown at end of hold 3
+	//Rancor
+	BOTH_BUCK_RIDER,	//# Rancor bucks when someone is on him
+	//WAMPA Grabbing enemy
+	BOTH_HOLD_START,	//#
+	BOTH_HOLD_MISS,	//#
+	BOTH_HOLD_IDLE,	//#
+	BOTH_HOLD_END,	//#
+	BOTH_HOLD_ATTACK,	//#
+	BOTH_HOLD_SNIFF,	//# Sniff the guy you're holding
+	BOTH_HOLD_DROP,		//# just drop 'em
+	//BEING GRABBED BY WAMPA
+	BOTH_GRABBED,	//#
+	BOTH_RELEASED,	//#
+	BOTH_HANG_IDLE,	//#
+	BOTH_HANG_ATTACK,	//#
+	BOTH_HANG_PAIN,	//#
+
+	//# #sep BOTH_ MISC MOVEMENT
+	BOTH_HIT1,				//# Kyle hit by crate in cin #9
+	BOTH_LADDER_UP1,		//# Climbing up a ladder with rungs at 16 unit intervals
+	BOTH_LADDER_DWN1,		//# Climbing down a ladder with rungs at 16 unit intervals
+	BOTH_LADDER_IDLE,		//#	Just sitting on the ladder
+
+	//# #sep BOTH_ FLYING IDLE
+	BOTH_FLY_SHIELDED,		//# For sentry droid, shields in
+
+	//# #sep BOTH_ SWIMMING
+	BOTH_SWIM_IDLE1,		//# Swimming Idle 1
+	BOTH_SWIMFORWARD,		//# Swim forward loop
+	BOTH_SWIMBACKWARD,		//# Swim backward loop
+
+	//# #sep BOTH_ LYING
+	BOTH_SLEEP1,			//# laying on back-rknee up-rhand on torso
+	BOTH_SLEEP6START,		//# Kyle leaning back to sleep (cin 20)
+	BOTH_SLEEP6STOP,		//# Kyle waking up and shaking his head (cin 21)
+	BOTH_SLEEP1GETUP,		//# alarmed and getting up out of sleep1 pose to stand
+	BOTH_SLEEP1GETUP2,		//# 
+
+	BOTH_CHOKE1START,		//# tavion in force grip choke
+	BOTH_CHOKE1STARTHOLD,	//# loop of tavion in force grip choke
+	BOTH_CHOKE1,			//# tavion in force grip choke
+
+	BOTH_CHOKE2,			//# tavion recovering from force grip choke
+	BOTH_CHOKE3,			//# left-handed choke (for people still holding a weapon)
+
+	//# #sep BOTH_ HUNTER-SEEKER BOT-SPECIFIC
+	BOTH_POWERUP1,			//# Wakes up
+
+	BOTH_TURNON,			//# Protocol Droid wakes up
+	BOTH_TURNOFF,			//# Protocol Droid shuts off
+
+	BOTH_BUTTON1,			//# Single button push with right hand
+	BOTH_BUTTON2,			//# Single button push with left finger
+	BOTH_BUTTON_HOLD,		//# Single button hold with left hand
+	BOTH_BUTTON_RELEASE,	//# Single button release with left hand
+
+	//# JEDI-SPECIFIC
+	//# #sep BOTH_ FORCE ANIMS
+	BOTH_RESISTPUSH,		//# plant yourself to resist force push/pulls.
+	BOTH_FORCEPUSH,			//# Use off-hand to do force power.
+	BOTH_FORCEPULL,			//# Use off-hand to do force power.
+	BOTH_MINDTRICK1,			//# Use off-hand to do mind trick
+	BOTH_MINDTRICK2,			//# Use off-hand to do distraction
+	BOTH_FORCELIGHTNING,		//# Use off-hand to do lightning
+	BOTH_FORCELIGHTNING_START,	//# Use off-hand to do lightning - start
+	BOTH_FORCELIGHTNING_HOLD,	//# Use off-hand to do lightning - hold
+	BOTH_FORCELIGHTNING_RELEASE,//# Use off-hand to do lightning - release
+	BOTH_FORCEHEAL_START,		//# Healing meditation pose start
+	BOTH_FORCEHEAL_STOP,		//# Healing meditation pose end
+	BOTH_FORCEHEAL_QUICK,		//# Healing meditation gesture
+	BOTH_SABERPULL,			//# Use off-hand to do force power.
+	BOTH_FORCEGRIP1,		//# force-gripping (no anim?)
+	BOTH_FORCEGRIP3,		//# force-gripping (right hand)
+	BOTH_FORCEGRIP3THROW,	//# throwing while force-gripping (right hand)
+	BOTH_FORCEGRIP_HOLD,	//# Use off-hand to do grip - hold
+	BOTH_FORCEGRIP_RELEASE,//# Use off-hand to do grip - release
+	BOTH_TOSS1,				//# throwing to left after force gripping
+	BOTH_TOSS2,				//# throwing to right after force gripping
+	//NEW force anims for JKA:
+	BOTH_FORCE_RAGE,
+	BOTH_FORCE_2HANDEDLIGHTNING,
+	BOTH_FORCE_2HANDEDLIGHTNING_START,
+	BOTH_FORCE_2HANDEDLIGHTNING_HOLD,
+	BOTH_FORCE_2HANDEDLIGHTNING_RELEASE,
+	BOTH_FORCE_DRAIN,
+	BOTH_FORCE_DRAIN_START,
+	BOTH_FORCE_DRAIN_HOLD,
+	BOTH_FORCE_DRAIN_RELEASE,
+	BOTH_FORCE_DRAIN_GRAB_START,
+	BOTH_FORCE_DRAIN_GRAB_HOLD,
+	BOTH_FORCE_DRAIN_GRAB_END,
+	BOTH_FORCE_DRAIN_GRABBED,
+	BOTH_FORCE_ABSORB,
+	BOTH_FORCE_ABSORB_START,
+	BOTH_FORCE_ABSORB_END,
+	BOTH_FORCE_PROTECT,
+	BOTH_FORCE_PROTECT_FAST,
+
+	BOTH_WIND,
+
+	BOTH_STAND_TO_KNEEL,
+	BOTH_KNEEL_TO_STAND,
+
+	BOTH_TUSKENATTACK1,
+	BOTH_TUSKENATTACK2,
+	BOTH_TUSKENATTACK3,
+	BOTH_TUSKENLUNGE1,
+	BOTH_TUSKENTAUNT1,
+
+	BOTH_COWER1_START,		//# cower start
+	BOTH_COWER1,			//# cower loop
+	BOTH_COWER1_STOP,		//# cower stop
+	BOTH_SONICPAIN_START,
+	BOTH_SONICPAIN_HOLD,
+	BOTH_SONICPAIN_END,
+
+	//new anim slots per Jarrod's request
+	BOTH_STAND10,
+	BOTH_STAND10_TALK1,
+	BOTH_STAND10_TALK2,
+	BOTH_STAND10TOSTAND1,
+
+	BOTH_STAND1_TALK1,
+	BOTH_STAND1_TALK2,
+	BOTH_STAND1_TALK3,
+
+	BOTH_SIT4,
+	BOTH_SIT5,
+	BOTH_SIT5_TALK1,
+	BOTH_SIT5_TALK2,
+	BOTH_SIT5_TALK3,
+
+	BOTH_SIT6,
+	BOTH_SIT7,
+
+	//=================================================
+	//ANIMS IN WHICH ONLY THE UPPER OBJECTS ARE IN MD3
+	//=================================================
+	//# #sep TORSO_ WEAPON-RELATED
+	TORSO_DROPWEAP1,		//# Put weapon away
+	TORSO_DROPWEAP4,		//# Put weapon away
+	TORSO_RAISEWEAP1,		//# Draw Weapon
+	TORSO_RAISEWEAP4,		//# Draw Weapon
+	TORSO_WEAPONREADY1,		//# Ready to fire stun baton
+	TORSO_WEAPONREADY2,		//# Ready to fire one-handed blaster pistol
+	TORSO_WEAPONREADY3,		//# Ready to fire blaster rifle
+	TORSO_WEAPONREADY4,		//# Ready to fire sniper rifle
+	TORSO_WEAPONREADY10,	//# Ready to fire thermal det
+	TORSO_WEAPONIDLE2,		//# Holding one-handed blaster
+	TORSO_WEAPONIDLE3,		//# Holding blaster rifle
+	TORSO_WEAPONIDLE4,		//# Holding sniper rifle
+	TORSO_WEAPONIDLE10,		//# Holding thermal det
+
+	//# #sep TORSO_ MISC
+	TORSO_SURRENDER_START,	//# arms up
+	TORSO_SURRENDER_STOP,	//# arms back down
+
+	TORSO_CHOKING1,			//# TEMP
+
+	TORSO_HANDSIGNAL1,
+	TORSO_HANDSIGNAL2,
+	TORSO_HANDSIGNAL3,
+	TORSO_HANDSIGNAL4,
+	TORSO_HANDSIGNAL5,
+
+
+	//=================================================
+	//ANIMS IN WHICH ONLY THE LOWER OBJECTS ARE IN MD3
+	//=================================================
+	//# #sep Legs-only anims
+	LEGS_TURN1,				//# What legs do when you turn your lower body to match your upper body facing
+	LEGS_TURN2,				//# Leg turning from stand2
+	LEGS_LEAN_LEFT1,		//# Lean left
+	LEGS_LEAN_RIGHT1,		//# Lean Right
+	LEGS_CHOKING1,			//# TEMP
+	LEGS_LEFTUP1,			//# On a slope with left foot 4 higher than right
+	LEGS_LEFTUP2,			//# On a slope with left foot 8 higher than right
+	LEGS_LEFTUP3,			//# On a slope with left foot 12 higher than right
+	LEGS_LEFTUP4,			//# On a slope with left foot 16 higher than right
+	LEGS_LEFTUP5,			//# On a slope with left foot 20 higher than right
+	LEGS_RIGHTUP1,			//# On a slope with RIGHT foot 4 higher than left
+	LEGS_RIGHTUP2,			//# On a slope with RIGHT foot 8 higher than left
+	LEGS_RIGHTUP3,			//# On a slope with RIGHT foot 12 higher than left
+	LEGS_RIGHTUP4,			//# On a slope with RIGHT foot 16 higher than left
+	LEGS_RIGHTUP5,			//# On a slope with RIGHT foot 20 higher than left
+	LEGS_S1_LUP1,
+	LEGS_S1_LUP2,
+	LEGS_S1_LUP3,
+	LEGS_S1_LUP4,
+	LEGS_S1_LUP5,
+	LEGS_S1_RUP1,
+	LEGS_S1_RUP2,
+	LEGS_S1_RUP3,
+	LEGS_S1_RUP4,
+	LEGS_S1_RUP5,
+	LEGS_S3_LUP1,
+	LEGS_S3_LUP2,
+	LEGS_S3_LUP3,
+	LEGS_S3_LUP4,
+	LEGS_S3_LUP5,
+	LEGS_S3_RUP1,
+	LEGS_S3_RUP2,
+	LEGS_S3_RUP3,
+	LEGS_S3_RUP4,
+	LEGS_S3_RUP5,
+	LEGS_S4_LUP1,
+	LEGS_S4_LUP2,
+	LEGS_S4_LUP3,
+	LEGS_S4_LUP4,
+	LEGS_S4_LUP5,
+	LEGS_S4_RUP1,
+	LEGS_S4_RUP2,
+	LEGS_S4_RUP3,
+	LEGS_S4_RUP4,
+	LEGS_S4_RUP5,
+	LEGS_S5_LUP1,
+	LEGS_S5_LUP2,
+	LEGS_S5_LUP3,
+	LEGS_S5_LUP4,
+	LEGS_S5_LUP5,
+	LEGS_S5_RUP1,
+	LEGS_S5_RUP2,
+	LEGS_S5_RUP3,
+	LEGS_S5_RUP4,
+	LEGS_S5_RUP5,
+	LEGS_S6_LUP1,
+	LEGS_S6_LUP2,
+	LEGS_S6_LUP3,
+	LEGS_S6_LUP4,
+	LEGS_S6_LUP5,
+	LEGS_S6_RUP1,
+	LEGS_S6_RUP2,
+	LEGS_S6_RUP3,
+	LEGS_S6_RUP4,
+	LEGS_S6_RUP5,
+	LEGS_S7_LUP1,
+	LEGS_S7_LUP2,
+	LEGS_S7_LUP3,
+	LEGS_S7_LUP4,
+	LEGS_S7_LUP5,
+	LEGS_S7_RUP1,
+	LEGS_S7_RUP2,
+	LEGS_S7_RUP3,
+	LEGS_S7_RUP4,
+	LEGS_S7_RUP5,
+
+	//New anim as per Jarrod's request
+	LEGS_TURN180,
+
+	//======================================================
+	//cinematic anims
+	//======================================================
+	//# #sep BOTH_ CINEMATIC-ONLY
+	BOTH_CIN_1,		//# Level specific cinematic 1
+	BOTH_CIN_2,		//# Level specific cinematic 2
+	BOTH_CIN_3,		//# Level specific cinematic 3
+	BOTH_CIN_4,		//# Level specific cinematic 4
+	BOTH_CIN_5,		//# Level specific cinematic 5
+	BOTH_CIN_6,		//# Level specific cinematic 6
+	BOTH_CIN_7,		//# Level specific cinematic 7
+	BOTH_CIN_8,		//# Level specific cinematic 8
+	BOTH_CIN_9,		//# Level specific cinematic 9
+	BOTH_CIN_10,		//# Level specific cinematic 10
+	BOTH_CIN_11,		//# Level specific cinematic 11
+	BOTH_CIN_12,		//# Level specific cinematic 12
+	BOTH_CIN_13,		//# Level specific cinematic 13
+	BOTH_CIN_14,		//# Level specific cinematic 14
+	BOTH_CIN_15,		//# Level specific cinematic 15
+	BOTH_CIN_16,		//# Level specific cinematic 16
+	BOTH_CIN_17,		//# Level specific cinematic 17
+	BOTH_CIN_18,		//# Level specific cinematic 18
+	BOTH_CIN_19,		//# Level specific cinematic 19
+	BOTH_CIN_20,		//# Level specific cinematic 20
+	BOTH_CIN_21,		//# Level specific cinematic 21
+	BOTH_CIN_22,		//# Level specific cinematic 22
+	BOTH_CIN_23,		//# Level specific cinematic 23
+	BOTH_CIN_24,		//# Level specific cinematic 24
+	BOTH_CIN_25,		//# Level specific cinematic 25
+	BOTH_CIN_26,		//# Level specific cinematic 
+	BOTH_CIN_27,		//# Level specific cinematic 
+	BOTH_CIN_28,		//# Level specific cinematic 
+	BOTH_CIN_29,		//# Level specific cinematic 
+	BOTH_CIN_30,		//# Level specific cinematic 
+	BOTH_CIN_31,		//# Level specific cinematic 
+	BOTH_CIN_32,		//# Level specific cinematic 
+	BOTH_CIN_33,		//# Level specific cinematic 
+	BOTH_CIN_34,		//# Level specific cinematic 
+	BOTH_CIN_35,		//# Level specific cinematic 
+	BOTH_CIN_36,		//# Level specific cinematic 
+	BOTH_CIN_37,		//# Level specific cinematic 
+	BOTH_CIN_38,		//# Level specific cinematic 
+	BOTH_CIN_39,		//# Level specific cinematic 
+	BOTH_CIN_40,		//# Level specific cinematic 
+	BOTH_CIN_41,		//# Level specific cinematic 
+	BOTH_CIN_42,		//# Level specific cinematic 
+	BOTH_CIN_43,		//# Level specific cinematic 
+	BOTH_CIN_44,		//# Level specific cinematic 
+	BOTH_CIN_45,		//# Level specific cinematic 
+	BOTH_CIN_46,		//# Level specific cinematic 
+	BOTH_CIN_47,		//# Level specific cinematic 
+	BOTH_CIN_48,		//# Level specific cinematic 
+	BOTH_CIN_49,		//# Level specific cinematic 
+	BOTH_CIN_50,		//# Level specific cinematic
+
+	//# #eol
+	MAX_ANIMATIONS,
+	MAX_TOTALANIMATIONS,
+} animNumber_t;
+
+#define SABER_ANIM_GROUP_SIZE (BOTH_A2_T__B_ - BOTH_A1_T__B_)
+
+
+#endif// #ifndef __ANIMS_H__
+
diff --git a/code/game/b_local.h b/code/game/b_local.h
new file mode 100644
index 0000000..4adec3b
--- /dev/null
+++ b/code/game/b_local.h
@@ -0,0 +1,353 @@
+//B_local.h
+//re-added by MCG
+#ifndef __B_LOCAL_H__
+#define __B_LOCAL_H__
+
+#include "g_local.h"
+#include "say.h"
+
+#include "AI.h"
+
+#define	AI_TIMERS 0//turn on to see print-outs of AI/nav timing
+//
+// Navigation susbsystem
+//
+
+#define NAVF_DUCK			0x00000001
+#define NAVF_JUMP			0x00000002
+#define NAVF_HOLD			0x00000004
+#define NAVF_SLOW			0x00000008
+
+#define DEBUG_LEVEL_DETAIL	4
+#define DEBUG_LEVEL_INFO	3
+#define DEBUG_LEVEL_WARNING	2
+#define DEBUG_LEVEL_ERROR	1
+#define DEBUG_LEVEL_NONE	0
+
+#define MAX_GOAL_REACHED_DIST_SQUARED	256//16 squared
+#define MIN_ANGLE_ERROR 0.01f
+
+#define MIN_ROCKET_DIST_SQUARED 16384//128*128
+//
+// NPC.cpp
+//
+// ai debug cvars
+void SetNPCGlobals( gentity_t *ent );
+void SaveNPCGlobals();
+void RestoreNPCGlobals();
+extern cvar_t		*debugNPCAI;			// used to print out debug info about the NPC AI
+extern cvar_t		*debugNPCFreeze;		// set to disable NPC ai and temporarily freeze them in place
+extern cvar_t		*debugNPCName;
+extern cvar_t		*d_JediAI;
+extern cvar_t		*d_saberCombat;
+extern void NPC_Think ( gentity_t *self);
+extern void pitch_roll_for_slope( gentity_t *forwhom, vec3_t pass_slope = NULL, vec3_t storeAngles = NULL );
+
+//NPC_reactions.cpp
+extern void NPC_Pain( gentity_t *self, gentity_t *inflictor, gentity_t *attacker, vec3_t point, int damage, int mod ,int hitLoc);
+extern void NPC_Touch( gentity_t *self, gentity_t *other, trace_t *trace );
+extern void NPC_Use( gentity_t *self, gentity_t *other, gentity_t *activator );
+extern float NPC_GetPainChance( gentity_t *self, int damage );
+
+//
+// NPC_misc.cpp
+//
+extern void Debug_Printf( cvar_t *cv, int level, char *fmt, ... );
+extern void Debug_NPCPrintf( gentity_t *printNPC, cvar_t *cv, int debugLevel, char *fmt, ... );
+
+//MCG - Begin============================================================
+//NPC_ai variables - shared by NPC.cpp andf the following modules
+extern gentity_t	*NPC;
+extern gNPC_t		*NPCInfo;
+extern gclient_t	*client;
+extern usercmd_t	ucmd;
+extern visibility_t	enemyVisibility;
+
+//AI_Default
+extern qboolean NPC_CheckInvestigate( int alertEventNum );
+extern qboolean NPC_StandTrackAndShoot (gentity_t *NPC);
+extern void NPC_BSIdle( void );
+extern void NPC_BSPointShoot(qboolean shoot);
+extern void NPC_BSStandGuard (void);
+extern void NPC_BSPatrol (void);
+extern void NPC_BSHuntAndKill (void);
+extern void NPC_BSStandAndShoot (void);
+extern void NPC_BSRunAndShoot (void);
+extern void NPC_BSWait( void );
+extern void NPC_BSDefault( void );
+
+//NPC_behavior
+extern void NPC_BSAdvanceFight (void);
+extern void NPC_BSInvestigate (void);
+extern void NPC_BSSleep( void );
+extern void NPC_BSFollowLeader (void);
+extern void NPC_BSJump (void);
+extern void NPC_BSRemove (void);
+extern void NPC_BSSearch (void);
+extern void NPC_BSSearchStart (int	homeWp, bState_t bState);
+extern void NPC_BSWander (void);
+extern qboolean NPC_BSFlee( void );
+extern void NPC_StartFlee( gentity_t *enemy, vec3_t dangerPoint, int dangerLevel, int fleeTimeMin, int fleeTimeMax );
+extern void G_StartFlee( gentity_t *self, gentity_t *enemy, vec3_t dangerPoint, int dangerLevel, int fleeTimeMin, int fleeTimeMax );
+
+//NPC_combat
+extern int ChooseBestWeapon( void );
+extern void NPC_ChangeWeapon( int newWeapon );
+extern void ShootThink( void );
+extern void WeaponThink( qboolean inCombat );
+extern qboolean HaveWeapon( int weapon );
+extern qboolean CanShoot ( gentity_t *ent, gentity_t *shooter );
+extern void NPC_CheckPossibleEnemy( gentity_t *other, visibility_t vis );
+extern gentity_t *NPC_PickEnemy (gentity_t *closestTo, int enemyTeam, qboolean checkVis, qboolean findPlayersFirst, qboolean findClosest);
+extern gentity_t *NPC_CheckEnemy (qboolean findNew, qboolean tooFarOk, qboolean setEnemy = qtrue );
+extern qboolean NPC_CheckAttack (float scale);
+extern qboolean NPC_CheckDefend (float scale);
+extern qboolean NPC_CheckCanAttack (float attack_scale, qboolean stationary);
+extern int NPC_AttackDebounceForWeapon (void);
+extern qboolean EntIsGlass (gentity_t *check);
+extern qboolean ShotThroughGlass (trace_t *tr, gentity_t *target, vec3_t spot, int mask);
+extern void G_ClearEnemy (gentity_t *self);
+extern void G_SetEnemy (gentity_t *self, gentity_t *enemy);
+extern gentity_t *NPC_PickAlly ( qboolean facingEachOther, float range, qboolean ignoreGroup, qboolean movingOnly );
+extern void NPC_LostEnemyDecideChase(void);
+extern float NPC_MaxDistSquaredForWeapon( void );
+extern qboolean NPC_EvaluateShot( int hit, qboolean glassOK );
+extern int NPC_ShotEntity( gentity_t *ent, vec3_t impactPos = NULL );
+
+//NPC_formation
+extern qboolean NPC_SlideMoveToGoal (void);
+extern float NPC_FindClosestTeammate (gentity_t *self);
+extern void NPC_CalcClosestFormationSpot(gentity_t *self);
+extern void G_MaintainFormations (gentity_t *self);
+extern void NPC_BSFormation (void);
+extern void NPC_CreateFormation (gentity_t *self);
+extern void NPC_DropFormation (gentity_t *self);
+extern void NPC_ReorderFormation (gentity_t *self);
+extern void NPC_InsertIntoFormation (gentity_t *self);
+extern void NPC_DeleteFromFormation (gentity_t *self);
+
+#define COLLISION_RADIUS 32
+#define NUM_POSITIONS 30
+
+//NPC spawnflags
+#define SFB_SMALLHULL	1
+
+#define SFB_RIFLEMAN	2
+#define SFB_OLDBORG		2//Borg
+#define SFB_PHASER		4
+#define SFB_GUN			4//Borg
+#define	SFB_TRICORDER	8
+#define	SFB_TASER		8//Borg
+#define	SFB_DRILL		16//Borg
+
+#define	SFB_CINEMATIC	32
+#define	SFB_NOTSOLID	64
+#define	SFB_STARTINSOLID 128
+
+#define SFB_TROOPERAI	(1<<9)
+
+//NPC_goal
+extern void SetGoal( gentity_t *goal, float rating );
+extern void NPC_SetGoal( gentity_t *goal, float rating );
+extern void NPC_ClearGoal( void );
+extern void NPC_ReachedGoal( void );
+extern qboolean ReachedGoal( gentity_t *goal );
+extern gentity_t *UpdateGoal( void );
+extern qboolean NPC_MoveToGoal( qboolean tryStraight );
+
+//NPC_move
+qboolean NPC_Jumping( void );
+qboolean NPC_JumpBackingUp( void );
+
+qboolean NPC_TryJump( gentity_t *goal,	float max_xy_dist = 0.0f, float max_z_diff = 0.0f );
+qboolean NPC_TryJump( const vec3_t& pos,float max_xy_dist = 0.0f, float max_z_diff = 0.0f );
+
+//NPC_reactions
+
+//NPC_senses
+#define	ALERT_CLEAR_TIME	200
+#define CHECK_PVS		1
+#define CHECK_360		2
+#define CHECK_FOV		4
+#define CHECK_SHOOT		8
+#define CHECK_VISRANGE	16
+extern qboolean CanSee ( gentity_t *ent );
+extern qboolean InFOV ( gentity_t *ent, gentity_t *from, int hFOV, int vFOV );
+extern qboolean InFOV( vec3_t origin, gentity_t *from, int hFOV, int vFOV );
+extern qboolean InFOV( vec3_t spot, vec3_t from, vec3_t fromAngles, int hFOV, int vFOV );
+extern visibility_t NPC_CheckVisibility ( gentity_t *ent, int flags );
+extern qboolean InVisrange ( gentity_t *ent );
+
+//NPC_sounds
+//extern void NPC_AngerSound(void);
+
+//NPC_spawn
+extern void NPC_Spawn( gentity_t *self );
+
+//NPC_stats
+extern int NPC_ReactionTime ( void );
+extern qboolean NPC_ParseParms( const char *NPCName, gentity_t *NPC );
+extern void NPC_LoadParms( void );
+
+//NPC_utils
+extern int	teamNumbers[TEAM_NUM_TEAMS];
+extern int	teamStrength[TEAM_NUM_TEAMS];
+extern int	teamCounter[TEAM_NUM_TEAMS];
+extern void CalcEntitySpot ( const gentity_t *ent, const spot_t spot, vec3_t point );
+extern qboolean NPC_UpdateAngles ( qboolean doPitch, qboolean doYaw );
+extern void NPC_UpdateShootAngles (vec3_t angles, qboolean doPitch, qboolean doYaw );
+extern qboolean NPC_UpdateFiringAngles ( qboolean doPitch, qboolean doYaw );
+extern void SetTeamNumbers (void);
+extern qboolean G_ActivateBehavior (gentity_t *self, int bset );
+extern void NPC_AimWiggle( vec3_t enemy_org );
+extern void NPC_SetLookTarget( gentity_t *self, int entNum, int clearTime );
+
+
+//other modules
+extern void CalcMuzzlePoint ( gentity_t *const ent, vec3_t forward, vec3_t right, vec3_t up, vec3_t muzzlePoint, float lead_in );
+
+//g_combat
+extern void ExplodeDeath( gentity_t *self );
+extern void ExplodeDeath_Wait( gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int meansOfDeath,int dFlags,int hitLoc );
+extern void GoExplodeDeath( gentity_t *self, gentity_t *other, gentity_t *activator);
+extern float IdealDistance ( gentity_t *self );
+
+//g_client
+extern qboolean SpotWouldTelefrag( gentity_t *spot, team_t checkteam );
+
+//g_squad
+extern void NPC_SetSayState (gentity_t *self, gentity_t *to, int saying);
+
+//g_utils
+extern qboolean G_CheckInSolid (gentity_t *self, qboolean fix);
+extern qboolean infront(gentity_t *from, gentity_t *to);
+
+//MCG - End============================================================
+
+// NPC.cpp
+extern void NPC_SetAnim(gentity_t	*ent,int setAnimParts,int anim,int setAnimFlags, int iBlend = SETANIM_BLEND_DEFAULT);
+extern qboolean NPC_EnemyTooFar(gentity_t *enemy, float dist, qboolean toShoot);
+
+// ==================================================================
+
+inline qboolean NPC_ClearLOS( const vec3_t start, const vec3_t end )
+{
+	return G_ClearLOS( NPC, start, end );
+}
+inline qboolean NPC_ClearLOS( const vec3_t end )
+{
+	return G_ClearLOS( NPC, end );
+}
+inline qboolean NPC_ClearLOS( gentity_t *ent ) 
+{
+	return G_ClearLOS( NPC, ent );
+}
+inline qboolean NPC_ClearLOS( const vec3_t start, gentity_t *ent )
+{
+	return G_ClearLOS( NPC, start, ent );
+}
+inline qboolean NPC_ClearLOS( gentity_t *ent, const vec3_t end )
+{
+	return G_ClearLOS( NPC, ent, end );
+}
+
+extern qboolean NPC_ClearShot( gentity_t *ent );
+
+extern int NPC_FindCombatPoint( const vec3_t position, const vec3_t avoidPosition, vec3_t enemyPosition, const int flags, const float avoidDist, const int ignorePoint = -1 );
+extern int NPC_FindCombatPointRetry( const vec3_t position, 
+							 const vec3_t avoidPosition, 
+							 vec3_t enemyPosition, 
+							 int *cpFlags, 
+							 float avoidDist, 
+							 const int ignorePoint );
+
+
+extern qboolean NPC_ReserveCombatPoint( int combatPointID );
+extern qboolean NPC_FreeCombatPoint( int combatPointID, qboolean failed = qfalse );
+extern qboolean NPC_SetCombatPoint( int combatPointID );
+
+#define	CP_ANY			0			//No flags
+#define	CP_COVER		0x00000001	//The enemy cannot currently shoot this position
+#define CP_CLEAR		0x00000002	//This cover point has a clear shot to the enemy
+#define CP_FLEE			0x00000004	//This cover point is marked as a flee point
+#define CP_DUCK			0x00000008	//This cover point is marked as a duck point
+#define CP_NEAREST		0x00000010	//Find the nearest combat point
+#define CP_AVOID_ENEMY	0x00000020	//Avoid our enemy
+#define CP_INVESTIGATE	0x00000040	//A special point worth enemy investigation if searching
+#define	CP_SQUAD		0x00000080	//Squad path
+#define	CP_AVOID		0x00000100	//Avoid supplied position
+#define	CP_APPROACH_ENEMY 0x00000200	//Try to get closer to enemy
+#define	CP_CLOSEST		0x00000400	//Take the closest combatPoint to the enemy that's available
+#define	CP_FLANK		0x00000800	//Pick a combatPoint behind the enemy
+#define	CP_HAS_ROUTE	0x00001000	//Pick a combatPoint that we have a route to
+#define	CP_SNIPE		0x00002000	//Pick a combatPoint that is marked as a sniper spot
+#define	CP_SAFE			0x00004000	//Pick a combatPoint that is not have dangerTime
+#define	CP_HORZ_DIST_COLL 0x00008000	//Collect combat points within *horizontal* dist
+#define	CP_NO_PVS		0x00010000	//A combat point out of the PVS of enemy pos
+#define	CP_RETREAT	 	0x00020000	//Try to get farther from enemy
+#define CP_SHORTEST_PATH 0x0004000	//Shortest path from me to combat point to enemy
+#define CP_TRYFAR		0x00080000
+
+#define CPF_NONE		0
+#define	CPF_DUCK		0x00000001
+#define	CPF_FLEE		0x00000002
+#define	CPF_INVESTIGATE	0x00000004
+#define	CPF_SQUAD		0x00000008
+#define	CPF_LEAN		0x00000010
+#define	CPF_SNIPE		0x00000020
+
+#define	MAX_COMBAT_POINT_CHECK	32
+
+extern int NPC_ValidEnemy( gentity_t *ent );
+extern int NPC_CheckEnemyExt( qboolean checkAlerts = qfalse );
+extern qboolean NPC_FindPlayer( void );
+extern qboolean NPC_CheckCanAttackExt( void );
+
+extern int NPC_CheckAlertEvents( qboolean checkSight, qboolean checkSound, int ignoreAlert = -1, qboolean mustHaveOwner = qfalse, int minAlertLevel = AEL_MINOR, qboolean onGroundOnly = qfalse );
+extern qboolean NPC_CheckForDanger( int alertEvent );
+extern void G_AlertTeam( gentity_t *victim, gentity_t *attacker, float radius, float soundDist );
+
+extern int NPC_FindSquadPoint( vec3_t position );
+
+extern void ClearPlayerAlertEvents( void );
+
+extern qboolean G_BoundsOverlap(const vec3_t mins1, const vec3_t maxs1, const vec3_t mins2, const vec3_t maxs2);
+
+extern void NPC_SetMoveGoal( gentity_t *ent, vec3_t point, int radius, qboolean isNavGoal = qfalse, int combatPoint = -1, gentity_t *targetEnt = NULL );
+
+extern void NPC_ApplyWeaponFireDelay(void);
+
+//NPC_FaceXXX suite
+extern qboolean NPC_FacePosition( vec3_t position, qboolean doPitch = qtrue );
+extern qboolean NPC_FaceEntity( gentity_t *ent, qboolean doPitch = qtrue );
+extern qboolean NPC_FaceEnemy( qboolean doPitch = qtrue );
+
+//Skill level cvar
+extern cvar_t	*g_spskill;
+
+#define	NIF_NONE		0x00000000
+#define	NIF_FAILED		0x00000001	//failed to find a way to the goal
+#define	NIF_MACRO_NAV	0x00000002	//using macro navigation
+#define	NIF_COLLISION	0x00000004	//resolving collision with an entity
+#define NIF_BLOCKED		0x00000008	//blocked from moving
+
+/*
+-------------------------
+struct navInfo_s
+-------------------------
+*/
+
+typedef struct navInfo_s
+{
+	gentity_t	*blocker;
+	vec3_t		direction;
+	vec3_t		pathDirection;
+	float		distance;
+	trace_t		trace;
+	int			flags;
+} navInfo_t;
+
+
+
+
+#endif
diff --git a/code/game/b_public.h b/code/game/b_public.h
new file mode 100644
index 0000000..cbaad9c
--- /dev/null
+++ b/code/game/b_public.h
@@ -0,0 +1,401 @@
+#ifndef __B_PUBLIC_H__
+#define __B_PUBLIC_H__
+
+#include "bstate.h"
+#include "AI.h"
+
+#define NPCAI_CHECK_WEAPON		0x00000001
+#define NPCAI_BURST_WEAPON		0x00000002
+#define NPCAI_MOVING			0x00000004
+#define NPCAI_TOUCHED_GOAL		0x00000008
+#define NPCAI_PUSHED			0x00000010
+#define NPCAI_NO_COLL_AVOID		0x00000020
+#define NPCAI_BLOCKED			0x00000040
+#define NPCAI_SUBBOSS_CHARACTER	0x00000080	//Alora, tough reborn
+#define NPCAI_OFF_PATH			0x00000100
+#define NPCAI_IN_SQUADPOINT		0x00000200
+#define NPCAI_STRAIGHT_TO_DESTPOS	0x00000400
+#define NPCAI_HEAVY_MELEE		0x00000800	//4x melee damage, dismemberment
+#define NPCAI_NO_SLOWDOWN		0x00001000
+#define NPCAI_LOST				0x00002000	//Can't nav to his goal
+#define NPCAI_SHIELDS			0x00004000	//Has shields, borg can adapt
+#define NPCAI_GREET_ALLIES		0x00008000	//Say hi to nearby allies
+#define NPCAI_FORM_TELE_NAV		0x00010000	//Tells formation people to use nav info to get to 
+#define NPCAI_ENROUTE_TO_HOMEWP 0x00020000	//Lets us know to run our lostenemyscript when we get to homeWp
+#define NPCAI_MATCHPLAYERWEAPON 0x00040000	//Match the player's weapon except when it changes during cinematics
+#define NPCAI_DIE_ON_IMPACT		0x00100000	//Next time you crashland, die!
+#define NPCAI_WALKING			0x00200000
+#define NPCAI_STOP_AT_LOS		0x00400000	//Stop Running When We Hit LOS
+#define NPCAI_NAV_THROUGH_BREAKABLES	0x00800000	//Navigation allows connections through breakable (func_glass, func_breakable or misc_model_breakable)
+#define NPCAI_KNEEL				0x01000000  //Kneel befor Zod
+#define NPCAI_FLY				0x02000000	//Fly, My Pretty!
+#define NPCAI_FLAMETHROW		0x04000000
+#define NPCAI_ROSH				0x08000000	//I am Rosh, when I'm hurt, drop to one knee and wait for Vil or Dasariah to heal me
+#define NPCAI_HEAL_ROSH			0x10000000	//Constantly look for NPC with NPC_type of rosh_dark, follow him, heal him if needbe
+#define NPCAI_JUMP				0x20000000	//Jump Now
+#define NPCAI_BOSS_CHARACTER	0x40000000	//Boss NPC flag for certain immunities/defenses
+#define NPCAI_NO_JEDI_DELAY		0x80000000	//Reborn/Jedi don't taunt enemy before attacking
+
+//Script flags
+#define	SCF_CROUCHED		0x00000001	//Force ucmd.upmove to be -127
+#define	SCF_WALKING			0x00000002	//Force BUTTON_WALKING to be pressed
+#define	SCF_MORELIGHT		0x00000004	//NPC will have a minlight of 96
+#define	SCF_LEAN_RIGHT		0x00000008	//Force rightmove+BUTTON_USE
+#define	SCF_LEAN_LEFT		0x00000010	//Force leftmove+BUTTON_USE
+#define	SCF_RUNNING			0x00000020	//Takes off walking button, overrides SCF_WALKING
+#define	SCF_ALT_FIRE		0x00000040	//Force to use alt-fire when firing
+#define	SCF_NO_RESPONSE		0x00000080	//NPC will not do generic responses to being used
+#define	SCF_FFDEATH			0x00000100	//Just tells player_die to run the friendly fire deathscript
+#define	SCF_NO_COMBAT_TALK	0x00000200	//NPC will not use their generic combat chatter stuff
+#define	SCF_CHASE_ENEMIES	0x00000400	//NPC chase enemies - FIXME: right now this is synonymous with using combat points... should it be?
+#define	SCF_LOOK_FOR_ENEMIES	0x00000800	//NPC be on the lookout for enemies
+#define	SCF_FACE_MOVE_DIR	0x00001000	//NPC face direction it's moving - FIXME: not really implemented right now
+#define	SCF_IGNORE_ALERTS	0x00002000	//NPC ignore alert events
+#define SCF_DONT_FIRE		0x00004000	//NPC won't shoot
+#define	SCF_DONT_FLEE		0x00008000	//NPC never flees
+#define	SCF_FORCED_MARCH	0x00010000	//NPC that the player must aim at to make him walk
+#define	SCF_NO_GROUPS		0x00020000	//NPC cannot alert groups or be part of a group
+#define	SCF_FIRE_WEAPON		0x00040000	//NPC will fire his (her) weapon
+#define	SCF_NO_MIND_TRICK	0x00080000	//Not succeptible to mind tricks
+#define	SCF_USE_CP_NEAREST	0x00100000	//Will use combat point close to it, not next to player or try and flank player
+#define	SCF_NO_FORCE		0x00200000	//Not succeptible to force powers
+#define	SCF_NO_FALLTODEATH	0x00400000	//NPC will not scream and tumble and fall to hit death over large drops
+#define	SCF_NO_ACROBATICS	0x00800000	//Jedi won't jump, roll or cartwheel
+#define	SCF_USE_SUBTITLES	0x01000000	//Regardless of subtitle setting, this NPC will display subtitles when it speaks lines
+#define	SCF_NO_ALERT_TALK	0x02000000	//Will not say alert sounds, but still can be woken up by alerts
+#define SCF_NAV_CAN_FLY		0x04000000	//Navigation allows connections through air
+#define SCF_FLY_WITH_JET	0x08000000	//Must Fly With A Jet
+#define	SCF_PILOT			0x10000000	//Can pilot a vehicle
+#define	SCF_NAV_CAN_JUMP	0x20000000	//Can attempt to jump when blocked
+#define	SCF_FIRE_WEAPON_NO_ANIM	0x40000000	//Fire weapon but don't play weapon firing anim
+#define	SCF_SAFE_REMOVE		0x80000000	//Remove NPC when it's safe (when player isn't looking)
+
+
+//#ifdef __DEBUG
+
+//Debug flag definitions
+
+#define	AID_IDLE		0x00000000	//Nothing is happening
+#define AID_ACQUIRED	0x00000001	//A target has been found
+#define AID_LOST		0x00000002	//Alert, but no target is in sight
+#define AID_CONFUSED	0x00000004	//Is unable to come up with a course of action
+#define AID_LOSTPATH	0x00000008	//Cannot make a valid movement due to lack of connections
+
+//#endif //__DEBUG
+
+//extern qboolean showWaypoints;
+
+typedef enum {VIS_UNKNOWN, VIS_NOT, VIS_PVS, VIS_360, VIS_FOV, VIS_SHOOT} visibility_t;
+typedef enum {SPOT_ORIGIN, SPOT_CHEST, SPOT_HEAD, SPOT_HEAD_LEAN, SPOT_WEAPON, SPOT_LEGS, SPOT_GROUND} spot_t;
+
+typedef enum //# lookMode_e
+{
+	LM_ENT = 0,
+	LM_INTEREST
+} lookMode_t;
+
+typedef enum //# jumpState_e
+{
+	JS_WAITING = 0,
+	JS_FACING,
+	JS_CROUCHING,
+	JS_JUMPING,
+	JS_LANDING
+} jumpState_t;
+
+typedef enum
+{
+	SEX_NEUTRAL = 0,
+	SEX_MALE,
+	SEX_FEMALE,
+	SEX_SHEMALE//what the Hell, ya never know...
+} sexType_t;
+
+// !!!!!!!!!! LOADSAVE-affecting structure !!!!!!!!!!
+typedef struct gNPCstats_e
+{//Stats, loaded in, and can be set by scripts
+	//AI
+	int		aggression;			//			"
+	int		aim;				//			"
+	float	earshot;			//			"
+	int		evasion;			//			"
+	int		hfov;				// horizontal field of view
+	int		intelligence;		//			"
+	int		move;				//			"
+	int		reactions;			// 1-5, higher is better
+	float	shootDistance;		//Maximum range- overrides range set for weapon if nonzero
+	int		vfov;				// vertical field of view
+	float	vigilance;			//			"
+	float	visrange;			//			"
+	//Movement
+	int		runSpeed;
+	int		walkSpeed;
+	float	yawSpeed;			// 1 - whatever, default is 50
+	int		health;
+	int		acceleration;
+	//sex
+	sexType_t	sex;			//male, female, etc.
+} gNPCstats_t;
+
+
+#define	MAX_ENEMY_POS_LAG	2400
+#define	ENEMY_POS_LAG_INTERVAL	100
+#define	ENEMY_POS_LAG_STEPS	(MAX_ENEMY_POS_LAG/ENEMY_POS_LAG_INTERVAL)
+
+// !!!!!!!!!! LOADSAVE-affecting structure !!!!!!!!!!
+typedef struct 
+{
+	//FIXME: Put in playerInfo or something
+	int			timeOfDeath;			//FIXME do we really need both of these
+	gentity_t	*touchedByPlayer;
+
+	visibility_t	enemyLastVisibility;
+
+	int			aimTime;
+	float		desiredYaw;
+	float		desiredPitch;
+	float		lockedDesiredYaw;
+	float		lockedDesiredPitch;
+	gentity_t	*aimingBeam;		// debugging aid
+
+	vec3_t		enemyLastSeenLocation;
+	int			enemyLastSeenTime;
+	vec3_t		enemyLastHeardLocation;
+	int			enemyLastHeardTime;
+	int			lastAlertID;		//unique ID
+
+	int			eFlags;
+	int			aiFlags;
+
+	int			currentAmmo;		// this sucks, need to find a better way
+	int			shotTime;
+	int			burstCount;
+	int			burstMin;
+	int			burstMean;
+	int			burstMax;
+	int			burstSpacing;
+	int			attackHold;
+	int			attackHoldTime;
+	vec3_t		shootAngles;		//Angles to where bot is shooting - fixme: make he torso turn to reflect these
+
+	//extra character info
+	rank_t		rank;		//for pips
+
+	//Behavior state info
+	bState_t	behaviorState;	//determines what actions he should be doing
+	bState_t	defaultBehavior;//State bot will default to if none other set
+	bState_t	tempBehavior;//While valid, overrides other behavior
+
+	qboolean	ignorePain;		//only play pain scripts when take pain
+
+	int			duckDebounceTime;//Keeps them ducked for a certain time
+	int			walkDebounceTime;
+	int			enemyCheckDebounceTime;
+	int			investigateDebounceTime;
+	int			investigateCount;
+	vec3_t		investigateGoal;
+	int			investigateSoundDebounceTime;
+	int			greetingDebounceTime;//when we can greet someone next
+	gentity_t	*eventOwner;
+	
+	//bState-specific fields
+	gentity_t	*coverTarg;
+	jumpState_t	jumpState;
+	float		followDist;
+
+	// goal, navigation & pathfinding
+	gentity_t	*tempGoal;			// used for locational goals (player's last seen/heard position)
+	gentity_t	*goalEntity;
+	gentity_t	*lastGoalEntity;
+	gentity_t	*eventualGoal;
+	gentity_t	*captureGoal;		//Where we should try to capture
+	gentity_t	*defendEnt;			//Who we're trying to protect
+	gentity_t	*greetEnt;			//Who we're greeting
+	int			goalTime;	//FIXME: This is never actually used
+	qboolean	straightToGoal;	//move straight at navgoals
+	float		distToGoal;
+	int			navTime;
+	int			blockingEntNum;
+	int			blockedSpeechDebounceTime;
+
+	int			homeWp;
+	int			avoidSide;
+	int			leaderAvoidSide;
+	int			lastAvoidSteerSide;
+	int			lastAvoidSteerSideDebouncer;
+	AIGroupInfo_t	*group;
+	int			troop;
+
+	vec3_t		lastPathAngles;		//So we know which way to face generally when we stop
+
+	//stats
+	gNPCstats_t	stats;
+	int			aimErrorDebounceTime;
+	float		lastAimErrorYaw;
+	float		lastAimErrorPitch;
+	vec3_t		aimOfs;
+	int			currentAim;
+	int			currentAggression;
+
+	//scriptflags
+	int			scriptFlags;//in b_local.h
+
+	//moveInfo
+	int			desiredSpeed;
+	int			currentSpeed;
+	char		last_forwardmove;
+	char		last_rightmove;
+	vec3_t		lastClearOrigin;
+	int			shoveCount;
+
+	int			blockedDebounceTime;
+	gentity_t*	blockedEntity;				// The entity That Causes The Current Blockage
+
+	vec3_t		blockedTargetPosition;		// Where the actor was trying to get TO before blocked
+	gentity_t*	blockedTargetEntity;		// Where the actor was trying to get TO before blocked
+
+
+	//jump info
+	vec3_t		jumpDest;					// Where The Actor Is Trying To Jump TO
+	gentity_t*	jumpTarget;					// What Entity The Actor Is Trying To Jump TO
+	float		jumpMaxXYDist;				// The Minimal Delta On The XY Plane Allowed To Jump To The Dest
+	float		jumpMazZDist;
+	int			jumpSide;					// Which Side The Last Jump Occured On
+	int			jumpTime;					// When The Last Jump Started
+	int			jumpBackupTime;				// If Active, Then The Guy Should Backup Before Jumping
+	int			jumpNextCheckTime;			// The Minimal Next Time To Check For A Jump
+
+	//
+	int			combatPoint;//NPCs in bState BS_COMBAT_POINT will find their closest empty combat_point
+	int			lastFailedCombatPoint;//NPCs in bState BS_COMBAT_POINT will find their closest empty combat_point
+	int			movementSpeech;	//what to say when you first successfully move
+	float		movementSpeechChance;//how likely you are to say it
+
+	//Testing physics at 20fps
+	int			nextBStateThink;
+	usercmd_t	last_ucmd;
+
+	//
+	//JWEIER ADDITIONS START
+
+	qboolean	combatMove;
+	int			goalRadius;
+
+	//FIXME: These may be redundant
+	
+	/*
+	int			weaponTime;		//Time until refire is valid
+	int			jumpTime;
+	*/
+	int			pauseTime;		//Time to stand still
+	int			standTime;
+
+	int			localState;		//Tracking information local to entity
+	int			squadState;		//Tracking information for team level interaction
+
+	//JWEIER ADDITIONS END
+	//
+
+	int			confusionTime;	//Doesn't respond to alerts or pick up enemies (unless shot) until this time is up
+	int			charmedTime;	//charmed to enemy team
+	int			controlledTime;	//controlled by player
+	int			surrenderTime;	//Hands up
+	int			kneelTime;		//kneeling (for troopers)
+
+	//Lagging enemy position - FIXME: seems awful wasteful...
+	vec3_t		enemyLaggedPos[ENEMY_POS_LAG_STEPS];
+
+	gentity_t	*watchTarget;	//for BS_CINEMATIC, keeps facing this ent
+
+	int			ffireCount;		//sigh... you'd think I'd be able to find a way to do this without having to use 3 int fields, but...
+	int			ffireDebounce;	
+	int			ffireFadeDebounce;
+} gNPC_t;
+
+void G_SquadPathsInit(void);
+void NPC_InitGame( void );
+void G_LoadBoltOns( void );
+void Svcmd_NPC_f( void );
+/*
+void Bot_InitGame( void );
+void Bot_InitPreSpawn( void );
+void Bot_InitPostSpawn( void );
+void Bot_Shutdown( void );
+void Bot_Think( gentity_t *ent, int msec );
+void Bot_Connect( gentity_t *bot, char *botName );
+void Bot_Begin( gentity_t *bot );
+void Bot_Disconnect( gentity_t *bot );
+void Svcmd_Bot_f( void );
+void Nav_ItemSpawn( gentity_t *ent, int remaining );
+*/
+
+//
+// This section should be moved to QFILES.H
+//
+/*
+#define NAVFILE_ID			(('I')+('N'<<8)+('A'<<16)+('V'<<24))
+#define NAVFILE_VERSION		6
+
+typedef struct {
+	unsigned	id;
+	unsigned	version;
+	unsigned	checksum;
+	unsigned	surfaceCount;
+	unsigned	edgeCount;
+} navheader_t;
+
+
+#define MAX_SURFACES	4096
+
+#define NSF_PUSH			0x00000001
+#define NSF_WATERLEVEL1		0x00000002
+#define NSF_WATERLEVEL2		0x00000004
+#define NSF_WATER_NOAIR		0x00000008
+#define NSF_DUCK			0x00000010
+#define NSF_PAIN			0x00000020
+#define NSF_TELEPORTER		0x00000040
+#define NSF_PLATHIGH		0x00000080
+#define NSF_PLATLOW			0x00000100
+#define NSF_DOOR_FLOOR		0x00000200
+#define NSF_DOOR_SHOOT		0x00000400
+#define NSF_DOOR_BUTTON		0x00000800
+#define NSF_BUTTON			0x00001000
+
+typedef struct {
+	vec3_t		origin;
+	vec2_t		absmin;
+	vec2_t		absmax;
+	int			parm;
+	unsigned	flags;
+	unsigned	edgeCount;
+	unsigned	edgeIndex;
+} nsurface_t;
+
+
+#define NEF_DUCK			0x00000001
+#define NEF_JUMP			0x00000002
+#define NEF_HOLD			0x00000004
+#define NEF_WALK			0x00000008
+#define NEF_RUN				0x00000010
+#define NEF_NOAIRMOVE		0x00000020
+#define NEF_LEFTGROUND		0x00000040
+#define NEF_PLAT			0x00000080
+#define NEF_FALL1			0x00000100
+#define NEF_FALL2			0x00000200
+#define NEF_DOOR_SHOOT		0x00000400
+#define NEF_DOOR_BUTTON		0x00000800
+#define NEF_BUTTON			0x00001000
+
+typedef struct {
+	vec3_t		origin;
+	vec2_t		absmin;		// region within this surface that is the portal to the other surface
+	vec2_t		absmax;
+	int			surfaceNum;
+	unsigned	flags;		// jump, prerequisite button, will take falling damage, etc...
+	float		cost;
+	int			dirIndex;
+	vec3_t		endSpot;
+	int			parm;
+} nedge_t;
+*/
+#endif
diff --git a/code/game/bg_lib.cpp b/code/game/bg_lib.cpp
new file mode 100644
index 0000000..85d34d0
--- /dev/null
+++ b/code/game/bg_lib.cpp
@@ -0,0 +1,656 @@
+// this include must remain at the top of every bg_xxxx CPP file
+#include "common_headers.h"
+
+//#include "q_shared.h"
+
+// this file is excluded from release builds because of intrinsics
+
+size_t strlen( const char *string ) {
+	const char	*s;
+
+	s = string;
+	while ( *s ) {
+		s++;
+	}
+	return s - string;
+}
+
+
+char *strcat( char *strDestination, const char *strSource ) {
+	char	*s;
+
+	s = strDestination;
+	while ( *s ) {
+		s++;
+	}
+	while ( *strSource ) {
+		*s++ = *strSource++;
+	}
+	*s = 0;
+	return strDestination;
+}
+
+char *strcpy( char *strDestination, const char *strSource ) {
+	char *s;
+
+	s = strDestination;
+	while ( *strSource ) {
+		*s++ = *strSource++;
+	}
+	*s = 0;
+	return strDestination;
+}
+
+
+int strcmp( const char *string1, const char *string2 ) {
+	while ( *string1 == *string2 && *string1 && *string2 ) {
+		string1++;
+		string2++;
+	}
+	return *string1 - *string2;
+}
+
+
+char *strchr( const char *string, int c ) {
+	do {
+		if ( *string == c ) {
+			return ( char * )string;
+		}
+		string++;
+	} while ( *(string-1) );
+	return (char *)0;
+}
+
+char *strstr( const char *string, const char *strCharSet ) {
+	while ( *string ) {
+		int		i;
+
+		for ( i = 0 ; strCharSet[i] ; i++ ) {
+			if ( string[i] != strCharSet[i] ) {
+				break;
+			}
+		}
+		if ( !strCharSet[i] ) {
+			return (char *)string;
+		}
+		string++;
+	}
+	return (char *)0;
+}
+
+#ifndef _MSC_VER
+
+int tolower( int c ) {
+	if ( c >= 'A' && c <= 'Z' ) {
+		c += 'a' - 'A';
+	}
+	return c;
+}
+
+#endif
+
+int toupper( int c ) {
+	if ( c >= 'a' && c <= 'z' ) {
+		c += 'A' - 'a';
+	}
+	return c;
+}
+
+//#ifndef _MSC_VER
+
+
+
+#if 0
+
+double floor( double x ) {
+	return (int)(x + 0x40000000) - 0x40000000;
+}
+
+void *memset( void *dest, int c, size_t count ) {
+	while ( count-- ) {
+		((char *)dest)[count] = c;
+	}
+	return dest;
+}
+
+void *memcpy( void *dest, const void *src, size_t count ) {
+	while ( count-- ) {
+		((char *)dest)[count] = ((char *)src)[count];
+	}
+	return dest;
+}
+
+char *strncpy( char *strDest, const char *strSource, size_t count ) {
+	char	*s;
+
+	s = strDest;
+	while ( *strSource && count ) {
+		*s++ = *strSource++;
+		count--;
+	}
+	while ( count-- ) {
+		*s++ = 0;
+	}
+	return strDest;
+}
+
+double sqrt( double x ) {
+	float	y;
+	float	delta;
+	float	maxError;
+
+	if ( x <= 0 ) {
+		return 0;
+	}
+
+	// initial guess
+	y = x / 2;
+
+	// refine
+	maxError = x * 0.001;
+
+	do {
+		delta = ( y * y ) - x;
+		y -= delta / ( 2 * y );
+	} while ( delta > maxError || delta < -maxError );
+
+	return y;
+}
+
+
+float sintable[1024] = {
+0.000000,0.001534,0.003068,0.004602,0.006136,0.007670,0.009204,0.010738,
+0.012272,0.013805,0.015339,0.016873,0.018407,0.019940,0.021474,0.023008,
+0.024541,0.026075,0.027608,0.029142,0.030675,0.032208,0.033741,0.035274,
+0.036807,0.038340,0.039873,0.041406,0.042938,0.044471,0.046003,0.047535,
+0.049068,0.050600,0.052132,0.053664,0.055195,0.056727,0.058258,0.059790,
+0.061321,0.062852,0.064383,0.065913,0.067444,0.068974,0.070505,0.072035,
+0.073565,0.075094,0.076624,0.078153,0.079682,0.081211,0.082740,0.084269,
+0.085797,0.087326,0.088854,0.090381,0.091909,0.093436,0.094963,0.096490,
+0.098017,0.099544,0.101070,0.102596,0.104122,0.105647,0.107172,0.108697,
+0.110222,0.111747,0.113271,0.114795,0.116319,0.117842,0.119365,0.120888,
+0.122411,0.123933,0.125455,0.126977,0.128498,0.130019,0.131540,0.133061,
+0.134581,0.136101,0.137620,0.139139,0.140658,0.142177,0.143695,0.145213,
+0.146730,0.148248,0.149765,0.151281,0.152797,0.154313,0.155828,0.157343,
+0.158858,0.160372,0.161886,0.163400,0.164913,0.166426,0.167938,0.169450,
+0.170962,0.172473,0.173984,0.175494,0.177004,0.178514,0.180023,0.181532,
+0.183040,0.184548,0.186055,0.187562,0.189069,0.190575,0.192080,0.193586,
+0.195090,0.196595,0.198098,0.199602,0.201105,0.202607,0.204109,0.205610,
+0.207111,0.208612,0.210112,0.211611,0.213110,0.214609,0.216107,0.217604,
+0.219101,0.220598,0.222094,0.223589,0.225084,0.226578,0.228072,0.229565,
+0.231058,0.232550,0.234042,0.235533,0.237024,0.238514,0.240003,0.241492,
+0.242980,0.244468,0.245955,0.247442,0.248928,0.250413,0.251898,0.253382,
+0.254866,0.256349,0.257831,0.259313,0.260794,0.262275,0.263755,0.265234,
+0.266713,0.268191,0.269668,0.271145,0.272621,0.274097,0.275572,0.277046,
+0.278520,0.279993,0.281465,0.282937,0.284408,0.285878,0.287347,0.288816,
+0.290285,0.291752,0.293219,0.294685,0.296151,0.297616,0.299080,0.300543,
+0.302006,0.303468,0.304929,0.306390,0.307850,0.309309,0.310767,0.312225,
+0.313682,0.315138,0.316593,0.318048,0.319502,0.320955,0.322408,0.323859,
+0.325310,0.326760,0.328210,0.329658,0.331106,0.332553,0.334000,0.335445,
+0.336890,0.338334,0.339777,0.341219,0.342661,0.344101,0.345541,0.346980,
+0.348419,0.349856,0.351293,0.352729,0.354164,0.355598,0.357031,0.358463,
+0.359895,0.361326,0.362756,0.364185,0.365613,0.367040,0.368467,0.369892,
+0.371317,0.372741,0.374164,0.375586,0.377007,0.378428,0.379847,0.381266,
+0.382683,0.384100,0.385516,0.386931,0.388345,0.389758,0.391170,0.392582,
+0.393992,0.395401,0.396810,0.398218,0.399624,0.401030,0.402435,0.403838,
+0.405241,0.406643,0.408044,0.409444,0.410843,0.412241,0.413638,0.415034,
+0.416430,0.417824,0.419217,0.420609,0.422000,0.423390,0.424780,0.426168,
+0.427555,0.428941,0.430326,0.431711,0.433094,0.434476,0.435857,0.437237,
+0.438616,0.439994,0.441371,0.442747,0.444122,0.445496,0.446869,0.448241,
+0.449611,0.450981,0.452350,0.453717,0.455084,0.456449,0.457813,0.459177,
+0.460539,0.461900,0.463260,0.464619,0.465976,0.467333,0.468689,0.470043,
+0.471397,0.472749,0.474100,0.475450,0.476799,0.478147,0.479494,0.480839,
+0.482184,0.483527,0.484869,0.486210,0.487550,0.488889,0.490226,0.491563,
+0.492898,0.494232,0.495565,0.496897,0.498228,0.499557,0.500885,0.502212,
+0.503538,0.504863,0.506187,0.507509,0.508830,0.510150,0.511469,0.512786,
+0.514103,0.515418,0.516732,0.518045,0.519356,0.520666,0.521975,0.523283,
+0.524590,0.525895,0.527199,0.528502,0.529804,0.531104,0.532403,0.533701,
+0.534998,0.536293,0.537587,0.538880,0.540171,0.541462,0.542751,0.544039,
+0.545325,0.546610,0.547894,0.549177,0.550458,0.551738,0.553017,0.554294,
+0.555570,0.556845,0.558119,0.559391,0.560662,0.561931,0.563199,0.564466,
+0.565732,0.566996,0.568259,0.569521,0.570781,0.572040,0.573297,0.574553,
+0.575808,0.577062,0.578314,0.579565,0.580814,0.582062,0.583309,0.584554,
+0.585798,0.587040,0.588282,0.589521,0.590760,0.591997,0.593232,0.594466,
+0.595699,0.596931,0.598161,0.599389,0.600616,0.601842,0.603067,0.604290,
+0.605511,0.606731,0.607950,0.609167,0.610383,0.611597,0.612810,0.614022,
+0.615232,0.616440,0.617647,0.618853,0.620057,0.621260,0.622461,0.623661,
+0.624859,0.626056,0.627252,0.628446,0.629638,0.630829,0.632019,0.633207,
+0.634393,0.635578,0.636762,0.637944,0.639124,0.640303,0.641481,0.642657,
+0.643832,0.645005,0.646176,0.647346,0.648514,0.649681,0.650847,0.652011,
+0.653173,0.654334,0.655493,0.656651,0.657807,0.658961,0.660114,0.661266,
+0.662416,0.663564,0.664711,0.665856,0.667000,0.668142,0.669283,0.670422,
+0.671559,0.672695,0.673829,0.674962,0.676093,0.677222,0.678350,0.679476,
+0.680601,0.681724,0.682846,0.683965,0.685084,0.686200,0.687315,0.688429,
+0.689541,0.690651,0.691759,0.692866,0.693971,0.695075,0.696177,0.697278,
+0.698376,0.699473,0.700569,0.701663,0.702755,0.703845,0.704934,0.706021,
+0.707107,0.708191,0.709273,0.710353,0.711432,0.712509,0.713585,0.714659,
+0.715731,0.716801,0.717870,0.718937,0.720003,0.721066,0.722128,0.723188,
+0.724247,0.725304,0.726359,0.727413,0.728464,0.729514,0.730563,0.731609,
+0.732654,0.733697,0.734739,0.735779,0.736817,0.737853,0.738887,0.739920,
+0.740951,0.741980,0.743008,0.744034,0.745058,0.746080,0.747101,0.748119,
+0.749136,0.750152,0.751165,0.752177,0.753187,0.754195,0.755201,0.756206,
+0.757209,0.758210,0.759209,0.760207,0.761202,0.762196,0.763188,0.764179,
+0.765167,0.766154,0.767139,0.768122,0.769103,0.770083,0.771061,0.772036,
+0.773010,0.773983,0.774953,0.775922,0.776888,0.777853,0.778817,0.779778,
+0.780737,0.781695,0.782651,0.783605,0.784557,0.785507,0.786455,0.787402,
+0.788346,0.789289,0.790230,0.791169,0.792107,0.793042,0.793975,0.794907,
+0.795837,0.796765,0.797691,0.798615,0.799537,0.800458,0.801376,0.802293,
+0.803208,0.804120,0.805031,0.805940,0.806848,0.807753,0.808656,0.809558,
+0.810457,0.811355,0.812251,0.813144,0.814036,0.814926,0.815814,0.816701,
+0.817585,0.818467,0.819348,0.820226,0.821103,0.821977,0.822850,0.823721,
+0.824589,0.825456,0.826321,0.827184,0.828045,0.828904,0.829761,0.830616,
+0.831470,0.832321,0.833170,0.834018,0.834863,0.835706,0.836548,0.837387,
+0.838225,0.839060,0.839894,0.840725,0.841555,0.842383,0.843208,0.844032,
+0.844854,0.845673,0.846491,0.847307,0.848120,0.848932,0.849742,0.850549,
+0.851355,0.852159,0.852961,0.853760,0.854558,0.855354,0.856147,0.856939,
+0.857729,0.858516,0.859302,0.860085,0.860867,0.861646,0.862424,0.863199,
+0.863973,0.864744,0.865514,0.866281,0.867046,0.867809,0.868571,0.869330,
+0.870087,0.870842,0.871595,0.872346,0.873095,0.873842,0.874587,0.875329,
+0.876070,0.876809,0.877545,0.878280,0.879012,0.879743,0.880471,0.881197,
+0.881921,0.882643,0.883363,0.884081,0.884797,0.885511,0.886223,0.886932,
+0.887640,0.888345,0.889048,0.889750,0.890449,0.891146,0.891841,0.892534,
+0.893224,0.893913,0.894599,0.895284,0.895966,0.896646,0.897325,0.898001,
+0.898674,0.899346,0.900016,0.900683,0.901349,0.902012,0.902673,0.903332,
+0.903989,0.904644,0.905297,0.905947,0.906596,0.907242,0.907886,0.908528,
+0.909168,0.909806,0.910441,0.911075,0.911706,0.912335,0.912962,0.913587,
+0.914210,0.914830,0.915449,0.916065,0.916679,0.917291,0.917901,0.918508,
+0.919114,0.919717,0.920318,0.920917,0.921514,0.922109,0.922701,0.923291,
+0.923880,0.924465,0.925049,0.925631,0.926210,0.926787,0.927363,0.927935,
+0.928506,0.929075,0.929641,0.930205,0.930767,0.931327,0.931884,0.932440,
+0.932993,0.933544,0.934093,0.934639,0.935184,0.935726,0.936266,0.936803,
+0.937339,0.937872,0.938404,0.938932,0.939459,0.939984,0.940506,0.941026,
+0.941544,0.942060,0.942573,0.943084,0.943593,0.944100,0.944605,0.945107,
+0.945607,0.946105,0.946601,0.947094,0.947586,0.948075,0.948561,0.949046,
+0.949528,0.950008,0.950486,0.950962,0.951435,0.951906,0.952375,0.952842,
+0.953306,0.953768,0.954228,0.954686,0.955141,0.955594,0.956045,0.956494,
+0.956940,0.957385,0.957826,0.958266,0.958703,0.959139,0.959572,0.960002,
+0.960431,0.960857,0.961280,0.961702,0.962121,0.962538,0.962953,0.963366,
+0.963776,0.964184,0.964590,0.964993,0.965394,0.965793,0.966190,0.966584,
+0.966976,0.967366,0.967754,0.968139,0.968522,0.968903,0.969281,0.969657,
+0.970031,0.970403,0.970772,0.971139,0.971504,0.971866,0.972226,0.972584,
+0.972940,0.973293,0.973644,0.973993,0.974339,0.974684,0.975025,0.975365,
+0.975702,0.976037,0.976370,0.976700,0.977028,0.977354,0.977677,0.977999,
+0.978317,0.978634,0.978948,0.979260,0.979570,0.979877,0.980182,0.980485,
+0.980785,0.981083,0.981379,0.981673,0.981964,0.982253,0.982539,0.982824,
+0.983105,0.983385,0.983662,0.983937,0.984210,0.984480,0.984749,0.985014,
+0.985278,0.985539,0.985798,0.986054,0.986308,0.986560,0.986809,0.987057,
+0.987301,0.987544,0.987784,0.988022,0.988258,0.988491,0.988722,0.988950,
+0.989177,0.989400,0.989622,0.989841,0.990058,0.990273,0.990485,0.990695,
+0.990903,0.991108,0.991311,0.991511,0.991710,0.991906,0.992099,0.992291,
+0.992480,0.992666,0.992850,0.993032,0.993212,0.993389,0.993564,0.993737,
+0.993907,0.994075,0.994240,0.994404,0.994565,0.994723,0.994879,0.995033,
+0.995185,0.995334,0.995481,0.995625,0.995767,0.995907,0.996045,0.996180,
+0.996313,0.996443,0.996571,0.996697,0.996820,0.996941,0.997060,0.997176,
+0.997290,0.997402,0.997511,0.997618,0.997723,0.997825,0.997925,0.998023,
+0.998118,0.998211,0.998302,0.998390,0.998476,0.998559,0.998640,0.998719,
+0.998795,0.998870,0.998941,0.999011,0.999078,0.999142,0.999205,0.999265,
+0.999322,0.999378,0.999431,0.999481,0.999529,0.999575,0.999619,0.999660,
+0.999699,0.999735,0.999769,0.999801,0.999831,0.999858,0.999882,0.999905,
+0.999925,0.999942,0.999958,0.999971,0.999981,0.999989,0.999995,0.999999
+};
+
+double sin( double x ) {
+	int	index;
+	int	quad;
+
+	index = 1024 * x / (M_PI * 0.5);
+	quad = ( index >> 10 ) & 3;
+	index &= 1023;
+	switch ( quad ) {
+	case 0:
+		return sintable[index];
+	case 1:
+		return sintable[1023-index];
+	case 2:
+		return -sintable[index];
+	case 3:
+		return -sintable[1023-index];
+	}
+	return 0;
+}
+
+
+double cos( double x ) {
+	int	index;
+	int	quad;
+
+	index = 1024 * x / (M_PI * 0.5);
+	quad = ( index >> 10 ) & 3;
+	index &= 1023;
+	switch ( quad ) {
+	case 3:
+		return sintable[index];
+	case 0:
+		return sintable[1023-index];
+	case 1:
+		return -sintable[index];
+	case 2:
+		return -sintable[1023-index];
+	}
+	return 0;
+}
+
+
+double atan2( double y, double x ) {
+	float	base;
+	float	temp;
+	float	dir;
+	float	test;
+	int		i;
+
+	if ( x < 0 ) {
+		if ( y >= 0 ) {
+			// quad 1
+			base = M_PI / 2;
+			temp = x;
+			x = y;
+			y = -temp;
+		} else {
+			// quad 2
+			base = M_PI;
+			x = -x;
+			y = -y;
+		}
+	} else {
+		if ( y < 0 ) {
+			// quad 3
+			base = 3 * M_PI / 2;
+			temp = x;
+			x = -y;
+			y = temp;
+		}
+	}
+
+	if ( y > x ) {
+		base += M_PI/2;
+		temp = x;
+		x = y;
+		y = temp;
+		dir = -1;
+	} else {
+		dir = 1;
+	}
+
+	// calcualte angle in octant 0
+	if ( x == 0 ) {
+		return base;
+	}
+	y /= x;
+
+	for ( i = 0 ; i < 512 ; i++ ) {
+		test = sintable[i] / sintable[1023-i];
+		if ( test > y ) {
+			break;
+		}
+	}
+
+	return base + dir * i * ( M_PI/2048); 
+}
+
+
+#endif
+
+double tan( double x ) {
+	return sin(x) / cos(x);
+}
+
+
+static int randSeed = 0;
+
+int		rand( void ) {
+	randSeed = (69069 * randSeed + 1);
+	return randSeed & 0x7fff;
+}
+
+double atof( const char *string ) {
+	double	sign;
+	double	value;
+	int		c;
+
+
+	// skip whitespace
+	while ( *string <= ' ' ) {
+		if ( !*string ) {
+			return 0;
+		}
+		string++;
+	}
+
+	// check sign
+	switch ( *string ) {
+	case '+':
+		string++;
+		sign = 1;
+		break;
+	case '-':
+		string++;
+		sign = -1;
+		break;
+	default:
+		sign = 1;
+		break;
+	}
+
+	// read digits
+	value = 0;
+	do {
+		c = *string++;
+		if ( c < '0' || c > '9' ) {
+			break;
+		}
+		c -= '0';
+		value = value * 10 + c;
+	} while ( 1 );
+
+	// check for decimal point
+	if ( c == '.' ) {
+		double fraction;
+
+		string++;
+		fraction = 0.1;
+		do {
+			c = *string++;
+			if ( c < '0' || c > '9' ) {
+				break;
+			}
+			c -= '0';
+			value += c * fraction;
+			fraction *= 0.1;
+		} while ( 1 );
+
+	}
+
+	// not handling 10e10 notation...
+
+	return value * sign;
+}
+
+#ifndef _MSC_VER
+
+int atoi( const char *string ) {
+	int		sign;
+	int		value;
+	int		c;
+
+
+	// skip whitespace
+	while ( *string <= ' ' ) {
+		if ( !*string ) {
+			return 0;
+		}
+		string++;
+	}
+
+	// check sign
+	switch ( *string ) {
+	case '+':
+		string++;
+		sign = 1;
+		break;
+	case '-':
+		string++;
+		sign = -1;
+		break;
+	default:
+		sign = 1;
+		break;
+	}
+
+	// read digits
+	value = 0;
+	do {
+		c = *string++;
+		if ( c < '0' || c > '9' ) {
+			break;
+		}
+		c -= '0';
+		value = value * 10 + c;
+	} while ( 1 );
+
+	// not handling 10e10 notation...
+
+	return value * sign;
+}
+
+#endif
+
+int abs( int n ) {
+	return n < 0 ? -n : n;
+}
+
+double fabs( double x ) {
+	return x < 0 ? -x : x;
+}
+
+
+
+//=========================================================
+
+
+void AddInt( char **buf_p, int val, int width ) {
+	char	text[32];
+	int		digits;
+	int		signedVal;
+	char	*buf;
+
+	digits = 0;
+	signedVal = val;
+	if ( val < 0 ) {
+		val = -val;
+	}
+	do {
+		text[digits++] = '0' + val % 10;
+		val /= 10;
+	} while ( val );
+
+	if ( signedVal < 0 ) {
+		text[digits++] = '-';
+	}
+
+	buf = *buf_p;
+
+	while ( digits < width ) {
+		*buf++ = ' ';
+		width--;
+	}
+
+	while ( digits-- ) {
+		*buf++ = text[digits];
+	}
+
+	*buf_p = buf;
+}
+
+void AddFloat( char **buf_p, float fval, int width ) {
+	char	text[32];
+	int		digits;
+	float	signedVal;
+	char	*buf;
+	int		val;
+
+	// FIXME!!!! handle fractions
+
+	digits = 0;
+	signedVal = fval;
+	if ( fval < 0 ) {
+		fval = -fval;
+	}
+
+	val = (int)fval;
+	do {
+		text[digits++] = '0' + val % 10;
+		val /= 10;
+	} while ( val );
+
+	if ( signedVal < 0 ) {
+		text[digits++] = '-';
+	}
+
+	buf = *buf_p;
+
+	while ( digits < width ) {
+		*buf++ = ' ';
+		width--;
+	}
+
+	while ( digits-- ) {
+		*buf++ = text[digits];
+	}
+
+	*buf_p = buf;
+}
+
+int vsprintf( char *buffer, const char *fmt, va_list argptr ) {
+	char	*buf_p;
+	int		cmd;
+	int		*arg;
+	char	*s;
+	int		width;
+
+	buf_p = buffer;
+	arg = (int *)argptr;
+
+	while ( *fmt ) {
+		if ( fmt[0] != '%' ) {
+			*buf_p++ = *fmt++;
+			continue;
+		}
+
+		cmd = fmt[1];
+		if ( cmd >= '0' && cmd <= '9' ) {
+			width = cmd - '0';
+			cmd = fmt[2];
+			fmt++;
+		} else {
+			width = 0;
+		}
+		fmt += 2;
+
+		switch ( cmd ) {
+		case 'i':
+		case 'd':
+		case 'u':
+			AddInt( &buf_p, *arg, width );
+			break;
+
+		case 'f':
+			AddFloat( &buf_p, *(float *)arg, width );
+			break;
+
+		case 's':
+			s = (char *)*arg;
+			if ( !s ) {
+				s = "<NULL>";
+			}
+			while ( *s ) {
+				*buf_p++ = *s++;
+			}
+			break;
+		}
+		arg++;
+	}
+
+	*buf_p = 0;
+	return buf_p - buffer;
+}
+
diff --git a/code/game/bg_local.h b/code/game/bg_local.h
new file mode 100644
index 0000000..6f4b5b9
--- /dev/null
+++ b/code/game/bg_local.h
@@ -0,0 +1,56 @@
+// bg_local.h -- local definitions for the bg (both games) files
+
+#define	TIMER_LAND		130
+#define	TIMER_GESTURE	(34*66+50)
+
+#define	OVERCLIP		1.001F
+
+// all of the locals will be zeroed before each
+// pmove, just to make damn sure we don't have
+// any differences when running on client or server
+typedef struct {
+	vec3_t		forward, right, up;
+	float		frametime;
+
+	int			msec;
+
+	qboolean	walking;
+	qboolean	groundPlane;
+	trace_t		groundTrace;
+
+	float		impactSpeed;
+
+	vec3_t		previous_origin;
+	vec3_t		previous_velocity;
+	int			previous_waterlevel;
+} pml_t;
+
+extern	pmove_t		*pm;
+extern	pml_t		pml;
+
+// movement parameters
+extern	const float	pm_stopspeed;
+extern	const float	pm_duckScale;
+extern	const float	pm_swimScale;
+extern	const float	pm_wadeScale;
+
+extern	const float	pm_accelerate;
+extern	const float	pm_airaccelerate;
+extern	const float	pm_wateraccelerate;
+extern	const float	pm_flyaccelerate;
+
+extern	const float	pm_friction;
+extern	const float	pm_waterfriction;
+extern	const float	pm_flightfriction;
+
+extern	int		c_pmove;
+
+void PM_ClipVelocity( vec3_t in, vec3_t normal, vec3_t out, float overbounce );
+void PM_AddTouchEnt( int entityNum );
+void PM_AddEvent( int newEvent );
+
+qboolean	PM_SlideMove( float gravity );
+void		PM_StepSlideMove( float gravity );
+
+
+
diff --git a/code/game/bg_misc.cpp b/code/game/bg_misc.cpp
new file mode 100644
index 0000000..6f52773
--- /dev/null
+++ b/code/game/bg_misc.cpp
@@ -0,0 +1,741 @@
+// this include must remain at the top of every bg_xxxx CPP file
+#include "common_headers.h"
+
+// included in both game dll and client
+
+//#include "q_shared.h"
+#include "g_local.h"
+#include "bg_public.h"
+#include "g_items.h"
+#include "g_vehicles.h"
+
+
+extern weaponData_t weaponData[WP_NUM_WEAPONS];
+extern ammoData_t ammoData[AMMO_MAX];
+
+
+#define PICKUPSOUND "sound/weapons/w_pkup.wav"
+
+/*QUAKED weapon_***** ( 0 0 0 ) (-16 -16 -16) (16 16 16) suspended
+DO NOT USE THIS CLASS, IT JUST HOLDS GENERAL INFORMATION for weapons, ammo, and item pickups.
+The suspended flag will allow items to hang in the air, otherwise they are dropped to the next surface.
+The NOPLAYER flag makes it so player cannot pick it up.
+The ALLOWNPC flag allows only NPCs to pick it up, too
+
+If an item is the target of another entity, it will spawn as normal, use INVISIBLE to hide it.
+
+An item fires all of its targets when it is picked up.  If the toucher can't carry it, the targets won't be fired.
+
+"wait"	override the default wait before respawning.  -1 = never respawn automatically, which can be used with targeted spawning.
+"random" random number of plus or minus seconds varied from the respawn time
+"count" override quantity or duration on most items.
+"team" only this team can pick it up
+	"player"
+	"neutral"
+	"enemy"
+*/
+
+/*QUAKED weapon_stun_baton (.3 .3 1) (-16 -16 -2) (16 16 16) SUSPEND NOPLAYER ALLOWNPC NOTSOLID VERTICAL INVISIBLE
+model="/models/weapons2/stun_baton/baton.md3"
+*/
+/*QUAKED weapon_saber (.3 .3 1) (-16 -16 -8) (16 16 16) SUSPEND NOPLAYER ALLOWNPC NOTSOLID VERTICAL INVISIBLE NOGLOW
+model="/models/weapons2/saber/saber_w.md3"
+When picked up, will be used as a second saber unless:
+	1) It's a two-handed saber
+	2) The old saber was two-handed
+	OR
+	3) You set "saberSolo" to "1"
+
+saberType - entry name from sabers.cfg - which kind of saber this is - use "player" to make it so that the saber will be whatever saber the player is configured to use
+saberColor - red, orange, yellow, green, blue, and purple
+saberSolo - set to "1" and this will be the only saber the person who picks this up will be holding
+*/
+/*QUAKED weapon_bryar_pistol (.3 .3 1) (-16 -16 -2) (16 16 16) SUSPEND NOPLAYER ALLOWNPC NOTSOLID VERTICAL INVISIBLE
+model="/models/weapons2/briar_pistol/briar_pistol.md3"
+*/
+/*QUAKED weapon_blaster_pistol (.3 .3 1) (-16 -16 -2) (16 16 16) SUSPEND NOPLAYER ALLOWNPC NOTSOLID VERTICAL INVISIBLE
+model="/models/weapons2/blaster_pistol/blaster_pistol.md3"
+*/
+/*QUAKED weapon_blaster (.3 .3 1) (-16 -16 -2) (16 16 16) SUSPEND NOPLAYER ALLOWNPC NOTSOLID VERTICAL INVISIBLE
+model="/models/weapons2/blaster_r/blaster.md3"
+*/
+/*QUAKED weapon_disruptor (.3 .3 1) (-16 -16 -2) (16 16 16) SUSPEND NOPLAYER ALLOWNPC NOTSOLID VERTICAL INVISIBLE
+model="/models/weapons2/disruptor/disruptor.md3"
+*/
+/*QUAKED weapon_bowcaster (.3 .3 1) (-16 -16 -2) (16 16 16) SUSPEND NOPLAYER ALLOWNPC NOTSOLID VERTICAL INVISIBLE
+model="/models/weapons2/bowcaster/bowcaster.md3"
+*/
+/*QUAKED weapon_repeater (.3 .3 1) (-16 -16 -2) (16 16 16) SUSPEND NOPLAYER ALLOWNPC NOTSOLID VERTICAL INVISIBLE
+model="/models/weapons2/heavy_repeater/heavy_repeater.md3"
+*/
+/*QUAKED weapon_demp2 (.3 .3 1) (-16 -16 -2) (16 16 16) SUSPEND NOPLAYER ALLOWNPC NOTSOLID VERTICAL INVISIBLE
+model="/models/weapons2/demp2/demp2.md3"
+*/
+/*QUAKED weapon_flechette (.3 .3 1) (-16 -16 -2) (16 16 16) SUSPEND NOPLAYER ALLOWNPC NOTSOLID VERTICAL INVISIBLE
+model="/models/weapons2/golan_arms/golan_arms.md3"
+*/
+/*QUAKED weapon_concussion_rifle (.3 .3 1) (-16 -16 -2) (16 16 16) SUSPEND NOPLAYER ALLOWNPC NOTSOLID VERTICAL INVISIBLE
+model="/models/weapons2/c_rifle/c_rifle.md3"
+*/
+/*QUAKED weapon_rocket_launcher (.3 .3 1) (-16 -16 -2) (16 16 16) SUSPEND NOPLAYER ALLOWNPC NOTSOLID VERTICAL INVISIBLE
+model="/models/weapons2/merr_sonn/merr_sonn.md3"
+*/
+/*QUAKED weapon_thermal (.3 .3 1) (-16 -16 -2) (16 16 16) SUSPEND NOPLAYER ALLOWNPC NOTSOLID VERTICAL INVISIBLE
+model="/models/weapons2/thermal/thermal.md3"
+*/
+/*QUAKED weapon_trip_mine (.3 .3 1) (-16 -16 -2) (16 16 16) SUSPEND NOPLAYER ALLOWNPC NOTSOLID VERTICAL INVISIBLE
+model="/models/weapons2/laser_trap/laser_trap.md3"
+*/
+/*QUAKED weapon_det_pack (.3 .3 1) (-16 -16 -2) (16 16 16) SUSPEND NOPLAYER ALLOWNPC NOTSOLID VERTICAL INVISIBLE
+model="/models/weapons2/detpack/det_pack.md3"
+*/
+
+/*QUAKED item_seeker (.3 .3 1) (-8 -8 -4) (8 8 16) suspended
+30 seconds of seeker drone
+*/
+/*QUAKED item_bacta (.3 .3 1) (-8 -8 0) (8 8 16) suspended
+model="/models/items/bacta.md3"
+*/
+/*QUAKED item_datapad (.3 .3 1) (-8 -8 0) (8 8 16) suspended
+model="/models/items/datapad.md3"
+*/
+/*QUAKED item_binoculars (.3 .3 1) (-8 -8 0) (8 8 16) suspended
+model="/models/items/binoculars.md3"
+*/
+/*QUAKED item_sentry_gun (.3 .3 1) (-8 -8 0) (8 8 16) suspended
+*/
+/*QUAKED item_la_goggles (.3 .3 1) (-8 -8 0) (8 8 16) suspended
+*/
+/*QUAKED ammo_force (.3 .5 1) (-8 -8 -0) (8 8 16) SUSPEND NOPLAYER ALLOWNPC NOTSOLID
+Ammo for the force.
+*/
+/*QUAKED ammo_blaster (.3 .5 1) (-8 -8 -0) (8 8 16) SUSPEND NOPLAYER ALLOWNPC NOTSOLID
+Ammo for the Bryar and Blaster pistols.
+*/
+/*QUAKED ammo_powercell (.3 .5 1) (-8 -8 -0) (8 8 16) SUSPEND NOPLAYER ALLOWNPC NOTSOLID
+Ammo for Tenloss Disruptor, Wookie Bowcaster, and the Destructive Electro Magnetic Pulse (demp2 ) guns
+*/
+/*QUAKED ammo_metallic_bolts (.3 .5 1) (-8 -8 -0) (8 8 16) SUSPEND NOPLAYER ALLOWNPC NOTSOLID
+Ammo for Imperial Heavy Repeater and the Golan Arms Flechette
+*/
+/*QUAKED ammo_rockets (.3 .5 1) (-8 -8 -0) (8 8 16) SUSPEND NOPLAYER ALLOWNPC NOTSOLID
+Ammo for Merr-Sonn portable missile launcher
+*/
+/*QUAKED ammo_thermal (.3 .5 1) (-16 -16 -0) (16 16 16) SUSPEND NOPLAYER ALLOWNPC NOTSOLID
+Belt of thermal detonators
+*/
+/*QUAKED ammo_tripmine (.3 .5 1) (-8 -8 -0) (8 8 16) SUSPEND NOPLAYER ALLOWNPC NOTSOLID
+3 pack of tripmines
+*/
+/*QUAKED ammo_detpack (.3 .5 1) (-8 -8 -0) (8 8 16) SUSPEND NOPLAYER ALLOWNPC NOTSOLID
+3 pack of detpacks
+*/
+
+/*QUAKED item_medpak_instant (.3 .3 1) (-8 -8 -4) (8 8 16) SUSPEND NOPLAYER ALLOWNPC NOTSOLID VERTICAL INVISIBLE
+*/
+
+/*QUAKED item_shield_sm_instant (.3 .3 1) (-8 -8 -4) (8 8 16) SUSPEND NOPLAYER ALLOWNPC NOTSOLID VERTICAL INVISIBLE
+*/
+
+/*QUAKED item_shield_lrg_instant (.3 .3 1) (-8 -8 -4) (8 8 16) SUSPEND NOPLAYER ALLOWNPC NOTSOLID VERTICAL INVISIBLE
+*/
+/*QUAKED item_goodie_key (.3 .3 1) (-8 -8 0) (8 8 16) suspended
+*/
+/*QUAKED item_security_key (.3 .3 1) (-8 -8 0) (8 8 16) suspended
+message - used to differentiate one key from another.
+*/
+/*QUAKED item_battery (.3 .5 1) (-8 -8 -0) (8 8 16) SUSPEND NOPLAYER ALLOWNPC NOTSOLID
+model="/models/items/battery.md3"
+battery pickup item
+*/
+
+/*QUAKED holocron_force_heal (.3 .5 1) (-8 -8 -0) (8 8 16) SUSPEND NOPLAYER ALLOWNPC NOTSOLID
+force heal pickup item
+
+"count"     level of force power this holocron gives activator ( range: 0-3, default 1)
+*/
+
+/*QUAKED holocron_force_levitation (.3 .5 1) (-8 -8 -0) (8 8 16) SUSPEND NOPLAYER ALLOWNPC NOTSOLID
+force levitation pickup item
+
+"count"     level of force power this holocron gives activator ( range: 0-3, default 1)
+*/
+
+/*QUAKED holocron_force_speed (.3 .5 1) (-8 -8 -0) (8 8 16) SUSPEND NOPLAYER ALLOWNPC NOTSOLID
+force speed pickup item
+
+"count"     level of force power this holocron gives activator ( range: 0-3, default 1)
+*/
+
+/*QUAKED holocron_force_push (.3 .5 1) (-8 -8 -0) (8 8 16) SUSPEND NOPLAYER ALLOWNPC NOTSOLID
+force push pickup item
+
+"count"     level of force power this holocron gives activator ( range: 0-3, default 1)
+*/
+
+/*QUAKED holocron_force_pull (.3 .5 1) (-8 -8 -0) (8 8 16) SUSPEND NOPLAYER ALLOWNPC NOTSOLID
+force pull pickup item
+
+"count"     level of force power this holocron gives activator ( range: 0-3, default 1)
+*/
+
+/*QUAKED holocron_force_telepathy (.3 .5 1) (-8 -8 -0) (8 8 16) SUSPEND NOPLAYER ALLOWNPC NOTSOLID
+force telepathy pickup item
+
+"count"     level of force power this holocron gives activator ( range: 0-3, default 1)
+*/
+
+/*QUAKED holocron_force_grip (.3 .5 1) (-8 -8 -0) (8 8 16) SUSPEND NOPLAYER ALLOWNPC NOTSOLID
+force grip pickup item
+
+"count"     level of force power this holocron gives activator ( range: 0-3, default 1)
+*/
+
+/*QUAKED holocron_force_lightining (.3 .5 1) (-8 -8 -0) (8 8 16) SUSPEND NOPLAYER ALLOWNPC NOTSOLID
+force lighting pickup item
+
+"count"     level of force power this holocron gives activator ( range: 0-3, default 1)
+*/
+
+/*QUAKED holocron_force_saberthrow (.3 .5 1) (-8 -8 -0) (8 8 16) SUSPEND NOPLAYER ALLOWNPC NOTSOLID
+force saberthrow pickup item
+
+"count"     level of force power this holocron gives activator ( range: 0-3, default 1)
+*/
+
+gitem_t	bg_itemlist[ITM_NUM_ITEMS+1];//need a null on the end
+
+//int		bg_numItems = sizeof(bg_itemlist) / sizeof(bg_itemlist[0]) ;
+const int		bg_numItems = ITM_NUM_ITEMS;
+
+
+
+/*
+===============
+FindItemForWeapon
+
+===============
+*/
+gitem_t	*FindItemForWeapon( weapon_t weapon ) {
+	int		i;
+
+	for ( i = 1 ; i < bg_numItems ; i++ ) {
+		if ( bg_itemlist[i].giType == IT_WEAPON && bg_itemlist[i].giTag == weapon ) {
+			return &bg_itemlist[i];
+		}
+	}
+
+	Com_Error( ERR_DROP, "Couldn't find item for weapon %i", weapon);
+	return NULL;
+}
+
+//----------------------------------------------
+gitem_t	*FindItemForInventory( int inv ) 
+{
+	int		i;
+	gitem_t	*it;
+
+	// Now just check for any other kind of item.
+	for ( i = 1 ; i < bg_numItems ; i++ ) 
+	{
+		it = &bg_itemlist[i];
+
+		if ( it->giType == IT_HOLDABLE )
+		{
+			if ( it->giTag == inv ) 
+			{
+				return it;
+			}
+		}
+	}
+
+	Com_Error( ERR_DROP, "Couldn't find item for inventory %i", inv );
+	return NULL;
+}
+
+/*
+===============
+FindItemForWeapon
+
+===============
+*/
+gitem_t	*FindItemForAmmo( ammo_t ammo ) 
+{
+	int		i;
+
+	for ( i = 1 ; i < bg_numItems ; i++ ) 
+	{
+		if ( bg_itemlist[i].giType == IT_AMMO && bg_itemlist[i].giTag == ammo ) 
+		{
+			return &bg_itemlist[i];
+		}
+	}
+
+	Com_Error( ERR_DROP, "Couldn't find item for ammo %i", ammo );
+	return NULL;
+}
+
+/*
+===============
+FindItem
+
+===============
+*/
+gitem_t	*FindItem( const char *className ) {
+	int		i;
+
+	for ( i = 1 ; i < bg_numItems ; i++ ) {
+		if ( !Q_stricmp( bg_itemlist[i].classname, className ) )
+			return &bg_itemlist[i];
+	}
+
+	return NULL;
+}
+
+
+/*
+================
+BG_CanItemBeGrabbed
+
+Returns false if the item should not be picked up.
+This needs to be the same for client side prediction and server use.
+================
+*/
+qboolean	BG_CanItemBeGrabbed( const entityState_t *ent, const playerState_t *ps ) {
+	gitem_t	*item;
+
+	if ( ent->modelindex < 1 || ent->modelindex >= bg_numItems ) {
+		Com_Error( ERR_DROP, "BG_CanItemBeGrabbed: index out of range" );
+	}
+
+	item = &bg_itemlist[ent->modelindex];
+
+	switch( item->giType ) {
+
+	case IT_WEAPON:
+		// See if we already have this weapon.
+		if ( !(ps->stats[ STAT_WEAPONS ] & ( 1 << item->giTag ))) 
+		{			
+			// Don't have this weapon yet, so pick it up.
+			return qtrue;
+		}
+		else if ( item->giTag == WP_SABER )
+		{//always pick up a saber, might be a new one?
+			return qtrue;
+		}
+
+		// Make sure that we aren't already full on ammo for this weapon
+		if ( ps->ammo[weaponData[item->giTag].ammoIndex] >= ammoData[weaponData[item->giTag].ammoIndex].max )
+		{
+			// full, so don't grab the item
+			return qfalse; 
+		}
+
+		return qtrue; // could use more of this type of ammo, so grab the item
+
+	case IT_AMMO:
+
+		if (item->giTag != AMMO_FORCE)
+		{
+			// since the ammo is the weapon in this case, picking up ammo should actually give you the weapon
+			switch( item->giTag )
+			{
+			case AMMO_THERMAL:
+				if( !(ps->stats[STAT_WEAPONS] & ( 1 << WP_THERMAL ) ) )
+				{
+					return qtrue;
+				}
+				break;
+			case AMMO_DETPACK:
+				if( !(ps->stats[STAT_WEAPONS] & ( 1 << WP_DET_PACK ) ) )
+				{
+					return qtrue;
+				}
+				break;
+			case AMMO_TRIPMINE:
+				if( !(ps->stats[STAT_WEAPONS] & ( 1 << WP_TRIP_MINE ) ) )
+				{
+					return qtrue;
+				}
+				break;
+			}
+
+			if ( ps->ammo[ item->giTag ] >= ammoData[item->giTag].max )	// checkme			
+			{
+				return qfalse;		// can't hold any more
+			}
+		}
+		else
+		{
+			if (ps->forcePower >= ammoData[item->giTag].max*2)
+			{
+				return qfalse;		// can't hold any more
+			}
+
+		}
+
+		return qtrue;
+
+	case IT_ARMOR:
+		// we also clamp armor to the maxhealth for handicapping
+		if ( ps->stats[STAT_ARMOR] >= ps->stats[STAT_MAX_HEALTH] ) {
+			return qfalse;
+		}
+		return qtrue;
+
+	case IT_HEALTH:
+		if ((ps->forcePowersActive & (1 << FP_RAGE)))
+		{//ragers can't use health
+			return qfalse;
+		}
+		// don't pick up if already at max
+		if ( ps->stats[STAT_HEALTH] >= ps->stats[STAT_MAX_HEALTH] ) {
+			return qfalse;
+		}
+		return qtrue;
+
+	case IT_BATTERY:
+		// don't pick up if already at max
+		if ( ps->batteryCharge >= MAX_BATTERIES ) 
+		{
+			return qfalse;
+		}
+		return qtrue;
+
+	case IT_HOLOCRON:
+		// pretty lame but for now you can always pick these up
+		return qtrue;
+		
+
+	case IT_HOLDABLE:
+		if ( item->giTag >= INV_ELECTROBINOCULARS && item->giTag <= INV_SENTRY )
+		{
+			// hardcoded--can only pick up five of any holdable
+			if ( ps->inventory[item->giTag] >= 5 )
+			{
+				return qfalse;
+			}
+		}
+		return qtrue;
+	}
+
+	return qfalse;
+}
+
+//======================================================================
+
+/*
+================
+EvaluateTrajectory
+
+================
+*/
+void EvaluateTrajectory( const trajectory_t *tr, int atTime, vec3_t result ) {
+	float		deltaTime;
+	float		phase;
+
+	switch( tr->trType ) {
+	case TR_STATIONARY:
+	case TR_INTERPOLATE:
+		VectorCopy( tr->trBase, result );
+		break;
+	case TR_LINEAR:
+		deltaTime = ( atTime - tr->trTime ) * 0.001F;	// milliseconds to seconds
+		VectorMA( tr->trBase, deltaTime, tr->trDelta, result );
+		break;
+	case TR_SINE:
+		deltaTime = ( atTime - tr->trTime ) / (float) tr->trDuration;
+		phase = (float)sin( deltaTime * M_PI * 2 );
+		VectorMA( tr->trBase, phase, tr->trDelta, result );
+		break;
+	case TR_LINEAR_STOP:
+		if ( atTime > tr->trTime + tr->trDuration ) 
+		{
+			atTime = tr->trTime + tr->trDuration;
+		}
+		//old totally linear
+		deltaTime = ( atTime - tr->trTime ) * 0.001F;	// milliseconds to seconds
+		if ( deltaTime < 0 ) 
+		{//going past the total duration
+			deltaTime = 0;
+		}
+		VectorMA( tr->trBase, deltaTime, tr->trDelta, result );
+		break;
+	case TR_NONLINEAR_STOP:
+		if ( atTime > tr->trTime + tr->trDuration ) 
+		{
+			atTime = tr->trTime + tr->trDuration;
+		}
+		//new slow-down at end
+		if ( atTime - tr->trTime > tr->trDuration || atTime - tr->trTime <= 0  )
+		{
+			deltaTime = 0;
+		}
+		else
+		{//FIXME: maybe scale this somehow?  So that it starts out faster and stops faster?
+			deltaTime = tr->trDuration*0.001f*((float)cos( DEG2RAD(90.0f - (90.0f*((float)atTime-tr->trTime)/(float)tr->trDuration)) ));
+		}
+		VectorMA( tr->trBase, deltaTime, tr->trDelta, result );
+		break;
+	case TR_GRAVITY:
+		deltaTime = ( atTime - tr->trTime ) * 0.001F;	// milliseconds to seconds
+		VectorMA( tr->trBase, deltaTime, tr->trDelta, result );
+		result[2] -= 0.5F * g_gravity->value * deltaTime * deltaTime;//DEFAULT_GRAVITY
+		break;
+	default:
+		Com_Error( ERR_DROP, "EvaluateTrajectory: unknown trType: %i", tr->trTime );
+		break;
+	}
+}
+
+/*
+================
+EvaluateTrajectoryDelta
+
+Returns current speed at given time
+================
+*/
+void EvaluateTrajectoryDelta( const trajectory_t *tr, int atTime, vec3_t result ) {
+	float	deltaTime;
+	float	phase;
+
+	switch( tr->trType ) {
+	case TR_STATIONARY:
+	case TR_INTERPOLATE:
+		VectorClear( result );
+		break;
+	case TR_LINEAR:
+		VectorCopy( tr->trDelta, result );
+		break;
+	case TR_SINE:
+		deltaTime = ( atTime - tr->trTime ) / (float) tr->trDuration;
+		phase = (float)cos( deltaTime * M_PI * 2 );	// derivative of sin = cos
+		phase *= 0.5;
+		VectorScale( tr->trDelta, phase, result );
+		break;
+	case TR_LINEAR_STOP:
+		if ( atTime > tr->trTime + tr->trDuration ) 
+		{
+			VectorClear( result );
+			return;
+		}
+		VectorCopy( tr->trDelta, result );
+		break;
+	case TR_NONLINEAR_STOP:
+		if ( atTime - tr->trTime > tr->trDuration || atTime - tr->trTime <= 0  )
+		{
+			VectorClear( result );
+			return;
+		}
+		deltaTime = tr->trDuration*0.001f*((float)cos( DEG2RAD(90.0f - (90.0f*((float)atTime-tr->trTime)/(float)tr->trDuration)) ));
+		VectorScale( tr->trDelta, deltaTime, result );
+		break;
+	case TR_GRAVITY:
+		deltaTime = ( atTime - tr->trTime ) * 0.001F;	// milliseconds to seconds
+		VectorCopy( tr->trDelta, result );
+		result[2] -= g_gravity->value * deltaTime;		// DEFAULT_GRAVITY
+		break;
+	default:
+		Com_Error( ERR_DROP, "EvaluateTrajectoryDelta: unknown trType: %i", tr->trTime );
+		break;
+	}
+}
+
+/*
+===============
+AddEventToPlayerstate
+
+Handles the sequence numbers
+===============
+*/
+void AddEventToPlayerstate( int newEvent, int eventParm, playerState_t *ps ) {
+	ps->events[ps->eventSequence & (MAX_PS_EVENTS-1)] = newEvent;
+	ps->eventParms[ps->eventSequence & (MAX_PS_EVENTS-1)] = eventParm;
+	ps->eventSequence++;
+}
+
+
+/*
+===============
+CurrentPlayerstateEvent
+
+===============
+*/
+int	CurrentPlayerstateEvent( playerState_t *ps ) {
+	return ps->events[ (ps->eventSequence-1) & (MAX_PS_EVENTS-1) ];
+}
+
+/*
+========================
+PlayerStateToEntityState
+
+This is done after each set of usercmd_t on the server,
+and after local prediction on the client
+========================
+*/
+void PlayerStateToEntityState( playerState_t *ps, entityState_t *s ) 
+{
+	int		i;
+
+	if ( ps->pm_type == PM_INTERMISSION || ps->pm_type == PM_SPECTATOR ) 
+	{
+		s->eType = ET_INVISIBLE;
+	} 
+	/*else if ( ps->stats[STAT_HEALTH] <= GIB_HEALTH ) 
+	{
+		s->eType = ET_INVISIBLE;
+	} */
+	else
+	{
+		s->eType = ET_PLAYER;
+	}
+
+	s->number = ps->clientNum;
+
+	s->pos.trType = TR_INTERPOLATE;
+	VectorCopy( ps->origin, s->pos.trBase );
+	//SnapVector( s->pos.trBase );
+
+	s->apos.trType = TR_INTERPOLATE;
+	VectorCopy( ps->viewangles, s->apos.trBase );
+	//SnapVector( s->apos.trBase );
+
+	s->angles2[YAW] = ps->movementDir;
+	s->legsAnim = ps->legsAnim;
+	s->torsoAnim = ps->torsoAnim;
+	s->clientNum = ps->clientNum;		// ET_PLAYER looks here instead of at number
+										// so corpses can also reference the proper config
+	s->eFlags = ps->eFlags;
+
+	// new sabre stuff
+	s->saberActive = ps->SaberActive();//WHY is this on the entityState_t, too???
+	s->saberInFlight = ps->saberInFlight;
+
+	// NOTE: Although we store this stuff locally on a vehicle, who's to say we
+	// can't bring back these variables and fill them at the appropriate time? -Aurelio
+	// We need to bring these in from the vehicle NPC.
+	if ( g_entities[ps->clientNum].client && g_entities[ps->clientNum].client->NPC_class == CLASS_VEHICLE && g_entities[ps->clientNum].NPC )
+	{
+		Vehicle_t *pVeh = g_entities[ps->clientNum].m_pVehicle;
+		s->vehicleArmor = pVeh->m_iArmor;
+		VectorCopy( pVeh->m_vOrientation, s->vehicleAngles );
+	}
+
+	s->weapon = ps->weapon;
+	s->groundEntityNum = ps->groundEntityNum;
+
+	s->powerups = 0;
+	for ( i = 0 ; i < MAX_POWERUPS ; i++ ) {
+		if ( ps->powerups[ i ] ) {
+			s->powerups |= 1 << i;
+		}
+	}
+#if 0
+	if ( ps->externalEvent ) {
+		s->event = ps->externalEvent;
+		s->eventParm = ps->externalEventParm;
+	} else {
+		int		seq;
+
+		seq = (ps->eventSequence-1) & (MAX_PS_EVENTS-1);
+		s->event = ps->events[ seq ] | ( ( ps->eventSequence & 3 ) << 8 );
+		s->eventParm = ps->eventParms[ seq ];
+	}
+
+	// show some roll in the body based on velocity and angle
+	if ( ps->stats[STAT_HEALTH] > 0 ) {
+		vec3_t		right;
+		float		sign;
+		float		side;
+		float		value;
+
+		AngleVectors( ps->viewangles, NULL, right, NULL );
+
+		side = DotProduct (ps->velocity, right);
+		sign = side < 0 ? -1 : 1;
+		side = fabs(side);
+		
+		value = 2;	// g_rollangle->value;
+
+		if (side < 200 /* g_rollspeed->value */ )
+			side = side * value / 200; // g_rollspeed->value;
+		else
+			side = value;
+		
+		s->angles[ROLL] = (int)(side*sign * 4);
+	}
+#endif
+}
+
+
+/*
+============
+BG_PlayerTouchesItem
+
+Items can be picked up without actually touching their physical bounds
+============
+*/
+qboolean	BG_PlayerTouchesItem( playerState_t *ps, entityState_t *item, int atTime ) {
+	vec3_t		origin;
+
+	EvaluateTrajectory( &item->pos, atTime, origin );
+
+	// we are ignoring ducked differences here
+	if ( ps->origin[0] - origin[0] > 44
+		|| ps->origin[0] - origin[0] < -50
+		|| ps->origin[1] - origin[1] > 36
+		|| ps->origin[1] - origin[1] < -36
+		|| ps->origin[2] - origin[2] > 36
+		|| ps->origin[2] - origin[2] < -36 ) {
+		return qfalse;
+	}
+
+	return qtrue;
+}
+
+
+/*
+=================
+BG_EmplacedView
+
+Shared code for emplaced angle gun constriction
+=================
+*/
+int BG_EmplacedView(vec3_t baseAngles, vec3_t angles, float *newYaw, float constraint)
+{
+	float dif = AngleSubtract(baseAngles[YAW], angles[YAW]);
+
+	if (dif > constraint ||
+		dif < -constraint)
+	{
+		float amt;
+
+		if (dif > constraint)
+		{
+			amt = (dif-constraint);
+			dif = constraint;
+		}
+		else if (dif < -constraint)
+		{
+			amt = (dif+constraint);
+			dif = -constraint;
+		}
+		else
+		{
+			amt = 0.0f;
+		}
+
+		*newYaw = AngleSubtract(angles[YAW], -dif);
+
+		if (amt > 1.0f || amt < -1.0f)
+		{ //significant, force the view
+			return 2;
+		}
+		else
+		{ //just a little out of range
+			return 1;
+		}
+	}
+
+	return 0;
+}
diff --git a/code/game/bg_pangles.cpp b/code/game/bg_pangles.cpp
new file mode 100644
index 0000000..7bc0948
--- /dev/null
+++ b/code/game/bg_pangles.cpp
@@ -0,0 +1,1842 @@
+// this include must remain at the top of every bg_xxxx CPP file
+#include "common_headers.h"
+
+// define GAME_INCLUDE so that g_public.h does not define the
+// short, server-visible gclient_t and gentity_t structures,
+// because we define the full size ones in this file
+#define GAME_INCLUDE
+#include "q_shared.h"
+#include "g_shared.h"
+#include "bg_local.h"
+#include "anims.h"
+#include "wp_saber.h"
+#include "g_vehicles.h"
+#include "../ghoul2/ghoul2_gore.h"
+
+extern void CG_SetClientViewAngles( vec3_t angles, qboolean overrideViewEnt );
+extern qboolean PM_InAnimForSaberMove( int anim, int saberMove );
+extern qboolean PM_InForceGetUp( playerState_t *ps );
+extern qboolean PM_InKnockDown( playerState_t *ps );
+extern qboolean PM_InReboundJump( int anim );
+extern qboolean PM_StabDownAnim( int anim );
+extern qboolean PM_DodgeAnim( int anim );
+extern qboolean PM_DodgeHoldAnim( int anim );
+extern qboolean PM_InReboundHold( int anim );
+extern qboolean PM_InKnockDownNoGetup( playerState_t *ps );
+extern qboolean PM_InGetUpNoRoll( playerState_t *ps );
+extern Vehicle_t *G_IsRidingVehicle( gentity_t *ent );
+extern void WP_ForcePowerDrain( gentity_t *self, forcePowers_t forcePower, int overrideAmt );
+extern qboolean G_ControlledByPlayer( gentity_t *self );
+
+extern qboolean cg_usingInFrontOf;
+extern qboolean		player_locked;
+extern pmove_t		*pm;
+extern pml_t		pml;
+
+extern cvar_t	*g_debugMelee;
+
+
+void BG_IK_MoveLimb( CGhoul2Info_v &ghoul2, int boltIndex, char *animBone, char *firstBone, char *secondBone,
+				   int time, entityState_t *ent, int animFileIndex, int basePose, 
+				   vec3_t desiredPos, qboolean *ikInProgress, vec3_t origin, 
+				   vec3_t angles, vec3_t scale, int blendTime, qboolean forceHalt )
+{
+	mdxaBone_t holdPointMatrix;
+	vec3_t holdPoint;
+	vec3_t torg;
+	float distToDest;
+	animation_t	*anim = &level.knownAnimFileSets[animFileIndex].animations[basePose];
+
+	assert( ghoul2.size() );
+
+	assert( anim->firstFrame > 0 );//FIXME: umm...?
+
+	if ( !*ikInProgress && !forceHalt )
+	{
+		sharedSetBoneIKStateParams_t ikP;
+
+		//restrict the shoulder joint
+		//VectorSet(ikP.pcjMins,-50.0f,-80.0f,-15.0f);
+		//VectorSet(ikP.pcjMaxs,15.0f,40.0f,15.0f);
+
+		//for now, leaving it unrestricted, but restricting elbow joint.
+		//This lets us break the arm however we want in order to fling people
+		//in throws, and doesn't look bad.
+		VectorSet( ikP.pcjMins, 0, 0, 0 );
+		VectorSet( ikP.pcjMaxs, 0, 0, 0 );
+
+		//give the info on our entity.
+		ikP.blendTime = blendTime;
+		VectorCopy( origin, ikP.origin );
+		VectorCopy( angles, ikP.angles );
+		ikP.angles[PITCH] = 0;
+		ikP.pcjOverrides = 0;
+		ikP.radius = 10.0f;
+		VectorCopy( scale, ikP.scale );
+		
+		//base pose frames for the limb
+		ikP.startFrame = anim->firstFrame + anim->numFrames;
+		ikP.endFrame = anim->firstFrame + anim->numFrames;
+
+		//ikP.forceAnimOnBone = qfalse; //let it use existing anim if it's the same as this one.
+
+		//we want to call with a null bone name first. This will init all of the
+		//ik system stuff on the g2 instance, because we need ragdoll effectors
+		//in order for our pcj's to know how to angle properly.
+		if ( !gi.G2API_SetBoneIKState( ghoul2, time, NULL, IKS_DYNAMIC, &ikP ) )
+		{
+			assert( !"Failed to init IK system for g2 instance!" );
+		}
+
+		//Now, create our IK bone state.
+		if ( gi.G2API_SetBoneIKState( ghoul2, time, "lower_lumbar", IKS_DYNAMIC, &ikP ) )
+		{
+			//restrict the elbow joint
+			VectorSet( ikP.pcjMins, -90.0f, -20.0f, -20.0f );
+			VectorSet( ikP.pcjMaxs, 30.0f, 20.0f, -20.0f );
+			if ( gi.G2API_SetBoneIKState( ghoul2, time, "upper_lumbar", IKS_DYNAMIC, &ikP ) )
+			{
+				//restrict the elbow joint
+				VectorSet( ikP.pcjMins, -90.0f, -20.0f, -20.0f );
+				VectorSet( ikP.pcjMaxs, 30.0f, 20.0f, -20.0f );
+				if ( gi.G2API_SetBoneIKState( ghoul2, time, "thoracic", IKS_DYNAMIC, &ikP ) )
+				{
+					//restrict the elbow joint
+					VectorSet( ikP.pcjMins, -90.0f, -20.0f, -20.0f );
+					VectorSet( ikP.pcjMaxs, 30.0f, 20.0f, -20.0f );
+					if ( gi.G2API_SetBoneIKState( ghoul2, time, secondBone, IKS_DYNAMIC, &ikP ) )
+					{
+						//restrict the elbow joint
+						VectorSet( ikP.pcjMins, -90.0f, -20.0f, -20.0f );
+						VectorSet( ikP.pcjMaxs, 30.0f, 20.0f, -20.0f );
+
+						if ( gi.G2API_SetBoneIKState( ghoul2, time, firstBone, IKS_DYNAMIC, &ikP ) )
+						{ //everything went alright.
+							*ikInProgress = qtrue;
+						}
+					}
+				}
+			}
+		}
+	}
+
+	if ( *ikInProgress && !forceHalt )
+	{ //actively update our ik state.
+		sharedIKMoveParams_t ikM;
+		CRagDollUpdateParams tuParms;
+		vec3_t tAngles;
+
+		//set the argument struct up
+		VectorCopy( desiredPos, ikM.desiredOrigin ); //we want the bone to move here.. if possible
+
+		VectorCopy( angles, tAngles );
+		tAngles[PITCH] = tAngles[ROLL] = 0;
+
+		gi.G2API_GetBoltMatrix( ghoul2, 0, boltIndex, &holdPointMatrix, tAngles, origin, time, 0, scale );
+		//Get the point position from the matrix.
+		holdPoint[0] = holdPointMatrix.matrix[0][3];
+		holdPoint[1] = holdPointMatrix.matrix[1][3];
+		holdPoint[2] = holdPointMatrix.matrix[2][3];
+
+		VectorSubtract( holdPoint, desiredPos, torg );
+		distToDest = VectorLength( torg );
+
+		//closer we are, more we want to keep updated.
+		//if we're far away we don't want to be too fast or we'll start twitching all over.
+		if ( distToDest < 2 )
+		{ //however if we're this close we want very precise movement
+			ikM.movementSpeed = 0.4f;
+		}
+		else if ( distToDest < 16 )
+		{
+			ikM.movementSpeed = 0.9f;//8.0f;
+		}
+		else if ( distToDest < 32 )
+		{
+			ikM.movementSpeed = 0.8f;//4.0f;
+		}
+		else if ( distToDest < 64 )
+		{
+			ikM.movementSpeed = 0.7f;//2.0f;
+		}
+		else
+		{
+			ikM.movementSpeed = 0.6f;
+		}
+		VectorCopy( origin, ikM.origin ); //our position in the world.
+
+		ikM.boneName[0] = 0;
+		if ( gi.G2API_IKMove( ghoul2, time, &ikM ) )
+		{
+			//now do the standard model animate stuff with ragdoll update params.
+			VectorCopy( angles, tuParms.angles );
+			tuParms.angles[PITCH] = 0;
+
+			VectorCopy( origin, tuParms.position );
+			VectorCopy( scale, tuParms.scale );
+
+			tuParms.me = ent->number;
+			VectorClear( tuParms.velocity );
+
+			gi.G2API_AnimateG2Models( ghoul2, time, &tuParms );
+		}
+		else
+		{
+			*ikInProgress = qfalse;
+		}
+	}
+	else if ( *ikInProgress )
+	{ //kill it
+		float cFrame, animSpeed;
+		int sFrame, eFrame, flags;
+
+		gi.G2API_SetBoneIKState( ghoul2, time, "lower_lumbar", IKS_NONE, NULL );
+		gi.G2API_SetBoneIKState( ghoul2, time, "upper_lumbar", IKS_NONE, NULL );
+		gi.G2API_SetBoneIKState( ghoul2, time, "thoracic", IKS_NONE, NULL );
+		gi.G2API_SetBoneIKState( ghoul2, time, secondBone, IKS_NONE, NULL );
+		gi.G2API_SetBoneIKState( ghoul2, time, firstBone, IKS_NONE, NULL );
+		
+		//then reset the angles/anims on these PCJs
+		gi.G2API_SetBoneAngles( &ghoul2[0], "lower_lumbar", vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, NULL, 0, time );
+		gi.G2API_SetBoneAngles( &ghoul2[0], "upper_lumbar", vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, NULL, 0, time );
+		gi.G2API_SetBoneAngles( &ghoul2[0], "thoracic", vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, NULL, 0, time );
+		gi.G2API_SetBoneAngles( &ghoul2[0], secondBone, vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, NULL, 0, time );
+		gi.G2API_SetBoneAngles( &ghoul2[0], firstBone, vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, NULL, 0, time );
+
+		//Get the anim/frames that the pelvis is on exactly, and match the left arm back up with them again.
+		gi.G2API_GetBoneAnim( &ghoul2[0], animBone, (const int)time, &cFrame, &sFrame, &eFrame, &flags, &animSpeed, 0 );
+		gi.G2API_SetBoneAnim( &ghoul2[0], "lower_lumbar", sFrame, eFrame, flags, animSpeed, time, sFrame, 300 );
+		gi.G2API_SetBoneAnim( &ghoul2[0], "upper_lumbar", sFrame, eFrame, flags, animSpeed, time, sFrame, 300 );
+		gi.G2API_SetBoneAnim( &ghoul2[0], "thoracic", sFrame, eFrame, flags, animSpeed, time, sFrame, 300 );
+		gi.G2API_SetBoneAnim( &ghoul2[0], secondBone, sFrame, eFrame, flags, animSpeed, time, sFrame, 300 );
+		gi.G2API_SetBoneAnim( &ghoul2[0], firstBone, sFrame, eFrame, flags, animSpeed, time, sFrame, 300 );
+
+		//And finally, get rid of all the ik state effector data by calling with null bone name (similar to how we init it).
+		gi.G2API_SetBoneIKState( ghoul2, time, NULL, IKS_NONE, NULL );
+		
+		*ikInProgress = qfalse;
+	}
+}
+
+void PM_IKUpdate( gentity_t *ent )
+{
+	//The bone we're holding them by and the next bone after that
+	char *animBone = "lower_lumbar";
+	char *firstBone = "lradius";
+	char *secondBone = "lhumerus";
+	char *defaultBoltName = "*r_hand";
+
+	if ( !ent->client )
+	{
+		return;
+	}
+	if ( ent->client->ps.heldByClient <= ENTITYNUM_WORLD )
+	{ //then put our arm in this client's hand
+		gentity_t *holder = &g_entities[ent->client->ps.heldByClient];
+
+		if ( holder && holder->inuse && holder->client && holder->ghoul2.size())
+		{
+			if ( !ent->client->ps.heldByBolt )
+			{//bolt wan't set
+				ent->client->ps.heldByBolt = gi.G2API_AddBolt( &holder->ghoul2[0], defaultBoltName );
+			}
+		}
+		else
+		{ //they're gone, stop holding me
+			ent->client->ps.heldByClient = 0;
+			return;
+		}
+
+		if ( ent->client->ps.heldByBolt )
+		{
+			mdxaBone_t boltMatrix;
+			vec3_t boltOrg;
+			vec3_t tAngles;
+
+			VectorCopy( holder->client->ps.viewangles, tAngles );
+			tAngles[PITCH] = tAngles[ROLL] = 0;
+
+			gi.G2API_GetBoltMatrix( holder->ghoul2, 0, ent->client->ps.heldByBolt, &boltMatrix, tAngles, holder->client->ps.origin, level.time, 0, holder->s.modelScale );
+			gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, boltOrg );
+
+			int grabbedByBolt = gi.G2API_AddBolt( &ent->ghoul2[0], firstBone );
+			if ( grabbedByBolt )
+			{
+				//point the limb
+				BG_IK_MoveLimb( ent->ghoul2, grabbedByBolt, animBone, firstBone, secondBone,
+					level.time, &ent->s, ent->client->clientInfo.animFileIndex, 
+					ent->client->ps.torsoAnim/*BOTH_DEAD1*/, boltOrg, &ent->client->ps.ikStatus,
+					ent->client->ps.origin, ent->client->ps.viewangles, ent->s.modelScale, 
+					500, qfalse );
+
+				//now see if we need to be turned and/or pulled
+				vec3_t grabDiff, grabbedByOrg;
+
+				VectorCopy( ent->client->ps.viewangles, tAngles );
+				tAngles[PITCH] = tAngles[ROLL] = 0;
+
+				gi.G2API_GetBoltMatrix( ent->ghoul2, 0, grabbedByBolt, &boltMatrix, tAngles, ent->client->ps.origin, level.time, 0, ent->s.modelScale );
+				gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, grabbedByOrg );
+				
+				//check for turn
+				vec3_t org2Targ, org2Bolt;
+				VectorSubtract( boltOrg, ent->currentOrigin, org2Targ );
+				float org2TargYaw = vectoyaw( org2Targ );
+				VectorSubtract( grabbedByOrg, ent->currentOrigin, org2Bolt );
+				float org2BoltYaw = vectoyaw( org2Bolt );
+				if ( org2TargYaw-1.0f > org2BoltYaw )
+				{
+					ent->currentAngles[YAW]++;
+					G_SetAngles( ent, ent->currentAngles );
+				}
+				else if ( org2TargYaw+1.0f < org2BoltYaw )
+				{
+					ent->currentAngles[YAW]--;
+					G_SetAngles( ent, ent->currentAngles );
+				}
+
+				//check for pull
+				VectorSubtract( boltOrg, grabbedByOrg, grabDiff );
+				if ( VectorLength( grabDiff ) > 128.0f )
+				{//too far, release me
+					ent->client->ps.heldByClient = holder->client->ps.heldClient = ENTITYNUM_NONE;
+				}
+				else if ( 1 )
+				{//pull me along
+					trace_t trace;
+					vec3_t destOrg;
+					VectorAdd( ent->currentOrigin, grabDiff, destOrg );
+					gi.trace( &trace, ent->currentOrigin, ent->mins, ent->maxs, destOrg, ent->s.number, (ent->clipmask&~holder->contents) );
+					G_SetOrigin( ent, trace.endpos );
+					//FIXME: better yet: do an actual slidemove to the new pos?
+					//FIXME: if I'm alive, just tell me to walk some?
+				}
+				//FIXME: if I need to turn to keep my bone facing him, do so...
+			}
+			//don't let us fall?
+			VectorClear( ent->client->ps.velocity );
+			//FIXME: also make the holder point his holding limb at you?
+		}
+	}
+	else if ( ent->client->ps.ikStatus )
+	{ //make sure we aren't IKing if we don't have anyone to hold onto us.
+		if ( ent && ent->inuse && ent->client && ent->ghoul2.size() )
+		{
+			if ( !ent->client->ps.heldByBolt )
+			{
+				ent->client->ps.heldByBolt = gi.G2API_AddBolt( &ent->ghoul2[0], defaultBoltName );
+			}
+		}
+		else
+		{ //This shouldn't happen, but just in case it does, we'll have a failsafe.
+			ent->client->ps.heldByBolt = 0;
+			ent->client->ps.ikStatus = qfalse;
+		}
+
+		if ( ent->client->ps.heldByBolt )
+		{
+			BG_IK_MoveLimb( ent->ghoul2, ent->client->ps.heldByBolt, animBone, firstBone, secondBone,
+				level.time, &ent->s, ent->client->clientInfo.animFileIndex, 
+				ent->client->ps.torsoAnim/*BOTH_DEAD1*/, (float *)vec3_origin, 
+				&ent->client->ps.ikStatus, ent->client->ps.origin, 
+				ent->client->ps.viewangles, ent->s.modelScale, 500, qtrue );
+		}
+	}
+}
+
+
+void BG_G2SetBoneAngles( centity_t *cent, gentity_t *gent, int boneIndex, const vec3_t angles, const int flags,
+							 const Eorientations up, const Eorientations right, const Eorientations forward, qhandle_t *modelList )
+{
+	if (boneIndex!=-1)
+	{
+		gi.G2API_SetBoneAnglesIndex( &cent->gent->ghoul2[0], boneIndex, angles, flags, up, right, forward, modelList ); 
+	}
+}
+
+#define	MAX_YAWSPEED_X_WING		1
+#define	MAX_PITCHSPEED_X_WING	1
+void PM_ScaleUcmd( playerState_t *ps, usercmd_t *cmd, gentity_t *gent )
+{
+	if ( G_IsRidingVehicle( gent ) )
+	{//driving a vehicle
+		//clamp the turn rate
+		int maxPitchSpeed = MAX_PITCHSPEED_X_WING;//switch, eventually?  Or read from file?
+		int diff = AngleNormalize180(SHORT2ANGLE((cmd->angles[PITCH]+ps->delta_angles[PITCH]))) - floor(ps->viewangles[PITCH]);
+	
+		if ( diff > maxPitchSpeed )
+		{
+			cmd->angles[PITCH] = ANGLE2SHORT( ps->viewangles[PITCH] + maxPitchSpeed ) - ps->delta_angles[PITCH];
+		}
+		else if ( diff < -maxPitchSpeed )
+		{
+			cmd->angles[PITCH] = ANGLE2SHORT( ps->viewangles[PITCH] - maxPitchSpeed ) - ps->delta_angles[PITCH];
+		}
+
+		//Um, WTF?  When I turn in a certain direction, I start going backwards?  Or strafing?
+		int maxYawSpeed = MAX_YAWSPEED_X_WING;//switch, eventually?  Or read from file?
+		diff = AngleNormalize180(SHORT2ANGLE(cmd->angles[YAW]+ps->delta_angles[YAW]) - floor(ps->viewangles[YAW]));
+
+		//clamp the turn rate
+		if ( diff > maxYawSpeed )
+		{
+			cmd->angles[YAW] = ANGLE2SHORT( ps->viewangles[YAW] + maxYawSpeed ) - ps->delta_angles[YAW];
+		}
+		else if ( diff < -maxYawSpeed )
+		{
+			cmd->angles[YAW] = ANGLE2SHORT( ps->viewangles[YAW] - maxYawSpeed ) - ps->delta_angles[YAW];
+		}
+	}
+}
+
+extern void SetClientViewAngle( gentity_t *ent, vec3_t angle );
+qboolean PM_LockAngles( gentity_t *ent, usercmd_t *ucmd )
+{
+	if ( ent->client->ps.viewEntity <= 0 || ent->client->ps.viewEntity >= ENTITYNUM_WORLD )
+	{//don't clamp angles when looking through a viewEntity
+		SetClientViewAngle( ent, ent->client->ps.viewangles );
+	}
+	ucmd->angles[PITCH] = ANGLE2SHORT( ent->client->ps.viewangles[PITCH] ) - ent->client->ps.delta_angles[PITCH];
+	ucmd->angles[YAW] = ANGLE2SHORT( ent->client->ps.viewangles[YAW] ) - ent->client->ps.delta_angles[YAW];
+	return qtrue;
+}
+
+qboolean PM_AdjustAnglesToGripper( gentity_t *ent, usercmd_t *ucmd )
+{//FIXME: make this more generic and have it actually *tell* the client what cmd angles it should be locked at?
+	if ( ((ent->client->ps.eFlags&EF_FORCE_GRIPPED)||(ent->client->ps.eFlags&EF_FORCE_DRAINED)) && ent->enemy )
+	{
+		vec3_t dir, angles;
+
+		VectorSubtract( ent->enemy->currentOrigin, ent->currentOrigin, dir );
+		vectoangles( dir, angles );
+		angles[PITCH] = AngleNormalize180( angles[PITCH] );
+		angles[YAW] = AngleNormalize180( angles[YAW] );
+		if ( ent->client->ps.viewEntity <= 0 || ent->client->ps.viewEntity >= ENTITYNUM_WORLD )
+		{//don't clamp angles when looking through a viewEntity
+			SetClientViewAngle( ent, angles );
+		}
+		ucmd->angles[PITCH] = ANGLE2SHORT(angles[PITCH]) - ent->client->ps.delta_angles[PITCH];
+		ucmd->angles[YAW] = ANGLE2SHORT(angles[YAW]) - ent->client->ps.delta_angles[YAW];
+		return qtrue;
+	}
+	return qfalse;
+}
+
+qboolean PM_AdjustAnglesToPuller( gentity_t *ent, gentity_t *puller, usercmd_t *ucmd, qboolean faceAway )
+{//FIXME: make this more generic and have it actually *tell* the client what cmd angles it should be locked at?
+	vec3_t dir, angles;
+
+	VectorSubtract( puller->currentOrigin, ent->currentOrigin, dir );
+	vectoangles( dir, angles );
+	angles[PITCH] = AngleNormalize180( angles[PITCH] );
+	if ( faceAway )
+	{
+		angles[YAW] += 180;
+	}
+	angles[YAW] = AngleNormalize180( angles[YAW] );
+	if ( ent->client->ps.viewEntity <= 0 || ent->client->ps.viewEntity >= ENTITYNUM_WORLD )
+	{//don't clamp angles when looking through a viewEntity
+		SetClientViewAngle( ent, angles );
+	}
+	ucmd->angles[PITCH] = ANGLE2SHORT(angles[PITCH]) - ent->client->ps.delta_angles[PITCH];
+	ucmd->angles[YAW] = ANGLE2SHORT(angles[YAW]) - ent->client->ps.delta_angles[YAW];
+	return qtrue;
+}
+
+qboolean PM_AdjustAngleForWallRun( gentity_t *ent, usercmd_t *ucmd, qboolean doMove )
+{
+	if (( ent->client->ps.legsAnim == BOTH_WALL_RUN_RIGHT || ent->client->ps.legsAnim == BOTH_WALL_RUN_LEFT ) && ent->client->ps.legsAnimTimer > 500 )
+	{//wall-running and not at end of anim 
+		//stick to wall, if there is one
+		vec3_t	fwd, rt, traceTo, mins = {ent->mins[0],ent->mins[1],0}, maxs = {ent->maxs[0],ent->maxs[1],24}, fwdAngles = {0, ent->client->ps.viewangles[YAW], 0};		
+		trace_t	trace;
+		float	dist, yawAdjust=0.0f;
+
+		AngleVectors( fwdAngles, fwd, rt, NULL );
+
+		if ( ent->client->ps.legsAnim == BOTH_WALL_RUN_RIGHT )
+		{
+			dist = 128;
+			yawAdjust = -90;
+		}
+		else
+		{
+			dist = -128;
+			yawAdjust = 90;
+		}
+		VectorMA( ent->currentOrigin, dist, rt, traceTo );
+		gi.trace( &trace, ent->currentOrigin, mins, maxs, traceTo, ent->s.number, ent->clipmask );
+		if ( trace.fraction < 1.0f 
+			&& (trace.plane.normal[2] >= 0.0f && trace.plane.normal[2] <= 0.4f) )//&& ent->client->ps.groundEntityNum == ENTITYNUM_NONE )
+		{
+			trace_t	trace2;
+			vec3_t traceTo2;
+			vec3_t	wallRunFwd, wallRunAngles = {0};
+			
+			wallRunAngles[YAW] = vectoyaw( trace.plane.normal )+yawAdjust;
+			AngleVectors( wallRunAngles, wallRunFwd, NULL, NULL );
+
+			VectorMA( ent->currentOrigin, 32, wallRunFwd, traceTo2 );
+			gi.trace( &trace2, ent->currentOrigin, mins, maxs, traceTo2, ent->s.number, ent->clipmask );
+			if ( trace2.fraction < 1.0f && DotProduct( trace2.plane.normal, wallRunFwd ) <= -0.999f )
+			{//wall we can't run on in front of us
+				trace.fraction = 1.0f;//just a way to get it to kick us off the wall below
+			}
+		} 
+		if ( trace.fraction < 1.0f 
+			&& (trace.plane.normal[2] >= 0.0f && trace.plane.normal[2] <= 0.4f) )//&& ent->client->ps.groundEntityNum == ENTITYNUM_NONE )
+		{//still a vertical wall there
+			//FIXME: don't pull around 90 turns
+			//FIXME: simulate stepping up steps here, somehow?
+			if ( (ent->s.number>=MAX_CLIENTS&&!G_ControlledByPlayer(ent)) || !player_locked )
+			{
+				if ( ent->client->ps.legsAnim == BOTH_WALL_RUN_RIGHT )
+				{
+					ucmd->rightmove = 127;
+				}
+				else
+				{
+					ucmd->rightmove = -127;
+				}
+			}
+			if ( ucmd->upmove < 0 )
+			{
+				ucmd->upmove = 0;
+			}
+			if ( ent->NPC )
+			{//invalid now
+				VectorClear( ent->client->ps.moveDir );
+			}
+			//make me face perpendicular to the wall
+			ent->client->ps.viewangles[YAW] = vectoyaw( trace.plane.normal )+yawAdjust;
+			if ( ent->client->ps.viewEntity <= 0 || ent->client->ps.viewEntity >= ENTITYNUM_WORLD )
+			{//don't clamp angles when looking through a viewEntity
+				SetClientViewAngle( ent, ent->client->ps.viewangles );
+			}
+			ucmd->angles[YAW] = ANGLE2SHORT( ent->client->ps.viewangles[YAW] ) - ent->client->ps.delta_angles[YAW];
+			if ( (ent->s.number&&!G_ControlledByPlayer(ent)) || !player_locked )
+			{
+				if ( doMove )
+				{
+					//push me forward
+					float	zVel = ent->client->ps.velocity[2];
+					if ( zVel > forceJumpStrength[FORCE_LEVEL_2]/2.0f )
+					{
+						zVel = forceJumpStrength[FORCE_LEVEL_2]/2.0f;
+					}
+					//pull me toward the wall
+					VectorScale( trace.plane.normal, -128, ent->client->ps.velocity );
+					if ( ent->client->ps.legsAnimTimer > 500 ) 
+					{//not at end of anim yet, pushing forward
+						//FIXME: or MA?
+						float speed = 175;
+						if ( ucmd->forwardmove < 0 )
+						{//slower
+							speed = 100;
+						}
+						else if ( ucmd->forwardmove > 0 )
+						{
+							speed = 250;//running speed
+						}
+						VectorMA( ent->client->ps.velocity, speed, fwd, ent->client->ps.velocity );
+					} 
+					ent->client->ps.velocity[2] = zVel;//preserve z velocity
+					//VectorMA( ent->client->ps.velocity, -128, trace.plane.normal, ent->client->ps.velocity );
+					//pull me toward the wall, too
+					//VectorMA( ent->client->ps.velocity, dist, rt, ent->client->ps.velocity );
+				}
+			}
+			ucmd->forwardmove = 0;
+			return qtrue;
+		}
+		else if ( doMove )
+		{//stop it
+			if ( ent->client->ps.legsAnim == BOTH_WALL_RUN_RIGHT )
+			{
+				NPC_SetAnim( ent, SETANIM_BOTH, BOTH_WALL_RUN_RIGHT_STOP, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+			}
+			else if ( ent->client->ps.legsAnim == BOTH_WALL_RUN_LEFT )
+			{
+				NPC_SetAnim( ent, SETANIM_BOTH, BOTH_WALL_RUN_LEFT_STOP, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+			}
+		}
+	}
+	return qfalse;
+}
+
+extern int PM_AnimLength( int index, animNumber_t anim );
+qboolean PM_AdjustAnglesForSpinningFlip( gentity_t *ent, usercmd_t *ucmd, qboolean anglesOnly )
+{
+	vec3_t	newAngles;
+	float	animLength, spinStart, spinEnd, spinAmt, spinLength;
+	animNumber_t	spinAnim;
+
+	if ( ent->client->ps.legsAnim == BOTH_JUMPFLIPSTABDOWN )
+	{
+		spinAnim = BOTH_JUMPFLIPSTABDOWN;
+		spinStart = 300.0f;//700.0f;
+		spinEnd = 1400.0f;
+		spinAmt = 180.0f;
+	}
+	else if ( ent->client->ps.legsAnim == BOTH_JUMPFLIPSLASHDOWN1 )
+	{
+		spinAnim = BOTH_JUMPFLIPSLASHDOWN1;
+		spinStart = 300.0f;//700.0f;//1500.0f;
+		spinEnd = 1400.0f;//2300.0f;
+		spinAmt = 180.0f;
+	}
+	else
+	{
+		if ( !anglesOnly )
+		{
+			if ( (ent->s.number<MAX_CLIENTS||G_ControlledByPlayer(ent)) )
+			{
+				cg.overrides.active &= ~CG_OVERRIDE_3RD_PERSON_VOF;
+				cg.overrides.thirdPersonVertOffset = 0;
+			}
+		}
+		return qfalse;
+	}
+	animLength = PM_AnimLength( ent->client->clientInfo.animFileIndex, spinAnim );
+	float elapsedTime = (float)(animLength-ent->client->ps.legsAnimTimer);
+	//face me
+	if ( elapsedTime >= spinStart && elapsedTime <= spinEnd )
+	{
+		spinLength = spinEnd - spinStart;
+		VectorCopy( ent->client->ps.viewangles, newAngles );
+		newAngles[YAW] = ent->angle + (spinAmt * (elapsedTime-spinStart) / spinLength);
+		if ( ent->client->ps.viewEntity <= 0 || ent->client->ps.viewEntity >= ENTITYNUM_WORLD )
+		{//don't clamp angles when looking through a viewEntity
+			SetClientViewAngle( ent, newAngles );
+		}
+		ucmd->angles[PITCH] = ANGLE2SHORT( ent->client->ps.viewangles[PITCH] ) - ent->client->ps.delta_angles[PITCH];
+		ucmd->angles[YAW] = ANGLE2SHORT( ent->client->ps.viewangles[YAW] ) - ent->client->ps.delta_angles[YAW];
+		if ( anglesOnly )
+		{
+			return qtrue;
+		}
+	}
+	else if ( anglesOnly )
+	{
+		return qfalse;
+	}
+	//push me
+	if ( ent->client->ps.legsAnimTimer > 300 )//&& ent->client->ps.groundEntityNum == ENTITYNUM_NONE )
+	{//haven't landed or reached end of anim yet
+		if ( (ent->s.number>=MAX_CLIENTS&&!G_ControlledByPlayer(ent)) || !player_locked )
+		{
+			vec3_t pushDir, pushAngles = {0,ent->angle,0};
+			AngleVectors( pushAngles, pushDir, NULL, NULL );
+			if ( DotProduct( ent->client->ps.velocity, pushDir ) < 100 )
+			{
+				VectorMA( ent->client->ps.velocity, 10, pushDir, ent->client->ps.velocity );
+			}
+		}
+	}
+	//do a dip in the view
+	if ( (ent->s.number<MAX_CLIENTS||G_ControlledByPlayer(ent)) )
+	{
+		float viewDip = 0;
+		if ( elapsedTime < animLength/2.0f )
+		{//starting anim
+			viewDip = (elapsedTime/animLength)*-120.0f;
+		}
+		else
+		{//ending anim
+			viewDip = ((animLength-elapsedTime)/animLength)*-120.0f;
+		}
+		cg.overrides.active |= CG_OVERRIDE_3RD_PERSON_VOF;
+		cg.overrides.thirdPersonVertOffset = cg_thirdPersonVertOffset.value+viewDip;
+		//pm->ps->viewheight = standheight + viewDip;
+	}
+	return qtrue;
+}
+
+qboolean PM_AdjustAnglesForBackAttack( gentity_t *ent, usercmd_t *ucmd )
+{
+	if ( (ent->s.number>=MAX_CLIENTS&&!G_ControlledByPlayer(ent)) )
+	{
+		return qfalse;
+	}
+	if ( ( ent->client->ps.saberMove == LS_A_BACK || ent->client->ps.saberMove == LS_A_BACK_CR || ent->client->ps.saberMove == LS_A_BACKSTAB )
+		&& PM_InAnimForSaberMove( ent->client->ps.torsoAnim, ent->client->ps.saberMove ) )
+	{
+		if ( ent->client->ps.saberMove != LS_A_BACKSTAB || !ent->enemy || (ent->s.number>=MAX_CLIENTS&&!G_ControlledByPlayer(ent)) )
+		{
+			if ( ent->client->ps.viewEntity <= 0 || ent->client->ps.viewEntity >= ENTITYNUM_WORLD )
+			{//don't clamp angles when looking through a viewEntity
+				SetClientViewAngle( ent, ent->client->ps.viewangles );
+			}
+			ucmd->angles[PITCH] = ANGLE2SHORT( ent->client->ps.viewangles[PITCH] ) - ent->client->ps.delta_angles[PITCH];
+			ucmd->angles[YAW] = ANGLE2SHORT( ent->client->ps.viewangles[YAW] ) - ent->client->ps.delta_angles[YAW];
+		}
+		else 
+		{//keep player facing away from their enemy
+			vec3_t enemyBehindDir;
+			VectorSubtract( ent->currentOrigin, ent->enemy->currentOrigin, enemyBehindDir );
+			float enemyBehindYaw = AngleNormalize180( vectoyaw( enemyBehindDir ) );
+			float yawError = AngleNormalize180( enemyBehindYaw - AngleNormalize180( ent->client->ps.viewangles[YAW] ) );
+			if ( yawError > 1 )
+			{
+				yawError = 1;
+			}
+			else if ( yawError < -1 )
+			{
+				yawError = -1;
+			}
+			ucmd->angles[YAW] = ANGLE2SHORT( AngleNormalize180( ent->client->ps.viewangles[YAW] + yawError ) ) - ent->client->ps.delta_angles[YAW];
+			ucmd->angles[PITCH] = ANGLE2SHORT( ent->client->ps.viewangles[PITCH] ) - ent->client->ps.delta_angles[PITCH];
+		}
+		return qtrue;
+	}
+	return qfalse;
+}
+
+qboolean PM_AdjustAnglesForSaberLock( gentity_t *ent, usercmd_t *ucmd )
+{
+	if ( ent->client->ps.saberLockTime > level.time )
+	{
+		if ( ent->client->ps.viewEntity <= 0 || ent->client->ps.viewEntity >= ENTITYNUM_WORLD )
+		{//don't clamp angles when looking through a viewEntity
+			SetClientViewAngle( ent, ent->client->ps.viewangles );
+		}
+		ucmd->angles[PITCH] = ANGLE2SHORT( ent->client->ps.viewangles[PITCH] ) - ent->client->ps.delta_angles[PITCH];
+		ucmd->angles[YAW] = ANGLE2SHORT( ent->client->ps.viewangles[YAW] ) - ent->client->ps.delta_angles[YAW];
+		return qtrue;
+	}
+	return qfalse;
+}
+
+int G_MinGetUpTime( gentity_t *ent )
+{
+	if ( ent 
+		&& ent->client 
+		&& ( ent->client->ps.legsAnim == BOTH_PLAYER_PA_3_FLY
+			|| ent->client->ps.legsAnim == BOTH_LK_DL_ST_T_SB_1_L
+			|| ent->client->ps.legsAnim == BOTH_RELEASED ) )
+	{//special cases
+		return 200;
+	}
+	else if ( ent && ent->client && ent->client->NPC_class == CLASS_ALORA )
+	{//alora springs up very quickly from knockdowns!
+		return 1000;
+	}
+	else if ( (ent->s.clientNum < MAX_CLIENTS||G_ControlledByPlayer(ent)) )
+	{//player can get up faster based on his/her force jump skill
+		int getUpTime = PLAYER_KNOCKDOWN_HOLD_EXTRA_TIME;
+		if ( ent->client->ps.forcePowerLevel[FP_LEVITATION] >= FORCE_LEVEL_3 )
+		{
+			return (getUpTime+400);//750
+		}
+		else if ( ent->client->ps.forcePowerLevel[FP_LEVITATION] == FORCE_LEVEL_2 )
+		{
+			return (getUpTime+200);//500
+		}
+		else if ( ent->client->ps.forcePowerLevel[FP_LEVITATION] == FORCE_LEVEL_1 )
+		{
+			return (getUpTime+100);//250
+		}
+		else
+		{
+			return getUpTime;
+		}
+	}
+	return 200;
+}
+
+qboolean PM_AdjustAnglesForKnockdown( gentity_t *ent, usercmd_t *ucmd, qboolean angleClampOnly )
+{
+	if ( PM_InKnockDown( &ent->client->ps ) )
+	{//being knocked down or getting up, can't do anything!
+		if ( !angleClampOnly )
+		{
+			if ( ent->client->ps.legsAnimTimer > G_MinGetUpTime( ent ) 
+				|| (ent->s.number >= MAX_CLIENTS&&!G_ControlledByPlayer(ent)) )
+			{//can't get up yet
+				ucmd->forwardmove = 0;
+				ucmd->rightmove = 0;
+			}
+			if ( ent->NPC )
+			{
+				VectorClear( ent->client->ps.moveDir );
+			}
+			//you can jump up out of a knockdown and you get get up into a crouch from a knockdown
+			//ucmd->upmove = 0;
+			//if ( !PM_InForceGetUp( &ent->client->ps ) || ent->client->ps.torsoAnimTimer > 800 || ent->s.weapon != WP_SABER )
+			if ( ent->health > 0 )
+			{//can only attack if you've started a force-getup and are using the saber
+				ucmd->buttons = 0;
+			}
+		}
+		if ( !PM_InForceGetUp( &ent->client->ps ) )
+		{//can't turn unless in a force getup
+			if ( ent->client->ps.viewEntity <= 0 || ent->client->ps.viewEntity >= ENTITYNUM_WORLD )
+			{//don't clamp angles when looking through a viewEntity
+				SetClientViewAngle( ent, ent->client->ps.viewangles );
+			}
+			ucmd->angles[PITCH] = ANGLE2SHORT( ent->client->ps.viewangles[PITCH] ) - ent->client->ps.delta_angles[PITCH];
+			ucmd->angles[YAW] = ANGLE2SHORT( ent->client->ps.viewangles[YAW] ) - ent->client->ps.delta_angles[YAW];
+			return qtrue;
+		}
+	}
+	return qfalse;
+}
+
+qboolean PM_AdjustAnglesForDualJumpAttack( gentity_t *ent, usercmd_t *ucmd )
+{
+	if ( ent->client->ps.viewEntity <= 0 || ent->client->ps.viewEntity >= ENTITYNUM_WORLD )
+	{//don't clamp angles when looking through a viewEntity
+		SetClientViewAngle( ent, ent->client->ps.viewangles );
+	}
+	ucmd->angles[PITCH] = ANGLE2SHORT( ent->client->ps.viewangles[PITCH] ) - ent->client->ps.delta_angles[PITCH];
+	ucmd->angles[YAW] = ANGLE2SHORT( ent->client->ps.viewangles[YAW] ) - ent->client->ps.delta_angles[YAW];
+	return qtrue;
+}
+
+qboolean PM_AdjustAnglesForLongJump( gentity_t *ent, usercmd_t *ucmd )
+{
+	if ( ent->client->ps.viewEntity <= 0 || ent->client->ps.viewEntity >= ENTITYNUM_WORLD )
+	{//don't clamp angles when looking through a viewEntity
+		SetClientViewAngle( ent, ent->client->ps.viewangles );
+	}
+	ucmd->angles[PITCH] = ANGLE2SHORT( ent->client->ps.viewangles[PITCH] ) - ent->client->ps.delta_angles[PITCH];
+	ucmd->angles[YAW] = ANGLE2SHORT( ent->client->ps.viewangles[YAW] ) - ent->client->ps.delta_angles[YAW];
+	return qtrue;
+}
+
+qboolean PM_AdjustAnglesForGrapple( gentity_t *ent, usercmd_t *ucmd )
+{
+	if ( ent->client->ps.viewEntity <= 0 || ent->client->ps.viewEntity >= ENTITYNUM_WORLD )
+	{//don't clamp angles when looking through a viewEntity
+		SetClientViewAngle( ent, ent->client->ps.viewangles );
+	}
+	ucmd->angles[PITCH] = ANGLE2SHORT( ent->client->ps.viewangles[PITCH] ) - ent->client->ps.delta_angles[PITCH];
+	ucmd->angles[YAW] = ANGLE2SHORT( ent->client->ps.viewangles[YAW] ) - ent->client->ps.delta_angles[YAW];
+	return qtrue;
+}
+
+qboolean PM_AdjustAngleForWallRunUp( gentity_t *ent, usercmd_t *ucmd, qboolean doMove )
+{
+	if ( ent->client->ps.legsAnim == BOTH_FORCEWALLRUNFLIP_START )
+	{//wall-running up
+		//stick to wall, if there is one
+		vec3_t	fwd, traceTo, mins = {ent->mins[0],ent->mins[1],0}, maxs = {ent->maxs[0],ent->maxs[1],24}, fwdAngles = {0, ent->client->ps.viewangles[YAW], 0};		
+		trace_t	trace;
+		float	dist = 128;
+
+		AngleVectors( fwdAngles, fwd, NULL, NULL );
+		VectorMA( ent->currentOrigin, dist, fwd, traceTo );
+		gi.trace( &trace, ent->currentOrigin, mins, maxs, traceTo, ent->s.number, ent->clipmask );
+		if ( trace.fraction > 0.5f )
+		{//hmm, some room, see if there's a floor right here
+			trace_t	trace2;
+			vec3_t	top, bottom;
+			VectorCopy( trace.endpos, top );
+			top[2] += (ent->mins[2]*-1) + 4.0f;
+			VectorCopy( top, bottom );
+			bottom[2] -= 64.0f;//was 32.0f
+			gi.trace( &trace2, top, ent->mins, ent->maxs, bottom, ent->s.number, ent->clipmask );
+			if ( !trace2.allsolid 
+				&& !trace2.startsolid 
+				&& trace2.fraction < 1.0f 
+				&& trace2.plane.normal[2] > 0.7f )//slope we can stand on
+			{//cool, do the alt-flip and land on whetever it is we just scaled up
+				VectorScale( fwd, 100, ent->client->ps.velocity );
+				ent->client->ps.velocity[2] += 200;
+				NPC_SetAnim( ent, SETANIM_BOTH, BOTH_FORCEWALLRUNFLIP_ALT, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+				ent->client->ps.pm_flags |= PMF_JUMP_HELD;
+				ent->client->ps.pm_flags |= PMF_JUMPING|PMF_SLOW_MO_FALL;
+				ent->client->ps.forcePowersActive |= (1<<FP_LEVITATION);
+				G_AddEvent( ent, EV_JUMP, 0 );
+				ucmd->upmove = 0;
+				return qfalse;
+			}
+		}
+		if ( //ucmd->upmove <= 0 && 
+			ent->client->ps.legsAnimTimer > 0 
+			&& ucmd->forwardmove > 0 
+			&& trace.fraction < 1.0f 
+			&& (trace.plane.normal[2] >= 0.0f && trace.plane.normal[2] <= MAX_WALL_RUN_Z_NORMAL) )
+		{//still a vertical wall there
+			//make sure there's not a ceiling above us!
+			trace_t	trace2;
+			VectorCopy( ent->currentOrigin, traceTo );
+			traceTo[2] += 64;
+			gi.trace( &trace2, ent->currentOrigin, mins, maxs, traceTo, ent->s.number, ent->clipmask );
+			if ( trace2.fraction < 1.0f )
+			{//will hit a ceiling, so force jump-off right now
+				//NOTE: hits any entity or clip brush in the way, too, not just architecture!
+			}
+			else
+			{//all clear, keep going
+				//FIXME: don't pull around 90 turns
+				//FIXME: simulate stepping up steps here, somehow?
+				if ( (ent->s.number>=MAX_CLIENTS&&!G_ControlledByPlayer(ent)) || !player_locked )
+				{
+					ucmd->forwardmove = 127;
+				}
+				if ( ucmd->upmove < 0 )
+				{
+					ucmd->upmove = 0;
+				}
+				if ( ent->NPC )
+				{//invalid now
+					VectorClear( ent->client->ps.moveDir );
+				}
+				//make me face the wall
+				ent->client->ps.viewangles[YAW] = vectoyaw( trace.plane.normal )+180;
+				if ( ent->client->ps.viewEntity <= 0 || ent->client->ps.viewEntity >= ENTITYNUM_WORLD )
+				{//don't clamp angles when looking through a viewEntity
+					SetClientViewAngle( ent, ent->client->ps.viewangles );
+				}
+				ucmd->angles[YAW] = ANGLE2SHORT( ent->client->ps.viewangles[YAW] ) - ent->client->ps.delta_angles[YAW];
+				if ( (ent->s.number>=MAX_CLIENTS&&!G_ControlledByPlayer(ent)) || !player_locked )
+				{
+					if ( doMove )
+					{
+						//pull me toward the wall
+						VectorScale( trace.plane.normal, -128, ent->client->ps.velocity );
+						//push me up
+						if ( ent->client->ps.legsAnimTimer > 200 )
+						{//not at end of anim yet
+							float speed = 300;
+							/*
+							if ( ucmd->forwardmove < 0 )
+							{//slower
+								speed = 100;
+							}
+							else if ( ucmd->forwardmove > 0 )
+							{
+								speed = 250;//running speed
+							}
+							*/
+							ent->client->ps.velocity[2] = speed;//preserve z velocity
+						}
+						//pull me toward the wall
+						//VectorMA( ent->client->ps.velocity, -128, trace.plane.normal, ent->client->ps.velocity );
+					}
+				}
+				ucmd->forwardmove = 0;
+				return qtrue;
+			}
+		}
+		//failed!
+		if ( doMove )
+		{//stop it
+			VectorScale( fwd, WALL_RUN_UP_BACKFLIP_SPEED, ent->client->ps.velocity );
+			ent->client->ps.velocity[2] += 200;
+			NPC_SetAnim( ent, SETANIM_BOTH, BOTH_FORCEWALLRUNFLIP_END, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+			ent->client->ps.pm_flags |= PMF_JUMP_HELD;
+			ent->client->ps.pm_flags |= PMF_JUMPING|PMF_SLOW_MO_FALL;
+			ent->client->ps.forcePowersActive |= (1<<FP_LEVITATION);
+			G_AddEvent( ent, EV_JUMP, 0 );
+			ucmd->upmove = 0;
+			//return qtrue;
+		}
+	}
+	return qfalse;
+}
+
+float G_ForceWallJumpStrength( void )
+{
+	return (forceJumpStrength[FORCE_LEVEL_3]/2.5f);
+}
+
+qboolean PM_AdjustAngleForWallJump( gentity_t *ent, usercmd_t *ucmd, qboolean doMove )
+{
+	if ( PM_InReboundJump( ent->client->ps.legsAnim )
+		|| PM_InReboundHold( ent->client->ps.legsAnim ) )
+	{//hugging wall, getting ready to jump off
+		//stick to wall, if there is one
+		vec3_t	checkDir, traceTo, mins = {ent->mins[0],ent->mins[1],0}, maxs = {ent->maxs[0],ent->maxs[1],24}, fwdAngles = {0, ent->client->ps.viewangles[YAW], 0};		
+		trace_t	trace;
+		float	dist = 128, yawAdjust;
+		switch ( ent->client->ps.legsAnim )
+		{
+		case BOTH_FORCEWALLREBOUND_RIGHT:
+		case BOTH_FORCEWALLHOLD_RIGHT:
+			AngleVectors( fwdAngles, NULL, checkDir, NULL );
+			yawAdjust = -90;
+			break;
+		case BOTH_FORCEWALLREBOUND_LEFT:
+		case BOTH_FORCEWALLHOLD_LEFT:
+			AngleVectors( fwdAngles, NULL, checkDir, NULL );
+			VectorScale( checkDir, -1, checkDir );
+			yawAdjust = 90;
+			break;
+		case BOTH_FORCEWALLREBOUND_FORWARD:
+		case BOTH_FORCEWALLHOLD_FORWARD:
+			AngleVectors( fwdAngles, checkDir, NULL, NULL );
+			yawAdjust = 180;
+			break;
+		case BOTH_FORCEWALLREBOUND_BACK:
+		case BOTH_FORCEWALLHOLD_BACK:
+			AngleVectors( fwdAngles, checkDir, NULL, NULL );
+			VectorScale( checkDir, -1, checkDir );
+			yawAdjust = 0;
+			break;
+		default:
+			//WTF???
+			return qfalse;
+			break;
+		}
+		if ( g_debugMelee->integer )
+		{//uber-skillz
+			if ( ucmd->upmove > 0 )
+			{//hold on until you let go manually
+				if ( PM_InReboundHold( ent->client->ps.legsAnim ) )
+				{//keep holding
+					if ( ent->client->ps.legsAnimTimer < 150 )
+					{
+						ent->client->ps.legsAnimTimer = 150;
+					}
+				}
+				else
+				{//if got to hold part of anim, play hold anim
+					if ( ent->client->ps.legsAnimTimer <= 300 )
+					{
+						ent->client->ps.SaberDeactivate();
+						NPC_SetAnim( ent, SETANIM_BOTH, BOTH_FORCEWALLRELEASE_FORWARD+(ent->client->ps.legsAnim-BOTH_FORCEWALLHOLD_FORWARD), SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+						ent->client->ps.legsAnimTimer = ent->client->ps.torsoAnimTimer = 150;
+					}
+				}
+			}
+		}
+		VectorMA( ent->currentOrigin, dist, checkDir, traceTo );
+		gi.trace( &trace, ent->currentOrigin, mins, maxs, traceTo, ent->s.number, ent->clipmask );
+		if ( //ucmd->upmove <= 0 && 
+			ent->client->ps.legsAnimTimer > 100 &&
+			trace.fraction < 1.0f && fabs(trace.plane.normal[2]) <= MAX_WALL_GRAB_SLOPE )
+		{//still a vertical wall there
+			//FIXME: don't pull around 90 turns
+			/*
+			if ( (ent->s.number>=MAX_CLIENTS&&!G_ControlledByPlayer(ent)) || !player_locked )
+			{
+				ucmd->forwardmove = 127;
+			}
+			*/
+			if ( ucmd->upmove < 0 )
+			{
+				ucmd->upmove = 0;
+			}
+			if ( ent->NPC )
+			{//invalid now
+				VectorClear( ent->client->ps.moveDir );
+			}
+			//align me to the wall
+			ent->client->ps.viewangles[YAW] = vectoyaw( trace.plane.normal )+yawAdjust;
+			if ( ent->client->ps.viewEntity <= 0 || ent->client->ps.viewEntity >= ENTITYNUM_WORLD )
+			{//don't clamp angles when looking through a viewEntity
+				SetClientViewAngle( ent, ent->client->ps.viewangles );
+			}
+			ucmd->angles[YAW] = ANGLE2SHORT( ent->client->ps.viewangles[YAW] ) - ent->client->ps.delta_angles[YAW];
+			if ( (ent->s.number>=MAX_CLIENTS&&!G_ControlledByPlayer(ent)) || !player_locked )
+			{
+				if ( doMove )
+				{
+					//pull me toward the wall
+					VectorScale( trace.plane.normal, -128, ent->client->ps.velocity );
+				}
+			}
+			ucmd->upmove = 0;
+			ent->client->ps.pm_flags |= PMF_STUCK_TO_WALL;
+			return qtrue;
+		}
+		else if ( doMove 
+			&& (ent->client->ps.pm_flags&PMF_STUCK_TO_WALL))
+		{//jump off
+			//push off of it!
+			ent->client->ps.pm_flags &= ~PMF_STUCK_TO_WALL;
+			ent->client->ps.velocity[0] = ent->client->ps.velocity[1] = 0;
+			VectorScale( checkDir, -JUMP_OFF_WALL_SPEED, ent->client->ps.velocity );
+			ent->client->ps.velocity[2] = G_ForceWallJumpStrength();
+			ent->client->ps.pm_flags |= PMF_JUMPING|PMF_JUMP_HELD;
+			G_SoundOnEnt( ent, CHAN_BODY, "sound/weapons/force/jump.wav" );
+			ent->client->ps.forcePowersActive |= (1<<FP_LEVITATION);
+			WP_ForcePowerDrain( ent, FP_LEVITATION, 10 );
+			if ( PM_InReboundHold( ent->client->ps.legsAnim ) )
+			{//if was in hold pose, release now
+				NPC_SetAnim( ent, SETANIM_BOTH, BOTH_FORCEWALLRELEASE_FORWARD+(ent->client->ps.legsAnim-BOTH_FORCEWALLHOLD_FORWARD), SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+			}
+			//no control for half a second
+			ent->client->ps.pm_flags |= PMF_TIME_KNOCKBACK;
+			ent->client->ps.pm_time = 500;
+			ucmd->forwardmove = 0;
+			ucmd->rightmove = 0;
+			ucmd->upmove = 0;
+			//return qtrue;
+		}
+	}
+	ent->client->ps.pm_flags &= ~PMF_STUCK_TO_WALL;
+	return qfalse;
+}
+
+qboolean PM_AdjustAnglesForBFKick( gentity_t *self, usercmd_t *ucmd, vec3_t fwdAngs, qboolean aimFront )
+{
+	//Auto-aim the player at the ent in front/back of them
+	//FIXME: camera angle should always be in front/behind me for the 2 kicks 
+	//			(to hide how far away the two entities really are)
+	//FIXME: don't let the people we're auto-aiming at move?
+	gentity_t	*ent;
+	gentity_t	*entityList[MAX_GENTITIES];
+	vec3_t		mins, maxs;
+	int			i, e;
+	int			radius = ((self->maxs[0]*1.5f)+(self->maxs[0]*1.5f)+STAFF_KICK_RANGE+24.0f);//a little wide on purpose
+	vec3_t		center, vec2Ent, v_fwd;
+	float		distToEnt, bestDist = Q3_INFINITE;
+	float		dot, bestDot = -1.1f;
+	float		bestYaw = Q3_INFINITE;
+	
+	AngleVectors( fwdAngs, v_fwd, NULL, NULL );
+	
+	VectorCopy( self->currentOrigin, center );
+
+	for ( i = 0 ; i < 3 ; i++ ) 
+	{
+		mins[i] = center[i] - radius;
+		maxs[i] = center[i] + radius;
+	}
+
+	int numListedEntities = gi.EntitiesInBox( mins, maxs, entityList, MAX_GENTITIES );
+
+	for ( e = 0 ; e < numListedEntities ; e++ ) 
+	{
+		ent = entityList[ e ];
+
+		if (ent == self)
+			continue;
+		if (ent->owner == self)
+			continue;
+		if ( !(ent->inuse) )
+			continue;
+		//not a client?
+		if ( !ent->client )
+			continue;
+		//ally?
+		if ( ent->client->playerTeam == self->client->playerTeam )
+			continue;
+		//on the ground
+		if ( PM_InKnockDown( &ent->client->ps ) )
+			continue;
+		//dead?
+		if ( ent->health <= 0 )
+		{
+			if ( level.time - ent->s.time > 2000 )
+			{//died more than 2 seconds ago, forget him
+				continue;
+			}
+		}
+		//too far?
+		VectorSubtract( ent->currentOrigin, center, vec2Ent );
+		distToEnt = VectorNormalize( vec2Ent );
+		if ( distToEnt > radius )
+			continue;
+		
+		if ( !aimFront )
+		{//aim away from them
+			VectorScale( vec2Ent, -1, vec2Ent );
+		}
+		dot = DotProduct( vec2Ent, v_fwd );
+		if ( dot < 0.0f )
+		{//never turn all the way around
+			continue;
+		}
+		if ( dot > bestDot || ((bestDot-dot<0.25f)&&distToEnt-bestDist>8.0f) )
+		{//more in front... OR: still relatively close to in front and significantly closer
+			bestDot = dot;
+			bestDist = distToEnt;
+			bestYaw = vectoyaw( vec2Ent );
+		}
+	}
+	if ( bestYaw != Q3_INFINITE && bestYaw != fwdAngs[YAW] )
+	{//aim us at them
+		AngleNormalize180( bestYaw );
+		AngleNormalize180( fwdAngs[YAW] );
+		float angDiff = AngleSubtract( bestYaw, fwdAngs[YAW] );
+		AngleNormalize180( angDiff );
+		if ( fabs(angDiff) <= 3.0f )
+		{
+			self->client->ps.viewangles[YAW] = bestYaw;
+		}
+		else if ( angDiff > 0.0f )
+		{//more than 3 degrees higher
+			self->client->ps.viewangles[YAW] += 3.0f;
+		}
+		else
+		{//must be more than 3 less than
+			self->client->ps.viewangles[YAW] -= 3.0f;
+		}
+		if ( self->client->ps.viewEntity <= 0 || self->client->ps.viewEntity >= ENTITYNUM_WORLD )
+		{//don't clamp angles when looking through a viewEntity
+			SetClientViewAngle( self, self->client->ps.viewangles );
+		}
+		ucmd->angles[YAW] = ANGLE2SHORT( self->client->ps.viewangles[YAW] ) - self->client->ps.delta_angles[YAW];
+		return qtrue;
+	}
+	else
+	{//lock these angles
+		if ( self->client->ps.viewEntity <= 0 || self->client->ps.viewEntity >= ENTITYNUM_WORLD )
+		{//don't clamp angles when looking through a viewEntity
+			SetClientViewAngle( self, self->client->ps.viewangles );
+		}
+		ucmd->angles[YAW] = ANGLE2SHORT( self->client->ps.viewangles[YAW] ) - self->client->ps.delta_angles[YAW];
+	}
+	return qtrue;
+}
+
+qboolean PM_AdjustAnglesForStabDown( gentity_t *ent, usercmd_t *ucmd )
+{
+	if ( PM_StabDownAnim( ent->client->ps.torsoAnim )
+		&& ent->client->ps.torsoAnimTimer )
+	{//lock our angles
+		ucmd->forwardmove = ucmd->rightmove = ucmd->upmove = 0;
+		float elapsedTime = PM_AnimLength( ent->client->clientInfo.animFileIndex, (animNumber_t)ent->client->ps.torsoAnim ) - ent->client->ps.torsoAnimTimer;
+		//FIXME: scale forwardmove by dist from enemy - none if right next to him (so we don't slide off!)
+		if ( ent->enemy )
+		{
+			float dist2Enemy = DistanceHorizontal( ent->enemy->currentOrigin, ent->currentOrigin );
+			if ( dist2Enemy > (ent->enemy->maxs[0]*1.5f)+(ent->maxs[0]*1.5f) )
+			{
+				ent->client->ps.speed = dist2Enemy*2.0f;
+			}
+			else
+			{
+				ent->client->ps.speed = 0;
+			}
+		}
+		else
+		{
+			ent->client->ps.speed = 150;
+		}
+		switch ( ent->client->ps.legsAnim )
+		{
+		case BOTH_STABDOWN:
+			if ( elapsedTime >= 300 && elapsedTime < 900 )
+			{//push forward?
+				//FIXME: speed!
+				ucmd->forwardmove = 127;
+			}
+			break;
+		case BOTH_STABDOWN_STAFF:
+			if ( elapsedTime > 400 && elapsedTime < 950 )
+			{//push forward?
+				//FIXME: speed!
+				ucmd->forwardmove = 127;
+			}
+			break;
+		case BOTH_STABDOWN_DUAL:
+			if ( elapsedTime >= 300 && elapsedTime < 900 )
+			{//push forward?
+				//FIXME: speed!
+				ucmd->forwardmove = 127;
+			}
+			break;
+		}
+		VectorClear( ent->client->ps.moveDir );
+
+		if ( ent->enemy//still have a valid enemy
+			&& ent->enemy->client//who is a client
+			&& (PM_InKnockDownNoGetup( &ent->enemy->client->ps ) //enemy still on ground
+				|| PM_InGetUpNoRoll( &ent->enemy->client->ps ) ) )//or getting straight up
+		{//aim at the enemy
+			vec3_t enemyDir;
+			VectorSubtract( ent->enemy->currentOrigin, ent->currentOrigin, enemyDir );
+			float enemyYaw = AngleNormalize180( vectoyaw( enemyDir ) );
+			float yawError = AngleNormalize180( enemyYaw - AngleNormalize180( ent->client->ps.viewangles[YAW] ) );
+			if ( yawError > 1 )
+			{
+				yawError = 1;
+			}
+			else if ( yawError < -1 )
+			{
+				yawError = -1;
+			}
+			ucmd->angles[YAW] = ANGLE2SHORT( AngleNormalize180( ent->client->ps.viewangles[YAW] + yawError ) ) - ent->client->ps.delta_angles[YAW];
+			ucmd->angles[PITCH] = ANGLE2SHORT( ent->client->ps.viewangles[PITCH] ) - ent->client->ps.delta_angles[PITCH];
+		}
+		else
+		{//can't turn
+			if ( ent->client->ps.viewEntity <= 0 || ent->client->ps.viewEntity >= ENTITYNUM_WORLD )
+			{//don't clamp angles when looking through a viewEntity
+				SetClientViewAngle( ent, ent->client->ps.viewangles );
+			}
+			ucmd->angles[PITCH] = ANGLE2SHORT( ent->client->ps.viewangles[PITCH] ) - ent->client->ps.delta_angles[PITCH];
+			ucmd->angles[YAW] = ANGLE2SHORT( ent->client->ps.viewangles[YAW] ) - ent->client->ps.delta_angles[YAW];
+		}
+		return qtrue;
+	}
+	return qfalse;
+}
+
+qboolean PM_AdjustAnglesForSpinProtect( gentity_t *ent, usercmd_t *ucmd )
+{
+	if ( ent->client->ps.torsoAnim == BOTH_A6_SABERPROTECT )
+	{//in the dual spin thing
+		if ( ent->client->ps.torsoAnimTimer )
+		{//flatten and lock our angles, pull back camera
+			//FIXME: lerp this
+			ent->client->ps.viewangles[PITCH] = 0;
+			if ( ent->client->ps.viewEntity <= 0 || ent->client->ps.viewEntity >= ENTITYNUM_WORLD )
+			{//don't clamp angles when looking through a viewEntity
+				SetClientViewAngle( ent, ent->client->ps.viewangles );
+			}
+			ucmd->angles[PITCH] = ANGLE2SHORT( ent->client->ps.viewangles[PITCH] ) - ent->client->ps.delta_angles[PITCH];
+			ucmd->angles[YAW] = ANGLE2SHORT( ent->client->ps.viewangles[YAW] ) - ent->client->ps.delta_angles[YAW];
+			return qtrue;
+		}
+	}
+	return qfalse;
+}
+
+qboolean PM_AdjustAnglesForWallRunUpFlipAlt( gentity_t *ent, usercmd_t *ucmd )
+{
+	if ( ent->client->ps.viewEntity <= 0 || ent->client->ps.viewEntity >= ENTITYNUM_WORLD )
+	{//don't clamp angles when looking through a viewEntity
+		SetClientViewAngle( ent, ent->client->ps.viewangles );
+	}
+	ucmd->angles[PITCH] = ANGLE2SHORT( ent->client->ps.viewangles[PITCH] ) - ent->client->ps.delta_angles[PITCH];
+	ucmd->angles[YAW] = ANGLE2SHORT( ent->client->ps.viewangles[YAW] ) - ent->client->ps.delta_angles[YAW];
+	return qtrue;
+}
+
+qboolean PM_AdjustAnglesForHeldByMonster( gentity_t *ent, gentity_t *monster, usercmd_t *ucmd )
+{
+	vec3_t	newViewAngles;
+	if ( !monster || !monster->client )
+	{
+		return qfalse;
+	}
+	VectorScale( monster->client->ps.viewangles, -1, newViewAngles );
+	if ( ent->client->ps.viewEntity <= 0 || ent->client->ps.viewEntity >= ENTITYNUM_WORLD )
+	{//don't clamp angles when looking through a viewEntity
+		SetClientViewAngle( ent, newViewAngles );
+	}
+	ucmd->angles[PITCH] = ANGLE2SHORT( newViewAngles[PITCH] ) - ent->client->ps.delta_angles[PITCH];
+	ucmd->angles[YAW] = ANGLE2SHORT( newViewAngles[YAW] ) - ent->client->ps.delta_angles[YAW];
+	return qtrue;
+}
+
+qboolean G_OkayToLean( playerState_t *ps, usercmd_t *cmd, qboolean interruptOkay )
+{
+	if ( (ps->clientNum < MAX_CLIENTS||G_ControlledByPlayer(&g_entities[ps->clientNum]))//player
+		&& ps->groundEntityNum != ENTITYNUM_NONE//on ground
+		&& ( (interruptOkay//okay to interrupt a lean
+				&& PM_DodgeAnim( ps->torsoAnim ) )//already leaning
+			|| 
+			 (!ps->weaponTime//not attacking or being prevented from attacking
+				&& !ps->legsAnimTimer//not in any held legs anim
+				&& !ps->torsoAnimTimer) //not in any held torso anim
+			)
+		&& !(cmd->buttons&(BUTTON_ATTACK|BUTTON_ALT_ATTACK|BUTTON_FORCE_LIGHTNING|BUTTON_USE_FORCE|BUTTON_FORCE_DRAIN|BUTTON_FORCEGRIP))//not trying to attack
+		//&& (ps->forcePowersActive&(1<<FP_SPEED))
+		&& VectorCompare( ps->velocity, vec3_origin )//not moving
+		&& !cg_usingInFrontOf )//use button wouldn't be used for anything else
+	{
+		return qtrue;
+	}
+	return qfalse;
+}
+/*
+================
+PM_UpdateViewAngles
+
+This can be used as another entry point when only the viewangles
+are being updated isntead of a full move
+
+//FIXME: Now that they pmove twice per think, they snap-look really fast
+================
+*/
+void PM_UpdateViewAngles( playerState_t *ps, usercmd_t *cmd, gentity_t *gent ) 
+{
+	short		temp;
+	float		rootPitch = 0, pitchMin=-75, pitchMax=75, yawMin=0, yawMax=0, lockedYawValue = 0;	//just to shut up warnings
+	int			i;
+	vec3_t		start, end, tmins, tmaxs, right;
+	trace_t		trace;
+	qboolean	lockedYaw = qfalse, clamped = qfalse;
+
+	if ( ps->pm_type == PM_INTERMISSION ) 
+	{
+		return;		// no view changes at all
+	}
+
+	//TEMP
+#if 0 //rww 12/23/02 - I'm disabling this for now, I'm going to try to make it work with my new rag stuff
+	if ( gent != NULL )
+	{
+		PM_IKUpdate( gent );
+	}
+#endif
+
+	if ( ps->pm_type != PM_SPECTATOR && ps->stats[STAT_HEALTH] <= 0 ) 
+	{
+		return;		// no view changes at all
+	}
+
+//	if ( player_locked )
+//	{//can't turn
+//		return;
+//	}
+	if ( ps->clientNum != 0 && gent != NULL && gent->client != NULL )
+	{
+		if(gent->client->renderInfo.renderFlags & RF_LOCKEDANGLE)
+		{
+			pitchMin = 0 - gent->client->renderInfo.headPitchRangeUp - gent->client->renderInfo.torsoPitchRangeUp;
+			pitchMax = gent->client->renderInfo.headPitchRangeDown + gent->client->renderInfo.torsoPitchRangeDown;
+			
+			yawMin = 0 - gent->client->renderInfo.headYawRangeLeft - gent->client->renderInfo.torsoYawRangeLeft;
+			yawMax = gent->client->renderInfo.headYawRangeRight + gent->client->renderInfo.torsoYawRangeRight;
+
+			lockedYaw = qtrue;
+			lockedYawValue = gent->client->renderInfo.lockYaw;
+		}
+		else
+		{
+			pitchMin = -gent->client->renderInfo.headPitchRangeUp-gent->client->renderInfo.torsoPitchRangeUp;
+			pitchMax = gent->client->renderInfo.headPitchRangeDown+gent->client->renderInfo.torsoPitchRangeDown;
+		}
+	}
+
+	if ( ps->eFlags & EF_LOCKED_TO_WEAPON )
+	{
+		// Emplaced guns have different pitch capabilities
+		if ( gent && gent->owner && gent->owner->e_UseFunc == useF_eweb_use )
+		{
+			pitchMin = -15;
+			pitchMax = 10;
+			/*
+			lockedYawValue = gent->owner->s.angles[YAW];
+			yawMax = gent->owner->s.origin2[0];
+			yawMin = yawMax *-1;
+			lockedYaw = qtrue;
+			*/
+		}
+		else
+		{
+			pitchMin = -35;
+			pitchMax = 30;
+		}
+	}
+
+	Vehicle_t *pVeh = NULL;
+
+	// If we're a vehicle, or we're riding a vehicle...?
+	if ( gent && gent->client && gent->client->NPC_class == CLASS_VEHICLE && gent->m_pVehicle)
+	{
+		pVeh = gent->m_pVehicle;
+		// If we're a vehicle...
+		if (pVeh->m_pVehicleInfo->Inhabited(pVeh) || pVeh->m_iBoarding!=0 || pVeh->m_pVehicleInfo->type!=VH_ANIMAL)
+		{
+			lockedYawValue = pVeh->m_vOrientation[YAW];
+			yawMax = yawMin = 0;
+			rootPitch = pVeh->m_vOrientation[PITCH];//???  what if goes over 90 when add the min/max?
+			pitchMax = 0.0f;//pVeh->m_pVehicleInfo->pitchLimit;
+			pitchMin = 0.0f;//-pitchMax;
+			lockedYaw = qtrue;
+		}
+		// If we're riding a vehicle...
+		else if ( (pVeh = G_IsRidingVehicle( gent ) ) != NULL )
+		{
+			if ( pVeh->m_pVehicleInfo->type != VH_ANIMAL )
+			{//animals just turn normally, no clamping
+				lockedYawValue = 0;//gent->owner->client->ps.vehicleAngles[YAW];
+				lockedYaw = qtrue;
+				yawMax = pVeh->m_pVehicleInfo->lookYaw;
+				yawMin = -yawMax;
+				if ( pVeh->m_pVehicleInfo->type == VH_FIGHTER )
+				{
+					rootPitch = pVeh->m_vOrientation[PITCH];//gent->owner->client->ps.vehicleAngles[PITCH];//???  what if goes over 90 when add the min/max?
+					pitchMax = pVeh->m_pVehicleInfo->pitchLimit;
+					pitchMin = -pitchMax;
+				}
+				else
+				{
+					rootPitch = 0;//gent->owner->client->ps.vehicleAngles[PITCH];//???  what if goes over 90 when add the min/max?
+					pitchMax = pVeh->m_pVehicleInfo->lookPitch;
+					pitchMin = -pitchMax;
+				}
+			}
+		}
+
+		/*if ( vehIndex != -1 )
+		{
+			//FIXME: read from NPCs.cfg or vehicles.cfg?
+			lockedYaw = qtrue;
+		}*/
+	}
+
+	const short pitchClampMin = ANGLE2SHORT(rootPitch+pitchMin);
+	const short pitchClampMax = ANGLE2SHORT(rootPitch+pitchMax);
+	const short yawClampMin = ANGLE2SHORT(lockedYawValue+yawMin);
+	const short yawClampMax = ANGLE2SHORT(lockedYawValue+yawMax);
+
+	// circularly clamp the angles with deltas
+	for (i=0 ; i<3 ; i++) 
+	{
+		temp = cmd->angles[i] + ps->delta_angles[i];
+		if ( i == PITCH ) 
+		{
+			//FIXME get this limit from the NPCs stats?
+			// don't let the player look up or down more than 90 degrees
+			if ( temp > pitchClampMax ) 
+			{
+				ps->delta_angles[i] = (pitchClampMax - cmd->angles[i]) & 0xffff;	//& clamp to short
+				temp = pitchClampMax;
+				clamped = qtrue;
+			} 
+			else if ( temp < pitchClampMin ) 
+			{
+				ps->delta_angles[i] = (pitchClampMin - cmd->angles[i]) & 0xffff;	//& clamp to short
+				temp = pitchClampMin;
+				clamped = qtrue;
+			}
+		}
+		/*
+		if ( i == ROLL && ps->vehicleIndex != VEHICLE_NONE ) 
+		{
+			if ( temp > pitchClampMax ) 
+			{
+				ps->delta_angles[i] = (pitchClampMax - cmd->angles[i]) & 0xffff;
+				temp = pitchClampMax;
+			} 
+			else if ( temp < pitchClampMin ) 
+			{
+				ps->delta_angles[i] = (pitchClampMin - cmd->angles[i]) & 0xffff;
+				temp = pitchClampMin;
+			}
+		}
+		*/
+		//FIXME: Are we losing precision here?  Is this why it jitters?
+		/*
+		if ( i == YAW && lockedYaw ) 
+		{
+			float multiplier = 1.0f;
+			float newYaw = SHORT2ANGLE(temp);
+			lockedYawValue = AngleNormalize180( lockedYawValue );
+			float yawDiff = AngleNormalize180( newYaw ) - lockedYawValue;
+			if ( yawDiff > 180 )
+			{
+				multiplier = -1.0f;
+				yawDiff = 360 - yawDiff;
+			}
+			else if ( yawDiff < -180 )
+			{
+				//multiplier = -1.0f;
+				yawDiff = 360 + yawDiff;
+			}
+			// don't let the player look left or right more than the clamp, if any
+			if ( yawDiff > yawMax ) 
+			{
+				clamped = qtrue;
+				ps->viewangles[i] = AngleNormalize180( lockedYawValue+((yawMax-2)*multiplier) );
+			} 
+			else if ( yawDiff < yawMin ) 
+			{
+				clamped = qtrue;
+				ps->viewangles[i] = AngleNormalize180( lockedYawValue+((yawMin+2)*multiplier) );
+			}
+			else
+			{
+				ps->viewangles[i] = newYaw;
+			}
+		}
+		*/
+		if ( i == YAW && lockedYaw ) 
+		{
+			//FIXME get this limit from the NPCs stats?
+			// don't let the player look up or down more than 90 degrees
+			if ( temp > yawClampMax ) 
+			{
+				ps->delta_angles[i] = (yawClampMax - cmd->angles[i]) & 0xffff;	//& clamp to short
+				temp = yawClampMax;
+				clamped = qtrue;
+			} 
+			else if ( temp < yawClampMin ) 
+			{
+				ps->delta_angles[i] = (yawClampMin - cmd->angles[i]) & 0xffff;	//& clamp to short
+				temp = yawClampMin;
+				clamped = qtrue;
+			}
+			ps->viewangles[i] = SHORT2ANGLE(temp);
+		}
+		else
+		{
+			ps->viewangles[i] = SHORT2ANGLE(temp);
+		}
+	}
+
+	if ( gent )
+	{	//only in the real pmove
+		if ( (cmd->buttons & BUTTON_USE) )
+		{//check leaning
+			if ( cg.renderingThirdPerson )
+			{//third person lean
+				if ( G_OkayToLean( ps, cmd, qtrue )
+					&& (cmd->rightmove || (cmd->forwardmove && g_debugMelee->integer ) ) )//pushing a direction
+				{
+					int anim = -1;
+					if ( cmd->rightmove > 0 )
+					{//lean right
+						if ( cmd->forwardmove > 0 )
+						{//lean forward right
+							if ( ps->torsoAnim == BOTH_DODGE_HOLD_FR )
+							{
+								anim = ps->torsoAnim;
+							}
+							else
+							{
+								anim = BOTH_DODGE_FR;
+							}
+						}
+						else if ( cmd->forwardmove < 0 )
+						{//lean backward right
+							if ( ps->torsoAnim == BOTH_DODGE_HOLD_BR )
+							{
+								anim = ps->torsoAnim;
+							}
+							else
+							{
+								anim = BOTH_DODGE_BR;
+							}
+						}
+						else
+						{//lean right
+							if ( ps->torsoAnim == BOTH_DODGE_HOLD_R )
+							{
+								anim = ps->torsoAnim;
+							}
+							else
+							{
+								anim = BOTH_DODGE_R;
+							}
+						}
+					}
+					else if ( cmd->rightmove < 0 )
+					{//lean left
+						if ( cmd->forwardmove > 0 )
+						{//lean forward left
+							if ( ps->torsoAnim == BOTH_DODGE_HOLD_FL )
+							{
+								anim = ps->torsoAnim;
+							}
+							else
+							{
+								anim = BOTH_DODGE_FL;
+							}
+						}
+						else if ( cmd->forwardmove < 0 )
+						{//lean backward left
+							if ( ps->torsoAnim == BOTH_DODGE_HOLD_BL )
+							{
+								anim = ps->torsoAnim;
+							}
+							else
+							{
+								anim = BOTH_DODGE_BL;
+							}
+						}
+						else
+						{//lean left
+							if ( ps->torsoAnim == BOTH_DODGE_HOLD_L )
+							{
+								anim = ps->torsoAnim;
+							}
+							else
+							{
+								anim = BOTH_DODGE_L;
+							}
+						}
+					}
+					else
+					{//not pressing either side
+						if ( cmd->forwardmove > 0 )
+						{//lean forward
+							if ( PM_DodgeAnim( ps->torsoAnim ) )
+							{
+								anim = ps->torsoAnim;
+							}
+							else if ( Q_irand( 0, 1 ) )
+							{
+								anim = BOTH_DODGE_FL;
+							}
+							else
+							{
+								anim = BOTH_DODGE_FR;
+							}
+						}
+						else if ( cmd->forwardmove < 0 )
+						{//lean backward
+							if ( PM_DodgeAnim( ps->torsoAnim ) )
+							{
+								anim = ps->torsoAnim;
+							}
+							else if ( Q_irand( 0, 1 ) )
+							{
+								anim = BOTH_DODGE_BL;
+							}
+							else
+							{
+								anim = BOTH_DODGE_BR;
+							}
+						}
+					}
+					if ( anim != -1 )
+					{
+						int extraHoldTime = 0;
+						if ( PM_DodgeAnim( ps->torsoAnim ) 
+							&& !PM_DodgeHoldAnim( ps->torsoAnim ) )
+						{//already in a dodge
+							//use the hold pose, don't start it all over again
+							anim = BOTH_DODGE_HOLD_FL+(anim-BOTH_DODGE_FL);
+							extraHoldTime = 200;
+						}
+						if ( anim == pm->ps->torsoAnim )
+						{
+							if ( pm->ps->torsoAnimTimer < 100 )
+							{
+								pm->ps->torsoAnimTimer = 100;
+							}
+						}
+						else
+						{
+							NPC_SetAnim( gent, SETANIM_TORSO, anim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+						}
+						if ( extraHoldTime && ps->torsoAnimTimer < extraHoldTime )
+						{
+							ps->torsoAnimTimer += extraHoldTime;
+						}
+						if ( ps->groundEntityNum != ENTITYNUM_NONE
+							&& !cmd->upmove )
+						{
+							NPC_SetAnim( gent, SETANIM_LEGS, anim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+							ps->legsAnimTimer = ps->torsoAnimTimer;
+						}
+						else
+						{
+							NPC_SetAnim( gent, SETANIM_LEGS, anim, SETANIM_FLAG_NORMAL );
+						}
+						ps->weaponTime = ps->torsoAnimTimer;
+						ps->leanStopDebounceTime = ceil((float)ps->torsoAnimTimer/50.0f);//20;
+					}
+				}
+			}
+			else if ( (!cg.renderingThirdPerson||cg.zoomMode) && cmd->rightmove != 0 && !cmd->forwardmove && cmd->upmove <= 0 )
+			{//Only lean if holding use button, strafing and not moving forward or back and not jumping
+				int leanofs = 0;
+				vec3_t	viewangles;
+
+				if ( cmd->rightmove > 0 )
+				{
+					/*
+					if( pm->ps->legsAnim != LEGS_LEAN_RIGHT1)
+					{
+					PM_SetAnim(pm, SETANIM_LEGS, LEGS_LEAN_RIGHT1, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD);
+					}
+					pm->ps->legsAnimTimer = 500;//Force it to hold the anim for at least half a sec
+					*/
+
+					if ( ps->leanofs <= 28 )
+					{
+						leanofs = ps->leanofs + 4;
+					}
+					else
+					{
+						leanofs = 32;
+					}
+				}
+				else
+				{
+					/*
+					if ( pm->ps->legsAnim != LEGS_LEAN_LEFT1 )
+					{
+					PM_SetAnim(pm, SETANIM_LEGS, LEGS_LEAN_LEFT1, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD);
+					}
+					pm->ps->legsAnimTimer = 500;//Force it to hold the anim for at least half a sec
+					*/
+
+					if ( ps->leanofs >= -28 )
+					{
+						leanofs = ps->leanofs - 4;
+					}
+					else
+					{
+						leanofs = -32;
+					}
+				}
+
+				VectorCopy( ps->origin, start );
+				start[2] += ps->viewheight;
+				VectorCopy( ps->viewangles, viewangles );
+				viewangles[ROLL] = 0;
+				AngleVectors( ps->viewangles, NULL, right, NULL );
+				VectorNormalize( right );
+				right[2] = (leanofs<0)?0.25:-0.25;
+				VectorMA( start, leanofs, right, end );
+				VectorSet( tmins, -8, -8, -4 );
+				VectorSet( tmaxs, 8, 8, 4 );
+				//if we don't trace EVERY frame, can TURN while leaning and
+				//end up leaning into solid architecture (sigh)
+				gi.trace( &trace, start, tmins, tmaxs, end, gent->s.number, MASK_PLAYERSOLID );
+
+				ps->leanofs = floor((float)leanofs * trace.fraction);
+
+				ps->leanStopDebounceTime = 20;
+			}
+			else
+			{
+				if ( (cmd->forwardmove || cmd->upmove > 0) )
+				{
+					if( ( pm->ps->legsAnim == LEGS_LEAN_RIGHT1) ||
+						( pm->ps->legsAnim == LEGS_LEAN_LEFT1) )
+					{
+						pm->ps->legsAnimTimer = 0;//Force it to stop the anim
+					}
+
+					if ( ps->leanofs > 0 )
+					{
+						ps->leanofs-=4;
+						if ( ps->leanofs < 0 )
+						{
+							ps->leanofs = 0;
+						}
+					}
+					else if ( ps->leanofs < 0 )
+					{
+						ps->leanofs+=4;
+						if ( ps->leanofs > 0 )
+						{
+							ps->leanofs = 0;
+						}
+					}
+				}
+
+			}
+		}
+		else//BUTTON_USE
+		{
+			if ( ps->leanofs > 0 )
+			{
+				ps->leanofs-=4;
+				if ( ps->leanofs < 0 )
+				{
+					ps->leanofs = 0;
+				}
+			}
+			else if ( ps->leanofs < 0 )
+			{
+				ps->leanofs+=4;
+				if ( ps->leanofs > 0 )
+				{
+					ps->leanofs = 0;
+				}
+			}
+		}
+	}
+
+	if ( ps->leanStopDebounceTime )
+	{
+		ps->leanStopDebounceTime -= 1;
+		cmd->rightmove = 0;
+		cmd->buttons &= ~BUTTON_USE;
+	}
+}
\ No newline at end of file
diff --git a/code/game/bg_panimate.cpp b/code/game/bg_panimate.cpp
new file mode 100644
index 0000000..266101a
--- /dev/null
+++ b/code/game/bg_panimate.cpp
@@ -0,0 +1,6639 @@
+// this include must remain at the top of every bg_xxxx CPP file
+#include "common_headers.h"
+
+
+// define GAME_INCLUDE so that g_public.h does not define the
+// short, server-visible gclient_t and gentity_t structures,
+// because we define the full size ones in this file
+#define GAME_INCLUDE
+//#include "../renderer/tr_local.h"
+
+#include "q_shared.h"
+#include "g_shared.h"
+#include "bg_local.h"
+#include "../cgame/cg_local.h"
+#include "anims.h"
+#include "Q3_Interface.h"
+#include "g_local.h"
+#include "wp_saber.h"
+#include "g_vehicles.h"
+
+extern pmove_t	*pm;
+extern pml_t	pml;
+extern cvar_t	*g_ICARUSDebug;
+extern cvar_t	*g_timescale;
+extern cvar_t	*g_synchSplitAnims;
+extern cvar_t	*g_AnimWarning;
+extern cvar_t	*g_noFootSlide;
+extern cvar_t	*g_noFootSlideRunScale;
+extern cvar_t	*g_noFootSlideWalkScale;
+extern cvar_t	*g_saberAnimSpeed;
+extern cvar_t	*g_saberAutoAim;
+extern cvar_t	*g_speederControlScheme;
+extern cvar_t	*g_saberNewControlScheme;
+
+extern qboolean InFront( vec3_t spot, vec3_t from, vec3_t fromAngles, float threshHold = 0.0f );
+extern void WP_ForcePowerDrain( gentity_t *self, forcePowers_t forcePower, int overrideAmt );
+extern qboolean ValidAnimFileIndex ( int index );
+extern qboolean PM_ControlledByPlayer( void );
+extern qboolean PM_DroidMelee( int npc_class );
+extern qboolean PM_PainAnim( int anim );
+extern qboolean PM_JumpingAnim( int anim );
+extern qboolean PM_FlippingAnim( int anim );
+extern qboolean PM_RollingAnim( int anim );
+extern qboolean PM_SwimmingAnim( int anim );
+extern qboolean PM_InKnockDown( playerState_t *ps );
+extern qboolean PM_InRoll( playerState_t *ps );
+extern qboolean PM_DodgeAnim( int anim );
+extern qboolean PM_InSlopeAnim( int anim );
+extern qboolean PM_ForceAnim( int anim );
+extern qboolean PM_InKnockDownOnGround( playerState_t *ps );
+extern qboolean PM_InSpecialJump( int anim );
+extern qboolean PM_RunningAnim( int anim );
+extern qboolean PM_WalkingAnim( int anim );
+extern qboolean PM_SwimmingAnim( int anim );
+extern qboolean PM_JumpingAnim( int anim );
+extern qboolean PM_SaberStanceAnim( int anim );
+extern qboolean PM_SaberDrawPutawayAnim( int anim );
+extern void PM_SetJumped( float height, qboolean force );
+extern qboolean PM_InGetUpNoRoll( playerState_t *ps );
+extern qboolean PM_CrouchAnim( int anim );
+extern qboolean G_TryingKataAttack( gentity_t *self, usercmd_t *cmd );
+extern qboolean G_TryingCartwheel( gentity_t *self, usercmd_t *cmd );
+extern qboolean G_TryingSpecial( gentity_t *self, usercmd_t *cmd );
+extern qboolean G_TryingJumpAttack( gentity_t *self, usercmd_t *cmd );
+extern qboolean G_TryingJumpForwardAttack( gentity_t *self, usercmd_t *cmd );
+extern qboolean G_TryingLungeAttack( gentity_t *self, usercmd_t *cmd );
+extern qboolean G_TryingPullAttack( gentity_t *self, usercmd_t *cmd, qboolean amPulling );
+extern qboolean G_InCinematicSaberAnim( gentity_t *self );
+extern qboolean G_ControlledByPlayer( gentity_t *self );
+
+extern int g_crosshairEntNum;
+
+int PM_AnimLength( int index, animNumber_t anim );
+qboolean PM_LockedAnim( int anim );
+qboolean PM_StandingAnim( int anim );
+qboolean PM_InOnGroundAnim ( playerState_t *ps );
+qboolean PM_SuperBreakWinAnim( int anim );
+qboolean PM_SuperBreakLoseAnim( int anim );
+qboolean PM_LockedAnim( int anim );
+saberMoveName_t PM_SaberFlipOverAttackMove( void );
+qboolean PM_CheckFlipOverAttackMove( qboolean checkEnemy );
+saberMoveName_t PM_SaberJumpForwardAttackMove( void );
+qboolean PM_CheckJumpForwardAttackMove( void );
+saberMoveName_t PM_SaberBackflipAttackMove( void );
+qboolean PM_CheckBackflipAttackMove( void );
+saberMoveName_t PM_SaberDualJumpAttackMove( void );
+qboolean PM_CheckDualJumpAttackMove( void );
+saberMoveName_t PM_SaberLungeAttackMove( qboolean fallbackToNormalLunge );
+qboolean PM_CheckLungeAttackMove( void );
+// Okay, here lies the much-dreaded Pat-created FSM movement chart...  Heretic II strikes again!
+// Why am I inflicting this on you?  Well, it's better than hardcoded states.
+// Ideally this will be replaced with an external file or more sophisticated move-picker
+// once the game gets out of prototype stage.
+
+// Silly, but I'm replacing these macros so they are shorter!
+#define AFLAG_IDLE	(SETANIM_FLAG_NORMAL)
+#define AFLAG_ACTIVE (SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLD | SETANIM_FLAG_HOLDLESS)
+#define AFLAG_WAIT (SETANIM_FLAG_HOLD | SETANIM_FLAG_HOLDLESS)
+#define AFLAG_FINISH (SETANIM_FLAG_HOLD)
+
+//FIXME: add the alternate anims for each style?
+saberMoveData_t	saberMoveData[LS_MOVE_MAX] = {//							NB:randomized
+	// name			anim(do all styles?)startQ	endQ	setanimflag		blend,	blocking	chain_idle		chain_attack	trailLen
+	{"None",		BOTH_STAND1,		Q_R,	Q_R,	AFLAG_IDLE,		350,	BLK_NO,		LS_NONE,		LS_NONE,		0	},	// LS_NONE		= 0,
+
+	// General movements with saber
+	{"Ready",		BOTH_STAND2,		Q_R,	Q_R,	AFLAG_IDLE,		350,	BLK_WIDE,	LS_READY,		LS_S_R2L,		0	},	// LS_READY,
+	{"Draw",		BOTH_STAND1TO2,		Q_R,	Q_R,	AFLAG_FINISH,	350,	BLK_NO,		LS_READY,		LS_S_R2L,		0	},	// LS_DRAW,
+	{"Putaway",		BOTH_STAND2TO1,		Q_R,	Q_R,	AFLAG_FINISH,	350,	BLK_NO,		LS_READY,		LS_S_R2L,		0	},	// LS_PUTAWAY,
+
+	// Attacks
+	//UL2LR
+	{"TL2BR Att",	BOTH_A1_TL_BR,		Q_TL,	Q_BR,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_R_TL2BR,		LS_R_TL2BR,		200	},	// LS_A_TL2BR
+	//SLASH LEFT
+	{"L2R Att",		BOTH_A1__L__R,		Q_L,	Q_R,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_R_L2R,		LS_R_L2R,		200 },	// LS_A_L2R
+	//LL2UR
+	{"BL2TR Att",	BOTH_A1_BL_TR,		Q_BL,	Q_TR,	AFLAG_ACTIVE,	50,		BLK_TIGHT,	LS_R_BL2TR,		LS_R_BL2TR,		200	},	// LS_A_BL2TR
+	//LR2UL
+	{"BR2TL Att",	BOTH_A1_BR_TL,		Q_BR,	Q_TL,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_R_BR2TL,		LS_R_BR2TL,		200	},	// LS_A_BR2TL
+	//SLASH RIGHT
+	{"R2L Att",		BOTH_A1__R__L,		Q_R,	Q_L,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_R_R2L,		LS_R_R2L,		200 },// LS_A_R2L
+	//UR2LL
+	{"TR2BL Att",	BOTH_A1_TR_BL,		Q_TR,	Q_BL,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_R_TR2BL,		LS_R_TR2BL,		200	},	// LS_A_TR2BL
+	//SLASH DOWN
+	{"T2B Att",		BOTH_A1_T__B_,		Q_T,	Q_B,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_R_T2B,		LS_R_T2B,		200	},	// LS_A_T2B
+	//special attacks
+	{"Back Stab",	BOTH_A2_STABBACK1,	Q_R,	Q_R,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_READY,		LS_READY,		200	},	// LS_A_BACKSTAB
+	{"Back Att",	BOTH_ATTACK_BACK,	Q_R,	Q_R,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_READY,		LS_READY,		200	},	// LS_A_BACK
+	{"CR Back Att",	BOTH_CROUCHATTACKBACK1,Q_R,	Q_R,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_READY,		LS_READY,		200	},	// LS_A_BACK_CR
+	{"RollStab",	BOTH_ROLL_STAB,		Q_R,	Q_R,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_READY,		LS_READY,		200	},	// LS_ROLL_STAB
+	{"Lunge Att",	BOTH_LUNGE2_B__T_,	Q_B,	Q_T,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_READY,		LS_READY,		200	},	// LS_A_LUNGE
+	{"Jump Att",	BOTH_FORCELEAP2_T__B_,Q_T,	Q_B,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_READY,		LS_READY,		200	},	// LS_A_JUMP_T__B_
+	{"Flip Stab",	BOTH_JUMPFLIPSTABDOWN,Q_R,	Q_T,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_READY,		LS_T1_T___R,	200	},	// LS_A_FLIP_STAB
+	{"Flip Slash",	BOTH_JUMPFLIPSLASHDOWN1,Q_L,Q_R,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_READY,		LS_T1__R_T_,	200	},	// LS_A_FLIP_SLASH
+	{"DualJump Atk",BOTH_JUMPATTACK6,	Q_R,	Q_BL,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_READY,		LS_T1_BL_TR,	200	},	// LS_JUMPATTACK_DUAL
+
+	{"DualJumpAtkL_A",BOTH_ARIAL_LEFT,	Q_R,	Q_TL,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_READY,		LS_A_TL2BR,		200	},	// LS_JUMPATTACK_ARIAL_LEFT
+	{"DualJumpAtkR_A",BOTH_ARIAL_RIGHT,	Q_R,	Q_TR,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_READY,		LS_A_TR2BL,		200	},	// LS_JUMPATTACK_ARIAL_RIGHT
+
+	{"DualJumpAtkL_A",BOTH_CARTWHEEL_LEFT,	Q_R,Q_TL,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_READY,		LS_T1_TL_BR,	200	},	// LS_JUMPATTACK_CART_LEFT
+	{"DualJumpAtkR_A",BOTH_CARTWHEEL_RIGHT,	Q_R,Q_TR,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_READY,		LS_T1_TR_BL,	200	},	// LS_JUMPATTACK_CART_RIGHT
+	
+	{"DualJumpAtkLStaff", BOTH_BUTTERFLY_FL1,Q_R,Q_L,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_READY,		LS_T1__L__R,	200	},	// LS_JUMPATTACK_STAFF_LEFT
+	{"DualJumpAtkRStaff", BOTH_BUTTERFLY_FR1,Q_R,Q_R,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_READY,		LS_T1__R__L,	200	},	// LS_JUMPATTACK_STAFF_RIGHT
+
+	{"ButterflyLeft", BOTH_BUTTERFLY_LEFT,Q_R,Q_L,		AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_READY,		LS_T1__L__R,	200	},	// LS_BUTTERFLY_LEFT
+	{"ButterflyRight", BOTH_BUTTERFLY_RIGHT,Q_R,Q_R,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_READY,		LS_T1__R__L,	200	},	// LS_BUTTERFLY_RIGHT
+	
+	{"BkFlip Atk",	BOTH_JUMPATTACK7,	Q_B,	Q_T,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_READY,		LS_T1_T___R,	200	},	// LS_A_BACKFLIP_ATK
+	{"DualSpinAtk",	BOTH_SPINATTACK6,	Q_R,	Q_R,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_READY,		LS_READY,		200	},	// LS_SPINATTACK_DUAL
+	{"StfSpinAtk",	BOTH_SPINATTACK7,	Q_L,	Q_R,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_READY,		LS_READY,		200	},	// LS_SPINATTACK
+	{"LngLeapAtk",	BOTH_FORCELONGLEAP_ATTACK,Q_R,Q_L,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_READY,		LS_READY,		200	},	// LS_LEAP_ATTACK
+	{"SwoopAtkR",	BOTH_VS_ATR_S,		Q_R,	Q_T,	AFLAG_ACTIVE,	100,	BLK_NO,		LS_READY,		LS_READY,		200	},	// LS_SWOOP_ATTACK_RIGHT
+	{"SwoopAtkL",	BOTH_VS_ATL_S,		Q_L,	Q_T,	AFLAG_ACTIVE,	100,	BLK_NO,		LS_READY,		LS_READY,		200	},	// LS_SWOOP_ATTACK_LEFT
+	{"TauntaunAtkR",BOTH_VT_ATR_S,		Q_R,	Q_T,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_READY,		LS_READY,		200	},	// LS_TAUNTAUN_ATTACK_RIGHT
+	{"TauntaunAtkL",BOTH_VT_ATL_S,		Q_L,	Q_T,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_READY,		LS_READY,		200	},	// LS_TAUNTAUN_ATTACK_LEFT
+	{"StfKickFwd",	BOTH_A7_KICK_F,		Q_R,	Q_R,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_READY,		LS_S_R2L,		200	},	// LS_KICK_F
+	{"StfKickBack",	BOTH_A7_KICK_B,		Q_R,	Q_R,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_READY,		LS_S_R2L,		200	},	// LS_KICK_B
+	{"StfKickRight",BOTH_A7_KICK_R,		Q_R,	Q_R,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_READY,		LS_S_R2L,		200	},	// LS_KICK_R
+	{"StfKickLeft",	BOTH_A7_KICK_L,		Q_R,	Q_R,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_READY,		LS_S_R2L,		200	},	// LS_KICK_L
+	{"StfKickSpin",	BOTH_A7_KICK_S,		Q_R,	Q_R,	AFLAG_ACTIVE,	100,	BLK_NO,		LS_READY,		LS_S_R2L,		200	},	// LS_KICK_S
+	{"StfKickBkFwd",BOTH_A7_KICK_BF,	Q_R,	Q_R,	AFLAG_ACTIVE,	100,	BLK_NO,		LS_READY,		LS_S_R2L,		200	},	// LS_KICK_BF
+	{"StfKickSplit",BOTH_A7_KICK_RL,	Q_R,	Q_R,	AFLAG_ACTIVE,	100,	BLK_NO,		LS_READY,		LS_S_R2L,		200	},	// LS_KICK_RL
+	{"StfKickFwdAir",BOTH_A7_KICK_F_AIR,Q_R,	Q_R,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_READY,		LS_S_R2L,		200	},	// LS_KICK_F_AIR
+	{"StfKickBackAir",BOTH_A7_KICK_B_AIR,Q_R,	Q_R,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_READY,		LS_S_R2L,		200	},	// LS_KICK_B_AIR
+	{"StfKickRightAir",BOTH_A7_KICK_R_AIR,Q_R,	Q_R,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_READY,		LS_S_R2L,		200	},	// LS_KICK_R_AIR
+	{"StfKickLeftAir",BOTH_A7_KICK_L_AIR,Q_R,	Q_R,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_READY,		LS_S_R2L,		200	},	// LS_KICK_L_AIR
+	{"StabDown",	BOTH_STABDOWN,		Q_R,	Q_R,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_READY,		LS_S_R2L,		200	},	// LS_STABDOWN
+	{"StabDownStf",	BOTH_STABDOWN_STAFF,Q_R,	Q_R,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_READY,		LS_S_R2L,		200	},	// LS_STABDOWN_STAFF
+	{"StabDownDual",BOTH_STABDOWN_DUAL,	Q_R,	Q_R,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_READY,		LS_S_R2L,		200	},	// LS_STABDOWN_DUAL
+	{"dualspinprot",BOTH_A6_SABERPROTECT,Q_R,	Q_R,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_READY,		LS_READY,		500	},	// LS_DUAL_SPIN_PROTECT
+	{"StfSoulCal",	BOTH_A7_SOULCAL,	Q_R,	Q_R,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_READY,		LS_READY,		500	},	// LS_STAFF_SOULCAL
+	{"specialfast",	BOTH_A1_SPECIAL,	Q_R,	Q_R,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_READY,		LS_READY,		2000},	// LS_A1_SPECIAL
+	{"specialmed",	BOTH_A2_SPECIAL,	Q_R,	Q_R,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_READY,		LS_READY,		2000},	// LS_A2_SPECIAL
+	{"specialstr",	BOTH_A3_SPECIAL,	Q_R,	Q_R,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_READY,		LS_READY,		2000},	// LS_A3_SPECIAL
+	{"upsidedwnatk",BOTH_FLIP_ATTACK7,	Q_R,	Q_R,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_READY,		LS_READY,		200},	// LS_UPSIDE_DOWN_ATTACK
+	{"pullatkstab",	BOTH_PULL_IMPALE_STAB,Q_R,	Q_R,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_READY,		LS_READY,		200},	// LS_PULL_ATTACK_STAB
+	{"pullatkswing",BOTH_PULL_IMPALE_SWING,Q_R,	Q_R,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_READY,		LS_READY,		200},	// LS_PULL_ATTACK_SWING
+	{"AloraSpinAtk",BOTH_ALORA_SPIN_SLASH,Q_R,	Q_R,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_READY,		LS_READY,		200	},	// LS_SPINATTACK_ALORA
+	{"Dual FB Atk",	BOTH_A6_FB,			Q_R,	Q_R,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_READY,		LS_READY,		200	},	// LS_DUAL_FB
+	{"Dual LR Atk",	BOTH_A6_LR,			Q_R,	Q_R,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_READY,		LS_READY,		200 },	// LS_DUAL_LR
+	{"StfHiltBash",	BOTH_A7_HILT,		Q_R,	Q_R,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_READY,		LS_READY,		200	},	// LS_HILT_BASH
+
+	//starts
+	{"TL2BR St",	BOTH_S1_S1_TL,		Q_R,	Q_TL,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_A_TL2BR,		LS_A_TL2BR,		200	},	// LS_S_TL2BR
+	{"L2R St",		BOTH_S1_S1__L,		Q_R,	Q_L,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_A_L2R,		LS_A_L2R,		200	},	// LS_S_L2R
+	{"BL2TR St",	BOTH_S1_S1_BL,		Q_R,	Q_BL,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_A_BL2TR,		LS_A_BL2TR,		200	},	// LS_S_BL2TR
+	{"BR2TL St",	BOTH_S1_S1_BR,		Q_R,	Q_BR,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_A_BR2TL,		LS_A_BR2TL,		200	},	// LS_S_BR2TL
+	{"R2L St",		BOTH_S1_S1__R,		Q_R,	Q_R,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_A_R2L,		LS_A_R2L,		200	},	// LS_S_R2L
+	{"TR2BL St",	BOTH_S1_S1_TR,		Q_R,	Q_TR,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_A_TR2BL,		LS_A_TR2BL,		200	},	// LS_S_TR2BL
+	{"T2B St",		BOTH_S1_S1_T_,		Q_R,	Q_T,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_A_T2B,		LS_A_T2B,		200	},	// LS_S_T2B
+	
+	//returns
+	{"TL2BR Ret",	BOTH_R1_BR_S1,		Q_BR,	Q_R,	AFLAG_FINISH,	100,	BLK_TIGHT,	LS_READY,		LS_READY,		200	},	// LS_R_TL2BR
+	{"L2R Ret",		BOTH_R1__R_S1,		Q_R,	Q_R,	AFLAG_FINISH,	100,	BLK_TIGHT,	LS_READY,		LS_READY,		200	},	// LS_R_L2R
+	{"BL2TR Ret",	BOTH_R1_TR_S1,		Q_TR,	Q_R,	AFLAG_FINISH,	100,	BLK_TIGHT,	LS_READY,		LS_READY,		200	},	// LS_R_BL2TR
+	{"BR2TL Ret",	BOTH_R1_TL_S1,		Q_TL,	Q_R,	AFLAG_FINISH,	100,	BLK_TIGHT,	LS_READY,		LS_READY,		200	},	// LS_R_BR2TL
+	{"R2L Ret",		BOTH_R1__L_S1,		Q_L,	Q_R,	AFLAG_FINISH,	100,	BLK_TIGHT,	LS_READY,		LS_READY,		200	},	// LS_R_R2L
+	{"TR2BL Ret",	BOTH_R1_BL_S1,		Q_BL,	Q_R,	AFLAG_FINISH,	100,	BLK_TIGHT,	LS_READY,		LS_READY,		200	},	// LS_R_TR2BL
+	{"T2B Ret",		BOTH_R1_B__S1,		Q_B,	Q_R,	AFLAG_FINISH,	100,	BLK_TIGHT,	LS_READY,		LS_READY,		200	},	// LS_R_T2B
+
+	//Transitions
+	{"BR2R Trans",	BOTH_T1_BR__R,		Q_BR,	Q_R,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_L2R,		LS_A_R2L,		150	},	//# Fast arc bottom right to right
+	{"BR2TR Trans",	BOTH_T1_BR_TR,		Q_BR,	Q_TR,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_BL2TR,		LS_A_TR2BL,		150	},	//# Fast arc bottom right to top right		(use: BOTH_T1_TR_BR)
+	{"BR2T Trans",	BOTH_T1_BR_T_,		Q_BR,	Q_T,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_BL2TR,		LS_A_T2B,		150	},	//# Fast arc bottom right to top			(use: BOTH_T1_T__BR)
+	{"BR2TL Trans",	BOTH_T1_BR_TL,		Q_BR,	Q_TL,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_BR2TL,		LS_A_TL2BR,		150	},	//# Fast weak spin bottom right to top left
+	{"BR2L Trans",	BOTH_T1_BR__L,		Q_BR,	Q_L,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_R2L,		LS_A_L2R,		150	},	//# Fast weak spin bottom right to left
+	{"BR2BL Trans",	BOTH_T1_BR_BL,		Q_BR,	Q_BL,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_TR2BL,		LS_A_BL2TR,		150	},	//# Fast weak spin bottom right to bottom left
+	{"R2BR Trans",	BOTH_T1__R_BR,		Q_R,	Q_BR,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_TL2BR,		LS_A_BR2TL,		150	},	//# Fast arc right to bottom right			(use: BOTH_T1_BR__R)
+	{"R2TR Trans",	BOTH_T1__R_TR,		Q_R,	Q_TR,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_BL2TR,		LS_A_TR2BL,		150	},	//# Fast arc right to top right
+	{"R2T Trans",	BOTH_T1__R_T_,		Q_R,	Q_T,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_BL2TR,		LS_A_T2B,		150	},	//# Fast ar right to top				(use: BOTH_T1_T___R)
+	{"R2TL Trans",	BOTH_T1__R_TL,		Q_R,	Q_TL,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_BR2TL,		LS_A_TL2BR,		150	},	//# Fast arc right to top left
+	{"R2L Trans",	BOTH_T1__R__L,		Q_R,	Q_L,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_R2L,		LS_A_L2R,		150	},	//# Fast weak spin right to left
+	{"R2BL Trans",	BOTH_T1__R_BL,		Q_R,	Q_BL,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_TR2BL,		LS_A_BL2TR,		150	},	//# Fast weak spin right to bottom left
+	{"TR2BR Trans",	BOTH_T1_TR_BR,		Q_TR,	Q_BR,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_TL2BR,		LS_A_BR2TL,		150	},	//# Fast arc top right to bottom right
+	{"TR2R Trans",	BOTH_T1_TR__R,		Q_TR,	Q_R,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_L2R,		LS_A_R2L,		150	},	//# Fast arc top right to right			(use: BOTH_T1__R_TR)
+	{"TR2T Trans",	BOTH_T1_TR_T_,		Q_TR,	Q_T,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_BL2TR,		LS_A_T2B,		150	},	//# Fast arc top right to top				(use: BOTH_T1_T__TR)
+	{"TR2TL Trans",	BOTH_T1_TR_TL,		Q_TR,	Q_TL,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_BR2TL,		LS_A_TL2BR,		150	},	//# Fast arc top right to top left
+	{"TR2L Trans",	BOTH_T1_TR__L,		Q_TR,	Q_L,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_R2L,		LS_A_L2R,		150	},	//# Fast arc top right to left
+	{"TR2BL Trans",	BOTH_T1_TR_BL,		Q_TR,	Q_BL,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_TR2BL,		LS_A_BL2TR,		150	},	//# Fast weak spin top right to bottom left
+	{"T2BR Trans",	BOTH_T1_T__BR,		Q_T,	Q_BR,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_TL2BR,		LS_A_BR2TL,		150	},	//# Fast arc top to bottom right
+	{"T2R Trans",	BOTH_T1_T___R,		Q_T,	Q_R,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_L2R,		LS_A_R2L,		150	},	//# Fast arc top to right
+	{"T2TR Trans",	BOTH_T1_T__TR,		Q_T,	Q_TR,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_BL2TR,		LS_A_TR2BL,		150	},	//# Fast arc top to top right
+	{"T2TL Trans",	BOTH_T1_T__TL,		Q_T,	Q_TL,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_BR2TL,		LS_A_TL2BR,		150	},	//# Fast arc top to top left
+	{"T2L Trans",	BOTH_T1_T___L,		Q_T,	Q_L,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_R2L,		LS_A_L2R,		150	},	//# Fast arc top to left
+	{"T2BL Trans",	BOTH_T1_T__BL,		Q_T,	Q_BL,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_TR2BL,		LS_A_BL2TR,		150	},	//# Fast arc top to bottom left
+	{"TL2BR Trans",	BOTH_T1_TL_BR,		Q_TL,	Q_BR,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_TL2BR,		LS_A_BR2TL,		150	},	//# Fast weak spin top left to bottom right
+	{"TL2R Trans",	BOTH_T1_TL__R,		Q_TL,	Q_R,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_L2R,		LS_A_R2L,		150	},	//# Fast arc top left to right			(use: BOTH_T1__R_TL)
+	{"TL2TR Trans",	BOTH_T1_TL_TR,		Q_TL,	Q_TR,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_BL2TR,		LS_A_TR2BL,		150	},	//# Fast arc top left to top right			(use: BOTH_T1_TR_TL)
+	{"TL2T Trans",	BOTH_T1_TL_T_,		Q_TL,	Q_T,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_BL2TR,		LS_A_T2B,		150	},	//# Fast arc top left to top				(use: BOTH_T1_T__TL)
+	{"TL2L Trans",	BOTH_T1_TL__L,		Q_TL,	Q_L,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_R2L,		LS_A_L2R,		150	},	//# Fast arc top left to left				(use: BOTH_T1__L_TL)
+	{"TL2BL Trans",	BOTH_T1_TL_BL,		Q_TL,	Q_BL,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_TR2BL,		LS_A_BL2TR,		150	},	//# Fast arc top left to bottom left
+	{"L2BR Trans",	BOTH_T1__L_BR,		Q_L,	Q_BR,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_TL2BR,		LS_A_BR2TL,		150	},	//# Fast weak spin left to bottom right
+	{"L2R Trans",	BOTH_T1__L__R,		Q_L,	Q_R,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_L2R,		LS_A_R2L,		150	},	//# Fast weak spin left to right
+	{"L2TR Trans",	BOTH_T1__L_TR,		Q_L,	Q_TR,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_BL2TR,		LS_A_TR2BL,		150	},	//# Fast arc left to top right			(use: BOTH_T1_TR__L)
+	{"L2T Trans",	BOTH_T1__L_T_,		Q_L,	Q_T,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_BL2TR,		LS_A_T2B,		150	},	//# Fast arc left to top				(use: BOTH_T1_T___L)
+	{"L2TL Trans",	BOTH_T1__L_TL,		Q_L,	Q_TL,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_BR2TL,		LS_A_TL2BR,		150	},	//# Fast arc left to top left
+	{"L2BL Trans",	BOTH_T1__L_BL,		Q_L,	Q_BL,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_TR2BL,		LS_A_BL2TR,		150	},	//# Fast arc left to bottom left			(use: BOTH_T1_BL__L)
+	{"BL2BR Trans",	BOTH_T1_BL_BR,		Q_BL,	Q_BR,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_TL2BR,		LS_A_BR2TL,		150	},	//# Fast weak spin bottom left to bottom right
+	{"BL2R Trans",	BOTH_T1_BL__R,		Q_BL,	Q_R,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_L2R,		LS_A_R2L,		150	},	//# Fast weak spin bottom left to right
+	{"BL2TR Trans",	BOTH_T1_BL_TR,		Q_BL,	Q_TR,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_BL2TR,		LS_A_TR2BL,		150	},	//# Fast weak spin bottom left to top right
+	{"BL2T Trans",	BOTH_T1_BL_T_,		Q_BL,	Q_T,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_BL2TR,		LS_A_T2B,		150	},	//# Fast arc bottom left to top			(use: BOTH_T1_T__BL)
+	{"BL2TL Trans",	BOTH_T1_BL_TL,		Q_BL,	Q_TL,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_BR2TL,		LS_A_TL2BR,		150	},	//# Fast arc bottom left to top left		(use: BOTH_T1_TL_BL)
+	{"BL2L Trans",	BOTH_T1_BL__L,		Q_BL,	Q_L,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_R2L,		LS_A_L2R,		150	},	//# Fast arc bottom left to left
+
+	//Bounces
+	{"Bounce BR",	BOTH_B1_BR___,		Q_BR,	Q_BR,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_TL2BR,		LS_T1_BR_TR,	150	},	
+	{"Bounce R",	BOTH_B1__R___,		Q_R,	Q_R,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_L2R,		LS_T1__R__L,	150	},	
+	{"Bounce TR",	BOTH_B1_TR___,		Q_TR,	Q_TR,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_BL2TR,		LS_T1_TR_TL,	150	},	
+	{"Bounce T",	BOTH_B1_T____,		Q_T,	Q_T,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_BL2TR,		LS_T1_T__BL,	150	},	
+	{"Bounce TL",	BOTH_B1_TL___,		Q_TL,	Q_TL,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_BR2TL,		LS_T1_TL_TR,	150	},	
+	{"Bounce L",	BOTH_B1__L___,		Q_L,	Q_L,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_R2L,		LS_T1__L__R,	150	},	
+	{"Bounce BL",	BOTH_B1_BL___,		Q_BL,	Q_BL,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_TR2BL,		LS_T1_BL_TR,	150	},	
+
+	//Deflected attacks (like bounces, but slide off enemy saber, not straight back)
+	{"Deflect BR",	BOTH_D1_BR___,		Q_BR,	Q_BR,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_TL2BR,		LS_T1_BR_TR,	150	},	
+	{"Deflect R",	BOTH_D1__R___,		Q_R,	Q_R,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_L2R,		LS_T1__R__L,	150	},	
+	{"Deflect TR",	BOTH_D1_TR___,		Q_TR,	Q_TR,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_BL2TR,		LS_T1_TR_TL,	150	},	
+	{"Deflect T",	BOTH_B1_T____,		Q_T,	Q_T,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_BL2TR,		LS_T1_T__BL,	150	},	
+	{"Deflect TL",	BOTH_D1_TL___,		Q_TL,	Q_TL,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_BR2TL,		LS_T1_TL_TR,	150	},	
+	{"Deflect L",	BOTH_D1__L___,		Q_L,	Q_L,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_R2L,		LS_T1__L__R,	150	},	
+	{"Deflect BL",	BOTH_D1_BL___,		Q_BL,	Q_BL,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_TR2BL,		LS_T1_BL_TR,	150	},	
+	{"Deflect B",	BOTH_D1_B____,		Q_B,	Q_B,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_BL2TR,		LS_T1_T__BL,	150	},	
+
+	//Reflected attacks
+	{"Reflected BR",BOTH_V1_BR_S1,		Q_BR,	Q_BR,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_READY,		LS_READY,	150	},//	LS_V1_BR
+	{"Reflected R",	BOTH_V1__R_S1,		Q_R,	Q_R,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_READY,		LS_READY,	150	},//	LS_V1__R
+	{"Reflected TR",BOTH_V1_TR_S1,		Q_TR,	Q_TR,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_READY,		LS_READY,	150	},//	LS_V1_TR
+	{"Reflected T",	BOTH_V1_T__S1,		Q_T,	Q_T,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_READY,		LS_READY,	150	},//	LS_V1_T_
+	{"Reflected TL",BOTH_V1_TL_S1,		Q_TL,	Q_TL,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_READY,		LS_READY,	150	},//	LS_V1_TL
+	{"Reflected L",	BOTH_V1__L_S1,		Q_L,	Q_L,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_READY,		LS_READY,	150	},//	LS_V1__L
+	{"Reflected BL",BOTH_V1_BL_S1,		Q_BL,	Q_BL,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_READY,		LS_READY,	150	},//	LS_V1_BL
+	{"Reflected B",	BOTH_V1_B__S1,		Q_B,	Q_B,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_READY,		LS_READY,	150	},//	LS_V1_B_
+
+	// Broken parries
+	{"BParry Top",	BOTH_H1_S1_T_,		Q_T,	Q_B,	AFLAG_ACTIVE,	50,		BLK_NO,	LS_READY,		LS_READY,		150	},	// LS_PARRY_UP,
+	{"BParry UR",	BOTH_H1_S1_TR,		Q_TR,	Q_BL,	AFLAG_ACTIVE,	50,		BLK_NO,	LS_READY,		LS_READY,		150	},	// LS_PARRY_UR,
+	{"BParry UL",	BOTH_H1_S1_TL,		Q_TL,	Q_BR,	AFLAG_ACTIVE,	50,		BLK_NO,	LS_READY,		LS_READY,		150	},	// LS_PARRY_UL,
+	{"BParry LR",	BOTH_H1_S1_BL,		Q_BL,	Q_TR,	AFLAG_ACTIVE,	50,		BLK_NO,	LS_READY,		LS_READY,		150	},	// LS_PARRY_LR,
+	{"BParry Bot",	BOTH_H1_S1_B_,		Q_B,	Q_T,	AFLAG_ACTIVE,	50,		BLK_NO,	LS_READY,		LS_READY,		150	},	// LS_PARRY_LL
+	{"BParry LL",	BOTH_H1_S1_BR,		Q_BR,	Q_TL,	AFLAG_ACTIVE,	50,		BLK_NO,	LS_READY,		LS_READY,		150	},	// LS_PARRY_LL
+
+	// Knockaways
+	{"Knock Top",	BOTH_K1_S1_T_,		Q_R,	Q_T,	AFLAG_ACTIVE,	50,		BLK_WIDE,	LS_R_BL2TR,		LS_T1_T__BR,		150	},	// LS_PARRY_UP,
+	{"Knock UR",	BOTH_K1_S1_TR,		Q_R,	Q_TR,	AFLAG_ACTIVE,	50,		BLK_WIDE,	LS_R_BL2TR,		LS_T1_TR__R,		150	},	// LS_PARRY_UR,
+	{"Knock UL",	BOTH_K1_S1_TL,		Q_R,	Q_TL,	AFLAG_ACTIVE,	50,		BLK_WIDE,	LS_R_BR2TL,		LS_T1_TL__L,		150	},	// LS_PARRY_UL,
+	{"Knock LR",	BOTH_K1_S1_BL,		Q_R,	Q_BL,	AFLAG_ACTIVE,	50,		BLK_WIDE,	LS_R_TL2BR,		LS_T1_BL_TL,		150	},	// LS_PARRY_LR,
+	{"Knock LL",	BOTH_K1_S1_BR,		Q_R,	Q_BR,	AFLAG_ACTIVE,	50,		BLK_WIDE,	LS_R_TR2BL,		LS_T1_BR_TR,		150	},	// LS_PARRY_LL
+
+	// Parry
+	{"Parry Top",	BOTH_P1_S1_T_,		Q_R,	Q_T,	AFLAG_ACTIVE,	50,		BLK_WIDE,	LS_R_BL2TR,		LS_A_T2B,		150	},	// LS_PARRY_UP,
+	{"Parry UR",	BOTH_P1_S1_TR,		Q_R,	Q_TL,	AFLAG_ACTIVE,	50,		BLK_WIDE,	LS_R_BL2TR,		LS_A_TR2BL,		150	},	// LS_PARRY_UR,
+	{"Parry UL",	BOTH_P1_S1_TL,		Q_R,	Q_TR,	AFLAG_ACTIVE,	50,		BLK_WIDE,	LS_R_BR2TL,		LS_A_TL2BR,		150	},	// LS_PARRY_UL,
+	{"Parry LR",	BOTH_P1_S1_BL,		Q_R,	Q_BR,	AFLAG_ACTIVE,	50,		BLK_WIDE,	LS_R_TL2BR,		LS_A_BR2TL,		150	},	// LS_PARRY_LR,
+	{"Parry LL",	BOTH_P1_S1_BR,		Q_R,	Q_BL,	AFLAG_ACTIVE,	50,		BLK_WIDE,	LS_R_TR2BL,		LS_A_BL2TR,		150	},	// LS_PARRY_LL
+
+	// Reflecting a missile
+	{"Reflect Top",	BOTH_P1_S1_T_,		Q_R,	Q_T,	AFLAG_ACTIVE,	50,		BLK_WIDE,	LS_R_BL2TR,		LS_A_T2B,		300	},	// LS_PARRY_UP,
+	{"Reflect UR",	BOTH_P1_S1_TL,		Q_R,	Q_TR,	AFLAG_ACTIVE,	50,		BLK_WIDE,	LS_R_BR2TL,		LS_A_TL2BR,		300	},	// LS_PARRY_UR,
+	{"Reflect UL",	BOTH_P1_S1_TR,		Q_R,	Q_TL,	AFLAG_ACTIVE,	50,		BLK_WIDE,	LS_R_BL2TR,		LS_A_TR2BL,		300	},	// LS_PARRY_UL,
+	{"Reflect LR",	BOTH_P1_S1_BR,		Q_R,	Q_BL,	AFLAG_ACTIVE,	50,		BLK_WIDE,	LS_R_TR2BL,		LS_A_BL2TR,		300	},	// LS_PARRY_LR
+	{"Reflect LL",	BOTH_P1_S1_BL,		Q_R,	Q_BR,	AFLAG_ACTIVE,	50,		BLK_WIDE,	LS_R_TL2BR,		LS_A_BR2TL,		300	},	// LS_PARRY_LL,
+};
+
+
+saberMoveName_t transitionMove[Q_NUM_QUADS][Q_NUM_QUADS] = 
+{
+	LS_NONE,	//Can't transition to same pos!
+	LS_T1_BR__R,//40
+	LS_T1_BR_TR,
+	LS_T1_BR_T_,
+	LS_T1_BR_TL,
+	LS_T1_BR__L,
+	LS_T1_BR_BL,
+	LS_NONE,	//No transitions to bottom, and no anims start there, so shouldn't need any
+	LS_T1__R_BR,//46
+	LS_NONE,	//Can't transition to same pos!
+	LS_T1__R_TR,
+	LS_T1__R_T_,
+	LS_T1__R_TL,
+	LS_T1__R__L,
+	LS_T1__R_BL,
+	LS_NONE,	//No transitions to bottom, and no anims start there, so shouldn't need any
+	LS_T1_TR_BR,//52
+	LS_T1_TR__R,
+	LS_NONE,	//Can't transition to same pos!
+	LS_T1_TR_T_,
+	LS_T1_TR_TL,
+	LS_T1_TR__L,
+	LS_T1_TR_BL,
+	LS_NONE,	//No transitions to bottom, and no anims start there, so shouldn't need any
+	LS_T1_T__BR,//58
+	LS_T1_T___R,
+	LS_T1_T__TR,
+	LS_NONE,	//Can't transition to same pos!
+	LS_T1_T__TL,
+	LS_T1_T___L,
+	LS_T1_T__BL,
+	LS_NONE,	//No transitions to bottom, and no anims start there, so shouldn't need any
+	LS_T1_TL_BR,//64
+	LS_T1_TL__R,
+	LS_T1_TL_TR,
+	LS_T1_TL_T_,
+	LS_NONE,	//Can't transition to same pos!
+	LS_T1_TL__L,
+	LS_T1_TL_BL,
+	LS_NONE,	//No transitions to bottom, and no anims start there, so shouldn't need any
+	LS_T1__L_BR,//70
+	LS_T1__L__R,
+	LS_T1__L_TR,
+	LS_T1__L_T_,
+	LS_T1__L_TL,
+	LS_NONE,	//Can't transition to same pos!
+	LS_T1__L_BL,
+	LS_NONE,	//No transitions to bottom, and no anims start there, so shouldn't need any
+	LS_T1_BL_BR,//76
+	LS_T1_BL__R,
+	LS_T1_BL_TR,
+	LS_T1_BL_T_,
+	LS_T1_BL_TL,
+	LS_T1_BL__L,
+	LS_NONE,	//Can't transition to same pos!
+	LS_NONE,	//No transitions to bottom, and no anims start there, so shouldn't need any
+	LS_T1_BL_BR,//NOTE: there are no transitions from bottom, so re-use the bottom right transitions
+	LS_T1_BR__R,
+	LS_T1_BR_TR,
+	LS_T1_BR_T_,
+	LS_T1_BR_TL,
+	LS_T1_BR__L,
+	LS_T1_BR_BL,
+	LS_NONE		//No transitions to bottom, and no anims start there, so shouldn't need any
+};
+
+void PM_VelocityForSaberMove( playerState_t *ps, vec3_t throwDir )
+{
+	vec3_t	vForward, vRight, vUp, startQ, endQ;
+
+	AngleVectors( ps->viewangles, vForward, vRight, vUp );
+
+	switch ( saberMoveData[ps->saberMove].startQuad )
+	{
+	case Q_BR:
+		VectorScale( vRight, 1, startQ );
+		VectorMA( startQ, -1, vUp, startQ );
+		break;
+	case Q_R:
+		VectorScale( vRight, 2, startQ );
+		break;
+	case Q_TR:
+		VectorScale( vRight, 1, startQ );
+		VectorMA( startQ, 1, vUp, startQ );
+		break;
+	case Q_T:
+		VectorScale( vUp, 2, startQ );
+		break;
+	case Q_TL:
+		VectorScale( vRight, -1, startQ );
+		VectorMA( startQ, 1, vUp, startQ );
+		break;
+	case Q_L:
+		VectorScale( vRight, -2, startQ );
+		break;
+	case Q_BL:
+		VectorScale( vRight, -1, startQ );
+		VectorMA( startQ, -1, vUp, startQ );
+		break;
+	case Q_B:
+		VectorScale( vUp, -2, startQ );
+		break;
+	}
+	switch ( saberMoveData[ps->saberMove].endQuad )
+	{
+	case Q_BR:
+		VectorScale( vRight, 1, endQ );
+		VectorMA( endQ, -1, vUp, endQ );
+		break;
+	case Q_R:
+		VectorScale( vRight, 2, endQ );
+		break;
+	case Q_TR:
+		VectorScale( vRight, 1, endQ );
+		VectorMA( endQ, 1, vUp, endQ );
+		break;
+	case Q_T:
+		VectorScale( vUp, 2, endQ );
+		break;
+	case Q_TL:
+		VectorScale( vRight, -1, endQ );
+		VectorMA( endQ, 1, vUp, endQ );
+		break;
+	case Q_L:
+		VectorScale( vRight, -2, endQ );
+		break;
+	case Q_BL:
+		VectorScale( vRight, -1, endQ );
+		VectorMA( endQ, -1, vUp, endQ );
+		break;
+	case Q_B:
+		VectorScale( vUp, -2, endQ );
+		break;
+	}
+	VectorMA( endQ, 2, vForward, endQ );
+	VectorScale( throwDir, 125, throwDir );//FIXME: pass in the throw strength?
+	VectorSubtract( endQ, startQ, throwDir );
+}
+
+qboolean PM_VelocityForBlockedMove( playerState_t *ps, vec3_t throwDir )
+{
+	vec3_t	vForward, vRight, vUp;
+	AngleVectors( ps->viewangles, vForward, vRight, vUp );
+	switch ( ps->saberBlocked )
+	{
+	case BLOCKED_UPPER_RIGHT:
+		VectorScale( vRight, 1, throwDir );
+		VectorMA( throwDir, 1, vUp, throwDir );
+		break;
+	case BLOCKED_UPPER_LEFT:
+		VectorScale( vRight, -1, throwDir );
+		VectorMA( throwDir, 1, vUp, throwDir );
+		break;
+	case BLOCKED_LOWER_RIGHT:
+		VectorScale( vRight, 1, throwDir );
+		VectorMA( throwDir, -1, vUp, throwDir );
+		break;
+	case BLOCKED_LOWER_LEFT:
+		VectorScale( vRight, -1, throwDir );
+		VectorMA( throwDir, -1, vUp, throwDir );
+		break;
+	case BLOCKED_TOP:
+		VectorScale( vUp, 2, throwDir );
+		break;
+	default:
+		return qfalse;
+		break;
+	}
+	VectorMA( throwDir, 2, vForward, throwDir );
+	VectorScale( throwDir, 250, throwDir );//FIXME: pass in the throw strength?
+	return qtrue;
+}
+
+int PM_AnimLevelForSaberAnim( int anim )
+{
+	if ( anim >= BOTH_A1_T__B_ && anim <= BOTH_D1_B____ )
+	{
+		return FORCE_LEVEL_1;
+	}
+	if ( anim >= BOTH_A2_T__B_ && anim <= BOTH_D2_B____ )
+	{
+		return FORCE_LEVEL_2;
+	}
+	if ( anim >= BOTH_A3_T__B_ && anim <= BOTH_D3_B____ )
+	{
+		return FORCE_LEVEL_3;
+	}
+	if ( anim >= BOTH_A4_T__B_ && anim <= BOTH_D4_B____ )
+	{//desann
+		return FORCE_LEVEL_4;
+	}
+	if ( anim >= BOTH_A5_T__B_ && anim <= BOTH_D5_B____ )
+	{//tavion
+		return FORCE_LEVEL_5;
+	}
+	if ( anim >= BOTH_A6_T__B_ && anim <= BOTH_D6_B____ )
+	{//dual
+		return SS_DUAL;
+	}
+	if ( anim >= BOTH_A7_T__B_ && anim <= BOTH_D7_B____ )
+	{//staff
+		return SS_STAFF;
+	}
+	return FORCE_LEVEL_0;
+}
+
+int PM_PowerLevelForSaberAnim( playerState_t *ps, int saberNum )
+{
+	int anim = ps->torsoAnim;
+	int	animTimeElapsed = PM_AnimLength( g_entities[ps->clientNum].client->clientInfo.animFileIndex, (animNumber_t)anim ) - ps->torsoAnimTimer;
+	if ( anim >= BOTH_A1_T__B_ && anim <= BOTH_D1_B____ )
+	{
+		//FIXME: these two need their own style
+		if ( ps->saber[0].type == SABER_LANCE )
+		{
+			return FORCE_LEVEL_4;
+		}
+		else if ( ps->saber[0].type == SABER_TRIDENT )
+		{
+			return FORCE_LEVEL_3;
+		}
+		return FORCE_LEVEL_1;
+	}
+	if ( anim >= BOTH_A2_T__B_ && anim <= BOTH_D2_B____ )
+	{
+		return FORCE_LEVEL_2;
+	}
+	if ( anim >= BOTH_A3_T__B_ && anim <= BOTH_D3_B____ )
+	{
+		return FORCE_LEVEL_3;
+	}
+	if ( anim >= BOTH_A4_T__B_ && anim <= BOTH_D4_B____ )
+	{//desann
+		return FORCE_LEVEL_4;
+	}
+	if ( anim >= BOTH_A5_T__B_ && anim <= BOTH_D5_B____ )
+	{//tavion
+		return FORCE_LEVEL_2;
+	}
+	if ( anim >= BOTH_A6_T__B_ && anim <= BOTH_D6_B____ )
+	{//dual
+		return FORCE_LEVEL_2;
+	}
+	if ( anim >= BOTH_A7_T__B_ && anim <= BOTH_D7_B____ )
+	{//staff
+		return FORCE_LEVEL_2;
+	}
+	if ( ( anim >= BOTH_P1_S1_T_ && anim <= BOTH_P1_S1_BR )
+		|| ( anim >= BOTH_P6_S6_T_ && anim <= BOTH_P6_S6_BR ) 
+		|| ( anim >= BOTH_P7_S7_T_ && anim <= BOTH_P7_S7_BR ) )
+	{//parries
+		switch ( ps->saberAnimLevel )
+		{
+		case SS_STRONG:
+		case SS_DESANN:
+			return FORCE_LEVEL_3;
+			break;
+		case SS_TAVION:
+		case SS_STAFF:
+		case SS_DUAL:
+		case SS_MEDIUM:
+			return FORCE_LEVEL_2;
+			break;
+		case SS_FAST:
+			return FORCE_LEVEL_1;
+			break;
+		default:
+			return FORCE_LEVEL_0;
+			break;
+		}
+	}
+	if ( ( anim >= BOTH_K1_S1_T_ && anim <= BOTH_K1_S1_BR )
+		|| ( anim >= BOTH_K6_S6_T_ && anim <= BOTH_K6_S6_BR ) 
+		|| ( anim >= BOTH_K7_S7_T_ && anim <= BOTH_K7_S7_BR ) )
+	{//knockaways
+		return FORCE_LEVEL_3;
+	}
+	if ( ( anim >= BOTH_V1_BR_S1 && anim <= BOTH_V1_B__S1 )
+		|| ( anim >= BOTH_V6_BR_S6 && anim <= BOTH_V6_B__S6 ) 
+		|| ( anim >= BOTH_V7_BR_S7 && anim <= BOTH_V7_B__S7 ) )
+	{//knocked-away attacks
+		return FORCE_LEVEL_1;
+	}
+	if ( ( anim >= BOTH_H1_S1_T_ && anim <= BOTH_H1_S1_BR )
+		|| ( anim >= BOTH_H6_S6_T_ && anim <= BOTH_H6_S6_BR ) 
+		|| ( anim >= BOTH_H7_S7_T_ && anim <= BOTH_H7_S7_BR ) )
+	{//broken parries
+		return FORCE_LEVEL_0;
+	}
+	switch ( anim )
+	{
+	case BOTH_A2_STABBACK1:
+		if ( ps->torsoAnimTimer < 450 )
+		{//end of anim
+			return FORCE_LEVEL_0;
+		}
+		else if ( animTimeElapsed < 400 )
+		{//beginning of anim
+			return FORCE_LEVEL_0;
+		}
+		return FORCE_LEVEL_3;
+		break;
+	case BOTH_ATTACK_BACK:
+		if ( ps->torsoAnimTimer < 500 )
+		{//end of anim
+			return FORCE_LEVEL_0;
+		}
+		return FORCE_LEVEL_3;
+		break;
+	case BOTH_CROUCHATTACKBACK1:
+		if ( ps->torsoAnimTimer < 800 )
+		{//end of anim
+			return FORCE_LEVEL_0;
+		}
+		return FORCE_LEVEL_3;
+		break;
+	case BOTH_BUTTERFLY_LEFT:
+	case BOTH_BUTTERFLY_RIGHT:
+	case BOTH_BUTTERFLY_FL1:
+	case BOTH_BUTTERFLY_FR1:
+		//FIXME: break up?
+		return FORCE_LEVEL_3;
+		break;
+	case BOTH_FJSS_TR_BL:
+	case BOTH_FJSS_TL_BR:
+		//FIXME: break up?
+		return FORCE_LEVEL_3;
+		break;
+	case BOTH_K1_S1_T_:	//# knockaway saber top
+	case BOTH_K1_S1_TR:	//# knockaway saber top right
+	case BOTH_K1_S1_TL:	//# knockaway saber top left
+	case BOTH_K1_S1_BL:	//# knockaway saber bottom left
+	case BOTH_K1_S1_B_:	//# knockaway saber bottom
+	case BOTH_K1_S1_BR:	//# knockaway saber bottom right
+		//FIXME: break up?
+		return FORCE_LEVEL_3;
+		break;
+	case BOTH_LUNGE2_B__T_:
+		if ( ps->torsoAnimTimer < 400 )
+		{//end of anim
+			return FORCE_LEVEL_0;
+		}
+		else if ( animTimeElapsed < 150 )
+		{//beginning of anim
+			return FORCE_LEVEL_0;
+		}
+		return FORCE_LEVEL_3;
+		break;
+	case BOTH_FORCELEAP2_T__B_:
+		if ( ps->torsoAnimTimer < 400 )
+		{//end of anim
+			return FORCE_LEVEL_0;
+		}
+		else if ( animTimeElapsed < 550 )
+		{//beginning of anim
+			return FORCE_LEVEL_0;
+		}
+		return FORCE_LEVEL_3;
+		break;
+	case BOTH_VS_ATR_S:
+	case BOTH_VS_ATL_S:
+	case BOTH_VT_ATR_S:
+	case BOTH_VT_ATL_S:
+		return FORCE_LEVEL_3;//???
+		break;
+	case BOTH_JUMPFLIPSLASHDOWN1:
+		if ( ps->torsoAnimTimer <= 900 )
+		{//end of anim
+			return FORCE_LEVEL_0;
+		}
+		else if ( animTimeElapsed < 550 )
+		{//beginning of anim
+			return FORCE_LEVEL_0;
+		}
+		return FORCE_LEVEL_3;
+		break;
+	case BOTH_JUMPFLIPSTABDOWN:
+		if ( ps->torsoAnimTimer <= 1200 )
+		{//end of anim
+			return FORCE_LEVEL_0;
+		}
+		else if ( animTimeElapsed <= 250 )
+		{//beginning of anim
+			return FORCE_LEVEL_0;
+		}
+		return FORCE_LEVEL_3;
+		break;
+	case BOTH_JUMPATTACK6:
+		/*
+		if (pm->ps)
+		{
+			if ( ( pm->ps->legsAnimTimer >= 1450
+					&& PM_AnimLength( g_entities[ps->clientNum].client->clientInfo.animFileIndex, BOTH_JUMPATTACK6 ) - pm->ps->legsAnimTimer >= 400 ) 
+				||(pm->ps->legsAnimTimer >= 400
+					&& PM_AnimLength( g_entities[ps->clientNum].client->clientInfo.animFileIndex, BOTH_JUMPATTACK6 ) - pm->ps->legsAnimTimer >= 1100 ) )
+			{//pretty much sideways
+				return FORCE_LEVEL_3;
+			}
+		}
+		*/
+		if ( ( ps->torsoAnimTimer >= 1450
+				&& animTimeElapsed >= 400 )
+			||(ps->torsoAnimTimer >= 400
+				&& animTimeElapsed >= 1100 ) )
+		{//pretty much sideways
+			return FORCE_LEVEL_3;
+		}
+		return FORCE_LEVEL_0;
+		break;
+	case BOTH_JUMPATTACK7:
+		if ( ps->torsoAnimTimer <= 1200 )
+		{//end of anim
+			return FORCE_LEVEL_0;
+		}
+		else if ( animTimeElapsed < 200 )
+		{//beginning of anim
+			return FORCE_LEVEL_0;
+		}
+		return FORCE_LEVEL_3;
+		break;
+	case BOTH_SPINATTACK6:
+		if ( animTimeElapsed <= 200 )
+		{//beginning of anim
+			return FORCE_LEVEL_0;
+		}
+		return FORCE_LEVEL_3;
+		break;
+	case BOTH_SPINATTACK7:
+		if ( ps->torsoAnimTimer <= 500 )
+		{//end of anim
+			return FORCE_LEVEL_0;
+		}
+		else if ( animTimeElapsed < 500 )
+		{//beginning of anim
+			return FORCE_LEVEL_0;
+		}
+		return FORCE_LEVEL_3;
+		break;
+	case BOTH_FORCELONGLEAP_ATTACK:
+		if ( animTimeElapsed <= 200 )
+		{//1st four frames of anim
+			return FORCE_LEVEL_3;
+		}
+		break;
+	/*
+	case BOTH_A7_KICK_F://these kicks attack, too
+	case BOTH_A7_KICK_B:
+	case BOTH_A7_KICK_R:
+	case BOTH_A7_KICK_L:
+		//FIXME: break up
+		return FORCE_LEVEL_3;
+		break;
+	*/
+	case BOTH_STABDOWN:
+		if ( ps->torsoAnimTimer <= 900 )
+		{//end of anim
+			return FORCE_LEVEL_3;
+		}
+		break;
+	case BOTH_STABDOWN_STAFF:
+		if ( ps->torsoAnimTimer <= 850 )
+		{//end of anim
+			return FORCE_LEVEL_3;
+		}
+		break;
+	case BOTH_STABDOWN_DUAL:
+		if ( ps->torsoAnimTimer <= 900 )
+		{//end of anim
+			return FORCE_LEVEL_3;
+		}
+		break;
+	case BOTH_A6_SABERPROTECT:
+		if ( ps->torsoAnimTimer < 650 )
+		{//end of anim
+			return FORCE_LEVEL_0;
+		}
+		return FORCE_LEVEL_3;
+		break;
+	case BOTH_A7_SOULCAL:
+		if ( ps->torsoAnimTimer < 650 )
+		{//end of anim
+			return FORCE_LEVEL_0;
+		}
+		else if ( animTimeElapsed < 600 )
+		{//beginning of anim
+			return FORCE_LEVEL_0;
+		}
+		return FORCE_LEVEL_3;
+		break;
+	case BOTH_A1_SPECIAL:
+		if ( ps->torsoAnimTimer < 600 )
+		{//end of anim
+			return FORCE_LEVEL_0;
+		}
+		else if ( animTimeElapsed < 200 )
+		{//beginning of anim
+			return FORCE_LEVEL_0;
+		}
+		return FORCE_LEVEL_3;
+		break;
+	case BOTH_A2_SPECIAL:
+		if ( ps->torsoAnimTimer < 300 )
+		{//end of anim
+			return FORCE_LEVEL_0;
+		}
+		else if ( animTimeElapsed < 200 )
+		{//beginning of anim
+			return FORCE_LEVEL_0;
+		}
+		return FORCE_LEVEL_3;
+		break;
+	case BOTH_A3_SPECIAL:
+		if ( ps->torsoAnimTimer < 700 )
+		{//end of anim
+			return FORCE_LEVEL_0;
+		}
+		else if ( animTimeElapsed < 200 )
+		{//beginning of anim
+			return FORCE_LEVEL_0;
+		}
+		return FORCE_LEVEL_3;
+		break;
+	case BOTH_FLIP_ATTACK7:
+		return FORCE_LEVEL_3;
+		break;
+	case BOTH_PULL_IMPALE_STAB:
+		if ( ps->torsoAnimTimer < 1000 )
+		{//end of anim
+			return FORCE_LEVEL_0;
+		}
+		return FORCE_LEVEL_3;
+		break;
+	case BOTH_PULL_IMPALE_SWING:
+		if ( ps->torsoAnimTimer < 500 )//750 )
+		{//end of anim
+			return FORCE_LEVEL_0;
+		}
+		else if ( animTimeElapsed < 650 )//600 )
+		{//beginning of anim
+			return FORCE_LEVEL_0;
+		}
+		return FORCE_LEVEL_3;
+		break;
+	case BOTH_ALORA_SPIN_SLASH:
+		if ( ps->torsoAnimTimer < 900 )
+		{//end of anim
+			return FORCE_LEVEL_0;
+		}
+		else if ( animTimeElapsed < 250 )
+		{//beginning of anim
+			return FORCE_LEVEL_0;
+		}
+		return FORCE_LEVEL_3;
+		break;
+	case BOTH_A6_FB:
+		if ( ps->torsoAnimTimer < 250 )
+		{//end of anim
+			return FORCE_LEVEL_0;
+		}
+		else if ( animTimeElapsed < 250 )
+		{//beginning of anim
+			return FORCE_LEVEL_0;
+		}
+		return FORCE_LEVEL_3;
+		break;
+	case BOTH_A6_LR:	
+		if ( ps->torsoAnimTimer < 250 )
+		{//end of anim
+			return FORCE_LEVEL_0;
+		}
+		else if ( animTimeElapsed < 250 )
+		{//beginning of anim
+			return FORCE_LEVEL_0;
+		}
+		return FORCE_LEVEL_3;
+		break;
+	case BOTH_A7_HILT:
+		return FORCE_LEVEL_0;
+		break;
+//===SABERLOCK SUPERBREAKS START===========================================================================
+	case BOTH_LK_S_DL_T_SB_1_W:
+		if ( ps->torsoAnimTimer < 700 )
+		{//end of anim
+			return FORCE_LEVEL_0;
+		}
+		return FORCE_LEVEL_5;
+		break;
+	case BOTH_LK_S_ST_S_SB_1_W:
+		if ( ps->torsoAnimTimer < 300 )
+		{//end of anim
+			return FORCE_LEVEL_0;
+		}
+		return FORCE_LEVEL_5;
+		break;
+	case BOTH_LK_S_DL_S_SB_1_W:
+	case BOTH_LK_S_S_S_SB_1_W:
+		if ( ps->torsoAnimTimer < 700 )
+		{//end of anim
+			return FORCE_LEVEL_0;
+		}
+		else if ( animTimeElapsed < 400 )
+		{//beginning of anim
+			return FORCE_LEVEL_0;
+		}
+		return FORCE_LEVEL_5;
+		break;
+	case BOTH_LK_S_ST_T_SB_1_W:
+	case BOTH_LK_S_S_T_SB_1_W:
+		if ( ps->torsoAnimTimer < 150 )
+		{//end of anim
+			return FORCE_LEVEL_0;
+		}
+		else if ( animTimeElapsed < 400 )
+		{//beginning of anim
+			return FORCE_LEVEL_0;
+		}
+		return FORCE_LEVEL_5;
+		break;
+	case BOTH_LK_DL_DL_T_SB_1_W:
+		return FORCE_LEVEL_5;
+		break;
+	case BOTH_LK_DL_DL_S_SB_1_W:
+	case BOTH_LK_DL_ST_S_SB_1_W:
+		if ( animTimeElapsed < 1000 )
+		{//beginning of anim
+			return FORCE_LEVEL_0;
+		}
+		return FORCE_LEVEL_5;
+		break;
+	case BOTH_LK_DL_ST_T_SB_1_W:
+		if ( ps->torsoAnimTimer < 950 )
+		{//end of anim
+			return FORCE_LEVEL_0;
+		}
+		else if ( animTimeElapsed < 650 )
+		{//beginning of anim
+			return FORCE_LEVEL_0;
+		}
+		return FORCE_LEVEL_5;
+		break;
+	case BOTH_LK_DL_S_S_SB_1_W:
+		if ( saberNum != 0 )
+		{//only right hand saber does damage in this suberbreak
+			return FORCE_LEVEL_0;
+		}
+		if ( ps->torsoAnimTimer < 900 )
+		{//end of anim
+			return FORCE_LEVEL_0;
+		}
+		else if ( animTimeElapsed < 450 )
+		{//beginning of anim
+			return FORCE_LEVEL_0;
+		}
+		return FORCE_LEVEL_5;
+		break;
+	case BOTH_LK_DL_S_T_SB_1_W:
+		if ( saberNum != 0 )
+		{//only right hand saber does damage in this suberbreak
+			return FORCE_LEVEL_0;
+		}
+		if ( ps->torsoAnimTimer < 250 )
+		{//end of anim
+			return FORCE_LEVEL_0;
+		}
+		else if ( animTimeElapsed < 150 )
+		{//beginning of anim
+			return FORCE_LEVEL_0;
+		}
+		return FORCE_LEVEL_5;
+		break;
+	case BOTH_LK_ST_DL_S_SB_1_W:
+		return FORCE_LEVEL_5;
+		break;
+	case BOTH_LK_ST_DL_T_SB_1_W:
+		//special suberbreak - doesn't kill, just kicks them backwards
+		return FORCE_LEVEL_0;
+		break;
+	case BOTH_LK_ST_ST_S_SB_1_W:
+	case BOTH_LK_ST_S_S_SB_1_W:
+		if ( ps->torsoAnimTimer < 800 )
+		{//end of anim
+			return FORCE_LEVEL_0;
+		}
+		else if ( animTimeElapsed < 350 )
+		{//beginning of anim
+			return FORCE_LEVEL_0;
+		}
+		return FORCE_LEVEL_5;
+		break;
+	case BOTH_LK_ST_ST_T_SB_1_W:
+	case BOTH_LK_ST_S_T_SB_1_W:
+		return FORCE_LEVEL_5;
+		break;
+//===SABERLOCK SUPERBREAKS START===========================================================================
+	case BOTH_HANG_ATTACK:
+		//FIME: break up
+		if ( ps->torsoAnimTimer < 1000 )
+		{//end of anim
+			return FORCE_LEVEL_0;
+		}
+		else if ( animTimeElapsed < 250 )
+		{//beginning of anim
+			return FORCE_LEVEL_0;
+		}
+		else
+		{//sweet spot
+			return FORCE_LEVEL_5;
+		}
+		break;
+	case BOTH_ROLL_STAB:
+		if ( animTimeElapsed > 400 )
+		{//end of anim
+			return FORCE_LEVEL_0;
+		}
+		else
+		{
+			return FORCE_LEVEL_3;
+		}
+		break;
+	}
+	return FORCE_LEVEL_0;
+}
+
+qboolean PM_InAnimForSaberMove( int anim, int saberMove )
+{
+	switch ( anim )
+	{//special case anims
+	case BOTH_A2_STABBACK1:
+	case BOTH_ATTACK_BACK:
+	case BOTH_CROUCHATTACKBACK1:
+	case BOTH_ROLL_STAB:
+	case BOTH_BUTTERFLY_LEFT:
+	case BOTH_BUTTERFLY_RIGHT:
+	case BOTH_BUTTERFLY_FL1:
+	case BOTH_BUTTERFLY_FR1:
+	case BOTH_FJSS_TR_BL:
+	case BOTH_FJSS_TL_BR:
+	case BOTH_LUNGE2_B__T_:
+	case BOTH_FORCELEAP2_T__B_:
+	case BOTH_JUMPFLIPSLASHDOWN1://#
+	case BOTH_JUMPFLIPSTABDOWN://#
+	case BOTH_JUMPATTACK6:
+	case BOTH_JUMPATTACK7:
+	case BOTH_SPINATTACK6:
+	case BOTH_SPINATTACK7:
+	case BOTH_VS_ATR_S:
+	case BOTH_VS_ATL_S:
+	case BOTH_VT_ATR_S:
+	case BOTH_VT_ATL_S:
+	case BOTH_FORCELONGLEAP_ATTACK:
+	case BOTH_A7_KICK_F:
+	case BOTH_A7_KICK_B:
+	case BOTH_A7_KICK_R:
+	case BOTH_A7_KICK_L:
+	case BOTH_A7_KICK_S:
+	case BOTH_A7_KICK_BF:
+	case BOTH_A7_KICK_RL:
+	case BOTH_A7_KICK_F_AIR:
+	case BOTH_A7_KICK_B_AIR:
+	case BOTH_A7_KICK_R_AIR:
+	case BOTH_A7_KICK_L_AIR:
+	case BOTH_STABDOWN:
+	case BOTH_STABDOWN_STAFF:
+	case BOTH_STABDOWN_DUAL:
+	case BOTH_A6_SABERPROTECT:
+	case BOTH_A7_SOULCAL:
+	case BOTH_A1_SPECIAL:
+	case BOTH_A2_SPECIAL:
+	case BOTH_A3_SPECIAL:
+	case BOTH_FLIP_ATTACK7:
+	case BOTH_PULL_IMPALE_STAB:
+	case BOTH_PULL_IMPALE_SWING:
+	case BOTH_ALORA_SPIN_SLASH:
+	case BOTH_A6_FB:
+	case BOTH_A6_LR:	
+	case BOTH_A7_HILT:
+	case BOTH_LK_S_DL_S_SB_1_W:
+	case BOTH_LK_S_DL_T_SB_1_W:
+	case BOTH_LK_S_ST_S_SB_1_W:
+	case BOTH_LK_S_ST_T_SB_1_W:
+	case BOTH_LK_S_S_S_SB_1_W:
+	case BOTH_LK_S_S_T_SB_1_W:
+	case BOTH_LK_DL_DL_S_SB_1_W:
+	case BOTH_LK_DL_DL_T_SB_1_W:
+	case BOTH_LK_DL_ST_S_SB_1_W:
+	case BOTH_LK_DL_ST_T_SB_1_W:
+	case BOTH_LK_DL_S_S_SB_1_W:
+	case BOTH_LK_DL_S_T_SB_1_W:
+	case BOTH_LK_ST_DL_S_SB_1_W:
+	case BOTH_LK_ST_DL_T_SB_1_W:
+	case BOTH_LK_ST_ST_S_SB_1_W:
+	case BOTH_LK_ST_ST_T_SB_1_W:
+	case BOTH_LK_ST_S_S_SB_1_W:
+	case BOTH_LK_ST_S_T_SB_1_W:
+	case BOTH_HANG_ATTACK:
+		return qtrue;
+	}
+	if ( PM_SaberDrawPutawayAnim( anim ) )
+	{
+		if ( saberMove == LS_DRAW || saberMove == LS_PUTAWAY )
+		{
+			return qtrue;
+		}
+		return qfalse;
+	}
+	else if ( PM_SaberStanceAnim( anim ) )
+	{
+		if ( saberMove == LS_READY )
+		{
+			return qtrue;
+		}
+		return qfalse;
+	}
+	int animLevel = PM_AnimLevelForSaberAnim( anim );
+	if ( animLevel <= 0 )
+	{//NOTE: this will always return false for the ready poses and putaway/draw...
+		return qfalse;
+	}
+	//drop the anim to the first level and start the checks there
+	anim -= (animLevel-FORCE_LEVEL_1)*SABER_ANIM_GROUP_SIZE;
+	//check level 1
+	if ( anim == saberMoveData[saberMove].animToUse )
+	{
+		return qtrue;
+	}
+	//check level 2
+	anim += SABER_ANIM_GROUP_SIZE;
+	if ( anim == saberMoveData[saberMove].animToUse )
+	{
+		return qtrue;
+	}
+	//check level 3
+	anim += SABER_ANIM_GROUP_SIZE;
+	if ( anim == saberMoveData[saberMove].animToUse )
+	{
+		return qtrue;
+	}
+	//check level 4
+	anim += SABER_ANIM_GROUP_SIZE;
+	if ( anim == saberMoveData[saberMove].animToUse )
+	{
+		return qtrue;
+	}
+	//check level 5
+	anim += SABER_ANIM_GROUP_SIZE;
+	if ( anim == saberMoveData[saberMove].animToUse )
+	{
+		return qtrue;
+	}
+	if ( anim >= BOTH_P1_S1_T_ && anim <= BOTH_H1_S1_BR )
+	{//parries, knockaways and broken parries
+		return (anim==saberMoveData[saberMove].animToUse);
+	}
+	return qfalse;
+}
+
+qboolean PM_SaberInIdle( int move )
+{
+	switch ( move )
+	{
+	case LS_NONE:
+	case LS_READY:
+	case LS_DRAW:
+	case LS_PUTAWAY:
+		return qtrue;
+		break;
+	}
+	return qfalse;
+}
+qboolean PM_SaberInSpecialAttack( int anim )
+{
+	switch ( anim )
+	{
+	case BOTH_A2_STABBACK1:
+	case BOTH_ATTACK_BACK:
+	case BOTH_CROUCHATTACKBACK1:
+	case BOTH_ROLL_STAB:
+	case BOTH_BUTTERFLY_LEFT:
+	case BOTH_BUTTERFLY_RIGHT:
+	case BOTH_BUTTERFLY_FL1:
+	case BOTH_BUTTERFLY_FR1:
+	case BOTH_FJSS_TR_BL:
+	case BOTH_FJSS_TL_BR:
+	case BOTH_LUNGE2_B__T_:
+	case BOTH_FORCELEAP2_T__B_:
+	case BOTH_JUMPFLIPSLASHDOWN1://#
+	case BOTH_JUMPFLIPSTABDOWN://#
+	case BOTH_JUMPATTACK6:
+	case BOTH_JUMPATTACK7:
+	case BOTH_SPINATTACK6:
+	case BOTH_SPINATTACK7:
+	case BOTH_FORCELONGLEAP_ATTACK:
+	case BOTH_VS_ATR_S:
+	case BOTH_VS_ATL_S:
+	case BOTH_VT_ATR_S:
+	case BOTH_VT_ATL_S:
+	case BOTH_A7_KICK_F:
+	case BOTH_A7_KICK_B:
+	case BOTH_A7_KICK_R:
+	case BOTH_A7_KICK_L:
+	case BOTH_A7_KICK_S:
+	case BOTH_A7_KICK_BF:
+	case BOTH_A7_KICK_RL:
+	case BOTH_A7_KICK_F_AIR:
+	case BOTH_A7_KICK_B_AIR:
+	case BOTH_A7_KICK_R_AIR:
+	case BOTH_A7_KICK_L_AIR:
+	case BOTH_STABDOWN:
+	case BOTH_STABDOWN_STAFF:
+	case BOTH_STABDOWN_DUAL:
+	case BOTH_A6_SABERPROTECT:
+	case BOTH_A7_SOULCAL:
+	case BOTH_A1_SPECIAL:
+	case BOTH_A2_SPECIAL:
+	case BOTH_A3_SPECIAL:
+	case BOTH_FLIP_ATTACK7:
+	case BOTH_PULL_IMPALE_STAB:
+	case BOTH_PULL_IMPALE_SWING:
+	case BOTH_ALORA_SPIN_SLASH:
+	case BOTH_A6_FB:
+	case BOTH_A6_LR:	
+	case BOTH_A7_HILT:
+	case BOTH_LK_S_DL_S_SB_1_W:
+	case BOTH_LK_S_DL_T_SB_1_W:
+	case BOTH_LK_S_ST_S_SB_1_W:
+	case BOTH_LK_S_ST_T_SB_1_W:
+	case BOTH_LK_S_S_S_SB_1_W:
+	case BOTH_LK_S_S_T_SB_1_W:
+	case BOTH_LK_DL_DL_S_SB_1_W:
+	case BOTH_LK_DL_DL_T_SB_1_W:
+	case BOTH_LK_DL_ST_S_SB_1_W:
+	case BOTH_LK_DL_ST_T_SB_1_W:
+	case BOTH_LK_DL_S_S_SB_1_W:
+	case BOTH_LK_DL_S_T_SB_1_W:
+	case BOTH_LK_ST_DL_S_SB_1_W:
+	case BOTH_LK_ST_DL_T_SB_1_W:
+	case BOTH_LK_ST_ST_S_SB_1_W:
+	case BOTH_LK_ST_ST_T_SB_1_W:
+	case BOTH_LK_ST_S_S_SB_1_W:
+	case BOTH_LK_ST_S_T_SB_1_W:
+	case BOTH_HANG_ATTACK:
+		return qtrue;
+	}
+	return qfalse;
+}
+
+qboolean PM_SaberInAttack( int move )
+{
+	if ( move >= LS_A_TL2BR && move <= LS_A_T2B )
+	{
+		return qtrue;
+	}
+	switch ( move )
+	{
+	case LS_A_BACK:
+	case LS_A_BACK_CR:
+	case LS_A_BACKSTAB:
+	case LS_ROLL_STAB:
+	case LS_A_LUNGE:
+	case LS_A_JUMP_T__B_:
+	case LS_A_FLIP_STAB:
+	case LS_A_FLIP_SLASH:
+	case LS_JUMPATTACK_DUAL:
+	case LS_JUMPATTACK_ARIAL_LEFT:
+	case LS_JUMPATTACK_ARIAL_RIGHT:
+	case LS_JUMPATTACK_CART_LEFT:
+	case LS_JUMPATTACK_CART_RIGHT:
+	case LS_JUMPATTACK_STAFF_LEFT:
+	case LS_JUMPATTACK_STAFF_RIGHT:
+	case LS_BUTTERFLY_LEFT:
+	case LS_BUTTERFLY_RIGHT:
+	case LS_A_BACKFLIP_ATK:
+	case LS_SPINATTACK_DUAL:
+	case LS_SPINATTACK:
+	case LS_LEAP_ATTACK:
+	case LS_SWOOP_ATTACK_RIGHT:
+	case LS_SWOOP_ATTACK_LEFT:
+	case LS_TAUNTAUN_ATTACK_RIGHT:
+	case LS_TAUNTAUN_ATTACK_LEFT:
+	case LS_KICK_F:
+	case LS_KICK_B:
+	case LS_KICK_R:
+	case LS_KICK_L:
+	case LS_KICK_S:
+	case LS_KICK_BF:
+	case LS_KICK_RL:
+	case LS_KICK_F_AIR:
+	case LS_KICK_B_AIR:
+	case LS_KICK_R_AIR:
+	case LS_KICK_L_AIR:
+	case LS_STABDOWN:
+	case LS_STABDOWN_STAFF:
+	case LS_STABDOWN_DUAL:
+	case LS_DUAL_SPIN_PROTECT:
+	case LS_STAFF_SOULCAL:
+	case LS_A1_SPECIAL:
+	case LS_A2_SPECIAL:
+	case LS_A3_SPECIAL:
+	case LS_UPSIDE_DOWN_ATTACK:
+	case LS_PULL_ATTACK_STAB:
+	case LS_PULL_ATTACK_SWING:
+	case LS_SPINATTACK_ALORA:
+	case LS_DUAL_FB:
+	case LS_DUAL_LR:
+	case LS_HILT_BASH:
+		return qtrue;
+		break;
+	}
+	return qfalse;
+}
+qboolean PM_SaberInTransition( int move )
+{
+	if ( move >= LS_T1_BR__R && move <= LS_T1_BL__L )
+	{
+		return qtrue;
+	}
+	return qfalse;
+}
+qboolean PM_SaberInStart( int move )
+{
+	if ( move >= LS_S_TL2BR && move <= LS_S_T2B )
+	{
+		return qtrue;
+	}
+	return qfalse;
+}
+qboolean PM_SaberInReturn( int move )
+{
+	if ( move >= LS_R_TL2BR && move <= LS_R_T2B )
+	{
+		return qtrue;
+	}
+	return qfalse;
+}
+qboolean PM_SaberInTransitionAny( int move )
+{
+	if ( PM_SaberInStart( move ) )
+	{
+		return qtrue;
+	}
+	else if ( PM_SaberInTransition( move ) )
+	{
+		return qtrue;
+	}
+	else if ( PM_SaberInReturn( move ) )
+	{
+		return qtrue;
+	}
+	return qfalse;
+}
+qboolean PM_SaberInBounce( int move )
+{
+	if ( move >= LS_B1_BR && move <= LS_B1_BL )
+	{
+		return qtrue;
+	}
+	if ( move >= LS_D1_BR && move <= LS_D1_BL )
+	{
+		return qtrue;
+	}
+	return qfalse;
+}
+qboolean PM_SaberInBrokenParry( int move )
+{
+	if ( move >= LS_V1_BR && move <= LS_V1_B_ )
+	{
+		return qtrue;
+	}
+	if ( move >= LS_H1_T_ && move <= LS_H1_BL )
+	{
+		return qtrue;
+	}
+	return qfalse;
+}
+qboolean PM_SaberInDeflect( int move )
+{
+	if ( move >= LS_D1_BR && move <= LS_D1_B_ )
+	{
+		return qtrue;
+	}
+	return qfalse;
+}
+qboolean PM_SaberInParry( int move )
+{
+	if ( move >= LS_PARRY_UP && move <= LS_PARRY_LL )
+	{
+		return qtrue;
+	}
+	return qfalse;
+}
+qboolean PM_SaberInKnockaway( int move )
+{
+	if ( move >= LS_K1_T_ && move <= LS_K1_BL )
+	{
+		return qtrue;
+	}
+	return qfalse;
+}
+qboolean PM_SaberInReflect( int move )
+{
+	if ( move >= LS_REFLECT_UP && move <= LS_REFLECT_LL )
+	{
+		return qtrue;
+	}
+	return qfalse;
+}
+
+qboolean PM_SaberInSpecial( int move )
+{
+	switch( move )
+	{
+	case LS_A_BACK:
+	case LS_A_BACK_CR:
+	case LS_A_BACKSTAB:
+	case LS_ROLL_STAB:
+	case LS_A_LUNGE:
+	case LS_A_JUMP_T__B_:
+	case LS_A_FLIP_STAB:
+	case LS_A_FLIP_SLASH:
+	case LS_JUMPATTACK_DUAL:
+	case LS_JUMPATTACK_ARIAL_LEFT:
+	case LS_JUMPATTACK_ARIAL_RIGHT:
+	case LS_JUMPATTACK_CART_LEFT:
+	case LS_JUMPATTACK_CART_RIGHT:
+	case LS_JUMPATTACK_STAFF_LEFT:
+	case LS_JUMPATTACK_STAFF_RIGHT:
+	case LS_BUTTERFLY_LEFT:
+	case LS_BUTTERFLY_RIGHT:
+	case LS_A_BACKFLIP_ATK:
+	case LS_SPINATTACK_DUAL:
+	case LS_SPINATTACK:
+	case LS_LEAP_ATTACK:
+	case LS_SWOOP_ATTACK_RIGHT:
+	case LS_SWOOP_ATTACK_LEFT:
+	case LS_TAUNTAUN_ATTACK_RIGHT:
+	case LS_TAUNTAUN_ATTACK_LEFT:
+	case LS_KICK_F:
+	case LS_KICK_B:
+	case LS_KICK_R:
+	case LS_KICK_L:
+	case LS_KICK_S:
+	case LS_KICK_BF:
+	case LS_KICK_RL:
+	case LS_KICK_F_AIR:
+	case LS_KICK_B_AIR:
+	case LS_KICK_R_AIR:
+	case LS_KICK_L_AIR:
+	case LS_STABDOWN:
+	case LS_STABDOWN_STAFF:
+	case LS_STABDOWN_DUAL:
+	case LS_DUAL_SPIN_PROTECT:
+	case LS_STAFF_SOULCAL:
+	case LS_A1_SPECIAL:
+	case LS_A2_SPECIAL:
+	case LS_A3_SPECIAL:
+	case LS_UPSIDE_DOWN_ATTACK:
+	case LS_PULL_ATTACK_STAB:
+	case LS_PULL_ATTACK_SWING:
+	case LS_SPINATTACK_ALORA:
+	case LS_DUAL_FB:
+	case LS_DUAL_LR:
+	case LS_HILT_BASH:
+		return qtrue;
+	}
+	return qfalse;
+}
+
+qboolean PM_KickMove( int move )
+{
+	switch( move )
+	{
+	case LS_KICK_F:
+	case LS_KICK_B:
+	case LS_KICK_R:
+	case LS_KICK_L:
+	case LS_KICK_S:
+	case LS_KICK_BF:
+	case LS_KICK_RL:
+	case LS_HILT_BASH:
+	case LS_KICK_F_AIR:
+	case LS_KICK_B_AIR:
+	case LS_KICK_R_AIR:
+	case LS_KICK_L_AIR:
+		return qtrue;
+	}
+	return qfalse;
+}
+
+saberMoveName_t PM_BrokenParryForAttack( int move )
+{
+	//Our attack was knocked away by a knockaway parry
+	//FIXME: need actual anims for this
+	//FIXME: need to know which side of the saber was hit!  For now, we presume the saber gets knocked away from the center
+	switch ( saberMoveData[move].startQuad )
+	{
+	case Q_B:
+		return LS_V1_B_;
+		break;
+	case Q_BR:
+		return LS_V1_BR;
+		break;
+	case Q_R:
+		return LS_V1__R;
+		break;
+	case Q_TR:
+		return LS_V1_TR;
+		break;
+	case Q_T:
+		return LS_V1_T_;
+		break;
+	case Q_TL:
+		return LS_V1_TL;
+		break;
+	case Q_L:
+		return LS_V1__L;
+		break;
+	case Q_BL:
+		return LS_V1_BL;
+		break;
+	}
+	return LS_NONE;
+}
+
+saberMoveName_t PM_BrokenParryForParry( int move )
+{
+	//FIXME: need actual anims for this
+	//FIXME: need to know which side of the saber was hit!  For now, we presume the saber gets knocked away from the center
+	switch ( move )
+	{
+	case LS_PARRY_UP:
+		//Hmm... since we don't know what dir the hit came from, randomly pick knock down or knock back
+		if ( Q_irand( 0, 1 ) )
+		{
+			return LS_H1_B_;
+		}
+		else
+		{
+			return LS_H1_T_;
+		}
+		break;
+	case LS_PARRY_UR:
+		return LS_H1_TR;
+		break;
+	case LS_PARRY_UL:
+		return LS_H1_TL;
+		break;
+	case LS_PARRY_LR:
+		return LS_H1_BR;
+		break;
+	case LS_PARRY_LL:
+		return LS_H1_BL;
+		break;
+	case LS_READY:
+		return LS_H1_B_;//???
+		break;
+	}
+	return LS_NONE;
+}
+
+saberMoveName_t PM_KnockawayForParry( int move )
+{
+	//FIXME: need actual anims for this
+	//FIXME: need to know which side of the saber was hit!  For now, we presume the saber gets knocked away from the center
+	switch ( move )
+	{
+	case BLOCKED_TOP://LS_PARRY_UP:
+		return LS_K1_T_;//push up
+		break;
+	case BLOCKED_UPPER_RIGHT://LS_PARRY_UR:
+	default://case LS_READY:
+		return LS_K1_TR;//push up, slightly to right
+		break;
+	case BLOCKED_UPPER_LEFT://LS_PARRY_UL:
+		return LS_K1_TL;//push up and to left
+		break;
+	case BLOCKED_LOWER_RIGHT://LS_PARRY_LR:
+		return LS_K1_BR;//push down and to left
+		break;
+	case BLOCKED_LOWER_LEFT://LS_PARRY_LL:
+		return LS_K1_BL;//push down and to right
+		break;
+	}
+	//return LS_NONE;
+}
+
+saberMoveName_t PM_SaberBounceForAttack( int move )
+{
+	switch ( saberMoveData[move].startQuad )
+	{
+	case Q_B:
+	case Q_BR:
+		return LS_B1_BR;
+		break;
+	case Q_R:
+		return LS_B1__R;
+		break;
+	case Q_TR:
+		return LS_B1_TR;
+		break;
+	case Q_T:
+		return LS_B1_T_;
+		break;
+	case Q_TL:
+		return LS_B1_TL;
+		break;
+	case Q_L:
+		return LS_B1__L;
+		break;
+	case Q_BL:
+		return LS_B1_BL;
+		break;
+	}
+	return LS_NONE;
+}
+
+saberMoveName_t PM_AttackMoveForQuad( int quad )
+{
+	switch ( quad )
+	{
+	case Q_B:
+	case Q_BR:
+		return LS_A_BR2TL;
+		break;
+	case Q_R:
+		return LS_A_R2L;
+		break;
+	case Q_TR:
+		return LS_A_TR2BL;
+		break;
+	case Q_T:
+		return LS_A_T2B;
+		break;
+	case Q_TL:
+		return LS_A_TL2BR;
+		break;
+	case Q_L:
+		return LS_A_L2R;
+		break;
+	case Q_BL:
+		return LS_A_BL2TR;
+		break;
+	}
+	return LS_NONE;
+}
+
+int saberMoveTransitionAngle[Q_NUM_QUADS][Q_NUM_QUADS] = 
+{
+	0,//Q_BR,Q_BR,
+	45,//Q_BR,Q_R,
+	90,//Q_BR,Q_TR,
+	135,//Q_BR,Q_T,
+	180,//Q_BR,Q_TL,
+	215,//Q_BR,Q_L,
+	270,//Q_BR,Q_BL,
+	45,//Q_BR,Q_B,
+	45,//Q_R,Q_BR,
+	0,//Q_R,Q_R,
+	45,//Q_R,Q_TR,
+	90,//Q_R,Q_T,
+	135,//Q_R,Q_TL,
+	180,//Q_R,Q_L,
+	215,//Q_R,Q_BL,
+	90,//Q_R,Q_B,
+	90,//Q_TR,Q_BR,
+	45,//Q_TR,Q_R,
+	0,//Q_TR,Q_TR,
+	45,//Q_TR,Q_T,
+	90,//Q_TR,Q_TL,
+	135,//Q_TR,Q_L,
+	180,//Q_TR,Q_BL,
+	135,//Q_TR,Q_B,
+	135,//Q_T,Q_BR,
+	90,//Q_T,Q_R,
+	45,//Q_T,Q_TR,
+	0,//Q_T,Q_T,
+	45,//Q_T,Q_TL,
+	90,//Q_T,Q_L,
+	135,//Q_T,Q_BL,
+	180,//Q_T,Q_B,
+	180,//Q_TL,Q_BR,
+	135,//Q_TL,Q_R,
+	90,//Q_TL,Q_TR,
+	45,//Q_TL,Q_T,
+	0,//Q_TL,Q_TL,
+	45,//Q_TL,Q_L,
+	90,//Q_TL,Q_BL,
+	135,//Q_TL,Q_B,
+	215,//Q_L,Q_BR,
+	180,//Q_L,Q_R,
+	135,//Q_L,Q_TR,
+	90,//Q_L,Q_T,
+	45,//Q_L,Q_TL,
+	0,//Q_L,Q_L,
+	45,//Q_L,Q_BL,
+	90,//Q_L,Q_B,
+	270,//Q_BL,Q_BR,
+	215,//Q_BL,Q_R,
+	180,//Q_BL,Q_TR,
+	135,//Q_BL,Q_T,
+	90,//Q_BL,Q_TL,
+	45,//Q_BL,Q_L,
+	0,//Q_BL,Q_BL,
+	45,//Q_BL,Q_B,
+	45,//Q_B,Q_BR,
+	90,//Q_B,Q_R,
+	135,//Q_B,Q_TR,
+	180,//Q_B,Q_T,
+	135,//Q_B,Q_TL,
+	90,//Q_B,Q_L,
+	45,//Q_B,Q_BL,
+	0//Q_B,Q_B,
+};
+
+int PM_SaberAttackChainAngle( int move1, int move2 )
+{
+	if ( move1 == -1 || move2 == -1 )
+	{
+		return -1;
+	}
+	return saberMoveTransitionAngle[saberMoveData[move1].endQuad][saberMoveData[move2].startQuad];
+}
+
+qboolean PM_SaberKataDone( int curmove = LS_NONE, int newmove = LS_NONE )
+{
+	if ( pm->ps->forceRageRecoveryTime > level.time )
+	{//rage recovery, only 1 swing at a time (tired)
+		if ( pm->ps->saberAttackChainCount > 0 )
+		{//swung once
+			return qtrue;
+		}
+		else
+		{//allow one attack
+			return qfalse;
+		}
+	}
+	else if ( (pm->ps->forcePowersActive&(1<<FP_RAGE)) )
+	{//infinite chaining when raged
+		return qfalse;
+	}
+	else if ( pm->ps->saber[0].maxChain == -1 )
+	{
+		return qfalse;
+	}
+	else if ( pm->ps->saber[0].maxChain != 0 )
+	{
+		if ( pm->ps->saberAttackChainCount >= pm->ps->saber[0].maxChain )
+		{
+			return qtrue;
+		}
+		else
+		{
+			return qfalse;
+		}
+	}
+
+	if ( pm->ps->saberAnimLevel == SS_DESANN || pm->ps->saberAnimLevel == SS_TAVION )
+	{//desann and tavion can link up as many attacks as they want
+		return qfalse;
+	}
+	//FIXME: instead of random, apply some sort of logical conditions to whether or 
+	//		not you can chain?  Like if you were completely missed, you can't chain as much, or...?
+	//		And/Or based on FP_SABER_OFFENSE level?  So number of attacks you can chain
+	//		increases with your FP_SABER_OFFENSE skill?
+	if ( pm->ps->saberAnimLevel == SS_STAFF )
+	{
+		//TEMP: for now, let staff attacks infinitely chain
+		return qfalse;
+		/*
+		if ( pm->ps->saberAttackChainCount > Q_irand( 3, 4 ) )
+		{
+			return qtrue;
+		}
+		else if ( pm->ps->saberAttackChainCount > 0 )
+		{
+			int chainAngle = PM_SaberAttackChainAngle( curmove, newmove );
+			if ( chainAngle < 135 || chainAngle > 215 )
+			{//if trying to chain to a move that doesn't continue the momentum
+				if ( pm->ps->saberAttackChainCount > 1 )
+				{
+					return qtrue;
+				}
+			}
+			else if ( chainAngle == 180 )
+			{//continues the momentum perfectly, allow it to chain 66% of the time
+				if ( pm->ps->saberAttackChainCount > 2 )
+				{
+					return qtrue;
+				}
+			}
+			else
+			{//would continue the movement somewhat, 50% chance of continuing
+				if ( pm->ps->saberAttackChainCount > 3 )
+				{
+					return qtrue;
+				}
+			}
+		}
+		*/
+	}
+	else if ( pm->ps->saberAnimLevel == SS_DUAL )
+	{
+		//TEMP: for now, let staff attacks infinitely chain
+		return qfalse;
+	}
+	else if ( pm->ps->saberAnimLevel == FORCE_LEVEL_3 )
+	{
+		if ( curmove == LS_NONE || newmove == LS_NONE )
+		{
+			if ( pm->ps->saberAnimLevel >= FORCE_LEVEL_3 && pm->ps->saberAttackChainCount > Q_irand( 0, 1 ) )
+			{
+				return qtrue;
+			}
+		}
+		else if ( pm->ps->saberAttackChainCount > Q_irand( 2, 3 ) )
+		{
+			return qtrue;
+		}
+		else if ( pm->ps->saberAttackChainCount > 0 )
+		{
+			int chainAngle = PM_SaberAttackChainAngle( curmove, newmove );
+			if ( chainAngle < 135 || chainAngle > 215 )
+			{//if trying to chain to a move that doesn't continue the momentum
+				return qtrue;
+			}
+			else if ( chainAngle == 180 )
+			{//continues the momentum perfectly, allow it to chain 66% of the time
+				if ( pm->ps->saberAttackChainCount > 1 )
+				{
+					return qtrue;
+				}
+			}
+			else
+			{//would continue the movement somewhat, 50% chance of continuing
+				if ( pm->ps->saberAttackChainCount > 2 )
+				{
+					return qtrue;
+				}
+			}
+		}
+	}
+	else 
+	{//FIXME: have chainAngle influence fast and medium chains as well?
+		if ( (pm->ps->saberAnimLevel == FORCE_LEVEL_2 || pm->ps->saberAnimLevel == SS_DUAL)
+			&& pm->ps->saberAttackChainCount > Q_irand( 2, 5 ) )
+		{
+			return qtrue;
+		}
+	}
+	return qfalse;
+}
+
+qboolean PM_CheckEnemyInBack( float backCheckDist )
+{
+	if ( !pm->gent || !pm->gent->client )
+	{
+		return qfalse;
+	}
+	if ( (pm->ps->clientNum < MAX_CLIENTS||PM_ControlledByPlayer())
+		&& !g_saberAutoAim->integer && pm->cmd.forwardmove >= 0 )
+	{//don't auto-backstab
+		return qfalse;
+	}
+	if ( pm->ps->groundEntityNum == ENTITYNUM_NONE )
+	{//only when on ground
+		return qfalse;
+	}
+	trace_t	trace;
+	vec3_t end, fwd, fwdAngles = {0,pm->ps->viewangles[YAW],0};
+
+	AngleVectors( fwdAngles, fwd, NULL, NULL );
+	VectorMA( pm->ps->origin, -backCheckDist, fwd, end );
+
+	pm->trace( &trace, pm->ps->origin, vec3_origin, vec3_origin, end, pm->ps->clientNum, CONTENTS_SOLID|CONTENTS_BODY );
+	if ( trace.fraction < 1.0f && trace.entityNum < ENTITYNUM_WORLD )
+	{
+		gentity_t *traceEnt = &g_entities[trace.entityNum];
+		if ( traceEnt 
+			&& traceEnt->health > 0 
+			&& traceEnt->client 
+			&& traceEnt->client->playerTeam == pm->gent->client->enemyTeam 
+			&& traceEnt->client->ps.groundEntityNum != ENTITYNUM_NONE )
+		{
+			if ( (pm->ps->clientNum < MAX_CLIENTS||PM_ControlledByPlayer()) )
+			{//player
+				if ( pm->gent )
+				{//set player enemy to traceEnt so he auto-aims at him
+					pm->gent->enemy = traceEnt;
+				}
+			}
+			return qtrue;
+		}
+	}
+	return qfalse;
+}
+
+saberMoveName_t PM_PickBackStab( void )
+{
+	if ( !pm->gent || !pm->gent->client )
+	{
+		return LS_READY;
+	}
+	if ( pm->ps->dualSabers
+		&& pm->ps->saber[1].Active() )
+	{
+		if ( pm->ps->pm_flags & PMF_DUCKED )
+		{
+			return LS_A_BACK_CR;
+		}
+		else
+		{
+			return LS_A_BACK;
+		}
+	}
+	if ( pm->gent->client->ps.saberAnimLevel == SS_TAVION )
+	{
+		return LS_A_BACKSTAB;
+	}
+	else if ( pm->gent->client->ps.saberAnimLevel == SS_DESANN )
+	{
+		if ( pm->ps->saberMove == LS_READY || !Q_irand( 0, 3 ) )
+		{
+			return LS_A_BACKSTAB;
+		}
+		else if ( pm->ps->pm_flags & PMF_DUCKED )
+		{
+			return LS_A_BACK_CR;
+		}
+		else
+		{
+			return LS_A_BACK;
+		}
+	}
+	else if ( pm->ps->saberAnimLevel == FORCE_LEVEL_2 
+		|| pm->ps->saberAnimLevel == SS_DUAL )
+	{//using medium attacks or dual sabers
+		if ( pm->ps->pm_flags & PMF_DUCKED )
+		{
+			return LS_A_BACK_CR;
+		}
+		else
+		{
+			return LS_A_BACK;
+		}
+	}
+	else
+	{
+		return LS_A_BACKSTAB;
+	}
+}
+
+saberMoveName_t PM_CheckStabDown( void )
+{
+	if ( !pm->gent || !pm->gent->enemy || !pm->gent->enemy->client )
+	{
+		return LS_NONE;
+	}
+	if ( pm->ps->clientNum < MAX_CLIENTS || PM_ControlledByPlayer() ) //PLAYER ONLY
+	{//player 
+		if ( G_TryingKataAttack( pm->gent, &pm->cmd ) )//(pm->cmd.buttons&BUTTON_FORCE_FOCUS) )//Holding focus
+		{//want to try a special
+			return LS_NONE;
+		}
+	}
+	if ( (pm->ps->clientNum < MAX_CLIENTS||PM_ControlledByPlayer()) )
+	{//player
+		if ( pm->ps->groundEntityNum == ENTITYNUM_NONE )//in air 
+		{//sorry must be on ground (or have just jumped)
+			if ( level.time-pm->ps->lastOnGround <= 50 && (pm->ps->pm_flags&PMF_JUMPING) )
+			{//just jumped, it's okay
+			}
+			else
+			{
+				return LS_NONE;
+			}
+		}
+		/*
+		if ( pm->cmd.upmove > 0 )
+		{//trying to jump
+		}
+		else if ( pm->ps->groundEntityNum == ENTITYNUM_NONE //in air 
+			&& level.time-pm->ps->lastOnGround <= 250 //just left ground
+			&& (pm->ps->pm_flags&PMF_JUMPING) )//jumped
+		{//just jumped
+		}
+		else
+		{
+			return LS_NONE;
+		}
+		*/
+		pm->ps->velocity[2] = 0;
+		pm->cmd.upmove = 0;
+	}
+	else if ( (pm->ps->clientNum >= MAX_CLIENTS&&!PM_ControlledByPlayer()) )
+	{//NPC
+		if ( pm->ps->groundEntityNum == ENTITYNUM_NONE )//in air 
+		{//sorry must be on ground (or have just jumped)
+			if ( level.time-pm->ps->lastOnGround <= 250 && (pm->ps->pm_flags&PMF_JUMPING) )
+			{//just jumped, it's okay
+			}
+			else
+			{
+				return LS_NONE;
+			}
+		}
+		if ( !pm->gent->NPC )
+		{//wtf???
+			return LS_NONE;
+		}
+		if ( Q_irand( 0, RANK_CAPTAIN ) > pm->gent->NPC->rank )
+		{//lower ranks do this less often
+			return LS_NONE;
+		}
+	}
+	vec3_t enemyDir, faceFwd, facingAngles = {0, pm->ps->viewangles[YAW], 0};
+	AngleVectors( facingAngles, faceFwd, NULL, NULL );
+	VectorSubtract( pm->gent->enemy->currentOrigin, pm->ps->origin, enemyDir );
+	float enemyZDiff = enemyDir[2];
+	enemyDir[2] = 0;
+	float enemyHDist = VectorNormalize( enemyDir )-(pm->gent->maxs[0]+pm->gent->enemy->maxs[0]);
+	float dot = DotProduct( enemyDir, faceFwd );
+
+	if ( //(pm->ps->clientNum < MAX_CLIENTS || PM_ControlledByPlayer())
+		dot > 0.65f 
+		//&& enemyHDist >= 32 //was 48
+		&& enemyHDist <= 164//was 112
+		&& PM_InKnockDownOnGround( &pm->gent->enemy->client->ps )//still on ground
+		&& !PM_InGetUpNoRoll( &pm->gent->enemy->client->ps )//not getting up yet
+		&& enemyZDiff <= 20 )
+	{//guy is on the ground below me, do a top-down attack
+		if ( pm->gent->enemy->s.number >= MAX_CLIENTS
+			|| !G_ControlledByPlayer( pm->gent->enemy ) )
+		{//don't get up while I'm doing this
+			//stop them from trying to get up for at least another 3 seconds
+			TIMER_Set( pm->gent->enemy, "noGetUpStraight", 3000 );
+		}
+		//pick the right anim
+		if ( pm->ps->saberAnimLevel == SS_DUAL
+			|| (pm->ps->dualSabers&&pm->ps->saber[1].Active()) )
+		{
+			return LS_STABDOWN_DUAL;
+		}
+		else if ( pm->ps->saberAnimLevel == SS_STAFF )
+		{
+			return LS_STABDOWN_STAFF;
+		}
+		else
+		{
+			return LS_STABDOWN;
+		}
+	}
+	return LS_NONE;
+}
+
+extern saberMoveName_t PM_NPCSaberAttackFromQuad( int quad );
+saberMoveName_t PM_SaberFlipOverAttackMove( void );
+saberMoveName_t PM_AttackForEnemyPos( qboolean allowFB, qboolean allowStabDown )
+{
+	saberMoveName_t autoMove = LS_INVALID;
+
+	if( !pm->gent->enemy )
+	{
+		return LS_NONE;
+	}
+
+	vec3_t enemy_org, enemyDir, faceFwd, faceRight, faceUp, facingAngles = {0, pm->ps->viewangles[YAW], 0};
+	AngleVectors( facingAngles, faceFwd, faceRight, faceUp );
+	//FIXME: predict enemy position?
+	if ( pm->gent->enemy->client )
+	{
+		//VectorCopy( pm->gent->enemy->currentOrigin, enemy_org );
+		//HMM... using this will adjust for bbox size, so let's do that...
+		vec3_t	size;
+		VectorSubtract( pm->gent->enemy->absmax, pm->gent->enemy->absmin, size );
+		VectorMA( pm->gent->enemy->absmin, 0.5, size, enemy_org );
+
+		VectorSubtract( pm->gent->enemy->client->renderInfo.eyePoint, pm->ps->origin, enemyDir );
+	}
+	else
+	{
+		if ( pm->gent->enemy->bmodel && VectorCompare( vec3_origin, pm->gent->enemy->currentOrigin ) )
+		{//a brush model without an origin brush
+			vec3_t	size;
+			VectorSubtract( pm->gent->enemy->absmax, pm->gent->enemy->absmin, size );
+			VectorMA( pm->gent->enemy->absmin, 0.5, size, enemy_org );
+		}
+		else
+		{
+			VectorCopy( pm->gent->enemy->currentOrigin, enemy_org );
+		}
+		VectorSubtract( enemy_org, pm->ps->origin, enemyDir );
+	}
+	float enemyZDiff = enemyDir[2];
+	float enemyDist = VectorNormalize( enemyDir );
+	float dot = DotProduct( enemyDir, faceFwd );
+	if ( dot > 0 )
+	{//enemy is in front
+		if ( allowStabDown )
+		{//okay to try this
+			saberMoveName_t stabDownMove = PM_CheckStabDown();
+			if ( stabDownMove != LS_NONE )
+			{
+				return stabDownMove;
+			}
+		}
+		if ( (pm->ps->clientNum < MAX_CLIENTS || PM_ControlledByPlayer())
+			&& dot > 0.65f 
+			&& enemyDist <= 64 && pm->gent->enemy->client
+			&& (enemyZDiff <= 20 || PM_InKnockDownOnGround( &pm->gent->enemy->client->ps ) || PM_CrouchAnim( pm->gent->enemy->client->ps.legsAnim ) ) ) 
+		{//swing down at them
+			return LS_A_T2B;
+		}
+		if ( allowFB )
+		{//directly in front anim allowed
+			if ( enemyDist > 200 || pm->gent->enemy->health <= 0 )
+			{//hmm, look in back for an enemy
+				if ( pm->ps->clientNum && !PM_ControlledByPlayer() )
+				{//player should never do this automatically
+					if ( pm->ps->groundEntityNum != ENTITYNUM_NONE )
+					{//only when on ground
+						if ( pm->gent && pm->gent->client && pm->gent->NPC && pm->gent->NPC->rank >= RANK_LT_JG && Q_irand( 0, pm->gent->NPC->rank ) > RANK_ENSIGN )
+						{//only fencers and higher can do this, higher rank does it more
+							if ( PM_CheckEnemyInBack( 100 ) )
+							{
+								return PM_PickBackStab();
+							}
+						}
+					}
+				}
+			}
+			//this is the default only if they're *right* in front... 
+			if ( (pm->ps->clientNum&&!PM_ControlledByPlayer()) 
+				|| ((pm->ps->clientNum < MAX_CLIENTS||PM_ControlledByPlayer()) && cg.renderingThirdPerson && !cg.zoomMode) )
+			{//NPC or player not in 1st person
+				if ( PM_CheckFlipOverAttackMove( qtrue ) )
+				{//enemy must be close and in front
+					return PM_SaberFlipOverAttackMove();
+				}
+			}
+			if ( PM_CheckLungeAttackMove() )
+			{//NPC
+				autoMove = PM_SaberLungeAttackMove( qtrue );
+			}
+			else
+			{
+				autoMove = LS_A_T2B;
+			}
+		}
+		else
+		{//pick a random one
+			if ( Q_irand( 0, 1 ) )
+			{
+				autoMove = LS_A_TR2BL;
+			}
+			else
+			{
+				autoMove = LS_A_TL2BR;
+			}
+		}
+		float dotR = DotProduct( enemyDir, faceRight );
+		if ( dotR > 0.35 )
+		{//enemy is to far right
+			autoMove = LS_A_L2R;
+		}
+		else if ( dotR < -0.35 )
+		{//far left
+			autoMove = LS_A_R2L;
+		}
+		else if ( dotR > 0.15 )
+		{//enemy is to near right
+			autoMove = LS_A_TR2BL;
+		}
+		else if ( dotR < -0.15 )
+		{//near left
+			autoMove = LS_A_TL2BR;
+		}
+		if ( DotProduct( enemyDir, faceUp ) > 0.5 )
+		{//enemy is above me
+			if ( autoMove == LS_A_TR2BL )
+			{
+				autoMove = LS_A_BL2TR;
+			}
+			else if ( autoMove == LS_A_TL2BR )
+			{
+				autoMove = LS_A_BR2TL;
+			}
+		}
+	}
+	else if ( allowFB )
+	{//back attack allowed
+		//if ( !PM_InKnockDown( pm->ps ) )
+		if ( pm->ps->groundEntityNum != ENTITYNUM_NONE )
+		{//only when on ground
+			if ( !pm->gent->enemy->client || pm->gent->enemy->client->ps.groundEntityNum != ENTITYNUM_NONE )
+			{//enemy not a client or is a client and on ground
+				if ( dot < -0.75f 
+					&& enemyDist < 128
+					&& (pm->ps->saberAnimLevel == SS_FAST || pm->ps->saberAnimLevel == SS_STAFF || (pm->gent->client &&(pm->gent->client->NPC_class == CLASS_TAVION||pm->gent->client->NPC_class == CLASS_ALORA)&&Q_irand(0,2))) )
+				{//fast back-stab
+					if ( !(pm->ps->pm_flags&PMF_DUCKED) && pm->cmd.upmove >= 0 )
+					{//can't do it while ducked?
+						if ( (pm->ps->clientNum < MAX_CLIENTS||PM_ControlledByPlayer()) || (pm->gent->NPC && pm->gent->NPC->rank >= RANK_LT_JG) )
+						{//only fencers and above can do this
+							autoMove = LS_A_BACKSTAB;
+						}
+					}
+				}
+				else if ( pm->ps->saberAnimLevel != SS_FAST
+					&& pm->ps->saberAnimLevel != SS_STAFF )
+				{//higher level back spin-attacks
+					if ( (pm->ps->clientNum&&!PM_ControlledByPlayer()) || ((pm->ps->clientNum < MAX_CLIENTS||PM_ControlledByPlayer()) && cg.renderingThirdPerson && !cg.zoomMode) )
+					{
+						if ( (pm->ps->pm_flags&PMF_DUCKED) || pm->cmd.upmove < 0 )
+						{
+							autoMove = LS_A_BACK_CR;
+						}
+						else
+						{
+							autoMove = LS_A_BACK;
+						}
+					}
+				}
+			}
+		}
+	}
+	return autoMove;
+}
+
+qboolean PM_InSecondaryStyle( void )
+{
+	if ( pm->ps->saber[0].numBlades > 1
+		&& pm->ps->saber[0].singleBladeStyle
+		&& pm->ps->saber[0].singleBladeStyle != pm->ps->saber[0].style
+		&& pm->ps->saberAnimLevel == pm->ps->saber[0].singleBladeStyle )
+	{
+		return qtrue;
+	}
+
+	if ( pm->ps->dualSabers
+		&& !pm->ps->saber[1].Active() )//pm->ps->saberAnimLevel != SS_DUAL )
+	{
+		return qtrue;
+	}
+	return qfalse;
+}
+
+saberMoveName_t PM_SaberLungeAttackMove( qboolean fallbackToNormalLunge )
+{
+	G_DrainPowerForSpecialMove( pm->gent, FP_SABER_OFFENSE, SABER_ALT_ATTACK_POWER_FB );
+	if ( pm->gent->client->NPC_class == CLASS_ALORA && !Q_irand( 0, 3 ) )
+	{//alora NPC
+		return LS_SPINATTACK_ALORA; 
+	}
+	else
+	{
+		if ( pm->ps->dualSabers )
+		{
+			return LS_SPINATTACK_DUAL;
+		}
+		switch ( pm->ps->saberAnimLevel )
+		{
+		case SS_DUAL:
+			return LS_SPINATTACK_DUAL;
+			break;
+		case SS_STAFF:
+			return LS_SPINATTACK;
+			break;
+		default://normal lunge
+			if ( fallbackToNormalLunge )
+			{
+				vec3_t fwdAngles, jumpFwd;
+
+				VectorCopy( pm->ps->viewangles, fwdAngles );
+				fwdAngles[PITCH] = fwdAngles[ROLL] = 0;
+				//do the lunge
+				AngleVectors( fwdAngles, jumpFwd, NULL, NULL );
+				VectorScale( jumpFwd, 150, pm->ps->velocity );
+				pm->ps->velocity[2] = 50;
+				PM_AddEvent( EV_JUMP );
+
+				return LS_A_LUNGE;
+			}
+			break;
+		}
+	}
+	return LS_NONE;
+}
+
+qboolean PM_CheckLungeAttackMove( void )
+{
+	if ( pm->ps->saberAnimLevel == SS_FAST//fast
+		|| pm->ps->saberAnimLevel == SS_DUAL//dual
+		|| pm->ps->saberAnimLevel == SS_STAFF //staff
+		|| pm->ps->saberAnimLevel == SS_DESANN
+		|| pm->ps->dualSabers )
+	{//alt+back+attack using fast, dual or staff attacks
+		if ( pm->ps->clientNum >= MAX_CLIENTS && !PM_ControlledByPlayer() )
+		{//NPC
+			if ( pm->cmd.upmove < 0 || (pm->ps->pm_flags&PMF_DUCKED) )
+			{//ducking
+				if ( pm->ps->legsAnim == BOTH_STAND2
+					|| pm->ps->legsAnim == BOTH_SABERFAST_STANCE
+					|| pm->ps->legsAnim == BOTH_SABERSLOW_STANCE
+					|| pm->ps->legsAnim == BOTH_SABERSTAFF_STANCE
+					|| pm->ps->legsAnim == BOTH_SABERDUAL_STANCE
+					|| (level.time-pm->ps->lastStationary) <= 500  )
+				{//standing or just stopped standing
+					if ( pm->gent 
+						&& pm->gent->NPC //NPC
+						&& pm->gent->NPC->rank >= RANK_LT_JG //high rank
+						&& ( pm->gent->NPC->rank == RANK_LT_JG || Q_irand( -3, pm->gent->NPC->rank ) >= RANK_LT_JG )//Q_irand( 0, pm->gent->NPC->rank ) >= RANK_LT_JG )
+						&& !Q_irand( 0, 3-g_spskill->integer ) )
+					{//only fencer and higher can do this
+						if ( pm->ps->saberAnimLevel == SS_DESANN )
+						{
+							if ( !Q_irand( 0, 4 ) )
+							{
+								return qtrue;
+							}
+						}
+						else
+						{
+							return qtrue;
+						}
+					}
+				}
+			}
+		}
+		else
+		{//player
+			if ( G_TryingLungeAttack( pm->gent, &pm->cmd )
+				&& G_EnoughPowerForSpecialMove( pm->ps->forcePower, SABER_ALT_ATTACK_POWER_FB )/*pm->ps->forcePower >= SABER_ALT_ATTACK_POWER_FB*/ )//have enough force power to pull it off
+			{
+				return qtrue;
+			}
+		}
+	}
+
+	return qfalse;
+}
+
+saberMoveName_t PM_SaberJumpForwardAttackMove( void )
+{
+	G_DrainPowerForSpecialMove( pm->gent, FP_LEVITATION, SABER_ALT_ATTACK_POWER_FB );
+
+	if ( pm->ps->saberAnimLevel == SS_DUAL
+		|| pm->ps->saberAnimLevel == SS_STAFF )
+	{
+		pm->cmd.upmove = 0;//no jump just yet
+
+		if ( pm->ps->saberAnimLevel == SS_STAFF )
+		{
+			if ( Q_irand(0, 1) )
+			{
+				return LS_JUMPATTACK_STAFF_LEFT;
+			}
+			else
+			{
+				return LS_JUMPATTACK_STAFF_RIGHT;
+			}
+		}
+
+		return LS_JUMPATTACK_DUAL;
+	}
+	else
+	{
+		vec3_t fwdAngles, jumpFwd;
+
+		VectorCopy( pm->ps->viewangles, fwdAngles );
+		fwdAngles[PITCH] = fwdAngles[ROLL] = 0;
+		AngleVectors( fwdAngles, jumpFwd, NULL, NULL );
+		VectorScale( jumpFwd, 200, pm->ps->velocity );
+		pm->ps->velocity[2] = 180;
+		pm->ps->forceJumpZStart = pm->ps->origin[2];//so we don't take damage if we land at same height
+		pm->ps->pm_flags |= PMF_JUMPING|PMF_SLOW_MO_FALL;
+
+		//FIXME: NPCs yell?
+		PM_AddEvent( EV_JUMP );
+		G_SoundOnEnt( pm->gent, CHAN_BODY, "sound/weapons/force/jump.wav" );
+		pm->cmd.upmove = 0;
+
+		return LS_A_JUMP_T__B_;
+	}
+}
+
+qboolean PM_CheckJumpForwardAttackMove( void )
+{
+	if ( pm->ps->clientNum < MAX_CLIENTS 
+		&& PM_InSecondaryStyle() )
+	{
+		return qfalse;
+	}
+
+	if ( pm->cmd.forwardmove > 0 //going forward
+		&& pm->ps->forceRageRecoveryTime < pm->cmd.serverTime	//not in a force Rage recovery period
+		&& pm->ps->forcePowerLevel[FP_LEVITATION] > FORCE_LEVEL_1 //can force jump
+		&& pm->gent && !(pm->gent->flags&FL_LOCK_PLAYER_WEAPONS) // yes this locked weapons check also includes force powers, if we need a separate check later I'll make one
+		&& (pm->ps->groundEntityNum != ENTITYNUM_NONE||level.time-pm->ps->lastOnGround<=250) //on ground or just jumped (if not player)
+		)
+	{
+		if ( pm->ps->saberAnimLevel == SS_DUAL 
+			|| pm->ps->saberAnimLevel == SS_STAFF )
+		{//dual and staff
+			if ( !PM_SaberInTransitionAny( pm->ps->saberMove ) //not going to/from/between an attack anim
+				&& !PM_SaberInAttack( pm->ps->saberMove ) //not in attack anim
+				&& pm->ps->weaponTime <= 0//not busy
+				&& (pm->cmd.buttons&BUTTON_ATTACK) )//want to attack
+			{
+				if ( pm->ps->clientNum >= MAX_CLIENTS && !PM_ControlledByPlayer() ) 
+				{//NPC
+					if ( pm->cmd.upmove > 0 || (pm->ps->pm_flags&PMF_JUMPING) )//jumping NPC
+					{
+						if ( pm->gent 
+							&& pm->gent->NPC 
+							&& (pm->gent->NPC->rank==RANK_CREWMAN||pm->gent->NPC->rank>=RANK_LT) )
+						{
+							return qtrue;
+						}
+					}
+				}
+				else
+				{//PLAYER
+					if ( G_TryingJumpForwardAttack( pm->gent, &pm->cmd )
+						&& G_EnoughPowerForSpecialMove( pm->ps->forcePower, SABER_ALT_ATTACK_POWER_FB ) )//have enough power to attack
+					{
+						return qtrue;
+					}
+				}
+			}
+		}
+		//check strong
+		else if ( pm->ps->saberAnimLevel == SS_STRONG //strong style
+			|| pm->ps->saberAnimLevel == SS_DESANN )//desann
+		{
+			if ( //&& !PM_InKnockDown( pm->ps )
+				!pm->ps->dualSabers
+				//&& (pm->ps->legsAnim == BOTH_STAND2||pm->ps->legsAnim == BOTH_SABERFAST_STANCE||pm->ps->legsAnim == BOTH_SABERSLOW_STANCE||level.time-pm->ps->lastStationary<=500)//standing or just started moving
+				)
+			{//strong attack: jump-hack
+				/*
+				if ( pm->ps->legsAnim == BOTH_STAND2
+					|| pm->ps->legsAnim == BOTH_SABERFAST_STANCE 
+					|| pm->ps->legsAnim == BOTH_SABERSLOW_STANCE
+					|| level.time-pm->ps->lastStationary <= 250 )//standing or just started moving
+				*/
+				if ( pm->ps->clientNum >= MAX_CLIENTS && !PM_ControlledByPlayer() )
+				{//NPC
+					if ( pm->cmd.upmove > 0 || (pm->ps->pm_flags&PMF_JUMPING) )//NPC jumping
+					{
+						if ( pm->gent 
+							&& pm->gent->NPC 
+							&& (pm->gent->NPC->rank==RANK_CREWMAN||pm->gent->NPC->rank>=RANK_LT) )
+						{//only acrobat or boss and higher can do this
+							if ( pm->ps->legsAnim == BOTH_STAND2
+								|| pm->ps->legsAnim == BOTH_SABERFAST_STANCE 
+								|| pm->ps->legsAnim == BOTH_SABERSLOW_STANCE
+								|| level.time-pm->ps->lastStationary <= 250 )
+							{//standing or just started moving
+								if ( pm->gent->client
+									&& pm->gent->client->NPC_class == CLASS_DESANN )
+								{
+									if ( !Q_irand( 0, 1 ) )
+									{
+										return qtrue;
+									}
+								}
+								else
+								{
+									return qtrue;
+								}
+							}
+						}
+					}
+				}
+				else
+				{//player
+					if ( G_TryingJumpForwardAttack( pm->gent, &pm->cmd )
+						&& G_EnoughPowerForSpecialMove( pm->ps->forcePower, SABER_ALT_ATTACK_POWER_FB ) )
+					{
+						return qtrue;
+					}
+				}
+			}
+		}
+	}
+	return qfalse;
+}
+
+saberMoveName_t PM_SaberFlipOverAttackMove( void )
+{
+	//FIXME: check above for room enough to jump!
+	//FIXME: while in this jump, keep velocity[2] at a minimum until the end of the anim 
+	vec3_t fwdAngles, jumpFwd;
+
+	VectorCopy( pm->ps->viewangles, fwdAngles );
+	fwdAngles[PITCH] = fwdAngles[ROLL] = 0;
+	AngleVectors( fwdAngles, jumpFwd, NULL, NULL );
+	VectorScale( jumpFwd, 150, pm->ps->velocity );
+	pm->ps->velocity[2] = 250;
+	//250 is normalized for a standing enemy at your z level, about 64 tall... adjust for actual maxs[2]-mins[2] of enemy and for zdiff in origins
+	if ( pm->gent && pm->gent->enemy )
+	{	//go higher for taller enemies
+		pm->ps->velocity[2] *= (pm->gent->enemy->maxs[2]-pm->gent->enemy->mins[2])/64.0f;
+		//go higher for enemies higher than you, lower for those lower than you
+		float zDiff = pm->gent->enemy->currentOrigin[2] - pm->ps->origin[2];
+		pm->ps->velocity[2] += (zDiff)*1.5f;
+		//clamp to decent-looking values
+		//FIXME: still jump too low sometimes
+		if ( zDiff <= 0 && pm->ps->velocity[2] < 200 )
+		{//if we're on same level, don't let me jump so low, I clip into the ground
+			pm->ps->velocity[2] = 200;
+		}
+		else if ( pm->ps->velocity[2] < 50 )
+		{
+			pm->ps->velocity[2] = 50;
+		}
+		else if ( pm->ps->velocity[2] > 400 )
+		{
+			pm->ps->velocity[2] = 400;
+		}
+	}
+	pm->ps->forceJumpZStart = pm->ps->origin[2];//so we don't take damage if we land at same height
+	pm->ps->pm_flags |= PMF_JUMPING|PMF_SLOW_MO_FALL;
+
+	//FIXME: NPCs yell?
+	PM_AddEvent( EV_JUMP );
+	G_SoundOnEnt( pm->gent, CHAN_BODY, "sound/weapons/force/jump.wav" );
+	pm->cmd.upmove = 0;
+	//FIXME: don't allow this to land on other people
+
+	pm->gent->angle = pm->ps->viewangles[YAW];//so we know what yaw we started this at
+
+	G_DrainPowerForSpecialMove( pm->gent, FP_LEVITATION, SABER_ALT_ATTACK_POWER_FB );
+
+	if ( Q_irand( 0, 1 ) )
+	{
+		return LS_A_FLIP_STAB;
+	}
+	else
+	{
+		return LS_A_FLIP_SLASH;
+	}
+}
+
+qboolean PM_CheckFlipOverAttackMove( qboolean checkEnemy )
+{
+	if ( pm->ps->clientNum < MAX_CLIENTS 
+		&& PM_InSecondaryStyle() )
+	{
+		return qfalse;
+	}
+
+	if ( (pm->ps->saberAnimLevel == SS_MEDIUM //medium
+		|| pm->ps->saberAnimLevel == SS_TAVION )//tavion
+		&& pm->ps->forcePowerLevel[FP_LEVITATION] > FORCE_LEVEL_1 //can force jump
+		&& !(pm->gent->flags&FL_LOCK_PLAYER_WEAPONS) // yes this locked weapons check also includes force powers, if we need a separate check later I'll make one
+		&& (pm->ps->groundEntityNum != ENTITYNUM_NONE||level.time-pm->ps->lastOnGround<=250) //on ground or just jumped
+		)
+	{
+		qboolean tryMove = qfalse;
+		if ( pm->ps->clientNum >= MAX_CLIENTS && !PM_ControlledByPlayer() )
+		{//NPC
+			if ( pm->cmd.upmove > 0//want to jump
+				|| (pm->ps->pm_flags&PMF_JUMPING) )//jumping
+			{//flip over-forward down-attack
+				if ( (pm->gent->NPC 
+					&& (pm->gent->NPC->rank==RANK_CREWMAN||pm->gent->NPC->rank>=RANK_LT) 
+					&& !Q_irand(0, 2) ) )//NPC who can do this, 33% chance
+				{//only player or acrobat or boss and higher can do this
+					tryMove = qtrue;
+				}
+			}
+		}
+		else
+		{//player
+			if ( G_TryingJumpForwardAttack( pm->gent, &pm->cmd )
+				&& G_EnoughPowerForSpecialMove( pm->ps->forcePower, SABER_ALT_ATTACK_POWER_FB ) )//have enough power
+			{
+				if ( !pm->cmd.rightmove )
+				{
+					if ( pm->ps->legsAnim == BOTH_JUMP1 
+						|| pm->ps->legsAnim == BOTH_FORCEJUMP1 
+						|| pm->ps->legsAnim == BOTH_INAIR1 
+						|| pm->ps->legsAnim == BOTH_FORCEINAIR1 )
+					{//in a non-flip forward jump
+						tryMove = qtrue;
+					}
+				}
+			}
+		}
+
+		if ( tryMove )
+		{
+			if ( !checkEnemy )
+			{//based just on command input
+				return qtrue;
+			}
+			else
+			{//based on presence of enemy
+				if ( pm->gent->enemy )//have an enemy
+				{
+					vec3_t fwdAngles = {0,pm->ps->viewangles[YAW],0};
+					if ( pm->gent->enemy->health > 0 
+						&& pm->ps->forceRageRecoveryTime < pm->cmd.serverTime	//not in a force Rage recovery period
+						&& pm->gent->enemy->maxs[2] > 12
+						&& (!pm->gent->enemy->client || !PM_InKnockDownOnGround( &pm->gent->enemy->client->ps ) )
+						&& DistanceSquared( pm->gent->currentOrigin, pm->gent->enemy->currentOrigin ) < 10000
+						&& InFront( pm->gent->enemy->currentOrigin, pm->gent->currentOrigin, fwdAngles, 0.3f ) )
+					{//enemy must be alive, not low to ground, close and in front
+						return qtrue;
+					}
+				}
+				return qfalse;
+			}
+		}
+	}
+	return qfalse;
+}
+
+saberMoveName_t PM_SaberBackflipAttackMove( void )
+{
+	pm->cmd.upmove = 0;//no jump just yet
+	return LS_A_BACKFLIP_ATK;
+}
+
+qboolean PM_CheckBackflipAttackMove( void )
+{
+	if ( pm->ps->clientNum < MAX_CLIENTS 
+		&& PM_InSecondaryStyle() )
+	{
+		return qfalse;
+	}
+
+	if ( pm->ps->forcePowerLevel[FP_LEVITATION] > FORCE_LEVEL_1 //can force jump
+		&& pm->ps->forceRageRecoveryTime < pm->cmd.serverTime	//not in a force Rage recovery period
+		&& pm->gent && !(pm->gent->flags&FL_LOCK_PLAYER_WEAPONS) // yes this locked weapons check also includes force powers, if we need a separate check later I'll make one
+		//&& (pm->ps->legsAnim == BOTH_SABERSTAFF_STANCE || level.time-pm->ps->lastStationary<=250)//standing or just started moving
+		&& (pm->ps->groundEntityNum != ENTITYNUM_NONE||level.time-pm->ps->lastOnGround<=250) )//on ground or just jumped (if not player)
+	{
+		if ( pm->cmd.forwardmove < 0 //moving backwards
+			&& pm->ps->saberAnimLevel == SS_STAFF //using staff
+			&& (pm->cmd.upmove > 0 || (pm->ps->pm_flags&PMF_JUMPING)) )//jumping
+		{//jumping backwards and using staff
+			if ( !PM_SaberInTransitionAny( pm->ps->saberMove ) //not going to/from/between an attack anim
+				&& !PM_SaberInAttack( pm->ps->saberMove ) //not in attack anim
+				&& pm->ps->weaponTime <= 0//not busy
+				&& (pm->cmd.buttons&BUTTON_ATTACK) )//want to attack
+			{//not already attacking
+				if ( pm->ps->clientNum >= MAX_CLIENTS && !PM_ControlledByPlayer() )
+				{//NPC
+					if ( pm->gent 
+						&& pm->gent->NPC 
+						&& (pm->gent->NPC->rank==RANK_CREWMAN||pm->gent->NPC->rank>=RANK_LT) )
+					{//acrobat or boss and higher can do this
+						return qtrue;
+					}
+				}
+				else
+				{//player
+					return qtrue;
+				}
+			}
+		}
+	}
+	return qfalse;
+}
+
+saberMoveName_t PM_CheckDualSpinProtect( void )
+{
+	if ( pm->ps->clientNum < MAX_CLIENTS 
+		&& PM_InSecondaryStyle() )
+	{
+		return LS_NONE;
+	}
+
+	if ( pm->ps->saberMove == LS_READY//ready
+		//&& (pm->ps->clientNum < MAX_CLIENTS||PM_ControlledByPlayer())//PLAYER ONLY...?
+		//&& pm->ps->viewangles[0] > 30 //looking down
+		&& pm->ps->saberAnimLevel == SS_DUAL//using dual saber style
+		&& pm->ps->saber[0].Active() && pm->ps->saber[1].Active()//both sabers on
+		//&& pm->ps->forcePowerLevel[FP_PUSH]>=FORCE_LEVEL_3//force push 3
+		//&& ((pm->ps->forcePowersActive&(1<<FP_PUSH))||pm->ps->forcePowerDebounce[FP_PUSH]>level.time)//force-pushing
+		&& G_TryingKataAttack( pm->gent, &pm->cmd )//(pm->cmd.buttons&BUTTON_FORCE_FOCUS)//holding focus
+		&& G_EnoughPowerForSpecialMove( pm->ps->forcePower, SABER_ALT_ATTACK_POWER, qtrue )//pm->ps->forcePower >= SABER_ALT_ATTACK_POWER//DUAL_SPIN_PROTECT_POWER//force push 3
+		&& (pm->cmd.buttons&BUTTON_ATTACK)//pressing attack
+		)
+	{//FIXME: some NPC logic to do this?
+		/*
+		if ( (pm->ps->pm_flags&PMF_DUCKED||pm->cmd.upmove<0)//crouching
+			&& g_crosshairEntNum >= ENTITYNUM_WORLD )
+		*/
+		{
+			if ( pm->gent )
+			{
+				G_DrainPowerForSpecialMove( pm->gent, FP_PUSH, SABER_ALT_ATTACK_POWER, qtrue );//drain the required force power
+			}
+			return LS_DUAL_SPIN_PROTECT;
+		}
+	}
+	return LS_NONE;
+}
+
+saberMoveName_t PM_CheckStaffKata( void )
+{
+	if ( pm->ps->clientNum < MAX_CLIENTS 
+		&& PM_InSecondaryStyle() )
+	{
+		return LS_NONE;
+	}
+
+	if ( pm->ps->saberMove == LS_READY//ready
+		//&& (pm->ps->clientNum < MAX_CLIENTS||PM_ControlledByPlayer())//PLAYER ONLY...?
+		//&& pm->ps->viewangles[0] > 30 //looking down
+		&& pm->ps->saberAnimLevel == SS_STAFF//using dual saber style
+		&& pm->ps->saber[0].Active()//saber on
+		//&& pm->ps->forcePowerLevel[FP_PUSH]>=FORCE_LEVEL_3//force push 3
+		//&& ((pm->ps->forcePowersActive&(1<<FP_PUSH))||pm->ps->forcePowerDebounce[FP_PUSH]>level.time)//force-pushing
+		&& G_TryingKataAttack( pm->gent, &pm->cmd )//(pm->cmd.buttons&BUTTON_FORCE_FOCUS)//holding focus
+		&& G_EnoughPowerForSpecialMove( pm->ps->forcePower, SABER_ALT_ATTACK_POWER, qtrue )//pm->ps->forcePower >= SABER_ALT_ATTACK_POWER//DUAL_SPIN_PROTECT_POWER//force push 3
+		&& (pm->cmd.buttons&BUTTON_ATTACK)//pressing attack
+		)
+	{//FIXME: some NPC logic to do this?
+		/*
+		if ( (pm->ps->pm_flags&PMF_DUCKED||pm->cmd.upmove<0)//crouching
+			&& g_crosshairEntNum >= ENTITYNUM_WORLD )
+		*/
+		{
+			if ( pm->gent )
+			{
+				G_DrainPowerForSpecialMove( pm->gent, FP_LEVITATION, SABER_ALT_ATTACK_POWER, qtrue );//drain the required force power
+			}
+			return LS_STAFF_SOULCAL;
+		}
+	}
+	return LS_NONE;
+}
+
+extern qboolean WP_ForceThrowable( gentity_t *ent, gentity_t *forwardEnt, gentity_t *self, qboolean pull, float cone, float radius, vec3_t forward );
+saberMoveName_t PM_CheckPullAttack( void )
+{
+	if ( pm->ps->clientNum < MAX_CLIENTS 
+		&& PM_InSecondaryStyle() )
+	{
+		return LS_NONE;
+	}
+
+	if ( (pm->ps->saberMove == LS_READY||PM_SaberInReturn(pm->ps->saberMove)||PM_SaberInReflect(pm->ps->saberMove))//ready
+		//&& (pm->ps->clientNum < MAX_CLIENTS||PM_ControlledByPlayer())//PLAYER ONLY
+		&& pm->ps->saberAnimLevel >= SS_FAST//single saber styles - FIXME: Tavion?
+		&& pm->ps->saberAnimLevel <= SS_STRONG//single saber styles - FIXME: Tavion?
+		&& G_TryingPullAttack( pm->gent, &pm->cmd, qfalse )//(pm->cmd.buttons&BUTTON_FORCE_FOCUS)//holding focus
+		//&& pm->cmd.forwardmove<0//pulling back
+		&& (pm->cmd.buttons&BUTTON_ATTACK)//attacking
+		&& G_EnoughPowerForSpecialMove( pm->ps->forcePower, SABER_ALT_ATTACK_POWER_FB )//pm->ps->forcePower >= SABER_ALT_ATTACK_POWER_FB//have enough power
+		)
+	{//FIXME: some NPC logic to do this?
+		qboolean doMove = g_saberNewControlScheme->integer?qtrue:qfalse;//in new control scheme, can always do this, even if there's no-one to do it to
+		if ( g_saberNewControlScheme->integer
+			|| g_crosshairEntNum < ENTITYNUM_WORLD )//in old control scheme, there has to be someone there
+		{	
+			saberMoveName_t pullAttackMove = LS_NONE;
+			if ( pm->ps->saberAnimLevel == SS_FAST )
+			{
+				pullAttackMove = LS_PULL_ATTACK_STAB;
+			}
+			else
+			{
+				pullAttackMove = LS_PULL_ATTACK_SWING;
+			}
+
+			if ( g_crosshairEntNum < ENTITYNUM_WORLD 
+				&& pm->gent && pm->gent->client )
+			{
+				gentity_t *targEnt = &g_entities[g_crosshairEntNum];
+				if ( targEnt->client
+					&& targEnt->health > 0
+					//FIXME: check other things like in knockdown, saberlock, uninterruptable anims, etc.
+					&& !PM_InOnGroundAnim( &targEnt->client->ps )
+					&& !PM_LockedAnim( targEnt->client->ps.legsAnim ) 
+					&& !PM_SuperBreakLoseAnim( targEnt->client->ps.legsAnim )
+					&& !PM_SuperBreakWinAnim( targEnt->client->ps.legsAnim )
+					&& targEnt->client->ps.saberLockTime <= 0
+					&& WP_ForceThrowable( targEnt, targEnt, pm->gent, qtrue, 1.0f, 0.0f, NULL ) )
+				{
+					if ( !g_saberNewControlScheme->integer )
+					{//in old control scheme, make sure they're close or far enough away for the move we'll be doing
+						float targDist = Distance( targEnt->currentOrigin, pm->ps->origin );
+						if ( pullAttackMove == LS_PULL_ATTACK_STAB )
+						{//must be closer than 512
+							if ( targDist > 384.0f )
+							{
+								return LS_NONE;
+							}
+						}
+						else//if ( pullAttackMove == LS_PULL_ATTACK_SWING )
+						{//must be farther than 256
+							if ( targDist > 512.0f )
+							{
+								return LS_NONE;
+							}
+							if ( targDist < 192.0f )
+							{
+								return LS_NONE;
+							}
+						}
+					}
+
+					vec3_t targAngles = {0,targEnt->client->ps.viewangles[YAW],0};
+					if ( InFront( pm->ps->origin, targEnt->currentOrigin, targAngles ) )
+					{
+						NPC_SetAnim( targEnt, SETANIM_BOTH, BOTH_PULLED_INAIR_F, SETANIM_FLAG_OVERRIDE, SETANIM_FLAG_HOLD );
+					}
+					else
+					{
+						NPC_SetAnim( targEnt, SETANIM_BOTH, BOTH_PULLED_INAIR_B, SETANIM_FLAG_OVERRIDE, SETANIM_FLAG_HOLD );
+					}
+					//hold the anim until I'm with done pull anim
+					targEnt->client->ps.legsAnimTimer = targEnt->client->ps.torsoAnimTimer = PM_AnimLength( pm->gent->client->clientInfo.animFileIndex, (animNumber_t)saberMoveData[pullAttackMove].animToUse );
+					//set pullAttackTime
+					pm->gent->client->ps.pullAttackTime = targEnt->client->ps.pullAttackTime = level.time+targEnt->client->ps.legsAnimTimer;
+					//make us know about each other
+					pm->gent->client->ps.pullAttackEntNum = g_crosshairEntNum;
+					targEnt->client->ps.pullAttackEntNum = pm->ps->clientNum;
+					//do effect and sound on me
+					pm->ps->powerups[PW_FORCE_PUSH] = level.time + 1000;
+					if ( pm->gent )
+					{
+						G_Sound( pm->gent, G_SoundIndex( "sound/weapons/force/pull.wav" ) );
+					}
+					doMove = qtrue;
+				}
+			}
+			if ( doMove )
+			{
+				if ( pm->gent )
+				{
+					G_DrainPowerForSpecialMove( pm->gent, FP_PULL, SABER_ALT_ATTACK_POWER_FB );
+				}
+				return pullAttackMove;
+			}
+		}
+	}
+	return LS_NONE;
+}
+
+saberMoveName_t PM_CheckPlayerAttackFromParry( int curmove )
+{
+	if ( pm->ps->clientNum < MAX_CLIENTS || PM_ControlledByPlayer() )
+	{
+		if ( curmove >= LS_PARRY_UP 
+			&& curmove <= LS_REFLECT_LL )
+		{//in a parry
+			switch ( saberMoveData[curmove].endQuad )
+			{
+			case Q_T:
+				return LS_A_T2B;
+				break;
+			case Q_TR:
+				return LS_A_TR2BL;
+				break;
+			case Q_TL:
+				return LS_A_TL2BR;
+				break;
+			case Q_BR:
+				return LS_A_BR2TL;
+				break;
+			case Q_BL:
+				return LS_A_BL2TR;
+				break;
+			//shouldn't be a parry that ends at L, R or B
+			}
+		}
+	}
+	return LS_NONE;
+}
+
+
+saberMoveName_t PM_SaberAttackForMovement( int forwardmove, int rightmove, int curmove )
+{
+	qboolean noSpecials = qfalse;
+	
+	if ( pm->ps->clientNum < MAX_CLIENTS 
+		&& PM_InSecondaryStyle() )
+	{
+		noSpecials = qtrue;
+	}
+
+#ifdef _XBOX
+	if ( rightmove > 64 )
+#else
+	if ( rightmove > 0 )
+#endif // _XBOX
+	{//moving right
+		if ( !noSpecials
+			&& (pm->ps->groundEntityNum != ENTITYNUM_NONE||level.time-pm->ps->lastOnGround<=250) //on ground or just jumped
+			&& (pm->cmd.buttons&BUTTON_ATTACK)//hitting attack
+			&& pm->ps->forcePowerLevel[FP_LEVITATION] > FORCE_LEVEL_0//have force jump 1 at least
+			&& G_EnoughPowerForSpecialMove( pm->ps->forcePower, SABER_ALT_ATTACK_POWER_LR )//pm->ps->forcePower >= SABER_ALT_ATTACK_POWER_LR//have enough power
+			&& (((pm->ps->clientNum>=MAX_CLIENTS&&!PM_ControlledByPlayer())&&pm->cmd.upmove > 0)//jumping NPC
+				||((pm->ps->clientNum<MAX_CLIENTS||PM_ControlledByPlayer())&&G_TryingCartwheel(pm->gent, &pm->cmd)/*(pm->cmd.buttons&BUTTON_FORCE_FOCUS)*/)) )//focus-holding player
+		{//cartwheel right
+			vec3_t right, fwdAngles = {0, pm->ps->viewangles[YAW], 0};
+			if ( pm->gent )
+			{
+				G_DrainPowerForSpecialMove( pm->gent, FP_LEVITATION, SABER_ALT_ATTACK_POWER_LR );
+			}
+			pm->cmd.upmove = 0;
+			if ( pm->ps->saberAnimLevel == SS_STAFF )
+			{
+				AngleVectors( fwdAngles, NULL, right, NULL );
+				pm->ps->velocity[0] = pm->ps->velocity[1] = 0; 
+				VectorMA( pm->ps->velocity, 190, right, pm->ps->velocity );
+				return LS_BUTTERFLY_RIGHT;
+			}
+			else
+			{
+				/*
+				if ( pm->ps->groundEntityNum != ENTITYNUM_NONE )
+				{//still on ground
+					VectorClear( pm->ps->velocity );
+					return LS_JUMPATTACK_CART_RIGHT;
+				}
+				else
+				*/
+				{//in air
+					AngleVectors( fwdAngles, NULL, right, NULL );
+					pm->ps->velocity[0] = pm->ps->velocity[1] = 0; 
+					VectorMA( pm->ps->velocity, 190, right, pm->ps->velocity );
+					PM_SetJumped( JUMP_VELOCITY, qtrue );
+					return LS_JUMPATTACK_ARIAL_RIGHT;
+				}
+			}
+		}
+		else if ( pm->ps->legsAnim != BOTH_CARTWHEEL_RIGHT 
+			&& pm->ps->legsAnim != BOTH_ARIAL_RIGHT )
+		{//not in a cartwheel/arial
+			if ( pm->ps->clientNum < MAX_CLIENTS || PM_ControlledByPlayer() ) //PLAYER ONLY
+			{//player 
+				if ( G_TryingSpecial(pm->gent, &pm->cmd)/*(pm->cmd.buttons&BUTTON_FORCE_FOCUS)*/ )//Holding focus
+				{//if no special worked, do nothing
+					return LS_NONE;
+				}
+			}
+			//checked all special attacks, if we're in a parry, attack from that move
+			saberMoveName_t parryAttackMove = PM_CheckPlayerAttackFromParry( curmove );
+			if ( parryAttackMove != LS_NONE )
+			{
+				return parryAttackMove;
+			}
+			//check regular attacks
+			if ( forwardmove > 0 )
+			{//forward right = TL2BR slash
+				return LS_A_TL2BR;
+			}
+			else if ( forwardmove < 0 )
+			{//backward right = BL2TR uppercut
+				return LS_A_BL2TR;
+			}
+			else
+			{//just right is a left slice
+				return LS_A_L2R;
+			}
+		}
+	}
+#ifdef _XBOX
+	else if ( rightmove < -64 )
+#else
+	else if ( rightmove < 0 )
+#endif // _XBOX
+	{//moving left
+		if ( !noSpecials
+			&& (pm->ps->groundEntityNum != ENTITYNUM_NONE||level.time-pm->ps->lastOnGround<=250) //on ground or just jumped
+			&& (pm->cmd.buttons&BUTTON_ATTACK)//hitting attack
+			&& pm->ps->forcePowerLevel[FP_LEVITATION] > FORCE_LEVEL_0//have force jump 1 at least
+			&& G_EnoughPowerForSpecialMove( pm->ps->forcePower, SABER_ALT_ATTACK_POWER_LR )//pm->ps->forcePower >= SABER_ALT_ATTACK_POWER_LR//have enough power
+			&& (((pm->ps->clientNum>=MAX_CLIENTS&&!PM_ControlledByPlayer())&&pm->cmd.upmove > 0)//jumping NPC
+				||((pm->ps->clientNum<MAX_CLIENTS||PM_ControlledByPlayer())&&G_TryingCartwheel(pm->gent, &pm->cmd)/*(pm->cmd.buttons&BUTTON_FORCE_FOCUS)*/)) )//focus-holding player
+		{//cartwheel left
+			vec3_t right, fwdAngles = {0, pm->ps->viewangles[YAW], 0};
+			if ( pm->gent )
+			{
+				G_DrainPowerForSpecialMove( pm->gent, FP_LEVITATION, SABER_ALT_ATTACK_POWER_LR );
+			}
+			pm->cmd.upmove = 0;
+			if ( pm->ps->saberAnimLevel == SS_STAFF )
+			{
+				AngleVectors( fwdAngles, NULL, right, NULL );
+				pm->ps->velocity[0] = pm->ps->velocity[1] = 0; 
+				VectorMA( pm->ps->velocity, -190, right, pm->ps->velocity );
+				return LS_BUTTERFLY_LEFT;
+			}
+			else
+			{
+				/*
+				if ( pm->ps->groundEntityNum != ENTITYNUM_NONE )
+				{//still on ground
+					VectorClear( pm->ps->velocity );
+					return LS_JUMPATTACK_ARIAL_LEFT;
+				}
+				else
+				*/
+				{
+					AngleVectors( fwdAngles, NULL, right, NULL );
+					pm->ps->velocity[0] = pm->ps->velocity[1] = 0; 
+					VectorMA( pm->ps->velocity, -190, right, pm->ps->velocity );
+					PM_SetJumped( JUMP_VELOCITY, qtrue );
+					return LS_JUMPATTACK_CART_LEFT;
+				}
+			}
+		}
+		else if ( pm->ps->legsAnim != BOTH_CARTWHEEL_LEFT 
+			&& pm->ps->legsAnim != BOTH_ARIAL_LEFT )
+		{//not in a left cartwheel/arial
+			if ( pm->ps->clientNum < MAX_CLIENTS || PM_ControlledByPlayer() ) //PLAYER ONLY
+			{//player 
+				if ( G_TryingSpecial(pm->gent, &pm->cmd)/*(pm->cmd.buttons&BUTTON_FORCE_FOCUS)*/ )//Holding focus
+				{//if no special worked, do nothing
+					return LS_NONE;
+				}
+			}
+			//checked all special attacks, if we're in a parry, attack from that move
+			saberMoveName_t parryAttackMove = PM_CheckPlayerAttackFromParry( curmove );
+			if ( parryAttackMove != LS_NONE )
+			{
+				return parryAttackMove;
+			}
+			//check regular attacks
+			if ( forwardmove > 0 )
+			{//forward left = TR2BL slash
+				return LS_A_TR2BL;
+			}
+			else if ( forwardmove < 0 )
+			{//backward left = BR2TL uppercut
+				return LS_A_BR2TL;
+			}
+			else
+			{//just left is a right slice
+				return LS_A_R2L;
+			}
+		}
+	}
+	else
+	{//not moving left or right
+#ifdef _XBOX
+		if ( forwardmove > 64 )
+#else
+		if ( forwardmove > 0 )
+#endif // _XBOX
+		{//forward= T2B slash
+			saberMoveName_t stabDownMove = noSpecials?LS_NONE:PM_CheckStabDown();
+			if ( stabDownMove != LS_NONE )
+			{
+				return stabDownMove;
+			}
+			if ( ((pm->ps->clientNum < MAX_CLIENTS||PM_ControlledByPlayer()) && cg.renderingThirdPerson && !cg.zoomMode) )//player in third person, not zoomed in
+			{//player in thirdperson, not zoomed in
+				//flip-over attack logic
+				if ( !noSpecials && PM_CheckFlipOverAttackMove( qfalse ) )
+				{//flip over-forward down-attack
+					return PM_SaberFlipOverAttackMove();
+				}
+				//lunge attack logic
+				else if ( PM_CheckLungeAttackMove() )
+				{
+					return PM_SaberLungeAttackMove( qtrue );
+				}
+				//jump forward attack logic
+				else if ( !noSpecials && PM_CheckJumpForwardAttackMove() )
+				{
+					return PM_SaberJumpForwardAttackMove();
+				}
+			}
+
+			//player NPC with enemy: autoMove logic
+			if ( pm->gent 
+				&& pm->gent->enemy 
+				&& pm->gent->enemy->client )
+			{//I have an active enemy
+				if ( pm->ps->clientNum < MAX_CLIENTS || PM_ControlledByPlayer() )
+				{//a player who is running at an enemy
+					//if the enemy is not a jedi, don't use top-down, pick a diagonal or side attack
+					if ( pm->gent->enemy->s.weapon != WP_SABER 
+						&& pm->gent->enemy->client->NPC_class != CLASS_REMOTE//too small to do auto-aiming accurately
+						&& pm->gent->enemy->client->NPC_class != CLASS_SEEKER//too small to do auto-aiming accurately
+						&& pm->gent->enemy->client->NPC_class != CLASS_GONK//too short to do auto-aiming accurately
+						&& pm->gent->enemy->client->NPC_class != CLASS_HOWLER//too short to do auto-aiming accurately
+						&& g_saberAutoAim->integer )
+					{
+						saberMoveName_t autoMove = PM_AttackForEnemyPos( qfalse, (qboolean)(pm->ps->clientNum>=MAX_CLIENTS&&!PM_ControlledByPlayer()) );
+						if ( autoMove != LS_INVALID )
+						{
+							return autoMove;
+						}
+					}
+				}
+
+				if ( pm->ps->clientNum>=MAX_CLIENTS && !PM_ControlledByPlayer() ) //NPC ONLY
+				{//NPC
+					if ( PM_CheckFlipOverAttackMove( qtrue ) )
+					{
+						return PM_SaberFlipOverAttackMove();
+					}
+				}
+			}
+			
+			//Regular NPCs
+			if ( pm->ps->clientNum >= MAX_CLIENTS && !PM_ControlledByPlayer() ) //NPC ONLY
+			{//NPC or player in third person, not zoomed in
+				//fwd jump attack logic
+				if ( PM_CheckJumpForwardAttackMove() )
+				{
+					return PM_SaberJumpForwardAttackMove();
+				}
+				//lunge attack logic
+				else if ( PM_CheckLungeAttackMove() )
+				{
+					return PM_SaberLungeAttackMove( qtrue );
+				}
+			}
+
+			if ( pm->ps->clientNum < MAX_CLIENTS || PM_ControlledByPlayer() ) //PLAYER ONLY
+			{//player 
+				if ( G_TryingSpecial(pm->gent,&pm->cmd) )//(pm->cmd.buttons&BUTTON_FORCE_FOCUS) )//Holding focus
+				{//if no special worked, do nothing
+					return LS_NONE;
+				}
+			}
+		
+			//checked all special attacks, if we're in a parry, attack from that move
+			saberMoveName_t parryAttackMove = PM_CheckPlayerAttackFromParry( curmove );
+			if ( parryAttackMove != LS_NONE )
+			{
+				return parryAttackMove;
+			}
+			//check regular attacks
+			return LS_A_T2B;
+		}
+#ifdef _XBOX
+		else if ( forwardmove < -64 )
+#else
+		else if ( forwardmove < 0 )
+#endif // _XBOX
+		{//backward= T2B slash//B2T uppercut?
+			if ( g_saberNewControlScheme->integer )
+			{
+				saberMoveName_t pullAtk = PM_CheckPullAttack();
+				if ( pullAtk != LS_NONE )
+				{
+					return pullAtk;
+				}
+			}
+			
+			if ( g_saberNewControlScheme->integer
+				&& (pm->ps->clientNum < MAX_CLIENTS || PM_ControlledByPlayer())  //PLAYER ONLY
+				&& (pm->cmd.buttons&BUTTON_FORCE_FOCUS) )//Holding focus, trying special backwards attacks
+			{//player lunge attack logic
+				if ( ( pm->ps->dualSabers //or dual
+						|| pm->ps->saberAnimLevel == SS_STAFF )//pm->ps->SaberStaff() )//or staff
+					&& G_EnoughPowerForSpecialMove( pm->ps->forcePower, SABER_ALT_ATTACK_POWER_FB )/*pm->ps->forcePower >= SABER_ALT_ATTACK_POWER_FB*/ )//have enough force power to pull it off
+				{//alt+back+attack using fast, dual or staff attacks
+					PM_SaberLungeAttackMove( qfalse );
+				}
+			}
+			else if ( (pm->ps->clientNum&&!PM_ControlledByPlayer()) //NPC
+				|| ((pm->ps->clientNum < MAX_CLIENTS||PM_ControlledByPlayer()) && cg.renderingThirdPerson && !cg.zoomMode) )//player in third person, not zooomed
+			{//NPC or player in third person, not zoomed
+				if ( PM_CheckBackflipAttackMove() )
+				{
+					return PM_SaberBackflipAttackMove();//backflip attack
+				}
+				if ( pm->ps->clientNum < MAX_CLIENTS || PM_ControlledByPlayer() ) //PLAYER ONLY
+				{//player 
+					if ( G_TryingSpecial(pm->gent,&pm->cmd) )//(pm->cmd.buttons&BUTTON_FORCE_FOCUS) )//Holding focus
+					{//if no special worked, do nothing
+						return LS_NONE;
+					}
+				}
+				//if ( !PM_InKnockDown( pm->ps ) )
+				if ( pm->ps->groundEntityNum != ENTITYNUM_NONE )
+				{//only when on ground
+					if ( pm->gent && pm->gent->enemy )
+					{//FIXME: or just trace for a valid enemy standing behind me?  And no enemy in front?
+						vec3_t enemyDir, faceFwd, facingAngles = {0, pm->ps->viewangles[YAW], 0};
+						AngleVectors( facingAngles, faceFwd, NULL, NULL );
+						VectorSubtract( pm->gent->enemy->currentOrigin, pm->ps->origin, enemyDir );
+						float dot = DotProduct( enemyDir, faceFwd );
+						if ( dot < 0 )
+						{//enemy is behind me
+							if ( dot < -0.75f 
+								&& DistanceSquared( pm->gent->currentOrigin, pm->gent->enemy->currentOrigin ) < 16384//128 squared
+								&& (pm->ps->saberAnimLevel == SS_FAST || pm->ps->saberAnimLevel == SS_STAFF || (pm->gent->client &&(pm->gent->client->NPC_class == CLASS_TAVION||pm->gent->client->NPC_class == CLASS_ALORA)&&Q_irand(0,1))) )
+							{//fast attacks and Tavion
+								if ( !(pm->ps->pm_flags&PMF_DUCKED) && pm->cmd.upmove >= 0 )
+								{//can't do it while ducked?
+									if ( (pm->ps->clientNum < MAX_CLIENTS||PM_ControlledByPlayer()) || (pm->gent->NPC && pm->gent->NPC->rank >= RANK_LT_JG) )
+									{//only fencers and above can do this
+										return LS_A_BACKSTAB;
+									}
+								}
+							}
+							else if ( pm->ps->saberAnimLevel != SS_FAST
+								&& pm->ps->saberAnimLevel != SS_STAFF )
+							{//medium and higher attacks
+								if ( (pm->ps->pm_flags&PMF_DUCKED) || pm->cmd.upmove < 0 )
+								{
+									return LS_A_BACK_CR;
+								}
+								else
+								{
+									return LS_A_BACK;
+								}
+							}
+						}
+						else
+						{//enemy in front
+							float enemyDistSq = DistanceSquared( pm->gent->currentOrigin, pm->gent->enemy->currentOrigin );
+							if ( (pm->ps->saberAnimLevel == FORCE_LEVEL_1||pm->ps->saberAnimLevel == SS_STAFF||pm->gent->client->NPC_class==CLASS_TAVION||pm->gent->client->NPC_class == CLASS_ALORA||(pm->gent->client->NPC_class==CLASS_DESANN&&!Q_irand(0,3))) && enemyDistSq > 16384 || pm->gent->enemy->health <= 0 )//128 squared
+							{//my enemy is pretty far in front of me and I'm using fast attacks
+								if ( (pm->ps->clientNum < MAX_CLIENTS||PM_ControlledByPlayer()) ||
+									( pm->gent && pm->gent->client && pm->gent->NPC && pm->gent->NPC->rank >= RANK_LT_JG && Q_irand( 0, pm->gent->NPC->rank ) > RANK_ENSIGN ) )
+								{//only fencers and higher can do this, higher rank does it more
+									if ( PM_CheckEnemyInBack( 128 ) )
+									{
+										return PM_PickBackStab();
+									}
+								}
+							}
+							else if ( (pm->ps->saberAnimLevel >= FORCE_LEVEL_2 || pm->gent->client->NPC_class == CLASS_DESANN) && enemyDistSq > 40000 || pm->gent->enemy->health <= 0 )//200 squared
+							{//enemy is very faw away and I'm using medium/strong attacks
+								if ( (pm->ps->clientNum < MAX_CLIENTS||PM_ControlledByPlayer()) ||
+									( pm->gent && pm->gent->client && pm->gent->NPC && pm->gent->NPC->rank >= RANK_LT_JG && Q_irand( 0, pm->gent->NPC->rank ) > RANK_ENSIGN ) )
+								{//only fencers and higher can do this, higher rank does it more
+									if ( PM_CheckEnemyInBack( 164 ) )
+									{
+										return PM_PickBackStab();
+									}
+								}
+							}
+						}
+					}
+					else
+					{//no current enemy
+						if ( (pm->ps->clientNum < MAX_CLIENTS||PM_ControlledByPlayer()) && pm->gent && pm->gent->client )
+						{//only player
+							if ( PM_CheckEnemyInBack( 128 ) )
+							{
+								return PM_PickBackStab();
+							}
+						}
+					}
+				}
+			}
+
+			if ( pm->ps->clientNum < MAX_CLIENTS || PM_ControlledByPlayer() ) //PLAYER ONLY
+			{//player 
+				if ( G_TryingSpecial( pm->gent, &pm->cmd ) )//(pm->cmd.buttons&BUTTON_FORCE_FOCUS) )//Holding focus
+				{//if no special worked, do nothing
+					return LS_NONE;
+				}
+			}
+			
+			//checked all special attacks, if we're in a parry, attack from that move
+			saberMoveName_t parryAttackMove = PM_CheckPlayerAttackFromParry( curmove );
+			if ( parryAttackMove != LS_NONE )
+			{
+				return parryAttackMove;
+			}
+			//check regular attacks
+			//else just swing down
+			return LS_A_T2B;
+		}
+		else
+		{//not moving in any direction
+			if ( PM_SaberInBounce( curmove ) )
+			{//bounces should go to their default attack if you don't specify a direction but are attacking
+				if ( pm->ps->clientNum < MAX_CLIENTS || PM_ControlledByPlayer() ) //PLAYER ONLY
+				{//player 
+					if ( G_TryingSpecial(pm->gent,&pm->cmd) )//(pm->cmd.buttons&BUTTON_FORCE_FOCUS) )//Holding focus
+					{//if no special worked, do nothing
+						return LS_NONE;
+					}
+				}
+				saberMoveName_t newmove;
+				if ( pm->ps->clientNum && !PM_ControlledByPlayer() && Q_irand( 0, 3 ) )
+				{//use NPC random
+					newmove = PM_NPCSaberAttackFromQuad( saberMoveData[curmove].endQuad );
+				}
+				else
+				{//player uses chain-attack
+					newmove = saberMoveData[curmove].chain_attack;
+				}
+				if ( PM_SaberKataDone( curmove, newmove ) )
+				{
+					return saberMoveData[curmove].chain_idle;
+				}
+				else
+				{
+					return newmove;
+				}
+			}
+			else if ( PM_SaberInKnockaway( curmove ) )
+			{//bounces should go to their default attack if you don't specify a direction but are attacking
+				if ( pm->ps->clientNum < MAX_CLIENTS || PM_ControlledByPlayer() ) //PLAYER ONLY
+				{//player 
+					if ( G_TryingSpecial( pm->gent, &pm->cmd ) )//(pm->cmd.buttons&BUTTON_FORCE_FOCUS) )//Holding focus
+					{//if no special worked, do nothing
+						return LS_NONE;
+					}
+				}
+				saberMoveName_t newmove;
+				if ( pm->ps->clientNum && !PM_ControlledByPlayer() && Q_irand( 0, 3 ) )
+				{//use NPC random
+					newmove = PM_NPCSaberAttackFromQuad( saberMoveData[curmove].endQuad );
+				}
+				else
+				{
+					if ( pm->ps->saberAnimLevel == SS_FAST ||
+						pm->ps->saberAnimLevel == SS_TAVION )
+					{//player is in fast attacks, so come right back down from the same spot
+						newmove = PM_AttackMoveForQuad( saberMoveData[curmove].endQuad );
+					}
+					else
+					{//use a transition to wrap to another attack from a different dir
+						newmove = saberMoveData[curmove].chain_attack;
+					}
+				}
+				if ( PM_SaberKataDone( curmove, newmove ) )
+				{
+					return saberMoveData[curmove].chain_idle;
+				}
+				else
+				{
+					return newmove;
+				}
+			}
+			else if ( curmove == LS_READY 
+				|| curmove == LS_A_FLIP_STAB 
+				|| curmove == LS_A_FLIP_SLASH
+				|| ( curmove >= LS_PARRY_UP 
+					&& curmove <= LS_REFLECT_LL ) )
+			{//Not moving at all, not too busy to attack
+				//push + lookdown + attack + dual sabers = LS_DUAL_SPIN_PROTECT
+				if ( g_saberNewControlScheme->integer )
+				{
+					if ( PM_CheckDualSpinProtect() )
+					{
+						return LS_DUAL_SPIN_PROTECT;
+					}
+					if ( PM_CheckStaffKata() )
+					{
+						return LS_STAFF_SOULCAL;
+					}
+				}
+				if ( pm->ps->clientNum < MAX_CLIENTS || PM_ControlledByPlayer() ) //PLAYER ONLY
+				{//player 
+					if ( G_TryingSpecial( pm->gent, &pm->cmd ) )//(pm->cmd.buttons&BUTTON_FORCE_FOCUS) )//Holding focus
+					{//if no special worked, do nothing
+						return LS_NONE;
+					}
+				}
+				//checked all special attacks, if we're in a parry, attack from that move
+				saberMoveName_t parryAttackMove = PM_CheckPlayerAttackFromParry( curmove );
+				if ( parryAttackMove != LS_NONE )
+				{
+					return parryAttackMove;
+				}
+				//check regular attacks
+				if ( pm->ps->clientNum || g_saberAutoAim->integer )
+				{//auto-aim
+					if ( pm->gent && pm->gent->enemy )
+					{//based on enemy position, pick a proper attack
+						saberMoveName_t autoMove = PM_AttackForEnemyPos( qtrue, (qboolean)(pm->ps->clientNum>=MAX_CLIENTS) );
+						if ( autoMove != LS_INVALID )
+						{
+							return autoMove;
+						}
+					}
+					else if ( fabs(pm->ps->viewangles[0]) > 30 )
+					{//looking far up or far down uses the top to bottom attack, presuming you want a vertical attack
+						return LS_A_T2B;
+					}
+				}
+				else
+				{//for now, just pick a random attack
+					return ((saberMoveName_t)Q_irand( LS_A_TL2BR, LS_A_T2B ));
+				}
+			}
+		}
+	}
+	//FIXME: pick a return?
+	return LS_NONE;
+}
+
+saberMoveName_t PM_SaberAnimTransitionMove( saberMoveName_t curmove, saberMoveName_t newmove )
+{
+	//FIXME: take FP_SABER_OFFENSE into account here somehow?
+	int retmove = newmove;
+	if ( curmove == LS_READY )
+	{//just standing there
+		switch ( newmove )
+		{
+		case LS_A_TL2BR:
+		case LS_A_L2R:
+		case LS_A_BL2TR:
+		case LS_A_BR2TL:
+		case LS_A_R2L:
+		case LS_A_TR2BL:
+		case LS_A_T2B:
+			//transition is the start
+			retmove = LS_S_TL2BR + (newmove-LS_A_TL2BR);
+			break;
+		}
+	}
+	else
+	{
+		switch ( newmove )
+		{
+		//transitioning to ready pose
+		case LS_READY:
+			switch ( curmove )
+			{
+			//transitioning from an attack
+			case LS_A_TL2BR:
+			case LS_A_L2R:
+			case LS_A_BL2TR:
+			case LS_A_BR2TL:
+			case LS_A_R2L:
+			case LS_A_TR2BL:
+			case LS_A_T2B:
+				//transition is the return
+				retmove = LS_R_TL2BR + (newmove-LS_A_TL2BR);
+				break;
+			}
+			break;
+		//transitioning to an attack
+		case LS_A_TL2BR:
+		case LS_A_L2R:
+		case LS_A_BL2TR:
+		case LS_A_BR2TL:
+		case LS_A_R2L:
+		case LS_A_TR2BL:
+		case LS_A_T2B:
+			if ( newmove == curmove )
+			{//FIXME: need a spin or something or go to next level, but for now, just play the return
+				//going into another attack...
+				//allow endless chaining in level 1 attacks, several in level 2 and only one or a few in level 3
+				//FIXME: don't let strong attacks chain to an attack in the opposite direction ( > 45 degrees?)
+				if ( PM_SaberKataDone( curmove, newmove ) )
+				{//done with this kata, must return to ready before attack again
+					retmove = LS_R_TL2BR + (newmove-LS_A_TL2BR);
+				}
+				else
+				{//okay to chain to another attack
+					retmove = transitionMove[saberMoveData[curmove].endQuad][saberMoveData[newmove].startQuad];
+				}
+			}
+			else if ( saberMoveData[curmove].endQuad == saberMoveData[newmove].startQuad )
+			{//new move starts from same quadrant
+				retmove = newmove;
+			}
+			else
+			{
+				switch ( curmove )
+				{
+				//transitioning from an attack
+				case LS_A_TL2BR:
+				case LS_A_L2R:
+				case LS_A_BL2TR:
+				case LS_A_BR2TL:
+				case LS_A_R2L:
+				case LS_A_TR2BL:
+				case LS_A_T2B:
+				case LS_D1_BR:
+				case LS_D1__R:
+				case LS_D1_TR:
+				case LS_D1_T_:
+				case LS_D1_TL:
+				case LS_D1__L:
+				case LS_D1_BL:
+				case LS_D1_B_:
+					retmove = transitionMove[saberMoveData[curmove].endQuad][saberMoveData[newmove].startQuad];
+					break;
+				//transitioning from a return
+				case LS_R_TL2BR:
+				case LS_R_L2R:
+				case LS_R_BL2TR:
+				case LS_R_BR2TL:
+				case LS_R_R2L:
+				case LS_R_TR2BL:
+				case LS_R_T2B:
+				//transitioning from a bounce
+				/*
+				case LS_BOUNCE_UL2LL:
+				case LS_BOUNCE_LL2UL:
+				case LS_BOUNCE_L2LL:
+				case LS_BOUNCE_L2UL:
+				case LS_BOUNCE_UR2LR:
+				case LS_BOUNCE_LR2UR:
+				case LS_BOUNCE_R2LR:
+				case LS_BOUNCE_R2UR:
+				case LS_BOUNCE_TOP:
+				case LS_OVER_UR2UL:
+				case LS_OVER_UL2UR:
+				case LS_BOUNCE_UR:
+				case LS_BOUNCE_UL:
+				case LS_BOUNCE_LR:
+				case LS_BOUNCE_LL:
+				*/
+				//transitioning from a parry/reflection/knockaway/broken parry
+				case LS_PARRY_UP:
+				case LS_PARRY_UR:
+				case LS_PARRY_UL:
+				case LS_PARRY_LR:
+				case LS_PARRY_LL:
+				case LS_REFLECT_UP:
+				case LS_REFLECT_UR:
+				case LS_REFLECT_UL:
+				case LS_REFLECT_LR:
+				case LS_REFLECT_LL:
+				case LS_K1_T_:
+				case LS_K1_TR:
+				case LS_K1_TL:
+				case LS_K1_BR:
+				case LS_K1_BL:
+				case LS_V1_BR:
+				case LS_V1__R:
+				case LS_V1_TR:
+				case LS_V1_T_:
+				case LS_V1_TL:
+				case LS_V1__L:
+				case LS_V1_BL:
+				case LS_V1_B_:
+				case LS_H1_T_:
+				case LS_H1_TR:
+				case LS_H1_TL:
+				case LS_H1_BR:
+				case LS_H1_BL:
+					retmove = transitionMove[saberMoveData[curmove].endQuad][saberMoveData[newmove].startQuad];
+					break;
+				//NB: transitioning from transitions is fine
+				}
+			}
+			break;
+		//transitioning to any other anim is not supported
+		}
+	}
+
+	if ( retmove == LS_NONE )
+	{
+		return newmove;
+	}
+
+	return ((saberMoveName_t)retmove);
+}
+
+/*
+-------------------------
+PM_LegsAnimForFrame
+Returns animNumber for current frame
+-------------------------
+*/
+int PM_LegsAnimForFrame( gentity_t *ent, int legsFrame )
+{
+	//Must be a valid client
+	if ( ent->client == NULL )
+		return -1;
+
+	//Must have a file index entry
+	if( ValidAnimFileIndex( ent->client->clientInfo.animFileIndex ) == qfalse )
+		return -1;
+
+	animation_t *animations = level.knownAnimFileSets[ent->client->clientInfo.animFileIndex].animations;
+	int	glaIndex = gi.G2API_GetAnimIndex(&(ent->ghoul2[0]));
+
+	for ( int animation = 0; animation < BOTH_CIN_1; animation++ )	//first anim after last legs
+	{
+		if ( animation >= TORSO_DROPWEAP1 && animation < LEGS_TURN1 )	//first legs only anim
+		{//not a possible legs anim
+			continue;
+		}
+
+		if ( animations[animation].glaIndex != glaIndex )
+		{
+			continue;
+		}
+
+		if ( animations[animation].firstFrame > legsFrame )
+		{//This anim starts after this frame
+			continue;
+		}
+
+		if ( animations[animation].firstFrame + animations[animation].numFrames < legsFrame )
+		{//This anim ends before this frame
+			continue;
+		}
+		//else, must be in this anim!
+		return animation;
+	}
+
+	//Not in ANY torsoAnim?  SHOULD NEVER HAPPEN
+//	assert(0);
+	return -1;
+}
+
+int PM_ValidateAnimRange( const int startFrame, const int endFrame, const float animSpeed )
+{//given a startframe and endframe, see if that lines up with any known animation
+	animation_t *animations = level.knownAnimFileSets[0].animations;
+
+	for ( int anim = 0; anim < MAX_ANIMATIONS; anim++ )
+	{
+		if ( animSpeed < 0 )
+		{//playing backwards
+			 if ( animations[anim].firstFrame == endFrame )
+			 {
+				if ( animations[anim].numFrames + animations[anim].firstFrame == startFrame )
+				{
+					//Com_Printf( "valid reverse anim: %s\n", animTable[anim].name );
+					return anim;
+				}
+			 }
+		}
+		else
+		{//playing forwards
+			if ( animations[anim].firstFrame == startFrame )
+			{//This anim starts on this frame
+				if ( animations[anim].firstFrame + animations[anim].numFrames == endFrame )
+				{//This anim ends on this frame
+					//Com_Printf( "valid forward anim: %s\n", animTable[anim].name );
+					return anim;
+				}
+			}
+		}
+		//else, must not be this anim!
+	}
+
+	//Not in ANY anim?  SHOULD NEVER HAPPEN
+	Com_Printf( "invalid anim range %d to %d, speed %4.2f\n", startFrame, endFrame, animSpeed );
+	return -1;
+}
+/*
+-------------------------
+PM_TorsoAnimForFrame
+Returns animNumber for current frame
+-------------------------
+*/
+int PM_TorsoAnimForFrame( gentity_t *ent, int torsoFrame )
+{
+	//Must be a valid client
+	if ( ent->client == NULL )
+		return -1;
+
+	//Must have a file index entry
+	if( ValidAnimFileIndex( ent->client->clientInfo.animFileIndex ) == qfalse )
+		return -1;
+
+	animation_t *animations = level.knownAnimFileSets[ent->client->clientInfo.animFileIndex].animations;
+	int	glaIndex = gi.G2API_GetAnimIndex(&(ent->ghoul2[0]));
+
+	for ( int animation = 0; animation < LEGS_TURN1; animation++ )	//first legs only anim
+	{
+		if ( animations[animation].glaIndex != glaIndex )
+		{
+			continue;
+		}
+
+		if ( animations[animation].firstFrame > torsoFrame )
+		{//This anim starts after this frame
+			continue;
+		}
+
+		if ( animations[animation].firstFrame + animations[animation].numFrames < torsoFrame )
+		{//This anim ends before this frame
+			continue;
+		}
+		//else, must be in this anim!
+		return animation;
+	}
+
+	//Not in ANY torsoAnim?  SHOULD NEVER HAPPEN
+//	assert(0);
+	return -1;
+}
+
+qboolean PM_FinishedCurrentLegsAnim( gentity_t *self )
+{
+	int		junk, curFrame;
+	float	currentFrame, animSpeed;
+
+	if ( !self->client )
+	{
+		return qtrue;
+	}
+
+	gi.G2API_GetBoneAnimIndex( &self->ghoul2[self->playerModel], self->rootBone, (cg.time?cg.time:level.time), &currentFrame, &junk, &junk, &junk, &animSpeed, NULL );
+	curFrame = floor( currentFrame );
+
+	int				legsAnim	= self->client->ps.legsAnim;
+	animation_t		*animations	= level.knownAnimFileSets[self->client->clientInfo.animFileIndex].animations;
+
+	if ( curFrame >= animations[legsAnim].firstFrame + (animations[legsAnim].numFrames - 2) )
+	{
+		return qtrue;
+	}
+
+	return qfalse;
+}
+
+/*
+-------------------------
+PM_HasAnimation
+-------------------------
+*/
+
+qboolean PM_HasAnimation( gentity_t *ent, int animation )
+{
+	//Must be a valid client
+	if ( !ent || ent->client == NULL )
+		return qfalse;
+
+	//must be a valid anim number
+	if ( animation < 0 || animation >= MAX_ANIMATIONS )
+	{
+		return qfalse;
+	}
+	//Must have a file index entry
+	if( ValidAnimFileIndex( ent->client->clientInfo.animFileIndex ) == qfalse )
+		return qfalse;
+
+	animation_t *animations = level.knownAnimFileSets[ent->client->clientInfo.animFileIndex].animations;
+
+	//No frames, no anim
+	if ( animations[animation].numFrames == 0 )
+		return qfalse;
+
+	//Has the sequence
+	return qtrue;
+}
+
+int PM_PickAnim( gentity_t *self, int minAnim, int maxAnim )
+{
+	int anim;
+	int count = 0;
+
+	if ( !self )
+	{
+		return Q_irand(minAnim, maxAnim);
+	}
+
+	do
+	{
+		anim = Q_irand(minAnim, maxAnim);
+		count++;
+	}
+	while ( !PM_HasAnimation( self, anim ) && count < 1000 );
+
+	return anim;
+}
+
+/*
+-------------------------
+PM_AnimLength
+-------------------------
+*/
+
+int PM_AnimLength( int index, animNumber_t anim )
+{
+	if ( ValidAnimFileIndex( index ) == false )
+		return 0;
+
+	return level.knownAnimFileSets[index].animations[anim].numFrames * abs(level.knownAnimFileSets[index].animations[anim].frameLerp);
+}
+
+/*
+-------------------------
+PM_SetLegsAnimTimer
+-------------------------
+*/
+
+void PM_SetLegsAnimTimer( gentity_t *ent, int *legsAnimTimer, int time )
+{
+	*legsAnimTimer = time;
+
+	if ( *legsAnimTimer < 0 && time != -1 )
+	{//Cap timer to 0 if was counting down, but let it be -1 if that was intentional
+		*legsAnimTimer = 0;
+	}
+
+	if ( !*legsAnimTimer && ent && Q3_TaskIDPending( ent, TID_ANIM_LOWER ) )
+	{//Waiting for legsAnimTimer to complete, and it just got set to zero
+		if ( !Q3_TaskIDPending( ent, TID_ANIM_BOTH) )
+		{//Not waiting for top
+			Q3_TaskIDComplete( ent, TID_ANIM_LOWER );
+		}
+		else 
+		{//Waiting for both to finish before complete 
+			Q3_TaskIDClear( &ent->taskID[TID_ANIM_LOWER] );//Bottom is done, regardless
+			if ( !Q3_TaskIDPending( ent, TID_ANIM_UPPER) )
+			{//top is done and we're done
+				Q3_TaskIDComplete( ent, TID_ANIM_BOTH );
+			}
+		}
+	}
+}
+
+/*
+-------------------------
+PM_SetTorsoAnimTimer
+-------------------------
+*/
+
+void PM_SetTorsoAnimTimer( gentity_t *ent, int *torsoAnimTimer, int time )
+{
+	*torsoAnimTimer = time;
+
+	if ( *torsoAnimTimer < 0 && time != -1 )
+	{//Cap timer to 0 if was counting down, but let it be -1 if that was intentional
+		*torsoAnimTimer = 0;
+	}
+
+	if ( !*torsoAnimTimer && ent && Q3_TaskIDPending( ent, TID_ANIM_UPPER ) )
+	{//Waiting for torsoAnimTimer to complete, and it just got set to zero
+		if ( !Q3_TaskIDPending( ent, TID_ANIM_BOTH) )
+		{//Not waiting for bottom
+			Q3_TaskIDComplete( ent, TID_ANIM_UPPER );
+		}
+		else 
+		{//Waiting for both to finish before complete 
+			Q3_TaskIDClear( &ent->taskID[TID_ANIM_UPPER] );//Top is done, regardless
+			if ( !Q3_TaskIDPending( ent, TID_ANIM_LOWER) )
+			{//lower is done and we're done
+				Q3_TaskIDComplete( ent, TID_ANIM_BOTH );
+			}
+		}
+	}
+}
+
+extern qboolean PM_SpinningSaberAnim( int anim );
+extern float saberAnimSpeedMod[NUM_FORCE_POWER_LEVELS];
+void PM_SaberStartTransAnim( int saberAnimLevel, int anim, float *animSpeed, gentity_t *gent )
+{
+	if ( g_saberAnimSpeed->value != 1.0f )
+	{
+		if ( anim >= BOTH_A1_T__B_ && anim <= BOTH_CROUCHATTACKBACK1 )
+		{
+			*animSpeed *= g_saberAnimSpeed->value;
+		}
+	}
+	if ( gent
+		&& gent->client
+		&& gent->client->ps.stats[STAT_WEAPONS]&(1<<WP_SCEPTER)
+		&& gent->client->ps.dualSabers 
+		&& saberAnimLevel == SS_DUAL
+		&& gent->weaponModel[1] )
+	{//using a scepter and dual style, slow down anims
+		if ( anim >= BOTH_A1_T__B_ && anim <= BOTH_H7_S7_BR )
+		{
+			*animSpeed *= 0.75;
+		}
+	}
+	if ( gent && gent->client && gent->client->ps.forceRageRecoveryTime > level.time )
+	{//rage recovery
+		if ( anim >= BOTH_A1_T__B_ && anim <= BOTH_H1_S1_BR )
+		{//animate slower
+			*animSpeed *= 0.75;
+		}
+	}
+	else if ( gent && gent->NPC && gent->NPC->rank == RANK_CIVILIAN )
+	{//grunt reborn
+		if ( anim >= BOTH_A1_T__B_ && anim <= BOTH_R1_TR_S1 )
+		{//his fast attacks are slower
+			if ( !PM_SpinningSaberAnim( anim ) )
+			{
+				*animSpeed *= 0.75;
+			}
+			return;
+		}
+	}
+	else if ( gent && gent->client )
+	{
+		if ( gent->client->ps.saber[0].type == SABER_LANCE || gent->client->ps.saber[0].type == SABER_TRIDENT )
+		{//FIXME: hack for now - these use the fast anims, but slowed down.  Should have own style
+			if ( anim >= BOTH_A1_T__B_ && anim <= BOTH_R1_TR_S1 )
+			{//his fast attacks are slower
+				if ( !PM_SpinningSaberAnim( anim ) )
+				{
+					*animSpeed *= 0.75;
+				}
+				return;
+			}
+		}
+	}
+
+	if ( ( anim >= BOTH_T1_BR__R && 
+		anim <= BOTH_T1_BL_TL ) ||
+		( anim >= BOTH_T3_BR__R && 
+		anim <= BOTH_T3_BL_TL ) ||
+		( anim >= BOTH_T5_BR__R && 
+		anim <= BOTH_T5_BL_TL ) )
+	{
+		if ( saberAnimLevel == FORCE_LEVEL_1 || saberAnimLevel == FORCE_LEVEL_5 )
+		{//FIXME: should not be necc for FORCE_LEVEL_1's
+			*animSpeed *= 1.5;
+		}
+		else if ( saberAnimLevel == FORCE_LEVEL_3 )
+		{
+			*animSpeed *= 0.75;
+		}
+	}
+}
+/*
+void PM_SaberStartTransAnim( int anim, int entNum, int saberOffenseLevel, float *animSpeed )
+{
+	//check starts
+	if ( ( anim >= BOTH_S1_S1_T_ && 
+		anim <= BOTH_S1_S1_TR ) ||
+		( anim >= BOTH_S1_S1_T_ && 
+			anim <= BOTH_S1_S1_TR ) ||
+		( anim >= BOTH_S3_S1_T_ && 
+			anim <= BOTH_S3_S1_TR ) )
+	{
+		if ( entNum == 0 )
+		{
+			*animSpeed *= saberAnimSpeedMod[FORCE_LEVEL_3];
+		}
+		else
+		{
+			*animSpeed *= saberAnimSpeedMod[saberOffenseLevel];
+		}
+	}
+	//Check transitions
+	else if ( PM_SpinningSaberAnim( anim ) )
+	{//spins stay normal speed
+		return;
+	}
+	else if ( ( anim >= BOTH_T1_BR__R && 
+			anim <= BOTH_T1_BL_TL ) ||
+			( anim >= BOTH_T2_BR__R && 
+			anim <= BOTH_T2_BL_TL ) ||
+			( anim >= BOTH_T3_BR__R && 
+			anim <= BOTH_T3_BL_TL ) )
+	{//slow down the transitions
+		if ( entNum == 0 && saberOffenseLevel <= FORCE_LEVEL_2 )
+		{
+			*animSpeed *= saberAnimSpeedMod[saberOffenseLevel];
+		}
+		else
+		{
+			*animSpeed *= saberAnimSpeedMod[saberOffenseLevel]/2.0f;
+		}
+	}
+
+	return;
+}
+*/
+extern qboolean		player_locked;
+extern qboolean		MatrixMode;
+float PM_GetTimeScaleMod( gentity_t *gent )
+{
+	if ( g_timescale->value )
+	{
+		if ( !MatrixMode
+			&& gent->client->ps.legsAnim != BOTH_FORCELONGLEAP_START
+			&& gent->client->ps.legsAnim != BOTH_FORCELONGLEAP_ATTACK
+			&& gent->client->ps.legsAnim != BOTH_FORCELONGLEAP_LAND )
+		{
+			if ( gent && gent->s.clientNum == 0 && !player_locked && gent->client->ps.forcePowersActive&(1<<FP_SPEED) )
+			{
+				return (1.0 / g_timescale->value);
+			}
+			else if ( gent && gent->client && gent->client->ps.forcePowersActive&(1<<FP_SPEED) )
+			{
+				return (1.0 / g_timescale->value);
+			}
+		}
+	}
+	return 1.0f;
+}
+
+static inline qboolean PM_IsHumanoid( CGhoul2Info *ghlInfo )
+{
+	char	*GLAName;
+	GLAName = gi.G2API_GetGLAName( ghlInfo );
+	assert(GLAName);
+
+	if ( !Q_stricmp( "models/players/_humanoid/_humanoid", GLAName ) )
+	{
+		return qtrue;
+	}
+
+	return qfalse;
+}
+
+/*
+-------------------------
+PM_SetAnimFinal
+-------------------------
+*/
+#define G2_DEBUG_TIMING (0)
+void PM_SetAnimFinal(int *torsoAnim,int *legsAnim,
+					 int setAnimParts,int anim,int setAnimFlags,
+					 int *torsoAnimTimer,int *legsAnimTimer,
+					 gentity_t *gent,int blendTime)		// default blendTime=350
+{
+
+// BASIC SETUP AND SAFETY CHECKING
+//=================================
+
+	// If It Is A Busted Entity, Don't Do Anything Here.
+	//---------------------------------------------------
+	if (!gent || !gent->client)
+	{
+		return;
+	}
+
+	// Make Sure This Character Has Such An Anim And A Model
+	//-------------------------------------------------------
+	if (anim<0 || anim>=MAX_ANIMATIONS || !ValidAnimFileIndex(gent->client->clientInfo.animFileIndex))
+	{
+		#ifndef FINAL_BUILD
+ 		if (g_AnimWarning->integer)
+		{
+			if (anim<0 || anim>=MAX_ANIMATIONS)
+			{
+				gi.Printf(S_COLOR_RED"PM_SetAnimFinal: Invalid Anim Index (%d)!\n", anim);
+			}
+			else
+			{
+				gi.Printf(S_COLOR_RED"PM_SetAnimFinal: Invalid Anim File Index (%d)!\n", gent->client->clientInfo.animFileIndex);
+			}
+		}
+		#endif
+		return;
+	}
+
+
+	// Get Global Time Properties
+	//----------------------------
+	float			timeScaleMod  = PM_GetTimeScaleMod( gent );
+	const int		actualTime	  = (cg.time?cg.time:level.time);
+	const animation_t*	animations	  = level.knownAnimFileSets[gent->client->clientInfo.animFileIndex].animations;
+	const animation_t&	curAnim		  = animations[anim];
+
+	// Make Sure This Character Has Such An Anim And A Model
+	//-------------------------------------------------------
+	if (animations[anim].numFrames==0)
+	{
+		static int	LastAnimWarningNum=0;
+	#ifndef FINAL_BUILD
+		if (LastAnimWarningNum!=anim)
+		{
+			if ((cg_debugAnim.integer==3)	||												// 3 = do everyone
+ 				(cg_debugAnim.integer==1 && gent->s.number==0) ||							// 1 = only the player
+				(cg_debugAnim.integer==2 && gent->s.number!=0) ||							// 2 = only everyone else
+				(cg_debugAnim.integer==4 && gent->s.number!=cg_debugAnimTarget.integer) 	// 4 = specific entnum
+				)	
+			{
+				gi.Printf(S_COLOR_RED"PM_SetAnimFinal: Anim %s does not exist in this model (%s)!\n", animTable[anim].name, gent->NPC_type );
+			}
+		}
+		LastAnimWarningNum = anim;
+	#endif
+		return;
+	}
+
+	// If It's Not A Ghoul 2 Model, Just Remember The Anims And Stop, Because Everything Beyond This Is Ghoul2
+	//---------------------------------------------------------------------------------------------------------
+	if (!gi.G2API_HaveWeGhoul2Models(gent->ghoul2))
+	{
+		if (setAnimParts&SETANIM_TORSO)
+		{
+			(*torsoAnim) = anim;
+		}
+		if (setAnimParts&SETANIM_LEGS)
+		{
+			(*legsAnim) = anim;
+		}
+		return;
+	}
+
+
+	// Lower Offensive Skill Slows Down The Saber Start Attack Animations
+	//--------------------------------------------------------------------
+	PM_SaberStartTransAnim( gent->client->ps.saberAnimLevel, anim, &timeScaleMod, gent );
+
+
+
+// SETUP VALUES FOR INCOMMING ANIMATION
+//======================================
+	const bool	animFootMove  = (PM_WalkingAnim(anim) || PM_RunningAnim(anim) || anim==BOTH_CROUCH1WALK || anim==BOTH_CROUCH1WALKBACK);
+	const bool	animHoldless  = (setAnimFlags&SETANIM_FLAG_HOLDLESS)!=0;
+	const bool	animHold	  = (setAnimFlags&SETANIM_FLAG_HOLD)!=0;
+	const bool	animRestart	  = (setAnimFlags&SETANIM_FLAG_RESTART)!=0;
+	const bool	animOverride  = (setAnimFlags&SETANIM_FLAG_OVERRIDE)!=0;
+	const bool	animSync	  = (g_synchSplitAnims->integer!=0 && !animRestart);
+	float	animCurrent	  = (-1.0f);
+	float	animSpeed	  = (50.0f / curAnim.frameLerp * timeScaleMod); // animSpeed is 1.0 if the frameLerp (ms/frame) is 50 (20 fps).
+	const float	animFPS		  = (fabsf(curAnim.frameLerp));
+	const int		animDurMSec	  = (int)(((curAnim.numFrames - 1) * animFPS) / timeScaleMod);
+	const int		animHoldMSec  = ((animHoldless && timeScaleMod==1.0f)?((animDurMSec>1)?(animDurMSec-1):(animFPS)):(animDurMSec));
+	int		animFlags	  = (curAnim.loopFrames!=-1)?(BONE_ANIM_OVERRIDE_LOOP):(BONE_ANIM_OVERRIDE_FREEZE);
+	int		animStart	  = (curAnim.firstFrame);
+	int		animEnd		  = (curAnim.firstFrame)+(animations[anim].numFrames);
+
+	// If We Have A Blend Timer, Add The Blend Flag
+	//----------------------------------------------
+	if (blendTime > 0)
+	{
+		animFlags |= BONE_ANIM_BLEND;
+	}
+
+	// If Animation Is Going Backwards, Swap Last And First Frames
+	//-------------------------------------------------------------
+	if (animSpeed<0.0f)
+	{
+//	#ifndef FINAL_BUILD
+	#if 0
+		if (g_AnimWarning->integer==1)
+		{
+			if (animFlags&BONE_ANIM_OVERRIDE_LOOP)
+			{
+				gi.Printf(S_COLOR_YELLOW"PM_SetAnimFinal: WARNING: Anim (%s) looping backwards!\n", animTable[anim].name);
+			}
+		}
+	#endif
+
+		int temp	= animEnd;
+		animEnd		= animStart;
+		animStart	= temp;
+		blendTime	= 0;
+	}
+
+	// If The Animation Is Walking Or Running, Attempt To Scale The Playback Speed To Match
+	//--------------------------------------------------------------------------------------
+	if (g_noFootSlide->integer 
+		&& animFootMove 
+		&& !(animSpeed<0.0f)
+		//FIXME: either read speed from animation.cfg or only do this for NPCs
+		//			for whom we've specifically determined the proper numbers!
+		&& gent->client->NPC_class != CLASS_HOWLER
+		&& gent->client->NPC_class != CLASS_WAMPA
+		&& gent->client->NPC_class != CLASS_GONK
+		&& gent->client->NPC_class != CLASS_HOWLER
+		&& gent->client->NPC_class != CLASS_MOUSE
+		&& gent->client->NPC_class != CLASS_PROBE
+		&& gent->client->NPC_class != CLASS_PROTOCOL
+		&& gent->client->NPC_class != CLASS_R2D2
+		&& gent->client->NPC_class != CLASS_R5D2
+		&& gent->client->NPC_class != CLASS_SEEKER)
+	{
+		bool	Walking = !!PM_WalkingAnim(anim);
+		bool	HasDual = (gent->client->ps.saberAnimLevel==SS_DUAL);
+		bool	HasStaff = (gent->client->ps.saberAnimLevel==SS_STAFF);
+		float	moveSpeedOfAnim  = 150.0f;//g_noFootSlideRunScale->value;
+
+		if (anim==BOTH_CROUCH1WALK || anim==BOTH_CROUCH1WALKBACK)
+		{
+			moveSpeedOfAnim = 75.0f;
+		}
+		else
+		{
+			if (gent->client->NPC_class == CLASS_HAZARD_TROOPER)
+			{
+				moveSpeedOfAnim = 50.0f;
+			}
+			else if (gent->client->NPC_class == CLASS_RANCOR)
+			{
+				moveSpeedOfAnim = 173.0f;
+			}
+			else
+			{
+				if (Walking)
+				{
+					if (HasDual || HasStaff)
+					{
+						moveSpeedOfAnim = 100.0f;
+					}
+					else
+					{
+						moveSpeedOfAnim = 50.0f;// g_noFootSlideWalkScale->value;
+					}
+				}
+				else
+				{
+					if (HasStaff)
+					{
+						moveSpeedOfAnim = 250.0f;
+					}
+					else
+					{
+						moveSpeedOfAnim = 150.0f;
+					}
+				}
+			}
+		}
+
+
+
+
+
+
+		animSpeed *= (gent->resultspeed/moveSpeedOfAnim);
+		if (animSpeed<0.01f)
+		{
+			animSpeed = 0.01f;
+		}
+
+		// Make Sure Not To Play Too Fast An Anim
+		//----------------------------------------
+		float	maxPlaybackSpeed = (1.5f * timeScaleMod);
+		if (animSpeed>maxPlaybackSpeed)
+		{
+			animSpeed = maxPlaybackSpeed;
+		}
+	}
+
+
+// GET VALUES FOR EXISTING BODY ANIMATION
+//==========================================
+	float	bodySpeed	  = 0.0f;
+	float	bodyCurrent	  = 0.0f;
+	int		bodyStart	  = 0;
+	int		bodyEnd		  = 0;
+	int		bodyFlags	  = 0;
+	int		bodyAnim	  = (*legsAnim);
+	int		bodyBone	  = (gent->rootBone);
+	bool	bodyTimerOn	  = ((*legsAnimTimer>0) || (*legsAnimTimer)==-1);
+	bool	bodyPlay	  = ((setAnimParts&SETANIM_LEGS) && (bodyBone!=-1) && (animOverride || !bodyTimerOn));
+	bool	bodyAnimating = !!gi.G2API_GetBoneAnimIndex(&gent->ghoul2[gent->playerModel], bodyBone, actualTime, &bodyCurrent, &bodyStart, &bodyEnd, &bodyFlags, &bodySpeed, NULL);
+	bool	bodyOnAnimNow = (bodyAnimating && bodyAnim==anim && bodyStart==animStart && bodyEnd==animEnd);
+	bool	bodyMatchTorsFrame = false;
+
+
+// GET VALUES FOR EXISTING TORSO ANIMATION
+//===========================================
+	float	torsSpeed	  = 0.0f;
+	float	torsCurrent	  = 0.0f;
+	int		torsStart	  = 0;
+	int		torsEnd		  = 0;
+	int		torsFlags	  = 0;
+	int		torsAnim	  = (*torsoAnim);
+	int		torsBone	  = (gent->lowerLumbarBone);
+	bool	torsTimerOn	  = ((*torsoAnimTimer)>0 || (*torsoAnimTimer)==-1);
+	bool	torsPlay	  = (gent->client->NPC_class!=CLASS_RANCOR && (setAnimParts&SETANIM_TORSO) && (torsBone!=-1) && (animOverride || !torsTimerOn));
+	bool	torsAnimating = !!gi.G2API_GetBoneAnimIndex(&gent->ghoul2[gent->playerModel], torsBone, actualTime, &torsCurrent, &torsStart, &torsEnd, &torsFlags, &torsSpeed, NULL);
+	bool	torsOnAnimNow = (torsAnimating && torsAnim==anim && torsStart==animStart && torsEnd==animEnd);
+	bool	torsMatchBodyFrame = false;
+
+
+// APPLY SYNC TO TORSO
+//=====================
+ 	if (animSync && torsPlay && !bodyPlay && bodyOnAnimNow && (!torsOnAnimNow || torsCurrent!=bodyCurrent))
+	{
+		torsMatchBodyFrame = true;
+		animCurrent		=  bodyCurrent;
+	}
+ 	if (animSync && bodyPlay && !torsPlay && torsOnAnimNow && (!bodyOnAnimNow || bodyCurrent!=torsCurrent))
+	{
+		bodyMatchTorsFrame = true;
+		animCurrent		=  torsCurrent;
+	}
+
+	// If Already Doing These Exact Parameters, Then Don't Play
+	//----------------------------------------------------------
+	if (!animRestart)
+	{
+		torsPlay &= !(torsOnAnimNow && torsSpeed==animSpeed && !torsMatchBodyFrame);
+		bodyPlay &= !(bodyOnAnimNow && bodySpeed==animSpeed && !bodyMatchTorsFrame);
+	}
+
+#ifndef FINAL_BUILD
+	if ((cg_debugAnim.integer==3)	||												// 3 = do everyone
+		(cg_debugAnim.integer==1 && gent->s.number==0) ||							// 1 = only the player
+		(cg_debugAnim.integer==2 && gent->s.number!=0) ||							// 2 = only everyone else
+		(cg_debugAnim.integer==4 && gent->s.number!=cg_debugAnimTarget.integer) 	// 4 = specific entnum
+		)	
+	{
+		if (bodyPlay || torsPlay)
+		{
+			char*	entName = gent->targetname;
+			char*	location;
+
+			// Select Entity Name
+			//--------------------
+			if (!entName || !entName[0])
+			{
+				entName = gent->NPC_targetname;
+			}
+			if (!entName || !entName[0])
+			{
+				entName = gent->NPC_type;
+			}
+			if (!entName || !entName[0])
+			{
+				entName = gent->classname;
+			}
+			if (!entName || !entName[0])
+			{
+				entName = "UNKNOWN";
+			}
+
+			// Select Play Location
+			//----------------------
+			if (bodyPlay && torsPlay)
+			{
+				location = "BOTH ";
+			}
+			else if (bodyPlay)
+			{
+				location = "LEGS ";
+			}
+			else
+			{
+				location = "TORSO";
+			}
+
+			// Print It!
+			//-----------
+	 		Com_Printf("[%10d] ent[%3d-%18s] %s anim[%3d] - %s\n", 
+	 			actualTime, 
+				gent->s.number, 
+				entName, 
+				location,
+				anim, 
+				animTable[anim].name );
+		}
+	}
+#endif
+
+
+// PLAY ON THE TORSO
+//========================
+	if (torsPlay)
+	{
+		*torsoAnim = anim;
+		float oldAnimCurrent = animCurrent; 
+		if (animCurrent!=bodyCurrent && torsOnAnimNow && !animRestart && !torsMatchBodyFrame)
+		{
+			animCurrent = torsCurrent;
+		}
+
+		gi.G2API_SetAnimIndex(&gent->ghoul2[gent->playerModel], curAnim.glaIndex);
+		gi.G2API_SetBoneAnimIndex(&gent->ghoul2[gent->playerModel], torsBone, 
+			animStart, 
+			animEnd, 
+			(torsOnAnimNow && !animRestart)?(animFlags&~BONE_ANIM_BLEND):(animFlags), 
+			animSpeed, 
+			actualTime, 
+			animCurrent, 
+			blendTime);
+
+		if (gent->motionBone!=-1)
+		{
+			gi.G2API_SetBoneAnimIndex(&gent->ghoul2[gent->playerModel], gent->motionBone, 
+				animStart, 
+				animEnd, 
+				(torsOnAnimNow && !animRestart)?(animFlags&~BONE_ANIM_BLEND):(animFlags), 
+				animSpeed, 
+				actualTime, 
+				animCurrent, 
+				blendTime);
+		}
+
+		animCurrent = oldAnimCurrent;
+
+		// If This Animation Is To Be Locked And Held, Calculate The Duration And Set The Timer
+		//--------------------------------------------------------------------------------------
+		if (animHold || animHoldless)
+		{
+			PM_SetTorsoAnimTimer(gent, torsoAnimTimer, animHoldMSec);
+		}
+	}
+
+// PLAY ON THE WHOLE BODY 
+//========================
+	if (bodyPlay)
+	{
+		*legsAnim = anim;
+
+		if (bodyOnAnimNow && !animRestart && !bodyMatchTorsFrame)
+		{
+			animCurrent = bodyCurrent;
+		}
+
+		gi.G2API_SetAnimIndex(&gent->ghoul2[gent->playerModel], curAnim.glaIndex);
+		gi.G2API_SetBoneAnimIndex(&gent->ghoul2[gent->playerModel], bodyBone, 
+			animStart, 
+			animEnd, 
+			(bodyOnAnimNow && !animRestart)?(animFlags&~BONE_ANIM_BLEND):(animFlags), 
+			animSpeed, 
+			actualTime, 
+			animCurrent, 
+			blendTime);
+
+		// If This Animation Is To Be Locked And Held, Calculate The Duration And Set The Timer
+		//--------------------------------------------------------------------------------------
+		if (animHold || animHoldless)
+		{
+			PM_SetLegsAnimTimer(gent, legsAnimTimer, animHoldMSec);
+		}
+	}
+
+
+
+
+
+// PRINT SOME DEBUG TEXT OF EXISTING VALUES
+//==========================================
+	if (false)
+	{
+		gi.Printf("PLAYANIM: (%3d) Speed(%4.2f) ", anim, animSpeed);
+		if (bodyAnimating)
+		{
+			gi.Printf("BODY: (%4.2f) (%4.2f) ", bodyCurrent,  bodySpeed);
+		}
+		else
+		{
+			gi.Printf("                      ");
+		}
+		if (torsAnimating)
+		{
+			gi.Printf("TORS: (%4.2f) (%4.2f)\n", torsCurrent,  torsSpeed);
+		}
+		else
+		{
+			gi.Printf("\n");
+		}
+	}
+}
+
+
+
+void PM_SetAnim(pmove_t	*pm,int setAnimParts,int anim,int setAnimFlags, int blendTime)
+{	// FIXME : once torsoAnim and legsAnim are in the same structure for NPC and Players
+	// rename PM_SetAnimFinal to PM_SetAnim and have both NPC and Players call PM_SetAnim
+
+	if ( pm->ps->pm_type >= PM_DEAD ) 
+	{//FIXME: sometimes we'll want to set anims when your dead... twitches, impacts, etc.
+		return;
+	}
+
+	if ( pm->gent == NULL ) 
+	{
+		return;
+	}
+
+	if ( !pm->gent || pm->gent->health > 0 )
+	{//don't lock anims if the guy is dead
+		if ( pm->ps->torsoAnimTimer
+			&& PM_LockedAnim( pm->ps->torsoAnim ) 
+			&& !PM_LockedAnim( anim ) )
+		{//nothing can override these special anims
+			setAnimParts &= ~SETANIM_TORSO;
+		}
+
+		if ( pm->ps->legsAnimTimer
+			&& PM_LockedAnim( pm->ps->legsAnim ) 
+			&& !PM_LockedAnim( anim ) )
+		{//nothing can override these special anims
+			setAnimParts &= ~SETANIM_LEGS;
+		}
+	}
+
+	if ( !setAnimParts )
+	{
+		return;
+	}
+
+	if (setAnimFlags&SETANIM_FLAG_OVERRIDE)
+	{
+//		pm->ps->animationTimer = 0;
+		
+		if (setAnimParts & SETANIM_TORSO)
+		{
+			if( (setAnimFlags & SETANIM_FLAG_RESTART) || pm->ps->torsoAnim != anim )
+			{
+				PM_SetTorsoAnimTimer( pm->gent, &pm->ps->torsoAnimTimer, 0 );
+			}
+		}
+		if (setAnimParts & SETANIM_LEGS)
+		{
+			if( (setAnimFlags & SETANIM_FLAG_RESTART) || pm->ps->legsAnim != anim )
+			{
+				PM_SetLegsAnimTimer( pm->gent, &pm->ps->legsAnimTimer, 0 );
+			}
+		}
+	}
+
+	PM_SetAnimFinal(&pm->ps->torsoAnim,&pm->ps->legsAnim,setAnimParts,anim,setAnimFlags,&pm->ps->torsoAnimTimer,&pm->ps->legsAnimTimer,&g_entities[pm->ps->clientNum],blendTime);//was pm->gent
+}
+
+bool TorsoAgainstWindTest( gentity_t* ent )
+{
+	if (ent&&//valid ent
+		ent->client&&//a client
+		(ent->client->ps.weapon!=WP_SABER||ent->client->ps.saberMove==LS_READY)&&//either not holding a saber or the saber is in the ready pose
+		(ent->s.number<MAX_CLIENTS||G_ControlledByPlayer(ent)) &&
+		gi.WE_GetWindGusting(ent->currentOrigin) && 
+		gi.WE_IsOutside(ent->currentOrigin) )
+	{
+		if (Q_stricmp(level.mapname, "t2_wedge")!=0)
+		{
+			vec3_t	fwd;
+			vec3_t	windDir;
+			if (gi.WE_GetWindVector(windDir, ent->currentOrigin))
+			{
+				VectorScale(windDir, -1.0f, windDir);
+				AngleVectors(pm->gent->currentAngles, fwd, 0, 0);
+				if (DotProduct(fwd, windDir)>0.65f)
+				{
+					if (ent->client && ent->client->ps.torsoAnim!=BOTH_WIND)
+					{
+						NPC_SetAnim(ent, SETANIM_TORSO, BOTH_WIND, SETANIM_FLAG_NORMAL, 400);
+					}
+					return true;
+				}
+			}
+		}
+	}
+	return false;
+}
+
+/*
+-------------------------
+PM_TorsoAnimLightsaber
+-------------------------
+*/
+
+
+// Note that this function is intended to set the animation for the player, but 
+// only does idle-ish anims.  Anything that has a timer associated, such as attacks and blocks,
+// are set by PM_WeaponLightsaber()
+
+extern Vehicle_t *G_IsRidingVehicle( gentity_t *pEnt );
+extern qboolean PM_LandingAnim( int anim );
+extern qboolean PM_JumpingAnim( int anim );
+qboolean PM_InCartwheel( int anim );
+void PM_TorsoAnimLightsaber()
+{
+	// *********************************************************
+	// WEAPON_READY
+	// *********************************************************
+	if ( pm->ps->forcePowersActive&(1<<FP_GRIP) && pm->ps->forcePowerLevel[FP_GRIP] > FORCE_LEVEL_1 )
+	{//holding an enemy aloft with force-grip
+		return;
+	}
+
+	if ( pm->ps->forcePowersActive&(1<<FP_LIGHTNING) && pm->ps->forcePowerLevel[FP_LIGHTNING] > FORCE_LEVEL_1 )
+	{//lightning
+		return;
+	}
+
+	if ( pm->ps->forcePowersActive&(1<<FP_DRAIN) )
+	{//drain
+		return;
+	}
+
+	if ( pm->ps->saber[0].blade[0].active
+		&& pm->ps->saber[0].blade[0].length < 3 
+		&& !(pm->ps->saberEventFlags&SEF_HITWALL) 
+		&& pm->ps->weaponstate == WEAPON_RAISING )
+	{
+		if (!G_IsRidingVehicle(pm->gent))
+		{
+			PM_SetSaberMove(LS_DRAW);
+		}
+		return;
+	}
+	else if ( !pm->ps->SaberActive() && pm->ps->SaberLength() )
+	{
+		if (!G_IsRidingVehicle(pm->gent))
+		{
+			PM_SetSaberMove(LS_PUTAWAY);
+		}
+		return;
+	}
+
+	if (pm->ps->weaponTime > 0)
+	{	// weapon is already busy.
+		if ( pm->ps->torsoAnim == BOTH_TOSS1
+			|| pm->ps->torsoAnim == BOTH_TOSS2 )
+		{//in toss
+			if ( !pm->ps->torsoAnimTimer )
+			{//weird, get out of it, I guess
+				PM_SetAnim(pm,SETANIM_TORSO,pm->ps->legsAnim,SETANIM_FLAG_NORMAL);
+			}
+		}
+		return;
+	}
+
+	if (	pm->ps->weaponstate == WEAPON_READY || 
+			pm->ps->weaponstate == WEAPON_CHARGING ||
+			pm->ps->weaponstate == WEAPON_CHARGING_ALT )
+	{//ready
+		if ( pm->ps->weapon == WP_SABER && (pm->ps->SaberLength()) )
+		{//saber is on
+			// Select the proper idle Lightsaber attack move from the chart.
+			if (pm->ps->saberMove > LS_READY && pm->ps->saberMove < LS_MOVE_MAX)
+			{
+				PM_SetSaberMove(saberMoveData[pm->ps->saberMove].chain_idle);
+			}
+			else
+			{
+				if ( PM_JumpingAnim( pm->ps->legsAnim )
+					|| PM_LandingAnim( pm->ps->legsAnim )
+					|| PM_InCartwheel( pm->ps->legsAnim ) 
+					|| PM_FlippingAnim( pm->ps->legsAnim ))
+				{
+					PM_SetAnim(pm,SETANIM_TORSO,pm->ps->legsAnim,SETANIM_FLAG_NORMAL);
+				}
+				else
+				{
+					if ( (pm->ps->clientNum < MAX_CLIENTS||PM_ControlledByPlayer()) && pm->ps->torsoAnim == BOTH_BUTTON_HOLD )
+					{//using something
+						if ( !pm->ps->useTime )
+						{//stopped holding it, release
+							PM_SetAnim( pm, SETANIM_TORSO, BOTH_BUTTON_RELEASE, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+						}//else still holding, leave it as it is
+					}
+					else
+					{
+						if ( (PM_RunningAnim( pm->ps->legsAnim ) 
+								|| pm->ps->legsAnim == BOTH_WALK_STAFF 
+								|| pm->ps->legsAnim == BOTH_WALK_DUAL 
+								|| pm->ps->legsAnim == BOTH_WALKBACK_STAFF
+								|| pm->ps->legsAnim == BOTH_WALKBACK_DUAL )
+							&& pm->ps->saberBlockingTime < cg.time )
+						{//running w/1-handed weapon uses full-body anim
+							PM_SetAnim(pm,SETANIM_TORSO,pm->ps->legsAnim,SETANIM_FLAG_NORMAL);
+						}
+						else
+						{
+							PM_SetSaberMove(LS_READY);
+						}
+					}
+				}
+			}
+			/*
+			if ( PM_JumpingAnim( pm->ps->legsAnim )
+				|| PM_LandingAnim( pm->ps->legsAnim )
+				|| PM_InCartwheel( pm->ps->legsAnim ) 
+				|| PM_FlippingAnim( pm->ps->legsAnim ))
+			{//jumping, landing cartwheel, flipping
+				PM_SetAnim(pm,SETANIM_TORSO,pm->ps->legsAnim,SETANIM_FLAG_NORMAL);
+			}
+			else
+			{
+				PM_SetSaberMove( LS_READY );
+			}
+			*/
+		}
+		else if (TorsoAgainstWindTest(pm->gent))
+		{
+		}
+		else if( pm->ps->legsAnim == BOTH_RUN1 )
+		{
+			PM_SetAnim(pm,SETANIM_TORSO,BOTH_RUN1,SETANIM_FLAG_NORMAL);
+			pm->ps->saberMove = LS_READY;
+		}
+		else if( pm->ps->legsAnim == BOTH_RUN2 )//&& pm->ps->saberAnimLevel != SS_STAFF )
+		{
+			PM_SetAnim(pm,SETANIM_TORSO,BOTH_RUN2,SETANIM_FLAG_NORMAL);
+			pm->ps->saberMove = LS_READY;
+		}
+		else if( pm->ps->legsAnim == BOTH_RUN_STAFF )
+		{
+			PM_SetAnim(pm,SETANIM_TORSO,BOTH_RUN_STAFF,SETANIM_FLAG_NORMAL);
+			pm->ps->saberMove = LS_READY;
+		}
+		else if( pm->ps->legsAnim == BOTH_RUN_DUAL )
+		{
+			PM_SetAnim(pm,SETANIM_TORSO,BOTH_RUN_DUAL,SETANIM_FLAG_NORMAL);
+			pm->ps->saberMove = LS_READY;
+		}
+		else if( pm->ps->legsAnim == BOTH_WALK1 )
+		{
+			PM_SetAnim(pm,SETANIM_TORSO,BOTH_WALK1,SETANIM_FLAG_NORMAL);
+			pm->ps->saberMove = LS_READY;
+		}
+		else if( pm->ps->legsAnim == BOTH_WALK2 )
+		{
+			PM_SetAnim(pm,SETANIM_TORSO,BOTH_WALK2,SETANIM_FLAG_NORMAL);
+			pm->ps->saberMove = LS_READY;
+		}
+		else if( pm->ps->legsAnim == BOTH_WALK_STAFF )
+		{
+			PM_SetAnim(pm,SETANIM_TORSO,BOTH_WALK_STAFF,SETANIM_FLAG_NORMAL);
+			pm->ps->saberMove = LS_READY;
+		}
+		else if( pm->ps->legsAnim == BOTH_WALK_DUAL )
+		{
+			PM_SetAnim(pm,SETANIM_TORSO,BOTH_WALK_DUAL,SETANIM_FLAG_NORMAL);
+			pm->ps->saberMove = LS_READY;
+		}
+		else if( pm->ps->legsAnim == BOTH_CROUCH1IDLE && pm->ps->clientNum != 0 )//player falls through
+		{
+			//??? Why nothing?  What if you were running???
+			//PM_SetAnim(pm,SETANIM_TORSO,BOTH_CROUCH1IDLE,SETANIM_FLAG_NORMAL);
+			pm->ps->saberMove = LS_READY;
+		}
+		else if( pm->ps->legsAnim == BOTH_JUMP1 )
+		{
+			PM_SetAnim(pm,SETANIM_TORSO,BOTH_JUMP1,SETANIM_FLAG_NORMAL);
+			pm->ps->saberMove = LS_READY;
+		}
+		else
+		{//Used to default to both_stand1 which is an arms-down anim
+//				PM_SetAnim(pm,SETANIM_TORSO,BOTH_ATTACK1,SETANIM_FLAG_NORMAL);//TORSO_WEAPONREADY1
+			// Select the next proper pose for the lightsaber assuming that there are no attacks.
+			if (pm->ps->saberMove > LS_READY && pm->ps->saberMove < LS_MOVE_MAX)
+			{
+				PM_SetSaberMove(saberMoveData[pm->ps->saberMove].chain_idle);
+			}
+			else
+			{
+				if ( PM_JumpingAnim( pm->ps->legsAnim )
+					|| PM_LandingAnim( pm->ps->legsAnim )
+					|| PM_InCartwheel( pm->ps->legsAnim ) 
+					|| PM_FlippingAnim( pm->ps->legsAnim ))
+				{
+					PM_SetAnim(pm,SETANIM_TORSO,pm->ps->legsAnim,SETANIM_FLAG_NORMAL);
+				}
+				else
+				{
+					if ( (pm->ps->clientNum < MAX_CLIENTS||PM_ControlledByPlayer()) && pm->ps->torsoAnim == BOTH_BUTTON_HOLD )
+					{//using something
+						if ( !pm->ps->useTime )
+						{//stopped holding it, release
+							PM_SetAnim( pm, SETANIM_TORSO, BOTH_BUTTON_RELEASE, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+						}//else still holding, leave it as it is
+					}
+					else
+					{
+						PM_SetSaberMove(LS_READY);
+					}
+				}
+			}
+		}
+	}
+
+	// *********************************************************
+	// WEAPON_IDLE
+	// *********************************************************
+
+	else if ( pm->ps->weaponstate == WEAPON_IDLE )
+	{
+		if (TorsoAgainstWindTest(pm->gent))
+		{
+		}
+		else if( pm->ps->legsAnim == BOTH_GUARD_LOOKAROUND1 )
+		{
+			PM_SetAnim(pm,SETANIM_TORSO,BOTH_GUARD_LOOKAROUND1,SETANIM_FLAG_NORMAL);
+			pm->ps->saberMove = LS_READY;
+		}
+		else if( pm->ps->legsAnim == BOTH_GUARD_IDLE1 )
+		{
+			PM_SetAnim(pm,SETANIM_TORSO,BOTH_GUARD_IDLE1,SETANIM_FLAG_NORMAL);
+			pm->ps->saberMove = LS_READY;
+		}
+		else if( pm->ps->legsAnim == BOTH_STAND1IDLE1 
+			|| pm->ps->legsAnim == BOTH_STAND2IDLE1
+			|| pm->ps->legsAnim == BOTH_STAND2IDLE2
+			|| pm->ps->legsAnim == BOTH_STAND3IDLE1
+			|| pm->ps->legsAnim == BOTH_STAND5IDLE1 )
+		{
+			PM_SetAnim(pm,SETANIM_TORSO,pm->ps->legsAnim,SETANIM_FLAG_NORMAL);
+			pm->ps->saberMove = LS_READY;
+		}
+		else if( pm->ps->legsAnim == BOTH_STAND2TO4 )
+		{
+			PM_SetAnim(pm,SETANIM_TORSO,BOTH_STAND2TO4,SETANIM_FLAG_NORMAL);
+			pm->ps->saberMove = LS_READY;
+		}
+		else if( pm->ps->legsAnim == BOTH_STAND4TO2 )
+		{
+			PM_SetAnim(pm,SETANIM_TORSO,BOTH_STAND4TO2,SETANIM_FLAG_NORMAL);
+			pm->ps->saberMove = LS_READY;
+		}
+		else if( pm->ps->legsAnim == BOTH_STAND4 )
+		{
+			PM_SetAnim(pm,SETANIM_TORSO,BOTH_STAND4,SETANIM_FLAG_NORMAL);
+			pm->ps->saberMove = LS_READY;
+		}
+		else
+		{
+// This is now set in SetSaberMove.
+			// Idle for Lightsaber 
+			if ( pm->gent && pm->gent->client )
+			{
+//				pm->gent->client->saberTrail.inAction = qfalse;
+			}
+
+			qboolean saberInAir = qtrue;
+			if ( pm->ps->saberInFlight )
+			{//guiding saber
+				if ( PM_SaberInBrokenParry( pm->ps->saberMove ) || pm->ps->saberBlocked == BLOCKED_PARRY_BROKEN || PM_DodgeAnim( pm->ps->torsoAnim ) )
+				{//we're stuck in a broken parry
+					saberInAir = qfalse;
+				}
+				if ( pm->ps->saberEntityNum < ENTITYNUM_NONE && pm->ps->saberEntityNum > 0 )//player is 0
+				{//
+					if ( &g_entities[pm->ps->saberEntityNum] != NULL && g_entities[pm->ps->saberEntityNum].s.pos.trType == TR_STATIONARY )
+					{//fell to the ground and we're not trying to pull it back
+						saberInAir = qfalse;
+					}
+				}
+			}
+			if ( pm->ps->saberInFlight 
+				&& saberInAir 
+				&& (!pm->ps->dualSabers || !pm->ps->saber[1].Active()))
+			{
+				if ( !PM_ForceAnim( pm->ps->torsoAnim ) 
+					|| pm->ps->torsoAnimTimer < 300 )
+				{//don't interrupt a force power anim
+					if ( pm->ps->torsoAnim != BOTH_LOSE_SABER
+						|| !pm->ps->torsoAnimTimer )
+					{
+						PM_SetAnim( pm, SETANIM_TORSO,BOTH_SABERPULL,SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+					}
+				}
+			}
+			else
+			{//saber is on
+				// Idle for Lightsaber 
+				if ( pm->gent && pm->gent->client )
+				{
+					if ( !G_InCinematicSaberAnim( pm->gent ) )
+					{
+						pm->gent->client->ps.SaberDeactivateTrail( 0 );
+					}
+				}
+				// Idle for idle/ready Lightsaber
+//				PM_SetAnim(pm,SETANIM_TORSO,BOTH_ATTACK1,SETANIM_FLAG_NORMAL);//TORSO_WEAPONIDLE1
+				// Select the proper idle Lightsaber attack move from the chart.
+				if (pm->ps->saberMove > LS_READY && pm->ps->saberMove < LS_MOVE_MAX)
+				{
+					PM_SetSaberMove(saberMoveData[pm->ps->saberMove].chain_idle);
+				}
+				else
+				{
+					if ( PM_JumpingAnim( pm->ps->legsAnim )
+						|| PM_LandingAnim( pm->ps->legsAnim )
+						|| PM_InCartwheel( pm->ps->legsAnim ) 
+						|| PM_FlippingAnim( pm->ps->legsAnim ))
+					{
+						PM_SetAnim(pm,SETANIM_TORSO,pm->ps->legsAnim,SETANIM_FLAG_NORMAL);
+					}
+					else
+					{
+						if ( (pm->ps->clientNum < MAX_CLIENTS||PM_ControlledByPlayer()) && pm->ps->torsoAnim == BOTH_BUTTON_HOLD )
+						{//using something
+							if ( !pm->ps->useTime )
+							{//stopped holding it, release
+								PM_SetAnim( pm, SETANIM_TORSO, BOTH_BUTTON_RELEASE, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+							}//else still holding, leave it as it is
+						}
+						else
+						{
+							if ( (PM_RunningAnim( pm->ps->legsAnim ) 
+								|| pm->ps->legsAnim == BOTH_WALK_STAFF 
+								|| pm->ps->legsAnim == BOTH_WALK_DUAL 
+								|| pm->ps->legsAnim == BOTH_WALKBACK_STAFF 
+								|| pm->ps->legsAnim == BOTH_WALKBACK_DUAL )
+								&& pm->ps->saberBlockingTime < cg.time )
+							{//running w/1-handed weapon uses full-body anim
+								int setFlags = SETANIM_FLAG_NORMAL;
+								if ( PM_LandingAnim( pm->ps->torsoAnim ) )
+								{
+									setFlags = SETANIM_FLAG_OVERRIDE;
+								}
+								PM_SetAnim(pm,SETANIM_TORSO,pm->ps->legsAnim,setFlags);
+							}
+							else
+							{
+								PM_SetSaberMove(LS_READY);
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+
+
+
+/*
+-------------------------
+PM_TorsoAnimation
+-------------------------
+*/
+
+void PM_TorsoAnimation( void ) 
+{//FIXME: Write a much smarter and more appropriate anim picking routine logic...
+//	int	oldAnim;
+	if ( PM_InKnockDown( pm->ps ) || PM_InRoll( pm->ps ))
+	{//in knockdown
+		return;
+	}
+
+	if ( (pm->ps->eFlags&EF_HELD_BY_WAMPA) )
+	{
+		return;
+	}
+
+	if ( (pm->ps->eFlags&EF_FORCE_DRAINED) )
+	{//being drained
+		//PM_SetAnim( pm, SETANIM_TORSO, BOTH_HUGGEE1, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+		return;
+	}
+	if ( (pm->ps->forcePowersActive&(1<<FP_DRAIN)) 
+		&& pm->ps->forceDrainEntityNum < ENTITYNUM_WORLD )
+	{//draining
+		//PM_SetAnim( pm, SETANIM_TORSO, BOTH_HUGGER1, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+		return;
+	}
+
+	if( pm->gent && pm->gent->NPC && (pm->gent->NPC->scriptFlags & SCF_FORCED_MARCH) )
+	{
+		return;
+	}
+
+	if(pm->gent != NULL && pm->gent->client)
+	{
+		pm->gent->client->renderInfo.torsoFpsMod = 1.0f;
+	}
+
+	if ( pm->gent && pm->ps && pm->ps->eFlags & EF_LOCKED_TO_WEAPON )
+	{
+		if ( pm->gent->owner && pm->gent->owner->e_UseFunc == useF_emplaced_gun_use )//ugly way to tell, but...
+		{//full body
+			PM_SetAnim(pm,SETANIM_BOTH,BOTH_GUNSIT1,SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD);//SETANIM_FLAG_NORMAL
+		}
+		else
+		{//torso
+			PM_SetAnim(pm,SETANIM_TORSO,BOTH_GUNSIT1,SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD);//SETANIM_FLAG_NORMAL
+		}
+		return;
+	}
+/*	else if ( pm->gent && pm->gent->client && pm->gent->client->NPC_class == CLASS_VEHICLE && pm->ps->clientNum < MAX_CLIENTS && (m_pVehicleInfo[((CVehicleNPC *)pm->gent->NPC)->m_iVehicleTypeID].numHands == 2 || g_speederControlScheme->value == 2) )
+	{//can't look around
+		PM_SetAnim(pm,SETANIM_TORSO,m_pVehicleInfo[((CVehicleNPC *)pm->gent->NPC)->m_iVehicleTypeID].riderAnim,SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD);
+		return;
+	}*/
+
+	if ( pm->ps->taunting > level.time )
+	{
+		if ( pm->gent && pm->gent->client && pm->gent->client->NPC_class == CLASS_ALORA )
+		{
+			PM_SetAnim(pm,SETANIM_BOTH,BOTH_ALORA_TAUNT,SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD);//SETANIM_FLAG_NORMAL
+		}
+		else if ( pm->ps->weapon == WP_SABER && pm->ps->saberAnimLevel == SS_DUAL && PM_HasAnimation( pm->gent, BOTH_DUAL_TAUNT ) )
+		{
+			PM_SetAnim(pm,SETANIM_BOTH,BOTH_DUAL_TAUNT,SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD);//SETANIM_FLAG_NORMAL
+		}
+		else if ( pm->ps->weapon == WP_SABER 
+			&& pm->ps->saberAnimLevel == SS_STAFF )//pm->ps->saber[0].type == SABER_STAFF )
+		{//turn on the blades
+			if ( PM_HasAnimation( pm->gent, BOTH_STAFF_TAUNT ) )
+			{
+				PM_SetAnim(pm,SETANIM_BOTH,BOTH_STAFF_TAUNT,SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD);//SETANIM_FLAG_NORMAL
+			}
+			/*
+			else
+			{
+				if ( !pm->ps->saber[0].blade[0].active )
+				{//first blade is off
+					//turn it on
+					pm->ps->SaberBladeActivate( 0, 0, qtrue );
+					if ( !pm->ps->saber[0].blade[1].active )
+					{//second blade is also off, extend time of this taunt so we have enough time to turn them both on
+						pm->ps->taunting = level.time + 3000;
+					}
+				}
+				else if ( (pm->ps->taunting - level.time) < 1500 )
+				{//only 1500ms left in taunt
+					if ( !pm->ps->saber[0].blade[1].active )
+					{//second blade is off
+						//turn it on
+						pm->ps->SaberBladeActivate( 0, 1, qtrue );
+					}
+				}
+				//pose
+				PM_SetAnim(pm,SETANIM_BOTH,BOTH_SABERSTAFF_STANCE,SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD);
+				pm->ps->torsoAnimTimer = pm->ps->legsAnimTimer = (pm->ps->taunting - level.time);
+			}
+			*/
+		}
+		else if ( PM_HasAnimation( pm->gent, BOTH_GESTURE1 ) )
+		{
+			PM_SetAnim(pm,SETANIM_BOTH,BOTH_GESTURE1,SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD);//SETANIM_FLAG_NORMAL
+			pm->gent->client->ps.SaberActivateTrail( 100 );
+			//FIXME: will this reset?
+			//FIXME: force-control (yellow glow) effect on hand and saber?
+		}
+		else
+		{
+			//PM_SetAnim(pm,SETANIM_TORSO,TORSO_WEAPONIDLE1,SETANIM_FLAG_NORMAL);
+		}
+		return;
+	}
+
+	if (pm->ps->weapon == WP_SABER )		// WP_LIGHTSABER
+	{
+		qboolean saberInAir = qfalse;
+		if ( pm->ps->SaberLength() && !pm->ps->saberInFlight )
+		{
+			PM_TorsoAnimLightsaber();
+		}
+		else
+		{
+			if ( pm->ps->forcePowersActive&(1<<FP_GRIP) && pm->ps->forcePowerLevel[FP_GRIP] > FORCE_LEVEL_1 )
+			{//holding an enemy aloft with force-grip
+				return;
+			}
+			if ( pm->ps->forcePowersActive&(1<<FP_LIGHTNING) && pm->ps->forcePowerLevel[FP_LIGHTNING] > FORCE_LEVEL_1 )
+			{//lightning
+				return;
+			}
+			if ( pm->ps->forcePowersActive&(1<<FP_DRAIN) )
+			{//drain
+				return;
+			}
+
+			saberInAir = qtrue;
+
+			if ( PM_SaberInBrokenParry( pm->ps->saberMove ) || pm->ps->saberBlocked == BLOCKED_PARRY_BROKEN || PM_DodgeAnim( pm->ps->torsoAnim ) )
+			{//we're stuck in a broken parry
+				PM_TorsoAnimLightsaber();
+			}
+			else
+			{
+				if ( pm->ps->saberEntityNum < ENTITYNUM_NONE && pm->ps->saberEntityNum > 0 )//player is 0
+					{//
+					if ( &g_entities[pm->ps->saberEntityNum] != NULL && g_entities[pm->ps->saberEntityNum].s.pos.trType == TR_STATIONARY )
+					{//fell to the ground and we're not trying to pull it back
+						saberInAir = qfalse;
+					}
+				}
+
+				if ( pm->ps->saberInFlight 
+					&& saberInAir 
+					&& (!pm->ps->dualSabers //not using 2 sabers
+						|| !pm->ps->saber[1].Active() //left one off
+						|| pm->ps->torsoAnim == BOTH_SABERDUAL_STANCE//not attacking
+						|| pm->ps->torsoAnim == BOTH_SABERPULL//not attacking
+						|| pm->ps->torsoAnim == BOTH_STAND1//not attacking
+						|| PM_RunningAnim( pm->ps->torsoAnim ) //not attacking
+						|| PM_WalkingAnim( pm->ps->torsoAnim ) //not attacking
+						|| PM_JumpingAnim( pm->ps->torsoAnim )//not attacking
+						|| PM_SwimmingAnim( pm->ps->torsoAnim ) )//not attacking
+					)
+				{
+					if ( !PM_ForceAnim( pm->ps->torsoAnim ) || pm->ps->torsoAnimTimer < 300 )
+					{//don't interrupt a force power anim
+						if ( pm->ps->torsoAnim != BOTH_LOSE_SABER 
+							|| !pm->ps->torsoAnimTimer )
+						{
+							PM_SetAnim( pm, SETANIM_TORSO,BOTH_SABERPULL,SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+						}
+					}
+				}
+				else
+				{
+					if ( PM_InSlopeAnim( pm->ps->legsAnim ) )
+					{//HMM... this probably breaks the saber putaway and select anims
+						if ( pm->ps->SaberLength() > 0 )
+						{
+							PM_SetAnim(pm,SETANIM_TORSO,BOTH_STAND2,SETANIM_FLAG_NORMAL);
+						}
+						else
+						{
+							PM_SetAnim(pm,SETANIM_TORSO,BOTH_STAND1,SETANIM_FLAG_NORMAL);
+						}
+					}
+					else
+					{
+						if ( (pm->ps->clientNum < MAX_CLIENTS||PM_ControlledByPlayer()) && pm->ps->torsoAnim == BOTH_BUTTON_HOLD )
+						{//using something
+							if ( !pm->ps->useTime )
+							{//stopped holding it, release
+								PM_SetAnim( pm, SETANIM_TORSO, BOTH_BUTTON_RELEASE, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+							}//else still holding, leave it as it is
+						}
+						else
+						{
+							PM_SetAnim(pm,SETANIM_TORSO,pm->ps->legsAnim,SETANIM_FLAG_NORMAL);
+						}
+					}
+				}
+			}
+		}
+
+		if (pm->ps->weaponTime<= 0 && (pm->ps->saberMove==LS_READY || pm->ps->SaberLength()==0) && !saberInAir)
+		{
+			TorsoAgainstWindTest(pm->gent); 
+		}
+		return;
+	}
+
+	if ( PM_ForceAnim( pm->ps->torsoAnim )
+		&& pm->ps->torsoAnimTimer > 0 )
+	{//in a force anim, don't do a stand anim
+		return;
+	}
+
+
+	qboolean weaponBusy = qfalse;
+
+	if ( pm->ps->weapon == WP_NONE )
+	{
+		weaponBusy = qfalse;
+	}
+	else if ( pm->ps->weaponstate == WEAPON_FIRING || pm->ps->weaponstate == WEAPON_CHARGING || pm->ps->weaponstate == WEAPON_CHARGING_ALT )
+	{
+		weaponBusy = qtrue;
+	}
+	else if ( pm->ps->lastShotTime > level.time - 3000 )
+	{
+		weaponBusy = qtrue;
+	}
+	else if ( pm->ps->weaponTime > 0 )
+	{
+		weaponBusy = qtrue;
+	}
+	else if ( pm->gent && pm->gent->client->fireDelay > 0 )
+	{
+		weaponBusy = qtrue;
+	}
+	else if ( TorsoAgainstWindTest(pm->gent) )
+	{
+		return;
+	}
+	else if ( (pm->ps->clientNum < MAX_CLIENTS||PM_ControlledByPlayer()) && cg.zoomTime > cg.time - 5000 )
+	{//if we used binoculars recently, aim weapon
+		weaponBusy = qtrue;
+		pm->ps->weaponstate = WEAPON_IDLE;
+	}
+	else if ( pm->ps->pm_flags & PMF_DUCKED )
+	{//ducking is considered on alert... plus looks stupid to have arms hanging down when crouched
+		weaponBusy = qtrue;
+	}
+
+	if (	pm->ps->weapon == WP_NONE || 
+			pm->ps->weaponstate == WEAPON_READY || 
+			pm->ps->weaponstate == WEAPON_CHARGING ||
+			pm->ps->weaponstate == WEAPON_CHARGING_ALT )
+	{
+		if ( pm->ps->weapon == WP_SABER && pm->ps->SaberLength() )
+		{
+			PM_SetAnim(pm,SETANIM_TORSO,BOTH_ATTACK1,SETANIM_FLAG_NORMAL);//TORSO_WEAPONREADY1
+		}
+		else if( pm->ps->legsAnim == BOTH_RUN1 && !weaponBusy )
+		{
+			PM_SetAnim(pm,SETANIM_TORSO,BOTH_RUN1,SETANIM_FLAG_NORMAL);
+		}
+		else if( pm->ps->legsAnim == BOTH_RUN2 && !weaponBusy )//&& pm->ps->saberAnimLevel != SS_STAFF )
+		{
+			PM_SetAnim(pm,SETANIM_TORSO,BOTH_RUN2,SETANIM_FLAG_NORMAL);
+		}
+		else if( pm->ps->legsAnim == BOTH_RUN4 && !weaponBusy )//&& pm->ps->saberAnimLevel != SS_STAFF )
+		{
+			PM_SetAnim(pm,SETANIM_TORSO,BOTH_RUN4,SETANIM_FLAG_NORMAL);
+		}
+		else if( pm->ps->legsAnim == BOTH_RUN_STAFF && !weaponBusy )
+		{
+			PM_SetAnim(pm,SETANIM_TORSO,BOTH_RUN_STAFF,SETANIM_FLAG_NORMAL);
+		}
+		else if( pm->ps->legsAnim == BOTH_RUN_DUAL && !weaponBusy )
+		{
+			PM_SetAnim(pm,SETANIM_TORSO,BOTH_RUN_DUAL,SETANIM_FLAG_NORMAL);
+		}
+		else if( pm->ps->legsAnim == BOTH_WALK1 && !weaponBusy  )
+		{
+			PM_SetAnim(pm,SETANIM_TORSO,BOTH_WALK1,SETANIM_FLAG_NORMAL);
+		}
+		else if( pm->ps->legsAnim == BOTH_WALK2 && !weaponBusy  )
+		{
+			PM_SetAnim(pm,SETANIM_TORSO,BOTH_WALK2,SETANIM_FLAG_NORMAL);
+		}
+		else if( pm->ps->legsAnim == BOTH_WALK_STAFF && !weaponBusy  )
+		{
+			PM_SetAnim(pm,SETANIM_TORSO,BOTH_WALK_STAFF,SETANIM_FLAG_NORMAL);
+		}
+		else if( pm->ps->legsAnim == BOTH_WALK_DUAL&& !weaponBusy  )
+		{
+			PM_SetAnim(pm,SETANIM_TORSO,BOTH_WALK_DUAL,SETANIM_FLAG_NORMAL);
+		}
+		else if( pm->ps->legsAnim == BOTH_CROUCH1IDLE && pm->ps->clientNum != 0 )//player falls through
+		{
+			//??? Why nothing?  What if you were running???
+			//PM_SetAnim(pm,SETANIM_TORSO,BOTH_CROUCH1IDLE,SETANIM_FLAG_NORMAL);
+		}
+		else if( pm->ps->legsAnim == BOTH_JUMP1 && !weaponBusy )
+		{
+			PM_SetAnim(pm,SETANIM_TORSO,BOTH_JUMP1,SETANIM_FLAG_NORMAL, 100);	// Only blend over 100ms
+		}
+		else if( pm->ps->legsAnim == BOTH_SWIM_IDLE1 && !weaponBusy )
+		{
+			PM_SetAnim(pm,SETANIM_TORSO,BOTH_SWIM_IDLE1,SETANIM_FLAG_NORMAL);
+		}
+		else if( pm->ps->legsAnim == BOTH_SWIMFORWARD && !weaponBusy )
+		{
+			PM_SetAnim(pm,SETANIM_TORSO,BOTH_SWIMFORWARD,SETANIM_FLAG_NORMAL);
+		}
+		else if ( pm->ps->weapon == WP_NONE )
+		{
+			int legsAnim = pm->ps->legsAnim;
+			/*
+			if ( PM_RollingAnim( legsAnim ) || 
+				PM_FlippingAnim( legsAnim ) ||
+				PM_JumpingAnim( legsAnim ) ||
+				PM_PainAnim( legsAnim ) ||
+				PM_SwimmingAnim( legsAnim ) )
+			*/
+			{
+				PM_SetAnim(pm, SETANIM_TORSO, legsAnim, SETANIM_FLAG_NORMAL );
+			}
+		}
+		else
+		{//Used to default to both_stand1 which is an arms-down anim
+			if ( (pm->ps->clientNum < MAX_CLIENTS||PM_ControlledByPlayer()) && pm->ps->torsoAnim == BOTH_BUTTON_HOLD )
+			{//using something
+				if ( !pm->ps->useTime )
+				{//stopped holding it, release
+					PM_SetAnim( pm, SETANIM_TORSO, BOTH_BUTTON_RELEASE, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+				}//else still holding, leave it as it is
+			}
+			else if ( pm->gent != NULL 
+				&& (pm->gent->s.number<MAX_CLIENTS||G_ControlledByPlayer(pm->gent))
+				&& pm->ps->weaponstate != WEAPON_CHARGING 
+				&& pm->ps->weaponstate != WEAPON_CHARGING_ALT )
+			{//PLayer- temp hack for weapon frame
+				if ( pm->gent && pm->gent->client && pm->gent->client->NPC_class == CLASS_RANCOR )
+				{//ignore
+				}
+				else if ( pm->ps->weapon == WP_MELEE )
+				{//hehe
+					PM_SetAnim(pm,SETANIM_TORSO,BOTH_STAND6,SETANIM_FLAG_NORMAL);
+				}
+				else
+				{
+					PM_SetAnim(pm,SETANIM_TORSO,BOTH_STAND1,SETANIM_FLAG_NORMAL);
+				}
+			}
+			else if ( PM_InSpecialJump( pm->ps->legsAnim ) )
+			{//use legs anim
+				//FIXME: or just use whatever's currently playing?
+				//PM_SetAnim( pm, SETANIM_TORSO, pm->ps->legsAnim, SETANIM_FLAG_NORMAL );
+			}
+			else
+			{
+				switch(pm->ps->weapon)
+				{
+				// ********************************************************
+				case WP_SABER:		// WP_LIGHTSABER
+					// Ready pose for Lightsaber
+//					PM_SetAnim(pm,SETANIM_TORSO,BOTH_ATTACK1,SETANIM_FLAG_NORMAL);//TORSO_WEAPONREADY1
+					// Select the next proper pose for the lightsaber assuming that there are no attacks.
+					if (pm->ps->saberMove > LS_NONE && pm->ps->saberMove < LS_MOVE_MAX)
+					{
+						PM_SetSaberMove(saberMoveData[pm->ps->saberMove].chain_idle);
+					}
+					break;
+				// ********************************************************
+
+				case WP_BRYAR_PISTOL:
+					//FIXME: if recently fired, hold the ready!
+					if ( pm->ps->weaponstate == WEAPON_CHARGING_ALT || weaponBusy )
+					{
+						PM_SetAnim(pm,SETANIM_TORSO,TORSO_WEAPONREADY2,SETANIM_FLAG_NORMAL);
+					}
+					else if ( PM_RunningAnim( pm->ps->legsAnim ) 
+						|| PM_WalkingAnim( pm->ps->legsAnim ) 
+						|| PM_JumpingAnim( pm->ps->legsAnim )
+						|| PM_SwimmingAnim( pm->ps->legsAnim ) )
+					{//running w/1-handed weapon uses full-body anim
+						PM_SetAnim(pm,SETANIM_TORSO,pm->ps->legsAnim,SETANIM_FLAG_NORMAL);
+					}
+					else
+					{
+						PM_SetAnim(pm,SETANIM_TORSO,TORSO_WEAPONREADY2,SETANIM_FLAG_NORMAL);
+					}
+					break;
+				case WP_BLASTER_PISTOL:
+					if ( pm->gent 
+						&& pm->gent->weaponModel[1] > 0 )
+					{//dual pistols
+						if ( weaponBusy )
+						{
+							PM_SetAnim(pm,SETANIM_TORSO,BOTH_GUNSIT1,SETANIM_FLAG_NORMAL);
+						}
+						else if ( PM_RunningAnim( pm->ps->legsAnim ) 
+							|| PM_WalkingAnim( pm->ps->legsAnim ) 
+							|| PM_JumpingAnim( pm->ps->legsAnim )
+							|| PM_SwimmingAnim( pm->ps->legsAnim ) )
+						{//running w/1-handed weapon uses full-body anim
+							PM_SetAnim(pm,SETANIM_TORSO,pm->ps->legsAnim,SETANIM_FLAG_NORMAL);
+						}
+						else
+						{
+							PM_SetAnim(pm,SETANIM_TORSO,BOTH_STAND6,SETANIM_FLAG_NORMAL);
+						}
+					}
+					else
+					{//single pistols
+						if ( pm->ps->weaponstate == WEAPON_CHARGING_ALT || weaponBusy )
+						{
+							PM_SetAnim(pm,SETANIM_TORSO,TORSO_WEAPONREADY2,SETANIM_FLAG_NORMAL);
+						}
+						else if ( PM_RunningAnim( pm->ps->legsAnim ) 
+							|| PM_WalkingAnim( pm->ps->legsAnim ) 
+							|| PM_JumpingAnim( pm->ps->legsAnim )
+							|| PM_SwimmingAnim( pm->ps->legsAnim ) )
+						{//running w/1-handed weapon uses full-body anim
+							PM_SetAnim(pm,SETANIM_TORSO,pm->ps->legsAnim,SETANIM_FLAG_NORMAL);
+						}
+						else
+						{
+							PM_SetAnim(pm,SETANIM_TORSO,TORSO_WEAPONREADY2,SETANIM_FLAG_NORMAL);
+						}
+					}
+					break;
+				case WP_NONE:
+					//NOTE: should never get here
+					break;
+				case WP_MELEE:
+					if ( PM_RunningAnim( pm->ps->legsAnim ) 
+						|| PM_WalkingAnim( pm->ps->legsAnim ) 
+						|| PM_JumpingAnim( pm->ps->legsAnim )
+						|| PM_SwimmingAnim( pm->ps->legsAnim ) )
+					{//running w/1-handed weapon uses full-body anim
+						PM_SetAnim(pm,SETANIM_TORSO,pm->ps->legsAnim,SETANIM_FLAG_NORMAL);
+					}
+					else
+					{
+						if ( pm->gent && pm->gent->client && pm->gent->client->NPC_class == CLASS_RANCOR )
+						{//ignore
+						}
+						else if ( pm->gent && pm->gent->client && !PM_DroidMelee( pm->gent->client->NPC_class ) )
+						{
+							PM_SetAnim(pm,SETANIM_TORSO,BOTH_STAND6,SETANIM_FLAG_NORMAL);
+						}
+						else
+						{
+							PM_SetAnim(pm,SETANIM_TORSO,BOTH_STAND1,SETANIM_FLAG_NORMAL);
+						}
+					}
+					break;
+				case WP_TUSKEN_STAFF:
+					if ( PM_RunningAnim( pm->ps->legsAnim ) 
+						|| PM_WalkingAnim( pm->ps->legsAnim ) 
+						|| PM_JumpingAnim( pm->ps->legsAnim )
+						|| PM_SwimmingAnim( pm->ps->legsAnim ) )
+					{//running w/1-handed weapon uses full-body anim
+						PM_SetAnim(pm,SETANIM_TORSO,pm->ps->legsAnim,SETANIM_FLAG_NORMAL);
+					}
+					else
+					{
+						PM_SetAnim(pm, SETANIM_TORSO, BOTH_STAND3, SETANIM_FLAG_NORMAL);
+					}
+					break;
+				
+				case WP_NOGHRI_STICK:
+					PM_SetAnim(pm,SETANIM_TORSO,TORSO_WEAPONREADY3,SETANIM_FLAG_NORMAL);
+					//PM_SetAnim(pm,SETANIM_LEGS,BOTH_ATTACK2,SETANIM_FLAG_NORMAL);
+					break;
+				
+				case WP_BLASTER:
+					PM_SetAnim(pm,SETANIM_TORSO,TORSO_WEAPONREADY3,SETANIM_FLAG_NORMAL);
+					//PM_SetAnim(pm,SETANIM_LEGS,BOTH_ATTACK2,SETANIM_FLAG_NORMAL);
+					break;
+				case WP_DISRUPTOR:
+				case WP_TUSKEN_RIFLE:
+					if ( (pm->ps->weaponstate != WEAPON_FIRING 
+							&& pm->ps->weaponstate != WEAPON_CHARGING 
+							&& pm->ps->weaponstate != WEAPON_CHARGING_ALT)
+							|| PM_RunningAnim( pm->ps->legsAnim ) 
+							|| PM_WalkingAnim( pm->ps->legsAnim ) 
+							|| PM_JumpingAnim( pm->ps->legsAnim )
+							|| PM_SwimmingAnim( pm->ps->legsAnim ) )
+					{//running sniper weapon uses normal ready
+						if ( pm->ps->clientNum )
+						{
+							PM_SetAnim( pm, SETANIM_TORSO, TORSO_WEAPONREADY3, SETANIM_FLAG_NORMAL );
+						}
+						else
+						{
+							PM_SetAnim( pm, SETANIM_TORSO, TORSO_WEAPONREADY3, SETANIM_FLAG_NORMAL );
+						}
+					}
+					else
+					{
+						if ( pm->ps->clientNum )
+						{
+							PM_SetAnim( pm, SETANIM_TORSO, TORSO_WEAPONREADY4, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );//TORSO_WEAPONREADY4//SETANIM_FLAG_RESTART|
+						}
+						else
+						{
+							PM_SetAnim( pm, SETANIM_TORSO, TORSO_WEAPONREADY4, SETANIM_FLAG_NORMAL );
+						}
+					}
+					break;
+				case WP_BOT_LASER:
+					PM_SetAnim(pm,SETANIM_TORSO,TORSO_WEAPONIDLE2,SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_RESTART|SETANIM_FLAG_HOLD);
+					break;
+				case WP_THERMAL:
+					if ( pm->ps->weaponstate != WEAPON_FIRING 
+						&& pm->ps->weaponstate != WEAPON_CHARGING 
+						&& pm->ps->weaponstate != WEAPON_CHARGING_ALT
+						&& (PM_RunningAnim( pm->ps->legsAnim ) 
+							|| PM_WalkingAnim( pm->ps->legsAnim ) 
+							|| PM_JumpingAnim( pm->ps->legsAnim )
+							|| PM_SwimmingAnim( pm->ps->legsAnim )) )
+					{//running w/1-handed weapon uses full-body anim
+						PM_SetAnim(pm,SETANIM_TORSO,pm->ps->legsAnim,SETANIM_FLAG_NORMAL);
+					}
+					else
+					{
+						if ( (pm->ps->clientNum < MAX_CLIENTS||PM_ControlledByPlayer()) && (pm->ps->weaponstate == WEAPON_CHARGING || pm->ps->weaponstate == WEAPON_CHARGING_ALT) )
+						{//player pulling back to throw
+							if ( PM_StandingAnim( pm->ps->legsAnim ) )
+							{
+								PM_SetAnim( pm, SETANIM_LEGS, BOTH_THERMAL_READY, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+							}
+							else if ( pm->ps->legsAnim == BOTH_THERMAL_READY )
+							{//sigh... hold it so pm_footsteps doesn't override
+								if ( pm->ps->legsAnimTimer < 100 )
+								{
+									pm->ps->legsAnimTimer = 100;
+								}
+							}
+							PM_SetAnim( pm, SETANIM_TORSO, BOTH_THERMAL_READY, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+						}
+						else
+						{
+							if ( weaponBusy )
+							{
+								PM_SetAnim( pm, SETANIM_TORSO, TORSO_WEAPONREADY10, SETANIM_FLAG_NORMAL );
+							}
+							else
+							{
+								PM_SetAnim( pm, SETANIM_TORSO, BOTH_STAND1, SETANIM_FLAG_NORMAL );
+							}
+						}
+					}
+					break;
+				case WP_REPEATER:
+					if ( pm->gent && pm->gent->client && pm->gent->client->NPC_class == CLASS_GALAKMECH )
+					{//
+						if ( pm->gent->alt_fire )
+						{
+							PM_SetAnim(pm,SETANIM_TORSO,TORSO_WEAPONREADY3,SETANIM_FLAG_NORMAL);
+						}
+						else
+						{
+							PM_SetAnim(pm,SETANIM_TORSO,TORSO_WEAPONREADY1,SETANIM_FLAG_NORMAL);
+						}
+					}
+					else
+					{
+						PM_SetAnim(pm,SETANIM_TORSO,TORSO_WEAPONREADY3,SETANIM_FLAG_NORMAL);
+					}
+					break;
+				case WP_TRIP_MINE:
+				case WP_DET_PACK:
+					if ( PM_RunningAnim( pm->ps->legsAnim ) 
+						|| PM_WalkingAnim( pm->ps->legsAnim ) 
+						|| PM_JumpingAnim( pm->ps->legsAnim )
+						|| PM_SwimmingAnim( pm->ps->legsAnim ) )
+					{//running w/1-handed weapon uses full-body anim
+						PM_SetAnim(pm,SETANIM_TORSO,pm->ps->legsAnim,SETANIM_FLAG_NORMAL);
+					}
+					else
+					{
+						if ( weaponBusy )
+						{
+							PM_SetAnim( pm, SETANIM_TORSO, TORSO_WEAPONREADY3, SETANIM_FLAG_NORMAL );
+						}
+						else
+						{
+							PM_SetAnim( pm, SETANIM_TORSO, BOTH_STAND1, SETANIM_FLAG_NORMAL );
+						}
+					}
+					break;
+				default:
+					PM_SetAnim(pm,SETANIM_TORSO,TORSO_WEAPONREADY3,SETANIM_FLAG_NORMAL);
+					break;
+				}
+			}
+		}
+	}
+	else if ( pm->ps->weaponstate == WEAPON_IDLE )
+	{
+		if( pm->ps->legsAnim == BOTH_GUARD_LOOKAROUND1 )
+		{
+			PM_SetAnim(pm,SETANIM_TORSO,BOTH_GUARD_LOOKAROUND1,SETANIM_FLAG_NORMAL);
+		}
+		else if( pm->ps->legsAnim == BOTH_GUARD_IDLE1 )
+		{
+			PM_SetAnim(pm,SETANIM_TORSO,BOTH_GUARD_IDLE1,SETANIM_FLAG_NORMAL);
+		}
+		else if( pm->ps->legsAnim == BOTH_STAND1IDLE1 
+			|| pm->ps->legsAnim == BOTH_STAND2IDLE1
+			|| pm->ps->legsAnim == BOTH_STAND2IDLE2
+			|| pm->ps->legsAnim == BOTH_STAND3IDLE1
+			|| pm->ps->legsAnim == BOTH_STAND5IDLE1 )
+		{
+			PM_SetAnim(pm,SETANIM_TORSO,pm->ps->legsAnim,SETANIM_FLAG_NORMAL);
+			pm->ps->saberMove = LS_READY;
+		}
+		else if( pm->ps->legsAnim == BOTH_STAND2TO4 )
+		{
+			PM_SetAnim(pm,SETANIM_TORSO,BOTH_STAND2TO4,SETANIM_FLAG_NORMAL);
+		}
+		else if( pm->ps->legsAnim == BOTH_STAND4TO2 )
+		{
+			PM_SetAnim(pm,SETANIM_TORSO,BOTH_STAND4TO2,SETANIM_FLAG_NORMAL);
+		}
+		else if( pm->ps->legsAnim == BOTH_STAND4 )
+		{
+			PM_SetAnim(pm,SETANIM_TORSO,BOTH_STAND4,SETANIM_FLAG_NORMAL);
+		}
+		else if( pm->ps->legsAnim == BOTH_SWIM_IDLE1 )
+		{
+			PM_SetAnim(pm,SETANIM_TORSO,BOTH_SWIM_IDLE1,SETANIM_FLAG_NORMAL);
+		}
+		else if( pm->ps->legsAnim == BOTH_SWIMFORWARD )
+		{
+			PM_SetAnim(pm,SETANIM_TORSO,BOTH_SWIMFORWARD,SETANIM_FLAG_NORMAL);
+		}
+		else if ( PM_InSpecialJump( pm->ps->legsAnim ) )
+		{//use legs anim
+			//FIXME: or just use whatever's currently playing?
+			//PM_SetAnim( pm, SETANIM_TORSO, pm->ps->legsAnim, SETANIM_FLAG_NORMAL );
+		}
+		else if ( (pm->ps->clientNum < MAX_CLIENTS||PM_ControlledByPlayer()) && pm->ps->torsoAnim == BOTH_BUTTON_HOLD )
+		{//using something
+			if ( !pm->ps->useTime )
+			{//stopped holding it, release
+				PM_SetAnim( pm, SETANIM_TORSO, BOTH_BUTTON_RELEASE, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+			}//else still holding, leave it as it is
+		}
+		else
+		{
+			if ( !weaponBusy 
+				&& pm->ps->weapon != WP_BOWCASTER
+				&& pm->ps->weapon != WP_REPEATER
+				&& pm->ps->weapon != WP_FLECHETTE
+				&& pm->ps->weapon != WP_ROCKET_LAUNCHER
+				&& pm->ps->weapon != WP_CONCUSSION
+				&& ( PM_RunningAnim( pm->ps->legsAnim ) 
+					|| (PM_WalkingAnim( pm->ps->legsAnim ) && (pm->ps->clientNum < MAX_CLIENTS||PM_ControlledByPlayer()))
+					|| PM_JumpingAnim( pm->ps->legsAnim )
+					|| PM_SwimmingAnim( pm->ps->legsAnim ) ) )
+			{//running w/1-handed or light 2-handed weapon uses full-body anim if you're not using the weapon right now
+				PM_SetAnim(pm,SETANIM_TORSO,pm->ps->legsAnim,SETANIM_FLAG_NORMAL);
+			}
+			else
+			{
+				switch ( pm->ps->weapon )
+				{
+				// ********************************************************
+				case WP_SABER:		// WP_LIGHTSABER
+					// Shouldn't get here, should go to TorsoAnimLightsaber
+					break;
+				// ********************************************************
+
+				case WP_BRYAR_PISTOL:
+					if ( pm->ps->weaponstate == WEAPON_CHARGING_ALT || weaponBusy )
+					{
+						PM_SetAnim(pm,SETANIM_TORSO,TORSO_WEAPONREADY2,SETANIM_FLAG_NORMAL);
+					}
+					else if ( PM_RunningAnim( pm->ps->legsAnim ) 
+						|| PM_WalkingAnim( pm->ps->legsAnim ) 
+						|| PM_JumpingAnim( pm->ps->legsAnim )
+						|| PM_SwimmingAnim( pm->ps->legsAnim ) )
+					{//running w/1-handed weapon uses full-body anim
+						PM_SetAnim(pm,SETANIM_TORSO,pm->ps->legsAnim,SETANIM_FLAG_NORMAL);
+					}
+					else
+					{
+						PM_SetAnim(pm,SETANIM_TORSO,TORSO_WEAPONIDLE2,SETANIM_FLAG_NORMAL);
+					}
+					break;
+				case WP_BLASTER_PISTOL:
+					if ( pm->gent 
+						&& pm->gent->weaponModel[1] > 0 )
+					{//dual pistols
+						if ( weaponBusy )
+						{
+							PM_SetAnim(pm,SETANIM_TORSO,BOTH_GUNSIT1,SETANIM_FLAG_NORMAL);
+						}
+						else if ( PM_RunningAnim( pm->ps->legsAnim ) 
+							|| PM_WalkingAnim( pm->ps->legsAnim ) 
+							|| PM_JumpingAnim( pm->ps->legsAnim )
+							|| PM_SwimmingAnim( pm->ps->legsAnim ) )
+						{//running w/1-handed weapon uses full-body anim
+							PM_SetAnim(pm,SETANIM_TORSO,pm->ps->legsAnim,SETANIM_FLAG_NORMAL);
+						}
+						else
+						{
+							PM_SetAnim(pm,SETANIM_TORSO,BOTH_STAND1,SETANIM_FLAG_NORMAL);
+						}
+					}
+					else
+					{//single pistols
+						if ( pm->ps->weaponstate == WEAPON_CHARGING_ALT || weaponBusy )
+						{
+							PM_SetAnim(pm,SETANIM_TORSO,TORSO_WEAPONREADY2,SETANIM_FLAG_NORMAL);
+						}
+						else if ( PM_RunningAnim( pm->ps->legsAnim ) 
+								|| PM_WalkingAnim( pm->ps->legsAnim ) 
+								|| PM_JumpingAnim( pm->ps->legsAnim )
+								|| PM_SwimmingAnim( pm->ps->legsAnim ) )
+						{//running w/1-handed weapon uses full-body anim
+							PM_SetAnim(pm,SETANIM_TORSO,pm->ps->legsAnim,SETANIM_FLAG_NORMAL);
+						}
+						else
+						{
+							PM_SetAnim(pm,SETANIM_TORSO,TORSO_WEAPONIDLE2,SETANIM_FLAG_NORMAL);
+						}
+					}
+					break;
+
+				case WP_NONE:
+					//NOTE: should never get here
+					break;
+
+				case WP_MELEE:
+					if ( PM_RunningAnim( pm->ps->legsAnim ) 
+						|| PM_WalkingAnim( pm->ps->legsAnim ) 
+						|| PM_JumpingAnim( pm->ps->legsAnim )
+						|| PM_SwimmingAnim( pm->ps->legsAnim ) )
+					{//running w/1-handed weapon uses full-body anim
+						PM_SetAnim(pm,SETANIM_TORSO,pm->ps->legsAnim,SETANIM_FLAG_NORMAL);
+					}
+					else
+					{
+						if ( pm->gent && pm->gent->client && pm->gent->client->NPC_class == CLASS_RANCOR )
+						{//ignore
+						}
+						else if ( pm->gent && pm->gent->client && !PM_DroidMelee( pm->gent->client->NPC_class ) )
+						{
+							PM_SetAnim(pm,SETANIM_TORSO,BOTH_STAND6,SETANIM_FLAG_NORMAL);
+						}
+						else
+						{
+							PM_SetAnim(pm,SETANIM_TORSO,BOTH_STAND1,SETANIM_FLAG_NORMAL);
+						}
+					}
+					break;
+
+				case WP_TUSKEN_STAFF:
+					if ( PM_RunningAnim( pm->ps->legsAnim ) 
+						|| PM_WalkingAnim( pm->ps->legsAnim ) 
+						|| PM_JumpingAnim( pm->ps->legsAnim )
+						|| PM_SwimmingAnim( pm->ps->legsAnim ) )
+					{//running w/1-handed weapon uses full-body anim
+						PM_SetAnim(pm,SETANIM_TORSO,pm->ps->legsAnim,SETANIM_FLAG_NORMAL);
+					}
+					else
+					{
+						PM_SetAnim(pm, SETANIM_TORSO, BOTH_STAND3, SETANIM_FLAG_NORMAL);
+					}
+					break;
+
+				case WP_NOGHRI_STICK:
+					if ( weaponBusy )
+					{
+						PM_SetAnim(pm,SETANIM_TORSO,TORSO_WEAPONREADY3,SETANIM_FLAG_NORMAL);
+					}
+					else
+					{
+						PM_SetAnim(pm,SETANIM_TORSO,TORSO_WEAPONIDLE3,SETANIM_FLAG_NORMAL);
+					}
+					break;
+
+				case WP_BLASTER:
+					if ( weaponBusy )
+					{
+						PM_SetAnim(pm,SETANIM_TORSO,TORSO_WEAPONREADY3,SETANIM_FLAG_NORMAL);
+					}
+					else
+					{
+						PM_SetAnim(pm,SETANIM_TORSO,TORSO_WEAPONIDLE3,SETANIM_FLAG_NORMAL);
+					}
+					break;
+
+				case WP_DISRUPTOR:
+				case WP_TUSKEN_RIFLE:
+					if ( (pm->ps->weaponstate != WEAPON_FIRING 
+							&& pm->ps->weaponstate != WEAPON_CHARGING 
+							&& pm->ps->weaponstate != WEAPON_CHARGING_ALT)
+							|| PM_RunningAnim( pm->ps->legsAnim ) 
+							|| PM_WalkingAnim( pm->ps->legsAnim ) 
+							|| PM_JumpingAnim( pm->ps->legsAnim )
+							|| PM_SwimmingAnim( pm->ps->legsAnim ) )
+					{//running sniper weapon uses normal ready
+						if ( pm->ps->clientNum )
+						{
+							PM_SetAnim( pm, SETANIM_TORSO, TORSO_WEAPONREADY3, SETANIM_FLAG_NORMAL );
+						}
+						else
+						{
+							PM_SetAnim( pm, SETANIM_TORSO, TORSO_WEAPONREADY3, SETANIM_FLAG_NORMAL );
+						}
+					}
+					else
+					{
+						if ( pm->ps->clientNum )
+						{
+							PM_SetAnim( pm, SETANIM_TORSO, TORSO_WEAPONREADY4, SETANIM_FLAG_NORMAL );
+						}
+						else
+						{
+							PM_SetAnim( pm, SETANIM_TORSO, TORSO_WEAPONREADY4, SETANIM_FLAG_NORMAL );
+						}
+					}
+					break;
+
+				case WP_BOT_LASER:
+					PM_SetAnim(pm,SETANIM_TORSO,TORSO_WEAPONIDLE2,SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_RESTART|SETANIM_FLAG_HOLD);
+					break;
+
+				case WP_THERMAL:
+					if ( PM_RunningAnim( pm->ps->legsAnim ) 
+						|| PM_WalkingAnim( pm->ps->legsAnim ) 
+						|| PM_JumpingAnim( pm->ps->legsAnim )
+						|| PM_SwimmingAnim( pm->ps->legsAnim ) )
+					{//running w/1-handed weapon uses full-body anim
+						PM_SetAnim(pm,SETANIM_TORSO,pm->ps->legsAnim,SETANIM_FLAG_NORMAL);
+					}
+					else
+					{
+						if ( weaponBusy )
+						{
+							PM_SetAnim( pm, SETANIM_TORSO, TORSO_WEAPONIDLE10, SETANIM_FLAG_NORMAL );
+						}
+						else
+						{
+							PM_SetAnim( pm, SETANIM_TORSO, BOTH_STAND1, SETANIM_FLAG_NORMAL );
+						}
+					}
+					break;
+
+				case WP_REPEATER:
+					if ( weaponBusy )
+					{
+						PM_SetAnim(pm,SETANIM_TORSO,TORSO_WEAPONREADY3,SETANIM_FLAG_NORMAL);
+					}
+					else
+					{
+						PM_SetAnim(pm,SETANIM_TORSO,TORSO_WEAPONIDLE3,SETANIM_FLAG_NORMAL);
+					}
+					break;
+				case WP_TRIP_MINE:
+				case WP_DET_PACK:
+					if ( PM_RunningAnim( pm->ps->legsAnim ) 
+						|| PM_WalkingAnim( pm->ps->legsAnim ) 
+						|| PM_JumpingAnim( pm->ps->legsAnim )
+						|| PM_SwimmingAnim( pm->ps->legsAnim ) )
+					{//running w/1-handed weapon uses full-body anim
+						PM_SetAnim(pm,SETANIM_TORSO,pm->ps->legsAnim,SETANIM_FLAG_NORMAL);
+					}
+					else
+					{
+						if ( weaponBusy )
+						{
+							PM_SetAnim( pm, SETANIM_TORSO, TORSO_WEAPONIDLE3, SETANIM_FLAG_NORMAL );
+						}
+						else
+						{
+							PM_SetAnim( pm, SETANIM_TORSO, BOTH_STAND1, SETANIM_FLAG_NORMAL );
+						}
+					}
+					break;
+
+				default:
+					if ( weaponBusy )
+					{
+						PM_SetAnim(pm,SETANIM_TORSO,TORSO_WEAPONREADY3,SETANIM_FLAG_NORMAL);
+					}
+					else
+					{
+						PM_SetAnim(pm,SETANIM_TORSO,TORSO_WEAPONIDLE3,SETANIM_FLAG_NORMAL);
+					}
+					break;
+				}
+			}
+		}
+	}
+}
+
+//=========================================================================
+// Anim checking utils
+//=========================================================================
+
+int PM_GetTurnAnim( gentity_t *gent, int anim )
+{
+	if ( !gent )
+	{
+		return -1;
+	}
+
+	switch( anim )
+	{
+	case BOTH_STAND1:			//# Standing idle: no weapon: hands down
+	case BOTH_STAND1IDLE1:		//# Random standing idle
+	case BOTH_STAND2:			//# Standing idle with a weapon
+	case BOTH_SABERFAST_STANCE:
+	case BOTH_SABERSLOW_STANCE:
+	case BOTH_STAND2IDLE1:		//# Random standing idle
+	case BOTH_STAND2IDLE2:		//# Random standing idle
+	case BOTH_STAND3:			//# Standing hands behind back: at ease: etc.
+	case BOTH_STAND3IDLE1:		//# Random standing idle
+	case BOTH_STAND4:			//# two handed: gun down: relaxed stand
+	case BOTH_STAND5:			//# standing idle, no weapon, hand down, back straight
+	case BOTH_STAND5IDLE1:		//# Random standing idle
+	case BOTH_STAND6:			//# one handed: gun at side: relaxed stand
+	case BOTH_STAND2TO4:			//# Transition from stand2 to stand4
+	case BOTH_STAND4TO2:			//# Transition from stand4 to stand2
+	case BOTH_GESTURE1:			//# Generic gesture: non-specific
+	case BOTH_GESTURE2:			//# Generic gesture: non-specific
+	case BOTH_TALK1:				//# Generic talk anim
+	case BOTH_TALK2:				//# Generic talk anim
+		if ( PM_HasAnimation( gent, LEGS_TURN1 ) )
+		{
+			return LEGS_TURN1;
+		}
+		else
+		{
+			return -1;
+		}
+		break;
+	case BOTH_ATTACK1:			//# Attack with generic 1-handed weapon
+	case BOTH_ATTACK2:			//# Attack with generic 2-handed weapon
+	case BOTH_ATTACK3:			//# Attack with heavy 2-handed weapon
+	case BOTH_ATTACK4:			//# Attack with ???
+	case BOTH_MELEE1:			//# First melee attack
+	case BOTH_MELEE2:			//# Second melee attack
+	case BOTH_GUARD_LOOKAROUND1:	//# Cradling weapon and looking around
+	case BOTH_GUARD_IDLE1:		//# Cradling weapon and standing
+		if ( PM_HasAnimation( gent, LEGS_TURN2 ) )
+		{
+			return LEGS_TURN2;
+		}
+		else
+		{
+			return -1;
+		}
+		break;
+	default:
+		return -1;
+		break;
+	}
+}
+
+int PM_TurnAnimForLegsAnim( gentity_t *gent, int anim )
+{
+	if ( !gent )
+	{
+		return -1;
+	}
+
+	switch( anim )
+	{
+	case BOTH_STAND1:			//# Standing idle: no weapon: hands down
+	case BOTH_STAND1IDLE1:		//# Random standing idle
+		if ( PM_HasAnimation( gent, BOTH_TURNSTAND1 ) )
+		{
+			return BOTH_TURNSTAND1;
+		}
+		else
+		{
+			return -1;
+		}
+		break;
+	case BOTH_STAND2:			//# Standing idle with a weapon
+	case BOTH_SABERFAST_STANCE:
+	case BOTH_SABERSLOW_STANCE:
+	case BOTH_STAND2IDLE1:		//# Random standing idle
+	case BOTH_STAND2IDLE2:		//# Random standing idle
+		if ( PM_HasAnimation( gent, BOTH_TURNSTAND2 ) )
+		{
+			return BOTH_TURNSTAND2;
+		}
+		else
+		{
+			return -1;
+		}
+		break;
+	case BOTH_STAND3:			//# Standing hands behind back: at ease: etc.
+	case BOTH_STAND3IDLE1:		//# Random standing idle
+		if ( PM_HasAnimation( gent, BOTH_TURNSTAND3 ) )
+		{
+			return BOTH_TURNSTAND3;
+		}
+		else
+		{
+			return -1;
+		}
+		break;
+	case BOTH_STAND4:			//# two handed: gun down: relaxed stand
+		if ( PM_HasAnimation( gent, BOTH_TURNSTAND4 ) )
+		{
+			return BOTH_TURNSTAND4;
+		}
+		else
+		{
+			return -1;
+		}
+		break;
+	case BOTH_STAND5:			//# standing idle, no weapon, hand down, back straight
+	case BOTH_STAND5IDLE1:		//# Random standing idle
+		if ( PM_HasAnimation( gent, BOTH_TURNSTAND5 ) )
+		{
+			return BOTH_TURNSTAND5;
+		}
+		else
+		{
+			return -1;
+		}
+		break;
+	case BOTH_CROUCH1:			//# Transition from standing to crouch
+	case BOTH_CROUCH1IDLE:		//# Crouching idle
+	/*
+	case BOTH_UNCROUCH1:			//# Transition from crouch to standing
+	case BOTH_CROUCH2TOSTAND1:	//# going from crouch2 to stand1
+	case BOTH_CROUCH3:			//# Desann crouching down to Kyle (cin 9)
+	case BOTH_UNCROUCH3:			//# Desann uncrouching down to Kyle (cin 9)
+	case BOTH_CROUCH4:			//# Slower version of crouch1 for cinematics
+	case BOTH_UNCROUCH4:			//# Slower version of uncrouch1 for cinematics
+	*/
+		if ( PM_HasAnimation( gent, BOTH_TURNCROUCH1 ) )
+		{
+			return BOTH_TURNCROUCH1;
+		}
+		else
+		{
+			return -1;
+		}
+		break;
+	default:
+		return -1;
+		break;
+	}
+}
+
+qboolean PM_InOnGroundAnim ( playerState_t *ps )
+{
+	switch( ps->legsAnim )
+	{
+	case BOTH_DEAD1:
+	case BOTH_DEAD2:
+	case BOTH_DEAD3:
+	case BOTH_DEAD4:
+	case BOTH_DEAD5:
+	case BOTH_DEADFORWARD1:
+	case BOTH_DEADBACKWARD1:
+	case BOTH_DEADFORWARD2:
+	case BOTH_DEADBACKWARD2:
+	case BOTH_LYINGDEATH1:
+	case BOTH_LYINGDEAD1:
+	case BOTH_SLEEP1:			//# laying on back-rknee up-rhand on torso
+		return qtrue;
+		break;
+	case BOTH_KNOCKDOWN1:		//# 
+	case BOTH_KNOCKDOWN2:		//# 
+	case BOTH_KNOCKDOWN3:		//# 
+	case BOTH_KNOCKDOWN4:		//# 
+	case BOTH_KNOCKDOWN5:		//# 
+	case BOTH_LK_DL_ST_T_SB_1_L:
+	case BOTH_RELEASED:
+		if ( ps->legsAnimTimer < 500 )
+		{//pretty much horizontal by this point
+			return qtrue;
+		}
+		break;
+	case BOTH_PLAYER_PA_3_FLY:
+		if ( ps->legsAnimTimer < 300 )
+		{//pretty much horizontal by this point
+			return qtrue;
+		}
+		/*
+		else if ( ps->clientNum < MAX_CLIENTS 
+			&& ps->legsAnimTimer < 300 + PLAYER_KNOCKDOWN_HOLD_EXTRA_TIME )
+		{
+			return qtrue;
+		}
+		*/
+		break;
+	case BOTH_GETUP1:
+	case BOTH_GETUP2:
+	case BOTH_GETUP3:
+	case BOTH_GETUP4:
+	case BOTH_GETUP5:
+	case BOTH_GETUP_CROUCH_F1:
+	case BOTH_GETUP_CROUCH_B1:
+	case BOTH_FORCE_GETUP_F1:
+	case BOTH_FORCE_GETUP_F2:
+	case BOTH_FORCE_GETUP_B1:
+	case BOTH_FORCE_GETUP_B2:
+	case BOTH_FORCE_GETUP_B3:
+	case BOTH_FORCE_GETUP_B4:
+	case BOTH_FORCE_GETUP_B5:
+	case BOTH_FORCE_GETUP_B6:
+		if ( ps->legsAnimTimer > PM_AnimLength( g_entities[ps->clientNum].client->clientInfo.animFileIndex, (animNumber_t)ps->legsAnim )-400 )
+		{//still pretty much horizontal at this point
+			return qtrue;
+		}
+		break;
+	}
+
+	return qfalse;
+}
+
+qboolean PM_InSpecialDeathAnim( int anim )
+{
+	switch( pm->ps->legsAnim )
+	{
+	case BOTH_DEATH_ROLL:		//# Death anim from a roll
+	case BOTH_DEATH_FLIP:		//# Death anim from a flip
+	case BOTH_DEATH_SPIN_90_R:	//# Death anim when facing 90 degrees right
+	case BOTH_DEATH_SPIN_90_L:	//# Death anim when facing 90 degrees left
+	case BOTH_DEATH_SPIN_180:	//# Death anim when facing backwards
+	case BOTH_DEATH_LYING_UP:	//# Death anim when lying on back
+	case BOTH_DEATH_LYING_DN:	//# Death anim when lying on front
+	case BOTH_DEATH_FALLING_DN:	//# Death anim when falling on face
+	case BOTH_DEATH_FALLING_UP:	//# Death anim when falling on back
+	case BOTH_DEATH_CROUCHED:	//# Death anim when crouched
+		return qtrue;
+		break;
+	default:
+		return qfalse;
+		break;
+	}
+}
+
+qboolean PM_InDeathAnim ( void )
+{//Purposely does not cover stumbledeath and falldeath...
+	switch( pm->ps->legsAnim )
+	{
+	case BOTH_DEATH1:		//# First Death anim
+	case BOTH_DEATH2:			//# Second Death anim
+	case BOTH_DEATH3:			//# Third Death anim
+	case BOTH_DEATH4:			//# Fourth Death anim
+	case BOTH_DEATH5:			//# Fifth Death anim
+	case BOTH_DEATH6:			//# Sixth Death anim
+	case BOTH_DEATH7:			//# Seventh Death anim
+	case BOTH_DEATH8:			//# 
+	case BOTH_DEATH9:			//# 
+	case BOTH_DEATH10:			//# 
+	case BOTH_DEATH11:			//#
+	case BOTH_DEATH12:			//# 
+	case BOTH_DEATH13:			//# 
+	case BOTH_DEATH14:			//# 
+	case BOTH_DEATH14_UNGRIP:	//# Desann's end death (cin #35)
+	case BOTH_DEATH14_SITUP:		//# Tavion sitting up after having been thrown (cin #23)
+	case BOTH_DEATH15:			//# 
+	case BOTH_DEATH16:			//# 
+	case BOTH_DEATH17:			//# 
+	case BOTH_DEATH18:			//# 
+	case BOTH_DEATH19:			//# 
+	case BOTH_DEATH20:			//# 
+	case BOTH_DEATH21:			//# 
+	case BOTH_DEATH22:			//# 
+	case BOTH_DEATH23:			//# 
+	case BOTH_DEATH24:			//# 
+	case BOTH_DEATH25:			//# 
+
+	case BOTH_DEATHFORWARD1:		//# First Death in which they get thrown forward
+	case BOTH_DEATHFORWARD2:		//# Second Death in which they get thrown forward
+	case BOTH_DEATHFORWARD3:		//# Tavion's falling in cin# 23
+	case BOTH_DEATHBACKWARD1:	//# First Death in which they get thrown backward
+	case BOTH_DEATHBACKWARD2:	//# Second Death in which they get thrown backward
+
+	case BOTH_DEATH1IDLE:		//# Idle while close to death
+	case BOTH_LYINGDEATH1:		//# Death to play when killed lying down
+	case BOTH_STUMBLEDEATH1:		//# Stumble forward and fall face first death
+	case BOTH_FALLDEATH1:		//# Fall forward off a high cliff and splat death - start
+	case BOTH_FALLDEATH1INAIR:	//# Fall forward off a high cliff and splat death - loop
+	case BOTH_FALLDEATH1LAND:	//# Fall forward off a high cliff and splat death - hit bottom
+	//# #sep case BOTH_ DEAD POSES # Should be last frame of corresponding previous anims
+	case BOTH_DEAD1:				//# First Death finished pose
+	case BOTH_DEAD2:				//# Second Death finished pose
+	case BOTH_DEAD3:				//# Third Death finished pose
+	case BOTH_DEAD4:				//# Fourth Death finished pose
+	case BOTH_DEAD5:				//# Fifth Death finished pose
+	case BOTH_DEAD6:				//# Sixth Death finished pose
+	case BOTH_DEAD7:				//# Seventh Death finished pose
+	case BOTH_DEAD8:				//# 
+	case BOTH_DEAD9:				//# 
+	case BOTH_DEAD10:			//# 
+	case BOTH_DEAD11:			//#
+	case BOTH_DEAD12:			//# 
+	case BOTH_DEAD13:			//# 
+	case BOTH_DEAD14:			//# 
+	case BOTH_DEAD15:			//# 
+	case BOTH_DEAD16:			//# 
+	case BOTH_DEAD17:			//# 
+	case BOTH_DEAD18:			//# 
+	case BOTH_DEAD19:			//# 
+	case BOTH_DEAD20:			//# 
+	case BOTH_DEAD21:			//# 
+	case BOTH_DEAD22:			//# 
+	case BOTH_DEAD23:			//# 
+	case BOTH_DEAD24:			//# 
+	case BOTH_DEAD25:			//# 
+	case BOTH_DEADFORWARD1:		//# First thrown forward death finished pose
+	case BOTH_DEADFORWARD2:		//# Second thrown forward death finished pose
+	case BOTH_DEADBACKWARD1:		//# First thrown backward death finished pose
+	case BOTH_DEADBACKWARD2:		//# Second thrown backward death finished pose
+	case BOTH_LYINGDEAD1:		//# Killed lying down death finished pose
+	case BOTH_STUMBLEDEAD1:		//# Stumble forward death finished pose
+	case BOTH_FALLDEAD1LAND:		//# Fall forward and splat death finished pose
+	//# #sep case BOTH_ DEAD TWITCH/FLOP # React to being shot from death poses
+	case BOTH_DEADFLOP1:		//# React to being shot from First Death finished pose
+	case BOTH_DEADFLOP2:		//# React to being shot from Second Death finished pose
+	case BOTH_DISMEMBER_HEAD1:	//#
+	case BOTH_DISMEMBER_TORSO1:	//#
+	case BOTH_DISMEMBER_LLEG:	//#
+	case BOTH_DISMEMBER_RLEG:	//#
+	case BOTH_DISMEMBER_RARM:	//#
+	case BOTH_DISMEMBER_LARM:	//#
+		return qtrue;
+		break;
+	default:
+		return PM_InSpecialDeathAnim( pm->ps->legsAnim );
+		break;
+	}
+}
+
+qboolean PM_InCartwheel( int anim )
+{
+	switch ( anim )
+	{
+	case BOTH_ARIAL_LEFT:
+	case BOTH_ARIAL_RIGHT:
+	case BOTH_ARIAL_F1:
+	case BOTH_CARTWHEEL_LEFT:
+	case BOTH_CARTWHEEL_RIGHT:
+		return qtrue;
+		break;
+	}
+	return qfalse;
+}
+
+qboolean PM_InButterfly( int anim )
+{
+	switch ( anim )
+	{
+	case BOTH_BUTTERFLY_LEFT:
+	case BOTH_BUTTERFLY_RIGHT:
+	case BOTH_BUTTERFLY_FL1:
+	case BOTH_BUTTERFLY_FR1:
+		return qtrue;
+		break;
+	}
+	return qfalse;
+}
+
+qboolean PM_StandingAnim( int anim )
+{//NOTE: does not check idles or special (cinematic) stands
+	switch ( anim )
+	{
+	case BOTH_STAND1:
+	case BOTH_STAND2:
+	case BOTH_STAND3:
+	case BOTH_STAND4:
+	case BOTH_ATTACK3:
+		return qtrue;
+		break;
+	}
+	return qfalse;
+}
+
+qboolean PM_InAirKickingAnim( int anim )
+{
+	switch ( anim )
+	{
+	case BOTH_A7_KICK_F_AIR:
+	case BOTH_A7_KICK_B_AIR:
+	case BOTH_A7_KICK_R_AIR:
+	case BOTH_A7_KICK_L_AIR:
+		return qtrue;
+	}
+	return qfalse;
+}
+
+qboolean PM_KickingAnim( int anim )
+{
+	switch ( anim )
+	{
+	case BOTH_A7_KICK_F:
+	case BOTH_A7_KICK_B:
+	case BOTH_A7_KICK_R:
+	case BOTH_A7_KICK_L:
+	case BOTH_A7_KICK_S:
+	case BOTH_A7_KICK_BF:
+	case BOTH_A7_KICK_RL:
+	//NOT a kick, but acts like one:
+	case BOTH_A7_HILT:
+	//NOT kicks, but do kick traces anyway
+	case BOTH_GETUP_BROLL_B:
+	case BOTH_GETUP_BROLL_F:
+	case BOTH_GETUP_FROLL_B:
+	case BOTH_GETUP_FROLL_F:
+		return qtrue;
+		break;
+	default:
+		return PM_InAirKickingAnim( anim );
+		break;
+	}
+	//return qfalse;
+}
+
+qboolean PM_StabDownAnim( int anim )
+{
+	switch ( anim )
+	{
+	case BOTH_STABDOWN:
+	case BOTH_STABDOWN_STAFF:
+	case BOTH_STABDOWN_DUAL:
+		return qtrue;
+	}
+	return qfalse;
+}
+
+qboolean PM_GoingToAttackDown( playerState_t *ps )
+{
+	if ( PM_StabDownAnim( ps->torsoAnim )//stabbing downward
+		|| ps->saberMove == LS_A_LUNGE//lunge
+		|| ps->saberMove == LS_A_JUMP_T__B_//death from above
+		|| ps->saberMove == LS_A_T2B//attacking top to bottom
+		|| ps->saberMove == LS_S_T2B//starting at attack downward
+		|| (PM_SaberInTransition( ps->saberMove ) && saberMoveData[ps->saberMove].endQuad == Q_T) )//transitioning to a top to bottom attack
+	{
+		return qtrue;
+	}
+	return qfalse;
+}
+		
+qboolean PM_ForceUsingSaberAnim( int anim )
+{//saber/acrobatic anims that should prevent you from recharging force power while you're in them...
+	switch ( anim )
+	{
+	case BOTH_JUMPFLIPSLASHDOWN1:
+	case BOTH_JUMPFLIPSTABDOWN:
+	case BOTH_FORCELEAP2_T__B_:
+	case BOTH_JUMPATTACK6:
+	case BOTH_JUMPATTACK7:
+	case BOTH_FORCELONGLEAP_START:
+	case BOTH_FORCELONGLEAP_ATTACK:
+	case BOTH_FORCEWALLRUNFLIP_START:
+	case BOTH_FORCEWALLRUNFLIP_END:
+	case BOTH_FORCEWALLRUNFLIP_ALT:
+	case BOTH_FORCEWALLREBOUND_FORWARD:
+	case BOTH_FORCEWALLREBOUND_LEFT:
+	case BOTH_FORCEWALLREBOUND_BACK:
+	case BOTH_FORCEWALLREBOUND_RIGHT:
+	case BOTH_FLIP_ATTACK7:
+	case BOTH_FLIP_HOLD7:
+	case BOTH_FLIP_LAND:
+	case BOTH_PULL_IMPALE_STAB:
+	case BOTH_PULL_IMPALE_SWING:
+	case BOTH_A6_SABERPROTECT:
+	case BOTH_A7_SOULCAL:
+	case BOTH_A1_SPECIAL:
+	case BOTH_A2_SPECIAL:
+	case BOTH_A3_SPECIAL:
+	case BOTH_ARIAL_LEFT:
+	case BOTH_ARIAL_RIGHT:
+	case BOTH_CARTWHEEL_LEFT:
+	case BOTH_CARTWHEEL_RIGHT:
+	case BOTH_FLIP_LEFT:
+	case BOTH_FLIP_BACK1:
+	case BOTH_FLIP_BACK2:
+	case BOTH_FLIP_BACK3:
+	case BOTH_ALORA_FLIP_B:
+	case BOTH_BUTTERFLY_LEFT:
+	case BOTH_BUTTERFLY_RIGHT:
+	case BOTH_BUTTERFLY_FL1:
+	case BOTH_BUTTERFLY_FR1:
+	case BOTH_WALL_RUN_RIGHT:
+	case BOTH_WALL_RUN_RIGHT_FLIP:
+	case BOTH_WALL_RUN_RIGHT_STOP: 
+	case BOTH_WALL_RUN_LEFT:
+	case BOTH_WALL_RUN_LEFT_FLIP:
+	case BOTH_WALL_RUN_LEFT_STOP: 
+	case BOTH_WALL_FLIP_RIGHT:
+	case BOTH_WALL_FLIP_LEFT:
+	case BOTH_FORCEJUMP1:		
+	case BOTH_FORCEINAIR1:		
+	case BOTH_FORCELAND1:		
+	case BOTH_FORCEJUMPBACK1:	
+	case BOTH_FORCEINAIRBACK1:	
+	case BOTH_FORCELANDBACK1:	
+	case BOTH_FORCEJUMPLEFT1:	
+	case BOTH_FORCEINAIRLEFT1:	
+	case BOTH_FORCELANDLEFT1:	
+	case BOTH_FORCEJUMPRIGHT1:	
+	case BOTH_FORCEINAIRRIGHT1:	
+	case BOTH_FORCELANDRIGHT1:	
+	case BOTH_FLIP_F:			
+	case BOTH_FLIP_B:			
+	case BOTH_FLIP_L:			
+	case BOTH_FLIP_R:			
+	case BOTH_ALORA_FLIP_1:
+	case BOTH_ALORA_FLIP_2:
+	case BOTH_ALORA_FLIP_3:
+	case BOTH_DODGE_FL:			
+	case BOTH_DODGE_FR:			
+	case BOTH_DODGE_BL:			
+	case BOTH_DODGE_BR:			
+	case BOTH_DODGE_L:			
+	case BOTH_DODGE_R:			
+	case BOTH_DODGE_HOLD_FL:
+	case BOTH_DODGE_HOLD_FR:
+	case BOTH_DODGE_HOLD_BL:
+	case BOTH_DODGE_HOLD_BR:
+	case BOTH_DODGE_HOLD_L:
+	case BOTH_DODGE_HOLD_R:
+	case BOTH_FORCE_GETUP_F1:	
+	case BOTH_FORCE_GETUP_F2:	
+	case BOTH_FORCE_GETUP_B1:	
+	case BOTH_FORCE_GETUP_B2:	
+	case BOTH_FORCE_GETUP_B3:	
+	case BOTH_FORCE_GETUP_B4:	
+	case BOTH_FORCE_GETUP_B5:	
+	case BOTH_FORCE_GETUP_B6:	
+	case BOTH_GETUP_BROLL_B:
+	case BOTH_GETUP_BROLL_F:
+	case BOTH_GETUP_BROLL_L:
+	case BOTH_GETUP_BROLL_R:
+	case BOTH_GETUP_FROLL_B:
+	case BOTH_GETUP_FROLL_F:
+	case BOTH_GETUP_FROLL_L:
+	case BOTH_GETUP_FROLL_R:
+	case BOTH_WALL_FLIP_BACK1:	
+	case BOTH_WALL_FLIP_BACK2:	
+	case BOTH_SPIN1:				
+	case BOTH_FJSS_TR_BL:		
+	case BOTH_FJSS_TL_BR:		
+	case BOTH_DEFLECTSLASH__R__L_FIN:
+	case BOTH_ARIAL_F1:
+		return qtrue;
+	}
+	return qfalse;
+}
+
+qboolean G_HasKnockdownAnims( gentity_t *ent )
+{
+	if ( PM_HasAnimation( ent, BOTH_KNOCKDOWN1 )
+		&& PM_HasAnimation( ent, BOTH_KNOCKDOWN2 )
+		&& PM_HasAnimation( ent, BOTH_KNOCKDOWN3 )
+		&& PM_HasAnimation( ent, BOTH_KNOCKDOWN4 )
+		&& PM_HasAnimation( ent, BOTH_KNOCKDOWN5 ) )
+	{
+		return qtrue;
+	}
+	return qfalse;
+}
+
+qboolean PM_InAttackRoll( int anim )
+{
+	switch ( anim )
+	{
+	case BOTH_GETUP_BROLL_B:
+	case BOTH_GETUP_BROLL_F:
+	case BOTH_GETUP_FROLL_B:
+	case BOTH_GETUP_FROLL_F:
+		return qtrue;
+	}
+	return qfalse;
+}
+
+qboolean PM_LockedAnim( int anim )
+{//anims that can *NEVER* be overridden, regardless
+	switch ( anim )
+	{
+	case BOTH_KYLE_PA_1:
+	case BOTH_KYLE_PA_2:
+	case BOTH_KYLE_PA_3:
+	case BOTH_PLAYER_PA_1:
+	case BOTH_PLAYER_PA_2:
+	case BOTH_PLAYER_PA_3:
+	case BOTH_PLAYER_PA_3_FLY:
+	case BOTH_TAVION_SCEPTERGROUND:
+	case BOTH_TAVION_SWORDPOWER:
+	case BOTH_SCEPTER_START:
+	case BOTH_SCEPTER_HOLD:
+	case BOTH_SCEPTER_STOP:
+	//grabbed by wampa
+	case BOTH_GRABBED:	//#
+	case BOTH_RELEASED:	//#	when Wampa drops player, transitions into fall on back
+	case BOTH_HANG_IDLE:	//#
+	case BOTH_HANG_ATTACK:	//#
+	case BOTH_HANG_PAIN:	//#
+		return qtrue;
+	}
+	return qfalse;
+}
+
+qboolean PM_SuperBreakLoseAnim( int anim )
+{
+	switch ( anim )
+	{
+	case BOTH_LK_S_DL_S_SB_1_L:	//super break I lost
+	case BOTH_LK_S_DL_T_SB_1_L:	//super break I lost
+	case BOTH_LK_S_ST_S_SB_1_L:	//super break I lost
+	case BOTH_LK_S_ST_T_SB_1_L:	//super break I lost
+	case BOTH_LK_S_S_S_SB_1_L:	//super break I lost
+	case BOTH_LK_S_S_T_SB_1_L:	//super break I lost
+	case BOTH_LK_DL_DL_S_SB_1_L:	//super break I lost
+	case BOTH_LK_DL_DL_T_SB_1_L:	//super break I lost
+	case BOTH_LK_DL_ST_S_SB_1_L:	//super break I lost
+	case BOTH_LK_DL_ST_T_SB_1_L:	//super break I lost
+	case BOTH_LK_DL_S_S_SB_1_L:	//super break I lost
+	case BOTH_LK_DL_S_T_SB_1_L:	//super break I lost
+	case BOTH_LK_ST_DL_S_SB_1_L:	//super break I lost
+	case BOTH_LK_ST_DL_T_SB_1_L:	//super break I lost
+	case BOTH_LK_ST_ST_S_SB_1_L:	//super break I lost
+	case BOTH_LK_ST_ST_T_SB_1_L:	//super break I lost
+	case BOTH_LK_ST_S_S_SB_1_L:	//super break I lost
+	case BOTH_LK_ST_S_T_SB_1_L:	//super break I lost
+		return qtrue;
+		break;
+	}
+	return qfalse;
+}
+
+qboolean PM_SuperBreakWinAnim( int anim )
+{
+	switch ( anim )
+	{
+	case BOTH_LK_S_DL_S_SB_1_W:	//super break I won
+	case BOTH_LK_S_DL_T_SB_1_W:	//super break I won
+	case BOTH_LK_S_ST_S_SB_1_W:	//super break I won
+	case BOTH_LK_S_ST_T_SB_1_W:	//super break I won
+	case BOTH_LK_S_S_S_SB_1_W:	//super break I won
+	case BOTH_LK_S_S_T_SB_1_W:	//super break I won
+	case BOTH_LK_DL_DL_S_SB_1_W:	//super break I won
+	case BOTH_LK_DL_DL_T_SB_1_W:	//super break I won
+	case BOTH_LK_DL_ST_S_SB_1_W:	//super break I won
+	case BOTH_LK_DL_ST_T_SB_1_W:	//super break I won
+	case BOTH_LK_DL_S_S_SB_1_W:	//super break I won
+	case BOTH_LK_DL_S_T_SB_1_W:	//super break I won
+	case BOTH_LK_ST_DL_S_SB_1_W:	//super break I won
+	case BOTH_LK_ST_DL_T_SB_1_W:	//super break I won
+	case BOTH_LK_ST_ST_S_SB_1_W:	//super break I won
+	case BOTH_LK_ST_ST_T_SB_1_W:	//super break I won
+	case BOTH_LK_ST_S_S_SB_1_W:	//super break I won
+	case BOTH_LK_ST_S_T_SB_1_W:	//super break I won
+		return qtrue;
+		break;
+	}
+	return qfalse;
+}
+
+qboolean PM_SaberLockBreakAnim( int anim )
+{
+	switch ( anim )
+	{
+	case BOTH_BF1BREAK:
+	case BOTH_BF2BREAK:
+	case BOTH_CWCIRCLEBREAK:
+	case BOTH_CCWCIRCLEBREAK:
+	case BOTH_LK_S_DL_S_B_1_L:	//normal break I lost
+	case BOTH_LK_S_DL_S_B_1_W:	//normal break I won
+	case BOTH_LK_S_DL_T_B_1_L:	//normal break I lost
+	case BOTH_LK_S_DL_T_B_1_W:	//normal break I won
+	case BOTH_LK_S_ST_S_B_1_L:	//normal break I lost
+	case BOTH_LK_S_ST_S_B_1_W:	//normal break I won
+	case BOTH_LK_S_ST_T_B_1_L:	//normal break I lost
+	case BOTH_LK_S_ST_T_B_1_W:	//normal break I won
+	case BOTH_LK_S_S_S_B_1_L:	//normal break I lost
+	case BOTH_LK_S_S_S_B_1_W:	//normal break I won
+	case BOTH_LK_S_S_T_B_1_L:	//normal break I lost
+	case BOTH_LK_S_S_T_B_1_W:	//normal break I won
+	case BOTH_LK_DL_DL_S_B_1_L:	//normal break I lost
+	case BOTH_LK_DL_DL_S_B_1_W:	//normal break I won
+	case BOTH_LK_DL_DL_T_B_1_L:	//normal break I lost
+	case BOTH_LK_DL_DL_T_B_1_W:	//normal break I won
+	case BOTH_LK_DL_ST_S_B_1_L:	//normal break I lost
+	case BOTH_LK_DL_ST_S_B_1_W:	//normal break I won
+	case BOTH_LK_DL_ST_T_B_1_L:	//normal break I lost
+	case BOTH_LK_DL_ST_T_B_1_W:	//normal break I won
+	case BOTH_LK_DL_S_S_B_1_L:	//normal break I lost
+	case BOTH_LK_DL_S_S_B_1_W:	//normal break I won
+	case BOTH_LK_DL_S_T_B_1_L:	//normal break I lost
+	case BOTH_LK_DL_S_T_B_1_W:	//normal break I won
+	case BOTH_LK_ST_DL_S_B_1_L:	//normal break I lost
+	case BOTH_LK_ST_DL_S_B_1_W:	//normal break I won
+	case BOTH_LK_ST_DL_T_B_1_L:	//normal break I lost
+	case BOTH_LK_ST_DL_T_B_1_W:	//normal break I won
+	case BOTH_LK_ST_ST_S_B_1_L:	//normal break I lost
+	case BOTH_LK_ST_ST_S_B_1_W:	//normal break I won
+	case BOTH_LK_ST_ST_T_B_1_L:	//normal break I lost
+	case BOTH_LK_ST_ST_T_B_1_W:	//normal break I won
+	case BOTH_LK_ST_S_S_B_1_L:	//normal break I lost
+	case BOTH_LK_ST_S_S_B_1_W:	//normal break I won
+	case BOTH_LK_ST_S_T_B_1_L:	//normal break I lost
+	case BOTH_LK_ST_S_T_B_1_W:	//normal break I won
+		return (PM_SuperBreakLoseAnim(anim)||PM_SuperBreakWinAnim(anim));
+		break;
+	}
+	return qfalse;
+}
+
+qboolean PM_GetupAnimNoMove( int legsAnim )
+{
+	switch( legsAnim )
+	{
+	case BOTH_GETUP1:
+	case BOTH_GETUP2:
+	case BOTH_GETUP3:
+	case BOTH_GETUP4:
+	case BOTH_GETUP5:
+	case BOTH_GETUP_CROUCH_F1:
+	case BOTH_GETUP_CROUCH_B1:
+	case BOTH_FORCE_GETUP_F1:
+	case BOTH_FORCE_GETUP_F2:
+	case BOTH_FORCE_GETUP_B1:
+	case BOTH_FORCE_GETUP_B2:
+	case BOTH_FORCE_GETUP_B3:
+	case BOTH_FORCE_GETUP_B4:
+	case BOTH_FORCE_GETUP_B5:
+	case BOTH_FORCE_GETUP_B6:
+		return qtrue;
+	}
+	return qfalse;
+}
+
+qboolean PM_KnockDownAnim( int anim )
+{
+	switch ( anim )
+	{
+	case BOTH_KNOCKDOWN1:
+	case BOTH_KNOCKDOWN2:
+	case BOTH_KNOCKDOWN3:
+	case BOTH_KNOCKDOWN4:
+	case BOTH_KNOCKDOWN5:
+	/*
+	//special anims:
+	case BOTH_RELEASED:
+	case BOTH_LK_DL_ST_T_SB_1_L:
+	case BOTH_PLAYER_PA_3_FLY:
+	*/
+		return qtrue;
+		break;
+	/*
+	default:
+		return PM_InGetUp( ps );
+		break;
+	*/
+	}
+	return qfalse;
+}
+
+qboolean PM_KnockDownAnimExtended( int anim )
+{
+	switch ( anim )
+	{
+	case BOTH_KNOCKDOWN1:
+	case BOTH_KNOCKDOWN2:
+	case BOTH_KNOCKDOWN3:
+	case BOTH_KNOCKDOWN4:
+	case BOTH_KNOCKDOWN5:
+	//special anims:
+	case BOTH_RELEASED:
+	case BOTH_LK_DL_ST_T_SB_1_L:
+	case BOTH_PLAYER_PA_3_FLY:
+		return qtrue;
+		break;
+	/*
+	default:
+		return PM_InGetUp( ps );
+		break;
+	*/
+	}
+	return qfalse;
+}
+
+qboolean PM_SaberInKata( saberMoveName_t saberMove )
+{
+	switch ( saberMove )
+	{
+	case LS_A1_SPECIAL:
+	case LS_A2_SPECIAL:
+	case LS_A3_SPECIAL:
+	case LS_DUAL_SPIN_PROTECT:
+	case LS_STAFF_SOULCAL:
+		return qtrue;
+	}
+	return qfalse;
+}
+
+qboolean PM_CanRollFromSoulCal( playerState_t *ps )
+{
+	if ( ps->legsAnim == BOTH_A7_SOULCAL
+		&& ps->legsAnimTimer < 700
+		&& ps->legsAnimTimer > 250 )
+	{
+		return qtrue;
+	}
+	return qfalse;
+}
+
+qboolean BG_FullBodyTauntAnim( int anim )
+{
+	switch ( anim )
+	{
+	case BOTH_GESTURE1:
+	case BOTH_DUAL_TAUNT:
+	case BOTH_STAFF_TAUNT:
+	case BOTH_BOW:
+	case BOTH_MEDITATE:
+	case BOTH_SHOWOFF_FAST:
+	case BOTH_SHOWOFF_MEDIUM:
+	case BOTH_SHOWOFF_STRONG:
+	case BOTH_SHOWOFF_DUAL:
+	case BOTH_SHOWOFF_STAFF:
+	case BOTH_VICTORY_FAST:
+	case BOTH_VICTORY_MEDIUM:
+	case BOTH_VICTORY_STRONG:
+	case BOTH_VICTORY_DUAL:
+	case BOTH_VICTORY_STAFF:
+		return qtrue;
+		break;
+	}
+	return qfalse;
+}
diff --git a/code/game/bg_pmove.cpp b/code/game/bg_pmove.cpp
new file mode 100644
index 0000000..34d8335
--- /dev/null
+++ b/code/game/bg_pmove.cpp
@@ -0,0 +1,15090 @@
+// this include must remain at the top of every bg_xxxx CPP file
+#include "common_headers.h"
+
+#include "../renderer/tr_public.h"
+
+
+// bg_pmove.c -- both games player movement code
+// takes a playerstate and a usercmd as input and returns a modifed playerstate
+
+// define GAME_INCLUDE so that g_public.h does not define the
+// short, server-visible gclient_t and gentity_t structures,
+// because we define the full size ones in this file
+
+#define	GAME_INCLUDE
+#include "q_shared.h"
+#include "g_shared.h"
+#include "bg_local.h"			   
+#include "g_local.h"			   
+#include "g_functions.h"
+#include "anims.h"
+#include "../cgame/cg_local.h"	// yeah I know this is naughty, but we're shipping soon...
+
+#include "wp_saber.h"
+#include "g_vehicles.h"
+#include <float.h>
+
+#ifdef _XBOX
+#include "../client/fffx.h"
+#endif
+
+extern qboolean G_DoDismemberment( gentity_t *self, vec3_t point, int mod, int damage, int hitLoc, qboolean force = qfalse );
+extern qboolean G_EntIsUnlockedDoor( int entityNum );
+extern qboolean G_EntIsDoor( int entityNum );
+extern qboolean InFront( vec3_t spot, vec3_t from, vec3_t fromAngles, float threshHold = 0.0f );
+extern void G_AddVoiceEvent( gentity_t *self, int event, int speakDebounceTime );
+extern	qboolean	Q3_TaskIDPending( gentity_t *ent, taskID_t taskType );
+extern qboolean WP_SaberLose( gentity_t *self, vec3_t throwDir );
+extern int Jedi_ReCalcParryTime( gentity_t *self, evasionType_t evasionType );
+extern qboolean PM_HasAnimation( gentity_t *ent, int animation );
+extern saberMoveName_t PM_SaberAnimTransitionMove( saberMoveName_t curmove, saberMoveName_t newmove );
+extern saberMoveName_t PM_AttackMoveForQuad( int quad );
+extern qboolean PM_SaberInTransition( int move );
+extern qboolean PM_SaberInTransitionAny( int move );
+extern qboolean PM_SaberInBounce( int move );
+extern qboolean PM_SaberInSpecialAttack( int anim );
+extern qboolean PM_SaberInAttack( int move );
+extern qboolean PM_InAnimForSaberMove( int anim, int saberMove );
+extern saberMoveName_t PM_SaberBounceForAttack( int move );
+extern saberMoveName_t PM_SaberAttackForMovement( int forwardmove, int rightmove, int curmove );
+extern saberMoveName_t PM_BrokenParryForParry( int move );
+extern saberMoveName_t PM_KnockawayForParry( int move );
+extern qboolean PM_SaberInParry( int move );
+extern qboolean PM_SaberInKnockaway( int move );
+extern qboolean PM_SaberInBrokenParry( int move );
+extern qboolean PM_SaberInReflect( int move );
+extern qboolean PM_SaberInIdle( int move );
+extern qboolean PM_SaberInStart( int move );
+extern qboolean PM_SaberInReturn( int move );
+extern qboolean PM_SaberKataDone( int curmove, int newmove );
+extern qboolean PM_SaberInSpecial( int move );
+extern qboolean PM_InDeathAnim ( void );
+extern qboolean PM_StandingAnim( int anim );
+extern qboolean PM_KickMove( int move );
+extern qboolean PM_KickingAnim( int anim );
+extern qboolean PM_InAirKickingAnim( int anim );
+extern qboolean PM_SuperBreakLoseAnim( int anim );
+extern qboolean PM_SuperBreakWinAnim( int anim );
+extern qboolean PM_InCartwheel( int anim );
+extern qboolean PM_InButterfly( int anim );
+extern qboolean PM_CanRollFromSoulCal( playerState_t *ps );
+extern saberMoveName_t PM_SaberFlipOverAttackMove( void );
+extern qboolean PM_CheckFlipOverAttackMove( qboolean checkEnemy );
+extern saberMoveName_t PM_SaberJumpForwardAttackMove( void );
+extern qboolean PM_CheckJumpForwardAttackMove( void );
+extern saberMoveName_t PM_SaberBackflipAttackMove( void );
+extern qboolean PM_CheckBackflipAttackMove( void );
+extern saberMoveName_t PM_SaberDualJumpAttackMove( void );
+extern qboolean PM_CheckDualJumpAttackMove( void );
+extern saberMoveName_t PM_SaberLungeAttackMove( qboolean fallbackToNormalLunge );
+extern qboolean PM_CheckLungeAttackMove( void );
+extern qboolean PM_InSecondaryStyle( void );
+extern qboolean PM_KnockDownAnimExtended( int anim );
+extern void G_StartMatrixEffect( gentity_t *ent, int meFlags = 0, int length = 1000, float timeScale = 0.0f, int spinTime = 0 );
+extern void WP_ForcePowerStop( gentity_t *self, forcePowers_t forcePower );
+extern qboolean WP_ForcePowerAvailable( gentity_t *self, forcePowers_t forcePower, int overrideAmt );
+extern void WP_ForcePowerDrain( gentity_t *self, forcePowers_t forcePower, int overrideAmt );
+extern float G_ForceWallJumpStrength( void );
+extern int G_CheckRollSafety( gentity_t *self, int anim, float testDist );
+extern saberMoveName_t PM_CheckDualSpinProtect( void );
+extern saberMoveName_t PM_CheckPullAttack( void );
+extern qboolean JET_Flying( gentity_t *self );
+extern void JET_FlyStart( gentity_t *self );
+extern void JET_FlyStop( gentity_t *self );
+extern qboolean PM_LockedAnim( int anim );
+extern qboolean G_TryingKataAttack( gentity_t *self, usercmd_t *cmd );
+extern qboolean G_TryingCartwheel( gentity_t *self, usercmd_t *cmd );
+extern qboolean G_TryingSpecial( gentity_t *self, usercmd_t *cmd );
+extern qboolean G_TryingJumpAttack( gentity_t *self, usercmd_t *cmd );
+extern qboolean G_TryingJumpForwardAttack( gentity_t *self, usercmd_t *cmd );
+extern void WP_SaberSwingSound( gentity_t *ent, int saberNum, swingType_t swingType );
+
+qboolean PM_InKnockDown( playerState_t *ps );
+qboolean PM_InKnockDownOnGround( playerState_t *ps );
+qboolean PM_InGetUp( playerState_t *ps );
+qboolean PM_InRoll( playerState_t *ps );
+qboolean PM_SpinningSaberAnim( int anim );
+qboolean PM_GettingUpFromKnockDown( float standheight, float crouchheight );
+qboolean PM_SpinningAnim( int anim );
+qboolean PM_FlippingAnim( int anim );
+qboolean PM_PainAnim( int anim );
+qboolean PM_RollingAnim( int anim );
+qboolean PM_SwimmingAnim( int anim );
+qboolean PM_InReboundJump( int anim );
+qboolean PM_ForceJumpingAnim( int anim );
+void PM_CmdForRoll( playerState_t *ps, usercmd_t *pCmd );
+
+extern int parryDebounce[];
+extern qboolean cg_usingInFrontOf;
+extern qboolean		player_locked;
+extern qboolean		MatrixMode;
+qboolean		waterForceJump;
+extern cvar_t	*g_timescale;
+extern cvar_t	*g_speederControlScheme;
+extern cvar_t	*d_slowmodeath;
+extern cvar_t	*g_debugMelee;
+extern cvar_t	*g_saberNewControlScheme;
+extern cvar_t	*g_stepSlideFix;
+
+static void PM_SetWaterLevelAtPoint( vec3_t org, int *waterlevel, int *watertype );
+
+#define		FLY_NONE	0
+#define		FLY_NORMAL	1
+#define		FLY_VEHICLE	2
+#define		FLY_HOVER	3
+int			Flying = FLY_NONE;
+
+pmove_t		*pm;
+pml_t		pml;
+
+// movement parameters
+const float	pm_stopspeed = 100.0f;
+const float	pm_duckScale = 0.50f;
+const float	pm_swimScale = 0.50f;
+float	pm_ladderScale = 0.7f;
+
+const float	pm_vehicleaccelerate = 36.0f;
+const float	pm_accelerate = 12.0f;
+const float	pm_airaccelerate = 4.0f;
+const float	pm_wateraccelerate = 4.0f;
+const float	pm_flyaccelerate = 8.0f;
+
+const float	pm_friction = 6.0f;
+const float	pm_waterfriction = 1.0f;
+const float	pm_flightfriction = 3.0f;
+
+const float	pm_frictionModifier	= 3.0f;	//Used for "careful" mode (when pressing use)
+const float pm_airDecelRate = 1.35f;	//Used for air decelleration away from current movement velocity
+
+int	c_pmove = 0;
+
+extern void PM_SetTorsoAnimTimer( gentity_t *ent, int *torsoAnimTimer, int time );
+extern void PM_SetLegsAnimTimer( gentity_t *ent, int *legsAnimTimer, int time );
+//extern void PM_SetAnim(pmove_t	*pm,int setAnimParts,int anim,int setAnimFlags);
+extern void PM_TorsoAnimation( void );
+extern int PM_TorsoAnimForFrame( gentity_t *ent, int torsoFrame );
+extern int PM_AnimLength( int index, animNumber_t anim );
+extern qboolean PM_InDeathAnim ( void );
+extern qboolean PM_InOnGroundAnim ( playerState_t *ps );
+extern	weaponInfo_t	cg_weapons[MAX_WEAPONS];
+extern int PM_PickAnim( gentity_t *self, int minAnim, int maxAnim );
+
+extern void DoImpact( gentity_t *self, gentity_t *other, qboolean damageSelf, trace_t *trace );
+
+#define	PHASER_RECHARGE_TIME	100
+extern saberMoveName_t transitionMove[Q_NUM_QUADS][Q_NUM_QUADS];
+
+extern Vehicle_t *G_IsRidingVehicle( gentity_t *ent );
+Vehicle_t *PM_RidingVehicle( void )
+{
+	return (G_IsRidingVehicle( pm->gent ));
+}
+
+extern qboolean G_ControlledByPlayer( gentity_t *self );
+qboolean PM_ControlledByPlayer( void )
+{
+	return G_ControlledByPlayer( pm->gent );
+}
+
+qboolean BG_UnrestrainedPitchRoll( playerState_t *ps, Vehicle_t *pVeh )
+{
+/*
+	if ( 0 && ps->clientNum < MAX_CLIENTS //real client
+		&& ps->m_iVehicleNum//in a vehicle
+		&& pVeh //valid vehicle data pointer
+		&& pVeh->m_pVehicleInfo//valid vehicle info
+		&& pVeh->m_pVehicleInfo->type == VH_FIGHTER )//fighter
+		//FIXME: specify per vehicle instead of assuming true for all fighters
+		//FIXME: map/server setting?
+	{//can roll and pitch without limitation!
+		return qtrue;
+	}*/
+	return qfalse;
+}
+
+
+/*
+===============
+PM_AddEvent
+
+===============
+*/
+void PM_AddEvent( int newEvent ) 
+{
+	AddEventToPlayerstate( newEvent, 0, pm->ps );
+}
+
+qboolean PM_PredictJumpSafe( vec3_t jumpHorizDir, float jumpHorizSpeed, float jumpVertSpeed, int predictTimeLength )
+{
+	return qtrue;
+}
+
+
+void PM_GrabWallForJump( int anim )
+{//NOTE!!! assumes an appropriate anim is being passed in!!!
+	PM_SetAnim( pm, SETANIM_BOTH, anim, SETANIM_FLAG_RESTART|SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD, 0 );
+	PM_AddEvent( EV_JUMP );//make sound for grab
+	pm->ps->pm_flags |= PMF_STUCK_TO_WALL;
+}
+
+qboolean PM_CheckGrabWall( trace_t *trace )
+{
+	if ( !pm->gent || !pm->gent->client )
+	{
+		return qfalse;
+	}
+	if ( pm->gent->health <= 0 )
+	{//must be alive
+		return qfalse;
+	}
+	if ( pm->gent->client->ps.groundEntityNum != ENTITYNUM_NONE )
+	{//must be in air
+		return qfalse;
+	}
+	if ( trace->plane.normal[2] != 0 )
+	{//must be a flat wall
+		return qfalse;
+	}
+	if ( !trace->plane.normal[0] && !trace->plane.normal[1] )
+	{//invalid normal
+		return qfalse;
+	}
+	if ( (trace->contents&(CONTENTS_PLAYERCLIP|CONTENTS_MONSTERCLIP)) )
+	{//can't jump off of clip brushes
+		return qfalse;
+	}
+	if ( pm->gent->client->ps.forcePowerLevel[FP_LEVITATION] < FORCE_LEVEL_1 )
+	{//must have at least FJ 1
+		return qfalse;
+	}
+	if ( (pm->ps->clientNum < MAX_CLIENTS||PM_ControlledByPlayer())
+		&& pm->gent->client->ps.forcePowerLevel[FP_LEVITATION] < FORCE_LEVEL_3 )
+	{//player must have force jump 3
+		return qfalse;
+	}
+	if ( (pm->ps->clientNum < MAX_CLIENTS||PM_ControlledByPlayer()) )
+	{//player
+		//only if we were in a longjump
+		if ( pm->ps->legsAnim != BOTH_FORCELONGLEAP_START
+			&& pm->ps->legsAnim != BOTH_FORCELONGLEAP_ATTACK )
+		{
+			return qfalse;
+		}
+		//hit a flat wall during our long jump, see if we should grab it
+		vec3_t moveDir;
+		VectorCopy( pm->ps->velocity, moveDir );
+		VectorNormalize( moveDir );
+		if ( DotProduct( moveDir, trace->plane.normal ) > -0.65f )
+		{//not enough of a direct impact, just slide off
+			return qfalse;
+		}
+		if ( fabs(trace->plane.normal[2]) > MAX_WALL_GRAB_SLOPE )
+		{
+			return qfalse;
+		}
+		//grab it!
+		//FIXME: stop Matrix effect!
+		VectorClear( pm->ps->velocity );
+		//FIXME: stop slidemove!
+		//NOTE: we know it's forward, so...
+        PM_GrabWallForJump( BOTH_FORCEWALLREBOUND_FORWARD );
+		return qtrue;
+	}
+	else
+	{//NPCs
+		if ( PM_InReboundJump( pm->ps->legsAnim ) )
+		{//already in a rebound!
+			return qfalse;
+		}
+		if ( (pm->ps->eFlags&EF_FORCE_GRIPPED) )
+		{//being gripped!
+			return qfalse;
+		}
+		/*
+		if ( pm->gent->painDebounceTime > level.time )
+		{//can't move!
+			return qfalse;
+		}
+		if ( (pm->ps->pm_flags&PMF_TIME_KNOCKBACK) )
+		{//being thrown back!
+			return qfalse;
+		}
+		*/
+		if ( pm->gent->NPC && (pm->gent->NPC->aiFlags&NPCAI_DIE_ON_IMPACT) )
+		{//faling to our death!
+			return qfalse;
+		}
+		//FIXME: random chance, based on skill/rank?
+		if ( pm->ps->legsAnim != BOTH_FORCELONGLEAP_START
+			&& pm->ps->legsAnim != BOTH_FORCELONGLEAP_ATTACK )
+		{//not in a long-jump
+			if ( !pm->gent->enemy )
+			{//no enemy
+				return qfalse;
+			}
+			else
+			{//see if the enemy is in the direction of the wall or above us
+				//if ( pm->gent->enemy->currentOrigin[2] < (pm->ps->origin[2]-128) )
+				{//enemy is way below us
+					vec3_t enemyDir;
+					VectorSubtract( pm->gent->enemy->currentOrigin, pm->ps->origin, enemyDir );
+					enemyDir[2] = 0;
+					VectorNormalize( enemyDir );
+					if ( DotProduct( enemyDir, trace->plane.normal ) < 0.65f )
+					{//jumping off this wall would not launch me in the general direction of my enemy
+						return qfalse;
+					}
+				}
+			}
+		}
+		//FIXME: check for ground close beneath us?
+		//FIXME: check for obstructions in the dir we're going to jump 
+		//		- including "do not enter" brushes!
+		//hit a flat wall during our long jump, see if we should grab it
+		vec3_t moveDir;
+		VectorCopy( pm->ps->velocity, moveDir );
+		VectorNormalize( moveDir );
+		if ( DotProduct( moveDir, trace->plane.normal ) > -0.65f )
+		{//not enough of a direct impact, just slide off
+			return qfalse;
+		}
+
+		//Okay, now see if jumping off this thing would send us into a do not enter brush
+		if ( !PM_PredictJumpSafe( trace->plane.normal, JUMP_OFF_WALL_SPEED, G_ForceWallJumpStrength(), 1500 ) )
+		{//we would hit a do not enter brush, so don't grab the wall
+			return qfalse;
+		}
+
+		//grab it!
+		//Pick the proper anim
+		int anim = BOTH_FORCEWALLREBOUND_FORWARD;
+		vec3_t	facingAngles, wallDir, fwdDir, rtDir;
+		VectorSubtract( trace->endpos, pm->gent->lastOrigin, wallDir );
+		wallDir[2] = 0;
+		VectorNormalize( wallDir );
+		VectorSet( facingAngles, 0, pm->ps->viewangles[YAW], 0 );
+		AngleVectors( facingAngles, fwdDir, rtDir, NULL );
+		float fDot = DotProduct( fwdDir, wallDir );
+		if ( fabs( fDot ) >= 0.5f )
+		{//hit a wall in front/behind
+			if ( fDot > 0.0f )
+			{//in front
+				anim = BOTH_FORCEWALLREBOUND_FORWARD;
+			}
+			else
+			{//behind
+				anim = BOTH_FORCEWALLREBOUND_BACK;
+			}
+		}
+		else if ( DotProduct( rtDir, wallDir ) > 0 )
+		{//hit a wall on the right
+			anim = BOTH_FORCEWALLREBOUND_RIGHT;
+		}
+		else
+		{//hit a wall on the left
+			anim = BOTH_FORCEWALLREBOUND_LEFT;
+		}
+		VectorClear( pm->ps->velocity );
+		//FIXME: stop slidemove!
+        PM_GrabWallForJump( anim );
+		return qtrue;
+	}
+	//return qfalse;
+}
+/*
+===============
+qboolean PM_ClientImpact( trace_t *trace, qboolean damageSelf )
+
+===============
+*/
+qboolean PM_ClientImpact( trace_t *trace, qboolean damageSelf )
+{
+	gentity_t	*traceEnt;
+	int			otherEntityNum = trace->entityNum;
+
+	if ( !pm->gent )
+	{
+		return qfalse;
+	}
+
+	traceEnt = &g_entities[otherEntityNum];
+
+	if ( otherEntityNum == ENTITYNUM_WORLD
+		|| (traceEnt->bmodel && traceEnt->s.pos.trType == TR_STATIONARY ) )
+	{//hit world or a non-moving brush
+		if ( PM_CheckGrabWall( trace ) )
+		{//stopped on the wall
+			return qtrue;
+		}
+	}
+
+	if( (VectorLength( pm->ps->velocity )*(pm->gent->mass/10)) >= 100 && (pm->gent->client->NPC_class == CLASS_VEHICLE || pm->ps->lastOnGround+100<level.time) )//was 300 ||(other->material>=MAT_GLASS&&pm->gent->lastImpact+100<=level.time))
+	{
+		DoImpact( pm->gent, &g_entities[otherEntityNum], damageSelf, trace );
+	}
+
+	if ( otherEntityNum >= ENTITYNUM_WORLD )
+	{
+		return qfalse;
+	}
+
+	if ( !traceEnt || !(traceEnt->contents&pm->tracemask) )
+	{//it's dead or not in my way anymore
+		return qtrue;
+	}
+
+	return qfalse;
+}
+/*
+===============
+PM_AddTouchEnt
+===============
+*/
+void PM_AddTouchEnt( int entityNum ) {
+	int		i;
+
+	if ( entityNum == ENTITYNUM_WORLD ) {
+		return;
+	}
+	if ( pm->numtouch == MAXTOUCH ) {
+		return;
+	}
+
+	// see if it is already added
+	for ( i = 0 ; i < pm->numtouch ; i++ ) {
+		if ( pm->touchents[ i ] == entityNum ) {
+			return;
+		}
+	}
+
+	// add it
+	pm->touchents[pm->numtouch] = entityNum;
+	pm->numtouch++;
+}
+
+
+
+
+/*
+==================
+PM_ClipVelocity
+
+Slide off of the impacting surface
+
+  This will pull you down onto slopes if heading away from
+  them and push you up them as you go up them.
+  Also stops you when you hit walls.
+
+==================
+*/
+void PM_ClipVelocity( vec3_t in, vec3_t normal, vec3_t out, float overbounce ) {
+	float	backoff;
+	float	change;
+	float	oldInZ;
+	int		i;
+	
+	if ( (pm->ps->pm_flags&PMF_STUCK_TO_WALL) )
+	{//no sliding!
+		VectorCopy( in, out );
+		return;
+	}
+	oldInZ = in[2];
+
+	backoff = DotProduct (in, normal);
+	
+	if ( backoff < 0 ) {
+		backoff *= overbounce;
+	} else {
+		backoff /= overbounce;
+	}
+
+	for ( i=0 ; i<3 ; i++ ) 
+	{
+		change = normal[i]*backoff;
+		/*
+		if ( i == 2 && Flying == FLY_HOVER && change > 0 )
+		{//don't pull a hovercraft down
+			change = 0;
+		}
+		else
+		*/
+		{
+			out[i] = in[i] - change;
+		}
+	}
+	if ( g_stepSlideFix->integer )
+	{
+		if ( pm->ps->clientNum < MAX_CLIENTS//normal player
+			&& normal[2] < MIN_WALK_NORMAL )//sliding against a steep slope
+		{
+			if ( pm->ps->groundEntityNum != ENTITYNUM_NONE )//on the ground
+			{//if walking on the ground, don't slide up slopes that are too steep to walk on
+				out[2] = oldInZ;
+			}
+		}
+	}
+}
+
+
+/*
+==================
+PM_Friction
+
+Handles both ground friction and water friction
+==================
+*/
+static void PM_Friction( void ) {
+	vec3_t	vec;
+	float	*vel;
+	float	speed, newspeed, control;
+	float	drop, friction = pm->ps->friction;
+	
+	vel = pm->ps->velocity;
+	
+	VectorCopy( vel, vec );
+	if ( pml.walking ) {
+		vec[2] = 0;	// ignore slope movement
+	}
+
+	speed = VectorLength(vec);
+	if (speed < 1) {
+		vel[0] = 0;
+		vel[1] = 0;		// allow sinking underwater
+		// FIXME: still have z friction underwater?
+		return;
+	}
+
+	drop = 0;
+
+	// apply ground friction, even if on ladder
+	if ( pm->gent 
+		&& pm->gent->client 
+		&& pm->gent->client->NPC_class == CLASS_VEHICLE && pm->gent->m_pVehicle
+		&& pm->gent->m_pVehicle->m_pVehicleInfo->type != VH_ANIMAL )
+	{
+		friction = pm->gent->m_pVehicle->m_pVehicleInfo->friction;
+
+		if ( pm->gent->m_pVehicle && pm->gent->m_pVehicle->m_pVehicleInfo->hoverHeight > 0 )
+		{//in a hovering vehicle, have air control
+			if ( pm->gent->m_pVehicle->m_ulFlags & VEH_FLYING )
+			{
+				friction = 0.10f;
+			}
+		}
+
+		if ( !(pm->ps->pm_flags & PMF_TIME_KNOCKBACK) && !(pm->ps->pm_flags & PMF_TIME_NOFRICTION) ) 
+		{
+			control = speed < pm_stopspeed ? pm_stopspeed : speed;
+			drop += control*friction*pml.frametime;
+			/*
+			if ( Flying == FLY_HOVER )
+			{
+				if ( pm->cmd.rightmove )
+				{//if turning, increase friction
+					control *= 2.0f;
+				}
+				if ( pm->ps->groundEntityNum < ENTITYNUM_NONE ) 
+				{//on the ground
+					drop += control*friction*pml.frametime;
+				}
+				else if ( pml.groundPlane )
+				{//on a slope
+					drop += control*friction*2.0f*pml.frametime;
+				}
+				else
+				{//in air
+					drop += control*2.0f*friction*pml.frametime;
+				}
+			}
+			*/
+		}
+	}
+	else if ( Flying != FLY_NORMAL )
+	{
+		if ( (pm->watertype & CONTENTS_LADDER) || pm->waterlevel <= 1 ) 
+		{
+			if ( (pm->watertype & CONTENTS_LADDER) || (pml.walking && !(pml.groundTrace.surfaceFlags & SURF_SLICK)) ) 
+			{
+				// if getting knocked back, no friction	
+				if ( !(pm->ps->pm_flags & PMF_TIME_KNOCKBACK) && !(pm->ps->pm_flags & PMF_TIME_NOFRICTION) ) 
+				{
+					if ( pm->ps->legsAnim == BOTH_FORCELONGLEAP_START
+						|| pm->ps->legsAnim == BOTH_FORCELONGLEAP_ATTACK
+						|| pm->ps->legsAnim == BOTH_FORCELONGLEAP_LAND )
+					{//super forward jump
+						if ( pm->ps->groundEntityNum != ENTITYNUM_NONE )
+						{//not in air
+							if ( pm->cmd.forwardmove < 0 )
+							{//trying to hold back some
+								friction *= 0.5f;//0.25f;
+							}
+							else
+							{//free slide
+								friction *= 0.2f;//0.1f;
+							}
+							pm->cmd.forwardmove = pm->cmd.rightmove = 0;
+							if ( pml.groundPlane && pm->ps->legsAnim == BOTH_FORCELONGLEAP_LAND )
+							{
+								//slide effect
+								G_PlayEffect( "env/slide_dust", pml.groundTrace.endpos, pml.groundTrace.plane.normal );
+								//FIXME: slide sound
+							}
+						}
+					}
+					/*
+					else if ( pm->cmd.buttons & BUTTON_USE )
+					{//If the use key is pressed. slow the player more quickly
+						if ( pm->gent->client->NPC_class != CLASS_VEHICLE )	// if not in a vehicle...
+						{//in a vehicle, use key makes you turbo-boost
+							friction *= pm_frictionModifier;
+						}
+					}
+					*/
+
+					control = speed < pm_stopspeed ? pm_stopspeed : speed;
+					drop += control*friction*pml.frametime;
+				}
+			}
+		}
+	}
+	else if ( (pm->ps->clientNum < MAX_CLIENTS||PM_ControlledByPlayer())
+		&& pm->gent 
+		&& pm->gent->client 
+		&& (pm->gent->client->NPC_class == CLASS_BOBAFETT || pm->gent->client->NPC_class == CLASS_ROCKETTROOPER) && pm->gent->client->moveType == MT_FLYSWIM )
+	{//player as Boba
+		drop += speed*pm_waterfriction*pml.frametime;
+	}
+	
+	if ( Flying == FLY_VEHICLE )
+	{
+		if ( !(pm->ps->pm_flags & PMF_TIME_KNOCKBACK) && !(pm->ps->pm_flags & PMF_TIME_NOFRICTION) ) 
+		{
+			control = speed < pm_stopspeed ? pm_stopspeed : speed;
+			drop += control*friction*pml.frametime;
+		}
+	}
+
+	// apply water friction even if just wading
+	if ( !waterForceJump )
+	{
+		if ( pm->waterlevel && !(pm->watertype & CONTENTS_LADDER))
+		{
+			drop += speed*pm_waterfriction*pm->waterlevel*pml.frametime;
+		}
+	}
+	
+	// apply flying friction
+	if ( pm->ps->pm_type == PM_SPECTATOR ) 	
+	{
+		drop += speed*pm_flightfriction*pml.frametime;
+	}
+
+	// scale the velocity
+	newspeed = speed - drop;
+	if (newspeed < 0)
+		newspeed = 0;
+
+	newspeed /= speed;
+
+	vel[0] = vel[0] * newspeed;
+	vel[1] = vel[1] * newspeed;
+	vel[2] = vel[2] * newspeed;
+}
+
+
+/*
+==============
+PM_Accelerate
+
+Handles user intended acceleration
+==============
+*/
+
+static void PM_Accelerate( vec3_t wishdir, float wishspeed, float accel ) 
+{
+	int			i;
+	float		addspeed, accelspeed, currentspeed;
+
+	currentspeed = DotProduct (pm->ps->velocity, wishdir);
+
+	addspeed = wishspeed - currentspeed;
+	
+	if (addspeed <= 0) {
+		return;
+	}
+	accelspeed = ( accel * pml.frametime ) * wishspeed;
+
+	if (accelspeed > addspeed) {
+		accelspeed = addspeed;
+	}
+	for (i=0 ; i<3 ; i++) {
+		pm->ps->velocity[i] += accelspeed * wishdir[i];	
+	}
+}
+
+/*
+============
+PM_CmdScale
+
+Returns the scale factor to apply to cmd movements
+This allows the clients to use axial -127 to 127 values for all directions
+without getting a sqrt(2) distortion in speed.
+============
+*/
+static float PM_CmdScale( usercmd_t *cmd ) 
+{
+	int		max;
+	float	total;
+	float	scale;
+
+	max = abs( cmd->forwardmove );
+	
+	if ( abs( cmd->rightmove ) > max ) {
+		max = abs( cmd->rightmove );
+	}
+	if ( abs( cmd->upmove ) > max ) {
+		max = abs( cmd->upmove );
+	}
+	if ( !max ) {
+		return 0;
+	}
+	total = sqrt(	(float)(( cmd->forwardmove * cmd->forwardmove ) 
+				  + ( cmd->rightmove * cmd->rightmove ) 
+				  + ( cmd->upmove * cmd->upmove )) );
+	
+	scale = (float) pm->ps->speed * max / ( 127.0f * total );
+
+	return scale;
+}
+
+
+/*
+================
+PM_SetMovementDir
+
+Determine the rotation of the legs reletive
+to the facing dir
+================
+*/
+static void PM_SetMovementDir( void ) {
+	if ( pm->cmd.forwardmove || pm->cmd.rightmove ) {
+		if ( pm->cmd.rightmove == 0 && pm->cmd.forwardmove > 0 ) {
+			pm->ps->movementDir = 0;
+		} else if ( pm->cmd.rightmove < 0 && pm->cmd.forwardmove > 0 ) {
+			pm->ps->movementDir = 1;
+		} else if ( pm->cmd.rightmove < 0 && pm->cmd.forwardmove == 0 ) {
+			pm->ps->movementDir = 2;
+		} else if ( pm->cmd.rightmove < 0 && pm->cmd.forwardmove < 0 ) {
+			pm->ps->movementDir = 3;
+		} else if ( pm->cmd.rightmove == 0 && pm->cmd.forwardmove < 0 ) {
+			pm->ps->movementDir = 4;
+		} else if ( pm->cmd.rightmove > 0 && pm->cmd.forwardmove < 0 ) {
+			pm->ps->movementDir = 5;
+		} else if ( pm->cmd.rightmove > 0 && pm->cmd.forwardmove == 0 ) {
+			pm->ps->movementDir = 6;
+		} else if ( pm->cmd.rightmove > 0 && pm->cmd.forwardmove > 0 ) {
+			pm->ps->movementDir = 7;
+		}
+	} else {
+		// if they aren't actively going directly sideways,
+		// change the animation to the diagonal so they
+		// don't stop too crooked
+		if ( pm->ps->movementDir == 2 ) {
+			pm->ps->movementDir = 1;
+		} else if ( pm->ps->movementDir == 6 ) {
+			pm->ps->movementDir = 7;
+		} 
+	}
+}
+
+
+/*
+=============
+PM_CheckJump
+=============
+*/
+#define METROID_JUMP 1
+qboolean PM_InReboundJump( int anim )
+{
+	switch ( anim )
+	{
+	case BOTH_FORCEWALLREBOUND_FORWARD:
+	case BOTH_FORCEWALLREBOUND_LEFT:
+	case BOTH_FORCEWALLREBOUND_BACK:
+	case BOTH_FORCEWALLREBOUND_RIGHT:
+		return qtrue;
+		break;
+	}
+	return qfalse;
+}
+
+qboolean PM_InReboundHold( int anim )
+{
+	switch ( anim )
+	{
+	case BOTH_FORCEWALLHOLD_FORWARD:
+	case BOTH_FORCEWALLHOLD_LEFT:
+	case BOTH_FORCEWALLHOLD_BACK:
+	case BOTH_FORCEWALLHOLD_RIGHT:
+		return qtrue;
+		break;
+	}
+	return qfalse;
+}
+
+qboolean PM_InReboundRelease( int anim )
+{
+	switch ( anim )
+	{
+	case BOTH_FORCEWALLRELEASE_FORWARD:
+	case BOTH_FORCEWALLRELEASE_LEFT:
+	case BOTH_FORCEWALLRELEASE_BACK:
+	case BOTH_FORCEWALLRELEASE_RIGHT:
+		return qtrue;
+		break;
+	}
+	return qfalse;
+}
+
+qboolean PM_InBackFlip( int anim )
+{
+	switch ( anim )
+	{
+	case BOTH_FLIP_BACK1:
+	case BOTH_FLIP_BACK2:
+	case BOTH_FLIP_BACK3:
+	case BOTH_ALORA_FLIP_B:
+		return qtrue;
+		break;
+	}
+	return qfalse;
+}
+
+qboolean PM_InSpecialJump( int anim )
+{
+	switch ( anim )
+	{
+	case BOTH_WALL_RUN_RIGHT:
+	case BOTH_WALL_RUN_RIGHT_STOP:
+	case BOTH_WALL_RUN_RIGHT_FLIP:
+	case BOTH_WALL_RUN_LEFT:
+	case BOTH_WALL_RUN_LEFT_STOP:
+	case BOTH_WALL_RUN_LEFT_FLIP:
+	case BOTH_WALL_FLIP_RIGHT:
+	case BOTH_WALL_FLIP_LEFT:
+	case BOTH_WALL_FLIP_BACK1:
+	case BOTH_BUTTERFLY_LEFT:
+	case BOTH_BUTTERFLY_RIGHT:
+	case BOTH_BUTTERFLY_FL1:
+	case BOTH_BUTTERFLY_FR1:
+	case BOTH_FJSS_TR_BL:
+	case BOTH_FJSS_TL_BR:
+	case BOTH_FORCELEAP2_T__B_:
+	case BOTH_JUMPFLIPSLASHDOWN1://#
+	case BOTH_JUMPFLIPSTABDOWN://#
+	case BOTH_JUMPATTACK6:
+	case BOTH_JUMPATTACK7:
+	case BOTH_ARIAL_LEFT:
+	case BOTH_ARIAL_RIGHT:
+	case BOTH_ARIAL_F1:
+	case BOTH_CARTWHEEL_LEFT:
+	case BOTH_CARTWHEEL_RIGHT:
+
+	case BOTH_FORCELONGLEAP_START:
+	case BOTH_FORCELONGLEAP_ATTACK:
+	case BOTH_FORCEWALLRUNFLIP_START:
+	case BOTH_FORCEWALLRUNFLIP_END:
+	case BOTH_FORCEWALLRUNFLIP_ALT:
+	case BOTH_FLIP_ATTACK7:
+	case BOTH_FLIP_HOLD7:
+	case BOTH_FLIP_LAND:
+	case BOTH_A7_SOULCAL:
+		return qtrue;
+	}
+	if ( PM_InReboundJump( anim ) )
+	{
+		return qtrue;
+	}
+	if ( PM_InReboundHold( anim ) )
+	{
+		return qtrue;
+	}
+	if ( PM_InReboundRelease( anim ) )
+	{
+		return qtrue;
+	}
+	if ( PM_InBackFlip( anim ) )
+	{
+		return qtrue;
+	}
+	return qfalse;
+}
+
+extern void CG_PlayerLockedWeaponSpeech( int jumping );
+qboolean PM_ForceJumpingUp( gentity_t *gent )
+{
+	if ( !gent || !gent->client )
+	{
+		return qfalse;
+	}
+
+	if ( gent->NPC )
+	{//this is ONLY for the player
+		if ( player 
+			&& player->client 
+			&& player->client->ps.viewEntity == gent->s.number )
+		{//okay to jump if an NPC controlled by the player
+		}
+		else
+		{
+			return qfalse;
+		}
+	}
+
+	if ( !(gent->client->ps.forcePowersActive&(1<<FP_LEVITATION)) && gent->client->ps.forceJumpCharge )
+	{//already jumped and let go
+		return qfalse;
+	}
+
+	if ( PM_InSpecialJump( gent->client->ps.legsAnim ) )
+	{
+		return qfalse;
+	}
+
+	if ( PM_InKnockDown( &gent->client->ps ) )
+	{
+		return qfalse;
+	}
+	
+	if ( (gent->s.number<MAX_CLIENTS||G_ControlledByPlayer(gent)) && in_camera )
+	{//player can't use force powers in cinematic
+		return qfalse;
+	}
+	if ( gent->client->ps.groundEntityNum == ENTITYNUM_NONE //in air
+		&& ( (gent->client->ps.pm_flags&PMF_JUMPING) && gent->client->ps.velocity[2] > 0 )//jumped & going up or at water surface///*(gent->client->ps.waterHeightLevel==WHL_SHOULDERS&&gent->client->usercmd.upmove>0) ||*/ 
+		&& gent->client->ps.forcePowerLevel[FP_LEVITATION] > FORCE_LEVEL_0 //force-jump capable
+		&& !(gent->client->ps.pm_flags&PMF_TRIGGER_PUSHED) )//not pushed by a trigger
+	{
+		if( gent->flags & FL_LOCK_PLAYER_WEAPONS ) // yes this locked weapons check also includes force powers, if we need a separate check later I'll make one
+		{
+			CG_PlayerLockedWeaponSpeech( qtrue );
+			return qfalse;
+		}
+		return qtrue;
+	}
+	return qfalse;
+}
+
+static void PM_JumpForDir( void )
+{
+	int anim = BOTH_JUMP1;
+	if ( pm->cmd.forwardmove > 0 ) 
+	{
+		anim = BOTH_JUMP1;
+		pm->ps->pm_flags &= ~PMF_BACKWARDS_JUMP;
+	} 
+	else if ( pm->cmd.forwardmove < 0 )
+	{
+		anim = BOTH_JUMPBACK1;
+		pm->ps->pm_flags |= PMF_BACKWARDS_JUMP;
+	}
+	else if ( pm->cmd.rightmove > 0 ) 
+	{
+		anim = BOTH_JUMPRIGHT1;
+		pm->ps->pm_flags &= ~PMF_BACKWARDS_JUMP;
+	}
+	else if ( pm->cmd.rightmove < 0 ) 
+	{
+		anim = BOTH_JUMPLEFT1;
+		pm->ps->pm_flags &= ~PMF_BACKWARDS_JUMP;
+	}
+	else
+	{
+		anim = BOTH_JUMP1;
+		pm->ps->pm_flags &= ~PMF_BACKWARDS_JUMP;
+	}
+	if(!PM_InDeathAnim())
+	{
+		PM_SetAnim(pm,SETANIM_LEGS,anim,SETANIM_FLAG_OVERRIDE, 100);		// Only blend over 100ms
+	}
+}
+
+qboolean PM_GentCantJump( gentity_t *gent )
+{//FIXME: ugh, hacky, set a flag on NPC or something, please...
+	if ( gent && gent->client && 
+		( gent->client->NPC_class == CLASS_ATST || 
+		gent->client->NPC_class == CLASS_GONK || 
+		gent->client->NPC_class == CLASS_MARK1 || 
+		gent->client->NPC_class == CLASS_MARK2 || 
+		gent->client->NPC_class == CLASS_MOUSE || 
+		gent->client->NPC_class == CLASS_PROBE || 
+		gent->client->NPC_class == CLASS_PROTOCOL || 
+		gent->client->NPC_class == CLASS_R2D2 || 
+		gent->client->NPC_class == CLASS_R5D2 || 
+		gent->client->NPC_class == CLASS_SEEKER || 
+		gent->client->NPC_class == CLASS_REMOTE || 
+		gent->client->NPC_class == CLASS_SENTRY ) )
+	{
+		return qtrue;
+	}
+	return qfalse;
+}
+
+static qboolean PM_CheckJump( void ) 
+{
+	//Don't allow jump until all buttons are up
+	if ( pm->ps->pm_flags & PMF_RESPAWNED ) {
+		return qfalse;		
+	}
+
+	if ( PM_InKnockDown( pm->ps ) || PM_InRoll( pm->ps ) ) 
+	{//in knockdown
+		return qfalse;		
+	}
+
+	if ( PM_GentCantJump( pm->gent ) )
+	{
+		return qfalse;		
+	}
+
+	if ( PM_KickingAnim( pm->ps->legsAnim ) && !PM_InAirKickingAnim( pm->ps->legsAnim ) )
+	{//can't jump when in a kicking anim
+		return qfalse;
+	}
+	/*
+	if ( pm->cmd.buttons & BUTTON_FORCEJUMP )
+	{
+		pm->ps->pm_flags |= PMF_JUMP_HELD;
+	}
+	*/
+
+#if METROID_JUMP
+	if ( (pm->ps->clientNum < MAX_CLIENTS||PM_ControlledByPlayer()) 
+		&& pm->gent && pm->gent->client 
+		&& (pm->gent->client->NPC_class == CLASS_BOBAFETT || pm->gent->client->NPC_class == CLASS_ROCKETTROOPER) )
+	{//player playing as boba fett
+		if ( pm->cmd.upmove > 0 )
+		{//turn on/go up
+			if ( pm->ps->groundEntityNum == ENTITYNUM_NONE && !(pm->ps->pm_flags&PMF_JUMP_HELD) )
+			{//double-tap - must activate while in air
+				if ( !JET_Flying( pm->gent ) )
+				{
+					JET_FlyStart( pm->gent );
+				}
+			}
+		}
+		else if ( pm->cmd.upmove < 0 )
+		{//turn it off (or should we just go down)?
+			/*
+			if ( JET_Flying( pm->gent ) )
+			{
+				JET_FlyStop( pm->gent );
+			}
+			*/
+		}
+	}
+	else if ( pm->waterlevel < 3 )//|| (pm->ps->waterHeightLevel==WHL_SHOULDERS&&pm->cmd.upmove>0) ) 
+	{
+		if ( pm->ps->gravity > 0 )
+		{//can't do this in zero-G
+			if ( pm->ps->legsAnim == BOTH_FORCELONGLEAP_START
+				|| pm->ps->legsAnim == BOTH_FORCELONGLEAP_ATTACK
+				|| pm->ps->legsAnim == BOTH_FORCELONGLEAP_LAND )
+			{//in the middle of a force long-jump
+				/*
+				if ( pm->ps->groundEntityNum == ENTITYNUM_NONE 
+					&& pm->cmd.upmove > 0
+					&& pm->cmd.forwardmove > 0 )
+				*/
+				if ( (pm->ps->legsAnim == BOTH_FORCELONGLEAP_START || pm->ps->legsAnim == BOTH_FORCELONGLEAP_ATTACK)
+					&& pm->ps->legsAnimTimer > 0 )
+				{//in the air
+					//FIXME: need an actual set time so it doesn't matter when the attack happens
+					//FIXME: make sure we don't jump further than force jump 3 allows
+					vec3_t	jFwdAngs, jFwdVec;
+					VectorSet( jFwdAngs, 0, pm->ps->viewangles[YAW], 0 );
+					AngleVectors( jFwdAngs, jFwdVec, NULL, NULL );
+					float oldZVel = pm->ps->velocity[2];
+					if ( pm->ps->legsAnimTimer > 150 && oldZVel < 0 )
+					{
+						oldZVel = 0;
+					}
+					VectorScale( jFwdVec, FORCE_LONG_LEAP_SPEED, pm->ps->velocity ); 
+					pm->ps->velocity[2] = oldZVel;
+					pm->ps->pm_flags |= PMF_JUMP_HELD;
+					pm->ps->pm_flags |= PMF_JUMPING|PMF_SLOW_MO_FALL;
+					pm->ps->forcePowersActive |= (1<<FP_LEVITATION);
+					return qtrue;
+				}
+				else
+				{//landing-slide
+					if ( pm->ps->legsAnim == BOTH_FORCELONGLEAP_START 
+						|| pm->ps->legsAnim == BOTH_FORCELONGLEAP_ATTACK )
+					{//still in start anim, but it's run out
+						pm->ps->forcePowersActive |= (1<<FP_LEVITATION);
+						if ( pm->ps->groundEntityNum == ENTITYNUM_NONE )
+						{//still in air?
+							//hold it for another 50ms
+							//PM_SetAnim( pm, SETANIM_BOTH, BOTH_FORCELONGLEAP_START, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+						}
+					}
+					else
+					{//in land-slide anim
+						//FIXME: force some forward movement?  Less if holding back?
+					} 
+					if ( pm->ps->groundEntityNum == ENTITYNUM_NONE//still in air
+						&& pm->ps->origin[2] < pm->ps->jumpZStart )//dropped below original jump start
+					{//slow down 
+						pm->ps->velocity[0] *= 0.75f; 
+						pm->ps->velocity[1] *= 0.75f; 
+						if ( (pm->ps->velocity[0]+pm->ps->velocity[1])*0.5f<=10.0f )
+						{//falling straight down
+							PM_SetAnim( pm, SETANIM_BOTH, BOTH_FORCEINAIR1, SETANIM_FLAG_OVERRIDE );
+						}
+					}
+					return qfalse;
+				}
+			}
+			else if ( (pm->ps->clientNum < MAX_CLIENTS||PM_ControlledByPlayer()) //player-only for now
+				&& pm->cmd.upmove > 0 //trying to jump
+				&& pm->ps->forcePowerLevel[FP_LEVITATION] >= FORCE_LEVEL_3 //force jump 3 or better
+				&& pm->ps->forcePower >= FORCE_LONGJUMP_POWER //this costs 20 force to do
+				&& (pm->ps->forcePowersActive&(1<<FP_SPEED)) //force-speed is on
+				&& pm->cmd.forwardmove > 0 //pushing forward
+				&& !pm->cmd.rightmove //not strafing
+				&& pm->ps->groundEntityNum != ENTITYNUM_NONE//not in mid-air
+				&& !(pm->ps->pm_flags&PMF_JUMP_HELD)
+				//&& (float)(level.time-pm->ps->lastStationary) >= (3000.0f*g_timescale->value)//have to have a 3 second running start - relative to force speed slowdown
+				&& (level.time-pm->ps->forcePowerDebounce[FP_SPEED]) <= 250//have to have just started the force speed within the last half second
+				&& pm->gent )
+			{//start a force long-jump!
+				vec3_t	jFwdAngs, jFwdVec;
+				//BOTH_FORCELONGLEAP_ATTACK if holding attack, too?
+				PM_SetAnim( pm, SETANIM_BOTH, BOTH_FORCELONGLEAP_START, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+				VectorSet( jFwdAngs, 0, pm->ps->viewangles[YAW], 0 );
+				AngleVectors( jFwdAngs, jFwdVec, NULL, NULL );
+				VectorScale( jFwdVec, FORCE_LONG_LEAP_SPEED, pm->ps->velocity );
+				pm->ps->velocity[2] = 320;
+				pml.groundPlane = qfalse;
+				pml.walking = qfalse;
+				pm->ps->groundEntityNum = ENTITYNUM_NONE;
+				pm->ps->jumpZStart = pm->ps->origin[2];
+				pm->ps->pm_flags |= PMF_JUMP_HELD;
+				pm->ps->pm_flags |= PMF_JUMPING|PMF_SLOW_MO_FALL;
+				//start force jump
+				pm->ps->forcePowersActive |= (1<<FP_LEVITATION);
+				pm->cmd.upmove = 0;
+				// keep track of force jump stat
+				if(pm->ps->clientNum == 0)
+				{	
+					if( pm->gent && pm->gent->client )
+					{
+						pm->gent->client->sess.missionStats.forceUsed[(int)FP_LEVITATION]++;
+					}
+				}
+				G_SoundOnEnt( pm->gent, CHAN_BODY, "sound/weapons/force/jump.wav" );
+				WP_ForcePowerStop( pm->gent, FP_SPEED );
+				WP_ForcePowerDrain( pm->gent, FP_LEVITATION, FORCE_LONGJUMP_POWER );//drain the required force power
+				G_StartMatrixEffect( pm->gent, 0, pm->ps->legsAnimTimer+500 );
+				return qtrue;
+			}
+			else if ( PM_InCartwheel( pm->ps->legsAnim )
+				|| PM_InButterfly( pm->ps->legsAnim ) )
+			{//can't keep jumping up in cartwheels, ariels and butterflies
+			}
+			//FIXME: still able to pogo-jump...
+			else if ( PM_ForceJumpingUp( pm->gent ) && (pm->ps->pm_flags&PMF_JUMP_HELD) )//||pm->ps->waterHeightLevel==WHL_SHOULDERS) )
+			{//force jumping && holding jump
+				/*
+				if ( !pm->ps->forceJumpZStart && (pm->ps->waterHeightLevel==WHL_SHOULDERS&&pm->cmd.upmove>0) )
+				{
+					pm->ps->forceJumpZStart = pm->ps->origin[2];
+				}
+				*/
+				float curHeight = pm->ps->origin[2] - pm->ps->forceJumpZStart;
+				//check for max force jump level and cap off & cut z vel
+				if ( ( curHeight<=forceJumpHeight[0] ||//still below minimum jump height
+						(pm->ps->forcePower&&pm->cmd.upmove>=10) ) &&////still have force power available and still trying to jump up 
+					curHeight < forceJumpHeight[pm->ps->forcePowerLevel[FP_LEVITATION]] )//still below maximum jump height
+				{//can still go up
+					//FIXME: after a certain amount of time of held jump, play force jump sound and flip if a dir is being held
+					//FIXME: if hit a wall... should we cut velocity or allow them to slide up it?
+					//FIXME: constantly drain force power at a rate by which the usage for maximum height would use up the full cost of force jump
+					if ( curHeight > forceJumpHeight[0] )
+					{//passed normal jump height  *2?
+						if ( !(pm->ps->forcePowersActive&(1<<FP_LEVITATION)) )//haven't started forcejump yet
+						{
+							//start force jump
+   							pm->ps->forcePowersActive |= (1<<FP_LEVITATION);
+							if ( pm->gent )
+							{
+								G_SoundOnEnt( pm->gent, CHAN_BODY, "sound/weapons/force/jump.wav" );
+								// keep track of force jump stat
+								if(pm->ps->clientNum == 0 && pm->gent->client)
+								{
+									pm->gent->client->sess.missionStats.forceUsed[(int)FP_LEVITATION]++;
+								}
+							}
+							//play flip
+							//FIXME: do this only when they stop the jump (below) or when they're just about to hit the peak of the jump
+							if ( PM_InAirKickingAnim( pm->ps->legsAnim )
+								&& pm->ps->legsAnimTimer )
+							{//still in kick
+							}
+							else if ((pm->cmd.forwardmove || pm->cmd.rightmove) && //pushing in a dir
+								//pm->ps->legsAnim != BOTH_ARIAL_F1 &&//not already flipping
+								pm->ps->legsAnim != BOTH_FLIP_F &&
+								pm->ps->legsAnim != BOTH_FLIP_B &&
+								pm->ps->legsAnim != BOTH_FLIP_R &&
+								pm->ps->legsAnim != BOTH_FLIP_L && 
+								pm->ps->legsAnim != BOTH_ALORA_FLIP_1 &&
+								pm->ps->legsAnim != BOTH_ALORA_FLIP_2 &&
+								pm->ps->legsAnim != BOTH_ALORA_FLIP_3
+								&& cg.renderingThirdPerson//third person only
+								&& !cg.zoomMode )//not zoomed in
+							{//FIXME: this could end up playing twice if the jump is very long...
+								int anim = BOTH_FORCEINAIR1;
+								int	parts = SETANIM_BOTH;
+
+								if ( pm->cmd.forwardmove > 0 )
+								{
+									/*
+									if ( pm->ps->forcePowerLevel[FP_LEVITATION] < FORCE_LEVEL_2 )
+									{
+										anim = BOTH_ARIAL_F1;
+									}
+									else
+									*/
+									if ( pm->gent && pm->gent->client && pm->gent->client->NPC_class == CLASS_ALORA && Q_irand( 0, 3 ) )
+									{
+										anim = Q_irand( BOTH_ALORA_FLIP_1, BOTH_ALORA_FLIP_3 );
+									}
+									else
+									{
+										anim = BOTH_FLIP_F;
+									}
+								}
+								else if ( pm->cmd.forwardmove < 0 )
+								{
+									anim = BOTH_FLIP_B;
+								}
+								else if ( pm->cmd.rightmove > 0 )
+								{
+									anim = BOTH_FLIP_R;
+								}
+								else if ( pm->cmd.rightmove < 0 )
+								{
+									anim = BOTH_FLIP_L;
+								}
+								if ( pm->ps->weaponTime )
+								{//FIXME: really only care if we're in a saber attack anim...
+									parts = SETANIM_LEGS;
+								}
+
+								PM_SetAnim( pm, parts, anim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+							}
+							else if ( pm->ps->forcePowerLevel[FP_LEVITATION] > FORCE_LEVEL_1 )
+							{//FIXME: really want to know how far off ground we are, probably...
+								vec3_t facingFwd, facingRight, facingAngles = {0, pm->ps->viewangles[YAW], 0};
+								int	anim = -1;
+								AngleVectors( facingAngles, facingFwd, facingRight, NULL );
+								float dotR = DotProduct( facingRight, pm->ps->velocity );
+								float dotF = DotProduct( facingFwd, pm->ps->velocity );
+								if ( fabs(dotR) > fabs(dotF) * 1.5 )
+								{
+									if ( dotR > 150 )
+									{
+										anim = BOTH_FORCEJUMPRIGHT1;
+									}
+									else if ( dotR < -150 )
+									{
+										anim = BOTH_FORCEJUMPLEFT1;
+									}
+								}
+								else
+								{
+									if ( dotF > 150 )
+									{
+										anim = BOTH_FORCEJUMP1;
+									}
+									else if ( dotF < -150 )
+									{
+										anim = BOTH_FORCEJUMPBACK1;
+									}
+								}
+								if ( anim != -1 )
+								{
+									int parts = SETANIM_BOTH;
+									if ( pm->ps->weaponTime )
+									{//FIXME: really only care if we're in a saber attack anim...
+										parts = SETANIM_LEGS;
+									}
+
+									PM_SetAnim( pm, parts, anim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+								}
+							}
+						}
+						else
+						{
+							if ( !pm->ps->legsAnimTimer )
+							{//not in the middle of a legsAnim
+								int anim = pm->ps->legsAnim;
+								int newAnim = -1;
+								switch ( anim )
+								{
+								case BOTH_FORCEJUMP1:
+									newAnim = BOTH_FORCELAND1;//BOTH_FORCEINAIR1;
+									break;
+								case BOTH_FORCEJUMPBACK1:
+									newAnim = BOTH_FORCELANDBACK1;//BOTH_FORCEINAIRBACK1;
+									break;
+								case BOTH_FORCEJUMPLEFT1:
+									newAnim = BOTH_FORCELANDLEFT1;//BOTH_FORCEINAIRLEFT1;
+									break;
+								case BOTH_FORCEJUMPRIGHT1:
+									newAnim = BOTH_FORCELANDRIGHT1;//BOTH_FORCEINAIRRIGHT1;
+									break;
+								}
+								if ( newAnim != -1 )
+								{
+									int parts = SETANIM_BOTH;
+									if ( pm->ps->weaponTime )
+									{//FIXME: really only care if we're in a saber attack anim...
+										parts = SETANIM_LEGS;
+									}
+
+									PM_SetAnim( pm, parts, newAnim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+								}
+							}
+						}
+					}
+
+					//need to scale this down, start with height velocity (based on max force jump height) and scale down to regular jump vel
+					pm->ps->velocity[2] = (forceJumpHeight[pm->ps->forcePowerLevel[FP_LEVITATION]]-curHeight)/forceJumpHeight[pm->ps->forcePowerLevel[FP_LEVITATION]]*forceJumpStrength[pm->ps->forcePowerLevel[FP_LEVITATION]];//JUMP_VELOCITY;
+					pm->ps->velocity[2] /= 10;
+					pm->ps->velocity[2] += JUMP_VELOCITY;
+					pm->ps->pm_flags |= PMF_JUMP_HELD;
+				}
+				else if ( curHeight > forceJumpHeight[0] && curHeight < forceJumpHeight[pm->ps->forcePowerLevel[FP_LEVITATION]] - forceJumpHeight[0] )
+				{//still have some headroom, don't totally stop it
+					if ( pm->ps->velocity[2] > JUMP_VELOCITY )
+					{
+						pm->ps->velocity[2] = JUMP_VELOCITY;
+					}
+				}
+				else
+				{
+					pm->ps->velocity[2] = 0;
+				}
+				pm->cmd.upmove = 0;
+				return qfalse;
+			}
+		}
+	}
+
+#endif
+
+	//Not jumping
+	if ( pm->cmd.upmove < 10 ) {
+		return qfalse;
+	}
+
+	// must wait for jump to be released
+	if ( pm->ps->pm_flags & PMF_JUMP_HELD ) 
+	{
+		// clear upmove so cmdscale doesn't lower running speed
+		pm->cmd.upmove = 0;
+		return qfalse;
+	}
+
+	if ( pm->ps->gravity <= 0 )
+	{//in low grav, you push in the dir you're facing as long as there is something behind you to shove off of
+		vec3_t	forward, back;
+		trace_t	trace;
+
+		AngleVectors( pm->ps->viewangles, forward, NULL, NULL );
+		VectorMA( pm->ps->origin, -8, forward, back );
+		pm->trace( &trace, pm->ps->origin, pm->mins, pm->maxs, back, pm->ps->clientNum, pm->tracemask&~(CONTENTS_PLAYERCLIP|CONTENTS_MONSTERCLIP) );
+
+		pm->cmd.upmove = 0;
+
+		if ( trace.fraction < 1.0f )
+		{
+			VectorMA( pm->ps->velocity, JUMP_VELOCITY/2, forward, pm->ps->velocity );
+			//FIXME: kicking off wall anim?  At least check what anim we're in?
+			PM_SetAnim(pm,SETANIM_LEGS,BOTH_FORCEJUMP1,SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD|SETANIM_FLAG_RESTART);
+		}
+		else
+		{//else no surf close enough to push off of
+			return qfalse;
+		}
+
+		if ( pm->ps->groundEntityNum == ENTITYNUM_NONE )
+		{//need to set some things and return
+			//Jumping
+			pm->ps->forceJumpZStart = 0;
+			pml.groundPlane = qfalse;
+			pml.walking = qfalse;
+			pm->ps->pm_flags |= (PMF_JUMPING|PMF_JUMP_HELD);
+			pm->ps->groundEntityNum = ENTITYNUM_NONE;
+			pm->ps->jumpZStart = pm->ps->origin[2];
+
+			if ( pm->gent )
+			{
+				if ( !Q3_TaskIDPending( pm->gent, TID_CHAN_VOICE ) )
+				{
+					PM_AddEvent( EV_JUMP );
+				}
+			}
+			else
+			{
+				PM_AddEvent( EV_JUMP );
+			}
+	
+			return qtrue;
+		}//else no surf close enough to push off of
+	}
+	else if ( pm->cmd.upmove > 0 //want to jump
+		&& pm->waterlevel < 2 //not in water above ankles
+		&& pm->ps->forcePowerLevel[FP_LEVITATION] > FORCE_LEVEL_0 //have force jump ability
+		&& !(pm->ps->pm_flags&PMF_JUMP_HELD)//not holding jump from a previous jump
+		//&& !PM_InKnockDown( pm->ps )//not in a knockdown
+		&& pm->ps->forceRageRecoveryTime < pm->cmd.serverTime	//not in a force Rage recovery period
+		&& pm->gent && WP_ForcePowerAvailable( pm->gent, FP_LEVITATION, 0 ) //have enough force power to jump
+		&& ((pm->ps->clientNum&&!PM_ControlledByPlayer())||((pm->ps->clientNum < MAX_CLIENTS||PM_ControlledByPlayer()) && cg.renderingThirdPerson && !cg.zoomMode	&& !(pm->gent->flags&FL_LOCK_PLAYER_WEAPONS) )) )// yes this locked weapons check also includes force powers, if we need a separate check later I'll make one
+	{
+		if ( pm->gent->NPC && pm->gent->NPC->rank != RANK_CREWMAN && pm->gent->NPC->rank <= RANK_LT_JG )
+		{//reborn who are not acrobats can't do any of these acrobatics
+			//FIXME: extern these abilities in the .npc file!
+		}
+		else if ( pm->ps->groundEntityNum != ENTITYNUM_NONE )
+		{//on the ground
+			//check for left-wall and right-wall special jumps
+			int anim = -1;
+			float	vertPush = 0;
+			int		forcePowerCostOverride = 0;
+			
+			// Cartwheels/ariels/butterflies
+			if ( (pm->ps->weapon==WP_SABER&&G_TryingCartwheel(pm->gent,&pm->cmd)/*(pm->cmd.buttons&BUTTON_FORCE_FOCUS)*/&&(pm->cmd.buttons&BUTTON_ATTACK))//using saber and holding focus + attack
+//					  ||(pm->ps->weapon!=WP_SABER&&((pm->cmd.buttons&BUTTON_ATTACK)||(pm->cmd.buttons&BUTTON_ALT_ATTACK)) ) )//using any other weapon and hitting either attack button
+				&& (((pm->ps->clientNum>=MAX_CLIENTS&&!PM_ControlledByPlayer())&&pm->cmd.upmove > 0&& pm->ps->velocity[2] >= 0 )//jumping NPC, going up already
+					||((pm->ps->clientNum<MAX_CLIENTS||PM_ControlledByPlayer())&&G_TryingCartwheel(pm->gent,&pm->cmd)/*(pm->cmd.buttons&BUTTON_FORCE_FOCUS)*/))//focus-holding player
+				&& G_EnoughPowerForSpecialMove( pm->ps->forcePower, SABER_ALT_ATTACK_POWER_LR )/*pm->ps->forcePower >= SABER_ALT_ATTACK_POWER_LR*/ )// have enough power
+			{//holding attack and jumping
+				if ( pm->cmd.rightmove > 0 ) 
+				{
+					// If they're using the staff we do different anims.
+					if ( pm->ps->saberAnimLevel == SS_STAFF 
+						&& pm->ps->weapon == WP_SABER )
+					{
+						if ( (pm->ps->clientNum >= MAX_CLIENTS&&!PM_ControlledByPlayer())
+							|| pm->ps->forcePowerLevel[FP_LEVITATION] > FORCE_LEVEL_2 ) 
+						{
+							anim = BOTH_BUTTERFLY_RIGHT;
+							forcePowerCostOverride = G_CostForSpecialMove( SABER_ALT_ATTACK_POWER_LR );
+						}
+					}
+					else if ( (pm->ps->clientNum >= MAX_CLIENTS&&!PM_ControlledByPlayer())
+						|| pm->ps->forcePowerLevel[FP_LEVITATION] > FORCE_LEVEL_1 ) 
+					{
+						if ( pm->ps->clientNum < MAX_CLIENTS||PM_ControlledByPlayer() )
+						{//player: since we're on the ground, always do a cartwheel
+							/*
+							anim = BOTH_CARTWHEEL_RIGHT;
+							forcePowerCostOverride = G_CostForSpecialMove( SABER_ALT_ATTACK_POWER_LR );
+							*/
+						}
+						else
+						{
+							vertPush = JUMP_VELOCITY;
+							if ( Q_irand( 0, 1 ) )
+							{
+								anim = BOTH_ARIAL_RIGHT;
+								forcePowerCostOverride = G_CostForSpecialMove( SABER_ALT_ATTACK_POWER_LR );
+							}
+							else
+							{
+								anim = BOTH_CARTWHEEL_RIGHT;
+								forcePowerCostOverride = G_CostForSpecialMove( SABER_ALT_ATTACK_POWER_LR );
+							}
+						}
+					}
+				}
+				else if ( pm->cmd.rightmove < 0 )
+				{
+					// If they're using the staff we do different anims.
+					if ( pm->ps->saberAnimLevel == SS_STAFF 
+						&& pm->ps->weapon == WP_SABER )
+					{
+						if ( (pm->ps->clientNum >= MAX_CLIENTS&&!PM_ControlledByPlayer())
+							|| pm->ps->forcePowerLevel[FP_LEVITATION] > FORCE_LEVEL_2 ) 
+						{
+							anim = BOTH_BUTTERFLY_LEFT;
+							forcePowerCostOverride = G_CostForSpecialMove( SABER_ALT_ATTACK_POWER_LR );
+						}
+					}
+					else if ( (pm->ps->clientNum >= MAX_CLIENTS&&!PM_ControlledByPlayer())
+						|| pm->ps->forcePowerLevel[FP_LEVITATION] > FORCE_LEVEL_1 ) 
+					{
+						if ( pm->ps->clientNum < MAX_CLIENTS||PM_ControlledByPlayer() )
+						{//player: since we're on the ground, always do a cartwheel
+							/*
+							anim = BOTH_CARTWHEEL_LEFT;
+							forcePowerCostOverride = G_CostForSpecialMove( SABER_ALT_ATTACK_POWER_LR );
+							*/
+						}
+						else
+						{
+							vertPush = JUMP_VELOCITY;
+							if ( Q_irand( 0, 1 ) )
+							{
+								anim = BOTH_ARIAL_LEFT;
+								forcePowerCostOverride = G_CostForSpecialMove( SABER_ALT_ATTACK_POWER_LR );
+							}
+							else
+							{
+								anim = BOTH_CARTWHEEL_LEFT;
+								forcePowerCostOverride = G_CostForSpecialMove( SABER_ALT_ATTACK_POWER_LR );
+							}
+						}
+					}
+				}
+			}
+			else if ( pm->cmd.rightmove > 0 && pm->ps->forcePowerLevel[FP_LEVITATION] > FORCE_LEVEL_1 )
+			{//strafing right
+				if ( pm->cmd.forwardmove > 0 )
+				{//wall-run
+					vertPush = forceJumpStrength[FORCE_LEVEL_2]/2.0f;
+					anim = BOTH_WALL_RUN_RIGHT;
+				}
+				else if ( pm->cmd.forwardmove == 0 )
+				{//wall-flip
+					vertPush = forceJumpStrength[FORCE_LEVEL_2]/2.25f;
+					anim = BOTH_WALL_FLIP_RIGHT;
+				}
+			}
+			else if ( pm->cmd.rightmove < 0 && pm->ps->forcePowerLevel[FP_LEVITATION] > FORCE_LEVEL_1 )
+			{//strafing left
+				if ( pm->cmd.forwardmove > 0 )
+				{//wall-run
+					vertPush = forceJumpStrength[FORCE_LEVEL_2]/2.0f;
+					anim = BOTH_WALL_RUN_LEFT;
+				}
+				else if ( pm->cmd.forwardmove == 0 )
+				{//wall-flip
+					vertPush = forceJumpStrength[FORCE_LEVEL_2]/2.25f;
+					anim = BOTH_WALL_FLIP_LEFT;
+				}
+			}
+			else if ( /*pm->ps->clientNum >= MAX_CLIENTS//not the player
+				&& !PM_ControlledByPlayer() //not controlled by player
+				&&*/ pm->cmd.forwardmove > 0 //pushing forward
+				&& pm->ps->forcePowerLevel[FP_LEVITATION] > FORCE_LEVEL_1 )//have jump 2 or higher
+			{//step off wall, flip backwards
+				if ( VectorLengthSquared( pm->ps->velocity ) > 40000 /*200*200*/)
+				{//have to be moving... FIXME: make sure it's opposite the wall... or at least forward?
+					if ( pm->ps->forcePowerLevel[FP_LEVITATION] > FORCE_LEVEL_2 )
+					{//run all the way up wwall
+						vertPush = forceJumpStrength[FORCE_LEVEL_2]/2.0f;
+						anim = BOTH_FORCEWALLRUNFLIP_START;
+					}
+					else
+					{//run just a couple steps up
+						vertPush = forceJumpStrength[FORCE_LEVEL_2]/2.25f;
+						anim = BOTH_WALL_FLIP_BACK1;
+					}
+				}
+			}
+			else if ( pm->cmd.forwardmove < 0 //pushing back
+				//&& pm->ps->clientNum//not the player
+				&& !(pm->cmd.buttons&BUTTON_ATTACK) )//not attacking
+			{//back-jump does backflip... FIXME: always?!  What about just doing a normal jump backwards?
+				if ( pm->ps->velocity[2] >= 0 )
+				{//must be going up already
+					vertPush = JUMP_VELOCITY;
+					if ( pm->gent->client && pm->gent->client->NPC_class == CLASS_ALORA && !Q_irand( 0, 2 ) )
+					{
+						anim = BOTH_ALORA_FLIP_B;
+					}
+					else
+					{
+						anim = PM_PickAnim( pm->gent, BOTH_FLIP_BACK1, BOTH_FLIP_BACK3 );
+					}
+				}
+			}
+			else if ( VectorLengthSquared( pm->ps->velocity ) < 256 /*16 squared*/)
+			{//not moving
+				if ( pm->ps->weapon == WP_SABER && (pm->cmd.buttons & BUTTON_ATTACK) && pm->ps->saberAnimLevel == SS_MEDIUM )
+				{
+					/*
+					//Only tavion does these now
+					if ( pm->ps->clientNum && Q_irand( 0, 1 ) )
+					{//butterfly... FIXME: does direction matter?
+						vertPush = JUMP_VELOCITY;
+						if ( Q_irand( 0, 1 ) )
+						{
+							anim = BOTH_BUTTERFLY_LEFT;
+						}
+						else
+						{
+							anim = BOTH_BUTTERFLY_RIGHT;
+						}
+					}
+					else 
+					*/if ( pm->ps->clientNum >= MAX_CLIENTS && !PM_ControlledByPlayer() )//NOTE: pretty much useless, so player never does these
+					{//jump-spin FIXME: does direction matter?
+						vertPush = forceJumpStrength[FORCE_LEVEL_2]/1.5f;
+						if ( pm->gent->client && pm->gent->client->NPC_class == CLASS_ALORA )
+						{
+							anim = BOTH_ALORA_SPIN;
+						}
+						else
+						{
+							anim = Q_irand( BOTH_FJSS_TR_BL, BOTH_FJSS_TL_BR );
+						}
+					}
+				}
+			}
+
+			if ( anim != -1 && PM_HasAnimation( pm->gent, anim ) )
+			{
+				vec3_t fwd, right, traceto, mins = {pm->mins[0],pm->mins[1],0}, maxs = {pm->maxs[0],pm->maxs[1],24}, fwdAngles = {0, pm->ps->viewangles[YAW], 0};
+				trace_t	trace;
+				qboolean doTrace = qfalse;
+				int contents = CONTENTS_SOLID;
+
+				AngleVectors( fwdAngles, fwd, right, NULL );
+
+				//trace-check for a wall, if necc.
+				switch ( anim )
+				{
+				case BOTH_WALL_FLIP_LEFT:
+					if ( g_debugMelee->integer )
+					{
+						contents |= CONTENTS_BODY;
+					}
+					//NOTE: purposely falls through to next case!
+				case BOTH_WALL_RUN_LEFT:
+					doTrace = qtrue;
+					VectorMA( pm->ps->origin, -16, right, traceto );
+					break;
+
+				case BOTH_WALL_FLIP_RIGHT:
+					if ( g_debugMelee->integer )
+					{
+						contents |= CONTENTS_BODY;
+					}
+					//NOTE: purposely falls through to next case!
+				case BOTH_WALL_RUN_RIGHT:
+					doTrace = qtrue;
+					VectorMA( pm->ps->origin, 16, right, traceto );
+					break;
+
+				case BOTH_WALL_FLIP_BACK1:
+					if ( g_debugMelee->integer )
+					{
+						contents |= CONTENTS_BODY;
+					}
+					doTrace = qtrue;
+					VectorMA( pm->ps->origin, 32, fwd, traceto );//was 16
+					break;
+			
+				case BOTH_FORCEWALLRUNFLIP_START:
+					if ( g_debugMelee->integer )
+					{
+						contents |= CONTENTS_BODY;
+					}
+					doTrace = qtrue;
+					VectorMA( pm->ps->origin, 32, fwd, traceto );//was 16
+					break;
+				}
+
+				vec3_t	idealNormal={0}, wallNormal={0};
+				if ( doTrace )
+				{
+					//FIXME: all these jump ones should check for head clearance
+					pm->trace( &trace, pm->ps->origin, mins, maxs, traceto, pm->ps->clientNum, contents );
+					VectorCopy( trace.plane.normal, wallNormal );
+					VectorNormalize( wallNormal );
+					VectorSubtract( pm->ps->origin, traceto, idealNormal );
+					VectorNormalize( idealNormal );
+					if ( anim == BOTH_WALL_FLIP_LEFT )
+					{//sigh.. check for bottomless pit to the right
+						trace_t	trace2;
+						vec3_t	start;
+						VectorMA( pm->ps->origin, 128, right, traceto );
+						pm->trace( &trace2, pm->ps->origin, mins, maxs, traceto, pm->ps->clientNum, contents );
+						if ( !trace2.allsolid && !trace2.startsolid )
+						{
+							VectorCopy( trace2.endpos, traceto );
+							VectorCopy( traceto, start );
+							traceto[2] -= 384;
+							pm->trace( &trace2, start, mins, maxs, traceto, pm->ps->clientNum, contents );
+							if ( !trace2.allsolid && !trace2.startsolid && trace2.fraction >= 1.0f )
+							{//bottomless pit!
+								trace.fraction = 1.0f;//way to stop it from doing the side-flip
+							}
+						}
+					}
+					else if ( anim == BOTH_WALL_FLIP_RIGHT )
+					{//sigh.. check for bottomless pit to the left
+						trace_t	trace2;
+						vec3_t	start;
+						VectorMA( pm->ps->origin, -128, right, traceto );
+						pm->trace( &trace2, pm->ps->origin, mins, maxs, traceto, pm->ps->clientNum, contents );
+						if ( !trace2.allsolid && !trace2.startsolid )
+						{
+							VectorCopy( trace2.endpos, traceto );
+							VectorCopy( traceto, start );
+							traceto[2] -= 384;
+							pm->trace( &trace2, start, mins, maxs, traceto, pm->ps->clientNum, contents );
+							if ( !trace2.allsolid && !trace2.startsolid && trace2.fraction >= 1.0f )
+							{//bottomless pit!
+								trace.fraction = 1.0f;//way to stop it from doing the side-flip
+							}
+						}
+					}
+					else
+					{
+						if ( anim == BOTH_WALL_FLIP_BACK1 
+							|| anim == BOTH_FORCEWALLRUNFLIP_START )
+						{//trace up and forward a little to make sure the wall it at least 64 tall
+							if ( (contents&CONTENTS_BODY)//included entitied
+								&& (trace.contents&CONTENTS_BODY) //hit an entity
+								&& g_entities[trace.entityNum].client )//hit a client
+							{//no need to trace up, it's all good...
+								if ( PM_InOnGroundAnim( &g_entities[trace.entityNum].client->ps ) )//on the ground, no jump
+								{//can't jump off guys on ground
+									trace.fraction = 1.0f;//way to stop if from doing the jump
+								}
+								else if ( anim == BOTH_FORCEWALLRUNFLIP_START )
+								{//instead of wall-running up, do the backflip
+									anim = BOTH_WALL_FLIP_BACK1;
+									vertPush = forceJumpStrength[FORCE_LEVEL_2]/2.25f;
+								}
+							}
+							else if ( anim == BOTH_WALL_FLIP_BACK1 )
+							{
+								trace_t	trace2;
+								vec3_t	start;
+								VectorCopy( pm->ps->origin, start );
+								start[2] += 64;
+								VectorMA( start, 32, fwd, traceto );
+								pm->trace( &trace2, start, mins, maxs, traceto, pm->ps->clientNum, contents );
+								if ( trace2.allsolid 
+									|| trace2.startsolid 
+									|| trace2.fraction >= 1.0f )
+								{//no room above or no wall in front at that height
+									trace.fraction = 1.0f;//way to stop if from doing the jump
+								}
+							}
+						}
+						if ( trace.fraction < 1.0f )
+						{//still valid to jump
+							if ( anim == BOTH_WALL_FLIP_BACK1 )
+							{//sigh.. check for bottomless pit to the rear
+								trace_t	trace2;
+								vec3_t	start;
+								VectorMA( pm->ps->origin, -128, fwd, traceto );
+								pm->trace( &trace2, pm->ps->origin, mins, maxs, traceto, pm->ps->clientNum, contents );
+								if ( !trace2.allsolid && !trace2.startsolid )
+								{
+									VectorCopy( trace2.endpos, traceto );
+									VectorCopy( traceto, start );
+									traceto[2] -= 384;
+									pm->trace( &trace2, start, mins, maxs, traceto, pm->ps->clientNum, contents );
+									if ( !trace2.allsolid && !trace2.startsolid && trace2.fraction >= 1.0f )
+									{//bottomless pit!
+										trace.fraction = 1.0f;//way to stop it from doing the side-flip
+									}
+								}
+							}
+						}
+					}
+				}
+				gentity_t *traceEnt = &g_entities[trace.entityNum];
+				
+				if ( !doTrace || (trace.fraction < 1.0f&&((trace.entityNum<ENTITYNUM_WORLD&&traceEnt&&traceEnt->s.solid!=SOLID_BMODEL)||DotProduct(wallNormal,idealNormal)>0.7)) )
+				{//there is a wall there
+
+					if ( (anim != BOTH_WALL_RUN_LEFT 
+							&& anim != BOTH_WALL_RUN_RIGHT
+							&& anim != BOTH_FORCEWALLRUNFLIP_START) 
+						|| (wallNormal[2] >= 0.0f && wallNormal[2] <= MAX_WALL_RUN_Z_NORMAL) )
+					{//wall-runs can only run on relatively flat walls, sorry. 
+						if ( anim == BOTH_ARIAL_LEFT || anim == BOTH_CARTWHEEL_LEFT ) 
+						{
+							pm->ps->velocity[0] = pm->ps->velocity[1] = 0;
+							VectorMA( pm->ps->velocity, -185, right, pm->ps->velocity );
+						}
+						else if ( anim == BOTH_ARIAL_RIGHT || anim == BOTH_CARTWHEEL_RIGHT ) 
+						{
+							pm->ps->velocity[0] = pm->ps->velocity[1] = 0;
+							VectorMA( pm->ps->velocity, 185, right, pm->ps->velocity );
+						}
+						else if ( anim == BOTH_BUTTERFLY_LEFT )
+						{
+							pm->ps->velocity[0] = pm->ps->velocity[1] = 0; 
+							VectorMA( pm->ps->velocity, -190, right, pm->ps->velocity );
+						}
+						else if ( anim == BOTH_BUTTERFLY_RIGHT )
+						{
+							pm->ps->velocity[0] = pm->ps->velocity[1] = 0;
+							VectorMA( pm->ps->velocity, 190, right, pm->ps->velocity );
+						}
+						//move me to side
+						else if ( anim == BOTH_WALL_FLIP_LEFT )
+						{
+							pm->ps->velocity[0] = pm->ps->velocity[1] = 0;
+							VectorMA( pm->ps->velocity, 150, right, pm->ps->velocity );
+						}
+						else if ( anim == BOTH_WALL_FLIP_RIGHT )
+						{
+							pm->ps->velocity[0] = pm->ps->velocity[1] = 0;
+							VectorMA( pm->ps->velocity, -150, right, pm->ps->velocity );
+						}
+						else if ( anim == BOTH_FLIP_BACK1 
+							|| anim == BOTH_FLIP_BACK2 
+							|| anim == BOTH_FLIP_BACK3 
+							|| anim == BOTH_ALORA_FLIP_B
+							|| anim == BOTH_WALL_FLIP_BACK1 )
+						{
+							pm->ps->velocity[0] = pm->ps->velocity[1] = 0;
+							VectorMA( pm->ps->velocity, -150, fwd, pm->ps->velocity );
+						}
+						//kick if jumping off an ent
+						if ( doTrace 
+							&& anim != BOTH_WALL_RUN_LEFT 
+							&& anim != BOTH_WALL_RUN_RIGHT 
+							&& anim != BOTH_FORCEWALLRUNFLIP_START)
+						{
+							if ( pm->gent && trace.entityNum < ENTITYNUM_WORLD )
+							{
+								if ( traceEnt 
+									&& traceEnt->client 
+									&& traceEnt->health > 0 
+									&& traceEnt->takedamage
+									&& traceEnt->client->NPC_class != CLASS_GALAKMECH
+									&& traceEnt->client->NPC_class != CLASS_DESANN
+									&& !(traceEnt->flags&FL_NO_KNOCKBACK) )
+								{//push them away and do pain
+									vec3_t oppDir, fxDir;
+									float strength = VectorNormalize2( pm->ps->velocity, oppDir );
+									VectorScale( oppDir, -1, oppDir );
+									//FIXME: need knockdown anim
+									G_Damage( traceEnt, pm->gent, pm->gent, oppDir, traceEnt->currentOrigin, 10, DAMAGE_NO_ARMOR|DAMAGE_NO_HIT_LOC|DAMAGE_NO_KNOCKBACK, MOD_MELEE );
+									VectorCopy( fwd, fxDir );
+									VectorScale( fxDir, -1, fxDir );
+									G_PlayEffect( G_EffectIndex( "melee/kick_impact" ), trace.endpos, fxDir );
+									//G_Sound( traceEnt, G_SoundIndex( va("sound/weapons/melee/punch%d", Q_irand(1, 4)) ) );
+									if ( traceEnt->health > 0 )
+									{//didn't kill him
+										if ( (traceEnt->s.number==0&&!Q_irand(0,g_spskill->integer)) 
+											|| (traceEnt->NPC!=NULL&&Q_irand(RANK_CIVILIAN,traceEnt->NPC->rank)+Q_irand(-2,2)<RANK_ENSIGN) )
+										{
+											NPC_SetAnim( traceEnt, SETANIM_BOTH, BOTH_KNOCKDOWN2, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+											G_Throw( traceEnt, oppDir, strength );
+										}
+									}
+								}
+							}
+						}
+						//up
+						if ( vertPush )
+						{
+							pm->ps->velocity[2] = vertPush;
+						}
+						//animate me
+						if ( anim == BOTH_BUTTERFLY_RIGHT )
+						{
+							PM_SetSaberMove( LS_BUTTERFLY_RIGHT );
+						}
+						else if ( anim == BOTH_BUTTERFLY_LEFT )
+						{
+							PM_SetSaberMove( LS_BUTTERFLY_LEFT );
+						}
+						else
+						{//not a proper saberMove, so do set all the details manually
+							int parts = SETANIM_LEGS;
+							if ( /*anim == BOTH_BUTTERFLY_LEFT ||
+								anim == BOTH_BUTTERFLY_RIGHT ||*/
+								anim == BOTH_FJSS_TR_BL ||
+								anim == BOTH_FJSS_TL_BR )
+							{
+								parts = SETANIM_BOTH;
+								pm->cmd.buttons&=~BUTTON_ATTACK;
+								pm->ps->saberMove = LS_NONE;
+								pm->gent->client->ps.SaberActivateTrail( 300 );
+							}
+							else if ( !pm->ps->weaponTime )
+							{
+								parts = SETANIM_BOTH;
+							}
+							PM_SetAnim( pm, parts, anim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD, 0 );
+							if ( /*anim == BOTH_BUTTERFLY_LEFT
+								|| anim == BOTH_BUTTERFLY_RIGHT
+								||*/ anim == BOTH_FJSS_TR_BL
+								|| anim == BOTH_FJSS_TL_BR 
+								|| anim == BOTH_FORCEWALLRUNFLIP_START )
+							{
+								pm->ps->weaponTime = pm->ps->torsoAnimTimer;
+							}
+							else if ( anim == BOTH_WALL_FLIP_LEFT
+									|| anim == BOTH_WALL_FLIP_RIGHT
+									|| anim == BOTH_WALL_FLIP_BACK1 )
+							{//let us do some more moves after this
+								pm->ps->saberAttackChainCount = 0;
+							}
+						}
+						pm->ps->forceJumpZStart = pm->ps->origin[2];//so we don't take damage if we land at same height
+						pm->ps->pm_flags |= (PMF_JUMPING|PMF_SLOW_MO_FALL);
+						pm->cmd.upmove = 0;
+						G_SoundOnEnt( pm->gent, CHAN_BODY, "sound/weapons/force/jump.wav" );
+						WP_ForcePowerDrain( pm->gent, FP_LEVITATION, forcePowerCostOverride );
+					}
+				}
+			}
+		}
+		else 
+		{//in the air
+			int legsAnim = pm->ps->legsAnim;
+
+			if ( legsAnim == BOTH_WALL_RUN_LEFT || legsAnim == BOTH_WALL_RUN_RIGHT )
+			{//running on a wall
+				vec3_t right, traceto, mins = {pm->mins[0],pm->mins[0],0}, maxs = {pm->maxs[0],pm->maxs[0],24}, fwdAngles = {0, pm->ps->viewangles[YAW], 0};
+				trace_t	trace;
+				int		anim = -1;
+
+				AngleVectors( fwdAngles, NULL, right, NULL );
+
+				if ( legsAnim == BOTH_WALL_RUN_LEFT )
+				{
+					if ( pm->ps->legsAnimTimer > 400 )
+					{//not at the end of the anim
+						float animLen = PM_AnimLength( pm->gent->client->clientInfo.animFileIndex, BOTH_WALL_RUN_LEFT );
+						if ( pm->ps->legsAnimTimer < animLen - 400 )
+						{//not at start of anim
+							VectorMA( pm->ps->origin, -16, right, traceto );
+							anim = BOTH_WALL_RUN_LEFT_FLIP;
+						}
+					}
+				}
+				else if ( legsAnim == BOTH_WALL_RUN_RIGHT )
+				{
+					if ( pm->ps->legsAnimTimer > 400 )
+					{//not at the end of the anim
+						float animLen = PM_AnimLength( pm->gent->client->clientInfo.animFileIndex, BOTH_WALL_RUN_RIGHT );
+						if ( pm->ps->legsAnimTimer < animLen - 400 )
+						{//not at start of anim
+							VectorMA( pm->ps->origin, 16, right, traceto );
+							anim = BOTH_WALL_RUN_RIGHT_FLIP;
+						}
+					}
+				}
+				if ( anim != -1 )
+				{
+					pm->trace( &trace, pm->ps->origin, mins, maxs, traceto, pm->ps->clientNum, CONTENTS_SOLID|CONTENTS_BODY );
+					if ( trace.fraction < 1.0f )
+					{//flip off wall
+						if ( anim == BOTH_WALL_RUN_LEFT_FLIP )
+						{
+							pm->ps->velocity[0] *= 0.5f;
+							pm->ps->velocity[1] *= 0.5f;
+							VectorMA( pm->ps->velocity, 150, right, pm->ps->velocity );
+						}
+						else if ( anim == BOTH_WALL_RUN_RIGHT_FLIP )
+						{
+							pm->ps->velocity[0] *= 0.5f;
+							pm->ps->velocity[1] *= 0.5f;
+							VectorMA( pm->ps->velocity, -150, right, pm->ps->velocity );
+						}
+						PM_SetAnim( pm, SETANIM_BOTH, anim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD, 0 );
+						pm->ps->pm_flags |= PMF_JUMPING|PMF_SLOW_MO_FALL;
+						pm->cmd.upmove = 0;
+					}
+				}
+				if ( pm->cmd.upmove != 0 )
+				{//jump failed, so don't try to do normal jump code, just return
+					return qfalse;
+				}
+			}
+			else if ( pm->ps->legsAnim == BOTH_FORCEWALLRUNFLIP_START )
+			{//want to jump off wall
+				vec3_t fwd, traceto, mins = {pm->mins[0],pm->mins[0],0}, maxs = {pm->maxs[0],pm->maxs[0],24}, fwdAngles = {0, pm->ps->viewangles[YAW], 0};
+				trace_t	trace;
+				int		anim = -1;
+
+				AngleVectors( fwdAngles, fwd, NULL, NULL );
+
+				float animLen = PM_AnimLength( pm->gent->client->clientInfo.animFileIndex, BOTH_FORCEWALLRUNFLIP_START );
+				if ( pm->ps->legsAnimTimer < animLen - 250 )//was 400
+				{//not at start of anim
+					VectorMA( pm->ps->origin, 16, fwd, traceto );
+					anim = BOTH_FORCEWALLRUNFLIP_END;
+				}
+				if ( anim != -1 )
+				{
+					pm->trace( &trace, pm->ps->origin, mins, maxs, traceto, pm->ps->clientNum, CONTENTS_SOLID|CONTENTS_BODY );
+					if ( trace.fraction < 1.0f )
+					{//flip off wall
+						pm->ps->velocity[0] *= 0.5f;
+						pm->ps->velocity[1] *= 0.5f;
+						VectorMA( pm->ps->velocity, WALL_RUN_UP_BACKFLIP_SPEED, fwd, pm->ps->velocity );
+						pm->ps->velocity[2] += 200;
+						int parts = SETANIM_LEGS;
+						if ( !pm->ps->weaponTime )
+						{//not attacking, set anim on both
+							parts = SETANIM_BOTH;
+						}
+						PM_SetAnim( pm, parts, anim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD, 0 );
+						//FIXME: do damage to traceEnt, like above?
+						pm->ps->pm_flags |= PMF_JUMPING|PMF_SLOW_MO_FALL;
+						pm->cmd.upmove = 0;
+						PM_AddEvent( EV_JUMP );
+					}
+				}
+				if ( pm->cmd.upmove != 0 )
+				{//jump failed, so don't try to do normal jump code, just return
+					return qfalse;
+				}
+			}
+			/*
+			else if ( pm->cmd.forwardmove < 0 
+				&& pm->ps->forcePowerLevel[FP_LEVITATION] > FORCE_LEVEL_1 
+				&& !(pm->ps->pm_flags&PMF_JUMP_HELD) //not holding jump
+				&& (level.time - pm->ps->lastOnGround) <= 250 //just jumped
+				)//&& !(pm->cmd.buttons&BUTTON_ATTACK) )
+			{//double-tap back-jump does backflip
+				vec3_t fwd, fwdAngles = {0, pm->ps->viewangles[YAW], 0};
+
+				AngleVectors( fwdAngles, fwd, NULL, NULL );
+				pm->ps->velocity[0] = pm->ps->velocity[1] = 0;
+				VectorMA( pm->ps->velocity, -150, fwd, pm->ps->velocity );
+				//pm->ps->velocity[2] = JUMP_VELOCITY;
+				int parts = SETANIM_LEGS;
+				if ( !pm->ps->weaponTime )
+				{
+					parts = SETANIM_BOTH;
+				}
+				PM_SetAnim( pm, parts, PM_PickAnim( pm->gent, BOTH_FLIP_BACK1, BOTH_FLIP_BACK3 ), SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD, 0 );
+				pm->ps->forceJumpZStart = pm->ps->origin[2];//so we don't take damage if we land at same height
+				pm->ps->pm_flags |= PMF_JUMPING|PMF_SLOW_MO_FALL;
+				pm->cmd.upmove = 0;
+				G_SoundOnEnt( pm->gent, CHAN_BODY, "sound/weapons/force/jump.wav" );
+				WP_ForcePowerDrain( pm->gent, FP_LEVITATION, 0 );
+			}
+			*/
+			/*
+			else if ( pm->cmd.forwardmove > 0 //pushing forward
+				&& pm->ps->forceRageRecoveryTime < pm->cmd.serverTime	//not in a force Rage recovery period
+				&& pm->ps->forcePowerLevel[FP_LEVITATION] > FORCE_LEVEL_1 //have force jump 2 or higher
+				&& (level.time - pm->ps->lastOnGround) <= 250//just jumped
+				&& (pm->ps->legsAnim == BOTH_JUMP1 || pm->ps->legsAnim == BOTH_INAIR1 )//not in a flip or spin or anything
+			{//run up wall, flip backwards
+				//FIXME: have to be moving... make sure it's opposite the wall... or at least forward?
+				int wallWalkAnim = BOTH_WALL_FLIP_BACK1;
+				int parts = SETANIM_LEGS;
+				int contents = CONTENTS_SOLID;
+				qboolean kick = qtrue;
+				if ( pm->ps->forcePowerLevel[FP_LEVITATION] > FORCE_LEVEL_2 )
+				{
+					wallWalkAnim = BOTH_FORCEWALLRUNFLIP_START;
+					parts = SETANIM_BOTH;
+					kick = qfalse;
+				}
+				else
+				{
+					contents |= CONTENTS_BODY;
+					if ( !pm->ps->weaponTime )
+					{
+						parts = SETANIM_BOTH;
+					}
+				}
+				if ( PM_HasAnimation( pm->gent, wallWalkAnim ) )
+				{
+					vec3_t fwd, traceto, mins = {pm->mins[0],pm->mins[1],0}, maxs = {pm->maxs[0],pm->maxs[1],24}, fwdAngles = {0, pm->ps->viewangles[YAW], 0};
+					trace_t	trace;
+					vec3_t	idealNormal;
+
+					AngleVectors( fwdAngles, fwd, NULL, NULL );
+					VectorMA( pm->ps->origin, 32, fwd, traceto );
+
+					pm->trace( &trace, pm->ps->origin, mins, maxs, traceto, pm->ps->clientNum, contents );//FIXME: clip brushes too?
+					VectorSubtract( pm->ps->origin, traceto, idealNormal );
+					VectorNormalize( idealNormal );
+					gentity_t *traceEnt = &g_entities[trace.entityNum];
+					
+					if ( trace.fraction < 1.0f
+						&&((trace.entityNum<ENTITYNUM_WORLD&&traceEnt&&traceEnt->s.solid!=SOLID_BMODEL)||DotProduct(trace.plane.normal,idealNormal)>0.7) )
+					{//there is a wall there
+						pm->ps->velocity[0] = pm->ps->velocity[1] = 0;
+						if ( wallWalkAnim == BOTH_FORCEWALLRUNFLIP_START )
+						{
+							pm->ps->velocity[2] = forceJumpStrength[FORCE_LEVEL_3]/2.0f;
+						}
+						else
+						{
+							VectorMA( pm->ps->velocity, -150, fwd, pm->ps->velocity );
+						}
+						//animate me
+						PM_SetAnim( pm, parts, wallWalkAnim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD, 0 );
+						pm->ps->forceJumpZStart = pm->ps->origin[2];//so we don't take damage if we land at same height
+						pm->ps->pm_flags |= PMF_JUMPING|PMF_SLOW_MO_FALL;
+						pm->cmd.upmove = 0;
+						G_SoundOnEnt( pm->gent, CHAN_BODY, "sound/weapons/force/jump.wav" );
+						WP_ForcePowerDrain( pm->gent, FP_LEVITATION, 0 );
+						//kick if jumping off an ent
+						if ( kick && pm->gent && trace.entityNum < ENTITYNUM_WORLD )
+						{
+							if ( traceEnt 
+								&& traceEnt->client 
+								&& traceEnt->health > 0 
+								&& traceEnt->takedamage 
+								&& traceEnt->client->NPC_class != CLASS_GALAKMECH
+								&& traceEnt->client->NPC_class != CLASS_DESANN
+								&& !(traceEnt->flags&FL_NO_KNOCKBACK) )
+							{//push them away and do pain
+								vec3_t oppDir;
+								float strength = VectorNormalize2( pm->ps->velocity, oppDir );
+								VectorScale( oppDir, -1, oppDir );
+								//FIXME: need knockdown anim
+								G_Damage( traceEnt, pm->gent, pm->gent, oppDir, traceEnt->currentOrigin, 10, DAMAGE_NO_ARMOR|DAMAGE_NO_HIT_LOC|DAMAGE_NO_KNOCKBACK, MOD_MELEE );
+								G_Sound( traceEnt, G_SoundIndex( va("sound/weapons/melee/punch%d", Q_irand(1, 4)) ) );
+								if ( trace.fraction <= 0.5f )
+								{//close to him
+									if ( traceEnt->health > 0 )
+									{//didn't kill him
+										if ( (traceEnt->s.number==0&&!Q_irand(0,g_spskill->integer)) 
+											|| (traceEnt->NPC!=NULL&&Q_irand(RANK_CIVILIAN,traceEnt->NPC->rank)+Q_irand(-2,2)<RANK_ENSIGN) )
+										{
+											NPC_SetAnim( traceEnt, SETANIM_BOTH, BOTH_KNOCKDOWN2, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+											G_Throw( traceEnt, oppDir, strength );
+										}
+									}
+								}
+							}
+						}
+					}
+				}
+			}
+			*/
+			else if ( (pm->ps->legsAnimTimer<=100
+						||!PM_InSpecialJump( legsAnim )//not in a special jump anim 
+						||PM_InReboundJump( legsAnim )//we're already in a rebound
+						||PM_InBackFlip( legsAnim ) )//a backflip (needed so you can jump off a wall behind you)
+					//&& pm->ps->velocity[2] <= 0 
+					&& pm->ps->velocity[2] > -1200 //not falling down very fast
+					&& !(pm->ps->pm_flags&PMF_JUMP_HELD)//have to have released jump since last press
+					&& (pm->cmd.forwardmove||pm->cmd.rightmove)//pushing in a direction
+					//&& pm->ps->forceRageRecoveryTime < pm->cmd.serverTime	//not in a force Rage recovery period
+					&& pm->ps->forcePowerLevel[FP_LEVITATION] > FORCE_LEVEL_2//level 3 jump or better
+					&& pm->ps->forcePower > 10 //have enough force power to do another one
+					&& (level.time-pm->ps->lastOnGround) > 250 //haven't been on the ground in the last 1/4 of a second
+					&& (!(pm->ps->pm_flags&PMF_JUMPING)//not jumping
+						|| ( (level.time-pm->ps->lastOnGround) > 250 //we are jumping, but have been in the air for at least half a second
+							 &&( g_debugMelee->integer//if you know kung fu, no height cap on wall-grab-jumps
+								|| ((pm->ps->origin[2]-pm->ps->forceJumpZStart) < (forceJumpHeightMax[FORCE_LEVEL_3]-(G_ForceWallJumpStrength()/2.0f))) )//can fit at least one more wall jump in (yes, using "magic numbers"... for now)
+							)
+						)
+					//&& (pm->ps->legsAnim == BOTH_JUMP1 || pm->ps->legsAnim == BOTH_INAIR1 ) )//not in a flip or spin or anything
+					)
+			{//see if we're pushing at a wall and jump off it if so
+				//FIXME: make sure we have enough force power
+				//FIXME: check  to see if we can go any higher
+				//FIXME: limit to a certain number of these in a row?
+				//FIXME: maybe don't require a ucmd direction, just check all 4?
+				//FIXME: should stick to the wall for a second, then push off...
+				vec3_t checkDir, traceto, mins = {pm->mins[0],pm->mins[1],0}, maxs = {pm->maxs[0],pm->maxs[1],24}, fwdAngles = {0, pm->ps->viewangles[YAW], 0};
+				trace_t	trace;
+				vec3_t	idealNormal;
+				int		anim = -1;
+
+				if ( pm->cmd.rightmove )
+				{
+					if ( pm->cmd.rightmove > 0 )
+					{
+						anim = BOTH_FORCEWALLREBOUND_RIGHT;
+						AngleVectors( fwdAngles, NULL, checkDir, NULL );
+					}
+					else if ( pm->cmd.rightmove < 0 )
+					{
+						anim = BOTH_FORCEWALLREBOUND_LEFT;
+						AngleVectors( fwdAngles, NULL, checkDir, NULL );
+						VectorScale( checkDir, -1, checkDir );
+					}
+				}
+				else if ( pm->cmd.forwardmove > 0 )
+				{
+					anim = BOTH_FORCEWALLREBOUND_FORWARD;
+					AngleVectors( fwdAngles, checkDir, NULL, NULL );
+				}
+				else if ( pm->cmd.forwardmove < 0 )
+				{
+					anim = BOTH_FORCEWALLREBOUND_BACK;
+					AngleVectors( fwdAngles, checkDir, NULL, NULL );
+					VectorScale( checkDir, -1, checkDir );
+				}
+				if ( anim != -1 )
+				{//trace in the dir we're pushing in and see if there's a vertical wall there
+					VectorMA( pm->ps->origin, 16, checkDir, traceto );//was 8
+					pm->trace( &trace, pm->ps->origin, mins, maxs, traceto, pm->ps->clientNum, CONTENTS_SOLID );//FIXME: clip brushes too?
+					VectorSubtract( pm->ps->origin, traceto, idealNormal );
+					VectorNormalize( idealNormal );
+					gentity_t *traceEnt = &g_entities[trace.entityNum];
+					if ( trace.fraction < 1.0f
+						&& fabs(trace.plane.normal[2]) <= MAX_WALL_GRAB_SLOPE
+						&&((trace.entityNum<ENTITYNUM_WORLD&&traceEnt&&traceEnt->s.solid!=SOLID_BMODEL)||DotProduct(trace.plane.normal,idealNormal)>0.7) )
+					{//there is a wall there
+						float dot = DotProduct( pm->ps->velocity, trace.plane.normal );
+						if ( dot < 1.0f )
+						{//can't be heading *away* from the wall!
+							//grab it!
+							PM_GrabWallForJump( anim );
+						}
+					}
+				}
+			}
+			else
+			{
+				//FIXME: if in a butterfly, kick people away?
+			}
+		}
+	}
+
+	if ( pm->gent
+		//&& pm->cmd.upmove > 0 
+		&& pm->ps->forceRageRecoveryTime < pm->cmd.serverTime	//not in a force Rage recovery period
+		&& pm->ps->weapon == WP_SABER
+		&& (pm->ps->weaponTime > 0||(pm->cmd.buttons&BUTTON_ATTACK))
+		&& ((pm->ps->clientNum&&!PM_ControlledByPlayer())||((pm->ps->clientNum < MAX_CLIENTS||PM_ControlledByPlayer()) && cg.renderingThirdPerson && !cg.zoomMode)) )
+	{//okay, we just jumped and we're in an attack
+		if ( !PM_RollingAnim( pm->ps->legsAnim )
+			&& !PM_InKnockDown( pm->ps )
+			&& !PM_InDeathAnim()
+			&& !PM_PainAnim( pm->ps->torsoAnim )
+			&& !PM_FlippingAnim( pm->ps->legsAnim )
+			&& !PM_SpinningAnim( pm->ps->legsAnim )
+			&& !PM_SaberInSpecialAttack( pm->ps->torsoAnim ) )
+		{//HMM... do NPCs need this logic?
+			if ( !PM_SaberInTransitionAny( pm->ps->saberMove ) //not going to/from/between an attack anim
+				&& !PM_SaberInAttack( pm->ps->saberMove ) //not in attack anim
+				&& pm->ps->weaponTime <= 0//not busy
+				&& (pm->cmd.buttons&BUTTON_ATTACK) )//want to attack
+			{//not in an attack or finishing/starting/transitioning one
+				if ( PM_CheckBackflipAttackMove() )
+				{
+					PM_SetSaberMove( PM_SaberBackflipAttackMove() );//backflip attack
+				}
+				/*
+				else if ( PM_CheckSaberDualJumpAttackMove() )
+				{
+					PM_SetSaberMove( PM_SaberDualJumpAttackMove() );//jump forward sideways flip attack
+				}
+				*/
+			}
+			/*
+			else if ( ( PM_SaberInTransitionAny( pm->ps->saberMove ) || PM_SaberInAttack( pm->ps->saberMove ) )
+				&& PM_InAnimForSaberMove( pm->ps->torsoAnim, pm->ps->saberMove ) )
+			{//not in an anim we shouldn't interrupt
+				//see if it's not too late to start a special jump-attack
+				float animLength = PM_AnimLength( g_entities[pm->ps->clientNum].client->clientInfo.animFileIndex, (animNumber_t)pm->ps->torsoAnim );
+				if ( animLength - pm->ps->torsoAnimTimer < 500 )
+				{//just started the saberMove
+					//check for special-case jump attacks
+					if ( PM_CheckFlipOverAttackMove( qtrue ) )
+					{
+						PM_SetSaberMove( PM_SaberFlipOverAttackMove() );
+					}
+					else if ( PM_CheckJumpAttackMove() )
+					{
+						PM_SetSaberMove( PM_SaberJumpAttackMove() );
+					}
+				}
+			}
+			*/
+		}
+	}
+	if ( pm->ps->groundEntityNum == ENTITYNUM_NONE )
+	{
+		return qfalse;
+	}
+	if ( pm->cmd.upmove > 0 )
+	{//no special jumps
+		/*
+		gentity_t *groundEnt = &g_entities[pm->ps->groundEntityNum];
+		if ( groundEnt && groundEnt->NPC )
+		{//Can't jump off of someone's head
+			return qfalse;
+		}
+		*/
+
+		pm->ps->velocity[2] = JUMP_VELOCITY;
+		pm->ps->forceJumpZStart = pm->ps->origin[2];//so we don't take damage if we land at same height
+		pm->ps->pm_flags |= PMF_JUMPING;
+	}
+
+	if ( d_JediAI->integer )
+	{
+		if ( pm->ps->clientNum && pm->ps->weapon == WP_SABER )
+		{
+			Com_Printf( "jumping\n" );
+		}
+	}
+	//Jumping
+	pml.groundPlane = qfalse;
+	pml.walking = qfalse;
+	pm->ps->pm_flags |= PMF_JUMP_HELD;
+	pm->ps->groundEntityNum = ENTITYNUM_NONE;
+	pm->ps->jumpZStart = pm->ps->origin[2];
+
+	if ( pm->gent )
+	{
+		if ( !Q3_TaskIDPending( pm->gent, TID_CHAN_VOICE ) )
+		{
+			PM_AddEvent( EV_JUMP );
+		}
+	}
+	else
+	{
+		PM_AddEvent( EV_JUMP );
+	}
+
+	//Set the animations
+	if ( pm->ps->gravity > 0 && !PM_InSpecialJump( pm->ps->legsAnim ) && !PM_InGetUp( pm->ps ) )
+	{
+		PM_JumpForDir();
+	}
+
+	return qtrue;
+}
+
+/*
+=============
+PM_CheckWaterJump
+=============
+*/
+static qboolean	PM_CheckWaterJump( void ) {
+	vec3_t	spot;
+	int		cont;
+	vec3_t	flatforward;
+
+	if (pm->ps->pm_time) {
+		return qfalse;
+	}
+
+	if ( pm->cmd.forwardmove <= 0 && pm->cmd.upmove <= 0 )
+	{//they must not want to get out?
+		return qfalse;
+	}
+	// check for water jump
+	if ( pm->waterlevel != 2 ) {
+		return qfalse;
+	}
+
+	if ( pm->watertype & CONTENTS_LADDER ) {
+		if (pm->ps->velocity[2] <= 0)
+			return qfalse;
+	}
+
+	flatforward[0] = pml.forward[0];
+	flatforward[1] = pml.forward[1];
+	flatforward[2] = 0;
+	VectorNormalize( flatforward );
+
+	VectorMA( pm->ps->origin, 30, flatforward, spot );
+	spot[2] += 24;
+	cont = pm->pointcontents (spot, pm->ps->clientNum );
+	if ( !(cont & CONTENTS_SOLID) ) {
+		return qfalse;
+	}
+	
+	spot[2] += 16;
+	cont = pm->pointcontents( spot, pm->ps->clientNum );
+	if ( cont&(CONTENTS_SOLID|CONTENTS_PLAYERCLIP|CONTENTS_WATER|CONTENTS_SLIME|CONTENTS_LAVA|CONTENTS_BODY) ) {
+		return qfalse;
+	}
+
+	// jump out of water
+	VectorScale( pml.forward, 200, pm->ps->velocity );
+	pm->ps->velocity[2] = 350+((pm->ps->waterheight-pm->ps->origin[2])*2);
+
+	pm->ps->pm_flags |= PMF_TIME_WATERJUMP;
+	pm->ps->pm_time = 2000;
+
+	return qtrue;
+}
+
+//============================================================================
+
+
+/*
+===================
+PM_WaterJumpMove
+
+Flying out of the water
+===================
+*/
+static void PM_WaterJumpMove( void ) 
+{
+	// waterjump has no control, but falls
+
+	PM_StepSlideMove( 1 );
+
+	pm->ps->velocity[2] -= pm->ps->gravity * pml.frametime;
+	if (pm->ps->velocity[2] < 0) 
+	{
+		// cancel as soon as we are falling down again
+		pm->ps->pm_flags &= ~PMF_ALL_TIMES;
+		pm->ps->pm_time = 0;
+	}
+}
+
+/*
+===================
+PM_WaterMove
+
+===================
+*/
+static void PM_WaterMove( void ) {
+	int		i;
+	vec3_t	wishvel;
+	float	wishspeed;
+	vec3_t	wishdir;
+	float	scale;
+	float	vel;
+
+	if ( PM_CheckWaterJump() ) 	{
+		PM_WaterJumpMove();
+		return;
+	}
+	else if ( pm->ps->forcePowerLevel[FP_LEVITATION] > FORCE_LEVEL_0 && pm->waterlevel < 3 )
+	{
+		if ( PM_CheckJump () ) {
+			// jumped away
+			return;
+		}
+	}
+#if 0
+	// jump = head for surface
+	if ( pm->cmd.upmove >= 10 ) {
+		if (pm->ps->velocity[2] > -300) {
+			if ( pm->watertype == CONTENTS_WATER ) {
+				pm->ps->velocity[2] = 100;
+			} else if (pm->watertype == CONTENTS_SLIME) {
+				pm->ps->velocity[2] = 80;
+			} else {
+				pm->ps->velocity[2] = 50;
+			}
+		}
+	}
+#endif
+	PM_Friction ();
+
+	scale = PM_CmdScale( &pm->cmd );
+	//
+	// user intentions
+	//
+	if ( !scale ) {
+		wishvel[0] = 0;
+		wishvel[1] = 0;
+		if ( pm->watertype & CONTENTS_LADDER ) {
+			wishvel[2] = 0;
+		} else {
+			wishvel[2] = -60;		// sink towards bottom
+		}
+	} else {
+		for (i=0 ; i<3 ; i++) {
+			wishvel[i] = scale * pml.forward[i]*pm->cmd.forwardmove + scale * pml.right[i]*pm->cmd.rightmove;
+		}
+		wishvel[2] += scale * pm->cmd.upmove;
+		if ( !(pm->watertype&CONTENTS_LADDER) )	//ladder
+		{
+			float depth = (pm->ps->origin[2]+pm->gent->client->standheight)-pm->ps->waterheight;
+			if ( depth >= 12 )
+			{//too high!
+				wishvel[2] -= 120;		// sink towards bottom
+				if ( wishvel[2] > 0 )
+				{
+					wishvel[2] = 0;
+				}
+			}
+			else if ( pm->ps->waterHeightLevel >= WHL_UNDER )//!depth && pm->waterlevel == 3 )
+			{
+			}
+			else if ( depth < 12 )
+			{//still deep
+				wishvel[2] -= 60;		// sink towards bottom
+				if ( wishvel[2] > 30 )
+				{
+					wishvel[2] = 30;
+				}
+			}
+		}
+	}
+
+	VectorCopy (wishvel, wishdir);
+	wishspeed = VectorNormalize(wishdir);
+
+	if ( pm->watertype & CONTENTS_LADDER )	//ladder
+	{
+		if ( wishspeed > pm->ps->speed * pm_ladderScale ) {
+			wishspeed = pm->ps->speed * pm_ladderScale;
+		}
+		PM_Accelerate( wishdir, wishspeed, pm_flyaccelerate );
+	} else {
+		if ( pm->ps->gravity < 0 )
+		{//float up
+			pm->ps->velocity[2] -= pm->ps->gravity * pml.frametime;
+		}
+		if ( wishspeed > pm->ps->speed * pm_swimScale ) {
+			wishspeed = pm->ps->speed * pm_swimScale;
+		}
+		PM_Accelerate( wishdir, wishspeed, pm_wateraccelerate );
+	}
+
+	// make sure we can go up slopes easily under water
+	if ( pml.groundPlane && DotProduct( pm->ps->velocity, pml.groundTrace.plane.normal ) < 0 ) {
+		vel = VectorLength(pm->ps->velocity);
+		// slide along the ground plane
+		PM_ClipVelocity (pm->ps->velocity, pml.groundTrace.plane.normal, 
+			pm->ps->velocity, OVERCLIP );
+
+		VectorNormalize(pm->ps->velocity);
+		VectorScale(pm->ps->velocity, vel, pm->ps->velocity);
+	}
+
+	PM_SlideMove( qfalse );
+}
+
+
+/*
+===================
+PM_FlyVehicleMove
+
+===================
+*/
+static void PM_FlyVehicleMove( void ) 
+{
+	int		i;
+	vec3_t	wishvel;
+	float	wishspeed;
+	vec3_t	wishdir;
+	float	scale;
+	float	zVel;
+	float	fmove = 0.0f, smove = 0.0f;
+
+	// We don't use these here because we pre-calculate the movedir in the vehicle update anyways, and if
+	// you leave this, you get strange motion during boarding (the player can move the vehicle).
+	//fmove = pm->cmd.forwardmove;
+	//smove = pm->cmd.rightmove;
+
+	// normal slowdown
+	if ( pm->ps->gravity && pm->ps->velocity[2] < 0 && pm->ps->groundEntityNum == ENTITYNUM_NONE )
+	{//falling
+		zVel = pm->ps->velocity[2];
+		PM_Friction ();
+		pm->ps->velocity[2] = zVel;
+	}
+	else
+	{
+		PM_Friction ();
+		if ( pm->ps->velocity[2] < 0 && pm->ps->groundEntityNum != ENTITYNUM_NONE )
+		{
+			pm->ps->velocity[2] = 0;	// ignore slope movement
+		}
+	}
+
+	scale = PM_CmdScale( &pm->cmd );
+
+	// Get The WishVel And WishSpeed
+	//-------------------------------   
+	if ( pm->ps->clientNum && (USENEWNAVSYSTEM || !VectorCompare( pm->ps->moveDir, vec3_origin )) )
+	{//NPC
+		
+		// If The UCmds Were Set, But Never Converted Into A MoveDir, Then Make The WishDir From UCmds
+		//--------------------------------------------------------------------------------------------
+		if ((fmove!=0.0f || smove!=0.0f) &&	VectorCompare(pm->ps->moveDir, vec3_origin))
+		{
+			//gi.Printf("Generating MoveDir\n");
+			for ( i = 0 ; i < 3 ; i++ ) 
+			{
+				wishvel[i] = pml.forward[i]*fmove + pml.right[i]*smove;
+			}
+
+			VectorCopy( wishvel, wishdir );
+			wishspeed = VectorNormalize(wishdir);
+			wishspeed *= scale;
+		}
+		// Otherwise, Use The Move Dir
+		//-----------------------------
+		else
+		{
+			wishspeed = pm->ps->speed;
+			VectorScale( pm->ps->moveDir, pm->ps->speed, wishvel );
+			VectorCopy( pm->ps->moveDir, wishdir );
+		}
+
+	}
+	else
+	{
+		for ( i = 0 ; i < 3 ; i++ ) {
+			wishvel[i] = pml.forward[i]*fmove + pml.right[i]*smove;
+		}
+		// when going up or down slopes the wish velocity should Not be zero
+	//	wishvel[2] = 0;
+
+		VectorCopy (wishvel, wishdir);
+		wishspeed = VectorNormalize(wishdir);
+		wishspeed *= scale;
+	}
+
+	// Handle negative speed.
+	if ( wishspeed < 0 )
+	{
+		wishspeed = wishspeed * -1.0f;
+		VectorScale( wishvel, -1.0f, wishvel );
+		VectorScale( wishdir, -1.0f, wishdir );
+	}
+
+	VectorCopy( wishvel, wishdir );
+	wishspeed = VectorNormalize( wishdir );
+
+	PM_Accelerate( wishdir, wishspeed, 100 );
+
+	PM_StepSlideMove( 1 );
+}
+
+/*
+===================
+PM_FlyMove
+
+Only with the flight powerup
+===================
+*/
+static void PM_FlyMove( void ) 
+{
+	int		i;
+	vec3_t	wishvel;
+	float	wishspeed;
+	vec3_t	wishdir;
+	float	scale;
+	float	accel;
+	qboolean	lowGravMove = qfalse;
+	qboolean	jetPackMove = qfalse;
+
+	// normal slowdown
+	PM_Friction ();
+
+	if ( (pm->ps->clientNum < MAX_CLIENTS||PM_ControlledByPlayer())
+		&& pm->gent 
+		&& pm->gent->client 
+		&& (pm->gent->client->NPC_class == CLASS_BOBAFETT||pm->gent->client->NPC_class == CLASS_ROCKETTROOPER) && pm->gent->client->moveType == MT_FLYSWIM )
+	{//jetpack accel
+		accel = pm_flyaccelerate;
+		jetPackMove = qtrue;
+	}
+	else if ( pm->ps->gravity <= 0
+		&& ((pm->ps->clientNum < MAX_CLIENTS||PM_ControlledByPlayer()) || (pm->gent&&pm->gent->client&&pm->gent->client->moveType == MT_RUNJUMP)) )
+	{
+		PM_CheckJump();
+		accel = 1.0f;
+		pm->ps->velocity[2] -= pm->ps->gravity * pml.frametime;
+		pm->ps->jumpZStart = pm->ps->origin[2];//so we don't take a lot of damage when the gravity comes back on
+		lowGravMove = qtrue;
+	}
+	else
+	{
+		accel = pm_flyaccelerate;
+	}
+
+	scale = PM_CmdScale( &pm->cmd );
+	//
+	// user intentions
+	//
+	if ( !scale ) 
+	{
+		wishvel[0] = 0;
+		wishvel[1] = 0;
+		wishvel[2] = 0;
+	} 
+	else
+	{
+		for (i=0 ; i<3 ; i++) 
+		{
+			wishvel[i] = scale * pml.forward[i]*pm->cmd.forwardmove + scale * pml.right[i]*pm->cmd.rightmove;
+		}
+		if ( jetPackMove )
+		{
+			wishvel[2] += pm->cmd.upmove;
+		}
+		else if ( lowGravMove )
+		{
+			wishvel[2] += scale * pm->cmd.upmove;
+			VectorScale( wishvel, 0.5f, wishvel );
+		}
+	}
+
+	VectorCopy( wishvel, wishdir );
+	wishspeed = VectorNormalize( wishdir );
+
+	PM_Accelerate( wishdir, wishspeed, accel );
+
+	PM_StepSlideMove( 1 );
+}
+
+qboolean PM_GroundSlideOkay( float zNormal )
+{
+	if ( zNormal > 0 )
+	{
+		if ( pm->ps->velocity[2] > 0 )
+		{
+			if ( pm->ps->legsAnim == BOTH_WALL_RUN_RIGHT
+				|| pm->ps->legsAnim == BOTH_WALL_RUN_LEFT 
+				|| pm->ps->legsAnim == BOTH_WALL_RUN_RIGHT_STOP
+				|| pm->ps->legsAnim == BOTH_WALL_RUN_LEFT_STOP 
+				|| pm->ps->legsAnim == BOTH_FORCEWALLRUNFLIP_START 
+				|| pm->ps->legsAnim == BOTH_FORCELONGLEAP_START
+				|| pm->ps->legsAnim == BOTH_FORCELONGLEAP_ATTACK
+				|| pm->ps->legsAnim == BOTH_FORCELONGLEAP_LAND
+				|| PM_InReboundJump( pm->ps->legsAnim ))
+			{
+				return qfalse;
+			}
+		}
+	}
+	return qtrue;
+}
+/*
+===================
+PM_AirMove
+
+===================
+*/
+static void PM_AirMove( void ) {
+	int			i;
+	vec3_t		wishvel;
+	float		fmove, smove;
+	vec3_t		wishdir;
+	float		wishspeed;
+	float		scale;
+	usercmd_t	cmd;
+	float		gravMod = 1.0f;
+
+#if METROID_JUMP
+	PM_CheckJump();
+#endif
+
+	PM_Friction();
+
+	fmove = pm->cmd.forwardmove;
+	smove = pm->cmd.rightmove;
+
+	cmd = pm->cmd;
+	scale = PM_CmdScale( &cmd );
+
+	// set the movementDir so clients can rotate the legs for strafing
+	PM_SetMovementDir();
+
+	// project moves down to flat plane
+	pml.forward[2] = 0;
+	pml.right[2] = 0;
+	VectorNormalize (pml.forward);
+	VectorNormalize (pml.right);
+
+	Vehicle_t *pVeh = NULL;
+
+	if ( pm->gent->client && pm->gent->client->NPC_class == CLASS_VEHICLE )
+	{
+		pVeh = pm->gent->m_pVehicle;
+	}
+
+	if ( pVeh && pVeh->m_pVehicleInfo->hoverHeight > 0 )
+	{//in a hovering vehicle, have air control
+
+		// Flying Or Breaking, No Control
+		//--------------------------------
+		if ( pVeh->m_ulFlags&VEH_FLYING || pVeh->m_ulFlags&VEH_SLIDEBREAKING)
+		{
+			wishspeed = 0.0f;
+			VectorClear( wishvel );
+			VectorClear( wishdir );
+		}
+
+		// Out Of Control - Maintain pos3 Velocity
+		//-----------------------------------------
+		else if ((pVeh->m_ulFlags&VEH_OUTOFCONTROL) || (pVeh->m_ulFlags&VEH_STRAFERAM))
+		{
+ 			VectorCopy(pm->gent->pos3, wishvel);
+			VectorCopy(wishvel, wishdir);
+			wishspeed = VectorNormalize(wishdir);
+		}
+
+		// Boarding - Maintain Boarding Velocity
+		//---------------------------------------
+		else if (pVeh->m_iBoarding)
+		{
+			VectorCopy(pVeh->m_vBoardingVelocity, wishvel);
+			VectorCopy(wishvel, wishdir);
+			wishspeed = VectorNormalize(wishdir);
+		}
+
+		// Otherwise, Normal Velocity
+		//----------------------------
+		else
+		{
+			wishspeed = pm->ps->speed;
+			VectorScale( pm->ps->moveDir, pm->ps->speed, wishvel );
+			VectorCopy( pm->ps->moveDir, wishdir );
+		}
+	}
+	else if ( (pm->ps->pm_flags&PMF_SLOW_MO_FALL) )
+	{//no air-control
+		VectorClear( wishvel );
+	}
+	else
+	{
+		for ( i = 0 ; i < 2 ; i++ ) 
+		{
+			wishvel[i] = pml.forward[i]*fmove + pml.right[i]*smove;
+		}
+		wishvel[2] = 0;
+	}
+
+	VectorCopy (wishvel, wishdir);
+ 	wishspeed = VectorNormalize(wishdir);
+
+	if ( ( DotProduct (pm->ps->velocity, wishdir) ) < 0.0f )
+	{//Encourage deceleration away from the current velocity
+		wishspeed *= pm_airDecelRate;
+	}
+
+	// not on ground, so little effect on velocity
+	float accelerate = pm_airaccelerate;
+ 	if ( pVeh && pVeh->m_pVehicleInfo->type == VH_SPEEDER )
+	{//speeders have more control in air
+		//in mid-air
+		accelerate = pVeh->m_pVehicleInfo->acceleration;
+		if ( pml.groundPlane )
+		{//on a slope of some kind, shouldn't have much control and should slide a lot
+			accelerate *= 0.5f;
+		}
+ 		if (pVeh->m_ulFlags & VEH_SLIDEBREAKING)
+		{
+			VectorScale(pm->ps->velocity, 0.80f, pm->ps->velocity);
+		}
+		if (pm->ps->velocity[2]>1000.0f)
+		{ 
+			pm->ps->velocity[2] = 1000.0f;
+		}
+	}
+	PM_Accelerate( wishdir, wishspeed, accelerate );
+
+
+	// we may have a ground plane that is very steep, even
+	// though we don't have a groundentity
+	// slide along the steep plane
+	if ( pml.groundPlane ) 
+	{
+		if ( PM_GroundSlideOkay( pml.groundTrace.plane.normal[2] ) )
+		{
+			PM_ClipVelocity( pm->ps->velocity, pml.groundTrace.plane.normal, 
+								pm->ps->velocity, OVERCLIP );
+		}
+	}
+
+	if ( (pm->ps->clientNum < MAX_CLIENTS||PM_ControlledByPlayer())
+		&& pm->ps->forcePowerLevel[FP_LEVITATION] > FORCE_LEVEL_0 
+		&& pm->ps->forceJumpZStart 
+		&& pm->ps->velocity[2] > 0 )
+	{//I am force jumping and I'm not holding the button anymore
+		float curHeight = pm->ps->origin[2] - pm->ps->forceJumpZStart + (pm->ps->velocity[2]*pml.frametime);
+		float maxJumpHeight = forceJumpHeight[pm->ps->forcePowerLevel[FP_LEVITATION]];
+		if ( curHeight >= maxJumpHeight )
+		{//reached top, cut velocity
+			pm->ps->velocity[2] = 0;
+		}
+	}
+	if ( (pm->ps->pm_flags&PMF_STUCK_TO_WALL) )
+	{
+		gravMod = 0.0f;
+	}
+	PM_StepSlideMove( gravMod );
+
+  	if (pVeh && pm->ps->pm_flags&PMF_BUMPED)
+	{
+
+/*
+		// Turn Vehicle In Direction Of Collision
+		//----------------------------------------
+		vec3_t	nAngles;
+ 		vectoangles(pm->ps->velocity, nAngles);
+		nAngles[0] = pVeh->m_pParentEntity->client->ps.viewangles[0];
+		nAngles[2] = pVeh->m_pParentEntity->client->ps.viewangles[2];
+
+		// toggle the teleport bit so the client knows to not lerp
+		player->client->ps.eFlags ^= EF_TELEPORT_BIT;
+
+		// set angles
+		SetClientViewAngle( pVeh->m_pParentEntity, nAngles );
+		if (pVeh->m_pPilot)
+		{
+			SetClientViewAngle( pVeh->m_pPilot, nAngles );
+	 	}
+
+		VectorCopy(nAngles, pVeh->m_vPrevOrientation);
+		VectorCopy(nAngles, pVeh->m_vOrientation);
+		pVeh->m_vAngularVelocity = 0.0f;
+*/
+
+		// Reduce "Bounce Up Wall" Velocity
+		//----------------------------------
+	 	if (pm->ps->velocity[2]>0)
+		{
+			pm->ps->velocity[2] *= 0.1f;
+		}
+	}
+}
+
+
+/*
+===================
+PM_WalkMove
+
+===================
+*/
+static void PM_WalkMove( void ) {
+	int			i;
+	vec3_t		wishvel;
+	float		fmove, smove;
+	vec3_t		wishdir;
+	float		wishspeed;
+	float		scale;
+	usercmd_t	cmd;
+	float		accelerate;
+	float		vel;
+
+	if ( pm->ps->gravity < 0 )
+	{//float away
+		pm->ps->velocity[2] -= pm->ps->gravity * pml.frametime;
+		pm->ps->groundEntityNum = ENTITYNUM_NONE;
+		pml.groundPlane = qfalse;
+		pml.walking = qfalse;
+		if ( pm->waterlevel > 1 ) {
+			PM_WaterMove();
+		} else {
+			PM_AirMove();
+		}
+		return;
+	}
+
+	if ( pm->waterlevel > 2 && DotProduct( pml.forward, pml.groundTrace.plane.normal ) > 0 ) {
+		// begin swimming
+		PM_WaterMove();
+		return;
+	}
+
+
+	if ( PM_CheckJump () ) {
+		// jumped away
+		if ( pm->waterlevel > 1 ) {
+			PM_WaterMove();
+		} else {
+			PM_AirMove();
+		}
+		return;
+	}
+
+	if ( pm->ps->groundEntityNum != ENTITYNUM_NONE &&//on ground
+		pm->ps->velocity[2] <= 0 &&//not going up
+		pm->ps->pm_flags&PMF_TIME_KNOCKBACK )//knockback fimter on (stops friction)
+	{
+		pm->ps->pm_flags &= ~PMF_TIME_KNOCKBACK;
+	}
+
+	qboolean slide = qfalse;
+	if ( pm->ps->pm_type == PM_DEAD )
+	{//corpse
+		if ( g_entities[pm->ps->groundEntityNum].client )
+		{//on a client
+			if ( g_entities[pm->ps->groundEntityNum].health > 0 )
+			{//a living client
+				//no friction
+				slide = qtrue;
+			}
+		}
+	}
+	if ( !slide )
+	{
+		PM_Friction ();
+	}
+
+	if ( g_debugMelee->integer )
+	{
+		if ( (pm->ps->clientNum < MAX_CLIENTS||PM_ControlledByPlayer())//player
+			&& cg.renderingThirdPerson//in third person
+			&& ((pm->cmd.buttons&BUTTON_USE)||pm->ps->leanStopDebounceTime)//holding use or leaning
+			//&& (pm->ps->forcePowersActive&(1<<FP_SPEED))
+			&& pm->ps->groundEntityNum != ENTITYNUM_NONE//on ground
+			&& !cg_usingInFrontOf )//nothing to use
+		{//holding use stops you from moving
+			return;
+		}
+	}
+	fmove = pm->cmd.forwardmove;
+	smove = pm->cmd.rightmove;
+
+	cmd = pm->cmd;
+	scale = PM_CmdScale( &cmd );
+
+	// set the movementDir so clients can rotate the legs for strafing
+	PM_SetMovementDir();
+
+	// project moves down to flat plane
+	pml.forward[2] = 0;
+	pml.right[2] = 0;
+
+	// project the forward and right directions onto the ground plane
+	PM_ClipVelocity (pml.forward, pml.groundTrace.plane.normal, pml.forward, OVERCLIP );
+	PM_ClipVelocity (pml.right, pml.groundTrace.plane.normal, pml.right, OVERCLIP );
+	//
+	VectorNormalize (pml.forward);
+	VectorNormalize (pml.right);
+
+/*	if ( ( pm->gent && pm->gent->client && pm->gent->client->NPC_class == CLASS_VEHICLE ) && pm->gent->NPC )
+	{//speeder control scheme
+		vec3_t	vfwd, vrt;
+		AngleVectors( ((CVehicleNPC *)pm->gent->NPC)->m_vOrientation, vfwd, vrt, NULL );
+
+		float speed = pm->ps->speed;
+		if ( fmove < 0 )
+		{//going backwards
+			if ( speed < 0 )
+			{//speed is negative, but since our command is reverse, make speed positive
+				speed = fabs( speed );
+			}
+			else if ( speed > 0 )
+			{//trying to move back but speed is still positive, so keep moving forward (we'll slow down eventually)
+				speed *= -1;
+			}
+		}
+		VectorScale( vfwd, speed*fmove/127.0f, wishvel );
+		//VectorMA( wishvel, pm->ps->speed*smove/127.0f, vrt, wishvel );
+		wishspeed = VectorNormalize2( wishvel, wishdir );
+	}
+	else*/
+
+	// Get The WishVel And WishSpeed
+	//-------------------------------  
+	if ( pm->ps->clientNum && (USENEWNAVSYSTEM || !VectorCompare( pm->ps->moveDir, vec3_origin )) )
+	{//NPC
+		
+		// If The UCmds Were Set, But Never Converted Into A MoveDir, Then Make The WishDir From UCmds
+		//--------------------------------------------------------------------------------------------
+		if ((fmove!=0.0f || smove!=0.0f) &&	VectorCompare(pm->ps->moveDir, vec3_origin))
+		{
+			//gi.Printf("Generating MoveDir\n");
+			for ( i = 0 ; i < 3 ; i++ ) 
+			{
+				wishvel[i] = pml.forward[i]*fmove + pml.right[i]*smove;
+			}
+
+			VectorCopy( wishvel, wishdir );
+			wishspeed = VectorNormalize(wishdir);
+			wishspeed *= scale;
+		}
+		// Otherwise, Use The Move Dir
+		//-----------------------------
+		else
+		{
+			wishspeed = pm->ps->speed;
+			VectorScale( pm->ps->moveDir, pm->ps->speed, wishvel );
+			VectorCopy( pm->ps->moveDir, wishdir );
+		}
+
+	}
+	else
+	{
+		for ( i = 0 ; i < 3 ; i++ ) {
+			wishvel[i] = pml.forward[i]*fmove + pml.right[i]*smove;
+		}
+		// when going up or down slopes the wish velocity should Not be zero
+	//	wishvel[2] = 0;
+
+		VectorCopy (wishvel, wishdir);
+		wishspeed = VectorNormalize(wishdir);
+		wishspeed *= scale;
+	}
+
+	// Handle negative speed.
+	if ( wishspeed < 0 )
+	{
+		wishspeed = wishspeed * -1.0f;
+		VectorScale( wishvel, -1.0f, wishvel );
+		VectorScale( wishdir, -1.0f, wishdir );
+	}
+
+	// clamp the speed lower if ducking
+	if ( pm->ps->pm_flags & PMF_DUCKED && !PM_InKnockDown( pm->ps ) ) 
+	{
+		if ( wishspeed > pm->ps->speed * pm_duckScale ) 
+		{
+			wishspeed = pm->ps->speed * pm_duckScale;
+		}
+	}
+
+	// clamp the speed lower if wading or walking on the bottom
+	if ( pm->waterlevel ) {
+		float	waterScale;
+
+		waterScale = pm->waterlevel / 3.0;
+		waterScale = 1.0 - ( 1.0 - pm_swimScale ) * waterScale;
+		if ( wishspeed > pm->ps->speed * waterScale ) {
+			wishspeed = pm->ps->speed * waterScale;
+		}
+	}
+
+	// when a player gets hit, they temporarily lose
+	// full control, which allows them to be moved a bit
+	if ( Flying == FLY_HOVER )
+	{
+		accelerate = pm_vehicleaccelerate;
+	}
+	else if ( ( pml.groundTrace.surfaceFlags & SURF_SLICK ) || (pm->ps->pm_flags&PMF_TIME_KNOCKBACK) || (pm->ps->pm_flags&PMF_TIME_NOFRICTION) ) 
+	{
+		accelerate = pm_airaccelerate;
+	} 
+	else 
+	{
+		accelerate = pm_accelerate;
+
+		// Wind Affects Acceleration
+		//===================================================
+		if (wishspeed>0.0f && pm->gent && !pml.walking)
+		{
+			if (gi.WE_GetWindGusting(pm->gent->currentOrigin))
+			{
+				vec3_t	windDir;
+				if (gi.WE_GetWindVector(windDir, pm->gent->currentOrigin))
+				{
+					if (gi.WE_IsOutside(pm->gent->currentOrigin))
+					{
+						VectorScale(windDir, -1.0f, windDir);
+						accelerate *=  (1.0f - (DotProduct(wishdir, windDir)*0.55f));
+					}
+				}
+			}
+		}
+		//===================================================
+	}
+
+	PM_Accelerate (wishdir, wishspeed, accelerate);
+
+	//Com_Printf("velocity = %1.1f %1.1f %1.1f\n", pm->ps->velocity[0], pm->ps->velocity[1], pm->ps->velocity[2]);
+	//Com_Printf("velocity1 = %1.1f\n", VectorLength(pm->ps->velocity));
+
+	if ( ( pml.groundTrace.surfaceFlags & SURF_SLICK ) || pm->ps->pm_flags & PMF_TIME_KNOCKBACK || (pm->ps->pm_flags&PMF_TIME_NOFRICTION) ) {
+		if ( pm->ps->gravity >= 0 && pm->ps->groundEntityNum != ENTITYNUM_NONE && !VectorLengthSquared( pm->ps->velocity ) && pml.groundTrace.plane.normal[2] == 1.0 )
+		{//on ground and not moving and on level ground, no reason to do stupid fucking gravity with the clipvelocity!!!!
+		}
+		else
+		{
+			if ( !(pm->ps->eFlags&EF_FORCE_GRIPPED) && !(pm->ps->eFlags&EF_FORCE_DRAINED) )
+			{
+				pm->ps->velocity[2] -= pm->ps->gravity * pml.frametime;
+			}
+		}
+	} else {
+		// don't reset the z velocity for slopes
+//		pm->ps->velocity[2] = 0;
+	}
+
+	vel = VectorLength(pm->ps->velocity);
+
+	// slide along the ground plane
+	PM_ClipVelocity (pm->ps->velocity, pml.groundTrace.plane.normal, 
+		pm->ps->velocity, OVERCLIP );
+
+	// don't decrease velocity when going up or down a slope
+	VectorNormalize(pm->ps->velocity);
+	VectorScale(pm->ps->velocity, vel, pm->ps->velocity);
+
+	// don't do anything if standing still
+	if ( !pm->ps->velocity[0] && !pm->ps->velocity[1] ) {
+		return;
+	}
+
+	if ( pm->ps->gravity <= 0 )
+	{//need to apply gravity since we're going to float up from ground
+		PM_StepSlideMove( 1 );
+	}
+	else
+	{
+		PM_StepSlideMove( 0 );
+	}
+
+	//Com_Printf("velocity2 = %1.1f\n", VectorLength(pm->ps->velocity));
+
+}
+
+
+/*
+==============
+PM_DeadMove
+==============
+*/
+static void PM_DeadMove( void ) {
+	float	forward;
+
+	// If this is a vehicle, tell him he's dead, but give him a little while to do his things.
+/*	if ( pm->gent && pm->gent->client && pm->gent->client->NPC_class == CLASS_VEHICLE && pm->gent->NPC && pm->gent->health != -99999 )
+	{
+		pm->gent->health = 1;
+		((CVehicleNPC *)pm->gent->NPC)->StartDeathDelay( 0 );
+	}
+	else
+	{
+		pm->gent->health = 0;
+	}*/
+	
+	if ( !pml.walking ) {
+		return;
+	}
+
+	// extra friction
+
+	forward = VectorLength (pm->ps->velocity);
+	forward -= 20;
+	if ( forward <= 0 ) {
+		VectorClear (pm->ps->velocity);
+	} else {
+		VectorNormalize (pm->ps->velocity);
+		VectorScale (pm->ps->velocity, forward, pm->ps->velocity);
+	}
+}
+
+
+/*
+===============
+PM_NoclipMove
+===============
+*/
+static void PM_NoclipMove( void ) {
+	float	speed, drop, friction, control, newspeed;
+	int			i;
+	vec3_t		wishvel;
+	float		fmove, smove;
+	vec3_t		wishdir;
+	float		wishspeed;
+	float		scale;
+
+	if(pm->gent && pm->gent->client)
+	{
+		pm->ps->viewheight = pm->gent->client->standheight + STANDARD_VIEWHEIGHT_OFFSET;
+//		if ( !pm->gent->mins[0] || !pm->gent->mins[1] || !pm->gent->mins[2] || !pm->gent->maxs[0] || !pm->gent->maxs[1] || !pm->gent->maxs[2] )
+//		{
+//			assert(0);
+//		}
+
+		VectorCopy( pm->gent->mins, pm->mins );
+		VectorCopy( pm->gent->maxs, pm->maxs );
+	}
+	else
+	{
+		pm->ps->viewheight = DEFAULT_MAXS_2 + STANDARD_VIEWHEIGHT_OFFSET;//DEFAULT_VIEWHEIGHT;
+
+		if ( !DEFAULT_MINS_0 || !DEFAULT_MINS_1 || !DEFAULT_MAXS_0 || !DEFAULT_MAXS_1 || !DEFAULT_MINS_2 || !DEFAULT_MAXS_2 )
+		{
+			assert(0);
+		}
+
+		pm->mins[0] = DEFAULT_MINS_0;
+		pm->mins[1] = DEFAULT_MINS_1;
+		pm->mins[2] = DEFAULT_MINS_2;
+
+		pm->maxs[0] = DEFAULT_MAXS_0;
+		pm->maxs[1] = DEFAULT_MAXS_1;
+		pm->maxs[2] = DEFAULT_MAXS_2;
+	}
+
+	// friction
+
+	speed = VectorLength (pm->ps->velocity);
+	if (speed < 1)
+	{
+		VectorCopy (vec3_origin, pm->ps->velocity);
+	}
+	else
+	{
+		drop = 0;
+
+		friction = pm_friction*1.5;	// extra friction
+		control = speed < pm_stopspeed ? pm_stopspeed : speed;
+		drop += control*friction*pml.frametime;
+
+		// scale the velocity
+		newspeed = speed - drop;
+		if (newspeed < 0)
+			newspeed = 0;
+		newspeed /= speed;
+
+		VectorScale (pm->ps->velocity, newspeed, pm->ps->velocity);
+	}
+
+	// accelerate
+	scale = PM_CmdScale( &pm->cmd );
+	if (pm->cmd.buttons & BUTTON_ATTACK) {	//turbo boost
+		scale *= 10;
+	}
+	if (pm->cmd.buttons & BUTTON_ALT_ATTACK) {	//turbo boost
+		scale *= 10;
+	}
+
+	fmove = pm->cmd.forwardmove;
+	smove = pm->cmd.rightmove;
+	
+	for (i=0 ; i<3 ; i++)
+		wishvel[i] = pml.forward[i]*fmove + pml.right[i]*smove;
+	wishvel[2] += pm->cmd.upmove;
+
+	VectorCopy (wishvel, wishdir);
+	wishspeed = VectorNormalize(wishdir);
+	wishspeed *= scale;
+
+	PM_Accelerate( wishdir, wishspeed, pm_accelerate );
+
+	// move
+	VectorMA (pm->ps->origin, pml.frametime, pm->ps->velocity, pm->ps->origin);
+}
+
+//============================================================================
+
+static float PM_DamageForDelta( int delta )
+{
+	float damage = delta;
+	if ( pm->gent->NPC )
+	{
+		if ( pm->ps->weapon == WP_SABER 
+			|| (pm->gent->client && pm->gent->client->NPC_class == CLASS_REBORN) )
+		{//FIXME: for now Jedi take no falling damage, but really they should if pushed off?
+			damage = 0;
+		}
+	}
+	else if ( pm->ps->clientNum < MAX_CLIENTS )
+	{
+		if ( damage < 50 )
+		{
+			if ( damage > 24 )
+			{
+				damage = damage - 25;
+			}
+		}
+		else
+		{
+			damage *= 0.5f;
+		}
+	}
+	return damage * 0.5f;
+}
+
+static void PM_CrashLandDamage( int damage ) 
+{
+	if ( pm->gent )
+	{
+		int dflags = DAMAGE_NO_ARMOR;
+		if ( pm->gent->NPC && (pm->gent->NPC->aiFlags&NPCAI_DIE_ON_IMPACT) )
+		{
+			damage = 1000;
+			dflags |= DAMAGE_DIE_ON_IMPACT;
+		}
+		else if ( !(pm->gent->flags&FL_NO_IMPACT_DMG) )
+		{
+			damage = PM_DamageForDelta( damage );
+		}
+
+		if ( damage )
+		{
+			pm->gent->painDebounceTime = level.time + 200;	// no normal pain sound
+			G_Damage( pm->gent, NULL, player, NULL, NULL, damage, dflags, MOD_FALLING );
+		}
+	}
+}
+
+/*
+static float PM_CrashLandDelta( vec3_t org, vec3_t prevOrg, vec3_t prev_vel, float grav, int waterlevel )
+{
+	float		delta;
+	float		dist;
+	float		vel, acc;
+	float		t;
+	float		a, b, c, den;
+
+	// calculate the exact velocity on landing
+	dist = org[2] - prevOrg[2];
+	vel = prev_vel[2];
+	acc = -grav;
+
+	a = acc / 2;
+	b = vel;
+	c = -dist;
+
+	den =  b * b - 4 * a * c;
+	if ( den < 0 ) 
+	{
+		return 0;
+	}
+	t = (-b - sqrt( den ) ) / ( 2 * a );
+
+	delta = vel + t * acc;
+	delta = delta*delta * 0.0001;
+
+	// never take falling damage if completely underwater
+	if ( waterlevel == 3 ) 
+	{
+		return 0;
+	}
+	// reduce falling damage if there is standing water
+	if ( waterlevel == 2 ) 
+	{
+		delta *= 0.25;
+	}
+	if ( waterlevel == 1 ) 
+	{
+		delta *= 0.5;
+	}
+
+	return delta;
+}
+*/
+
+static float PM_CrashLandDelta( vec3_t prev_vel, int waterlevel )
+{
+	float delta;
+
+	if ( pm->waterlevel == 3 ) 
+	{
+		return 0;
+	}
+	delta = fabs(prev_vel[2])/10;//VectorLength( prev_vel )
+
+	// reduce falling damage if there is standing water
+	if ( pm->waterlevel == 2 ) 
+	{
+		delta *= 0.25;
+	}
+	if ( pm->waterlevel == 1 ) 
+	{
+		delta *= 0.5;
+	}
+
+	return delta;
+}
+
+int PM_GetLandingAnim( void )
+{
+	int anim = pm->ps->legsAnim;
+	
+	//special cases:
+	if ( anim == BOTH_FLIP_ATTACK7
+		|| anim == BOTH_FLIP_HOLD7 )
+	{
+        return BOTH_FLIP_LAND;
+	}
+	else if ( anim == BOTH_FLIP_LAND )
+	{
+		//stick landings some
+		pm->ps->velocity[0] *= 0.5f;
+		pm->ps->velocity[1] *= 0.5f;
+		return BOTH_LAND1;
+	}
+	else if ( PM_InAirKickingAnim( anim ) )
+	{
+		switch ( anim )
+		{
+		case BOTH_A7_KICK_F_AIR:
+			return BOTH_FORCELAND1;
+			break;
+		case BOTH_A7_KICK_B_AIR:
+			return BOTH_FORCELANDBACK1;
+			break;
+		case BOTH_A7_KICK_R_AIR:
+			return BOTH_FORCELANDRIGHT1;
+			break;
+		case BOTH_A7_KICK_L_AIR:
+			return BOTH_FORCELANDLEFT1;
+			break;
+		}
+	}
+
+	if ( PM_SpinningAnim( anim ) || PM_SaberInSpecialAttack( anim ) )
+	{
+		return -1;
+	}
+	switch ( anim )
+	{
+	case BOTH_FORCEJUMPLEFT1:
+	case BOTH_FORCEINAIRLEFT1:
+		anim = BOTH_FORCELANDLEFT1;
+		//stick landings some
+		pm->ps->velocity[0] *= 0.5f;
+		pm->ps->velocity[1] *= 0.5f;
+		break;
+	case BOTH_FORCEJUMPRIGHT1:
+	case BOTH_FORCEINAIRRIGHT1:
+		anim = BOTH_FORCELANDRIGHT1;
+		//stick landings some
+		pm->ps->velocity[0] *= 0.5f;
+		pm->ps->velocity[1] *= 0.5f;
+		break;
+	case BOTH_FORCEJUMP1:
+	case BOTH_FORCEINAIR1:
+		//stick landings some
+		pm->ps->velocity[0] *= 0.5f;
+		pm->ps->velocity[1] *= 0.5f;
+		anim = BOTH_FORCELAND1;
+		break;
+	case BOTH_FORCEJUMPBACK1:
+	case BOTH_FORCEINAIRBACK1:
+		//stick landings some
+		pm->ps->velocity[0] *= 0.5f;
+		pm->ps->velocity[1] *= 0.5f;
+		anim = BOTH_FORCELANDBACK1;
+		break;
+	case BOTH_JUMPLEFT1:
+	case BOTH_INAIRLEFT1:
+		anim = BOTH_LANDLEFT1;
+		//stick landings some
+		pm->ps->velocity[0] *= 0.5f;
+		pm->ps->velocity[1] *= 0.5f;
+		break;
+	case BOTH_JUMPRIGHT1:
+	case BOTH_INAIRRIGHT1:
+		anim = BOTH_LANDRIGHT1;
+		//stick landings some
+		pm->ps->velocity[0] *= 0.5f;
+		pm->ps->velocity[1] *= 0.5f;
+		break;
+	case BOTH_JUMP1:
+	case BOTH_INAIR1:
+		anim = BOTH_LAND1;
+		//stick landings some
+		pm->ps->velocity[0] *= 0.5f;
+		pm->ps->velocity[1] *= 0.5f;
+		break;
+	case BOTH_JUMPBACK1:
+	case BOTH_INAIRBACK1:
+		anim = BOTH_LANDBACK1;
+		//stick landings some
+		pm->ps->velocity[0] *= 0.5f;
+		pm->ps->velocity[1] *= 0.5f;
+		break;
+	case BOTH_BUTTERFLY_LEFT:
+	case BOTH_BUTTERFLY_RIGHT:
+	case BOTH_BUTTERFLY_FL1:
+	case BOTH_BUTTERFLY_FR1:
+	case BOTH_FJSS_TR_BL:
+	case BOTH_FJSS_TL_BR:
+	case BOTH_LUNGE2_B__T_:
+	case BOTH_FORCELEAP2_T__B_:
+	case BOTH_ARIAL_LEFT:
+	case BOTH_ARIAL_RIGHT:
+	case BOTH_ARIAL_F1:
+	case BOTH_CARTWHEEL_LEFT:
+	case BOTH_CARTWHEEL_RIGHT:
+	case BOTH_JUMPFLIPSLASHDOWN1://#
+	case BOTH_JUMPFLIPSTABDOWN://#
+	case BOTH_JUMPATTACK6:
+	case BOTH_JUMPATTACK7:
+	case BOTH_A7_KICK_F:
+	case BOTH_A7_KICK_B:
+	case BOTH_A7_KICK_R:
+	case BOTH_A7_KICK_L:
+	case BOTH_A7_KICK_S:
+	case BOTH_A7_KICK_BF:
+	case BOTH_A7_KICK_RL:
+	case BOTH_A7_KICK_F_AIR:
+	case BOTH_A7_KICK_B_AIR:
+	case BOTH_A7_KICK_R_AIR:
+	case BOTH_A7_KICK_L_AIR:
+	case BOTH_STABDOWN:
+	case BOTH_STABDOWN_STAFF:
+	case BOTH_STABDOWN_DUAL:
+	case BOTH_A6_SABERPROTECT:
+	case BOTH_A7_SOULCAL:
+	case BOTH_A1_SPECIAL:
+	case BOTH_A2_SPECIAL:
+	case BOTH_A3_SPECIAL:
+	case BOTH_PULL_IMPALE_STAB:
+	case BOTH_PULL_IMPALE_SWING:
+		anim = -1;
+		break;
+	case BOTH_FORCELONGLEAP_START:
+	case BOTH_FORCELONGLEAP_ATTACK:
+		return BOTH_FORCELONGLEAP_LAND;
+		break;
+	case BOTH_WALL_RUN_LEFT://#
+	case BOTH_WALL_RUN_RIGHT://#
+		if ( pm->ps->legsAnimTimer > 500 )
+		{//only land at end of anim
+			return -1;
+		}
+		//NOTE: falls through on purpose!
+	default:
+		if ( pm->ps->pm_flags & PMF_BACKWARDS_JUMP ) 
+		{
+			anim = BOTH_LANDBACK1;
+		}
+		else
+		{
+			anim = BOTH_LAND1;
+		}
+		//stick landings some
+		pm->ps->velocity[0] *= 0.5f;
+		pm->ps->velocity[1] *= 0.5f;
+		break;
+	}
+	return anim;
+}
+
+void G_StartRoll( gentity_t *ent, int anim )
+{
+	NPC_SetAnim(ent,SETANIM_BOTH,anim,SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD|SETANIM_FLAG_HOLDLESS);
+	ent->client->ps.weaponTime = ent->client->ps.torsoAnimTimer - 200;//just to make sure it's cleared when roll is done
+	G_AddEvent( ent, EV_ROLL, 0 );
+	ent->client->ps.saberMove = LS_NONE;
+}
+
+static qboolean PM_TryRoll( void )
+{
+	float rollDist = 192;//was 64;
+	if ( PM_SaberInAttack( pm->ps->saberMove ) || PM_SaberInSpecialAttack( pm->ps->torsoAnim ) 
+		|| PM_SpinningSaberAnim( pm->ps->legsAnim ) 
+		|| ((pm->ps->clientNum < MAX_CLIENTS||PM_ControlledByPlayer())&&PM_SaberInStart( pm->ps->saberMove )) )
+	{//attacking or spinning (or, if player, starting an attack)
+		if ( PM_CanRollFromSoulCal( pm->ps ) )
+		{//hehe
+		}
+		else
+		{
+			return qfalse;
+		}
+	}
+	if ( (pm->ps->clientNum < MAX_CLIENTS||PM_ControlledByPlayer()) && (!cg.renderingThirdPerson || cg.zoomMode) )
+	{//player can't do this in 1st person
+		return qfalse;
+	}
+	if ( !pm->gent )
+	{
+		return qfalse;
+	}
+	if ( pm->ps->clientNum && pm->gent->NPC )
+	{//NPC
+		if ( pm->gent->NPC->scriptFlags&SCF_NO_ACROBATICS )
+		{//scripted to never do acrobatics
+			return qfalse;
+		}
+
+		if ( pm->ps->weapon == WP_SABER )
+		{//jedi/reborn
+			if ( pm->gent->NPC->rank != RANK_CREWMAN && pm->gent->NPC->rank < RANK_LT_JG )
+			{//reborn/jedi who are not acrobats or fencers can't do any of these acrobatics
+				return qfalse;
+			}
+		}
+		else
+		{//non-jedi/reborn
+			if ( pm->ps->weapon != WP_NONE )//not empty-handed...who would that be???
+			{//only jedi/reborn NPCs should be able to do rolls (with a few exceptions)
+				if ( !pm->gent 
+					|| !pm->gent->client 
+					|| (pm->gent->client->NPC_class != CLASS_BOBAFETT //boba can roll with it, baby
+						&& pm->gent->client->NPC_class != CLASS_REBORN //reborn using weapons other than saber can still roll
+					))
+				{//can't roll
+					return qfalse;
+				}
+			}
+		}
+	}
+
+	vec3_t fwd, right, traceto, mins = {pm->mins[0],pm->mins[1],pm->mins[2]+STEPSIZE}, maxs = {pm->maxs[0],pm->maxs[1],pm->gent->client->crouchheight}, fwdAngles = {0, pm->ps->viewangles[YAW], 0};
+	trace_t	trace;
+	int		anim = -1;
+	AngleVectors( fwdAngles, fwd, right, NULL );
+	//FIXME: trace ahead for clearance to roll
+	if ( pm->cmd.forwardmove )
+	{
+		if ( pm->ps->pm_flags & PMF_BACKWARDS_RUN ) 
+		{
+			anim = BOTH_ROLL_B;
+			VectorMA( pm->ps->origin, -rollDist, fwd, traceto );
+		}
+		else
+		{
+			anim = BOTH_ROLL_F;
+			VectorMA( pm->ps->origin, rollDist, fwd, traceto );
+		}
+	}
+	else if ( pm->cmd.rightmove > 0 )
+	{
+		anim = BOTH_ROLL_R;
+		VectorMA( pm->ps->origin, rollDist, right, traceto );
+	}
+	else if ( pm->cmd.rightmove < 0 )
+	{
+		anim = BOTH_ROLL_L;
+		VectorMA( pm->ps->origin, -rollDist, right, traceto );
+	}
+	else
+	{//???
+	}
+	if ( anim != -1 )
+	{
+		qboolean roll = qfalse;
+		int		clipmask = CONTENTS_SOLID;
+		if ( pm->ps->clientNum )
+		{
+			clipmask |= (CONTENTS_MONSTERCLIP|CONTENTS_BOTCLIP);
+		}
+		else
+		{
+			if ( pm->gent && pm->gent->enemy && pm->gent->enemy->health > 0 )
+			{//player can always roll in combat
+				roll = qtrue;
+			}
+			else
+			{
+				clipmask |= CONTENTS_PLAYERCLIP;
+			}
+		}
+		if ( !roll )
+		{
+			pm->trace( &trace, pm->ps->origin, mins, maxs, traceto, pm->ps->clientNum, clipmask );
+			if ( trace.fraction >= 1.0f )
+			{//okay, clear, check for a bottomless drop
+				vec3_t	top;
+				VectorCopy( traceto, top );
+				traceto[2] -= 256;
+				pm->trace( &trace, top, mins, maxs, traceto, pm->ps->clientNum, CONTENTS_SOLID );
+				if ( trace.fraction < 1.0f )
+				{//not a bottomless drop
+					roll = qtrue;
+				}
+			}
+			else
+			{//hit an architectural obstruction
+				if ( pm->ps->clientNum )
+				{//NPCs don't care about rolling into walls, just off ledges
+					if ( !(trace.contents&CONTENTS_BOTCLIP) )
+					{
+						roll = qtrue;
+					}
+				}
+				else if ( G_EntIsDoor( trace.entityNum ) )
+				{//okay to roll into a door
+					if ( G_EntIsUnlockedDoor( trace.entityNum ) )
+					{//if it's an auto-door
+						roll = qtrue;
+					}
+				}
+				else 
+				{//check other conditions
+					gentity_t *traceEnt = &g_entities[trace.entityNum];
+					if ( traceEnt && (traceEnt->svFlags&SVF_GLASS_BRUSH) )
+					{//okay to roll through glass
+						roll = qtrue;
+					}
+				}
+			}
+		}
+		if ( roll )
+		{
+			G_StartRoll( pm->gent, anim );
+			return qtrue;
+		}
+	}
+	return qfalse;
+}
+
+extern void CG_LandingEffect( vec3_t origin, vec3_t normal, int material );
+static void PM_CrashLandEffect( void )
+{
+	if ( pm->waterlevel )
+	{
+		return;
+	}
+	float delta = fabs(pml.previous_velocity[2])/10;//VectorLength( pml.previous_velocity );?
+	if ( delta >= 30 ) 
+	{
+		vec3_t bottom = {pm->ps->origin[0],pm->ps->origin[1],pm->ps->origin[2]+pm->mins[2]+1};
+		CG_LandingEffect( bottom, pml.groundTrace.plane.normal, (pml.groundTrace.surfaceFlags&MATERIAL_MASK) );
+	}
+}
+/*
+=================
+PM_CrashLand
+
+Check for hard landings that generate sound events
+=================
+*/
+static void PM_CrashLand( void ) 
+{
+	float		delta = 0;
+	qboolean	forceLanding = qfalse;
+
+	if ( pm->gent && pm->gent->client && pm->gent->client->NPC_class == CLASS_VEHICLE )
+	{
+		if ( pm->gent->m_pVehicle->m_pVehicleInfo->type != VH_ANIMAL )
+		{
+			float dot = DotProduct( pm->ps->velocity, pml.groundTrace.plane.normal );
+			//Com_Printf("%i:crashland %4.2f\n", c_pmove, pm->ps->velocity[2]);
+			if ( dot < -100.0f )
+			{
+				//NOTE: never hits this anyway
+				if ( pm->gent->m_pVehicle->m_pVehicleInfo->iImpactFX )
+				{//make sparks
+					if ( !Q_irand( 0, 3 ) )
+					{//FIXME: debounce
+						G_PlayEffect( pm->gent->m_pVehicle->m_pVehicleInfo->iImpactFX, pm->ps->origin, pml.groundTrace.plane.normal );
+					}
+				}
+				int damage = floor(fabs(dot+100)/10.0f);
+				if ( damage >= 0 )
+				{
+					G_Damage( pm->gent, NULL, NULL, NULL, NULL, damage, 0, MOD_FALLING );
+				}
+			}
+		}
+		return;
+	}
+
+	if ( (pm->ps->pm_flags&PMF_TRIGGER_PUSHED) )
+	{
+		delta = 21;//?
+		forceLanding = qtrue;
+	}
+	else
+	{
+		if ( pm->gent && pm->gent->NPC && pm->gent->NPC->aiFlags & NPCAI_DIE_ON_IMPACT )
+		{//have to do death on impact if we are falling to our death, FIXME: should we avoid any additional damage this func?
+			PM_CrashLandDamage( 1000 );
+		}
+		else if ( pm->gent 
+			&& pm->gent->client 
+			&& (pm->gent->client->NPC_class == CLASS_BOBAFETT||pm->gent->client->NPC_class == CLASS_ROCKETTROOPER) )
+		{
+			if ( JET_Flying( pm->gent ) )
+			{
+				if ( pm->gent->client->NPC_class == CLASS_BOBAFETT
+					|| (pm->gent->client->NPC_class == CLASS_ROCKETTROOPER&&pm->gent->NPC&&pm->gent->NPC->rank<RANK_LT) )
+				{
+					JET_FlyStop( pm->gent );
+				}
+				else
+				{
+					pm->ps->velocity[2] += Q_flrand( 100, 200 );
+				}
+				PM_AddEvent( EV_FALL_SHORT );
+			}
+			if ( pm->ps->forceJumpZStart )
+			{//we were force-jumping
+				forceLanding = qtrue;
+			}
+			delta = 1;
+		}
+		else if ( pm->ps->jumpZStart && (pm->ps->forcePowerLevel[FP_LEVITATION] >= FORCE_LEVEL_1||(pm->ps->clientNum < MAX_CLIENTS||PM_ControlledByPlayer())) )
+		{//we were force-jumping
+			if ( pm->ps->origin[2] >= pm->ps->jumpZStart )
+			{//we landed at same height or higher than we landed
+				if ( pm->ps->forceJumpZStart )
+				{//we were force-jumping
+					forceLanding = qtrue;
+				}
+				delta = 0;
+			}
+			else
+			{//take off some of it, at least
+				delta = (pm->ps->jumpZStart-pm->ps->origin[2]);
+				float dropAllow = forceJumpHeight[pm->ps->forcePowerLevel[FP_LEVITATION]];
+				if ( dropAllow < 128 )
+				{//always allow a drop from 128, at least
+					dropAllow = 128;
+				}
+				if ( delta > forceJumpHeight[FORCE_LEVEL_1] )
+				{//will have to use force jump ability to absorb some of it
+					forceLanding = qtrue;//absorbed some - just to force the correct animation to play below
+				}
+				delta = (delta - dropAllow)/2;
+			}
+			if ( delta < 1 )
+			{
+				delta = 1;
+			}
+		}
+
+		if ( !delta )
+		{
+			delta = PM_CrashLandDelta( pml.previous_velocity, pm->waterlevel );
+		}
+	}
+
+	PM_CrashLandEffect();
+
+	if ( (pm->ps->pm_flags&PMF_DUCKED) && (level.time-pm->ps->lastOnGround)>500 ) 
+	{//must be crouched and have been inthe air for half a second minimum
+		if( !PM_InOnGroundAnim( pm->ps ) && !PM_InKnockDown( pm->ps ) )
+		{//roll!
+			if ( PM_TryRoll() )
+			{//absorb some impact
+				delta *= 0.5f;
+			}
+		}
+	}
+
+	// If he just entered the water (from a fall presumably), absorb some of the impact.
+	if ( pm->waterlevel >= 2 )
+	{
+		delta *= 0.4f;
+	}
+	
+	if ( delta < 1 ) 
+	{
+		AddSoundEvent( pm->gent, pm->ps->origin, 32, AEL_MINOR, qfalse, qtrue );
+		return;
+	}
+
+	qboolean deadFallSound = qfalse;
+	if( !PM_InDeathAnim() )
+	{
+		if ( PM_InAirKickingAnim( pm->ps->legsAnim )
+			&& pm->ps->torsoAnim == pm->ps->legsAnim )
+		{
+			int anim = PM_GetLandingAnim();
+			if ( anim != -1 )
+			{//interrupting a kick clears everything
+				PM_SetAnim( pm, SETANIM_BOTH, anim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD, 100 );	// Only blend over 100ms
+				pm->ps->saberMove = LS_READY;
+				pm->ps->weaponTime = 0;
+				//stick landings some
+				pm->ps->velocity[0] *= 0.5f;
+				pm->ps->velocity[1] *= 0.5f;
+			}
+		}
+		else if ( pm->gent 
+			&& pm->gent->client 
+			&& pm->gent->client->NPC_class == CLASS_ROCKETTROOPER )
+		{//rockettroopers are simpler
+			int anim = PM_GetLandingAnim();
+			if ( anim != -1 )
+			{
+				if ( pm->gent->NPC
+					&& pm->gent->NPC->rank < RANK_LT )
+				{//special case: ground-based rocket troopers *always* play land anim on whole body
+					PM_SetAnim( pm, SETANIM_BOTH, anim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD, 100 );	// Only blend over 100ms
+				}
+				else
+				{
+					PM_SetAnim( pm, SETANIM_LEGS, anim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD, 100 );	// Only blend over 100ms
+				}
+			}
+		}
+		else if ( pm->cmd.upmove >= 0 && !PM_InKnockDown( pm->ps ) && !PM_InRoll( pm->ps ))
+		{//not crouching
+			if ( delta > 10 
+				|| pm->ps->pm_flags & PMF_BACKWARDS_JUMP 
+				|| (pm->ps->forcePowersActive&(1<<FP_LEVITATION))
+				|| forceLanding ) //EV_FALL_SHORT or jumping back or force-land
+			{// decide which landing animation to use
+				if ( pm->gent 
+					&& pm->gent->client 
+					&& (pm->gent->client->NPC_class == CLASS_RANCOR || pm->gent->client->NPC_class == CLASS_WAMPA ) )
+				{
+				}
+				else
+				{
+					int anim = PM_GetLandingAnim();
+					if ( anim != -1 )
+					{
+						if ( PM_FlippingAnim( pm->ps->torsoAnim )
+							|| PM_SpinningAnim( pm->ps->torsoAnim ) 
+							|| pm->ps->torsoAnim == BOTH_FLIP_LAND )
+						{//interrupt these if we're going to play a land
+							pm->ps->torsoAnimTimer = 0;
+						}
+						if ( anim == BOTH_FORCELONGLEAP_LAND )
+						{
+							if ( pm->gent )
+							{
+								G_SoundOnEnt( pm->gent, CHAN_AUTO, "sound/player/slide.wav" );
+							}
+							PM_SetAnim( pm, SETANIM_BOTH, anim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD, 100 );	// Only blend over 100ms
+						}
+						else if ( anim == BOTH_FLIP_LAND 
+							|| (pm->ps->torsoAnim == BOTH_FLIP_LAND) )
+						{
+							PM_SetAnim( pm, SETANIM_BOTH, anim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD, 100 );	// Only blend over 100ms
+						}
+						else if ( PM_InAirKickingAnim( pm->ps->legsAnim )
+							&& pm->ps->torsoAnim == pm->ps->legsAnim )
+						{//interrupting a kick clears everything
+							PM_SetAnim( pm, SETANIM_BOTH, anim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD, 100 );	// Only blend over 100ms
+							pm->ps->saberMove = LS_READY;
+							pm->ps->weaponTime = 0;
+						}
+						else if ( PM_ForceJumpingAnim( pm->ps->legsAnim )
+							&& pm->ps->torsoAnim == pm->ps->legsAnim )
+						{//special case: if land during one of these, set the torso, too, if it's not doing something else
+							PM_SetAnim( pm, SETANIM_BOTH, anim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD, 100 );	// Only blend over 100ms
+						}
+						else
+						{
+							PM_SetAnim( pm, SETANIM_LEGS, anim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD, 100 );	// Only blend over 100ms
+						}
+					}
+				}
+			}
+		}
+	}
+	else
+	{
+		pm->ps->gravity = 1.0;
+		//PM_CrashLandDamage( delta );
+		if ( pm->gent )
+		{	
+			if ((!(pml.groundTrace.surfaceFlags & SURF_NODAMAGE)) &&
+//				(!(pml.groundTrace.contents & CONTENTS_NODROP)) && 
+				(!(pm->pointcontents(pm->ps->origin,pm->ps->clientNum) & CONTENTS_NODROP)))
+			{
+				if ( pm->waterlevel < 2 )
+				{//don't play fallsplat when impact in the water
+					deadFallSound = qtrue;
+					if ( !(pm->ps->eFlags&EF_NODRAW) )
+					{//no sound if no draw
+						if ( delta >= 75 )
+						{
+							G_SoundOnEnt( pm->gent, CHAN_BODY, "sound/player/fallsplat.wav" );
+						}
+						else
+						{
+							G_SoundOnEnt( pm->gent, CHAN_BODY, va("sound/player/bodyfall_human%d.wav",Q_irand(1,3)) );
+						}
+					}
+				}
+				else
+				{
+					G_SoundOnEnt( pm->gent, CHAN_BODY, va("sound/player/bodyfall_water%d.wav",Q_irand(1,3)) );
+				}
+				if ( gi.VoiceVolume[pm->ps->clientNum]
+					&& pm->gent->NPC && (pm->gent->NPC->aiFlags&NPCAI_DIE_ON_IMPACT) )
+				{//I was talking, so cut it off... with a jump sound?
+					if ( !(pm->ps->eFlags&EF_NODRAW) )
+					{//no sound if no draw
+						G_SoundOnEnt( pm->gent, CHAN_VOICE_ATTEN, "*pain100.wav" );
+					}
+				}
+			}
+		}
+		if( pm->ps->legsAnim == BOTH_FALLDEATH1 || pm->ps->legsAnim == BOTH_FALLDEATH1INAIR)
+		{//FIXME: add a little bounce?
+			//FIXME: cut voice channel?
+			int old_pm_type = pm->ps->pm_type;
+			pm->ps->pm_type = PM_NORMAL;
+			//Hack because for some reason PM_SetAnim just returns if you're dead...???
+			PM_SetAnim(pm, SETANIM_BOTH, BOTH_FALLDEATH1LAND, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD);
+			pm->ps->pm_type = old_pm_type;
+			AddSoundEvent( pm->gent, pm->ps->origin, 256, AEL_SUSPICIOUS, qfalse, qtrue );
+			return;
+		}
+	} 
+
+	// create a local entity event to play the sound
+
+	if ( pm->gent && pm->gent->client && pm->gent->client->respawnTime >= level.time - 500 )
+	{//just spawned in, don't make a noise
+		return;
+	}
+
+	if ( delta >= 75 ) 
+	{
+		if ( !deadFallSound )
+		{
+			if ( !(pm->ps->eFlags&EF_NODRAW) )
+			{//no sound if no draw
+				PM_AddEvent( EV_FALL_FAR );
+			}
+		}
+		if ( !(pml.groundTrace.surfaceFlags & SURF_NODAMAGE) )  
+		{
+			PM_CrashLandDamage( delta );
+		}
+		if ( pm->gent )
+		{
+			if ( pm->gent->s.number == 0 ) 
+			{
+				vec3_t	bottom;
+
+				VectorCopy( pm->ps->origin, bottom );
+				bottom[2] += pm->mins[2];
+			//	if ( pm->gent->client && pm->gent->client->playerTeam != TEAM_DISGUISE )
+				{
+					AddSoundEvent( pm->gent, bottom, 256, AEL_SUSPICIOUS, qfalse, qtrue );
+				}
+			}
+			else if ( pm->ps->stats[STAT_HEALTH] <= 0 && pm->gent && pm->gent->enemy )
+			{
+				AddSoundEvent( pm->gent->enemy, pm->ps->origin, 256, AEL_DISCOVERED, qfalse, qtrue );
+			}
+		}
+	} 
+	else if ( delta >= 50 ) 
+	{
+		// this is a pain grunt, so don't play it if dead
+		if ( pm->ps->stats[STAT_HEALTH] > 0 ) 
+		{
+			if ( !deadFallSound )
+			{
+				if ( !(pm->ps->eFlags&EF_NODRAW) )
+				{//no sound if no draw
+					PM_AddEvent( EV_FALL_MEDIUM );//damage is dealt in g_active, ClientEvents
+				}
+			}
+			if ( pm->gent )
+			{
+				if ( !(pml.groundTrace.surfaceFlags & SURF_NODAMAGE) )  
+				{
+					PM_CrashLandDamage( delta );
+				}
+				if ( pm->gent->s.number == 0 ) 
+				{
+					vec3_t	bottom;
+
+					VectorCopy( pm->ps->origin, bottom );
+					bottom[2] += pm->mins[2];
+				//	if ( pm->gent->client && pm->gent->client->playerTeam != TEAM_DISGUISE )
+					{
+						AddSoundEvent( pm->gent, bottom, 256, AEL_MINOR, qfalse, qtrue );
+					}
+				}
+			}
+		}
+	} 
+	else if ( delta >= 30 ) 
+	{
+		if ( !deadFallSound )
+		{
+			if ( !(pm->ps->eFlags&EF_NODRAW) )
+			{//no sound if no draw
+				PM_AddEvent( EV_FALL_SHORT );
+			}
+		}
+		if ( pm->gent )
+		{
+			if ( pm->gent->s.number == 0 ) 
+			{
+				vec3_t	bottom;
+
+				VectorCopy( pm->ps->origin, bottom );
+				bottom[2] += pm->mins[2];
+		//		if ( pm->gent->client && pm->gent->client->playerTeam != TEAM_DISGUISE )
+				{
+					AddSoundEvent( pm->gent, bottom, 128, AEL_MINOR, qfalse, qtrue );
+				}
+			}
+			else
+			{
+				if ( !(pml.groundTrace.surfaceFlags & SURF_NODAMAGE) )  
+				{
+					PM_CrashLandDamage( delta );
+				}
+			}
+		}
+	} 
+	else 
+	{
+		if ( !deadFallSound )
+		{
+			if ( !(pm->ps->pm_flags&PMF_DUCKED) || !Q_irand( 0, 3 ) )
+			{//only 25% chance of making landing alert when ducked
+				AddSoundEvent( pm->gent, pm->ps->origin, 32, AEL_MINOR, qfalse, qtrue );
+			}
+			if ( !(pm->ps->eFlags&EF_NODRAW) )
+			{//no sound if no draw
+				if ( forceLanding )
+				{//we were force-jumping
+					PM_AddEvent( EV_FALL_SHORT );
+				}
+				else
+				{
+//moved to cg_player				PM_AddEvent( PM_FootstepForSurface() );
+				}
+			}
+		}
+	}
+
+	// start footstep cycle over
+	pm->ps->bobCycle = 0;
+	if ( pm->gent && pm->gent->client )
+	{//stop the force push effect when you land
+		pm->gent->forcePushTime = 0;
+	}
+}
+
+
+
+/*
+=============
+PM_CorrectAllSolid
+=============
+*/
+static void PM_CorrectAllSolid( void ) {
+	if ( pm->debugLevel ) {
+		Com_Printf("%i:allsolid\n", c_pmove);	//NOTENOTE: If this ever happens, I'd really like to see this print!
+	}
+
+	// FIXME: jitter around
+
+	pm->ps->groundEntityNum = ENTITYNUM_NONE;
+	pml.groundPlane = qfalse;
+	pml.walking = qfalse;
+}
+
+qboolean FlyingCreature( gentity_t *ent )
+{
+	if ( ent->client->ps.gravity <= 0 && (ent->svFlags&SVF_CUSTOM_GRAVITY) )
+	{
+		return qtrue;
+	}
+	return qfalse;
+}
+
+qboolean PM_RocketeersAvoidDangerousFalls( void )
+{
+	if ( pm->gent->NPC 
+		&& pm->gent->client 
+		&& (pm->gent->client->NPC_class == CLASS_BOBAFETT||pm->gent->client->NPC_class == CLASS_ROCKETTROOPER) )
+	{//fixme:  fall through if jetpack broken?
+		if ( JET_Flying( pm->gent ) )
+		{
+			if ( pm->gent->client->NPC_class == CLASS_BOBAFETT )
+			{
+				pm->gent->client->jetPackTime = level.time + 2000;
+				//Wait, what if the effect is already playing, how do we know???
+				//G_PlayEffect( G_EffectIndex( "boba/jetSP" ), pm->gent->playerModel, pm->gent->genericBolt1, pm->gent->s.number, pm->gent->currentOrigin, pm->gent->client->jetPackTime-level.time );
+			}
+			else
+			{
+				pm->gent->client->jetPackTime = Q3_INFINITE;
+			}
+		}
+		else
+		{
+			TIMER_Set( pm->gent, "jetRecharge", 0 );
+			JET_FlyStart( pm->gent );
+		}
+		return qtrue;
+	}
+	return qfalse;
+}
+
+static void PM_FallToDeath( void )
+{
+	if ( !pm->gent )
+	{
+		return;
+	}
+
+	if ( PM_RocketeersAvoidDangerousFalls() )
+	{
+		return;
+	}
+
+	// If this is a vehicle, more precisely an animal...
+	if ( pm->gent->client->NPC_class == CLASS_VEHICLE && pm->gent->m_pVehicle->m_pVehicleInfo->type == VH_ANIMAL )
+	{
+		Vehicle_t *pVeh = pm->gent->m_pVehicle;
+		pVeh->m_pVehicleInfo->EjectAll( pVeh );
+	}
+	else
+	{
+		if ( PM_HasAnimation( pm->gent, BOTH_FALLDEATH1 ) )
+		{
+			PM_SetAnim(pm,SETANIM_LEGS,BOTH_FALLDEATH1,SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD);
+		}
+		else
+		{
+			PM_SetAnim(pm,SETANIM_LEGS,BOTH_DEATH1,SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD);
+		}
+		G_SoundOnEnt( pm->gent, CHAN_VOICE, "*falling1.wav" );//CHAN_VOICE_ATTEN
+	}
+
+	if ( pm->gent->NPC )
+	{
+		pm->gent->NPC->aiFlags |= NPCAI_DIE_ON_IMPACT;
+		pm->gent->NPC->nextBStateThink = Q3_INFINITE;
+	}
+	pm->ps->friction = 1;
+}
+
+int PM_ForceJumpAnimForJumpAnim( int anim )
+{
+	switch( anim )
+	{
+	case BOTH_JUMP1:				//# Jump - wind-up and leave ground
+		anim = BOTH_FORCEJUMP1;			//# Jump - wind-up and leave ground
+		break;
+	case BOTH_INAIR1:			//# In air loop (from jump)
+		anim = BOTH_FORCEINAIR1;			//# In air loop (from jump)
+		break;
+	case BOTH_LAND1:				//# Landing (from in air loop)
+		anim = BOTH_FORCELAND1;				//# Landing (from in air loop)
+		break;
+	case BOTH_JUMPBACK1:			//# Jump backwards - wind-up and leave ground
+		anim = BOTH_FORCEJUMPBACK1;			//# Jump backwards - wind-up and leave ground
+		break;
+	case BOTH_INAIRBACK1:		//# In air loop (from jump back)
+		anim = BOTH_FORCEINAIRBACK1;		//# In air loop (from jump back)
+		break;
+	case BOTH_LANDBACK1:			//# Landing backwards(from in air loop)
+		anim = BOTH_FORCELANDBACK1;			//# Landing backwards(from in air loop)
+		break;
+	case BOTH_JUMPLEFT1:			//# Jump left - wind-up and leave ground
+		anim = BOTH_FORCEJUMPLEFT1;			//# Jump left - wind-up and leave ground
+		break;
+	case BOTH_INAIRLEFT1:		//# In air loop (from jump left)
+		anim = BOTH_FORCEINAIRLEFT1;		//# In air loop (from jump left)
+		break;
+	case BOTH_LANDLEFT1:			//# Landing left(from in air loop)
+		anim = BOTH_FORCELANDLEFT1;			//# Landing left(from in air loop)
+		break;
+	case BOTH_JUMPRIGHT1:		//# Jump right - wind-up and leave ground
+		anim = BOTH_FORCEJUMPRIGHT1;		//# Jump right - wind-up and leave ground
+		break;
+	case BOTH_INAIRRIGHT1:		//# In air loop (from jump right)
+		anim = BOTH_FORCEINAIRRIGHT1;		//# In air loop (from jump right)
+		break;
+	case BOTH_LANDRIGHT1:		//# Landing right(from in air loop)
+		anim = BOTH_FORCELANDRIGHT1;		//# Landing right(from in air loop)
+		break;
+	}
+	return anim;
+}
+
+static void PM_SetVehicleAngles( vec3_t normal )
+{
+	if ( !pm->gent->client || pm->gent->client->NPC_class != CLASS_VEHICLE )
+		return;
+
+	Vehicle_t *pVeh = pm->gent->m_pVehicle;
+	
+	//float	curVehicleBankingSpeed;
+	float	vehicleBankingSpeed = pVeh->m_pVehicleInfo->bankingSpeed;//0.25f
+	vec3_t	vAngles;
+
+	if ( vehicleBankingSpeed <= 0 
+		|| ( pVeh->m_pVehicleInfo->pitchLimit <= 0 && pVeh->m_pVehicleInfo->rollLimit <= 0 ) )
+	{//don't bother, this vehicle doesn't bank
+		return;
+	}
+	//FIXME: do 3 traces to define a plane and use that... smoothes it out some, too...
+	//pitch_roll_for_slope( pm->gent, normal, vAngles );
+	//FIXME: maybe have some pitch control in water and/or air?
+	
+	//center of gravity affects pitch in air/water (FIXME: what about roll?)
+	//float pitchBias = 90.0f*pVeh->m_pVehicleInfo->centerOfGravity[0];//if centerOfGravity is all the way back (-1.0f), vehicle pitches up 90 degrees when in air
+
+	VectorClear( vAngles );
+
+
+ 	if (pm->waterlevel>0 || (normal && (pml.groundTrace.contents&(CONTENTS_WATER|CONTENTS_SLIME|CONTENTS_LAVA))))
+	{//in water
+	//	vAngles[PITCH] += (pm->ps->viewangles[PITCH]-vAngles[PITCH])*0.75f + (pitchBias*0.5);
+	}
+	else if ( normal )
+	{//have a valid surface below me
+		pitch_roll_for_slope( pm->gent, normal, vAngles );
+		float deltaPitch = (vAngles[PITCH] - pVeh->m_vOrientation[PITCH]);
+ 		if (deltaPitch< -10.0f)
+		{
+			vAngles[PITCH] = pVeh->m_vOrientation[PITCH] - 10.0f;
+		}
+		else if (deltaPitch>10.0f)
+		{
+			vAngles[PITCH] = pVeh->m_vOrientation[PITCH] + 10.0f;
+		}
+	}
+	else
+	{//in air, let pitch match view...?
+		//FIXME: take center of gravity into account
+	 	vAngles[PITCH] = pVeh->m_vOrientation[PITCH] - 1;
+		if (vAngles[PITCH]<-15)
+		{
+			vAngles[PITCH]=-15;
+		}
+		//don't bank so fast when in the air
+		vehicleBankingSpeed *= 0.125f;
+	}
+	//NOTE: if angles are flat and we're moving through air (not on ground),
+	//		then pitch/bank?
+	if (pVeh->m_ulFlags & VEH_SPINNING)
+	{
+		vAngles[ROLL] = pVeh->m_vOrientation[ROLL] - 25;
+	}
+	else if (pVeh->m_ulFlags & VEH_OUTOFCONTROL)
+	{
+		//vAngles[ROLL] = pVeh->m_vOrientation[ROLL] + 5;
+	}
+	else if ( pVeh->m_pVehicleInfo->rollLimit > 0 )
+	{
+		//roll when banking
+		vec3_t	velocity;
+		float	speed;
+		VectorCopy( pm->ps->velocity, velocity );
+		speed = VectorNormalize( velocity );
+		if ( speed>0.01f )
+		{
+			vec3_t	rt, tempVAngles;
+			float	side, dotp;
+
+
+			VectorCopy( pVeh->m_vOrientation, tempVAngles );
+			tempVAngles[ROLL] = 0;
+			AngleVectors( tempVAngles, NULL, rt, NULL );
+			dotp = DotProduct( velocity, rt );
+			//if (fabsf(dotp)>0.5f)
+			{
+				speed *= dotp;
+
+
+				// Magic number fun!  Speed is used for banking, so modulate the speed by a sine wave
+				//FIXME: this banks too early
+				//speed *= sin( (150 + pml.frametime) * 0.003 );
+				if (level.time < pVeh->m_iTurboTime)
+				{
+					speed /= pVeh->m_pVehicleInfo->turboSpeed;
+				}
+				else
+				{
+					speed /= pVeh->m_pVehicleInfo->speedMax;
+				}
+
+			///	if (pm->cmd.forwardmove==0)
+			//	{
+			//		speed *= 0.5;
+			//	}
+			//	if (pm->cmd.forwardmove<0)
+			//	{
+			//		speed *= 0.1f;
+			//	}
+				if (pVeh->m_ulFlags & VEH_SLIDEBREAKING)
+				{
+					speed *= 3.0f;
+				}
+
+		
+  				side = speed * 75.0f;
+	//			if (pVeh->m_ulFlags & VEH_STRAFERAM) 
+	//			{
+	//	 			vAngles[ROLL] += side;
+	//			}
+	//			else
+				{
+		 			vAngles[ROLL] -= side;
+				}
+
+		 		//gi.Printf("VAngles(%f)", vAngles[2]);
+			}
+			if (fabsf(vAngles[ROLL])<0.001f)
+			{
+				vAngles[ROLL] = 0.0f;
+			}
+		}
+	}
+
+	//cap
+ 	if ( vAngles[PITCH] > pVeh->m_pVehicleInfo->pitchLimit )
+	{
+		vAngles[PITCH] = pVeh->m_pVehicleInfo->pitchLimit;
+	}
+	else if ( vAngles[PITCH] < -pVeh->m_pVehicleInfo->pitchLimit )
+	{
+		vAngles[PITCH] = -pVeh->m_pVehicleInfo->pitchLimit;
+	}
+
+	if (!(pVeh->m_ulFlags & VEH_SPINNING))
+	{
+		if ( vAngles[ROLL] > pVeh->m_pVehicleInfo->rollLimit )
+		{
+			vAngles[ROLL] = pVeh->m_pVehicleInfo->rollLimit;
+		}
+		else if ( vAngles[ROLL] < -pVeh->m_pVehicleInfo->rollLimit )
+		{
+			vAngles[ROLL] = -pVeh->m_pVehicleInfo->rollLimit;
+		}
+	}
+	
+	//do it
+ 	for ( int i = 0; i < 3; i++ )
+	{
+		if ( i == YAW )
+		{//yawing done elsewhere
+			continue;
+		}
+
+		if ( i == ROLL && pVeh->m_ulFlags & VEH_STRAFERAM)
+		{//during strafe ram, roll is done elsewhere
+			continue;
+		}
+		//bank faster the higher the difference is
+		/*
+		else if ( i == PITCH )
+		{
+			curVehicleBankingSpeed = vehicleBankingSpeed*fabs(AngleNormalize180(AngleSubtract( vAngles[PITCH], pVeh->m_vOrientation[PITCH] )))/(g_vehicleInfo[pm->ps->vehicleIndex].pitchLimit/2.0f);
+		}
+		else if ( i == ROLL )
+		{
+			curVehicleBankingSpeed = vehicleBankingSpeed*fabs(AngleNormalize180(AngleSubtract( vAngles[ROLL], pVeh->m_vOrientation[ROLL] )))/(g_vehicleInfo[pm->ps->vehicleIndex].rollLimit/2.0f);
+		}
+
+		if ( curVehicleBankingSpeed )
+		*/
+		{
+		//	if ( pVeh->m_vOrientation[i] >= vAngles[i] + vehicleBankingSpeed )
+		//	{
+		//		pVeh->m_vOrientation[i] -= vehicleBankingSpeed;
+		//	}
+		//	else if ( pVeh->m_vOrientation[i] <= vAngles[i] - vehicleBankingSpeed )
+		//	{
+		//		pVeh->m_vOrientation[i] += vehicleBankingSpeed;
+		//	}
+		//	else
+			{
+				pVeh->m_vOrientation[i] = vAngles[i];
+			}
+		}
+	}
+ 	//gi.Printf("Orientation(%f)", pVeh->m_vOrientation[2]);
+}
+
+void BG_ExternThisSoICanRecompileInDebug( Vehicle_t *pVeh, playerState_t *riderPS )
+{/*
+	float pitchSubtract, pitchDelta, yawDelta;
+	//Com_Printf( S_COLOR_RED"PITCH: %4.2f, YAW: %4.2f, ROLL: %4.2f\n", riderPS->viewangles[0],riderPS->viewangles[1],riderPS->viewangles[2]);
+	yawDelta = AngleSubtract(riderPS->viewangles[YAW],pVeh->m_vPrevRiderViewAngles[YAW]);
+#ifndef QAGAME
+	if ( !cg_paused.integer )
+	{
+		//Com_Printf( "%d - yawDelta %4.2f\n", pm->cmd.serverTime, yawDelta );
+	}
+#endif
+	yawDelta *= (4.0f*pVeh->m_fTimeModifier);
+	pVeh->m_vOrientation[ROLL] -= yawDelta;
+
+	pitchDelta = AngleSubtract(riderPS->viewangles[PITCH],pVeh->m_vPrevRiderViewAngles[PITCH]);
+	pitchDelta *= (2.0f*pVeh->m_fTimeModifier);
+	pitchSubtract = pitchDelta * (fabs(pVeh->m_vOrientation[ROLL])/90.0f);
+	pVeh->m_vOrientation[PITCH] += pitchDelta-pitchSubtract;
+	if ( pVeh->m_vOrientation[ROLL] > 0 )
+	{
+		pVeh->m_vOrientation[YAW] += pitchSubtract;
+	}
+	else
+	{
+		pVeh->m_vOrientation[YAW] -= pitchSubtract;
+	}
+	pVeh->m_vOrientation[PITCH] = AngleNormalize180( pVeh->m_vOrientation[PITCH] );
+	pVeh->m_vOrientation[YAW] = AngleNormalize360( pVeh->m_vOrientation[YAW] );
+	pVeh->m_vOrientation[ROLL] = AngleNormalize180( pVeh->m_vOrientation[ROLL] );
+
+	VectorCopy( riderPS->viewangles, pVeh->m_vPrevRiderViewAngles );*/
+}
+
+void BG_VehicleTurnRateForSpeed( Vehicle_t *pVeh, float speed, float *mPitchOverride, float *mYawOverride )
+{
+	if ( pVeh && pVeh->m_pVehicleInfo )
+	{
+		float speedFrac = 1.0f;
+		if ( pVeh->m_pVehicleInfo->speedDependantTurning )
+		{
+			if ( pVeh->m_LandTrace.fraction >= 1.0f 
+				|| pVeh->m_LandTrace.plane.normal[2] < MIN_LANDING_SLOPE  )
+			{
+				speedFrac = (speed/(pVeh->m_pVehicleInfo->speedMax*0.75f));
+				if ( speedFrac < 0.25f )
+				{
+					speedFrac = 0.25f;
+				}
+				else if ( speedFrac > 1.0f )
+				{
+					speedFrac = 1.0f;
+				}
+			}
+		}
+		if ( pVeh->m_pVehicleInfo->mousePitch )
+		{
+			*mPitchOverride = pVeh->m_pVehicleInfo->mousePitch*speedFrac;
+		}
+		if ( pVeh->m_pVehicleInfo->mouseYaw )
+		{
+			*mYawOverride = pVeh->m_pVehicleInfo->mouseYaw*speedFrac;
+		}
+	}
+}
+/*
+=============
+PM_GroundTraceMissed
+
+The ground trace didn't hit a surface, so we are in freefall
+=============
+*/
+static void PM_GroundTraceMissed( void ) {
+	trace_t		trace;
+	vec3_t		point;
+	qboolean	cliff_fall = qfalse;
+
+	if ( Flying != FLY_HOVER )
+	{
+		if ( !(pm->ps->eFlags&EF_FORCE_DRAINED) )
+		{
+			//FIXME: if in a contents_falldeath brush, play the falling death anim and sound?
+			if ( pm->ps->clientNum != 0 && pm->gent && pm->gent->NPC && pm->gent->client && pm->gent->client->NPC_class != CLASS_DESANN )//desann never falls to his death
+			{
+				if ( pm->ps->groundEntityNum == ENTITYNUM_NONE )
+				{
+					if ( pm->ps->stats[STAT_HEALTH] > 0 
+						&& !(pm->gent->NPC->aiFlags&NPCAI_DIE_ON_IMPACT) 
+						&& !(pm->gent->NPC->aiFlags&NPCAI_JUMP)					// doing a path jump
+						&& !(pm->gent->NPC->scriptFlags&SCF_NO_FALLTODEATH)
+						&& pm->gent->NPC->behaviorState != BS_JUMP )//not being scripted to jump
+					{
+						if ( (level.time - pm->gent->client->respawnTime > 2000)//been in the world for at least 2 seconds
+							&& (!pm->gent->NPC->timeOfDeath || level.time - pm->gent->NPC->timeOfDeath < 1000) && pm->gent->e_ThinkFunc != thinkF_NPC_RemoveBody //Have to do this now because timeOfDeath is used by thinkF_NPC_RemoveBody to debounce removal checks
+							&& !(pm->gent->client->ps.forcePowersActive&(1<<FP_LEVITATION)) )
+						{
+							if ( !FlyingCreature( pm->gent ) 
+								&& g_gravity->value > 0 )
+							{
+								if ( !(pm->gent->flags&FL_UNDYING) 
+									&& !(pm->gent->flags&FL_GODMODE) )
+								{
+									if ( !(pm->ps->eFlags&EF_FORCE_GRIPPED) 
+										&& !(pm->ps->eFlags&EF_FORCE_DRAINED) 
+										&& !(pm->ps->pm_flags&PMF_TRIGGER_PUSHED) )
+									{
+										if ( !pm->ps->forceJumpZStart || pm->ps->forceJumpZStart > pm->ps->origin[2] )// && fabs(pm->ps->velocity[0])<10 && fabs(pm->ps->velocity[1])<10 && pm->ps->velocity[2]<0)//either not force-jumping or force-jumped and now fell below original jump start height
+										{
+											/*if ( pm->ps->legsAnim = BOTH_FALLDEATH1 
+											&& pm->ps->legsAnim != BOTH_DEATH1 
+											&& PM_HasAnimation( pm->gent, BOTH_FALLDEATH1 )*/
+											//New method: predict impact, 400 ahead
+											vec3_t	vel;
+											float	time;
+
+											VectorCopy( pm->ps->velocity, vel );
+											float speed = VectorLength( vel );
+											if ( !speed )
+											{//damn divide by zero
+												speed = 1;
+											}
+											time = 400/speed;
+											vel[2] -= 0.5 * time * pm->ps->gravity;
+											speed = VectorLength( vel );
+											if ( !speed )
+											{//damn divide by zero
+												speed = 1;
+											}
+											time = 400/speed;
+											VectorScale( vel, time, vel );
+											VectorAdd( pm->ps->origin, vel, point );
+
+											pm->trace( &trace, pm->ps->origin, pm->mins, pm->maxs, point, pm->ps->clientNum, pm->tracemask );
+
+											if ( (trace.contents&CONTENTS_LAVA)
+												&& PM_RocketeersAvoidDangerousFalls() )
+											{//got out of it
+											}
+											else if ( !trace.allsolid && !trace.startsolid && (pm->ps->origin[2] - trace.endpos[2]) >= 128 )//>=128 so we don't die on steps!
+											{
+												if ( trace.fraction == 1.0 )
+												{//didn't hit, we're probably going to die
+													if ( pm->ps->velocity[2] < 0 && pm->ps->origin[2] - point[2] > 256 )
+													{//going down, into a bottomless pit, apparently
+														PM_FallToDeath();
+														cliff_fall = qtrue;
+													}
+												}
+												else if ( trace.entityNum < ENTITYNUM_NONE 
+													&& pm->ps->weapon != WP_SABER 
+													&& (!pm->gent || !pm->gent->client || (pm->gent->client->NPC_class != CLASS_BOBAFETT&&pm->gent->client->NPC_class!=CLASS_REBORN&&pm->gent->client->NPC_class!=CLASS_ROCKETTROOPER)) )
+												{//Jedi don't scream and die if they're heading for a hard impact
+													gentity_t *traceEnt = &g_entities[trace.entityNum];
+													if ( trace.entityNum == ENTITYNUM_WORLD || (traceEnt && traceEnt->bmodel) )
+													{//hit architecture, find impact force
+														float	dmg;
+
+														VectorCopy( pm->ps->velocity, vel );
+														time = Distance( trace.endpos, pm->ps->origin )/VectorLength( vel );
+														vel[2] -= 0.5 * time * pm->ps->gravity;
+
+														if ( trace.plane.normal[2] > 0.5 )
+														{//use falling damage
+															int	waterlevel, junk;
+															PM_SetWaterLevelAtPoint( trace.endpos, &waterlevel, &junk );
+															dmg = PM_CrashLandDelta( vel, waterlevel );
+															if ( dmg >= 30 )
+															{//there is a minimum fall threshhold
+																dmg = PM_DamageForDelta( dmg );
+															}
+															else
+															{
+																dmg = 0;
+															}
+														}
+														else
+														{//use impact damage
+															//guestimate
+															if ( pm->gent->client && pm->gent->client->ps.forceJumpZStart )
+															{//we were force-jumping
+																if ( pm->gent->currentOrigin[2] >= pm->gent->client->ps.forceJumpZStart )
+																{//we landed at same height or higher than we landed
+																	dmg = 0;
+																}
+																else
+																{//FIXME: take off some of it, at least?
+																	dmg = (pm->gent->client->ps.forceJumpZStart-pm->gent->currentOrigin[2])/3;
+																}
+															}
+															dmg = 10 * VectorLength( pm->ps->velocity );
+															if ( pm->ps->clientNum < MAX_CLIENTS )
+															{
+																dmg /= 2;
+															}
+															dmg *= 0.01875f;//magic number
+														}
+														float maxDmg = pm->ps->stats[STAT_HEALTH]>20?pm->ps->stats[STAT_HEALTH]:20;//a fall that would do less than 20 points of damage should never make us scream to our deaths
+														if ( pm->gent && pm->gent->client && pm->gent->client->NPC_class == CLASS_HOWLER )
+														{//howlers can survive long falls, despire their health
+															maxDmg *= 5;
+														}
+														if ( dmg >= pm->ps->stats[STAT_HEALTH] )//armor?
+														{
+															PM_FallToDeath();
+															cliff_fall = qtrue;
+														}
+													}
+												}
+											}
+											
+											/*
+											vec3_t	start;
+											//okay, kind of expensive temp hack here, but let's check to see if we should scream
+											//FIXME: we should either do a better check (predict using actual velocity) or we should wait until they've been over a bottomless pit for a certain amount of time...
+											VectorCopy( pm->ps->origin, start );
+											if ( pm->ps->forceJumpZStart < start[2] )
+											{//Jedi who are force-jumping should only do this from landing point down?
+												start[2] = pm->ps->forceJumpZStart;
+											}
+											VectorCopy( start, point );
+											point[2] -= 400;//320
+											pm->trace (&trace, pm->ps->origin, pm->mins, pm->maxs, point, pm->ps->clientNum, pm->tracemask);
+											//FIXME: somehow, people can still get stuck on ledges and not splat when hit...?
+											if ( !trace.allsolid && !trace.startsolid && trace.fraction == 1.0 )
+											{
+												PM_FallToDeath();
+												cliff_fall = qtrue;
+											}
+											*/
+										}
+									}
+								}
+							}
+						}
+					}
+				}
+			}
+			if ( !cliff_fall )
+			{
+				if ( pm->ps->legsAnim == BOTH_FORCELONGLEAP_START 
+					|| pm->ps->legsAnim == BOTH_FORCELONGLEAP_ATTACK
+					|| pm->ps->legsAnim == BOTH_FORCEWALLRUNFLIP_START
+					|| pm->ps->legsAnim == BOTH_FLIP_LAND )
+				{//let it stay on this anim
+				}
+				else if ( PM_KnockDownAnimExtended( pm->ps->legsAnim ) )
+				{//no in-air anims when in knockdown anim
+				}
+				else if ( ( pm->ps->legsAnim == BOTH_WALL_RUN_RIGHT
+					|| pm->ps->legsAnim == BOTH_WALL_RUN_LEFT
+					|| pm->ps->legsAnim == BOTH_WALL_RUN_RIGHT_STOP
+					|| pm->ps->legsAnim == BOTH_WALL_RUN_LEFT_STOP
+					|| pm->ps->legsAnim == BOTH_WALL_RUN_RIGHT_FLIP
+					|| pm->ps->legsAnim == BOTH_WALL_RUN_LEFT_FLIP
+					|| pm->ps->legsAnim == BOTH_WALL_FLIP_RIGHT
+					|| pm->ps->legsAnim == BOTH_WALL_FLIP_LEFT 
+					|| pm->ps->legsAnim == BOTH_FORCEWALLREBOUND_FORWARD
+					|| pm->ps->legsAnim == BOTH_FORCEWALLREBOUND_LEFT
+					|| pm->ps->legsAnim == BOTH_FORCEWALLREBOUND_BACK
+					|| pm->ps->legsAnim == BOTH_FORCEWALLREBOUND_RIGHT
+					|| pm->ps->legsAnim == BOTH_CEILING_DROP )
+					&& !pm->ps->legsAnimTimer )
+				{//if flip anim is done, okay to use inair
+					PM_SetAnim( pm, SETANIM_LEGS, BOTH_FORCEINAIR1, SETANIM_FLAG_OVERRIDE, 350 );	// Only blend over 100ms
+				}
+				else if ( pm->ps->legsAnim == BOTH_FLIP_ATTACK7 
+					|| pm->ps->legsAnim == BOTH_FLIP_HOLD7  )
+				{
+					if ( !pm->ps->legsAnimTimer )
+					{//done?
+						PM_SetAnim( pm, SETANIM_BOTH, BOTH_FLIP_HOLD7, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD, 350 );	// Only blend over 100ms
+					}
+				}
+				else if ( PM_InCartwheel( pm->ps->legsAnim ) )
+				{
+					if ( pm->ps->legsAnimTimer > 0 )
+					{//still playing on bottom
+					}
+					else
+					{
+						PM_SetAnim( pm, SETANIM_BOTH, BOTH_INAIR1, SETANIM_FLAG_NORMAL, 350  );
+					}
+				}
+				else if ( PM_InAirKickingAnim( pm->ps->legsAnim ) ) 
+				{
+					if ( pm->ps->legsAnimTimer > 0 )
+					{//still playing on bottom
+					}
+					else
+					{
+						PM_SetAnim( pm, SETANIM_BOTH, BOTH_INAIR1, SETANIM_FLAG_NORMAL, 350  );
+						pm->ps->saberMove = LS_READY;
+						pm->ps->weaponTime = 0;
+					}
+				}
+				else if ( !PM_InRoll( pm->ps ) 
+					&& !PM_SpinningAnim( pm->ps->legsAnim )
+					&& !PM_FlippingAnim( pm->ps->legsAnim )
+					&& !PM_InSpecialJump( pm->ps->legsAnim ) )
+				{
+					if ( pm->ps->groundEntityNum != ENTITYNUM_NONE ) 
+					{
+						// we just transitioned into freefall
+						if ( pm->debugLevel ) 
+						{
+							Com_Printf("%i:lift\n", c_pmove);
+						}
+
+						// if they aren't in a jumping animation and the ground is a ways away, force into it
+						// if we didn't do the trace, the player would be backflipping down staircases
+						VectorCopy( pm->ps->origin, point );
+						point[2] -= 64;
+
+						pm->trace (&trace, pm->ps->origin, pm->mins, pm->maxs, point, pm->ps->clientNum, pm->tracemask);
+						if ( trace.fraction == 1.0 ) 
+						{//FIXME: if velocity[2] < 0 and didn't jump, use some falling anim
+							if ( pm->ps->velocity[2] <= 0 && !(pm->ps->pm_flags&PMF_JUMP_HELD))
+							{
+								if(!PM_InDeathAnim())
+								{
+									// If we're a vehicle, set our falling flag.
+									if ( pm->gent && pm->gent->client && pm->gent->client->NPC_class == CLASS_VEHICLE )
+									{
+										// We're flying in the air.
+										if ( pm->gent->m_pVehicle->m_pVehicleInfo->type == VH_ANIMAL )
+										{
+											pm->gent->m_pVehicle->m_ulFlags |= VEH_FLYING;
+										}
+									}
+									else
+									{
+										vec3_t	moveDir, lookAngles, lookDir, lookRight;
+										int		anim = BOTH_INAIR1;
+
+										VectorCopy( pm->ps->velocity, moveDir );
+										moveDir[2] = 0;
+										VectorNormalize( moveDir );
+
+										VectorCopy( pm->ps->viewangles, lookAngles );
+										lookAngles[PITCH] = lookAngles[ROLL] = 0;
+										AngleVectors( lookAngles, lookDir, lookRight, NULL );
+
+										float dot = DotProduct( moveDir, lookDir );
+										if ( dot > 0.5 )
+										{//redundant
+											anim = BOTH_INAIR1;
+										}
+										else if ( dot < -0.5 )
+										{
+											anim = BOTH_INAIRBACK1;
+										}
+										else
+										{
+											dot = DotProduct( moveDir, lookRight );
+											if ( dot > 0.5 )
+											{
+												anim = BOTH_INAIRRIGHT1;
+											}
+											else if ( dot < -0.5 )
+											{
+												anim = BOTH_INAIRLEFT1;
+											}
+											else
+											{//redundant
+												anim = BOTH_INAIR1;
+											}
+										}
+										if ( pm->ps->forcePowersActive & ( 1 << FP_LEVITATION ) )
+										{
+											anim = PM_ForceJumpAnimForJumpAnim( anim );
+										}
+										PM_SetAnim( pm, SETANIM_LEGS, anim, SETANIM_FLAG_OVERRIDE, 100 );	// Only blend over 100ms
+									}
+								}
+								pm->ps->pm_flags &= ~PMF_BACKWARDS_JUMP;
+							}
+							else if ( !(pm->ps->forcePowersActive&(1<<FP_LEVITATION)) )
+							{
+								if ( pm->cmd.forwardmove >= 0 ) 
+								{
+									if(!PM_InDeathAnim())
+									{
+										PM_SetAnim(pm,SETANIM_LEGS,BOTH_JUMP1,SETANIM_FLAG_OVERRIDE, 100);	// Only blend over 100ms
+									}
+									pm->ps->pm_flags &= ~PMF_BACKWARDS_JUMP;
+								} 
+								else if ( pm->cmd.forwardmove < 0 ) 
+								{
+									if(!PM_InDeathAnim())
+									{
+										PM_SetAnim(pm,SETANIM_LEGS,BOTH_JUMPBACK1,SETANIM_FLAG_OVERRIDE, 100);	// Only blend over 100ms
+									}
+									pm->ps->pm_flags |= PMF_BACKWARDS_JUMP;
+								}
+							}
+						}
+						else
+						{
+							// If we're a vehicle, set our falling flag.
+							if ( pm->gent && pm->gent->client && pm->gent->client->NPC_class == CLASS_VEHICLE )
+							{
+								// We're on the ground.
+								if ( pm->gent->m_pVehicle->m_pVehicleInfo->type == VH_ANIMAL )
+								{
+									pm->gent->m_pVehicle->m_ulFlags &= ~VEH_FLYING;
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+
+		if ( pm->ps->groundEntityNum != ENTITYNUM_NONE )
+		{
+			pm->ps->jumpZStart = pm->ps->origin[2];
+		}
+	}
+	pm->ps->groundEntityNum = ENTITYNUM_NONE;
+	pml.groundPlane = qfalse;
+	pml.walking = qfalse;
+}
+
+
+/*
+=============
+PM_GroundTrace
+=============
+*/
+static void PM_GroundTrace( void ) {
+	vec3_t		point;
+	trace_t		trace;
+
+	if ( (pm->ps->eFlags&EF_LOCKED_TO_WEAPON)
+		|| (pm->ps->eFlags&EF_HELD_BY_RANCOR)
+		|| (pm->ps->eFlags&EF_HELD_BY_WAMPA)
+		|| (pm->ps->eFlags&EF_HELD_BY_SAND_CREATURE)
+		|| PM_RidingVehicle() )
+	{
+		pml.groundPlane = qtrue;
+		pml.walking = qtrue;
+		pm->ps->groundEntityNum = ENTITYNUM_WORLD;
+		pm->ps->lastOnGround = level.time;
+		/*
+		pml.groundTrace.allsolid = qfalse;
+		pml.groundTrace.contents = CONTENTS_SOLID;
+		VectorCopy( pm->ps->origin, pml.groundTrace.endpos );
+		pml.groundTrace.entityNum = ENTITYNUM_WORLD;
+		pml.groundTrace.fraction = 0.0f;;
+		pml.groundTrace.G2CollisionMap = NULL;
+		pml.groundTrace.plane.dist = 0.0f;
+		VectorSet( pml.groundTrace.plane.normal, 0, 0, 1 );
+		pml.groundTrace.plane.pad = 0;
+		pml.groundTrace.plane.signbits = 0;
+		pml.groundTrace.plane.type = 0;;
+		pml.groundTrace.startsolid = qfalse;
+		pml.groundTrace.surfaceFlags = 0;
+		*/
+		return;
+	}
+	else if ( pm->ps->legsAnimTimer > 300 
+		&& (pm->ps->legsAnim == BOTH_WALL_RUN_RIGHT 
+			|| pm->ps->legsAnim == BOTH_WALL_RUN_LEFT
+			|| pm->ps->legsAnim == BOTH_FORCEWALLRUNFLIP_START) )
+	{//wall-running forces you to be in the air
+		pml.groundPlane = qfalse;
+		pml.walking = qfalse;
+		pm->ps->groundEntityNum = ENTITYNUM_NONE;
+		return;
+	}
+
+	float minNormal = (float)MIN_WALK_NORMAL;
+	if ( pm->gent && pm->gent->client && pm->gent->client->NPC_class == CLASS_VEHICLE )
+	{//FIXME: extern this as part of vehicle data
+		minNormal = pm->gent->m_pVehicle->m_pVehicleInfo->maxSlope;
+	}
+
+	point[0] = pm->ps->origin[0];
+	point[1] = pm->ps->origin[1];
+	point[2] = pm->ps->origin[2] - 0.25f;
+
+	pm->trace (&trace, pm->ps->origin, pm->mins, pm->maxs, point, pm->ps->clientNum, pm->tracemask);
+	pml.groundTrace = trace;
+
+	// do something corrective if the trace starts in a solid...
+	if ( trace.allsolid ) {
+		PM_CorrectAllSolid();
+		return;
+	}
+
+	// if the trace didn't hit anything, we are in free fall
+	if ( trace.fraction == 1.0 || g_gravity->value <= 0 ) 
+	{
+		PM_GroundTraceMissed();
+		pml.groundPlane = qfalse;
+		pml.walking = qfalse;
+		/*
+		if ( pm->ps->vehicleIndex != VEHICLE_NONE )
+		{
+			PM_SetVehicleAngles( NULL );
+		}
+		*/
+		return;
+	}
+
+	// Not a vehicle and not riding one.
+	if ( pm->gent 
+		&& pm->gent->client 
+		&& pm->gent->client->NPC_class != CLASS_SAND_CREATURE
+		&& (pm->gent->client->NPC_class != CLASS_VEHICLE && !PM_RidingVehicle() ) )
+	{
+		// check if getting thrown off the ground
+		if ( ((pm->ps->velocity[2]>0&&(pm->ps->pm_flags&PMF_TIME_KNOCKBACK))||pm->ps->velocity[2]>100) && DotProduct( pm->ps->velocity, trace.plane.normal ) > 10 )
+		{//either thrown off ground (PMF_TIME_KNOCKBACK) or going off the ground at a large velocity
+			if ( pm->debugLevel ) {
+				Com_Printf("%i:kickoff\n", c_pmove);
+			}
+			// go into jump animation
+			if ( PM_FlippingAnim( pm->ps->legsAnim) )
+			{//we're flipping
+			}
+			else if ( PM_InSpecialJump( pm->ps->legsAnim ) )
+			{//special jumps
+			}
+			else if ( PM_InKnockDown( pm->ps ) )
+			{//in knockdown
+			}
+			else if ( PM_InRoll( pm->ps ) )
+			{//in knockdown
+			}
+			else if ( PM_KickingAnim( pm->ps->legsAnim ) )
+			{//in kick
+			}
+			else if ( pm->gent 
+				&& pm->gent->client 
+				&& (pm->gent->client->NPC_class == CLASS_RANCOR || pm->gent->client->NPC_class == CLASS_WAMPA) )
+			{
+			}
+			else
+			{
+				PM_JumpForDir();
+			}
+
+			pm->ps->groundEntityNum = ENTITYNUM_NONE;
+			pml.groundPlane = qfalse;
+			pml.walking = qfalse;
+			return;
+		}
+	}
+	
+	/*
+	if ( pm->ps->vehicleIndex != VEHICLE_NONE )
+	{
+		PM_SetVehicleAngles( trace.plane.normal );
+	}
+	*/
+
+	// slopes that are too steep will not be considered onground
+	if ( trace.plane.normal[2] < minNormal ) {
+		if ( pm->debugLevel ) {
+			Com_Printf("%i:steep\n", c_pmove);
+		}
+		// FIXME: if they can't slide down the slope, let them
+		// walk (sharp crevices)
+		pm->ps->groundEntityNum = ENTITYNUM_NONE;
+		pml.groundPlane = qtrue;
+		pml.walking = qfalse;
+		return;
+	}
+
+	//FIXME: if the ground surface is a "cover surface (like tall grass), add a "cover" flag to me
+	pml.groundPlane = qtrue;
+	pml.walking = qtrue;
+
+	// hitting solid ground will end a waterjump
+	if (pm->ps->pm_flags & PMF_TIME_WATERJUMP)
+	{
+		pm->ps->pm_flags &= ~(PMF_TIME_WATERJUMP | PMF_TIME_LAND);
+		pm->ps->pm_time = 0;
+	}
+
+	if ( pm->ps->groundEntityNum == ENTITYNUM_NONE ) {
+		// just hit the ground
+		if ( pm->debugLevel ) {
+			Com_Printf("%i:Land\n", c_pmove);
+		}
+		
+		//if ( !PM_ClientImpact( trace.entityNum, qtrue ) )
+		{
+			PM_CrashLand();
+
+			// don't do landing time if we were just going down a slope
+			if ( pml.previous_velocity[2] < -200 ) {
+				// don't allow another jump for a little while
+				pm->ps->pm_flags |= PMF_TIME_LAND;
+				pm->ps->pm_time = 250;
+			}
+			if (!pm->cmd.forwardmove && !pm->cmd.rightmove) {
+				if ( Flying != FLY_HOVER )
+				{
+					pm->ps->velocity[2] = 0;	//wouldn't normally want this because of slopes, but we aren't tyring to move...
+				}
+			}
+		}
+	}
+
+	pm->ps->groundEntityNum = trace.entityNum;
+	pm->ps->lastOnGround = level.time;
+	if ( (pm->ps->clientNum < MAX_CLIENTS||PM_ControlledByPlayer()) )
+	{//if a player, clear the jumping "flag" so can't double-jump
+		pm->ps->forceJumpCharge = 0;
+	}
+
+	// don't reset the z velocity for slopes
+//	pm->ps->velocity[2] = 0;
+
+	PM_AddTouchEnt( trace.entityNum );
+}
+
+int		LastMatrixJumpTime = 0;
+#define	DEBUGMATRIXJUMP		0
+
+void PM_HoverTrace( void )
+{
+	if ( !pm->gent || !pm->gent->client || pm->gent->client->NPC_class != CLASS_VEHICLE )
+	{
+		return;
+	}
+
+	Vehicle_t *pVeh = pm->gent->m_pVehicle;
+	float hoverHeight = pVeh->m_pVehicleInfo->hoverHeight;
+	vec3_t		point, vAng, fxAxis[3];
+	trace_t		*trace = &pml.groundTrace;
+	int			traceContents = pm->tracemask;
+
+	pml.groundPlane = qfalse;
+
+	float relativeWaterLevel = (pm->ps->waterheight - (pm->ps->origin[2]+pm->mins[2]));
+	if ( pm->waterlevel && relativeWaterLevel >= 0 )
+	{//in water
+		if ( pVeh->m_pVehicleInfo->bouyancy <= 0.0f )
+		{//sink like a rock
+		}
+		else
+		{//rise up
+			float floatHeight = (pVeh->m_pVehicleInfo->bouyancy * ((pm->maxs[2]-pm->mins[2])*0.5f)) - (hoverHeight*0.5f);//1.0f should make you float half-in, half-out of water
+			if ( relativeWaterLevel > floatHeight )
+			{//too low, should rise up
+				pm->ps->velocity[2] += (relativeWaterLevel - floatHeight) * pVeh->m_fTimeModifier;
+			}
+		}
+		if ( pm->ps->waterheight < pm->ps->origin[2]+pm->maxs[2] )
+		{//part of us is sticking out of water
+			if ( fabs(pm->ps->velocity[0]) + fabs(pm->ps->velocity[1]) > 100 )
+			{//moving at a decent speed
+				if ( Q_irand( pml.frametime, 100 ) >= 50 )
+				{//splash
+					vAng[PITCH] = vAng[ROLL] = 0;
+					vAng[YAW] = pVeh->m_vOrientation[YAW];
+					AngleVectors( vAng, fxAxis[2], fxAxis[1], fxAxis[0] );
+					vec3_t wakeOrg;
+					VectorCopy( pm->ps->origin, wakeOrg );
+					wakeOrg[2] = pm->ps->waterheight;
+					if ( pVeh->m_pVehicleInfo->iWakeFX )
+					{
+						G_PlayEffect( pVeh->m_pVehicleInfo->iWakeFX, wakeOrg, fxAxis );
+					}
+				}
+			}
+			pml.groundPlane = qtrue;
+		}
+	}
+	else
+	{
+		float minNormal = (float)MIN_WALK_NORMAL;
+		minNormal = pVeh->m_pVehicleInfo->maxSlope;
+
+		point[0] = pm->ps->origin[0];
+		point[1] = pm->ps->origin[1];
+		point[2] = pm->ps->origin[2] - (hoverHeight*3.0f);
+
+		//FIXME: check for water, too?  If over water, go slower and make wave effect
+		//		If *in* water, go really slow and use bouyancy stat to determine how far below surface to float
+
+		//NOTE: if bouyancy is 2.0f or higher, you float over water like it's solid ground.
+		//		if it's 1.0f, you sink halfway into water.  If it's 0, you sink...
+		if ( pVeh->m_pVehicleInfo->bouyancy >= 2.0f )
+		{//sit on water
+			traceContents |= (CONTENTS_WATER|CONTENTS_SLIME|CONTENTS_LAVA);
+		}
+ 		pm->trace( trace, pm->ps->origin, pm->mins, pm->maxs, point, pm->ps->clientNum, traceContents );
+		if ( trace->plane.normal[2] >= minNormal ) 
+		{//not a steep slope, so push us up
+			if ( trace->fraction < 0.3f )
+			{//push up off ground
+	 			float hoverForce = pVeh->m_pVehicleInfo->hoverStrength;
+				pm->ps->velocity[2] += (0.3f-trace->fraction)*hoverForce*pVeh->m_fTimeModifier;
+
+			//	if (pm->ps->velocity[2]>60.0f)
+			//	{
+			//		pm->ps->velocity[2] = 60.0f;
+			//	}
+
+				if ( (trace->contents&(CONTENTS_WATER|CONTENTS_SLIME|CONTENTS_LAVA)) )
+				{//hovering on water, make a spash if moving
+					if ( fabs(pm->ps->velocity[0]) + fabs(pm->ps->velocity[1]) > 100 )
+					{//moving at a decent speed
+						if ( Q_irand( pml.frametime, 100 ) >= 50 )
+						{//splash
+							vAng[PITCH] = vAng[ROLL] = 0;
+							vAng[YAW] = pVeh->m_vOrientation[YAW];
+							AngleVectors( vAng, fxAxis[2], fxAxis[1], fxAxis[0] );
+							if ( pVeh->m_pVehicleInfo->iWakeFX )
+							{
+								G_PlayEffect( pVeh->m_pVehicleInfo->iWakeFX, trace->endpos, fxAxis );
+							}
+						}
+					}
+				}
+				
+				if (pVeh->m_ulFlags & VEH_SLIDEBREAKING)
+				{
+  				 	if ( Q_irand( pml.frametime, 100 ) >= 50 )
+					{//dust
+						VectorClear(fxAxis[0]);
+					 	fxAxis[0][2] = 1;
+
+						VectorCopy(pm->ps->velocity, fxAxis[1]);
+ 						fxAxis[1][2] *= 0.01f;
+						VectorMA(pm->ps->origin, 0.25f, fxAxis[1], point);
+						G_PlayEffect("ships/swoop_dust", point, fxAxis[0]);
+					}
+				}
+				pml.groundPlane = qtrue;
+			}
+		}
+	}
+	if ( pml.groundPlane )
+	{
+ 		PM_SetVehicleAngles( pml.groundTrace.plane.normal );
+		// We're on the ground.
+//		if (pVeh->m_ulFlags&VEH_FLYING && level.time<pVeh->m_iTurboTime)
+//		{
+//			pVeh->m_iTurboTime = 0;	// stop turbo
+//		}
+		pVeh->m_ulFlags &= ~VEH_FLYING;
+		pVeh->m_vAngularVelocity = 0.0f;
+	}
+	else
+	{
+		PM_SetVehicleAngles( NULL );
+		// We're flying in the air.
+		pVeh->m_ulFlags |= VEH_FLYING;
+		//groundTrace
+
+		if (pVeh->m_vAngularVelocity==0.0f)
+		{
+			pVeh->m_vAngularVelocity = pVeh->m_vOrientation[YAW] - pVeh->m_vPrevOrientation[YAW];
+			if (pVeh->m_vAngularVelocity<-15.0f)
+			{
+				pVeh->m_vAngularVelocity = -15.0f;
+			}
+			if (pVeh->m_vAngularVelocity> 15.0f)
+			{
+				pVeh->m_vAngularVelocity =  15.0f;
+			}
+
+			// BEGIN MATRIX MODE INIT FOR JUMP
+			//=================================
+  			if (pm->gent && 
+				pm->gent->owner && 
+				(pm->gent->owner->s.number<MAX_CLIENTS||G_ControlledByPlayer(pm->gent->owner)) && 
+				pVeh->m_pVehicleInfo->type==VH_SPEEDER &&
+				level.time>(LastMatrixJumpTime+5000) && VectorLength(pm->ps->velocity)>30.0f)
+			{
+ 				LastMatrixJumpTime = level.time;
+	 			vec3_t	predictedApx;
+				vec3_t	predictedFallVelocity;
+				vec3_t	predictedLandPosition;
+
+ 				VectorScale(pm->ps->velocity, 2.0f, predictedFallVelocity);					// take friction into account
+	 			predictedFallVelocity[2] = -(pm->ps->gravity * 1.1f);	// take gravity into account
+
+				VectorMA(pm->ps->origin,	0.25f, pm->ps->velocity,			predictedApx);
+				VectorMA(predictedApx,		0.25f, predictedFallVelocity,	predictedLandPosition);
+
+
+
+
+				trace_t trace2;
+ 				gi.trace( &trace2, predictedApx, pm->mins, pm->maxs, predictedLandPosition, pm->ps->clientNum, traceContents);
+ 				if (!trace2.startsolid && !trace2.allsolid && trace2.fraction>0.75 && Q_irand(0, 3)==0)
+				{
+					LastMatrixJumpTime += 20000;
+ 				 	G_StartMatrixEffect(pm->gent, MEF_HIT_GROUND_STOP);
+//					CG_DrawEdge(pm->ps->origin, predictedApx,			EDGE_WHITE_TWOSECOND);
+//					CG_DrawEdge(predictedApx, predictedLandPosition,	EDGE_WHITE_TWOSECOND);
+				}
+//				else
+//				{
+//					CG_DrawEdge(pm->ps->origin, predictedApx,			EDGE_RED_TWOSECOND);
+//					CG_DrawEdge(predictedApx, predictedLandPosition,	EDGE_RED_TWOSECOND);
+//				}
+			}
+			//=================================
+		}
+		pVeh->m_vAngularVelocity *= 0.95f;		// Angular Velocity Decays Over Time
+	}
+	PM_GroundTraceMissed();
+}
+
+#ifdef _XBOX
+
+short	npcsToUpdate[MAX_NPC_WATER_UPDATE];		// queue of npcs
+short	npcsToUpdateTop = 0;					// top of the queue
+short	npcsToUpdateCount = 0;					// number of npcs in the queue
+
+
+/*
+=============
+PM_SetWaterLevelAtPoint2
+Xbox version does not depend on a pmove structure
+This function is used to update AI waterlevels every few
+frames.
+=============
+*/
+static void PM_SetWaterLevelAtPoint2( vec3_t org, int *waterlevel, int *watertype, int clientNum, int viewHeight ) 
+{
+	vec3_t		point;
+	int			cont;
+	int			sample1;
+	int			sample2;
+
+	// use the server fucntion directly, we don't have a pmove ptr to work with right now
+	extern int SV_PointContents( const vec3_t p, int passEntityNum );
+
+	//
+	// get waterlevel, accounting for ducking
+	//
+	*waterlevel = 0;
+	*watertype = 0;
+
+	point[0] = org[0];
+	point[1] = org[1];
+	point[2] = org[2] + DEFAULT_MINS_2 + 1;	
+	cont = SV_PointContents( point, clientNum );
+
+	if ( cont & (MASK_WATER|CONTENTS_LADDER) ) 
+	{
+		sample2 = viewHeight - DEFAULT_MINS_2;
+		sample1 = sample2 / 2;
+
+		*watertype = cont;
+		*waterlevel = 1;
+		point[2] = org[2] + DEFAULT_MINS_2 + sample1;
+		cont = SV_PointContents( point, clientNum );
+		if ( cont & (MASK_WATER|CONTENTS_LADDER) ) 
+		{
+			*waterlevel = 2;
+			point[2] = org[2] + DEFAULT_MINS_2 + sample2;
+			cont = SV_PointContents( point, clientNum );
+			if ( cont & (MASK_WATER|CONTENTS_LADDER) )
+			{
+				*waterlevel = 3;
+			}
+		}
+	}
+}
+
+/*
+=============
+AddNPCToWaterUpdate
+This function adds an AI to the water level update queue
+=============
+*/
+static void AddNPCToWaterUpdate(int num)
+{
+	// get an entity pointer
+	gentity_t *ent = g_entities + num;
+
+	// only add this client if it isn't already queued
+	if(ent->wupdate == 0)
+	{
+		// check to make sure we don't have too many NPCs in the queue
+		if((npcsToUpdateCount + 1) < MAX_NPC_WATER_UPDATE)
+		{
+			// figure out where to place this npc in the queue
+			int spot = npcsToUpdateTop + npcsToUpdateCount;
+
+			if(spot < MAX_NPC_WATER_UPDATE)
+			{
+				npcsToUpdate[spot] = num;
+			}
+			else
+			{
+				npcsToUpdate[spot - MAX_NPC_WATER_UPDATE] = num;
+			}
+
+			// set the water update flag
+			ent->wupdate = 1;
+
+			// update the queue count
+			npcsToUpdateCount++;
+		}
+		else
+		{
+			// the queue isn't big enough
+			assert(0);
+		}
+	}
+}
+
+/*
+=============
+UpdateNPCWaterLevels
+This function updates the water level for MAX_NPC_WATER_UPDATES_PER_FRAME NPCs
+=============
+*/
+void UpdateNPCWaterLevels(void)
+{
+	int i;
+	gentity_t *ent;
+
+	// update the maxium number per frame
+	for(i = 0; i < MAX_NPC_WATER_UPDATES_PER_FRAME; i++)
+	{
+		// make sure we have something to update
+		if(npcsToUpdateCount)
+		{
+			// if the clientnum is -1, we've got some serious problems
+			assert(npcsToUpdate[npcsToUpdateTop] != -1);
+
+			// get an enitiy pointer
+			ent	= g_entities + npcsToUpdate[npcsToUpdateTop];
+
+			// make sure this client isn't in Jedi heaven
+			if(ent->client)
+			{
+				// set the previous water level... this is used later to update the water state
+				ent->prev_waterlevel = ent->waterlevel;
+				// get our new state
+				PM_SetWaterLevelAtPoint2( ent->currentOrigin, &ent->waterlevel, &ent->watertype, npcsToUpdate[npcsToUpdateTop], ent->client->ps.viewheight );
+				// flag this client as updated
+				ent->wupdate = 0;
+			}
+
+			// clear this client from the queue
+			npcsToUpdate[npcsToUpdateTop] = -1;
+			// move our queue ptr and decr our count
+			npcsToUpdateTop++;
+			npcsToUpdateCount--;
+
+			// if the top is pointing to the end wrap it around the the start
+			if(npcsToUpdateTop == MAX_NPC_WATER_UPDATE)
+			{
+				npcsToUpdateTop = 0;
+			}
+		}
+	}
+}
+
+#endif // _XBOX
+
+/*
+=============
+PM_SetWaterLevelAtPoint	FIXME: avoid this twice?  certainly if not moving
+=============
+*/
+static void PM_SetWaterLevelAtPoint( vec3_t org, int *waterlevel, int *watertype ) 
+{
+	vec3_t		point;
+	int			cont;
+	int			sample1;
+	int			sample2;
+
+	//
+	// get waterlevel, accounting for ducking
+	//
+	*waterlevel = 0;
+	*watertype = 0;
+
+	point[0] = org[0];
+	point[1] = org[1];
+	point[2] = org[2] + DEFAULT_MINS_2 + 1;	
+	if (gi.totalMapContents() & (MASK_WATER|CONTENTS_LADDER))
+	{
+		cont = pm->pointcontents( point, pm->ps->clientNum );
+
+		if ( cont & (MASK_WATER|CONTENTS_LADDER) ) 
+		{
+			sample2 = pm->ps->viewheight - DEFAULT_MINS_2;
+			sample1 = sample2 / 2;
+
+			*watertype = cont;
+			*waterlevel = 1;
+			point[2] = org[2] + DEFAULT_MINS_2 + sample1;
+			cont = pm->pointcontents( point, pm->ps->clientNum );
+			if ( cont & (MASK_WATER|CONTENTS_LADDER) ) 
+			{
+				*waterlevel = 2;
+				point[2] = org[2] + DEFAULT_MINS_2 + sample2;
+				cont = pm->pointcontents( point, pm->ps->clientNum );
+				if ( cont & (MASK_WATER|CONTENTS_LADDER) )
+				{
+					*waterlevel = 3;
+				}
+			}
+		}
+	}
+}
+
+void PM_SetWaterHeight( void )
+{
+	pm->ps->waterHeightLevel = WHL_NONE;
+	if ( pm->waterlevel < 1 )
+	{
+		pm->ps->waterheight = pm->ps->origin[2] + DEFAULT_MINS_2 - 4;
+		return;
+	}
+	trace_t trace;
+	vec3_t	top, bottom;
+
+	VectorCopy( pm->ps->origin, top );
+	VectorCopy( pm->ps->origin, bottom );
+	top[2] += pm->gent->client->standheight;
+	bottom[2] += DEFAULT_MINS_2;
+
+	gi.trace( &trace, top, pm->mins, pm->maxs, bottom, pm->ps->clientNum, MASK_WATER );
+
+	if ( trace.startsolid )
+	{//under water
+		pm->ps->waterheight = top[2] + 4;
+	}
+	else if ( trace.fraction < 1.0f )
+	{//partially in and partially out of water
+		pm->ps->waterheight = trace.endpos[2]+pm->mins[2];
+	}
+	else if ( trace.contents&MASK_WATER )
+	{//water is above me
+		pm->ps->waterheight = top[2] + 4;
+	}
+	else
+	{//water is below me
+		pm->ps->waterheight = bottom[2] - 4;
+	}
+	float distFromEyes = (pm->ps->origin[2]+pm->gent->client->standheight)-pm->ps->waterheight;
+
+	if ( distFromEyes < 0 )
+	{
+		pm->ps->waterHeightLevel = WHL_UNDER;
+	}
+	else if ( distFromEyes < 6 )
+	{
+		pm->ps->waterHeightLevel = WHL_HEAD;
+	}
+	else if ( distFromEyes < 18 )
+	{
+		pm->ps->waterHeightLevel = WHL_SHOULDERS;
+	}
+	else if ( distFromEyes < pm->gent->client->standheight-8 )
+	{//at least 8 above origin
+		pm->ps->waterHeightLevel = WHL_TORSO;
+	}
+	else 
+	{
+		float distFromOrg = pm->ps->origin[2]-pm->ps->waterheight;
+		if ( distFromOrg < 6 )
+		{
+			pm->ps->waterHeightLevel = WHL_WAIST;
+		}
+		else if ( distFromOrg < 16 )
+		{
+			pm->ps->waterHeightLevel = WHL_KNEES;
+		}
+		else if ( distFromOrg > fabs(pm->mins[2]) )
+		{
+			pm->ps->waterHeightLevel = WHL_NONE;
+		}
+		else 
+		{
+			pm->ps->waterHeightLevel = WHL_ANKLES;
+		}
+	}
+}
+
+
+/*
+==============
+PM_SetBounds
+
+Sets mins, maxs
+==============
+*/
+static void PM_SetBounds (void)
+{
+	if ( pm->gent && pm->gent->client )
+	{
+		if ( !pm->gent->mins[0] || !pm->gent->mins[1] || !pm->gent->mins[2] || !pm->gent->maxs[0] || !pm->gent->maxs[1] || !pm->gent->maxs[2] )
+		{
+			//assert(0);
+		}
+
+		VectorCopy( pm->gent->mins, pm->mins );
+		VectorCopy( pm->gent->maxs, pm->maxs );
+	}
+	else
+	{
+		if ( !DEFAULT_MINS_0 || !DEFAULT_MINS_1 || !DEFAULT_MAXS_0 || !DEFAULT_MAXS_1 || !DEFAULT_MINS_2 || !DEFAULT_MAXS_2 )
+		{
+			assert(0);
+		}
+
+		pm->mins[0] = DEFAULT_MINS_0;
+		pm->mins[1] = DEFAULT_MINS_1;
+
+		pm->maxs[0] = DEFAULT_MAXS_0;
+		pm->maxs[1] = DEFAULT_MAXS_1;
+
+		pm->mins[2] = DEFAULT_MINS_2;
+		pm->maxs[2] = DEFAULT_MAXS_2;
+	}
+}
+
+/*
+==============
+PM_CheckDuck
+
+Sets mins, maxs, and pm->ps->viewheight
+==============
+*/
+static void PM_CheckDuck (void)
+{
+	trace_t	trace;
+	int		standheight;
+	int		crouchheight;
+	int		oldHeight;
+
+	if ( pm->gent && pm->gent->client )
+	{
+		if ( !pm->gent->mins[0] || !pm->gent->mins[1] || !pm->gent->mins[2] || !pm->gent->maxs[0] || !pm->gent->maxs[1] || !pm->gent->maxs[2] )
+		{
+			//assert(0);
+		}
+
+		if ( pm->ps->clientNum < MAX_CLIENTS 
+			&& (pm->gent->client->NPC_class == CLASS_ATST ||pm->gent->client->NPC_class == CLASS_RANCOR)
+			&& !cg.renderingThirdPerson )
+		{
+			standheight = crouchheight = 128;
+		}
+		else
+		{
+			standheight = pm->gent->client->standheight;
+			crouchheight = pm->gent->client->crouchheight;
+		}
+	}
+	else
+	{
+		if ( !DEFAULT_MINS_0 || !DEFAULT_MINS_1 || !DEFAULT_MAXS_0 || !DEFAULT_MAXS_1 || !DEFAULT_MINS_2 || !DEFAULT_MAXS_2 )
+		{
+			assert(0);
+		}
+
+		standheight = DEFAULT_MAXS_2;
+		crouchheight = CROUCH_MAXS_2;
+	}
+
+	if ( PM_RidingVehicle() || (pm->gent && pm->gent->client && pm->gent->client->NPC_class == CLASS_VEHICLE) )
+	{//riding a vehicle or are a vehicle
+		//no ducking or rolling when on a vehicle
+		//right?  not even on ones that you just ride on top of?
+		pm->ps->pm_flags &= ~PMF_DUCKED;
+		pm->maxs[2] = standheight;
+		//FIXME: have a crouchviewheight and standviewheight on ent?
+		pm->ps->viewheight = standheight + STANDARD_VIEWHEIGHT_OFFSET;//DEFAULT_VIEWHEIGHT;
+		//NOTE: we don't clear the pm->cmd.upmove here because 
+		//the vehicle code may need it later... but, for riders,
+		//it should have already been copied over to the vehicle, right?
+		return;
+	}
+
+	if ( PM_InGetUp( pm->ps ) )
+	{//can't do any kind of crouching when getting up
+		if ( pm->ps->legsAnim == BOTH_GETUP_CROUCH_B1 || pm->ps->legsAnim == BOTH_GETUP_CROUCH_F1 )
+		{//crouched still
+			pm->ps->pm_flags |= PMF_DUCKED;
+			pm->maxs[2] = crouchheight;
+		}
+		pm->ps->viewheight = crouchheight + STANDARD_VIEWHEIGHT_OFFSET;
+		return;
+	}
+
+	oldHeight = pm->maxs[2];
+
+	if ( PM_InRoll( pm->ps ) )
+	{
+		/*
+		if ( pm->ps->clientNum && pm->gent && pm->gent->client )
+		{
+			pm->maxs[2] = pm->gent->client->renderInfo.eyePoint[2]-pm->ps->origin[2] + 4;
+			if ( crouchheight > pm->maxs[2] )
+			{
+				pm->maxs[2] = crouchheight;
+			}
+		}
+		else
+		*/
+		{
+			pm->maxs[2] = crouchheight;
+		}
+		pm->ps->viewheight = crouchheight + STANDARD_VIEWHEIGHT_OFFSET;
+		pm->ps->pm_flags |= PMF_DUCKED;
+		return;
+	}
+	if ( PM_GettingUpFromKnockDown( standheight, crouchheight ) )
+	{
+		pm->ps->viewheight = crouchheight + STANDARD_VIEWHEIGHT_OFFSET;
+		return;
+	}
+	if ( PM_InKnockDown( pm->ps ) )
+	{//forced crouch
+		if ( pm->gent && pm->gent->client )
+		{//interrupted any potential delayed weapon fires
+			pm->gent->client->fireDelay = 0;
+		}
+		pm->maxs[2] = crouchheight;
+		pm->ps->viewheight = crouchheight + STANDARD_VIEWHEIGHT_OFFSET;
+		pm->ps->pm_flags |= PMF_DUCKED;
+		return;
+	}
+	if ( pm->cmd.upmove < 0 )
+	{	// trying to duck
+		pm->maxs[2] = crouchheight;
+		pm->ps->viewheight = crouchheight + STANDARD_VIEWHEIGHT_OFFSET;//CROUCH_VIEWHEIGHT;
+		if ( pm->ps->groundEntityNum == ENTITYNUM_NONE && !PM_SwimmingAnim( pm->ps->legsAnim ) )
+		{//Not ducked already and trying to duck in mid-air
+			//will raise your feet, unducking whilst in air will drop feet
+			if ( !(pm->ps->pm_flags&PMF_DUCKED) )
+			{
+				pm->ps->eFlags ^= EF_TELEPORT_BIT;
+			}
+			if ( pm->gent )
+			{
+				pm->ps->origin[2] += oldHeight - pm->maxs[2];//diff will be zero if were already ducking
+				//Don't worry, we know we fit in a smaller size
+			}
+		}
+		pm->ps->pm_flags |= PMF_DUCKED;
+		if ( d_JediAI->integer )
+		{
+			if ( pm->ps->clientNum && pm->ps->weapon == WP_SABER )
+			{
+				Com_Printf( "ducking\n" );
+			}
+		}
+	}
+	else
+	{	// want to stop ducking, stand up if possible
+		if ( pm->ps->pm_flags & PMF_DUCKED )
+		{//Was ducking
+			if ( pm->ps->groundEntityNum == ENTITYNUM_NONE )
+			{//unducking whilst in air will try to drop feet
+				pm->maxs[2] = standheight;
+				pm->ps->origin[2] += oldHeight - pm->maxs[2];
+				pm->trace (&trace, pm->ps->origin, pm->mins, pm->maxs, pm->ps->origin, pm->ps->clientNum, pm->tracemask );
+				if ( !trace.allsolid )
+				{
+					pm->ps->eFlags ^= EF_TELEPORT_BIT;
+					pm->ps->pm_flags &= ~PMF_DUCKED;
+				}
+				else
+				{//Put us back
+					pm->ps->origin[2] -= oldHeight - pm->maxs[2];
+				}
+				//NOTE: this isn't the best way to check this, you may have room to unduck
+				//while in air, but your feet are close to landing.  Probably won't be a
+				//noticable shortcoming
+			}
+			else
+			{
+				// try to stand up
+				pm->maxs[2] = standheight;
+				pm->trace( &trace, pm->ps->origin, pm->mins, pm->maxs, pm->ps->origin, pm->ps->clientNum, pm->tracemask );
+				if ( !trace.allsolid )
+				{
+					pm->ps->pm_flags &= ~PMF_DUCKED;
+				}
+			}
+		}
+
+		if ( pm->ps->pm_flags & PMF_DUCKED )
+		{//Still ducking
+			pm->maxs[2] = crouchheight;
+			pm->ps->viewheight = crouchheight + STANDARD_VIEWHEIGHT_OFFSET;//CROUCH_VIEWHEIGHT;
+		}
+		else
+		{//standing now
+			pm->maxs[2] = standheight;
+			//FIXME: have a crouchviewheight and standviewheight on ent?
+			pm->ps->viewheight = standheight + STANDARD_VIEWHEIGHT_OFFSET;//DEFAULT_VIEWHEIGHT;
+		}
+	}
+}
+
+
+
+//===================================================================
+qboolean PM_SaberLockAnim( int anim )
+{
+	switch ( anim )
+	{
+	case BOTH_BF2LOCK:	//#
+	case BOTH_BF1LOCK:	//#
+	case BOTH_CWCIRCLELOCK:	//#
+	case BOTH_CCWCIRCLELOCK:	//#
+		return qtrue;
+	}
+	return qfalse;
+}
+
+qboolean PM_ForceAnim( int anim )
+{
+	switch ( anim )
+	{
+	case BOTH_CHOKE1:			//being choked...???
+	case BOTH_GESTURE1:			//taunting...
+	case BOTH_RESISTPUSH:		//# plant yourself to resist force push/pulls.
+	case BOTH_FORCEPUSH:		//# Use off-hand to do force power.
+	case BOTH_FORCEPULL:		//# Use off-hand to do force power.
+	case BOTH_MINDTRICK1:		//# Use off-hand to do mind trick
+	case BOTH_MINDTRICK2:		//# Use off-hand to do distraction
+	case BOTH_FORCELIGHTNING:	//# Use off-hand to do lightning
+	case BOTH_FORCELIGHTNING_START:
+	case BOTH_FORCELIGHTNING_HOLD:	//# Use off-hand to do lightning
+	case BOTH_FORCELIGHTNING_RELEASE:	//# Use off-hand to do lightning
+	case BOTH_FORCEHEAL_START:	//# Healing meditation pose start
+	case BOTH_FORCEHEAL_STOP:	//# Healing meditation pose end
+	case BOTH_FORCEHEAL_QUICK:	//# Healing meditation gesture
+	case BOTH_FORCEGRIP1:		//# temp force-grip anim (actually re-using push)
+	case BOTH_FORCEGRIP_HOLD:		//# temp force-grip anim (actually re-using push)
+	case BOTH_FORCEGRIP_RELEASE:		//# temp force-grip anim (actually re-using push)
+	//case BOTH_FORCEGRIP3:		//# force-gripping
+	case BOTH_FORCE_RAGE:
+	case BOTH_FORCE_2HANDEDLIGHTNING:
+	case BOTH_FORCE_2HANDEDLIGHTNING_START:
+	case BOTH_FORCE_2HANDEDLIGHTNING_HOLD:
+	case BOTH_FORCE_2HANDEDLIGHTNING_RELEASE:
+	case BOTH_FORCE_DRAIN:
+	case BOTH_FORCE_DRAIN_START:
+	case BOTH_FORCE_DRAIN_HOLD:
+	case BOTH_FORCE_DRAIN_RELEASE:
+	case BOTH_FORCE_ABSORB:
+	case BOTH_FORCE_ABSORB_START:
+	case BOTH_FORCE_ABSORB_END:
+	case BOTH_FORCE_PROTECT:
+	case BOTH_FORCE_PROTECT_FAST:
+		return qtrue;
+		break;
+	}
+	return qfalse;
+}
+
+qboolean PM_InSaberAnim( int anim )
+{
+	if ( anim >= BOTH_A1_T__B_ && anim <= BOTH_H1_S1_BR )
+	{
+		return qtrue;
+	}
+	return qfalse;
+}
+
+qboolean PM_InForceGetUp( playerState_t *ps )
+{
+	switch ( ps->legsAnim )
+	{
+	case BOTH_FORCE_GETUP_F1:
+	case BOTH_FORCE_GETUP_F2:
+	case BOTH_FORCE_GETUP_B1:
+	case BOTH_FORCE_GETUP_B2:
+	case BOTH_FORCE_GETUP_B3:
+	case BOTH_FORCE_GETUP_B4:
+	case BOTH_FORCE_GETUP_B5:
+	case BOTH_FORCE_GETUP_B6:
+	case BOTH_GETUP_BROLL_B:
+	case BOTH_GETUP_BROLL_F:
+	case BOTH_GETUP_BROLL_L:
+	case BOTH_GETUP_BROLL_R:
+	case BOTH_GETUP_FROLL_B:
+	case BOTH_GETUP_FROLL_F:
+	case BOTH_GETUP_FROLL_L:
+	case BOTH_GETUP_FROLL_R:
+		if ( ps->legsAnimTimer )
+		{
+			return qtrue;
+		}
+		break;
+	}
+	return qfalse;
+}
+
+qboolean PM_InGetUp( playerState_t *ps )
+{
+	switch ( ps->legsAnim )
+	{
+	case BOTH_GETUP1:
+	case BOTH_GETUP2:
+	case BOTH_GETUP3:
+	case BOTH_GETUP4:
+	case BOTH_GETUP5:
+	case BOTH_GETUP_CROUCH_F1:
+	case BOTH_GETUP_CROUCH_B1:
+	case BOTH_GETUP_BROLL_B:
+	case BOTH_GETUP_BROLL_F:
+	case BOTH_GETUP_BROLL_L:
+	case BOTH_GETUP_BROLL_R:
+	case BOTH_GETUP_FROLL_B:
+	case BOTH_GETUP_FROLL_F:
+	case BOTH_GETUP_FROLL_L:
+	case BOTH_GETUP_FROLL_R:
+		if ( ps->legsAnimTimer )
+		{
+			return qtrue;
+		}
+		break;
+	default:
+		return PM_InForceGetUp( ps );
+		break;
+	}
+	//what the hell, redundant, but...
+	return qfalse;
+}
+
+qboolean PM_InGetUpNoRoll( playerState_t *ps )
+{
+	switch ( ps->legsAnim )
+	{
+	case BOTH_GETUP1:
+	case BOTH_GETUP2:
+	case BOTH_GETUP3:
+	case BOTH_GETUP4:
+	case BOTH_GETUP5:
+	case BOTH_GETUP_CROUCH_F1:
+	case BOTH_GETUP_CROUCH_B1:
+	case BOTH_FORCE_GETUP_F1:
+	case BOTH_FORCE_GETUP_F2:
+	case BOTH_FORCE_GETUP_B1:
+	case BOTH_FORCE_GETUP_B2:
+	case BOTH_FORCE_GETUP_B3:
+	case BOTH_FORCE_GETUP_B4:
+	case BOTH_FORCE_GETUP_B5:
+	case BOTH_FORCE_GETUP_B6:
+		if ( ps->legsAnimTimer )
+		{
+			return qtrue;
+		}
+		break;
+	}
+	return qfalse;
+}
+
+qboolean PM_InKnockDown( playerState_t *ps )
+{
+	switch ( ps->legsAnim )
+	{
+	case BOTH_KNOCKDOWN1:
+	case BOTH_KNOCKDOWN2:
+	case BOTH_KNOCKDOWN3:
+	case BOTH_KNOCKDOWN4:
+	case BOTH_KNOCKDOWN5:
+	//special anims:
+	case BOTH_RELEASED:
+		return qtrue;
+		break;
+	case BOTH_LK_DL_ST_T_SB_1_L:
+		if ( ps->legsAnimTimer < 550 )
+		{
+			return qtrue;
+		}
+		break;
+	case BOTH_PLAYER_PA_3_FLY:
+		if ( ps->legsAnimTimer < 300 )
+		{
+			return qtrue;
+		}
+		/*
+		else if ( ps->clientNum < MAX_CLIENTS 
+			&& ps->legsAnimTimer < 300 + PLAYER_KNOCKDOWN_HOLD_EXTRA_TIME )
+		{
+			return qtrue;
+		}
+		*/
+		break;
+	default:
+		return PM_InGetUp( ps );
+		break;
+	}
+	return qfalse;
+}
+
+qboolean PM_InKnockDownNoGetup( playerState_t *ps )
+{
+	switch ( ps->legsAnim )
+	{
+	case BOTH_KNOCKDOWN1:
+	case BOTH_KNOCKDOWN2:
+	case BOTH_KNOCKDOWN3:
+	case BOTH_KNOCKDOWN4:
+	case BOTH_KNOCKDOWN5:
+	//special anims:
+	case BOTH_RELEASED:
+		return qtrue;
+		break;
+	case BOTH_LK_DL_ST_T_SB_1_L:
+		if ( ps->legsAnimTimer < 550 )
+		{
+			return qtrue;
+		}
+		break;
+	case BOTH_PLAYER_PA_3_FLY:
+		if ( ps->legsAnimTimer < 300 )
+		{
+			return qtrue;
+		}
+		/*
+		else if ( ps->clientNum < MAX_CLIENTS 
+			&& ps->legsAnimTimer < 300 + PLAYER_KNOCKDOWN_HOLD_EXTRA_TIME )
+		{
+			return qtrue;
+		}
+		*/
+		break;
+	}
+	return qfalse;
+}
+
+qboolean PM_InKnockDownOnGround( playerState_t *ps )
+{
+	switch ( ps->legsAnim )
+	{
+	case BOTH_KNOCKDOWN1:
+	case BOTH_KNOCKDOWN2:
+	case BOTH_KNOCKDOWN3:
+	case BOTH_KNOCKDOWN4:
+	case BOTH_KNOCKDOWN5:
+	case BOTH_RELEASED:
+		//if ( PM_AnimLength( g_entities[ps->clientNum].client->clientInfo.animFileIndex, (animNumber_t)ps->legsAnim ) - ps->legsAnimTimer > 300 )
+		{//at end of fall down anim
+			return qtrue;
+		}
+		break;
+	case BOTH_GETUP1:
+	case BOTH_GETUP2:
+	case BOTH_GETUP3:
+	case BOTH_GETUP4:
+	case BOTH_GETUP5:
+	case BOTH_GETUP_CROUCH_F1:
+	case BOTH_GETUP_CROUCH_B1:
+	case BOTH_FORCE_GETUP_F1:
+	case BOTH_FORCE_GETUP_F2:
+	case BOTH_FORCE_GETUP_B1:
+	case BOTH_FORCE_GETUP_B2:
+	case BOTH_FORCE_GETUP_B3:
+	case BOTH_FORCE_GETUP_B4:
+	case BOTH_FORCE_GETUP_B5:
+	case BOTH_FORCE_GETUP_B6:
+		if ( PM_AnimLength( g_entities[ps->clientNum].client->clientInfo.animFileIndex, (animNumber_t)ps->legsAnim ) - ps->legsAnimTimer < 500 )
+		{//at beginning of getup anim
+			return qtrue;
+		}
+		break;
+	case BOTH_GETUP_BROLL_B:
+	case BOTH_GETUP_BROLL_F:
+	case BOTH_GETUP_BROLL_L:
+	case BOTH_GETUP_BROLL_R:
+	case BOTH_GETUP_FROLL_B:
+	case BOTH_GETUP_FROLL_F:
+	case BOTH_GETUP_FROLL_L:
+	case BOTH_GETUP_FROLL_R:
+		if ( PM_AnimLength( g_entities[ps->clientNum].client->clientInfo.animFileIndex, (animNumber_t)ps->legsAnim ) - ps->legsAnimTimer < 500 )
+		{//at beginning of getup anim
+			return qtrue;
+		}
+		break;
+	case BOTH_LK_DL_ST_T_SB_1_L:
+		if ( ps->legsAnimTimer < 1000 )
+		{
+			return qtrue;
+		}
+		break;
+	case BOTH_PLAYER_PA_3_FLY:
+		if ( ps->legsAnimTimer < 300 )
+		{
+			return qtrue;
+		}
+		/*
+		else if ( ps->clientNum < MAX_CLIENTS 
+			&& ps->legsAnimTimer < 300 + PLAYER_KNOCKDOWN_HOLD_EXTRA_TIME )
+		{
+			return qtrue;
+		}
+		*/
+		break;
+	}
+	return qfalse;
+}
+
+qboolean PM_CrouchGetup( float crouchheight )
+{
+	pm->maxs[2] = crouchheight;
+	pm->ps->viewheight = crouchheight + STANDARD_VIEWHEIGHT_OFFSET;
+	int	anim = -1;
+	switch ( pm->ps->legsAnim )
+	{
+	case BOTH_KNOCKDOWN1:
+	case BOTH_KNOCKDOWN2:
+	case BOTH_KNOCKDOWN4:
+	case BOTH_RELEASED:
+	case BOTH_PLAYER_PA_3_FLY:
+		anim = BOTH_GETUP_CROUCH_B1;
+		break;
+	case BOTH_KNOCKDOWN3:
+	case BOTH_KNOCKDOWN5:
+	case BOTH_LK_DL_ST_T_SB_1_L:
+		anim = BOTH_GETUP_CROUCH_F1;
+		break;
+	}
+	if ( anim == -1 )
+	{//WTF? stay down?
+		pm->ps->legsAnimTimer = 100;//hold this anim for another 10th of a second
+		return qfalse;
+	}
+	else
+	{//get up into crouch anim
+		if ( PM_LockedAnim( pm->ps->torsoAnim ) )
+		{//need to be able to override this anim
+			pm->ps->torsoAnimTimer = 0;
+		}
+		if ( PM_LockedAnim( pm->ps->legsAnim ) )
+		{//need to be able to override this anim
+			pm->ps->legsAnimTimer = 0;
+		}
+		PM_SetAnim( pm, SETANIM_BOTH, anim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD|SETANIM_FLAG_HOLDLESS );
+		pm->ps->saberMove = pm->ps->saberBounceMove = LS_READY;//don't finish whatever saber anim you may have been in
+		pm->ps->saberBlocked = BLOCKED_NONE;
+		return qtrue;
+	}
+}
+
+extern qboolean PM_GoingToAttackDown( playerState_t *ps );
+qboolean PM_CheckRollGetup( void )
+{
+	if ( pm->ps->legsAnim == BOTH_KNOCKDOWN1
+		|| pm->ps->legsAnim == BOTH_KNOCKDOWN2
+		|| pm->ps->legsAnim == BOTH_KNOCKDOWN3
+		|| pm->ps->legsAnim == BOTH_KNOCKDOWN4
+		|| pm->ps->legsAnim == BOTH_KNOCKDOWN5 
+		|| pm->ps->legsAnim == BOTH_LK_DL_ST_T_SB_1_L
+		|| pm->ps->legsAnim == BOTH_PLAYER_PA_3_FLY
+		|| pm->ps->legsAnim == BOTH_RELEASED )
+	{//lying on back or front
+		if ( ((pm->ps->clientNum < MAX_CLIENTS||PM_ControlledByPlayer()) && ( pm->cmd.rightmove || (pm->cmd.forwardmove&&pm->ps->forcePowerLevel[FP_LEVITATION] > FORCE_LEVEL_0) ) )//player pressing left or right
+			|| ( (pm->ps->clientNum >= MAX_CLIENTS&&!PM_ControlledByPlayer()) && pm->gent->NPC//an NPC
+				&& pm->ps->forcePowerLevel[FP_LEVITATION] > FORCE_LEVEL_0//have at least force jump 1
+				&& pm->gent->enemy //I have an enemy
+				&& pm->gent->enemy->client//a client
+				&& pm->gent->enemy->enemy == pm->gent//he's mad at me!
+				&& (PM_GoingToAttackDown( &pm->gent->enemy->client->ps )||!Q_irand(0,2))//he's attacking downward! (or we just feel like doing it this time)
+				&& ((pm->gent->client&&pm->gent->client->NPC_class==CLASS_ALORA)||Q_irand( 0, RANK_CAPTAIN )<pm->gent->NPC->rank) ) )//higher rank I am, more likely I am to roll away!
+		{//roll away!
+			int anim;
+			qboolean forceGetUp = qfalse;
+			if ( pm->cmd.forwardmove > 0 )
+			{
+				if ( pm->ps->legsAnim == BOTH_KNOCKDOWN3 
+					|| pm->ps->legsAnim == BOTH_KNOCKDOWN5 
+					|| pm->ps->legsAnim == BOTH_LK_DL_ST_T_SB_1_L )
+				{
+					anim = BOTH_GETUP_FROLL_F;
+				}
+				else
+				{
+					anim = BOTH_GETUP_BROLL_F;
+				}
+				forceGetUp = qtrue;
+			}
+			else if ( pm->cmd.forwardmove < 0 )
+			{
+				if ( pm->ps->legsAnim == BOTH_KNOCKDOWN3
+					|| pm->ps->legsAnim == BOTH_KNOCKDOWN5
+					|| pm->ps->legsAnim == BOTH_LK_DL_ST_T_SB_1_L )
+				{
+					anim = BOTH_GETUP_FROLL_B;
+				}
+				else
+				{
+					anim = BOTH_GETUP_BROLL_B;
+				}
+				forceGetUp = qtrue;
+			}
+			else if ( pm->cmd.rightmove > 0 )
+			{
+				if ( pm->ps->legsAnim == BOTH_KNOCKDOWN3 
+					|| pm->ps->legsAnim == BOTH_KNOCKDOWN5
+					|| pm->ps->legsAnim == BOTH_LK_DL_ST_T_SB_1_L )
+				{
+					anim = BOTH_GETUP_FROLL_R;
+				}
+				else
+				{
+					anim = BOTH_GETUP_BROLL_R;
+				}
+			}
+			else if ( pm->cmd.rightmove < 0 )
+			{
+				if ( pm->ps->legsAnim == BOTH_KNOCKDOWN3 
+					|| pm->ps->legsAnim == BOTH_KNOCKDOWN5
+					|| pm->ps->legsAnim == BOTH_LK_DL_ST_T_SB_1_L )
+				{
+					anim = BOTH_GETUP_FROLL_L;
+				}
+				else
+				{
+					anim = BOTH_GETUP_BROLL_L;
+				}
+			}
+			else
+			{
+				if ( pm->ps->legsAnim == BOTH_KNOCKDOWN3
+					|| pm->ps->legsAnim == BOTH_KNOCKDOWN5
+					|| pm->ps->legsAnim == BOTH_LK_DL_ST_T_SB_1_L )
+				{//on your front
+					anim = Q_irand( BOTH_GETUP_FROLL_B, BOTH_GETUP_FROLL_R );
+				}
+				else
+				{
+					anim = Q_irand( BOTH_GETUP_BROLL_B, BOTH_GETUP_BROLL_R );
+				}
+			}
+			if ( (pm->ps->clientNum >= MAX_CLIENTS&&!PM_ControlledByPlayer()) )
+			{
+				if ( !G_CheckRollSafety( pm->gent, anim, 64 ) )
+				{//oops, try other one
+					if ( pm->ps->legsAnim == BOTH_KNOCKDOWN3
+						|| pm->ps->legsAnim == BOTH_KNOCKDOWN5
+						|| pm->ps->legsAnim == BOTH_LK_DL_ST_T_SB_1_L )
+					{
+						if ( anim == BOTH_GETUP_FROLL_R )
+						{
+							anim = BOTH_GETUP_FROLL_L;
+						}
+						else if ( anim == BOTH_GETUP_FROLL_F )
+						{
+							anim = BOTH_GETUP_FROLL_B;
+						}
+						else if ( anim == BOTH_GETUP_FROLL_B )
+						{
+							anim = BOTH_GETUP_FROLL_F;
+						}
+						else
+						{
+							anim = BOTH_GETUP_FROLL_L;
+						}
+						if ( !G_CheckRollSafety( pm->gent, anim, 64 ) )
+						{//neither side is clear, screw it
+							return qfalse;
+						}
+					}
+					else
+					{
+						if ( anim == BOTH_GETUP_BROLL_R )
+						{
+							anim = BOTH_GETUP_BROLL_L;
+						}
+						else if ( anim == BOTH_GETUP_BROLL_F )
+						{
+							anim = BOTH_GETUP_BROLL_B;
+						}
+						else if ( anim == BOTH_GETUP_FROLL_B )
+						{
+							anim = BOTH_GETUP_BROLL_F;
+						}
+						else
+						{
+							anim = BOTH_GETUP_BROLL_L;
+						}
+						if ( !G_CheckRollSafety( pm->gent, anim, 64 ) )
+						{//neither side is clear, screw it
+							return qfalse;
+						}
+					}
+				}
+			}
+			pm->cmd.rightmove = pm->cmd.forwardmove = 0;
+			if ( PM_LockedAnim( pm->ps->torsoAnim ) )
+			{//need to be able to override this anim
+				pm->ps->torsoAnimTimer = 0;
+			}
+			if ( PM_LockedAnim( pm->ps->legsAnim ) )
+			{//need to be able to override this anim
+				pm->ps->legsAnimTimer = 0;
+			}
+			PM_SetAnim( pm, SETANIM_BOTH, anim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD|SETANIM_FLAG_HOLDLESS );
+			pm->ps->weaponTime = pm->ps->torsoAnimTimer - 300;//don't attack until near end of this anim
+			pm->ps->saberMove = pm->ps->saberBounceMove = LS_READY;//don't finish whatever saber anim you may have been in
+			pm->ps->saberBlocked = BLOCKED_NONE;
+			if ( forceGetUp )
+			{
+				if ( pm->gent && pm->gent->client && pm->gent->client->playerTeam == TEAM_ENEMY 
+					&& pm->gent->NPC && pm->gent->NPC->blockedSpeechDebounceTime < level.time
+					&& !Q_irand( 0, 1 ) )
+				{
+					PM_AddEvent( Q_irand( EV_COMBAT1, EV_COMBAT3 ) );
+					pm->gent->NPC->blockedSpeechDebounceTime = level.time + 1000;
+				}
+				G_SoundOnEnt( pm->gent, CHAN_BODY, "sound/weapons/force/jump.wav" );
+				//launch off ground?
+				pm->ps->weaponTime = 300;//just to make sure it's cleared
+			}
+			return qtrue;
+		}
+	}
+	return qfalse;
+}
+
+extern int G_MinGetUpTime( gentity_t *ent );
+qboolean PM_GettingUpFromKnockDown( float standheight, float crouchheight )
+{
+	int legsAnim = pm->ps->legsAnim;
+	if ( legsAnim == BOTH_KNOCKDOWN1
+		||legsAnim == BOTH_KNOCKDOWN2
+		||legsAnim == BOTH_KNOCKDOWN3 
+		||legsAnim == BOTH_KNOCKDOWN4
+		||legsAnim == BOTH_KNOCKDOWN5 
+		||legsAnim == BOTH_PLAYER_PA_3_FLY
+		||legsAnim == BOTH_LK_DL_ST_T_SB_1_L
+		||legsAnim == BOTH_RELEASED )
+	{//in a knockdown
+		int minTimeLeft = G_MinGetUpTime( pm->gent );
+		if ( pm->ps->legsAnimTimer <= minTimeLeft )
+		{//if only a quarter of a second left, allow roll-aways
+			if ( PM_CheckRollGetup() )
+			{
+				pm->cmd.rightmove = pm->cmd.forwardmove = 0;
+				return qtrue;
+			}
+		}
+		if ( TIMER_Exists( pm->gent, "noGetUpStraight" ) ) 
+		{
+			if ( !TIMER_Done2( pm->gent, "noGetUpStraight", qtrue ) )
+			{//not allowed to do straight get-ups for another few seconds
+				if ( pm->ps->legsAnimTimer <= minTimeLeft )
+				{//hold it for a bit
+					pm->ps->legsAnimTimer = minTimeLeft+1;
+				}
+			}
+		}
+		if ( !pm->ps->legsAnimTimer	|| (pm->ps->legsAnimTimer<=minTimeLeft&&(pm->cmd.upmove>0||(pm->gent&&pm->gent->client&&pm->gent->client->NPC_class==CLASS_ALORA))) )
+		{//done with the knockdown - FIXME: somehow this is allowing an *instant* getup...???
+			//FIXME: if trying to crouch (holding button?), just get up into a crouch?
+			if ( pm->cmd.upmove < 0 )
+			{
+				return PM_CrouchGetup( crouchheight );
+			}
+			else
+			{
+				trace_t	trace;
+				// try to stand up
+				pm->maxs[2] = standheight;
+				pm->trace( &trace, pm->ps->origin, pm->mins, pm->maxs, pm->ps->origin, pm->ps->clientNum, pm->tracemask );
+				if ( !trace.allsolid )
+				{//stand up
+					int	anim = BOTH_GETUP1;
+					qboolean forceGetUp = qfalse;
+					pm->maxs[2] = standheight;
+					pm->ps->viewheight = standheight + STANDARD_VIEWHEIGHT_OFFSET;
+					//NOTE: the force power checks will stop fencers and grunts from getting up using force jump
+					switch ( pm->ps->legsAnim )
+					{
+					case BOTH_KNOCKDOWN1:
+						if ( (pm->ps->clientNum&&pm->ps->forcePowerLevel[FP_LEVITATION] > FORCE_LEVEL_0) || ((pm->ps->clientNum < MAX_CLIENTS||PM_ControlledByPlayer())&&pm->cmd.upmove>0&&pm->ps->forcePowerLevel[FP_LEVITATION] > FORCE_LEVEL_0) )//FORCE_LEVEL_1) )FORCE_LEVEL_1) )
+						{
+							anim = Q_irand( BOTH_FORCE_GETUP_B1, BOTH_FORCE_GETUP_B6 );//NOTE: BOTH_FORCE_GETUP_B5 takes soe steps forward at end
+							forceGetUp = qtrue;
+						}
+						else
+						{
+							anim = BOTH_GETUP1;
+						}
+						break;
+					case BOTH_KNOCKDOWN2:
+					case BOTH_PLAYER_PA_3_FLY:
+						if ( (pm->ps->clientNum&&pm->ps->forcePowerLevel[FP_LEVITATION] > FORCE_LEVEL_0) || ((pm->ps->clientNum < MAX_CLIENTS||PM_ControlledByPlayer())&&pm->cmd.upmove>0&&pm->ps->forcePowerLevel[FP_LEVITATION] > FORCE_LEVEL_0) )//FORCE_LEVEL_1) )FORCE_LEVEL_1) )
+						{
+							anim = Q_irand( BOTH_FORCE_GETUP_B1, BOTH_FORCE_GETUP_B6 );//NOTE: BOTH_FORCE_GETUP_B5 takes soe steps forward at end
+							forceGetUp = qtrue;
+						}
+						else
+						{
+							anim = BOTH_GETUP2;
+						}
+						break;
+					case BOTH_KNOCKDOWN3:
+						if ( (pm->ps->clientNum&&pm->ps->forcePowerLevel[FP_LEVITATION] > FORCE_LEVEL_0) || ((pm->ps->clientNum < MAX_CLIENTS||PM_ControlledByPlayer())&&pm->cmd.upmove>0&&pm->ps->forcePowerLevel[FP_LEVITATION] > FORCE_LEVEL_0) )//FORCE_LEVEL_1) )
+						{
+							anim = Q_irand( BOTH_FORCE_GETUP_F1, BOTH_FORCE_GETUP_F2 );
+							forceGetUp = qtrue;
+						}
+						else
+						{
+							anim = BOTH_GETUP3;
+						}
+						break;
+					case BOTH_KNOCKDOWN4:
+					case BOTH_RELEASED:
+						if ( (pm->ps->clientNum&&pm->ps->forcePowerLevel[FP_LEVITATION] > FORCE_LEVEL_0) || ((pm->ps->clientNum < MAX_CLIENTS||PM_ControlledByPlayer())&&pm->cmd.upmove>0&&pm->ps->forcePowerLevel[FP_LEVITATION] > FORCE_LEVEL_0) )//FORCE_LEVEL_1) )FORCE_LEVEL_1) )
+						{
+							anim = Q_irand( BOTH_FORCE_GETUP_B1, BOTH_FORCE_GETUP_B6 );//NOTE: BOTH_FORCE_GETUP_B5 takes soe steps forward at end
+							forceGetUp = qtrue;
+						}
+						else
+						{
+							anim = BOTH_GETUP4;
+						}
+						break;
+					case BOTH_KNOCKDOWN5:
+					case BOTH_LK_DL_ST_T_SB_1_L:
+						if ( (pm->ps->clientNum&&pm->ps->forcePowerLevel[FP_LEVITATION] > FORCE_LEVEL_0) || ((pm->ps->clientNum < MAX_CLIENTS||PM_ControlledByPlayer())&&pm->cmd.upmove>0&&pm->ps->forcePowerLevel[FP_LEVITATION] > FORCE_LEVEL_0) )//FORCE_LEVEL_1) )FORCE_LEVEL_1) )
+						{
+							anim = Q_irand( BOTH_FORCE_GETUP_F1, BOTH_FORCE_GETUP_F2 );
+							forceGetUp = qtrue;
+						}
+						else
+						{
+							anim = BOTH_GETUP5;
+						}
+						break;
+					}
+					//Com_Printf( "getupanim = %s\n", animTable[anim].name );
+					if ( forceGetUp )
+					{
+						if ( pm->gent && pm->gent->client && pm->gent->client->playerTeam == TEAM_ENEMY 
+							&& pm->gent->NPC && pm->gent->NPC->blockedSpeechDebounceTime < level.time
+							&& !Q_irand( 0, 1 ) )
+						{
+							PM_AddEvent( Q_irand( EV_COMBAT1, EV_COMBAT3 ) );
+							pm->gent->NPC->blockedSpeechDebounceTime = level.time + 1000;
+						}
+						G_SoundOnEnt( pm->gent, CHAN_BODY, "sound/weapons/force/jump.wav" );
+						//launch off ground?
+						pm->ps->weaponTime = 300;//just to make sure it's cleared
+					}
+					if ( PM_LockedAnim( pm->ps->torsoAnim ) )
+					{//need to be able to override this anim
+						pm->ps->torsoAnimTimer = 0;
+					}
+					if ( PM_LockedAnim( pm->ps->legsAnim ) )
+					{//need to be able to override this anim
+						pm->ps->legsAnimTimer = 0;
+					}
+					PM_SetAnim( pm, SETANIM_BOTH, anim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD|SETANIM_FLAG_HOLDLESS );
+					pm->ps->saberMove = pm->ps->saberBounceMove = LS_READY;//don't finish whatever saber anim you may have been in
+					pm->ps->saberBlocked = BLOCKED_NONE;
+					return qtrue;
+				}
+				else
+				{
+					return PM_CrouchGetup( crouchheight );
+				}
+			}
+		}
+		else
+		{
+			if ( pm->ps->legsAnim == BOTH_LK_DL_ST_T_SB_1_L )
+			{
+				PM_CmdForRoll( pm->ps, &pm->cmd );
+			}
+			else
+			{
+				pm->cmd.rightmove = pm->cmd.forwardmove = 0;
+			}
+		}
+	}
+	return qfalse;
+}
+
+void PM_CmdForRoll( playerState_t *ps, usercmd_t *pCmd )
+{
+	switch ( ps->legsAnim )
+	{
+	case BOTH_ROLL_F:
+		pCmd->forwardmove = 127;
+		pCmd->rightmove = 0;
+		break;
+	case BOTH_ROLL_B:
+		pCmd->forwardmove = -127;
+		pCmd->rightmove = 0;
+		break;
+	case BOTH_ROLL_R:
+		pCmd->forwardmove = 0;
+		pCmd->rightmove = 127;
+		break;
+	case BOTH_ROLL_L:
+		pCmd->forwardmove = 0;
+		pCmd->rightmove = -127;
+		break;
+
+	case BOTH_GETUP_BROLL_R:
+		pCmd->forwardmove = 0;
+		pCmd->rightmove = 48;
+		//NOTE: speed is 400
+		break;
+
+	case BOTH_GETUP_FROLL_R:
+		if ( ps->legsAnimTimer <= 250 )
+		{//end of anim
+			pCmd->forwardmove = pCmd->rightmove = 0;
+		}
+		else
+		{
+			pCmd->forwardmove = 0;
+			pCmd->rightmove = 48;
+			//NOTE: speed is 400
+		}
+		break;
+
+	case BOTH_GETUP_BROLL_L:
+		pCmd->forwardmove = 0;
+		pCmd->rightmove = -48;
+		//NOTE: speed is 400
+		break;
+
+	case BOTH_GETUP_FROLL_L:
+		if ( ps->legsAnimTimer <= 250 )
+		{//end of anim
+			pCmd->forwardmove = pCmd->rightmove = 0;
+		}
+		else
+		{
+			pCmd->forwardmove = 0;
+			pCmd->rightmove = -48;
+			//NOTE: speed is 400
+		}
+		break;
+
+	case BOTH_GETUP_BROLL_B:
+		if ( ps->torsoAnimTimer <= 250 )
+		{//end of anim
+			pCmd->forwardmove = pCmd->rightmove = 0;
+		}
+		else if ( PM_AnimLength( g_entities[ps->clientNum].client->clientInfo.animFileIndex, (animNumber_t)ps->legsAnim ) - ps->torsoAnimTimer < 350 )
+		{//beginning of anim
+			pCmd->forwardmove = pCmd->rightmove = 0;
+		}
+		else
+		{
+			//FIXME: ramp down over length of anim
+			pCmd->forwardmove = -64;
+			pCmd->rightmove = 0;
+			//NOTE: speed is 400
+		}
+		break;
+
+	case BOTH_GETUP_FROLL_B:
+		if ( ps->torsoAnimTimer <= 100 )
+		{//end of anim
+			pCmd->forwardmove = pCmd->rightmove = 0;
+		}
+		else if ( PM_AnimLength( g_entities[ps->clientNum].client->clientInfo.animFileIndex, (animNumber_t)ps->legsAnim ) - ps->torsoAnimTimer < 200 )
+		{//beginning of anim
+			pCmd->forwardmove = pCmd->rightmove = 0;
+		}
+		else
+		{
+			//FIXME: ramp down over length of anim
+			pCmd->forwardmove = -64;
+			pCmd->rightmove = 0;
+			//NOTE: speed is 400
+		}
+		break;
+
+	case BOTH_GETUP_BROLL_F:
+		if ( ps->torsoAnimTimer <= 550 )
+		{//end of anim
+			pCmd->forwardmove = pCmd->rightmove = 0;
+		}
+		else if ( PM_AnimLength( g_entities[ps->clientNum].client->clientInfo.animFileIndex, (animNumber_t)ps->legsAnim ) - ps->torsoAnimTimer < 150 )
+		{//beginning of anim
+			pCmd->forwardmove = pCmd->rightmove = 0;
+		}
+		else
+		{
+			pCmd->forwardmove = 64;
+			pCmd->rightmove = 0;
+			//NOTE: speed is 400
+		}
+		break;
+
+	case BOTH_GETUP_FROLL_F:
+		if ( ps->torsoAnimTimer <= 100 )
+		{//end of anim
+			pCmd->forwardmove = pCmd->rightmove = 0;
+		}
+		else
+		{
+			//FIXME: ramp down over length of anim
+			pCmd->forwardmove = 64;
+			pCmd->rightmove = 0;
+			//NOTE: speed is 400
+		}
+		break;
+	case BOTH_LK_DL_ST_T_SB_1_L:
+		//kicked backwards
+		if ( ps->legsAnimTimer < 3050//at least 10 frames in
+			&& ps->legsAnimTimer > 550 )//at least 6 frames from end
+		{//move backwards
+			pCmd->forwardmove = -64;
+			pCmd->rightmove = 0;
+		}
+		else
+		{
+			pCmd->forwardmove = pCmd->rightmove = 0;
+		}
+		break;
+	}
+
+	pCmd->upmove = 0;
+}
+
+qboolean PM_InRollIgnoreTimer( playerState_t *ps )
+{
+	switch ( ps->legsAnim )
+	{
+	case BOTH_ROLL_F:
+	case BOTH_ROLL_B:
+	case BOTH_ROLL_R:
+	case BOTH_ROLL_L:
+	case BOTH_GETUP_BROLL_B:
+	case BOTH_GETUP_BROLL_F:
+	case BOTH_GETUP_BROLL_L:
+	case BOTH_GETUP_BROLL_R:
+	case BOTH_GETUP_FROLL_B:
+	case BOTH_GETUP_FROLL_F:
+	case BOTH_GETUP_FROLL_L:
+	case BOTH_GETUP_FROLL_R:
+		return qtrue;
+	}
+	return qfalse;
+}
+
+qboolean PM_InRoll( playerState_t *ps )
+{
+	if ( ps->legsAnimTimer && PM_InRollIgnoreTimer( ps ) )
+	{
+		return qtrue;
+	}
+
+	return qfalse;
+}
+
+qboolean PM_CrouchAnim( int anim )
+{
+	switch ( anim )
+	{
+	case BOTH_SIT1:				//# Normal chair sit.
+	case BOTH_SIT2:				//# Lotus position.
+	case BOTH_SIT3:				//# Sitting in tired position: elbows on knees
+	case BOTH_CROUCH1:			//# Transition from standing to crouch
+	case BOTH_CROUCH1IDLE:		//# Crouching idle
+	case BOTH_CROUCH1WALK:		//# Walking while crouched
+	case BOTH_CROUCH1WALKBACK:	//# Walking while crouched
+	case BOTH_CROUCH2TOSTAND1:	//# going from crouch2 to stand1
+	case BOTH_CROUCH3:			//# Desann crouching down to Kyle (cin 9)
+	case BOTH_KNEES1:			//# Tavion on her knees
+	case BOTH_CROUCHATTACKBACK1://FIXME: not if in middle of anim?
+	case BOTH_ROLL_STAB:
+	//???
+	case BOTH_STAND_TO_KNEEL:
+	case BOTH_KNEEL_TO_STAND:
+	case BOTH_TURNCROUCH1:
+	case BOTH_CROUCH4:
+	case BOTH_KNEES2:			//# Tavion on her knees looking down
+	case BOTH_KNEES2TO1:			//# Transition of KNEES2 to KNEES1
+		return qtrue;
+		break;
+	}
+	return qfalse;
+}
+
+qboolean PM_PainAnim( int anim )
+{
+	switch ( anim )
+	{
+		case BOTH_PAIN1:				//# First take pain anim
+		case BOTH_PAIN2:				//# Second take pain anim
+		case BOTH_PAIN3:				//# Third take pain anim
+		case BOTH_PAIN4:				//# Fourth take pain anim
+		case BOTH_PAIN5:				//# Fifth take pain anim - from behind
+		case BOTH_PAIN6:				//# Sixth take pain anim - from behind
+		case BOTH_PAIN7:				//# Seventh take pain anim - from behind
+		case BOTH_PAIN8:				//# Eigth take pain anim - from behind
+		case BOTH_PAIN9:				//# 
+		case BOTH_PAIN10:			//# 
+		case BOTH_PAIN11:			//# 
+		case BOTH_PAIN12:			//# 
+		case BOTH_PAIN13:			//# 
+		case BOTH_PAIN14:			//# 
+		case BOTH_PAIN15:			//# 
+		case BOTH_PAIN16:			//# 
+		case BOTH_PAIN17:			//# 
+		case BOTH_PAIN18:			//# 
+		return qtrue;
+		break;
+	}
+	return qfalse;
+}
+
+
+qboolean PM_DodgeHoldAnim( int anim )
+{
+	switch ( anim )
+	{
+	case BOTH_DODGE_HOLD_FL:
+	case BOTH_DODGE_HOLD_FR:
+	case BOTH_DODGE_HOLD_BL:
+	case BOTH_DODGE_HOLD_BR:
+	case BOTH_DODGE_HOLD_L:
+	case BOTH_DODGE_HOLD_R:
+		return qtrue;
+		break;
+	}
+	return qfalse;
+}
+
+qboolean PM_DodgeAnim( int anim )
+{
+	switch ( anim )
+	{
+	case BOTH_DODGE_FL:			//# lean-dodge forward left
+	case BOTH_DODGE_FR:			//# lean-dodge forward right
+	case BOTH_DODGE_BL:			//# lean-dodge backwards left
+	case BOTH_DODGE_BR:			//# lean-dodge backwards right
+	case BOTH_DODGE_L:			//# lean-dodge left
+	case BOTH_DODGE_R:			//# lean-dodge right
+		return qtrue;
+		break;
+	default:
+		return PM_DodgeHoldAnim( anim );
+		break;
+	}
+	//return qfalse;
+}
+
+qboolean PM_ForceJumpingAnim( int anim )
+{
+	switch ( anim )
+	{
+		case BOTH_FORCEJUMP1:				//# Jump - wind-up and leave ground
+		case BOTH_FORCEINAIR1:			//# In air loop (from jump)
+		case BOTH_FORCELAND1:				//# Landing (from in air loop)
+		case BOTH_FORCEJUMPBACK1:			//# Jump backwards - wind-up and leave ground
+		case BOTH_FORCEINAIRBACK1:		//# In air loop (from jump back)
+		case BOTH_FORCELANDBACK1:			//# Landing backwards(from in air loop)
+		case BOTH_FORCEJUMPLEFT1:			//# Jump left - wind-up and leave ground
+		case BOTH_FORCEINAIRLEFT1:		//# In air loop (from jump left)
+		case BOTH_FORCELANDLEFT1:			//# Landing left(from in air loop)
+		case BOTH_FORCEJUMPRIGHT1:		//# Jump right - wind-up and leave ground
+		case BOTH_FORCEINAIRRIGHT1:		//# In air loop (from jump right)
+		case BOTH_FORCELANDRIGHT1:		//# Landing right(from in air loop)
+		return qtrue;
+		break;
+	}
+	return qfalse;
+}
+
+qboolean PM_JumpingAnim( int anim )
+{
+	switch ( anim )
+	{
+	case BOTH_JUMP1:				//# Jump - wind-up and leave ground
+	case BOTH_INAIR1:			//# In air loop (from jump)
+	case BOTH_LAND1:				//# Landing (from in air loop)
+	case BOTH_LAND2:				//# Landing Hard (from a great height)
+	case BOTH_JUMPBACK1:			//# Jump backwards - wind-up and leave ground
+	case BOTH_INAIRBACK1:		//# In air loop (from jump back)
+	case BOTH_LANDBACK1:			//# Landing backwards(from in air loop)
+	case BOTH_JUMPLEFT1:			//# Jump left - wind-up and leave ground
+	case BOTH_INAIRLEFT1:		//# In air loop (from jump left)
+	case BOTH_LANDLEFT1:			//# Landing left(from in air loop)
+	case BOTH_JUMPRIGHT1:		//# Jump right - wind-up and leave ground
+	case BOTH_INAIRRIGHT1:		//# In air loop (from jump right)
+	case BOTH_LANDRIGHT1:		//# Landing right(from in air loop)
+		return qtrue;
+		break;
+	default:
+		if ( PM_InAirKickingAnim( anim ) )
+		{
+			return qtrue;
+		}
+		return PM_ForceJumpingAnim( anim );
+		break;
+	}
+	//return qfalse;
+}
+
+qboolean PM_LandingAnim( int anim )
+{
+	switch ( anim )
+	{
+		case BOTH_LAND1:				//# Landing (from in air loop)
+		case BOTH_LAND2:				//# Landing Hard (from a great height)
+		case BOTH_LANDBACK1:			//# Landing backwards(from in air loop)
+		case BOTH_LANDLEFT1:			//# Landing left(from in air loop)
+		case BOTH_LANDRIGHT1:		//# Landing right(from in air loop)
+		case BOTH_FORCELAND1:		//# Landing (from in air loop)
+		case BOTH_FORCELANDBACK1:	//# Landing backwards(from in air loop)
+		case BOTH_FORCELANDLEFT1:	//# Landing left(from in air loop)
+		case BOTH_FORCELANDRIGHT1:	//# Landing right(from in air loop)
+		return qtrue;
+		break;
+	}
+	return qfalse;
+}
+
+qboolean PM_FlippingAnim( int anim )
+{
+	switch ( anim )
+	{
+	case BOTH_FLIP_F:			//# Flip forward
+	case BOTH_FLIP_B:			//# Flip backwards
+	case BOTH_FLIP_L:			//# Flip left
+	case BOTH_FLIP_R:			//# Flip right
+	case BOTH_ALORA_FLIP_1:
+	case BOTH_ALORA_FLIP_2:
+	case BOTH_ALORA_FLIP_3:
+	case BOTH_WALL_RUN_RIGHT_FLIP:
+	case BOTH_WALL_RUN_LEFT_FLIP:
+	case BOTH_WALL_FLIP_RIGHT:
+	case BOTH_WALL_FLIP_LEFT:
+	case BOTH_FLIP_BACK1:
+	case BOTH_FLIP_BACK2:
+	case BOTH_FLIP_BACK3:
+	case BOTH_WALL_FLIP_BACK1:
+	case BOTH_ALORA_FLIP_B:
+	//Not really flips, but...
+	case BOTH_WALL_RUN_RIGHT:
+	case BOTH_WALL_RUN_LEFT:
+	case BOTH_WALL_RUN_RIGHT_STOP:
+	case BOTH_WALL_RUN_LEFT_STOP:
+	case BOTH_BUTTERFLY_LEFT:
+	case BOTH_BUTTERFLY_RIGHT:
+	case BOTH_BUTTERFLY_FL1:
+	case BOTH_BUTTERFLY_FR1:
+	//
+	case BOTH_ARIAL_LEFT:
+	case BOTH_ARIAL_RIGHT:
+	case BOTH_ARIAL_F1:
+	case BOTH_CARTWHEEL_LEFT:
+	case BOTH_CARTWHEEL_RIGHT:
+	case BOTH_JUMPFLIPSLASHDOWN1:
+	case BOTH_JUMPFLIPSTABDOWN:
+	case BOTH_JUMPATTACK6:
+	case BOTH_JUMPATTACK7:
+	//JKA
+	case BOTH_FORCEWALLRUNFLIP_END:
+	case BOTH_FORCEWALLRUNFLIP_ALT:
+	case BOTH_FLIP_ATTACK7:
+	case BOTH_A7_SOULCAL:
+		return qtrue;
+		break;
+	}
+	return qfalse;
+}
+
+qboolean PM_WalkingAnim( int anim )
+{
+	switch ( anim )
+	{
+	case BOTH_WALK1:				//# Normal walk
+	case BOTH_WALK2:				//# Normal walk with saber
+	case BOTH_WALK_STAFF:			//# Normal walk with staff
+	case BOTH_WALK_DUAL:			//# Normal walk with staff
+	case BOTH_WALK5:				//# Tavion taunting Kyle (cin 22)
+	case BOTH_WALK6:				//# Slow walk for Luke (cin 12)
+	case BOTH_WALK7:				//# Fast walk
+	case BOTH_WALKBACK1:			//# Walk1 backwards
+	case BOTH_WALKBACK2:			//# Walk2 backwards
+	case BOTH_WALKBACK_STAFF:		//# Walk backwards with staff
+	case BOTH_WALKBACK_DUAL:		//# Walk backwards with dual
+		return qtrue;
+		break;
+	}
+	return qfalse;
+}
+
+qboolean PM_RunningAnim( int anim )
+{
+	switch ( anim )
+	{
+	case BOTH_RUN1:			
+	case BOTH_RUN2:			
+	case BOTH_RUN4:
+	case BOTH_RUN_STAFF:			
+	case BOTH_RUN_DUAL:
+	case BOTH_RUNBACK1:			
+	case BOTH_RUNBACK2:			
+	case BOTH_RUNBACK_STAFF:			
+	case BOTH_RUN1START:			//# Start into full run1
+	case BOTH_RUN1STOP:			//# Stop from full run1
+	case BOTH_RUNSTRAFE_LEFT1:	//# Sidestep left: should loop
+	case BOTH_RUNSTRAFE_RIGHT1:	//# Sidestep right: should loop
+		return qtrue;
+		break;
+	}
+	return qfalse;
+}
+
+qboolean PM_RollingAnim( int anim )
+{
+	switch ( anim )
+	{
+	case BOTH_ROLL_F:			//# Roll forward
+	case BOTH_ROLL_B:			//# Roll backward
+	case BOTH_ROLL_L:			//# Roll left
+	case BOTH_ROLL_R:			//# Roll right
+	case BOTH_GETUP_BROLL_B:
+	case BOTH_GETUP_BROLL_F:
+	case BOTH_GETUP_BROLL_L:
+	case BOTH_GETUP_BROLL_R:
+	case BOTH_GETUP_FROLL_B:
+	case BOTH_GETUP_FROLL_F:
+	case BOTH_GETUP_FROLL_L:
+	case BOTH_GETUP_FROLL_R:
+		return qtrue;
+		break;
+	}
+	return qfalse;
+}
+
+qboolean PM_SwimmingAnim( int anim )
+{
+	switch ( anim )
+	{
+	case BOTH_SWIM_IDLE1:		//# Swimming Idle 1
+	case BOTH_SWIMFORWARD:		//# Swim forward loop
+	case BOTH_SWIMBACKWARD:		//# Swim backward loop
+		return qtrue;
+		break;
+	}
+	return qfalse;
+}
+
+qboolean PM_LeapingSaberAnim( int anim )
+{
+	switch ( anim )
+	{
+	//level 7
+	case BOTH_T7_BR_TL:
+	case BOTH_T7__L_BR:
+	case BOTH_T7__L__R:
+	case BOTH_T7_BL_BR:
+	case BOTH_T7_BL__R:
+	case BOTH_T7_BL_TR:
+		return qtrue;
+		break;
+	}
+	return qfalse;
+}
+
+qboolean PM_SpinningSaberAnim( int anim )
+{
+	switch ( anim )
+	{
+	//level 1 - FIXME: level 1 will have *no* spins
+	case BOTH_T1_BR_BL:
+	case BOTH_T1__R__L:
+	case BOTH_T1__R_BL:
+	case BOTH_T1_TR_BL:
+	case BOTH_T1_BR_TL:
+	case BOTH_T1_BR__L:
+	case BOTH_T1_TL_BR:
+	case BOTH_T1__L_BR:
+	case BOTH_T1__L__R:
+	case BOTH_T1_BL_BR:
+	case BOTH_T1_BL__R:
+	case BOTH_T1_BL_TR:
+	//level 2
+	case BOTH_T2_BR__L:
+	case BOTH_T2_BR_BL:
+	case BOTH_T2__R_BL:
+	case BOTH_T2__L_BR:
+	case BOTH_T2_BL_BR:
+	case BOTH_T2_BL__R:
+	//level 3
+	case BOTH_T3_BR__L:
+	case BOTH_T3_BR_BL:
+	case BOTH_T3__R_BL:
+	case BOTH_T3__L_BR:
+	case BOTH_T3_BL_BR:
+	case BOTH_T3_BL__R:
+	//level 4
+	case BOTH_T4_BR__L:
+	case BOTH_T4_BR_BL:
+	case BOTH_T4__R_BL:
+	case BOTH_T4__L_BR:
+	case BOTH_T4_BL_BR:
+	case BOTH_T4_BL__R:
+	//level 5
+	case BOTH_T5_BR_BL:
+	case BOTH_T5__R__L:
+	case BOTH_T5__R_BL:
+	case BOTH_T5_TR_BL:
+	case BOTH_T5_BR_TL:
+	case BOTH_T5_BR__L:
+	case BOTH_T5_TL_BR:
+	case BOTH_T5__L_BR:
+	case BOTH_T5__L__R:
+	case BOTH_T5_BL_BR:
+	case BOTH_T5_BL__R:
+	case BOTH_T5_BL_TR:
+	//level 6
+	case BOTH_T6_BR_TL:
+	case BOTH_T6__R_TL:
+	case BOTH_T6__R__L:
+	case BOTH_T6__R_BL:
+	case BOTH_T6_TR_TL:
+	case BOTH_T6_TR__L:
+	case BOTH_T6_TR_BL:
+	case BOTH_T6_T__TL:
+	case BOTH_T6_T__BL:
+	case BOTH_T6_TL_BR:
+	case BOTH_T6__L_BR:
+	case BOTH_T6__L__R:
+	case BOTH_T6_TL__R:
+	case BOTH_T6_TL_TR:
+	case BOTH_T6__L_TR:
+	case BOTH_T6__L_T_:
+	case BOTH_T6_BL_T_:
+	case BOTH_T6_BR__L:
+	case BOTH_T6_BR_BL:
+	case BOTH_T6_BL_BR:
+	case BOTH_T6_BL__R:
+	case BOTH_T6_BL_TR:
+	//level 7
+	case BOTH_T7_BR_TL:
+	case BOTH_T7_BR__L:
+	case BOTH_T7_BR_BL:
+	case BOTH_T7__R__L:
+	case BOTH_T7__R_BL:
+	case BOTH_T7_TR__L:
+	case BOTH_T7_T___R:
+	case BOTH_T7_TL_BR:
+	case BOTH_T7__L_BR:
+	case BOTH_T7__L__R:
+	case BOTH_T7_BL_BR:
+	case BOTH_T7_BL__R:
+	case BOTH_T7_BL_TR:
+	case BOTH_T7_TL_TR:
+	case BOTH_T7_T__BR:
+	case BOTH_T7__L_TR:
+	case BOTH_V7_BL_S7:
+	//special
+	//case BOTH_A2_STABBACK1:
+	case BOTH_ATTACK_BACK:
+	case BOTH_CROUCHATTACKBACK1:
+	case BOTH_BUTTERFLY_LEFT:
+	case BOTH_BUTTERFLY_RIGHT:
+	case BOTH_FJSS_TR_BL:
+	case BOTH_FJSS_TL_BR:
+	case BOTH_JUMPFLIPSLASHDOWN1:
+	case BOTH_JUMPFLIPSTABDOWN:
+		return qtrue;
+		break;
+	}
+	return qfalse;
+}
+
+qboolean PM_SpinningAnim( int anim )
+{
+	/*
+	switch ( anim )
+	{
+	//FIXME: list any other spinning anims
+	default:
+		break;
+	}
+	*/
+	return PM_SpinningSaberAnim( anim );
+}
+
+void PM_ResetAnkleAngles( void )
+{
+	if ( !pm->gent || !pm->gent->client || pm->gent->client->NPC_class != CLASS_ATST )
+	{
+		return;
+	}
+	if ( pm->gent->footLBone != -1 )
+	{
+		gi.G2API_SetBoneAnglesIndex( &pm->gent->ghoul2[0], pm->gent->footLBone, vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_Z, NEGATIVE_Y, NEGATIVE_X, NULL ); 
+	}
+	if ( pm->gent->footRBone != -1 )
+	{
+		gi.G2API_SetBoneAnglesIndex( &pm->gent->ghoul2[0], pm->gent->footRBone, vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_Z, NEGATIVE_Y, NEGATIVE_X, NULL ); 
+	}
+}
+
+void PM_AnglesForSlope( const float yaw, const vec3_t slope, vec3_t angles )
+{
+	vec3_t	nvf, ovf, ovr, new_angles;
+	float	pitch, mod, dot;
+
+	VectorSet( angles, 0, yaw, 0 );
+	AngleVectors( angles, ovf, ovr, NULL );
+
+	vectoangles( slope, new_angles );
+	pitch = new_angles[PITCH] + 90;
+	new_angles[ROLL] = new_angles[PITCH] = 0;
+
+	AngleVectors( new_angles, nvf, NULL, NULL );
+
+	mod = DotProduct( nvf, ovr );
+
+	if ( mod < 0 )
+		mod = -1;
+	else
+		mod = 1;
+
+	dot = DotProduct( nvf, ovf );
+
+	angles[YAW] = 0;
+	angles[PITCH] = dot * pitch;
+	angles[ROLL] = ((1-Q_fabs(dot)) * pitch * mod);
+}
+
+void PM_FootSlopeTrace( float *pDiff, float *pInterval )
+{
+	vec3_t	footLOrg, footROrg, footLBot, footRBot;
+	trace_t	trace;
+	float	diff, interval;
+	if ( pm->gent->client->NPC_class == CLASS_ATST )
+	{
+		interval = 10;
+	}
+	else
+	{
+		interval = 4;//?
+	}
+
+	if ( pm->gent->footLBolt == -1 || pm->gent->footRBolt == -1 )
+	{
+		if ( pDiff != NULL )
+		{
+			*pDiff = 0;
+		}
+		if ( pInterval != NULL )
+		{
+			*pInterval = interval;
+		}
+		return;
+	}
+#if 1
+	for ( int i = 0; i < 3; i++ )
+	{
+		if ( _isnan( pm->gent->client->renderInfo.footLPoint[i] )
+			|| _isnan( pm->gent->client->renderInfo.footRPoint[i] ) )
+		{
+			if ( pDiff != NULL )
+			{
+				*pDiff = 0;
+			}
+			if ( pInterval != NULL )
+			{
+				*pInterval = interval;
+			}
+			return;
+		}
+	}
+#else
+
+	//FIXME: these really should have been gotten on the cgame, but I guess sometimes they're not and we end up with qnan numbers!
+	mdxaBone_t	boltMatrix;
+	vec3_t		G2Angles = {0, pm->gent->client->ps.legsYaw, 0};
+	//get the feet
+	gi.G2API_GetBoltMatrix( pm->gent->ghoul2, pm->gent->playerModel, pm->gent->footLBolt, 
+			&boltMatrix, G2Angles, pm->ps->origin, (cg.time?cg.time:level.time), 
+					NULL, pm->gent->s.modelScale );
+	gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, pm->gent->client->renderInfo.footLPoint );
+	
+	gi.G2API_GetBoltMatrix( pm->gent->ghoul2, pm->gent->playerModel, pm->gent->footRBolt, 
+					&boltMatrix, G2Angles, pm->ps->origin, (cg.time?cg.time:level.time), 
+					NULL, pm->gent->s.modelScale );
+	gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, pm->gent->client->renderInfo.footRPoint );
+#endif
+	//NOTE: on AT-STs, rotating the foot moves this point, so it will wiggle... 
+	//		we have to do this extra work (more G2 transforms) to stop the wiggle... is it worth it?
+	/*
+	if ( pm->gent->client->NPC_class == CLASS_ATST )
+	{
+		mdxaBone_t	boltMatrix;
+		vec3_t		G2Angles = {0, pm->gent->client->ps.legsYaw, 0};
+		//get the feet
+		gi.G2API_SetBoneAnglesIndex( &pm->gent->ghoul2[0], pm->gent->footLBone, vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_Z, NEGATIVE_Y, NEGATIVE_X, NULL ); 
+		gi.G2API_GetBoltMatrix( pm->gent->ghoul2, pm->gent->playerModel, pm->gent->footLBolt, 
+				&boltMatrix, G2Angles, pm->ps->origin, (cg.time?cg.time:level.time), 
+						NULL, pm->gent->s.modelScale );
+		gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, pm->gent->client->renderInfo.footLPoint );
+		
+		gi.G2API_SetBoneAnglesIndex( &pm->gent->ghoul2[0], pm->gent->footRBone, vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_Z, NEGATIVE_Y, NEGATIVE_X, NULL ); 
+		gi.G2API_GetBoltMatrix( pm->gent->ghoul2, pm->gent->playerModel, pm->gent->footRBolt, 
+						&boltMatrix, G2Angles, pm->ps->origin, (cg.time?cg.time:level.time), 
+						NULL, pm->gent->s.modelScale );
+		gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, pm->gent->client->renderInfo.footRPoint );
+	}
+	*/
+	//get these on the cgame and store it, save ourselves a ghoul2 construct skel call
+	VectorCopy( pm->gent->client->renderInfo.footLPoint, footLOrg );
+	VectorCopy( pm->gent->client->renderInfo.footRPoint, footROrg );
+
+	//step 2: adjust foot tag z height to bottom of bbox+1
+	footLOrg[2] = pm->gent->currentOrigin[2] + pm->gent->mins[2] + 1;
+	footROrg[2] = pm->gent->currentOrigin[2] + pm->gent->mins[2] + 1;
+	VectorSet( footLBot, footLOrg[0], footLOrg[1], footLOrg[2] - interval*10 );
+	VectorSet( footRBot, footROrg[0], footROrg[1], footROrg[2] - interval*10 );
+
+	//step 3: trace down from each, find difference
+	vec3_t footMins, footMaxs;
+	vec3_t footLSlope, footRSlope;
+	if ( pm->gent->client->NPC_class == CLASS_ATST )
+	{
+		VectorSet( footMins, -16, -16, 0 );
+		VectorSet( footMaxs, 16, 16, 1 );
+	}
+	else
+	{
+		VectorSet( footMins, -3, -3, 0 );
+		VectorSet( footMaxs, 3, 3, 1 );
+	}
+
+	pm->trace( &trace, footLOrg, footMins, footMaxs, footLBot, pm->ps->clientNum, pm->tracemask );
+	VectorCopy( trace.endpos, footLBot );
+	VectorCopy( trace.plane.normal, footLSlope );
+
+	pm->trace( &trace, footROrg, footMins, footMaxs, footRBot, pm->ps->clientNum, pm->tracemask );
+	VectorCopy( trace.endpos, footRBot );
+	VectorCopy( trace.plane.normal, footRSlope );
+
+	diff = footLBot[2] - footRBot[2];
+
+	//optional step: for atst, tilt the footpads to match the slopes under it...
+	if ( pm->gent->client->NPC_class == CLASS_ATST )
+	{
+		vec3_t footAngles;
+		if ( !VectorCompare( footLSlope, vec3_origin ) )
+		{//rotate the ATST's left foot pad to match the slope
+			PM_AnglesForSlope( pm->gent->client->renderInfo.legsYaw, footLSlope, footAngles );
+			//Hmm... lerp this?
+			gi.G2API_SetBoneAnglesIndex( &pm->gent->ghoul2[0], pm->gent->footLBone, footAngles, BONE_ANGLES_POSTMULT, POSITIVE_Z, NEGATIVE_Y, NEGATIVE_X, NULL ); 
+		}
+		if ( !VectorCompare( footRSlope, vec3_origin ) )
+		{//rotate the ATST's right foot pad to match the slope
+			PM_AnglesForSlope( pm->gent->client->renderInfo.legsYaw, footRSlope, footAngles );
+			//Hmm... lerp this?
+			gi.G2API_SetBoneAnglesIndex( &pm->gent->ghoul2[0], pm->gent->footRBone, footAngles, BONE_ANGLES_POSTMULT, POSITIVE_Z, NEGATIVE_Y, NEGATIVE_X, NULL ); 
+		}
+	}
+
+	if ( pDiff != NULL )
+	{
+		*pDiff = diff;
+	}
+	if ( pInterval != NULL )
+	{
+		*pInterval = interval;
+	}
+}
+
+qboolean PM_InSlopeAnim( int anim )
+{
+	switch ( anim )
+	{
+	case LEGS_LEFTUP1:			//# On a slope with left foot 4 higher than right
+	case LEGS_LEFTUP2:			//# On a slope with left foot 8 higher than right
+	case LEGS_LEFTUP3:			//# On a slope with left foot 12 higher than right
+	case LEGS_LEFTUP4:			//# On a slope with left foot 16 higher than right
+	case LEGS_LEFTUP5:			//# On a slope with left foot 20 higher than right
+	case LEGS_RIGHTUP1:			//# On a slope with RIGHT foot 4 higher than left
+	case LEGS_RIGHTUP2:			//# On a slope with RIGHT foot 8 higher than left
+	case LEGS_RIGHTUP3:			//# On a slope with RIGHT foot 12 higher than left
+	case LEGS_RIGHTUP4:			//# On a slope with RIGHT foot 16 higher than left
+	case LEGS_RIGHTUP5:			//# On a slope with RIGHT foot 20 higher than left
+	case LEGS_S1_LUP1:
+	case LEGS_S1_LUP2:
+	case LEGS_S1_LUP3:
+	case LEGS_S1_LUP4:
+	case LEGS_S1_LUP5:
+	case LEGS_S1_RUP1:
+	case LEGS_S1_RUP2:
+	case LEGS_S1_RUP3:
+	case LEGS_S1_RUP4:
+	case LEGS_S1_RUP5:
+	case LEGS_S3_LUP1:
+	case LEGS_S3_LUP2:
+	case LEGS_S3_LUP3:
+	case LEGS_S3_LUP4:
+	case LEGS_S3_LUP5:
+	case LEGS_S3_RUP1:
+	case LEGS_S3_RUP2:
+	case LEGS_S3_RUP3:
+	case LEGS_S3_RUP4:
+	case LEGS_S3_RUP5:
+	case LEGS_S4_LUP1:
+	case LEGS_S4_LUP2:
+	case LEGS_S4_LUP3:
+	case LEGS_S4_LUP4:
+	case LEGS_S4_LUP5:
+	case LEGS_S4_RUP1:
+	case LEGS_S4_RUP2:
+	case LEGS_S4_RUP3:
+	case LEGS_S4_RUP4:
+	case LEGS_S4_RUP5:
+	case LEGS_S5_LUP1:
+	case LEGS_S5_LUP2:
+	case LEGS_S5_LUP3:
+	case LEGS_S5_LUP4:
+	case LEGS_S5_LUP5:
+	case LEGS_S5_RUP1:
+	case LEGS_S5_RUP2:
+	case LEGS_S5_RUP3:
+	case LEGS_S5_RUP4:
+	case LEGS_S5_RUP5:
+	case LEGS_S6_LUP1:
+	case LEGS_S6_LUP2:
+	case LEGS_S6_LUP3:
+	case LEGS_S6_LUP4:
+	case LEGS_S6_LUP5:
+	case LEGS_S6_RUP1:
+	case LEGS_S6_RUP2:
+	case LEGS_S6_RUP3:
+	case LEGS_S6_RUP4:
+	case LEGS_S6_RUP5:
+	case LEGS_S7_LUP1:
+	case LEGS_S7_LUP2:
+	case LEGS_S7_LUP3:
+	case LEGS_S7_LUP4:
+	case LEGS_S7_LUP5:
+	case LEGS_S7_RUP1:
+	case LEGS_S7_RUP2:
+	case LEGS_S7_RUP3:
+	case LEGS_S7_RUP4:
+	case LEGS_S7_RUP5:
+		return qtrue;
+		break;
+	}
+	return qfalse;
+}
+
+qboolean PM_SaberStanceAnim( int anim )
+{
+	switch ( anim )
+	{
+	case BOTH_STAND1://not really a saberstance anim, actually... "saber off" stance
+	case BOTH_STAND2://single-saber, medium style
+	case BOTH_SABERFAST_STANCE://single-saber, fast style
+	case BOTH_SABERSLOW_STANCE://single-saber, strong style
+	case BOTH_SABERSTAFF_STANCE://saber staff style
+	case BOTH_SABERDUAL_STANCE://dual saber style
+		return qtrue;
+		break;
+	}
+	return qfalse;
+}
+
+qboolean PM_SaberDrawPutawayAnim( int anim )
+{
+	switch ( anim )
+	{
+	case BOTH_STAND1TO2:
+	case BOTH_STAND2TO1:
+	case BOTH_S1_S7:
+	case BOTH_S7_S1:
+	case BOTH_S1_S6:
+	case BOTH_S6_S1:
+		return qtrue;
+		break;
+	}
+	return qfalse;
+}
+
+#define	SLOPE_RECALC_INT 100
+extern qboolean G_StandardHumanoid( gentity_t *self );
+qboolean PM_AdjustStandAnimForSlope( void )
+{
+	if ( !pm->gent || !pm->gent->client )
+	{
+		return qfalse;
+	}
+	if ( pm->gent->client->NPC_class != CLASS_ATST 
+		&& (!pm->gent||!G_StandardHumanoid( pm->gent )) )
+	{//only ATST and player does this
+		return qfalse;
+	}
+	if ( (pm->ps->clientNum < MAX_CLIENTS||PM_ControlledByPlayer())
+		&& (!cg.renderingThirdPerson || cg.zoomMode) )
+	{//first person doesn't do this
+		return qfalse;
+	}
+	if ( pm->gent->footLBolt == -1 || pm->gent->footRBolt == -1 )
+	{//need these bolts!
+		return qfalse;
+	}
+	//step 1: find the 2 foot tags
+	float	diff;
+	float	interval;
+	PM_FootSlopeTrace( &diff, &interval );
+
+	//step 4: based on difference, choose one of the left/right slope-match intervals
+	int		destAnim;
+	if ( diff >= interval*5 )
+	{
+		destAnim = LEGS_LEFTUP5;
+	}
+	else if ( diff >= interval*4 )
+	{
+		destAnim = LEGS_LEFTUP4;
+	}
+	else if ( diff >= interval*3 )
+	{
+		destAnim = LEGS_LEFTUP3;
+	}
+	else if ( diff >= interval*2 )
+	{
+		destAnim = LEGS_LEFTUP2;
+	}
+	else if ( diff >= interval )
+	{
+		destAnim = LEGS_LEFTUP1;
+	}
+	else if ( diff <= interval*-5 )
+	{
+		destAnim = LEGS_RIGHTUP5;
+	}
+	else if ( diff <= interval*-4 )
+	{
+		destAnim = LEGS_RIGHTUP4;
+	}
+	else if ( diff <= interval*-3 )
+	{
+		destAnim = LEGS_RIGHTUP3;
+	}
+	else if ( diff <= interval*-2 )
+	{
+		destAnim = LEGS_RIGHTUP2;
+	}
+	else if ( diff <= interval*-1 )
+	{
+		destAnim = LEGS_RIGHTUP1;
+	}
+	else
+	{
+		return qfalse;
+	}
+
+	int legsAnim = pm->ps->legsAnim;
+	if ( pm->gent->client->NPC_class != CLASS_ATST )
+	{
+		//adjust for current legs anim
+		switch ( legsAnim )
+		{
+		case BOTH_STAND1:
+		case LEGS_S1_LUP1:
+		case LEGS_S1_LUP2:
+		case LEGS_S1_LUP3:
+		case LEGS_S1_LUP4:
+		case LEGS_S1_LUP5:
+		case LEGS_S1_RUP1:
+		case LEGS_S1_RUP2:
+		case LEGS_S1_RUP3:
+		case LEGS_S1_RUP4:
+		case LEGS_S1_RUP5:
+			destAnim = LEGS_S1_LUP1 + (destAnim-LEGS_LEFTUP1);
+			break;
+		case BOTH_STAND2:
+		case BOTH_SABERFAST_STANCE:
+		case BOTH_SABERSLOW_STANCE:
+		case BOTH_CROUCH1IDLE:
+		case BOTH_CROUCH1:
+		case LEGS_LEFTUP1:			//# On a slope with left foot 4 higher than right
+		case LEGS_LEFTUP2:			//# On a slope with left foot 8 higher than right
+		case LEGS_LEFTUP3:			//# On a slope with left foot 12 higher than right
+		case LEGS_LEFTUP4:			//# On a slope with left foot 16 higher than right
+		case LEGS_LEFTUP5:			//# On a slope with left foot 20 higher than right
+		case LEGS_RIGHTUP1:			//# On a slope with RIGHT foot 4 higher than left
+		case LEGS_RIGHTUP2:			//# On a slope with RIGHT foot 8 higher than left
+		case LEGS_RIGHTUP3:			//# On a slope with RIGHT foot 12 higher than left
+		case LEGS_RIGHTUP4:			//# On a slope with RIGHT foot 16 higher than left
+		case LEGS_RIGHTUP5:			//# On a slope with RIGHT foot 20 higher than left
+			//fine
+			break;
+		case BOTH_STAND3:
+		case LEGS_S3_LUP1:
+		case LEGS_S3_LUP2:
+		case LEGS_S3_LUP3:
+		case LEGS_S3_LUP4:
+		case LEGS_S3_LUP5:
+		case LEGS_S3_RUP1:
+		case LEGS_S3_RUP2:
+		case LEGS_S3_RUP3:
+		case LEGS_S3_RUP4:
+		case LEGS_S3_RUP5:
+			destAnim = LEGS_S3_LUP1 + (destAnim-LEGS_LEFTUP1);
+			break;
+		case BOTH_STAND4:
+		case LEGS_S4_LUP1:
+		case LEGS_S4_LUP2:
+		case LEGS_S4_LUP3:
+		case LEGS_S4_LUP4:
+		case LEGS_S4_LUP5:
+		case LEGS_S4_RUP1:
+		case LEGS_S4_RUP2:
+		case LEGS_S4_RUP3:
+		case LEGS_S4_RUP4:
+		case LEGS_S4_RUP5:
+			destAnim = LEGS_S4_LUP1 + (destAnim-LEGS_LEFTUP1);
+			break;
+		case BOTH_STAND5:
+		case LEGS_S5_LUP1:
+		case LEGS_S5_LUP2:
+		case LEGS_S5_LUP3:
+		case LEGS_S5_LUP4:
+		case LEGS_S5_LUP5:
+		case LEGS_S5_RUP1:
+		case LEGS_S5_RUP2:
+		case LEGS_S5_RUP3:
+		case LEGS_S5_RUP4:
+		case LEGS_S5_RUP5:
+			destAnim = LEGS_S5_LUP1 + (destAnim-LEGS_LEFTUP1);
+			break;
+		case BOTH_SABERDUAL_STANCE:
+		case LEGS_S6_LUP1:
+		case LEGS_S6_LUP2:
+		case LEGS_S6_LUP3:
+		case LEGS_S6_LUP4:
+		case LEGS_S6_LUP5:
+		case LEGS_S6_RUP1:
+		case LEGS_S6_RUP2:
+		case LEGS_S6_RUP3:
+		case LEGS_S6_RUP4:
+		case LEGS_S6_RUP5:
+			destAnim = LEGS_S6_LUP1 + (destAnim-LEGS_LEFTUP1);
+			break;
+		case BOTH_SABERSTAFF_STANCE:
+		case LEGS_S7_LUP1:
+		case LEGS_S7_LUP2:
+		case LEGS_S7_LUP3:
+		case LEGS_S7_LUP4:
+		case LEGS_S7_LUP5:
+		case LEGS_S7_RUP1:
+		case LEGS_S7_RUP2:
+		case LEGS_S7_RUP3:
+		case LEGS_S7_RUP4:
+		case LEGS_S7_RUP5:
+			destAnim = LEGS_S7_LUP1 + (destAnim-LEGS_LEFTUP1);
+			break;
+		case BOTH_STAND6:
+		default:
+			return qfalse;
+			break;
+		}
+	}
+	//step 5: based on the chosen interval and the current legsAnim, pick the correct anim
+	//step 6: increment/decrement to the dest anim, not instant
+	if ( (legsAnim >= LEGS_LEFTUP1 && legsAnim <= LEGS_LEFTUP5)
+		|| (legsAnim >= LEGS_S1_LUP1 && legsAnim <= LEGS_S1_LUP5)
+		|| (legsAnim >= LEGS_S3_LUP1 && legsAnim <= LEGS_S3_LUP5)
+		|| (legsAnim >= LEGS_S4_LUP1 && legsAnim <= LEGS_S4_LUP5)
+		|| (legsAnim >= LEGS_S5_LUP1 && legsAnim <= LEGS_S5_LUP5)
+		|| (legsAnim >= LEGS_S6_LUP1 && legsAnim <= LEGS_S6_LUP5)
+		|| (legsAnim >= LEGS_S7_LUP1 && legsAnim <= LEGS_S7_LUP5) )
+	{//already in left-side up
+		if ( destAnim > legsAnim && pm->gent->client->slopeRecalcTime < level.time )
+		{
+			legsAnim++;
+			pm->gent->client->slopeRecalcTime = level.time + SLOPE_RECALC_INT;
+		}
+		else if ( destAnim < legsAnim && pm->gent->client->slopeRecalcTime < level.time )
+		{
+			legsAnim--;
+			pm->gent->client->slopeRecalcTime = level.time + SLOPE_RECALC_INT;
+		}
+		else
+		{
+			destAnim = legsAnim;
+		}
+	}
+	else if ( (legsAnim >= LEGS_RIGHTUP1 && legsAnim <= LEGS_RIGHTUP5) 
+		|| (legsAnim >= LEGS_S1_RUP1 && legsAnim <= LEGS_S1_RUP5)
+		|| (legsAnim >= LEGS_S3_RUP1 && legsAnim <= LEGS_S3_RUP5)
+		|| (legsAnim >= LEGS_S4_RUP1 && legsAnim <= LEGS_S4_RUP5)
+		|| (legsAnim >= LEGS_S5_RUP1 && legsAnim <= LEGS_S5_RUP5)
+		|| (legsAnim >= LEGS_S6_RUP1 && legsAnim <= LEGS_S6_RUP5)
+		|| (legsAnim >= LEGS_S7_RUP1 && legsAnim <= LEGS_S7_RUP5) )
+	{//already in right-side up
+		if ( destAnim > legsAnim && pm->gent->client->slopeRecalcTime < level.time )
+		{
+			legsAnim++;
+			pm->gent->client->slopeRecalcTime = level.time + SLOPE_RECALC_INT;
+		}
+		else if ( destAnim < legsAnim && pm->gent->client->slopeRecalcTime < level.time )
+		{
+			legsAnim--;
+			pm->gent->client->slopeRecalcTime = level.time + SLOPE_RECALC_INT;
+		}
+		else
+		{
+			destAnim = legsAnim;
+		}
+	}
+	else
+	{//in a stand of some sort?
+		if ( pm->gent->client->NPC_class == CLASS_ATST )
+		{
+			if ( legsAnim == BOTH_STAND1 || legsAnim == BOTH_STAND2 || legsAnim == BOTH_CROUCH1IDLE )
+			{
+				if ( destAnim >= LEGS_LEFTUP1 && destAnim <= LEGS_LEFTUP5 )
+				{//going into left side up
+					destAnim = LEGS_LEFTUP1;
+					pm->gent->client->slopeRecalcTime = level.time + SLOPE_RECALC_INT;
+				}
+				else if ( destAnim >= LEGS_RIGHTUP1 && destAnim <= LEGS_RIGHTUP5 )
+				{//going into right side up
+					destAnim = LEGS_RIGHTUP1;
+					pm->gent->client->slopeRecalcTime = level.time + SLOPE_RECALC_INT;
+				}
+				else
+				{//will never get here
+					return qfalse;
+				}
+			}
+		}
+		else
+		{
+			switch ( legsAnim )
+			{
+			case BOTH_STAND1:
+				if ( destAnim >= LEGS_S1_LUP1 && destAnim <= LEGS_S1_LUP5 )
+				{//going into left side up
+					destAnim = LEGS_S1_LUP1;
+					pm->gent->client->slopeRecalcTime = level.time + SLOPE_RECALC_INT;
+				}
+				else if ( destAnim >= LEGS_S1_RUP1 && destAnim <= LEGS_S1_RUP5 )
+				{//going into right side up
+					destAnim = LEGS_S1_RUP1;
+					pm->gent->client->slopeRecalcTime = level.time + SLOPE_RECALC_INT;
+				}
+				else
+				{//will never get here
+					return qfalse;
+				}
+				break;
+			case BOTH_STAND2:
+			case BOTH_SABERFAST_STANCE:
+			case BOTH_SABERSLOW_STANCE:
+			case BOTH_CROUCH1IDLE:
+				if ( destAnim >= LEGS_LEFTUP1 && destAnim <= LEGS_LEFTUP5 )
+				{//going into left side up
+					destAnim = LEGS_LEFTUP1;
+					pm->gent->client->slopeRecalcTime = level.time + SLOPE_RECALC_INT;
+				}
+				else if ( destAnim >= LEGS_RIGHTUP1 && destAnim <= LEGS_RIGHTUP5 )
+				{//going into right side up
+					destAnim = LEGS_RIGHTUP1;
+					pm->gent->client->slopeRecalcTime = level.time + SLOPE_RECALC_INT;
+				}
+				else
+				{//will never get here
+					return qfalse;
+				}
+				break;
+			case BOTH_STAND3:
+				if ( destAnim >= LEGS_S3_LUP1 && destAnim <= LEGS_S3_LUP5 )
+				{//going into left side up
+					destAnim = LEGS_S3_LUP1;
+					pm->gent->client->slopeRecalcTime = level.time + SLOPE_RECALC_INT;
+				}
+				else if ( destAnim >= LEGS_S3_RUP1 && destAnim <= LEGS_S3_RUP5 )
+				{//going into right side up
+					destAnim = LEGS_S3_RUP1;
+					pm->gent->client->slopeRecalcTime = level.time + SLOPE_RECALC_INT;
+				}
+				else
+				{//will never get here
+					return qfalse;
+				}
+				break;
+			case BOTH_STAND4:
+				if ( destAnim >= LEGS_S4_LUP1 && destAnim <= LEGS_S4_LUP5 )
+				{//going into left side up
+					destAnim = LEGS_S4_LUP1;
+					pm->gent->client->slopeRecalcTime = level.time + SLOPE_RECALC_INT;
+				}
+				else if ( destAnim >= LEGS_S4_RUP1 && destAnim <= LEGS_S4_RUP5 )
+				{//going into right side up
+					destAnim = LEGS_S4_RUP1;
+					pm->gent->client->slopeRecalcTime = level.time + SLOPE_RECALC_INT;
+				}
+				else
+				{//will never get here
+					return qfalse;
+				}
+				break;
+			case BOTH_STAND5:
+				if ( destAnim >= LEGS_S5_LUP1 && destAnim <= LEGS_S5_LUP5 )
+				{//going into left side up
+					destAnim = LEGS_S5_LUP1;
+					pm->gent->client->slopeRecalcTime = level.time + SLOPE_RECALC_INT;
+				}
+				else if ( destAnim >= LEGS_S5_RUP1 && destAnim <= LEGS_S5_RUP5 )
+				{//going into right side up
+					destAnim = LEGS_S5_RUP1;
+					pm->gent->client->slopeRecalcTime = level.time + SLOPE_RECALC_INT;
+				}
+				else
+				{//will never get here
+					return qfalse;
+				}
+				break;
+			case BOTH_SABERDUAL_STANCE:
+				if ( destAnim >= LEGS_S6_LUP1 && destAnim <= LEGS_S6_LUP5 )
+				{//going into left side up
+					destAnim = LEGS_S6_LUP1;
+					pm->gent->client->slopeRecalcTime = level.time + SLOPE_RECALC_INT;
+				}
+				else if ( destAnim >= LEGS_S6_RUP1 && destAnim <= LEGS_S6_RUP5 )
+				{//going into right side up
+					destAnim = LEGS_S6_RUP1;
+					pm->gent->client->slopeRecalcTime = level.time + SLOPE_RECALC_INT;
+				}
+				else
+				{//will never get here
+					return qfalse;
+				}
+				break;
+			case BOTH_SABERSTAFF_STANCE:
+				if ( destAnim >= LEGS_S7_LUP1 && destAnim <= LEGS_S7_LUP5 )
+				{//going into left side up
+					destAnim = LEGS_S7_LUP1;
+					pm->gent->client->slopeRecalcTime = level.time + SLOPE_RECALC_INT;
+				}
+				else if ( destAnim >= LEGS_S7_RUP1 && destAnim <= LEGS_S7_RUP5 )
+				{//going into right side up
+					destAnim = LEGS_S7_RUP1;
+					pm->gent->client->slopeRecalcTime = level.time + SLOPE_RECALC_INT;
+				}
+				else
+				{//will never get here
+					return qfalse;
+				}
+				break;
+			case BOTH_STAND6:
+			default:
+				return qfalse;
+				break;
+			}
+		}
+	}
+	//step 7: set the anim
+	PM_SetAnim( pm, SETANIM_LEGS, destAnim, SETANIM_FLAG_NORMAL );
+
+	return qtrue;
+}
+
+void PM_JetPackAnim( void )
+{
+	if ( !PM_ForceJumpingAnim( pm->ps->legsAnim ) )//haven't started forcejump yet
+	{
+		vec3_t facingFwd, facingRight, facingAngles = {0, pm->ps->viewangles[YAW], 0};
+		int anim = BOTH_FORCEJUMP1;
+		AngleVectors( facingAngles, facingFwd, facingRight, NULL );
+		float dotR = DotProduct( facingRight, pm->ps->velocity );
+		float dotF = DotProduct( facingFwd, pm->ps->velocity );
+		if ( fabs(dotR) > fabs(dotF) * 1.5 )
+		{
+			if ( dotR > 150 )
+			{
+				anim = BOTH_FORCEJUMPRIGHT1;
+			}
+			else if ( dotR < -150 )
+			{
+				anim = BOTH_FORCEJUMPLEFT1;
+			}
+		}
+		else
+		{
+			if ( dotF > 150 )
+			{
+				anim = BOTH_FORCEJUMP1;
+			}
+			else if ( dotF < -150 )
+			{
+				anim = BOTH_FORCEJUMPBACK1;
+			}
+		}
+		int parts = SETANIM_BOTH;
+		if ( pm->ps->weaponTime )
+		{//FIXME: really only care if we're in a saber attack anim...
+			parts = SETANIM_LEGS;
+		}
+
+		PM_SetAnim( pm, parts, anim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+	}
+	/*
+	else
+	{
+		if ( !pm->ps->legsAnimTimer )
+		{//not in the middle of a legsAnim
+			int anim = pm->ps->legsAnim;
+			int newAnim = -1;
+			switch ( anim )
+			{
+			case BOTH_FORCEJUMP1:
+				newAnim = BOTH_FORCELAND1;//BOTH_FORCEINAIR1;
+				break;
+			case BOTH_FORCEJUMPBACK1:
+				newAnim = BOTH_FORCELANDBACK1;//BOTH_FORCEINAIRBACK1;
+				break;
+			case BOTH_FORCEJUMPLEFT1:
+				newAnim = BOTH_FORCELANDLEFT1;//BOTH_FORCEINAIRLEFT1;
+				break;
+			case BOTH_FORCEJUMPRIGHT1:
+				newAnim = BOTH_FORCELANDRIGHT1;//BOTH_FORCEINAIRRIGHT1;
+				break;
+			}
+			if ( newAnim != -1 )
+			{
+				int parts = SETANIM_BOTH;
+				if ( pm->ps->weaponTime )
+				{//FIXME: really only care if we're in a saber attack anim...
+					parts = SETANIM_LEGS;
+				}
+
+				PM_SetAnim( pm, parts, newAnim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+			}
+		}
+	}
+	*/
+}
+void PM_SwimFloatAnim( void )
+{
+	int legsAnim = pm->ps->legsAnim;
+	//FIXME: no start or stop anims
+	if ( pm->cmd.forwardmove || pm->cmd.rightmove || pm->cmd.upmove )
+	{
+		PM_SetAnim(pm,SETANIM_LEGS,BOTH_SWIMFORWARD,SETANIM_FLAG_NORMAL);
+	}
+	else
+	{//stopping
+		if ( legsAnim == BOTH_SWIMFORWARD )
+		{//I was swimming 
+			if ( !pm->ps->legsAnimTimer )
+			{
+				PM_SetAnim(pm,SETANIM_LEGS,BOTH_SWIM_IDLE1,SETANIM_FLAG_NORMAL);
+			}
+		}
+		else
+		{//idle
+			if ( !(pm->ps->pm_flags&PMF_DUCKED) && pm->cmd.upmove >= 0 )
+			{//not crouching
+				PM_SetAnim(pm,SETANIM_LEGS,BOTH_SWIM_IDLE1,SETANIM_FLAG_NORMAL);
+			}
+		}
+	}
+}
+
+/*
+===============
+PM_Footsteps
+===============
+*/
+static void PM_Footsteps( void ) 
+{
+	float		bobmove;
+	int			old, oldAnim;
+	qboolean	footstep = qfalse;
+	qboolean	validNPC = qfalse;
+	qboolean	flipping = qfalse;
+	int			setAnimFlags = SETANIM_FLAG_NORMAL;
+
+	if( pm->gent == NULL || pm->gent->client == NULL )
+		return;
+
+	if ( (pm->ps->eFlags&EF_HELD_BY_WAMPA) )
+	{
+		PM_SetAnim( pm, SETANIM_BOTH, BOTH_HANG_IDLE, SETANIM_FLAG_NORMAL );
+		if ( pm->ps->legsAnim == BOTH_HANG_IDLE )
+		{
+			if ( pm->ps->torsoAnimTimer < 100 )
+			{
+				pm->ps->torsoAnimTimer = 100;
+			}
+			if ( pm->ps->legsAnimTimer < 100 )
+			{
+				pm->ps->legsAnimTimer = 100;
+			}
+		}
+		return;
+	}
+
+	if ( PM_SpinningSaberAnim( pm->ps->legsAnim ) && pm->ps->legsAnimTimer )
+	{//spinning
+		return;
+	}
+	if ( PM_InKnockDown( pm->ps ) || PM_InRoll( pm->ps ))
+	{//in knockdown
+		return;
+	}
+	if ( (pm->ps->eFlags&EF_FORCE_DRAINED) )
+	{//being drained
+		//PM_SetAnim( pm, SETANIM_LEGS, BOTH_HUGGEE1, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+		return;
+	}
+	if ( (pm->ps->forcePowersActive&(1<<FP_DRAIN)) 
+		&& pm->ps->forceDrainEntityNum < ENTITYNUM_WORLD )
+	{//draining
+		//PM_SetAnim( pm, SETANIM_LEGS, BOTH_HUGGER1, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+		return;
+	}
+	else if (pm->gent->NPC && pm->gent->NPC->aiFlags & NPCAI_KNEEL)
+	{//kneeling
+		return;
+	}
+
+	if( pm->gent->NPC != NULL )
+	{
+		validNPC = qtrue;
+	}
+
+	pm->gent->client->renderInfo.legsFpsMod = 1.0f;
+	//PM_ResetAnkleAngles();
+
+	//
+	// calculate speed and cycle to be used for
+	// all cyclic walking effects
+	//
+	pm->xyspeed = sqrt( pm->ps->velocity[0] * pm->ps->velocity[0]
+		+  pm->ps->velocity[1] * pm->ps->velocity[1] );
+
+	if ( pm->ps->legsAnim == BOTH_FLIP_F ||
+		pm->ps->legsAnim == BOTH_FLIP_B ||
+		pm->ps->legsAnim == BOTH_FLIP_L ||
+		pm->ps->legsAnim == BOTH_FLIP_R ||
+		pm->ps->legsAnim == BOTH_ALORA_FLIP_1 ||
+		pm->ps->legsAnim == BOTH_ALORA_FLIP_2 ||
+		pm->ps->legsAnim == BOTH_ALORA_FLIP_3 )
+	{
+		flipping = qtrue;
+	}
+
+	if ( pm->ps->groundEntityNum == ENTITYNUM_NONE 
+		|| ( pm->watertype & CONTENTS_LADDER ) 
+		|| pm->ps->waterHeightLevel >= WHL_TORSO ) 
+	{//in air or submerged in water or in ladder
+		// airborne leaves position in cycle intact, but doesn't advance
+		if ( pm->waterlevel > 0 ) 
+		{
+			if ( pm->watertype & CONTENTS_LADDER ) 
+			{//FIXME: check for watertype, save waterlevel for whether to play
+				//the get off ladder transition anim!
+				if ( pm->ps->velocity[2]  ) 
+				{//going up or down it
+					int	anim;
+					if ( pm->ps->velocity[2] > 0 )
+					{
+						anim = BOTH_LADDER_UP1;
+					}
+					else
+					{
+						anim = BOTH_LADDER_DWN1;
+					}
+					PM_SetAnim( pm, SETANIM_LEGS, anim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+					if ( pm->waterlevel >= 2 )	//arms on ladder
+					{
+						PM_SetAnim( pm, SETANIM_TORSO, anim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+					}
+					if (fabs(pm->ps->velocity[2]) >5) {
+						bobmove = 0.005 * fabs(pm->ps->velocity[2]);	// climbing bobs slow
+						if (bobmove > 0.3)
+							bobmove = 0.3F;
+						goto DoFootSteps;
+					}
+				}
+				else
+				{
+					PM_SetAnim( pm, SETANIM_LEGS, BOTH_LADDER_IDLE, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD|SETANIM_FLAG_RESTART );
+					pm->ps->legsAnimTimer += 300;
+					if ( pm->waterlevel >= 2 )	//arms on ladder
+					{
+						PM_SetAnim( pm, SETANIM_TORSO, BOTH_LADDER_IDLE, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD|SETANIM_FLAG_RESTART );
+						pm->ps->torsoAnimTimer += 300;
+					}
+				}
+				return;
+			}
+			else if ( pm->ps->waterHeightLevel >= WHL_TORSO 
+				&& ((pm->ps->clientNum < MAX_CLIENTS||PM_ControlledByPlayer())
+					||pm->ps->weapon==WP_SABER||pm->ps->weapon==WP_NONE||pm->ps->weapon==WP_MELEE) )//pm->waterlevel > 1 )	//in deep water
+			{
+				if ( !PM_ForceJumpingUp( pm->gent ) )
+				{
+					if ( pm->ps->groundEntityNum != ENTITYNUM_NONE && (pm->ps->pm_flags&PMF_DUCKED) ) 
+					{
+						if ( !flipping )
+						{//you can crouch under water if feet are on ground
+							if ( pm->cmd.forwardmove || pm->cmd.rightmove )
+							{
+								if ( pm->ps->pm_flags & PMF_BACKWARDS_RUN ) 
+								{
+									PM_SetAnim(pm,SETANIM_LEGS,BOTH_CROUCH1WALKBACK,setAnimFlags);
+								}
+								else
+								{
+									PM_SetAnim(pm,SETANIM_LEGS,BOTH_CROUCH1WALK,setAnimFlags);
+								}
+							}
+							else
+							{
+								PM_SetAnim(pm,SETANIM_LEGS,BOTH_CROUCH1,SETANIM_FLAG_NORMAL);
+							}
+							return;
+						}
+					}
+					PM_SwimFloatAnim();
+					if ( pm->ps->legsAnim != BOTH_SWIM_IDLE1 )
+					{//moving
+						old = pm->ps->bobCycle;
+						bobmove = 0.15f;	// swim is a slow cycle
+						pm->ps->bobCycle = (int)( old + bobmove * pml.msec ) & 255;
+
+						// if we just crossed a cycle boundary, play an apropriate footstep event
+						if ( ( ( old + 64 ) ^ ( pm->ps->bobCycle + 64 ) ) & 128 ) 
+						{
+							PM_AddEvent( EV_SWIM );
+						}
+					}
+				}
+				return;
+			}
+			else 
+			{//hmm, in water, but not high enough to swim
+				//fall through to walk/run/stand
+				if ( pm->ps->groundEntityNum == ENTITYNUM_NONE )
+				{//unless in the air
+					//NOTE: this is a dupe of the code just below... for when you are not in the water at all
+					if ( pm->ps->pm_flags & PMF_DUCKED ) 
+					{
+						if ( !flipping )
+						{
+							PM_SetAnim(pm,SETANIM_LEGS,BOTH_CROUCH1,SETANIM_FLAG_NORMAL);
+						}
+					}
+					else if ( pm->ps->gravity <= 0 )//FIXME: or just less than normal?
+					{
+						if ( pm->gent 
+							&& pm->gent->client 
+							&& (pm->gent->client->NPC_class == CLASS_BOBAFETT ||pm->gent->client->NPC_class == CLASS_ROCKETTROOPER)
+							&& pm->gent->client->moveType == MT_FLYSWIM )
+						{//flying around with jetpack
+							//do something else?
+							PM_JetPackAnim();
+						}
+						else
+						{
+							PM_SwimFloatAnim();
+						}
+					}
+					return;
+				}
+			}
+		}
+		else 
+		{
+			if ( pm->ps->pm_flags & PMF_DUCKED ) 
+			{
+				if ( !flipping )
+				{
+					PM_SetAnim(pm,SETANIM_LEGS,BOTH_CROUCH1,SETANIM_FLAG_NORMAL);
+				}
+			}
+			else if ( pm->ps->gravity <= 0 )//FIXME: or just less than normal?
+			{
+				if ( pm->gent 
+					&& pm->gent->client 
+					&& (pm->gent->client->NPC_class == CLASS_BOBAFETT||pm->gent->client->NPC_class == CLASS_ROCKETTROOPER)
+					&& pm->gent->client->moveType == MT_FLYSWIM )
+				{//flying around with jetpack
+					//do something else?
+					PM_JetPackAnim();
+				}
+				else
+				{
+					PM_SwimFloatAnim();
+				}
+			}
+			return;
+		}
+	}
+
+	if ( PM_SwimmingAnim( pm->ps->legsAnim ) && pm->waterlevel < 2 )
+	{//legs are in swim anim, and not swimming, be sure to override it
+		setAnimFlags |= SETANIM_FLAG_OVERRIDE;
+	}
+
+	// if not trying to move
+	if ( !pm->cmd.forwardmove && !pm->cmd.rightmove ) 
+	{
+		if ( pm->gent && pm->gent->client && pm->gent->client->NPC_class == CLASS_ATST )
+		{
+			if ( !PM_AdjustStandAnimForSlope() )
+			{
+				PM_SetAnim(pm,SETANIM_LEGS,BOTH_STAND1,SETANIM_FLAG_NORMAL);
+			}
+		}
+		else if ( pm->ps->pm_flags & PMF_DUCKED ) 
+		{
+			if( !PM_InOnGroundAnim( pm->ps ) )
+			{
+				if ( !PM_AdjustStandAnimForSlope() )
+				{
+					PM_SetAnim(pm,SETANIM_LEGS,BOTH_CROUCH1,SETANIM_FLAG_NORMAL);
+				}
+			}
+		} 
+		else
+		{
+			if ( pm->ps->legsAnimTimer && PM_LandingAnim( pm->ps->legsAnim ) )
+			{//still in a landing anim, let it play
+				return;
+			}
+			if ( pm->ps->legsAnimTimer 
+				&& (pm->ps->legsAnim == BOTH_THERMAL_READY
+					||pm->ps->legsAnim == BOTH_THERMAL_THROW
+					||pm->ps->legsAnim == BOTH_ATTACK10) )
+			{//still in a thermal anim, let it play
+				return;
+			}
+			qboolean saberInAir = qtrue;
+			if ( pm->ps->saberInFlight )
+			{//guiding saber
+				if ( PM_SaberInBrokenParry( pm->ps->saberMove ) || pm->ps->saberBlocked == BLOCKED_PARRY_BROKEN || PM_DodgeAnim( pm->ps->torsoAnim ) )
+				{//we're stuck in a broken parry
+					saberInAir = qfalse;
+				}
+				if ( pm->ps->saberEntityNum < ENTITYNUM_NONE && pm->ps->saberEntityNum > 0 )//player is 0
+				{//
+					if ( &g_entities[pm->ps->saberEntityNum] != NULL && g_entities[pm->ps->saberEntityNum].s.pos.trType == TR_STATIONARY )
+					{//fell to the ground and we're not trying to pull it back
+						saberInAir = qfalse;
+					}
+				}
+			}
+			if ( pm->gent && pm->gent->client && pm->gent->client->NPC_class == CLASS_GALAKMECH )
+			{//NOTE: stand1 is with the helmet retracted, stand1to2 is the helmet going into place
+				PM_SetAnim( pm, SETANIM_BOTH, BOTH_STAND2, SETANIM_FLAG_NORMAL );
+			}
+			else if ( pm->ps->weapon == WP_SABER 
+				&& pm->ps->saberInFlight 
+				&& saberInAir 
+				&& (!pm->ps->dualSabers || !pm->ps->saber[1].Active()))
+			{
+				if ( !PM_AdjustStandAnimForSlope() )
+				{
+					if ( pm->ps->legsAnim != BOTH_LOSE_SABER
+						|| !pm->ps->legsAnimTimer )
+					{
+						PM_SetAnim(pm,SETANIM_LEGS,BOTH_SABERPULL,SETANIM_FLAG_NORMAL);
+					}
+				}
+			}
+			else if ( (pm->ps->weapon == WP_SABER
+				&&pm->ps->SaberLength()>0
+				&&!pm->ps->saberInFlight
+				&&!PM_SaberDrawPutawayAnim( pm->ps->legsAnim )) )
+			{
+				if ( !PM_AdjustStandAnimForSlope() )
+				{
+					int legsAnim; 
+					if ( (pm->ps->torsoAnim == BOTH_SPINATTACK6 
+							|| pm->ps->torsoAnim == BOTH_SPINATTACK7
+							|| PM_SaberInAttack( pm->ps->saberMove ) 
+							|| PM_SaberInTransitionAny( pm->ps->saberMove ))
+						&& pm->ps->legsAnim != BOTH_FORCELONGLEAP_LAND
+						&& (pm->ps->groundEntityNum == ENTITYNUM_NONE//in air
+							|| (!PM_JumpingAnim( pm->ps->torsoAnim )&&!PM_InAirKickingAnim( pm->ps->torsoAnim ))) )//OR: on ground and torso not in a jump anim
+					{
+						legsAnim = pm->ps->torsoAnim;
+					}
+					else
+					{
+						switch ( pm->ps->saberAnimLevel )
+						{
+						case SS_FAST:
+						case SS_TAVION:
+							legsAnim = BOTH_SABERFAST_STANCE;
+							break;
+						case SS_STRONG:
+							legsAnim = BOTH_SABERSLOW_STANCE;
+							break;
+						case SS_DUAL:
+							legsAnim = BOTH_SABERDUAL_STANCE;
+							break;
+						case SS_STAFF:
+							legsAnim = BOTH_SABERSTAFF_STANCE;
+							break;
+						case SS_NONE:
+						case SS_MEDIUM:
+						case SS_DESANN:
+						default:
+							legsAnim = BOTH_STAND2;
+							break;
+						}
+					}
+					PM_SetAnim(pm,SETANIM_LEGS,legsAnim,SETANIM_FLAG_NORMAL);
+				}
+			}
+			else if( (validNPC && pm->ps->weapon > WP_SABER && pm->ps->weapon < WP_DET_PACK ))// && pm->gent->client->race != RACE_BORG))//Being careful or carrying a 2-handed weapon
+			{//Squadmates use BOTH_STAND3
+				oldAnim = pm->ps->legsAnim;
+				if(oldAnim != BOTH_GUARD_LOOKAROUND1 && oldAnim != BOTH_GUARD_IDLE1 
+					&& oldAnim != BOTH_STAND2TO4 
+					&& oldAnim != BOTH_STAND4TO2 && oldAnim != BOTH_STAND4 )
+				{//Don't auto-override the guard idles
+					if ( !PM_AdjustStandAnimForSlope() )
+					{
+						PM_SetAnim(pm,SETANIM_LEGS,BOTH_STAND3,SETANIM_FLAG_NORMAL);
+						//if(oldAnim != BOTH_STAND2 && pm->ps->legsAnim == BOTH_STAND2)
+						//{
+						//	pm->ps->legsAnimTimer = 500;
+						//}
+					}
+				}
+			}
+			else
+			{
+				if ( !PM_AdjustStandAnimForSlope() )
+				{
+					// FIXME: Do we need this here... The imps stand is 4, not 1...
+					if ( pm->gent && pm->gent->client && pm->gent->client->NPC_class == CLASS_IMPERIAL )
+					{
+						PM_SetAnim(pm,SETANIM_LEGS,BOTH_STAND4,SETANIM_FLAG_NORMAL);
+					}
+					else if ( pm->ps->weapon == WP_TUSKEN_STAFF )
+					{
+						PM_SetAnim(pm,SETANIM_LEGS,BOTH_STAND1,SETANIM_FLAG_NORMAL);
+					}
+					else
+					{
+						if ( pm->gent && pm->gent->client && pm->gent->client->NPC_class == CLASS_RANCOR )
+						{
+							if ( pm->gent->count )
+							{
+								PM_SetAnim(pm,SETANIM_LEGS,BOTH_STAND4,SETANIM_FLAG_NORMAL);
+							}
+							else if ( pm->gent->enemy || pm->gent->wait )
+							{//have an enemy or have had one since we spawned
+								PM_SetAnim(pm,SETANIM_LEGS,BOTH_STAND2,SETANIM_FLAG_NORMAL);
+							}
+							else
+							{
+								PM_SetAnim(pm,SETANIM_LEGS,BOTH_STAND1,SETANIM_FLAG_NORMAL);
+							}
+						}
+						else if ( pm->gent && pm->gent->client && pm->gent->client->NPC_class == CLASS_WAMPA )
+						{
+							if ( pm->gent->count )
+							{//holding a victim
+								PM_SetAnim(pm,SETANIM_LEGS,BOTH_HOLD_IDLE/*BOTH_STAND2*/,SETANIM_FLAG_NORMAL);
+							}
+							else
+							{//not holding a victim
+								PM_SetAnim(pm,SETANIM_LEGS,BOTH_STAND1,SETANIM_FLAG_NORMAL);
+							}
+						}
+						else
+						{
+							PM_SetAnim(pm,SETANIM_LEGS,BOTH_STAND1,SETANIM_FLAG_NORMAL);
+						}
+					}
+				}
+			}
+		}
+		return;
+	}
+	
+	//maybe call this every frame, even when moving?
+	if ( pm->gent && pm->gent->client && pm->gent->client->NPC_class == CLASS_ATST )
+	{
+		PM_FootSlopeTrace( NULL, NULL );
+	}
+
+	//trying to move laterally
+	if ( (pm->ps->eFlags&EF_IN_ATST)
+		|| (pm->gent&&pm->gent->client&&pm->gent->client->NPC_class==CLASS_RANCOR)//does this catch NPCs, too?
+		|| (pm->gent&&pm->gent->client&&pm->gent->client->NPC_class==CLASS_WAMPA) )//does this catch NPCs, too?
+	{//atst, Rancor & Wampa, only override turn anims on legs (no torso)
+		if ( pm->ps->legsAnim == BOTH_TURN_LEFT1 ||
+				pm->ps->legsAnim == BOTH_TURN_RIGHT1 )
+		{//moving overrides turning
+			setAnimFlags |= SETANIM_FLAG_OVERRIDE;
+		}
+	}
+	else
+	{//all other NPCs...
+		if ( (PM_InSaberAnim( pm->ps->legsAnim ) && !PM_SpinningSaberAnim( pm->ps->legsAnim )) 
+			|| PM_SaberStanceAnim( pm->ps->legsAnim )
+			|| PM_SaberDrawPutawayAnim( pm->ps->legsAnim )
+			|| pm->ps->legsAnim == BOTH_SPINATTACK6//not a full-body spin, just spinning the saber
+			|| pm->ps->legsAnim == BOTH_SPINATTACK7//not a full-body spin, just spinning the saber
+			|| pm->ps->legsAnim == BOTH_BUTTON_HOLD
+			|| pm->ps->legsAnim == BOTH_BUTTON_RELEASE
+			|| pm->ps->legsAnim == BOTH_THERMAL_READY
+			|| pm->ps->legsAnim == BOTH_THERMAL_THROW
+			|| pm->ps->legsAnim == BOTH_ATTACK10
+			|| PM_LandingAnim( pm->ps->legsAnim ) 
+			|| PM_PainAnim( pm->ps->legsAnim ) 
+			|| PM_ForceAnim( pm->ps->legsAnim ))
+		{//legs are in a saber anim, and not spinning, be sure to override it
+			setAnimFlags |= SETANIM_FLAG_OVERRIDE;
+		}
+	}
+
+	if ( pm->ps->pm_flags & PMF_DUCKED ) 
+	{
+		bobmove = 0.5;	// ducked characters bob much faster
+		if( !PM_InOnGroundAnim( pm->ps ) //not on the ground
+			&& ( !PM_InRollIgnoreTimer( pm->ps )||(!pm->ps->legsAnimTimer&&pm->cmd.upmove<0) ) )//not in a roll (or you just finished one and you're still holding crouch)
+		{
+			qboolean rolled = qfalse;
+			if ( PM_RunningAnim( pm->ps->legsAnim ) 
+				|| pm->ps->legsAnim == BOTH_FORCEHEAL_START
+				|| PM_CanRollFromSoulCal( pm->ps )) 
+			{//roll!
+				rolled = PM_TryRoll();
+			}
+			if ( !rolled )
+			{
+				if ( pm->ps->pm_flags & PMF_BACKWARDS_RUN ) 
+				{
+					PM_SetAnim(pm,SETANIM_LEGS,BOTH_CROUCH1WALKBACK,setAnimFlags);
+				}
+				else
+				{
+					PM_SetAnim(pm,SETANIM_LEGS,BOTH_CROUCH1WALK,setAnimFlags);
+				}
+				if ( !Q_irand( 0, 19 ) )
+				{//5% chance of making an alert
+					AddSoundEvent( pm->gent, pm->ps->origin, 16, AEL_MINOR, qtrue, qtrue );
+				}
+			}
+			else
+			{//rolling is a little noisy
+				AddSoundEvent( pm->gent, pm->ps->origin, 128, AEL_MINOR, qtrue, qtrue );
+			}
+		}
+		// ducked characters never play footsteps
+	}
+	else if ( pm->ps->pm_flags & PMF_BACKWARDS_RUN ) 
+	{//Moving backwards
+		if ( !( pm->cmd.buttons & BUTTON_WALKING ) ) 
+		{//running backwards
+			bobmove = 0.4F;	// faster speeds bob faster
+			if ( pm->ps->weapon == WP_SABER && pm->ps->SaberActive() )
+			{
+				/*
+				if ( pm->ps->saberAnimLevel == SS_STAFF )
+				{
+					PM_SetAnim(pm,SETANIM_LEGS,BOTH_RUNBACK_STAFF,setAnimFlags);
+				}
+				else
+				*/
+				{
+					PM_SetAnim(pm,SETANIM_LEGS,BOTH_RUNBACK2,setAnimFlags);
+				}
+			}
+			else if ( pm->gent && pm->gent->client && pm->gent->client->NPC_class == CLASS_RANCOR )
+			{//no run anim
+				PM_SetAnim(pm,SETANIM_LEGS,BOTH_WALKBACK1,setAnimFlags);
+			}
+			else
+			{
+				PM_SetAnim(pm,SETANIM_LEGS,BOTH_RUNBACK1,setAnimFlags);
+			}
+			footstep = qtrue;
+		} 
+		else 
+		{//walking backwards
+			bobmove = 0.3F;	// faster speeds bob faster
+			if ( pm->ps->weapon == WP_SABER && pm->ps->SaberActive() )
+			{
+				if ( pm->ps->saberAnimLevel == SS_DUAL )
+				{
+					PM_SetAnim(pm,SETANIM_LEGS,BOTH_WALKBACK_DUAL,setAnimFlags);
+				}
+				else if ( pm->ps->saberAnimLevel == SS_STAFF )
+				{
+					PM_SetAnim(pm,SETANIM_LEGS,BOTH_WALKBACK_STAFF,setAnimFlags);
+				}
+				else
+				{
+					PM_SetAnim(pm,SETANIM_LEGS,BOTH_WALKBACK2,setAnimFlags);
+				}
+			}
+			else
+			{
+				PM_SetAnim(pm,SETANIM_LEGS,BOTH_WALKBACK1,setAnimFlags);
+			}
+			if ( !Q_irand( 0, 9 ) )
+			{//10% chance of a small alert, mainly for the sand_creature
+				AddSoundEvent( pm->gent, pm->ps->origin, 16, AEL_MINOR, qtrue, qtrue );
+			}
+		}
+	}
+	else 
+	{
+		if ( pm->gent && pm->gent->client && pm->gent->client->NPC_class == CLASS_GALAKMECH )
+		{
+			bobmove = 0.3F;	// walking bobs slow
+			if ( pm->ps->weapon == WP_NONE )
+			{//helmet retracted
+				PM_SetAnim( pm, SETANIM_BOTH, BOTH_WALK1, SETANIM_FLAG_NORMAL );
+			}
+			else
+			{//helmet in place
+				PM_SetAnim( pm, SETANIM_BOTH, BOTH_WALK2, SETANIM_FLAG_NORMAL );
+			}
+			AddSoundEvent( pm->gent, pm->ps->origin, 128, AEL_SUSPICIOUS, qtrue, qtrue );
+		}
+		else
+		{
+			if ( !( pm->cmd.buttons & BUTTON_WALKING ) ) 
+			{//running
+				bobmove = 0.4F;	// faster speeds bob faster
+				if ( pm->ps->weapon == WP_SABER && pm->ps->SaberActive() )
+				{
+					if ( pm->ps->saberAnimLevel == SS_DUAL )
+					{
+						PM_SetAnim(pm,SETANIM_LEGS,BOTH_RUN_DUAL,setAnimFlags);
+					}
+					else if ( pm->ps->saberAnimLevel == SS_STAFF )
+					{
+						PM_SetAnim(pm,SETANIM_LEGS,BOTH_RUN_STAFF,setAnimFlags);
+					}
+					else
+					{
+						PM_SetAnim(pm,SETANIM_LEGS,BOTH_RUN2,setAnimFlags);
+					}
+				}
+				else
+				{
+					if ( pm->gent && pm->gent->client && pm->gent->client->NPC_class == CLASS_JAWA )
+					{
+						//if ( pm->gent->enemy && (pm->ps->weapon == WP_NONE || pm->ps->weapon == WP_MELEE) )
+						{
+							PM_SetAnim(pm,SETANIM_LEGS,BOTH_RUN4,setAnimFlags);
+						}
+						/*
+						else
+						{
+							PM_SetAnim(pm,SETANIM_LEGS,BOTH_RUN1,setAnimFlags);
+						}
+						*/
+					}
+					else if ( pm->gent && pm->gent->client && pm->gent->client->NPC_class == CLASS_ATST )
+					{
+						if ( pm->ps->legsAnim != BOTH_RUN1 )
+						{
+							if ( pm->ps->legsAnim != BOTH_RUN1START )
+							{//Hmm, he should really start slow and have to accelerate... also need to do this for stopping
+								PM_SetAnim( pm,SETANIM_LEGS, BOTH_RUN1START, setAnimFlags|SETANIM_FLAG_HOLD );
+							}
+							else if ( !pm->ps->legsAnimTimer )
+							{
+								PM_SetAnim( pm, SETANIM_LEGS, BOTH_RUN1, setAnimFlags );
+							}
+						}
+						else
+						{
+							PM_SetAnim( pm, SETANIM_LEGS, BOTH_RUN1, setAnimFlags );
+						}
+					}
+					else if ( pm->gent && pm->gent->client && pm->gent->client->NPC_class == CLASS_WAMPA )
+					{
+						if ( pm->gent->NPC && pm->gent->NPC->stats.runSpeed == 300 )
+						{//full on run, on all fours
+							PM_SetAnim(pm,SETANIM_LEGS,BOTH_RUN1,SETANIM_FLAG_NORMAL);
+						}
+						else
+						{//regular, upright run
+							PM_SetAnim(pm,SETANIM_LEGS,BOTH_RUN2,SETANIM_FLAG_NORMAL);
+						}
+					}
+					else if ( pm->gent && pm->gent->client && pm->gent->client->NPC_class == CLASS_RANCOR )
+					{//no run anim
+						PM_SetAnim( pm, SETANIM_LEGS, BOTH_WALK1, setAnimFlags );
+					}
+					else
+					{
+						PM_SetAnim( pm, SETANIM_LEGS, BOTH_RUN1, setAnimFlags );
+					}
+				}
+				footstep = qtrue;
+			} 
+			else 
+			{//walking forward
+				bobmove = 0.3F;	// walking bobs slow
+				if ( pm->ps->weapon == WP_SABER && pm->ps->SaberActive() )
+				{
+					if ( pm->ps->saberAnimLevel == SS_DUAL )
+					{
+						PM_SetAnim(pm,SETANIM_LEGS,BOTH_WALK_DUAL,setAnimFlags);
+					}
+					else if ( pm->ps->saberAnimLevel == SS_STAFF )
+					{
+						PM_SetAnim(pm,SETANIM_LEGS,BOTH_WALK_STAFF,setAnimFlags);
+					}
+					else
+					{
+						PM_SetAnim(pm,SETANIM_LEGS,BOTH_WALK2,setAnimFlags);
+					}
+				}
+				else if ( pm->gent && pm->gent->client && pm->gent->client->NPC_class == CLASS_WAMPA )
+				{
+					if ( pm->gent->health <= 50 )
+					{//hurt walk
+						PM_SetAnim(pm,SETANIM_LEGS,BOTH_WALK2,SETANIM_FLAG_NORMAL);
+					}
+					else
+					{//normal walk
+						PM_SetAnim(pm,SETANIM_LEGS,BOTH_WALK1,SETANIM_FLAG_NORMAL);
+					}
+				}
+				else
+				{
+					PM_SetAnim(pm,SETANIM_LEGS,BOTH_WALK1,setAnimFlags);
+				}
+				//Enemy NPCs always make footsteps for the benefit of the player
+				if ( pm->gent 
+					&& pm->gent->NPC 
+					&& pm->gent->client 
+					&& pm->gent->client->playerTeam != TEAM_PLAYER )
+				{
+					footstep = qtrue;
+				}
+				else if ( !Q_irand( 0, 9 ) )
+				{//10% chance of a small alert, mainly for the sand_creature
+					AddSoundEvent( pm->gent, pm->ps->origin, 16, AEL_MINOR, qtrue, qtrue );
+				}
+			}
+		}
+	}
+
+	if(pm->gent != NULL)
+	{
+		if( pm->gent->client->renderInfo.legsFpsMod > 2 )
+		{
+			pm->gent->client->renderInfo.legsFpsMod = 2;
+		}
+		else if(pm->gent->client->renderInfo.legsFpsMod < 0.5)
+		{
+			pm->gent->client->renderInfo.legsFpsMod = 0.5;
+		}
+	}
+
+DoFootSteps:
+
+	// check for footstep / splash sounds
+	old = pm->ps->bobCycle;
+	pm->ps->bobCycle = (int)( old + bobmove * pml.msec ) & 255;
+
+	// if we just crossed a cycle boundary, play an apropriate footstep event
+	if ( ( ( old + 64 ) ^ ( pm->ps->bobCycle + 64 ) ) & 128 ) 
+	{
+		if ( pm->watertype & CONTENTS_LADDER ) 
+		{
+			if ( !pm->noFootsteps ) 
+			{
+				if (pm->ps->groundEntityNum == ENTITYNUM_NONE) {// on ladder
+					 PM_AddEvent( EV_FOOTSTEP_METAL );
+				} else {
+					//PM_AddEvent( PM_FootstepForSurface() );	//still on ground
+				}
+			}
+			if ( pm->gent && pm->gent->s.number == 0 ) 
+			{
+//					if ( pm->gent->client && pm->gent->client->playerTeam != TEAM_DISGUISE )
+				{
+					AddSoundEvent( pm->gent, pm->ps->origin, 128, AEL_MINOR, qtrue );
+				}
+			}
+		}
+		else if ( pm->waterlevel == 0 ) 
+		{
+			// on ground will only play sounds if running
+			if ( footstep )
+			{
+				if ( !pm->noFootsteps ) 
+				{
+					//PM_AddEvent( PM_FootstepForSurface() );
+				}
+				if ( pm->gent && pm->gent->s.number == 0 ) 
+				{
+					vec3_t	bottom;
+
+					VectorCopy( pm->ps->origin, bottom );
+					bottom[2] += pm->mins[2];
+//					if ( pm->gent->client && pm->gent->client->playerTeam != TEAM_DISGUISE )
+					{
+						AddSoundEvent( pm->gent, bottom, 256, AEL_MINOR, qtrue, qtrue );
+					}
+				}
+			}
+		} 
+		else if ( pm->waterlevel == 1 ) 
+		{
+			// splashing
+			if ( pm->ps->waterHeightLevel >= WHL_KNEES )
+			{
+				PM_AddEvent( EV_FOOTWADE );
+			}
+			else
+			{
+				PM_AddEvent( EV_FOOTSPLASH );
+			}
+			if ( pm->gent && pm->gent->s.number == 0 ) 
+			{
+				vec3_t	bottom;
+
+				VectorCopy( pm->ps->origin, bottom );
+				bottom[2] += pm->mins[2];
+//				if ( pm->gent->client && pm->gent->client->playerTeam != TEAM_DISGUISE )
+				{
+					AddSoundEvent( pm->gent, pm->ps->origin, 384, AEL_SUSPICIOUS, qfalse, qtrue );//was bottom
+					AddSightEvent( pm->gent, pm->ps->origin, 512, AEL_MINOR );
+				}
+			}
+		} 
+		else if ( pm->waterlevel == 2 ) 
+		{
+			// wading / swimming at surface
+			/*
+			if ( pm->ps->waterHeightLevel >= WHL_TORSO )
+			{
+				PM_AddEvent( EV_SWIM );
+			}
+			else
+			*/
+			{
+				PM_AddEvent( EV_FOOTWADE );
+			}
+			if ( pm->gent && pm->gent->s.number == 0 ) 
+			{
+//				if ( pm->gent->client && pm->gent->client->playerTeam != TEAM_DISGUISE )
+				{
+					AddSoundEvent( pm->gent, pm->ps->origin, 256, AEL_MINOR, qfalse, qtrue );
+					AddSightEvent( pm->gent, pm->ps->origin, 512, AEL_SUSPICIOUS );
+				}
+			}
+		}
+		else
+		{// or no sound when completely underwater...?
+			PM_AddEvent( EV_SWIM );
+		}
+	}
+}
+
+/*
+==============
+PM_WaterEvents
+
+Generate sound events for entering and leaving water
+==============
+*/
+static void PM_WaterEvents( void ) {		// FIXME?
+	
+	qboolean impact_splash = qfalse;
+
+	if ( pm->watertype & CONTENTS_LADDER )	//fake water for ladder
+	{
+		return;
+	}
+	//
+	// if just entered a water volume, play a sound
+	//
+	if (!pml.previous_waterlevel && pm->waterlevel)
+	{
+		if ( (pm->watertype&CONTENTS_LAVA) )
+		{
+			PM_AddEvent( EV_LAVA_TOUCH );
+		}
+		else
+		{
+			PM_AddEvent( EV_WATER_TOUCH );
+		}
+		if ( pm->gent )
+		{
+			if ( VectorLengthSquared( pm->ps->velocity ) > 40000 )
+			{
+				impact_splash = qtrue;
+			}
+
+			if ( pm->ps->clientNum < MAX_CLIENTS )
+			{
+				AddSoundEvent( pm->gent, pm->ps->origin, 384, AEL_SUSPICIOUS );
+				AddSightEvent( pm->gent, pm->ps->origin, 512, AEL_SUSPICIOUS );
+			}
+		}
+	}
+
+	//
+	// if just completely exited a water volume, play a sound
+	//
+	if (pml.previous_waterlevel && !pm->waterlevel)
+	{
+		if ( (pm->watertype&CONTENTS_LAVA) )
+		{
+			PM_AddEvent( EV_LAVA_LEAVE );
+		}
+		else
+		{
+			PM_AddEvent( EV_WATER_LEAVE );
+		}
+		if ( pm->gent && VectorLengthSquared( pm->ps->velocity ) > 40000 )
+		{
+			impact_splash = qtrue;
+		}
+		if ( pm->gent && pm->ps->clientNum < MAX_CLIENTS )
+		{
+			AddSoundEvent( pm->gent, pm->ps->origin, 384, AEL_SUSPICIOUS );
+			AddSightEvent( pm->gent, pm->ps->origin, 512, AEL_SUSPICIOUS );
+		}
+	}
+
+	if ( impact_splash )
+	{
+		//play the splash effect
+		trace_t	tr;
+		vec3_t	axis[3], angs, start, end;
+
+		VectorSet( angs, 0, pm->gent->currentAngles[YAW], 0 );
+		AngleVectors( angs, axis[2], axis[1], axis[0] );
+
+		VectorCopy( pm->ps->origin, start );
+		VectorCopy( pm->ps->origin, end );
+
+		// FIXME: set start and end better
+		start[2] += 10;
+		end[2] -= 40;
+
+		gi.trace( &tr, start, vec3_origin, vec3_origin, end, pm->gent->s.number, MASK_WATER );
+
+		if ( tr.fraction < 1.0f )
+		{
+			if ( (tr.contents&CONTENTS_LAVA) )
+			{
+				G_PlayEffect( "env/lava_splash", tr.endpos, axis );
+			}
+			else if ( (tr.contents&CONTENTS_SLIME) )
+			{
+				G_PlayEffect( "env/acid_splash", tr.endpos, axis );
+			}
+			else //must be water
+			{
+				G_PlayEffect( "env/water_impact", tr.endpos, axis );
+			}
+		}
+	}
+
+	//
+	// check for head just going under water
+	//
+	if (pml.previous_waterlevel != 3 && pm->waterlevel == 3) {
+		if ( (pm->watertype&CONTENTS_LAVA) )
+		{
+			PM_AddEvent( EV_LAVA_UNDER );
+		}
+		else
+		{
+			PM_AddEvent( EV_WATER_UNDER );
+		}
+
+		if ( pm->gent && pm->ps->clientNum < MAX_CLIENTS )
+		{
+			AddSoundEvent( pm->gent, pm->ps->origin, 256, AEL_MINOR );
+			AddSightEvent( pm->gent, pm->ps->origin, 384, AEL_MINOR );
+		}
+	}
+
+	//
+	// check for head just coming out of water
+	//
+	if (pml.previous_waterlevel == 3 && pm->waterlevel != 3) {
+		if ( !pm->gent || !pm->gent->client || pm->gent->client->airOutTime < level.time + 2000 )
+		{//only do this if we were drowning or about to start drowning
+			PM_AddEvent( EV_WATER_CLEAR );
+		}
+		else
+		{
+			if ( (pm->watertype&CONTENTS_LAVA) )
+			{
+				PM_AddEvent( EV_LAVA_LEAVE );
+			}
+			else
+			{
+				PM_AddEvent( EV_WATER_LEAVE );
+			}
+		}
+		if ( pm->gent && pm->ps->clientNum < MAX_CLIENTS )
+		{
+			AddSoundEvent( pm->gent, pm->ps->origin, 256, AEL_MINOR );
+			AddSightEvent( pm->gent, pm->ps->origin, 384, AEL_SUSPICIOUS );
+		}
+	}
+}
+
+
+/*
+===============
+PM_BeginWeaponChange
+===============
+*/
+static void PM_BeginWeaponChange( int weapon ) {
+
+	if ( pm->gent && pm->gent->client && pm->gent->client->pers.enterTime >= level.time - 500 )
+	{//just entered map
+		if ( weapon == WP_NONE && pm->ps->weapon != weapon )
+		{//don't switch to weapon none if just entered map
+			return;
+		}
+	}
+
+	if ( weapon < WP_NONE || weapon >= WP_NUM_WEAPONS ) {
+		return;
+	}
+
+	if ( !( pm->ps->stats[STAT_WEAPONS] & ( 1 << weapon ) ) ) {
+		return;
+	}
+	
+	if ( pm->ps->weaponstate == WEAPON_DROPPING ) {
+		return;
+	}
+
+	if ( cg.time > 0 )
+	{//this way we don't get that annoying change weapon sound every time a map starts
+		PM_AddEvent( EV_CHANGE_WEAPON );
+	}
+
+	pm->ps->weaponstate = WEAPON_DROPPING;
+	pm->ps->weaponTime += 200;
+	if ( !(pm->ps->eFlags&EF_HELD_BY_WAMPA) && !G_IsRidingVehicle(pm->gent))
+	{
+		PM_SetAnim(pm,SETANIM_TORSO,TORSO_DROPWEAP1,SETANIM_FLAG_HOLD);
+	}
+
+	// turn of any kind of zooming when weapon switching....except the LA Goggles
+	if ( pm->ps->clientNum == 0 )
+	{
+		if ( cg.zoomMode > 0 && cg.zoomMode < 3 )
+		{
+			cg.zoomMode = 0;
+			cg.zoomTime = cg.time;
+		}
+	}
+
+	if ( pm->gent 
+		&& pm->gent->client 
+		&& (pm->gent->client->NPC_class == CLASS_ATST||pm->gent->client->NPC_class == CLASS_RANCOR) )
+	{
+		if ( pm->ps->clientNum < MAX_CLIENTS )
+		{
+			gi.cvar_set( "cg_thirdperson", "1" );
+		}
+	}
+	else if ( weapon == WP_SABER )
+	{//going to switch to lightsaber
+	}
+	else
+	{
+		if ( pm->ps->weapon == WP_SABER ) 
+		{//going to switch away from saber
+			if ( pm->gent )
+			{
+				G_SoundOnEnt( pm->gent, CHAN_WEAPON, "sound/weapons/saber/saberoffquick.wav" );
+#ifdef _IMMERSION
+				G_Force( pm->gent, G_ForceIndex( "fffx/weapons/saber/saberoffquick", FF_CHANNEL_WEAPON ) );
+#endif // _IMMERSION
+			}
+			if (!G_IsRidingVehicle(pm->gent))
+			{
+				PM_SetSaberMove(LS_PUTAWAY);
+			}
+		}
+		//put this back in because saberActive isn't being set somewhere else anymore
+		pm->ps->SaberDeactivate();
+		pm->ps->SetSaberLength( 0.0f );
+	}
+}
+
+
+/*
+===============
+PM_FinishWeaponChange
+===============
+*/
+static void PM_FinishWeaponChange( void ) {
+	int		weapon;
+	qboolean	trueSwitch = qtrue;
+
+	if ( pm->gent && pm->gent->client && pm->gent->client->pers.enterTime >= level.time - 500 )
+	{//just entered map
+		if ( pm->cmd.weapon == WP_NONE && pm->ps->weapon != pm->cmd.weapon )
+		{//don't switch to weapon none if just entered map
+			return;
+		}
+	}
+	weapon = pm->cmd.weapon;
+	if ( weapon < WP_NONE || weapon >= WP_NUM_WEAPONS ) {
+		weapon = WP_NONE;
+	}
+
+	if ( !( pm->ps->stats[STAT_WEAPONS] & ( 1 << weapon ) ) ) {
+		weapon = WP_NONE;
+	}
+
+	if ( pm->ps->weapon == weapon )
+	{
+		trueSwitch = qfalse;
+	}
+	//int oldWeap = pm->ps->weapon;
+	pm->ps->weapon = weapon;
+	pm->ps->weaponstate = WEAPON_RAISING;
+	pm->ps->weaponTime += 250;
+
+	if ( pm->gent && pm->gent->client && pm->gent->client->NPC_class == CLASS_ATST )
+	{//do nothing
+	}
+	else if ( weapon == WP_SABER )
+	{//turn on the lightsaber
+		//FIXME: somehow sometimes I still end up with 2 weapons in hand... usually if I
+		//		cycle weapons fast enough that I end up in 1st person lightsaber, then
+		//		somehow throw the saber and switch to another weapon (all in 1st person),
+		//		making my saber drop to the ground... when I switch back to the saber, it
+		//		does not remove the current weapon model and then, when I pull the saber
+		//		back to my hand, I have 2 weaponModels active...?
+		if ( pm->gent )
+		{// remove gun if we had it.
+			G_RemoveWeaponModels( pm->gent );
+		}
+
+		if ( !pm->ps->saberInFlight || pm->ps->dualSabers )
+		{//if it's not in flight or lying around, turn it on!
+			//FIXME: AddSound/Sight Event
+			//FIXME: don't do this if just loaded a game
+			if ( trueSwitch )
+			{//actually did switch weapons, turn it on
+				if ( PM_RidingVehicle() )
+				{//only turn on the first saber's first blade...?
+					pm->ps->SaberBladeActivate( 0, 0 );
+				}
+				else
+				{
+					pm->ps->SaberActivate();
+				}
+				pm->ps->SetSaberLength( 0.0f );
+			}
+
+			if ( pm->gent )
+			{
+				WP_SaberAddG2SaberModels( pm->gent );
+			}
+		}
+		else
+		{//FIXME: pull it back to us?
+		}
+
+		if ( pm->gent )
+		{
+			WP_SaberInitBladeData( pm->gent );
+			if ( (pm->ps->clientNum < MAX_CLIENTS||PM_ControlledByPlayer()) )
+			{
+				gi.cvar_set( "cg_thirdperson", "1" );
+			}
+		}
+		if ( trueSwitch )
+		{//actually did switch weapons, play anim
+			if (!G_IsRidingVehicle(pm->gent))
+			{
+				PM_SetSaberMove(LS_DRAW);
+			}
+		}
+	}
+	else
+	{//switched away from saber
+		if ( pm->gent )
+		{
+			// remove the sabre if we had it.
+			G_RemoveWeaponModels( pm->gent );
+			if (weaponData[weapon].weaponMdl[0]) {	//might be NONE, so check if it has a model
+				G_CreateG2AttachedWeaponModel( pm->gent, weaponData[weapon].weaponMdl, pm->gent->handRBolt, 0 );
+			}
+		}
+
+		if ( !(pm->ps->eFlags&EF_HELD_BY_WAMPA) )
+		{
+			if ( pm->ps->weapon != WP_THERMAL
+				&& pm->ps->weapon != WP_TRIP_MINE
+				&& pm->ps->weapon != WP_DET_PACK 
+				&& !G_IsRidingVehicle(pm->gent))
+			{				 
+				PM_SetAnim(pm,SETANIM_TORSO,TORSO_RAISEWEAP1,SETANIM_FLAG_HOLD);
+			}
+		}
+
+		if ( pm->ps->clientNum < MAX_CLIENTS 
+			&& cg_gunAutoFirst.integer 
+			&& !PM_RidingVehicle()
+//			&& oldWeap == WP_SABER 
+			&& weapon != WP_NONE )
+		{
+			gi.cvar_set( "cg_thirdperson", "0" );
+		}
+		pm->ps->saberMove = LS_NONE;
+		pm->ps->saberBlocking = BLK_NO;
+		pm->ps->saberBlocked = BLOCKED_NONE;
+	}
+}
+
+int PM_ReadyPoseForSaberAnimLevel( void )
+{
+	int anim = BOTH_STAND2;
+ 	if (PM_RidingVehicle())
+	{
+		return -1;
+	}
+	switch ( pm->ps->saberAnimLevel )
+	{
+	case SS_DUAL:
+		anim = BOTH_SABERDUAL_STANCE;
+		break;
+	case SS_STAFF:
+		anim = BOTH_SABERSTAFF_STANCE;
+		break;
+	case SS_FAST:
+	case SS_TAVION:
+		anim = BOTH_SABERFAST_STANCE;
+		break;
+	case SS_STRONG:
+		anim = BOTH_SABERSLOW_STANCE;
+		break;
+	case SS_NONE:
+	case SS_MEDIUM:
+	case SS_DESANN:
+	default:
+		anim = BOTH_STAND2;
+		break;
+	}
+	return anim;
+}
+
+qboolean PM_CanDoDualDoubleAttacks( void )
+{
+	//NOTE: assumes you're using SS_DUAL style and have both sabers on...
+	if ( (pm->ps->clientNum < MAX_CLIENTS||PM_ControlledByPlayer()) )
+	{//player
+		return qtrue;
+	}
+	if ( pm->gent && pm->gent->NPC && pm->gent->NPC->rank >= Q_irand( RANK_LT_COMM, RANK_CAPTAIN+2 ) )
+	{//high-rank NPC
+		return qtrue;
+	}
+	if ( pm->gent && pm->gent->client && pm->gent->client->NPC_class == CLASS_ALORA )
+	{//Alora
+		return qtrue;
+	}
+	return qfalse;
+}
+
+void PM_SetJumped( float height, qboolean force )
+{
+	pm->ps->velocity[2] = height;
+	pml.groundPlane = qfalse;
+	pml.walking = qfalse;
+	pm->ps->groundEntityNum = ENTITYNUM_NONE;
+	pm->ps->pm_flags |= PMF_JUMP_HELD;
+	pm->ps->pm_flags |= PMF_JUMPING;
+	pm->cmd.upmove = 0;
+
+	if ( force )
+	{
+		pm->ps->jumpZStart = pm->ps->origin[2];
+		pm->ps->pm_flags |= PMF_SLOW_MO_FALL;
+		//start force jump
+		pm->ps->forcePowersActive |= (1<<FP_LEVITATION);
+		G_SoundOnEnt( pm->gent, CHAN_BODY, "sound/weapons/force/jump.wav" );
+	}
+	else
+	{
+		PM_AddEvent( EV_JUMP );
+	}
+}
+
+
+void PM_SetSaberMove(saberMoveName_t newMove)
+{
+	unsigned int setflags;
+	int	anim;
+	int parts = SETANIM_TORSO;
+	qboolean manualBlocking = qfalse;
+
+	if ( newMove < LS_NONE || newMove >= LS_MOVE_MAX )
+	{
+		assert(0);
+		return;
+	}
+
+	setflags = saberMoveData[newMove].animSetFlags;
+	anim = saberMoveData[newMove].animToUse;
+
+	if ( (pm->ps->eFlags&EF_HELD_BY_WAMPA) )
+	{//no anim
+		return;
+	}
+
+	if ( cg_debugSaber.integer&0x01 && (newMove != LS_READY) )
+	{
+		Com_Printf("SetSaberMove:  From '%s' to '%s'\n", 
+				saberMoveData[pm->ps->saberMove].name,
+				saberMoveData[newMove].name);
+	}			
+	
+	if ( newMove == LS_READY || newMove == LS_A_FLIP_STAB || newMove == LS_A_FLIP_SLASH )
+	{//finished with a kata (or in a special move) reset attack counter
+		pm->ps->saberAttackChainCount = 0;
+	}
+	else if ( PM_SaberInAttack( newMove ) )
+	{//continuing with a kata, increment attack counter
+		//FIXME: maybe some contextual/style-specific logic in here
+		pm->ps->saberAttackChainCount++;
+	}
+
+	if ( newMove == LS_READY )
+	{
+		if ( pm->ps->saberBlockingTime > cg.time )
+		{
+			manualBlocking = qtrue;
+			if ( pm->ps->saber[0].type == SABER_CLAW )
+			{
+				anim = BOTH_INAIR1;//FIXME: is there a better anim for this?
+			}
+			else if ( pm->ps->dualSabers && pm->ps->saber[1].Active() )
+			{
+				anim = BOTH_INAIR1;
+			}
+			else
+			{
+				anim = BOTH_P1_S1_T_;
+			}
+		}
+		else if ( pm->ps->saber[0].type == SABER_ARC )
+		{//FIXME: need it's own style?
+			anim = BOTH_SABERFAST_STANCE;
+		}
+		else if ( (pm->ps->dualSabers && pm->ps->saber[1].Active()) )
+		{
+			anim = BOTH_SABERDUAL_STANCE;
+		}
+		else if ( (pm->ps->SaberStaff() && (!pm->ps->saber[0].singleBladeStyle||pm->ps->saber[0].blade[1].active))//saber staff with more than first blade active
+			|| pm->ps->saber[0].type == SABER_ARC )
+		{
+			anim = BOTH_SABERSTAFF_STANCE;
+		}
+		else if ( pm->ps->saber[0].type == SABER_LANCE || pm->ps->saber[0].type == SABER_TRIDENT )
+		{//FIXME: need some 2-handed forward-pointing anim
+			anim = BOTH_STAND1;
+		}
+		else
+		{
+			anim = PM_ReadyPoseForSaberAnimLevel();
+		}
+	}
+	else if ( newMove == LS_DRAW )
+	{
+		if ( PM_RunningAnim( pm->ps->torsoAnim ) )
+		{
+			pm->ps->saberMove = newMove;
+			return;
+		}
+		if ( pm->ps->saber[0].style == SS_STAFF )
+		{
+			anim = BOTH_S1_S7;
+		}
+		else if ( pm->ps->dualSabers && pm->ps->saber[0].style == SS_NONE && pm->ps->saber[1].style == SS_NONE )
+		{
+			anim = BOTH_S1_S6;
+		}
+		if ( pm->ps->torsoAnim == BOTH_STAND1IDLE1 )
+		{
+			setflags |= SETANIM_FLAG_OVERRIDE;
+		}
+	}
+	else if ( newMove == LS_PUTAWAY )
+	{
+		if ( pm->ps->saber[0].style == SS_STAFF 
+			&& pm->ps->saber[0].blade[1].active )
+		{
+			anim = BOTH_S7_S1;
+		}
+		else if ( pm->ps->dualSabers 
+			&& pm->ps->saber[0].style == SS_NONE 
+			&& pm->ps->saber[1].style == SS_NONE 
+			&& pm->ps->saber[1].Active() )
+		{
+			anim = BOTH_S6_S1;
+		}
+		if ( PM_SaberStanceAnim( pm->ps->legsAnim ) && pm->ps->legsAnim != BOTH_STAND1 )
+		{
+			parts = SETANIM_BOTH;
+		}
+		else
+		{
+			if ( PM_RunningAnim( pm->ps->torsoAnim ) )
+			{
+				pm->ps->saberMove = newMove;
+				return;
+			}
+			parts = SETANIM_TORSO;
+		}
+		//FIXME: also dual
+	}
+	else if ( pm->ps->saberAnimLevel == SS_STAFF && newMove >= LS_S_TL2BR && newMove < LS_REFLECT_LL )
+	{//staff has an entirely new set of anims, besides special attacks
+		//FIXME: include ready and draw/putaway?
+		//FIXME: get hand-made bounces and deflections?
+		if ( newMove >= LS_V1_BR && newMove <= LS_REFLECT_LL )
+		{//there aren't 1-7, just 1, 6 and 7, so just set it
+			anim = BOTH_P7_S7_T_ + (anim-BOTH_P1_S1_T_);//shift it up to the proper set
+		}
+		else
+		{//add the appropriate animLevel
+			anim += (pm->ps->saberAnimLevel-FORCE_LEVEL_1) * SABER_ANIM_GROUP_SIZE;
+		}
+	}
+	else if ( (pm->ps->saberAnimLevel == SS_DUAL 
+				|| (pm->ps->dualSabers&& pm->ps->saber[1].Active()))
+		&& newMove >= LS_S_TL2BR 
+		&& newMove < LS_REFLECT_LL )
+	{//staff has an entirely new set of anims, besides special attacks
+		//FIXME: include ready and draw/putaway?
+		//FIXME: get hand-made bounces and deflections?
+		//FIXME: only do the dual FB & LR attacks when on ground?
+		if ( newMove >= LS_V1_BR && newMove <= LS_REFLECT_LL )
+		{//there aren't 1-7, just 1, 6 and 7, so just set it
+			anim = BOTH_P6_S6_T_ + (anim-BOTH_P1_S1_T_);//shift it up to the proper set
+		}
+		else if ( ( newMove == LS_A_R2L || newMove == LS_S_R2L
+					|| newMove == LS_A_L2R  || newMove == LS_S_L2R )
+			&& PM_CanDoDualDoubleAttacks()
+			&& G_CheckEnemyPresence( pm->gent, DIR_RIGHT, 150.0f )
+			&& G_CheckEnemyPresence( pm->gent, DIR_LEFT, 150.0f ) )
+		{//enemy both on left and right
+			newMove = LS_DUAL_LR;
+			anim = saberMoveData[newMove].animToUse;
+			//probably already moved, but...
+			pm->cmd.rightmove = 0;
+		}
+		else if ( (newMove == LS_A_T2B || newMove == LS_S_T2B
+					|| newMove == LS_A_BACK || newMove == LS_A_BACK_CR )
+			&& PM_CanDoDualDoubleAttacks()
+			&& G_CheckEnemyPresence( pm->gent, DIR_FRONT, 150.0f )
+			&& G_CheckEnemyPresence( pm->gent, DIR_BACK, 150.0f ) )
+		{//enemy both in front and back
+			newMove = LS_DUAL_FB;
+			anim = saberMoveData[newMove].animToUse;
+			//probably already moved, but...
+			pm->cmd.forwardmove = 0;
+		}
+		else
+		{//add the appropriate animLevel
+			anim += (pm->ps->saberAnimLevel-FORCE_LEVEL_1) * SABER_ANIM_GROUP_SIZE;
+		}
+	}
+	/*
+	else if ( newMove == LS_DRAW && pm->ps->saberAnimLevel == SS_STAFF )//pm->ps->SaberStaff() )
+	{//hold saber out front as we turn it on
+		//FIXME: need a real "draw" anim for this (and put-away)
+		anim = BOTH_SABERSTAFF_STANCE;
+	}
+	*/
+	else if ( pm->ps->saberAnimLevel > FORCE_LEVEL_1 &&
+		 !PM_SaberInIdle( newMove ) && !PM_SaberInParry( newMove ) && !PM_SaberInKnockaway( newMove ) && !PM_SaberInBrokenParry( newMove ) && !PM_SaberInReflect( newMove ) && !PM_SaberInSpecial( newMove ))
+	{//readies, parries and reflections have only 1 level 
+		if ( pm->ps->saber[0].type == SABER_LANCE || pm->ps->saber[0].type == SABER_TRIDENT )
+		{//FIXME: hack for now - these use the fast anims, but slowed down.  Should have own style
+		}
+		else
+		{//increment the anim to the next level of saber anims
+			anim += (pm->ps->saberAnimLevel-FORCE_LEVEL_1) * SABER_ANIM_GROUP_SIZE;
+		}
+	}
+	else if ( newMove == LS_KICK_F_AIR 
+		|| newMove == LS_KICK_B_AIR
+		|| newMove == LS_KICK_R_AIR
+		|| newMove == LS_KICK_L_AIR )
+	{
+		if ( pm->ps->groundEntityNum != ENTITYNUM_NONE )
+		{
+			PM_SetJumped( 200, qtrue );
+		}
+	}
+
+	// If the move does the same animation as the last one, we need to force a restart...
+//	if ( saberMoveData[pm->ps->saberMove].animToUse == anim && newMove > LS_PUTAWAY)
+	if ( ( pm->ps->torsoAnim == anim || pm->ps->legsAnim == anim )
+		&& newMove > LS_PUTAWAY )
+	{
+		setflags |= SETANIM_FLAG_RESTART;
+	}
+
+	if ( (anim == BOTH_STAND1 && (pm->ps->saber[0].type == SABER_ARC || (pm->ps->dualSabers && pm->ps->saber[1].Active())) )
+		|| anim == BOTH_STAND2 
+		//FIXME: temp hack to stop it from using run2 with staff
+		|| (0 && anim == BOTH_SABERSTAFF_STANCE)
+		|| anim == BOTH_SABERDUAL_STANCE
+		|| anim == BOTH_SABERFAST_STANCE
+		|| anim == BOTH_SABERSLOW_STANCE )
+	{//match torso anim to walk/run anim if newMove is just LS_READY
+		//FIXME: play both_stand2_random1 when you've been idle for a while
+		switch ( pm->ps->legsAnim )
+		{
+		case BOTH_WALK1:
+		case BOTH_WALK2:
+		case BOTH_WALK_STAFF:
+		case BOTH_WALK_DUAL:
+		case BOTH_WALKBACK1:
+		case BOTH_WALKBACK2:
+		case BOTH_WALKBACK_STAFF:
+		case BOTH_WALKBACK_DUAL:
+		case BOTH_RUN1:
+		case BOTH_RUN2:
+		case BOTH_RUN_STAFF:
+		case BOTH_RUN_DUAL:
+		case BOTH_RUNBACK1:
+		case BOTH_RUNBACK2:
+		case BOTH_RUNBACK_STAFF:
+			anim = pm->ps->legsAnim;
+			break;
+		}
+	}
+
+	if ( !PM_RidingVehicle() )
+	{
+		if ( !manualBlocking )
+		{
+			if ( newMove == LS_A_LUNGE 
+				|| newMove == LS_A_JUMP_T__B_ 
+				|| newMove == LS_A_BACKSTAB
+				|| newMove == LS_A_BACK
+				|| newMove == LS_A_BACK_CR
+				|| newMove == LS_ROLL_STAB
+				|| newMove == LS_A_FLIP_STAB
+				|| newMove == LS_A_FLIP_SLASH
+				|| newMove == LS_JUMPATTACK_DUAL
+				|| newMove == LS_JUMPATTACK_ARIAL_LEFT
+				|| newMove == LS_JUMPATTACK_ARIAL_RIGHT
+				|| newMove == LS_JUMPATTACK_CART_LEFT
+				|| newMove == LS_JUMPATTACK_CART_RIGHT
+				|| newMove == LS_JUMPATTACK_STAFF_LEFT
+				|| newMove == LS_JUMPATTACK_STAFF_RIGHT
+				|| newMove == LS_BUTTERFLY_LEFT
+				|| newMove == LS_BUTTERFLY_RIGHT
+				|| newMove == LS_A_BACKFLIP_ATK
+				|| newMove == LS_STABDOWN
+				|| newMove == LS_STABDOWN_STAFF
+				|| newMove == LS_STABDOWN_DUAL
+				|| newMove == LS_DUAL_SPIN_PROTECT
+				|| newMove == LS_STAFF_SOULCAL
+				|| newMove == LS_A1_SPECIAL
+				|| newMove == LS_A2_SPECIAL
+				|| newMove == LS_A3_SPECIAL
+				|| newMove == LS_UPSIDE_DOWN_ATTACK
+				|| newMove == LS_PULL_ATTACK_STAB
+				|| newMove == LS_PULL_ATTACK_SWING
+				|| PM_KickMove( newMove ) )
+			{
+				parts = SETANIM_BOTH;
+			}
+			else if ( PM_SpinningSaberAnim( anim ) )
+			{//spins must be played on entire body
+				parts = SETANIM_BOTH;
+			}
+			else if ( (!pm->cmd.forwardmove&&!pm->cmd.rightmove&&!pm->cmd.upmove))
+			{//not trying to run, duck or jump
+				if ( !PM_FlippingAnim( pm->ps->legsAnim ) && 
+					!PM_InRoll( pm->ps ) && 
+					!PM_InKnockDown( pm->ps ) && 
+					!PM_JumpingAnim( pm->ps->legsAnim ) &&
+					!PM_PainAnim( pm->ps->legsAnim ) &&
+					!PM_InSpecialJump( pm->ps->legsAnim ) &&
+					!PM_InSlopeAnim( pm->ps->legsAnim ) &&
+					//!PM_CrouchAnim( pm->ps->legsAnim ) &&
+					//pm->cmd.upmove >= 0 &&
+					!(pm->ps->pm_flags & PMF_DUCKED) &&
+					newMove != LS_PUTAWAY )
+				{
+					parts = SETANIM_BOTH;
+				}
+				else if ( !(pm->ps->pm_flags & PMF_DUCKED) 
+					&& ( newMove == LS_SPINATTACK_DUAL || newMove == LS_SPINATTACK ) )
+				{
+					parts = SETANIM_BOTH;
+				}
+			}
+		}
+	}
+	else
+	{
+		if (!pm->ps->saberBlocked)
+		{
+			parts = SETANIM_BOTH;
+			setflags &= ~SETANIM_FLAG_RESTART;
+		}
+	}
+	if (anim!=-1)
+	{
+		PM_SetAnim( pm, parts, anim, setflags, saberMoveData[newMove].blendTime );
+	}
+
+	if ( pm->ps->torsoAnim == anim )
+	{//successfully changed anims
+	//special check for *starting* a saber swing
+		if ( pm->gent && pm->ps->SaberLength() > 1 )
+		{
+			if ( PM_SaberInAttack( newMove ) || PM_SaberInSpecialAttack( anim ) )
+			{//playing an attack
+				if ( pm->ps->saberMove != newMove )
+				{//wasn't playing that attack before
+					if ( PM_SaberInSpecialAttack( anim ) )
+					{
+						WP_SaberSwingSound( pm->gent, 0, SWING_FAST );
+						if ( !PM_InCartwheel( pm->ps->torsoAnim ) )
+						{//can still attack during a cartwheel/arial
+							pm->ps->weaponTime = pm->ps->torsoAnimTimer;//so we know our weapon is busy
+						}
+					}
+					else
+					{
+						switch ( pm->ps->saberAnimLevel )
+						{
+						case SS_DESANN:
+						case SS_STRONG:
+							WP_SaberSwingSound( pm->gent, 0, SWING_STRONG );
+							break;
+						case SS_MEDIUM:
+						case SS_DUAL:
+						case SS_STAFF:
+							WP_SaberSwingSound( pm->gent, 0, SWING_MEDIUM );
+							break;
+						case SS_TAVION:
+						case SS_FAST:
+							WP_SaberSwingSound( pm->gent, 0, SWING_FAST );
+							break;
+						}
+					}
+				}
+				else if ( (setflags&SETANIM_FLAG_RESTART) && PM_SaberInSpecialAttack( anim ) )
+				{//sigh, if restarted a special, then set the weaponTime *again*
+					if ( !PM_InCartwheel( pm->ps->torsoAnim ) )
+					{//can still attack during a cartwheel/arial
+						pm->ps->weaponTime = pm->ps->torsoAnimTimer;//so we know our weapon is busy
+					}
+				}
+			}
+			else if ( PM_SaberInStart( newMove ) && pm->ps->saberAnimLevel == SS_STRONG )
+			{
+				WP_SaberSwingSound( pm->gent, 0, SWING_FAST );
+			}
+		}
+
+		/*
+		//wtf... getting stuck with weaponTime set even though we're not in an attack...?
+		if ( PM_SaberInAttack( pm->ps->saberMove ) 
+			&& !PM_SaberInAttack( newMove ) )
+		{
+			pm->ps->weaponTime = 0;
+		}
+		*/
+
+
+		//Some special attacks can be started when sabers are off, make sure we turn them on, first!
+		switch ( newMove )
+		{//make sure the saber is on!
+		case LS_A_LUNGE:
+		case LS_ROLL_STAB:
+			if ( PM_InSecondaryStyle() )
+			{//staff as medium or dual as fast
+				if ( pm->ps->dualSabers )
+				{//only force on the first saber
+					pm->ps->saber[0].Activate();
+				}
+				else if ( pm->ps->saber[0].numBlades > 1 )
+				{//only force on the first saber's first blade
+					pm->ps->SaberBladeActivate(0,0);
+				}
+			}
+			else
+			{//turn on all blades on all sabers
+				pm->ps->SaberActivate();
+			}
+			break;
+		case LS_SPINATTACK_ALORA:
+		case LS_SPINATTACK_DUAL:
+		case LS_SPINATTACK:
+		case LS_A1_SPECIAL:
+		case LS_A2_SPECIAL:
+		case LS_A3_SPECIAL:
+		case LS_DUAL_SPIN_PROTECT:
+		case LS_STAFF_SOULCAL:
+			//FIXME: probably more...
+			pm->ps->SaberActivate();
+			break;
+		}
+
+		pm->ps->saberMove = newMove;
+		pm->ps->saberBlocking = saberMoveData[newMove].blocking;
+
+		if ( pm->ps->clientNum == 0 || PM_ControlledByPlayer() )
+		{
+			if ( pm->ps->saberBlocked >= BLOCKED_UPPER_RIGHT_PROJ && pm->ps->saberBlocked <= BLOCKED_TOP_PROJ 
+				&& newMove >= LS_REFLECT_UP && newMove <= LS_REFLECT_LL )
+			{//don't clear it when blocking projectiles
+			}
+			else
+			{
+				pm->ps->saberBlocked = BLOCKED_NONE;
+			}
+		}
+		else if ( pm->ps->saberBlocked <= BLOCKED_ATK_BOUNCE || !pm->ps->SaberActive() || (newMove < LS_PARRY_UR || newMove > LS_REFLECT_LL) )
+		{//NPCs only clear blocked if not blocking?
+			pm->ps->saberBlocked = BLOCKED_NONE;
+		}
+
+		if ( pm->gent && pm->gent->client )
+		{
+			if ( saberMoveData[newMove].trailLength > 0 )
+			{
+				pm->gent->client->ps.SaberActivateTrail( saberMoveData[newMove].trailLength ); // saber trail lasts for 75ms...feel free to change this if you want it longer or shorter
+			}
+			else
+			{
+				pm->gent->client->ps.SaberDeactivateTrail( 0 );
+			}
+		}
+	}
+}
+
+
+/*
+==============
+PM_Use
+
+Generates a use event
+==============
+*/
+#define USE_DELAY 250
+
+void PM_Use( void ) 
+{
+	if ( pm->ps->useTime > 0 )
+	{
+		pm->ps->useTime -= pml.msec;
+		if ( pm->ps->useTime < 0 )
+		{
+			pm->ps->useTime = 0;
+		}
+	}
+
+	if ( pm->ps->useTime > 0 ) {
+		return;
+	}
+
+	if ( ! (pm->cmd.buttons & BUTTON_USE ) )
+	{
+		pm->useEvent = 0;
+		pm->ps->useTime = 0;
+		return;
+	}
+
+	pm->useEvent = EV_USE;
+	pm->ps->useTime = USE_DELAY;
+}
+
+extern saberMoveName_t PM_AttackForEnemyPos( qboolean allowFB, qboolean allowStabDown );
+saberMoveName_t PM_NPCSaberAttackFromQuad( int quad )
+{	
+	//FIXME: this should be an AI decision 
+	// It should be based on the enemy's current LS_ move, saberAnimLevel,
+	// the jedi's difficulty level, rank and FP_OFFENSE skill...
+	saberMoveName_t autoMove = LS_NONE;
+	if ( pm->gent && ((pm->gent->NPC && pm->gent->NPC->rank != RANK_ENSIGN && pm->gent->NPC->rank != RANK_CIVILIAN ) || (pm->gent->client && (pm->gent->client->NPC_class == CLASS_TAVION||pm->gent->client->NPC_class == CLASS_ALORA))) )
+	{
+		autoMove = PM_AttackForEnemyPos( qtrue, qtrue );
+	}
+	if ( autoMove != LS_NONE && PM_SaberInSpecial( autoMove ) )
+	{//if have opportunity to do a special attack, do one
+		return autoMove;
+	}
+	else
+	{//pick another one
+		saberMoveName_t newmove = LS_NONE;
+		switch( quad )
+		{
+		case Q_T://blocked top
+			if ( Q_irand( 0, 1 ) )
+			{
+				newmove = LS_A_T2B;
+			}
+			else
+			{
+				newmove = LS_A_TR2BL;
+			}
+			break;
+		case Q_TR:
+			if ( !Q_irand( 0, 2 ) )
+			{
+				newmove = LS_A_R2L;
+			}
+			else if ( !Q_irand( 0, 1 ) )
+			{
+				newmove = LS_A_TR2BL;
+			}
+			else
+			{
+				newmove = LS_T1_TR_BR;
+			}
+			break;
+		case Q_TL:
+			if ( !Q_irand( 0, 2 ) )
+			{
+				newmove = LS_A_L2R;
+			}
+			else if ( !Q_irand( 0, 1 ) )
+			{
+				newmove = LS_A_TL2BR;
+			}
+			else
+			{
+				newmove = LS_T1_TL_BL;
+			}
+			break;
+		case Q_BR:
+			if ( !Q_irand( 0, 2 ) )
+			{
+				newmove = LS_A_BR2TL;
+			}
+			else if ( !Q_irand( 0, 1 ) )
+			{
+				newmove = LS_T1_BR_TR;
+			}
+			else
+			{
+				newmove = LS_A_R2L;
+			}
+			break;
+		case Q_BL:
+			if ( !Q_irand( 0, 2 ) )
+			{
+				newmove = LS_A_BL2TR;
+			}
+			else if ( !Q_irand( 0, 1 ) )
+			{
+				newmove = LS_T1_BL_TL;
+			}
+			else
+			{
+				newmove = LS_A_L2R;
+			}
+			break;
+		case Q_L:
+			if ( !Q_irand( 0, 2 ) )
+			{
+				newmove = LS_A_L2R;
+			}
+			else if ( !Q_irand( 0, 1 ) )
+			{
+				newmove = LS_T1__L_T_;
+			}
+			else
+			{
+				newmove = LS_A_R2L;
+			}
+			break;
+		case Q_R:
+			if ( !Q_irand( 0, 2 ) )
+			{
+				newmove = LS_A_R2L;
+			}
+			else if ( !Q_irand( 0, 1 ) )
+			{
+				newmove = LS_T1__R_T_;
+			}
+			else
+			{
+				newmove = LS_A_L2R;
+			}
+			break;
+		case Q_B:
+			if ( pm->gent 
+				&& pm->gent->NPC 
+				&& pm->gent->NPC->rank >= RANK_LT_JG )
+			{//fencers and above can do bottom-up attack
+				if ( Q_irand( 0, pm->gent->NPC->rank ) >= RANK_LT_JG )
+				{//but not overly likely
+					newmove = PM_SaberLungeAttackMove( qtrue );
+				}
+			}
+			break;
+		default:
+			break;
+		}
+		return newmove;
+	}
+}
+
+int PM_SaberMoveQuadrantForMovement( usercmd_t *ucmd )
+{
+	if ( ucmd->rightmove > 0 )
+	{//moving right
+		if ( ucmd->forwardmove > 0 )
+		{//forward right = TL2BR slash
+			return Q_TL;
+		}
+		else if ( ucmd->forwardmove < 0 )
+		{//backward right = BL2TR uppercut
+			return Q_BL;
+		}
+		else
+		{//just right is a left slice
+			return Q_L;
+		}
+	}
+	else if ( ucmd->rightmove < 0 )
+	{//moving left
+		if ( ucmd->forwardmove > 0 )
+		{//forward left = TR2BL slash
+			return Q_TR;
+		}
+		else if ( ucmd->forwardmove < 0 )
+		{//backward left = BR2TL uppercut
+			return Q_BR;
+		}
+		else
+		{//just left is a right slice
+			return Q_R;
+		}
+	}
+	else
+	{//not moving left or right
+		if ( ucmd->forwardmove > 0 )
+		{//forward= T2B slash
+			return Q_T;
+		}
+		else if ( ucmd->forwardmove < 0 )
+		{//backward= T2B slash	//or B2T uppercut?
+			return Q_T;
+		}
+		else //if ( curmove == LS_READY )//???
+		{//Not moving at all
+			return Q_R;
+		}
+	}
+	//return Q_R;//????
+}
+
+void PM_SetAnimFrame( gentity_t *gent, int frame, qboolean torso, qboolean legs )
+{
+	if ( !gi.G2API_HaveWeGhoul2Models( gent->ghoul2 ) )
+	{
+		return;
+	}
+	int	actualTime = (cg.time?cg.time:level.time);
+	if ( torso && gent->lowerLumbarBone != -1 )//gent->upperLumbarBone
+	{
+		gi.G2API_SetBoneAnimIndex(&gent->ghoul2[gent->playerModel], gent->lowerLumbarBone, //gent->upperLumbarBone
+			frame, frame+1, BONE_ANIM_OVERRIDE_FREEZE|BONE_ANIM_BLEND, 1, actualTime, frame, 150 );
+		if ( gent->motionBone != -1 )
+		{
+			gi.G2API_SetBoneAnimIndex(&gent->ghoul2[gent->playerModel], gent->motionBone, //gent->upperLumbarBone
+				frame, frame+1, BONE_ANIM_OVERRIDE_FREEZE|BONE_ANIM_BLEND, 1, actualTime, frame, 150 );
+		}
+	}
+	if ( legs && gent->rootBone != -1 )
+	{
+		gi.G2API_SetBoneAnimIndex(&gent->ghoul2[gent->playerModel], gent->rootBone, 
+			frame, frame+1, BONE_ANIM_OVERRIDE_FREEZE|BONE_ANIM_BLEND, 1, actualTime, frame, 150 );
+	}
+}
+
+int PM_SaberLockWinAnim( saberLockResult_t result, int breakType )
+{
+	int winAnim = -1;
+	switch ( pm->ps->torsoAnim )
+	{
+/*
+	default:
+#ifndef FINAL_BUILD
+		Com_Printf( S_COLOR_RED"ERROR-PM_SaberLockBreak: %s not in saberlock anim, anim = (%d)%s\n", pm->gent->NPC_type, pm->ps->torsoAnim, animTable[pm->ps->torsoAnim].name );
+#endif
+*/
+	case BOTH_BF2LOCK:
+		if ( breakType == SABERLOCK_SUPERBREAK )
+		{
+			winAnim = BOTH_LK_S_S_T_SB_1_W;
+		}
+		else if ( result == LOCK_DRAW )
+		{
+			winAnim = BOTH_BF1BREAK;
+		}
+		else
+		{
+			pm->ps->saberMove = LS_A_T2B;
+			winAnim = BOTH_A3_T__B_;
+		}
+		break;
+	case BOTH_BF1LOCK:
+		if ( breakType == SABERLOCK_SUPERBREAK )
+		{
+			winAnim = BOTH_LK_S_S_T_SB_1_W;
+		}
+		else if ( result == LOCK_DRAW )
+		{
+			winAnim = BOTH_KNOCKDOWN4;
+		}
+		else
+		{
+			pm->ps->saberMove = LS_K1_T_;
+			winAnim = BOTH_K1_S1_T_;
+		}
+		break;
+	case BOTH_CWCIRCLELOCK:
+		if ( breakType == SABERLOCK_SUPERBREAK )
+		{
+			winAnim = BOTH_LK_S_S_S_SB_1_W;
+		}
+		else if ( result == LOCK_DRAW )
+		{
+			pm->ps->saberMove = pm->ps->saberBounceMove = LS_V1_BL;
+			pm->ps->saberBlocked = BLOCKED_PARRY_BROKEN;
+			winAnim = BOTH_V1_BL_S1;
+		}
+		else
+		{
+			winAnim = BOTH_CWCIRCLEBREAK;
+		}
+		break;
+	case BOTH_CCWCIRCLELOCK:
+		if ( breakType == SABERLOCK_SUPERBREAK )
+		{
+			winAnim = BOTH_LK_S_S_S_SB_1_W;
+		}
+		else if ( result == LOCK_DRAW )
+		{
+			pm->ps->saberMove = pm->ps->saberBounceMove = LS_V1_BR;
+			pm->ps->saberBlocked = BLOCKED_PARRY_BROKEN;
+			winAnim = BOTH_V1_BR_S1;
+		}
+		else
+		{
+			winAnim = BOTH_CCWCIRCLEBREAK;
+		}
+		break;
+	default:
+		//must be using new system:
+		break;
+	}
+	if ( winAnim != -1 )
+	{
+		PM_SetAnim( pm, SETANIM_BOTH, winAnim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+		pm->ps->weaponTime = pm->ps->torsoAnimTimer;
+		pm->ps->saberBlocked = BLOCKED_NONE;
+		pm->ps->weaponstate = WEAPON_FIRING;
+		if ( breakType == SABERLOCK_SUPERBREAK 
+			&& winAnim != BOTH_LK_ST_DL_T_SB_1_W )
+		{//going to attack with saber, do a saber trail
+			pm->ps->SaberActivateTrail( 200 );
+		}
+	}
+	return winAnim;
+}
+
+int PM_SaberLockLoseAnim( gentity_t *genemy, saberLockResult_t result, int breakType )
+{ 
+	int loseAnim = -1;
+	switch ( genemy->client->ps.torsoAnim )
+	{
+/*
+	default:
+#ifndef FINAL_BUILD
+		Com_Printf( S_COLOR_RED"ERROR-PM_SaberLockBreak: %s not in saberlock anim, anim = (%d)%s\n", genemy->NPC_type, genemy->client->ps.torsoAnim, animTable[genemy->client->ps.torsoAnim].name );
+#endif
+*/
+	case BOTH_BF2LOCK:
+		if ( breakType == SABERLOCK_SUPERBREAK )
+		{
+			loseAnim = BOTH_LK_S_S_T_SB_1_L;
+		}
+		else if ( result == LOCK_DRAW )
+		{
+			loseAnim = BOTH_BF1BREAK;
+		}
+		else
+		{
+			if ( result == LOCK_STALEMATE )
+			{//no-one won
+				genemy->client->ps.saberMove = LS_K1_T_;
+				loseAnim = BOTH_K1_S1_T_;
+			}
+			else
+			{//FIXME: this anim needs to transition back to ready when done
+				loseAnim = BOTH_BF1BREAK;
+			}
+		}
+		break;
+	case BOTH_BF1LOCK:
+		if ( breakType == SABERLOCK_SUPERBREAK )
+		{
+			loseAnim = BOTH_LK_S_S_T_SB_1_L;
+		}
+		else if ( result == LOCK_DRAW )
+		{
+			loseAnim = BOTH_KNOCKDOWN4;
+		}
+		else
+		{
+			if ( result == LOCK_STALEMATE )
+			{//no-one won
+				genemy->client->ps.saberMove = LS_A_T2B;
+				loseAnim = BOTH_A3_T__B_;
+			}
+			else
+			{
+				loseAnim = BOTH_KNOCKDOWN4;
+			}
+		}
+		break;
+	case BOTH_CWCIRCLELOCK:
+		if ( breakType == SABERLOCK_SUPERBREAK )
+		{
+			loseAnim = BOTH_LK_S_S_S_SB_1_L;
+		}
+		else if ( result == LOCK_DRAW )
+		{
+			genemy->client->ps.saberMove = genemy->client->ps.saberBounceMove = LS_V1_BL;
+			genemy->client->ps.saberBlocked = BLOCKED_PARRY_BROKEN;
+			loseAnim = BOTH_V1_BL_S1;
+		}
+		else
+		{
+			if ( result == LOCK_STALEMATE )
+			{//no-one won
+				loseAnim = BOTH_CCWCIRCLEBREAK;
+			}
+			else
+			{
+				genemy->client->ps.saberMove = genemy->client->ps.saberBounceMove = LS_V1_BL;
+				genemy->client->ps.saberBlocked = BLOCKED_PARRY_BROKEN;
+				loseAnim = BOTH_V1_BL_S1;
+				/*
+				genemy->client->ps.saberMove = genemy->client->ps.saberBounceMove = LS_H1_BR;
+				genemy->client->ps.saberBlocked = BLOCKED_PARRY_BROKEN;
+				loseAnim = BOTH_H1_S1_BL;
+				*/
+			}
+		}
+		break;
+	case BOTH_CCWCIRCLELOCK:
+		if ( breakType == SABERLOCK_SUPERBREAK )
+		{
+			loseAnim = BOTH_LK_S_S_S_SB_1_L;
+		}
+		else if ( result == LOCK_DRAW )
+		{
+			genemy->client->ps.saberMove = genemy->client->ps.saberBounceMove = LS_V1_BR;
+			genemy->client->ps.saberBlocked = BLOCKED_PARRY_BROKEN;
+			loseAnim = BOTH_V1_BR_S1;
+		}
+		else
+		{
+			if ( result == LOCK_STALEMATE )
+			{//no-one won
+				loseAnim = BOTH_CWCIRCLEBREAK;
+			}
+			else
+			{
+				genemy->client->ps.saberMove = genemy->client->ps.saberBounceMove = LS_V1_BR;
+				genemy->client->ps.saberBlocked = BLOCKED_PARRY_BROKEN;
+				loseAnim = BOTH_V1_BR_S1;
+				/*
+				genemy->client->ps.saberMove = genemy->client->ps.saberBounceMove = LS_H1_BL;
+				genemy->client->ps.saberBlocked = BLOCKED_PARRY_BROKEN;
+				loseAnim = BOTH_H1_S1_BR;
+				*/
+			}
+		}
+		break;
+	}
+	if ( loseAnim != -1 )
+	{
+		NPC_SetAnim( genemy, SETANIM_BOTH, loseAnim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+		genemy->client->ps.weaponTime = genemy->client->ps.torsoAnimTimer;// + 250;
+		genemy->client->ps.saberBlocked = BLOCKED_NONE;
+		genemy->client->ps.weaponstate = WEAPON_READY;
+	}
+	return loseAnim;
+}
+
+int PM_SaberLockResultAnim( gentity_t *duelist, int lockOrBreakOrSuperBreak, int winOrLose )
+{
+	int baseAnim = duelist->client->ps.torsoAnim;
+	switch ( baseAnim )
+	{
+	case BOTH_LK_S_S_S_L_2:		//lock if I'm using single vs. a single and other intitiated
+		baseAnim = BOTH_LK_S_S_S_L_1;
+		break;
+	case BOTH_LK_S_S_T_L_2:		//lock if I'm using single vs. a single and other initiated
+		baseAnim = BOTH_LK_S_S_T_L_1;
+		break;
+	case BOTH_LK_DL_DL_S_L_2:	//lock if I'm using dual vs. dual and other initiated
+		baseAnim = BOTH_LK_DL_DL_S_L_1;
+		break;
+	case BOTH_LK_DL_DL_T_L_2:	//lock if I'm using dual vs. dual and other initiated
+		baseAnim = BOTH_LK_DL_DL_T_L_1;
+		break;
+	case BOTH_LK_ST_ST_S_L_2:	//lock if I'm using staff vs. a staff and other initiated
+		baseAnim = BOTH_LK_ST_ST_S_L_1;
+		break;
+	case BOTH_LK_ST_ST_T_L_2:	//lock if I'm using staff vs. a staff and other initiated
+		baseAnim = BOTH_LK_ST_ST_T_L_1;
+		break;
+	}
+	//what kind of break?
+	if ( lockOrBreakOrSuperBreak == SABERLOCK_BREAK )
+	{ 
+		baseAnim -= 2;
+	}
+	else if ( lockOrBreakOrSuperBreak == SABERLOCK_SUPERBREAK )
+	{
+		baseAnim += 1;
+	}
+	else
+	{//WTF?  Not a valid result
+		return -1;
+	}
+	//win or lose?
+	if ( winOrLose == SABERLOCK_WIN )
+	{
+		baseAnim += 1;
+	}
+	//play the anim and hold it
+	NPC_SetAnim( duelist, SETANIM_BOTH, baseAnim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+
+	if ( lockOrBreakOrSuperBreak == SABERLOCK_SUPERBREAK
+		&& winOrLose == SABERLOCK_LOSE )
+	{//if you lose a superbreak, you're defenseless
+		//make saberent not block
+		gentity_t *saberent = &g_entities[duelist->client->ps.saberEntityNum];
+		if ( saberent )
+		{
+			VectorClear(saberent->mins);
+			VectorClear(saberent->maxs);
+			G_SetOrigin(saberent, duelist->currentOrigin);
+		}
+		//set sabermove to none
+		duelist->client->ps.saberMove = LS_NONE;
+		//Hold the anim a little longer than it is
+		duelist->client->ps.torsoAnimTimer += 250;;
+	}
+
+	//no attacking during this anim
+	duelist->client->ps.weaponTime = duelist->client->ps.torsoAnimTimer;
+	duelist->client->ps.saberBlocked = BLOCKED_NONE;
+	if ( lockOrBreakOrSuperBreak == SABERLOCK_SUPERBREAK 
+		&& winOrLose == SABERLOCK_WIN
+		&& baseAnim != BOTH_LK_ST_DL_T_SB_1_W )
+	{//going to attack with saber, do a saber trail
+		duelist->client->ps.SaberActivateTrail( 200 );
+	}
+	return baseAnim;
+}
+
+void PM_SaberLockBreak( gentity_t *gent, gentity_t *genemy, saberLockResult_t result, int victoryStrength )
+{
+	int	winAnim = -1, loseAnim = -1;
+	int breakType = SABERLOCK_BREAK;
+	qboolean singleVsSingle = qtrue;
+	
+	if ( result == LOCK_VICTORY
+		&& Q_irand(0,7) < victoryStrength )
+	{ 
+		if ( genemy 
+			&& genemy->NPC
+			&& ((genemy->NPC->aiFlags&NPCAI_BOSS_CHARACTER)
+				||(genemy->NPC->aiFlags&NPCAI_SUBBOSS_CHARACTER)
+				||(genemy->client&&genemy->client->NPC_class == CLASS_SHADOWTROOPER))
+			&& Q_irand(0, 4)
+			)
+		{//less of a chance of getting a superbreak against a boss
+			breakType = SABERLOCK_BREAK;
+		}
+		else
+		{
+			breakType = SABERLOCK_SUPERBREAK;
+		}
+	}
+	else
+	{
+		breakType = SABERLOCK_BREAK;
+	}
+	winAnim = PM_SaberLockWinAnim( result, breakType );
+	if ( winAnim != -1 )
+	{//a single vs. single break
+		if ( genemy && genemy->client )
+		{
+			loseAnim = PM_SaberLockLoseAnim( genemy, result, breakType );
+		}
+	}
+	else
+	{//must be a saberlock that's not between single and single...
+		singleVsSingle = qfalse;
+		winAnim = PM_SaberLockResultAnim( gent, breakType, SABERLOCK_WIN );
+		pm->ps->weaponstate = WEAPON_FIRING;
+		if ( genemy && genemy->client )
+		{
+			loseAnim = PM_SaberLockResultAnim( genemy, breakType, SABERLOCK_LOSE );
+			genemy->client->ps.weaponstate = WEAPON_READY;
+		}
+	}
+
+	if ( d_saberCombat->integer )
+	{
+		Com_Printf( "%s won saber lock, anim = %s!\n", gent->NPC_type, animTable[winAnim].name );
+		Com_Printf( "%s lost saber lock, anim = %s!\n", genemy->NPC_type, animTable[loseAnim].name );
+	}
+
+	pm->ps->saberLockTime = genemy->client->ps.saberLockTime = 0;
+	pm->ps->saberLockEnemy = genemy->client->ps.saberLockEnemy = ENTITYNUM_NONE;
+	pm->ps->saberMoveNext = LS_NONE;
+	if ( genemy && genemy->client )
+	{
+		genemy->client->ps.saberMoveNext = LS_NONE;
+	}
+
+	PM_AddEvent( EV_JUMP );
+	if ( result == LOCK_STALEMATE )
+	{//no-one won
+		G_AddEvent( genemy, EV_JUMP, 0 );
+	}
+	else
+	{
+		if ( pm->ps->clientNum )
+		{//an NPC
+			pm->ps->saberEventFlags |= SEF_LOCK_WON;//tell the winner to press the advantage
+		}
+		//painDebounceTime will stop them from doing anything
+		genemy->painDebounceTime = level.time + genemy->client->ps.torsoAnimTimer + 500;
+		if ( Q_irand( 0, 1 ) )
+		{
+			G_AddEvent( genemy, EV_PAIN, Q_irand( 0, 75 ) );
+		}
+		else
+		{
+			if ( genemy->NPC )
+			{
+				genemy->NPC->blockedSpeechDebounceTime = 0;
+			}
+			G_AddVoiceEvent( genemy, Q_irand( EV_PUSHED1, EV_PUSHED3 ), 500 );
+		}
+		if ( result == LOCK_VICTORY )
+		{//one person won
+			if ( Q_irand( FORCE_LEVEL_1, FORCE_LEVEL_2 ) < pm->ps->forcePowerLevel[FP_SABER_OFFENSE] )
+			{
+				vec3_t throwDir = {0,0,350};
+				int		winMove = pm->ps->saberMove;
+				if ( !singleVsSingle )
+				{//all others have their own super breaks
+					//so it doesn't try to set some other anim below
+					winAnim = -1;
+				}
+				else if ( winAnim == BOTH_LK_S_S_S_SB_1_W
+					|| winAnim == BOTH_LK_S_S_T_SB_1_W )
+				{//doing a superbreak on single-vs-single, don't do the old superbreaks this time
+					//so it doesn't try to set some other anim below
+					winAnim = -1;
+				}
+				else
+				{//JK2-style
+					switch ( winAnim )
+					{
+					case BOTH_A3_T__B_:
+						winAnim = BOTH_D1_TL___;
+						winMove = LS_D1_TL;
+						//FIXME: mod throwDir?
+						break;
+					case BOTH_K1_S1_T_:
+						//FIXME: mod throwDir?
+						break;
+					case BOTH_CWCIRCLEBREAK:
+						//FIXME: mod throwDir?
+						break;
+					case BOTH_CCWCIRCLEBREAK:
+						winAnim = BOTH_A1_BR_TL;
+						winMove = LS_A_BR2TL;
+						//FIXME: mod throwDir?
+						break;
+					}
+					if ( winAnim != BOTH_CCWCIRCLEBREAK )
+					{
+						if ( (!genemy->s.number&&genemy->health<=25)//player low on health
+							||(genemy->s.number&&genemy->client->NPC_class!=CLASS_KYLE&&genemy->client->NPC_class!=CLASS_LUKE&&genemy->client->NPC_class!=CLASS_TAVION&&genemy->client->NPC_class!=CLASS_ALORA&&genemy->client->NPC_class!=CLASS_DESANN)//any NPC that's not a boss character
+							||(genemy->s.number&&genemy->health<=50) )//boss character with less than 50 health left
+						{//possibly knock saber out of hand OR cut hand off!
+							if ( Q_irand( 0, 25 ) < victoryStrength
+								&& ((!genemy->s.number&&genemy->health<=10)||genemy->s.number) )
+							{
+								NPC_SetAnim( genemy, SETANIM_BOTH, BOTH_RIGHTHANDCHOPPEDOFF, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );//force this
+								genemy->client->dismembered = false;
+								G_DoDismemberment( genemy, genemy->client->renderInfo.handRPoint, MOD_SABER, 1000, HL_HAND_RT, qtrue );
+								G_Damage( genemy, gent, gent, throwDir, genemy->client->renderInfo.handRPoint, genemy->health+10, DAMAGE_NO_PROTECTION|DAMAGE_NO_ARMOR|DAMAGE_NO_KNOCKBACK|DAMAGE_NO_HIT_LOC, MOD_SABER, HL_NONE );
+
+								PM_SetAnim( pm, SETANIM_BOTH, winAnim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+								pm->ps->weaponTime = pm->ps->torsoAnimTimer + 500;
+								pm->ps->saberMove = winMove;
+								pm->ps->saberBlocked = BLOCKED_NONE;
+								pm->ps->weaponstate = WEAPON_FIRING;
+								return;
+							}
+						}
+					}
+				}
+				//else see if we can knock the saber out of their hand
+				//FIXME: for now, always disarm the right-hand saber
+				if ( genemy->client->ps.saber[0].disarmable )
+				{
+					//add disarmBonus into this check
+					victoryStrength += pm->ps->SaberDisarmBonus()*2;
+					if ( genemy->client->ps.saber[0].twoHanded || (genemy->client->ps.dualSabers && genemy->client->ps.saber[1].Active()) )
+					{//defender gets a bonus for using a 2-handed saber or 2 sabers
+						victoryStrength -= 2;
+					}
+					if ( pm->ps->forcePowersActive&(1<<FP_RAGE) )
+					{
+						victoryStrength += gent->client->ps.forcePowerLevel[FP_RAGE];
+					}
+					else if ( pm->ps->forceRageRecoveryTime > pm->cmd.serverTime )
+					{
+						victoryStrength--;
+					}
+					if ( genemy->client->ps.forceRageRecoveryTime > pm->cmd.serverTime )
+					{
+						victoryStrength++;
+					}
+					if ( Q_irand( 0, 10 ) < victoryStrength )
+					{
+						if ( !genemy->client->ps.saber[0].twoHanded 
+							|| !Q_irand( 0, 1 ) )
+						{//if it's a two-handed saber, it has a 50% chance of resisting a disarming
+							WP_SaberLose( genemy, throwDir );
+							if ( winAnim != -1 )
+							{
+								PM_SetAnim( pm, SETANIM_BOTH, winAnim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+								pm->ps->weaponTime = pm->ps->torsoAnimTimer;
+								pm->ps->saberMove = winMove;
+								pm->ps->saberBlocked = BLOCKED_NONE;
+								pm->ps->weaponstate = WEAPON_FIRING;
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+int G_SaberLockStrength( gentity_t *gent )
+{
+	int strength = gent->client->ps.saber[0].lockBonus;
+	if ( gent->client->ps.saber[0].twoHanded )
+	{
+		strength += 1;
+	}
+	if ( gent->client->ps.dualSabers && gent->client->ps.saber[1].Active() )
+	{
+		strength += 1 + gent->client->ps.saber[1].lockBonus;
+	}
+	if ( gent->client->ps.forcePowersActive&(1<<FP_RAGE) )
+	{
+		strength += gent->client->ps.forcePowerLevel[FP_RAGE];
+	}
+	else if ( gent->client->ps.forceRageRecoveryTime > pm->cmd.serverTime )
+	{
+		strength--;
+	}
+	if ( gent->s.number >= MAX_CLIENTS )
+	{
+		if ( gent->client->NPC_class == CLASS_DESANN || gent->client->NPC_class == CLASS_LUKE )
+		{
+			strength += 5+Q_irand(0,g_spskill->integer);
+		}
+		else
+		{
+			strength += gent->client->ps.forcePowerLevel[FP_SABER_OFFENSE]+Q_irand(0,g_spskill->integer);
+			if ( gent->NPC )
+			{
+				if ( (gent->NPC->aiFlags&NPCAI_BOSS_CHARACTER)
+					|| (gent->NPC->aiFlags&NPCAI_ROSH) 
+					|| gent->client->NPC_class == CLASS_SHADOWTROOPER )
+				{
+					strength += Q_irand(0,2);
+				}
+				else if ( (gent->NPC->aiFlags&NPCAI_SUBBOSS_CHARACTER) )
+				{
+					strength += Q_irand(-1,1);
+				}
+			}
+		}
+	}
+	else 
+	{//player
+		strength += gent->client->ps.forcePowerLevel[FP_SABER_OFFENSE]+Q_irand(0,g_spskill->integer)+Q_irand(0,1);
+	}
+	return strength;
+}
+
+qboolean PM_InSaberLockOld( int anim )
+{
+	switch ( anim )
+	{
+	case BOTH_BF2LOCK:
+	case BOTH_BF1LOCK:
+	case BOTH_CWCIRCLELOCK:
+	case BOTH_CCWCIRCLELOCK:
+		return qtrue;
+	}
+	return qfalse;
+}
+
+qboolean PM_InSaberLock( int anim ) 
+{
+	switch ( anim )
+	{
+	case BOTH_LK_S_DL_S_L_1:		//lock if I'm using single vs. a dual
+	case BOTH_LK_S_DL_T_L_1:		//lock if I'm using single vs. a dual
+	case BOTH_LK_S_ST_S_L_1:		//lock if I'm using single vs. a staff
+	case BOTH_LK_S_ST_T_L_1:		//lock if I'm using single vs. a staff
+	case BOTH_LK_S_S_S_L_1:		//lock if I'm using single vs. a single and I initiated
+	case BOTH_LK_S_S_T_L_1:		//lock if I'm using single vs. a single and I initiated
+	case BOTH_LK_DL_DL_S_L_1:	//lock if I'm using dual vs. dual and I initiated
+	case BOTH_LK_DL_DL_T_L_1:	//lock if I'm using dual vs. dual and I initiated
+	case BOTH_LK_DL_ST_S_L_1:	//lock if I'm using dual vs. a staff
+	case BOTH_LK_DL_ST_T_L_1:	//lock if I'm using dual vs. a staff
+	case BOTH_LK_DL_S_S_L_1:		//lock if I'm using dual vs. a single
+	case BOTH_LK_DL_S_T_L_1:		//lock if I'm using dual vs. a single
+	case BOTH_LK_ST_DL_S_L_1:	//lock if I'm using staff vs. dual
+	case BOTH_LK_ST_DL_T_L_1:	//lock if I'm using staff vs. dual
+	case BOTH_LK_ST_ST_S_L_1:	//lock if I'm using staff vs. a staff and I initiated
+	case BOTH_LK_ST_ST_T_L_1:	//lock if I'm using staff vs. a staff and I initiated
+	case BOTH_LK_ST_S_S_L_1:		//lock if I'm using staff vs. a single
+	case BOTH_LK_ST_S_T_L_1:		//lock if I'm using staff vs. a single
+	case BOTH_LK_S_S_S_L_2:
+	case BOTH_LK_S_S_T_L_2:
+	case BOTH_LK_DL_DL_S_L_2:
+	case BOTH_LK_DL_DL_T_L_2:
+	case BOTH_LK_ST_ST_S_L_2:
+	case BOTH_LK_ST_ST_T_L_2:
+		return qtrue;
+		break;
+	default:
+		return PM_InSaberLockOld( anim );
+		break;
+	}
+	//return qfalse;
+}
+
+extern qboolean ValidAnimFileIndex ( int index );
+extern qboolean G_CheckIncrementLockAnim( int anim, int winOrLose );
+qboolean PM_SaberLocked( void )
+{	
+	//FIXME: maybe kick out of saberlock?
+	if ( pm->ps->saberLockEnemy == ENTITYNUM_NONE )
+	{
+		if ( PM_InSaberLock( pm->ps->torsoAnim ) )
+		{//wtf?  Maybe enemy died?
+			PM_SaberLockWinAnim( LOCK_STALEMATE, SABERLOCK_BREAK );
+		}
+		return qfalse;
+	}
+	gentity_t *gent = pm->gent;
+	if ( !gent )
+	{
+		return qfalse;
+	}
+	gentity_t *genemy = &g_entities[pm->ps->saberLockEnemy];
+	if ( !genemy )
+	{
+		return qfalse;
+	}
+	if ( PM_InSaberLock( pm->ps->torsoAnim ) && PM_InSaberLock( genemy->client->ps.torsoAnim ) )
+	{
+		if ( pm->ps->saberLockTime <= level.time + 500 
+			&& pm->ps->saberLockEnemy != ENTITYNUM_NONE )
+		{//lock just ended
+			int strength = G_SaberLockStrength( gent );
+			int eStrength = G_SaberLockStrength( genemy );
+			if ( strength > 1 && eStrength > 1 && !Q_irand( 0, abs(strength-eStrength)+1 ) )
+			{//both knock each other down!
+				PM_SaberLockBreak( gent, genemy, LOCK_DRAW, 0 );
+			}
+			else
+			{//both "win"
+				PM_SaberLockBreak( gent, genemy, LOCK_STALEMATE, 0 );
+			}
+			return qtrue;
+		}
+		else if ( pm->ps->saberLockTime < level.time )
+		{//done... tie breaker above should have handled this, but...?
+			if ( PM_InSaberLock( pm->ps->torsoAnim ) && pm->ps->torsoAnimTimer > 0 )
+			{
+				pm->ps->torsoAnimTimer = 0;
+			}
+			if ( PM_InSaberLock( pm->ps->legsAnim ) && pm->ps->legsAnimTimer > 0 )
+			{
+				pm->ps->legsAnimTimer = 0;
+			}
+			return qfalse;
+		}
+		else if ( pm->cmd.buttons & BUTTON_ATTACK )
+		{//holding attack
+			if ( !(pm->ps->pm_flags&PMF_ATTACK_HELD) )
+			{//tapping
+				int	remaining = 0;
+				if( ValidAnimFileIndex( gent->client->clientInfo.animFileIndex ) )
+				{
+					animation_t *anim;
+					float		currentFrame, junk2;
+					int			curFrame, junk;
+					int			strength = 1;
+					anim = &level.knownAnimFileSets[gent->client->clientInfo.animFileIndex].animations[pm->ps->torsoAnim];
+					qboolean ret;
+					ret=gi.G2API_GetBoneAnimIndex( &gent->ghoul2[gent->playerModel], gent->lowerLumbarBone, (cg.time?cg.time:level.time), &currentFrame, &junk, &junk, &junk, &junk2, NULL );
+
+					assert(ret); // this would be pretty bad, the below code seems to assume the call succeeds. -gil
+	
+					strength = G_SaberLockStrength( gent );
+					if ( PM_InSaberLockOld( pm->ps->torsoAnim ) )
+					{//old locks
+						if ( pm->ps->torsoAnim == BOTH_CCWCIRCLELOCK ||
+							pm->ps->torsoAnim == BOTH_BF2LOCK )
+						{
+							curFrame = floor( currentFrame )-strength;
+							//drop my frame one
+							if ( curFrame <= anim->firstFrame )
+							{//I won!  Break out
+								PM_SaberLockBreak( gent, genemy, LOCK_VICTORY, strength );
+								return qtrue;
+							}
+							else
+							{
+								PM_SetAnimFrame( gent, curFrame, qtrue, qtrue );
+								remaining = curFrame-anim->firstFrame;
+								if ( d_saberCombat->integer )
+								{
+									Com_Printf( "%s pushing in saber lock, %d frames to go!\n", gent->NPC_type, remaining );
+								}
+							}
+						}
+						else
+						{
+							curFrame = ceil( currentFrame )+strength;
+							//advance my frame one
+							if ( curFrame >= anim->firstFrame+anim->numFrames )
+							{//I won!  Break out
+								PM_SaberLockBreak( gent, genemy, LOCK_VICTORY, strength );
+								return qtrue;
+							}
+							else
+							{
+								PM_SetAnimFrame( gent, curFrame, qtrue, qtrue );
+								remaining = anim->firstFrame+anim->numFrames-curFrame;
+								if ( d_saberCombat->integer )
+								{
+									Com_Printf( "%s pushing in saber lock, %d frames to go!\n", gent->NPC_type, remaining );
+								}
+							}
+						}
+					}
+					else
+					{//new locks
+						if ( G_CheckIncrementLockAnim( pm->ps->torsoAnim, SABERLOCK_WIN ) )
+						{
+							curFrame = ceil( currentFrame )+strength;
+							//advance my frame one
+							if ( curFrame >= anim->firstFrame+anim->numFrames )
+							{//I won!  Break out
+								PM_SaberLockBreak( gent, genemy, LOCK_VICTORY, strength );
+								return qtrue;
+							}
+							else
+							{
+								PM_SetAnimFrame( gent, curFrame, qtrue, qtrue );
+								remaining = anim->firstFrame+anim->numFrames-curFrame;
+								if ( d_saberCombat->integer )
+								{
+									Com_Printf( "%s pushing in saber lock, %d frames to go!\n", gent->NPC_type, remaining );
+								}
+							}
+						}
+						else
+						{
+							curFrame = floor( currentFrame )-strength;
+							//drop my frame one
+							if ( curFrame <= anim->firstFrame )
+							{//I won!  Break out
+								PM_SaberLockBreak( gent, genemy, LOCK_VICTORY, strength );
+								return qtrue;
+							}
+							else
+							{
+								PM_SetAnimFrame( gent, curFrame, qtrue, qtrue );
+								remaining = curFrame-anim->firstFrame;
+								if ( d_saberCombat->integer )
+								{
+									Com_Printf( "%s pushing in saber lock, %d frames to go!\n", gent->NPC_type, remaining );
+								}
+							}
+						}
+					}
+					if ( !Q_irand( 0, 2 ) )
+					{
+						if ( pm->ps->clientNum < MAX_CLIENTS )
+						{
+							if ( !Q_irand( 0, 3 ) )
+							{
+								PM_AddEvent( EV_JUMP );
+							}
+							else
+							{
+								PM_AddEvent( Q_irand( EV_PUSHED1, EV_PUSHED3 ) );
+							}
+						}
+						else
+						{
+							if ( gent->NPC && gent->NPC->blockedSpeechDebounceTime < level.time )
+							{
+								switch ( Q_irand( 0, 3 ) )
+								{
+								case 0:
+									PM_AddEvent( EV_JUMP );
+									break;
+								case 1:
+									PM_AddEvent( Q_irand( EV_ANGER1, EV_ANGER3 ) );
+									gent->NPC->blockedSpeechDebounceTime = level.time + 3000;
+									break;
+								case 2:
+									PM_AddEvent( Q_irand( EV_TAUNT1, EV_TAUNT3 ) );
+									gent->NPC->blockedSpeechDebounceTime = level.time + 3000;
+									break;
+								case 3:
+									PM_AddEvent( Q_irand( EV_GLOAT1, EV_GLOAT3 ) );
+									gent->NPC->blockedSpeechDebounceTime = level.time + 3000;
+									break;
+								}
+							}
+						}
+					}
+				}
+				else
+				{
+					return qfalse;
+				}
+
+				if( ValidAnimFileIndex( genemy->client->clientInfo.animFileIndex ) )
+				{
+					animation_t *anim;
+					anim = &level.knownAnimFileSets[genemy->client->clientInfo.animFileIndex].animations[genemy->client->ps.torsoAnim];
+					/*
+					float		currentFrame, junk2;
+					int			junk;
+
+					gi.G2API_GetBoneAnimIndex( &genemy->ghoul2[genemy->playerModel], genemy->lowerLumbarBone, (cg.time?cg.time:level.time), &currentFrame, &junk, &junk, &junk, &junk2, NULL );
+					*/
+
+					if ( !Q_irand( 0, 2 ) )
+					{
+						switch ( Q_irand( 0, 3 ) )
+						{
+						case 0:
+							G_AddEvent( genemy, EV_PAIN, floor((float)genemy->health/genemy->max_health*100.0f) );
+							break;
+						case 1:
+							G_AddVoiceEvent( genemy, Q_irand( EV_PUSHED1, EV_PUSHED3 ), 500 );
+							break;
+						case 2:
+							G_AddVoiceEvent( genemy, Q_irand( EV_CHOKE1, EV_CHOKE3 ), 500 );
+							break;
+						case 3:
+							G_AddVoiceEvent( genemy, EV_PUSHFAIL, 2000 );
+							break;
+						}
+					}
+
+					if ( PM_InSaberLockOld( genemy->client->ps.torsoAnim ) )
+					{
+						if ( genemy->client->ps.torsoAnim == BOTH_CCWCIRCLELOCK ||
+							genemy->client->ps.torsoAnim == BOTH_BF2LOCK )
+						{
+							PM_SetAnimFrame( genemy, anim->firstFrame+anim->numFrames-remaining, qtrue, qtrue );
+						}
+						else
+						{
+							PM_SetAnimFrame( genemy, anim->firstFrame+remaining, qtrue, qtrue );
+						}
+					}
+					else
+					{//new locks
+						//???
+						if ( G_CheckIncrementLockAnim( genemy->client->ps.torsoAnim, SABERLOCK_LOSE ) )
+						{
+							PM_SetAnimFrame( genemy, anim->firstFrame+anim->numFrames-remaining, qtrue, qtrue );
+						}
+						else
+						{
+							PM_SetAnimFrame( genemy, anim->firstFrame+remaining, qtrue, qtrue );
+						}
+					}
+				}
+			}
+		}
+		else
+		{//FIXME: other ways out of a saberlock?
+			//force-push?  (requires more force power?)
+			//kick?  (requires anim ... hit jump key?)
+			//roll?
+			//backflip?
+		}
+	}
+	else
+	{//something broke us out of it
+		if ( gent->painDebounceTime > level.time && genemy->painDebounceTime > level.time )
+		{
+			PM_SaberLockBreak( gent, genemy, LOCK_DRAW, 0 );
+		}
+		else if ( gent->painDebounceTime > level.time )
+		{
+			PM_SaberLockBreak( genemy, gent, LOCK_VICTORY, 0 );
+		}
+		else if ( genemy->painDebounceTime > level.time )
+		{
+			PM_SaberLockBreak( gent, genemy, LOCK_VICTORY, 0 );
+		}
+		else
+		{
+			PM_SaberLockBreak( gent, genemy, LOCK_STALEMATE, 0 );
+		}
+	}
+	return qtrue;
+}
+
+qboolean G_EnemyInKickRange( gentity_t *self, gentity_t *enemy )
+{
+	if ( !self || !enemy )
+	{
+		return qfalse;
+	}
+	if ( fabs(self->currentOrigin[2]-enemy->currentOrigin[2]) < 32 )
+	{//generally at same height
+		if ( DistanceHorizontal( self->currentOrigin, enemy->currentOrigin ) <= (STAFF_KICK_RANGE+8.0f+(self->maxs[0]*1.5f)+(enemy->maxs[0]*1.5f)) )
+		{//within kicking range!
+			return qtrue;
+		}
+	}
+	return qfalse;
+}
+
+qboolean G_CanKickEntity( gentity_t *self, gentity_t *target )
+{
+	if ( target && target->client
+		&& !PM_InKnockDown( &target->client->ps )
+		&& G_EnemyInKickRange( self, target ) )
+	{
+		return qtrue;
+	}
+	return qfalse;
+}
+
+float PM_GroundDistance(void)
+{
+	trace_t tr;
+	vec3_t down;
+
+	VectorCopy(pm->ps->origin, down);
+
+	down[2] -= 4096;
+
+	pm->trace(&tr, pm->ps->origin, pm->mins, pm->maxs, down, pm->ps->clientNum, pm->tracemask);
+
+	VectorSubtract(pm->ps->origin, tr.endpos, down);
+
+	return VectorLength(down);
+}
+
+float G_GroundDistance(gentity_t *self)
+{
+	if ( !self )
+	{//wtf?!!
+		return Q3_INFINITE;
+	}
+	trace_t tr;
+	vec3_t down;
+
+	VectorCopy(self->currentOrigin, down);
+
+	down[2] -= 4096;
+
+	gi.trace(&tr, self->currentOrigin, self->mins, self->maxs, down, self->s.number, self->clipmask);
+
+	VectorSubtract(self->currentOrigin, tr.endpos, down);
+
+	return VectorLength(down);
+}
+
+saberMoveName_t G_PickAutoKick( gentity_t *self, gentity_t *enemy, qboolean storeMove )
+{
+	saberMoveName_t kickMove = LS_NONE;
+	if ( !self || !self->client )
+	{
+		return LS_NONE;
+	}
+	if ( !enemy )
+	{
+		return LS_NONE;
+	}
+	vec3_t	v_fwd, v_rt, enemyDir, fwdAngs = {0,self->client->ps.viewangles[YAW],0};
+	VectorSubtract( enemy->currentOrigin, self->currentOrigin, enemyDir );
+	VectorNormalize( enemyDir );//not necessary, I guess, but doesn't happen often
+	AngleVectors( fwdAngs, v_fwd, v_rt, NULL );
+	float fDot = DotProduct( enemyDir, v_fwd );
+	float rDot = DotProduct( enemyDir, v_rt );
+	if ( fabs( rDot ) > 0.5f && fabs( fDot ) < 0.5f )
+	{//generally to one side
+		if ( rDot > 0 )
+		{//kick right
+			kickMove = LS_KICK_R;
+		}
+		else
+		{//kick left
+			kickMove = LS_KICK_L;
+		}
+	}
+	else if ( fabs( fDot ) > 0.5f && fabs( rDot ) < 0.5f )
+	{//generally in front or behind us
+		if ( fDot > 0 )
+		{//kick fwd
+			kickMove = LS_KICK_F;
+		}
+		else
+		{//kick back
+			kickMove = LS_KICK_B;
+		}
+	}
+	else
+	{//diagonal to us, kick would miss
+	}
+	if ( kickMove != LS_NONE )
+	{//have a valid one to do
+		if ( self->client->ps.groundEntityNum == ENTITYNUM_NONE )
+		{//if in air, convert kick to an in-air kick
+			float gDist = G_GroundDistance( self );
+			//let's only allow air kicks if a certain distance from the ground
+			//it's silly to be able to do them right as you land.
+			//also looks wrong to transition from a non-complete flip anim...
+			if ((!PM_FlippingAnim( self->client->ps.legsAnim ) || self->client->ps.legsAnimTimer <= 0) &&
+				gDist > 64.0f && //strict minimum
+				gDist > (-self->client->ps.velocity[2])-64.0f //make sure we are high to ground relative to downward velocity as well
+				)
+			{
+				switch ( kickMove )
+				{
+				case LS_KICK_F:
+					kickMove = LS_KICK_F_AIR;
+					break;
+				case LS_KICK_B:
+					kickMove = LS_KICK_B_AIR;
+					break;
+				case LS_KICK_R:
+					kickMove = LS_KICK_R_AIR;
+					break;
+				case LS_KICK_L:
+					kickMove = LS_KICK_L_AIR;
+					break;
+				default: //oh well, can't do any other kick move while in-air
+					kickMove = LS_NONE;
+					break;
+				}
+			}
+			else
+			{//leave it as a normal kick unless we're too high up
+				if ( gDist > 128.0f || self->client->ps.velocity[2] >= 0 )
+				{ //off ground, but too close to ground
+					kickMove = LS_NONE;
+				}
+			}
+		}
+		if ( storeMove )
+		{
+			self->client->ps.saberMoveNext = kickMove;
+		}
+	}
+	return kickMove;
+}
+
+saberMoveName_t PM_PickAutoKick( gentity_t *enemy )
+{
+	return G_PickAutoKick( pm->gent, enemy, qfalse );
+}
+
+saberMoveName_t G_PickAutoMultiKick( gentity_t *self, qboolean allowSingles, qboolean storeMove )
+{
+	gentity_t	*ent;
+	gentity_t	*entityList[MAX_GENTITIES];
+	vec3_t		mins, maxs;
+	int			i, e;
+	int			radius = ((self->maxs[0]*1.5f)+(self->maxs[0]*1.5f)+STAFF_KICK_RANGE+24.0f);//a little wide on purpose
+	vec3_t		center;
+	saberMoveName_t kickMove, bestKick = LS_NONE;
+	float		distToEnt, bestDistToEnt = Q3_INFINITE;
+	gentity_t	*bestEnt = NULL;
+	int			enemiesFront = 0;
+	int			enemiesBack = 0;
+	int			enemiesRight = 0;
+	int			enemiesLeft = 0;
+	int			enemiesSpin = 0;
+	
+	if ( !self || !self->client )
+	{
+		return LS_NONE;
+	}
+
+	VectorCopy( self->currentOrigin, center );
+
+	for ( i = 0 ; i < 3 ; i++ ) 
+	{
+		mins[i] = center[i] - radius;
+		maxs[i] = center[i] + radius;
+	}
+
+	int numListedEntities = gi.EntitiesInBox( mins, maxs, entityList, MAX_GENTITIES );
+
+	for ( e = 0 ; e < numListedEntities ; e++ ) 
+	{
+		ent = entityList[ e ];
+
+		if (ent == self)
+			continue;
+		if (ent->owner == self)
+			continue;
+		if ( !(ent->inuse) )
+			continue;
+		//not a client?
+		if ( !ent->client )
+			continue;
+		//ally?
+		if ( ent->client->playerTeam == self->client->playerTeam )
+			continue;
+		//dead?
+		if ( ent->health <= 0 )
+			continue;
+		//too far?
+		distToEnt = DistanceSquared( ent->currentOrigin, center );
+		if ( distToEnt > (radius*radius) )
+			continue;
+		kickMove = G_PickAutoKick( self, ent, qfalse );
+		if ( kickMove == LS_KICK_F_AIR
+			&& kickMove == LS_KICK_B_AIR
+			&& kickMove == LS_KICK_R_AIR
+			&& kickMove == LS_KICK_L_AIR )
+		{//in air?  Can't do multikicks
+		}
+		else
+		{
+			switch ( kickMove )
+			{
+			case LS_KICK_F:
+				enemiesFront++;
+				break;
+			case LS_KICK_B:
+				enemiesBack++;
+				break;
+			case LS_KICK_R:
+				enemiesRight++;
+				break;
+			case LS_KICK_L:
+				enemiesLeft++;
+				break;
+			default:
+				enemiesSpin++;
+				break;
+			}
+		}
+		if ( allowSingles )
+		{
+			if ( kickMove != LS_NONE
+				&& distToEnt < bestDistToEnt )
+			{
+				bestKick = kickMove;
+				bestEnt = ent;
+			}
+		}
+	}
+	kickMove = LS_NONE;
+	if ( self->client->ps.groundEntityNum != ENTITYNUM_NONE )
+	{//can't do the multikicks in air
+		if ( enemiesFront && enemiesBack 
+			&& (enemiesFront+enemiesBack)-(enemiesRight+enemiesLeft)>1 )
+		{//more enemies in front/back than left/right
+			kickMove = LS_KICK_BF;
+		}
+		else if ( enemiesRight && enemiesLeft
+			&& (enemiesRight+enemiesLeft)-(enemiesFront+enemiesBack)>1 )
+		{//more enemies on left & right than front/back
+			kickMove = LS_KICK_RL;
+		}
+		else if ( (enemiesFront || enemiesBack) && (enemiesRight || enemiesLeft) )
+		{//at least 2 enemies around us, not aligned
+			kickMove = LS_KICK_S;
+		}
+		else if ( enemiesSpin > 1 )
+		{//at least 2 enemies around us, not aligned
+			kickMove = LS_KICK_S;
+		}
+	}
+	if ( kickMove == LS_NONE
+		&& bestKick != LS_NONE )
+	{//no good multi-kick move, but we do have a nice single-kick we found
+		kickMove = bestKick;
+		//get mad at him so he knows he's being targetted
+		if ( (self->s.number < MAX_CLIENTS||G_ControlledByPlayer(self))
+			&& bestEnt != NULL )
+		{//player
+			G_SetEnemy( self, bestEnt );
+		}
+	}
+	if ( kickMove != LS_NONE )
+	{
+		if ( storeMove )
+		{
+			self->client->ps.saberMoveNext = kickMove;
+		}
+	}
+	return kickMove;
+}
+
+qboolean PM_PickAutoMultiKick( qboolean allowSingles )
+{
+	saberMoveName_t kickMove = G_PickAutoMultiKick( pm->gent, allowSingles, qfalse );
+	if ( kickMove != LS_NONE )
+	{
+		PM_SetSaberMove( kickMove );
+		return qtrue;
+	}
+	return qfalse;
+}
+
+qboolean PM_SaberThrowable( void )
+{
+	//ugh, hard-coding this is bad...
+	if ( pm->ps->saberAnimLevel == SS_STAFF )
+	{
+		return qfalse;
+	}
+	
+	if ( pm->ps->saber[0].throwable )
+	{//yes, this saber is always throwable
+		return qtrue;
+	}
+
+	//saber is not normally throwable
+	if ( pm->ps->saber[0].singleBladeThrowable )
+	{//it is throwable if only one blade is on
+		if ( pm->ps->saber[0].numBlades > 1 )
+		{//it has more than one blade
+			int numBladesActive = 0;
+			for ( int i = 0; i < pm->ps->saber[0].numBlades; i++ )
+			{
+				if ( pm->ps->saber[0].blade[i].active )
+				{
+					numBladesActive++;
+				}
+			}
+			if ( numBladesActive == 1 )
+			{//only 1 blade is on
+				return qtrue;
+			}
+		}
+	}
+	//nope, can't throw it
+	return qfalse;
+}
+
+qboolean PM_CheckAltKickAttack( void )
+{
+	if ( (pm->cmd.buttons&BUTTON_ALT_ATTACK) 
+		&& (!(pm->ps->pm_flags&PMF_ALT_ATTACK_HELD) ||PM_SaberInReturn(pm->ps->saberMove))
+		&& (!PM_FlippingAnim(pm->ps->legsAnim)||pm->ps->legsAnimTimer<=250)
+		&& (!PM_SaberThrowable()) && pm->ps->SaberActive() )
+	{
+		return qtrue;
+	}
+	return qfalse;
+}
+
+qboolean PM_CheckUpsideDownAttack( void )
+{
+	if ( pm->ps->saberMove != LS_READY )
+	{
+		return qfalse;
+	}
+	if ( !(pm->cmd.buttons&BUTTON_ATTACK) )
+	{
+		return qfalse;
+	}
+	if ( pm->ps->saberAnimLevel < SS_FAST 
+		|| pm->ps->saberAnimLevel > SS_STRONG )
+	{
+		return qfalse;
+	}
+	if ( (pm->ps->clientNum >= MAX_CLIENTS&&!PM_ControlledByPlayer()) )
+	{//FIXME: check ranks?
+		return qfalse;
+	}
+	//FIXME: enemy below
+	//FIXME: more than 64 off ground
+	if ( !g_debugMelee->integer )
+	{//hmm, can't get this to work quite the way we wanted... secret move, then!
+		return qfalse;
+	}
+
+	switch( pm->ps->legsAnim )
+	{
+	case BOTH_WALL_RUN_RIGHT_FLIP:
+	case BOTH_WALL_RUN_LEFT_FLIP:
+	case BOTH_WALL_FLIP_RIGHT:
+	case BOTH_WALL_FLIP_LEFT:
+	case BOTH_FLIP_BACK1:
+	case BOTH_FLIP_BACK2:
+	case BOTH_FLIP_BACK3:
+	case BOTH_WALL_FLIP_BACK1:
+	case BOTH_ALORA_FLIP_B:
+	//JKA
+	case BOTH_FORCEWALLRUNFLIP_END:
+		{
+			float animLength = PM_AnimLength( pm->gent->client->clientInfo.animFileIndex, (animNumber_t)pm->ps->legsAnim );
+			float elapsedTime = (float)(animLength-pm->ps->legsAnimTimer);
+			float midPoint = animLength/2.0f;
+			if ( elapsedTime < midPoint-100.0f
+				|| elapsedTime > midPoint+100.0f )
+			{//only a 200ms window (in middle of anim) of opportunity to do this move in these anims
+				return qfalse;
+			}
+		}
+		//NOTE: falls through on purpose
+	case BOTH_FLIP_HOLD7:
+		pm->ps->pm_flags |= PMF_SLOW_MO_FALL;
+		PM_SetSaberMove( LS_UPSIDE_DOWN_ATTACK );
+		return qtrue;
+		break;
+	}
+	return qfalse;
+}
+
+qboolean PM_SaberMoveOkayForKata( void )
+{
+	if ( g_saberNewControlScheme->integer )
+	{
+		if ( pm->ps->saberMove == LS_READY //not doing anything
+			|| PM_SaberInReflect( pm->ps->saberMove ) )//interrupt a projectile blocking move
+		{
+			return qtrue;
+		}
+		else
+		{
+			return qfalse;
+		}
+	}
+	else
+	{//old control scheme, allow it to interrupt a start or ready
+		if ( pm->ps->saberMove == LS_READY
+			|| PM_SaberInReflect( pm->ps->saberMove )//interrupt a projectile blocking move
+			|| PM_SaberInStart( pm->ps->saberMove ) )
+		{
+			return qtrue;
+		}
+		else
+		{
+			return qfalse;
+		}
+	}
+}
+
+qboolean PM_CanDoKata( void )
+{
+	if ( PM_InSecondaryStyle() )
+	{
+		return qfalse;
+	}
+	if ( !pm->ps->saberInFlight//not throwing saber
+		&& PM_SaberMoveOkayForKata()
+		/*
+		&& pm->ps->saberAnimLevel >= SS_FAST//fast, med or strong style
+		&& pm->ps->saberAnimLevel <= SS_STRONG//FIXME: Tavion, too?
+		*/
+		&& pm->ps->groundEntityNum != ENTITYNUM_NONE//not in the air
+		&& (pm->cmd.buttons&BUTTON_ATTACK)//pressing attack
+		&& pm->cmd.forwardmove >=0 //not moving back (used to be !pm->cmd.forwardmove)
+		&& !pm->cmd.rightmove//not moving r/l
+		&& pm->cmd.upmove <= 0//not jumping...?
+		&& G_TryingKataAttack(pm->gent,&pm->cmd)/*(pm->cmd.buttons&BUTTON_FORCE_FOCUS)*///holding focus
+		&& G_EnoughPowerForSpecialMove( pm->ps->forcePower, SABER_ALT_ATTACK_POWER, qtrue )/*pm->ps->forcePower >= SABER_ALT_ATTACK_POWER*/ )//SINGLE_SPECIAL_POWER )// have enough power
+	{//FIXME: check rage, etc...
+		return qtrue;
+	}
+	return qfalse;
+}
+
+void PM_SaberDroidWeapon( void )
+{
+	// make weapon function
+	if ( pm->ps->weaponTime > 0 ) {
+		pm->ps->weaponTime -= pml.msec;
+		if ( pm->ps->weaponTime <= 0 )
+		{
+			pm->ps->weaponTime = 0;
+		}
+	}
+
+	// Now we react to a block action by the player's lightsaber.
+	if ( pm->ps->saberBlocked )
+	{
+		switch ( pm->ps->saberBlocked )
+		{
+			case BLOCKED_PARRY_BROKEN:
+				PM_SetAnim( pm, SETANIM_BOTH, Q_irand(BOTH_PAIN1,BOTH_PAIN3), SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+				pm->ps->weaponTime = pm->ps->legsAnimTimer;
+				break;
+			case BLOCKED_ATK_BOUNCE:
+				PM_SetAnim( pm, SETANIM_BOTH, Q_irand(BOTH_PAIN1,BOTH_PAIN3), SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+				pm->ps->weaponTime = pm->ps->legsAnimTimer;
+				break;
+			case BLOCKED_UPPER_RIGHT:
+			case BLOCKED_UPPER_RIGHT_PROJ:
+			case BLOCKED_LOWER_RIGHT:
+			case BLOCKED_LOWER_RIGHT_PROJ:
+				PM_SetAnim( pm, SETANIM_BOTH, BOTH_P1_S1_TR, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+				pm->ps->legsAnimTimer += Q_irand( 200, 1000 );
+				pm->ps->weaponTime = pm->ps->legsAnimTimer;
+				break;
+			case BLOCKED_UPPER_LEFT:
+			case BLOCKED_UPPER_LEFT_PROJ:
+			case BLOCKED_LOWER_LEFT:
+			case BLOCKED_LOWER_LEFT_PROJ:
+				PM_SetAnim( pm, SETANIM_BOTH, BOTH_P1_S1_TL, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+				pm->ps->legsAnimTimer += Q_irand( 200, 1000 );
+				pm->ps->weaponTime = pm->ps->legsAnimTimer;
+				break;
+			case BLOCKED_TOP:
+			case BLOCKED_TOP_PROJ:
+				PM_SetAnim( pm, SETANIM_BOTH, BOTH_P1_S1_T_, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+				pm->ps->legsAnimTimer += Q_irand( 200, 1000 );
+				pm->ps->weaponTime = pm->ps->legsAnimTimer;
+				break;
+			default:
+				pm->ps->saberBlocked = BLOCKED_NONE;
+				break;
+		}
+
+		pm->ps->saberBlocked = BLOCKED_NONE;
+		pm->ps->saberBounceMove = LS_NONE;
+		pm->ps->weaponstate = WEAPON_READY;
+		
+		// Done with block, so stop these active weapon branches.
+		return;
+	}
+}
+
+void PM_TryGrab( void )
+{
+	if ( pm->ps->groundEntityNum != ENTITYNUM_NONE 
+		//&& !pm->ps->saberInFlight
+		&& pm->ps->weaponTime <= 0 )//< 200 )
+	{
+		PM_SetAnim( pm, SETANIM_BOTH, BOTH_KYLE_GRAB, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+		pm->ps->torsoAnimTimer += 200;
+		pm->ps->weaponTime = pm->ps->torsoAnimTimer;
+		pm->ps->saberMove = pm->ps->saberMoveNext = LS_READY;
+		VectorClear( pm->ps->velocity );
+		VectorClear( pm->ps->moveDir );
+		pm->cmd.rightmove = pm->cmd.forwardmove = pm->cmd.upmove = 0;
+		if ( pm->gent )
+		{
+			pm->gent->painDebounceTime = level.time + pm->ps->torsoAnimTimer;
+		}
+		pm->ps->SaberDeactivate();
+	}
+}
+
+void PM_TryAirKick( saberMoveName_t kickMove )
+{
+	if ( pm->ps->groundEntityNum < ENTITYNUM_NONE )
+	{//just do it
+		PM_SetSaberMove( kickMove );
+	}
+	else
+	{
+		float gDist = PM_GroundDistance();
+		//let's only allow air kicks if a certain distance from the ground
+		//it's silly to be able to do them right as you land.
+		//also looks wrong to transition from a non-complete flip anim...
+		if ((!PM_FlippingAnim( pm->ps->legsAnim ) || pm->ps->legsAnimTimer <= 0) &&
+			gDist > 64.0f && //strict minimum
+			gDist > (-pm->ps->velocity[2])-64.0f //make sure we are high to ground relative to downward velocity as well
+			)
+		{
+			PM_SetSaberMove( kickMove );
+		}
+		else
+		{//leave it as a normal kick unless we're too high up
+			if ( gDist > 128.0f || pm->ps->velocity[2] >= 0 )
+			{ //off ground, but too close to ground
+			}
+			else
+			{//high close enough to ground to do a normal kick, convert it
+				switch ( kickMove )
+				{
+				case LS_KICK_F_AIR:
+					PM_SetSaberMove( LS_KICK_F );
+					break;
+				case LS_KICK_B_AIR:
+					PM_SetSaberMove( LS_KICK_B );
+					break;
+				case LS_KICK_R_AIR:
+					PM_SetSaberMove( LS_KICK_R );
+					break;
+				case LS_KICK_L_AIR:
+					PM_SetSaberMove( LS_KICK_L );
+					break;
+				}
+			}
+		}
+	}
+}
+
+void PM_CheckKick( void )
+{
+	if ( !PM_KickMove( pm->ps->saberMove )//not already in a kick
+		&& !(pm->ps->pm_flags&PMF_DUCKED)//not ducked
+		&& (pm->cmd.upmove >= 0 ) )//not trying to duck
+	{//player kicks
+		//FIXME: only if FP_SABER_OFFENSE >= 3
+		if ( pm->cmd.rightmove )
+		{//kick to side
+			if ( pm->cmd.rightmove > 0 )
+			{//kick right
+				if ( pm->ps->groundEntityNum == ENTITYNUM_NONE 
+					|| pm->cmd.upmove > 0 )
+				{
+					PM_TryAirKick( LS_KICK_R_AIR );
+				}
+				else
+				{
+					PM_SetSaberMove( LS_KICK_R );
+				}
+			}
+			else
+			{//kick left
+				if ( pm->ps->groundEntityNum == ENTITYNUM_NONE 
+					|| pm->cmd.upmove > 0 )
+				{
+					PM_TryAirKick( LS_KICK_L_AIR );
+				}
+				else
+				{
+					PM_SetSaberMove( LS_KICK_L );
+				}
+			}
+			pm->cmd.rightmove = 0;
+		}
+		else if ( pm->cmd.forwardmove )
+		{//kick front/back
+			if ( pm->cmd.forwardmove > 0 )
+			{//kick fwd
+				if ( pm->ps->groundEntityNum == ENTITYNUM_NONE
+					|| pm->cmd.upmove > 0 )
+				{
+					PM_TryAirKick( LS_KICK_F_AIR );
+				}
+				/*
+				else if ( pm->ps->weapon == WP_SABER
+					&& pm->ps->saberAnimLevel == SS_STAFF
+					&& pm->gent 
+					&& G_CheckEnemyPresence( pm->gent, DIR_FRONT, 64, 0.8f ) )
+				{//FIXME: don't jump while doing this move and don't do this move if in air
+					PM_SetSaberMove( LS_HILT_BASH );
+				}
+				*/
+				else
+				{
+					PM_SetSaberMove( LS_KICK_F );
+				}
+			}
+			else if ( pm->ps->groundEntityNum == ENTITYNUM_NONE
+					|| pm->cmd.upmove > 0 )
+			{
+				PM_TryAirKick( LS_KICK_B_AIR );
+			}
+			else
+			{//kick back
+				PM_SetSaberMove( LS_KICK_B );
+			}
+			pm->cmd.forwardmove = 0;
+		}
+		else if ( pm->gent 
+			&& pm->gent->enemy
+			&& G_CanKickEntity( pm->gent, pm->gent->enemy ) )
+		{//auto-pick?
+			if ( /*(pm->ps->pm_flags&PMF_ALT_ATTACK_HELD)
+				&& (pm->cmd.buttons&BUTTON_ATTACK)
+				&&*/ PM_PickAutoMultiKick( qfalse ) )
+			{//kicked!
+				if ( pm->ps->saberMove == LS_KICK_RL )
+				{//just pull back
+					if ( d_slowmodeath->integer > 3 )
+					{
+						G_StartMatrixEffect( pm->gent, MEF_NO_SPIN, pm->ps->legsAnimTimer+500 );
+					}
+				}
+				else
+				{//normal spin
+					if ( d_slowmodeath->integer > 3 )
+					{
+	                    G_StartMatrixEffect( pm->gent, 0, pm->ps->legsAnimTimer+500 );
+					}
+				}
+				if ( pm->ps->groundEntityNum == ENTITYNUM_NONE 
+					&&( pm->ps->saberMove == LS_KICK_S 
+						||pm->ps->saberMove == LS_KICK_BF
+						||pm->ps->saberMove == LS_KICK_RL ) )
+				{//in the air and doing a jump-kick, which is a ground anim, so....
+					//cut z velocity...?
+					pm->ps->velocity[2] = 0;
+				}
+				pm->cmd.upmove = 0;
+			}
+			else
+			{
+				saberMoveName_t kickMove = PM_PickAutoKick( pm->gent->enemy );
+				if ( kickMove != LS_NONE )
+				{//Matrix?
+					PM_SetSaberMove( kickMove );
+					int meFlags = 0;
+					switch ( kickMove )
+					{
+					case LS_KICK_B://just pull back
+					case LS_KICK_B_AIR://just pull back
+						meFlags = MEF_NO_SPIN;
+						break;
+					case LS_KICK_L://spin to the left
+					case LS_KICK_L_AIR://spin to the left
+						meFlags = MEF_REVERSE_SPIN;
+						break;
+					default:
+						break;
+					}
+					if ( d_slowmodeath->integer > 3 )
+					{
+						G_StartMatrixEffect( pm->gent, meFlags, pm->ps->legsAnimTimer+500 );
+					}
+				}
+			}
+		}
+		else
+		{
+			if ( PM_PickAutoMultiKick( qtrue ) )
+			{
+				int meFlags = 0;
+				switch ( pm->ps->saberMove )
+				{
+				case LS_KICK_RL://just pull back
+				case LS_KICK_B://just pull back
+				case LS_KICK_B_AIR://just pull back
+					meFlags = MEF_NO_SPIN;
+					break;
+				case LS_KICK_L://spin to the left
+				case LS_KICK_L_AIR://spin to the left
+					meFlags = MEF_REVERSE_SPIN;
+					break;
+				default:
+					break;
+				}
+				if ( d_slowmodeath->integer > 3 )
+				{
+					G_StartMatrixEffect( pm->gent, meFlags, pm->ps->legsAnimTimer+500 );
+				}
+				if ( pm->ps->groundEntityNum == ENTITYNUM_NONE 
+					&&( pm->ps->saberMove == LS_KICK_S 
+						||pm->ps->saberMove == LS_KICK_BF
+						||pm->ps->saberMove == LS_KICK_RL ) )
+				{//in the air and doing a jump-kick, which is a ground anim, so....
+					//cut z velocity...?
+					pm->ps->velocity[2] = 0;
+				}
+				pm->cmd.upmove = 0;
+			}
+		}
+	}
+}
+
+void PM_CheckClearSaberBlock( void )
+{
+	if ( pm->ps->clientNum < MAX_CLIENTS || PM_ControlledByPlayer() )
+	{//player
+		if ( pm->ps->saberBlocked >= BLOCKED_UPPER_RIGHT_PROJ && pm->ps->saberBlocked <= BLOCKED_TOP_PROJ )
+		{//blocking a projectile
+			if ( pm->ps->forcePowerDebounce[FP_SABER_DEFENSE] < level.time )
+			{//block is done or breaking out of it with an attack
+				pm->ps->weaponTime = 0;
+				pm->ps->saberBlocked = BLOCKED_NONE;
+			}
+			else if ( (pm->cmd.buttons&BUTTON_ATTACK) )
+			{//block is done or breaking out of it with an attack
+				pm->ps->weaponTime = 0;
+				pm->ps->saberBlocked = BLOCKED_NONE;
+			}
+		}
+		else if ( pm->ps->saberBlocked == BLOCKED_UPPER_LEFT
+			&& pm->ps->powerups[PW_SHOCKED] > level.time )
+		{//probably blocking lightning
+			if ( (pm->cmd.buttons&BUTTON_ATTACK) )
+			{//trying to attack
+				//allow the attack
+				pm->ps->weaponTime = 0;
+				pm->ps->saberBlocked = BLOCKED_NONE;
+			}
+		}
+	}
+}
+
+qboolean PM_SaberBlocking( void )
+{
+	// Now we react to a block action by the player's lightsaber.
+	if ( pm->ps->saberBlocked )
+	{
+		if ( pm->ps->saberMove > LS_PUTAWAY && pm->ps->saberMove <= LS_A_BL2TR && pm->ps->saberBlocked != BLOCKED_PARRY_BROKEN &&
+			(pm->ps->saberBlocked < BLOCKED_UPPER_RIGHT_PROJ || pm->ps->saberBlocked > BLOCKED_TOP_PROJ))//&& Q_irand( 0, 2 )
+		{//we parried another lightsaber while attacking, so treat it as a bounce
+			pm->ps->saberBlocked = BLOCKED_ATK_BOUNCE;
+		} 
+		else if ( pm->ps->clientNum < MAX_CLIENTS||PM_ControlledByPlayer() )//player
+		{
+			if ( pm->ps->saberBlocked >= BLOCKED_UPPER_RIGHT_PROJ
+				&& pm->ps->saberBlocked <= BLOCKED_TOP_PROJ )
+			{//blocking a projectile
+				if ( (pm->cmd.buttons&BUTTON_ATTACK) )
+				{//trying to attack
+					if ( pm->ps->saberMove == LS_READY
+						|| PM_SaberInReflect( pm->ps->saberMove ) )
+					{//not already busy or already in projectile deflection
+						//trying to attack during projectile blocking, so do the attack instead
+						pm->ps->saberBlocked = BLOCKED_NONE;
+						pm->ps->saberBounceMove = LS_NONE;
+						pm->ps->weaponstate = WEAPON_READY;
+						if ( PM_SaberInReflect( pm->ps->saberMove ) && pm->ps->weaponTime > 0 )
+						{//interrupt the current deflection move
+							pm->ps->weaponTime = 0;
+						}
+						return qfalse;
+					}
+				}
+			}
+		}
+		/*
+		else if ( (pm->cmd.buttons&BUTTON_ATTACK) 
+			&& pm->ps->saberBlocked >= BLOCKED_UPPER_RIGHT
+			&& pm->ps->saberBlocked <= BLOCKED_TOP 
+			&& !PM_SaberInKnockaway( pm->ps->saberBounceMove ) )
+		{//if hitting attack during a parry (not already a knockaway)
+			if ( pm->ps->forcePowerLevel[FP_SABER_DEFENSE] > FORCE_LEVEL_2 )
+			{//have high saber defense, turn the parry into a knockaway?
+				//FIXME: this could actually be bad for us...?  Leaves us open
+				pm->ps->saberBounceMove = PM_KnockawayForParry( pm->ps->saberBlocked );
+			}
+		}
+		*/
+
+		if ( pm->ps->saberBlocked != BLOCKED_ATK_BOUNCE )
+		{//can't attack for twice whatever your skill level's parry debounce time is
+			if ( pm->ps->clientNum == 0 || PM_ControlledByPlayer() )
+			{//player
+				if ( pm->ps->forcePowerLevel[FP_SABER_DEFENSE] <= FORCE_LEVEL_1 )
+				{
+					pm->ps->weaponTime = parryDebounce[pm->ps->forcePowerLevel[FP_SABER_DEFENSE]];
+				}
+			}
+			else
+			{//NPC
+				//pm->ps->weaponTime = parryDebounce[pm->ps->forcePowerLevel[FP_SABER_DEFENSE]] * 2;
+				if ( pm->gent )
+				{
+					pm->ps->weaponTime = Jedi_ReCalcParryTime( pm->gent, EVASION_PARRY );
+				}
+				else
+				{//WTF???
+					pm->ps->weaponTime = parryDebounce[pm->ps->forcePowerLevel[FP_SABER_DEFENSE]] * 2;
+				}
+			}
+		}
+		switch ( pm->ps->saberBlocked )
+		{
+			case BLOCKED_PARRY_BROKEN:
+				//whatever parry we were is in now broken, play the appropriate knocked-away anim
+				{
+					saberMoveName_t nextMove;
+					if ( PM_SaberInBrokenParry( pm->ps->saberBounceMove ) )
+					{//already have one...?
+						nextMove = (saberMoveName_t)pm->ps->saberBounceMove;
+					}
+					else
+					{
+						nextMove = PM_BrokenParryForParry( (saberMoveName_t)pm->ps->saberMove );
+					}
+					if ( nextMove != LS_NONE )
+					{
+						PM_SetSaberMove( nextMove );
+						pm->ps->weaponTime = pm->ps->torsoAnimTimer;
+					}
+					else
+					{//Maybe in a knockaway?
+					}
+					//pm->ps->saberBounceMove = LS_NONE;
+				}
+				break;
+			case BLOCKED_ATK_BOUNCE:
+				// If there is absolutely no blocked move in the chart, don't even mess with the animation.
+				// OR if we are already in a block or parry.
+				if ( pm->ps->saberMove >= LS_T1_BR__R/*LS_BOUNCE_TOP*/ )//|| saberMoveData[pm->ps->saberMove].bounceMove == LS_NONE )
+				{//an actual bounce?  Other bounces before this are actually transitions?
+					pm->ps->saberBlocked = BLOCKED_NONE;
+				}
+				else if ( PM_SaberInBounce( pm->ps->saberMove ) || !PM_SaberInAttack( pm->ps->saberMove ) )
+				{//already in the bounce, go into an attack or transition to ready.. should never get here since can't be blocked in a bounce!
+					int nextMove;
+
+					if ( pm->cmd.buttons & BUTTON_ATTACK )
+					{//transition to a new attack
+						if ( pm->ps->clientNum && !PM_ControlledByPlayer() )
+						{//NPC
+							nextMove = saberMoveData[pm->ps->saberMove].chain_attack;
+						}
+						else
+						{//player
+							int newQuad = PM_SaberMoveQuadrantForMovement( &pm->cmd );
+							while ( newQuad == saberMoveData[pm->ps->saberMove].startQuad )
+							{//player is still in same attack quad, don't repeat that attack because it looks bad, 
+								//FIXME: try to pick one that might look cool?
+								newQuad = Q_irand( Q_BR, Q_BL );
+								//FIXME: sanity check, just in case?
+							}//else player is switching up anyway, take the new attack dir
+							nextMove = transitionMove[saberMoveData[pm->ps->saberMove].startQuad][newQuad];
+						}
+					}
+					else
+					{//return to ready
+						if ( pm->ps->clientNum && !PM_ControlledByPlayer() )
+						{//NPC
+							nextMove = saberMoveData[pm->ps->saberMove].chain_idle;
+						}
+						else
+						{//player
+							if ( saberMoveData[pm->ps->saberMove].startQuad == Q_T )
+							{
+								nextMove = LS_R_BL2TR;
+							}
+							else if ( saberMoveData[pm->ps->saberMove].startQuad < Q_T )
+							{
+								nextMove = LS_R_TL2BR+(saberMoveName_t)(saberMoveData[pm->ps->saberMove].startQuad-Q_BR);
+							}
+							else// if ( saberMoveData[pm->ps->saberMove].startQuad > Q_T )
+							{
+								nextMove = LS_R_BR2TL+(saberMoveName_t)(saberMoveData[pm->ps->saberMove].startQuad-Q_TL);
+							}
+						}
+					}
+					PM_SetSaberMove( (saberMoveName_t)nextMove );
+					pm->ps->weaponTime = pm->ps->torsoAnimTimer;
+				}
+				else
+				{//start the bounce move
+					saberMoveName_t bounceMove;
+					if ( pm->ps->saberBounceMove != LS_NONE )
+					{
+						bounceMove = (saberMoveName_t)pm->ps->saberBounceMove;
+					}
+					else
+					{
+						bounceMove = PM_SaberBounceForAttack( (saberMoveName_t)pm->ps->saberMove );
+					}
+					PM_SetSaberMove( bounceMove );
+					pm->ps->weaponTime = pm->ps->torsoAnimTimer;
+				}
+				//clear the saberBounceMove
+				//pm->ps->saberBounceMove = LS_NONE;
+
+				if (cg_debugSaber.integer>=2)
+				{
+					Com_Printf("Saber Block: Bounce\n");
+				}
+				break;
+			case BLOCKED_UPPER_RIGHT:
+				if ( pm->ps->saberBounceMove != LS_NONE )
+				{
+					PM_SetSaberMove( (saberMoveName_t)pm->ps->saberBounceMove );
+					//pm->ps->saberBounceMove = LS_NONE;
+					pm->ps->weaponTime = pm->ps->torsoAnimTimer;
+				}
+				else
+				{
+					PM_SetSaberMove( LS_PARRY_UR );
+				}
+
+				if ( cg_debugSaber.integer >= 2 )
+				{
+					Com_Printf( "Saber Block: Parry UR\n" );
+				}
+				break;
+			case BLOCKED_UPPER_RIGHT_PROJ:
+				PM_SetSaberMove( LS_REFLECT_UR );
+
+				if ( cg_debugSaber.integer >= 2 )
+				{
+					Com_Printf("Saber Block: Deflect UR\n");
+				}
+				break;
+			case BLOCKED_UPPER_LEFT:
+				if ( pm->ps->saberBounceMove != LS_NONE )
+				{
+					PM_SetSaberMove( (saberMoveName_t)pm->ps->saberBounceMove );
+					//pm->ps->saberBounceMove = LS_NONE;
+					pm->ps->weaponTime = pm->ps->torsoAnimTimer;
+				}
+				else
+				{
+					PM_SetSaberMove( LS_PARRY_UL );
+				}
+
+				if ( cg_debugSaber.integer >= 2 )
+				{
+					Com_Printf( "Saber Block: Parry UL\n" );
+				}
+				break;
+			case BLOCKED_UPPER_LEFT_PROJ:
+				PM_SetSaberMove( LS_REFLECT_UL );
+
+				if ( cg_debugSaber.integer >= 2 )
+				{
+					Com_Printf("Saber Block: Deflect UL\n");
+				}
+				break;
+			case BLOCKED_LOWER_RIGHT:
+				if ( pm->ps->saberBounceMove != LS_NONE )
+				{
+					PM_SetSaberMove( (saberMoveName_t)pm->ps->saberBounceMove );
+					//pm->ps->saberBounceMove = LS_NONE;
+					pm->ps->weaponTime = pm->ps->torsoAnimTimer;
+				}
+				else
+				{
+					PM_SetSaberMove( LS_PARRY_LR );
+				}
+
+				if ( cg_debugSaber.integer >= 2 )
+				{
+					Com_Printf("Saber Block: Parry LR\n");
+				}
+				break;
+			case BLOCKED_LOWER_RIGHT_PROJ:
+				PM_SetSaberMove( LS_REFLECT_LR );
+
+				if ( cg_debugSaber.integer >= 2 )
+				{
+					Com_Printf("Saber Block: Deflect LR\n");
+				}
+				break;
+			case BLOCKED_LOWER_LEFT:
+				if ( pm->ps->saberBounceMove != LS_NONE )
+				{
+					PM_SetSaberMove( (saberMoveName_t)pm->ps->saberBounceMove );
+					//pm->ps->saberBounceMove = LS_NONE;
+					pm->ps->weaponTime = pm->ps->torsoAnimTimer;
+				}
+				else
+				{
+					PM_SetSaberMove( LS_PARRY_LL );
+				}
+
+				if ( cg_debugSaber.integer >= 2 )
+				{
+					Com_Printf("Saber Block: Parry LL\n");
+				}
+				break;
+			case BLOCKED_LOWER_LEFT_PROJ:
+				PM_SetSaberMove( LS_REFLECT_LL);
+
+				if ( cg_debugSaber.integer >= 2 )
+				{
+					Com_Printf("Saber Block: Deflect LL\n");
+				}
+				break;
+			case BLOCKED_TOP:
+				if ( pm->ps->saberBounceMove != LS_NONE )
+				{
+					PM_SetSaberMove( (saberMoveName_t)pm->ps->saberBounceMove );
+					//pm->ps->saberBounceMove = LS_NONE;
+					pm->ps->weaponTime = pm->ps->torsoAnimTimer;
+				}
+				else
+				{
+					PM_SetSaberMove( LS_PARRY_UP );
+				}
+
+				if ( cg_debugSaber.integer >= 2 )
+				{
+					Com_Printf("Saber Block: Parry Top\n");
+				}
+				break;
+			case BLOCKED_TOP_PROJ:
+				PM_SetSaberMove( LS_REFLECT_UP );
+
+				if ( cg_debugSaber.integer >= 2 )
+				{
+					Com_Printf("Saber Block: Deflect Top\n");
+				}
+				break;
+			default:
+				pm->ps->saberBlocked = BLOCKED_NONE;
+				break;
+		}
+
+		// Charging is like a lead-up before attacking again.  This is an appropriate use, or we can create a new weaponstate for blocking
+		pm->ps->saberBounceMove = LS_NONE;
+		pm->ps->weaponstate = WEAPON_READY;
+		
+		// Done with block, so stop these active weapon branches.
+		return qtrue;
+	}
+	return qfalse;
+}
+
+qboolean PM_NPCCheckAttackRoll( void )
+{
+	if ( pm->ps->clientNum >= MAX_CLIENTS && !PM_ControlledByPlayer()//NPC
+		&& pm->gent
+		&& pm->gent->NPC
+		//&& Q_irand(-3,pm->gent->NPC->rank)>RANK_CREWMAN)
+		&& ( pm->gent->NPC->rank > RANK_CREWMAN && !Q_irand(0,3-g_spskill->integer) )
+		&& pm->gent->enemy
+		&& fabs(pm->gent->enemy->currentOrigin[2]-pm->ps->origin[2])<32
+		&& DistanceHorizontalSquared(pm->gent->enemy->currentOrigin, pm->ps->origin ) < (128.0f*128.0f)
+		&& InFOV( pm->gent->enemy->currentOrigin, pm->ps->origin, pm->ps->viewangles, 30, 90 ) )
+	{//stab!
+		return qtrue;
+	}
+	return qfalse;
+}
+/*
+=================
+PM_WeaponLightsaber
+
+Consults a chart to choose what to do with the lightsaber.
+While this is a little different than the Quake 3 code, there is no clean way of using the Q3 code for this kind of thing.
+=================
+*/
+// Ultimate goal is to set the sabermove to the proper next location
+// Note that if the resultant animation is NONE, then the animation is essentially "idle", and is set in WP_TorsoAnim
+void PM_WeaponLightsaber(void)
+{
+	int			addTime,amount;
+	qboolean	delayed_fire = qfalse, animLevelOverridden = qfalse;
+	weaponInfo_t	*weapon;
+	int			anim=-1;
+	int			curmove, newmove=LS_NONE;
+
+	if ( pm->gent 
+		&& pm->gent->client 
+		&& pm->gent->client->NPC_class == CLASS_SABER_DROID )
+	{//Saber droid does it's own attack logic
+		PM_SaberDroidWeapon();
+		return;
+	}
+
+	// don't allow attack until all buttons are up
+	if ( pm->ps->pm_flags & PMF_RESPAWNED ) {
+		return;
+	}
+
+	// check for dead player
+	if ( pm->ps->stats[STAT_HEALTH] <= 0 )
+	{
+		if ( pm->gent )
+		{
+			pm->gent->s.loopSound = 0;
+		}
+		return;
+	}
+
+	// make weapon function
+	if ( pm->ps->weaponTime > 0 ) {
+		pm->ps->weaponTime -= pml.msec;
+		if ( pm->ps->weaponTime <= 0 )
+		{
+			pm->ps->weaponTime = 0;
+		}
+	}
+
+	if ( pm->ps->stats[STAT_WEAPONS]&(1<<WP_SCEPTER)
+		&& !pm->ps->dualSabers 
+		&& pm->gent
+		&& pm->gent->weaponModel[1] )
+	{//holding scepter in left hand, use dual style
+		pm->ps->saberAnimLevel = SS_DUAL;
+		animLevelOverridden = qtrue;
+	}
+	else if ( pm->ps->saber[0].singleBladeStyle != SS_NONE//SaberStaff() 
+		&& !pm->ps->dualSabers 
+		&& pm->ps->saber[0].blade[0].active
+		&& !pm->ps->saber[0].blade[1].active )
+	{//using a staff, but only with first blade turned on, so use is as a normal saber...?
+		//override so that single-blade staff must be used with specified style
+		pm->ps->saberAnimLevel = pm->ps->saber[0].singleBladeStyle;//SS_STRONG;
+		animLevelOverridden = qtrue;
+	}
+	else if ( pm->ps->saber[0].Active() && pm->ps->saber[0].style != SS_NONE )
+	{//one of the sabers I'm using forces me to use a single style
+		pm->ps->saberAnimLevel = pm->ps->saber[0].style;
+		animLevelOverridden = qtrue;
+	}
+	else if ( pm->ps->dualSabers )
+	{
+		if ( pm->ps->saber[1].Active() && pm->ps->saber[1].style != SS_NONE )
+		{//one of the sabers I'm using forces me to use a single style
+			pm->ps->saberAnimLevel = pm->ps->saber[1].style;
+			animLevelOverridden = qtrue;
+		}
+		else if ( pm->ps->saber[1].Active() )
+		{//if second saber is on, must use dual style
+			pm->ps->saberAnimLevel = SS_DUAL;
+			animLevelOverridden = qtrue;
+		}
+		else if ( pm->ps->saber[0].Active() )
+		{//with only one saber on, use fast style
+			pm->ps->saberAnimLevel = SS_FAST;
+			animLevelOverridden = qtrue;
+		}
+	}
+	if ( !animLevelOverridden )
+	{
+		if ( (pm->ps->clientNum < MAX_CLIENTS||PM_ControlledByPlayer())
+ 			&& cg.saberAnimLevelPending > SS_NONE
+			&& cg.saberAnimLevelPending != pm->ps->saberAnimLevel )
+		{
+			if ( !PM_SaberInStart( pm->ps->saberMove ) 
+				&& !PM_SaberInTransition( pm->ps->saberMove ) 
+				&& !PM_SaberInAttack( pm->ps->saberMove ) )
+			{//don't allow changes when in the middle of an attack set...(or delay the change until it's done)
+				pm->ps->saberAnimLevel = cg.saberAnimLevelPending;
+			}
+		}
+	}
+	else if ( (pm->ps->clientNum < MAX_CLIENTS||PM_ControlledByPlayer()) )
+	{//if overrid the player's saberAnimLevel, let the cgame know
+		cg.saberAnimLevelPending = pm->ps->saberAnimLevel;
+	}
+	/*
+	if ( PM_InForceGetUp( pm->ps ) )
+	{//if mostly up, can start attack
+		if ( pm->ps->torsoAnimTimer > 800 )
+		{//not up enough yet
+			// make weapon function
+			if ( pm->ps->weaponTime > 0 ) {
+				pm->ps->weaponTime -= pml.msec;
+				if ( pm->ps->weaponTime <= 0 )
+				{
+					pm->ps->weaponTime = 0;
+				}
+			}
+			return;
+		}
+		else 
+		{
+			if ( pm->cmd.buttons & BUTTON_ATTACK )
+			{//let an attack interrupt the torso part of this force getup
+				pm->ps->weaponTime = 0;
+			}
+		}
+	}
+	else 
+	*/
+	if ( PM_InKnockDown( pm->ps ) || PM_InRoll( pm->ps ))
+	{//in knockdown
+		if ( pm->ps->legsAnim == BOTH_ROLL_F 
+			&& pm->ps->legsAnimTimer <= 250 )
+		{
+			if ( (pm->cmd.buttons&BUTTON_ATTACK) 
+				|| PM_NPCCheckAttackRoll() )
+			{
+				if ( G_EnoughPowerForSpecialMove( pm->ps->forcePower, SABER_ALT_ATTACK_POWER_FB ) )
+				{
+					PM_SetSaberMove( LS_ROLL_STAB );
+					if ( pm->gent )
+					{
+						G_DrainPowerForSpecialMove( pm->gent, FP_SABER_OFFENSE, SABER_ALT_ATTACK_POWER_FB );
+					}
+				}
+			}
+		}
+		return;
+	}
+
+ 	if ( PM_SaberLocked() )
+	{
+		pm->ps->saberMove = LS_NONE;
+		return;
+	}
+
+	if ( pm->ps->torsoAnim == BOTH_FORCELONGLEAP_LAND 
+		|| (pm->ps->torsoAnim == BOTH_FORCELONGLEAP_START && !(pm->cmd.buttons&BUTTON_ATTACK)) )
+	{//if you're in the long-jump and you're not attacking (or are landing), you're not doing anything
+		if ( pm->ps->torsoAnimTimer )
+		{
+			return;
+		}
+	}
+
+	if ( pm->ps->legsAnim == BOTH_FLIP_HOLD7 
+		&& !(pm->cmd.buttons&BUTTON_ATTACK) )
+	{//if you're in the upside-down attack hold, don't do anything unless you're attacking
+		return;
+	}
+
+	if ( PM_KickingAnim( pm->ps->legsAnim ) )
+	{
+		if ( pm->ps->legsAnimTimer )
+		{//you're kicking, no interruptions
+			return;
+		}
+		//done?  be immeditately ready to do an attack
+		pm->ps->saberMove = LS_READY;
+		pm->ps->weaponTime = 0;
+	}
+
+	if ( pm->ps->saberMoveNext != LS_NONE 
+		&& (pm->ps->saberMove == LS_READY||pm->ps->saberMove == LS_NONE))//ready for another one
+	{//something is forcing us to set a specific next saberMove
+		//FIXME: if this is a NPC kick, re-verify it before executing it!
+		PM_SetSaberMove( (saberMoveName_t)pm->ps->saberMoveNext );
+		pm->ps->saberMoveNext = LS_NONE;//clear it now that we played it
+		return;
+	}
+
+	if ( pm->ps->saberEventFlags&SEF_INWATER )//saber in water
+	{
+		pm->cmd.buttons &= ~(BUTTON_ATTACK|BUTTON_ALT_ATTACK|BUTTON_FORCE_FOCUS);
+	}
+
+	qboolean saberInAir = qtrue;
+	if ( !PM_SaberInBrokenParry( pm->ps->saberMove ) && pm->ps->saberBlocked != BLOCKED_PARRY_BROKEN && !PM_DodgeAnim( pm->ps->torsoAnim ) )
+	{//we're not stuck in a broken parry
+		if ( pm->ps->saberInFlight )
+		{//guiding saber
+			if ( pm->ps->saberEntityNum < ENTITYNUM_NONE && pm->ps->saberEntityNum > 0 )//player is 0
+			{//
+				if ( &g_entities[pm->ps->saberEntityNum] != NULL && g_entities[pm->ps->saberEntityNum].s.pos.trType == TR_STATIONARY )
+				{//fell to the ground and we're not trying to pull it back
+					saberInAir = qfalse;
+				}
+			}
+			if ( pm->ps->weaponTime <= 0 || pm->ps->weaponstate != WEAPON_FIRING ) 
+			{
+				if ( pm->ps->weapon != pm->cmd.weapon ) 
+				{
+					PM_BeginWeaponChange( pm->cmd.weapon );
+				}
+			}
+			else if ( pm->ps->weapon == WP_SABER 
+				&& (!pm->ps->dualSabers || !pm->ps->saber[1].Active()) )
+			{//guiding saber
+				if ( saberInAir )
+				{
+					if ( !PM_ForceAnim( pm->ps->torsoAnim ) || pm->ps->torsoAnimTimer < 300 )
+					{//don't interrupt a force power anim
+						if ( pm->ps->torsoAnim != BOTH_LOSE_SABER
+							|| !pm->ps->torsoAnimTimer )
+						{
+							PM_SetAnim( pm, SETANIM_TORSO, BOTH_SABERPULL, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+						}
+					}
+				}
+				return;
+			}
+		}
+	}
+
+	if ( pm->gent && pm->gent->client && pm->gent->client->fireDelay > 0 )
+	{//FIXME: this is going to fire off one frame before you expect, actually
+		pm->gent->client->fireDelay -= pml.msec;
+		if ( pm->gent->client->fireDelay <= 0 )
+		{//just finished delay timer
+			pm->gent->client->fireDelay = 0;
+			delayed_fire = qtrue;
+		}
+	}
+
+	PM_CheckClearSaberBlock();
+
+	if ( PM_LockedAnim( pm->ps->torsoAnim ) 
+		&& pm->ps->torsoAnimTimer )
+	{//can't interrupt these anims ever
+		return;
+	}
+	if ( PM_SuperBreakLoseAnim( pm->ps->torsoAnim ) 
+		&& pm->ps->torsoAnimTimer )
+	{//don't interrupt these anims
+		return;
+	}
+	if ( PM_SuperBreakWinAnim( pm->ps->torsoAnim ) 
+		&& pm->ps->torsoAnimTimer )
+	{//don't interrupt these anims
+		return;
+	}
+	
+	if ( PM_SaberBlocking() )
+	{//busy blocking, don't do attacks
+		return;
+	}
+
+	// check for weapon change
+	// can't change if weapon is firing, but can change again if lowering or raising
+	if ( pm->ps->weaponTime <= 0 || pm->ps->weaponstate != WEAPON_FIRING ) {
+		if ( pm->ps->weapon != pm->cmd.weapon ) {
+			PM_BeginWeaponChange( pm->cmd.weapon );
+		}
+	}
+
+	if ( pm->ps->weaponTime > 0 ) 
+	{
+		//FIXME: allow some window of opportunity to change your attack 
+		//		if it just started and your directional input is different 
+		//		than it was before... but only 100 milliseconds at most?
+		//OR:	Make it so that attacks don't start until 100ms after you
+		//		press the attack button...???
+		if ( (pm->ps->clientNum < MAX_CLIENTS||PM_ControlledByPlayer()) //player
+			&& PM_SaberInReturn( pm->ps->saberMove )//in a saber return move - FIXME: what about transitions?
+			//&& pm->ps->torsoAnimTimer<=250//towards the end of a saber return anim
+			&& pm->ps->saberBlocked == BLOCKED_NONE//not interacting with any other saber
+			&& !(pm->cmd.buttons&BUTTON_ATTACK)//not trying to swing the saber
+			&& (pm->cmd.forwardmove||pm->cmd.rightmove) )//trying to kick in a specific direction
+		{
+			if ( PM_CheckAltKickAttack() )//trying to do a kick
+			{//allow them to do the kick now!
+				pm->ps->weaponTime = 0;
+				PM_CheckKick();
+				return;
+			}
+		}
+		else
+		{
+			if ( !pm->cmd.rightmove
+				&&!pm->cmd.forwardmove
+				&&(pm->cmd.buttons&BUTTON_ATTACK) )
+			{
+				/*
+				if ( PM_CheckDualSpinProtect() )
+				{//check to see if we're going to do the special dual push protect move
+					PM_SetSaberMove( LS_DUAL_SPIN_PROTECT );
+					pm->ps->weaponstate = WEAPON_FIRING;
+					return;
+				}
+				else
+				*/
+				if ( !g_saberNewControlScheme->integer )
+				{
+					saberMoveName_t pullAtk = PM_CheckPullAttack();
+					if ( pullAtk != LS_NONE )
+					{
+						PM_SetSaberMove( pullAtk );
+						pm->ps->weaponstate = WEAPON_FIRING;
+						return;
+					}
+				}
+			}
+			else
+			{
+				return;
+			}
+		}
+	}
+
+	// *********************************************************
+	// WEAPON_DROPPING
+	// *********************************************************
+
+	// change weapon if time
+	if ( pm->ps->weaponstate == WEAPON_DROPPING ) {
+		PM_FinishWeaponChange();
+		return;
+	}
+
+	// *********************************************************
+	// WEAPON_RAISING
+	// *********************************************************
+
+	if ( pm->ps->weaponstate == WEAPON_RAISING ) 
+	{//Just selected the weapon
+		pm->ps->weaponstate = WEAPON_IDLE;
+		if(pm->gent && (pm->gent->s.number<MAX_CLIENTS||G_ControlledByPlayer(pm->gent)))
+		{
+			switch ( pm->ps->legsAnim )
+			{
+			case BOTH_WALK1:
+			case BOTH_WALK2:
+			case BOTH_WALK_STAFF:
+			case BOTH_WALK_DUAL:
+			case BOTH_WALKBACK1:
+			case BOTH_WALKBACK2:
+			case BOTH_WALKBACK_STAFF:
+			case BOTH_WALKBACK_DUAL:
+			case BOTH_RUN1:
+			case BOTH_RUN2:
+			case BOTH_RUN_STAFF:
+			case BOTH_RUN_DUAL:
+			case BOTH_RUNBACK1:
+			case BOTH_RUNBACK2:
+			case BOTH_RUNBACK_STAFF:
+				PM_SetAnim(pm,SETANIM_TORSO,pm->ps->legsAnim,SETANIM_FLAG_NORMAL);
+				break;
+			default:
+				int anim = PM_ReadyPoseForSaberAnimLevel();
+				if (anim!=-1)
+				{
+					PM_SetAnim(pm,SETANIM_TORSO,anim,SETANIM_FLAG_NORMAL);
+				}
+				break;
+			}
+		}
+		else
+		{
+			qboolean saberInAir = qtrue;
+			if ( pm->ps->saberInFlight )
+			{//guiding saber
+				if ( PM_SaberInBrokenParry( pm->ps->saberMove ) || pm->ps->saberBlocked == BLOCKED_PARRY_BROKEN || PM_DodgeAnim( pm->ps->torsoAnim ) )
+				{//we're stuck in a broken parry
+					saberInAir = qfalse;
+				}
+				if ( pm->ps->saberEntityNum < ENTITYNUM_NONE && pm->ps->saberEntityNum > 0 )//player is 0
+				{//
+					if ( &g_entities[pm->ps->saberEntityNum] != NULL && g_entities[pm->ps->saberEntityNum].s.pos.trType == TR_STATIONARY )
+					{//fell to the ground and we're not trying to pull it back
+						saberInAir = qfalse;
+					}
+				}
+			}
+			if ( pm->ps->weapon == WP_SABER 
+				&& pm->ps->saberInFlight 
+				&& saberInAir 
+				&& (!pm->ps->dualSabers || !pm->ps->saber[1].Active()))
+			{//guiding saber
+				if ( !PM_ForceAnim( pm->ps->torsoAnim ) || pm->ps->torsoAnimTimer < 300 )
+				{//don't interrupt a force power anim
+					if ( pm->ps->torsoAnim != BOTH_LOSE_SABER
+						|| !pm->ps->torsoAnimTimer )
+					{
+						PM_SetAnim( pm, SETANIM_TORSO, BOTH_SABERPULL, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+					}
+				}
+			}
+			else
+			{
+				// PM_SetAnim(pm, SETANIM_TORSO, BOTH_ATTACK1, SETANIM_FLAG_NORMAL);
+				// Select the proper idle Lightsaber attack move from the chart.
+				PM_SetSaberMove(LS_READY);
+			}
+		}
+		return;
+	}
+
+	// *********************************************************
+	// Check for WEAPON ATTACK
+	// *********************************************************
+
+	if ( PM_CanDoKata() )
+	{
+		//FIXME: make sure to turn on saber(s)!
+		switch ( pm->ps->saberAnimLevel )
+		{
+		case SS_FAST:
+		case SS_TAVION:
+			PM_SetSaberMove( LS_A1_SPECIAL );
+			break;
+		case SS_MEDIUM:
+			PM_SetSaberMove( LS_A2_SPECIAL );
+			break;
+		case SS_STRONG:
+		case SS_DESANN:
+			PM_SetSaberMove( LS_A3_SPECIAL );
+			break;
+		case SS_DUAL:
+			PM_SetSaberMove( LS_DUAL_SPIN_PROTECT );//PM_CheckDualSpinProtect();
+			break;
+		case SS_STAFF:
+			PM_SetSaberMove( LS_STAFF_SOULCAL );
+			break;
+		}
+		pm->ps->weaponstate = WEAPON_FIRING;
+		if ( pm->gent )
+		{
+			G_DrainPowerForSpecialMove( pm->gent, FP_SABER_OFFENSE, SABER_ALT_ATTACK_POWER, qtrue );//FP_SPEED, SINGLE_SPECIAL_POWER );
+			//G_StartMatrixEffect( pm->gent, MEF_REVERSE_SPIN, pm->ps->torsoAnimTimer );
+		}
+		return;
+	}
+
+	if ( PM_CheckAltKickAttack() )
+	{//trying to do a kick
+		//FIXME: in-air kicks?
+		if ( pm->ps->saberAnimLevel == SS_STAFF
+			&& (pm->ps->clientNum >= MAX_CLIENTS||PM_ControlledByPlayer()) )
+		{//NPCs spin the staff
+			//NOTE: only NPCs can do it the easy way... they kick directly, not through ucmds...
+			PM_SetSaberMove( LS_SPINATTACK );
+			return;
+		}
+		else
+		{
+			PM_CheckKick();
+		}
+		return;
+	}
+	//this is never a valid regular saber attack button
+	//pm->cmd.buttons &= ~BUTTON_FORCE_FOCUS;
+
+	if ( PM_CheckUpsideDownAttack() )
+	{
+		return;
+	}
+
+	weapon = &cg_weapons[pm->ps->weapon];
+
+	if(!delayed_fire)
+	{
+		// Start with the current move, and cross index it with the current control states.
+		if ( pm->ps->saberMove > LS_NONE && pm->ps->saberMove < LS_MOVE_MAX )
+		{
+			curmove = (saberMoveName_t)pm->ps->saberMove;
+		}
+		else
+		{
+			curmove = LS_READY;
+		}
+		if ( curmove == LS_A_JUMP_T__B_ || pm->ps->torsoAnim == BOTH_FORCELEAP2_T__B_ )
+		{//must transition back to ready from this anim
+			newmove = LS_R_T2B;
+		}
+		// check for fire
+		else if ( !(pm->cmd.buttons & BUTTON_ATTACK) )//(BUTTON_ATTACK|BUTTON_ALT_ATTACK|BUTTON_FORCE_FOCUS)) )
+		{//not attacking
+			pm->ps->weaponTime = 0;
+			
+			if ( pm->gent && pm->gent->client && pm->gent->client->fireDelay > 0 )
+			{//Still firing
+				pm->ps->weaponstate = WEAPON_FIRING;
+			}
+			else if ( pm->ps->weaponstate != WEAPON_READY )
+			{
+				pm->ps->weaponstate = WEAPON_IDLE;
+			}
+			//Check for finishing an anim if necc.
+			if ( curmove >= LS_S_TL2BR && curmove <= LS_S_T2B )
+			{//started a swing, must continue from here
+				newmove = LS_A_TL2BR + (curmove-LS_S_TL2BR);
+			}
+			else if ( curmove >= LS_A_TL2BR && curmove <= LS_A_T2B )
+			{//finished an attack, must continue from here
+				newmove = LS_R_TL2BR + (curmove-LS_A_TL2BR);
+			}
+			else if ( PM_SaberInTransition( curmove ) )
+			{//in a transition, must play sequential attack
+				newmove = saberMoveData[curmove].chain_attack;
+			}
+			else if ( PM_SaberInBounce( curmove ) )
+			{//in a bounce
+				if ( pm->ps->clientNum && !PM_ControlledByPlayer() )
+				{//NPCs must play sequential attack
+					//going into another attack...
+					//allow endless chaining in level 1 attacks, several in level 2 and only one or a few in level 3
+					if ( PM_SaberKataDone( LS_NONE, LS_NONE ) )
+					{//done with this kata, must return to ready before attack again
+						newmove = saberMoveData[curmove].chain_idle;
+					}
+					else
+					{//okay to chain to another attack
+						newmove = saberMoveData[curmove].chain_attack;//we assume they're attacking, even if they're not
+						pm->ps->saberAttackChainCount++;
+					}
+				}
+				else
+				{//player gets his by directional control
+					newmove = saberMoveData[curmove].chain_idle;//oops, not attacking, so don't chain
+				}
+			}
+			else
+			{//FIXME: what about returning from a parry?
+				//PM_SetSaberMove( LS_READY );
+				if ( pm->ps->saberBlockingTime > cg.time )
+				{
+					PM_SetSaberMove( LS_READY );
+				}
+				return;
+			}
+		}
+
+		// ***************************************************
+		// Pressing attack, so we must look up the proper attack move.
+		qboolean saberInAir = qtrue;
+		if ( pm->ps->saberInFlight )
+		{//guiding saber
+			if ( PM_SaberInBrokenParry( pm->ps->saberMove ) || pm->ps->saberBlocked == BLOCKED_PARRY_BROKEN || PM_DodgeAnim( pm->ps->torsoAnim ) )
+			{//we're stuck in a broken parry
+				saberInAir = qfalse;
+			}
+			if ( pm->ps->saberEntityNum < ENTITYNUM_NONE && pm->ps->saberEntityNum > 0 )//player is 0
+			{//
+				if ( &g_entities[pm->ps->saberEntityNum] != NULL && g_entities[pm->ps->saberEntityNum].s.pos.trType == TR_STATIONARY )
+				{//fell to the ground and we're not trying to pull it back
+					saberInAir = qfalse;
+				}
+			}
+		}
+
+		if ( pm->ps->weapon == WP_SABER 
+			&& pm->ps->saberInFlight 
+			&& saberInAir 
+			&& (!pm->ps->dualSabers || !pm->ps->saber[1].Active()))
+		{//guiding saber
+			if ( !PM_ForceAnim( pm->ps->torsoAnim ) || pm->ps->torsoAnimTimer < 300 )
+			{//don't interrupt a force power anim
+				if ( pm->ps->torsoAnim != BOTH_LOSE_SABER
+					|| !pm->ps->torsoAnimTimer )
+				{
+					PM_SetAnim( pm, SETANIM_TORSO,BOTH_SABERPULL,SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+				}
+			}
+		}
+		else if ( pm->ps->weaponTime > 0 )
+		{	// Last attack is not yet complete.
+			pm->ps->weaponstate = WEAPON_FIRING;
+			return;
+		}
+		else
+		{
+			int	both = qfalse;
+			if ( pm->ps->torsoAnim == BOTH_FORCELONGLEAP_ATTACK
+				|| pm->ps->torsoAnim == BOTH_FORCELONGLEAP_LAND )
+			{//can't attack in these anims
+				return;
+			}
+			else if ( pm->ps->torsoAnim == BOTH_FORCELONGLEAP_START )
+			{//only 1 attack you can do from this anim
+				if ( pm->ps->torsoAnimTimer >= 200 )
+				{//hit it early enough to do the attack
+					PM_SetSaberMove( LS_LEAP_ATTACK );
+				}
+				return;
+			}
+			if ( curmove >= LS_PARRY_UP && curmove <= LS_REFLECT_LL )
+			{//from a parry or reflection, can go directly into an attack
+				if ( pm->ps->clientNum >= MAX_CLIENTS && !PM_ControlledByPlayer() )
+				{//NPCs
+					newmove = PM_NPCSaberAttackFromQuad( saberMoveData[curmove].endQuad );
+				}
+				else
+				{
+					newmove = PM_SaberAttackForMovement( pm->cmd.forwardmove, pm->cmd.rightmove, curmove );
+				}
+			}
+
+			if ( newmove != LS_NONE )
+			{//have a valid, final LS_ move picked, so skip findingt he transition move and just get the anim
+				if (PM_HasAnimation( pm->gent, saberMoveData[newmove].animToUse))
+				{
+					anim = saberMoveData[newmove].animToUse;
+				}
+			}
+
+			//FIXME: diagonal dirs use the figure-eight attacks from ready pose?
+			if ( anim == -1 )
+			{
+				//FIXME: take FP_SABER_OFFENSE into account here somehow?
+				if ( PM_SaberInTransition( curmove ) )
+				{//in a transition, must play sequential attack
+					newmove = saberMoveData[curmove].chain_attack;
+				}
+				else if ( curmove >= LS_S_TL2BR && curmove <= LS_S_T2B )
+				{//started a swing, must continue from here
+					newmove = LS_A_TL2BR + (curmove-LS_S_TL2BR);
+				}
+				else if ( PM_SaberInBrokenParry( curmove ) )
+				{//broken parries must always return to ready
+					newmove = LS_READY;
+				}
+				else//if ( pm->cmd.buttons&BUTTON_ATTACK && !(pm->ps->pm_flags&PMF_ATTACK_HELD) )//only do this if just pressed attack button?
+				{//get attack move from movement command
+					/*
+					if ( PM_SaberKataDone() )
+					{//we came from a bounce and cannot chain to another attack because our kata is done
+						newmove = saberMoveData[curmove].chain_idle;
+					}
+					else */
+					if ( pm->ps->clientNum >= MAX_CLIENTS
+						&& !PM_ControlledByPlayer() 
+						&& (Q_irand( 0, pm->ps->forcePowerLevel[FP_SABER_OFFENSE]-1 )
+							|| (pm->gent&&pm->gent->enemy&&pm->gent->enemy->client&&PM_InKnockDownOnGround(&pm->gent->enemy->client->ps))//enemy knocked down, use some logic
+							|| ( pm->ps->saberAnimLevel == SS_FAST && pm->gent && pm->gent->NPC && pm->gent->NPC->rank >= RANK_LT_JG && Q_irand( 0, 1 ) ) ) )//minor change to make fast-attack users use the special attacks more
+					{//NPCs use more randomized attacks the more skilled they are
+						newmove = PM_NPCSaberAttackFromQuad( saberMoveData[curmove].endQuad );
+					}
+					else
+					{
+						newmove = PM_SaberAttackForMovement( pm->cmd.forwardmove, pm->cmd.rightmove, curmove );
+						if ( (PM_SaberInBounce( curmove )||PM_SaberInBrokenParry( curmove ))
+							&& saberMoveData[newmove].startQuad == saberMoveData[curmove].endQuad )
+						{//this attack would be a repeat of the last (which was blocked), so don't actually use it, use the default chain attack for this bounce
+							newmove = saberMoveData[curmove].chain_attack;
+						}
+					}
+					if ( PM_SaberKataDone( curmove, newmove ) )
+					{//cannot chain this time
+						newmove = saberMoveData[curmove].chain_idle;
+					}
+				}
+				/*
+				if ( newmove == LS_NONE )
+				{//FIXME: should we allow this?  Are there some anims that you should never be able to chain into an attack?
+					//only curmove that might get in here is LS_NONE, LS_DRAW, LS_PUTAWAY and the LS_R_ returns... all of which are in Q_R
+					newmove = PM_AttackMoveForQuad( saberMoveData[curmove].endQuad );
+				}
+				*/
+				if ( newmove != LS_NONE )
+				{
+					if ( !PM_InCartwheel( pm->ps->legsAnim ) )
+					{//don't do transitions when cartwheeling - could make you spin!
+						//Now get the proper transition move
+						newmove = PM_SaberAnimTransitionMove( (saberMoveName_t)curmove, (saberMoveName_t)newmove );
+						if ( PM_HasAnimation( pm->gent, saberMoveData[newmove].animToUse ) )
+						{
+							anim = saberMoveData[newmove].animToUse;
+						}
+					}
+				}
+			}
+
+			if (anim == -1)
+			{//not side-stepping, pick neutral anim
+				if ( !G_TryingSpecial(pm->gent,&pm->cmd)/*(pm->cmd.buttons&BUTTON_FORCE_FOCUS)*/ )
+				{//but only if not trying one of the special attacks!
+					if ( PM_InCartwheel( pm->ps->legsAnim )
+						&& pm->ps->legsAnimTimer > 100 )
+					{//if in the middle of a cartwheel, the chain attack is just a normal attack
+						//NOTE: this should match the switch in PM_InCartwheel!
+						switch( pm->ps->legsAnim )
+						{
+						case BOTH_ARIAL_LEFT://swing from l to r
+						case BOTH_CARTWHEEL_LEFT:
+							newmove = LS_A_L2R;
+							break;
+						case BOTH_ARIAL_RIGHT://swing from r to l
+						case BOTH_CARTWHEEL_RIGHT:
+							newmove = LS_A_R2L;
+							break;
+						case BOTH_ARIAL_F1://random l/r attack
+							if ( Q_irand( 0, 1 ) )
+							{
+								newmove = LS_A_L2R;
+							}
+							else
+							{
+								newmove = LS_A_R2L;
+							}
+							break;
+						}
+					}
+					else
+					{
+						// Add randomness for prototype?
+						newmove = saberMoveData[curmove].chain_attack;
+					}
+					if ( newmove != LS_NONE )
+					{
+						if (PM_HasAnimation( pm->gent, saberMoveData[newmove].animToUse))
+						{
+							anim= saberMoveData[newmove].animToUse;
+						}
+					}
+				}
+
+				if ( !pm->cmd.forwardmove && !pm->cmd.rightmove && pm->cmd.upmove >= 0 && pm->ps->groundEntityNum != ENTITYNUM_NONE )
+				{//not moving at all, so set the anim on entire body
+					both = qtrue;
+				}
+			
+			}
+
+			if ( anim == -1)
+			{
+				switch ( pm->ps->legsAnim )
+				{
+				case BOTH_WALK1:
+				case BOTH_WALK2:
+				case BOTH_WALK_STAFF:
+				case BOTH_WALK_DUAL:
+				case BOTH_WALKBACK1:
+				case BOTH_WALKBACK2:
+				case BOTH_WALKBACK_STAFF:
+				case BOTH_WALKBACK_DUAL:
+				case BOTH_RUN1:
+				case BOTH_RUN2:
+				case BOTH_RUN_STAFF:
+				case BOTH_RUN_DUAL:
+				case BOTH_RUNBACK1:
+				case BOTH_RUNBACK2:
+				case BOTH_RUNBACK_STAFF:
+					anim = pm->ps->legsAnim;
+					break;
+				default:
+					anim = PM_ReadyPoseForSaberAnimLevel();
+					break;
+				}
+				newmove = LS_READY;
+			}
+
+			if ( !pm->ps->SaberActive() )
+			{//turn on the saber if it's not on
+				pm->ps->SaberActivate();
+			}
+
+			PM_SetSaberMove( (saberMoveName_t)newmove );
+
+			if ( both && pm->ps->legsAnim != pm->ps->torsoAnim )
+			{
+				PM_SetAnim( pm,SETANIM_LEGS,pm->ps->torsoAnim,SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+			}
+			if ( pm->gent && pm->gent->client )
+			{
+//				pm->gent->client->saberTrail.inAction = qtrue;
+//				pm->gent->client->saberTrail.duration = 75; // saber trail lasts for 75ms...feel free to change this if you want it longer or shorter
+			}
+			if ( !PM_InCartwheel( pm->ps->torsoAnim ) )
+			{//can still attack during a cartwheel/arial
+				//don't fire again until anim is done
+				pm->ps->weaponTime = pm->ps->torsoAnimTimer;
+			}
+			/*
+			//FIXME: this may be making it so sometimes you can't swing again right away...
+			if ( newmove == LS_READY )
+			{
+				pm->ps->weaponTime = 500;
+			}
+			*/
+		}
+	}
+
+	// *********************************************************
+	// WEAPON_FIRING
+	// *********************************************************
+
+	pm->ps->weaponstate = WEAPON_FIRING;
+
+	/*
+	if ( pm->cmd.buttons & BUTTON_ALT_ATTACK )
+		amount = weaponData[pm->ps->weapon].altEnergyPerShot;
+	else*/
+		amount = weaponData[pm->ps->weapon].energyPerShot;
+
+	if ( pm->gent && pm->gent->client && pm->gent->client->fireDelay > 0 )
+	{//FIXME: this is going to fire off one frame before you expect, actually
+		// Clear these out since we're not actually firing yet
+		pm->ps->eFlags &= ~EF_FIRING;
+		pm->ps->eFlags &= ~EF_ALT_FIRING;
+		return;
+	}
+
+	addTime = pm->ps->weaponTime;
+	/*if ( pm->cmd.buttons & BUTTON_ALT_ATTACK ) 	{
+		PM_AddEvent( EV_ALT_FIRE );
+		if ( !addTime )
+		{
+			addTime = weaponData[pm->ps->weapon].altFireTime;
+			if ( g_timescale != NULL )
+			{
+				if ( g_timescale->value < 1.0f )
+				{
+					if ( !MatrixMode )
+					{//Special test for Matrix Mode (tm)
+						if ( pm->ps->clientNum == 0 && !player_locked && (pm->ps->forcePowersActive&(1<<FP_SPEED)||pm->ps->forcePowersActive&(1<<FP_RAGE)) )
+						{//player always fires at normal speed
+							addTime *= g_timescale->value;
+						}
+						else if ( g_entities[pm->ps->clientNum].client && (pm->ps->forcePowersActive&(1<<FP_SPEED)||pm->ps->forcePowersActive&(1<<FP_RAGE)) )
+						{
+							addTime *= g_timescale->value;
+						}
+					}
+				}
+			}
+		}
+	}
+	else */{
+		PM_AddEvent( EV_FIRE_WEAPON );
+		if ( !addTime )
+		{
+			addTime = weaponData[pm->ps->weapon].fireTime;
+			if ( g_timescale != NULL )
+			{
+				if ( g_timescale->value < 1.0f )
+				{
+					if ( !MatrixMode )
+					{//Special test for Matrix Mode (tm)
+						if ( pm->ps->clientNum == 0 && !player_locked && (pm->ps->forcePowersActive&(1<<FP_SPEED)||pm->ps->forcePowersActive&(1<<FP_RAGE)) )
+						{//player always fires at normal speed
+							addTime *= g_timescale->value;
+						}
+						else if ( g_entities[pm->ps->clientNum].client 
+							&& (pm->ps->forcePowersActive&(1<<FP_SPEED)||pm->ps->forcePowersActive&(1<<FP_RAGE)) )
+						{
+							addTime *= g_timescale->value;
+						}
+					}
+				}
+			}
+		}
+	}
+
+	if (pm->ps->forcePowersActive & (1 << FP_RAGE))
+	{
+		addTime *= 0.75;
+	}
+	else if (pm->ps->forceRageRecoveryTime > pm->cmd.serverTime)
+	{
+		addTime *= 1.5;
+	}
+
+	//If the phaser has been fired, delay the next recharge time
+	if ( !PM_ControlledByPlayer() )
+	{
+		if( pm->gent && pm->gent->NPC != NULL )
+		{//NPCs have their own refire logic
+			//FIXME: this really should be universal...
+			return;
+		}
+	}
+
+	if ( !PM_InCartwheel( pm->ps->torsoAnim ) )
+	{//can still attack during a cartwheel/arial
+		pm->ps->weaponTime = addTime;
+	}
+}
+
+//---------------------------------------
+static bool PM_DoChargedWeapons( void )
+//---------------------------------------
+{
+	qboolean	charging = qfalse,
+				altFire = qfalse;
+
+	//FIXME: make jedi aware they're being aimed at with a charged-up weapon (strafe and be evasive?)
+	// If you want your weapon to be a charging weapon, just set this bit up
+	switch( pm->ps->weapon )
+	{
+	//------------------
+	case WP_BRYAR_PISTOL:
+	case WP_BLASTER_PISTOL:
+
+		// alt-fire charges the weapon
+		if ( pm->cmd.buttons & BUTTON_ALT_ATTACK )
+		{
+			charging = qtrue;
+			altFire = qtrue;
+		}
+		break;
+
+	//------------------
+	case WP_DISRUPTOR:
+
+		// alt-fire charges the weapon...but due to zooming being controlled by the alt-button, the main button actually charges...but only when zoomed.
+		//	lovely, eh?
+		if ( (pm->ps->clientNum < MAX_CLIENTS||PM_ControlledByPlayer()) )
+		{
+			if ( cg.zoomMode == 2 )
+			{
+				if ( pm->cmd.buttons & BUTTON_ATTACK )
+				{
+					charging = qtrue;
+					altFire = qtrue; // believe it or not, it really is an alt-fire in this case!
+#ifndef _XBOX
+				}
+#else
+					cgi_FF_StartFX( fffx_StartConst );
+				}
+				else
+				{
+					cgi_FF_StartFX( fffx_StopConst );
+				}
+#endif
+
+			}
+		}
+		else if ( pm->gent && pm->gent->NPC )
+		{
+			if ( (pm->gent->NPC->scriptFlags&SCF_ALT_FIRE) )
+			{
+				if ( pm->gent->fly_sound_debounce_time > level.time )
+				{
+					charging = qtrue;
+					altFire = qtrue;
+				}
+			}
+		}
+		break;
+		
+	//------------------
+	case WP_BOWCASTER:
+
+		// main-fire charges the weapon
+		if ( pm->cmd.buttons & BUTTON_ATTACK )
+		{
+			charging = qtrue;
+		}
+		break;
+	
+	//------------------
+	case WP_DEMP2:
+
+		// alt-fire charges the weapon
+		if ( pm->cmd.buttons & BUTTON_ALT_ATTACK )
+		{
+			charging = qtrue;
+			altFire = qtrue;
+		}
+		break;
+
+	//------------------
+	case WP_ROCKET_LAUNCHER:
+
+		// Not really a charge weapon, but we still want to delay fire until the button comes up so that we can
+		//	implement our alt-fire locking stuff
+		if ( pm->cmd.buttons & BUTTON_ALT_ATTACK )
+		{
+			charging = qtrue;
+			altFire = qtrue;
+		}
+		break;
+
+	//------------------
+	case WP_THERMAL:
+		//			FIXME: Really should have a wind-up anim for player 
+		//			as he holds down the fire button to throw, then play
+		//			the actual throw when he lets go...
+		if ( pm->cmd.buttons & BUTTON_ALT_ATTACK )
+		{
+			altFire = qtrue; // override default of not being an alt-fire
+			charging = qtrue;
+		}
+		else if ( pm->cmd.buttons & BUTTON_ATTACK )
+		{
+			charging = qtrue;
+		}
+		break;
+
+	} // end switch
+
+	// set up the appropriate weapon state based on the button that's down.  
+	//	Note that we ALWAYS return if charging is set ( meaning the buttons are still down )
+	if ( charging )
+	{
+
+
+		if ( altFire )
+		{
+			if ( pm->ps->weaponstate != WEAPON_CHARGING_ALT && pm->ps->weaponstate != WEAPON_DROPPING )
+			{
+				if ( pm->ps->ammo[weaponData[pm->ps->weapon].ammoIndex] <= 0)
+				{
+					PM_AddEvent( EV_NOAMMO );
+					pm->ps->weaponTime += 500;
+					return true;
+				}
+
+				// charge isn't started, so do it now
+				pm->ps->weaponstate = WEAPON_CHARGING_ALT;
+				pm->ps->weaponChargeTime = level.time;
+
+				if ( cg_weapons[pm->ps->weapon].altChargeSound )
+				{
+					G_SoundOnEnt( pm->gent, CHAN_WEAPON, weaponData[pm->ps->weapon].altChargeSnd );
+				}
+#ifdef _IMMERSION
+				if ( cg_weapons[pm->ps->weapon].altChargeForce )
+				{
+					G_Force( pm->gent, G_ForceIndex( weaponData[pm->ps->weapon].altChargeFrc, FF_CHANNEL_WEAPON ) );
+				}
+#endif // _IMMERSION
+			}
+		}
+		else
+		{
+
+			if ( pm->ps->weaponstate != WEAPON_CHARGING && pm->ps->weaponstate != WEAPON_DROPPING )
+			{
+				if ( pm->ps->ammo[weaponData[pm->ps->weapon].ammoIndex] <= 0)
+				{
+					PM_AddEvent( EV_NOAMMO );
+					pm->ps->weaponTime += 500;
+					return true;
+				}
+
+				// charge isn't started, so do it now
+				pm->ps->weaponstate = WEAPON_CHARGING;
+				pm->ps->weaponChargeTime = level.time;
+
+#ifdef _IMMERSION
+				if ( pm->gent && !pm->gent->NPC ) // HACK: !NPC mostly for bowcaster and weequay
+				{
+					if ( cg_weapons[pm->ps->weapon].chargeSound )
+					{
+						G_SoundOnEnt( pm->gent, CHAN_WEAPON, weaponData[pm->ps->weapon].chargeSnd );
+					}
+
+					if ( cg_weapons[pm->ps->weapon].chargeForce )
+					{
+						G_Force( pm->gent, G_ForceIndex( weaponData[pm->ps->weapon].chargeFrc, FF_CHANNEL_WEAPON ) );
+					}
+				}
+#else
+				if ( cg_weapons[pm->ps->weapon].chargeSound && pm->gent && !pm->gent->NPC ) // HACK: !NPC mostly for bowcaster and weequay
+				{
+					G_SoundOnEnt( pm->gent, CHAN_WEAPON, weaponData[pm->ps->weapon].chargeSnd );
+				}
+#endif // _IMMERSION
+			}
+		}
+
+		return true; // short-circuit rest of weapon code
+	}
+
+	// Only charging weapons should be able to set these states...so....
+	//	let's see which fire mode we need to set up now that the buttons are up
+	if ( pm->ps->weaponstate == WEAPON_CHARGING )
+	{
+		// weapon has a charge, so let us do an attack
+		// dumb, but since we shoot a charged weapon on button-up, we need to repress this button for now
+		pm->cmd.buttons |= BUTTON_ATTACK;
+		pm->ps->eFlags |= EF_FIRING;
+#ifdef _IMMERSION
+		// HACKHACKHACK - charging sound effect stops when button released,
+		// but I can't find the place where this stop occurs... it's here for now...
+		G_ForceStop( pm->gent, G_ForceIndex( weaponData[pm->ps->weapon].chargeFrc, FF_CHANNEL_WEAPON ) );
+#endif // _IMMERSION
+	}
+	else if ( pm->ps->weaponstate == WEAPON_CHARGING_ALT )
+	{
+		// weapon has a charge, so let us do an alt-attack
+		// dumb, but since we shoot a charged weapon on button-up, we need to repress this button for now
+		pm->cmd.buttons |= BUTTON_ALT_ATTACK;
+		pm->ps->eFlags |= (EF_FIRING|EF_ALT_FIRING);
+#ifdef _IMMERSION
+		// HACKHACKHACK - charging sound effect stops when button released,
+		// but I can't find the place where this stop occurs... it's here for now...
+		G_ForceStop( pm->gent, G_ForceIndex( weaponData[pm->ps->weapon].altChargeFrc, FF_CHANNEL_WEAPON ) );
+#endif // _IMMERSION
+	}
+
+	return false; // continue with the rest of the weapon code
+}
+
+
+#define BOWCASTER_CHARGE_UNIT	200.0f	// bowcaster charging gives us one more unit every 200ms--if you change this, you'll have to do the same in g_weapon
+#define BRYAR_CHARGE_UNIT		200.0f	// bryar charging gives us one more unit every 200ms--if you change this, you'll have to do the same in g_weapon
+#define DEMP2_CHARGE_UNIT		500.0f	// ditto
+#define DISRUPTOR_CHARGE_UNIT	150.0f	// ditto
+
+// Specific weapons can opt to modify the ammo usage based on charges, otherwise if no special case code
+//	is handled below, regular ammo usage will happen
+//---------------------------------------
+static int PM_DoChargingAmmoUsage( int *amount )
+//---------------------------------------
+{
+	int count = 0;
+
+	if ( pm->ps->weapon == WP_BOWCASTER && !( pm->cmd.buttons & BUTTON_ALT_ATTACK ))
+	{
+		// this code is duplicated ( I know, I know ) in G_weapon.cpp for the bowcaster alt-fire
+		count = ( level.time - pm->ps->weaponChargeTime ) / BOWCASTER_CHARGE_UNIT;
+
+		if ( count < 1 )
+		{
+			count = 1;
+		}
+		else if ( count > 5 )
+		{
+			count = 5;
+		}
+
+		if ( !(count & 1 ))
+		{
+			// if we aren't odd, knock us down a level
+			count--;
+		}
+
+		// Only bother with these checks if we don't have infinite ammo
+		if ( pm->ps->ammo[ weaponData[pm->ps->weapon].ammoIndex ] != -1 )
+		{
+			int dif = pm->ps->ammo[weaponData[pm->ps->weapon].ammoIndex] - *amount * count;
+
+			// If we have enough ammo to do the full charged shot, we are ok
+			if ( dif < 0 ) 
+			{
+				// we are not ok, so hack our chargetime and ammo usage, note that DIF is going to be negative
+				count += floor(dif / (float)*amount);
+
+				if ( count < 1 )
+				{
+					count = 1;
+				}
+
+				// now get a real chargeTime so the duplicated code in g_weapon doesn't get freaked
+				pm->ps->weaponChargeTime = level.time - ( count * BOWCASTER_CHARGE_UNIT );
+			}
+		}	
+
+		// now that count is cool, get the real ammo usage
+		*amount *= count;
+	}
+	else if(  ( pm->ps->weapon == WP_BRYAR_PISTOL && pm->cmd.buttons & BUTTON_ALT_ATTACK )
+			  || ( pm->ps->weapon == WP_BLASTER_PISTOL && pm->cmd.buttons & BUTTON_ALT_ATTACK ) )
+	{
+		// this code is duplicated ( I know, I know ) in G_weapon.cpp for the bryar alt-fire
+		count = ( level.time - pm->ps->weaponChargeTime ) / BRYAR_CHARGE_UNIT;
+
+		if ( count < 1 )
+		{
+			count = 1;
+		}
+		else if ( count > 5 )
+		{
+			count = 5;
+		}
+
+		// Only bother with these checks if we don't have infinite ammo
+		if ( pm->ps->ammo[ weaponData[pm->ps->weapon].ammoIndex ] != -1 )
+		{
+			int dif = pm->ps->ammo[weaponData[pm->ps->weapon].ammoIndex] - *amount * count;
+
+			// If we have enough ammo to do the full charged shot, we are ok
+			if ( dif < 0 ) 
+			{
+				// we are not ok, so hack our chargetime and ammo usage, note that DIF is going to be negative
+				count += floor(dif / (float)*amount);
+
+				if ( count < 1 )
+				{
+					count = 1;
+				}
+
+				// now get a real chargeTime so the duplicated code in g_weapon doesn't get freaked
+				pm->ps->weaponChargeTime = level.time - ( count * BRYAR_CHARGE_UNIT );
+			}
+		}	
+
+		// now that count is cool, get the real ammo usage
+		*amount *= count;
+	}
+	else if ( pm->ps->weapon == WP_DEMP2 && pm->cmd.buttons & BUTTON_ALT_ATTACK )
+	{
+		// this code is duplicated ( I know, I know ) in G_weapon.cpp for the demp2 alt-fire
+		count = ( level.time - pm->ps->weaponChargeTime ) / DEMP2_CHARGE_UNIT;
+
+		if ( count < 1 )
+		{
+			count = 1;
+		}
+		else if ( count > 3 )
+		{
+			count = 3;
+		}
+
+		// Only bother with these checks if we don't have infinite ammo
+		if ( pm->ps->ammo[ weaponData[pm->ps->weapon].ammoIndex ] != -1 )
+		{
+			int dif = pm->ps->ammo[weaponData[pm->ps->weapon].ammoIndex] - *amount * count;
+
+			// If we have enough ammo to do the full charged shot, we are ok
+			if ( dif < 0 ) 
+			{
+				// we are not ok, so hack our chargetime and ammo usage, note that DIF is going to be negative
+				count += floor(dif / (float)*amount);
+
+				if ( count < 1 )
+				{
+					count = 1;
+				}
+
+				// now get a real chargeTime so the duplicated code in g_weapon doesn't get freaked
+				pm->ps->weaponChargeTime = level.time - ( count * DEMP2_CHARGE_UNIT );
+			}
+		}	
+
+		// now that count is cool, get the real ammo usage
+		*amount *= count;
+
+		// this is an after-thought.  should probably re-write the function to do this naturally.
+		if ( *amount > pm->ps->ammo[weaponData[pm->ps->weapon].ammoIndex] )
+		{
+			*amount = pm->ps->ammo[weaponData[pm->ps->weapon].ammoIndex];
+		}
+	}
+	else if ( pm->ps->weapon == WP_DISRUPTOR && pm->cmd.buttons & BUTTON_ALT_ATTACK ) // BUTTON_ATTACK will have been mapped to BUTTON_ALT_ATTACK if we are zoomed
+	{
+		// this code is duplicated ( I know, I know ) in G_weapon.cpp for the disruptor alt-fire
+		count = ( level.time - pm->ps->weaponChargeTime ) / DISRUPTOR_CHARGE_UNIT;
+
+		if ( count < 1 )
+		{
+			count = 1;
+		}
+		else if ( count > 10 )
+		{
+			count = 10;
+		}
+
+		// Only bother with these checks if we don't have infinite ammo
+		if ( pm->ps->ammo[ weaponData[pm->ps->weapon].ammoIndex ] != -1 )
+		{
+			int dif = pm->ps->ammo[weaponData[pm->ps->weapon].ammoIndex] - *amount * count;
+
+			// If we have enough ammo to do the full charged shot, we are ok
+			if ( dif < 0 ) 
+			{
+				// we are not ok, so hack our chargetime and ammo usage, note that DIF is going to be negative
+				count += floor(dif / (float)*amount);
+
+				if ( count < 1 )
+				{
+					count = 1;
+				}
+
+				// now get a real chargeTime so the duplicated code in g_weapon doesn't get freaked
+				pm->ps->weaponChargeTime = level.time - ( count * DISRUPTOR_CHARGE_UNIT );
+			}
+		}	
+
+		// now that count is cool, get the real ammo usage
+		*amount *= count;
+
+		// this is an after-thought.  should probably re-write the function to do this naturally.
+		if ( *amount > pm->ps->ammo[weaponData[pm->ps->weapon].ammoIndex] )
+		{
+			*amount = pm->ps->ammo[weaponData[pm->ps->weapon].ammoIndex];
+		}
+	}
+
+	return count;
+}
+
+qboolean PM_DroidMelee( int npc_class )
+{
+	if ( npc_class == CLASS_PROBE 
+		|| npc_class == CLASS_SEEKER 
+		|| npc_class == CLASS_INTERROGATOR 
+		|| npc_class == CLASS_SENTRY 
+		|| npc_class == CLASS_REMOTE )
+	{
+		return qtrue;
+	}
+	return qfalse;
+}
+
+void PM_WeaponWampa( void )
+{
+	// make weapon function
+	if ( pm->ps->weaponTime > 0 ) {
+		pm->ps->weaponTime -= pml.msec;
+		if ( pm->ps->weaponTime <= 0 )
+		{
+			pm->ps->weaponTime = 0;
+		}
+	}
+
+	// check for weapon change
+	// can't change if weapon is firing, but can change again if lowering or raising
+	if ( pm->ps->weaponTime <= 0 || pm->ps->weaponstate != WEAPON_FIRING ) {
+		if ( pm->ps->weapon != pm->cmd.weapon ) {
+			PM_BeginWeaponChange( pm->cmd.weapon );
+		}
+	}
+
+	if ( pm->ps->weaponTime > 0 ) 
+	{
+		return;
+	}
+
+	// change weapon if time
+ 	if ( pm->ps->weaponstate == WEAPON_DROPPING ) {
+		PM_FinishWeaponChange();
+		return;
+	}
+
+	if ( pm->ps->weapon == WP_SABER 
+		&& (pm->cmd.buttons&BUTTON_ATTACK) 
+		&& pm->ps->torsoAnim == BOTH_HANG_IDLE )
+	{
+		pm->ps->SaberActivate();
+		pm->ps->SaberActivateTrail( 150 );
+		PM_SetAnim( pm, SETANIM_BOTH, BOTH_HANG_ATTACK, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+		pm->ps->weaponstate = WEAPON_FIRING;
+		pm->ps->saberBlocked = BLOCKED_NONE;
+		pm->ps->saberMove = LS_READY;
+		pm->ps->saberMoveNext = LS_NONE;
+	}
+	else if ( pm->ps->torsoAnim == BOTH_HANG_IDLE )
+	{
+		pm->ps->SaberDeactivateTrail( 0 );
+		pm->ps->weaponstate = WEAPON_READY;
+		pm->ps->saberMove = LS_READY;
+		pm->ps->saberMoveNext = LS_NONE;
+	}
+}
+/*
+==============
+PM_Weapon
+
+Generates weapon events and modifes the weapon counter
+==============
+*/
+static void PM_Weapon( void ) 
+{
+	int			addTime, amount, trueCount = 1;
+	qboolean	delayed_fire = qfalse;
+
+	if ( (pm->ps->eFlags&EF_HELD_BY_WAMPA) )
+	{
+		PM_WeaponWampa();
+		return;
+	}
+	if ( pm->ps->eFlags&EF_FORCE_DRAINED )
+	{//being drained
+		return;
+	}
+	if ( (pm->ps->forcePowersActive&(1<<FP_DRAIN))
+		&& pm->ps->forceDrainEntityNum < ENTITYNUM_WORLD )
+	{//draining
+		return;
+	}
+	if (pm->ps->weapon == WP_SABER && (cg.zoomMode==3||!cg.zoomMode||pm->ps->clientNum) )		// WP_LIGHTSABER
+	{	// Separate logic for lightsaber, but not for player when zoomed
+		PM_WeaponLightsaber();
+		if ( pm->gent && pm->gent->client && pm->ps->saber[0].Active() && pm->ps->saberInFlight )
+		{//FIXME: put saberTrail in playerState
+			if ( pm->gent->client->ps.saberEntityState == SES_RETURNING )
+			{//turn off the saber trail
+				pm->gent->client->ps.SaberDeactivateTrail( 75 );
+			}
+			else
+			{//turn on the saber trail
+				pm->gent->client->ps.SaberActivateTrail( 150 ); 
+			}
+		}
+		return;
+	}
+
+	if ( PM_InKnockDown( pm->ps ) || PM_InRoll( pm->ps ))
+	{//in knockdown
+		if ( pm->ps->weaponTime > 0 ) {
+			pm->ps->weaponTime -= pml.msec;
+			if ( pm->ps->weaponTime <= 0 )
+			{
+				pm->ps->weaponTime = 0;
+			}
+		}
+		return;
+	}
+
+	if( pm->gent && pm->gent->client )
+	{
+		if ( pm->gent->client->fireDelay > 0 )
+		{//FIXME: this is going to fire off one frame before you expect, actually
+			pm->gent->client->fireDelay -= pml.msec;
+			if(pm->gent->client->fireDelay <= 0)
+			{//just finished delay timer
+				if ( pm->ps->clientNum && pm->ps->weapon == WP_ROCKET_LAUNCHER )
+				{
+					G_SoundOnEnt( pm->gent, CHAN_WEAPON, "sound/weapons/rocket/lock.wav" );
+					pm->cmd.buttons |= BUTTON_ALT_ATTACK;
+				}
+				pm->gent->client->fireDelay = 0;
+				delayed_fire = qtrue;
+				if ( (pm->ps->clientNum < MAX_CLIENTS||PM_ControlledByPlayer())
+					&& pm->ps->weapon == WP_THERMAL
+					&& pm->gent->alt_fire )
+				{
+					pm->cmd.buttons |= BUTTON_ALT_ATTACK;
+				}
+			}
+			else
+			{
+				if ( pm->ps->clientNum && pm->ps->weapon == WP_ROCKET_LAUNCHER && Q_irand( 0, 1 ) )
+				{
+					G_SoundOnEnt( pm->gent, CHAN_WEAPON, "sound/weapons/rocket/tick.wav" );
+				}
+			}
+		}
+	}
+
+   // don't allow attack until all buttons are up
+	if ( pm->ps->pm_flags & PMF_RESPAWNED ) {
+		return;
+	}
+
+	// check for dead player
+	if ( pm->ps->stats[STAT_HEALTH] <= 0 )
+	{
+		if ( pm->gent && pm->gent->client )
+		{
+			// borg no longer exist, use NPC_class to check for any npc's that don't drop their weapons (if there are any)
+			// Sigh..borg shouldn't drop their weapon attachments when they die.  Also, never drop a lightsaber!
+		//	if ( pm->gent->client->playerTeam != TEAM_BORG)
+			{
+				pm->ps->weapon = WP_NONE;
+			}
+		}
+
+		if ( pm->gent )
+		{
+			pm->gent->s.loopSound = 0;
+		}
+		return;
+	}
+
+	// make weapon function
+	if ( pm->ps->weaponTime > 0 ) {
+		pm->ps->weaponTime -= pml.msec;
+		if ( pm->ps->weaponTime <= 0 )
+		{
+			pm->ps->weaponTime = 0;
+		}
+	}
+
+	// check for weapon change
+	// can't change if weapon is firing, but can change again if lowering or raising
+	if ( pm->ps->weaponTime <= 0 || pm->ps->weaponstate != WEAPON_FIRING ) {
+		if ( pm->ps->weapon != pm->cmd.weapon ) {
+			PM_BeginWeaponChange( pm->cmd.weapon );
+		}
+	}
+
+	if ( pm->ps->weaponTime > 0 ) 
+	{
+		return;
+	}
+
+	// change weapon if time
+ 	if ( pm->ps->weaponstate == WEAPON_DROPPING ) {
+		PM_FinishWeaponChange();
+		return;
+	}
+
+	if ( pm->ps->weapon == WP_NONE )
+	{
+		return;
+	}
+
+	if ( pm->ps->weaponstate == WEAPON_RAISING ) 
+	{
+		//Just selected the weapon
+		pm->ps->weaponstate = WEAPON_IDLE;
+
+		if(pm->gent && (pm->gent->s.number<MAX_CLIENTS||G_ControlledByPlayer(pm->gent)))
+		{
+			PM_SetAnim(pm,SETANIM_TORSO,BOTH_STAND1,SETANIM_FLAG_NORMAL);
+		}
+		else
+		{
+			switch(pm->ps->weapon)
+			{
+			case WP_BRYAR_PISTOL:
+			case WP_BLASTER_PISTOL:
+				if ( pm->gent 
+					&& pm->gent->weaponModel[1] > 0 )
+				{//dual pistols
+					//FIXME: should be a better way of detecting a dual-pistols user so it's not hardcoded to the saboteurcommando...
+					PM_SetAnim(pm,SETANIM_TORSO,BOTH_STAND1,SETANIM_FLAG_NORMAL);
+				}
+				else
+				{//single pistol
+					PM_SetAnim(pm,SETANIM_TORSO,TORSO_WEAPONIDLE2,SETANIM_FLAG_NORMAL);
+				}
+				break;
+			default:
+				PM_SetAnim(pm,SETANIM_TORSO,TORSO_WEAPONIDLE3,SETANIM_FLAG_NORMAL);
+				break;
+			}
+		}
+		return;
+	}
+
+	if ( pm->gent )
+	{//ready to throw thermal again, add it
+		if ( pm->ps->weapon == WP_THERMAL
+			&& pm->gent->weaponModel[0] == -1 )
+		{//add the thermal model back in our hand
+			// remove anything if we have anything already
+			G_RemoveWeaponModels( pm->gent );
+			if (weaponData[pm->ps->weapon].weaponMdl[0]) {	//might be NONE, so check if it has a model
+				G_CreateG2AttachedWeaponModel( pm->gent, weaponData[pm->ps->weapon].weaponMdl, pm->gent->handRBolt, 0 );
+				//make it sound like we took another one out from... uh.. somewhere...
+				if ( cg.time > 0 )
+				{//this way we don't get that annoying change weapon sound every time a map starts
+					PM_AddEvent( EV_CHANGE_WEAPON );
+				}
+			}
+		}
+	}
+
+	if ( !delayed_fire )
+	{//didn't just finish a fire delay
+		if ( PM_DoChargedWeapons())
+		{
+			// In some cases the charged weapon code may want us to short circuit the rest of the firing code
+			return;
+		}
+		else
+		{
+			if ( !pm->gent->client->fireDelay//not already waiting to fire
+				&& (pm->ps->clientNum < MAX_CLIENTS||PM_ControlledByPlayer())//player
+				&& pm->ps->weapon == WP_THERMAL//holding thermal
+				&& pm->gent//gent
+				&& pm->gent->client//client
+				&& (pm->cmd.buttons&(BUTTON_ATTACK|BUTTON_ALT_ATTACK)) )//holding fire
+			{//delay the actual firing of the missile until the anim has played some
+				if ( PM_StandingAnim( pm->ps->legsAnim ) 
+					|| pm->ps->legsAnim == BOTH_THERMAL_READY )
+				{
+					PM_SetAnim( pm, SETANIM_LEGS, BOTH_THERMAL_THROW, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+				}
+				PM_SetAnim(pm,SETANIM_TORSO,BOTH_THERMAL_THROW,SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_RESTART|SETANIM_FLAG_HOLD);
+				pm->gent->client->fireDelay = 300;
+				pm->ps->weaponstate = WEAPON_FIRING;
+				pm->gent->alt_fire = (qboolean)(pm->cmd.buttons&BUTTON_ALT_ATTACK);
+				return;
+			}
+		}
+	}
+
+ 	if(!delayed_fire)
+	{
+		if ( pm->ps->weapon == WP_MELEE	&& (pm->ps->clientNum < MAX_CLIENTS||PM_ControlledByPlayer()) )
+		{//melee
+			if ( (pm->cmd.buttons&(BUTTON_ATTACK|BUTTON_ALT_ATTACK)) != (BUTTON_ATTACK|BUTTON_ALT_ATTACK) )
+			{//not holding both buttons
+				if ( (pm->cmd.buttons&BUTTON_ATTACK)&&(pm->ps->pm_flags&PMF_ATTACK_HELD) )
+				{//held button
+					//clear it
+					pm->cmd.buttons &= ~BUTTON_ATTACK;
+				}
+				if ( (pm->cmd.buttons&BUTTON_ALT_ATTACK)&&(pm->ps->pm_flags&PMF_ALT_ATTACK_HELD) )
+				{//held button
+					//clear it
+					pm->cmd.buttons &= ~BUTTON_ALT_ATTACK;
+				}
+			}
+		}
+		// check for fire
+		if ( !(pm->cmd.buttons & (BUTTON_ATTACK|BUTTON_ALT_ATTACK)) )
+		{
+			pm->ps->weaponTime = 0;
+		
+			if ( pm->gent && pm->gent->client && pm->gent->client->fireDelay > 0 )
+			{//Still firing
+				pm->ps->weaponstate = WEAPON_FIRING;
+			}
+			else if ( pm->ps->weaponstate != WEAPON_READY )
+			{
+				if ( !pm->gent || !pm->gent->NPC || pm->gent->attackDebounceTime < level.time )
+				{
+					pm->ps->weaponstate = WEAPON_IDLE;
+				}
+			}
+			
+			if ( pm->ps->weapon == WP_MELEE
+				&& (pm->ps->clientNum < MAX_CLIENTS||PM_ControlledByPlayer())
+				&& PM_KickMove( pm->ps->saberMove ) )
+			{//melee, not attacking, clear move
+				pm->ps->saberMove = LS_NONE;
+			}
+			return;
+		}
+		if (pm->gent->s.m_iVehicleNum!=0)
+		{
+			// No Anims if on Veh
+		}
+
+		// start the animation even if out of ammo
+		else if ( pm->gent && pm->gent->client && pm->gent->client->NPC_class == CLASS_ROCKETTROOPER )
+		{
+			if ( pm->gent->client->moveType == MT_FLYSWIM )
+			{
+				PM_SetAnim(pm,SETANIM_TORSO,BOTH_ATTACK2,SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_RESTART|SETANIM_FLAG_HOLD);
+			}
+			else
+			{
+				PM_SetAnim(pm,SETANIM_TORSO,BOTH_ATTACK1,SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_RESTART|SETANIM_FLAG_HOLD);
+			}
+		}
+		else if ( pm->gent && pm->gent->client && pm->gent->client->NPC_class == CLASS_ASSASSIN_DROID )
+		{
+			// Crouched Attack
+ 			if (PM_CrouchAnim(pm->gent->client->ps.legsAnim))
+			{
+				PM_SetAnim(pm,SETANIM_TORSO,BOTH_ATTACK2,SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_RESTART|SETANIM_FLAG_HOLDLESS);
+			}
+
+			// Standing Attack
+			//-----------------
+			else
+			{
+			//	if (PM_StandingAnim(pm->gent->client->ps.legsAnim))
+			//	{
+			//		PM_SetAnim(pm,SETANIM_BOTH,BOTH_ATTACK3,SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_RESTART|SETANIM_FLAG_HOLDLESS);
+			//	}
+			//	else
+				{
+					PM_SetAnim(pm,SETANIM_TORSO,BOTH_ATTACK3,SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_RESTART|SETANIM_FLAG_HOLDLESS);
+				}
+			}
+		}
+		else
+		{
+			switch(pm->ps->weapon)
+			{
+				/*
+			case WP_SABER://1 - handed
+				PM_SetAnim(pm,SETANIM_TORSO,BOTH_ATTACK1,SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_RESTART|SETANIM_FLAG_HOLD);
+				break;
+	*/		
+			case WP_BRYAR_PISTOL://1-handed
+			case WP_BLASTER_PISTOL://1-handed
+				if ( pm->gent && pm->gent->weaponModel[1] > 0 )
+				{//dual pistols
+					PM_SetAnim(pm,SETANIM_TORSO,BOTH_GUNSIT1,SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_RESTART|SETANIM_FLAG_HOLD);
+				}
+				else
+				{//single pistol
+					PM_SetAnim(pm,SETANIM_TORSO,BOTH_ATTACK2,SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_RESTART|SETANIM_FLAG_HOLD);
+				}
+				break;
+			
+			case WP_MELEE:
+
+				// since there's no RACE_BOTS, I listed all the droids that have might have melee attacks - dmv
+				if ( pm->gent && pm->gent->client )
+				{
+					if ( PM_DroidMelee( pm->gent->client->NPC_class ) )
+					{
+						if ( rand() & 1 )
+							PM_SetAnim(pm,SETANIM_BOTH,BOTH_MELEE1,SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD);
+						else
+							PM_SetAnim(pm,SETANIM_BOTH,BOTH_MELEE2,SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD);
+					}
+					else
+					{
+						int anim = -1;
+						if ( (pm->ps->clientNum < MAX_CLIENTS ||PM_ControlledByPlayer())
+							&& g_debugMelee->integer )
+						{
+							if ( (pm->cmd.buttons&BUTTON_ALT_ATTACK) )
+							{
+								if ( (pm->cmd.buttons&BUTTON_ATTACK) )
+								{
+									PM_TryGrab();
+								}
+								else if ( !(pm->ps->pm_flags&PMF_ALT_ATTACK_HELD) )
+								{
+									PM_CheckKick();
+								}
+							}
+							else if ( !(pm->ps->pm_flags&PMF_ATTACK_HELD) )
+							{
+								anim = PM_PickAnim( pm->gent, BOTH_MELEE1, BOTH_MELEE2 );
+							}
+						}
+						else
+						{
+							anim = PM_PickAnim( pm->gent, BOTH_MELEE1, BOTH_MELEE2 );
+						}
+						if ( anim != -1 )
+						{
+							if ( VectorCompare( pm->ps->velocity, vec3_origin ) && pm->cmd.upmove >= 0 )
+							{
+								PM_SetAnim( pm, SETANIM_BOTH, anim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD|SETANIM_FLAG_RESTART );
+							}
+							else
+							{
+								PM_SetAnim( pm, SETANIM_TORSO, anim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD|SETANIM_FLAG_RESTART );
+							}
+						}
+					}
+				}
+				break;
+
+			case WP_TUSKEN_RIFLE:
+				if ( pm->cmd.buttons & BUTTON_ALT_ATTACK )
+				{//shoot
+					//in alt-fire, sniper mode
+					PM_SetAnim( pm, SETANIM_TORSO, BOTH_ATTACK4, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+				}
+				else
+				{//melee
+					int anim = PM_PickAnim( pm->gent, BOTH_TUSKENATTACK1, BOTH_TUSKENATTACK3 );	// Rifle
+					if ( VectorCompare( pm->ps->velocity, vec3_origin ) && pm->cmd.upmove >= 0 )
+					{
+						PM_SetAnim( pm, SETANIM_BOTH, anim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD|SETANIM_FLAG_RESTART );
+					}
+					else
+					{
+						PM_SetAnim( pm, SETANIM_TORSO, anim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD|SETANIM_FLAG_RESTART );
+					}
+				}
+				break;
+
+			case WP_TUSKEN_STAFF:
+
+				if ( pm->gent && pm->gent->client )
+				{
+					int anim;
+					int flags = (SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD|SETANIM_FLAG_RESTART);
+					if ( (pm->ps->clientNum < MAX_CLIENTS||PM_ControlledByPlayer()) )
+					{//player
+						if ( pm->cmd.buttons & BUTTON_ALT_ATTACK )
+						{
+							if ( pm->cmd.buttons & BUTTON_ATTACK )
+							{
+								anim = BOTH_TUSKENATTACK3;
+							}
+							else
+							{
+								anim = BOTH_TUSKENATTACK2;
+							}
+						}
+						else
+						{
+							anim = BOTH_TUSKENATTACK1;
+						}
+					}
+					else
+					{// npc
+						if ( pm->cmd.buttons & BUTTON_ALT_ATTACK )
+						{
+							anim = BOTH_TUSKENLUNGE1;
+							if (pm->ps->torsoAnimTimer>0)
+							{
+								flags &= ~SETANIM_FLAG_RESTART;
+							}
+						}
+						else
+						{
+							anim = PM_PickAnim( pm->gent, BOTH_TUSKENATTACK1, BOTH_TUSKENATTACK3 );
+						}
+					}
+					if ( VectorCompare( pm->ps->velocity, vec3_origin ) && pm->cmd.upmove >= 0 )
+					{
+						PM_SetAnim( pm, SETANIM_BOTH, anim,  flags, 0);
+					}
+					else
+					{
+						PM_SetAnim( pm, SETANIM_TORSO, anim, flags, 0);
+					}
+				}
+				break;
+
+			case WP_NOGHRI_STICK:
+
+				if ( pm->gent && pm->gent->client )
+				{
+					int anim;
+					if ( pm->cmd.buttons & BUTTON_ATTACK )
+					{
+						anim = BOTH_ATTACK3;
+					}
+					else
+					{
+						anim = PM_PickAnim( pm->gent, BOTH_TUSKENATTACK1, BOTH_TUSKENATTACK3 );
+					}
+					if ( anim != BOTH_ATTACK3 && VectorCompare( pm->ps->velocity, vec3_origin ) && pm->cmd.upmove >= 0 )
+					{
+						PM_SetAnim( pm, SETANIM_BOTH, anim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD|SETANIM_FLAG_RESTART );
+					}
+					else
+					{
+						PM_SetAnim( pm, SETANIM_TORSO, anim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD|SETANIM_FLAG_RESTART );
+					}
+				}
+				break;
+
+			case WP_BLASTER:
+				PM_SetAnim( pm, SETANIM_TORSO, BOTH_ATTACK3, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD|SETANIM_FLAG_RESTART);
+				break;
+
+			case WP_DISRUPTOR:
+				if ( ((pm->ps->clientNum >= MAX_CLIENTS&&!PM_ControlledByPlayer())&& pm->gent && pm->gent->NPC && (pm->gent->NPC->scriptFlags&SCF_ALT_FIRE)) ||
+					((pm->ps->clientNum < MAX_CLIENTS||PM_ControlledByPlayer()) && cg.zoomMode == 2 ) )
+				{//NPC or player in alt-fire, sniper mode
+					PM_SetAnim( pm, SETANIM_TORSO, BOTH_ATTACK4, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+				}
+				else
+				{//in primary fire mode
+					PM_SetAnim( pm, SETANIM_TORSO, BOTH_ATTACK3, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD|SETANIM_FLAG_RESTART);
+				}
+				break;
+
+			case WP_BOT_LASER:
+				PM_SetAnim(pm,SETANIM_TORSO,BOTH_ATTACK1,SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_RESTART|SETANIM_FLAG_HOLD);
+				break;
+
+			case WP_THERMAL:
+				if ( (pm->ps->clientNum >= MAX_CLIENTS&&!PM_ControlledByPlayer()) )
+				{
+					if ( PM_StandingAnim( pm->ps->legsAnim ) )
+					{
+						PM_SetAnim( pm, SETANIM_LEGS, BOTH_ATTACK10, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+					}
+					PM_SetAnim(pm,SETANIM_TORSO,BOTH_ATTACK10,SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_RESTART|SETANIM_FLAG_HOLD);
+				}
+				else
+				{
+					if ( cg.renderingThirdPerson )
+					{
+						if ( PM_StandingAnim( pm->ps->legsAnim ) 
+							|| pm->ps->legsAnim == BOTH_THERMAL_READY )
+						{
+							PM_SetAnim( pm, SETANIM_LEGS, BOTH_THERMAL_THROW, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+						}
+						PM_SetAnim(pm,SETANIM_TORSO,BOTH_THERMAL_THROW,SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD);//|SETANIM_FLAG_RESTART
+					}
+					else
+					{
+						PM_SetAnim(pm,SETANIM_TORSO,BOTH_ATTACK2,SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_RESTART|SETANIM_FLAG_HOLD);
+					}
+				}
+				break;
+
+			case WP_EMPLACED_GUN:
+				// Guess we don't play an attack animation?  Maybe we should have a custom one??
+				break;
+
+			case WP_NONE:
+				// no anim
+				break;
+
+			case WP_REPEATER:
+				if ( pm->gent && pm->gent->client && pm->gent->client->NPC_class == CLASS_GALAKMECH )
+				{//
+					if ( pm->cmd.buttons & BUTTON_ALT_ATTACK )
+					{
+						PM_SetAnim(pm,SETANIM_TORSO,BOTH_ATTACK3,SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_RESTART|SETANIM_FLAG_HOLD);
+					}
+					else
+					{
+						PM_SetAnim(pm,SETANIM_TORSO,BOTH_ATTACK1,SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_RESTART|SETANIM_FLAG_HOLD);
+					}
+				}
+				else
+				{
+					PM_SetAnim(pm,SETANIM_TORSO,BOTH_ATTACK3,SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_RESTART|SETANIM_FLAG_HOLD);
+				}
+				break;
+
+			case WP_TRIP_MINE:
+			case WP_DET_PACK:
+				PM_SetAnim(pm,SETANIM_TORSO,BOTH_ATTACK11,SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_RESTART|SETANIM_FLAG_HOLD);
+				break;
+
+			default://2-handed heavy weapon
+				PM_SetAnim(pm,SETANIM_TORSO,BOTH_ATTACK3,SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_RESTART|SETANIM_FLAG_HOLD);
+				break;
+			}
+		}
+	}
+
+	if ( pm->cmd.buttons & BUTTON_ALT_ATTACK )
+	{
+		amount = weaponData[pm->ps->weapon].altEnergyPerShot;
+	}
+	else
+	{
+		amount = weaponData[pm->ps->weapon].energyPerShot;
+	}
+
+	if ( (pm->ps->weaponstate == WEAPON_CHARGING) || (pm->ps->weaponstate == WEAPON_CHARGING_ALT) )
+	{
+		// charging weapons may want to do their own ammo logic.
+		trueCount = PM_DoChargingAmmoUsage( &amount );
+	}
+
+	pm->ps->weaponstate = WEAPON_FIRING;
+
+	// take an ammo away if not infinite
+	if ( pm->ps->ammo[ weaponData[pm->ps->weapon].ammoIndex ] != -1 )
+	{
+		// enough energy to fire this weapon?
+		if ((pm->ps->ammo[weaponData[pm->ps->weapon].ammoIndex] - amount) >= 0) 
+		{
+			pm->ps->ammo[weaponData[pm->ps->weapon].ammoIndex] -= amount;
+		}
+		else	// Not enough energy
+		{
+			if ( !( pm->ps->eFlags & EF_LOCKED_TO_WEAPON ))
+			{
+				// Switch weapons
+				PM_AddEvent( EV_NOAMMO );
+				pm->ps->weaponTime += 500;
+			}
+			return;
+		}
+	}
+
+	if ( pm->gent && pm->gent->client && pm->gent->client->fireDelay > 0 )
+	{//FIXME: this is going to fire off one frame before you expect, actually
+		// Clear these out since we're not actually firing yet
+		pm->ps->eFlags &= ~EF_FIRING;
+		pm->ps->eFlags &= ~EF_ALT_FIRING;
+		return;
+	}
+
+	if ( pm->ps->weapon == WP_EMPLACED_GUN )
+	{
+		if ( pm->gent
+			&& pm->gent->owner
+			&& pm->gent->owner->e_UseFunc == useF_eweb_use )
+		{//eweb always shoots alt-fire, for proper effects and sounds
+			PM_AddEvent( EV_ALT_FIRE );
+			addTime = weaponData[pm->ps->weapon].altFireTime;
+		}
+		else
+		{//emplaced gun always shoots normal fire
+			PM_AddEvent( EV_FIRE_WEAPON );
+			addTime = weaponData[pm->ps->weapon].fireTime;
+		}
+	}
+	else if ( (pm->ps->weapon == WP_MELEE && (pm->ps->clientNum>=MAX_CLIENTS||!g_debugMelee->integer) )
+		|| pm->ps->weapon == WP_TUSKEN_STAFF 
+		|| (pm->ps->weapon == WP_TUSKEN_RIFLE&&!(pm->cmd.buttons&BUTTON_ALT_ATTACK))  )
+	{
+		PM_AddEvent( EV_FIRE_WEAPON );
+		addTime = pm->ps->torsoAnimTimer;
+	}
+	else if ( pm->cmd.buttons & BUTTON_ALT_ATTACK ) 	
+	{
+		PM_AddEvent( EV_ALT_FIRE );
+		addTime = weaponData[pm->ps->weapon].altFireTime;
+		if ( pm->ps->weapon == WP_THERMAL )
+		{//threw our thermal
+			if ( pm->gent )
+			{// remove the thermal model if we had it.
+				G_RemoveWeaponModels( pm->gent );
+				if ( (pm->ps->clientNum >= MAX_CLIENTS&&!PM_ControlledByPlayer()) )
+				{//NPCs need to know when to put the thermal back in their hand
+					pm->ps->weaponTime = pm->ps->torsoAnimTimer-500;
+				}
+			}
+		}
+	}
+	else 
+	{
+		if ( pm->ps->clientNum //NPC
+			&& !PM_ControlledByPlayer() //not under player control
+			&& pm->ps->weapon == WP_THERMAL //using thermals
+			&& pm->ps->torsoAnim != BOTH_ATTACK10 )//not in the throw anim
+		{//oops, got knocked out of the anim, don't throw the thermal
+			return;
+		}
+		PM_AddEvent( EV_FIRE_WEAPON );
+		addTime = weaponData[pm->ps->weapon].fireTime;
+
+		switch( pm->ps->weapon)
+		{
+		case WP_REPEATER:
+			// repeater is supposed to do smoke after sustained bursts
+			pm->ps->weaponShotCount++;
+			break;
+		case WP_BOWCASTER:
+			addTime *= (( trueCount < 3 ) ? 0.35f : 1.0f );// if you only did a small charge shot with the bowcaster, use less time between shots
+			break;
+		case WP_THERMAL:
+			if ( pm->gent )
+			{// remove the thermal model if we had it.
+				G_RemoveWeaponModels( pm->gent );
+				if ( (pm->ps->clientNum >= MAX_CLIENTS&&!PM_ControlledByPlayer()) )
+				{//NPCs need to know when to put the thermal back in their hand
+					pm->ps->weaponTime = pm->ps->torsoAnimTimer-500;
+				}
+			}
+			break;
+		}
+	}
+
+
+	if(pm->gent && pm->gent->NPC != NULL )
+	{//NPCs have their own refire logic
+		return;
+	}
+
+	if ( g_timescale != NULL )
+	{
+		if ( g_timescale->value < 1.0f )
+		{
+			if ( !MatrixMode )
+			{//Special test for Matrix Mode (tm)
+				if ( pm->ps->clientNum == 0 && !player_locked && (pm->ps->forcePowersActive&(1<<FP_SPEED)||pm->ps->forcePowersActive&(1<<FP_RAGE)) )
+				{//player always fires at normal speed
+					addTime *= g_timescale->value;
+				}
+				else if ( g_entities[pm->ps->clientNum].client 
+					&& (pm->ps->forcePowersActive&(1<<FP_SPEED)||pm->ps->forcePowersActive&(1<<FP_RAGE)) )
+				{
+					addTime *= g_timescale->value;
+				}
+			}
+		}
+	}
+
+	pm->ps->weaponTime += addTime;
+	pm->ps->lastShotTime = level.time;//so we know when the last time we fired our gun is
+	
+	// HACK!!!!!
+	if ( pm->ps->ammo[weaponData[pm->ps->weapon].ammoIndex] <= 0 )
+	{
+		if ( pm->ps->weapon == WP_THERMAL || pm->ps->weapon == WP_TRIP_MINE )
+		{
+			// because these weapons have the ammo attached to the hand, we should switch weapons when the last one is thrown, otherwise it will look silly
+			//	NOTE: could also switch to an empty had version, but was told we aren't getting any new models at this point
+			CG_OutOfAmmoChange();
+			PM_SetAnim(pm,SETANIM_TORSO,TORSO_DROPWEAP1 + 2,SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD); // hack weapon down!
+			pm->ps->weaponTime = 50;
+		}
+	}
+}
+
+/*
+==============
+PM_VehicleWeapon
+
+Generates weapon events and modifes the weapon counter
+==============
+*/
+static void PM_VehicleWeapon( void ) 
+{
+	int			addTime = 0, amount;
+	qboolean	delayed_fire = qfalse;
+
+	if ( pm->ps->weapon == WP_NONE )
+	{ 
+		return;
+	}
+
+	if(pm->gent && pm->gent->client && pm->gent->client->fireDelay > 0) 
+	{//FIXME: this is going to fire off one frame before you expect, actually
+		pm->gent->client->fireDelay -= pml.msec;
+		if(pm->gent->client->fireDelay <= 0)
+		{//just finished delay timer
+			if ( pm->ps->clientNum && pm->ps->weapon == WP_ROCKET_LAUNCHER )
+			{
+				G_SoundOnEnt( pm->gent, CHAN_WEAPON, "sound/weapons/rocket/lock.wav" );
+				pm->cmd.buttons |= BUTTON_ALT_ATTACK;
+			}
+			pm->gent->client->fireDelay = 0;
+			delayed_fire = qtrue;
+		}
+		else
+		{
+			if ( pm->ps->clientNum && pm->ps->weapon == WP_ROCKET_LAUNCHER && Q_irand( 0, 1 ) )
+			{
+				G_SoundOnEnt( pm->gent, CHAN_WEAPON, "sound/weapons/rocket/tick.wav" );
+			}
+		}
+	}
+
+   // don't allow attack until all buttons are up
+	if ( pm->ps->pm_flags & PMF_RESPAWNED ) {
+		return;
+	}
+
+	// check for dead player
+	if ( pm->ps->stats[STAT_HEALTH] <= 0 )
+	{
+		if ( pm->gent && pm->gent->client )
+		{
+			// borg no longer exist, use NPC_class to check for any npc's that don't drop their weapons (if there are any)
+			// Sigh..borg shouldn't drop their weapon attachments when they die.  Also, never drop a lightsaber!
+		//	if ( pm->gent->client->playerTeam != TEAM_BORG)
+			{
+		//		pm->ps->weapon = WP_NONE;
+			}
+		}
+
+		if ( pm->gent )
+		{
+			pm->gent->s.loopSound = 0;
+		}
+		return;
+	}
+
+	// make weapon function
+	if ( pm->ps->weaponTime > 0 ) {
+		pm->ps->weaponTime -= pml.msec;
+		if ( pm->ps->weaponTime <= 0 )
+		{
+			pm->ps->weaponTime = 0;
+		}
+	}
+
+	if ( pm->ps->weaponTime > 0 ) 
+	{
+		return;
+	}
+
+	// change weapon if time
+	if ( pm->ps->weaponstate == WEAPON_DROPPING ) {
+		PM_FinishWeaponChange();
+		return;
+	}
+
+	if ( PM_DoChargedWeapons())
+	{
+		// In some cases the charged weapon code may want us to short circuit the rest of the firing code
+		return;
+	}
+
+	if(!delayed_fire)
+	{
+		// check for fire
+		if ( !(pm->cmd.buttons & (BUTTON_ATTACK|BUTTON_ALT_ATTACK)) )
+		{
+			pm->ps->weaponTime = 0;
+		
+			if ( pm->gent && pm->gent->client && pm->gent->client->fireDelay > 0 )
+			{//Still firing
+				pm->ps->weaponstate = WEAPON_FIRING;
+			}
+			else if ( pm->ps->weaponstate != WEAPON_READY )
+			{
+				if ( !pm->gent || !pm->gent->NPC || pm->gent->attackDebounceTime < level.time )
+				{
+					pm->ps->weaponstate = WEAPON_IDLE;
+				}
+			}
+			
+			return;
+		}
+	}
+
+	if ( pm->cmd.buttons & BUTTON_ALT_ATTACK )
+	{
+		amount = weaponData[pm->ps->weapon].altEnergyPerShot;
+	}
+	else
+	{
+		amount = weaponData[pm->ps->weapon].energyPerShot;
+	}
+
+	pm->ps->weaponstate = WEAPON_FIRING;
+
+	if ( pm->gent && pm->gent->client && pm->gent->client->fireDelay > 0 )
+	{//FIXME: this is going to fire off one frame before you expect, actually
+		// Clear these out since we're not actually firing yet
+		pm->ps->eFlags &= ~EF_FIRING;
+		pm->ps->eFlags &= ~EF_ALT_FIRING;
+		return;
+	}
+
+	if ( pm->cmd.buttons & BUTTON_ALT_ATTACK ) 	
+	{
+		PM_AddEvent( EV_ALT_FIRE );
+		//addTime = weaponData[pm->ps->weapon].altFireTime;
+	}
+	else 
+	{
+		PM_AddEvent( EV_FIRE_WEAPON );
+		// TODO: Use the real weapon fire time from the vehicle cfg file.
+		//addTime = weaponData[pm->ps->weapon].fireTime;
+	} 
+
+/*	if(pm->gent && pm->gent->NPC != NULL )
+	{//NPCs have their own refire logic
+		return;
+	}*/
+
+	if ( g_timescale != NULL )
+	{
+		if ( g_timescale->value < 1.0f )
+		{
+			if ( !MatrixMode )
+			{//Special test for Matrix Mode (tm)
+				if ( pm->ps->clientNum == 0 && !player_locked && (pm->ps->forcePowersActive&(1<<FP_SPEED)||pm->ps->forcePowersActive&(1<<FP_RAGE)) )
+				{//player always fires at normal speed
+					addTime *= g_timescale->value;
+				}
+				else if ( g_entities[pm->ps->clientNum].client 
+					&& (pm->ps->forcePowersActive&(1<<FP_SPEED)||pm->ps->forcePowersActive&(1<<FP_RAGE)) )
+				{
+					addTime *= g_timescale->value;
+				}
+			}
+		}
+	}
+
+	pm->ps->weaponTime += addTime;
+	pm->ps->lastShotTime = level.time;//so we know when the last time we fired our gun is
+}
+
+
+extern void ForceHeal( gentity_t *self );
+extern void ForceTelepathy( gentity_t *self );
+extern void ForceRage( gentity_t *self );
+extern void ForceProtect( gentity_t *self );
+extern void ForceAbsorb( gentity_t *self );
+extern void ForceSeeing( gentity_t *self );
+void PM_CheckForceUseButton( gentity_t *ent, usercmd_t *ucmd  )
+{
+	if ( !ent )
+	{
+		return;
+	}
+	if ( ucmd->buttons & BUTTON_USE_FORCE ) 
+	{
+		if (!(ent->client->ps.pm_flags & PMF_USEFORCE_HELD))
+		{
+			//impulse one shot
+			switch ( showPowers[cg.forcepowerSelect] )
+			{
+			case FP_HEAL:
+				ForceHeal( ent );
+				break;
+			case FP_SPEED:
+				ForceSpeed( ent );
+				break;
+			case FP_PUSH:
+				ForceThrow( ent, qfalse );
+				break;
+			case FP_PULL:
+				ForceThrow( ent, qtrue );
+				break;
+			case FP_TELEPATHY:
+				ForceTelepathy( ent );
+				break;
+				// Added 01/20/03 by AReis.
+				// New Jedi Academy powers.
+			case FP_RAGE:		//duration - speed, invincibility and extra damage for short period, drains your health and leaves you weak and slow afterwards.
+				ForceRage( ent );
+				break;
+			case FP_PROTECT:	//duration - protect against physical/energy (level 1 stops blaster/energy bolts, level 2 stops projectiles, level 3 protects against explosions)
+				ForceProtect( ent );
+				break;
+			case FP_ABSORB:		//duration - protect against dark force powers (grip, lightning, drain - maybe push/pull, too?)
+				ForceAbsorb( ent );
+				break;
+			case FP_SEE:		//duration - detect/see hidden enemies
+				ForceSeeing( ent );
+				break;
+			}
+		}
+		//these stay are okay to call every frame button is down
+		switch ( showPowers[cg.forcepowerSelect] )
+		{
+		case FP_LEVITATION:
+			ucmd->upmove = 127;
+			break;
+		case FP_GRIP:
+			ucmd->buttons |= BUTTON_FORCEGRIP;
+			break;
+		case FP_LIGHTNING:
+			ucmd->buttons |= BUTTON_FORCE_LIGHTNING;
+			break;
+		case FP_DRAIN:
+			// FIXME! Failing at WP_ForcePowerUsable(). -AReis
+			ucmd->buttons |= BUTTON_FORCE_DRAIN;
+			break;
+//		default:
+//			Com_Printf( "Use Force: Unhandled force: %d\n", showPowers[cg.forcepowerSelect]);
+//			break;
+		}
+		ent->client->ps.pm_flags |= PMF_USEFORCE_HELD;
+	}
+	else//not pressing USE_FORCE
+	{
+		ent->client->ps.pm_flags &= ~PMF_USEFORCE_HELD;
+	}
+}
+
+/*
+================
+PM_ForcePower
+================
+sends event to client for client side fx, not used
+*/
+
+/*
+static void PM_ForcePower(void)
+{
+	// check for item using
+	if ( pm->cmd.buttons & BUTTON_USE_FORCE ) 
+	{
+		if ( ! ( pm->ps->pm_flags & PMF_USE_FORCE ) ) 
+		{
+			pm->ps->pm_flags |= PMF_USE_FORCE;
+			PM_AddEvent( EV_USE_FORCE);
+			return;		
+		}
+	} 
+	else 
+	{
+		pm->ps->pm_flags &= ~PMF_USE_FORCE;
+	}
+}
+*/
+
+/*
+================
+PM_DropTimers
+================
+*/
+static void PM_DropTimers( void ) 
+{
+	// drop misc timing counter
+	if ( pm->ps->pm_time ) 
+	{
+		if ( pml.msec >= pm->ps->pm_time ) 
+		{
+			pm->ps->pm_flags &= ~PMF_ALL_TIMES;
+			pm->ps->pm_time = 0;
+		} 
+		else 
+		{
+			pm->ps->pm_time -= pml.msec;
+		}
+	}
+
+	// drop legs animation counter
+	if ( pm->ps->legsAnimTimer > 0 )
+	{
+		int newTime = pm->ps->legsAnimTimer - pml.msec;
+
+		if ( newTime < 0 )
+		{
+			newTime = 0;
+		}
+
+		PM_SetLegsAnimTimer( pm->gent, &pm->ps->legsAnimTimer, newTime );
+	}
+
+	// drop torso animation counter
+	if ( pm->ps->torsoAnimTimer > 0 )
+	{
+		int newTime = pm->ps->torsoAnimTimer - pml.msec;
+
+		if ( newTime < 0 )
+		{
+			newTime = 0;
+		}
+
+		PM_SetTorsoAnimTimer( pm->gent, &pm->ps->torsoAnimTimer, newTime );
+	}
+}
+
+void PM_SetSpecialMoveValues (void )
+{
+	Flying = 0;
+	if ( pm->gent )
+	{
+		if ( pm->gent->client && pm->gent->client->moveType == MT_FLYSWIM )
+		{
+			Flying = FLY_NORMAL;
+		}
+		else if ( pm->gent && pm->gent->client && pm->gent->client->NPC_class == CLASS_VEHICLE )
+		{
+			if ( pm->gent->m_pVehicle->m_pVehicleInfo->type == VH_FIGHTER )
+			{
+				Flying = FLY_VEHICLE;
+			}
+			else if ( pm->gent->m_pVehicle->m_pVehicleInfo->hoverHeight > 0 )
+			{//FIXME: or just check for hoverHeight?
+				Flying = FLY_HOVER;
+			}
+		}
+	}
+
+	if ( g_timescale != NULL )
+	{
+		if ( g_timescale->value < 1.0f )
+		{
+			if ( !MatrixMode )
+			{
+				if ( pm->ps->clientNum == 0 && !player_locked && (pm->ps->forcePowersActive&(1<<FP_SPEED)||pm->ps->forcePowersActive&(1<<FP_RAGE)) )
+				{
+					pml.frametime *= (1.0f/g_timescale->value);
+				}
+				else if ( g_entities[pm->ps->clientNum].client 
+					&& (pm->ps->forcePowersActive&(1<<FP_SPEED)||pm->ps->forcePowersActive&(1<<FP_RAGE)) )
+				{
+					pml.frametime *= (1.0f/g_timescale->value);
+				}
+			}
+		}
+	}
+}
+
+extern float cg_zoomFov;	//from cg_view.cpp
+
+//-------------------------------------------
+void PM_AdjustAttackStates( pmove_t *pm )
+//-------------------------------------------
+{
+	int amount;
+
+	// get ammo usage
+	if ( pm->cmd.buttons & BUTTON_ALT_ATTACK )
+	{
+		amount = pm->ps->ammo[weaponData[ pm->ps->weapon ].ammoIndex] - weaponData[pm->ps->weapon].altEnergyPerShot;
+	}
+	else
+	{
+		amount = pm->ps->ammo[weaponData[ pm->ps->weapon ].ammoIndex] - weaponData[pm->ps->weapon].energyPerShot;
+	}
+
+	if ( pm->ps->weapon == WP_SABER && (!cg.zoomMode||pm->ps->clientNum) )
+	{//don't let the alt-attack be interpreted as an actual attack command
+		if ( pm->ps->saberInFlight )
+		{
+			pm->cmd.buttons &= ~BUTTON_ALT_ATTACK;
+			//FIXME: what about alt-attack modifier button?
+			if ( (!pm->ps->dualSabers || !pm->ps->saber[1].Active()) )
+			{//saber not in hand, can't swing it
+				pm->cmd.buttons &= ~BUTTON_ATTACK;
+			}
+		}
+		//saber staff alt-attack does a special attack anim, non-throwable sabers do kicks
+		if ( pm->ps->saberAnimLevel != SS_STAFF 
+			&& pm->ps->saber[0].throwable )
+		{//using a throwable saber, so remove the saber throw button
+			if ( !g_saberNewControlScheme->integer
+				&& PM_CanDoKata() )
+			{//old control scheme - alt-attack + attack does kata
+			}
+			else
+			{//new control scheme - alt-attack doesn't have anything to do with katas, safe to clear it here
+				pm->cmd.buttons &= ~BUTTON_ALT_ATTACK;
+			}
+		}
+	}
+
+	// disruptor alt-fire should toggle the zoom mode, but only bother doing this for the player?
+	if ( pm->ps->weapon == WP_DISRUPTOR && pm->gent && (pm->gent->s.number<MAX_CLIENTS||G_ControlledByPlayer(pm->gent)) && pm->ps->weaponstate != WEAPON_DROPPING )
+	{
+		// we are not alt-firing yet, but the alt-attack button was just pressed and
+		//	we either are ducking ( in which case we don't care if they are moving )...or they are not ducking...and also not moving right/forward.
+		if ( !(pm->ps->eFlags & EF_ALT_FIRING) && (pm->cmd.buttons & BUTTON_ALT_ATTACK)
+				&& ( pm->cmd.upmove < 0 || ( !pm->cmd.forwardmove && !pm->cmd.rightmove )))
+		{
+			// We just pressed the alt-fire key
+			if ( cg.zoomMode == 0 || cg.zoomMode == 3 )
+			{
+				G_SoundOnEnt( pm->gent, CHAN_AUTO, "sound/weapons/disruptor/zoomstart.wav" );
+#ifdef _IMMERSION
+				G_Force( pm->gent, G_ForceIndex( "fffx/weapons/disruptor/zoomstart", FF_CHANNEL_WEAPON ) );
+#endif // _IMMERSION
+				// not already zooming, so do it now
+				cg.zoomMode = 2;
+				cg.zoomLocked = qfalse;
+				cg_zoomFov = 80.0f;//(cg.overrides.active&CG_OVERRIDE_FOV) ? cg.overrides.fov : cg_fov.value;
+			}
+			else if ( cg.zoomMode == 2 )
+			{
+				G_SoundOnEnt( pm->gent, CHAN_AUTO, "sound/weapons/disruptor/zoomend.wav" );
+#ifdef _IMMERSION
+				G_Force( pm->gent, G_ForceIndex( "fffx/weapons/disruptor/zoomend", FF_CHANNEL_WEAPON ) );
+#endif // _IMMERSION
+				// already zooming, so must be wanting to turn it off
+				cg.zoomMode = 0;
+				cg.zoomTime = cg.time;
+				cg.zoomLocked = qfalse;
+			}
+		}
+		else if ( !(pm->cmd.buttons & BUTTON_ALT_ATTACK ))
+		{
+			// Not pressing zoom any more
+			if ( cg.zoomMode == 2 )
+			{
+				// were zooming in, so now lock the zoom
+				cg.zoomLocked = qtrue;
+			}
+		}
+
+		if ( pm->cmd.buttons & BUTTON_ATTACK )
+		{
+			// If we are zoomed, we should switch the ammo usage to the alt-fire, otherwise, we'll
+			//	just use whatever ammo was selected from above
+			if ( cg.zoomMode == 2 )
+			{
+				amount = pm->ps->ammo[weaponData[ pm->ps->weapon ].ammoIndex] - 
+							weaponData[pm->ps->weapon].altEnergyPerShot;
+			}
+		}
+		else
+		{
+			// alt-fire button pressing doesn't use any ammo
+			amount = 0;
+		}
+
+	}
+
+	// Check for binocular specific mode
+	if ( cg.zoomMode == 1 && pm->gent && (pm->gent->s.number<MAX_CLIENTS||G_ControlledByPlayer(pm->gent)) ) // 
+	{
+		if ( pm->cmd.buttons & BUTTON_ALT_ATTACK && pm->ps->batteryCharge )
+		{
+			// zooming out
+			cg.zoomLocked = qfalse;
+			cg.zoomDir = 1;
+		}
+		else if ( pm->cmd.buttons & BUTTON_ATTACK && pm->ps->batteryCharge )
+		{
+			// zooming in
+			cg.zoomLocked = qfalse;
+			cg.zoomDir = -1;
+		}
+		else
+		{
+			// if no buttons are down, we should be in a locked state
+			cg.zoomLocked = qtrue;
+		}
+
+		// kill buttons and associated firing flags so we can't fire
+		pm->ps->eFlags &= ~EF_FIRING;
+		pm->ps->eFlags &= ~EF_ALT_FIRING;
+		pm->cmd.buttons &= ~(BUTTON_ALT_ATTACK|BUTTON_ATTACK);
+	}
+
+	// set the firing flag for continuous beam weapons, phaser will fire even if out of ammo
+	if ( (( pm->cmd.buttons & BUTTON_ATTACK || pm->cmd.buttons & BUTTON_ALT_ATTACK ) && ( amount >= 0 || pm->ps->weapon == WP_SABER )) ) 
+	{
+		if ( pm->cmd.buttons & BUTTON_ALT_ATTACK )
+		{
+			pm->ps->eFlags |= EF_ALT_FIRING;
+			if ( pm->ps->clientNum < MAX_CLIENTS && pm->gent && (pm->ps->eFlags&EF_IN_ATST) )
+			{//switch ATST barrels
+				pm->gent->alt_fire = qtrue;
+			}
+		}
+		else
+		{
+			pm->ps->eFlags &= ~EF_ALT_FIRING;
+			if ( pm->ps->clientNum < MAX_CLIENTS && pm->gent && (pm->ps->eFlags&EF_IN_ATST) )
+			{//switch ATST barrels
+				pm->gent->alt_fire = qfalse;
+			}
+		}
+
+		// This flag should always get set, even when alt-firing
+		pm->ps->eFlags |= EF_FIRING;
+	} 
+	else 
+	{
+//		int iFlags = pm->ps->eFlags;
+
+		// Clear 'em out
+		pm->ps->eFlags &= ~EF_FIRING;
+		pm->ps->eFlags &= ~EF_ALT_FIRING;
+
+		// if I don't check the flags before stopping FX then it switches them off too often, which tones down
+		//	the stronger FFFX so you can hardly feel them. However, if you only do iton these flags then the 
+		//	repeat-fire weapons like tetrion and dreadnought don't switch off quick enough. So...
+		//
+/* // Might need this for beam type weapons
+		if ( pm->ps->weapon == WP_DREADNOUGHT || (iFlags & (EF_FIRING|EF_ALT_FIRING) )
+		{
+			cgi_FF_StopAllFX();
+		}
+		*/
+	}
+
+	// disruptor should convert a main fire to an alt-fire if the gun is currently zoomed
+	if ( pm->ps->weapon == WP_DISRUPTOR && pm->gent && (pm->gent->s.number<MAX_CLIENTS||G_ControlledByPlayer(pm->gent)) )
+	{
+		if ( pm->cmd.buttons & BUTTON_ATTACK && cg.zoomMode == 2 )
+		{
+			// converting the main fire to an alt-fire
+			pm->cmd.buttons |= BUTTON_ALT_ATTACK;
+			pm->ps->eFlags |= EF_ALT_FIRING;
+		}
+		else
+		{
+			// don't let an alt-fire through
+			pm->cmd.buttons &= ~BUTTON_ALT_ATTACK;
+		}
+	}
+}
+
+qboolean PM_WeaponOkOnVehicle( int weapon )
+{
+	//FIXME: check g_vehicleInfo for our vehicle?
+	switch ( weapon )
+	{
+	case WP_NONE:
+	case WP_SABER:
+	case WP_BLASTER:
+	case WP_THERMAL:
+		return qtrue;
+		break;
+	}
+	return qfalse;
+}
+
+void PM_CheckInVehicleSaberAttackAnim( void )
+{//A bit of a hack, but makes the vehicle saber attacks act like any other saber attack...
+	// make weapon function
+	if ( pm->ps->weaponTime > 0 ) {
+		pm->ps->weaponTime -= pml.msec;
+		if ( pm->ps->weaponTime <= 0 )
+		{
+			pm->ps->weaponTime = 0;
+		}
+	}
+	PM_CheckClearSaberBlock();
+
+/*	if ( PM_SaberBlocking() )
+	{//busy blocking, don't do attacks
+		return;
+	}
+*/
+	saberMoveName_t saberMove = LS_INVALID;
+	switch ( pm->ps->torsoAnim )
+	{
+	case BOTH_VS_ATR_S:
+		saberMove = LS_SWOOP_ATTACK_RIGHT;
+		break;
+	case BOTH_VS_ATL_S:
+		saberMove = LS_SWOOP_ATTACK_LEFT;
+		break;
+	case BOTH_VT_ATR_S:
+		saberMove = LS_TAUNTAUN_ATTACK_RIGHT;
+		break;
+	case BOTH_VT_ATL_S:
+		saberMove = LS_TAUNTAUN_ATTACK_LEFT;
+		break;
+	}
+	if ( saberMove != LS_INVALID )
+	{
+ 		if ( pm->ps->saberMove == saberMove )
+		{//already playing it
+			if ( !pm->ps->torsoAnimTimer )
+			{//anim was done, set it back to ready
+ 				PM_SetSaberMove( LS_READY );
+				pm->ps->saberMove = LS_READY;
+				pm->ps->weaponstate = WEAPON_IDLE;
+				if (pm->cmd.buttons&BUTTON_ATTACK)
+				{
+					if ( !pm->ps->weaponTime ) 
+					{
+	 					PM_SetSaberMove( saberMove );
+						pm->ps->weaponstate = WEAPON_FIRING;
+						pm->ps->weaponTime = pm->ps->torsoAnimTimer;
+					}
+				}
+			}
+		}
+		else if ( pm->ps->torsoAnimTimer 
+			&& !pm->ps->weaponTime ) 
+		{
+ 			PM_SetSaberMove( LS_READY );
+			pm->ps->saberMove = LS_READY;
+			pm->ps->weaponstate = WEAPON_IDLE;
+			PM_SetSaberMove( saberMove );
+			pm->ps->weaponstate = WEAPON_FIRING;
+			pm->ps->weaponTime = pm->ps->torsoAnimTimer;
+		}
+	}
+	pm->ps->saberBlocking = saberMoveData[pm->ps->saberMove].blocking;
+}
+
+//force the vehicle to turn and travel to its forced destination point
+void PM_VehForcedTurning( gentity_t *veh )
+{
+	gentity_t *dst = &g_entities[pm->ps->vehTurnaroundIndex];
+	float pitchD, yawD;
+	vec3_t dir;
+
+	if (!veh || !veh->m_pVehicle)
+	{
+		return;
+	}
+
+	if (!dst)
+	{ //can't find dest ent?
+		return;
+	}
+
+	pm->cmd.upmove = veh->m_pVehicle->m_ucmd.upmove = 127;
+	pm->cmd.forwardmove = veh->m_pVehicle->m_ucmd.forwardmove = 0;
+	pm->cmd.rightmove = veh->m_pVehicle->m_ucmd.rightmove = 0;
+
+	VectorSubtract(dst->s.origin, veh->currentOrigin, dir);
+	vectoangles(dir, dir);
+
+	yawD = AngleSubtract(pm->ps->viewangles[YAW], dir[YAW]);
+	pitchD = AngleSubtract(pm->ps->viewangles[PITCH], dir[PITCH]);
+
+	yawD *= 0.2f*pml.frametime;
+	pitchD *= 0.6f*pml.frametime;
+
+	pm->ps->viewangles[YAW] = AngleSubtract(pm->ps->viewangles[YAW], yawD);
+	pm->ps->viewangles[PITCH] = AngleSubtract(pm->ps->viewangles[PITCH], pitchD);
+
+	//PM_SetPMViewAngle(pm->ps, pm->ps->viewangles, &pm->cmd);
+	SetClientViewAngle(pm->gent, pm->ps->viewangles);
+}
+/*
+================
+Pmove
+
+Can be called by either the server or the client
+================
+*/
+void Pmove( pmove_t *pmove )
+{
+	Vehicle_t *pVeh = NULL;
+
+	pm = pmove;
+
+	// this counter lets us debug movement problems with a journal by setting a conditional breakpoint fot the previous frame
+	c_pmove++;
+
+	// clear results
+	pm->numtouch = 0;
+#ifndef _XBOX
+	pm->watertype = 0;
+	pm->waterlevel = 0;
+#endif
+
+	// Clear the blocked flag
+	//pm->ps->pm_flags &= ~PMF_BLOCKED;
+	pm->ps->pm_flags &= ~PMF_BUMPED;
+
+	// In certain situations, we may want to control which attack buttons are pressed and what kind of functionality
+	//	is attached to them
+	PM_AdjustAttackStates( pm );
+
+	// clear the respawned flag if attack and use are cleared
+	if ( pm->ps->stats[STAT_HEALTH] > 0 && 
+		!( pm->cmd.buttons & BUTTON_ATTACK ) ) 
+	{
+		pm->ps->pm_flags &= ~PMF_RESPAWNED;
+	}
+
+	// clear all pmove local vars
+	memset (&pml, 0, sizeof(pml));
+
+	// determine the time
+	pml.msec = pmove->cmd.serverTime - pm->ps->commandTime;
+	if ( pml.msec < 1 ) {
+		pml.msec = 1;
+	} else if ( pml.msec > 200 ) {
+		pml.msec = 200;
+	}
+	
+	pm->ps->commandTime = pmove->cmd.serverTime;
+
+	// save old org in case we get stuck
+	VectorCopy (pm->ps->origin, pml.previous_origin);
+
+	// save old velocity for crashlanding
+	VectorCopy (pm->ps->velocity, pml.previous_velocity);
+
+	pml.frametime = pml.msec * 0.001;
+	
+	if ( pm->ps->clientNum >= MAX_CLIENTS &&
+		pm->gent &&
+		pm->gent->client &&
+		pm->gent->client->NPC_class == CLASS_VEHICLE )
+	{ //we are a vehicle
+		pVeh = pm->gent->m_pVehicle;
+		assert( pVeh );
+		if ( pVeh )
+		{
+			pVeh->m_fTimeModifier = (pml.frametime*60.0f);//at 16.67ms (60fps), should be 1.0f
+		}
+	}
+	else if ( pm->gent && PM_RidingVehicle() )
+	{
+		if ( pm->ps->vehTurnaroundIndex 
+			&& pm->ps->vehTurnaroundTime > pm->cmd.serverTime )
+		{ //riding this vehicle, turn my view too
+			PM_VehForcedTurning( &g_entities[pm->gent->s.m_iVehicleNum] );
+		}
+	}
+
+	PM_SetSpecialMoveValues();
+
+	// update the viewangles
+	PM_UpdateViewAngles( pm->ps, &pm->cmd, pm->gent);
+
+	AngleVectors ( pm->ps->viewangles, pml.forward, pml.right, pml.up );
+
+	if ( pm->cmd.upmove < 10 ) {
+		// not holding jump
+		pm->ps->pm_flags &= ~PMF_JUMP_HELD;
+	}
+
+	// decide if backpedaling animations should be used
+	if ( pm->cmd.forwardmove < 0 ) {
+		pm->ps->pm_flags |= PMF_BACKWARDS_RUN;
+	} else if ( pm->cmd.forwardmove > 0 || ( pm->cmd.forwardmove == 0 && pm->cmd.rightmove ) ) {
+		pm->ps->pm_flags &= ~PMF_BACKWARDS_RUN;
+	}
+
+	if ( pm->ps->pm_type >= PM_DEAD ) {
+		pm->cmd.forwardmove = 0;
+		pm->cmd.rightmove = 0;
+		pm->cmd.upmove = 0;
+		if ( pm->ps->viewheight > -12 )
+		{//slowly sink view to ground
+			pm->ps->viewheight -= 1;
+		}
+	}
+
+	if ( pm->ps->pm_type == PM_SPECTATOR ) {
+		PM_CheckDuck ();
+		PM_FlyMove ();
+		PM_DropTimers ();
+		return;
+	}
+
+	if ( pm->ps->pm_type == PM_NOCLIP ) {
+		PM_NoclipMove ();
+		PM_DropTimers ();
+		return;
+	}
+
+	if (pm->ps->pm_type == PM_FREEZE) {
+		return;		// no movement at all
+	}
+
+	if ( pm->ps->pm_type == PM_INTERMISSION ) {
+		return;		// no movement at all
+	}
+
+	if ( pm->ps->pm_flags & PMF_SLOW_MO_FALL )
+	{//half grav
+		pm->ps->gravity *= 0.5;
+	}
+
+	// set watertype, and waterlevel
+#ifdef _XBOX
+	// if the client is the player do a normal water test
+	// if it's an npc add the client to the npc water test queue
+	// we don't want to update too many npcs in one frame
+	if(pm->ps->clientNum == 0)
+	{
+		PM_SetWaterLevelAtPoint( pm->ps->origin, &pm->waterlevel, &pm->watertype );
+	}
+	else
+	{
+		AddNPCToWaterUpdate(pm->ps->clientNum);
+	}
+#else
+	PM_SetWaterLevelAtPoint( pm->ps->origin, &pm->waterlevel, &pm->watertype );
+#endif
+
+	PM_SetWaterHeight();
+
+#ifdef _XBOX
+	if ( !(pm->watertype & CONTENTS_LADDER) )
+	{//Don't want to remember this for ladders, is only for waterlevel change events (sounds)
+
+		// if we're the player set the water test from the pmove
+		// otherwise set it from the entitity structure
+		if(pm->ps->clientNum == 0 )
+		{
+			pml.previous_waterlevel = pmove->waterlevel;
+		}
+		else
+		{
+			pml.previous_waterlevel = (g_entities + pm->ps->clientNum)->prev_waterlevel;
+		}
+	}
+#else
+	if ( !(pm->watertype & CONTENTS_LADDER) )
+	{//Don't want to remember this for ladders, is only for waterlevel change events (sounds)
+		pml.previous_waterlevel = pmove->waterlevel;
+	}
+#endif
+
+
+	waterForceJump = qfalse;
+	if ( pmove->waterlevel && pm->ps->clientNum )
+	{
+		if ( pm->ps->forceJumpZStart//force jumping
+			||(pm->gent&&pm->gent->NPC && level.time<pm->gent->NPC->jumpTime)) //TIMER_Done(pm->gent, "forceJumpChasing" )) )//force-jumping
+		{
+			waterForceJump = qtrue;
+		}
+	}
+
+	// set mins, maxs, and viewheight
+	PM_SetBounds();
+
+	if ( !Flying && !(pm->watertype & CONTENTS_LADDER) && pm->ps->pm_type != PM_DEAD )
+	{//NOTE: noclippers shouldn't jump or duck either, no?
+		PM_CheckDuck();
+	}
+
+	// set groundentity
+	PM_GroundTrace();
+	if ( Flying == FLY_HOVER )
+	{//never stick to the ground
+		PM_HoverTrace();
+	}
+
+	if ( pm->ps->pm_type == PM_DEAD ) {
+		PM_DeadMove ();
+	}
+
+	PM_DropTimers(); 
+
+	/*
+	if ( PM_RidingVehicle() )
+	{
+		PM_NoclipMove();
+	}
+	else */if ( pm->ps && ( (pm->ps->eFlags&EF_LOCKED_TO_WEAPON) 
+							|| (pm->ps->eFlags&EF_HELD_BY_RANCOR)
+							|| (pm->ps->eFlags&EF_HELD_BY_WAMPA)
+							|| (pm->ps->eFlags&EF_HELD_BY_SAND_CREATURE) ) )
+	{//in an emplaced gun
+		PM_NoclipMove();
+	}
+	else if ( Flying == FLY_NORMAL )//|| pm->ps->gravity <= 0 ) 
+	{
+		// flight powerup doesn't allow jump and has different friction
+		PM_FlyMove();
+	} 
+	else if ( Flying == FLY_VEHICLE )
+	{
+		PM_FlyVehicleMove();
+	}
+	else if ( pm->ps->pm_flags & PMF_TIME_WATERJUMP ) 
+	{
+		PM_WaterJumpMove();
+	} 
+	else if ( pm->waterlevel > 1 //in water
+			 &&((pm->ps->clientNum < MAX_CLIENTS||PM_ControlledByPlayer()) || !waterForceJump) )//player or NPC not force jumping
+	{//force-jumping NPCs should
+		// swimming or in ladder
+		PM_WaterMove();
+	}
+	else if (pm->gent && pm->gent->NPC && pm->gent->NPC->jumpTime!=0)
+	{
+		ucmd.forwardmove = 0;
+		ucmd.rightmove = 0;
+		ucmd.upmove = 0;
+		pm->ps->speed = 0;
+		VectorClear(pm->ps->moveDir);
+
+		PM_AirMove();
+	}
+	else if ( pml.walking ) 
+	{// walking on ground
+		vec3_t	oldOrg;
+
+		VectorCopy( pm->ps->origin, oldOrg );
+
+		PM_WalkMove();
+
+
+		float threshHold = 0.001f, movedDist = DistanceSquared( oldOrg, pm->ps->origin );
+		if ( PM_StandingAnim( pm->ps->legsAnim ) || pm->ps->legsAnim == BOTH_CROUCH1 )
+		{
+			threshHold = 0.005f;
+		}
+
+		if ( movedDist < threshHold )
+		{//didn't move, play no legs anim
+		//	pm->cmd.forwardmove = pm->cmd.rightmove = 0;
+		}
+	} 
+	else 
+	{
+		if ( pm->ps->gravity <= 0 )
+		{
+			PM_FlyMove();
+		}
+		else
+		{
+			// airborne
+			PM_AirMove();
+		}
+	}
+
+	//PM_Animate();
+
+	// If we didn't move at all, then why bother doing this again -MW.
+	if(!(VectorCompare(pm->ps->origin,pml.previous_origin)))
+	{
+		PM_GroundTrace();
+		if ( Flying == FLY_HOVER )
+		{//never stick to the ground
+			PM_HoverTrace();
+		}
+	}
+
+	if ( pm->ps->groundEntityNum != ENTITYNUM_NONE )
+	{//on ground
+		pm->ps->forceJumpZStart = 0;
+		pm->ps->jumpZStart = 0;
+		pm->ps->pm_flags &= ~PMF_JUMPING;
+		pm->ps->pm_flags &= ~PMF_TRIGGER_PUSHED;
+		pm->ps->pm_flags &= ~PMF_SLOW_MO_FALL;
+	}
+	
+	// If we didn't move at all, then why bother doing this again -MW.
+	// Note: ok, so long as we don't have water levels that change.
+	if(!(VectorCompare(pm->ps->origin,pml.previous_origin)))
+	{
+#ifdef _XBOX
+		// only do this on xbox if it's a player not an npc
+		if(pm->ps->clientNum == 0)
+		{
+			PM_SetWaterLevelAtPoint( pm->ps->origin, &pm->waterlevel, &pm->watertype );
+		}
+#else
+		PM_SetWaterLevelAtPoint( pm->ps->origin, &pm->waterlevel, &pm->watertype );
+#endif
+		PM_SetWaterHeight();
+	}
+
+//	PM_ForcePower(); sends event to client for client side fx, not used
+
+	// If we're a vehicle, do our special weapon function.
+	if ( pm->gent && pm->gent->client && pm->gent->client->NPC_class == CLASS_VEHICLE )
+	{
+		pVeh = pm->gent->m_pVehicle;
+
+		// Using vehicle weapon...
+		//if ( pm->cmd.weapon == WP_NONE )
+		{
+			//PM_Weapon();
+			//PM_AddEvent( EV_FIRE_WEAPON );
+			PM_VehicleWeapon();
+		}
+	}
+	// If we are riding a vehicle...
+	else if ( PM_RidingVehicle() )
+	{
+		if ( pm->cmd.buttons & BUTTON_ALT_ATTACK )
+		{// alt attack always does other stuff when riding a vehicle (turbo)
+		}
+		else if ( (pm->ps->eFlags&EF_NODRAW) )
+		{//inside a vehicle?  don't do any weapon stuff
+		}
+		else if ( pm->ps->weapon == WP_BLASTER//using blaster
+		 || pm->ps->weapon == WP_THERMAL//using thermal
+		 || pm->ps->weaponstate == WEAPON_DROPPING//changing weapon - dropping
+		 || pm->ps->weaponstate == WEAPON_RAISING//changing weapon - raising
+		 || (pm->cmd.weapon != pm->ps->weapon && PM_WeaponOkOnVehicle( pm->cmd.weapon )) )//FIXME: make this a vehicle call to see if this new weapon is valid for this vehicle
+		{//either weilding a weapon we can fire with normal weapon logic, or trying to change to a valid weapon
+			// call normal weapons code... should we override the normal fire anims with vehicle fire anims in here or in a subsequent call to VehicleWeapons or something?
+			//Maybe break PM_Weapon into PM_Weapon and PM_WeaponAnimate (then call our own PM_VehicleWeaponAnimate)?
+			PM_Weapon();
+		}
+		//BUT: now call Vehicle's weapon code, to handle lightsaber and (maybe) overriding weapon ready/firing anims?
+	}
+	// otherwise do the normal weapon function.
+	else
+	{
+		// weapons
+		PM_Weapon();
+	}
+	if ( pm->cmd.buttons & BUTTON_ATTACK )
+	{
+		pm->ps->pm_flags |= PMF_ATTACK_HELD;
+	}
+	else
+	{
+		pm->ps->pm_flags &= ~PMF_ATTACK_HELD;
+	}
+	if ( pm->cmd.buttons & BUTTON_ALT_ATTACK )
+	{
+		pm->ps->pm_flags |= PMF_ALT_ATTACK_HELD;
+	}
+	else
+	{
+		pm->ps->pm_flags &= ~PMF_ALT_ATTACK_HELD;
+	}
+	if ( pm->cmd.buttons & BUTTON_FORCE_FOCUS )
+	{
+		pm->ps->pm_flags |= PMF_FORCE_FOCUS_HELD;
+	}
+	else
+	{
+		pm->ps->pm_flags &= ~PMF_FORCE_FOCUS_HELD;
+	}
+
+	if ( pm->gent )//&& pm->gent->s.number == 0 )//player only?
+	{
+		// Use
+		PM_Use();
+	}
+
+	// Calculate the resulting speed of the last pmove
+	//-------------------------------------------------
+	if ( pm->gent )
+	{
+		pm->gent->resultspeed = ((Distance(pm->ps->origin, pm->gent->currentOrigin) / pml.msec) * 1000);
+		if (pm->gent->resultspeed>5.0f)
+		{
+			pm->gent->lastMoveTime = level.time;
+		}
+
+		// If Have Not Been Moving For A While, Stop
+		//-------------------------------------------
+		if (pml.walking && (level.time - pm->gent->lastMoveTime)>1000)
+		{
+			pm->cmd.forwardmove = pm->cmd.rightmove = 0;
+		}
+	}
+
+
+	// ANIMATION
+	//================================
+
+	// TEMPTEMPTEMPTEMPTEMPTEMPTEMPTEMPTEMPTEMPTEMPTEMPTEMPTEMPTEMP
+	if ( pm->gent && pm->ps && pm->ps->eFlags & EF_LOCKED_TO_WEAPON )
+	{
+		if ( pm->gent->owner && pm->gent->owner->e_UseFunc == useF_emplaced_gun_use )//ugly way to tell, but...
+		{//full body
+			PM_SetAnim(pm,SETANIM_BOTH,BOTH_GUNSIT1,SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD);//SETANIM_FLAG_NORMAL
+		}
+		else
+		{//stand (or could be overridden by strafe anims)
+			PM_SetAnim(pm,SETANIM_LEGS,BOTH_STAND1,SETANIM_FLAG_NORMAL);
+		}
+	}
+	else if ( pm->gent && pm->ps && (pm->ps->eFlags&EF_HELD_BY_RANCOR) )
+	{
+		PM_SetAnim(pm,SETANIM_LEGS,BOTH_SWIM_IDLE1,SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD);//SETANIM_FLAG_NORMAL
+	}
+	// If we are a vehicle, animate...
+	else if ( pVeh )
+	{
+		pVeh->m_pVehicleInfo->Animate( pVeh );
+	}
+	// If we're riding a vehicle, don't do anything!.
+	else if ( ( pVeh = PM_RidingVehicle() ) != 0 )
+	{
+		PM_CheckInVehicleSaberAttackAnim();
+	}
+	else // TEMPTEMPTEMPTEMPTEMPTEMPTEMPTEMPTEMPTEMPTEMPTEMPTEMP
+	{
+		// footstep events / legs animations
+		PM_Footsteps();
+	}
+	// torso animation
+	if ( !pVeh )
+	{//not riding a vehicle
+		PM_TorsoAnimation();
+	}
+
+	// entering / leaving water splashes
+	PM_WaterEvents();
+
+	// snap some parts of playerstate to save network bandwidth
+	// SnapVector( pm->ps->velocity );
+
+	if ( !pm->cmd.rightmove && !pm->cmd.forwardmove && pm->cmd.upmove <= 0 )
+	{
+		if ( VectorCompare( pm->ps->velocity, vec3_origin ) )
+		{
+			pm->ps->lastStationary = level.time;
+		}
+	}
+
+	if ( pm->ps->pm_flags & PMF_SLOW_MO_FALL )
+	{//half grav
+		pm->ps->gravity *= 2;
+	}
+}
\ No newline at end of file
diff --git a/code/game/bg_public.h b/code/game/bg_public.h
new file mode 100644
index 0000000..3d04738
--- /dev/null
+++ b/code/game/bg_public.h
@@ -0,0 +1,736 @@
+#ifndef __BG_PUBLIC_H__
+#define __BG_PUBLIC_H__
+// bg_public.h -- definitions shared by both the server game and client game modules
+#include "weapons.h"
+#include "g_items.h"
+#include "teams.h"
+#include "statindex.h"
+
+#define	DEFAULT_GRAVITY		800
+#define	GIB_HEALTH			-40
+#define	ARMOR_PROTECTION	0.40
+
+#define	MAX_ITEMS			128
+
+#define	RANK_TIED_FLAG		0x4000
+
+#define DEFAULT_SHOTGUN_SPREAD	700
+#define DEFAULT_SHOTGUN_COUNT	11
+
+#define	ITEM_RADIUS			15		// item sizes are needed for client side pickup detection
+
+//Player sizes
+extern float DEFAULT_MINS_0;
+extern float DEFAULT_MINS_1;
+extern float DEFAULT_MAXS_0;
+extern float DEFAULT_MAXS_1;
+extern float DEFAULT_PLAYER_RADIUS;
+#define DEFAULT_MINS_2		-24
+#define DEFAULT_MAXS_2		40// was 32, but too short for player
+#define CROUCH_MAXS_2		16
+
+#define ATST_MINS0			-40
+#define ATST_MINS1			-40
+#define ATST_MINS2			-24
+#define ATST_MAXS0			40
+#define ATST_MAXS1			40
+#define ATST_MAXS2			248
+
+//Player viewheights
+#define	STANDARD_VIEWHEIGHT_OFFSET -4
+//#define	RAVEN_VIEWHEIGHT_ADJ 2
+//#define	DEFAULT_VIEWHEIGHT	(26+RAVEN_VIEWHEIGHT_ADJ)
+//#define CROUCH_VIEWHEIGHT	12
+#define	DEAD_VIEWHEIGHT		-16
+//Player movement values
+#define	MIN_WALK_NORMAL		0.7		// can't walk on very steep slopes
+#define	JUMP_VELOCITY		225		// 270
+#define	STEPSIZE			18
+
+
+
+/*
+===================================================================================
+
+PMOVE MODULE
+
+The pmove code takes a player_state_t and a usercmd_t and generates a new player_state_t
+and some other output data.  Used for local prediction on the client game and true
+movement on the server game.
+===================================================================================
+*/
+
+typedef enum {
+	PM_NORMAL,		// can accelerate and turn
+	PM_NOCLIP,		// noclip movement
+	PM_SPECTATOR,	// still run into walls
+	PM_DEAD,		// no acceleration or turning, but free falling
+	PM_FREEZE,		// stuck in place with no control
+	PM_INTERMISSION	// no movement or status bar
+} pmtype_t;
+
+typedef enum {
+	WEAPON_READY, 
+	WEAPON_RAISING,
+	WEAPON_DROPPING,
+	WEAPON_FIRING,
+	WEAPON_CHARGING,
+	WEAPON_CHARGING_ALT,
+	WEAPON_IDLE, //lowered
+} weaponstate_t;
+
+// pmove->pm_flags
+#define	PMF_DUCKED			(1<<0)//1
+#define	PMF_JUMP_HELD		(1<<1)//2
+#define	PMF_JUMPING			(1<<2)//4		// yes, I really am in a jump -- Mike, you may want to come up with something better here since this is really a temp fix.
+#define	PMF_BACKWARDS_JUMP	(1<<3)//8		// go into backwards land
+#define	PMF_BACKWARDS_RUN	(1<<4)//16		// coast down to backwards run
+#define	PMF_TIME_LAND		(1<<5)//32		// pm_time is time before rejump
+#define	PMF_TIME_KNOCKBACK	(1<<6)//64		// pm_time is an air-accelerate only time
+#define	PMF_TIME_NOFRICTION	(1<<7)//128		// pm_time is a no-friction time
+#define	PMF_TIME_WATERJUMP	(1<<8)//256		// pm_time is waterjump
+#define	PMF_RESPAWNED		(1<<9)//512		// clear after attack and jump buttons come up
+#define	PMF_USEFORCE_HELD	(1<<10)//1024	// for debouncing the button
+#define PMF_JUMP_DUCKED		(1<<11)//2048	// viewheight changes in mid-air
+#define PMF_TRIGGER_PUSHED	(1<<12)//4096	// pushed by a trigger_push or other such thing - cannot force jump and will not take impact damage
+#define PMF_STUCK_TO_WALL	(1<<13)//8192	// grabbing a wall
+#define PMF_SLOW_MO_FALL	(1<<14)//16384	// Fall slower until hit ground
+#define	PMF_ATTACK_HELD		(1<<15)//32768	// Holding down the attack button
+#define	PMF_ALT_ATTACK_HELD	(1<<16)//65536	// Holding down the alt-attack button
+#define PMF_BUMPED			(1<<17)//131072	// Bumped into something
+#define PMF_FORCE_FOCUS_HELD	(1<<18)//262144	// Holding down the saberthrow/kick button
+#define PMF_FIX_MINS		(1<<19)//524288	// Mins raised for dual forward jump, fix them
+#define	PMF_ALL_TIMES	(PMF_TIME_WATERJUMP|PMF_TIME_LAND|PMF_TIME_KNOCKBACK|PMF_TIME_NOFRICTION)
+
+#if defined(_XBOX) && !defined(_TRACE_FUNCTOR_T_DEFINED_)
+// Function objects to replace the function pointers used for trace in pmove_t
+// We can't have default arguments on function pointers, but this allows us to
+// do the same thing with minimal impact elsewhere.
+struct Trace_Functor_t
+{
+	typedef void (*trace_func_t)(trace_t *, const vec3_t, const vec3_t, const vec3_t, const vec3_t,
+								 const int, const int, const EG2_Collision, const int);
+	trace_func_t trace_func;
+	void operator()( trace_t *results, const vec3_t start, const vec3_t mins, const vec3_t maxs, const vec3_t end, 
+						const int passEntityNum, const int contentMask, const EG2_Collision eG2TraceType = (EG2_Collision)0, const int useLod = 0 )
+		{ trace_func(results, start, mins, maxs, end, passEntityNum, contentMask, eG2TraceType, useLod); }
+	const Trace_Functor_t &operator=(trace_func_t traceRHS)
+	{
+		trace_func = traceRHS;
+		return *this;
+	}
+};
+
+// Always create this class exactly once
+#define _TRACE_FUNCTOR_T_DEFINED_
+#endif
+
+#define	MAXTOUCH	32
+typedef struct gentity_s gentity_t;
+typedef struct {
+	// state (in / out)
+	playerState_t	*ps;
+
+	// command (in)
+	usercmd_t	cmd;
+	int			tracemask;			// collide against these types of surfaces
+	int			debugLevel;			// if set, diagnostic output will be printed
+	qboolean	noFootsteps;		// if the game is setup for no footsteps by the server
+
+	// results (out)
+	int			numtouch;
+	int			touchents[MAXTOUCH];
+
+	int			useEvent;
+
+	vec3_t		mins, maxs;			// bounding box size
+
+	int			watertype;
+	int			waterlevel;
+
+	float		xyspeed;
+	gentity_s	*gent;				// Pointer to entity in g_entities[]
+
+	// callbacks to test the world
+	// these will be different functions during game and cgame
+#ifdef _XBOX
+	Trace_Functor_t	trace;
+#else
+	void		(*trace)( trace_t *results, const vec3_t start, const vec3_t mins, const vec3_t maxs, const vec3_t end, 
+						const int passEntityNum, const int contentMask, const EG2_Collision eG2TraceType = (EG2_Collision)0, const int useLod = 0 );
+#endif
+	int			(*pointcontents)( const vec3_t point, int passEntityNum );
+} pmove_t;
+
+// if a full pmove isn't done on the client, you can just update the angles
+void PM_UpdateViewAngles( playerState_t *ps, usercmd_t *cmd, gentity_t *gent );
+void Pmove( pmove_t *pmove );
+
+
+#define SETANIM_TORSO 1
+#define SETANIM_LEGS  2
+#define SETANIM_BOTH  (SETANIM_TORSO|SETANIM_LEGS)//3
+
+#define SETANIM_FLAG_NORMAL		0//Only set if timer is 0
+#define SETANIM_FLAG_OVERRIDE	1//Override previous
+#define SETANIM_FLAG_HOLD		2//Set the new timer
+#define SETANIM_FLAG_RESTART	4//Allow restarting the anim if playing the same one (weapon fires)
+#define SETANIM_FLAG_HOLDLESS	8//Set the new timer
+
+#define SETANIM_BLEND_DEFAULT	100
+
+void PM_SetAnim(pmove_t	*pm,int setAnimParts,int anim,int setAnimFlags, int blendTime=SETANIM_BLEND_DEFAULT);
+void PM_SetAnimFinal(int *torsoAnim,int *legsAnim,int type,int anim,int priority,int *torsoAnimTimer,int *legsAnimTimer,gentity_t *gent,int blendTime=SETANIM_BLEND_DEFAULT);
+
+//===================================================================================
+
+
+// player_state->persistant[] indexes
+// these fields are the only part of player_state that isn't
+// cleared on respawn
+//
+//  NOTE!!! Even though this is an enum, the array that contains these uses #define MAX_PERSISTANT 16 in q_shared.h,
+//		so be careful how many you add since it'll just overflow without telling you -slc
+//
+typedef enum {
+	PERS_SCORE,						// !!! MUST NOT CHANGE, SERVER AND GAME BOTH REFERENCE !!!
+	PERS_HITS,						// total points damage inflicted so damage beeps can sound on change
+	PERS_TEAM,				
+	PERS_SPAWN_COUNT,				// incremented every respawn
+//	PERS_REWARD_COUNT,				// incremented for each reward sound
+	PERS_ATTACKER,					// clientnum of last damage inflicter
+	PERS_KILLED,					// count of the number of times you died
+
+	PERS_ACCURACY_SHOTS,			// scoreboard - number of player shots
+	PERS_ACCURACY_HITS,				// scoreboard - number of player shots that hit an enemy
+	PERS_ENEMIES_KILLED,			// scoreboard - number of enemies player killed
+	PERS_TEAMMATES_KILLED			// scoreboard - number of teammates killed 
+} persEnum_t;
+
+
+// entityState_t->eFlags
+#define EF_HELD_BY_SAND_CREATURE 0x00000001	// In a sand creature's mouth
+#define	EF_HELD_BY_RANCOR		0x00000002	// Being held by Rancor
+#define	EF_TELEPORT_BIT			0x00000004	// toggled every time the origin abruptly changes
+#define	EF_SHADER_ANIM			0x00000008	// Animating shader (by s.frame)
+#define	EF_BOUNCE				0x00000010	// for missiles
+#define	EF_BOUNCE_HALF			0x00000020	// for missiles
+#define EF_MISSILE_STICK		0x00000040	// missiles that stick to the wall.
+#define	EF_NODRAW				0x00000080	// may have an event, but no model (unspawned items)
+#define	EF_FIRING				0x00000100	// for lightning gun
+#define EF_ALT_FIRING			0x00000200	// for alt-fires, mostly for lightning guns though
+#define	EF_VEH_BOARDING			0x00000400	// Whether a vehicle is being boarded or not.
+#define	EF_AUTO_SIZE			0x00000800	// CG_Ents will create the mins & max itself based on model bounds
+#define	EF_BOUNCE_SHRAPNEL		0x00001000	// special shrapnel flag
+#define EF_USE_ANGLEDELTA		0x00002000	// Not used.
+#define EF_ANIM_ALLFAST			0x00004000	// automatically cycle through all frames at 10hz
+#define EF_ANIM_ONCE			0x00008000	// cycle through all frames just once then stop
+#define EF_HELD_BY_WAMPA		0x00010000	// being held by the Wampa
+#define EF_PROX_TRIP			0x00020000	// Proximity trip mine has been activated
+#define EF_LOCKED_TO_WEAPON		0x00040000	// When we use an emplaced weapon, we turn this on to lock us to that weapon
+
+//rest not sent over net?
+
+#define EF_PERMANENT			0x00080000	// this entity is permanent and is never updated (sent only in the game state)
+#define EF_SPOTLIGHT			0x00100000	// Your lights are on...
+#define EF_PLANTED_CHARGE		0x00200000	// For detpack charge
+#define EF_POWERING_ROSH		0x00400000	// Only for Twins powering up Rosh
+#define EF_FORCE_VISIBLE		0x00800000	// Always visible with force sight
+#define EF_IN_ATST				0x01000000	// Driving an ATST
+#define EF_DISINTEGRATION		0x02000000	// Disruptor effect
+#define EF_LESS_ATTEN			0x04000000	// Use less sound attenuation (louder even when farther).
+#define EF_JETPACK_ACTIVE		0x08000000	// Not used
+#define EF_DISABLE_SHADER_ANIM	0x10000000	// Normally shader animation chugs along, but movers can force shader animation to be on frame 1
+#define EF_FORCE_GRIPPED		0x20000000	// Force gripped effect
+#define EF_FORCE_DRAINED		0x40000000	// Force drained effect
+#define EF_BLOCKED_MOVER		0x80000000	// for movers that are blocked - shared with previous
+
+typedef enum {
+	PW_NONE,
+	PW_QUAD,// This can go away
+	PW_BATTLESUIT,
+	PW_HASTE,// This can go away
+	PW_CLOAKED,
+	PW_UNCLOAKING,
+	PW_DISRUPTION,
+	PW_GALAK_SHIELD,
+//	PW_WEAPON_OVERCHARGE,
+	PW_SEEKER,
+	PW_SHOCKED,//electricity effect
+	PW_DRAINED,//drain effect
+	PW_DISINT_2,//ghost
+	PW_INVINCIBLE,
+	PW_FORCE_PUSH,
+	PW_FORCE_PUSH_RHAND,
+
+	PW_NUM_POWERUPS
+} powerup_t;
+
+#define PW_REMOVE_AT_DEATH ((1<<PW_QUAD)|(1<<PW_BATTLESUIT)|(1<<PW_HASTE)|(1<<PW_CLOAKED)|(1<<PW_UNCLOAKING)|(1<<PW_UNCLOAKING)|(1<<PW_GALAK_SHIELD)|(1<<PW_DISINT_2)|(1<<PW_INVINCIBLE)|(1<<PW_SEEKER))
+// entityState_t->event values
+// entity events are for effects that take place relative
+// to an existing entities origin.  Very network efficient.
+
+// two bits at the top of the entityState->event field
+// will be incremented with each change in the event so
+// that an identical event started twice in a row can
+// be distinguished.  And off the value with ~EV_EVENT_BITS
+// to retrieve the actual event number
+#define	EV_EVENT_BIT1		0x00000100
+#define	EV_EVENT_BIT2		0x00000200
+#define	EV_EVENT_BITS		(EV_EVENT_BIT1|EV_EVENT_BIT2)
+
+typedef enum {
+	EV_NONE,
+ 
+	EV_FOOTSTEP,
+	EV_FOOTSTEP_METAL,
+	EV_FOOTSPLASH,
+	EV_FOOTWADE,
+	EV_SWIM,
+
+	EV_STEP_4,
+	EV_STEP_8,
+	EV_STEP_12,
+	EV_STEP_16,
+
+	EV_FALL_SHORT,
+	EV_FALL_MEDIUM,
+	EV_FALL_FAR,
+
+	EV_JUMP,
+	EV_ROLL,
+	EV_WATER_TOUCH,	// foot touches
+	EV_WATER_LEAVE,	// foot leaves
+	EV_WATER_UNDER,	// head touches
+	EV_WATER_CLEAR,	// head leaves
+	EV_WATER_GURP1,	// need air 1
+	EV_WATER_GURP2,	// need air 2
+	EV_WATER_DROWN,	// drowned
+	EV_LAVA_TOUCH,	// foot touches
+	EV_LAVA_LEAVE,	// foot leaves
+	EV_LAVA_UNDER,	// head touches
+
+	EV_ITEM_PICKUP,
+
+	EV_NOAMMO,
+	EV_CHANGE_WEAPON,
+	EV_FIRE_WEAPON,
+	EV_ALT_FIRE,
+	EV_POWERUP_SEEKER_FIRE,
+	EV_POWERUP_BATTLESUIT,
+	EV_USE,
+
+	EV_REPLICATOR,
+
+	EV_BATTERIES_CHARGED,
+
+	EV_GRENADE_BOUNCE,		// eventParm will be the soundindex
+	EV_MISSILE_STICK,		// eventParm will be the soundindex
+
+	EV_BMODEL_SOUND,
+	EV_GENERAL_SOUND,
+	EV_GLOBAL_SOUND,		// no attenuation
+
+#ifdef _IMMERSION
+	EV_ENTITY_FORCE,
+	EV_AREA_FORCE,
+	EV_GLOBAL_FORCE,
+	EV_FORCE_STOP,
+#endif // _IMMERSION
+	EV_PLAY_EFFECT,
+	EV_PLAY_MUZZLE_EFFECT,
+	EV_STOP_EFFECT,
+
+	EV_TARGET_BEAM_DRAW,
+
+	EV_DISRUPTOR_MAIN_SHOT,
+	EV_DISRUPTOR_SNIPER_SHOT,
+	EV_DISRUPTOR_SNIPER_MISS,
+
+	EV_DEMP2_ALT_IMPACT,
+//NEW for JKA weapons:
+	EV_CONC_ALT_SHOT,
+	EV_CONC_ALT_MISS,
+//END JKA weapons
+	EV_PAIN,
+	EV_DEATH1,
+	EV_DEATH2,
+	EV_DEATH3,
+
+	EV_MISSILE_HIT,
+	EV_MISSILE_MISS,
+
+	EV_DISINTEGRATION,
+
+	EV_ANGER1,	//Say when acquire an enemy when didn't have one before
+	EV_ANGER2,
+	EV_ANGER3,
+
+	EV_VICTORY1,	//Say when killed an enemy
+	EV_VICTORY2,
+	EV_VICTORY3,
+
+	EV_CONFUSE1,	//Say when confused
+	EV_CONFUSE2,
+	EV_CONFUSE3,
+
+	EV_PUSHED1,		//Say when pushed
+	EV_PUSHED2,
+	EV_PUSHED3,
+
+	EV_CHOKE1,		//Say when choking
+	EV_CHOKE2,
+	EV_CHOKE3,
+
+	EV_FFWARN,		//ffire founds
+	EV_FFTURN,
+	//extra sounds for ST
+	EV_CHASE1,
+	EV_CHASE2,
+	EV_CHASE3,
+	EV_COVER1,
+	EV_COVER2,
+	EV_COVER3,
+	EV_COVER4,
+	EV_COVER5,
+	EV_DETECTED1,
+	EV_DETECTED2,
+	EV_DETECTED3,
+	EV_DETECTED4,
+	EV_DETECTED5,
+	EV_LOST1,
+	EV_OUTFLANK1,
+	EV_OUTFLANK2,
+	EV_ESCAPING1,
+	EV_ESCAPING2,
+	EV_ESCAPING3,
+	EV_GIVEUP1,
+	EV_GIVEUP2,
+	EV_GIVEUP3,
+	EV_GIVEUP4,
+	EV_LOOK1,
+	EV_LOOK2,
+	EV_SIGHT1,
+	EV_SIGHT2,
+	EV_SIGHT3,
+	EV_SOUND1,
+	EV_SOUND2,
+	EV_SOUND3,
+	EV_SUSPICIOUS1,
+	EV_SUSPICIOUS2,
+	EV_SUSPICIOUS3,
+	EV_SUSPICIOUS4,
+	EV_SUSPICIOUS5,
+	//extra sounds for Jedi
+	EV_COMBAT1,
+	EV_COMBAT2,
+	EV_COMBAT3,
+	EV_JDETECTED1,
+	EV_JDETECTED2,
+	EV_JDETECTED3,
+	EV_TAUNT1,
+	EV_TAUNT2,
+	EV_TAUNT3,
+	EV_JCHASE1,
+	EV_JCHASE2,
+	EV_JCHASE3,
+	EV_JLOST1,
+	EV_JLOST2,
+	EV_JLOST3,
+	EV_DEFLECT1,
+	EV_DEFLECT2,
+	EV_DEFLECT3,
+	EV_GLOAT1,
+	EV_GLOAT2,
+	EV_GLOAT3,
+	EV_PUSHFAIL,
+
+	EV_USE_ITEM,
+
+	EV_USE_INV_BINOCULARS,
+	EV_USE_INV_BACTA,
+	EV_USE_INV_SEEKER,
+	EV_USE_INV_LIGHTAMP_GOGGLES,
+	EV_USE_INV_SENTRY,
+
+	EV_USE_FORCE,
+
+	EV_DRUGGED,		// hit by an interrogator
+
+	EV_DEBUG_LINE,
+	EV_KOTHOS_BEAM,
+
+
+} entity_event_t;
+
+#pragma pack(push, 1)
+typedef struct animation_s {
+	unsigned short		firstFrame;
+	unsigned short		numFrames;
+	short			frameLerp;			// msec between frames	
+	//initial lerp is abs(frameLerp)
+	signed char		loopFrames;			// 0 to numFrames, -1 = no loop
+	unsigned char	glaIndex;			
+} animation_t;
+#pragma pack(pop)
+
+#ifdef _XBOX
+// Feel free to re-increase this if necessary, worst case right now is vjun3 -> 9
+#define MAX_ANIM_FILES	10
+#else
+#define MAX_ANIM_FILES	16
+#endif
+#define MAX_ANIM_EVENTS 300
+
+//size of Anim eventData array...
+#define MAX_RANDOM_ANIM_SOUNDS		8
+#define	AED_ARRAY_SIZE				(MAX_RANDOM_ANIM_SOUNDS+3)
+//indices for AEV_SOUND data
+#define	AED_SOUNDINDEX_START		0
+#define	AED_SOUNDINDEX_END			(MAX_RANDOM_ANIM_SOUNDS-1)
+#define	AED_SOUND_NUMRANDOMSNDS		(MAX_RANDOM_ANIM_SOUNDS)
+#define	AED_SOUND_PROBABILITY		(MAX_RANDOM_ANIM_SOUNDS+1)
+//indices for AEV_SOUNDCHAN data
+#define	AED_SOUNDCHANNEL			(MAX_RANDOM_ANIM_SOUNDS+2)
+//indices for AEV_FOOTSTEP data
+#define	AED_FOOTSTEP_TYPE			0
+#define	AED_FOOTSTEP_PROBABILITY	1
+//indices for AEV_EFFECT data
+#define	AED_EFFECTINDEX				0
+#define	AED_BOLTINDEX				1
+#define	AED_EFFECT_PROBABILITY		2
+#define	AED_MODELINDEX				3
+//indices for AEV_FIRE data
+#define	AED_FIRE_ALT				0
+#define	AED_FIRE_PROBABILITY		1
+//indices for AEV_MOVE data
+#define	AED_MOVE_FWD				0
+#define	AED_MOVE_RT					1
+#define	AED_MOVE_UP					2
+
+typedef enum
+{//NOTENOTE:  Be sure to update animEventTypeTable and ParseAnimationEvtBlock(...) if you change this enum list!
+	AEV_NONE,
+	AEV_SOUND,		//# animID AEV_SOUND framenum soundpath randomlow randomhi chancetoplay
+	AEV_FOOTSTEP,	//# animID AEV_FOOTSTEP framenum footstepType chancetoplay
+	AEV_EFFECT,		//# animID AEV_EFFECT framenum effectpath boltName chancetoplay
+	AEV_FIRE,		//# animID AEV_FIRE framenum altfire chancetofire
+	AEV_MOVE,		//# animID AEV_MOVE framenum forwardpush rightpush uppush
+	AEV_SOUNDCHAN,  //# animID AEV_SOUNDCHAN framenum CHANNEL soundpath randomlow randomhi chancetoplay 
+	AEV_NUM_AEV
+} animEventType_t;
+
+#ifdef _XBOX
+#pragma pack(push, 1)
+#endif
+typedef struct animevent_s 
+{
+	animEventType_t	eventType;
+	signed short	modelOnly;			//event is specific to a modelname to skeleton
+	unsigned short	glaIndex;
+	unsigned short	keyFrame;			//Frame to play event on
+	signed short	eventData[AED_ARRAY_SIZE];	//Unique IDs, can be soundIndex of sound file to play OR effect index or footstep type, etc.
+	char			*stringData;		//we allow storage of one string, temporarily (in case we have to look up an index later, then make sure to set stringData to NULL so we only do the look-up once)
+} animevent_t;
+#ifdef _XBOX
+#pragma pack(pop)
+#endif
+
+typedef enum
+{
+	FOOTSTEP_R,
+	FOOTSTEP_L,
+	FOOTSTEP_HEAVY_R,
+	FOOTSTEP_HEAVY_L,
+	NUM_FOOTSTEP_TYPES
+} footstepType_t;
+
+// means of death
+typedef enum {
+
+	MOD_UNKNOWN,
+
+// weapons
+	MOD_SABER,
+	MOD_BRYAR,
+	MOD_BRYAR_ALT,
+	MOD_BLASTER,
+	MOD_BLASTER_ALT,
+	MOD_DISRUPTOR,
+	MOD_SNIPER,
+	MOD_BOWCASTER,
+	MOD_BOWCASTER_ALT,
+	MOD_REPEATER,
+	MOD_REPEATER_ALT,
+	MOD_DEMP2,
+	MOD_DEMP2_ALT,
+	MOD_FLECHETTE,
+	MOD_FLECHETTE_ALT,
+	MOD_ROCKET,
+	MOD_ROCKET_ALT,
+//NEW for JKA weapons:
+	MOD_CONC,
+	MOD_CONC_ALT,
+//END JKA weapons.
+	MOD_THERMAL,
+	MOD_THERMAL_ALT,
+	MOD_DETPACK,
+	MOD_LASERTRIP,
+	MOD_LASERTRIP_ALT,
+	MOD_MELEE,
+	MOD_SEEKER,
+	MOD_FORCE_GRIP,
+	MOD_FORCE_LIGHTNING,
+	MOD_FORCE_DRAIN,
+	MOD_EMPLACED,
+
+// world / generic
+	MOD_ELECTROCUTE,
+	MOD_EXPLOSIVE,
+	MOD_EXPLOSIVE_SPLASH,
+	MOD_KNOCKOUT,
+	MOD_ENERGY,
+	MOD_ENERGY_SPLASH,
+	MOD_WATER,
+	MOD_SLIME,
+	MOD_LAVA,
+	MOD_CRUSH,
+	MOD_IMPACT,
+	MOD_FALLING,
+	MOD_SUICIDE,
+	MOD_TRIGGER_HURT,
+	MOD_GAS,
+
+	NUM_MODS,
+
+} meansOfDeath_t;
+
+
+//---------------------------------------------------------
+
+// gitem_t->type
+typedef enum 
+{
+	IT_BAD,
+	IT_WEAPON,
+	IT_AMMO,
+	IT_ARMOR,
+	IT_HEALTH,
+	IT_HOLDABLE,
+	IT_BATTERY,
+	IT_HOLOCRON,
+							
+} itemType_t;
+
+
+
+typedef struct gitem_s {
+	char		*classname;	// spawning name
+	char		*pickup_sound;
+	char		*world_model;
+
+	char		*icon;
+
+	int			quantity;		// for ammo how much, or duration of powerup
+	itemType_t  giType;			// IT_* flags
+
+	int			giTag;
+
+	char		*precaches;		// string of all models and images this item will use
+	char		*sounds;		// string of all sounds this item will use
+	vec3_t		mins;			// Bbox
+	vec3_t		maxs;			// Bbox
+#ifdef _IMMERSION
+	char		*pickup_force;
+	char		*forces;
+#endif // _IMMERSION
+} gitem_t;
+
+// included in both the game dll and the client
+extern	gitem_t	bg_itemlist[];
+extern	const int		bg_numItems;
+
+
+//==============================================================================
+
+/*
+typedef struct ginfoitem_s 
+{
+	char				*infoString;// Text message
+	vec3_t				color;		// Text color
+
+} ginfoitem_t;
+*/
+
+//==============================================================================
+
+extern weaponData_t weaponData[];
+
+//==============================================================================
+extern ammoData_t ammoData[];
+
+//==============================================================================
+
+gitem_t	*FindItem( const char *className );
+gitem_t	*FindItemForWeapon( weapon_t weapon );
+gitem_t	*FindItemForInventory( int inv );
+
+#define	ITEM_INDEX(x) ((x)-bg_itemlist)
+
+qboolean	BG_CanItemBeGrabbed( const entityState_t *ent, const playerState_t *ps );
+
+
+// content masks
+#define	MASK_ALL				(-1)
+#define	MASK_SOLID				(CONTENTS_SOLID|CONTENTS_TERRAIN)
+#define	MASK_PLAYERSOLID		(CONTENTS_SOLID|CONTENTS_PLAYERCLIP|CONTENTS_BODY|CONTENTS_TERRAIN)
+#define	MASK_NPCSOLID			(CONTENTS_SOLID|CONTENTS_MONSTERCLIP|CONTENTS_BODY|CONTENTS_TERRAIN)
+#define	MASK_DEADSOLID			(CONTENTS_SOLID|CONTENTS_PLAYERCLIP|CONTENTS_TERRAIN)
+#define	MASK_WATER				(CONTENTS_WATER|CONTENTS_LAVA|CONTENTS_SLIME)
+#define	MASK_OPAQUE				(CONTENTS_OPAQUE|CONTENTS_SLIME|CONTENTS_LAVA)//was CONTENTS_SOLID, not CONTENTS_OPAQUE...?
+/*
+Ghoul2 Insert Start
+*/
+#define	MASK_SHOT				(CONTENTS_SOLID|CONTENTS_BODY|CONTENTS_CORPSE|CONTENTS_SHOTCLIP|CONTENTS_TERRAIN)
+/*
+Ghoul2 Insert End
+*/
+
+//
+// entityState_t->eType
+//
+typedef enum {
+	ET_GENERAL,
+	ET_PLAYER,
+	ET_ITEM,
+	ET_MISSILE,
+	ET_MOVER,
+	ET_BEAM,
+	ET_PORTAL,
+	ET_SPEAKER,
+	ET_PUSH_TRIGGER,
+	ET_TELEPORT_TRIGGER,
+	ET_INVISIBLE,
+	ET_THINKER,
+	ET_CLOUD, // dumb
+	ET_TERRAIN,
+
+	ET_EVENTS				// any of the EV_* events can be added freestanding
+							// by setting eType to ET_EVENTS + eventNum
+							// this avoids having to set eFlags and eventNum
+} entityType_t;
+
+
+
+void	EvaluateTrajectory( const trajectory_t *tr, int atTime, vec3_t result );
+void	EvaluateTrajectoryDelta( const trajectory_t *tr, int atTime, vec3_t result );
+
+void AddEventToPlayerstate( int newEvent, int eventParm, playerState_t *ps );
+int	CurrentPlayerstateEvent( playerState_t *ps );
+
+void PlayerStateToEntityState( playerState_t *ps, entityState_t *s );
+
+qboolean	BG_PlayerTouchesItem( playerState_t *ps, entityState_t *item, int atTime );
+
+#endif//#ifndef __BG_PUBLIC_H__
\ No newline at end of file
diff --git a/code/game/bg_slidemove.cpp b/code/game/bg_slidemove.cpp
new file mode 100644
index 0000000..2b9a3f9
--- /dev/null
+++ b/code/game/bg_slidemove.cpp
@@ -0,0 +1,573 @@
+// this include must remain at the top of every bg_xxxx CPP file
+#include "common_headers.h"
+
+#include "q_shared.h"
+#include "bg_public.h"
+#include "bg_local.h"
+#include "g_vehicles.h"
+
+extern qboolean PM_ClientImpact( trace_t *trace, qboolean damageSelf );
+extern qboolean PM_ControlledByPlayer( void );
+extern qboolean PM_InReboundHold( int anim );
+extern cvar_t *g_stepSlideFix;
+
+/*
+
+input: origin, velocity, bounds, groundPlane, trace function
+
+output: origin, velocity, impacts, stairup boolean
+
+*/
+
+/*
+==================
+PM_SlideMove
+
+Returns qtrue if the velocity was clipped in some way
+==================
+*/
+#define	MAX_CLIP_PLANES	5
+extern qboolean PM_GroundSlideOkay( float zNormal );
+extern qboolean PM_InSpecialJump( int anim );
+qboolean	PM_SlideMove( float gravMod ) {
+	int			bumpcount, numbumps;
+	vec3_t		dir;
+	float		d;
+	int			numplanes;
+	vec3_t		normal, planes[MAX_CLIP_PLANES];
+	vec3_t		primal_velocity;
+	vec3_t		clipVelocity;
+	int			i, j, k;
+	trace_t	trace;
+	vec3_t		end;
+	float		time_left;
+	float		into;
+	vec3_t		endVelocity;
+	vec3_t		endClipVelocity;
+	qboolean	damageSelf = qtrue;
+	int			slideMoveContents = pm->tracemask;
+
+	if ( pm->ps->clientNum >= MAX_CLIENTS
+		&& !PM_ControlledByPlayer() )
+	{//a non-player client, not an NPC under player control
+		if ( pml.walking //walking on the ground
+			|| (pm->ps->groundEntityNum != ENTITYNUM_NONE //in air
+				&& PM_InSpecialJump( pm->ps->legsAnim )//in a special jump
+				&& !(pm->ps->eFlags&EF_FORCE_GRIPPED)//not being gripped
+				&& !(pm->ps->pm_flags&PMF_TIME_KNOCKBACK)
+				&& pm->gent
+				&& pm->gent->forcePushTime < level.time) )//not being pushed
+		{//
+			// If we're a vehicle, ignore this if we're being driven
+			if ( !pm->gent //not an game ent
+				|| !pm->gent->client //not a client
+				|| pm->gent->client->NPC_class != CLASS_VEHICLE//not a vehicle
+				|| !pm->gent->m_pVehicle //no vehicle
+				|| !pm->gent->m_pVehicle->m_pPilot//no pilot
+				|| pm->gent->m_pVehicle->m_pPilot->s.number >= MAX_CLIENTS )//pilot is not the player
+			{//then treat do not enter brushes as SOLID
+				slideMoveContents |= CONTENTS_BOTCLIP;
+			}
+		}
+	}
+	
+	numbumps = 4;
+
+	VectorCopy (pm->ps->velocity, primal_velocity);
+
+	if ( gravMod ) 
+	{
+		VectorCopy( pm->ps->velocity, endVelocity );
+		if ( !(pm->ps->eFlags&EF_FORCE_GRIPPED) && !(pm->ps->eFlags&EF_FORCE_DRAINED) )
+		{
+			endVelocity[2] -= pm->ps->gravity * pml.frametime * gravMod;
+		}
+		pm->ps->velocity[2] = ( pm->ps->velocity[2] + endVelocity[2] ) * 0.5;
+		primal_velocity[2] = endVelocity[2];
+		if ( pml.groundPlane ) 
+		{
+			if ( PM_GroundSlideOkay( pml.groundTrace.plane.normal[2] ) )
+			{// slide along the ground plane
+				PM_ClipVelocity( pm->ps->velocity, pml.groundTrace.plane.normal, 
+					pm->ps->velocity, OVERCLIP );
+			}
+		}
+	}
+
+	time_left = pml.frametime;
+
+	// never turn against the ground plane
+	if ( pml.groundPlane ) 
+	{
+		numplanes = 1;
+		VectorCopy( pml.groundTrace.plane.normal, planes[0] );
+		if ( !PM_GroundSlideOkay( planes[0][2] ) )
+		{
+			planes[0][2] = 0;
+			VectorNormalize( planes[0] );
+		}
+	} 
+	else 
+	{
+		numplanes = 0;
+	}
+
+	// never turn against original velocity
+	VectorNormalize2( pm->ps->velocity, planes[numplanes] );
+	numplanes++;
+
+	for ( bumpcount=0 ; bumpcount < numbumps ; bumpcount++ ) {
+
+		// calculate position we are trying to move to
+		VectorMA( pm->ps->origin, time_left, pm->ps->velocity, end );
+
+		// see if we can make it there
+		pm->trace ( &trace, pm->ps->origin, pm->mins, pm->maxs, end, pm->ps->clientNum, slideMoveContents );
+		if ( (trace.contents&CONTENTS_BOTCLIP)
+			&& (slideMoveContents&CONTENTS_BOTCLIP) )
+		{//hit a do not enter brush
+			if ( trace.allsolid || trace.startsolid  )//inside the botclip
+			{//crap, we're in a do not enter brush, take it out for the remainder of the traces and re-trace this one right now without it
+				slideMoveContents &= ~CONTENTS_BOTCLIP;
+				pm->trace ( &trace, pm->ps->origin, pm->mins, pm->maxs, end, pm->ps->clientNum, slideMoveContents );
+			}
+			else if ( trace.plane.normal[2] > 0.0f )
+			{//on top of a do not enter brush, it, just redo this one trace without it
+				pm->trace ( &trace, pm->ps->origin, pm->mins, pm->maxs, end, pm->ps->clientNum, (slideMoveContents&~CONTENTS_BOTCLIP) );
+			}
+		}
+
+		if ( trace.allsolid ) 
+		{// entity is completely trapped in another solid
+			pm->ps->velocity[2] = 0;	// don't build up falling damage, but allow sideways acceleration
+			return qtrue;
+		}
+
+		if ( trace.fraction > 0 ) 
+		{// actually covered some distance
+			VectorCopy( trace.endpos, pm->ps->origin );
+		}
+
+		if ( trace.fraction == 1 ) 
+		{
+			 break;		// moved the entire distance
+		}
+
+
+
+		// save entity for contact
+		PM_AddTouchEnt( trace.entityNum );
+
+		//Hit it
+		if ( trace.surfaceFlags&SURF_NODAMAGE )
+		{
+			damageSelf = qfalse;
+		}
+		else if ( trace.entityNum == ENTITYNUM_WORLD && trace.plane.normal[2] > 0.5f )
+		{//if we land on the ground, let falling damage do it's thing itself, otherwise do impact damage
+			damageSelf = qfalse;
+		}
+		else
+		{
+			damageSelf = qtrue;
+		}
+
+		if ( PM_ClientImpact( &trace, damageSelf ) )
+		{
+			continue;
+		}
+
+		if (pm->gent->client && 
+			pm->gent->client->NPC_class == CLASS_VEHICLE &&
+			trace.plane.normal[2]<pm->gent->m_pVehicle->m_pVehicleInfo->maxSlope
+			)
+		{
+			pm->ps->pm_flags |= PMF_BUMPED;
+		}
+
+		time_left -= time_left * trace.fraction;
+
+		if ( numplanes >= MAX_CLIP_PLANES ) 
+		{// this shouldn't really happen
+			VectorClear( pm->ps->velocity );
+			return qtrue;
+		}
+
+		VectorCopy( trace.plane.normal, normal );
+
+ 		if ( !PM_GroundSlideOkay( normal[2] ) )
+		{//wall-running
+			//never push up off a sloped wall
+			normal[2] = 0;
+			VectorNormalize( normal );
+		}
+
+		//
+		// if this is the same plane we hit before, nudge velocity
+		// out along it, which fixes some epsilon issues with
+		// non-axial planes
+		//
+		if ( !(pm->ps->pm_flags&PMF_STUCK_TO_WALL) )
+		{//no sliding if stuck to wall!
+			for ( i = 0 ; i < numplanes ; i++ ) {
+				if ( DotProduct( normal, planes[i] ) > 0.99 ) {
+					VectorAdd( normal, pm->ps->velocity, pm->ps->velocity );
+					break;
+				}
+			}
+			if ( i < numplanes ) {
+				continue;
+			}
+		}
+		VectorCopy( normal, planes[numplanes] );
+		numplanes++;
+
+		//
+		// modify velocity so it parallels all of the clip planes
+		//
+
+		// find a plane that it enters
+		for ( i = 0 ; i < numplanes ; i++ ) {
+			into = DotProduct( pm->ps->velocity, planes[i] );
+			if ( into >= 0.1 ) {
+				continue;		// move doesn't interact with the plane
+			}
+
+			// see how hard we are hitting things
+			if ( -into > pml.impactSpeed ) {
+				pml.impactSpeed = -into;
+			}
+
+			// slide along the plane
+			PM_ClipVelocity (pm->ps->velocity, planes[i], clipVelocity, OVERCLIP );
+
+			// slide along the plane
+			PM_ClipVelocity (endVelocity, planes[i], endClipVelocity, OVERCLIP );
+
+			// see if there is a second plane that the new move enters
+			for ( j = 0 ; j < numplanes ; j++ ) {
+				if ( j == i ) {
+					continue;
+				}
+				if ( DotProduct( clipVelocity, planes[j] ) >= 0.1 ) {
+					continue;		// move doesn't interact with the plane
+				}
+
+				// try clipping the move to the plane
+				PM_ClipVelocity( clipVelocity, planes[j], clipVelocity, OVERCLIP );
+				PM_ClipVelocity( endClipVelocity, planes[j], endClipVelocity, OVERCLIP );
+
+				// see if it goes back into the first clip plane
+				if ( DotProduct( clipVelocity, planes[i] ) >= 0 ) {
+					continue;
+				}
+
+				// slide the original velocity along the crease
+				CrossProduct (planes[i], planes[j], dir);
+				VectorNormalize( dir );
+				d = DotProduct( dir, pm->ps->velocity );
+				VectorScale( dir, d, clipVelocity );
+
+				CrossProduct (planes[i], planes[j], dir);
+				VectorNormalize( dir );
+				d = DotProduct( dir, endVelocity );
+				VectorScale( dir, d, endClipVelocity );
+
+				// see if there is a third plane the the new move enters
+				for ( k = 0 ; k < numplanes ; k++ ) {
+					if ( k == i || k == j ) {
+						continue;
+					}
+					if ( DotProduct( clipVelocity, planes[k] ) >= 0.1 ) {
+						continue;		// move doesn't interact with the plane
+					}
+
+					// stop dead at a triple plane interaction
+					VectorClear( pm->ps->velocity );
+					return qtrue;
+				}
+			}
+
+			// if we have fixed all interactions, try another move
+			VectorCopy( clipVelocity, pm->ps->velocity );
+			VectorCopy( endClipVelocity, endVelocity );
+			break;
+		}
+	}
+
+	if ( gravMod ) {
+		VectorCopy( endVelocity, pm->ps->velocity );
+	}
+
+	// don't change velocity if in a timer (FIXME: is this correct?)
+	if ( pm->ps->pm_time ) {
+		VectorCopy( primal_velocity, pm->ps->velocity );
+	}
+
+	return ( bumpcount != 0 );
+}
+
+/*
+==================
+PM_StepSlideMove
+
+==================
+*/
+void PM_StepSlideMove( float gravMod ) 
+{
+	vec3_t		start_o, start_v;
+	vec3_t		down_o, down_v;
+	vec3_t		slideMove, stepUpMove;
+	trace_t		trace;
+	vec3_t		up, down;
+	qboolean	cantStepUpFwd, isGiant = qfalse;;
+	int			stepSize = STEPSIZE;
+
+	VectorCopy (pm->ps->origin, start_o);
+	VectorCopy (pm->ps->velocity, start_v);
+
+	if ( PM_InReboundHold( pm->ps->legsAnim ) )
+	{
+		gravMod = 0.0f;
+	}
+
+	if ( PM_SlideMove( gravMod ) == 0 ) {
+		return;		// we got exactly where we wanted to go first try	
+	}//else Bumped into something, see if we can step over it
+
+	if ( pm->gent && pm->gent->client && pm->gent->client->NPC_class == CLASS_VEHICLE && pm->gent->m_pVehicle->m_pVehicleInfo->hoverHeight > 0 )
+	{//Hovering vehicles don't do steps
+		//FIXME: maybe make hovering vehicles go up steps, but not down them?
+		return;
+	}
+
+	if ( pm->gent 
+		&& pm->gent->client
+		&& (pm->gent->client->NPC_class == CLASS_ATST||pm->gent->client->NPC_class == CLASS_RANCOR) )
+	{
+		isGiant = qtrue;
+		if ( pm->gent->client->NPC_class == CLASS_RANCOR )
+		{
+			if ( (pm->gent->spawnflags&1) )
+			{
+				stepSize = 64;//hack for Mutant Rancor stepping
+			}
+			else
+			{
+				stepSize = 48;//hack for Rancor stepping
+			}
+		}
+		else
+		{
+			stepSize = 70;//hack for AT-ST stepping, slightly taller than a standing stormtrooper
+		}
+	}
+	else if ( pm->maxs[2] <= 0 )
+	{//short little guys can't go up steps... FIXME: just make this a flag for certain NPCs- especially ones that roll?
+		stepSize = 4;
+	}
+
+	//Q3Final addition...
+	VectorCopy(start_o, down);
+	down[2] -= stepSize;
+	pm->trace (&trace, start_o, pm->mins, pm->maxs, down, pm->ps->clientNum, pm->tracemask);
+	VectorSet(up, 0, 0, 1);
+	// never step up when you still have up velocity
+	if ( pm->ps->velocity[2] > 0 && (trace.fraction == 1.0 ||
+			DotProduct(trace.plane.normal, up) < 0.7)) {
+		return;
+	}
+
+	if ( !pm->ps->velocity[0] && !pm->ps->velocity[1] ) 
+	{//All our velocity was cancelled sliding
+		return;
+	}
+
+	VectorCopy (pm->ps->origin, down_o);
+	VectorCopy (pm->ps->velocity, down_v);
+
+	VectorCopy (start_o, up);
+	up[2] += stepSize;
+
+	// test the player position if they were a stepheight higher
+
+	pm->trace (&trace, start_o, pm->mins, pm->maxs, up, pm->ps->clientNum, pm->tracemask);
+	if ( trace.allsolid || trace.startsolid || trace.fraction == 0) {
+		if ( pm->debugLevel ) {
+			Com_Printf("%i:bend can't step\n", c_pmove);
+		}
+		return;		// can't step up
+	}
+
+	if ( pm->debugLevel )
+	{
+		G_DebugLine(start_o,trace.endpos,2000,0xffffff,qtrue); 
+	}
+
+//===Another slidemove forward================================================================================
+	// try slidemove from this position
+	VectorCopy( trace.endpos, pm->ps->origin );
+	VectorCopy( start_v, pm->ps->velocity );
+	cantStepUpFwd = PM_SlideMove( gravMod ); 
+//===Another slidemove forward================================================================================
+
+	if ( pm->debugLevel )
+	{
+		G_DebugLine(trace.endpos,pm->ps->origin,2000,0xffffff,qtrue);
+	}
+	//compare the initial slidemove and this slidemove from a step up position
+	VectorSubtract( down_o, start_o, slideMove );
+	VectorSubtract( trace.endpos, pm->ps->origin, stepUpMove );
+
+	if ( fabs(stepUpMove[0]) < 0.1 && fabs(stepUpMove[1]) < 0.1 && VectorLengthSquared( slideMove ) > VectorLengthSquared( stepUpMove ) )
+	{
+		//slideMove was better, use it
+		VectorCopy (down_o, pm->ps->origin);
+		VectorCopy (down_v, pm->ps->velocity);
+	}
+	else
+	{
+		qboolean skipStep = qfalse;
+		// push down the final amount
+		VectorCopy (pm->ps->origin, down);
+		down[2] -= stepSize;
+		pm->trace (&trace, pm->ps->origin, pm->mins, pm->maxs, down, pm->ps->clientNum, pm->tracemask);
+		if ( pm->debugLevel )
+		{
+			G_DebugLine(pm->ps->origin,trace.endpos,2000,0xffffff,qtrue);
+		}
+		if ( g_stepSlideFix->integer )
+		{
+			if ( pm->ps->clientNum < MAX_CLIENTS
+				&& trace.plane.normal[2] < MIN_WALK_NORMAL )
+			{//normal players cannot step up slopes that are too steep to walk on!
+				vec3_t stepVec;
+				//okay, the step up ends on a slope that it too steep to step up onto,
+				//BUT:
+				//If the step looks like this:
+				//  (B)\__
+				//        \_____(A)
+				//Then it might still be okay, so we figure out the slope of the entire move
+				//from (A) to (B) and if that slope is walk-upabble, then it's okay
+				VectorSubtract( trace.endpos, down_o, stepVec );
+				VectorNormalize( stepVec ); 
+				if ( stepVec[2] > (1.0f-MIN_WALK_NORMAL) )
+				{
+					if ( pm->debugLevel )
+					{
+						G_DebugLine(down_o,trace.endpos,2000,0x0000ff,qtrue);
+					}
+					skipStep = qtrue;
+				}
+			}
+		}
+
+		if ( !trace.allsolid
+			&& !skipStep ) //normal players cannot step up slopes that are too steep to walk on!
+		{
+			if ( pm->ps->clientNum 
+				&& isGiant 
+				&& g_entities[trace.entityNum].client
+				&& pm->gent
+				&& pm->gent->client
+				&& pm->gent->client->NPC_class == CLASS_RANCOR )
+			{//Rancor don't step on clients
+				if ( g_stepSlideFix->integer )
+				{
+					VectorCopy (down_o, pm->ps->origin);
+					VectorCopy (down_v, pm->ps->velocity);
+				}
+				else
+				{
+					VectorCopy (start_o, pm->ps->origin);
+					VectorCopy (start_v, pm->ps->velocity);
+				}
+			}
+			else if ( pm->ps->clientNum 
+				&& isGiant 
+				&& g_entities[trace.entityNum].client
+				&& g_entities[trace.entityNum].client->playerTeam == pm->gent->client->playerTeam )
+			{//AT-ST's don't step up on allies
+				if ( g_stepSlideFix->integer )
+				{
+					VectorCopy (down_o, pm->ps->origin);
+					VectorCopy (down_v, pm->ps->velocity);
+				}
+				else
+				{
+					VectorCopy (start_o, pm->ps->origin);
+					VectorCopy (start_v, pm->ps->velocity);
+				}
+			}
+			else
+			{
+				VectorCopy( trace.endpos, pm->ps->origin );
+				if ( g_stepSlideFix->integer )
+				{
+					if ( trace.fraction < 1.0 ) 
+					{
+						PM_ClipVelocity( pm->ps->velocity, trace.plane.normal, pm->ps->velocity, OVERCLIP );
+					}
+				}
+			}
+		}
+		else
+		{
+			if ( g_stepSlideFix->integer )
+			{
+				VectorCopy (down_o, pm->ps->origin);
+				VectorCopy (down_v, pm->ps->velocity);
+			}
+		}
+		if ( !g_stepSlideFix->integer )
+		{
+			if ( trace.fraction < 1.0 ) 
+			{
+				PM_ClipVelocity( pm->ps->velocity, trace.plane.normal, pm->ps->velocity, OVERCLIP );
+			}
+		}
+	}
+
+	/*
+	if(cantStepUpFwd && pm->ps->origin[2] < start_o[2] + stepSize && pm->ps->origin[2] >= start_o[2])
+	{//We bumped into something we could not step up
+		pm->ps->pm_flags |= PMF_BLOCKED;
+	}
+	else
+	{//We did step up, clear the bumped flag
+	}
+	*/
+#if 0
+	// if the down trace can trace back to the original position directly, don't step
+	pm->trace( &trace, pm->ps->origin, pm->mins, pm->maxs, start_o, pm->ps->clientNum, pm->tracemask);
+	if ( trace.fraction == 1.0 ) {
+		// use the original move
+		VectorCopy (down_o, pm->ps->origin);
+		VectorCopy (down_v, pm->ps->velocity);
+		if ( pm->debugLevel ) {
+			Com_Printf("%i:bend\n", c_pmove);
+		}
+	} else 
+#endif
+	{
+		// use the step move
+		float	delta;
+
+		delta = pm->ps->origin[2] - start_o[2];
+		if ( delta > 2 ) {
+			if ( delta < 7 ) {
+				PM_AddEvent( EV_STEP_4 );
+			} else if ( delta < 11 ) {
+				PM_AddEvent( EV_STEP_8 );
+			} else if ( delta < 15 ) {
+				PM_AddEvent( EV_STEP_12 );
+			} else {
+				PM_AddEvent( EV_STEP_16 );
+			}
+		}
+		if ( pm->debugLevel ) {
+			Com_Printf("%i:stepped\n", c_pmove);
+		}
+	}
+}
+
diff --git a/code/game/bg_vehicleLoad.c b/code/game/bg_vehicleLoad.c
new file mode 100644
index 0000000..865da19
--- /dev/null
+++ b/code/game/bg_vehicleLoad.c
@@ -0,0 +1,1668 @@
+//bg_vehicleLoad.c
+
+#ifdef _JK2 //SP does not have this preprocessor for game like MP does
+#ifndef _JK2MP
+#define _JK2MP
+#endif
+#endif
+
+#ifdef _JK2MP
+	#include "q_shared.h"
+	#include "bg_public.h"
+	#include "bg_vehicles.h"
+	#include "bg_weapons.h"
+
+	//Could use strap stuff but I don't particularly care at the moment anyway.
+#include "../namespace_begin.h"
+	extern int	trap_FS_FOpenFile( const char *qpath, fileHandle_t *f, fsMode_t mode );
+	extern void	trap_FS_Read( void *buffer, int len, fileHandle_t f );
+	extern void	trap_FS_Write( const void *buffer, int len, fileHandle_t f );
+	extern void	trap_FS_FCloseFile( fileHandle_t f );
+	extern int	trap_FS_GetFileList(  const char *path, const char *extension, char *listbuf, int bufsize );
+#include "../namespace_end.h"
+#else
+	#include "g_local.h"
+	#define QAGAME
+#endif
+
+
+#ifdef _JK2MP
+#ifndef QAGAME
+#ifndef CGAME
+#define WE_ARE_IN_THE_UI
+#include "../ui/ui_local.h"
+#endif
+#endif
+#endif
+
+#ifndef _JK2MP
+#include "..\Ratl\string_vs.h"
+#endif
+
+#ifdef QAGAME
+extern void G_SetSharedVehicleFunctions( vehicleInfo_t *pVehInfo );
+extern int G_ModelIndex( const char *name );
+extern int G_SoundIndex( const char *name );
+	#ifdef _JK2MP
+		extern int G_EffectIndex( const char *name );
+	#endif
+#elif CGAME
+#include "../namespace_begin.h"
+extern qhandle_t	trap_R_RegisterModel( const char *name );			// returns rgb axis if not found
+extern qhandle_t	trap_R_RegisterSkin( const char *name );			// returns all white if not found
+extern qhandle_t	trap_R_RegisterShader( const char *name );
+extern qhandle_t	trap_R_RegisterShaderNoMip( const char *name );
+extern int			trap_FX_RegisterEffect(const char *file);
+extern sfxHandle_t	trap_S_RegisterSound( const char *sample);		// returns buzz if not found
+#include "../namespace_end.h"
+#else//UI
+#include "../namespace_begin.h"
+extern qhandle_t	trap_R_RegisterModel( const char *name );			// returns rgb axis if not found
+extern qhandle_t	trap_R_RegisterSkin( const char *name );			// returns all white if not found
+extern qhandle_t	trap_R_RegisterShader( const char *name );			// returns all white if not found
+extern qhandle_t	trap_R_RegisterShaderNoMip( const char *name );			// returns all white if not found
+extern sfxHandle_t	trap_S_RegisterSound( const char *sample);		// returns buzz if not found
+#include "../namespace_end.h"
+#endif
+
+extern stringID_table_t animTable [MAX_ANIMATIONS+1];
+
+// These buffers are filled in with the same contents and then just read from in
+// a few places. We only need one copy on Xbox.
+#define MAX_VEH_WEAPON_DATA_SIZE 0x4000
+#define MAX_VEHICLE_DATA_SIZE 0x10000
+
+#if !defined(_XBOX) || defined(QAGAME)
+	char	VehWeaponParms[MAX_VEH_WEAPON_DATA_SIZE];
+	char	VehicleParms[MAX_VEHICLE_DATA_SIZE];
+
+void BG_ClearVehicleParseParms(void)
+{
+	//You can't strcat to these forever without clearing them!
+	VehWeaponParms[0] = 0;
+	VehicleParms[0] = 0;
+}
+
+#else
+	extern char VehWeaponParms[MAX_VEH_WEAPON_DATA_SIZE];
+	extern char VehicleParms[MAX_VEHICLE_DATA_SIZE];
+#endif
+
+#ifdef _JK2MP
+#include "../namespace_begin.h"
+#endif
+
+#ifndef WE_ARE_IN_THE_UI
+//These funcs are actually shared in both projects
+extern void G_SetAnimalVehicleFunctions( vehicleInfo_t *pVehInfo );
+extern void G_SetSpeederVehicleFunctions( vehicleInfo_t *pVehInfo );
+extern void G_SetWalkerVehicleFunctions( vehicleInfo_t *pVehInfo );
+extern void G_SetFighterVehicleFunctions( vehicleInfo_t *pVehInfo );
+#endif
+
+vehWeaponInfo_t g_vehWeaponInfo[MAX_VEH_WEAPONS];
+int		numVehicleWeapons = 1;//first one is null/default
+
+vehicleInfo_t g_vehicleInfo[MAX_VEHICLES];
+int		numVehicles = 0;//first one is null/default
+
+void BG_VehicleLoadParms( void );
+
+typedef enum {
+	VF_IGNORE,
+	VF_INT,
+	VF_FLOAT,
+	VF_LSTRING,	// string on disk, pointer in memory, TAG_LEVEL
+	VF_VECTOR,
+	VF_BOOL,
+	VF_VEHTYPE,
+	VF_ANIM,
+	VF_WEAPON,	// take string, resolve into index into VehWeaponParms
+	VF_MODEL,	// take the string, get the G_ModelIndex
+	VF_MODEL_CLIENT,	// (cgame only) take the string, get the G_ModelIndex
+	VF_EFFECT,	// take the string, get the G_EffectIndex
+	VF_EFFECT_CLIENT,	// (cgame only) take the string, get the index
+	VF_SHADER,	// (cgame only) take the string, call trap_R_RegisterShader
+	VF_SHADER_NOMIP,// (cgame only) take the string, call trap_R_RegisterShaderNoMip
+	VF_SOUND,	// take the string, get the G_SoundIndex
+	VF_SOUND_CLIENT	// (cgame only) take the string, get the index
+} vehFieldType_t;
+
+typedef struct
+{
+	char	*name;
+	int		ofs;
+	vehFieldType_t	type;
+} vehField_t;
+
+vehField_t vehWeaponFields[NUM_VWEAP_PARMS] = 
+{
+	{"name", VWFOFS(name), VF_LSTRING},	//unique name of the vehicle
+	{"projectile", VWFOFS(bIsProjectile), VF_BOOL},	//traceline or entity?
+	{"hasGravity", VWFOFS(bHasGravity), VF_BOOL},	//if a projectile, drops
+	{"ionWeapon", VWFOFS(bIonWeapon), VF_BOOL},	//disables ship shields and sends them out of control
+	{"saberBlockable", VWFOFS(bSaberBlockable), VF_BOOL},	//lightsabers can deflect this projectile
+	{"muzzleFX", VWFOFS(iMuzzleFX), VF_EFFECT_CLIENT},	//index of Muzzle Effect
+	{"model", VWFOFS(iModel), VF_MODEL_CLIENT},	//handle to the model used by this projectile
+	{"shotFX", VWFOFS(iShotFX), VF_EFFECT_CLIENT},	//index of Shot Effect
+	{"impactFX", VWFOFS(iImpactFX), VF_EFFECT_CLIENT},	//index of Impact Effect
+	{"g2MarkShader", VWFOFS(iG2MarkShaderHandle), VF_SHADER},	//index of shader to use for G2 marks made on other models when hit by this projectile
+	{"g2MarkSize", VWFOFS(fG2MarkSize), VF_FLOAT},	//size (diameter) of the ghoul2 mark
+	{"loopSound", VWFOFS(iLoopSound), VF_SOUND_CLIENT},	//index of loopSound
+	{"speed", VWFOFS(fSpeed), VF_FLOAT},		//speed of projectile/range of traceline
+	{"homing", VWFOFS(fHoming), VF_FLOAT},		//0.0 = not homing, 0.5 = half vel to targ, half cur vel, 1.0 = all vel to targ
+	{"lockOnTime", VWFOFS(iLockOnTime), VF_INT},	//0 = no lock time needed, else # of ms needed to lock on
+	{"damage", VWFOFS(iDamage), VF_INT},		//damage done when traceline or projectile directly hits target
+	{"splashDamage", VWFOFS(iSplashDamage), VF_INT},//damage done to ents in splashRadius of end of traceline or projectile origin on impact
+	{"splashRadius", VWFOFS(fSplashRadius), VF_FLOAT},//radius that ent must be in to take splashDamage (linear fall-off)
+	{"ammoPerShot", VWFOFS(iAmmoPerShot), VF_INT},//how much "ammo" each shot takes
+	{"health", VWFOFS(iHealth), VF_INT},		//if non-zero, projectile can be shot, takes this much damage before being destroyed
+	{"width", VWFOFS(fWidth), VF_FLOAT},		//width of traceline or bounding box of projecile (non-rotating!)
+	{"height", VWFOFS(fHeight), VF_FLOAT},		//height of traceline or bounding box of projecile (non-rotating!)
+	{"lifetime", VWFOFS(iLifeTime), VF_INT},	//removes itself after this amount of time
+	{"explodeOnExpire", VWFOFS(bExplodeOnExpire), VF_BOOL},	//when iLifeTime is up, explodes rather than simply removing itself
+};
+
+static qboolean BG_ParseVehWeaponParm( vehWeaponInfo_t *vehWeapon, char *parmName, char *pValue )
+{
+	int		i;
+	vec3_t	vec;
+	byte	*b = (byte *)vehWeapon;
+	int		_iFieldsRead = 0;
+	vehicleType_t vehType;
+	char	value[1024];
+
+	Q_strncpyz( value, pValue, sizeof(value) );
+
+	// Loop through possible parameters
+	for ( i = 0; i < NUM_VWEAP_PARMS; i++ )
+	{
+		if ( vehWeaponFields[i].name && !Q_stricmp( vehWeaponFields[i].name, parmName ) )
+		{
+			// found it
+			switch( vehWeaponFields[i].type ) 
+			{
+			case VF_INT:
+				*(int *)(b+vehWeaponFields[i].ofs) = atoi(value);
+				break;
+			case VF_FLOAT:
+				*(float *)(b+vehWeaponFields[i].ofs) = atof(value);
+				break;
+			case VF_LSTRING:	// string on disk, pointer in memory, TAG_LEVEL
+				if (!*(char **)(b+vehWeaponFields[i].ofs))
+				{ //just use 1024 bytes in case we want to write over the string
+#ifdef _JK2MP
+					*(char **)(b+vehWeaponFields[i].ofs) = (char *)BG_Alloc(1024);//(char *)BG_Alloc(strlen(value));
+					strcpy(*(char **)(b+vehWeaponFields[i].ofs), value);
+#else
+					(*(char **)(b+vehWeaponFields[i].ofs)) = G_NewString( value );
+#endif
+				}
+				
+				break;
+			case VF_VECTOR:
+				_iFieldsRead = sscanf (value, "%f %f %f", &vec[0], &vec[1], &vec[2]);
+				assert(_iFieldsRead==3 );
+				if (_iFieldsRead!=3)
+				{
+					Com_Printf (S_COLOR_YELLOW"BG_ParseVehWeaponParm: VEC3 sscanf() failed to read 3 floats ('angle' key bug?)\n");
+				}
+				((float *)(b+vehWeaponFields[i].ofs))[0] = vec[0];
+				((float *)(b+vehWeaponFields[i].ofs))[1] = vec[1];
+				((float *)(b+vehWeaponFields[i].ofs))[2] = vec[2];
+				break;
+			case VF_BOOL:
+				*(qboolean *)(b+vehWeaponFields[i].ofs) = (qboolean)(atof(value)!=0);
+				break;
+			case VF_VEHTYPE:
+				vehType = (vehicleType_t)GetIDForString( VehicleTable, value );
+				*(vehicleType_t *)(b+vehWeaponFields[i].ofs) = vehType;
+				break;
+			case VF_ANIM:
+				{
+					int anim = GetIDForString( animTable, value );
+					*(int *)(b+vehWeaponFields[i].ofs) = anim;
+				}
+				break;
+			case VF_WEAPON:	// take string, resolve into index into VehWeaponParms
+				//*(int *)(b+vehWeaponFields[i].ofs) = VEH_VehWeaponIndexForName( value );
+				break;
+			case VF_MODEL:// take the string, get the G_ModelIndex
+#ifdef QAGAME
+				*(int *)(b+vehWeaponFields[i].ofs) = G_ModelIndex( value );
+#else
+				*(int *)(b+vehWeaponFields[i].ofs) = trap_R_RegisterModel( value );
+#endif
+				break;
+			case VF_MODEL_CLIENT:	// (MP cgame only) take the string, get the G_ModelIndex
+#ifndef _JK2MP
+				*(int *)(b+vehWeaponFields[i].ofs) = G_ModelIndex( value );
+#elif QAGAME
+				//*(int *)(b+vehWeaponFields[i].ofs) = G_ModelIndex( value );
+#else
+				*(int *)(b+vehWeaponFields[i].ofs) = trap_R_RegisterModel( value );
+#endif
+				break;
+			case VF_EFFECT:	// take the string, get the G_EffectIndex
+#ifdef QAGAME
+				*(int *)(b+vehWeaponFields[i].ofs) = G_EffectIndex( value );
+#elif CGAME
+				*(int *)(b+vehWeaponFields[i].ofs) = trap_FX_RegisterEffect( value );
+#endif
+				break;
+			case VF_EFFECT_CLIENT:	// (MP cgame only) take the string, get the index
+#ifndef _JK2MP
+				*(int *)(b+vehWeaponFields[i].ofs) = G_EffectIndex( value );
+#elif QAGAME
+				//*(int *)(b+vehWeaponFields[i].ofs) = G_EffectIndex( value );
+#elif CGAME
+				*(int *)(b+vehWeaponFields[i].ofs) = trap_FX_RegisterEffect( value );
+#endif
+				break;
+			case VF_SHADER:	// (cgame only) take the string, call trap_R_RegisterShader
+#ifdef WE_ARE_IN_THE_UI
+				*(int *)(b+vehWeaponFields[i].ofs) = trap_R_RegisterShaderNoMip( value );
+#elif CGAME
+				*(int *)(b+vehWeaponFields[i].ofs) = trap_R_RegisterShader( value );
+#endif
+				break;
+			case VF_SHADER_NOMIP:// (cgame only) take the string, call trap_R_RegisterShaderNoMip
+#ifndef QAGAME
+				*(int *)(b+vehWeaponFields[i].ofs) = trap_R_RegisterShaderNoMip( value );
+#endif
+				break;
+			case VF_SOUND:	// take the string, get the G_SoundIndex
+#ifdef QAGAME
+				*(int *)(b+vehWeaponFields[i].ofs) = G_SoundIndex( value );
+#else
+				*(int *)(b+vehWeaponFields[i].ofs) = trap_S_RegisterSound( value );
+#endif
+				break;
+			case VF_SOUND_CLIENT:	// (MP cgame only) take the string, get the index
+#ifndef _JK2MP
+				*(int *)(b+vehWeaponFields[i].ofs) = G_SoundIndex( value );
+#elif QAGAME
+				//*(int *)(b+vehWeaponFields[i].ofs) = G_SoundIndex( value );
+#else
+				*(int *)(b+vehWeaponFields[i].ofs) = trap_S_RegisterSound( value );
+#endif
+				break;
+			default:
+				//Unknown type?
+				return qfalse;
+				break;
+			}
+			break;
+		}
+	}
+	if ( i == NUM_VWEAP_PARMS )
+	{
+        return qfalse;
+	}
+	else
+	{
+		return qtrue;
+	}
+}
+
+int VEH_LoadVehWeapon( const char *vehWeaponName )
+{//load up specified vehWeapon and save in array: g_vehWeaponInfo
+	const char	*token;
+	char		parmName[128];//we'll assume that no parm name is longer than 128
+	char		*value;
+	const char	*p;
+	vehWeaponInfo_t	*vehWeapon = NULL;
+
+	//BG_VehWeaponSetDefaults( &g_vehWeaponInfo[0] );//set the first vehicle to default data
+
+	//try to parse data out
+	p = VehWeaponParms;
+
+#ifdef _JK2MP
+	COM_BeginParseSession("vehWeapons");
+#else
+	COM_BeginParseSession();
+#endif
+
+	vehWeapon = &g_vehWeaponInfo[numVehicleWeapons];
+	// look for the right vehicle weapon
+	while ( p ) 
+	{
+		token = COM_ParseExt( &p, qtrue );
+		if ( token[0] == 0 )
+		{
+			return qfalse;
+		}
+
+		if ( !Q_stricmp( token, vehWeaponName ) ) 
+		{
+			break;
+		}
+
+		SkipBracedSection( &p );
+	}
+	if ( !p ) 
+	{
+		return qfalse;
+	}
+
+	token = COM_ParseExt( &p, qtrue );
+	if ( token[0] == 0 )
+	{//barf
+		return VEH_WEAPON_NONE;
+	}
+
+	if ( Q_stricmp( token, "{" ) != 0 ) 
+	{
+		return VEH_WEAPON_NONE;
+	}
+	
+	// parse the vehWeapon info block
+	while ( 1 ) 
+	{
+		SkipRestOfLine( &p );
+		token = COM_ParseExt( &p, qtrue );
+		if ( !token[0] ) 
+		{
+			Com_Printf( S_COLOR_RED"ERROR: unexpected EOF while parsing Vehicle Weapon '%s'\n", vehWeaponName );
+			return VEH_WEAPON_NONE;
+		}
+
+		if ( !Q_stricmp( token, "}" ) ) 
+		{
+			break;
+		}
+		Q_strncpyz( parmName, token, sizeof(parmName) );
+		value = COM_ParseExt( &p, qtrue );
+		if ( !value || !value[0] )
+		{
+			Com_Printf( S_COLOR_RED"ERROR: Vehicle Weapon token '%s' has no value!\n", parmName );
+		}
+		else
+		{
+			if ( !BG_ParseVehWeaponParm( vehWeapon, parmName, value ) )
+			{
+				Com_Printf( S_COLOR_RED"ERROR: Unknown Vehicle Weapon key/value pair '%s','%s'!\n", parmName, value );
+			}
+		}
+	}
+	if ( vehWeapon->fHoming )
+	{//all lock-on weapons use these 2 sounds
+#ifdef QAGAME
+		//Hmm, no need fo have server register this, is there?
+		//G_SoundIndex( "sound/weapons/torpedo/tick.wav" );
+		//G_SoundIndex( "sound/weapons/torpedo/lock.wav" );
+#elif CGAME
+		trap_S_RegisterSound( "sound/vehicles/weapons/common/tick.wav" );
+		trap_S_RegisterSound( "sound/vehicles/weapons/common/lock.wav" );
+		trap_S_RegisterSound( "sound/vehicles/common/lockalarm1.wav" );
+		trap_S_RegisterSound( "sound/vehicles/common/lockalarm2.wav" );
+		trap_S_RegisterSound( "sound/vehicles/common/lockalarm3.wav" );
+#else
+		trap_S_RegisterSound( "sound/vehicles/weapons/common/tick.wav" );
+		trap_S_RegisterSound( "sound/vehicles/weapons/common/lock.wav" );
+		trap_S_RegisterSound( "sound/vehicles/common/lockalarm1.wav" );
+		trap_S_RegisterSound( "sound/vehicles/common/lockalarm2.wav" );
+		trap_S_RegisterSound( "sound/vehicles/common/lockalarm3.wav" );
+#endif
+	}
+	return (numVehicleWeapons++);
+}
+
+int VEH_VehWeaponIndexForName( const char *vehWeaponName )
+{
+	int vw;
+	if ( !vehWeaponName || !vehWeaponName[0] )
+	{
+		Com_Printf( S_COLOR_RED"ERROR: Trying to read Vehicle Weapon with no name!\n" );
+		return VEH_WEAPON_NONE;
+	}
+	for ( vw = VEH_WEAPON_BASE; vw < numVehicleWeapons; vw++ )
+	{
+		if ( g_vehWeaponInfo[vw].name
+			&& Q_stricmp( g_vehWeaponInfo[vw].name, vehWeaponName ) == 0 )
+		{//already loaded this one
+			return vw;
+		}
+	}
+	//haven't loaded it yet
+	if ( vw >= MAX_VEH_WEAPONS )
+	{//no more room!
+		Com_Printf( S_COLOR_RED"ERROR: Too many Vehicle Weapons (max 16), aborting load on %s!\n", vehWeaponName );
+		return VEH_WEAPON_NONE;
+	}
+	//we have room for another one, load it up and return the index
+	//HMM... should we not even load the .vwp file until we want to?
+	vw = VEH_LoadVehWeapon( vehWeaponName );
+	if ( vw == VEH_WEAPON_NONE )
+	{
+		Com_Printf( S_COLOR_RED"ERROR: Could not find Vehicle Weapon %s!\n", vehWeaponName );
+	}
+	return vw;
+}
+
+vehField_t vehicleFields[] = 
+{
+	{"name", VFOFS(name), VF_LSTRING},	//unique name of the vehicle
+
+	//general data
+	{"type", VFOFS(type), VF_VEHTYPE},	//what kind of vehicle
+	{"numHands", VFOFS(numHands), VF_INT},	//if 2 hands, no weapons, if 1 hand, can use 1-handed weapons, if 0 hands, can use 2-handed weapons
+	{"lookPitch", VFOFS(lookPitch), VF_FLOAT},	//How far you can look up and down off the forward of the vehicle
+	{"lookYaw", VFOFS(lookYaw), VF_FLOAT},	//How far you can look left and right off the forward of the vehicle
+	{"length", VFOFS(length), VF_FLOAT},		//how long it is - used for body length traces when turning/moving?
+	{"width", VFOFS(width), VF_FLOAT},		//how wide it is - used for body length traces when turning/moving?
+	{"height", VFOFS(height), VF_FLOAT},		//how tall it is - used for body length traces when turning/moving?
+	{"centerOfGravity", VFOFS(centerOfGravity), VF_VECTOR},//offset from origin: {forward, right, up} as a modifier on that dimension (-1.0f is all the way back, 1.0f is all the way forward)
+
+	//speed stats
+	{"speedMax", VFOFS(speedMax), VF_FLOAT},		//top speed
+	{"turboSpeed", VFOFS(turboSpeed), VF_FLOAT},	//turbo speed
+	{"speedMin", VFOFS(speedMin), VF_FLOAT},		//if < 0, can go in reverse
+	{"speedIdle", VFOFS(speedIdle), VF_FLOAT},		//what speed it drifts to when no accel/decel input is given
+	{"accelIdle", VFOFS(accelIdle), VF_FLOAT},		//if speedIdle > 0, how quickly it goes up to that speed
+	{"acceleration", VFOFS(acceleration), VF_FLOAT},	//when pressing on accelerator
+	{"decelIdle", VFOFS(decelIdle), VF_FLOAT},		//when giving no input, how quickly it drops to speedIdle
+	{"throttleSticks", VFOFS(throttleSticks), VF_BOOL},//if true, speed stays at whatever you accel/decel to, unless you turbo or brake
+	{"strafePerc", VFOFS(strafePerc), VF_FLOAT},		//multiplier on current speed for strafing.  If 1.0f, you can strafe at the same speed as you're going forward, 0.5 is half, 0 is no strafing
+
+	//handling stats
+	{"bankingSpeed", VFOFS(bankingSpeed), VF_FLOAT},	//how quickly it pitches and rolls (not under player control)
+	{"pitchLimit", VFOFS(pitchLimit), VF_FLOAT},		//how far it can roll forward or backward
+	{"rollLimit", VFOFS(rollLimit), VF_FLOAT},		//how far it can roll to either side
+	{"braking", VFOFS(braking), VF_FLOAT},		//when pressing on decelerator
+	{"mouseYaw", VFOFS(mouseYaw), VF_FLOAT},			// The mouse yaw override.
+	{"mousePitch", VFOFS(mousePitch), VF_FLOAT},			// The mouse yaw override.
+	{"turningSpeed", VFOFS(turningSpeed), VF_FLOAT},	//how quickly you can turn
+	{"turnWhenStopped", VFOFS(turnWhenStopped), VF_BOOL},//whether or not you can turn when not moving
+	{"traction", VFOFS(traction), VF_FLOAT},		//how much your command input affects velocity
+	{"friction", VFOFS(friction), VF_FLOAT},		//how much velocity is cut on its own
+	{"maxSlope", VFOFS(maxSlope), VF_FLOAT},		//the max slope that it can go up with control
+	{"speedDependantTurning", VFOFS(speedDependantTurning), VF_BOOL},//vehicle turns faster the faster it's going
+	
+	//durability stats
+	{"mass", VFOFS(mass), VF_INT},			//for momentum and impact force (player mass is 10)
+	{"armor", VFOFS(armor), VF_INT},			//total points of damage it can take
+	{"shields", VFOFS(shields), VF_INT},			//energy shield damage points
+	{"shieldRechargeMS", VFOFS(shieldRechargeMS), VF_INT},//energy shield milliseconds per point recharged
+	{"toughness", VFOFS(toughness), VF_FLOAT},		//modifies incoming damage, 1.0 is normal, 0.5 is half, etc.  Simulates being made of tougher materials/construction
+	{"malfunctionArmorLevel", VFOFS(malfunctionArmorLevel), VF_INT},//when armor drops to or below this point, start malfunctioning
+	{"surfDestruction", VFOFS(surfDestruction), VF_INT},
+
+	//visuals & sounds
+	{"model", VFOFS(model), VF_LSTRING},			//what model to use - if make it an NPC's primary model, don't need this?
+	{"skin", VFOFS(skin), VF_LSTRING},				//what skin to use - if make it an NPC's primary model, don't need this?
+	{"g2radius", VFOFS(g2radius), VF_INT},			//render radius (really diameter, but...) for the ghoul2 model
+	{"riderAnim", VFOFS(riderAnim), VF_ANIM},		//what animation the rider uses
+	{"droidNPC", VFOFS(droidNPC), VF_LSTRING},		//NPC to attach to *droidunit tag (if it exists in the model)
+
+#ifdef _JK2MP
+	{"radarIcon", VFOFS(radarIconHandle), VF_SHADER_NOMIP},		//what icon to show on radar in MP
+	{"dmgIndicFrame", VFOFS(dmgIndicFrameHandle), VF_SHADER_NOMIP},	//what image to use for the frame of the damage indicator
+	{"dmgIndicShield", VFOFS(dmgIndicShieldHandle), VF_SHADER_NOMIP},//what image to use for the shield of the damage indicator
+	{"dmgIndicBackground", VFOFS(dmgIndicBackgroundHandle), VF_SHADER_NOMIP},//what image to use for the background of the damage indicator
+	{"icon_front", VFOFS(iconFrontHandle), VF_SHADER_NOMIP},	//what image to use for the front of the ship on the damage indicator
+	{"icon_back", VFOFS(iconBackHandle), VF_SHADER_NOMIP},		//what image to use for the back of the ship on the damage indicator
+	{"icon_right", VFOFS(iconRightHandle), VF_SHADER_NOMIP},	//what image to use for the right of the ship on the damage indicator
+	{"icon_left", VFOFS(iconLeftHandle), VF_SHADER_NOMIP},		//what image to use for the left of the ship on the damage indicator
+	{"crosshairShader", VFOFS(crosshairShaderHandle), VF_SHADER_NOMIP},	//what image to use as the crosshair
+	{"shieldShader", VFOFS(shieldShaderHandle), VF_SHADER},		//What shader to use when drawing the shield shell
+
+	//individual "area" health -rww
+	{"health_front", VFOFS(health_front), VF_INT},
+	{"health_back", VFOFS(health_back), VF_INT},
+	{"health_right", VFOFS(health_right), VF_INT},
+	{"health_left", VFOFS(health_left), VF_INT},
+#else
+	{"radarIcon", 0, VF_IGNORE},		//what icon to show on radar in MP
+#endif
+
+	{"soundOn",			VFOFS(soundOn),			VF_SOUND},//sound to play when get on it
+	{"soundOff",		VFOFS(soundOff),		VF_SOUND},//sound to play when get off
+	{"soundLoop",		VFOFS(soundLoop),		VF_SOUND},//sound to loop while riding it
+	{"soundTakeOff",	VFOFS(soundTakeOff),	VF_SOUND},//sound to play when ship takes off
+	{"soundEngineStart",VFOFS(soundEngineStart),VF_SOUND_CLIENT},//sound to play when ship's thrusters first activate
+	{"soundSpin",		VFOFS(soundSpin),		VF_SOUND},//sound to loop while spiraling out of control
+	{"soundTurbo",		VFOFS(soundTurbo),		VF_SOUND},//sound to play when turbo/afterburner kicks in
+	{"soundHyper",		VFOFS(soundHyper),		VF_SOUND_CLIENT},//sound to play when hits hyperspace
+	{"soundLand",		VFOFS(soundLand),		VF_SOUND},//sound to play when ship lands
+	{"soundFlyBy",		VFOFS(soundFlyBy),		VF_SOUND_CLIENT},//sound to play when they buzz you
+	{"soundFlyBy2",		VFOFS(soundFlyBy2),		VF_SOUND_CLIENT},//alternate sound to play when they buzz you
+	{"soundShift1",		VFOFS(soundShift1),		VF_SOUND},//sound to play when changing speeds
+	{"soundShift2",		VFOFS(soundShift2),		VF_SOUND},//sound to play when changing speeds
+	{"soundShift3",		VFOFS(soundShift3),		VF_SOUND},//sound to play when changing speeds
+	{"soundShift4",		VFOFS(soundShift4),		VF_SOUND},//sound to play when changing speeds
+
+	{"exhaustFX", VFOFS(iExhaustFX), VF_EFFECT_CLIENT},		//exhaust effect, played from "*exhaust" bolt(s)
+	{"turboFX", VFOFS(iTurboFX), VF_EFFECT_CLIENT},		//turbo exhaust effect, played from "*exhaust" bolt(s) when ship is in "turbo" mode
+	{"turboStartFX", VFOFS(iTurboStartFX), VF_EFFECT},		//turbo start effect, played from "*exhaust" bolt(s) when ship is in "turbo" mode
+	{"trailFX", VFOFS(iTrailFX), VF_EFFECT_CLIENT},		//trail effect, played from "*trail" bolt(s)
+	{"impactFX", VFOFS(iImpactFX), VF_EFFECT_CLIENT},		//impact effect, for when it bumps into something
+	{"explodeFX", VFOFS(iExplodeFX), VF_EFFECT},		//explosion effect, for when it blows up (should have the sound built into explosion effect)
+	{"wakeFX", VFOFS(iWakeFX), VF_EFFECT_CLIENT},		//effect it makes when going across water
+	{"dmgFX", VFOFS(iDmgFX), VF_EFFECT_CLIENT},		//effect to play on damage from a weapon or something
+#ifdef _JK2MP
+	{"injureFX", VFOFS(iInjureFX), VF_EFFECT_CLIENT}, //effect to play on partially damaged ship surface
+	{"noseFX", VFOFS(iNoseFX), VF_EFFECT_CLIENT},		//effect for nose piece flying away when blown off
+	{"lwingFX", VFOFS(iLWingFX), VF_EFFECT_CLIENT},		//effect for left wing piece flying away when blown off
+	{"rwingFX", VFOFS(iRWingFX), VF_EFFECT_CLIENT},		//effect for right wing piece flying away when blown off
+#else
+	{"armorLowFX", VFOFS(iArmorLowFX), VF_EFFECT_CLIENT},		//effect to play on damage from a weapon or something
+	{"armorGoneFX", VFOFS(iArmorGoneFX), VF_EFFECT_CLIENT},		//effect to play on damage from a weapon or something
+#endif
+
+	// Weapon stuff:
+	{"weap1", VFOFS(weapon[0].ID), VF_WEAPON},	//weapon used when press fire
+	{"weap2", VFOFS(weapon[1].ID), VF_WEAPON},//weapon used when press alt-fire
+	// The delay between shots for this weapon.
+	{"weap1Delay", VFOFS(weapon[0].delay), VF_INT},
+	{"weap2Delay", VFOFS(weapon[1].delay), VF_INT},
+	// Whether or not all the muzzles for each weapon can be linked together (linked delay = weapon delay * number of muzzles linked!)
+	{"weap1Link", VFOFS(weapon[0].linkable), VF_INT},
+	{"weap2Link", VFOFS(weapon[1].linkable), VF_INT},
+	// Whether or not to auto-aim the projectiles at the thing under the crosshair when we fire
+	{"weap1Aim", VFOFS(weapon[0].aimCorrect), VF_BOOL},
+	{"weap2Aim", VFOFS(weapon[1].aimCorrect), VF_BOOL},
+	//maximum ammo
+	{"weap1AmmoMax", VFOFS(weapon[0].ammoMax), VF_INT},
+	{"weap2AmmoMax", VFOFS(weapon[1].ammoMax), VF_INT},
+	//ammo recharge rate - milliseconds per unit (minimum of 100, which is 10 ammo per second)
+	{"weap1AmmoRechargeMS", VFOFS(weapon[0].ammoRechargeMS), VF_INT},
+	{"weap2AmmoRechargeMS", VFOFS(weapon[1].ammoRechargeMS), VF_INT},
+	//sound to play when out of ammo (plays default "no ammo" sound if none specified)
+	{"weap1SoundNoAmmo", VFOFS(weapon[0].soundNoAmmo), VF_SOUND_CLIENT},//sound to play when try to fire weapon 1 with no ammo
+	{"weap2SoundNoAmmo", VFOFS(weapon[1].soundNoAmmo), VF_SOUND_CLIENT},//sound to play when try to fire weapon 2 with no ammo
+	
+	// Which weapon a muzzle fires (has to match one of the weapons this vehicle has).
+	{"weapMuzzle1", VFOFS(weapMuzzle[0]), VF_WEAPON},
+	{"weapMuzzle2", VFOFS(weapMuzzle[1]), VF_WEAPON},
+	{"weapMuzzle3", VFOFS(weapMuzzle[2]), VF_WEAPON},
+	{"weapMuzzle4", VFOFS(weapMuzzle[3]), VF_WEAPON},
+	{"weapMuzzle5", VFOFS(weapMuzzle[4]), VF_WEAPON},
+	{"weapMuzzle6", VFOFS(weapMuzzle[5]), VF_WEAPON},
+	{"weapMuzzle7", VFOFS(weapMuzzle[6]), VF_WEAPON},
+	{"weapMuzzle8", VFOFS(weapMuzzle[7]), VF_WEAPON},
+	{"weapMuzzle9", VFOFS(weapMuzzle[8]), VF_WEAPON},
+	{"weapMuzzle10", VFOFS(weapMuzzle[9]), VF_WEAPON},
+
+	// The max height before this ship (?) starts (auto)landing.
+	{"landingHeight", VFOFS(landingHeight), VF_FLOAT},
+
+	//other misc stats
+	{"gravity", VFOFS(gravity), VF_INT},			//normal is 800
+	{"hoverHeight", VFOFS(hoverHeight), VF_FLOAT},	//if 0, it's a ground vehicle
+	{"hoverStrength", VFOFS(hoverStrength), VF_FLOAT},	//how hard it pushes off ground when less than hover height... causes "bounce", like shocks
+	{"waterProof", VFOFS(waterProof), VF_BOOL},		//can drive underwater if it has to
+	{"bouyancy", VFOFS(bouyancy), VF_FLOAT},		//when in water, how high it floats (1 is neutral bouyancy)
+	{"fuelMax", VFOFS(fuelMax), VF_INT},		//how much fuel it can hold (capacity)
+	{"fuelRate", VFOFS(fuelRate), VF_INT},		//how quickly is uses up fuel
+	{"turboDuration", VFOFS(turboDuration), VF_INT},		//how long turbo lasts
+	{"turboRecharge", VFOFS(turboRecharge), VF_INT},		//how long turbo takes to recharge
+	{"visibility", VFOFS(visibility), VF_INT},		//for sight alerts
+	{"loudness", VFOFS(loudness), VF_INT},		//for sound alerts
+	{"explosionRadius", VFOFS(explosionRadius), VF_FLOAT},//range of explosion
+	{"explosionDamage", VFOFS(explosionDamage), VF_INT},//damage of explosion
+
+	//new stuff
+	{"maxPassengers", VFOFS(maxPassengers), VF_INT},	// The max number of passengers this vehicle may have (Default = 0).
+	{"hideRider", VFOFS(hideRider), VF_BOOL},			// rider (and passengers?) should not be drawn
+	{"killRiderOnDeath", VFOFS(killRiderOnDeath), VF_BOOL},//if rider is on vehicle when it dies, they should die
+	{"flammable", VFOFS(flammable), VF_BOOL},			//whether or not the vehicle should catch on fire before it explodes
+	{"explosionDelay", VFOFS(explosionDelay), VF_INT},	//how long the vehicle should be on fire/dying before it explodes
+	//camera stuff
+	{"cameraOverride", VFOFS(cameraOverride), VF_BOOL},//override the third person camera with the below values - normal is 0 (off)
+	{"cameraRange", VFOFS(cameraRange), VF_FLOAT},		//how far back the camera should be - normal is 80
+	{"cameraVertOffset", VFOFS(cameraVertOffset), VF_FLOAT},//how high over the vehicle origin the camera should be - normal is 16
+	{"cameraHorzOffset", VFOFS(cameraHorzOffset), VF_FLOAT},//how far to left/right (negative/positive) of of the vehicle origin the camera should be - normal is 0
+	{"cameraPitchOffset", VFOFS(cameraPitchOffset), VF_FLOAT},//a modifier on the camera's pitch (up/down angle) to the vehicle - normal is 0
+	{"cameraFOV", VFOFS(cameraFOV), VF_FLOAT},			//third person camera FOV, default is 80
+	{"cameraAlpha", VFOFS(cameraAlpha), VF_FLOAT},		//fade out the vehicle to this alpha (0.1-1.0f) if it's in the way of the crosshair
+	{"cameraPitchDependantVertOffset", VFOFS(cameraPitchDependantVertOffset), VF_BOOL},		//use the hacky AT-ST pitch dependant vertical offset
+//===TURRETS===========================================================================
+	//Turret 1
+	{"turret1Weap", VFOFS(turret[0].iWeapon), VF_WEAPON},
+	{"turret1Delay", VFOFS(turret[0].iDelay), VF_INT},
+	{"turret1AmmoMax", VFOFS(turret[0].iAmmoMax), VF_INT},
+	{"turret1AmmoRechargeMS", VFOFS(turret[0].iAmmoRechargeMS), VF_INT},
+	{"turret1YawBone", VFOFS(turret[0].yawBone), VF_LSTRING},
+	{"turret1PitchBone", VFOFS(turret[0].pitchBone), VF_LSTRING},
+	{"turret1YawAxis", VFOFS(turret[0].yawAxis), VF_INT},
+	{"turret1PitchAxis", VFOFS(turret[0].pitchAxis), VF_INT},
+	{"turret1ClampYawL", VFOFS(turret[0].yawClampLeft), VF_FLOAT},	//how far the turret is allowed to turn left
+	{"turret1ClampYawR", VFOFS(turret[0].yawClampRight), VF_FLOAT},	//how far the turret is allowed to turn right
+	{"turret1ClampPitchU", VFOFS(turret[0].pitchClampUp), VF_FLOAT},	//how far the turret is allowed to title up
+	{"turret1ClampPitchD", VFOFS(turret[0].pitchClampDown), VF_FLOAT}, //how far the turret is allowed to tilt down
+	{"turret1Muzzle1", VFOFS(turret[0].iMuzzle[0]), VF_INT},
+	{"turret1Muzzle2", VFOFS(turret[0].iMuzzle[1]), VF_INT},
+	{"turret1TurnSpeed", VFOFS(turret[0].fTurnSpeed), VF_FLOAT},
+	{"turret1AI", VFOFS(turret[0].bAI), VF_BOOL},
+	{"turret1AILead", VFOFS(turret[0].bAILead), VF_BOOL},
+	{"turret1AIRange", VFOFS(turret[0].fAIRange), VF_FLOAT},
+	{"turret1PassengerNum", VFOFS(turret[0].passengerNum), VF_INT},//which number passenger can control this turret
+	{"turret1GunnerViewTag", VFOFS(turret[0].gunnerViewTag), VF_LSTRING},
+	
+	//Turret 2
+	{"turret2Weap", VFOFS(turret[1].iWeapon), VF_WEAPON},
+	{"turret2Delay", VFOFS(turret[1].iDelay), VF_INT},
+	{"turret2AmmoMax", VFOFS(turret[1].iAmmoMax), VF_INT},
+	{"turret2AmmoRechargeMS", VFOFS(turret[1].iAmmoRechargeMS), VF_INT},
+	{"turret2YawBone", VFOFS(turret[1].yawBone), VF_LSTRING},
+	{"turret2PitchBone", VFOFS(turret[1].pitchBone), VF_LSTRING},
+	{"turret2YawAxis", VFOFS(turret[1].yawAxis), VF_INT},
+	{"turret2PitchAxis", VFOFS(turret[1].pitchAxis), VF_INT},
+	{"turret2ClampYawL", VFOFS(turret[1].yawClampLeft), VF_FLOAT},	//how far the turret is allowed to turn left
+	{"turret2ClampYawR", VFOFS(turret[1].yawClampRight), VF_FLOAT},	//how far the turret is allowed to turn right
+	{"turret2ClampPitchU", VFOFS(turret[1].pitchClampUp), VF_FLOAT},	//how far the turret is allowed to title up
+	{"turret2ClampPitchD", VFOFS(turret[1].pitchClampDown), VF_FLOAT}, //how far the turret is allowed to tilt down
+	{"turret2Muzzle1", VFOFS(turret[1].iMuzzle[0]), VF_INT},
+	{"turret2Muzzle2", VFOFS(turret[1].iMuzzle[1]), VF_INT},
+	{"turret2TurnSpeed", VFOFS(turret[1].fTurnSpeed), VF_FLOAT},
+	{"turret2AI", VFOFS(turret[1].bAI), VF_BOOL},
+	{"turret2AILead", VFOFS(turret[1].bAILead), VF_BOOL},
+	{"turret2AIRange", VFOFS(turret[1].fAIRange), VF_FLOAT},
+	{"turret2PassengerNum", VFOFS(turret[1].passengerNum), VF_INT},//which number passenger can control this turret
+	{"turret2GunnerViewTag", VFOFS(turret[1].gunnerViewTag), VF_LSTRING},
+//===END TURRETS===========================================================================
+	//terminating entry
+	{0, -1, VF_INT}
+};
+
+stringID_table_t VehicleTable[VH_NUM_VEHICLES+1] =
+{
+	ENUM2STRING(VH_NONE),
+	ENUM2STRING(VH_WALKER),		//something you ride inside of, it walks like you, like an AT-ST
+	ENUM2STRING(VH_FIGHTER),	//something you fly inside of, like an X-Wing or TIE fighter
+	ENUM2STRING(VH_SPEEDER),	//something you ride on that hovers, like a speeder or swoop
+	ENUM2STRING(VH_ANIMAL),		//animal you ride on top of that walks, like a tauntaun
+	ENUM2STRING(VH_FLIER),		//animal you ride on top of that flies, like a giant mynoc?
+	0,	-1
+};
+
+// Setup the shared functions (one's that all vehicles would generally use).
+void BG_SetSharedVehicleFunctions( vehicleInfo_t *pVehInfo )
+{
+#ifdef QAGAME
+	//only do the whole thing if we're on game
+	G_SetSharedVehicleFunctions(pVehInfo);
+#endif
+
+#ifndef WE_ARE_IN_THE_UI
+	switch( pVehInfo->type )
+	{
+		case VH_SPEEDER:
+			G_SetSpeederVehicleFunctions( pVehInfo );
+			break;
+		case VH_ANIMAL:
+			G_SetAnimalVehicleFunctions( pVehInfo );
+			break;
+		case VH_FIGHTER:
+			G_SetFighterVehicleFunctions( pVehInfo );
+			break;
+		case VH_WALKER:
+			G_SetWalkerVehicleFunctions( pVehInfo );
+			break;
+	}
+#endif
+}
+
+void BG_VehicleSetDefaults( vehicleInfo_t *vehicle )
+{
+	memset(vehicle, 0, sizeof(vehicleInfo_t));
+/*
+#if _JK2MP
+	if (!vehicle->name)
+	{
+		vehicle->name = (char *)BG_Alloc(1024);
+	}
+	strcpy(vehicle->name, "default");
+#else
+	vehicle->name = G_NewString( "default" );
+#endif
+
+	//general data
+	vehicle->type = VH_SPEEDER;				//what kind of vehicle
+	//FIXME: no saber or weapons if numHands = 2, should switch to speeder weapon, no attack anim on player
+	vehicle->numHands = 0;					//if 2 hands, no weapons, if 1 hand, can use 1-handed weapons, if 0 hands, can use 2-handed weapons
+	vehicle->lookPitch = 0;				//How far you can look up and down off the forward of the vehicle
+	vehicle->lookYaw = 5;					//How far you can look left and right off the forward of the vehicle
+	vehicle->length = 0;					//how long it is - used for body length traces when turning/moving?
+	vehicle->width = 0;						//how wide it is - used for body length traces when turning/moving?
+	vehicle->height = 0;					//how tall it is - used for body length traces when turning/moving?
+	VectorClear( vehicle->centerOfGravity );//offset from origin: {forward, right, up} as a modifier on that dimension (-1.0f is all the way back, 1.0f is all the way forward)
+
+	//speed stats - note: these are DESIRED speed, not actual current speed/velocity
+	vehicle->speedMax = VEH_DEFAULT_SPEED_MAX;	//top speed
+	vehicle->turboSpeed = 0;					//turboBoost
+	vehicle->speedMin = 0;						//if < 0, can go in reverse
+	vehicle->speedIdle = 0;						//what speed it drifts to when no accel/decel input is given
+	vehicle->accelIdle = 0;						//if speedIdle > 0, how quickly it goes up to that speed
+	vehicle->acceleration = VEH_DEFAULT_ACCEL;	//when pressing on accelerator (1/2 this when going in reverse)
+	vehicle->decelIdle = VEH_DEFAULT_DECEL;		//when giving no input, how quickly it desired speed drops to speedIdle
+	vehicle->strafePerc = VEH_DEFAULT_STRAFE_PERC;//multiplier on current speed for strafing.  If 1.0f, you can strafe at the same speed as you're going forward, 0.5 is half, 0 is no strafing
+
+	//handling stats
+	vehicle->bankingSpeed = VEH_DEFAULT_BANKING_SPEED;	//how quickly it pitches and rolls (not under player control)
+	vehicle->rollLimit = VEH_DEFAULT_ROLL_LIMIT;		//how far it can roll to either side
+	vehicle->pitchLimit = VEH_DEFAULT_PITCH_LIMIT;		//how far it can pitch forward or backward
+	vehicle->braking = VEH_DEFAULT_BRAKING;				//when pressing on decelerator (backwards)
+	vehicle->turningSpeed = VEH_DEFAULT_TURNING_SPEED;	//how quickly you can turn
+	vehicle->turnWhenStopped = qfalse;					//whether or not you can turn when not moving	
+	vehicle->traction = VEH_DEFAULT_TRACTION;			//how much your command input affects velocity
+	vehicle->friction = VEH_DEFAULT_FRICTION;			//how much velocity is cut on its own
+	vehicle->maxSlope = VEH_DEFAULT_MAX_SLOPE;			//the max slope that it can go up with control
+
+	//durability stats
+	vehicle->mass = VEH_DEFAULT_MASS;			//for momentum and impact force (player mass is 10)
+	vehicle->armor = VEH_DEFAULT_MAX_ARMOR;		//total points of damage it can take
+	vehicle->toughness = VEH_DEFAULT_TOUGHNESS;	//modifies incoming damage, 1.0 is normal, 0.5 is half, etc.  Simulates being made of tougher materials/construction
+	vehicle->malfunctionArmorLevel = 0;			//when armor drops to or below this point, start malfunctioning
+
+	//visuals & sounds
+	//vehicle->model = "models/map_objects/ships/swoop.md3";	//what model to use - if make it an NPC's primary model, don't need this?
+	if (!vehicle->model)
+	{
+		vehicle->model = (char *)BG_Alloc(1024);
+	}
+	strcpy(vehicle->model, "models/map_objects/ships/swoop.md3");
+
+	vehicle->modelIndex = 0;							//set internally, not until this vehicle is spawned into the level
+	vehicle->skin = NULL;								//what skin to use - if make it an NPC's primary model, don't need this?
+	vehicle->riderAnim = BOTH_GUNSIT1;					//what animation the rider uses
+
+	vehicle->soundOn = NULL;							//sound to play when get on it
+	vehicle->soundLoop = NULL;							//sound to loop while riding it
+	vehicle->soundOff = NULL;							//sound to play when get off
+	vehicle->exhaustFX = NULL;							//exhaust effect, played from "*exhaust" bolt(s)
+	vehicle->trailFX = NULL;							//trail effect, played from "*trail" bolt(s)
+	vehicle->impactFX = NULL;							//explosion effect, for when it blows up (should have the sound built into explosion effect)
+	vehicle->explodeFX = NULL;							//explosion effect, for when it blows up (should have the sound built into explosion effect)
+	vehicle->wakeFX = NULL;								//effect itmakes when going across water
+
+	//other misc stats
+	vehicle->gravity = VEH_DEFAULT_GRAVITY;				//normal is 800
+	vehicle->hoverHeight = 0;//VEH_DEFAULT_HOVER_HEIGHT;	//if 0, it's a ground vehicle
+	vehicle->hoverStrength = 0;//VEH_DEFAULT_HOVER_STRENGTH;//how hard it pushes off ground when less than hover height... causes "bounce", like shocks
+	vehicle->waterProof = qtrue;						//can drive underwater if it has to
+	vehicle->bouyancy = 1.0f;							//when in water, how high it floats (1 is neutral bouyancy)
+	vehicle->fuelMax = 1000;							//how much fuel it can hold (capacity)
+	vehicle->fuelRate = 1;								//how quickly is uses up fuel
+	vehicle->visibility = VEH_DEFAULT_VISIBILITY;		//radius for sight alerts
+	vehicle->loudness = VEH_DEFAULT_LOUDNESS;			//radius for sound alerts
+	vehicle->explosionRadius = VEH_DEFAULT_EXP_RAD;
+	vehicle->explosionDamage = VEH_DEFAULT_EXP_DMG;
+	vehicle->maxPassengers = 0;
+
+	//new stuff
+	vehicle->hideRider = qfalse;						// rider (and passengers?) should not be drawn
+	vehicle->killRiderOnDeath = qfalse;					//if rider is on vehicle when it dies, they should die
+	vehicle->flammable = qfalse;						//whether or not the vehicle should catch on fire before it explodes
+	vehicle->explosionDelay = 0;						//how long the vehicle should be on fire/dying before it explodes
+	//camera stuff
+	vehicle->cameraOverride = qfalse;					//whether or not to use all of the following 3rd person camera override values
+	vehicle->cameraRange = 0.0f;						//how far back the camera should be - normal is 80
+	vehicle->cameraVertOffset = 0.0f;					//how high over the vehicle origin the camera should be - normal is 16
+	vehicle->cameraHorzOffset = 0.0f;					//how far to left/right (negative/positive) of of the vehicle origin the camera should be - normal is 0
+	vehicle->cameraPitchOffset = 0.0f;					//a modifier on the camera's pitch (up/down angle) to the vehicle - normal is 0
+	vehicle->cameraFOV = 0.0f;							//third person camera FOV, default is 80
+	vehicle->cameraAlpha = qfalse;						//fade out the vehicle if it's in the way of the crosshair
+*/
+}
+
+void BG_VehicleClampData( vehicleInfo_t *vehicle )
+{//sanity check and clamp the vehicle's data
+	int		i;
+
+	for ( i = 0; i < 3; i++ )
+	{
+		if ( vehicle->centerOfGravity[i] > 1.0f )
+		{
+			vehicle->centerOfGravity[i] = 1.0f;
+		}
+		else if ( vehicle->centerOfGravity[i] < -1.0f )
+		{
+			vehicle->centerOfGravity[i] = -1.0f;
+		}
+	}
+
+	// Validate passenger max.
+	if ( vehicle->maxPassengers > VEH_MAX_PASSENGERS )
+	{
+		vehicle->maxPassengers = VEH_MAX_PASSENGERS;
+	}
+	else if ( vehicle->maxPassengers < 0 )
+	{
+		vehicle->maxPassengers = 0;
+	}
+}
+
+static qboolean BG_ParseVehicleParm( vehicleInfo_t *vehicle, char *parmName, char *pValue )
+{
+	int		i;
+	vec3_t	vec;
+	byte	*b = (byte *)vehicle;
+	int		_iFieldsRead = 0;
+	vehicleType_t vehType;
+	char value[1024];
+
+	Q_strncpyz( value, pValue, sizeof(value) );
+
+	// Loop through possible parameters
+	for ( i = 0; vehicleFields[i].ofs != -1; i++ )
+	{
+		if ( !Q_stricmp( vehicleFields[i].name, parmName ) )
+		{
+			// found it
+			switch( vehicleFields[i].type ) 
+			{
+			case VF_IGNORE:
+				break;
+			case VF_INT:
+				*(int *)(b+vehicleFields[i].ofs) = atoi(value);
+				break;
+			case VF_FLOAT:
+				*(float *)(b+vehicleFields[i].ofs) = atof(value);
+				break;
+			case VF_LSTRING:	// string on disk, pointer in memory, TAG_LEVEL
+				if (!*(char **)(b+vehicleFields[i].ofs))
+				{ //just use 128 bytes in case we want to write over the string
+#ifdef _JK2MP
+					*(char **)(b+vehicleFields[i].ofs) = (char *)BG_Alloc(128);//(char *)BG_Alloc(strlen(value));
+					strcpy(*(char **)(b+vehicleFields[i].ofs), value);
+#else
+					(*(char **)(b+vehicleFields[i].ofs)) = G_NewString( value );
+#endif
+				}
+				
+				break;
+			case VF_VECTOR:
+				_iFieldsRead = sscanf (value, "%f %f %f", &vec[0], &vec[1], &vec[2]);
+				assert(_iFieldsRead==3 );
+				if (_iFieldsRead!=3)
+				{
+					Com_Printf (S_COLOR_YELLOW"BG_ParseVehicleParm: VEC3 sscanf() failed to read 3 floats ('angle' key bug?)\n");
+				}
+				((float *)(b+vehWeaponFields[i].ofs))[0] = vec[0];
+				((float *)(b+vehWeaponFields[i].ofs))[1] = vec[1];
+				((float *)(b+vehWeaponFields[i].ofs))[2] = vec[2];
+				break;
+			case VF_BOOL:
+				*(qboolean *)(b+vehicleFields[i].ofs) = (qboolean)(atof(value)!=0);
+				break;
+			case VF_VEHTYPE:
+				vehType = (vehicleType_t)GetIDForString( VehicleTable, value );
+				*(vehicleType_t *)(b+vehicleFields[i].ofs) = vehType;
+				break;
+			case VF_ANIM:
+				{
+					int anim = GetIDForString( animTable, value );
+					*(int *)(b+vehicleFields[i].ofs) = anim;
+				}
+				break;
+			case VF_WEAPON:	// take string, resolve into index into VehWeaponParms
+				*(int *)(b+vehicleFields[i].ofs) = VEH_VehWeaponIndexForName( value );
+				break;
+			case VF_MODEL:	// take the string, get the G_ModelIndex
+#ifdef QAGAME
+				*(int *)(b+vehicleFields[i].ofs) = G_ModelIndex( value );
+#else
+				*(int *)(b+vehicleFields[i].ofs) = trap_R_RegisterModel( value );
+#endif
+				break;
+			case VF_MODEL_CLIENT:	// (MP cgame only) take the string, get the G_ModelIndex
+#ifndef _JK2MP
+				*(int *)(b+vehicleFields[i].ofs) = G_ModelIndex( value );
+#elif QAGAME
+				//*(int *)(b+vehicleFields[i].ofs) = G_ModelIndex( value );
+#else
+				*(int *)(b+vehicleFields[i].ofs) = trap_R_RegisterModel( value );
+#endif
+				break;
+			case VF_EFFECT:	// take the string, get the G_EffectIndex
+#ifdef QAGAME
+				*(int *)(b+vehicleFields[i].ofs) = G_EffectIndex( value );
+#elif CGAME
+				*(int *)(b+vehicleFields[i].ofs) = trap_FX_RegisterEffect( value );
+#endif
+				break;
+			case VF_EFFECT_CLIENT:	// (MP cgame only) take the string, get the G_EffectIndex
+#ifndef _JK2MP
+				*(int *)(b+vehicleFields[i].ofs) = G_EffectIndex( value );
+#elif QAGAME
+				//*(int *)(b+vehicleFields[i].ofs) = G_EffectIndex( value );
+#elif CGAME
+				*(int *)(b+vehicleFields[i].ofs) = trap_FX_RegisterEffect( value );
+#endif
+				break;
+			case VF_SHADER:	// (cgame only) take the string, call trap_R_RegisterShader
+#ifdef WE_ARE_IN_THE_UI
+				*(int *)(b+vehicleFields[i].ofs) = trap_R_RegisterShaderNoMip( value );
+#elif CGAME
+				*(int *)(b+vehicleFields[i].ofs) = trap_R_RegisterShader( value );
+#endif
+				break;
+			case VF_SHADER_NOMIP:// (cgame only) take the string, call trap_R_RegisterShaderNoMip
+#ifndef QAGAME
+				*(int *)(b+vehicleFields[i].ofs) = trap_R_RegisterShaderNoMip( value );
+#endif
+				break;
+			case VF_SOUND:	// take the string, get the G_SoundIndex
+#ifdef QAGAME
+				*(int *)(b+vehicleFields[i].ofs) = G_SoundIndex( value );
+#else
+				*(int *)(b+vehicleFields[i].ofs) = trap_S_RegisterSound( value );
+#endif
+				break;
+			case VF_SOUND_CLIENT:	// (MP cgame only) take the string, get the G_SoundIndex
+#ifndef _JK2MP
+				*(int *)(b+vehicleFields[i].ofs) = G_SoundIndex( value );
+#elif QAGAME
+				//*(int *)(b+vehicleFields[i].ofs) = G_SoundIndex( value );
+#else
+				*(int *)(b+vehicleFields[i].ofs) = trap_S_RegisterSound( value );
+#endif
+				break;
+			default:
+				//Unknown type?
+				return qfalse;
+				break;
+			}
+			break;
+		}
+	}
+	if ( vehicleFields[i].ofs == -1 )
+	{
+        return qfalse;
+	}
+	else
+	{
+		return qtrue;
+	}
+}
+
+int VEH_LoadVehicle( const char *vehicleName )
+{//load up specified vehicle and save in array: g_vehicleInfo
+	const char	*token;
+	//we'll assume that no parm name is longer than 128
+	char		parmName[128] = { 0 };
+	char		weap1[128] = { 0 }, weap2[128] = { 0 };
+	char		weapMuzzle1[128] = { 0 };
+	char		weapMuzzle2[128] = { 0 };
+	char		weapMuzzle3[128] = { 0 };
+	char		weapMuzzle4[128] = { 0 };
+	char		weapMuzzle5[128] = { 0 };
+	char		weapMuzzle6[128] = { 0 };
+	char		weapMuzzle7[128] = { 0 };
+	char		weapMuzzle8[128] = { 0 };
+	char		weapMuzzle9[128] = { 0 };
+	char		weapMuzzle10[128] = { 0 };
+	char		*value = NULL;
+	const char	*p = NULL;
+	vehicleInfo_t	*vehicle = NULL;
+
+	// Load the vehicle parms if no vehicles have been loaded yet.
+	if ( numVehicles == 0 ) 
+	{
+		BG_VehicleLoadParms();
+	}
+
+	//try to parse data out
+	p = VehicleParms;
+
+#ifdef _JK2MP
+	COM_BeginParseSession("vehicles");
+#else
+	COM_BeginParseSession();
+#endif
+
+	vehicle = &g_vehicleInfo[numVehicles];
+	// look for the right vehicle
+	while ( p ) 
+	{
+		token = COM_ParseExt( &p, qtrue );
+		if ( token[0] == 0 )
+		{
+			return VEHICLE_NONE;
+		}
+
+		if ( !Q_stricmp( token, vehicleName ) ) 
+		{
+			break;
+		}
+
+		SkipBracedSection( &p );
+	}
+
+	if ( !p )
+	{
+		return VEHICLE_NONE;
+	}
+
+	token = COM_ParseExt( &p, qtrue );
+	if ( token[0] == 0 )
+	{//barf
+		return VEHICLE_NONE;
+	}
+
+	if ( Q_stricmp( token, "{" ) != 0 ) 
+	{
+		return VEHICLE_NONE;
+	}
+	
+	BG_VehicleSetDefaults( vehicle );
+	// parse the vehicle info block
+	while ( 1 ) 
+	{
+		SkipRestOfLine( &p );
+		token = COM_ParseExt( &p, qtrue );
+		if ( !token[0] ) 
+		{
+			Com_Printf( S_COLOR_RED"ERROR: unexpected EOF while parsing Vehicle '%s'\n", vehicleName );
+			return VEHICLE_NONE;
+		}
+
+		if ( !Q_stricmp( token, "}" ) ) 
+		{
+			break;
+		}
+		Q_strncpyz( parmName, token, sizeof(parmName) );
+		value = COM_ParseExt( &p, qtrue );
+		if ( !value || !value[0] )
+		{
+			Com_Printf( S_COLOR_RED"ERROR: Vehicle token '%s' has no value!\n", parmName );
+		}
+		else if ( Q_stricmp( "weap1", parmName ) == 0 )
+		{//hmm, store this off because we don't want to call another one of these text parsing routines while we're in the middle of one...
+			Q_strncpyz( weap1, value, sizeof(weap1) );
+		}
+		else if ( Q_stricmp( "weap2", parmName ) == 0 )
+		{//hmm, store this off because we don't want to call another one of these text parsing routines while we're in the middle of one...
+			Q_strncpyz( weap2, value, sizeof(weap2) );
+		}
+		else if ( Q_stricmp( "weapMuzzle1", parmName ) == 0 )
+		{//hmm, store this off because we don't want to call another one of these text parsing routines while we're in the middle of one...
+			Q_strncpyz( weapMuzzle1, value, sizeof(weapMuzzle1) );
+		}
+		else if ( Q_stricmp( "weapMuzzle2", parmName ) == 0 )
+		{//hmm, store this off because we don't want to call another one of these text parsing routines while we're in the middle of one...
+			Q_strncpyz( weapMuzzle2, value, sizeof(weapMuzzle2) );
+		}
+		else if ( Q_stricmp( "weapMuzzle3", parmName ) == 0 )
+		{//hmm, store this off because we don't want to call another one of these text parsing routines while we're in the middle of one...
+			Q_strncpyz( weapMuzzle3, value, sizeof(weapMuzzle3) );
+		}
+		else if ( Q_stricmp( "weapMuzzle4", parmName ) == 0 )
+		{//hmm, store this off because we don't want to call another one of these text parsing routines while we're in the middle of one...
+			Q_strncpyz( weapMuzzle4, value, sizeof(weapMuzzle4) );
+		}
+		else if ( Q_stricmp( "weapMuzzle5", parmName ) == 0 )
+		{//hmm, store this off because we don't want to call another one of these text parsing routines while we're in the middle of one...
+			Q_strncpyz( weapMuzzle5, value, sizeof(weapMuzzle5) );
+		}
+		else if ( Q_stricmp( "weapMuzzle6", parmName ) == 0 )
+		{//hmm, store this off because we don't want to call another one of these text parsing routines while we're in the middle of one...
+			Q_strncpyz( weapMuzzle6, value, sizeof(weapMuzzle6) );
+		}
+		else if ( Q_stricmp( "weapMuzzle7", parmName ) == 0 )
+		{//hmm, store this off because we don't want to call another one of these text parsing routines while we're in the middle of one...
+			Q_strncpyz( weapMuzzle7, value, sizeof(weapMuzzle7) );
+		}
+		else if ( Q_stricmp( "weapMuzzle8", parmName ) == 0 )
+		{//hmm, store this off because we don't want to call another one of these text parsing routines while we're in the middle of one...
+			Q_strncpyz( weapMuzzle8, value, sizeof(weapMuzzle8) );
+		}
+		else if ( Q_stricmp( "weapMuzzle9", parmName ) == 0 )
+		{//hmm, store this off because we don't want to call another one of these text parsing routines while we're in the middle of one...
+			Q_strncpyz( weapMuzzle9, value, sizeof(weapMuzzle9) );
+		}
+		else if ( Q_stricmp( "weapMuzzle10", parmName ) == 0 )
+		{//hmm, store this off because we don't want to call another one of these text parsing routines while we're in the middle of one...
+			Q_strncpyz( weapMuzzle10, value, sizeof(weapMuzzle10) );
+		}
+		else
+		{
+			if ( !BG_ParseVehicleParm( vehicle, parmName, value ) )
+			{
+#ifndef FINAL_BUILD
+				Com_Printf( S_COLOR_RED"ERROR: Unknown Vehicle key/value pair '%s', '%s'!\n", parmName, value );
+#endif
+			}
+		}
+	}
+	//NOW: if we have any weapons, go ahead and load them
+	if ( weap1[0] )
+	{
+		if ( !BG_ParseVehicleParm( vehicle, "weap1", weap1 ) )
+		{
+#ifndef FINAL_BUILD
+			Com_Printf( S_COLOR_RED"ERROR: Unknown Vehicle key/value pair 'weap1', '%s'!\n", weap1 );
+#endif
+		}
+	}
+	if ( weap2[0] )
+	{
+		if ( !BG_ParseVehicleParm( vehicle, "weap2", weap2 ) )
+		{
+#ifndef FINAL_BUILD
+			Com_Printf( S_COLOR_RED"ERROR: Unknown Vehicle key/value pair 'weap2', '%s'!\n", weap2 );
+#endif
+		}
+	}
+	if ( weapMuzzle1[0] )
+	{
+		if ( !BG_ParseVehicleParm( vehicle, "weapMuzzle1", weapMuzzle1 ) )
+		{
+#ifndef FINAL_BUILD
+			Com_Printf( S_COLOR_RED"ERROR: Unknown Vehicle key/value pair 'weapMuzzle1', '%s'!\n", weapMuzzle1 );
+#endif
+		}
+	}
+	if ( weapMuzzle2[0] )
+	{
+		if ( !BG_ParseVehicleParm( vehicle, "weapMuzzle2", weapMuzzle2 ) )
+		{
+#ifndef FINAL_BUILD
+			Com_Printf( S_COLOR_RED"ERROR: Unknown Vehicle key/value pair 'weapMuzzle2', '%s'!\n", weapMuzzle2 );
+#endif
+		}
+	}
+	if ( weapMuzzle3[0] )
+	{
+		if ( !BG_ParseVehicleParm( vehicle, "weapMuzzle3", weapMuzzle3 ) )
+		{
+#ifndef FINAL_BUILD
+			Com_Printf( S_COLOR_RED"ERROR: Unknown Vehicle key/value pair 'weapMuzzle3', '%s'!\n", weapMuzzle3 );
+#endif
+		}
+	}
+	if ( weapMuzzle4[0] )
+	{
+		if ( !BG_ParseVehicleParm( vehicle, "weapMuzzle4", weapMuzzle4 ) )
+		{
+#ifndef FINAL_BUILD
+			Com_Printf( S_COLOR_RED"ERROR: Unknown Vehicle key/value pair 'weapMuzzle4', '%s'!\n", weapMuzzle4 );
+#endif
+		}
+	}
+	if ( weapMuzzle5[0] )
+	{
+		if ( !BG_ParseVehicleParm( vehicle, "weapMuzzle5", weapMuzzle5 ) )
+		{
+#ifndef FINAL_BUILD
+			Com_Printf( S_COLOR_RED"ERROR: Unknown Vehicle key/value pair 'weapMuzzle5', '%s'!\n", weapMuzzle5 );
+#endif
+		}
+	}
+	if ( weapMuzzle6[0] )
+	{
+		if ( !BG_ParseVehicleParm( vehicle, "weapMuzzle6", weapMuzzle6 ) )
+		{
+#ifndef FINAL_BUILD
+			Com_Printf( S_COLOR_RED"ERROR: Unknown Vehicle key/value pair 'weapMuzzle6', '%s'!\n", weapMuzzle6 );
+#endif
+		}
+	}
+	if ( weapMuzzle7[0] )
+	{
+		if ( !BG_ParseVehicleParm( vehicle, "weapMuzzle7", weapMuzzle7 ) )
+		{
+#ifndef FINAL_BUILD
+			Com_Printf( S_COLOR_RED"ERROR: Unknown Vehicle key/value pair 'weapMuzzle7', '%s'!\n", weapMuzzle7 );
+#endif
+		}
+	}
+	if ( weapMuzzle8[0] )
+	{
+		if ( !BG_ParseVehicleParm( vehicle, "weapMuzzle8", weapMuzzle8 ) )
+		{
+#ifndef FINAL_BUILD
+			Com_Printf( S_COLOR_RED"ERROR: Unknown Vehicle key/value pair 'weapMuzzle8', '%s'!\n", weapMuzzle8 );
+#endif
+		}
+	}
+	if ( weapMuzzle9[0] )
+	{
+		if ( !BG_ParseVehicleParm( vehicle, "weapMuzzle9", weapMuzzle9 ) )
+		{
+#ifndef FINAL_BUILD
+			Com_Printf( S_COLOR_RED"ERROR: Unknown Vehicle key/value pair 'weapMuzzle9', '%s'!\n", weapMuzzle9 );
+#endif
+		}
+	}
+	if ( weapMuzzle10[0] )
+	{
+		if ( !BG_ParseVehicleParm( vehicle, "weapMuzzle10", weapMuzzle10 ) )
+		{
+#ifndef FINAL_BUILD
+			Com_Printf( S_COLOR_RED"ERROR: Unknown Vehicle key/value pair 'weapMuzzle10', '%s'!\n", weapMuzzle10 );
+#endif
+		}
+	}
+
+#ifdef _JK2MP
+	//let's give these guys some defaults
+	if (!vehicle->health_front)
+	{
+		vehicle->health_front = vehicle->armor/4;
+	}
+	if (!vehicle->health_back)
+	{
+		vehicle->health_back = vehicle->armor/4;
+	}
+	if (!vehicle->health_right)
+	{
+		vehicle->health_right = vehicle->armor/4;
+	}
+	if (!vehicle->health_left)
+	{
+		vehicle->health_left = vehicle->armor/4;
+	}
+#endif
+
+	if ( vehicle->model )
+	{
+#ifdef QAGAME
+		vehicle->modelIndex = G_ModelIndex( va( "models/players/%s/model.glm", vehicle->model ) );
+#else
+		vehicle->modelIndex = trap_R_RegisterModel( va( "models/players/%s/model.glm", vehicle->model ) );
+#endif
+	}
+
+#ifndef _JK2MP
+	//SP
+	if ( vehicle->skin
+		&& vehicle->skin[0] )
+	{
+		ratl::string_vs<256>			skins(vehicle->skin);
+		for (ratl::string_vs<256>::tokenizer i = skins.begin("|"); i!=skins.end(); i++)
+		{
+			//this will just turn off surfs if there is a *off shader on a surf, the skin will actually get thrown away when cgame starts
+			gi.RE_RegisterSkin( va( "models/players/%s/model_%s.skin", vehicle->model, *i) );
+			//this is for the server-side call, it will propgate down to cgame with configstrings and register it at the same time as all the other skins for ghoul2 models
+			G_SkinIndex( va( "models/players/%s/model_%s.skin", vehicle->model, *i) );
+		}
+	}
+	else
+	{
+		//this will just turn off surfs if there is a *off shader on a surf, the skin will actually get thrown away when cgame starts
+		gi.RE_RegisterSkin( va( "models/players/%s/model_default.skin", vehicle->model) );
+		//this is for the server-side call, it will propgate down to cgame with configstrings and register it at the same time as all the other skins for ghoul2 models
+		G_SkinIndex( va( "models/players/%s/model_default.skin", vehicle->model) );
+	}
+#else
+#ifndef QAGAME
+	if ( vehicle->skin
+		&& vehicle->skin[0] )
+	{
+		trap_R_RegisterSkin( va( "models/players/%s/model_%s.skin", vehicle->model, vehicle->skin) );
+	}
+#endif
+#endif
+	//sanity check and clamp the vehicle's data
+	BG_VehicleClampData( vehicle );
+	// Setup the shared function pointers.
+	BG_SetSharedVehicleFunctions( vehicle );
+	//misc effects... FIXME: not even used in MP, are they?
+	if ( vehicle->explosionDamage )
+	{
+#ifdef QAGAME
+		G_EffectIndex( "ships/ship_explosion_mark" );
+#elif CGAME
+		trap_FX_RegisterEffect( "ships/ship_explosion_mark" );
+#endif
+	}
+	if ( vehicle->flammable )
+	{
+#ifdef QAGAME
+		G_SoundIndex( "sound/vehicles/common/fire_lp.wav" );
+#elif CGAME
+		trap_S_RegisterSound( "sound/vehicles/common/fire_lp.wav" );
+#else
+		trap_S_RegisterSound( "sound/vehicles/common/fire_lp.wav" );
+#endif
+	}
+
+	if ( vehicle->hoverHeight > 0 )
+	{
+#ifndef _JK2MP
+		G_EffectIndex( "ships/swoop_dust" );
+#elif QAGAME
+		G_EffectIndex( "ships/swoop_dust" );
+#elif CGAME
+		trap_FX_RegisterEffect( "ships/swoop_dust" );
+#endif
+	}
+
+#ifdef QAGAME
+	G_EffectIndex( "volumetric/black_smoke" );
+	G_EffectIndex( "ships/fire" );
+	G_SoundIndex( "sound/vehicles/common/release.wav" );
+#elif CGAME
+	trap_R_RegisterShader( "gfx/menus/radar/bracket" );
+	trap_R_RegisterShaderNoMip( "gfx/menus/radar/asteroid" );
+	trap_S_RegisterSound( "sound/vehicles/common/impactalarm.wav" );
+	trap_S_RegisterSound( "sound/vehicles/common/linkweaps.wav" );
+	trap_S_RegisterSound( "sound/vehicles/common/release.wav" );
+	trap_FX_RegisterEffect("effects/ships/dest_burning.efx");
+	trap_FX_RegisterEffect("effects/ships/dest_destroyed.efx");
+	trap_FX_RegisterEffect( "volumetric/black_smoke" );
+	trap_FX_RegisterEffect( "ships/fire" );
+	trap_FX_RegisterEffect("ships/hyperspace_stars");
+
+	if ( vehicle->hideRider )
+	{
+		trap_R_RegisterShaderNoMip( "gfx/menus/radar/circle_base" );
+		trap_R_RegisterShaderNoMip( "gfx/menus/radar/circle_base_frame" );
+		trap_R_RegisterShaderNoMip( "gfx/menus/radar/circle_base_shield" );
+	}
+#endif
+
+	return (numVehicles++);
+}
+
+int VEH_VehicleIndexForName( const char *vehicleName )
+{
+	int v;
+	if ( !vehicleName || !vehicleName[0] )
+	{
+		Com_Printf( S_COLOR_RED"ERROR: Trying to read Vehicle with no name!\n" );
+		return VEHICLE_NONE;
+	}
+	for (  v = VEHICLE_BASE; v < numVehicles; v++ )
+	{
+		if ( g_vehicleInfo[v].name
+			&& Q_stricmp( g_vehicleInfo[v].name, vehicleName ) == 0 )
+		{//already loaded this one
+			return v;
+		}
+	}
+	//haven't loaded it yet
+	if ( v >= MAX_VEHICLES )
+	{//no more room!
+		Com_Printf( S_COLOR_RED"ERROR: Too many Vehicles (max 64), aborting load on %s!\n", vehicleName );
+		return VEHICLE_NONE;
+	}
+	//we have room for another one, load it up and return the index
+	//HMM... should we not even load the .veh file until we want to?
+	v = VEH_LoadVehicle( vehicleName ); 
+ 	if ( v == VEHICLE_NONE )
+	{
+		Com_Printf( S_COLOR_RED"ERROR: Could not find Vehicle %s!\n", vehicleName );
+	}
+	return v;
+}
+
+void BG_VehWeaponLoadParms( void ) 
+{
+	int			len, totallen, vehExtFNLen, mainBlockLen, fileCnt, i;
+	char		*holdChar, *marker;
+	char		vehWeaponExtensionListBuf[2048];			//	The list of file names read in
+	fileHandle_t	f;
+	char		*tempReadBuffer;
+
+	len = 0;
+
+	//remember where to store the next one
+	totallen = mainBlockLen = len;
+	marker = VehWeaponParms+totallen;
+	*marker = 0;
+
+	//now load in the extra .veh extensions
+#ifdef _JK2MP
+	fileCnt = trap_FS_GetFileList("ext_data/vehicles/weapons", ".vwp", vehWeaponExtensionListBuf, sizeof(vehWeaponExtensionListBuf) );
+#else
+	fileCnt = gi.FS_GetFileList("ext_data/vehicles/weapons", ".vwp", vehWeaponExtensionListBuf, sizeof(vehWeaponExtensionListBuf) );
+#endif
+
+	holdChar = vehWeaponExtensionListBuf;
+
+#ifdef _JK2MP
+	tempReadBuffer = (char *)BG_TempAlloc(MAX_VEH_WEAPON_DATA_SIZE);
+#else
+	tempReadBuffer = (char *)gi.Malloc( MAX_VEH_WEAPON_DATA_SIZE, TAG_G_ALLOC, qtrue );
+#endif
+	
+	// NOTE: Not use TempAlloc anymore...
+	//Make ABSOLUTELY CERTAIN that BG_Alloc/etc. is not used before
+	//the subsequent BG_TempFree or the pool will be screwed. 
+
+	for ( i = 0; i < fileCnt; i++, holdChar += vehExtFNLen + 1 ) 
+	{
+		vehExtFNLen = strlen( holdChar );
+
+//		Com_Printf( "Parsing %s\n", holdChar );
+
+#ifdef _JK2MP
+		len = trap_FS_FOpenFile(va( "ext_data/vehicles/weapons/%s", holdChar), &f, FS_READ);
+#else
+//		len = gi.FS_ReadFile( va( "ext_data/vehicles/weapons/%s", holdChar), (void **) &buffer );
+		len = gi.FS_FOpenFile(va( "ext_data/vehicles/weapons/%s", holdChar), &f, FS_READ);
+#endif
+
+		if ( len == -1 ) 
+		{
+			Com_Printf( "error reading file\n" );
+		}
+		else
+		{
+#ifdef _JK2MP
+			trap_FS_Read(tempReadBuffer, len, f);
+			tempReadBuffer[len] = 0;
+#else
+			gi.FS_Read(tempReadBuffer, len, f);
+			tempReadBuffer[len] = 0;
+#endif
+
+			// Don't let it end on a } because that should be a stand-alone token.
+			if ( totallen && *(marker-1) == '}' )
+			{
+				strcat( marker, " " );
+				totallen++;
+				marker++; 
+			}
+
+			if ( totallen + len >= MAX_VEH_WEAPON_DATA_SIZE ) {
+				Com_Error(ERR_DROP, "Vehicle Weapon extensions (*.vwp) are too large" );
+			}
+			strcat( marker, tempReadBuffer );
+#ifdef _JK2MP
+			trap_FS_FCloseFile( f );
+#else
+			gi.FS_FCloseFile( f );
+#endif
+
+			totallen += len;
+			marker = VehWeaponParms+totallen;
+		}
+	}
+
+#ifdef _JK2MP
+	BG_TempFree(MAX_VEH_WEAPON_DATA_SIZE);
+#else
+	gi.Free(tempReadBuffer);	tempReadBuffer = NULL;
+#endif
+}
+
+void BG_VehicleLoadParms( void ) 
+{//HMM... only do this if there's a vehicle on the level?
+	int			len, totallen, vehExtFNLen, mainBlockLen, fileCnt, i;
+//	const char	*filename = "ext_data/vehicles.dat";
+	char		*holdChar, *marker;
+	char		vehExtensionListBuf[2048];			//	The list of file names read in
+	fileHandle_t	f;
+	char		*tempReadBuffer;
+
+	len = 0;
+
+	//remember where to store the next one
+	totallen = mainBlockLen = len;
+	marker = VehicleParms+totallen;
+	*marker = 0;
+
+	//now load in the extra .veh extensions
+#ifdef _JK2MP
+	fileCnt = trap_FS_GetFileList("ext_data/vehicles", ".veh", vehExtensionListBuf, sizeof(vehExtensionListBuf) );
+#else
+	fileCnt = gi.FS_GetFileList("ext_data/vehicles", ".veh", vehExtensionListBuf, sizeof(vehExtensionListBuf) );
+#endif
+
+	holdChar = vehExtensionListBuf;
+
+#ifdef _JK2MP
+	tempReadBuffer = (char *)BG_TempAlloc(MAX_VEHICLE_DATA_SIZE);
+#else
+	tempReadBuffer = (char *)gi.Malloc( MAX_VEHICLE_DATA_SIZE, TAG_G_ALLOC, qtrue );
+#endif
+	
+	// NOTE: Not use TempAlloc anymore...
+	//Make ABSOLUTELY CERTAIN that BG_Alloc/etc. is not used before
+	//the subsequent BG_TempFree or the pool will be screwed. 
+
+	for ( i = 0; i < fileCnt; i++, holdChar += vehExtFNLen + 1 ) 
+	{
+		vehExtFNLen = strlen( holdChar );
+
+//		Com_Printf( "Parsing %s\n", holdChar );
+
+#ifdef _JK2MP
+		len = trap_FS_FOpenFile(va( "ext_data/vehicles/%s", holdChar), &f, FS_READ);
+#else
+//		len = gi.FS_ReadFile( va( "ext_data/vehicles/%s", holdChar), (void **) &buffer );
+		len = gi.FS_FOpenFile(va( "ext_data/vehicles/%s", holdChar), &f, FS_READ);
+#endif
+
+		if ( len == -1 ) 
+		{
+			Com_Printf( "error reading file\n" );
+		}
+		else
+		{
+#ifdef _JK2MP
+			trap_FS_Read(tempReadBuffer, len, f);
+			tempReadBuffer[len] = 0;
+#else
+			gi.FS_Read(tempReadBuffer, len, f);
+			tempReadBuffer[len] = 0;
+#endif
+
+			// Don't let it end on a } because that should be a stand-alone token.
+			if ( totallen && *(marker-1) == '}' )
+			{
+				strcat( marker, " " );
+				totallen++;
+				marker++; 
+			}
+
+			if ( totallen + len >= MAX_VEHICLE_DATA_SIZE ) {
+				Com_Error(ERR_DROP, "Vehicle extensions (*.veh) are too large" );
+			}
+			strcat( marker, tempReadBuffer );
+#ifdef _JK2MP
+			trap_FS_FCloseFile( f );
+#else
+			gi.FS_FCloseFile( f );
+#endif
+
+			totallen += len;
+			marker = VehicleParms+totallen;
+		}
+	}
+
+#ifdef _JK2MP
+	BG_TempFree(MAX_VEHICLE_DATA_SIZE);
+#else
+	gi.Free(tempReadBuffer);	tempReadBuffer = NULL;
+#endif
+	
+	numVehicles = 1;//first one is null/default
+	//set the first vehicle to default data
+	BG_VehicleSetDefaults( &g_vehicleInfo[VEHICLE_BASE] );
+	//sanity check and clamp the vehicle's data
+	BG_VehicleClampData( &g_vehicleInfo[VEHICLE_BASE] );
+	// Setup the shared function pointers.
+	BG_SetSharedVehicleFunctions( &g_vehicleInfo[VEHICLE_BASE] );
+
+	//Load the Vehicle Weapons data, too
+	BG_VehWeaponLoadParms();
+}
+
+int BG_VehicleGetIndex( const char *vehicleName )
+{
+	return (VEH_VehicleIndexForName( vehicleName ));
+}
+
+//We get the vehicle name passed in as modelname
+//with a $ in front of it.
+//we are expected to then get the model for the
+//vehicle and stomp over modelname with it.
+void BG_GetVehicleModelName(char *modelname)
+{
+	char *vehName = &modelname[1];
+	int vIndex = BG_VehicleGetIndex(vehName);
+	assert(modelname[0] == '$');
+	
+	if (vIndex == VEHICLE_NONE)
+	{
+		Com_Error(ERR_DROP, "BG_GetVehicleModelName:  couldn't find vehicle %s", vehName);
+	}
+
+    strcpy(modelname, g_vehicleInfo[vIndex].model);	
+}
+
+void BG_GetVehicleSkinName(char *skinname)
+{
+	char *vehName = &skinname[1];
+	int vIndex = BG_VehicleGetIndex(vehName);
+	assert(skinname[0] == '$');
+	
+	if (vIndex == VEHICLE_NONE)
+	{
+		Com_Error(ERR_DROP, "BG_GetVehicleSkinName:  couldn't find vehicle %s", vehName);
+	}
+
+    if ( !g_vehicleInfo[vIndex].skin 
+		|| !g_vehicleInfo[vIndex].skin[0] )
+	{
+		skinname[0] = 0;
+	}
+	else
+	{
+		strcpy(skinname, g_vehicleInfo[vIndex].skin);	
+	}
+}
+
+#ifdef _JK2MP
+#ifndef WE_ARE_IN_THE_UI
+//so cgame can assign the function pointer for the vehicle attachment without having to
+//bother with all the other funcs that don't really exist cgame-side.
+extern int BG_GetTime(void);
+extern int trap_G2API_AddBolt(void *ghoul2, int modelIndex, const char *boneName);
+extern qboolean trap_G2API_GetBoltMatrix(void *ghoul2, const int modelIndex, const int boltIndex, mdxaBone_t *matrix,
+								const vec3_t angles, const vec3_t position, const int frameNum, qhandle_t *modelList, vec3_t scale);
+void AttachRidersGeneric( Vehicle_t *pVeh )
+{
+	// If we have a pilot, attach him to the driver tag.
+	if ( pVeh->m_pPilot )
+	{
+		mdxaBone_t boltMatrix;
+		vec3_t	yawOnlyAngles;
+		bgEntity_t *parent = pVeh->m_pParentEntity;
+		bgEntity_t *pilot = pVeh->m_pPilot;
+		int crotchBolt = trap_G2API_AddBolt(parent->ghoul2, 0, "*driver");
+
+		assert(parent->playerState);
+
+		VectorSet(yawOnlyAngles, 0, parent->playerState->viewangles[YAW], 0);
+
+		// Get the driver tag.
+		trap_G2API_GetBoltMatrix( parent->ghoul2, 0, crotchBolt, &boltMatrix,
+								yawOnlyAngles, parent->playerState->origin,
+								BG_GetTime(), NULL, parent->modelScale );
+		BG_GiveMeVectorFromMatrix( &boltMatrix, ORIGIN, pilot->playerState->origin );
+	}
+}
+#endif
+
+#include "../namespace_end.h"
+
+#endif // _JK2MP
+
diff --git a/code/game/bset.h b/code/game/bset.h
new file mode 100644
index 0000000..0fdfb60
--- /dev/null
+++ b/code/game/bset.h
@@ -0,0 +1,24 @@
+typedef enum //# bSet_e
+{//This should check to matching a behavior state name first, then look for a script
+	BSET_INVALID = -1,
+	BSET_FIRST = 0,
+	BSET_SPAWN = 0,//# script to use when first spawned
+	BSET_USE,//# script to use when used
+	BSET_AWAKE,//# script to use when awoken/startled
+	BSET_ANGER,//# script to use when aquire an enemy
+	BSET_ATTACK,//# script to run when you attack
+	BSET_VICTORY,//# script to run when you kill someone
+	BSET_LOSTENEMY,//# script to run when you can't find your enemy
+	BSET_PAIN,//# script to use when take pain
+	BSET_FLEE,//# script to use when take pain below 50% of health
+	BSET_DEATH,//# script to use when killed
+	BSET_DELAYED,//# script to run when self->delayScriptTime is reached
+	BSET_BLOCKED,//# script to run when blocked by a friendly NPC or player
+	BSET_BUMPED,//# script to run when bumped into a friendly NPC or player (can set bumpRadius)
+	BSET_STUCK,//# script to run when blocked by a wall
+	BSET_FFIRE,//# script to run when player shoots their own teammates
+	BSET_FFDEATH,//# script to run when player kills a teammate
+	BSET_MINDTRICK,//# script to run when player does a mind trick on this NPC
+
+	NUM_BSETS
+} bSet_t;
diff --git a/code/game/bstate.h b/code/game/bstate.h
new file mode 100644
index 0000000..b4f5f25
--- /dev/null
+++ b/code/game/bstate.h
@@ -0,0 +1,29 @@
+#ifndef __BSTATE_H__
+#define __BSTATE_H__
+
+//bstate.h
+typedef enum //# bState_e
+{//These take over only if script allows them to be autonomous
+	BS_DEFAULT = 0,//# default behavior for that NPC
+	BS_ADVANCE_FIGHT,//# Advance to captureGoal and shoot enemies if you can
+	BS_SLEEP,//# Play awake script when startled by sound
+	BS_FOLLOW_LEADER,//# Follow your leader and shoot any enemies you come across
+	BS_JUMP,//# Face navgoal and jump to it.
+	BS_SEARCH,//# Using current waypoint as a base, search the immediate branches of waypoints for enemies
+	BS_WANDER,//# Wander down random waypoint paths
+	BS_NOCLIP,//# Moves through walls, etc.
+	BS_REMOVE,//# Waits for player to leave PVS then removes itself
+	BS_CINEMATIC,//# Does nothing but face it's angles and move to a goal if it has one
+	BS_FLEE,//# Run away!
+	//# #eol
+	//internal bStates only
+	BS_WAIT,//# Does nothing but face it's angles
+	BS_STAND_GUARD,
+	BS_PATROL,
+	BS_INVESTIGATE,//# head towards temp goal and look for enemies and listen for sounds
+	BS_STAND_AND_SHOOT,
+	BS_HUNT_AND_KILL,
+	NUM_BSTATES
+} bState_t;
+
+#endif //#ifndef __BSTATE_H__
diff --git a/code/game/channels.h b/code/game/channels.h
new file mode 100644
index 0000000..8d3344c
--- /dev/null
+++ b/code/game/channels.h
@@ -0,0 +1,22 @@
+// These entries are now also duplicated in ModView, so tell me if you need any adding or removing.
+//  Note that the order is ok to change, I only read/write text strings of them anyway, but tell me if there
+//	are different choices to offer in the pulldown box. I know, it's tacky, but ModView wasn't planned as an
+//	editor and this was never an external file. A great combination...   - Ste.
+//
+typedef enum //# soundChannel_e
+{
+	CHAN_AUTO,	//## %s !!"W:\game\base\!!sound\*.wav;*.mp3" # Auto-picks an empty channel to play sound on
+	CHAN_LOCAL,	//## %s !!"W:\game\base\!!sound\*.wav;*.mp3" # menu sounds, etc
+	CHAN_WEAPON,//## %s !!"W:\game\base\!!sound\*.wav;*.mp3" 
+	CHAN_VOICE, //## %s !!"W:\game\base\!!sound\voice\*.wav;*.mp3" # Voice sounds cause mouth animation
+	CHAN_VOICE_ATTEN, //## %s !!"W:\game\base\!!sound\voice\*.wav;*.mp3" # Causes mouth animation but still use normal sound falloff 
+	CHAN_VOICE_GLOBAL,  //## %s !!"W:\game\base\!!sound\voice\*.wav;*.mp3" # Causes mouth animation and is broadcast with no separation
+	CHAN_ITEM,  //## %s !!"W:\game\base\!!sound\*.wav;*.mp3"
+	CHAN_BODY,	//## %s !!"W:\game\base\!!sound\*.wav;*.mp3"
+	CHAN_AMBIENT,//## %s !!"W:\game\base\!!sound\*.wav;*.mp3" # added for ambient sounds
+	CHAN_LOCAL_SOUND,	//## %s !!"W:\game\base\!!sound\*.wav;*.mp3" #chat messages, etc
+	CHAN_ANNOUNCER,		//## %s !!"W:\game\base\!!sound\*.wav;*.mp3" #announcer voices, etc
+	CHAN_LESS_ATTEN,	//## %s !!"W:\game\base\!!sound\*.wav;*.mp3" #attenuates similar to chan_voice, but uses empty channel auto-pick behaviour
+	CHAN_MUSIC,	//played as a looping sound - added by BTO (VV)
+} soundChannel_t;
+
diff --git a/code/game/characters.h b/code/game/characters.h
new file mode 100644
index 0000000..bc4af40
--- /dev/null
+++ b/code/game/characters.h
@@ -0,0 +1,52 @@
+typedef enum //# characters_e
+{
+	//HazTeam Alpha
+	//CHARACTER_MUNRO = 0,
+	CHARACTER_FOSTER = 0,
+	CHARACTER_TELSIA,
+	CHARACTER_BIESSMAN,
+	CHARACTER_CHANG,
+	CHARACTER_CHELL,
+	CHARACTER_JUROT,
+	//HazTeam Beta
+	CHARACTER_LAIRD,
+	CHARACTER_KENN,
+	CHARACTER_OVIEDO,
+	CHARACTER_ODELL,
+	CHARACTER_NELSON,
+	CHARACTER_JAWORSKI,
+	CHARACTER_CSATLOS,
+	//Senior Crew
+	CHARACTER_JANEWAY,
+	CHARACTER_CHAKOTAY,
+	CHARACTER_TUVOK,
+	CHARACTER_TUVOKHAZ,
+	CHARACTER_TORRES,
+	CHARACTER_PARIS,
+	CHARACTER_KIM,
+	CHARACTER_DOCTOR,
+	CHARACTER_SEVEN,
+	CHARACTER_SEVENHAZ,
+	CHARACTER_NEELIX,
+	//Other Crew
+	CHARACTER_PELLETIER,
+	//Generic Crew
+	CHARACTER_CREWMAN,
+	//CHARACTER_ENSIGN,
+	CHARACTER_LT,
+	CHARACTER_COMM,
+	CHARACTER_CAPT,
+	CHARACTER_GENERIC1,
+	CHARACTER_GENERIC2,
+	CHARACTER_GENERIC3,
+	CHARACTER_GENERIC4,
+	//# #eol
+	CHARACTER_NUM_CHARS
+} characters_t;
+
+typedef struct
+{
+	char	*name;
+	char	*sound;
+	sfxHandle_t		soundIndex;
+} characterName_t;
diff --git a/code/game/common_headers.h b/code/game/common_headers.h
new file mode 100644
index 0000000..b22c828
--- /dev/null
+++ b/code/game/common_headers.h
@@ -0,0 +1,26 @@
+#pragma once
+#if !defined(COMMON_HEADERS_H_INC)
+#define COMMON_HEADERS_H_INC
+
+#if !defined(__Q_SHARED_H)
+	#include "../game/q_shared.h"
+#endif
+
+//#if !defined(Q_SHAREDBASIC_H_INC)
+//	#include "../game/q_sharedbasic.h"			// fileHandle_t
+//#endif
+
+//#if !defined(Q_MATH_H_INC)
+//	#include "../game/q_math.h"
+//#endif
+
+#ifdef _XBOX
+#define GAME_INCLUDE
+	#include "../game/b_local.h"
+	#include "../cgame/cg_local.h"
+	#include "../game/g_navigator.h"
+	#include "../game/g_shared.h"
+	#include "../game/g_functions.h"
+#endif
+
+#endif // COMMON_HEADERS_H_INC
diff --git a/code/game/dmstates.h b/code/game/dmstates.h
new file mode 100644
index 0000000..c66a87a
--- /dev/null
+++ b/code/game/dmstates.h
@@ -0,0 +1,15 @@
+#ifndef __DMSTATES_H__
+#define __DMSTATES_H__
+
+//dynamic music
+typedef enum //# dynamicMusic_e
+{
+	DM_AUTO,	//# let the game determine the dynamic music as normal
+	DM_SILENCE,	//# stop the music
+	DM_EXPLORE,	//# force the exploration music to play
+	DM_ACTION,	//# force the action music to play
+	DM_BOSS,	//# force the boss battle music to play (if there is any)
+	DM_DEATH	//# force the "player dead" music to play
+} dynamicMusic_t;
+
+#endif//#ifndef __DMSTATES_H__
diff --git a/code/game/events.h b/code/game/events.h
new file mode 100644
index 0000000..ed4973c
--- /dev/null
+++ b/code/game/events.h
@@ -0,0 +1,10 @@
+#ifndef __EVENTS__
+#define __EVENTS__
+
+typedef enum //# eventType_e
+{
+	EV_BAD = 0,
+
+} eventType_t;	
+
+#endif	//__EVENTS__
\ No newline at end of file
diff --git a/code/game/fields.h b/code/game/fields.h
new file mode 100644
index 0000000..289c2e5
--- /dev/null
+++ b/code/game/fields.h
@@ -0,0 +1,64 @@
+// Filename:-	fields.h
+//
+
+#ifndef FIELDS_H
+#define FIELDS_H
+
+//
+// fields are needed for spawning from the entity string
+// and saving / loading games
+//
+#define FFL_SPAWNTEMP		1
+#define MAX_GHOULINST_SIZE	16384
+
+#ifndef FOFS
+#define	FOFS(x) ((int)&(((gentity_t *)0)->x))	// usually already defined in qshared.h
+#endif
+#define	STOFS(x) ((int)&(((spawn_temp_t *)0)->x))
+#define	LLOFS(x) ((int)&(((level_locals_t *)0)->x))
+#define	CLOFS(x) ((int)&(((gclient_t *)0)->x))
+#define NPCOFS(x) ((int)&(((gNPC_t *)0)->x)) 
+#define VHOFS(x) ((int)&(((Vehicle_t *)0)->x)) 
+
+//
+#define strFOFS(x)	 #x,FOFS(x)
+#define	strSTOFS(x)  #x,STOFS(x)
+#define	strLLOFS(x)	 #x,LLOFS(x)	
+#define	strCLOFS(x)  #x,CLOFS(x)
+#define strNPCOFS(x) #x,NPCOFS(x)
+#define strVHICOFS(x) #x,VHOFS(x)
+
+typedef enum
+{
+//	F_INT, 
+//	F_SHORT,
+//	F_FLOAT,
+	F_STRING,		// string
+//	F_VECTOR,
+	F_NULL,				// A ptr to null out
+	F_ITEM,				// Item pointer handling
+//	F_MMOVE,			// Mmove pointer handling
+	F_GCLIENT,			// Client pointer handling
+	F_GENTITY,			// gentity_t ptr handling
+	F_BOOLPTR,			// Generic pointer that is recreated later, could be left alone, but clearer if only 0/1 rather than 0/alloc
+
+	F_BEHAVIORSET,		// special scripting string ptr array handler	
+	F_ALERTEVENT,		// special handler for alertevent struct in level_locals_t
+	F_AIGROUPS,			// some AI grouping stuff of Mike's
+	F_ANIMFILESETS,		// animfileset animevent strings
+
+	F_GROUP,
+	F_VEHINFO,
+	F_IGNORE
+} fieldtypeSAVE_t;
+
+typedef struct
+{
+	char	*psName;
+	int		iOffset;
+	fieldtypeSAVE_t	eFieldType;
+} save_field_t;
+
+#endif	// #ifndef FIELDS_H
+
+//////////////////////// eof //////////////////////////
\ No newline at end of file
diff --git a/code/game/g_active.cpp b/code/game/g_active.cpp
new file mode 100644
index 0000000..18901e0
--- /dev/null
+++ b/code/game/g_active.cpp
@@ -0,0 +1,5780 @@
+// leave this line at the top for all g_xxxx.cpp files...
+#include "g_headers.h"
+
+
+#include "g_local.h"
+#include "g_functions.h"
+#include "..\cgame\cg_local.h"
+#include "Q3_Interface.h"
+#include "wp_saber.h"
+#include "g_vehicles.h"
+
+#ifdef _DEBUG
+	#include <float.h>
+#endif //_DEBUG
+
+#define	SLOWDOWN_DIST	128.0f
+#define	MIN_NPC_SPEED	16.0f
+
+#ifdef _XBOX
+int g_lastFireTime = 0;
+#endif
+extern void VehicleExplosionDelay( gentity_t *self );
+extern qboolean Q3_TaskIDPending( gentity_t *ent, taskID_t taskType );
+extern void G_MaintainFormations(gentity_t *self);
+extern void BG_CalculateOffsetAngles( gentity_t *ent, usercmd_t *ucmd );//in bg_pangles.cpp
+extern void TryUse( gentity_t *ent );
+extern void ChangeWeapon( gentity_t *ent, int newWeapon );
+extern void ScoreBoardReset(void);
+extern void WP_SaberReflectCheck( gentity_t *self, usercmd_t *ucmd  );
+extern void WP_SaberUpdate( gentity_t *self, usercmd_t *ucmd );
+extern void WP_SaberStartMissileBlockCheck( gentity_t *self, usercmd_t *ucmd  );
+extern void WP_ForcePowersUpdate( gentity_t *self, usercmd_t *ucmd );
+extern gentity_t *SeekerAcquiresTarget ( gentity_t *ent, vec3_t pos );
+extern void FireSeeker( gentity_t *owner, gentity_t *target, vec3_t origin, vec3_t dir );
+extern qboolean InFront( vec3_t spot, vec3_t from, vec3_t fromAngles, float threshHold = 0.0f );
+extern float DotToSpot( vec3_t spot, vec3_t from, vec3_t fromAngles );
+extern void NPC_SetLookTarget( gentity_t *self, int entNum, int clearTime );
+extern qboolean PM_LockAngles( gentity_t *ent, usercmd_t *ucmd );
+extern qboolean PM_AdjustAnglesToGripper( gentity_t *gent, usercmd_t *cmd );
+extern qboolean PM_AdjustAnglesToPuller( gentity_t *ent, gentity_t *puller, usercmd_t *ucmd, qboolean faceAway );
+extern qboolean PM_AdjustAngleForWallRun( gentity_t *ent, usercmd_t *ucmd, qboolean doMove );
+extern qboolean PM_AdjustAngleForWallRunUp( gentity_t *ent, usercmd_t *ucmd, qboolean doMove );
+extern qboolean PM_AdjustAnglesForSpinningFlip( gentity_t *ent, usercmd_t *ucmd, qboolean anglesOnly );
+extern qboolean PM_AdjustAnglesForBackAttack( gentity_t *ent, usercmd_t *ucmd );
+extern qboolean PM_AdjustAnglesForSaberLock( gentity_t *ent, usercmd_t *ucmd );
+extern qboolean PM_AdjustAnglesForKnockdown( gentity_t *ent, usercmd_t *ucmd, qboolean angleClampOnly );
+extern qboolean PM_AdjustAnglesForDualJumpAttack( gentity_t *ent, usercmd_t *ucmd );
+extern qboolean PM_AdjustAnglesForLongJump( gentity_t *ent, usercmd_t *ucmd );
+extern qboolean PM_AdjustAnglesForGrapple( gentity_t *ent, usercmd_t *ucmd );
+extern qboolean PM_AdjustAngleForWallJump( gentity_t *ent, usercmd_t *ucmd, qboolean doMove );
+extern qboolean PM_AdjustAnglesForBFKick( gentity_t *ent, usercmd_t *ucmd, vec3_t fwdAngs, qboolean aimFront );
+extern qboolean PM_AdjustAnglesForStabDown( gentity_t *ent, usercmd_t *ucmd );
+extern qboolean PM_AdjustAnglesForSpinProtect( gentity_t *ent, usercmd_t *ucmd );
+extern qboolean PM_AdjustAnglesForWallRunUpFlipAlt( gentity_t *ent, usercmd_t *ucmd );
+extern qboolean PM_AdjustAnglesForHeldByMonster( gentity_t *ent, gentity_t *monster, usercmd_t *ucmd );
+extern qboolean PM_HasAnimation( gentity_t *ent, int animation );
+extern qboolean PM_LeapingSaberAnim( int anim );
+extern qboolean PM_SpinningSaberAnim( int anim );
+extern qboolean PM_SaberInAttack( int move );
+extern qboolean PM_KickingAnim( int anim );
+extern int PM_AnimLength( int index, animNumber_t anim );
+extern qboolean PM_InKnockDown( playerState_t *ps );
+extern qboolean PM_InGetUp( playerState_t *ps );
+extern qboolean PM_InRoll( playerState_t *ps );
+extern void PM_CmdForRoll( playerState_t *ps, usercmd_t *pCmd );
+extern qboolean PM_InAttackRoll( int anim );
+extern qboolean PM_CrouchAnim( int anim );
+extern qboolean PM_FlippingAnim( int anim );
+extern qboolean PM_InCartwheel( int anim );
+extern qboolean PM_StandingAnim( int anim );
+extern qboolean PM_InForceGetUp( playerState_t *ps );
+extern qboolean PM_GetupAnimNoMove( int legsAnim );
+extern qboolean PM_SuperBreakLoseAnim( int anim );
+extern qboolean PM_SuperBreakWinAnim( int anim );
+extern qboolean PM_CanRollFromSoulCal( playerState_t *ps );
+extern qboolean BG_FullBodyTauntAnim( int anim );
+extern qboolean FlyingCreature( gentity_t *ent );
+extern Vehicle_t *G_IsRidingVehicle( gentity_t *ent );
+extern void G_AttachToVehicle( gentity_t *ent, usercmd_t **ucmd );
+extern void G_GetBoltPosition( gentity_t *self, int boltIndex, vec3_t pos, int modelIndex = 0 );
+extern void G_UpdateEmplacedWeaponData( gentity_t *ent );
+extern void RunEmplacedWeapon( gentity_t *ent, usercmd_t **ucmd );
+extern qboolean G_PointInBounds( const vec3_t point, const vec3_t mins, const vec3_t maxs );
+extern void NPC_SetPainEvent( gentity_t *self );
+extern qboolean G_HasKnockdownAnims( gentity_t *ent );
+extern int G_GetEntsNearBolt( gentity_t *self, gentity_t **radiusEnts, float radius, int boltIndex, vec3_t boltOrg );
+extern qboolean PM_InOnGroundAnim ( playerState_t *ps );
+extern qboolean PM_LockedAnim( int anim );
+extern qboolean WP_SabersCheckLock2( gentity_t *attacker, gentity_t *defender, sabersLockMode_t lockMode );
+extern qboolean G_JediInNormalAI( gentity_t *ent );
+
+extern bool		in_camera;
+extern qboolean	player_locked;
+extern qboolean	stop_icarus;
+extern qboolean	MatrixMode;
+
+extern cvar_t	*g_spskill;
+extern cvar_t	*g_timescale;
+extern cvar_t	*g_saberMoveSpeed;
+extern cvar_t	*g_saberAutoBlocking;
+extern cvar_t	*g_speederControlScheme;
+extern cvar_t	*d_slowmodeath;
+extern cvar_t	*g_debugMelee;
+extern vmCvar_t	cg_thirdPersonAlpha;
+extern vmCvar_t	cg_thirdPersonAutoAlpha;
+
+void ClientEndPowerUps( gentity_t *ent );
+
+int G_FindLookItem( gentity_t *self )
+{
+//FIXME: should be a more intelligent way of doing this, like auto aim?
+//closest, most in front... did damage to... took damage from?  How do we know who the player is focusing on?
+	gentity_t	*ent;
+	int			bestEntNum = ENTITYNUM_NONE;
+	gentity_t	*entityList[MAX_GENTITIES];
+	int			numListedEntities;
+	vec3_t		center, mins, maxs, fwdangles, forward, dir;
+	int			i, e;
+	float		radius = 256;
+	float		rating, bestRating = 0.0f;
+
+	//FIXME: no need to do this in 1st person?
+	fwdangles[1] = self->client->ps.viewangles[1];
+	AngleVectors( fwdangles, forward, NULL, NULL );
+
+	VectorCopy( self->currentOrigin, center );
+
+	for ( i = 0 ; i < 3 ; i++ ) 
+	{
+		mins[i] = center[i] - radius;
+		maxs[i] = center[i] + radius;
+	}
+	numListedEntities = gi.EntitiesInBox( mins, maxs, entityList, MAX_GENTITIES );
+	
+	if ( !numListedEntities )
+	{
+		return ENTITYNUM_NONE;
+	}
+
+	for ( e = 0 ; e < numListedEntities ; e++ ) 
+	{
+		ent = entityList[ e ];
+
+		if ( !ent->item )
+		{
+			continue;
+		}
+		if ( ent->s.eFlags&EF_NODRAW )
+		{
+			continue;
+		}
+		if ( (ent->spawnflags&4/*ITMSF_MONSTER*/) )
+		{//NPCs only
+			continue;
+		}
+		if ( !BG_CanItemBeGrabbed( &ent->s, &self->client->ps ) )
+		{//don't need it
+			continue;
+		}
+		if ( !gi.inPVS( self->currentOrigin, ent->currentOrigin ) )
+		{//not even potentially visible
+			continue;
+		}
+
+		if ( !G_ClearLOS( self, self->client->renderInfo.eyePoint, ent ) )
+		{//can't see him
+			continue;
+		}
+		//rate him based on how close & how in front he is
+		VectorSubtract( ent->currentOrigin, center, dir );
+		rating = (1.0f-(VectorNormalize( dir )/radius));
+		rating *= DotProduct( forward, dir );
+		if ( ent->item->giType == IT_HOLDABLE && ent->item->giTag == INV_SECURITY_KEY )
+		{//security keys are of the highest importance
+			rating *= 2.0f;
+		}
+		if ( rating > bestRating )
+		{
+			bestEntNum = ent->s.number;
+			bestRating = rating;
+		}
+	}
+	return bestEntNum;
+}
+
+extern void CG_SetClientViewAngles( vec3_t angles, qboolean overrideViewEnt );
+qboolean G_ClearViewEntity( gentity_t *ent )
+{
+	if ( !ent->client->ps.viewEntity )
+		return qfalse;
+
+	if ( ent->client->ps.viewEntity > 0 && ent->client->ps.viewEntity < ENTITYNUM_NONE )
+	{
+		if ( &g_entities[ent->client->ps.viewEntity] )
+		{
+			g_entities[ent->client->ps.viewEntity].svFlags &= ~SVF_BROADCAST;
+			if ( g_entities[ent->client->ps.viewEntity].NPC )
+			{
+				g_entities[ent->client->ps.viewEntity].NPC->controlledTime = 0;
+				SetClientViewAngle( &g_entities[ent->client->ps.viewEntity], g_entities[ent->client->ps.viewEntity].currentAngles );
+				G_SetAngles( &g_entities[ent->client->ps.viewEntity], g_entities[ent->client->ps.viewEntity].currentAngles );
+				VectorCopy( g_entities[ent->client->ps.viewEntity].currentAngles, g_entities[ent->client->ps.viewEntity].NPC->lastPathAngles );
+				g_entities[ent->client->ps.viewEntity].NPC->desiredYaw = g_entities[ent->client->ps.viewEntity].currentAngles[YAW];
+			}
+		}
+		CG_SetClientViewAngles( ent->pos4, qtrue );
+		SetClientViewAngle( ent, ent->pos4 );
+	}
+	ent->client->ps.viewEntity = 0;
+	return qtrue;
+}
+
+void G_SetViewEntity( gentity_t *self, gentity_t *viewEntity )
+{
+	if ( !self || !self->client || !viewEntity )
+	{
+		return;
+	}
+
+	if ( self->s.number == 0 && cg.zoomMode )
+	{
+		// yeah, it should really toggle them so it plays the end sound....
+		cg.zoomMode = 0;
+	}
+	if ( viewEntity->s.number == self->client->ps.viewEntity )
+	{
+		return;
+	}
+	//clear old one first
+	G_ClearViewEntity( self );
+	//set new one
+	self->client->ps.viewEntity = viewEntity->s.number;
+	viewEntity->svFlags |= SVF_BROADCAST;
+	//remember current angles
+	VectorCopy( self->client->ps.viewangles, self->pos4 );
+	if ( viewEntity->client )
+	{
+		//vec3_t	clear = {0,0,0};
+		CG_SetClientViewAngles( viewEntity->client->ps.viewangles, qtrue );
+		//SetClientViewAngle( self, viewEntity->client->ps.viewangles );
+		//SetClientViewAngle( viewEntity, clear );
+		/*
+		VectorCopy( viewEntity->client->ps.viewangles, self->client->ps.viewangles );
+		for ( int i = 0; i < 3; i++ )
+		{
+			self->client->ps.delta_angles[i] = viewEntity->client->ps.delta_angles[i];
+		}
+		*/
+	}
+	if ( !self->s.number )
+	{
+		CG_CenterPrint( "@SP_INGAME_EXIT_VIEW", SCREEN_HEIGHT * 0.95 );
+	}
+}
+
+qboolean G_ControlledByPlayer( gentity_t *self )
+{
+	if ( self && self->NPC && self->NPC->controlledTime > level.time )
+	{//being controlled
+		gentity_t *controller = &g_entities[0];
+		if ( controller->client && controller->client->ps.viewEntity == self->s.number )
+		{//we're the player's viewEntity
+			return qtrue;
+		}
+	}
+	return qfalse;
+}
+
+qboolean G_ValidateLookEnemy( gentity_t *self, gentity_t *enemy )
+{
+	if ( !enemy )
+	{
+		return qfalse;
+	}
+
+	if ( enemy->flags&FL_NOTARGET )
+	{
+		return qfalse;
+	}
+
+	if ( (enemy->s.eFlags&EF_NODRAW) )
+	{
+		return qfalse;
+	}
+
+	if ( !enemy || enemy == self || !enemy->inuse )
+	{
+		return qfalse;
+	}
+	if ( !enemy->client || !enemy->NPC )
+	{//not valid
+		if ( (enemy->svFlags&SVF_NONNPC_ENEMY) 
+			&& enemy->s.weapon == WP_TURRET 
+			&& enemy->noDamageTeam != self->client->playerTeam
+			&& enemy->health > 0 )
+		{//a turret
+			//return qtrue;
+		}
+		else
+		{
+			return qfalse;
+		}
+	}
+	else 
+	{
+		if ( self->client->playerTeam != TEAM_FREE//evil player hates everybody
+			&& enemy->client->playerTeam == self->client->playerTeam )
+		{//on same team
+			return qfalse;
+		}
+
+		Vehicle_t *pVeh = G_IsRidingVehicle( self );
+		if ( pVeh && pVeh == enemy->m_pVehicle )
+		{
+			return qfalse;
+		}
+
+		if ( enemy->health <= 0 && ((level.time-enemy->s.time) > 3000||!InFront(enemy->currentOrigin,self->currentOrigin,self->client->ps.viewangles,0.2f)||DistanceHorizontal(enemy->currentOrigin,self->currentOrigin)>16384))//>128
+		{//corpse, been dead too long or too out of sight to be interesting
+			if ( !enemy->message )
+			{
+				return qfalse;
+			}
+		}
+	}
+
+	if ( (!InFront( enemy->currentOrigin, self->currentOrigin, self->client->ps.viewangles, 0.0f) || !G_ClearLOS( self, self->client->renderInfo.eyePoint, enemy ) ) 
+		&& ( DistanceHorizontalSquared( enemy->currentOrigin, self->currentOrigin ) > 65536 || fabs(enemy->currentOrigin[2]-self->currentOrigin[2]) > 384 )  )
+	{//(not in front or not clear LOS) & greater than 256 away
+		return qfalse;
+	}
+
+	//LOS?
+
+	return qtrue;
+}
+
+void G_ChooseLookEnemy( gentity_t *self, usercmd_t *ucmd )
+{
+//FIXME: should be a more intelligent way of doing this, like auto aim?
+//closest, most in front... did damage to... took damage from?  How do we know who the player is focusing on?
+	gentity_t	*ent, *bestEnt = NULL;
+	gentity_t	*entityList[MAX_GENTITIES];
+	int			numListedEntities;
+	vec3_t		center, mins, maxs, fwdangles, forward, dir;
+	int			i, e;
+	float		radius = 256;
+	float		rating, bestRating = 0.0f;
+
+	//FIXME: no need to do this in 1st person?
+	fwdangles[0] = 0;		//Must initialize data!
+	fwdangles[1] = self->client->ps.viewangles[1];
+	fwdangles[2] = 0;
+	AngleVectors( fwdangles, forward, NULL, NULL );
+
+	VectorCopy( self->currentOrigin, center );
+
+	for ( i = 0 ; i < 3 ; i++ ) 
+	{
+		mins[i] = center[i] - radius;
+		maxs[i] = center[i] + radius;
+	}
+	numListedEntities = gi.EntitiesInBox( mins, maxs, entityList, MAX_GENTITIES );
+	
+	if ( !numListedEntities )
+	{//should we clear the enemy?
+		return;
+	}
+
+	for ( e = 0 ; e < numListedEntities ; e++ ) 
+	{
+		ent = entityList[ e ];
+
+		if ( !gi.inPVS( self->currentOrigin, ent->currentOrigin ) )
+		{//not even potentially visible
+			continue;
+		}
+
+		if ( !G_ValidateLookEnemy( self, ent ) )
+		{//doesn't meet criteria of valid look enemy (don't check current since we would have done that before this func's call
+			continue;
+		}
+
+		if ( !G_ClearLOS( self, self->client->renderInfo.eyePoint, ent ) )
+		{//can't see him
+			continue;
+		}
+		//rate him based on how close & how in front he is
+		VectorSubtract( ent->currentOrigin, center, dir );
+		rating = (1.0f-(VectorNormalize( dir )/radius));
+		rating *= DotProduct( forward, dir )+1.0f;
+		if ( ent->health <= 0 )
+		{
+			if ( (ucmd->buttons&BUTTON_ATTACK) 
+				|| (ucmd->buttons&BUTTON_ALT_ATTACK) 
+				|| (ucmd->buttons&BUTTON_FORCE_FOCUS) )
+			{//if attacking, don't consider dead enemies
+				continue;
+			}
+			if ( ent->message )
+			{//keyholder
+				rating *= 0.5f;
+			}
+			else
+			{
+				rating *= 0.1f;
+			}
+		}
+		if ( ent->s.weapon == WP_SABER )
+		{
+			rating *= 2.0f;
+		}
+		if ( ent->enemy == self )
+		{//he's mad at me, he's more important
+			rating *= 2.0f;
+		}
+		else if ( ent->NPC && ent->NPC->blockedSpeechDebounceTime > level.time - 6000 )
+		{//he's detected me, he's more important
+			if ( ent->NPC->blockedSpeechDebounceTime > level.time + 4000 )
+			{
+				rating *= 1.5f;
+			}
+			else
+			{//from 1.0f to 1.5f
+				rating += rating * ((float)(ent->NPC->blockedSpeechDebounceTime-level.time) + 6000.0f)/20000.0f;
+			}
+		}
+		/*
+		if ( g_crosshairEntNum == ent && !self->enemy )
+		{//we don't have an enemy and we are aiming at this guy
+			rading *= 2.0f;
+		}
+		*/
+		if ( rating > bestRating )
+		{
+			bestEnt = ent;
+			bestRating = rating;
+		}
+	}
+	if ( bestEnt )
+	{
+		self->enemy = bestEnt;
+	}
+}
+
+/*
+===============
+G_DamageFeedback
+
+Called just before a snapshot is sent to the given player.
+Totals up all damage and generates both the player_state_t
+damage values to that client for pain blends and kicks, and
+global pain sound events for all clients.
+===============
+*/
+void P_DamageFeedback( gentity_t *player ) {
+	gclient_t	*client;
+	float	count;
+	vec3_t	angles;
+
+	client = player->client;
+	if ( client->ps.pm_type == PM_DEAD ) {
+		return;
+	}
+
+	// total points of damage shot at the player this frame
+	count = client->damage_blood + client->damage_armor;
+	if ( count == 0 ) {
+		return;		// didn't take any damage
+	}
+
+	if ( count > 255 ) {
+		count = 255;
+	}
+
+	// send the information to the client
+
+	// world damage (falling, slime, etc) uses a special code
+	// to make the blend blob centered instead of positional
+	if ( client->damage_fromWorld ) 
+	{
+		client->ps.damagePitch = 255;
+		client->ps.damageYaw = 255;
+
+		client->damage_fromWorld = false;
+	} 
+	else 
+	{
+		vectoangles( client->damage_from, angles );
+		client->ps.damagePitch = angles[PITCH]/360.0 * 256;
+		client->ps.damageYaw = angles[YAW]/360.0 * 256;
+	}
+
+	client->ps.damageCount = count;
+
+	//
+	// clear totals
+	//
+	client->damage_blood = 0;
+	client->damage_armor = 0;
+}
+
+
+
+/*
+=============
+P_WorldEffects
+
+Check for lava / slime contents and drowning
+=============
+*/
+
+extern void WP_ForcePowerStart( gentity_t *self, forcePowers_t forcePower, int overrideAmt );
+void P_WorldEffects( gentity_t *ent ) {
+	int			mouthContents = 0;
+
+	if ( ent->client->noclip ) 
+	{
+		ent->client->airOutTime = level.time + 12000;	// don't need air
+		return;
+	}
+
+	if ( !in_camera )
+	{
+#ifndef _XBOX
+		if (gi.totalMapContents() & (CONTENTS_WATER|CONTENTS_SLIME))
+		{
+			mouthContents = gi.pointcontents( ent->client->renderInfo.eyePoint, ent->s.number );
+		}
+#endif // _XBOX
+	}
+	//
+	// check for drowning
+	//
+
+#ifdef _XBOX
+	// using waterlevel 3 should be good enough
+	// this saves us from doing an expensive trace
+	if ( ent->waterlevel == 3 )
+#else
+	if ( (mouthContents&(CONTENTS_WATER|CONTENTS_SLIME)) ) 
+#endif // _XBOX
+	{
+
+		if ( ent->client->NPC_class == CLASS_SWAMPTROOPER )
+		{//they have air tanks
+			ent->client->airOutTime = level.time + 12000;	// don't need air
+			ent->damage = 2;
+		}
+		else if ( ent->client->airOutTime < level.time) 
+		{// if out of air, start drowning
+			// drown!
+			ent->client->airOutTime += 1000;
+			if ( ent->health > 0 ) {
+				// take more damage the longer underwater
+				ent->damage += 2;
+				if (ent->damage > 15)
+					ent->damage = 15;
+
+				// play a gurp sound instead of a normal pain sound
+				if (ent->health <= ent->damage) 
+				{
+					G_AddEvent( ent, EV_WATER_DROWN, 0 );
+				} 
+				else
+				{
+					G_AddEvent( ent, Q_irand(EV_WATER_GURP1, EV_WATER_GURP2), 0 );
+				} 
+
+				// don't play a normal pain sound
+				ent->painDebounceTime = level.time + 200;
+
+				G_Damage (ent, NULL, NULL, NULL, NULL, 
+					ent->damage, DAMAGE_NO_ARMOR, MOD_WATER);
+			}
+		}
+	} 
+	else 
+	{
+		ent->client->airOutTime = level.time + 12000;
+		ent->damage = 2;
+	}
+
+	//
+	// check for sizzle damage (move to pmove?)
+	//
+	if (ent->waterlevel && 
+		(ent->watertype&(CONTENTS_LAVA|CONTENTS_SLIME)) ) {
+		if (ent->health > 0
+			&& ent->painDebounceTime < level.time	) {
+
+			if (ent->watertype & CONTENTS_LAVA) {
+				G_Damage (ent, NULL, NULL, NULL, NULL, 
+					15*ent->waterlevel, 0, MOD_LAVA);
+			}
+
+			if (ent->watertype & CONTENTS_SLIME) {
+				G_Damage (ent, NULL, NULL, NULL, NULL, 
+					1, 0, MOD_SLIME);
+			}
+		}
+	}
+
+	if ((ent->health > 0) && 
+		(ent->painDebounceTime < level.time) && 
+		gi.WE_IsOutsideCausingPain(ent->currentOrigin) &&
+		TIMER_Done(ent, "AcidPainDebounce"))
+	{
+		if (ent->NPC && ent->client && (ent->client->ps.forcePowersKnown&(1<< FP_PROTECT)))
+		{
+			if (!(ent->client->ps.forcePowersActive & (1<<FP_PROTECT)))
+			{
+				WP_ForcePowerStart( ent, FP_PROTECT, 0 );
+			}
+		}
+		else
+		{
+			G_Damage (ent, NULL, NULL, NULL, NULL, 1, 0, MOD_SLIME);
+		}
+	}
+
+	// Poisoned?
+	if ((ent->client->poisonDamage) && (ent->client->poisonTime < level.time))
+	{
+		ent->client->poisonDamage -= 2;
+		ent->client->poisonTime = level.time + 1000;
+		G_Damage( ent, NULL, NULL, 0, 0, 2, DAMAGE_NO_KNOCKBACK|DAMAGE_NO_ARMOR, MOD_UNKNOWN );//FIXME: MOD_POISON?
+
+		if (ent->client->poisonDamage<0)
+		{
+			ent->client->poisonDamage = 0;
+		}
+	}
+
+	//in space?
+	if (ent->client->inSpaceIndex && ent->client->inSpaceIndex != ENTITYNUM_NONE)
+	{ //we're in space, check for suffocating and for exiting
+        gentity_t *spacetrigger = &g_entities[ent->client->inSpaceIndex];
+
+		if (!spacetrigger->inuse ||
+			!G_PointInBounds(ent->client->ps.origin, spacetrigger->absmin, spacetrigger->absmax))
+		{ //no longer in space then I suppose
+            ent->client->inSpaceIndex = 0;					
+		}
+		else
+		{ //check for suffocation
+            if (ent->client->inSpaceSuffocation < level.time)
+			{ //suffocate!
+				if (ent->health > 0)
+				{ //if they're still alive..
+					G_Damage(ent, spacetrigger, spacetrigger, NULL, ent->client->ps.origin, Q_irand(20, 40), DAMAGE_NO_ARMOR, MOD_SUICIDE);
+
+					if (ent->health > 0)
+					{ //did that last one kill them?
+						//play the choking sound
+						G_SoundOnEnt( ent, CHAN_VOICE, va( "*choke%d.wav", Q_irand( 1, 3 ) ) );
+
+						int anim = BOTH_CHOKE3; //left-handed choke
+						if ( ent->client->ps.weapon == WP_NONE || ent->client->ps.weapon == WP_MELEE )
+						{
+							anim = BOTH_CHOKE1; //two-handed choke
+						}
+						//make them grasp their throat
+						NPC_SetAnim( ent, SETANIM_BOTH, BOTH_CHOKE1, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+					}
+				}
+
+				ent->client->inSpaceSuffocation = level.time + Q_irand(1000, 2000);
+			}
+		}
+	}
+
+
+}
+
+
+
+/*
+===============
+G_SetClientSound
+===============
+*/
+void G_SetClientSound( gentity_t *ent ) {
+//	if (ent->waterlevel && (ent->watertype&(CONTENTS_LAVA|CONTENTS_SLIME)) )
+//		ent->s.loopSound = G_SoundIndex("sound/weapons/stasis/electricloop.wav");
+
+//	else
+//		ent->s.loopSound = 0;
+}
+
+
+
+//==============================================================
+extern void G_Knockdown( gentity_t *self, gentity_t *attacker, const vec3_t pushDir, float strength, qboolean breakSaberLock );
+extern void G_StartMatrixEffect( gentity_t *ent, int meFlags = 0, int length = 1000, float timeScale = 0.0f, int spinTime = 0 );
+void G_GetMassAndVelocityForEnt( gentity_t *ent, float *mass, vec3_t velocity )
+{
+	if( ent->client )
+	{
+		VectorCopy( ent->client->ps.velocity, velocity );
+		*mass = ent->mass;
+	}
+	else 
+	{
+		VectorCopy( ent->s.pos.trDelta, velocity );
+		if ( ent->s.pos.trType == TR_GRAVITY )
+		{
+			velocity[2] -= 0.25f * g_gravity->value;
+		}
+		if( !ent->mass )
+		{
+			*mass = 1;
+		}
+		else if ( ent->mass <= 10 )
+		{
+			*mass = 10;
+		}
+		else
+		{
+			*mass = ent->mass;///10;
+		}
+	}
+}
+
+void DoImpact( gentity_t *self, gentity_t *other, qboolean damageSelf, trace_t *trace )
+{
+	float magnitude, my_mass;
+	bool	thrown = false;
+	vec3_t	velocity;
+
+	Vehicle_t *pSelfVeh = NULL;
+	Vehicle_t *pOtherVeh = NULL;
+
+	// See if either of these guys are vehicles, if so, keep a pointer to the vehicle npc.
+	if ( self->client && self->client->NPC_class == CLASS_VEHICLE )
+	{
+		pSelfVeh = self->m_pVehicle;
+	}
+	if ( other->client && other->client->NPC_class == CLASS_VEHICLE )
+	{
+		pOtherVeh = other->m_pVehicle;
+	}
+
+	G_GetMassAndVelocityForEnt( self, &my_mass, velocity );
+
+	if ( pSelfVeh )
+	{
+		magnitude = VectorLength( velocity ) * pSelfVeh->m_pVehicleInfo->mass / 50.0f;
+	}
+	else
+	{
+		magnitude = VectorLength( velocity ) * my_mass / 50;
+	}
+
+	//if vehicle hit another vehicle, factor in their data, too
+	// TODO: Bring this back in later on, it's not critical right now...
+/*	if ( self->client && self->client->NPC_class == CLASS_VEHICLE )
+	{//we're in a vehicle
+		if ( other->client && other->client->ps.vehicleIndex != VEHICLE_NONE )
+		{//they're in a vehicle
+			float	o_mass;
+			vec3_t	o_velocity;
+
+			G_GetMassAndVelocityForEnt( other, &o_mass, o_velocity );
+
+			//now combine
+			if ( DotProduct( o_velocity, velocity ) < 0 )
+			{//were heading towards each other, this is going to be a STRONG impact...
+				vec3_t velocityMod;
+
+				//incorportate mass into each velocity to get directional force
+				VectorScale( velocity, my_mass/50, velocityMod );
+				VectorScale( o_velocity, o_mass/50, o_velocity );
+				//figure out the overall magnitude of those 2 directed forces impacting
+				magnitude = (DotProduct( o_velocity, velocityMod ) * -1.0f)/500.0f;
+			}
+		}
+	}*/
+
+
+
+	// Check For Vehicle On Vehicle Impact (Ramming)
+	//-----------------------------------------------
+	if ( pSelfVeh && 
+		 pSelfVeh->m_pVehicleInfo->type!=VH_ANIMAL && 
+		 pOtherVeh && 
+		 pSelfVeh->m_pVehicleInfo==pOtherVeh->m_pVehicleInfo
+		)
+	{
+		gentity_t*	attacker	= self;
+		Vehicle_t*	attackerVeh = pSelfVeh;
+		gentity_t*	victim		= other;
+		Vehicle_t*	victimVeh	= pOtherVeh;
+
+		// Is The Attacker Actually Not Attacking?
+		//-----------------------------------------
+		if (!(attackerVeh->m_ulFlags&VEH_STRAFERAM))
+		{
+			// Ok, So Is The Victim Actually Attacking?
+			//------------------------------------------
+			if (victimVeh->m_ulFlags&VEH_STRAFERAM)
+			{
+				// Ah, Ok.  Swap Who Is The Attacker Then
+				//----------------------------------------
+				attacker	= other;
+				attackerVeh = pOtherVeh;
+				victim		= self;
+				victimVeh	= pSelfVeh;
+			}
+			else
+			{
+				// No Attackers, So Stop
+				//-----------------------
+				attacker = victim = 0;
+			}
+		}
+
+		if (attacker && victim)
+		{
+		//	float		maxMoveSpeed	= pSelfVeh->m_pVehicleInfo->speedMax;
+		//	float		minLockingSpeed = maxMoveSpeed * 0.75;
+
+			vec3_t		attackerMoveDir;
+			float		attackerMoveSpeed;
+
+			vec3_t		victimMoveDir;
+			float		victimMoveSpeed;
+			vec3_t		victimTowardAttacker;
+			float		victimTowardAttackerDistance;
+			vec3_t		victimRight;
+			float		victimRightAccuracy;
+
+			VectorCopy(attacker->client->ps.velocity,	attackerMoveDir);
+			VectorCopy(victim->client->ps.velocity,		victimMoveDir);
+
+			attackerMoveSpeed	= VectorNormalize(attackerMoveDir);
+			victimMoveSpeed		= VectorNormalize(victimMoveDir);
+
+			AngleVectors(victim->currentAngles, 0, victimRight, 0);
+
+			VectorSubtract(victim->currentOrigin, attacker->currentOrigin, victimTowardAttacker);
+			victimTowardAttackerDistance = VectorNormalize(victimTowardAttacker);
+
+			victimRightAccuracy = DotProduct(victimTowardAttacker, victimRight);
+
+			if (
+				fabsf(victimRightAccuracy)>0.25 						// Must Be Exactly Right Or Left
+			//	&& victimTowardAttackerDistance<100.0f 					// Must Be Close Enough
+			//	&& attackerMoveSpeed>minLockingSpeed					// Must be moving fast enough
+			//	&& fabsf(attackerMoveSpeed - victimMoveSpeed)<100	 	// Both must be going about the same speed
+				)
+			{
+				thrown = true;
+
+				vec3_t	victimRight;
+				vec3_t	victimAngles;
+				VectorCopy(victim->currentAngles, victimAngles);
+				victimAngles[2] = 0;
+				AngleVectors(victimAngles, 0, victimRight, 0);
+
+				if (attackerVeh->m_fStrafeTime<0)
+				{
+					VectorScale(victimRight, -1.0f, victimRight);
+				}
+				if ( !(victim->flags&FL_NO_KNOCKBACK) )
+				{
+					G_Throw(victim, victimRight, 250);
+				}
+//				if (false)
+//				{
+//					VectorMA(victim->currentOrigin, 250.0f, victimRight, victimRight);
+//					CG_DrawEdge(victim->currentOrigin, victimRight, EDGE_IMPACT_POSSIBLE);
+//				}
+				if (victimVeh->m_pVehicleInfo->iImpactFX)
+				{
+					G_PlayEffect(victimVeh->m_pVehicleInfo->iImpactFX, victim->currentOrigin, trace->plane.normal );
+				}
+			}
+		}
+	}
+
+
+ 	if ( !self->client || self->client->ps.lastOnGround+300<level.time || ( self->client->ps.lastOnGround+100 < level.time ) )
+	{
+		vec3_t dir1, dir2;
+		float force = 0, dot;
+		qboolean vehicleHitOwner = qfalse;
+
+		if ( other->material == MAT_GLASS || other->material == MAT_GLASS_METAL || other->material == MAT_GRATE1 || ((other->svFlags&SVF_BBRUSH)&&(other->spawnflags&8/*THIN*/)) )//(other->absmax[0]-other->absmin[0]<=32||other->absmax[1]-other->absmin[1]<=32||other->absmax[2]-other->absmin[2]<=32)) )
+		{//glass and thin breakable brushes (axially aligned only, unfortunately) take more impact damage
+			magnitude *= 2;
+		}
+		
+		// See if the vehicle has crashed into the ground.
+		if ( pSelfVeh && pSelfVeh->m_pVehicleInfo->type!=VH_ANIMAL)
+		{
+ 			if ((magnitude >= 80) && (self->painDebounceTime < level.time))
+			{
+
+				// Setup Some Variables
+				//----------------------
+				vec3_t	vehFwd;
+				VectorCopy(velocity, vehFwd);
+				float	vehSpeed					= VectorNormalize(vehFwd);
+				float	vehToughnessAgainstOther	= pSelfVeh->m_pVehicleInfo->toughness;
+				float	vehHitPercent				= fabsf(DotProduct(vehFwd, trace->plane.normal));
+				int		vehDFlags					= DAMAGE_NO_ARMOR;
+				bool	vehPilotedByPlayer			= (pSelfVeh->m_pPilot && pSelfVeh->m_pPilot->s.number<MAX_CLIENTS);
+				bool	vehInTurbo					= (pSelfVeh->m_iTurboTime>level.time);
+
+				self->painDebounceTime				= level.time + 200;
+
+
+				// Modify Magnitude By Hit Percent And Toughness Against Other
+				//-------------------------------------------------------------
+				if (pSelfVeh->m_ulFlags & VEH_OUTOFCONTROL)
+				{
+					vehToughnessAgainstOther *= 0.01f;		// If Out Of Control, No Damage Resistance
+				}
+				else
+				{
+ 					if (vehPilotedByPlayer)
+					{
+						vehToughnessAgainstOther *= 1.5f;
+					}
+					if (other && other->client)
+					{
+						vehToughnessAgainstOther *= 15.0f;	// Very Tough against other clients (NPCS, Player, etc)
+					}
+				}
+				if (vehToughnessAgainstOther>0.0f)
+				{
+					magnitude *= (vehHitPercent / vehToughnessAgainstOther);
+				}
+				else
+				{
+					magnitude *= vehHitPercent;
+				}
+
+
+				// If We Hit Architecture
+				//------------------------
+				if (!other || !other->client)
+				{
+					// Turbo Hurts
+					//-------------
+					if (vehInTurbo)
+					{
+						magnitude *= 5.0f;
+					}
+
+					else if (trace->plane.normal[2]>0.75f && vehHitPercent<0.2f)
+					{
+						magnitude /= 10.0f;
+					}
+
+
+					// If No Pilot, Blow This Thing Now
+					//----------------------------------
+					if (vehHitPercent>0.9f && !pSelfVeh->m_pPilot && vehSpeed>1000.0f)
+					{
+						vehDFlags |= DAMAGE_IMPACT_DIE;
+					}
+
+					// If Out Of Control, And We Hit A Wall Or Landed Or Head On
+					//------------------------------------------------------------
+					if ((pSelfVeh->m_ulFlags&VEH_OUTOFCONTROL) && (vehHitPercent>0.5f || trace->plane.normal[2]<0.5f || velocity[2]<-50.0f))
+					{
+						vehDFlags |= DAMAGE_IMPACT_DIE;
+					}
+
+					// If This Is A Direct Impact (Debounced By 4 Seconds)
+					//-----------------------------------------------------
+					if (vehHitPercent>0.9f && (level.time - self->lastImpact)>2000 && vehSpeed>300.0f)
+					{
+						self->lastImpact = level.time;
+
+						// The Player Has Harder Requirements to Explode
+						//-----------------------------------------------
+						if (vehPilotedByPlayer)
+						{
+							if ((vehHitPercent>0.99f && vehSpeed>1000.0f && !Q_irand(0,30)) ||
+								(vehHitPercent>0.999f && vehInTurbo))
+							{
+								vehDFlags |= DAMAGE_IMPACT_DIE;
+							}
+						}
+						else if (player && G_IsRidingVehicle(player) &&
+							(Distance(self->currentOrigin, player->currentOrigin)<800.0f) &&
+							(vehInTurbo || !Q_irand(0,1) || vehHitPercent>0.999f))
+						{
+							vehDFlags |= DAMAGE_IMPACT_DIE;
+						}
+					}
+
+					// Make Sure He Dies This Time.  I will accept no excuses.
+					//---------------------------------------------------------
+					if (vehDFlags&DAMAGE_IMPACT_DIE)
+					{
+						// If close enough To The PLayer
+ 						if (player && 
+							G_IsRidingVehicle(player) &&
+							self->owner &&
+							Distance(self->currentOrigin, player->currentOrigin)<500.0f)
+						{
+				 			player->lastEnemy = self->owner;
+							G_StartMatrixEffect(player, MEF_LOOK_AT_ENEMY|MEF_NO_RANGEVAR|MEF_NO_VERTBOB|MEF_NO_SPIN, 1000);
+						}
+						magnitude = 100000.0f;
+					}
+				}
+
+				if (magnitude>10.0f)
+				{
+					// Play The Impact Effect
+					//------------------------
+					if (pSelfVeh->m_pVehicleInfo->iImpactFX && vehSpeed>100.0f)
+					{
+						G_PlayEffect( pSelfVeh->m_pVehicleInfo->iImpactFX, self->currentOrigin, trace->plane.normal );
+					}
+
+					// Set The Crashing Flag And Pain Debounce Time
+					//----------------------------------------------
+					pSelfVeh->m_ulFlags		|= VEH_CRASHING;
+				}
+
+				G_Damage( self, player, player, NULL, self->currentOrigin, magnitude, vehDFlags, MOD_FALLING );//FIXME: MOD_IMPACT
+			}
+
+			if ( self->owner == other || self->activator == other )
+			{//hit owner/activator
+				if ( self->m_pVehicle && !self->m_pVehicle->m_pVehicleInfo->Inhabited( self->m_pVehicle ) )
+				{//empty swoop
+					if ( self->client->respawnTime - level.time < 1000 )
+					{//just spawned in a second ago
+						//don't actually damage or throw him...
+						vehicleHitOwner = qtrue;
+					}
+				}
+			}
+			//if 2 vehicles on same side hit each other, tone it down
+			//NOTE: we do this here because we still want the impact effect
+			if ( pOtherVeh )
+			{
+				if ( self->client->playerTeam == other->client->playerTeam )
+				{
+					magnitude /= 25;
+				}
+			}
+		}
+		else if ( self->client
+			&& (PM_InKnockDown( &self->client->ps )||(self->client->ps.eFlags&EF_FORCE_GRIPPED))
+			&& magnitude >= 120 )
+		{//FORCE-SMACKED into something
+			if ( TIMER_Done( self, "impactEffect" ) )
+			{
+				G_PlayEffect( G_EffectIndex( "env/impact_dustonly" ), trace->endpos, trace->plane.normal );
+				G_Sound( self, G_SoundIndex( va( "sound/weapons/melee/punch%d", Q_irand( 1, 4 ) ) ) );
+				TIMER_Set( self, "impactEffect", 1000 );
+			}
+		}
+
+		//damage them
+		if ( magnitude >= 100 && other->s.number < ENTITYNUM_WORLD )
+		{
+			VectorCopy( velocity, dir1 );
+			VectorNormalize( dir1 );
+			if( VectorCompare( other->currentOrigin, vec3_origin ) )
+			{//a brush with no origin
+				VectorCopy ( dir1, dir2 );
+			}
+			else
+			{
+				VectorSubtract( other->currentOrigin, self->currentOrigin, dir2 );
+				VectorNormalize( dir2 );
+			}
+
+			dot = DotProduct( dir1, dir2 );
+
+			if ( dot >= 0.2 )
+			{
+				force = dot;
+			}
+			else
+			{
+				force = 0;
+			}
+
+			force *= (magnitude/50);
+
+			int cont = gi.pointcontents( other->absmax, other->s.number );
+			if( (cont&CONTENTS_WATER) )
+			{//water absorbs 2/3 velocity
+				force *= 0.33333f;
+			}
+
+			if ( self->NPC && other->s.number == ENTITYNUM_WORLD )
+			{//NPCs take less damage
+				force *= 0.5f;
+			}
+
+			if ( self->s.number >= MAX_CLIENTS && self->client && (PM_InKnockDown( &self->client->ps )||self->client->ps.eFlags&EF_FORCE_GRIPPED) )
+			{//NPC: I was knocked down or being gripped, impact should be harder
+				//FIXME: what if I was just thrown - force pushed/pulled or thrown from a grip?
+				force *= 10;
+			}
+
+			//FIXME: certain NPCs/entities should be TOUGH - like Ion Cannons, AT-STs, Mark1 droids, etc.
+			if ( pOtherVeh )
+			{//if hit another vehicle, take their toughness into account, too
+				force /= pOtherVeh->m_pVehicleInfo->toughness;
+			}
+
+			if( ( (force >= 1 || pSelfVeh) && other->s.number>=MAX_CLIENTS ) || force >= 10)
+			{
+	/*			
+				dprint("Damage other (");
+				dprint(loser.classname);
+				dprint("): ");
+				dprint(ftos(force));
+				dprint("\n");
+	*/
+				if ( other->svFlags & SVF_GLASS_BRUSH )
+				{
+					other->splashRadius = (float)(self->maxs[0] - self->mins[0])/4.0f;
+				}
+
+				if ( pSelfVeh )
+				{//if in a vehicle when land on someone, always knockdown, throw, damage
+					if ( !vehicleHitOwner )
+					{//didn't hit owner
+						// If the player was hit don't make the damage so bad...
+						if ( other && other->s.number<MAX_CLIENTS )
+						{
+							force *= 0.5f;
+						}
+						//Hmm, maybe knockdown?
+						if ( !(other->flags&FL_NO_KNOCKBACK) )
+						{
+							G_Throw( other, dir2, force );
+						}
+						G_Knockdown( other, self, dir2, force, qtrue );
+						G_Damage( other, self, self, velocity, self->currentOrigin, force, DAMAGE_NO_ARMOR|DAMAGE_EXTRA_KNOCKBACK, MOD_IMPACT );
+					}
+				}
+				else if ( self->forcePushTime > level.time - 1000//was force pushed/pulled in the last 1600 milliseconds
+					&& self->forcePuller == other->s.number>=MAX_CLIENTS )//hit the person who pushed/pulled me
+				{//ignore the impact
+				}
+				else if ( other->takedamage )
+				{
+					if ( !self->client || other->s.number<MAX_CLIENTS || !other->client )
+					{//aw, fuck it, clients no longer take impact damage from other clients, unless you're the player 
+						if ( other->client //he's a client
+							&& self->client //I'm a client
+							&& other->client->ps.forceGripEntityNum == self->s.number )//he's force-gripping me
+						{//don't damage the other guy if he's gripping me
+						}
+						else
+						{
+							G_Damage( other, self, self, velocity, self->currentOrigin, floor(force), DAMAGE_NO_ARMOR, MOD_IMPACT );
+						}
+					}
+					else
+					{
+						GEntity_PainFunc( other, self, self, self->currentOrigin, force, MOD_IMPACT );
+						//Hmm, maybe knockdown?
+						if (!thrown)
+						{
+							if ( !(other->flags&FL_NO_KNOCKBACK) )
+							{
+								G_Throw( other, dir2, force );
+							}
+						}
+					}
+					if ( other->health > 0 )
+					{//still alive?
+						//TODO: if someone was thrown through the air (in a knockdown or being gripped) 
+						//		and they hit me hard enough, knock me down
+						if ( other->client )
+						{
+							if ( self->client )
+							{
+                                if ( PM_InKnockDown( &self->client->ps ) || (self->client->ps.eFlags&EF_FORCE_GRIPPED) )
+								{
+									G_Knockdown( other, self, dir2, Q_irand( 200, 400 ), qtrue );
+								}
+							}
+							else if ( self->forcePuller != ENTITYNUM_NONE
+								&& g_entities[self->forcePuller].client
+								&& self->mass > Q_irand( 50, 100 ) )
+							{
+								G_Knockdown( other, &g_entities[self->forcePuller], dir2, Q_irand( 200, 400 ), qtrue );
+							}
+						}
+					}
+				}
+				else
+				{
+					//Hmm, maybe knockdown?
+					if (!thrown)
+					{
+						if ( !(other->flags&FL_NO_KNOCKBACK) )
+						{
+							G_Throw( other, dir2, force );
+						}
+					}
+				}
+			}
+		}
+
+		if ( damageSelf && self->takedamage && !(self->flags&FL_NO_IMPACT_DMG))
+		{
+			//Now damage me
+			//FIXME: more lenient falling damage, especially for when driving a vehicle
+			if ( pSelfVeh && self->client->ps.forceJumpZStart )
+			{//we were force-jumping
+				if ( self->currentOrigin[2] >= self->client->ps.forceJumpZStart )
+				{//we landed at same height or higher than we landed
+					magnitude = 0;
+				}
+				else
+				{//FIXME: take off some of it, at least?
+					magnitude = (self->client->ps.forceJumpZStart-self->currentOrigin[2])/3;
+				}
+			}
+
+			if( ( magnitude >= 100 + self->health 
+					&& self->s.number >= MAX_CLIENTS 
+					&& self->s.weapon != WP_SABER )
+				|| self->client->NPC_class == CLASS_VEHICLE
+				|| ( magnitude >= 700 ) )//health here is used to simulate structural integrity
+			{
+				if ( (self->s.weapon == WP_SABER || self->s.number<MAX_CLIENTS || (self->client&&(self->client->NPC_class==CLASS_BOBAFETT||self->client->NPC_class==CLASS_ROCKETTROOPER))) && self->client && self->client->ps.groundEntityNum < ENTITYNUM_NONE && magnitude < 1000 )
+				{//players and jedi take less impact damage
+					//allow for some lenience on high falls
+					magnitude /= 2;
+				}
+				//drop it some (magic number... sigh)
+				magnitude /= 40;
+				//If damage other, subtract half of that damage off of own injury
+				if ( other->bmodel && other->material != MAT_GLASS )
+				{//take off only a little because we broke architecture (not including glass), that should hurt
+					magnitude = magnitude - force/8;
+				}
+				else
+				{//take off half damage we did to it
+					magnitude = magnitude - force/2;
+				}
+
+				if ( pSelfVeh )
+				{
+					//FIXME: if hit another vehicle, take their toughness into
+					//			account, too?  Or should their toughness only matter
+					//			when they hit me?
+					magnitude /= pSelfVeh->m_pVehicleInfo->toughness * 1000.0f;
+					if ( other->bmodel && other->material != MAT_GLASS )
+					{//broke through some architecture, take a good amount of damage
+					}
+					else if ( pOtherVeh )
+					{//they're tougher
+						//magnitude /= 4.0f;//FIXME: get the toughness of other from vehicles.cfg
+					}
+					else
+					{//take some off because of give
+						//NOTE: this covers all other entities and impact with world...
+						//FIXME: certain NPCs/entities should be TOUGH - like Ion Cannons, AT-STs, Mark1 droids, etc.
+						magnitude /= 10.0f;
+					}
+					if ( magnitude < 1.0f )
+					{
+						magnitude = 0;
+					}
+				}
+				if ( magnitude >= 1 )
+				{
+	//FIXME: Put in a thingtype impact sound function
+	/*					
+					dprint("Damage self (");
+					dprint(self.classname);
+					dprint("): ");
+					dprint(ftos(magnitude));
+					dprint("\n");
+	*/
+					if ( self->NPC && self->s.weapon == WP_SABER )
+					{//FIXME: for now Jedi take no falling damage, but really they should if pushed off?
+						magnitude = 0;
+					}
+					G_Damage( self, NULL, NULL, NULL, self->currentOrigin, magnitude/2, DAMAGE_NO_ARMOR, MOD_FALLING );//FIXME: MOD_IMPACT
+				}
+			}
+		}
+
+		//FIXME: slow my velocity some?
+	
+
+
+		/*
+		if(self.flags&FL_ONGROUND)
+			self.last_onground=time;
+		*/
+	}
+}
+
+/*
+==============
+ClientImpacts
+==============
+*/
+void ClientImpacts( gentity_t *ent, pmove_t *pm ) {
+	int		i, j;
+	trace_t	trace;
+	gentity_t	*other;
+
+	memset( &trace, 0, sizeof( trace ) );
+	for (i=0 ; i<pm->numtouch ; i++) {
+		for (j=0 ; j<i ; j++) {
+			if (pm->touchents[j] == pm->touchents[i] ) {
+				break;
+			}
+		}
+		if (j != i) {
+			continue;	// duplicated
+		}
+		other = &g_entities[ pm->touchents[i] ];
+
+		if ( ( ent->NPC != NULL ) && ( ent->e_TouchFunc != touchF_NULL ) ) {	// last check unneccessary
+			GEntity_TouchFunc( ent, other, &trace );
+		}
+
+		if ( other->e_TouchFunc == touchF_NULL ) {	// not needed, but I'll leave it I guess (cache-hit issues)
+			continue;
+		}
+		GEntity_TouchFunc( other, ent, &trace );
+	}
+
+}
+
+/*
+============
+G_TouchTriggersLerped
+
+Find all trigger entities that ent's current position touches.
+Spectators will only interact with teleporters.
+
+This version checks at 6 unit steps between last and current origins
+============
+*/
+void	G_TouchTriggersLerped( gentity_t *ent ) {
+	int			i, num;
+	float		dist, curDist = 0;
+	gentity_t	*touch[MAX_GENTITIES], *hit;
+	trace_t		trace;
+	vec3_t		end, mins, maxs, diff;
+	const vec3_t	range = { 40, 40, 52 };
+	qboolean	touched[MAX_GENTITIES];
+	qboolean	done = qfalse;
+
+	if ( !ent->client ) {
+		return;
+	}
+
+	// dead NPCs don't activate triggers!
+	if ( ent->client->ps.stats[STAT_HEALTH] <= 0 ) 
+	{
+		if ( ent->s.number>=MAX_CLIENTS )
+		{
+			return;
+		}
+	}
+
+#ifdef _DEBUG
+	for ( int j = 0; j < 3; j++ )
+	{
+		assert( !_isnan(ent->currentOrigin[j]));
+		assert( !_isnan(ent->lastOrigin[j]));
+	}
+#endif// _DEBUG
+	VectorSubtract( ent->currentOrigin, ent->lastOrigin, diff );
+	dist = VectorNormalize( diff );
+#ifdef _DEBUG
+	assert( (dist<1024) && "insane distance in G_TouchTriggersLerped!" );
+#endif// _DEBUG
+
+	if ( dist > 1024 )
+	{
+		return;
+	}
+	memset (touched, qfalse, sizeof(touched) );
+
+	for ( curDist = 0; !done && ent->maxs[1]>0; curDist += (float)ent->maxs[1]/2.0f )
+	{
+		if ( curDist >= dist )
+		{
+			VectorCopy( ent->currentOrigin, end );
+			done = qtrue;
+		}
+		else
+		{
+			VectorMA( ent->lastOrigin, curDist, diff, end );
+		}
+		VectorSubtract( end, range, mins );
+		VectorAdd( end, range, maxs );
+
+		num = gi.EntitiesInBox( mins, maxs, touch, MAX_GENTITIES );
+
+		// can't use ent->absmin, because that has a one unit pad
+		VectorAdd( end, ent->mins, mins );
+		VectorAdd( end, ent->maxs, maxs );
+
+		for ( i=0 ; i<num ; i++ ) {
+			hit = touch[i];
+
+			if ( (hit->e_TouchFunc == touchF_NULL) && (ent->e_TouchFunc == touchF_NULL) ) {
+				continue;
+			}
+			if ( !( hit->contents & CONTENTS_TRIGGER ) ) {
+				continue;
+			}
+
+			if ( touched[i] == qtrue ) {
+				continue;//already touched this move
+			}
+			if ( ent->client->ps.stats[STAT_HEALTH] <= 0 ) 
+			{
+				if ( Q_stricmp( "trigger_teleport", hit->classname ) || !(hit->spawnflags&16/*TTSF_DEAD_OK*/) )
+				{//dead clients can only touch tiogger_teleports that are marked as touchable
+					continue;
+				}
+			}
+			// use seperate code for determining if an item is picked up
+			// so you don't have to actually contact its bounding box
+			/*
+			if ( hit->s.eType == ET_ITEM ) {
+				if ( !BG_PlayerTouchesItem( &ent->client->ps, &hit->s, level.time ) ) {
+					continue;
+				}
+			} else */
+			{
+				if ( !gi.EntityContact( mins, maxs, hit ) ) {
+					continue;
+				}
+			}
+
+			touched[i] = qtrue;
+
+			memset( &trace, 0, sizeof(trace) );
+
+			if ( hit->e_TouchFunc != touchF_NULL ) {
+				GEntity_TouchFunc(hit, ent, &trace);
+			}
+
+			//WTF?  Why would a trigger ever fire off the NPC's touch func??!!!
+			/*
+			if ( ( ent->NPC != NULL ) && ( ent->e_TouchFunc != touchF_NULL ) ) {
+				GEntity_TouchFunc( ent, hit, &trace );
+			}
+			*/
+		}
+	}
+}
+
+/*
+============
+G_TouchTriggers
+
+Find all trigger entities that ent's current position touches.
+Spectators will only interact with teleporters.
+============
+*/
+void	G_TouchTriggers( gentity_t *ent ) {
+	int			i, num;
+	gentity_t	*touch[MAX_GENTITIES], *hit;
+	trace_t		trace;
+	vec3_t		mins, maxs;
+	const vec3_t	range = { 40, 40, 52 };
+
+	if ( !ent->client ) {
+		return;
+	}
+
+	// dead clients don't activate triggers!
+	if ( ent->client->ps.stats[STAT_HEALTH] <= 0 ) {
+		return;
+	}
+
+	VectorSubtract( ent->client->ps.origin, range, mins );
+	VectorAdd( ent->client->ps.origin, range, maxs );
+
+	num = gi.EntitiesInBox( mins, maxs, touch, MAX_GENTITIES );
+
+	// can't use ent->absmin, because that has a one unit pad
+	VectorAdd( ent->client->ps.origin, ent->mins, mins );
+	VectorAdd( ent->client->ps.origin, ent->maxs, maxs );
+
+	for ( i=0 ; i<num ; i++ ) {
+		hit = touch[i];
+
+		if ( (hit->e_TouchFunc == touchF_NULL) && (ent->e_TouchFunc == touchF_NULL) ) {
+			continue;
+		}
+		if ( !( hit->contents & CONTENTS_TRIGGER ) ) {
+			continue;
+		}
+
+		// use seperate code for determining if an item is picked up
+		// so you don't have to actually contact its bounding box
+		/*
+		if ( hit->s.eType == ET_ITEM ) {
+			if ( !BG_PlayerTouchesItem( &ent->client->ps, &hit->s, level.time ) ) {
+				continue;
+			}
+		} else */
+		{
+			if ( !gi.EntityContact( mins, maxs, hit ) ) {
+				continue;
+			}
+		}
+
+		memset( &trace, 0, sizeof(trace) );
+
+		if ( hit->e_TouchFunc != touchF_NULL ) {
+			GEntity_TouchFunc(hit, ent, &trace);
+		}
+
+		if ( ( ent->NPC != NULL ) && ( ent->e_TouchFunc != touchF_NULL ) ) {
+			GEntity_TouchFunc( ent, hit, &trace );
+		}
+	}
+}
+
+
+/*
+============
+G_MoverTouchTriggers
+
+Find all trigger entities that ent's current position touches.
+Spectators will only interact with teleporters.
+============
+*/
+void G_MoverTouchPushTriggers( gentity_t *ent, vec3_t oldOrg ) 
+{
+	int			i, num;
+	float		step, stepSize, dist;
+	gentity_t	*touch[MAX_GENTITIES], *hit;
+	trace_t		trace;
+	vec3_t		mins, maxs, dir, size, checkSpot;
+	const vec3_t	range = { 40, 40, 52 };
+
+	// non-moving movers don't hit triggers!
+	if ( !VectorLengthSquared( ent->s.pos.trDelta ) ) 
+	{
+		return;
+	}
+
+	VectorSubtract( ent->mins, ent->maxs, size );
+	stepSize = VectorLength( size );
+	if ( stepSize < 1 )
+	{
+		stepSize = 1;
+	}
+
+	VectorSubtract( ent->currentOrigin, oldOrg, dir );
+	dist = VectorNormalize( dir );
+	for ( step = 0; step <= dist; step += stepSize )
+	{
+		VectorMA( ent->currentOrigin, step, dir, checkSpot );
+		VectorSubtract( checkSpot, range, mins );
+		VectorAdd( checkSpot, range, maxs );
+
+		num = gi.EntitiesInBox( mins, maxs, touch, MAX_GENTITIES );
+
+		// can't use ent->absmin, because that has a one unit pad
+		VectorAdd( checkSpot, ent->mins, mins );
+		VectorAdd( checkSpot, ent->maxs, maxs );
+
+		for ( i=0 ; i<num ; i++ ) 
+		{
+			hit = touch[i];
+
+			if ( hit->s.eType != ET_PUSH_TRIGGER )
+			{
+				continue;
+			}
+
+			if ( hit->e_TouchFunc == touchF_NULL ) 
+			{
+				continue;
+			}
+
+			if ( !( hit->contents & CONTENTS_TRIGGER ) ) 
+			{
+				continue;
+			}
+
+
+			if ( !gi.EntityContact( mins, maxs, hit ) ) 
+			{
+				continue;
+			}
+
+			memset( &trace, 0, sizeof(trace) );
+
+			if ( hit->e_TouchFunc != touchF_NULL ) 
+			{
+				GEntity_TouchFunc(hit, ent, &trace);
+			}
+		}
+	}
+}
+
+void G_MatchPlayerWeapon( gentity_t *ent )
+{
+	if ( g_entities[0].inuse && g_entities[0].client )
+	{//player is around
+		int newWeap;
+		if ( g_entities[0].client->ps.weapon > WP_CONCUSSION )
+		{
+			newWeap = WP_BLASTER_PISTOL;
+		}
+		else
+		{
+			newWeap = g_entities[0].client->ps.weapon;
+		}
+		if ( newWeap != WP_NONE && ent->client->ps.weapon != newWeap )
+		{
+			G_RemoveWeaponModels( ent );
+			ent->client->ps.stats[STAT_WEAPONS] = ( 1 << newWeap );
+			ent->client->ps.ammo[weaponData[newWeap].ammoIndex] = 999;
+			ChangeWeapon( ent, newWeap );
+			ent->client->ps.weapon = newWeap;
+			ent->client->ps.weaponstate = WEAPON_READY;
+			if ( newWeap == WP_SABER )
+			{
+				//FIXME: AddSound/Sight Event
+				int numSabers = WP_SaberInitBladeData( ent );
+				WP_SaberAddG2SaberModels( ent );
+				for ( int saberNum = 0; saberNum < numSabers; saberNum++ )
+				{
+					//G_CreateG2AttachedWeaponModel( ent, ent->client->ps.saber[saberNum].model, ent->handRBolt, 0 );
+					ent->client->ps.saber[saberNum].type = g_entities[0].client->ps.saber[saberNum].type;
+					for ( int bladeNum = 0; bladeNum < ent->client->ps.saber[saberNum].numBlades; bladeNum++ )
+					{
+						ent->client->ps.saber[saberNum].blade[0].active = g_entities[0].client->ps.saber[saberNum].blade[bladeNum].active;
+						ent->client->ps.saber[saberNum].blade[0].length = g_entities[0].client->ps.saber[saberNum].blade[bladeNum].length;
+					}
+				}
+				ent->client->ps.saberAnimLevel = g_entities[0].client->ps.saberAnimLevel;
+				ent->client->ps.saberStylesKnown = g_entities[0].client->ps.saberStylesKnown;
+			}
+			else
+			{
+				G_CreateG2AttachedWeaponModel( ent, weaponData[newWeap].weaponMdl, ent->handRBolt, 0 );
+			}
+		}
+	}
+}
+
+void G_NPCMunroMatchPlayerWeapon( gentity_t *ent )
+{
+	//special uber hack for cinematic players to match player's weapon
+	if ( !in_camera )
+	{
+		if ( ent && ent->client && ent->NPC && (ent->NPC->aiFlags&NPCAI_MATCHPLAYERWEAPON) )
+		{//we're a Player NPC
+			G_MatchPlayerWeapon( ent );
+		}
+	}
+}
+
+/*
+==================
+ClientTimerActions
+
+Actions that happen once a second
+==================
+*/
+void ClientTimerActions( gentity_t *ent, int msec ) {
+	gclient_t *client;
+
+	client = ent->client;
+	client->timeResidual += msec;
+
+	while ( client->timeResidual >= 1000 ) 
+	{
+		client->timeResidual -= 1000;
+
+		if ( ent->s.weapon != WP_NONE )
+		{
+			ent->client->sess.missionStats.weaponUsed[ent->s.weapon]++;
+		}
+		// if we've got the seeker powerup, see if we can shoot it at someone
+/*		if ( ent->client->ps.powerups[PW_SEEKER] > level.time )
+		{
+			vec3_t	seekerPos, dir;
+			gentity_t *enemy = SeekerAcquiresTarget( ent, seekerPos );
+
+			if ( enemy != NULL ) // set the client's enemy to a valid target
+			{
+				FireSeeker( ent, enemy, seekerPos, dir );
+
+				gentity_t *tent;
+				tent = G_TempEntity( seekerPos, EV_POWERUP_SEEKER_FIRE );
+				VectorCopy( dir, tent->pos1 );
+				tent->s.eventParm = ent->s.number;
+			}
+		}*/
+		if ( (ent->flags&FL_OVERCHARGED_HEALTH) )
+		{//need to gradually reduce health back to max
+			if ( ent->health > ent->client->ps.stats[STAT_MAX_HEALTH] )
+			{//decrement it
+				ent->health--;
+				ent->client->ps.stats[STAT_HEALTH] = ent->health;
+			}
+			else
+			{//done
+				ent->flags &= ~FL_OVERCHARGED_HEALTH;
+			}
+		}
+	}
+}
+
+/*
+====================
+ClientIntermissionThink
+====================
+*/
+static qboolean ClientCinematicThink( gclient_t *client ) {
+	client->ps.eFlags &= ~EF_FIRING;
+
+	// swap button actions
+	client->oldbuttons = client->buttons;
+	client->buttons = client->usercmd.buttons;
+	if ( client->buttons & ( BUTTON_USE ) & ( client->oldbuttons ^ client->buttons ) ) {
+		return( qtrue );
+	}
+	return( qfalse );
+}
+
+
+/*
+================
+ClientEvents
+
+Events will be passed on to the clients for presentation,
+but any server game effects are handled here
+================
+*/
+extern void WP_SabersDamageTrace( gentity_t *ent, qboolean noEffects = qfalse );
+extern void WP_SaberUpdateOldBladeData( gentity_t *ent );
+void ClientEvents( gentity_t *ent, int oldEventSequence ) {
+	int		i;
+	int		event;
+	gclient_t *client;
+	//int		damage;
+	qboolean	fired;
+
+	client = ent->client;
+
+	fired = qfalse;
+
+	for ( i = oldEventSequence ; i < client->ps.eventSequence ; i++ ) {
+		event = client->ps.events[ i & (MAX_PS_EVENTS-1) ];
+
+		switch ( event ) {
+		case EV_FALL_MEDIUM:
+		case EV_FALL_FAR://these come from bg_pmove, PM_CrashLand
+			if ( ent->s.eType != ET_PLAYER ) {
+				break;		// not in the player model
+			}
+			/*
+			//FIXME: isn't there a more accurate way to calculate damage from falls?
+			if ( event == EV_FALL_FAR ) 
+			{
+				damage = 50;
+			} 
+			else 
+			{
+				damage = 25;
+			}
+			ent->painDebounceTime = level.time + 200;	// no normal pain sound
+			G_Damage (ent, NULL, NULL, NULL, NULL, damage, 0, MOD_FALLING);
+			*/
+			break;
+
+		case EV_FIRE_WEAPON:
+#ifndef FINAL_BUILD
+			if ( fired ) {
+				gi.Printf( "DOUBLE EV_FIRE_WEAPON AND-OR EV_ALT_FIRE!!\n" );
+			}
+#endif
+			fired = qtrue;
+			FireWeapon( ent, qfalse );
+#ifdef _XBOX
+			extern int Sys_Milliseconds();
+			if (ent->s.clientNum == 0)
+				g_lastFireTime = Sys_Milliseconds();
+#endif
+			break;
+
+		case EV_ALT_FIRE:
+#ifndef FINAL_BUILD
+			if ( fired ) {
+				gi.Printf( "DOUBLE EV_FIRE_WEAPON AND-OR EV_ALT_FIRE!!\n" );
+			}
+#endif
+			fired = qtrue;
+			FireWeapon( ent, qtrue );
+#ifdef _XBOX
+			if (ent->s.clientNum == 0)
+				g_lastFireTime = Sys_Milliseconds();
+#endif
+			break;
+
+		default:
+			break;
+		}
+	}
+	//by the way, if you have your saber in hand and it's on, do the damage trace
+	if ( client->ps.weapon == WP_SABER )
+	{
+		if ( g_timescale->value >= 1.0f || !(client->ps.forcePowersActive&(1<<FP_SPEED)) )
+		{
+			int wait = FRAMETIME/2;
+			//sanity check
+			if ( client->ps.saberDamageDebounceTime - level.time > wait )
+			{//when you unpause the game with force speed on, the time gets *really* wiggy...
+				client->ps.saberDamageDebounceTime = level.time + wait;
+			}
+			if ( client->ps.saberDamageDebounceTime <= level.time )
+			{
+				WP_SabersDamageTrace( ent );
+				WP_SaberUpdateOldBladeData( ent );
+				/*
+				if ( g_timescale->value&&client->ps.clientNum==0&&!player_locked&&!MatrixMode&&client->ps.forcePowersActive&(1<<FP_SPEED) )
+				{
+					wait = floor( (float)wait*g_timescale->value );
+				}
+				*/
+				client->ps.saberDamageDebounceTime = level.time + wait;
+			}
+		}
+	}
+}
+
+void G_ThrownDeathAnimForDeathAnim( gentity_t *hitEnt, vec3_t impactPoint )
+{
+	int anim = -1;
+	if ( !hitEnt || !hitEnt->client )
+	{
+		return;
+	}
+	switch ( hitEnt->client->ps.legsAnim )
+	{
+	case BOTH_DEATH9://fall to knees, fall over
+	case BOTH_DEATH10://fall to knees, fall over
+	case BOTH_DEATH11://fall to knees, fall over
+	case BOTH_DEATH13://stumble back, fall over
+	case BOTH_DEATH17://jerky fall to knees, fall over
+	case BOTH_DEATH18://grab gut, fall to knees, fall over
+	case BOTH_DEATH19://grab gut, fall to knees, fall over
+	case BOTH_DEATH20://grab shoulder, fall forward
+	case BOTH_DEATH21://grab shoulder, fall forward
+	case BOTH_DEATH3://knee collapse, twist & fall forward
+	case BOTH_DEATH7://knee collapse, twist & fall forward
+		{
+			vec3_t dir2Impact, fwdAngles, facing;
+			VectorSubtract( impactPoint, hitEnt->currentOrigin, dir2Impact );
+			dir2Impact[2] = 0;
+			VectorNormalize( dir2Impact );
+			VectorSet( fwdAngles, 0, hitEnt->client->ps.viewangles[YAW], 0 );
+			AngleVectors( fwdAngles, facing, NULL, NULL );
+			float dot = DotProduct( facing, dir2Impact );//-1 = hit in front, 0 = hit on side, 1 = hit in back
+			if ( dot > 0.5f )
+			{//kicked in chest, fly backward
+				switch ( Q_irand( 0, 4 ) )
+				{//FIXME: don't start at beginning of anim?
+				case 0:
+					anim = BOTH_DEATH1;//thrown backwards
+					break;
+				case 1:
+					anim = BOTH_DEATH2;//fall backwards
+					break;
+				case 2:
+					anim = BOTH_DEATH15;//roll over backwards
+					break;
+				case 3:
+					anim = BOTH_DEATH22;//fast fall back
+					break;
+				case 4:
+					anim = BOTH_DEATH23;//fast fall back
+					break;
+				}
+			}
+			else if ( dot < -0.5f )
+			{//kicked in back, fly forward
+				switch ( Q_irand( 0, 5 ) )
+				{//FIXME: don't start at beginning of anim?
+				case 0:
+					anim = BOTH_DEATH14;
+					break;
+				case 1:
+					anim = BOTH_DEATH24;
+					break;
+				case 2:
+					anim = BOTH_DEATH25;
+					break;
+				case 3:
+					anim = BOTH_DEATH4;//thrown forwards
+					break;
+				case 4:
+					anim = BOTH_DEATH5;//thrown forwards
+					break;
+				case 5:
+					anim = BOTH_DEATH16;//thrown forwards
+					break;
+				}
+			}
+			else
+			{//hit on side, spin
+				switch ( Q_irand( 0, 2 ) )
+				{//FIXME: don't start at beginning of anim?
+				case 0:
+					anim = BOTH_DEATH12;
+					break;
+				case 1:
+					anim = BOTH_DEATH14;
+					break;
+				case 2:
+					anim = BOTH_DEATH15;
+					break;
+				case 3:
+					anim = BOTH_DEATH6;
+					break;
+				case 4:
+					anim = BOTH_DEATH8;
+					break;
+				}
+			}
+		}
+		break;
+	}
+	if ( anim != -1 )
+	{
+		NPC_SetAnim( hitEnt, SETANIM_BOTH, anim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+	}
+}
+
+gentity_t *G_KickTrace( gentity_t *ent, vec3_t kickDir, float kickDist, vec3_t kickEnd, int kickDamage, float kickPush, qboolean doSoundOnWalls )
+{
+	vec3_t	traceOrg, traceEnd, kickMins={-2,-2,-2}, kickMaxs={2,2,2};
+	trace_t	trace;
+	gentity_t	*hitEnt = NULL;
+	//FIXME: variable kick height?
+	if ( kickEnd && !VectorCompare( kickEnd, vec3_origin ) )
+	{//they passed us the end point of the trace, just use that
+		//this makes the trace flat
+		VectorSet( traceOrg, ent->currentOrigin[0], ent->currentOrigin[1], kickEnd[2] );
+		VectorCopy( kickEnd, traceEnd );
+	}
+	else
+	{//extrude
+		VectorSet( traceOrg, ent->currentOrigin[0], ent->currentOrigin[1], ent->currentOrigin[2]+ent->maxs[2]*0.5f );
+		VectorMA( traceOrg, kickDist, kickDir, traceEnd );
+	}
+
+	gi.trace( &trace, traceOrg, kickMins, kickMaxs, traceEnd, ent->s.number, MASK_SHOT );//clipmask ok?
+	if ( trace.fraction < 1.0f && !trace.startsolid && !trace.allsolid && trace.entityNum < ENTITYNUM_NONE )
+	{
+		hitEnt = &g_entities[trace.entityNum];
+		if ( ent->client->ps.lastKickedEntNum != trace.entityNum )
+		{
+			TIMER_Remove( ent, "kickSoundDebounce" );
+			ent->client->ps.lastKickedEntNum = trace.entityNum;
+		}
+		if ( hitEnt )
+		{//we hit an entity
+			if ( hitEnt->client )
+			{
+				if ( !(hitEnt->client->ps.pm_flags&PMF_TIME_KNOCKBACK) 
+					&& TIMER_Done( hitEnt, "kickedDebounce" ) )//not already flying through air?  Intended to stop multiple hits, but...
+				{//FIXME: this should not always work
+					if ( PM_InKnockDown( &hitEnt->client->ps ) 
+						&& !PM_InGetUp( &hitEnt->client->ps ) )
+					{//don't hit people who are knocked down or being knocked down (okay to hit people getting up, though)
+						return NULL;
+					}
+					if ( PM_InRoll( &hitEnt->client->ps ) )
+					{//can't hit people who are rolling
+						return NULL;
+					}
+					//don't hit same ent more than once per kick
+					if ( hitEnt->takedamage )
+					{//hurt it
+						G_Damage( hitEnt, ent, ent, kickDir, trace.endpos, kickDamage, DAMAGE_NO_KNOCKBACK|DAMAGE_NO_KILL, MOD_MELEE );
+					}
+					//do kick hit sound and impact effect
+					if ( TIMER_Done( ent, "kickSoundDebounce" ) )
+					{
+						if ( ent->client->ps.torsoAnim == BOTH_A7_HILT )
+						{
+							G_Sound( ent, G_SoundIndex( "sound/movers/objects/saber_slam" ) );
+						}
+						else
+						{
+							vec3_t fxOrg, fxDir;
+							VectorCopy( kickDir, fxDir );
+							VectorMA( trace.endpos, Q_flrand( 5.0f, 10.0f ), fxDir, fxOrg );
+							VectorScale( fxDir, -1, fxDir );
+							G_PlayEffect( G_EffectIndex( "melee/kick_impact" ), fxOrg, fxDir );
+							//G_Sound( ent, G_SoundIndex( va( "sound/weapons/melee/punch%d", Q_irand( 1, 4 ) ) ) );
+						}
+						TIMER_Set( ent, "kickSoundDebounce", 2000 );
+					}
+					TIMER_Set( hitEnt, "kickedDebounce", 1000 );
+					if ( ent->client->ps.torsoAnim == BOTH_A7_HILT )
+					{//hit in head
+						if ( hitEnt->health > 0 )
+						{//knock down
+							if ( kickPush >= 150.0f/*75.0f*/ && !Q_irand( 0, 1 ) )
+							{//knock them down
+								if ( !(hitEnt->flags&FL_NO_KNOCKBACK) )
+								{
+									G_Throw( hitEnt, kickDir, kickPush/3.0f );
+								}
+								G_Knockdown( hitEnt, ent, kickDir, 300, qtrue );
+							}
+							else
+							{//force them to play a pain anim
+								if ( hitEnt->s.number < MAX_CLIENTS )
+								{
+									NPC_SetPainEvent( hitEnt );
+								}
+								else
+								{
+									GEntity_PainFunc( hitEnt, ent, ent, hitEnt->currentOrigin, 0, MOD_MELEE );
+								}
+							}
+							//just so we don't hit him again...
+							hitEnt->client->ps.pm_flags |= PMF_TIME_KNOCKBACK;
+							hitEnt->client->ps.pm_time = 100;
+						}
+						else
+						{
+							if ( !(hitEnt->flags&FL_NO_KNOCKBACK) )
+							{
+								G_Throw( hitEnt, kickDir, kickPush );
+							}
+							//see if we should play a better looking death on them
+							G_ThrownDeathAnimForDeathAnim( hitEnt, trace.endpos );
+						}
+					}
+					else if ( ent->client->ps.legsAnim == BOTH_GETUP_BROLL_B
+						|| ent->client->ps.legsAnim == BOTH_GETUP_BROLL_F
+						|| ent->client->ps.legsAnim == BOTH_GETUP_FROLL_B
+						|| ent->client->ps.legsAnim == BOTH_GETUP_FROLL_F )
+					{
+						if ( hitEnt->health > 0 )
+						{//knock down
+							if ( hitEnt->client->ps.groundEntityNum == ENTITYNUM_NONE )
+							{//he's in the air?  Send him flying back
+								if ( !(hitEnt->flags&FL_NO_KNOCKBACK) )
+								{
+									G_Throw( hitEnt, kickDir, kickPush );
+								}
+							}
+							else
+							{
+								//just so we don't hit him again...
+								hitEnt->client->ps.pm_flags |= PMF_TIME_KNOCKBACK;
+								hitEnt->client->ps.pm_time = 100;
+							}
+							//knock them down
+							G_Knockdown( hitEnt, ent, kickDir, 300, qtrue );
+						}
+						else
+						{
+							if ( !(hitEnt->flags&FL_NO_KNOCKBACK) )
+							{
+								G_Throw( hitEnt, kickDir, kickPush );
+							}
+							//see if we should play a better looking death on them
+							G_ThrownDeathAnimForDeathAnim( hitEnt, trace.endpos );
+						}
+					}
+					else if ( hitEnt->health <= 0 )
+					{//we kicked a dead guy
+						//throw harder - FIXME: no matter how hard I push them, they don't go anywhere... corpses use less physics???
+						if ( !(hitEnt->flags&FL_NO_KNOCKBACK) )
+						{
+							G_Throw( hitEnt, kickDir, kickPush*4 );
+						}
+						//see if we should play a better looking death on them
+						G_ThrownDeathAnimForDeathAnim( hitEnt, trace.endpos );
+					}
+					else
+					{
+						if ( !(hitEnt->flags&FL_NO_KNOCKBACK) )
+						{
+							G_Throw( hitEnt, kickDir, kickPush );
+						}
+						if ( kickPush >= 150.0f/*75.0f*/ && !Q_irand( 0, 2 ) )
+						{
+							G_Knockdown( hitEnt, ent, kickDir, 300, qtrue );
+						}
+						else
+						{
+							G_Knockdown( hitEnt, ent, kickDir, kickPush, qtrue );
+						}
+					}
+				}
+			}
+			else
+			{//FIXME: don't do this in repeated frames... only allow 1 frame in kick to hit wall?  The most extended one?  Pass in a bool on that frame.
+				if ( doSoundOnWalls )
+				{//do kick hit sound and impact effect
+					if ( TIMER_Done( ent, "kickSoundDebounce" ) )
+					{
+						if ( ent->client->ps.torsoAnim == BOTH_A7_HILT )
+						{
+							G_Sound( ent, G_SoundIndex( "sound/movers/objects/saber_slam" ) );
+						}
+						else
+						{
+							G_PlayEffect( G_EffectIndex( "melee/kick_impact" ), trace.endpos, trace.plane.normal );
+							//G_Sound( ent, G_SoundIndex( va( "sound/weapons/melee/punch%d", Q_irand( 1, 4 ) ) ) );
+						}
+						TIMER_Set( ent, "kickSoundDebounce", 2000 );
+					}
+				}
+			}
+		}
+	}
+	return (hitEnt);
+}
+
+qboolean G_CheckRollSafety( gentity_t *self, int anim, float testDist ) 
+{
+	vec3_t	forward, right, testPos, angles;
+	trace_t	trace;
+	int		contents = (CONTENTS_SOLID|CONTENTS_BOTCLIP);
+
+	if ( !self || !self->client )
+	{
+		return qfalse;
+	}
+
+	if ( self->s.number < MAX_CLIENTS )
+	{//player
+		contents |= CONTENTS_PLAYERCLIP;
+	}
+	else
+	{//NPC
+		contents |= CONTENTS_MONSTERCLIP;
+	}
+	if ( PM_InAttackRoll( self->client->ps.legsAnim ) )
+	{//we don't care if people are in the way, we'll knock them down!
+		contents &= ~CONTENTS_BODY;
+	}
+	angles[PITCH] = angles[ROLL] = 0;
+	angles[YAW] = self->client->ps.viewangles[YAW];//Add ucmd.angles[YAW]?
+	AngleVectors( angles, forward, right, NULL );
+
+	switch ( anim )
+	{
+	case BOTH_GETUP_BROLL_R:
+	case BOTH_GETUP_FROLL_R:
+		VectorMA( self->currentOrigin, testDist, right, testPos );
+		break;
+	case BOTH_GETUP_BROLL_L:
+	case BOTH_GETUP_FROLL_L:
+		VectorMA( self->currentOrigin, -testDist, right, testPos );
+		break;
+	case BOTH_GETUP_BROLL_F:
+	case BOTH_GETUP_FROLL_F:
+		VectorMA( self->currentOrigin, testDist, forward, testPos );
+		break;
+	case BOTH_GETUP_BROLL_B:
+	case BOTH_GETUP_FROLL_B:
+		VectorMA( self->currentOrigin, -testDist, forward, testPos );
+		break;
+	default://FIXME: add normal rolls?  Make generic for any forced-movement anim?
+		return qtrue;
+		break;
+	}
+
+	gi.trace( &trace, self->currentOrigin, self->mins, self->maxs, testPos, self->s.number, contents );
+	if ( trace.fraction < 1.0f 
+		|| trace.allsolid
+		|| trace.startsolid )
+	{//inside something or will hit something
+		return qfalse;
+	}
+	return qtrue;
+}
+
+void G_CamPullBackForLegsAnim( gentity_t *ent, qboolean useTorso = qfalse )
+{
+	if ( (ent->s.number < MAX_CLIENTS||G_ControlledByPlayer(ent)) )
+	{
+		float animLength = PM_AnimLength( ent->client->clientInfo.animFileIndex, (useTorso?(animNumber_t)ent->client->ps.torsoAnim:(animNumber_t)ent->client->ps.legsAnim) );
+		float elapsedTime = (float)(animLength-(useTorso?ent->client->ps.torsoAnimTimer:ent->client->ps.legsAnimTimer));
+		float backDist = 0;
+		if ( elapsedTime < animLength/2.0f )
+		{//starting anim
+			backDist = (elapsedTime/animLength)*120.0f;
+		}
+		else
+		{//ending anim
+			backDist = ((animLength-elapsedTime)/animLength)*120.0f;
+		}
+		cg.overrides.active |= CG_OVERRIDE_3RD_PERSON_RNG;
+		cg.overrides.thirdPersonRange = cg_thirdPersonRange.value+backDist;
+	}
+}
+
+void G_CamCircleForLegsAnim( gentity_t *ent )
+{
+	if ( (ent->s.number < MAX_CLIENTS||G_ControlledByPlayer(ent)) )
+	{
+		float animLength = PM_AnimLength( ent->client->clientInfo.animFileIndex, (animNumber_t)ent->client->ps.legsAnim );
+		float elapsedTime = (float)(animLength-ent->client->ps.legsAnimTimer);
+		float angle = 0;
+		angle = (elapsedTime/animLength)*360.0f;
+		cg.overrides.active |= CG_OVERRIDE_3RD_PERSON_ANG;
+		cg.overrides.thirdPersonAngle = cg_thirdPersonAngle.value+angle;
+	}
+}
+
+qboolean G_GrabClient( gentity_t *ent, usercmd_t *ucmd )
+{
+	gentity_t	*bestEnt = NULL, *radiusEnts[ 128 ];
+	int			numEnts;
+	const float	radius = 100.0f;
+	const float	radiusSquared = (radius*radius);
+	float		bestDistSq = (radiusSquared+1.0f), distSq;
+	int			i;
+	vec3_t		boltOrg;
+
+	numEnts = G_GetEntsNearBolt( ent, radiusEnts, radius, ent->handRBolt, boltOrg );
+
+	for ( i = 0; i < numEnts; i++ )
+	{
+		if ( !radiusEnts[i]->inuse )
+		{
+			continue;
+		}
+		
+		if ( radiusEnts[i] == ent )
+		{//Skip the rancor ent
+			continue;
+		}
+
+		if ( !radiusEnts[i]->inuse || radiusEnts[i]->health <= 0 )
+		{//must be alive
+			continue;
+		}
+		
+		if ( radiusEnts[i]->client == NULL )
+		{//must be a client
+			continue;
+		}
+
+		if ( (radiusEnts[i]->client->ps.eFlags&EF_HELD_BY_RANCOR)
+			||(radiusEnts[i]->client->ps.eFlags&EF_HELD_BY_WAMPA)
+			||(radiusEnts[i]->client->ps.eFlags&EF_HELD_BY_SAND_CREATURE) )
+		{//can't be one being held
+			continue;
+		}
+		
+		if ( PM_LockedAnim( radiusEnts[i]->client->ps.torsoAnim )
+			|| PM_LockedAnim( radiusEnts[i]->client->ps.legsAnim ) )
+		{//don't interrupt
+			continue;
+		}
+		if ( radiusEnts[i]->client->ps.groundEntityNum == ENTITYNUM_NONE )
+		{//must be on ground
+			continue;
+		}
+		
+		if ( PM_InOnGroundAnim( &radiusEnts[i]->client->ps ) )
+		{//must be standing up
+			continue;
+		}
+
+		if ( fabs(radiusEnts[i]->currentOrigin[2]-ent->currentOrigin[2])>8.0f )
+		{//have to be close in Z
+			continue;
+		}
+
+		if ( !PM_HasAnimation( radiusEnts[i], BOTH_PLAYER_PA_1 ) )
+		{//doesn't have matching anims
+			continue;
+		}
+
+		distSq = DistanceSquared( radiusEnts[i]->currentOrigin, boltOrg );
+		if ( distSq < bestDistSq )
+		{
+			bestDistSq = distSq;
+			bestEnt = radiusEnts[i];
+		}
+	}
+
+	if ( bestEnt != NULL )
+	{
+		int lockType = LOCK_KYLE_GRAB1;
+		if ( ucmd->forwardmove > 0 )
+		{
+			lockType = LOCK_KYLE_GRAB3;
+		}
+		else if ( ucmd->forwardmove < 0 )
+		{
+			lockType = LOCK_KYLE_GRAB2;
+		}
+		WP_SabersCheckLock2( ent, bestEnt, (sabersLockMode_t)lockType );
+		return qtrue;
+	}
+	return qfalse;
+}
+
+qboolean G_PullAttack( gentity_t *ent, usercmd_t *ucmd )
+{
+	qboolean overridAngles = qfalse;
+	if ( ent->client->ps.torsoAnim == BOTH_PULL_IMPALE_STAB
+		|| ent->client->ps.torsoAnim == BOTH_PULL_IMPALE_SWING )
+	{//pulling
+		if ( ent->NPC )
+		{
+			VectorClear( ent->client->ps.moveDir );
+		}
+		overridAngles = (PM_LockAngles( ent, ucmd )?qtrue:overridAngles);
+		ucmd->forwardmove = ucmd->rightmove = ucmd->upmove = 0;
+	}
+	else if ( ent->client->ps.torsoAnim == BOTH_PULLED_INAIR_B
+		|| ent->client->ps.torsoAnim == BOTH_PULLED_INAIR_F )
+	{//being pulled
+		gentity_t *puller = &g_entities[ent->client->ps.pullAttackEntNum];
+		if ( puller
+			&& puller->inuse
+			&& puller->client
+			&& ( puller->client->ps.torsoAnim == BOTH_PULL_IMPALE_STAB
+				|| puller->client->ps.torsoAnim == BOTH_PULL_IMPALE_SWING ) )
+		{
+			vec3_t pullDir;
+			vec3_t pullPos;
+			//calc where to pull me to
+			/*
+			VectorCopy( puller->client->ps.saber[0].blade[0].muzzlePoint, pullPos );
+			VectorMA( pullPos, puller->client->ps.saber[0].blade[0].length*0.5f, puller->client->ps.saber[0].blade[0].muzzleDir, pullPos );
+			*/
+			vec3_t pullerFwd;
+			AngleVectors( puller->client->ps.viewangles, pullerFwd, NULL, NULL );
+			VectorMA( puller->currentOrigin, (puller->maxs[0]*1.5f)+16.0f, pullerFwd, pullPos );
+			//pull me towards that pos
+			VectorSubtract( pullPos, ent->currentOrigin, pullDir );
+			float pullDist = VectorNormalize( pullDir );
+			int	sweetSpotTime = (puller->client->ps.torsoAnim == BOTH_PULL_IMPALE_STAB)?1250:1350;
+			float pullLength = PM_AnimLength( puller->client->clientInfo.animFileIndex, (animNumber_t)puller->client->ps.torsoAnim )-sweetSpotTime;
+			if ( pullLength <= 0.25f )
+			{
+				pullLength = 0.25f;
+			}
+			//float pullTimeRemaining = ent->client->ps.pullAttackTime - level.time;
+			
+			//float pullSpeed = pullDist * (pullTimeRemaining/pullLength);
+			float pullSpeed = (pullDist*1000.0f)/pullLength;
+			
+			VectorScale( pullDir, pullSpeed, ent->client->ps.velocity );
+			//slide, if necessary
+			ent->client->ps.pm_flags |= PMF_TIME_NOFRICTION;
+			ent->client->ps.pm_time = 100;
+			//make it so I don't actually hurt them when pulled at them...
+			ent->forcePuller = puller->s.number;
+			ent->forcePushTime = level.time + 100; // let the push effect last for 100 more ms
+			//look at him
+			PM_AdjustAnglesToPuller( ent, puller, ucmd, qboolean(ent->client->ps.legsAnim==BOTH_PULLED_INAIR_B) );
+			overridAngles = qtrue;
+			//don't move
+			if ( ent->NPC )
+			{
+				VectorClear( ent->client->ps.moveDir );
+			}
+			ucmd->forwardmove = ucmd->rightmove = ucmd->upmove = 0;
+		}
+	}
+	return overridAngles;
+}
+
+void G_FixMins( gentity_t *ent )
+{
+	//do a trace to make sure it's okay
+	float  downdist = (DEFAULT_MINS_2-ent->mins[2]);
+	vec3_t end={ent->currentOrigin[0],ent->currentOrigin[1],ent->currentOrigin[2]+downdist}; 
+	trace_t	trace;
+	gi.trace( &trace, ent->currentOrigin, ent->mins, ent->maxs, end, ent->s.number, ent->clipmask );
+	if ( !trace.allsolid && !trace.startsolid )
+	{
+		if ( trace.fraction >= 1.0f )
+		{//all clear
+			//drop the bottom of my bbox back down
+			ent->mins[2] = DEFAULT_MINS_2;
+			if ( ent->client )
+			{
+				ent->client->ps.pm_flags &= ~PMF_FIX_MINS;
+			}
+		}
+		else
+		{//move me up so the bottom of my bbox will be where the trace ended, at least
+			//need to trace up, too
+			float updist = ((1.0f-trace.fraction) * -downdist);
+			end[2] = ent->currentOrigin[2]+updist; 
+			gi.trace( &trace, ent->currentOrigin, ent->mins, ent->maxs, end, ent->s.number, ent->clipmask );
+			if ( !trace.allsolid && !trace.startsolid )
+			{
+				if ( trace.fraction >= 1.0f )
+				{//all clear
+					//move me up
+					ent->currentOrigin[2] += updist;
+					//drop the bottom of my bbox back down
+					ent->mins[2] = DEFAULT_MINS_2;
+					G_SetOrigin( ent, ent->currentOrigin );
+					gi.linkentity( ent );
+					if ( ent->client )
+					{
+						ent->client->ps.pm_flags &= ~PMF_FIX_MINS;
+					}
+				}
+				else
+				{//crap, no room to expand!
+					if ( ent->client->ps.legsAnimTimer <= 200 )
+					{//at the end of the anim, and we can't leave ourselves like this
+						//so drop the maxs, put the mins back and move us up
+						ent->maxs[2] += downdist;
+						ent->currentOrigin[2] -= downdist;
+						ent->mins[2] = DEFAULT_MINS_2;
+						G_SetOrigin( ent, ent->currentOrigin );
+						gi.linkentity( ent );
+						//this way we'll be in a crouch when we're done
+						ent->client->ps.legsAnimTimer = ent->client->ps.torsoAnimTimer = 0;
+						ent->client->ps.pm_flags |= PMF_DUCKED;
+						//FIXME: do we need to set a crouch anim here?
+						if ( ent->client )
+						{
+							ent->client->ps.pm_flags &= ~PMF_FIX_MINS;
+						}
+					}
+				}
+			}//crap, stuck
+		}
+	}//crap, stuck!
+}
+
+
+qboolean G_CheckClampUcmd( gentity_t *ent, usercmd_t *ucmd )
+{
+	qboolean overridAngles = qfalse;
+
+	if ( ent->client->NPC_class == CLASS_PROTOCOL
+		|| ent->client->NPC_class == CLASS_R2D2
+		|| ent->client->NPC_class == CLASS_R5D2
+		|| ent->client->NPC_class == CLASS_GONK
+		|| ent->client->NPC_class == CLASS_MOUSE )
+	{//these droids *cannot* strafe (looks bad)
+		if ( ucmd->rightmove )
+		{
+			//clear the strafe
+			ucmd->rightmove = 0;
+			//movedir is invalid now, but PM_WalkMove will rebuild it from the ucmds, with the appropriate speed
+			VectorClear( ent->client->ps.moveDir );
+		}
+	}
+
+	if ( ent->client->ps.pullAttackEntNum < ENTITYNUM_WORLD
+		&& ent->client->ps.pullAttackTime > level.time )
+	{
+		return G_PullAttack( ent, ucmd );
+	}
+
+	if ( (ent->s.number < MAX_CLIENTS||G_ControlledByPlayer(ent))
+		&& ent->s.weapon == WP_MELEE
+		&& ent->client->ps.torsoAnim == BOTH_KYLE_GRAB )
+	{//see if we grabbed enemy
+		if ( ent->client->ps.torsoAnimTimer <= 200 )
+		{//close to end of anim
+			if ( G_GrabClient( ent, ucmd ) )
+			{//grabbed someone!
+			}
+			else
+			{//missed
+				NPC_SetAnim( ent, SETANIM_BOTH, BOTH_KYLE_MISS, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+				ent->client->ps.weaponTime = ent->client->ps.torsoAnimTimer;
+			}
+		}
+		ucmd->rightmove = ucmd->forwardmove = ucmd->upmove = 0;
+	}
+
+	if ( (!ent->s.number&&ent->aimDebounceTime>level.time) 
+		|| (ent->client->ps.pm_time && (ent->client->ps.pm_flags&PMF_TIME_KNOCKBACK)) 
+		|| ent->forcePushTime > level.time )
+	{//being knocked back, can't do anything!
+		ucmd->buttons = 0;
+		ucmd->forwardmove = 0;
+		ucmd->rightmove = 0;
+		ucmd->upmove = 0;
+		if ( ent->NPC )
+		{
+			VectorClear( ent->client->ps.moveDir );
+		}
+	}
+
+	overridAngles = (PM_AdjustAnglesForKnockdown( ent, ucmd, qfalse )?qtrue:overridAngles);
+	if ( PM_GetupAnimNoMove( ent->client->ps.legsAnim ) )
+	{
+		ucmd->forwardmove = ucmd->rightmove = 0;//ucmd->upmove = ?
+	}
+	//check saberlock
+	if ( ent->client->ps.saberLockTime > level.time )
+	{//in saberlock
+		ucmd->forwardmove = ucmd->rightmove = ucmd->upmove = 0;
+		if ( ent->client->ps.saberLockTime - level.time > SABER_LOCK_DELAYED_TIME )
+		{//2 second delay before either can push
+			//FIXME: base on difficulty
+			ucmd->buttons = 0;
+		}
+		else
+		{
+			ucmd->buttons &= ~(ucmd->buttons&~BUTTON_ATTACK);
+		}
+		overridAngles = (PM_AdjustAnglesForSaberLock( ent, ucmd )?qtrue:overridAngles);
+		if ( ent->NPC )
+		{
+			VectorClear( ent->client->ps.moveDir );
+		}
+	}
+	//check force drain
+	if ( (ent->client->ps.forcePowersActive&(1<<FP_DRAIN)) )
+	{//draining
+		ucmd->forwardmove = ucmd->rightmove = ucmd->upmove = 0;
+		ucmd->buttons &= ~(BUTTON_ATTACK|BUTTON_ALT_ATTACK|BUTTON_FORCE_FOCUS);
+		if ( ent->NPC )
+		{
+			VectorClear( ent->client->ps.moveDir );
+		}
+	}
+
+	if ( ent->client->ps.saberMove == LS_A_LUNGE )
+	{//can't move during lunge
+		ucmd->rightmove = ucmd->upmove = 0;
+		if ( ent->client->ps.legsAnimTimer > 500 && (ent->s.number || !player_locked) )
+		{
+			ucmd->forwardmove = 127;
+		}
+		else
+		{
+			ucmd->forwardmove = 0;
+		}
+		if ( ent->NPC )
+		{//invalid now
+			VectorClear( ent->client->ps.moveDir );
+		}
+	}
+
+	if ( ent->client->ps.legsAnim == BOTH_FORCEWALLRUNFLIP_ALT 
+		&& ent->client->ps.legsAnimTimer )
+	{
+		vec3_t vFwd, fwdAng = {0,ent->currentAngles[YAW],0};
+		AngleVectors( fwdAng, vFwd, NULL, NULL );
+		if ( ent->client->ps.groundEntityNum == ENTITYNUM_NONE )
+		{
+			float savZ = ent->client->ps.velocity[2];
+			VectorScale( vFwd, 100, ent->client->ps.velocity );
+			ent->client->ps.velocity[2] = savZ;
+		}
+		ucmd->forwardmove = ucmd->rightmove = ucmd->upmove = 0;
+		overridAngles = (PM_AdjustAnglesForWallRunUpFlipAlt( ent, ucmd )?qtrue:overridAngles);
+	}
+
+	if ( ent->client->ps.saberMove == LS_A_JUMP_T__B_ )
+	{//can't move during leap
+		if ( ent->client->ps.groundEntityNum != ENTITYNUM_NONE || (!ent->s.number && player_locked) )
+		{//hit the ground
+			ucmd->forwardmove = 0;
+		}
+		ucmd->rightmove = ucmd->upmove = 0;
+		if ( ent->NPC )
+		{//invalid now
+			VectorClear( ent->client->ps.moveDir );
+		}
+	}
+
+	if ( ent->client->ps.saberMove == LS_A_BACKFLIP_ATK
+		&& ent->client->ps.legsAnim == BOTH_JUMPATTACK7 )
+	{//backflip attack
+		if ( ent->client->ps.legsAnimTimer > 800 //not at end
+			&& PM_AnimLength( ent->client->clientInfo.animFileIndex, BOTH_JUMPATTACK7 ) - ent->client->ps.legsAnimTimer >= 400 )//not in beginning
+		{//middle of anim
+			if ( ent->client->ps.groundEntityNum != ENTITYNUM_NONE )
+			{//still on ground?
+				vec3_t yawAngles, backDir;
+
+				//push backwards some?
+				VectorSet( yawAngles, 0, ent->client->ps.viewangles[YAW]+180, 0 );
+				AngleVectors( yawAngles, backDir, 0, 0 );
+				VectorScale( backDir, 100, ent->client->ps.velocity );
+
+				//jump!
+				ent->client->ps.velocity[2] = 180;
+				ent->client->ps.forceJumpZStart = ent->client->ps.origin[2];//so we don't take damage if we land at same height
+				ent->client->ps.pm_flags |= PMF_JUMPING|PMF_SLOW_MO_FALL;
+
+				//FIXME: NPCs yell?
+				G_AddEvent( ent, EV_JUMP, 0 );
+				G_SoundOnEnt( ent, CHAN_BODY, "sound/weapons/force/jump.wav" );
+				ucmd->upmove = 0;//clear any actual jump command
+			}
+		}
+		ucmd->forwardmove = ucmd->rightmove = ucmd->upmove = 0;
+		if ( ent->NPC )
+		{//invalid now
+			VectorClear( ent->client->ps.moveDir );
+		}
+	}
+
+
+	if ( ent->client->ps.legsAnim == BOTH_JUMPATTACK6 
+		&& ent->client->ps.legsAnimTimer > 0 )
+	{
+		ucmd->forwardmove = ucmd->rightmove = ucmd->upmove = 0;
+		//FIXME: don't slide off people/obstacles?
+		if ( ent->client->ps.legsAnimTimer >= 100 //not at end
+			&& PM_AnimLength( ent->client->clientInfo.animFileIndex, BOTH_JUMPATTACK6 ) - ent->client->ps.legsAnimTimer >= 250 )//not in beginning
+		{//middle of anim
+			//push forward
+			ucmd->forwardmove = 127;
+		}
+		
+		if ( (ent->client->ps.legsAnimTimer >= 900 //not at end
+				&& PM_AnimLength( ent->client->clientInfo.animFileIndex, BOTH_JUMPATTACK6 ) - ent->client->ps.legsAnimTimer >= 950 ) //not in beginning
+			|| ( ent->client->ps.legsAnimTimer >= 1600 
+				&& PM_AnimLength( ent->client->clientInfo.animFileIndex, BOTH_JUMPATTACK6 ) - ent->client->ps.legsAnimTimer >= 400 ) )//not in beginning
+		{//one of the two jumps
+			if ( ent->client->ps.groundEntityNum != ENTITYNUM_NONE )
+			{//still on ground?
+				//jump!
+				ent->client->ps.velocity[2] = 250;
+				ent->client->ps.forceJumpZStart = ent->client->ps.origin[2];//so we don't take damage if we land at same height
+				ent->client->ps.pm_flags |= PMF_JUMPING;//|PMF_SLOW_MO_FALL;
+				//FIXME: NPCs yell?
+				G_AddEvent( ent, EV_JUMP, 0 );
+				G_SoundOnEnt( ent, CHAN_BODY, "sound/weapons/force/jump.wav" );
+			}
+			else
+			{//FIXME: if this is the second jump, maybe we should just stop the anim?
+			}
+		}
+		//else
+		{//disallow turning unless in the middle frame when you're on the ground
+			//overridAngles = (PM_AdjustAnglesForDualJumpAttack( ent, ucmd )?qtrue:overridAngles);
+		}
+
+		//dynamically reduce bounding box to let character sail over heads of enemies
+		if ( ( ent->client->ps.legsAnimTimer >= 1450
+				&& PM_AnimLength( ent->client->clientInfo.animFileIndex, BOTH_JUMPATTACK6 ) - ent->client->ps.legsAnimTimer >= 400 ) 
+			||(ent->client->ps.legsAnimTimer >= 400
+				&& PM_AnimLength( ent->client->clientInfo.animFileIndex, BOTH_JUMPATTACK6 ) - ent->client->ps.legsAnimTimer >= 1100 ) )
+		{//in a part of the anim that we're pretty much sideways in, raise up the mins
+			ent->mins[2] = 0;
+			ent->client->ps.pm_flags |= PMF_FIX_MINS;
+		}
+		else if ( (ent->client->ps.pm_flags&PMF_FIX_MINS) )
+		{//drop the mins back down
+			G_FixMins( ent );
+		}
+		if ( ent->NPC )
+		{//invalid now
+			VectorClear( ent->client->ps.moveDir );
+		}
+	}
+	else if ( (ent->client->ps.pm_flags&PMF_FIX_MINS) )
+	{
+		G_FixMins( ent );
+	}
+	
+	if ( ( ent->client->ps.legsAnim == BOTH_BUTTERFLY_FL1 
+			&& ent->client->ps.saberMove == LS_JUMPATTACK_STAFF_LEFT ) 
+		|| ( ent->client->ps.legsAnim == BOTH_BUTTERFLY_FR1 
+			&& ent->client->ps.saberMove == LS_JUMPATTACK_STAFF_RIGHT )
+		|| ( ent->client->ps.legsAnim == BOTH_BUTTERFLY_RIGHT
+			&& ent->client->ps.saberMove == LS_BUTTERFLY_RIGHT ) 
+		|| ( ent->client->ps.legsAnim == BOTH_BUTTERFLY_LEFT 
+			&& ent->client->ps.saberMove == LS_BUTTERFLY_LEFT ) )
+	{//forward flip/spin attack
+		ucmd->forwardmove = ucmd->rightmove = ucmd->upmove = 0;
+
+		/*if ( ent->client->ps.legsAnim == BOTH_BUTTERFLY_FL1 
+			|| ent->client->ps.legsAnim == BOTH_BUTTERFLY_FR1
+			|| ent->client->ps.legsAnim == BOTH_BUTTERFLY_LEFT
+			|| ent->client->ps.legsAnim == BOTH_BUTTERFLY RIGHT )*/
+		{
+			//FIXME: don't slide off people/obstacles?
+			if ( ent->client->ps.legsAnim != BOTH_BUTTERFLY_LEFT
+				&& ent->client->ps.legsAnim != BOTH_BUTTERFLY_RIGHT )
+			{
+				if ( ent->client->ps.legsAnimTimer >= 100 //not at end
+					&& PM_AnimLength( ent->client->clientInfo.animFileIndex, (animNumber_t)ent->client->ps.legsAnim ) - ent->client->ps.legsAnimTimer >= 250 )//not in beginning
+				{//middle of anim
+					//push forward
+					ucmd->forwardmove = 127;
+				}
+			}
+			
+			if ( ent->client->ps.legsAnimTimer >= 1700 && ent->client->ps.legsAnimTimer < 1800 )     
+			{//one of the two jumps
+				if ( ent->client->ps.groundEntityNum != ENTITYNUM_NONE )
+				{//still on ground?
+					//jump!
+					ent->client->ps.velocity[2] = 250;
+					ent->client->ps.forceJumpZStart = ent->client->ps.origin[2];//so we don't take damage if we land at same height
+					ent->client->ps.pm_flags |= PMF_JUMPING;//|PMF_SLOW_MO_FALL;
+					//FIXME: NPCs yell?
+					G_AddEvent( ent, EV_JUMP, 0 );
+					G_SoundOnEnt( ent, CHAN_BODY, "sound/weapons/force/jump.wav" );
+				}
+				else
+				{//FIXME: if this is the second jump, maybe we should just stop the anim?
+				}
+			}
+
+			//disallow turning unless in the middle frame when you're on the ground
+			//overridAngles = (PM_AdjustAnglesForDualJumpAttack( ent, ucmd )?qtrue:overridAngles);
+		}
+
+		if ( ent->NPC )
+		{//invalid now
+			VectorClear( ent->client->ps.moveDir );
+		}
+	}
+	
+	if ( ent->client->ps.legsAnim == BOTH_A7_SOULCAL
+		&& ent->client->ps.saberMove == LS_STAFF_SOULCAL )
+	{//forward spinning staff attack
+		ucmd->upmove = 0;
+
+		if ( PM_CanRollFromSoulCal( &ent->client->ps ) )
+		{
+			ucmd->upmove = -127;
+		}
+		else
+		{
+			ucmd->rightmove = 0;
+			//FIXME: don't slide off people/obstacles?
+			if ( ent->client->ps.legsAnimTimer >= 2750 )
+			{//not at end
+				//push forward
+				ucmd->forwardmove = 64;
+			}
+			else
+			{
+				ucmd->forwardmove = 0;
+			}
+		}
+		if ( ent->client->ps.legsAnimTimer >= 2650 
+			&& ent->client->ps.legsAnimTimer < 2850 )     
+		{//the jump
+			if ( ent->client->ps.groundEntityNum != ENTITYNUM_NONE )
+			{//still on ground?
+				//jump!
+				ent->client->ps.velocity[2] = 250;
+				ent->client->ps.forceJumpZStart = ent->client->ps.origin[2];//so we don't take damage if we land at same height
+				ent->client->ps.pm_flags |= PMF_JUMPING;//|PMF_SLOW_MO_FALL;
+				//FIXME: NPCs yell?
+				G_AddEvent( ent, EV_JUMP, 0 );
+				G_SoundOnEnt( ent, CHAN_BODY, "sound/weapons/force/jump.wav" );
+			}
+		}
+
+		if ( ent->NPC )
+		{//invalid now
+			VectorClear( ent->client->ps.moveDir );
+		}
+	}
+
+	if ( ent->client->ps.torsoAnim == BOTH_LK_DL_S_T_SB_1_W )
+	{
+		G_CamPullBackForLegsAnim( ent, qtrue );
+	}
+
+	if ( ent->client->ps.torsoAnim == BOTH_A6_FB
+		|| ent->client->ps.torsoAnim == BOTH_A6_LR )
+	{//can't turn or move during dual attack
+		if ( ent->NPC )
+		{
+			VectorClear( ent->client->ps.moveDir );
+		}
+		overridAngles = (PM_LockAngles( ent, ucmd )?qtrue:overridAngles);
+		ucmd->forwardmove = ucmd->rightmove = ucmd->upmove = 0;
+	}
+	else if ( ent->client->ps.legsAnim == BOTH_ROLL_STAB )
+	{
+		if ( ent->NPC )
+		{
+			VectorClear( ent->client->ps.moveDir );
+		}
+		overridAngles = (PM_LockAngles( ent, ucmd )?qtrue:overridAngles);
+		ucmd->forwardmove = ucmd->rightmove = ucmd->upmove = 0;
+		if ( ent->client->ps.legsAnimTimer )
+		{
+			ucmd->upmove = -127;
+		}
+		if ( ent->client->ps.dualSabers && ent->client->ps.saber[1].Active() )
+		{
+			G_CamPullBackForLegsAnim( ent );
+		}
+	}
+	else if ( PM_SuperBreakLoseAnim( ent->client->ps.torsoAnim ) )
+	{//can't turn during Kyle's grappling
+		if ( ent->NPC )
+		{
+			VectorClear( ent->client->ps.moveDir );
+		}
+		overridAngles = (PM_LockAngles( ent, ucmd )?qtrue:overridAngles);
+		ucmd->forwardmove = ucmd->rightmove = ucmd->upmove = 0;
+		if ( ent->client->ps.legsAnim == BOTH_LK_DL_ST_T_SB_1_L )
+		{
+            PM_CmdForRoll( &ent->client->ps, ucmd );
+			if ( ent->NPC )
+			{//invalid now
+				VectorClear( ent->client->ps.moveDir );
+			}
+			ent->client->ps.speed = 400;
+		}
+	}
+	else if ( ent->client->ps.torsoAnim==BOTH_FORCE_DRAIN_GRAB_START
+		|| ent->client->ps.torsoAnim==BOTH_FORCE_DRAIN_GRAB_HOLD
+		|| ent->client->ps.torsoAnim==BOTH_FORCE_DRAIN_GRAB_END
+		|| ent->client->ps.legsAnim==BOTH_FORCE_DRAIN_GRABBED )
+	{//can't turn or move
+		if ( ent->s.number < MAX_CLIENTS
+			|| G_ControlledByPlayer(ent) )
+		{//player
+			float forceDrainAngle = 90.0f;
+			if ( ent->client->ps.torsoAnim == BOTH_FORCE_DRAIN_GRAB_START )
+			{//starting drain
+				float animLength = PM_AnimLength( ent->client->clientInfo.animFileIndex, (animNumber_t)ent->client->ps.torsoAnim );
+				float elapsedTime = (float)(animLength-ent->client->ps.legsAnimTimer);
+				float angle = (elapsedTime/animLength)*forceDrainAngle;
+				cg.overrides.active |= CG_OVERRIDE_3RD_PERSON_ANG;
+				cg.overrides.thirdPersonAngle = cg_thirdPersonAngle.value+angle;
+			}
+			else if ( ent->client->ps.torsoAnim == BOTH_FORCE_DRAIN_GRAB_HOLD )
+			{//draining
+				cg.overrides.active |= CG_OVERRIDE_3RD_PERSON_ANG;
+				cg.overrides.thirdPersonAngle = cg_thirdPersonAngle.value+forceDrainAngle;
+			}
+			else if ( ent->client->ps.torsoAnim == BOTH_FORCE_DRAIN_GRAB_END )
+			{//ending drain
+				float animLength = PM_AnimLength( ent->client->clientInfo.animFileIndex, (animNumber_t)ent->client->ps.torsoAnim );
+				float elapsedTime = (float)(animLength-ent->client->ps.legsAnimTimer);
+				float angle = forceDrainAngle-((elapsedTime/animLength)*forceDrainAngle);
+				cg.overrides.active |= CG_OVERRIDE_3RD_PERSON_ANG;
+				cg.overrides.thirdPersonAngle = cg_thirdPersonAngle.value+angle;
+			}
+		}
+
+		if ( ent->NPC )
+		{
+			VectorClear( ent->client->ps.moveDir );
+		}
+		ucmd->forwardmove = ucmd->rightmove = ucmd->upmove = 0;
+		overridAngles = PM_LockAngles( ent, ucmd )?qtrue:overridAngles;
+	}
+	else if ( ent->client->ps.legsAnim==BOTH_PLAYER_PA_1
+		|| ent->client->ps.legsAnim==BOTH_PLAYER_PA_2
+		|| ent->client->ps.legsAnim==BOTH_PLAYER_PA_3
+		|| ent->client->ps.legsAnim==BOTH_PLAYER_PA_3_FLY
+		|| ent->client->ps.legsAnim==BOTH_KYLE_PA_1
+		|| ent->client->ps.legsAnim==BOTH_KYLE_PA_2
+		|| ent->client->ps.legsAnim==BOTH_KYLE_PA_3 )
+	{//can't turn during Kyle's grappling
+		if ( ent->NPC )
+		{
+			VectorClear( ent->client->ps.moveDir );
+		}
+		overridAngles = PM_AdjustAnglesForGrapple( ent, ucmd )?qtrue:overridAngles;
+		//if ( g_debugMelee->integer )
+		{//actually do some damage during sequence
+			int damage = 0;
+			int dflags = (DAMAGE_NO_KNOCKBACK|DAMAGE_NO_ARMOR|DAMAGE_NO_KILL);
+			if ( TIMER_Done( ent, "grappleDamageDebounce" ) )
+			{
+				switch ( ent->client->ps.legsAnim )
+				{
+				case BOTH_PLAYER_PA_1:
+					if ( ent->client->ps.legsAnimTimer <= 3150
+						&& ent->client->ps.legsAnimTimer > 3050 )
+					{
+						TIMER_Set( ent, "grappleDamageDebounce", 150 );
+						if ( ent->s.number < MAX_CLIENTS )
+						{//special case
+							damage = Q_irand( 1, 3 );
+						}
+						else
+						{
+							damage = Q_irand( 3, 5 );
+						}
+					}
+					if ( ent->client->ps.legsAnimTimer <= 1150
+						&& ent->client->ps.legsAnimTimer > 10500 )
+					{
+						TIMER_Set( ent, "grappleDamageDebounce", 150 );
+						if ( ent->s.number < MAX_CLIENTS )
+						{//special case
+							damage = Q_irand( 3, 5 );
+						}
+						else
+						{
+							damage = Q_irand( 5, 8 );
+						}
+					}
+					if ( ent->client->ps.legsAnimTimer <= 100 )
+					{
+						TIMER_Set( ent, "grappleDamageDebounce", 150 );
+						if ( ent->s.number < MAX_CLIENTS )
+						{//special case
+							damage = Q_irand( 5, 8 );
+						}
+						else
+						{
+							damage = Q_irand( 10, 20 );
+						}
+						dflags &= ~DAMAGE_NO_KILL;
+					}
+					break;
+				case BOTH_PLAYER_PA_2:
+					if ( ent->client->ps.legsAnimTimer <= 5700
+						&& ent->client->ps.legsAnimTimer > 5600 )
+					{
+						TIMER_Set( ent, "grappleDamageDebounce", 150 );
+						if ( ent->s.number < MAX_CLIENTS )
+						{//special case
+							damage = Q_irand( 3, 6 );
+						}
+						else
+						{
+							damage = Q_irand( 7, 10 );
+						}
+					}
+					if ( ent->client->ps.legsAnimTimer <= 5200
+						&& ent->client->ps.legsAnimTimer > 5100 )
+					{
+						TIMER_Set( ent, "grappleDamageDebounce", 150 );
+						if ( ent->s.number < MAX_CLIENTS )
+						{//special case
+							damage = Q_irand( 1, 3 );
+						}
+						else
+						{
+							damage = Q_irand( 3, 5 );
+						}
+					}
+					if ( ent->client->ps.legsAnimTimer <= 4550
+						&& ent->client->ps.legsAnimTimer > 4450 )
+					{
+						TIMER_Set( ent, "grappleDamageDebounce", 150 );
+						if ( ent->s.number < MAX_CLIENTS )
+						{//special case
+							damage = Q_irand( 3, 6 );
+						}
+						else
+						{
+							damage = Q_irand( 10, 15 );
+						}
+					}
+					if ( ent->client->ps.legsAnimTimer <= 3550
+						&& ent->client->ps.legsAnimTimer > 3450 )
+					{
+						TIMER_Set( ent, "grappleDamageDebounce", 150 );
+						if ( ent->s.number < MAX_CLIENTS )
+						{//special case
+							damage = Q_irand( 3, 6 );
+						}
+						else
+						{
+							damage = Q_irand( 10, 20 );
+						}
+						dflags &= ~DAMAGE_NO_KILL;
+					}
+					break;
+				case BOTH_PLAYER_PA_3:
+					if ( ent->client->ps.legsAnimTimer <= 3800
+						&& ent->client->ps.legsAnimTimer > 3700 )
+					{
+						TIMER_Set( ent, "grappleDamageDebounce", 150 );
+						if ( ent->s.number < MAX_CLIENTS )
+						{//special case
+							damage = Q_irand( 2, 5 );
+						}
+						else
+						{
+							damage = Q_irand( 5, 8 );
+						}
+					}
+					if ( ent->client->ps.legsAnimTimer <= 3100
+						&& ent->client->ps.legsAnimTimer > 3000 )
+					{
+						TIMER_Set( ent, "grappleDamageDebounce", 150 );
+						if ( ent->s.number < MAX_CLIENTS )
+						{//special case
+							damage = Q_irand( 2, 5 );
+						}
+						else
+						{
+							damage = Q_irand( 5, 8 );
+						}
+					}
+					if ( ent->client->ps.legsAnimTimer <= 1650
+						&& ent->client->ps.legsAnimTimer > 1550 )
+					{
+						TIMER_Set( ent, "grappleDamageDebounce", 150 );
+						if ( ent->s.number < MAX_CLIENTS )
+						{//special case
+							damage = Q_irand( 3, 6 );
+						}
+						else
+						{
+							damage = Q_irand( 7, 12 );
+						}
+					}
+					break;
+				case BOTH_PLAYER_PA_3_FLY:
+					/*
+					if ( ent->s.number < MAX_CLIENTS )
+					{//special case
+						if ( ent->client->ps.legsAnimTimer > PLAYER_KNOCKDOWN_HOLD_EXTRA_TIME
+							&& ent->client->ps.legsAnimTimer <= PLAYER_KNOCKDOWN_HOLD_EXTRA_TIME + 100 )
+						{
+							TIMER_Set( ent, "grappleDamageDebounce", 150 );
+							damage = Q_irand( 4, 8 );
+							dflags &= ~DAMAGE_NO_KILL;
+						}
+					}
+					else*/ if ( ent->client->ps.legsAnimTimer <= 100 )
+					{
+						TIMER_Set( ent, "grappleDamageDebounce", 150 );
+						damage = Q_irand( 10, 20 );
+						dflags &= ~DAMAGE_NO_KILL;
+					}
+					break;
+				}
+				if ( damage )
+				{
+					G_Damage( ent, ent->enemy, ent->enemy, NULL, ent->currentOrigin, damage, dflags, MOD_MELEE );//MOD_IMPACT?
+				}
+			}
+		}
+		qboolean clearMove = qtrue;
+		int endOfAnimTime = 100;
+		if ( ent->s.number < MAX_CLIENTS 
+			&& ent->client->ps.legsAnim == BOTH_PLAYER_PA_3_FLY )
+		{//player holds extra long so you have more time to decide to do the quick getup
+			//endOfAnimTime += PLAYER_KNOCKDOWN_HOLD_EXTRA_TIME;
+			if ( ent->client->ps.legsAnimTimer <= endOfAnimTime )//PLAYER_KNOCKDOWN_HOLD_EXTRA_TIME )
+			{
+				clearMove = qfalse;
+			}
+		}
+		if ( clearMove )
+		{
+			ucmd->forwardmove = ucmd->rightmove = ucmd->upmove = 0;
+		}
+
+		if ( ent->client->ps.legsAnimTimer <= endOfAnimTime )
+		{//pretty much done with the anim, so get up now
+			if ( ent->client->ps.legsAnim==BOTH_PLAYER_PA_3 )
+			{
+				vec3_t ang = {10,ent->currentAngles[YAW],0};
+				vec3_t throwDir;
+				AngleVectors( ang, throwDir, NULL, NULL );
+				if ( !(ent->flags&FL_NO_KNOCKBACK) )
+				{
+					G_Throw( ent, throwDir, -100 );
+				}
+				ent->client->ps.legsAnimTimer = ent->client->ps.torsoAnimTimer = 0;
+				NPC_SetAnim( ent, SETANIM_BOTH, BOTH_PLAYER_PA_3_FLY, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+				ent->client->ps.weaponTime = ent->client->ps.legsAnimTimer;
+				/*
+				if ( ent->s.number < MAX_CLIENTS )
+				{//player holds extra long so you have more time to decide to do the quick getup
+					ent->client->ps.legsAnimTimer += PLAYER_KNOCKDOWN_HOLD_EXTRA_TIME;
+					ent->client->ps.torsoAnimTimer += PLAYER_KNOCKDOWN_HOLD_EXTRA_TIME;
+				}
+				*/
+				//force-thrown - FIXME: start earlier?
+				ent->forcePushTime = level.time + 500;
+			}
+			else if ( ent->client->ps.legsAnim==BOTH_PLAYER_PA_1 )
+			{
+				vec3_t ang = {10,ent->currentAngles[YAW],0};
+				vec3_t throwDir;
+				AngleVectors( ang, throwDir, NULL, NULL );
+				if ( !(ent->flags&FL_NO_KNOCKBACK) )
+				{
+					G_Throw( ent, throwDir, -100 );
+				}
+				ent->client->ps.legsAnimTimer = ent->client->ps.torsoAnimTimer = 0;
+				NPC_SetAnim( ent, SETANIM_BOTH, BOTH_KNOCKDOWN2, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+				ent->client->ps.weaponTime = ent->client->ps.legsAnimTimer;
+				if ( ent->s.number < MAX_CLIENTS )
+				{//player holds extra long so you have more time to decide to do the quick getup
+					ent->client->ps.legsAnimTimer += PLAYER_KNOCKDOWN_HOLD_EXTRA_TIME;
+					ent->client->ps.torsoAnimTimer += PLAYER_KNOCKDOWN_HOLD_EXTRA_TIME;
+				}
+			}
+			//FIXME: should end so you can do a getup
+			/*
+			else if ( ent->client->ps.legsAnim==BOTH_PLAYER_PA_2 )
+			{
+				ent->client->ps.legsAnimTimer = ent->client->ps.torsoAnimTimer = 0;
+				NPC_SetAnim( ent, SETANIM_BOTH, BOTH_GETUP1, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+				ent->client->ps.weaponTime = ent->client->ps.legsAnimTimer;
+			}
+			*/
+		}
+		if ( d_slowmodeath->integer <= 3 
+			&& ent->s.number < MAX_CLIENTS )
+		{//no matrix effect, so slide the camera back and to the side
+			G_CamPullBackForLegsAnim( ent );
+			G_CamCircleForLegsAnim( ent );
+		}
+	}
+	else if ( ent->client->ps.legsAnim == BOTH_FORCELONGLEAP_START
+		|| ent->client->ps.legsAnim == BOTH_FORCELONGLEAP_ATTACK
+		|| ent->client->ps.legsAnim == BOTH_FORCELONGLEAP_LAND )
+	{//can't turn during force leap
+		if ( ent->NPC )
+		{
+			VectorClear( ent->client->ps.moveDir );
+		}
+		overridAngles = PM_AdjustAnglesForLongJump( ent, ucmd )?qtrue:overridAngles;
+	}
+	else if ( PM_KickingAnim( ent->client->ps.legsAnim )
+		|| ent->client->ps.legsAnim == BOTH_ARIAL_F1
+		|| ent->client->ps.legsAnim == BOTH_ARIAL_LEFT
+		|| ent->client->ps.legsAnim == BOTH_ARIAL_RIGHT
+		|| ent->client->ps.legsAnim == BOTH_CARTWHEEL_LEFT
+		|| ent->client->ps.legsAnim == BOTH_CARTWHEEL_RIGHT
+		|| ent->client->ps.legsAnim == BOTH_JUMPATTACK7
+		|| ent->client->ps.legsAnim == BOTH_BUTTERFLY_FL1 
+		|| ent->client->ps.legsAnim == BOTH_BUTTERFLY_FR1 
+		|| ent->client->ps.legsAnim == BOTH_BUTTERFLY_RIGHT
+		|| ent->client->ps.legsAnim == BOTH_BUTTERFLY_LEFT 
+		|| ent->client->ps.legsAnim == BOTH_A7_SOULCAL )
+	{//can't move, check for damage frame
+		if ( PM_KickingAnim( ent->client->ps.legsAnim ) )
+		{
+			ucmd->forwardmove = ucmd->rightmove = 0;
+			if ( ent->NPC )
+			{
+				VectorClear( ent->client->ps.moveDir );
+			}
+		}
+		vec3_t	kickDir={0,0,0}, kickDir2={0,0,0}, kickEnd={0,0,0}, kickEnd2={0,0,0}, fwdAngs = {0,ent->client->ps.viewangles[YAW],0};
+		float animLength = PM_AnimLength( ent->client->clientInfo.animFileIndex, (animNumber_t)ent->client->ps.legsAnim );
+		float elapsedTime = (float)(animLength-ent->client->ps.legsAnimTimer);
+		float remainingTime = (animLength-elapsedTime);
+		float kickDist = (ent->maxs[0]*1.5f)+STAFF_KICK_RANGE+8.0f;//fudge factor of 8
+		float kickDist2 = kickDist;
+		int	  kickDamage = Q_irand( 3, 8 );
+		int	  kickDamage2 = Q_irand( 3, 8 );
+		int	  kickPush = Q_flrand( 100.0f, 200.0f );//Q_flrand( 50.0f, 100.0f );
+		int	  kickPush2 = Q_flrand( 100.0f, 200.0f );//Q_flrand( 50.0f, 100.0f );
+		qboolean doKick = qfalse;
+		qboolean doKick2 = qfalse;
+		qboolean kickSoundOnWalls = qfalse;
+		//HMM... or maybe trace from origin to footRBolt/footLBolt?  Which one?  G2 trace?  Will do hitLoc, if so...
+		if ( ent->client->ps.torsoAnim == BOTH_A7_HILT )
+		{
+			if ( elapsedTime >= 250 && remainingTime >= 250 )
+			{//front
+				doKick = qtrue;
+				if ( ent->handRBolt != -1 )
+				{//actually trace to a bolt
+					G_GetBoltPosition( ent, ent->handRBolt, kickEnd );
+					VectorSubtract( kickEnd, ent->currentOrigin, kickDir );
+					kickDir[2] = 0;//ah, flatten it, I guess...
+					VectorNormalize( kickDir );
+				}
+				else
+				{//guess
+					AngleVectors( fwdAngs, kickDir, NULL, NULL );
+				}
+			}
+		}
+		else
+		{
+			switch ( ent->client->ps.legsAnim )
+			{
+			case BOTH_A7_SOULCAL:
+				kickPush = Q_flrand( 150.0f, 250.0f );//Q_flrand( 75.0f, 125.0f );
+				if ( elapsedTime >= 1400 && elapsedTime <= 1500 )
+				{//right leg
+					doKick = qtrue;
+					if ( ent->footRBolt != -1 )
+					{//actually trace to a bolt
+						G_GetBoltPosition( ent, ent->footRBolt, kickEnd );
+						VectorSubtract( kickEnd, ent->currentOrigin, kickDir );
+						kickDir[2] = 0;//ah, flatten it, I guess...
+						VectorNormalize( kickDir );
+					}
+					else
+					{//guess
+						AngleVectors( fwdAngs, kickDir, NULL, NULL );
+					}
+				}
+				break;
+			case BOTH_ARIAL_F1:
+				if ( elapsedTime >= 550 && elapsedTime <= 1000 )
+				{//right leg
+					doKick = qtrue;
+					if ( ent->footRBolt != -1 )
+					{//actually trace to a bolt
+						G_GetBoltPosition( ent, ent->footRBolt, kickEnd );
+						VectorSubtract( kickEnd, ent->currentOrigin, kickDir );
+						kickDir[2] = 0;//ah, flatten it, I guess...
+						VectorNormalize( kickDir );
+					}
+					else
+					{//guess
+						AngleVectors( fwdAngs, kickDir, NULL, NULL );
+					}
+				}
+				if ( elapsedTime >= 800 && elapsedTime <= 1200 )
+				{//left leg
+					doKick2 = qtrue;
+					if ( ent->footLBolt != -1 )
+					{//actually trace to a bolt
+						G_GetBoltPosition( ent, ent->footLBolt, kickEnd2 );
+						VectorSubtract( kickEnd2, ent->currentOrigin, kickDir2 );
+						kickDir2[2] = 0;//ah, flatten it, I guess...
+						VectorNormalize( kickDir2 );
+					}
+					else
+					{//guess
+						AngleVectors( fwdAngs, kickDir2, NULL, NULL );
+					}
+				}
+				break;
+			case BOTH_ARIAL_LEFT:
+			case BOTH_ARIAL_RIGHT:
+				if ( elapsedTime >= 200 && elapsedTime <= 600 )
+				{//lead leg
+					int footBolt = (ent->client->ps.legsAnim==BOTH_ARIAL_LEFT)?ent->footRBolt:ent->footLBolt;//mirrored anims
+					doKick = qtrue;
+					if ( footBolt != -1 )
+					{//actually trace to a bolt
+						G_GetBoltPosition( ent, footBolt, kickEnd );
+						VectorSubtract( kickEnd, ent->currentOrigin, kickDir );
+						kickDir[2] = 0;//ah, flatten it, I guess...
+						VectorNormalize( kickDir );
+					}
+					else
+					{//guess
+						AngleVectors( fwdAngs, kickDir, NULL, NULL );
+					}
+				}
+				if ( elapsedTime >= 400 && elapsedTime <= 850 )
+				{//trailing leg
+					int footBolt = (ent->client->ps.legsAnim==BOTH_ARIAL_LEFT)?ent->footLBolt:ent->footRBolt;//mirrored anims
+					doKick2 = qtrue;
+					if ( footBolt != -1 )
+					{//actually trace to a bolt
+						G_GetBoltPosition( ent, footBolt, kickEnd2 );
+						VectorSubtract( kickEnd2, ent->currentOrigin, kickDir2 );
+						kickDir2[2] = 0;//ah, flatten it, I guess...
+						VectorNormalize( kickDir2 );
+					}
+					else
+					{//guess
+						AngleVectors( fwdAngs, kickDir2, NULL, NULL );
+					}
+				}
+				break;
+			case BOTH_CARTWHEEL_LEFT:
+			case BOTH_CARTWHEEL_RIGHT:
+				if ( elapsedTime >= 200 && elapsedTime <= 600 )
+				{//lead leg
+					int footBolt = (ent->client->ps.legsAnim==BOTH_CARTWHEEL_LEFT)?ent->footRBolt:ent->footLBolt;//mirrored anims
+					doKick = qtrue;
+					if ( footBolt != -1 )
+					{//actually trace to a bolt
+						G_GetBoltPosition( ent, footBolt, kickEnd );
+						VectorSubtract( kickEnd, ent->currentOrigin, kickDir );
+						kickDir[2] = 0;//ah, flatten it, I guess...
+						VectorNormalize( kickDir );
+					}
+					else
+					{//guess
+						AngleVectors( fwdAngs, kickDir, NULL, NULL );
+					}
+				}
+				if ( elapsedTime >= 350 && elapsedTime <= 650 )
+				{//trailing leg
+					int footBolt = (ent->client->ps.legsAnim==BOTH_CARTWHEEL_LEFT)?ent->footLBolt:ent->footRBolt;//mirrored anims
+					doKick2 = qtrue;
+					if ( footBolt != -1 )
+					{//actually trace to a bolt
+						G_GetBoltPosition( ent, footBolt, kickEnd2 );
+						VectorSubtract( kickEnd2, ent->currentOrigin, kickDir2 );
+						kickDir2[2] = 0;//ah, flatten it, I guess...
+						VectorNormalize( kickDir2 );
+					}
+					else
+					{//guess
+						AngleVectors( fwdAngs, kickDir2, NULL, NULL );
+					}
+				}
+				break;
+			case BOTH_JUMPATTACK7:
+				if ( elapsedTime >= 300 && elapsedTime <= 900 )
+				{//right knee
+					doKick = qtrue;
+					if ( ent->kneeRBolt != -1 )
+					{//actually trace to a bolt
+						G_GetBoltPosition( ent, ent->kneeRBolt, kickEnd );
+						VectorSubtract( kickEnd, ent->currentOrigin, kickDir );
+						kickDir[2] = 0;//ah, flatten it, I guess...
+						VectorNormalize( kickDir );
+					}
+					else
+					{//guess
+						AngleVectors( fwdAngs, kickDir, NULL, NULL );
+					}
+				}
+				if ( elapsedTime >= 600 && elapsedTime <= 900 )
+				{//left leg
+					doKick2 = qtrue;
+					if ( ent->footLBolt != -1 )
+					{//actually trace to a bolt
+						G_GetBoltPosition( ent, ent->footLBolt, kickEnd2 );
+						VectorSubtract( kickEnd2, ent->currentOrigin, kickDir2 );
+						kickDir2[2] = 0;//ah, flatten it, I guess...
+						VectorNormalize( kickDir2 );
+					}
+					else
+					{//guess
+						AngleVectors( fwdAngs, kickDir2, NULL, NULL );
+					}
+				}
+				break;
+			case BOTH_BUTTERFLY_FL1: 
+			case BOTH_BUTTERFLY_FR1:
+				if ( elapsedTime >= 950 && elapsedTime <= 1300 )
+				{//lead leg
+					int footBolt = (ent->client->ps.legsAnim==BOTH_BUTTERFLY_FL1)?ent->footRBolt:ent->footLBolt;//mirrored anims
+					doKick = qtrue;
+					if ( footBolt != -1 )
+					{//actually trace to a bolt
+						G_GetBoltPosition( ent, footBolt, kickEnd );
+						VectorSubtract( kickEnd, ent->currentOrigin, kickDir );
+						kickDir[2] = 0;//ah, flatten it, I guess...
+						VectorNormalize( kickDir );
+					}
+					else
+					{//guess
+						AngleVectors( fwdAngs, kickDir, NULL, NULL );
+					}
+				}
+				if ( elapsedTime >= 1150 && elapsedTime <= 1600 )
+				{//trailing leg
+					int footBolt = (ent->client->ps.legsAnim==BOTH_BUTTERFLY_FL1)?ent->footLBolt:ent->footRBolt;//mirrored anims
+					doKick2 = qtrue;
+					if ( footBolt != -1 )
+					{//actually trace to a bolt
+						G_GetBoltPosition( ent, footBolt, kickEnd2 );
+						VectorSubtract( kickEnd2, ent->currentOrigin, kickDir2 );
+						kickDir2[2] = 0;//ah, flatten it, I guess...
+						VectorNormalize( kickDir2 );
+					}
+					else
+					{//guess
+						AngleVectors( fwdAngs, kickDir2, NULL, NULL );
+					}
+				}
+				break;
+			case BOTH_BUTTERFLY_LEFT:
+			case BOTH_BUTTERFLY_RIGHT:
+				if ( (elapsedTime >= 100 && elapsedTime <= 450)
+					|| (elapsedTime >= 1100 && elapsedTime <= 1350) )
+				{//lead leg
+					int footBolt = (ent->client->ps.legsAnim==BOTH_BUTTERFLY_LEFT)?ent->footLBolt:ent->footRBolt;//mirrored anims
+					doKick = qtrue;
+					if ( footBolt != -1 )
+					{//actually trace to a bolt
+						G_GetBoltPosition( ent, footBolt, kickEnd );
+						VectorSubtract( kickEnd, ent->currentOrigin, kickDir );
+						kickDir[2] = 0;//ah, flatten it, I guess...
+						VectorNormalize( kickDir );
+					}
+					else
+					{//guess
+						AngleVectors( fwdAngs, kickDir, NULL, NULL );
+					}
+				}
+				if ( elapsedTime >= 900 && elapsedTime <= 1600 )
+				{//trailing leg
+					int footBolt = (ent->client->ps.legsAnim==BOTH_BUTTERFLY_LEFT)?ent->footRBolt:ent->footLBolt;//mirrored anims
+					doKick2 = qtrue;
+					if ( footBolt != -1 )
+					{//actually trace to a bolt
+						G_GetBoltPosition( ent, footBolt, kickEnd2 );
+						VectorSubtract( kickEnd2, ent->currentOrigin, kickDir2 );
+						kickDir2[2] = 0;//ah, flatten it, I guess...
+						VectorNormalize( kickDir2 );
+					}
+					else
+					{//guess
+						AngleVectors( fwdAngs, kickDir2, NULL, NULL );
+					}
+				}
+				break;
+			case BOTH_GETUP_BROLL_B:
+			case BOTH_GETUP_BROLL_F:
+			case BOTH_GETUP_FROLL_B:
+			case BOTH_GETUP_FROLL_F:
+				kickPush = Q_flrand( 150.0f, 250.0f );//Q_flrand( 75.0f, 125.0f );
+				if ( elapsedTime >= 250 && remainingTime >= 250 )
+				{//front
+					doKick = qtrue;
+					if ( ent->footRBolt != -1 )
+					{//actually trace to a bolt
+						G_GetBoltPosition( ent, ent->footRBolt, kickEnd );
+						VectorSubtract( kickEnd, ent->currentOrigin, kickDir );
+						kickDir[2] = 0;//ah, flatten it, I guess...
+						VectorNormalize( kickDir );
+					}
+					else
+					{//guess
+						AngleVectors( fwdAngs, kickDir, NULL, NULL );
+					}
+				}
+				if ( ent->client->ps.legsAnim == BOTH_GETUP_BROLL_B
+					|| ent->client->ps.legsAnim == BOTH_GETUP_FROLL_B )
+				{//rolling back, pull back the view
+					G_CamPullBackForLegsAnim( ent );
+				}
+				break;
+			case BOTH_A7_KICK_F_AIR:
+				kickPush = Q_flrand( 150.0f, 250.0f );//Q_flrand( 75.0f, 125.0f );
+				kickSoundOnWalls = qtrue;
+				if ( elapsedTime >= 100 && remainingTime >= 500 )
+				{//front
+					doKick = qtrue;
+					if ( ent->footRBolt != -1 )
+					{//actually trace to a bolt
+						G_GetBoltPosition( ent, ent->footRBolt, kickEnd );
+						VectorSubtract( kickEnd, ent->currentOrigin, kickDir );
+						kickDir[2] = 0;//ah, flatten it, I guess...
+						VectorNormalize( kickDir );
+					}
+					else
+					{//guess
+						AngleVectors( fwdAngs, kickDir, NULL, NULL );
+					}
+				}
+				break;
+			case BOTH_A7_KICK_F:
+				kickSoundOnWalls = qtrue;
+				//FIXME: push forward?
+				if ( elapsedTime >= 250 && remainingTime >= 250 )
+				{//front
+					doKick = qtrue;
+					if ( ent->footRBolt != -1 )
+					{//actually trace to a bolt
+						G_GetBoltPosition( ent, ent->footRBolt, kickEnd );
+						VectorSubtract( kickEnd, ent->currentOrigin, kickDir );
+						kickDir[2] = 0;//ah, flatten it, I guess...
+						VectorNormalize( kickDir );
+					}
+					else
+					{//guess
+						AngleVectors( fwdAngs, kickDir, NULL, NULL );
+					}
+				}
+				break;
+			case BOTH_A7_KICK_B_AIR:
+				kickPush = Q_flrand( 150.0f, 250.0f );//Q_flrand( 75.0f, 125.0f );
+				kickSoundOnWalls = qtrue;
+				if ( elapsedTime >= 100 && remainingTime >= 400 )
+				{//back
+					doKick = qtrue;
+					if ( ent->footRBolt != -1 )
+					{//actually trace to a bolt
+						G_GetBoltPosition( ent, ent->footRBolt, kickEnd );
+						VectorSubtract( kickEnd, ent->currentOrigin, kickDir );
+						kickDir[2] = 0;//ah, flatten it, I guess...
+						VectorNormalize( kickDir );
+					}
+					else
+					{//guess
+						AngleVectors( fwdAngs, kickDir, NULL, NULL );
+						VectorScale( kickDir, -1, kickDir );
+					}
+				}
+				break;
+			case BOTH_A7_KICK_B:
+				kickSoundOnWalls = qtrue;
+				if ( elapsedTime >= 250 && remainingTime >= 250 )
+				{//back
+					doKick = qtrue;
+					if ( ent->footRBolt != -1 )
+					{//actually trace to a bolt
+						G_GetBoltPosition( ent, ent->footRBolt, kickEnd );
+						VectorSubtract( kickEnd, ent->currentOrigin, kickDir );
+						kickDir[2] = 0;//ah, flatten it, I guess...
+						VectorNormalize( kickDir );
+					}
+					else
+					{//guess
+						AngleVectors( fwdAngs, kickDir, NULL, NULL );
+						VectorScale( kickDir, -1, kickDir );
+					}
+				}
+				break;
+			case BOTH_A7_KICK_R_AIR:
+				kickPush = Q_flrand( 150.0f, 250.0f );//Q_flrand( 75.0f, 125.0f );
+				kickSoundOnWalls = qtrue;
+				if ( elapsedTime >= 150 && remainingTime >= 300 )
+				{//left
+					doKick = qtrue;
+					if ( ent->footLBolt != -1 )
+					{//actually trace to a bolt
+						G_GetBoltPosition( ent, ent->footLBolt, kickEnd );
+						VectorSubtract( kickEnd, ent->currentOrigin, kickDir );
+						kickDir[2] = 0;//ah, flatten it, I guess...
+						VectorNormalize( kickDir );
+					}
+					else
+					{//guess
+						AngleVectors( fwdAngs, NULL, kickDir, NULL );
+						VectorScale( kickDir, -1, kickDir );
+					}
+				}
+				break;
+			case BOTH_A7_KICK_R:
+				kickSoundOnWalls = qtrue;
+				//FIXME: push right?
+				if ( elapsedTime >= 250 && remainingTime >= 250 )
+				{//right
+					doKick = qtrue;
+					if ( ent->footRBolt != -1 )
+					{//actually trace to a bolt
+						G_GetBoltPosition( ent, ent->footRBolt, kickEnd );
+						VectorSubtract( kickEnd, ent->currentOrigin, kickDir );
+						kickDir[2] = 0;//ah, flatten it, I guess...
+						VectorNormalize( kickDir );
+					}
+					else
+					{//guess
+						AngleVectors( fwdAngs, NULL, kickDir, NULL );
+					}
+				}
+				break;
+			case BOTH_A7_KICK_L_AIR:
+				kickPush = Q_flrand( 150.0f, 250.0f );//Q_flrand( 75.0f, 125.0f );
+				kickSoundOnWalls = qtrue;
+				if ( elapsedTime >= 150 && remainingTime >= 300 )
+				{//left
+					doKick = qtrue;
+					if ( ent->footLBolt != -1 )
+					{//actually trace to a bolt
+						G_GetBoltPosition( ent, ent->footLBolt, kickEnd );
+						VectorSubtract( kickEnd, ent->currentOrigin, kickDir );
+						kickDir[2] = 0;//ah, flatten it, I guess...
+						VectorNormalize( kickDir );
+					}
+					else
+					{//guess
+						AngleVectors( fwdAngs, NULL, kickDir, NULL );
+						VectorScale( kickDir, -1, kickDir );
+					}
+				}
+				break;
+			case BOTH_A7_KICK_L:
+				kickSoundOnWalls = qtrue;
+				//FIXME: push left?
+				if ( elapsedTime >= 250 && remainingTime >= 250 )
+				{//left
+					doKick = qtrue;
+					if ( ent->footLBolt != -1 )
+					{//actually trace to a bolt
+						G_GetBoltPosition( ent, ent->footLBolt, kickEnd );
+						VectorSubtract( kickEnd, ent->currentOrigin, kickDir );
+						kickDir[2] = 0;//ah, flatten it, I guess...
+						VectorNormalize( kickDir );
+					}
+					else
+					{//guess
+						AngleVectors( fwdAngs, NULL, kickDir, NULL );
+						VectorScale( kickDir, -1, kickDir );
+					}
+				}
+				break;
+			case BOTH_A7_KICK_S:
+				kickPush = Q_flrand( 150.0f, 250.0f );//Q_flrand( 75.0f, 125.0f );
+				if ( ent->footRBolt != -1 )
+				{//actually trace to a bolt
+					if ( elapsedTime >= 550 
+						&& elapsedTime <= 1050 )
+					{
+						doKick = qtrue;
+						G_GetBoltPosition( ent, ent->footRBolt, kickEnd );
+						VectorSubtract( kickEnd, ent->currentOrigin, kickDir );
+						kickDir[2] = 0;//ah, flatten it, I guess...
+						VectorNormalize( kickDir );
+						//NOTE: have to fudge this a little because it's not getting enough range with the anim as-is
+						VectorMA( kickEnd, 8.0f, kickDir, kickEnd );
+					}
+				}
+				else
+				{//guess
+					if ( elapsedTime >= 400 && elapsedTime < 500 )
+					{//front
+						doKick = qtrue;
+						AngleVectors( fwdAngs, kickDir, NULL, NULL );
+					}
+					else if ( elapsedTime >= 500 && elapsedTime < 600 )
+					{//front-right?
+						doKick = qtrue;
+						fwdAngs[YAW] += 45;
+						AngleVectors( fwdAngs, kickDir, NULL, NULL );
+					}
+					else if ( elapsedTime >= 600 && elapsedTime < 700 )
+					{//right
+						doKick = qtrue;
+						AngleVectors( fwdAngs, NULL, kickDir, NULL );
+					}
+					else if ( elapsedTime >= 700 && elapsedTime < 800 )
+					{//back-right?
+						doKick = qtrue;
+						fwdAngs[YAW] += 45;
+						AngleVectors( fwdAngs, NULL, kickDir, NULL );
+					}
+					else if ( elapsedTime >= 800 && elapsedTime < 900 )
+					{//back
+						doKick = qtrue;
+						AngleVectors( fwdAngs, kickDir, NULL, NULL );
+						VectorScale( kickDir, -1, kickDir );
+					}
+					else if ( elapsedTime >= 900 && elapsedTime < 1000 )
+					{//back-left?
+						doKick = qtrue;
+						fwdAngs[YAW] += 45;
+						AngleVectors( fwdAngs, kickDir, NULL, NULL );
+					}
+					else if ( elapsedTime >= 1000 && elapsedTime < 1100 )
+					{//left
+						doKick = qtrue;
+						AngleVectors( fwdAngs, NULL, kickDir, NULL );
+						VectorScale( kickDir, -1, kickDir );
+					}
+					else if ( elapsedTime >= 1100 && elapsedTime < 1200 )
+					{//front-left?
+						doKick = qtrue;
+						fwdAngs[YAW] += 45;
+						AngleVectors( fwdAngs, NULL, kickDir, NULL );
+						VectorScale( kickDir, -1, kickDir );
+					}
+				}
+				break;
+			case BOTH_A7_KICK_BF:
+				kickPush = Q_flrand( 150.0f, 250.0f );//Q_flrand( 75.0f, 125.0f );
+				if ( elapsedTime < 1500 )
+				{//auto-aim!
+					overridAngles = PM_AdjustAnglesForBFKick( ent, ucmd, fwdAngs, qboolean(elapsedTime<850) )?qtrue:overridAngles;
+					//FIXME: if we haven't done the back kick yet and there's no-one there to
+					//			kick anymore, go into some anim that returns us to our base stance
+				}
+				if ( ent->footRBolt != -1 )
+				{//actually trace to a bolt
+					if ( ( elapsedTime >= 750 && elapsedTime < 850 )
+						|| ( elapsedTime >= 1400 && elapsedTime < 1500 ) )
+					{//right, though either would do
+						doKick = qtrue;
+						G_GetBoltPosition( ent, ent->footRBolt, kickEnd );
+						VectorSubtract( kickEnd, ent->currentOrigin, kickDir );
+						kickDir[2] = 0;//ah, flatten it, I guess...
+						VectorNormalize( kickDir );
+						//NOTE: have to fudge this a little because it's not getting enough range with the anim as-is
+						VectorMA( kickEnd, 8, kickDir, kickEnd );
+					}
+				}
+				else
+				{//guess
+					if ( elapsedTime >= 250 && elapsedTime < 350 )
+					{//front
+						doKick = qtrue;
+						AngleVectors( fwdAngs, kickDir, NULL, NULL );
+					}
+					else if ( elapsedTime >= 350 && elapsedTime < 450 )
+					{//back
+						doKick = qtrue;
+						AngleVectors( fwdAngs, kickDir, NULL, NULL );
+						VectorScale( kickDir, -1, kickDir );
+					}
+				}
+				break;
+			case BOTH_A7_KICK_RL:
+				kickSoundOnWalls = qtrue;
+				kickPush = Q_flrand( 150.0f, 250.0f );//Q_flrand( 75.0f, 125.0f );
+				//FIXME: auto aim at enemies on the side of us?
+				//overridAngles = PM_AdjustAnglesForRLKick( ent, ucmd, fwdAngs, qboolean(elapsedTime<850) )?qtrue:overridAngles;
+				if ( elapsedTime >= 250 && elapsedTime < 350 )
+				{//right
+					doKick = qtrue;
+					if ( ent->footRBolt != -1 )
+					{//actually trace to a bolt
+						G_GetBoltPosition( ent, ent->footRBolt, kickEnd );
+						VectorSubtract( kickEnd, ent->currentOrigin, kickDir );
+						kickDir[2] = 0;//ah, flatten it, I guess...
+						VectorNormalize( kickDir );
+						//NOTE: have to fudge this a little because it's not getting enough range with the anim as-is
+						VectorMA( kickEnd, 8, kickDir, kickEnd );
+					}
+					else
+					{//guess
+						AngleVectors( fwdAngs, NULL, kickDir, NULL );
+					}
+				}
+				else if ( elapsedTime >= 350 && elapsedTime < 450 )
+				{//left
+					doKick = qtrue;
+					if ( ent->footLBolt != -1 )
+					{//actually trace to a bolt
+						G_GetBoltPosition( ent, ent->footLBolt, kickEnd );
+						VectorSubtract( kickEnd, ent->currentOrigin, kickDir );
+						kickDir[2] = 0;//ah, flatten it, I guess...
+						VectorNormalize( kickDir );
+						//NOTE: have to fudge this a little because it's not getting enough range with the anim as-is
+						VectorMA( kickEnd, 8, kickDir, kickEnd );
+					}
+					else
+					{//guess
+						AngleVectors( fwdAngs, NULL, kickDir, NULL );
+						VectorScale( kickDir, -1, kickDir );
+					}
+				}
+				break;
+			}
+		}
+		if ( doKick )
+		{
+			G_KickTrace( ent, kickDir, kickDist, kickEnd, kickDamage, kickPush, kickSoundOnWalls );
+		}
+		if ( doKick2 )
+		{
+			G_KickTrace( ent, kickDir2, kickDist2, kickEnd2, kickDamage2, kickPush2, kickSoundOnWalls );
+		}
+	}
+	else if ( ent->client->ps.saberMove == LS_DUAL_FB )
+	{
+		//pull back the view
+		G_CamPullBackForLegsAnim( ent );
+	}
+	else if ( ent->client->ps.saberMove == LS_A_BACK || ent->client->ps.saberMove == LS_A_BACK_CR 
+		|| ent->client->ps.saberMove == LS_A_BACKSTAB )
+	{//can't move or turn during back attacks
+		ucmd->forwardmove = ucmd->rightmove = 0;
+		if ( ent->NPC )
+		{
+			VectorClear( ent->client->ps.moveDir );
+		}
+		if ( (overridAngles = (PM_AdjustAnglesForBackAttack( ent, ucmd )?qtrue:overridAngles)) == qtrue )
+		{
+			//pull back the view
+			G_CamPullBackForLegsAnim( ent );
+		}
+	}
+	else if ( ent->client->ps.torsoAnim == BOTH_WALL_FLIP_BACK1 
+		|| ent->client->ps.torsoAnim == BOTH_WALL_FLIP_BACK2 
+		|| ent->client->ps.legsAnim == BOTH_FORCEWALLRUNFLIP_END
+		|| ent->client->ps.legsAnim == BOTH_FORCEWALLREBOUND_BACK )
+	{
+		//pull back the view
+		G_CamPullBackForLegsAnim( ent );
+	}
+	else if ( ent->client->ps.torsoAnim == BOTH_A6_SABERPROTECT )
+	{
+		ucmd->forwardmove = ucmd->rightmove = ucmd->upmove = 0;
+		if ( ent->NPC )
+		{
+			VectorClear( ent->client->ps.moveDir );
+			ent->client->ps.forceJumpCharge = 0;
+		}
+		if ( !ent->s.number )
+		{
+			float animLength = PM_AnimLength( ent->client->clientInfo.animFileIndex, (animNumber_t)ent->client->ps.torsoAnim );
+			float elapsedTime = (float)(animLength-ent->client->ps.torsoAnimTimer);
+			float backDist = 0;
+			if ( elapsedTime <= 300.0f )
+			{//starting anim
+				backDist = (elapsedTime/300.0f)*90.0f;
+			}
+			else if ( ent->client->ps.torsoAnimTimer <= 300.0f )
+			{//ending anim
+				backDist = (ent->client->ps.torsoAnimTimer/300.0f)*90.0f;
+			}
+			else
+			{//in middle of anim
+				backDist = 90.0f;
+			}
+			//back off and look down
+			cg.overrides.active |= (CG_OVERRIDE_3RD_PERSON_RNG|CG_OVERRIDE_3RD_PERSON_POF);
+			cg.overrides.thirdPersonRange = cg_thirdPersonRange.value+backDist;
+			cg.overrides.thirdPersonPitchOffset = cg_thirdPersonPitchOffset.value+(backDist/2.0f);
+		}
+		overridAngles = (PM_AdjustAnglesForSpinProtect( ent, ucmd )?qtrue:overridAngles);
+	}
+	else if ( ent->client->ps.legsAnim == BOTH_A3_SPECIAL )
+	{//push forward
+		float animLength = PM_AnimLength( ent->client->clientInfo.animFileIndex, (animNumber_t)ent->client->ps.torsoAnim );
+		float elapsedTime = (float)(animLength-ent->client->ps.torsoAnimTimer);
+		ucmd->upmove = ucmd->rightmove = 0;
+		ucmd->forwardmove = 0;
+		if ( elapsedTime >= 350 && elapsedTime < 1500 )
+		{//push forward
+			ucmd->forwardmove = 64;
+			ent->client->ps.speed = 200.0f;
+		}
+		//FIXME: pull back camera?
+	}
+	else if ( ent->client->ps.legsAnim == BOTH_A2_SPECIAL )
+	{//push forward
+		ucmd->upmove = ucmd->rightmove = 0;
+		ucmd->forwardmove = 0;
+		if ( ent->client->ps.legsAnimTimer > 200.0f )
+		{
+			float animLength = PM_AnimLength( ent->client->clientInfo.animFileIndex, (animNumber_t)ent->client->ps.torsoAnim );
+			float elapsedTime = (float)(animLength-ent->client->ps.torsoAnimTimer);
+			if ( elapsedTime < 750
+				|| (elapsedTime >= 1650 && elapsedTime < 2400) )
+			{//push forward
+				ucmd->forwardmove = 64;
+				ent->client->ps.speed = 200.0f;
+			}
+		}
+		//FIXME: pull back camera?
+	}//FIXME: fast special?
+	else if ( ent->client->ps.legsAnim == BOTH_A1_SPECIAL
+		&& (ucmd->forwardmove || ucmd->rightmove || (VectorCompare( ent->client->ps.moveDir, vec3_origin )&&ent->client->ps.speed>0)) )
+	{//moving during full-body fast special
+		ent->client->ps.legsAnimTimer = 0;//don't hold this legsAnim, allow them to run
+		//FIXME: just add this to the list of overridable special moves in PM_Footsteps?
+	}
+	else if ( ent->client->ps.legsAnim == BOTH_FLIP_LAND )
+	{//moving during full-body fast special
+		float animLength = PM_AnimLength( ent->client->clientInfo.animFileIndex, (animNumber_t)ent->client->ps.torsoAnim );
+		float elapsedTime = (float)(animLength-ent->client->ps.torsoAnimTimer);
+		ucmd->upmove = ucmd->rightmove = ucmd->forwardmove = 0;
+		if ( elapsedTime > 600 && elapsedTime < 800 
+			&& ent->client->ps.groundEntityNum != ENTITYNUM_NONE )
+		{//jump - FIXME: how do we stop double-jumps?
+			ent->client->ps.pm_flags |= PMF_JUMP_HELD;
+			ent->client->ps.groundEntityNum = ENTITYNUM_NONE;
+			ent->client->ps.jumpZStart = ent->currentOrigin[2];
+			ent->client->ps.velocity[2] = JUMP_VELOCITY;
+			G_AddEvent( ent, EV_JUMP, 0 );
+		}
+	}
+	else if ( ( PM_SuperBreakWinAnim( ent->client->ps.torsoAnim )
+			    || PM_SuperBreakLoseAnim( ent->client->ps.torsoAnim ) )
+			 && ent->client->ps.torsoAnimTimer )
+	{//can't move or turn
+		ucmd->forwardmove = ucmd->rightmove = ucmd->upmove = 0;
+		if ( ent->NPC )
+		{
+			VectorClear( ent->client->ps.moveDir );
+			ent->client->ps.forceJumpCharge = 0;
+		}
+		overridAngles = (PM_LockAngles( ent, ucmd )?qtrue:overridAngles);
+	}
+	else if ( BG_FullBodyTauntAnim( ent->client->ps.legsAnim )
+		&& BG_FullBodyTauntAnim( ent->client->ps.torsoAnim ) )
+	{
+		if ( (ucmd->buttons&BUTTON_ATTACK)
+			|| (ucmd->buttons&BUTTON_ALT_ATTACK)
+			|| (ucmd->buttons&BUTTON_USE_FORCE)
+			|| (ucmd->buttons&BUTTON_FORCEGRIP)
+			|| (ucmd->buttons&BUTTON_FORCE_LIGHTNING)
+			|| (ucmd->buttons&BUTTON_FORCE_DRAIN)
+			|| ucmd->upmove )
+		{//stop the anim
+			if ( ent->client->ps.legsAnim == BOTH_MEDITATE
+				&& ent->client->ps.torsoAnim == BOTH_MEDITATE )
+			{
+				NPC_SetAnim( ent, SETANIM_BOTH, BOTH_MEDITATE_END, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD, 0 );
+			}
+			else
+			{
+				ent->client->ps.legsAnimTimer = ent->client->ps.torsoAnimTimer = 0;
+			}
+		}
+		else 
+		{
+			if ( ent->client->ps.legsAnim == BOTH_MEDITATE )
+			{
+				if ( ent->client->ps.legsAnimTimer < 100 )
+				{
+					ent->client->ps.legsAnimTimer = 100;
+				}
+			}
+			if ( ent->client->ps.torsoAnim == BOTH_MEDITATE )
+			{
+				if ( ent->client->ps.torsoAnimTimer < 100 )
+				{
+					ent->client->ps.legsAnimTimer = 100;
+				}
+			}
+			if ( ent->client->ps.legsAnimTimer > 0 || ent->client->ps.torsoAnimTimer > 0 )
+			{
+				ucmd->rightmove = 0;
+				ucmd->upmove = 0;
+				ucmd->forwardmove = 0;
+				ucmd->buttons = 0;
+				if ( ent->NPC )
+				{
+					VectorClear( ent->client->ps.moveDir );
+					ent->client->ps.forceJumpCharge = 0;
+				}
+				overridAngles = (PM_LockAngles( ent, ucmd )?qtrue:overridAngles);
+			}
+		}
+	}
+	else if ( ent->client->ps.legsAnim == BOTH_MEDITATE_END 
+		&& ent->client->ps.legsAnimTimer > 0 )
+	{
+        ucmd->rightmove = 0;
+		ucmd->upmove = 0;
+		ucmd->forwardmove = 0;
+		ucmd->buttons = 0;
+		if ( ent->NPC )
+		{
+			VectorClear( ent->client->ps.moveDir );
+			ent->client->ps.forceJumpCharge = 0;
+		}
+		overridAngles = (PM_LockAngles( ent, ucmd )?qtrue:overridAngles);
+	}
+	else if ( !ent->s.number )
+	{
+		if ( ent->client->NPC_class != CLASS_ATST )
+		{
+			// Not in a vehicle.
+			if ( ent->s.m_iVehicleNum == 0 )
+			{
+				if ( !MatrixMode )
+				{
+					cg.overrides.active &= ~(CG_OVERRIDE_3RD_PERSON_RNG|CG_OVERRIDE_3RD_PERSON_POF|CG_OVERRIDE_3RD_PERSON_ANG);
+					cg.overrides.thirdPersonRange = 0;
+				}
+			}
+		}
+	}
+
+
+	if ( PM_InRoll( &ent->client->ps ) )
+	{
+		if ( ent->s.number >= MAX_CLIENTS || !player_locked )
+		{
+			//FIXME: NPCs should try to face us during this roll, so they roll around us...?
+			PM_CmdForRoll( &ent->client->ps, ucmd );
+			if ( ent->s.number >= MAX_CLIENTS )
+			{//make sure it doesn't roll me off a ledge
+				if ( !G_CheckRollSafety( ent, ent->client->ps.legsAnim, 24 ) )
+				{//crap!  I guess all we can do is stop...  UGH
+					ucmd->rightmove = ucmd->forwardmove = 0;
+				}
+			}
+		}
+		if ( ent->NPC )
+		{//invalid now
+			VectorClear( ent->client->ps.moveDir );
+		}
+		ent->client->ps.speed = 400;
+	}
+
+	if ( PM_InCartwheel( ent->client->ps.legsAnim ) )
+	{//can't keep moving in cartwheel
+		if ( ent->client->ps.legsAnimTimer > 100 )
+		{//still have time left in the anim
+			ucmd->forwardmove = ucmd->rightmove = ucmd->upmove = 0;
+			if ( ent->NPC )
+			{//invalid now
+				VectorClear( ent->client->ps.moveDir );
+			}
+			if ( ent->s.number || !player_locked )
+			{
+				switch ( ent->client->ps.legsAnim )
+				{
+				case BOTH_ARIAL_LEFT:
+				case BOTH_CARTWHEEL_LEFT:
+					ucmd->rightmove = -127;
+					break;
+				case BOTH_ARIAL_RIGHT:
+				case BOTH_CARTWHEEL_RIGHT:
+					ucmd->rightmove = 127;
+					break;
+				case BOTH_ARIAL_F1:
+					ucmd->forwardmove = 127;
+					break;
+				default:
+					break;
+				}
+			}
+		}
+	}
+
+	if ( ent->client->ps.legsAnim == BOTH_BUTTERFLY_LEFT 
+		|| ent->client->ps.legsAnim == BOTH_BUTTERFLY_RIGHT )
+	{
+		if ( ent->client->ps.legsAnimTimer > 100 )
+		{//still have time left in the anim
+			ucmd->forwardmove = ucmd->rightmove = ucmd->upmove = 0;
+			if ( ent->NPC )
+			{//invalid now
+				VectorClear( ent->client->ps.moveDir );
+			}
+			if ( ent->s.number || !player_locked )
+			{
+				if ( ent->client->ps.legsAnimTimer > 450 )
+				{
+					switch ( ent->client->ps.legsAnim )
+					{
+						case BOTH_BUTTERFLY_LEFT:
+							ucmd->rightmove = -127;
+							break;
+						case BOTH_BUTTERFLY_RIGHT:
+							ucmd->rightmove = 127;
+							break;
+						default:
+							break;
+					}
+				}
+			}
+		}
+	}
+
+	overridAngles = (PM_AdjustAnglesForStabDown( ent, ucmd )?qtrue:overridAngles);
+	overridAngles = (PM_AdjustAngleForWallJump( ent, ucmd, qtrue )?qtrue:overridAngles);
+	overridAngles = (PM_AdjustAngleForWallRunUp( ent, ucmd, qtrue )?qtrue:overridAngles);
+	overridAngles = (PM_AdjustAngleForWallRun( ent, ucmd, qtrue )?qtrue:overridAngles);
+
+	return overridAngles;
+}
+
+void BG_AddPushVecToUcmd( gentity_t *self, usercmd_t *ucmd )
+{
+	vec3_t	forward, right, moveDir;
+	float	pushSpeed, fMove, rMove;
+
+	if ( !self->client )
+	{
+		return;
+	}
+	pushSpeed = VectorLengthSquared(self->client->pushVec);
+	if(!pushSpeed)
+	{//not being pushed
+		return;
+	}
+
+	AngleVectors(self->client->ps.viewangles, forward, right, NULL);
+	VectorScale(forward, ucmd->forwardmove/127.0f * self->client->ps.speed, moveDir);
+	VectorMA(moveDir, ucmd->rightmove/127.0f * self->client->ps.speed, right, moveDir);
+	//moveDir is now our intended move velocity
+
+	VectorAdd(moveDir, self->client->pushVec, moveDir);
+	self->client->ps.speed = VectorNormalize(moveDir);
+	//moveDir is now our intended move velocity plus our push Vector
+
+	fMove = 127.0 * DotProduct(forward, moveDir);
+	rMove = 127.0 * DotProduct(right, moveDir);
+	ucmd->forwardmove = floor(fMove);//If in the same dir , will be positive
+	ucmd->rightmove = floor(rMove);//If in the same dir , will be positive
+
+	if ( self->client->pushVecTime < level.time )
+	{
+		VectorClear( self->client->pushVec );
+	}
+}
+
+void NPC_Accelerate( gentity_t *ent, qboolean fullWalkAcc, qboolean fullRunAcc )
+{
+	if ( !ent->client || !ent->NPC )
+	{
+		return;
+	}
+
+	if ( !ent->NPC->stats.acceleration )
+	{//No acceleration means just start and stop
+		ent->NPC->currentSpeed = ent->NPC->desiredSpeed;
+	}
+	//FIXME:  in cinematics always accel/decel?
+	else if ( ent->NPC->desiredSpeed <= ent->NPC->stats.walkSpeed )
+	{//Only accelerate if at walkSpeeds
+		if ( ent->NPC->desiredSpeed > ent->NPC->currentSpeed + ent->NPC->stats.acceleration )
+		{
+			//ent->client->ps.friction = 0;
+			ent->NPC->currentSpeed += ent->NPC->stats.acceleration;
+		}
+		else if ( ent->NPC->desiredSpeed > ent->NPC->currentSpeed )
+		{
+			//ent->client->ps.friction = 0;
+			ent->NPC->currentSpeed = ent->NPC->desiredSpeed;
+		}
+		else if ( fullWalkAcc && ent->NPC->desiredSpeed < ent->NPC->currentSpeed - ent->NPC->stats.acceleration )
+		{//decelerate even when walking
+			ent->NPC->currentSpeed -= ent->NPC->stats.acceleration;
+		}
+		else if ( ent->NPC->desiredSpeed < ent->NPC->currentSpeed )
+		{//stop on a dime
+			ent->NPC->currentSpeed = ent->NPC->desiredSpeed;
+		}
+	}
+	else//  if ( ent->NPC->desiredSpeed > ent->NPC->stats.walkSpeed )
+	{//Only decelerate if at runSpeeds
+		if ( fullRunAcc && ent->NPC->desiredSpeed > ent->NPC->currentSpeed + ent->NPC->stats.acceleration )
+		{//Accelerate to runspeed
+			//ent->client->ps.friction = 0;
+			ent->NPC->currentSpeed += ent->NPC->stats.acceleration;
+		}
+		else if ( ent->NPC->desiredSpeed > ent->NPC->currentSpeed )
+		{//accelerate instantly
+			//ent->client->ps.friction = 0;
+			ent->NPC->currentSpeed = ent->NPC->desiredSpeed;
+		}
+		else if ( fullRunAcc && ent->NPC->desiredSpeed < ent->NPC->currentSpeed - ent->NPC->stats.acceleration )
+		{
+			ent->NPC->currentSpeed -= ent->NPC->stats.acceleration;
+		}
+		else if ( ent->NPC->desiredSpeed < ent->NPC->currentSpeed )
+		{
+			ent->NPC->currentSpeed = ent->NPC->desiredSpeed;
+		}
+	}
+}
+
+/*
+-------------------------
+NPC_GetWalkSpeed
+-------------------------
+*/
+
+static int NPC_GetWalkSpeed( gentity_t *ent )
+{
+	int	walkSpeed = 0;
+
+	if ( ( ent->client == NULL ) || ( ent->NPC == NULL ) )
+		return 0;
+
+	switch ( ent->client->playerTeam )
+	{
+	case TEAM_PLAYER:	//To shutup compiler, will add entries later (this is stub code)
+	default:
+		walkSpeed = ent->NPC->stats.walkSpeed;
+		break;
+	}
+
+	return walkSpeed;
+}
+
+/*
+-------------------------
+NPC_GetRunSpeed
+-------------------------
+*/
+#define	BORG_RUN_INCR		25
+#define SPECIES_RUN_INCR	25	
+#define STASIS_RUN_INCR		20
+#define	WARBOT_RUN_INCR		20
+
+static int NPC_GetRunSpeed( gentity_t *ent )
+{
+	int	runSpeed = 0;
+
+	if ( ( ent->client == NULL ) || ( ent->NPC == NULL ) )
+		return 0;
+/*
+	switch ( ent->client->playerTeam )
+	{
+	case TEAM_BORG:
+		runSpeed = ent->NPC->stats.runSpeed;
+		runSpeed += BORG_RUN_INCR * (g_spskill->integer%3);
+		break;
+
+	case TEAM_8472:
+		runSpeed = ent->NPC->stats.runSpeed;
+		runSpeed += SPECIES_RUN_INCR * (g_spskill->integer%3);
+		break;
+
+	case TEAM_STASIS:
+		runSpeed = ent->NPC->stats.runSpeed;
+		runSpeed += STASIS_RUN_INCR * (g_spskill->integer%3);
+		break;
+
+	case TEAM_BOTS:
+		runSpeed = ent->NPC->stats.runSpeed;
+		break;
+
+	default:
+		runSpeed = ent->NPC->stats.runSpeed;
+		break;
+	}
+*/
+	// team no longer indicates species/race.  Use NPC_class to adjust speed for specific npc types
+	switch( ent->client->NPC_class)
+	{
+	case CLASS_PROBE:	// droid cases here to shut-up compiler
+	case CLASS_GONK:
+	case CLASS_R2D2:
+	case CLASS_R5D2:
+	case CLASS_MARK1:
+	case CLASS_MARK2:
+	case CLASS_PROTOCOL:
+	case CLASS_ATST: // hmm, not really your average droid
+	case CLASS_MOUSE:
+	case CLASS_SEEKER:
+	case CLASS_REMOTE:
+		runSpeed = ent->NPC->stats.runSpeed;
+		break;
+
+	default:
+		runSpeed = ent->NPC->stats.runSpeed;
+		break;
+	}
+
+	return runSpeed;
+}
+
+void G_HeldByMonster( gentity_t *ent, usercmd_t **ucmd )
+{
+	if ( ent && ent->activator && ent->activator->inuse && ent->activator->health > 0 )
+	{
+		gentity_t *monster = ent->activator;
+		//take the monster's waypoint as your own
+		ent->waypoint = monster->waypoint;
+
+		//update the actual origin of the victim
+		mdxaBone_t	boltMatrix;
+
+		// Getting the bolt here
+		int boltIndex = monster->gutBolt;//default to being held in his mouth
+		if ( monster->count == 1 )
+		{//being held in hand rather than the mouth, so use *that* bolt
+			boltIndex = monster->handRBolt;
+		}
+		vec3_t monAngles = {0};
+		monAngles[YAW] = monster->currentAngles[YAW];//only use YAW when passing angles to G2
+		gi.G2API_GetBoltMatrix( monster->ghoul2, monster->playerModel, boltIndex,
+				&boltMatrix, monAngles, monster->currentOrigin, (cg.time?cg.time:level.time),
+				NULL, monster->s.modelScale );
+		// Storing ent position, bolt position, and bolt axis
+		gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, ent->client->ps.origin );
+		gi.linkentity( ent );
+		//lock view angles
+		PM_AdjustAnglesForHeldByMonster( ent, monster, *ucmd );
+		if ( monster->client && monster->client->NPC_class == CLASS_WAMPA )
+		{//can only hit attack button
+			(*ucmd)->buttons &= ~((*ucmd)->buttons&~BUTTON_ATTACK);
+		}
+	}
+	else if (ent)
+	{//doh, my captor died!
+		ent->activator = NULL;
+		if (ent->client)
+		{
+			ent->client->ps.eFlags &= ~(EF_HELD_BY_WAMPA|EF_HELD_BY_RANCOR);
+		}
+	}
+	// don't allow movement, weapon switching, and most kinds of button presses
+	(*ucmd)->forwardmove = 0;
+	(*ucmd)->rightmove = 0;
+	(*ucmd)->upmove = 0;
+}
+
+// yes...   so stop skipping...
+void G_StopCinematicSkip( void )
+{
+	gi.cvar_set("skippingCinematic", "0");
+	gi.cvar_set("timescale", "1");
+}
+
+void G_StartCinematicSkip( void )
+{
+	
+	if (cinematicSkipScript[0])
+	{
+		Quake3Game()->RunScript( &g_entities[0], cinematicSkipScript );
+
+		cinematicSkipScript[0] = 0;
+		gi.cvar_set("skippingCinematic", "1");
+		gi.cvar_set("timescale", "100");
+	}
+	else 
+	{
+		// no... so start skipping...
+		gi.cvar_set("skippingCinematic", "1");
+		gi.cvar_set("timescale", "100");
+	}
+}
+
+void G_CheckClientIdle( gentity_t *ent, usercmd_t *ucmd ) 
+{
+	if ( !ent || !ent->client || ent->health <= 0 )
+	{
+		return;
+	}
+	if ( !ent->s.number && ( !cg.renderingThirdPerson || cg.zoomMode ) )
+	{
+		if ( ent->client->idleTime < level.time )
+		{
+			ent->client->idleTime = level.time;
+		}
+		return;
+	}
+	if ( !VectorCompare( vec3_origin, ent->client->ps.velocity ) 
+		|| ucmd->buttons || ucmd->forwardmove || ucmd->rightmove || ucmd->upmove 
+		|| !PM_StandingAnim( ent->client->ps.legsAnim ) 
+		|| ent->enemy 
+		|| ent->client->ps.legsAnimTimer
+		|| ent->client->ps.torsoAnimTimer )
+	{//FIXME: also check for turning?
+		if ( !VectorCompare( vec3_origin, ent->client->ps.velocity ) 
+			|| ucmd->buttons || ucmd->forwardmove || ucmd->rightmove || ucmd->upmove 
+			|| ent->enemy )
+		{
+			//if in an idle, break out
+			switch ( ent->client->ps.legsAnim )
+			{
+			case BOTH_STAND1IDLE1:
+			case BOTH_STAND2IDLE1:
+			case BOTH_STAND2IDLE2:
+			case BOTH_STAND3IDLE1:
+			case BOTH_STAND5IDLE1:
+				ent->client->ps.legsAnimTimer = 0;
+				break;
+			}
+			switch ( ent->client->ps.torsoAnim )
+			{
+			case BOTH_STAND1IDLE1:
+			case BOTH_STAND2IDLE1:
+			case BOTH_STAND2IDLE2:
+			case BOTH_STAND3IDLE1:
+			case BOTH_STAND5IDLE1:
+				ent->client->ps.torsoAnimTimer = 0;
+				break;
+			}
+		}
+		//
+		if ( ent->client->idleTime < level.time )
+		{
+			ent->client->idleTime = level.time;
+		}
+	}
+	else if ( level.time - ent->client->idleTime > 5000 )
+	{//been idle for 5 seconds
+		int	idleAnim = -1;
+		switch ( ent->client->ps.legsAnim )
+		{
+		case BOTH_STAND1:
+			idleAnim = BOTH_STAND1IDLE1;
+			break;
+		case BOTH_STAND2:
+			idleAnim = Q_irand(BOTH_STAND2IDLE1,BOTH_STAND2IDLE2);
+			break;
+		case BOTH_STAND3:
+			idleAnim = BOTH_STAND3IDLE1;
+			break;
+		case BOTH_STAND5:
+			idleAnim = BOTH_STAND5IDLE1;
+			break;
+		}
+		if ( idleAnim != -1 && PM_HasAnimation( ent, idleAnim ) )
+		{
+			NPC_SetAnim( ent, SETANIM_BOTH, idleAnim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+			//don't idle again after this anim for a while
+			ent->client->idleTime = level.time + PM_AnimLength( ent->client->clientInfo.animFileIndex, (animNumber_t)idleAnim ) + Q_irand( 0, 2000 );
+		}
+	}
+}
+
+void G_CheckMovingLoopingSounds( gentity_t *ent, usercmd_t *ucmd )
+{
+	if ( ent->client )
+	{
+		if ( (ent->NPC&&!VectorCompare( vec3_origin, ent->client->ps.moveDir ))//moving using moveDir
+			|| ucmd->forwardmove || ucmd->rightmove//moving using ucmds
+			|| (ucmd->upmove&&FlyingCreature( ent ))//flier using ucmds to move
+			|| (FlyingCreature( ent )&&!VectorCompare( vec3_origin, ent->client->ps.velocity )&&ent->health>0))//flier using velocity to move
+		{
+			switch( ent->client->NPC_class )
+			{
+			case CLASS_R2D2:
+				ent->s.loopSound = G_SoundIndex( "sound/chars/r2d2/misc/r2_move_lp.wav" );
+				break;
+			case CLASS_R5D2:
+				ent->s.loopSound = G_SoundIndex( "sound/chars/r2d2/misc/r2_move_lp2.wav" );
+				break;
+			case CLASS_MARK2:
+				ent->s.loopSound = G_SoundIndex( "sound/chars/mark2/misc/mark2_move_lp" );
+				break;
+			case CLASS_MOUSE:
+				ent->s.loopSound = G_SoundIndex( "sound/chars/mouse/misc/mouse_lp" );
+				break;
+			case CLASS_PROBE:
+				ent->s.loopSound = G_SoundIndex( "sound/chars/probe/misc/probedroidloop" );
+			}
+		}
+		else
+		{//not moving under your own control, stop loopSound
+			if ( ent->client->NPC_class == CLASS_R2D2 || ent->client->NPC_class == CLASS_R5D2 
+					|| ent->client->NPC_class == CLASS_MARK2 || ent->client->NPC_class == CLASS_MOUSE 
+					|| ent->client->NPC_class == CLASS_PROBE )
+			{
+				ent->s.loopSound = 0;
+			}
+		}
+	}
+}
+
+
+/*
+==============
+ClientAlterSpeed
+
+This function is called ONLY from ClientThinkReal, and is responsible for setting client ps.speed
+==============
+*/
+void	ClientAlterSpeed(gentity_t *ent, usercmd_t *ucmd, qboolean	controlledByPlayer, float vehicleFrameTimeModifier)
+{
+	gclient_t	*client = ent->client;
+	Vehicle_t *pVeh = NULL;
+
+	if ( ent->client && ent->client->NPC_class == CLASS_VEHICLE )
+	{
+		pVeh = ent->m_pVehicle;
+	}
+
+	// set speed
+	// This may be wrong: If we're an npc and we are in a vehicle???
+	if ( ent->NPC != NULL && ent->client && ( ent->s.m_iVehicleNum != 0 )/*&& ent->client->NPC_class == CLASS_VEHICLE*/ )
+	{//we don't actually scale the ucmd, we use actual speeds
+		//FIXME: swoop should keep turning (and moving forward?) for a little bit?
+		if ( ent->NPC->combatMove == qfalse )
+		{
+			if ( !(ucmd->buttons & BUTTON_USE) )
+			{//Not leaning
+				qboolean Flying = (ucmd->upmove && ent->client->moveType == MT_FLYSWIM);
+				qboolean Climbing = (ucmd->upmove && ent->watertype&CONTENTS_LADDER );
+
+				client->ps.friction = 6;
+
+				if ( ucmd->forwardmove || ucmd->rightmove || Flying )
+				{
+					//if ( ent->NPC->behaviorState != BS_FORMATION )
+					{//In - Formation NPCs set thier desiredSpeed themselves
+						if ( ucmd->buttons & BUTTON_WALKING )
+						{
+							ent->NPC->desiredSpeed = NPC_GetWalkSpeed( ent );//ent->NPC->stats.walkSpeed;
+						}
+						else//running
+						{
+							ent->NPC->desiredSpeed = NPC_GetRunSpeed( ent );//ent->NPC->stats.runSpeed;
+						}
+
+						if ( ent->NPC->currentSpeed >= 80 && !controlledByPlayer )
+						{//At higher speeds, need to slow down close to stuff
+							//Slow down as you approach your goal
+						//	if ( ent->NPC->distToGoal < SLOWDOWN_DIST && client->race != RACE_BORG && !(ent->NPC->aiFlags&NPCAI_NO_SLOWDOWN) )//128
+							if ( ent->NPC->distToGoal < SLOWDOWN_DIST && !(ent->NPC->aiFlags&NPCAI_NO_SLOWDOWN) )//128
+							{
+								if ( ent->NPC->desiredSpeed > MIN_NPC_SPEED )
+								{
+									float slowdownSpeed = ((float)ent->NPC->desiredSpeed) * ent->NPC->distToGoal / SLOWDOWN_DIST;
+
+									ent->NPC->desiredSpeed = ceil(slowdownSpeed);
+									if ( ent->NPC->desiredSpeed < MIN_NPC_SPEED )
+									{//don't slow down too much
+										ent->NPC->desiredSpeed = MIN_NPC_SPEED;
+									}
+								}
+							}
+						}
+					}
+				}
+				else if ( Climbing )
+				{
+					ent->NPC->desiredSpeed = ent->NPC->stats.walkSpeed;
+				}
+				else
+				{//We want to stop
+					ent->NPC->desiredSpeed = 0;
+				}
+
+				NPC_Accelerate( ent, qfalse, qfalse );
+
+				if ( ent->NPC->currentSpeed <= 24 && ent->NPC->desiredSpeed < ent->NPC->currentSpeed )
+				{//No-one walks this slow
+					client->ps.speed = ent->NPC->currentSpeed = 0;//Full stop
+					ucmd->forwardmove = 0;
+					ucmd->rightmove = 0;
+				}
+				else
+				{
+					if ( ent->NPC->currentSpeed <= ent->NPC->stats.walkSpeed )
+					{//Play the walkanim
+						ucmd->buttons |= BUTTON_WALKING;
+					}
+					else
+					{
+						ucmd->buttons &= ~BUTTON_WALKING;
+					}
+
+					if ( ent->NPC->currentSpeed > 0 )
+					{//We should be moving
+						if ( Climbing || Flying )
+						{
+							if ( !ucmd->upmove )
+							{//We need to force them to take a couple more steps until stopped
+								ucmd->upmove = ent->NPC->last_ucmd.upmove;//was last_upmove;
+							}
+						}
+						else if ( !ucmd->forwardmove && !ucmd->rightmove )
+						{//We need to force them to take a couple more steps until stopped
+							ucmd->forwardmove = ent->NPC->last_ucmd.forwardmove;//was last_forwardmove;
+							ucmd->rightmove = ent->NPC->last_ucmd.rightmove;//was last_rightmove;
+						}
+					}
+
+					client->ps.speed = ent->NPC->currentSpeed;
+					if ( player && player->client && player->client->ps.viewEntity == ent->s.number )
+					{
+					}
+					else
+					{
+						//Slow down on turns - don't orbit!!!
+						float turndelta = 0; 
+						// if the NPC is locked into a Yaw, we want to check the lockedDesiredYaw...otherwise the NPC can't walk backwards, because it always thinks it trying to turn according to desiredYaw
+						if( client->renderInfo.renderFlags & RF_LOCKEDANGLE ) // yeah I know the RF_ flag is a pretty ugly hack...
+						{	
+							turndelta = (180 - fabs( AngleDelta( ent->currentAngles[YAW], ent->NPC->lockedDesiredYaw ) ))/180;
+						}
+						else
+						{
+							turndelta = (180 - fabs( AngleDelta( ent->currentAngles[YAW], ent->NPC->desiredYaw ) ))/180;
+						}
+												
+						if ( turndelta < 0.75f )
+						{
+							client->ps.speed = 0;
+						}
+						else if ( ent->NPC->distToGoal < 100 && turndelta < 1.0 )
+						{//Turn is greater than 45 degrees or closer than 100 to goal
+							client->ps.speed = floor(((float)(client->ps.speed))*turndelta);
+						}
+					}
+				}
+			}
+		}
+		else
+		{	
+			ent->NPC->desiredSpeed = ( ucmd->buttons & BUTTON_WALKING ) ? NPC_GetWalkSpeed( ent ) : NPC_GetRunSpeed( ent );
+
+			client->ps.speed = ent->NPC->desiredSpeed;
+		}
+	}
+	else
+	{//Client sets ucmds and such for speed alterations
+		{
+			client->ps.speed = g_speed->value;//default is 320
+			/*if ( !ent->s.number && ent->painDebounceTime>level.time )
+			{
+				client->ps.speed *= 0.25f;
+			}
+			else */if (ent->client->ps.heldClient < ENTITYNUM_WORLD)
+			{
+				client->ps.speed *= 0.3f;
+			}
+			else if ( PM_SaberInAttack( ent->client->ps.saberMove ) && ucmd->forwardmove < 0 )
+			{//if running backwards while attacking, don't run as fast.
+				switch( client->ps.saberAnimLevel )
+				{
+				case SS_FAST:
+					client->ps.speed *= 0.75f;
+					break;
+				case SS_MEDIUM:
+				case SS_DUAL:
+				case SS_STAFF:
+					client->ps.speed *= 0.60f;
+					break;
+				case SS_STRONG:
+					client->ps.speed *= 0.45f;
+					break;
+				}
+				if ( g_saberMoveSpeed->value != 1.0f )
+				{
+					client->ps.speed *= g_saberMoveSpeed->value;
+				}
+			}
+			else if ( PM_LeapingSaberAnim( client->ps.legsAnim ) )
+			{//no mod on speed when leaping
+				//FIXME: maybe jump?
+			}
+			else if ( PM_SpinningSaberAnim( client->ps.legsAnim ) )
+			{
+				client->ps.speed *= 0.5f;
+				if ( g_saberMoveSpeed->value != 1.0f )
+				{
+					client->ps.speed *= g_saberMoveSpeed->value;
+				}
+			}
+			else if ( client->ps.weapon == WP_SABER && ( ucmd->buttons & BUTTON_ATTACK ) )
+			{//if attacking with saber while running, drop your speed
+				//FIXME: should be weaponTime?  Or in certain anims?
+				switch( client->ps.saberAnimLevel )
+				{
+				case SS_MEDIUM:
+				case SS_DUAL:
+				case SS_STAFF:
+					client->ps.speed *= 0.85f;
+					break;
+				case SS_STRONG:
+					client->ps.speed *= 0.70f;
+					break;
+				}
+				if ( g_saberMoveSpeed->value != 1.0f )
+				{
+					client->ps.speed *= g_saberMoveSpeed->value;
+				}
+			}
+		}
+	}
+	if ( client->NPC_class == CLASS_ATST && client->ps.legsAnim == BOTH_RUN1START )
+	{//HACK: when starting to move as atst, ramp up speed
+		//float animLength = PM_AnimLength( client->clientInfo.animFileIndex, (animNumber_t)client->ps.legsAnim);
+		//client->ps.speed *= ( animLength - client->ps.legsAnimTimer)/animLength;
+		if ( client->ps.legsAnimTimer > 100 )
+		{
+			client->ps.speed = 0;
+		}
+	}
+
+	//Apply forced movement
+	if ( client->forced_forwardmove )
+	{
+		ucmd->forwardmove = client->forced_forwardmove;
+		if ( !client->ps.speed )
+		{
+			if ( ent->NPC != NULL )
+			{
+				client->ps.speed = ent->NPC->stats.runSpeed;
+			}
+			else
+			{
+				client->ps.speed = g_speed->value;//default is 320
+			}
+		}
+	}
+
+	if ( client->forced_rightmove )
+	{
+		ucmd->rightmove = client->forced_rightmove;
+		if ( !client->ps.speed )
+		{
+			if ( ent->NPC != NULL  )
+			{
+				client->ps.speed = ent->NPC->stats.runSpeed;
+			}
+			else
+			{
+				client->ps.speed = g_speed->value;//default is 320
+			}
+		}
+	}
+
+	if ( !pVeh )
+	{
+		if ( ucmd->forwardmove < 0 && !(ucmd->buttons&BUTTON_WALKING) && client->ps.groundEntityNum != ENTITYNUM_NONE )
+		{//running backwards is slower than running forwards
+			client->ps.speed *= 0.75;
+		}
+
+		if (client->ps.forceRageRecoveryTime > level.time )
+		{
+			client->ps.speed *= 0.75;
+		}
+	}
+}
+
+
+extern qboolean ForceDrain2(gentity_t *ent);
+extern void ForceGrip(gentity_t *ent);
+extern void ForceLightning(gentity_t *ent);
+extern void ForceProtect(gentity_t *ent);
+extern void ForceRage(gentity_t *ent);
+extern void ForceSeeing(gentity_t *ent);
+extern void ForceTelepathy(gentity_t *ent);
+extern void ForceAbsorb(gentity_t *ent);
+extern void ForceHeal(gentity_t *ent);
+static void ProcessGenericCmd(gentity_t *ent, byte cmd)
+{
+	switch(cmd) {
+	case 0:
+		break;
+	case GENCMD_FORCE_DRAIN:
+		ForceDrain2(ent);
+		break;
+	case GENCMD_FORCE_THROW:
+		ForceThrow(ent, qfalse);
+		break;
+	case GENCMD_FORCE_SPEED:
+		ForceSpeed(ent);
+		break;
+	case GENCMD_FORCE_PULL:
+		ForceThrow(ent, qtrue);
+		break;
+	case GENCMD_FORCE_DISTRACT:
+		ForceTelepathy(ent);
+		break;
+	case GENCMD_FORCE_GRIP:
+		ForceGrip(ent);
+		break;
+	case GENCMD_FORCE_LIGHTNING:
+		ForceLightning(ent);
+		break;
+	case GENCMD_FORCE_RAGE:
+		ForceRage(ent);
+		break;
+	case GENCMD_FORCE_PROTECT:
+		ForceProtect(ent);
+		break;
+	case GENCMD_FORCE_ABSORB:
+		ForceAbsorb(ent);
+		break;
+	case GENCMD_FORCE_SEEING:
+		ForceSeeing(ent);
+		break;
+	case GENCMD_FORCE_HEAL:
+		ForceHeal(ent);
+		break;
+	}
+}
+
+
+/*
+==============
+ClientThink
+
+This will be called once for each client frame, which will
+usually be a couple times for each server frame on fast clients.
+
+==============
+*/
+
+extern int		G_FindLocalInterestPoint( gentity_t *self );
+extern float	G_CanJumpToEnemyVeh(Vehicle_t *pVeh, const usercmd_t *pUmcd );
+
+void ClientThink_real( gentity_t *ent, usercmd_t *ucmd ) 
+{
+	gclient_t	*client;
+	pmove_t		pm;
+	vec3_t		oldOrigin;
+	int			oldEventSequence;
+	int			msec;
+	qboolean	inSpinFlipAttack = PM_AdjustAnglesForSpinningFlip( ent, ucmd, qfalse );
+	qboolean	controlledByPlayer = qfalse;
+
+	Vehicle_t *pVeh = NULL;
+
+	if ( ent->client && ent->client->NPC_class == CLASS_VEHICLE )
+	{
+		pVeh = ent->m_pVehicle;
+	}
+
+	//Don't let the player do anything if in a camera
+	if ( (ent->s.eFlags&EF_HELD_BY_RANCOR) 
+		|| (ent->s.eFlags&EF_HELD_BY_WAMPA) )
+	{
+		G_HeldByMonster( ent, &ucmd );
+	}
+
+	if ( ent->s.number == 0 ) 
+	{
+extern cvar_t	*g_skippingcin;
+
+		if ( ent->s.eFlags & EF_LOCKED_TO_WEAPON )
+		{
+			G_UpdateEmplacedWeaponData( ent );
+			RunEmplacedWeapon( ent, &ucmd );
+		}
+		if ( ent->client->ps.saberLockTime > level.time && ent->client->ps.saberLockEnemy != ENTITYNUM_NONE )
+		{
+			NPC_SetLookTarget( ent, ent->client->ps.saberLockEnemy, level.time+1000 );
+		}
+		if ( ent->client->renderInfo.lookTargetClearTime < level.time //NOTE: here this is used as a debounce, not an actual timer
+			&& ent->health > 0 //must be alive
+			&& (!ent->enemy || ent->client->ps.saberMove != LS_A_BACKSTAB) )//don't update if in backstab unless don't currently have an enemy
+		{//NOTE: doesn't keep updating to nearest enemy once you're dead
+			int	newLookTarget;
+			if ( !G_ValidateLookEnemy( ent, ent->enemy ) )
+			{
+				ent->enemy = NULL;
+			}
+			//FIXME: make this a little prescient?
+			G_ChooseLookEnemy( ent, ucmd );
+			if ( ent->enemy )
+			{//target
+				newLookTarget = ent->enemy->s.number;
+				//so we don't change our minds in the next 1 second
+				ent->client->renderInfo.lookTargetClearTime = level.time+1000;
+				ent->client->renderInfo.lookMode = LM_ENT;
+			}
+			else
+			{//no target
+				//FIXME: what about sightalerts and missiles?
+				newLookTarget = ENTITYNUM_NONE;
+				newLookTarget = G_FindLocalInterestPoint( ent );
+				if ( newLookTarget != ENTITYNUM_NONE )
+				{//found something of interest
+					ent->client->renderInfo.lookMode = LM_INTEREST;
+				}
+				else
+				{//okay, no interesting things and no enemies, so look for items
+					newLookTarget = G_FindLookItem( ent );
+					ent->client->renderInfo.lookMode = LM_ENT;
+				}
+			}
+			if ( ent->client->renderInfo.lookTarget != newLookTarget )
+			{//transitioning
+				NPC_SetLookTarget( ent, newLookTarget, level.time+1000 );
+			}
+		}
+		if ( in_camera )
+		{
+			// watch the code here, you MUST "return" within this IF(), *unless* you're stopping the cinematic skip.
+			//
+			if ( ClientCinematicThink(ent->client) )
+			{
+				if (g_skippingcin->integer)	// already doing cinematic skip?
+				{// yes...   so stop skipping...
+					G_StopCinematicSkip();
+				}
+				else
+				{// no... so start skipping...
+					G_StartCinematicSkip();
+					return;
+				}
+			}
+			else
+			{
+				return;
+			}
+		}
+		// If he's riding the vehicle...
+		else if ( ent->s.m_iVehicleNum != 0 && ent->health > 0 )
+		{
+		}
+		else 
+		{
+			if ( g_skippingcin->integer )
+			{//We're skipping the cinematic and it's over now
+				gi.cvar_set("timescale", "1");
+				gi.cvar_set("skippingCinematic", "0");
+			}
+			if ( ent->client->ps.pm_type == PM_DEAD && cg.missionStatusDeadTime < level.time )
+			{//mission status screen is up because player is dead, stop all scripts
+				if (Q_stricmpn(level.mapname,"_holo",5)) {
+					stop_icarus = qtrue;
+				}
+			}
+		}
+
+//		// Don't allow the player to adjust the pitch when they are in third person overhead cam.
+//extern vmCvar_t cg_thirdPerson;
+//		if ( cg_thirdPerson.integer == 2 )
+//		{
+//			ucmd->angles[PITCH] = 0;
+//		}
+
+		if ( cg.zoomMode == 2 )
+		{
+			// Any kind of movement when the player is NOT ducked when the disruptor gun is zoomed will cause us to auto-magically un-zoom
+			if ( ( (ucmd->forwardmove||ucmd->rightmove) 
+				   && ucmd->upmove >= 0 //crouching-moving is ok
+				   && !(ucmd->buttons&BUTTON_USE)/*leaning is ok*/ 
+				 ) 
+				 || ucmd->upmove > 0 //jumping not allowed
+			   )
+			{
+				// already zooming, so must be wanting to turn it off
+				G_Sound( ent, G_SoundIndex( "sound/weapons/disruptor/zoomend.wav" ));
+#ifdef _IMMERSION
+				G_Force( ent, G_ForceIndex( "fffx/weapons/disruptor/zoomend", FF_CHANNEL_WEAPON ) );
+#endif // _IMMERSION
+				cg.zoomMode = 0;
+				cg.zoomTime = cg.time;
+				cg.zoomLocked = qfalse;
+			}
+		}
+
+		if ( (player_locked 
+				|| (ent->client->ps.eFlags&EF_FORCE_GRIPPED) 
+				|| (ent->client->ps.eFlags&EF_FORCE_DRAINED)
+				|| (ent->client->ps.legsAnim==BOTH_PLAYER_PA_1)
+				|| (ent->client->ps.legsAnim==BOTH_PLAYER_PA_2)
+				|| (ent->client->ps.legsAnim==BOTH_PLAYER_PA_3))
+			&& ent->client->ps.pm_type < PM_DEAD ) // unless dead
+		{//lock out player control
+			if ( !player_locked )
+			{
+				VectorClear( ucmd->angles );
+			}
+			ucmd->forwardmove = 0;
+			ucmd->rightmove = 0;
+			ucmd->buttons = 0;
+			ucmd->upmove = 0;
+			PM_AdjustAnglesToGripper( ent, ucmd );
+		}
+		if ( ent->client->ps.leanofs )
+		{//no shooting while leaning
+			ucmd->buttons &= ~BUTTON_ATTACK;
+			if ( ent->client->ps.weapon != WP_DISRUPTOR )
+			{//can still zoom around corners
+				ucmd->buttons &= ~BUTTON_ALT_ATTACK;
+			}
+		}
+	}
+	else
+	{
+		if ( ent->s.eFlags & EF_LOCKED_TO_WEAPON )
+		{
+			G_UpdateEmplacedWeaponData( ent );
+		}
+		if ( player && player->client && player->client->ps.viewEntity == ent->s.number )
+		{
+			controlledByPlayer = qtrue;
+			int sav_weapon = ucmd->weapon;
+			memcpy( ucmd, &player->client->usercmd, sizeof( usercmd_t ) );
+			ucmd->weapon = sav_weapon;
+			ent->client->usercmd = *ucmd;
+		}
+
+		// Transfer over our driver's commands to us (the vehicle).
+		if ( ent->owner && ent->client && ent->client->NPC_class == CLASS_VEHICLE )
+		{
+			memcpy( ucmd, &ent->owner->client->usercmd, sizeof( usercmd_t ) );
+			ucmd->buttons &= ~BUTTON_USE;//Vehicles NEVER try to use ANYTHING!!!
+			//ucmd->weapon = ent->client->ps.weapon;	// but keep our weapon.
+			ent->client->usercmd = *ucmd;
+		}
+
+		G_NPCMunroMatchPlayerWeapon( ent );
+	}
+
+	// If we are a vehicle, update ourself.
+	if ( pVeh 
+		&& (pVeh->m_pVehicleInfo->Inhabited(pVeh) 
+			|| pVeh->m_iBoarding!=0 
+			|| pVeh->m_pVehicleInfo->type!=VH_ANIMAL) )
+	{
+		pVeh->m_pVehicleInfo->Update( pVeh, ucmd );
+	}
+	else if ( ent->client )
+	{//this is any client that is not a vehicle (OR: is a vehicle and it not being ridden, is not being boarded, or is a TaunTaun...!
+		if ( ent->client->NPC_class == CLASS_GONK || 
+			ent->client->NPC_class == CLASS_MOUSE || 
+			ent->client->NPC_class == CLASS_R2D2 || 
+			ent->client->NPC_class == CLASS_R5D2 )
+		{//no jumping or strafing in these guys
+			ucmd->upmove = ucmd->rightmove = 0;
+		}
+		else if ( ent->client->NPC_class == CLASS_ATST || ent->client->NPC_class == CLASS_RANCOR )
+		{//no jumping in atst
+			if (ent->client->ps.pm_type != PM_NOCLIP)
+			{
+				ucmd->upmove = 0;
+			}
+			if ( ent->client->ps.groundEntityNum != ENTITYNUM_NONE )
+			{//ATST crushes anything underneath it
+				gentity_t	*under = &g_entities[ent->client->ps.groundEntityNum];
+				if ( under && under->health && under->takedamage )
+				{
+					vec3_t	down = {0,0,-1};
+					//FIXME: we'll be doing traces down from each foot, so we'll have a real impact origin
+					G_Damage( under, ent, ent, down, under->currentOrigin, 100, 0, MOD_CRUSH );
+				}
+				//so they know to run like hell when I get close
+				//FIXME: project this in the direction I'm moving?
+				if ( ent->client->NPC_class != CLASS_RANCOR && !Q_irand( 0, 10 ) )
+				{//not so often...
+					AddSoundEvent( ent, ent->currentOrigin, ent->maxs[1]*5, AEL_DANGER, qfalse, qtrue );
+					AddSightEvent( ent, ent->currentOrigin, ent->maxs[1]*5, AEL_DANGER, 100 );
+				}
+			}
+		}
+		else if ( ent->client->ps.groundEntityNum < ENTITYNUM_WORLD && !ent->client->ps.forceJumpCharge )
+		{//standing on an entity and not currently force jumping
+			gentity_t *groundEnt = &g_entities[ent->client->ps.groundEntityNum];
+			if ( groundEnt && groundEnt->client )
+			{
+				// If you landed on a speeder or animal vehicle...
+ 				if ( groundEnt->client && groundEnt->client->NPC_class == CLASS_VEHICLE )
+				{
+					if ( ent->client->NPC_class != CLASS_VEHICLE )
+					{//um... vehicles shouldn't ride other vehicles, mmkay?
+						if ( (groundEnt->m_pVehicle->m_pVehicleInfo->type == VH_ANIMAL && PM_HasAnimation( ent, BOTH_VT_IDLE ))
+							|| (groundEnt->m_pVehicle->m_pVehicleInfo->type == VH_SPEEDER && PM_HasAnimation( ent, BOTH_VS_IDLE )) )
+						{
+							//groundEnt->m_pVehicle->m_iBoarding = -3;	// Land From Behind
+							groundEnt->m_pVehicle->m_pVehicleInfo->Board( groundEnt->m_pVehicle, ent );
+						}
+					}
+				}
+				else if ( groundEnt->client && groundEnt->client->NPC_class == CLASS_SAND_CREATURE
+					&& G_HasKnockdownAnims( ent ) )
+				{//step on a sand creature = *you* fall down
+                    G_Knockdown( ent, groundEnt, vec3_origin, 300, qtrue );
+				}
+				else if ( groundEnt->client && groundEnt->client->NPC_class == CLASS_RANCOR )
+				{//step on a Rancor, it bucks & throws you off
+					if ( groundEnt->client->ps.legsAnim != BOTH_ATTACK3 
+						&& groundEnt->client->ps.legsAnim != BOTH_ATTACK4 
+						&& groundEnt->client->ps.legsAnim != BOTH_BUCK_RIDER )
+					{//don't interrupt special anims
+						vec3_t	throwDir, right;
+						AngleVectors( groundEnt->currentAngles, throwDir, right, NULL );
+						VectorScale(throwDir,-1,throwDir);
+						VectorMA( throwDir, Q_flrand( -0.5f, 0.5f), right, throwDir );
+						throwDir[2] = 0.2f;
+						VectorNormalize( throwDir );
+						if ( !(ent->flags&FL_NO_KNOCKBACK) )
+						{
+							G_Throw( ent, throwDir, Q_flrand( 50, 200 ) );
+						}
+						if ( G_HasKnockdownAnims( ent ) )
+						{
+							G_Knockdown( ent, groundEnt, vec3_origin, 300, qtrue );
+						}
+						NPC_SetAnim( groundEnt, SETANIM_BOTH, BOTH_BUCK_RIDER, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD);
+					}
+				}
+				else if ( groundEnt->client->ps.groundEntityNum != ENTITYNUM_NONE && 
+							groundEnt->health > 0 && !PM_InRoll( &groundEnt->client->ps ) 
+							&& !(groundEnt->client->ps.eFlags&EF_LOCKED_TO_WEAPON) 
+							&& !(groundEnt->client->ps.eFlags&EF_HELD_BY_RANCOR) 
+							&& !(groundEnt->client->ps.eFlags&EF_HELD_BY_WAMPA)
+							&& !(groundEnt->client->ps.eFlags&EF_HELD_BY_SAND_CREATURE)
+							&& !inSpinFlipAttack )
+
+				{//landed on a live client who is on the ground, jump off them and knock them down
+					qboolean forceKnockdown = qfalse;
+					
+					// If in a vehicle when land on someone, always knockdown.
+					if ( pVeh )
+					{
+						forceKnockdown = qtrue;
+					}
+					else if ( ent->s.number 
+						&& ent->NPC 
+						&& ent->client->ps.forcePowerLevel[FP_LEVITATION] > FORCE_LEVEL_0 )//ent->s.weapon == WP_SABER )
+					{//force-jumper landed on someone
+						//don't jump off, too many ledges, plus looks weird
+						if ( groundEnt->client->playerTeam != ent->client->playerTeam )
+						{//don't knock down own guys
+							forceKnockdown = (qboolean)(Q_irand( 0, RANK_CAPTAIN+4 )<ent->NPC->rank);
+						}
+						//now what... push the groundEnt out of the way?
+						if ( !ent->client->ps.velocity[0]
+							&& !ent->client->ps.velocity[1] )
+						{//not moving, shove us a little
+							vec3_t slideFwd;
+							AngleVectors( ent->client->ps.viewangles, slideFwd, NULL, NULL );
+							slideFwd[2] = 0.0f;
+							VectorNormalize( slideFwd );
+							ent->client->ps.velocity[0] = slideFwd[0]*10.0f;
+							ent->client->ps.velocity[1] = slideFwd[1]*10.0f;
+						}
+						//slide for a little
+						ent->client->ps.pm_flags |= PMF_TIME_NOFRICTION;
+						ent->client->ps.pm_time = 100;
+					}
+					else if ( ent->health > 0 )
+					{
+						if ( !PM_InRoll( &ent->client->ps ) 
+							&& !PM_FlippingAnim( ent->client->ps.legsAnim ) )
+						{
+							if ( ent->s.number && ent->s.weapon == WP_SABER )
+							{
+								ent->client->ps.forceJumpCharge = 320;//FIXME: calc this intelligently?
+							}
+							else if ( !ucmd->upmove )
+							{//if not ducking (which should cause a roll), then jump
+								ucmd->upmove = 127;
+							}
+							if ( !ucmd->forwardmove && !ucmd->rightmove )
+							{//  If not moving, don't want to jump straight up
+								//FIXME: trace for clear di?
+								if ( !Q_irand( 0, 3 ) )
+								{
+									ucmd->forwardmove = 127;
+								}
+								else if ( !Q_irand( 0, 3 ) )
+								{
+									ucmd->forwardmove = -127;
+								}
+								else if ( !Q_irand( 0, 1 ) )
+								{
+									ucmd->rightmove = 127;
+								}
+								else
+								{
+									ucmd->rightmove = -127;
+								}
+							}
+							if ( !ent->s.number && ucmd->upmove < 0 )
+							{//player who should roll- force it
+								int	rollAnim = BOTH_ROLL_F;
+								if ( ucmd->forwardmove >= 0 )
+								{
+									rollAnim = BOTH_ROLL_F;
+								}
+								else if ( ucmd->forwardmove < 0 )
+								{
+									rollAnim = BOTH_ROLL_B;
+								}
+								else if ( ucmd->rightmove > 0 )
+								{
+									rollAnim = BOTH_ROLL_R;
+								}
+								else if ( ucmd->rightmove < 0 )
+								{
+									rollAnim = BOTH_ROLL_L;
+								}
+								NPC_SetAnim(ent,SETANIM_BOTH,rollAnim,SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD);
+								G_AddEvent( ent, EV_ROLL, 0 );
+								ent->client->ps.saberMove = LS_NONE;
+							}
+						}
+					}
+					else
+					{//a corpse?  Shit
+						//Hmm, corpses should probably *always* knockdown...
+						forceKnockdown = qtrue;
+						ent->clipmask &= ~CONTENTS_BODY;
+					}
+					//FIXME: need impact sound event
+					GEntity_PainFunc( groundEnt, ent, ent, groundEnt->currentOrigin, 0, MOD_CRUSH );
+					if ( !forceKnockdown 
+						&& groundEnt->client->NPC_class == CLASS_DESANN 
+						&& ent->client->NPC_class != CLASS_LUKE )
+					{//can't knock down desann unless you're luke
+						//FIXME: should he smack you away like Galak Mech?
+					}
+					else if ( forceKnockdown //forced
+						|| ent->client->NPC_class == CLASS_DESANN //desann always knocks people down
+						|| ( ( (groundEnt->s.number&&(groundEnt->s.weapon!=WP_SABER||!groundEnt->NPC||groundEnt->NPC->rank<Q_irand(RANK_CIVILIAN,RANK_CAPTAIN+1)))  //an NPC who is either not a saber user or passed the rank-based probability test
+								|| ((!ent->s.number||G_ControlledByPlayer(groundEnt)) && !Q_irand( 0, 3 )&&cg.renderingThirdPerson&&!cg.zoomMode) )//or a player in third person, 25% of the time
+							&& groundEnt->client->playerTeam != ent->client->playerTeam//and not on the same team
+							&& ent->client->ps.legsAnim != BOTH_JUMPATTACK6 ) )//not in the sideways-spinning jump attack
+					{
+						int knockAnim = BOTH_KNOCKDOWN1;
+						if ( PM_CrouchAnim( groundEnt->client->ps.legsAnim ) )
+						{//knockdown from crouch
+							knockAnim = BOTH_KNOCKDOWN4;
+						}
+						else
+						{
+							vec3_t gEFwd, gEAngles = {0,groundEnt->client->ps.viewangles[YAW],0};
+							AngleVectors( gEAngles, gEFwd, NULL, NULL );
+							if ( DotProduct( ent->client->ps.velocity, gEFwd ) > 50 )
+							{//pushing him forward
+								knockAnim = BOTH_KNOCKDOWN3;
+							}
+						}
+						NPC_SetAnim( groundEnt, SETANIM_BOTH, knockAnim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+					}
+				}
+			}
+		}
+	}
+
+
+	client = ent->client;
+
+	// mark the time, so the connection sprite can be removed
+	client->lastCmdTime = level.time;
+	client->pers.lastCommand = *ucmd;
+
+	// sanity check the command time to prevent speedup cheating
+	if ( ucmd->serverTime > level.time + 200 ) 
+	{
+		ucmd->serverTime = level.time + 200;
+	}
+	if ( ucmd->serverTime < level.time - 1000 ) 
+	{
+		ucmd->serverTime = level.time - 1000;
+	} 
+
+	msec = ucmd->serverTime - client->ps.commandTime;
+	if ( msec < 1 ) 
+	{
+		msec = 1;
+	}
+	if ( msec > 200 ) 
+	{
+		msec = 200;
+	}
+
+	if ( client->noclip ) 
+	{
+		client->ps.pm_type = PM_NOCLIP;
+	} 
+	else if ( client->ps.stats[STAT_HEALTH] <= 0 ) 
+	{
+		client->ps.pm_type = PM_DEAD;
+	} 
+	else 
+	{
+		client->ps.pm_type = PM_NORMAL;
+	}
+
+	//FIXME: if global gravity changes this should update everyone's personal gravity...
+	if ( !(ent->svFlags & SVF_CUSTOM_GRAVITY) )
+	{
+		if (ent->client->inSpaceIndex)
+		{ //in space, so no gravity...
+			client->ps.gravity = 0.0f;
+		}
+		else
+		{
+			client->ps.gravity = g_gravity->value;
+		}
+	}
+
+	if (!USENEWNAVSYSTEM || ent->s.number==0)
+	{
+		ClientAlterSpeed(ent, ucmd, controlledByPlayer, 0);
+	}
+
+
+	//FIXME: need to do this before check to avoid walls and cliffs (or just cliffs?)
+	BG_AddPushVecToUcmd( ent, ucmd );
+
+	G_CheckClampUcmd( ent, ucmd );
+
+	WP_ForcePowersUpdate( ent, ucmd );
+
+	//if we have the saber in hand, check for starting a block to reflect shots
+	if ( ent->s.number < MAX_CLIENTS//player
+		|| ( ent->NPC && G_JediInNormalAI( ent ) ) )//NPC jedi not in a special AI mode
+	{
+		WP_SaberStartMissileBlockCheck( ent, ucmd  );
+	}
+
+	// Update the position of the saber, and check to see if we're throwing it
+	if ( client->ps.saberEntityNum != ENTITYNUM_NONE )
+	{
+		int updates = 1;
+		if ( ent->NPC )
+		{
+			updates = 3;//simulate player update rate?
+		}
+		for ( int update = 0; update < updates; update++ )
+		{
+			WP_SaberUpdate( ent, ucmd );
+		}
+	}
+
+	//NEED to do this every frame, since these overrides do not go into the save/load data
+	if ( ent->client && ent->s.m_iVehicleNum != 0 && !ent->s.number && !MatrixMode)
+	{//FIXME: extern and read from g_vehicleInfo?
+		Vehicle_t *pPlayerVeh = ent->owner->m_pVehicle;
+		if ( pPlayerVeh && pPlayerVeh->m_pVehicleInfo->cameraOverride )
+		{
+			// Vehicle Camera Overrides
+			//--------------------------
+ 			cg.overrides.active					|= ( CG_OVERRIDE_3RD_PERSON_RNG | CG_OVERRIDE_FOV | CG_OVERRIDE_3RD_PERSON_VOF | CG_OVERRIDE_3RD_PERSON_POF );
+ 			cg.overrides.thirdPersonRange		 = pPlayerVeh->m_pVehicleInfo->cameraRange;
+			cg.overrides.fov					 = pPlayerVeh->m_pVehicleInfo->cameraFOV;
+			cg.overrides.thirdPersonVertOffset	 = pPlayerVeh->m_pVehicleInfo->cameraVertOffset;
+			cg.overrides.thirdPersonPitchOffset  = pPlayerVeh->m_pVehicleInfo->cameraPitchOffset;
+
+			if ( pPlayerVeh->m_pVehicleInfo->cameraAlpha )
+			{
+				cg.overrides.active				|= CG_OVERRIDE_3RD_PERSON_APH;
+			}
+
+			// If In A Speeder (NOT DURING TURBO)
+			//------------------------------------
+			if ((level.time>pPlayerVeh->m_iTurboTime) && pPlayerVeh->m_pVehicleInfo->type==VH_SPEEDER)
+			{
+				// If Using Strafe And Use Keys
+				//------------------------------
+				if ((pPlayerVeh->m_ucmd.rightmove!=0) && 
+//					(pPlayerVeh->m_pParentEntity->client->ps.speed>=0) && 
+					(pPlayerVeh->m_ucmd.buttons&BUTTON_USE)
+					)
+				{
+					cg.overrides.active |= CG_OVERRIDE_3RD_PERSON_ANG;		// Turn On Angle Offset
+					cg.overrides.thirdPersonRange *= -2;					// Camera In Front Of Player
+					cg.overrides.thirdPersonAngle  = (pPlayerVeh->m_ucmd.rightmove>0)?(20):(-20);
+				}
+
+				// Auto Pullback Of Camera To Show Enemy
+				//---------------------------------------
+				else 
+				{
+					cg.overrides.active &= ~CG_OVERRIDE_3RD_PERSON_ANG;		// Turn Off Angle Offset
+					if (ent->enemy)
+					{
+						vec3_t	actorDirection;
+						vec3_t	enemyDirection;
+
+						AngleVectors(ent->currentAngles, actorDirection, 0, 0);
+						VectorSubtract(ent->enemy->currentOrigin, ent->currentOrigin, enemyDirection);
+						float	enemyDistance = VectorNormalize(enemyDirection);
+
+						if (enemyDistance>cg.overrides.thirdPersonRange && enemyDistance<400 && DotProduct(actorDirection, enemyDirection)<-0.5f)
+						{
+							cg.overrides.thirdPersonRange = enemyDistance;
+						}
+					}
+				}
+			}
+		}
+	}
+	else if ( client->ps.eFlags&EF_IN_ATST )
+	{
+		cg.overrides.active |= (CG_OVERRIDE_3RD_PERSON_RNG|CG_OVERRIDE_3RD_PERSON_POF|CG_OVERRIDE_3RD_PERSON_VOF);
+		cg.overrides.thirdPersonRange = 240;
+		if ( cg_thirdPersonAutoAlpha.integer )
+		{
+			if ( ent->health > 0 && ent->client->ps.viewangles[PITCH] < 15 && ent->client->ps.viewangles[PITCH] > 0 )
+			{
+				cg.overrides.active |= CG_OVERRIDE_3RD_PERSON_APH;
+				if ( cg.overrides.thirdPersonAlpha > 0.525f )
+				{
+					cg.overrides.thirdPersonAlpha -= 0.025f;
+				}
+				else if ( cg.overrides.thirdPersonAlpha > 0.5f )
+				{
+					cg.overrides.thirdPersonAlpha = 0.5f;
+				}
+			}
+			else if ( cg.overrides.active&CG_OVERRIDE_3RD_PERSON_APH )
+			{
+				if ( cg.overrides.thirdPersonAlpha > cg_thirdPersonAlpha.value )
+				{
+					cg.overrides.active &= ~CG_OVERRIDE_3RD_PERSON_APH;
+				}
+				else if ( cg.overrides.thirdPersonAlpha < cg_thirdPersonAlpha.value-0.1f )
+				{
+					cg.overrides.thirdPersonAlpha += 0.1f;
+				}
+				else if ( cg.overrides.thirdPersonAlpha < cg_thirdPersonAlpha.value )
+				{
+					cg.overrides.thirdPersonAlpha = cg_thirdPersonAlpha.value;
+					cg.overrides.active &= ~CG_OVERRIDE_3RD_PERSON_APH;
+				}
+			}
+		}
+		if ( ent->client->ps.viewangles[PITCH] > 0 )
+		{
+			cg.overrides.thirdPersonPitchOffset = ent->client->ps.viewangles[PITCH]*-0.75;
+			cg.overrides.thirdPersonVertOffset = 300+ent->client->ps.viewangles[PITCH]*-10;
+			if ( cg.overrides.thirdPersonVertOffset < 0 )
+			{
+				cg.overrides.thirdPersonVertOffset = 0;
+			}
+		}
+		else if ( ent->client->ps.viewangles[PITCH] < 0 )
+		{
+			cg.overrides.thirdPersonPitchOffset = ent->client->ps.viewangles[PITCH]*-0.75;
+			cg.overrides.thirdPersonVertOffset = 300+ent->client->ps.viewangles[PITCH]*-5;
+			if ( cg.overrides.thirdPersonVertOffset > 300 )
+			{
+				cg.overrides.thirdPersonVertOffset = 300;
+			}
+		}
+		else
+		{
+			cg.overrides.thirdPersonPitchOffset = 0;
+			cg.overrides.thirdPersonVertOffset = 200;
+		}
+	}
+
+	//play/stop any looping sounds tied to controlled movement
+	G_CheckMovingLoopingSounds( ent, ucmd );
+
+	//remember your last angles
+	VectorCopy ( ent->client->ps.viewangles, ent->lastAngles );
+	// set up for pmove
+	oldEventSequence = client->ps.eventSequence;
+
+	memset( &pm, 0, sizeof(pm) );
+
+	pm.gent = ent;
+	pm.ps = &client->ps;
+	pm.cmd = *ucmd;
+//	pm.tracemask = MASK_PLAYERSOLID;	// used differently for navgen
+	pm.tracemask = ent->clipmask;
+	pm.trace = gi.trace;
+	pm.pointcontents = gi.pointcontents;
+	pm.debugLevel = g_debugMove->integer;
+	pm.noFootsteps = 0;//( g_dmflags->integer & DF_NO_FOOTSTEPS ) > 0;
+
+	if ( ent->client && ent->NPC )
+	{
+		pm.cmd.weapon = ent->client->ps.weapon;
+	}
+
+	VectorCopy( client->ps.origin, oldOrigin );
+
+#ifdef _XBOX
+	// if we're an npc then set the waterlevel
+	// based on the entity structure
+	// otherwise, zero it
+	if(ent->s.number != 0)
+	{
+		pm.waterlevel = ent->waterlevel;
+		pm.watertype = ent->watertype;
+	}
+	else
+	{
+		pm.waterlevel = 0;
+		pm.watertype = 0;
+	}
+#endif
+
+	// perform a pmove
+	Pmove( &pm );
+	pm.gent = 0;
+
+	ProcessGenericCmd(ent, pm.cmd.generic_cmd);
+
+	// save results of pmove
+	if ( ent->client->ps.eventSequence != oldEventSequence ) 
+	{
+		ent->eventTime = level.time;
+		{
+			int		seq;
+
+			seq = (ent->client->ps.eventSequence-1) & (MAX_PS_EVENTS-1);
+			ent->s.event = ent->client->ps.events[ seq ] | ( ( ent->client->ps.eventSequence & 3 ) << 8 );
+			ent->s.eventParm = ent->client->ps.eventParms[ seq ];
+		}
+	}
+	PlayerStateToEntityState( &ent->client->ps, &ent->s );
+
+	VectorCopy ( ent->currentOrigin, ent->lastOrigin );
+#if 1
+	// use the precise origin for linking
+	VectorCopy( ent->client->ps.origin, ent->currentOrigin );
+#else
+	//We don't use prediction anymore, so screw this
+	// use the snapped origin for linking so it matches client predicted versions
+	VectorCopy( ent->s.pos.trBase, ent->currentOrigin );
+#endif
+
+
+	//Had to leave this in, some legacy code must still be using s.angles
+	//Shouldn't interfere with interpolation of angles, should it?
+	VectorCopy(ent->client->ps.viewangles , ent->currentAngles );
+//	if (pVeh)
+//	{
+//		gi.Printf("%d\n", ucmd->angles[2]);
+//	}
+
+	VectorCopy( pm.mins, ent->mins );
+	VectorCopy( pm.maxs, ent->maxs );
+
+#ifdef _XBOX
+	// if this is the player then set the ent water level
+	// npcs are updated elsewhere
+	if(ent->s.number == 0)
+	{
+		ent->waterlevel = pm.waterlevel;
+		ent->watertype = pm.watertype;
+	}
+#else
+	ent->waterlevel = pm.waterlevel;
+	ent->watertype = pm.watertype;
+#endif
+
+
+
+	_VectorCopy( ucmd->angles, client->pers.cmd_angles );
+
+	// execute client events
+	ClientEvents( ent, oldEventSequence );
+
+	if ( pm.useEvent )
+	{
+		//TODO: Use
+		TryUse( ent );
+	}
+
+	// link entity now, after any personal teleporters have been used
+	gi.linkentity( ent );
+	ent->client->hiddenDist = 0;
+	if ( !ent->client->noclip ) 
+	{
+		G_TouchTriggersLerped( ent );
+	}
+
+	// touch other objects
+	ClientImpacts( ent, &pm );
+
+	// swap and latch button actions
+	client->oldbuttons = client->buttons;
+	client->buttons = ucmd->buttons;
+	client->latched_buttons |= client->buttons & ~client->oldbuttons;
+
+	// check for respawning
+	if ( client->ps.stats[STAT_HEALTH] <= 0 ) 
+	{
+		// wait for the attack button to be pressed
+		if ( ent->NPC == NULL && level.time > client->respawnTime ) 
+		{
+			// don't allow respawn if they are still flying through the
+			// air, unless 10 extra seconds have passed, meaning something
+			// strange is going on, like the corpse is caught in a wind tunnel
+			/*
+			if ( level.time < client->respawnTime + 10000 ) 
+			{
+				if ( client->ps.groundEntityNum == ENTITYNUM_NONE ) 
+				{
+					return;
+				}
+			}
+			*/
+
+			// pressing attack or use is the normal respawn method
+			if ( ucmd->buttons & ( BUTTON_ATTACK ) ) 
+			{
+				respawn( ent );
+			}
+		}
+		if ( ent 
+			&& !ent->s.number 
+			&& ent->enemy 
+			&& ent->enemy != ent 
+			&& ent->enemy->s.number < ENTITYNUM_WORLD 
+			&& ent->enemy->inuse 
+			&& !(cg.overrides.active&CG_OVERRIDE_3RD_PERSON_ANG) )
+		{//keep facing enemy
+			vec3_t deadDir;
+			float deadYaw;
+			VectorSubtract( ent->enemy->currentOrigin, ent->currentOrigin, deadDir );
+			deadYaw = AngleNormalize180( vectoyaw ( deadDir ) );
+			if ( deadYaw > ent->client->ps.stats[STAT_DEAD_YAW] + 1 )
+			{
+				ent->client->ps.stats[STAT_DEAD_YAW]++;
+			}
+			else if ( deadYaw < ent->client->ps.stats[STAT_DEAD_YAW] - 1 )
+			{
+				ent->client->ps.stats[STAT_DEAD_YAW]--;
+			}
+			else
+			{
+				ent->client->ps.stats[STAT_DEAD_YAW] = deadYaw;
+			}
+		}
+		return;
+	}
+
+	// perform once-a-second actions
+	ClientTimerActions( ent, msec );
+
+	ClientEndPowerUps( ent );
+	//try some idle anims on ent if getting no input and not moving for some time
+	G_CheckClientIdle( ent, ucmd );
+}
+
+/*
+==================
+ClientThink
+
+A new command has arrived from the client
+==================
+*/
+extern void PM_CheckForceUseButton( gentity_t *ent, usercmd_t *ucmd  );
+extern qboolean PM_GentCantJump( gentity_t *gent );
+extern qboolean PM_WeaponOkOnVehicle( int weapon );
+void ClientThink( int clientNum, usercmd_t *ucmd ) {
+	gentity_t *ent;
+	qboolean restore_ucmd = qfalse;
+	usercmd_t sav_ucmd = {0};
+
+	ent = g_entities + clientNum;
+
+	if ( ent->s.number<MAX_CLIENTS )
+	{
+		if ( ent->client->ps.viewEntity > 0 && ent->client->ps.viewEntity < ENTITYNUM_WORLD )
+		{//you're controlling another NPC
+			gentity_t *controlled = &g_entities[ent->client->ps.viewEntity];
+			qboolean freed = qfalse;
+			if ( controlled->NPC 
+				&& controlled->NPC->controlledTime
+				&& ent->client->ps.forcePowerLevel[FP_TELEPATHY] > FORCE_LEVEL_3 )
+			{//An NPC I'm controlling with mind trick
+				if ( controlled->NPC->controlledTime < level.time )
+				{//time's up!
+					G_ClearViewEntity( ent );
+					freed = qtrue;
+				}
+			}
+			else if ( controlled->client //an NPC
+				&& PM_GentCantJump( controlled ) //that cannot jump
+				&& controlled->client->moveType != MT_FLYSWIM ) //and does not use upmove to fly
+			{//these types use jump to get out
+				if ( ucmd->upmove > 0 )
+				{//jumping gets you out of it FIXME: check some other button instead... like ESCAPE... so you could even have total control over an NPC?
+					G_ClearViewEntity( ent );
+					ucmd->upmove = 0;//ucmd->buttons = 0;
+					//stop player from doing anything for a half second after
+					ent->aimDebounceTime = level.time + 500;
+					freed = qtrue;
+				}
+			}
+
+			if ( !freed )
+			{//still controlling, save off my ucmd and clear it for my actual run through pmove
+				restore_ucmd = qtrue;
+				memcpy( &sav_ucmd, ucmd, sizeof( usercmd_t ) );
+				memset( ucmd, 0, sizeof( usercmd_t ) );
+				//to keep pointing in same dir, need to set ucmd->angles
+				ucmd->angles[PITCH] = ANGLE2SHORT( ent->client->ps.viewangles[PITCH] ) - ent->client->ps.delta_angles[PITCH];
+				ucmd->angles[YAW] = ANGLE2SHORT( ent->client->ps.viewangles[YAW] ) - ent->client->ps.delta_angles[YAW];
+				ucmd->angles[ROLL] = 0;
+				if ( controlled->NPC )
+				{
+					VectorClear( controlled->client->ps.moveDir );
+					controlled->client->ps.speed = (sav_ucmd.buttons&BUTTON_WALKING)?controlled->NPC->stats.walkSpeed:controlled->NPC->stats.runSpeed;
+				}
+			}
+			else
+			{
+				ucmd->angles[PITCH] = ANGLE2SHORT( ent->client->ps.viewangles[PITCH] ) - ent->client->ps.delta_angles[PITCH];
+				ucmd->angles[YAW] = ANGLE2SHORT( ent->client->ps.viewangles[YAW] ) - ent->client->ps.delta_angles[YAW];
+				ucmd->angles[ROLL] = 0;
+			}
+		}
+		else if ( ent->client->NPC_class == CLASS_ATST )
+		{
+			if ( ucmd->upmove > 0 )
+			{//get out of ATST
+				GEntity_UseFunc( ent->activator, ent, ent );
+				ucmd->upmove = 0;//ucmd->buttons = 0;
+			}
+		}
+
+
+		PM_CheckForceUseButton( ent, ucmd );
+	}
+
+	Vehicle_t *pVeh = NULL;
+
+	// Rider logic.
+	// NOTE: Maybe this should be extracted into a RiderUpdate() within the vehicle.
+	if ( ( pVeh = G_IsRidingVehicle( ent ) ) != 0  )
+	{
+		// If we're still in the vehicle...
+		if ( pVeh->m_pVehicleInfo->UpdateRider( pVeh, ent, ucmd ) )
+		{
+			restore_ucmd = qtrue;
+			memcpy( &sav_ucmd, ucmd, sizeof( usercmd_t ) );
+			memset( ucmd, 0, sizeof( usercmd_t ) );
+			//to keep pointing in same dir, need to set ucmd->angles
+			//ucmd->angles[PITCH] = ANGLE2SHORT( ent->client->ps.viewangles[PITCH] ) - ent->client->ps.delta_angles[PITCH];
+			//ucmd->angles[YAW] = ANGLE2SHORT( ent->client->ps.viewangles[YAW] ) - ent->client->ps.delta_angles[YAW];
+			//ucmd->angles[ROLL] = 0;
+			ucmd->angles[PITCH] = sav_ucmd.angles[PITCH];
+			ucmd->angles[YAW] = sav_ucmd.angles[YAW];
+			ucmd->angles[ROLL] = sav_ucmd.angles[ROLL];
+			//if ( sav_ucmd.weapon != ent->client->ps.weapon && PM_WeaponOkOnVehicle( sav_ucmd.weapon ) )
+			{//trying to change weapons to a valid weapon for this vehicle, to preserve this weapon change command
+				ucmd->weapon = sav_ucmd.weapon;
+			}
+			//else 
+			{//keep our current weapon
+			//	ucmd->weapon = ent->client->ps.weapon;
+			//	if ( ent->client->ps.weapon != WP_NONE )
+				{//not changing weapons and we are using one of our weapons, not using vehicle weapon
+					//so we actually want to do our fire weapon on us, not the vehicle
+					ucmd->buttons = (sav_ucmd.buttons&(BUTTON_ATTACK|BUTTON_ALT_ATTACK));
+			//		sav_ucmd.buttons &= ~ucmd->buttons;
+				}
+			}
+		}
+	}
+
+	ent->client->usercmd = *ucmd;
+
+//	if ( !g_syncronousClients->integer ) 
+	{
+		ClientThink_real( ent, ucmd );
+	}
+
+	// If a vehicle, make sure to attach our driver and passengers here (after we pmove, which is done in Think_Real))
+	if ( ent->client && ent->client->NPC_class == CLASS_VEHICLE )
+	{
+		pVeh = ent->m_pVehicle;
+		pVeh->m_pVehicleInfo->AttachRiders( pVeh );
+	}
+
+
+	// ClientThink_real can end up freeing this ent, need to check
+	if ( restore_ucmd && ent->client )
+	{//restore ucmd for later so NPC you're controlling can refer to them
+		memcpy( &ent->client->usercmd, &sav_ucmd, sizeof( usercmd_t ) );
+	}
+
+	if ( ent->s.number )
+	{//NPCs drown, burn from lava, etc, also
+		P_WorldEffects( ent );
+	}
+}
+
+void ClientEndPowerUps( gentity_t *ent ) 
+{
+	int			i;
+
+	if ( ent == NULL || ent->client == NULL ) 
+	{
+		return;
+	}
+	// turn off any expired powerups
+	for ( i = 0 ; i < MAX_POWERUPS ; i++ ) 
+	{
+		if ( ent->client->ps.powerups[ i ] < level.time ) 
+		{
+			ent->client->ps.powerups[ i ] = 0;
+		}
+	}
+}
+/*
+==============
+ClientEndFrame
+
+Called at the end of each server frame for each connected client
+A fast client will have multiple ClientThink for each ClientEdFrame,
+while a slow client may have multiple ClientEndFrame between ClientThink.
+==============
+*/
+void ClientEndFrame( gentity_t *ent ) 
+{
+	//
+	// If the end of unit layout is displayed, don't give
+	// the player any normal movement attributes
+	//
+
+	// burn from lava, etc
+	P_WorldEffects (ent);
+
+	// apply all the damage taken this frame
+	P_DamageFeedback (ent);
+
+	// add the EF_CONNECTION flag if we haven't gotten commands recently
+	/*
+	if ( level.time - ent->client->lastCmdTime > 1000 ) {
+		ent->s.eFlags |= EF_CONNECTION;
+	} else {
+		ent->s.eFlags &= ~EF_CONNECTION;
+	}
+	*/
+
+	ent->client->ps.stats[STAT_HEALTH] = ent->health;	// FIXME: get rid of ent->health...
+
+//	G_SetClientSound (ent);
+}
+
+
diff --git a/code/game/g_breakable.cpp b/code/game/g_breakable.cpp
new file mode 100644
index 0000000..8f4b66c
--- /dev/null
+++ b/code/game/g_breakable.cpp
@@ -0,0 +1,1535 @@
+// leave this line at the top for all g_xxxx.cpp files...
+#include "g_headers.h"
+
+
+#include "g_local.h"
+#include "g_functions.h"
+#include "..\cgame\cg_media.h"
+
+//client side shortcut hacks from cg_local.h
+//extern void CG_SurfaceExplosion( vec3_t origin, vec3_t normal, float radius, float shake_speed, qboolean smoke );
+extern void CG_MiscModelExplosion( vec3_t mins, vec3_t maxs, int size, material_t chunkType );
+extern void CG_Chunks( int owner, vec3_t origin, const vec3_t normal, const vec3_t mins, const vec3_t maxs,
+							float speed, int numChunks, material_t chunkType, int customChunk, float baseScale, int customSound = 0 );
+extern void G_SetEnemy( gentity_t *self, gentity_t *enemy );
+
+extern gentity_t *G_CreateObject ( gentity_t *owner, vec3_t origin, vec3_t angles, int modelIndex, int frame, trType_t trType, int effectID );
+
+extern	qboolean	player_locked;
+
+//---------------------------------------------------
+static void CacheChunkEffects( material_t material )
+{
+	switch( material )
+	{
+	case MAT_GLASS:
+		G_EffectIndex( "chunks/glassbreak" );
+		break;
+	case MAT_GLASS_METAL:
+		G_EffectIndex( "chunks/glassbreak" );
+		G_EffectIndex( "chunks/metalexplode" );
+		break;
+	case MAT_ELECTRICAL:
+	case MAT_ELEC_METAL:
+		G_EffectIndex( "chunks/sparkexplode" );
+		break;
+	case MAT_METAL:
+	case MAT_METAL2:
+	case MAT_METAL3:
+	case MAT_CRATE1:
+	case MAT_CRATE2:
+		G_EffectIndex( "chunks/metalexplode" );
+		break;
+	case MAT_GRATE1:
+		G_EffectIndex( "chunks/grateexplode" );
+		break;
+	case MAT_DRK_STONE:
+	case MAT_LT_STONE:
+	case MAT_GREY_STONE:
+	case MAT_WHITE_METAL: // what is this crap really supposed to be??
+		G_EffectIndex( "chunks/rockbreaklg" );
+		G_EffectIndex( "chunks/rockbreakmed" );
+		break;
+	case MAT_ROPE:
+		G_EffectIndex( "chunks/ropebreak" );
+//		G_SoundIndex(); // FIXME: give it a sound
+		break;
+	}
+}
+
+//--------------------------------------
+void funcBBrushDieGo (gentity_t *self)
+{
+	vec3_t		org, dir, up;
+	gentity_t	*attacker = self->enemy;
+	float		scale;
+	int			numChunks, size = 0;
+	material_t	chunkType = self->material;
+	
+	// if a missile is stuck to us, blow it up so we don't look dumb
+	// FIXME: flag me so I should know to do this check!
+	for ( int i = 0; i < MAX_GENTITIES; i++ )
+	{
+		if ( g_entities[i].s.groundEntityNum == self->s.number && ( g_entities[i].s.eFlags & EF_MISSILE_STICK ))
+		{
+			G_Damage( &g_entities[i], self, self, NULL, NULL, 99999, 0, MOD_CRUSH ); //?? MOD?
+		}
+	}
+
+	//NOTE: MUST do this BEFORE clearing contents, or you may not open the area portal!!!
+	gi.AdjustAreaPortalState( self, qtrue );
+
+	//So chunks don't get stuck inside me
+	self->s.solid = 0;
+	self->contents = 0;
+	self->clipmask = 0;
+	gi.linkentity(self); 
+
+	VectorSet(up, 0, 0, 1);
+
+	if ( self->target && attacker != NULL )
+	{
+		G_UseTargets(self, attacker);
+	}
+
+	VectorSubtract( self->absmax, self->absmin, org );// size
+
+	numChunks = random() * 6 + 18;
+
+	// This formula really has no logical basis other than the fact that it seemed to be the closest to yielding the results that I wanted.
+	// Volume is length * width * height...then break that volume down based on how many chunks we have
+	scale = sqrt( sqrt( org[0] * org[1] * org[2] )) * 1.75f;
+
+	if ( scale > 48 )
+	{
+		size = 2;
+	}
+	else if ( scale > 24 )
+	{
+		size = 1;
+	}
+
+	scale = scale / numChunks;
+
+	if ( self->radius > 0.0f )
+	{
+		// designer wants to scale number of chunks, helpful because the above scale code is far from perfect
+		//	I do this after the scale calculation because it seems that the chunk size generally seems to be very close, it's just the number of chunks is a bit weak
+		numChunks *= self->radius;
+	}
+
+	VectorMA( self->absmin, 0.5, org, org );
+	VectorAdd( self->absmin,self->absmax, org );
+	VectorScale( org, 0.5f, org );
+
+	if ( attacker != NULL && attacker->client )
+	{
+		VectorSubtract( org, attacker->currentOrigin, dir );
+		VectorNormalize( dir );
+	}
+	else
+	{
+		VectorCopy(up, dir);
+	} 
+
+	if ( !(self->spawnflags & 2048) ) // NO_EXPLOSION
+	{
+		// we are allowed to explode
+		CG_MiscModelExplosion( self->absmin, self->absmax, size, chunkType );
+	}
+
+	if ( self->splashDamage > 0 && self->splashRadius > 0 )
+	{
+		//explode
+		AddSightEvent( attacker, org, 256, AEL_DISCOVERED, 100 );
+		AddSoundEvent( attacker, org, 128, AEL_DISCOVERED, qfalse, qtrue );//FIXME: am I on ground or not?
+		G_RadiusDamage( org, self, self->splashDamage, self->splashRadius, self, MOD_UNKNOWN );
+
+		gentity_t *te = G_TempEntity( org, EV_GENERAL_SOUND );
+		te->s.eventParm = G_SoundIndex("sound/weapons/explosions/cargoexplode.wav");
+	}
+	else
+	{//just break
+		AddSightEvent( attacker, org, 128, AEL_DISCOVERED );
+		AddSoundEvent( attacker, org, 64, AEL_SUSPICIOUS, qfalse, qtrue );//FIXME: am I on ground or not?
+	}
+
+	//FIXME: base numChunks off size?
+	CG_Chunks( self->s.number, org, dir, self->absmin, self->absmax, 300, numChunks, chunkType, 0, scale, self->noise_index );
+
+	self->e_ThinkFunc = thinkF_G_FreeEntity;
+	self->nextthink = level.time + 50;
+	//G_FreeEntity( self );
+}
+
+void funcBBrushDie (gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int mod,int dFlags,int hitLoc)
+{
+	self->takedamage = qfalse;//stop chain reaction runaway loops
+
+	G_SetEnemy(self, attacker);
+
+	if(self->delay)
+	{
+		self->e_ThinkFunc = thinkF_funcBBrushDieGo;
+		self->nextthink = level.time + floor(self->delay * 1000.0f);
+		return;
+	}
+
+	funcBBrushDieGo(self);
+}
+
+void funcBBrushUse (gentity_t *self, gentity_t *other, gentity_t *activator)
+{
+	G_ActivateBehavior( self, BSET_USE );
+	if(self->spawnflags & 64)
+	{//Using it doesn't break it, makes it use it's targets
+		if(self->target && self->target[0])
+		{
+			G_UseTargets(self, activator);
+		}
+	}
+	else
+	{
+		funcBBrushDie(self, other, activator, self->health, MOD_UNKNOWN);
+	}
+}
+
+void funcBBrushPain(gentity_t *self, gentity_t *inflictor, gentity_t *attacker, const vec3_t point, int damage, int mod,int hitLoc)
+{
+	if ( self->painDebounceTime > level.time )
+	{
+		return;
+	}
+
+	if ( self->paintarget )
+	{
+		G_UseTargets2 (self, self->activator, self->paintarget);
+	}
+
+	G_ActivateBehavior( self, BSET_PAIN );
+
+	if ( self->material == MAT_DRK_STONE
+		|| self->material == MAT_LT_STONE
+		|| self->material == MAT_GREY_STONE )
+	{
+		vec3_t	org, dir;
+		float	scale;
+		VectorSubtract( self->absmax, self->absmin, org );// size
+		// This formula really has no logical basis other than the fact that it seemed to be the closest to yielding the results that I wanted.
+		// Volume is length * width * height...then break that volume down based on how many chunks we have
+		scale = VectorLength( org ) / 100.0f;
+		VectorMA( self->absmin, 0.5, org, org );
+		VectorAdd( self->absmin,self->absmax, org );
+		VectorScale( org, 0.5f, org );
+		if ( attacker != NULL && attacker->client )
+		{
+			VectorSubtract( attacker->currentOrigin, org, dir );
+			VectorNormalize( dir );
+		}
+		else
+		{
+			VectorSet( dir, 0, 0, 1 );
+		} 
+		CG_Chunks( self->s.number, org, dir, self->absmin, self->absmax, 300, Q_irand( 1, 3 ), self->material, 0, scale );
+	}
+
+	if ( self->wait == -1 )
+	{
+		self->e_PainFunc = painF_NULL;
+		return;
+	}
+
+	self->painDebounceTime = level.time + self->wait;
+}
+
+static void InitBBrush ( gentity_t *ent ) 
+{
+	float		light;
+	vec3_t		color;
+	qboolean	lightSet, colorSet;
+
+	VectorCopy( ent->s.origin, ent->pos1 );
+	
+	gi.SetBrushModel( ent, ent->model );
+
+	ent->e_DieFunc = dieF_funcBBrushDie;
+	
+	ent->svFlags |= SVF_BBRUSH;
+
+	// if the "model2" key is set, use a seperate model
+	// for drawing, but clip against the brushes
+	if ( ent->model2 ) 
+	{
+		ent->s.modelindex2 = G_ModelIndex( ent->model2 );
+	}
+
+	// if the "color" or "light" keys are set, setup constantLight
+	lightSet = G_SpawnFloat( "light", "100", &light );
+	colorSet = G_SpawnVector( "color", "1 1 1", color );
+	if ( lightSet || colorSet ) 
+	{
+		int		r, g, b, i;
+
+		r = color[0] * 255;
+		if ( r > 255 ) {
+			r = 255;
+		}
+		g = color[1] * 255;
+		if ( g > 255 ) {
+			g = 255;
+		}
+		b = color[2] * 255;
+		if ( b > 255 ) {
+			b = 255;
+		}
+		i = light / 4;
+		if ( i > 255 ) {
+			i = 255;
+		}
+		ent->s.constantLight = r | ( g << 8 ) | ( b << 16 ) | ( i << 24 );
+	}
+
+	if(ent->spawnflags & 128)
+	{//Can be used by the player's BUTTON_USE
+		ent->svFlags |= SVF_PLAYER_USABLE;
+	}
+
+	ent->s.eType = ET_MOVER;
+	gi.linkentity (ent);
+
+	ent->s.pos.trType = TR_STATIONARY;
+	VectorCopy( ent->pos1, ent->s.pos.trBase );
+}
+
+void funcBBrushTouch( gentity_t *ent, gentity_t *other, trace_t *trace )
+{
+}
+
+/*QUAKED func_breakable (0 .8 .5) ? INVINCIBLE IMPACT CRUSHER THIN SABERONLY HEAVY_WEAP USE_NOT_BREAK PLAYER_USE NO_EXPLOSION
+INVINCIBLE - can only be broken by being used
+IMPACT - does damage on impact
+CRUSHER - won't reverse movement when hit an obstacle
+THIN - can be broken by impact damage, like glass
+SABERONLY - only takes damage from sabers
+HEAVY_WEAP - only takes damage by a heavy weapon, like an emplaced gun or AT-ST gun.
+USE_NOT_BREAK - Using it doesn't make it break, still can be destroyed by damage
+PLAYER_USE - Player can use it with the use button
+NO_EXPLOSION - Does not play an explosion effect, though will still create chunks if specified
+
+When destroyed, fires it's trigger and chunks and plays sound "noise" or sound for type if no noise specified
+
+"targetname" entities with matching target will fire it
+"paintarget" target to fire when hit (but not destroyed)
+"wait"		how long minimum to wait between firing paintarget each time hit
+"delay"		When killed or used, how long (in seconds) to wait before blowing up (none by default)
+"model2"	.md3 model to also draw
+"modelAngles" md3 model's angles <pitch yaw roll> (in addition to any rotation on the part of the brush entity itself)
+"target"	all entities with a matching targetname will be used when this is destoryed
+"health"	default is 10
+"radius"  Chunk code tries to pick a good volume of chunks, but you can alter this to scale the number of spawned chunks. (default 1)  (.5) is half as many chunks, (2) is twice as many chunks
+"NPC_targetname" - Only the NPC with this name can damage this
+"forcevisible" - When you turn on force sight (any level), you can see these draw through the entire level...
+"redCrosshair" - crosshair turns red when you look at this
+
+Damage: default is none
+"splashDamage" - damage to do
+"splashRadius" - radius for above damage
+
+"team" - This cannot take damage from members of this team:
+	"player"
+	"neutral"
+	"enemy"
+
+Don't know if these work:  
+"color"		constantLight color
+"light"		constantLight radius
+
+"material" - default is "0 - MAT_METAL" - choose from this list:
+0 = MAT_METAL		(basic blue-grey scorched-DEFAULT)
+1 = MAT_GLASS		
+2 = MAT_ELECTRICAL	(sparks only)
+3 = MAT_ELEC_METAL	(METAL2 chunks and sparks)
+4 =	MAT_DRK_STONE	(brown stone chunks)
+5 =	MAT_LT_STONE	(tan stone chunks)
+6 =	MAT_GLASS_METAL (glass and METAL2 chunks)
+7 = MAT_METAL2		(electronic type of metal)
+8 = MAT_NONE		(no chunks)
+9 = MAT_GREY_STONE	(grey colored stone)
+10 = MAT_METAL3		(METAL and METAL2 chunk combo)
+11 = MAT_CRATE1		(yellow multi-colored crate chunks)
+12 = MAT_GRATE1		(grate chunks--looks horrible right now)
+13 = MAT_ROPE		(for yavin_trial, no chunks, just wispy bits )
+14 = MAT_CRATE2		(red multi-colored crate chunks)
+15 = MAT_WHITE_METAL (white angular chunks for Stu, NS_hideout )
+
+*/
+void SP_func_breakable( gentity_t *self ) 
+{
+	if(!(self->spawnflags & 1))
+	{
+		if(!self->health)
+		{
+			self->health = 10;
+		}
+	}
+
+	if ( self->spawnflags & 16 ) // saber only
+	{
+		self->flags |= FL_DMG_BY_SABER_ONLY;
+	}
+	else if ( self->spawnflags & 32 ) // heavy weap
+	{
+		self->flags |= FL_DMG_BY_HEAVY_WEAP_ONLY;
+	}
+
+	if (self->health) 
+	{
+		self->takedamage = qtrue;
+	}
+
+	G_SoundIndex("sound/weapons/explosions/cargoexplode.wav");//precaching
+	G_SpawnFloat( "radius", "1", &self->radius ); // used to scale chunk code if desired by a designer
+	G_SpawnInt( "material", "0", (int*)&self->material );
+	CacheChunkEffects( self->material );
+
+	self->e_UseFunc = useF_funcBBrushUse;
+
+	//if ( self->paintarget )
+	{
+		self->e_PainFunc = painF_funcBBrushPain;
+	}
+
+	self->e_TouchFunc = touchF_funcBBrushTouch;
+
+	if ( self->team && self->team[0] )
+	{
+		self->noDamageTeam = (team_t)GetIDForString( TeamTable, self->team );
+		if(self->noDamageTeam == TEAM_FREE)
+		{
+			G_Error("team name %s not recognized\n", self->team);
+		}
+	}
+	self->team = NULL;
+	if (!self->model) {
+		G_Error("func_breakable with NULL model\n");
+	}
+	InitBBrush( self );
+
+	char	buffer[MAX_QPATH];
+	char	*s;
+	if ( G_SpawnString( "noise", "*NOSOUND*", &s ) ) 
+	{
+		Q_strncpyz( buffer, s, sizeof(buffer) );
+		COM_DefaultExtension( buffer, sizeof(buffer), ".wav");
+		self->noise_index = G_SoundIndex(buffer);
+	}
+
+	int forceVisible = 0;
+	G_SpawnInt( "forcevisible", "0", &forceVisible );
+	if ( forceVisible )
+	{//can see these through walls with force sight, so must be broadcast
+		if ( VectorCompare( self->s.origin, vec3_origin ) )
+		{//no origin brush
+			self->svFlags |= SVF_BROADCAST;
+		}
+		self->s.eFlags |= EF_FORCE_VISIBLE;
+	}
+
+	int redCrosshair = 0;
+	G_SpawnInt( "redCrosshair", "0", &redCrosshair );
+	if ( redCrosshair )
+	{//can see these through walls with force sight, so must be broadcast
+		self->flags |= FL_RED_CROSSHAIR;
+	}
+}
+
+
+void misc_model_breakable_pain ( gentity_t *self, gentity_t *inflictor, gentity_t *other, const vec3_t point, int damage, int mod,int hitLoc )
+{
+	if ( self->health > 0 )
+	{
+		// still alive, react to the pain
+		if ( self->paintarget )
+		{
+			G_UseTargets2 (self, self->activator, self->paintarget);
+		}
+
+		// Don't do script if dead
+		G_ActivateBehavior( self, BSET_PAIN );
+	}
+}
+
+void misc_model_breakable_die( gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int meansOfDeath,int dFlags,int hitLoc ) 
+{
+	int		numChunks;
+	float	size = 0, scale;
+	vec3_t	dir, up, dis;
+
+	if (self->e_DieFunc == dieF_NULL)	//i was probably already killed since my die func was removed
+	{
+#ifndef FINAL_BUILD
+		gi.Printf(S_COLOR_YELLOW"Recursive misc_model_breakable_die.  Use targets probably pointing back at self.\n");
+#endif
+		return;	//this happens when you have a cyclic target chain!
+	}
+	//NOTE: Stop any scripts that are currently running (FLUSH)... ?
+	//Turn off animation
+	self->s.frame = self->startFrame = self->endFrame = 0;
+	self->svFlags &= ~SVF_ANIMATING;
+			
+	self->health = 0;
+	//Throw some chunks
+	AngleVectors( self->s.apos.trBase, dir, NULL, NULL );
+	VectorNormalize( dir );
+
+	numChunks = random() * 6 + 20;
+
+	VectorSubtract( self->absmax, self->absmin, dis );
+
+	// This formula really has no logical basis other than the fact that it seemed to be the closest to yielding the results that I wanted.
+	// Volume is length * width * height...then break that volume down based on how many chunks we have
+	scale = sqrt( sqrt( dis[0] * dis[1] * dis[2] )) * 1.75f;
+
+	if ( scale > 48 )
+	{
+		size = 2;
+	}
+	else if ( scale > 24 )
+	{
+		size = 1;
+	}
+
+	scale = scale / numChunks;
+
+	if ( self->radius > 0.0f )
+	{
+		// designer wants to scale number of chunks, helpful because the above scale code is far from perfect
+		//	I do this after the scale calculation because it seems that the chunk size generally seems to be very close, it's just the number of chunks is a bit weak
+		numChunks *= self->radius;
+	}
+
+	VectorAdd( self->absmax, self->absmin, dis );
+	VectorScale( dis, 0.5f, dis );
+
+	CG_Chunks( self->s.number, dis, dir, self->absmin, self->absmax, 300, numChunks, self->material, self->s.modelindex3, scale );
+
+	self->e_PainFunc = painF_NULL;
+	self->e_DieFunc  = dieF_NULL;
+//	self->e_UseFunc  = useF_NULL;
+
+	self->takedamage = qfalse;
+
+	if ( !(self->spawnflags & 4) )
+	{//We don't want to stay solid
+		self->s.solid = 0;
+		self->contents = 0;
+		self->clipmask = 0;
+		if (self!=0)
+		{
+			NAV::WayEdgesNowClear(self);
+		}
+		gi.linkentity(self);
+	}
+
+	VectorSet(up, 0, 0, 1);
+
+	if(self->target)
+	{
+		G_UseTargets(self, attacker);
+	}
+
+	if(inflictor->client)
+	{
+		VectorSubtract( self->currentOrigin, inflictor->currentOrigin, dir );
+		VectorNormalize( dir );
+	}
+	else
+	{
+		VectorCopy(up, dir);
+	}
+
+	if ( !(self->spawnflags & 2048) ) // NO_EXPLOSION
+	{
+		// Ok, we are allowed to explode, so do it now!
+		if(self->splashDamage > 0 && self->splashRadius > 0)
+		{//explode
+			vec3_t org;
+			AddSightEvent( attacker, self->currentOrigin, 256, AEL_DISCOVERED, 100 );
+			AddSoundEvent( attacker, self->currentOrigin, 128, AEL_DISCOVERED, qfalse, qtrue );//FIXME: am I on ground or not?
+			//FIXME: specify type of explosion?  (barrel, electrical, etc.)  Also, maybe just use the explosion effect below since it's
+			//				a bit better?
+			// up the origin a little for the damage check, because several models have their origin on the ground, so they don't alwasy do damage, not the optimal solution...
+			VectorCopy( self->currentOrigin, org );
+			if ( self->mins[2] > -4 )
+			{//origin is going to be below it or very very low in the model
+				//center the origin
+				org[2] = self->currentOrigin[2] + self->mins[2] + (self->maxs[2] - self->mins[2])/2.0f;
+			}
+			G_RadiusDamage( org, self, self->splashDamage, self->splashRadius, self, MOD_UNKNOWN );
+
+			if ( self->model && ( Q_stricmp( "models/map_objects/ships/tie_fighter.md3", self->model ) == 0 ||
+								  Q_stricmp( "models/map_objects/ships/tie_bomber.md3", self->model ) == 0 ) )
+			{//TEMP HACK for Tie Fighters- they're HUGE
+				G_PlayEffect( "explosions/fighter_explosion2", self->currentOrigin );
+				G_Sound( self, G_SoundIndex( "sound/weapons/tie_fighter/TIEexplode.wav" ) );
+				self->s.loopSound = 0;
+			}
+			else
+			{
+				CG_MiscModelExplosion( self->absmin, self->absmax, size, self->material );
+				G_Sound( self, G_SoundIndex("sound/weapons/explosions/cargoexplode.wav") );
+				self->s.loopSound = 0;
+			}
+		}
+		else
+		{//just break
+			AddSightEvent( attacker, self->currentOrigin, 128, AEL_DISCOVERED );
+			AddSoundEvent( attacker, self->currentOrigin, 64, AEL_SUSPICIOUS, qfalse, qtrue );//FIXME: am I on ground or not?
+			// This is the default explosion
+			CG_MiscModelExplosion( self->absmin, self->absmax, size, self->material );
+			G_Sound(self, G_SoundIndex("sound/weapons/explosions/cargoexplode.wav"));
+		}
+	}
+
+	self->e_ThinkFunc = thinkF_NULL;
+	self->nextthink = -1;
+
+	if(self->s.modelindex2 != -1 && !(self->spawnflags & 8))
+	{//FIXME: modelindex doesn't get set to -1 if the damage model doesn't exist
+		self->svFlags |= SVF_BROKEN;
+		self->s.modelindex = self->s.modelindex2;
+		G_ActivateBehavior( self, BSET_DEATH );
+	}
+	else
+	{
+		G_FreeEntity( self );
+	}
+}
+
+void misc_model_throw_at_target4( gentity_t *self, gentity_t *activator )
+{
+	vec3_t	pushDir, kvel;
+	float	knockback = 200;
+	float	mass = self->mass;
+	gentity_t *target = G_Find( NULL, FOFS(targetname), self->target4 );
+	if ( !target )
+	{//nothing to throw ourselves at...
+		return;
+	}
+	VectorSubtract( target->currentOrigin, self->currentOrigin, pushDir );
+	knockback -= VectorNormalize( pushDir );
+	if ( knockback < 100 )
+	{
+		knockback = 100;
+	}
+	VectorCopy( self->currentOrigin, self->s.pos.trBase );
+	self->s.pos.trTime = level.time;								// move a bit on the very first frame
+	if ( self->s.pos.trType != TR_INTERPOLATE )
+	{//don't do this to rolling missiles
+		self->s.pos.trType = TR_GRAVITY;
+	}
+
+	if ( mass < 50 )
+	{//???
+		mass = 50;
+	}
+
+	if ( g_gravity->value > 0 )
+	{
+		VectorScale( pushDir, g_knockback->value * knockback / mass * 0.8, kvel );
+		kvel[2] = pushDir[2] * g_knockback->value * knockback / mass * 1.5;
+	}
+	else
+	{
+		VectorScale( pushDir, g_knockback->value * knockback / mass, kvel );
+	}
+
+	VectorAdd( self->s.pos.trDelta, kvel, self->s.pos.trDelta );
+	if ( g_gravity->value > 0 )
+	{
+		if ( self->s.pos.trDelta[2] < knockback )
+		{
+			self->s.pos.trDelta[2] = knockback;
+		}
+	}
+	//no trDuration?
+	if ( self->e_ThinkFunc != thinkF_G_RunObject )
+	{//objects spin themselves?
+		//spin it
+		//FIXME: messing with roll ruins the rotational center???
+		self->s.apos.trTime = level.time;
+		self->s.apos.trType = TR_LINEAR;
+		VectorClear( self->s.apos.trDelta );
+		self->s.apos.trDelta[1] = Q_irand( -800, 800 );
+	}
+
+	self->forcePushTime = level.time + 600; // let the push effect last for 600 ms
+	if ( activator )
+	{
+		self->forcePuller = activator->s.number;//remember this regardless
+	}
+	else
+	{
+		self->forcePuller = NULL;
+	}
+}
+
+void misc_model_use (gentity_t *self, gentity_t *other, gentity_t *activator)
+{
+	if ( self->target4 )
+	{//throw me at my target!
+		misc_model_throw_at_target4( self, activator );
+		return;
+	}
+
+	if ( self->health <= 0 && self->max_health > 0)
+	{//used while broken fired target3
+		G_UseTargets2( self, activator, self->target3 );
+		return;
+	}
+
+	// Become solid again.
+	if ( !self->count )
+	{
+		self->count = 1;
+		self->activator = activator;
+		self->svFlags &= ~SVF_NOCLIENT;
+		self->s.eFlags &= ~EF_NODRAW;
+	}
+
+	G_ActivateBehavior( self, BSET_USE );
+	//Don't explode if they've requested it to not
+	if ( self->spawnflags & 64 )
+	{//Usemodels toggling
+		if ( self->spawnflags & 32 )
+		{
+			if( self->s.modelindex == self->sound1to2 )
+			{
+				self->s.modelindex = self->sound2to1;
+			}
+			else
+			{
+				self->s.modelindex = self->sound1to2;
+			}
+		}
+
+		return;
+	}
+
+	self->e_DieFunc  = dieF_misc_model_breakable_die;
+	misc_model_breakable_die( self, other, activator, self->health, MOD_UNKNOWN );
+}
+
+#define MDL_OTHER			0
+#define MDL_ARMOR_HEALTH	1
+#define MDL_AMMO			2
+
+void misc_model_breakable_init( gentity_t *ent )
+{
+	int		type;
+
+	type = MDL_OTHER;
+
+	if (!ent->model) {
+		G_Error("no model set on %s at (%.1f %.1f %.1f)\n", ent->classname, ent->s.origin[0],ent->s.origin[1],ent->s.origin[2]);
+	}
+	//Main model
+	ent->s.modelindex = ent->sound2to1 = G_ModelIndex( ent->model );
+
+	if ( ent->spawnflags & 1 )
+	{//Blocks movement
+		ent->contents = CONTENTS_SOLID|CONTENTS_OPAQUE|CONTENTS_BODY|CONTENTS_MONSTERCLIP|CONTENTS_BOTCLIP;//Was CONTENTS_SOLID, but only architecture should be this
+	}
+	else if ( ent->health )
+	{//Can only be shot
+		ent->contents = CONTENTS_SHOTCLIP;
+	}
+
+	if (type == MDL_OTHER)
+	{
+		ent->e_UseFunc = useF_misc_model_use;	
+	}
+	else if ( type == MDL_ARMOR_HEALTH )
+	{
+//		G_SoundIndex("sound/player/suithealth.wav");
+		ent->e_UseFunc = useF_health_use;
+		if (!ent->count)
+		{
+			ent->count = 100;
+		}
+		ent->health = 60;
+	}
+	else if ( type == MDL_AMMO )
+	{
+//		G_SoundIndex("sound/player/suitenergy.wav");
+		ent->e_UseFunc = useF_ammo_use;
+		if (!ent->count)
+		{
+			ent->count = 100;
+		}
+		ent->health = 60;
+	}
+
+	if ( ent->health ) 
+	{
+		G_SoundIndex("sound/weapons/explosions/cargoexplode.wav");
+		ent->max_health = ent->health;
+		ent->takedamage = qtrue;
+		ent->e_PainFunc = painF_misc_model_breakable_pain;
+		ent->e_DieFunc  = dieF_misc_model_breakable_die;
+	}
+}
+
+void TieFighterThink ( gentity_t *self )
+{
+	gentity_t *player = &g_entities[0];
+
+	if ( self->health <= 0 )
+	{
+		return;
+	}
+
+	self->nextthink = level.time + FRAMETIME;
+	if ( player )
+	{
+		vec3_t	playerDir, fighterDir, fwd, rt;
+		float	playerDist, fighterSpeed;
+
+		//use player eyepoint
+		VectorSubtract( player->currentOrigin, self->currentOrigin, playerDir );
+		playerDist = VectorNormalize( playerDir );
+		VectorSubtract( self->currentOrigin, self->lastOrigin, fighterDir );
+		VectorCopy( self->currentOrigin, self->lastOrigin );
+		fighterSpeed = VectorNormalize( fighterDir )*1000;
+		AngleVectors( self->currentAngles, fwd, rt, NULL );
+
+		if ( fighterSpeed ) 
+		{
+			float	side;
+
+			// Magic number fun!  Speed is used for banking, so modulate the speed by a sine wave
+			fighterSpeed *= sin( ( 100 ) * 0.003 );
+
+			// Clamp to prevent harsh rolling
+			if ( fighterSpeed > 10 )
+				fighterSpeed = 10;
+
+			side = fighterSpeed * DotProduct( fighterDir, rt );
+			self->s.apos.trBase[2] -= side;
+		}
+
+		//FIXME: bob up/down, strafe left/right some
+		float dot = DotProduct( playerDir, fighterDir );
+		if ( dot > 0 )
+		{//heading toward the player
+			if ( playerDist < 1024 )
+			{
+				if ( DotProduct( playerDir, fwd ) > 0.7 )
+				{//facing the player
+					if ( self->attackDebounceTime < level.time )
+					{
+						gentity_t	*bolt;
+
+						bolt = G_Spawn();
+						
+						bolt->classname = "tie_proj";
+						bolt->nextthink = level.time + 10000;
+						bolt->e_ThinkFunc = thinkF_G_FreeEntity;
+						bolt->s.eType = ET_MISSILE;
+						bolt->s.weapon = WP_BLASTER;
+						bolt->owner = self;
+						bolt->damage = 30;
+						bolt->dflags = DAMAGE_NO_KNOCKBACK;		// Don't push them around, or else we are constantly re-aiming
+						bolt->splashDamage = 0;
+						bolt->splashRadius = 0;
+						bolt->methodOfDeath = MOD_ENERGY;	// ?
+						bolt->clipmask = MASK_SHOT;
+
+						bolt->s.pos.trType = TR_LINEAR;
+						bolt->s.pos.trTime = level.time;		// move a bit on the very first frame
+						VectorCopy( self->currentOrigin, bolt->s.pos.trBase );
+						VectorScale( fwd, 8000, bolt->s.pos.trDelta );
+						SnapVector( bolt->s.pos.trDelta );		// save net bandwidth
+						VectorCopy( self->currentOrigin, bolt->currentOrigin);
+
+						if ( !Q_irand( 0, 2 ) )
+						{
+							G_SoundOnEnt( bolt, CHAN_VOICE, "sound/weapons/tie_fighter/tie_fire.wav" );
+						}
+						else
+						{
+							G_SoundOnEnt( bolt, CHAN_VOICE, va( "sound/weapons/tie_fighter/tie_fire%d.wav", Q_irand( 2, 3 ) ) );
+						}
+						self->attackDebounceTime = level.time + Q_irand( 300, 2000 );
+					}
+				}
+			}
+		}
+
+		if ( playerDist < 1024 )//512 )
+		{//within range to start our sound
+			if ( dot > 0 )
+			{
+				if ( !self->fly_sound_debounce_time )
+				{//start sound
+					G_SoundOnEnt( self, CHAN_VOICE, va( "sound/weapons/tie_fighter/tiepass%d.wav", Q_irand( 1, 5 ) ) );
+					self->fly_sound_debounce_time = 2000;
+				}
+				else
+				{//sound already started
+					self->fly_sound_debounce_time = -1;
+				}
+			}
+		}
+		else if ( self->fly_sound_debounce_time < level.time )
+		{
+			self->fly_sound_debounce_time = 0;
+		}
+	}
+}
+
+void TieFighterUse( gentity_t *self, gentity_t *other, gentity_t *activator )
+{
+	if ( !self || !other || !activator )
+		return;
+
+	vec3_t	fwd, rt;
+	AngleVectors( self->currentAngles, fwd, rt, NULL );
+
+	gentity_t	*bolt;
+	bolt = G_Spawn();
+
+	bolt->classname = "tie_proj";
+	bolt->nextthink = level.time + 10000;
+	bolt->e_ThinkFunc = thinkF_G_FreeEntity;
+	bolt->s.eType = ET_MISSILE;
+	bolt->s.weapon = WP_TIE_FIGHTER;
+	bolt->owner = self;
+	bolt->damage = 30;
+	bolt->dflags = DAMAGE_NO_KNOCKBACK;		// Don't push them around, or else we are constantly re-aiming
+	bolt->splashDamage = 0;
+	bolt->splashRadius = 0;
+	bolt->methodOfDeath = MOD_ENERGY;	// ?
+	bolt->clipmask = MASK_SHOT;
+
+	bolt->s.pos.trType = TR_LINEAR;
+	bolt->s.pos.trTime = level.time;		// move a bit on the very first frame
+	VectorCopy( self->currentOrigin, bolt->s.pos.trBase );
+	rt[2] += 2.0f;
+	VectorMA( bolt->s.pos.trBase, -15.0, rt, bolt->s.pos.trBase );
+	VectorScale( fwd, 3000, bolt->s.pos.trDelta );
+	SnapVector( bolt->s.pos.trDelta );		// save net bandwidth
+	VectorCopy( self->currentOrigin, bolt->currentOrigin);
+
+	bolt = G_Spawn();
+
+	bolt->classname = "tie_proj";
+	bolt->nextthink = level.time + 10000;
+	bolt->e_ThinkFunc = thinkF_G_FreeEntity;
+	bolt->s.eType = ET_MISSILE;
+	bolt->s.weapon = WP_TIE_FIGHTER;
+	bolt->owner = self;
+	bolt->damage = 30;
+	bolt->dflags = DAMAGE_NO_KNOCKBACK;		// Don't push them around, or else we are constantly re-aiming
+	bolt->splashDamage = 0;
+	bolt->splashRadius = 0;
+	bolt->methodOfDeath = MOD_ENERGY;	// ?
+	bolt->clipmask = MASK_SHOT;
+
+	bolt->s.pos.trType = TR_LINEAR;
+	bolt->s.pos.trTime = level.time;		// move a bit on the very first frame
+	VectorCopy( self->currentOrigin, bolt->s.pos.trBase ); 
+	rt[2] -= 4.0f;
+	VectorMA( bolt->s.pos.trBase, 15.0, rt, bolt->s.pos.trBase );
+	VectorScale( fwd, 3000, bolt->s.pos.trDelta );
+	SnapVector( bolt->s.pos.trDelta );		// save net bandwidth
+	VectorCopy( self->currentOrigin, bolt->currentOrigin);
+}
+
+void TouchTieBomb( gentity_t *self, gentity_t *other, trace_t *trace )
+{
+	// Stop the effect.
+	G_StopEffect( G_EffectIndex( "ships/tiebomber_bomb_falling" ), self->playerModel, gi.G2API_AddBolt( &self->ghoul2[0], "model_root" ), self->s.number );
+
+	self->e_ThinkFunc = thinkF_G_FreeEntity;
+	self->nextthink = level.time + FRAMETIME;
+	G_PlayEffect( G_EffectIndex( "ships/tiebomber_explosion2" ), self->currentOrigin, self->currentAngles );
+	G_RadiusDamage( self->currentOrigin, self, 900, 500, self, MOD_EXPLOSIVE_SPLASH );
+}
+
+#define		MIN_PLAYER_DIST			1600
+
+void TieBomberThink( gentity_t *self )
+{
+	// NOTE: Lerp2Angles will think this thinkfunc if the model is a misc_model_breakable. Watchout
+	// for that in a script (try to just use ROFF's?).
+
+	// Stop thinking, you're dead.
+	if ( self->health <= 0 )
+	{
+		return;
+	}
+
+	// Needed every think...
+	self->nextthink = level.time + FRAMETIME;
+
+	gentity_t *player = &g_entities[0];
+	vec3_t	playerDir;
+	float	playerDist;
+	
+	//use player eyepoint
+	VectorSubtract( player->currentOrigin, self->currentOrigin, playerDir );
+	playerDist = VectorNormalize( playerDir );
+
+	// Time to attack?
+	if ( player->health > 0 && playerDist < MIN_PLAYER_DIST && self->attackDebounceTime < level.time )  
+	{
+		char name1[200] = "models/players/remote/model.glm";
+		gentity_t *bomb = G_CreateObject( self, self->s.pos.trBase, self->s.apos.trBase, 0, 0, TR_GRAVITY, 0 );
+		bomb->s.modelindex = G_ModelIndex( name1 );
+		gi.G2API_InitGhoul2Model( bomb->ghoul2, name1, bomb->s.modelindex);
+		bomb->s.radius = 50;
+		bomb->s.eFlags |= EF_NODRAW;
+
+		// Make the bombs go forward in the bombers direction a little.
+		vec3_t	fwd, rt;
+		AngleVectors( self->currentAngles, fwd, rt, NULL );
+		rt[2] -= 0.5f;
+		VectorMA( bomb->s.pos.trBase, -30.0, rt, bomb->s.pos.trBase );
+		VectorScale( fwd, 300, bomb->s.pos.trDelta );
+		SnapVector( bomb->s.pos.trDelta );		// save net bandwidth
+
+		// Start the effect.
+		G_PlayEffect( G_EffectIndex( "ships/tiebomber_bomb_falling" ), bomb->playerModel, gi.G2API_AddBolt( &bomb->ghoul2[0], "model_root" ), bomb->s.number, bomb->currentOrigin, 1000, qtrue );
+
+		// Set the tie bomb to have a touch function, so when it hits the ground (or whatever), there's a nice 'boom'.
+		bomb->e_TouchFunc = touchF_TouchTieBomb;
+
+		self->attackDebounceTime = level.time + 1000;
+	}
+}
+
+void misc_model_breakable_gravity_init( gentity_t *ent, qboolean dropToFloor )
+{
+	//G_SoundIndex( "sound/movers/objects/objectHurt.wav" );
+	G_EffectIndex( "melee/kick_impact" );
+	G_EffectIndex( "melee/kick_impact_silent" );
+	//G_SoundIndex( "sound/weapons/melee/punch1.mp3" );
+	//G_SoundIndex( "sound/weapons/melee/punch2.mp3" );
+	//G_SoundIndex( "sound/weapons/melee/punch3.mp3" );
+	//G_SoundIndex( "sound/weapons/melee/punch4.mp3" );
+	G_SoundIndex( "sound/movers/objects/objectHit.wav" );
+	G_SoundIndex( "sound/movers/objects/objectHitHeavy.wav" );
+	G_SoundIndex( "sound/movers/objects/objectBreak.wav" );
+	//FIXME: dust impact effect when hits ground?
+	ent->s.eType = ET_GENERAL;
+	ent->s.eFlags |= EF_BOUNCE_HALF;
+	ent->clipmask = MASK_SOLID|CONTENTS_BODY|CONTENTS_MONSTERCLIP|CONTENTS_BOTCLIP;//?
+	if ( !ent->mass )
+	{//not overridden by designer
+		ent->mass = VectorLength( ent->maxs ) + VectorLength( ent->mins );
+	}
+	ent->physicsBounce = ent->mass;
+	//drop to floor
+	trace_t		tr;
+	vec3_t		top, bottom;
+
+	if ( dropToFloor )
+	{
+		VectorCopy( ent->currentOrigin, top );
+		top[2] += 1;
+		VectorCopy( ent->currentOrigin, bottom );
+		bottom[2] = MIN_WORLD_COORD;
+		gi.trace( &tr, top, ent->mins, ent->maxs, bottom, ent->s.number, MASK_NPCSOLID );
+		if ( !tr.allsolid && !tr.startsolid && tr.fraction < 1.0 )
+		{
+			G_SetOrigin( ent, tr.endpos );
+			gi.linkentity( ent );
+		}
+	}
+	else
+	{
+		G_SetOrigin( ent, ent->currentOrigin );
+		gi.linkentity( ent );
+	}
+	//set up for object thinking
+	if ( VectorCompare( ent->s.pos.trDelta, vec3_origin ) )
+	{//not moving
+		ent->s.pos.trType = TR_STATIONARY;
+	}
+	else
+	{
+		ent->s.pos.trType = TR_GRAVITY;
+	}
+	VectorCopy( ent->currentOrigin, ent->s.pos.trBase );
+	VectorClear( ent->s.pos.trDelta );
+	ent->s.pos.trTime = level.time;
+	if ( VectorCompare( ent->s.apos.trDelta, vec3_origin ) )
+	{//not moving
+		ent->s.apos.trType = TR_STATIONARY;
+	}
+	else
+	{
+		ent->s.apos.trType = TR_LINEAR;
+	}
+	VectorCopy( ent->currentAngles, ent->s.apos.trBase );
+	VectorClear( ent->s.apos.trDelta );
+	ent->s.apos.trTime = level.time;
+	ent->nextthink = level.time + FRAMETIME;
+	ent->e_ThinkFunc = thinkF_G_RunObject;
+}
+
+/*QUAKED misc_model_breakable (1 0 0) (-16 -16 -16) (16 16 16) SOLID AUTOANIMATE DEADSOLID NO_DMODEL NO_SMOKE USE_MODEL USE_NOT_BREAK PLAYER_USE NO_EXPLOSION START_OFF
+SOLID - Movement is blocked by it, if not set, can still be broken by explosions and shots if it has health
+AUTOANIMATE - Will cycle it's anim
+DEADSOLID - Stay solid even when destroyed (in case damage model is rather large).
+NO_DMODEL - Makes it NOT display a damage model when destroyed, even if one exists
+USE_MODEL - When used, will toggle to it's usemodel (model + "_u1.md3")... this obviously does nothing if USE_NOT_BREAK is not checked
+USE_NOT_BREAK - Using it, doesn't make it break, still can be destroyed by damage
+PLAYER_USE - Player can use it with the use button
+NO_EXPLOSION - By default, will explode when it dies...this is your override.
+START_OFF - Will start off and will not appear until used.
+
+"model"		arbitrary .md3 file to display
+"modelscale"	"x" uniform scale
+"modelscale_vec" "x y z" scale model in each axis - height, width and length - bbox will scale with it
+"health"	how much health to have - default is zero (not breakable)  If you don't set the SOLID flag, but give it health, it can be shot but will not block NPCs or players from moving
+"targetname" when used, dies and displays damagemodel (model + "_d1.md3"), if any (if not, removes itself)
+"target" What to use when it dies
+"target2" What to use when it's repaired
+"target3" What to use when it's used while it's broken
+"paintarget" target to fire when hit (but not destroyed)
+"count"  the amount of armor/health/ammo given (default 50)
+"radius"  Chunk code tries to pick a good volume of chunks, but you can alter this to scale the number of spawned chunks. (default 1)  (.5) is half as many chunks, (2) is twice as many chunks
+"NPC_targetname" - Only the NPC with this name can damage this
+"forcevisible" - When you turn on force sight (any level), you can see these draw through the entire level...
+"redCrosshair" - crosshair turns red when you look at this
+
+"gravity"	if set to 1, this will be affected by gravity
+"throwtarget" if set (along with gravity), this thing, when used, will throw itself at the entity whose targetname matches this string
+"mass"		if gravity is on, this determines how much damage this thing does when it hits someone.  Default is the size of the object from one corner to the other, that works very well.  Only override if this is an object whose mass should be very high or low for it's size (density)
+
+Damage: default is none
+"splashDamage" - damage to do (will make it explode on death)
+"splashRadius" - radius for above damage
+
+"team" - This cannot take damage from members of this team:
+	"player"
+	"neutral"
+	"enemy"
+
+"material" - default is "8 - MAT_NONE" - choose from this list:
+0 = MAT_METAL		(grey metal)
+1 = MAT_GLASS		
+2 = MAT_ELECTRICAL	(sparks only)
+3 = MAT_ELEC_METAL	(METAL chunks and sparks)
+4 =	MAT_DRK_STONE	(brown stone chunks)
+5 =	MAT_LT_STONE	(tan stone chunks)
+6 =	MAT_GLASS_METAL (glass and METAL chunks)
+7 = MAT_METAL2		(blue/grey metal)
+8 = MAT_NONE		(no chunks-DEFAULT)
+9 = MAT_GREY_STONE	(grey colored stone)
+10 = MAT_METAL3		(METAL and METAL2 chunk combo)
+11 = MAT_CRATE1		(yellow multi-colored crate chunks)
+12 = MAT_GRATE1		(grate chunks--looks horrible right now)
+13 = MAT_ROPE		(for yavin_trial, no chunks, just wispy bits )
+14 = MAT_CRATE2		(red multi-colored crate chunks)
+15 = MAT_WHITE_METAL (white angular chunks for Stu, NS_hideout )
+*/
+void SP_misc_model_breakable( gentity_t *ent ) 
+{
+	char	damageModel[MAX_QPATH];
+	char	chunkModel[MAX_QPATH];
+	char	useModel[MAX_QPATH];
+	int		len;
+	
+	// Chris F. requested default for misc_model_breakable to be NONE...so don't arbitrarily change this.
+	G_SpawnInt( "material", "8", (int*)&ent->material );
+	G_SpawnFloat( "radius", "1", &ent->radius ); // used to scale chunk code if desired by a designer
+	qboolean bHasScale = G_SpawnVector("modelscale_vec", "0 0 0", ent->s.modelScale);
+	if (!bHasScale)
+	{
+		float temp;
+		G_SpawnFloat( "modelscale", "0", &temp);
+		if (temp != 0.0f)
+		{
+			ent->s.modelScale[ 0 ] = ent->s.modelScale[ 1 ] = ent->s.modelScale[ 2 ] = temp;
+			bHasScale = qtrue;
+		}
+	}
+
+	CacheChunkEffects( ent->material );
+	misc_model_breakable_init( ent );
+
+	len = strlen( ent->model ) - 4;
+	assert(ent->model[len]=='.');//we're expecting ".md3"
+	strncpy( damageModel, ent->model, sizeof(damageModel) );
+	damageModel[len] = 0;	//chop extension
+	strncpy( chunkModel, damageModel, sizeof(chunkModel));
+	strncpy( useModel, damageModel, sizeof(useModel));
+	
+	if (ent->takedamage) {
+		//Dead/damaged model
+		if( !(ent->spawnflags & 8) ) {	//no dmodel
+			strcat( damageModel, "_d1.md3" );
+			ent->s.modelindex2 = G_ModelIndex( damageModel );
+		}
+		
+		//Chunk model
+		strcat( chunkModel, "_c1.md3" );
+		ent->s.modelindex3 = G_ModelIndex( chunkModel );
+	}
+
+	//Use model
+	if( ent->spawnflags & 32 ) {	//has umodel
+		strcat( useModel, "_u1.md3" );
+		ent->sound1to2 = G_ModelIndex( useModel );
+	}
+	if ( !ent->mins[0] && !ent->mins[1] && !ent->mins[2] )
+	{
+		VectorSet (ent->mins, -16, -16, -16);
+	}
+	if ( !ent->maxs[0] && !ent->maxs[1] && !ent->maxs[2] )
+	{
+		VectorSet (ent->maxs, 16, 16, 16);
+	}
+
+	// Scale up the tie-bomber bbox a little.
+	if ( ent->model && Q_stricmp( "models/map_objects/ships/tie_bomber.md3", ent->model ) == 0 )
+	{
+		VectorSet (ent->mins, -80, -80, -80);
+		VectorSet (ent->maxs, 80, 80, 80); 
+
+		//ent->s.modelScale[ 0 ] = ent->s.modelScale[ 1 ] = ent->s.modelScale[ 2 ] *= 2.0f;
+		//bHasScale = qtrue;
+	}
+
+	if (bHasScale)
+	{
+		//scale the x axis of the bbox up.
+		ent->maxs[0] *= ent->s.modelScale[0];//*scaleFactor;
+		ent->mins[0] *= ent->s.modelScale[0];//*scaleFactor;
+		
+		//scale the y axis of the bbox up.
+		ent->maxs[1] *= ent->s.modelScale[1];//*scaleFactor;
+		ent->mins[1] *= ent->s.modelScale[1];//*scaleFactor;
+		
+		//scale the z axis of the bbox up and adjust origin accordingly
+		ent->maxs[2] *= ent->s.modelScale[2];
+		float oldMins2 = ent->mins[2];
+		ent->mins[2] *= ent->s.modelScale[2];
+		ent->s.origin[2] += (oldMins2-ent->mins[2]);
+	}
+
+	if ( ent->spawnflags & 2 )
+	{
+		ent->s.eFlags |= EF_ANIM_ALLFAST;
+	}
+
+	G_SetOrigin( ent, ent->s.origin );
+	G_SetAngles( ent, ent->s.angles );
+	gi.linkentity (ent);
+
+	if ( ent->spawnflags & 128 )
+	{//Can be used by the player's BUTTON_USE
+		ent->svFlags |= SVF_PLAYER_USABLE;
+	}
+
+	if ( ent->team && ent->team[0] )
+	{
+		ent->noDamageTeam = (team_t)GetIDForString( TeamTable, ent->team );
+		if ( ent->noDamageTeam == TEAM_FREE )
+		{
+			G_Error("team name %s not recognized\n", ent->team);
+		}
+	}
+	
+	ent->team = NULL;
+
+	//HACK
+	if ( ent->model && Q_stricmp( "models/map_objects/ships/x_wing_nogear.md3", ent->model ) == 0 )
+	{
+		if( ent->splashDamage > 0 && ent->splashRadius > 0 )
+		{
+			ent->s.loopSound = G_SoundIndex( "sound/vehicles/x-wing/loop.wav" );
+			ent->s.eFlags |= EF_LESS_ATTEN;
+		}
+	}
+	else if ( ent->model && Q_stricmp( "models/map_objects/ships/tie_fighter.md3", ent->model ) == 0 )
+	{//run a think
+		G_EffectIndex( "explosions/fighter_explosion2" );
+		G_SoundIndex( "sound/weapons/tie_fighter/tiepass1.wav" );
+/*		G_SoundIndex( "sound/weapons/tie_fighter/tiepass2.wav" );
+		G_SoundIndex( "sound/weapons/tie_fighter/tiepass3.wav" );
+		G_SoundIndex( "sound/weapons/tie_fighter/tiepass4.wav" );
+		G_SoundIndex( "sound/weapons/tie_fighter/tiepass5.wav" );*/
+		G_SoundIndex( "sound/weapons/tie_fighter/tie_fire.wav" );
+/*		G_SoundIndex( "sound/weapons/tie_fighter/tie_fire2.wav" );
+		G_SoundIndex( "sound/weapons/tie_fighter/tie_fire3.wav" );*/
+		G_SoundIndex( "sound/weapons/tie_fighter/TIEexplode.wav" );
+		RegisterItem( FindItemForWeapon( WP_TIE_FIGHTER ));
+
+		ent->s.eFlags |= EF_LESS_ATTEN;
+
+		if( ent->splashDamage > 0 && ent->splashRadius > 0 )
+		{
+			ent->s.loopSound = G_SoundIndex( "sound/vehicles/tie-bomber/loop.wav" );
+			//ent->e_ThinkFunc = thinkF_TieFighterThink;
+			//ent->e_UseFunc = thinkF_TieFighterThink;
+			//ent->nextthink = level.time + FRAMETIME;
+			ent->e_UseFunc = useF_TieFighterUse;
+
+			// Yeah, I could have just made this value changable from the editor, but I
+			// need it immediately!
+			float		light;
+			vec3_t		color;
+			qboolean	lightSet, colorSet;
+
+			// if the "color" or "light" keys are set, setup constantLight
+			lightSet = qtrue;//G_SpawnFloat( "light", "100", &light );
+			light = 255;
+			//colorSet = "1 1 1"//G_SpawnVector( "color", "1 1 1", color );
+			colorSet = qtrue;
+			color[0] = 1;	color[1] = 1;	color[2] = 1;
+			if ( lightSet || colorSet ) 
+			{
+				int		r, g, b, i;
+
+				r = color[0] * 255;
+				if ( r > 255 ) {
+					r = 255;
+				}
+				g = color[1] * 255;
+				if ( g > 255 ) {
+					g = 255;
+				}
+				b = color[2] * 255;
+				if ( b > 255 ) {
+					b = 255;
+				}
+				i = light / 4;
+				if ( i > 255 ) {
+					i = 255;
+				}
+				ent->s.constantLight = r | ( g << 8 ) | ( b << 16 ) | ( i << 24 );
+			}
+		}
+	}
+	else if ( ent->model && Q_stricmp( "models/map_objects/ships/tie_bomber.md3", ent->model ) == 0 )
+	{
+		G_EffectIndex( "ships/tiebomber_bomb_falling" );
+		G_EffectIndex( "ships/tiebomber_explosion2" );
+		G_EffectIndex( "explosions/fighter_explosion2" );
+		G_SoundIndex( "sound/weapons/tie_fighter/TIEexplode.wav" );
+		ent->e_ThinkFunc = thinkF_TieBomberThink;
+		ent->nextthink = level.time + FRAMETIME;
+		ent->attackDebounceTime = level.time + 1000;
+		// We only take damage from a heavy weapon class missiles.
+		ent->flags |= FL_DMG_BY_HEAVY_WEAP_ONLY;
+		ent->s.loopSound = G_SoundIndex( "sound/vehicles/tie-bomber/loop.wav" );
+		ent->s.eFlags |= EF_LESS_ATTEN;
+	}
+
+	float grav = 0;
+	G_SpawnFloat( "gravity", "0", &grav );
+	if ( grav )
+	{//affected by gravity
+		G_SetAngles( ent, ent->s.angles );
+		G_SetOrigin( ent, ent->currentOrigin );
+		G_SpawnString( "throwtarget", NULL, &ent->target4 ); // used to throw itself at something
+		misc_model_breakable_gravity_init( ent, qtrue );
+	}
+
+	// Start off.
+	if ( ent->spawnflags & 4096 )
+	{
+		ent->spawnContents = ent->contents;	// It Navs can temporarly turn it "on"
+		ent->s.solid = 0;
+		ent->contents = 0;
+		ent->clipmask = 0;
+		ent->svFlags |= SVF_NOCLIENT;
+		ent->s.eFlags |= EF_NODRAW;
+		ent->count = 0;
+	}
+
+	int forceVisible = 0;
+	G_SpawnInt( "forcevisible", "0", &forceVisible );
+	if ( forceVisible )
+	{//can see these through walls with force sight, so must be broadcast
+		//ent->svFlags |= SVF_BROADCAST;
+		ent->s.eFlags |= EF_FORCE_VISIBLE;
+	}
+
+	int redCrosshair = 0;
+	G_SpawnInt( "redCrosshair", "0", &redCrosshair );
+	if ( redCrosshair )
+	{//can see these through walls with force sight, so must be broadcast
+		ent->flags |= FL_RED_CROSSHAIR;
+	}
+}
+
+
+//----------------------------------
+//
+// Breaking Glass Technology
+//
+//----------------------------------
+
+// Really naughty cheating.  Put in an EVENT at some point...
+extern void cgi_R_GetBModelVerts(int bmodelIndex, vec3_t *verts, vec3_t normal );	
+extern void CG_DoGlass( vec3_t verts[4], vec3_t normal, vec3_t dmgPt, vec3_t dmgDir, float dmgRadius );
+extern	cgs_t			cgs;
+
+//-----------------------------------------------------
+void funcGlassDie( gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int mod,int dFlags,int hitLoc )
+{
+	vec3_t		verts[4], normal;
+
+	// if a missile is stuck to us, blow it up so we don't look dumb....we could, alternately, just let the missile drop off??
+	for ( int i = 0; i < MAX_GENTITIES; i++ )
+	{
+		if ( g_entities[i].s.groundEntityNum == self->s.number && ( g_entities[i].s.eFlags & EF_MISSILE_STICK ))
+		{
+			G_Damage( &g_entities[i], self, self, NULL, NULL, 99999, 0, MOD_CRUSH ); //?? MOD?
+		}
+	}
+
+	// Really naughty cheating.  Put in an EVENT at some point...
+	cgi_R_GetBModelVerts( cgs.inlineDrawModel[self->s.modelindex], verts, normal );
+	CG_DoGlass( verts, normal, self->pos1, self->pos2, self->splashRadius );
+
+	self->takedamage = qfalse;//stop chain reaction runaway loops
+
+	G_SetEnemy( self, self->enemy );
+
+	//NOTE: MUST do this BEFORE clearing contents, or you may not open the area portal!!!
+	gi.AdjustAreaPortalState( self, qtrue );
+
+	//So chunks don't get stuck inside me
+	self->s.solid = 0;
+	self->contents = 0;
+	self->clipmask = 0;
+	gi.linkentity(self); 
+
+	if ( self->target && attacker != NULL )
+	{
+		G_UseTargets( self, attacker );
+	}
+
+	G_FreeEntity( self );
+}
+
+//-----------------------------------------------------
+void funcGlassUse( gentity_t *self, gentity_t *other, gentity_t *activator )
+{
+	vec3_t temp1, temp2;
+
+	// For now, we just break on use
+	G_ActivateBehavior( self, BSET_USE );
+
+	VectorAdd( self->mins, self->maxs, temp1 );
+	VectorScale( temp1, 0.5f, temp1 );
+
+	VectorAdd( other->mins, other->maxs, temp2 );
+	VectorScale( temp2, 0.5f, temp2 );
+
+	VectorSubtract( temp1, temp2, self->pos2 );
+	VectorCopy( temp1, self->pos1 );
+
+	VectorNormalize( self->pos2 );
+	VectorScale( self->pos2, 390, self->pos2 );
+
+	self->splashRadius = 40; // ?? some random number, maybe it's ok?
+
+	funcGlassDie( self, other, activator, self->health, MOD_UNKNOWN );
+}
+
+//-----------------------------------------------------
+/*QUAKED func_glass (0 .8 .5) ? INVINCIBLE
+When destroyed, fires it's target, breaks into glass chunks and plays glass noise
+For now, instantly breaks on impact
+
+INVINCIBLE - can only be broken by being used
+
+"targetname" entities with matching target will fire it
+"target"	all entities with a matching targetname will be used when this is destroyed
+"health"	default is 1
+*/
+//-----------------------------------------------------
+void SP_func_glass( gentity_t *self ) 
+{
+	if ( !(self->spawnflags & 1 ))
+	{
+		if ( !self->health )
+		{
+			self->health = 1;
+		}
+	}
+
+	if ( self->health ) 
+	{
+		self->takedamage = qtrue;
+	}
+
+	self->e_UseFunc = useF_funcGlassUse;
+	self->e_DieFunc = dieF_funcGlassDie;
+
+	VectorCopy( self->s.origin, self->pos1 );
+	
+	gi.SetBrushModel( self, self->model );
+	self->svFlags |= (SVF_GLASS_BRUSH|SVF_BBRUSH);
+	self->material = MAT_GLASS;
+
+	self->s.eType = ET_MOVER;
+
+	self->s.pos.trType = TR_STATIONARY;
+	VectorCopy( self->pos1, self->s.pos.trBase );
+
+	G_SoundIndex( "sound/effects/glassbreak1.wav" );
+	G_EffectIndex( "misc/glass_impact" );
+
+	gi.linkentity( self );
+}
+
+qboolean G_EntIsBreakable( int entityNum, gentity_t *breaker )
+{//breakable brush/model that can actually be broken
+	if ( entityNum < 0 || entityNum >= ENTITYNUM_WORLD )
+	{
+		return qfalse;
+	}
+
+	gentity_t *ent = &g_entities[entityNum];
+	if ( !ent->takedamage )
+	{
+		return qfalse;
+	}
+
+	if ( ent->NPC_targetname )
+	{//only a specific entity can break this!
+		if ( !breaker
+			|| !breaker->targetname 
+			|| Q_stricmp( ent->NPC_targetname, breaker->targetname ) != 0 )
+		{//I'm not the one who can break it
+			return qfalse;
+		}
+	}
+
+	if ( (ent->svFlags&SVF_GLASS_BRUSH) )
+	{
+		return qtrue;
+	}
+	if ( (ent->svFlags&SVF_BBRUSH) )
+	{
+		return qtrue;
+	}
+	if ( !Q_stricmp( "misc_model_breakable", ent->classname ) )
+	{
+		return qtrue;
+	}
+	if ( !Q_stricmp( "misc_maglock", ent->classname ) )
+	{
+		return qtrue;
+	}
+
+	return qfalse;
+}
diff --git a/code/game/g_camera.cpp b/code/game/g_camera.cpp
new file mode 100644
index 0000000..efea818
--- /dev/null
+++ b/code/game/g_camera.cpp
@@ -0,0 +1,256 @@
+// leave this line at the top for all g_xxxx.cpp files...
+#include "g_headers.h"
+
+
+//g_camera.cpp
+#include "g_local.h"
+//#include "Q3_Interface.h"
+//#include "anims.h"
+//#include "b_local.h"
+#include "..\cgame\cg_camera.h"
+#include "g_functions.h"
+
+/*
+#define MAX_CAMERA_GROUP_SUBJECTS	16
+void misc_camera_focus_think (gentity_t *self)
+{
+	//Check to see if I should stop?
+	gi.linkentity(self);
+	self->nextthink = level.time + FRAMETIME;
+}
+
+void misc_camera_focus_use (gentity_t *self, gentity_t *other, gentity_t *activator)
+{
+	G_ActivateBehavior(self,BSET_USE);
+
+	//First, find everyone in my cameraGroup, if I have one
+
+	//Now find my first path_corner, if I have one
+
+	//Start thinking
+
+	self->e_ThinkFunc = thinkF_misc_camera_focus_think;
+	misc_camera_focus_think(self);
+
+	self->e_clThinkFunc = clThinkF_CG_MiscCameraFocusThink;	// blurgh!...
+	self->s.eType = ET_THINKER;
+
+	self->aimDebounceTime = level.time;
+}
+*/
+/*QUAK-ED misc_camera_focus (0 0 1) (-4 -4 -4) (4 4 4) lerptostart
+
+LERPTOSTART - With interpolate from camera's current angles to this thing's start angle instead of snapping to it, which is the default behavior
+
+The focal point for a camera in a scene
+
+"targetname" - Use it to get it to find it's cameraGroup and start tracking it, also get started on it's path, if any
+
+"cameraGroup" - will find all ents in this group and pick a point in the center of that group.
+
+"speed" angular speed modifier - 100 is normal
+*/
+void SP_misc_camera_focus (gentity_t *self)
+{
+	if(!self->targetname)
+	{
+		gi.Printf(S_COLOR_RED"ERROR: misc_camera_focus with no targetname\n");
+		G_FreeEntity(self);
+		return;
+	}
+
+	/*
+	if(self->speed > 0)
+	{
+		self->moveInfo.aspeed = self->speed;
+	}
+	else
+	{
+		self->moveInfo.aspeed = 100.f;
+	}
+	*/
+	self->speed = 0;
+	self->script_targetname = G_NewString(self->targetname);
+//	self->e_UseFunc = useF_misc_camera_focus_use;
+}
+
+/*
+void misc_camera_track_think (gentity_t *self)
+{
+	vec3_t		vec;
+	float		dist;
+	//Check to see if I should stop?
+
+	gi.linkentity(self);
+
+	if(self->enemy)
+	{//We're already heading to a path_corner
+		VectorSubtract(self->currentOrigin, self->s.origin2, vec);
+		dist = VectorLengthSquared(vec);
+		if(dist < 256)//16 squared
+		{
+			G_UseTargets(self, self);
+			self->target = self->enemy->target;
+			self->enemy = NULL;
+		}
+	}
+	
+	if( !self->enemy)
+	{
+		if( self->target && self->target[0] )
+		{//Find out next path_corner
+			self->enemy = G_Find(NULL, FOFS(targetname), self->target);
+			if(self->enemy)
+			{
+				if(self->enemy->radius < 0)
+				{//Don't bother trying to maintain a radius
+					self->radius = 0;
+					self->moveInfo.speed = self->speed/10.0f;
+				}
+				else if(self->enemy->radius > 0)
+				{
+					self->radius = self->enemy->radius;
+				}
+
+				if(self->enemy->speed < 0)
+				{//go back to our default speed
+					self->moveInfo.speed = self->speed/10.0f;
+				}
+				else if(self->enemy->speed > 0)
+				{
+					self->moveInfo.speed = self->enemy->speed/10.0f;
+				}
+			}
+		}
+		else
+		{//stop thinking if this is the last one
+			self->e_ThinkFunc = thinkF_NULL;
+			self->e_clThinkFunc = clThinkF_NULL;
+			self->s.eType = ET_GENERAL;
+			self->nextthink = -1;
+		}
+	}
+
+	if(self->enemy)
+	{//clThink will lerp this
+		VectorCopy(self->enemy->currentOrigin, self->s.origin2);
+	}
+
+	self->nextthink = level.time + FRAMETIME;
+}
+
+void misc_camera_track_use (gentity_t *self, gentity_t *other, gentity_t *activator)
+{
+
+	G_ActivateBehavior(self,BSET_USE);
+
+	//Start thinking
+
+	self->e_ThinkFunc = thinkF_misc_camera_track_think;
+	misc_camera_track_think(self);
+
+	self->e_clThinkFunc = clThinkF_CG_MiscCameraTrackThink;
+	self->s.eType = ET_THINKER;
+}
+*/
+/*QUAK-ED misc_camera_track (0 0 1) (-4 -4 -4) (4 4 4)
+
+The track for a camera to stay on
+
+"targetname" - Use it to get it started on it's path
+
+"target" - First point on it's path - if misc_camera_focus is on a path, it will pick the point on it's path closest to the above calced point
+use "path_corner"s - path it should stay on- if that path_corner has a speed value, it will use this as it's speed to the next path_corner
+
+"speed" - How quickly to move, 0 by default
+
+"radius" - How far camera should try to stay from it's subject, default is 0 (dist doesn't matter), can pick this up from a path_corner too
+*/
+void SP_misc_camera_track (gentity_t *self)
+{
+	if(!self->targetname || !self->targetname[0])
+	{
+		gi.Printf(S_COLOR_RED"ERROR: misc_camera_track with no targetname\n");
+		G_FreeEntity(self);
+		return;
+	}
+
+	self->script_targetname = G_NewString(self->targetname);
+	//self->moveInfo.speed = self->speed/10;
+
+//	self->e_UseFunc = useF_misc_camera_track_use;
+}
+
+
+//-------------------------------------------------
+//	Bezier camera stuff
+//-------------------------------------------------
+
+void cam_point_link( gentity_t *ent )
+{
+
+}
+
+void cam_ctrl_point_link( gentity_t *ent )
+{	
+/*	gentity_t	*target2 = NULL;
+
+	target2 = G_Find( NULL, FOFS(targetname), ent->target2 );
+
+	if ( !target2 )
+	{
+		// Bah, you fool!  Target2 not found
+		Com_Printf( "cam_point_link: target2 specified but not found: %s\n", ent->target2 );
+		G_FreeEntity( ent );
+		return;
+	}
+
+	// Store the control point here
+	VectorCopy( target2->s.origin, ent->pos1 );
+	
+	//---------------------
+	if ( ent->target )
+	{
+		gentity_t	*target = NULL;
+
+		target = G_Find( NULL, FOFS(targetname), ent->target );
+
+		if ( !target )
+		{
+			// Bah, you fool!  Target not found
+			Com_Printf( "cam_point_link: target specified but not found: %s\n", ent->target );
+			G_FreeEntity( ent );
+			return;
+		}
+
+		ent->nextTrain = target;
+	}
+*/
+}
+
+/*QUAK-ED cam_point (0.25 0 0.5) (-2 -2 -2) (2 2 2)
+Under development -- DONT USE ME!!!!!
+A camera point used to construct a camera bezier path
+
+Every cam_point MUST be targeted (target2) at one and only one control point
+*/
+void SP_cam_point( gentity_t *ent )
+{
+/*	if ( !ent->target2 )
+	{
+		// Bah, you fool!  Target2 not found so we have no idea how to make the curve
+		Com_Printf( "cam_point_link: target2 was required but not found\n" );
+		G_FreeEntity( ent );
+		return;
+
+	}
+
+	// The thing we are targeting may not be spawned in yet so, wait a bit to try and link to it
+	ent->e_ThinkFunc = thinkF_cam_ctrl_point_link;
+	ent->nextthink = level.time + 200;
+
+	// Save our position and link us up!
+	G_SetOrigin( ent, ent->s.origin );
+	gi.linkentity( ent );
+*/
+}
\ No newline at end of file
diff --git a/code/game/g_client.cpp b/code/game/g_client.cpp
new file mode 100644
index 0000000..ae848ac
--- /dev/null
+++ b/code/game/g_client.cpp
@@ -0,0 +1,2416 @@
+// leave this line at the top for all g_xxxx.cpp files...
+#include "g_headers.h"
+
+
+#include "IcarusInterface.h"
+#include "Q3_Interface.h"
+#include "g_local.h"
+#include "g_functions.h"
+#include "anims.h"
+#include "wp_saber.h"
+#include "g_vehicles.h"
+#include "objectives.h"
+
+extern int WP_SaberInitBladeData( gentity_t *ent );
+extern void G_CreateG2AttachedWeaponModel( gentity_t *ent, const char *weaponModel, int boltNum, int weaponNum );
+extern qboolean	CheatsOk( gentity_t *ent );
+extern void Boba_Precache( void );
+
+extern cvar_t	*g_char_model;
+extern cvar_t	*g_char_skin_head;
+extern cvar_t	*g_char_skin_torso;
+extern cvar_t	*g_char_skin_legs;
+extern cvar_t	*g_char_color_red;
+extern cvar_t	*g_char_color_green;
+extern cvar_t	*g_char_color_blue;
+extern cvar_t	*g_saber;
+extern cvar_t	*g_saber2;
+extern cvar_t	*g_saber_color;
+extern cvar_t	*g_saber2_color;
+extern cvar_t	*g_saberDarkSideSaberColor;
+
+// g_client.c -- client functions that don't happen every frame
+
+float DEFAULT_MINS_0 = -16;
+float DEFAULT_MINS_1 = -16;
+float DEFAULT_MAXS_0 = 16;
+float DEFAULT_MAXS_1 = 16;
+float DEFAULT_PLAYER_RADIUS	= sqrt((DEFAULT_MAXS_0*DEFAULT_MAXS_0) + (DEFAULT_MAXS_1*DEFAULT_MAXS_1));
+vec3_t playerMins = {DEFAULT_MINS_0, DEFAULT_MINS_1, DEFAULT_MINS_2};
+vec3_t playerMinsStep = {DEFAULT_MINS_0, DEFAULT_MINS_1, DEFAULT_MINS_2+STEPSIZE};
+vec3_t playerMaxs = {DEFAULT_MAXS_0, DEFAULT_MAXS_1, DEFAULT_MAXS_2};
+
+void SP_misc_teleporter_dest (gentity_t *ent);
+
+/*QUAK-ED info_player_deathmatch (1 0 1) (-16 -16 -24) (16 16 32) KEEP_PREV DROPTOFLOOR x x x STUN_BATON NOWEAPON x
+potential spawning position for deathmatch games.
+Targets will be fired when someone spawns in on them.
+*/
+void SP_info_player_deathmatch(gentity_t *ent) {
+	SP_misc_teleporter_dest (ent);
+	
+	if ( ent->spawnflags & 32 ) // STUN_BATON
+	{
+		RegisterItem( FindItemForWeapon( WP_STUN_BATON ));
+	}
+	else
+	{
+		RegisterItem( FindItemForWeapon( WP_SABER ) );	//these are given in ClientSpawn(), but we register them now before cgame starts
+		saberInfo_t	saber;
+		WP_SaberParseParms( g_saber->string, &saber );//get saber sounds and models cached before client begins
+		if (saber.model) G_ModelIndex( saber.model );
+		if (saber.brokenSaber1) G_ModelIndex( saber.brokenSaber1 );
+		if (saber.brokenSaber2) G_ModelIndex( saber.brokenSaber2 );
+		if (saber.skin) G_SkinIndex( saber.skin );
+		WP_SaberFreeStrings(saber);
+	}
+}
+
+/*QUAKED info_player_start (1 0 0) (-16 -16 -24) (16 16 32) KEEP_PREV DROPTOFLOOR x x x STUN_BATON NOWEAPON x
+KEEP_PREV - keep previous health + armor
+DROPTOFLOOR - Player will start on the first solid structure under it
+STUN_BATON - Gives player the stun baton and bryar pistol, but not the saber, plus any weapons they may have carried over from previous levels.
+
+Targets will be fired when someone spawns in on them.
+equivalant to info_player_deathmatch
+*/
+void SP_info_player_start(gentity_t *ent) {
+	ent->classname = "info_player_deathmatch";
+
+	SP_info_player_deathmatch( ent );
+}
+
+
+
+/*
+=======================================================================
+
+  SelectSpawnPoint
+
+=======================================================================
+*/
+
+/*
+================
+SpotWouldTelefrag
+
+================
+*/
+qboolean SpotWouldTelefrag( gentity_t *spot, team_t checkteam ) 
+{
+	int			i, num;
+	gentity_t	*touch[MAX_GENTITIES], *hit;
+	vec3_t		mins, maxs;
+
+	// If we have a mins, use that instead of the hardcoded bounding box
+	if ( spot->mins && VectorLength( spot->mins ) )
+		VectorAdd( spot->s.origin, spot->mins, mins );
+	else
+		VectorAdd( spot->s.origin, playerMins, mins );
+
+	// If we have a maxs, use that instead of the hardcoded bounding box
+	if ( spot->maxs && VectorLength( spot->maxs ) )
+		VectorAdd( spot->s.origin, spot->maxs, maxs );
+	else
+		VectorAdd( spot->s.origin, playerMaxs, maxs );
+
+	num = gi.EntitiesInBox( mins, maxs, touch, MAX_GENTITIES );
+
+	for (i=0 ; i<num ; i++) 
+	{
+		hit = touch[i];
+		if ( hit != spot && hit->client && hit->client->ps.stats[STAT_HEALTH] > 0 ) 
+		{
+			if ( hit->contents & CONTENTS_BODY )
+			{
+				if( checkteam == TEAM_FREE || hit->client->playerTeam == checkteam )
+				{//checking against teammates only...?
+					return qtrue;
+				}
+			}
+		}
+	}
+
+	return qfalse;
+}
+
+qboolean SpotWouldTelefrag2( gentity_t *mover, vec3_t dest ) 
+{
+	int			i, num;
+	gentity_t	*touch[MAX_GENTITIES], *hit;
+	vec3_t		mins, maxs;
+
+	VectorAdd( dest, mover->mins, mins );
+	VectorAdd( dest, mover->maxs, maxs );
+	num = gi.EntitiesInBox( mins, maxs, touch, MAX_GENTITIES );
+
+	for (i=0 ; i<num ; i++) 
+	{
+		hit = touch[i];
+		if ( hit == mover )
+		{
+			continue;
+		}
+
+		if ( hit->contents & mover->contents )
+		{
+			return qtrue;
+		}
+	}
+
+	return qfalse;
+}
+/*
+================
+SelectNearestDeathmatchSpawnPoint
+
+Find the spot that we DON'T want to use
+================
+*/
+#define	MAX_SPAWN_POINTS	128
+gentity_t *SelectNearestDeathmatchSpawnPoint( vec3_t from, team_t team ) {
+	gentity_t	*spot;
+	float		dist, nearestDist;
+	gentity_t	*nearestSpot;
+
+	nearestDist = (float)WORLD_SIZE*(float)WORLD_SIZE;
+	nearestSpot = NULL;
+	spot = NULL;
+
+	while ((spot = G_Find (spot, FOFS(classname), "info_player_deathmatch")) != NULL) {
+		/*if ( team == TEAM_RED && ( spot->spawnflags & 2 ) ) {
+			continue;
+		}
+		if ( team == TEAM_BLUE && ( spot->spawnflags & 1 ) ) {
+			continue;
+		}*/
+
+		if ( spot->targetname != NULL ) {
+			//this search routine should never find a spot that is targetted
+			continue;
+		}
+		dist = DistanceSquared( spot->s.origin, from );
+		if ( dist < nearestDist ) {
+			nearestDist = dist;
+			nearestSpot = spot;
+		}
+	}
+
+	return nearestSpot;
+}
+
+
+/*
+================
+SelectRandomDeathmatchSpawnPoint
+
+go to a random point that doesn't telefrag
+================
+*/
+#define	MAX_SPAWN_POINTS	128
+gentity_t *SelectRandomDeathmatchSpawnPoint( team_t team ) {
+	gentity_t	*spot;
+	int			count;
+	int			selection;
+	gentity_t	*spots[MAX_SPAWN_POINTS];
+
+	count = 0;
+	spot = NULL;
+
+	while ((spot = G_Find (spot, FOFS(classname), "info_player_deathmatch")) != NULL) {
+		/*if ( team == TEAM_RED && ( spot->spawnflags & 2 ) ) {
+			continue;
+		}
+		if ( team == TEAM_BLUE && ( spot->spawnflags & 1 ) ) {
+			continue;
+		}*/
+
+		if ( spot->targetname != NULL ) {
+			//this search routine should never find a spot that is targetted
+			continue;
+		}
+		if ( SpotWouldTelefrag( spot, TEAM_FREE ) ) {
+			continue;
+		}
+		spots[ count ] = spot;
+		count++;
+	}
+
+	if ( !count ) {	// no spots that won't telefrag
+		spot = G_Find( NULL, FOFS(classname), "info_player_deathmatch");
+		if ( !spot )
+		{
+			return NULL;
+		}
+		if ( spot->targetname != NULL ) 
+		{
+			//this search routine should never find a spot that is targetted
+			return NULL;
+		}
+		else
+		{
+			return spot;
+		}
+	}
+
+	selection = rand() % count;
+	return spots[ selection ];
+}
+
+
+/*
+===========
+SelectSpawnPoint
+
+Chooses a player start, deathmatch start, etc
+============
+*/
+gentity_t *SelectSpawnPoint ( vec3_t avoidPoint, team_t team, vec3_t origin, vec3_t angles ) {
+	gentity_t	*spot;
+	gentity_t	*nearestSpot;
+
+	if ( level.spawntarget != NULL && level.spawntarget[0] )
+	{//we have a spawnpoint specified, try to find it
+		if ( (nearestSpot = spot = G_Find( NULL, FOFS(targetname), level.spawntarget )) == NULL )
+		{//you HAVE to be able to find the desired spot
+			G_Error( "Couldn't find spawntarget %s\n", level.spawntarget );
+			return NULL;
+		}
+	}
+	else 
+	{//not looking for a special startspot
+		nearestSpot = SelectNearestDeathmatchSpawnPoint( avoidPoint, team );
+
+		spot = SelectRandomDeathmatchSpawnPoint ( team );
+		if ( spot == nearestSpot ) {
+			// roll again if it would be real close to point of death
+			spot = SelectRandomDeathmatchSpawnPoint ( team );
+		}
+	}
+
+	// find a single player start spot
+	if (!spot) {
+		G_Error( "Couldn't find a spawn point\n" );
+	}
+
+
+	VectorCopy( spot->s.origin, origin );
+	if ( spot->spawnflags & 2 )
+	{
+		trace_t		tr;
+
+		origin[2] = MIN_WORLD_COORD;
+		gi.trace(&tr, spot->s.origin, playerMins, playerMaxs, origin, ENTITYNUM_NONE, MASK_PLAYERSOLID );
+		if ( tr.fraction < 1.0 && !tr.allsolid && !tr.startsolid )
+		{//found a floor
+			VectorCopy(tr.endpos, origin );
+		}
+		else
+		{//In solid or too far
+			VectorCopy( spot->s.origin, origin );
+		}
+	}
+
+	origin[2] += 9;
+	VectorCopy (spot->s.angles, angles);
+
+	return spot;
+}
+
+
+//======================================================================
+
+
+/*
+==================
+SetClientViewAngle
+
+==================
+*/
+void SetClientViewAngle( gentity_t *ent, vec3_t angle ) {
+	int			i;
+
+	// set the delta angle
+	for (i=0 ; i<3 ; i++) 
+	{
+		ent->client->ps.delta_angles[i] = (ANGLE2SHORT(angle[i]) - ent->client->pers.cmd_angles[i])&0xffff;
+	}
+	VectorCopy( angle, ent->s.angles );
+	VectorCopy (ent->s.angles, ent->client->ps.viewangles);
+}
+
+/*
+================
+respawn
+================
+*/
+void respawn( gentity_t *ent ) {
+
+	if (Q_stricmpn(level.mapname,"_holo",5)) {
+		gi.SendConsoleCommand("load *respawn\n");	// special case
+	}
+	else {//we're on the holodeck
+		int			flags;
+
+		// toggle the teleport bit so the client knows to not lerp
+		flags = ent->client->ps.eFlags;
+		ClientSpawn(ent, eNO/*qfalse*/);	// SavedGameJustLoaded_e
+		ent->client->ps.eFlags = flags ^ EF_TELEPORT_BIT;
+	}
+}
+
+
+/*
+================
+PickTeam
+
+================
+*/
+team_t PickTeam( int ignoreClientNum ) {
+	int		i;
+	int		counts[TEAM_NUM_TEAMS];
+
+	memset( counts, 0, sizeof( counts ) );
+
+	for ( i = 0 ; i < level.maxclients ; i++ ) {
+		if ( i == ignoreClientNum ) {
+			continue;
+		}
+		if ( level.clients[i].pers.connected == CON_DISCONNECTED ) {
+			continue;
+		}
+	}
+
+	return TEAM_FREE;
+}
+
+/*
+===========
+ForceClientSkin
+
+Forces a client's skin (for teamplay)
+===========
+*/
+void ForceClientSkin( gclient_t *client, char *model, const char *skin ) {
+	char *p;
+
+	if ((p = strchr(model, '/')) != NULL) {
+		*p = 0;
+	}
+
+	Q_strcat(model, MAX_QPATH, "/");
+	Q_strcat(model, MAX_QPATH, skin);
+}
+
+/*
+===========
+ClientUserInfoChanged
+
+Called from ClientConnect when the player first connects and
+directly by the server system when the player updates a userinfo variable.
+
+The game can override any of the settings and call gi.SetUserinfo
+if desired.
+============
+*/
+void ClientUserinfoChanged( int clientNum ) {
+	gentity_t *ent;
+	char	*s;
+	char	headModel[MAX_QPATH];
+	char	torsoModel[MAX_QPATH];
+	char	legsModel[MAX_QPATH];
+	char	sound[MAX_QPATH];
+	char	oldname[MAX_STRING_CHARS];
+	gclient_t	*client;
+	char	*sex;
+	char	userinfo[MAX_INFO_STRING];
+
+	ent = g_entities + clientNum;
+	client = ent->client;
+
+	gi.GetUserinfo( clientNum, userinfo, sizeof( userinfo ) );
+
+	// check for malformed or illegal info strings
+	if ( !Info_Validate(userinfo) ) {
+		strcpy (userinfo, "\\name\\badinfo");
+	}
+
+	// set name
+	Q_strncpyz ( oldname, client->pers.netname, sizeof( oldname ) );
+	s = Info_ValueForKey (userinfo, "name");
+	Q_strncpyz( client->pers.netname, s, sizeof(client->pers.netname) );
+
+/*	if ( client->pers.connected == CON_CONNECTED ) {
+		if ( strcmp( oldname, client->pers.netname ) ) {
+			gi.SendServerCommand( -1, "print \"%s renamed to %s\n\"", oldname, client->pers.netname );
+		}
+	}
+*/
+	// set max health
+	client->pers.maxHealth = atoi( Info_ValueForKey( userinfo, "handicap" ) );
+	if ( client->pers.maxHealth < 1 || client->pers.maxHealth > 100 ) {
+		client->pers.maxHealth = 100;
+	}
+	client->ps.stats[STAT_MAX_HEALTH] = client->pers.maxHealth;
+
+	// sounds
+	Q_strncpyz( sound, Info_ValueForKey (userinfo, "snd"), sizeof( sound ) );
+
+
+	// set model
+	//Q_strncpyz( headModel, Info_ValueForKey (userinfo, "headModel"), sizeof( headModel ) );
+	//Q_strncpyz( torsoModel, Info_ValueForKey (userinfo, "torsoModel"), sizeof( torsoModel ) );
+	//Q_strncpyz( legsModel, Info_ValueForKey (userinfo, "legsModel"), sizeof( legsModel ) );
+	headModel[0]=0;
+	torsoModel[0]=0;
+	legsModel[0]=0;
+
+	// sex
+	sex = Info_ValueForKey( userinfo, "sex" );
+	if ( !sex[0] ) {
+		sex = "m";
+	}
+
+	// send over a subset of the userinfo keys so other clients can
+	// print scoreboards, display models, and play custom sounds
+
+	s = va("n\\%s\\t\\%i\\headModel\\%s\\torsoModel\\%s\\legsModel\\%s\\hc\\%i\\snd\\%s",
+		client->pers.netname, client->sess.sessionTeam, headModel, torsoModel, legsModel, 
+		client->pers.maxHealth, sound );
+
+	gi.SetConfigstring( CS_PLAYERS+clientNum, s );
+}
+
+
+/*
+===========
+ClientConnect
+
+Called when a player begins connecting to the server.
+Called again for every map change or tournement restart.
+
+The session information will be valid after exit.
+
+Return NULL if the client should be allowed, otherwise return
+a string with the reason for denial.
+
+Otherwise, the client will be sent the current gamestate
+and will eventually get to ClientBegin.
+
+firstTime will be qtrue the very first time a client connects
+to the server machine, but qfalse on map changes and tournement
+restarts.
+============
+*/
+char *ClientConnect( int clientNum, qboolean firstTime, SavedGameJustLoaded_e eSavedGameJustLoaded ) 
+{
+	gclient_t	*client;
+	char		userinfo[MAX_INFO_STRING];
+	gentity_t	*ent;
+	clientSession_t		savedSess;
+
+	ent = &g_entities[ clientNum ];
+	gi.GetUserinfo( clientNum, userinfo, sizeof( userinfo ) );
+
+
+	// they can connect
+	ent->client = level.clients + clientNum;
+	client = ent->client;
+
+//	if (!qbFromSavedGame)
+	if (eSavedGameJustLoaded != eFULL)
+	{
+		savedSess = client->sess;	// 
+		memset( client, 0, sizeof(*client) );
+		client->sess = savedSess; 
+		if ( firstTime ) {	//not loading full, and directconnect
+			client->playerTeam = TEAM_PLAYER;	//set these now because after an auto_load kyle can see your team for a bit before you really join.
+			client->enemyTeam = TEAM_ENEMY;
+		}
+	}
+
+	client->pers.connected = CON_CONNECTING;
+
+	if (eSavedGameJustLoaded == eFULL)//qbFromSavedGame)
+	{
+		// G_WriteClientSessionData( client ); // forget it, this is DM stuff anyway
+		// get and distribute relevent paramters
+		ClientUserinfoChanged( clientNum );
+	}
+	else
+	{
+		// read or initialize the session data
+		if ( firstTime ) {
+			G_InitSessionData( client, userinfo );
+		}
+		G_ReadSessionData( client );
+
+		// get and distribute relevent paramters
+		ClientUserinfoChanged( clientNum );
+
+		// don't do the "xxx connected" messages if they were caried over from previous level
+		if ( firstTime ) {
+			gi.SendServerCommand( -1, "print \"%s connected\n\"", client->pers.netname);
+		}
+	}
+
+	return NULL;
+}
+
+/*
+===========
+ClientBegin
+
+called when a client has finished connecting, and is ready
+to be placed into the level.  This will happen every level load,
+and on transition between teams, but doesn't happen on respawns
+============
+*/
+void ClientBegin( int clientNum, usercmd_t *cmd, SavedGameJustLoaded_e eSavedGameJustLoaded)		
+//												qboolean qbFromSavedGame 
+{
+	gentity_t	*ent;
+	gclient_t	*client;
+
+	ent = g_entities + clientNum;
+	client = level.clients + clientNum;
+
+	if (eSavedGameJustLoaded == eFULL)//qbFromSavedGame)
+	{
+		client->pers.connected = CON_CONNECTED;
+		ent->client = client;
+		ClientSpawn( ent, eSavedGameJustLoaded );
+	}
+	else
+	{
+		if ( ent->linked ) {
+			gi.unlinkentity( ent );
+		}
+		G_InitGentity( ent, qfalse );
+		ent->e_TouchFunc = touchF_NULL;
+		ent->e_PainFunc  = painF_PlayerPain;//painF_NULL;
+		ent->client = client;
+
+		client->pers.connected = CON_CONNECTED;
+		client->pers.teamState.state = TEAM_BEGIN;
+		_VectorCopy( cmd->angles, client->pers.cmd_angles );
+
+		memset( &client->ps, 0, sizeof( client->ps ) );
+		if( gi.Cvar_VariableIntegerValue( "g_clearstats" ) )
+		{
+			memset( &client->sess.missionStats, 0, sizeof( client->sess.missionStats ) );
+			client->sess.missionStats.totalSecrets = gi.Cvar_VariableIntegerValue("newTotalSecrets");
+		}
+		
+		// locate ent at a spawn point
+		if ( ClientSpawn( ent, eSavedGameJustLoaded) )	// SavedGameJustLoaded_e
+		{
+			// send teleport event
+		}
+		client->ps.inventory[INV_GOODIE_KEY] = 0;
+		client->ps.inventory[INV_SECURITY_KEY] = 0;
+	}
+}
+
+
+
+/*
+============
+Player_CacheFromPrevLevel
+  Description	: just need to grab the weapon items we're going to have when we spawn so they'll be cached
+  Return type	: void 
+  Argument		: void
+============
+*/
+void Player_CacheFromPrevLevel(void)
+{
+	char	s[MAX_STRING_CHARS];
+	
+	gi.Cvar_VariableStringBuffer( sCVARNAME_PLAYERSAVE, s, sizeof(s) );
+	
+	if (s[0])	// actually this would be safe anyway because of the way sscanf() works, but this is clearer
+	{
+		int iDummy, bits, ibits;
+
+		sscanf( s, "%i %i %i %i", 
+			&iDummy,//client->ps.stats[STAT_HEALTH],
+			&iDummy,//client->ps.stats[STAT_ARMOR],
+			&bits,	//client->ps.stats[STAT_WEAPONS]
+			&ibits	//client->ps.stats[STAT_ITEMS]
+			);
+
+		for ( int i = 1 ; i < 16 ; i++ ) 
+		{
+			if ( bits & ( 1 << i ) ) 
+			{
+				RegisterItem( FindItemForWeapon( (weapon_t)i ) );
+			}
+		}
+
+extern gitem_t	*FindItemForInventory( int inv );
+
+		for ( i = 1 ; i < 16 ; i++ ) 
+		{
+			if ( ibits & ( 1 << i ) ) 
+			{
+				RegisterItem( FindItemForInventory( i-1 ));
+			}
+		}
+	}
+}
+
+/*
+============
+Player_RestoreFromPrevLevel
+  Description	: retrieve maptransition data recorded by server when exiting previous level (to carry over weapons/ammo/health/etc)
+  Return type	: void 
+  Argument		: gentity_t *ent
+============
+*/
+void Player_RestoreFromPrevLevel(gentity_t *ent)
+{
+	gclient_t	*client = ent->client;
+	int			i;
+
+	assert(client);
+	if (client)	// though I can't see it not being true...
+	{
+		char	s[MAX_STRING_CHARS];
+		char	saber0Name[MAX_QPATH];
+		char	saber1Name[MAX_QPATH];
+		const char	*var;
+						
+		gi.Cvar_VariableStringBuffer( sCVARNAME_PLAYERSAVE, s, sizeof(s) );
+
+		if (strlen(s))	// actually this would be safe anyway because of the way sscanf() works, but this is clearer
+		{//				|general info				  |-force powers |-saber 1										   |-saber 2										  |-general saber
+			sscanf( s, "%i %i %i %i %i %i %i %f %f %f %i %i %i %i %i %s %i %i %i %i %i %i %i %i %i %i %i %i %i %i %i %i %s %i %i %i %i %i %i %i %i %i %i %i %i %i %i %i %i %i %i %i %i", 
+								&client->ps.stats[STAT_HEALTH],
+								&client->ps.stats[STAT_ARMOR],
+								&client->ps.stats[STAT_WEAPONS],
+								&client->ps.stats[STAT_ITEMS],
+								&client->ps.weapon,
+								&client->ps.weaponstate,
+								&client->ps.batteryCharge,
+								&client->ps.viewangles[0],
+								&client->ps.viewangles[1],
+								&client->ps.viewangles[2],
+								//force power data
+								&client->ps.forcePowersKnown,
+								&client->ps.forcePower,
+								&client->ps.forcePowerMax,
+								&client->ps.forcePowerRegenRate,
+								&client->ps.forcePowerRegenAmount,
+								//saber 1 data
+								&saber0Name,
+								&client->ps.saber[0].blade[0].active,
+								&client->ps.saber[0].blade[1].active,
+								&client->ps.saber[0].blade[2].active,
+								&client->ps.saber[0].blade[3].active,
+								&client->ps.saber[0].blade[4].active,
+								&client->ps.saber[0].blade[5].active,
+								&client->ps.saber[0].blade[6].active,
+								&client->ps.saber[0].blade[7].active,
+								&client->ps.saber[0].blade[0].color,
+								&client->ps.saber[0].blade[1].color,
+								&client->ps.saber[0].blade[2].color,
+								&client->ps.saber[0].blade[3].color,
+								&client->ps.saber[0].blade[4].color,
+								&client->ps.saber[0].blade[5].color,
+								&client->ps.saber[0].blade[6].color,
+								&client->ps.saber[0].blade[7].color,
+								//saber 2 data
+								&saber1Name,
+								&client->ps.saber[1].blade[0].active,
+								&client->ps.saber[1].blade[1].active,
+								&client->ps.saber[1].blade[2].active,
+								&client->ps.saber[1].blade[3].active,
+								&client->ps.saber[1].blade[4].active,
+								&client->ps.saber[1].blade[5].active,
+								&client->ps.saber[1].blade[6].active,
+								&client->ps.saber[1].blade[7].active,
+								&client->ps.saber[1].blade[0].color,
+								&client->ps.saber[1].blade[1].color,
+								&client->ps.saber[1].blade[2].color,
+								&client->ps.saber[1].blade[3].color,
+								&client->ps.saber[1].blade[4].color,
+								&client->ps.saber[1].blade[5].color,
+								&client->ps.saber[1].blade[6].color,
+								&client->ps.saber[1].blade[7].color,
+								//general saber data
+								&client->ps.saberStylesKnown,
+								&client->ps.saberAnimLevel,
+								&client->ps.saberLockEnemy,
+								&client->ps.saberLockTime
+					);
+			ent->health = client->ps.stats[STAT_HEALTH];
+
+			if(ent->client->ps.saber[0].name && gi.bIsFromZone(ent->client->ps.saber[0].name, TAG_G_ALLOC)) {
+				gi.Free(ent->client->ps.saber[0].name);
+			}
+			ent->client->ps.saber[0].name=0;
+
+			if(ent->client->ps.saber[1].name && gi.bIsFromZone(ent->client->ps.saber[1].name, TAG_G_ALLOC) ) {
+				gi.Free(ent->client->ps.saber[1].name);
+			}
+			ent->client->ps.saber[1].name=0;
+			//NOTE: if sscanf can get a "(null)" out of strings that had NULL string pointers plugged into the original string
+			if ( saber0Name[0] && Q_stricmp( "(null)", saber0Name ) != 0 )
+			{
+				ent->client->ps.saber[0].name = G_NewString( saber0Name );
+			}
+			if ( saber1Name[0] && Q_stricmp( "(null)", saber1Name ) != 0 )
+			{//have a second saber
+				ent->client->ps.saber[1].name = G_NewString( saber1Name );
+				ent->client->ps.dualSabers = qtrue;
+			}
+			else
+			{//have only 1 saber
+				ent->client->ps.dualSabers = qfalse;
+			}
+
+// slight issue with ths for the moment in that although it'll correctly restore angles it doesn't take into account
+//	the overall map orientation, so (eg) exiting east to enter south will be out by 90 degrees, best keep spawn angles for now
+//
+//			VectorClear (ent->client->pers.cmd_angles);
+//
+//			SetClientViewAngle( ent, ent->client->ps.viewangles);
+
+			//ammo
+			gi.Cvar_VariableStringBuffer( "playerammo", s, sizeof(s) );
+			i=0;
+			var = strtok( s, " " );
+			while( var != NULL )
+			{
+			  /* While there are tokens in "s" */
+			  client->ps.ammo[i++] = atoi(var);
+			  /* Get next token: */
+			  var = strtok( NULL, " " );
+			}
+			assert (i==AMMO_MAX);
+
+			//inventory
+			gi.Cvar_VariableStringBuffer( "playerinv", s, sizeof(s) );
+			i=0;
+			var = strtok( s, " " );
+			while( var != NULL )
+			{
+			  /* While there are tokens in "s" */
+			  client->ps.inventory[i++] = atoi(var);
+			  /* Get next token: */
+			  var = strtok( NULL, " " );
+			}
+			assert (i==INV_MAX);
+
+
+			// the new JK2 stuff - force powers, etc...
+			//
+			gi.Cvar_VariableStringBuffer( "playerfplvl", s, sizeof(s) );
+			i=0;
+			var = strtok( s, " " );
+			while( var != NULL )
+			{
+			  /* While there are tokens in "s" */
+			  client->ps.forcePowerLevel[i++] = atoi(var);
+			  /* Get next token: */
+			  var = strtok( NULL, " " );
+			}
+			assert (i==NUM_FORCE_POWERS);
+
+			client->ps.forceGripEntityNum = client->ps.forceDrainEntityNum = ENTITYNUM_NONE;
+		}
+	}
+}
+
+/*
+Ghoul2 Insert Start
+*/
+static void G_SetSkin( gentity_t *ent )
+{
+	char	skinName[MAX_QPATH];
+	//ok, lets register the skin name, and then pass that name to the config strings so the client can get it too.
+	if (Q_stricmp( "hoth2", level.mapname ) == 0	//hack, is this the only map?
+		||
+		Q_stricmp( "hoth3", level.mapname ) == 0	// no! ;-)
+		)
+	{
+		Com_sprintf( skinName, sizeof( skinName ), "models/players/%s/|%s|%s|%s", g_char_model->string, g_char_skin_head->string, "torso_g1", "lower_e1" );
+	}
+	else
+	{
+		Com_sprintf( skinName, sizeof( skinName ), "models/players/%s/|%s|%s|%s", g_char_model->string, g_char_skin_head->string, g_char_skin_torso->string, g_char_skin_legs->string );
+	}
+
+	// lets see if it's out there
+	int skin = gi.RE_RegisterSkin( skinName );
+	if ( skin )
+	{//what if this returns 0 because *one* part of a multi-skin didn't load?
+		// put it in the config strings
+		// and set the ghoul2 model to use it
+		gi.G2API_SetSkin( &ent->ghoul2[ent->playerModel], G_SkinIndex( skinName ), skin );
+	}
+	
+	//color tinting
+	if ( g_char_color_red->integer 
+		|| g_char_color_green->integer
+		|| g_char_color_blue->integer )
+	{
+		ent->client->renderInfo.customRGBA[0] = g_char_color_red->integer;
+		ent->client->renderInfo.customRGBA[1] = g_char_color_green->integer;
+		ent->client->renderInfo.customRGBA[2] = g_char_color_blue->integer;
+		ent->client->renderInfo.customRGBA[3] = 255;
+	}
+}
+
+qboolean G_StandardHumanoid( gentity_t *self )
+{
+	if ( !self || !self->ghoul2.size() )
+	{
+		return qfalse;
+	}
+	if ( self->playerModel < 0 || self->playerModel >= self->ghoul2.size() )
+	{
+		return qfalse;
+	}
+	const char	*GLAName = gi.G2API_GetGLAName( &self->ghoul2[self->playerModel] );
+	assert(GLAName);
+	if (GLAName) 
+	{
+		if ( !Q_stricmpn( "models/players/_humanoid", GLAName, 24 ) )///_humanoid", GLAName, 36) )
+		{//only _humanoid skeleton is expected to have these
+			return qtrue;
+		}
+		if ( !Q_stricmp( "models/players/protocol/protocol", GLAName ) )
+		{//protocol droid duplicates many of these
+			return qtrue;
+		}
+		if ( !Q_stricmp( "models/players/assassin_droid/model", GLAName ) )
+		{//assassin_droid duplicates many of these
+			return qtrue;
+		}
+		if ( !Q_stricmp( "models/players/saber_droid/model", GLAName ) )
+		{//saber_droid duplicates many of these
+			return qtrue;
+		}
+		if ( !Q_stricmp( "models/players/hazardtrooper/hazardtrooper", GLAName ) )
+		{//hazardtrooper duplicates many of these
+			return qtrue;
+		}
+		if ( !Q_stricmp( "models/players/rockettrooper/rockettrooper", GLAName ) )
+		{//rockettrooper duplicates many of these
+			return qtrue;
+		}
+		if ( !Q_stricmp( "models/players/wampa/wampa", GLAName ) )
+		{//rockettrooper duplicates many of these
+			return qtrue;
+		}
+	}
+	return qfalse;
+}
+
+qboolean G_ClassHasBadBones( int NPC_class )
+{
+	switch ( NPC_class )
+	{
+	case CLASS_WAMPA:
+	case CLASS_ROCKETTROOPER:
+	case CLASS_SABER_DROID:
+	case CLASS_HAZARD_TROOPER:
+	case CLASS_ASSASSIN_DROID:
+	case CLASS_RANCOR:
+		return qtrue;
+	}
+	return qfalse;
+}
+
+char *AxesNames[] = 
+{
+	"ORIGIN",//ORIGIN, 
+	"POSITIVE_X",//POSITIVE_X,
+	"POSITIVE_Z",//POSITIVE_Z,
+	"POSITIVE_Y",//POSITIVE_Y,
+	"NEGATIVE_X",//NEGATIVE_X,
+	"NEGATIVE_Z",//NEGATIVE_Z,
+	"NEGATIVE_Y"//NEGATIVE_Y
+};
+
+Eorientations testAxes[3]={POSITIVE_X,POSITIVE_Z,POSITIVE_Y};
+int axes_0 = POSITIVE_X;
+int axes_1 = POSITIVE_Z;
+int axes_2 = POSITIVE_Y;
+void G_NextTestAxes( void )
+{
+	static int whichAxes = 0;
+	int axesCount = 0;
+	do
+	{
+		whichAxes++;
+		if ( whichAxes > 216 )
+		{
+			whichAxes = 0;
+			Com_Printf( S_COLOR_RED"WRAPPED\n" );
+			break;
+		}
+		axesCount = 0;
+		axes_0 = 0;
+		axes_1 = 0;
+		axes_2 = 0;
+		for ( axes_0 = 0; axes_0 < 6 && (axesCount<whichAxes); axes_0++ )
+		{
+			axesCount++;
+			for ( axes_1 = 0; axes_1 < 6 && (axesCount<whichAxes); axes_1++ )
+			{
+				axesCount++;
+				for ( axes_2 = 0; axes_2 < 6 && (axesCount<whichAxes); axes_2++ )
+				{
+					axesCount++;
+				}
+			}
+		}
+		testAxes[0] = (Eorientations)((axes_0%6)+1);
+		testAxes[1] = (Eorientations)((axes_1%6)+1);
+		testAxes[2] = (Eorientations)((axes_2%6)+1);
+	} while ( testAxes[1] == testAxes[0] || (testAxes[1]-testAxes[0]) == 3 || (testAxes[0]-testAxes[1]) == 3
+		|| testAxes[2] == testAxes[0] || (testAxes[2]-testAxes[0]) == 3 || (testAxes[0]-testAxes[2]) == 3
+		|| testAxes[2] == testAxes[1] || (testAxes[2]-testAxes[1]) == 3 || (testAxes[1]-testAxes[2]) == 3 );
+
+	Com_Printf( "Up: %s\nRight: %s\nForward: %s\n", AxesNames[testAxes[0]], AxesNames[testAxes[1]], AxesNames[testAxes[2]] );
+	if ( testAxes[0] == POSITIVE_X
+		&& testAxes[1] == POSITIVE_Z
+		&& testAxes[2] == POSITIVE_Y )
+	{
+		Com_Printf( S_COLOR_RED"WRAPPED\n" );
+	}
+}
+
+void G_BoneOrientationsForClass( int NPC_class, char *boneName, Eorientations *oUp, Eorientations *oRt, Eorientations *oFwd )
+{
+	//defaults
+	*oUp = POSITIVE_X;
+	*oRt = NEGATIVE_Y;
+	*oFwd = NEGATIVE_Z;
+	//switch off class
+	switch ( NPC_class )
+	{
+	case CLASS_RANCOR:
+		*oUp = NEGATIVE_X;
+		*oRt = POSITIVE_Y;
+		*oFwd = POSITIVE_Z;
+		//*oUp = testAxes[0];
+		//*oRt = testAxes[1];
+		//*oFwd = testAxes[2];
+		break;
+	case CLASS_ROCKETTROOPER:
+	case CLASS_HAZARD_TROOPER:
+		//Root is:
+		//*oUp = POSITIVE_Z;
+		//*oRt = NEGATIVE_X;
+		//*oFwd = NEGATIVE_Y;
+		if ( Q_stricmp( "pelvis", boneName ) == 0 )
+		{//child of root
+			//in ModView:
+			//*oUp = NEGATIVE_X;
+			//*oRt = NEGATIVE_Z;
+			//*oFwd = NEGATIVE_Y;
+			//actual, when differences with root are accounted for:
+			*oUp = POSITIVE_Z;
+			*oRt = NEGATIVE_X;
+			*oFwd = NEGATIVE_Y;
+		}
+		else
+		{//all the rest are the same, children of root (not pelvis)
+			//in ModView:
+			//*oUp = POSITIVE_X;
+			//*oRt = POSITIVE_Y;
+			//*oFwd = POSITIVE_Z;
+			//actual, when differences with root are accounted for:
+			//*oUp = POSITIVE_Z;
+			//*oRt = NEGATIVE_Y;
+			//*oFwd = NEGATIVE_X;
+			*oUp = NEGATIVE_X;
+			*oRt = POSITIVE_Y;
+			*oFwd = POSITIVE_Z;
+		}
+		break;
+	case CLASS_SABER_DROID:
+		if ( Q_stricmp( "pelvis", boneName ) == 0
+			|| Q_stricmp( "thoracic", boneName ) == 0 )
+		{
+			*oUp = NEGATIVE_X;
+			*oRt = NEGATIVE_Z;
+			*oFwd = NEGATIVE_Y;
+		}
+		else
+		{
+			*oUp = NEGATIVE_X;//POSITIVE_X;
+			*oRt = POSITIVE_Y;
+			*oFwd = POSITIVE_Z;
+		}
+		break;
+	case CLASS_WAMPA:
+		if ( Q_stricmp( "pelvis", boneName ) == 0 )
+		{
+			*oUp = NEGATIVE_X;
+			*oRt = POSITIVE_Y;
+			*oFwd = NEGATIVE_Z;
+		}
+		else
+		{
+			//*oUp = POSITIVE_X;
+			//*oRt = POSITIVE_Y;
+			//*oFwd = POSITIVE_Z;
+			//kinda worked
+			*oUp = NEGATIVE_X;
+			*oRt = POSITIVE_Y;
+			*oFwd = POSITIVE_Z;
+		}
+		break;
+	case CLASS_ASSASSIN_DROID:
+		if ( Q_stricmp( "pelvis", boneName ) == 0
+			|| Q_stricmp( "lower_lumbar", boneName ) == 0
+			|| Q_stricmp( "upper_lumbar", boneName ) == 0 )
+		{//only these 3 bones on them are wrong
+			//*oUp = POSITIVE_X;
+			//*oRt = POSITIVE_Y;
+			//*oFwd = POSITIVE_Z;
+			*oUp = NEGATIVE_X;
+			*oRt = POSITIVE_Y;
+			*oFwd = POSITIVE_Z;
+		}
+		break;
+	}
+}
+
+extern void G_LoadAnimFileSet( gentity_t *ent, const char *modelName );
+qboolean G_SetG2PlayerModelInfo( gentity_t *ent, const char *modelName, const char *customSkin, const char *surfOff, const char *surfOn )
+{
+	if ( ent->playerModel != -1 )
+	{// we found the model ok
+		vec3_t	angles = {0,0,0};
+		const char	*token;
+		const char	*p;
+
+		//Now turn on/off any surfaces
+		if ( surfOff && surfOff[0] )
+		{
+			p = surfOff;
+			while ( 1 ) 
+			{
+				token = COM_ParseExt( &p, qtrue );
+				if ( !token[0] ) 
+				{//reached end of list
+					break;
+				}
+				//turn off this surf
+				gi.G2API_SetSurfaceOnOff( &ent->ghoul2[ent->playerModel], token, 0x00000002/*G2SURFACEFLAG_OFF*/ );
+			}
+		}
+		if ( surfOn && surfOn[0] )
+		{
+			p = surfOn;
+			while ( 1 )
+			{
+				token = COM_ParseExt( &p, qtrue );
+				if ( !token[0] ) 
+				{//reached end of list
+					break;
+				}
+				//turn on this surf
+				gi.G2API_SetSurfaceOnOff( &ent->ghoul2[ent->playerModel], token, 0 );
+			}
+		}
+		if ( ent->client->NPC_class == CLASS_IMPERIAL && ent->message )
+		{//carrying a key, turn on the key sleeve surface (assuming we have one)
+			gi.G2API_SetSurfaceOnOff( &ent->ghoul2[ent->playerModel], "l_arm_key", 0 );
+		}
+
+		G_LoadAnimFileSet( ent, modelName );
+		
+		ent->headBolt = ent->cervicalBolt = ent->torsoBolt = ent->gutBolt = ent->chestBolt = 
+			ent->crotchBolt = ent->elbowLBolt = ent->elbowRBolt = ent->handLBolt = 
+			ent->handRBolt = ent->kneeLBolt = ent->kneeRBolt = ent->footLBolt = 
+			ent->footRBolt = -1;
+		// now turn on the bolt in the hand - this one would be best always turned on.
+		if ( G_StandardHumanoid( ent ) )
+		{//only _humanoid skeleton is expected to have these
+			ent->headBolt = gi.G2API_AddBolt(&ent->ghoul2[ent->playerModel], "*head_eyes");
+			ent->cervicalBolt = gi.G2API_AddBolt(&ent->ghoul2[ent->playerModel], "cervical" );
+			if ( !Q_stricmp("protocol", modelName ) )
+			{//*sigh*, no thoracic bone
+				ent->gutBolt = gi.G2API_AddBolt(&ent->ghoul2[ent->playerModel], "upper_lumbar");
+				ent->chestBolt = ent->gutBolt;
+			}
+			else
+			{
+				ent->chestBolt = gi.G2API_AddBolt(&ent->ghoul2[ent->playerModel], "thoracic");
+				ent->gutBolt = gi.G2API_AddBolt(&ent->ghoul2[ent->playerModel], "upper_lumbar");
+			}
+			ent->torsoBolt = gi.G2API_AddBolt(&ent->ghoul2[ent->playerModel], "lower_lumbar");
+			ent->crotchBolt = gi.G2API_AddBolt(&ent->ghoul2[ent->playerModel], "pelvis");
+			ent->elbowLBolt = gi.G2API_AddBolt(&ent->ghoul2[ent->playerModel], "*l_arm_elbow");
+			ent->elbowRBolt = gi.G2API_AddBolt(&ent->ghoul2[ent->playerModel], "*r_arm_elbow");
+			ent->handLBolt = gi.G2API_AddBolt(&ent->ghoul2[ent->playerModel], "*l_hand");
+			ent->handRBolt = gi.G2API_AddBolt(&ent->ghoul2[ent->playerModel], "*r_hand");
+			ent->kneeLBolt = gi.G2API_AddBolt(&ent->ghoul2[ent->playerModel], "*hips_l_knee");
+			ent->kneeRBolt = gi.G2API_AddBolt(&ent->ghoul2[ent->playerModel], "*hips_r_knee");
+			ent->footLBolt = gi.G2API_AddBolt(&ent->ghoul2[ent->playerModel], "*l_leg_foot");
+			ent->footRBolt = gi.G2API_AddBolt(&ent->ghoul2[ent->playerModel], "*r_leg_foot");
+			if ( ent->client->NPC_class == CLASS_BOBAFETT
+				|| ent->client->NPC_class == CLASS_ROCKETTROOPER )
+			{//get jet bolts
+				ent->genericBolt1 = gi.G2API_AddBolt( &ent->ghoul2[ent->playerModel], "*jet1" );
+				ent->genericBolt2 = gi.G2API_AddBolt( &ent->ghoul2[ent->playerModel], "*jet2" );
+			}
+			if ( ent->client->NPC_class == CLASS_BOBAFETT )
+			{//get the flamethrower bolt
+				ent->genericBolt3 = gi.G2API_AddBolt(&ent->ghoul2[ent->playerModel], "*flamethrower");
+			}
+		}
+		else 
+		{
+			if ( ent->client->NPC_class == CLASS_VEHICLE )
+			{//do vehicles tags
+
+				// Setup the driver tag (where the driver is mounted to).
+				ent->crotchBolt = gi.G2API_AddBolt(&ent->ghoul2[ent->playerModel], "*driver");
+
+				// Setup the droid unit (or other misc tag we're using this for).
+				ent->m_pVehicle->m_iDroidUnitTag = gi.G2API_AddBolt(&ent->ghoul2[ent->playerModel], "*droidunit");
+
+				char strTemp[128];
+
+				// Setup the Exhausts.
+				for ( int i = 0; i < MAX_VEHICLE_EXHAUSTS; i++ )
+				{
+					_snprintf( strTemp, 128, "*exhaust%d", i + 1 );
+					ent->m_pVehicle->m_iExhaustTag[i] = gi.G2API_AddBolt( &ent->ghoul2[ent->playerModel], strTemp );
+				}
+
+				// Setup the Muzzles.
+				for ( int i = 0; i < MAX_VEHICLE_MUZZLES; i++ )
+				{
+					_snprintf( strTemp, 128, "*muzzle%d", i + 1 );
+					ent->m_pVehicle->m_iMuzzleTag[i] = gi.G2API_AddBolt( &ent->ghoul2[ent->playerModel], strTemp );
+				}
+			}
+			else if ( ent->client->NPC_class == CLASS_HOWLER )
+			{
+				ent->genericBolt1 = gi.G2API_AddBolt(&ent->ghoul2[ent->playerModel], "Tongue01" );// tongue base
+				ent->genericBolt2 = gi.G2API_AddBolt(&ent->ghoul2[ent->playerModel], "Tongue08" );// tongue tip
+			}
+			else if ( !Q_stricmp( "gonk", modelName ) || !Q_stricmp( "seeker", modelName ) || !Q_stricmp( "remote", modelName ) 
+						|| !Q_stricmpn( "r2d2", modelName, 4 ) || !Q_stricmpn( "r5d2", modelName, 4 ) )
+			{//TEMP HACK: not a non-humanoid droid
+				ent->headBolt = -1;
+			}
+			else if (!Q_stricmp( "interrogator",modelName))
+			{
+				ent->headBolt = -1;				
+			}
+			else if (!Q_stricmpn( "probe",modelName, 5))
+			{
+				ent->headBolt = gi.G2API_AddBolt(&ent->ghoul2[ent->playerModel], "cranium");		// head pivot point
+				ent->genericBolt1 = gi.G2API_AddBolt(&ent->ghoul2[ent->playerModel], "*flash");		// Gun 1
+			}
+			else if (!Q_stricmp( "sentry",modelName))
+			{
+				ent->headBolt = -1;				
+				ent->genericBolt1 = gi.G2API_AddBolt(&ent->ghoul2[ent->playerModel], "*flash1");		// Gun 1
+				ent->genericBolt2 = gi.G2API_AddBolt(&ent->ghoul2[ent->playerModel], "*flash2");		// Gun 2
+				ent->genericBolt3 = gi.G2API_AddBolt(&ent->ghoul2[ent->playerModel], "*flash03");		// Gun 3
+			}
+			else if (!Q_stricmp( "mark1",modelName))
+			{
+				ent->headBolt = -1;				
+				ent->handRBolt = ent->genericBolt1 = gi.G2API_AddBolt(&ent->ghoul2[ent->playerModel], "*flash1");		// Blaster Gun 1
+				ent->genericBolt2 = gi.G2API_AddBolt(&ent->ghoul2[ent->playerModel], "*flash2");		// Blaster Gun 2
+				ent->genericBolt3 = gi.G2API_AddBolt(&ent->ghoul2[ent->playerModel], "*flash3");		// Blaster Gun 3
+				ent->genericBolt4 = gi.G2API_AddBolt(&ent->ghoul2[ent->playerModel], "*flash4");		// Blaster Gun 4
+				ent->genericBolt5 = gi.G2API_AddBolt(&ent->ghoul2[ent->playerModel], "*flash5");		// Missile Gun 1
+			}
+			else if (!Q_stricmp( "mark2",modelName))
+			{
+				ent->headBolt = -1;				
+				ent->handRBolt = ent->genericBolt1 = gi.G2API_AddBolt(&ent->ghoul2[ent->playerModel], "*flash");		// Blaster Gun 1
+			}
+			else if (!Q_stricmp( "atst",modelName) )//&& (ent->client->playerTeam != TEAM_PLAYER))
+			{
+				ent->headBolt = gi.G2API_AddBolt(&ent->ghoul2[ent->playerModel], "*head");
+
+				ent->handLBolt = gi.G2API_AddBolt(&ent->ghoul2[ent->playerModel], "*flash1");		// Front guns
+				ent->handRBolt = gi.G2API_AddBolt(&ent->ghoul2[ent->playerModel], "*flash2");
+
+				ent->genericBolt1 = gi.G2API_AddBolt(&ent->ghoul2[ent->playerModel], "*flash3");		// Left side gun
+				ent->genericBolt2 = gi.G2API_AddBolt(&ent->ghoul2[ent->playerModel], "*flash4");		// Right side missle launcher
+
+				ent->footLBolt = gi.G2API_AddBolt(&ent->ghoul2[ent->playerModel], "*l_foot");
+				ent->footRBolt = gi.G2API_AddBolt(&ent->ghoul2[ent->playerModel], "*r_foot");
+			}
+			else if ( !Q_stricmp( "minemonster", modelName ))
+			{
+				ent->handRBolt = ent->headBolt = gi.G2API_AddBolt(&ent->ghoul2[ent->playerModel], "*head_f1");
+			}
+			else if ( !Q_stricmp( "rancor", modelName )
+					|| !Q_stricmp( "mutant_rancor", modelName ))
+			{
+				ent->handLBolt = gi.G2API_AddBolt(&ent->ghoul2[ent->playerModel], "*l_hand");
+				ent->handRBolt = gi.G2API_AddBolt(&ent->ghoul2[ent->playerModel], "*r_hand");
+				ent->headBolt = gi.G2API_AddBolt(&ent->ghoul2[ent->playerModel], "*head_eyes");
+				ent->gutBolt = gi.G2API_AddBolt(&ent->ghoul2[ent->playerModel], "*head_mouth");
+			}
+			else if ( !Q_stricmp( "sand_creature", modelName ))
+			{
+				ent->gutBolt = gi.G2API_AddBolt(&ent->ghoul2[ent->playerModel], "*mouth");
+				ent->crotchBolt = gi.G2API_AddBolt(&ent->ghoul2[ent->playerModel], "*ground");
+			}
+			else if ( !Q_stricmp( "wampa", modelName ))
+			{
+				ent->headBolt = gi.G2API_AddBolt(&ent->ghoul2[ent->playerModel], "*head_eyes");
+				ent->cervicalBolt = gi.G2API_AddBolt(&ent->ghoul2[ent->playerModel], "neck_bone" );
+				ent->chestBolt = gi.G2API_AddBolt(&ent->ghoul2[ent->playerModel], "upper_spine");
+				ent->gutBolt = gi.G2API_AddBolt(&ent->ghoul2[ent->playerModel], "mid_spine");
+				ent->torsoBolt = gi.G2API_AddBolt(&ent->ghoul2[ent->playerModel], "lower_spine");
+				ent->crotchBolt = gi.G2API_AddBolt(&ent->ghoul2[ent->playerModel], "rear_bone");
+				ent->elbowLBolt = gi.G2API_AddBolt(&ent->ghoul2[ent->playerModel], "*l_arm_elbow");
+				ent->elbowRBolt = gi.G2API_AddBolt(&ent->ghoul2[ent->playerModel], "*r_arm_elbow");
+				ent->handLBolt = gi.G2API_AddBolt(&ent->ghoul2[ent->playerModel], "*l_hand");
+				ent->handRBolt = gi.G2API_AddBolt(&ent->ghoul2[ent->playerModel], "*r_hand");
+				ent->kneeLBolt = gi.G2API_AddBolt(&ent->ghoul2[ent->playerModel], "*hips_l_knee");
+				ent->kneeRBolt = gi.G2API_AddBolt(&ent->ghoul2[ent->playerModel], "*hips_r_knee");
+				ent->footLBolt = gi.G2API_AddBolt(&ent->ghoul2[ent->playerModel], "*l_leg_foot");
+				ent->footRBolt = gi.G2API_AddBolt(&ent->ghoul2[ent->playerModel], "*r_leg_foot");
+			}
+			else
+			{//TEMP HACK: not a non-humanoid droid
+				ent->handRBolt = gi.G2API_AddBolt(&ent->ghoul2[ent->playerModel], "*weapon");//should be r_hand
+				if ( Q_stricmp( "atst", modelName ) )
+				{//not an ATST
+					ent->headBolt = gi.G2API_AddBolt(&ent->ghoul2[ent->playerModel], "*headg");
+					ent->cervicalBolt = gi.G2API_AddBolt(&ent->ghoul2[ent->playerModel], "cervical" );
+					ent->torsoBolt = gi.G2API_AddBolt(&ent->ghoul2[ent->playerModel], "lower_lumbar");
+					ent->gutBolt = gi.G2API_AddBolt(&ent->ghoul2[ent->playerModel], "upper_lumbar");
+					ent->chestBolt = gi.G2API_AddBolt(&ent->ghoul2[ent->playerModel], "thoracic");
+					ent->crotchBolt = gi.G2API_AddBolt(&ent->ghoul2[ent->playerModel], "pelvis");
+					ent->elbowLBolt = gi.G2API_AddBolt(&ent->ghoul2[ent->playerModel], "*bicep_lg");
+					ent->elbowRBolt = gi.G2API_AddBolt(&ent->ghoul2[ent->playerModel], "*bicep_rg");
+					ent->handLBolt = gi.G2API_AddBolt(&ent->ghoul2[ent->playerModel], "*hand_l");
+					ent->kneeLBolt = gi.G2API_AddBolt(&ent->ghoul2[ent->playerModel], "*thigh_lg");
+					ent->kneeRBolt = gi.G2API_AddBolt(&ent->ghoul2[ent->playerModel], "*thigh_rg");
+					ent->footLBolt = gi.G2API_AddBolt(&ent->ghoul2[ent->playerModel], "*foot_lg");
+					ent->footRBolt = gi.G2API_AddBolt(&ent->ghoul2[ent->playerModel], "*foot_rg");
+				}
+			}
+		}
+
+		ent->faceBone = BONE_INDEX_INVALID;
+		ent->craniumBone = BONE_INDEX_INVALID;
+		ent->cervicalBone = BONE_INDEX_INVALID;
+		ent->thoracicBone = BONE_INDEX_INVALID;
+		ent->upperLumbarBone = BONE_INDEX_INVALID;
+		ent->lowerLumbarBone = BONE_INDEX_INVALID;
+		ent->motionBone = BONE_INDEX_INVALID;
+		ent->hipsBone = BONE_INDEX_INVALID;
+		ent->rootBone = gi.G2API_GetBoneIndex( &ent->ghoul2[ent->playerModel], "model_root", qtrue );
+#ifndef FINAL_BUILD
+		if ( g_developer->integer && ent->rootBone == -1 )
+		{
+			Com_Error(ERR_DROP,"ERROR: model %s has no model_root bone (and hence cannot animate)!!!\n", modelName );
+		}
+#endif
+		ent->footLBone = BONE_INDEX_INVALID;
+		ent->footRBone = BONE_INDEX_INVALID;
+		ent->humerusRBone = gi.G2API_GetBoneIndex( &ent->ghoul2[ent->playerModel], "rhumerus", qtrue );
+
+		// now add overrides on specific joints so the client can set angle overrides on the legs, torso and head
+		if ( ent->client->NPC_class == CLASS_VEHICLE )
+		{//do vehicles tags
+			//vehicleInfo_t *vehicle = ent->m_pVehicle->m_pVehicleInfo;
+		}
+		else if ( ent->client->NPC_class == CLASS_HOWLER )
+		{
+		}
+		else if ( !Q_stricmp( "gonk", modelName ) || !Q_stricmp( "seeker", modelName ) || !Q_stricmp( "remote", modelName ) )
+		{//
+		}		
+		else if (!Q_stricmp( "sentry",modelName))
+		{
+		}
+		else if (!Q_stricmpn( "probe", modelName, 5 ))
+		{
+			ent->craniumBone = gi.G2API_GetBoneIndex( &ent->ghoul2[ent->playerModel], "cranium", qtrue );
+			if (ent->craniumBone>=0)
+			{
+				gi.G2API_SetBoneAnglesIndex( &ent->ghoul2[ent->playerModel], ent->craniumBone, angles, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, NULL ); 
+			}
+			ent->thoracicBone = gi.G2API_GetBoneIndex( &ent->ghoul2[ent->playerModel], "pelvis", qtrue );
+			if (ent->thoracicBone>=0)
+			{
+				gi.G2API_SetBoneAnglesIndex( &ent->ghoul2[ent->playerModel], ent->thoracicBone, angles, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, NULL ); 
+			}
+		}
+		else if (!Q_stricmp( "interrogator", modelName ))
+		{
+			ent->genericBone1 = gi.G2API_GetBoneIndex( &ent->ghoul2[ent->playerModel], "left_arm", qtrue );
+			if (ent->genericBone1>=0)
+			{
+				gi.G2API_SetBoneAnglesIndex( &ent->ghoul2[ent->playerModel], ent->genericBone1, angles, BONE_ANGLES_POSTMULT, NEGATIVE_Y, NEGATIVE_X, NEGATIVE_Z, NULL ); 
+			}
+			ent->genericBone2 = gi.G2API_GetBoneIndex( &ent->ghoul2[ent->playerModel], "right_arm", qtrue );
+			if (ent->genericBone2>=0)
+			{
+				gi.G2API_SetBoneAnglesIndex( &ent->ghoul2[ent->playerModel], ent->genericBone2, angles, BONE_ANGLES_POSTMULT, NEGATIVE_Y, NEGATIVE_X, NEGATIVE_Z, NULL ); 
+			}
+			ent->genericBone3 = gi.G2API_GetBoneIndex( &ent->ghoul2[ent->playerModel], "claw", qtrue );
+			if (ent->genericBone3>=0)
+			{
+				gi.G2API_SetBoneAnglesIndex( &ent->ghoul2[ent->playerModel], ent->genericBone3, angles, BONE_ANGLES_POSTMULT, NEGATIVE_Y, NEGATIVE_X, NEGATIVE_Z, NULL ); 
+			}
+		}
+		else if (!Q_stricmpn( "r2d2", modelName, 4 ))
+		{
+			ent->craniumBone = gi.G2API_GetBoneIndex( &ent->ghoul2[ent->playerModel], "cranium", qtrue );
+			if (ent->craniumBone>=0)
+			{
+				gi.G2API_SetBoneAnglesIndex( &ent->ghoul2[ent->playerModel], ent->craniumBone, angles, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, NULL ); 
+			}
+			ent->thoracicBone = gi.G2API_GetBoneIndex( &ent->ghoul2[ent->playerModel], "body", qtrue );
+			if (ent->thoracicBone>=0)
+			{
+				gi.G2API_SetBoneAnglesIndex( &ent->ghoul2[ent->playerModel], ent->thoracicBone, angles, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, NULL ); 
+			}
+			ent->genericBone1 = gi.G2API_GetBoneIndex( &ent->ghoul2[ent->playerModel], "f_eye", qtrue );
+			if (ent->genericBone1>=0)
+			{
+				gi.G2API_SetBoneAnglesIndex( &ent->ghoul2[ent->playerModel], ent->genericBone1, angles, BONE_ANGLES_POSTMULT, NEGATIVE_Y, NEGATIVE_X, NEGATIVE_Z, NULL ); 
+			}
+		}
+		else if (!Q_stricmpn( "r5d2", modelName, 4 ))
+		{
+			ent->craniumBone = gi.G2API_GetBoneIndex( &ent->ghoul2[ent->playerModel], "cranium", qtrue );
+			if (ent->craniumBone>=0)
+			{
+				gi.G2API_SetBoneAnglesIndex( &ent->ghoul2[ent->playerModel], ent->craniumBone, angles, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, NULL ); 
+			}
+			ent->thoracicBone = gi.G2API_GetBoneIndex( &ent->ghoul2[ent->playerModel], "body", qtrue );
+			if (ent->thoracicBone>=0)
+			{
+				gi.G2API_SetBoneAnglesIndex( &ent->ghoul2[ent->playerModel], ent->thoracicBone, angles, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, NULL ); 
+			}
+		}
+		else if ( !Q_stricmp( "atst", modelName ))
+		{
+			ent->craniumBone = gi.G2API_GetBoneIndex( &ent->ghoul2[ent->playerModel], "cranium", qtrue );
+			if (ent->craniumBone>=0)
+			{
+				gi.G2API_SetBoneAnglesIndex( &ent->ghoul2[ent->playerModel], ent->craniumBone, angles, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, NULL ); 
+			}
+			ent->thoracicBone = gi.G2API_GetBoneIndex( &ent->ghoul2[ent->playerModel], "thoracic", qtrue );
+			if (ent->thoracicBone>=0)
+			{
+				gi.G2API_SetBoneAnglesIndex( &ent->ghoul2[ent->playerModel], ent->thoracicBone, angles, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, NULL ); 
+			}
+			ent->footLBone = gi.G2API_GetBoneIndex( &ent->ghoul2[ent->playerModel], "l_tarsal", qtrue );
+			if (ent->footLBone>=0)
+			{
+				gi.G2API_SetBoneAnglesIndex( &ent->ghoul2[ent->playerModel], ent->footLBone, angles, BONE_ANGLES_POSTMULT, POSITIVE_Z, NEGATIVE_Y, NEGATIVE_X, NULL ); 
+			}
+			ent->footRBone = gi.G2API_GetBoneIndex( &ent->ghoul2[ent->playerModel], "r_tarsal", qtrue );
+			if (ent->footRBone>=0)
+			{
+				gi.G2API_SetBoneAnglesIndex( &ent->ghoul2[ent->playerModel], ent->footRBone, angles, BONE_ANGLES_POSTMULT, POSITIVE_Z, NEGATIVE_Y, NEGATIVE_X, NULL ); 
+			}
+		}
+		else if ( !Q_stricmp( "mark1", modelName ))
+		{
+			ent->craniumBone = gi.G2API_GetBoneIndex( &ent->ghoul2[ent->playerModel], "cranium", qtrue );
+			if (ent->craniumBone>=0)
+			{
+				gi.G2API_SetBoneAnglesIndex( &ent->ghoul2[ent->playerModel], ent->craniumBone, angles, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, NULL ); 
+			}
+			ent->upperLumbarBone = gi.G2API_GetBoneIndex( &ent->ghoul2[ent->playerModel], "cranium", qtrue );
+			if (ent->upperLumbarBone>=0)
+			{
+				gi.G2API_SetBoneAnglesIndex( &ent->ghoul2[ent->playerModel], ent->upperLumbarBone, angles, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, NULL ); 
+			}
+		}
+		else if ( !Q_stricmp( "mark2", modelName ))
+		{
+			ent->craniumBone = gi.G2API_GetBoneIndex( &ent->ghoul2[ent->playerModel], "cranium", qtrue );
+			if (ent->craniumBone>=0)
+			{
+				gi.G2API_SetBoneAnglesIndex( &ent->ghoul2[ent->playerModel], ent->craniumBone, angles, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, NULL ); 
+			}
+			ent->thoracicBone = gi.G2API_GetBoneIndex( &ent->ghoul2[ent->playerModel], "thoracic", qtrue );
+			if (ent->thoracicBone>=0)
+			{
+				gi.G2API_SetBoneAnglesIndex( &ent->ghoul2[ent->playerModel], ent->thoracicBone, angles, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, NULL ); 
+			}
+		}
+		else if ( !Q_stricmp( "minemonster", modelName ))
+		{
+			ent->thoracicBone = gi.G2API_GetBoneIndex( &ent->ghoul2[ent->playerModel], "thoracic1", qtrue );
+			if (ent->thoracicBone>=0)
+			{
+				gi.G2API_SetBoneAnglesIndex( &ent->ghoul2[ent->playerModel], ent->thoracicBone, angles, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, NULL ); 
+			}
+			ent->craniumBone = gi.G2API_GetBoneIndex( &ent->ghoul2[ent->playerModel], "cranium", qtrue );
+			if (ent->craniumBone>=0)
+			{
+				gi.G2API_SetBoneAnglesIndex( &ent->ghoul2[ent->playerModel], ent->craniumBone, angles, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, NULL ); 
+			}
+		}
+		else if ( ent->client->NPC_class == CLASS_RANCOR )
+			/*!Q_stricmp( "rancor", modelName )	|| !Q_stricmp( "mutant_rancor", modelName ) )*/
+		{
+			Eorientations oUp, oRt, oFwd;
+			//regular bones we need
+			ent->lowerLumbarBone = gi.G2API_GetBoneIndex( &ent->ghoul2[ent->playerModel], "lower_spine", qtrue );
+			if (ent->lowerLumbarBone>=0)
+			{
+				G_BoneOrientationsForClass( ent->client->NPC_class, "lower_lumbar", &oUp, &oRt, &oFwd );
+				gi.G2API_SetBoneAnglesIndex( &ent->ghoul2[ent->playerModel], ent->lowerLumbarBone, angles, BONE_ANGLES_POSTMULT, oUp, oRt, oFwd, NULL ); 
+			}
+			ent->upperLumbarBone = gi.G2API_GetBoneIndex( &ent->ghoul2[ent->playerModel], "mid_spine", qtrue );
+			if (ent->upperLumbarBone>=0)
+			{
+				G_BoneOrientationsForClass( ent->client->NPC_class, "upper_lumbar", &oUp, &oRt, &oFwd );
+				gi.G2API_SetBoneAnglesIndex( &ent->ghoul2[ent->playerModel], ent->upperLumbarBone, angles, BONE_ANGLES_POSTMULT, oUp, oRt, oFwd, NULL ); 
+			}
+			ent->thoracicBone = gi.G2API_GetBoneIndex( &ent->ghoul2[ent->playerModel], "upper_spine", qtrue );
+			if (ent->thoracicBone>=0)
+			{
+				G_BoneOrientationsForClass( ent->client->NPC_class, "thoracic", &oUp, &oRt, &oFwd );
+				gi.G2API_SetBoneAnglesIndex( &ent->ghoul2[ent->playerModel], ent->thoracicBone, angles, BONE_ANGLES_POSTMULT, oUp, oRt, oFwd, NULL ); 
+			}
+		}
+		else if ( !Q_stricmp( "sand_creature", modelName ))
+		{
+		}
+		else if ( !Q_stricmp( "wampa", modelName ) )
+		{
+			//Eorientations oUp, oRt, oFwd;
+			//bone needed for turning anims
+			/*
+			//SIGH... fucks him up BAD
+			ent->hipsBone = gi.G2API_GetBoneIndex( &ent->ghoul2[ent->playerModel], "pelvis", qtrue );
+			if (ent->hipsBone>=0)
+			{
+				G_BoneOrientationsForClass( ent->client->NPC_class, "pelvis", &oUp, &oRt, &oFwd );
+				gi.G2API_SetBoneAnglesIndex( &ent->ghoul2[ent->playerModel], ent->hipsBone, angles, BONE_ANGLES_POSTMULT, oUp, oRt, oFwd, NULL ); 
+			}
+			*/
+			/*
+			//SIGH... no anim split
+			ent->lowerLumbarBone = gi.G2API_GetBoneIndex( &ent->ghoul2[ent->playerModel], "lower_lumbar", qtrue );
+			if (ent->lowerLumbarBone>=0)
+			{
+				G_BoneOrientationsForClass( ent->client->NPC_class, "lower_lumbar", &oUp, &oRt, &oFwd );
+				gi.G2API_SetBoneAnglesIndex( &ent->ghoul2[ent->playerModel], ent->lowerLumbarBone, angles, BONE_ANGLES_POSTMULT, oUp, oRt, oFwd, NULL ); 
+			}
+			*/
+			/*
+			//SIGH... spine wiggles fuck all this shit
+			ent->upperLumbarBone = gi.G2API_GetBoneIndex( &ent->ghoul2[ent->playerModel], "upper_lumbar", qtrue );
+			if (ent->upperLumbarBone>=0)
+			{
+				G_BoneOrientationsForClass( ent->client->NPC_class, "upper_lumbar", &oUp, &oRt, &oFwd );
+				gi.G2API_SetBoneAnglesIndex( &ent->ghoul2[ent->playerModel], ent->upperLumbarBone, angles, BONE_ANGLES_POSTMULT, oUp, oRt, oFwd, NULL ); 
+			}
+			ent->thoracicBone = gi.G2API_GetBoneIndex( &ent->ghoul2[ent->playerModel], "thoracic", qtrue );
+			if (ent->thoracicBone>=0)
+			{
+				G_BoneOrientationsForClass( ent->client->NPC_class, "thoracic", &oUp, &oRt, &oFwd );
+				gi.G2API_SetBoneAnglesIndex( &ent->ghoul2[ent->playerModel], ent->thoracicBone, angles, BONE_ANGLES_POSTMULT, oUp, oRt, oFwd, NULL ); 
+			}
+			ent->cervicalBone = gi.G2API_GetBoneIndex( &ent->ghoul2[ent->playerModel], "cervical", qtrue );
+			if (ent->cervicalBone>=0)
+			{
+				G_BoneOrientationsForClass( ent->client->NPC_class, "cervical", &oUp, &oRt, &oFwd );
+				gi.G2API_SetBoneAnglesIndex( &ent->ghoul2[ent->playerModel], ent->cervicalBone, angles, BONE_ANGLES_POSTMULT, oUp, oRt, oFwd, NULL ); 
+			}
+			ent->craniumBone = gi.G2API_GetBoneIndex( &ent->ghoul2[ent->playerModel], "cranium", qtrue );
+			if (ent->craniumBone>=0)
+			{
+				G_BoneOrientationsForClass( ent->client->NPC_class, "cranium", &oUp, &oRt, &oFwd );
+				gi.G2API_SetBoneAnglesIndex( &ent->ghoul2[ent->playerModel], ent->craniumBone, angles, BONE_ANGLES_POSTMULT, oUp, oRt, oFwd, NULL ); 
+			}
+			*/
+		}
+		else if ( !Q_stricmp( "rockettrooper", modelName )
+			|| !Q_stricmp( "hazardtrooper", modelName )
+			|| !Q_stricmp( "saber_droid", modelName )
+			|| !Q_stricmp( "assassin_droid", modelName ) )
+		{
+			Eorientations oUp, oRt, oFwd;
+			if ( Q_stricmp( "saber_droid", modelName ) )
+			{//saber droid doesn't use these lower bones
+				//regular bones we need
+				ent->upperLumbarBone = gi.G2API_GetBoneIndex( &ent->ghoul2[ent->playerModel], "upper_lumbar", qtrue );
+				if (ent->upperLumbarBone>=0)
+				{
+					G_BoneOrientationsForClass( ent->client->NPC_class, "upper_lumbar", &oUp, &oRt, &oFwd );
+					gi.G2API_SetBoneAnglesIndex( &ent->ghoul2[ent->playerModel], ent->upperLumbarBone, angles, BONE_ANGLES_POSTMULT, oUp, oRt, oFwd, NULL ); 
+				}
+				ent->lowerLumbarBone = gi.G2API_GetBoneIndex( &ent->ghoul2[ent->playerModel], "lower_lumbar", qtrue );
+				if (ent->lowerLumbarBone>=0)
+				{
+					G_BoneOrientationsForClass( ent->client->NPC_class, "lower_lumbar", &oUp, &oRt, &oFwd );
+					gi.G2API_SetBoneAnglesIndex( &ent->ghoul2[ent->playerModel], ent->lowerLumbarBone, angles, BONE_ANGLES_POSTMULT, oUp, oRt, oFwd, NULL ); 
+				}
+			}
+			if ( Q_stricmp( "hazardtrooper", modelName ) )
+			{//hazard trooper doesn't have these upper bones
+				if ( Q_stricmp( "saber_droid", modelName ) )
+				{//saber droid doesn't use thoracic bone
+					ent->thoracicBone = gi.G2API_GetBoneIndex( &ent->ghoul2[ent->playerModel], "thoracic", qtrue );
+					if (ent->thoracicBone>=0)
+					{
+						G_BoneOrientationsForClass( ent->client->NPC_class, "thoracic", &oUp, &oRt, &oFwd );
+						gi.G2API_SetBoneAnglesIndex( &ent->ghoul2[ent->playerModel], ent->thoracicBone, angles, BONE_ANGLES_POSTMULT, oUp, oRt, oFwd, NULL ); 
+					}
+				}
+				ent->cervicalBone = gi.G2API_GetBoneIndex( &ent->ghoul2[ent->playerModel], "cervical", qtrue );
+				if (ent->cervicalBone>=0)
+				{
+					G_BoneOrientationsForClass( ent->client->NPC_class, "cervical", &oUp, &oRt, &oFwd );
+					gi.G2API_SetBoneAnglesIndex( &ent->ghoul2[ent->playerModel], ent->cervicalBone, angles, BONE_ANGLES_POSTMULT, oUp, oRt, oFwd, NULL ); 
+				}
+				ent->craniumBone = gi.G2API_GetBoneIndex( &ent->ghoul2[ent->playerModel], "cranium", qtrue );
+				if (ent->craniumBone>=0)
+				{
+					G_BoneOrientationsForClass( ent->client->NPC_class, "cranium", &oUp, &oRt, &oFwd );
+					gi.G2API_SetBoneAnglesIndex( &ent->ghoul2[ent->playerModel], ent->craniumBone, angles, BONE_ANGLES_POSTMULT, oUp, oRt, oFwd, NULL ); 
+				}
+			}
+		}
+		else
+		{
+			//special case motion bone - to match up split anims
+			ent->motionBone = gi.G2API_GetBoneIndex( &ent->ghoul2[ent->playerModel], "Motion", qtrue );
+			if (ent->motionBone>=0)
+			{
+				gi.G2API_SetBoneAnglesIndex( &ent->ghoul2[ent->playerModel], ent->motionBone, angles, BONE_ANGLES_POSTMULT, POSITIVE_Z, NEGATIVE_X, NEGATIVE_Y, NULL ); 
+			}
+			ent->motionBolt = gi.G2API_AddBolt(&ent->ghoul2[ent->playerModel], "Motion");
+			//bone needed for turning anims
+			ent->hipsBone = gi.G2API_GetBoneIndex( &ent->ghoul2[ent->playerModel], "pelvis", qtrue );
+			if (ent->hipsBone>=0)
+			{
+				gi.G2API_SetBoneAnglesIndex( &ent->ghoul2[ent->playerModel], ent->hipsBone, angles, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, NULL ); 
+			}
+			//regular bones we need
+			ent->upperLumbarBone = gi.G2API_GetBoneIndex( &ent->ghoul2[ent->playerModel], "upper_lumbar", qtrue );
+			if (ent->upperLumbarBone>=0)
+			{
+				gi.G2API_SetBoneAnglesIndex( &ent->ghoul2[ent->playerModel], ent->upperLumbarBone, angles, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, NULL ); 
+			}
+			ent->lowerLumbarBone = gi.G2API_GetBoneIndex( &ent->ghoul2[ent->playerModel], "lower_lumbar", qtrue );
+			if (ent->lowerLumbarBone>=0)
+			{
+				gi.G2API_SetBoneAnglesIndex( &ent->ghoul2[ent->playerModel], ent->lowerLumbarBone, angles, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, NULL ); 
+			}
+
+			ent->faceBone = gi.G2API_GetBoneIndex( &ent->ghoul2[ent->playerModel], "face", qtrue );
+			if (ent->faceBone>=0)
+			{
+				gi.G2API_SetBoneAnglesIndex( &ent->ghoul2[ent->playerModel], ent->faceBone, angles, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, NULL ); 
+			}
+			ent->craniumBone = gi.G2API_GetBoneIndex( &ent->ghoul2[ent->playerModel], "cranium", qtrue );
+			if (ent->craniumBone>=0)
+			{
+				gi.G2API_SetBoneAnglesIndex( &ent->ghoul2[ent->playerModel], ent->craniumBone, angles, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, NULL ); 
+			}
+			ent->cervicalBone = gi.G2API_GetBoneIndex( &ent->ghoul2[ent->playerModel], "cervical", qtrue );
+			if (ent->cervicalBone>=0)
+			{
+				gi.G2API_SetBoneAnglesIndex( &ent->ghoul2[ent->playerModel], ent->cervicalBone, angles, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, NULL ); 
+			}
+			ent->thoracicBone = gi.G2API_GetBoneIndex( &ent->ghoul2[ent->playerModel], "thoracic", qtrue );
+			if (ent->thoracicBone>=0)
+			{
+				gi.G2API_SetBoneAnglesIndex( &ent->ghoul2[ent->playerModel], ent->thoracicBone, angles, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, NULL ); 
+			}
+		}
+		ent->client->clientInfo.infoValid = qtrue;
+
+	}
+
+	if ( ent->client->NPC_class == CLASS_SAND_CREATURE )
+	{
+		ent->s.radius = 256;
+	}
+	else if ( ent->client->NPC_class == CLASS_RANCOR )
+	{
+		if ( (ent->spawnflags&1) )
+		{//mutant
+			ent->s.radius = 300;
+		}
+		else
+		{
+			ent->s.radius = 150;
+		}
+	}
+	else if ( ent->s.radius <= 0 )//radius cannot be negative or zero
+	{//set the radius to be the largest axial distance on the entity
+		float	max;
+		max = ent->mins[0];//NOTE: mins is always negative
+		if ( max > ent->mins[1] )
+		{
+			max = ent->mins[1];
+		}
+
+		if ( max > ent->mins[2] )
+		{
+			max = ent->mins[2];
+		}
+
+		max = fabs(max);//convert to positive to compare with maxs
+		if ( max < ent->maxs[0] )
+		{
+			max = ent->maxs[0];
+		}
+
+		if ( max < ent->maxs[1] )
+		{
+			max = ent->maxs[1];
+		}
+
+		if ( max < ent->maxs[2] )
+		{
+			max = ent->maxs[2];
+		}
+
+		ent->s.radius = (int)max;
+
+		if (!ent->s.radius)	// Still no radius?
+		{
+			ent->s.radius = 60;
+		}
+	}
+
+	// set the weaponmodel to -1 so we don't try to remove it in Pmove before we have it built
+	ent->weaponModel[0] = -1;
+
+	if ( ent->playerModel == -1 )
+	{
+		return qfalse;
+	}
+	return qtrue;
+}
+
+void G_SetG2PlayerModel( gentity_t * const ent, const char *modelName, const char *customSkin, const char *surfOff, const char *surfOn )
+{
+	char	skinName[MAX_QPATH];
+
+	//ok, lets register the skin name, and then pass that name to the config strings so the client can get it too.
+	if ( !customSkin )
+	{//use the default
+		Com_sprintf( skinName, sizeof( skinName ), "models/players/%s/model_default.skin", modelName );
+	}
+	else
+	{
+		if (strchr(customSkin, '|'))
+		{//three part skin
+			Com_sprintf( skinName, sizeof( skinName ), "models/players/%s/|%s", modelName, customSkin );
+		}
+		else
+		{
+			Com_sprintf( skinName, sizeof( skinName ), "models/players/%s/model_%s.skin", modelName, customSkin );
+		}
+	}
+	int skin = gi.RE_RegisterSkin( skinName );
+	assert(skin);
+	//now generate the ghoul2 model this client should be.
+	if ( ent->client->NPC_class == CLASS_VEHICLE )
+	{//vehicles actually grab their model from the appropriate vehicle data entry
+		
+		// This will register the model and other assets.
+		Vehicle_t *pVeh = ent->m_pVehicle;
+		pVeh->m_pVehicleInfo->RegisterAssets( pVeh );
+		ent->playerModel = gi.G2API_InitGhoul2Model( ent->ghoul2, va("models/players/%s/model.glm", modelName), pVeh->m_pVehicleInfo->modelIndex, G_SkinIndex( skinName ) );
+	}
+	else
+	{
+		//NOTE: it still loads the default skin's tga's because they're referenced in the .glm.
+		ent->playerModel = gi.G2API_InitGhoul2Model( ent->ghoul2, va("models/players/%s/model.glm", modelName), G_ModelIndex( va("models/players/%s/model.glm", modelName) ), G_SkinIndex( skinName ) );
+	}
+	if (ent->playerModel == -1)
+	{//try the stormtrooper as a default
+		gi.Printf( S_COLOR_RED"G_SetG2PlayerModel: cannot load model %s\n", modelName );
+		modelName = "stormtrooper";
+		Com_sprintf( skinName, sizeof( skinName ), "models/players/%s/model_default.skin", modelName );
+		skin = gi.RE_RegisterSkin( skinName );
+		assert(skin);
+		ent->playerModel = gi.G2API_InitGhoul2Model( ent->ghoul2, va("models/players/%s/model.glm", modelName), G_ModelIndex( va("models/players/%s/model.glm", modelName) ) );
+	}
+	if (ent->playerModel == -1)
+	{//very bad thing here!
+		Com_Error(ERR_DROP, "Cannot fall back to default model %s!", modelName);
+	}
+
+	gi.G2API_SetSkin( &ent->ghoul2[ent->playerModel], G_SkinIndex( skinName ), skin );//this is going to set the surfs on/off matching the skin file
+
+	// did we find a ghoul2 model? if so, load the animation.cfg file
+	if ( !G_SetG2PlayerModelInfo( ent, modelName, customSkin, surfOff, surfOn ) )
+	{//couldn't set g2 info, fall back to a mouse md3
+		NPC_ParseParms( "mouse", ent );
+		Com_Printf( S_COLOR_RED"couldn't load playerModel %s!\n", va("models/players/%s/model.glm", modelName) );
+	}
+}
+/*
+Ghoul2 Insert End
+*/
+
+void G_RemovePlayerModel( gentity_t *ent )
+{
+	if ( ent->playerModel >= 0 && ent->ghoul2.size() )
+	{
+		gi.G2API_RemoveGhoul2Model( ent->ghoul2, ent->playerModel );
+		ent->playerModel = -1;
+	}
+}
+
+void G_RemoveWeaponModels( gentity_t *ent )
+{
+	if ( ent->ghoul2.size() )
+	{
+		if ( ent->weaponModel[0] > 0 )
+		{
+			gi.G2API_RemoveGhoul2Model( ent->ghoul2, ent->weaponModel[0] );
+			ent->weaponModel[0] = -1;
+		}
+		if ( ent->weaponModel[1] > 0 )
+		{
+			gi.G2API_RemoveGhoul2Model( ent->ghoul2, ent->weaponModel[1] );
+			ent->weaponModel[1] = -1;
+		}
+	}
+}
+
+void G_AddWeaponModels( gentity_t *ent )
+{
+	if ( !ent || !ent->client )
+	{
+		return;
+	}
+	if ( ent->weaponModel[0] == -1 )
+	{
+		if ( ent->client->ps.weapon == WP_SABER )
+		{
+			WP_SaberAddG2SaberModels( ent );
+		}
+		else if ( ent->client->ps.weapon != WP_NONE )
+		{
+			G_CreateG2AttachedWeaponModel( ent, weaponData[ent->client->ps.weapon].weaponMdl, ent->handRBolt, 0 );
+		}
+	}
+}
+
+extern saber_colors_t TranslateSaberColor( const char *name );
+extern void WP_RemoveSaber( gentity_t *ent, int saberNum );
+void G_ChangePlayerModel( gentity_t *ent, const char *newModel );
+void G_SetSabersFromCVars( gentity_t *ent )
+{
+	if ( g_saber->string
+		&& g_saber->string[0]
+		&& Q_stricmp( "none", g_saber->string )
+		&& Q_stricmp( "NULL", g_saber->string ) )
+	{//FIXME: how to specify second saber?
+		WP_SaberParseParms( g_saber->string, &ent->client->ps.saber[0] );
+		if ( ent->client->ps.saber[0].style )
+		{
+			ent->client->ps.saberStylesKnown |= (1<<ent->client->ps.saber[0].style);
+		}
+	}
+
+	if ( player 
+		&& player->client 
+		&& player->client->sess.mission_objectives[LIGHTSIDE_OBJ].status == 2 
+		&& g_saberDarkSideSaberColor->integer )
+	{//dark side!
+		//always use red
+		for ( int n = 0; n < MAX_BLADES; n++ )
+		{
+			ent->client->ps.saber[0].blade[n].color = SABER_RED;
+		}
+	}
+	else if ( g_saber_color->string )
+	{//FIXME: how to specify color for each blade and/or color for second saber?
+		saber_colors_t color = TranslateSaberColor( g_saber_color->string );
+		for ( int n = 0; n < MAX_BLADES; n++ )
+		{
+			ent->client->ps.saber[0].blade[n].color = color;
+		}
+	}
+	if ( g_saber2->string 
+		&& g_saber2->string[0]
+		&& Q_stricmp( "none", g_saber2->string )
+		&& Q_stricmp( "NULL", g_saber2->string ) )
+	{
+		if ( !ent->client->ps.saber[0].twoHanded )
+		{//can't use a second saber if first one is a two-handed saber...?
+			WP_SaberParseParms( g_saber2->string, &ent->client->ps.saber[1] );
+			if ( ent->client->ps.saber[1].style )
+			{
+				ent->client->ps.saberStylesKnown |= (1<<ent->client->ps.saber[1].style);
+			}
+			if ( ent->client->ps.saber[1].twoHanded )
+			{//tsk tsk, can't use a twoHanded saber as second saber
+				WP_RemoveSaber( ent, 1 );
+			}
+			else
+			{
+				ent->client->ps.dualSabers = qtrue;
+				if ( player 
+					&& player->client 
+					&& player->client->sess.mission_objectives[LIGHTSIDE_OBJ].status == 2 
+					&& g_saberDarkSideSaberColor->integer )
+				{//dark side!
+					//always use red
+					for ( int n = 0; n < MAX_BLADES; n++ )
+					{
+						ent->client->ps.saber[1].blade[n].color = SABER_RED;
+					}
+				}
+				else if ( g_saber2_color->string )
+				{//FIXME: how to specify color for each blade and/or color for second saber?
+					saber_colors_t color = TranslateSaberColor( g_saber2_color->string );
+					for ( int n = 0; n < MAX_BLADES; n++ )
+					{
+						ent->client->ps.saber[1].blade[n].color = color;
+					}
+				}
+			}
+		}
+	}
+}
+
+void G_InitPlayerFromCvars( gentity_t *ent )
+{
+	//set model based on cvars
+	G_ChangePlayerModel( ent, va("%s|%s|%s|%s", g_char_model->string, g_char_skin_head->string, g_char_skin_torso->string, g_char_skin_legs->string) );
+
+	//FIXME: parse these 2 from some cvar or require playermodel to be in a *.npc?
+	if( ent->NPC_type && gi.bIsFromZone(ent->NPC_type, TAG_G_ALLOC) ) {
+		gi.Free(ent->NPC_type);
+	}
+	ent->NPC_type = "player";//default for now
+	if( ent->client->clientInfo.customBasicSoundDir && gi.bIsFromZone(ent->client->clientInfo.customBasicSoundDir, TAG_G_ALLOC) ) {
+		gi.Free(ent->client->clientInfo.customBasicSoundDir);
+	}
+
+	char snd[512];
+	gi.Cvar_VariableStringBuffer( "snd", snd, sizeof(snd) );
+
+	ent->client->clientInfo.customBasicSoundDir = G_NewString(snd);	//copy current cvar
+
+	//set the lightsaber
+	G_RemoveWeaponModels( ent );
+	G_SetSabersFromCVars( ent );
+	//set up weapon models, etc.
+	G_AddWeaponModels( ent );
+	NPC_SetAnim( ent, SETANIM_LEGS, ent->client->ps.legsAnim, SETANIM_FLAG_NORMAL|SETANIM_FLAG_RESTART );
+	NPC_SetAnim( ent, SETANIM_TORSO, ent->client->ps.torsoAnim, SETANIM_FLAG_NORMAL|SETANIM_FLAG_RESTART );
+	if ( !ent->s.number )
+	{//the actual player, not an NPC pretending to be a player
+		ClientUserinfoChanged( ent->s.number );
+	}
+	//color tinting
+	//FIXME: the customRGBA shouldn't be set if the shader this guys .skin is using doesn't have the tinting on it
+	if ( g_char_color_red->integer 
+		|| g_char_color_green->integer
+		|| g_char_color_blue->integer )
+	{
+		ent->client->renderInfo.customRGBA[0] = g_char_color_red->integer;
+		ent->client->renderInfo.customRGBA[1] = g_char_color_green->integer;
+		ent->client->renderInfo.customRGBA[2] = g_char_color_blue->integer;
+		ent->client->renderInfo.customRGBA[3] = 255;
+	}
+}
+
+void G_ChangePlayerModel( gentity_t *ent, const char *newModel )
+{
+	if ( !ent || !ent->client || !newModel )
+	{
+		return;
+	}
+	
+	G_RemovePlayerModel( ent );
+	if ( Q_stricmp( "player", newModel ) == 0 )
+	{
+		G_InitPlayerFromCvars( ent );
+		return;
+	}
+
+	//attempt to free the string (currently can't since it's always "player" )
+	if( ent->NPC_type && gi.bIsFromZone(ent->NPC_type, TAG_G_ALLOC) ) {
+		gi.Free(ent->NPC_type);
+	}
+	ent->NPC_type = G_NewString( newModel );
+	G_RemoveWeaponModels( ent );
+
+	if ( strchr(newModel,'|') )
+	{
+		char name[MAX_QPATH];
+		strcpy(name, newModel);
+		char *p = strchr(name, '|');
+		*p=0;
+		p++;
+
+		G_SetG2PlayerModel( ent, name, p, NULL, NULL );
+	}
+	else
+	{
+		//FIXME: everything but force powers gets reset, those should, too... 
+		//		currently leaves them as is except where otherwise noted in the NPCs.cfg?
+		//FIXME: remove all weapons?
+		if ( NPC_ParseParms( ent->NPC_type, ent ) )
+		{
+			G_AddWeaponModels( ent );
+			NPC_SetAnim( ent, SETANIM_LEGS, ent->client->ps.legsAnim, SETANIM_FLAG_NORMAL|SETANIM_FLAG_RESTART );
+			NPC_SetAnim( ent, SETANIM_TORSO, ent->client->ps.torsoAnim, SETANIM_FLAG_NORMAL|SETANIM_FLAG_RESTART );
+			ClientUserinfoChanged( ent->s.number );
+			//Ugh, kind of a hack for now:
+			if ( ent->client->NPC_class == CLASS_BOBAFETT 
+				|| ent->client->NPC_class == CLASS_ROCKETTROOPER )
+			{
+				//FIXME: remove saber, too?
+				Boba_Precache();	// player as boba?
+			}
+		}
+		else
+		{
+			gi.Printf( S_COLOR_RED"G_ChangePlayerModel: cannot find NPC %s\n", newModel );
+			G_ChangePlayerModel( ent, "stormtrooper" );	//need a better fallback?
+		}
+	}
+}
+
+void G_ReloadSaberData( gentity_t *ent )
+{
+	//dualSabers should already be set
+	if ( ent->client->ps.saber[0].name != NULL )
+	{
+		WP_SaberParseParms( ent->client->ps.saber[0].name, &ent->client->ps.saber[0], qfalse );
+		if ( ent->client->ps.saber[0].style )
+		{
+			ent->client->ps.saberStylesKnown |= (1<<ent->client->ps.saber[0].style);
+		}
+	}
+	if ( ent->client->ps.saber[1].name != NULL )
+	{
+		WP_SaberParseParms( ent->client->ps.saber[1].name, &ent->client->ps.saber[1], qfalse );
+		if ( ent->client->ps.saber[1].style )
+		{
+			ent->client->ps.saberStylesKnown |= (1<<ent->client->ps.saber[1].style);
+		}
+	}
+}
+
+qboolean G_PlayerSpawned( void )
+{
+	if ( !player
+		|| !player->client 
+		|| player->client->pers.teamState.state != TEAM_ACTIVE 
+		|| level.time - player->client->pers.enterTime < 100 )
+	{//player hasn't spawned yet
+		return qfalse;
+	}
+	return qtrue;
+}
+
+/*
+===========
+ClientSpawn
+
+Called every time a client is placed fresh in the world:
+after the first ClientBegin, and after each respawn
+Initializes all non-persistant parts of playerState
+============
+*/
+
+qboolean G_CheckPlayerDarkSide( void )
+{
+	if ( player && player->client && player->client->sess.mission_objectives[LIGHTSIDE_OBJ].status == 2 )
+	{//dark side player!
+		player->client->playerTeam = TEAM_FREE;
+		player->client->enemyTeam = TEAM_FREE;
+		if ( g_saberDarkSideSaberColor->integer )
+		{//dark side!
+			//always use red
+			for ( int n = 0; n < MAX_BLADES; n++ )
+			{
+				player->client->ps.saber[0].blade[n].color = player->client->ps.saber[1].blade[n].color = SABER_RED;
+			}
+		}
+		G_SoundIndex( "sound/chars/jedi2/28je2008.wav" );
+		G_SoundIndex( "sound/chars/jedi2/28je2009.wav" );
+		G_SoundIndex( "sound/chars/jedi2/28je2012.wav" );
+		return qtrue;
+	}
+	return qfalse;
+}
+
+qboolean ClientSpawn(gentity_t *ent, SavedGameJustLoaded_e eSavedGameJustLoaded ) 
+{
+	int		index;
+	vec3_t	spawn_origin, spawn_angles;
+	gclient_t	*client;
+	int		i;
+	clientPersistant_t	saved;
+	clientSession_t		savedSess;
+	clientInfo_t		savedCi;
+	int		persistant[MAX_PERSISTANT];
+	usercmd_t	ucmd;
+	gentity_t	*spawnPoint;
+	qboolean	beamInEffect = qfalse;
+	extern qboolean g_qbLoadTransition;
+
+	index = ent - g_entities;
+	client = ent->client;
+
+	if ( eSavedGameJustLoaded == eFULL && g_qbLoadTransition == qfalse )//qbFromSavedGame)
+	{//loading up a full save game
+		ent->client->pers.teamState.state = TEAM_ACTIVE;
+
+		// increment the spawncount so the client will detect the respawn
+		client->ps.persistant[PERS_SPAWN_COUNT]++;
+		client->ps.persistant[PERS_TEAM] = client->sess.sessionTeam;
+
+		client->airOutTime = level.time + 12000;
+
+		for (i=0; i<3; i++)
+		{
+			ent->client->pers.cmd_angles[i] = 0.0f;
+		}
+
+		SetClientViewAngle( ent, ent->client->ps.viewangles);//spawn_angles );
+
+		gi.linkentity (ent);
+
+		// run the presend to set anything else
+		ClientEndFrame( ent );
+
+		// clear entity state values
+		PlayerStateToEntityState( &client->ps, &ent->s );
+
+		//FIXME: make sure ent->NPC_type is saved out
+		G_LoadAnimFileSet( ent, ent->NPC_type );
+		G_SetSkin( ent );
+
+		//setup sabers
+		G_ReloadSaberData( ent );
+		//force power levels should already be set
+	}
+	else
+	{
+		// find a spawn point
+		// do it before setting health back up, so farthest
+		// ranging doesn't count this client
+		// don't spawn near existing origin if possible
+		spawnPoint = SelectSpawnPoint ( ent->client->ps.origin, 
+			(team_t) ent->client->ps.persistant[PERS_TEAM], spawn_origin, spawn_angles);
+
+		ent->client->pers.teamState.state = TEAM_ACTIVE;
+
+		// clear everything but the persistant data
+		saved = client->pers;
+		savedSess = client->sess;
+		for ( i = 0 ; i < MAX_PERSISTANT ; i++ ) 
+		{
+			persistant[i] = client->ps.persistant[i];
+		}
+		//Preserve clientInfo
+		memcpy (&savedCi, &client->clientInfo, sizeof(clientInfo_t));
+		
+		memset (client, 0, sizeof(*client));
+
+		memcpy (&client->clientInfo, &savedCi, sizeof(clientInfo_t));
+
+		client->pers = saved;
+		client->sess = savedSess;
+		for ( i = 0 ; i < MAX_PERSISTANT ; i++ ) 
+		{
+			client->ps.persistant[i] = persistant[i];
+		}
+
+		// increment the spawncount so the client will detect the respawn
+		client->ps.persistant[PERS_SPAWN_COUNT]++;
+		client->ps.persistant[PERS_TEAM] = client->sess.sessionTeam;
+
+		client->airOutTime = level.time + 12000;
+
+		// clear entity values
+		client->ps.stats[STAT_MAX_HEALTH] = client->pers.maxHealth;
+		ent->s.groundEntityNum = ENTITYNUM_NONE;
+		ent->client = &level.clients[index];
+		ent->mass = 10;
+		ent->takedamage = qtrue;
+		ent->inuse = qtrue;
+		SetInUse(ent);
+		ent->m_iIcarusID = IIcarusInterface::ICARUS_INVALID;
+		if ( !ent->NPC_type )
+		{
+			ent->NPC_type = "player";
+		}
+		ent->classname = "player";
+		ent->targetname = ent->script_targetname = "player";
+		if ( ent->client->NPC_class == CLASS_NONE )
+		{
+			ent->client->NPC_class = CLASS_PLAYER;
+		}
+		client->playerTeam = TEAM_PLAYER;
+		client->enemyTeam = TEAM_ENEMY;
+		ent->contents = CONTENTS_BODY;
+		ent->clipmask = MASK_PLAYERSOLID;
+		ent->e_DieFunc = dieF_player_die;
+		ent->waterlevel = 0;
+		ent->watertype = 0;
+		client->ps.friction = 6;
+		client->ps.gravity = g_gravity->value;
+		ent->flags &= ~FL_NO_KNOCKBACK;
+		client->renderInfo.lookTarget = ENTITYNUM_NONE;
+		client->renderInfo.lookTargetClearTime = 0;
+		client->renderInfo.lookMode = LM_ENT;
+
+		VectorCopy (playerMins, ent->mins);
+		VectorCopy (playerMaxs, ent->maxs);
+		client->crouchheight = CROUCH_MAXS_2;
+		client->standheight = DEFAULT_MAXS_2;
+
+		client->ps.clientNum = index;
+
+		// give default weapons
+		//these are precached in g_items, ClearRegisteredItems()
+		client->ps.stats[STAT_WEAPONS] = ( 1 << WP_NONE );
+		//client->ps.inventory[INV_ELECTROBINOCULARS] = 1;
+		//ent->client->ps.inventory[INV_BACTA_CANISTER] = 1;
+
+		// give EITHER the saber or the stun baton..never both
+		if ( spawnPoint->spawnflags & 32 ) // STUN_BATON
+		{
+			client->ps.stats[STAT_WEAPONS] |= ( 1 << WP_STUN_BATON );
+			client->ps.weapon = WP_STUN_BATON;
+		}
+		else
+		{	// give the saber because most test maps will not have the STUN BATON flag set
+			client->ps.stats[STAT_WEAPONS] |= ( 1 << WP_SABER );	//this is precached in SP_info_player_deathmatch 
+			client->ps.weapon = WP_SABER;
+		}
+		// force the base weapon up
+		client->ps.weaponstate = WEAPON_READY;
+
+		for ( i = FIRST_WEAPON; i < MAX_PLAYER_WEAPONS; i++ ) // don't give ammo for explosives
+		{
+			if ( (client->ps.stats[STAT_WEAPONS]&(1<<i)) )
+			{//if starting with this weapon, gimme max ammo for it
+				client->ps.ammo[weaponData[i].ammoIndex] = ammoData[weaponData[i].ammoIndex].max;
+			}
+		}
+
+		if ( eSavedGameJustLoaded == eNO )
+		{
+			//FIXME: get player's info from NPCs.cfg
+			client->ps.dualSabers = qfalse;
+			WP_SaberParseParms( g_saber->string, &client->ps.saber[0] );//get saber info
+
+			client->ps.saberStylesKnown |= (1<<gi.Cvar_VariableIntegerValue("g_fighting_style"));
+
+//			if ( client->ps.saber[0].style )
+//			{
+//				client->ps.saberStylesKnown |= (1<<client->ps.saber[0].style);
+//			}
+			WP_InitForcePowers( ent );//Initialize force powers
+		}
+		else
+		{//autoload, will be taken care of below
+		}
+		//
+		
+		ent->health = client->ps.stats[STAT_HEALTH] = client->ps.stats[STAT_MAX_HEALTH];
+		ent->client->dismemberProbHead = 0;
+		ent->client->dismemberProbArms = 5;
+		ent->client->dismemberProbHands = 20;
+		ent->client->dismemberProbWaist = 0;
+		ent->client->dismemberProbLegs = 0;
+
+		ent->client->ps.batteryCharge = 2500;
+
+		VectorCopy( spawn_origin, client->ps.origin );
+		VectorCopy( spawn_origin, ent->currentOrigin );
+
+		// the respawned flag will be cleared after the attack and jump keys come up
+		client->ps.pm_flags |= PMF_RESPAWNED;
+
+		SetClientViewAngle( ent, spawn_angles );
+
+		G_KillBox( ent );
+		gi.linkentity (ent);
+
+		// don't allow full run speed for a bit
+		client->ps.pm_flags |= PMF_TIME_KNOCKBACK;
+		client->ps.pm_time = 100;
+
+		client->respawnTime = level.time;
+		client->latched_buttons = 0;
+
+		// set default animations
+		client->ps.torsoAnim = BOTH_STAND2;
+		client->ps.legsAnim = BOTH_STAND2;
+
+		//clear IK grabbing stuff
+		client->ps.heldClient = client->ps.heldByClient = ENTITYNUM_NONE;
+		client->ps.saberLockEnemy = ENTITYNUM_NONE;	//duh, don't think i'm locking with myself
+
+		// restore some player data 
+		//
+		Player_RestoreFromPrevLevel(ent);
+
+		//FIXME: put this BEFORE the Player_RestoreFromPrevLevel check above?
+		if (eSavedGameJustLoaded == eNO)
+		{//fresh start
+			if (!(spawnPoint->spawnflags&1))		// not KEEP_PREV
+			{//then restore health and armor
+				ent->health = client->ps.stats[STAT_ARMOR] = client->ps.stats[STAT_HEALTH] = client->ps.stats[STAT_MAX_HEALTH];
+				ent->client->ps.forcePower = ent->client->ps.forcePowerMax;
+			}
+			G_InitPlayerFromCvars( ent );
+		}
+		else
+		{//autoload
+			G_LoadAnimFileSet( ent, ent->NPC_type );
+			G_SetSkin( ent );
+			G_ReloadSaberData( ent );
+			//force power levels should already be set
+		}
+
+		//NEVER start a map with either of your sabers or blades on...
+		ent->client->ps.SaberDeactivate();
+		// run a client frame to drop exactly to the floor,
+		// initialize animations and other things
+		client->ps.commandTime = level.time - 100;
+		ucmd = client->pers.lastCommand;
+		ucmd.serverTime = level.time;
+		_VectorCopy( client->pers.cmd_angles, ucmd.angles );
+		ucmd.weapon = client->ps.weapon;	// client think calls Pmove which sets the client->ps.weapon to ucmd.weapon, so ...
+		ent->client->ps.groundEntityNum = ENTITYNUM_NONE;
+		ClientThink( ent-g_entities, &ucmd );
+
+		// run the presend to set anything else
+		ClientEndFrame( ent );
+
+		// clear entity state values
+		PlayerStateToEntityState( &client->ps, &ent->s );
+
+		//ICARUS include
+		Quake3Game()->FreeEntity( ent );
+		Quake3Game()->InitEntity( ent );
+
+		// Make sure no Sequencer exists then Get a new one.
+		IIcarusInterface::GetIcarus()->DeleteIcarusID( ent->m_iIcarusID );
+		ent->m_iIcarusID = IIcarusInterface::GetIcarus()->GetIcarusID( ent->s.number );
+
+		if ( spawnPoint->spawnflags & 64 )	//NOWEAPON
+		{//player starts with absolutely no weapons
+			ent->client->ps.stats[STAT_WEAPONS] = ( 1 << WP_NONE );
+			ent->client->ps.ammo[weaponData[WP_NONE].ammoIndex] = 32000;
+			ent->client->ps.weapon = WP_NONE;
+			ent->client->ps.weaponstate = WEAPON_READY;
+		}
+
+		if ( ent->client->ps.stats[STAT_WEAPONS] & ( 1 << WP_SABER ) )
+		{//set up so has lightsaber
+			WP_SaberInitBladeData( ent );
+			if ( (ent->weaponModel[0] <= 0 || (ent->weaponModel[1]<=0&&ent->client->ps.dualSabers)) //one or both of the saber models is not initialized
+				&& ent->client->ps.weapon == WP_SABER )//current weapon is saber
+			{//add the proper models
+				WP_SaberAddG2SaberModels( ent );
+			}
+		}
+		if ( ent->weaponModel[0] == -1 && ent->client->ps.weapon != WP_NONE )
+		{
+			G_CreateG2AttachedWeaponModel( ent, weaponData[ent->client->ps.weapon].weaponMdl, ent->handRBolt, 0 );
+		}
+
+		{
+			// fire the targets of the spawn point
+			G_UseTargets( spawnPoint, ent );
+			//Designers needed them to fire off target2's as well... this is kind of messy
+			G_UseTargets2( spawnPoint, ent, spawnPoint->target2 );
+
+			/*
+			// select the highest weapon number available, after any
+			// spawn given items have fired
+			client->ps.weapon = 1;
+			for ( i = WP_NUM_WEAPONS - 1 ; i > 0 ; i-- ) {
+				if ( client->ps.stats[STAT_WEAPONS] & ( 1 << i ) ) {
+					client->ps.weapon = i;
+					break;
+				}
+			}*/
+		}
+	}
+
+	client->pers.enterTime = level.time;//needed mainly to stop the weapon switch to WP_NONE that happens on loads
+	ent->max_health = client->ps.stats[STAT_MAX_HEALTH];
+
+	if ( eSavedGameJustLoaded == eNO )
+	{//on map transitions, Ghoul2 frame gets reset to zero, restart our anim
+		NPC_SetAnim( ent, SETANIM_LEGS, ent->client->ps.legsAnim, SETANIM_FLAG_NORMAL|SETANIM_FLAG_RESTART );
+		NPC_SetAnim( ent, SETANIM_TORSO, ent->client->ps.torsoAnim, SETANIM_FLAG_NORMAL|SETANIM_FLAG_RESTART );
+	}
+
+	if ( ent->s.number == 0 )
+	{//player
+		G_CheckPlayerDarkSide();
+	}
+
+	if ( (ent->client->ps.stats[STAT_WEAPONS]&(1<<WP_SABER))
+		&& !ent->client->ps.saberStylesKnown )
+	{//um, if you have a saber, you need at least 1 style to use it with...
+		ent->client->ps.saberStylesKnown |= (1<<SS_MEDIUM);
+	}
+
+	return beamInEffect;
+}
+
+
+/*
+===========
+ClientDisconnect
+
+Called when a player drops from the server.
+Will not be called between levels.
+============
+*/
+void ClientDisconnect( int clientNum ) {
+	gentity_t	*ent;
+
+	ent = g_entities + clientNum;
+	if ( !ent->client ) {
+		return;
+	}
+
+	// send effect if they were completely connected
+/*	if ( ent->client->pers.connected == CON_CONNECTED ) {
+		// They don't get to take powerups with them!
+		// Especially important for stuff like CTF flags
+		TossClientItems ( ent );
+	}
+*/
+	gi.unlinkentity (ent);
+	ent->s.modelindex = 0;
+	ent->inuse = qfalse;
+	ClearInUse(ent);
+	ent->classname = "disconnected";
+	ent->client->pers.connected = CON_DISCONNECTED;
+	ent->client->ps.persistant[PERS_TEAM] = TEAM_FREE;
+
+	gi.SetConfigstring( CS_PLAYERS + clientNum, "");
+
+	IIcarusInterface::GetIcarus()->DeleteIcarusID(ent->m_iIcarusID);
+
+}
+
+
+																  
diff --git a/code/game/g_cmds.cpp b/code/game/g_cmds.cpp
new file mode 100644
index 0000000..f65ad99
--- /dev/null
+++ b/code/game/g_cmds.cpp
@@ -0,0 +1,1456 @@
+// leave this line at the top for all g_xxxx.cpp files...
+#include "g_headers.h"
+
+
+#include "g_local.h"
+#include "objectives.h"
+#include "wp_saber.h"
+#include "g_vehicles.h"
+
+extern	bool		in_camera;
+extern stringID_table_t SaberStyleTable[];
+
+extern void ForceHeal( gentity_t *self );
+extern void ForceGrip( gentity_t *self );
+extern void ForceTelepathy( gentity_t *self );
+extern void ForceRage( gentity_t *self );
+extern void ForceProtect( gentity_t *self );
+extern void ForceAbsorb( gentity_t *self );
+extern void ForceSeeing( gentity_t *self );
+extern void G_CreateG2AttachedWeaponModel( gentity_t *ent, const char *psWeaponModel, int boltNum, int weaponNum );
+extern void G_StartMatrixEffect( gentity_t *ent, int meFlags = 0, int length = 1000, float timeScale = 0.0f, int spinTime = 0 );
+extern void ItemUse_Bacta(gentity_t *ent);
+extern gentity_t *G_GetSelfForPlayerCmd( void );
+
+/*
+==================
+CheatsOk
+==================
+*/
+qboolean	CheatsOk( gentity_t *ent ) {
+	if ( !g_cheats->integer ) {
+		gi.SendServerCommand( ent-g_entities, "print \"Cheats are not enabled on this server.\n\"");
+		return qfalse;
+	}
+	if ( ent->health <= 0 ) {
+		gi.SendServerCommand( ent-g_entities, "print \"You must be alive to use this command.\n\"");
+		return qfalse;
+	}
+	return qtrue;
+}
+
+
+/*
+==================
+ConcatArgs
+==================
+*/
+char	*ConcatArgs( int start ) {
+	int		i, c, tlen;
+	static char	line[MAX_STRING_CHARS];
+	int		len;
+	char	*arg;
+
+	len = 0;
+	c = gi.argc();
+	for ( i = start ; i < c ; i++ ) {
+		arg = gi.argv( i );
+		tlen = strlen( arg );
+		if ( len + tlen >= MAX_STRING_CHARS - 1 ) {
+			break;
+		}
+		memcpy( line + len, arg, tlen );
+		len += tlen;
+		if ( i != c - 1 ) {
+			line[len] = ' ';
+			len++;
+		}
+	}
+
+	line[len] = 0;
+
+	return line;
+}
+
+/*
+==================
+SanitizeString
+
+Remove case and control characters
+==================
+*/
+void SanitizeString( char *in, char *out ) {
+	while ( *in ) {
+		if ( *in == 27 ) {
+			in += 2;		// skip color code
+			continue;
+		}
+		if ( *in < 32 ) {
+			in++;
+			continue;
+		}
+		*out++ = tolower( *in++ );
+	}
+
+	*out = 0;
+}
+
+/*
+==================
+ClientNumberFromString
+
+Returns a player number for either a number or name string
+Returns -1 if invalid
+==================
+*/
+int ClientNumberFromString( gentity_t *to, char *s ) {
+	gclient_t	*cl;
+	int			idnum;
+	char		s2[MAX_STRING_CHARS];
+	char		n2[MAX_STRING_CHARS];
+
+	// numeric values are just slot numbers
+	if (s[0] >= '0' && s[0] <= '9') {
+		idnum = atoi( s );
+		if ( idnum < 0 || idnum >= level.maxclients ) {
+			gi.SendServerCommand( to-g_entities, "print \"Bad client slot: %i\n\"", idnum);
+			return -1;
+		}
+
+		cl = &level.clients[idnum];
+		if ( cl->pers.connected != CON_CONNECTED ) {
+			gi.SendServerCommand( to-g_entities, "print \"Client %i is not active\n\"", idnum);
+			return -1;
+		}
+		return idnum;
+	}
+
+	// check for a name match
+	SanitizeString( s, s2 );
+	for ( idnum=0,cl=level.clients ; idnum < level.maxclients ; idnum++,cl++ ) {
+		if ( cl->pers.connected != CON_CONNECTED ) {
+			continue;
+		}
+		SanitizeString( cl->pers.netname, n2 );
+		if ( !strcmp( n2, s2 ) ) {
+			return idnum;
+		}
+	}
+
+	gi.SendServerCommand( to-g_entities, "print \"User %s is not on the server\n\"", s);
+	return -1;
+}
+
+/*
+==================
+Cmd_Give_f
+
+Give items to a client
+==================
+*/
+void Cmd_Give_f (gentity_t *ent)
+{
+	char		*name;
+	gitem_t		*it;
+	int			i;
+	qboolean	give_all;
+
+	if ( !CheatsOk( ent ) ) {
+		return;
+	}
+
+	name = ConcatArgs( 1 );
+
+	if (Q_stricmp(name, "all") == 0)
+		give_all = qtrue;
+	else
+		give_all = qfalse;
+
+	if (give_all || Q_stricmp(name, "force") == 0)
+	{
+		if ( ent->client )
+		{
+			ent->client->ps.forcePower = FORCE_POWER_MAX;
+		}
+		if (!give_all)
+			return;
+	}
+
+	if (give_all || Q_stricmp(gi.argv(1), "health") == 0)
+	{
+		if (gi.argc() == 3) {
+			ent->health = atoi(gi.argv(2));
+			if (ent->health > ent->client->ps.stats[STAT_MAX_HEALTH]) {
+				ent->health = ent->client->ps.stats[STAT_MAX_HEALTH];
+			}
+		}
+		else {
+			ent->health = ent->client->ps.stats[STAT_MAX_HEALTH];
+		}
+		if (!give_all)
+			return;
+	}
+
+
+/*	if (give_all || Q_stricmp(name, "inventory") == 0)
+	{
+		// Huh?  Was doing a INV_MAX+1 which was wrong because then you'd actually have every inventory item including INV_MAX
+		ent->client->ps.stats[STAT_ITEMS] = (1 << (INV_MAX)) - ( 1 << INV_ELECTROBINOCULARS );
+
+		ent->client->ps.inventory[INV_ELECTROBINOCULARS] = 1;
+		//ent->client->ps.inventory[INV_BACTA_CANISTER] = 5;
+		//ent->client->ps.inventory[INV_SEEKER] = 5;
+		ent->client->ps.inventory[INV_LIGHTAMP_GOGGLES] = 1;
+		//ent->client->ps.inventory[INV_SENTRY] = 5;
+		//ent->client->ps.inventory[INV_GOODIE_KEY] = 5;
+		//ent->client->ps.inventory[INV_SECURITY_KEY] = 5;
+
+		if (!give_all)
+		{
+			return;
+		}
+	}
+*/
+	if (give_all || Q_stricmp(name, "weapons") == 0)
+	{
+		ent->client->ps.stats[STAT_WEAPONS] = (1 << (WP_MELEE)) - ( 1 << WP_NONE );
+		if (!give_all)
+			return;
+	}
+
+	if ( !give_all && Q_stricmp(gi.argv(1), "weaponnum") == 0 )
+	{
+		ent->client->ps.stats[STAT_WEAPONS] |= (1 << atoi(gi.argv(2)));
+		return;
+	}
+
+	if ( Q_stricmp(name, "eweaps") == 0)	//for developing, gives you all the weapons, including enemy
+	{
+		ent->client->ps.stats[STAT_WEAPONS] = (unsigned)(1 << WP_NUM_WEAPONS) - ( 1 << WP_NONE ); // NOTE: this wasn't giving the last weapon in the list
+		if (!give_all)
+			return;
+	}
+
+	if (give_all || Q_stricmp(name, "ammo") == 0)
+	{
+		for ( i = 0 ; i < AMMO_MAX ; i++ ) {
+			ent->client->ps.ammo[i] = ammoData[i].max;
+		}
+		if (!give_all)
+			return;
+	}
+
+	if (give_all || Q_stricmp(gi.argv(1), "batteries") == 0)
+	{
+		if (gi.argc() == 3)
+			ent->client->ps.batteryCharge = atoi(gi.argv(2));
+		else
+			ent->client->ps.batteryCharge = MAX_BATTERIES;
+
+		if (!give_all)
+			return;
+	}
+
+	if (give_all || Q_stricmp(gi.argv(1), "armor") == 0)
+	{
+		if (gi.argc() == 3)
+			ent->client->ps.stats[STAT_ARMOR] = atoi(gi.argv(2));
+		else
+			ent->client->ps.stats[STAT_ARMOR] = ent->client->ps.stats[STAT_MAX_HEALTH];
+
+		if ( ent->client->ps.stats[STAT_ARMOR] > 0 )
+		{
+			ent->client->ps.powerups[PW_BATTLESUIT] = Q3_INFINITE;
+		}
+		else
+		{
+			ent->client->ps.powerups[PW_BATTLESUIT] = 0;
+		}
+
+		if (!give_all)
+			return;
+	}
+
+	// spawn a specific item right on the player
+	if ( !give_all ) {
+		gentity_t	*it_ent;
+		trace_t		trace;
+		it = FindItem (name);
+		if (!it) {
+			name = gi.argv(1);
+			it = FindItem (name);
+			if (!it) {
+				gi.SendServerCommand( ent-g_entities, "print \"unknown item\n\"");
+				return;
+			}
+		}
+
+		it_ent = G_Spawn();
+		VectorCopy( ent->currentOrigin, it_ent->s.origin );
+		it_ent->classname = G_NewString(it->classname);
+		G_SpawnItem (it_ent, it);
+		FinishSpawningItem(it_ent );
+		memset( &trace, 0, sizeof( trace ) );
+		Touch_Item (it_ent, ent, &trace);
+		if (it_ent->inuse) {
+			G_FreeEntity( it_ent );
+		}
+	}
+}
+
+//------------------
+void Cmd_Fx( gentity_t *ent )
+{
+	vec3_t		dir;
+	gentity_t	*fx_ent = NULL;
+
+	if ( Q_stricmp( gi.argv(1), "play" ) == 0 )
+	{
+		if ( gi.argc() == 3 )
+		{
+			// I guess, only allow one active at a time
+			while (( fx_ent = G_Find( fx_ent, FOFS(classname), "cmd_fx")) != NULL ) 
+			{
+				G_FreeEntity( fx_ent );
+			}
+
+			fx_ent = G_Spawn();
+
+			fx_ent->fxFile = gi.argv( 2 );
+
+			// Move out in front of the person spawning the effect
+			AngleVectors( ent->currentAngles, dir, NULL, NULL );
+			VectorMA( ent->currentOrigin, 32, dir, fx_ent->s.origin );
+
+extern void SP_fx_runner( gentity_t *ent );
+
+			SP_fx_runner( fx_ent );
+			fx_ent->delay = 2000;			// adjusting delay
+			fx_ent->classname = "cmd_fx";	//	and classname
+
+			return;
+		}
+	}
+	else if ( Q_stricmp( gi.argv(1), "stop" ) == 0 )
+	{
+		while (( fx_ent = G_Find( fx_ent, FOFS(classname), "cmd_fx")) != NULL ) 
+		{
+			G_FreeEntity( fx_ent );
+		}
+
+		return;
+	}
+	else if ( Q_stricmp( gi.argv(1), "delay" ) == 0 )
+	{
+		while (( fx_ent = G_Find( fx_ent, FOFS(classname), "cmd_fx")) != NULL ) 
+		{
+			if ( gi.argc() == 3 )
+			{
+				fx_ent->delay = atoi( gi.argv( 2 ));
+			}
+			else
+			{
+				gi.Printf( S_COLOR_GREEN"FX: current delay is: %i\n", fx_ent->delay );
+			}
+
+			return;
+		}
+	}
+	else if ( Q_stricmp( gi.argv(1), "random" ) == 0 )
+	{
+		while (( fx_ent = G_Find( fx_ent, FOFS(classname), "cmd_fx")) != NULL ) 
+		{
+			if ( gi.argc() == 3 )
+			{
+				fx_ent->random = atoi( gi.argv( 2 ));
+			}
+			else
+			{
+				gi.Printf( S_COLOR_GREEN"FX: current random is: %6.2f\n", fx_ent->random );
+			}
+
+			return;
+		}
+	}
+	else if ( Q_stricmp( gi.argv(1), "origin" ) == 0 )
+	{
+		while (( fx_ent = G_Find( fx_ent, FOFS(classname), "cmd_fx")) != NULL ) 
+		{
+			if ( gi.argc() == 5 )
+			{
+				fx_ent->s.origin[0] = atof( gi.argv( 2 ));
+				fx_ent->s.origin[1] = atof( gi.argv( 3 ));
+				fx_ent->s.origin[2] = atof( gi.argv( 4 ));
+
+				G_SetOrigin( fx_ent, fx_ent->s.origin );
+			}
+			else
+			{
+				gi.Printf( S_COLOR_GREEN"FX: current origin is: <%6.2f %6.2f %6.2f>\n", 
+									fx_ent->currentOrigin[0], fx_ent->currentOrigin[1], fx_ent->currentOrigin[2] );
+			}
+
+			return;
+		}
+	}
+	else if ( Q_stricmp( gi.argv(1), "dir" ) == 0 )
+	{
+		while (( fx_ent = G_Find( fx_ent, FOFS(classname), "cmd_fx")) != NULL ) 
+		{
+			if ( gi.argc() == 5 )
+			{
+				fx_ent->s.angles[0] = atof( gi.argv( 2 ));
+				fx_ent->s.angles[1] = atof( gi.argv( 3 ));
+				fx_ent->s.angles[2] = atof( gi.argv( 4 ));
+
+				if ( !VectorNormalize( fx_ent->s.angles ))
+				{
+					// must have been zero length
+					fx_ent->s.angles[2] = 1;
+				}
+			}
+			else
+			{
+				gi.Printf( S_COLOR_GREEN"FX: current dir is: <%6.2f %6.2f %6.2f>\n", 
+									fx_ent->s.angles[0], fx_ent->s.angles[1], fx_ent->s.angles[2] );
+			}
+
+			return;
+		}
+	}
+
+	gi.Printf( S_COLOR_CYAN"Fx--------------------------------------------------------\n" );
+	gi.Printf( S_COLOR_CYAN"commands:              sample usage:\n" );
+	gi.Printf( S_COLOR_CYAN"----------------------------------------------------------\n" );
+	gi.Printf( S_COLOR_CYAN"fx play <filename>     fx play sparks, fx play env/fire\n" );
+	gi.Printf( S_COLOR_CYAN"fx stop                fx stop\n" );		
+	gi.Printf( S_COLOR_CYAN"fx delay <#>           fx delay 1000\n" );
+	gi.Printf( S_COLOR_CYAN"fx random <#>          fx random 200\n" );
+	gi.Printf( S_COLOR_CYAN"fx origin <#><#><#>    fx origin 10 20 30\n" );
+	gi.Printf( S_COLOR_CYAN"fx dir <#><#><#>       fx dir 0 0 -1\n\n" );
+}
+
+/*
+==================
+Cmd_God_f
+
+Sets client to godmode
+
+argv(0) god
+==================
+*/
+void Cmd_God_f (gentity_t *ent)
+{
+	char	*msg;
+
+	if ( !CheatsOk( ent ) ) {
+		return;
+	}
+
+	ent->flags ^= FL_GODMODE;
+	if (!(ent->flags & FL_GODMODE) )
+		msg = "godmode OFF\n";
+	else
+		msg = "godmode ON\n";
+
+	gi.SendServerCommand( ent-g_entities, "print \"%s\"", msg);
+}
+
+/*
+==================
+Cmd_Undying_f
+
+Sets client to undead mode
+
+argv(0) undying
+==================
+*/
+void Cmd_Undying_f (gentity_t *ent)
+{
+	char	*msg;
+
+	if ( !CheatsOk( ent ) ) 
+	{
+		return;
+	}
+
+	ent->flags ^= FL_UNDYING;
+	if (!(ent->flags & FL_UNDYING) )
+	{
+		msg = "undead mode OFF\n";
+	}
+	else
+	{
+		int		max;
+		char	*cmd;
+
+		cmd = gi.argv(1);
+		if ( cmd && atoi( cmd ) )
+		{
+			max = atoi( cmd );
+		}
+		else
+		{
+			max = 999;
+		}
+
+		ent->health = ent->max_health = max;
+
+		msg = "undead mode ON\n";
+
+		if ( ent->client )
+		{
+			ent->client->ps.stats[STAT_HEALTH] = ent->client->ps.stats[STAT_MAX_HEALTH] = 999;
+		}
+	}
+
+	gi.SendServerCommand( ent-g_entities, "print \"%s\"", msg);
+}
+
+/*
+==================
+Cmd_Notarget_f
+
+Sets client to notarget
+
+argv(0) notarget
+==================
+*/
+void Cmd_Notarget_f( gentity_t *ent ) {
+	char	*msg;
+
+	if ( !CheatsOk( ent ) ) {
+		return;
+	}
+
+	ent->flags ^= FL_NOTARGET;
+	if (!(ent->flags & FL_NOTARGET) )
+		msg = "notarget OFF\n";
+	else
+		msg = "notarget ON\n";
+
+	gi.SendServerCommand( ent-g_entities, "print \"%s\"", msg);
+}
+
+
+/*
+==================
+Cmd_Noclip_f
+
+argv(0) noclip
+==================
+*/
+void Cmd_Noclip_f( gentity_t *ent ) {
+	char	*msg;
+
+	if ( !CheatsOk( ent ) ) {
+		return;
+	}
+
+	if ( ent->client->noclip ) {
+		msg = "noclip OFF\n";
+	} else {
+		msg = "noclip ON\n";
+	}
+	ent->client->noclip = !ent->client->noclip;
+
+	gi.SendServerCommand( ent-g_entities, "print \"%s\"", msg);
+}
+
+
+/*
+==================
+Cmd_LevelShot_f
+
+This is just to help generate the level pictures
+for the menus.  It goes to the intermission immediately
+and sends over a command to the client to resize the view,
+hide the scoreboard, and take a special screenshot
+==================
+*/
+void Cmd_LevelShot_f( gentity_t *ent ) {
+	if ( !CheatsOk( ent ) ) {
+		return;
+	}
+
+	gi.SendServerCommand( ent-g_entities, "clientLevelShot" );
+}
+
+
+/*
+=================
+Cmd_Kill_f
+=================
+*/
+void Cmd_Kill_f( gentity_t *ent ) {
+	if( ( level.time - ent->client->respawnTime ) < 5000 ) {
+		gi.SendServerCommand( ent-g_entities, "cp @SP_INGAME_ONE_KILL_PER_5_SECONDS");
+		return;
+	}
+	ent->flags &= ~FL_GODMODE;
+	ent->client->ps.stats[STAT_HEALTH] = ent->health = 0;
+	player_die (ent, ent, ent, 100000, MOD_SUICIDE);
+}
+
+
+/*
+==================
+Cmd_Where_f
+==================
+*/
+void Cmd_Where_f( gentity_t *ent ) {
+	const char *s = gi.argv(1);
+	const len = strlen(s);
+	gentity_t	*check;
+	
+	if ( gi.argc () < 2 ) {
+		gi.Printf("usage: where classname\n");
+		return;
+	}
+	for (int i = 0; i < globals.num_entities; i++)
+	{
+		if(!PInUse(i))
+			continue;
+//		if(!check || !check->inuse) {
+//			continue;
+//		}
+		check = &g_entities[i];
+		if (!Q_stricmpn(s, check->classname, len) ) {
+			gi.SendServerCommand( ent-g_entities, "print \"%s %s\n\"", check->classname, vtos( check->s.pos.trBase ) );
+		}
+	}
+}
+
+
+/*
+-------------------------
+UserSpawn
+-------------------------
+*/
+
+extern qboolean G_CallSpawn( gentity_t *ent );
+
+void UserSpawn( gentity_t *ent, const char *name )
+{
+	vec3_t		origin;
+	vec3_t		vf;
+	vec3_t		angles;
+	gentity_t	*ent2;
+	
+	//Spawn the ent
+	ent2 = G_Spawn();
+	ent2->classname = G_NewString( name );
+
+	//TODO: This should ultimately make sure this is a safe spawn!
+
+	//Spawn the entity and place it there
+	VectorSet( angles, 0, ent->s.apos.trBase[YAW], 0 );
+	AngleVectors( angles, vf, NULL, NULL );
+	VectorMA( ent->s.pos.trBase, 96, vf, origin );	//FIXME: Find the radius size of the object, and push out 32 + radius
+
+	origin[2] += 8;
+	VectorCopy( origin, ent2->s.pos.trBase );
+	VectorCopy( origin, ent2->s.origin );
+	VectorCopy( ent->s.apos.trBase, ent2->s.angles );
+
+	gi.linkentity( ent2 );
+
+	//Find a valid spawning spot
+	if ( G_CallSpawn( ent2 ) == qfalse )
+	{
+		gi.SendServerCommand( ent-g_entities, "print \"Failed to spawn '%s'\n\"", name );
+		G_FreeEntity( ent2 );
+		return;
+	}
+}
+
+/*
+-------------------------
+Cmd_Spawn
+-------------------------
+*/
+
+void Cmd_Spawn( gentity_t *ent )
+{
+	char	*name;
+
+	name = ConcatArgs( 1 );
+
+	gi.SendServerCommand( ent-g_entities, "print \"Spawning '%s'\n\"", name );
+
+	UserSpawn( ent, name );
+}
+
+/*
+=================
+Cmd_SetViewpos_f
+=================
+*/
+void Cmd_SetViewpos_f( gentity_t *ent ) {
+	vec3_t		origin, angles;
+	int			i;
+
+	if ( !g_cheats->integer ) {
+		gi.SendServerCommand( ent-g_entities, va("print \"Cheats are not enabled on this server.\n\""));
+		return;
+	}
+	if ( gi.argc() != 5 ) {
+		gi.SendServerCommand( ent-g_entities, va("print \"usage: setviewpos x y z yaw\n\""));
+		return;
+	}
+
+	VectorClear( angles );
+	for ( i = 0 ; i < 3 ; i++ ) {
+		origin[i] = atof( gi.argv( i+1 ) );
+	}
+	origin[2] -= 25;	//acount for eye height from viewpos cmd
+
+	angles[YAW] = atof( gi.argv( 4 ) );
+
+	TeleportPlayer( ent, origin, angles );
+}
+
+
+
+/*
+=================
+Cmd_SetObjective_f
+=================
+*/
+qboolean G_CheckPlayerDarkSide( void );
+
+void Cmd_SetObjective_f( gentity_t *ent ) 
+{
+	int objectiveI,status,displayStatus;
+
+	if ( gi.argc() == 2 ) {
+		objectiveI = atoi(gi.argv(1));
+		gi.Printf("objective #%d  display status=%d, status=%d\n",objectiveI, 
+			ent->client->sess.mission_objectives[objectiveI].display,
+			ent->client->sess.mission_objectives[objectiveI].status
+			);
+		return;
+	}
+	if ( gi.argc() != 4 ) {
+		gi.SendServerCommand( ent-g_entities, va("print \"usage: setobjective <objective #>  <display status> <status>\n\""));
+		return;
+	}
+
+	if ( !CheatsOk( ent ) ) 
+	{
+		return;
+	}
+
+	objectiveI = atoi(gi.argv(1));
+	displayStatus = atoi(gi.argv(2));
+	status = atoi(gi.argv(3));
+
+	ent->client->sess.mission_objectives[objectiveI].display = displayStatus;
+	ent->client->sess.mission_objectives[objectiveI].status = status;
+	G_CheckPlayerDarkSide();
+}
+
+/*
+=================
+Cmd_ViewObjective_f
+=================
+*/
+void Cmd_ViewObjective_f( gentity_t *ent ) 
+{
+	int objectiveI;
+
+	if ( gi.argc() != 2 ) {
+		gi.SendServerCommand( ent-g_entities, va("print \"usage: viewobjective <objective #>\n\""));
+		return;
+	}
+
+	objectiveI = atoi(gi.argv(1));
+
+	gi.SendServerCommand( ent-g_entities, va("print \"Objective %d   Display Status(1=show): %d  Status:%d\n\"",objectiveI,ent->client->sess.mission_objectives[objectiveI].display,ent->client->sess.mission_objectives[objectiveI].status));
+}
+
+
+/*
+================
+Cmd_UseElectrobinoculars_f
+================
+*/
+void Cmd_UseElectrobinoculars_f(gentity_t *ent)
+{
+	if ( ent->health < 1 || in_camera )
+	{
+		return;
+	}
+
+	if ( ent->client->ps.inventory[INV_ELECTROBINOCULARS] <= 0 )
+	{
+		// have none to place...play sound?
+		return;
+	}
+
+	G_AddEvent( ent, EV_USE_INV_BINOCULARS, 0 );
+}
+
+/*
+================
+Cmd_UseBacta_f
+================
+*/
+void Cmd_UseBacta_f(gentity_t *ent)
+{
+	if ( ent->health < 1 || in_camera )
+	{
+		return;
+	}
+
+	ItemUse_Bacta(ent);
+}
+
+//----------------------------------------------------------------------------------
+qboolean PickSeekerSpawnPoint( vec3_t org, vec3_t fwd, vec3_t right, int skip, vec3_t spot )
+{
+	vec3_t	mins, maxs, forward, end;
+	trace_t tr;
+
+	VectorSet( maxs, -8, -8, -24); // ?? size
+	VectorSet( maxs, 8, 8, 8 );
+
+	VectorCopy( fwd, forward );
+
+	// to the front and side a bit
+	forward[2] = 0.3f; // start up a bit
+
+	VectorMA( org, 48, forward, end );
+	VectorMA( end, -8, right, end );
+
+	gi.trace( &tr, org, mins, maxs, end, skip, MASK_PLAYERSOLID );
+
+	if ( !tr.startsolid && !tr.allsolid && tr.fraction >= 1.0f )
+	{
+		VectorCopy( tr.endpos, spot );
+		return qtrue;
+	}
+
+	// side
+	VectorMA( org, 48, right, end );
+
+	gi.trace( &tr, org, mins, maxs, end, skip, MASK_PLAYERSOLID );
+
+	if ( !tr.startsolid && !tr.allsolid && tr.fraction >= 1.0f )
+	{
+		VectorCopy( tr.endpos, spot );
+		return qtrue;
+	}
+
+	// other side
+	VectorMA( org, -48, right, end );
+
+	gi.trace( &tr, org, mins, maxs, end, skip, MASK_PLAYERSOLID );
+
+	if ( !tr.startsolid && !tr.allsolid && tr.fraction >= 1.0f )
+	{
+		VectorCopy( tr.endpos, spot );
+		return qtrue;
+	}
+
+	// behind
+	VectorMA( org, -48, fwd, end );
+
+	gi.trace( &tr, org, mins, maxs, end, skip, MASK_PLAYERSOLID );
+
+	if ( !tr.startsolid && !tr.allsolid && tr.fraction >= 1.0f )
+	{
+		VectorCopy( tr.endpos, spot );
+		return qtrue;
+	}
+
+	return qfalse;
+}
+
+/*
+================
+Cmd_UseSeeker_f
+================
+*/
+void Cmd_UseSeeker_f( gentity_t *ent )
+{
+	if ( ent->health < 1 || in_camera )
+	{
+		return;
+	}
+
+	// don't use them if we don't have any...also don't use them if one is already going
+	if ( ent->client && ent->client->ps.inventory[INV_SEEKER] > 0 && level.time > ent->client->ps.powerups[PW_SEEKER] )
+	{
+		gentity_t	*tent = G_Spawn();
+	
+		if ( tent )
+		{
+			vec3_t	fwd, right, spot;
+
+			AngleVectors( ent->client->ps.viewangles, fwd, right, NULL );
+
+			VectorCopy( ent->currentOrigin, spot ); // does nothing really, just initialize the goods...
+
+			if ( PickSeekerSpawnPoint( ent->currentOrigin, fwd, right, ent->s.number, spot ))
+			{
+				VectorCopy( spot, tent->s.origin );
+				G_SetOrigin( tent, spot );
+				G_SetAngles( tent, ent->currentAngles );
+
+extern void SP_NPC_Droid_Seeker( gentity_t *ent );
+
+				SP_NPC_Droid_Seeker( tent );
+				G_Sound( tent, G_SoundIndex( "sound/chars/seeker/misc/hiss" ));
+
+				// make sure that we even have some
+				ent->client->ps.inventory[INV_SEEKER]--;
+				ent->client->ps.powerups[PW_SEEKER] = level.time + 1000;// can only drop one every second..maybe this is annoying?
+
+			}
+		}
+	}
+}
+
+/*
+================
+Cmd_UseGoggles_f
+================
+*/
+void Cmd_UseGoggles_f(gentity_t *ent)
+{
+	if ( ent->health < 1 || in_camera )
+	{
+		return;
+	}
+
+	if ( ent->client && ent->client->ps.inventory[INV_LIGHTAMP_GOGGLES] > 0 )
+	{
+		G_AddEvent( ent, EV_USE_INV_LIGHTAMP_GOGGLES, 0 );
+	}
+}
+
+/*
+================
+Cmd_UseSentry_f
+================
+*/
+qboolean place_portable_assault_sentry( gentity_t *self, vec3_t origin, vec3_t dir );
+void Cmd_UseSentry_f(gentity_t *ent)
+{
+	if ( ent->health < 1 || in_camera )
+	{
+		return;
+	}
+
+	if ( ent->client->ps.inventory[INV_SENTRY] <= 0 )
+	{
+		// have none to place...play sound?
+		return;
+	}
+
+	if ( place_portable_assault_sentry( ent, ent->currentOrigin, ent->client->ps.viewangles ))
+	{
+		ent->client->ps.inventory[INV_SENTRY]--;
+		G_AddEvent( ent, EV_USE_INV_SENTRY, 0 );
+	}
+	else
+	{
+		// couldn't be placed....play a notification sound!!
+	}
+}
+
+/*
+================
+Cmd_UseInventory_f
+================
+*/
+void Cmd_UseInventory_f(gentity_t *ent)
+{
+	switch (cg.inventorySelect)
+	{
+		case INV_ELECTROBINOCULARS :
+			Cmd_UseElectrobinoculars_f(ent);
+			return;
+		//case INV_BACTA_CANISTER :
+		//	Cmd_UseBacta_f(ent);
+		//	return;
+		case INV_SEEKER :
+			Cmd_UseSeeker_f(ent);
+			return;
+		case INV_LIGHTAMP_GOGGLES :
+			Cmd_UseGoggles_f(ent);
+			return;
+		case INV_SENTRY :
+			Cmd_UseSentry_f(ent);
+			return;
+		default :
+			return;
+
+	}
+}
+
+void Cmd_FlushCamFile_f(gentity_t *ent)
+{
+	gi.FlushCamFile();
+}
+
+void G_Taunt( gentity_t *ent )
+{
+	if ( ent->client )
+	{
+		if ( ent->client->ps.weapon == WP_SABER 
+			&& (ent->client->ps.saberAnimLevel == SS_STAFF //ent->client->ps.saber[0].type == SABER_STAFF 
+				|| ent->client->ps.dualSabers) )
+		{
+			ent->client->ps.taunting = level.time + 100;
+			//make sure all sabers are on
+			ent->client->ps.SaberActivate();
+		}
+		else
+		{
+			ent->client->ps.taunting = level.time + 100;
+		}
+	}
+}
+
+void G_Victory( gentity_t *ent )
+{
+	if ( ent->health > 0 )
+	{//say something and put away saber
+		G_SoundOnEnt( ent, CHAN_VOICE, "sound/chars/kyle/misc/taunt1.wav" );
+		if ( ent->client )
+		{
+			ent->client->ps.SaberDeactivate();
+		}
+	}
+}
+
+typedef enum
+{
+	TAUNT_TAUNT = 0,
+	TAUNT_BOW,
+	TAUNT_MEDITATE,
+	TAUNT_FLOURISH,
+	TAUNT_GLOAT
+};
+
+extern void G_SpeechEvent( gentity_t *self, int event );
+void G_TauntSound( gentity_t *ent, int taunt )
+{
+	switch ( taunt )
+	{
+	case TAUNT_TAUNT:
+	default:
+		if ( Q_irand( 0, 1 ) )
+		{
+			G_SpeechEvent( ent, Q_irand( EV_ANGER1, EV_ANGER3 ) );
+		}
+		else
+		{
+			G_SpeechEvent( ent, Q_irand( EV_TAUNT1, EV_TAUNT3 ) );
+		}
+		break;
+	case TAUNT_BOW:
+		break;
+	case TAUNT_MEDITATE:
+		break;
+	case TAUNT_FLOURISH:
+		if ( Q_irand( 0, 1 ) )
+		{
+			G_SpeechEvent( ent, Q_irand( EV_DEFLECT1, EV_DEFLECT3 ) );
+		}
+		else
+		{
+			G_SpeechEvent( ent, Q_irand( EV_GLOAT1, EV_GLOAT3 ) );
+		}
+		break;
+	case TAUNT_GLOAT:
+		G_SpeechEvent( ent, Q_irand( EV_VICTORY1, EV_VICTORY3 ) );
+		break;
+	}
+}
+
+void G_SetTauntAnim( gentity_t *ent, int taunt )
+{
+	if ( !ent || !ent->client )
+	{
+		return;
+	}
+	if ( !ent->client->ps.torsoAnimTimer
+		&& !ent->client->ps.legsAnimTimer
+		&& !ent->client->ps.weaponTime
+		&& ent->client->ps.saberLockTime < level.time )
+	{
+		int anim = -1;
+		switch ( taunt )
+		{
+		case TAUNT_TAUNT:
+			if ( ent->client->ps.weapon != WP_SABER )
+			{
+				anim = BOTH_ENGAGETAUNT;
+			}
+			else
+			{
+				switch ( ent->client->ps.saberAnimLevel )
+				{
+				case SS_FAST:
+				case SS_TAVION:
+					if ( ent->client->ps.saber[1].Active() )
+					{//turn off second saber
+						G_Sound( ent, ent->client->ps.saber[1].soundOff );
+					}
+					else if ( ent->client->ps.saber[0].Active() )
+					{//turn off first
+						G_Sound( ent, ent->client->ps.saber[0].soundOff );
+					}
+					ent->client->ps.SaberDeactivate();
+					anim = BOTH_GESTURE1;
+					break;
+				case SS_MEDIUM:
+				case SS_STRONG:
+				case SS_DESANN:
+					anim = BOTH_ENGAGETAUNT;
+					break;
+				case SS_DUAL:
+					ent->client->ps.SaberActivate();
+					anim = BOTH_DUAL_TAUNT;
+					break;
+				case SS_STAFF:
+					ent->client->ps.SaberActivate();
+					anim = BOTH_STAFF_TAUNT;
+					break;
+				}
+			}
+			break;
+		case TAUNT_BOW:
+			anim = BOTH_BOW;
+			if ( ent->client->ps.saber[1].Active() )
+			{//turn off second saber
+				G_Sound( ent, ent->client->ps.saber[1].soundOff );
+			}
+			else if ( ent->client->ps.saber[0].Active() )
+			{//turn off first
+				G_Sound( ent, ent->client->ps.saber[0].soundOff );
+			}
+			ent->client->ps.SaberDeactivate();
+			break;
+		case TAUNT_MEDITATE:
+			anim = BOTH_MEDITATE;
+			if ( ent->client->ps.saber[1].Active() )
+			{//turn off second saber
+				G_Sound( ent, ent->client->ps.saber[1].soundOff );
+			}
+			else if ( ent->client->ps.saber[0].Active() )
+			{//turn off first
+				G_Sound( ent, ent->client->ps.saber[0].soundOff );
+			}
+			ent->client->ps.SaberDeactivate();
+			break;
+		case TAUNT_FLOURISH:
+			if ( ent->client->ps.weapon == WP_SABER )
+			{
+				ent->client->ps.SaberActivate();
+				switch ( ent->client->ps.saberAnimLevel )
+				{
+				case SS_FAST:
+				case SS_TAVION:
+					anim = BOTH_SHOWOFF_FAST;
+					break;
+				case SS_MEDIUM:
+					anim = BOTH_SHOWOFF_MEDIUM;
+					break;
+				case SS_STRONG:
+				case SS_DESANN:
+					anim = BOTH_SHOWOFF_STRONG;
+					break;
+				case SS_DUAL:
+					anim = BOTH_SHOWOFF_DUAL;
+					break;
+				case SS_STAFF:
+					anim = BOTH_SHOWOFF_STAFF;
+					break;
+				}
+			}
+			break;
+		case TAUNT_GLOAT:
+			switch ( ent->client->ps.saberAnimLevel )
+			{
+			case SS_FAST:
+			case SS_TAVION:
+				anim = BOTH_VICTORY_FAST;
+				break;
+			case SS_MEDIUM:
+				anim = BOTH_VICTORY_MEDIUM;
+				break;
+			case SS_STRONG:
+			case SS_DESANN:
+				ent->client->ps.SaberActivate();
+				anim = BOTH_VICTORY_STRONG;
+				break;
+			case SS_DUAL:
+				ent->client->ps.SaberActivate();
+				anim = BOTH_VICTORY_DUAL;
+				break;
+			case SS_STAFF:
+				ent->client->ps.SaberActivate();
+				anim = BOTH_VICTORY_STAFF;
+				break;
+			}
+			break;
+		}
+		if ( anim != -1 )
+		{
+			if ( ent->client->ps.groundEntityNum != ENTITYNUM_NONE ) 
+			{
+				int parts = SETANIM_TORSO;
+				if ( anim != BOTH_ENGAGETAUNT ) 
+				{
+					parts = SETANIM_BOTH;
+					VectorClear( ent->client->ps.velocity );
+				}
+				NPC_SetAnim( ent, parts, anim, (SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD) );
+			}
+			if ( taunt != TAUNT_MEDITATE 
+				&& taunt != TAUNT_BOW )
+			{//no sound for meditate or bow
+				G_TauntSound( ent, taunt );
+			}
+		}
+	}
+}
+/*
+=================
+ClientCommand
+=================
+*/
+void ClientCommand( int clientNum ) {
+	gentity_t *ent;
+	char	*cmd;
+
+	ent = g_entities + clientNum;
+	if ( !ent->client ) {
+		return;		// not fully in game yet
+	}
+
+	cmd = gi.argv(0);
+
+	if (Q_stricmp (cmd, "spawn") == 0)
+	{
+		Cmd_Spawn( ent );
+		return;
+	}
+	
+	if (Q_stricmp (cmd, "give") == 0)
+		Cmd_Give_f (ent);
+	else if (Q_stricmp (cmd, "god") == 0)
+		Cmd_God_f (ent);
+	else if (Q_stricmp (cmd, "undying") == 0)
+		Cmd_Undying_f (ent);
+	else if (Q_stricmp (cmd, "notarget") == 0)
+		Cmd_Notarget_f (ent);
+	else if (Q_stricmp (cmd, "noclip") == 0)
+	{
+		Cmd_Noclip_f (ent);
+	}
+	else if (Q_stricmp (cmd, "kill") == 0)
+	{
+		if ( !CheatsOk( ent ) )
+		{
+			return;
+		}
+		Cmd_Kill_f (ent);
+	}
+	else if (Q_stricmp (cmd, "levelshot") == 0)
+		Cmd_LevelShot_f (ent);
+	else if (Q_stricmp (cmd, "where") == 0)
+		Cmd_Where_f (ent);
+	else if (Q_stricmp (cmd, "setviewpos") == 0)
+		Cmd_SetViewpos_f( ent );
+	else if (Q_stricmp (cmd, "setobjective") == 0)
+		Cmd_SetObjective_f( ent );
+	else if (Q_stricmp (cmd, "viewobjective") == 0)
+		Cmd_ViewObjective_f( ent );
+	else if (Q_stricmp (cmd, "force_throw") == 0)
+	{
+		ent = G_GetSelfForPlayerCmd();
+		ForceThrow( ent, qfalse );
+	}
+	else if (Q_stricmp (cmd, "force_pull") == 0)
+	{
+		ent = G_GetSelfForPlayerCmd();
+		ForceThrow( ent, qtrue );
+	}
+	else if (Q_stricmp (cmd, "force_speed") == 0)
+	{
+		ent = G_GetSelfForPlayerCmd();
+		ForceSpeed( ent );
+	}
+	else if (Q_stricmp (cmd, "force_heal") == 0)
+	{
+		ent = G_GetSelfForPlayerCmd();
+		ForceHeal( ent );
+	}
+	else if (Q_stricmp (cmd, "force_grip") == 0)
+	{
+		ent = G_GetSelfForPlayerCmd();
+		ForceGrip( ent );
+	}
+	else if (Q_stricmp (cmd, "force_distract") == 0)
+	{
+		ent = G_GetSelfForPlayerCmd();
+		ForceTelepathy( ent );
+	}
+	else if (Q_stricmp (cmd, "force_rage") == 0)
+	{
+		ent = G_GetSelfForPlayerCmd();
+		ForceRage(ent);
+	}
+	else if (Q_stricmp (cmd, "force_protect") == 0)
+	{
+		ent = G_GetSelfForPlayerCmd();
+		ForceProtect(ent);
+	}
+	else if (Q_stricmp (cmd, "force_absorb") == 0)
+	{
+		ent = G_GetSelfForPlayerCmd();
+		ForceAbsorb(ent);
+	}
+	else if (Q_stricmp (cmd, "force_sight") == 0)
+	{
+		ent = G_GetSelfForPlayerCmd();
+		ForceSeeing(ent);
+	}
+	else if (Q_stricmp (cmd, "addsaberstyle") == 0)
+	{
+		ent = G_GetSelfForPlayerCmd();
+		if ( !ent || !ent->client )
+		{//wtf?
+			return;
+		}
+		if ( gi.argc() < 2 )
+		{
+			gi.SendServerCommand( ent-g_entities, va("print \"usage: addsaberstyle <saber style>\n\""));
+			gi.SendServerCommand( ent-g_entities, va("print \"Valid styles: SS_FAST, SS_MEDIUM, SS_STRONG, SS_DESANN, SS_TAVION, SS_DUAL and SS_STAFF\n\""));
+			return;
+		}
+
+		int addStyle = GetIDForString( SaberStyleTable, gi.argv(1) );
+		if ( addStyle > SS_NONE && addStyle < SS_STAFF )
+		{
+			ent->client->ps.saberStylesKnown |= (1<<addStyle);
+		}
+	}
+	else if (Q_stricmp (cmd, "setsaberstyle") == 0)
+	{
+		ent = G_GetSelfForPlayerCmd();
+		if ( !ent || !ent->client )
+		{//wtf?
+			return;
+		}
+		if ( gi.argc() < 2 )
+		{
+			gi.SendServerCommand( ent-g_entities, va("print \"usage: setsaberstyle <saber style>\n\""));
+			gi.SendServerCommand( ent-g_entities, va("print \"Valid styles: SS_FAST, SS_MEDIUM, SS_STRONG, SS_DESANN, SS_TAVION, SS_DUAL and SS_STAFF\n\""));
+			return;
+		}
+
+		int setStyle = GetIDForString( SaberStyleTable, gi.argv(1) );
+		if ( setStyle > SS_NONE && setStyle < SS_STAFF )
+		{
+			ent->client->ps.saberStylesKnown = (1<<setStyle);
+			cg.saberAnimLevelPending = ent->client->ps.saberAnimLevel = setStyle;
+		}
+	}
+	else if (Q_stricmp (cmd, "taunt") == 0)
+	{
+		ent = G_GetSelfForPlayerCmd();
+//		G_Taunt( ent );
+		G_SetTauntAnim( ent, TAUNT_TAUNT );
+	}
+	else if (Q_stricmp (cmd, "bow") == 0)
+	{
+		ent = G_GetSelfForPlayerCmd();
+		G_SetTauntAnim( ent, TAUNT_BOW );
+	}
+	else if (Q_stricmp (cmd, "meditate") == 0)
+	{
+		ent = G_GetSelfForPlayerCmd();
+		G_SetTauntAnim( ent, TAUNT_MEDITATE );
+	}
+	else if (Q_stricmp (cmd, "flourish") == 0)
+	{
+		ent = G_GetSelfForPlayerCmd();
+		G_SetTauntAnim( ent, TAUNT_FLOURISH );
+	}
+	else if (Q_stricmp (cmd, "gloat") == 0)
+	{
+		ent = G_GetSelfForPlayerCmd();
+		G_SetTauntAnim( ent, TAUNT_GLOAT );
+	}
+	/*
+	else if (Q_stricmp (cmd, "drive") == 0)
+	{
+		if ( !CheatsOk( ent ) )
+		{
+			return;
+		}
+		if ( gi.argc() < 2 )
+		{
+			gi.SendServerCommand( ent-g_entities, va("print \"usage: drive <vehicle name>\n\""));
+			gi.SendServerCommand( ent-g_entities, va("print \"Vehicles will be in vehicles.cfg, try using 'speeder' for now\n\""));
+			return;
+		}
+		G_DriveVehicle( ent, NULL, gi.argv(1) );
+	}
+	*/
+	else if (Q_stricmp (cmd, "NPCdrive") == 0)
+	{
+		if ( !CheatsOk( ent ) )
+		{
+			return;
+		}
+		if ( gi.argc() < 3 )
+		{
+			gi.SendServerCommand( ent-g_entities, va("print \"usage: drive <NPC_targetname> <vehicle name>\n\""));
+			gi.SendServerCommand( ent-g_entities, va("print \"Vehicles will be in vehicles.cfg, try using 'speeder' for now\n\""));
+			return;
+		}
+		gentity_t *found = G_Find( NULL, FOFS(targetname), gi.argv(1) );
+		if ( found && found->health > 0 && found->client )
+		{
+			// TEMPORARY! BRING BACK LATER!!!
+			//G_DriveVehicle( found, NULL, gi.argv(2) );
+		}
+	}
+	else if (Q_stricmp (cmd, "thereisnospoon") == 0)
+		G_StartMatrixEffect( ent );
+	else if (Q_stricmp (cmd, "use_electrobinoculars") == 0)
+		Cmd_UseElectrobinoculars_f( ent );
+	else if (Q_stricmp (cmd, "use_bacta") == 0)
+		Cmd_UseBacta_f( ent );
+	else if (Q_stricmp (cmd, "use_seeker") == 0)
+		Cmd_UseSeeker_f( ent );
+	else if (Q_stricmp (cmd, "use_lightamp_goggles") == 0)
+		Cmd_UseGoggles_f( ent );
+	else if (Q_stricmp (cmd, "use_sentry") == 0)
+		Cmd_UseSentry_f( ent );
+	else if (Q_stricmp (cmd, "fx") == 0)
+		Cmd_Fx( ent );
+	else if (Q_stricmp (cmd, "invuse") == 0)
+	{
+		Cmd_UseInventory_f( ent );
+	}
+	else if (Q_stricmp (cmd, "playmusic") == 0)
+	{
+		char *cmd2 = gi.argv(1);
+		if ( cmd2 )
+		{
+			gi.SetConfigstring( CS_MUSIC, cmd2 );
+		}
+	}
+	else if (Q_stricmp (cmd, "flushcam") == 0)
+	{
+		Cmd_FlushCamFile_f( ent );
+	}
+}
diff --git a/code/game/g_combat.cpp b/code/game/g_combat.cpp
new file mode 100644
index 0000000..6e17709
--- /dev/null
+++ b/code/game/g_combat.cpp
@@ -0,0 +1,6945 @@
+// g_combat.c
+
+// leave this line at the top for all g_xxxx.cpp files...
+#include "g_headers.h"
+
+
+
+
+#include "g_local.h"
+#include "b_local.h"
+#include "g_functions.h"
+#include "anims.h"
+#include "objectives.h"
+#include "../cgame/cg_local.h"
+#include "wp_saber.h"
+#include "g_vehicles.h"
+#include "Q3_Interface.h"
+
+#define TURN_OFF			0x00000100
+
+extern qboolean Rosh_TwinPresent( gentity_t *self );
+extern void G_CheckCharmed( gentity_t *self );
+extern qboolean Wampa_CheckDropVictim( gentity_t *self, qboolean excludeMe );
+
+extern	cvar_t	*g_debugDamage;
+extern qboolean	stop_icarus;
+extern cvar_t	*g_dismemberment;
+extern cvar_t	*g_saberRealisticCombat;
+extern cvar_t		*g_timescale;
+extern cvar_t		*d_slowmodeath;
+extern gentity_t *player;
+
+gentity_t *g_lastClientDamaged;
+
+extern int killPlayerTimer;
+
+extern void G_VehicleStartExplosionDelay( gentity_t *self );
+extern void NPC_TempLookTarget ( gentity_t *self, int lookEntNum, int minLookTime, int maxLookTime );
+extern void G_AddVoiceEvent( gentity_t *self, int event, int speakDebounceTime );
+extern qboolean PM_HasAnimation( gentity_t *ent, int animation );
+extern qboolean G_TeamEnemy( gentity_t *self );
+extern void CG_ChangeWeapon( int num );
+extern void ChangeWeapon( gentity_t *ent, int newWeapon );
+
+extern void G_SetEnemy( gentity_t *self, gentity_t *enemy );
+extern void PM_SetLegsAnimTimer( gentity_t *ent, int *legsAnimTimer, int time );
+extern void PM_SetTorsoAnimTimer( gentity_t *ent, int *torsoAnimTimer, int time );
+extern int PM_PickAnim( gentity_t *self, int minAnim, int maxAnim );
+extern qboolean PM_InOnGroundAnim ( playerState_t *ps );
+extern void G_ATSTCheckPain( gentity_t *self, gentity_t *other, const vec3_t point, int damage, int mod,int hitLoc );
+extern qboolean Jedi_WaitingAmbush( gentity_t *self );
+extern qboolean G_ClearViewEntity( gentity_t *ent );
+extern qboolean PM_CrouchAnim( int anim );
+extern qboolean PM_InKnockDown( playerState_t *ps );
+extern qboolean PM_InRoll( playerState_t *ps );
+extern qboolean PM_SpinningAnim( int anim );
+extern qboolean PM_RunningAnim( int anim );
+extern int PM_PowerLevelForSaberAnim( playerState_t *ps, int saberNum = 0 );
+extern qboolean PM_SaberInSpecialAttack( int anim );
+extern qboolean PM_SpinningSaberAnim( int anim );
+extern qboolean PM_FlippingAnim( int anim );
+extern qboolean PM_InSpecialJump( int anim );
+extern qboolean PM_RollingAnim( int anim );
+extern qboolean PM_InAnimForSaberMove( int anim, int saberMove );
+extern qboolean PM_SaberInStart( int move );
+extern qboolean PM_SaberInReturn( int move );
+extern int PM_AnimLength( int index, animNumber_t anim );
+extern qboolean PM_LockedAnim( int anim );
+extern qboolean PM_KnockDownAnim( int anim );
+extern void G_SpeechEvent( gentity_t *self, int event );
+extern qboolean Rosh_BeingHealed( gentity_t *self );
+
+static int G_CheckForLedge( gentity_t *self, vec3_t fallCheckDir, float checkDist );
+static int G_CheckSpecialDeathAnim( gentity_t *self, vec3_t point, int damage, int mod, int hitLoc );
+static int G_PickDeathAnim( gentity_t *self, vec3_t point, int damage, int mod, int hitLoc );
+static void G_TrackWeaponUsage( gentity_t *self, gentity_t *inflictor, int add, int mod );
+static qboolean G_Dismemberable( gentity_t *self, int hitLoc );
+extern gitem_t	*FindItemForAmmo( ammo_t ammo );
+
+
+qboolean G_GetRootSurfNameWithVariant( gentity_t *ent, const char *rootSurfName, char *returnSurfName, int returnSize );
+/*
+============
+AddScore
+
+Adds score to both the client and his team
+============
+*/
+void AddScore( gentity_t *ent, int score ) {
+	if ( !ent->client ) {
+		return;
+	}
+	// no scoring during pre-match warmup
+	ent->client->ps.persistant[PERS_SCORE] += score;
+}
+
+/*
+=================
+TossClientItems
+
+Toss the weapon and powerups for the killed player
+=================
+*/
+extern gentity_t *WP_DropThermal( gentity_t *ent );
+extern qboolean WP_SaberLose( gentity_t *self, vec3_t throwDir );
+gentity_t *TossClientItems( gentity_t *self ) 
+{
+	//FIXME: drop left-hand weapon, too?
+	gentity_t	*dropped = NULL;
+	gitem_t		*item = NULL;
+	int			weapon;
+
+	if ( self->client->NPC_class == CLASS_SEEKER 
+		|| self->client->NPC_class == CLASS_REMOTE
+		|| self->client->NPC_class == CLASS_SABER_DROID
+		|| self->client->NPC_class == CLASS_VEHICLE
+		|| self->client->NPC_class == CLASS_ATST)
+	{
+		// these things are so small that they shouldn't bother throwing anything
+		return NULL;
+	}
+
+	// drop the weapon if not a saber or enemy-only weapon
+	weapon = self->s.weapon;
+	if ( weapon == WP_SABER )
+	{
+		if ( self->weaponModel[0] < 0 || (self->client->ps.saber[0].disarmable && WP_SaberLose( self, NULL )) )
+		{
+			self->s.weapon = WP_NONE;
+		}
+	}
+	else if ( weapon == WP_BLASTER_PISTOL )
+	{//FIXME: either drop the pistol and make the pickup only give ammo or drop ammo
+	}
+	else if ( weapon == WP_STUN_BATON
+		|| weapon == WP_MELEE )
+	{//never drop these
+	}
+	else if ( weapon > WP_SABER && weapon <= MAX_PLAYER_WEAPONS )//&& self->client->ps.ammo[ weaponData[weapon].ammoIndex ]
+	{
+		self->s.weapon = WP_NONE;
+
+		if ( weapon == WP_THERMAL && self->client->ps.torsoAnim == BOTH_ATTACK10 )
+		{//we were getting ready to throw the thermal, drop it! 
+			self->client->ps.weaponChargeTime = level.time - FRAMETIME;//so it just kind of drops it
+			dropped = WP_DropThermal( self );
+		}
+		else
+		{// find the item type for this weapon
+			item = FindItemForWeapon( (weapon_t) weapon );
+		}
+		if ( item && !dropped )
+		{
+			// spawn the item
+			dropped = Drop_Item( self, item, 0, qtrue );
+			//TEST: dropped items never go away
+			dropped->e_ThinkFunc = thinkF_NULL;
+			dropped->nextthink = -1;
+
+			if ( !self->s.number )
+			{//player's dropped items never go away
+				//dropped->e_ThinkFunc = thinkF_NULL;
+				//dropped->nextthink = -1;
+				dropped->count = 0;//no ammo
+			}
+			else
+			{//FIXME: base this on the NPC's actual amount of ammo he's used up... 
+				switch ( weapon )
+				{
+				case WP_BRYAR_PISTOL:
+				case WP_BLASTER_PISTOL:
+					dropped->count = 20;
+					break;
+				case WP_BLASTER:
+					dropped->count = 15;
+					break;
+				case WP_DISRUPTOR:
+					dropped->count = 20;
+					break;
+				case WP_BOWCASTER:
+					dropped->count = 5;
+					break;
+				case WP_REPEATER:
+					dropped->count = 20;
+					break;
+				case WP_DEMP2:
+					dropped->count = 10;
+					break;
+				case WP_FLECHETTE:
+					dropped->count = 30;
+					break;
+				case WP_ROCKET_LAUNCHER:
+					dropped->count = 3;
+					break;
+				case WP_CONCUSSION:
+					dropped->count = 200;//12;
+					break;
+				case WP_THERMAL:
+					dropped->count = 4;
+					break;
+				case WP_TRIP_MINE:
+					dropped->count = 3;
+					break;
+				case WP_DET_PACK:
+					dropped->count = 1;
+					break;
+				case WP_STUN_BATON:
+					dropped->count = 20;
+					break;
+				default:
+					dropped->count = 0;
+					break;
+				}
+			}
+			// well, dropped weapons are G2 models, so they have to be initialised if they want to draw..give us a radius so we don't get prematurely culled
+			if ( weapon != WP_THERMAL
+				&& weapon != WP_TRIP_MINE
+				&& weapon != WP_DET_PACK )
+			{
+				gi.G2API_InitGhoul2Model( dropped->ghoul2, item->world_model, G_ModelIndex( item->world_model ));
+				dropped->s.radius = 10;
+			}
+		}
+	}
+//	else if (( self->client->NPC_class == CLASS_SENTRY ) || ( self->client->NPC_class == CLASS_PROBE )) // Looks dumb, Steve told us to take it out.
+//	{
+//		item = FindItemForAmmo( AMMO_BLASTER ); 
+//		Drop_Item( self, item, 0, qtrue );
+//	}
+	else if ( self->client->NPC_class == CLASS_MARK1 ) 
+	{
+
+		if (Q_irand( 1, 2 )>1)
+		{
+			item = FindItemForAmmo( AMMO_METAL_BOLTS );
+		}
+		else
+		{
+			item = FindItemForAmmo( AMMO_BLASTER );
+		}
+		Drop_Item( self, item, 0, qtrue );
+	}
+	else if ( self->client->NPC_class == CLASS_MARK2 ) 
+	{
+
+		if (Q_irand( 1, 2 )>1)
+		{
+			item = FindItemForAmmo( AMMO_METAL_BOLTS );
+		}
+		else
+		{
+			item = FindItemForAmmo( AMMO_POWERCELL );
+		}
+		Drop_Item( self, item, 0, qtrue );
+	}
+
+	return dropped;//NOTE: presumes only drop one thing
+}
+
+void G_DropKey( gentity_t *self )
+{//drop whatever security key I was holding
+	gitem_t		*item = NULL;
+	if ( !Q_stricmp( "goodie", self->message ) )
+	{
+		item = FindItemForInventory( INV_GOODIE_KEY );
+	}
+	else
+	{
+		item = FindItemForInventory( INV_SECURITY_KEY );
+	}
+	gentity_t	*dropped = Drop_Item( self, item, 0, qtrue );
+	//Don't throw the key
+	VectorClear( dropped->s.pos.trDelta );
+	dropped->message = self->message;
+	self->message = NULL;
+}
+
+void ObjectDie (gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int meansOfDeath )
+{
+	if(self->target)
+		G_UseTargets(self, attacker);
+
+	//remove my script_targetname
+	G_FreeEntity( self );
+}
+/*
+==================
+ExplodeDeath
+==================
+*/
+
+//FIXME: all hacked up...
+
+//void CG_SurfaceExplosion( vec3_t origin, vec3_t normal, float radius, float shake_speed, qboolean smoke );
+void ExplodeDeath( gentity_t *self ) 
+{
+//	gentity_t	*tent;
+	vec3_t		forward;
+
+	self->takedamage = qfalse;//stop chain reaction runaway loops
+
+	self->s.loopSound = 0;
+
+	VectorCopy( self->currentOrigin, self->s.pos.trBase );
+
+//	tent = G_TempEntity( self->s.origin, EV_FX_EXPLOSION );
+	AngleVectors(self->s.angles, forward, NULL, NULL);  // FIXME: letting effect always shoot up?  Might be ok.
+
+	if ( self->fxID > 0 )
+	{
+		G_PlayEffect( self->fxID, self->currentOrigin, forward );
+	}
+//	else
+//	{
+//		CG_SurfaceExplosion( self->currentOrigin, forward, 20.0f, 12.0f, ((self->spawnflags&4)==qfalse) );	//FIXME: This needs to be consistent to all exploders!
+//		G_Sound(self, self->sounds );
+//	}
+	
+	if(self->splashDamage > 0 && self->splashRadius > 0)
+	{
+		gentity_t *attacker = self;
+		if ( self->owner )
+		{
+			attacker = self->owner;
+		}
+		G_RadiusDamage( self->currentOrigin, attacker, self->splashDamage, self->splashRadius, 
+				attacker, MOD_UNKNOWN );
+	}
+
+	ObjectDie( self, self, self, 20, 0 );
+}
+
+void ExplodeDeath_Wait( gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int meansOfDeath,int dFlags,int hitLoc ) 
+{
+	self->e_DieFunc = dieF_NULL;
+	self->nextthink = level.time + Q_irand(100, 500);
+	self->e_ThinkFunc = thinkF_ExplodeDeath;
+}
+
+void ExplodeDeath( gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int meansOfDeath,int dFlags,int hitLoc ) 
+{
+	self->currentOrigin[2] += 16; // me bad for hacking this.  should either do it in the effect file or make a custom explode death??
+	ExplodeDeath( self );
+}
+
+void GoExplodeDeath( gentity_t *self, gentity_t *other, gentity_t *activator) 
+{
+	G_ActivateBehavior(self,BSET_USE);
+
+	self->targetname = NULL;	//Make sure this entity cannot be told to explode again (recursive death fix)
+
+	ExplodeDeath( self );
+}
+
+qboolean G_ActivateBehavior (gentity_t *self, int bset );
+void G_CheckVictoryScript(gentity_t *self)
+{
+	if ( !G_ActivateBehavior( self, BSET_VICTORY ) )
+	{
+		if ( self->NPC && self->s.weapon == WP_SABER )
+		{//Jedi taunt from within their AI
+			self->NPC->blockedSpeechDebounceTime = 0;//get them ready to taunt
+			return;
+		}
+		if ( self->client && self->client->NPC_class == CLASS_GALAKMECH )
+		{
+			self->wait = 1;
+			TIMER_Set( self, "gloatTime", Q_irand( 5000, 8000 ) );
+			self->NPC->blockedSpeechDebounceTime = 0;//get him ready to taunt
+			return;
+		}
+		//FIXME: any way to not say this *right away*?  Wait for victim's death anim/scream to finish?
+		if ( self->NPC && self->NPC->group && self->NPC->group->commander && self->NPC->group->commander->NPC && self->NPC->group->commander->NPC->rank > self->NPC->rank && !Q_irand( 0, 2 ) )
+		{//sometimes have the group commander speak instead
+			self->NPC->group->commander->NPC->greetingDebounceTime = level.time + Q_irand( 2000, 5000 );
+			//G_AddVoiceEvent( self->NPC->group->commander, Q_irand(EV_VICTORY1, EV_VICTORY3), 2000 );
+		}
+		else if ( self->NPC )
+		{
+			self->NPC->greetingDebounceTime = level.time + Q_irand( 2000, 5000 );
+			//G_AddVoiceEvent( self, Q_irand(EV_VICTORY1, EV_VICTORY3), 2000 );
+		}
+	}
+}
+
+qboolean OnSameTeam( gentity_t *ent1, gentity_t *ent2 )
+{
+	if ( ent1->s.number < MAX_CLIENTS
+		&& ent1->client
+		&& ent1->client->playerTeam == TEAM_FREE )
+	{//evil player *has* no allies
+		return qfalse;
+	}
+	if ( ent2->s.number < MAX_CLIENTS
+		&& ent2->client
+		&& ent2->client->playerTeam == TEAM_FREE )
+	{//evil player *has* no allies
+		return qfalse;
+	}
+	if ( !ent1->client || !ent2->client )
+	{
+		if ( ent1->noDamageTeam )
+		{
+			if ( ent2->client && ent2->client->playerTeam == ent1->noDamageTeam )
+			{
+				return qtrue;
+			}
+			else if ( ent2->noDamageTeam == ent1->noDamageTeam )
+			{
+				if ( ent1->splashDamage && ent2->splashDamage && Q_stricmp("ambient_etherian_fliers", ent1->classname) != 0 )
+				{//Barrels, exploding breakables and mines will blow each other up
+					return qfalse;
+				}
+				else
+				{
+					return qtrue;
+				}
+			}
+		}
+		return qfalse;
+	}
+
+	// shouldn't need this anymore, there were problems with certain droids, but now they have been labeled TEAM_ENEMY so this isn't needed
+//	if ((( ent1->client->playerTeam == TEAM_IMPERIAL ) && ( ent1->client->playerTeam == TEAM_BOTS )) ||
+//		(( ent1->client->playerTeam == TEAM_BOTS ) && ( ent1->client->playerTeam == TEAM_IMPERIAL )))
+//	{
+//		return qtrue;
+//	}
+
+	return ( ent1->client->playerTeam == ent2->client->playerTeam );
+}
+
+
+/*
+-------------------------
+G_AlertTeam
+-------------------------
+*/
+
+void G_AlertTeam( gentity_t *victim, gentity_t *attacker, float radius, float soundDist )
+{
+	gentity_t	*radiusEnts[ 128 ];
+	vec3_t		mins, maxs;
+	int			numEnts;
+	float		distSq, sndDistSq = (soundDist*soundDist);
+
+	if ( attacker == NULL || attacker->client == NULL )
+		return;
+
+	//Setup the bbox to search in
+	for ( int i = 0; i < 3; i++ )
+	{
+		mins[i] = victim->currentOrigin[i] - radius;
+		maxs[i] = victim->currentOrigin[i] + radius;
+	}
+
+	//Get the number of entities in a given space
+	numEnts = gi.EntitiesInBox( mins, maxs, radiusEnts, 128 );
+
+	//Cull this list
+	for ( i = 0; i < numEnts; i++ )
+	{
+		//Validate clients
+		if ( radiusEnts[i]->client == NULL )
+			continue;
+
+		//only want NPCs
+		if ( radiusEnts[i]->NPC == NULL )
+			continue;
+
+		//Don't bother if they're ignoring enemies
+		if ( radiusEnts[i]->svFlags & SVF_IGNORE_ENEMIES )
+			continue;
+
+		//This NPC specifically flagged to ignore alerts
+		if ( radiusEnts[i]->NPC->scriptFlags & SCF_IGNORE_ALERTS )
+			continue;
+
+		//This NPC specifically flagged to ignore alerts
+		if ( !(radiusEnts[i]->NPC->scriptFlags&SCF_LOOK_FOR_ENEMIES) )
+			continue;
+
+		//this ent does not participate in group AI
+		if ( (radiusEnts[i]->NPC->scriptFlags&SCF_NO_GROUPS) )
+			continue;
+
+		//Skip the requested avoid radiusEnts[i] if present
+		if ( radiusEnts[i] == victim )
+			continue;
+
+		//Skip the attacker
+		if ( radiusEnts[i] == attacker )
+			continue;
+
+		//Must be on the same team
+		if ( radiusEnts[i]->client->playerTeam != victim->client->playerTeam )
+			continue;
+
+		//Must be alive
+		if ( radiusEnts[i]->health <= 0 )
+			continue;
+
+		if ( radiusEnts[i]->enemy == NULL )
+		{//only do this if they're not already mad at someone
+			distSq = DistanceSquared( radiusEnts[i]->currentOrigin, victim->currentOrigin );
+			if ( distSq > 16384 /*128 squared*/ && !gi.inPVS( victim->currentOrigin, radiusEnts[i]->currentOrigin ) )
+			{//not even potentially visible/hearable
+				continue;
+			}
+			//NOTE: this allows sound alerts to still go through doors/PVS if the teammate is within 128 of the victim...
+			if ( soundDist <= 0 || distSq > sndDistSq )
+			{//out of sound range
+				if ( !InFOV( victim, radiusEnts[i], radiusEnts[i]->NPC->stats.hfov, radiusEnts[i]->NPC->stats.vfov ) 
+					||  !NPC_ClearLOS( radiusEnts[i], victim->currentOrigin ) )
+				{//out of FOV or no LOS
+					continue;
+				}
+			}
+
+			//FIXME: This can have a nasty cascading effect if setup wrong...
+			G_SetEnemy( radiusEnts[i], attacker );
+		}
+	}
+}
+
+/*
+-------------------------
+G_DeathAlert
+-------------------------
+*/
+
+#define	DEATH_ALERT_RADIUS			512
+#define	DEATH_ALERT_SOUND_RADIUS	512
+
+void G_DeathAlert( gentity_t *victim, gentity_t *attacker )
+{//FIXME: with all the other alert stuff, do we really need this?
+	G_AlertTeam( victim, attacker, DEATH_ALERT_RADIUS, DEATH_ALERT_SOUND_RADIUS );
+}
+
+/*
+----------------------------------------
+DeathFX
+
+Applies appropriate special effects that occur while the entity is dying
+Not to be confused with NPC_RemoveBodyEffects (NPC.cpp), which only applies effect when removing the body
+----------------------------------------
+*/
+
+void DeathFX( gentity_t *ent )
+{
+	if ( !ent || !ent->client )
+		return;
+/*
+	switch( ent->client->playerTeam )
+	{
+	case TEAM_BOTS:
+		if (!Q_stricmp( ent->NPC_type, "mouse" ))
+		{
+			vec3_t		effectPos;
+			VectorCopy( ent->currentOrigin, effectPos );
+			effectPos[2] -= 20;
+
+			G_PlayEffect( "mouseexplosion1", effectPos );
+			G_PlayEffect( "smaller_chunks", effectPos );
+
+		}
+		else if (!Q_stricmp( ent->NPC_type, "probe" ))
+		{
+			vec3_t		effectPos;
+			VectorCopy( ent->currentOrigin, effectPos );
+			effectPos[2] += 50;
+
+			G_PlayEffect( "probeexplosion1", effectPos );
+			G_PlayEffect( "small_chunks", effectPos );
+		}
+		else
+		{
+			vec3_t		effectPos;
+			VectorCopy( ent->currentOrigin, effectPos );
+			effectPos[2] -= 15;
+			G_PlayEffect( "droidexplosion1", effectPos );
+			G_PlayEffect( "small_chunks", effectPos );
+		}
+
+		break;
+
+	default:
+		break;
+	}
+*/
+	// team no longer indicates species/race.  NPC_class should be used to identify certain npc types
+	vec3_t		effectPos, right;
+	switch(ent->client->NPC_class)
+	{
+	case CLASS_MOUSE:
+		VectorCopy( ent->currentOrigin, effectPos );
+		effectPos[2] -= 20;
+		G_PlayEffect( "env/small_explode", effectPos );
+		G_SoundOnEnt( ent, CHAN_AUTO, "sound/chars/mouse/misc/death1" );
+		break;
+
+	case CLASS_PROBE:
+		VectorCopy( ent->currentOrigin, effectPos );
+		effectPos[2] += 50;
+		G_PlayEffect( "explosions/probeexplosion1", effectPos );
+		break;
+		
+	case CLASS_ATST: 
+		AngleVectors( ent->currentAngles, NULL, right, NULL );
+		VectorMA( ent->currentOrigin, 20, right, effectPos );
+		effectPos[2] += 180;
+		G_PlayEffect( "explosions/droidexplosion1", effectPos );
+		VectorMA( effectPos, -40, right, effectPos );
+		G_PlayEffect( "explosions/droidexplosion1", effectPos );
+		break;
+
+	case CLASS_SEEKER:
+	case CLASS_REMOTE:
+		G_PlayEffect( "env/small_explode", ent->currentOrigin );
+		break;
+
+	case CLASS_GONK:
+		VectorCopy( ent->currentOrigin, effectPos );
+		effectPos[2] -= 5;
+//		statusTextIndex = Q_irand( IGT_RESISTANCEISFUTILE, IGT_NAMEIS8OF12 );
+		G_SoundOnEnt( ent, CHAN_AUTO, va("sound/chars/gonk/misc/death%d.wav",Q_irand( 1, 3 )) );
+		G_PlayEffect( "env/med_explode", effectPos );
+		break;
+
+	// should list all remaining droids here, hope I didn't miss any
+	case CLASS_R2D2:
+		VectorCopy( ent->currentOrigin, effectPos );
+		effectPos[2] -= 10;
+		G_PlayEffect( "env/med_explode", effectPos );
+		G_SoundOnEnt( ent, CHAN_AUTO, "sound/chars/mark2/misc/mark2_explo" );
+		break;
+
+	case CLASS_PROTOCOL://??
+	case CLASS_R5D2:
+		VectorCopy( ent->currentOrigin, effectPos );
+		effectPos[2] -= 10;
+		G_PlayEffect( "env/med_explode", effectPos );
+		G_SoundOnEnt( ent, CHAN_AUTO, "sound/chars/mark2/misc/mark2_explo" );
+		break;
+
+	case CLASS_MARK2:
+		VectorCopy( ent->currentOrigin, effectPos );
+		effectPos[2] -= 15;
+		G_PlayEffect( "explosions/droidexplosion1", effectPos );
+		G_SoundOnEnt( ent, CHAN_AUTO, "sound/chars/mark2/misc/mark2_explo" );
+		break;
+
+	case CLASS_INTERROGATOR:
+		VectorCopy( ent->currentOrigin, effectPos );
+		effectPos[2] -= 15;
+		G_PlayEffect( "explosions/droidexplosion1", effectPos );
+		G_SoundOnEnt( ent, CHAN_AUTO, "sound/chars/interrogator/misc/int_droid_explo" );
+		break;
+
+	case CLASS_MARK1:
+		AngleVectors( ent->currentAngles, NULL, right, NULL );
+		VectorMA( ent->currentOrigin, 10, right, effectPos );
+		effectPos[2] -= 15;
+		G_PlayEffect( "explosions/droidexplosion1", effectPos );
+		VectorMA( effectPos, -20, right, effectPos );
+		G_PlayEffect( "explosions/droidexplosion1", effectPos );
+		VectorMA( effectPos, -20, right, effectPos );
+		G_PlayEffect( "explosions/droidexplosion1", effectPos );
+		G_SoundOnEnt( ent, CHAN_AUTO, "sound/chars/mark1/misc/mark1_explo" );
+		break;
+
+	case CLASS_SENTRY:
+		G_SoundOnEnt( ent, CHAN_AUTO, "sound/chars/sentry/misc/sentry_explo" );
+		VectorCopy( ent->currentOrigin, effectPos );
+		G_PlayEffect( "env/med_explode", effectPos );
+		break;
+
+	default:
+		break;
+
+	}
+
+}
+
+void G_SetMissionStatusText( gentity_t *attacker, int mod )
+{
+	if ( statusTextIndex >= 0 )
+	{
+		return;
+	}
+
+	if ( mod == MOD_FALLING )
+	{//fell to your death
+		statusTextIndex = STAT_WATCHYOURSTEP;
+	}
+	else if ( mod == MOD_CRUSH )
+	{//crushed
+		statusTextIndex = STAT_JUDGEMENTMUCHDESIRED;
+	}
+	// borg no longer exist
+//	else if ( attacker && attacker->client && attacker->client->playerTeam == TEAM_BORG )
+//	{//assimilated
+//		statusTextIndex = Q_irand( IGT_RESISTANCEISFUTILE, IGT_NAMEIS8OF12 );
+//	}
+	else if ( attacker && Q_stricmp( "trigger_hurt", attacker->classname ) == 0 )
+	{//Killed by something that should have been clearly dangerous
+//		statusTextIndex = Q_irand( IGT_JUDGEMENTDESIRED, IGT_JUDGEMENTMUCHDESIRED );
+		statusTextIndex = STAT_JUDGEMENTMUCHDESIRED;
+	}
+	else if ( attacker && attacker->s.number != 0 && attacker->client && attacker->client->playerTeam == TEAM_PLAYER )
+	{//killed by a teammate
+		statusTextIndex = STAT_INSUBORDINATION;
+	}
+	/*
+	else if ()
+	{//killed a teammate- note: handled above
+		if ( Q_irand( 0, 1 ) )
+		{
+			statusTextIndex = IGT_YOUCAUSEDDEATHOFTEAMMATE;
+		}
+		else
+		{
+			statusTextIndex = IGT_KILLEDANINNOCENTCREWMAN;
+		}
+	}
+	else
+	{
+		//This next block is not contiguous
+		IGT_INADEQUATE,
+		IGT_RESPONSETIME,
+		IGT_SHOOTINRANGE,
+		IGT_TRYAGAIN,
+		IGT_TRAINONHOLODECK,
+		IGT_WHATCOLORSHIRT,
+		IGT_NOTIMPRESS7OF9,
+		IGT_NEELIXFAREDBETTER,
+		IGT_THATMUSTHURT,
+		IGT_TUVOKDISAPPOINTED,
+		IGT_STARFLEETNOTIFYFAMILY,
+		IGT_TEAMMATESWILLMISSYOU,
+		IGT_LESSTHANEXEMPLARY,
+		IGT_SACRIFICEDFORTHEWHOLE,
+		IGT_NOTLIVELONGANDPROSPER,
+		IGT_BETTERUSEOFSIMULATIONS,
+	}
+	*/
+
+	/*
+	//These can be set by designers
+	IGT_INSUBORDINATION,
+	IGT_YOUCAUSEDDEATHOFTEAMMATE,
+	IGT_DIDNTPROTECTTECH,
+	IGT_DIDNTPROTECT7OF9,
+	IGT_NOTSTEALTHYENOUGH,
+	IGT_STEALTHTACTICSNECESSARY,
+	*/
+}
+
+void G_MakeTeamVulnerable( void )
+{
+	int i, newhealth;
+	gentity_t *ent;
+	gentity_t *self = &g_entities[0];
+	if ( !self->client )
+	{
+		return;
+	}
+
+//	for ( i = 0; i < globals.num_entities ; i++, ent++) 
+	for ( i = 0; i < globals.num_entities ; i++) 
+	{
+		if(!PInUse(i))
+			continue;
+//		if ( !ent->inuse  )
+//		{
+//			continue;
+//		}
+//		if ( !ent )
+//		{
+//			continue;
+//		}
+		ent=&g_entities[i];
+		if ( !ent->client  )
+		{
+			continue;
+		}
+		if ( ent->client->playerTeam != TEAM_PLAYER )
+		{
+			continue;
+		}
+		if ( !(ent->flags&FL_UNDYING) )
+		{
+			continue;
+		}
+		ent->flags &= ~FL_UNDYING;
+		newhealth = Q_irand( 5, 40 );
+		if ( ent->health > newhealth )
+		{
+			ent->health = newhealth;
+		}
+	}
+}
+
+void G_StartMatrixEffect( gentity_t *ent, int meFlags = 0, int length = 1000, float timeScale = 0.0f, int spinTime = 0 )
+{
+	//FIXME: allow them to specify a different focal entity or point?
+	if ( g_timescale->value != 1.0 || in_camera )
+	{//already in some slow-mo mode or in_camera
+		return;
+	}
+
+	gentity_t	*matrix = G_Spawn();
+	if ( matrix )
+	{
+		G_SetOrigin( matrix, ent->currentOrigin );
+		gi.linkentity( matrix );
+		matrix->s.otherEntityNum = ent->s.number;
+		matrix->e_clThinkFunc = clThinkF_CG_MatrixEffect;
+		matrix->s.eType = ET_THINKER;
+		matrix->svFlags |= SVF_BROADCAST;// Broadcast to all clients
+		matrix->s.time = level.time;
+		matrix->s.eventParm = length;
+		//now the cgame decides when to remove us... in case the framerate chugs so severely that it never finishes the effect before it removes itself!
+		//matrix->e_ThinkFunc = thinkF_G_FreeEntity;
+		//matrix->nextthink = level.time + length + 500;
+		matrix->s.boltInfo = meFlags;
+		matrix->s.time2 = spinTime;
+		matrix->s.angles2[0] = timeScale;
+	}
+}
+
+qboolean G_JediInRoom( vec3_t from )
+{
+	gentity_t *ent;
+	int i;
+//	for ( i = 1, ent = &g_entities[1]; i < globals.num_entities; i++, ent++ )
+	for ( i = 1; i < globals.num_entities; i++)
+	{
+		if(!PInUse(i))
+			continue;
+//		if ( !ent->inuse )
+//		{
+//			continue;
+//		}
+//		if ( !ent )
+//		{
+//			continue;
+//		}		
+		ent = &g_entities[i];
+		if ( !ent->NPC )
+		{
+			continue;
+		}
+		if ( ent->health <= 0 )
+		{
+			continue;
+		}
+		if ( ent->s.eFlags&EF_NODRAW )
+		{
+			continue;
+		}
+		if ( ent->s.weapon != WP_SABER )
+		{
+			continue;
+		}
+		if ( !gi.inPVS( ent->currentOrigin, from ) )
+		{
+			continue;
+		}
+		return qtrue;
+	}
+	return qfalse;
+}
+
+qboolean G_GetHitLocFromSurfName( gentity_t *ent, const char *surfName, int *hitLoc, vec3_t point, vec3_t dir, vec3_t bladeDir, int mod, saberType_t saberType )
+{
+	qboolean dismember = qfalse;
+
+	*hitLoc = HL_NONE;
+
+	if ( !surfName || !surfName[0] )
+	{
+		return qfalse;
+	}
+
+	if( !ent->client )
+	{
+		return qfalse;
+	}
+
+	if ( ent->client 
+		&& ( ent->client->NPC_class == CLASS_R2D2 
+			|| ent->client->NPC_class == CLASS_R2D2 
+			|| ent->client->NPC_class == CLASS_GONK
+			|| ent->client->NPC_class == CLASS_MOUSE
+			|| ent->client->NPC_class == CLASS_SENTRY
+			|| ent->client->NPC_class == CLASS_INTERROGATOR
+			|| ent->client->NPC_class == CLASS_SENTRY
+			|| ent->client->NPC_class == CLASS_PROBE ) )
+	{//we don't care about per-surface hit-locations or dismemberment for these guys 
+		return qfalse;
+	}
+
+	if ( ent->client && (ent->client->NPC_class == CLASS_ATST) )
+	{
+		//FIXME: almost impossible to hit these... perhaps we should
+		//		check for splashDamage and do radius damage to these parts?
+		//		Or, if we ever get bbox G2 traces, that may fix it, too
+		if (!Q_stricmp("head_light_blaster_cann",surfName))
+		{
+			*hitLoc = HL_ARM_LT;
+		}
+		else if (!Q_stricmp("head_concussion_charger",surfName))
+		{
+			*hitLoc = HL_ARM_RT;
+		}
+		return(qfalse);
+	}
+	else if ( ent->client && (ent->client->NPC_class == CLASS_MARK1) )
+	{
+		if (!Q_stricmp("l_arm",surfName))
+		{
+			*hitLoc = HL_ARM_LT;
+		}
+		else if (!Q_stricmp("r_arm",surfName))
+		{
+			*hitLoc = HL_ARM_RT;
+		}
+		else if (!Q_stricmp("torso_front",surfName))
+		{
+			*hitLoc = HL_CHEST;
+		}
+		else if (!Q_stricmp("torso_tube1",surfName))
+		{
+			*hitLoc = HL_GENERIC1;
+		}
+		else if (!Q_stricmp("torso_tube2",surfName))
+		{
+			*hitLoc = HL_GENERIC2;
+		}
+		else if (!Q_stricmp("torso_tube3",surfName))
+		{
+			*hitLoc = HL_GENERIC3;
+		}
+		else if (!Q_stricmp("torso_tube4",surfName))
+		{
+			*hitLoc = HL_GENERIC4;
+		}
+		else if (!Q_stricmp("torso_tube5",surfName))
+		{
+			*hitLoc = HL_GENERIC5;
+		}
+		else if (!Q_stricmp("torso_tube6",surfName))
+		{
+			*hitLoc = HL_GENERIC6;
+		}
+		return(qfalse);
+	}
+	else if ( ent->client && (ent->client->NPC_class == CLASS_MARK2) )
+	{
+		if (!Q_stricmp("torso_canister1",surfName))
+		{
+			*hitLoc = HL_GENERIC1;
+		}
+		else if (!Q_stricmp("torso_canister2",surfName))
+		{
+			*hitLoc = HL_GENERIC2;
+		}
+		else if (!Q_stricmp("torso_canister3",surfName))
+		{
+			*hitLoc = HL_GENERIC3;
+		}
+		return(qfalse);
+	}
+	else if ( ent->client && (ent->client->NPC_class == CLASS_GALAKMECH) )
+	{
+		if (!Q_stricmp("torso_antenna",surfName)||!Q_stricmp("torso_antenna_base",surfName))
+		{
+			*hitLoc = HL_GENERIC1;
+		}
+		else if (!Q_stricmp("torso_shield",surfName))
+		{
+			*hitLoc = HL_GENERIC2;
+		}
+		else
+		{
+			*hitLoc = HL_CHEST;
+		}
+		return(qfalse);
+	}
+
+
+	//FIXME: check the hitLoc and hitDir against the cap tag for the place 
+	//where the split will be- if the hit dir is roughly perpendicular to 
+	//the direction of the cap, then the split is allowed, otherwise we
+	//hit it at the wrong angle and should not dismember...
+	int	actualTime = (cg.time?cg.time:level.time);
+	if ( !Q_stricmpn( "hips", surfName, 4 ) )
+	{//FIXME: test properly for legs
+		*hitLoc = HL_WAIST;
+		if ( ent->client != NULL && ent->ghoul2.size() )
+		{
+			mdxaBone_t	boltMatrix;
+			vec3_t	tagOrg, angles;
+
+			VectorSet( angles, 0, ent->currentAngles[YAW], 0 );
+			if (ent->kneeLBolt>=0)
+			{
+				gi.G2API_GetBoltMatrix( ent->ghoul2, ent->playerModel, ent->kneeLBolt, 
+								&boltMatrix, angles, ent->currentOrigin,
+								actualTime, NULL, ent->s.modelScale );
+				gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, tagOrg );
+				if ( DistanceSquared( point, tagOrg ) < 100 )
+				{//actually hit the knee
+					*hitLoc = HL_LEG_LT;
+				}
+			}
+			if (*hitLoc == HL_WAIST)
+			{
+				if (ent->kneeRBolt>=0)
+				{
+					gi.G2API_GetBoltMatrix( ent->ghoul2, ent->playerModel, ent->kneeRBolt, 
+									&boltMatrix, angles, ent->currentOrigin,
+									actualTime, NULL, ent->s.modelScale );
+					gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, tagOrg );
+					if ( DistanceSquared( point, tagOrg ) < 100 )
+					{//actually hit the knee
+						*hitLoc = HL_LEG_RT;
+					}
+				}
+			}
+		}
+	}
+	else if ( !Q_stricmpn( "torso", surfName, 5 ) )
+	{
+		if ( !ent->client )
+		{
+			*hitLoc = HL_CHEST;
+		}
+		else
+		{
+			vec3_t	t_fwd, t_rt, t_up, dirToImpact;
+			float frontSide, rightSide, upSide;
+			AngleVectors( ent->client->renderInfo.torsoAngles, t_fwd, t_rt, t_up );
+			VectorSubtract( point, ent->client->renderInfo.torsoPoint, dirToImpact );
+			frontSide = DotProduct( t_fwd, dirToImpact );
+			rightSide = DotProduct( t_rt, dirToImpact );
+			upSide = DotProduct( t_up, dirToImpact );
+			if ( upSide < -10 )
+			{//hit at waist
+				*hitLoc = HL_WAIST;
+			}
+			else
+			{//hit on upper torso
+				if ( rightSide > 4 )
+				{
+					*hitLoc = HL_ARM_RT;
+				}
+				else if ( rightSide < -4 )
+				{
+					*hitLoc = HL_ARM_LT;
+				}
+				else if ( rightSide > 2 )
+				{
+					if ( frontSide > 0 )
+					{
+						*hitLoc = HL_CHEST_RT;
+					}
+					else
+					{
+						*hitLoc = HL_BACK_RT;
+					}
+				}
+				else if ( rightSide < -2 )
+				{
+					if ( frontSide > 0 )
+					{
+						*hitLoc = HL_CHEST_LT;
+					}
+					else
+					{
+						*hitLoc = HL_BACK_LT;
+					}
+				}
+				else if ( upSide > -3 && mod == MOD_SABER )
+				{
+					*hitLoc = HL_HEAD;
+				}
+				else if ( frontSide > 0 )
+				{
+					*hitLoc = HL_CHEST;
+				}
+				else
+				{
+					*hitLoc = HL_BACK;
+				}
+			}
+		}
+	}
+	else if ( !Q_stricmpn( "head", surfName, 4 ) )
+	{
+		*hitLoc = HL_HEAD;
+	}
+	else if ( !Q_stricmpn( "r_arm", surfName, 5 ) )
+	{
+		*hitLoc = HL_ARM_RT;
+		if ( ent->client != NULL && ent->ghoul2.size() )
+		{
+			mdxaBone_t	boltMatrix;
+			vec3_t	tagOrg, angles;
+
+			VectorSet( angles, 0, ent->currentAngles[YAW], 0 );
+			if (ent->handRBolt>=0)
+			{
+				gi.G2API_GetBoltMatrix( ent->ghoul2, ent->playerModel, ent->handRBolt, 
+								&boltMatrix, angles, ent->currentOrigin,
+								actualTime, NULL, ent->s.modelScale );
+				gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, tagOrg );
+				if ( DistanceSquared( point, tagOrg ) < 256 )
+				{//actually hit the hand
+					*hitLoc = HL_HAND_RT;
+				}
+			}
+		}
+	}
+	else if ( !Q_stricmpn( "l_arm", surfName, 5 ) )
+	{
+		*hitLoc = HL_ARM_LT;
+		if ( ent->client != NULL && ent->ghoul2.size() )
+		{
+			mdxaBone_t	boltMatrix;
+			vec3_t	tagOrg, angles;
+
+			VectorSet( angles, 0, ent->currentAngles[YAW], 0 );
+			if (ent->handLBolt>=0)
+			{
+				gi.G2API_GetBoltMatrix( ent->ghoul2, ent->playerModel, ent->handLBolt, 
+								&boltMatrix, angles, ent->currentOrigin,
+								actualTime, NULL, ent->s.modelScale );
+				gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, tagOrg );
+				if ( DistanceSquared( point, tagOrg ) < 256 )
+				{//actually hit the hand
+					*hitLoc = HL_HAND_LT;
+				}
+			}
+		}
+	}
+	else if ( !Q_stricmpn( "r_leg", surfName, 5 ) )
+	{
+		*hitLoc = HL_LEG_RT;
+		if ( ent->client != NULL && ent->ghoul2.size() )
+		{
+			mdxaBone_t	boltMatrix;
+			vec3_t	tagOrg, angles;
+
+			VectorSet( angles, 0, ent->currentAngles[YAW], 0 );
+			if (ent->footRBolt>=0)
+			{
+				gi.G2API_GetBoltMatrix( ent->ghoul2, ent->playerModel, ent->footRBolt, 
+								&boltMatrix, angles, ent->currentOrigin,
+								actualTime, NULL, ent->s.modelScale );
+				gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, tagOrg );
+				if ( DistanceSquared( point, tagOrg ) < 100 )
+				{//actually hit the foot
+					*hitLoc = HL_FOOT_RT;
+				}
+			}
+		}
+	}
+	else if ( !Q_stricmpn( "l_leg", surfName, 5 ) )
+	{
+		*hitLoc = HL_LEG_LT;
+		if ( ent->client != NULL && ent->ghoul2.size() )
+		{
+			mdxaBone_t	boltMatrix;
+			vec3_t	tagOrg, angles;
+
+			VectorSet( angles, 0, ent->currentAngles[YAW], 0 );
+			if (ent->footLBolt>=0)
+			{
+				gi.G2API_GetBoltMatrix( ent->ghoul2, ent->playerModel, ent->footLBolt, 
+								&boltMatrix, angles, ent->currentOrigin,
+								actualTime, NULL, ent->s.modelScale );
+				gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, tagOrg );
+				if ( DistanceSquared( point, tagOrg ) < 100 )
+				{//actually hit the foot
+					*hitLoc = HL_FOOT_LT;
+				}
+			}
+		}
+	}
+	else if ( mod == MOD_SABER && WP_BreakSaber( ent, surfName, saberType ) )
+	{//saber hit and broken
+		*hitLoc = HL_HAND_RT;
+	}
+	else if ( !Q_stricmpn( "r_hand", surfName, 6 ) || !Q_stricmpn( "w_", surfName, 2 ) )
+	{//right hand or weapon
+		//FIXME: if hit weapon, chance of breaking saber (if sabers.cfg entry shows it as breakable)
+		//			if breaks, remove saber and replace with the 2 replacement sabers (preserve color, length, etc.)
+		*hitLoc = HL_HAND_RT;
+	}
+	else if ( !Q_stricmpn( "l_hand", surfName, 6 ) )
+	{
+		*hitLoc = HL_HAND_LT;
+	}
+	else if ( ent->client && ent->client->ps.powerups[PW_GALAK_SHIELD] && !Q_stricmp( "force_shield", surfName ) )
+	{
+		*hitLoc = HL_GENERIC2;
+
+	}
+#ifdef _DEBUG
+	else
+	{
+		Com_Printf( "ERROR: surface %s does not belong to any hitLocation!!!\n", surfName );
+	}
+#endif //_DEBUG
+
+	if ( g_saberRealisticCombat->integer > 1 )
+	{
+		dismember = qtrue;
+	}
+	else if ( ent->client && ent->client->NPC_class == CLASS_PROTOCOL )
+	{
+		dismember = qtrue;
+	}
+	else if ( ent->client && ent->client->NPC_class == CLASS_ASSASSIN_DROID )
+	{
+		dismember = qtrue;
+	}
+	else if ( ent->client && ent->client->NPC_class == CLASS_SABER_DROID )
+	{
+		dismember = qtrue;
+	}
+	else if ( g_dismemberment->integer == 113811381138 || !ent->client->dismembered )
+	{
+		if ( dir && (dir[0] || dir[1] || dir[2]) &&
+			bladeDir && (bladeDir[0] || bladeDir[1] || bladeDir[2]) )
+		{//we care about direction (presumably for dismemberment)
+			if ( G_Dismemberable( ent, *hitLoc ) )
+			{//the probability let us continue
+				char *tagName = NULL;
+				float	aoa = 0.5f;
+				//dir must be roughly perpendicular to the hitLoc's cap bolt
+				switch ( *hitLoc )
+				{
+					case HL_LEG_RT:
+						tagName = "*hips_cap_r_leg";
+						break;
+					case HL_LEG_LT:
+						tagName = "*hips_cap_l_leg";
+						break;
+					case HL_WAIST:
+						tagName = "*hips_cap_torso";
+						aoa = 0.25f;
+						break;
+					case HL_CHEST_RT:
+					case HL_ARM_RT:
+					case HL_BACK_LT:
+						tagName = "*torso_cap_r_arm";
+						break;
+					case HL_CHEST_LT:
+					case HL_ARM_LT:
+					case HL_BACK_RT:
+						tagName = "*torso_cap_l_arm";
+						break;
+					case HL_HAND_RT:
+						tagName = "*r_arm_cap_r_hand";
+						break;
+					case HL_HAND_LT:
+						tagName = "*l_arm_cap_l_hand";
+						break;
+					case HL_HEAD:
+						tagName = "*torso_cap_head";
+						aoa = 0.25f;
+						break;
+					case HL_CHEST:
+					case HL_BACK:
+					case HL_FOOT_RT:
+					case HL_FOOT_LT:
+					default:
+						//no dismemberment possible with these, so no checks needed
+						break;
+				}
+				if ( tagName )
+				{
+					int tagBolt = gi.G2API_AddBolt( &ent->ghoul2[ent->playerModel], tagName );
+					if ( tagBolt != -1 )
+					{
+						mdxaBone_t	boltMatrix;
+						vec3_t	tagOrg, tagDir, angles;
+						VectorSet( angles, 0, ent->currentAngles[YAW], 0 );
+						gi.G2API_GetBoltMatrix( ent->ghoul2, ent->playerModel, tagBolt, 
+										&boltMatrix, angles, ent->currentOrigin,
+										actualTime, NULL, ent->s.modelScale );
+						gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, tagOrg );
+						gi.G2API_GiveMeVectorFromMatrix( boltMatrix, NEGATIVE_Y, tagDir );
+						if ( DistanceSquared( point, tagOrg ) < 256 )
+						{//hit close
+							float dot = DotProduct( dir, tagDir );
+							if ( dot < aoa && dot > -aoa )
+							{//hit roughly perpendicular
+								dot = DotProduct( bladeDir, tagDir );
+								if ( dot < aoa && dot > -aoa )
+								{//blade was roughly perpendicular
+									dismember = qtrue;
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+	return dismember;
+}
+
+int G_GetHitLocation ( gentity_t *target, const vec3_t ppoint )
+{
+	vec3_t			point, point_dir;
+	vec3_t			forward, right, up;
+	vec3_t			tangles, tcenter;
+	float			tradius;
+	float			udot, fdot, rdot;
+	int				Vertical, Forward, Lateral;
+	int				HitLoc;
+
+//get target forward, right and up
+	if(target->client)
+	{//ignore player's pitch and roll
+		VectorSet(tangles, 0, target->currentAngles[YAW], 0);
+	}
+
+	AngleVectors(tangles, forward, right, up);
+
+//get center of target
+	VectorAdd(target->absmin, target->absmax, tcenter);
+	VectorScale(tcenter, 0.5, tcenter);
+
+//get radius width of target
+	tradius = (fabs(target->maxs[0]) + fabs(target->maxs[1]) + fabs(target->mins[0]) + fabs(target->mins[1]))/4;
+
+//get impact point
+	if(ppoint && !VectorCompare(ppoint, vec3_origin))
+	{
+		VectorCopy(ppoint, point);
+	}
+	else
+	{
+		return HL_NONE;
+	}
+
+/*
+//get impact dir
+	if(pdir && !VectorCompare(pdir, vec3_origin))
+	{
+		VectorCopy(pdir, dir);
+	}
+	else
+	{
+		return;
+	}
+
+//put point at controlled distance from center
+	VectorSubtract(point, tcenter, tempvec);
+	tempvec[2] = 0;
+	hdist = VectorLength(tempvec);
+
+	VectorMA(point, hdist - tradius, dir, point);
+	//now a point on the surface of a cylinder with a radius of tradius
+*/	
+	VectorSubtract(point, tcenter, point_dir);
+	VectorNormalize(point_dir);
+
+	//Get bottom to top (Vertical) position index
+	udot = DotProduct(up, point_dir);
+	if(udot>.800)
+		Vertical = 4;
+	else if(udot>.400)
+		Vertical = 3;
+	else if(udot>-.333)
+		Vertical = 2;
+	else if(udot>-.666)
+		Vertical = 1;
+	else
+		Vertical = 0;
+
+	//Get back to front (Forward) position index
+	fdot = DotProduct(forward, point_dir);
+	if(fdot>.666)
+		Forward = 4;
+	else if(fdot>.333)
+		Forward = 3;
+	else if(fdot>-.333)
+		Forward = 2;
+	else if(fdot>-.666)
+		Forward = 1;
+	else
+		Forward = 0;
+
+	//Get left to right (Lateral) position index
+	rdot = DotProduct(right, point_dir);
+	if(rdot>.666)
+		Lateral = 4;
+	else if(rdot>.333)
+		Lateral = 3;
+	else if(rdot>-.333)
+		Lateral = 2;
+	else if(rdot>-.666)
+		Lateral = 1;
+	else
+		Lateral = 0;
+
+	HitLoc = Vertical * 25 + Forward * 5 + Lateral;
+
+	if(HitLoc <= 10)
+	{//feet
+		if ( rdot > 0 )
+		{
+			return HL_FOOT_RT;
+		}
+		else
+		{
+			return HL_FOOT_LT;
+		}
+	}
+	else if(HitLoc <= 50)
+	{//legs
+		if ( rdot > 0 )
+		{
+			return HL_LEG_RT;
+		}
+		else
+		{
+			return HL_LEG_LT;
+		}
+	}
+	else if ( HitLoc == 56||HitLoc == 60||HitLoc == 61||HitLoc == 65||HitLoc == 66||HitLoc == 70 )
+	{//hands
+		if ( rdot > 0 )
+		{
+			return HL_HAND_RT;
+		}
+		else
+		{
+			return HL_HAND_LT;
+		}
+	}
+	else if ( HitLoc == 83||HitLoc == 87||HitLoc == 88||HitLoc == 92||HitLoc == 93||HitLoc == 97 )
+	{//arms
+		if ( rdot > 0 )
+		{
+			return HL_ARM_RT;
+		}
+		else
+		{
+			return HL_ARM_LT;
+		}
+	}
+	else if((HitLoc >= 107 && HitLoc <= 109)||
+		(HitLoc >= 112 && HitLoc <= 114)||
+		(HitLoc >= 117 && HitLoc <= 119))
+	{//head
+		return HL_HEAD;
+	}
+	else
+	{
+		if ( udot < 0.3 )
+		{
+			return HL_WAIST;
+		}
+		else if ( fdot < 0 )
+		{
+			if ( rdot > 0.4 )
+			{
+				return HL_BACK_RT;
+			}
+			else if ( rdot < -0.4 )
+			{
+				return HL_BACK_LT;
+			}
+			else
+			{
+				return HL_BACK;
+			}
+		}
+		else
+		{
+			if ( rdot > 0.3 )
+			{
+				return HL_CHEST_RT;
+			}
+			else if ( rdot < -0.3 )
+			{
+				return HL_CHEST_LT;
+			}
+			else
+			{
+				return HL_CHEST;
+			}
+		}
+	}
+	//return HL_NONE;
+}
+
+int G_PickPainAnim( gentity_t *self, const vec3_t point, int damage, int hitLoc = HL_NONE )
+{
+	if ( hitLoc == HL_NONE )
+	{
+		hitLoc = G_GetHitLocation( self, point );
+	}
+	switch( hitLoc )
+	{
+	case HL_FOOT_RT:
+		return BOTH_PAIN12;
+		//PAIN12 = right foot
+		break;
+	case HL_FOOT_LT:
+		return -1;
+		break;
+	case HL_LEG_RT:
+		if ( !Q_irand( 0, 1 ) )
+		{
+			return BOTH_PAIN11;
+		}
+		else
+		{
+			return BOTH_PAIN13;
+		}
+		//PAIN11 = twitch right leg
+		//PAIN13 = right knee
+		break;
+	case HL_LEG_LT:
+		return BOTH_PAIN14;
+		//PAIN14 = twitch left leg
+		break;
+	case HL_BACK_RT:
+		return BOTH_PAIN7;
+		//PAIN7 = med left shoulder
+		break;
+	case HL_BACK_LT:
+		return Q_irand( BOTH_PAIN15, BOTH_PAIN16 );
+		//PAIN15 = med right shoulder
+		//PAIN16 = twitch right shoulder
+		break;
+	case HL_BACK:
+		if ( !Q_irand( 0, 1 ) )
+		{
+			return BOTH_PAIN1;
+		}
+		else
+		{
+			return BOTH_PAIN5;
+		}
+		//PAIN1 = back
+		//PAIN5 = same as 1
+		break;
+	case HL_CHEST_RT:
+		return BOTH_PAIN3;
+		//PAIN3 = long, right shoulder
+		break;
+	case HL_CHEST_LT:
+		return BOTH_PAIN2;
+		//PAIN2 = long, left shoulder
+		break;
+	case HL_WAIST:
+	case HL_CHEST:
+		if ( !Q_irand( 0, 3 ) )
+		{
+			return BOTH_PAIN6;
+		}
+		else if ( !Q_irand( 0, 2 ) )
+		{
+			return BOTH_PAIN8;
+		}
+		else if ( !Q_irand( 0, 1 ) )
+		{
+			return BOTH_PAIN17;
+		}
+		else
+		{
+			return BOTH_PAIN18;
+		}
+		//PAIN6 = gut
+		//PAIN8 = chest
+		//PAIN17 = twitch crotch
+		//PAIN19 = med crotch
+		break;
+	case HL_ARM_RT:
+	case HL_HAND_RT:
+		return BOTH_PAIN9;
+		//PAIN9 = twitch right arm
+		break;
+	case HL_ARM_LT:
+	case HL_HAND_LT:
+		return BOTH_PAIN10;
+		//PAIN10 = twitch left arm
+		break;
+	case HL_HEAD:
+		return BOTH_PAIN4;
+		//PAIN4 = head
+		break;
+	default:
+		return -1;
+		break;
+	}
+}
+
+extern void G_BounceMissile( gentity_t *ent, trace_t *trace );
+void LimbThink( gentity_t *ent )
+{//FIXME: just use object thinking?
+	vec3_t		origin;
+	trace_t		tr;
+
+
+	ent->nextthink = level.time + FRAMETIME;
+	if ( ent->owner 
+		&& ent->owner->client 
+		&& (ent->owner->client->ps.eFlags&EF_HELD_BY_RANCOR) )
+	{
+		ent->e_ThinkFunc = thinkF_G_FreeEntity;
+		return;
+	}
+
+	if ( ent->enemy )
+	{//alert people that I am a piece of one of their friends
+		AddSightEvent( ent->enemy, ent->currentOrigin, 384, AEL_DISCOVERED );
+	}
+
+	if ( ent->s.pos.trType == TR_STATIONARY )
+	{//stopped
+		if ( level.time > ent->s.apos.trTime + ent->s.apos.trDuration )
+		{
+			if (ent->owner && ent->owner->m_pVehicle)
+			{
+				ent->nextthink = level.time + Q_irand( 10000, 15000 );
+			}
+			else
+			{
+				ent->nextthink = level.time + Q_irand( 5000, 15000 );
+			}
+
+			ent->e_ThinkFunc = thinkF_G_FreeEntity;
+			//FIXME: these keep drawing for a frame or so after being freed?!  See them lerp to origin of world...
+		}
+		else
+		{
+			EvaluateTrajectory( &ent->s.apos, level.time, ent->currentAngles );
+		}
+		return;
+	}
+
+	// get current position
+	EvaluateTrajectory( &ent->s.pos, level.time, origin );
+	// get current angles
+	EvaluateTrajectory( &ent->s.apos, level.time, ent->currentAngles );
+
+	// trace a line from the previous position to the current position,
+	// ignoring interactions with the missile owner
+	gi.trace( &tr, ent->currentOrigin, ent->mins, ent->maxs, origin, 
+		ent->owner ? ent->owner->s.number : ENTITYNUM_NONE, ent->clipmask );
+
+	VectorCopy( tr.endpos, ent->currentOrigin );
+	if ( tr.startsolid ) 
+	{
+		tr.fraction = 0;
+	}
+
+
+	gi.linkentity( ent );
+
+	if ( tr.fraction != 1 ) 
+	{
+		G_BounceMissile( ent, &tr );
+		if ( ent->s.pos.trType == TR_STATIONARY )
+		{//stopped, stop spinning
+			//lay flat
+			//pitch
+			VectorCopy( ent->currentAngles, ent->s.apos.trBase );
+			vec3_t	flatAngles;
+			if ( ent->s.angles2[0] == -1 )
+			{//any pitch is okay
+				flatAngles[0] = ent->currentAngles[0];
+			}
+			else
+			{//lay flat
+				if ( ent->owner 
+					&& ent->owner->client 
+					&& ent->owner->client->NPC_class == CLASS_PROTOCOL 
+					&& ent->count == BOTH_DISMEMBER_TORSO1 )
+				{
+					if ( ent->currentAngles[0] > 0 || ent->currentAngles[0] < -180 )
+					{
+						flatAngles[0] = -90;
+					}
+					else
+					{
+						flatAngles[0] = 90;
+					}
+				}
+				else
+				{
+					if ( ent->currentAngles[0] > 90 || ent->currentAngles[0] < -90 )
+					{
+						flatAngles[0] = 180;
+					}
+					else
+					{
+						flatAngles[0] = 0;
+					}
+				}
+			}
+			//yaw
+			flatAngles[1] = ent->currentAngles[1];
+			//roll
+			if ( ent->s.angles2[2] == -1 )
+			{//any roll is okay
+				flatAngles[2] = ent->currentAngles[2];
+			}
+			else
+			{
+				if ( ent->currentAngles[2] > 90 || ent->currentAngles[2] < -90 )
+				{
+					flatAngles[2] = 180;
+				}
+				else
+				{
+					flatAngles[2] = 0;
+				}
+			}
+			VectorSubtract( flatAngles, ent->s.apos.trBase, ent->s.apos.trDelta );
+			for ( int i = 0; i < 3; i++ )
+			{
+				ent->s.apos.trDelta[i] = AngleNormalize180( ent->s.apos.trDelta[i] );
+			}
+			ent->s.apos.trTime = level.time;
+			ent->s.apos.trDuration = 1000;
+			ent->s.apos.trType = TR_LINEAR_STOP;
+			//VectorClear( ent->s.apos.trDelta );
+		}
+	}
+}
+
+float hitLocHealthPercentage[HL_MAX] = 
+{
+	0.0f,	//HL_NONE = 0,
+	0.05f,	//HL_FOOT_RT,
+	0.05f,	//HL_FOOT_LT,
+	0.20f,	//HL_LEG_RT,
+	0.20f,	//HL_LEG_LT,
+	0.30f,	//HL_WAIST,
+	0.15f,	//HL_BACK_RT,
+	0.15f,	//HL_BACK_LT,
+	0.30f,	//HL_BACK,
+	0.15f,	//HL_CHEST_RT,
+	0.15f,	//HL_CHEST_LT,
+	0.30f,	//HL_CHEST,
+	0.05f,	//HL_ARM_RT,
+	0.05f,	//HL_ARM_LT,
+	0.01f,	//HL_HAND_RT,
+	0.01f,	//HL_HAND_LT,
+	0.10f,	//HL_HEAD
+	0.0f,	//HL_GENERIC1,
+	0.0f,	//HL_GENERIC2,
+	0.0f,	//HL_GENERIC3,
+	0.0f,	//HL_GENERIC4,
+	0.0f,	//HL_GENERIC5,
+	0.0f	//HL_GENERIC6
+};
+
+char *hitLocName[HL_MAX] = 
+{
+	"none",	//HL_NONE = 0,
+	"right foot",	//HL_FOOT_RT,
+	"left foot",	//HL_FOOT_LT,
+	"right leg",	//HL_LEG_RT,
+	"left leg",	//HL_LEG_LT,
+	"waist",	//HL_WAIST,
+	"back right shoulder",	//HL_BACK_RT,
+	"back left shoulder",	//HL_BACK_LT,
+	"back",	//HL_BACK,
+	"front right shouler",	//HL_CHEST_RT,
+	"front left shoulder",	//HL_CHEST_LT,
+	"chest",	//HL_CHEST,
+	"right arm",	//HL_ARM_RT,
+	"left arm",	//HL_ARM_LT,
+	"right hand",	//HL_HAND_RT,
+	"left hand",	//HL_HAND_LT,
+	"head",	//HL_HEAD
+	"generic1",	//HL_GENERIC1,
+	"generic2",	//HL_GENERIC2,
+	"generic3",	//HL_GENERIC3,
+	"generic4",	//HL_GENERIC4,
+	"generic5",	//HL_GENERIC5,
+	"generic6"	//HL_GENERIC6
+};
+
+qboolean G_LimbLost( gentity_t *ent, int hitLoc )
+{
+	switch ( hitLoc )
+	{
+	case HL_FOOT_RT:
+		if ( ent->locationDamage[HL_FOOT_RT] >= Q3_INFINITE )
+		{
+			return qtrue;
+		}
+		//NOTE: falls through
+	case HL_LEG_RT:
+		//NOTE: feet fall through
+		if ( ent->locationDamage[HL_LEG_RT] >= Q3_INFINITE )
+		{
+			return qtrue;
+		}
+		return qfalse;
+		break;
+
+	case HL_FOOT_LT:
+		if ( ent->locationDamage[HL_FOOT_LT] >= Q3_INFINITE )
+		{
+			return qtrue;
+		}
+		//NOTE: falls through
+	case HL_LEG_LT:
+		//NOTE: feet fall through
+		if ( ent->locationDamage[HL_LEG_LT] >= Q3_INFINITE )
+		{
+			return qtrue;
+		}
+		return qfalse;
+		break;
+
+	case HL_HAND_LT:
+		if ( ent->locationDamage[HL_HAND_LT] >= Q3_INFINITE )
+		{
+			return qtrue;
+		}
+		//NOTE: falls through
+	case HL_ARM_LT:
+	case HL_CHEST_LT:
+	case HL_BACK_RT:
+		//NOTE: hand falls through
+		if ( ent->locationDamage[HL_ARM_LT] >= Q3_INFINITE 
+			|| ent->locationDamage[HL_CHEST_LT] >= Q3_INFINITE 
+			|| ent->locationDamage[HL_BACK_RT] >= Q3_INFINITE 
+			|| ent->locationDamage[HL_WAIST] >= Q3_INFINITE )
+		{
+			return qtrue;
+		}
+		return qfalse;
+		break;
+
+	case HL_HAND_RT:
+		if ( ent->locationDamage[HL_HAND_RT] >= Q3_INFINITE )
+		{
+			return qtrue;
+		}
+		//NOTE: falls through
+	case HL_ARM_RT:
+	case HL_CHEST_RT:
+	case HL_BACK_LT:
+		//NOTE: hand falls through
+		if ( ent->locationDamage[HL_ARM_RT] >= Q3_INFINITE 
+			|| ent->locationDamage[HL_CHEST_RT] >= Q3_INFINITE 
+			|| ent->locationDamage[HL_BACK_LT] >= Q3_INFINITE 
+			|| ent->locationDamage[HL_WAIST] >= Q3_INFINITE )
+		{
+			return qtrue;
+		}
+		return qfalse;
+		break;
+
+	case HL_HEAD:
+		if ( ent->locationDamage[HL_HEAD] >= Q3_INFINITE )
+		{
+			return qtrue;
+		}
+		//NOTE: falls through
+	case HL_WAIST:
+		//NOTE: head falls through
+		if ( ent->locationDamage[HL_WAIST] >= Q3_INFINITE )
+		{
+			return qtrue;
+		}
+		return qfalse;
+		break;
+	default:
+		return (ent->locationDamage[hitLoc]>=Q3_INFINITE);
+		break;
+	}
+}
+
+extern qboolean G_GetRootSurfNameWithVariant( gentity_t *ent, const char *rootSurfName, char *returnSurfName, int returnSize );
+void G_RemoveWeaponsWithLimbs( gentity_t *ent, gentity_t *limb, int limbAnim )
+{
+	int		weaponModelNum = 0, checkAnim;
+	char	handName[MAX_QPATH];
+
+	for ( weaponModelNum = 0; weaponModelNum < MAX_INHAND_WEAPONS; weaponModelNum++ )
+	{
+		if ( ent->weaponModel[weaponModelNum] >= 0 )
+		{//have a weapon in this hand
+			if ( weaponModelNum == 0 && ent->client->ps.saberInFlight )
+			{//this is the right-hand weapon and it's a saber in-flight (i.e.: not in-hand, so no need to worry about it)
+				continue;
+			}
+			//otherwise, the corpse hasn't dropped their weapon
+			switch ( weaponModelNum )
+			{
+			case 0://right hand
+				checkAnim = BOTH_DISMEMBER_RARM;
+				G_GetRootSurfNameWithVariant( ent, "r_hand", handName, sizeof(handName) );
+				break;
+			case 1://left hand
+				checkAnim = BOTH_DISMEMBER_LARM;
+				G_GetRootSurfNameWithVariant( ent, "l_hand", handName, sizeof(handName) );
+				break;
+			default://not handled/valid
+				continue;
+				break;
+			}
+
+			if ( limbAnim == checkAnim || limbAnim == BOTH_DISMEMBER_TORSO1 )//either/both hands
+			{//FIXME: is this first check needed with this lower one?
+				if ( !gi.G2API_GetSurfaceRenderStatus( &limb->ghoul2[0], handName ) )
+				{//only copy the weapon over if the hand is actually on this limb...
+					//copy it to limb
+					if ( ent->s.weapon != WP_NONE )
+					{//only if they actually still have a weapon
+						limb->s.weapon = ent->s.weapon;
+						limb->weaponModel[weaponModelNum] = ent->weaponModel[weaponModelNum];
+					}//else - weaponModel is not -1 but don't have a weapon?  Oops, somehow G2 model wasn't removed?
+					//remove it on owner
+					if ( ent->weaponModel[weaponModelNum] > 0 )
+					{
+						gi.G2API_RemoveGhoul2Model( ent->ghoul2, ent->weaponModel[weaponModelNum] );
+						ent->weaponModel[weaponModelNum] = -1;
+					}
+					if ( !ent->client->ps.saberInFlight )
+					{//saberent isn't flying through the air, it's in-hand and attached to player
+						if ( ent->client->ps.saberEntityNum != ENTITYNUM_NONE && ent->client->ps.saberEntityNum > 0 )
+						{//remove the owner ent's saber model and entity
+							if ( g_entities[ent->client->ps.saberEntityNum].inuse )
+							{
+								G_FreeEntity( &g_entities[ent->client->ps.saberEntityNum] );
+							}
+							ent->client->ps.saberEntityNum = ENTITYNUM_NONE;
+						}
+					}
+				}
+				else
+				{//the hand had already been removed
+					if ( ent->weaponModel[weaponModelNum] > 0 )
+					{//still a weapon associated with it, remove it from the limb
+						gi.G2API_RemoveGhoul2Model( limb->ghoul2, ent->weaponModel[weaponModelNum] );
+						limb->weaponModel[weaponModelNum] = -1;
+					}
+				}
+			}
+			else
+			{//this weapon isn't affected by this dismemberment
+				if ( ent->weaponModel[weaponModelNum] > 0 )
+				{//but a weapon was copied over to the limb, so remove it
+					gi.G2API_RemoveGhoul2Model( limb->ghoul2, ent->weaponModel[weaponModelNum] );
+					limb->weaponModel[weaponModelNum] = -1;
+				}
+			}
+		}
+	}
+}
+
+static qboolean G_Dismember( gentity_t *ent, vec3_t point, 
+				 const char *limbBone, const char *rotateBone, const char *limbName, 
+				 const char *limbCapName, const char *stubCapName, const char *limbTagName, const char *stubTagName, 
+				 int limbAnim, float limbRollBase, float limbPitchBase,
+				 int damage, int hitLoc )
+{
+	int newBolt;
+	vec3_t	dir, newPoint, limbAngles = {0,ent->client->ps.legsYaw,0};
+	gentity_t *limb;
+	trace_t	trace;
+
+	//make sure this limb hasn't been lopped off already!
+	if ( gi.G2API_GetSurfaceRenderStatus( &ent->ghoul2[ent->playerModel], limbName ) == 0x00000100/*G2SURFACEFLAG_NODESCENDANTS*/ )
+	{//already lost this limb
+		//NOTE: we now check for off wth no decendants 
+		//because the torso surface can be off with 
+		//the torso variations on when this is one of 
+		//our "choose your own jedi" models
+		return qfalse;
+	}
+
+	//NOTE: only reason I have this next part is because G2API_GetSurfaceRenderStatus is *not* working
+	if ( G_LimbLost( ent, hitLoc ) )
+	{//already lost this limb
+		return qfalse;
+	}
+
+	//FIXME: when timescale is high, can sometimes cut off a surf that includes a surf that was already cut off
+//0) create a limb ent
+	VectorCopy( point, newPoint );
+	newPoint[2] += 6;
+	limb = G_Spawn();
+	G_SetOrigin( limb, newPoint );
+	//VectorCopy(ent->currentAngles,limbAngles);
+	//G_SetAngles( limb, ent->currentAngles );
+	VectorCopy( newPoint, limb->s.pos.trBase );
+//1) copy the g2 instance of the victim into the limb
+	gi.G2API_CopyGhoul2Instance( ent->ghoul2, limb->ghoul2 );
+	limb->playerModel = 0;//assumption!
+	limb->craniumBone = ent->craniumBone;
+	limb->cervicalBone = ent->cervicalBone;
+	limb->thoracicBone = ent->thoracicBone;
+	limb->upperLumbarBone = ent->upperLumbarBone;
+	limb->lowerLumbarBone = ent->lowerLumbarBone;
+	limb->hipsBone = ent->hipsBone;
+	limb->rootBone = ent->rootBone;
+//2) set the root surf on the limb
+	if ( limbTagName )
+	{//add smoke to cap tag
+		newBolt = gi.G2API_AddBolt( &limb->ghoul2[limb->playerModel], limbTagName );
+		if ( newBolt != -1 )
+		{
+			G_PlayEffect( G_EffectIndex("blaster/smoke_bolton"), limb->playerModel, newBolt, limb->s.number, newPoint);
+		}
+	}
+	/*
+	if ( limbBone && hitLoc == HL_HEAD )
+	{//stop the current anim on the limb?
+		gi.G2API_StopBoneAnim( &limb->ghoul2[limb->playerModel], "model_root" );
+		gi.G2API_StopBoneAnim( &limb->ghoul2[limb->playerModel], "motion" );
+		gi.G2API_StopBoneAnim( &limb->ghoul2[limb->playerModel], "upper_lumbar" );
+	}
+	*/
+	gi.G2API_StopBoneAnimIndex( &limb->ghoul2[limb->playerModel], limb->hipsBone );
+
+	gi.G2API_SetRootSurface( limb->ghoul2, limb->playerModel, limbName );
+	/*
+	if ( limbBone && hitLoc != HL_WAIST )
+	{//play the dismember anim on the limb?
+		//FIXME: screws up origin
+		animation_t *animations = level.knownAnimFileSets[ent->client->clientInfo.animFileIndex].animations;
+		//play the proper dismember anim on the limb
+		gi.G2API_SetBoneAnim(&limb->ghoul2[limb->playerModel], 0, animations[limbAnim].firstFrame - 1, 
+							animations[limbAnim].numFrames + animations[limbAnim].firstFrame - 1,
+							BONE_ANIM_OVERRIDE_FREEZE, 1, cg.time);
+	}
+	*/
+	if ( limbBone && hitLoc == HL_WAIST && ent->client->NPC_class == CLASS_PROTOCOL )
+	{//play the dismember anim on the limb?
+		gi.G2API_StopBoneAnim( &limb->ghoul2[limb->playerModel], "model_root" );
+		gi.G2API_StopBoneAnim( &limb->ghoul2[limb->playerModel], "motion" );
+		gi.G2API_StopBoneAnim( &limb->ghoul2[limb->playerModel], "pelvis" );
+		gi.G2API_StopBoneAnim( &limb->ghoul2[limb->playerModel], "upper_lumbar" );
+		//FIXME: screws up origin
+		animation_t *animations = level.knownAnimFileSets[ent->client->clientInfo.animFileIndex].animations;
+		//play the proper dismember anim on the limb
+		gi.G2API_SetBoneAnim(&limb->ghoul2[limb->playerModel], 0, animations[limbAnim].firstFrame, 
+							animations[limbAnim].numFrames + animations[limbAnim].firstFrame,
+							BONE_ANIM_OVERRIDE_FREEZE, 1, cg.time );
+	}
+	if ( rotateBone )
+	{
+ 		gi.G2API_SetNewOrigin( &limb->ghoul2[0], gi.G2API_AddBolt( &limb->ghoul2[0], rotateBone ) );
+
+		//now let's try to position the limb at the *exact* right spot
+		int newBolt = gi.G2API_AddBolt( &ent->ghoul2[0], rotateBone );
+		if ( newBolt != -1 )
+		{
+			int	actualTime = (cg.time?cg.time:level.time);
+			mdxaBone_t	boltMatrix;
+			vec3_t	angles;
+
+			VectorSet( angles, 0, ent->currentAngles[YAW], 0 );
+			gi.G2API_GetBoltMatrix( ent->ghoul2, ent->playerModel, newBolt, 
+							&boltMatrix, angles, ent->currentOrigin,
+							actualTime, NULL, ent->s.modelScale );
+			gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, limb->s.origin );
+			G_SetOrigin( limb, limb->s.origin );
+			VectorCopy( limb->s.origin, limb->s.pos.trBase );
+			//angles, too
+			/*
+			vec3_t	limbF, limbR;
+			newBolt = gi.G2API_AddBolt( &ent->ghoul2[0], limbBone );
+			if ( newBolt != -1 )
+			{
+				gi.G2API_GetBoltMatrix( ent->ghoul2, ent->playerModel, newBolt, 
+								&boltMatrix, angles, ent->currentOrigin,
+								actualTime, NULL, ent->s.modelScale );
+				gi.G2API_GiveMeVectorFromMatrix( boltMatrix, POSITIVE_X, limbF );
+				gi.G2API_GiveMeVectorFromMatrix( boltMatrix, NEGATIVE_Y, limbR );
+				vectoangles( limbF, limbAngles );
+				vectoangles( limbR, angles );
+				limbAngles[YAW] += 180;
+				limbAngles[ROLL] = angles[PITCH]*-1.0f;
+			}
+			*/
+		}
+	}
+	if ( limbCapName )
+	{//turn on caps
+		gi.G2API_SetSurfaceOnOff( &limb->ghoul2[limb->playerModel], limbCapName, 0 );
+	}
+//3) turn off w/descendants that surf in original model
+//NOTE: we actually change the ent's stuff on the cgame side so that there is no 50ms lag
+//		this is neccessary because the Ghoul2 info does not have to go over the network,
+//		cgame looks at game's data.  The new limb ent will be delayed so we will see
+//		that a limb is missing before the chopped off limb appears.
+//		also, if the limb was going to start in solid, we can delete it and return
+	if ( stubTagName )
+	{//add smoke to cap surf, spawn effect
+		//do it later
+		limb->target = G_NewString( stubTagName );
+		/*
+		newBolt = gi.G2API_AddBolt( &ent->ghoul2[ent->playerModel], stubTagName );
+		if ( newBolt != -1 )
+		{
+			G_PlayEffect( "blaster/smoke_bolton", ent->playerModel, newBolt, ent->s.number);
+		}
+		*/
+	}
+	if ( limbName )
+	{
+		limb->target2 = G_NewString( limbName );
+		//gi.G2API_SetSurfaceOnOff( &ent->ghoul2[ent->playerModel], limbName, 0x00000100 );//G2SURFACEFLAG_NODESCENDANTS
+	}
+	if ( stubCapName )
+	{//turn on caps
+		limb->target3 = G_NewString( stubCapName );
+		//gi.G2API_SetSurfaceOnOff( &ent->ghoul2[ent->playerModel], stubCapName, 0 );
+	}
+	limb->count = limbAnim;
+//
+	limb->s.radius = 60;
+//4) toss the limb away
+	limb->classname = "limb";
+	limb->owner = ent;
+	limb->enemy = ent->enemy;
+	
+	//remove weapons/move them to limb (if applicable in this dismemberment)
+	G_RemoveWeaponsWithLimbs( ent, limb, limbAnim );
+
+	limb->e_clThinkFunc = clThinkF_CG_Limb;
+	limb->e_ThinkFunc = thinkF_LimbThink;
+	limb->nextthink = level.time + FRAMETIME;
+	gi.linkentity( limb );
+	//need size, contents, clipmask
+	limb->svFlags = SVF_USE_CURRENT_ORIGIN;
+	limb->clipmask = MASK_SOLID;
+	limb->contents = CONTENTS_CORPSE;
+	VectorSet( limb->mins, -3.0f, -3.0f, -6.0f );
+	VectorSet( limb->maxs, 3.0f, 3.0f, 6.0f );
+
+	//make sure it doesn't start in solid
+	gi.trace( &trace, limb->s.pos.trBase, limb->mins, limb->maxs, limb->s.pos.trBase, limb->s.number, limb->clipmask );
+	if ( trace.startsolid )
+	{
+		limb->s.pos.trBase[2] -= limb->mins[2];
+		gi.trace( &trace, limb->s.pos.trBase, limb->mins, limb->maxs, limb->s.pos.trBase, limb->s.number, limb->clipmask );
+		if ( trace.startsolid )
+		{
+			limb->s.pos.trBase[2] += limb->mins[2];
+			gi.trace( &trace, limb->s.pos.trBase, limb->mins, limb->maxs, limb->s.pos.trBase, limb->s.number, limb->clipmask );
+			if ( trace.startsolid )
+			{//stuck?  don't remove
+				G_FreeEntity( limb );
+				return qfalse;
+			}
+		}
+	}
+
+	//move it
+	VectorCopy( limb->s.pos.trBase, limb->currentOrigin );
+	gi.linkentity( limb );
+
+	limb->s.eType = ET_THINKER;//ET_GENERAL;
+	limb->physicsBounce = 0.2f;
+	limb->s.pos.trType = TR_GRAVITY;
+	limb->s.pos.trTime = level.time;								// move a bit on the very first frame
+	VectorSubtract( point, ent->currentOrigin, dir );
+	VectorNormalize( dir );
+	//no trDuration?
+	//spin it
+	//new way- try to preserve the exact angle and position of the limb as it was when attached
+	VectorSet( limb->s.angles2, limbPitchBase, 0, limbRollBase );
+	VectorCopy( limbAngles, limb->s.apos.trBase );
+	/*
+	//old way- just set an angle... 
+	limb->s.apos.trBase[0] += limbPitchBase;
+	limb->s.apos.trBase[1] = ent->client->ps.viewangles[1];
+	limb->s.apos.trBase[2] += limbRollBase;
+	*/
+	limb->s.apos.trTime = level.time;
+	limb->s.apos.trType = TR_LINEAR;
+	VectorClear( limb->s.apos.trDelta );
+
+	if ( hitLoc == HL_HAND_RT || hitLoc == HL_HAND_LT )
+	{//hands fly farther
+		VectorMA( ent->client->ps.velocity, 200, dir, limb->s.pos.trDelta );
+		//make it bounce some
+		limb->s.eFlags |= EF_BOUNCE_HALF;
+		limb->s.apos.trDelta[0] = Q_irand( -300, 300 );
+		limb->s.apos.trDelta[1] = Q_irand( -800, 800 );
+	}
+	else if ( limbAnim == BOTH_DISMEMBER_HEAD1
+		|| limbAnim == BOTH_DISMEMBER_LARM
+		|| limbAnim == BOTH_DISMEMBER_RARM )
+	{//head and arms don't fly as far
+		limb->s.eFlags |= EF_BOUNCE_SHRAPNEL;
+		VectorMA( ent->client->ps.velocity, 150, dir, limb->s.pos.trDelta );
+		limb->s.apos.trDelta[0] = Q_irand( -200, 200 );
+		limb->s.apos.trDelta[1] = Q_irand( -400, 400 );
+	}
+	else// if ( limbAnim == BOTH_DISMEMBER_TORSO1 || limbAnim == BOTH_DISMEMBER_LLEG || limbAnim == BOTH_DISMEMBER_RLEG )
+	{//everything else just kinda falls off
+		limb->s.eFlags |= EF_BOUNCE_SHRAPNEL;
+		VectorMA( ent->client->ps.velocity, 100, dir, limb->s.pos.trDelta );
+		limb->s.apos.trDelta[0] = Q_irand( -100, 100 );
+		limb->s.apos.trDelta[1] = Q_irand( -200, 200 );
+	}
+	//roll? No, doesn't work...
+	//limb->s.apos.trDelta[2] = Q_irand( -300, 300 );//FIXME: this scales it down @ 80% and does weird stuff in timescale != 1.0
+	//limb->s.apos.trDelta[2] = limbRoll;
+
+	//preserve scale so giants don't have tiny limbs
+	VectorCopy( ent->s.modelScale, limb->s.modelScale );
+
+	//mark ent as dismembered	
+	ent->locationDamage[hitLoc] = Q3_INFINITE;//mark this limb as gone
+	ent->client->dismembered = true;
+
+	//copy the custom RGB to the limb (for skin coloring)
+	limb->startRGBA[0] = ent->client->renderInfo.customRGBA[0];
+	limb->startRGBA[1] = ent->client->renderInfo.customRGBA[1];
+	limb->startRGBA[2] = ent->client->renderInfo.customRGBA[2];
+
+	return qtrue;
+}
+
+static qboolean G_Dismemberable( gentity_t *self, int hitLoc )
+{
+	if ( self->client->dismembered )
+	{//cannot dismember me right now
+		return qfalse;
+	}
+	if ( g_dismemberment->integer != 113811381138 && g_saberRealisticCombat->integer < 2 )
+	{
+		if ( 1 ) //g_dismemberProbabilities->value > 0.0f == it always is now, no cheating and changing the game from what was approved.
+		{//use the ent-specific dismemberProbabilities
+			float dismemberProb = 0;
+			// check which part of the body it is. Then check the npc's probability
+			// of that body part coming off, if it doesn't pass, return out.
+			switch ( hitLoc )
+			{
+			case HL_LEG_RT:
+			case HL_LEG_LT:
+				dismemberProb = self->client->dismemberProbLegs;
+				break;
+			case HL_WAIST:
+				dismemberProb = self->client->dismemberProbWaist;
+				break;
+			case HL_BACK_RT:
+			case HL_BACK_LT:
+			case HL_CHEST_RT:
+			case HL_CHEST_LT:
+			case HL_ARM_RT:
+			case HL_ARM_LT:
+				dismemberProb = self->client->dismemberProbArms;
+				break;
+			case HL_HAND_RT:
+			case HL_HAND_LT:
+				dismemberProb = self->client->dismemberProbHands;
+				break;
+			case HL_HEAD:
+				dismemberProb = self->client->dismemberProbHead;
+				break;
+			default:
+				return qfalse;
+				break;
+			}
+
+			//check probability of this happening on this npc
+			if ( Q_flrand( 1, 100 ) > dismemberProb*2.0f )//probabilities seemed really really low, had to crank them up
+			{	
+				return qfalse;
+			}
+		}
+	}
+	return qtrue;
+}
+
+#define	MAX_VARIANTS 8
+qboolean G_GetRootSurfNameWithVariant( gentity_t *ent, const char *rootSurfName, char *returnSurfName, int returnSize )
+{
+	if ( !gi.G2API_GetSurfaceRenderStatus( &ent->ghoul2[ent->playerModel], rootSurfName ) )
+	{//see if the basic name without variants is on
+		Q_strncpyz( returnSurfName, rootSurfName, returnSize, qtrue );
+		return qtrue;
+	}
+	else
+	{//check variants
+		int i;
+		for ( i = 0; i < MAX_VARIANTS; i++ )
+		{
+			Com_sprintf( returnSurfName, returnSize, "%s%c", rootSurfName, 'a'+i );
+			if ( !gi.G2API_GetSurfaceRenderStatus( &ent->ghoul2[ent->playerModel], returnSurfName ) )
+			{
+				return qtrue;
+			}
+		}
+	}
+	Q_strncpyz( returnSurfName, rootSurfName, returnSize, qtrue );
+	return qfalse;
+}
+
+extern qboolean G_StandardHumanoid( gentity_t *self );
+qboolean G_DoDismemberment( gentity_t *self, vec3_t point, int mod, int damage, int hitLoc, qboolean force = qfalse )
+{
+//extern cvar_t	*g_iscensored;
+	// dismemberment -- FIXME: should have a check for how long npc has been dead so people can't
+	// continue to dismember a dead body long after it's been dead
+	//NOTE that you can only cut one thing off unless the dismemberment is == 113811381138
+#ifdef GERMAN_CENSORED
+	if ( 0 ) //germany == censorship
+#else
+	if ( /*!g_iscensored->integer &&*/ ( g_dismemberment->integer || g_saberRealisticCombat->integer > 1 ) && mod == MOD_SABER )//only lightsaber
+#endif
+	{//FIXME: don't do strcmps here
+		if ( G_StandardHumanoid( self ) )
+		{//we're using probabilities
+			//FIXME: check the hitLoc and hitDir against the cap tag for the place 
+			//where the split will be- if the hit dir is roughly perpendicular to 
+			//the direction of the cap, then the split is allowed, otherwise we
+			//hit it at the wrong angle and should not dismember...
+			const char	*limbBone = NULL, *rotateBone = NULL, *limbTagName = NULL, *stubTagName = NULL;
+			int		anim = -1;
+			float	limbRollBase = 0, limbPitchBase = 0;
+			qboolean doDismemberment = qfalse;
+			char	limbName[MAX_QPATH];
+			char	stubName[MAX_QPATH];
+			char	limbCapName[MAX_QPATH];
+			char	stubCapName[MAX_QPATH];
+
+			switch( hitLoc )//self->hitLoc
+			{
+			case HL_LEG_RT:
+				if ( g_dismemberment->integer > 1 )
+				{
+					doDismemberment = qtrue;
+					limbBone = "rtibia";
+					rotateBone = "rtalus";
+					G_GetRootSurfNameWithVariant( self, "r_leg", limbName, sizeof(limbName) );
+					G_GetRootSurfNameWithVariant( self, "hips", stubName, sizeof(stubName) );
+					Com_sprintf( limbCapName, sizeof( limbCapName ), "%s_cap_hips", limbName );
+					Com_sprintf( stubCapName, sizeof( stubCapName), "%s_cap_r_leg", stubName );
+					limbTagName = "*r_leg_cap_hips";
+					stubTagName = "*hips_cap_r_leg";
+					anim = BOTH_DISMEMBER_RLEG;
+					limbRollBase = 0;
+					limbPitchBase = 0;
+				}
+				break;
+			case HL_LEG_LT:
+				if ( g_dismemberment->integer > 1 )
+				{
+					doDismemberment = qtrue;
+					limbBone = "ltibia";
+					rotateBone = "ltalus";
+					G_GetRootSurfNameWithVariant( self, "l_leg", limbName, sizeof(limbName) );
+					G_GetRootSurfNameWithVariant( self, "hips", stubName, sizeof(stubName) );
+					Com_sprintf( limbCapName, sizeof( limbCapName ), "%s_cap_hips", limbName );
+					Com_sprintf( stubCapName, sizeof( stubCapName), "%s_cap_l_leg", stubName );
+					limbTagName = "*l_leg_cap_hips";
+					stubTagName = "*hips_cap_l_leg";
+					anim = BOTH_DISMEMBER_LLEG;
+					limbRollBase = 0;
+					limbPitchBase = 0;
+				}
+				break;
+			case HL_WAIST:
+				if ( g_dismemberment->integer > 2 &&
+					(!self->s.number||!self->message))
+				{
+					doDismemberment = qtrue;
+					limbBone = "pelvis";
+					rotateBone = "thoracic";
+					Q_strncpyz( limbName, "torso", sizeof( limbName ) );
+					Q_strncpyz( limbCapName, "torso_cap_hips", sizeof( limbCapName ) );
+					Q_strncpyz( stubCapName, "hips_cap_torso", sizeof( stubCapName ) );
+					limbTagName = "*torso_cap_hips";
+					stubTagName = "*hips_cap_torso";
+					anim = BOTH_DISMEMBER_TORSO1;
+					limbRollBase = 0;
+					limbPitchBase = 0;
+				}
+				break;
+			case HL_CHEST_RT:
+			case HL_ARM_RT:
+			case HL_BACK_RT:
+				if ( g_dismemberment->integer )
+				{
+					doDismemberment = qtrue;
+					limbBone = "rhumerus";
+					rotateBone = "rradius";
+					G_GetRootSurfNameWithVariant( self, "r_arm", limbName, sizeof(limbName) );
+					G_GetRootSurfNameWithVariant( self, "torso", stubName, sizeof(stubName) );
+					Com_sprintf( limbCapName, sizeof( limbCapName ), "%s_cap_torso", limbName );
+					Com_sprintf( stubCapName, sizeof( stubCapName), "%s_cap_r_arm", stubName );
+					limbTagName = "*r_arm_cap_torso";
+					stubTagName = "*torso_cap_r_arm";
+					anim = BOTH_DISMEMBER_RARM;
+					limbRollBase = 0;
+					limbPitchBase = 0;
+				}
+				break;
+			case HL_CHEST_LT:
+			case HL_ARM_LT:
+			case HL_BACK_LT:
+				if ( g_dismemberment->integer &&
+					(!self->s.number||!self->message))
+				{//either the player or not carrying a key on my arm
+					doDismemberment = qtrue;
+					limbBone = "lhumerus";
+					rotateBone = "lradius";
+					G_GetRootSurfNameWithVariant( self, "l_arm", limbName, sizeof(limbName) );
+					G_GetRootSurfNameWithVariant( self, "torso", stubName, sizeof(stubName) );
+					Com_sprintf( limbCapName, sizeof( limbCapName ), "%s_cap_torso", limbName );
+					Com_sprintf( stubCapName, sizeof( stubCapName), "%s_cap_l_arm", stubName );
+					limbTagName = "*l_arm_cap_torso";
+					stubTagName = "*torso_cap_l_arm";
+					anim = BOTH_DISMEMBER_LARM;
+					limbRollBase = 0;
+					limbPitchBase = 0;
+				}
+				break;
+			case HL_HAND_RT:
+				if ( g_dismemberment->integer )
+				{
+					doDismemberment = qtrue;
+					limbBone = "rradiusX";
+					rotateBone = "rhand";
+					G_GetRootSurfNameWithVariant( self, "r_hand", limbName, sizeof(limbName) );
+					G_GetRootSurfNameWithVariant( self, "r_arm", stubName, sizeof(stubName) );
+					Com_sprintf( limbCapName, sizeof( limbCapName ), "%s_cap_r_arm", limbName );
+					Com_sprintf( stubCapName, sizeof( stubCapName), "%s_cap_r_hand", stubName );
+					limbTagName = "*r_hand_cap_r_arm";
+					stubTagName = "*r_arm_cap_r_hand";
+					anim = BOTH_DISMEMBER_RARM;
+					limbRollBase = 0;
+					limbPitchBase = 0;
+				}
+				break;
+			case HL_HAND_LT:
+				if ( g_dismemberment->integer )
+				{
+					doDismemberment = qtrue;
+					limbBone = "lradiusX";
+					rotateBone = "lhand";
+					G_GetRootSurfNameWithVariant( self, "l_hand", limbName, sizeof(limbName) );
+					G_GetRootSurfNameWithVariant( self, "l_arm", stubName, sizeof(stubName) );
+					Com_sprintf( limbCapName, sizeof( limbCapName ), "%s_cap_l_arm", limbName );
+					Com_sprintf( stubCapName, sizeof( stubCapName), "%s_cap_l_hand", stubName );
+					limbTagName = "*l_hand_cap_l_arm";
+					stubTagName = "*l_arm_cap_l_hand";
+					anim = BOTH_DISMEMBER_LARM;
+					limbRollBase = 0;
+					limbPitchBase = 0;
+				}
+				break;
+			case HL_HEAD:
+				if ( g_dismemberment->integer > 2 )
+				{
+					doDismemberment = qtrue;
+					limbBone = "cervical";
+					rotateBone = "cranium";
+					Q_strncpyz( limbName, "head", sizeof( limbName ) );
+					Q_strncpyz( limbCapName, "head_cap_torso", sizeof( limbCapName ) );
+					Q_strncpyz( stubCapName, "torso_cap_head", sizeof( stubCapName ) );
+					limbTagName = "*head_cap_torso";
+					stubTagName = "*torso_cap_head";
+					anim = BOTH_DISMEMBER_HEAD1;
+					limbRollBase = -1;
+					limbPitchBase = -1;
+				}
+				break;
+			case HL_FOOT_RT:
+			case HL_FOOT_LT:
+			case HL_CHEST:
+			case HL_BACK:
+			default:
+				break;
+			}
+			if ( doDismemberment )
+			{
+				return G_Dismember( self, point, limbBone, rotateBone, limbName, 
+					limbCapName, stubCapName, limbTagName, stubTagName,
+					anim, limbRollBase, limbPitchBase, damage, hitLoc );
+			}
+		}
+	}
+	return qfalse;
+}
+
+static int G_CheckSpecialDeathAnim( gentity_t *self, vec3_t point, int damage, int mod, int hitLoc )
+{
+	int deathAnim = -1;
+
+	if ( self->client->ps.legsAnim == BOTH_GETUP_BROLL_L
+		|| self->client->ps.legsAnim == BOTH_GETUP_BROLL_R )
+	{//rolling away to the side on our back
+		deathAnim = BOTH_DEATH_LYING_UP;
+	}
+	else if ( self->client->ps.legsAnim == BOTH_GETUP_FROLL_L
+		|| self->client->ps.legsAnim == BOTH_GETUP_FROLL_R )
+	{//rolling away to the side on our front
+		deathAnim = BOTH_DEATH_LYING_DN;
+	}
+	else if ( self->client->ps.legsAnim == BOTH_GETUP_BROLL_F
+		&& self->client->ps.legsAnimTimer > 350 )
+	{//kicking up 
+		deathAnim = BOTH_DEATH_FALLING_UP;
+	}
+	else if ( self->client->ps.legsAnim == BOTH_GETUP_BROLL_B
+		&& self->client->ps.legsAnimTimer > 950 )
+	{//on back, rolling back to get up
+		deathAnim = BOTH_DEATH_LYING_UP;
+	}
+	else if ( self->client->ps.legsAnim == BOTH_GETUP_BROLL_B
+		&& self->client->ps.legsAnimTimer <= 950
+		&& self->client->ps.legsAnimTimer > 250 )
+	{//flipping over backwards
+		deathAnim = BOTH_FALLDEATH1LAND;
+	}
+	else if ( self->client->ps.legsAnim == BOTH_GETUP_FROLL_B
+		&& self->client->ps.legsAnimTimer <= 1100
+		&& self->client->ps.legsAnimTimer > 250 )
+	{//flipping over backwards
+		deathAnim = BOTH_FALLDEATH1LAND;
+	}
+	else if ( PM_InRoll( &self->client->ps ) )
+	{
+		deathAnim = BOTH_DEATH_ROLL;		//# Death anim from a roll
+	}
+	else if ( PM_FlippingAnim( self->client->ps.legsAnim ) )
+	{
+		deathAnim = BOTH_DEATH_FLIP;		//# Death anim from a flip
+	}
+	else if ( PM_SpinningAnim( self->client->ps.legsAnim ) )
+	{
+		float yawDiff = AngleNormalize180(AngleNormalize180(self->client->renderInfo.torsoAngles[YAW]) - AngleNormalize180(self->client->ps.viewangles[YAW]));
+		if ( yawDiff > 135 || yawDiff < -135 )
+		{
+			deathAnim = BOTH_DEATH_SPIN_180;	//# Death anim when facing backwards
+		}
+		else if ( yawDiff < -60 )
+		{
+			deathAnim = BOTH_DEATH_SPIN_90_R;	//# Death anim when facing 90 degrees right
+		}
+		else if ( yawDiff > 60 )
+		{
+			deathAnim = BOTH_DEATH_SPIN_90_L;	//# Death anim when facing 90 degrees left
+		}
+	}
+	else if ( PM_InKnockDown( &self->client->ps ) )
+	{//since these happen a lot, let's handle them case by case
+		int animLength = PM_AnimLength( self->client->clientInfo.animFileIndex, (animNumber_t)self->client->ps.legsAnim );
+		if ( self->s.number < MAX_CLIENTS )
+		{
+			switch ( self->client->ps.legsAnim )
+			{
+			case BOTH_KNOCKDOWN1:
+			case BOTH_KNOCKDOWN2:
+			case BOTH_KNOCKDOWN3:
+			case BOTH_KNOCKDOWN4:
+			case BOTH_KNOCKDOWN5:
+			//case BOTH_PLAYER_PA_3_FLY:
+				animLength += PLAYER_KNOCKDOWN_HOLD_EXTRA_TIME;
+				break;
+			}
+		}
+		switch ( self->client->ps.legsAnim )
+		{
+		case BOTH_KNOCKDOWN1:
+			if ( animLength - self->client->ps.legsAnimTimer > 100 )
+			{//on our way down
+				if ( self->client->ps.legsAnimTimer > 600 )
+				{//still partially up
+					deathAnim = BOTH_DEATH_FALLING_UP;
+				}
+				else
+				{//down
+					deathAnim = BOTH_DEATH_LYING_UP;
+				}
+			}
+			break;
+		case BOTH_PLAYER_PA_3_FLY:
+		case BOTH_KNOCKDOWN2:
+			if ( animLength - self->client->ps.legsAnimTimer > 700 )
+			{//on our way down
+				if ( self->client->ps.legsAnimTimer > 600 )
+				{//still partially up
+					deathAnim = BOTH_DEATH_FALLING_UP;
+				}
+				else
+				{//down
+					deathAnim = BOTH_DEATH_LYING_UP;
+				}
+			}
+			break;
+		case BOTH_KNOCKDOWN3:
+			if ( animLength - self->client->ps.legsAnimTimer > 100 )
+			{//on our way down
+				if ( self->client->ps.legsAnimTimer > 1300 )
+				{//still partially up
+					deathAnim = BOTH_DEATH_FALLING_DN;
+				}
+				else
+				{//down
+					deathAnim = BOTH_DEATH_LYING_DN;
+				}
+			}
+			break;
+		case BOTH_KNOCKDOWN4:
+		case BOTH_RELEASED:
+			if ( animLength - self->client->ps.legsAnimTimer > 300 )
+			{//on our way down
+				if ( self->client->ps.legsAnimTimer > 350 )
+				{//still partially up
+					deathAnim = BOTH_DEATH_FALLING_UP;
+				}
+				else
+				{//down
+					deathAnim = BOTH_DEATH_LYING_UP;
+				}
+			}
+			else
+			{//crouch death
+				vec3_t fwd;
+				AngleVectors( self->currentAngles, fwd, NULL, NULL );
+				float	thrown = DotProduct( fwd, self->client->ps.velocity );
+				if ( thrown < -150 )
+				{
+					deathAnim = BOTH_DEATHBACKWARD1;	//# Death anim when crouched and thrown back
+				}
+				else
+				{
+					deathAnim = BOTH_DEATH_CROUCHED;	//# Death anim when crouched
+				}
+			}
+			break;
+		case BOTH_KNOCKDOWN5:
+		case BOTH_LK_DL_ST_T_SB_1_L:
+			if ( self->client->ps.legsAnimTimer < 750 )
+			{//flat
+				deathAnim = BOTH_DEATH_LYING_DN;
+			}
+			break;
+		case BOTH_GETUP1:
+			if ( self->client->ps.legsAnimTimer < 350 )
+			{//standing up
+			}
+			else if ( self->client->ps.legsAnimTimer < 800 )
+			{//crouching
+				vec3_t fwd;
+				AngleVectors( self->currentAngles, fwd, NULL, NULL );
+				float	thrown = DotProduct( fwd, self->client->ps.velocity );
+				if ( thrown < -150 )
+				{
+					deathAnim = BOTH_DEATHBACKWARD1;	//# Death anim when crouched and thrown back
+				}
+				else
+				{
+					deathAnim = BOTH_DEATH_CROUCHED;	//# Death anim when crouched
+				}
+			}
+			else
+			{//lying down
+				if ( animLength - self->client->ps.legsAnimTimer > 450 )
+				{//partially up
+					deathAnim = BOTH_DEATH_FALLING_UP;
+				}
+				else
+				{//down
+					deathAnim = BOTH_DEATH_LYING_UP;
+				}
+			}
+			break;
+		case BOTH_GETUP2:
+			if ( self->client->ps.legsAnimTimer < 150 )
+			{//standing up
+			}
+			else if ( self->client->ps.legsAnimTimer < 850 )
+			{//crouching
+				vec3_t fwd;
+				AngleVectors( self->currentAngles, fwd, NULL, NULL );
+				float	thrown = DotProduct( fwd, self->client->ps.velocity );
+				if ( thrown < -150 )
+				{
+					deathAnim = BOTH_DEATHBACKWARD1;	//# Death anim when crouched and thrown back
+				}
+				else
+				{
+					deathAnim = BOTH_DEATH_CROUCHED;	//# Death anim when crouched
+				}
+			}
+			else
+			{//lying down
+				if ( animLength - self->client->ps.legsAnimTimer > 500 )
+				{//partially up
+					deathAnim = BOTH_DEATH_FALLING_UP;
+				}
+				else
+				{//down
+					deathAnim = BOTH_DEATH_LYING_UP;
+				}
+			}
+			break;
+		case BOTH_GETUP3:
+			if ( self->client->ps.legsAnimTimer < 250 )
+			{//standing up
+			}
+			else if ( self->client->ps.legsAnimTimer < 600 )
+			{//crouching
+				vec3_t fwd;
+				AngleVectors( self->currentAngles, fwd, NULL, NULL );
+				float	thrown = DotProduct( fwd, self->client->ps.velocity );
+				if ( thrown < -150 )
+				{
+					deathAnim = BOTH_DEATHBACKWARD1;	//# Death anim when crouched and thrown back
+				}
+				else
+				{
+					deathAnim = BOTH_DEATH_CROUCHED;	//# Death anim when crouched
+				}
+			}
+			else
+			{//lying down
+				if ( animLength - self->client->ps.legsAnimTimer > 150 )
+				{//partially up
+					deathAnim = BOTH_DEATH_FALLING_DN;
+				}
+				else
+				{//down
+					deathAnim = BOTH_DEATH_LYING_DN;
+				}
+			}
+			break;
+		case BOTH_GETUP4:
+			if ( self->client->ps.legsAnimTimer < 250 )
+			{//standing up
+			}
+			else if ( self->client->ps.legsAnimTimer < 600 )
+			{//crouching
+				vec3_t fwd;
+				AngleVectors( self->currentAngles, fwd, NULL, NULL );
+				float	thrown = DotProduct( fwd, self->client->ps.velocity );
+				if ( thrown < -150 )
+				{
+					deathAnim = BOTH_DEATHBACKWARD1;	//# Death anim when crouched and thrown back
+				}
+				else
+				{
+					deathAnim = BOTH_DEATH_CROUCHED;	//# Death anim when crouched
+				}
+			}
+			else
+			{//lying down
+				if ( animLength - self->client->ps.legsAnimTimer > 850 )
+				{//partially up
+					deathAnim = BOTH_DEATH_FALLING_DN;
+				}
+				else
+				{//down
+					deathAnim = BOTH_DEATH_LYING_UP;
+				}
+			}
+			break;
+		case BOTH_GETUP5:
+			if ( self->client->ps.legsAnimTimer > 850 )
+			{//lying down
+				if ( animLength - self->client->ps.legsAnimTimer > 1500 )
+				{//partially up
+					deathAnim = BOTH_DEATH_FALLING_DN;
+				}
+				else
+				{//down
+					deathAnim = BOTH_DEATH_LYING_DN;
+				}
+			}
+			break;
+		case BOTH_GETUP_CROUCH_B1:
+			if ( self->client->ps.legsAnimTimer < 800 )
+			{//crouching
+				vec3_t fwd;
+				AngleVectors( self->currentAngles, fwd, NULL, NULL );
+				float	thrown = DotProduct( fwd, self->client->ps.velocity );
+				if ( thrown < -150 )
+				{
+					deathAnim = BOTH_DEATHBACKWARD1;	//# Death anim when crouched and thrown back
+				}
+				else
+				{
+					deathAnim = BOTH_DEATH_CROUCHED;	//# Death anim when crouched
+				}
+			}
+			else
+			{//lying down
+				if ( animLength - self->client->ps.legsAnimTimer > 400 )
+				{//partially up
+					deathAnim = BOTH_DEATH_FALLING_UP;
+				}
+				else
+				{//down
+					deathAnim = BOTH_DEATH_LYING_UP;
+				}
+			}
+			break;
+		case BOTH_GETUP_CROUCH_F1:
+			if ( self->client->ps.legsAnimTimer < 800 )
+			{//crouching
+				vec3_t fwd;
+				AngleVectors( self->currentAngles, fwd, NULL, NULL );
+				float	thrown = DotProduct( fwd, self->client->ps.velocity );
+				if ( thrown < -150 )
+				{
+					deathAnim = BOTH_DEATHBACKWARD1;	//# Death anim when crouched and thrown back
+				}
+				else
+				{
+					deathAnim = BOTH_DEATH_CROUCHED;	//# Death anim when crouched
+				}
+			}
+			else
+			{//lying down
+				if ( animLength - self->client->ps.legsAnimTimer > 150 )
+				{//partially up
+					deathAnim = BOTH_DEATH_FALLING_DN;
+				}
+				else
+				{//down
+					deathAnim = BOTH_DEATH_LYING_DN;
+				}
+			}
+			break;
+		case BOTH_FORCE_GETUP_B1:
+			if ( self->client->ps.legsAnimTimer < 325 )
+			{//standing up
+			}
+			else if ( self->client->ps.legsAnimTimer < 725 )
+			{//spinning up
+				deathAnim = BOTH_DEATH_SPIN_180;	//# Death anim when facing backwards
+			}
+			else if ( self->client->ps.legsAnimTimer < 900 )
+			{//crouching
+				vec3_t fwd;
+				AngleVectors( self->currentAngles, fwd, NULL, NULL );
+				float	thrown = DotProduct( fwd, self->client->ps.velocity );
+				if ( thrown < -150 )
+				{
+					deathAnim = BOTH_DEATHBACKWARD1;	//# Death anim when crouched and thrown back
+				}
+				else
+				{
+					deathAnim = BOTH_DEATH_CROUCHED;	//# Death anim when crouched
+				}
+			}
+			else
+			{//lying down
+				if ( animLength - self->client->ps.legsAnimTimer > 50 )
+				{//partially up
+					deathAnim = BOTH_DEATH_FALLING_UP;
+				}
+				else
+				{//down
+					deathAnim = BOTH_DEATH_LYING_UP;
+				}
+			}
+			break;
+		case BOTH_FORCE_GETUP_B2:
+			if ( self->client->ps.legsAnimTimer < 575 )
+			{//standing up
+			}
+			else if ( self->client->ps.legsAnimTimer < 875 )
+			{//spinning up
+				deathAnim = BOTH_DEATH_SPIN_180;	//# Death anim when facing backwards
+			}
+			else if ( self->client->ps.legsAnimTimer < 900 )
+			{//crouching
+				vec3_t fwd;
+				AngleVectors( self->currentAngles, fwd, NULL, NULL );
+				float	thrown = DotProduct( fwd, self->client->ps.velocity );
+				if ( thrown < -150 )
+				{
+					deathAnim = BOTH_DEATHBACKWARD1;	//# Death anim when crouched and thrown back
+				}
+				else
+				{
+					deathAnim = BOTH_DEATH_CROUCHED;	//# Death anim when crouched
+				}
+			}
+			else
+			{//lying down
+				//partially up
+				deathAnim = BOTH_DEATH_FALLING_UP;
+			}
+			break;
+		case BOTH_FORCE_GETUP_B3:
+			if ( self->client->ps.legsAnimTimer < 150 )
+			{//standing up
+			}
+			else if ( self->client->ps.legsAnimTimer < 775 )
+			{//flipping
+				deathAnim = BOTH_DEATHBACKWARD2; //backflip
+			}
+			else
+			{//lying down
+				//partially up
+				deathAnim = BOTH_DEATH_FALLING_UP;
+			}
+			break;
+		case BOTH_FORCE_GETUP_B4:
+			if ( self->client->ps.legsAnimTimer < 325 )
+			{//standing up
+			}
+			else
+			{//lying down
+				if ( animLength - self->client->ps.legsAnimTimer > 150 )
+				{//partially up
+					deathAnim = BOTH_DEATH_FALLING_UP;
+				}
+				else
+				{//down
+					deathAnim = BOTH_DEATH_LYING_UP;
+				}
+			}
+			break;
+		case BOTH_FORCE_GETUP_B5:
+			if ( self->client->ps.legsAnimTimer < 550 )
+			{//standing up
+			}
+			else if ( self->client->ps.legsAnimTimer < 1025 )
+			{//kicking up
+				deathAnim = BOTH_DEATHBACKWARD2; //backflip
+			}
+			else
+			{//lying down
+				if ( animLength - self->client->ps.legsAnimTimer > 50 )
+				{//partially up
+					deathAnim = BOTH_DEATH_FALLING_UP;
+				}
+				else
+				{//down
+					deathAnim = BOTH_DEATH_LYING_UP;
+				}
+			}
+			break;
+		case BOTH_FORCE_GETUP_B6:
+			if ( self->client->ps.legsAnimTimer < 225 )
+			{//standing up
+			}
+			else if ( self->client->ps.legsAnimTimer < 425 )
+			{//crouching up
+				vec3_t fwd;
+				AngleVectors( self->currentAngles, fwd, NULL, NULL );
+				float	thrown = DotProduct( fwd, self->client->ps.velocity );
+				if ( thrown < -150 )
+				{
+					deathAnim = BOTH_DEATHBACKWARD1;	//# Death anim when crouched and thrown back
+				}
+				else
+				{
+					deathAnim = BOTH_DEATH_CROUCHED;	//# Death anim when crouched
+				}
+			}
+			else if ( self->client->ps.legsAnimTimer < 825 )
+			{//flipping up
+				deathAnim = BOTH_DEATHFORWARD3; //backflip
+			}
+			else
+			{//lying down
+				if ( animLength - self->client->ps.legsAnimTimer > 225 )
+				{//partially up
+					deathAnim = BOTH_DEATH_FALLING_UP;
+				}
+				else
+				{//down
+					deathAnim = BOTH_DEATH_LYING_UP;
+				}
+			}
+			break;
+		case BOTH_FORCE_GETUP_F1:
+			if ( self->client->ps.legsAnimTimer < 275 )
+			{//standing up
+			}
+			else if ( self->client->ps.legsAnimTimer < 750 )
+			{//flipping
+				deathAnim = BOTH_DEATH14;
+			}
+			else
+			{//lying down
+				if ( animLength - self->client->ps.legsAnimTimer > 100 )
+				{//partially up
+					deathAnim = BOTH_DEATH_FALLING_DN;
+				}
+				else
+				{//down
+					deathAnim = BOTH_DEATH_LYING_DN;
+				}
+			}
+			break;
+		case BOTH_FORCE_GETUP_F2:
+			if ( self->client->ps.legsAnimTimer < 1200 )
+			{//standing
+			}
+			else
+			{//lying down
+				if ( animLength - self->client->ps.legsAnimTimer > 225 )
+				{//partially up
+					deathAnim = BOTH_DEATH_FALLING_DN;
+				}
+				else
+				{//down
+					deathAnim = BOTH_DEATH_LYING_DN;
+				}
+			}
+			break;
+		}
+	}
+	else if ( PM_InOnGroundAnim( &self->client->ps ) )
+	{
+		if ( AngleNormalize180(self->client->renderInfo.torsoAngles[PITCH]) < 0 )
+		{
+			deathAnim = BOTH_DEATH_LYING_UP;	//# Death anim when lying on back
+		}
+		else
+		{
+			deathAnim = BOTH_DEATH_LYING_DN;	//# Death anim when lying on front
+		}
+	}
+	else if ( PM_CrouchAnim( self->client->ps.legsAnim ) )
+	{
+		vec3_t fwd;
+		AngleVectors( self->currentAngles, fwd, NULL, NULL );
+		float	thrown = DotProduct( fwd, self->client->ps.velocity );
+		if ( thrown < -200 )
+		{
+			deathAnim = BOTH_DEATHBACKWARD1;	//# Death anim when crouched and thrown back
+			if ( self->client->ps.velocity[2] > 0 && self->client->ps.velocity[2] < 100 )
+			{
+				self->client->ps.velocity[2] = 100;
+			}
+		}
+		else
+		{
+			deathAnim = BOTH_DEATH_CROUCHED;	//# Death anim when crouched
+		}
+	}
+
+	return deathAnim;
+}
+extern qboolean PM_FinishedCurrentLegsAnim( gentity_t *self );
+static int G_PickDeathAnim( gentity_t *self, vec3_t point, int damage, int mod, int hitLoc )
+{//FIXME: play dead flop anims on body if in an appropriate _DEAD anim when this func is called
+	int deathAnim = -1;
+	if ( hitLoc == HL_NONE )
+	{
+		hitLoc = G_GetHitLocation( self, point );//self->hitLoc
+	}
+	//dead flops...if you are already playing a death animation, I guess it can just return directly
+	switch( self->client->ps.legsAnim )
+	{
+	case BOTH_DEATH1:		//# First Death anim
+	case BOTH_DEAD1:
+	case BOTH_DEATH2:			//# Second Death anim
+	case BOTH_DEAD2:
+	case BOTH_DEATH8:			//# 
+	case BOTH_DEAD8:
+	case BOTH_DEATH13:			//# 
+	case BOTH_DEAD13:
+	case BOTH_DEATH14:			//# 
+	case BOTH_DEAD14:
+	case BOTH_DEATH16:			//# 
+	case BOTH_DEAD16:
+	case BOTH_DEADBACKWARD1:		//# First thrown backward death finished pose
+	case BOTH_DEADBACKWARD2:		//# Second thrown backward death finished pose
+		//return -2;
+		//break;
+		if ( PM_FinishedCurrentLegsAnim( self ) )
+		{//done with the anim
+			deathAnim = BOTH_DEADFLOP2;
+		}
+		else
+		{
+			deathAnim = -2;
+		}
+		return deathAnim;
+		break;
+	case BOTH_DEADFLOP2:
+		//return -2;
+		return BOTH_DEADFLOP2;
+		break;
+	case BOTH_DEATH10:			//# 
+	case BOTH_DEAD10:
+	case BOTH_DEATH15:			//# 
+	case BOTH_DEAD15:
+	case BOTH_DEADFORWARD1:		//# First thrown forward death finished pose
+	case BOTH_DEADFORWARD2:		//# Second thrown forward death finished pose
+		//return -2;
+		//break;
+		if ( PM_FinishedCurrentLegsAnim( self ) )
+		{//done with the anim
+			deathAnim = BOTH_DEADFLOP1;
+		}
+		else
+		{
+			deathAnim = -2;
+		}
+		return deathAnim;
+		break;
+	case BOTH_DEADFLOP1:
+		//return -2;
+		return BOTH_DEADFLOP1;
+		break;
+	case BOTH_DEAD3:				//# Third Death finished pose
+	case BOTH_DEAD4:				//# Fourth Death finished pose
+	case BOTH_DEAD5:				//# Fifth Death finished pose
+	case BOTH_DEAD6:				//# Sixth Death finished pose
+	case BOTH_DEAD7:				//# Seventh Death finished pose
+	case BOTH_DEAD9:				//# 
+	case BOTH_DEAD11:			//#
+	case BOTH_DEAD12:			//# 
+	case BOTH_DEAD17:			//# 
+	case BOTH_DEAD18:			//# 
+	case BOTH_DEAD19:			//# 
+	case BOTH_DEAD20:			//# 
+	case BOTH_DEAD21:			//# 
+	case BOTH_DEAD22:			//# 
+	case BOTH_DEAD23:			//# 
+	case BOTH_DEAD24:			//# 
+	case BOTH_DEAD25:			//# 
+	case BOTH_LYINGDEAD1:		//# Killed lying down death finished pose
+	case BOTH_STUMBLEDEAD1:		//# Stumble forward death finished pose
+	case BOTH_FALLDEAD1LAND:		//# Fall forward and splat death finished pose
+	case BOTH_DEATH3:			//# Third Death anim
+	case BOTH_DEATH4:			//# Fourth Death anim
+	case BOTH_DEATH5:			//# Fifth Death anim
+	case BOTH_DEATH6:			//# Sixth Death anim
+	case BOTH_DEATH7:			//# Seventh Death anim
+	case BOTH_DEATH9:			//# 
+	case BOTH_DEATH11:			//#
+	case BOTH_DEATH12:			//# 
+	case BOTH_DEATH17:			//# 
+	case BOTH_DEATH18:			//# 
+	case BOTH_DEATH19:			//# 
+	case BOTH_DEATH20:			//# 
+	case BOTH_DEATH21:			//# 
+	case BOTH_DEATH22:			//# 
+	case BOTH_DEATH23:			//# 
+	case BOTH_DEATH24:			//# 
+	case BOTH_DEATH25:			//# 
+	case BOTH_DEATHFORWARD1:		//# First Death in which they get thrown forward
+	case BOTH_DEATHFORWARD2:		//# Second Death in which they get thrown forward
+	case BOTH_DEATHFORWARD3:		//# Second Death in which they get thrown forward
+	case BOTH_DEATHBACKWARD1:	//# First Death in which they get thrown backward
+	case BOTH_DEATHBACKWARD2:	//# Second Death in which they get thrown backward
+	case BOTH_DEATH1IDLE:		//# Idle while close to death
+	case BOTH_LYINGDEATH1:		//# Death to play when killed lying down
+	case BOTH_STUMBLEDEATH1:		//# Stumble forward and fall face first death
+	case BOTH_FALLDEATH1:		//# Fall forward off a high cliff and splat death - start
+	case BOTH_FALLDEATH1INAIR:	//# Fall forward off a high cliff and splat death - loop
+	case BOTH_FALLDEATH1LAND:	//# Fall forward off a high cliff and splat death - hit bottom
+		return -2;
+		break;
+	case BOTH_DEATH_ROLL:		//# Death anim from a roll
+	case BOTH_DEATH_FLIP:		//# Death anim from a flip
+	case BOTH_DEATH_SPIN_90_R:	//# Death anim when facing 90 degrees right
+	case BOTH_DEATH_SPIN_90_L:	//# Death anim when facing 90 degrees left
+	case BOTH_DEATH_SPIN_180:	//# Death anim when facing backwards
+	case BOTH_DEATH_LYING_UP:	//# Death anim when lying on back
+	case BOTH_DEATH_LYING_DN:	//# Death anim when lying on front
+	case BOTH_DEATH_FALLING_DN:	//# Death anim when falling on face
+	case BOTH_DEATH_FALLING_UP:	//# Death anim when falling on back
+	case BOTH_DEATH_CROUCHED:	//# Death anim when crouched
+	case BOTH_RIGHTHANDCHOPPEDOFF:
+		return -2;
+		break;
+	}
+	// Not currently playing a death animation, so try and get an appropriate one now.
+	if ( deathAnim == -1 )
+	{
+		deathAnim = G_CheckSpecialDeathAnim( self, point, damage, mod, hitLoc );
+
+		if ( deathAnim == -1 )
+		{//base on hitLoc
+			vec3_t fwd;
+			AngleVectors( self->currentAngles, fwd, NULL, NULL );
+			float	thrown = DotProduct( fwd, self->client->ps.velocity );
+			//death anims
+			switch( hitLoc )
+			{
+			case HL_FOOT_RT:
+				if ( !Q_irand( 0, 2 ) && thrown < 250 )
+				{
+					deathAnim = BOTH_DEATH24;//right foot trips up, spin
+				}
+				else if ( !Q_irand( 0, 1 ) )
+				{
+					if ( !Q_irand( 0, 1 ) )
+					{
+						deathAnim = BOTH_DEATH4;//back: forward
+					}
+					else
+					{
+						deathAnim = BOTH_DEATH16;//same as 1
+					}
+				}
+				else
+				{
+					deathAnim = BOTH_DEATH5;//same as 4
+				}
+				break;
+			case HL_FOOT_LT:
+				if ( !Q_irand( 0, 2 ) && thrown < 250 )
+				{
+					deathAnim = BOTH_DEATH25;//left foot trips up, spin
+				}
+				else if ( !Q_irand( 0, 1 ) )
+				{
+					if ( !Q_irand( 0, 1 ) )
+					{
+						deathAnim = BOTH_DEATH4;//back: forward
+					}
+					else
+					{
+						deathAnim = BOTH_DEATH16;//same as 1
+					}
+				}
+				else
+				{
+					deathAnim = BOTH_DEATH5;//same as 4
+				}
+				break;
+			case HL_LEG_RT:
+				if ( !Q_irand( 0, 2 ) && thrown < 250 )
+				{
+					deathAnim = BOTH_DEATH3;//right leg collapse
+				}
+				else if ( !Q_irand( 0, 1 ) )
+				{
+					deathAnim = BOTH_DEATH5;//same as 4
+				}
+				else
+				{
+					if ( !Q_irand( 0, 1 ) )
+					{
+						deathAnim = BOTH_DEATH4;//back: forward
+					}
+					else
+					{
+						deathAnim = BOTH_DEATH16;//same as 1
+					}
+				}
+				break;
+			case HL_LEG_LT:
+				if ( !Q_irand( 0, 2 ) && thrown < 250 )
+				{
+					deathAnim = BOTH_DEATH7;//left leg collapse
+				}
+				else if ( !Q_irand( 0, 1 ) )
+				{
+					deathAnim = BOTH_DEATH5;//same as 4
+				}
+				else
+				{
+					if ( !Q_irand( 0, 1 ) )
+					{
+						deathAnim = BOTH_DEATH4;//back: forward
+					}
+					else
+					{
+						deathAnim = BOTH_DEATH16;//same as 1
+					}
+				}
+				break;
+			case HL_BACK:
+				if ( fabs(thrown) < 50 || (fabs(thrown) < 200&&!Q_irand(0,3)) )
+				{
+					if ( Q_irand( 0, 1 ) )
+					{
+						deathAnim = BOTH_DEATH17;//head/back: croak
+					}
+					else
+					{
+						deathAnim = BOTH_DEATH10;//back: bend back, fall forward
+					}
+				}
+				else
+				{
+					if ( !Q_irand( 0, 2 ) )
+					{
+						deathAnim = BOTH_DEATH4;//back: forward
+					}
+					else if ( !Q_irand( 0, 1 ) )
+					{
+						deathAnim = BOTH_DEATH5;//back: forward
+					}
+					else
+					{
+						deathAnim = BOTH_DEATH16;//same as 1
+					}
+				}
+				break;
+			case HL_HAND_RT:
+			case HL_CHEST_RT:
+			case HL_ARM_RT:
+			case HL_BACK_LT:
+				if ( (damage <= self->max_health*0.25&&Q_irand(0,1)) || (fabs(thrown)<200&&!Q_irand(0,2)) || !Q_irand( 0, 10 ) )
+				{
+					if ( Q_irand( 0, 1 ) )
+					{
+						deathAnim = BOTH_DEATH9;//chest right: snap, fall forward
+					}
+					else
+					{
+						deathAnim = BOTH_DEATH20;//chest right: snap, fall forward
+					}
+				}
+				else if ( (damage <= self->max_health*0.5&&Q_irand(0,1)) || !Q_irand( 0, 10 ) )
+				{
+					deathAnim = BOTH_DEATH3;//chest right: back
+				}
+				else if ( (damage <= self->max_health*0.75&&Q_irand(0,1)) || !Q_irand( 0, 10 ) )
+				{
+					deathAnim = BOTH_DEATH6;//chest right: spin
+				}
+				else 
+				{
+					//TEMP HACK: play spinny deaths less often
+					if ( Q_irand( 0, 1 ) )
+					{
+						deathAnim = BOTH_DEATH8;//chest right: spin high
+					}
+					else
+					{
+						switch ( Q_irand( 0, 3 ) )
+						{
+						default:
+						case 0:
+							deathAnim = BOTH_DEATH9;//chest right: snap, fall forward
+							break;
+						case 1:
+							deathAnim = BOTH_DEATH3;//chest right: back
+							break;
+						case 2:
+							deathAnim = BOTH_DEATH6;//chest right: spin
+							break;
+						case 3:
+							deathAnim = BOTH_DEATH20;//chest right: spin
+							break;
+						}
+					}
+				}
+				break;
+			case HL_CHEST_LT:
+			case HL_ARM_LT:
+			case HL_HAND_LT:
+			case HL_BACK_RT:
+				if ( (damage <= self->max_health*0.25&&Q_irand(0,1)) || (fabs(thrown)<200&&!Q_irand(0,2)) || !Q_irand(0, 10) )
+				{
+					if ( Q_irand( 0, 1 ) )
+					{
+						deathAnim = BOTH_DEATH11;//chest left: snap, fall forward
+					}
+					else
+					{
+						deathAnim = BOTH_DEATH21;//chest left: snap, fall forward
+					}
+				}
+				else if ( (damage <= self->max_health*0.5&&Q_irand(0,1)) || !Q_irand(0, 10) )
+				{
+					deathAnim = BOTH_DEATH7;//chest left: back
+				}
+				else if ( (damage <= self->max_health*0.75&&Q_irand(0,1)) || !Q_irand(0, 10) )
+				{
+					deathAnim = BOTH_DEATH12;//chest left: spin
+				}
+				else
+				{
+					//TEMP HACK: play spinny deaths less often
+					if ( Q_irand( 0, 1 ) )
+					{
+						deathAnim = BOTH_DEATH14;//chest left: spin high
+					}
+					else
+					{
+						switch ( Q_irand( 0, 3 ) )
+						{
+						default:
+						case 0:
+							deathAnim = BOTH_DEATH11;//chest left: snap, fall forward
+							break;
+						case 1:
+							deathAnim = BOTH_DEATH7;//chest left: back
+							break;
+						case 2:
+							deathAnim = BOTH_DEATH12;//chest left: spin
+							break;
+						case 3:
+							deathAnim = BOTH_DEATH21;//chest left: spin
+							break;
+						}
+					}
+				}
+				break;
+			case HL_CHEST:
+			case HL_WAIST:
+				if ( (damage <= self->max_health*0.25&&Q_irand(0,1)) || thrown > -50 )
+				{
+					if ( !Q_irand( 0, 1 ) )
+					{
+						deathAnim = BOTH_DEATH18;//gut: fall right
+					}
+					else
+					{
+						deathAnim = BOTH_DEATH19;//gut: fall left
+					}
+				}
+				else if ( (damage <= self->max_health*0.5&&!Q_irand(0,1)) || (fabs(thrown)<200&&!Q_irand(0,3)) )
+				{
+					if ( Q_irand( 0, 2 ) )
+					{
+						deathAnim = BOTH_DEATH2;//chest: backward short
+					}
+					else if ( Q_irand( 0, 1 ) )
+					{
+						deathAnim = BOTH_DEATH22;//chest: backward short
+					}
+					else
+					{
+						deathAnim = BOTH_DEATH23;//chest: backward short
+					}
+				}
+				else if ( thrown < -300 && Q_irand( 0, 1 ) )
+				{
+					if ( Q_irand( 0, 1 ) )
+					{
+						deathAnim = BOTH_DEATHBACKWARD1;//chest: fly back
+					}
+					else
+					{
+						deathAnim = BOTH_DEATHBACKWARD2;//chest: flip back
+					}
+				}
+				else if ( thrown < -200 && Q_irand( 0, 1 ) )
+				{
+					deathAnim = BOTH_DEATH15;//chest: roll backward
+				}
+				else 
+				{
+					deathAnim = BOTH_DEATH1;//chest: backward med
+				}
+				break;
+			case HL_HEAD:
+				if ( damage <= self->max_health*0.5 && Q_irand(0,2) )
+				{
+					deathAnim = BOTH_DEATH17;//head/back: croak
+				}
+				else
+				{
+					if ( Q_irand( 0, 2 ) )
+					{
+						deathAnim = BOTH_DEATH13;//head: stumble, fall back
+					}
+					else
+					{
+						deathAnim = BOTH_DEATH10;//head: stumble, fall back
+					}
+				}
+				break;
+			default:
+				break;
+			}
+		}
+	}
+
+	// Validate.....
+	if ( deathAnim == -1 || !PM_HasAnimation( self, deathAnim ))
+	{
+		if ( deathAnim == BOTH_DEADFLOP1
+			|| deathAnim == BOTH_DEADFLOP2 )
+		{//if don't have deadflop, don't do anything
+			deathAnim = -1;
+		}
+		else
+		{
+			// I guess we'll take what we can get.....
+			deathAnim = PM_PickAnim( self, BOTH_DEATH1, BOTH_DEATH25 );
+		}
+	}
+
+	return deathAnim;
+}
+
+int G_CheckLedgeDive( gentity_t *self, float checkDist, const vec3_t checkVel, qboolean tryOpposite, qboolean tryPerp )
+{
+	//		Intelligent Ledge-Diving Deaths:
+	//		If I'm an NPC, check for nearby ledges and fall off it if possible
+	//		How should/would/could this interact with knockback if we already have some?
+	//		Ideally - apply knockback if there are no ledges or a ledge in that dir
+	//		But if there is a ledge and it's not in the dir of my knockback, fall off the ledge instead
+	if ( !self || !self->client )
+	{
+		return 0;
+	}
+
+	vec3_t	fallForwardDir, fallRightDir;
+	vec3_t	angles = {0};
+	int		cliff_fall = 0;
+
+	if ( checkVel && !VectorCompare( checkVel, vec3_origin ) )
+	{//already moving in a dir
+		angles[1] = vectoyaw( self->client->ps.velocity );
+		AngleVectors( angles, fallForwardDir, fallRightDir, NULL );
+	}
+	else
+	{//try forward first
+		angles[1] = self->client->ps.viewangles[1];
+		AngleVectors( angles, fallForwardDir, fallRightDir, NULL );
+	}
+	VectorNormalize( fallForwardDir );
+	float fallDist = G_CheckForLedge( self, fallForwardDir, checkDist );
+	if ( fallDist >= 128 )
+	{
+		VectorClear( self->client->ps.velocity );
+		G_Throw( self, fallForwardDir, 85 );
+		self->client->ps.velocity[2] = 100;
+		self->client->ps.groundEntityNum = ENTITYNUM_NONE;
+	}
+	else if ( tryOpposite )
+	{
+		VectorScale( fallForwardDir, -1, fallForwardDir );
+		fallDist = G_CheckForLedge( self, fallForwardDir, checkDist );
+		if ( fallDist >= 128 )
+		{
+			VectorClear( self->client->ps.velocity );
+			G_Throw( self, fallForwardDir, 85 );
+			self->client->ps.velocity[2] = 100;
+			self->client->ps.groundEntityNum = ENTITYNUM_NONE;
+		}
+	}
+	if ( !cliff_fall && tryPerp )
+	{//try sides
+		VectorNormalize( fallRightDir );
+		fallDist = G_CheckForLedge( self, fallRightDir, checkDist );
+		if ( fallDist >= 128 )
+		{
+			VectorClear( self->client->ps.velocity );
+			G_Throw( self, fallRightDir, 85 );
+			self->client->ps.velocity[2] = 100;
+		}
+		else 
+		{
+			VectorScale( fallRightDir, -1, fallRightDir );
+			fallDist = G_CheckForLedge( self, fallRightDir, checkDist );
+			if ( fallDist >= 128 )
+			{
+				VectorClear( self->client->ps.velocity );
+				G_Throw( self, fallRightDir, 85 );
+				self->client->ps.velocity[2] = 100;
+			}
+		}
+	}
+	if ( fallDist >= 256 )
+	{
+		cliff_fall = 2;
+	}
+	else if ( fallDist >= 128 )
+	{
+		cliff_fall = 1;
+	}
+	return cliff_fall;
+}
+
+/*
+==================
+player_die
+==================
+*/
+void NPC_SetAnim(gentity_t	*ent,int setAnimParts,int anim,int setAnimFlags, int iBlend);
+extern void AI_DeleteSelfFromGroup( gentity_t *self );
+extern void AI_GroupMemberKilled( gentity_t *self );
+extern qboolean FlyingCreature( gentity_t *ent );
+extern void G_DrivableATSTDie( gentity_t *self );
+extern void JET_FlyStop( gentity_t *self );
+extern void VehicleExplosionDelay( gentity_t *self );
+extern void NPC_LeaveTroop(gentity_t* actor);
+extern void Rancor_DropVictim( gentity_t *self );
+extern void Wampa_DropVictim( gentity_t *self );
+extern void WP_StopForceHealEffects( gentity_t *self );
+void player_die( gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int meansOfDeath, int dflags, int hitLoc ) 
+{
+	int			anim;
+	int			contents;
+	qboolean	deathScript = qfalse;
+	qboolean	lastInGroup = qfalse;
+	qboolean	specialAnim = qfalse;
+	qboolean	holdingSaber = qfalse;
+	int			cliff_fall = 0;
+
+	//FIXME: somehow people are sometimes not completely dying???
+	if ( self->client->ps.pm_type == PM_DEAD && (meansOfDeath != MOD_SNIPER || (self->flags & FL_DISINTEGRATED)) )
+	{//do dismemberment/twitching
+		if ( self->client->NPC_class == CLASS_MARK1 )
+		{
+			DeathFX(self);
+			self->takedamage = qfalse;
+			self->client->ps.eFlags |= EF_NODRAW;
+			self->contents = 0;
+			// G_FreeEntity( self ); // Is this safe?  I can't see why we'd mark it nodraw and then just leave it around??
+			self->e_ThinkFunc = thinkF_G_FreeEntity;
+			self->nextthink = level.time + FRAMETIME;
+		}
+		else
+		{
+			anim = G_PickDeathAnim( self, self->pos1, damage, meansOfDeath, hitLoc );
+			if ( dflags & DAMAGE_DISMEMBER )
+			{
+				G_DoDismemberment( self, self->pos1, meansOfDeath, damage, hitLoc );
+			}
+			if ( anim >= 0 )
+			{
+				NPC_SetAnim(self, SETANIM_BOTH, anim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_RESTART|SETANIM_FLAG_HOLD);
+			}
+		}
+		return;
+	}
+
+	// If the entity is in a vehicle.
+	if ( self->client && self->client->NPC_class != CLASS_VEHICLE && self->s.m_iVehicleNum != 0 )
+	{
+		Vehicle_t *pVeh = g_entities[self->s.m_iVehicleNum].m_pVehicle;
+		if (pVeh)
+		{
+			if ( pVeh->m_pOldPilot != self
+				&& pVeh->m_pPilot != self )
+			{//whaaa?  I'm not on this bike?  er....
+				assert(!!"How did we get to this point?");
+			}
+			else
+			{	// Get thrown out.
+				pVeh->m_pVehicleInfo->Eject( pVeh, self, qtrue );
+
+				// Now Send The Vehicle Flying To It's Death
+				if (pVeh->m_pVehicleInfo->type==VH_SPEEDER && pVeh->m_pParentEntity && pVeh->m_pParentEntity->client)
+				{
+					gentity_t*	parent = pVeh->m_pParentEntity;
+					float		CurSpeed = VectorLength(parent->client->ps.velocity);
+
+					// If Moving
+					//-----------
+					if (CurSpeed>(pVeh->m_pVehicleInfo->speedMax*0.5f))
+					{
+						// Send The Bike Out Of Control
+						//------------------------------
+						pVeh->m_pVehicleInfo->StartDeathDelay(pVeh, 10000);
+						pVeh->m_ulFlags		|= (VEH_OUTOFCONTROL);
+						VectorScale(parent->client->ps.velocity, 1.25f, parent->pos3);
+
+
+						// Try To Accelerate A Slowing Moving Vehicle To Full Speed
+						//----------------------------------------------------------
+						if (CurSpeed<(pVeh->m_pVehicleInfo->speedMax*0.9f))
+						{
+							VectorNormalize(parent->pos3);
+							if (fabsf(parent->pos3[2])<0.3f)
+							{
+								VectorScale(parent->pos3, (pVeh->m_pVehicleInfo->speedMax * 1.25f), parent->pos3);
+							}
+							else
+							{
+								VectorClear(parent->pos3);
+							}
+						}
+
+						// Throw The Pilot
+						//----------------
+						if (parent->pos3[0] || parent->pos3[1])
+						{
+							vec3_t	throwDir;
+
+							VectorCopy(parent->client->ps.velocity, throwDir);
+							VectorNormalize(throwDir);
+							throwDir[2] += 0.3f;	// up a little
+
+							self->client->noRagTime = -1;	// no ragdoll for you
+							CurSpeed /= 10.0f;
+							if (CurSpeed<50.0)
+							{
+								CurSpeed = 50.0f;
+							}
+							if (throwDir[2]<0.0f)
+							{
+								throwDir[2] = fabsf(throwDir[2]);
+							}
+							if (fabsf(throwDir[0])<0.2f)
+							{
+								throwDir[0] = Q_flrand(-0.5f, 0.5f);
+							}
+							if (fabsf(throwDir[1])<0.2f)
+							{
+								throwDir[1] = Q_flrand(-0.5f, 0.5f);
+							}
+							G_Throw(self, throwDir, CurSpeed);
+						}
+					}
+				}
+			}
+		}
+		else
+		{
+			assert(!!"How did we get to this point?");
+		}
+	}
+
+#ifndef FINAL_BUILD
+	if ( d_saberCombat->integer && attacker && attacker->client )
+	{
+		gi.Printf( S_COLOR_YELLOW"combatant %s died, killer anim = %s\n", self->targetname, animTable[attacker->client->ps.torsoAnim].name );
+	}
+#endif//FINAL_BUILD
+	if ( self->NPC )
+	{
+		if (NAV::HasPath(self))
+		{
+			NAV::ClearPath(self);
+		}
+		if (self->NPC->troop)
+		{
+			NPC_LeaveTroop(self);
+		}
+		// STEER_TODO: Do we need to free the steer user too?
+
+		//clear charmed
+		G_CheckCharmed( self );
+
+		// Remove The Bubble Shield From The Assassin Droid
+		if (self->client && self->client->NPC_class==CLASS_ASSASSIN_DROID && (self->flags&FL_SHIELDED))
+		{
+			self->flags &= ~FL_SHIELDED;
+			self->client->ps.stats[STAT_ARMOR] = 0;
+			self->client->ps.powerups[PW_GALAK_SHIELD] = 0;
+			gi.G2API_SetSurfaceOnOff( &self->ghoul2[self->playerModel], "force_shield", TURN_OFF );
+		}
+
+		if (self->client && self->client->NPC_class==CLASS_HOWLER)
+		{
+			G_StopEffect( G_EffectIndex( "howler/sonic" ), self->playerModel, self->genericBolt1, self->s.number );
+		}
+
+
+
+		if ( self->client && Jedi_WaitingAmbush( self ) )
+		{//ambushing trooper
+			self->client->noclip = false;
+		}
+		NPC_FreeCombatPoint( self->NPC->combatPoint );
+		if ( self->NPC->group )
+		{
+			lastInGroup = (self->NPC->group->numGroup < 2);
+			AI_GroupMemberKilled( self );
+			AI_DeleteSelfFromGroup( self );
+		}
+
+		if ( self->NPC->tempGoal )
+		{
+			G_FreeEntity( self->NPC->tempGoal );
+			self->NPC->tempGoal = NULL;
+		}
+		if ( self->s.eFlags & EF_LOCKED_TO_WEAPON )
+		{
+			// dumb, just get the NPC out of the chair
+extern void RunEmplacedWeapon( gentity_t *ent, usercmd_t **ucmd );
+
+			usercmd_t cmd, *ad_cmd;
+
+			memset( &cmd, 0, sizeof( usercmd_t ));
+
+			//gentity_t *old = self->owner;
+
+			if ( self->owner )
+			{
+				self->owner->s.frame = self->owner->startFrame = self->owner->endFrame = 0;
+				self->owner->svFlags &= ~SVF_ANIMATING;
+			}
+
+			cmd.buttons |= BUTTON_USE;
+			ad_cmd = &cmd;
+			RunEmplacedWeapon( self, &ad_cmd );
+			//self->owner = old;
+		}
+		if ( self->client->NPC_class == CLASS_BOBAFETT 
+			|| self->client->NPC_class == CLASS_ROCKETTROOPER )
+		{
+			if ( self->client->moveType == MT_FLYSWIM )
+			{
+				JET_FlyStop( self );
+			}
+		}
+		if ( self->client->NPC_class == CLASS_ROCKETTROOPER )
+		{
+			self->client->ps.eFlags &= ~EF_SPOTLIGHT;
+		}
+		if ( self->client->NPC_class == CLASS_SAND_CREATURE )
+		{
+			self->client->ps.eFlags &= ~EF_NODRAW;
+			self->s.eFlags &= ~EF_NODRAW;
+		}
+		if ( self->client->NPC_class == CLASS_RANCOR )
+		{
+			if ( self->count )
+			{
+				Rancor_DropVictim( self );
+			}
+		}
+		if ( self->client->NPC_class == CLASS_WAMPA )
+		{
+			if ( self->count )
+			{
+				if ( self->activator && attacker == self->activator && meansOfDeath == MOD_SABER )
+				{
+					self->client->dismembered = false;
+					//FIXME: the limb should just disappear, cuz I ate it
+					G_DoDismemberment( self, self->currentOrigin, MOD_SABER, 1000, HL_ARM_RT, qtrue );
+				}
+				Wampa_DropVictim( self );
+			}
+		}
+		if ( (self->NPC->aiFlags&NPCAI_HEAL_ROSH) )
+		{
+			if ( self->client->leader )
+			{
+				self->client->leader->flags &= ~FL_UNDYING;
+				if ( self->client->leader->client )
+				{
+					self->client->leader->client->ps.forcePowersKnown &= ~FORCE_POWERS_ROSH_FROM_TWINS;
+				}
+			}
+		}
+		if ( (self->client->ps.stats[STAT_WEAPONS]&(1<<WP_SCEPTER)) )
+		{
+			G_StopEffect( G_EffectIndex( "scepter/beam_warmup.efx" ), self->weaponModel[1], self->genericBolt1, self->s.number );
+			G_StopEffect( G_EffectIndex( "scepter/beam.efx" ), self->weaponModel[1], self->genericBolt1, self->s.number );
+			G_StopEffect( G_EffectIndex( "scepter/slam_warmup.efx" ), self->weaponModel[1], self->genericBolt1, self->s.number );
+			self->s.loopSound = 0;
+		}
+	}
+	if ( attacker && attacker->NPC && attacker->NPC->group && attacker->NPC->group->enemy == self )
+	{
+		attacker->NPC->group->enemy = NULL;
+	}
+	if ( self->s.weapon == WP_SABER )
+	{
+		holdingSaber = qtrue;
+	}
+	if ( self->client->ps.saberEntityNum != ENTITYNUM_NONE && self->client->ps.saberEntityNum > 0 )
+	{
+		if ( self->client->ps.saberInFlight )
+		{//just drop it
+			self->client->ps.saber[0].Deactivate();
+		}
+		else
+		{
+			if ( (  
+					(hitLoc != HL_HAND_RT&&hitLoc !=HL_CHEST_RT&&hitLoc!=HL_ARM_RT&&hitLoc!=HL_BACK_LT)
+					|| self->client->dismembered
+					|| meansOfDeath != MOD_SABER 
+				  )//if might get hand cut off, leave saber in hand
+				&& holdingSaber
+				&& ( Q_irand( 0, 1 ) 
+					|| meansOfDeath == MOD_EXPLOSIVE 
+					|| meansOfDeath == MOD_REPEATER_ALT
+					|| meansOfDeath == MOD_FLECHETTE_ALT
+					|| meansOfDeath == MOD_ROCKET
+					|| meansOfDeath == MOD_ROCKET_ALT
+					|| meansOfDeath == MOD_CONC
+					|| meansOfDeath == MOD_CONC_ALT
+					|| meansOfDeath == MOD_THERMAL
+					|| meansOfDeath == MOD_THERMAL_ALT
+					|| meansOfDeath == MOD_DETPACK
+					|| meansOfDeath == MOD_LASERTRIP
+					|| meansOfDeath == MOD_LASERTRIP_ALT
+					|| meansOfDeath == MOD_MELEE
+					|| meansOfDeath == MOD_FORCE_GRIP
+					|| meansOfDeath == MOD_KNOCKOUT
+					|| meansOfDeath == MOD_CRUSH
+					|| meansOfDeath == MOD_IMPACT
+					|| meansOfDeath == MOD_FALLING
+					|| meansOfDeath == MOD_EXPLOSIVE_SPLASH ) )
+			{//drop it
+				TossClientItems( self );
+				self->client->ps.weapon = self->s.weapon = WP_NONE;
+			}
+			else
+			{//just free it
+				if ( g_entities[self->client->ps.saberEntityNum].inuse )
+				{
+					G_FreeEntity( &g_entities[self->client->ps.saberEntityNum] );
+				}
+				self->client->ps.saberEntityNum = ENTITYNUM_NONE;
+			}
+		}
+	}
+	if ( self->client->NPC_class == CLASS_SHADOWTROOPER )
+	{//drop a force crystal
+		if ( Q_stricmpn("shadowtrooper", self->NPC_type, 13 ) == 0 )
+		{
+			gitem_t		*item;
+			item = FindItemForAmmo( AMMO_FORCE );
+			Drop_Item( self, item, 0, qtrue );
+		}
+	}
+	//Use any target we had
+	if ( meansOfDeath != MOD_KNOCKOUT )
+	{
+		G_UseTargets( self, self );
+	}
+
+	if ( attacker )
+	{
+		if ( attacker->client && !attacker->s.number )
+		{
+			if ( self->client )
+			{//killed a client
+				if ( self->client->playerTeam == TEAM_ENEMY 
+					|| self->client->playerTeam == TEAM_FREE
+					|| (self->NPC && self->NPC->charmedTime > level.time) )
+				{//killed an enemy
+					attacker->client->sess.missionStats.enemiesKilled++;
+				}
+			}
+			if ( attacker != self )
+			{
+				G_TrackWeaponUsage( attacker, inflictor, 30, meansOfDeath );
+			}
+		}
+		G_CheckVictoryScript(attacker);
+		//player killing a jedi with a lightsaber spawns a matrix-effect entity
+		if ( d_slowmodeath->integer )
+		{
+			if ( !self->s.number )
+			{//what the hell, always do slow-mo when player dies
+				//FIXME: don't do this when crushed to death?
+				if ( meansOfDeath == MOD_FALLING && self->client->ps.groundEntityNum == ENTITYNUM_NONE )
+				{//falling to death, have not hit yet
+					G_StartMatrixEffect( self, (MEF_NO_VERTBOB|MEF_HIT_GROUND_STOP|MEF_MULTI_SPIN), 10000, 0.25f );
+				}
+				else if ( meansOfDeath != MOD_CRUSH )
+				{//for all deaths except being crushed
+					G_StartMatrixEffect( self );
+				}
+			}
+			else if ( d_slowmodeath->integer < 4 )
+			{//any jedi killed by player-saber
+				if ( d_slowmodeath->integer < 3 )
+				{//must be the last jedi in the room
+					if ( !G_JediInRoom( attacker->currentOrigin ) )
+					{
+						lastInGroup = qtrue;
+					}
+					else
+					{
+						lastInGroup = qfalse;
+					}
+				}
+				if ( !attacker->s.number 
+					&& (holdingSaber||self->client->NPC_class==CLASS_WAMPA)
+					&& meansOfDeath == MOD_SABER 
+					&& attacker->client 
+					&& attacker->client->ps.weapon == WP_SABER 
+					&& !attacker->client->ps.saberInFlight //FIXME: if dualSabers, should still do slowmo if this killing blow was struck with the left-hand saber...
+					&& (d_slowmodeath->integer > 2||lastInGroup) )//either slow mo death level 3 (any jedi) or 2 and I was the last jedi in the room
+				{//Matrix!
+					if ( attacker->client->ps.torsoAnim == BOTH_A6_SABERPROTECT )
+					{//don't override the range and vertbob
+						G_StartMatrixEffect( self, (MEF_NO_RANGEVAR|MEF_NO_VERTBOB) );
+					}
+					else
+					{
+						G_StartMatrixEffect( self );
+					}
+				}
+			}
+			else
+			{//all player-saber kills
+				if ( !attacker->s.number 
+					&& meansOfDeath == MOD_SABER 
+					&& attacker->client 
+					&& attacker->client->ps.weapon == WP_SABER 
+					&& !attacker->client->ps.saberInFlight 
+					&& (d_slowmodeath->integer > 4||lastInGroup||holdingSaber||self->client->NPC_class==CLASS_WAMPA))//either slow mo death level 5 (any enemy) or 4 and I was the last in my group or I'm a saber user
+				{//Matrix!
+					if ( attacker->client->ps.torsoAnim == BOTH_A6_SABERPROTECT )
+					{//don't override the range and vertbob
+						G_StartMatrixEffect( self, (MEF_NO_RANGEVAR|MEF_NO_VERTBOB) );
+					}
+					else
+					{
+						G_StartMatrixEffect( self );
+					}
+				}
+			}
+		}
+	}
+
+	self->enemy = attacker;
+	self->client->renderInfo.lookTarget = ENTITYNUM_NONE;
+
+	self->client->ps.persistant[PERS_KILLED]++;
+	if ( self->client->playerTeam == TEAM_PLAYER )
+	{//FIXME: just HazTeam members in formation on away missions?
+		//or more controlled- via deathscripts?
+		// Don't count player
+		if (( &g_entities[0] != NULL && g_entities[0].client ) && (self->s.number != 0))
+		{//add to the number of teammates lost
+			g_entities[0].client->ps.persistant[PERS_TEAMMATES_KILLED]++;
+		}
+		else	// Player died, fire off scoreboard soon
+		{
+			cg.missionStatusDeadTime = level.time + 1000;	// Too long?? Too short??
+			cg.zoomMode = 0; // turn off zooming when we die
+		}
+	}
+
+	if ( self->s.number == 0 && attacker )
+	{
+//		G_SetMissionStatusText( attacker, meansOfDeath );
+		//TEST: If player killed, unmark all teammates from being undying so they can buy it too
+		//NOTE: we want this to happen ONLY on our squad ONLY on missions... in the tutorial or on voyager levels this could be really weird.
+		G_MakeTeamVulnerable();
+	}
+
+	if ( attacker && attacker->client) 
+	{
+		if ( attacker == self || OnSameTeam (self, attacker ) ) 
+		{
+			AddScore( attacker, -1 );
+		} 
+		else 
+		{
+			AddScore( attacker, 1 );
+		}
+	} 
+	else 
+	{
+		AddScore( self, -1 );
+	}
+
+	// if client is in a nodrop area, don't drop anything
+	contents = gi.pointcontents( self->currentOrigin, -1 );
+	if ( !holdingSaber
+		//&& self->s.number != 0 
+		&& !( contents & CONTENTS_NODROP ) 
+		&& meansOfDeath != MOD_SNIPER 
+		&& (!self->client||self->client->NPC_class!=CLASS_GALAKMECH))
+	{
+		TossClientItems( self );
+	}
+
+	if ( meansOfDeath == MOD_SNIPER )
+	{//I was disintegrated
+		if ( self->message )
+		{//I was holding a key
+			//drop the key
+			G_DropKey( self );
+		}
+	}
+
+	if ( holdingSaber )
+	{//never drop a lightsaber!
+		if ( self->client->ps.SaberActive() )
+		{
+			self->client->ps.SaberDeactivate();
+			G_SoundIndexOnEnt( self, CHAN_AUTO, self->client->ps.saber[0].soundOff );
+#ifdef _IMMERSION
+			if ( self->client->playerTeam == TEAM_PLAYER )
+			{
+				G_Force( self, G_ForceIndex( "fffx/weapons/saber/saberoff", FF_CHANNEL_WEAPON ) );
+			}
+			else
+			{
+				G_Force( self, G_ForceIndex( "fffx/weapons/saber/enemy_saber_off", FF_CHANNEL_WEAPON ) );
+			}
+#endif // _IMMERSION
+		}
+	}
+	else if ( self->s.weapon != WP_BRYAR_PISTOL )
+	{//since player can't pick up bryar pistols, never drop those
+		self->s.weapon = WP_NONE;
+		G_RemoveWeaponModels( self );
+	}
+
+	self->s.powerups &= ~PW_REMOVE_AT_DEATH;//removes everything but electricity and force push
+
+	//FIXME: do this on a callback?  So people can't walk through long death anims?
+	//Maybe set on last frame?  Would be cool for big blocking corpses if the never got set?
+	//self->contents = CONTENTS_CORPSE;//now done a second after death
+	/*
+	self->takedamage = qfalse;	// no gibbing
+	if ( self->client->playerTeam == TEAM_PARASITE )
+	{
+		self->contents = CONTENTS_NONE; // FIXME: temp fix
+	}
+	else
+	{
+		self->contents = CONTENTS_CORPSE;
+		self->maxs[2] = -8;
+	}
+	*/
+	if ( !self->s.number )
+	{//player
+		self->contents = CONTENTS_CORPSE;
+		self->maxs[2] = -8;
+	}
+	self->clipmask&=~(CONTENTS_MONSTERCLIP|CONTENTS_BOTCLIP);//so dead NPC can fly off ledges
+	
+	//FACING==========================================================
+	if ( attacker && self->s.number == 0 )
+	{
+		self->client->ps.stats[STAT_DEAD_YAW] = AngleNormalize180( self->client->ps.viewangles[YAW] );
+	}
+	self->currentAngles[PITCH] = 0; 
+	self->currentAngles[ROLL] = 0;
+	if ( self->NPC )
+	{
+		self->NPC->desiredYaw = 0; 
+		self->NPC->desiredPitch = 0;
+		self->NPC->confusionTime = 0;
+		self->NPC->charmedTime = 0;
+		if ( self->ghoul2.size() )
+		{
+			if ( self->chestBolt != -1 )
+			{
+				G_StopEffect("force/rage2", self->playerModel, self->chestBolt, self->s.number );
+			}
+			if ( self->headBolt != -1 )
+			{
+				G_StopEffect("force/confusion", self->playerModel, self->headBolt, self->s.number );
+			}
+			WP_StopForceHealEffects( self );
+		}
+	}
+	VectorCopy( self->currentAngles, self->client->ps.viewangles );
+	//FACING==========================================================
+	if ( player && player->client && player->client->ps.viewEntity == self->s.number )
+	{//I was the player's viewentity and I died, kick him back to his normal view
+		G_ClearViewEntity( player );
+	}
+	else if ( !self->s.number && self->client->ps.viewEntity > 0 && self->client->ps.viewEntity < ENTITYNUM_NONE )
+	{
+		G_ClearViewEntity( self );
+	}
+	else if ( !self->s.number && self->client->ps.viewEntity > 0 && self->client->ps.viewEntity < ENTITYNUM_NONE )
+	{
+		G_ClearViewEntity( self );
+	}
+
+	self->s.loopSound = 0;
+
+	// remove powerups
+	memset( self->client->ps.powerups, 0, sizeof(self->client->ps.powerups) );
+
+	if ( (self->client->ps.eFlags&EF_HELD_BY_RANCOR)
+		|| (self->client->ps.eFlags&EF_HELD_BY_SAND_CREATURE)
+		|| (self->client->ps.eFlags&EF_HELD_BY_WAMPA) )
+	{//do nothing special here
+	}
+	else if ( self->client->NPC_class == CLASS_MARK1 )
+	{
+		Mark1_die( self, inflictor, attacker, damage, meansOfDeath, dflags, hitLoc );
+	}
+	else if ( self->client->NPC_class == CLASS_INTERROGATOR )
+	{
+		Interrogator_die( self, inflictor, attacker, damage, meansOfDeath, dflags, hitLoc );
+	}
+	else if ( self->client->NPC_class == CLASS_GALAKMECH )
+	{//FIXME: need keyframed explosions?
+		NPC_SetAnim( self, SETANIM_BOTH, BOTH_DEATH1, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+		G_AddEvent( self, Q_irand(EV_DEATH1, EV_DEATH3), self->health );
+	}
+	else if ( self->client->NPC_class == CLASS_ATST )
+	{//FIXME: need keyframed explosions
+		if ( !self->s.number )
+		{
+			G_DrivableATSTDie( self );
+		}
+		anim = PM_PickAnim( self, BOTH_DEATH1, BOTH_DEATH25 );	//initialize to good data
+		if ( anim != -1 )
+		{
+			NPC_SetAnim( self, SETANIM_BOTH, anim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+		}
+	}
+	else if ( self->s.number && self->message && meansOfDeath != MOD_SNIPER )
+	{//imp with a key on his arm
+		//pick a death anim that leaves key visible
+		switch ( Q_irand( 0, 3 ) )
+		{
+		case 0:
+			anim = BOTH_DEATH4;
+			break;
+		case 1:
+			anim = BOTH_DEATH21;
+			break;
+		case 2:
+			anim = BOTH_DEATH17;
+			break;
+		case 3:
+		default:
+			anim = BOTH_DEATH18;
+			break;
+		}
+		//FIXME: verify we have this anim?
+		NPC_SetAnim( self, SETANIM_BOTH, anim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+		if ( meansOfDeath == MOD_KNOCKOUT || meansOfDeath == MOD_MELEE )
+		{
+			G_AddEvent( self, EV_JUMP, 0 );
+		}
+		else if ( meansOfDeath == MOD_FORCE_DRAIN )
+		{
+			G_AddEvent( self, EV_WATER_DROWN, 0 );
+		}
+		else if ( meansOfDeath == MOD_GAS )
+		{
+			G_AddEvent( self, EV_WATER_DROWN, 0 );
+		}
+		else
+		{
+			G_AddEvent( self, Q_irand(EV_DEATH1, EV_DEATH3), self->health );
+		}
+	}
+	else if ( meansOfDeath == MOD_FALLING || (self->client->ps.legsAnim == BOTH_FALLDEATH1INAIR && self->client->ps.torsoAnim == BOTH_FALLDEATH1INAIR) || (self->client->ps.legsAnim == BOTH_FALLDEATH1 && self->client->ps.torsoAnim == BOTH_FALLDEATH1) )
+	{
+		//FIXME: no good way to predict you're going to fall to your death... need falling bushes/triggers?
+		if ( self->client->ps.groundEntityNum == ENTITYNUM_NONE //in the air
+			&& self->client->ps.velocity[2] < 0 //falling
+			&& self->client->ps.legsAnim != BOTH_FALLDEATH1INAIR //not already in falling loop
+			&& self->client->ps.torsoAnim != BOTH_FALLDEATH1INAIR )//not already in falling loop
+		{
+			NPC_SetAnim(self, SETANIM_BOTH, BOTH_FALLDEATH1INAIR, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD);
+			if ( !self->NPC )
+			{
+				G_SoundOnEnt( self, CHAN_VOICE, "*falling1.wav" );//CHAN_VOICE_ATTEN
+			}
+			else if (!(self->NPC->aiFlags&NPCAI_DIE_ON_IMPACT) )
+			{
+				G_SoundOnEnt( self, CHAN_VOICE, "*falling1.wav" );//CHAN_VOICE_ATTEN
+				//so we don't do this again
+				self->NPC->aiFlags |= NPCAI_DIE_ON_IMPACT;
+				//self->client->ps.gravity *= 0.5;//Fall a bit slower
+				self->client->ps.friction = 1;
+			}
+		}
+		else
+		{
+			int	deathAnim = BOTH_FALLDEATH1LAND;
+			if ( PM_InOnGroundAnim( &self->client->ps ) )
+			{
+				if ( AngleNormalize180(self->client->renderInfo.torsoAngles[PITCH]) < 0 )
+				{
+					deathAnim = BOTH_DEATH_LYING_UP;	//# Death anim when lying on back
+				}
+				else
+				{
+					deathAnim = BOTH_DEATH_LYING_DN;	//# Death anim when lying on front
+				}
+			}
+			else if ( PM_InKnockDown( &self->client->ps ) )
+			{
+				if ( AngleNormalize180(self->client->renderInfo.torsoAngles[PITCH]) < 0 )
+				{
+					deathAnim = BOTH_DEATH_FALLING_UP;	//# Death anim when falling on back
+				}
+				else
+				{
+					deathAnim = BOTH_DEATH_FALLING_DN;	//# Death anim when falling on face
+				}
+			}
+			NPC_SetAnim(self, SETANIM_BOTH, deathAnim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD);
+			//HMM: check for nodrop?
+			G_SoundOnEnt( self, CHAN_BODY, "sound/player/fallsplat.wav" );
+			if ( gi.VoiceVolume[self->s.number]
+				&& self->NPC && (self->NPC->aiFlags&NPCAI_DIE_ON_IMPACT) )
+			{//I was talking, so cut it off... with a jump sound?
+				G_SoundOnEnt( self, CHAN_VOICE_ATTEN, "*pain100.wav" );
+			}
+		}
+	}
+	else
+	{// normal death
+		anim = G_CheckSpecialDeathAnim( self, self->pos1, damage, meansOfDeath, hitLoc );
+		if ( anim == -1 )
+		{
+			if ( PM_InOnGroundAnim( &self->client->ps ) && PM_HasAnimation( self, BOTH_LYINGDEATH1 ) )
+			{//on ground, need different death anim
+				anim = BOTH_LYINGDEATH1;
+			}
+			else if ( meansOfDeath == MOD_TRIGGER_HURT && (self->s.powerups&(1<<PW_SHOCKED)) )
+			{//electrocuted
+				anim = BOTH_DEATH17;
+			}
+			else if ( meansOfDeath == MOD_WATER || meansOfDeath == MOD_GAS || meansOfDeath == MOD_FORCE_DRAIN )
+			{//drowned
+				anim = BOTH_DEATH17;
+			}
+			else if ( meansOfDeath != MOD_SNIPER //disintegrates
+				&& meansOfDeath != MOD_CONC_ALT )//does its own death throw
+			{
+				cliff_fall = G_CheckLedgeDive( self, 128, self->client->ps.velocity, qtrue, qfalse );
+				if ( cliff_fall == 2 )
+				{
+					if ( !FlyingCreature( self ) && g_gravity->value > 0 )
+					{
+						if ( !self->NPC )
+						{
+							G_SoundOnEnt( self, CHAN_VOICE, "*falling1.wav" );//CHAN_VOICE_ATTEN
+						}
+						else if (!(self->NPC->aiFlags&NPCAI_DIE_ON_IMPACT) )
+						{
+							G_SoundOnEnt( self, CHAN_VOICE, "*falling1.wav" );//CHAN_VOICE_ATTEN
+							self->NPC->aiFlags |= NPCAI_DIE_ON_IMPACT;
+							self->client->ps.friction = 0;
+						}
+					}
+				}
+				if ( self->client->ps.pm_time > 0 && self->client->ps.pm_flags & PMF_TIME_KNOCKBACK && self->client->ps.velocity[2] > 0 )
+				{
+					float	thrown, dot;
+					vec3_t	throwdir, forward;
+					
+					AngleVectors(self->currentAngles, forward, NULL, NULL);
+					thrown = VectorNormalize2(self->client->ps.velocity, throwdir);
+					dot = DotProduct(forward, throwdir);
+					if ( thrown > 100 ) 
+					{
+						if ( dot > 0.3 )
+						{//falling forward
+							if ( cliff_fall == 2 && PM_HasAnimation( self, BOTH_FALLDEATH1 ) )
+							{
+								anim = BOTH_FALLDEATH1;
+							}
+							else
+							{
+								switch ( Q_irand( 0, 7 ) )
+								{
+								case 0:
+								case 1:
+									anim = BOTH_DEATH4;
+									break;
+								case 2:
+									anim = BOTH_DEATH16;
+									break;
+								case 3:
+								case 4:
+								case 5:
+									anim = BOTH_DEATH5;
+									break;
+								case 6:
+									anim = BOTH_DEATH8;
+									break;
+								case 7:
+									anim = BOTH_DEATH14;
+									break;
+								}
+								if ( PM_HasAnimation( self, anim ))
+								{
+									self->client->ps.gravity *= 0.8;
+									self->client->ps.friction = 0;
+									if ( self->client->ps.velocity[2] > 0 && self->client->ps.velocity[2] < 100 )
+									{
+										self->client->ps.velocity[2] = 100;
+									}
+								}
+								else
+								{
+									anim = -1;
+								}
+							}
+						}
+						else if ( dot < -0.3 ) 
+						{
+							if ( thrown >= 250 && !Q_irand( 0, 3 ) )
+							{
+								if ( Q_irand( 0, 1 ) )
+								{
+									anim = BOTH_DEATHBACKWARD1;
+								}
+								else
+								{
+									anim = BOTH_DEATHBACKWARD2;
+								}
+							}
+							else
+							{
+								switch ( Q_irand( 0, 7 ) )
+								{
+								case 0:
+								case 1:
+									anim = BOTH_DEATH1;
+									break;
+								case 2:
+								case 3:
+									anim = BOTH_DEATH2;
+									break;
+								case 4:
+								case 5:
+									anim = BOTH_DEATH22;
+									break;
+								case 6:
+								case 7:
+									anim = BOTH_DEATH23;
+									break;
+								}
+							}
+							if ( PM_HasAnimation( self, anim ) ) 
+							{
+								self->client->ps.gravity *= 0.8;
+								self->client->ps.friction = 0;
+								if ( self->client->ps.velocity[2] > 0 && self->client->ps.velocity[2] < 100 )
+								{
+									self->client->ps.velocity[2] = 100;
+								}
+							}
+							else
+							{
+								anim = -1;
+							} 
+						}
+						else
+						{//falling to one of the sides
+							if ( cliff_fall == 2 && PM_HasAnimation( self, BOTH_FALLDEATH1 ) )
+							{
+								anim = BOTH_FALLDEATH1;
+								if ( self->client->ps.velocity[2] > 0 && self->client->ps.velocity[2] < 100 )
+								{
+									self->client->ps.velocity[2] = 100;
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+		else
+		{
+			specialAnim = qtrue;
+		}
+
+		if ( anim == -1 )
+		{
+			if ( meansOfDeath == MOD_ELECTROCUTE 
+				|| (meansOfDeath == MOD_CRUSH && self->s.eFlags&EF_FORCE_GRIPPED) 
+				|| (meansOfDeath == MOD_FORCE_DRAIN && self->s.eFlags&EF_FORCE_DRAINED))
+			{//electrocuted or choked to death
+				anim = BOTH_DEATH17;
+			}
+			else
+			{
+				anim = G_PickDeathAnim( self, self->pos1, damage, meansOfDeath, hitLoc );
+			}
+		}
+		if ( anim == -1 )
+		{
+			anim = PM_PickAnim( self, BOTH_DEATH1, BOTH_DEATH25 );	//initialize to good data
+			//TEMP HACK: these spinny deaths should happen less often
+			if ( ( anim == BOTH_DEATH8 || anim == BOTH_DEATH14 ) && Q_irand( 0, 1 ) )
+			{
+				anim = PM_PickAnim( self, BOTH_DEATH1, BOTH_DEATH25 );	//initialize to good data
+			}
+		}
+		else if ( !PM_HasAnimation( self, anim ) )
+		{//crap, still missing an anim, so pick one that we do have
+            anim = PM_PickAnim( self, BOTH_DEATH1, BOTH_DEATH25 );	//initialize to good data
+		}
+
+
+		if ( meansOfDeath == MOD_KNOCKOUT )
+		{
+			//FIXME: knock-out sound, and don't remove me
+			G_AddEvent( self, EV_JUMP, 0 );
+			G_UseTargets2( self, self, self->target2 );
+			G_AlertTeam( self, attacker, 512, 32 );
+			if ( self->NPC )
+			{//stick around for a while
+				self->NPC->timeOfDeath = level.time + 10000;
+			}
+		}
+		else if ( meansOfDeath == MOD_GAS || meansOfDeath == MOD_FORCE_DRAIN )
+		{
+			G_AddEvent( self, EV_WATER_DROWN, 0 );
+			G_AlertTeam( self, attacker, 512, 32 );
+			if ( self->NPC )
+			{//stick around for a while
+				self->NPC->timeOfDeath = level.time + 10000;
+			}
+		}
+		else if ( meansOfDeath == MOD_SNIPER )
+		{
+			gentity_t	*tent;
+			vec3_t		spot;
+
+			VectorCopy( self->currentOrigin, spot );
+			
+			self->flags |= FL_DISINTEGRATED;
+			self->svFlags |= SVF_BROADCAST;
+			tent = G_TempEntity( spot, EV_DISINTEGRATION );
+			tent->s.eventParm = PW_DISRUPTION;
+			tent->svFlags |= SVF_BROADCAST;
+			tent->owner = self;
+
+			G_AlertTeam( self, attacker, 512, 88 );
+
+			if ( self->playerModel >= 0 )
+			{
+				// don't let 'em animate
+				gi.G2API_PauseBoneAnimIndex( &self->ghoul2[self->playerModel], self->rootBone, cg.time );
+				gi.G2API_PauseBoneAnimIndex( &self->ghoul2[self->playerModel], self->motionBone, cg.time );
+				gi.G2API_PauseBoneAnimIndex( &self->ghoul2[self->playerModel], self->lowerLumbarBone, cg.time );
+				anim = -1;
+			}
+
+			//not solid anymore
+			self->contents = 0;
+			self->maxs[2] = -8;
+
+			if ( self->NPC )
+			{
+				//need to pad deathtime some to stick around long enough for death effect to play
+				self->NPC->timeOfDeath = level.time + 2000;
+			}
+		}
+		else 
+		{
+			if ( hitLoc == HL_HEAD 
+				&& !(dflags&DAMAGE_RADIUS)
+				&& meansOfDeath!=MOD_REPEATER_ALT
+				&& meansOfDeath!=MOD_FLECHETTE_ALT
+				&& meansOfDeath!=MOD_ROCKET
+				&& meansOfDeath!=MOD_ROCKET_ALT
+				&& meansOfDeath!=MOD_CONC
+				&& meansOfDeath!=MOD_THERMAL
+				&& meansOfDeath!=MOD_THERMAL_ALT
+				&& meansOfDeath!=MOD_DETPACK
+				&& meansOfDeath!=MOD_LASERTRIP
+				&& meansOfDeath!=MOD_LASERTRIP_ALT
+				&& meansOfDeath!=MOD_EXPLOSIVE
+				&& meansOfDeath!=MOD_EXPLOSIVE_SPLASH )
+			{//no sound when killed by headshot (explosions don't count)
+				G_AlertTeam( self, attacker, 512, 0 );
+				if ( gi.VoiceVolume[self->s.number] )
+				{//I was talking, so cut it off... with a jump sound?
+					G_SoundOnEnt( self, CHAN_VOICE, "*jump1.wav" );
+				}
+			}
+			else 
+			{
+				if ( (self->client->ps.eFlags&EF_FORCE_GRIPPED) || (self->client->ps.eFlags&EF_FORCE_DRAINED) )
+				{//killed while gripped - no loud scream
+					G_AlertTeam( self, attacker, 512, 32 );
+				}
+				else if ( cliff_fall != 2 )
+				{
+					if ( meansOfDeath == MOD_KNOCKOUT || meansOfDeath == MOD_MELEE )
+					{
+						G_AddEvent( self, EV_JUMP, 0 );
+					}
+					else if ( meansOfDeath == MOD_GAS || meansOfDeath == MOD_FORCE_DRAIN )
+					{
+						G_AddEvent( self, EV_WATER_DROWN, 0 );
+					}
+					else
+					{
+						G_AddEvent( self, Q_irand(EV_DEATH1, EV_DEATH3), self->health );
+					}
+					G_DeathAlert( self, attacker );
+				}
+				else
+				{//screaming death is louder
+					G_AlertTeam( self, attacker, 512, 1024 );
+				}
+			}
+		}
+
+		if ( attacker && attacker->s.number == 0 )
+		{//killed by player
+			//FIXME: this should really be wherever my body comes to rest...
+			AddSightEvent( attacker, self->currentOrigin, 384, AEL_DISCOVERED, 10 );
+			//FIXME: danger event so that others will run away from this area since it's obviously dangerous
+		}
+
+		if ( anim >= 0 )//can be -1 if it fails, -2 if it's already in a death anim
+		{
+			NPC_SetAnim(self, SETANIM_BOTH, anim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD);
+		}
+	}
+
+	//do any dismemberment if there's any to do...
+	if ( (dflags&DAMAGE_DISMEMBER) 
+		&& G_DoDismemberment( self, self->pos1, meansOfDeath, damage, hitLoc ) 
+		&& !specialAnim )
+	{//we did dismemberment and our death anim is okay to override
+		if ( hitLoc == HL_HAND_RT && self->locationDamage[hitLoc] >= Q3_INFINITE && cliff_fall != 2 && self->client->ps.groundEntityNum != ENTITYNUM_NONE )
+		{//just lost our right hand and we're on the ground, use the special anim
+			NPC_SetAnim( self, SETANIM_BOTH, BOTH_RIGHTHANDCHOPPEDOFF, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+		}
+	}
+
+	// don't allow player to respawn for a few seconds
+	self->client->respawnTime = level.time + 2000;//self->client->ps.legsAnimTimer;
+
+//rww - RAGDOLL_BEGIN
+	if (gi.Cvar_VariableIntegerValue("broadsword"))
+	{
+		if ( self->client && (!self->NPC || !G_StandardHumanoid( self ) ) )
+		{
+			PM_SetLegsAnimTimer( self, &self->client->ps.legsAnimTimer, -1 );
+			PM_SetTorsoAnimTimer( self, &self->client->ps.torsoAnimTimer, -1 );
+		}
+	}
+	else
+	{
+		if ( self->client )
+		{
+			PM_SetLegsAnimTimer( self, &self->client->ps.legsAnimTimer, -1 );
+			PM_SetTorsoAnimTimer( self, &self->client->ps.torsoAnimTimer, -1 );
+		}
+	}
+//rww - RAGDOLL_END
+
+	//Flying creatures should drop when killed
+	//FIXME: This may screw up certain things that expect to float even while dead <?>
+	self->svFlags &= ~SVF_CUSTOM_GRAVITY;
+
+	self->client->ps.pm_type = PM_DEAD;
+	self->client->ps.pm_flags &= ~PMF_STUCK_TO_WALL;
+	//need to update STAT_HEALTH here because ClientThink_real for self may happen before STAT_HEALTH is updated from self->health and pmove will stomp death anim with a move anim
+	self->client->ps.stats[STAT_HEALTH] = self->health;
+
+	if ( self->NPC )
+	{//If an NPC, make sure we start running our scripts again- this gets set to infinite while we fall to our deaths
+		self->NPC->nextBStateThink = level.time;
+	}
+
+	if ( G_ActivateBehavior( self, BSET_DEATH ) )
+	{
+		deathScript = qtrue;
+	}
+	
+	if ( self->NPC && (self->NPC->scriptFlags&SCF_FFDEATH) )
+	{
+		if ( G_ActivateBehavior( self, BSET_FFDEATH ) )  
+		{//FIXME: should running this preclude running the normal deathscript?
+			deathScript = qtrue;
+		}
+		G_UseTargets2( self, self, self->target4 );
+	}
+	
+	if ( !deathScript && !(self->svFlags&SVF_KILLED_SELF) )
+	{
+		//Should no longer run scripts
+		//WARNING!!! DO NOT DO THIS WHILE RUNNING A SCRIPT, ICARUS WILL HANDLE IT, but it's bad
+		Quake3Game()->FreeEntity( self );
+	}
+
+	// Free up any timers we may have on us.
+	TIMER_Clear( self->s.number );
+
+	// Set pending objectives to failed
+	OBJ_SetPendingObjectives(self);
+	
+	gi.linkentity (self);
+
+	self->bounceCount = -1; // This is a cheap hack for optimizing the pointcontents check in deadthink
+	if ( self->NPC )
+	{
+		self->NPC->timeOfDeath = level.time;//this will change - used for debouncing post-death events
+		self->s.time = level.time;//this will not chage- this is actual time of death
+	}
+
+	// Start any necessary death fx for this entity
+	DeathFX( self );
+}
+
+qboolean G_CheckForStrongAttackMomentum( gentity_t *self )
+{//see if our saber attack has too much momentum to be interrupted
+	if ( PM_PowerLevelForSaberAnim( &self->client->ps ) > FORCE_LEVEL_2 )
+	{//strong attacks can't be interrupted
+		if ( PM_InAnimForSaberMove( self->client->ps.torsoAnim, self->client->ps.saberMove ) )
+		{//our saberMove was not already interupted by some other anim (like pain)
+			if ( PM_SaberInStart( self->client->ps.saberMove ) )
+			{
+				float animLength = PM_AnimLength( self->client->clientInfo.animFileIndex, (animNumber_t)self->client->ps.torsoAnim );
+				if ( animLength - self->client->ps.torsoAnimTimer > 750 )
+				{//start anim is already 3/4 of a second into it, can't interrupt it now
+					return qtrue;
+				}
+			}
+			else if ( PM_SaberInReturn( self->client->ps.saberMove ) )
+			{
+				if ( self->client->ps.torsoAnimTimer > 750 )
+				{//still have a good amount of time left in the return anim, can't interrupt it
+					return qtrue;
+				}
+			}
+			else
+			{//cannot interrupt actual transitions and attacks
+				return qtrue;
+			}
+		}
+	}
+	return qfalse;
+}
+
+void PlayerPain( gentity_t *self, gentity_t *inflictor, gentity_t *other, const vec3_t point, int damage, int mod, int hitLoc )
+{
+	if ( self->client->NPC_class == CLASS_ATST )
+	{//different kind of pain checking altogether
+		G_ATSTCheckPain( self, other, point, damage, mod, hitLoc );
+		int blasterTest = gi.G2API_GetSurfaceRenderStatus( &self->ghoul2[self->playerModel], "head_light_blaster_cann" );
+		int chargerTest = gi.G2API_GetSurfaceRenderStatus( &self->ghoul2[self->playerModel], "head_concussion_charger" );
+		if ( blasterTest && chargerTest )
+		{//lost both side guns
+			//take away that weapon
+			self->client->ps.stats[STAT_WEAPONS] &= ~( 1 << WP_ATST_SIDE );
+			//switch to primary guns
+			if ( self->client->ps.weapon == WP_ATST_SIDE )
+			{
+				CG_ChangeWeapon( WP_ATST_MAIN );
+			}
+		}
+	}
+	else
+	{
+		// play an apropriate pain sound
+		if ( level.time > self->painDebounceTime && !(self->flags & FL_GODMODE) ) 
+		{//first time hit this frame and not in godmode
+			self->client->ps.damageEvent++;
+			if ( !Q3_TaskIDPending( self, TID_CHAN_VOICE ) )
+			{
+				if ( self->client->damage_blood )
+				{//took damage myself, not just armor
+					if ( mod == MOD_GAS )
+					{
+						//SIGH... because our choke sounds are inappropriately long, I have to debounce them in code!
+						if ( TIMER_Done( self, "gasChokeSound" ) )
+						{
+							TIMER_Set( self, "gasChokeSound", Q_irand( 1000, 2000 ) );
+							G_SpeechEvent( self, Q_irand(EV_CHOKE1, EV_CHOKE3) );
+						}
+						if ( self->painDebounceTime <= level.time )
+						{
+							self->painDebounceTime = level.time + 50;
+						}
+					}
+					else
+					{
+						G_AddEvent( self, EV_PAIN, self->health );
+					}
+				}
+			}
+		}
+		if ( damage != -1 && (mod==MOD_MELEE || damage==0/*fake damage*/ || (Q_irand( 0, 10 ) <= damage && self->client->damage_blood)) )
+		{//-1 == don't play pain anim
+			if ( ( ((mod==MOD_SABER||mod==MOD_MELEE)&&self->client->damage_blood) || mod == MOD_CRUSH ) && (self->s.weapon == WP_SABER||self->s.weapon==WP_MELEE||cg.renderingThirdPerson) )//FIXME: not only if using saber, but if in third person at all?  But then 1st/third person functionality is different...
+			{//FIXME: only strong-level saber attacks should make me play pain anim?
+				if ( !G_CheckForStrongAttackMomentum( self ) && !PM_SpinningSaberAnim( self->client->ps.legsAnim )
+					&& !PM_SaberInSpecialAttack( self->client->ps.torsoAnim )
+					&& !PM_InKnockDown( &self->client->ps ) )
+				{//strong attacks and spins cannot be interrupted by pain, no pain when in knockdown
+					int	parts = SETANIM_BOTH;
+					if ( self->client->ps.groundEntityNum != ENTITYNUM_NONE &&
+						!PM_SpinningSaberAnim( self->client->ps.legsAnim ) &&
+						!PM_FlippingAnim( self->client->ps.legsAnim ) &&
+						!PM_InSpecialJump( self->client->ps.legsAnim ) &&
+						!PM_RollingAnim( self->client->ps.legsAnim )&&
+						!PM_CrouchAnim( self->client->ps.legsAnim )&&
+						!PM_RunningAnim( self->client->ps.legsAnim ))
+					{//if on a surface and not in a spin or flip, play full body pain
+						parts = SETANIM_BOTH;
+					}
+					else
+					{//play pain just in torso
+						parts = SETANIM_TORSO;
+					}
+					if ( self->painDebounceTime < level.time )
+					{
+						//temp HACK: these are the only 2 pain anims that look good when holding a saber
+						NPC_SetAnim( self, parts, PM_PickAnim( self, BOTH_PAIN2, BOTH_PAIN3 ), SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+						self->client->ps.saberMove = LS_READY;//don't finish whatever saber move you may have been in
+						//WTF - insn't working
+						if ( self->health < 10 && d_slowmodeath->integer > 5 )
+						{
+							G_StartMatrixEffect( self );
+						}
+					}
+					if ( parts == SETANIM_BOTH && damage > 30 || (self->painDebounceTime>level.time&&damage>10))
+					{//took a lot of damage in 1 hit //or took 2 hits in quick succession
+						self->aimDebounceTime = level.time + self->client->ps.torsoAnimTimer;
+						self->client->ps.pm_time = self->client->ps.torsoAnimTimer; 
+						self->client->ps.pm_flags |= PMF_TIME_KNOCKBACK;
+					}
+					self->client->ps.weaponTime = self->client->ps.torsoAnimTimer;
+					self->attackDebounceTime = level.time + self->client->ps.torsoAnimTimer;
+				}
+				self->painDebounceTime = level.time + self->client->ps.torsoAnimTimer;
+			}
+		}
+	}
+	if ( mod != MOD_GAS && self->painDebounceTime <= level.time )
+	{
+		self->painDebounceTime = level.time + 700;
+	}
+}
+/*
+================
+CheckArmor
+================
+*/
+int CheckArmor (gentity_t *ent, int damage, int dflags, int mod)
+{
+	gclient_t	*client;
+	int			save;
+	int			count;
+
+	if (!damage)
+		return 0;
+
+	client = ent->client;
+
+	if (!client)
+		return 0;
+
+	if ( (dflags&DAMAGE_NO_ARMOR) )
+	{
+		// If this isn't a vehicle, leave.
+		if ( client->NPC_class != CLASS_VEHICLE )
+		{
+			return 0;
+		}
+	}
+
+	if (client->NPC_class==CLASS_ASSASSIN_DROID)
+	{
+		// The Assassin Always Completely Ignores These Damage Types
+		//-----------------------------------------------------------
+		if (mod==MOD_GAS ||	mod==MOD_IMPACT || mod==MOD_LAVA || mod==MOD_SLIME || mod==MOD_WATER ||
+			mod==MOD_FORCE_GRIP || mod==MOD_FORCE_DRAIN || mod==MOD_SEEKER || mod==MOD_MELEE ||
+			mod==MOD_BOWCASTER || mod==MOD_BRYAR || mod==MOD_BRYAR_ALT || mod==MOD_BLASTER || mod==MOD_BLASTER_ALT ||
+			mod==MOD_SNIPER || mod==MOD_BOWCASTER || mod==MOD_BOWCASTER_ALT || mod==MOD_REPEATER || mod==MOD_REPEATER_ALT)
+		{
+			return damage;
+		}
+
+		// The Assassin Always Takes Half Of These Damage Types
+		//------------------------------------------------------
+		if (mod==MOD_GAS ||	mod==MOD_IMPACT || mod==MOD_LAVA || mod==MOD_SLIME || mod==MOD_WATER)
+		{
+			return damage/2;
+		}
+
+		// If The Shield Is Not On, No Additional Protection
+		//---------------------------------------------------
+		if (!(ent->flags&FL_SHIELDED))
+		{
+			// He Does Ignore Half Saber Damage, Even Shield Down
+			//----------------------------------------------------
+			if (mod==MOD_SABER)
+			{
+				return (int)((float)(damage)*0.75f);
+			}
+			return 0;
+		}
+
+		// If The Shield Is Up, He Ignores These Damage Types
+		//----------------------------------------------------
+		if (mod==MOD_SABER || mod==MOD_FLECHETTE || mod==MOD_FLECHETTE_ALT || mod==MOD_DISRUPTOR)
+		{
+			return damage;
+		}
+
+		// The Demp Completely Destroys The Shield
+		//-----------------------------------------
+		if (mod==MOD_DEMP2 || mod==MOD_DEMP2_ALT)
+		{
+			client->ps.stats[STAT_ARMOR] = 0;
+			return 0;
+		}
+
+		// Otherwise, The Shield Absorbs As Much Damage As Possible
+		//----------------------------------------------------------
+		int	previousArmor			  = client->ps.stats[STAT_ARMOR];
+		client->ps.stats[STAT_ARMOR] -= damage;
+		if (client->ps.stats[STAT_ARMOR]<0)
+		{
+			client->ps.stats[STAT_ARMOR] = 0;
+		}
+		return (previousArmor - client->ps.stats[STAT_ARMOR]);
+	}
+
+
+
+	if ( client->NPC_class == CLASS_GALAKMECH)
+	{//special case
+		if ( client->ps.stats[STAT_ARMOR] <= 0 )
+		{//no shields
+			client->ps.powerups[PW_GALAK_SHIELD] = 0;
+			return 0;
+		}
+		else
+		{//shields take all the damage
+			client->ps.stats[STAT_ARMOR] -= damage;
+			if ( client->ps.stats[STAT_ARMOR] <= 0 )
+			{
+				client->ps.powerups[PW_GALAK_SHIELD] = 0;
+				client->ps.stats[STAT_ARMOR] = 0;
+			}
+			return damage;
+		}
+	}
+	else
+	{
+		// armor
+		count = client->ps.stats[STAT_ARMOR];
+
+		// No damage to entity until armor is at less than 50% strength
+		if (count > (client->ps.stats[STAT_MAX_HEALTH]/2)) // MAX_HEALTH is considered max armor. Or so I'm told.
+		{
+			save = damage;
+		}
+		else
+		{
+			if ( !ent->s.number && client->NPC_class == CLASS_ATST )
+			{//player in ATST... armor takes *all* the damage
+				save = damage;
+			}
+			else
+			{
+				save = ceil( (float) damage * ARMOR_PROTECTION );
+			}
+		}
+
+		//Always round up
+		if (damage == 1)
+		{
+			if ( client->ps.stats[STAT_ARMOR] > 0 ) 
+				client->ps.stats[STAT_ARMOR] -= save;
+			//WTF? returns false 0 if armor absorbs only 1 point of damage
+			return 0;
+		}
+
+		if (save >= count)
+			save = count;
+
+		if (!save)
+			return 0;
+
+		client->ps.stats[STAT_ARMOR] -= save;
+
+		return save;
+	}
+}
+
+extern void NPC_SetPainEvent( gentity_t *self );
+extern qboolean Boba_StopKnockdown( gentity_t *self, gentity_t *pusher, const vec3_t pushDir, qboolean forceKnockdown = qfalse );
+extern qboolean Jedi_StopKnockdown( gentity_t *self, gentity_t *pusher, const vec3_t pushDir );
+void G_Knockdown( gentity_t *self, gentity_t *attacker, const vec3_t pushDir, float strength, qboolean breakSaberLock )
+{
+	if ( !self || !self->client || !attacker || !attacker->client )
+	{
+		return;
+	}
+
+	if ( self->client->NPC_class == CLASS_ROCKETTROOPER )
+	{
+		return;
+	}
+
+	if ( Boba_StopKnockdown( self, attacker, pushDir ) )
+	{
+		return;
+	}
+	else if ( Jedi_StopKnockdown( self, attacker, pushDir ) )
+	{//They can sometimes backflip instead of be knocked down
+		return;
+	}
+	else if ( PM_LockedAnim( self->client->ps.legsAnim ) )
+	{//stuck doing something else
+		return;
+	}
+	else if ( Rosh_BeingHealed( self ) )
+	{
+		return;
+	}
+
+	//break out of a saberLock?
+	if ( self->client->ps.saberLockTime > level.time )
+	{
+		if ( breakSaberLock )
+		{
+			self->client->ps.saberLockTime = 0;
+			self->client->ps.saberLockEnemy = ENTITYNUM_NONE;
+		}
+		else
+		{
+			return;
+		}
+	}
+
+	if ( self->health > 0 )
+	{
+		if ( !self->s.number )
+		{
+			NPC_SetPainEvent( self );
+		}
+		else
+		{
+			GEntity_PainFunc( self, attacker, attacker, self->currentOrigin, 0, MOD_MELEE );
+		}
+		
+		G_CheckLedgeDive( self, 72, pushDir, qfalse, qfalse );
+
+		if ( !PM_SpinningSaberAnim( self->client->ps.legsAnim ) 
+			&& !PM_FlippingAnim( self->client->ps.legsAnim ) 
+			&& !PM_RollingAnim( self->client->ps.legsAnim ) 
+			&& !PM_InKnockDown( &self->client->ps ) )
+		{
+			int knockAnim = BOTH_KNOCKDOWN1;//default knockdown
+			if ( !self->s.number && ( strength < 300 ) )//!g_spskill->integer || 
+			{//player only knocked down if pushed *hard*
+				return;
+			}
+			else if ( PM_CrouchAnim( self->client->ps.legsAnim ) )
+			{//crouched knockdown
+				knockAnim = BOTH_KNOCKDOWN4;
+			}
+			else
+			{//plain old knockdown
+				vec3_t pLFwd, pLAngles = {0,self->client->ps.viewangles[YAW],0};
+				AngleVectors( pLAngles, pLFwd, NULL, NULL );
+				if ( DotProduct( pLFwd, pushDir ) > 0.2f )
+				{//pushing him from behind
+					knockAnim = BOTH_KNOCKDOWN3;
+				}
+				else
+				{//pushing him from front
+					knockAnim = BOTH_KNOCKDOWN1;
+				}
+			}
+			if ( knockAnim == BOTH_KNOCKDOWN1 && strength > 150 )
+			{//push *hard*
+				knockAnim = BOTH_KNOCKDOWN2;
+			}
+			NPC_SetAnim( self, SETANIM_BOTH, knockAnim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+			if ( self->s.number >= MAX_CLIENTS )
+			{//randomize getup times
+				int addTime = Q_irand( -200, 200 );
+				self->client->ps.legsAnimTimer += addTime;
+				self->client->ps.torsoAnimTimer += addTime;
+			}
+			else
+			{//player holds extra long so you have more time to decide to do the quick getup
+				if ( PM_KnockDownAnim( self->client->ps.legsAnim ) )
+				{
+					self->client->ps.legsAnimTimer += PLAYER_KNOCKDOWN_HOLD_EXTRA_TIME;
+					self->client->ps.torsoAnimTimer += PLAYER_KNOCKDOWN_HOLD_EXTRA_TIME;
+				}
+			}
+		}
+	}
+}
+
+void G_CheckKnockdown( gentity_t *targ, gentity_t *attacker, vec3_t newDir, int dflags, int mod )
+{
+	if ( !targ || !attacker )
+	{
+		return;
+	}
+	if ( !(dflags&DAMAGE_RADIUS) )
+	{//not inherently explosive damage, check mod
+		if ( mod!=MOD_REPEATER_ALT
+			&&mod!=MOD_FLECHETTE_ALT
+			&&mod!=MOD_ROCKET
+			&&mod!=MOD_ROCKET_ALT
+			&&mod!=MOD_CONC
+			&&mod!=MOD_CONC_ALT
+			&&mod!=MOD_THERMAL
+			&&mod!=MOD_THERMAL_ALT
+			&&mod!=MOD_DETPACK
+			&&mod!=MOD_LASERTRIP
+			&&mod!=MOD_LASERTRIP_ALT
+			&&mod!=MOD_EXPLOSIVE
+			&&mod!=MOD_EXPLOSIVE_SPLASH )
+		{
+			return;
+		}
+	}
+
+	if ( !targ->client || targ->client->NPC_class == CLASS_PROTOCOL || !G_StandardHumanoid( targ ) )
+	{
+		return;
+	}
+
+	if ( targ->client->ps.groundEntityNum == ENTITYNUM_NONE )
+	{//already in air
+		return;
+	}
+
+	if ( !targ->s.number )
+	{//player less likely to be knocked down
+		if ( !g_spskill->integer )
+		{//never in easy
+			return;
+		}
+		if ( !cg.renderingThirdPerson || cg.zoomMode )
+		{//never if not in chase camera view (so more likely with saber out)
+			return;
+		}
+		if ( g_spskill->integer == 1 )
+		{//33% chance on medium
+			if ( Q_irand( 0, 2 ) )
+			{
+				return;
+			}
+		}
+		else
+		{//50% chance on hard
+			if ( Q_irand( 0, 1 ) )
+			{
+				return;
+			}
+		}
+	}
+
+	float strength = VectorLength( targ->client->ps.velocity );
+	if ( targ->client->ps.velocity[2] > 100 && strength > Q_irand( 150, 350 ) )//600 ) )
+	{//explosive concussion possibly do a knockdown?
+		G_Knockdown( targ, attacker, newDir, strength, qtrue );
+	}
+}
+
+void G_ApplyKnockback( gentity_t *targ, vec3_t newDir, float knockback )
+{
+	vec3_t	kvel;
+	float	mass;
+
+	if ( targ 
+		&& targ->client 
+		&& ( targ->client->NPC_class == CLASS_ATST
+			|| targ->client->NPC_class == CLASS_RANCOR
+			|| targ->client->NPC_class == CLASS_SAND_CREATURE ) )
+	{//much to large to *ever* throw
+		return;
+	}
+
+	//--- TEMP TEST
+	if ( newDir[2] <= 0.0f )
+	{
+
+		newDir[2] += (( 0.0f - newDir[2] ) * 1.2f );
+	}
+
+	knockback *= 2.0f;
+
+	if ( knockback > 120 )
+	{
+		knockback = 120;
+	}
+	//--- TEMP TEST
+
+	if ( targ->physicsBounce > 0 )	//overide the mass
+		mass = targ->physicsBounce;
+	else
+		mass = 200;
+
+	if ( g_gravity->value > 0 )
+	{
+		VectorScale( newDir, g_knockback->value * (float)knockback / mass * 0.8, kvel );
+		kvel[2] = newDir[2] * ( g_knockback->value * (float)knockback ) / ( mass * 1.5 ) + 20;
+	}
+	else
+	{
+		VectorScale( newDir, g_knockback->value * (float)knockback / mass, kvel );
+	}
+
+	if ( targ->client )
+	{
+		VectorAdd( targ->client->ps.velocity, kvel, targ->client->ps.velocity );
+	}
+	else if ( targ->s.pos.trType != TR_STATIONARY && targ->s.pos.trType != TR_LINEAR_STOP && targ->s.pos.trType != TR_NONLINEAR_STOP )
+	{
+		VectorAdd( targ->s.pos.trDelta, kvel, targ->s.pos.trDelta );
+		VectorCopy( targ->currentOrigin, targ->s.pos.trBase );
+		targ->s.pos.trTime = level.time;
+	}
+
+	// set the timer so that the other client can't cancel
+	// out the movement immediately
+	if ( targ->client && !targ->client->ps.pm_time ) 
+	{
+		int		t;
+
+		t = knockback * 2;
+		if ( t < 50 ) {
+			t = 50;
+		}
+		if ( t > 200 ) {
+			t = 200;
+		}
+		targ->client->ps.pm_time = t;
+		targ->client->ps.pm_flags |= PMF_TIME_KNOCKBACK;
+	}
+}
+
+static int G_CheckForLedge( gentity_t *self, vec3_t fallCheckDir, float checkDist )
+{
+	vec3_t	start, end;
+	trace_t	tr;
+
+	VectorMA( self->currentOrigin, checkDist, fallCheckDir, end );
+	//Should have clip burshes masked out by now and have bbox resized to death size
+	gi.trace( &tr, self->currentOrigin, self->mins, self->maxs, end, self->s.number, self->clipmask );
+	if ( tr.allsolid || tr.startsolid )
+	{
+		return 0;
+	}
+	VectorCopy( tr.endpos, start );
+	VectorCopy( start, end );
+	end[2] -= 256;
+
+	gi.trace( &tr, start, self->mins, self->maxs, end, self->s.number, self->clipmask );
+	if ( tr.allsolid || tr.startsolid )
+	{
+		return 0;
+	}
+	if ( tr.fraction >= 1.0 )
+	{
+		return (start[2]-tr.endpos[2]);
+	}
+	return 0;
+}
+
+static void G_FriendlyFireReaction( gentity_t *self, gentity_t *other, int dflags )
+{
+	if ( (!player->client->ps.viewEntity || other->s.number != player->client->ps.viewEntity)) 
+	{//hit by a teammate
+		if ( other != self->enemy && self != other->enemy )
+		{//we weren't already enemies
+			if ( self->enemy || other->enemy || (other->s.number&&other->s.number!=player->client->ps.viewEntity) )
+			{//if one of us actually has an enemy already, it's okay, just an accident OR wasn't hit by player or someone controlled by player OR player hit ally and didn't get 25% chance of getting mad (FIXME:accumulate anger+base on diff?)
+				return;
+			}
+			else if ( self->NPC && !other->s.number )//should be assumed, but...
+			{//dammit, stop that!
+				if ( !(dflags&DAMAGE_RADIUS) )
+				{
+					//if it's radius damage, ignore it
+					if ( self->NPC->ffireDebounce < level.time )
+					{
+						//FIXME: way something?  NEED DIALOGUE
+						self->NPC->ffireCount++;
+						//Com_Printf( "incr: %d < %d\n", self->NPC->ffireCount, 3+((2-g_spskill->integer)*2) );
+						self->NPC->ffireDebounce = level.time + 500;
+					}
+				}
+			}
+		}
+	}
+}
+
+float damageModifier[HL_MAX] = 
+{
+	1.0f,	//HL_NONE,
+	0.25f,	//HL_FOOT_RT,
+	0.25f,	//HL_FOOT_LT,
+	0.75f,	//HL_LEG_RT,
+	0.75f,	//HL_LEG_LT,
+	1.0f,	//HL_WAIST,
+	1.0f,	//HL_BACK_RT,
+	1.0f,	//HL_BACK_LT,
+	1.0f,	//HL_BACK,
+	1.0f,	//HL_CHEST_RT,
+	1.0f,	//HL_CHEST_LT,
+	1.0f,	//HL_CHEST,
+	0.5f,	//HL_ARM_RT,
+	0.5f,	//HL_ARM_LT,
+	0.25f,	//HL_HAND_RT,
+	0.25f,	//HL_HAND_LT,
+	2.0f,	//HL_HEAD,
+	1.0f,	//HL_GENERIC1,
+	1.0f,	//HL_GENERIC2,
+	1.0f,	//HL_GENERIC3,
+	1.0f,	//HL_GENERIC4,
+	1.0f,	//HL_GENERIC5,
+	1.0f,	//HL_GENERIC6,
+};
+
+void G_TrackWeaponUsage( gentity_t *self, gentity_t *inflictor, int add, int mod )
+{
+	if ( !self || !self->client || self->s.number )
+	{//player only
+		return;
+	}
+	int weapon = WP_NONE;
+	//FIXME: need to check the MOD to find out what weapon (if *any*) actually did the killing
+	if ( inflictor && !inflictor->client && mod != MOD_SABER && inflictor->lastEnemy && inflictor->lastEnemy != self )
+	{//a missile that was reflected, ie: not owned by me originally
+		if ( inflictor->owner == self && self->s.weapon == WP_SABER )
+		{//we reflected it
+			weapon = WP_SABER;
+		}
+	}
+	if ( weapon == WP_NONE )
+	{
+		switch ( mod )
+		{
+		case MOD_SABER:
+			weapon = WP_SABER;
+			break;
+		case MOD_BRYAR:
+		case MOD_BRYAR_ALT:
+			weapon = WP_BRYAR_PISTOL;
+			break;
+		case MOD_BLASTER:
+		case MOD_BLASTER_ALT:
+			weapon = WP_BLASTER;
+			break;
+		case MOD_DISRUPTOR:
+		case MOD_SNIPER:
+			weapon = WP_DISRUPTOR;
+			break;
+		case MOD_BOWCASTER:
+		case MOD_BOWCASTER_ALT:
+			weapon = WP_BOWCASTER;
+			break;
+		case MOD_REPEATER:
+		case MOD_REPEATER_ALT:
+			weapon = WP_REPEATER;
+			break;
+		case MOD_DEMP2:
+		case MOD_DEMP2_ALT:
+			weapon = WP_DEMP2;
+			break;
+		case MOD_FLECHETTE:
+		case MOD_FLECHETTE_ALT:
+			weapon = WP_FLECHETTE;
+			break;
+		case MOD_ROCKET:
+		case MOD_ROCKET_ALT:
+			weapon = WP_ROCKET_LAUNCHER;
+			break;
+		case MOD_CONC:
+		case MOD_CONC_ALT:
+			weapon = WP_CONCUSSION;
+			break;
+		case MOD_THERMAL:
+		case MOD_THERMAL_ALT:
+			weapon = WP_THERMAL;
+			break;
+		case MOD_DETPACK:
+			weapon = WP_DET_PACK;
+			break;
+		case MOD_LASERTRIP:
+		case MOD_LASERTRIP_ALT:
+			weapon = WP_TRIP_MINE;
+			break;
+		case MOD_MELEE:
+			if ( self->s.weapon == WP_STUN_BATON )
+			{
+				weapon = WP_STUN_BATON;
+			}
+			else if ( self->s.weapon == WP_MELEE )
+			{
+				weapon = WP_MELEE;
+			}
+			break;
+		}
+	}
+	if ( weapon != WP_NONE )
+	{
+		self->client->sess.missionStats.weaponUsed[weapon] += add;
+	}
+}
+
+qboolean G_NonLocationSpecificDamage( int meansOfDeath )
+{
+	if ( meansOfDeath == MOD_EXPLOSIVE 
+		|| meansOfDeath == MOD_REPEATER_ALT
+		|| meansOfDeath == MOD_FLECHETTE_ALT
+		|| meansOfDeath == MOD_ROCKET
+		|| meansOfDeath == MOD_ROCKET_ALT
+		|| meansOfDeath == MOD_CONC
+		|| meansOfDeath == MOD_THERMAL
+		|| meansOfDeath == MOD_THERMAL_ALT
+		|| meansOfDeath == MOD_DETPACK
+		|| meansOfDeath == MOD_LASERTRIP
+		|| meansOfDeath == MOD_LASERTRIP_ALT
+		|| meansOfDeath == MOD_MELEE
+		|| meansOfDeath == MOD_FORCE_GRIP
+		|| meansOfDeath == MOD_KNOCKOUT
+		|| meansOfDeath == MOD_CRUSH
+		|| meansOfDeath == MOD_EXPLOSIVE_SPLASH )
+	{
+		return qtrue;
+	}
+	return qfalse;
+}
+
+qboolean G_ImmuneToGas( gentity_t *ent )
+{
+	if ( !ent || !ent->client )
+	{//only effects living clients
+		return qtrue;
+	}
+	if ( ent->s.weapon == WP_NOGHRI_STICK//assumes user is immune
+		|| ent->client->NPC_class == CLASS_HAZARD_TROOPER
+		|| ent->client->NPC_class == CLASS_ATST
+		|| ent->client->NPC_class == CLASS_GONK
+		|| ent->client->NPC_class == CLASS_SAND_CREATURE
+		|| ent->client->NPC_class == CLASS_INTERROGATOR
+		|| ent->client->NPC_class == CLASS_MARK1
+		|| ent->client->NPC_class == CLASS_MARK2
+		|| ent->client->NPC_class == CLASS_GALAKMECH
+		|| ent->client->NPC_class == CLASS_MOUSE
+		|| ent->client->NPC_class == CLASS_PROBE			// droid
+		|| ent->client->NPC_class == CLASS_PROTOCOL			// droid
+		|| ent->client->NPC_class == CLASS_R2D2				// droid
+		|| ent->client->NPC_class == CLASS_R5D2				// droid
+		|| ent->client->NPC_class == CLASS_REMOTE
+		|| ent->client->NPC_class == CLASS_SEEKER			// droid
+		|| ent->client->NPC_class == CLASS_SENTRY
+		|| ent->client->NPC_class == CLASS_SWAMPTROOPER
+		|| ent->client->NPC_class == CLASS_TUSKEN
+		|| ent->client->NPC_class == CLASS_BOBAFETT
+		|| ent->client->NPC_class == CLASS_ROCKETTROOPER
+		|| ent->client->NPC_class == CLASS_SABER_DROID
+		|| ent->client->NPC_class == CLASS_ASSASSIN_DROID
+		|| ent->client->NPC_class == CLASS_HAZARD_TROOPER
+		|| ent->client->NPC_class == CLASS_VEHICLE )
+	{
+		return qtrue;
+	}
+	return qfalse;
+}
+
+extern Vehicle_t *G_IsRidingVehicle( gentity_t *ent );
+extern void G_StartRoll( gentity_t *ent, int anim );
+extern void WP_ForcePowerStart( gentity_t *self, forcePowers_t forcePower, int overrideAmt );
+
+/*
+============
+T_Damage
+
+targ		entity that is being damaged
+inflictor	entity that is causing the damage
+attacker	entity that caused the inflictor to damage targ
+	example: targ=monster, inflictor=rocket, attacker=player
+
+dir			direction of the attack for knockback
+point		point at which the damage is being inflicted, used for headshots
+damage		amount of damage being inflicted
+knockback	force to be applied against targ as a result of the damage
+
+inflictor, attacker, dir, and point can be NULL for environmental effects
+
+dflags		these flags are used to control how T_Damage works
+	DAMAGE_RADIUS			damage was indirect (from a nearby explosion)
+	DAMAGE_NO_ARMOR			armor does not protect from this damage
+	DAMAGE_NO_KNOCKBACK		do not affect velocity, just view angles
+	DAMAGE_NO_PROTECTION	kills godmode, armor, everything
+	DAMAGE_NO_HIT_LOC		Damage not based on hit location
+============
+*/
+void G_Damage( gentity_t *targ, gentity_t *inflictor, gentity_t *attacker, const vec3_t dir, const vec3_t point, int damage, int dflags, int mod, int hitLoc ) 
+{
+	gclient_t	*client;
+	int			take;
+	int			save;
+	int			asave = 0;
+	int			knockback;
+	vec3_t		newDir;
+	qboolean	alreadyDead = qfalse;
+
+	if (!targ->takedamage) {
+		if ( targ->client //client
+			&& targ->client->NPC_class == CLASS_SAND_CREATURE//sand creature
+			&& targ->activator//something in our mouth
+			&& targ->activator == inflictor )//inflictor of damage is the thing in our mouth
+		{//being damaged by the thing in our mouth, allow the damage
+		}
+		else
+		{
+			return;
+		}
+	}
+
+	if ( targ->health <= 0 && !targ->client )
+	{	// allow corpses to be disintegrated
+		if( mod != MOD_SNIPER || (targ->flags & FL_DISINTEGRATED) )
+		return;
+	}
+
+	// if we are the player and we are locked to an emplaced gun, we have to reroute damage to the gun....sigh.
+	if ( targ->s.eFlags & EF_LOCKED_TO_WEAPON 
+		&& targ->s.number == 0 
+		&& targ->owner 
+		&& !targ->owner->bounceCount //not an EWeb
+		&& !( targ->owner->flags & FL_GODMODE ))
+	{
+		// swapping the gun into our place to absorb our damage
+		targ = targ->owner;
+	}
+
+	if ( (targ->flags&FL_SHIELDED) && mod != MOD_SABER  && !targ->client)
+	{//magnetically protected, this thing can only be damaged by lightsabers
+		return;
+	}
+
+	if ( (targ->flags&FL_DMG_BY_SABER_ONLY) && mod != MOD_SABER )
+	{//can only be damaged by lightsabers (but no shield... yeah, it's redundant, but whattayagonnado?)
+		return;
+	}
+
+	if (( targ->flags & FL_DMG_BY_HEAVY_WEAP_ONLY ) && !( dflags & DAMAGE_HEAVY_WEAP_CLASS ))
+	{
+		// can only be damaged by an heavy type weapon...but impacting missile was in the heavy weap class...so we just aren't taking damage from this missile
+		return;
+	}
+
+	if ( (targ->svFlags&SVF_BBRUSH)
+		|| (!targ->client && Q_stricmp( "misc_model_breakable", targ->classname ) == 0 ) )//FIXME: flag misc_model_breakables?
+	{//breakable brush or misc_model_breakable
+		if ( targ->NPC_targetname )
+		{//only a certain attacker can destroy this
+			if ( !attacker 
+				|| !attacker->targetname
+				|| Q_stricmp( targ->NPC_targetname, attacker->targetname ) != 0 )
+			{//and it's not this one, do nothing
+				return;
+			}
+		}
+	}
+
+	if ( targ->client && targ->client->NPC_class == CLASS_ATST )
+	{
+		// extra checks can be done here
+		if ( mod == MOD_SNIPER 
+			|| mod == MOD_DISRUPTOR
+			|| mod == MOD_CONC_ALT )
+		{
+			// disruptor does not hurt an atst
+			return;
+		}
+	}
+	if ( targ->client 
+		&& targ->client->NPC_class == CLASS_RANCOR 
+		&& (!attacker||!attacker->client||attacker->client->NPC_class!=CLASS_RANCOR) )
+	{
+		// I guess always do 10 points of damage...feel free to tweak as needed
+		if ( damage < 10 )
+		{//ignore piddly little damage
+			damage = 0;
+		}
+		else if ( damage >= 10 )
+		{
+			damage = 10;
+		}
+	}
+	else if ( mod == MOD_SABER )
+	{//sabers do less damage to mark1's and atst's, and to hazard troopers and assassin droids
+		if ( targ->client )
+		{
+			if ( targ->client->NPC_class == CLASS_ATST 
+				|| targ->client->NPC_class == CLASS_MARK1 )
+			{
+				// I guess always do 5 points of damage...feel free to tweak as needed
+				if ( damage > 5 )
+				{
+					damage = 5;
+				}
+			}
+			/*
+			//NOTE: a more controlled way to do the class-specific saber immunities, if we want
+			else if ( targ->client->NPC_class == CLASS_ASSASSIN_DROID )
+			{//takes 2 hits to kill on easy, 3 on medium, 4 on hard
+				int maxDamage = ceil((float)targ->max_health/(2.0f+g_spskill->value));
+				if ( damage > maxDamage )
+				{
+					damage = maxDamage;
+				}
+			}
+			else if ( targ->client->NPC_class == CLASS_HAZARD_TROOPER )
+			{//takes 3 hits to kill on easy, 4 on medium, 5 on hard
+				int maxDamage = ceil((float)targ->max_health/(3.0f+g_spskill->value));
+				if ( damage > maxDamage )
+				{
+					damage = maxDamage;
+				}
+			}
+			*/
+		}
+	}
+
+	if ( !inflictor ) {
+		inflictor = &g_entities[ENTITYNUM_WORLD];
+	}
+	if ( !attacker ) {
+		attacker = &g_entities[ENTITYNUM_WORLD];
+	}
+
+	// no more weakling allies!
+//	if ( attacker->s.number != 0 && damage >= 2 && targ->s.number != 0 && attacker->client && attacker->client->playerTeam == TEAM_PLAYER )
+//	{//player-helpers do only half damage to enemies
+//		damage = ceil((float)damage/2.0f);
+//	}
+
+	client = targ->client;
+
+	if ( client ) {
+		if ( client->noclip && !targ->s.number ) {
+			return;
+		}
+	}
+
+	if ( mod == MOD_GAS )
+	{//certain NPCs are immune
+		if ( G_ImmuneToGas( targ ) )
+		{//immune
+			return;
+		}
+		dflags |= DAMAGE_NO_ARMOR;
+	}
+	if ( dflags&DAMAGE_NO_DAMAGE )
+	{
+		damage = 0;
+	}
+
+	if ( dir == NULL ) 
+	{
+		dflags |= DAMAGE_NO_KNOCKBACK;
+	} 
+	else 
+	{
+		VectorNormalize2( dir, newDir );
+	}
+
+	if ( targ->s.number != 0 )
+	{//not the player
+		if ( (targ->flags&FL_GODMODE) || (targ->flags&FL_UNDYING) )
+		{//have god or undying on, so ignore no protection flag
+			dflags &= ~DAMAGE_NO_PROTECTION;
+		}
+	}
+
+	if ( client && PM_InOnGroundAnim( &client->ps ))
+	{
+		dflags |= DAMAGE_NO_KNOCKBACK;
+	}
+	if ( !attacker->s.number && targ->client && attacker->client && targ->client->playerTeam == attacker->client->playerTeam )
+	{//player doesn't do knockback against allies unless he kills them
+		dflags |= DAMAGE_DEATH_KNOCKBACK;
+	}
+
+	if (targ->client &&  (mod == MOD_DEMP2 || mod == MOD_DEMP2_ALT) )
+	{
+		TIMER_Set(targ, "DEMP2_StunTime", Q_irand(1000, 2000));
+	}
+
+	if ((client) && 
+		(mod==MOD_DEMP2 || mod==MOD_DEMP2_ALT) &&
+		(
+			client->NPC_class == CLASS_SABER_DROID ||
+			client->NPC_class == CLASS_ASSASSIN_DROID ||
+			client->NPC_class == CLASS_GONK ||
+			client->NPC_class == CLASS_MOUSE ||
+			client->NPC_class == CLASS_PROBE ||
+			client->NPC_class == CLASS_PROTOCOL ||
+			client->NPC_class == CLASS_R2D2 ||
+			client->NPC_class == CLASS_R5D2 ||
+			client->NPC_class == CLASS_SEEKER ||
+			client->NPC_class == CLASS_INTERROGATOR
+		)
+	   )
+	{
+		damage *= 7;
+	}
+
+	if ( client && client->NPC_class == CLASS_HAZARD_TROOPER )
+	{
+		if ( mod == MOD_SABER 
+			&& damage>0
+			&& !(dflags&DAMAGE_NO_PROTECTION) )
+		{
+			damage /= 10;
+		}
+	}
+
+	if ( client 
+		&& client->NPC_class == CLASS_GALAKMECH 
+		&& !(dflags&DAMAGE_NO_PROTECTION) )
+	{//hit Galak
+		if ( client->ps.stats[STAT_ARMOR] > 0 )
+		{//shields are up
+			dflags &= ~DAMAGE_NO_ARMOR;//always affect armor
+			if ( mod == MOD_ELECTROCUTE 
+				|| mod == MOD_DEMP2
+				|| mod == MOD_DEMP2_ALT )
+			{//shield protects us from this
+				damage = 0;
+			}
+		}
+		else
+		{//shields down
+			if ( mod == MOD_MELEE 
+				|| (mod == MOD_CRUSH && attacker && attacker->client) )
+			{//Galak takes no impact damage
+				return;
+			}
+			if ( (dflags & DAMAGE_RADIUS) 
+				|| mod == MOD_REPEATER_ALT
+				|| mod == MOD_FLECHETTE_ALT
+				|| mod == MOD_ROCKET
+				|| mod == MOD_ROCKET_ALT
+				|| mod == MOD_CONC
+				|| mod == MOD_THERMAL
+				|| mod == MOD_THERMAL_ALT
+				|| mod == MOD_DETPACK
+				|| mod == MOD_LASERTRIP
+				|| mod == MOD_LASERTRIP_ALT
+				|| mod == MOD_EXPLOSIVE_SPLASH
+				|| mod == MOD_ENERGY_SPLASH
+				|| mod == MOD_SABER )
+			{//galak without shields takes quarter damage from explosives and lightsaber
+				damage = ceil((float)damage/4.0f);
+			}
+		}
+	}
+
+	if ( mod == MOD_DEMP2 || mod == MOD_DEMP2_ALT )
+	{
+		if ( client )
+		{
+			if ( client->NPC_class == CLASS_PROTOCOL || client->NPC_class == CLASS_SEEKER ||
+				client->NPC_class == CLASS_R2D2 || client->NPC_class == CLASS_R5D2 ||
+				client->NPC_class == CLASS_MOUSE || client->NPC_class == CLASS_GONK )
+			{
+				// DEMP2 does more damage to these guys.
+				damage *= 2;
+			}
+			else if ( client->NPC_class == CLASS_PROBE || client->NPC_class == CLASS_INTERROGATOR ||
+						client->NPC_class == CLASS_MARK1 || client->NPC_class == CLASS_MARK2 || client->NPC_class == CLASS_SENTRY ||
+						client->NPC_class == CLASS_ATST )
+			{
+				// DEMP2 does way more damage to these guys.
+				damage *= 5;
+			}
+		}
+		else if ( targ->s.weapon == WP_TURRET )
+		{
+			damage *= 6;// more damage to turret things
+		}
+	}
+	
+	if (targ 
+		&& targ->client 
+		&& !(dflags&DAMAGE_NO_PROTECTION)
+		&& !(dflags&DAMAGE_DIE_ON_IMPACT) )//falling to you death ignores force protect and force rage (but obeys godmode and undying flags)
+	{//force protections
+		//rage
+		if ( (targ->client->ps.forcePowersActive & (1 << FP_RAGE)))
+		{
+			damage = floor((float)damage/(float)(targ->client->ps.forcePowerLevel[FP_RAGE]*2));
+		}
+		//protect
+		if ( (targ->client->ps.forcePowersActive & (1 << FP_PROTECT)) )
+		{
+			/*
+			qboolean doSound = qfalse;
+			switch ( targ->client->ps.forcePowerLevel[FP_PROTECT] )
+			{
+			case FORCE_LEVEL_3:
+				//NOTE: purposely falls through
+				switch ( mod )
+				{
+				case MOD_REPEATER_ALT:
+				case MOD_FLECHETTE_ALT:
+				case MOD_ROCKET:
+				case MOD_ROCKET_ALT:
+				case MOD_CONC:
+				case MOD_THERMAL:
+				case MOD_THERMAL_ALT:
+				case MOD_DETPACK:
+				case MOD_LASERTRIP:
+				case MOD_LASERTRIP_ALT:
+				case MOD_EMPLACED:
+				case MOD_EXPLOSIVE:
+				case MOD_EXPLOSIVE_SPLASH:
+				case MOD_CRUSH:
+					doSound = (Q_irand(0,4)==0);
+					damage = floor((float)damage/(float)(targ->client->ps.forcePowerLevel[FP_PROTECT]-1));
+					break;
+				}
+			case FORCE_LEVEL_2:
+				//NOTE: purposely falls through
+				switch ( mod )
+				{
+				case MOD_SABER:
+				case MOD_DISRUPTOR:
+				case MOD_SNIPER:
+				case MOD_CONC_ALT:
+				case MOD_BOWCASTER:
+				case MOD_BOWCASTER_ALT:
+				case MOD_DEMP2:
+				case MOD_DEMP2_ALT:
+				case MOD_ENERGY:
+				case MOD_ENERGY_SPLASH:
+				case MOD_ELECTROCUTE:
+					doSound = (Q_irand(0,4)==0);
+					damage = floor((float)damage/(float)(targ->client->ps.forcePowerLevel[FP_PROTECT]));
+					break;
+				}
+			case FORCE_LEVEL_1:
+				switch ( mod )
+				{
+				case MOD_BRYAR:
+				case MOD_BRYAR_ALT:
+				case MOD_BLASTER:
+				case MOD_BLASTER_ALT:
+				case MOD_REPEATER:
+				case MOD_FLECHETTE:
+				case MOD_WATER:
+				case MOD_SLIME:
+				case MOD_LAVA:
+				case MOD_FALLING:
+					doSound = (Q_irand(0,4)==0);
+					damage = floor((float)damage/(float)(targ->client->ps.forcePowerLevel[FP_PROTECT]+1));
+					break;
+				}
+				break;
+			}
+			*/
+			//New way: just cut all physical damage by force level
+			if ( mod == MOD_FALLING 
+				&& targ->NPC
+				&& (targ->NPC->aiFlags&NPCAI_DIE_ON_IMPACT) )
+			{//if falling to your death, protect can't save you
+			}
+			else
+			{
+				qboolean doSound = qfalse;
+				switch ( mod )
+				{
+				case MOD_CRUSH:
+					if ( attacker && attacker->client )
+					{//need to still be crushed by AT-ST
+						break;
+					}
+				case MOD_REPEATER_ALT:
+				case MOD_FLECHETTE_ALT:
+				case MOD_ROCKET:
+				case MOD_ROCKET_ALT:
+				case MOD_CONC:
+				case MOD_THERMAL:
+				case MOD_THERMAL_ALT:
+				case MOD_DETPACK:
+				case MOD_LASERTRIP:
+				case MOD_LASERTRIP_ALT:
+				case MOD_EMPLACED:
+				case MOD_EXPLOSIVE:
+				case MOD_EXPLOSIVE_SPLASH:
+				case MOD_SABER:
+				case MOD_DISRUPTOR:
+				case MOD_SNIPER:
+				case MOD_CONC_ALT:
+				case MOD_BOWCASTER:
+				case MOD_BOWCASTER_ALT:
+				case MOD_DEMP2:
+				case MOD_DEMP2_ALT:
+				case MOD_ENERGY:
+				case MOD_ENERGY_SPLASH:
+				case MOD_ELECTROCUTE:
+				case MOD_BRYAR:
+				case MOD_BRYAR_ALT:
+				case MOD_BLASTER:
+				case MOD_BLASTER_ALT:
+				case MOD_REPEATER:
+				case MOD_FLECHETTE:
+				case MOD_WATER:
+				case MOD_SLIME:
+				case MOD_LAVA:
+				case MOD_FALLING:
+				case MOD_MELEE:
+					doSound = (Q_irand(0,4)==0);
+					switch ( targ->client->ps.forcePowerLevel[FP_PROTECT] )
+					{
+					case FORCE_LEVEL_4:
+						//je suis invincible!!!
+						if ( targ->client 
+							&& attacker->client 
+							&& targ->client->playerTeam == attacker->client->playerTeam 
+							&& (!targ->NPC || !targ->NPC->charmedTime) )
+						{//complain, but don't turn on them
+							G_FriendlyFireReaction( targ, attacker, dflags );
+						}
+						return;
+						break;
+					case FORCE_LEVEL_3:
+						//one-tenth damage
+						if ( damage <= 1 )
+						{
+							damage = 0;
+						}
+						else
+						{
+							damage = ceil((float)damage*0.25f);//was 0.1f);
+						}
+						break;
+					case FORCE_LEVEL_2:
+						//half damage
+						if ( damage <= 1 )
+						{
+							damage = 0;
+						}
+						else
+						{
+							damage = ceil((float)damage*0.5f);
+						}
+						break;
+					case FORCE_LEVEL_1:
+						//three-quarters damage
+						if ( damage <= 1 )
+						{
+							damage = 0;
+						}
+						else
+						{
+							damage = ceil((float)damage*0.75f);
+						}
+						break;
+					}
+					break;
+				}
+				if ( doSound )
+				{
+					//make protect sound
+					G_SoundOnEnt( targ, CHAN_ITEM, "sound/weapons/force/protecthit.wav" );
+				}
+			}
+		}
+		//absorb
+		/*
+		if ( (targ->client->ps.forcePowersActive & (1 << FP_ABSORB)) )
+		{
+			if ( mod == MOD_FORCE_LIGHTNING
+				|| mod == MOD_FORCE_GRIP
+				|| mod == MOD_FORCE_DRAIN )
+			{
+				int absorbed = targ->client->ps.forcePowerLevel[FP_ABSORB]*5;
+				damage -= absorbed;
+				if ( damage < 0 )
+				{
+					absorbed += damage;
+					damage = 0;
+				}
+				//absorb the energy
+				//make absorb sound
+				G_SoundOnEnt( targ, CHAN_ITEM, "sound/weapons/force/absorbhit.wav" );
+				targ->client->ps.forcePower += absorbed;
+			}
+		}
+		*/
+	}
+
+	knockback = damage;
+
+	//Attempt to apply extra knockback
+	if ( dflags & DAMAGE_EXTRA_KNOCKBACK )
+	{
+		knockback *= 2;
+	}
+	
+	if ( knockback > 200 ) {
+		knockback = 200;
+	}
+
+	if ( targ->client
+		&& (targ->client->ps.forcePowersActive&(1<<FP_PROTECT))
+		&& targ->client->ps.forcePowerLevel[FP_PROTECT] == FORCE_LEVEL_3 )
+	{//pretend there was no damage?
+		knockback = 0;
+	}
+	else if ( mod == MOD_CRUSH )
+	{
+		knockback = 0;
+	}
+	else if ( targ->flags & FL_NO_KNOCKBACK ) 
+	{
+		knockback = 0;
+	}
+	else if ( targ->NPC
+		&& 	targ->NPC->jumpState == JS_JUMPING )
+	{
+		knockback = 0;
+	}
+	else if ( attacker->s.number >= MAX_CLIENTS//an NPC fired
+		&& targ->client //hit a client
+		&& attacker->client //attacker is a client
+		&& targ->client->playerTeam == attacker->client->playerTeam )//on same team
+	{//crap, ignore knockback
+		knockback = 0;
+	}
+	else if ( dflags & DAMAGE_NO_KNOCKBACK )
+	{
+		knockback = 0;
+	}
+	// figure momentum add, even if the damage won't be taken
+	if ( knockback && !(dflags&DAMAGE_DEATH_KNOCKBACK) ) //&& targ->client 
+	{
+		G_ApplyKnockback( targ, newDir, knockback );
+		G_CheckKnockdown( targ, attacker, newDir, dflags, mod );
+	}
+
+	// check for godmode, completely getting out of the damage
+	if ( ( (targ->flags&FL_GODMODE) || (targ->client&&targ->client->ps.powerups[PW_INVINCIBLE]>level.time) )
+		&& !(dflags&DAMAGE_NO_PROTECTION) ) 
+	{
+		if ( targ->client 
+			&& attacker->client 
+			&& targ->client->playerTeam == attacker->client->playerTeam 
+			&& (!targ->NPC || !targ->NPC->charmedTime) )
+		{//complain, but don't turn on them
+			G_FriendlyFireReaction( targ, attacker, dflags );
+		}
+		return;
+	}
+
+	// Check for team damage
+	/*
+	if ( targ != attacker && !(dflags&DAMAGE_IGNORE_TEAM) && OnSameTeam (targ, attacker)  ) 
+	{//on same team
+		if ( !targ->client ) 
+		{//a non-player object should never take damage from an ent on the same team
+			return;
+		}
+
+		if ( attacker->client && attacker->client->playerTeam == targ->noDamageTeam ) 
+		{//NPC or player shot an object on his own team
+			return;
+		}
+
+		if ( attacker->s.number != 0 && targ->s.number != 0 &&//player not involved in any way in this exchange
+			attacker->client && targ->client &&//two NPCs
+			attacker->client->playerTeam == targ->client->playerTeam ) //on the same team
+		{//NPCs on same team don't hurt each other
+			return;
+		}
+
+		if ( targ->s.number == 0 &&//player was hit
+			attacker->client && targ->client &&//by an NPC
+			attacker->client->playerTeam == TEAM_PLAYER ) //on the same team
+		{
+			if ( attacker->enemy != targ )//by accident
+			{//do no damage, no armor loss, no reaction, run no scripts
+				return;
+			}
+		}
+	}
+	*/
+
+	// add to the attacker's hit counter
+	if ( attacker->client && targ != attacker && targ->health > 0 ) {
+		if ( OnSameTeam( targ, attacker ) ) {
+//			attacker->client->ps.persistant[PERS_HITS] -= damage;
+		} else {
+//			attacker->client->ps.persistant[PERS_HITS] += damage;
+		}
+	}
+
+	take = damage;
+	save = 0;
+
+	//FIXME: Do not use this method of difficulty changing
+	// Scale the amount of damage given to the player based on the skill setting
+	/*
+	if ( targ->s.number == 0 && targ != attacker )
+	{
+		take *= ( g_spskill->integer + 1) * 0.75;
+	}
+
+	if ( take < 1 ) {
+		take = 1;
+	}
+	*/
+	if ( client )
+	{
+		//don't lose armor if on same team
+		// save some from armor
+		asave = CheckArmor (targ, take, dflags, mod);
+		if ( !asave )
+		{//nothing was absorbed (or just ran out?)
+		}
+		else if ( targ->client->NPC_class != CLASS_VEHICLE )
+		{//vehicles don't have personal shields
+			targ->client->ps.powerups[PW_BATTLESUIT] = level.time + ARMOR_EFFECT_TIME;
+			if ( targ->client->ps.stats[STAT_ARMOR] <= 0 )
+			{//all out of armor
+				//remove Galak's shield
+				targ->client->ps.powerups[PW_BATTLESUIT] = 0;
+			}
+		}
+		
+		if (mod==MOD_SLIME || mod==MOD_LAVA)
+		{
+			// Hazard Troopers Don't Mind Acid Rain
+			if (targ->client->NPC_class == CLASS_HAZARD_TROOPER
+				&& !(dflags&DAMAGE_NO_PROTECTION) )
+			{
+				take = 0;
+			}
+
+			if (mod==MOD_SLIME)
+			{
+  				trace_t		testTrace;
+				vec3_t		testDirection;
+				vec3_t		testStartPos;
+				vec3_t		testEndPos;
+				//int			numPuffs = Q_irand(1, 2);
+
+				//for (int i=0; i<numPuffs; i++)
+				{
+ 					testDirection[0] = (random() * 0.5f) - 0.25f;
+					testDirection[1] = (random() * 0.5f) - 0.25f;
+					testDirection[2] = 1.0f;
+					VectorMA(targ->currentOrigin, 60.0f, testDirection, testStartPos);
+					VectorCopy(targ->currentOrigin, testEndPos);
+					testEndPos[0] += (random() * 8.0f) - 4.0f;
+					testEndPos[1] += (random() * 8.0f) - 4.0f;
+					testEndPos[2] += (random() * 8.0f);
+
+					gi.trace (&testTrace, testStartPos, NULL, NULL, testEndPos, ENTITYNUM_NONE, MASK_SHOT, G2_COLLIDE);
+
+					if (!testTrace.startsolid && 
+						!testTrace.allsolid && 
+						testTrace.entityNum==targ->s.number && 
+						testTrace.G2CollisionMap[0].mEntityNum!=-1)
+					{
+						G_PlayEffect( "world/acid_fizz", testTrace.G2CollisionMap[0].mCollisionPosition );
+					}
+//					CG_DrawEdge(testStartPos,	testEndPos,	EDGE_IMPACT_POSSIBLE);
+					float chanceOfFizz = gi.WE_GetChanceOfSaberFizz();
+					TIMER_Set(targ, "AcidPainDebounce", 200 + (10000.0f * random() * chanceOfFizz));
+					hitLoc = HL_CHEST;
+				}
+			}
+		}
+
+		take -= asave;
+
+		if ( targ->client->NPC_class == CLASS_VEHICLE )
+		{
+			if ( ( targ->m_pVehicle->m_pVehicleInfo->type == VH_ANIMAL ) )
+			{
+				//((CVehicleNPC *)targ->NPC)->m_ulFlags |= CVehicleNPC::VEH_BUCKING;
+			}
+
+			if ( (damage > 0) &&											// Actually took some damage
+				 (mod!=MOD_SABER) &&										// and damage didn't come from a saber
+				 (targ->m_pVehicle->m_pVehicleInfo->type==VH_SPEEDER) &&	// and is a speeder
+			//	 (targ->client->ps.speed > 30.0f) &&						// and is moving
+				 (attacker) &&												// and there is an attacker
+				 (attacker->client) &&										// who is a client
+				 (attacker->s.number<MAX_CLIENTS) &&						// who is the player
+				 (G_IsRidingVehicle(attacker))								// who is riding a bike
+				 )
+			{
+				vec3_t	vehFwd;
+				vec3_t	actorFwd;
+				AngleVectors(targ->currentAngles, actorFwd, 0, 0);
+
+
+				Vehicle_t*	pVeh = G_IsRidingVehicle(attacker);
+				VectorCopy(pVeh->m_pParentEntity->client->ps.velocity, vehFwd);
+				VectorNormalize(vehFwd);
+
+				if (DotProduct(vehFwd, actorFwd)>0.5)
+				{
+					damage *= 10.0f;
+				}
+			}
+
+			if ( (damage > 0) &&												// Actually took some damage
+				 (mod==MOD_SABER) &&										// If Attacked By A Saber
+				 (targ->m_pVehicle->m_pVehicleInfo->type==VH_SPEEDER) &&	// and is a speeder
+				!(targ->m_pVehicle->m_ulFlags & VEH_OUTOFCONTROL) &&			// and is not already spinning
+				 (targ->client->ps.speed > 30.0f) &&						// and is moving
+				 (attacker==inflictor || Q_irand(0, 30)==0)					// and EITHER saber is held, or 1 in 30 chance of hitting when thrown
+				)
+			{
+				Vehicle_t*	pVeh = targ->m_pVehicle;
+				gentity_t*	parent = pVeh->m_pParentEntity;
+				float		CurSpeed = VectorLength(parent->client->ps.velocity);
+				pVeh->m_iArmor	= 0;	// Remove all remaining Armor
+				pVeh->m_pVehicleInfo->StartDeathDelay(pVeh, 10000);
+				pVeh->m_ulFlags |= (VEH_OUTOFCONTROL|VEH_SPINNING);
+				VectorScale(parent->client->ps.velocity, 1.25f, parent->pos3);
+				if (CurSpeed<pVeh->m_pVehicleInfo->speedMax)
+				{
+					VectorNormalize(parent->pos3);
+					if (CurSpeed<pVeh->m_pVehicleInfo->speedMax)
+					{
+						VectorNormalize(parent->pos3);
+						if (fabsf(parent->pos3[2])<0.25f)
+						{
+							VectorScale(parent->pos3, (pVeh->m_pVehicleInfo->speedMax * 1.25f), parent->pos3);
+						}
+						else 
+						{
+							VectorScale(parent->client->ps.velocity, 1.25f, parent->pos3);
+						}
+					}
+				}
+
+
+				// TODO: Play Huge Spark Effect & Start Rolling Sound
+	 			if (attacker==inflictor && (!G_IsRidingVehicle(attacker) || Q_irand(0, 3)==0))
+				{
+		 			attacker->lastEnemy = targ;
+					G_StartMatrixEffect(attacker, MEF_LOOK_AT_ENEMY|MEF_NO_RANGEVAR|MEF_NO_VERTBOB|MEF_NO_SPIN, 1000);
+					if (!G_IsRidingVehicle(attacker))
+					{
+						G_StartRoll(attacker, (Q_irand(0,1)==0)?(BOTH_ROLL_L):(BOTH_ROLL_R));
+					}
+				}
+
+				if (targ->m_pVehicle->m_pPilot && targ->m_pVehicle->m_pPilot->s.number>=MAX_CLIENTS)
+				{
+					G_SoundOnEnt(targ->m_pVehicle->m_pPilot, CHAN_VOICE, "*falling1.wav" );
+				}
+
+
+
+				// DISMEMBER THE FRONT PART OF THE MODEL
+				{
+					trace_t	trace;
+
+					gentity_t *limb = G_Spawn();
+
+
+					// Setup Basic Limb Entity Properties
+					//------------------------------------
+					limb->s.radius		= 60;
+					limb->s.eType		= ET_THINKER;
+					limb->s.eFlags	   |= EF_BOUNCE_HALF;
+					limb->classname		= "limb";
+					limb->owner			= targ;
+					limb->enemy			= targ->enemy;
+					limb->svFlags		= SVF_USE_CURRENT_ORIGIN;
+					limb->playerModel	= 0;
+					limb->clipmask		= MASK_SOLID;
+					limb->contents		= CONTENTS_CORPSE;
+					limb->e_clThinkFunc = clThinkF_CG_Limb;
+					limb->e_ThinkFunc	= thinkF_LimbThink;
+					limb->nextthink		= level.time + FRAMETIME;
+					limb->physicsBounce = 0.2f;
+					limb->craniumBone	= targ->craniumBone;
+					limb->cervicalBone	= targ->cervicalBone;
+					limb->thoracicBone	= targ->thoracicBone;
+					limb->upperLumbarBone = targ->upperLumbarBone;
+					limb->lowerLumbarBone = targ->lowerLumbarBone;
+					limb->hipsBone		= targ->hipsBone;
+					limb->rootBone		= targ->rootBone;
+
+
+					// Calculate The Location Of The New Limb
+					//----------------------------------------
+					G_SetOrigin( limb, targ->currentOrigin );
+
+					VectorCopy( targ->currentOrigin, limb->s.pos.trBase );
+					VectorSet( limb->mins, -3.0f, -3.0f, -6.0f );
+					VectorSet( limb->maxs, 3.0f, 3.0f, 6.0f );
+					VectorCopy( targ->s.modelScale, limb->s.modelScale );
+
+
+
+
+					//copy the g2 instance of the victim into the limb
+					//-------------------------------------------------
+ 					gi.G2API_CopyGhoul2Instance(targ->ghoul2, limb->ghoul2);
+					gi.G2API_SetRootSurface(limb->ghoul2, limb->playerModel, "lfront");
+					gi.G2API_SetSurfaceOnOff(&targ->ghoul2[targ->playerModel], "lfront", TURN_OFF);
+					animation_t *animations = level.knownAnimFileSets[targ->client->clientInfo.animFileIndex].animations;
+
+					//play the proper dismember anim on the limb
+					gi.G2API_SetBoneAnim(&limb->ghoul2[limb->playerModel], 0, animations[BOTH_A1_BL_TR].firstFrame, 
+							animations[BOTH_A1_BL_TR].numFrames + animations[BOTH_A1_BL_TR].firstFrame,
+							BONE_ANIM_OVERRIDE_FREEZE, 1, level.time );
+
+
+					// Check For Start In Solid
+					//--------------------------
+					gi.linkentity( limb );
+					gi.trace( &trace, limb->s.pos.trBase, limb->mins, limb->maxs, limb->s.pos.trBase, limb->s.number, limb->clipmask );
+					if ( trace.startsolid )
+					{
+						limb->s.pos.trBase[2] -= limb->mins[2];
+						gi.trace( &trace, limb->s.pos.trBase, limb->mins, limb->maxs, limb->s.pos.trBase, limb->s.number, limb->clipmask );
+						if ( trace.startsolid )
+						{
+							limb->s.pos.trBase[2] += limb->mins[2];
+							gi.trace( &trace, limb->s.pos.trBase, limb->mins, limb->maxs, limb->s.pos.trBase, limb->s.number, limb->clipmask );
+
+						}
+					}
+
+					// If Started In Solid, Remove
+					//-----------------------------
+					if ( trace.startsolid )
+					{
+						G_FreeEntity( limb );
+					}
+
+					// Otherwise, Send It Flying
+					//---------------------------
+					else
+					{
+						VectorCopy( limb->s.pos.trBase, limb->currentOrigin );
+						VectorScale( targ->client->ps.velocity, 1.0f, limb->s.pos.trDelta );
+						limb->s.pos.trType		= TR_GRAVITY;
+						limb->s.pos.trTime		= level.time;
+
+						VectorCopy( targ->currentAngles, limb->s.apos.trBase );
+						VectorClear( limb->s.apos.trDelta );
+						limb->s.apos.trTime		= level.time;
+						limb->s.apos.trType		= TR_LINEAR;
+						limb->s.apos.trDelta[0] = Q_irand( -300, 300 );
+						limb->s.apos.trDelta[1] = Q_irand( -800, 800 );
+
+						gi.linkentity( limb );
+					}
+				}
+			}
+
+			targ->m_pVehicle->m_iShields = targ->client->ps.stats[STAT_ARMOR];
+			targ->m_pVehicle->m_iArmor -= take;
+			if ( targ->m_pVehicle->m_iArmor < 0 ) 
+			{
+				targ->m_pVehicle->m_iArmor = 0;
+			}
+			if ( ( targ->m_pVehicle->m_iArmor <= 0 ) 
+				&& targ->m_pVehicle->m_pVehicleInfo->type != VH_ANIMAL )
+			{//vehicle all out of armor
+				Vehicle_t *pVeh = targ->m_pVehicle;
+				if (dflags&DAMAGE_IMPACT_DIE)
+				{
+					// kill it now
+					pVeh->m_pVehicleInfo->StartDeathDelay( pVeh, -1/* -1 causes instant death */ );
+				}
+				else
+				{
+					if ( pVeh->m_iDieTime == 0 )
+					{//just start the flaming effect and explosion delay, if it's not going already...
+						pVeh->m_pVehicleInfo->StartDeathDelay( pVeh, Q_irand( 4000, 5500 ) );
+					}
+				}
+			}
+			else if (targ->m_pVehicle->m_pVehicleInfo->type != VH_ANIMAL)
+			{
+				take = 0;
+			}
+		}
+	}
+	if ( !(dflags&DAMAGE_NO_HIT_LOC) || !(dflags&DAMAGE_RADIUS))
+	{
+		if ( !G_NonLocationSpecificDamage( mod ) )
+		{//certain kinds of damage don't care about hitlocation
+			take = ceil( (float)take*damageModifier[hitLoc] );
+		}
+	}
+
+	if ( g_debugDamage->integer ) {
+		gi.Printf( "[%d]client:%i health:%i damage:%i armor:%i hitloc:%s\n", level.time, targ->s.number, targ->health, take, asave, hitLocName[hitLoc] );
+	}
+
+	// add to the damage inflicted on a player this frame
+	// the total will be turned into screen blends and view angle kicks
+	// at the end of the frame
+	if ( client ) {
+		client->ps.persistant[PERS_ATTACKER] = attacker->s.number;	//attack can be the world ent
+		client->damage_armor += asave;
+		client->damage_blood += take;
+		if ( dir ) {	//can't check newdir since it's local, newdir is dir normalized
+			VectorCopy ( newDir, client->damage_from );
+			client->damage_fromWorld = false;
+		} else {
+			VectorCopy ( targ->currentOrigin, client->damage_from );
+			client->damage_fromWorld = true;
+		}
+	}
+
+	// do the damage
+	if ( targ->health <= 0 )
+	{
+		alreadyDead = qtrue;
+	}
+
+	// Undying If:
+	//--------------------------------------------------------------------------
+	qboolean	targUndying = (!alreadyDead 
+							&& !(dflags&DAMAGE_NO_PROTECTION) 
+							&& (
+								(targ->flags&FL_UNDYING) 
+								|| (dflags&DAMAGE_NO_KILL) 
+								|| ((targ->client) && (targ->client->ps.forcePowersActive & (1<<FP_RAGE)) && !(dflags&DAMAGE_NO_PROTECTION) && !(dflags&DAMAGE_DIE_ON_IMPACT))
+							    )
+						   );
+
+	if ( targ->client 
+		&& targ->client->NPC_class == CLASS_WAMPA 
+		&& targ->count 
+		&& take >= targ->health )
+	{//wampa holding someone, don't die unless you can release them!
+		qboolean removeArm = qfalse;
+		if ( targ->activator 
+			&& attacker == targ->activator 
+			&& mod == MOD_SABER )
+		{
+			removeArm = qtrue;
+		}
+		if ( Wampa_CheckDropVictim( targ, qtrue ) )
+		{//released our victim
+			if ( removeArm )
+			{
+				targ->client->dismembered = false;
+				//FIXME: the limb should just disappear, cuz I ate it
+				G_DoDismemberment( targ, targ->currentOrigin, MOD_SABER, 1000, HL_ARM_RT, qtrue );
+			}
+		}
+		else
+		{//couldn't release him
+			targUndying = qtrue;
+		}
+	}
+
+	if ( attacker && attacker->client && !attacker->s.number )
+	{
+		if ( !alreadyDead )
+		{
+			int add;
+			if ( take > targ->health )
+			{
+				add = targ->health;
+			}
+			else
+			{
+				add = take;
+			}
+			add += asave;
+			add = ceil(add/10.0f);
+			if ( attacker != targ )
+			{
+				G_TrackWeaponUsage( attacker, inflictor, add, mod );
+			}
+		}
+	}
+
+	if ( take || (dflags&DAMAGE_NO_DAMAGE) ) 
+	{
+		if ( !targ->client || !attacker->client )
+		{
+			targ->health = targ->health - take;
+			if (targ->health < 0)
+			{
+				targ->health = 0;
+			}
+			if ( targUndying  )
+			{
+				if(targ->health < 1)
+				{
+					G_ActivateBehavior( targ, BSET_DEATH );
+					targ->health = 1;
+				}
+			}
+		}
+		else 
+		{//two clients
+			team_t		targTeam = TEAM_FREE;
+			team_t		attackerTeam = TEAM_FREE;
+
+			if ( player->client->ps.viewEntity && targ->s.number == player->client->ps.viewEntity )
+			{
+				targTeam = player->client->playerTeam;
+			}
+			else if ( targ->client ) {
+				targTeam = targ->client->playerTeam;
+			}
+			else {
+				targTeam = targ->noDamageTeam;
+			}
+		//	if ( targTeam == TEAM_DISGUISE ) {
+		//		targTeam = TEAM_PLAYER;
+		//	}
+			if ( player->client->ps.viewEntity && attacker->s.number == player->client->ps.viewEntity )
+			{
+				attackerTeam = player->client->playerTeam;
+			}
+			else if ( attacker->client ) {
+				attackerTeam = attacker->client->playerTeam;
+			}
+			else {
+				attackerTeam = attacker->noDamageTeam;
+			}
+		//	if ( attackerTeam == TEAM_DISGUISE ) {
+		//		attackerTeam = TEAM_PLAYER;
+		//	}
+
+			if ( targTeam != attackerTeam 
+				|| (targ->s.number < MAX_CLIENTS && targTeam == TEAM_FREE)//evil player hit
+				|| (attacker && attacker->s.number < MAX_CLIENTS && attackerTeam == TEAM_FREE) )//evil player attacked
+			{//on opposite team
+				targ->health = targ->health - take;
+
+				//MCG - Falling should never kill player- only if a trigger_hurt does so.
+				if ( mod == MOD_FALLING && targ->s.number == 0 && targ->health < 1 )
+				{
+					targ->health = 1;
+				}
+				else if (targ->health < 0)
+				{
+					targ->health = 0;
+				}
+
+				if (targUndying)
+				{
+					if ( targ->health < 1 )
+					{
+						if ( targ->NPC == NULL || !(targ->NPC->aiFlags&NPCAI_ROSH) || !Rosh_TwinPresent( targ ) )
+						{//NOTE: Rosh won't run his deathscript until he doesn't have the twins to heal him
+							G_ActivateBehavior( targ, BSET_DEATH );
+						}
+						targ->health = 1;
+					}
+				}
+				else if ( targ->health < 1 && attacker->client )
+				{	// The player or NPC just killed an enemy so increment the kills counter
+					attacker->client->ps.persistant[PERS_ENEMIES_KILLED]++;
+				}
+			}
+			else if ( targTeam == TEAM_PLAYER )
+			{//on the same team, and target is an ally
+				qboolean takeDamage = qtrue;
+				qboolean yellAtAttacker = qtrue;
+
+				//1) player doesn't take damage from teammates unless they're angry at him
+				if ( targ->s.number == 0 )
+				{//the player
+					if ( attacker->enemy != targ && attacker != targ )
+					{//an NPC shot the player by accident
+						takeDamage = qfalse;
+					}
+				}
+				//2) NPCs don't take any damage from player during combat
+				else 
+				{//an NPC
+					if ( ((dflags & DAMAGE_RADIUS)) && !(dflags&DAMAGE_IGNORE_TEAM) )
+					{//An NPC got hit by player and this is during combat or it was slash damage
+						//NOTE: though it's not realistic to have teammates not take splash damage,
+						//		even when not in combat, it feels really bad to have them able to
+						//		actually be killed by the player's splash damage
+						takeDamage = qfalse;
+					}
+
+					if ( (dflags & DAMAGE_RADIUS) )
+					{//you're fighting and it's just radius damage, so don't even mention it
+						yellAtAttacker = qfalse;
+					}
+				}
+
+				if ( takeDamage )
+				{
+					targ->health = targ->health - take;
+					if ( !alreadyDead && ((((targ->flags&FL_UNDYING)||targ->client->ps.forcePowersActive & (1 << FP_RAGE)) && !(dflags&DAMAGE_NO_PROTECTION) && attacker->s.number != 0) || (dflags&DAMAGE_NO_KILL) ) )
+					{//guy is marked undying and we're not the player or we're in combat
+						if ( targ->health < 1 )
+						{
+							G_ActivateBehavior( targ, BSET_DEATH );
+							
+							targ->health = 1;
+						}
+					}
+					else if ( !alreadyDead && ((((targ->flags&FL_UNDYING)||targ->client->ps.forcePowersActive & (1 << FP_RAGE)) && !(dflags&DAMAGE_NO_PROTECTION) && !attacker->s.number && !targ->s.number) || (dflags&DAMAGE_NO_KILL)) )
+					{// player is undying and he's attacking himself, don't let him die
+						if ( targ->health < 1 )
+						{
+							G_ActivateBehavior( targ, BSET_DEATH );
+							
+							targ->health = 1;
+						}
+					}
+					else if ( targ->health < 0 )
+					{
+						targ->health = 0;
+						if ( attacker->s.number == 0 && targ->NPC )
+						{
+							targ->NPC->scriptFlags |= SCF_FFDEATH;
+						}
+					}
+				}
+				
+				if ( yellAtAttacker )
+				{
+					if ( !targ->NPC || !targ->NPC->charmedTime )
+					{
+						G_FriendlyFireReaction( targ, attacker, dflags );
+					}
+				}
+			}
+			else
+			{
+
+			}
+		}
+
+		if ( targ->client ) {
+			targ->client->ps.stats[STAT_HEALTH] = targ->health;
+			g_lastClientDamaged = targ;
+		}
+			
+		//TEMP HACK FOR PLAYER LOOK AT ENEMY CODE
+		//FIXME: move this to a player pain func?
+		if ( targ->s.number == 0 )
+		{
+			if ( !targ->enemy //player does not have an enemy yet
+				|| targ->enemy->s.weapon != WP_SABER //or player's enemy is not a jedi
+				|| attacker->s.weapon == WP_SABER )//and attacker is a jedi
+				//keep enemy jedi over shooters
+			{
+				if ( attacker->enemy == targ || !OnSameTeam( targ, attacker ) )
+				{//don't set player's enemy to teammates that hit him by accident
+					targ->enemy = attacker;
+				}
+				NPC_SetLookTarget( targ, attacker->s.number, level.time+1000 );
+			}
+		}
+		else if ( attacker->s.number == 0 && (!targ->NPC || !targ->NPC->timeOfDeath) && (mod == MOD_SABER || attacker->s.weapon != WP_SABER || !attacker->enemy || attacker->enemy->s.weapon != WP_SABER) )//keep enemy jedi over shooters
+		{//this looks dumb when they're on the ground and you keep hitting them, so only do this when first kill them
+			if ( !OnSameTeam( targ, attacker ) )
+			{//don't set player's enemy to teammates that he hits by accident
+				attacker->enemy = targ;
+			}
+			NPC_SetLookTarget( attacker, targ->s.number, level.time+1000 );
+		}
+		//TEMP HACK FOR PLAYER LOOK AT ENEMY CODE
+
+		//add up the damage to the location
+		if ( targ->client )
+		{
+			if ( targ->locationDamage[hitLoc] < Q3_INFINITE )
+			{
+				targ->locationDamage[hitLoc] += take;
+			}
+		}
+
+
+		if ( targ->health > 0 && targ->NPC && targ->NPC->surrenderTime > level.time )
+		{//he was surrendering, goes down with one hit
+			if (!targ->client || targ->client->NPC_class!=CLASS_BOBAFETT)
+			{
+				targ->health = 0;
+			}
+		}
+
+		if ( targ->health <= 0 ) 
+		{
+			if ( knockback && (dflags&DAMAGE_DEATH_KNOCKBACK) )//&& targ->client 
+			{//only do knockback on death
+				if ( mod == MOD_FLECHETTE )
+				{//special case because this is shotgun-ish damage, we need to multiply the knockback
+					knockback *= 12;//*6 for 6 flechette shots
+				}
+				G_ApplyKnockback( targ, newDir, knockback );
+			}
+
+			/*
+			if ( client )
+				targ->flags |= FL_NO_KNOCKBACK;
+			*/
+
+			if (targ->health < -999)
+				targ->health = -999;
+
+			// If we are a breaking glass brush, store the damage point so we can do cool things with it.
+			if ( targ->svFlags & SVF_GLASS_BRUSH )
+			{
+				VectorCopy( point, targ->pos1 );
+				VectorCopy( dir, targ->pos2 );
+			}
+			if ( targ->client )
+			{//HACK
+				if ( point )
+				{
+					VectorCopy( point, targ->pos1 );
+				}
+				else
+				{
+					VectorCopy( targ->currentOrigin, targ->pos1 );
+				}
+			}
+			if ( !alreadyDead && !targ->enemy )
+			{//just killed and didn't have an enemy before
+				targ->enemy = attacker;
+			}
+
+			GEntity_DieFunc( targ, inflictor, attacker, take, mod, dflags, hitLoc );
+		}
+		else 
+		{
+			GEntity_PainFunc( targ, inflictor, attacker, point, take, mod, hitLoc );
+			if ( targ->s.number == 0 )
+			{//player run painscript
+				G_ActivateBehavior( targ, BSET_PAIN );
+				if ( targ->health <= 25 )
+				{
+					G_ActivateBehavior( targ, BSET_FLEE );
+				}
+			}
+		}
+	}
+}
+
+
+/*
+============
+CanDamage
+
+Returns qtrue if the inflictor can directly damage the target.  Used for
+explosions and melee attacks.
+============
+*/
+qboolean CanDamage (gentity_t *targ, const vec3_t origin) {
+	vec3_t	dest;
+	trace_t	tr;
+	vec3_t	midpoint;
+	qboolean cantHitEnt = qtrue;
+	
+	if ( (targ->contents&MASK_SOLID) )
+	{//can hit it
+		if ( targ->s.solid == SOLID_BMODEL )
+		{//but only if it's a brushmodel
+			cantHitEnt = qfalse;
+		}
+	}
+
+	// use the midpoint of the bounds instead of the origin, because
+	// bmodels may have their origin at 0,0,0
+	VectorAdd (targ->absmin, targ->absmax, midpoint);
+	VectorScale (midpoint, 0.5, midpoint);
+
+	VectorCopy (midpoint, dest);
+	/*
+	vec3_t blah;
+	VectorCopy( origin, blah);
+	G_DebugLine(blah, dest, 5000, 0x0000ff, qtrue );
+	*/
+	gi.trace ( &tr, origin, vec3_origin, vec3_origin, dest, ENTITYNUM_NONE, MASK_SOLID);
+	if (( tr.fraction == 1.0 && cantHitEnt) || tr.entityNum == targ->s.number ) // if we also test the entitynum's we can bust up bbrushes better!
+		return qtrue;
+
+	// this should probably check in the plane of projection, 
+	// rather than in world coordinate, and also include Z
+	VectorCopy (midpoint, dest);
+	dest[0] += 15.0;
+	dest[1] += 15.0;
+	gi.trace ( &tr, origin, vec3_origin, vec3_origin, dest, ENTITYNUM_NONE, MASK_SOLID);
+	if (( tr.fraction == 1.0 && cantHitEnt) || tr.entityNum == targ->s.number )
+		return qtrue;
+
+	VectorCopy (midpoint, dest);
+	dest[0] += 15.0;
+	dest[1] -= 15.0;
+	gi.trace ( &tr, origin, vec3_origin, vec3_origin, dest, ENTITYNUM_NONE, MASK_SOLID);
+	if (( tr.fraction == 1.0 && cantHitEnt) || tr.entityNum == targ->s.number )
+		return qtrue;
+
+	VectorCopy (midpoint, dest);
+	dest[0] -= 15.0;
+	dest[1] += 15.0;
+	gi.trace ( &tr, origin, vec3_origin, vec3_origin, dest, ENTITYNUM_NONE, MASK_SOLID);
+	if (( tr.fraction == 1.0 && cantHitEnt) || tr.entityNum == targ->s.number )
+		return qtrue;
+
+	VectorCopy (midpoint, dest);
+	dest[0] -= 15.0;
+	dest[1] -= 15.0;
+	gi.trace ( &tr, origin, vec3_origin, vec3_origin, dest, ENTITYNUM_NONE, MASK_SOLID);
+	if (( tr.fraction == 1.0 && cantHitEnt) || tr.entityNum == targ->s.number )
+		return qtrue;
+
+
+	return qfalse;
+}
+
+extern	void	Boba_DustFallNear(const vec3_t origin, int dustcount);
+extern	void	G_GetMassAndVelocityForEnt( gentity_t *ent, float *mass, vec3_t velocity );
+/*
+============
+G_RadiusDamage
+============
+*/
+void G_RadiusDamage ( const vec3_t origin, gentity_t *attacker, float damage, float radius,
+					 gentity_t *ignore, int mod) {
+	float		points, dist;
+	gentity_t	*ent;
+	gentity_t	*entityList[MAX_GENTITIES];
+	int			numListedEntities;
+	vec3_t		mins, maxs;
+	vec3_t		v;
+	vec3_t		dir;
+	int			i, e;
+	int			dFlags = DAMAGE_RADIUS;
+
+	if ( radius < 1 ) {
+		radius = 1;
+	}
+
+	for ( i = 0 ; i < 3 ; i++ ) {
+		mins[i] = origin[i] - radius;
+		maxs[i] = origin[i] + radius;
+	}
+
+	if (mod==MOD_ROCKET)
+	{
+		Boba_DustFallNear(origin, 10);
+	}
+
+	if ( mod == MOD_GAS )
+	{
+		dFlags |= DAMAGE_NO_KNOCKBACK;
+	}
+
+	numListedEntities = gi.EntitiesInBox( mins, maxs, entityList, MAX_GENTITIES );
+
+	for ( e = 0 ; e < numListedEntities ; e++ ) {
+		ent = entityList[ e ];
+
+		if ( ent == ignore )
+			continue;
+		if ( !ent->takedamage )
+			continue;
+		if ( !ent->contents )
+			continue;
+
+		// find the distance from the edge of the bounding box
+		for ( i = 0 ; i < 3 ; i++ ) {
+			if ( origin[i] < ent->absmin[i] ) {
+				v[i] = ent->absmin[i] - origin[i];
+			} else if ( origin[i] > ent->absmax[i] ) {
+				v[i] = origin[i] - ent->absmax[i];
+			} else {
+				v[i] = 0;
+			}
+		}
+
+		dist = VectorLength( v );
+		if ( dist >= radius ) {
+			continue;
+		}
+
+		points = damage * ( 1.0 - dist / radius );
+
+		// Lessen damage to vehicles that are moving away from the explosion
+		if (ent->client && (ent->client->NPC_class==CLASS_VEHICLE || G_IsRidingVehicle(ent)))
+		{
+			gentity_t*	bike = ent;
+
+			if (G_IsRidingVehicle(ent) && ent->owner)
+			{
+				bike = ent->owner;
+			}
+
+			vec3_t	vehMoveDirection;
+			float	vehMoveSpeed;
+
+			vec3_t	explosionDirection;
+			float	explosionDirectionSimilarity;
+
+			float	mass;
+			G_GetMassAndVelocityForEnt( bike, &mass, vehMoveDirection );
+			vehMoveSpeed		= VectorNormalize(vehMoveDirection);
+			if (vehMoveSpeed>300.0f)
+			{
+				VectorSubtract(bike->currentOrigin, origin, explosionDirection);
+				VectorNormalize(explosionDirection);
+
+				explosionDirectionSimilarity = DotProduct(vehMoveDirection, explosionDirection);
+				if (explosionDirectionSimilarity>0.0f)
+				{
+					points *= (1.0f - explosionDirectionSimilarity);
+				}
+			}
+		}
+
+		if (CanDamage (ent, origin)) 
+		{//FIXME: still do a little damage in in PVS and close?
+			if ( ent->svFlags & (SVF_GLASS_BRUSH|SVF_BBRUSH) )
+			{
+				VectorAdd( ent->absmin, ent->absmax, v );
+				VectorScale( v, 0.5f, v );
+			}
+			else
+			{
+				VectorCopy( ent->currentOrigin, v );
+			}
+
+			VectorSubtract( v, origin, dir);
+			// push the center of mass higher than the origin so players
+			// get knocked into the air more
+			dir[2] += 24;
+
+			if ( ent->svFlags & SVF_GLASS_BRUSH )
+			{
+				if ( points > 1.0f )
+				{
+					// we want to cap this at some point, otherwise it just gets crazy
+					if ( points > 6.0f )
+					{
+						VectorScale( dir, 6.0f, dir );
+					}
+					else
+					{
+						VectorScale( dir, points, dir );
+					}
+				}
+
+				ent->splashRadius = radius;// * ( 1.0 - dist / radius );
+			}
+
+			G_Damage (ent, NULL, attacker, dir, origin, (int)points, dFlags, mod);
+		}
+	}
+}
diff --git a/code/game/g_emplaced.cpp b/code/game/g_emplaced.cpp
new file mode 100644
index 0000000..eb6ec5c
--- /dev/null
+++ b/code/game/g_emplaced.cpp
@@ -0,0 +1,1133 @@
+// leave this line at the top for all g_xxxx.cpp files...
+#include "g_headers.h"
+
+
+
+#include "g_local.h"
+#include "g_functions.h"
+#include "anims.h"
+#include "wp_saber.h"
+
+extern Vehicle_t *G_IsRidingVehicle( gentity_t *pEnt );
+
+//lock the owner into place relative to the cannon pos
+void EWebPositionUser(gentity_t *owner, gentity_t *eweb)
+{ 
+	mdxaBone_t boltMatrix;
+	vec3_t p, p2, d;
+	trace_t tr;
+	qboolean traceOver = qtrue;
+
+	if ( owner->s.number < MAX_CLIENTS )
+	{//extra checks
+		gi.trace(&tr, owner->currentOrigin, owner->mins, owner->maxs, owner->currentOrigin, owner->s.number, owner->clipmask);
+		if ( tr.startsolid || tr.allsolid )
+		{//crap, they're already in solid somehow, don't bother tracing over
+			traceOver = qfalse;
+		}
+	}
+	if ( traceOver )
+	{//trace up
+		VectorCopy( owner->currentOrigin, p2 );
+		p2[2] += STEPSIZE;
+		gi.trace(&tr, owner->currentOrigin, owner->mins, owner->maxs, p2, owner->s.number, owner->clipmask);
+		if (!tr.startsolid && !tr.allsolid )
+		{
+			VectorCopy( tr.endpos, p2 );
+		}
+		else
+		{
+			VectorCopy( owner->currentOrigin, p2 );
+		}
+	}
+	//trace over
+	gi.G2API_GetBoltMatrix( eweb->ghoul2, 0, eweb->headBolt, &boltMatrix, 
+		eweb->s.apos.trBase, eweb->currentOrigin, 
+		(cg.time?cg.time:level.time), NULL, eweb->s.modelScale );
+	gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, p );
+	gi.G2API_GiveMeVectorFromMatrix( boltMatrix, NEGATIVE_Y, d );
+	d[2] = 0;
+	VectorNormalize( d );
+	VectorMA( p, -44.0f, d, p );
+	if ( !traceOver )
+	{
+		VectorCopy( p, tr.endpos );
+		tr.allsolid = tr.startsolid = qfalse;
+	}
+	else 
+	{
+		p[2] = p2[2];
+		if ( owner->s.number < MAX_CLIENTS )
+		{//extra checks
+			//just see if end point is not in solid
+			gi.trace(&tr, p, owner->mins, owner->maxs, p, owner->s.number, owner->clipmask);
+			if ( tr.startsolid || tr.allsolid )
+			{//would be in solid there, so just trace over, I guess?
+				gi.trace(&tr, p2, owner->mins, owner->maxs, p, owner->s.number, owner->clipmask);
+			}
+		}
+		else
+		{//trace over
+			gi.trace(&tr, p2, owner->mins, owner->maxs, p, owner->s.number, owner->clipmask);
+		}
+	}
+	if (!tr.startsolid && !tr.allsolid )
+	{
+		//trace down
+		VectorCopy( tr.endpos, p );
+		VectorCopy( p, p2 );
+		p2[2] -= STEPSIZE;
+		gi.trace(&tr, p, owner->mins, owner->maxs, p2, owner->s.number, owner->clipmask);
+
+		if (!tr.startsolid && !tr.allsolid )//&& tr.fraction == 1.0f)
+		{ //all clear, we can move there
+			vec3_t	moveDir;
+			float moveDist;
+			VectorCopy( tr.endpos, p );
+			VectorSubtract( p, eweb->pos4, moveDir );
+			moveDist = VectorNormalize( moveDir );
+			if ( moveDist > 4.0f )
+			{//moved past the threshold from last position
+				vec3_t	oRight;
+				int		strafeAnim;
+
+				VectorCopy( p, eweb->pos4 );//update the position
+				//find out what direction he moved in
+				AngleVectors( owner->currentAngles, NULL, oRight, NULL );
+				if ( DotProduct( moveDir, oRight ) > 0 )
+				{//moved to his right, play right strafe
+					strafeAnim = BOTH_STRAFE_RIGHT1;
+				}
+				else
+				{//moved left, play left strafe
+					strafeAnim = BOTH_STRAFE_LEFT1;
+				}
+				NPC_SetAnim( owner, SETANIM_LEGS, strafeAnim,SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD);
+			}
+			
+			G_SetOrigin(owner, p);
+			VectorCopy(p, owner->client->ps.origin);
+			gi.linkentity( owner );
+		}
+	}
+	//FIXME: IK the hands to the handles of the gun?
+}
+
+//===============================================
+//End E-Web
+//===============================================
+
+//----------------------------------------------------------
+
+//===============================================
+//Emplaced Gun
+//===============================================
+
+// spawnflag
+#define	EMPLACED_INACTIVE	1
+#define EMPLACED_FACING		2
+#define EMPLACED_VULNERABLE	4
+#define EWEB_INVULNERABLE	4
+#define EMPLACED_PLAYERUSE	8
+
+/*QUAKED emplaced_eweb (0 0 1) (-12 -12 -24) (12 12 24) INACTIVE FACING INVULNERABLE PLAYERUSE
+
+ INACTIVE cannot be used until used by a target_activate
+ FACING - player must be facing relatively in the same direction as the gun in order to use it
+ VULNERABLE - allow the gun to take damage
+ PLAYERUSE - only the player makes it run its usescript
+
+ count - how much ammo to give this gun ( default 999 )
+ health - how much damage the gun can take before it blows ( default 250 )
+ delay - ONLY AFFECTS NPCs - time between shots ( default 200 on hardest setting )
+ wait - ONLY AFFECTS NPCs - time between bursts ( default 800 on hardest setting )
+ splashdamage - how much damage a blowing up gun deals ( default 80 )
+ splashradius - radius for exploding damage ( default 128 )
+
+ scripts:
+	will run usescript, painscript and deathscript
+*/
+//----------------------------------------------------------
+void eweb_pain( gentity_t *self, gentity_t *inflictor, gentity_t *attacker, const vec3_t point, int damage, int mod,int hitLoc )
+{
+	if ( self->health <= 0 )
+	{
+		// play pain effect?
+	}
+	else
+	{
+		if ( self->paintarget )
+		{
+			G_UseTargets2( self, self->activator, self->paintarget );
+		}
+
+		// Don't do script if dead
+		G_ActivateBehavior( self, BSET_PAIN );
+	}
+}
+//----------------------------------------------------------
+void eweb_die( gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int mod,int dFlags,int hitLoc )
+{
+	vec3_t org;
+
+	// turn off any firing animations it may have been doing
+	self->s.frame = self->startFrame = self->endFrame = 0;
+	self->svFlags &= ~(SVF_ANIMATING|SVF_PLAYER_USABLE);
+	
+			
+	self->health = 0;
+//	self->s.weapon = WP_EMPLACED_GUN; // we need to be able to switch back to the old weapon
+
+	self->takedamage = qfalse;
+	self->lastEnemy = attacker;
+
+	if ( self->activator && self->activator->client )
+	{
+		if ( self->activator->NPC )
+		{
+			vec3_t right;
+
+			// radius damage seems to throw them, but add an extra bit to throw them away from the weapon
+			AngleVectors( self->currentAngles, NULL, right, NULL );
+			VectorMA( self->activator->client->ps.velocity, 140, right, self->activator->client->ps.velocity );
+			self->activator->client->ps.velocity[2] = -100;
+
+			// kill them
+			self->activator->health = 0;
+			self->activator->client->ps.stats[STAT_HEALTH] = 0;
+		}
+
+		// kill the players emplaced ammo, cheesy way to keep the gun from firing
+		self->activator->client->ps.ammo[weaponData[WP_EMPLACED_GUN].ammoIndex] = 0;
+	}
+
+	self->e_PainFunc = painF_NULL;
+
+	if ( self->target )
+	{
+		G_UseTargets( self, attacker );
+	}
+
+	G_RadiusDamage( self->currentOrigin, self, self->splashDamage, self->splashRadius, self, MOD_UNKNOWN );
+
+	VectorCopy( self->currentOrigin,  org );
+	org[2] += 20;
+
+	G_PlayEffect( "emplaced/explode", org );
+
+	// Turn the top of the eweb off.
+#define TURN_OFF			0x00000100//G2SURFACEFLAG_NODESCENDANTS
+	gi.G2API_SetSurfaceOnOff( &self->ghoul2[self->playerModel], "eweb_damage", TURN_OFF );
+
+	// create some persistent smoke by using a dynamically created fx runner
+	gentity_t *ent = G_Spawn();
+
+	if ( ent )
+	{
+		ent->delay = 200;
+		ent->random = 100;
+
+		ent->fxID = G_EffectIndex( "emplaced/dead_smoke" );
+
+		ent->e_ThinkFunc = thinkF_fx_runner_think; 
+		ent->nextthink = level.time + 50;
+
+		// move up above the gun origin
+		VectorCopy( self->currentOrigin, org );
+		org[2] += 35;
+		G_SetOrigin( ent, org );
+		VectorCopy( org, ent->s.origin );
+
+		VectorSet( ent->s.angles, -90, 0, 0 ); // up
+		G_SetAngles( ent, ent->s.angles );
+
+		gi.linkentity( ent );
+	}
+
+	G_ActivateBehavior( self, BSET_DEATH );
+}
+
+qboolean eweb_can_be_used( gentity_t *self, gentity_t *other, gentity_t *activator )
+{
+	if ( self->health <= 0 )
+	{
+		// can't use a dead gun.
+		return qfalse;
+	}
+
+	if ( self->svFlags & SVF_INACTIVE )
+	{
+		return qfalse; // can't use inactive gun
+	}
+
+	if ( !activator->client )
+	{
+		return qfalse; // only a client can use it.
+	}
+
+	if ( self->activator )
+	{
+		// someone is already in the gun.
+		return qfalse;
+	}
+
+	if ( other && other->client && G_IsRidingVehicle( other ) )
+	{//can't use eweb when on a vehicle
+		return qfalse;
+	}
+
+	if ( activator && activator->client && G_IsRidingVehicle( activator ) )
+	{//can't use eweb when on a vehicle
+		return qfalse;
+	}
+
+	if ( activator && activator->client && (activator->client->ps.pm_flags&PMF_DUCKED) )
+	{//stand up, ya cowardly varmint!
+		return qfalse;
+	}
+
+	if ( activator && activator->health <= 0 )
+	{//dead men ain't got no more use fer guns...
+		return qfalse;
+	}
+
+	vec3_t fwd1, fwd2;
+	vec3_t	facingAngles;
+
+	VectorAdd( self->s.angles, self->pos1, facingAngles );
+	if ( activator->s.number < MAX_CLIENTS )
+	{//player must be facing general direction of the turret head
+		// Let's get some direction vectors for the users
+		AngleVectors( activator->client->ps.viewangles, fwd1, NULL, NULL );
+		fwd1[2] = 0;
+
+		// Get the gun's direction vector
+		AngleVectors( facingAngles, fwd2, NULL, NULL );
+		fwd2[2] = 0;
+
+		float dot = DotProduct( fwd1, fwd2 );
+
+		// Must be reasonably facing the way the gun points ( 90 degrees or so ), otherwise we don't allow to use it.
+		if ( dot < 0.75f )
+		{
+			return qfalse;
+		}
+	}
+
+	if ( self->delay + 500 < level.time )
+	{
+		return qtrue;
+	}
+	return qfalse;
+}
+
+void eweb_use( gentity_t *self, gentity_t *other, gentity_t *activator )
+{
+	if ( !eweb_can_be_used( self, other, activator ) )
+	{
+		return;
+	}
+
+	int	oldWeapon = activator->s.weapon;
+
+	if ( oldWeapon == WP_SABER )
+	{
+		self->alt_fire = activator->client->ps.SaberActive();
+	}
+
+	// swap the users weapon with the emplaced gun and add the ammo the gun has to the player
+	activator->client->ps.weapon = self->s.weapon;
+	Add_Ammo( activator, WP_EMPLACED_GUN, self->count );
+	activator->client->ps.stats[STAT_WEAPONS] |= ( 1 << WP_EMPLACED_GUN );
+
+	// Allow us to point from one to the other
+	activator->owner = self; // kind of dumb, but when we are locked to the weapon, we are owned by it.
+	self->activator = activator;
+
+	G_RemoveWeaponModels( activator );
+
+extern void ChangeWeapon( gentity_t *ent, int newWeapon );
+	if ( activator->NPC )
+	{
+		ChangeWeapon( activator, WP_EMPLACED_GUN );
+	}
+	else if ( activator->s.number == 0 )
+	{
+		// we don't want for it to draw the weapon select stuff
+		cg.weaponSelect = WP_EMPLACED_GUN;
+		CG_CenterPrint( "@SP_INGAME_EXIT_VIEW", SCREEN_HEIGHT * 0.95 );
+	}
+
+	VectorCopy( activator->currentOrigin, self->pos4 );//keep this around so we know when to make them play the strafe anim
+
+	// the gun will track which weapon we used to have
+	self->s.weapon = oldWeapon;
+
+	// Lock the player
+	activator->client->ps.eFlags |= EF_LOCKED_TO_WEAPON;
+	activator->owner = self; // kind of dumb, but when we are locked to the weapon, we are owned by it.
+	self->activator = activator;
+	self->delay = level.time; // can't disconnect from the thing for half a second
+
+	// Let the gun be considered an enemy
+	//Ugh, so much AI code seems to assume enemies are clients, maybe this shouldn't be on, but it's too late in the game to change it now without knowing what side-effects this will have
+	self->svFlags |= SVF_NONNPC_ENEMY;
+	self->noDamageTeam = activator->client->playerTeam;
+
+	//FIXME: should really wait a bit after spawn and get this just once?
+	self->waypoint = NAV::GetNearestNode(self);
+#ifdef _DEBUG
+	if ( self->waypoint == -1 )
+	{
+		gi.Printf( S_COLOR_RED"ERROR: no waypoint for emplaced_gun %s at %s\n", self->targetname, vtos(self->currentOrigin) );
+	}
+#endif
+
+	G_Sound( self, G_SoundIndex( "sound/weapons/eweb/eweb_mount.mp3" ));
+#ifdef _IMMERSION
+	G_Force( self, G_ForceIndex( "fffx/weapons/emplaced/emplaced_mount", FF_CHANNEL_TOUCH ) );
+#endif // _IMMERSION
+
+	if ( !(self->spawnflags&EMPLACED_PLAYERUSE) || activator->s.number == 0 )
+	{//player-only usescript or any usescript
+		// Run use script
+		G_ActivateBehavior( self, BSET_USE );
+	}
+}
+
+//----------------------------------------------------------
+void SP_emplaced_eweb( gentity_t *ent )
+{
+	char name[] = "models/map_objects/hoth/eweb_model.glm";
+
+	ent->svFlags |= SVF_PLAYER_USABLE;
+	ent->contents = CONTENTS_BODY;
+
+	if ( ent->spawnflags & EMPLACED_INACTIVE )
+	{
+		ent->svFlags |= SVF_INACTIVE;
+	}
+
+	VectorSet( ent->mins, -12, -12, -24 );
+	VectorSet( ent->maxs, 12, 12, 24 );
+
+	ent->takedamage = qtrue;
+
+	if ( ( ent->spawnflags & EWEB_INVULNERABLE ))
+	{
+		ent->flags |= FL_GODMODE;
+	}
+
+	ent->s.radius = 80;
+	ent->spawnflags |= 4; // deadsolid
+
+	//ent->e_ThinkFunc = thinkF_NULL;
+	ent->e_PainFunc = painF_eweb_pain;
+	ent->e_DieFunc  = dieF_eweb_die;
+
+	G_EffectIndex( "emplaced/explode" );
+	G_EffectIndex( "emplaced/dead_smoke" );
+
+	G_SoundIndex( "sound/weapons/eweb/eweb_aim.wav" );
+	G_SoundIndex( "sound/weapons/eweb/eweb_dismount.mp3" );
+	//G_SoundIndex( "sound/weapons/eweb/eweb_empty.wav" );
+	G_SoundIndex( "sound/weapons/eweb/eweb_fire.wav" );
+	G_SoundIndex( "sound/weapons/eweb/eweb_hitplayer.wav" );
+	G_SoundIndex( "sound/weapons/eweb/eweb_hitsurface.wav" );
+	//G_SoundIndex( "sound/weapons/eweb/eweb_load.wav" );
+	G_SoundIndex( "sound/weapons/eweb/eweb_mount.mp3" );
+
+	// Set up our defaults and override with custom amounts as necessary
+	G_SpawnInt( "count", "999", &ent->count );
+	G_SpawnInt( "health", "250", &ent->health );
+	G_SpawnInt( "splashDamage", "40", &ent->splashDamage );
+	G_SpawnInt( "splashRadius", "100", &ent->splashRadius );
+	G_SpawnFloat( "delay", "200", &ent->random ); // NOTE: spawning into a different field!!
+	G_SpawnFloat( "wait", "800", &ent->wait );
+
+	ent->max_health = ent->health;
+	ent->dflags |= DAMAGE_CUSTOM_HUD; // dumb, but we draw a custom hud
+
+	ent->s.modelindex = G_ModelIndex( name );
+	ent->playerModel = gi.G2API_InitGhoul2Model( ent->ghoul2, name, ent->s.modelindex );
+
+	// Activate our tags and bones
+	ent->handLBolt = gi.G2API_AddBolt( &ent->ghoul2[ent->playerModel], "*cannonflash" ); //muzzle bolt
+	ent->headBolt = gi.G2API_AddBolt( &ent->ghoul2[ent->playerModel], "cannon_Xrot" ); //for placing the owner relative to rotation
+	ent->rootBone = gi.G2API_GetBoneIndex( &ent->ghoul2[ent->playerModel], "model_root", qtrue );
+	ent->lowerLumbarBone = gi.G2API_GetBoneIndex( &ent->ghoul2[ent->playerModel], "cannon_Yrot", qtrue );
+	ent->upperLumbarBone = gi.G2API_GetBoneIndex( &ent->ghoul2[ent->playerModel], "cannon_Xrot", qtrue );
+	gi.G2API_SetBoneAnglesIndex( &ent->ghoul2[ent->playerModel], ent->lowerLumbarBone, vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_Z, NEGATIVE_X, NEGATIVE_Y, NULL); 
+	gi.G2API_SetBoneAnglesIndex( &ent->ghoul2[ent->playerModel], ent->upperLumbarBone, vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_Z, NEGATIVE_X, NEGATIVE_Y, NULL); 
+	//gi.G2API_SetBoneAngles( &ent->ghoul2[0], "cannon_Yrot", vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_Y, POSITIVE_Z, POSITIVE_X, NULL); 
+	//set the constraints for this guy as an emplaced weapon, and his constraint angles
+	//ent->s.origin2[0] = 60.0f; //60 degrees in either direction
+
+	RegisterItem( FindItemForWeapon( WP_EMPLACED_GUN ));
+	ent->s.weapon = WP_EMPLACED_GUN;
+
+	G_SetOrigin( ent, ent->s.origin );
+	G_SetAngles( ent, ent->s.angles );
+	VectorCopy( ent->s.angles, ent->lastAngles );
+
+	// store base angles for later
+	VectorClear( ent->pos1 );
+
+	ent->e_UseFunc = useF_eweb_use;
+	ent->bounceCount = 1;//to distinguish it from the emplaced gun
+
+	gi.linkentity (ent);
+}
+
+/*QUAKED emplaced_gun (0 0 1) (-24 -24 0) (24 24 64) INACTIVE x VULNERABLE PLAYERUSE
+
+ INACTIVE cannot be used until used by a target_activate
+ VULNERABLE - allow the gun to take damage
+ PLAYERUSE - only the player makes it run its usescript
+
+ count - how much ammo to give this gun ( default 999 )
+ health - how much damage the gun can take before it blows ( default 250 )
+ delay - ONLY AFFECTS NPCs - time between shots ( default 200 on hardest setting )
+ wait - ONLY AFFECTS NPCs - time between bursts ( default 800 on hardest setting )
+ splashdamage - how much damage a blowing up gun deals ( default 80 )
+ splashradius - radius for exploding damage ( default 128 )
+
+ scripts:
+	will run usescript, painscript and deathscript
+*/
+ 
+//----------------------------------------------------------
+void emplaced_gun_use( gentity_t *self, gentity_t *other, gentity_t *activator )
+{
+	vec3_t fwd1, fwd2;
+
+	if ( self->health <= 0 )
+	{
+		// can't use a dead gun.
+		return;
+	}
+
+	if ( self->svFlags & SVF_INACTIVE )
+	{
+		return; // can't use inactive gun
+	}
+
+	if ( !activator->client )
+	{
+		return; // only a client can use it.
+	}
+
+	if ( self->activator )
+	{
+		// someone is already in the gun.
+		return;
+	}
+
+	if ( other && other->client && G_IsRidingVehicle( other ) )
+	{//can't use eweb when on a vehicle
+		return;
+	}
+
+	if ( activator && activator->client && G_IsRidingVehicle( activator ) )
+	{//can't use eweb when on a vehicle
+		return;
+	}
+
+	// We'll just let the designers duke this one out....I mean, as to whether they even want to limit such a thing.
+	if ( self->spawnflags & EMPLACED_FACING )
+	{
+		// Let's get some direction vectors for the users
+		AngleVectors( activator->client->ps.viewangles, fwd1, NULL, NULL );
+
+		// Get the guns direction vector
+		AngleVectors( self->pos1, fwd2, NULL, NULL );
+
+		float dot = DotProduct( fwd1, fwd2 );
+
+		// Must be reasonably facing the way the gun points ( 90 degrees or so ), otherwise we don't allow to use it.
+		if ( dot < 0.0f )
+		{
+			return;
+		}
+	}
+
+	// don't allow using it again for half a second
+	if ( self->delay + 500 < level.time )
+	{
+		int	oldWeapon = activator->s.weapon;
+
+		if ( oldWeapon == WP_SABER )
+		{
+			self->alt_fire = activator->client->ps.SaberActive();
+		}
+
+		// swap the users weapon with the emplaced gun and add the ammo the gun has to the player
+		activator->client->ps.weapon = self->s.weapon;
+		Add_Ammo( activator, WP_EMPLACED_GUN, self->count );
+		activator->client->ps.stats[STAT_WEAPONS] |= ( 1 << WP_EMPLACED_GUN );
+
+		// Allow us to point from one to the other
+		activator->owner = self; // kind of dumb, but when we are locked to the weapon, we are owned by it.
+		self->activator = activator;
+
+		G_RemoveWeaponModels( activator );
+
+extern void ChangeWeapon( gentity_t *ent, int newWeapon );
+		if ( activator->NPC )
+		{
+			ChangeWeapon( activator, WP_EMPLACED_GUN );
+		}
+		else if ( activator->s.number == 0 )
+		{
+			// we don't want for it to draw the weapon select stuff
+			cg.weaponSelect = WP_EMPLACED_GUN;
+			CG_CenterPrint( "@SP_INGAME_EXIT_VIEW", SCREEN_HEIGHT * 0.95 );
+		}
+		// Since we move the activator inside of the gun, we reserve a solid spot where they were standing in order to be able to get back out without being in solid
+		if ( self->nextTrain )
+		{//you never know
+			G_FreeEntity( self->nextTrain );
+		}
+		self->nextTrain = G_Spawn();
+		//self->nextTrain->classname = "emp_placeholder";
+		self->nextTrain->contents = CONTENTS_MONSTERCLIP|CONTENTS_PLAYERCLIP;//hmm... playerclip too now that we're doing it for NPCs?
+		G_SetOrigin( self->nextTrain, activator->client->ps.origin );
+		VectorCopy( activator->mins, self->nextTrain->mins );
+		VectorCopy( activator->maxs, self->nextTrain->maxs );
+		gi.linkentity( self->nextTrain );
+
+		//need to inflate the activator's mins/maxs since the gunsit anim puts them outside of their bbox
+		VectorSet( activator->mins, -24, -24, -24 );
+		VectorSet( activator->maxs, 24, 24, 40 );
+
+		// Move the activator into the center of the gun.  For NPC's the only way the can get out of the gun is to die.
+		VectorCopy( self->s.origin, activator->client->ps.origin );
+		activator->client->ps.origin[2] += 30; // move them up so they aren't standing in the floor
+		gi.linkentity( activator );
+
+		// the gun will track which weapon we used to have
+		self->s.weapon = oldWeapon;
+
+		// Lock the player
+		activator->client->ps.eFlags |= EF_LOCKED_TO_WEAPON;
+		activator->owner = self; // kind of dumb, but when we are locked to the weapon, we are owned by it.
+		self->activator = activator;
+		self->delay = level.time; // can't disconnect from the thing for half a second
+
+		// Let the gun be considered an enemy
+		//Ugh, so much AI code seems to assume enemies are clients, maybe this shouldn't be on, but it's too late in the game to change it now without knowing what side-effects this will have
+		self->svFlags |= SVF_NONNPC_ENEMY;
+		self->noDamageTeam = activator->client->playerTeam;
+
+		// FIXME: don't do this, we'll try and actually put the player in this beast
+		// move the player to the center of the gun
+//		activator->contents = 0;
+//		VectorCopy( self->currentOrigin, activator->client->ps.origin );
+
+		SetClientViewAngle( activator, self->pos1 );
+
+		//FIXME: should really wait a bit after spawn and get this just once?
+		self->waypoint = NAV::GetNearestNode(self);
+#ifdef _DEBUG
+		if ( self->waypoint == -1 )
+		{
+			gi.Printf( S_COLOR_RED"ERROR: no waypoint for emplaced_gun %s at %s\n", self->targetname, vtos(self->currentOrigin) );
+		}
+#endif
+
+		G_Sound( self, G_SoundIndex( "sound/weapons/emplaced/emplaced_mount.mp3" ));
+#ifdef _IMMERSION
+		G_Force( self, G_ForceIndex( "fffx/weapons/emplaced/emplaced_mount", FF_CHANNEL_TOUCH ) );
+#endif // _IMMERSION
+
+		if ( !(self->spawnflags&EMPLACED_PLAYERUSE) || activator->s.number == 0 )
+		{//player-only usescript or any usescript
+			// Run use script
+			G_ActivateBehavior( self, BSET_USE );
+		}
+	}
+}
+
+//----------------------------------------------------------
+void emplaced_gun_pain( gentity_t *self, gentity_t *inflictor, gentity_t *attacker, const vec3_t point, int damage, int mod,int hitLoc )
+{
+	if ( self->health <= 0 )
+	{
+		// play pain effect?
+	}
+	else
+	{
+		if ( self->paintarget )
+		{
+			G_UseTargets2( self, self->activator, self->paintarget );
+		}
+
+		// Don't do script if dead
+		G_ActivateBehavior( self, BSET_PAIN );
+	}
+}
+
+//----------------------------------------------------------
+void emplaced_blow( gentity_t *ent )
+{
+	ent->e_DieFunc = dieF_NULL;
+	emplaced_gun_die( ent, ent->lastEnemy, ent->lastEnemy, 0, MOD_UNKNOWN );
+}
+
+//----------------------------------------------------------
+void emplaced_gun_die( gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int mod,int dFlags,int hitLoc )
+{
+	vec3_t org;
+
+	// turn off any firing animations it may have been doing
+	self->s.frame = self->startFrame = self->endFrame = 0;
+	self->svFlags &= ~SVF_ANIMATING;
+			
+	self->health = 0;
+//	self->s.weapon = WP_EMPLACED_GUN; // we need to be able to switch back to the old weapon
+
+	self->takedamage = qfalse;
+	self->lastEnemy = attacker;
+
+	// we defer explosion so the player has time to get out
+	if ( self->e_DieFunc )
+	{
+		self->e_ThinkFunc = thinkF_emplaced_blow;
+		self->nextthink = level.time + 3000; // don't blow for a couple of seconds
+		return;
+	}
+
+	if ( self->activator && self->activator->client )
+	{
+		if ( self->activator->NPC )
+		{
+			vec3_t right;
+
+			// radius damage seems to throw them, but add an extra bit to throw them away from the weapon
+			AngleVectors( self->currentAngles, NULL, right, NULL );
+			VectorMA( self->activator->client->ps.velocity, 140, right, self->activator->client->ps.velocity );
+			self->activator->client->ps.velocity[2] = -100;
+
+			// kill them
+			self->activator->health = 0;
+			self->activator->client->ps.stats[STAT_HEALTH] = 0;
+		}
+
+		// kill the players emplaced ammo, cheesy way to keep the gun from firing
+		self->activator->client->ps.ammo[weaponData[WP_EMPLACED_GUN].ammoIndex] = 0;
+	}
+
+	self->e_PainFunc = painF_NULL;
+	self->e_ThinkFunc = thinkF_NULL;
+
+	if ( self->target )
+	{
+		G_UseTargets( self, attacker );
+	}
+
+	G_RadiusDamage( self->currentOrigin, self, self->splashDamage, self->splashRadius, self, MOD_UNKNOWN );
+
+	// when the gun is dead, add some ugliness to it.
+	vec3_t ugly;
+
+	ugly[YAW] = 4;
+	ugly[PITCH] = self->lastAngles[PITCH] * 0.8f + crandom() * 6;
+	ugly[ROLL] = crandom() * 7;
+	gi.G2API_SetBoneAnglesIndex( &self->ghoul2[self->playerModel], self->lowerLumbarBone, ugly, BONE_ANGLES_POSTMULT, POSITIVE_Y, POSITIVE_Z, POSITIVE_X, NULL ); 
+
+	VectorCopy( self->currentOrigin,  org );
+	org[2] += 20;
+
+	G_PlayEffect( "emplaced/explode", org );
+
+	// create some persistent smoke by using a dynamically created fx runner
+	gentity_t *ent = G_Spawn();
+
+	if ( ent )
+	{
+		ent->delay = 200;
+		ent->random = 100;
+
+		ent->fxID = G_EffectIndex( "emplaced/dead_smoke" );
+
+		ent->e_ThinkFunc = thinkF_fx_runner_think; 
+		ent->nextthink = level.time + 50;
+
+		// move up above the gun origin
+		VectorCopy( self->currentOrigin, org );
+		org[2] += 35;
+		G_SetOrigin( ent, org );
+		VectorCopy( org, ent->s.origin );
+
+		VectorSet( ent->s.angles, -90, 0, 0 ); // up
+		G_SetAngles( ent, ent->s.angles );
+
+		gi.linkentity( ent );
+	}
+
+	G_ActivateBehavior( self, BSET_DEATH );
+}
+
+//----------------------------------------------------------
+void SP_emplaced_gun( gentity_t *ent )
+{
+	char name[] = "models/map_objects/imp_mine/turret_chair.glm";
+
+	ent->svFlags |= SVF_PLAYER_USABLE;
+	ent->contents = CONTENTS_BODY;//CONTENTS_SHOTCLIP|CONTENTS_PLAYERCLIP|CONTENTS_MONSTERCLIP;//CONTENTS_SOLID;
+
+	if ( ent->spawnflags & EMPLACED_INACTIVE )
+	{
+		ent->svFlags |= SVF_INACTIVE;
+	}
+
+	VectorSet( ent->mins, -30, -30, -5 );
+	VectorSet( ent->maxs, 30, 30, 60 );
+
+	ent->takedamage = qtrue;
+
+	if ( !( ent->spawnflags & EMPLACED_VULNERABLE ))
+	{
+		ent->flags |= FL_GODMODE;
+	}
+
+	ent->s.radius = 110;
+	ent->spawnflags |= 4; // deadsolid
+
+	//ent->e_ThinkFunc = thinkF_NULL;
+	ent->e_PainFunc = painF_emplaced_gun_pain;
+	ent->e_DieFunc  = dieF_emplaced_gun_die;
+
+	G_EffectIndex( "emplaced/explode" );
+	G_EffectIndex( "emplaced/dead_smoke" );
+
+	G_SoundIndex( "sound/weapons/emplaced/emplaced_mount.mp3" );
+	G_SoundIndex( "sound/weapons/emplaced/emplaced_dismount.mp3" );
+	G_SoundIndex( "sound/weapons/emplaced/emplaced_move_lp.wav" );
+
+	// Set up our defaults and override with custom amounts as necessary
+	G_SpawnInt( "count", "999", &ent->count );
+	G_SpawnInt( "health", "250", &ent->health );
+	G_SpawnInt( "splashDamage", "80", &ent->splashDamage );
+	G_SpawnInt( "splashRadius", "128", &ent->splashRadius );
+	G_SpawnFloat( "delay", "200", &ent->random ); // NOTE: spawning into a different field!!
+	G_SpawnFloat( "wait", "800", &ent->wait );
+
+	ent->max_health = ent->health;
+	ent->dflags |= DAMAGE_CUSTOM_HUD; // dumb, but we draw a custom hud
+
+	ent->s.modelindex = G_ModelIndex( name );
+	ent->playerModel = gi.G2API_InitGhoul2Model( ent->ghoul2, name, ent->s.modelindex );
+
+	// Activate our tags and bones
+	ent->headBolt = gi.G2API_AddBolt( &ent->ghoul2[ent->playerModel], "*seat" );
+	ent->handLBolt = gi.G2API_AddBolt( &ent->ghoul2[ent->playerModel], "*flash01" );
+	ent->handRBolt = gi.G2API_AddBolt( &ent->ghoul2[ent->playerModel], "*flash02" );
+	ent->rootBone = gi.G2API_GetBoneIndex( &ent->ghoul2[ent->playerModel], "base_bone", qtrue );
+	ent->lowerLumbarBone = gi.G2API_GetBoneIndex( &ent->ghoul2[ent->playerModel], "swivel_bone", qtrue );
+	gi.G2API_SetBoneAnglesIndex( &ent->ghoul2[ent->playerModel], ent->lowerLumbarBone, vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_Y, POSITIVE_Z, POSITIVE_X, NULL); 
+
+	RegisterItem( FindItemForWeapon( WP_EMPLACED_GUN ));
+	ent->s.weapon = WP_EMPLACED_GUN;
+
+	G_SetOrigin( ent, ent->s.origin );
+	G_SetAngles( ent, ent->s.angles );
+	VectorCopy( ent->s.angles, ent->lastAngles );
+
+	// store base angles for later
+	VectorCopy( ent->s.angles, ent->pos1 );
+
+	ent->e_UseFunc = useF_emplaced_gun_use;
+	ent->bounceCount = 0;//to distinguish it from the eweb
+
+	gi.linkentity (ent);
+}
+
+//====================================================
+//General Emplaced Weapon Funcs called in g_active.cpp
+//====================================================
+
+void G_UpdateEmplacedWeaponData( gentity_t *ent )
+{
+	if ( ent && ent->owner && ent->health > 0 )
+	{
+		gentity_t *chair = ent->owner;
+		if ( chair->e_UseFunc == useF_emplaced_gun_use )//yeah, crappy way to check this, but...
+		{//one that you sit in
+			//take the emplaced gun's waypoint as your own
+			ent->waypoint = chair->waypoint;
+
+			//update the actual origin of the sitter
+			mdxaBone_t	boltMatrix;
+			vec3_t	chairAng = {0, ent->client->ps.viewangles[YAW], 0};
+
+			// Getting the seat bolt here
+			gi.G2API_GetBoltMatrix( chair->ghoul2, chair->playerModel, chair->headBolt,
+					&boltMatrix, chairAng, chair->currentOrigin, (cg.time?cg.time:level.time),
+					NULL, chair->s.modelScale );
+			// Storing ent position, bolt position, and bolt axis
+			gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, ent->client->ps.origin );
+			gi.linkentity( ent );
+		}
+		else if ( chair->e_UseFunc == useF_eweb_use )//yeah, crappy way to check this, but...
+		{//standing at an E-Web
+			EWebPositionUser( ent, chair );
+		}
+	}
+}
+
+void ExitEmplacedWeapon( gentity_t *ent )
+{
+	// requesting to unlock from the weapon
+	// We'll leave the gun pointed in the direction it was last facing, though we'll cut out the pitch
+	if ( ent->client )
+	{
+		// if we are the player we will have put down a brush that blocks NPCs so that we have a clear spot to get back out.
+		//gentity_t *place = G_Find( NULL, FOFS(classname), "emp_placeholder" );
+
+		if ( ent->health > 0 )
+		{//he's still alive, and we have a placeholder, so put him back
+			if ( ent->owner->nextTrain )
+			{
+				// reset the players position
+				VectorCopy( ent->owner->nextTrain->currentOrigin, ent->client->ps.origin );
+				//reset ent's size to normal
+				VectorCopy( ent->owner->nextTrain->mins, ent->mins );
+				VectorCopy( ent->owner->nextTrain->maxs, ent->maxs );
+				//free the placeholder
+				G_FreeEntity( ent->owner->nextTrain );
+				//re-link the ent
+				gi.linkentity( ent );
+			}
+			else if ( ent->owner->e_UseFunc == useF_eweb_use )//yeah, crappy way to check this, but...
+			{
+				// so give 'em a push away from us
+				vec3_t backDir, start, end;
+				trace_t trace;
+				gentity_t *eweb = ent->owner;
+				float curRadius = 0.0f;
+				float minRadius, maxRadius;
+				qboolean safeExit = qfalse;
+
+				VectorSubtract( ent->currentOrigin, eweb->currentOrigin, backDir );
+				backDir[2] = 0;
+				minRadius = VectorNormalize( backDir )-8.0f;
+
+				maxRadius = (ent->maxs[0]+ent->maxs[1])*0.5f;
+				maxRadius += (eweb->maxs[0]+eweb->maxs[1])*0.5f;
+				maxRadius *= 1.5f;
+
+				if ( minRadius >= maxRadius - 1.0f )
+				{
+					maxRadius = minRadius + 8.0f;
+				}
+
+				ent->owner = NULL;//so his trace hits me
+
+				for ( curRadius = minRadius; curRadius <= maxRadius; curRadius += 4.0f )
+				{
+					VectorMA( ent->currentOrigin, curRadius, backDir, start );
+					//make sure they're not in the ground
+					VectorCopy( start, end );
+					start[2] += 18;
+					end[2] -= 18;
+					gi.trace(&trace, start, ent->mins, ent->maxs, end, ent->s.number, ent->clipmask);
+					if ( !trace.allsolid && !trace.startsolid )
+					{
+						G_SetOrigin( ent, trace.endpos );
+						gi.linkentity( ent );
+						safeExit = qtrue;
+						break;
+					}
+				}
+				//Hmm... otherwise, don't allow them to get off?
+				ent->owner = eweb;
+				if ( !safeExit )
+				{//don't try again for a second
+					ent->owner->delay = level.time + 500;
+					return;
+				}
+			}
+		}
+		else if ( ent->health <= 0 )
+		{
+			// dead, so give 'em a push out of the chair
+			vec3_t dir;
+			AngleVectors( ent->owner->s.angles, NULL, dir, NULL );
+
+			if ( rand() & 1 )
+			{
+				VectorScale( dir, -1, dir );
+			}
+
+			VectorMA( ent->client->ps.velocity, 75, dir, ent->client->ps.velocity );
+		}
+		//don't let them move towards me for a couple frames so they don't step back into me while I'm becoming solid to them
+		if ( ent->s.number < MAX_CLIENTS )
+		{
+			if ( ent->client->ps.pm_time < 100 )
+			{
+				ent->client->ps.pm_time = 100;
+			}
+			ent->client->ps.pm_flags |= (PMF_TIME_NOFRICTION|PMF_TIME_KNOCKBACK);
+		}
+
+		if ( !ent->owner->bounceCount )
+		{//not an EWeb - the overridden bone angles will remember the angle we left it at
+			VectorCopy( ent->client->ps.viewangles, ent->owner->s.angles );
+			ent->owner->s.angles[PITCH] = 0;
+			G_SetAngles( ent->owner, ent->owner->s.angles );
+			VectorCopy( ent->owner->s.angles, ent->owner->pos1 );
+		}
+	}
+
+	// Remove the emplaced gun from our inventory
+	ent->client->ps.stats[STAT_WEAPONS] &= ~( 1 << WP_EMPLACED_GUN );
+
+extern void ChangeWeapon( gentity_t *ent, int newWeapon );
+extern void CG_ChangeWeapon( int num );
+	if ( ent->health <= 0 ) 
+	{//when die, don't set weapon back on when ejected from emplaced/eweb
+		//empty hands
+		ent->client->ps.weapon = WP_NONE;
+		if ( ent->NPC )
+		{
+			ChangeWeapon( ent, ent->client->ps.weapon );	// should be OK actually.
+		}
+		else
+		{
+			CG_ChangeWeapon( ent->client->ps.weapon );
+		}
+		if ( ent->s.number < MAX_CLIENTS )
+		{
+			gi.cvar_set( "cg_thirdperson", "1" );
+		}
+	}
+	else
+	{
+		// when we lock or unlock from the the gun, we get our old weapon back
+		ent->client->ps.weapon = ent->owner->s.weapon;
+
+		if ( ent->NPC )
+		{//BTW, if a saber-using NPC ever gets off of an emplaced gun/eweb, this will not work, look at NPC_ChangeWeapon for the proper way
+			ChangeWeapon( ent, ent->client->ps.weapon );
+		}
+		else
+		{
+			G_RemoveWeaponModels( ent );
+			CG_ChangeWeapon( ent->client->ps.weapon );
+			if ( ent->client->ps.weapon == WP_SABER )
+			{
+				WP_SaberAddG2SaberModels( ent );
+			}
+			else
+			{
+				G_CreateG2AttachedWeaponModel( ent, weaponData[ent->client->ps.weapon].weaponMdl, ent->handRBolt, 0 );
+			}
+
+			if ( ent->s.number < MAX_CLIENTS )
+			{
+				if ( ent->client->ps.weapon == WP_SABER )
+				{
+					gi.cvar_set( "cg_thirdperson", "1" );
+				}
+				else if ( ent->client->ps.weapon != WP_SABER && cg_gunAutoFirst.integer )
+				{
+					gi.cvar_set( "cg_thirdperson", "0" );
+				}
+			}
+		}
+
+		if ( ent->client->ps.weapon == WP_SABER )
+		{
+			if ( ent->owner->alt_fire )
+			{
+				ent->client->ps.SaberActivate();
+			}
+			else
+			{
+				ent->client->ps.SaberDeactivate();
+			}
+		}
+	}
+	//set the emplaced gun/eweb's weapon back to the emplaced gun
+	ent->owner->s.weapon = WP_EMPLACED_GUN;
+//	gi.G2API_DetachG2Model( &ent->ghoul2[ent->playerModel] );
+
+	ent->s.eFlags &= ~EF_LOCKED_TO_WEAPON;
+	ent->client->ps.eFlags &= ~EF_LOCKED_TO_WEAPON;
+
+	ent->owner->noDamageTeam = TEAM_FREE;
+	ent->owner->svFlags &= ~SVF_NONNPC_ENEMY;
+	ent->owner->delay = level.time;
+	ent->owner->activator = NULL;
+
+	if ( !ent->NPC )
+	{
+		// by keeping the owner, a dead npc can be pushed out of the chair without colliding with it
+		ent->owner = NULL;
+	}
+}
+
+void RunEmplacedWeapon( gentity_t *ent, usercmd_t **ucmd )
+{
+	if (( (*ucmd)->buttons & BUTTON_USE || (*ucmd)->forwardmove < 0 || (*ucmd)->upmove > 0 ) && ent->owner && ent->owner->delay + 500 < level.time )
+	{
+		ent->owner->s.loopSound = 0;
+
+		if ( ent->owner->e_UseFunc == useF_eweb_use )//yeah, crappy way to check this, but...
+		{
+			G_Sound( ent, G_SoundIndex( "sound/weapons/eweb/eweb_dismount.mp3" ));
+		}
+		else
+		{
+			G_Sound( ent, G_SoundIndex( "sound/weapons/emplaced/emplaced_dismount.mp3" ));
+
+		}
+#ifdef _IMMERSION
+		G_Force( ent, G_ForceIndex( "fffx/weapons/emplaced/emplaced_dismount", FF_CHANNEL_TOUCH ) );
+#endif // _IMMERSION
+
+		ExitEmplacedWeapon( ent );
+		(*ucmd)->buttons &= ~BUTTON_USE;
+		if ( (*ucmd)->upmove > 0 )
+		{//don't actually jump
+			(*ucmd)->upmove = 0;
+		}
+	}
+	else
+	{
+		// this is a crappy way to put sounds on a moving eweb....
+		if ( ent->owner
+			&& ent->owner->e_UseFunc == useF_eweb_use )//yeah, crappy way to check this, but...
+		{
+			if ( !VectorCompare( ent->client->ps.viewangles, ent->owner->movedir ))
+			{
+				ent->owner->s.loopSound = G_SoundIndex( "sound/weapons/eweb/eweb_aim.wav" );
+				ent->owner->fly_sound_debounce_time = level.time;
+			}
+			else
+			{
+				if ( ent->owner->fly_sound_debounce_time + 100 <= level.time )
+				{
+					ent->owner->s.loopSound = 0;
+				}
+			}
+
+			VectorCopy( ent->client->ps.viewangles, ent->owner->movedir );
+		}
+
+		// don't allow movement, weapon switching, and most kinds of button presses
+		(*ucmd)->forwardmove = 0;
+		(*ucmd)->rightmove = 0;
+		(*ucmd)->upmove = 0;
+		(*ucmd)->buttons &= (BUTTON_ATTACK|BUTTON_ALT_ATTACK);
+
+		(*ucmd)->weapon = ent->client->ps.weapon; //WP_EMPLACED_GUN;
+
+		if ( ent->health <= 0 )
+		{
+			ExitEmplacedWeapon( ent );
+		}
+	}
+}
diff --git a/code/game/g_functions.cpp b/code/game/g_functions.cpp
new file mode 100644
index 0000000..8e11517
--- /dev/null
+++ b/code/game/g_functions.cpp
@@ -0,0 +1,412 @@
+// Filename:-	g_functions.cpp
+//
+
+// leave this line at the top for all g_xxxx.cpp files...
+#include "g_headers.h"
+
+
+
+
+
+// This file contains the 8 (so far) function calls that replace the 8 function ptrs in the gentity_t structure
+
+#include "g_local.h"
+#include "..\cgame\cg_local.h"
+#include "g_functions.h"
+
+void GEntity_ThinkFunc(gentity_t *self)
+{
+//#define THINKCASE(blah) case thinkF_ ## blah: blah(self); OutputDebugString(va("%s\n",#blah));break;
+#define THINKCASE(blah) case thinkF_ ## blah: blah(self); break;
+
+	switch (self->e_ThinkFunc)
+	{
+	case thinkF_NULL:																	
+		break;
+
+	THINKCASE( funcBBrushDieGo )			
+	THINKCASE( ExplodeDeath )				
+	THINKCASE( RespawnItem )				
+	THINKCASE( G_FreeEntity )				
+	THINKCASE( FinishSpawningItem )			
+	THINKCASE( locateCamera )				
+	THINKCASE( G_RunObject )				
+	THINKCASE( ReturnToPos1 )				
+	THINKCASE( Use_BinaryMover_Go )			
+	THINKCASE( Think_MatchTeam )			
+	THINKCASE( Think_BeginMoving )			
+	THINKCASE( Think_SetupTrainTargets )	
+	THINKCASE( Think_SpawnNewDoorTrigger )	
+	THINKCASE( ref_link )						
+	THINKCASE( Think_Target_Delay )			
+	THINKCASE( target_laser_think )			
+	THINKCASE( target_laser_start )			
+	THINKCASE( target_location_linkup )		
+	THINKCASE( scriptrunner_run )			
+	THINKCASE( multi_wait )					
+	THINKCASE( multi_trigger_run )			
+	THINKCASE( trigger_always_think )		
+	THINKCASE( AimAtTarget )				
+	THINKCASE( func_timer_think )			
+	THINKCASE( NPC_RemoveBody )				
+	THINKCASE( Disappear )					
+	THINKCASE( NPC_Think )					
+	THINKCASE( NPC_Spawn_Go )				
+	THINKCASE( NPC_Begin )					
+	THINKCASE( moverCallback )
+	THINKCASE( anglerCallback )
+	// This RemoveOwner need to exist here anymore???
+	THINKCASE( RemoveOwner )				
+	THINKCASE( MakeOwnerInvis )				
+	THINKCASE( MakeOwnerEnergy )			
+	THINKCASE( func_usable_think )
+	THINKCASE( misc_dlight_think )
+	THINKCASE( health_think )
+	THINKCASE( ammo_think )
+	THINKCASE( trigger_teleporter_find_closest_portal )
+	THINKCASE( thermalDetonatorExplode )
+	THINKCASE( WP_ThermalThink )
+	THINKCASE( trigger_hurt_reset )
+	THINKCASE( turret_base_think )
+	THINKCASE( turret_head_think )
+	THINKCASE( laser_arm_fire )
+	THINKCASE( laser_arm_start )
+	THINKCASE( trigger_visible_check_player_visibility )
+	THINKCASE( target_relay_use_go )
+	THINKCASE( trigger_cleared_fire )
+	THINKCASE( MoveOwner )
+	THINKCASE( SolidifyOwner )
+	THINKCASE( cycleCamera )
+	THINKCASE( spawn_ammo_crystal_trigger )
+	THINKCASE( NPC_ShySpawn )
+	THINKCASE( func_wait_return_solid )
+	THINKCASE( InflateOwner )
+	THINKCASE( mega_ammo_think )
+	THINKCASE( misc_replicator_item_finish_spawn )
+	THINKCASE( fx_runner_link )
+	THINKCASE( fx_runner_think )
+	THINKCASE( fx_rain_think ) // delay flagging entities as portal entities (for sky portals)
+	THINKCASE( removeBoltSurface)
+	THINKCASE( set_MiscAnim)
+	THINKCASE( LimbThink )
+	THINKCASE( laserTrapThink )
+	THINKCASE( TieFighterThink )
+	THINKCASE( TieBomberThink )
+	THINKCASE( rocketThink )
+	THINKCASE( prox_mine_think )
+	THINKCASE( emplaced_blow )
+	THINKCASE( WP_Explode )
+	THINKCASE( pas_think )	// personal assault sentry
+	THINKCASE( ion_cannon_think )
+	THINKCASE( maglock_link )
+	THINKCASE( WP_flechette_alt_blow )
+	THINKCASE( WP_prox_mine_think )
+	THINKCASE( camera_aim )
+	THINKCASE( fx_explosion_trail_link )
+	THINKCASE( fx_explosion_trail_think )
+	THINKCASE( fx_target_beam_link )
+	THINKCASE( fx_target_beam_think )
+	THINKCASE( spotlight_think )
+	THINKCASE( spotlight_link )
+	THINKCASE( trigger_push_checkclear )
+	THINKCASE( DEMP2_AltDetonate )
+	THINKCASE( DEMP2_AltRadiusDamage )
+	THINKCASE( panel_turret_think )
+	THINKCASE( welder_think )
+	THINKCASE( gas_random_jet )
+	THINKCASE( poll_converter ) // dumb loop sound handling 
+	THINKCASE( spawn_rack_goods ) // delay spawn of goods to help on ents
+	THINKCASE( NoghriGasCloudThink )
+
+	THINKCASE( G_PortalifyEntities ) // delay flagging entities as portal entities (for sky portals)
+
+	THINKCASE( misc_weapon_shooter_aim )
+	THINKCASE( misc_weapon_shooter_fire )
+
+	THINKCASE( beacon_think )
+	
+	default:
+		Com_Error(ERR_DROP, "GEntity_ThinkFunc: case %d not handled!\n",self->e_ThinkFunc);
+		break;
+	}
+}
+
+// note different switch-case code for CEntity as opposed to GEntity (CEntity goes through parent GEntity first)...
+//
+void CEntity_ThinkFunc(centity_s *cent)
+{
+//#define CLTHINKCASE(blah) case clThinkF_ ## blah: blah(cent); OutputDebugString(va("%s\n",#blah));break;
+#define CLTHINKCASE(blah) case clThinkF_ ## blah: blah(cent); break;
+
+	switch (cent->gent->e_clThinkFunc)
+	{
+	case clThinkF_NULL:
+		break;
+
+	CLTHINKCASE( CG_DLightThink )
+	CLTHINKCASE( CG_MatrixEffect )
+	CLTHINKCASE( CG_Limb )
+
+	default:
+		Com_Error(ERR_DROP, "CEntity_ThinkFunc: case %d not handled!\n",cent->gent->e_clThinkFunc);
+		break;
+	}
+}
+
+
+void GEntity_ReachedFunc(gentity_t *self)
+{	
+//#define REACHEDCASE(blah) case reachedF_ ## blah: blah(self); OutputDebugString(va("%s\n",#blah));break;
+#define REACHEDCASE(blah) case reachedF_ ## blah: blah(self); break;
+
+	switch (self->e_ReachedFunc)
+	{	
+	case reachedF_NULL:
+		break;
+
+	REACHEDCASE( Reached_BinaryMover )
+	REACHEDCASE( Reached_Train )
+	REACHEDCASE( moverCallback )
+	REACHEDCASE( moveAndRotateCallback )
+
+	default:
+		Com_Error(ERR_DROP, "GEntity_ReachedFunc: case %d not handled!\n",self->e_ReachedFunc);
+		break;
+	}
+}
+
+
+
+void GEntity_BlockedFunc(gentity_t *self, gentity_t *other)
+{
+//#define BLOCKEDCASE(blah) case blockedF_ ## blah: blah(self,other); OutputDebugString(va("%s\n",#blah));break;
+#define BLOCKEDCASE(blah) case blockedF_ ## blah: blah(self,other); break;
+
+	switch (self->e_BlockedFunc)
+	{
+	case blockedF_NULL:
+		break;
+
+	BLOCKEDCASE( Blocked_Door )		
+	BLOCKEDCASE( Blocked_Mover )		
+
+	default:
+		Com_Error(ERR_DROP, "GEntity_BlockedFunc: case %d not handled!\n",self->e_BlockedFunc);
+		break;
+	}
+}
+
+void GEntity_TouchFunc(gentity_t *self, gentity_t *other, trace_t *trace)
+{
+//#define TOUCHCASE(blah) case touchF_ ## blah: blah(self,other,trace); OutputDebugString(va("%s\n",#blah));break;
+#define TOUCHCASE(blah) case touchF_ ## blah: blah(self,other,trace); break;
+
+	switch (self->e_TouchFunc)
+	{
+	case touchF_NULL:
+		break;
+
+	TOUCHCASE( Touch_Item )
+	TOUCHCASE( teleporter_touch )
+	TOUCHCASE( charge_stick )
+	TOUCHCASE( Touch_DoorTrigger )
+	TOUCHCASE( Touch_PlatCenterTrigger )
+	TOUCHCASE( Touch_Plat )
+	TOUCHCASE( Touch_Button )
+	TOUCHCASE( Touch_Multi )
+	TOUCHCASE( trigger_push_touch )
+	TOUCHCASE( trigger_teleporter_touch )
+	TOUCHCASE( hurt_touch )
+	TOUCHCASE( NPC_Touch )
+	TOUCHCASE( touch_ammo_crystal_tigger )
+	TOUCHCASE( funcBBrushTouch )
+	TOUCHCASE( touchLaserTrap )
+	TOUCHCASE( prox_mine_stick )
+	TOUCHCASE( func_rotating_touch )
+	TOUCHCASE( TouchTieBomb )
+	
+	default:
+		Com_Error(ERR_DROP, "GEntity_TouchFunc: case %d not handled!\n",self->e_TouchFunc);
+	}
+}
+
+void GEntity_UseFunc(gentity_t *self, gentity_t *other, gentity_t *activator)
+{
+	if ( !self || (self->svFlags&SVF_INACTIVE) )
+	{
+		return;
+	}
+//#define USECASE(blah) case useF_ ## blah: blah(self,other,activator); OutputDebugString(va("%s\n",#blah));break;
+#define USECASE(blah) case useF_ ## blah: blah(self,other,activator); break;
+
+	switch (self->e_UseFunc)
+	{
+	case useF_NULL:
+		break;
+
+	USECASE( funcBBrushUse )
+	USECASE( misc_model_use )
+	USECASE( Use_Item )
+	USECASE( Use_Shooter )
+	USECASE( GoExplodeDeath )
+	USECASE( Use_BinaryMover )
+	USECASE( use_wall )
+	USECASE( Use_Target_Give )
+	USECASE( Use_Target_Delay )
+	USECASE( Use_Target_Score )
+	USECASE( Use_Target_Print )
+	USECASE( Use_Target_Speaker )
+	USECASE( target_laser_use )
+	USECASE( target_relay_use )
+	USECASE( target_kill_use )
+	USECASE( target_counter_use )
+	USECASE( target_random_use )
+	USECASE( target_scriptrunner_use )
+	USECASE( target_gravity_change_use )
+	USECASE( target_friction_change_use )
+	USECASE( target_teleporter_use )
+	USECASE( Use_Multi )
+	USECASE( Use_target_push )
+	USECASE( hurt_use )
+	USECASE( func_timer_use )
+	USECASE( trigger_entdist_use )
+	USECASE( func_usable_use )
+	USECASE( target_activate_use )
+	USECASE( target_deactivate_use )
+	USECASE( NPC_Use )
+	USECASE( NPC_Spawn )
+	USECASE( misc_dlight_use )
+	USECASE( health_use )
+	USECASE( ammo_use )
+	USECASE( mega_ammo_use )
+	USECASE( target_level_change_use )
+	USECASE( target_change_parm_use )
+	USECASE( turret_base_use )
+	USECASE( laser_arm_use )
+	USECASE( func_static_use )
+	USECASE( target_play_music_use )
+	USECASE( misc_model_useup )
+	USECASE( misc_portal_use )
+	USECASE( target_autosave_use )
+	USECASE( switch_models )
+	USECASE( misc_replicator_item_spawn )
+	USECASE( misc_replicator_item_remove )
+	USECASE( target_secret_use)
+	USECASE( func_bobbing_use )
+	USECASE( func_rotating_use )
+	USECASE( fx_runner_use )
+	USECASE( funcGlassUse )
+	USECASE( TrainUse )
+	USECASE( misc_trip_mine_activate )
+	USECASE( emplaced_gun_use )
+	USECASE( shield_power_converter_use )
+	USECASE( ammo_power_converter_use )
+	USECASE( bomb_planted_use )
+	USECASE( beacon_use )
+	USECASE( security_panel_use )
+	USECASE( ion_cannon_use )
+	USECASE( camera_use )
+	USECASE( fx_explosion_trail_use )
+	USECASE( fx_target_beam_use )
+	USECASE( sentry_use )
+	USECASE( spotlight_use )
+	USECASE( misc_atst_use )
+	USECASE( panel_turret_use )
+	USECASE( welder_use )
+	USECASE( jabba_cam_use )
+	USECASE( misc_use )
+	USECASE( pas_use )
+	USECASE( item_spawn_use )
+	USECASE( NPC_VehicleSpawnUse )
+	USECASE( misc_weapon_shooter_use )
+	USECASE( eweb_use )
+	USECASE( TieFighterUse );
+	
+	default:
+		Com_Error(ERR_DROP, "GEntity_UseFunc: case %d not handled!\n",self->e_UseFunc);
+	}
+}
+
+void GEntity_PainFunc(gentity_t *self, gentity_t *inflictor, gentity_t *attacker, const vec3_t point, int damage, int mod,int hitLoc)
+{
+//#define PAINCASE(blah) case painF_ ## blah: blah(self,attacker,damage); OutputDebugString(va("%s\n",#blah));break;
+#define PAINCASE(blah) case painF_ ## blah: blah(self,inflictor,attacker,point,damage,mod,hitLoc); break;
+
+	switch (self->e_PainFunc)
+	{
+	case painF_NULL:
+		break;
+
+	PAINCASE( funcBBrushPain )
+	PAINCASE( misc_model_breakable_pain	)
+	PAINCASE( NPC_Pain )
+	PAINCASE( station_pain )
+	PAINCASE( func_usable_pain )
+	PAINCASE( NPC_ATST_Pain )
+	PAINCASE( NPC_ST_Pain )
+	PAINCASE( NPC_Jedi_Pain )
+	PAINCASE( NPC_Droid_Pain )
+	PAINCASE( NPC_Probe_Pain )
+	PAINCASE( NPC_MineMonster_Pain )
+	PAINCASE( NPC_Howler_Pain )
+	PAINCASE( NPC_Rancor_Pain )
+	PAINCASE( NPC_Wampa_Pain )
+	PAINCASE( NPC_SandCreature_Pain )
+	PAINCASE( NPC_Seeker_Pain )
+	PAINCASE( NPC_Remote_Pain )
+	PAINCASE( emplaced_gun_pain )
+	PAINCASE( NPC_Mark1_Pain )
+	PAINCASE( NPC_Sentry_Pain )
+	PAINCASE( NPC_Mark2_Pain )
+	PAINCASE( PlayerPain )
+	PAINCASE( GasBurst )
+	PAINCASE( CrystalCratePain )
+	PAINCASE( TurretPain )
+	PAINCASE( eweb_pain )
+
+	default:
+		Com_Error(ERR_DROP, "GEntity_PainFunc: case %d not handled!\n",self->e_PainFunc);
+	}
+}
+
+
+void GEntity_DieFunc(gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int mod, int dFlags, int hitLoc)
+{
+//#define DIECASE(blah) case dieF_ ## blah: blah(self,inflictor,attacker,damage,mod); OutputDebugString(va("%s\n",#blah));break;
+#define DIECASE(blah) case dieF_ ## blah: blah(self,inflictor,attacker,damage,mod,dFlags,hitLoc); break;
+
+	switch (self->e_DieFunc)
+	{
+	case dieF_NULL:
+		break;
+
+	DIECASE( funcBBrushDie )
+	DIECASE( misc_model_breakable_die )
+	DIECASE( misc_model_cargo_die )
+	DIECASE( func_train_die )
+	DIECASE( player_die )
+	DIECASE( ExplodeDeath_Wait )
+	DIECASE( ExplodeDeath )
+	DIECASE( func_usable_die )
+	DIECASE( turret_die )
+	DIECASE( funcGlassDie )
+//	DIECASE( laserTrapDelayedExplode )
+	DIECASE( emplaced_gun_die )
+	DIECASE( WP_ExplosiveDie )
+	DIECASE( ion_cannon_die )
+	DIECASE( maglock_die )
+	DIECASE( camera_die )
+	DIECASE( Mark1_die )
+	DIECASE( Interrogator_die )
+	DIECASE( misc_atst_die )
+	DIECASE( misc_panel_turret_die )
+	DIECASE( thermal_die )
+	DIECASE( eweb_die )
+
+	default:
+		Com_Error(ERR_DROP, "GEntity_DieFunc: case %d not handled!\n",self->e_DieFunc);
+	}
+}
+
+//////////////////// eof /////////////////////
+
diff --git a/code/game/g_functions.h b/code/game/g_functions.h
new file mode 100644
index 0000000..79f27e0
--- /dev/null
+++ b/code/game/g_functions.h
@@ -0,0 +1,630 @@
+// Filename:-	g_functions.h
+//
+
+#ifndef G_FUNCTIONS
+#define G_FUNCTIONS
+
+#undef thinkFunc_t
+#undef clThinkFunc_t
+#undef reachedFunc_t
+#undef blockedFunc_t
+#undef touchFunc_t
+#undef useFunc_t
+#undef painFunc_t
+#undef dieFunc_t
+
+//	void		(*think)(gentity_t *self);
+typedef enum 
+{
+	thinkF_NULL = 0,
+	//
+	thinkF_teleporter_think,
+	thinkF_funcBBrushDieGo,
+	thinkF_ExplodeDeath,
+	thinkF_RespawnItem,
+	thinkF_G_FreeEntity,
+	thinkF_FinishSpawningItem,	
+	thinkF_locateCamera,
+	thinkF_G_RunObject,
+	thinkF_ReturnToPos1,
+	thinkF_Use_BinaryMover_Go,
+	thinkF_Think_MatchTeam,
+	thinkF_Think_BeginMoving,
+	thinkF_Think_SetupTrainTargets,
+	thinkF_Think_SpawnNewDoorTrigger,
+	thinkF_ref_link,
+	thinkF_Think_Target_Delay,
+	thinkF_target_laser_think,
+	thinkF_target_laser_start,
+	thinkF_target_location_linkup,
+	thinkF_scriptrunner_run,
+	thinkF_multi_wait,
+	thinkF_multi_trigger_run,
+	thinkF_trigger_always_think,
+	thinkF_AimAtTarget,
+	thinkF_func_timer_think,
+	thinkF_NPC_RemoveBody,
+	thinkF_Disappear,
+	thinkF_NPC_Think,
+	thinkF_NPC_Spawn_Go,
+	thinkF_NPC_Begin,
+	thinkF_moverCallback,
+	thinkF_anglerCallback,
+	thinkF_RemoveOwner,
+	thinkF_MakeOwnerInvis,
+	thinkF_MakeOwnerEnergy,
+	thinkF_transporter_stream_think,
+	thinkF_func_usable_think,
+	thinkF_misc_dlight_think,
+	thinkF_health_think,
+	thinkF_ammo_think,
+	thinkF_trigger_teleporter_find_closest_portal,
+	thinkF_thermalDetonatorExplode,
+	thinkF_WP_ThermalThink,
+	thinkF_trigger_hurt_reset,
+	thinkF_turret_base_think,
+	thinkF_turret_head_think,
+	thinkF_HS_Think,
+	thinkF_laser_arm_fire,
+	thinkF_laser_arm_start,
+	thinkF_trigger_visible_check_player_visibility,
+	thinkF_target_relay_use_go,
+	thinkF_trigger_cleared_fire,
+	thinkF_MoveOwner,
+	thinkF_SolidifyOwner,
+	thinkF_cycleCamera,
+	thinkF_spawn_ammo_crystal_trigger,
+	thinkF_NPC_ShySpawn,
+	thinkF_func_wait_return_solid,
+	thinkF_InflateOwner,
+	thinkF_mega_ammo_think,
+	thinkF_misc_replicator_item_finish_spawn,
+	thinkF_fx_runner_link,
+	thinkF_fx_runner_think,
+	thinkF_fx_rain_think,		// cdr added
+	thinkF_removeBoltSurface,
+	thinkF_set_MiscAnim,
+	thinkF_LimbThink,
+	thinkF_laserTrapThink,
+	thinkF_TieFighterThink,
+	thinkF_TieBomberThink,
+	thinkF_rocketThink,
+	thinkF_prox_mine_think,
+	thinkF_emplaced_blow,
+	thinkF_WP_Explode,
+	thinkF_pas_think,	//personal assault sentry
+	thinkF_ion_cannon_think,
+	thinkF_maglock_link,
+	thinkF_WP_flechette_alt_blow,
+	thinkF_WP_prox_mine_think,
+	thinkF_camera_aim,
+	thinkF_fx_explosion_trail_link,
+	thinkF_fx_explosion_trail_think,
+	thinkF_fx_target_beam_link,
+	thinkF_fx_target_beam_think,
+	thinkF_spotlight_think,
+	thinkF_spotlight_link,
+	thinkF_trigger_push_checkclear,
+	thinkF_DEMP2_AltDetonate,
+	thinkF_DEMP2_AltRadiusDamage,
+	thinkF_panel_turret_think,
+	thinkF_welder_think,
+	thinkF_gas_random_jet,
+	thinkF_poll_converter,
+	thinkF_spawn_rack_goods,
+	thinkF_misc_weapon_shooter_aim,
+	thinkF_misc_weapon_shooter_fire,
+	thinkF_beacon_think,
+	thinkF_NoghriGasCloudThink,
+
+	//rww - added for sky portals
+	thinkF_G_PortalifyEntities,
+
+} thinkFunc_t;
+
+// THINK functions...
+//
+extern void teleporter_think	( gentity_t *ent );
+extern void funcBBrushDieGo		( gentity_t *ent );
+extern void ExplodeDeath		( gentity_t *ent );
+extern void RespawnItem			( gentity_t *ent );
+extern void G_FreeEntity		( gentity_t *ent );
+extern void FinishSpawningItem	( gentity_t *ent );
+extern void locateCamera		( gentity_t *ent );
+extern void G_RunObject			( gentity_t *ent );
+extern void ReturnToPos1		( gentity_t *ent );
+extern void Use_BinaryMover_Go	( gentity_t *ent );
+extern void Think_MatchTeam		( gentity_t *ent );
+extern void Think_MatchTeam		( gentity_t *ent );
+extern void Think_BeginMoving	( gentity_t *ent );
+extern void Think_SetupTrainTargets	( gentity_t *ent );
+extern void Think_SpawnNewDoorTrigger	( gentity_t *ent );
+extern void ref_link			( gentity_t *ent );
+extern void Think_Target_Delay	( gentity_t *ent );
+extern void target_laser_think	( gentity_t *ent );
+extern void target_laser_start	( gentity_t *ent );
+extern void target_location_linkup	( gentity_t *ent );
+extern void scriptrunner_run	( gentity_t *ent );
+extern void multi_wait			( gentity_t *ent );
+extern void multi_trigger_run	( gentity_t *ent );
+extern void trigger_always_think	( gentity_t *ent );
+extern void AimAtTarget			( gentity_t *ent );
+extern void func_timer_think	( gentity_t *ent );
+extern void NPC_RemoveBody		( gentity_t *ent );
+extern void Disappear			( gentity_t *ent );
+extern void NPC_Think			( gentity_t *ent );
+extern void NPC_Spawn_Go		( gentity_t *ent );
+extern void NPC_Begin			( gentity_t *ent );
+extern void moverCallback		( gentity_t *ent );
+extern void anglerCallback		( gentity_t *ent );
+extern void RemoveOwner			( gentity_t *ent );
+extern void MakeOwnerInvis		( gentity_t *ent );
+extern void MakeOwnerEnergy		( gentity_t *ent );
+extern void func_usable_think	( gentity_t *self );
+extern void misc_dlight_think	( gentity_t *ent ); 
+extern void laser_link				( gentity_t *ent );
+extern void blow_chunks_link		( gentity_t *ent );
+extern void health_think			( gentity_t *ent );
+extern void ammo_think				( gentity_t *ent );
+extern void trigger_teleporter_find_closest_portal ( gentity_t *self );
+extern void thermalDetonatorExplode	( gentity_t *ent );
+extern void WP_ThermalThink			( gentity_t *ent );
+extern void trigger_hurt_reset		( gentity_t *self );
+extern void turret_base_think		( gentity_t *self );
+extern void turret_head_think		( gentity_t *self );
+extern void laser_arm_fire			( gentity_t *ent );
+extern void laser_arm_start			( gentity_t *base );
+extern void trigger_visible_check_player_visibility	( gentity_t *self );
+extern void target_relay_use_go		( gentity_t *self );
+extern void trigger_cleared_fire	( gentity_t *self );
+extern void MoveOwner				( gentity_t *self );
+extern void SolidifyOwner			( gentity_t *self );
+extern void cycleCamera				( gentity_t *self );
+extern void spawn_ammo_crystal_trigger	( gentity_t *ent );
+extern void NPC_ShySpawn			( gentity_t *ent );
+extern void func_wait_return_solid	( gentity_t *self );
+extern void InflateOwner			( gentity_t *self );
+extern void mega_ammo_think			( gentity_t *self );
+extern void misc_replicator_item_finish_spawn( gentity_t *self );
+extern void fx_runner_link			( gentity_t *self );
+extern void fx_runner_think			( gentity_t *self );
+extern void fx_rain_think			( gentity_t *self );
+extern void set_MiscAnim			( gentity_t *self);
+extern void removeBoltSurface		( gentity_t *self);
+extern void LimbThink				( gentity_t *ent );
+extern void laserTrapThink			( gentity_t *self );
+extern void TieFighterThink			( gentity_t *self );
+extern void TieBomberThink			( gentity_t *self );
+extern void rocketThink				( gentity_t *ent );
+extern void prox_mine_think			( gentity_t *ent );
+extern void emplaced_blow			( gentity_t *self );
+extern void WP_Explode				( gentity_t *self );
+extern void pas_think				( gentity_t *self );
+extern void ion_cannon_think		( gentity_t *self );
+extern void maglock_link			( gentity_t *self );
+extern void WP_flechette_alt_blow	( gentity_t *self );
+extern void WP_prox_mine_think		( gentity_t *self );
+extern void camera_aim				( gentity_t *self );
+extern void fx_explosion_trail_link	( gentity_t *self );
+extern void fx_explosion_trail_think( gentity_t *self );
+extern void fx_target_beam_link		( gentity_t *self );
+extern void fx_target_beam_think	( gentity_t *self );
+extern void spotlight_think			( gentity_t *self );
+extern void spotlight_link			( gentity_t *self );
+extern void trigger_push_checkclear	( gentity_t *self );
+extern void DEMP2_AltDetonate		( gentity_t *self );
+extern void DEMP2_AltRadiusDamage	( gentity_t *self );
+extern void panel_turret_think		( gentity_t *self );
+extern void welder_think			( gentity_t *self );
+extern void gas_random_jet			( gentity_t *self );
+extern void poll_converter			( gentity_t *self );
+extern void spawn_rack_goods		( gentity_t *self );
+extern void NoghriGasCloudThink		( gentity_t *self );
+
+extern void G_PortalifyEntities		( gentity_t *ent );
+extern void misc_weapon_shooter_aim	( gentity_t *self );
+extern void misc_weapon_shooter_fire( gentity_t *self );
+
+extern void beacon_think			( gentity_t *self );
+
+
+//	void		(*clThink)(centity_s *cent);	//Think func for equivalent centity
+typedef enum
+{
+	clThinkF_NULL = 0,	
+	//
+	clThinkF_CG_DLightThink,
+	clThinkF_CG_MatrixEffect,
+	clThinkF_CG_Limb,
+
+} clThinkFunc_t;
+
+// CEntity THINK functions...
+//
+extern void CG_DLightThink ( centity_t *cent );
+extern void CG_MatrixEffect ( centity_t *cent );
+extern void CG_Limb ( centity_t *cent );
+
+//	void		(*reached)(gentity_t *self);	// movers call this when hitting endpoint
+typedef enum
+{
+	reachedF_NULL = 0,
+	//
+	reachedF_Reached_BinaryMover,
+	reachedF_Reached_Train,
+	reachedF_moverCallback,
+	reachedF_moveAndRotateCallback
+
+} reachedFunc_t;
+
+// REACHED functions...
+//
+extern void Reached_BinaryMover	( gentity_t *ent );
+extern void Reached_Train		( gentity_t *ent );
+extern void moverCallback		( gentity_t *ent );
+extern void moveAndRotateCallback( gentity_t *ent );
+
+
+//	void		(*blocked)(gentity_t *self, gentity_t *other);
+typedef enum
+{
+	blockedF_NULL = 0,
+	//
+	blockedF_Blocked_Door,
+	blockedF_Blocked_Mover	
+
+} blockedFunc_t;
+
+// BLOCKED functions...
+//
+extern void Blocked_Door		(gentity_t *self, gentity_t *other);
+extern void Blocked_Mover		(gentity_t *self, gentity_t *other);
+
+
+
+//	void		(*touch)(gentity_t *self, gentity_t *other, trace_t *trace);
+typedef enum
+{	
+	touchF_NULL = 0,
+	//
+	touchF_Touch_Item,
+	touchF_teleporter_touch,
+	touchF_charge_stick,
+	touchF_Touch_DoorTrigger,
+	touchF_Touch_PlatCenterTrigger,
+	touchF_Touch_Plat,
+	touchF_Touch_Button,
+	touchF_Touch_Multi,
+	touchF_trigger_push_touch,
+	touchF_trigger_teleporter_touch,
+	touchF_hurt_touch,
+	touchF_NPC_Touch,
+	touchF_touch_ammo_crystal_tigger,
+	touchF_funcBBrushTouch,
+	touchF_touchLaserTrap,
+	touchF_prox_mine_stick,
+	touchF_func_rotating_touch,
+	touchF_TouchTieBomb,
+} touchFunc_t;
+
+// TOUCH functions...
+//
+extern void Touch_Item				(gentity_t *self, gentity_t *other, trace_t *trace);
+extern void teleporter_touch		(gentity_t *self, gentity_t *other, trace_t *trace);
+extern void charge_stick			(gentity_t *self, gentity_t *other, trace_t *trace);
+extern void Touch_DoorTrigger		(gentity_t *self, gentity_t *other, trace_t *trace);
+extern void Touch_PlatCenterTrigger	(gentity_t *self, gentity_t *other, trace_t *trace);
+extern void Touch_Plat				(gentity_t *self, gentity_t *other, trace_t *trace);
+extern void Touch_Button			(gentity_t *self, gentity_t *other, trace_t *trace);
+extern void Touch_Multi				(gentity_t *self, gentity_t *other, trace_t *trace);
+extern void trigger_push_touch		(gentity_t *self, gentity_t *other, trace_t *trace);
+extern void trigger_teleporter_touch(gentity_t *self, gentity_t *other, trace_t *trace);
+extern void hurt_touch				(gentity_t *self, gentity_t *other, trace_t *trace);
+extern void NPC_Touch				(gentity_t *self, gentity_t *other, trace_t *trace);
+extern void touch_ammo_crystal_tigger	( gentity_t *self, gentity_t *other, trace_t *trace );
+extern void funcBBrushTouch			( gentity_t *ent, gentity_t *other, trace_t *trace );
+extern void touchLaserTrap	( gentity_t *ent, gentity_t *other, trace_t *trace );
+extern void prox_mine_stick( gentity_t *self, gentity_t *other, trace_t *trace );
+extern void func_rotating_touch				(gentity_t *self, gentity_t *other, trace_t *trace);
+extern void TouchTieBomb( gentity_t *self, gentity_t *other, trace_t *trace );
+extern void TieFighterUse( gentity_t *self, gentity_t *other, gentity_t *activator );
+
+//	void		(*use)(gentity_t *self, gentity_t *other, gentity_t *activator);
+typedef enum
+{
+	useF_NULL = 0,
+	//
+	useF_funcBBrushUse,
+	useF_misc_model_use,
+	useF_Use_Item,
+	useF_Use_Shooter,
+	useF_GoExplodeDeath,
+	useF_Use_BinaryMover,
+	useF_use_wall,
+	useF_Use_Target_Give,
+	useF_Use_Target_Delay,
+	useF_Use_Target_Score,
+	useF_Use_Target_Print,
+	useF_Use_Target_Speaker,
+	useF_target_laser_use,
+	useF_target_relay_use,
+	useF_target_kill_use,
+	useF_target_counter_use,
+	useF_target_random_use,
+	useF_target_scriptrunner_use,
+	useF_target_gravity_change_use,
+	useF_target_friction_change_use,
+	useF_target_teleporter_use,
+	useF_Use_Multi,
+	useF_Use_target_push,
+	useF_hurt_use,
+	useF_func_timer_use,
+	useF_trigger_entdist_use,
+	useF_func_usable_use,
+	useF_target_activate_use,
+	useF_target_deactivate_use,
+	useF_NPC_Use,
+	useF_NPC_Spawn,
+	useF_misc_dlight_use,
+	useF_health_use,
+	useF_ammo_use,
+	useF_mega_ammo_use,
+	useF_target_level_change_use,
+	useF_target_change_parm_use,
+	useF_crew_beam_in_use,
+	useF_turret_base_use,
+	useF_laser_arm_use,
+	useF_func_static_use,
+	useF_target_play_music_use,
+	useF_misc_model_useup,
+	useF_misc_portal_use,
+	useF_target_autosave_use,
+	useF_switch_models,
+	useF_misc_replicator_item_spawn,
+	useF_misc_replicator_item_remove,
+	useF_target_secret_use,
+	useF_func_bobbing_use,
+	useF_func_rotating_use,
+	useF_fx_runner_use,
+	useF_funcGlassUse,
+	useF_TrainUse,
+	useF_misc_trip_mine_activate,
+	useF_emplaced_gun_use,
+	useF_shield_power_converter_use,
+	useF_ammo_power_converter_use,
+	useF_bomb_planted_use,
+	useF_beacon_use,
+	useF_security_panel_use,
+	useF_ion_cannon_use,
+	useF_camera_use,
+	useF_fx_explosion_trail_use,
+	useF_fx_target_beam_use,
+	useF_sentry_use,
+	useF_spotlight_use,
+	useF_misc_atst_use,
+	useF_panel_turret_use,
+	useF_welder_use,
+	useF_jabba_cam_use,
+	useF_misc_use,
+	useF_pas_use,
+	useF_item_spawn_use,
+	useF_NPC_VehicleSpawnUse,
+	useF_misc_weapon_shooter_use,
+	useF_eweb_use,
+	useF_TieFighterUse,
+} useFunc_t;
+
+// USE functions...
+//
+extern void funcBBrushUse			( gentity_t *self, gentity_t *other, gentity_t *activator);
+extern void misc_model_use			( gentity_t *self, gentity_t *other, gentity_t *activator);
+extern void Use_Item				( gentity_t *self, gentity_t *other, gentity_t *activator);
+extern void Use_Shooter				( gentity_t *self, gentity_t *other, gentity_t *activator);					 
+extern void GoExplodeDeath			( gentity_t *self, gentity_t *other, gentity_t *activator);					 
+extern void Use_BinaryMover			( gentity_t *self, gentity_t *other, gentity_t *activator);					 
+extern void use_wall				( gentity_t *self, gentity_t *other, gentity_t *activator);					 
+extern void Use_Target_Give			( gentity_t *self, gentity_t *other, gentity_t *activator);					 
+extern void Use_Target_Delay		( gentity_t *self, gentity_t *other, gentity_t *activator);					 
+extern void Use_Target_Score		( gentity_t *self, gentity_t *other, gentity_t *activator);					 
+extern void Use_Target_Print		( gentity_t *self, gentity_t *other, gentity_t *activator);					 
+extern void Use_Target_Speaker		( gentity_t *self, gentity_t *other, gentity_t *activator);					 
+extern void target_laser_use		( gentity_t *self, gentity_t *other, gentity_t *activator);
+extern void target_relay_use		( gentity_t *self, gentity_t *other, gentity_t *activator);
+extern void target_kill_use			( gentity_t *self, gentity_t *other, gentity_t *activator);
+extern void target_counter_use		( gentity_t *self, gentity_t *other, gentity_t *activator);
+extern void target_random_use		( gentity_t *self, gentity_t *other, gentity_t *activator);							
+extern void target_scriptrunner_use	( gentity_t *self, gentity_t *other, gentity_t *activator);
+extern void target_gravity_change_use	( gentity_t *self, gentity_t *other, gentity_t *activator);
+extern void target_friction_change_use	( gentity_t *self, gentity_t *other, gentity_t *activator);
+extern void target_teleporter_use	( gentity_t *self, gentity_t *other, gentity_t *activator);
+extern void Use_Multi				( gentity_t *self, gentity_t *other, gentity_t *activator);
+extern void Use_target_push			( gentity_t *self, gentity_t *other, gentity_t *activator);
+extern void hurt_use				( gentity_t *self, gentity_t *other, gentity_t *activator);
+extern void func_timer_use			( gentity_t *self, gentity_t *other, gentity_t *activator);
+extern void trigger_entdist_use		( gentity_t *self, gentity_t *other, gentity_t *activator);
+extern void func_usable_use			( gentity_t *self, gentity_t *other, gentity_t *activator);
+extern void target_activate_use		( gentity_t *self, gentity_t *other, gentity_t *activator);
+extern void	target_deactivate_use	( gentity_t *self, gentity_t *other, gentity_t *activator);
+extern void NPC_Use					( gentity_t *self, gentity_t *other, gentity_t *activator);
+extern void NPC_Spawn				( gentity_t *self, gentity_t *other, gentity_t *activator);
+extern void transporter_use			( gentity_t *self, gentity_t *other, gentity_t *activator);
+extern void teleporter_use			( gentity_t *self, gentity_t *other, gentity_t *activator);
+extern void misc_dlight_use			( gentity_t *ent, gentity_t *other, gentity_t *activator );
+extern void health_use				( gentity_t *self, gentity_t *other, gentity_t *activator );
+extern void ammo_use				( gentity_t *self, gentity_t *other, gentity_t *activator );
+extern void mega_ammo_use			( gentity_t *self, gentity_t *other, gentity_t *activator );
+extern void target_level_change_use	( gentity_t *self, gentity_t *other, gentity_t *activator );
+extern void target_change_parm_use	( gentity_t *self, gentity_t *other, gentity_t *activator );
+extern void turret_base_use			( gentity_t *self, gentity_t *other, gentity_t *activator );
+extern void laser_arm_use			( gentity_t *self, gentity_t *other, gentity_t *activator );
+extern void func_static_use			( gentity_t *self, gentity_t *other, gentity_t *activator );
+extern void target_play_music_use	( gentity_t *self, gentity_t *other, gentity_t *activator );
+extern void misc_model_useup		( gentity_t *self, gentity_t *other, gentity_t *activator );
+extern void misc_portal_use			( gentity_t *self, gentity_t *other, gentity_t *activator );
+extern void target_autosave_use 	( gentity_t *self, gentity_t *other, gentity_t *activator );
+extern void switch_models			( gentity_t *self, gentity_t *other, gentity_t *activator );
+extern void misc_replicator_item_spawn ( gentity_t *self, gentity_t *other, gentity_t *activator );
+extern void misc_replicator_item_remove ( gentity_t *self, gentity_t *other, gentity_t *activator );
+extern void target_secret_use		( gentity_t *self, gentity_t *other, gentity_t *activator );
+extern void func_bobbing_use		( gentity_t *self, gentity_t *other, gentity_t *activator );
+extern void func_rotating_use		( gentity_t *self, gentity_t *other, gentity_t *activator );
+extern void fx_runner_use			( gentity_t *self, gentity_t *other, gentity_t *activator );
+extern void funcGlassUse			( gentity_t *self, gentity_t *other, gentity_t *activator );
+extern void TrainUse				( gentity_t *ent, gentity_t *other, gentity_t *activator );
+extern void misc_trip_mine_activate	( gentity_t *self, gentity_t *other, gentity_t *activator );
+extern void emplaced_gun_use		( gentity_t *self, gentity_t *other, gentity_t *activator );
+extern void shield_power_converter_use( gentity_t *self, gentity_t *other, gentity_t *activator );
+extern void ammo_power_converter_use( gentity_t *self, gentity_t *other, gentity_t *activator );
+extern void bomb_planted_use		( gentity_t *self, gentity_t *other, gentity_t *activator );
+extern void beacon_use				( gentity_t *self, gentity_t *other, gentity_t *activator );
+extern void security_panel_use		( gentity_t *self, gentity_t *other, gentity_t *activator );
+extern void ion_cannon_use			( gentity_t *self, gentity_t *other, gentity_t *activator );
+extern void camera_use				( gentity_t *self, gentity_t *other, gentity_t *activator );
+extern void fx_explosion_trail_use	( gentity_t *self, gentity_t *other, gentity_t *activator );
+extern void fx_target_beam_use		( gentity_t *self, gentity_t *other, gentity_t *activator );
+extern void sentry_use				( gentity_t *self, gentity_t *other, gentity_t *activator );
+extern void spotlight_use			( gentity_t *self, gentity_t *other, gentity_t *activator );
+extern void misc_atst_use			( gentity_t *self, gentity_t *other, gentity_t *activator );
+extern void panel_turret_use		( gentity_t *self, gentity_t *other, gentity_t *activator );
+extern void welder_use				( gentity_t *self, gentity_t *other, gentity_t *activator );
+extern void jabba_cam_use			( gentity_t *self, gentity_t *other, gentity_t *activator );
+extern void misc_use				( gentity_t *self, gentity_t *other, gentity_t *activator );
+extern void pas_use					( gentity_t *self, gentity_t *other, gentity_t *activator );
+extern void item_spawn_use			( gentity_t *self, gentity_t *other, gentity_t *activator );
+extern void NPC_VehicleSpawnUse		( gentity_t *self, gentity_t *other, gentity_t *activator );
+extern void misc_weapon_shooter_use	( gentity_t *self, gentity_t *other, gentity_t *activator );
+extern void eweb_use				( gentity_t *self, gentity_t *other, gentity_t *activator );
+
+//	void		(*pain)(gentity_t *self, gentity_t *attacker, int damage,int mod,int hitLoc);
+typedef enum
+{
+	painF_NULL = 0,
+	//
+	painF_funcBBrushPain,
+	painF_misc_model_breakable_pain,
+	painF_NPC_Pain,
+	painF_station_pain,
+	painF_func_usable_pain,
+	painF_NPC_ATST_Pain,
+	painF_NPC_ST_Pain,
+	painF_NPC_Jedi_Pain,
+	painF_NPC_Droid_Pain,
+	painF_NPC_Probe_Pain,
+	painF_NPC_MineMonster_Pain,
+	painF_NPC_Howler_Pain,
+	painF_NPC_Rancor_Pain,
+	painF_NPC_Wampa_Pain,
+	painF_NPC_SandCreature_Pain,
+	painF_NPC_Seeker_Pain,
+	painF_NPC_Remote_Pain,
+	painF_emplaced_gun_pain,
+	painF_NPC_Mark1_Pain,
+	painF_NPC_GM_Pain,
+	painF_NPC_Sentry_Pain,
+	painF_NPC_Mark2_Pain,
+	painF_PlayerPain,
+	painF_GasBurst,
+	painF_CrystalCratePain,
+	painF_TurretPain,
+	painF_eweb_pain,
+} painFunc_t;
+
+// PAIN functions...
+//
+extern void funcBBrushPain				(gentity_t *self, gentity_t *inflictor, gentity_t *attacker, const vec3_t point, int damage, int mod,int hitLoc=HL_NONE);
+extern void misc_model_breakable_pain	(gentity_t *self, gentity_t *inflictor, gentity_t *attacker, const vec3_t point, int damage, int mod,int hitLoc=HL_NONE);
+extern void NPC_Pain					(gentity_t *self, gentity_t *inflictor, gentity_t *attacker, const vec3_t point, int damage, int mod,int hitLoc=HL_NONE);
+extern void station_pain				(gentity_t *self, gentity_t *inflictor, gentity_t *attacker, const vec3_t point, int damage, int mod,int hitLoc=HL_NONE);
+extern void func_usable_pain			(gentity_t *self, gentity_t *inflictor, gentity_t *attacker, const vec3_t point, int damage, int mod,int hitLoc=HL_NONE);
+extern void NPC_ATST_Pain				(gentity_t *self, gentity_t *inflictor, gentity_t *attacker, const vec3_t point, int damage, int mod,int hitLoc=HL_NONE);
+extern void NPC_ST_Pain					(gentity_t *self, gentity_t *inflictor, gentity_t *attacker, const vec3_t point, int damage, int mod,int hitLoc=HL_NONE);
+extern void NPC_Jedi_Pain				(gentity_t *self, gentity_t *inflictor, gentity_t *attacker, const vec3_t point, int damage, int mod,int hitLoc=HL_NONE);
+extern void NPC_Droid_Pain				(gentity_t *self, gentity_t *inflictor, gentity_t *attacker, const vec3_t point, int damage, int mod,int hitLoc=HL_NONE);
+extern void NPC_Probe_Pain				(gentity_t *self, gentity_t *inflictor, gentity_t *attacker, const vec3_t point, int damage, int mod,int hitLoc=HL_NONE);
+extern void NPC_MineMonster_Pain		(gentity_t *self, gentity_t *inflictor, gentity_t *attacker, const vec3_t point, int damage, int mod,int hitLoc=HL_NONE);
+extern void NPC_Howler_Pain				(gentity_t *self, gentity_t *inflictor, gentity_t *attacker, const vec3_t point, int damage, int mod,int hitLoc=HL_NONE);
+extern void NPC_Rancor_Pain				(gentity_t *self, gentity_t *inflictor, gentity_t *attacker, const vec3_t point, int damage, int mod,int hitLoc=HL_NONE);
+extern void NPC_Wampa_Pain				(gentity_t *self, gentity_t *inflictor, gentity_t *attacker, const vec3_t point, int damage, int mod,int hitLoc=HL_NONE);
+extern void NPC_SandCreature_Pain		(gentity_t *self, gentity_t *inflictor, gentity_t *attacker, const vec3_t point, int damage, int mod,int hitLoc=HL_NONE);
+extern void NPC_Seeker_Pain				(gentity_t *self, gentity_t *inflictor, gentity_t *attacker, const vec3_t point, int damage, int mod,int hitLoc=HL_NONE);
+extern void NPC_Remote_Pain				(gentity_t *self, gentity_t *inflictor, gentity_t *attacker, const vec3_t point, int damage, int mod,int hitLoc=HL_NONE);
+extern void emplaced_gun_pain			(gentity_t *self, gentity_t *inflictor, gentity_t *attacker, const vec3_t point, int damage, int mod,int hitLoc=HL_NONE);
+extern void NPC_Mark1_Pain				(gentity_t *self, gentity_t *inflictor, gentity_t *attacker, const vec3_t point, int damage, int mod,int hitLoc=HL_NONE);
+extern void NPC_Sentry_Pain				(gentity_t *self, gentity_t *inflictor, gentity_t *attacker, const vec3_t point, int damage, int mod,int hitLoc=HL_NONE);
+extern void NPC_Mark2_Pain				(gentity_t *self, gentity_t *inflictor, gentity_t *attacker, const vec3_t point, int damage, int mod,int hitLoc=HL_NONE);
+extern void PlayerPain					(gentity_t *self, gentity_t *inflictor, gentity_t *attacker, const vec3_t point, int damage, int mod,int hitLoc=HL_NONE);
+extern void GasBurst					(gentity_t *self, gentity_t *inflictor, gentity_t *attacker, const vec3_t point, int damage, int mod, int hitLoc=HL_NONE );
+extern void CrystalCratePain			(gentity_t *self, gentity_t *inflictor, gentity_t *attacker, const vec3_t point, int damage, int mod, int hitLoc=HL_NONE);
+extern void TurretPain					(gentity_t *self, gentity_t *inflictor, gentity_t *attacker, const vec3_t point, int damage, int mod, int hitLoc=HL_NONE );
+extern void eweb_pain					(gentity_t *self, gentity_t *inflictor, gentity_t *attacker, const vec3_t point, int damage, int mod,int hitLoc=HL_NONE);
+
+//	void		(*die)(gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int mod);
+typedef enum
+{
+	dieF_NULL = 0,
+	//
+	dieF_funcBBrushDie,
+	dieF_misc_model_breakable_die,
+	dieF_misc_model_cargo_die,
+	dieF_func_train_die,
+	dieF_player_die,
+	dieF_ExplodeDeath_Wait,
+	dieF_ExplodeDeath,
+	dieF_func_usable_die,
+	dieF_turret_die,
+	dieF_funcGlassDie,
+//	dieF_laserTrapDelayedExplode,
+	dieF_emplaced_gun_die,
+	dieF_WP_ExplosiveDie,
+	dieF_ion_cannon_die,
+	dieF_maglock_die,
+	dieF_camera_die,
+	dieF_Mark1_die,
+	dieF_Interrogator_die,
+	dieF_misc_atst_die,
+	dieF_misc_panel_turret_die,
+	dieF_thermal_die,
+	dieF_eweb_die,
+} dieFunc_t;
+
+// DIE functions...
+//
+extern void funcBBrushDie				(gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int mod,int dFlags=0,int hitLoc=HL_NONE);
+extern void misc_model_breakable_die	(gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int mod,int dFlags=0,int hitLoc=HL_NONE);
+extern void misc_model_cargo_die		(gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int mod,int dFlags=0,int hitLoc=HL_NONE);
+extern void func_train_die				(gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int mod,int dFlags=0,int hitLoc=HL_NONE);
+extern void player_die					(gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int mod,int dFlags=0,int hitLoc=HL_NONE);
+extern void ExplodeDeath_Wait			(gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int mod,int dFlags=0,int hitLoc=HL_NONE);
+extern void ExplodeDeath				(gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int mod,int dFlags=0,int hitLoc=HL_NONE);
+extern void func_usable_die				(gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int mod,int dFlags=0,int hitLoc=HL_NONE);
+extern void turret_die					(gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int mod,int dFlags=0,int hitLoc=HL_NONE);
+extern void funcGlassDie				(gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int mod,int dFlags=0,int hitLoc=HL_NONE);
+extern void laserTrapDelayedExplode		(gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int mod,int dFlags=0,int hitLoc=HL_NONE);
+extern void emplaced_gun_die			(gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int mod,int dFlags=0,int hitLoc=HL_NONE);
+extern void WP_ExplosiveDie				(gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int mod,int dFlags=0,int hitLoc=HL_NONE);
+extern void ion_cannon_die				(gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int mod,int dFlags=0,int hitLoc=HL_NONE);
+extern void maglock_die					(gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int mod,int dFlags=0,int hitLoc=HL_NONE);
+extern void camera_die					(gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int mod,int dFlags=0,int hitLoc=HL_NONE);
+extern void Mark1_die					(gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int mod,int dFlags=0,int hitLoc=HL_NONE);
+extern void Interrogator_die			(gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int mod,int dFlags=0,int hitLoc=HL_NONE);
+extern void misc_atst_die				(gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int mod,int dFlags=0,int hitLoc=HL_NONE);
+extern void misc_panel_turret_die		(gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int mod,int dFlags=0,int hitLoc=HL_NONE);
+extern void thermal_die					(gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int mod,int dFlags=0,int hitLoc=HL_NONE);
+extern void eweb_die					(gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int mod,int dFlags=0,int hitLoc=HL_NONE);
+
+void GEntity_ThinkFunc(gentity_t *self);
+void CEntity_ThinkFunc(centity_s *cent);	//Think func for equivalent centity
+void GEntity_ReachedFunc(gentity_t *self);	// movers call this when hitting endpoint
+void GEntity_BlockedFunc(gentity_t *self, gentity_t *other);
+void GEntity_TouchFunc(gentity_t *self, gentity_t *other, trace_t *trace);
+void GEntity_UseFunc(gentity_t *self, gentity_t *other, gentity_t *activator);
+void GEntity_PainFunc(gentity_t *self, gentity_t *inflictor, gentity_t *attacker, const vec3_t point, int damage, int mod,int hitLoc=HL_NONE);
+void GEntity_DieFunc(gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int mod,int dFlags=0,int hitLoc=HL_NONE);
+
+// external functions that I now refer to...
+
+
+#endif	// #ifndef G_FUNCTIONS
+
+/////////////////// eof ///////////////////
+
diff --git a/code/game/g_fx.cpp b/code/game/g_fx.cpp
new file mode 100644
index 0000000..0e2ce36
--- /dev/null
+++ b/code/game/g_fx.cpp
@@ -0,0 +1,1236 @@
+// leave this line at the top for all g_xxxx.cpp files...
+#include "g_headers.h"
+
+
+#include "g_local.h"
+#include "g_functions.h"
+
+extern int	G_FindConfigstringIndex( const char *name, int start, int max, qboolean create );
+
+#define FX_ENT_RADIUS 32
+
+extern int	BMS_START;
+extern int	BMS_MID;
+extern int	BMS_END;
+
+//----------------------------------------------------------
+
+/*QUAKED fx_runner (0 0 1) (-8 -8 -8) (8 8 8) STARTOFF ONESHOT DAMAGE
+Runs the specified effect, can also be targeted at an info_notnull to orient the effect
+
+	STARTOFF - effect starts off, toggles on/off when used
+	ONESHOT - effect fires only when used
+	DAMAGE - does radius damage around effect every "delay" milliseonds
+
+	"fxFile" - name of the effect file to play
+	"target" - direction to aim the effect in, otherwise defaults to up
+	"target2" - uses its target2 when the fx gets triggered
+	"delay"  - how often to call the effect, don't over-do this ( default 200 )
+	"random" - random amount of time to add to delay, ( default 0, 200 = 0ms to 200ms )
+	"splashRadius" - only works when damage is checked ( default 16 )
+	"splashDamage" - only works when damage is checked ( default 5 )
+	"soundset"	- bmodel set to use, plays start sound when toggled on, loop sound while on ( doesn't play on a oneshot), and a stop sound when turned off
+*/
+#define FX_RUNNER_RESERVED 0x800000
+
+//----------------------------------------------------------
+void fx_runner_think( gentity_t *ent )
+{
+	vec3_t temp;
+
+	EvaluateTrajectory( &ent->s.pos, level.time, ent->currentOrigin );
+	EvaluateTrajectory( &ent->s.apos, level.time, ent->currentAngles );
+
+	// call the effect with the desired position and orientation
+	G_AddEvent( ent, EV_PLAY_EFFECT, ent->fxID );
+
+	// Assume angles, we'll do a cross product on the other end to finish up
+	AngleVectors( ent->currentAngles, ent->pos3, NULL, NULL );
+	MakeNormalVectors( ent->pos3, ent->pos4, temp ); // there IS a reason this is done...it's so that it doesn't break every effect in the game...
+
+	ent->nextthink = level.time + ent->delay + random() * ent->random;
+
+	if ( ent->spawnflags & 4 ) // damage
+	{
+		G_RadiusDamage( ent->currentOrigin, ent, ent->splashDamage, ent->splashRadius, ent, MOD_UNKNOWN );
+	}
+
+	if ( ent->target2 )
+	{
+		// let our target know that we have spawned an effect
+		G_UseTargets2( ent, ent, ent->target2 );
+	}
+
+	if ( !(ent->spawnflags & 2 ) && !ent->s.loopSound ) // NOT ONESHOT...this is an assy thing to do
+	{
+		if ( VALIDSTRING( ent->soundSet ) == true )
+		{
+			ent->s.loopSound = CAS_GetBModelSound( ent->soundSet, BMS_MID );
+
+			if ( ent->s.loopSound < 0 )
+			{
+				ent->s.loopSound = 0;
+			}
+		}
+	}
+
+}
+
+//----------------------------------------------------------
+void fx_runner_use( gentity_t *self, gentity_t *other, gentity_t *activator )
+{
+	if (self->s.isPortalEnt)
+	{ //rww - mark it as broadcast upon first use if it's within the area of a skyportal
+		self->svFlags |= SVF_BROADCAST;
+	}
+
+	if ( self->spawnflags & 2 ) // ONESHOT
+	{
+		// call the effect with the desired position and orientation, as a safety thing,
+		//	make sure we aren't thinking at all.
+		fx_runner_think( self );
+		self->nextthink = -1;
+
+		if ( self->target2 )
+		{
+			// let our target know that we have spawned an effect
+			G_UseTargets2( self, self, self->target2 );
+		}
+
+		if ( VALIDSTRING( self->soundSet ) == true )
+		{
+			G_AddEvent( self, EV_BMODEL_SOUND, CAS_GetBModelSound( self->soundSet, BMS_START ));
+		}
+	}
+	else
+	{
+		// ensure we are working with the right think function
+		self->e_ThinkFunc = thinkF_fx_runner_think;
+
+		// toggle our state
+		if ( self->nextthink == -1 )
+		{
+			// NOTE: we fire the effect immediately on use, the fx_runner_think func will set
+			//	up the nextthink time.
+			fx_runner_think( self );
+
+			if ( VALIDSTRING( self->soundSet ) == true )
+			{
+				G_AddEvent( self, EV_BMODEL_SOUND, CAS_GetBModelSound( self->soundSet, BMS_START ));
+				self->s.loopSound = CAS_GetBModelSound( self->soundSet, BMS_MID );
+
+				if ( self->s.loopSound < 0 )
+				{
+					self->s.loopSound = 0;
+				}
+			}
+		}
+		else
+		{
+			// turn off for now
+			self->nextthink = -1;
+
+			if ( VALIDSTRING( self->soundSet ) == true )
+			{
+				G_AddEvent( self, EV_BMODEL_SOUND, CAS_GetBModelSound( self->soundSet, BMS_END ));
+				self->s.loopSound = 0;
+			}
+		}
+	}
+}
+
+//----------------------------------------------------------
+void fx_runner_link( gentity_t *ent )
+{
+	vec3_t	dir;
+
+	if ( ent->target )
+	{
+		// try to use the target to override the orientation
+		gentity_t	*target = NULL;
+
+		target = G_Find( target, FOFS(targetname), ent->target );
+
+		if ( !target )
+		{
+			// Bah, no good, dump a warning, but continue on and use the UP vector
+			Com_Printf( "fx_runner_link: target specified but not found: %s\n", ent->target );
+			Com_Printf( "  -assuming UP orientation.\n" );
+		}
+		else
+		{
+			// Our target is valid so let's override the default UP vector
+			VectorSubtract( target->s.origin, ent->s.origin, dir );
+			VectorNormalize( dir );
+			vectoangles( dir, ent->s.angles );
+		}
+	}
+
+	// don't really do anything with this right now other than do a check to warn the designers if the target2 is bogus
+	if ( ent->target2 )
+	{
+		gentity_t	*target = NULL;
+
+		target = G_Find( target, FOFS(targetname), ent->target2 );
+
+		if ( !target )
+		{
+			// Target2 is bogus, but we can still continue
+			Com_Printf( "fx_runner_link: target2 was specified but is not valid: %s\n", ent->target2 );
+		}
+	}
+
+	G_SetAngles( ent, ent->s.angles );
+
+	if ( ent->spawnflags & 1 || ent->spawnflags & 2 ) // STARTOFF || ONESHOT
+	{
+		// We won't even consider thinking until we are used
+		ent->nextthink = -1;
+	}
+	else
+	{
+		if ( VALIDSTRING( ent->soundSet ) == true )
+		{
+			ent->s.loopSound = CAS_GetBModelSound( ent->soundSet, BMS_MID );
+
+			if ( ent->s.loopSound < 0 )
+			{
+				ent->s.loopSound = 0;
+			}
+		}
+
+		// Let's get to work right now!
+		ent->e_ThinkFunc = thinkF_fx_runner_think;
+		ent->nextthink = level.time + 200; // wait a small bit, then start working
+	}
+
+	// make us useable if we can be targeted
+	if ( ent->targetname )
+	{
+		ent->e_UseFunc = useF_fx_runner_use;
+	}
+}
+
+//----------------------------------------------------------
+void SP_fx_runner( gentity_t *ent )
+{
+	// Get our defaults
+	G_SpawnInt( "delay", "200", &ent->delay );
+	G_SpawnFloat( "random", "0", &ent->random );
+	G_SpawnInt( "splashRadius", "16", &ent->splashRadius );
+	G_SpawnInt( "splashDamage", "5", &ent->splashDamage );
+
+	if ( !G_SpawnAngleHack( "angle", "0", ent->s.angles ))
+	{
+		// didn't have angles, so give us the default of up
+		VectorSet( ent->s.angles, -90, 0, 0 );
+	}
+
+	if ( !ent->fxFile )
+	{
+		gi.Printf( S_COLOR_RED"ERROR: fx_runner %s at %s has no fxFile specified\n", ent->targetname, vtos(ent->s.origin) );
+		G_FreeEntity( ent );
+		return;
+	}
+
+	// Try and associate an effect file, unfortunately we won't know if this worked or not 
+	//	until the CGAME trys to register it...
+	ent->fxID = G_EffectIndex( ent->fxFile );
+
+	ent->s.eType = ET_MOVER;
+
+	// Give us a bit of time to spawn in the other entities, since we may have to target one of 'em
+	ent->e_ThinkFunc = thinkF_fx_runner_link; 
+	ent->nextthink = level.time + 400;
+
+	// Save our position and link us up!
+	G_SetOrigin( ent, ent->s.origin );
+
+	VectorSet( ent->maxs, FX_ENT_RADIUS, FX_ENT_RADIUS, FX_ENT_RADIUS );
+	VectorScale( ent->maxs, -1, ent->mins );
+
+	gi.linkentity( ent );
+}
+
+
+/*QUAKED fx_snow (1 0 0) (-16 -16 -16) (16 16 16) LIGHT MEDIUM HEAVY MISTY_FOG
+This world effect will spawn snow globally into the level.
+*/
+void SP_CreateSnow( gentity_t *ent )
+{ 
+	cvar_t *r_weatherScale = gi.cvar( "r_weatherScale", "1", CVAR_ARCHIVE );
+	if ( r_weatherScale->value == 0.0f )
+	{
+		return;
+	}
+
+
+	// Different Types Of Rain
+	//-------------------------
+	if (ent->spawnflags & 1)
+	{
+		G_FindConfigstringIndex("lightsnow", CS_WORLD_FX, MAX_WORLD_FX, qtrue);
+	}
+	else if (ent->spawnflags & 2)
+	{
+		G_FindConfigstringIndex("snow", CS_WORLD_FX, MAX_WORLD_FX, qtrue);
+	}
+	else if (ent->spawnflags & 4)
+	{
+		G_FindConfigstringIndex("heavysnow", CS_WORLD_FX, MAX_WORLD_FX, qtrue);
+	}
+	else
+	{
+		G_FindConfigstringIndex("snow", CS_WORLD_FX, MAX_WORLD_FX, qtrue);
+		G_FindConfigstringIndex("fog", CS_WORLD_FX, MAX_WORLD_FX, qtrue);
+	}
+
+
+	// MISTY FOG
+	//===========
+	if (ent->spawnflags & 8)
+	{
+		G_FindConfigstringIndex("fog", CS_WORLD_FX, MAX_WORLD_FX, qtrue);
+	}
+}
+
+/*QUAKED fx_wind (0 .5 .8) (-16 -16 -16) (16 16 16) NORMAL CONSTANT GUSTING SWIRLING x  FOG LIGHT_FOG
+Generates global wind forces
+
+NORMAL    creates a random light global wind
+CONSTANT  forces all wind to go in a specified direction
+GUSTING   causes random gusts of wind
+SWIRLING  causes random swirls of wind
+
+"angles" the direction for constant wind
+"speed"  the speed for constant wind
+*/
+void SP_CreateWind( gentity_t *ent )
+{
+	cvar_t *r_weatherScale = gi.cvar( "r_weatherScale", "1", CVAR_ARCHIVE );
+	if ( r_weatherScale->value <= 0.0f )
+	{
+		return;
+	}
+
+	char	temp[256];
+
+	// Normal Wind
+	//-------------
+	if (ent->spawnflags & 1)
+	{
+		G_FindConfigstringIndex("wind", CS_WORLD_FX, MAX_WORLD_FX, qtrue);
+	}
+
+	// Constant Wind
+	//---------------
+	if (ent->spawnflags & 2)
+	{
+		vec3_t	windDir;
+		AngleVectors(ent->s.angles, windDir, 0, 0);
+		G_SpawnFloat( "speed", "500", &ent->speed );
+		VectorScale(windDir, ent->speed, windDir);
+
+		sprintf( temp, "constantwind ( %f %f %f )", windDir[0], windDir[1], windDir[2] );
+		G_FindConfigstringIndex(temp, CS_WORLD_FX, MAX_WORLD_FX, qtrue);
+	}
+
+	// Gusting Wind
+	//--------------
+	if (ent->spawnflags & 4)
+	{
+		G_FindConfigstringIndex("gustingwind", CS_WORLD_FX, MAX_WORLD_FX, qtrue);
+	}
+
+	// Swirling Wind
+	//---------------
+	if (ent->spawnflags & 8)
+	{
+		G_FindConfigstringIndex("swirlingwind", CS_WORLD_FX, MAX_WORLD_FX, qtrue);
+	}
+
+
+	// MISTY FOG
+	//===========
+	if (ent->spawnflags & 32)
+	{
+		G_FindConfigstringIndex("fog", CS_WORLD_FX, MAX_WORLD_FX, qtrue);
+	}
+
+	// MISTY FOG
+	//===========
+	if (ent->spawnflags & 64)
+	{
+		G_FindConfigstringIndex("light_fog", CS_WORLD_FX, MAX_WORLD_FX, qtrue);
+	}
+}
+
+/*QUAKED fx_wind_zone (0 .5 .8) ?  Creates a constant wind in a local area
+Generates local wind forces
+
+"angles" the direction for constant wind
+"speed"  the speed for constant wind
+*/
+void SP_CreateWindZone( gentity_t *ent )
+{
+	cvar_t *r_weatherScale = gi.cvar( "r_weatherScale", "1", CVAR_ARCHIVE );
+	if ( r_weatherScale->value <= 0.0f )
+	{
+		return;
+	}
+
+	gi.SetBrushModel(ent, ent->model);
+
+	vec3_t	windDir;
+ 	AngleVectors(ent->s.angles, windDir, 0, 0);
+	G_SpawnFloat( "speed", "500", &ent->speed );
+	VectorScale(windDir, ent->speed, windDir);
+
+	char	temp[256];
+	sprintf( temp, "windzone ( %f %f %f ) ( %f %f %f ) ( %f %f %f )", 
+		ent->mins[0], ent->mins[1], ent->mins[2],
+		ent->maxs[0], ent->maxs[1], ent->maxs[2],
+		windDir[0],	  windDir[1],   windDir[2]
+		);
+	G_FindConfigstringIndex(temp, CS_WORLD_FX, MAX_WORLD_FX, qtrue);
+}
+
+
+
+/*QUAKED fx_rain (1 0 0) (-16 -16 -16) (16 16 16) LIGHT MEDIUM HEAVY ACID OUTSIDE_SHAKE MISTY_FOG
+This world effect will spawn rain globally into the level.
+
+LIGHT   create light drizzle
+MEDIUM  create average medium rain
+HEAVY   create heavy downpour (with fog and lightning automatically)
+ACID    create acid rain
+
+OUTSIDE_SHAKE  will cause the camera to shake slightly whenever outside
+MISTY_FOG      causes clouds of misty fog to float through the level
+LIGHTNING      causes random bursts of lightning and thunder in the level
+
+The following fields are for lightning:
+"flashcolor"    "200 200 200" (r g b) (values 0.0-255.0)
+"flashdelay"    "12000" maximum time delay between lightning strikes
+"chanceflicker" "2"  1 in 2 chance of flickering fog
+"chancesound"   "3"  1 in 3 chance of playing a sound
+"chanceeffect"  "4"  1 in 4 chance of playing the effect
+*/
+//----------------------------------------------------------
+
+//----------------------------------------------------------
+extern void G_SoundAtSpot( vec3_t org, int soundIndex, qboolean broadcast );
+
+void fx_rain_think( gentity_t *ent )
+{
+	if (player)
+	{
+ 		if (ent->count!=0)
+		{
+			ent->count--;
+			if (ent->count==0 || (ent->count%2)==0)
+			{
+				gi.WE_SetTempGlobalFogColor(ent->pos2);		// Turn Off
+				if (ent->count==0)
+				{
+					ent->nextthink = level.time + Q_irand(1000, 12000);
+				}
+				else if (ent->count==2)
+				{
+					ent->nextthink = level.time + Q_irand(150, 450);
+				}
+				else
+				{
+					ent->nextthink = level.time + Q_irand(50, 150);
+				}
+			}
+			else
+			{
+				gi.WE_SetTempGlobalFogColor(ent->pos3);		// Turn On
+				ent->nextthink = level.time + 50;
+			}
+		}
+		else if (gi.WE_IsOutside(player->currentOrigin))
+		{
+			vec3_t	effectPos;
+			vec3_t	effectDir;
+			VectorClear(effectDir);
+		 	effectDir[0] += Q_flrand(-1.0f, 1.0f);
+			effectDir[1] += Q_flrand(-1.0f, 1.0f);
+
+			bool	PlayEffect	= Q_irand(1,ent->aimDebounceTime)==1;
+			bool	PlayFlicker = Q_irand(1,ent->attackDebounceTime)==1;
+			bool	PlaySound	= (PlayEffect || PlayFlicker || Q_irand(1,ent->pushDebounceTime)==1);
+
+			// Play The Sound
+			//----------------
+			if (PlaySound && !PlayEffect)
+			{
+				VectorMA(player->currentOrigin, 250.0f, effectDir, effectPos);
+				G_SoundAtSpot(effectPos, G_SoundIndex(va("sound/ambience/thunder%d", Q_irand(1,4))), qtrue);
+			}
+
+			// Play The Effect
+			//-----------------
+ 			if (PlayEffect)
+			{ 
+  			 	VectorMA(player->currentOrigin, 400.0f, effectDir, effectPos);
+				if (PlaySound) 
+				{
+					G_Sound(player, G_SoundIndex(va("sound/ambience/thunder_close%d", Q_irand(1,2))));
+				}
+
+				// Raise It Up Into The Sky
+				//--------------------------
+				effectPos[2] += Q_flrand(600.0f, 1000.0f);
+
+				VectorClear(effectDir);
+				effectDir[2]  = -1.0f;
+
+				G_PlayEffect("env/huge_lightning", effectPos, effectDir);
+				ent->nextthink = level.time + Q_irand(100, 200);
+			}
+
+			// Change The Fog Color
+			//----------------------
+			if (PlayFlicker)
+			{
+				ent->count = (Q_irand(1,4) * 2);
+				ent->nextthink = level.time + 50;
+				gi.WE_SetTempGlobalFogColor(ent->pos3);
+			}
+			else
+			{
+				ent->nextthink = level.time + Q_irand(1000, ent->delay);
+			}
+		}
+		else
+		{
+			ent->nextthink = level.time + Q_irand(1000, ent->delay);
+		}
+	}
+	else
+	{
+		ent->nextthink = level.time + Q_irand(1000, ent->delay);
+	}
+}
+
+void SP_CreateRain( gentity_t *ent )
+{ 
+	// Different Types Of Rain
+	//-------------------------
+	if (ent->spawnflags & 1)
+	{
+		G_FindConfigstringIndex("lightrain", CS_WORLD_FX, MAX_WORLD_FX, qtrue);
+	}
+	else if (ent->spawnflags & 2)
+	{
+		G_FindConfigstringIndex("rain", CS_WORLD_FX, MAX_WORLD_FX, qtrue);
+	}
+	else if (ent->spawnflags & 4)
+	{
+		G_FindConfigstringIndex("heavyrain", CS_WORLD_FX, MAX_WORLD_FX, qtrue);
+
+		// Automatically Get Heavy Fog
+		//-----------------------------
+		G_FindConfigstringIndex("heavyrainfog", CS_WORLD_FX, MAX_WORLD_FX, qtrue );
+
+		// Automatically Get Lightning & Thunder
+		//---------------------------------------
+		ent->spawnflags |= 64;
+	}
+	else if (ent->spawnflags & 8)
+	{
+		G_EffectIndex( "world/acid_fizz" );
+		G_FindConfigstringIndex("acidrain", CS_WORLD_FX, MAX_WORLD_FX, qtrue);
+	}
+
+
+	// OUTSIDE SHAKE
+	//===============
+	if (ent->spawnflags & 16)
+	{
+		G_FindConfigstringIndex("outsideShake", CS_WORLD_FX, MAX_WORLD_FX, qtrue);
+	}
+
+	// MISTY FOG
+	//===========
+	if (ent->spawnflags & 32)
+	{
+		G_FindConfigstringIndex("fog", CS_WORLD_FX, MAX_WORLD_FX, qtrue );
+	}
+
+	// LIGHTNING
+	//===========
+	if (ent->spawnflags & 64)
+	{
+		G_SoundIndex("sound/ambience/thunder1");
+		G_SoundIndex("sound/ambience/thunder2");
+		G_SoundIndex("sound/ambience/thunder3");
+		G_SoundIndex("sound/ambience/thunder4");
+		G_SoundIndex("sound/ambience/thunder_close1");
+		G_SoundIndex("sound/ambience/thunder_close2");
+		G_EffectIndex( "env/huge_lightning" );
+		ent->e_ThinkFunc = thinkF_fx_rain_think;
+		ent->nextthink = level.time + Q_irand(4000, 8000);
+		
+		if (!G_SpawnVector( "flashcolor", "200 200 200", ent->pos3))
+		{
+			VectorSet(ent->pos3, 200, 200, 200);
+		}
+		VectorClear(ent->pos2);		// the "off" color
+
+		G_SpawnInt("flashdelay",    "12000",	&ent->delay);
+		G_SpawnInt("chanceflicker", "2",		&ent->attackDebounceTime);
+		G_SpawnInt("chancesound",   "3",		&ent->pushDebounceTime);
+		G_SpawnInt("chanceeffect",  "4",		&ent->aimDebounceTime);
+	}
+}
+
+// Added by Aurelio Reis on 10/20/02.
+/*QUAKED fx_puff (1 0 0) (-16 -16 -16) (16 16 16)
+This world effect will spawn a puff system globally into the level.
+Enter any valid puff command as a key and value to setup the puff
+system properties.
+
+"count"			The number of puffs/particles (default of 1000).
+
+"whichsystem"	Which puff system to use (currently 0 and 1. Default 0).
+
+// Apply a default puff system.
+default  <value>
+Current defaults are "snowstorm", "sandstorm", "foggy", and "smokey"
+
+// Set the color of the particles (0-1.0).
+color  ( <red>, <green>, <blue> )
+default ( 0.5, 0.5, 0.5 )
+
+// Set the alpha (transparency) value for the particles (0-1.0).
+alpha  <value>
+default 0.5
+
+// Set which texture to use for the particles (make sure to include full path).
+texture  <textures/texture.tga>
+default gfx/effects/alpha_smoke2b.tga
+
+// Set the size of particles (from center, like a radius) (MIN 4, MAX 2048).
+size  <value>
+default 100
+
+// Whether the saber should flicker and spark or not (0 false, 1 true).
+sabersparks   <value>
+default 0
+
+// Set texture filtering mode (0 = Bilinear(default), 1 = Nearest(less quality).
+filtermode  <value>
+default 0
+
+// Set the alpha blending mode (0 = src, src-1, 1 = one, one (additive)).
+blendmode  <value>
+default 0
+
+// How much to rotate particles per second (in degree's). 
+rotate ( <min>, <max> )
+default ( 0, 0 )
+
+// Set the area around the player the puffs cover:
+spread ( minX minY minZ ) ( maxX maxY maxZ )			
+default: ( -600 -600 -500 ) ( 600 600 550 )
+
+// Set the random range that sets the speed the puffs fall:
+velocity ( minX minY minZ ) ( maxX maxY maxZ )			
+default: ( -15 -15 -20 ) ( 15 15 -70 )
+
+// Set an area of puff blowing:
+wind ( windOriginX windOriginY windOriginZ ) ( windVelocityX windVelocityY windVelocityZ ) ( sizeX sizeY sizeZ  )
+
+// Set puff blowing data:
+blowing duration <int>
+blowing low <int>
+		default: 3
+blowing velocity ( min max )
+		default: ( 30 70 )
+blowing size ( minX minY minZ )
+		default: ( 1000 300 300 )
+*/
+//----------------------------------------------------------
+void SP_CreatePuffSystem( gentity_t *ent )
+{ 
+	char	temp[128];
+
+	// Initialize the puff system to either 1000 particles or whatever they choose.
+	G_SpawnInt( "count", "1000", &ent->count );
+	cvar_t *r_weatherScale = gi.cvar( "r_weatherScale", "1", CVAR_ARCHIVE );
+
+	// See which puff system to use.
+	int iPuffSystem = 0;
+	int iVal = 0;
+	if ( G_SpawnInt( "whichsystem", "0", &iVal ) )
+	{
+		iPuffSystem = iVal;
+		if ( iPuffSystem < 0 || iPuffSystem > 1 )
+		{
+			iPuffSystem = 0;
+			//ri.Error( ERR_DROP, "Weather Effect: Invalid value for whichsystem key" );
+			Com_Printf( "Weather Effect: Invalid value for whichsystem key\n" );
+		}
+	}
+
+	if ( r_weatherScale->value > 0.0f )
+	{
+		sprintf( temp, "puff%i init %i", iPuffSystem, (int)( ent->count * r_weatherScale->value ));
+
+		G_FindConfigstringIndex( temp, CS_WORLD_FX, MAX_WORLD_FX, qtrue );
+
+		// Should return here??? It didn't originally...
+	}
+
+	// See whether we should have the saber spark from the puff system.
+	iVal = 0;
+	G_SpawnInt( "sabersparks", "0", &iVal );
+	if ( iVal == 1 )
+		level.worldFlags |= WF_PUFFING;
+	else
+		level.worldFlags &= ~WF_PUFFING;
+
+	// Go through all the fields and assign the values to the created puff system now.
+	for ( int i = 0; i < 20; i++ )
+	{
+		char *key = NULL;
+		char *value = NULL;
+		// Fetch a field.
+		if ( !G_SpawnField( i, &key, &value ) )
+			continue;
+
+		// Make sure we don't get key's that are worthless.
+		if ( Q_stricmp( key, "origin" ) == 0 || Q_stricmp( key, "classname" ) == 0 ||
+			 Q_stricmp( key, "count" ) == 0 || Q_stricmp( key, "targetname" ) == 0  ||
+			 Q_stricmp( key, "sabersparks" ) == 0 || Q_stricmp( key, "whichsystem" ) == 0 )
+			continue;
+
+		// Send the command.
+		_snprintf( temp, 128, "puff%i %s %s", iPuffSystem, key, value );
+		G_FindConfigstringIndex( temp, CS_WORLD_FX, MAX_WORLD_FX, qtrue );
+ 	}
+}
+
+// Don't use this! Too powerful! - Aurelio
+/*NOTEINUSE! fx_command (1 0 0) (-16 -16 -16) (16 16 16)
+//This effect allows you to issue console commands from within the world editor.
+//Use the variables c00 to c99 to issue a maximum of 100 console commands.
+
+//example: c00 r_showtris 1
+
+*/
+//----------------------------------------------------------
+/*void SP_Command( gentity_t *ent )
+{ 
+	char *strCommand;
+
+	// Go through all the commands.
+	for ( int i = 0; i < 100; i++ )
+	{
+		strCommand = NULL;
+
+		// Fetch a command.
+		G_SpawnString( va("c%02d", i), NULL, &strCommand );
+
+		// If it's valid, issue it.
+		if ( strCommand && strCommand[0] )
+		{
+			gi.SendConsoleCommand( strCommand );
+		}
+	}
+}*/
+
+//-----------------
+// Explosion Trail
+//-----------------
+
+//----------------------------------------------------------
+void fx_explosion_trail_think( gentity_t *ent )
+{
+	vec3_t	origin;
+	trace_t	tr;
+
+	if ( ent->spawnflags & 1 ) // gravity
+	{
+		ent->s.pos.trType = TR_GRAVITY;
+	}
+	else
+	{
+		ent->s.pos.trType = TR_LINEAR;
+	}
+
+	EvaluateTrajectory( &ent->s.pos, level.time, origin );
+
+	gi.trace( &tr, ent->currentOrigin, vec3_origin, vec3_origin, origin, 
+				ent->owner ? ent->owner->s.number : ENTITYNUM_NONE, ent->clipmask, G2_RETURNONHIT, 10 );
+
+	if ( tr.fraction < 1.0f ) 
+	{
+		// never explode or bounce on sky
+		if ( !( tr.surfaceFlags & SURF_NOIMPACT ))
+		{
+			if ( ent->splashDamage && ent->splashRadius )
+			{
+				G_RadiusDamage( tr.endpos, ent, ent->splashDamage, ent->splashRadius, ent, MOD_EXPLOSIVE_SPLASH );
+			}
+		}
+
+		if ( ent->cameraGroup )
+		{
+			// fxFile2....in other words, impact fx
+			G_PlayEffect( ent->cameraGroup, tr.endpos, tr.plane.normal );
+		}
+
+		if ( VALIDSTRING( ent->soundSet ) == true )
+		{
+			G_AddEvent( ent, EV_BMODEL_SOUND, CAS_GetBModelSound( ent->soundSet, BMS_END ));
+		}
+
+		G_FreeEntity( ent );
+		return;
+	}
+
+	G_RadiusDamage( origin, ent, ent->damage, ent->radius, ent, MOD_EXPLOSIVE_SPLASH );
+
+	// call the effect with the desired position and orientation
+	G_PlayEffect( ent->fxID, origin, ent->currentAngles );
+
+	ent->nextthink = level.time + 50;
+	gi.linkentity( ent );
+}
+
+//----------------------------------------------------------
+void fx_explosion_trail_use( gentity_t *self, gentity_t *other, gentity_t *activator )
+{
+	gentity_t *missile = G_Spawn();
+
+	// We aren't a missile in the truest sense, rather we just move through the world and spawn effects
+	if ( missile )
+	{
+		missile->classname = "fx_exp_trail";
+
+		missile->nextthink = level.time + 50;
+		missile->e_ThinkFunc = thinkF_fx_explosion_trail_think;
+
+		missile->s.eType = ET_MOVER;
+
+		missile->owner = self;
+
+		missile->s.modelindex = self->s.modelindex2;
+
+		missile->s.pos.trTime = level.time;
+		G_SetOrigin( missile, self->currentOrigin );
+		if ( self->spawnflags & 1 ) // gravity
+		{
+			missile->s.pos.trType = TR_GRAVITY;
+		}
+		else
+		{
+			missile->s.pos.trType = TR_LINEAR;
+		}
+
+		missile->spawnflags = self->spawnflags;
+
+		G_SetAngles( missile, self->currentAngles );
+		VectorScale( self->currentAngles, self->speed, missile->s.pos.trDelta );
+		missile->s.pos.trTime = level.time;
+		missile->radius = self->radius;
+		missile->damage = self->damage;
+		missile->splashDamage = self->splashDamage;
+		missile->splashRadius = self->splashRadius;
+		missile->fxID = self->fxID;
+		missile->cameraGroup = self->cameraGroup;	//fxfile2
+
+		missile->clipmask = MASK_SHOT;
+
+		gi.linkentity( missile );
+
+		if ( VALIDSTRING( self->soundSet ) == true )
+		{
+			G_AddEvent( self, EV_BMODEL_SOUND, CAS_GetBModelSound( self->soundSet, BMS_START ));
+			missile->s.loopSound = CAS_GetBModelSound( self->soundSet, BMS_MID );
+			missile->soundSet = G_NewString(self->soundSet);//get my own copy so i can free it when i die
+
+			if ( missile->s.loopSound < 0 )
+			{
+				missile->s.loopSound = 0;
+			}
+		}
+	}
+}
+
+//----------------------------------------------------------
+void fx_explosion_trail_link( gentity_t *ent )
+{
+	vec3_t		dir;
+	gentity_t	*target = NULL;
+
+	// we ony activate when used
+	ent->e_UseFunc = useF_fx_explosion_trail_use;
+
+	if ( ent->target )
+	{
+		// try to use the target to override the orientation
+		target = G_Find( target, FOFS(targetname), ent->target );
+
+		if ( !target )
+		{
+			gi.Printf( S_COLOR_RED"ERROR: fx_explosion_trail %s could not find target %s\n", ent->targetname, ent->target );
+			G_FreeEntity( ent );
+			return;
+		}
+
+		// Our target is valid so lets use that
+		VectorSubtract( target->s.origin, ent->s.origin, dir );
+		VectorNormalize( dir );
+	}
+	else 
+	{
+		// we are assuming that we have angles, but there are no checks to verify this
+		AngleVectors( ent->s.angles, dir, NULL, NULL );
+	}
+
+	// NOTE: this really isn't an angle, but rather an orientation vector
+	G_SetAngles( ent, dir );
+}
+
+/*QUAKED fx_explosion_trail (0 0 1) (-8 -8 -8) (8 8 8) GRAVITY
+Creates an explosion type trail using the specified effect file, damaging things as it moves through the environment
+Can also be used for something like a meteor, just add an impact effect ( fxFile2 ) and a splashDamage and splashRadius
+
+  GRAVITY - object uses gravity instead of linear motion
+
+  "fxFile" - name of the effect to play for the trail ( default "env/exp_trail_comp" )
+  "fxFile2" - effect file to play on impact
+
+  "model" - model to attach to the trail
+
+  "target" - direction to aim the trail in, required unless you specify angles
+  "targetname" - (required) trail effect spawns only when used.
+  "speed" - velocity through the world, ( default 350 )
+
+  "radius" - damage radius around trail as it travels through the world ( default 128 )
+  "damage" - radius damage ( default 128 )
+  "splashDamage" - damage when thing impacts ( default 0 )
+  "splashRadius" - damage radius on impact ( default 0 )
+  "soundset" - soundset to use, start sound plays when explosion trail starts, loop sound plays on explosion trail, end sound plays when it impacts
+
+*/
+//----------------------------------------------------------
+void SP_fx_explosion_trail( gentity_t *ent )
+{
+	// We have to be useable, otherwise we won't spawn in
+	if ( !ent->targetname )
+	{
+		gi.Printf( S_COLOR_RED"ERROR: fx_explosion_trail at %s has no targetname specified\n", vtos( ent->s.origin ));
+		G_FreeEntity( ent );
+		return;
+	}
+
+	// Get our defaults
+	G_SpawnString( "fxFile", "env/exp_trail_comp", &ent->fxFile );
+	G_SpawnInt( "damage", "128", &ent->damage );
+	G_SpawnFloat( "radius", "128", &ent->radius );
+	G_SpawnFloat( "speed", "350", &ent->speed );
+
+	// Try to associate an effect file, unfortunately we won't know if this worked or not until the CGAME trys to register it...
+	ent->fxID = G_EffectIndex( ent->fxFile );
+
+	if ( ent->cameraGroup )
+	{
+		G_EffectIndex( ent->cameraGroup );
+	}
+
+	if ( ent->model )
+	{
+		ent->s.modelindex2 = G_ModelIndex( ent->model );
+	}
+
+	// Give us a bit of time to spawn in the other entities, since we may have to target one of 'em
+	ent->e_ThinkFunc = thinkF_fx_explosion_trail_link; 
+	ent->nextthink = level.time + 500;
+
+	// Save our position and link us up!
+	G_SetOrigin( ent, ent->s.origin );
+
+	VectorSet( ent->maxs, FX_ENT_RADIUS, FX_ENT_RADIUS, FX_ENT_RADIUS );
+	VectorScale( ent->maxs, -1, ent->mins );
+
+	gi.linkentity( ent );
+}
+
+
+//
+//
+
+//------------------------------------------
+void fx_target_beam_set_debounce( gentity_t *self )
+{
+	if ( self->wait >= FRAMETIME )
+	{
+		self->attackDebounceTime = level.time + self->wait + Q_irand( -self->random, self->random );
+	}
+	else if ( self->wait < 0 )
+	{
+		self->e_UseFunc = useF_NULL;
+	}
+	else 
+	{
+		self->attackDebounceTime = level.time + FRAMETIME + Q_irand( -self->random, self->random );
+	}
+}
+
+//------------------------------------------
+void fx_target_beam_fire( gentity_t *ent )
+{
+	trace_t		trace;
+	vec3_t		dir, org, end;
+	int			ignore;
+	qboolean	open;
+
+	if ( !ent->enemy || !ent->enemy->inuse )
+	{//info_null most likely
+		ignore = ent->s.number;
+		ent->enemy = NULL;
+		VectorCopy( ent->s.origin2, org );
+	}
+	else
+	{
+		ignore = ent->enemy->s.number;
+		VectorCopy( ent->enemy->currentOrigin, org );
+	}
+
+	VectorCopy( org, ent->s.origin2 );
+	VectorSubtract( org, ent->s.origin, dir );
+	VectorNormalize( dir );
+
+	gi.trace( &trace, ent->s.origin, NULL, NULL, org, ENTITYNUM_NONE, MASK_SHOT );//ignore
+	if ( ent->spawnflags & 2 )
+	{
+		open = qtrue;
+		VectorCopy( org, end );
+	}
+	else
+	{
+		open = qfalse;
+		VectorCopy( trace.endpos, end );
+	}
+
+	if ( trace.fraction < 1.0 )
+	{
+		if ( trace.entityNum < ENTITYNUM_WORLD )
+		{
+			gentity_t *victim = &g_entities[trace.entityNum];
+			if ( victim && victim->takedamage )
+			{
+				if ( ent->spawnflags & 4 ) // NO_KNOCKBACK
+				{
+					G_Damage( victim, ent, ent->activator, dir, trace.endpos, ent->damage, DAMAGE_NO_KNOCKBACK, MOD_UNKNOWN );
+				}
+				else
+				{
+					G_Damage( victim, ent, ent->activator, dir, trace.endpos, ent->damage, 0, MOD_UNKNOWN );
+				}
+			}
+		}
+	}
+
+	G_AddEvent( ent, EV_TARGET_BEAM_DRAW, ent->fxID );
+	VectorCopy( end, ent->s.origin2 );
+
+	if ( open )
+	{
+		VectorScale( dir, -1, ent->pos1 );
+	}
+	else
+	{
+		VectorCopy( trace.plane.normal, ent->pos1 );
+	}
+
+	ent->e_ThinkFunc = thinkF_fx_target_beam_think;
+	ent->nextthink = level.time + FRAMETIME;
+}
+
+//------------------------------------------
+void fx_target_beam_fire_start( gentity_t *self )
+{
+	fx_target_beam_set_debounce( self );
+	self->e_ThinkFunc		= thinkF_fx_target_beam_think;
+	self->nextthink			= level.time + FRAMETIME;
+	self->painDebounceTime	= level.time + self->speed + Q_irand( -500, 500 );
+	fx_target_beam_fire( self );
+}
+
+//------------------------------------------
+void fx_target_beam_use( gentity_t *self, gentity_t *other, gentity_t *activator )
+{
+	if ( self->spawnflags & 8 ) // one shot
+	{
+		fx_target_beam_fire( self );
+		self->e_ThinkFunc	= thinkF_NULL;
+	}
+	else if ( self->e_ThinkFunc == thinkF_NULL )
+	{
+		self->e_ThinkFunc	= thinkF_fx_target_beam_think;
+		self->nextthink		= level.time + 50;
+	}
+	else
+	{
+		self->e_ThinkFunc	= thinkF_NULL;
+	}
+
+	self->activator = activator;
+}
+
+//------------------------------------------
+void fx_target_beam_think( gentity_t *ent )
+{
+	if ( ent->attackDebounceTime > level.time )
+	{
+		ent->nextthink = level.time + FRAMETIME;
+		return;
+	}
+
+	fx_target_beam_fire_start( ent );
+}
+
+//------------------------------------------
+void fx_target_beam_link( gentity_t *ent )
+{
+	gentity_t	*target = NULL;
+	vec3_t		dir;
+	float		len;
+
+	target = G_Find( target, FOFS(targetname), ent->target );
+
+	if ( !target )
+	{
+		Com_Printf( "bolt_link: unable to find target %s\n", ent->target );
+		G_FreeEntity( ent );
+		return;
+	}
+
+	ent->attackDebounceTime = level.time;
+
+	if ( !target->classname || Q_stricmp( "info_null", target->classname ) )
+	{//don't want to set enemy to something that's going to free itself... actually, this could be bad in other ways, too... ent pointer could be freed up and re-used by the time we check it next
+		G_SetEnemy( ent, target );
+	}
+	VectorSubtract( target->s.origin, ent->s.origin, dir );//er, does it ever use dir?
+	len = VectorNormalize( dir );//er, does it use len or dir?
+	vectoangles( dir, ent->s.angles );//er, does it use s.angles?
+	
+	VectorCopy( target->s.origin, ent->s.origin2 );
+
+	if ( ent->spawnflags & 1 )
+	{
+		// Do nothing
+		ent->e_ThinkFunc	= thinkF_NULL;
+	}
+	else
+	{
+		if ( !(ent->spawnflags & 8 )) // one_shot, only calls when used
+		{
+			// switch think functions to avoid doing the bolt_link every time
+			ent->e_ThinkFunc = thinkF_fx_target_beam_think;
+			ent->nextthink	= level.time + FRAMETIME;
+		}
+	}
+
+	ent->e_UseFunc = useF_fx_target_beam_use;
+	gi.linkentity( ent );
+}
+
+/*QUAKED fx_target_beam (1 0.5 0.5) (-8 -8 -8) (8 8 8) STARTOFF OPEN NO_KNOCKBACK ONE_SHOT NO_IMPACT
+ Emits specified effect file, doing damage if required
+
+STARTOFF - must be used before it's on
+OPEN - will draw all the way to the target, regardless of where the trace hits
+NO_KNOCKBACK - beam damage does no knockback
+
+ "fxFile" - Effect used to draw the beam, ( default "env/targ_beam" )
+ "fxFile2" - Effect used for the beam impact effect, ( default "env/targ_beam_impact" )
+ "targetname" - Fires only when used
+ "duration" - How many seconds each burst lasts, -1 will make it stay on forever
+ "wait" - If always on, how long to wait between blasts, in MILLISECONDS - default/min is 100 (1 frame at 10 fps), -1 means it will never fire again
+ "random" - random amount of seconds added to/subtracted from "wait" each firing
+ "damage" - How much damage to inflict PER FRAME (so probably want it kind of low), default is none
+ "target" - ent to point at- you MUST have this.  This can be anything you want, including a moving ent - for static beams, just use info_null
+*/
+//------------------------------------------
+void SP_fx_target_beam( gentity_t *ent )
+{
+	G_SetOrigin( ent, ent->s.origin );
+
+	ent->speed	*= 1000;
+	ent->wait	*= 1000;
+	ent->random *= 1000;
+
+	if ( ent->speed < FRAMETIME )
+	{
+		ent->speed = FRAMETIME;
+	}
+
+	G_SpawnInt( "damage", "0", &ent->damage );
+	G_SpawnString( "fxFile", "env/targ_beam", &ent->fxFile );
+
+	if ( ent->spawnflags & 16 ) // NO_IMPACT FX
+	{
+		ent->delay = 0;
+	}
+	else
+	{
+		G_SpawnString( "fxFile2", "env/targ_beam_impact", &ent->cameraGroup );
+		ent->delay = G_EffectIndex( ent->cameraGroup );
+	}
+
+	ent->fxID = G_EffectIndex( ent->fxFile );
+
+	ent->activator = ent;
+	ent->owner	= NULL;
+
+	ent->e_ThinkFunc = thinkF_fx_target_beam_link;
+	ent->nextthink	= level.time + START_TIME_LINK_ENTS;
+
+	VectorSet( ent->maxs, FX_ENT_RADIUS, FX_ENT_RADIUS, FX_ENT_RADIUS );
+	VectorScale( ent->maxs, -1, ent->mins );
+
+	gi.linkentity( ent );
+}
+
+
+/*QUAKED fx_cloudlayer (1 0.3 0.5) (-8 -8 -8) (8 8 8) TUBE ALT
+
+  Creates a scalable scrolling cloud layer, mostly for bespin undercity but could be used other places
+
+  TUBE - creates cloud layer with tube opening in the middle, must an INNER radius also
+  ALT - uses slightly different shader, good if using two layers sort of close together
+
+"radius" - outer radius of cloud layer, (default 2048)
+"random" - inner radius of cloud layer, (default 128) only works for TUBE type
+"wait" - adds curvature as it moves out to the edge of the layer.  ( default 0 ), 1 = small up, 3 = up more, -1 = small down, -3 = down more, etc.
+
+*/
+
+void SP_fx_cloudlayer( gentity_t *ent )
+{
+	// HACK: this effect is never played, rather it just caches the shaders I need cgame side
+	G_EffectIndex( "world/haze_cache" );
+
+	G_SpawnFloat( "radius", "2048", &ent->radius );
+	G_SpawnFloat( "random", "128", &ent->random );
+	G_SpawnFloat( "wait", "0", &ent->wait );
+
+	ent->s.eType = ET_CLOUD; // dumb
+
+	G_SetOrigin( ent, ent->s.origin );
+
+	ent->contents = 0;
+	VectorSet( ent->maxs, 200, 200, 200 );
+	VectorScale( ent->maxs, -1, ent->mins );
+
+	gi.linkentity( ent );
+}
\ No newline at end of file
diff --git a/code/game/g_headers.cpp b/code/game/g_headers.cpp
new file mode 100644
index 0000000..fe27977
--- /dev/null
+++ b/code/game/g_headers.cpp
@@ -0,0 +1,8 @@
+// Precompiled header file for the game dll
+
+#include "g_headers.h"
+#include "NPC_Headers.h"
+#include "../cgame/cg_headers.h"
+
+
+// end
diff --git a/code/game/g_headers.h b/code/game/g_headers.h
new file mode 100644
index 0000000..f0c009d
--- /dev/null
+++ b/code/game/g_headers.h
@@ -0,0 +1,32 @@
+#pragma once
+#if !defined(G_HEADERS_H_INC)
+#define G_HEADERS_H_INC
+
+#if !defined(G_LOCAL_H_INC)
+	#include "../game/g_local.h"
+#endif
+
+//#if !defined(G_WRAITH_H_INC)
+//	#include "../game/g_Wraith.h"
+//#endif
+
+#if !defined(TEAMS_H_INC)
+	#include "../game/Teams.h"
+#endif
+
+//#if !defined(IGINTERFACE_H_INC)
+//	#include "../game/IGInterface.h"
+//#endif
+
+// More stuff that we "need" on Xbox, as we don't use PCH
+#ifdef _XBOX
+	#include "../game/b_local.h"
+	#include "../game/g_functions.h"
+	#include "../game/g_nav.h"
+	#include "../game/g_navigator.h"
+	#include "../game/g_vehicles.h"
+	#include "../cgame/cg_camera.h"	// Just for AI_Rancor
+	#include "../cgame/cg_local.h"	// Evil? Maybe. Necessary? Absolutely.
+#endif
+
+#endif // G_HEADERS_H_INC
\ No newline at end of file
diff --git a/code/game/g_inventory.cpp b/code/game/g_inventory.cpp
new file mode 100644
index 0000000..d5e4c5b
--- /dev/null
+++ b/code/game/g_inventory.cpp
@@ -0,0 +1,137 @@
+//g_inventory.cpp
+
+// leave this line at the top for all g_xxxx.cpp files...
+#include "g_headers.h"
+
+#include "g_local.h"
+
+/*
+================
+Goodie Keys
+================
+*/
+qboolean INV_GoodieKeyGive( gentity_t *target )
+{
+	if ( !target || !target->client )
+	{
+		return (qfalse);
+	}
+
+	target->client->ps.inventory[INV_GOODIE_KEY]++;
+	return (qtrue);
+
+}
+
+qboolean INV_GoodieKeyTake( gentity_t *target )
+{
+	if ( !target || !target->client )
+	{
+		return (qfalse);
+	}
+
+	if (target->client->ps.inventory[INV_GOODIE_KEY])
+	{
+		target->client->ps.inventory[INV_GOODIE_KEY]--;
+		return (qtrue);
+	}
+
+	//had no keys
+	return (qfalse);
+}
+
+int INV_GoodieKeyCheck( gentity_t *target )
+{
+	if ( !target || !target->client )
+	{
+		return (qfalse);
+	}
+
+	if ( target->client->ps.inventory[INV_GOODIE_KEY] )
+	{//found a key
+		return (INV_GOODIE_KEY);
+	}
+
+	//no keys
+	return (qfalse);
+}
+
+/*
+================
+Security Keys
+================
+*/
+qboolean INV_SecurityKeyGive( gentity_t *target, const char *keyname )
+{
+	if ( target == NULL || keyname == NULL || target->client == NULL )
+	{
+		return qfalse;
+	}
+
+	for ( int i = 0; i <= 4; i++ )
+	{
+		if ( target->client->ps.security_key_message[i][0] == NULL )
+		{//fill in the first empty slot we find with this key
+			target->client->ps.inventory[INV_SECURITY_KEY]++;	// He got the key
+			Q_strncpyz( target->client->ps.security_key_message[i], keyname, MAX_SECURITY_KEY_MESSSAGE, qtrue );
+			return qtrue;
+		}
+	}
+	//couldn't find an empty slot
+	return qfalse;
+}
+
+void INV_SecurityKeyTake( gentity_t *target, char *keyname )
+{
+	if ( !target || !keyname || !target->client )
+	{
+		return;
+	}
+
+	for ( int i = 0; i <= 4; i++ )
+	{
+		if ( target->client->ps.security_key_message[i] )
+		{
+			if ( !Q_stricmp( keyname, target->client->ps.security_key_message[i] ) )
+			{
+				target->client->ps.inventory[INV_SECURITY_KEY]--;	// Take the key
+				target->client->ps.security_key_message[i][0] = NULL;
+				return;
+			}
+		}
+		/*
+		//don't do this because we could have removed one that's between 2 valid ones
+		else
+		{
+			break;
+		}
+		*/
+	}
+}
+
+qboolean INV_SecurityKeyCheck( gentity_t *target, char *keyname )
+{
+	if ( !target || !keyname || !target->client )
+	{
+		return (qfalse);
+	}
+
+	for ( int i = 0; i <= 4; i++ )
+	{
+		if ( target->client->ps.inventory[INV_SECURITY_KEY] && target->client->ps.security_key_message[i] )
+		{
+			if ( !Q_stricmp( keyname, target->client->ps.security_key_message[i] ) )
+			{
+				return (qtrue);
+			}
+		}
+		/*
+		//don't do this because we could have removed one that's between 2 valid ones
+		else
+		{
+			break;
+		}
+		*/
+	}
+
+	return (qfalse);
+}
diff --git a/code/game/g_itemLoad.cpp b/code/game/g_itemLoad.cpp
new file mode 100644
index 0000000..716a477
--- /dev/null
+++ b/code/game/g_itemLoad.cpp
@@ -0,0 +1,730 @@
+//g_itemLoad.cpp
+//reads in ext_data\items.dat to bg_itemlist[]
+
+// leave this line at the top for all g_xxxx.cpp files...
+#include "g_headers.h"
+
+
+
+
+#include "g_local.h"
+#include "g_items.h"
+
+#define PICKUPSOUND "sound/weapons/w_pkup.wav"
+#ifdef _IMMERSION
+#define PICKUPFORCE "fffx/weapons/w_pkup"
+#endif // _IMMERSION
+
+//qboolean COM_ParseInt( char **data, int *i );
+//qboolean COM_ParseString( char **data, char **s ); 
+//qboolean COM_ParseFloat( char **data, float *f );
+
+extern gitem_t	bg_itemlist[];
+
+struct 
+{
+	int	itemNum;
+} itemParms;
+
+
+static void IT_ClassName (const char **holdBuf);
+static void IT_Count (const char **holdBuf);
+static void IT_Icon (const char **holdBuf);
+static void IT_Min (const char **holdBuf);
+static void IT_Max (const char **holdBuf);
+static void IT_Name (const char **holdBuf);
+static void IT_PickupSound (const char **holdBuf);
+static void IT_Tag (const char **holdBuf);
+static void IT_Type (const char **holdBuf);
+static void IT_WorldModel (const char **holdBuf);
+#ifdef _IMMERSION
+static void IT_PickupForce( const char **holdBuf);
+#endif // _IMMERSION
+
+
+typedef struct 
+{
+	char	*parmName;
+	void	(*func)(const char **holdBuf);
+} itemParms_t;
+
+
+#ifdef _IMMERSION
+#define IT_PARM_MAX 11
+#else
+#define IT_PARM_MAX 10
+#endif // _IMMERSION
+
+itemParms_t ItemParms[IT_PARM_MAX] = 
+{
+	"itemname",			IT_Name,
+	"classname",		IT_ClassName,
+	"count",			IT_Count,
+	"icon",				IT_Icon,
+	"min",				IT_Min,
+	"max",				IT_Max,
+	"pickupsound",		IT_PickupSound,
+	"tag",				IT_Tag,
+	"type",				IT_Type,
+	"worldmodel",		IT_WorldModel,
+#ifdef _IMMERSION
+	"pickupforce",		IT_PickupForce,
+#endif // _IMMERSION
+};
+
+static void IT_SetDefaults()
+{
+
+	bg_itemlist[itemParms.itemNum].mins[0] = -16;
+	bg_itemlist[itemParms.itemNum].mins[1] = -16;
+	bg_itemlist[itemParms.itemNum].mins[2] = -2;
+
+	bg_itemlist[itemParms.itemNum].maxs[0] = 16;
+	bg_itemlist[itemParms.itemNum].maxs[1] = 16;
+	bg_itemlist[itemParms.itemNum].maxs[2] = 16;
+
+
+	bg_itemlist[itemParms.itemNum].pickup_sound = PICKUPSOUND;	//give it a default sound
+	bg_itemlist[itemParms.itemNum].precaches = NULL;
+	bg_itemlist[itemParms.itemNum].sounds = NULL;
+#ifdef _IMMERSION
+	bg_itemlist[itemParms.itemNum].pickup_force = PICKUPFORCE;
+	bg_itemlist[itemParms.itemNum].forces = NULL;
+#endif // _IMMERSION
+}
+
+static void IT_Name(const char **holdBuf)
+{
+	int itemNum;
+	const char	*tokenStr;
+
+	if (COM_ParseString(holdBuf,&tokenStr)) 
+	{
+		return;
+	}
+
+
+	if (!Q_stricmp(tokenStr,"ITM_NONE"))	
+		itemNum = ITM_NONE;
+	else if (!Q_stricmp(tokenStr,"ITM_STUN_BATON_PICKUP"))	
+		itemNum = ITM_STUN_BATON_PICKUP;
+	else if (!Q_stricmp(tokenStr,"ITM_SABER_PICKUP"))	
+		itemNum = ITM_SABER_PICKUP;
+	else if (!Q_stricmp(tokenStr,"ITM_BRYAR_PISTOL_PICKUP"))	
+		itemNum = ITM_BRYAR_PISTOL_PICKUP;
+	else if (!Q_stricmp(tokenStr,"ITM_BLASTER_PICKUP"))	
+		itemNum = ITM_BLASTER_PICKUP;
+	else if (!Q_stricmp(tokenStr,"ITM_DISRUPTOR_PICKUP"))	
+		itemNum = ITM_DISRUPTOR_PICKUP;
+	else if (!Q_stricmp(tokenStr,"ITM_BOWCASTER_PICKUP"))	
+		itemNum = ITM_BOWCASTER_PICKUP;
+	else if (!Q_stricmp(tokenStr,"ITM_REPEATER_PICKUP"))	
+		itemNum = ITM_REPEATER_PICKUP;
+	else if (!Q_stricmp(tokenStr,"ITM_DEMP2_PICKUP"))	
+		itemNum = ITM_DEMP2_PICKUP;
+	else if (!Q_stricmp(tokenStr,"ITM_FLECHETTE_PICKUP"))	
+		itemNum = ITM_FLECHETTE_PICKUP;
+	else if (!Q_stricmp(tokenStr,"ITM_ROCKET_LAUNCHER_PICKUP"))	
+		itemNum = ITM_ROCKET_LAUNCHER_PICKUP;
+	else if (!Q_stricmp(tokenStr,"ITM_THERMAL_DET_PICKUP"))	
+		itemNum = ITM_THERMAL_DET_PICKUP;
+	else if (!Q_stricmp(tokenStr,"ITM_TRIP_MINE_PICKUP"))	
+		itemNum = ITM_TRIP_MINE_PICKUP;
+	else if (!Q_stricmp(tokenStr,"ITM_DET_PACK_PICKUP"))	
+		itemNum = ITM_DET_PACK_PICKUP;
+	else if (!Q_stricmp(tokenStr,"ITM_BOT_LASER_PICKUP"))	
+		itemNum = ITM_BOT_LASER_PICKUP;
+	else if (!Q_stricmp(tokenStr,"ITM_EMPLACED_GUN_PICKUP"))	
+		itemNum = ITM_EMPLACED_GUN_PICKUP;
+	else if (!Q_stricmp(tokenStr,"ITM_TURRET_PICKUP"))	
+		itemNum = ITM_TURRET_PICKUP;
+	else if (!Q_stricmp(tokenStr,"ITM_MELEE"))	
+		itemNum = ITM_MELEE;
+	else if (!Q_stricmp(tokenStr,"ITM_ATST_MAIN_PICKUP"))	
+		itemNum = ITM_ATST_MAIN_PICKUP;
+	else if (!Q_stricmp(tokenStr,"ITM_ATST_SIDE_PICKUP"))	
+		itemNum = ITM_ATST_SIDE_PICKUP;
+	else if (!Q_stricmp(tokenStr,"ITM_TIE_FIGHTER_PICKUP"))	
+		itemNum = ITM_TIE_FIGHTER_PICKUP;
+	else if (!Q_stricmp(tokenStr,"ITM_RAPID_FIRE_CONC_PICKUP"))	
+		itemNum = ITM_RAPID_FIRE_CONC_PICKUP;
+	else if (!Q_stricmp(tokenStr,"ITM_JAWA_PICKUP"))	
+		itemNum = ITM_JAWA_PICKUP;
+	else if (!Q_stricmp(tokenStr,"ITM_TUSKEN_RIFLE_PICKUP"))	
+		itemNum = ITM_TUSKEN_RIFLE_PICKUP;
+	else if (!Q_stricmp(tokenStr,"ITM_TUSKEN_STAFF_PICKUP"))	
+		itemNum = ITM_TUSKEN_STAFF_PICKUP;
+	else if (!Q_stricmp(tokenStr,"ITM_SCEPTER_PICKUP"))	
+		itemNum = ITM_SCEPTER_PICKUP;
+	else if (!Q_stricmp(tokenStr,"ITM_NOGHRI_STICK_PICKUP"))	
+		itemNum = ITM_NOGHRI_STICK_PICKUP;
+	//ammo
+	else if (!Q_stricmp(tokenStr,"ITM_AMMO_FORCE_PICKUP"))
+		itemNum = ITM_AMMO_FORCE_PICKUP;
+	else if (!Q_stricmp(tokenStr,"ITM_AMMO_BLASTER_PICKUP"))
+		itemNum = ITM_AMMO_BLASTER_PICKUP;
+	else if (!Q_stricmp(tokenStr,"ITM_AMMO_POWERCELL_PICKUP"))
+		itemNum = ITM_AMMO_POWERCELL_PICKUP;
+	else if (!Q_stricmp(tokenStr,"ITM_AMMO_METAL_BOLTS_PICKUP"))
+		itemNum = ITM_AMMO_METAL_BOLTS_PICKUP;
+	else if (!Q_stricmp(tokenStr,"ITM_AMMO_ROCKETS_PICKUP"))
+		itemNum = ITM_AMMO_ROCKETS_PICKUP;
+	else if (!Q_stricmp(tokenStr,"ITM_AMMO_EMPLACED_PICKUP"))
+		itemNum = ITM_AMMO_EMPLACED_PICKUP;
+	else if (!Q_stricmp(tokenStr,"ITM_AMMO_THERMAL_PICKUP"))
+		itemNum = ITM_AMMO_THERMAL_PICKUP;
+	else if (!Q_stricmp(tokenStr,"ITM_AMMO_TRIPMINE_PICKUP"))
+		itemNum = ITM_AMMO_TRIPMINE_PICKUP;
+	else if (!Q_stricmp(tokenStr,"ITM_AMMO_DETPACK_PICKUP"))
+		itemNum = ITM_AMMO_DETPACK_PICKUP;
+	else if (!Q_stricmp(tokenStr,"ITM_FORCE_HEAL_PICKUP"))
+	{
+		itemNum = ITM_FORCE_HEAL_PICKUP;
+	}
+	else if (!Q_stricmp(tokenStr,"ITM_FORCE_LEVITATION_PICKUP"))
+	{
+		itemNum = ITM_FORCE_LEVITATION_PICKUP;
+	}
+	else if (!Q_stricmp(tokenStr,"ITM_FORCE_SPEED_PICKUP"))
+	{
+		itemNum = ITM_FORCE_SPEED_PICKUP;
+	}
+	else if (!Q_stricmp(tokenStr,"ITM_FORCE_PUSH_PICKUP"))
+	{
+		itemNum = ITM_FORCE_PUSH_PICKUP;
+	}
+	else if (!Q_stricmp(tokenStr,"ITM_FORCE_PULL_PICKUP"))
+	{
+		itemNum = ITM_FORCE_PULL_PICKUP;
+	}
+	else if (!Q_stricmp(tokenStr,"ITM_FORCE_TELEPATHY_PICKUP"))
+	{
+		itemNum = ITM_FORCE_TELEPATHY_PICKUP;
+	}
+	else if (!Q_stricmp(tokenStr,"ITM_FORCE_GRIP_PICKUP"))
+	{
+		itemNum = ITM_FORCE_GRIP_PICKUP;
+	}
+	else if (!Q_stricmp(tokenStr,"ITM_FORCE_LIGHTNING_PICKUP"))
+	{
+		itemNum = ITM_FORCE_LIGHTNING_PICKUP;
+	}
+	else if (!Q_stricmp(tokenStr,"ITM_FORCE_SABERTHROW_PICKUP"))
+	{
+		itemNum = ITM_FORCE_SABERTHROW_PICKUP;
+	}
+	else if (!Q_stricmp(tokenStr,"ITM_BATTERY_PICKUP"))	
+	{
+		itemNum = ITM_BATTERY_PICKUP;
+	}
+	else if (!Q_stricmp(tokenStr,"ITM_SEEKER_PICKUP"))	
+		itemNum = ITM_SEEKER_PICKUP;
+	else if (!Q_stricmp(tokenStr,"ITM_SHIELD_PICKUP"))	
+		itemNum = ITM_SHIELD_PICKUP;
+	else if (!Q_stricmp(tokenStr,"ITM_BACTA_PICKUP"))	
+		itemNum = ITM_BACTA_PICKUP;
+	else if (!Q_stricmp(tokenStr,"ITM_DATAPAD_PICKUP"))	
+		itemNum = ITM_DATAPAD_PICKUP;
+	else if (!Q_stricmp(tokenStr,"ITM_BINOCULARS_PICKUP"))	
+		itemNum = ITM_BINOCULARS_PICKUP;
+	else if (!Q_stricmp(tokenStr,"ITM_SENTRY_GUN_PICKUP"))	
+		itemNum = ITM_SENTRY_GUN_PICKUP;
+	else if (!Q_stricmp(tokenStr,"ITM_LA_GOGGLES_PICKUP"))	
+		itemNum = ITM_LA_GOGGLES_PICKUP;
+	else if (!Q_stricmp(tokenStr,"ITM_BLASTER_PISTOL_PICKUP"))	
+		itemNum = ITM_BLASTER_PISTOL_PICKUP;
+	else if (!Q_stricmp(tokenStr,"ITM_CONCUSSION_RIFLE_PICKUP"))	
+		itemNum = ITM_CONCUSSION_RIFLE_PICKUP;
+	else if (!Q_stricmp(tokenStr,"ITM_MEDPAK_PICKUP"))	
+		itemNum = ITM_MEDPAK_PICKUP;
+	else if (!Q_stricmp(tokenStr,"ITM_SHIELD_SM_PICKUP"))	
+		itemNum = ITM_SHIELD_SM_PICKUP;
+	else if (!Q_stricmp(tokenStr,"ITM_SHIELD_LRG_PICKUP"))	
+		itemNum = ITM_SHIELD_LRG_PICKUP;
+	else if (!Q_stricmp(tokenStr,"ITM_GOODIE_KEY_PICKUP"))	
+		itemNum = ITM_GOODIE_KEY_PICKUP;
+	else if (!Q_stricmp(tokenStr,"ITM_SECURITY_KEY_PICKUP"))	
+		itemNum = ITM_SECURITY_KEY_PICKUP;
+	else
+	{
+		itemNum = 0;
+		gi.Printf("WARNING: bad itemname in external item data '%s'\n", tokenStr);
+	}
+
+	itemParms.itemNum = itemNum;	
+//	++bg_numItems;
+
+	IT_SetDefaults();
+}
+
+static void IT_ClassName(const char **holdBuf)
+{
+	int len;
+	const char	*tokenStr;
+
+	if (COM_ParseString(holdBuf,&tokenStr)) 
+	{
+		return;
+	}
+
+	len = strlen(tokenStr);
+	len++;
+	if (len > 32)
+	{
+		len = 32;
+		gi.Printf("WARNING: weaponclass too long in external ITEMS.DAT '%s'\n", tokenStr);
+	}
+
+	bg_itemlist[itemParms.itemNum].classname = G_NewString(tokenStr);
+
+//	Q_strncpyz(bg_itemlist[itemParms.itemNum].classname,tokenStr,len);
+
+}
+
+static void IT_WorldModel(const char **holdBuf)
+{
+	int len;
+	const char	*tokenStr;
+
+	if (COM_ParseString(holdBuf,&tokenStr)) 
+	{
+		return;
+	}
+
+	len = strlen(tokenStr);
+	len++;
+	if (len > 64)
+	{
+		len = 64;
+		gi.Printf("WARNING: world model too long in external ITEMS.DAT '%s'\n", tokenStr);
+	}
+
+	bg_itemlist[itemParms.itemNum].world_model = G_NewString(tokenStr);
+
+//	Q_strncpyz(bg_itemlist[itemParms.itemNum].world_model[0],tokenStr,len);
+
+}
+
+static void IT_Tag(const char **holdBuf)
+{
+	int tag;
+	const char	*tokenStr;
+
+	if (COM_ParseString(holdBuf,&tokenStr)) 
+	{
+		return;
+	}
+
+	if (!Q_stricmp(tokenStr,"WP_NONE"))	
+		tag = WP_NONE;
+	else if (!Q_stricmp(tokenStr,"WP_STUN_BATON"))	
+		tag = WP_STUN_BATON;
+	else if (!Q_stricmp(tokenStr,"WP_SABER"))	
+		tag = WP_SABER;
+	else if (!Q_stricmp(tokenStr,"WP_BLASTER_PISTOL"))	
+		tag = WP_BLASTER_PISTOL;
+	else if (!Q_stricmp(tokenStr,"WP_BRYAR_PISTOL"))	
+		tag = WP_BRYAR_PISTOL;
+	else if (!Q_stricmp(tokenStr,"WP_BLASTER"))	
+		tag = WP_BLASTER;
+	else if (!Q_stricmp(tokenStr,"WP_DISRUPTOR"))	
+		tag = WP_DISRUPTOR;
+	else if (!Q_stricmp(tokenStr,"WP_BOWCASTER"))	
+		tag = WP_BOWCASTER;
+	else if (!Q_stricmp(tokenStr,"WP_REPEATER"))	
+		tag = WP_REPEATER;
+	else if (!Q_stricmp(tokenStr,"WP_DEMP2"))	
+		tag = WP_DEMP2;
+	else if (!Q_stricmp(tokenStr,"WP_FLECHETTE"))	
+		tag = WP_FLECHETTE;
+	else if (!Q_stricmp(tokenStr,"WP_ROCKET_LAUNCHER"))	
+		tag = WP_ROCKET_LAUNCHER;
+	else if (!Q_stricmp(tokenStr,"WP_CONCUSSION"))	
+		tag = WP_CONCUSSION;
+	else if (!Q_stricmp(tokenStr,"WP_THERMAL"))	
+		tag = WP_THERMAL;
+	else if (!Q_stricmp(tokenStr,"WP_TRIP_MINE"))	
+		tag = WP_TRIP_MINE;
+	else if (!Q_stricmp(tokenStr,"WP_DET_PACK"))	
+		tag = WP_DET_PACK;
+//	else if (!Q_stricmp(tokenStr,"WP_TRICORDER"))	
+//		tag = WP_TRICORDER;
+	else if (!Q_stricmp(tokenStr,"WP_BOT_LASER"))	
+		tag = WP_BOT_LASER;
+	else if (!Q_stricmp(tokenStr,"WP_EMPLACED_GUN"))	
+		tag = WP_EMPLACED_GUN;
+	else if (!Q_stricmp(tokenStr,"WP_MELEE"))	
+		tag = WP_MELEE;
+	else if (!Q_stricmp(tokenStr,"WP_TURRET"))
+		tag = WP_TURRET;
+	else if (!Q_stricmp(tokenStr,"WP_ATST_MAIN"))
+		tag = WP_ATST_MAIN;
+	else if (!Q_stricmp(tokenStr,"WP_ATST_SIDE"))
+		tag = WP_ATST_SIDE;
+	else if (!Q_stricmp(tokenStr,"WP_TIE_FIGHTER"))
+		tag = WP_TIE_FIGHTER;
+	else if (!Q_stricmp(tokenStr,"WP_RAPID_FIRE_CONC"))
+		tag = WP_RAPID_FIRE_CONC;
+	else if (!Q_stricmp(tokenStr,"WP_BLASTER_PISTOL"))
+		tag = WP_BLASTER_PISTOL;
+	else if (!Q_stricmp(tokenStr,"WP_JAWA"))
+		tag = WP_JAWA;
+	else if (!Q_stricmp(tokenStr,"WP_TUSKEN_RIFLE"))
+		tag = WP_TUSKEN_RIFLE;
+	else if (!Q_stricmp(tokenStr,"WP_TUSKEN_STAFF"))
+		tag = WP_TUSKEN_STAFF;
+	else if (!Q_stricmp(tokenStr,"WP_SCEPTER"))
+		tag = WP_SCEPTER;
+	else if (!Q_stricmp(tokenStr,"WP_NOGHRI_STICK"))
+		tag = WP_NOGHRI_STICK;
+	else if (!Q_stricmp(tokenStr,"AMMO_FORCE"))	
+		tag = AMMO_FORCE;
+	else if (!Q_stricmp(tokenStr,"AMMO_BLASTER"))	
+		tag = AMMO_BLASTER;
+	else if (!Q_stricmp(tokenStr,"AMMO_POWERCELL"))	
+		tag = AMMO_POWERCELL;
+	else if (!Q_stricmp(tokenStr,"AMMO_METAL_BOLTS"))	
+		tag = AMMO_METAL_BOLTS;
+	else if (!Q_stricmp(tokenStr,"AMMO_ROCKETS"))	
+		tag = AMMO_ROCKETS;
+	else if (!Q_stricmp(tokenStr,"AMMO_EMPLACED"))	
+		tag = AMMO_EMPLACED;
+	else if (!Q_stricmp(tokenStr,"AMMO_THERMAL"))	
+		tag = AMMO_THERMAL;
+	else if (!Q_stricmp(tokenStr,"AMMO_TRIPMINE"))	
+		tag = AMMO_TRIPMINE;
+	else if (!Q_stricmp(tokenStr,"AMMO_DETPACK"))	
+		tag = AMMO_DETPACK;
+	else if (!Q_stricmp(tokenStr,"FP_HEAL"))	
+	{
+		tag = FP_HEAL;
+	}
+	else if (!Q_stricmp(tokenStr,"FP_LEVITATION"))	
+	{
+		tag = FP_LEVITATION;
+	}
+	else if (!Q_stricmp(tokenStr,"FP_SPEED"))	
+	{
+		tag = FP_SPEED;
+	}
+	else if (!Q_stricmp(tokenStr,"FP_PUSH"))	
+	{
+		tag = FP_PUSH;
+	}
+	else if (!Q_stricmp(tokenStr,"FP_PULL"))	
+	{
+		tag = FP_PULL;
+	}
+	else if (!Q_stricmp(tokenStr,"FP_TELEPATHY"))	
+	{
+		tag = FP_TELEPATHY;
+	}
+	else if (!Q_stricmp(tokenStr,"FP_GRIP"))	
+	{
+		tag = FP_GRIP;
+	}
+	else if (!Q_stricmp(tokenStr,"FP_LIGHTNING"))	
+	{
+		tag = FP_LIGHTNING;
+	}
+	else if (!Q_stricmp(tokenStr,"FP_SABERTHROW"))	
+	{
+		tag = FP_SABERTHROW;
+	}
+	else if (!Q_stricmp(tokenStr,"ITM_BATTERY_PICKUP"))	
+	{
+		tag = ITM_BATTERY_PICKUP;
+	}
+	else if (!Q_stricmp(tokenStr,"INV_SEEKER"))	
+	{
+		tag = INV_SEEKER;
+	}
+	else if (!Q_stricmp(tokenStr,"ITM_SHIELD_PICKUP"))	
+	{
+		tag = ITM_SHIELD_PICKUP;
+	}
+	else if (!Q_stricmp(tokenStr,"INV_BACTA_CANISTER"))	
+	{
+		tag = INV_BACTA_CANISTER;
+	}
+	else if (!Q_stricmp(tokenStr,"ITM_DATAPAD_PICKUP"))	
+	{
+		tag = ITM_DATAPAD_PICKUP;
+	}
+	else if (!Q_stricmp(tokenStr,"INV_ELECTROBINOCULARS"))	
+	{
+		tag = INV_ELECTROBINOCULARS;
+	}
+	else if (!Q_stricmp(tokenStr,"INV_SENTRY"))	
+	{
+		tag = INV_SENTRY;
+	}
+	else if (!Q_stricmp(tokenStr,"INV_LIGHTAMP_GOGGLES"))	
+	{
+		tag = INV_LIGHTAMP_GOGGLES;
+	}
+	else if (!Q_stricmp(tokenStr,"INV_GOODIE_KEY"))	
+	{
+		tag = INV_GOODIE_KEY;
+	}
+	else if (!Q_stricmp(tokenStr,"INV_SECURITY_KEY"))	
+	{
+		tag = INV_SECURITY_KEY;
+	}
+	else if (!Q_stricmp(tokenStr,"ITM_MEDPAK_PICKUP"))	
+	{
+		tag = ITM_MEDPAK_PICKUP;
+	}
+	else if (!Q_stricmp(tokenStr,"ITM_SHIELD_SM_PICKUP"))
+	{
+		tag = ITM_SHIELD_SM_PICKUP;
+	}
+	else if (!Q_stricmp(tokenStr,"ITM_SHIELD_LRG_PICKUP"))	
+	{
+		tag = ITM_SHIELD_LRG_PICKUP;
+	}
+	else
+	{
+		tag = WP_BRYAR_PISTOL;
+		//This error was slipping through too much, causing runaway exceptions and shutting down, so now it's a real error when not in Final
+#ifndef FINAL_BUILD
+		G_Error("ERROR: bad tagname in external item data '%s'\n", tokenStr);
+#else
+		gi.Printf("WARNING: bad tagname in external item data '%s'\n", tokenStr);
+#endif
+	}
+
+	bg_itemlist[itemParms.itemNum].giTag = tag;
+
+}
+
+static void IT_Type(const char **holdBuf)
+{
+	int type;
+	const char	*tokenStr;
+
+	if (COM_ParseString(holdBuf,&tokenStr)) 
+	{
+		return;
+	}
+
+	if (!Q_stricmp(tokenStr,"IT_BAD"))	
+		type = IT_BAD;
+	else if (!Q_stricmp(tokenStr,"IT_WEAPON"))	
+		type = IT_WEAPON;
+	else if (!Q_stricmp(tokenStr,"IT_AMMO"))	
+		type = IT_AMMO;
+	else if (!Q_stricmp(tokenStr,"IT_ARMOR"))
+		type = IT_ARMOR;
+	else if (!Q_stricmp(tokenStr,"IT_HEALTH"))
+		type = IT_HEALTH;
+	else if (!Q_stricmp(tokenStr,"IT_HOLDABLE"))	
+		type = IT_HOLDABLE;
+	else if (!Q_stricmp(tokenStr,"IT_BATTERY"))	
+		type = IT_BATTERY;
+	else if (!Q_stricmp(tokenStr,"IT_HOLOCRON"))	
+		type = IT_HOLOCRON;
+	else
+	{
+		type = IT_BAD;
+		gi.Printf("WARNING: bad itemname in external item data '%s'\n", tokenStr);
+	}
+
+	bg_itemlist[itemParms.itemNum].giType = (itemType_t) type;
+
+}
+
+static void IT_Icon(const char **holdBuf)
+{
+	int len;
+	const char	*tokenStr;
+
+	if (COM_ParseString(holdBuf,&tokenStr)) 
+	{
+		return;
+	}
+
+	len = strlen(tokenStr);
+	len++;
+	if (len > 32)
+	{
+		len = 32;
+		gi.Printf("WARNING: icon too long in external ITEMS.DAT '%s'\n", tokenStr);
+	}
+
+	bg_itemlist[itemParms.itemNum].icon = G_NewString(tokenStr);
+}
+
+static void IT_Count(const char **holdBuf)
+{
+	int		tokenInt;
+
+	if ( COM_ParseInt(holdBuf,&tokenInt)) 
+	{
+		SkipRestOfLine(holdBuf);
+		return;
+	}
+
+	if ((tokenInt < 0) || (tokenInt > 1000 )) // FIXME :What are the right values?
+	{
+		gi.Printf("WARNING: bad Count in external item data '%d'\n", tokenInt);
+		return;
+	}
+	bg_itemlist[itemParms.itemNum].quantity = tokenInt;
+
+}
+
+
+static void IT_Min(const char **holdBuf)
+{
+	int		tokenInt;
+	int		i;
+
+	for (i=0;i<3;++i)
+	{
+		if ( COM_ParseInt(holdBuf,&tokenInt)) 
+		{
+			SkipRestOfLine(holdBuf);
+			return;
+		}
+
+		bg_itemlist[itemParms.itemNum].mins[i] = tokenInt;
+	}
+
+}
+
+static void IT_Max(const char **holdBuf)
+{
+	int		tokenInt;
+	int		i;
+
+	for (i=0;i<3;++i)
+	{
+		if ( COM_ParseInt(holdBuf,&tokenInt)) 
+		{
+			SkipRestOfLine(holdBuf);
+			return;
+		}
+
+		bg_itemlist[itemParms.itemNum].maxs[i] = tokenInt;
+	}
+
+}
+
+static void IT_PickupSound(const char **holdBuf)
+{
+	int len;
+	const char	*tokenStr;
+
+	if (COM_ParseString(holdBuf,&tokenStr)) 
+	{
+		return;
+	}
+
+	len = strlen(tokenStr);
+	len++;
+	if (len > 32)
+	{
+		len = 32;
+		gi.Printf("WARNING: Pickup Sound too long in external ITEMS.DAT '%s'\n", tokenStr);
+	}
+
+	bg_itemlist[itemParms.itemNum].pickup_sound = G_NewString(tokenStr);
+}
+
+#ifdef _IMMERSION
+static void IT_PickupForce(const char **holdBuf)
+{
+	int len;
+	const char	*tokenStr;
+
+	if (COM_ParseString(holdBuf,&tokenStr)) 
+	{
+		return;
+	}
+
+	len = strlen(tokenStr);
+	len++;
+	if (len > 32)
+	{
+		len = 32;
+		gi.Printf("WARNING: Pickup Force too long in external ITEMS.DAT '%s'\n", tokenStr);
+	}
+
+	bg_itemlist[itemParms.itemNum].pickup_force = G_NewString(tokenStr);
+}
+#endif // _IMMERSION
+static void IT_ParseWeaponParms(const char **holdBuf)
+{
+	static int	weaponNum,ammoNum;
+	const char	*token;
+	int		i;
+
+
+	while (holdBuf)
+	{
+		token = COM_ParseExt( holdBuf, qtrue );
+
+		if (!Q_stricmp( token, "}" ))	// End of data for this weapon
+			break;
+
+		// Loop through possible parameters
+		for (i=0;i<IT_PARM_MAX;++i)
+		{
+			if (!Q_stricmp(token,ItemParms[i].parmName))	
+			{
+				ItemParms[i].func(holdBuf);
+				break;
+			}
+		}
+
+		if (i < IT_PARM_MAX)	// Find parameter???
+		{
+			continue;
+		}
+
+		gi.Printf("bad parameter in external weapon data '%s'\n", token);
+		SkipRestOfLine(holdBuf);
+		
+	}
+}
+
+
+static void IT_ParseParms(const char *buffer)
+{
+	const char	*holdBuf;
+	const char	*token;
+
+//	bg_numItems = 0;
+	holdBuf = buffer;
+	COM_BeginParseSession();
+
+	while ( holdBuf ) 
+	{
+		token = COM_ParseExt( &holdBuf, qtrue );
+
+		if ( !Q_stricmp( token, "{" ) ) 
+		{
+			token =token;
+			IT_ParseWeaponParms(&holdBuf);
+		}
+		 
+	}
+
+//	--bg_numItems;
+
+}
+
+
+void IT_LoadItemParms (void)
+{
+	char *buffer;
+	int len;
+
+	len = gi.FS_ReadFile("ext_data/items.dat",(void **) &buffer);
+
+	IT_ParseParms(buffer);
+
+	gi.FS_FreeFile( buffer );	//let go of the buffer
+}
+
diff --git a/code/game/g_items.cpp b/code/game/g_items.cpp
new file mode 100644
index 0000000..d0ffafe
--- /dev/null
+++ b/code/game/g_items.cpp
@@ -0,0 +1,1304 @@
+// leave this line at the top for all g_xxxx.cpp files...
+#include "g_headers.h"
+
+
+
+#include "g_local.h"
+#include "g_functions.h"
+#include "g_items.h"
+#include "wp_saber.h"
+
+extern qboolean	missionInfo_Updated;
+
+extern void CrystalAmmoSettings(gentity_t *ent);
+extern void ChangeWeapon( gentity_t *ent, int newWeapon );
+extern qboolean PM_InKnockDown( playerState_t *ps );
+extern qboolean PM_InGetUp( playerState_t *ps );
+extern void WP_SetSaber( gentity_t *ent, int saberNum, char *saberName );
+extern void WP_RemoveSaber( gentity_t *ent, int saberNum );
+extern saber_colors_t TranslateSaberColor( const char *name );
+
+extern	cvar_t	*g_spskill;
+extern	cvar_t	*g_sex;
+
+#define MAX_BACTA_HEAL_AMOUNT		25
+
+/*
+
+  Items are any object that a player can touch to gain some effect.
+
+  Pickup will return the number of seconds until they should respawn.
+
+  all items should pop when dropped in lava or slime
+
+  Respawnable items don't actually go away when picked up, they are
+  just made invisible and untouchable.  This allows them to ride
+  movers and respawn apropriately.
+*/
+
+// Item Spawn flags
+#define ITMSF_SUSPEND		1
+#define ITMSF_NOPLAYER		2
+#define ITMSF_ALLOWNPC		4
+#define ITMSF_NOTSOLID		8
+#define ITMSF_VERTICAL		16
+#define ITMSF_INVISIBLE		32
+#define ITMSF_NOGLOW		64
+
+//======================================================================
+
+/*
+===============
+G_InventorySelectable
+===============
+*/
+qboolean G_InventorySelectable( int index,gentity_t *other) 
+{
+	if (other->client->ps.inventory[index])
+	{
+		return qtrue;
+	}
+
+	return qfalse;
+}
+
+extern qboolean INV_GoodieKeyGive( gentity_t *target );
+extern qboolean INV_SecurityKeyGive( gentity_t *target, const char *keyname );
+int Pickup_Holdable( gentity_t *ent, gentity_t *other ) 
+{
+	int		i,original;
+
+	other->client->ps.stats[STAT_ITEMS] |= (1<<ent->item->giTag);
+
+	if ( ent->item->giTag == INV_SECURITY_KEY )
+	{//give the key
+		//FIXME: temp message
+		gi.SendServerCommand( NULL, "cp @SP_INGAME_YOU_TOOK_SECURITY_KEY" );
+		INV_SecurityKeyGive( other, ent->message );
+	}
+	else if ( ent->item->giTag == INV_GOODIE_KEY )
+	{//give the key
+		//FIXME: temp message
+		gi.SendServerCommand( NULL, "cp @SP_INGAME_YOU_TOOK_SUPPLY_KEY" );
+		INV_GoodieKeyGive( other );
+	}
+	else
+	{// Picking up a normal item?
+		other->client->ps.inventory[ent->item->giTag]++;
+	}
+	// Got a security key
+
+	// Set the inventory select, just in case it hasn't
+	original = cg.inventorySelect;
+	for ( i = 0 ; i < INV_MAX ; i++ ) 
+	{
+		if ((cg.inventorySelect < INV_ELECTROBINOCULARS) || (cg.inventorySelect >= INV_MAX))
+		{ 
+			cg.inventorySelect = (INV_MAX - 1); 
+		}
+		
+		if ( G_InventorySelectable( cg.inventorySelect,other ) ) 
+		{	
+			return 60;
+		}
+		cg.inventorySelect++;
+	}
+
+	cg.inventorySelect = original;
+
+	return 60;
+}
+
+
+//======================================================================
+int Add_Ammo2 (gentity_t *ent, int ammoType, int count)
+{
+
+	if (ammoType != AMMO_FORCE)
+	{
+		ent->client->ps.ammo[ammoType] += count;
+
+		// since the ammo is the weapon in this case, picking up ammo should actually give you the weapon
+		switch( ammoType )
+		{
+		case AMMO_THERMAL:
+			ent->client->ps.stats[STAT_WEAPONS] |= ( 1 << WP_THERMAL );
+			break;
+		case AMMO_DETPACK:
+			ent->client->ps.stats[STAT_WEAPONS] |= ( 1 << WP_DET_PACK );
+			break;
+		case AMMO_TRIPMINE:
+			ent->client->ps.stats[STAT_WEAPONS] |= ( 1 << WP_TRIP_MINE );
+			break;
+		}
+
+		if ( ent->client->ps.ammo[ammoType] > ammoData[ammoType].max ) 
+		{
+			ent->client->ps.ammo[ammoType] = ammoData[ammoType].max;
+			return qfalse;
+		}
+	}
+	else
+	{
+		if ( ent->client->ps.forcePower >= ammoData[ammoType].max )
+		{//if have full force, just get 25 extra per crystal
+			ent->client->ps.forcePower += 25;
+		}
+		else
+		{//else if don't have full charge, give full amount, up to max + 25
+			ent->client->ps.forcePower += count;
+			if ( ent->client->ps.forcePower >= ammoData[ammoType].max + 25 )
+			{//cap at max + 25
+				ent->client->ps.forcePower = ammoData[ammoType].max + 25;
+			}
+		}
+
+		if ( ent->client->ps.forcePower >= ammoData[ammoType].max*2 )
+		{//always cap at twice a full charge
+			ent->client->ps.forcePower = ammoData[ammoType].max*2;
+			return qfalse;		// can't hold any more
+		}
+	}
+	return qtrue;
+}
+
+//-------------------------------------------------------
+void Add_Ammo (gentity_t *ent, int weapon, int count)
+{
+	Add_Ammo2(ent,weaponData[weapon].ammoIndex,count);
+}
+
+//-------------------------------------------------------
+int Pickup_Ammo (gentity_t *ent, gentity_t *other)
+{
+	int		quantity;
+
+	if ( ent->count ) {
+		quantity = ent->count;
+	} else {
+		quantity = ent->item->quantity;
+	}
+
+	Add_Ammo2 (other, ent->item->giTag, quantity);
+
+	return 30;
+}
+
+//======================================================================
+void Add_Batteries( gentity_t *ent, int *count )
+{
+	if ( ent->client && ent->client->ps.batteryCharge < MAX_BATTERIES && *count )
+	{
+		if ( *count + ent->client->ps.batteryCharge > MAX_BATTERIES )
+		{
+			// steal what we need, then leave the rest for later
+			*count -= ( MAX_BATTERIES - ent->client->ps.batteryCharge );
+			ent->client->ps.batteryCharge = MAX_BATTERIES;
+		}
+		else
+		{
+			// just drain all of the batteries
+			ent->client->ps.batteryCharge += *count;	
+			*count = 0;
+		}
+
+		G_AddEvent( ent, EV_BATTERIES_CHARGED, 0 );
+	}
+}
+
+//-------------------------------------------------------
+int Pickup_Battery( gentity_t *ent, gentity_t *other )
+{
+	int	quantity;
+
+	if ( ent->count ) 
+	{
+		quantity = ent->count;
+	} 
+	else 
+	{
+		quantity = ent->item->quantity;
+	}
+
+	// There may be some left over in quantity if the player is close to full, but with pickup items, this amount will just be lost
+	Add_Batteries( other, &quantity );
+
+	return 30;
+}
+
+//======================================================================
+
+extern void G_SetSabersFromCVars( gentity_t *ent );
+void Pickup_Saber( gentity_t *self, qboolean hadSaber, qboolean saberSolo, char *saberType, char *saberColor )
+{
+	//G_RemoveWeaponModels( ent );//???
+	if ( Q_stricmp( "player", saberType ) == 0 )
+	{//"player" means use cvar info
+		G_SetSabersFromCVars( self );
+	}
+	else 
+	{
+		saberInfo_t	newSaber={0};
+		if ( WP_SaberParseParms( saberType, &newSaber ) )
+		{//successfully found a saber .sab entry to use
+			//FIXME: what about dual sabers?
+			int	saberNum = 0;
+			if ( saberSolo//only supposed to use this one saber when grab this pickup
+				|| newSaber.twoHanded //new saber is two-handed
+				|| (hadSaber && self->client->ps.saber[0].twoHanded) )//old saber is two-handed
+			{//replace the old right-hand saber and remove the left hand one
+				WP_RemoveSaber( self, 1 );
+			}
+			else
+			{//add it as a second saber
+				saberNum = 1;
+			}
+			WP_SetSaber( self, saberNum, saberType );
+			WP_SaberInitBladeData( self );
+			if ( self->client->ps.saber[saberNum].style )
+			{
+				self->client->ps.saberStylesKnown |= (1<<self->client->ps.saber[saberNum].style);
+			}
+			if ( saberColor != NULL )
+			{//NPC_targetname = saberColor
+				saber_colors_t saber_color = TranslateSaberColor( saberColor );
+				for ( int bladeNum = 0; bladeNum < MAX_BLADES; bladeNum++ )
+				{
+					self->client->ps.saber[saberNum].blade[bladeNum].color = saber_color;
+				}
+			}
+		}
+		WP_SaberFreeStrings(newSaber);
+	}
+}
+
+extern void CG_ChangeWeapon( int num );
+int Pickup_Weapon (gentity_t *ent, gentity_t *other) 
+{
+	int		quantity;
+	qboolean	hadWeapon = qfalse;
+
+	/*
+	if ( ent->count || (ent->activator && !ent->activator->s.number) ) 
+	{
+		quantity = ent->count;
+	} 
+	else 
+	{
+		quantity = ent->item->quantity;
+	}
+	*/
+
+	// dropped items are always picked up
+	if ( ent->flags & FL_DROPPED_ITEM ) 
+	{
+		quantity = ent->count;
+	}
+	else
+	{//wasn't dropped
+		quantity = ent->item->quantity?ent->item->quantity:50;
+	}
+
+	// add the weapon
+	if ( other->client->ps.stats[STAT_WEAPONS] & ( 1 << ent->item->giTag ) )
+	{
+		hadWeapon = qtrue;
+	}
+	other->client->ps.stats[STAT_WEAPONS] |= ( 1 << ent->item->giTag );
+
+	if ( ent->item->giTag == WP_SABER && (!hadWeapon || ent->NPC_type != NULL) )
+	{//didn't have a saber or it is specifying a certain kind of saber to use
+		//NOTE: alt_fire = saberSolo, NPC_type = saberType, NPC_targetname = saberColor
+		Pickup_Saber( other, hadWeapon, ent->alt_fire, ent->NPC_type, ent->NPC_targetname );
+	}
+
+	if ( other->s.number )
+	{//NPC
+		if ( other->s.weapon == WP_NONE )
+		{//NPC with no weapon picked up a weapon, change to this weapon
+			//FIXME: clear/set the alt-fire flag based on the picked up weapon and my class?
+			other->client->ps.weapon = ent->item->giTag;
+			other->client->ps.weaponstate = WEAPON_RAISING;
+			ChangeWeapon( other, ent->item->giTag );
+			if ( ent->item->giTag == WP_SABER )
+			{
+				other->client->ps.SaberActivate();
+				WP_SaberAddG2SaberModels( other );
+			}
+			else
+			{
+				G_CreateG2AttachedWeaponModel( other, weaponData[ent->item->giTag].weaponMdl, other->handRBolt, 0 );
+			}
+		}
+	}
+
+	if ( quantity )
+	{
+		// Give ammo
+		Add_Ammo( other, ent->item->giTag, quantity );
+	}
+	return 5;
+}
+
+
+//======================================================================
+
+int ITM_AddHealth (gentity_t *ent, int count) 
+{
+	
+	ent->health += count;
+
+	if (ent->health > ent->client->ps.stats[STAT_MAX_HEALTH])	// Past max health
+	{
+		ent->health = ent->client->ps.stats[STAT_MAX_HEALTH];
+
+		return qfalse;
+	}
+
+	return qtrue;
+
+}
+
+int Pickup_Health (gentity_t *ent, gentity_t *other) {
+	int			max;
+	int			quantity;
+
+	max = other->client->ps.stats[STAT_MAX_HEALTH];
+
+	if ( ent->count ) {
+		quantity = ent->count;
+	} else {
+		quantity = ent->item->quantity;
+	}
+
+	other->health += quantity;
+
+	if (other->health > max ) {
+		other->health = max;
+	}
+
+	if ( ent->item->giTag == 100 ) {		// mega health respawns slow
+		return 120;
+	}
+
+	return 30;
+}
+
+//======================================================================
+
+int ITM_AddArmor (gentity_t *ent, int count) 
+{
+	
+	ent->client->ps.stats[STAT_ARMOR] += count;
+
+	if (ent->client->ps.stats[STAT_ARMOR] > ent->client->ps.stats[STAT_MAX_HEALTH]) 
+	{
+		ent->client->ps.stats[STAT_ARMOR] = ent->client->ps.stats[STAT_MAX_HEALTH];
+		return qfalse;
+	}
+
+	return qtrue;
+}
+
+
+int Pickup_Armor( gentity_t *ent, gentity_t *other ) {
+
+	// make sure that the shield effect is on
+	other->client->ps.powerups[PW_BATTLESUIT] = Q3_INFINITE;
+
+	other->client->ps.stats[STAT_ARMOR] += ent->item->quantity;
+	if ( other->client->ps.stats[STAT_ARMOR] > other->client->ps.stats[STAT_MAX_HEALTH] ) {
+		other->client->ps.stats[STAT_ARMOR] = other->client->ps.stats[STAT_MAX_HEALTH];
+	}
+
+	return 30;
+}
+
+
+
+//======================================================================
+
+int Pickup_Holocron( gentity_t *ent, gentity_t *other )
+{
+	int forcePower = ent->item->giTag;
+	int forceLevel = ent->count;
+	// check if out of range
+	if( forceLevel < 0 || forceLevel >= NUM_FORCE_POWER_LEVELS )
+	{
+		gi.Printf(" Pickup_Holocron : count %d not in valid range\n", forceLevel );
+		return 1;
+	}
+	 
+	// don't pick up if already known AND your level is higher than pickup level
+	if ( ( other->client->ps.forcePowersKnown & ( 1 << forcePower )) )
+	{
+		//don't pickup if item is lower than current level
+		if( other->client->ps.forcePowerLevel[forcePower] >= forceLevel )
+		{
+			return 1;
+		}
+	}
+
+	other->client->ps.forcePowerLevel[forcePower] = forceLevel;
+	other->client->ps.forcePowersKnown |= ( 1 << forcePower );
+	
+	missionInfo_Updated = qtrue;	// Activate flashing text
+	gi.cvar_set("cg_updatedDataPadForcePower1", va("%d",forcePower+1)); // The +1 is offset in the print routine. 
+	cg_updatedDataPadForcePower1.integer = forcePower+1;
+	gi.cvar_set("cg_updatedDataPadForcePower2", "0"); // The +1 is offset in the print routine. 
+	cg_updatedDataPadForcePower2.integer = 0;
+	gi.cvar_set("cg_updatedDataPadForcePower3", "0"); // The +1 is offset in the print routine. 
+	cg_updatedDataPadForcePower3.integer = 0;
+	
+	return 1;
+}
+
+
+//======================================================================
+
+/*
+===============
+RespawnItem
+===============
+*/
+void RespawnItem( gentity_t *ent ) {
+}
+
+
+qboolean CheckItemCanBePickedUpByNPC( gentity_t *item, gentity_t *pickerupper )
+{
+	if ( (item->flags&FL_DROPPED_ITEM) 
+		&& item->activator != &g_entities[0] 
+		&& pickerupper->s.number 
+		&& pickerupper->s.weapon == WP_NONE 
+		&& pickerupper->enemy 
+		&& pickerupper->painDebounceTime < level.time
+		&& pickerupper->NPC && pickerupper->NPC->surrenderTime < level.time //not surrendering
+		&& !(pickerupper->NPC->scriptFlags&SCF_FORCED_MARCH) //not being forced to march
+		&& item->item->giTag != INV_SECURITY_KEY )
+	{//non-player, in combat, picking up a dropped item that does NOT belong to the player and it *not* a security key
+		if ( level.time - item->s.time < 3000 )//was 5000
+		{
+			return qfalse;
+		}
+		return qtrue;
+	}
+	return qfalse;
+}
+
+qboolean G_CanPickUpWeapons( gentity_t *other )
+{
+	if ( !other || !other->client )
+	{
+		return qfalse;
+	}
+	switch ( other->client->NPC_class )
+	{
+	case CLASS_ATST:
+	case CLASS_GONK: 
+	case CLASS_MARK1: 
+	case CLASS_MARK2: 
+	case CLASS_MOUSE: 
+	case CLASS_PROBE: 
+	case CLASS_PROTOCOL: 
+	case CLASS_R2D2: 
+	case CLASS_R5D2: 
+	case CLASS_SEEKER: 
+	case CLASS_REMOTE: 
+	case CLASS_RANCOR: 
+	case CLASS_WAMPA: 
+	case CLASS_JAWA: //FIXME: in some cases it's okay?
+	case CLASS_UGNAUGHT: //FIXME: in some cases it's okay?
+	case CLASS_SENTRY:
+		return qfalse;
+		break;
+	}
+	return qtrue;
+}
+/*
+===============
+Touch_Item
+===============
+*/
+extern cvar_t		*g_timescale;
+void Touch_Item (gentity_t *ent, gentity_t *other, trace_t *trace) {
+	int			respawn = 0;
+
+	if (!other->client)
+		return;
+	if (other->health < 1)
+		return;		// dead people can't pickup
+
+	if ( other->client->ps.pm_time > 0 )
+	{//cant pick up when out of control
+		return;
+	}
+
+	// NPCs can pick it up
+	if ((ent->spawnflags &  ITMSF_ALLOWNPC) && (!other->s.number))
+	{
+		return;
+	}
+
+	// Players cannot pick it up
+	if ( (ent->spawnflags &  ITMSF_NOPLAYER) && (other->s.number) )
+	{
+		return;
+	}
+
+	if ( ent->noDamageTeam != TEAM_FREE && other->client->playerTeam != ent->noDamageTeam )
+	{//only one team can pick it up
+		return;
+	}
+	
+	if ( !G_CanPickUpWeapons( other ) )
+	{//FIXME: some flag would be better
+		//droids can't pick up items/weapons!
+		return;
+	}
+
+	//FIXME: need to make them run toward a dropped weapon when fleeing without one?
+	//FIXME: need to make them come out of flee mode when pick up their old weapon?
+	if ( CheckItemCanBePickedUpByNPC( ent, other ) )
+	{
+		if ( other->NPC && other->NPC->goalEntity && other->NPC->goalEntity == ent )
+		{//they were running to pick me up, they did, so clear goal
+			other->NPC->goalEntity	= NULL;
+			other->NPC->squadState	= SQUAD_STAND_AND_SHOOT;
+ 			NPCInfo->tempBehavior	= BS_DEFAULT;
+			TIMER_Set(other, "flee", -1); 
+		}
+		else
+		{
+			return;
+		}
+	}
+	else if ( !(ent->spawnflags &  ITMSF_ALLOWNPC) )
+	{// NPCs cannot pick it up
+		if ( other->s.number != 0 )
+		{// Not the player?
+			return;
+		}
+	}
+
+	// the same pickup rules are used for client side and server side
+	if ( !BG_CanItemBeGrabbed( &ent->s, &other->client->ps ) ) {
+		return;
+	}
+
+	if ( other->client )
+	{
+		if ( (other->client->ps.eFlags&EF_FORCE_GRIPPED) || (other->client->ps.eFlags&EF_FORCE_DRAINED) )
+		{//can't pick up anything while being gripped
+			return;
+		}
+		if ( PM_InKnockDown( &other->client->ps ) && !PM_InGetUp( &other->client->ps ) )
+		{//can't pick up while in a knockdown
+			return;
+		}
+	}
+	if (!ent->item) {		//not an item!
+		gi.Printf( "Touch_Item: %s is not an item!\n", ent->classname);
+		return;
+	}
+	qboolean bHadWeapon = qfalse;
+	// call the item-specific pickup function
+	switch( ent->item->giType ) 
+	{
+	case IT_WEAPON:
+		if ( other->NPC && other->s.weapon == WP_NONE )
+		{//Make them duck and sit here for a few seconds
+			int pickUpTime = Q_irand( 1000, 3000 );
+			TIMER_Set( other, "duck", pickUpTime );
+			TIMER_Set( other, "roamTime", pickUpTime );
+			TIMER_Set( other, "stick", pickUpTime );
+			TIMER_Set( other, "verifyCP", pickUpTime );
+			TIMER_Set( other, "attackDelay", 600 );
+			respawn = 0;
+		}
+		if ( other->client->ps.stats[STAT_WEAPONS] & ( 1 << ent->item->giTag ) )
+		{
+			bHadWeapon = qtrue;
+		}
+		respawn = Pickup_Weapon(ent, other);
+		break;
+	case IT_AMMO:
+		respawn = Pickup_Ammo(ent, other);
+		break;
+	case IT_ARMOR:
+		respawn = Pickup_Armor(ent, other);
+		break;
+	case IT_HEALTH:
+		respawn = Pickup_Health(ent, other);
+		break;
+	case IT_HOLDABLE:
+		respawn = Pickup_Holdable(ent, other);
+		break;
+	case IT_BATTERY:
+		respawn = Pickup_Battery( ent, other );
+		break;
+	case IT_HOLOCRON:
+		respawn = Pickup_Holocron( ent, other );
+		break;
+	default:
+		return;
+	}
+
+	if ( !respawn ) 
+	{
+		return;
+	}
+
+	// play the normal pickup sound
+	if ( !other->s.number && g_timescale->value < 1.0f  )
+	{//SIGH... with timescale on, you lose events left and right
+extern void CG_ItemPickup( int itemNum, qboolean bHadItem );
+		// but we're SP so we'll cheat
+		cgi_S_StartSound( NULL, other->s.number, CHAN_AUTO,	cgi_S_RegisterSound( ent->item->pickup_sound ) );
+		// show icon and name on status bar
+		CG_ItemPickup( ent->s.modelindex, bHadWeapon );
+	}
+	else
+	{
+		if ( bHadWeapon )
+		{
+			G_AddEvent( other, EV_ITEM_PICKUP, -ent->s.modelindex );
+		} 
+		else
+		{
+			G_AddEvent( other, EV_ITEM_PICKUP, ent->s.modelindex );
+		}
+	}
+
+	// fire item targets
+	G_UseTargets (ent, other);
+
+	// wait of -1 will not respawn
+//	if ( ent->wait == -1 ) 
+	{
+		//why not just remove me?
+		G_FreeEntity( ent );
+		/*
+		//NOTE: used to do this:  (for respawning?)
+		ent->svFlags |= SVF_NOCLIENT;
+		ent->s.eFlags |= EF_NODRAW;
+		ent->contents = 0;
+		ent->unlinkAfterEvent = qtrue;
+		*/
+		return;
+	}
+}
+
+
+//======================================================================
+
+/*
+================
+LaunchItem
+
+Spawns an item and tosses it forward
+================
+*/
+gentity_t *LaunchItem( gitem_t *item, const vec3_t origin, const vec3_t velocity, char *target ) {
+	gentity_t	*dropped;
+
+	dropped = G_Spawn();
+
+	dropped->s.eType = ET_ITEM;
+	dropped->s.modelindex = item - bg_itemlist;	// store item number in modelindex
+	dropped->s.modelindex2 = 1; // This is non-zero is it's a dropped item
+
+	dropped->classname = G_NewString(item->classname);	//copy it so it can be freed safely
+	dropped->item = item;
+
+	// try using the "correct" mins/maxs first
+	VectorSet( dropped->mins, item->mins[0], item->mins[1], item->mins[2] );
+	VectorSet( dropped->maxs, item->maxs[0], item->maxs[1], item->maxs[2] );
+
+	if ((!dropped->mins[0] && !dropped->mins[1] && !dropped->mins[2]) && 
+		(!dropped->maxs[0] && !dropped->maxs[1] && !dropped->maxs[2]))
+	{
+		VectorSet( dropped->maxs, ITEM_RADIUS, ITEM_RADIUS, ITEM_RADIUS );
+		VectorScale( dropped->maxs, -1, dropped->mins );
+	}
+
+	dropped->contents = CONTENTS_TRIGGER|CONTENTS_ITEM;//CONTENTS_TRIGGER;//not CONTENTS_BODY for dropped items, don't need to ID them
+
+	if ( target && target[0] )
+	{
+		dropped->target = G_NewString( target );
+	}
+	else
+	{
+		// if not targeting something, auto-remove after 30 seconds
+		// only if it's NOT a security or goodie key
+		if (dropped->item->giTag != INV_SECURITY_KEY )
+		{
+			dropped->e_ThinkFunc = thinkF_G_FreeEntity;
+			dropped->nextthink = level.time + 30000;
+		}
+
+		if ( dropped->item->giType == IT_AMMO && dropped->item->giTag == AMMO_FORCE )
+		{
+			dropped->nextthink = -1;
+			dropped->e_ThinkFunc = thinkF_NULL;
+		}
+	}
+
+	dropped->e_TouchFunc = touchF_Touch_Item;
+
+	if ( item->giType == IT_WEAPON )
+	{
+		// give weapon items zero pitch, a random yaw, and rolled onto their sides...but would be bad to do this for a bowcaster
+		if ( item->giTag != WP_BOWCASTER
+			&& item->giTag != WP_THERMAL
+			&& item->giTag != WP_TRIP_MINE
+			&& item->giTag != WP_DET_PACK )
+		{
+			VectorSet( dropped->s.angles, 0, crandom() * 180, 90.0f );
+			G_SetAngles( dropped, dropped->s.angles );
+		}
+	}
+
+	G_SetOrigin( dropped, origin );
+	dropped->s.pos.trType = TR_GRAVITY;
+	dropped->s.pos.trTime = level.time;
+	VectorCopy( velocity, dropped->s.pos.trDelta );
+
+	dropped->s.eFlags |= EF_BOUNCE_HALF;
+
+	dropped->flags = FL_DROPPED_ITEM;
+
+	gi.linkentity (dropped);
+
+	return dropped;
+}
+
+/*
+================
+Drop_Item
+
+Spawns an item and tosses it forward
+================
+*/
+gentity_t *Drop_Item( gentity_t *ent, gitem_t *item, float angle, qboolean copytarget ) {
+	gentity_t	*dropped = NULL;
+	vec3_t	velocity;
+	vec3_t	angles;
+
+	VectorCopy( ent->s.apos.trBase, angles );
+	angles[YAW] += angle;
+	angles[PITCH] = 0;	// always forward
+
+	AngleVectors( angles, velocity, NULL, NULL );
+	VectorScale( velocity, 150, velocity );
+	velocity[2] += 200 + crandom() * 50;
+	
+	if ( copytarget )
+	{
+		dropped = LaunchItem( item, ent->s.pos.trBase, velocity, ent->opentarget );
+	}
+	else
+	{
+		dropped = LaunchItem( item, ent->s.pos.trBase, velocity, NULL );
+	}
+
+	dropped->activator = ent;//so we know who we belonged to so they can pick it back up later
+	dropped->s.time = level.time;//mark this time so we aren't picked up instantly by the guy who dropped us
+	return dropped;
+}
+
+
+/*
+================
+Use_Item
+
+Respawn the item
+================
+*/
+void Use_Item( gentity_t *ent, gentity_t *other, gentity_t *activator ) 
+{
+	if ( (ent->svFlags&SVF_PLAYER_USABLE) && other && !other->s.number )
+	{//used directly by the player, pick me up
+		GEntity_TouchFunc( ent, other, NULL );
+	}
+	else
+	{//use me
+		if ( ent->spawnflags & 32 ) // invisible
+		{
+			// If it was invisible, first use makes it visible....
+			ent->s.eFlags &= ~EF_NODRAW;
+			ent->contents = CONTENTS_TRIGGER|CONTENTS_ITEM;
+
+			ent->spawnflags &= ~32;
+			return;
+		}
+
+		G_ActivateBehavior( ent, BSET_USE );
+		RespawnItem( ent );
+	}
+}
+
+//======================================================================
+
+/*
+================
+FinishSpawningItem
+
+Traces down to find where an item should rest, instead of letting them
+free fall from their spawn points
+================
+*/
+extern int delayedShutDown;
+extern cvar_t	*g_saber;
+void FinishSpawningItem( gentity_t *ent ) {
+	trace_t		tr;
+	vec3_t		dest;
+	gitem_t		*item;
+	int			itemNum;
+
+	itemNum=1;
+	for ( item = bg_itemlist + 1 ; item->classname ; item++,itemNum++) 
+	{
+		if (!strcmp(item->classname,ent->classname))
+		{
+			break;
+		}
+	}
+
+	// Set bounding box for item
+	VectorSet( ent->mins, item->mins[0],item->mins[1] ,item->mins[2]);
+	VectorSet( ent->maxs, item->maxs[0],item->maxs[1] ,item->maxs[2]);
+
+	if ((!ent->mins[0] && !ent->mins[1] && !ent->mins[2]) && 
+		(!ent->maxs[0] && !ent->maxs[1] && !ent->maxs[2]))
+	{
+		VectorSet (ent->mins, -ITEM_RADIUS, -ITEM_RADIUS, -2);//to match the comments in the items.dat file!
+		VectorSet (ent->maxs, ITEM_RADIUS, ITEM_RADIUS, ITEM_RADIUS);
+	}
+
+	if ((item->quantity) && (item->giType == IT_AMMO))
+	{
+		ent->count = item->quantity;
+	}
+
+	if ((item->quantity) && (item->giType == IT_BATTERY))
+	{
+		ent->count = item->quantity; 
+	}
+
+	ent->s.radius = 20;
+	VectorSet( ent->s.modelScale, 1.0f, 1.0f, 1.0f );
+
+	if ( ent->item->giType == IT_WEAPON
+		&& ent->item->giTag == WP_SABER
+		&& ent->NPC_type
+		&& ent->NPC_type[0]
+		&& Q_stricmp( "player", ent->NPC_type ) == 0
+		&& g_saber->string
+		&& g_saber->string[0]
+		&& Q_stricmp( "none", g_saber->string )
+		&& Q_stricmp( "NULL", g_saber->string ) )
+	{//player's saber
+		saberInfo_t itemSaber;
+		WP_SaberParseParms( g_saber->string, &itemSaber );
+		//NOTE:  should I keep this string around for any reason?  Will I ever need it later?
+		//ent->??? = G_NewString( itemSaber.model );
+		gi.G2API_InitGhoul2Model( ent->ghoul2, itemSaber.model, G_ModelIndex( itemSaber.model ));
+		WP_SaberFreeStrings(itemSaber);
+	}
+	else
+	{
+		gi.G2API_InitGhoul2Model( ent->ghoul2, ent->item->world_model, G_ModelIndex( ent->item->world_model ));
+	}
+
+	// Set crystal ammo amount based on skill level
+/*	if ((itemNum == ITM_AMMO_CRYSTAL_BORG) ||
+		(itemNum == ITM_AMMO_CRYSTAL_DN) ||
+		(itemNum == ITM_AMMO_CRYSTAL_FORGE) ||
+		(itemNum == ITM_AMMO_CRYSTAL_SCAVENGER) ||
+		(itemNum == ITM_AMMO_CRYSTAL_STASIS))
+	{
+		CrystalAmmoSettings(ent);
+	}
+*/
+	ent->s.eType = ET_ITEM;
+	ent->s.modelindex = ent->item - bg_itemlist;		// store item number in modelindex
+	ent->s.modelindex2 = 0; // zero indicates this isn't a dropped item
+
+	ent->contents = CONTENTS_TRIGGER|CONTENTS_ITEM;//CONTENTS_BODY;//CONTENTS_TRIGGER|
+	ent->e_TouchFunc = touchF_Touch_Item;
+	// useing an item causes it to respawn
+	ent->e_UseFunc = useF_Use_Item;
+	ent->svFlags |= SVF_PLAYER_USABLE;//so player can pick it up
+
+	// Hang in air?
+	ent->s.origin[2] += 1;//just to get it off the damn ground because coplanar = insolid
+	if ( ent->spawnflags & ITMSF_SUSPEND) 
+	{
+		// suspended
+		G_SetOrigin( ent, ent->s.origin );
+	} 
+	else 
+	{
+		// drop to floor
+		VectorSet( dest, ent->s.origin[0], ent->s.origin[1], MIN_WORLD_COORD );
+		gi.trace( &tr, ent->s.origin, ent->mins, ent->maxs, dest, ent->s.number, MASK_SOLID|CONTENTS_PLAYERCLIP );
+		if ( tr.startsolid ) 
+		{
+			if ( &g_entities[tr.entityNum] != NULL )
+			{
+				gi.Printf (S_COLOR_RED"FinishSpawningItem: removing %s startsolid at %s (in a %s)\n", ent->classname, vtos(ent->s.origin), g_entities[tr.entityNum].classname );
+			}
+			else
+			{
+				gi.Printf (S_COLOR_RED"FinishSpawningItem: removing %s startsolid at %s (in a %s)\n", ent->classname, vtos(ent->s.origin) );
+			}
+			assert( 0 && "item starting in solid");
+			if (!g_entities[ENTITYNUM_WORLD].s.radius){	//not a region
+				delayedShutDown = level.time + 100;
+			}
+			G_FreeEntity( ent );
+			return;
+		}
+
+		// allow to ride movers
+		ent->s.groundEntityNum = tr.entityNum;
+
+		G_SetOrigin( ent, tr.endpos );
+	}
+
+/* ? don't need this
+	// team slaves and targeted items aren't present at start
+	if ( ( ent->flags & FL_TEAMSLAVE ) || ent->targetname ) {
+		ent->s.eFlags |= EF_NODRAW;
+		ent->contents = 0;
+		return;
+	}
+*/
+	if ( ent->spawnflags & ITMSF_INVISIBLE ) // invisible
+	{
+		ent->s.eFlags |= EF_NODRAW;
+		ent->contents = 0;
+	}
+
+	if ( ent->spawnflags & ITMSF_NOTSOLID ) // not solid
+	{
+		ent->contents = 0;
+	}
+
+	gi.linkentity (ent);
+}
+
+
+char itemRegistered[MAX_ITEMS+1];
+
+
+/*
+==============
+ClearRegisteredItems
+==============
+*/
+void ClearRegisteredItems( void ) {
+	memset( itemRegistered, '0', bg_numItems );
+	itemRegistered[ bg_numItems ] = 0;
+
+	//these are given in g_client, ClientSpawn(), but MUST be registered HERE, BEFORE cgame starts.
+	//RegisterItem( FindItemForWeapon( WP_NONE ) );	//has no item
+	RegisterItem( FindItemForInventory( INV_ELECTROBINOCULARS ));
+	//RegisterItem( FindItemForInventory( INV_BACTA_CANISTER ));
+	// saber or baton is cached in SP_info_player_deathmatch now.
+
+extern void Player_CacheFromPrevLevel(void);//g_client.cpp
+	Player_CacheFromPrevLevel();	//reads from transition carry-over;
+}
+
+/*
+===============
+RegisterItem
+
+The item will be added to the precache list
+===============
+*/
+void RegisterItem( gitem_t *item ) {
+	if ( !item ) {
+		G_Error( "RegisterItem: NULL" );
+	}
+	itemRegistered[ item - bg_itemlist ] = '1';
+	gi.SetConfigstring(CS_ITEMS, itemRegistered);	//Write the needed items to a config string
+}
+
+
+/*
+===============
+SaveRegisteredItems
+
+Write the needed items to a config string
+so the client will know which ones to precache
+===============
+*/
+void SaveRegisteredItems( void ) {
+/*	char	string[MAX_ITEMS+1];
+	int		i;
+	int		count;
+
+	count = 0;
+	for ( i = 0 ; i < bg_numItems ; i++ ) {
+		if ( itemRegistered[i] ) {
+			count++;
+			string[i] = '1';
+		} else {
+			string[i] = '0';
+		}
+	}
+	string[ bg_numItems ] = 0;
+
+	gi.Printf( "%i items registered\n", count );
+	gi.SetConfigstring(CS_ITEMS, string);
+*/
+	gi.SetConfigstring(CS_ITEMS, itemRegistered);
+}
+
+/*
+============
+item_spawn_use
+
+ if an item is given a targetname, it will be spawned in when used
+============
+*/
+void item_spawn_use( gentity_t *self, gentity_t *other, gentity_t *activator )
+//-----------------------------------------------------------------------------
+{
+	self->nextthink = level.time + 50;
+	self->e_ThinkFunc = thinkF_FinishSpawningItem;
+	// I could be fancy and add a count or something like that to be able to spawn the item numerous times...
+	self->e_UseFunc = NULL;
+}
+
+/*
+============
+G_SpawnItem
+
+Sets the clipping size and plants the object on the floor.
+
+Items can't be immediately dropped to floor, because they might
+be on an entity that hasn't spawned yet.
+============
+*/
+void G_SpawnItem (gentity_t *ent, gitem_t *item) {
+	G_SpawnFloat( "random", "0", &ent->random );
+	G_SpawnFloat( "wait", "0", &ent->wait );
+
+	RegisterItem( item );
+	ent->item = item;
+
+	// targetname indicates they want to spawn it later
+	if( ent->targetname )
+	{
+		ent->e_UseFunc = useF_item_spawn_use;
+	}
+	else
+	{	// some movers spawn on the second frame, so delay item
+		// spawns until the third frame so they can ride trains
+		ent->nextthink = level.time + START_TIME_MOVERS_SPAWNED + 50;
+		ent->e_ThinkFunc = thinkF_FinishSpawningItem;
+	}
+
+	ent->physicsBounce = 0.50;		// items are bouncy
+
+	// Set a default infoString text color
+	// NOTE: if we want to do cool cross-hair colors for items, we can just modify this, but for now, don't do it
+	VectorSet( ent->startRGBA, 1.0f, 1.0f, 1.0f );
+
+	if ( ent->team && ent->team[0] )
+	{
+		ent->noDamageTeam = (team_t)GetIDForString( TeamTable, ent->team );
+		if ( ent->noDamageTeam == TEAM_FREE )
+		{
+			G_Error("team name %s not recognized\n", ent->team);
+		}
+	}
+	ent->team = NULL;
+}
+
+
+/*
+================
+G_BounceItem
+
+================
+*/
+void G_BounceItem( gentity_t *ent, trace_t *trace ) {
+	vec3_t	velocity;
+	float	dot;
+	int		hitTime;
+
+	// reflect the velocity on the trace plane
+	hitTime = level.previousTime + ( level.time - level.previousTime ) * trace->fraction;
+	EvaluateTrajectoryDelta( &ent->s.pos, hitTime, velocity );
+	dot = DotProduct( velocity, trace->plane.normal );
+	VectorMA( velocity, -2*dot, trace->plane.normal, ent->s.pos.trDelta );
+
+	// cut the velocity to keep from bouncing forever
+	VectorScale( ent->s.pos.trDelta, ent->physicsBounce, ent->s.pos.trDelta );
+
+	// check for stop
+	if ( trace->plane.normal[2] > 0 && ent->s.pos.trDelta[2] < 40 ) {
+		G_SetOrigin( ent, trace->endpos );
+		ent->s.groundEntityNum = trace->entityNum;
+		return;
+	}
+
+	VectorAdd( ent->currentOrigin, trace->plane.normal, ent->currentOrigin);
+	VectorCopy( ent->currentOrigin, ent->s.pos.trBase );
+	ent->s.pos.trTime = level.time;
+}
+
+
+/*
+================
+G_RunItem
+
+================
+*/
+void G_RunItem( gentity_t *ent ) {
+	vec3_t		origin;
+	trace_t		tr;
+	int			contents;
+	int			mask;
+
+	// if groundentity has been set to -1, it may have been pushed off an edge
+	if ( ent->s.groundEntityNum == ENTITYNUM_NONE ) 
+	{
+		if ( ent->s.pos.trType != TR_GRAVITY ) 
+		{
+			ent->s.pos.trType = TR_GRAVITY;
+			ent->s.pos.trTime = level.time;
+		}
+	}
+
+	if ( ent->s.pos.trType == TR_STATIONARY ) 
+	{
+		// check think function
+		G_RunThink( ent );
+		if ( !g_gravity->value )
+		{
+			ent->s.pos.trType = TR_GRAVITY;
+			ent->s.pos.trTime = level.time;
+			ent->s.pos.trDelta[0] += crandom() * 40.0f; // I dunno, just do this??
+			ent->s.pos.trDelta[1] += crandom() * 40.0f;
+			ent->s.pos.trDelta[2] += random() * 20.0f;
+		}
+		return;
+	}
+
+	// get current position
+	EvaluateTrajectory( &ent->s.pos, level.time, origin );
+
+	// trace a line from the previous position to the current position
+	if ( ent->clipmask ) 
+	{
+		mask = ent->clipmask;
+	} 
+	else 
+	{
+		mask = MASK_SOLID|CONTENTS_PLAYERCLIP;//shouldn't be able to get anywhere player can't
+	}
+
+	int ignore = ENTITYNUM_NONE;
+	if ( ent->owner )
+	{
+		ignore = ent->owner->s.number;
+	}
+	else if ( ent->activator )
+	{
+		ignore = ent->activator->s.number;
+	}
+	gi.trace( &tr, ent->currentOrigin, ent->mins, ent->maxs, origin, ignore, mask );
+
+	VectorCopy( tr.endpos, ent->currentOrigin );
+
+	if ( tr.startsolid ) 
+	{
+		tr.fraction = 0;
+	}
+
+	gi.linkentity( ent );	// FIXME: avoid this for stationary?
+
+	// check think function
+	G_RunThink( ent );
+
+	if ( tr.fraction == 1 ) 
+	{
+		if ( g_gravity->value <= 0 )
+		{
+			if ( ent->s.apos.trType != TR_LINEAR )
+			{
+				VectorCopy( ent->currentAngles, ent->s.apos.trBase );
+				ent->s.apos.trType = TR_LINEAR;
+				ent->s.apos.trDelta[1] = Q_flrand( -300, 300 );
+				ent->s.apos.trDelta[0] = Q_flrand( -10, 10 );
+				ent->s.apos.trDelta[2] = Q_flrand( -10, 10 );
+				ent->s.apos.trTime = level.time;
+			}
+		}
+		//friction in zero-G
+		if ( !g_gravity->value )
+		{
+			float friction = 0.975f;
+			/*friction -= ent->mass/1000.0f;
+			if ( friction < 0.1 )
+			{
+				friction = 0.1f;
+			}
+			*/
+			VectorScale( ent->s.pos.trDelta, friction, ent->s.pos.trDelta );
+			VectorCopy( ent->currentOrigin, ent->s.pos.trBase );
+			ent->s.pos.trTime = level.time;
+		}
+		return;
+	}
+
+	// if it is in a nodrop volume, remove it
+	contents = gi.pointcontents( ent->currentOrigin, -1 );
+	if ( contents & CONTENTS_NODROP ) 
+	{
+		G_FreeEntity( ent );
+		return;
+	}
+
+	if ( !tr.startsolid )
+	{
+		G_BounceItem( ent, &tr );
+	}
+}
+
+/*
+================
+ItemUse_Bacta
+
+================
+*/
+void ItemUse_Bacta(gentity_t *ent)
+{
+	if (!ent || !ent->client)
+	{
+		return;
+	}
+
+	if (ent->health >= ent->client->ps.stats[STAT_MAX_HEALTH] || !ent->client->ps.inventory[INV_BACTA_CANISTER] )
+	{
+		return;
+	}
+
+	ent->health += MAX_BACTA_HEAL_AMOUNT;
+
+	if (ent->health > ent->client->ps.stats[STAT_MAX_HEALTH])
+	{
+		ent->health = ent->client->ps.stats[STAT_MAX_HEALTH];
+	}
+
+	ent->client->ps.inventory[INV_BACTA_CANISTER]--;
+
+	G_SoundOnEnt( ent, CHAN_VOICE, va( "sound/weapons/force/heal%d_%c.mp3", Q_irand( 1, 4 ), g_sex->string[0] ) );
+}
diff --git a/code/game/g_items.h b/code/game/g_items.h
new file mode 100644
index 0000000..9522506
--- /dev/null
+++ b/code/game/g_items.h
@@ -0,0 +1,94 @@
+//g_items.h
+
+#ifndef __ITEMS_H__
+#define __ITEMS_H__
+
+// Items enums
+typedef enum 
+{
+ITM_NONE,
+
+ITM_SABER_PICKUP,
+ITM_BLASTER_PISTOL_PICKUP,
+ITM_BLASTER_PICKUP,
+ITM_DISRUPTOR_PICKUP,
+ITM_BOWCASTER_PICKUP,
+ITM_REPEATER_PICKUP,
+ITM_DEMP2_PICKUP,
+ITM_FLECHETTE_PICKUP,
+ITM_CONCUSSION_RIFLE_PICKUP,
+ITM_ROCKET_LAUNCHER_PICKUP,
+ITM_THERMAL_DET_PICKUP,
+ITM_TRIP_MINE_PICKUP,
+ITM_DET_PACK_PICKUP,
+ITM_STUN_BATON_PICKUP,
+ITM_MELEE,
+
+ITM_BRYAR_PISTOL_PICKUP,
+ITM_EMPLACED_GUN_PICKUP,
+ITM_BOT_LASER_PICKUP,
+ITM_TURRET_PICKUP,
+ITM_ATST_MAIN_PICKUP,
+ITM_ATST_SIDE_PICKUP,
+ITM_TIE_FIGHTER_PICKUP,
+ITM_RAPID_FIRE_CONC_PICKUP,
+ITM_JAWA_PICKUP,
+ITM_TUSKEN_RIFLE_PICKUP,
+ITM_TUSKEN_STAFF_PICKUP,
+ITM_SCEPTER_PICKUP,
+ITM_NOGHRI_STICK_PICKUP,
+
+ITM_AMMO_FORCE_PICKUP,
+ITM_AMMO_BLASTER_PICKUP,
+ITM_AMMO_POWERCELL_PICKUP,
+ITM_AMMO_METAL_BOLTS_PICKUP,
+ITM_AMMO_ROCKETS_PICKUP,
+ITM_AMMO_EMPLACED_PICKUP,
+ITM_AMMO_THERMAL_PICKUP,
+ITM_AMMO_TRIPMINE_PICKUP,
+ITM_AMMO_DETPACK_PICKUP,
+
+ITM_FORCE_HEAL_PICKUP,
+ITM_FORCE_LEVITATION_PICKUP,
+ITM_FORCE_SPEED_PICKUP,
+ITM_FORCE_PUSH_PICKUP,
+ITM_FORCE_PULL_PICKUP,
+ITM_FORCE_TELEPATHY_PICKUP,
+ITM_FORCE_GRIP_PICKUP,
+ITM_FORCE_LIGHTNING_PICKUP,
+ITM_FORCE_SABERTHROW_PICKUP,
+
+ITM_BATTERY_PICKUP,
+ITM_SEEKER_PICKUP,
+ITM_SHIELD_PICKUP,
+ITM_BACTA_PICKUP,
+ITM_DATAPAD_PICKUP,
+ITM_BINOCULARS_PICKUP,
+ITM_SENTRY_GUN_PICKUP,
+ITM_LA_GOGGLES_PICKUP,
+
+ITM_MEDPAK_PICKUP,
+ITM_SHIELD_SM_PICKUP,
+ITM_SHIELD_LRG_PICKUP,
+ITM_GOODIE_KEY_PICKUP,
+ITM_SECURITY_KEY_PICKUP,
+
+ITM_NUM_ITEMS
+}; 
+
+// Inventory item enums
+typedef enum //# item_e
+{
+	INV_ELECTROBINOCULARS,
+	INV_BACTA_CANISTER,
+	INV_SEEKER,
+	INV_LIGHTAMP_GOGGLES,
+	INV_SENTRY,		
+	//# #eol
+	INV_GOODIE_KEY,	// don't want to include keys in the icarus list
+	INV_SECURITY_KEY,
+
+	INV_MAX						// Be sure to update MAX_INVENTORY
+};
+
+#endif
diff --git a/code/game/g_local.h b/code/game/g_local.h
new file mode 100644
index 0000000..3efaf18
--- /dev/null
+++ b/code/game/g_local.h
@@ -0,0 +1,627 @@
+#ifndef __G_LOCAL_H__
+#define __G_LOCAL_H__
+// g_local.h -- local definitions for game module
+
+// define GAME_INCLUDE so that g_public.h does not define the
+// short, server-visible gclient_t and gentity_t structures,
+// because we define the full size ones in this file
+#define	GAME_INCLUDE
+#include "../ui/gameinfo.h"
+#include "g_shared.h"
+#include "anims.h"
+#include "dmstates.h"
+
+//==================================================================
+
+// the "gameversion" client command will print this plus compile date
+#define	GAMEVERSION	"base"
+
+#define BODY_QUEUE_SIZE		8
+
+#define Q3_INFINITE			16777216 
+
+#define	FRAMETIME			100					// msec
+#define	EVENT_VALID_MSEC	300
+#define	CARNAGE_REWARD_TIME	3000
+
+#define	INTERMISSION_DELAY_TIME	1000
+
+#define	START_TIME_LINK_ENTS		FRAMETIME*1 // time-delay after map start at which all ents have been spawned, so can link them
+#define	START_TIME_FIND_LINKS		FRAMETIME*2 // time-delay after map start at which you can find linked entities
+#define	START_TIME_MOVERS_SPAWNED	FRAMETIME*2 // time-delay after map start at which all movers should be spawned
+#define	START_TIME_REMOVE_ENTS		FRAMETIME*3 // time-delay after map start to remove temporary ents
+#define	START_TIME_NAV_CALC			FRAMETIME*4 // time-delay after map start to connect waypoints and calc routes
+#define	START_TIME_FIND_WAYPOINT	FRAMETIME*5 // time-delay after map start after which it's okay to try to find your best waypoint
+
+// gentity->flags
+#define	FL_SHIELDED				0x00000001	// protected from all damage except lightsabers
+#define FL_DMG_BY_HEAVY_WEAP_ONLY	0x00000002	// protected from all damage except heavy weap class missiles
+#define	FL_DMG_BY_SABER_ONLY	0x00000004	//protected from all damage except saber damage
+#define	FL_GODMODE				0x00000010
+#define	FL_NOTARGET				0x00000020
+#define	FL_TEAMSLAVE			0x00000400	// not the first on the team
+#define FL_NO_KNOCKBACK			0x00000800
+#define FL_DROPPED_ITEM			0x00001000
+#define	FL_DONT_SHOOT			0x00002000	// Can target him, but not shoot him
+#define	FL_UNDYING				0x00004000	// Takes damage down to 1 point, but does not die
+//#define FL_OVERCHARGED			0x00008000	// weapon shot is an overcharged version....probably a lame place to be putting this flag...
+#define FL_LOCK_PLAYER_WEAPONS	0x00010000	// player can't switch weapons... ask james if there's a better spot for this
+#define FL_DISINTEGRATED		0x00020000	// marks that the corpse has already been disintegrated
+#define FL_FORCE_PULLABLE_ONLY	0x00040000	// cannot be force pushed
+#define FL_NO_IMPACT_DMG		0x00080000	// Will not take impact damage
+#define FL_OVERCHARGED_HEALTH	0x00100000	// Reduce health back to max
+#define FL_NO_ANGLES			0x00200000	// No bone angle overrides, no pitch or roll in full angles
+#define FL_RED_CROSSHAIR		0x00400000	// Crosshair red on me
+
+
+//Pointer safety utilities
+#define VALID( a )		( a != NULL )
+#define	VALIDATE( a )	( assert( a ) )
+
+#define	VALIDATEV( a )	if ( a == NULL ) {	assert(0);	return;			}
+#define	VALIDATEB( a )	if ( a == NULL ) {	assert(0);	return qfalse;	}
+#define VALIDATEP( a )	if ( a == NULL ) {	assert(0);	return NULL;	}
+
+#define VALIDSTRING( a )	( ( a != NULL ) && ( a[0] != NULL ) )
+
+//animations
+typedef struct
+{
+	char			filename[MAX_QPATH];
+	animation_t		animations[MAX_ANIMATIONS];
+	animevent_t		torsoAnimEvents[MAX_ANIM_EVENTS];
+	animevent_t		legsAnimEvents[MAX_ANIM_EVENTS];
+	unsigned char	torsoAnimEventCount;
+	unsigned char	legsAnimEventCount;
+} animFileSet_t;
+
+extern stringID_table_t animTable [MAX_ANIMATIONS+1];
+
+//Interest points
+
+#define MAX_INTEREST_POINTS		64
+
+typedef struct 
+{
+	vec3_t		origin;
+	char		*target;
+} interestPoint_t;
+
+//Combat points
+
+#define MAX_COMBAT_POINTS		512
+
+typedef struct 
+{
+	vec3_t		origin;
+	int			flags;
+//	char		*NPC_targetname;
+//	team_t		team;
+	qboolean	occupied;
+	int			waypoint;
+	int			dangerTime;
+} combatPoint_t;
+
+// Alert events
+
+#define	MAX_ALERT_EVENTS	32
+
+enum alertEventType_e
+{
+	AET_SIGHT,
+	AET_SOUND,
+};
+
+enum alertEventLevel_e
+{
+	AEL_MINOR,			//Enemy responds to the sound, but only by looking
+	AEL_SUSPICIOUS,		//Enemy looks at the sound, and will also investigate it
+	AEL_DISCOVERED,		//Enemy knows the player is around, and will actively hunt
+	AEL_DANGER,			//Enemy should try to find cover
+	AEL_DANGER_GREAT,	//Enemy should run like hell!
+};
+
+// !!!!!!!!! LOADSAVE-affecting struct !!!!!!!!!!
+typedef struct alertEvent_s
+{
+	vec3_t				position;	//Where the event is located
+	float				radius;		//Consideration radius
+	alertEventLevel_e	level;		//Priority level of the event
+	alertEventType_e	type;		//Event type (sound,sight)
+	gentity_t			*owner;		//Who made the sound
+	float				light;		//ambient light level at point
+	float				addLight;	//additional light- makes it more noticable, even in darkness
+	int					ID;			//unique... if get a ridiculous number, this will repeat, but should not be a problem as it's just comparing it to your lastAlertID
+	int					timestamp;	//when it was created
+	qboolean			onGround;	//alert is on the ground (only used for sounds)
+} alertEvent_t;
+
+//
+// this structure is cleared as each map is entered
+//
+
+#define	MAX_SPAWN_VARS			64
+#define	MAX_SPAWN_VARS_CHARS	2048
+
+typedef struct
+{
+	char	targetname[MAX_QPATH];
+	char	target[MAX_QPATH];
+	char	target2[MAX_QPATH];
+	char	target3[MAX_QPATH];
+	char	target4[MAX_QPATH];
+	int		nodeID;
+} waypointData_t;
+
+#define	WF_RAINING		0x00000001	// raining
+#define	WF_SNOWING		0x00000002	// snowing
+#define	WF_PUFFING		0x00000004	// puffing something
+
+// !!!!!!!!!! LOADSAVE-affecting structure !!!!!!!!!!
+typedef struct 
+{
+	gclient_t	*clients;		// [maxclients]
+
+	// store latched cvars here that we want to get at often
+	int			maxclients;
+
+	int			framenum;
+	int			time;					// in msec
+	int			previousTime;			// so movers can back up when blocked
+
+	int			globalTime;				// global time at level initialization
+
+	char		mapname[MAX_QPATH];		// the server name (base1, etc)
+
+	qboolean	locationLinked;			// target_locations get linked
+	gentity_t	*locationHead;			// head of the location list
+
+	alertEvent_t	alertEvents[ MAX_ALERT_EVENTS ];
+	int				numAlertEvents;
+	int				curAlertID;
+
+	AIGroupInfo_t	groups[MAX_FRAME_GROUPS];
+
+	animFileSet_t	knownAnimFileSets[MAX_ANIM_FILES];
+	int				numKnownAnimFileSets;
+
+	int				worldFlags;
+
+	int				dmState;		//actually, we do want save/load the dynamic music state
+// =====================================
+//
+// NOTE!!!!!!   The only things beyond this point in the structure should be the ones you do NOT wish to be
+//					affected by loading saved-games. Since loading a game first starts the map and then loads
+//					over things like entities etc then these fields are usually the ones setup by the map loader.
+//					If they ever get modified in-game let me know and I'll include them in the save. -Ste
+//
+#define LEVEL_LOCALS_T_SAVESTOP logFile	// name of whichever field is next below this in the source
+
+	fileHandle_t	logFile;
+
+	//Interest points- squadmates automatically look at these if standing around and close to them
+	interestPoint_t	interestPoints[MAX_INTEREST_POINTS];
+	int			numInterestPoints;
+
+	//Combat points- NPCs in bState BS_COMBAT_POINT will find their closest empty combat_point
+	combatPoint_t	combatPoints[MAX_COMBAT_POINTS];
+	int			numCombatPoints;
+	char		spawntarget[MAX_QPATH];		// the targetname of the spawnpoint you want the player to start at
+
+	int			dmDebounceTime;
+	int			dmBeatTime;
+
+	int			mNumBSPInstances;
+	int			mBSPInstanceDepth;
+	vec3_t		mOriginAdjust;
+	float		mRotationAdjust;
+	char		*mTargetAdjust;
+	qboolean	hasBspInstances;
+} level_locals_t;
+
+extern	level_locals_t	level;
+extern	game_export_t	globals;
+
+extern	cvar_t	*g_gravity;
+extern	cvar_t	*g_speed;
+extern	cvar_t	*g_cheats;
+extern	cvar_t	*g_developer;
+extern	cvar_t	*g_knockback;
+extern	cvar_t	*g_inactivity;
+extern	cvar_t	*g_debugMove;
+extern	cvar_t	*g_subtitles;
+extern	cvar_t	*g_removeDoors;
+
+extern	cvar_t	*g_ICARUSDebug;
+
+extern cvar_t	*g_npcdebug;
+
+extern gentity_t *player;
+//
+// g_spawn.c
+//
+qboolean	G_SpawnField( unsigned int uiField, char **ppKey, char **ppValue );
+qboolean	G_SpawnString( const char *key, const char *defaultString, char **out );
+// spawn string returns a temporary reference, you must CopyString() if you want to keep it
+qboolean	G_SpawnFloat( const char *key, const char *defaultString, float *out );
+qboolean	G_SpawnInt( const char *key, const char *defaultString, int *out );
+qboolean	G_SpawnVector( const char *key, const char *defaultString, float *out );
+qboolean	G_SpawnVector4( const char *key, const char *defaultString, float *out );
+qboolean	G_SpawnAngleHack( const char *key, const char *defaultString, float *out );
+void		G_SpawnEntitiesFromString( const char *entities );
+
+//
+// g_cmds.c
+//
+void Cmd_Score_f (gentity_t *ent);
+
+//
+// g_items.c
+//
+void G_RunItem( gentity_t *ent );
+void RespawnItem( gentity_t *ent );
+
+void UseHoldableItem( gentity_t *ent );
+void PrecacheItem (gitem_t *it);
+gentity_t *Drop_Item( gentity_t *ent, gitem_t *item, float angle, qboolean copytarget );
+void SetRespawn (gentity_t *ent, float delay);
+void G_SpawnItem (gentity_t *ent, gitem_t *item);
+void FinishSpawningItem( gentity_t *ent );
+void Think_Weapon (gentity_t *ent);
+int ArmorIndex (gentity_t *ent);
+void	Add_Ammo (gentity_t *ent, int weapon, int count);
+void Touch_Item (gentity_t *ent, gentity_t *other, trace_t *trace);
+
+void ClearRegisteredItems( void );
+void RegisterItem( gitem_t *item );
+void SaveRegisteredItems( void );
+
+//
+// g_utils.c
+//
+int G_ModelIndex( const char *name );
+int	G_SoundIndex( const char *name );
+/*
+Ghoul2 Insert Start
+*/
+int G_SkinIndex( const char *name );
+void	G_SetBoltSurfaceRemoval( const int entNum, const int modelIndex, const int boltIndex, const int surfaceIndex = -1, float duration = 5000 );
+/*
+Ghoul2 Insert End
+*/
+
+int G_EffectIndex( const char *name );
+void G_PlayEffect( const char *name, const vec3_t origin );
+void G_PlayEffect( const char *name, int clientNum );
+void G_PlayEffect( const char *name, const vec3_t origin, const vec3_t fwd );
+void G_PlayEffect( const char *name, const vec3_t origin, const vec3_t axis[3] );
+void G_PlayEffect( int fxID, const vec3_t origin, const vec3_t fwd );
+void G_PlayEffect( int fxID, const vec3_t origin, const vec3_t axis[3] );
+void G_PlayEffect( int fxID, const int modelIndex, const int boltIndex, const int entNum, const vec3_t origin, int iLoopTime = qfalse, qboolean isRelative = qfalse );//iLoopTime 0 = not looping, 1 for infinite, else duration
+void G_PlayEffect( int fxID, int entNum, const vec3_t fwd );
+#ifdef _IMMERSION
+void G_PlayEffect( const char *name, int clientNum, const vec3_t origin, const vec3_t fwd );
+void G_PlayEffect( int fxID, int clientNum, const vec3_t origin, const vec3_t fwd );
+#endif // _IMMERSION
+void G_StopEffect( int fxID, const int modelIndex, const int boltIndex, const int entNum );
+void G_StopEffect(const char *name, const int modelIndex, const int boltIndex, const int entNum );
+
+int G_BSPIndex( char *name );
+
+void	G_KillBox (gentity_t *ent);
+gentity_t *G_Find (gentity_t *from, int fieldofs, const char *match);
+int		G_RadiusList ( vec3_t origin, float radius,	gentity_t *ignore, qboolean takeDamage, gentity_t *ent_list[MAX_GENTITIES]);
+gentity_t *G_PickTarget (char *targetname);
+void	G_UseTargets (gentity_t *ent, gentity_t *activator);
+void	G_UseTargets2 (gentity_t *ent, gentity_t *activator, const char *string);
+void	G_SetMovedir ( vec3_t angles, vec3_t movedir);
+
+void	G_InitGentity( gentity_t *e, qboolean bFreeG2 );
+gentity_t	*G_Spawn (void);
+gentity_t *G_TempEntity( const vec3_t origin, int event );
+void	G_Sound( gentity_t *ent, int soundIndex );
+void	G_FreeEntity( gentity_t *e );
+
+#ifdef _IMMERSION
+int		G_ForceIndex( const char *name, int channel );
+void	G_Force( gentity_t *ent, int forceIndex );
+void	G_ForceArea( gentity_t *ent, int forceIndex );
+void	G_ForceBroadcast( gentity_t *ent, int forceIndex );
+void	G_ForceStop( gentity_t* ent, int forceIndex );
+#endif // _IMMERSION
+void	G_TouchTriggers (gentity_t *ent);
+void	G_TouchTeamClients (gentity_t *ent);
+void	G_TouchSolids (gentity_t *ent);
+
+char	*vtos( const vec3_t v );
+
+float vectoyaw( const vec3_t vec );
+
+void G_AddEvent( gentity_t *ent, int event, int eventParm );
+void G_SetOrigin( gentity_t *ent, const vec3_t origin );
+void G_SetAngles( gentity_t *ent, const vec3_t angles );
+
+void	G_DebugLine(vec3_t A, vec3_t B, int duration, int color, qboolean deleteornot);
+
+//
+// g_combat.c
+//
+qboolean CanDamage (gentity_t *targ, const vec3_t origin);
+void G_Damage( gentity_t *targ, gentity_t *inflictor, gentity_t *attacker, const vec3_t dir, const vec3_t point, int damage, int dflags, int mod, int hitLoc=HL_NONE );
+void G_RadiusDamage (const vec3_t origin, gentity_t *attacker, float damage, float radius, gentity_t *ignore, int mod);
+gentity_t *TossClientItems( gentity_t *self );
+void ExplodeDeath_Wait( gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int meansOfDeath,int dFlags,int hitLoc );
+void ExplodeDeath( gentity_t *self );
+void GoExplodeDeath( gentity_t *self, gentity_t *other, gentity_t *activator);
+void G_ApplyKnockback( gentity_t *targ, const vec3_t newDir, float knockback );
+void G_Throw( gentity_t *targ, const vec3_t newDir, float push );
+
+// damage flags
+#define DAMAGE_RADIUS			0x00000001	// damage was indirect
+#define DAMAGE_NO_ARMOR			0x00000002	// armour does not protect from this damage
+#define DAMAGE_NO_KNOCKBACK		0x00000008	// do not affect velocity, just view angles
+#define DAMAGE_NO_HIT_LOC		0x00000010	// do not modify damage by hit loc
+#define DAMAGE_NO_PROTECTION	0x00000020  // armor, shields, invulnerability, and godmode have no effect
+#define DAMAGE_EXTRA_KNOCKBACK	0x00000040	// add extra knockback to this damage
+#define DAMAGE_DEATH_KNOCKBACK	0x00000080	// only does knockback on death of target
+#define DAMAGE_IGNORE_TEAM		0x00000100	// damage is always done, regardless of teams
+#define DAMAGE_NO_DAMAGE		0x00000200	// do no actual damage but react as if damage was taken
+#define DAMAGE_DISMEMBER		0x00000400	// do dismemberment
+#define DAMAGE_NO_KILL			0x00000800	// do damage, but don't kill them
+#define DAMAGE_HEAVY_WEAP_CLASS	0x00001000	// doing heavy weapon type damage, certain objects may only take damage by missiles containing this flag
+#define DAMAGE_CUSTOM_HUD		0x00002000	// really dumb, but....
+#define	DAMAGE_IMPACT_DIE		0x00004000	// if a vehicle hits a wall it should instantly die
+#define	DAMAGE_DIE_ON_IMPACT	0x00008000	// ignores force-power based protection
+
+//
+// g_missile.c
+//
+void G_RunMissile( gentity_t *ent );
+
+gentity_t *fire_blaster (gentity_t *self, vec3_t start, vec3_t aimdir);
+gentity_t *fire_plasma (gentity_t *self, vec3_t start, vec3_t aimdir);
+gentity_t *fire_grenade (gentity_t *self, vec3_t start, vec3_t aimdir);
+gentity_t *fire_rocket (gentity_t *self, vec3_t start, vec3_t dir);
+
+
+//
+// g_mover.c
+//
+#define MOVER_START_ON		1
+#define MOVER_FORCE_ACTIVATE	2
+#define MOVER_CRUSHER		4
+#define MOVER_TOGGLE		8
+#define MOVER_LOCKED		16
+#define MOVER_GOODIE		32
+#define MOVER_PLAYER_USE	64
+#define MOVER_INACTIVE		128
+void G_RunMover( gentity_t *ent );
+
+
+//
+// g_misc.c
+//
+void TeleportPlayer( gentity_t *player, vec3_t origin, vec3_t angles );
+
+
+//
+// g_weapon.c
+//
+//void CalcMuzzlePoint ( gentity_t *ent, vec3_t forward, vec3_t right, vec3_t up, vec3_t muzzlePoint );
+//void SnapVectorTowards( vec3_t v, vec3_t to );
+//qboolean CheckGauntletAttack( gentity_t *ent );
+void WP_LoadWeaponParms (void);
+
+void IT_LoadItemParms( void );
+
+//
+// g_client.c
+//
+team_t PickTeam( int ignoreClientNum );
+void SetClientViewAngle( gentity_t *ent, vec3_t angle );
+gentity_t *SelectSpawnPoint ( vec3_t avoidPoint, team_t team, vec3_t origin, vec3_t angles );
+void respawn (gentity_t *ent);
+void InitClientPersistant (gclient_t *client);
+void InitClientResp (gclient_t *client);
+qboolean ClientSpawn( gentity_t *ent, SavedGameJustLoaded_e eSavedGameJustLoaded );
+void player_die (gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int mod, int dFlags, int hitLoc);
+void AddScore( gentity_t *ent, int score );
+qboolean SpotWouldTelefrag( gentity_t *spot, team_t checkteam );
+void G_RemoveWeaponModels( gentity_t *ent );
+
+//
+// g_svcmds.c
+//
+qboolean	ConsoleCommand( void );
+
+//
+// g_weapon.c
+//
+void FireWeapon( gentity_t *ent, qboolean alt_fire );
+
+//
+// p_hud.c
+//
+void MoveClientToIntermission (gentity_t *client);
+void G_SetStats (gentity_t *ent);
+void DeathmatchScoreboardMessage (gentity_t *client);
+
+//
+// g_cmds.c
+//
+static void G_SayTo( gentity_t *ent, gentity_t *other, int mode, int color, const char *name, const char *message );
+
+//
+// g_pweapon.c
+//
+
+
+//
+// g_main.c
+//
+void G_RunThink (gentity_t *ent);
+void QDECL G_Error( const char *fmt, ... );
+void SetInUse(gentity_t *ent);
+void ClearInUse(gentity_t *ent);
+qboolean PInUse(unsigned int entNum);
+qboolean PInUse2(gentity_t *ent);
+void WriteInUseBits(void);
+void ReadInUseBits(void);
+
+//
+// g_nav.cpp
+//
+void Svcmd_Nav_f (void);
+
+//
+// g_squad.cpp
+//
+void Svcmd_Comm_f (void);
+void Svcmd_Hail_f (void);
+void Svcmd_Form_f (void);
+
+
+//
+// g_utils.cpp
+//
+void Svcmd_Use_f (void);
+extern void G_SoundOnEnt( gentity_t *ent, soundChannel_t channel, const char *soundPath );
+extern void G_SoundIndexOnEnt( gentity_t *ent, soundChannel_t channel, int index );
+
+//
+// g_weapons.cpp
+//
+
+//
+// g_client.c
+//
+char *ClientConnect( int clientNum, qboolean firstTime, SavedGameJustLoaded_e eSavedGameJustLoaded );
+void ClientUserinfoChanged( int clientNum );
+void ClientDisconnect( int clientNum );
+void ClientBegin( int clientNum, usercmd_t *cmd, SavedGameJustLoaded_e eSavedGameJustLoaded );
+void ClientCommand( int clientNum );
+
+//
+// g_active.c
+//
+void ClientThink( int clientNum, usercmd_t *cmd );
+void ClientEndFrame (gentity_t *ent);
+
+//
+// g_inventory.cpp
+//
+extern qboolean INV_GoodieKeyGive( gentity_t *target );
+extern qboolean INV_GoodieKeyTake( gentity_t *target );
+extern int INV_GoodieKeyCheck( gentity_t *target );
+extern qboolean INV_SecurityKeyGive( gentity_t *target, const char *keyname );
+extern void INV_SecurityKeyTake( gentity_t *target, char *keyname );
+extern qboolean INV_SecurityKeyCheck( gentity_t *target, char *keyname );
+
+//
+// g_team.c
+//
+qboolean OnSameTeam( gentity_t *ent1, gentity_t *ent2 );
+
+
+//
+// g_mem.c
+//
+void *G_Alloc( int size );
+void G_InitMemory( void );
+void Svcmd_GameMem_f( void );
+
+//
+// g_session.c
+//
+void G_ReadSessionData( gclient_t *client );
+void G_InitSessionData( gclient_t *client, char *userinfo );
+
+void G_InitWorldSession( void );
+void G_WriteSessionData( void );
+
+
+//
+// NPC_senses.cpp
+//
+extern void AddSightEvent( gentity_t *owner, vec3_t position, float radius, alertEventLevel_e alertLevel, float addLight=0.0f );
+extern void AddSoundEvent( gentity_t *owner, vec3_t position, float radius, alertEventLevel_e alertLevel, qboolean needLOS = qfalse, qboolean onGround = qfalse );
+extern qboolean G_CheckForDanger( gentity_t *self, int alertEvent );
+extern int G_CheckAlertEvents( gentity_t *self, qboolean checkSight, qboolean checkSound, float maxSeeDist, float maxHearDist, int ignoreAlert = -1, qboolean mustHaveOwner = qfalse, int minAlertLevel = AEL_MINOR, qboolean onGroundOnly = qfalse );
+extern qboolean G_CheckForDanger( gentity_t *self, int alertEvent );
+extern qboolean G_ClearLOS( gentity_t *self, const vec3_t start, const vec3_t end );
+extern qboolean G_ClearLOS( gentity_t *self, gentity_t *ent, const vec3_t end );
+extern qboolean G_ClearLOS( gentity_t *self, const vec3_t start, gentity_t *ent );
+extern qboolean G_ClearLOS( gentity_t *self, gentity_t *ent );
+extern qboolean G_ClearLOS( gentity_t *self, const vec3_t end );
+
+//============================================================================
+
+//Tags
+
+// Reference tags
+
+#define MAX_REFTAGS	128		// Probably more than we'll ever need
+#define MAX_REFNAME	32
+
+#define	RTF_NONE	0
+#define	RTF_NAVGOAL	0x00000001
+
+typedef struct reference_tag_s
+{
+	char	name[MAX_REFNAME];
+	vec3_t	origin;
+	vec3_t	angles;
+	int		flags;	//Just in case
+	int		radius;	//For nav goals
+} reference_tag_t;
+
+extern	void TAG_Init( void );
+extern	reference_tag_t	*TAG_Add( const char *name, const char *owner, vec3_t origin, vec3_t angles, int radius, int flags );
+
+extern	int	TAG_GetOrigin( const char *owner, const char *name, vec3_t origin );
+extern	int	TAG_GetAngles( const char *owner, const char *name, vec3_t angles );
+extern	int TAG_GetRadius( const char *owner, const char *name );
+extern	int TAG_GetFlags( const char *owner, const char *name );
+
+void TAG_ShowTags( int flags );
+
+// Reference tags END
+
+extern char *G_NewString( const char *string );
+
+// some stuff for savegames...
+//
+void WriteLevel(qboolean qbAutosave);
+void ReadLevel(qboolean qbAutosave, qboolean qbLoadTransition);
+qboolean GameAllowedToSaveHere(void);
+
+extern qboolean G_ActivateBehavior( gentity_t *ent, int bset );
+
+//Timing information
+void		TIMER_Clear( void );
+void		TIMER_Clear( int idx );
+void		TIMER_Save( void );
+void		TIMER_Load( void );
+void		TIMER_Set( gentity_t *ent, const char *identifier, int duration );
+int			TIMER_Get( gentity_t *ent, const char *identifier );
+qboolean	TIMER_Done( gentity_t *ent, const char *identifier );
+qboolean	TIMER_Start( gentity_t *self, const char *identifier, int duration );
+qboolean	TIMER_Done2( gentity_t *ent, const char *identifier, qboolean remove = qfalse );
+qboolean	TIMER_Exists( gentity_t *ent, const char *identifier );
+void		TIMER_Remove( gentity_t *ent, const char *identifier );
+
+float NPC_GetHFOVPercentage( vec3_t spot, vec3_t from, vec3_t facing, float hFOV );
+float NPC_GetVFOVPercentage( vec3_t spot, vec3_t from, vec3_t facing, float vFOV );
+
+#ifdef _XBOX
+// data used for NPC water detection
+#define MAX_NPC_WATER_UPDATE 64						// maximum npcs that can be waiting for a water update
+#define	MAX_NPC_WATER_UPDATES_PER_FRAME 2			// updates per frame
+
+extern	short	npcsToUpdate[MAX_NPC_WATER_UPDATE];	// queue of npcs
+extern	short	npcsToUpdateTop;					// top of the queue
+extern	short	npcsToUpdateCount;					// number of npcs in the queue
+
+#endif // _XBOX
+
+#endif//#ifndef __G_LOCAL_H__
diff --git a/code/game/g_main.cpp b/code/game/g_main.cpp
new file mode 100644
index 0000000..4d6c9dd
--- /dev/null
+++ b/code/game/g_main.cpp
@@ -0,0 +1,2141 @@
+// leave this line at the top for all g_xxxx.cpp files...
+#include "g_headers.h"
+
+
+
+#include "g_local.h"
+#include "g_functions.h"
+#include "Q3_Interface.h"
+#include "g_nav.h"
+#include "g_roff.h"
+#include "g_navigator.h"
+#include "b_local.h"
+#include "anims.h"
+#include "objectives.h"
+#include "../cgame/cg_local.h"	// yeah I know this is naughty, but we're shipping soon...
+
+//rww - RAGDOLL_BEGIN
+#include "../ghoul2/ghoul2_gore.h"
+//rww - RAGDOLL_END
+
+extern void WP_SaberLoadParms( void );
+extern qboolean G_PlayerSpawned( void );
+
+extern void Rail_Initialize( void );
+extern void Rail_Update( void );
+extern void	Rail_Reset(void);
+
+extern void Troop_Initialize( void );
+extern void Troop_Update( void );
+extern void	Troop_Reset(void);
+
+extern void	Pilot_Reset(void);
+extern void	Pilot_Update(void);
+
+extern void G_ASPreCacheFree(void);
+
+
+static int 	navCalcPathTime = 0;
+int		eventClearTime = 0;
+
+extern qboolean g_bCollidableRoffs;
+
+
+#define	STEPSIZE		18
+
+level_locals_t	level;
+game_import_t	gi;
+game_export_t	globals;
+gentity_t		g_entities[MAX_GENTITIES];
+unsigned int	g_entityInUseBits[MAX_GENTITIES/32];
+
+static void ClearAllInUse(void)
+{
+	memset(g_entityInUseBits,0,sizeof(g_entityInUseBits));
+}
+
+void SetInUse(gentity_t *ent)
+{
+	assert(((unsigned int)ent)>=(unsigned int)g_entities);
+	assert(((unsigned int)ent)<=(unsigned int)(g_entities+MAX_GENTITIES-1));
+	unsigned int entNum=ent-g_entities;
+	g_entityInUseBits[entNum/32]|=((unsigned int)1)<<(entNum&0x1f);
+}
+
+void ClearInUse(gentity_t *ent)
+{
+	assert(((unsigned int)ent)>=(unsigned int)g_entities);
+	assert(((unsigned int)ent)<=(unsigned int)(g_entities+MAX_GENTITIES-1));
+	unsigned int entNum=ent-g_entities;
+	g_entityInUseBits[entNum/32]&=~(((unsigned int)1)<<(entNum&0x1f));
+}
+
+qboolean PInUse(unsigned int entNum)
+{
+	assert(entNum>=0);
+	assert(entNum<MAX_GENTITIES);
+	return((g_entityInUseBits[entNum/32]&(((unsigned int)1)<<(entNum&0x1f)))!=0);
+}
+
+/*qboolean PInUse2(gentity_t *ent)
+{
+	assert(((unsigned int)ent)>=(unsigned int)g_entities);
+	assert(((unsigned int)ent)<=(unsigned int)(g_entities+MAX_GENTITIES-1));
+	unsigned int entNum=ent-g_entities;
+	return((g_entityInUseBits[entNum/32]&(((unsigned int)1)<<(entNum&0x1f)))!=0);
+}
+*/
+
+void WriteInUseBits(void)
+{
+	gi.AppendToSaveGame('INUS', &g_entityInUseBits, sizeof(g_entityInUseBits) );
+}
+
+void ReadInUseBits(void)
+{
+	gi.ReadFromSaveGame('INUS', &g_entityInUseBits, sizeof(g_entityInUseBits));
+	// This is only temporary. Once I have converted all the ent->inuse refs,
+	// it won;t be needed -MW.
+	for(int i=0;i<MAX_GENTITIES;i++)
+	{
+		g_entities[i].inuse=PInUse(i);
+	}
+}
+
+#ifdef _DEBUG
+static void ValidateInUseBits(void)
+{
+	for(int i=0;i<MAX_GENTITIES;i++)
+	{
+		assert(g_entities[i].inuse==PInUse(i));
+	}
+}
+#endif
+
+gentity_t		*player;
+
+cvar_t	*g_speed;
+cvar_t	*g_gravity;
+cvar_t	*g_stepSlideFix;
+
+cvar_t	*g_sex;
+cvar_t	*g_spskill;
+cvar_t	*g_cheats;
+cvar_t	*g_developer;
+cvar_t	*g_timescale;
+cvar_t	*g_knockback;
+cvar_t	*g_dismemberment;
+cvar_t	*g_corpseRemovalTime;
+
+cvar_t	*g_synchSplitAnims;
+#ifndef FINAL_BUILD
+cvar_t	*g_AnimWarning;
+#endif
+cvar_t	*g_noFootSlide;
+cvar_t	*g_noFootSlideRunScale;
+cvar_t	*g_noFootSlideWalkScale;
+
+cvar_t	*g_nav1;
+cvar_t	*g_nav2;
+cvar_t	*g_bobaDebug;
+
+cvar_t	*g_delayedShutdown;
+
+cvar_t	*g_inactivity;
+cvar_t	*g_debugMove;
+cvar_t	*g_debugDamage;
+cvar_t	*g_weaponRespawn;
+cvar_t	*g_subtitles;
+cvar_t	*g_ICARUSDebug;
+
+#ifdef _XBOX
+extern cvar_t *com_buildScript;
+#else
+cvar_t	*com_buildScript;
+#endif
+
+cvar_t	*g_skippingcin;
+cvar_t	*g_AIsurrender;
+cvar_t	*g_numEntities;
+//cvar_t	*g_iscensored;
+
+cvar_t	*g_saberAutoBlocking;
+cvar_t	*g_saberRealisticCombat;
+cvar_t	*g_saberDamageCapping;
+cvar_t	*g_saberMoveSpeed;
+cvar_t	*g_saberAnimSpeed;
+cvar_t	*g_saberAutoAim;
+cvar_t	*g_saberNewControlScheme;
+cvar_t	*g_debugSaberLock;
+cvar_t	*g_saberLockRandomNess;
+cvar_t	*g_debugMelee;
+cvar_t	*g_saberRestrictForce;
+
+cvar_t	*g_speederControlScheme;
+
+cvar_t	*g_char_model;
+cvar_t	*g_char_skin_head;
+cvar_t	*g_char_skin_torso;
+cvar_t	*g_char_skin_legs;
+cvar_t	*g_char_color_red;
+cvar_t	*g_char_color_green;
+cvar_t	*g_char_color_blue;
+cvar_t	*g_saber;
+cvar_t	*g_saber2;
+cvar_t	*g_saber_color;
+cvar_t	*g_saber2_color;
+cvar_t	*g_saberDarkSideSaberColor;
+
+// kef -- used with DebugTraceForNPC
+cvar_t	*g_npcdebug;
+
+// mcg -- testing: make NPCs obey do not enter brushes better?
+cvar_t	*g_navSafetyChecks;
+
+cvar_t	*g_broadsword;
+
+qboolean	stop_icarus = qfalse;
+
+extern char *G_GetLocationForEnt( gentity_t *ent );
+extern void CP_FindCombatPointWaypoints( void );
+extern qboolean InFront( vec3_t spot, vec3_t from, vec3_t fromAngles, float threshHold = 0.0f );
+
+void G_RunFrame (int levelTime);
+void PrintEntClassname( int gentNum );
+void ClearNPCGlobals( void );
+extern void AI_UpdateGroups( void );
+
+void ClearPlayerAlertEvents( void );
+extern void NPC_ShowDebugInfo (void);
+extern int killPlayerTimer;
+
+/*
+static void G_DynamicMusicUpdate( usercmd_t *ucmd )
+
+  FIXME: can we merge any of this with the G_ChooseLookEnemy stuff?
+*/
+static void G_DynamicMusicUpdate( void )
+{
+	gentity_t	*ent;
+	gentity_t	*entityList[MAX_GENTITIES];
+	int			numListedEntities;
+	vec3_t		mins, maxs;
+	int			i, e;
+	int			distSq, radius = 2048;
+	vec3_t		center;
+	int			danger = 0;
+	int			battle = 0;
+	int			entTeam;
+	qboolean	dangerNear = qfalse;
+	qboolean	suspicious = qfalse;
+	qboolean	LOScalced = qfalse, clearLOS = qfalse;
+
+	//FIXME: intro and/or other cues? (one-shot music sounds)
+
+	//loops
+
+	//player-based
+	if ( !player )
+	{//WTF?
+		player = &g_entities[0];
+		return;
+	}
+
+	if ( !G_PlayerSpawned() )
+	{//player hasn't spawned yet!
+		return;
+	}
+
+	if ( player->health <= 0 && player->max_health > 0 )
+	{//defeat music
+		if ( level.dmState != DM_DEATH )
+		{
+			level.dmState = DM_DEATH;
+		}
+	}
+
+	if ( level.dmState == DM_DEATH )
+	{
+		gi.SetConfigstring( CS_DYNAMIC_MUSIC_STATE, "death" );
+		return;
+	}
+
+	if ( level.dmState == DM_BOSS )
+	{
+		gi.SetConfigstring( CS_DYNAMIC_MUSIC_STATE, "boss" );
+		return;
+	}
+
+	if ( level.dmState == DM_SILENCE )
+	{
+		gi.SetConfigstring( CS_DYNAMIC_MUSIC_STATE, "silence" );
+		return;
+	}
+
+	if ( level.dmBeatTime > level.time )
+	{//not on a beat
+		return;
+	}
+
+	level.dmBeatTime = level.time + 1000;//1 second beats
+
+	if ( player->health <= 20 )
+	{
+		danger = 1;
+	}
+
+	//enemy-based
+	VectorCopy( player->currentOrigin, center );
+	for ( i = 0 ; i < 3 ; i++ ) 
+	{
+		mins[i] = center[i] - radius;
+		maxs[i] = center[i] + radius;
+	}
+	
+	numListedEntities = gi.EntitiesInBox( mins, maxs, entityList, MAX_GENTITIES );
+	for ( e = 0 ; e < numListedEntities ; e++ ) 
+	{
+		ent = entityList[ e ];
+		if ( !ent || !ent->inuse )
+		{
+			continue;
+		}
+
+		if ( !ent->client || !ent->NPC )
+		{
+			if ( ent->classname && (!Q_stricmp( "PAS", ent->classname )||!Q_stricmp( "misc_turret", ent->classname )) )
+			{//a turret
+				entTeam = ent->noDamageTeam;
+			}
+			else
+			{
+				continue;
+			}
+		}
+		else
+		{//an NPC
+			entTeam = ent->client->playerTeam;
+		}
+
+		if ( entTeam == player->client->playerTeam )
+		{//ally
+			continue;
+		}
+
+		if ( entTeam == TEAM_NEUTRAL && (!ent->enemy || !ent->enemy->client || ent->enemy->client->playerTeam != player->client->playerTeam) )
+		{//a droid that is not mad at me or my allies
+			continue;
+		}
+
+		if ( !gi.inPVS( player->currentOrigin, ent->currentOrigin ) )
+		{//not potentially visible
+			continue;
+		}
+
+		if ( ent->client && ent->s.weapon == WP_NONE )
+		{//they don't have a weapon... FIXME: only do this for droids?
+			continue;
+		}
+
+		LOScalced = clearLOS = qfalse;
+		if ( (ent->enemy==player&&(!ent->NPC||ent->NPC->confusionTime<level.time)) || (ent->client&&ent->client->ps.weaponTime) || (!ent->client&&ent->attackDebounceTime>level.time))
+		{//mad
+			if ( ent->health > 0 )
+			{//alive
+				//FIXME: do I really need this check?
+				if ( ent->s.weapon == WP_SABER && ent->client && !ent->client->ps.SaberActive() && ent->enemy != player )
+				{//a Jedi who has not yet gotten made at me
+					continue;
+				}
+				if ( ent->NPC && ent->NPC->behaviorState == BS_CINEMATIC )
+				{//they're not actually going to do anything about being mad at me...
+					continue;
+				}
+				//okay, they're in my PVS, but how close are they?  Are they actively attacking me?
+				if ( !ent->client && ent->s.weapon == WP_TURRET && ent->fly_sound_debounce_time && ent->fly_sound_debounce_time - level.time < 10000 )
+				{//a turret that shot at me less than ten seconds ago
+				}
+				else if ( ent->client && ent->client->ps.lastShotTime && ent->client->ps.lastShotTime - level.time < 10000 )
+				{//an NPC that shot at me less than ten seconds ago
+				}
+				else
+				{//not actively attacking me lately, see how far away they are
+					distSq = DistanceSquared( ent->currentOrigin, player->currentOrigin );
+					if ( distSq > 4194304/*2048*2048*/ )
+					{//> 2048 away
+						continue;
+					}
+					else if ( distSq > 1048576/*1024*1024*/ )
+					{//> 1024 away
+						clearLOS = G_ClearLOS( player, player->client->renderInfo.eyePoint, ent );
+						LOScalced = qtrue;
+						if ( clearLOS == qfalse )
+						{//No LOS
+							continue;
+						}
+					}
+				}
+				battle++;
+			}
+		}
+
+		if ( level.dmState == DM_EXPLORE )
+		{//only do these visibility checks if you're still in exploration mode
+			if ( !InFront( ent->currentOrigin, player->currentOrigin, player->client->ps.viewangles, 0.0f) )
+			{//not in front
+				continue;
+			}
+
+			if ( !LOScalced )
+			{
+				clearLOS = G_ClearLOS( player, player->client->renderInfo.eyePoint, ent );
+			}
+			if ( !clearLOS ) 
+			{//can't see them directly
+				continue;
+			}
+		}
+
+		if ( ent->health <= 0 )
+		{//dead
+			if ( !ent->client || level.time - ent->s.time > 10000 )
+			{//corpse has been dead for more than 10 seconds
+				//FIXME: coming across corpses should cause danger sounds too?
+				continue;
+			}
+		}
+		//we see enemies and/or corpses
+		danger++;
+	}
+
+	if ( !battle )
+	{//no active enemies, but look for missiles, shot impacts, etc...
+		int alert = G_CheckAlertEvents( player, qtrue, qtrue, 1024, 1024, -1, qfalse, AEL_SUSPICIOUS );
+		if ( alert != -1 )
+		{//FIXME: maybe tripwires and other FIXED things need their own sound, some kind of danger/caution theme
+			if ( G_CheckForDanger( player, alert ) )
+			{//found danger near by
+				danger++;
+				battle = 1;
+			}
+			else if ( level.alertEvents[alert].owner && (level.alertEvents[alert].owner == player->enemy || (level.alertEvents[alert].owner->client && level.alertEvents[alert].owner->client->playerTeam == player->client->enemyTeam) ) )
+			{//NPC on enemy team of player made some noise
+				switch ( level.alertEvents[alert].level )
+				{
+				case AEL_DISCOVERED:
+					dangerNear = qtrue;
+					break;
+				case AEL_SUSPICIOUS:
+					suspicious = qtrue;
+					break;
+				case AEL_MINOR:
+					//distraction = qtrue;
+					break;
+				}
+			}
+		}
+	}
+
+	if ( battle )
+	{//battle - this can interrupt level.dmDebounceTime of lower intensity levels
+		//play battle
+		if ( level.dmState != DM_ACTION )
+		{
+			gi.SetConfigstring( CS_DYNAMIC_MUSIC_STATE, "action" );
+		}
+		level.dmState = DM_ACTION;
+		if ( battle > 5 )
+		{
+			//level.dmDebounceTime = level.time + 8000;//don't change again for 5 seconds
+		}
+		else
+		{
+			//level.dmDebounceTime = level.time + 3000 + 1000*battle;
+		}
+	}
+	else 
+	{
+		if ( level.dmDebounceTime > level.time )
+		{//not ready to switch yet
+			return;
+		}
+		else
+		{//at least 1 second (for beats)
+			//level.dmDebounceTime = level.time + 1000;//FIXME: define beat time?
+		}
+		/*
+		if ( danger || dangerNear )
+		{//danger
+			//stay on whatever we were on, action or exploration
+			if ( !danger )
+			{//minimum
+				danger = 1;
+			}
+			if ( danger > 3 )
+			{
+				level.dmDebounceTime = level.time + 5000;
+			}
+			else
+			{
+				level.dmDebounceTime = level.time + 2000 + 1000*danger;
+			}
+		}
+		else
+		*/
+		{//still nothing dangerous going on
+			if ( level.dmState != DM_EXPLORE )
+			{//just went to explore, hold it for a couple seconds at least
+				//level.dmDebounceTime = level.time + 2000;
+				gi.SetConfigstring( CS_DYNAMIC_MUSIC_STATE, "explore" );
+			}
+			level.dmState = DM_EXPLORE;
+			//FIXME: look for interest points and play "mysterious" music instead of exploration?
+			//FIXME: suspicious and distraction sounds should play some cue or change music in a subtle way?
+			//play exploration
+		}
+		//FIXME: when do we go to silence?
+	}
+}
+
+void G_ConnectNavs( const char *mapname, int checkSum )
+{
+	NAV::LoadFromEntitiesAndSaveToFile(mapname, checkSum);
+	CP_FindCombatPointWaypoints();
+}
+
+/*
+================
+G_FindTeams
+
+Chain together all entities with a matching team field.
+Entity teams are used for item groups and multi-entity mover groups.
+
+All but the first will have the FL_TEAMSLAVE flag set and teammaster field set
+All but the last will have the teamchain field set to the next one
+================
+*/
+void G_FindTeams( void ) {
+	gentity_t	*e, *e2;
+	int		i, j;
+	int		c, c2;
+
+	c = 0;
+	c2 = 0;
+//	for ( i=1, e=g_entities,i ; i < globals.num_entities ; i++,e++ )
+	for ( i=1 ; i < globals.num_entities ; i++ )
+	{
+//		if (!e->inuse)
+//			continue;
+		if(!PInUse(i))
+			continue;
+		e=&g_entities[i];
+
+		if (!e->team)
+			continue;
+		if (e->flags & FL_TEAMSLAVE)
+			continue;
+		e->teammaster = e;
+		c++;
+		c2++;
+//		for (j=i+1, e2=e+1 ; j < globals.num_entities ; j++,e2++)
+		for (j=i+1; j < globals.num_entities ; j++)
+		{
+//			if (!e2->inuse)
+//				continue;
+			if(!PInUse(j))
+				continue;
+			
+			e2=&g_entities[j];
+			if (!e2->team)
+				continue;
+			if (e2->flags & FL_TEAMSLAVE)
+				continue;
+			if (!strcmp(e->team, e2->team))
+			{
+				c2++;
+				e2->teamchain = e->teamchain;
+				e->teamchain = e2;
+				e2->teammaster = e;
+				e2->flags |= FL_TEAMSLAVE;
+
+				// make sure that targets only point at the master
+				if ( e2->targetname ) {
+					e->targetname = G_NewString(e2->targetname);
+					e2->targetname = NULL;
+				}
+			}
+		}
+	}
+
+	//gi.Printf ("%i teams with %i entities\n", c, c2);
+}
+
+
+/*
+============
+G_InitCvars
+
+============
+*/
+void G_InitCvars( void ) {
+	// don't override the cheat state set by the system
+	g_cheats = gi.cvar ("helpUsObi", "", 0);
+	g_developer = gi.cvar ("developer", "", 0);
+
+	// noset vars
+	gi.cvar( "gamename", GAMEVERSION , CVAR_SERVERINFO | CVAR_ROM );
+	gi.cvar( "gamedate", __DATE__ , CVAR_ROM );
+	g_skippingcin = gi.cvar ("skippingCinematic", "0", CVAR_ROM);
+
+	// latched vars
+
+	// change anytime vars
+	g_speed = gi.cvar( "g_speed", "250", CVAR_CHEAT );
+	g_gravity = gi.cvar( "g_gravity", "800", CVAR_SAVEGAME|CVAR_ROM );
+	g_stepSlideFix = gi.cvar( "g_stepSlideFix", "1", CVAR_ARCHIVE );
+	g_sex = gi.cvar ("sex", "f", CVAR_USERINFO | CVAR_ARCHIVE|CVAR_SAVEGAME|CVAR_NORESTART );
+	g_spskill = gi.cvar ("g_spskill", "0", CVAR_ARCHIVE | CVAR_SAVEGAME|CVAR_NORESTART);
+	g_knockback = gi.cvar( "g_knockback", "1000", CVAR_CHEAT );
+	g_dismemberment = gi.cvar ( "g_dismemberment", "3", CVAR_ARCHIVE );//0 = none, 1 = arms and hands, 2 = legs, 3 = waist and head, 4 = mega dismemberment
+	// for now I'm making default 10 seconds
+	g_corpseRemovalTime = gi.cvar ( "g_corpseRemovalTime", "10", CVAR_ARCHIVE );//number of seconds bodies stick around for, at least... 0 = never go away
+	g_synchSplitAnims = gi.cvar ( "g_synchSplitAnims", "1", 0 );
+#ifndef FINAL_BUILD
+	g_AnimWarning = gi.cvar ( "g_AnimWarning", "1", 0 );
+#endif
+	g_noFootSlide = gi.cvar ( "g_noFootSlide", "1", 0 );
+	g_noFootSlideRunScale = gi.cvar ( "g_noFootSlideRunScale", "150.0", 0 );
+	g_noFootSlideWalkScale = gi.cvar ( "g_noFootSlideWalkScale", "50.0", 0 );
+
+	g_nav1 = gi.cvar ( "g_nav1", "", 0 );
+	g_nav2 = gi.cvar ( "g_nav2", "", 0 );
+
+	g_bobaDebug = gi.cvar ( "g_bobaDebug", "", 0 );
+
+#if defined(FINAL_BUILD) || defined(_XBOX)
+	g_delayedShutdown = gi.cvar ( "g_delayedShutdown", "0", 0 );
+#else
+	g_delayedShutdown = gi.cvar ( "g_delayedShutdown", "1", 0 );
+#endif
+
+	g_inactivity = gi.cvar ("g_inactivity", "0", 0);
+	g_debugMove = gi.cvar ("g_debugMove", "0", CVAR_CHEAT );
+	g_debugDamage = gi.cvar ("g_debugDamage", "0", CVAR_CHEAT );
+	g_ICARUSDebug = gi.cvar( "g_ICARUSDebug", "0", CVAR_CHEAT );
+	g_timescale = gi.cvar( "timescale", "1", 0 );
+	g_npcdebug = gi.cvar( "g_npcdebug", "0", 0 );
+	g_navSafetyChecks = gi.cvar( "g_navSafetyChecks", "0", 0 );
+	// NOTE : I also create this is UI_Init()
+	g_subtitles = gi.cvar( "g_subtitles", "0", CVAR_ARCHIVE );
+	com_buildScript = gi.cvar ("com_buildscript", "0", 0);
+
+	g_saberAutoBlocking = gi.cvar( "g_saberAutoBlocking", "1", CVAR_CHEAT );//must press +block button to do any blocking
+	g_saberRealisticCombat = gi.cvar( "g_saberMoreRealistic", "0", CVAR_CHEAT|CVAR_INIT );//makes collision more precise, increases damage
+	g_saberDamageCapping = gi.cvar( "g_saberDamageCapping", "1", CVAR_CHEAT );//caps damage of sabers vs players and NPC who use sabers
+	g_saberMoveSpeed = gi.cvar( "g_saberMoveSpeed", "1", CVAR_CHEAT );//how fast you run while attacking with a saber
+	g_saberAnimSpeed = gi.cvar( "g_saberAnimSpeed", "1", CVAR_CHEAT );//how fast saber animations run
+	g_saberAutoAim = gi.cvar( "g_saberAutoAim", "1", CVAR_CHEAT );//auto-aims at enemies when not moving or when just running forward
+	g_saberNewControlScheme = gi.cvar( "g_saberNewControlScheme", "0", CVAR_ARCHIVE );//use +forcefocus to pull off all the special moves
+	g_debugSaberLock = gi.cvar( "g_debugSaberLock", "0", CVAR_CHEAT );//just for debugging/development, makes saberlocks happen all the time
+	g_saberLockRandomNess = gi.cvar( "g_saberLockRandomNess", "2", CVAR_ARCHIVE );//just for debugging/development, controls frequency of saberlocks
+	g_debugMelee = gi.cvar( "g_debugMelee", "0", CVAR_CHEAT );//just for debugging/development, test kicks and grabs
+	g_saberRestrictForce = gi.cvar( "g_saberRestrictForce", "0", CVAR_ARCHIVE );//restricts certain force powers when using a 2-handed saber or 2 sabers
+
+	g_AIsurrender = gi.cvar( "g_AIsurrender", "0", CVAR_CHEAT );
+	g_numEntities = gi.cvar( "g_numEntities", "0", 0 );
+	
+	gi.cvar( "newTotalSecrets", "0", CVAR_ROM );
+	gi.cvar_set("newTotalSecrets", "0");//used to carry over the count from SP_target_secret to ClientBegin
+	//g_iscensored = gi.cvar( "ui_iscensored", "0", CVAR_ARCHIVE|CVAR_ROM|CVAR_INIT|CVAR_CHEAT|CVAR_NORESTART );
+
+	g_speederControlScheme = gi.cvar( "g_speederControlScheme", "2", CVAR_ARCHIVE|CVAR_ROM );//2 is default, 1 is alternate
+
+	g_char_model = gi.cvar( "g_char_model", "jedi_tf", CVAR_ARCHIVE|CVAR_SAVEGAME|CVAR_NORESTART );	
+	g_char_skin_head = gi.cvar( "g_char_skin_head", "head_a1", CVAR_ARCHIVE|CVAR_SAVEGAME|CVAR_NORESTART );	
+	g_char_skin_torso = gi.cvar( "g_char_skin_torso", "torso_a1", CVAR_ARCHIVE|CVAR_SAVEGAME|CVAR_NORESTART );	
+	g_char_skin_legs = gi.cvar( "g_char_skin_legs", "lower_a1", CVAR_ARCHIVE|CVAR_SAVEGAME|CVAR_NORESTART );	
+	g_char_color_red = gi.cvar( "g_char_color_red", "255", CVAR_ARCHIVE|CVAR_SAVEGAME|CVAR_NORESTART );	
+	g_char_color_green = gi.cvar( "g_char_color_green", "255", CVAR_ARCHIVE|CVAR_SAVEGAME|CVAR_NORESTART );	
+	g_char_color_blue = gi.cvar( "g_char_color_blue", "255", CVAR_ARCHIVE|CVAR_SAVEGAME|CVAR_NORESTART );	
+	g_saber = gi.cvar( "g_saber", "single_1", CVAR_ARCHIVE|CVAR_SAVEGAME|CVAR_NORESTART );	
+	g_saber2 = gi.cvar( "g_saber2", "", CVAR_ARCHIVE|CVAR_SAVEGAME|CVAR_NORESTART );	
+	g_saber_color = gi.cvar( "g_saber_color", "yellow", CVAR_ARCHIVE|CVAR_SAVEGAME|CVAR_NORESTART );	
+	g_saber2_color = gi.cvar( "g_saber2_color", "yellow", CVAR_ARCHIVE|CVAR_SAVEGAME|CVAR_NORESTART );	
+	g_saberDarkSideSaberColor = gi.cvar( "g_saberDarkSideSaberColor", "0", CVAR_ARCHIVE );	//when you turn evil, it turns your saber red!
+
+	g_broadsword = gi.cvar( "broadsword", "1", 0);
+
+	gi.cvar( "tier_storyinfo", "0", CVAR_ROM|CVAR_SAVEGAME|CVAR_NORESTART);
+	gi.cvar( "tiers_complete", "", CVAR_ROM|CVAR_SAVEGAME|CVAR_NORESTART);
+
+	gi.cvar( "ui_prisonerobj_currtotal", "0", CVAR_ROM|CVAR_SAVEGAME|CVAR_NORESTART);
+	gi.cvar( "ui_prisonerobj_maxtotal", "0", CVAR_ROM|CVAR_SAVEGAME|CVAR_NORESTART);
+
+	gi.cvar( "g_clearstats", "1", CVAR_ROM|CVAR_NORESTART);
+
+}
+/*
+============
+InitGame
+
+============
+*/
+
+// I'm just declaring a global here which I need to get at in NAV_GenerateSquadPaths for deciding if pre-calc'd
+//	data is valid, and this saves changing the proto of G_SpawnEntitiesFromString() to include a checksum param which
+//	may get changed anyway if a new nav system is ever used. This way saves messing with g_local.h each time -slc
+int giMapChecksum;	
+SavedGameJustLoaded_e g_eSavedGameJustLoaded;
+qboolean g_qbLoadTransition = qfalse;
+void InitGame(  const char *mapname, const char *spawntarget, int checkSum, const char *entities, int levelTime, int randomSeed, int globalTime, SavedGameJustLoaded_e eSavedGameJustLoaded, qboolean qbLoadTransition )
+{
+	//rww - default this to 0, we will auto-set it to 1 if we run into a terrain ent
+	gi.cvar_set("RMG", "0");
+
+	g_bCollidableRoffs = false;
+
+	giMapChecksum = checkSum;
+	g_eSavedGameJustLoaded = eSavedGameJustLoaded;
+	g_qbLoadTransition = qbLoadTransition;
+
+	gi.Printf ("------- Game Initialization -------\n");
+	gi.Printf ("gamename: %s\n", GAMEVERSION);
+	gi.Printf ("gamedate: %s\n", __DATE__);
+
+	srand( randomSeed );
+
+	G_InitCvars();
+
+	G_InitMemory();
+
+	// set some level globals
+	memset( &level, 0, sizeof( level ) );
+	level.time = levelTime;
+	level.globalTime = globalTime;
+	Q_strncpyz( level.mapname, mapname, sizeof(level.mapname) );
+	if ( spawntarget != NULL && spawntarget[0] )
+	{
+		Q_strncpyz( level.spawntarget, spawntarget, sizeof(level.spawntarget) );
+	}
+	else
+	{
+		level.spawntarget[0] = 0;
+	}
+
+
+	G_InitWorldSession();
+
+	// initialize all entities for this game
+	memset( g_entities, 0, MAX_GENTITIES * sizeof(g_entities[0]) );
+	globals.gentities = g_entities;
+	ClearAllInUse();
+	// initialize all clients for this game
+	level.maxclients = 1;
+	level.clients = (struct gclient_s *) G_Alloc( level.maxclients * sizeof(level.clients[0]) );
+	memset(level.clients, 0, level.maxclients * sizeof(level.clients[0]));
+
+	// set client fields on player
+	g_entities[0].client = level.clients;
+
+	// always leave room for the max number of clients,
+	// even if they aren't all used, so numbers inside that
+	// range are NEVER anything but clients
+	globals.num_entities = MAX_CLIENTS;
+
+	//Load sabers.cfg data
+	WP_SaberLoadParms();
+	//Set up NPC init data
+	NPC_InitGame();
+	
+	TIMER_Clear();
+	Rail_Reset();
+	Troop_Reset();
+	Pilot_Reset();
+
+	IT_LoadItemParms ();
+
+	ClearRegisteredItems();
+
+	// clear out old nav info, attempt to load from file
+	NAV::LoadFromFile(level.mapname, giMapChecksum);
+
+	// parse the key/value pairs and spawn gentities
+	G_SpawnEntitiesFromString( entities );
+
+	// general initialization
+	G_FindTeams();
+
+//	SaveRegisteredItems();
+
+	gi.Printf ("-----------------------------------\n");
+
+	Rail_Initialize();
+	Troop_Initialize();
+
+
+	player = &g_entities[0];
+
+	//Init dynamic music
+	level.dmState = DM_EXPLORE;
+	level.dmDebounceTime = 0;
+	level.dmBeatTime = 0;
+
+	level.curAlertID = 1;//0 is default for lastAlertEvent, so...
+	eventClearTime = 0;
+
+#ifdef _XBOX
+	// clear out NPC water detection data
+	npcsToUpdateTop		= 0;
+	npcsToUpdateCount	= 0;
+	memset(npcsToUpdate, -1, 2 * MAX_NPC_WATER_UPDATE);
+#endif // _XBOX
+
+}
+
+/*
+=================
+ShutdownGame
+=================
+*/
+void ShutdownGame( void )
+{
+	// write all the client session data so we can get it back
+	G_WriteSessionData(); 
+
+#ifdef _XBOX
+	// The following functions, cleverly disguised as memory freeing and dealloction,
+	// actually allocate small blocks. Fooled you!
+	extern void Z_SetNewDeleteTemporary(bool bTemp);
+	Z_SetNewDeleteTemporary( true );
+#endif
+
+	// Destroy the Game Interface.
+	IGameInterface::Destroy();
+
+	// Shut ICARUS down.
+	IIcarusInterface::DestroyIcarus();
+
+	// Destroy the Game Interface again.  Only way to really free everything.
+	IGameInterface::Destroy();
+
+#ifdef _XBOX
+	Z_SetNewDeleteTemporary( false );
+#endif
+
+	TAG_Init();	//Clear the reference tags
+/*
+Ghoul2 Insert Start
+*/
+	for (int i=0; i<MAX_GENTITIES; i++)
+	{
+		gi.G2API_CleanGhoul2Models(g_entities[i].ghoul2);
+	}
+	/*
+Ghoul2 Insert End
+*/
+	G_ASPreCacheFree();
+}
+
+
+
+//===================================================================
+
+static void G_Cvar_Create( const char *var_name, const char *var_value, int flags ) {
+	gi.cvar( var_name, var_value, flags );
+}
+
+//BEGIN GAMESIDE RMG
+qboolean G_ParseSpawnVars( const char **data );
+void G_SpawnGEntityFromSpawnVars( void );
+
+void G_GameSpawnRMGEntity(char *s)
+{
+	if (G_ParseSpawnVars((const char **)&s))
+	{
+		G_SpawnGEntityFromSpawnVars();
+	}
+}
+//END GAMESIDE RMG
+
+/*
+=================
+GetGameAPI
+
+Returns a pointer to the structure with all entry points
+and global variables
+=================
+*/
+extern int PM_ValidateAnimRange( const int startFrame, const int endFrame, const float animSpeed );
+game_export_t *GetGameAPI( game_import_t *import ) {
+	gameinfo_import_t	gameinfo_import;
+
+	gi = *import;
+
+	globals.apiversion = GAME_API_VERSION;
+	globals.Init = InitGame;
+	globals.Shutdown = ShutdownGame;
+
+	globals.WriteLevel = WriteLevel;
+	globals.ReadLevel = ReadLevel;
+	globals.GameAllowedToSaveHere = GameAllowedToSaveHere;
+
+	globals.ClientThink = ClientThink;
+	globals.ClientConnect = ClientConnect;
+	globals.ClientUserinfoChanged = ClientUserinfoChanged;
+	globals.ClientDisconnect = ClientDisconnect;
+	globals.ClientBegin = ClientBegin;
+	globals.ClientCommand = ClientCommand;
+
+	globals.RunFrame = G_RunFrame;
+	globals.ConnectNavs = G_ConnectNavs;
+
+	globals.ConsoleCommand = ConsoleCommand;
+	//globals.PrintEntClassname = PrintEntClassname;
+
+	//globals.ValidateAnimRange = PM_ValidateAnimRange;
+
+	globals.GameSpawnRMGEntity = G_GameSpawnRMGEntity;
+
+	globals.gentitySize = sizeof(gentity_t);
+
+	gameinfo_import.FS_FOpenFile = gi.FS_FOpenFile;
+	gameinfo_import.FS_Read = gi.FS_Read;
+	gameinfo_import.FS_FCloseFile = gi.FS_FCloseFile;
+	gameinfo_import.Cvar_Set = gi.cvar_set;
+	gameinfo_import.Cvar_VariableStringBuffer = gi.Cvar_VariableStringBuffer;
+	gameinfo_import.Cvar_Create = G_Cvar_Create;
+
+	GI_Init( &gameinfo_import );
+
+	return &globals;
+}
+
+void QDECL G_Error( const char *fmt, ... ) {
+	va_list		argptr;
+	char		text[1024];
+
+	va_start (argptr, fmt);
+	vsprintf (text, fmt, argptr);
+	va_end (argptr);
+
+	gi.Error( ERR_DROP, "%s", text);
+}
+
+#ifndef GAME_HARD_LINKED
+// this is only here so the functions in q_shared.c and bg_*.c can link
+
+/*
+-------------------------
+Com_Error
+-------------------------
+*/
+
+void Com_Error ( int level, const char *error, ... ) {
+	va_list		argptr;
+	char		text[1024];
+
+	va_start (argptr, error);
+	vsprintf (text, error, argptr);
+	va_end (argptr);
+
+	gi.Error( level, "%s", text);
+}
+
+/*
+-------------------------
+Com_Printf
+-------------------------
+*/
+
+void Com_Printf( const char *msg, ... ) {
+	va_list		argptr;
+	char		text[1024];
+
+	va_start (argptr, msg);
+	vsprintf (text, msg, argptr);
+	va_end (argptr);
+
+	gi.Printf ("%s", text);
+}
+
+#endif
+
+/*
+========================================================================
+
+MAP CHANGING
+
+========================================================================
+*/
+
+
+/*
+========================================================================
+
+FUNCTIONS CALLED EVERY FRAME
+
+========================================================================
+*/
+
+static void G_CheckTasksCompleted (gentity_t *ent) 
+{
+	if ( Q3_TaskIDPending( ent, TID_CHAN_VOICE ) )
+	{
+		if ( !gi.VoiceVolume[ent->s.number] )
+		{//not playing a voice sound
+			//return task_complete
+			Q3_TaskIDComplete( ent, TID_CHAN_VOICE );
+		}
+	}
+
+	if ( Q3_TaskIDPending( ent, TID_LOCATION ) )
+	{
+		char	*currentLoc = G_GetLocationForEnt( ent );
+
+		if ( currentLoc && currentLoc[0] && Q_stricmp( ent->message, currentLoc ) == 0 )
+		{//we're in the desired location
+			Q3_TaskIDComplete( ent, TID_LOCATION );
+		}
+		//FIXME: else see if were in other trigger_locations?
+	}
+}
+
+static void G_CheckSpecialPersistentEvents( gentity_t *ent )
+{//special-case alerts that would be a pain in the ass to have the ent's think funcs generate
+	if ( ent == NULL )
+	{
+		return;
+	}
+	if ( ent->s.eType == ET_MISSILE && ent->s.weapon == WP_THERMAL && ent->s.pos.trType == TR_STATIONARY )
+	{
+		if ( eventClearTime == level.time + ALERT_CLEAR_TIME )
+		{//events were just cleared out so add me again
+			AddSoundEvent( ent->owner, ent->currentOrigin, ent->splashRadius*2, AEL_DANGER, qfalse, qtrue );
+			AddSightEvent( ent->owner, ent->currentOrigin, ent->splashRadius*2, AEL_DANGER );
+		}
+	}
+	if ( ent->forcePushTime >= level.time )
+	{//being pushed
+		if ( eventClearTime == level.time + ALERT_CLEAR_TIME )
+		{//events were just cleared out so add me again
+			//NOTE: presumes the player did the pushing, this is not always true, but shouldn't really matter?
+			if ( ent->item && ent->item->giTag == INV_SECURITY_KEY )
+			{
+				AddSightEvent( player, ent->currentOrigin, 128, AEL_DISCOVERED );//security keys are more important
+			}
+			else
+			{
+				AddSightEvent( player, ent->currentOrigin, 128, AEL_SUSPICIOUS );//hmm... or should this always be discovered?
+			}
+		}
+	}
+	if ( ent->contents == CONTENTS_LIGHTSABER && !Q_stricmp( "lightsaber", ent->classname ) )
+	{//lightsaber
+		if( ent->owner && ent->owner->client )
+		{
+			if ( ent->owner->client->ps.SaberLength() > 0 )
+			{//it's on
+				//sight event
+				AddSightEvent( ent->owner, ent->currentOrigin, 512, AEL_DISCOVERED );
+			}
+		}
+	}
+}
+/*
+=============
+G_RunThink
+
+Runs thinking code for this frame if necessary
+=============
+*/
+void G_RunThink (gentity_t *ent) 
+{
+	if ( (ent->nextthink <= 0) || (ent->nextthink > level.time) ) 
+	{
+		goto runicarus;
+	}
+		
+	ent->nextthink = 0;
+	if ( ent->e_ThinkFunc == thinkF_NULL )	// actually you don't need this since I check for it in the next function -slc
+	{
+		goto runicarus;
+	}
+
+	GEntity_ThinkFunc( ent );
+
+runicarus:
+	if ( ent->inuse )	// GEntity_ThinkFunc( ent ) can have freed up this ent if it was a type flier_child (stasis1 crash)
+	{
+		if ( ent->NPC == NULL )
+		{
+			if ( ent->m_iIcarusID != IIcarusInterface::ICARUS_INVALID && !stop_icarus )
+			{
+				IIcarusInterface::GetIcarus()->Update( ent->m_iIcarusID );
+			}
+		}
+	}
+}
+
+/*
+-------------------------
+G_Animate
+-------------------------
+*/
+
+static void G_Animate ( gentity_t *self )
+{
+	if ( self->s.eFlags & EF_SHADER_ANIM )
+	{
+		return;
+	}
+	if ( self->s.frame == self->endFrame )
+	{
+		if ( self->svFlags & SVF_ANIMATING )
+		{
+			// ghoul2 requires some extra checks to see if the animation is done since it doesn't set the current frame directly
+			if ( self->ghoul2.size() )
+			{
+				float frame, junk2;
+				int junk;
+
+				// I guess query ghoul2 to find out what the current frame is and see if we are done.
+				gi.G2API_GetBoneAnimIndex( &self->ghoul2[self->playerModel], self->rootBone, 
+									(cg.time?cg.time:level.time), &frame, &junk, &junk, &junk, &junk2, NULL );
+
+				// It NEVER seems to get to what you'd think the last frame would be, so I'm doing this to try and catch when the animation has stopped
+				if ( frame + 1 >= self->endFrame )
+				{
+					self->svFlags &= ~SVF_ANIMATING;
+					Q3_TaskIDComplete( self, TID_ANIM_BOTH );
+				}
+			}
+			else // not ghoul2
+			{
+				if ( self->loopAnim )
+				{
+					self->s.frame = self->startFrame;
+				}
+				else
+				{
+					self->svFlags &= ~SVF_ANIMATING;
+				}
+
+				//Finished sequence - FIXME: only do this once even on looping anims?
+				Q3_TaskIDComplete( self, TID_ANIM_BOTH );
+			}
+		}
+		return;
+	}
+
+	self->svFlags |= SVF_ANIMATING;
+
+	// With ghoul2, we'll just set the desired start and end frame and let it do it's thing.
+	if ( self->ghoul2.size())
+	{
+		self->s.frame = self->endFrame;
+		
+		gi.G2API_SetBoneAnimIndex( &self->ghoul2[self->playerModel], self->rootBone, 
+									self->startFrame, self->endFrame, BONE_ANIM_OVERRIDE_FREEZE, 1.0f, cg.time );
+		return;
+	}
+
+	if ( self->startFrame < self->endFrame )
+	{
+		if ( self->s.frame < self->startFrame || self->s.frame > self->endFrame )
+		{
+			self->s.frame = self->startFrame;
+		}
+		else
+		{
+			self->s.frame++;
+		}
+	}
+	else if ( self->startFrame > self->endFrame )
+	{
+		if ( self->s.frame > self->startFrame || self->s.frame < self->endFrame )
+		{
+			self->s.frame = self->startFrame;
+		}
+		else
+		{
+			self->s.frame--;
+		}
+	}
+	else
+	{
+		self->s.frame = self->endFrame;
+	}
+}
+
+/*
+-------------------------
+ResetTeamCounters
+-------------------------
+*/
+
+/*
+void ResetTeamCounters( void )
+{
+	//clear team enemy counters
+	for ( int team = TEAM_FREE; team < TEAM_NUM_TEAMS; team++ )
+	{
+		teamEnemyCount[team] = 0;
+		teamCount[team] = 0;
+	}
+}
+*/
+
+/*
+-------------------------
+UpdateTeamCounters
+-------------------------
+*/
+/*
+void UpdateTeamCounters( gentity_t *ent )
+{
+	if ( !ent->NPC )
+	{
+		return;
+	}
+	if ( !ent->client )
+	{
+		return;
+	}
+	if ( ent->health <= 0 )
+	{
+		return;
+	}
+	if ( (ent->s.eFlags&EF_NODRAW) )
+	{
+		return;
+	}
+	if ( ent->client->playerTeam == TEAM_FREE )
+	{
+		return;
+	}
+	//this is an NPC who is alive and visible and is on a specific team
+
+	teamCount[ent->client->playerTeam]++;
+	if ( !ent->enemy )
+	{
+		return;
+	}
+
+	//ent has an enemy
+	if ( !ent->enemy->client )
+	{//enemy is a normal ent
+		if ( ent->noDamageTeam == ent->client->playerTeam )
+		{//it's on my team, don't count it as an enemy
+			return;
+		}
+	}
+	else
+	{//enemy is another NPC/player
+		if ( ent->enemy->client->playerTeam == ent->client->playerTeam)
+		{//enemy is on the same team, don't count it as an enemy
+			return;
+		}
+	}
+
+	//ent's enemy is not on the same team
+	teamLastEnemyTime[ent->client->playerTeam] = level.time;
+	teamEnemyCount[ent->client->playerTeam]++;
+}
+*/
+void G_PlayerGuiltDeath( void )
+{
+	if ( player && player->client )
+	{//simulate death
+		player->client->ps.stats[STAT_HEALTH] = 0;
+		//turn off saber
+		if ( player->client->ps.weapon == WP_SABER && player->client->ps.SaberActive() )
+		{
+			G_SoundIndexOnEnt( player, CHAN_WEAPON, player->client->ps.saber[0].soundOff );
+			player->client->ps.SaberDeactivate();
+		}
+		//play the "what have I done?!" anim
+		NPC_SetAnim( player, SETANIM_BOTH, BOTH_FORCEHEAL_START, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+		player->client->ps.legsAnimTimer = player->client->ps.torsoAnimTimer = -1;
+		//look at yourself
+		player->client->ps.stats[STAT_DEAD_YAW] = player->client->ps.viewangles[YAW]+180;
+	}
+}
+extern void NPC_SetAnim(gentity_t	*ent,int setAnimParts,int anim,int setAnimFlags, int iBlend);
+extern void G_MakeTeamVulnerable( void );
+int killPlayerTimer = 0;
+static void G_CheckEndLevelTimers( gentity_t *ent )
+{
+	if ( killPlayerTimer && level.time > killPlayerTimer )
+	{
+		killPlayerTimer = 0;
+		ent->health = 0;
+		if ( ent->client && ent->client->ps.stats[STAT_HEALTH] > 0 )
+		{
+			G_PlayerGuiltDeath();
+			//cg.missionStatusShow = qtrue;
+			statusTextIndex = MISSIONFAILED_TURNED;
+			//debounce respawn time
+			ent->client->respawnTime = level.time + 2000;
+			//stop all scripts
+			stop_icarus = qtrue;
+			//make the team killable
+			G_MakeTeamVulnerable();
+		}
+	}
+}
+
+
+
+//rww - RAGDOLL_BEGIN
+class CGameRagDollUpdateParams : public CRagDollUpdateParams
+{
+	void EffectorCollision(const SRagDollEffectorCollision &data) 
+	{
+		//Com_Printf("Effector Collision at (%f %f %f)\n",data.effectorPosition[0],data.effectorPosition[1],data.effectorPosition[2]);
+		vec3_t effectorPosDif;
+
+		if (data.useTracePlane)
+		{
+			float magicFactor42=64.0f;
+			VectorScale(data.tr.plane.normal,magicFactor42,effectorPosDif);
+		}
+		else
+		{
+			gentity_t *thisguy = &g_entities[me];
+
+			if (thisguy && thisguy->client)
+			{
+				VectorSubtract(thisguy->client->ps.origin, data.effectorPosition, effectorPosDif);
+			}
+			else
+			{
+				return;
+			}
+		}
+
+		VectorAdd(effectorTotal, effectorPosDif, effectorTotal);
+
+		hasEffectorData = qtrue;
+		return;
+	}
+	void RagDollBegin() 
+	{
+		return;
+	}
+	virtual void RagDollSettled() 
+	{
+		return;
+	}
+	void Collision()   // we had a collision, please stop animating and (sometime soon) call SetRagDoll RP_DEATH_COLLISION
+	{
+		return;
+	}
+	
+#ifdef _DEBUG
+	void DebugLine(vec3_t p1,vec3_t p2,int color,bool bbox) 
+	{
+		if (!bbox)
+		{
+			CG_TestLine(p1, p2, 50, color, 1);
+		}
+		return;
+	}
+#endif
+public:
+	vec3_t effectorTotal;
+	qboolean hasEffectorData;
+};
+
+//list of valid ragdoll effectors
+static const char *g_effectorStringTable[] =
+{ //commented out the ones I don't want dragging to affect
+//	"thoracic",
+//	"rhand",
+	"lhand",
+	"rtibia",
+	"ltibia",
+	"rtalus",
+	"ltalus",
+//	"rradiusX",
+	"lradiusX",
+	"rfemurX",
+	"lfemurX",
+//	"ceyebrow",
+	NULL //always terminate
+};
+
+extern qboolean G_StandardHumanoid( gentity_t *self );
+extern void PM_SetTorsoAnimTimer( gentity_t *ent, int *torsoAnimTimer, int time );
+extern void PM_SetLegsAnimTimer( gentity_t *ent, int *legsAnimTimer, int time );
+extern qboolean G_ReleaseEntity( gentity_t *grabber );
+
+static void G_BodyDragUpdate(gentity_t *ent, gentity_t *dragger)
+{
+	vec3_t handVec;
+	float handDist;
+
+	assert(ent && ent->inuse && ent->client && ent->ghoul2.size() &&
+		dragger && dragger->inuse && dragger->client && dragger->ghoul2.size());
+
+	VectorSubtract(dragger->client->renderInfo.handRPoint, ent->client->renderInfo.torsoPoint, handVec);
+	handDist = VectorLength(handVec);
+
+	if (handDist > 64.0f)
+	{
+		G_ReleaseEntity(dragger);
+	}
+	else if (handDist > 12.0f)
+	{
+		VectorNormalize(handVec);
+		VectorScale(handVec, 256.0f, handVec);
+		handVec[2] = 0;
+
+		//VectorAdd(ent->client->ps.velocity, handVec, ent->client->ps.velocity);
+		//VectorCopy(handVec, ent->client->ps.velocity);
+		ent->client->ps.velocity[0] = handVec[0];
+		ent->client->ps.velocity[1] = handVec[1];
+	}
+}
+
+//we want to see which way the pelvis is facing to get a relatively oriented base settling frame
+//this is to avoid the arms stretching in opposite directions on the body trying to reach the base
+//pose if the pelvis is flipped opposite of the base pose or something -rww
+static int G_RagAnimForPositioning(gentity_t *ent)
+{
+	vec3_t dir;
+	mdxaBone_t matrix;
+	assert(ent->client);
+	vec3_t G2Angles = {0, ent->client->ps.viewangles[YAW], 0};
+
+	assert(ent->ghoul2.size() > 0);
+	assert(ent->crotchBolt > -1);
+
+	gi.G2API_GetBoltMatrix(ent->ghoul2, ent->playerModel, ent->crotchBolt, &matrix, G2Angles, ent->client->ps.origin,
+		(cg.time?cg.time:level.time), NULL, ent->s.modelScale);
+	gi.G2API_GiveMeVectorFromMatrix(matrix, NEGATIVE_Z, dir);
+
+	if (dir[2] > 0.1f)
+	{ //facing up
+		return BOTH_DEADFLOP2;
+	}
+	else
+	{ //facing down
+		return BOTH_DEADFLOP1;
+	}
+}
+
+static inline qboolean G_RagWantsHumanoidsOnly( CGhoul2Info *ghlInfo )
+{
+	char	*GLAName;
+	GLAName = gi.G2API_GetGLAName( ghlInfo );
+	assert(GLAName);
+
+	if ( !Q_stricmp( "models/players/_humanoid/_humanoid", GLAName ) )
+	{//only _humanoid skeleton is expected to have these
+		return qtrue;
+	}
+
+	return qfalse;
+}
+
+//rww - game interface for the ragdoll stuff.
+//Returns qtrue if the entity is now in a ragdoll state, otherwise qfalse.
+//(ported from MP's CG version)
+
+qboolean G_RagDoll(gentity_t *ent, vec3_t forcedAngles)
+{
+	vec3_t G2Angles;
+	vec3_t usedOrg;
+	qboolean inSomething = qfalse;
+	int ragAnim;
+	//int ragVar = gi.Cvar_VariableIntegerValue("broadsword");
+	int ragVar = g_broadsword->integer;
+
+	if (!ragVar)
+	{
+		return qfalse;
+	}
+
+	if (!ent ||
+		!ent->inuse ||
+		!ent->client ||
+		ent->health > 0 ||
+		ent->client->noRagTime >= level.time ||
+		ent->client->noRagTime==-1 ||
+		(ent->s.powerups & (1 << PW_DISRUPTION)) ||
+		!ent->e_DieFunc ||
+ 		ent->playerModel < 0 ||
+		!ent->ghoul2.size() ||
+		!G_RagWantsHumanoidsOnly(&ent->ghoul2[ent->playerModel])
+		)
+	{
+		return qfalse;
+	}
+
+	VectorCopy(forcedAngles, G2Angles);
+	forcedAngles[0] = forcedAngles[2] = 0;
+
+	if (ent->client->ps.heldByClient <= ENTITYNUM_WORLD)
+	{
+		gentity_t *grabbedBy = &g_entities[ent->client->ps.heldByClient];
+
+		if (grabbedBy->inuse && grabbedBy->client &&
+			grabbedBy->ghoul2.size())
+		{
+			G_BodyDragUpdate(ent, grabbedBy);
+		}
+	}
+
+	//--FIXME: do not go into ragdoll if in a spinning death anim or something, it really messes things up
+	//rww 12/17/02 - should be ok now actually with my new stuff
+
+	VectorCopy(ent->client->ps.origin, usedOrg);
+
+	if (!ent->client->isRagging)
+	{ //If we're not in a ragdoll state, perform the checks.
+		if (ent->client->ps.heldByClient <= ENTITYNUM_WORLD)
+		{ //want to rag no matter what then
+			inSomething = qtrue;
+		}
+		else if (ent->client->ps.groundEntityNum == ENTITYNUM_NONE)
+		{
+			vec3_t cVel;
+
+			VectorCopy(ent->client->ps.velocity, cVel);
+
+			if (VectorNormalize(cVel) > 400)
+			{ //if he's flying through the air at a good enough speed, switch into ragdoll
+				inSomething = qtrue;
+			}
+		}
+
+		if (ragVar > 1)
+		{ //go into rag instantly upon death
+			inSomething = qtrue;
+
+			//also shove them a tad so they don't just collapse onto the floor
+			//VectorScale(ent->client->ps.velocity, 1.3f, ent->client->ps.velocity);
+			ent->client->ps.velocity[2] += 32;
+		}
+
+		if (!inSomething)
+		{
+			int i = 0;
+			int boltChecks[5];
+			vec3_t boltPoints[5];
+			vec3_t trStart, trEnd;
+			vec3_t tAng;
+			qboolean deathDone = qfalse;
+			trace_t tr;
+			mdxaBone_t boltMatrix;
+
+			VectorSet( tAng, 0, ent->client->ps.viewangles[YAW], 0 );
+
+			if (ent->client->ps.legsAnimTimer <= 0)
+			{ //Looks like the death anim is done playing
+				deathDone = qtrue;
+			}
+
+			//if (deathDone)
+			if (1)
+			{ //only trace from the hands if the death anim is already done.
+				boltChecks[0] = gi.G2API_AddBolt(&ent->ghoul2[ent->playerModel], "rhand");
+				boltChecks[1] = gi.G2API_AddBolt(&ent->ghoul2[ent->playerModel], "lhand");
+			}
+			else
+			{ //otherwise start the trace loop at the cranium.
+				i = 2;
+			}
+			boltChecks[2] = gi.G2API_AddBolt(&ent->ghoul2[ent->playerModel], "cranium");
+			boltChecks[3] = gi.G2API_AddBolt(&ent->ghoul2[ent->playerModel], "rtalus");
+			boltChecks[4] = gi.G2API_AddBolt(&ent->ghoul2[ent->playerModel], "ltalus");
+
+			//Do the head first, because the hands reference it anyway.
+			gi.G2API_GetBoltMatrix(ent->ghoul2, ent->playerModel, boltChecks[2], &boltMatrix, tAng, ent->client->ps.origin, (cg.time?cg.time:level.time), NULL, ent->s.modelScale);
+			gi.G2API_GiveMeVectorFromMatrix(boltMatrix, ORIGIN, boltPoints[2]);
+
+			while (i < 5)
+			{
+				if (i < 2)
+				{ //when doing hands, trace to the head instead of origin
+					gi.G2API_GetBoltMatrix(ent->ghoul2, ent->playerModel, boltChecks[i], &boltMatrix, tAng, ent->client->ps.origin, (cg.time?cg.time:level.time), NULL, ent->s.modelScale);
+					gi.G2API_GiveMeVectorFromMatrix(boltMatrix, ORIGIN, boltPoints[i]);
+					VectorCopy(boltPoints[i], trStart);
+					VectorCopy(boltPoints[2], trEnd);
+				}
+				else
+				{
+					if (i > 2)
+					{ //2 is the head, which already has the bolt point.
+						gi.G2API_GetBoltMatrix(ent->ghoul2, ent->playerModel, boltChecks[i], &boltMatrix, tAng, ent->client->ps.origin, (cg.time?cg.time:level.time), NULL, ent->s.modelScale);
+						gi.G2API_GiveMeVectorFromMatrix(boltMatrix, ORIGIN, boltPoints[i]);
+					}
+					VectorCopy(boltPoints[i], trStart);
+					VectorCopy(ent->client->ps.origin, trEnd);
+				}
+
+				//Now that we have all that sorted out, trace between the two points we desire.
+				gi.trace(&tr, trStart, NULL, NULL, trEnd, ent->s.number, MASK_SOLID);
+
+				if (tr.fraction != 1.0 || tr.startsolid || tr.allsolid)
+				{ //Hit something or start in solid, so flag it and break.
+					//This is a slight hack, but if we aren't done with the death anim, we don't really want to
+					//go into ragdoll unless our body has a relatively "flat" pitch.
+#if 0
+					vec3_t vSub;
+
+					//Check the pitch from the head to the right foot (should be reasonable)
+					VectorSubtract(boltPoints[2], boltPoints[3], vSub);
+					VectorNormalize(vSub);
+					vectoangles(vSub, vSub);
+
+					if (deathDone || (vSub[PITCH] < 50 && vSub[PITCH] > -50))
+					{
+						inSomething = qtrue;
+					}
+#else
+					inSomething = qtrue;
+#endif
+					break;
+				}
+
+				i++;
+			}
+		}
+
+		if (inSomething)
+		{
+			/*
+			PM_SetTorsoAnimTimer( ent, &ent->client->ps.torsoAnimTimer, 0 );
+			PM_SetLegsAnimTimer( ent, &ent->client->ps.legsAnimTimer, 0 );
+
+			PM_SetAnimFinal(&ent->client->ps.torsoAnim,&ent->client->ps.legsAnim,SETANIM_BOTH,ragAnim,SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD,
+				&ent->client->ps.torsoAnimTimer,&ent->client->ps.legsAnimTimer,ent,500);
+			*/
+			ent->client->isRagging = qtrue;
+		}
+	}
+
+	if (ent->client->isRagging)
+	{ //We're in a ragdoll state, so make the call to keep our positions updated and whatnot.
+		CRagDollParams tParms;
+		CGameRagDollUpdateParams tuParms;
+	
+		ragAnim = G_RagAnimForPositioning(ent);
+
+		/*
+		if (ent->ikStatus)
+		{ //ik must be reset before ragdoll is started, or you'll get some interesting results.
+			trap_G2API_SetBoneIKState(cent->ghoul2, cg.time, NULL, IKS_NONE, NULL);
+			cent->ikStatus = qfalse;
+		}
+		*/
+
+		//these will be used as "base" frames for the ragoll settling.
+		tParms.startFrame = level.knownAnimFileSets[ent->client->clientInfo.animFileIndex].animations[ragAnim].firstFrame;
+		tParms.endFrame = level.knownAnimFileSets[ent->client->clientInfo.animFileIndex].animations[ragAnim].firstFrame+level.knownAnimFileSets[ent->client->clientInfo.animFileIndex].animations[ragAnim].numFrames;
+#if 1
+		{
+			float currentFrame;
+			int startFrame, endFrame;
+			int flags;
+			float animSpeed;
+
+			if (gi.G2API_GetBoneAnim(&ent->ghoul2[0], "model_root", (cg.time?cg.time:level.time), &currentFrame, &startFrame, &endFrame, &flags, &animSpeed, NULL))
+			{ //lock the anim on the current frame.
+				int blendTime = 500;
+
+				gi.G2API_SetBoneAnim(&ent->ghoul2[0], "lower_lumbar", currentFrame, currentFrame+1, flags, animSpeed,(cg.time?cg.time:level.time), currentFrame, blendTime);
+				gi.G2API_SetBoneAnim(&ent->ghoul2[0], "model_root", currentFrame, currentFrame+1, flags, animSpeed, (cg.time?cg.time:level.time), currentFrame, blendTime);
+				gi.G2API_SetBoneAnim(&ent->ghoul2[0], "Motion", currentFrame, currentFrame+1, flags, animSpeed, (cg.time?cg.time:level.time), currentFrame, blendTime);
+			}
+		}
+#endif
+
+		gi.G2API_SetBoneAngles( &ent->ghoul2[ent->playerModel], "upper_lumbar", vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, NULL, 100, (cg.time?cg.time:level.time) ); 
+		gi.G2API_SetBoneAngles( &ent->ghoul2[ent->playerModel], "lower_lumbar", vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, NULL, 100, (cg.time?cg.time:level.time) ); 
+		gi.G2API_SetBoneAngles( &ent->ghoul2[ent->playerModel], "thoracic", vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, NULL, 100, (cg.time?cg.time:level.time) ); 
+		gi.G2API_SetBoneAngles( &ent->ghoul2[ent->playerModel], "cervical", vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, NULL, 100, (cg.time?cg.time:level.time) ); 
+
+		VectorCopy(G2Angles, tParms.angles);
+		VectorCopy(usedOrg, tParms.position);
+		VectorCopy(ent->s.modelScale, tParms.scale);
+		tParms.me = ent->s.number;
+		tParms.groundEnt = ent->client->ps.groundEntityNum;
+
+		tParms.collisionType = 1;
+		tParms.RagPhase=CRagDollParams::ERagPhase::RP_DEATH_COLLISION;
+		tParms.fShotStrength = 4;
+
+		gi.G2API_SetRagDoll(ent->ghoul2, &tParms);
+
+
+		tuParms.hasEffectorData = qfalse;
+		VectorClear(tuParms.effectorTotal);
+
+		VectorCopy(G2Angles, tuParms.angles);
+		VectorCopy(usedOrg, tuParms.position);
+		VectorCopy(ent->s.modelScale, tuParms.scale);
+		tuParms.me = ent->s.number;
+		tuParms.settleFrame = tParms.endFrame-1;
+		tuParms.groundEnt = ent->client->ps.groundEntityNum;
+
+		if (ent->client->ps.groundEntityNum != ENTITYNUM_NONE)
+		{
+			VectorClear(tuParms.velocity);
+		}
+		else
+		{
+			VectorScale(ent->client->ps.velocity, 0.4f, tuParms.velocity);
+		}
+
+		gi.G2API_AnimateG2Models(ent->ghoul2, (cg.time?cg.time:level.time), &tuParms);
+
+		if (ent->client->ps.heldByClient <= ENTITYNUM_WORLD)
+		{
+			gentity_t *grabEnt;
+
+			grabEnt = &g_entities[ent->client->ps.heldByClient];
+
+			if (grabEnt->client && grabEnt->ghoul2.size())
+			{
+				vec3_t bOrg;
+				vec3_t thisHand;
+				vec3_t hands;
+				vec3_t pcjMin, pcjMax;
+				vec3_t pDif;
+				vec3_t thorPoint;
+				float difLen;
+
+				//Get the person who is holding our hand's hand location
+				//gi.G2API_GetBoltMatrix(grabEnt->ghoul2, 0, grabEnt->gent->client->renderInfo.handRPoint, &matrix, grabEnt->turAngles, grabEnt->lerpOrigin,
+				//	cg.time, cgs.gameModels, grabEnt->modelScale);
+				//BG_GiveMeVectorFromMatrix(&matrix, ORIGIN, bOrg);
+				VectorCopy(grabEnt->client->renderInfo.handRPoint, bOrg);
+
+				//Get our hand's location
+				//trap_G2API_GetBoltMatrix(cent->ghoul2, 0, 0, &matrix, cent->turAngles, cent->lerpOrigin,
+				//	cg.time, cgs.gameModels, cent->modelScale);
+				//BG_GiveMeVectorFromMatrix(&matrix, ORIGIN, thisHand);
+				VectorCopy(ent->client->renderInfo.handRPoint, thisHand);
+
+				//Get the position of the thoracic bone for hinting its velocity later on
+				//thorBolt = trap_G2API_AddBolt(cent->ghoul2, 0, "thoracic");
+				//trap_G2API_GetBoltMatrix(cent->ghoul2, 0, thorBolt, &matrix, cent->turAngles, cent->lerpOrigin,
+				//	cg.time, cgs.gameModels, cent->modelScale);
+				//BG_GiveMeVectorFromMatrix(&matrix, ORIGIN, thorPoint);
+				VectorCopy(ent->client->renderInfo.torsoPoint, thorPoint);
+
+				VectorSubtract(bOrg, thisHand, hands);
+
+				if (VectorLength(hands) < 3.0f)
+				{
+					gi.G2API_RagForceSolve(ent->ghoul2, qfalse);
+				}
+				else
+				{
+					gi.G2API_RagForceSolve(ent->ghoul2, qtrue);
+				}
+
+				//got the hand pos of him, now we want to make our hand go to it
+				gi.G2API_RagEffectorGoal(ent->ghoul2, "rhand", bOrg);
+				gi.G2API_RagEffectorGoal(ent->ghoul2, "rradius", bOrg);
+				gi.G2API_RagEffectorGoal(ent->ghoul2, "rradiusX", bOrg);
+				gi.G2API_RagEffectorGoal(ent->ghoul2, "rhumerusX", bOrg);
+				gi.G2API_RagEffectorGoal(ent->ghoul2, "rhumerus", bOrg);
+
+				//Make these two solve quickly so we can update decently
+				gi.G2API_RagPCJGradientSpeed(ent->ghoul2, "rhumerus", 1.5f);
+				gi.G2API_RagPCJGradientSpeed(ent->ghoul2, "rradius", 1.5f);
+
+				//Break the constraints on them I suppose
+				VectorSet(pcjMin, -999, -999, -999);
+				VectorSet(pcjMax, 999, 999, 999);
+				gi.G2API_RagPCJConstraint(ent->ghoul2, "rhumerus", pcjMin, pcjMax);
+				gi.G2API_RagPCJConstraint(ent->ghoul2, "rradius", pcjMin, pcjMax);
+
+				ent->client->overridingBones = level.time + 2000;
+
+				//hit the thoracic velocity to the hand point
+				VectorSubtract(bOrg, thorPoint, hands);
+				VectorNormalize(hands);
+				VectorScale(hands, 2048.0f, hands);
+				gi.G2API_RagEffectorKick(ent->ghoul2, "thoracic", hands);
+				gi.G2API_RagEffectorKick(ent->ghoul2, "ceyebrow", hands);
+
+				VectorSubtract(ent->client->ragLastOrigin, ent->client->ps.origin, pDif);
+				VectorCopy(ent->client->ps.origin, ent->client->ragLastOrigin);
+
+				if (ent->client->ragLastOriginTime >= level.time && ent->client->ps.groundEntityNum != ENTITYNUM_NONE)
+				{ //make sure it's reasonably updated
+					difLen = VectorLength(pDif);
+					if (difLen > 0.0f)
+					{ //if we're being dragged, then kick all the bones around a bit
+						vec3_t dVel;
+						vec3_t rVel;
+						int i = 0;
+
+						if (difLen < 12.0f)
+						{
+							VectorScale(pDif, 12.0f/difLen, pDif);
+							difLen = 12.0f;
+						}
+
+						while (g_effectorStringTable[i])
+						{
+							VectorCopy(pDif, dVel);
+							dVel[2] = 0;
+
+							//Factor in a random velocity
+							VectorSet(rVel, Q_flrand(-0.1f, 0.1f), Q_flrand(-0.1f, 0.1f), Q_flrand(0.1f, 0.5));
+							VectorScale(rVel, 8.0f, rVel);
+
+							VectorAdd(dVel, rVel, dVel);
+							VectorScale(dVel, 10.0f, dVel);
+
+							gi.G2API_RagEffectorKick(ent->ghoul2, g_effectorStringTable[i], dVel);
+
+							i++;
+						}
+					}
+				}
+				ent->client->ragLastOriginTime = level.time + 1000;
+			}
+		}
+		else if (ent->client->overridingBones)
+		{ //reset things to their normal rag state
+			vec3_t pcjMin, pcjMax;
+			vec3_t dVel;
+
+			//got the hand pos of him, now we want to make our hand go to it
+			gi.G2API_RagEffectorGoal(ent->ghoul2, "rhand", NULL);
+			gi.G2API_RagEffectorGoal(ent->ghoul2, "rradius", NULL);
+			gi.G2API_RagEffectorGoal(ent->ghoul2, "rradiusX", NULL);
+			gi.G2API_RagEffectorGoal(ent->ghoul2, "rhumerusX", NULL);
+			gi.G2API_RagEffectorGoal(ent->ghoul2, "rhumerus", NULL);
+
+			VectorSet(dVel, 0.0f, 0.0f, -64.0f);
+			gi.G2API_RagEffectorKick(ent->ghoul2, "rhand", dVel);
+
+			gi.G2API_RagPCJGradientSpeed(ent->ghoul2, "rhumerus", 0.0f);
+			gi.G2API_RagPCJGradientSpeed(ent->ghoul2, "rradius", 0.0f);
+
+			VectorSet(pcjMin,-100.0f,-40.0f,-15.0f);
+			VectorSet(pcjMax,-15.0f,80.0f,15.0f);
+			gi.G2API_RagPCJConstraint(ent->ghoul2, "rhumerus", pcjMin, pcjMax);
+
+			VectorSet(pcjMin,-25.0f,-20.0f,-20.0f);
+			VectorSet(pcjMax,90.0f,20.0f,-20.0f);
+			gi.G2API_RagPCJConstraint(ent->ghoul2, "rradius", pcjMin, pcjMax);
+
+			if (ent->client->overridingBones < level.time)
+			{
+				gi.G2API_RagForceSolve(ent->ghoul2, qfalse);
+				ent->client->overridingBones = 0;
+			}
+			else
+			{
+				gi.G2API_RagForceSolve(ent->ghoul2, qtrue);
+			}
+		}
+
+		if (tuParms.hasEffectorData)
+		{
+			/*
+			vec3_t efDir;
+			vec3_t existingVelocity;
+			float evValue = 0;
+
+			VectorCopy(tuParms.effectorTotal, efDir);
+			VectorNormalize(efDir);
+			VectorCopy(ent->client->ps.velocity, existingVelocity);
+			evValue = VectorNormalize(existingVelocity);
+
+			if (evValue < 32)
+			{
+				ent->client->ps.velocity[0] += efDir[0]*64;
+				ent->client->ps.velocity[1] += efDir[1]*64;
+				ent->client->ps.velocity[2] += efDir[2]*64;
+			}
+			*/
+
+			VectorNormalize(tuParms.effectorTotal);
+			VectorScale(tuParms.effectorTotal, 7.0f, tuParms.effectorTotal);
+
+			VectorAdd(ent->client->ps.velocity, tuParms.effectorTotal, ent->client->ps.velocity);
+		}
+
+		return qtrue;
+	}
+
+	return qfalse;
+}
+//rww - RAGDOLL_END
+
+
+/*
+================
+G_RunFrame
+
+Advances the non-player objects in the world
+================
+*/
+#if	AI_TIMERS
+int AITime = 0;
+int navTime = 0;
+#endif//	AI_TIMERS
+
+
+void G_RunFrame( int levelTime ) {
+	int			i;
+	gentity_t	*ent;
+	int			msec;
+	int			ents_inuse=0; // someone's gonna be pissed I put this here...
+#if	AI_TIMERS
+	AITime = 0;
+	navTime = 0;
+#endif//	AI_TIMERS
+	
+	level.framenum++;
+	level.previousTime = level.time;
+	level.time = levelTime;
+	msec = level.time - level.previousTime;
+	
+	//ResetTeamCounters();
+	NAV::DecayDangerSenses();
+	Rail_Update();
+	Troop_Update();
+	Pilot_Update();
+
+	
+	if (player && gi.WE_IsShaking(player->currentOrigin))
+	{
+ 	  	CGCam_Shake(0.45f, 100);
+	}
+
+	
+	AI_UpdateGroups();
+
+
+
+
+	//Look to clear out old events
+	ClearPlayerAlertEvents();
+
+	//Run the frame for all entities
+//	for ( i = 0, ent = &g_entities[0]; i < globals.num_entities ; i++, ent++)
+	for ( i = 0; i < globals.num_entities ; i++) 
+	{
+//		if ( !ent->inuse )
+//			continue;
+
+		if(!PInUse(i))
+			continue;
+		ents_inuse++;
+		ent = &g_entities[i];
+
+		// clear events that are too old
+		if ( level.time - ent->eventTime > EVENT_VALID_MSEC ) {
+			if ( ent->s.event ) {
+				ent->s.event = 0;	// &= EV_EVENT_BITS;
+				if ( ent->client ) {
+					ent->client->ps.externalEvent = 0;
+				}
+			}
+			if ( ent->freeAfterEvent ) {
+				// tempEntities or dropped items completely go away after their event
+				G_FreeEntity( ent );
+				continue;
+			}
+			/*	// This is never set to true anywhere. Killing the field (BTO - VV)
+			else if ( ent->unlinkAfterEvent ) {
+				// items that will respawn will hide themselves after their pickup event
+				ent->unlinkAfterEvent = qfalse;
+				gi.unlinkentity( ent );
+			}
+			*/
+		}
+
+		// temporary entities don't think
+		if ( ent->freeAfterEvent )
+			continue;
+
+		G_CheckTasksCompleted(ent);
+
+		G_Roff( ent );
+
+		if( !ent->client )
+		{
+			if ( !(ent->svFlags & SVF_SELF_ANIMATING) )
+			{//FIXME: make sure this is done only for models with frames?
+				//Or just flag as animating?
+				if ( ent->s.eFlags & EF_ANIM_ONCE )
+				{
+					ent->s.frame++;
+				}
+				else if ( !(ent->s.eFlags & EF_ANIM_ALLFAST) )
+				{
+					G_Animate( ent );
+				}
+			}
+		}
+		G_CheckSpecialPersistentEvents( ent );
+
+		if ( ent->s.eType == ET_MISSILE ) 
+		{
+			G_RunMissile( ent );
+			continue;
+		}
+
+		if ( ent->s.eType == ET_ITEM ) 
+		{
+			G_RunItem( ent );
+			continue;
+		}
+
+		if ( ent->s.eType == ET_MOVER ) 
+		{
+			if ( ent->model && Q_stricmp( "models/test/mikeg/tie_fighter.md3", ent->model ) == 0 )
+			{
+				TieFighterThink( ent );
+			}
+			G_RunMover( ent );
+			continue;
+		}
+
+		//The player
+		if ( i == 0 ) 
+		{
+			// decay batteries if the goggles are active
+			if ( cg.zoomMode == 1 && ent->client->ps.batteryCharge > 0 )
+			{
+				ent->client->ps.batteryCharge--;
+			}
+			else if ( cg.zoomMode == 3 && ent->client->ps.batteryCharge > 0 )
+			{
+				ent->client->ps.batteryCharge -= 2;
+
+				if ( ent->client->ps.batteryCharge < 0 )
+				{
+					ent->client->ps.batteryCharge = 0;
+				}
+			}
+
+			G_CheckEndLevelTimers( ent );
+			//Recalculate the nearest waypoint for the coming NPC updates
+			NAV::GetNearestNode( ent );
+
+
+			if( ent->m_iIcarusID != IIcarusInterface::ICARUS_INVALID && !stop_icarus )
+			{
+				IIcarusInterface::GetIcarus()->Update( ent->m_iIcarusID );
+			}
+			//dead
+			if ( ent->health <= 0 )
+			{
+				if ( ent->client->ps.groundEntityNum != ENTITYNUM_NONE )
+				{//on the ground
+					pitch_roll_for_slope( ent );
+				}
+			}
+
+			continue;	// players are ucmd driven
+		}
+
+		G_RunThink( ent );	// be aware that ent may be free after returning from here, at least one func frees them
+		ClearNPCGlobals();			//	but these 2 funcs are ok
+		//UpdateTeamCounters( ent );	//	   to call anyway on a freed ent.
+	}
+
+	// perform final fixups on the player
+	ent = &g_entities[0];
+	if ( ent->inuse ) 
+	{
+		ClientEndFrame( ent );
+	}
+	if( g_numEntities->integer )
+	{
+		gi.Printf( S_COLOR_WHITE"Number of Entities in use : %d\n", ents_inuse );
+	}
+	//DEBUG STUFF
+	NAV::ShowDebugInfo(ent->currentOrigin, ent->waypoint);
+	NPC_ShowDebugInfo();
+
+	G_DynamicMusicUpdate();
+
+#if	AI_TIMERS
+	AITime -= navTime;
+	if ( AITime > 20 )
+	{
+		gi.Printf( S_COLOR_RED"ERROR: total AI time: %d\n", AITime );
+	}
+	else if ( AITime > 10 )
+	{
+		gi.Printf( S_COLOR_YELLOW"WARNING: total AI time: %d\n", AITime );
+	}
+	else if ( AITime > 2 )
+	{
+		gi.Printf( S_COLOR_GREEN"total AI time: %d\n", AITime );
+	}
+	if ( navTime > 20 )
+	{
+		gi.Printf( S_COLOR_RED"ERROR: total nav time: %d\n", navTime );
+	}
+	else if ( navTime > 10 )
+	{
+		gi.Printf( S_COLOR_YELLOW"WARNING: total nav time: %d\n", navTime );
+	}
+	else if ( navTime > 2 )
+	{
+		gi.Printf( S_COLOR_GREEN"total nav time: %d\n", navTime );
+	}
+#endif//	AI_TIMERS
+
+extern int delayedShutDown;
+	if ( g_delayedShutdown->integer && delayedShutDown != 0 && delayedShutDown < level.time )
+	{
+		assert(0);
+		G_Error( "Game Errors. Scroll up the console to read them.\n" );
+	}
+
+#ifdef _DEBUG
+	if(!(level.framenum&0xff))
+	{
+		ValidateInUseBits();
+	}
+#endif
+
+#ifdef _XBOX
+	// update the water levels for npcs
+	extern void UpdateNPCWaterLevels(void);
+	UpdateNPCWaterLevels();
+#endif // _XBOX
+}
+
+
+
+extern qboolean player_locked;
+
+void G_LoadSave_WriteMiscData(void)
+{ 
+	gi.AppendToSaveGame('LCKD', &player_locked, sizeof(player_locked));
+}
+
+
+
+void G_LoadSave_ReadMiscData(void)
+{
+	gi.ReadFromSaveGame('LCKD', &player_locked, sizeof(player_locked));
+}
+
+
+/*
+void PrintEntClassname( int gentNum )
+{
+	Com_Printf( "%d: %s in snapshot\n", gentNum, g_entities[gentNum].classname );
+}
+*/
+IGhoul2InfoArray &TheGameGhoul2InfoArray()
+{
+	return gi.TheGhoul2InfoArray();
+}
diff --git a/code/game/g_mem.cpp b/code/game/g_mem.cpp
new file mode 100644
index 0000000..57345d8
--- /dev/null
+++ b/code/game/g_mem.cpp
@@ -0,0 +1,38 @@
+//
+// g_mem.c
+//
+// leave this line at the top for all g_xxxx.cpp files...
+#include "g_headers.h"
+
+
+
+
+#include "g_local.h"
+
+
+/*#define POOLSIZE	(2 * 1024 * 1024)
+
+static char		memoryPool[POOLSIZE];
+*/
+static int		allocPoint;
+static cvar_t	*g_debugalloc;
+
+void *G_Alloc( int size ) {
+	if ( g_debugalloc->integer ) {
+		gi.Printf( "G_Alloc of %i bytes\n", size );
+	}
+
+
+	allocPoint += size;
+	
+	return gi.Malloc(size, TAG_G_ALLOC, qfalse);
+}
+
+void G_InitMemory( void ) {
+	allocPoint = 0;
+	g_debugalloc = gi.cvar ("g_debugalloc", "0", 0);
+}
+
+void Svcmd_GameMem_f( void ) {
+	gi.Printf( "Game memory status: %i allocated\n", allocPoint );
+}
diff --git a/code/game/g_misc.cpp b/code/game/g_misc.cpp
new file mode 100644
index 0000000..26c04bf
--- /dev/null
+++ b/code/game/g_misc.cpp
@@ -0,0 +1,3297 @@
+// g_misc.c
+
+// leave this line at the top for all g_xxxx.cpp files...
+#include "g_headers.h"
+
+
+#include "g_local.h"
+#include "g_functions.h"
+#include "g_nav.h"
+#include "g_items.h"
+
+extern gentity_t *G_FindDoorTrigger( gentity_t *door );
+extern void G_SetEnemy( gentity_t *self, gentity_t *enemy );
+extern void SetMiscModelDefaults( gentity_t *ent, useFunc_t use_func, char *material, int solid_mask,int animFlag, 
+									qboolean take_damage, qboolean damage_model);
+
+#define MAX_AMMO_GIVE 4
+
+
+
+/*QUAKED func_group (0 0 0) ?
+Used to group brushes together just for editor convenience.  They are turned into normal brushes by the utilities.
+
+q3map_onlyvertexlighting 1	=	brush only gets vertex lighting (reduces bsp size!)
+*/
+
+
+/*QUAKED info_null (0 0.5 0) (-4 -4 -4) (4 4 4) LIGHT
+Used as a positional target for calculations in the utilities (spotlights, etc), but removed during gameplay.
+
+LIGHT - If this info_null is only targeted by a non-switchable light (a light without a targetname), it does NOT spawn in at all and doesn't count towards the # of entities on the map, even at map spawn/load
+*/
+void SP_info_null( gentity_t *self ) {
+	if ( (self->spawnflags&1) )
+	{//only used as a light target, so bugger off
+		G_FreeEntity( self );
+		return;
+	}
+	//FIXME: store targetname and vector (origin) in a list for further reference... remove after 1st second of game?
+	G_SetOrigin( self, self->s.origin );
+	self->e_ThinkFunc = thinkF_G_FreeEntity;
+	//Give other ents time to link
+	self->nextthink = level.time + START_TIME_REMOVE_ENTS;
+}
+
+
+/*QUAKED info_notnull (0 0.5 0) (-4 -4 -4) (4 4 4)
+Used as a positional target for in-game calculation, like jumppad targets.
+target_position does the same thing
+*/
+void SP_info_notnull( gentity_t *self ){
+	//FIXME: store in ref_tag system?
+	G_SetOrigin( self, self->s.origin );
+}
+
+
+/*QUAKED lightJunior (0 0.7 0.3) (-8 -8 -8) (8 8 8) nonlinear angle negative_spot negative_point
+Non-displayed light that only affects dynamic game models, but does not contribute to lightmaps
+"light" overrides the default 300 intensity.
+Nonlinear checkbox gives inverse square falloff instead of linear 
+Angle adds light:surface angle calculations (only valid for "Linear" lights) (wolf)
+Lights pointed at a target will be spotlights.
+"radius" overrides the default 64 unit radius of a spotlight at the target point.
+"fade" falloff/radius adjustment value. multiply the run of the slope by "fade" (1.0f default) (only valid for "Linear" lights) (wolf)
+*/
+
+/*QUAKED light (0 1 0) (-8 -8 -8) (8 8 8) linear noIncidence START_OFF
+Non-displayed light.
+"light" overrides the default 300 intensity. - affects size
+a negative "light" will subtract the light's color
+'Linear' checkbox gives linear falloff instead of inverse square
+'noIncidence' checkbox makes lighting smoother
+Lights pointed at a target will be spotlights.
+"radius" overrides the default 64 unit radius of a spotlight at the target point.
+"scale" multiplier for the light intensity - does not affect size (default 1)
+		greater than 1 is brighter, between 0 and 1 is dimmer.
+"color" sets the light's color
+"targetname" to indicate a switchable light - NOTE that all lights with the same targetname will be grouped together and act as one light (ie: don't mix colors, styles or start_off flag)
+"style" to specify a specify light style, even for switchable lights!
+"style_off" light style to use when switched off (Only for switchable lights)
+
+   1 FLICKER (first variety)
+   2 SLOW STRONG PULSE
+   3 CANDLE (first variety)
+   4 FAST STROBE
+   5 GENTLE PULSE 1
+   6 FLICKER (second variety)
+   7 CANDLE (second variety)
+   8 CANDLE (third variety)
+   9 SLOW STROBE (fourth variety)
+   10 FLUORESCENT FLICKER
+   11 SLOW PULSE NOT FADE TO BLACK
+   12 FAST PULSE FOR JEREMY
+   13 Test Blending
+*/
+static void misc_lightstyle_set ( gentity_t *ent)
+{
+	const int mLightStyle = ent->count;
+	const int mLightSwitchStyle = ent->bounceCount;
+	const int mLightOffStyle = ent->fly_sound_debounce_time;
+	if (!ent->misc_dlight_active)
+	{	//turn off
+		if (mLightOffStyle)	//i have a light style i'd like to use when off
+		{
+			char lightstyle[32];
+			gi.GetConfigstring(CS_LIGHT_STYLES + (mLightOffStyle*3)+0, lightstyle, 32);
+			gi.SetConfigstring(CS_LIGHT_STYLES + (mLightStyle*3)+0, lightstyle);
+
+			gi.GetConfigstring(CS_LIGHT_STYLES + (mLightOffStyle*3)+1, lightstyle, 32);
+			gi.SetConfigstring(CS_LIGHT_STYLES + (mLightStyle*3)+1, lightstyle);
+
+			gi.GetConfigstring(CS_LIGHT_STYLES + (mLightOffStyle*3)+2, lightstyle, 32);
+			gi.SetConfigstring(CS_LIGHT_STYLES + (mLightStyle*3)+2, lightstyle);
+		}else
+		{
+			gi.SetConfigstring(CS_LIGHT_STYLES + (mLightStyle*3)+0, "a");
+			gi.SetConfigstring(CS_LIGHT_STYLES + (mLightStyle*3)+1, "a");
+			gi.SetConfigstring(CS_LIGHT_STYLES + (mLightStyle*3)+2, "a");
+		}
+	} 
+	else
+	{	//Turn myself on now
+		if (mLightSwitchStyle)	//i have a light style i'd like to use when on
+		{
+			char lightstyle[32];
+			gi.GetConfigstring(CS_LIGHT_STYLES + (mLightSwitchStyle*3)+0, lightstyle, 32);
+			gi.SetConfigstring(CS_LIGHT_STYLES + (mLightStyle*3)+0, lightstyle);
+
+			gi.GetConfigstring(CS_LIGHT_STYLES + (mLightSwitchStyle*3)+1, lightstyle, 32);
+			gi.SetConfigstring(CS_LIGHT_STYLES + (mLightStyle*3)+1, lightstyle);
+
+			gi.GetConfigstring(CS_LIGHT_STYLES + (mLightSwitchStyle*3)+2, lightstyle, 32);
+			gi.SetConfigstring(CS_LIGHT_STYLES + (mLightStyle*3)+2, lightstyle);
+		}
+		else
+		{
+			gi.SetConfigstring(CS_LIGHT_STYLES + (mLightStyle*3)+0, "z");
+			gi.SetConfigstring(CS_LIGHT_STYLES + (mLightStyle*3)+1, "z");
+			gi.SetConfigstring(CS_LIGHT_STYLES + (mLightStyle*3)+2, "z");
+		}
+	}
+}
+void SP_light( gentity_t *self ) {
+	if (!self->targetname )
+	{//if i don't have a light style switch, the i go away
+		G_FreeEntity( self );
+		return;
+	}
+
+	G_SpawnInt( "style", "0", &self->count );
+	G_SpawnInt( "switch_style", "0", &self->bounceCount );
+	G_SpawnInt( "style_off", "0", &self->fly_sound_debounce_time );
+	G_SetOrigin( self, self->s.origin );
+	gi.linkentity( self );
+
+	self->e_UseFunc = useF_misc_dlight_use;
+	self->e_clThinkFunc = clThinkF_NULL;
+
+	self->s.eType = ET_GENERAL;
+	self->misc_dlight_active = qfalse;
+	self->svFlags |= SVF_NOCLIENT;
+
+	if ( !(self->spawnflags & 4) )
+	{	//turn myself on now
+		self->misc_dlight_active = qtrue;
+	}
+	misc_lightstyle_set (self);
+}
+
+void misc_dlight_use ( gentity_t *ent, gentity_t *other, gentity_t *activator )
+{
+	G_ActivateBehavior(ent,BSET_USE);
+
+	ent->misc_dlight_active = !ent->misc_dlight_active;	//toggle
+	misc_lightstyle_set (ent);
+}
+
+
+/*
+=================================================================================
+
+TELEPORTERS
+
+=================================================================================
+*/
+
+void TeleportPlayer( gentity_t *player, vec3_t origin, vec3_t angles ) 
+{
+	if ( player->NPC && ( player->NPC->aiFlags&NPCAI_FORM_TELE_NAV ) )
+	{
+		//My leader teleported, I was trying to catch up, take this off
+		player->NPC->aiFlags &= ~NPCAI_FORM_TELE_NAV;
+		
+	}
+
+	// unlink to make sure it can't possibly interfere with G_KillBox
+	gi.unlinkentity (player);
+
+	VectorCopy ( origin, player->client->ps.origin );
+	player->client->ps.origin[2] += 1;
+	VectorCopy ( player->client->ps.origin, player->currentOrigin );
+
+	// spit the player out
+	AngleVectors( angles, player->client->ps.velocity, NULL, NULL );
+	VectorScale( player->client->ps.velocity, 0, player->client->ps.velocity );
+	//player->client->ps.pm_time = 160;		// hold time
+	//player->client->ps.pm_flags |= PMF_TIME_KNOCKBACK;
+
+	// toggle the teleport bit so the client knows to not lerp
+	player->client->ps.eFlags ^= EF_TELEPORT_BIT;
+
+	// set angles
+	SetClientViewAngle( player, angles );
+
+	// kill anything at the destination
+	G_KillBox (player);
+
+	// save results of pmove
+	PlayerStateToEntityState( &player->client->ps, &player->s );
+
+	gi.linkentity (player);
+}
+
+void TeleportMover( gentity_t *mover, vec3_t origin, vec3_t diffAngles, qboolean snapAngle ) 
+{//FIXME: need an effect
+	vec3_t		oldAngle, newAngle;
+	float		speed;
+
+	// unlink to make sure it can't possibly interfere with G_KillBox
+	gi.unlinkentity (mover);
+
+	//reposition it
+	VectorCopy( origin, mover->s.pos.trBase );
+	VectorCopy( origin, mover->currentOrigin );
+
+	//Maintain their previous speed, but adjusted for new direction
+	if ( snapAngle )
+	{//not a diffAngle, actually an absolute angle
+		vec3_t	dir;
+
+		VectorCopy( diffAngles, newAngle );
+		AngleVectors( newAngle, dir, NULL, NULL );
+		VectorNormalize( dir );//necessary?
+		speed = VectorLength( mover->s.pos.trDelta );
+		VectorScale( dir, speed, mover->s.pos.trDelta );
+		mover->s.pos.trTime = level.time;
+
+		VectorSubtract( newAngle, mover->s.apos.trBase, diffAngles );
+		VectorCopy( newAngle, mover->s.apos.trBase );
+	}
+	else
+	{
+		speed = VectorNormalize( mover->s.pos.trDelta );
+
+		vectoangles( mover->s.pos.trDelta, oldAngle );
+		VectorAdd( oldAngle, diffAngles, newAngle );
+
+		AngleVectors( newAngle, mover->s.pos.trDelta, NULL, NULL );
+		VectorNormalize( mover->s.pos.trDelta );
+
+		VectorScale( mover->s.pos.trDelta, speed, mover->s.pos.trDelta );
+		mover->s.pos.trTime = level.time;
+
+		//Maintain their previous angles, but adjusted to new orientation
+		VectorAdd( mover->s.apos.trBase, diffAngles, mover->s.apos.trBase );
+	}
+
+	//Maintain their previous anglespeed, but adjusted to new orientation
+	speed = VectorNormalize( mover->s.apos.trDelta );
+	VectorAdd( mover->s.apos.trDelta, diffAngles, mover->s.apos.trDelta );
+	VectorNormalize( mover->s.apos.trDelta );
+	VectorScale( mover->s.apos.trDelta, speed, mover->s.apos.trDelta );
+
+	mover->s.apos.trTime = level.time;
+	
+	//Tell them it was teleported this move
+	mover->s.eFlags |= EF_TELEPORT_BIT;
+
+	// kill anything at the destination
+	//G_KillBox (mover);
+	//FIXME: call touch func instead of killbox?
+
+	gi.linkentity (mover);
+}
+
+void teleporter_touch (gentity_t *self, gentity_t *other, trace_t *trace)
+{
+	gentity_t		*dest;
+
+	if (!other->client)
+		return;
+	dest = 	G_PickTarget( self->target );
+	if (!dest) {
+		gi.Printf ("Couldn't find teleporter destination\n");
+		return;
+	}
+
+	TeleportPlayer( other, dest->s.origin, dest->s.angles );
+}
+
+/*QUAK-D misc_teleporter (1 0 0) (-32 -32 -24) (32 32 -16)
+Stepping onto this disc will teleport players to the targeted misc_teleporter_dest object.
+*/
+void SP_misc_teleporter (gentity_t *ent)
+{
+	gentity_t		*trig;
+
+	if (!ent->target)
+	{
+		gi.Printf ("teleporter without a target.\n");
+		G_FreeEntity( ent );
+		return;
+	}
+
+	ent->s.modelindex = G_ModelIndex( "models/objects/dmspot.md3" );
+	ent->s.clientNum = 1;
+//	ent->s.loopSound = G_SoundIndex("sound/world/amb10.wav");
+	ent->contents = CONTENTS_SOLID;
+
+	G_SetOrigin( ent, ent->s.origin );
+
+	VectorSet (ent->mins, -32, -32, -24);
+	VectorSet (ent->maxs, 32, 32, -16);
+	gi.linkentity (ent);
+
+	trig = G_Spawn ();
+	trig->e_TouchFunc = touchF_teleporter_touch;
+	trig->contents = CONTENTS_TRIGGER;
+	trig->target = ent->target;
+	trig->owner = ent;
+	G_SetOrigin( trig, ent->s.origin );
+	VectorSet (trig->mins, -8, -8, 8);
+	VectorSet (trig->maxs, 8, 8, 24);
+	gi.linkentity (trig);
+	
+}
+
+/*QUAK-D misc_teleporter_dest (1 0 0) (-32 -32 -24) (32 32 -16) - - NODRAW
+Point teleporters at these.
+*/
+void SP_misc_teleporter_dest( gentity_t *ent ) {
+	if ( ent->spawnflags & 4 ){
+		return;
+	}
+
+	G_SetOrigin( ent, ent->s.origin );
+
+	gi.linkentity (ent);
+}
+
+
+//===========================================================
+
+/*QUAKED misc_model (1 0 0) (-16 -16 -16) (16 16 16) RMG SOLID
+"model"		arbitrary .md3 or .ase file to display
+"_frame"	"x" which frame from an animated md3
+"modelscale"	"x" uniform scale
+"modelscale_vec" "x y z" scale model in each axis
+"_remap"	"from to" remap a shader in this model
+turns into BSP triangles - not solid by default (click SOLID or use _clipmodel shader)
+*/
+void SP_misc_model( gentity_t *ent ) {
+	G_FreeEntity( ent );
+}
+
+/*QUAKED misc_model_static (1 0 0) (-16 -16 0) (16 16 16)
+"model"		arbitrary .md3 file to display
+"_frame"	"x" which frame from an animated md3
+"modelscale"	"x" uniform scale
+"modelscale_vec" "x y z" scale model in each axis
+"zoffset"	units to offset vertical culling position by, can be
+			negative or positive. This does not affect the actual
+			position of the model, only the culling position. Use
+			it for models with stupid origins that go below the
+			ground and whatnot.
+
+loaded as a model in the renderer - does not take up precious bsp space!
+*/
+extern void CG_CreateMiscEntFromGent(gentity_t *ent, const vec3_t scale, float zOff); //cg_main.cpp
+void SP_misc_model_static(gentity_t *ent)
+{
+	char		*value;
+	float		temp;
+	float		zOff;
+	vec3_t		scale;
+
+	G_SpawnString("modelscale_vec", "1 1 1", &value);
+	sscanf( value, "%f %f %f", &scale[ 0 ], &scale[ 1 ], &scale[ 2 ] );
+
+	G_SpawnFloat( "modelscale", "0", &temp);
+	if (temp != 0.0f)
+	{
+		scale[ 0 ] = scale[ 1 ] = scale[ 2 ] = temp;
+	}
+
+	G_SpawnFloat( "zoffset", "0", &zOff);
+
+	if (!ent->model)
+	{
+		Com_Error( ERR_DROP,"misc_model_static at %s with out a MODEL!\n", vtos(ent->s.origin) );
+	}
+	//we can be horrible and cheat since this is SP!
+	CG_CreateMiscEntFromGent(ent, scale, zOff);
+	G_FreeEntity( ent );
+}
+
+//===========================================================
+
+void setCamera ( gentity_t *ent )
+{
+	vec3_t		dir;
+	gentity_t	*target = 0;
+
+	// frame holds the rotate speed
+	if ( ent->owner->spawnflags & 1 ) 
+	{
+		ent->s.frame = 25;
+	} 
+	else if ( ent->owner->spawnflags & 2 ) 
+	{
+		ent->s.frame = 75;
+	}
+
+	// clientNum holds the rotate offset
+	ent->s.clientNum = ent->owner->s.clientNum;
+
+	VectorCopy( ent->owner->s.origin, ent->s.origin2 );
+
+	// see if the portal_camera has a target
+	if (ent->owner->target) {
+		target = G_PickTarget( ent->owner->target );
+	}
+	if ( target ) 
+	{
+		VectorSubtract( target->s.origin, ent->owner->s.origin, dir );
+		VectorNormalize( dir );
+	} 
+	else 
+	{
+		G_SetMovedir( ent->owner->s.angles, dir );
+	}
+
+	ent->s.eventParm = DirToByte( dir );
+}
+
+void cycleCamera( gentity_t *self )
+{
+	self->owner = G_Find( self->owner, FOFS(targetname), self->target );
+	if  ( self->owner == NULL )
+	{
+		//Uh oh! Not targeted at any ents!  Or reached end of list?  Which is it?
+		//for now assume reached end of list and are cycling
+		self->owner = G_Find( self->owner, FOFS(targetname), self->target );
+		if  ( self->owner == NULL )
+		{//still didn't find one
+			gi.Printf( "Couldn't find target for misc_portal_surface\n" );
+			G_FreeEntity( self );
+			return;
+		}
+	}
+	setCamera( self );
+
+	if ( self->e_ThinkFunc == thinkF_cycleCamera )
+	{
+		if ( self->owner->wait > 0 )
+		{
+			self->nextthink = level.time + self->owner->wait;
+		}
+		else
+		{
+			self->nextthink = level.time + self->wait;
+		}
+	}
+}
+
+void misc_portal_use( gentity_t *self, gentity_t *other, gentity_t *activator )
+{
+	cycleCamera( self );
+}
+
+void locateCamera( gentity_t *ent ) 
+{//FIXME: make this fadeout with distance from misc_camera_portal
+
+	ent->owner = G_Find(NULL, FOFS(targetname), ent->target);
+	if ( !ent->owner ) 
+	{
+		gi.Printf( "Couldn't find target for misc_portal_surface\n" );
+		G_FreeEntity( ent );
+		return;
+	}
+
+	setCamera( ent );
+
+	if ( !ent->targetname )
+	{//not targetted, so auto-cycle
+		if ( G_Find(ent->owner, FOFS(targetname), ent->target) != NULL  )
+		{//targeted at more than one thing
+			ent->e_ThinkFunc = thinkF_cycleCamera;
+			if ( ent->owner->wait > 0 )
+			{
+				ent->nextthink = level.time + ent->owner->wait;
+			}
+			else
+			{
+				ent->nextthink = level.time + ent->wait;
+			}
+		}
+	}
+}
+
+/*QUAKED misc_portal_surface (0 0 1) (-8 -8 -8) (8 8 8)
+The portal surface nearest this entity will show a view from the targeted misc_portal_camera, or a mirror view if untargeted.
+This must be within 64 world units of the surface!
+
+targetname - When used, cycles to the next misc_portal_camera it's targeted
+wait - makes it auto-cycle between all cameras it's pointed at at intevervals of specified number of seconds.
+
+  cameras will be cycled through in the order they were created on the map.
+*/
+void SP_misc_portal_surface(gentity_t *ent) 
+{
+	VectorClear( ent->mins );
+	VectorClear( ent->maxs );
+	gi.linkentity (ent);
+
+	ent->svFlags = SVF_PORTAL;
+	ent->s.eType = ET_PORTAL;
+	ent->wait *= 1000;
+
+	if ( !ent->target ) 
+	{//mirror?
+		VectorCopy( ent->s.origin, ent->s.origin2 );
+	} 
+	else 
+	{
+		ent->e_ThinkFunc = thinkF_locateCamera;
+		ent->nextthink = level.time + 100;
+
+		if ( ent->targetname )
+		{
+			ent->e_UseFunc = useF_misc_portal_use;
+		}
+	}
+}
+
+/*QUAKED misc_portal_camera (0 0 1) (-8 -8 -8) (8 8 8) slowrotate fastrotate
+The target for a misc_portal_surface.  You can set either angles or target another entity (NOT an info_null) to determine the direction of view.
+"roll" an angle modifier to orient the camera around the target vector;
+*/
+void SP_misc_portal_camera(gentity_t *ent) {
+	float	roll;
+
+	VectorClear( ent->mins );
+	VectorClear( ent->maxs );
+	gi.linkentity (ent);
+
+	G_SpawnFloat( "roll", "0", &roll );
+
+	ent->s.clientNum = roll/360.0 * 256;
+	ent->wait *= 1000;
+}
+
+void G_SubBSPSpawnEntitiesFromString(const char *entityString, vec3_t posOffset, vec3_t angOffset);
+
+/*QUAKED misc_bsp (1 0 0) (-16 -16 -16) (16 16 16)
+"bspmodel"		arbitrary .bsp file to display
+*/
+void SP_misc_bsp(gentity_t *ent) 
+{
+	char	temp[MAX_QPATH];
+	char	*out;
+	float	newAngle;
+	int		tempint;
+
+	G_SpawnFloat( "angle", "0", &newAngle );
+	if (newAngle != 0.0)
+	{
+		ent->s.angles[1] = newAngle;
+	}
+	// don't support rotation any other way
+	ent->s.angles[0] = 0.0;
+	ent->s.angles[2] = 0.0;
+	
+	G_SpawnString("bspmodel", "", &out);
+
+	ent->s.eFlags = EF_PERMANENT;
+
+	// Mainly for debugging
+	G_SpawnInt( "spacing", "0", &tempint);
+	ent->s.time2 = tempint;
+	G_SpawnInt( "flatten", "0", &tempint);
+	ent->s.time = tempint;
+
+	Com_sprintf(temp, MAX_QPATH, "#%s", out);
+	gi.SetBrushModel( ent, temp );  // SV_SetBrushModel -- sets mins and maxs
+	G_BSPIndex(temp);
+
+	level.mNumBSPInstances++;
+	Com_sprintf(temp, MAX_QPATH, "%d-", level.mNumBSPInstances);
+	VectorCopy(ent->s.origin, level.mOriginAdjust);
+	level.mRotationAdjust = ent->s.angles[1];
+	level.mTargetAdjust = temp;
+	level.hasBspInstances = qtrue;
+	level.mBSPInstanceDepth++;
+
+	VectorCopy( ent->s.origin, ent->s.pos.trBase );
+	VectorCopy( ent->s.origin, ent->currentOrigin );
+	VectorCopy( ent->s.angles, ent->s.apos.trBase );
+	VectorCopy( ent->s.angles, ent->currentAngles );
+
+	ent->s.eType = ET_MOVER;
+
+	gi.linkentity (ent);
+
+	const char *ents = gi.SetActiveSubBSP(ent->s.modelindex);
+	if (ents)
+	{
+		G_SubBSPSpawnEntitiesFromString(ents, ent->s.origin, ent->s.angles);
+	}
+	gi.SetActiveSubBSP(-1);
+
+	level.mBSPInstanceDepth--;
+}
+
+#define MAX_INSTANCE_TYPES		16
+
+void AddSpawnField(char *field, char *value);
+
+/*QUAKED terrain (1.0 1.0 1.0) ? NOVEHDMG
+
+NOVEHDMG - don't damage vehicles upon impact with this terrain
+
+Terrain entity
+It will stretch to the full height of the brush
+
+numPatches - integer number of patches to split the terrain brush into (default 200)
+terxels - integer number of terxels on a patch side (default 4) (2 <= count <= 8)
+seed - integer seed for random terrain generation (default 0)
+textureScale - float scale of texture (default 0.005)
+heightmap - name of heightmap data image to use, located in heightmaps/*.png. (must be PNG format)
+terrainDef - defines how the game textures the terrain (file is base/ext_data/rmg/*.terrain - default is grassyhills)
+instanceDef - defines which bsp instances appear
+miscentDef - defines which client models spawn on the terrain (file is base/ext_data/rmg/*.miscents)
+densityMap - how dense the client models are packed
+
+*/
+void SP_terrain(gentity_t *ent) 
+{
+#ifdef _XBOX
+	assert(0);
+#else
+	char				temp[MAX_INFO_STRING];
+	char				final[MAX_QPATH];
+//	char				seed[MAX_QPATH];
+//	char				missionType[MAX_QPATH];
+//	char				soundSet[MAX_QPATH];
+	int					shaderNum, i;
+	char				*value;
+	int					terrainID;
+
+	//k, found a terrain, just set rmg to 1.
+	//This should always get set before RE_LoadWorldMap and all that is
+	//called which is all that matters.
+	//gi.cvar_set("RMG", "1");
+
+	VectorClear (ent->s.angles);
+	gi.SetBrushModel( ent, ent->model );
+
+	// Get the shader from the top of the brush
+//	shaderNum = gi.CM_GetShaderNum(s.modelindex);
+	shaderNum = 0;
+
+	//rww - Why not do this all the time? Not like terrain entities are used when you don't want them to be terrain.
+/*	if (g_RMG->integer)
+	{
+		gi.Cvar_VariableStringBuffer("RMG_seed", seed, MAX_QPATH);
+		gi.Cvar_VariableStringBuffer("RMG_mission", missionType, MAX_QPATH);
+
+	//	gi.Cvar_VariableStringBuffer("RMG_soundset", soundSet, MAX_QPATH);
+	//	gi.SetConfigstring(CS_AMBIENT_SOUNDSETS, soundSet );
+	}
+*/
+	// Arbitrary (but sane) limits to the number of terxels
+//	if((mTerxels < MIN_TERXELS) || (mTerxels > MAX_TERXELS))
+	{
+//		Com_printf("G_Terrain: terxels out of range - defaulting to 4\n");
+//		mTerxels = 4;
+	}
+
+	// Get info required for the common init
+	temp[0] = 0;
+	G_SpawnString("heightmap", "", &value);
+	Info_SetValueForKey(temp, "heightMap", value);
+
+	G_SpawnString("numpatches", "400", &value);
+	Info_SetValueForKey(temp, "numPatches", va("%d", atoi(value)));
+
+	G_SpawnString("terxels", "4", &value);
+	Info_SetValueForKey(temp, "terxels", va("%d", atoi(value)));
+
+	//Info_SetValueForKey(temp, "seed", seed);
+	Info_SetValueForKey(temp, "minx", va("%f", ent->mins[0]));
+	Info_SetValueForKey(temp, "miny", va("%f", ent->mins[1]));
+	Info_SetValueForKey(temp, "minz", va("%f", ent->mins[2]));
+	Info_SetValueForKey(temp, "maxx", va("%f", ent->maxs[0]));
+	Info_SetValueForKey(temp, "maxy", va("%f", ent->maxs[1]));
+	Info_SetValueForKey(temp, "maxz", va("%f", ent->maxs[2]));
+
+	Info_SetValueForKey(temp, "modelIndex", va("%d", ent->s.modelindex));
+
+	G_SpawnString("terraindef", "grassyhills", &value);
+	Info_SetValueForKey(temp, "terrainDef", value);
+
+	G_SpawnString("instancedef", "", &value);
+	Info_SetValueForKey(temp, "instanceDef", value);
+
+	G_SpawnString("miscentdef", "", &value);
+	Info_SetValueForKey(temp, "miscentDef", value);
+
+	//Info_SetValueForKey(temp, "missionType", missionType);
+	
+	for(i = 0; i < MAX_INSTANCE_TYPES; i++)
+	{
+		gi.Cvar_VariableStringBuffer(va("RMG_instance%d", i), final, MAX_QPATH);
+		if(strlen(final))
+		{
+			Info_SetValueForKey(temp, va("inst%d", i), final);
+		}
+	}
+
+	// Set additional data required on the client only
+	G_SpawnString("densitymap", "", &value);
+	Info_SetValueForKey(temp, "densityMap", value);
+
+	Info_SetValueForKey(temp, "shader", va("%d", shaderNum));
+	G_SpawnString("texturescale", "0.005", &value);
+	Info_SetValueForKey(temp, "texturescale", va("%f", atof(value)));
+
+	// Initialise the common aspects of the terrain
+	terrainID = gi.CM_RegisterTerrain(temp);
+//	SetCommon(common);
+
+	Info_SetValueForKey(temp, "terrainId", va("%d", terrainID));
+
+	// Let the entity know if it is random generated or not
+//	SetIsRandom(common->GetIsRandom());
+
+	// Let the game remember everything
+//	level.landScapes[terrainID] = ent;
+	//rww - I'm not doing this. Because it didn't even appear to be used. Is it?
+
+	// Send all the data down to the client
+	gi.SetConfigstring(CS_TERRAINS + terrainID, temp);
+
+	// Make sure the contents are properly set
+	ent->contents = CONTENTS_TERRAIN;
+	ent->svFlags = SVF_NOCLIENT;
+	ent->s.eFlags = EF_PERMANENT;
+	ent->s.eType = ET_TERRAIN;
+
+	// Hook into the world so physics will work
+	gi.linkentity(ent);
+
+	// If running RMG then initialize the terrain and handle team skins
+	//rww - Why not do this all the time? Not like terrain entities are used when you don't want them to be terrain.
+/* not using RMG
+	if ( g_RMG->integer ) 
+	{
+		gi.RMG_Init(terrainID);
+	}
+*/
+#endif	// _XBOX
+}
+
+//rww - Called by skyportal entities. This will check through entities and flag them
+//as portal ents if they are in the same pvs as a skyportal entity and pass
+//a direct point trace check between origins. I really wanted to use an eFlag for
+//flagging portal entities, but too many entities like to reset their eFlags.
+//Note that this was not part of the original wolf sky portal stuff.
+void G_PortalifyEntities(gentity_t *ent)
+{
+	int i = 0;
+	gentity_t *scan = NULL;
+
+	while (i < MAX_GENTITIES)
+	{
+		scan = &g_entities[i];
+
+		if (scan && scan->inuse && scan->s.number != ent->s.number && gi.inPVS(ent->s.origin, scan->currentOrigin))
+		{
+			trace_t tr;
+
+			gi.trace(&tr, ent->s.origin, vec3_origin, vec3_origin, scan->currentOrigin, ent->s.number, CONTENTS_SOLID, G2_NOCOLLIDE, 0);
+
+			if (tr.fraction == 1.0 || (tr.entityNum == scan->s.number && tr.entityNum != ENTITYNUM_NONE && tr.entityNum != ENTITYNUM_WORLD))
+			{
+				scan->s.isPortalEnt = qtrue; //he's flagged now
+			}
+		}
+
+		i++;
+	}
+
+	ent->e_ThinkFunc = thinkF_G_FreeEntity; //the portal entity is no longer needed because its information is stored in a config string.
+	ent->nextthink = level.time;
+}
+
+/*QUAKED misc_skyportal (.6 .7 .7) (-8 -8 0) (8 8 16)
+To have the portal sky fogged, enter any of the following values:
+"fogcolor" (r g b) (values 0.0-1.0)
+"fognear" distance from entity to start fogging
+"fogfar" distance from entity that fog is opaque
+rww - NOTE: fog doesn't work with these currently (at least not in this way).
+Use a fog brush instead.
+*/
+void SP_misc_skyportal (gentity_t *ent)
+{
+	vec3_t	fogv;	//----(SA)	
+	int		fogn;	//----(SA)	
+	int		fogf;	//----(SA)	
+	int		isfog = 0;	// (SA)
+
+	isfog += G_SpawnVector ("fogcolor", "0 0 0", fogv);
+	isfog += G_SpawnInt ("fognear", "0", &fogn);
+	isfog += G_SpawnInt ("fogfar", "300", &fogf);
+
+	gi.SetConfigstring( CS_SKYBOXORG, va("%.2f %.2f %.2f %i %.2f %.2f %.2f %i %i", ent->s.origin[0], ent->s.origin[1], ent->s.origin[2], isfog, fogv[0], fogv[1], fogv[2], fogn, fogf ) );
+
+	ent->e_ThinkFunc = thinkF_G_PortalifyEntities;
+	ent->nextthink = level.time + 1050; //give it some time first so that all other entities are spawned.
+}
+
+extern qboolean G_ClearViewEntity( gentity_t *ent );
+extern void G_SetViewEntity( gentity_t *self, gentity_t *viewEntity );
+extern void SP_fx_runner( gentity_t *ent );
+void camera_die( gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int mod,int dFlags,int hitLoc )
+{
+	if ( player && player->client && player->client->ps.viewEntity == self->s.number )
+	{
+		G_UseTargets2( self, player, self->target4 );
+		G_ClearViewEntity( player );
+		G_Sound( player, self->soundPos2 );
+	}
+	G_UseTargets2( self, player, self->closetarget );
+	//FIXME: explosion fx/sound
+	//leave sparks at origin- where base's pole is still at?
+	gentity_t *sparks = G_Spawn();
+	if ( sparks )
+	{
+		sparks->fxFile = "sparks/spark";
+		sparks->delay = 100;
+		sparks->random = 500;
+		sparks->s.angles[0] = 180;//point down
+		VectorCopy( self->s.origin, sparks->s.origin );
+		SP_fx_runner( sparks );
+	}
+
+	//bye!
+	self->takedamage = qfalse;
+	self->contents = 0;
+	self->s.eFlags |= EF_NODRAW;
+	self->s.modelindex = 0;
+}
+
+void camera_use( gentity_t *self, gentity_t *other, gentity_t *activator )
+{
+	if ( !activator || !activator->client || activator->s.number )
+	{//really only usable by the player
+		return;
+	}
+	self->painDebounceTime = level.time + (self->wait*1000);//FRAMETIME*5;//don't check for player buttons for 500 ms
+
+	// FIXME: I guess we are allowing them to switch to a dead camera.  Maybe we should conditionally do this though?
+	if ( /*self->health <= 0 ||*/ (player && player->client && player->client->ps.viewEntity == self->s.number) )
+	{//I'm already viewEntity, or I'm destroyed, find next
+		gentity_t *next = NULL;
+		if ( self->target2 != NULL )
+		{
+			next = G_Find( NULL, FOFS(targetname), self->target2 );
+		}
+		if ( next )
+		{//found another one
+			if ( !Q_stricmp( "misc_camera", next->classname ) )
+			{//make sure it's another camera
+				camera_use( next, other, activator );
+			}
+		}
+		else //if ( self->health > 0 )
+		{//I was the last (only?) one, clear out the viewentity
+			G_UseTargets2( self, activator, self->target4 );
+			G_ClearViewEntity( activator );
+			G_Sound( activator, self->soundPos2 );
+		}
+	}
+	else
+	{//set me as view entity
+		G_UseTargets2( self, activator, self->target3 );
+		self->s.eFlags |= EF_NODRAW;
+		self->s.modelindex = 0;
+		G_SetViewEntity( activator, self );
+		G_Sound( activator, self->soundPos1 );
+	}
+}
+
+void camera_aim( gentity_t *self )
+{
+	self->nextthink = level.time + FRAMETIME;
+	if ( player && player->client && player->client->ps.viewEntity == self->s.number )
+	{//I am the viewEntity
+		if ( player->client->usercmd.forwardmove || player->client->usercmd.rightmove || player->client->usercmd.upmove )
+		{//player wants to back out of camera
+			G_UseTargets2( self, player, self->target4 );
+			G_ClearViewEntity( player );
+			G_Sound( player, self->soundPos2 );
+			self->painDebounceTime = level.time + (self->wait*1000);//FRAMETIME*5;//don't check for player buttons for 500 ms
+			if ( player->client->usercmd.upmove > 0 )
+			{//stop player from doing anything for a half second after
+				player->aimDebounceTime = level.time + 500;
+			}
+		}
+		else if ( self->painDebounceTime < level.time )
+		{//check for use button
+			if ( (player->client->usercmd.buttons&BUTTON_USE) )
+			{//player pressed use button, wants to cycle to next
+				camera_use( self, player, player );
+			}
+		}
+		else
+		{//don't draw me when being looked through
+			self->s.eFlags |= EF_NODRAW;
+			self->s.modelindex = 0;
+		}
+	}
+	else if ( self->health > 0 )
+	{//still alive, can draw me again
+		self->s.eFlags &= ~EF_NODRAW;
+		self->s.modelindex = self->s.modelindex3;
+	}
+	//update my aim
+	if ( self->target )
+	{
+		gentity_t *targ = G_Find( NULL, FOFS(targetname), self->target );
+		if ( targ )
+		{
+			vec3_t angles, dir;
+			VectorSubtract( targ->currentOrigin, self->currentOrigin, dir );
+			vectoangles( dir, angles );
+			//FIXME: if a G2 model, do a bone override..???
+			VectorCopy( self->currentAngles, self->s.apos.trBase );
+
+			for( int i = 0; i < 3; i++ )
+			{
+				angles[i] = AngleNormalize180( angles[i] );
+				self->s.apos.trDelta[i] = AngleNormalize180( (angles[i]-self->currentAngles[i])*10 );
+			}
+			//VectorSubtract( angles, self->currentAngles, self->s.apos.trDelta );
+			//VectorScale( self->s.apos.trDelta, 10, self->s.apos.trDelta );
+			self->s.apos.trTime = level.time;
+			self->s.apos.trDuration = FRAMETIME;
+			VectorCopy( angles, self->currentAngles );
+
+			if ( DistanceSquared( self->currentAngles, self->lastAngles ) > 0.01f ) // if it moved at all, start a loop sound? not exactly the "bestest" solution
+			{
+				self->s.loopSound = G_SoundIndex( "sound/movers/objects/cameramove_lp2" );
+			}
+			else
+			{
+				self->s.loopSound = 0; // not moving so don't bother
+			}
+
+			VectorCopy( self->currentAngles, self->lastAngles );
+			//G_SetAngles( self, angles );
+		}
+	}
+}
+/*QUAKED misc_camera (0 0 1) (-8 -8 -12) (8 8 16) VULNERABLE
+A model in the world that can be used by the player to look through it's viewpoint
+
+There will be a video overlay instead of the regular HUD and the FOV will be wider
+
+VULNERABLE - allow camera to be destroyed
+
+"target" - camera will remain pointed at this entity (if it's a train or some other moving object, it will keep following it)
+"target2" - when player is in this camera and hits the use button, it will cycle to this next camera (if no target2, returns to normal view )
+"target3" - thing to use when player enters this camera view
+"target4" - thing to use when player leaves this camera view
+"closetarget" - (sigh...) yet another target, fired this when it's destroyed
+"wait"    - how long to wait between being used (default 0.5)
+*/
+void SP_misc_camera( gentity_t *self ) 
+{
+	G_SpawnFloat( "wait", "0.5", &self->wait );
+
+	//FIXME: spawn base, too
+	gentity_t *base = G_Spawn();
+	if ( base )
+	{
+		base->s.modelindex = G_ModelIndex( "models/map_objects/kejim/impcam_base.md3" );
+		VectorCopy( self->s.origin, base->s.origin );
+		base->s.origin[2] += 16;
+		G_SetOrigin( base, base->s.origin );
+		G_SetAngles( base, self->s.angles );
+		gi.linkentity( base );
+	}
+	self->s.modelindex3 = self->s.modelindex = G_ModelIndex( "models/map_objects/kejim/impcam.md3" );
+	self->soundPos1 = G_SoundIndex( "sound/movers/camera_on.mp3" );
+	self->soundPos2 = G_SoundIndex( "sound/movers/camera_off.mp3" );
+	G_SoundIndex( "sound/movers/objects/cameramove_lp2" );
+
+	G_SetOrigin( self, self->s.origin );
+	G_SetAngles( self, self->s.angles );
+	self->s.apos.trType = TR_LINEAR_STOP;//TR_INTERPOLATE;//
+	self->alt_fire = qtrue;
+	VectorSet( self->mins, -8, -8, -12 );
+	VectorSet( self->maxs, 8, 8, 0 );
+	self->contents = CONTENTS_SOLID;
+	gi.linkentity( self );
+
+	self->fxID = G_EffectIndex( "sparks/spark" );
+
+	if ( self->spawnflags & 1 ) // VULNERABLE
+	{
+		self->takedamage = qtrue;
+	}
+
+	self->health = 10;
+	self->e_DieFunc = dieF_camera_die;
+	
+	self->e_UseFunc = useF_camera_use;
+
+	self->e_ThinkFunc = thinkF_camera_aim;
+	self->nextthink = level.time + START_TIME_LINK_ENTS;
+}
+/*
+======================================================================
+
+  SHOOTERS
+
+======================================================================
+*/
+
+void Use_Shooter( gentity_t *ent, gentity_t *other, gentity_t *activator ) 
+{
+/*	vec3_t		dir;
+	float		deg;
+	vec3_t		up, right;
+*/
+	G_ActivateBehavior(ent,BSET_USE);
+/*
+	// see if we have a target
+	if ( ent->enemy ) {
+		VectorSubtract( ent->enemy->currentOrigin, ent->s.origin, dir );
+		VectorNormalize( dir );
+	} else {
+		VectorCopy( ent->movedir, dir );
+	}
+
+	// randomize a bit
+	PerpendicularVector( up, dir );
+	CrossProduct( up, dir, right );
+
+	deg = crandom() * ent->random;
+	VectorMA( dir, deg, up, dir );
+
+	deg = crandom() * ent->random;
+	VectorMA( dir, deg, right, dir );
+
+	VectorNormalize( dir );
+
+	switch ( ent->s.weapon ) 
+	{
+	case WP_GRENADE_LAUNCHER:
+		fire_grenade( ent, ent->s.origin, dir );
+		break;
+	case WP_ROCKET_LAUNCHER:
+		fire_rocket( ent, ent->s.origin, dir );
+		break;
+	case WP_PLASMAGUN:
+		fire_plasma( ent, ent->s.origin, dir );
+		break;
+	}
+
+	G_AddEvent( ent, EV_FIRE_WEAPON, 0 );
+*/
+}
+
+void InitShooter( gentity_t *ent, int weapon ) {
+	ent->e_UseFunc = useF_Use_Shooter;
+	ent->s.weapon = weapon;
+
+	RegisterItem( FindItemForWeapon( (weapon_t) weapon ) );
+
+	G_SetMovedir( ent->s.angles, ent->movedir );
+
+	if ( !ent->random ) {
+		ent->random = 1.0;
+	}
+	ent->random = sin( M_PI * ent->random / 180 );
+	// target might be a moving object, so we can't set movedir for it
+	if ( ent->target ) {
+		G_SetEnemy(ent, G_PickTarget( ent->target ));
+	}
+	gi.linkentity( ent );
+}
+
+/*QUAK-ED shooter_rocket (1 0 0) (-16 -16 -16) (16 16 16)
+Fires at either the target or the current direction.
+"random" the number of degrees of deviance from the taget. (1.0 default)
+*/
+void SP_shooter_rocket( gentity_t *ent ) 
+{
+//	InitShooter( ent, WP_TETRION_DISRUPTOR );
+}
+
+/*QUAK-ED shooter_plasma (1 0 0) (-16 -16 -16) (16 16 16)
+Fires at either the target or the current direction.
+"random" is the number of degrees of deviance from the taget. (1.0 default)
+*/
+void SP_shooter_plasma( gentity_t *ent ) 
+{
+	InitShooter( ent, WP_BRYAR_PISTOL);
+}
+
+/*QUAK-ED shooter_grenade (1 0 0) (-16 -16 -16) (16 16 16)
+Fires at either the target or the current direction.
+"random" is the number of degrees of deviance from the taget. (1.0 default)
+*/
+void SP_shooter_grenade( gentity_t *ent ) 
+{
+//	InitShooter( ent, WP_GRENADE_LAUNCHER);
+}
+
+
+/*QUAKED object_cargo_barrel1 (1 0 0) (-16 -16 -16) (16 16 29) SMALLER KLINGON NO_SMOKE POWDERKEG
+Cargo Barrel
+if given a targetname, using it makes it explode
+
+SMALLER - (-8, -8, -16) (8, 8, 8)
+KLINGON - klingon style barrel
+NO_SMOKE - will not leave lingering smoke cloud when killed
+POWDERKEG - wooden explosive barrel
+
+health		 default = 20 
+splashDamage default = 100
+splashRadius default = 200
+*/
+void SP_object_cargo_barrel1(gentity_t *ent)
+{
+	if(ent->spawnflags & 8)
+	{
+		ent->s.modelindex = G_ModelIndex( "/models/mapobjects/cargo/barrel_wood2.md3" );
+//		ent->sounds = G_SoundIndex("sound/weapons/explosions/explode3.wav");
+	}
+	else if(ent->spawnflags & 2)
+	{
+		ent->s.modelindex = G_ModelIndex( "/models/mapobjects/scavenger/k_barrel.md3" );
+//		ent->sounds = G_SoundIndex("sound/weapons/explosions/explode4.wav");
+	}
+	else
+	{
+		ent->s.modelindex = G_ModelIndex( va("/models/mapobjects/cargo/barrel%i.md3", Q_irand( 0, 2 )) );
+//		ent->sounds = G_SoundIndex("sound/weapons/explosions/explode1.wav");
+	}
+
+	ent->contents = CONTENTS_SOLID|CONTENTS_OPAQUE;
+	
+	if ( ent->spawnflags & 1 )
+	{
+		VectorSet (ent->mins, -8, -8, -16);
+		VectorSet (ent->maxs, 8, 8, 8);
+	}
+	else
+	{
+		VectorSet (ent->mins, -16, -16, -16);
+		VectorSet (ent->maxs, 16, 16, 29);
+	}
+
+	G_SetOrigin( ent, ent->s.origin );
+	VectorCopy( ent->s.angles, ent->s.apos.trBase );
+
+	if(!ent->health)
+		ent->health = 20;
+	
+	if(!ent->splashDamage)
+		ent->splashDamage = 100;
+
+	if(!ent->splashRadius)
+		ent->splashRadius = 200;
+
+	ent->takedamage = qtrue;
+
+	ent->e_DieFunc = dieF_ExplodeDeath_Wait;
+	
+	if(ent->targetname)
+		ent->e_UseFunc = useF_GoExplodeDeath;
+
+	gi.linkentity (ent);
+}
+
+
+/*QUAKED misc_dlight (0.2 0.8 0.2) (-4 -4 -4) (4 4 4) STARTOFF FADEON FADEOFF PULSE
+Dynamic light, toggles on and off when used
+  
+STARTOFF - Starts off
+FADEON - Fades from 0 Radius to start Radius
+FADEOFF - Fades from current Radius to 0 Radius before turning off
+PULSE - This flag must be checked if you want it to fade/switch between start and final RGBA, otherwise it will just sit at startRGBA
+
+ownername - Will display the light at the origin of the entity with this targetname
+
+startRGBA - Red Green Blue Radius to start with - This MUST be set or your light won't do anything
+
+These next values are used only if you want to fade/switch between 2 values (PULSE flag on)
+finalRGBA - Red Green Blue Radius to end with
+speed - how long to take to fade from start to final and final to start.  Also how long to fade on and off if appropriate flags are checked (seconds)
+finaltime - how long to hold at final (seconds)
+starttime - how long to hold at start (seconds)
+
+TODO: Add random to speed/radius?
+*/
+void SP_misc_dlight(gentity_t *ent)
+{
+	G_SetOrigin( ent, ent->s.origin );
+	gi.linkentity( ent );
+
+	ent->speed *= 1000;
+	ent->wait *= 1000;
+	ent->radius *= 1000;
+
+	//FIXME: attach self to a train or something?
+	ent->e_UseFunc = useF_misc_dlight_use;
+	
+	ent->misc_dlight_active = qfalse;
+	ent->e_clThinkFunc = clThinkF_NULL;
+
+	ent->s.eType = ET_GENERAL;
+	//Delay first think so we can find owner
+	if ( ent->ownername )
+	{
+		ent->e_ThinkFunc = thinkF_misc_dlight_think;
+		ent->nextthink = level.time + START_TIME_LINK_ENTS;
+	}
+
+	if ( !(ent->spawnflags & 1) )
+	{//Turn myself on now
+		GEntity_UseFunc( ent, ent, ent );
+	}
+}
+
+void misc_dlight_use_old ( gentity_t *ent, gentity_t *other, gentity_t *activator )
+{
+	G_ActivateBehavior(ent,BSET_USE);
+
+	if ( ent->misc_dlight_active )
+	{//We're on, turn off
+		if ( ent->spawnflags & 4 )
+		{//fade off
+			ent->pushDebounceTime = 3;
+		}
+		else
+		{
+			ent->misc_dlight_active = qfalse;
+			ent->e_clThinkFunc = clThinkF_NULL;
+
+			ent->s.eType = ET_GENERAL;
+			ent->svFlags &= ~SVF_BROADCAST;
+		}
+	}
+	else
+	{
+		//Start at start regardless of when we were turned off
+		if ( ent->spawnflags & 4 )
+		{//fade on
+			ent->pushDebounceTime = 2;
+		}
+		else
+		{//Just start on
+			ent->pushDebounceTime = 0;
+		}
+		ent->painDebounceTime = level.time;
+
+		ent->misc_dlight_active = qtrue;
+
+		ent->e_ThinkFunc = thinkF_misc_dlight_think;
+		ent->nextthink = level.time + FRAMETIME;
+
+		ent->e_clThinkFunc = clThinkF_CG_DLightThink;
+
+		ent->s.eType = ET_THINKER;
+		ent->svFlags |= SVF_BROADCAST;// Broadcast to all clients
+	}
+}
+
+void misc_dlight_think ( gentity_t *ent )
+{
+	//Stay Attached to owner
+	if ( ent->owner )
+	{
+		G_SetOrigin( ent, ent->owner->currentOrigin );
+		gi.linkentity( ent );
+	}
+	else if ( ent->ownername )
+	{
+		ent->owner = G_Find( NULL, FOFS(targetname), ent->ownername );
+		ent->ownername = NULL;
+	}
+	ent->nextthink = level.time + FRAMETIME;
+}
+
+
+void station_pain( gentity_t *self, gentity_t *inflictor, gentity_t *other, const vec3_t point, int damage, int mod,int hitLoc ) 
+{
+//	self->s.modelindex = G_ModelIndex("/models/mapobjects/stasis/plugin2_in.md3");
+//	self->s.eFlags &= ~ EF_ANIM_ALLFAST;
+//	self->s.eFlags |= EF_ANIM_ONCE;
+//	gi.linkentity (self);
+	self->s.modelindex = self->s.modelindex2;
+	gi.linkentity (self);
+}
+
+// --------------------------------------------------------------------
+//
+//   HEALTH/ARMOR plugin functions
+//
+// --------------------------------------------------------------------
+
+void health_use( gentity_t *self, gentity_t *other, gentity_t *activator);
+int ITM_AddArmor (gentity_t *ent, int count);
+int ITM_AddHealth (gentity_t *ent, int count);
+
+void health_shutdown( gentity_t *self )
+{
+	if (!(self->s.eFlags & EF_ANIM_ONCE))
+	{
+		self->s.eFlags &= ~ EF_ANIM_ALLFAST;
+		self->s.eFlags |= EF_ANIM_ONCE;
+
+		// Switch to and animate its used up model.
+		if (!Q_stricmp(self->model,"models/mapobjects/stasis/plugin2.md3"))	
+		{
+			self->s.modelindex = self->s.modelindex2;
+		}
+		else if (!Q_stricmp(self->model,"models/mapobjects/borg/plugin2.md3"))	
+		{
+			self->s.modelindex = self->s.modelindex2;
+		}                                
+		else if (!Q_stricmp(self->model,"models/mapobjects/stasis/plugin2_floor.md3"))	
+		{
+			self->s.modelindex = self->s.modelindex2;
+//			G_Sound(self, G_SoundIndex("sound/ambience/stasis/shrinkage1.wav") );
+		}
+		else if (!Q_stricmp(self->model,"models/mapobjects/forge/panels.md3"))
+		{
+			self->s.modelindex = self->s.modelindex2;
+		}
+
+		gi.linkentity (self);
+	}
+}
+
+void health_think( gentity_t *ent )
+{
+	int dif;
+
+	// He's dead, Jim. Don't give him health
+	if (ent->enemy->health<1)
+	{
+		ent->count = 0;
+		ent->e_ThinkFunc = thinkF_NULL;
+	}
+
+	// Still has power to give
+	if (ent->count > 0)
+	{
+		// For every 3 points of health, you get 1 point of armor
+		// BUT!!! after health is filled up, you get the full energy going to armor
+
+		dif = ent->enemy->client->ps.stats[STAT_MAX_HEALTH] - ent->enemy->health;
+
+		if (dif > 3 )
+		{
+			dif= 3;
+		}
+		else if (dif < 0) 
+		{
+			dif= 0;	
+		}
+
+		if (dif > ent->count)	// Can't give more than count
+		{
+			dif = ent->count;
+		}
+
+		if ((ITM_AddHealth (ent->enemy,dif)) && (dif>0))		
+		{
+			ITM_AddArmor (ent->enemy,1);	// 1 armor for every 3 health
+
+			ent->count-=dif;
+			ent->nextthink = level.time + 10;
+		}
+		else	// User has taken all health he can hold, see about giving it all to armor
+		{
+			dif = ent->enemy->client->ps.stats[STAT_MAX_HEALTH] - 
+				ent->enemy->client->ps.stats[STAT_ARMOR];
+
+			if (dif > 3)
+			{
+				dif = 3;
+			}
+			else if (dif < 0) 
+			{
+				dif= 0;	
+			}
+
+			if (ent->count < dif)	// Can't give more than count
+			{
+				dif = ent->count;
+			}
+
+			if ((!ITM_AddArmor(ent->enemy,dif)) || (dif<=0))
+			{
+				ent->e_UseFunc = useF_health_use;	
+				ent->e_ThinkFunc = thinkF_NULL;
+			}
+			else
+			{
+				ent->count-=dif;
+				ent->nextthink = level.time + 10;
+			}
+		}
+	}
+
+	if (ent->count < 1)
+	{
+		health_shutdown(ent);
+	}
+}
+
+void misc_model_useup( gentity_t *self, gentity_t *other, gentity_t *activator)
+{
+	G_ActivateBehavior(self,BSET_USE);
+
+	self->s.eFlags &= ~ EF_ANIM_ALLFAST;
+	self->s.eFlags |= EF_ANIM_ONCE;
+
+	// Switch to and animate its used up model.
+	self->s.modelindex = self->s.modelindex2;
+
+	gi.linkentity (self);
+
+	// Use target when used
+	if (self->spawnflags & 8)
+	{
+		G_UseTargets( self, activator );	
+	}
+
+	self->e_UseFunc = useF_NULL;	
+	self->e_ThinkFunc = thinkF_NULL;
+	self->nextthink = -1;
+}
+
+void health_use( gentity_t *self, gentity_t *other, gentity_t *activator)
+{//FIXME: Heal entire team?  Or only those that are undying...?
+	int dif;
+	int dif2;
+	int hold;
+
+	G_ActivateBehavior(self,BSET_USE);
+
+	if (self->e_ThinkFunc != thinkF_NULL)
+	{
+		self->e_ThinkFunc = thinkF_NULL;
+	}
+	else
+	{
+
+		if (other->client)
+		{
+			// He's dead, Jim. Don't give him health
+			if (other->client->ps.stats[STAT_HEALTH]<1)
+			{
+				dif = 1;
+				self->count = 0;
+			}
+			else 
+			{	// Health
+				dif = other->client->ps.stats[STAT_MAX_HEALTH] - other->client->ps.stats[STAT_HEALTH];
+				// Armor
+				dif2 = other->client->ps.stats[STAT_MAX_HEALTH] - other->client->ps.stats[STAT_ARMOR];
+				hold = (dif2 - dif);
+				// For every 3 points of health, you get 1 point of armor
+				// BUT!!! after health is filled up, you get the full energy going to armor
+				if (hold>0)	// Need more armor than health
+				{
+					// Calculate total amount of station energy needed.
+					
+					hold = dif / 3;	//	For every 3 points of health, you get 1 point of armor
+					dif2 -= hold;
+					dif2 += dif;	
+					
+					dif = dif2;
+				}
+			}
+		}
+		else
+		{	// Being triggered to be used up
+			dif = 1;
+			self->count = 0;
+		}
+		
+		// Does player already have full health and full armor?
+		if (dif > 0)
+		{
+//			G_Sound(self, G_SoundIndex("sound/player/suithealth.wav") );
+
+			if ((dif >= self->count) || (self->count<1)) // use it all up?
+			{
+				health_shutdown(self);
+			}
+			// Use target when used
+			if (self->spawnflags & 8)
+			{
+				G_UseTargets( self, activator );	
+			}
+
+			self->e_UseFunc = useF_NULL;	
+			self->enemy = other;
+			self->e_ThinkFunc = thinkF_health_think;
+			self->nextthink = level.time + 50;
+		}
+		else
+		{
+//			G_Sound(self, G_SoundIndex("sound/weapons/noammo.wav") );
+		}
+	}	
+}
+
+// --------------------------------------------------------------------
+//
+//   AMMO plugin functions
+//
+// --------------------------------------------------------------------
+void ammo_use( gentity_t *self, gentity_t *other, gentity_t *activator);
+int Add_Ammo2 (gentity_t *ent, int ammoType, int count);
+
+void ammo_shutdown( gentity_t *self )
+{
+	if (!(self->s.eFlags & EF_ANIM_ONCE))
+	{
+		self->s.eFlags &= ~ EF_ANIM_ALLFAST;
+		self->s.eFlags |= EF_ANIM_ONCE;
+
+		gi.linkentity (self);
+	}
+}
+void ammo_think( gentity_t *ent )
+{
+	int dif;
+
+	// Still has ammo to give
+	if (ent->count > 0 && ent->enemy )
+	{
+		dif = ammoData[AMMO_BLASTER].max  - ent->enemy->client->ps.ammo[AMMO_BLASTER];
+
+		if (dif > 2 )
+		{
+			dif= 2;
+		}
+		else if (dif < 0) 
+		{
+			dif= 0;	
+		}
+
+		if (ent->count < dif)	// Can't give more than count
+		{
+			dif = ent->count;
+		}
+
+		// Give player ammo 
+		if (Add_Ammo2(ent->enemy,AMMO_BLASTER,dif) && (dif!=0))	
+		{
+			ent->count-=dif;
+			ent->nextthink = level.time + 10;
+		}
+		else	// User has taken all ammo he can hold
+		{
+			ent->e_UseFunc = useF_ammo_use;	
+			ent->e_ThinkFunc = thinkF_NULL;
+		}
+	}
+
+	if (ent->count < 1)
+	{
+		ammo_shutdown(ent);
+	}
+}
+
+//------------------------------------------------------------
+void ammo_use( gentity_t *self, gentity_t *other, gentity_t *activator)
+{
+	int dif;
+
+	G_ActivateBehavior(self,BSET_USE);
+
+	if (self->e_ThinkFunc != thinkF_NULL)
+	{
+		if (self->e_UseFunc != useF_NULL)
+		{
+			self->e_ThinkFunc = thinkF_NULL;
+		}
+	}
+	else
+	{
+		if (other->client)
+		{
+			dif = ammoData[AMMO_BLASTER].max - other->client->ps.ammo[AMMO_BLASTER];
+		}
+		else
+		{	// Being triggered to be used up
+			dif = 1;
+			self->count = 0;
+		}
+
+		// Does player already have full ammo?
+		if (dif > 0)
+		{
+//			G_Sound(self, G_SoundIndex("sound/player/suitenergy.wav") );
+
+			if ((dif >= self->count) || (self->count<1)) // use it all up?
+			{
+				ammo_shutdown(self);
+			}
+		}	
+		else
+		{
+//			G_Sound(self, G_SoundIndex("sound/weapons/noammo.wav") );
+		}
+		// Use target when used
+		if (self->spawnflags & 8)
+		{
+			G_UseTargets( self, activator );	
+		}
+
+		self->e_UseFunc = useF_NULL;	
+		G_SetEnemy( self, other );
+		self->e_ThinkFunc = thinkF_ammo_think;
+		self->nextthink = level.time + 50;
+	}	
+}
+
+//------------------------------------------------------------
+void mega_ammo_use( gentity_t *self, gentity_t *other, gentity_t *activator )
+{
+	G_ActivateBehavior( self, BSET_USE );
+
+	// Use target when used
+	G_UseTargets( self, activator );
+
+	// first use, adjust the max ammo a person can hold for each type of ammo
+	ammoData[AMMO_BLASTER].max	= 999;
+	ammoData[AMMO_POWERCELL].max		= 999;
+
+	// Set up our count with whatever the max difference will be
+	if ( other->client->ps.ammo[AMMO_POWERCELL] > other->client->ps.ammo[AMMO_BLASTER] )
+		self->count = ammoData[AMMO_BLASTER].max - other->client->ps.ammo[AMMO_BLASTER];
+	else
+		self->count = ammoData[AMMO_POWERCELL].max - other->client->ps.ammo[AMMO_POWERCELL];
+
+//	G_Sound( self, G_SoundIndex("sound/player/superenergy.wav") );
+
+	// Clear our usefunc, then think until our ammo is full
+	self->e_UseFunc = useF_NULL;	
+	G_SetEnemy( self, other );
+	self->e_ThinkFunc = thinkF_mega_ammo_think;
+	self->nextthink = level.time + 50;
+
+	self->s.frame = 0;
+	self->s.eFlags |= EF_ANIM_ONCE;
+}
+
+//------------------------------------------------------------
+void mega_ammo_think( gentity_t *self )
+{
+	int	ammo_add = 5;
+
+	// If the middle model is done animating, and we haven't switched to the last model yet...
+	//		chuck up the last model.
+
+	if (!Q_stricmp(self->model,"models/mapobjects/forge/power_up_boss.md3"))	// Because the normal forge_ammo model can use this too
+	{
+		if ( self->s.frame > 16 && self->s.modelindex != self->s.modelindex2 )
+			self->s.modelindex = self->s.modelindex2;
+	}
+	
+	if ( self->enemy && self->count > 0 )
+	{
+		// Add an equal ammount of ammo to each type
+		self->enemy->client->ps.ammo[AMMO_BLASTER]		+= ammo_add;
+		self->enemy->client->ps.ammo[AMMO_POWERCELL]	+= ammo_add;
+
+		// Now cap to prevent overflows
+		if ( self->enemy->client->ps.ammo[AMMO_BLASTER] > ammoData[AMMO_BLASTER].max )
+			self->enemy->client->ps.ammo[AMMO_BLASTER] = ammoData[AMMO_BLASTER].max;
+
+		if ( self->enemy->client->ps.ammo[AMMO_POWERCELL] > ammoData[AMMO_POWERCELL].max )
+			self->enemy->client->ps.ammo[AMMO_POWERCELL] = ammoData[AMMO_POWERCELL].max;
+
+		// Decrement the count given counter
+		self->count -= ammo_add;
+
+		// If we've given all we should, prevent giving any more, even if they player is no longer full
+		if ( self->count <= 0 )
+		{
+			self->count = 0;
+			self->e_ThinkFunc = thinkF_NULL;
+			self->nextthink = -1;
+		}
+		else
+			self->nextthink = 20;
+	}
+}
+
+
+//------------------------------------------------------------
+void switch_models( gentity_t *self, gentity_t *other, gentity_t *activator )
+{
+	// FIXME: need a sound here!!
+	if ( self->s.modelindex2 )
+		self->s.modelindex = self->s.modelindex2;
+}
+
+//------------------------------------------------------------
+void touch_ammo_crystal_tigger( gentity_t *self, gentity_t *other, trace_t *trace )
+{
+	if ( !other->client )
+		return;
+
+	// dead people can't pick things up
+	if ( other->health < 1 )
+		return;
+
+	// Only player can pick it up
+	if ( !other->s.number == 0 )
+	{
+		return;
+	}
+
+	if ( other->client->ps.ammo[ AMMO_POWERCELL ] >= ammoData[AMMO_POWERCELL].max )
+	{
+		return;		// can't hold any more
+	}
+
+	// Add the ammo
+	other->client->ps.ammo[AMMO_POWERCELL] += self->owner->count;
+
+	if ( other->client->ps.ammo[AMMO_POWERCELL] > ammoData[AMMO_POWERCELL].max ) 
+	{
+		other->client->ps.ammo[AMMO_POWERCELL] = ammoData[AMMO_POWERCELL].max;
+	}
+
+	// Trigger once only
+	self->e_TouchFunc = touchF_NULL;
+
+	// swap the model to the version without the crystal and ditch the infostring
+	self->owner->s.modelindex = self->owner->s.modelindex2;
+
+	// play the normal pickup sound
+//	G_AddEvent( other, EV_ITEM_PICKUP, ITM_AMMO_CRYSTAL_BORG );
+
+	// fire item targets
+	G_UseTargets( self->owner, other );
+}
+
+//------------------------------------------------------------
+void spawn_ammo_crystal_trigger( gentity_t *ent )
+{
+	gentity_t	*other;
+	vec3_t		mins, maxs;
+
+	// Set the base bounds
+	VectorCopy( ent->s.origin, mins );
+	VectorCopy( ent->s.origin, maxs );
+
+	// Now add an area of influence around the thing
+	for ( int i = 0; i < 3; i++ )
+	{
+		maxs[i] += 48;
+		mins[i] -= 48;
+	}
+
+	// create a trigger with this size
+	other = G_Spawn( );
+
+	VectorCopy( mins, other->mins );
+	VectorCopy( maxs, other->maxs );
+
+	// set up the other bits that the engine needs to know
+	other->owner = ent;
+	other->contents = CONTENTS_TRIGGER;
+	other->e_TouchFunc = touchF_touch_ammo_crystal_tigger;
+
+	gi.linkentity( other );
+}
+
+void misc_replicator_item_remove ( gentity_t *self, gentity_t *other, gentity_t *activator )
+{
+	self->s.eFlags |= EF_NODRAW;
+	//self->contents = 0;
+	self->s.modelindex = 0;
+	self->e_UseFunc = useF_misc_replicator_item_spawn;
+	//FIXME: pickup sound?
+	if ( activator->client )
+	{
+		activator->health += 5;
+		if ( activator->health > activator->client->ps.stats[STAT_MAX_HEALTH] )	// Past max health
+		{
+			activator->health = activator->client->ps.stats[STAT_MAX_HEALTH];
+		}
+	}
+}
+
+void misc_replicator_item_finish_spawn( gentity_t *self )
+{
+	//self->contents = CONTENTS_ITEM;
+	//FIXME: blinks out for a couple frames when transporter effect is done?
+	self->e_UseFunc = useF_misc_replicator_item_remove;
+}
+
+void misc_replicator_item_spawn ( gentity_t *self, gentity_t *other, gentity_t *activator )
+{
+	switch ( Q_irand( 1, self->count ) )
+	{
+	case 1:
+		self->s.modelindex = self->bounceCount;
+		break;
+	case 2:
+		self->s.modelindex = self->fly_sound_debounce_time;
+		break;
+	case 3:
+		self->s.modelindex = self->painDebounceTime;
+		break;
+	case 4:
+		self->s.modelindex = self->disconnectDebounceTime;
+		break;
+	case 5:
+		self->s.modelindex = self->attackDebounceTime;
+		break;
+	case 6://max
+		self->s.modelindex = self->pushDebounceTime;
+		break;
+	}
+	self->s.eFlags &= ~EF_NODRAW;
+	self->e_ThinkFunc = thinkF_misc_replicator_item_finish_spawn;
+	self->nextthink = level.time + 4000;//shorter?
+	self->e_UseFunc = useF_NULL;
+
+	gentity_t *tent = G_TempEntity( self->currentOrigin, EV_REPLICATOR );
+	tent->owner = self;
+}
+
+/*QUAK-ED misc_replicator_item (0.2 0.8 0.2) (-4 -4 0) (4 4 8) 
+When used. this will "spawn" an entity with a random model from the ones provided below...
+
+Using it again removes the item as if it were picked up.
+
+model  - first random model key
+model2  - second random model key
+model3  - third random model key
+model4  - fourth random model key
+model5  - fifth random model key
+model6  - sixth random model key
+
+NOTE: do not skip one of these model names, start with the lowest and fill in each next highest one with a value.  A gap will cause the item to not work correctly.
+
+NOTE: if you use an invalid model, it will still try to use it and show the NULL axis model (or nothing at all)
+
+targetname - how you refer to it for using it
+*/
+void SP_misc_replicator_item ( gentity_t *self )
+{
+	if ( self->model )
+	{
+		self->bounceCount = G_ModelIndex( self->model );
+		self->count++;
+		if ( self->model2 )
+		{
+			self->fly_sound_debounce_time = G_ModelIndex( self->model2 );
+			self->count++;
+			if ( self->target )
+			{
+				self->painDebounceTime = G_ModelIndex( self->target );
+				self->count++;
+				if ( self->target2 )
+				{
+					self->disconnectDebounceTime = G_ModelIndex( self->target2 );
+					self->count++;
+					if ( self->target3 )
+					{
+						self->attackDebounceTime = G_ModelIndex( self->target3 );
+						self->count++;
+						if ( self->target4 )
+						{
+							self->pushDebounceTime = G_ModelIndex( self->target4 );
+							self->count++;
+						}
+					}
+				}
+			}
+		}
+	}
+//	G_SoundIndex( "sound/movers/switches/replicator.wav" );
+	self->e_UseFunc = useF_misc_replicator_item_spawn;
+
+	self->s.eFlags |= EF_NODRAW;
+	//self->contents = 0;
+
+	VectorSet( self->mins, -4, -4, 0 );
+	VectorSet( self->maxs, 4, 4, 8 );
+	G_SetOrigin( self, self->s.origin );
+	G_SetAngles( self, self->s.angles );
+
+	gi.linkentity( self );
+}
+
+/*QUAKED misc_trip_mine (0.2 0.8 0.2) (-4 -4 -4) (4 4 4) START_ON BROADCAST START_OFF
+Place in a map and point the angles at whatever surface you want it to attach to.
+
+START_ON - If you give it a targetname to make it toggle-able, but want it to start on, set this flag
+BROADCAST - ONLY USE THIS IF YOU HAVE TO!  causes the trip wire and loop sound to always happen, use this if the beam drops out in certain situations
+START_OFF - If you give it a targetname, it will start completely off (laser AND base unit)  until used.
+
+The trip mine will attach to that surface and fire it's beam away from the surface at an angle perpendicular to it.
+
+targetname - starts off, when used, turns on (toggles)
+
+FIXME: sometimes we want these to not be shootable... maybe just put them behind a force field?
+*/
+extern void touchLaserTrap( gentity_t *ent, gentity_t *other, trace_t *trace );
+extern void CreateLaserTrap( gentity_t *laserTrap, vec3_t start, gentity_t *owner );
+
+void misc_trip_mine_activate( gentity_t *self, gentity_t *other, gentity_t *activator )
+{
+	if ( self->e_ThinkFunc == thinkF_laserTrapThink )
+	{
+		self->s.eFlags &= ~EF_FIRING;
+		self->s.loopSound = 0;
+		self->e_ThinkFunc = thinkF_NULL;
+		self->nextthink = -1;
+	}
+	else
+	{
+		self->e_ThinkFunc = thinkF_laserTrapThink;
+		self->nextthink = level.time + FRAMETIME;
+
+		self->s.eFlags &= ~EF_NODRAW;
+		self->contents = CONTENTS_SHOTCLIP;//CAN'T USE CONTENTS_SOLID because only ARCHITECTURE is contents_solid!!!
+		self->takedamage = qtrue;
+	}
+}
+
+void SP_misc_trip_mine( gentity_t *self )
+{
+	vec3_t	forward, end;
+	trace_t	trace;
+
+	AngleVectors( self->s.angles, forward, NULL, NULL );
+	VectorMA( self->s.origin, 128, forward, end );
+
+	gi.trace( &trace, self->s.origin, vec3_origin, vec3_origin, end, self->s.number, MASK_SHOT );
+
+	if ( trace.allsolid || trace.startsolid )
+	{
+		Com_Error( ERR_DROP,"misc_trip_mine at %s in solid\n", vtos(self->s.origin) );
+		G_FreeEntity( self );
+		return;
+	}
+	if ( trace.fraction == 1.0 )
+	{
+		Com_Error( ERR_DROP,"misc_trip_mine at %s pointed at no surface\n", vtos(self->s.origin) );
+		G_FreeEntity( self );
+		return;
+	}
+
+	RegisterItem( FindItemForWeapon( WP_TRIP_MINE ));	//precache the weapon
+
+	self->count = 2/*TRIPWIRE_STYLE*/;
+
+	vectoangles( trace.plane.normal, end );
+	G_SetOrigin( self, trace.endpos );
+	G_SetAngles( self, end );
+
+	CreateLaserTrap( self, trace.endpos, self );
+	touchLaserTrap( self, self, &trace );
+	self->e_ThinkFunc = thinkF_NULL;
+	self->nextthink = -1;
+
+	if ( !self->targetname || (self->spawnflags&1) )
+	{//starts on
+		misc_trip_mine_activate( self, self, self );
+	}
+	if ( self->targetname )
+	{
+		self->e_UseFunc = useF_misc_trip_mine_activate;
+	}
+
+	if (( self->spawnflags & 2 )) // broadcast...should only be used in very rare cases.  could fix networking, perhaps, but james suggested this because it's easier
+	{
+		self->svFlags |= SVF_BROADCAST;
+	}
+
+	// Whether to start completelly off or not.
+	if  ( self->targetname && self->spawnflags & 4 )
+	{
+		self->s.eFlags = EF_NODRAW;
+		self->contents = 0;
+		self->takedamage = qfalse;
+	}
+
+	gi.linkentity( self );
+}
+
+/*QUAKED misc_maglock (0 .5 .8) (-8 -8 -8) (8 8 8) x x x x x x x x
+Place facing a door (using the angle, not a targetname) and it will lock that door.  Can only be destroyed by lightsaber and will automatically unlock the door it's attached to
+
+NOTE: place these half-way in the door to make it flush with the door's surface.
+
+"target"	thing to use when destoryed (not doors - it automatically unlocks the door it was angled at)
+"health"	default is 10
+*/
+void maglock_die( gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int mod, int dFlags, int hitLoc )
+{
+	//unlock our door if we're the last lock pointed at the door
+	if ( self->activator )
+	{
+		self->activator->lockCount--;
+		if ( !self->activator->lockCount )
+		{
+			self->activator->svFlags &= ~SVF_INACTIVE;
+		}
+	}
+	
+	//use targets
+	G_UseTargets( self, attacker );
+	//die
+	WP_Explode( self );
+}
+void SP_misc_maglock ( gentity_t *self )
+{
+	//NOTE: May have to make these only work on doors that are either untargeted 
+	//		or are targeted by a trigger, not doors fired off by scripts, counters 
+	//		or other such things?
+	self->s.modelindex = G_ModelIndex( "models/map_objects/imp_detention/door_lock.md3" );
+	self->fxID = G_EffectIndex( "maglock/explosion" );
+
+	G_SetOrigin( self, self->s.origin );
+
+	self->e_ThinkFunc = thinkF_maglock_link;
+	//FIXME: for some reason, when you re-load a level, these fail to find their doors...?  Random?  Testing an additional 200ms after the START_TIME_FIND_LINKS
+	self->nextthink = level.time + START_TIME_FIND_LINKS+200;//START_TIME_FIND_LINKS;//because we need to let the doors link up and spawn their triggers first!
+}
+void maglock_link( gentity_t *self )
+{
+	//find what we're supposed to be attached to
+	vec3_t	forward, start, end;
+	trace_t	trace;
+
+	AngleVectors( self->s.angles, forward, NULL, NULL );
+	VectorMA( self->s.origin, 128, forward, end );
+	VectorMA( self->s.origin, -4, forward, start );
+
+	gi.trace( &trace, start, vec3_origin, vec3_origin, end, self->s.number, MASK_SHOT );
+
+	if ( trace.allsolid || trace.startsolid )
+	{
+		Com_Error( ERR_DROP,"misc_maglock at %s in solid\n", vtos(self->s.origin) );
+		G_FreeEntity( self );
+		return;
+	}
+	if ( trace.fraction == 1.0 )
+	{
+		self->e_ThinkFunc = thinkF_maglock_link;
+		self->nextthink = level.time + 100;
+		/*
+		Com_Error( ERR_DROP,"misc_maglock at %s pointed at no surface\n", vtos(self->s.origin) );
+		G_FreeEntity( self );
+		*/
+		return;
+	}
+	gentity_t *traceEnt = &g_entities[trace.entityNum];
+	if ( trace.entityNum >= ENTITYNUM_WORLD || !traceEnt || Q_stricmp( "func_door", traceEnt->classname ) )
+	{
+		self->e_ThinkFunc = thinkF_maglock_link;
+		self->nextthink = level.time + 100;
+		//Com_Error( ERR_DROP,"misc_maglock at %s not pointed at a door\n", vtos(self->s.origin) );
+		//G_FreeEntity( self );
+		return;
+	}
+
+	//check the traceEnt, make sure it's a door and give it a lockCount and deactivate it
+	//find the trigger for the door
+	self->activator = G_FindDoorTrigger( traceEnt );
+	if ( !self->activator )
+	{
+		self->activator = traceEnt;
+	}
+	self->activator->lockCount++;
+	self->activator->svFlags |= SVF_INACTIVE;
+
+	//now position and orient it
+	vectoangles( trace.plane.normal, end );
+	G_SetOrigin( self, trace.endpos );
+	G_SetAngles( self, end );
+
+	//make it hittable
+	//FIXME: if rotated/inclined this bbox may be off... but okay if we're a ghoul model?
+	//self->s.modelindex = G_ModelIndex( "models/map_objects/imp_detention/door_lock.md3" );
+	VectorSet( self->mins, -8, -8, -8 );
+	VectorSet( self->maxs, 8, 8, 8 );
+	self->contents = CONTENTS_CORPSE;
+
+	//make it destroyable
+	self->flags |= FL_SHIELDED;//only damagable by lightsabers
+	self->takedamage = qtrue;
+	self->health = 10;
+	self->e_DieFunc = dieF_maglock_die;
+	//self->fxID = G_EffectIndex( "maglock/explosion" );
+
+	gi.linkentity( self );
+}
+
+/*
+================
+EnergyShieldStationSettings
+================
+*/
+void EnergyShieldStationSettings(gentity_t *ent)
+{
+	G_SpawnInt( "count", "0", &ent->count );
+
+	if (!ent->count)
+	{
+		switch (g_spskill->integer)
+		{
+		case 0:	//	EASY
+			ent->count = 100; 
+			break;
+		case 1:	//	MEDIUM
+			ent->count = 75; 
+			break;
+		default :
+		case 2:	//	HARD
+			ent->count = 50; 
+			break;
+		}
+	}
+}
+
+/*
+================
+shield_power_converter_use
+================
+*/
+void shield_power_converter_use( gentity_t *self, gentity_t *other, gentity_t *activator)
+{
+	int dif,add;
+
+	if ( !activator || activator->s.number != 0 )
+	{
+		//only the player gets to use these
+		return;
+	}
+
+	G_ActivateBehavior( self,BSET_USE );
+
+	if ( self->setTime < level.time )
+	{
+		self->setTime = level.time + 100;
+
+		dif = 100 - activator->client->ps.stats[STAT_ARMOR]; // FIXME: define for max armor?
+
+		if ( dif > 0 && self->count )	// Already at full armor?..and do I even have anything to give
+		{
+			if ( dif > MAX_AMMO_GIVE )
+			{
+				add = MAX_AMMO_GIVE;
+			}
+			else
+			{
+				add = dif;
+			}
+
+			if ( self->count < add )
+			{
+				add = self->count;
+			}
+
+			self->count -= add;
+
+			activator->client->ps.stats[STAT_ARMOR] += add;
+
+			self->s.loopSound = G_SoundIndex( "sound/interface/shieldcon_run.wav" );
+		}
+	
+		if ( self->count <= 0 )
+		{
+			// play empty sound
+			self->setTime = level.time + 1000; // extra debounce so that the sounds don't overlap too much
+			G_Sound( self, G_SoundIndex( "sound/interface/shieldcon_empty.mp3" ));
+			self->s.loopSound = 0;
+
+			if ( self->s.eFlags & EF_SHADER_ANIM )
+			{
+	 			self->s.frame = 1;
+			}
+		}
+		else if ( activator->client->ps.stats[STAT_ARMOR] >= 100 ) // FIXME: define for max
+		{
+			// play full sound
+			G_Sound( self, G_SoundIndex( "sound/interface/shieldcon_done.mp3" ));
+			self->setTime = level.time + 1000; // extra debounce so that the sounds don't overlap too much
+			self->s.loopSound = 0;
+		}
+	}
+
+	if ( self->s.loopSound )
+	{
+		// we will have to shut of the loop sound, so I guess try and do it intelligently...NOTE: this could get completely stomped every time through the loop
+		//	this is fine, since it just controls shutting off the sound when there are situations that could start the sound but not shut it off
+		self->e_ThinkFunc = thinkF_poll_converter;
+		self->nextthink = level.time + 500;
+	}
+	else
+	{
+		// sound is already off, so we don't need to "think" about it.
+		self->e_ThinkFunc = thinkF_NULL;
+		self->nextthink = 0;
+	}
+	
+	if ( activator->client->ps.stats[STAT_ARMOR] > 0 )
+	{
+		activator->client->ps.powerups[PW_BATTLESUIT] = Q3_INFINITE;
+	}
+}
+
+
+/*QUAKED misc_model_shield_power_converter (1 0 0) (-16 -16 -16) (16 16 16) x x x USETARGET
+model="models/items/psd_big.md3"
+Gives shield energy when used.
+
+USETARGET - when used it fires off target
+
+"health" - how much health the model has - default 60 (zero makes non-breakable)
+"targetname" - dies and displays damagemodel when used, if any (if not, removes itself)
+"target" - what to use when it dies
+"paintarget" - target to fire when hit (but not destroyed)
+"count" - the amount of ammo given when used (default 100)
+*/
+//------------------------------------------------------------
+void SP_misc_model_shield_power_converter( gentity_t *ent )
+{
+	SetMiscModelDefaults( ent, useF_shield_power_converter_use, "4", CONTENTS_SOLID, NULL, qfalse, NULL );
+
+	ent->takedamage = qfalse;
+
+	EnergyShieldStationSettings(ent);
+
+	G_SoundIndex("sound/interface/shieldcon_run.wav");
+	G_SoundIndex("sound/interface/shieldcon_done.mp3");
+	G_SoundIndex("sound/interface/shieldcon_empty.mp3");
+
+	ent->s.modelindex = G_ModelIndex("models/items/psd_big.md3");	// Precache model
+	ent->s.modelindex2 = G_ModelIndex("models/items/psd_big.md3");	// Precache model
+}
+
+void bomb_planted_use( gentity_t *self, gentity_t *other, gentity_t *activator)
+{
+	if ( self->count == 2 )
+	{
+		self->s.eFlags &= ~EF_NODRAW;
+		self->contents = CONTENTS_SOLID;
+		self->count = 1;
+		self->s.loopSound = self->noise_index;
+	}
+	else if ( self->count == 1 )
+	{
+		self->count = 0;
+		// play disarm sound
+		self->setTime = level.time + 1000; // extra debounce so that the sounds don't overlap too much
+		G_Sound( self, G_SoundIndex("sound/weapons/overchargeend"));
+		self->s.loopSound = 0;
+
+		// this pauses the shader on one frame (more or less)
+		self->s.eFlags |= EF_DISABLE_SHADER_ANIM;
+
+		// this starts the animation for the model
+		self->s.eFlags |= EF_ANIM_ONCE;
+		self->s.frame = 0;
+
+		//use targets
+		G_UseTargets( self, activator );
+	}
+}
+
+/*QUAKED misc_model_bomb_planted (1 0 0) (-16 -16 0) (16 16 70) x x x USETARGET
+model="models/map_objects/factory/bomb_new_deact.md3"
+Planted by evil men for evil purposes.
+
+"health" - please don't shoot the thermonuclear device
+"forcevisible" - When you turn on force sight (any level), you can see these draw through the entire level...
+*/
+//------------------------------------------------------------
+void SP_misc_model_bomb_planted( gentity_t *ent )
+{
+	VectorSet( ent->mins, -16, -16, 0 );
+	VectorSet( ent->maxs, 16, 16, 70 );
+
+	SetMiscModelDefaults( ent, useF_bomb_planted_use, "4", CONTENTS_SOLID, NULL, qfalse, NULL );
+
+	ent->takedamage = qfalse;
+
+	G_SoundIndex("sound/weapons/overchargeend");
+
+	ent->s.modelindex = G_ModelIndex("models/map_objects/factory/bomb_new_deact.md3");	// Precache model
+	ent->s.modelindex2 = G_ModelIndex("models/map_objects/factory/bomb_new_deact.md3");	// Precache model
+	ent->noise_index = G_SoundIndex("sound/interface/ammocon_run");
+	ent->s.loopSound = ent->noise_index;
+	//ent->s.eFlags |= EF_SHADER_ANIM;
+	//ent->s.frame = ent->startFrame = 0;
+	ent->count = 1;
+
+	// If we have a targetname, we're are invisible until we are spawned in by being used.
+	if ( ent->targetname )
+	{
+		ent->s.eFlags = EF_NODRAW;
+		ent->contents = 0;
+		ent->count = 2;
+		ent->s.loopSound = 0;
+	}
+
+	int forceVisible = 0;
+	G_SpawnInt( "forcevisible", "0", &forceVisible );
+	if ( forceVisible )
+	{//can see these through walls with force sight, so must be broadcast
+		//ent->svFlags |= SVF_BROADCAST;
+		ent->s.eFlags |= EF_FORCE_VISIBLE;
+	}
+}
+
+void beacon_deploy( gentity_t *ent )
+{
+	ent->e_ThinkFunc = thinkF_beacon_think;
+	ent->nextthink = level.time + FRAMETIME * 0.5f;
+
+	ent->s.frame = 0;
+	ent->startFrame = 0;
+	ent->endFrame = 30;
+	ent->loopAnim = qfalse;
+}
+
+void beacon_think( gentity_t *ent )
+{
+	ent->nextthink = level.time + FRAMETIME * 0.5f;
+
+	// Deploy animation complete? Stop thinking and just animate signal forever.
+	if ( ent->s.frame == 30 ) 
+	{
+		ent->e_ThinkFunc = thinkF_NULL;
+		ent->nextthink = -1;
+
+		ent->startFrame = 31;
+		ent->endFrame = 60;
+		ent->loopAnim = qtrue;
+
+		ent->s.loopSound = ent->noise_index;
+	}
+}
+
+void beacon_use( gentity_t *self, gentity_t *other, gentity_t *activator)
+{
+	// Every time it's used it will be toggled on or off.
+	if ( self->count == 0 )
+	{
+		self->s.eFlags &= ~EF_NODRAW;
+		self->contents = CONTENTS_SOLID;
+		self->count = 1;
+		self->svFlags = SVF_ANIMATING;
+		beacon_deploy( self );
+	}
+	else
+	{
+		self->s.eFlags = EF_NODRAW;
+		self->contents = 0; 
+		self->count = 0;
+		self->s.loopSound = 0;
+		self->svFlags = 0;
+	}
+}
+
+/*QUAKED misc_model_beacon (1 0 0) (-16 -16 0) (16 16 24) x x x
+model="models/map_objects/wedge/beacon.md3"
+An animating beacon model.
+
+"forcevisible" - When you turn on force sight (any level), you can see these draw through the entire level...
+*/
+//------------------------------------------------------------
+void SP_misc_model_beacon( gentity_t *ent )
+{
+	VectorSet( ent->mins, -16, -16, 0 );
+	VectorSet( ent->maxs, 16, 16, 24 );
+
+	SetMiscModelDefaults( ent, useF_beacon_use, "4", CONTENTS_SOLID, NULL, qfalse, NULL );
+
+	ent->takedamage = qfalse;
+
+	//G_SoundIndex("sound/weapons/overchargeend");
+
+	ent->s.modelindex = G_ModelIndex("models/map_objects/wedge/beacon.md3");	// Precache model
+	ent->s.modelindex2 = G_ModelIndex("models/map_objects/wedge/beacon.md3");	// Precache model
+	ent->noise_index = G_SoundIndex("sound/interface/ammocon_run");
+
+	// If we have a targetname, we're are invisible until we are spawned in by being used.
+	if ( ent->targetname )
+	{
+		ent->s.eFlags = EF_NODRAW;
+		ent->contents = 0;
+		ent->s.loopSound = 0;
+		ent->count = 0;
+	}
+	else
+	{
+		ent->count = 1;
+		beacon_deploy( ent );
+	}
+
+	int forceVisible = 0;
+	G_SpawnInt( "forcevisible", "0", &forceVisible );
+	if ( forceVisible )
+	{//can see these through walls with force sight, so must be broadcast
+		//ent->svFlags |= SVF_BROADCAST;
+		ent->s.eFlags |= EF_FORCE_VISIBLE;
+	}
+}
+
+/*QUAKED misc_shield_floor_unit (1 0 0) (-16 -16 0) (16 16 32) x x x USETARGET
+model="models/items/a_shield_converter.md3"
+Gives shield energy when used.
+
+USETARGET - when used it fires off target
+
+"health" - how much health the model has - default 60 (zero makes non-breakable)
+"targetname" - dies and displays damagemodel when used, if any (if not, removes itself)
+"target" - what to use when it dies
+"paintarget" - target to fire when hit (but not destroyed)
+"count" - the amount of ammo given when used (default 100)
+*/
+//------------------------------------------------------------
+void SP_misc_shield_floor_unit( gentity_t *ent )
+{
+	VectorSet( ent->mins, -16, -16, 0 );
+	VectorSet( ent->maxs, 16, 16, 32 );
+
+	SetMiscModelDefaults( ent, useF_shield_power_converter_use, "4", CONTENTS_SOLID, NULL, qfalse, NULL );
+
+	ent->takedamage = qfalse;
+
+	EnergyShieldStationSettings(ent);
+
+	G_SoundIndex("sound/interface/shieldcon_run.wav");
+	G_SoundIndex("sound/interface/shieldcon_done.mp3");
+	G_SoundIndex("sound/interface/shieldcon_empty.mp3");
+
+	ent->s.modelindex = G_ModelIndex( "models/items/a_shield_converter.md3" );	// Precache model
+	ent->s.eFlags |= EF_SHADER_ANIM;
+}
+
+
+/*
+================
+EnergyAmmoShieldStationSettings
+================
+*/
+void EnergyAmmoStationSettings(gentity_t *ent)
+{
+	G_SpawnInt( "count", "0", &ent->count );
+
+	if (!ent->count)
+	{
+		switch (g_spskill->integer)
+		{
+		case 0:	//	EASY
+			ent->count = 100; 
+			break;
+		case 1:	//	MEDIUM
+			ent->count = 75; 
+			break;
+		default :
+		case 2:	//	HARD
+			ent->count = 50; 
+			break;
+		}
+	}
+}
+
+// There has to be an easier way to turn off the looping sound...but
+//	it's the night before beta and my brain is fried
+//------------------------------------------------------------------
+void poll_converter( gentity_t *self )
+{
+	self->s.loopSound = 0;
+	self->nextthink = 0;
+	self->e_ThinkFunc = thinkF_NULL;
+}
+
+/*
+================
+ammo_power_converter_use
+================
+*/
+void ammo_power_converter_use( gentity_t *self, gentity_t *other, gentity_t *activator)
+{
+	int			add;
+	int			difBlaster,difPowerCell,difMetalBolts;
+	playerState_t *ps;
+
+	if ( !activator || activator->s.number != 0 )
+	{//only the player gets to use these
+		return;
+	}
+
+	G_ActivateBehavior( self, BSET_USE );
+
+	ps = &activator->client->ps;
+
+	if ( self->setTime < level.time )
+	{
+		difBlaster		= ammoData[AMMO_BLASTER].max - ps->ammo[AMMO_BLASTER];
+		difPowerCell	= ammoData[AMMO_POWERCELL].max - ps->ammo[AMMO_POWERCELL];
+		difMetalBolts	= ammoData[AMMO_METAL_BOLTS].max - ps->ammo[AMMO_METAL_BOLTS];
+
+		// Has it got any power left...and can we even use any of it?
+		if ( self->count && ( difBlaster > 0 || difPowerCell > 0 || difMetalBolts > 0 ))	
+		{
+			// at least one of the ammo types could stand to take on a bit more ammo
+			self->setTime = level.time + 100;
+			self->s.loopSound = G_SoundIndex( "sound/interface/ammocon_run.wav" );
+
+			// dole out ammo in little packets
+			if ( self->count > MAX_AMMO_GIVE )
+			{
+				add = MAX_AMMO_GIVE;
+			}
+			else if ( self->count < 0 )
+			{
+				add = 0;
+			}
+			else
+			{
+				add = self->count;
+			}
+
+			// all weapons fill at same rate...
+			ps->ammo[AMMO_BLASTER]		+= add;
+			ps->ammo[AMMO_POWERCELL]	+= add;
+			ps->ammo[AMMO_METAL_BOLTS]	+= add;
+
+			// ...then get clamped to max
+			if ( ps->ammo[AMMO_BLASTER] > ammoData[AMMO_BLASTER].max )
+			{
+				ps->ammo[AMMO_BLASTER] = ammoData[AMMO_BLASTER].max;
+			}
+
+			if ( ps->ammo[AMMO_POWERCELL] > ammoData[AMMO_POWERCELL].max )
+			{
+				ps->ammo[AMMO_POWERCELL] = ammoData[AMMO_POWERCELL].max;
+			}
+
+			if ( ps->ammo[AMMO_METAL_BOLTS] > ammoData[AMMO_METAL_BOLTS].max )
+			{
+				ps->ammo[AMMO_METAL_BOLTS] = ammoData[AMMO_METAL_BOLTS].max;
+			}
+
+			self->count -= add;
+		}
+
+		if ( self->count <= 0 )
+		{
+			// play empty sound
+			self->setTime = level.time + 1000; // extra debounce so that the sounds don't overlap too much
+			G_Sound( self, G_SoundIndex( "sound/interface/ammocon_empty.mp3" ));
+			self->s.loopSound = 0;
+
+			if ( self->s.eFlags & EF_SHADER_ANIM )
+			{
+				self->s.frame = 1;
+			}
+		}
+		else if  ( ps->ammo[AMMO_BLASTER] >= ammoData[AMMO_BLASTER].max 
+						&& ps->ammo[AMMO_POWERCELL] >= ammoData[AMMO_POWERCELL].max 
+						&& ps->ammo[AMMO_METAL_BOLTS] >= ammoData[AMMO_METAL_BOLTS].max )
+		{
+			// play full sound
+			G_Sound( self, G_SoundIndex( "sound/interface/ammocon_done.wav" ));
+			self->setTime = level.time + 1000; // extra debounce so that the sounds don't overlap too much
+			self->s.loopSound = 0;
+		}
+	}
+
+	
+	if ( self->s.loopSound )
+	{
+		// we will have to shut of the loop sound, so I guess try and do it intelligently...NOTE: this could get completely stomped every time through the loop
+		//	this is fine, since it just controls shutting off the sound when there are situations that could start the sound but not shut it off
+		self->e_ThinkFunc = thinkF_poll_converter;
+		self->nextthink = level.time + 500;
+	}
+	else
+	{
+		// sound is already off, so we don't need to "think" about it.
+		self->e_ThinkFunc = thinkF_NULL;
+		self->nextthink = 0;
+	}
+}
+
+/*QUAKED misc_model_ammo_power_converter (1 0 0) (-16 -16 -16) (16 16 16) x x x USETARGET
+model="models/items/power_converter.md3"
+Gives ammo energy when used.
+
+USETARGET - when used it fires off target
+
+"health" - how much health the model has - default 60 (zero makes non-breakable)
+"targetname" - dies and displays damagemodel when used, if any (if not, removes itself)
+"target" - what to use when it dies
+"paintarget" - target to fire when hit (but not destroyed)
+"count" - the amount of ammo given when used (default 100)
+*/
+//------------------------------------------------------------
+void SP_misc_model_ammo_power_converter( gentity_t *ent )
+{
+	SetMiscModelDefaults( ent, useF_ammo_power_converter_use, "4", CONTENTS_SOLID, NULL, qfalse, NULL );
+
+	ent->takedamage = qfalse;
+
+	EnergyAmmoStationSettings(ent);
+
+	G_SoundIndex("sound/interface/ammocon_run.wav");
+	G_SoundIndex("sound/interface/ammocon_done.mp3");
+	G_SoundIndex("sound/interface/ammocon_empty.mp3");
+
+	ent->s.modelindex = G_ModelIndex("models/items/power_converter.md3");	// Precache model
+	ent->s.modelindex2 = G_ModelIndex("models/items/power_converter.md3");	// Precache model
+}
+
+/*QUAKED misc_ammo_floor_unit (1 0 0) (-16 -16 0) (16 16 32) x x x USETARGET
+model="models/items/a_pwr_converter.md3"
+Gives ammo energy when used.
+
+USETARGET - when used it fires off target
+
+"health" - how much health the model has - default 60 (zero makes non-breakable)
+"targetname" - dies and displays damagemodel when used, if any (if not, removes itself)
+"target" - what to use when it dies
+"paintarget" - target to fire when hit (but not destroyed)
+"count" - the amount of ammo given when used (default 100)
+*/
+//------------------------------------------------------------
+void SP_misc_ammo_floor_unit( gentity_t *ent )
+{
+	VectorSet( ent->mins, -16, -16, 0 );
+	VectorSet( ent->maxs, 16, 16, 32 );
+
+	SetMiscModelDefaults( ent, useF_ammo_power_converter_use, "4", CONTENTS_SOLID, NULL, qfalse, NULL );
+
+	ent->takedamage = qfalse;
+
+	EnergyAmmoStationSettings(ent);
+
+	G_SoundIndex("sound/interface/ammocon_run.wav");
+	G_SoundIndex("sound/interface/ammocon_done.mp3");
+	G_SoundIndex("sound/interface/ammocon_empty.mp3");
+
+	ent->s.modelindex = G_ModelIndex("models/items/a_pwr_converter.md3");	// Precache model
+	ent->s.eFlags |= EF_SHADER_ANIM;
+}
+
+
+/*
+================
+welder_think
+================
+*/
+void welder_think( gentity_t *self )
+{
+	self->nextthink = level.time + 200;
+	vec3_t		org,
+				dir;
+	mdxaBone_t	boltMatrix;
+
+	if( self->svFlags & SVF_INACTIVE )
+	{	
+		return;
+	}
+
+	int newBolt;
+	
+	// could alternate between the two... or make it random... ?
+	newBolt = gi.G2API_AddBolt( &self->ghoul2[self->playerModel], "*flash" );
+//	newBolt = gi.G2API_AddBolt( &self->ghoul2[self->playerModel], "*flash01" );
+
+	if ( newBolt != -1 )
+	{
+		G_Sound( self, self->noise_index );
+	//	G_PlayEffect( "blueWeldSparks", self->playerModel, newBolt, self->s.number);
+		// The welder gets rotated around a lot, and since the origin is offset by 352 I have to make this super expensive call to position the hurt...
+		gi.G2API_GetBoltMatrix( self->ghoul2, self->playerModel, newBolt,
+					&boltMatrix, self->currentAngles, self->currentOrigin, (cg.time?cg.time:level.time),
+					NULL, self->s.modelScale );
+
+		gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, org );
+		VectorSubtract( self->currentOrigin, org, dir );
+		VectorNormalize( dir );
+		// we want the  welder effect to face inwards....
+		G_PlayEffect( "sparks/blueWeldSparks", org, dir );
+		G_RadiusDamage( org, self, 10, 45, self, MOD_UNKNOWN );
+	}
+
+} 
+
+/*
+================
+welder_use
+================
+*/
+void welder_use( gentity_t *self, gentity_t *other, gentity_t *activator )
+{
+	// Toggle on and off
+	if( self->spawnflags & 1 )
+	{
+		self->nextthink = level.time + FRAMETIME;		
+	}
+	else
+	{
+		self->nextthink = -1;	
+	}
+	self->spawnflags = (self->spawnflags ^ 1);
+	
+}
+
+/*QUAKED misc_model_welder (1 0 0) (-16 -16 -16) (16 16 16) START_OFF 
+model="models/map_objects/cairn/welder.md3"
+When 'on' emits sparks from it's welding points
+
+START_OFF  - welder starts off, using it toggles it on/off
+
+*/
+//------------------------------------------------------------
+void SP_misc_model_welder( gentity_t *ent )
+{
+	VectorSet( ent->mins, 336, -16, 0 );
+	VectorSet( ent->maxs, 368, 16, 32 );
+
+	SetMiscModelDefaults( ent, useF_welder_use, "4", CONTENTS_SOLID, NULL, qfalse, NULL );
+
+	ent->takedamage = qfalse;
+	ent->contents = 0;
+	G_EffectIndex( "sparks/blueWeldSparks" );
+	ent->noise_index = G_SoundIndex( "sound/movers/objects/welding.wav" );
+
+	ent->s.modelindex = G_ModelIndex( "models/map_objects/cairn/welder.glm" );
+//	ent->s.modelindex2 = G_ModelIndex( "models/map_objects/cairn/welder.md3" );
+	ent->playerModel = gi.G2API_InitGhoul2Model( ent->ghoul2, "models/map_objects/cairn/welder.glm", ent->s.modelindex );
+	ent->s.radius = 400.0f;// the origin of the welder is offset by approximately 352, so we need the big radius
+
+	ent->e_ThinkFunc = thinkF_welder_think;
+
+	ent->nextthink = level.time + 1000;
+	if( ent->spawnflags & 1 )
+	{
+		ent->nextthink = -1;
+	}
+}
+
+
+/*
+================
+jabba_cam_use
+================
+*/
+void jabba_cam_use( gentity_t *self, gentity_t *other, gentity_t *activator )
+{
+	if( self->spawnflags & 1 )
+	{
+		self->spawnflags &= ~1;
+		gi.G2API_SetBoneAnimIndex( &self->ghoul2[self->playerModel], self->rootBone, 15, 0, BONE_ANIM_OVERRIDE_FREEZE, -1.5f, (cg.time?cg.time:level.time), -1, 0 );
+
+	}
+	else
+	{
+		self->spawnflags |= 1;
+		gi.G2API_SetBoneAnimIndex( &self->ghoul2[self->playerModel], self->rootBone, 0, 15, BONE_ANIM_OVERRIDE_FREEZE, 1.5f, (cg.time?cg.time:level.time), -1, 0 );
+	}
+}
+
+/*QUAKED misc_model_jabba_cam (1 0 0) ( 0 -8 0) (60 8 16) EXTENDED
+model="models/map_objects/nar_shaddar/jabacam.md3"
+
+The eye camera that popped out of Jabba's front door
+
+  EXTENDED - Starts in the extended position
+
+  targetname - Toggles it on/off
+  
+*/
+//-----------------------------------------------------
+void SP_misc_model_jabba_cam( gentity_t *ent )
+//-----------------------------------------------------
+{
+
+	VectorSet( ent->mins, -60.0f, -8.0f, 0.0f );
+	VectorSet( ent->maxs, 60.0f, 8.0f, 16.0f );
+		
+	SetMiscModelDefaults( ent, useF_jabba_cam_use, "4", 0, NULL, qfalse, NULL );
+	G_SetAngles( ent, ent->s.angles );
+
+	ent->s.modelindex = G_ModelIndex( "models/map_objects/nar_shaddar/jabacam/jabacam.glm" );
+	ent->playerModel = gi.G2API_InitGhoul2Model( ent->ghoul2, "models/map_objects/nar_shaddar/jabacam/jabacam.glm", ent->s.modelindex );
+	ent->s.radius = 150.0f;  //......
+	VectorSet( ent->s.modelScale, 1.0f, 1.0f, 1.0f );
+
+	ent->rootBone = gi.G2API_GetBoneIndex( &ent->ghoul2[ent->playerModel], "model_root", qtrue );
+	
+	ent->e_UseFunc = useF_jabba_cam_use;
+
+	ent->takedamage = qfalse;
+
+	// start extended..
+	if ( ent->spawnflags & 1 )
+	{
+		gi.G2API_SetBoneAnimIndex( &ent->ghoul2[ent->playerModel], ent->rootBone, 0, 15, BONE_ANIM_OVERRIDE_FREEZE, 0.6f, cg.time );
+	}
+
+	gi.linkentity( ent );
+}
+
+//------------------------------------------------------------------------
+void misc_use( gentity_t *self, gentity_t *other, gentity_t *activator )
+{
+	misc_model_breakable_die( self, other, activator, 100, MOD_UNKNOWN );
+}
+
+/*QUAKED misc_exploding_crate (1 0 0.25) (-24 -24 0) (24 24 64)
+model="models/map_objects/nar_shaddar/crate_xplode.md3"
+Basic exploding crate
+
+"health" - how much health the model has - default 40 (zero makes non-breakable)
+
+"splashRadius" - radius to do damage in - default 128
+"splashDamage" - amount of damage to do when it explodes - default 50
+
+"targetname" - auto-explodes
+"target" - what to use when it dies
+
+*/
+//------------------------------------------------------------
+void SP_misc_exploding_crate( gentity_t *ent )
+{
+	G_SpawnInt( "health", "40", &ent->health );
+	G_SpawnInt( "splashRadius", "128", &ent->splashRadius );
+	G_SpawnInt( "splashDamage", "50", &ent->splashDamage );
+
+	ent->s.modelindex = G_ModelIndex( "models/map_objects/nar_shaddar/crate_xplode.md3" );
+	G_SoundIndex("sound/weapons/explosions/cargoexplode.wav");
+	G_EffectIndex( "chunks/metalexplode" );
+	
+	VectorSet( ent->mins, -24, -24, 0 );
+	VectorSet( ent->maxs, 24, 24, 64 );
+
+	ent->contents = CONTENTS_SOLID|CONTENTS_OPAQUE|CONTENTS_BODY|CONTENTS_MONSTERCLIP|CONTENTS_BOTCLIP;//CONTENTS_SOLID;
+	ent->takedamage = qtrue;
+
+	G_SetOrigin( ent, ent->s.origin );
+	VectorCopy( ent->s.angles, ent->s.apos.trBase );
+	gi.linkentity (ent);
+
+	if ( ent->targetname )
+	{
+		ent->e_UseFunc = useF_misc_use;
+	}
+
+	ent->material = MAT_CRATE1;
+	ent->e_DieFunc = dieF_misc_model_breakable_die;//ExplodeDeath;
+}
+
+/*QUAKED misc_gas_tank (1 0 0.25) (-4 -4 0) (4 4 40)
+model="models/map_objects/imp_mine/tank.md3"
+Basic exploding oxygen tank
+
+"health" - how much health the model has - default 20 (zero makes non-breakable)
+
+"splashRadius" - radius to do damage in - default 48
+"splashDamage" - amount of damage to do when it explodes - default 32
+
+"targetname" - auto-explodes
+"target" - what to use when it dies
+
+*/
+
+void gas_random_jet( gentity_t *self )
+{
+	vec3_t pt;
+
+	VectorCopy( self->currentOrigin, pt );
+	pt[2] += 50;
+
+	G_PlayEffect( "env/mini_gasjet", pt );
+
+	self->nextthink = level.time + random() * 16000 + 12000; // do this rarely
+}
+
+//------------------------------------------------------------
+void GasBurst( gentity_t *self, gentity_t *inflictor, gentity_t *attacker, const vec3_t point, int damage, int mod, int hitLoc )
+{
+	vec3_t pt;
+
+	VectorCopy( self->currentOrigin, pt );
+	pt[2] += 46;
+
+	G_PlayEffect( "env/mini_flamejet", pt );
+
+	// do some damage to anything that may be standing on top of it when it bursts into flame
+	pt[2] += 32;
+	G_RadiusDamage( pt, self, 32, 32, self, MOD_UNKNOWN );
+
+	//  only get one burst
+	self->e_PainFunc = painF_NULL;
+}
+
+//------------------------------------------------------------
+void SP_misc_gas_tank( gentity_t *ent )
+{
+	G_SpawnInt( "health", "20", &ent->health );
+	G_SpawnInt( "splashRadius", "48", &ent->splashRadius );
+	G_SpawnInt( "splashDamage", "32", &ent->splashDamage );
+
+	ent->s.modelindex = G_ModelIndex( "models/map_objects/imp_mine/tank.md3" );
+	G_SoundIndex("sound/weapons/explosions/cargoexplode.wav");
+	G_EffectIndex( "chunks/metalexplode" );
+	G_EffectIndex( "env/mini_flamejet" );
+	G_EffectIndex( "env/mini_gasjet" );
+
+	VectorSet( ent->mins, -4, -4, 0 );
+	VectorSet( ent->maxs, 4, 4, 40 );
+
+	ent->contents = CONTENTS_SOLID;
+	ent->takedamage = qtrue;
+
+	G_SetOrigin( ent, ent->s.origin );
+	VectorCopy( ent->s.angles, ent->s.apos.trBase );
+	gi.linkentity (ent);
+
+	ent->e_PainFunc = painF_GasBurst;
+
+	if ( ent->targetname )
+	{
+		ent->e_UseFunc = useF_misc_use;
+	}
+
+	ent->material = MAT_METAL3;
+
+	ent->e_DieFunc = dieF_misc_model_breakable_die;
+
+	ent->e_ThinkFunc = thinkF_gas_random_jet;
+	ent->nextthink = level.time + random() * 12000 + 6000; // do this rarely
+}
+
+/*QUAKED misc_crystal_crate (1 0 0.25) (-34 -34 0) (34 34 44) NON_SOLID
+model="models/map_objects/imp_mine/crate_open.md3"
+Open crate of crystals that explode when shot
+
+NON_SOLID - can only be shot 
+
+"health" - how much health the crate has, default 80 
+
+"splashRadius" - radius to do damage in, default 80
+"splashDamage" - amount of damage to do when it explodes, default 40
+
+"targetname" - auto-explodes
+"target" - what to use when it dies
+
+*/
+
+//------------------------------------------------------------
+void CrystalCratePain( gentity_t *self, gentity_t *inflictor, gentity_t *attacker, const vec3_t point, int damage, int mod, int hitLoc )
+{
+	vec3_t pt;
+
+	VectorCopy( self->currentOrigin, pt );
+	pt[2] += 36;
+
+	G_PlayEffect( "env/crystal_crate", pt );
+
+	// do some damage, heh
+	pt[2] += 32;
+	G_RadiusDamage( pt, self, 16, 32, self, MOD_UNKNOWN );
+
+}
+
+//------------------------------------------------------------
+void SP_misc_crystal_crate( gentity_t *ent )
+{
+	G_SpawnInt( "health", "80", &ent->health );
+	G_SpawnInt( "splashRadius", "80", &ent->splashRadius );
+	G_SpawnInt( "splashDamage", "40", &ent->splashDamage );
+
+	ent->s.modelindex = G_ModelIndex( "models/map_objects/imp_mine/crate_open.md3" );
+	ent->fxID = G_EffectIndex( "thermal/explosion" ); // FIXME: temp
+	G_EffectIndex( "env/crystal_crate" );
+	G_SoundIndex("sound/weapons/explosions/cargoexplode.wav");
+
+	VectorSet( ent->mins, -34, -34, 0 );
+	VectorSet( ent->maxs, 34, 34, 44 );
+	
+	//Blocks movement
+	ent->contents = CONTENTS_SOLID|CONTENTS_OPAQUE|CONTENTS_BODY|CONTENTS_MONSTERCLIP|CONTENTS_BOTCLIP;//Was CONTENTS_SOLID, but only architecture should be this
+
+	if ( ent->spawnflags & 1 )  // non-solid
+	{	// Override earlier contents flag...
+		//Can only be shot
+		ent->contents = CONTENTS_SHOTCLIP;
+	}
+	
+
+	ent->takedamage = qtrue;
+
+	G_SetOrigin( ent, ent->s.origin );
+	VectorCopy( ent->s.angles, ent->s.apos.trBase );
+	gi.linkentity (ent);
+
+	ent->e_PainFunc = painF_CrystalCratePain;
+
+	if ( ent->targetname )
+	{
+		ent->e_UseFunc = useF_misc_use;
+	}
+
+	ent->material = MAT_CRATE2;
+
+	ent->e_DieFunc = dieF_misc_model_breakable_die;
+}
+
+/*QUAKED misc_atst_drivable (1 0 0.25) (-40 -40 -24) (40 40 248)
+model="models/players/atst/model.glm"
+
+Drivable ATST, when used by player, they become the ATST.  When the player hits use again, they get out.
+
+"health" - how much health the atst has - default 800
+
+"target" - what to use when it dies
+*/
+void misc_atst_setanim( gentity_t *self, int bone, int anim )
+{
+	if ( bone < 0 || anim < 0 )
+	{
+		return;
+	}
+	int	firstFrame = -1;
+	int	lastFrame = -1;
+	float animSpeed = 0;
+	//try to get anim ranges from the animation.cfg for an AT-ST
+	for ( int i = 0; i < level.numKnownAnimFileSets; i++ )
+	{
+		if ( !Q_stricmp( "atst", level.knownAnimFileSets[i].filename ) )
+		{ 
+			firstFrame = level.knownAnimFileSets[i].animations[anim].firstFrame;
+			lastFrame = firstFrame+level.knownAnimFileSets[i].animations[anim].numFrames;
+			animSpeed = 50.0f / level.knownAnimFileSets[i].animations[anim].frameLerp;
+			break;
+		}
+	}
+	if ( firstFrame != -1 && lastFrame != -1 && animSpeed != 0 )
+	{
+		if (!gi.G2API_SetBoneAnimIndex( &self->ghoul2[self->playerModel], bone, firstFrame,
+								lastFrame, BONE_ANIM_OVERRIDE_FREEZE|BONE_ANIM_BLEND, animSpeed, 
+								(cg.time?cg.time:level.time), -1, 150 ))
+		{
+			gi.G2API_SetBoneAnimIndex( &self->ghoul2[self->playerModel], bone, firstFrame,
+								lastFrame, BONE_ANIM_OVERRIDE_FREEZE, animSpeed, 
+								(cg.time?cg.time:level.time), -1, 150 );
+		}
+	}
+}
+void misc_atst_die( gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int mod,int dFlags,int hitLoc )
+{//ATST was destroyed while you weren't in it
+	//can't be used anymore
+	self->e_UseFunc = useF_NULL;
+	//sigh... remove contents so we don't block the player's path...
+	self->contents = CONTENTS_CORPSE;
+	self->takedamage = qfalse;
+	self->maxs[2] = 48;
+
+	//FIXME: match to slope
+	vec3_t effectPos;
+	VectorCopy( self->currentOrigin, effectPos );
+	effectPos[2] -= 15;
+	G_PlayEffect( "explosions/droidexplosion1", effectPos );
+//	G_PlayEffect( "small_chunks", effectPos );
+	//set these to defaults that work in a worst-case scenario (according to current animation.cfg)
+	gi.G2API_StopBoneAnimIndex( &self->ghoul2[self->playerModel], self->craniumBone );
+	misc_atst_setanim( self, self->rootBone, BOTH_DEATH1 );
+}
+
+extern void G_DriveATST( gentity_t *ent, gentity_t *atst );
+extern void SetClientViewAngle( gentity_t *ent, vec3_t angle );
+extern qboolean PM_InSlopeAnim( int anim );
+void misc_atst_use( gentity_t *self, gentity_t *other, gentity_t *activator )
+{
+	if ( !activator || activator->s.number )
+	{//only player can do this
+		return;
+	}
+
+	int	tempLocDmg[HL_MAX];
+	int	hl, tempHealth;
+
+	if ( activator->client->NPC_class != CLASS_ATST )
+	{//get in the ATST
+		if ( activator->client->ps.groundEntityNum != self->s.number )
+		{//can only get in if on top of me...
+			//we *could* even check for the hatch surf...?
+			return;
+		}
+		//copy origin
+		G_SetOrigin( activator, self->currentOrigin );
+
+		//copy angles
+		VectorCopy( self->s.angles2, self->currentAngles );
+		G_SetAngles( activator, self->currentAngles );
+		SetClientViewAngle( activator, self->currentAngles );
+
+		//set player to my g2 instance
+		gi.G2API_StopBoneAnimIndex( &self->ghoul2[self->playerModel], self->craniumBone );
+		G_DriveATST( activator, self );
+		activator->activator = self;
+		self->s.eFlags |= EF_NODRAW;
+		self->svFlags |= SVF_NOCLIENT;
+		self->contents = 0;
+		self->takedamage = qfalse;
+		//transfer armor
+		tempHealth = self->health;
+		self->health = activator->client->ps.stats[STAT_ARMOR];
+		activator->client->ps.stats[STAT_ARMOR] = tempHealth;
+		//transfer locationDamage
+		for ( hl = HL_NONE; hl < HL_MAX; hl++ )
+		{
+			tempLocDmg[hl] = activator->locationDamage[hl];
+			activator->locationDamage[hl] = self->locationDamage[hl];
+			self->locationDamage[hl] = tempLocDmg[hl];
+		}
+		if ( !self->s.number )
+		{
+			CG_CenterPrint( "@SP_INGAME_EXIT_VIEW", SCREEN_HEIGHT * 0.95 );
+		}
+	}
+	else
+	{//get out of ATST
+		int legsAnim = activator->client->ps.legsAnim;
+		if ( legsAnim != BOTH_STAND1 
+			&& !PM_InSlopeAnim( legsAnim ) 
+			&& legsAnim != BOTH_TURN_RIGHT1 && legsAnim != BOTH_TURN_LEFT1 )
+		{//can't get out of it while it's still moving
+			return;
+		}
+		//FIXME: after a load/save, this crashes, BAD... somewhere in G2
+		G_SetOrigin( self, activator->currentOrigin );
+		VectorSet( self->currentAngles, 0, activator->client->ps.legsYaw, 0 );
+		//self->currentAngles[PITCH] = activator->currentAngles[ROLL] = 0;
+		G_SetAngles( self, self->currentAngles );
+		VectorCopy( activator->currentAngles, self->s.angles2 );
+		//remove my G2
+		if ( self->playerModel >= 0 )
+		{
+			gi.G2API_RemoveGhoul2Model( self->ghoul2, self->playerModel );
+			self->playerModel = -1;
+		}
+		//copy player's
+		gi.G2API_CopyGhoul2Instance( activator->ghoul2, self->ghoul2 );
+		self->playerModel = 0;//assumption
+		//reset player to kyle
+		G_DriveATST( activator, NULL );
+		activator->activator = NULL;
+		self->s.eFlags &= ~EF_NODRAW;
+		self->svFlags &= ~SVF_NOCLIENT;
+		self->contents = CONTENTS_SOLID|CONTENTS_BODY|CONTENTS_MONSTERCLIP|CONTENTS_BOTCLIP;
+		self->takedamage = qtrue;
+		//transfer armor
+		tempHealth = self->health;
+		self->health = activator->client->ps.stats[STAT_ARMOR];
+		activator->client->ps.stats[STAT_ARMOR] = tempHealth;
+		//transfer locationDamage
+		for ( hl = HL_NONE; hl < HL_MAX; hl++ )
+		{
+			tempLocDmg[hl] = self->locationDamage[hl];
+			self->locationDamage[hl] = activator->locationDamage[hl];
+			activator->locationDamage[hl] = tempLocDmg[hl];
+		}
+		//link me back in
+		gi.linkentity ( self );
+		//put activator on top of me?
+		vec3_t	newOrg = {activator->currentOrigin[0], activator->currentOrigin[1], activator->currentOrigin[2] + (self->maxs[2]-self->mins[2]) + 1 };
+		G_SetOrigin( activator, newOrg );
+		//open the hatch
+		misc_atst_setanim( self, self->craniumBone, BOTH_STAND2 );
+		gi.G2API_SetSurfaceOnOff( &self->ghoul2[self->playerModel], "head_hatchcover", 0 );
+		G_Sound( self, G_SoundIndex( "sound/chars/atst/atst_hatch_open" ));
+	}
+}
+
+void SP_misc_atst_drivable( gentity_t *ent )
+{
+	extern void NPC_ATST_Precache(void);
+	extern void NPC_PrecacheAnimationCFG( const char *NPC_type );
+
+	ent->s.modelindex = G_ModelIndex( "models/players/atst/model.glm" );
+	ent->playerModel = gi.G2API_InitGhoul2Model( ent->ghoul2, "models/players/atst/model.glm", ent->s.modelindex );
+	ent->rootBone = gi.G2API_GetBoneIndex( &ent->ghoul2[ent->playerModel], "model_root", qtrue );
+	ent->craniumBone = gi.G2API_GetBoneIndex( &ent->ghoul2[ent->playerModel], "cranium", qtrue );	//FIXME: need to somehow set the anim/frame to the equivalent of BOTH_STAND1...  use to be that BOTH_STAND1 was the first frame of the glm, but not anymore
+	ent->s.radius = 320;
+	VectorSet( ent->s.modelScale, 1.0f, 1.0f, 1.0f );
+
+	//register my weapons, sounds and model
+	RegisterItem( FindItemForWeapon( WP_ATST_MAIN ));	//precache the weapon
+	RegisterItem( FindItemForWeapon( WP_ATST_SIDE ));	//precache the weapon
+	//HACKHACKHACKTEMP - until ATST gets real weapons of it's own?
+	RegisterItem( FindItemForWeapon( WP_EMPLACED_GUN ));	//precache the weapon
+//	RegisterItem( FindItemForWeapon( WP_ROCKET_LAUNCHER ));	//precache the weapon
+//	RegisterItem( FindItemForWeapon( WP_BOWCASTER ));	//precache the weapon
+	//HACKHACKHACKTEMP - until ATST gets real weapons of it's own?
+
+	G_SoundIndex( "sound/chars/atst/atst_hatch_open" );
+	G_SoundIndex( "sound/chars/atst/atst_hatch_close" );
+
+	NPC_ATST_Precache();
+	ent->NPC_type = "atst";
+	NPC_PrecacheAnimationCFG( ent->NPC_type );
+	//open the hatch
+	misc_atst_setanim( ent, ent->rootBone, BOTH_STAND2 );
+	gi.G2API_SetSurfaceOnOff( &ent->ghoul2[ent->playerModel], "head_hatchcover", 0 );
+
+	VectorSet( ent->mins, ATST_MINS0, ATST_MINS1, ATST_MINS2 );
+	VectorSet( ent->maxs, ATST_MAXS0, ATST_MAXS1, ATST_MAXS2 );
+
+	ent->contents = CONTENTS_SOLID|CONTENTS_BODY|CONTENTS_MONSTERCLIP|CONTENTS_BOTCLIP;
+	ent->flags |= FL_SHIELDED;
+	ent->takedamage = qtrue;
+	if ( !ent->health )
+	{
+		ent->health = 800;
+	}
+	ent->s.radius = 320;
+
+	ent->max_health = ent->health; // cg_draw needs this
+
+	G_SetOrigin( ent, ent->s.origin );
+	G_SetAngles( ent, ent->s.angles );
+	VectorCopy( ent->currentAngles, ent->s.angles2 );
+
+	gi.linkentity ( ent );
+
+	//FIXME: test the origin to make sure I'm clear?
+
+	ent->e_UseFunc = useF_misc_atst_use;
+	ent->svFlags |= SVF_PLAYER_USABLE;
+
+	//make it able to take damage and die when you're not in it...
+	//do an explosion and play the death anim, remove use func.
+	ent->e_DieFunc = dieF_misc_atst_die;
+}
+
+extern int	G_FindConfigstringIndex( const char *name, int start, int max, qboolean create );
+
+/*QUAKED misc_weather_zone (0 .5 .8) ? 
+Determines a region to check for weather contents - (optional, used to reduce load times)
+Place surrounding your inside/outside brushes.  It will not check for weather contents outside of these zones.
+*/
+void SP_misc_weather_zone( gentity_t *ent )
+{
+	gi.SetBrushModel(ent, ent->model);
+
+	char	temp[256];
+	sprintf( temp, "zone ( %f %f %f ) ( %f %f %f )", 
+		ent->mins[0], ent->mins[1], ent->mins[2], 
+		ent->maxs[0], ent->maxs[1], ent->maxs[2] );
+
+	G_FindConfigstringIndex(temp, CS_WORLD_FX, MAX_WORLD_FX, qtrue);
+
+//	gi.WE_AddWeatherZone(ent->mins, ent->maxs);
+	G_FreeEntity(ent);
+}
diff --git a/code/game/g_misc_model.cpp b/code/game/g_misc_model.cpp
new file mode 100644
index 0000000..e62f282
--- /dev/null
+++ b/code/game/g_misc_model.cpp
@@ -0,0 +1,792 @@
+// leave this line at the top for all g_xxxx.cpp files...
+#include "g_headers.h"
+
+
+#include "g_local.h"
+#include "g_functions.h"
+#include "bg_public.h"
+
+extern cvar_t *g_spskill;
+
+//
+// Helper functions
+//
+//------------------------------------------------------------
+void SetMiscModelModels( char *modelNameString, gentity_t *ent, qboolean damage_model )
+{
+	char	damageModel[MAX_QPATH];
+	char	chunkModel[MAX_QPATH];
+	int		len;
+
+	//Main model
+	ent->s.modelindex = G_ModelIndex( modelNameString );
+
+	if ( damage_model )
+	{
+		len = strlen( modelNameString ) - 4; // extract the extension
+
+		//Dead/damaged model
+		strncpy( damageModel, modelNameString, len );
+		damageModel[len] = 0;
+		strncpy( chunkModel, damageModel, sizeof(chunkModel));
+		strcat( damageModel, "_d1.md3" );
+		ent->s.modelindex2 = G_ModelIndex( damageModel );
+
+		ent->spawnflags |= 4; // deadsolid
+
+		//Chunk model
+		strcat( chunkModel, "_c1.md3" );
+		ent->s.modelindex3 = G_ModelIndex( chunkModel );
+	}
+}
+
+//------------------------------------------------------------
+void SetMiscModelDefaults( gentity_t *ent, useFunc_t use_func, char *material, int solid_mask,int animFlag, 
+									qboolean take_damage, qboolean damage_model = qfalse )
+{
+	// Apply damage and chunk models if they exist
+	SetMiscModelModels( ent->model, ent, damage_model );
+
+	ent->s.eFlags = animFlag;
+	ent->svFlags |= SVF_PLAYER_USABLE;
+	ent->contents = solid_mask;
+
+	G_SetOrigin( ent, ent->s.origin );
+	VectorCopy( ent->s.angles, ent->s.apos.trBase );
+	gi.linkentity (ent);
+
+	// Set a generic use function
+	
+	ent->e_UseFunc = use_func;	
+/*	if (use_func == useF_health_use) 
+	{
+		G_SoundIndex("sound/player/suithealth.wav");
+	} 
+	else if (use_func == useF_ammo_use ) 
+	{
+		G_SoundIndex("sound/player/suitenergy.wav");
+	}
+*/
+	G_SpawnInt( "material", material, (int *)&ent->material );
+	
+	if (ent->health) 
+	{
+		ent->max_health = ent->health;
+		ent->takedamage = take_damage;
+		ent->e_PainFunc = painF_misc_model_breakable_pain;
+		ent->e_DieFunc  = dieF_misc_model_breakable_die;
+	}
+}
+
+void HealthStationSettings(gentity_t *ent)
+{
+	G_SpawnInt( "count", "0", &ent->count );
+
+	if (!ent->count)
+	{
+		switch (g_spskill->integer)
+		{
+		case 0:	//	EASY
+			ent->count = 100; 
+			break;
+		case 1:	//	MEDIUM
+			ent->count = 75; 
+			break;
+		default :
+		case 2:	//	HARD
+			ent->count = 50; 
+			break;
+		}
+	}
+}
+
+
+void CrystalAmmoSettings(gentity_t *ent)
+{
+	G_SpawnInt( "count", "0", &ent->count );
+
+	if (!ent->count)
+	{
+		switch (g_spskill->integer)
+		{
+		case 0:	//	EASY
+			ent->count = 75; 
+			break;
+		case 1:	//	MEDIUM
+			ent->count = 75; 
+			break;
+		default :
+		case 2:	//	HARD
+			ent->count = 75; 
+			break;
+		}
+	}
+}
+
+
+//------------------------------------------------------------
+
+//------------------------------------------------------------
+/*QUAKED misc_model_ghoul (1 0 0) (-16 -16 -37) (16 16 32)
+"model"		arbitrary .glm file to display
+"health" - how much health the model has - default 60 (zero makes non-breakable)
+*/
+//------------------------------------------------------------
+#include "anims.h"
+extern int G_ParseAnimFileSet( const char *skeletonName, const char *modelName=0);
+int temp_animFileIndex;
+void set_MiscAnim( gentity_t *ent)
+{
+	animation_t *animations = level.knownAnimFileSets[temp_animFileIndex].animations;
+	if (ent->playerModel & 1)
+	{
+		int anim = BOTH_STAND3;
+		float animSpeed = 50.0f / animations[anim].frameLerp;
+
+		// yes, its the same animation, so work out where we are in the leg anim, and blend us
+		gi.G2API_SetBoneAnim(&ent->ghoul2[0], "model_root", animations[anim].firstFrame, 
+							(animations[anim].numFrames -1 )+ animations[anim].firstFrame,
+							BONE_ANIM_OVERRIDE_FREEZE | BONE_ANIM_BLEND , animSpeed, (cg.time?cg.time:level.time), -1, 350);
+	}
+	else
+	{
+		int anim = BOTH_PAIN3;
+		float animSpeed = 50.0f / animations[anim].frameLerp;
+		gi.G2API_SetBoneAnim(&ent->ghoul2[0], "model_root", animations[anim].firstFrame, 
+						(animations[anim].numFrames -1 )+ animations[anim].firstFrame,
+						BONE_ANIM_OVERRIDE_FREEZE | BONE_ANIM_BLEND, animSpeed, (cg.time?cg.time:level.time), -1, 350);
+	}
+	ent->nextthink = level.time + 900;
+	ent->playerModel++;
+
+}
+
+void SP_misc_model_ghoul( gentity_t *ent )
+{
+#if 1
+	ent->s.modelindex = G_ModelIndex( ent->model );
+	gi.G2API_InitGhoul2Model(ent->ghoul2, ent->model, ent->s.modelindex);
+	ent->s.radius = 50;
+#else
+	char name1[200] = "models/players/kyle/model.glm";
+	ent->s.modelindex = G_ModelIndex( name1 );
+
+	gi.G2API_InitGhoul2Model(ent->ghoul2, name1, ent->s.modelindex);
+	ent->s.radius = 150;
+
+			// we found the model ok - load it's animation config
+	temp_animFileIndex = G_ParseAnimFileSet("_humanoid", "kyle");
+ 	if ( temp_animFileIndex<0 ) 
+ 	{
+ 		Com_Printf( S_COLOR_RED"Failed to load animation file set models/players/jedi/animation.cfg\n");
+ 	}
+ 
+
+	ent->s.angles[0] = 0;
+	ent->s.angles[1] = 90;
+	ent->s.angles[2] = 0;
+
+	ent->s.origin[2] = 20;
+	ent->s.origin[1] = 80;
+//	ent->s.modelScale[0] = ent->s.modelScale[1] = ent->s.modelScale[2] = 0.8f;
+
+	VectorSet (ent->mins, -16, -16, -37);
+	VectorSet (ent->maxs, 16, 16, 32);
+//#if _DEBUG
+//loadsavecrash
+//	VectorCopy(ent->mins, ent->s.mins);
+//	VectorCopy(ent->maxs, ent->s.maxs);
+//#endif
+	ent->contents = CONTENTS_BODY;
+	ent->clipmask = MASK_NPCSOLID;
+
+	G_SetOrigin( ent, ent->s.origin );
+	VectorCopy( ent->s.angles, ent->s.apos.trBase );
+	ent->health = 1000;
+
+//	ent->s.modelindex = G_ModelIndex( "models/weapons2/blaster_r/g2blaster_w.glm" );
+//	gi.G2API_InitGhoul2Model(ent->ghoul2, "models/weapons2/blaster_r/g2blaster_w.glm", ent->s.modelindex);
+//	gi.G2API_AddBolt(&ent->ghoul2[0], "*weapon");
+//	gi.G2API_AttachG2Model(&ent->ghoul2[1],&ent->ghoul2[0], 0, 0);
+
+	gi.linkentity (ent);
+
+	animation_t *animations = level.knownAnimFileSets[temp_animFileIndex].animations;
+	int anim = BOTH_STAND3;
+	float animSpeed = 50.0f / animations[anim].frameLerp;
+	gi.G2API_SetBoneAnim(&ent->ghoul2[0], "model_root", animations[anim].firstFrame, 
+					(animations[anim].numFrames -1 )+ animations[anim].firstFrame,
+					BONE_ANIM_OVERRIDE_FREEZE , animSpeed, cg.time);
+
+//	int test = gi.G2API_GetSurfaceRenderStatus(&ent->ghoul2[0], "l_hand");
+//	gi.G2API_SetSurfaceOnOff(&ent->ghoul2[0], "l_arm",0x00000100);
+//	test = gi.G2API_GetSurfaceRenderStatus(&ent->ghoul2[0], "l_hand");
+
+//	gi.G2API_SetNewOrigin(&ent->ghoul2[0], gi.G2API_AddBolt(&ent->ghoul2[0], "rhang_tag_bone"));
+//	ent->s.apos.trDelta[1] = 10;
+//	ent->s.apos.trType = TR_LINEAR;
+
+
+	ent->nextthink = level.time + 1000;
+	ent->e_ThinkFunc = thinkF_set_MiscAnim;
+#endif
+}
+
+
+#define RACK_BLASTER	1
+#define RACK_REPEATER	2
+#define RACK_ROCKET		4
+
+/*QUAKED misc_model_gun_rack (1 0 0.25) (-14 -14 -4) (14 14 30) BLASTER REPEATER ROCKET
+model="models/map_objects/kejim/weaponsrack.md3"
+
+NOTE: can mix and match these spawnflags to get multi-weapon racks.  If only one type is checked the rack will be full of those weapons
+BLASTER - Puts one or more blaster guns on the rack.
+REPEATER - Puts one or more repeater guns on the rack.
+ROCKET - Puts one or more rocket launchers on the rack.
+*/
+
+void GunRackAddItem( gitem_t *gun, vec3_t org, vec3_t angs, float ffwd, float fright, float fup )
+{
+	vec3_t		fwd, right;
+	gentity_t	*it_ent = G_Spawn();
+	qboolean	rotate = qtrue;
+
+	AngleVectors( angs, fwd, right, NULL );
+
+	if ( it_ent && gun )
+	{
+		// FIXME: scaling the ammo will probably need to be tweaked to a reasonable amount...adjust as needed
+		// Set base ammo per type
+		if ( gun->giType == IT_WEAPON )
+		{
+			it_ent->spawnflags |= 16;// VERTICAL
+
+			switch( gun->giTag )
+			{
+			case WP_BLASTER:
+				it_ent->count = 15;
+				break;
+			case WP_REPEATER:
+				it_ent->count = 100;
+				break;
+			case WP_ROCKET_LAUNCHER:
+				it_ent->count = 4;
+				break;
+			}
+		}
+		else
+		{
+			rotate = qfalse;
+
+			// must deliberately make it small, or else the objects will spawn inside of each other.
+			VectorSet( it_ent->maxs, 6.75f, 6.75f, 6.75f );
+			VectorScale( it_ent->maxs, -1, it_ent->mins );
+		}
+
+		it_ent->spawnflags |= 1;// ITMSF_SUSPEND
+		it_ent->classname = G_NewString(gun->classname);	//copy it so it can be freed safely
+		G_SpawnItem( it_ent, gun );
+
+		// FinishSpawningItem handles everything, so clear the thinkFunc that was set in G_SpawnItem
+		FinishSpawningItem( it_ent );
+
+		if ( gun->giType == IT_AMMO )
+		{
+			if ( gun->giTag == AMMO_BLASTER ) // I guess this just has to use different logic??
+			{
+				if ( g_spskill->integer >= 2 )
+				{
+					it_ent->count += 10; // give more on higher difficulty because there will be more/harder enemies?
+				}
+			}
+			else
+			{
+				// scale ammo based on skill
+				switch ( g_spskill->integer )
+				{
+				case 0: // do default
+					break;
+				case 1:
+					it_ent->count *= 0.75f;
+					break;
+				case 2:
+					it_ent->count *= 0.5f;
+					break;
+				}
+			}
+		}
+
+		it_ent->nextthink = 0;
+
+		VectorCopy( org, it_ent->s.origin );
+		VectorMA( it_ent->s.origin, fright, right, it_ent->s.origin );
+		VectorMA( it_ent->s.origin, ffwd, fwd, it_ent->s.origin );
+		it_ent->s.origin[2] += fup;
+
+		VectorCopy( angs, it_ent->s.angles );
+
+		// by doing this, we can force the amount of ammo we desire onto the weapon for when it gets picked-up
+		it_ent->flags |= ( FL_DROPPED_ITEM | FL_FORCE_PULLABLE_ONLY );
+		it_ent->physicsBounce = 0.1f;
+
+		for ( int t = 0; t < 3; t++ )
+		{
+			if ( rotate )
+			{
+				if ( t == YAW )
+				{
+					it_ent->s.angles[t] = AngleNormalize180( it_ent->s.angles[t] + 180 + crandom() * 14 );
+				}
+				else
+				{
+					it_ent->s.angles[t] = AngleNormalize180( it_ent->s.angles[t] + crandom() * 4 );
+				}
+			}
+			else
+			{
+				if ( t == YAW )
+				{
+					it_ent->s.angles[t] = AngleNormalize180( it_ent->s.angles[t] + 90 + crandom() * 4 );
+				}
+			}
+		}
+
+		G_SetAngles( it_ent, it_ent->s.angles );
+		G_SetOrigin( it_ent, it_ent->s.origin );
+		gi.linkentity( it_ent );
+	}
+}
+
+//---------------------------------------------
+void SP_misc_model_gun_rack( gentity_t *ent )
+{
+	gitem_t		*blaster = NULL, *repeater = NULL, *rocket = NULL;
+	int			ct = 0;
+	float		ofz[3];
+	gitem_t		*itemList[3];
+
+	// If BLASTER is checked...or nothing is checked then we'll do blasters
+	if (( ent->spawnflags & RACK_BLASTER ) || !(ent->spawnflags & ( RACK_BLASTER | RACK_REPEATER | RACK_ROCKET )))
+	{
+		blaster	= FindItemForWeapon( WP_BLASTER );
+	}
+
+	if (( ent->spawnflags & RACK_REPEATER ))
+	{
+		repeater = FindItemForWeapon( WP_REPEATER );
+	}
+
+	if (( ent->spawnflags & RACK_ROCKET ))
+	{
+		rocket = FindItemForWeapon( WP_ROCKET_LAUNCHER );
+	}
+
+	//---------weapon types
+	if ( blaster )
+	{
+		ofz[ct] = 23.0f;
+		itemList[ct++] = blaster;
+	}
+
+	if ( repeater )
+	{
+		ofz[ct] = 24.5f;
+		itemList[ct++] = repeater;
+	}
+
+	if ( rocket )
+	{
+		ofz[ct] = 25.5f;
+		itemList[ct++] = rocket;
+	}
+
+	if ( ct ) //..should always have at least one item on their, but just being safe
+	{
+		for ( ; ct < 3 ; ct++ )
+		{
+			ofz[ct] = ofz[0];
+			itemList[ct] = itemList[0]; // first weapon ALWAYS propagates to fill up the shelf
+		}
+	}
+
+	// now actually add the items to the shelf...validate that we have a list to add
+	if ( ct )
+	{
+		for ( int i = 0; i < ct; i++ )
+		{
+			GunRackAddItem( itemList[i], ent->s.origin, ent->s.angles, crandom() * 2, ( i - 1 ) * 9 + crandom() * 2, ofz[i] );
+		}
+	}
+
+	ent->s.modelindex = G_ModelIndex( "models/map_objects/kejim/weaponsrack.md3" );
+
+	G_SetOrigin( ent, ent->s.origin );
+	G_SetAngles( ent, ent->s.angles );
+
+	ent->contents = CONTENTS_SOLID;
+
+	gi.linkentity( ent );
+}
+
+#define RACK_METAL_BOLTS	2
+#define RACK_ROCKETS		4
+#define RACK_WEAPONS		8
+#define RACK_HEALTH			16
+#define RACK_PWR_CELL		32
+#define RACK_NO_FILL		64
+
+/*QUAKED misc_model_ammo_rack (1 0 0.25) (-14 -14 -4) (14 14 30) BLASTER METAL_BOLTS ROCKETS WEAPON HEALTH PWR_CELL NO_FILL
+model="models/map_objects/kejim/weaponsrung.md3"
+
+NOTE: can mix and match these spawnflags to get multi-ammo racks.  If only one type is checked the rack will be full of that ammo.  Only three ammo packs max can be displayed.
+
+
+BLASTER - Adds one or more ammo packs that are compatible with Blasters and the Bryar pistol.
+METAL_BOLTS - Adds one or more metal bolt ammo packs that are compatible with the heavy repeater and the flechette gun
+ROCKETS - Puts one or more rocket packs on a rack.
+WEAPON - adds a weapon matching a selected ammo type to the rack.
+HEALTH - adds a health pack to the top shelf of the ammo rack
+PWR_CELL - Adds one or more power cell packs that are compatible with the Disuptor, bowcaster, and demp2
+NO_FILL - Only puts selected ammo on the rack, it never fills up all three slots if only one or two items were checked
+*/
+
+extern gitem_t	*FindItemForAmmo( ammo_t ammo );
+
+//---------------------------------------------
+void SP_misc_model_ammo_rack( gentity_t *ent )
+{
+// If BLASTER is checked...or nothing is checked then we'll do blasters
+	if (( ent->spawnflags & RACK_BLASTER ) || !(ent->spawnflags & ( RACK_BLASTER | RACK_METAL_BOLTS | RACK_ROCKETS | RACK_PWR_CELL )))
+	{
+		if ( ent->spawnflags & RACK_WEAPONS )
+		{
+			RegisterItem( FindItemForWeapon( WP_BLASTER ));
+		}
+		RegisterItem( FindItemForAmmo( AMMO_BLASTER ));
+	}
+
+	if (( ent->spawnflags & RACK_METAL_BOLTS ))
+	{
+		if ( ent->spawnflags & RACK_WEAPONS )
+		{
+			RegisterItem( FindItemForWeapon( WP_REPEATER ));
+		}
+		RegisterItem( FindItemForAmmo( AMMO_METAL_BOLTS ));
+	}
+
+	if (( ent->spawnflags & RACK_ROCKETS ))
+	{
+		if ( ent->spawnflags & RACK_WEAPONS )
+		{
+			RegisterItem( FindItemForWeapon( WP_ROCKET_LAUNCHER ));
+		}
+		RegisterItem( FindItemForAmmo( AMMO_ROCKETS ));
+	}
+
+	if (( ent->spawnflags & RACK_PWR_CELL ))
+	{
+		RegisterItem( FindItemForAmmo( AMMO_POWERCELL ));
+	}
+
+	if (( ent->spawnflags & RACK_HEALTH ))
+	{
+		RegisterItem( FindItem( "item_medpak_instant" ));
+	}
+
+	ent->e_ThinkFunc = thinkF_spawn_rack_goods;
+	ent->nextthink = level.time + 100;
+
+	G_SetOrigin( ent, ent->s.origin );
+	G_SetAngles( ent, ent->s.angles );
+
+	ent->contents = CONTENTS_SHOTCLIP|CONTENTS_PLAYERCLIP|CONTENTS_MONSTERCLIP|CONTENTS_BOTCLIP;//CONTENTS_SOLID;//so use traces can go through them
+
+	gi.linkentity( ent );
+}
+
+// AMMO RACK!!
+void spawn_rack_goods( gentity_t *ent )
+{
+	float		v_off = 0;
+	gitem_t		*blaster = NULL, *metal_bolts = NULL, *rockets = NULL, *it = NULL;
+	gitem_t		*am_blaster = NULL, *am_metal_bolts = NULL, *am_rockets = NULL, *am_pwr_cell = NULL;
+	gitem_t		*health = NULL;
+	int			pos = 0, ct = 0;
+	gitem_t		*itemList[4]; // allocating 4, but we only use 3.  done so I don't have to validate that the array isn't full before I add another
+
+	gi.unlinkentity( ent );
+
+	// If BLASTER is checked...or nothing is checked then we'll do blasters
+	if (( ent->spawnflags & RACK_BLASTER ) || !(ent->spawnflags & ( RACK_BLASTER | RACK_METAL_BOLTS | RACK_ROCKETS | RACK_PWR_CELL )))
+	{
+		if ( ent->spawnflags & RACK_WEAPONS )
+		{
+			blaster	= FindItemForWeapon( WP_BLASTER );
+		}
+		am_blaster	= FindItemForAmmo( AMMO_BLASTER );
+	}
+
+	if (( ent->spawnflags & RACK_METAL_BOLTS ))
+	{
+		if ( ent->spawnflags & RACK_WEAPONS )
+		{
+			metal_bolts = FindItemForWeapon( WP_REPEATER );
+		}
+		am_metal_bolts = FindItemForAmmo( AMMO_METAL_BOLTS );
+	}
+
+	if (( ent->spawnflags & RACK_ROCKETS ))
+	{
+		if ( ent->spawnflags & RACK_WEAPONS )
+		{
+			rockets = FindItemForWeapon( WP_ROCKET_LAUNCHER );
+		}
+		am_rockets = FindItemForAmmo( AMMO_ROCKETS );
+	}
+
+	if (( ent->spawnflags & RACK_PWR_CELL ))
+	{
+		am_pwr_cell = FindItemForAmmo( AMMO_POWERCELL );
+	}
+
+	if (( ent->spawnflags & RACK_HEALTH ))
+	{
+		health = FindItem( "item_medpak_instant" );
+		RegisterItem( health );
+	}
+
+	//---------Ammo types
+	if ( am_blaster )
+	{
+		itemList[ct++] = am_blaster;
+	}
+
+	if ( am_metal_bolts )
+	{
+		itemList[ct++] = am_metal_bolts;
+	}
+
+	if ( am_pwr_cell )
+	{
+		itemList[ct++] = am_pwr_cell;
+	}
+
+	if ( am_rockets )
+	{
+		itemList[ct++] = am_rockets;
+	}
+
+	if ( !(ent->spawnflags & RACK_NO_FILL) && ct ) //double negative..should always have at least one item on there, but just being safe
+	{
+		for ( ; ct < 3 ; ct++ )
+		{
+			itemList[ct] = itemList[0]; // first item ALWAYS propagates to fill up the shelf
+		}
+	}
+
+	// now actually add the items to the shelf...validate that we have a list to add
+	if ( ct )
+	{
+		for ( int i = 0; i < ct; i++ )
+		{
+			GunRackAddItem( itemList[i], ent->s.origin, ent->s.angles, crandom() * 0.5f, (i-1)* 8, 7.0f );
+		}
+	}
+
+	// -----Weapon option
+	if ( ent->spawnflags & RACK_WEAPONS )
+	{
+		if ( !(ent->spawnflags & ( RACK_BLASTER | RACK_METAL_BOLTS | RACK_ROCKETS | RACK_PWR_CELL )))
+		{
+			// nothing was selected, so we assume blaster pack
+			it = blaster;
+		}
+		else
+		{
+			// if weapon is checked...and so are one or more ammo types, then pick a random weapon to display..always give weaker weapons first
+			if ( blaster )
+			{
+				it = blaster;
+				v_off = 25.5f;
+			}
+			else if ( metal_bolts )
+			{
+				it = metal_bolts;
+				v_off = 27.0f;
+			}
+			else if ( rockets )
+			{
+				it = rockets;
+				v_off = 28.0f;
+			}
+		}
+
+		if ( it )
+		{
+			// since we may have to put up a health pack on the shelf, we should know where we randomly put
+			//	the gun so we don't put the pack on the same spot..so pick either the left or right side
+			pos = ( random() > .5 ) ? -1 : 1;
+
+			GunRackAddItem( it, ent->s.origin, ent->s.angles, crandom() * 2, ( random() * 6 + 4 ) * pos, v_off );
+		}
+	}
+
+	// ------Medpack
+	if (( ent->spawnflags & RACK_HEALTH ) && health )
+	{
+		if ( !pos )
+		{
+			// we haven't picked a side already...
+			pos = ( random() > .5 ) ? -1 : 1;
+		}
+		else
+		{
+			// switch to the opposite side
+			pos *= -1;
+		}
+
+		GunRackAddItem( health, ent->s.origin, ent->s.angles, crandom() * 0.5f, ( random() * 4 + 4 ) * pos, 24 );
+	}
+
+	ent->s.modelindex = G_ModelIndex( "models/map_objects/kejim/weaponsrung.md3" );
+
+	G_SetOrigin( ent, ent->s.origin );
+	G_SetAngles( ent, ent->s.angles );
+
+	gi.linkentity( ent );
+}
+
+#define DROP_MEDPACK	1
+#define DROP_SHIELDS	2
+#define DROP_BACTA		4
+#define DROP_BATTERIES	8
+
+/*QUAKED misc_model_cargo_small (1 0 0.25) (-14 -14 -4) (14 14 30) MEDPACK SHIELDS BACTA BATTERIES
+model="models/map_objects/kejim/cargo_small.md3"
+
+  Cargo crate that can only be destroyed by heavy class weapons ( turrets, emplaced guns, at-st )  Can spawn useful things when it breaks
+
+MEDPACK - instant use medpacks
+SHIELDS - instant shields
+BACTA - bacta tanks
+BATTERIES -
+
+"health" - how much damage to take before blowing up ( default 25 )
+"splashRadius" - damage range when it explodes ( default 96 )
+"splashDamage" - damage to do within explode range ( default 1 )
+
+*/
+extern gentity_t *LaunchItem( gitem_t *item, const vec3_t origin, const vec3_t velocity, char *target );
+
+void misc_model_cargo_die( gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int mod, int dFlags, int hitLoc )
+{
+	int		flags;
+	vec3_t	org, temp;
+	gitem_t *health = NULL, *shields = NULL, *bacta = NULL, *batteries = NULL;
+
+	// copy these for later
+	flags = self->spawnflags;
+	VectorCopy( self->currentOrigin, org );
+
+	// we already had spawn flags, but we don't care what they were...we just need to set up the flags we want for misc_model_breakable_die
+	self->spawnflags = 8; // NO_DMODEL
+
+	// pass through to get the effects and such
+	misc_model_breakable_die( self, inflictor, attacker, damage, mod );
+
+	// now that the model is broken, we can safely spawn these in it's place without them being in solid
+	temp[2] = org[2] + 16;
+
+	// annoying, but spawn each thing in its own little quadrant so that they don't end up on top of each other
+	if (( flags & DROP_MEDPACK ))
+	{
+		health = FindItem( "item_medpak_instant" );
+
+		if ( health )
+		{
+			temp[0] = org[0] + crandom() * 8 + 16;
+			temp[1] = org[1] + crandom() * 8 + 16;
+
+			LaunchItem( health, temp, vec3_origin, NULL );
+		}
+	}
+	if (( flags & DROP_SHIELDS ))
+	{
+		shields = FindItem( "item_shield_sm_instant" );
+
+		if ( shields )
+		{
+			temp[0] = org[0] + crandom() * 8 - 16;
+			temp[1] = org[1] + crandom() * 8 + 16;
+
+			LaunchItem( shields, temp, vec3_origin, NULL );
+		}
+	}
+
+	if (( flags & DROP_BACTA ))
+	{
+		bacta = FindItem( "item_bacta" );
+
+		if ( bacta )
+		{
+			temp[0] = org[0] + crandom() * 8 - 16;
+			temp[1] = org[1] + crandom() * 8 - 16;
+
+			LaunchItem( bacta, temp, vec3_origin, NULL );
+		}
+	}
+
+	if (( flags & DROP_BATTERIES ))
+	{
+		batteries = FindItem( "item_battery" );
+
+		if ( batteries )
+		{
+			temp[0] = org[0] + crandom() * 8 + 16;
+			temp[1] = org[1] + crandom() * 8 - 16;
+
+			LaunchItem( batteries, temp, vec3_origin, NULL );
+		}
+	}
+}
+
+//---------------------------------------------
+void SP_misc_model_cargo_small( gentity_t *ent )
+{
+	G_SpawnInt( "splashRadius", "96", &ent->splashRadius );
+	G_SpawnInt( "splashDamage", "1", &ent->splashDamage );
+
+	if (( ent->spawnflags & DROP_MEDPACK ))
+	{
+		RegisterItem( FindItem( "item_medpak_instant" ));
+	}
+
+	if (( ent->spawnflags & DROP_SHIELDS ))
+	{
+		RegisterItem( FindItem( "item_shield_sm_instant" ));
+	}
+
+	if (( ent->spawnflags & DROP_BACTA ))
+	{
+//		RegisterItem( FindItem( "item_bacta" ));
+	}
+
+	if (( ent->spawnflags & DROP_BATTERIES ))
+	{
+		RegisterItem( FindItem( "item_battery" ));
+	}
+
+	G_SpawnInt( "health", "25", &ent->health );
+
+	SetMiscModelDefaults( ent, useF_NULL, "11", CONTENTS_SOLID|CONTENTS_OPAQUE|CONTENTS_BODY|CONTENTS_MONSTERCLIP|CONTENTS_BOTCLIP, NULL, qtrue, NULL );
+	ent->s.modelindex2 = G_ModelIndex("/models/map_objects/kejim/cargo_small.md3");	// Precache model
+
+	// we only take damage from a heavy weapon class missile
+	ent->flags |= FL_DMG_BY_HEAVY_WEAP_ONLY;
+
+	ent->e_DieFunc = dieF_misc_model_cargo_die;
+
+	ent->radius = 1.5f; // scale number of chunks spawned
+}
+
diff --git a/code/game/g_missile.cpp b/code/game/g_missile.cpp
new file mode 100644
index 0000000..ab225ac
--- /dev/null
+++ b/code/game/g_missile.cpp
@@ -0,0 +1,1534 @@
+// leave this line at the top for all g_xxxx.cpp files...
+#include "g_headers.h"
+
+
+#include "g_local.h"
+#include "g_functions.h"
+#include "wp_saber.h"
+#include "bg_local.h"			   
+
+#ifdef _DEBUG
+	#include <float.h>
+#endif //_DEBUG
+
+extern qboolean InFront( vec3_t spot, vec3_t from, vec3_t fromAngles, float threshHold = 0.0f );
+qboolean LogAccuracyHit( gentity_t *target, gentity_t *attacker );
+extern qboolean PM_SaberInParry( int move );
+extern qboolean PM_SaberInReflect( int move );
+extern qboolean PM_SaberInIdle( int move );
+extern qboolean PM_SaberInAttack( int move );
+extern qboolean PM_SaberInTransitionAny( int move );
+extern qboolean PM_SaberInSpecialAttack( int anim );
+
+//-------------------------------------------------------------------------
+#ifdef _IMMERSION
+void G_MissileBounceEffect( gentity_t *ent, int hitEntNum, vec3_t org, vec3_t dir, qboolean hitWorld )
+#else
+void G_MissileBounceEffect( gentity_t *ent, vec3_t org, vec3_t dir, qboolean hitWorld )
+#endif // _IMMERSION
+{
+	//FIXME: have an EV_BOUNCE_MISSILE event that checks the s.weapon and does the appropriate effect
+	switch( ent->s.weapon )
+	{
+	case WP_BOWCASTER:
+#ifdef _IMMERSION
+		if ( hitWorld )
+		{ 
+			G_PlayEffect( "bowcaster/bounce_wall", hitEntNum, org, dir ); 
+		}
+		else
+		{
+			G_PlayEffect( "bowcaster/deflect", hitEntNum, ent->currentOrigin, dir );
+		}
+#else
+		if ( hitWorld )
+		{
+			G_PlayEffect( "bowcaster/bounce_wall", org, dir );
+		}
+		else
+		{
+			G_PlayEffect( "bowcaster/deflect", ent->currentOrigin, dir );
+		}
+#endif // _IMMERSION
+		break;
+	case WP_BLASTER:
+	case WP_BRYAR_PISTOL:
+	case WP_BLASTER_PISTOL:
+#ifdef _IMMERSION
+		G_PlayEffect( "blaster/deflect", hitEntNum, ent->currentOrigin, dir );
+#else
+		G_PlayEffect( "blaster/deflect", ent->currentOrigin, dir );
+#endif // _IMMERSION
+		break;
+	default:
+		{
+			gentity_t *tent = G_TempEntity( org, EV_GRENADE_BOUNCE );
+			VectorCopy( dir, tent->pos1 );
+			tent->s.weapon = ent->s.weapon;
+#ifdef _IMMERSION
+			if ( hitEntNum != -1 )
+			{
+				tent->s.saberActive = 1;
+				tent->s.otherEntityNum = hitEntNum;
+			}
+#endif // _IMMERSION
+		}
+		break;
+	}
+}
+
+#ifdef _IMMERSION
+void G_MissileReflectEffect( gentity_t *ent, int hitEntNum, vec3_t org, vec3_t dir )
+#else
+void G_MissileReflectEffect( gentity_t *ent, vec3_t org, vec3_t dir )
+#endif // _IMMERSION
+{
+	//FIXME: have an EV_BOUNCE_MISSILE event that checks the s.weapon and does the appropriate effect
+	switch( ent->s.weapon )
+	{
+	case WP_BOWCASTER:
+#ifdef _IMMERSION
+		G_PlayEffect( "bowcaster/deflect", hitEntNum, ent->currentOrigin, dir );
+#else
+		G_PlayEffect( "bowcaster/deflect", ent->currentOrigin, dir );
+#endif // _IMMERSION
+		break;
+	case WP_BLASTER:
+	case WP_BRYAR_PISTOL:
+	case WP_BLASTER_PISTOL:
+	default:
+#ifdef _IMMERSION
+		G_PlayEffect( "blaster/deflect", hitEntNum, ent->currentOrigin, dir );
+#else
+		G_PlayEffect( "blaster/deflect", ent->currentOrigin, dir );
+#endif // _IMMERSION
+		break;
+	}
+}
+
+//-------------------------------------------------------------------------
+static void G_MissileStick( gentity_t *missile, gentity_t *other, trace_t *tr )
+{ 
+	if ( other->NPC || !Q_stricmp( other->classname, "misc_model_breakable" ))
+	{
+		// we bounce off of NPC's and misc model breakables because sticking to them requires too much effort
+		vec3_t velocity;
+
+		int hitTime = level.previousTime + ( level.time - level.previousTime ) * tr->fraction;
+
+		EvaluateTrajectoryDelta( &missile->s.pos, hitTime, velocity );
+
+		float dot = DotProduct( velocity, tr->plane.normal );
+		G_SetOrigin( missile, tr->endpos );
+		VectorMA( velocity, -1.6f * dot, tr->plane.normal, missile->s.pos.trDelta );
+		VectorMA( missile->s.pos.trDelta, 10, tr->plane.normal, missile->s.pos.trDelta );
+		missile->s.pos.trTime = level.time - 10; // move a bit on the first frame
+
+		// check for stop
+		if ( tr->entityNum >= 0 && tr->entityNum < ENTITYNUM_WORLD && 
+				tr->plane.normal[2] > 0.7 && missile->s.pos.trDelta[2] < 40 ) //this can happen even on very slightly sloped walls, so changed it from > 0 to > 0.7
+		{
+			missile->nextthink = level.time + 100;
+		}
+		else
+		{
+			// fall till we hit the ground
+			missile->s.pos.trType = TR_GRAVITY;
+		}
+
+		return; // don't stick yet
+	}
+
+	if ( missile->e_TouchFunc != touchF_NULL )
+	{
+		GEntity_TouchFunc( missile, other, tr );
+	}
+
+	G_AddEvent( missile, EV_MISSILE_STICK, 0 );
+
+	if ( other->s.eType == ET_MOVER || other->e_DieFunc == dieF_funcBBrushDie || other->e_DieFunc == dieF_funcGlassDie)
+	{
+		// movers and breakable brushes need extra info...so sticky missiles can ride lifts and blow up when the thing they are attached to goes away.
+		missile->s.groundEntityNum = tr->entityNum;
+	}
+}
+
+/*
+================
+G_ReflectMissile
+
+  Reflect the missile roughly back at it's owner
+================
+*/
+extern gentity_t *Jedi_FindEnemyInCone( gentity_t *self, gentity_t *fallback, float minDot );
+void G_ReflectMissile( gentity_t *ent, gentity_t *missile, vec3_t forward ) 
+{
+	vec3_t	bounce_dir;
+	int		i;
+	float	speed;
+	qboolean reflected = qfalse;
+	gentity_t	*owner = ent;
+
+	if ( ent->owner )
+	{
+		owner = ent->owner;
+	}
+
+	//save the original speed
+	speed = VectorNormalize( missile->s.pos.trDelta );
+
+	if ( ent && owner && owner->client && !owner->client->ps.saberInFlight && 
+		(owner->client->ps.forcePowerLevel[FP_SABER_DEFENSE] > FORCE_LEVEL_2 || (owner->client->ps.forcePowerLevel[FP_SABER_DEFENSE]>FORCE_LEVEL_1&&!Q_irand( 0, 3 )) ) )
+	{//if high enough defense skill and saber in-hand (100% at level 3, 25% at level 2, 0% at level 1), reflections are perfectly deflected toward an enemy
+		gentity_t *enemy;
+		if ( owner->enemy && Q_irand( 0, 3 ) )
+		{//toward current enemy 75% of the time
+			enemy = owner->enemy;
+		}
+		else
+		{//find another enemy
+			enemy = Jedi_FindEnemyInCone( owner, owner->enemy, 0.3f );
+		}
+		if ( enemy )
+		{
+			vec3_t	bullseye;
+			CalcEntitySpot( enemy, SPOT_HEAD, bullseye );
+			bullseye[0] += Q_irand( -4, 4 );
+			bullseye[1] += Q_irand( -4, 4 );
+			bullseye[2] += Q_irand( -16, 4 );
+			VectorSubtract( bullseye, missile->currentOrigin, bounce_dir );
+			VectorNormalize( bounce_dir );
+			if ( !PM_SaberInParry( owner->client->ps.saberMove ) 
+				&& !PM_SaberInReflect( owner->client->ps.saberMove ) 
+				&& !PM_SaberInIdle( owner->client->ps.saberMove ) )
+			{//a bit more wild
+				if ( PM_SaberInAttack( owner->client->ps.saberMove )
+					|| PM_SaberInTransitionAny( owner->client->ps.saberMove )
+					|| PM_SaberInSpecialAttack( owner->client->ps.torsoAnim ) )
+				{//moderately more wild
+					for ( i = 0; i < 3; i++ )
+					{
+						bounce_dir[i] += Q_flrand( -0.2f, 0.2f );
+					}
+				}
+				else
+				{//mildly more wild
+					for ( i = 0; i < 3; i++ )
+					{
+						bounce_dir[i] += Q_flrand( -0.1f, 0.1f );
+					}
+				}
+			}
+			VectorNormalize( bounce_dir );
+			reflected = qtrue;
+		}
+	}
+	if ( !reflected )
+	{
+		if ( missile->owner && missile->s.weapon != WP_SABER )
+		{//bounce back at them if you can
+			VectorSubtract( missile->owner->currentOrigin, missile->currentOrigin, bounce_dir );
+			VectorNormalize( bounce_dir );
+		}
+		else
+		{
+			vec3_t missile_dir;
+
+			VectorSubtract( ent->currentOrigin, missile->currentOrigin, missile_dir );
+			VectorCopy( missile->s.pos.trDelta, bounce_dir );
+			VectorScale( bounce_dir, DotProduct( forward, missile_dir ), bounce_dir );
+			VectorNormalize( bounce_dir );
+		}
+		if ( owner->s.weapon == WP_SABER && owner->client )
+		{//saber
+			if ( owner->client->ps.saberInFlight )
+			{//reflecting off a thrown saber is totally wild
+				for ( i = 0; i < 3; i++ )
+				{
+					bounce_dir[i] += Q_flrand( -0.8f, 0.8f );
+				}
+			}
+			else if ( owner->client->ps.forcePowerLevel[FP_SABER_DEFENSE] <= FORCE_LEVEL_1 )
+			{// at level 1
+				for ( i = 0; i < 3; i++ )
+				{
+					bounce_dir[i] += Q_flrand( -0.4f, 0.4f );
+				}
+			}
+			else
+			{// at level 2
+				for ( i = 0; i < 3; i++ )
+				{
+					bounce_dir[i] += Q_flrand( -0.2f, 0.2f );
+				}
+			}
+			if ( !PM_SaberInParry( owner->client->ps.saberMove ) 
+				&& !PM_SaberInReflect( owner->client->ps.saberMove ) 
+				&& !PM_SaberInIdle( owner->client->ps.saberMove ) )
+			{//a bit more wild
+				if ( PM_SaberInAttack( owner->client->ps.saberMove )
+					|| PM_SaberInTransitionAny( owner->client->ps.saberMove )
+					|| PM_SaberInSpecialAttack( owner->client->ps.torsoAnim ) )
+				{//really wild
+					for ( i = 0; i < 3; i++ )
+					{
+						bounce_dir[i] += Q_flrand( -0.3f, 0.3f );
+					}
+				}
+				else
+				{//mildly more wild
+					for ( i = 0; i < 3; i++ )
+					{
+						bounce_dir[i] += Q_flrand( -0.1f, 0.1f );
+					}
+				}
+			}
+		}
+		else
+		{//some other kind of reflection
+			for ( i = 0; i < 3; i++ )
+			{
+				bounce_dir[i] += Q_flrand( -0.2f, 0.2f );
+			}
+		}
+	}
+	VectorNormalize( bounce_dir );
+	VectorScale( bounce_dir, speed, missile->s.pos.trDelta );
+#ifdef _DEBUG
+		assert( !_isnan(missile->s.pos.trDelta[0])&&!_isnan(missile->s.pos.trDelta[1])&&!_isnan(missile->s.pos.trDelta[2]));
+#endif// _DEBUG
+	missile->s.pos.trTime = level.time - 10;		// move a bit on the very first frame
+	VectorCopy( missile->currentOrigin, missile->s.pos.trBase );
+	if ( missile->s.weapon != WP_SABER )
+	{//you are mine, now!
+		if ( !missile->lastEnemy )
+		{//remember who originally shot this missile
+			missile->lastEnemy = missile->owner;
+		}
+		missile->owner = owner;
+	}
+	if ( missile->s.weapon == WP_ROCKET_LAUNCHER )
+	{//stop homing
+		missile->e_ThinkFunc = thinkF_NULL;
+	}
+}
+
+/*
+================
+G_BounceRollMissile
+
+================
+*/
+void G_BounceRollMissile( gentity_t *ent, trace_t *trace ) 
+{
+	vec3_t	velocity, normal;
+	float	dot, speedXY, velocityZ, normalZ;
+	int		hitTime;
+
+	// reflect the velocity on the trace plane
+	hitTime = level.previousTime + ( level.time - level.previousTime ) * trace->fraction;
+	EvaluateTrajectoryDelta( &ent->s.pos, hitTime, velocity );
+	//Do horizontal
+	//FIXME: Need to roll up, down slopes
+	velocityZ = velocity[2];
+	velocity[2] = 0;
+	speedXY = VectorLength( velocity );//friction
+	VectorCopy( trace->plane.normal, normal );
+	normalZ = normal[2];
+	normal[2] = 0;
+	dot = DotProduct( velocity, normal );
+	VectorMA( velocity, -2*dot, normal, ent->s.pos.trDelta );
+	//now do the z reflection
+	//FIXME: Bobbles when it stops
+	VectorSet( velocity, 0, 0, velocityZ );
+	VectorSet( normal, 0, 0, normalZ );
+	dot = DotProduct( velocity, normal )*-1;
+	if ( dot > 10 )
+	{
+		ent->s.pos.trDelta[2] = dot*0.3f;//not very bouncy
+	}
+	else
+	{
+		ent->s.pos.trDelta[2] = 0;
+	}
+
+	// check for stop
+	if ( speedXY <= 0 ) 
+	{
+		G_SetOrigin( ent, trace->endpos );
+		VectorCopy( ent->currentAngles, ent->s.apos.trBase );
+		VectorClear( ent->s.apos.trDelta );
+		ent->s.apos.trType = TR_STATIONARY;
+		return;
+	}
+
+	//FIXME: rolling needs to match direction
+	VectorCopy( ent->currentAngles, ent->s.apos.trBase );
+	VectorCopy( ent->s.pos.trDelta, ent->s.apos.trDelta );
+
+	//remember this spot
+	VectorCopy( trace->endpos, ent->currentOrigin );
+	ent->s.pos.trTime = hitTime - 10;
+	VectorCopy( ent->currentOrigin, ent->s.pos.trBase );
+	//VectorCopy( trace->plane.normal, ent->pos1 );
+}
+
+/*
+================
+G_BounceMissile
+
+================
+*/
+void G_BounceMissile( gentity_t *ent, trace_t *trace ) {
+	vec3_t	velocity;
+	float	dot;
+	int		hitTime;
+
+	// reflect the velocity on the trace plane
+	hitTime = level.previousTime + ( level.time - level.previousTime ) * trace->fraction;
+	EvaluateTrajectoryDelta( &ent->s.pos, hitTime, velocity );
+	dot = DotProduct( velocity, trace->plane.normal );
+	VectorMA( velocity, -2*dot, trace->plane.normal, ent->s.pos.trDelta );
+
+	if ( ent->s.eFlags & EF_BOUNCE_SHRAPNEL ) 
+	{
+		VectorScale( ent->s.pos.trDelta, 0.25f, ent->s.pos.trDelta );
+		ent->s.pos.trType = TR_GRAVITY;
+
+		// check for stop
+		if ( trace->plane.normal[2] > 0.7 && ent->s.pos.trDelta[2] < 40 ) //this can happen even on very slightly sloped walls, so changed it from > 0 to > 0.7
+		{
+			G_SetOrigin( ent, trace->endpos );
+			ent->nextthink = level.time + 100;
+			return;
+		}
+	}
+	else if ( ent->s.eFlags & EF_BOUNCE_HALF ) 
+	{
+		VectorScale( ent->s.pos.trDelta, 0.5, ent->s.pos.trDelta );
+
+		// check for stop
+		if ( trace->plane.normal[2] > 0.7 && ent->s.pos.trDelta[2] < 40 ) //this can happen even on very slightly sloped walls, so changed it from > 0 to > 0.7
+		{
+			if ( ent->s.weapon == WP_THERMAL )
+			{//roll when you "stop"
+				ent->s.pos.trType = TR_INTERPOLATE;
+			}
+			else
+			{
+				G_SetOrigin( ent, trace->endpos );
+				ent->nextthink = level.time + 500;
+				return;
+			}
+		}
+
+		if ( ent->s.weapon == WP_THERMAL )
+		{
+			ent->has_bounced = qtrue;
+		}
+	}
+
+#if 0
+	// OLD--this looks so wrong.  It looked wrong in EF.  It just must be wrong.
+	VectorAdd( ent->currentOrigin, trace->plane.normal, ent->currentOrigin);
+
+	ent->s.pos.trTime = level.time - 10;
+#else
+	// NEW--It would seem that we want to set our trBase to the trace endpos
+	//	and set the trTime to the actual time of impact....
+	VectorAdd( trace->endpos, trace->plane.normal, ent->currentOrigin );
+	if ( hitTime >= level.time )
+	{//trace fraction must have been 1
+		ent->s.pos.trTime = level.time - 10;
+	}
+	else
+	{
+		ent->s.pos.trTime = hitTime - 10; // this is kinda dumb hacking, but it pushes the missile away from the impact plane a bit
+	}
+#endif
+
+	VectorCopy( ent->currentOrigin, ent->s.pos.trBase );
+	VectorCopy( trace->plane.normal, ent->pos1 );
+
+	if ( ent->s.weapon != WP_SABER 
+		&& ent->s.weapon != WP_THERMAL 
+		&& ent->e_clThinkFunc != clThinkF_CG_Limb
+		&& ent->e_ThinkFunc != thinkF_LimbThink )
+	{//not a saber, bouncing thermal or limb
+		//now you can damage the guy you came from
+		ent->owner = NULL;
+	}
+}
+ 
+/*
+================
+G_MissileImpact
+
+================
+*/
+
+void NoghriGasCloudThink( gentity_t *self )
+{
+	self->nextthink = level.time + FRAMETIME;
+	
+	AddSightEvent( self->owner, self->currentOrigin, 200, AEL_DANGER, 50 );
+
+	if ( self->fx_time < level.time )
+	{
+		vec3_t	up = {0,0,1};
+		G_PlayEffect( "noghri_stick/gas_cloud", self->currentOrigin, up );
+		self->fx_time = level.time + 250;
+	}
+
+	if ( level.time - self->s.time <= 2500 )
+	{
+		if ( !Q_irand( 0, 3-g_spskill->integer ) )
+		{
+			G_RadiusDamage( self->currentOrigin, self->owner, Q_irand( 1, 4 ), self->splashRadius, 
+				self->owner, self->splashMethodOfDeath );
+		}
+	}
+
+	if ( level.time - self->s.time > 3000 )
+	{
+		G_FreeEntity( self );
+	}
+}
+
+void G_SpawnNoghriGasCloud( gentity_t *ent )
+{//FIXME: force-pushable/dispersable?
+	ent->freeAfterEvent = qfalse;
+	ent->e_TouchFunc = NULL;
+	//ent->s.loopSound = G_SoundIndex( "sound/weapons/noghri/smoke.wav" );
+	//G_SoundOnEnt( ent, CHAN_AUTO, "sound/weapons/noghri/smoke.wav" );
+
+	G_SetOrigin( ent, ent->currentOrigin );
+	ent->e_ThinkFunc = thinkF_NoghriGasCloudThink;
+	ent->nextthink = level.time + FRAMETIME;
+
+	vec3_t	up = {0,0,1};
+	G_PlayEffect( "noghri_stick/gas_cloud", ent->currentOrigin, up );
+
+	ent->fx_time = level.time + 250;
+	ent->s.time = level.time;
+}
+
+extern void WP_SaberBlock( gentity_t *saber, vec3_t hitloc, qboolean missleBlock );
+extern void laserTrapStick( gentity_t *ent, vec3_t endpos, vec3_t normal );
+extern qboolean W_AccuracyLoggableWeapon( int weapon, qboolean alt_fire, int mod );
+void G_MissileImpacted( gentity_t *ent, gentity_t *other, vec3_t impactPos, vec3_t normal, int hitLoc=HL_NONE )
+{
+	// impact damage
+	if ( other->takedamage ) 
+	{
+		// FIXME: wrong damage direction?
+		if ( ent->damage ) 
+		{
+			vec3_t	velocity;
+
+			EvaluateTrajectoryDelta( &ent->s.pos, level.time, velocity );
+			if ( VectorLength( velocity ) == 0 ) 
+			{
+				velocity[2] = 1;	// stepped on a grenade
+			}
+
+			int damage = ent->damage;
+
+			if( other->client )
+			{
+				class_t	npc_class = other->client->NPC_class;
+
+				// If we are a robot and we aren't currently doing the full body electricity...
+				if ( npc_class == CLASS_SEEKER || npc_class == CLASS_PROBE || npc_class == CLASS_MOUSE ||
+					   npc_class == CLASS_GONK || npc_class == CLASS_R2D2 || npc_class == CLASS_R5D2 || npc_class == CLASS_REMOTE ||
+					   npc_class == CLASS_MARK1 || npc_class == CLASS_MARK2 || //npc_class == CLASS_PROTOCOL ||//no protocol, looks odd
+					   npc_class == CLASS_INTERROGATOR || npc_class == CLASS_ATST || npc_class == CLASS_SENTRY )
+				{
+					// special droid only behaviors
+					if ( other->client->ps.powerups[PW_SHOCKED] < level.time + 100 )
+					{
+						// ... do the effect for a split second for some more feedback
+						other->s.powerups |= ( 1 << PW_SHOCKED );
+						other->client->ps.powerups[PW_SHOCKED] = level.time + 450;
+					}
+					//FIXME: throw some sparks off droids,too
+				}
+			}
+
+			G_Damage( other, ent, ent->owner, velocity,
+					impactPos, damage, 
+					ent->dflags, ent->methodOfDeath, hitLoc);
+
+			if ( ent->s.weapon == WP_DEMP2 )
+			{//a hit with demp2 decloaks saboteurs
+				if ( other && other->client && other->client->NPC_class == CLASS_SABOTEUR )
+				{//FIXME: make this disabled cloak hold for some amount of time?
+					Saboteur_Decloak( other, Q_irand( 3000, 10000 ) );
+					if ( ent->methodOfDeath == MOD_DEMP2_ALT )
+					{//direct hit with alt disabled cloak forever
+						if ( other->NPC )
+						{//permanently disable the saboteur's cloak
+							other->NPC->aiFlags &= ~NPCAI_SHIELDS;
+						}
+					}
+				}
+			}
+		}
+	}
+
+	// is it cheaper in bandwidth to just remove this ent and create a new
+	// one, rather than changing the missile into the explosion?
+	//G_FreeEntity(ent);
+	
+	if ( (other->takedamage && other->client ) || (ent->s.weapon == WP_FLECHETTE && other->contents&CONTENTS_LIGHTSABER) ) 
+	{
+		G_AddEvent( ent, EV_MISSILE_HIT, DirToByte( normal ) );
+		ent->s.otherEntityNum = other->s.number;
+	} 
+	else 
+	{
+		G_AddEvent( ent, EV_MISSILE_MISS, DirToByte( normal ) );
+		ent->s.otherEntityNum = other->s.number;
+	}
+
+	VectorCopy( normal, ent->pos1 );
+
+	if ( ent->owner )//&& ent->owner->s.number == 0 )
+	{
+		//Add the event
+		AddSoundEvent( ent->owner, ent->currentOrigin, 256, AEL_SUSPICIOUS, qfalse, qtrue );
+		AddSightEvent( ent->owner, ent->currentOrigin, 512, AEL_DISCOVERED, 75 );
+	}
+
+	ent->freeAfterEvent = qtrue;
+
+	// change over to a normal entity right at the point of impact
+	ent->s.eType = ET_GENERAL;
+
+	//SnapVectorTowards( trace->endpos, ent->s.pos.trBase );	// save net bandwidth
+	VectorCopy( impactPos, ent->s.pos.trBase );
+
+	G_SetOrigin( ent, impactPos );
+
+	// splash damage (doesn't apply to person directly hit)
+	if ( ent->splashDamage ) 
+	{
+		G_RadiusDamage( impactPos, ent->owner, ent->splashDamage, ent->splashRadius, 
+			other, ent->splashMethodOfDeath );
+	}
+
+	if ( ent->s.weapon == WP_NOGHRI_STICK )
+	{
+		G_SpawnNoghriGasCloud( ent );
+	}
+
+	gi.linkentity( ent );
+}
+
+//------------------------------------------------
+static void G_MissileAddAlerts( gentity_t *ent )
+{
+	//Add the event
+	if ( ent->s.weapon == WP_THERMAL && ((ent->delay-level.time) < 2000 || ent->s.pos.trType == TR_INTERPOLATE) )
+	{//a thermal about to explode or rolling
+		if ( (ent->delay-level.time) < 500 )
+		{//half a second before it explodes!
+			AddSoundEvent( ent->owner, ent->currentOrigin, ent->splashRadius*2, AEL_DANGER_GREAT, qfalse, qtrue );
+			AddSightEvent( ent->owner, ent->currentOrigin, ent->splashRadius*2, AEL_DANGER_GREAT, 20 );
+		}
+		else
+		{//2 seconds until it explodes or it's rolling
+			AddSoundEvent( ent->owner, ent->currentOrigin, ent->splashRadius*2, AEL_DANGER, qfalse, qtrue );
+			AddSightEvent( ent->owner, ent->currentOrigin, ent->splashRadius*2, AEL_DANGER, 20 );
+		}
+	}
+	else
+	{
+		AddSoundEvent( ent->owner, ent->currentOrigin, 128, AEL_DISCOVERED );
+		AddSightEvent( ent->owner, ent->currentOrigin, 256, AEL_DISCOVERED, 40 );
+	}
+}
+
+//------------------------------------------------------
+void G_MissileImpact( gentity_t *ent, trace_t *trace, int hitLoc=HL_NONE ) 
+{
+	gentity_t		*other;
+	vec3_t			diff;
+
+	other = &g_entities[trace->entityNum];
+	if ( other == ent )
+	{
+		assert(0&&"missile hit itself!!!");
+		return;
+	}
+	if ( trace->plane.normal[0] == 0.0f &&
+		 trace->plane.normal[1] == 0.0f &&
+		 trace->plane.normal[2] == 0.0f
+		)
+	{//model moved into missile in flight probably...
+		trace->plane.normal[0] = -ent->s.pos.trDelta[0];
+		trace->plane.normal[1] = -ent->s.pos.trDelta[1];
+		trace->plane.normal[2] = -ent->s.pos.trDelta[2];
+		VectorNormalize(trace->plane.normal);
+	}
+
+	if ( ent->owner && (other->takedamage||other->client) )
+	{
+		if ( !ent->lastEnemy || ent->lastEnemy == ent->owner )
+		{//a missile that was not reflected or, if so, still is owned by original owner
+			if( LogAccuracyHit( other, ent->owner ) ) 
+			{
+				ent->owner->client->ps.persistant[PERS_ACCURACY_HITS]++;
+			}
+			if ( ent->owner->client && !ent->owner->s.number )
+			{
+				if ( W_AccuracyLoggableWeapon( ent->s.weapon, qfalse, ent->methodOfDeath ) )
+				{
+					ent->owner->client->sess.missionStats.hits++;
+				}
+			}
+		}
+	}
+	// check for bounce
+	//OR: if the surfaceParm is has a reflect property (magnetic shielding) and the missile isn't an exploding missile
+	qboolean bounce = !!( (!other->takedamage && (ent->s.eFlags&(EF_BOUNCE|EF_BOUNCE_HALF))) || (((trace->surfaceFlags&SURF_FORCEFIELD)||(other->flags&FL_SHIELDED))&&!ent->splashDamage&&!ent->splashRadius&&ent->s.weapon != WP_NOGHRI_STICK) );
+
+	if ( ent->dflags & DAMAGE_HEAVY_WEAP_CLASS )
+	{
+		// heavy class missiles generally never bounce.
+		bounce = qfalse;
+	}
+
+	if ( other->flags & (FL_DMG_BY_HEAVY_WEAP_ONLY | FL_SHIELDED ))
+	{
+		// Dumb assumption, but I guess we must be a shielded ion_cannon??  We should probably verify
+		// if it's an ion_cannon that's Heavy Weapon only, we don't want to make it shielded do we...?
+		if ( (!strcmp( "misc_ion_cannon", other->classname )) && (other->flags & FL_SHIELDED) )
+		{
+			// Anything will bounce off of us.
+			bounce = qtrue;
+
+			// Not exactly the debounce time, but rather the impact time for the shield effect...play effect for 1 second
+			other->painDebounceTime = level.time + 1000;
+		}
+	}
+
+	if ( ent->s.weapon == WP_DEMP2 )
+	{
+		// demp2 shots can never bounce
+		bounce = qfalse;
+
+		// in fact, alt-charge shots will not call the regular impact functions
+		if ( ent->alt_fire )
+		{
+			// detonate at the trace end
+			VectorCopy( trace->endpos, ent->currentOrigin );
+			VectorCopy( trace->plane.normal, ent->pos1 );
+			DEMP2_AltDetonate( ent );
+			return;
+		}
+	}
+
+	if ( bounce ) 
+	{
+		// Check to see if there is a bounce count
+		if ( ent->bounceCount ) 
+		{
+			// decrement number of bounces and then see if it should be done bouncing
+			if ( !(--ent->bounceCount) ) {
+				// He (or she) will bounce no more (after this current bounce, that is).
+				ent->s.eFlags &= ~( EF_BOUNCE | EF_BOUNCE_HALF );
+			}
+		}
+
+		if ( other->NPC )
+		{
+			G_Damage( other, ent, ent->owner, ent->currentOrigin, ent->s.pos.trDelta, 0, DAMAGE_NO_DAMAGE, MOD_UNKNOWN );
+		}
+
+		G_BounceMissile( ent, trace );
+		
+		if ( ent->owner )//&& ent->owner->s.number == 0 ) 
+		{
+			G_MissileAddAlerts( ent );
+		}
+#ifdef _IMMERSION
+		G_MissileBounceEffect( ent, (other->contents & CONTENTS_LIGHTSABER && !other->owner->s.saberInFlight ? other->owner->s.number : -1), trace->endpos, trace->plane.normal, trace->entityNum==ENTITYNUM_WORLD );
+#else
+		G_MissileBounceEffect( ent, trace->endpos, trace->plane.normal, trace->entityNum==ENTITYNUM_WORLD );
+#endif // _IMMERSION
+
+		return;
+	}
+	
+	// I would glom onto the EF_BOUNCE code section above, but don't feel like risking breaking something else
+	if ( (!other->takedamage && ( ent->s.eFlags&(EF_BOUNCE_SHRAPNEL) ) ) 
+		|| ((trace->surfaceFlags&SURF_FORCEFIELD)&&!ent->splashDamage&&!ent->splashRadius) ) 
+	{
+		if ( !(other->contents&CONTENTS_LIGHTSABER)
+			|| g_spskill->integer <= 0//on easy, it reflects all shots
+			|| (g_spskill->integer == 1 && ent->s.weapon != WP_FLECHETTE && ent->s.weapon != WP_DEMP2 )//on medium it won't reflect flechette or demp shots
+			|| (g_spskill->integer >= 2 && ent->s.weapon != WP_FLECHETTE && ent->s.weapon != WP_DEMP2 && ent->s.weapon != WP_BOWCASTER && ent->s.weapon != WP_REPEATER )//on hard it won't reflect flechette, demp, repeater or bowcaster shots
+			)
+		{
+			G_BounceMissile( ent, trace );
+
+			if ( --ent->bounceCount < 0 )
+			{
+				ent->s.eFlags &= ~EF_BOUNCE_SHRAPNEL;
+			}
+#ifdef _IMMERSION
+		// might deflect flechette spam in bespin_platform.bsp
+		G_MissileBounceEffect( ent, (other->contents & CONTENTS_LIGHTSABER && !other->owner->s.saberInFlight ? other->owner->s.number : -1), trace->endpos, trace->plane.normal, trace->entityNum==ENTITYNUM_WORLD );
+#else
+			G_MissileBounceEffect( ent, trace->endpos, trace->plane.normal, trace->entityNum==ENTITYNUM_WORLD );
+#endif // _IMMERSION
+			return;
+		}
+	}
+
+	if ( (!other->takedamage || (other->client && other->health <= 0))
+		&& ent->s.weapon == WP_THERMAL 
+		&& !ent->alt_fire )
+	{//rolling thermal det - FIXME: make this an eFlag like bounce & stick!!!
+		//G_BounceRollMissile( ent, trace );
+		if ( ent->owner )//&& ent->owner->s.number == 0 ) 
+		{
+			G_MissileAddAlerts( ent );
+		}
+		//gi.linkentity( ent );
+		return;
+	}
+
+	// check for sticking
+	if ( ent->s.eFlags & EF_MISSILE_STICK ) 
+	{
+		if ( ent->owner )//&& ent->owner->s.number == 0 ) 
+		{
+			//Add the event
+			if ( ent->s.weapon == WP_TRIP_MINE )
+			{
+				AddSoundEvent( ent->owner, ent->currentOrigin, ent->splashRadius/2, AEL_DISCOVERED/*AEL_DANGER*/, qfalse, qtrue );
+				AddSightEvent( ent->owner, ent->currentOrigin, ent->splashRadius*2, AEL_DISCOVERED/*AEL_DANGER*/, 60 );
+				/*
+				AddSoundEvent( ent->owner, ent->currentOrigin, ent->splashRadius*2, AEL_DANGER, qfalse, qtrue );
+				AddSightEvent( ent->owner, ent->currentOrigin, ent->splashRadius*2, AEL_DANGER, 60 );
+				*/
+			}
+			else
+			{
+				AddSoundEvent( ent->owner, ent->currentOrigin, 128, AEL_DISCOVERED, qfalse, qtrue );
+				AddSightEvent( ent->owner, ent->currentOrigin, 256, AEL_DISCOVERED, 10 );
+			}
+		}
+
+		G_MissileStick( ent, other, trace );
+		return;
+	}
+
+	// check for hitting a lightsaber
+	if ( other->contents & CONTENTS_LIGHTSABER )
+	{
+		if ( other->owner && !other->owner->s.number && other->owner->client )
+		{
+			other->owner->client->sess.missionStats.saberBlocksCnt++;
+		}
+		if ( ( g_spskill->integer <= 0//on easy, it reflects all shots
+				|| (g_spskill->integer == 1 && ent->s.weapon != WP_FLECHETTE && ent->s.weapon != WP_DEMP2 )//on medium it won't reflect flechette or demp shots
+				|| (g_spskill->integer >= 2 && ent->s.weapon != WP_FLECHETTE && ent->s.weapon != WP_DEMP2 && ent->s.weapon != WP_BOWCASTER && ent->s.weapon != WP_REPEATER )//on hard it won't reflect flechette, demp, repeater or bowcaster shots
+			 )
+			&& (!ent->splashDamage || !ent->splashRadius) //this would be cool, though, to "bat" the thermal det away...
+			&& ent->s.weapon != WP_NOGHRI_STICK )//gas bomb, don't reflect
+		{	
+			//FIXME: take other's owner's FP_SABER_DEFENSE into account here somehow?
+			if ( !other->owner || !other->owner->client || other->owner->client->ps.saberInFlight || InFront( ent->currentOrigin, other->owner->currentOrigin, other->owner->client->ps.viewangles, SABER_REFLECT_MISSILE_CONE ) )//other->owner->s.number != 0 || 
+			{//Jedi cannot block shots from behind!
+				int blockChance = 0;
+				switch ( other->owner->client->ps.forcePowerLevel[FP_SABER_DEFENSE] )
+				{//level 1 reflects 50% of the time, level 2 reflects 75% of the time
+				case FORCE_LEVEL_3:
+					blockChance = 10;
+					break;
+				case FORCE_LEVEL_2:
+					blockChance = 3;
+					break;
+				case FORCE_LEVEL_1:
+					blockChance = 1;
+					break;
+				}
+				if ( blockChance && (other->owner->client->ps.forcePowersActive&(1<<FP_SPEED)) )
+				{//in in force speed, better chance of deflecting the shot
+					blockChance += other->owner->client->ps.forcePowerLevel[FP_SPEED]*2;
+				}
+				if ( Q_irand( 0, blockChance ) )
+				{
+					VectorSubtract(ent->currentOrigin, other->currentOrigin, diff);
+					VectorNormalize(diff);
+					G_ReflectMissile( other, ent, diff);
+					//WP_SaberBlock( other, ent->currentOrigin, qtrue );
+					if ( other->owner && other->owner->client )
+					{
+						other->owner->client->ps.saberEventFlags |= SEF_DEFLECTED;
+					}
+					//do the effect
+					VectorCopy( ent->s.pos.trDelta, diff );
+					VectorNormalize( diff );
+#ifdef _IMMERSION
+					G_MissileReflectEffect( ent, other->owner->s.number, trace->endpos, trace->plane.normal );
+#else
+					G_MissileReflectEffect( ent, trace->endpos, trace->plane.normal );
+#endif // _IMMERSION
+					return;
+				}
+			}
+		}
+		else
+		{//still do the bounce effect
+#ifdef _IMMERSION
+			G_MissileReflectEffect( ent, other->owner->s.number, trace->endpos, trace->plane.normal );
+#else
+			G_MissileReflectEffect( ent, trace->endpos, trace->plane.normal );
+#endif // _IMMERSION
+		}
+	}
+
+	G_MissileImpacted( ent, other, trace->endpos, trace->plane.normal, hitLoc );
+}
+
+/*
+================
+G_ExplodeMissile
+
+Explode a missile without an impact
+================
+*/
+void G_ExplodeMissile( gentity_t *ent ) 
+{
+	vec3_t		dir;
+	vec3_t		origin;
+
+	EvaluateTrajectory( &ent->s.pos, level.time, origin );
+	SnapVector( origin );
+	G_SetOrigin( ent, origin );
+
+	// we don't have a valid direction, so just point straight up
+	dir[0] = dir[1] = 0;
+	dir[2] = 1;
+
+	if ( ent->owner )//&& ent->owner->s.number == 0 )
+	{
+		//Add the event
+		AddSoundEvent( ent->owner, ent->currentOrigin, 256, AEL_DISCOVERED, qfalse, qtrue );//FIXME: are we on ground or not?
+		AddSightEvent( ent->owner, ent->currentOrigin, 512, AEL_DISCOVERED, 100 );
+	}
+/*	ent->s.eType = ET_GENERAL;
+	G_AddEvent( ent, EV_MISSILE_MISS, DirToByte( dir ) );
+
+	ent->freeAfterEvent = qtrue;*/
+
+	// splash damage
+	if ( ent->splashDamage ) 
+	{
+		G_RadiusDamage( ent->currentOrigin, ent->owner, ent->splashDamage, ent->splashRadius, NULL
+			, ent->splashMethodOfDeath );
+	}
+
+	G_FreeEntity(ent);
+	//gi.linkentity( ent );
+}
+
+
+void G_RunStuckMissile( gentity_t *ent )
+{
+	if ( ent->takedamage )
+	{
+		if ( ent->s.groundEntityNum >= 0 && ent->s.groundEntityNum < ENTITYNUM_WORLD )
+		{
+			gentity_t *other = &g_entities[ent->s.groundEntityNum];
+
+			if ( (!VectorCompare( vec3_origin, other->s.pos.trDelta ) && other->s.pos.trType != TR_STATIONARY) || 
+				(!VectorCompare( vec3_origin, other->s.apos.trDelta ) && other->s.apos.trType != TR_STATIONARY) )
+			{//thing I stuck to is moving or rotating now, kill me
+				G_Damage( ent, other, other, NULL, NULL, 99999, 0, MOD_CRUSH );
+				return;
+			}
+		}
+	}
+	// check think function
+	G_RunThink( ent );
+}
+
+/*
+==================
+
+G_GroundTrace
+
+==================
+*/
+int G_GroundTrace( gentity_t *ent, pml_t *pPml )
+{
+	vec3_t		point;
+	trace_t		trace;
+
+	point[0] = ent->currentOrigin[0];
+	point[1] = ent->currentOrigin[1];
+	point[2] = ent->currentOrigin[2] - 0.25;
+
+	gi.trace ( &trace, ent->currentOrigin, ent->mins, ent->maxs, point, ent->s.number, ent->clipmask );
+	pPml->groundTrace = trace;
+
+	// do something corrective if the trace starts in a solid...
+	if ( trace.allsolid ) 
+	{
+		pPml->groundPlane = qfalse;
+		pPml->walking = qfalse;
+		return ENTITYNUM_NONE;
+	}
+
+	// if the trace didn't hit anything, we are in free fall
+	if ( trace.fraction == 1.0 ) 
+	{
+		pPml->groundPlane = qfalse;
+		pPml->walking = qfalse;
+		return ENTITYNUM_NONE;
+	}
+
+	// check if getting thrown off the ground
+	if ( ent->s.pos.trDelta[2] > 0 && DotProduct( ent->s.pos.trDelta, trace.plane.normal ) > 10 ) 
+	{
+		pPml->groundPlane = qfalse;
+		pPml->walking = qfalse;
+		return ENTITYNUM_NONE;
+	}
+	
+	// slopes that are too steep will not be considered onground
+	if ( trace.plane.normal[2] < MIN_WALK_NORMAL ) 
+	{
+		pPml->groundPlane = qtrue;
+		pPml->walking = qfalse;
+		return ENTITYNUM_NONE;
+	}
+
+	pPml->groundPlane = qtrue;
+	pPml->walking = qtrue;
+
+	/*
+	if ( ent->s.groundEntityNum == ENTITYNUM_NONE ) 
+	{
+		// just hit the ground
+	}
+	*/
+
+	return trace.entityNum;
+}
+
+void G_ClipVelocity( vec3_t in, vec3_t normal, vec3_t out, float overbounce ) 
+{
+	float	backoff;
+	float	change;
+	int		i;
+	
+	backoff = DotProduct (in, normal);
+	
+	if ( backoff < 0 ) {
+		backoff *= overbounce;
+	} else {
+		backoff /= overbounce;
+	}
+
+	for ( i=0 ; i<3 ; i++ ) 
+	{
+		change = normal[i]*backoff;
+		out[i] = in[i] - change;
+	}
+}
+/*
+==================
+
+G_RollMissile
+
+reworking the rolling object code, 
+still needs to stop bobbling up & down, 
+need to get roll angles right, 
+and need to maybe make the transfer of velocity happen on impacts?  
+Also need bounce sound for bounces off a floor.  
+Also need to not bounce as much off of enemies
+Also gets stuck inside thrower if looking down when thrown
+
+==================
+*/
+#define	MAX_CLIP_PLANES	5
+#define	BUMPCLIP		1.5f
+void G_RollMissile( gentity_t *ent )
+{
+	int			bumpcount, numbumps;
+	vec3_t		dir;
+	float		d;
+	int			numplanes;
+	vec3_t		planes[MAX_CLIP_PLANES];
+	vec3_t		primal_velocity;
+	vec3_t		clipVelocity;
+	int			i, j, k;
+	trace_t	trace;
+	vec3_t		end;
+	float		time_left;
+	float		into;
+	vec3_t		endVelocity;
+	vec3_t		endClipVelocity;
+	pml_t		objPML;
+	float		bounceAmt = BUMPCLIP;
+	gentity_t	*hitEnt = NULL;
+
+	memset( &objPML, 0, sizeof( objPML ) );
+	
+	G_GroundTrace( ent, &objPML );
+
+	objPML.frametime = (level.time - level.previousTime)*0.001;
+	
+	numbumps = 4;
+
+	VectorCopy ( ent->s.pos.trDelta, primal_velocity );
+
+	VectorCopy( ent->s.pos.trDelta, endVelocity );
+	endVelocity[2] -= g_gravity->value * objPML.frametime;
+	ent->s.pos.trDelta[2] = ( ent->s.pos.trDelta[2] + endVelocity[2] ) * 0.5;
+	primal_velocity[2] = endVelocity[2];
+	if ( objPML.groundPlane ) 
+	{//FIXME: never happens!
+		// slide along the ground plane
+		G_ClipVelocity( ent->s.pos.trDelta, objPML.groundTrace.plane.normal, ent->s.pos.trDelta, BUMPCLIP ); 
+		VectorScale( ent->s.pos.trDelta, 0.9f, ent->s.pos.trDelta );
+	}
+
+	time_left = objPML.frametime;
+
+	// never turn against the ground plane
+	if ( objPML.groundPlane ) 
+	{
+		numplanes = 1;
+		VectorCopy( objPML.groundTrace.plane.normal, planes[0] );
+	} 
+	else 
+	{
+		numplanes = 0;
+	}
+
+	// never turn against original velocity
+	/*
+	VectorNormalize2( ent->s.pos.trDelta, planes[numplanes] );
+	numplanes++;
+	*/
+
+	for ( bumpcount = 0; bumpcount < numbumps; bumpcount++ ) 
+	{
+		// calculate position we are trying to move to
+		VectorMA( ent->currentOrigin, time_left, ent->s.pos.trDelta, end );
+
+		// see if we can make it there
+		gi.trace ( &trace, ent->currentOrigin, ent->mins, ent->maxs, end, ent->s.number, ent->clipmask, G2_RETURNONHIT, 10 );
+
+		//TEMP HACK:
+		//had to move this up above the trace.allsolid check now that for some reason ghoul2 impacts tell me I'm allsolid?!
+		//this needs to be fixed, really
+		if ( trace.entityNum < ENTITYNUM_WORLD )
+		{//hit another ent
+			hitEnt = &g_entities[trace.entityNum];
+			if ( hitEnt && (hitEnt->takedamage || (hitEnt->contents&CONTENTS_LIGHTSABER) ) )
+			{
+				G_MissileImpact( ent, &trace );
+				if ( ent->s.eType == ET_GENERAL )
+				{//exploded
+					return;
+				}
+			}
+		}
+
+		if ( trace.allsolid )
+		{
+			// entity is completely trapped in another solid
+			//FIXME: this happens a lot now when we hit a G2 ent... WTF?
+			ent->s.pos.trDelta[2] = 0;	// don't build up falling damage, but allow sideways acceleration
+			return;// qtrue;
+		}
+
+		if ( trace.fraction > 0 ) 
+		{
+			// actually covered some distance
+			VectorCopy( trace.endpos, ent->currentOrigin );
+		}
+
+		if ( trace.fraction == 1 ) 
+		{
+			 break;		// moved the entire distance
+		}
+
+		//pm->ps->pm_flags |= PMF_BUMPED;
+
+		// save entity for contact
+		//PM_AddTouchEnt( trace.entityNum );
+
+		//Hit it
+		/*
+		if ( PM_ClientImpact( trace.entityNum, qtrue ) )
+		{
+			continue;
+		}
+		*/
+
+		time_left -= time_left * trace.fraction;
+
+		if ( numplanes >= MAX_CLIP_PLANES ) 
+		{
+			// this shouldn't really happen
+			VectorClear( ent->s.pos.trDelta );
+			return;// qtrue;
+		}
+
+		//
+		// if this is the same plane we hit before, nudge velocity
+		// out along it, which fixes some epsilon issues with
+		// non-axial planes
+		//
+		for ( i = 0 ; i < numplanes ; i++ ) 
+		{
+			if ( DotProduct( trace.plane.normal, planes[i] ) > 0.99 ) 
+			{
+				VectorAdd( trace.plane.normal, ent->s.pos.trDelta, ent->s.pos.trDelta );
+				break;
+			}
+		}
+		if ( i < numplanes ) 
+		{
+			continue;
+		}
+		VectorCopy( trace.plane.normal, planes[numplanes] );
+		numplanes++;
+
+		//
+		// modify velocity so it parallels all of the clip planes
+		//
+		if ( &g_entities[trace.entityNum] != NULL && g_entities[trace.entityNum].client ) 
+		{//hit a person, bounce off much less
+			bounceAmt = OVERCLIP;
+		}
+		else
+		{
+			bounceAmt = BUMPCLIP;
+		}
+
+		// find a plane that it enters
+		for ( i = 0 ; i < numplanes ; i++ ) 
+		{
+			into = DotProduct( ent->s.pos.trDelta, planes[i] );
+			if ( into >= 0.1 ) 
+			{
+				continue;		// move doesn't interact with the plane
+			}
+
+			// see how hard we are hitting things
+			if ( -into > pml.impactSpeed ) 
+			{
+				pml.impactSpeed = -into;
+			}
+
+			// slide along the plane
+			G_ClipVelocity( ent->s.pos.trDelta, planes[i], clipVelocity, bounceAmt );
+
+			// slide along the plane
+			G_ClipVelocity( endVelocity, planes[i], endClipVelocity, bounceAmt );
+
+			// see if there is a second plane that the new move enters
+			for ( j = 0 ; j < numplanes ; j++ ) 
+			{
+				if ( j == i ) 
+				{
+					continue;
+				}
+				if ( DotProduct( clipVelocity, planes[j] ) >= 0.1 ) 
+				{
+					continue;		// move doesn't interact with the plane
+				}
+
+				// try clipping the move to the plane
+				G_ClipVelocity( clipVelocity, planes[j], clipVelocity, bounceAmt );
+				G_ClipVelocity( endClipVelocity, planes[j], endClipVelocity, bounceAmt );
+
+				// see if it goes back into the first clip plane
+				if ( DotProduct( clipVelocity, planes[i] ) >= 0 ) 
+				{
+					continue;
+				}
+
+				// slide the original velocity along the crease
+				CrossProduct (planes[i], planes[j], dir);
+				VectorNormalize( dir );
+				d = DotProduct( dir, ent->s.pos.trDelta );
+				VectorScale( dir, d, clipVelocity );
+
+				CrossProduct (planes[i], planes[j], dir);
+				VectorNormalize( dir );
+				d = DotProduct( dir, endVelocity );
+				VectorScale( dir, d, endClipVelocity );
+
+				// see if there is a third plane the the new move enters
+				for ( k = 0 ; k < numplanes ; k++ ) 
+				{
+					if ( k == i || k == j ) 
+					{
+						continue;
+					}
+					if ( DotProduct( clipVelocity, planes[k] ) >= 0.1 ) 
+					{
+						continue;		// move doesn't interact with the plane
+					}
+
+					// stop dead at a triple plane interaction
+					VectorClear( ent->s.pos.trDelta );
+					return;// qtrue;
+				}
+			}
+
+			// if we have fixed all interactions, try another move
+			VectorCopy( clipVelocity, ent->s.pos.trDelta );
+			VectorCopy( endClipVelocity, endVelocity );
+			break;
+		}
+		VectorScale( endVelocity, 0.975f, endVelocity );
+	}
+
+	VectorCopy( endVelocity, ent->s.pos.trDelta );
+
+	// don't change velocity if in a timer (FIXME: is this correct?)
+	/*
+	if ( pm->ps->pm_time ) 
+	{
+		VectorCopy( primal_velocity, ent->s.pos.trDelta );
+	}
+	*/
+
+	return;// ( bumpcount != 0 );
+}
+/*
+================
+G_RunMissile
+
+================
+*/
+void G_MoverTouchPushTriggers( gentity_t *ent, vec3_t oldOrg );
+void G_RunMissile( gentity_t *ent ) 
+{
+	vec3_t		oldOrg;
+	trace_t		tr;
+	int			trHitLoc=HL_NONE;
+
+	if ( (ent->s.eFlags&EF_HELD_BY_SAND_CREATURE) )
+	{//in a sand creature's mouth
+		if ( ent->activator )
+		{
+			mdxaBone_t	boltMatrix;
+			// Getting the bolt here
+			//in hand
+			vec3_t scAngles = {0};
+			scAngles[YAW] = ent->activator->currentAngles[YAW];
+			gi.G2API_GetBoltMatrix( ent->activator->ghoul2, ent->activator->playerModel, ent->activator->gutBolt, 
+					&boltMatrix, scAngles, ent->activator->currentOrigin, (cg.time?cg.time:level.time),
+					NULL, ent->activator->s.modelScale );
+			// Storing ent position, bolt position, and bolt axis
+			gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, ent->currentOrigin );
+			G_SetOrigin( ent, ent->currentOrigin );
+		}
+		// check think function
+		G_RunThink( ent );
+		return;
+	}
+
+	VectorCopy( ent->currentOrigin, oldOrg );
+
+	// get current position
+	if ( ent->s.pos.trType == TR_INTERPOLATE )
+	{//rolling missile?
+		//FIXME: WTF?!!  Sticks to stick missiles?
+		//FIXME: they stick inside the player
+		G_RollMissile( ent );
+		if ( ent->s.eType != ET_GENERAL )
+		{//didn't explode
+			VectorCopy( ent->currentOrigin, ent->s.pos.trBase );
+			gi.trace( &tr, oldOrg, ent->mins, ent->maxs, ent->currentOrigin, ent->s.number, ent->clipmask, G2_RETURNONHIT, 10 );
+			if ( VectorCompare( ent->s.pos.trDelta, vec3_origin ) )
+			{
+				//VectorCopy( ent->currentAngles, ent->s.apos.trBase );
+				VectorClear( ent->s.apos.trDelta );
+			}
+			else
+			{
+				vec3_t	ang, fwdDir, rtDir;
+				float	speed;
+				
+				ent->s.apos.trType = TR_INTERPOLATE;
+				VectorSet( ang, 0, ent->s.apos.trBase[1], 0 );
+				AngleVectors( ang, fwdDir, rtDir, NULL );
+				speed = VectorLength( ent->s.pos.trDelta )*4;
+
+				//HMM, this works along an axis-aligned dir, but not along diagonals
+				//This is because when roll gets to 90, pitch becomes yaw, and vice-versa
+				//Maybe need to just set the angles directly?
+				ent->s.apos.trDelta[0] = DotProduct( fwdDir, ent->s.pos.trDelta );
+				ent->s.apos.trDelta[1] = 0;//never spin!
+				ent->s.apos.trDelta[2] = DotProduct( rtDir, ent->s.pos.trDelta );
+
+				VectorNormalize( ent->s.apos.trDelta );
+				VectorScale( ent->s.apos.trDelta, speed, ent->s.apos.trDelta );
+
+				ent->s.apos.trTime = level.previousTime;
+			}
+		}
+	}
+	else
+	{
+		vec3_t		origin; 
+		EvaluateTrajectory( &ent->s.pos, level.time, origin );
+		// trace a line from the previous position to the current position,
+		// ignoring interactions with the missile owner
+		gi.trace( &tr, ent->currentOrigin, ent->mins, ent->maxs, origin, 
+			ent->owner ? ent->owner->s.number : ent->s.number, ent->clipmask, G2_COLLIDE, 10 );
+		
+		if ( tr.entityNum != ENTITYNUM_NONE )
+		{
+			gentity_t *other = &g_entities[tr.entityNum];
+			// check for hitting a lightsaber
+			if ( other->contents & CONTENTS_LIGHTSABER )
+			{//hit a lightsaber bbox
+				if ( other->owner 
+					&& other->owner->client 
+					&& !other->owner->client->ps.saberInFlight 
+					&& ( Q_irand( 0, (other->owner->client->ps.forcePowerLevel[FP_SABER_DEFENSE]*other->owner->client->ps.forcePowerLevel[FP_SABER_DEFENSE]) ) == 0 
+						|| !InFront( ent->currentOrigin, other->owner->currentOrigin, other->owner->client->ps.viewangles, SABER_REFLECT_MISSILE_CONE ) ) )//other->owner->s.number == 0 &&
+				{//Jedi cannot block shots from behind!
+					//re-trace from here, ignoring the lightsaber
+					gi.trace( &tr, tr.endpos, ent->mins, ent->maxs, origin, tr.entityNum, ent->clipmask, G2_RETURNONHIT, 10 );
+				}
+			}
+		}
+
+		VectorCopy( tr.endpos, ent->currentOrigin );
+	}
+
+	// get current angles
+	VectorMA( ent->s.apos.trBase, (level.time - ent->s.apos.trTime) * 0.001, ent->s.apos.trDelta, ent->s.apos.trBase );
+
+	//FIXME: Rolling things hitting G2 polys is weird
+	///////////////////////////////////////////////////////
+//?	if ( tr.fraction != 1 ) 
+	{
+	// did we hit or go near a Ghoul2 model?
+//		qboolean hitModel = qfalse;
+		for (int i=0; i < MAX_G2_COLLISIONS; i++)
+		{
+			if (tr.G2CollisionMap[i].mEntityNum == -1)
+			{
+				break;
+			}
+
+			CCollisionRecord &coll = tr.G2CollisionMap[i];
+			gentity_t	*hitEnt = &g_entities[coll.mEntityNum];
+
+			// process collision records here...
+			// make sure we only do this once, not for all the entrance wounds we might generate
+			if ((coll.mFlags & G2_FRONTFACE)/* && !(hitModel)*/ && hitEnt->health)
+			{
+				if (trHitLoc==HL_NONE)
+				{
+					G_GetHitLocFromSurfName( &g_entities[coll.mEntityNum], gi.G2API_GetSurfaceName( &g_entities[coll.mEntityNum].ghoul2[coll.mModelIndex], coll.mSurfaceIndex ), &trHitLoc, coll.mCollisionPosition, NULL, NULL, ent->methodOfDeath );
+				}
+
+				break; // NOTE: the way this whole section was working, it would only get inside of this IF once anyway, might as well break out now
+			}
+		}
+	}
+/////////////////////////////////////////////////////////
+
+	if ( tr.startsolid ) 
+	{
+		tr.fraction = 0;
+	}
+
+	gi.linkentity( ent );
+
+	if ( ent->s.pos.trType == TR_STATIONARY && (ent->s.eFlags&EF_MISSILE_STICK) )
+	{//stuck missiles should check some special stuff
+		G_RunStuckMissile( ent );
+		return;
+	}
+
+	// check think function
+	G_RunThink( ent );
+
+	if ( ent->s.eType != ET_MISSILE ) 
+	{
+		return;		// exploded
+	}
+
+	if ( ent->mass )
+	{
+		G_MoverTouchPushTriggers( ent, oldOrg );
+	}
+	/*
+	if ( !(ent->s.eFlags & EF_TELEPORT_BIT) )
+	{
+		G_MoverTouchTeleportTriggers( ent, oldOrg );
+		if ( ent->s.eFlags & EF_TELEPORT_BIT )
+		{//was teleported
+			return;
+		}
+	}
+	else
+	{
+		ent->s.eFlags &= ~EF_TELEPORT_BIT;
+	}
+	*/
+
+	AddSightEvent( ent->owner, ent->currentOrigin, 512, AEL_DISCOVERED, 75 );//wakes them up when see a shot passes in front of them
+	if ( !Q_irand( 0, 10 ) )
+	{//not so often...
+		if ( ent->splashDamage && ent->splashRadius )
+		{//I'm an exploder, let people around me know danger is coming
+			if ( ent->s.weapon == WP_TRIP_MINE )
+			{//???
+			}
+			else 
+			{
+				if ( ent->s.weapon == WP_ROCKET_LAUNCHER && ent->e_ThinkFunc == thinkF_rocketThink )
+				{//homing rocket- run like hell!
+					AddSightEvent( ent->owner, ent->currentOrigin, ent->splashRadius, AEL_DANGER_GREAT, 50 );
+				}
+				else
+				{
+					AddSightEvent( ent->owner, ent->currentOrigin, ent->splashRadius, AEL_DANGER, 50 );
+				}
+				AddSoundEvent( ent->owner, ent->currentOrigin, ent->splashRadius, AEL_DANGER );
+			}
+		}
+		else
+		{//makes them run from near misses
+			AddSightEvent( ent->owner, ent->currentOrigin, 48, AEL_DANGER, 50 );
+		}
+	}
+
+	if ( tr.fraction == 1 ) 
+	{
+		if ( ent->s.weapon == WP_THERMAL && ent->s.pos.trType == TR_INTERPOLATE )
+		{//a rolling thermal that didn't hit anything
+			G_MissileAddAlerts( ent );
+		}
+		return;
+	}
+
+	// never explode or bounce on sky
+	if ( tr.surfaceFlags & SURF_NOIMPACT ) 
+	{
+		G_FreeEntity( ent );
+		return;
+	}
+
+	G_MissileImpact( ent, &tr, trHitLoc );
+}
\ No newline at end of file
diff --git a/code/game/g_mover.cpp b/code/game/g_mover.cpp
new file mode 100644
index 0000000..16cd892
--- /dev/null
+++ b/code/game/g_mover.cpp
@@ -0,0 +1,2657 @@
+// leave this line at the top for all g_xxxx.cpp files...
+#include "g_headers.h"
+
+#include "g_functions.h"
+#include "objectives.h"
+
+#include "../Icarus/IcarusInterface.h"
+
+
+int	BMS_START = 0;
+int	BMS_MID = 1;
+int	BMS_END = 2;
+
+extern void G_SetEnemy( gentity_t *self, gentity_t *enemy );
+void CalcTeamDoorCenter ( gentity_t *ent, vec3_t center );
+void InitMover( gentity_t *ent ) ;
+
+/*
+===============================================================================
+
+PUSHMOVE
+
+===============================================================================
+*/
+
+void MatchTeam( gentity_t *teamLeader, int moverState, int time );
+extern qboolean G_BoundsOverlap(const vec3_t mins1, const vec3_t maxs1, const vec3_t mins2, const vec3_t maxs2);
+
+typedef struct {
+	gentity_t	*ent;
+	vec3_t	origin;
+	vec3_t	angles;
+	float	deltayaw;
+} pushed_t;
+pushed_t	pushed[MAX_GENTITIES], *pushed_p;
+
+
+/*
+-------------------------
+G_SetLoopSound
+-------------------------
+*/
+
+void G_PlayDoorLoopSound( gentity_t *ent )
+{
+	if ( VALIDSTRING( ent->soundSet ) == false )
+		return;
+
+	sfxHandle_t	sfx = CAS_GetBModelSound( ent->soundSet, BMS_MID );
+
+	if ( sfx == -1 )
+	{
+		ent->s.loopSound = 0;
+		return;
+	}
+
+	ent->s.loopSound = sfx;
+}
+
+/*
+-------------------------
+G_PlayDoorSound
+-------------------------
+*/
+
+void G_PlayDoorSound( gentity_t *ent, int type )
+{
+	if ( VALIDSTRING( ent->soundSet ) == false )
+		return;
+
+	sfxHandle_t	sfx = CAS_GetBModelSound( ent->soundSet, type );
+
+	if ( sfx == -1 )
+		return;
+
+	vec3_t	doorcenter;
+	CalcTeamDoorCenter( ent, doorcenter );
+	if ( ent->activator && ent->activator->client && ent->activator->client->playerTeam == TEAM_PLAYER )
+	{
+		AddSoundEvent( ent->activator, doorcenter, 128, AEL_MINOR, qfalse, qtrue );
+	}
+
+	G_AddEvent( ent, EV_BMODEL_SOUND, sfx );
+}
+
+/*
+============
+G_TestEntityPosition
+
+============
+*/
+gentity_t	*G_TestEntityPosition( gentity_t *ent ) {
+	trace_t	tr;
+	int		mask;
+
+	if ( (ent->client && ent->health <= 0) || !ent->clipmask )
+	{//corpse or something with no clipmask
+		mask = MASK_SOLID;
+	} 
+	else 
+	{
+		mask = ent->clipmask;
+	}
+	if ( ent->client ) 
+	{
+		gi.trace( &tr, ent->client->ps.origin, ent->mins, ent->maxs, ent->client->ps.origin, ent->s.number, mask );
+	} 
+	else 
+	{
+		if ( ent->s.eFlags & EF_MISSILE_STICK )//Arggh, this is dumb...but when it used the bbox, it was pretty much always in solid when it is riding something..which is wrong..so I changed it to basically be a point contents check
+		{
+			gi.trace( &tr, ent->s.pos.trBase, vec3_origin, vec3_origin, ent->s.pos.trBase, ent->s.number, mask );
+		}
+		else
+		{
+			gi.trace( &tr, ent->s.pos.trBase, ent->mins, ent->maxs, ent->s.pos.trBase, ent->s.number, mask );
+		}
+	}
+	
+	if (tr.startsolid)
+		return &g_entities[ tr.entityNum ];
+		
+	return NULL;
+}
+
+
+/*
+==================
+G_TryPushingEntity
+
+Returns qfalse if the move is blocked
+==================
+*/
+extern qboolean G_OkayToRemoveCorpse( gentity_t *self );
+
+qboolean	G_TryPushingEntity( gentity_t *check, gentity_t *pusher, vec3_t move, vec3_t amove ) {
+	vec3_t		forward, right, up;
+	vec3_t		org, org2, move2;
+	gentity_t	*block;
+
+	/*
+	// EF_MOVER_STOP will just stop when contacting another entity
+	// instead of pushing it, but entities can still ride on top of it
+	if ( ( pusher->s.eFlags & EF_MOVER_STOP ) && 
+		check->s.groundEntityNum != pusher->s.number ) {
+		return qfalse;
+	}
+	*/
+
+	// save off the old position
+	if (pushed_p > &pushed[MAX_GENTITIES]) {
+		G_Error( "pushed_p > &pushed[MAX_GENTITIES]" );
+	}
+	pushed_p->ent = check;
+	VectorCopy (check->s.pos.trBase, pushed_p->origin);
+	VectorCopy (check->s.apos.trBase, pushed_p->angles);
+	if ( check->client ) {
+		pushed_p->deltayaw = check->client->ps.delta_angles[YAW];
+		VectorCopy (check->client->ps.origin, pushed_p->origin);
+	}
+	pushed_p++;
+
+	// we need this for pushing things later
+	VectorSubtract (vec3_origin, amove, org);
+	AngleVectors (org, forward, right, up);
+
+	// try moving the contacted entity 
+	VectorAdd (check->s.pos.trBase, move, check->s.pos.trBase);
+	if (check->client) {
+		// make sure the client's view rotates when on a rotating mover
+		check->client->ps.delta_angles[YAW] += ANGLE2SHORT(amove[YAW]);
+	}
+
+	// figure movement due to the pusher's amove
+	VectorSubtract (check->s.pos.trBase, pusher->currentOrigin, org);
+	org2[0] = DotProduct (org, forward);
+	org2[1] = -DotProduct (org, right);
+	org2[2] = DotProduct (org, up);
+	VectorSubtract (org2, org, move2);
+	VectorAdd (check->s.pos.trBase, move2, check->s.pos.trBase);
+	if ( check->client ) {
+		VectorAdd (check->client->ps.origin, move, check->client->ps.origin);
+		VectorAdd (check->client->ps.origin, move2, check->client->ps.origin);
+	}
+
+	// may have pushed them off an edge
+	if ( check->s.groundEntityNum != pusher->s.number ) {
+		check->s.groundEntityNum = ENTITYNUM_NONE;
+	}
+
+	/*
+	if ( check->client && check->health <= 0 && check->contents == CONTENTS_CORPSE )
+	{//sigh... allow pushing corpses into walls... problem is, they'll be stuck in there... maybe just remove them?
+		return qtrue;
+	}
+	*/
+	block = G_TestEntityPosition( check );
+	if (!block) {
+		// pushed ok
+		if ( check->client ) {
+			VectorCopy( check->client->ps.origin, check->currentOrigin );
+		} else {
+			VectorCopy( check->s.pos.trBase, check->currentOrigin );
+		}
+		gi.linkentity (check);
+		return qtrue;
+	}
+
+	// if it is ok to leave in the old position, do it
+	// this is only relevent for riding entities, not pushed
+	// Sliding trapdoors can cause this.
+	VectorCopy( (pushed_p-1)->origin, check->s.pos.trBase);
+	if ( check->client ) {
+		VectorCopy( (pushed_p-1)->origin, check->client->ps.origin);
+	}
+	VectorCopy( (pushed_p-1)->angles, check->s.apos.trBase );
+	block = G_TestEntityPosition (check);
+	if ( !block ) {
+		check->s.groundEntityNum = ENTITYNUM_NONE;
+		pushed_p--;
+		return qtrue;
+	}
+
+	// blocked
+	if ( pusher->damage )
+	{//Do damage
+		if ( (pusher->spawnflags&MOVER_CRUSHER)//a crusher
+ 			&& check->s.clientNum >= MAX_CLIENTS//not the player
+			&& check->client //NPC
+			&& check->health <= 0 //dead
+			&& G_OkayToRemoveCorpse( check ) )//okay to remove him
+		{//crusher stuck on a non->player corpse that does not have a key and is not running a script
+			G_FreeEntity( check );
+		}
+		else
+		{
+			G_Damage(check, pusher, pusher->activator, move, check->currentOrigin, pusher->damage, 0, MOD_CRUSH );
+		}
+	}
+
+	return qfalse;
+}
+
+
+/*
+============
+G_MoverPush
+
+Objects need to be moved back on a failed push,
+otherwise riders would continue to slide.
+If qfalse is returned, *obstacle will be the blocking entity
+============
+*/
+qboolean G_MoverPush( gentity_t *pusher, vec3_t move, vec3_t amove, gentity_t **obstacle ) {
+	qboolean	notMoving;
+	int			i, e;
+	int			listedEntities;
+	vec3_t		mins, maxs;
+	vec3_t		pusherMins, pusherMaxs, totalMins, totalMaxs;
+	pushed_t	*p;
+	gentity_t	*entityList[MAX_GENTITIES];
+	gentity_t	*check;
+
+	*obstacle = NULL;
+
+
+	if ( !pusher->bmodel )
+	{//misc_model_breakable
+		VectorAdd( pusher->currentOrigin, pusher->mins, pusherMins );
+		VectorAdd( pusher->currentOrigin, pusher->maxs, pusherMaxs );
+	}
+
+	// mins/maxs are the bounds at the destination
+	// totalMins / totalMaxs are the bounds for the entire move
+	if ( pusher->currentAngles[0] || pusher->currentAngles[1] || pusher->currentAngles[2]
+		|| amove[0] || amove[1] || amove[2] ) 
+	{
+		float		radius;
+
+		radius = RadiusFromBounds( pusher->mins, pusher->maxs );
+		for ( i = 0 ; i < 3 ; i++ ) 
+		{
+			mins[i] = pusher->currentOrigin[i] + move[i] - radius;
+			maxs[i] = pusher->currentOrigin[i] + move[i] + radius;
+			totalMins[i] = mins[i] - move[i];
+			totalMaxs[i] = maxs[i] - move[i];
+		}
+	} 
+	else 
+	{
+		for (i=0 ; i<3 ; i++) 
+		{
+			mins[i] = pusher->absmin[i] + move[i];
+			maxs[i] = pusher->absmax[i] + move[i];
+		}
+
+		VectorCopy( pusher->absmin, totalMins );
+		VectorCopy( pusher->absmax, totalMaxs );
+		for (i=0 ; i<3 ; i++) 
+		{
+			if ( move[i] > 0 ) 
+			{
+				totalMaxs[i] += move[i];
+			} 
+			else 
+			{
+				totalMins[i] += move[i];
+			}
+		}
+	}
+
+	// unlink the pusher so we don't get it in the entityList
+	gi.unlinkentity( pusher );
+
+	listedEntities = gi.EntitiesInBox( totalMins, totalMaxs, entityList, MAX_GENTITIES );
+
+	// move the pusher to it's final position
+	VectorAdd( pusher->currentOrigin, move, pusher->currentOrigin );
+	VectorAdd( pusher->currentAngles, amove, pusher->currentAngles );
+	gi.linkentity( pusher );
+
+	notMoving = (VectorCompare( vec3_origin, move )&&VectorCompare( vec3_origin, amove ));
+
+	// see if any solid entities are inside the final position
+	for ( e = 0 ; e < listedEntities ; e++ ) {
+		check = entityList[ e ];
+
+		if (( check->s.eFlags & EF_MISSILE_STICK ) && (notMoving || check->s.groundEntityNum < 0 || check->s.groundEntityNum >= ENTITYNUM_NONE ))
+		{
+			// special case hack for sticky things, destroy it if we aren't attached to the thing that is moving, but the moving thing is pushing us
+			G_Damage( check, pusher, pusher, NULL, NULL, 99999, 0, MOD_CRUSH );
+			continue;
+		}
+
+		// only push items and players
+		if ( check->s.eType != ET_ITEM ) 
+		{
+			//FIXME: however it allows items to be pushed through stuff, do same for corpses?
+			if ( check->s.eType != ET_PLAYER ) 
+			{
+				if ( !( check->s.eFlags & EF_MISSILE_STICK ))
+				{
+					// cannot be pushed by this mover
+					continue;
+				}
+			}
+			/*
+			else if ( check->health <= 0 )
+			{//For now, don't push on dead players
+				continue;
+			}
+			*/
+			else if ( !pusher->bmodel )
+			{
+				vec3_t	checkMins, checkMaxs;
+
+				VectorAdd( check->currentOrigin, check->mins, checkMins );
+				VectorAdd( check->currentOrigin, check->maxs, checkMaxs );
+
+				if ( G_BoundsOverlap( checkMins, checkMaxs, pusherMins, pusherMaxs ) )
+				{//They're inside me already, no push - FIXME: we're testing a moves spot, aren't we, so we could have just moved inside them?
+					continue;
+				}
+			}
+		}
+
+
+		if ( check->maxs[0] - check->mins[0] <= 0 &&
+				check->maxs[1] - check->mins[1] <= 0 &&
+				check->maxs[2] - check->mins[2] <= 0 )
+		{//no size, don't push
+			continue;
+		}
+
+		// if the entity is standing on the pusher, it will definitely be moved
+		if ( check->s.groundEntityNum != pusher->s.number ) {
+			// see if the ent needs to be tested
+			if ( check->absmin[0] >= maxs[0]
+			|| check->absmin[1] >= maxs[1]
+			|| check->absmin[2] >= maxs[2]
+			|| check->absmax[0] <= mins[0]
+			|| check->absmax[1] <= mins[1]
+			|| check->absmax[2] <= mins[2] ) {
+				continue;
+			}
+			// see if the ent's bbox is inside the pusher's final position
+			// this does allow a fast moving object to pass through a thin entity...
+			if ( G_TestEntityPosition( check ) != pusher ) 
+			{
+				continue;
+			}
+		}
+
+		if ( ((pusher->spawnflags&2)&&!Q_stricmp("func_breakable",pusher->classname))
+			||((pusher->spawnflags&16)&&!Q_stricmp("func_static",pusher->classname)) )
+		{//ugh, avoid stricmp with a unique flag
+			//Damage on impact
+			if ( pusher->damage )
+			{//Do damage
+				G_Damage( check, pusher, pusher->activator, move, check->currentOrigin, pusher->damage, 0, MOD_CRUSH );
+				if ( pusher->health >= 0 && pusher->takedamage && !(pusher->spawnflags&1) )
+				{//do some damage to me, too
+					G_Damage( pusher, check, pusher->activator, move, pusher->s.pos.trBase, floor(pusher->damage/4.0f), 0, MOD_CRUSH );
+				}
+			}
+		}
+		// really need a flag like MOVER_TOUCH that calls the ent's touch function here, instead of this stricmp crap
+		else if ( (pusher->spawnflags&2) && !Q_stricmp( "func_rotating", pusher->classname ) )
+		{
+			GEntity_TouchFunc( pusher, check, NULL );
+			continue;	// don't want it blocking so skip past it
+		}
+
+		vec3_t oldOrg;
+
+		VectorCopy( check->s.pos.trBase, oldOrg );
+
+		// the entity needs to be pushed
+		if ( G_TryPushingEntity( check, pusher, move, amove ) ) 
+		{
+			// the mover wasn't blocked
+			if ( check->s.eFlags & EF_MISSILE_STICK )
+			{
+				if ( !VectorCompare( oldOrg, check->s.pos.trBase ))
+				{
+					// and the rider was actually pushed, so interpolate position change to smooth out the ride
+					check->s.pos.trType = TR_INTERPOLATE;
+					continue;
+				}
+				//else..the mover wasn't blocked & we are riding the mover & but the rider did not move even though the mover itself did...so
+				//	drop through and let it blow up the rider up
+			}
+			else
+			{
+				continue;
+			}
+		}
+
+		// the move was blocked even after pushing this rider
+		if ( check->s.eFlags & EF_MISSILE_STICK )
+		{
+			// so nuke 'em so they don't block us anymore
+			G_Damage( check, pusher, pusher, NULL, NULL, 99999, 0, MOD_CRUSH );
+			continue;
+		}
+		
+		// save off the obstacle so we can call the block function (crush, etc)
+		*obstacle = check;
+
+		// move back any entities we already moved
+		// go backwards, so if the same entity was pushed
+		// twice, it goes back to the original position
+		for ( p=pushed_p-1 ; p>=pushed ; p-- ) {
+			VectorCopy (p->origin, p->ent->s.pos.trBase);
+			VectorCopy (p->angles, p->ent->s.apos.trBase);
+			if ( p->ent->client ) {
+				p->ent->client->ps.delta_angles[YAW] = p->deltayaw;
+				VectorCopy (p->origin, p->ent->client->ps.origin);
+			}
+			gi.linkentity (p->ent);
+		}
+		return qfalse;
+	}
+
+	return qtrue;
+}
+
+
+/*
+=================
+G_MoverTeam
+=================
+*/
+void G_MoverTeam( gentity_t *ent ) {
+	vec3_t		move, amove;
+	gentity_t	*part, *obstacle;
+	vec3_t		origin, angles;
+
+	obstacle = NULL;
+
+	// make sure all team slaves can move before commiting
+	// any moves or calling any think functions
+	// if the move is blocked, all moved objects will be backed out
+	pushed_p = pushed;
+	for (part = ent ; part ; part=part->teamchain) 
+	{
+		// get current position
+		part->s.eFlags &= ~EF_BLOCKED_MOVER;
+		EvaluateTrajectory( &part->s.pos, level.time, origin );
+		EvaluateTrajectory( &part->s.apos, level.time, angles );
+		VectorSubtract( origin, part->currentOrigin, move );
+		VectorSubtract( angles, part->currentAngles, amove );
+		if ( !G_MoverPush( part, move, amove, &obstacle ) ) 
+		{
+			break;	// move was blocked
+		}
+	}
+
+	if (part) 
+	{
+		// if the pusher has a "blocked" function, call it
+		// go back to the previous position
+		for ( part = ent ; part ; part = part->teamchain ) 
+		{
+			//Push up time so it doesn't wiggle when blocked
+			part->s.pos.trTime += level.time - level.previousTime;
+			part->s.apos.trTime += level.time - level.previousTime;
+			EvaluateTrajectory( &part->s.pos, level.time, part->currentOrigin );
+			EvaluateTrajectory( &part->s.apos, level.time, part->currentAngles );
+			gi.linkentity( part );
+			part->s.eFlags |= EF_BLOCKED_MOVER;
+		}
+
+		if ( ent->e_BlockedFunc != blockedF_NULL ) 
+		{// this check no longer necessary, done internally below, but it's here for reference
+			GEntity_BlockedFunc( ent, obstacle );
+		}
+		return;
+	}
+
+	// the move succeeded
+	for ( part = ent ; part ; part = part->teamchain ) 
+	{
+		// call the reached function if time is at or past end point
+		if ( part->s.pos.trType == TR_LINEAR_STOP ||
+			part->s.pos.trType == TR_NONLINEAR_STOP ) 
+		{
+			if ( level.time >= part->s.pos.trTime + part->s.pos.trDuration ) 
+			{				
+				GEntity_ReachedFunc( part );
+			}
+		}
+	}
+}
+
+/*
+================
+G_RunMover
+
+================
+*/
+//void rebolt_turret( gentity_t *base );
+void G_RunMover( gentity_t *ent ) {
+	// if not a team captain, don't do anything, because
+	// the captain will handle everything
+	if ( ent->flags & FL_TEAMSLAVE ) {
+		return;
+	}
+
+	// if stationary at one of the positions, don't move anything
+	if ( ent->s.pos.trType != TR_STATIONARY || ent->s.apos.trType != TR_STATIONARY ) {
+		G_MoverTeam( ent );
+	}
+
+/*	if ( ent->classname && Q_stricmp("misc_turret", ent->classname ) == 0 )
+	{
+		rebolt_turret( ent );
+	}
+*/
+	// check think function
+	G_RunThink( ent );
+}
+
+/*
+============================================================================
+
+GENERAL MOVERS
+
+Doors, plats, and buttons are all binary (two position) movers
+Pos1 is "at rest", pos2 is "activated"
+============================================================================
+*/
+
+/*
+CalcTeamDoorCenter
+
+Finds all the doors of a team and returns their center position
+*/
+
+void CalcTeamDoorCenter ( gentity_t *ent, vec3_t center ) 
+{
+	vec3_t		slavecenter;
+	gentity_t	*slave;
+
+	//Start with our center
+	VectorAdd(ent->mins, ent->maxs, center);
+	VectorScale(center, 0.5, center);
+	for ( slave = ent->teamchain ; slave ; slave = slave->teamchain ) 
+	{
+		//Find slave's center
+		VectorAdd(slave->mins, slave->maxs, slavecenter);
+		VectorScale(slavecenter, 0.5, slavecenter);
+		//Add that to our own, find middle
+		VectorAdd(center, slavecenter, center);
+		VectorScale(center, 0.5, center);
+	}
+}
+
+/*
+===============
+SetMoverState
+===============
+*/
+void SetMoverState( gentity_t *ent, moverState_t moverState, int time ) {
+	vec3_t			delta;
+	float			f;
+
+	ent->moverState = moverState;
+
+	ent->s.pos.trTime = time;
+
+	if ( ent->s.pos.trDuration <= 0 )
+	{//Don't allow divide by zero!
+		ent->s.pos.trDuration = 1;
+	}
+
+	switch( moverState ) {
+	case MOVER_POS1:
+		VectorCopy( ent->pos1, ent->s.pos.trBase );
+		ent->s.pos.trType = TR_STATIONARY;
+		break;
+	case MOVER_POS2:
+		VectorCopy( ent->pos2, ent->s.pos.trBase );
+		ent->s.pos.trType = TR_STATIONARY;
+		break;
+	case MOVER_1TO2:
+		VectorCopy( ent->pos1, ent->s.pos.trBase );
+		VectorSubtract( ent->pos2, ent->pos1, delta );
+		f = 1000.0 / ent->s.pos.trDuration;
+		VectorScale( delta, f, ent->s.pos.trDelta );
+		if ( ent->alt_fire )
+		{
+			ent->s.pos.trType = TR_LINEAR_STOP;
+		}
+		else
+		{
+			ent->s.pos.trType = TR_NONLINEAR_STOP;
+		}
+		ent->s.eFlags &= ~EF_BLOCKED_MOVER;
+		break;
+	case MOVER_2TO1:
+		VectorCopy( ent->pos2, ent->s.pos.trBase );
+		VectorSubtract( ent->pos1, ent->pos2, delta );
+		f = 1000.0 / ent->s.pos.trDuration;
+		VectorScale( delta, f, ent->s.pos.trDelta );
+		if ( ent->alt_fire )
+		{
+			ent->s.pos.trType = TR_LINEAR_STOP;
+		}
+		else
+		{
+			ent->s.pos.trType = TR_NONLINEAR_STOP;
+		}
+		ent->s.eFlags &= ~EF_BLOCKED_MOVER;
+		break;
+	}
+	EvaluateTrajectory( &ent->s.pos, level.time, ent->currentOrigin );	
+	gi.linkentity( ent );
+}
+
+/*
+================
+MatchTeam
+
+All entities in a mover team will move from pos1 to pos2
+in the same amount of time
+================
+*/
+void MatchTeam( gentity_t *teamLeader, int moverState, int time ) {
+	gentity_t		*slave;
+
+	for ( slave = teamLeader ; slave ; slave = slave->teamchain ) {
+		SetMoverState( slave, (moverState_t) moverState, time );
+	}
+}
+
+
+
+/*
+================
+ReturnToPos1
+================
+*/
+void ReturnToPos1( gentity_t *ent ) {
+	ent->e_ThinkFunc = thinkF_NULL;
+	ent->nextthink = 0;
+	ent->s.time = level.time;
+
+	MatchTeam( ent, MOVER_2TO1, level.time );
+
+	// starting sound
+	G_PlayDoorLoopSound( ent );
+	G_PlayDoorSound( ent, BMS_START );	//??
+}
+
+
+/*
+================
+Reached_BinaryMover
+================
+*/
+
+void Reached_BinaryMover( gentity_t *ent ) 
+{
+	// stop the looping sound
+	ent->s.loopSound = 0;
+
+	if ( ent->moverState == MOVER_1TO2 ) 
+	{//reached open
+		// reached pos2
+		SetMoverState( ent, MOVER_POS2, level.time );
+
+		vec3_t	doorcenter;
+		CalcTeamDoorCenter( ent, doorcenter );
+		if ( ent->activator && ent->activator->client && ent->activator->client->playerTeam == TEAM_PLAYER )
+		{
+			AddSightEvent( ent->activator, doorcenter, 256, AEL_MINOR, 1 );
+		}
+
+		// play sound
+		G_PlayDoorSound( ent, BMS_END );
+
+		if ( ent->wait < 0 )
+		{//Done for good
+			ent->e_ThinkFunc = thinkF_NULL;
+			ent->nextthink = -1;
+			ent->e_UseFunc = useF_NULL;
+		}
+		else
+		{
+			// return to pos1 after a delay
+			ent->e_ThinkFunc = thinkF_ReturnToPos1;
+			if(ent->spawnflags & 8)
+			{//Toggle, keep think, wait for next use?
+				ent->nextthink = -1;
+			}
+			else
+			{
+				ent->nextthink = level.time + ent->wait;
+			}
+		}
+
+		// fire targets
+		if ( !ent->activator ) 
+		{
+			ent->activator = ent;
+		}
+		G_UseTargets2( ent, ent->activator, ent->opentarget );
+	} 
+	else if ( ent->moverState == MOVER_2TO1 ) 
+	{//closed
+		// reached pos1
+		SetMoverState( ent, MOVER_POS1, level.time );
+
+		vec3_t	doorcenter;
+		CalcTeamDoorCenter( ent, doorcenter );
+		if ( ent->activator && ent->activator->client && ent->activator->client->playerTeam == TEAM_PLAYER )
+		{
+			AddSightEvent( ent->activator, doorcenter, 256, AEL_MINOR, 1 );
+		}
+		// play sound
+		G_PlayDoorSound( ent, BMS_END );
+
+		// close areaportals
+		if ( ent->teammaster == ent || !ent->teammaster ) 
+		{
+			gi.AdjustAreaPortalState( ent, qfalse );
+		}
+		G_UseTargets2( ent, ent->activator, ent->closetarget );
+	} 
+	else 
+	{
+		G_Error( "Reached_BinaryMover: bad moverState" );
+	}
+}
+
+
+/*
+================
+Use_BinaryMover_Go
+================
+*/
+void Use_BinaryMover_Go( gentity_t *ent ) 
+{
+	int		total;
+	int		partial;
+//	gentity_t	*other = ent->enemy;
+	gentity_t	*activator = ent->activator;
+
+	ent->activator = activator;
+
+	if ( ent->moverState == MOVER_POS1 ) 
+	{
+		// start moving 50 msec later, becase if this was player
+		// triggered, level.time hasn't been advanced yet
+		MatchTeam( ent, MOVER_1TO2, level.time + 50 );
+
+		vec3_t	doorcenter;
+		CalcTeamDoorCenter( ent, doorcenter );
+		if ( ent->activator && ent->activator->client && ent->activator->client->playerTeam == TEAM_PLAYER )
+		{
+			AddSightEvent( ent->activator, doorcenter, 256, AEL_MINOR, 1 );
+		}
+
+		// starting sound
+		G_PlayDoorLoopSound( ent );
+		G_PlayDoorSound( ent, BMS_START );
+		ent->s.time = level.time;
+
+		// open areaportal
+		if ( ent->teammaster == ent || !ent->teammaster ) {
+			gi.AdjustAreaPortalState( ent, qtrue );
+		}
+		G_UseTargets( ent, ent->activator );
+		return;
+	}
+
+	// if all the way up, just delay before coming down
+	if ( ent->moverState == MOVER_POS2 ) {
+		//have to do this because the delay sets our think to Use_BinaryMover_Go
+		ent->e_ThinkFunc = thinkF_ReturnToPos1;
+		if ( ent->spawnflags & 8 )
+		{//TOGGLE doors don't use wait!
+			ent->nextthink = level.time + FRAMETIME;
+		}
+		else
+		{
+			ent->nextthink = level.time + ent->wait;
+		}
+		G_UseTargets2( ent, ent->activator, ent->target2 );
+		return;
+	}
+
+	// only partway down before reversing
+	if ( ent->moverState == MOVER_2TO1 ) 
+	{
+		total = ent->s.pos.trDuration-50;
+		if ( ent->s.pos.trType == TR_NONLINEAR_STOP )
+		{
+			vec3_t curDelta;
+			VectorSubtract( ent->currentOrigin, ent->pos1, curDelta );
+			float fPartial = VectorLength( curDelta )/VectorLength( ent->s.pos.trDelta );
+			VectorScale( ent->s.pos.trDelta, fPartial, curDelta );
+			fPartial /= ent->s.pos.trDuration;
+			fPartial /= 0.001f;
+			fPartial = acos( fPartial );
+			fPartial = RAD2DEG( fPartial );
+			fPartial = (90.0f - fPartial)/90.0f*ent->s.pos.trDuration;
+			partial = total - floor( fPartial );
+		}
+		else
+		{
+			partial = level.time - ent->s.pos.trTime;//ent->s.time;
+		}
+
+		if ( partial > total ) {
+			partial = total;
+		}
+		ent->s.pos.trTime = level.time - ( total - partial );//ent->s.time;
+
+		MatchTeam( ent, MOVER_1TO2, ent->s.pos.trTime );
+
+		G_PlayDoorSound( ent, BMS_START );
+
+		return;
+	}
+
+	// only partway up before reversing
+	if ( ent->moverState == MOVER_1TO2 ) 
+	{
+		total = ent->s.pos.trDuration-50;
+		if ( ent->s.pos.trType == TR_NONLINEAR_STOP )
+		{
+			vec3_t curDelta;
+			VectorSubtract( ent->currentOrigin, ent->pos2, curDelta );
+			float fPartial = VectorLength( curDelta )/VectorLength( ent->s.pos.trDelta );
+			VectorScale( ent->s.pos.trDelta, fPartial, curDelta );
+			fPartial /= ent->s.pos.trDuration;
+			fPartial /= 0.001f;
+			fPartial = acos( fPartial );
+			fPartial = RAD2DEG( fPartial );
+			fPartial = (90.0f - fPartial)/90.0f*ent->s.pos.trDuration;
+			partial = total - floor( fPartial );
+		}
+		else
+		{
+			partial = level.time - ent->s.pos.trTime;//ent->s.time;
+		}
+		if ( partial > total ) {
+			partial = total;
+		}
+
+		ent->s.pos.trTime = level.time - ( total - partial );//ent->s.time;
+		MatchTeam( ent, MOVER_2TO1, ent->s.pos.trTime );
+
+		G_PlayDoorSound( ent, BMS_START );
+
+		return;
+	}
+}
+
+void UnLockDoors(gentity_t *const ent)
+{
+	//noise?
+	//go through and unlock the door and all the slaves
+	gentity_t	*slave = ent;
+	do 
+	{	// want to allow locked toggle doors, so keep the targetname
+		if( !(slave->spawnflags & MOVER_TOGGLE) )
+		{
+			slave->targetname = NULL;//not usable ever again
+		}
+		slave->spawnflags &= ~MOVER_LOCKED;
+		slave->s.frame = 1;//second stage of anim
+		slave = slave->teamchain;
+	} while  ( slave );
+}
+void LockDoors(gentity_t *const ent)
+{
+	//noise?
+	//go through and lock the door and all the slaves
+	gentity_t	*slave = ent;
+	do 
+	{
+		slave->spawnflags |= MOVER_LOCKED;
+		slave->s.frame = 0;//first stage of anim
+		slave = slave->teamchain;
+	} while  ( slave );
+}
+/*
+================
+Use_BinaryMover
+================
+*/
+void Use_BinaryMover( gentity_t *ent, gentity_t *other, gentity_t *activator ) 
+{
+	int	key;
+	char *text;
+
+	if ( ent->e_UseFunc == useF_NULL )
+	{//I cannot be used anymore, must be a door with a wait of -1 that's opened.
+		return;
+	}
+
+	// only the master should be used
+	if ( ent->flags & FL_TEAMSLAVE ) 
+	{
+		Use_BinaryMover( ent->teammaster, other, activator );
+		return;
+	}
+
+	if ( ent->svFlags & SVF_INACTIVE )
+	{
+		return;
+	}
+
+	if ( ent->spawnflags & MOVER_LOCKED )
+	{//a locked door, unlock it
+		UnLockDoors(ent);
+		return;
+	}
+
+	if ( ent->spawnflags & MOVER_GOODIE )
+	{
+		if ( ent->fly_sound_debounce_time > level.time )
+		{
+			return;
+		}
+		else 
+		{
+			key = INV_GoodieKeyCheck( activator );
+			if (key)
+			{//activator has a goodie key, remove it
+				activator->client->ps.inventory[key]--;		
+				G_Sound( activator, G_SoundIndex( "sound/movers/goodie_pass.wav" ) );
+				// once the goodie mover has been used, it no longer requires a goodie key
+				ent->spawnflags &= ~MOVER_GOODIE;
+			}
+			else
+			{	//don't have a goodie key
+				G_Sound( activator, G_SoundIndex( "sound/movers/goodie_fail.wav" ) );
+				ent->fly_sound_debounce_time = level.time + 5000;
+				text = "cp @SP_INGAME_NEED_KEY_TO_OPEN";
+				//FIXME: temp message, only on certain difficulties?, graphic instead of text?
+				gi.SendServerCommand( NULL, text );
+				return;
+			}
+		}
+	}
+
+	G_ActivateBehavior(ent,BSET_USE);
+
+	G_SetEnemy( ent, other );
+	ent->activator = activator;
+	if(ent->delay)
+	{
+		ent->e_ThinkFunc = thinkF_Use_BinaryMover_Go;
+		ent->nextthink = level.time + ent->delay;
+	}
+	else
+	{
+		Use_BinaryMover_Go(ent);
+	}
+}
+
+
+
+/*
+================
+InitMover
+
+"pos1", "pos2", and "speed" should be set before calling,
+so the movement delta can be calculated
+================
+*/
+void InitMoverTrData( gentity_t *ent )
+{
+	vec3_t		move;
+	float		distance;
+
+	ent->s.pos.trType = TR_STATIONARY;
+	VectorCopy( ent->pos1, ent->s.pos.trBase );
+
+	// calculate time to reach second position from speed
+	VectorSubtract( ent->pos2, ent->pos1, move );
+	distance = VectorLength( move );
+	if ( ! ent->speed ) 
+	{
+		ent->speed = 100;
+	}
+	VectorScale( move, ent->speed, ent->s.pos.trDelta );
+	ent->s.pos.trDuration = distance * 1000 / ent->speed;
+	if ( ent->s.pos.trDuration <= 0 ) 
+	{
+		ent->s.pos.trDuration = 1;
+	}
+}
+
+void InitMover( gentity_t *ent ) 
+{
+	float		light;
+	vec3_t		color;
+	qboolean	lightSet, colorSet;
+
+	// if the "model2" key is set, use a seperate model
+	// for drawing, but clip against the brushes
+	if ( ent->model2 ) 
+	{
+		if ( strstr( ent->model2, ".glm" ))
+		{
+			ent->s.modelindex2 = G_ModelIndex( ent->model2 );
+			ent->playerModel = gi.G2API_InitGhoul2Model( ent->ghoul2, ent->model2, ent->s.modelindex2 );
+			if ( ent->playerModel >= 0 )
+			{
+				ent->rootBone = gi.G2API_GetBoneIndex( &ent->ghoul2[ent->playerModel], "model_root", qtrue );
+			}
+
+			ent->s.radius = 120;
+		}
+		else
+		{
+			ent->s.modelindex2 = G_ModelIndex( ent->model2 );
+		}
+	}
+
+	// if the "color" or "light" keys are set, setup constantLight
+	lightSet = G_SpawnFloat( "light", "100", &light );
+	colorSet = G_SpawnVector( "color", "1 1 1", color );
+	if ( lightSet || colorSet ) {
+		int		r, g, b, i;
+
+		r = color[0] * 255;
+		if ( r > 255 ) {
+			r = 255;
+		}
+		g = color[1] * 255;
+		if ( g > 255 ) {
+			g = 255;
+		}
+		b = color[2] * 255;
+		if ( b > 255 ) {
+			b = 255;
+		}
+		i = light / 4;
+		if ( i > 255 ) {
+			i = 255;
+		}
+		ent->s.constantLight = r | ( g << 8 ) | ( b << 16 ) | ( i << 24 );
+	}
+
+	ent->e_UseFunc	   = useF_Use_BinaryMover;
+	ent->e_ReachedFunc = reachedF_Reached_BinaryMover;
+
+	ent->moverState = MOVER_POS1;
+	ent->svFlags = SVF_USE_CURRENT_ORIGIN;
+	if ( ent->spawnflags & MOVER_INACTIVE )
+	{// Make it inactive
+		ent->svFlags |= SVF_INACTIVE;	
+	}
+	if(ent->spawnflags & MOVER_PLAYER_USE)
+	{//Can be used by the player's BUTTON_USE
+		ent->svFlags |= SVF_PLAYER_USABLE;
+	}
+	ent->s.eType = ET_MOVER;
+	VectorCopy( ent->pos1, ent->currentOrigin );
+	gi.linkentity( ent );
+
+	InitMoverTrData( ent );
+}
+
+
+/*
+===============================================================================
+
+DOOR
+
+A use can be triggered either by a touch function, by being shot, or by being
+targeted by another entity.
+
+===============================================================================
+*/
+
+/*
+================
+Blocked_Door
+================
+*/
+void Blocked_Door( gentity_t *ent, gentity_t *other ) {
+	
+	// remove anything other than a client -- no longer the case
+
+	// don't remove security keys or goodie keys
+	if ( (other->s.eType == ET_ITEM) && (other->item->giTag >= INV_GOODIE_KEY && other->item->giTag <= INV_SECURITY_KEY) )
+	{
+		// should we be doing anything special if a key blocks it... move it somehow..?
+	}
+	// if your not a client, or your a dead client remove yourself...
+	else if ( other->s.number && (!other->client || (other->client && other->health <= 0 && other->contents == CONTENTS_CORPSE && !other->message)) )
+	{
+		if ( !IIcarusInterface::GetIcarus()->IsRunning( other->m_iIcarusID ) /*!other->taskManager || !other->taskManager->IsRunning()*/ )
+		{
+			// if an item or weapon can we do a little explosion..?
+			G_FreeEntity( other );
+			return;
+		}
+	}
+
+	if ( ent->damage ) 
+	{
+		if ( (ent->spawnflags&MOVER_CRUSHER)//a crusher
+ 			&& other->s.clientNum >= MAX_CLIENTS//not the player
+			&& other->client //NPC
+			&& other->health <= 0 //dead
+			&& G_OkayToRemoveCorpse( other ) )//okay to remove him
+		{//crusher stuck on a non->player corpse that does not have a key and is not running a script
+			G_FreeEntity( other );
+		}
+		else
+		{
+			G_Damage( other, ent, ent, NULL, NULL, ent->damage, 0, MOD_CRUSH );
+		}
+	}
+	if ( ent->spawnflags & MOVER_CRUSHER ) {
+		return;		// crushers don't reverse
+	}
+
+	// reverse direction
+	Use_BinaryMover( ent, ent, other );
+}
+
+
+/*
+================
+Touch_DoorTrigger
+================
+*/
+
+void Touch_DoorTrigger( gentity_t *ent, gentity_t *other, trace_t *trace ) 
+{
+	if ( ent->svFlags & SVF_INACTIVE )
+	{
+		return;
+	}
+
+	if ( ent->owner->spawnflags & MOVER_LOCKED )
+	{//don't even try to use the door if it's locked 
+		return;
+	}
+
+	if ( ent->owner->moverState != MOVER_1TO2 ) 
+	{//Door is not already opening
+		//if ( ent->owner->moverState == MOVER_POS1 || ent->owner->moverState == MOVER_2TO1 )
+		//{//only check these if closed or closing
+
+		//If door is closed, opening or open, check this
+		Use_BinaryMover( ent->owner, ent, other );
+	}
+
+	/*
+	//Old style
+	if ( ent->owner->moverState != MOVER_1TO2 ) {
+		Use_BinaryMover( ent->owner, ent, other );
+	}
+	*/
+}
+
+/*
+======================
+Think_SpawnNewDoorTrigger
+
+All of the parts of a door have been spawned, so create
+a trigger that encloses all of them
+======================
+*/
+void Think_SpawnNewDoorTrigger( gentity_t *ent ) 
+{
+	gentity_t		*other;
+	vec3_t		mins, maxs;
+	int			i, best;
+
+	// set all of the slaves as shootable
+	if ( ent->takedamage ) 
+	{
+		for ( other = ent ; other ; other = other->teamchain ) 
+		{
+			other->takedamage = qtrue;
+		}
+	}
+
+	// find the bounds of everything on the team
+	VectorCopy (ent->absmin, mins);
+	VectorCopy (ent->absmax, maxs);
+
+	for (other = ent->teamchain ; other ; other=other->teamchain) {
+		AddPointToBounds (other->absmin, mins, maxs);
+		AddPointToBounds (other->absmax, mins, maxs);
+	}
+
+	// find the thinnest axis, which will be the one we expand
+	best = 0;
+	for ( i = 1 ; i < 3 ; i++ ) {
+		if ( maxs[i] - mins[i] < maxs[best] - mins[best] ) {
+			best = i;
+		}
+	}
+	maxs[best] += 120;
+	mins[best] -= 120;
+
+	// create a trigger with this size
+	other = G_Spawn ();
+	VectorCopy (mins, other->mins);
+	VectorCopy (maxs, other->maxs);
+	other->owner = ent;
+	other->contents = CONTENTS_TRIGGER;
+	other->e_TouchFunc = touchF_Touch_DoorTrigger;
+	gi.linkentity (other);
+	other->classname = "trigger_door";
+
+	MatchTeam( ent, ent->moverState, level.time );
+}
+
+void Think_MatchTeam( gentity_t *ent ) 
+{
+	MatchTeam( ent, ent->moverState, level.time );
+}
+
+qboolean G_EntIsDoor( int entityNum )
+{
+	if ( entityNum < 0 || entityNum >= ENTITYNUM_WORLD )
+	{
+		return qfalse;
+	}
+
+	gentity_t *ent = &g_entities[entityNum];
+	if ( ent && !Q_stricmp( "func_door", ent->classname ) )
+	{//blocked by a door
+		return qtrue;
+	}
+	return qfalse;
+}
+
+gentity_t *G_FindDoorTrigger( gentity_t *ent )
+{
+	gentity_t *owner = NULL;
+	gentity_t *door = ent;
+	if ( door->flags & FL_TEAMSLAVE )
+	{//not the master door, get the master door
+		while ( door->teammaster && (door->flags&FL_TEAMSLAVE))
+		{
+			door = door->teammaster;
+		}
+	}
+	if ( door->targetname )
+	{//find out what is targeting it
+		//FIXME: if ent->targetname, check what kind of trigger/ent is targetting it?  If a normal trigger (active, etc), then it's okay?
+		while ( (owner = G_Find( owner, FOFS( target ), door->targetname )) != NULL )
+		{
+			if ( owner && (owner->contents&CONTENTS_TRIGGER) )
+			{
+				return owner;
+			}
+		}
+		owner = NULL;
+		while ( (owner = G_Find( owner, FOFS( target2 ), door->targetname )) != NULL )
+		{
+			if ( owner && (owner->contents&CONTENTS_TRIGGER) )
+			{
+				return owner;
+			}
+		}
+	}
+
+	owner = NULL;
+	while ( (owner = G_Find( owner, FOFS( classname ), "trigger_door" )) != NULL )
+	{
+		if ( owner->owner == door )
+		{
+			return owner;
+		}
+	}
+
+	return NULL;
+}
+
+qboolean G_TriggerActive( gentity_t *self );
+qboolean G_EntIsUnlockedDoor( int entityNum )
+{
+	if ( entityNum < 0 || entityNum >= ENTITYNUM_WORLD )
+	{
+		return qfalse;
+	}
+
+	if ( G_EntIsDoor( entityNum ) )
+	{
+		gentity_t *ent = &g_entities[entityNum];
+		gentity_t *owner = NULL;
+		if ( ent->flags & FL_TEAMSLAVE )
+		{//not the master door, get the master door
+			while ( ent->teammaster && (ent->flags&FL_TEAMSLAVE))
+			{
+				ent = ent->teammaster;
+			}
+		}
+		if ( ent->targetname )
+		{//find out what is targetting it
+			owner = NULL;
+			//FIXME: if ent->targetname, check what kind of trigger/ent is targetting it?  If a normal trigger (active, etc), then it's okay?
+			while ( (owner = G_Find( owner, FOFS( target ), ent->targetname )) != NULL )
+			{
+				if ( !Q_stricmp( "trigger_multiple", owner->classname )
+				  || !Q_stricmp( "trigger_once", owner->classname ) )//FIXME: other triggers okay too?
+				{
+					if ( G_TriggerActive( owner ) )
+					{
+						return qtrue;
+					}
+				}
+			}
+			owner = NULL;
+			while ( (owner = G_Find( owner, FOFS( target2 ), ent->targetname )) != NULL )
+			{
+				if ( !Q_stricmp( "trigger_multiple", owner->classname ) )//FIXME: other triggers okay too?
+				{
+					if ( G_TriggerActive( owner ) )
+					{
+						return qtrue;
+					}
+				}
+			}
+			return qfalse;
+		}
+		else
+		{//check the door's auto-created trigger instead
+			owner = G_FindDoorTrigger( ent );
+			if ( owner && (owner->svFlags&SVF_INACTIVE) )
+			{//owning auto-created trigger is inactive
+				return qfalse;
+			}
+		}
+		if ( !(ent->svFlags & SVF_INACTIVE) && //assumes that the reactivate trigger isn't right next to the door!
+			!ent->health &&
+			!(ent->spawnflags & MOVER_PLAYER_USE) &&
+			!(ent->spawnflags & MOVER_FORCE_ACTIVATE) &&
+			!(ent->spawnflags & MOVER_LOCKED))
+			//FIXME: what about MOVER_GOODIE?
+		{
+			return qtrue;
+		}
+	}
+	return qfalse;
+}
+
+
+/*QUAKED func_door (0 .5 .8) ? START_OPEN FORCE_ACTIVATE CRUSHER TOGGLE LOCKED GOODIE PLAYER_USE INACTIVE
+START_OPEN	the door to moves to its destination when spawned, and operate in reverse.  It is used to temporarily or permanently close off an area when triggered (not useful for touch or takedamage doors).
+FORCE_ACTIVATE	Can only be activated by a force push or pull
+CRUSHER		?
+TOGGLE		wait in both the start and end states for a trigger event - does NOT work on Trek doors.
+LOCKED		Starts locked, with the shader animmap at the first frame and inactive.  Once used, the animmap changes to the second frame and the door operates normally.  Note that you cannot use the door again after this.
+GOODIE		Door will not work unless activator has a "goodie key" in his inventory
+PLAYER_USE	Player can use it with the use button
+INACTIVE	must be used by a target_activate before it can be used
+
+"target"     Door fires this when it starts moving from it's closed position to its open position.
+"opentarget" Door fires this after reaching its "open" position
+"target2"    Door fires this when it starts moving from it's open position to its closed position.
+"closetarget" Door fires this after reaching its "closed" position
+"model2"	.md3 model to also draw
+"modelAngles" md3 model's angles <pitch yaw roll> (in addition to any rotation on the part of the brush entity itself)
+"angle"		determines the opening direction
+"targetname" if set, no touch field will be spawned and a remote button or trigger field activates the door.
+"speed"		movement speed (100 default)
+"wait"		wait before returning (3 default, -1 = never return)
+"delay"		when used, how many seconds to wait before moving - default is none
+"lip"		lip remaining at end of move (8 default)
+"dmg"		damage to inflict when blocked (2 default, set to negative for no damage)
+"color"		constantLight color
+"light"		constantLight radius
+"health"	if set, the door must be shot open
+"sounds" - sound door makes when opening/closing
+"linear"	set to 1 and it will move linearly rather than with acceleration (default is 0)
+0 - no sound (default)
+*/
+void SP_func_door (gentity_t *ent) 
+{
+	vec3_t	abs_movedir;
+	float	distance;
+	vec3_t	size;
+	float	lip;
+
+	ent->e_BlockedFunc = blockedF_Blocked_Door;
+
+	if ( ent->spawnflags & MOVER_GOODIE )
+	{
+		G_SoundIndex( "sound/movers/goodie_fail.wav" );
+		G_SoundIndex( "sound/movers/goodie_pass.wav" );
+	}
+
+	// default speed of 400
+	if (!ent->speed)
+		ent->speed = 400;
+
+	// default wait of 2 seconds
+	if (!ent->wait)
+		ent->wait = 2;
+	ent->wait *= 1000;
+
+	ent->delay *= 1000;
+
+	// default lip of 8 units
+	G_SpawnFloat( "lip", "8", &lip );
+
+	// default damage of 2 points
+	G_SpawnInt( "dmg", "2", &ent->damage );
+	if ( ent->damage < 0 )
+	{
+		ent->damage = 0;
+	}
+
+	// first position at start
+	VectorCopy( ent->s.origin, ent->pos1 );
+
+	// calculate second position
+	gi.SetBrushModel( ent, ent->model );
+	G_SetMovedir( ent->s.angles, ent->movedir );
+	abs_movedir[0] = fabs( ent->movedir[0] );
+	abs_movedir[1] = fabs( ent->movedir[1] );
+	abs_movedir[2] = fabs( ent->movedir[2] );
+	VectorSubtract( ent->maxs, ent->mins, size );
+	distance = DotProduct( abs_movedir, size ) - lip;
+	VectorMA( ent->pos1, distance, ent->movedir, ent->pos2 );
+
+	// if "start_open", reverse position 1 and 2
+	if ( ent->spawnflags & 1 ) 
+	{
+		vec3_t	temp;
+
+		VectorCopy( ent->pos2, temp );
+		VectorCopy( ent->s.origin, ent->pos2 );
+		VectorCopy( temp, ent->pos1 );
+	}
+
+	if ( ent->spawnflags & MOVER_LOCKED )
+	{//a locked door, set up as locked until used directly
+		ent->s.eFlags |= EF_SHADER_ANIM;//use frame-controlled shader anim
+		ent->s.frame = 0;//first stage of anim
+	}
+	InitMover( ent );
+
+	ent->nextthink = level.time + FRAMETIME;
+
+	if ( !(ent->flags&FL_TEAMSLAVE) ) 
+	{
+		int health;
+
+		G_SpawnInt( "health", "0", &health );
+		
+		if ( health ) 
+		{
+			ent->takedamage = qtrue;
+		}
+		
+		if ( !(ent->spawnflags&MOVER_LOCKED) && (ent->targetname || health || ent->spawnflags & MOVER_PLAYER_USE || ent->spawnflags & MOVER_FORCE_ACTIVATE) )
+		{
+			// non touch/shoot doors
+			ent->e_ThinkFunc = thinkF_Think_MatchTeam;
+		} 
+		else 
+		{//locked doors still spawn a trigger
+			ent->e_ThinkFunc = thinkF_Think_SpawnNewDoorTrigger;
+		}
+	}
+}
+
+/*
+===============================================================================
+
+PLAT
+
+===============================================================================
+*/
+
+/*
+==============
+Touch_Plat
+
+Don't allow decent if a living player is on it
+===============
+*/
+void Touch_Plat( gentity_t *ent, gentity_t *other, trace_t *trace ) {
+	if ( !other->client || other->client->ps.stats[STAT_HEALTH] <= 0 ) {
+		return;
+	}
+
+	// delay return-to-pos1 by one second
+	if ( ent->moverState == MOVER_POS2 ) {
+		ent->nextthink = level.time + 1000;
+	}
+}
+
+/*
+==============
+Touch_PlatCenterTrigger
+
+If the plat is at the bottom position, start it going up
+===============
+*/
+void Touch_PlatCenterTrigger(gentity_t *ent, gentity_t *other, trace_t *trace ) {
+	if ( !other->client ) {
+		return;
+	}
+
+	if ( ent->owner->moverState == MOVER_POS1 ) {
+		Use_BinaryMover( ent->owner, ent, other );
+	}
+}
+
+
+/*
+================
+SpawnPlatTrigger
+
+Spawn a trigger in the middle of the plat's low position
+Elevator cars require that the trigger extend through the entire low position,
+not just sit on top of it.
+================
+*/
+void SpawnPlatTrigger( gentity_t *ent ) {
+	gentity_t	*trigger;
+	vec3_t	tmin, tmax;
+
+	// the middle trigger will be a thin trigger just
+	// above the starting position
+	trigger = G_Spawn();
+	trigger->e_TouchFunc = touchF_Touch_PlatCenterTrigger;
+	trigger->contents = CONTENTS_TRIGGER;
+	trigger->owner = ent;
+	
+	tmin[0] = ent->pos1[0] + ent->mins[0] + 33;
+	tmin[1] = ent->pos1[1] + ent->mins[1] + 33;
+	tmin[2] = ent->pos1[2] + ent->mins[2];
+
+	tmax[0] = ent->pos1[0] + ent->maxs[0] - 33;
+	tmax[1] = ent->pos1[1] + ent->maxs[1] - 33;
+	tmax[2] = ent->pos1[2] + ent->maxs[2] + 8;
+
+	if ( tmax[0] <= tmin[0] ) {
+		tmin[0] = ent->pos1[0] + (ent->mins[0] + ent->maxs[0]) *0.5;
+		tmax[0] = tmin[0] + 1;
+	}
+	if ( tmax[1] <= tmin[1] ) {
+		tmin[1] = ent->pos1[1] + (ent->mins[1] + ent->maxs[1]) *0.5;
+		tmax[1] = tmin[1] + 1;
+	}
+	
+	VectorCopy (tmin, trigger->mins);
+	VectorCopy (tmax, trigger->maxs);
+
+	gi.linkentity (trigger);
+}
+
+
+/*QUAKED func_plat (0 .5 .8) ? x x x x x x PLAYER_USE INACTIVE
+PLAYER_USE	Player can use it with the use button
+INACTIVE	must be used by a target_activate before it can be used
+
+Plats are always drawn in the extended position so they will light correctly.
+
+"lip"		default 8, protrusion above rest position
+"height"	total height of movement, defaults to model height
+"speed"		overrides default 200.
+"dmg"		overrides default 2
+"model2"	.md3 model to also draw
+"modelAngles" md3 model's angles <pitch yaw roll> (in addition to any rotation on the part of the brush entity itself)
+"color"		constantLight color
+"light"		constantLight radius
+*/
+void SP_func_plat (gentity_t *ent) {
+	float		lip, height;
+
+//	ent->sound1to2 = ent->sound2to1 = G_SoundIndex("sound/movers/plats/pt1_strt.wav");
+//	ent->soundPos1 = ent->soundPos2 = G_SoundIndex("sound/movers/plats/pt1_end.wav");
+
+	VectorClear (ent->s.angles);
+
+	G_SpawnFloat( "speed", "200", &ent->speed );
+	G_SpawnInt( "dmg", "2", &ent->damage );
+	G_SpawnFloat( "wait", "1", &ent->wait );
+	G_SpawnFloat( "lip", "8", &lip );
+
+	ent->wait = 1000;
+
+	// create second position
+	gi.SetBrushModel( ent, ent->model );
+
+	if ( !G_SpawnFloat( "height", "0", &height ) ) {
+		height = (ent->maxs[2] - ent->mins[2]) - lip;
+	}
+
+	// pos1 is the rest (bottom) position, pos2 is the top
+	VectorCopy( ent->s.origin, ent->pos2 );
+	VectorCopy( ent->pos2, ent->pos1 );
+	ent->pos1[2] -= height;
+
+	InitMover( ent );
+
+	// touch function keeps the plat from returning while
+	// a live player is standing on it
+	ent->e_TouchFunc = touchF_Touch_Plat;
+
+	ent->e_BlockedFunc = blockedF_Blocked_Door;
+
+	ent->owner = ent;	// so it can be treated as a door
+
+	// spawn the trigger if one hasn't been custom made
+	if ( !ent->targetname ) {
+		SpawnPlatTrigger(ent);
+	}
+}
+
+
+/*
+===============================================================================
+
+BUTTON
+
+===============================================================================
+*/
+
+/*
+==============
+Touch_Button
+
+===============
+*/
+void Touch_Button(gentity_t *ent, gentity_t *other, trace_t *trace ) {
+	if ( !other->client ) {
+		return;
+	}
+
+	if ( ent->moverState == MOVER_POS1 ) {
+		Use_BinaryMover( ent, other, other );
+	}
+}
+
+
+/*QUAKED func_button (0 .5 .8) ? x x x x x x PLAYER_USE INACTIVE
+PLAYER_USE	Player can use it with the use button
+INACTIVE	must be used by a target_activate before it can be used
+
+When a button is touched, it moves some distance in the direction of it's angle, triggers all of it's targets, waits some time, then returns to it's original position where it can be triggered again.
+
+"model2"	.md3 model to also draw
+"modelAngles" md3 model's angles <pitch yaw roll> (in addition to any rotation on the part of the brush entity itself)
+"angle"		determines the opening direction
+"target"	all entities with a matching targetname will be used
+"speed"		override the default 40 speed
+"wait"		override the default 1 second wait (-1 = never return)
+"lip"		override the default 4 pixel lip remaining at end of move
+"health"	if set, the button must be killed instead of touched
+"color"		constantLight color
+"light"		constantLight radius
+*/
+void SP_func_button( gentity_t *ent ) {
+	vec3_t		abs_movedir;
+	float		distance;
+	vec3_t		size;
+	float		lip;
+
+//	ent->sound1to2 = G_SoundIndex("sound/movers/switches/butn2.wav");
+	
+	if ( !ent->speed ) {
+		ent->speed = 40;
+	}
+
+	if ( !ent->wait ) {
+		ent->wait = 1;
+	}
+	ent->wait *= 1000;
+
+	// first position
+	VectorCopy( ent->s.origin, ent->pos1 );
+
+	// calculate second position
+	gi.SetBrushModel( ent, ent->model );
+
+	G_SpawnFloat( "lip", "4", &lip );
+
+	G_SetMovedir( ent->s.angles, ent->movedir );
+	abs_movedir[0] = fabs(ent->movedir[0]);
+	abs_movedir[1] = fabs(ent->movedir[1]);
+	abs_movedir[2] = fabs(ent->movedir[2]);
+	VectorSubtract( ent->maxs, ent->mins, size );
+	distance = abs_movedir[0] * size[0] + abs_movedir[1] * size[1] + abs_movedir[2] * size[2] - lip;
+	VectorMA (ent->pos1, distance, ent->movedir, ent->pos2);
+
+	if (ent->health) {
+		// shootable button
+		ent->takedamage = qtrue;
+	} else {
+		// touchable button
+		ent->e_TouchFunc = touchF_Touch_Button;
+	}
+
+	InitMover( ent );
+}
+
+
+
+/*
+===============================================================================
+
+TRAIN
+
+===============================================================================
+*/
+
+
+#define TRAIN_START_ON		1
+#define TRAIN_TOGGLE		2
+#define TRAIN_BLOCK_STOPS	4
+
+/*
+===============
+Think_BeginMoving
+
+The wait time at a corner has completed, so start moving again
+===============
+*/
+void Think_BeginMoving( gentity_t *ent ) {
+
+	if ( ent->spawnflags & 2048 ) 
+	{
+		// this tie fighter hack is done for doom_detention, where the shooting gallery takes place. let them draw again when they start moving
+		ent->s.eFlags &= ~EF_NODRAW;
+	}
+
+	ent->s.pos.trTime = level.time;
+	if ( ent->alt_fire )
+	{
+		ent->s.pos.trType = TR_LINEAR_STOP;
+	}
+	else
+	{
+		ent->s.pos.trType = TR_NONLINEAR_STOP;
+	}
+}
+
+/*
+===============
+Reached_Train
+===============
+*/
+void Reached_Train( gentity_t *ent ) {
+	gentity_t		*next;
+	float			speed;
+	vec3_t			move;
+	float			length;
+
+	// copy the apropriate values
+	next = ent->nextTrain;
+	if ( !next || !next->nextTrain ) {
+		//FIXME: can we go backwards- say if we are toggle-able?
+		return;		// just stop
+	}
+
+	// fire all other targets
+	G_UseTargets( next, ent );
+
+	// set the new trajectory
+	ent->nextTrain = next->nextTrain;
+	VectorCopy( next->s.origin, ent->pos1 );
+	VectorCopy( next->nextTrain->s.origin, ent->pos2 );
+
+	// if the path_corner has a speed, use that
+	if ( next->speed ) {
+		speed = next->speed;
+	} else {
+		// otherwise use the train's speed
+		speed = ent->speed;
+	}
+	if ( speed < 1 ) {
+		speed = 1;
+	}
+
+	// calculate duration
+	VectorSubtract( ent->pos2, ent->pos1, move );
+	length = VectorLength( move );
+
+	ent->s.pos.trDuration = length * 1000 / speed;
+
+	// looping sound
+/*
+	if ( VALIDSTRING( next->soundSet ) )
+	{
+		ent->s.loopSound = CAS_GetBModelSound( next->soundSet, BMS_MID );//ent->soundLoop;
+	}
+*/
+	G_PlayDoorLoopSound( ent );
+
+	// start it going
+	SetMoverState( ent, MOVER_1TO2, level.time );
+
+	if (( next->spawnflags & 1 ))
+	{
+		vec3_t angs;
+
+		vectoangles( move, angs );
+		AnglesSubtract( angs, ent->currentAngles, angs );
+
+		for ( int i = 0; i < 3; i++ )
+		{
+			AngleNormalize360( angs[i] );
+		}
+		VectorCopy( ent->currentAngles, ent->s.apos.trBase );
+		VectorScale( angs, 0.5f, ent->s.apos.trDelta );
+		ent->s.apos.trTime = level.time;
+		ent->s.apos.trDuration = 2000;
+		if ( ent->alt_fire )
+		{
+			ent->s.apos.trType = TR_LINEAR_STOP;
+		}
+		else
+		{
+			ent->s.apos.trType = TR_NONLINEAR_STOP;
+		}
+	}
+	else 
+	{
+		if (( next->spawnflags & 4 ))
+		{//yaw
+			vec3_t angs;
+
+			vectoangles( move, angs );
+			AnglesSubtract( angs, ent->currentAngles, angs );
+
+			for ( int i = 0; i < 3; i++ )
+			{
+				AngleNormalize360( angs[i] );
+			}
+			VectorCopy( ent->currentAngles, ent->s.apos.trBase );
+			ent->s.apos.trDelta[YAW] = angs[YAW] * 0.5f;
+			if (( next->spawnflags & 8 ))
+			{//roll, too
+				ent->s.apos.trDelta[ROLL] = angs[YAW] * -0.1f;
+			}
+			ent->s.apos.trTime = level.time;
+			ent->s.apos.trDuration = 2000;
+			if ( ent->alt_fire )
+			{
+				ent->s.apos.trType = TR_LINEAR_STOP;
+			}
+			else
+			{
+				ent->s.apos.trType = TR_NONLINEAR_STOP;
+			}
+		}
+	}
+
+	// This is for the tie fighter shooting gallery on doom detention, you could see them waiting under the bay, but the architecture couldn't easily be changed..
+	if (( next->spawnflags & 2 ))
+	{
+		ent->s.eFlags |= EF_NODRAW; // make us invisible until we start moving again
+	}
+
+	// if there is a "wait" value on the target, don't start moving yet
+	if ( next->wait ) 
+	{
+		ent->nextthink = level.time + next->wait * 1000;
+		ent->e_ThinkFunc = thinkF_Think_BeginMoving;
+		ent->s.pos.trType = TR_STATIONARY;
+	}
+	else if (!( next->spawnflags & 2 ))
+	{
+		// we aren't waiting to start, so let us draw right away
+		ent->s.eFlags &= ~EF_NODRAW;
+	}
+}
+
+void TrainUse( gentity_t *ent, gentity_t *other, gentity_t *activator )
+{
+	Reached_Train( ent );
+}
+
+/*
+===============
+Think_SetupTrainTargets
+
+Link all the corners together
+===============
+*/
+void Think_SetupTrainTargets( gentity_t *ent ) {
+	gentity_t		*path, *next, *start;
+
+	ent->nextTrain = G_Find( NULL, FOFS(targetname), ent->target );
+	if ( !ent->nextTrain ) {
+		gi.Printf( "func_train at %s with an unfound target\n", vtos(ent->absmin) );
+		//Free me?`
+		return;
+	}
+
+	//FIXME: this can go into an infinite loop if last path_corner doesn't link to first
+	//path_corner, like so:
+	// t1---->t2---->t3
+	//         ^      |
+	//          \_____|
+	start = NULL;
+	next = NULL;
+	int iterations = 2000;	//max attempts to find our path start
+	for ( path = ent->nextTrain ; path != start ; path = next ) {
+		if (!iterations--)
+		{
+			G_Error( "Think_SetupTrainTargets:  last path_corner doesn't link back to first on func_train(%s)", vtos(ent->absmin) );
+		}
+		if (!start)
+		{
+			start = path;
+		}
+		if ( !path->target ) {
+//			gi.Printf( "Train corner at %s without a target\n", vtos(path->s.origin) );
+			//end of path
+			break;
+		}
+
+		// find a path_corner among the targets
+		// there may also be other targets that get fired when the corner
+		// is reached
+		next = NULL;
+		do {
+			next = G_Find( next, FOFS(targetname), path->target );
+			if ( !next ) {
+//				gi.Printf( "Train corner at %s without a target path_corner\n", vtos(path->s.origin) );
+				//end of path
+				break;
+			}
+		} while ( strcmp( next->classname, "path_corner" ) );
+
+		if ( next )
+		{
+			path->nextTrain = next;
+		}
+		else
+		{
+			break;
+		}
+	}
+
+	if ( !ent->targetname || (ent->spawnflags&1) /*start on*/)
+	{
+		// start the train moving from the first corner
+		Reached_Train( ent );
+	}
+	else
+	{
+		G_SetOrigin( ent, ent->s.origin );
+	}
+}
+
+
+
+/*QUAKED path_corner (.5 .3 0) (-8 -8 -8) (8 8 8) TURN_TRAIN INVISIBLE YAW_TRAIN ROLL_TRAIN
+
+TURN_TRAIN	func_train moving on this path will turn to face the next path_corner within 2 seconds
+INVISIBLE - train will become invisible ( but still solid ) when it reaches this path_corner.  
+		It will become visible again at the next path_corner that does not have this option checked
+
+Train path corners.
+Target: next path corner and other targets to fire
+"speed" speed to move to the next corner
+"wait" seconds to wait before behining move to next corner
+*/
+void SP_path_corner( gentity_t *self ) {
+	if ( !self->targetname ) {
+		gi.Printf ("path_corner with no targetname at %s\n", vtos(self->s.origin));
+		G_FreeEntity( self );
+		return;
+	}
+	// path corners don't need to be linked in
+	VectorCopy(self->s.origin, self->currentOrigin);
+}
+
+
+void func_train_die( gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int mod, int dFlags, int hitLoc )
+{
+	if ( self->target3 )
+	{
+		G_UseTargets2( self, self, self->target3 );
+	}
+
+	//HACKHACKHACKHACK
+	G_PlayEffect( "explosions/fighter_explosion2", self->currentOrigin );
+	G_FreeEntity( self );
+	//HACKHACKHACKHACK
+}
+
+/*QUAKED func_train (0 .5 .8) ? START_ON TOGGLE BLOCK_STOPS x x LOOP PLAYER_USE INACTIVE TIE
+
+LOOP - if it's a ghoul2 model, it will just loop the animation
+PLAYER_USE	Player can use it with the use button
+INACTIVE	must be used by a target_activate before it can be used
+TIE  flying Tie-fighter hack, should be made more flexible so other things can use this if needed
+
+A train is a mover that moves between path_corner target points.
+Trains MUST HAVE AN ORIGIN BRUSH.
+The train spawns at the first target it is pointing at.
+"model2"	.md3 model to also draw
+"modelAngles" md3 model's angles <pitch yaw roll> (in addition to any rotation on the part of the brush entity itself)
+"speed"		default 100
+"dmg"		default	2
+"health"	default 0
+"noise"		looping sound to play when the train is in motion
+"targetname" will not start until used
+"target"	next path corner
+"target3" what to use when it breaks
+"color"		constantLight color
+"light"		constantLight radius
+"linear" set to 1 and it will move linearly rather than with acceleration (default is 0)
+"startframe" default 0...ghoul2 animation start frame
+"endframe" default 0...ghoul2 animation end frame
+*/
+void SP_func_train (gentity_t *self) {
+	VectorClear (self->s.angles);
+
+	if (self->spawnflags & TRAIN_BLOCK_STOPS) {
+		self->damage = 0;
+	} else {
+		if (!self->damage) {
+			self->damage = 2;
+		}
+	}
+
+	if ( !self->speed ) {
+		self->speed = 100;
+	}
+
+	if ( !self->target ) {
+		gi.Printf ("func_train without a target at %s\n", vtos(self->absmin));
+		G_FreeEntity( self );
+		return;
+	}
+
+	char *noise;
+
+	G_SpawnInt( "startframe", "0", &self->startFrame );
+	G_SpawnInt( "endframe", "0", &self->endFrame );
+
+	if ( G_SpawnString( "noise", "", &noise ) )
+	{
+		if ( VALIDSTRING( noise ) )
+		{
+			self->s.loopSound = cgi_S_RegisterSound( noise );//G_SoundIndex( noise );
+		}
+	}
+
+	gi.SetBrushModel( self, self->model );
+	InitMover( self );
+
+	if ( self->spawnflags & 2048 ) // TIE HACK
+	{
+		//HACKHACKHACKHACKHACKHACKHACKHACKHACKHACKHACKHACKHACKHACKHACKHACKHACKHACKHACKHACK
+		self->s.modelindex2 = G_ModelIndex( "models/map_objects/ships/tie_fighter.md3" );
+		G_EffectIndex( "explosions/fighter_explosion2" );
+
+		self->contents = CONTENTS_SHOTCLIP;
+		self->takedamage = qtrue;
+		VectorSet( self->maxs, 112, 112, 112 );
+		VectorSet( self->mins, -112, -112, -112 );
+		self->e_DieFunc  = dieF_func_train_die;
+		gi.linkentity( self );
+		//HACKHACKHACKHACKHACKHACKHACKHACKHACKHACKHACKHACKHACKHACKHACKHACKHACKHACKHACKHACK
+	}
+
+	if ( self->targetname )
+	{
+		self->e_UseFunc = useF_TrainUse;
+	}
+
+	self->e_ReachedFunc = reachedF_Reached_Train;
+
+	// start trains on the second frame, to make sure their targets have had
+	// a chance to spawn
+	self->nextthink = level.time + START_TIME_LINK_ENTS;
+	self->e_ThinkFunc = thinkF_Think_SetupTrainTargets;
+
+
+	if ( self->playerModel >= 0 && self->spawnflags & 32 ) // loop...dunno, could support it on other things, but for now I need it for the glider...so...kill the flag
+	{
+		self->spawnflags &= ~32; // once only
+
+		gi.G2API_SetBoneAnim( &self->ghoul2[self->playerModel], "model_root", self->startFrame, self->endFrame, BONE_ANIM_OVERRIDE_LOOP, 1.0f + crandom() * 0.1f, 0 );
+		self->endFrame = 0; // don't allow it to do anything with the animation function in G_main
+	}
+}
+
+/*
+===============================================================================
+
+STATIC
+
+===============================================================================
+*/
+
+/*QUAKED func_static (0 .5 .8) ? F_PUSH F_PULL SWITCH_SHADER CRUSHER IMPACT SOLITARY PLAYER_USE INACTIVE BROADCAST
+F_PUSH		Will be used when you Force-Push it
+F_PULL		Will be used when you Force-Pull it
+SWITCH_SHADER	Toggle the shader anim frame between 1 and 2 when used
+CRUSHER		Make it do damage when it's blocked
+IMPACT		Make it do damage when it hits any entity
+SOLITARY	Can only be pushed when directly under crosshair, when pushed you shall push nothing else BUT me.
+PLAYER_USE	Player can use it with the use button
+INACTIVE	must be used by a target_activate before it can be used
+BROADCAST   don't ever use this, it's evil
+
+A bmodel that just sits there, doing nothing.  Can be used for conditional walls and models.
+"model2"	.md3 model to also draw
+"modelAngles" md3 model's angles <pitch yaw roll> (in addition to any rotation on the part of the brush entity itself)
+"color"		constantLight color
+"light"		constantLight radius
+"dmg"		how much damage to do when it crushes (use with CRUSHER spawnflag default is 2)
+"linear" set to 1 and it will move linearly rather than with acceleration (default is 0)
+"NPC_targetname" if set up to be push/pullable, only this NPC can push/pull it (for the player, use "player")
+*/
+void SP_func_static( gentity_t *ent ) 
+{
+	gi.SetBrushModel( ent, ent->model );
+
+	VectorCopy( ent->s.origin, ent->pos1 );
+	VectorCopy( ent->s.origin, ent->pos2 );
+
+	InitMover( ent );
+
+	G_SetOrigin( ent, ent->s.origin );
+	G_SetAngles( ent, ent->s.angles );
+
+	ent->e_UseFunc = useF_func_static_use;
+	ent->e_ReachedFunc = reachedF_NULL;
+
+
+	if( ent->spawnflags & 2048 )
+	{								   // yes this is very very evil, but for now (pre-alpha) it's a solution
+		ent->svFlags |= SVF_BROADCAST; // I need to rotate something that is huge and it's touching too many area portals...
+	}
+
+	if ( ent->spawnflags & 4/*SWITCH_SHADER*/ )
+	{
+		ent->s.eFlags |= EF_SHADER_ANIM;//use frame-controlled shader anim
+		ent->s.frame = 0;//first stage of anim
+		ent->spawnflags &= ~4;//this is the CRUSHER spawnflag!  remove it!
+	}
+	if ( ent->spawnflags & 8 )
+	{//!!! 8 is NOT the crusher spawnflag, 4 is!!!
+		ent->spawnflags &= ~8;
+		ent->spawnflags |= MOVER_CRUSHER;
+		if ( !ent->damage )
+		{
+			ent->damage = 2;
+		}
+	}
+	gi.linkentity( ent );
+
+	if (level.mBSPInstanceDepth)
+	{	// this means that this guy will never be updated, moved, changed, etc.
+		ent->s.eFlags = EF_PERMANENT;
+	}
+}
+
+void func_static_use ( gentity_t *self, gentity_t *other, gentity_t *activator )
+{
+	G_ActivateBehavior( self, BSET_USE );
+
+	if ( self->spawnflags & 4/*SWITCH_SHADER*/ )
+	{
+		self->s.frame = self->s.frame ? 0 : 1;//toggle frame
+	}
+	G_UseTargets( self, activator );
+}
+
+/*
+===============================================================================
+
+ROTATING
+
+===============================================================================
+*/
+void func_rotating_touch( gentity_t *self, gentity_t *other, trace_t *trace ) 
+{
+//	vec3_t spot;
+//	gentity_t	*tent;
+	if( !other->client ) // don't want to disintegrate items or weapons, etc...
+	{
+		return;
+	}
+	// yeah, this is a bit hacky...
+	if(	self->s.apos.trType != TR_STATIONARY && !(other->flags & FL_DISINTEGRATED) ) // only damage if it's moving
+	{
+//		VectorCopy( self->currentOrigin, spot );
+//		tent = G_TempEntity( spot, EV_DISINTEGRATION );
+//		tent->s.eventParm = PW_DISRUPTION;
+//		tent->owner = self;
+		// let G_Damage call the fx instead, beside, this way you can disintegrate a corpse this way
+		G_Sound( other, G_SoundIndex( "sound/effects/energy_crackle.wav" ) );
+		G_Damage( other, self, self, NULL, NULL, 10000, DAMAGE_NO_KNOCKBACK, MOD_SNIPER );			
+	}
+}
+
+
+void func_rotating_use( gentity_t *self, gentity_t *other, gentity_t *activator )
+{
+	if(	self->s.apos.trType == TR_LINEAR )
+	{
+		self->s.apos.trType = TR_STATIONARY;
+		// stop the sound if it stops moving
+		self->s.loopSound = 0;
+		// play stop sound too?
+		if ( VALIDSTRING( self->soundSet ) == true )
+		{
+			G_AddEvent( self, EV_BMODEL_SOUND, CAS_GetBModelSound( self->soundSet, BMS_END ));
+		}
+	}
+	else
+	{
+		if ( VALIDSTRING( self->soundSet ) == true )
+		{
+			G_AddEvent( self, EV_BMODEL_SOUND, CAS_GetBModelSound( self->soundSet, BMS_START ));
+			self->s.loopSound = CAS_GetBModelSound( self->soundSet, BMS_MID );
+			if ( self->s.loopSound < 0 )
+			{
+				self->s.loopSound = 0;
+			}
+		}
+		self->s.apos.trType = TR_LINEAR;
+	}
+}
+
+
+/*QUAKED func_rotating (0 .5 .8) ? START_ON TOUCH_KILL X_AXIS Y_AXIS x x PLAYER_USE INACTIVE
+PLAYER_USE	Player can use it with the use button
+TOUCH_KILL  Inflicts massive damage upon touching it, disitegrates bodies
+INACTIVE	must be used by a target_activate before it can be used
+
+You need to have an origin brush as part of this entity.  The center of that brush will be
+the point around which it is rotated. It will rotate around the Z axis by default.  You can
+check either the X_AXIS or Y_AXIS box to change that.
+
+"model2"	.md3 model to also draw
+"modelAngles" md3 model's angles <pitch yaw roll> (in addition to any rotation on the part of the brush entity itself)
+"speed"		determines how fast it moves; default value is 100.
+"dmg"		damage to inflict when blocked (2 default)
+"color"		constantLight color
+"light"		constantLight radius
+*/
+void SP_func_rotating (gentity_t *ent) {
+	if ( !ent->speed ) {
+		ent->speed = 100;
+	}
+
+
+	ent->s.apos.trType = TR_STATIONARY;
+	if( ent->spawnflags & 1 )	// start on
+	{
+		ent->s.apos.trType = TR_LINEAR;
+	}
+	// set the axis of rotation
+	if ( ent->spawnflags & 4 ) {
+		ent->s.apos.trDelta[2] = ent->speed;
+	} else if ( ent->spawnflags & 8 ) {
+		ent->s.apos.trDelta[0] = ent->speed;
+	} else {
+		ent->s.apos.trDelta[1] = ent->speed;
+	}
+
+	if (!ent->damage) {
+		ent->damage = 2;
+	}
+
+
+	gi.SetBrushModel( ent, ent->model );
+	InitMover( ent );
+	
+	if ( ent->targetname )
+	{
+		ent->e_UseFunc = useF_func_rotating_use;
+	}
+	
+	VectorCopy( ent->s.origin, ent->s.pos.trBase );
+	VectorCopy( ent->s.pos.trBase, ent->currentOrigin );
+	VectorCopy( ent->s.apos.trBase, ent->currentAngles );
+	if( ent->spawnflags & 2 )
+	{
+		ent->e_TouchFunc = touchF_func_rotating_touch;
+		G_SoundIndex( "sound/effects/energy_crackle.wav" );
+	}
+
+	gi.linkentity( ent );
+}
+
+
+/*
+===============================================================================
+
+BOBBING
+
+===============================================================================
+*/
+
+void func_bobbing_use( gentity_t *self, gentity_t *other, gentity_t *activator )
+{
+	// Toggle our move state
+	if ( self->s.pos.trType == TR_SINE )
+	{
+		self->s.pos.trType = TR_INTERPOLATE;
+
+		// Save off roughly where we were
+		VectorCopy( self->currentOrigin, self->s.pos.trBase );
+		// Store the current phase value so we know how to start up where we left off.
+		self->radius = ( level.time - self->s.pos.trTime ) / (float)self->s.pos.trDuration;
+	}
+	else
+	{
+		self->s.pos.trType = TR_SINE;
+
+		// Set the time based on the saved phase value
+		self->s.pos.trTime = level.time - self->s.pos.trDuration * self->radius;
+		// Always make sure we are starting with a fresh base
+		VectorCopy( self->s.origin, self->s.pos.trBase );
+	}
+}
+
+/*QUAKED func_bobbing (0 .5 .8) ? X_AXIS Y_AXIS START_OFF x x x PLAYER_USE INACTIVE
+PLAYER_USE	Player can use it with the use button
+INACTIVE	must be used by a target_activate before it can be used
+
+Normally bobs on the Z axis
+"model2"	.md3 model to also draw
+"modelAngles" md3 model's angles <pitch yaw roll> (in addition to any rotation on the part of the brush entity itself)
+"height"	amplitude of bob (32 default)
+"speed"		seconds to complete a bob cycle (4 default)
+"phase"		the 0.0 to 1.0 offset in the cycle to start at
+"dmg"		damage to inflict when blocked (2 default)
+"color"		constantLight color
+"light"		constantLight radius
+"targetname" turns on/off when used
+*/
+void SP_func_bobbing (gentity_t *ent) {
+	float		height;
+	float		phase;
+
+	G_SpawnFloat( "speed", "4", &ent->speed );
+	G_SpawnFloat( "height", "32", &height );
+	G_SpawnInt( "dmg", "2", &ent->damage );
+	G_SpawnFloat( "phase", "0", &phase );
+
+	gi.SetBrushModel( ent, ent->model );
+	InitMover( ent );
+
+	VectorCopy( ent->s.origin, ent->s.pos.trBase );
+	VectorCopy( ent->s.origin, ent->currentOrigin );
+
+	// set the axis of bobbing
+	if ( ent->spawnflags & 1 ) {
+		ent->s.pos.trDelta[0] = height;
+	} else if ( ent->spawnflags & 2 ) {
+		ent->s.pos.trDelta[1] = height;
+	} else {
+		ent->s.pos.trDelta[2] = height;
+	}
+
+	ent->s.pos.trDuration = ent->speed * 1000;
+	ent->s.pos.trTime = ent->s.pos.trDuration * phase;
+
+	if ( ent->spawnflags & 4 ) // start_off
+	{
+		ent->s.pos.trType = TR_INTERPOLATE;
+
+		// Now use the phase to calculate where it should be at the start.
+		ent->radius = phase;
+		phase = (float)sin( phase * M_PI * 2 );
+		VectorMA( ent->s.pos.trBase, phase, ent->s.pos.trDelta, ent->s.pos.trBase );
+
+		if ( ent->targetname )
+		{
+			ent->e_UseFunc = useF_func_bobbing_use;
+		}
+	}
+	else
+	{
+		ent->s.pos.trType = TR_SINE;
+	}
+}
+
+/*
+===============================================================================
+
+PENDULUM
+
+===============================================================================
+*/
+
+
+/*QUAKED func_pendulum (0 .5 .8) ? x x x x x x PLAYER_USE INACTIVE
+PLAYER_USE	Player can use it with the use button
+INACTIVE	must be used by a target_activate before it can be used
+
+You need to have an origin brush as part of this entity.
+Pendulums always swing north / south on unrotated models.  Add an angles field to the model to allow rotation in other directions.
+Pendulum frequency is a physical constant based on the length of the beam and gravity.
+"model2"	.md3 model to also draw
+"modelAngles" md3 model's angles <pitch yaw roll> (in addition to any rotation on the part of the brush entity itself)
+"speed"		the number of degrees each way the pendulum swings, (30 default)
+"phase"		the 0.0 to 1.0 offset in the cycle to start at
+"dmg"		damage to inflict when blocked (2 default)
+"color"		constantLight color
+"light"		constantLight radius
+*/
+void SP_func_pendulum(gentity_t *ent) {
+	float		freq;
+	float		length;
+	float		phase;
+	float		speed;
+
+	G_SpawnFloat( "speed", "30", &speed );
+	G_SpawnInt( "dmg", "2", &ent->damage );
+	G_SpawnFloat( "phase", "0", &phase );
+
+	gi.SetBrushModel( ent, ent->model );
+
+	// find pendulum length
+	length = fabs( ent->mins[2] );
+	if ( length < 8 ) {
+		length = 8;
+	}
+
+	freq = 1 / ( M_PI * 2 ) * sqrt( g_gravity->value / ( 3 * length ) );
+
+	ent->s.pos.trDuration = ( 1000 / freq );
+
+	InitMover( ent );
+
+	VectorCopy( ent->s.origin, ent->s.pos.trBase );
+	VectorCopy( ent->s.origin, ent->currentOrigin );
+
+	VectorCopy( ent->s.angles, ent->s.apos.trBase );
+
+	ent->s.apos.trDuration = 1000 / freq;
+	ent->s.apos.trTime = ent->s.apos.trDuration * phase;
+	ent->s.apos.trType = TR_SINE;
+
+	ent->s.apos.trDelta[2] = speed;
+}
+
+/*
+===============================================================================
+
+WALL
+
+===============================================================================
+*/
+
+//static -slc
+void use_wall( gentity_t *ent, gentity_t *other, gentity_t *activator )
+{
+	G_ActivateBehavior(ent,BSET_USE);
+
+	// Not there so make it there
+	//if (!(ent->contents & CONTENTS_SOLID))
+	if (!ent->count) // off
+	{
+		ent->svFlags &= ~SVF_NOCLIENT;
+		ent->s.eFlags &= ~EF_NODRAW;
+		ent->count = 1;
+		//NOTE: reset the brush model because we need to get *all* the contents back
+		//ent->contents |= CONTENTS_SOLID;
+		gi.SetBrushModel( ent, ent->model );
+		if ( !(ent->spawnflags&1) )
+		{//START_OFF doesn't effect area portals
+			gi.AdjustAreaPortalState( ent, qfalse );
+		}
+	}
+	// Make it go away
+	else
+	{
+		//NOTE: MUST do this BEFORE clearing contents, or you may not open the area portal!!!
+		if ( !(ent->spawnflags&1) )
+		{//START_OFF doesn't effect area portals
+			gi.AdjustAreaPortalState( ent, qtrue );
+		}
+		ent->contents = 0;
+		ent->svFlags |= SVF_NOCLIENT;
+		ent->s.eFlags |= EF_NODRAW;
+		ent->count = 0; // off
+	}
+}
+
+#define FUNC_WALL_OFF	1
+#define FUNC_WALL_ANIM	2
+
+
+/*QUAKED func_wall (0 .5 .8) ? START_OFF AUTOANIMATE x x x x PLAYER_USE INACTIVE
+PLAYER_USE	Player can use it with the use button
+INACTIVE	must be used by a target_activate before it can be used
+
+A bmodel that just sits there, doing nothing.  Can be used for conditional walls and models.
+"model2"	.md3 model to also draw
+"modelAngles" md3 model's angles <pitch yaw roll> (in addition to any rotation on the part of the brush entity itself)
+"color"		constantLight color
+"light"		constantLight radius
+
+START_OFF - the wall will not be there
+AUTOANIMATE - if a model is used it will animate				
+*/
+void SP_func_wall( gentity_t *ent ) 
+{
+	gi.SetBrushModel( ent, ent->model );
+
+	VectorCopy( ent->s.origin, ent->pos1 );
+	VectorCopy( ent->s.origin, ent->pos2 );
+
+	InitMover( ent );
+	VectorCopy( ent->s.origin, ent->s.pos.trBase );
+	VectorCopy( ent->s.origin, ent->currentOrigin );
+
+	// count is used as an on/off switch (start it on)
+	ent->count = 1;
+
+	// it must be START_OFF
+	if (ent->spawnflags & FUNC_WALL_OFF)
+	{
+		ent->spawnContents = ent->contents;
+		ent->contents = 0;
+		ent->svFlags |= SVF_NOCLIENT;
+		ent->s.eFlags |= EF_NODRAW;
+		// turn it off
+		ent->count = 0;
+	}
+
+	if (!(ent->spawnflags & FUNC_WALL_ANIM))
+	{
+		ent->s.eFlags |= EF_ANIM_ALLFAST;
+	}
+	ent->e_UseFunc = useF_use_wall;
+
+	gi.linkentity (ent);
+
+}
+
+
+void security_panel_use( gentity_t *self, gentity_t *other, gentity_t *activator )
+{
+	if ( !activator )
+	{
+		return;
+	}
+	if ( INV_SecurityKeyCheck( activator, self->message ) )
+	{//congrats!
+		gi.SendServerCommand( NULL, "cp @SP_INGAME_SECURITY_KEY_UNLOCKEDDOOR" );
+		//use targets
+		G_UseTargets( self, activator );
+		//take key
+		INV_SecurityKeyTake( activator, self->message );
+		if ( activator->ghoul2.size() )
+		{
+			gi.G2API_SetSurfaceOnOff( &activator->ghoul2[activator->playerModel], "l_arm_key", 0x00000002 );
+		}
+		//FIXME: maybe set frame on me to have key sticking out?
+		//self->s.frame = 1;
+		//play sound
+		G_Sound( self, self->soundPos2 );
+		//unusable
+		self->e_UseFunc = useF_NULL;
+	}
+	else
+	{//failure sound/display
+		if ( activator->message )
+		{//have a key, just the wrong one
+			gi.SendServerCommand( NULL, "cp @SP_INGAME_INCORRECT_KEY" );
+		}
+		else
+		{//don't have a key at all
+			gi.SendServerCommand( NULL, "cp @SP_INGAME_NEED_SECURITY_KEY" );
+		}
+		G_UseTargets2( self, activator, self->target2 );
+		//FIXME: change display?  Maybe shader animmap change?
+		//play sound
+		G_Sound( self, self->soundPos1 );
+	}
+}
+
+/*QUAKED misc_security_panel (0 .5 .8) (-8 -8 -8) (8 8 8) x x x x x x x INACTIVE
+model="models/map_objects/kejim/sec_panel.md3"
+  A model that just sits there and opens when a player uses it and has right key
+
+INACTIVE - Start off, has to be activated to be usable
+
+"message"	name of the key player must have
+"target"	thing to use when successfully opened
+"target2"	thing to use when player uses the panel without the key
+*/
+void SP_misc_security_panel ( gentity_t *self )
+{
+	self->s.modelindex = G_ModelIndex( "models/map_objects/kejim/sec_panel.md3" );
+	self->soundPos1 = G_SoundIndex( "sound/movers/sec_panel_fail.mp3" );
+	self->soundPos2 = G_SoundIndex( "sound/movers/sec_panel_pass.mp3" );
+	G_SetOrigin( self, self->s.origin );
+	G_SetAngles( self, self->s.angles );
+	VectorSet( self->mins, -8, -8, -8 );
+	VectorSet( self->maxs, 8, 8, 8 );
+	self->contents = CONTENTS_SOLID;
+	gi.linkentity( self );
+
+	//NOTE: self->message is the key
+	self->svFlags |= SVF_PLAYER_USABLE;
+	if(self->spawnflags & 128)
+	{
+		self->svFlags |= SVF_INACTIVE;
+	}
+	self->e_UseFunc = useF_security_panel_use;
+}
\ No newline at end of file
diff --git a/code/game/g_nav.cpp b/code/game/g_nav.cpp
new file mode 100644
index 0000000..183159e
--- /dev/null
+++ b/code/game/g_nav.cpp
@@ -0,0 +1,407 @@
+// leave this line at the top for all g_xxxx.cpp files...
+#include "g_headers.h"
+
+
+#include "b_local.h"
+#include "g_nav.h"
+#include "g_navigator.h"
+
+//Global navigator
+//CNavigator		navigator;
+
+extern qboolean G_EntIsUnlockedDoor( int entityNum );
+extern qboolean G_EntIsDoor( int entityNum );
+extern qboolean G_EntIsRemovableUsable( int entNum );
+extern qboolean G_FindClosestPointOnLineSegment( const vec3_t start, const vec3_t end, const vec3_t from, vec3_t result );
+extern void G_AddVoiceEvent( gentity_t *self, int event, int speakDebounceTime );
+//For debug graphics
+extern void CG_Line( vec3_t start, vec3_t end, vec3_t color, float alpha );
+extern void CG_Cube( vec3_t mins, vec3_t maxs, vec3_t color, float alpha );
+extern void CG_CubeOutline( vec3_t mins, vec3_t maxs, int time, unsigned int color, float alpha );
+extern qboolean FlyingCreature( gentity_t *ent );
+
+
+extern vec3_t NPCDEBUG_RED;
+
+
+/*
+-------------------------
+NPC_SetMoveGoal
+-------------------------
+*/
+
+void NPC_SetMoveGoal( gentity_t *ent, vec3_t point, int radius, qboolean isNavGoal, int combatPoint, gentity_t *targetEnt )
+{
+	//Must be an NPC
+	if ( ent->NPC == NULL )
+	{
+		return;
+	}
+
+	if ( ent->NPC->tempGoal == NULL )
+	{//must still have a goal
+		return;
+	}
+
+	//Copy the origin
+	//VectorCopy( point, ent->NPC->goalPoint );	//FIXME: Make it use this, and this alone!
+	VectorCopy( point, ent->NPC->tempGoal->currentOrigin );
+	
+	//Copy the mins and maxs to the tempGoal
+	VectorCopy( ent->mins, ent->NPC->tempGoal->mins );
+	VectorCopy( ent->mins, ent->NPC->tempGoal->maxs );
+
+	//FIXME: TESTING let's try making sure the tempGoal isn't stuck in the ground?
+	if ( 0 )
+	{
+		trace_t	trace;
+		vec3_t	bottom = {ent->NPC->tempGoal->currentOrigin[0],ent->NPC->tempGoal->currentOrigin[1],ent->NPC->tempGoal->currentOrigin[2]+ent->NPC->tempGoal->mins[2]};
+		gi.trace( &trace, ent->NPC->tempGoal->currentOrigin, vec3_origin, vec3_origin, bottom, ent->s.number, ent->clipmask );
+		if ( trace.fraction < 1.0f )
+		{//in the ground, raise it up
+			ent->NPC->tempGoal->currentOrigin[2] -= ent->NPC->tempGoal->mins[2]*(1.0f-trace.fraction)-0.125f;
+		}
+	}
+
+	ent->NPC->tempGoal->target = NULL;
+	ent->NPC->tempGoal->clipmask = ent->clipmask;
+	ent->NPC->tempGoal->svFlags &= ~SVF_NAVGOAL;
+	if ( targetEnt && targetEnt->waypoint >= 0 )
+	{
+		ent->NPC->tempGoal->waypoint = targetEnt->waypoint;
+	}
+	else
+	{
+		ent->NPC->tempGoal->waypoint = WAYPOINT_NONE;
+	}
+	ent->NPC->tempGoal->noWaypointTime = 0;
+
+	if ( isNavGoal )
+	{
+		assert(ent->NPC->tempGoal->owner);
+		ent->NPC->tempGoal->svFlags |= SVF_NAVGOAL;
+	}
+
+	ent->NPC->tempGoal->combatPoint = combatPoint;
+	ent->NPC->tempGoal->enemy = targetEnt;
+
+	ent->NPC->goalEntity = ent->NPC->tempGoal;
+	ent->NPC->goalRadius = radius;
+	ent->NPC->aiFlags	&= ~NPCAI_STOP_AT_LOS;
+
+	gi.linkentity( ent->NPC->goalEntity );
+}
+/*
+-------------------------
+waypoint_testDirection
+-------------------------
+*/
+
+static float waypoint_testDirection( vec3_t origin, float yaw, float minDist )
+{
+	vec3_t	trace_dir, test_pos;
+	vec3_t	maxs, mins;
+	trace_t	tr;
+
+	//Setup the mins and max
+	VectorSet( maxs, DEFAULT_MAXS_0, DEFAULT_MAXS_1, DEFAULT_MAXS_2 );
+	VectorSet( mins, DEFAULT_MINS_0, DEFAULT_MINS_1, DEFAULT_MINS_2 + STEPSIZE );
+
+	//Get our test direction
+	vec3_t	angles = { 0, yaw, 0 };
+	AngleVectors( angles, trace_dir, NULL, NULL );
+
+	//Move ahead
+	VectorMA( origin, minDist, trace_dir, test_pos );
+
+	gi.trace( &tr, origin, mins, maxs, test_pos, ENTITYNUM_NONE, ( CONTENTS_SOLID | CONTENTS_MONSTERCLIP | CONTENTS_BOTCLIP ) );
+
+	return ( minDist * tr.fraction );	//return actual dist completed
+}
+
+/*
+-------------------------
+waypoint_getRadius
+-------------------------
+*/
+
+static float waypoint_getRadius( gentity_t *ent )
+{
+	float	minDist = MAX_RADIUS_CHECK + 1; // (unsigned int) -1;
+	float	dist;
+
+	for ( int i = 0; i < YAW_ITERATIONS; i++ )
+	{
+		dist = waypoint_testDirection( ent->currentOrigin, ((360.0f/YAW_ITERATIONS) * i), minDist );
+
+		if ( dist < minDist )
+			minDist = dist;
+	}
+
+	return minDist + DEFAULT_MAXS_0;
+}
+
+/*QUAKED waypoint  (0.7 0.7 0) (-20 -20 -24) (20 20 45) SOLID_OK DROP_TO_FLOOR
+a place to go.
+
+SOLID_OK - only use if placing inside solid is unavoidable in map, but may be clear in-game (ie: at the bottom of a tall, solid lift that starts at the top position)
+DROP_TO_FLOOR - will cause the point to auto drop to the floor
+
+radius is automatically calculated in-world.
+"targetJump" is a special edge that only guys who can jump will cross (so basically Jedi)
+*/
+extern int delayedShutDown;
+void SP_waypoint ( gentity_t *ent )
+{
+		VectorSet(ent->mins, DEFAULT_MINS_0, DEFAULT_MINS_1, DEFAULT_MINS_2);
+		VectorSet(ent->maxs, DEFAULT_MAXS_0, DEFAULT_MAXS_1, DEFAULT_MAXS_2);
+		
+		ent->contents = CONTENTS_TRIGGER;
+		ent->clipmask = MASK_DEADSOLID;
+
+		gi.linkentity( ent );
+
+		ent->count = -1;
+		ent->classname = "waypoint";
+
+		if (ent->spawnflags&2)
+		{
+			ent->currentOrigin[2] += 128.0f;
+		}
+
+		if( !(ent->spawnflags&1) && G_CheckInSolid (ent, qtrue))
+		{//if not SOLID_OK, and in solid
+			ent->maxs[2] = CROUCH_MAXS_2;
+			if(G_CheckInSolid (ent, qtrue))
+			{
+				gi.Printf(S_COLOR_RED"ERROR: Waypoint %s at %s in solid!\n", ent->targetname, vtos(ent->currentOrigin));
+				assert(0 && "Waypoint in solid!");
+//				if (!g_entities[ENTITYNUM_WORLD].s.radius){	//not a region
+//					G_Error("Waypoint %s at %s in solid!\n", ent->targetname, vtos(ent->currentOrigin));
+//				}
+				delayedShutDown = level.time + 100;
+				G_FreeEntity(ent);
+				return;
+			}
+		}
+
+		//G_SpawnString("targetJump", "", &ent->targetJump);
+		ent->radius = waypoint_getRadius( ent );
+		NAV::SpawnedPoint(ent);
+
+		G_FreeEntity(ent);
+		return;
+}
+
+/*QUAKED waypoint_small  (0.7 0.7 0) (-2 -2 -24) (2 2 32) SOLID_OK
+SOLID_OK - only use if placing inside solid is unavoidable in map, but may be clear in-game (ie: at the bottom of a tall, solid lift that starts at the top position)
+DROP_TO_FLOOR - will cause the point to auto drop to the floor
+*/
+void SP_waypoint_small (gentity_t *ent)
+{
+		VectorSet(ent->mins, -2, -2, DEFAULT_MINS_2);
+		VectorSet(ent->maxs, 2, 2, DEFAULT_MAXS_2);
+
+		ent->contents = CONTENTS_TRIGGER;
+		ent->clipmask = MASK_DEADSOLID;
+
+		gi.linkentity( ent );
+
+		ent->count = -1;
+		ent->classname = "waypoint";
+
+		if ( !(ent->spawnflags&1) && G_CheckInSolid( ent, qtrue ) )
+		{
+			ent->maxs[2] = CROUCH_MAXS_2;
+			if ( G_CheckInSolid( ent, qtrue ) )
+			{
+				gi.Printf(S_COLOR_RED"ERROR: Waypoint_small %s at %s in solid!\n", ent->targetname, vtos(ent->currentOrigin));
+				assert(0);
+#ifndef FINAL_BUILD
+				if (!g_entities[ENTITYNUM_WORLD].s.radius){	//not a region
+					G_Error("Waypoint_small %s at %s in solid!\n", ent->targetname, vtos(ent->currentOrigin));
+				}
+#endif
+				G_FreeEntity(ent);
+				return;
+			}
+		}
+
+		ent->radius = 2;	// radius
+		NAV::SpawnedPoint(ent);
+
+		G_FreeEntity(ent);
+		return;
+}
+
+
+/*QUAKED waypoint_navgoal (0.3 1 0.3) (-20 -20 -24) (20 20 40) SOLID_OK DROP_TO_FLOOR NO_AUTO_CONNECT
+A waypoint for script navgoals
+Not included in navigation data
+
+DROP_TO_FLOOR - will cause the point to auto drop to the floor
+NO_AUTO_CONNECT - will not automatically connect to any other points, you must then connect it by hand
+
+
+SOLID_OK - only use if placing inside solid is unavoidable in map, but may be clear in-game (ie: at the bottom of a tall, solid lift that starts at the top position)
+
+targetname - name you would use in script when setting a navgoal (like so:)
+
+  For example: if you give this waypoint a targetname of "console", make an NPC go to it in a script like so:
+
+  set ("navgoal", "console");
+
+radius - how far from the navgoal an ent can be before it thinks it reached it - default is "0" which means no radius check, just have to touch it
+
+*/
+
+void SP_waypoint_navgoal( gentity_t *ent )
+{
+	int radius = ( ent->radius ) ? (ent->radius) : 12;
+
+	VectorSet( ent->mins, -16, -16, -24 );
+	VectorSet( ent->maxs, 16, 16, 32 );
+	ent->s.origin[2] += 0.125;
+	if ( !(ent->spawnflags&1) && G_CheckInSolid( ent, qfalse ) )
+	{
+		gi.Printf(S_COLOR_RED"ERROR: Waypoint_navgoal %s at %s in solid!\n", ent->targetname, vtos(ent->currentOrigin));
+		assert(0);
+#ifndef FINAL_BUILD
+		if (!g_entities[ENTITYNUM_WORLD].s.radius){	//not a region
+			G_Error("Waypoint_navgoal %s at %s in solid!\n", ent->targetname, vtos(ent->currentOrigin));
+		}
+#endif
+	}
+	TAG_Add( ent->targetname, NULL, ent->s.origin, ent->s.angles, radius, RTF_NAVGOAL );
+
+	ent->classname = "navgoal";
+	
+	NAV::SpawnedPoint(ent, NAV::PT_GOALNODE);
+
+	G_FreeEntity( ent );//can't do this, they need to be found later by some functions, though those could be fixed, maybe?
+}
+
+/*
+-------------------------
+Svcmd_Nav_f
+-------------------------
+*/
+
+void Svcmd_Nav_f( void )
+{
+	char	*cmd = gi.argv( 1 );
+
+	if ( Q_stricmp( cmd, "show" ) == 0 )
+	{
+		cmd = gi.argv( 2 );
+
+		if ( Q_stricmp( cmd, "all" ) == 0 )
+		{
+			NAVDEBUG_showNodes = !NAVDEBUG_showNodes;
+			
+			//NOTENOTE: This causes the two states to sync up if they aren't already
+			NAVDEBUG_showCollision = NAVDEBUG_showNavGoals = 
+			NAVDEBUG_showCombatPoints = NAVDEBUG_showEnemyPath = 
+			NAVDEBUG_showEdges = NAVDEBUG_showNearest = NAVDEBUG_showRadius = NAVDEBUG_showNodes;		
+		}
+		else if ( Q_stricmp( cmd, "nodes" ) == 0 )
+		{
+			NAVDEBUG_showNodes = !NAVDEBUG_showNodes;
+		}
+		else if ( Q_stricmp( cmd, "radius" ) == 0 )
+		{
+			NAVDEBUG_showRadius = !NAVDEBUG_showRadius;
+		}
+		else if ( Q_stricmp( cmd, "edges" ) == 0 )
+		{
+			NAVDEBUG_showEdges = !NAVDEBUG_showEdges;
+		}
+		else if ( Q_stricmp( cmd, "testpath" ) == 0 )
+		{
+			NAVDEBUG_showTestPath = !NAVDEBUG_showTestPath;
+		}
+		else if ( Q_stricmp( cmd, "enemypath" ) == 0 )
+		{
+			NAVDEBUG_showEnemyPath = !NAVDEBUG_showEnemyPath;
+		}
+		else if ( Q_stricmp( cmd, "combatpoints" ) == 0 )
+		{
+			NAVDEBUG_showCombatPoints = !NAVDEBUG_showCombatPoints;
+		}
+		else if ( Q_stricmp( cmd, "navgoals" ) == 0 )
+		{
+			NAVDEBUG_showNavGoals = !NAVDEBUG_showNavGoals;
+		}
+		else if ( Q_stricmp( cmd, "collision" ) == 0 )
+		{
+			NAVDEBUG_showCollision = !NAVDEBUG_showCollision;
+		}
+		else if ( Q_stricmp( cmd, "grid" ) == 0 )
+		{
+			NAVDEBUG_showGrid = !NAVDEBUG_showGrid;
+		}	
+		else if ( Q_stricmp( cmd, "nearest" ) == 0 )
+		{
+			NAVDEBUG_showNearest = !NAVDEBUG_showNearest;
+		}
+		else if ( Q_stricmp( cmd, "lines" ) == 0 )
+		{
+			NAVDEBUG_showPointLines = !NAVDEBUG_showPointLines;
+		}
+	}
+	else if ( Q_stricmp( cmd, "set" ) == 0 )
+	{
+		cmd = gi.argv( 2 );
+
+		if ( Q_stricmp( cmd, "testgoal" ) == 0 )
+		{
+		//	NAVDEBUG_curGoal = navigator.GetNearestNode( &g_entities[0], g_entities[0].waypoint, NF_CLEAR_PATH, WAYPOINT_NONE );
+		}
+	}
+	else if ( Q_stricmp( cmd, "goto" ) == 0 )
+	{
+		cmd = gi.argv( 2 );
+		NAV::TeleportTo(&(g_entities[0]), cmd);
+	}
+	else if ( Q_stricmp( cmd, "gotonum" ) == 0 )
+	{
+		cmd = gi.argv( 2 );
+		NAV::TeleportTo(&(g_entities[0]), atoi(cmd));
+	}
+	else if ( Q_stricmp( cmd, "totals" ) == 0 )
+	{
+		NAV::ShowStats();
+	}
+	else
+	{
+		//Print the available commands
+		Com_Printf("nav - valid commands\n---\n" );
+		Com_Printf("show\n - nodes\n - edges\n - testpath\n - enemypath\n - combatpoints\n - navgoals\n---\n");
+		Com_Printf("goto\n ---\n" );
+		Com_Printf("gotonum\n ---\n" );
+		Com_Printf("totals\n ---\n" );
+		Com_Printf("set\n - testgoal\n---\n" );
+	}
+}
+
+//
+//JWEIER ADDITIONS START
+
+bool	navCalculatePaths	= false;
+
+bool	NAVDEBUG_showNodes			= false;
+bool	NAVDEBUG_showRadius			= false;
+bool	NAVDEBUG_showEdges			= false;
+bool	NAVDEBUG_showTestPath		= false;
+bool	NAVDEBUG_showEnemyPath		= false;
+bool	NAVDEBUG_showCombatPoints	= false;
+bool	NAVDEBUG_showNavGoals		= false;
+bool	NAVDEBUG_showCollision		= false;
+int		NAVDEBUG_curGoal			= 0;
+bool	NAVDEBUG_showGrid			= false;
+bool	NAVDEBUG_showNearest		= false;
+bool	NAVDEBUG_showPointLines		= false;
+
+
+//
+//JWEIER ADDITIONS END
\ No newline at end of file
diff --git a/code/game/g_nav.h b/code/game/g_nav.h
new file mode 100644
index 0000000..b4dc0ab
--- /dev/null
+++ b/code/game/g_nav.h
@@ -0,0 +1,30 @@
+#ifndef __G_NAV_H__
+#define __G_NAV_H__
+
+#define	WAYPOINT_NONE	0
+
+#define	MAX_RADIUS_CHECK	1024
+#define	YAW_ITERATIONS	16
+
+extern	bool navCalculatePaths;
+
+extern	bool NAVDEBUG_showNodes;
+extern	bool NAVDEBUG_showRadius;
+extern	bool NAVDEBUG_showEdges;
+extern	bool NAVDEBUG_showTestPath;
+extern	bool NAVDEBUG_showEnemyPath;
+extern	bool NAVDEBUG_showCombatPoints;
+extern	bool NAVDEBUG_showNavGoals;
+extern	bool NAVDEBUG_showCollision;
+extern	bool NAVDEBUG_showGrid;
+extern	bool NAVDEBUG_showNearest;
+extern	int	 NAVDEBUG_curGoal;
+extern	bool NAVDEBUG_showPointLines;
+
+
+void CG_DrawNode( vec3_t origin, int type );
+void CG_DrawEdge( vec3_t start, vec3_t end, int type );
+void CG_DrawRadius( vec3_t origin, unsigned int radius, int type );
+void CG_DrawCombatPoint( vec3_t origin, int type );
+
+#endif //#ifndef __G_NAV_H__
diff --git a/code/game/g_navigator.cpp b/code/game/g_navigator.cpp
new file mode 100644
index 0000000..ecb57ae
--- /dev/null
+++ b/code/game/g_navigator.cpp
@@ -0,0 +1,5508 @@
+////////////////////////////////////////////////////////////////////////////////////////
+// RAVEN SOFTWARE - STAR WARS: JK II
+//  (c) 2002 Activision
+//
+//
+//
+//
+//
+////////////////////////////////////////////////////////////////////////////////////////
+#include "g_headers.h"
+
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// HFile Bindings
+////////////////////////////////////////////////////////////////////////////////////////
+bool	HFILEopen_read(int& handle,	const char* filepath)		{gi.FS_FOpenFile(filepath, &handle, FS_READ);	return (handle!=0);}
+bool	HFILEopen_write(int& handle, const char* filepath)		{gi.FS_FOpenFile(filepath, &handle, FS_WRITE);	return (handle!=0);}
+bool	HFILEread(int& handle,		void*		data, int size)	{return (gi.FS_Read(data, size, handle)!=0);}
+bool	HFILEwrite(int& handle,		const void* data, int size)	{return (gi.FS_Write(data, size, handle)!=0);}
+bool	HFILEclose(int& handle)									{gi.FS_FCloseFile(handle); return true;}
+
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Externs
+////////////////////////////////////////////////////////////////////////////////////////
+extern gentity_t*	G_FindDoorTrigger( gentity_t *ent );
+extern qboolean		G_EntIsBreakable( int entityNum, gentity_t *breaker );
+extern qboolean		G_CheckInSolidTeleport (const vec3_t& teleportPos, gentity_t *self);
+
+extern cvar_t*		g_nav1;
+extern cvar_t*		g_nav2;
+extern cvar_t*		g_developer;
+extern int			delayedShutDown;
+extern vec3_t		playerMinsStep;
+extern vec3_t		playerMaxs;
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Includes
+////////////////////////////////////////////////////////////////////////////////////////
+#include "b_local.h"
+#include "g_navigator.h"
+#if !defined(RAGL_GRAPH_VS_INC)
+	#include "..\Ragl\graph_vs.h"
+#endif
+#if !defined(RATL_GRAPH_REGION_INC)
+	#include "..\Ragl\graph_region.h"
+#endif
+//#if !defined(RATL_GRAPH_TRIANGULATE_INC)
+//	#include "..\Ragl\graph_triangulate.h"
+//#endif
+#if !defined(RATL_VECTOR_VS_INC)
+	#include "..\Ratl\vector_vs.h"
+#endif
+#if !defined(RUFL_HSTRING_INC)
+	#include "..\Rufl\hstring.h"
+#endif
+#if !defined(RUFL_HFILE_INC)
+	#include "..\Rufl\hfile.h"
+#endif
+#if !defined(RAVL_BOUNDS_INC)
+	#include "..\Ravl\CBounds.h"
+#endif
+
+
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Defines 
+////////////////////////////////////////////////////////////////////////////////////////
+#define		NAV_VERSION						1.3f
+#define		NEIGHBORING_DIST				200.0f
+#define		SAFE_NEIGHBORINGPOINT_DIST		400.0f
+#define		SAFE_AT_NAV_DIST_SQ				6400.0f			//80*80
+#define		SAFE_GOTO_DIST_SQ				19600.0f		//140*140
+
+namespace NAV
+{
+	enum
+	{
+#ifdef _XBOX
+		// now 11 bytes each
+		NUM_NODES			= 1024,	// Question for VV- is this big enough for all the levels?  if so, we should use it too...
+#else
+		NUM_NODES			= 1024,
+#endif
+		// now 5 bytes each
+		NUM_EDGES			= 3*NUM_NODES,
+		NUM_EDGES_PER_NODE	= 20,
+
+
+		NUM_REGIONS			= NUM_NODES/3,	// Had to raise this up for bounty
+		NUM_CELLS			= 32,	// should be the square root of NUM_NODES
+		NUM_NODES_PER_CELL	= 60,	// had to raise this for t3_bounty
+		NUM_TARGETS			= 5,	// max number of outgoing edges from a given node
+
+		CELL_RANGE			= 1000,
+		VIEW_RANGE			= 550,
+
+		BIAS_NONWAYPOINT	= 500,
+		BIAS_DANGER			= 8000,
+		BIAS_TOOSMALL		= 10000,
+
+		NULL_PATH_USER_INDEX= -1,
+#ifdef _XBOX
+		// This may not be safe, but I REALLY need memory. Better testing will reveal that
+		// these don't work, but in quick tests these numbers were sufficient.
+		MAX_PATH_USERS		= 60,
+		MAX_PATH_SIZE		= 50,
+#else
+		MAX_PATH_USERS		= 100,
+		MAX_PATH_SIZE		= NUM_NODES/7,
+#endif
+
+		Z_CULL_OFFSET		= 60,
+
+		MAX_NODES_PER_NAME	= 30,
+		MAX_EDGE_SEG_LEN	= 100,
+		MAX_EDGE_FLOOR_DIST	= 60,
+		MAX_EDGE_AUTO_LEN   = 500,
+
+		MAX_EDGES_PER_ENT	= 10,
+		MAX_BLOCKING_ENTS	= 100,
+		MAX_ALERTS_PER_AGENT= 10,
+		MAX_ALERT_TIME		= 10000,
+
+		MIN_WAY_NEIGHBORS	= 4,
+		MAX_NONWP_NEIGHBORS = 1,
+
+
+		// Human Sized 
+		//-------------
+		SC_MEDIUM_RADIUS	= 20,
+		SC_MEDIUM_HEIGHT	= 60,
+
+		// Rancor Sized
+		//--------------
+		SC_LARGE_RADIUS		= 60,
+		SC_LARGE_HEIGHT		= 120,
+
+
+		SAVE_LOAD			= 0,
+
+		CHECK_JUMP			= 0,
+		CHECK_START_OPEN	= 1,
+		CHECK_START_SOLID	= 1,
+	};
+}
+
+namespace STEER
+{
+	enum
+	{
+		NULL_STEER_USER_INDEX= -1,
+		MAX_NEIGHBORS		 = 20,
+		Z_CULL_OFFSET		 = 60,
+		SIDE_LOCKED_TIMER	 = 2000,
+		NEIGHBOR_RANGE		 = 60,
+	};
+}
+
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Total Memory - 11 Bytes (can save 5 bytes by removing Name and Targets)
+////////////////////////////////////////////////////////////////////////////////////////
+class	CWayNode
+{
+public:
+	CVec3			mPoint;
+	float			mRadius;
+	NAV::EPointType	mType;
+	hstring			mName;						// TODO OPTIMIZATION: Remove This?
+	hstring			mTargets[NAV::NUM_TARGETS];	// TODO OPTIMIZATION: Remove This
+	enum EWayNodeFlags
+	{
+		WN_NONE = 0,
+		WN_ISLAND,
+		WN_FLOATING,
+		WN_DROPTOFLOOR,
+		WN_NOAUTOCONNECT,
+		WN_MAX
+	};
+	ratl::bits_vs<EWayNodeFlags::WN_MAX>	mFlags;
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Access Operator (For Cells)(For Triangulation)
+	////////////////////////////////////////////////////////////////////////////////////
+	float			operator[](int dimension)
+	{
+		return mPoint[dimension];
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Left Right Test (For Triangulation)
+	////////////////////////////////////////////////////////////////////////////////////
+	virtual		ESide	LRTest(const CWayNode& A, const CWayNode& B) const
+	{
+		return (mPoint.LRTest(A.mPoint, B.mPoint));
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Point In Circle (For Triangulation)
+	////////////////////////////////////////////////////////////////////////////////////
+	virtual		bool	InCircle(const CWayNode& A, const CWayNode& B, const CWayNode& C) const
+	{
+		return (mPoint.PtInCircle(A.mPoint, B.mPoint, C.mPoint));
+	}
+};
+const CWayNode&		GetNode(int Handle);
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Total Memory - 5 bytes
+////////////////////////////////////////////////////////////////////////////////////////
+class	CWayEdge
+{
+public:
+	int				mNodeA;			// DO NOT REMOVE THIS: Handles are full ints because upper bits are used
+	int				mNodeB;			// DO NOT REMOVE THIS: Handles are full ints because upper bits are used
+	float			mDistance;		// DO NOT REMOVE THIS: It's a serious runtime optimization for A*
+
+	unsigned short	mOwnerNum;		// Converted to short.  Largest entity number is 1024
+	unsigned short	mEntityNum;		// Converted to short.  Largest entity number is 1024
+	enum EWayEdgeFlags
+	{
+		WE_NONE = 0,
+
+		WE_SIZE_MEDIUM,
+		WE_SIZE_LARGE,
+
+		WE_BLOCKING_DOOR,
+		WE_BLOCKING_WALL,
+		WE_BLOCKING_BREAK,
+
+		WE_VALID,
+		WE_ONHULL,
+		WE_FLYING,
+		WE_JUMPING,
+		WE_CANBEINVAL,
+		WE_DESIGNERPLACED,
+
+		WE_MAX
+	};
+	ratl::bits_vs<EWayEdgeFlags::WE_MAX>	mFlags;		// Should be only one int
+
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Size Function
+	////////////////////////////////////////////////////////////////////////////////////
+	inline int		Blocking()
+	{
+		if (mFlags.get_bit(WE_BLOCKING_BREAK))
+		{
+			return WE_BLOCKING_BREAK;
+		}
+		if (mFlags.get_bit(WE_BLOCKING_WALL))
+		{
+			return WE_BLOCKING_WALL;
+		}
+		if (mFlags.get_bit(WE_BLOCKING_DOOR))
+		{
+			return WE_BLOCKING_DOOR;
+		}
+		return 0;
+	}
+	inline	bool	BlockingBreakable()		{return (mFlags.get_bit(WE_BLOCKING_BREAK));}
+	inline	bool	BlockingWall()			{return (mFlags.get_bit(WE_BLOCKING_WALL));}
+	inline	bool	BlockingDoor()			{return (mFlags.get_bit(WE_BLOCKING_DOOR));}
+
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Size Function
+	////////////////////////////////////////////////////////////////////////////////////
+	inline int		Size() const
+	{
+		return (mFlags.get_bit(WE_SIZE_MEDIUM)?(WE_SIZE_MEDIUM):(WE_SIZE_LARGE));
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Access Operator (For Cells)(For Triangulation)
+	////////////////////////////////////////////////////////////////////////////////////
+	float			operator[](int dimension) const
+	{
+		CVec3	Half(GetNode(mNodeA).mPoint + GetNode(mNodeB).mPoint);
+		return (Half[dimension] * 0.5f);
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Point - returns the center of the edge
+	////////////////////////////////////////////////////////////////////////////////////
+	void			Point(CVec3& Half) const
+	{
+		Half = GetNode(mNodeA).mPoint;
+		Half += GetNode(mNodeB).mPoint;
+		Half *= 0.5f;
+
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// GetPoint A
+	////////////////////////////////////////////////////////////////////////////////////
+	const CVec3&	PointA() const
+	{
+		return GetNode(mNodeA).mPoint;
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// GetPoint B
+	////////////////////////////////////////////////////////////////////////////////////
+	const CVec3&	PointB() const
+	{
+		return GetNode(mNodeB).mPoint;
+	}
+
+};
+const CWayEdge&	GetEdge(int Handle);
+
+
+struct	SNodeSort
+{
+	NAV::TNodeHandle	mHandle;
+	float				mDistance;
+	bool				mInRadius;
+
+
+	bool	operator < (const SNodeSort& other) const
+	{
+		return (mDistance<other.mDistance);
+	}
+};
+
+struct SEntSize
+{
+	float	mRadius;
+	float	mHeight;
+};
+
+struct SDangerAlert
+{
+	int		mHandle;
+	float	mDanger;
+};
+
+
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Defines
+////////////////////////////////////////////////////////////////////////////////////////
+typedef		ragl::graph_vs		<CWayNode, NAV::NUM_NODES, CWayEdge, NAV::NUM_EDGES, NAV::NUM_EDGES_PER_NODE>				TGraph;
+typedef		ragl::graph_region	<CWayNode, NAV::NUM_NODES, CWayEdge, NAV::NUM_EDGES, NAV::NUM_EDGES_PER_NODE, NAV::NUM_REGIONS, NAV::NUM_REGIONS>	TGraphRegion;
+typedef		TGraph::cells		<NAV::NUM_NODES_PER_CELL, NAV::NUM_CELLS, NAV::NUM_CELLS>									TGraphCells;
+typedef		ratl::vector_vs		<SNodeSort, NAV::NUM_NODES_PER_CELL>														TNearestNavSort;
+
+typedef		ratl::array_vs		<SDangerAlert, NAV::MAX_ALERTS_PER_AGENT>													TAlertList;
+typedef		ratl::array_vs		<TAlertList, MAX_GENTITIES>																	TEntityAlertList;
+typedef		ratl::vector_vs		<NAV::TNodeHandle, NAV::MAX_NODES_PER_NAME>													TNamedNodeList;
+typedef		ratl::map_vs		<hstring, TNamedNodeList, NAV::NUM_NODES>													TNameToNodeMap;
+
+typedef		ratl::vector_vs		<NAV::TEdgeHandle, NAV::MAX_EDGES_PER_ENT>													TEdgesPerEnt;
+typedef		ratl::map_vs		<int, TEdgesPerEnt, NAV::MAX_BLOCKING_ENTS>													TEntEdgeMap;
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Path Point
+//
+// This is actual vector and speed location (as well as node handle of that the agent
+// has planned to go to.
+////////////////////////////////////////////////////////////////////////////////////////
+struct	SPathPoint
+{
+	CVec3				mPoint;
+	float				mSpeed;
+	float				mSlowingRadius;
+	float				mReachedRadius;
+	float				mDist;
+	float				mETA;
+	NAV::TNodeHandle	mNode;
+};
+typedef		ratl::vector_vs		<SPathPoint, NAV::MAX_PATH_SIZE>															TPath;
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Path User
+//
+// This is the cached path for a given actor
+////////////////////////////////////////////////////////////////////////////////////////
+struct	SPathUser
+{
+	int			mEnd;
+	bool		mSuccess;
+	int			mLastUseTime;
+	int			mLastAStarTime;
+	TPath		mPath;
+};
+typedef		ratl::pool_vs<SPathUser, NAV::MAX_PATH_USERS>																	TPathUsers;
+typedef		ratl::array_vs<int, MAX_GENTITIES>																				TPathUserIndex;
+
+
+typedef		ratl::vector_vs<gentity_t*, STEER::MAX_NEIGHBORS>																TNeighbors;
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Steer User
+//
+// This is the cached steering data for a given actor
+////////////////////////////////////////////////////////////////////////////////////////
+struct	SSteerUser
+{
+	// Constant Values In Entity
+	//---------------------------
+	float		mMaxForce;
+	float		mMaxSpeed;
+	float		mRadius;
+	float		mMass;
+
+
+	// Current Values
+	//----------------
+	TNeighbors	mNeighbors;
+
+	CVec3		mOrientation;
+	CVec3		mPosition;
+
+	CVec3		mVelocity;
+	float		mSpeed;
+
+
+	// Values Projected From Current Values
+	//--------------------------------------
+	CVec3		mProjectFwd;
+	CVec3		mProjectSide;
+	CVec3		mProjectPath;
+
+
+	// Temporary Values
+	//------------------
+	CVec3		mDesiredVelocity;
+	float		mDesiredSpeed;
+	float		mDistance;
+	CVec3		mSeekLocation;
+
+	int			mIgnoreEntity;
+
+	bool		mBlocked;
+	int			mBlockedTgtEntity;
+	CVec3		mBlockedTgtPosition;
+
+	// Steering
+	//----------
+	CVec3		mSteering;
+	float		mNewtons;
+};
+
+typedef		ratl::pool_vs<SSteerUser, 4>																					TSteerUsers;
+typedef		ratl::array_vs<int, MAX_GENTITIES>																				TSteerUserIndex;
+typedef		ratl::bits_vs<MAX_GENTITIES>																					TEntBits;
+
+
+TAlertList&			GetAlerts(gentity_t* actor);
+TGraph&				GetGraph();
+int					GetAirRegion();
+int					GetIslandRegion();
+
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// The Graph User
+//
+// Here we define our own user class, which can invalidate edges and generate unique
+// costs for node traversal based on the nodes, and possibly the actor attempting to
+// cross the nodes at any given time.
+//
+////////////////////////////////////////////////////////////////////////////////////////
+class		CGraphUser : public TGraph::user
+{
+private:
+	gentity_t*			mActor;
+	int					mActorSize;
+
+	CVec3				mDangerSpot;
+	float				mDangerSpotRadiusSq;
+
+
+public:
+	////////////////////////////////////////////////////////////////////////////////////
+	//
+	////////////////////////////////////////////////////////////////////////////////////
+	void	SetActor(gentity_t* actor)
+	{
+		mActor			= actor;
+		mActorSize		= NAV::ClassifyEntSize(actor);
+		mDangerSpotRadiusSq	= 0;
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	//
+	////////////////////////////////////////////////////////////////////////////////////
+	void	ClearActor()
+	{
+		mActor = 0;
+		mActorSize = 0;
+		mDangerSpotRadiusSq = 0;
+	}
+
+	gentity_t*	GetActor()
+	{
+		return mActor;
+	}
+
+	void	SetDangerSpot(const CVec3& Spot, float RadiusSq)
+	{
+		mDangerSpot = Spot;
+		mDangerSpotRadiusSq = RadiusSq;
+	}
+	void	ClearDangerSpot()
+	{
+		mDangerSpotRadiusSq = 0;
+	}
+
+
+
+
+public:
+	////////////////////////////////////////////////////////////////////////////////////
+	//
+	////////////////////////////////////////////////////////////////////////////////////
+	virtual		bool	can_be_invalid(const CWayEdge& Edge) const
+	{
+		return (Edge.mFlags.get_bit(CWayEdge::EWayEdgeFlags::WE_CANBEINVAL));
+	}
+
+
+	////////////////////////////////////////////////////////////////////////////////////
+	//
+	////////////////////////////////////////////////////////////////////////////////////
+	virtual		bool	is_valid(CWayEdge& Edge, int EndPoint=0) const
+	{
+		// If The Actor Can't Fly, But This Is A Flying Edge, It's Invalid
+		//-----------------------------------------------------------------
+		if (mActor && Edge.mFlags.get_bit(CWayEdge::EWayEdgeFlags::WE_FLYING) && mActor->NPC && !(mActor->NPC->scriptFlags&SCF_NAV_CAN_FLY))
+		{
+			return false;
+		}
+
+		// If The Actor Can't Fly, But This Is A Flying Edge, It's Invalid
+		//-----------------------------------------------------------------
+		if (mActor && Edge.mFlags.get_bit(CWayEdge::EWayEdgeFlags::WE_JUMPING) && mActor->NPC && !(mActor->NPC->scriptFlags&SCF_NAV_CAN_JUMP))
+		{
+			return false;
+		}
+		
+
+		// If The Actor Is Too Big, This Is Not A Valid Edge For Him
+		//-----------------------------------------------------------
+		if (mActor && Edge.Size()<mActorSize &&
+ 			(EndPoint!=-1) /*&&									// Don't count the last edge on the path as invalid because of size
+			(!EndPoint || (EndPoint!=Edge.mNodeA && EndPoint!=Edge.mNodeB))*/)
+		{
+			return false;
+		}
+
+		if (Edge.mEntityNum!=ENTITYNUM_NONE)
+		{
+			gentity_t*	ent		= &g_entities[Edge.mEntityNum];
+			if (ent)
+			{
+				// Can The Actor Navigate Through The Breakable Entity?
+				//------------------------------------------------------
+				if ((mActor) && 
+					(mActor->NPC) && 
+					(mActor->NPC->aiFlags&NPCAI_NAV_THROUGH_BREAKABLES) &&
+					(Edge.BlockingBreakable()) && 
+					(G_EntIsBreakable(Edge.mEntityNum, mActor))
+					)
+				{
+					return true;
+				}
+
+				// Is This A Door?
+				//-----------------
+				if (Edge.BlockingDoor())
+				{
+					bool	StartOpen	= (ent->spawnflags & 1);
+					bool	Closed		= (StartOpen)?(ent->moverState==MOVER_POS2):(ent->moverState==MOVER_POS1);
+
+					// If It Is Closed, We Want To Check If It Will Auto Open For Us
+					//---------------------------------------------------------------
+					if (Closed)
+					{
+						gentity_t*	owner	= &g_entities[Edge.mOwnerNum];
+						if (owner)
+						{
+							// Check To See If The Owner Is Inactive Or Locked, Or Unavailable To The NPC
+							//----------------------------------------------------------------------------
+							if ((owner->svFlags & SVF_INACTIVE) ||
+								(owner==ent && (owner->spawnflags & (MOVER_PLAYER_USE|MOVER_FORCE_ACTIVATE|MOVER_LOCKED))) ||
+								(owner!=ent && (owner->spawnflags & (1 /*PLAYERONLY*/|4 /*USE_BOTTON*/))))
+							{
+								return false;
+							}
+
+
+							// Look For A Key
+							//----------------
+							if (mActor!=0 && (owner->spawnflags & MOVER_GOODIE))
+							{
+								int key = INV_GoodieKeyCheck(mActor);
+								if (!key)
+								{
+									return false;
+								}
+							}
+						}
+
+						// No Owner?  This Must Be A Scripted Door Or Other Contraption
+						//--------------------------------------------------------------
+						else
+						{
+							return false;
+						}
+					}
+					return true;
+				}
+
+				// If This Is A Wall, Check If It Has Contents Now
+				//-------------------------------------------------
+				else if (Edge.BlockingWall())
+				{
+					return !(ent->contents&CONTENTS_SOLID);
+				}
+			}
+		}
+		else if ( Edge.BlockingBreakable())
+		{//we had a breakable in our way, now it's gone, see if there is anything else in the way
+			if ( NAV::TestEdge( Edge.mNodeA, Edge.mNodeB, false ) )
+			{//clear it
+				Edge.mFlags.clear_bit(CWayEdge::EWayEdgeFlags::WE_BLOCKING_BREAK);
+			}
+			//NOTE: if this fails with the SC_LARGE size 
+		}
+
+		return (Edge.mFlags.get_bit(CWayEdge::EWayEdgeFlags::WE_VALID));
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// This is the cost estimate from any node to any other node (usually the goal)
+	////////////////////////////////////////////////////////////////////////////////////
+	virtual		float	cost(const CWayNode& A, const CWayNode& B) const
+	{
+		return (A.mPoint.Dist(B.mPoint));
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// This is the cost estimate for traversing a particular edge
+	////////////////////////////////////////////////////////////////////////////////////
+	virtual		float	cost(const CWayEdge& Edge, const CWayNode& B) const
+	{
+		float	DangerBias = 0.0f;
+		if (mActor)
+		{
+			int			eHandle = GetGraph().edge_index(Edge);
+			TAlertList& al = GetAlerts(mActor);
+			for (int alIndex=0; alIndex<TAlertList::CAPACITY; alIndex++)
+			{
+				if (al[alIndex].mHandle==eHandle && al[alIndex].mDanger>0.0f)
+				{
+					DangerBias += (al[alIndex].mDanger*NAV::BIAS_DANGER);
+				}
+			}
+
+			// If The Actor Is Too Big, Bias This Edge For Him
+			//-------------------------------------------------
+			if (Edge.Size()<mActorSize)
+			{
+				//DangerBias += NAV::BIAS_TOOSMALL;
+			}
+		}
+
+		if (mDangerSpotRadiusSq > mDangerSpot.DistToLine2(Edge.PointA(), Edge.PointB()))
+		{
+			DangerBias += NAV::BIAS_DANGER;
+		}
+
+
+		if (B.mType==NAV::PT_WAYNODE)
+		{
+            return (Edge.mDistance + DangerBias);
+		}
+		return ((Edge.mDistance + DangerBias) + NAV::BIAS_NONWAYPOINT);
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	//
+	////////////////////////////////////////////////////////////////////////////////////
+	virtual		bool	on_same_floor(const CWayNode& A, const CWayNode& B) const
+	{
+		return (fabsf(A.mPoint[2] - B.mPoint[2])<100.0f);
+	}
+
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// setup the edge (For Triangulation)
+	//
+	// This function is here because it evaluates the base cost from NodeA to NodeB, which
+	//
+	////////////////////////////////////////////////////////////////////////////////////
+	virtual		void	setup_edge(CWayEdge& Edge, int A, int B, bool OnHull, const CWayNode& NodeA, const CWayNode& NodeB, bool CanBeInvalid=false)
+	{
+		Edge.mNodeA			= A;
+		Edge.mNodeB			= B;
+		Edge.mDistance		= NodeA.mPoint.Dist(NodeB.mPoint);
+		Edge.mEntityNum		= ENTITYNUM_NONE;
+		Edge.mOwnerNum		= ENTITYNUM_NONE;
+		Edge.mFlags.clear();
+		Edge.mFlags.set_bit(CWayEdge::EWayEdgeFlags::WE_VALID);
+		if (CanBeInvalid)
+		{
+			Edge.mFlags.set_bit(CWayEdge::EWayEdgeFlags::WE_CANBEINVAL);
+		}
+		if (OnHull)
+		{
+			Edge.mFlags.set_bit(CWayEdge::EWayEdgeFlags::WE_ONHULL);
+		}
+	}
+};
+
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// The Global Public Objects
+////////////////////////////////////////////////////////////////////////////////////////
+TGraph				mGraph;
+TGraphRegion		mRegion(mGraph);
+TGraphCells			mCells(mGraph);
+
+TGraph::search		mSearch;
+CGraphUser			mUser;
+
+
+TNameToNodeMap		mNodeNames;
+TEntEdgeMap			mEntEdgeMap;
+
+TNearestNavSort		mNearestNavSort;
+
+TPathUsers			mPathUsers;
+TPathUserIndex		mPathUserIndex;
+SPathUser			mPathUserMaster;
+
+TSteerUsers			mSteerUsers;
+TSteerUserIndex		mSteerUserIndex;
+
+TEntityAlertList	mEntityAlertList;
+
+vec3_t				mZeroVec;
+trace_t				mMoveTrace;
+trace_t				mViewTrace;
+
+int					mMoveTraceCount = 0;
+int					mViewTraceCount = 0;
+int					mConnectTraceCount = 0;
+int					mConnectTime = 0;
+int					mIslandCount = 0;
+int					mIslandRegion = 0;
+int					mAirRegion = 0;
+char				mLocStringA[256] = {0};
+char				mLocStringB[256] = {0};
+
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// 
+////////////////////////////////////////////////////////////////////////////////////////
+TAlertList&			GetAlerts(gentity_t* actor)
+{
+	return mEntityAlertList[actor->s.number];
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+//
+////////////////////////////////////////////////////////////////////////////////////////
+TGraph&				GetGraph()
+{
+	return mGraph;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+//
+////////////////////////////////////////////////////////////////////////////////////////
+const CWayNode&		GetNode(int Handle)
+{
+	return mGraph.get_node(Handle);
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+//
+////////////////////////////////////////////////////////////////////////////////////////
+const CWayEdge&		GetEdge(int Handle)
+{
+	return mGraph.get_edge(Handle);
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+//
+////////////////////////////////////////////////////////////////////////////////////////
+int					GetAirRegion()
+{
+	return mAirRegion;
+}
+int					GetIslandRegion()
+{
+	return mIslandRegion;
+}
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Helper Function : View Trace
+////////////////////////////////////////////////////////////////////////////////////////
+bool		ViewTrace(const CVec3& a, const CVec3& b)
+{
+	int contents	= (CONTENTS_SOLID|CONTENTS_TERRAIN|CONTENTS_MONSTERCLIP);
+
+	mViewTraceCount++;
+	gi.trace(&mViewTrace, a.v, 0, 0, b.v, ENTITYNUM_NONE, contents);
+
+	if ((mViewTrace.allsolid==qfalse) && (mViewTrace.startsolid==qfalse ) && (mViewTrace.fraction==1.0f))
+	{
+		return true;
+	}
+	return false;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Helper Function : View Trace
+////////////////////////////////////////////////////////////////////////////////////////
+bool		ViewNavTrace(const CVec3& a, const CVec3& b)
+{
+	int contents	= (CONTENTS_SOLID|CONTENTS_TERRAIN|CONTENTS_MONSTERCLIP|CONTENTS_BOTCLIP);
+
+	mViewTraceCount++;
+	gi.trace(&mViewTrace, a.v, 0, 0, b.v, ENTITYNUM_NONE, contents);
+
+	if ((mViewTrace.allsolid==qfalse) && (mViewTrace.startsolid==qfalse ) && (mViewTrace.fraction==1.0f))
+	{
+		return true;
+	}
+	return false;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Helper Function : Move Trace
+////////////////////////////////////////////////////////////////////////////////////////
+bool		MoveTrace(const CVec3& Start, const CVec3& Stop, const CVec3& Mins, const CVec3& Maxs, 
+					  int IgnoreEnt=0, 
+					  bool CheckForDoNotEnter=false, 
+					  bool RetryIfStartInDoNotEnter=true, 
+					  bool IgnoreAllEnts=false,
+					  int OverrideContents=0)
+{
+	int contents	= (MASK_NPCSOLID);
+	if (OverrideContents)
+	{
+		contents	= OverrideContents;
+	}
+	if (CheckForDoNotEnter)
+	{
+		contents |= CONTENTS_BOTCLIP;
+	}
+	if (IgnoreAllEnts)
+	{
+		contents &= ~CONTENTS_BODY;
+	}
+
+
+	// Run The Trace
+	//---------------
+	mMoveTraceCount++;
+	gi.trace(&mMoveTrace, Start.v, Mins.v, Maxs.v, Stop.v, IgnoreEnt, contents);
+
+
+	// Did It Make It?
+	//-----------------
+	if ((mMoveTrace.allsolid==qfalse) && (mMoveTrace.startsolid==qfalse ) && (mMoveTrace.fraction==1.0f))
+	{
+		return true;
+	}
+
+	// If We Started In Solid, Try Removing The "Do Not Enter" Contents Type, And Trace Again
+	//----------------------------------------------------------------------------------------
+	if (CheckForDoNotEnter && RetryIfStartInDoNotEnter && ((mMoveTrace.allsolid==qtrue) || (mMoveTrace.startsolid==qtrue)))
+	{
+		contents &= ~CONTENTS_BOTCLIP;
+
+		// Run The Trace
+		//---------------
+		mMoveTraceCount++;
+		gi.trace(&mMoveTrace, Start.v, Mins.v, Maxs.v, Stop.v, IgnoreEnt, contents);
+
+		// Did It Make It?
+		//-----------------
+		if ((mMoveTrace.allsolid==qfalse) && (mMoveTrace.startsolid==qfalse ) && (mMoveTrace.fraction==1.0f))
+		{
+			return true;
+		}
+	}
+	return false;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Helper Function : Move Trace (with actor)
+////////////////////////////////////////////////////////////////////////////////////////
+bool		MoveTrace(gentity_t* actor, const CVec3& goalPosition, bool IgnoreAllEnts=false)
+{
+	assert(actor!=0);
+	CVec3	Mins(actor->mins);
+	CVec3	Maxs(actor->maxs);
+
+	Mins[2] += (STEPSIZE*1);
+
+	return MoveTrace(actor->currentOrigin, goalPosition, Mins, Maxs, actor->s.number, true, true, IgnoreAllEnts/*, actor->contents*/);
+}
+
+
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// GoTo
+//
+// This Function serves as a master control for finding, updating, and following a path
+////////////////////////////////////////////////////////////////////////////////////////
+bool			NAV::GoTo(gentity_t* actor, TNodeHandle target, float MaxDangerLevel)
+{
+	assert(actor!=0 && actor->client!=0);
+
+	// Check If We Already Have A Path
+	//---------------------------------
+	bool	HasPath = NAV::HasPath(actor);
+
+	// If So Update It
+	//-----------------
+	if (HasPath)
+	{
+		HasPath = NAV::UpdatePath(actor, target, MaxDangerLevel);
+	}
+
+	// If No Path, Try To Find One
+	//-----------------------------
+	if (!HasPath)
+	{
+		HasPath = NAV::FindPath(actor, target, MaxDangerLevel);
+	}
+
+	// If We Have A Path, Now Try To Follow It
+	//-----------------------------------------
+	if (HasPath)
+	{
+		HasPath = (STEER::Path(actor)!=0.0f);
+		if (HasPath)
+		{
+			if (STEER::AvoidCollisions(actor, actor->client->leader))
+			{
+				STEER::Blocked(actor, NAV::NextPosition(actor));
+			}
+		}
+		else
+		{
+			STEER::Blocked(actor, NAV::GetNodePosition(target));
+		}
+	}
+
+	// Nope, No Path At All...  Bad
+	//------------------------------
+	else
+	{
+		STEER::Blocked(actor, NAV::GetNodePosition(target));
+	}
+
+	return HasPath;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// 
+////////////////////////////////////////////////////////////////////////////////////////
+bool			NAV::GoTo(gentity_t* actor, gentity_t* target, float MaxDangerLevel)
+{
+	assert(actor!=0 && actor->client!=0);
+
+	bool		HasPath		= false;
+	TNodeHandle	targetNode	= GetNearestNode(target, true);
+
+	// If The Target Has No Nearest Nav Point, Go To His Last Valid Waypoint Instead
+	//-------------------------------------------------------------------------------
+	if (targetNode==0)
+	{
+		targetNode = target->lastWaypoint;
+	}
+
+	// Has He EVER Had A Valid Waypoint?
+	//-----------------------------------
+	if (targetNode!=0)
+	{
+		// If On An Edge, Pick The Safest Of The Two Points
+		//--------------------------------------------------
+		if (targetNode<0)
+		{
+			targetNode = (Q_irand(0,1)==0)?(mGraph.get_edge(abs(targetNode)).mNodeA):(mGraph.get_edge(abs(targetNode)).mNodeB);
+		}
+
+		// Check If We Already Have A Path
+		//---------------------------------
+		HasPath = NAV::HasPath(actor);
+
+		// If So Update It
+		//-----------------
+		if (HasPath)
+		{
+			HasPath = NAV::UpdatePath(actor, targetNode, MaxDangerLevel);
+		}
+
+		// If No Path, Try To Find One
+		//-----------------------------
+		if (!HasPath)
+		{
+			HasPath = NAV::FindPath(actor, targetNode, MaxDangerLevel);
+		}
+
+		// If We Have A Path, Now Try To Follow It
+		//-----------------------------------------
+		if (HasPath)
+		{
+			HasPath = (STEER::Path(actor)!=0.0f);
+			if (HasPath)
+			{
+				// Attempt To Avoid Collisions Along The Path
+				//--------------------------------------------
+				if (STEER::AvoidCollisions(actor, actor->client->leader))
+				{
+					// Have A Path, Currently Blocked By Something
+					//---------------------------------------------
+					STEER::Blocked(actor, NAV::NextPosition(actor));
+				}
+			}
+			else
+			{
+				STEER::Blocked(actor, target);
+			}
+		}
+
+		// Nope, No Path At All...  Bad
+		//------------------------------
+		else
+		{
+			STEER::Blocked(actor, target);
+		}
+	}
+
+	// No Waypoint Near 
+	//------------------
+	else
+	{
+		STEER::Blocked(actor, target);
+	}
+
+	return HasPath;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// 
+////////////////////////////////////////////////////////////////////////////////////////
+bool			NAV::GoTo(gentity_t* actor, const vec3_t& position, float MaxDangerLevel)
+{
+	assert(actor!=0 && actor->client!=0);
+
+	bool		HasPath		= false;
+	TNodeHandle	targetNode	= GetNearestNode(position);
+	if (targetNode!=0)
+	{
+		// If On An Edge, Pick The Safest Of The Two Points
+		//--------------------------------------------------
+		if (targetNode<0)
+		{
+			targetNode = (Q_irand(0,1)==0)?(mGraph.get_edge(abs(targetNode)).mNodeA):(mGraph.get_edge(abs(targetNode)).mNodeB);
+		}
+
+		// Check If We Already Have A Path
+		//---------------------------------
+		HasPath = NAV::HasPath(actor);
+
+		// If So Update It
+		//-----------------
+		if (HasPath)
+		{
+			HasPath = NAV::UpdatePath(actor, targetNode, MaxDangerLevel);
+		}
+
+		// If No Path, Try To Find One
+		//-----------------------------
+		if (!HasPath)
+		{
+			HasPath = NAV::FindPath(actor, targetNode, MaxDangerLevel);
+		}
+
+		// If We Have A Path, Now Try To Follow It
+		//-----------------------------------------
+		if (HasPath)
+		{
+			HasPath = (STEER::Path(actor)!=0.0f);
+			if (HasPath)
+			{
+				// Attempt To Avoid Collisions Along The Path
+				//--------------------------------------------
+				if (STEER::AvoidCollisions(actor, actor->client->leader))
+				{
+					// Have A Path, Currently Blocked By Something
+					//---------------------------------------------
+					STEER::Blocked(actor, NAV::NextPosition(actor));
+				}
+			}
+			else
+			{
+				STEER::Blocked(actor, NAV::NextPosition(actor));
+			}
+		}
+
+		// Nope, No Path At All...  Bad
+		//------------------------------
+		else
+		{
+			STEER::Blocked(actor, position);
+		}
+	}
+
+	// No Waypoint Near 
+	//------------------
+	else
+	{
+		STEER::Blocked(actor, position);
+	}
+
+	return HasPath;
+}
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// This function exists as a wrapper so that the graph can write to the gi.Printf()
+////////////////////////////////////////////////////////////////////////////////////////
+void	stupid_print(const char* data)
+{
+	gi.Printf(data);
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// 
+////////////////////////////////////////////////////////////////////////////////////////
+bool			NAV::LoadFromFile(const char *filename, int checksum)
+{
+	mZeroVec[0] = 0;
+	mZeroVec[1] = 0;
+	mZeroVec[2] = 0;
+
+	mPathUserIndex.fill(NULL_PATH_USER_INDEX);
+	mSteerUserIndex.fill(STEER::NULL_STEER_USER_INDEX);
+
+	mMoveTraceCount = 0;
+	mViewTraceCount = 0;
+	mConnectTraceCount = 0;
+	mConnectTime = 0;
+	mIslandCount = 0;
+	mIslandRegion = 0;
+	mAirRegion = 0;
+
+	memset(&mEntityAlertList, 0, sizeof(mEntityAlertList));
+
+#if !defined(FINAL_BUILD)
+	ratl::ratl_base::OutputPrint = stupid_print;
+#endif
+
+	mGraph.clear();
+	mRegion.clear();
+	mCells.clear();
+	mNodeNames.clear();
+	mNearestNavSort.clear();
+
+#ifndef _XBOX
+	if (SAVE_LOAD)
+	{
+		hfile	navFile(va("maps/%s.navNEW"));
+		if (!navFile.open_read(NAV_VERSION, checksum))
+		{
+			return false;
+		}
+		navFile.load(&mGraph, sizeof(mGraph));
+		navFile.load(&mRegion, sizeof(mRegion));
+		navFile.load(&mCells, sizeof(mCells));
+		navFile.close();
+		return true;
+	}
+#endif
+	return false;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// 
+////////////////////////////////////////////////////////////////////////////////////////
+bool			NAV::TestEdge( TNodeHandle NodeA, TNodeHandle NodeB, qboolean IsDebugEdge )
+{
+	int			atHandle = mGraph.get_edge_across( NodeA, NodeB );
+	CWayEdge&	at = mGraph.get_edge(atHandle);
+	CWayNode&	a = mGraph.get_node(at.mNodeA);
+	CWayNode&	b = mGraph.get_node(at.mNodeB);
+	CVec3		Mins(-15.0f, -15.0f, 0.0f);		// These were the old "sizeless" defaults
+	CVec3		Maxs(15.0f, 15.0f, 40.0f);
+	bool		CanGo			= false;
+	bool		HitCharacter	= false;
+	int			EntHit			= ENTITYNUM_NONE;
+	int			i				= (int)(at.Size());
+
+	a.mPoint.ToStr(mLocStringA);
+	b.mPoint.ToStr(mLocStringB);
+
+	const char*	aName = (a.mName.empty())?(mLocStringA):(a.mName.c_str());
+	const char*	bName = (b.mName.empty())?(mLocStringB):(b.mName.c_str());
+
+	float		radius = (at.Size()==CWayEdge::EWayEdgeFlags::WE_SIZE_LARGE)?(SC_LARGE_RADIUS):(SC_MEDIUM_RADIUS);
+	float		height = (at.Size()==CWayEdge::EWayEdgeFlags::WE_SIZE_LARGE)?(SC_LARGE_HEIGHT):(SC_MEDIUM_HEIGHT);
+
+	Mins[0] = Mins[1] = (radius) * -1.0f;
+	Maxs[0] = Maxs[1] = (radius);
+	Maxs[2] =			(height);
+
+
+	// If Either Start Or End Points Are Too Small, Don' Bother At This Size
+	//-----------------------------------------------------------------------
+	if ((a.mType==PT_WAYNODE && a.mRadius<radius) ||
+		(b.mType==PT_WAYNODE && b.mRadius<radius))
+	{
+		if (IsDebugEdge)
+		{
+			gi.Printf("Nav(%s)<->(%s): Size Too Big\n", aName, bName, i);
+		}
+		CanGo = false;
+		return CanGo;
+	}
+
+
+	// Try It
+	//--------
+	CanGo	= MoveTrace(a.mPoint, b.mPoint, Mins, Maxs, 0, true, false);
+	EntHit	= mMoveTrace.entityNum;
+
+	// Check For A Flying Edge
+	//-------------------------
+	if (a.mFlags.get_bit(CWayNode::EWayNodeFlags::WN_FLOATING) || b.mFlags.get_bit(CWayNode::EWayNodeFlags::WN_FLOATING))
+	{
+		at.mFlags.set_bit(CWayEdge::EWayEdgeFlags::WE_FLYING);
+		if (!a.mFlags.get_bit(CWayNode::EWayNodeFlags::WN_FLOATING) || !b.mFlags.get_bit(CWayNode::EWayNodeFlags::WN_FLOATING))
+		{
+			at.mFlags.set_bit(CWayEdge::EWayEdgeFlags::WE_CANBEINVAL);
+		}
+	}
+
+
+	// Well, It' Can't Go, But Possibly If We Hit An Entity And Remove That Entity, We Can Go?
+	//-----------------------------------------------------------------------------------------
+	if (!CanGo && 
+		!mMoveTrace.startsolid && 
+		EntHit!=ENTITYNUM_WORLD && 
+		EntHit!=ENTITYNUM_NONE && 
+		(&g_entities[EntHit])!=0)
+	{
+		gentity_t*	ent		= &g_entities[EntHit];
+
+		if (IsDebugEdge)
+		{
+			gi.Printf("Nav(%s)<->(%s): Hit Entity Type (%s), TargetName (%s)\n", aName, bName, ent->classname, ent->targetname);
+		}
+
+
+		// Find Out What Type Of Entity This Is
+		//--------------------------------------
+		if (!Q_stricmp("func_door", ent->classname))
+		{
+			at.mFlags.set_bit(CWayEdge::EWayEdgeFlags::WE_BLOCKING_DOOR);
+		}
+		else if (
+			!Q_stricmp("func_wall", ent->classname) ||
+			!Q_stricmp("func_static", ent->classname) ||
+			!Q_stricmp("func_usable", ent->classname))
+		{
+			at.mFlags.set_bit(CWayEdge::EWayEdgeFlags::WE_BLOCKING_WALL);
+		}
+		else if (
+			!Q_stricmp("func_glass", ent->classname) || 
+			!Q_stricmp("func_breakable", ent->classname) ||
+			!Q_stricmp("misc_model_breakable", ent->classname))
+		{
+			at.mFlags.set_bit(CWayEdge::EWayEdgeFlags::WE_BLOCKING_BREAK);
+		}
+		else if (ent->NPC || ent->s.number==0)
+		{
+			HitCharacter = true;
+		}
+
+		// Don't Care About Any Other Entity Types
+		//-----------------------------------------
+		else
+		{
+			if (IsDebugEdge)
+			{
+				gi.Printf("Nav(%s)<->(%s): Unable To Ignore Ent, Going A Size Down\n", aName, bName);
+			}
+			return CanGo;	// Go To Next Size Down
+		}
+
+
+		// If It Is A Door, Try Opening The Door To See If We Can Get In
+		//---------------------------------------------------------------
+		if (at.BlockingDoor())
+		{
+			// Find The Master
+			//-----------------
+			gentity_t *master = ent;
+			while (master && master->teammaster && (master->flags&FL_TEAMSLAVE))
+			{
+				master = master->teammaster;
+			}
+			bool DoorIsStartOpen = master->spawnflags&1;
+
+			// Open The Chain
+			//----------------
+			gentity_t *slave = master;
+			while (slave)
+			{
+				VectorCopy((DoorIsStartOpen)?(slave->pos1):(slave->pos2), slave->currentOrigin);
+				gi.linkentity(slave);
+				slave = slave->teamchain;
+			}
+
+			// Try The Trace
+			//---------------
+			CanGo = MoveTrace(a.mPoint, b.mPoint, Mins, Maxs, 0, true, false);
+			if (CanGo)
+			{
+				ent		= master;
+				EntHit	= master->s.number;
+			}
+			else
+			{
+				if (IsDebugEdge)
+				{
+					gi.Printf("Nav(%s)<->(%s): Unable Pass Through Door Even When Open, Going A Size Down\n", aName, bName);
+				}
+			}
+
+			// Close The Door
+			//----------------
+			slave = master;
+			while (slave)
+			{
+				VectorCopy((DoorIsStartOpen)?(slave->pos2):(slave->pos1), slave->currentOrigin);
+				gi.linkentity(slave);
+				slave = slave->teamchain;
+			}
+		}
+
+		// Assume Breakable Walls Will Be Clear Later
+		//-----------------------------------------------------
+		else if (at.BlockingBreakable())
+		{//we'll do the trace again later if this ent gets broken
+			CanGo = true;
+		}
+
+		// Otherwise, Try It, Pretending The Ent is Not There
+		//----------------------------------------------------
+		else
+		{
+			CanGo = MoveTrace(a.mPoint, b.mPoint, Mins, Maxs, EntHit, true, false);
+			if (IsDebugEdge)
+			{
+				gi.Printf("Nav(%s)<->(%s): Unable Pass Through Even If Entity Was Gone, Going A Size Down\n", aName, bName);
+			}
+		}
+
+
+
+		// If We Can Now Go, Ignoring The Entity, Remember That (But Don't Remember Characters - They Won't Stay Anyway)
+		//---------------------------------------------------------------------------------------------------------------
+		if (CanGo && !HitCharacter)
+		{
+			ent->wayedge		= atHandle;
+			at.mEntityNum		= EntHit;
+			at.mFlags.set_bit(CWayEdge::EWayEdgeFlags::WE_CANBEINVAL);
+
+			// Add It To The Edge Map
+			//------------------------
+			TEntEdgeMap::iterator eemiter = mEntEdgeMap.find(EntHit);
+			if (eemiter==mEntEdgeMap.end())
+			{
+				TEdgesPerEnt	EdgesPerEnt;
+				EdgesPerEnt.push_back(atHandle);
+				mEntEdgeMap.insert(EntHit, EdgesPerEnt);
+			}
+			else
+			{
+				if (!eemiter->full())
+				{
+					eemiter->push_back(atHandle);
+				}
+				else
+				{	
+#ifndef FINAL_BUILD
+					assert("Max Edges Perh Handle Reached, Unable To Add To Edge Map!"==0);
+					gi.Printf("WARNING: Too many nav edges pass through entity %d (%s)\n", EntHit, g_entities[EntHit].targetname);
+#endif
+				}
+			}
+
+			// Check For Special Conditions For The Different Types
+			//-------------------------------------------------------
+			if (at.BlockingDoor())
+			{
+				// Doors Need To Know Their "owner" Entity - The Thing That Controlls
+				// When The Door Is Open (or can "auto open")
+				//
+				// We'll start by assuming the door is it's own master
+				//-----------------------------------------------------
+				at.mOwnerNum = ent->s.number;
+				gentity_t*	owner = 0;
+
+				// If There Is A Target Name, See If This Thing Is Controlled From A Switch Or Something
+				//---------------------------------------------------------------------------------------
+				if (ent->targetname)
+				{
+					// Try Target
+					//------------
+					owner = G_Find(owner, FOFS(target), ent->targetname);
+					if (owner && 
+						(!Q_stricmp("trigger_multiple", owner->classname) || !Q_stricmp("trigger_once", owner->classname)))
+					{
+						at.mOwnerNum = owner->s.number;
+					}
+					else
+					{
+						// Try Target2
+						//-------------
+						owner = G_Find(owner, FOFS(target2), ent->targetname);
+						if (owner && 
+							(!Q_stricmp("trigger_multiple", owner->classname) || !Q_stricmp("trigger_once", owner->classname)))
+						{
+							at.mOwnerNum = owner->s.number;
+						}
+					}
+				}
+
+				// Otherwise, See If There Is An Auto Door Opener Trigger
+				//--------------------------------------------------------
+				else
+				{
+					owner = G_FindDoorTrigger(ent);
+					if (owner)
+					{
+						at.mOwnerNum = owner->s.number;
+					}
+				}
+			}
+
+			// Breakable Walls Are Not Valid Until Broken.  Period
+			//-----------------------------------------------------
+			else if (at.BlockingBreakable())
+			{//we'll do the trace again later if this ent gets broken
+				at.mFlags.clear_bit(CWayEdge::EWayEdgeFlags::WE_VALID);
+			}
+		}
+	}
+
+	// Now Search For Any Holes In The Ground
+	//----------------------------------------
+	if (CHECK_JUMP && CanGo)
+	{
+		CVec3	Mins(-15.0f, -15.0f, 0.0f);		// These were the old "sizeless" defaults
+		CVec3	Maxs(15.0f, 15.0f, 40.0f);
+
+		CVec3	AtoB(b.mPoint - a.mPoint);
+		float	AtoBDist = AtoB.SafeNorm();
+		int		AtoBSegs = (AtoBDist / MAX_EDGE_SEG_LEN);
+
+		AtoB *= MAX_EDGE_SEG_LEN;
+		CVec3	Start(a.mPoint);
+		CVec3	Stop;
+
+		for (int curSeg=1; (curSeg<AtoBSegs && CanGo); curSeg++)
+		{
+			Start	+= AtoB;
+			Stop	= Start;
+			Stop[2] -= MAX_EDGE_FLOOR_DIST;
+
+			CanGo = !MoveTrace(Start, Stop, Mins, Maxs, EntHit, true, false);
+		}
+	}
+
+	return CanGo;
+}
+////////////////////////////////////////////////////////////////////////////////////////
+// 
+////////////////////////////////////////////////////////////////////////////////////////
+bool			NAV::LoadFromEntitiesAndSaveToFile(const char *filename, int checksum)
+{
+	if (mGraph.size_nodes()<=3)
+	{
+		return true;
+	}
+	mUser.ClearActor();
+
+	mMoveTraceCount = 0;
+	mViewTraceCount = 0;
+	mConnectTraceCount = 0;
+	mConnectTime = gi.Milliseconds();
+
+	// PHASE 0: SCAN ALL ENTITIES AND TEMPORARLY CLOSE / TURN THEM ON
+	//================================================================
+	TEntBits				Doors;
+	TEntBits				Walls;
+	TEntBits				NPCs;
+	if (CHECK_START_OPEN)
+	{
+		for (int curEnt=0; curEnt<MAX_GENTITIES; curEnt++)
+		{
+			gentity_t*	ent		= &g_entities[curEnt];
+
+			if (!ent || !ent->inuse)
+			{
+				continue;
+			}
+
+			// Is It An NPC or Vehicle?
+			//--------------------------------------
+			if (ent->NPC  || (ent->NPC_type && Q_stricmp(ent->NPC_type, "atst")==0))
+			{
+				NPCs.set_bit(curEnt);
+				ent->lastMoveTime = ent->contents;
+				ent->contents = 0;	
+				gi.linkentity(ent);
+			}
+
+				
+
+			// Is This Ent "Start Off" or "Start Open"?
+			//------------------------------------------
+			if (!(ent->spawnflags&1))
+			{
+				continue;
+			}
+
+
+			// Is It A Door?  Then Close It
+			//--------------------------------------
+			if (!Q_stricmp("func_door", ent->classname))
+			{
+				Doors.set_bit(curEnt);
+				VectorCopy(ent->pos2, ent->currentOrigin);
+				gi.linkentity(ent);
+			}
+
+			// Is It A Wall?  Then Turn It On
+			//--------------------------------------
+			else if (!Q_stricmp("func_wall", ent->classname) ||	!Q_stricmp("func_usable", ent->classname))
+			{
+				Walls.set_bit(curEnt);
+				ent->contents = ent->spawnContents;	
+				gi.linkentity(ent);
+			}
+		}
+	}
+
+
+	// PHASE I: TRIANGULATE ALL NODES IN THE GRAPH
+	//=============================================
+/*	TGraphTriang	*Triang = new TGraphTriang(mGraph);
+	Triang->clear();
+	Triang->insertion_hull();
+	Triang->delaunay_edge_flip();
+	Triang->floor_shape(mUser, 1000.0f);
+	Triang->alpha_shape(mUser, 1000.0f);
+	Triang->finish(mUser);
+	delete Triang;
+*/
+	mCells.fill_cells_nodes(NAV::CELL_RANGE);	
+
+
+
+
+
+
+	// PHASE II: SCAN THROUGH EXISTING NODES AND GENERATE EDGES TO OTHER NODES WAY POINTS
+	//====================================================================================
+	CWayNode*		at;
+	int				atHandle;
+	const char*		atNameStr;
+	int				tgtNum;
+	int				tgtHandle;
+	hstring			tgtName;
+	const char*		tgtNameStr;
+
+	CWayEdge		atToTgt;
+	CVec3			atFloor;
+	CVec3			atRoof;
+	bool			atOnFloor;
+
+
+	TNameToNodeMap::iterator	nameFinder;
+	TGraph::TNodes::iterator	nodeIter;
+	TGraph::TEdges::iterator	edgeIter;
+
+	ratl::ratl_compare			closestNbrs[MIN_WAY_NEIGHBORS];
+
+	// Drop To Floor And Mark Floating
+	//---------------------------------
+	for (nodeIter=mGraph.nodes_begin(); nodeIter!=mGraph.nodes_end(); nodeIter++)
+	{
+		at				= &(*nodeIter);
+		atRoof			= at->mPoint;
+		atFloor			= at->mPoint;
+		if (at->mFlags.get_bit(CWayNode::EWayNodeFlags::WN_DROPTOFLOOR))
+		{
+			atFloor[2]	-= MAX_EDGE_FLOOR_DIST;
+		}
+		atFloor[2]		-= (MAX_EDGE_FLOOR_DIST * 1.5f);
+		atOnFloor		= !ViewTrace(atRoof, atFloor);
+		if (at->mFlags.get_bit(CWayNode::EWayNodeFlags::WN_DROPTOFLOOR))
+		{
+			at->mPoint		= mViewTrace.endpos;
+			at->mPoint[2]	+= 5.0f;
+		}
+		else if (!atOnFloor && (at->mType==PT_WAYNODE || at->mType==PT_GOALNODE))
+		{
+			at->mFlags.set_bit(CWayNode::EWayNodeFlags::WN_FLOATING);
+		}
+	}
+
+
+	for (nodeIter=mGraph.nodes_begin(); nodeIter!=mGraph.nodes_end(); nodeIter++)
+	{
+		nodeIter->mPoint.ToStr(mLocStringA);
+
+		at				= &(*nodeIter);
+		atHandle		= (nodeIter.index());
+		atNameStr		= (at->mName.empty())?(mLocStringA):(at->mName.c_str());
+
+		// Connect To Hand Designed Targets
+		//----------------------------------
+		for (tgtNum=0; tgtNum<NAV::NUM_TARGETS; tgtNum++)
+		{
+			// Does This Target Name Exist (or is it "")?
+			//--------------------------------------------
+			tgtName		= at->mTargets[tgtNum];
+			if (!tgtName || tgtName.empty())
+			{
+				continue;
+			}
+			tgtNameStr	= tgtName.c_str();
+
+			// Clear The Name In The Array, So Save Is Not Corrupted
+			//-------------------------------------------------------
+			at->mTargets[tgtNum] = 0;
+
+
+			// Try To Find The Node This Target Name Refers To
+			//-------------------------------------------------
+			nameFinder	= mNodeNames.find(tgtName);
+			if (nameFinder==mNodeNames.end())
+			{
+#ifndef FINAL_BUILD
+				gi.Printf(S_COLOR_YELLOW"WARNING: nav unable to locate target (%s) from node (%s)\n", tgtNameStr, atNameStr);
+#endif
+				continue;
+			}
+
+			// For Each One
+			//--------------
+			for (int tgtNameIndex=0; tgtNameIndex<(*nameFinder).size(); tgtNameIndex++)
+			{
+				// Connect The Two Nodes In The Graph
+				//------------------------------------
+				tgtHandle	= (*nameFinder)[tgtNameIndex];
+
+				// Only If The Target Is NOT The Same As The Source
+				//--------------------------------------------------
+				if (atHandle!=tgtHandle)
+				{
+					int edge = mGraph.get_edge_across(atHandle, tgtHandle);
+
+					// If The Edge Already Exists, Just Make Sure To Add Any Flags
+					//-------------------------------------------------------------
+					if (edge)
+					{
+						// If It Is The Jump Edge (Last Target), Mark It
+						//-----------------------------------------------
+						if (tgtNum == (NAV::NUM_TARGETS-1))
+						{
+							mGraph.get_edge(edge).mFlags.set_bit(CWayEdge::EWayEdgeFlags::WE_JUMPING);
+						}
+						mGraph.get_edge(edge).mFlags.set_bit(CWayEdge::EWayEdgeFlags::WE_DESIGNERPLACED);
+						continue;
+					}
+					
+					// Setup The Edge
+					//----------------
+					mUser.setup_edge(atToTgt, atHandle, tgtHandle, false, mGraph.get_node(atHandle), mGraph.get_node(tgtHandle), false);
+					atToTgt.mFlags.set_bit(CWayEdge::EWayEdgeFlags::WE_DESIGNERPLACED);
+
+					// If It Is The Jump Edge (Last Target), Mark It
+					//-----------------------------------------------
+					if (tgtNum == (NAV::NUM_TARGETS-1))
+					{
+						atToTgt.mFlags.set_bit(CWayEdge::EWayEdgeFlags::WE_JUMPING);
+					}
+
+					// Now Tell The Graph Which Edge Index To Store Between The Two Points
+					//---------------------------------------------------------------------
+					mGraph.connect_node(atToTgt, atHandle, tgtHandle);
+				}
+			}
+		}
+
+
+		// If It Is A Combat Or Goal Nav, Try To "Auto Connect" To A Few Nearby Way Points
+		//---------------------------------------------------------------------------------
+		if (!at->mFlags.get_bit(CWayNode::EWayNodeFlags::WN_NOAUTOCONNECT) && 
+			(at->mType==NAV::PT_COMBATNODE || at->mType==NAV::PT_GOALNODE))
+		{
+			// Get The List Of Nodes For This Cell Of The Map
+			//------------------------------------------------
+			TGraphCells::SCell&			Cell = mCells.get_cell(at->mPoint[0], at->mPoint[1]);
+
+			// Create A Closest Neighbors Array And Initialize It Empty
+			//----------------------------------------------------------
+			for (int i=0; i<MIN_WAY_NEIGHBORS; i++)
+			{
+				closestNbrs[i].mHandle = 0;
+				closestNbrs[i].mCost = 0;
+			}
+			int highestCost=0;
+			int nonWPCount=0;
+
+			for (int cellNode=0; cellNode<Cell.mNodes.size(); cellNode++)
+			{
+				tgtHandle = Cell.mNodes[cellNode];
+
+				// If It Is The Same Node, Or We Already Connect To It, Ignore
+				//-------------------------------------------------------------
+				if (tgtHandle==atHandle || mGraph.get_edge_across(atHandle, tgtHandle))
+				{
+					continue;
+				}
+
+				// If The Target Is Another Combat Point Or Goal Node, Ignore It
+				//--------------------------------------------------------------
+				CWayNode&	node = mGraph.get_node(tgtHandle);
+
+
+				// Ignore Ones That Are A Floor Above Or Below
+				//---------------------------------------------
+				if (fabsf(node.mPoint[2] - at->mPoint[2])>NAV::MAX_EDGE_FLOOR_DIST)
+				{
+					continue;
+				}
+
+				// Ignore Ones That Are Too Far
+				//------------------------------
+				float cost = node.mPoint.Dist(at->mPoint);
+				if (cost>NAV::MAX_EDGE_AUTO_LEN)
+				{
+					continue;
+				}
+
+				// Connecting To Another Combat Point Or Goal Node It Must Be Half The Max Connect Distance
+				//------------------------------------------------------------------------------------------
+				if (node.mType==NAV::PT_COMBATNODE || node.mType==NAV::PT_GOALNODE)
+				{
+					nonWPCount++;
+					if (nonWPCount>NAV::MAX_NONWP_NEIGHBORS)
+					{
+						continue;
+					}
+
+					if (cost>(NAV::MAX_EDGE_AUTO_LEN/2.0f))
+					{
+						continue;
+					}
+				}
+
+				// If We Already Have Points, Ignore Anything Farther Than The Current Farthest
+				//------------------------------------------------------------------------------
+				if (closestNbrs[highestCost].mHandle!=0 && closestNbrs[highestCost].mCost<cost)
+				{
+					continue;
+				}
+
+				// Ignore Anything Not In The PVS
+				//--------------------------------
+				if (!(gi.inPVS(node.mPoint.v, at->mPoint.v)))
+				{
+					continue;
+				}
+
+
+				// Now Record This Point Over The One With The Highest Cost
+				//----------------------------------------------------------
+				closestNbrs[highestCost].mHandle	= tgtHandle;
+				closestNbrs[highestCost].mCost		= node.mPoint.Dist(at->mPoint);
+
+				// Find The New Highest Cost
+				//---------------------------
+				for (int i=0; i<MIN_WAY_NEIGHBORS; i++)
+				{
+					if (closestNbrs[i].mHandle==0)
+					{
+						highestCost = i;
+						break;
+					}
+
+					if (closestNbrs[i].mCost>closestNbrs[highestCost].mCost)
+					{
+						highestCost = i;
+					}
+				}
+			}
+
+			// Now Connect All The Closest Neighbors
+			//---------------------------------------
+			for (int i=0; i<MIN_WAY_NEIGHBORS; i++)
+			{
+				if (closestNbrs[i].mHandle)
+				{
+					mUser.setup_edge(atToTgt, atHandle, closestNbrs[i].mHandle, false, (*nodeIter), mGraph.get_node(closestNbrs[i].mHandle), false);
+					mGraph.connect_node(atToTgt, atHandle, closestNbrs[i].mHandle);
+				}
+			}
+		}
+	}
+
+
+
+
+
+	// PHASE III: SCAN EDGES AND RUN TRACES FOR VALID CONNECTIONS & DOORS
+	//==================================================================
+	ratl::vector_vs<int, NAV::NUM_EDGES>	*ToBeRemoved = new ratl::vector_vs<int, NAV::NUM_EDGES>;
+	for (edgeIter=mGraph.edges_begin(); edgeIter!=mGraph.edges_end(); edgeIter++)
+	{
+		CWayEdge& at		= (*edgeIter);
+		int		  atHandle	= edgeIter.index();
+		CWayNode& a			= mGraph.get_node(at.mNodeA);
+		CWayNode& b			= mGraph.get_node(at.mNodeB);
+
+		mGraph.get_node(at.mNodeA).mPoint.ToStr(mLocStringA);
+		mGraph.get_node(at.mNodeB).mPoint.ToStr(mLocStringB);
+
+		const char*	aName = (a.mName.empty())?(mLocStringA):(a.mName.c_str());
+		const char*	bName = (b.mName.empty())?(mLocStringB):(b.mName.c_str());
+
+
+		if (at.mFlags.get_bit(CWayEdge::EWayEdgeFlags::WE_JUMPING))
+		{
+			at.mFlags.set_bit(CWayEdge::EWayEdgeFlags::WE_SIZE_LARGE);
+			at.mFlags.set_bit(CWayEdge::EWayEdgeFlags::WE_CANBEINVAL);
+			at.mFlags.set_bit(CWayEdge::EWayEdgeFlags::WE_DESIGNERPLACED);
+			continue;
+		}
+
+
+		// Cycle through the different sizes, starting with the largest
+		//--------------------------------------------------------------
+		bool	CanGo		= false;
+		bool	IsDebugEdge = 
+			(g_nav1->string[0] && g_nav2->string[0] && 
+			(!stricmp(*(a.mName), g_nav1->string) || !stricmp(*(b.mName), g_nav1->string)) && 
+			(!stricmp(*(a.mName), g_nav2->string) || !stricmp(*(b.mName), g_nav2->string)));
+
+		// For debugging a connection between two known points:
+		//------------------------------------------------------
+		if (IsDebugEdge)
+		{
+			gi.Printf("===============================\n");
+			gi.Printf("Nav(%s)<->(%s): DEBUGGING START\n", aName, bName);
+			assert(0);	// Break Here
+		}
+
+		// Try Large
+		//-----------
+		at.mFlags.set_bit(CWayEdge::EWayEdgeFlags::WE_SIZE_LARGE);
+		if (IsDebugEdge)
+		{
+			gi.Printf("Nav(%s)<->(%s): Attempting Size Large...\n", aName, bName);
+		}
+
+		// Try Medium
+		//------------
+		CanGo = TestEdge( at.mNodeA, at.mNodeB, IsDebugEdge );
+		if (!CanGo)
+		{
+			at.mFlags.clear_bit(CWayEdge::EWayEdgeFlags::WE_SIZE_LARGE);
+			at.mFlags.set_bit(CWayEdge::EWayEdgeFlags::WE_SIZE_MEDIUM);
+			if (IsDebugEdge)
+			{
+				gi.Printf("Nav(%s)<->(%s): Attempting Size Medium...\n", aName, bName);
+			}
+			CanGo = TestEdge( at.mNodeA, at.mNodeB, IsDebugEdge );
+		}
+
+		// If This Edge Can't Go At Any Size, Dump It
+		//--------------------------------------------
+		if (!CanGo)
+		{
+			ToBeRemoved->push_back(atHandle);
+			if (IsDebugEdge)
+			{
+				CVec3	ContactNormal(mMoveTrace.plane.normal);
+				CVec3	ContactPoint( mMoveTrace.endpos);
+
+				char	cpointstr[256] = {0};
+				char	cnormstr[256] = {0};
+
+				ContactNormal.ToStr(cnormstr);
+				ContactPoint.ToStr(cpointstr);
+
+				gi.Printf("Nav(%s)<->(%s): FAILED, NO SMALLER SIZE POSSIBLE\n", aName, bName);
+				gi.Printf("Nav(%s)<->(%s): The last trace hit:\n", aName, bName);
+				gi.Printf("Nav(%s)<->(%s):     at %s,\n", aName, bName, cpointstr);
+				gi.Printf("Nav(%s)<->(%s):     normal %s\n", aName, bName, cnormstr);
+				if (mMoveTrace.entityNum!=ENTITYNUM_WORLD)
+				{
+					gentity_t*	ent		= &g_entities[mMoveTrace.entityNum];
+					gi.Printf("Nav(%s)<->(%s):     on entity Type (%s), TargetName (%s)\n", aName, bName, ent->classname, ent->targetname);
+				}
+				if ((mMoveTrace.contents)&CONTENTS_MONSTERCLIP)
+				{
+					gi.Printf("Nav(%s)<->(%s):     with contents BLOCKNPC\n", aName, bName);
+				}
+				else if ((mMoveTrace.contents)&CONTENTS_BOTCLIP)
+				{
+					gi.Printf("Nav(%s)<->(%s):     with contents DONOTENTER\n", aName, bName);
+				}
+				else if ((mMoveTrace.contents)&CONTENTS_SOLID)
+				{
+					gi.Printf("Nav(%s)<->(%s):     with contents SOLID\n", aName, bName);
+				}
+				else if ((mMoveTrace.contents)&CONTENTS_WATER)
+				{
+					gi.Printf("Nav(%s)<->(%s):     with contents WATER\n", aName, bName);
+				}
+			}
+		}
+		else
+		{
+			if (IsDebugEdge)
+			{
+				gi.Printf("Nav(%s)<->(%s): Success!\n", aName, bName);
+			}
+		}
+
+		if (IsDebugEdge)
+		{
+			gi.Printf("Nav(%s)<->(%s): DEBUGGING END\n", aName, bName);
+			gi.Printf("===============================\n");
+		}
+	}
+
+	// Now Go Ahead And Remove Dead Edges
+	//------------------------------------
+	for (int RemIndex=0;RemIndex<ToBeRemoved->size(); RemIndex++)
+	{
+		CWayEdge& at = mGraph.get_edge((*ToBeRemoved)[RemIndex]);
+		if (at.mFlags.get_bit(CWayEdge::EWayEdgeFlags::WE_DESIGNERPLACED))
+		{
+			hstring		aHstr = mGraph.get_node(at.mNodeA).mName;
+			hstring		bHstr = mGraph.get_node(at.mNodeB).mName;
+
+			mGraph.get_node(at.mNodeA).mPoint.ToStr(mLocStringA);
+			mGraph.get_node(at.mNodeB).mPoint.ToStr(mLocStringB);
+
+#ifndef FINAL_BUILD
+			gi.Printf( S_COLOR_RED"ERROR: Nav connect failed: %s@%s <-> %s@%s\n", aHstr.c_str(), mLocStringA, bHstr.c_str(), mLocStringB);
+#endif
+			delayedShutDown = level.time + 100;
+		}
+		mGraph.remove_edge(at.mNodeA, at.mNodeB);
+	}
+
+	delete ToBeRemoved;
+
+	// Detect Point Islands
+	//----------------------
+	for (nodeIter=mGraph.nodes_begin(); nodeIter!=mGraph.nodes_end(); nodeIter++)
+	{
+		at				= &(*nodeIter);
+		atHandle		= nodeIter.index();
+
+		if (!mGraph.node_has_neighbors(atHandle))
+		{
+			at->mPoint.ToStr(mLocStringA);
+
+			at->mFlags.set_bit(CWayNode::EWayNodeFlags::WN_ISLAND);
+			mIslandCount++;
+			if (at->mType==NAV::PT_COMBATNODE)
+			{
+#ifndef FINAL_BUILD
+				gi.Printf( S_COLOR_RED"ERROR: Combat Point %s@%s Is Not Connected To Anything\n", at->mName.c_str(), mLocStringA);
+				delayedShutDown = level.time + 100;
+#endif
+			}
+			if (at->mType==NAV::PT_GOALNODE)
+			{
+				// Try To Trace Down, If We Don't Hit Any Ground, Assume This Is An "Air Point"
+				//------------------------------------------------------------------------------
+				CVec3 Down(at->mPoint);
+				Down[2] -= 100;
+				if (!ViewTrace(at->mPoint, Down))
+				{
+#ifndef FINAL_BUILD
+					gi.Printf( S_COLOR_RED"ERROR: Nav Goal %s@%s Is Not Connected To Anything\n", at->mName.c_str(), mLocStringA);
+					delayedShutDown = level.time + 100;
+#endif
+				}
+			}
+		}
+	}
+
+
+
+	// PHASE IV: SCAN EDGES FOR REGIONS
+	//==================================
+	mRegion.clear();
+
+	mIslandRegion	= mRegion.reserve();
+//	mAirRegion		= mRegion.reserve();
+	for (nodeIter=mGraph.nodes_begin(); nodeIter!=mGraph.nodes_end(); nodeIter++)
+	{
+		at				= &(*nodeIter);
+		if (at->mFlags.get_bit(CWayNode::EWayNodeFlags::WN_ISLAND))
+		{
+			mRegion.assign_region(nodeIter.index(), mIslandRegion);
+		}
+	//	else if (at->mFlags.get_bit(CWayNode::EWayNodeFlags::WN_FLOATING))
+	//	{
+	//		mRegion.assign_region(nodeIter.index(), mAirRegion);
+	//	}
+	}
+	if (!mRegion.find_regions(mUser))
+	{
+#ifndef FINAL_BUILD
+		gi.Printf( S_COLOR_RED"ERROR: Too Many Regions!\n");
+		delayedShutDown = level.time + 100;
+#endif
+	}
+	if (!mRegion.find_region_edges())
+	{
+#ifndef FINAL_BUILD
+		gi.Printf( S_COLOR_RED"ERROR: Too Many Region Edges!\n");
+		delayedShutDown = level.time + 100;
+#endif
+	}
+
+
+	// PHASE V: SCAN NODES AND FILL CELLS
+	//===================================
+	mCells.fill_cells_edges(NAV::CELL_RANGE);	
+
+
+	// PHASE VI: SCAN ALL ENTITIES AND RE OPEN / TURN THEM OFF
+	//=========================================================
+	if (CHECK_START_OPEN)
+	{
+		for (int curEnt=0; curEnt<MAX_GENTITIES; curEnt++)
+		{
+			// Is This Ent "Start Off" or "Start Open"?
+			//------------------------------------------
+			gentity_t*	ent		= &g_entities[curEnt];
+			if (!ent || !ent->inuse)
+			{
+				continue;
+			}
+
+
+			// Is It A Door?
+			//--------------------------------------
+			if (Doors.get_bit(curEnt))
+			{
+				VectorCopy(ent->pos1, ent->currentOrigin);
+				gi.linkentity(ent);
+			}
+
+			// Is It A Wall?
+			//--------------------------------------
+			else if (Walls.get_bit(curEnt))
+			{
+				ent->contents = 0;
+				gi.linkentity(ent);
+			}
+
+			// Is It An NPC?
+			//--------------------------------------
+			else if (NPCs.get_bit(curEnt))
+			{
+				ent->contents = ent->lastMoveTime;	
+				ent->lastMoveTime = 0;
+				gi.linkentity(ent);
+			}
+
+
+		}
+	}
+	mConnectTraceCount = mMoveTraceCount;
+	mMoveTraceCount = 0;
+
+	mConnectTime = gi.Milliseconds() - mConnectTime;
+
+
+	// PHASE VI: SAVE TO FILE
+	//========================
+#ifndef _XBOX
+	if (SAVE_LOAD)
+	{
+		hfile	navFile(va("maps/%s.navNEW"));
+		if (!navFile.open_write(NAV_VERSION, checksum))
+		{
+			return false;
+		}
+		navFile.save(&mGraph, sizeof(mGraph));
+		navFile.save(&mRegion, sizeof(mRegion));
+		navFile.save(&mCells, sizeof(mCells));
+		navFile.close();
+	}
+#endif
+	return true;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// 
+////////////////////////////////////////////////////////////////////////////////////////
+void			NAV::DecayDangerSenses()
+{
+	float	PerFrameDecay = (50.0f) / (float)(NAV::MAX_ALERT_TIME);
+	for (int entIndex=0; entIndex<TEntityAlertList::CAPACITY; entIndex++)
+	{
+		TAlertList&	ae = mEntityAlertList[entIndex];
+		for (int alertIndex=0; alertIndex<TAlertList::CAPACITY; alertIndex++)
+		{
+			if (ae[alertIndex].mHandle!=0)
+			{
+				ae[alertIndex].mDanger -= PerFrameDecay;
+
+				// If It Just Decayed To Nothing, Clear It
+				//-----------------------------------------
+				if (ae[alertIndex].mDanger<=0.0f)
+				{
+					ae[alertIndex].mHandle = 0;
+					ae[alertIndex].mDanger = 0;
+				}
+			}
+		}
+	}
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// 
+////////////////////////////////////////////////////////////////////////////////////////
+void			NAV::RegisterDangerSense(gentity_t* actor, int alertEventIndex)
+{
+	if (actor==0 || alertEventIndex<0)
+	{
+		assert(0);
+		return;
+	}
+
+	//If there are no waypoints, don't bother trying to register danger on them
+	if (mGraph.size_nodes()<1)
+	{
+		return;
+	}
+
+	// Get The Alert List For This Ent And The Alert Itself
+	//------------------------------------------------------
+	TAlertList&		al = mEntityAlertList[actor->s.number];
+	alertEvent_t&	ae = level.alertEvents[alertEventIndex];
+
+	if (ae.radius<=0.0f)
+	{
+		return;
+	}
+
+	// DEBUG GRAPHICS
+	//=====================================================
+	if (NAVDEBUG_showRadius)
+	{
+		CG_DrawRadius(ae.position, ae.radius, NODE_GOAL);
+	}
+	//=====================================================
+
+
+	CVec3	DangerPoint(ae.position);
+
+	// Look Through The Nearby Edges And Record Any That Are Affected
+	//----------------------------------------------------------------
+	TGraphCells::TCellNodes& cellEdges = mCells.get_cell(DangerPoint[0], DangerPoint[1]).mEdges;
+	for (int cellEdgeIndex=0; cellEdgeIndex<cellEdges.size(); cellEdgeIndex++)
+	{
+		int			edgeHandle	= cellEdges[cellEdgeIndex];
+		CWayEdge&	edge		= mGraph.get_edge(edgeHandle);
+		float		edgeDanger	= ((ae.radius - DangerPoint.DistToLine(edge.PointA(), edge.PointB()))/(ae.radius));
+		if (edgeDanger>0.0f)
+		{
+
+			// Record The Square, So That Danger Drops Off Quadradically Rather Than Linearly
+			//--------------------------------------------------------------------------------
+			edgeDanger *= edgeDanger;
+
+
+			// Now Find The Index We Will "Replace" With This New Information
+			//----------------------------------------------------------------
+			int	replaceIndex = -1;
+			for (int alIndex=0; alIndex<TAlertList::CAPACITY; alIndex++)
+			{
+
+				// If It's The Same Edge Handle, Then Replace This One!
+				//------------------------------------------------------
+				if (al[alIndex].mHandle==edgeHandle || al[alIndex].mHandle==0)
+				{
+					replaceIndex = alIndex;
+					break;
+				}
+
+				// Otherwise, Remember The Least Dangerous One
+				//---------------------------------------------
+				if (replaceIndex==-1 || al[alIndex].mDanger<al[replaceIndex].mDanger)
+				{
+					replaceIndex = alIndex;
+				}
+			}
+
+			// Now Go Ahead And Record It
+			//----------------------------
+			al[replaceIndex].mHandle = edgeHandle;
+			al[replaceIndex].mDanger = edgeDanger;
+		}
+	}
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// 
+////////////////////////////////////////////////////////////////////////////////////////
+void			NAV::WayEdgesNowClear(gentity_t* ent)
+{
+	if (ent)
+	{
+		ent->wayedge = 0;
+
+		int EdgeHandle;
+		int	EntNum = ent->s.number;
+
+		TEntEdgeMap::iterator finder = mEntEdgeMap.find(EntNum);
+		if (finder!=mEntEdgeMap.end())
+		{
+			for (int i=0; i<finder->size(); i++)
+			{
+				EdgeHandle = (*finder)[i];
+				if (EdgeHandle!=0)
+				{
+					CWayEdge& edge = mGraph.get_edge(EdgeHandle);
+					edge.mFlags.set_bit(CWayEdge::EWayEdgeFlags::WE_VALID);
+					edge.mEntityNum = ENTITYNUM_NONE;
+					edge.mOwnerNum = ENTITYNUM_NONE;
+				}
+			}
+			mEntEdgeMap.erase(EntNum);
+		}
+	}
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// 
+////////////////////////////////////////////////////////////////////////////////////////
+void			NAV::SpawnedPoint(gentity_t* ent, NAV::EPointType type)
+{
+	if (mGraph.size_nodes()>=NUM_NODES)
+	{
+#ifndef FINAL_BUILD
+		gi.Printf( "SpawnedPoint: Max Nav points reached (%d)!\n",NUM_NODES );
+#endif
+        return;
+	}
+
+	CVec3 Mins;
+	CVec3 Maxs;
+
+
+	Mins[0] = Mins[1] = (SC_MEDIUM_RADIUS) * -1.0f;
+	Maxs[0] = Maxs[1] = (SC_MEDIUM_RADIUS);
+	Mins[2] = 0.0f;
+	Maxs[2] = SC_MEDIUM_HEIGHT;
+
+
+	CVec3 Start(ent->currentOrigin);
+	CVec3 Stop(ent->currentOrigin);
+	Stop[2] += 5.0f;
+
+	Start.ToStr(mLocStringA);
+	const char* pointName = (ent->targetname && ent->targetname[0])?(ent->targetname):"?";
+
+	if (CHECK_START_SOLID)
+	{
+		// Try It
+		//--------
+		if (!MoveTrace(Start, Stop, Mins, Maxs, 0, true, false))
+		{
+			assert("ERROR: Nav in solid!"==0);
+			gi.Printf( S_COLOR_RED"ERROR: Nav(%d) in solid: %s@%s\n", type, pointName, mLocStringA);
+			delayedShutDown = level.time + 100;
+			return;
+		}
+	}
+
+	CWayNode	node;
+
+	node.mPoint			= ent->currentOrigin;
+	node.mRadius		= ent->radius;
+	node.mType			= type;
+	node.mFlags.clear();
+	if (type==NAV::PT_WAYNODE && (ent->spawnflags & 2))
+	{
+		node.mFlags.set_bit(CWayNode::EWayNodeFlags::WN_DROPTOFLOOR);
+	}
+	if (ent->spawnflags & 4)
+	{
+		node.mFlags.set_bit(CWayNode::EWayNodeFlags::WN_NOAUTOCONNECT);
+	}
+
+	// TO AVOID PROBLEMS WITH THE TRIANGULATION, WE MOVE THE POINTS AROUND JUST A BIT
+	//================================================================================
+	//node.mPoint		+= CVec3(Q_flrand(-RANDOM_PERMUTE, RANDOM_PERMUTE), Q_flrand(-RANDOM_PERMUTE, RANDOM_PERMUTE), 0.0f);
+	//================================================================================
+
+	// Validate That The New Location Is Still Safe
+	//----------------------------------------------
+	if (false && CHECK_START_SOLID)
+	{
+		Start = (node.mPoint);
+		Stop = (node.mPoint);
+		Stop[2] += 5.0f;
+
+		// Try It Again
+		//--------------
+		if (!MoveTrace(Start, Stop, Mins, Maxs, 0, true, false))
+		{
+			gi.Printf( S_COLOR_YELLOW"WARNING: Nav Moved To Solid, Resetting: (%s)\n", pointName);
+			assert("WARNING: Nav Moved To Solid, Resetting!"==0);
+			node.mPoint		= ent->currentOrigin;
+		}
+	}
+
+	node.mTargets[0]	= ent->target;
+	node.mTargets[1]	= ent->target2;
+	node.mTargets[2]	= ent->target3;
+	node.mTargets[3]	= ent->target4;
+	node.mTargets[4]	= ent->targetJump;
+	node.mName			= ent->targetname;
+
+	int		NodeHandle	= mGraph.insert_node(node);
+
+	ent->waypoint		= NodeHandle;
+
+	mCells.expand_bounds(NodeHandle);
+
+	if (!node.mName.empty())
+	{
+		TNameToNodeMap::iterator		nameFinder	= mNodeNames.find(node.mName);
+
+		if (nameFinder==mNodeNames.end())
+		{
+			TNamedNodeList	list;
+			list.clear();
+			list.push_back(NodeHandle);
+			mNodeNames.insert(node.mName, list);
+		}
+		else
+		{
+			(*nameFinder).push_back(NodeHandle);
+		}
+	}
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// 
+////////////////////////////////////////////////////////////////////////////////////////
+NAV::TNodeHandle		NAV::GetNearestNode(gentity_t* ent, bool forceRecalcNow, NAV::TNodeHandle goal)
+{
+	if (!ent)
+	{
+		return 0;
+	}
+
+	if (ent->waypoint==WAYPOINT_NONE || forceRecalcNow || (level.time>ent->noWaypointTime))
+	{
+		if (ent->waypoint)
+		{
+			ent->lastWaypoint	= ent->waypoint;
+		}
+		ent->waypoint		= 
+			GetNearestNode(
+			ent->currentOrigin, 
+			ent->waypoint, 
+			goal, 
+			ent->s.number, 
+			(ent->client && ent->client->moveType==MT_FLYSWIM));
+		ent->noWaypointTime = level.time + 1000;	// Don't Erase This Result For 5 Seconds
+	}
+
+	return ent->waypoint;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// 
+////////////////////////////////////////////////////////////////////////////////////////
+NAV::TNodeHandle		NAV::GetNearestNode(const vec3_t& position, NAV::TNodeHandle previous, NAV::TNodeHandle goal, int ignoreEnt, bool allowZOffset)
+{
+	if (mGraph.size_edges()>0)
+	{
+		// Get The List Of Nodes For This Cell Of The Map
+		//------------------------------------------------
+		TGraphCells::SCell&			Cell = mCells.get_cell(position[0], position[1]);
+		if (Cell.mNodes.empty() && Cell.mEdges.empty())
+		{
+#ifndef FINAL_BUILD
+			if (g_developer->value)
+			{
+				gi.Printf("WARNING: Failure To Find A Node Here, Examine Cell Layout\n");
+			}
+#endif
+			return WAYPOINT_NONE;
+		}
+
+		CVec3		Pos(position);
+		SNodeSort	NodeSort;
+
+		// PHASE I - TEST NAV POINTS
+		//===========================
+		{
+			mNearestNavSort.clear();
+			for (int i=0; i<Cell.mNodes.size() && !mNearestNavSort.full(); i++)
+			{
+				CWayNode&	node = mGraph.get_node(Cell.mNodes[i]);
+
+				NodeSort.mHandle	= Cell.mNodes[i];
+				NodeSort.mDistance	= node.mPoint.Dist2(Pos);
+				NodeSort.mInRadius	= (NodeSort.mDistance<(node.mRadius*node.mRadius));
+
+				// Severly Bias Points That Are Not On The Same Z Height As The Pos
+				//------------------------------------------------------------------
+				if (!allowZOffset)
+				{
+					float	ZOff = fabsf(node.mPoint[2] - Pos[2]);
+					if (ZOff>(VIEW_RANGE / 4))
+					{
+						continue;
+					}
+					if (ZOff>30.0f)
+					{
+						NodeSort.mDistance += (ZOff*ZOff);
+					}
+				}
+
+				// Ignore Points That Are Too Far
+				//--------------------------------
+				if (NodeSort.mDistance>(NAV::VIEW_RANGE*NAV::VIEW_RANGE))
+				{
+					continue;
+				}
+
+				// Bias Points That Are Not Connected To Anything
+				//------------------------------------------------
+				if (node.mFlags.get_bit(CWayNode::EWayNodeFlags::WN_ISLAND))
+				{
+					NodeSort.mDistance *= 3.0f;
+				}
+
+				if (previous && previous!=NodeSort.mHandle && !NAV::InSameRegion(previous, NodeSort.mHandle))
+				{
+					NodeSort.mDistance += (100.0f*100.0f);
+				}
+				if (previous>0 && previous!=NodeSort.mHandle && !mGraph.get_edge_across(previous, NodeSort.mHandle))
+				{
+					NodeSort.mDistance += (200.0f*200.0f);
+				}
+				if (goal && goal!=NodeSort.mHandle && !NAV::InSameRegion(goal, NodeSort.mHandle))
+				{
+					NodeSort.mDistance += (300.0f*300.0f);
+				}
+
+
+				// Bias Combat And Goal Nodes Some
+				//---------------------------------
+			//	if (node.mType==NAV::PT_COMBATNODE || node.mType==NAV::PT_GOALNODE)
+			//	{
+			//		NodeSort.mDistance += 50.0f;
+			//	}
+
+				mNearestNavSort.push_back(NodeSort);
+			}
+
+			// Sort Them By Distance
+			//-----------------------
+			mNearestNavSort.sort();
+
+			// Now , Run Through Each Of The Sorted Nodes, Starting With The Closest One
+			//---------------------------------------------------------------------------
+			for (int j=0; j<mNearestNavSort.size(); j++)
+			{
+				// If In The Radius Of This Point, It Is Safe To Return It
+				//---------------------------------------------------------
+				if (mNearestNavSort[j].mInRadius)
+				{
+					return mNearestNavSort[j].mHandle;
+				}
+
+				// Otherwise, We Need To Trace To It
+				//-----------------------------------
+				else if (ViewNavTrace(Pos, mGraph.get_node(mNearestNavSort[j].mHandle).mPoint))
+				{
+					return mNearestNavSort[j].mHandle;
+				}
+			}
+		}
+
+		// PHASE II: TEST NAV EDGES
+		//==========================
+		{
+			CVec3	Point;
+			CVec3	PointOnEdge;
+			float	PointOnEdgeRange;
+			mNearestNavSort.clear();
+			for (int i=0; i<Cell.mEdges.size() && !mNearestNavSort.full(); i++)
+			{
+				CWayEdge&	edge = mGraph.get_edge(Cell.mEdges[i]);
+
+				edge.Point(Point);
+
+				NodeSort.mHandle	= Cell.mEdges[i];
+				NodeSort.mDistance	= Point.Dist2(Pos);
+
+				// Severly Bias Points That Are Not On The Same Z Height As The Pos
+				//------------------------------------------------------------------
+				if (!allowZOffset)
+				{
+					float	ZOff = fabsf(Point[2] - Pos[2]);
+					if (ZOff>(VIEW_RANGE / 4))
+					{
+						continue;
+					}
+					if (ZOff>30.0f)
+					{
+						NodeSort.mDistance += (ZOff*ZOff);
+					}
+				}
+
+				// Ignore Points That Are Too Far
+				//--------------------------------
+				if (NodeSort.mDistance>(NAV::VIEW_RANGE*NAV::VIEW_RANGE))
+				{
+					continue;
+				}
+				mNearestNavSort.push_back(NodeSort);
+			}
+
+			// Sort Them By Distance
+			//-----------------------
+			mNearestNavSort.sort();
+
+			// Now , Run Through Each Of The Sorted Edges, Starting With The Closest One
+			//---------------------------------------------------------------------------
+			for (int j=0; j<mNearestNavSort.size(); j++)
+			{
+				CWayEdge&	edge = mGraph.get_edge(mNearestNavSort[j].mHandle);
+				PointOnEdge = Pos;
+
+				PointOnEdgeRange = PointOnEdge.ProjectToLine(edge.PointA(), edge.PointB());
+
+				if (PointOnEdgeRange>0.0f && PointOnEdgeRange<1.0f)
+				{
+					// Otherwise, We Need To Trace To It
+					//-----------------------------------
+					if (ViewNavTrace(Pos, PointOnEdge))
+					{
+						return (mNearestNavSort[j].mHandle * -1);	// "Edges" have negative IDs
+					}
+				}
+			}
+		}
+	}
+	return WAYPOINT_NONE;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// 
+////////////////////////////////////////////////////////////////////////////////////////
+NAV::TNodeHandle		NAV::ChooseRandomNeighbor(NAV::TNodeHandle NodeHandle)
+{
+	if (NodeHandle!=WAYPOINT_NONE && NodeHandle>0)
+	{
+		TGraph::TNodeNeighbors&	neighbors = mGraph.get_node_neighbors(NodeHandle);
+		if (neighbors.size()>0)
+		{
+			return (neighbors[Q_irand(0, neighbors.size()-1)].mNode);
+		}
+	}
+	return WAYPOINT_NONE;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// 
+////////////////////////////////////////////////////////////////////////////////////////
+NAV::TNodeHandle		NAV::ChooseRandomNeighbor(TNodeHandle NodeHandle, const vec3_t& position, float maxDistance)
+{
+	if (NodeHandle!=WAYPOINT_NONE && NodeHandle>0)
+	{
+		CVec3 Pos(position);
+
+		TGraph::TNodeNeighbors&	neighbors = mGraph.get_node_neighbors(NodeHandle);
+
+		// Remove All Neighbors That Are Too Far
+		//---------------------------------------
+		for (int i=0; i<neighbors.size(); i++)
+		{
+			if (mGraph.get_node(neighbors[i].mNode).mPoint.Dist(Pos)>maxDistance)
+			{
+				neighbors.erase_swap(i);
+				i--;
+				if (neighbors.empty())
+				{
+					return WAYPOINT_NONE;
+				}
+			}
+		}
+
+		// Now, Randomly Pick From What Is Left
+		//--------------------------------------
+		if (neighbors.size()>0)
+		{
+			return (neighbors[Q_irand(0, neighbors.size()-1)].mNode);
+		}
+	}
+	return WAYPOINT_NONE;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// 
+////////////////////////////////////////////////////////////////////////////////////////
+NAV::TNodeHandle		NAV::ChooseClosestNeighbor(NAV::TNodeHandle NodeHandle, const vec3_t& position)
+{
+	if (NodeHandle!=WAYPOINT_NONE && NodeHandle>0)
+	{
+		CVec3					pos(position);
+		TGraph::TNodeNeighbors&	neighbors = mGraph.get_node_neighbors(NodeHandle);
+
+		NAV::TNodeHandle	Cur			= WAYPOINT_NONE;
+		float				CurDist		= 0.0f;
+		NAV::TNodeHandle	Best		= NodeHandle;
+		float				BestDist	= mGraph.get_node(Cur).mPoint.Dist2(pos);
+
+		for (int i=0; i<neighbors.size(); i++)
+		{
+			Cur		= neighbors[i].mNode;
+			CurDist = mGraph.get_node(Cur).mPoint.Dist2(pos);
+			if (Best==WAYPOINT_NONE || BestDist<CurDist)
+			{
+				Best		= Cur;
+				BestDist	= CurDist;
+			}
+		}
+		return Best;
+	}
+	return WAYPOINT_NONE;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// 
+////////////////////////////////////////////////////////////////////////////////////////
+NAV::TNodeHandle		NAV::ChooseFarthestNeighbor(NAV::TNodeHandle NodeHandle, const vec3_t& position)
+{
+	if (NodeHandle!=WAYPOINT_NONE && NodeHandle>0)
+	{
+		CVec3					pos(position);
+		TGraph::TNodeNeighbors&	neighbors = mGraph.get_node_neighbors(NodeHandle);
+
+		NAV::TNodeHandle	Cur			= WAYPOINT_NONE;
+		float				CurDist		= 0.0f;
+		NAV::TNodeHandle	Best		= NodeHandle;
+		float				BestDist	= mGraph.get_node(Cur).mPoint.Dist2(pos);
+
+		for (int i=0; i<neighbors.size(); i++)
+		{
+			Cur		= neighbors[i].mNode;
+			CurDist = mGraph.get_node(Cur).mPoint.Dist2(pos);
+			if (Best==WAYPOINT_NONE || BestDist>CurDist)
+			{
+				Best		= Cur;
+				BestDist	= CurDist;
+			}
+		}
+		return Best;
+	}
+	return WAYPOINT_NONE;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// 
+////////////////////////////////////////////////////////////////////////////////////////
+NAV::TNodeHandle		NAV::ChooseFarthestNeighbor(gentity_t* actor, const vec3_t& target, float maxSafeDot)
+{
+	CVec3					actorPos(actor->currentOrigin);
+	CVec3					targetPos(target);
+	CVec3					actorToTgt(targetPos - actorPos);
+	float					actorToTgtDist = actorToTgt.Norm();
+
+	NAV::TNodeHandle		cur			= GetNearestNode(actor);
+
+	// If Not Anywhere, Give Up
+	//--------------------------
+	if (cur==WAYPOINT_NONE)
+	{
+		return WAYPOINT_NONE;
+	}
+
+	// If On An Edge, Pick The Safest Of The Two Points
+	//--------------------------------------------------
+	if (cur<0)
+	{
+		CWayEdge& edge = mGraph.get_edge(abs(cur));
+		if (edge.PointA().Dist2(targetPos)>edge.PointA().Dist2(actorPos))
+		{
+			return edge.mNodeA;
+		}
+		return edge.mNodeB;
+	}
+
+	CVec3					curPos(mGraph.get_node(cur).mPoint);
+	CVec3					curToTgt(targetPos - curPos);
+	float					curDist		= curToTgt.SafeNorm();
+//	float					curDot		= curToTgt.Dot(actorToTgt);
+	NAV::TNodeHandle		best		= WAYPOINT_NONE;
+	float					bestDist	= 0.0f;
+	TGraph::TNodeNeighbors&	neighbors	= mGraph.get_node_neighbors(cur);
+
+
+	// If The Actor's Current Point Is Valid, Initialize The Best One To That
+	//------------------------------------------------------------------------
+	if (curDist>actorToTgtDist && actorPos.Dist(curPos)>300.0f)//curDot<maxSafeDot
+	{
+		best		= cur;
+		bestDist	= curDist;
+	}
+
+
+	for (int i=0; i<neighbors.size(); i++)
+	{
+		cur			= neighbors[i].mNode;
+		curPos		= (mGraph.get_node(cur).mPoint);
+		curToTgt	= (targetPos - curPos);
+		curDist		= curToTgt.SafeNorm();
+//		curDot		= curToTgt.Dot(actorToTgt);
+
+		if (curDist>bestDist && curDist>actorToTgtDist)//curDot<maxSafeDot
+		{
+			best		= cur;
+			bestDist	= curDist;
+		}
+	}
+	return best;
+}
+
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// 
+////////////////////////////////////////////////////////////////////////////////////////
+bool	NAV::FindPath(gentity_t* actor, NAV::TNodeHandle target, float MaxDangerLevel)
+{
+	mUser.ClearActor();
+
+	// If Either Start Or End Is Invalid, We Can't Do Any Pathing
+	//------------------------------------------------------------
+	if (target==WAYPOINT_NONE)
+	{
+		return false;
+	}
+
+	NAV::TNodeHandle	start = GetNearestNode(actor, true, target);
+	if (start==WAYPOINT_NONE)
+	{
+		return false;
+	}
+
+	// Convert Edges To Points
+	//------------------------
+	if (start<0)
+	{
+		start = (Q_irand(0,1)==0)?(mGraph.get_edge(abs(start)).mNodeA):(mGraph.get_edge(abs(start)).mNodeB);
+	}
+	if (target<0)
+	{
+		target = (Q_irand(0,1)==0)?(mGraph.get_edge(abs(target)).mNodeA):(mGraph.get_edge(abs(target)).mNodeB);
+	}
+
+	mUser.SetActor(actor);
+
+	// First Step: Find The Actor And Make Sure He Has A Path User Struct
+	//--------------------------------------------------------------------
+	int pathUserNum = mPathUserIndex[actor->s.number];
+	if (pathUserNum==NULL_PATH_USER_INDEX)
+	{
+		if (mPathUsers.full())
+		{
+			assert("NAV: No more unused path users, possibly change MAX_PATH_USERS"==0);
+			return false;
+		}
+
+		pathUserNum = mPathUsers.alloc();
+		mPathUsers[pathUserNum].mEnd			= WAYPOINT_NONE;
+		mPathUsers[pathUserNum].mSuccess		= false;
+		mPathUsers[pathUserNum].mLastAStarTime	= 0;
+		mPathUserIndex[actor->s.number]			= pathUserNum;
+	}
+	SPathUser&	puser = mPathUsers[pathUserNum];
+	puser.mLastUseTime = level.time;
+
+
+	// Now, Check To See If He Already Has Found A Path To This Target
+	//-----------------------------------------------------------------
+	if (puser.mEnd==target && level.time<puser.mLastAStarTime)
+	{
+		return puser.mSuccess;
+	}
+
+
+
+	// Setup The Search
+	//------------------
+	mSearch.mStart	= start;
+	mSearch.mEnd	= target;
+	puser.mEnd		= target;
+
+
+	// First Check The Region
+	//------------------------
+	if (mRegion.size()>0 && !mRegion.has_valid_edge(mSearch.mStart, mSearch.mEnd, mUser))
+	{
+		puser.mSuccess = false;
+		return puser.mSuccess;
+	}
+
+
+
+	// Now, Run A*
+	//-------------
+	if (actor->enemy && actor->enemy->client)
+	{
+		if (actor->enemy->client->ps.weapon==WP_SABER)
+		{
+			mUser.SetDangerSpot(actor->enemy->currentOrigin, 200.0f);
+		}
+		else if (
+			actor->enemy->client->NPC_class==CLASS_RANCOR ||
+			actor->enemy->client->NPC_class==CLASS_WAMPA)
+		{
+			mUser.SetDangerSpot(actor->enemy->currentOrigin, 400.0f);
+		}
+	}
+	mGraph.astar(mSearch, mUser);
+	mUser.ClearDangerSpot();
+
+	puser.mLastAStarTime = level.time + Q_irand(3000, 6000);
+	puser.mSuccess = mSearch.success();
+	if (!puser.mSuccess)
+	{
+		return puser.mSuccess;
+	}
+
+
+	// Grab A Couple "Current Conditions"
+	//------------------------------------
+	CVec3	At(actor->currentOrigin);
+	float	AtTime	= level.time;
+	float	AtSpeed = actor->NPC->stats.runSpeed;
+	if (!(actor->NPC->scriptFlags&SCF_RUNNING) && 
+		((actor->NPC->scriptFlags&SCF_WALKING) ||
+		 (actor->NPC->aiFlags&NPCAI_WALKING) || 
+		 (ucmd.buttons&BUTTON_WALKING)		
+		))
+	{
+		AtSpeed	= actor->NPC->stats.walkSpeed;
+	}
+
+	AtSpeed *= 0.001f;		// Convert units/sec to units/millisec for comparison against level.time
+	AtSpeed *= 0.25;		// Cut the speed in half to account for accel & decel & some slop
+
+
+
+	// Get The Size Of This Actor
+	//----------------------------
+	float minRadius = Min(actor->mins[0], actor->mins[1]);
+	float maxRadius = Max(actor->maxs[0], actor->maxs[1]);
+	float radius = Max(fabsf(minRadius), maxRadius);
+
+	if (radius>20.0f)
+	{
+		radius = 20.0f;
+	}
+
+
+	// Copy The Search Results Into The Path
+	//---------------------------------------
+	{
+		SPathPoint	PPoint;
+		puser.mPath.clear();
+		for (mSearch.path_begin(); !mSearch.path_end() && !puser.mPath.full(); mSearch.path_inc())
+		{
+			if (puser.mPath.full())
+			{
+				// NAV_TODO: If the path is longer than the max length, we want to store the first valid ones, instead of returning false
+				assert("This Is A Test To See If We Hit This Condition Anymore...  It Should Be Handled Properly"==0);
+				mPathUsers.free(pathUserNum);
+				mPathUserIndex[actor->s.number]		= NULL_PATH_USER_INDEX;
+				return false;
+			}
+
+			PPoint.mNode				= mSearch.path_at();
+			PPoint.mPoint				= mGraph.get_node(PPoint.mNode).mPoint;
+			PPoint.mSpeed				= AtSpeed;
+			PPoint.mSlowingRadius		= 0.0f;
+			PPoint.mReachedRadius		= Max(radius*3.0f, (mGraph.get_node(PPoint.mNode).mRadius * 0.40f));
+			if (mGraph.get_node(PPoint.mNode).mFlags.get_bit(CWayNode::EWayNodeFlags::WN_FLOATING))
+			{
+				PPoint.mReachedRadius	= 20.0f;
+			}
+			PPoint.mReachedRadius		*= PPoint.mReachedRadius;	// squared, for faster checks later
+			PPoint.mDist				= 0.0f;
+			PPoint.mETA					= 0.0f;
+
+			puser.mPath.push_back(PPoint);
+		}
+		assert(puser.mPath.size()>0);
+
+
+		// Last Point On The Path Always Gets A Slowing Radius
+		//-----------------------------------------------------
+		puser.mPath[0].mSlowingRadius	= Max(70.0f, (mGraph.get_node(PPoint.mNode).mRadius * 0.75f));
+		puser.mPath[0].mReachedRadius	= Max(radius, (mGraph.get_node(PPoint.mNode).mRadius * 0.15f));
+		puser.mPath[0].mReachedRadius	*= puser.mPath[0].mReachedRadius;	// squared, for faster checks later
+	}
+
+	int numEdges = (puser.mPath.size()-1);
+
+
+	// Trim Out Backtracking Edges 
+	//-----------------------------
+	for (int edge=0; edge<numEdges; edge++)
+	{
+		CVec3	PointA(puser.mPath[edge].mPoint);
+		CVec3	PointB(puser.mPath[edge+1].mPoint);
+
+		CVec3	AtOnEdge(At);
+		float	AtOnEdgeScale = AtOnEdge.ProjectToLineSeg(PointA, PointB);
+		float	AtDistToEdge = AtOnEdge.Dist(At);
+
+		if (AtOnEdgeScale>0.1f && AtOnEdgeScale<0.9f)
+		{
+			if (AtDistToEdge<(radius) || (AtDistToEdge<(radius*20.0f) && MoveTrace(At, AtOnEdge, actor->mins, actor->maxs, actor->s.number, true, true, false)))
+			{
+				puser.mPath.resize(edge+2);			// +2 because every edge needs at least 2 points
+				puser.mPath[edge+1].mPoint = AtOnEdge;
+				break;
+			}
+		}
+	}
+
+
+
+	// For All Points On The Path, Compute ETA, And Check For Sharp Corners
+	//----------------------------------------------------------------------
+	CVec3	AtToNext;
+	CVec3	NextToBeyond;
+	float	NextToBeyondDistance;
+	float	NextToBeyondDot;
+
+	for (int i=puser.mPath.size()-1; i>-1; i--)
+	{
+		SPathPoint&		PPoint	= puser.mPath[i];					// For Debugging And A Tad Speed Improvement, Get A Ref Directly
+
+		AtToNext		= (PPoint.mPoint - At);
+		if (fabsf(AtToNext[2])>Z_CULL_OFFSET)
+		{
+			AtToNext[2] = 0.0f;
+		}
+
+		PPoint.mDist	=  AtToNext.Norm();					// Get The Distance And Norm The Direction
+		PPoint.mETA		=  (PPoint.mDist / PPoint.mSpeed);	// Estimate Our Eta By Distance/Speed
+		PPoint.mETA		+= AtTime;
+
+
+		// Check To See If This Is The Apex Of A Sharp Turn
+		//--------------------------------------------------
+		if (i!=0 &&			//is there a next point?
+			!mGraph.get_node(PPoint.mNode).mFlags.get_bit(CWayNode::EWayNodeFlags::WN_FLOATING)
+			)
+		{
+			NextToBeyond = (puser.mPath[i-1].mPoint - PPoint.mPoint);
+			if (fabsf(NextToBeyond[2])>Z_CULL_OFFSET)
+			{
+				NextToBeyond[2] = 0.0f;
+			}
+			NextToBeyondDistance = NextToBeyond.Norm();
+			NextToBeyondDot = NextToBeyond.Dot(AtToNext);
+
+			if ((NextToBeyondDistance>150.0f && PPoint.mDist>150.0f && NextToBeyondDot<0.64f) ||
+				(NextToBeyondDistance>30.0f && NextToBeyondDot<0.5f))
+			{
+				PPoint.mSlowingRadius = Max(40.0f, mGraph.get_node(PPoint.mNode).mRadius);		// Force A Stop Here
+			}
+		}
+
+		// Update Our Time And Location For The Next Point
+		//-------------------------------------------------
+		AtTime	= PPoint.mETA;
+		At		= PPoint.mPoint;
+	}
+
+	// Failed To Find An Acceptibly Safe Path
+	//----------------------------------------
+	if (MaxDangerLevel!=1.0f && NAV::PathDangerLevel(NPC)>MaxDangerLevel)
+	{
+		puser.mSuccess = false;
+	}
+
+
+	assert(puser.mPath.size()>0);
+	return puser.mSuccess;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// 
+////////////////////////////////////////////////////////////////////////////////////////
+bool			NAV::SafePathExists(const CVec3& startVec, const CVec3& stopVec, const CVec3& danger, float dangerDistSq)
+{
+	mUser.ClearActor();
+
+
+	// If Either Start Or End Is Invalid, We Can't Do Any Pathing
+	//------------------------------------------------------------
+	NAV::TNodeHandle	target = GetNearestNode(stopVec.v, 0, 0, 0, true);
+	if (target==WAYPOINT_NONE)
+	{
+		return false;
+	}
+
+	NAV::TNodeHandle	start = GetNearestNode(startVec.v, 0, target, 0, true);
+	if (start==WAYPOINT_NONE)
+	{
+		return false;
+	}
+
+	// Convert Edges To Points
+	//------------------------
+	if (start<0)
+	{
+		start = mGraph.get_edge(abs(start)).mNodeA;
+	}
+	if (target<0)
+	{
+		target = mGraph.get_edge(abs(target)).mNodeA;
+	}
+	if (start==target)
+	{
+		return true;
+	}
+
+
+	// First Step: Find The Actor And Make Sure He Has A Path User Struct
+	//--------------------------------------------------------------------
+	SPathUser&	puser = mPathUserMaster;
+	puser.mLastUseTime = level.time;
+
+
+	// Now, Check To See If He Already Has Found A Path To This Target
+	//-----------------------------------------------------------------
+	if (puser.mEnd==target && level.time<puser.mLastAStarTime)
+	{
+		return puser.mSuccess;
+	}
+
+
+
+	// Setup The Search
+	//------------------
+	mSearch.mStart	= start;
+	mSearch.mEnd	= target;
+	puser.mEnd		= target;
+
+
+	// First Check The Region
+	//------------------------
+ 	if (mRegion.size()>0 && !mRegion.has_valid_edge(mSearch.mStart, mSearch.mEnd, mUser))
+	{
+		puser.mSuccess = false;
+		return puser.mSuccess;
+	}
+
+	// Now, Run A*
+	//-------------
+//	mUser.SetDangerSpot(danger, dangerDistSq);
+	mGraph.astar(mSearch, mUser);
+//	mUser.ClearDangerSpot();
+
+	puser.mLastAStarTime = level.time + Q_irand(3000, 6000);;
+	puser.mSuccess = mSearch.success();
+	if (!puser.mSuccess)
+	{
+		return puser.mSuccess;
+	}
+
+
+	// Failed To Find An Acceptibly Safe Path
+	//----------------------------------------
+	CVec3	Prev(stopVec);
+	CVec3	Next;
+	for (mSearch.path_begin(); !mSearch.path_end(); mSearch.path_inc())
+	{
+		Next = mGraph.get_node(mSearch.path_at()).mPoint;
+		if (dangerDistSq > danger.DistToLine2(Next, Prev))
+		{
+			puser.mSuccess = false;
+			break;
+		}
+		Prev = Next;
+	}
+	if (puser.mSuccess)
+	{
+		Next = startVec;
+		if (dangerDistSq > danger.DistToLine2(Prev, Next))
+		{
+			puser.mSuccess = false;
+		}
+	}
+
+	return puser.mSuccess;
+}
+
+
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// 
+////////////////////////////////////////////////////////////////////////////////////////
+float			NAV::EstimateCostToGoal(const vec3_t& position, TNodeHandle Goal)
+{
+	if (Goal!=0 && Goal!=WAYPOINT_NONE)
+	{
+		return	(Distance(position, GetNodePosition(Goal)));
+	}
+	return 0.0f;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// 
+////////////////////////////////////////////////////////////////////////////////////////
+float			NAV::EstimateCostToGoal(TNodeHandle Start, TNodeHandle Goal)
+{
+	mUser.ClearActor();
+	if (Goal!=0 && Goal!=WAYPOINT_NONE && Start!=0 && Start!=WAYPOINT_NONE)
+	{
+		return (Distance(GetNodePosition(Start), GetNodePosition(Goal)));
+	}
+	return 0.0f;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// 
+////////////////////////////////////////////////////////////////////////////////////////
+bool			NAV::OnSamePoint(gentity_t* actor, gentity_t* target)
+{
+	return (GetNearestNode(actor)==GetNearestNode(target));
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// 
+////////////////////////////////////////////////////////////////////////////////////////
+bool			NAV::InSameRegion(gentity_t* actor, gentity_t* target)
+{
+	mUser.ClearActor();
+	if (mRegion.size()>0)
+	{
+		NAV::TNodeHandle	actNode = GetNearestNode(actor);
+		NAV::TNodeHandle	tgtNode = GetNearestNode(target);
+		if (actNode==WAYPOINT_NONE || tgtNode==WAYPOINT_NONE)
+		{
+			return false;
+		}
+		if (actNode==tgtNode)
+		{
+			return true;
+		}
+
+		if (actNode<0)
+		{
+			actNode = mGraph.get_edge(abs(actNode)).mNodeA;
+		}
+		if (tgtNode<0)
+		{
+			tgtNode = mGraph.get_edge(abs(tgtNode)).mNodeA;
+		}
+
+		mUser.SetActor(actor);
+
+		return (mRegion.has_valid_edge(actNode, tgtNode, mUser));
+	}
+	return true;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// 
+////////////////////////////////////////////////////////////////////////////////////////
+bool			NAV::InSameRegion(gentity_t* actor, const vec3_t& position)
+{
+	mUser.ClearActor();
+	if (mRegion.size()>0)
+	{
+		NAV::TNodeHandle	actNode = GetNearestNode(actor);
+		NAV::TNodeHandle	tgtNode = GetNearestNode(position);
+
+		if (actNode==WAYPOINT_NONE || tgtNode==WAYPOINT_NONE)
+		{
+			return false;
+		}
+		if (actNode==tgtNode)
+		{
+			return true;
+		}
+
+		if (actNode<0)
+		{
+			actNode = mGraph.get_edge(abs(actNode)).mNodeA;
+		}
+		if (tgtNode<0)
+		{
+			tgtNode = mGraph.get_edge(abs(tgtNode)).mNodeA;
+		}
+
+		mUser.SetActor(actor);
+
+		return (mRegion.has_valid_edge(actNode, tgtNode, mUser));
+	}
+	return true;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// 
+////////////////////////////////////////////////////////////////////////////////////////
+bool			NAV::InSameRegion(NAV::TNodeHandle A, NAV::TNodeHandle B)
+{
+	if (mRegion.size()>0)
+	{
+		NAV::TNodeHandle	actNode = A;
+		NAV::TNodeHandle	tgtNode = B;
+
+		if (actNode==WAYPOINT_NONE || tgtNode==WAYPOINT_NONE)
+		{
+			return false;
+		}
+		if (actNode==tgtNode)
+		{
+			return true;
+		}
+
+		if (actNode<0)
+		{
+			actNode = mGraph.get_edge(abs(actNode)).mNodeA;
+		}
+		if (tgtNode<0)
+		{
+			tgtNode = mGraph.get_edge(abs(tgtNode)).mNodeA;
+		}
+
+		gentity_t*	tempActor = mUser.GetActor();
+		mUser.ClearActor();
+		bool	hasEdge = mRegion.has_valid_edge(actNode, tgtNode, mUser);
+		if (tempActor)
+		{
+			mUser.SetActor(tempActor);
+		}
+		return hasEdge;
+	}
+	return true;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// 
+////////////////////////////////////////////////////////////////////////////////////////
+bool			NAV::OnNeighboringPoints(TNodeHandle A, TNodeHandle B)
+{
+	if (A==B)
+	{
+		return true;
+	}
+
+	if (A<=0 || B<=0)
+	{
+		return false;
+	}
+	int edgeNum = mGraph.get_edge_across(A, B);
+	if (edgeNum && 
+		!mGraph.get_edge(edgeNum).mFlags.get_bit(CWayEdge::EWayEdgeFlags::WE_JUMPING) && 
+		!mGraph.get_edge(edgeNum).mFlags.get_bit(CWayEdge::EWayEdgeFlags::WE_FLYING) && 
+		 mGraph.get_edge(edgeNum).mDistance<SAFE_NEIGHBORINGPOINT_DIST)
+	{
+		return true;
+	}
+	return false;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// 
+////////////////////////////////////////////////////////////////////////////////////////
+bool			NAV::OnNeighboringPoints(gentity_t* actor, gentity_t* target)
+{
+	if (OnNeighboringPoints(GetNearestNode(actor), GetNearestNode(target)))
+	{
+		if (Distance(actor->currentOrigin, target->currentOrigin)<NEIGHBORING_DIST)
+		{
+//			if (ViewNavTrace(actor->currentOrigin, target->currentOrigin))
+			{
+				return true;
+			}
+		}
+	}
+	return false;
+}
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// 
+////////////////////////////////////////////////////////////////////////////////////////
+bool			NAV::OnNeighboringPoints(gentity_t* actor, const vec3_t& position)
+{
+	if (OnNeighboringPoints(GetNearestNode(actor), GetNearestNode(position)))
+	{
+		if (Distance(actor->currentOrigin, position)<NEIGHBORING_DIST)
+		{
+//			if (ViewNavTrace(actor->currentOrigin, position))
+			{
+				return true;
+			}
+		}
+	}
+	return false;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Is The Position (at) within the safe radius of the atNode, targetNode, or the edge
+// between?
+////////////////////////////////////////////////////////////////////////////////////////
+bool			NAV::InSafeRadius(CVec3 at, TNodeHandle atNode, TNodeHandle targetNode)
+{
+	// Uh, No
+	//--------
+	if (atNode<=0)
+	{
+		return false;
+	}
+
+	// If In The Radius Of Nearest Nav Point
+	//---------------------------------------
+	if (Distance(at.v, GetNodePosition(atNode))<mGraph.get_node(atNode).mRadius)
+	{
+		return true;
+	}
+
+	// If We Have A Target Node, We May Be On The Edge That Connects Between The Two
+	//-------------------------------------------------------------------------------
+	if (targetNode>0 && atNode!=targetNode)
+	{
+		// If In The Radius Of Target Nav Point
+		//---------------------------------------
+		if (Distance(at.v, GetNodePosition(targetNode))<mGraph.get_node(targetNode).mRadius)
+		{
+			return true;
+		}
+
+		// Does The Edge Exist?
+		//----------------------
+		int	atToTargetEdgeIndex = mGraph.get_edge_across(atNode, targetNode);
+		if (atToTargetEdgeIndex!=0)
+		{
+			CWayEdge&	atToTargetEdge	= mGraph.get_edge(atToTargetEdgeIndex);
+
+			// Is The Edge Valid?
+			//--------------------
+			if (!atToTargetEdge.mFlags.get_bit(CWayEdge::EWayEdgeFlags::WE_FLYING) &&
+				!atToTargetEdge.mFlags.get_bit(CWayEdge::EWayEdgeFlags::WE_JUMPING) &&
+				mUser.is_valid(atToTargetEdge, targetNode))
+			{
+				float	atDistToEdge = at.DistToLine(atToTargetEdge.PointA(), atToTargetEdge.PointB());
+
+				// Now Are We Close Enough To The Edge
+				//-------------------------------------
+				if (atToTargetEdge.mFlags.get_bit(CWayEdge::EWayEdgeFlags::WE_SIZE_LARGE))
+				{
+					return (atDistToEdge<SC_LARGE_RADIUS);
+				}
+				return (atDistToEdge<SC_MEDIUM_RADIUS);
+			}// not valid edge
+		}// no edge
+	}// no valid target
+	return false;
+}
+
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// 
+////////////////////////////////////////////////////////////////////////////////////////
+bool			NAV::FindPath(gentity_t* actor, gentity_t* target, float MaxDangerLevel)
+{
+	assert(target!=0 && actor!=0);
+	if (target!=0 && actor!=0)
+	{
+		if (target->waypoint==WAYPOINT_NONE)
+		{
+			GetNearestNode(target);
+		}
+		if (target->waypoint!=WAYPOINT_NONE)
+		{
+			return FindPath(actor, target->waypoint, MaxDangerLevel);
+		}
+		else if (target->lastWaypoint!=WAYPOINT_NONE)
+		{
+			return FindPath(actor, target->lastWaypoint, MaxDangerLevel);
+		}
+	}
+	return false;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// 
+////////////////////////////////////////////////////////////////////////////////////////
+bool			NAV::FindPath(gentity_t* actor, const vec3_t& position, float MaxDangerLevel)
+{
+	return FindPath(actor, GetNearestNode(position), MaxDangerLevel);
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// 
+////////////////////////////////////////////////////////////////////////////////////////
+const vec3_t&	NAV::NextPosition(gentity_t* actor)
+{
+	assert(HasPath(actor));
+	TPath&	path = mPathUsers[mPathUserIndex[actor->s.number]].mPath;
+
+	return (path[path.size()-1].mPoint.v);
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// 
+////////////////////////////////////////////////////////////////////////////////////////
+bool			NAV::NextPosition(gentity_t* actor, CVec3& Position)
+{
+	assert(HasPath(actor));
+	TPath&	path = mPathUsers[mPathUserIndex[actor->s.number]].mPath;
+	Position		= path[path.size()-1].mPoint;
+	return true;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// 
+////////////////////////////////////////////////////////////////////////////////////////
+bool			NAV::NextPosition(gentity_t* actor, CVec3& Position, float& SlowingRadius, bool& Fly, bool& Jump)
+{
+	assert(HasPath(actor));
+	TPath&			path = mPathUsers[mPathUserIndex[actor->s.number]].mPath;
+	SPathPoint&		next = path[path.size()-1];
+	CWayNode&		node = mGraph.get_node(next.mNode);
+	int				curNodeIndex	= NAV::GetNearestNode(actor);
+	int				edgeIndex		= (curNodeIndex>0)?(mGraph.get_edge_across(curNodeIndex, next.mNode)):(abs(curNodeIndex));
+
+	SlowingRadius	= next.mSlowingRadius;
+	Position		= next.mPoint;
+	Fly				= node.mFlags.get_bit(CWayNode::EWayNodeFlags::WN_FLOATING);
+
+	if (edgeIndex)
+	{
+		Jump		= mGraph.get_edge(edgeIndex).mFlags.get_bit(CWayEdge::EWayEdgeFlags::WE_JUMPING);
+	}
+
+	return true;
+}
+////////////////////////////////////////////////////////////////////////////////////////
+// This function completely removes any pathfinding information related to this agent
+// and frees up this path user structure for someone else to use.
+////////////////////////////////////////////////////////////////////////////////////////
+void			NAV::ClearPath(gentity_t* actor)
+{
+	int pathUserNum = mPathUserIndex[actor->s.number];
+	if (pathUserNum==NULL_PATH_USER_INDEX)
+	{
+		return;
+	}
+
+	mPathUsers.free(pathUserNum);
+	mPathUserIndex[actor->s.number] = NULL_PATH_USER_INDEX;
+}
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Update Path
+//
+// Removes points that have been reached, and frees the user if no points remain.
+//
+////////////////////////////////////////////////////////////////////////////////////////
+bool			NAV::UpdatePath(gentity_t* actor, TNodeHandle target, float MaxDangerLevel)
+{
+	int pathUserNum = mPathUserIndex[actor->s.number];
+	if (pathUserNum==NULL_PATH_USER_INDEX)
+	{
+		return false;
+	}
+	if (!mPathUsers[pathUserNum].mSuccess)
+	{
+		return false;
+	}
+	if (!mPathUsers[pathUserNum].mPath.size())
+	{
+		return false;
+	}
+
+
+	// Remove Any Points We Have Reached
+	//-----------------------------------
+	CVec3		At(actor->currentOrigin);
+	TPath&		path = mPathUsers[pathUserNum].mPath;
+	bool		InReachedRadius = false;
+	bool		ReachedAnything = false;
+	assert(path.size()>0);
+
+	do
+	{
+		SPathPoint&	PPoint	= path[path.size()-1];
+		CVec3	Dir(PPoint.mPoint - At);
+		if (fabsf(At[2] - PPoint.mPoint[2])<Z_CULL_OFFSET)
+		{
+			Dir[2] = 0.0f;
+		}
+
+		InReachedRadius = (Dir.Len2()<PPoint.mReachedRadius);
+		if (InReachedRadius)
+		{
+			ReachedAnything = true;
+			path.pop_back();
+		}
+	} while (InReachedRadius && path.size()>0);
+
+
+	// If We've Reached The End Of The Path, Return With no path!
+	//------------------------------------------------------------
+	if (path.empty())
+	{
+		return false;
+	}
+
+	if (ReachedAnything)
+	{
+		if (target!=PT_NONE && mPathUsers[pathUserNum].mEnd!=target)
+		{
+			return false;
+		}
+	}
+
+	// If Not, Time To Double Check To See If The Path Is Still Valid
+	//----------------------------------------------------------------
+	if (path[path.size()-1].mETA<level.time || (MaxDangerLevel!=1.0f && PathDangerLevel(NPC)>MaxDangerLevel))
+	{
+		// Hmmm.  Should Have Reached This Point By Now, Or Too Dangerous.  Try To Recompute The Path
+		//--------------------------------------------------------------------------------------------
+		NAV::TNodeHandle target = mPathUsers[pathUserNum].mEnd;			// Remember The End As Our Target
+		if (target==WAYPOINT_NONE)
+		{
+			ClearPath(actor);
+			return false;
+		}
+		mPathUsers[pathUserNum].mEnd = WAYPOINT_NONE;					// Clear Out The Old End
+		if (!FindPath(actor, target, MaxDangerLevel))
+		{
+			mPathUsers[pathUserNum].mEnd = target;
+			return false;
+		}
+		return true;
+	}
+
+
+	// Ok, We Have A Path, And Are On-Route
+	//--------------------------------------
+	return true;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// 
+////////////////////////////////////////////////////////////////////////////////////////
+bool			NAV::HasPath(gentity_t* actor, TNodeHandle target)
+{
+	int pathUserNum = mPathUserIndex[actor->s.number];
+	if (pathUserNum==NULL_PATH_USER_INDEX)
+	{
+		return false;
+	}
+	if (!mPathUsers[pathUserNum].mSuccess)
+	{
+		return false;
+	}
+	if (!mPathUsers[pathUserNum].mPath.size())
+	{
+		return false;
+	}
+	if (target!=PT_NONE && mPathUsers[pathUserNum].mEnd!=target)
+	{
+		return false;
+	}
+
+	return true;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// 
+////////////////////////////////////////////////////////////////////////////////////////
+float			NAV::PathDangerLevel(gentity_t* actor)
+{
+	if (!actor)
+	{
+		assert("No Actor!!!"==0);
+		return 0.0f;
+	}
+	int pathUserNum = mPathUserIndex[actor->s.number];
+	if (pathUserNum==NULL_PATH_USER_INDEX)
+	{
+		return 0.0f;
+	}
+	TPath&	Path = mPathUsers[pathUserNum].mPath;
+
+	// If it only has one point, let's say it's not dangerous
+	//--------------------------------------------------------
+	if (Path.size()<2)
+	{
+		return 0.0f;
+	}
+
+	float		DangerLevel			= 0.0f;
+	CVec3		enemyPos;
+	float		enemySafeDist		= 0.0f;
+	float		enemyDangerLevel	= 0.0f;
+	TEdgeHandle	curEdge				= 0;
+	int			curPathAt			= Path.size()-1;
+	TAlertList& al					= mEntityAlertList[actor->s.number];
+	int			alIndex				= 0;
+	TNodeHandle	prevNode			= (GetNearestNode(actor));
+	CVec3		prevPoint(actor->currentOrigin);
+
+
+	// Some Special Enemies Always Cause Persistant Danger
+	//-----------------------------------------------------
+	if (actor->enemy && actor->enemy->client)
+	{
+		if (actor->enemy->client->ps.weapon==WP_SABER ||
+			actor->enemy->client->NPC_class==CLASS_RANCOR ||
+			actor->enemy->client->NPC_class==CLASS_WAMPA)
+		{
+			enemyPos = (actor->enemy->currentOrigin);
+			enemySafeDist = actor->enemy->radius * 10.0f;
+		}
+	}
+
+
+	// Go Through All Remaining Points On The Path
+	//---------------------------------------------
+	for (; curPathAt>=0; curPathAt--)
+	{
+		SPathPoint&	PPoint	= Path[curPathAt];
+
+		// If Any Edges On The Path Have Been Registered As Dangerous
+		//-------------------------------------------------------------
+		if (prevNode<0 || mGraph.get_edge_across(prevNode, PPoint.mNode))
+		{
+			if (prevNode<0)
+			{
+				curEdge = prevNode;
+			}
+			else
+			{
+				curEdge = mGraph.get_edge_across(prevNode, PPoint.mNode);
+			}
+			for (alIndex=0; alIndex<TAlertList::CAPACITY; alIndex++)
+			{
+				if (al[alIndex].mHandle==curEdge && al[alIndex].mDanger>DangerLevel)
+				{
+					DangerLevel = al[alIndex].mDanger;
+				}
+			}
+		}
+
+		// Check For Enemy Position Proximity To This Next Edge (using actual Edge Locations)
+		//------------------------------------------------------------------------------------
+		if (enemySafeDist!=0.0f)
+		{
+			enemyDangerLevel = enemyPos.DistToLine(prevPoint, PPoint.mPoint)/enemySafeDist;
+			if (enemyDangerLevel>DangerLevel)
+			{
+				DangerLevel = enemyDangerLevel;
+			}
+		}
+
+		prevNode	= PPoint.mNode;
+		prevPoint	= PPoint.mPoint;
+	}
+	return DangerLevel;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// 
+////////////////////////////////////////////////////////////////////////////////////////
+int				NAV::PathNodesRemaining(gentity_t* actor)
+{
+	int pathUserNum = mPathUserIndex[actor->s.number];
+	if (pathUserNum==NULL_PATH_USER_INDEX)
+	{
+		return false;
+	}
+	return mPathUsers[pathUserNum].mPath.size();
+
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// 
+////////////////////////////////////////////////////////////////////////////////////////
+const vec3_t&	NAV::GetNodePosition(TNodeHandle NodeHandle)
+{
+	if (NodeHandle!=0)
+	{
+		if (NodeHandle>0)
+		{
+			return (mGraph.get_node(NodeHandle).mPoint.v);
+		}
+		else
+		{
+			return (mGraph.get_edge(abs(NodeHandle)).PointA().v);
+		}
+	}
+	return mZeroVec;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// 
+////////////////////////////////////////////////////////////////////////////////////////
+void			NAV::GetNodePosition(TNodeHandle NodeHandle, vec3_t& position)
+{
+	if (NodeHandle!=0)
+	{
+		if (NodeHandle>0)
+		{
+			VectorCopy(mGraph.get_node(NodeHandle).mPoint.v, position);
+		}
+		else
+		{
+			VectorCopy(mGraph.get_edge(abs(NodeHandle)).PointA().v, position);
+		}
+	}
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Call This function to get the size classification for a given entity
+////////////////////////////////////////////////////////////////////////////////////////
+unsigned int		NAV::ClassifyEntSize(gentity_t* ent)
+{
+	if (ent)
+	{
+		float minRadius = Min(ent->mins[0], ent->mins[1]);
+		float maxRadius = Max(ent->maxs[0], ent->maxs[1]);
+		float radius = Max(fabsf(minRadius), maxRadius);
+		float height = ent->maxs[2];
+
+		if ((radius > SC_MEDIUM_RADIUS) || height > (SC_MEDIUM_HEIGHT))
+		{
+			return CWayEdge::EWayEdgeFlags::WE_SIZE_LARGE;
+		}
+		return CWayEdge::EWayEdgeFlags::WE_SIZE_MEDIUM;
+	}
+	return 0;
+}
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// 
+////////////////////////////////////////////////////////////////////////////////////////
+void			NAV::ShowDebugInfo(const vec3_t& PlayerPosition, int PlayerWaypoint)
+{
+	mUser.ClearActor();
+	CVec3	atEnd;
+
+	// Show Nodes
+	//------------
+	if (NAVDEBUG_showNodes || NAVDEBUG_showCombatPoints || NAVDEBUG_showNavGoals)
+	{
+		for (TGraph::TNodes::iterator atIter=mGraph.nodes_begin(); atIter!=mGraph.nodes_end(); atIter++)
+		{
+			CWayNode& at	= (*atIter);
+			atEnd			= at.mPoint;
+			atEnd[2]		+= 30.0f;
+
+
+			if (gi.inPVS(PlayerPosition, at.mPoint.v))
+			{
+				if (at.mType==NAV::PT_WAYNODE && NAVDEBUG_showNodes)
+				{
+					if (NAVDEBUG_showPointLines)
+					{
+						if (at.mFlags.get_bit(CWayNode::EWayNodeFlags::WN_FLOATING))
+						{
+							CG_DrawEdge(at.mPoint.v, atEnd.v, EDGE_NODE_FLOATING );
+						}
+						else
+						{
+							CG_DrawEdge(at.mPoint.v, atEnd.v, EDGE_NODE_NORMAL );
+						}
+					}
+					else
+					{
+						if (at.mFlags.get_bit(CWayNode::EWayNodeFlags::WN_FLOATING))
+						{
+							CG_DrawNode(at.mPoint.v, NODE_FLOATING );
+						}
+						else
+						{
+							CG_DrawNode(at.mPoint.v, NODE_NORMAL );
+						}
+					}
+					if (NAVDEBUG_showRadius && at.mPoint.Dist2(PlayerPosition)<(at.mRadius*at.mRadius))
+					{
+						if (at.mFlags.get_bit(CWayNode::EWayNodeFlags::WN_FLOATING))
+						{
+							CG_DrawRadius(at.mPoint.v, at.mRadius, NODE_FLOATING );
+						}
+						else
+						{
+							CG_DrawRadius(at.mPoint.v, at.mRadius, NODE_NORMAL );
+						}
+					}
+				}
+				else if (at.mType==NAV::PT_COMBATNODE && NAVDEBUG_showCombatPoints)
+				{
+					if (NAVDEBUG_showPointLines)
+					{
+						CG_DrawEdge(at.mPoint.v, atEnd.v, EDGE_NODE_COMBAT );
+					}
+					else
+					{
+						CG_DrawCombatPoint(at.mPoint.v, 0);
+					}
+				}
+				else if (at.mType==NAV::PT_GOALNODE && NAVDEBUG_showNavGoals)
+				{
+					if (NAVDEBUG_showPointLines)
+					{
+						CG_DrawEdge(at.mPoint.v, atEnd.v, EDGE_NODE_GOAL );
+					}
+					else
+					{
+						CG_DrawNode(at.mPoint.v, NODE_NAVGOAL);
+					}
+				}
+			}
+		}
+	}
+
+
+	// Show Edges
+	//------------
+	if (NAVDEBUG_showEdges)
+	{
+		for (TGraph::TEdges::iterator atIter=mGraph.edges_begin(); atIter!=mGraph.edges_end(); atIter++)
+		{
+			CWayEdge& at	= (*atIter);
+			CWayNode& a		= mGraph.get_node(at.mNodeA);
+			CWayNode& b		= mGraph.get_node(at.mNodeB);
+			CVec3	AvePos	= a.mPoint + b.mPoint;
+			AvePos *= 0.5f;
+            
+			if (AvePos.Dist2(PlayerPosition)<(500.0f*500.0f) && gi.inPVS(PlayerPosition, AvePos.v))
+			{
+				if (mUser.is_valid(at))
+				{
+					if (at.mFlags.get_bit(CWayEdge::EWayEdgeFlags::WE_JUMPING))
+					{
+						CG_DrawEdge(a.mPoint.v, b.mPoint.v, EDGE_JUMP);
+					}
+					else if (at.mFlags.get_bit(CWayEdge::EWayEdgeFlags::WE_FLYING))
+					{
+						CG_DrawEdge(a.mPoint.v, b.mPoint.v, EDGE_FLY);
+					}
+					else if (at.Size()==CWayEdge::EWayEdgeFlags::WE_SIZE_LARGE)
+					{
+						CG_DrawEdge(a.mPoint.v, b.mPoint.v, EDGE_LARGE);
+					}
+					else
+					{
+						CG_DrawEdge(a.mPoint.v, b.mPoint.v, EDGE_NORMAL);
+					}
+				}
+				else
+				{
+					CG_DrawEdge(a.mPoint.v, b.mPoint.v, EDGE_BLOCKED);
+				}
+			}
+		}
+	}
+	if (NAVDEBUG_showGrid)
+	{
+		float x1, y1;
+		float x2, y2;
+		float z = 0.0f;
+
+		for (int x=0; x<TGraphCells::SIZEX; x++)
+		{
+			for (int y=0; y<TGraphCells::SIZEY; y++)
+			{
+				TGraphCells::TCellNodes& nodes = mCells.get_cell(x, y).mNodes;
+				mCells.get_cell_upperleft(x,y, x1, y1);
+				mCells.get_cell_lowerright(x,y, x2, y2);
+
+				int type = EDGE_CELL_EMPTY;
+				if (nodes.size())
+				{
+					type = EDGE_CELL;
+					z = mGraph.get_node(nodes[0])[2] - 10.0f;
+				}
+
+
+				CVec3	upleft(x1, y1, z);
+				CVec3	upright(x2, y1, z);
+				CVec3	downright(x2, y2, z);
+				CVec3	downleft(x1, y2, z);
+				CVec3	center = (upleft + downright) * 0.5f;
+				if (center.Dist(PlayerPosition)<10000.0f)
+				{
+					CG_DrawEdge(upleft.v, upright.v, type);
+					CG_DrawEdge(upright.v, downright.v, type);
+				//	CG_DrawEdge(downright.v, downleft.v, type);
+				//	CG_DrawEdge(downleft.v, upleft.v, type);
+
+				}
+			}
+		}
+	}
+
+	if ( NAVDEBUG_showTestPath )
+	{
+		// NAV_TODO: Allow Test Paths
+	}
+
+	if ( NAVDEBUG_showNearest && player && (player->waypoint!=0 || player->lastWaypoint!=0))
+	{
+		PlayerWaypoint = (player->waypoint)?(player->waypoint):(player->lastWaypoint);
+		CVec3	PPos(PlayerPosition);
+		if (PlayerWaypoint>0)
+		{
+			CWayNode& node	= mGraph.get_node(PlayerWaypoint);
+
+			CG_DrawEdge(PPos.v, node.mPoint.v, (player->waypoint)?(EDGE_NEARESTVALID):(EDGE_NEARESTINVALID));
+		}
+		else
+		{
+			CWayEdge& edge	= mGraph.get_edge(abs(PlayerWaypoint));
+			CVec3 PosOnLine(PlayerPosition);
+			PosOnLine.ProjectToLineSeg(edge.PointA(), edge.PointB());
+
+			CG_DrawEdge(PPos.v, PosOnLine.v, (player->waypoint)?(EDGE_NEARESTVALID):(EDGE_NEARESTINVALID));
+		}
+	}
+}
+
+////////////////////////////////////////////////////////////////////////////////////
+// Show Stats
+////////////////////////////////////////////////////////////////////////////////////
+void			NAV::ShowStats()
+{
+#if !defined(FINAL_BUILD)
+	mGraph.ProfileSpew();
+	mRegion.ProfileSpew();
+
+	mGraph.ProfilePrint("Point Islands: (%d)", mIslandCount);
+	mGraph.ProfilePrint("");
+	mGraph.ProfilePrint("");
+	mGraph.ProfilePrint("--------------------------------------------------------");
+	mGraph.ProfilePrint("              Star Wars - Jedi Academy                  ");
+	mGraph.ProfilePrint("               Additional Statistics                    ");
+	mGraph.ProfilePrint("--------------------------------------------------------");
+	mGraph.ProfilePrint("");
+	mGraph.ProfilePrint("MEMORY CONSUMPTION (In Bytes)");
+	mGraph.ProfilePrint("Cells  : (%d)", (sizeof(mCells)));
+	mGraph.ProfilePrint("Path   : (%d)", (sizeof(mPathUsers)+sizeof(mPathUserIndex)));
+	mGraph.ProfilePrint("Steer  : (%d)", (sizeof(mSteerUsers)+sizeof(mSteerUserIndex)));
+	mGraph.ProfilePrint("Alerts : (%d)", (sizeof(mEntityAlertList)));
+	float totalBytes = (
+		sizeof(mCells)+
+		sizeof(mGraph)+
+		sizeof(mRegion)+
+		sizeof(mPathUsers)+
+		sizeof(mPathUserIndex)+
+		sizeof(mSteerUsers)+
+		sizeof(mSteerUserIndex)+
+		sizeof(mEntityAlertList));
+
+	mGraph.ProfilePrint("TOTAL :  (KiloBytes): (%5.3f)  MeggaBytes(%3.3f)", 
+			((float)(totalBytes)/1024.0f), 
+			((float)(totalBytes)/1048576.0f)
+			);
+	mGraph.ProfilePrint("");
+
+
+	mGraph.ProfilePrint("Connect Stats: Milliseconds(%d) Traces(%d)", mConnectTime, mConnectTraceCount);
+	mGraph.ProfilePrint("");
+	mGraph.ProfilePrint("Move Trace: Count(%d) PerFrame(%f)", mMoveTraceCount, (float)(mMoveTraceCount)/(float)(level.time));
+	mGraph.ProfilePrint("View Trace: Count(%d) PerFrame(%f)", mViewTraceCount, (float)(mViewTraceCount)/(float)(level.time));
+
+#endif
+}
+
+////////////////////////////////////////////////////////////////////////////////////
+// TeleportTo
+////////////////////////////////////////////////////////////////////////////////////
+void			NAV::TeleportTo(gentity_t* actor, const char* pointName)
+{
+	assert(actor!=0);
+	hstring	nName(pointName);
+	TNameToNodeMap::iterator	nameFinder= mNodeNames.find(nName);
+	if (nameFinder!=mNodeNames.end())
+	{
+		if ((*nameFinder).size()>1)
+		{
+			gi.Printf("WARNING: More than one point named (%s).  Going to first one./n", pointName);
+		}
+		TeleportPlayer(actor, mGraph.get_node((*nameFinder)[0]).mPoint.v, actor->currentAngles);
+		return;
+	}
+	gi.Printf("Unable To Locate Point (%s)\n", pointName);
+}
+
+////////////////////////////////////////////////////////////////////////////////////
+// TeleportTo
+////////////////////////////////////////////////////////////////////////////////////
+void			NAV::TeleportTo(gentity_t* actor, int pointNum)
+{
+	assert(actor!=0);
+	TeleportPlayer(actor, mGraph.get_node(pointNum).mPoint.v, actor->currentAngles);
+	return;
+}
+
+
+
+
+////////////////////////////////////////////////////////////////////////////////////
+// Activate
+////////////////////////////////////////////////////////////////////////////////////
+void			STEER::Activate(gentity_t* actor)
+{
+	assert(!Active(actor) && actor && actor->client && actor->NPC);	// Can't Activate If Already Active
+
+
+// PHASE I - ACTIVATE THE STEER USER FOR THIS ACTOR
+//==================================================
+	if (mSteerUsers.full())
+	{
+		assert("STEER: No more unused steer users, possibly change size"==0);
+		return;
+	}
+
+	// Get A Steer User From The Pool
+	//--------------------------------
+	int steerUserNum = mSteerUsers.alloc();
+	mSteerUserIndex[actor->s.number] = steerUserNum;
+	SSteerUser& suser = mSteerUsers[steerUserNum];
+
+
+// PHASE II - Copy Data For This Actor Into The SUser
+//====================================================
+	suser.mPosition		= actor->currentOrigin;
+	suser.mOrientation	= actor->currentAngles;
+	suser.mVelocity		= actor->client->ps.velocity;
+	suser.mSpeed		= suser.mVelocity.Len();
+
+	suser.mBlocked		= false;
+
+	suser.mMaxSpeed		= actor->NPC->stats.runSpeed;
+	suser.mRadius		= RadiusFromBounds(actor->mins, actor->maxs);
+	suser.mMaxForce		= 150.0f;		//STEER_TODO: Get From actor Somehow
+	suser.mMass			= 1.0f;			//STEER_TODO: Get From actor Somehow
+	if (!(actor->NPC->scriptFlags&SCF_RUNNING) && 
+		((actor->NPC->scriptFlags&SCF_WALKING) ||
+		 (actor->NPC->aiFlags&NPCAI_WALKING) || 
+		 (ucmd.buttons&BUTTON_WALKING)		
+		))
+	{
+		suser.mMaxSpeed	= actor->NPC->stats.walkSpeed;
+	}
+
+	assert(suser.mPosition.IsFinite());
+	assert(suser.mOrientation.IsFinite());
+	assert(suser.mVelocity.IsFinite());
+
+
+	// Find Our Neighbors
+	//--------------------
+	suser.mNeighbors.clear();
+	float	RangeSize = suser.mRadius + STEER::NEIGHBOR_RANGE;
+
+	CVec3	Range(RangeSize, RangeSize, (actor->client->moveType==MT_FLYSWIM)?(RangeSize):(suser.mRadius*2.0f));
+	CVec3	Mins(suser.mPosition - Range);
+	CVec3	Maxs(suser.mPosition + Range);
+
+	gentity_t*	EntityList[MAX_GENTITIES];
+	gentity_t*	neighbor = 0;
+
+	int	numFound = gi.EntitiesInBox(Mins.v, Maxs.v, EntityList, MAX_GENTITIES);
+	for (int i=0; i<numFound; i++) 
+	{
+		neighbor = EntityList[i];
+		assert(neighbor!=0);
+
+		if (neighbor->s.number==actor->s.number || neighbor==actor->enemy || !neighbor->client || neighbor->health<=0 || !neighbor->inuse)
+		{
+			continue;
+		}
+
+		suser.mNeighbors.push_back(neighbor);
+	}
+
+
+	// Clear Out Steering, So If No STEER Operations Are Called, Net Effect Is Zero
+	//------------------------------------------------------------------------------
+	suser.mSteering.Clear();
+	suser.mNewtons		= 0.0f;
+
+	VectorClear(actor->client->ps.moveDir);	
+				actor->client->ps.speed = 0;
+
+
+// PHASE III - Project The Current Velocity Forward, To The Side, And Onto The Path
+//==================================================================================
+	suser.mProjectFwd	= suser.mPosition + (suser.mVelocity * 1.0f);
+	suser.mProjectSide	=                   (suser.mVelocity * 0.3f);
+	suser.mProjectSide.Reposition(suser.mPosition, (actor->NPC->avoidSide==Side_Left)?(40.0f):(-40.0f));
+
+
+	// STEER_TODO: Project The Point The Path (If The character has one)
+	//-------------------------------------------------------------------
+	//suser.mProjectPath	= ;
+
+}
+
+//////////////////////////////////////////////////////////////////////
+// DeActivate
+//
+// This function first scales back the composite steering vector to
+// the max force range, and if there is any steering left, it
+// applies the steering to the velocity.  Velocity is also truncated
+// to be less than Max Speed.
+//
+// Finaly, the results are copied onto the entity and the steer user
+// struct is freed for use by another entity.
+//////////////////////////////////////////////////////////////////////
+void			STEER::DeActivate(gentity_t* actor, usercmd_t* ucmd)
+{
+	assert(Active(actor) && actor && actor->client && actor->NPC);		// Can't Deactivate If Never Activated
+	SSteerUser& suser = mSteerUsers[mSteerUserIndex[actor->s.number]];
+
+
+	assert(suser.mPosition.IsFinite());
+	assert(suser.mOrientation.IsFinite());
+	assert(suser.mSteering.IsFinite());
+	assert(suser.mMass!=0.0f);
+
+
+
+// PHASE I - TRUNCATE STEERING AND APPLY TO VELOCITY
+//===================================================
+	suser.mNewtons	 = suser.mSteering.Truncate(suser.mMaxForce);
+	if (suser.mNewtons>1E-10)
+	{
+		suser.mSteering /= suser.mMass;
+		suser.mVelocity += suser.mSteering;
+		suser.mSpeed	 = suser.mVelocity.Truncate(suser.mMaxSpeed);
+
+		// DEBUG GRAPHICS
+		//=================================================================
+		if (NAVDEBUG_showCollision)
+		{
+			CVec3 EndThrust(suser.mPosition+suser.mSteering);
+			CVec3 EndVelocity(suser.mPosition+suser.mVelocity);
+
+			CG_DrawEdge(suser.mPosition.v, EndThrust.v,		EDGE_THRUST);
+			CG_DrawEdge(suser.mPosition.v, EndVelocity.v,	EDGE_VELOCITY);
+		}
+		//=================================================================
+	}
+	if (suser.mSpeed<10.0f)
+	{
+		suser.mSpeed = 0.0f;
+	}
+
+
+
+
+
+
+
+// PHASE II - CONVERT VELOCITY TO MOVE DIRECTION & ANGLES
+//========================================================
+	if (!NPC_Jumping())
+	{
+		CVec3	MoveDir(suser.mVelocity);
+		CVec3	Angles(actor->NPC->lastPathAngles);
+
+		if (suser.mSpeed>0.0f && MoveDir!=CVec3::mZero)
+		{
+			MoveDir.Norm();
+			CVec3	NewAngles(suser.mVelocity);
+			NewAngles.VecToAng();
+
+			Angles = NewAngles;//((Angles + NewAngles)*0.75f);
+		}
+		assert(MoveDir.IsFinite());
+		assert(Angles.IsFinite());
+
+
+
+// PHASE III - ASSIGN ALL THIS DATA TO THE ACTOR ENTITY
+//======================================================
+		actor->NPC->aiFlags |= NPCAI_NO_SLOWDOWN;
+
+		VectorCopy(MoveDir.v,	
+			actor->client->ps.moveDir);
+			actor->client->ps.speed		= suser.mSpeed;
+
+		VectorCopy(Angles.v,	
+			actor->NPC->lastPathAngles);
+			actor->NPC->desiredPitch	= 0.0f;
+			actor->NPC->desiredYaw		= AngleNormalize360(Angles[YAW]);
+
+
+		// Convert Movement To User Command
+		//----------------------------------
+		if (suser.mSpeed > 0.0f)
+		{
+			vec3_t	forward, right, up;
+			AngleVectors(actor->currentAngles,	forward, right, up);	// Use Current Angles
+
+			float fDot = Com_Clamp(-127.0f, 127.0f, DotProduct(forward, MoveDir.v)*127.0f);
+			float rDot = Com_Clamp(-127.0f, 127.0f, DotProduct(right,   MoveDir.v)*127.0f);
+
+			ucmd->forwardmove	= floor(fDot);
+			ucmd->rightmove		= floor(rDot);
+			ucmd->upmove		= 0.0f;
+
+			if (suser.mSpeed<(actor->NPC->stats.walkSpeed + 5.0f))
+			{
+				ucmd->buttons |= BUTTON_WALKING;
+			}
+			else
+			{
+				ucmd->buttons &= ~BUTTON_WALKING;
+			}
+
+			// Handle Fly Swim Movement
+			//--------------------------
+			if (actor->client->moveType==MT_FLYSWIM)
+			{
+				ucmd->forwardmove	= 0.0f;
+				ucmd->rightmove		= 0.0f;
+
+				VectorCopy(suser.mVelocity.v, actor->client->ps.velocity);
+			}
+		}
+		else
+		{
+			ucmd->forwardmove	= 0.0f;
+			ucmd->rightmove		= 0.0f;
+			ucmd->upmove		= 0.0f;
+
+			// Handle Fly Swim Movement
+			//--------------------------
+			if (actor->client->moveType==MT_FLYSWIM)
+			{
+				VectorClear(actor->client->ps.velocity);
+			}
+		}
+
+		// Slow Down If Going Backwards
+		//------------------------------
+		if (ucmd->forwardmove<0.0f)
+		{
+			client->ps.speed	*= 0.75f;
+			suser.mSpeed		*= 0.75f;
+		}
+
+
+// PHASE IV - UPDATE BLOCKING INFORMATION
+//========================================
+		if		(suser.mBlocked) 
+		{
+			// If Not Previously Blocked, Record The Start Time And Any Entites Involved
+			//---------------------------------------------------------------------------
+			if (!(actor->NPC->aiFlags&NPCAI_BLOCKED))
+			{
+				actor->NPC->aiFlags				|= NPCAI_BLOCKED;
+				actor->NPC->blockedDebounceTime  = level.time;
+			}
+
+			// If Navigation Or Steering Had A Target Entity (Trying To Go To), Record That Here
+			//-----------------------------------------------------------------------------------
+			actor->NPC->blockedTargetEntity  = 0;
+			if (suser.mBlockedTgtEntity!=ENTITYNUM_NONE)
+			{
+				actor->NPC->blockedTargetEntity	 = &g_entities[suser.mBlockedTgtEntity];
+			}
+			VectorCopy(suser.mBlockedTgtPosition.v, actor->NPC->blockedTargetPosition);
+		}
+		else 
+		{
+			// Nothing Blocking, So Turn Off The Blocked Stuff If It Is There
+			//----------------------------------------------------------------
+			if (actor->NPC->aiFlags&NPCAI_BLOCKED)
+			{
+				actor->NPC->aiFlags				&= ~NPCAI_BLOCKED;
+				actor->NPC->blockedDebounceTime  = 0;
+				actor->NPC->blockedTargetEntity	 = 0;
+			}
+		}
+
+		// If We've Been Blocked For More Than 2 Seconds, May Want To Take Corrective Action
+		//-----------------------------------------------------------------------------------
+		if (STEER::HasBeenBlockedFor(actor, 2000))
+		{
+			if (NAVDEBUG_showEnemyPath)
+			{
+				CG_DrawEdge(actor->currentOrigin, actor->NPC->blockedTargetPosition, EDGE_PATHBLOCKED);
+				if (actor->waypoint)
+				{
+					CVec3	Dumb(NAV::GetNodePosition(actor->waypoint));
+					CG_DrawEdge(actor->currentOrigin, Dumb.v, EDGE_BLOCKED);
+				}
+			}
+
+			// If He Can Fly Or Jump, Try That
+			//---------------------------------
+			if ((actor->NPC->scriptFlags&SCF_NAV_CAN_FLY) ||
+				(actor->NPC->scriptFlags&SCF_NAV_CAN_JUMP)
+				)
+			{
+				// Ok, Well, How About Jumping To The Last Waypoint We Had That Was Valid
+				//------------------------------------------------------------------------
+				if ((STEER::HasBeenBlockedFor(actor, 8000)) && 
+					(!actor->waypoint || Distance(NAV::GetNodePosition(actor->waypoint), actor->currentOrigin)>150.0f) && 
+					(actor->lastWaypoint))
+				{
+					if (player &&
+						(STEER::HasBeenBlockedFor(actor, 15000)) && 
+						!gi.inPVS(player->currentOrigin, NAV::GetNodePosition(actor->lastWaypoint)) &&
+						!gi.inPVS(player->currentOrigin, actor->currentOrigin) &&
+						!G_CheckInSolidTeleport(NAV::GetNodePosition(actor->lastWaypoint), actor)
+						)
+					{
+						G_SetOrigin(actor, NAV::GetNodePosition(actor->lastWaypoint));
+						G_SoundOnEnt( NPC, CHAN_BODY, "sound/weapons/force/jump.wav" );
+					}
+					else
+					{
+						NPC_TryJump(NAV::GetNodePosition(actor->lastWaypoint));
+					}
+				}
+
+				// First, Try Jumping Directly To Our Target Desired Location
+				//------------------------------------------------------------
+				else
+				{
+					// If We Had A Target Entity, Try Jumping There
+					//----------------------------------------------
+					if (NPCInfo->blockedTargetEntity)
+					{
+						NPC_TryJump(NPCInfo->blockedTargetEntity);
+					}
+
+					// Otherwise Try Jumping To The Target Position
+					//----------------------------------------------
+					else
+					{
+						NPC_TryJump(NPCInfo->blockedTargetPosition);
+					}
+				}
+			}
+		}
+	}
+
+// PHASE V - FREE UP THE STEER USER
+//===================================
+	mSteerUsers.free(mSteerUserIndex[actor->s.number]);
+	mSteerUserIndex[actor->s.number] = NULL_STEER_USER_INDEX;
+}
+
+//////////////////////////////////////////////////////////////////////
+// Active?
+//
+// Simple way for external systemm to check if this object is active
+// already.
+//
+//////////////////////////////////////////////////////////////////////
+bool			STEER::Active(gentity_t* actor)
+{
+	return (mSteerUserIndex[actor->s.number]!=NULL_STEER_USER_INDEX);
+}
+
+////////////////////////////////////////////////////////////////////////////////////
+// SafeToGoTo - returns true if it is safe for the actor to steer toward the target
+// position
+////////////////////////////////////////////////////////////////////////////////////
+bool			STEER::SafeToGoTo(gentity_t* actor, const vec3_t& targetPosition, int targetNode)
+{
+	int		actorNode				= NAV::GetNearestNode(actor, true, targetNode);
+	float	actorToTargetDistance	= Distance(actor->currentOrigin,  targetPosition);
+
+
+	// Are They Close Enough To Just Go There
+	//----------------------------------------
+	if (actorToTargetDistance<110.0f && fabsf(targetPosition[2]-actor->currentOrigin[2])<50.0f)
+	{
+		return true;
+	}
+
+	// Are They Both Within The Radius Of Their Nearest Nav Point?
+	//-------------------------------------------------------------
+	if (actorToTargetDistance<500.0f)
+	{
+		// Are Both Actor And Target In Safe Radius?
+		//-------------------------------------------
+		if (NAV::OnNeighboringPoints(actorNode, targetNode) &&  
+			NAV::InSafeRadius(actor->currentOrigin, actorNode,  targetNode) && 
+			NAV::InSafeRadius(targetPosition,		targetNode, actorNode))
+		{
+			return true;
+		}
+		
+		// If Close Enough, We May Be Able To Go Anyway, So Try A Trace
+		//--------------------------------------------------------------
+		if (actorToTargetDistance<400.0f)//250.0f)
+		{
+			if (!TIMER_Done(actor, "SafeToGoToDURATION"))
+			{
+				return true;
+			}
+
+			if (TIMER_Done(actor, "SafeToGoToCHECK"))
+			{
+				TIMER_Set( actor, "SafeToGoToCHECK", 1500);			// Check Every 1.5 Seconds
+				if (MoveTrace(actor, targetPosition, true))
+				{
+					TIMER_Set(actor, "SafeToGoToDURATION", 2000);	// Safe For 2 Seconds
+
+					if (NAVDEBUG_showCollision)
+					{
+						CVec3 Dumb(targetPosition);
+						CG_DrawEdge(actor->currentOrigin, Dumb.v, EDGE_WHITE_TWOSECOND);
+					}
+				}
+				else
+				{
+					if (NAVDEBUG_showCollision)
+					{
+						CVec3 Dumb(targetPosition);
+						CG_DrawEdge(actor->currentOrigin, Dumb.v, EDGE_RED_TWOSECOND);
+					}
+				}
+			}
+		}
+	}
+	return false;
+}
+
+////////////////////////////////////////////////////////////////////////////////////
+// Master Functions
+////////////////////////////////////////////////////////////////////////////////////
+bool			STEER::GoTo(gentity_t* actor,  gentity_t* target, float reachedRadius, bool avoidCollisions)
+{
+	// Can't Steer To A Guy In The Air
+	//---------------------------------
+	if (!target)
+	{
+		NAV::ClearPath(actor);
+		STEER::Stop(actor);
+		return true;
+	}
+
+	// If Within Reached Radius, Just Stop Right Here 
+	//------------------------------------------------
+	if (STEER::Reached(actor, target->currentOrigin, reachedRadius, (actor->client && actor->client->moveType==MT_FLYSWIM)))
+	{
+		NAV::ClearPath(actor);
+		STEER::Stop(actor);
+		return true;
+	}
+
+	// Check To See If It Is Safe To Attempt Steering Toward The Target Position
+	//---------------------------------------------------------------------------
+	if (
+		//(target->client && target->client->ps.groundEntityNum==ENTITYNUM_NONE) ||
+		!STEER::SafeToGoTo(actor, target->currentOrigin, NAV::GetNearestNode(target))
+ 		)
+	{
+		return false;
+	}
+
+	// Ok, It Is, So Clear The Path, And Go Toward Our Target
+	//--------------------------------------------------------
+	NAV::ClearPath(actor);
+	STEER::Persue(actor, target, reachedRadius*4.0f);
+	if (avoidCollisions)
+	{
+		if (STEER::AvoidCollisions(actor, actor->client->leader)!=0.0f)
+		{
+			STEER::Blocked(actor, target);					// Collision Detected
+		}
+	}
+	
+	if (NAVDEBUG_showEnemyPath)
+	{
+		CG_DrawEdge(actor->currentOrigin, target->currentOrigin, EDGE_FOLLOWPOS);
+	}
+	return true;
+}
+
+////////////////////////////////////////////////////////////////////////////////////
+// Master Function- GoTo
+////////////////////////////////////////////////////////////////////////////////////
+bool			STEER::GoTo(gentity_t* actor, const vec3_t& position, float reachedRadius, bool avoidCollisions)
+{
+	// If Within Reached Radius, Just Stop Right Here 
+	//------------------------------------------------
+	if (STEER::Reached(actor, position, reachedRadius, (actor->client && actor->client->moveType==MT_FLYSWIM)))
+	{
+		NAV::ClearPath(actor);
+		STEER::Stop(actor);
+		return true;
+	}
+
+	// Check To See If It Is Safe To Attempt Steering Toward The Target Position
+	//---------------------------------------------------------------------------
+	if (!STEER::SafeToGoTo(actor, position, NAV::GetNearestNode(position)))
+	{
+		return false;
+	}
+
+	// Ok, It Is, So Clear The Path, And Go Toward Our Target
+	//--------------------------------------------------------
+	NAV::ClearPath(actor);
+	STEER::Seek(actor, position, reachedRadius*2.0f);
+	if (avoidCollisions)
+	{
+		if (STEER::AvoidCollisions(actor, actor->client->leader)!=0.0f)
+		{
+			STEER::Blocked(actor, position);					// Collision Detected
+		}
+	}
+	
+	if (NAVDEBUG_showEnemyPath)
+	{
+		CVec3	Dumb(position);
+		CG_DrawEdge(actor->currentOrigin, Dumb.v, EDGE_FOLLOWPOS);
+	}
+	return true;
+}
+
+
+////////////////////////////////////////////////////////////////////////////////////
+// Blocked Recorder
+////////////////////////////////////////////////////////////////////////////////////
+void			STEER::Blocked(gentity_t* actor, gentity_t* target)
+{
+	assert(Active(actor));
+	SSteerUser& suser = mSteerUsers[mSteerUserIndex[actor->s.number]];
+
+	suser.mBlocked				= true;
+	suser.mBlockedTgtEntity		= target->s.number;
+	suser.mBlockedTgtPosition	= target->currentOrigin;
+}
+
+////////////////////////////////////////////////////////////////////////////////////
+// Blocked Recorder
+////////////////////////////////////////////////////////////////////////////////////
+void			STEER::Blocked(gentity_t* actor, const vec3_t& target)
+{
+	assert(Active(actor));
+	SSteerUser& suser = mSteerUsers[mSteerUserIndex[actor->s.number]];
+
+	suser.mBlocked				= true;
+	suser.mBlockedTgtEntity		= ENTITYNUM_NONE;
+	suser.mBlockedTgtPosition	= target;
+}
+
+////////////////////////////////////////////////////////////////////////////////////
+// Blocked Recorder
+////////////////////////////////////////////////////////////////////////////////////
+bool			STEER::HasBeenBlockedFor(gentity_t* actor, int duration)
+{
+	return (
+		(actor->NPC->aiFlags&NPCAI_BLOCKED) && 
+		(level.time - actor->NPC->blockedDebounceTime)>duration
+		);
+}
+
+//////////////////////////////////////////////////////////////////////
+// Stop
+//
+// Just Decelerate.
+//
+//////////////////////////////////////////////////////////////////////
+float			STEER::Stop(gentity_t* actor, float weight)
+{
+	assert(Active(actor));
+	SSteerUser& suser = mSteerUsers[mSteerUserIndex[actor->s.number]];
+
+	suser.mDesiredVelocity.Clear();
+	suser.mDistance			=  0.0f;
+	suser.mDesiredSpeed		=  0.0f;
+	suser.mSteering			+= ((suser.mDesiredVelocity - suser.mVelocity) * weight);
+
+	if (actor->NPC->aiFlags&NPCAI_FLY)
+	{
+		int nearestNode = NAV::GetNearestNode(actor);
+		if (nearestNode>0 && !mGraph.get_node(nearestNode).mFlags.get_bit(CWayNode::EWayNodeFlags::WN_FLOATING))
+		{
+			actor->NPC->aiFlags &= ~NPCAI_FLY;
+		}
+	}
+
+	assert(suser.mSteering.IsFinite());
+
+	return 0.0f;
+}
+
+//////////////////////////////////////////////////////////////////////
+//
+//////////////////////////////////////////////////////////////////////
+float			STEER::MatchSpeed(gentity_t* actor, float speed, float weight)
+{
+	assert(Active(actor));
+	SSteerUser& suser = mSteerUsers[mSteerUserIndex[actor->s.number]];
+
+	suser.mDesiredVelocity	= suser.mVelocity;
+	suser.mDesiredVelocity.Truncate(speed);
+	suser.mDistance			=  0.0f;
+	suser.mDesiredSpeed		=  0.0f;
+	suser.mSteering			+= ((suser.mDesiredVelocity - suser.mVelocity) * weight);
+
+	assert(suser.mSteering.IsFinite());
+
+	return 0.0f;
+
+}
+
+
+////////////////////////////////////////////////////////////////////////////////////
+// Seek
+//
+// The most basic of all steering operations, this function applies a change to
+// the steering vector
+//
+////////////////////////////////////////////////////////////////////////////////////
+float			STEER::Seek(gentity_t* actor, const CVec3& pos, float slowingDistance, float weight, float desiredSpeed)
+{
+	assert(Active(actor));
+	SSteerUser& suser = mSteerUsers[mSteerUserIndex[actor->s.number]];
+
+	suser.mSeekLocation		= pos;
+	suser.mDesiredVelocity	= suser.mSeekLocation - suser.mPosition;
+
+	//If The Difference In Height Is Small Enough, Just Kill It
+	//----------------------------------------------------------
+	if (fabsf(suser.mDesiredVelocity[2]) < 10.0f)
+	{
+		suser.mDesiredVelocity[2] = 0.0f;
+	}
+
+
+	suser.mDistance			=  suser.mDesiredVelocity.SafeNorm();
+	if (suser.mDistance>0.0f)
+	{
+		suser.mDesiredSpeed		=  (desiredSpeed!=0.0f)?(desiredSpeed):(suser.mMaxSpeed);
+		if (slowingDistance!=0.0f && suser.mDistance < slowingDistance)
+		{
+			suser.mDesiredSpeed	*= (suser.mDistance/slowingDistance);
+		}
+		suser.mDesiredVelocity	*= suser.mDesiredSpeed;
+	}
+	else
+	{
+		suser.mDesiredSpeed = 0.0f;
+		suser.mDesiredVelocity.Clear();
+	}
+
+	suser.mSteering			+= ((suser.mDesiredVelocity - suser.mVelocity) * weight);
+
+	assert(suser.mSteering.IsFinite());
+
+	return suser.mDistance;
+}
+
+////////////////////////////////////////////////////////////////////////////////////
+// Flee
+//
+// Similar to seek, except there is no concept of a slowing distance.  Adds the 
+// position vectors instead of subtracting them to obtain a desired velocity away
+// from the target.
+//
+////////////////////////////////////////////////////////////////////////////////////
+float			STEER::Flee(gentity_t* actor,		const CVec3& pos, float weight)
+{
+	assert(Active(actor));
+	SSteerUser& suser = mSteerUsers[mSteerUserIndex[actor->s.number]];
+
+	suser.mDesiredVelocity	=  suser.mPosition - pos;
+	suser.mDistance			=  suser.mDesiredVelocity.SafeNorm();
+	suser.mDesiredSpeed		=  suser.mMaxSpeed;
+	suser.mDesiredVelocity	*= suser.mDesiredSpeed;
+	suser.mSteering			+= ((suser.mDesiredVelocity - suser.mVelocity) * weight);
+	suser.mSeekLocation		= pos + suser.mDesiredVelocity;
+
+
+	assert(suser.mSteering.IsFinite());
+
+	return suser.mDistance;
+}
+
+
+////////////////////////////////////////////////////////////////////////////////////
+// Persue
+//
+// Predict the target's position and seek that.
+//
+////////////////////////////////////////////////////////////////////////////////////
+float			STEER::Persue(gentity_t* actor,	gentity_t* target, float slowingDistance)
+{
+	assert(Active(actor) && target);
+	SSteerUser& suser = mSteerUsers[mSteerUserIndex[actor->s.number]];
+
+	CVec3	ProjectedTargetPosition(target->currentOrigin);
+
+	if (target->client)
+	{
+		float	DistToTarget = ProjectedTargetPosition.Dist(suser.mPosition);
+
+		CVec3	TargetVelocity(target->client->ps.velocity);
+		float	TargetSpeed = TargetVelocity.SafeNorm();
+		if (TargetSpeed>0.0f)
+		{
+			TargetVelocity *= (DistToTarget + 5.0f);
+			ProjectedTargetPosition += TargetVelocity;
+		}
+	}
+
+	return Seek(actor, ProjectedTargetPosition, slowingDistance);
+}
+
+
+////////////////////////////////////////////////////////////////////////////////////
+// Persue
+//
+// Predict the target's position and seek that.
+//
+////////////////////////////////////////////////////////////////////////////////////
+float			STEER::Persue(gentity_t* actor,	gentity_t* target, float slowingDistance, float offsetForward, float offsetRight, float offsetUp, bool relativeToTargetFacing)
+{
+	assert(Active(actor) && target);
+	SSteerUser& suser = mSteerUsers[mSteerUserIndex[actor->s.number]];
+
+	CVec3	ProjectedTargetPosition(target->currentOrigin);
+
+	// If Target Is A Client, Take His Velocity Into Account And Project His Position
+	//--------------------------------------------------------------------------------
+	if (target->client)
+	{
+		float	DistToTarget = ProjectedTargetPosition.Dist(suser.mPosition);
+
+		CVec3	TargetVelocity(target->client->ps.velocity);
+		float	TargetSpeed = TargetVelocity.SafeNorm();
+	  	if (TargetSpeed>0.0f)
+		{
+			TargetVelocity[2] *= 0.1f;
+			TargetVelocity *= (DistToTarget + 5.0f);
+			ProjectedTargetPosition += TargetVelocity;
+		}
+	}
+
+	// Get The Direction Toward The Target
+	//-------------------------------------
+	CVec3	DirectionToTarget(ProjectedTargetPosition);
+			DirectionToTarget -= suser.mPosition;
+			DirectionToTarget.SafeNorm();
+
+
+	CVec3	ProjectForward(DirectionToTarget);
+	CVec3	ProjectRight;
+	CVec3	ProjectUp;
+
+	if (relativeToTargetFacing)
+	{
+		AngleVectors(target->currentAngles, ProjectForward.v, ProjectRight.v, ProjectUp.v);
+		if (ProjectRight.Dot(DirectionToTarget)>0.0f)
+		{
+			ProjectRight *= -1.0f;		// If Going In Same Direction As Target Right, Project Toward Target Left
+		}
+	}
+	else
+	{
+		MakeNormalVectors(ProjectForward.v, ProjectRight.v, ProjectUp.v);
+	}
+
+	ProjectedTargetPosition.ScaleAdd(ProjectForward, offsetForward);
+	ProjectedTargetPosition.ScaleAdd(ProjectRight,	 offsetRight);
+	ProjectedTargetPosition.ScaleAdd(ProjectUp,		 offsetUp);
+
+	return Seek(actor, ProjectedTargetPosition, slowingDistance);
+}
+
+
+////////////////////////////////////////////////////////////////////////////////////
+// Evade
+//
+// Predict the target's position and flee that.
+//
+////////////////////////////////////////////////////////////////////////////////////
+float			STEER::Evade(gentity_t* actor,		gentity_t* target)
+{
+	assert(Active(actor) && target);
+	SSteerUser& suser = mSteerUsers[mSteerUserIndex[actor->s.number]];
+
+	CVec3	ProjectedTargetPosition(target->currentOrigin);
+
+	if (target->client)
+	{
+		float	DistToTarget = ProjectedTargetPosition.Dist(suser.mPosition);
+
+
+		CVec3	TargetVelocity(target->client->ps.velocity);
+		float	TargetSpeed = TargetVelocity.SafeNorm();
+		if (TargetSpeed>0.0f)
+		{
+			TargetVelocity *= (DistToTarget + 5.0f);
+			ProjectedTargetPosition += TargetVelocity;
+		}
+	}
+
+	return Flee(actor, ProjectedTargetPosition);
+}
+
+
+////////////////////////////////////////////////////////////////////////////////////
+// Separation
+////////////////////////////////////////////////////////////////////////////////////
+float			STEER::Separation(gentity_t* actor, float Scale)
+{
+	assert(Active(actor) && actor);
+	SSteerUser& suser = mSteerUsers[mSteerUserIndex[actor->s.number]];
+
+	if (!suser.mNeighbors.empty())
+	{
+		for (int i=0; i<suser.mNeighbors.size(); i++)
+		{
+			if (suser.mNeighbors[i]->s.number>actor->s.number)
+			{
+				CVec3	NbrPos(suser.mNeighbors[i]->currentOrigin);
+				CVec3	NbrToAct(suser.mPosition - NbrPos);
+				float	NbrToActDist = NbrToAct.Len2();
+				if (NbrToActDist>1.0f)
+				{
+					NbrToActDist = (1.0f/NbrToActDist);
+					NbrToAct *= NbrToActDist * (suser.mMaxSpeed * 10.0f) * Scale;
+					suser.mSteering	+= NbrToAct;
+
+					if (NAVDEBUG_showCollision)
+					{
+						CVec3	Prj(suser.mPosition + NbrToAct);
+						CG_DrawEdge(suser.mPosition.v,	Prj.v, EDGE_IMPACT_POSSIBLE);	// Separation
+					}
+				}
+			}
+		}
+	}
+
+	assert(suser.mSteering.IsFinite());
+
+	return 0.0f;
+}
+
+////////////////////////////////////////////////////////////////////////////////////
+// Alignment
+////////////////////////////////////////////////////////////////////////////////////
+float			STEER::Alignment(gentity_t* actor, float Scale)
+{
+	return 0.0f;
+}
+
+////////////////////////////////////////////////////////////////////////////////////
+// Cohesion
+////////////////////////////////////////////////////////////////////////////////////
+float			STEER::Cohesion(gentity_t* actor, float Scale)
+{
+	assert(Active(actor) && actor);
+	SSteerUser& suser = mSteerUsers[mSteerUserIndex[actor->s.number]];
+
+	if (!suser.mNeighbors.empty())
+	{
+		CVec3	AvePosition;
+		for (int i=0; i<suser.mNeighbors.size(); i++)
+		{
+			AvePosition += CVec3(suser.mNeighbors[i]->currentOrigin);
+		}
+		AvePosition *= 1.0f/suser.mNeighbors.size();
+		return Seek(actor, AvePosition);
+	}
+	return 0.0f;
+}
+
+////////////////////////////////////////////////////////////////////////////////////
+// Find Nearest Leader
+////////////////////////////////////////////////////////////////////////////////////
+gentity_t*		STEER::SelectLeader(gentity_t* actor)
+{
+	assert(Active(actor) && actor);
+	SSteerUser& suser = mSteerUsers[mSteerUserIndex[actor->s.number]];
+
+	for (int i=0; i<suser.mNeighbors.size(); i++)
+	{
+		if (suser.mNeighbors[i]->s.number>actor->s.number && !Q_stricmp(suser.mNeighbors[i]->NPC_type, actor->NPC_type ))
+		{
+			return suser.mNeighbors[i];
+		}
+
+	}
+	return 0;
+}
+
+////////////////////////////////////////////////////////////////////////////////////
+// Path - Seek to the next position on the path (or jump)
+////////////////////////////////////////////////////////////////////////////////////
+float			STEER::Path(gentity_t* actor)
+{
+	if (NAV::HasPath(actor))
+	{
+		CVec3	NextPosition;
+		float	NextSlowingRadius;
+		bool	Fly = false;
+		bool	Jump = false;
+
+		if (!NAV::NextPosition(actor, NextPosition, NextSlowingRadius, Fly, Jump))
+		{
+			assert("STEER: Unable to obtain the next path position"==0);
+			return 0.0f;
+		}
+
+		// Start Flying If Next Point Is In The Air
+		//------------------------------------------
+		if (Fly)
+		{
+			actor->NPC->aiFlags |= NPCAI_FLY;
+		}
+
+		// Otherwise, If Next Point Is On The Ground, No Need To Fly Any Longer
+		//----------------------------------------------------------------------
+		else if (actor->NPC->aiFlags&NPCAI_FLY)
+		{
+			actor->NPC->aiFlags &= ~NPCAI_FLY;
+		}
+
+		// Start Jumping If Next Point Is A Jump
+		//---------------------------------------
+		if (Jump)
+		{
+			if (NPC_TryJump(NextPosition.v))
+			{
+				actor->NPC->aiFlags |= NPCAI_JUMP;
+				return 1.0f;
+			}
+		}
+		actor->NPC->aiFlags &=~NPCAI_JUMP;
+
+
+		// Preview His Path
+		//------------------
+		if (NAVDEBUG_showEnemyPath)
+		{
+			CVec3	Prev(actor->currentOrigin);
+			TPath&	path = mPathUsers[mPathUserIndex[actor->s.number]].mPath;
+			for (int i=path.size()-1; i>=0; i--)
+			{
+				CG_DrawEdge(Prev.v, path[i].mPoint.v, EDGE_PATH);
+				Prev = path[i].mPoint;
+			}
+		}
+
+		// If Jump Was On, But We Reached This Point, It Must Have Failed
+		//----------------------------------------------------------------
+		if (Jump)
+		{
+			Stop(actor);
+			return 0.0f;	// We've Failed!
+		}
+
+		// Otherwise, Go!
+		//----------------
+		return Seek(actor, NextPosition, NextSlowingRadius);
+	}
+	return 0.0f;
+}
+
+////////////////////////////////////////////////////////////////////////////////////
+// Wander
+////////////////////////////////////////////////////////////////////////////////////
+float			STEER::Wander(gentity_t* actor)
+{
+	assert(Active(actor) && actor);
+	SSteerUser& suser = mSteerUsers[mSteerUserIndex[actor->s.number]];
+
+
+	CVec3 Direction(CVec3::mX);
+
+	if (suser.mSpeed>0.1f)
+	{
+		Direction = suser.mVelocity;
+		Direction.VecToAng();
+		Direction[2] += Q_irand(-5, 5);
+		Direction.AngToVec();
+	}
+
+	Direction *= 70.0f;
+	Seek(actor, suser.mPosition+Direction);
+
+	return 0.0f;
+}
+
+////////////////////////////////////////////////////////////////////////////////////
+// Follow A Leader Entity
+////////////////////////////////////////////////////////////////////////////////////
+float			STEER::FollowLeader(gentity_t* actor, gentity_t* leader, float dist)
+{
+	assert(Active(actor) && actor && leader && leader->client);
+	SSteerUser& suser = mSteerUsers[mSteerUserIndex[actor->s.number]];
+
+
+	float	LeaderSpeed		= leader->resultspeed;
+	int		TimeRemaining	= (leader->followPosRecalcTime - level.time);
+
+	if (TimeRemaining<0 || (LeaderSpeed>0.0f && TimeRemaining>1000))
+	{
+		CVec3	LeaderPosition(leader->currentOrigin);
+		CVec3	LeaderDirection(leader->currentAngles);
+		LeaderDirection.pitch() = 0;
+		LeaderDirection.AngToVec();
+
+		if (!actor->enemy && !leader->enemy)
+		{
+			LeaderDirection = (LeaderPosition - suser.mPosition);
+			LeaderDirection.Norm();
+		}
+
+		CVec3	FollowPosition(LeaderDirection);
+		FollowPosition *= (-1.0f * (fabsf(dist)+suser.mRadius));
+		FollowPosition += LeaderPosition;
+
+		MoveTrace(leader, FollowPosition, true);
+		if (mMoveTrace.fraction>0.1)
+		{
+			FollowPosition = mMoveTrace.endpos;
+			FollowPosition += (LeaderDirection * suser.mRadius);
+			
+			VectorCopy(FollowPosition.v, leader->followPos);
+			leader->followPosWaypoint = NAV::GetNearestNode(leader->followPos, leader->waypoint, 0, leader->s.number);
+		}
+
+		float	MaxSpeed	= (g_speed->value);
+		if (LeaderSpeed>MaxSpeed)
+		{
+			MaxSpeed = LeaderSpeed;
+		}
+		float	SpeedScale	= (1.0f - (LeaderSpeed / MaxSpeed));
+
+		leader->followPosRecalcTime = 
+			(level.time) + 
+			(Q_irand(50, 500)) + 
+			(SpeedScale * Q_irand(3000, 8000)) +
+			((!actor->enemy && !leader->enemy)?(Q_irand(8000, 15000)):(0));
+	}
+
+	if (NAVDEBUG_showEnemyPath)
+	{
+		CG_DrawEdge(leader->currentOrigin, leader->followPos, EDGE_FOLLOWPOS);
+	}
+
+	return 0.0;
+}
+
+
+//////////////////////////////////////////////////////////////////////
+// Test For A Collision
+//
+// This is a helper function used by collision avoidance.
+//
+// Returns true when a collision is detected (not safe)
+//
+//////////////////////////////////////////////////////////////////////
+bool		TestCollision(gentity_t* actor, SSteerUser& suser, const CVec3& ProjectVelocity, float ProjectSpeed, ESide Side, float weight=1.0f)
+{
+	// Test To See If The Projected Position Is Safe
+	//-----------------------------------------------
+	bool Safe = (Side==Side_None)?(MoveTrace(actor, suser.mProjectFwd)):(MoveTrace(actor, suser.mProjectSide));
+	if (mMoveTrace.entityNum!=ENTITYNUM_NONE && mMoveTrace.entityNum!=ENTITYNUM_WORLD)
+	{
+		// The Ignore Entity Is Safe
+		//---------------------------
+		if (mMoveTrace.entityNum==suser.mIgnoreEntity)
+		{
+			Safe = true;
+		}
+
+		// Doors Are Always Safe
+		//-----------------------
+		if (g_entities[mMoveTrace.entityNum].classname && 
+			Q_stricmp(g_entities[mMoveTrace.entityNum].classname, "func_door")==0)
+		{
+			Safe = true;
+		}
+
+		// If It's Breakable And We Can Go Through It, Then That's Safe Too
+		//------------------------------------------------------------------
+		if ((actor->NPC->aiFlags&NPCAI_NAV_THROUGH_BREAKABLES) &&
+			G_EntIsBreakable(mMoveTrace.entityNum, actor))
+		{
+			Safe = true;
+		}
+
+		// TODO: Put Other Ignore Cases Below
+		//------------------------------------
+	}
+
+	// Need These Vectors To Draw The Lines Below
+	//--------------------------------------------
+	CVec3	ContactNormal(mMoveTrace.plane.normal);
+	CVec3	ContactPoint( mMoveTrace.endpos);
+	int		ContactNum =  mMoveTrace.entityNum;
+
+
+	if (!Safe && Side==Side_None)
+	{
+		// Did We Hit A Client?
+		//----------------------
+		if (ContactNum!=ENTITYNUM_WORLD && ContactNum!=ENTITYNUM_NONE && g_entities[ContactNum].client!=0)
+		{
+			gentity_t*		Contact			= &g_entities[ContactNum];
+			//bool			ContactIsPlayer = (Contact->client->ps.clientNum==0);
+			CVec3			ContactVelocity   (Contact->client->ps.velocity);
+			CVec3			ContactPosition   (Contact->currentOrigin);
+			float			ContactSpeed	= (ContactVelocity.Len());
+
+			// If He Is Moving, We Might Be Able To Just Slow Down Some And Stay Behind Him
+			//------------------------------------------------------------------------------
+			if (ContactSpeed>0.01f)
+			{
+				if (ContactSpeed<ProjectSpeed)
+				{
+					CVec3	MyDirection(ProjectVelocity);
+					CVec3	ContactDirection(ContactVelocity);
+
+					ContactDirection.Norm();
+					MyDirection.Norm();
+
+					float	DirectionSimilarity = fabsf(MyDirection.Dot(ContactDirection));
+					if (DirectionSimilarity>0.5)
+					{
+						// Match Speed
+						//-------------
+						suser.mDesiredVelocity	= suser.mVelocity;
+						suser.mDesiredVelocity.Truncate(ContactSpeed);
+						suser.mSteering			+= ((suser.mDesiredVelocity - ProjectVelocity) * DirectionSimilarity);
+						suser.mIgnoreEntity		= ContactNum;	// So The Side Trace Does Not Care About This Guy
+						assert(suser.mSteering.IsFinite());
+						Safe = true;	// We'll Say It's Safe For Now
+					}
+				}
+			}
+
+			// Ok, He's Just Standing There...  
+			//---------------------------------
+			else
+			{
+				CVec3	Next(suser.mSeekLocation);
+				if (NAV::HasPath(actor))
+				{
+					Next = CVec3(NAV::NextPosition(actor));
+				}
+
+				CVec3 AbsMin(Contact->absmin);
+				CVec3 AbsMax(Contact->absmax);
+
+				// Is The Contact Standing Over Our Next Position?
+				//-------------------------------------------------
+				if (Next>AbsMin && Next<AbsMax)
+				{
+					// Ok, Just Give Up And Stop For Now
+					//-----------------------------------
+					suser.mSteering			-= ProjectVelocity;
+					suser.mIgnoreEntity		= ContactNum;
+					assert(suser.mSteering.IsFinite());
+
+					Safe = true;	// We say it is "Safe" because We Don't Want To Try And Steer Around
+				}
+			}
+		}
+
+		// Ignore Shallow Slopes
+		//-----------------------
+		if (!Safe && ContactNormal[2]>0.0f && ContactNormal[2]<MIN_WALK_NORMAL)
+		{
+			Safe = true;
+		}
+
+		// If Still Not Safe
+		//-------------------
+		if (!Safe)
+		{
+			// Normalize Projected Velocity And Dot It With The Contact Normal
+			//-----------------------------------------------------------------
+			CVec3	ProjectDirection(ProjectVelocity);
+			ProjectDirection.Norm();
+
+			// Cross The Contact Normal With Z In Order To Get A Parallel Vector
+			//-------------------------------------------------------------------
+			ContactNormal.Cross(CVec3::mZ);
+
+			// Only Force A Particular Steering Side For A Max Of 2 Seconds, Then Retest Dot Product
+			//---------------------------------------------------------------------------------------
+			if (actor->NPC->lastAvoidSteerSide!=Side_None && actor->NPC->lastAvoidSteerSideDebouncer<level.time)
+			{
+				actor->NPC->lastAvoidSteerSide				= Side_None;
+				actor->NPC->lastAvoidSteerSideDebouncer		= level.time + Q_irand(500, STEER::SIDE_LOCKED_TIMER);
+			}
+
+			// Make Sure The Normal Is Going The Same Way As The Velocity
+			//-----------------------------------------------------------
+			if (((ESide)(actor->NPC->lastAvoidSteerSide)==Side_Right) ||
+				((ESide)(actor->NPC->lastAvoidSteerSide)==Side_None && ContactNormal.Dot(ProjectDirection)<0.0f))
+			{
+				ContactNormal *= -1.0f;
+				actor->NPC->lastAvoidSteerSide  = Side_Right;
+			}
+			else
+			{
+				actor->NPC->lastAvoidSteerSide  = Side_Left;
+			}
+			ContactNormal[2] = 0.0f;
+
+			// Scale Up The Normal A Bit And Translate The Contact Point Out
+			//---------------------------------------------------------------
+			ContactNormal *= (ProjectSpeed * weight * 0.5);
+			ContactPoint += ContactNormal;
+
+			// Move Toward The Contact Point
+			//-------------------------------
+			STEER::Seek(actor, ContactPoint, weight);
+		}
+
+		// If It Was Safe, Reset Our Avoid Side Data
+		//-------------------------------------------
+		else if (Side==Side_None)
+		{
+			actor->NPC->lastAvoidSteerSide = Side_None;
+		}
+	}
+
+
+
+
+
+	// DEBUG GRAPHICS
+	//=================================================================
+	if (NAVDEBUG_showCollision)
+	{
+		CVec3	Prj((Side==Side_None)?(suser.mProjectFwd):(suser.mProjectSide));
+	
+		if (Safe)
+		{
+			CG_DrawEdge(suser.mPosition.v,	Prj.v,				EDGE_IMPACT_SAFE);		// WHITE LINE
+		}
+		else
+		{
+			CG_DrawEdge(suser.mPosition.v,	mMoveTrace.endpos,	EDGE_IMPACT_POSSIBLE);	// RED LINE
+			CG_DrawEdge(mMoveTrace.endpos,	ContactPoint.v,		EDGE_IMPACT_POSSIBLE);	// RED LINE
+		}
+	}
+	//=================================================================
+
+	return !Safe;
+}
+
+////////////////////////////////////////////////////////////////////////////////////
+// Collision Avoidance
+//
+// Usually the last steering operation to call before finialization, this operation
+// attempts to avoid collisions with nearby entities and architecture by thrusing
+// away from them.
+////////////////////////////////////////////////////////////////////////////////////
+float			STEER::AvoidCollisions(gentity_t* actor, gentity_t* leader)
+{
+	assert(Active(actor) && actor && actor->client);
+	SSteerUser& suser = mSteerUsers[mSteerUserIndex[actor->s.number]];
+
+	suser.mIgnoreEntity = -5;
+
+
+	// Simulate The Results Of Any Current Steering To The Velocity
+	//--------------------------------------------------------------
+	CVec3	ProjectedSteering(suser.mSteering);
+	CVec3	ProjectedVelocity(suser.mVelocity);
+	float	ProjectedSpeed = suser.mSpeed;
+	float	Newtons;
+
+	Newtons	 = ProjectedSteering.Truncate(suser.mMaxForce);
+	if (Newtons>1E-10)
+	{
+		ProjectedSteering	/= suser.mMass;
+		ProjectedVelocity	+= ProjectedSteering;
+		ProjectedSpeed		=  ProjectedVelocity.Truncate(suser.mMaxSpeed);
+	}
+
+
+	// Select An Ignore Entity
+	//-------------------------
+	if (actor->NPC->behaviorState!=BS_CINEMATIC)
+	{
+		if (actor->NPC->greetEnt && actor->NPC->greetEnt->owner==NPC)
+		{
+			suser.mIgnoreEntity = actor->NPC->greetEnt->s.clientNum;
+		}
+		else if (actor->enemy)
+		{
+			suser.mIgnoreEntity = actor->enemy->s.clientNum;
+		}
+		else if (leader)
+		{
+			suser.mIgnoreEntity = leader->s.clientNum;
+		}
+	}
+
+
+	// If Moving
+	//-----------
+	if (ProjectedSpeed>0.01f)
+	{
+		CVec3	ProjectVelocitySide(ProjectedVelocity);
+		ProjectVelocitySide.Reposition(CVec3::mZero, (actor->NPC->avoidSide==Side_Left)?(40.0f):(-40.0f));
+
+		// Project Based On Our ProjectedVelocity
+		//-----------------------------------------
+		suser.mProjectFwd	= suser.mPosition + (ProjectedVelocity * 1.0f);
+		suser.mProjectSide	= suser.mPosition + (ProjectVelocitySide * 0.3f);
+
+		// Test For Collisions In The Front And On The Sides
+		//---------------------------------------------------
+		bool	HitFront	= TestCollision(actor, suser, ProjectedVelocity, ProjectedSpeed, Side_None, 1.0f);
+		bool	HitSide		= TestCollision(actor, suser, ProjectedVelocity, ProjectedSpeed, (ESide)actor->NPC->avoidSide, 0.5f);
+		if (!HitSide)
+		{
+			// If The Side Is Clear, Try The Other Side
+			//------------------------------------------
+			actor->NPC->avoidSide = (actor->NPC->avoidSide==Side_Left)?(Side_Right):(Side_Left);
+		}
+
+		// Hit Something!
+		//----------------
+		if (HitFront || HitSide)
+		{
+			return ProjectedSpeed;
+		}
+	}
+	return 0.0f;
+}
+
+////////////////////////////////////////////////////////////////////////////////////
+// Reached
+////////////////////////////////////////////////////////////////////////////////////
+bool	STEER::Reached(gentity_t* actor, gentity_t* target, float targetRadius, bool flying)
+{
+	if (!actor || !target)
+	{
+		return false;
+	}
+
+	CVec3	ActorPos(actor->currentOrigin);
+	CVec3	ActorMins(actor->absmin);
+	CVec3	ActorMaxs(actor->absmax);
+
+	CVec3	TargetPos(target->currentOrigin);
+
+	if (TargetPos.Dist2(ActorPos)<(targetRadius*targetRadius) || (TargetPos>ActorMins && TargetPos<ActorMaxs))
+	{
+		return true;
+	}
+	return false;
+}
+
+////////////////////////////////////////////////////////////////////////////////////
+// Reached
+////////////////////////////////////////////////////////////////////////////////////
+bool	STEER::Reached(gentity_t* actor, NAV::TNodeHandle target, float targetRadius, bool flying)
+{
+	if (!actor || !target)
+	{
+		return false;
+	}
+
+	CVec3	ActorPos(actor->currentOrigin);
+	CVec3	ActorMins(actor->absmin);
+	CVec3	ActorMaxs(actor->absmax);
+
+	CVec3	TargetPos(NAV::GetNodePosition(target));
+
+	if (TargetPos.Dist2(ActorPos)<(targetRadius*targetRadius) || (TargetPos>ActorMins && TargetPos<ActorMaxs))
+	{
+		return true;
+	}
+	return false;
+}
+
+////////////////////////////////////////////////////////////////////////////////////
+// Reached
+////////////////////////////////////////////////////////////////////////////////////
+bool	STEER::Reached(gentity_t* actor, const vec3_t& target, float targetRadius, bool flying)
+{
+	if (!actor || !target)
+	{
+		return false;
+	}
+
+	CVec3	ActorPos(actor->currentOrigin);
+	CVec3	ActorMins(actor->absmin);
+	CVec3	ActorMaxs(actor->absmax);
+
+	CVec3	TargetPos(target);
+
+	if (TargetPos.Dist2(ActorPos)<(targetRadius*targetRadius) || (TargetPos>ActorMins && TargetPos<ActorMaxs))
+	{
+		return true;
+	}
+
+//	if (target->client && target->client->ps.groundEntityNum == ENTITYNUM_NONE)
+//	{
+//		TargetPos -= ActorPos;
+//		if (fabsf(TargetPos[2]<(targetRadius*8)))
+//		{
+//			TargetPos[2] = 0.0f;
+//			if (TargetPos.Len2()<((targetRadius*2.0f)*(targetRadius*2.0f)))
+//			{
+//				return true;
+//			}
+//		}
+//	}
+
+	return false;
+}
+
+
+
+// Clean up all of the krufty structures that only grow, never shrink, eventually
+// causing asserts and subsequent memory trashing.
+void	ClearAllNavStructures(void)
+{
+	TEntEdgeMap::iterator i = mEntEdgeMap.begin();
+	for ( ; i != mEntEdgeMap.end(); i++)
+	{
+		i->clear();
+	}
+	mEntEdgeMap.clear();
+}
+
+
+
+
+
+
+
diff --git a/code/game/g_navigator.h b/code/game/g_navigator.h
new file mode 100644
index 0000000..532dcb1
--- /dev/null
+++ b/code/game/g_navigator.h
@@ -0,0 +1,269 @@
+////////////////////////////////////////////////////////////////////////////////////////
+// RAVEN SOFTWARE - STAR WARS: JK II
+//  (c) 2002 Activision
+//
+//
+//
+// NAVIGATOR
+// ---------
+// This file provides an interface to two actor related systems: 
+//  - Path Finding 
+//  - Steering
+//
+//
+//
+////////////////////////////////////////////////////////////////////////////////////////
+#ifndef __G_NAVIGATOR__
+#define __G_NAVIGATOR__
+
+
+#define	USENEWNAVSYSTEM	1
+
+
+#if !defined(RAVL_VEC_INC)
+	#include "..\Ravl\CVec.h"
+#endif
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// The NAV Namespace
+//
+// This namespace provides the public interface to the NPC Navigation and Pathfinding
+// system.  This system is a bidirectional graph of nodes and weighted edges.  Finding
+// a path from one node to another is accomplished with A*, and cached internally for
+// each actor who requests a path.
+////////////////////////////////////////////////////////////////////////////////////////
+namespace NAV
+{
+	typedef		int		TNodeHandle;
+	typedef		int		TEdgeHandle;
+
+
+	enum	EPointType
+	{
+		PT_NONE = 0,
+
+		PT_WAYNODE,
+		PT_COMBATNODE,
+		PT_GOALNODE,
+
+		PT_MAX
+	};
+
+
+
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Save, Load, Construct
+	////////////////////////////////////////////////////////////////////////////////////
+	bool			LoadFromFile(const char *filename, int checksum);
+	bool			TestEdge( TNodeHandle NodeA, TNodeHandle NodeB, qboolean IsDebugEdge );
+	bool			LoadFromEntitiesAndSaveToFile(const char *filename, int checksum);
+	void			SpawnedPoint(gentity_t* ent, EPointType type=PT_WAYNODE);
+
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Finding Nav Points
+	////////////////////////////////////////////////////////////////////////////////////
+	TNodeHandle		GetNearestNode(gentity_t* ent, bool forceRecalcNow=false, NAV::TNodeHandle goal=0);
+	TNodeHandle		GetNearestNode(const vec3_t& position, TNodeHandle previous=0, NAV::TNodeHandle goal=0, int ignoreEnt=ENTITYNUM_NONE, bool allowZOffset=false);
+
+	TNodeHandle		ChooseRandomNeighbor(TNodeHandle NodeHandle);
+	TNodeHandle		ChooseRandomNeighbor(TNodeHandle NodeHandle, const vec3_t& position, float maxDistance);
+	TNodeHandle		ChooseClosestNeighbor(TNodeHandle NodeHandle, const vec3_t& position);
+	TNodeHandle		ChooseFarthestNeighbor(TNodeHandle NodeHandle, const vec3_t& position);
+	TNodeHandle		ChooseFarthestNeighbor(gentity_t* actor, const vec3_t& target, float maxSafeDot);
+
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Get The Location Of A Given Node Handle
+	////////////////////////////////////////////////////////////////////////////////////
+	const vec3_t&	GetNodePosition(TNodeHandle NodeHandle);
+	void			GetNodePosition(TNodeHandle NodeHandle, vec3_t& position);
+
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Testing Nearness
+	////////////////////////////////////////////////////////////////////////////////////
+	float			EstimateCostToGoal(const vec3_t& position, TNodeHandle Goal);
+	float			EstimateCostToGoal(TNodeHandle Start, TNodeHandle Goal);
+
+	bool			OnSamePoint(gentity_t* actor, gentity_t* target);
+	bool			OnNeighboringPoints(TNodeHandle A, TNodeHandle B);
+	bool			OnNeighboringPoints(gentity_t* actor, gentity_t* target);
+	bool			OnNeighboringPoints(gentity_t* actor, const vec3_t& position);
+	bool			InSameRegion(gentity_t* actor, gentity_t* target);
+	bool			InSameRegion(gentity_t* actor, const vec3_t& position);
+	bool			InSameRegion(TNodeHandle A, TNodeHandle B);
+
+	bool			InSafeRadius(CVec3 at, TNodeHandle atNode, TNodeHandle targetNode=0);
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Finding A Path
+	////////////////////////////////////////////////////////////////////////////////////
+	bool			GoTo(gentity_t* actor, TNodeHandle target, float MaxDangerLevel=1.0f);
+	bool			GoTo(gentity_t* actor, gentity_t* target, float MaxDangerLevel=1.0f);
+	bool			GoTo(gentity_t* actor, const vec3_t& position, float MaxDangerLevel=1.0f);
+
+	bool			FindPath(gentity_t* actor, TNodeHandle target, float MaxDangerLevel=1.0f);
+	bool			FindPath(gentity_t* actor, gentity_t* target, float MaxDangerLevel=1.0f);
+	bool			FindPath(gentity_t* actor, const vec3_t& position, float MaxDangerLevel=1.0f);
+
+	bool			SafePathExists(const CVec3& start, const CVec3& stop, const CVec3& danger, float dangerDistSq);
+
+	bool			HasPath(gentity_t* actor, TNodeHandle target=PT_NONE);
+	void			ClearPath(gentity_t* actor);
+	bool			UpdatePath(gentity_t* actor, TNodeHandle target=PT_NONE, float MaxDangerLevel=1.0f);
+	float			PathDangerLevel(gentity_t* actor);
+	int				PathNodesRemaining(gentity_t* actor);
+
+	const vec3_t&	NextPosition(gentity_t* actor);
+	bool			NextPosition(gentity_t* actor, CVec3& Position);
+	bool			NextPosition(gentity_t* actor, CVec3& Position, float& SlowingRadius, bool& Fly, bool& Jump);
+
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Update One Or More Edges As A Result Of An Entity Getting Removed
+	////////////////////////////////////////////////////////////////////////////////////
+	void			WayEdgesNowClear(gentity_t* ent);
+
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// How Big Is The Given Ent
+	////////////////////////////////////////////////////////////////////////////////////
+	unsigned int	ClassifyEntSize(gentity_t* ent);
+	void			RegisterDangerSense(gentity_t* actor, int alertEventIndex);
+	void			DecayDangerSenses();
+
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Debugging Information
+	////////////////////////////////////////////////////////////////////////////////////
+	void			ShowDebugInfo(const vec3_t& PlayerPosition, TNodeHandle PlayerWaypoint);
+	void			ShowStats();
+
+	void			TeleportTo(gentity_t* actor, const char* pointName);
+	void			TeleportTo(gentity_t* actor, int pointNum);
+}
+
+
+
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// The STEER Namespace
+//
+// These functions allow access to the steering system.
+//
+// The Reset() and Finalize() functions MUST be called before and after any other steering
+// operations.  Beyond that, all other steering operations can be called in any order
+// and any number of times.  Once Finalize() is called, the results of all these
+// operations will be summed up and applied as accelleration to the actor's velocity.
+////////////////////////////////////////////////////////////////////////////////////////
+namespace STEER
+{
+	////////////////////////////////////////////////////////////////////////////////////
+	// Reset & Finalize
+	//
+	// Call these two operations before and after all other STEER operations.  They
+	// clear out and setup the thrust vector for use by the entity.
+	////////////////////////////////////////////////////////////////////////////////////
+	void			Activate(gentity_t* actor);
+	void			DeActivate(gentity_t* actor, usercmd_t* ucmd);
+	bool			Active(gentity_t* actor);
+
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Master Functions
+	////////////////////////////////////////////////////////////////////////////////////
+	bool			GoTo(gentity_t* actor, gentity_t* target, float reachedRadius, bool avoidCollisions=true);
+	bool			GoTo(gentity_t* actor, const vec3_t& position, float reachedRadius, bool avoidCollisions=true);
+
+	bool			SafeToGoTo(gentity_t* actor, const vec3_t& targetPosition, int targetNode);
+
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Stop
+	//
+	// Slow down and come to a stop.
+	//
+	////////////////////////////////////////////////////////////////////////////////////
+	float			Stop(gentity_t* actor, float weight=1.0f);
+	float			MatchSpeed(gentity_t* actor, float speed, float weight=1.0f);
+
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Seek & Flee
+	//
+	// These two operations form the root of all steering.  They do simple
+	// vector operations and add to the thrust vector.
+	////////////////////////////////////////////////////////////////////////////////////
+	float			Seek(gentity_t* actor,		const CVec3& pos, float slowingDistance=0.0f,  float weight=1.0f, float desiredSpeed=0.0f);
+	float			Flee(gentity_t* actor,		const CVec3& pos, float weight=1.0f);
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Persue & Evade
+	//
+	// Slightly more complicated than Seek & Flee, these operations predict the position
+	// of the target entitiy.
+	////////////////////////////////////////////////////////////////////////////////////
+	float			Persue(gentity_t* actor,	gentity_t* target, float slowingDistance);
+	float			Persue(gentity_t* actor,	gentity_t* target, float slowingDistance, float offsetForward, float offsetRight=0.0f, float offsetUp=0.0f, bool relativeToTargetFacing=false);
+	float			Evade(gentity_t* actor,		gentity_t* target);
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Separation, Alignment, Cohesion
+	//
+	// These standard steering operations will apply thrust to achieve a group oriented
+	// position or direction.
+	////////////////////////////////////////////////////////////////////////////////////
+	float			Separation(gentity_t* actor, float Scale=1.0f);
+	float			Alignment(gentity_t* actor, float Scale=1.0f);
+	float			Cohesion(gentity_t* actor, float Scale=1.0f);
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Wander & Path
+	//
+	// By far the most common way to alter a character's thrust, path maintaines motion
+	// along a navigational path (see NAV namespace), and a random wander path.
+	////////////////////////////////////////////////////////////////////////////////////
+	float			Path(gentity_t* actor);
+	float			Wander(gentity_t* actor);
+	float			FollowLeader(gentity_t* actor, gentity_t* leader, float dist);
+
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Collision Avoidance
+	//
+	// Usually the last steering operation to call before finialization, this operation
+	// attempts to avoid collisions with nearby entities and architecture by thrusing
+	// away from them.
+	////////////////////////////////////////////////////////////////////////////////////
+	float			AvoidCollisions(gentity_t* actor, gentity_t* leader=0);
+	gentity_t*		SelectLeader(gentity_t* actor);
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Blocked
+	//
+	// This function records whether AI is blocked while the steering is active
+	////////////////////////////////////////////////////////////////////////////////////
+	void			Blocked(gentity_t* actor, gentity_t* target);
+	void			Blocked(gentity_t* actor, const vec3_t& target);
+	bool			HasBeenBlockedFor(gentity_t* actor, int duration);
+
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Reached
+	//
+	// A quick function to see if a target location has been reached by an actor
+	////////////////////////////////////////////////////////////////////////////////////
+	bool			Reached(gentity_t* actor, gentity_t* target,  float targetRadius, bool flying=false);
+	bool			Reached(gentity_t* actor, NAV::TNodeHandle target, float targetRadius, bool flying=false);
+	bool			Reached(gentity_t* actor, const vec3_t& target, float targetRadius, bool flying=false);
+}
+
+
+
+
+
+#endif	//__G_NAVIGATOR__
\ No newline at end of file
diff --git a/code/game/g_navnew.cpp b/code/game/g_navnew.cpp
new file mode 100644
index 0000000..9f6083a
--- /dev/null
+++ b/code/game/g_navnew.cpp
@@ -0,0 +1,227 @@
+// leave this line at the top for all g_xxxx.cpp files...
+#include "g_headers.h"
+
+extern qboolean G_EntIsUnlockedDoor( int entityNum );
+extern qboolean FlyingCreature( gentity_t *ent );
+
+#define	MIN_DOOR_BLOCK_DIST			16
+#define	MIN_DOOR_BLOCK_DIST_SQR		( MIN_DOOR_BLOCK_DIST * MIN_DOOR_BLOCK_DIST )
+/*
+-------------------------
+NAV_HitNavGoal
+-------------------------
+*/
+
+qboolean NAV_HitNavGoal( vec3_t point, vec3_t mins, vec3_t maxs, vec3_t dest, int radius, qboolean flying )
+{
+	vec3_t	dmins, dmaxs, pmins, pmaxs;
+
+	if ( radius )
+	{
+		radius;
+		//NOTE:  This needs to do a DistanceSquared on navgoals that had
+		//			a radius manually set! We can't do the smaller navgoals against
+		//			walls to get around this because player-sized traces to them
+		//			from angles will not work... - MCG
+		if ( !flying )
+		{//Allow for a little z difference
+			vec3_t	diff;
+			VectorSubtract( point, dest, diff );
+			if ( fabs(diff[2]) <= 24 )
+			{
+				diff[2] = 0;
+			}
+			return ( VectorLengthSquared( diff ) <= (radius*radius) );
+		}
+		else
+		{//must hit exactly
+			return ( DistanceSquared(dest, point) <= (radius*radius) );
+		}
+		//There is probably a better way to do this, either by preserving the original
+		//		mins and maxs of the navgoal and doing this check ONLY if the radius 
+		//		is non-zero (like the original implementation) or some boolean to
+		//		tell us to do this check rather than the fake bbox overlap check...
+	}
+	else
+	{
+		//Construct a dummy bounding box from our radius value
+		VectorSet( dmins, -radius, -radius, -radius );
+		VectorSet( dmaxs,  radius,  radius,  radius );
+
+		//Translate it
+		VectorAdd( dmins, dest, dmins );
+		VectorAdd( dmaxs, dest, dmaxs );
+
+		//Translate the starting box
+		VectorAdd( point, mins, pmins );
+		VectorAdd( point, maxs, pmaxs );
+
+		//See if they overlap
+		return G_BoundsOverlap( pmins, pmaxs, dmins, dmaxs );
+	}
+}
+
+/*
+-------------------------
+NAV_CheckAhead
+-------------------------
+*/
+
+qboolean NAV_CheckAhead( gentity_t *self, vec3_t end, trace_t &trace, int clipmask )
+{
+	vec3_t	mins;
+
+	//Offset the step height
+	VectorSet( mins, self->mins[0], self->mins[1], self->mins[2] + STEPSIZE );
+	
+	gi.trace( &trace, self->currentOrigin, mins, self->maxs, end, self->s.number, clipmask );
+
+	if ( trace.startsolid&&(trace.contents&CONTENTS_BOTCLIP) )
+	{//started inside do not enter, so ignore them
+		clipmask &= ~CONTENTS_BOTCLIP;
+		gi.trace( &trace, self->currentOrigin, mins, self->maxs, end, self->s.number, clipmask );
+	}
+	//Do a simple check
+	if ( ( trace.allsolid == qfalse ) && ( trace.startsolid == qfalse ) && ( trace.fraction == 1.0f ) )
+		return qtrue;
+
+	//See if we're too far above
+	if ( fabs( self->currentOrigin[2] - end[2] ) > 48 )
+		return qfalse;
+
+	//This is a work around
+	float	radius = ( self->maxs[0] > self->maxs[1] ) ? self->maxs[0] : self->maxs[1];
+	float	dist = Distance( self->currentOrigin, end );
+	float	tFrac = 1.0f - ( radius / dist );
+
+	if ( trace.fraction >= tFrac )
+		return qtrue;
+
+	//Do a special check for doors
+	if ( trace.entityNum < ENTITYNUM_WORLD )
+	{
+		gentity_t	*blocker = &g_entities[trace.entityNum];
+		
+		if VALIDSTRING( blocker->classname )
+		{
+			if ( G_EntIsUnlockedDoor( blocker->s.number ) )
+			//if ( Q_stricmp( blocker->classname, "func_door" ) == 0 )
+			{
+				//We're too close, try and avoid the door (most likely stuck on a lip)
+				if ( DistanceSquared( self->currentOrigin, trace.endpos ) < MIN_DOOR_BLOCK_DIST_SQR )
+					return qfalse;
+
+				return qtrue;
+			}
+		}
+	}
+
+	return qfalse;
+}
+
+/*
+-------------------------
+NPC_ClearPathToGoal
+-------------------------
+*/
+
+qboolean NPC_ClearPathToGoal( vec3_t dir, gentity_t *goal )
+{
+	trace_t	trace;
+
+	//FIXME: What does do about area portals?  THIS IS BROKEN
+	//if ( gi.inPVS( NPC->currentOrigin, goal->currentOrigin ) == qfalse )
+	//	return qfalse;
+
+	//Look ahead and see if we're clear to move to our goal position
+	if ( NAV_CheckAhead( NPC, goal->currentOrigin, trace, ( NPC->clipmask & ~CONTENTS_BODY )|CONTENTS_BOTCLIP ) )
+	{
+		//VectorSubtract( goal->currentOrigin, NPC->currentOrigin, dir );
+		return qtrue;
+	}
+
+	if (!FlyingCreature(NPC))
+	{
+		//See if we're too far above
+		if ( fabs( NPC->currentOrigin[2] - goal->currentOrigin[2] ) > 48 )
+			return qfalse;
+	}
+
+	//This is a work around
+	float	radius = ( NPC->maxs[0] > NPC->maxs[1] ) ? NPC->maxs[0] : NPC->maxs[1];
+	float	dist = Distance( NPC->currentOrigin, goal->currentOrigin );
+	float	tFrac = 1.0f - ( radius / dist );
+
+	if ( trace.fraction >= tFrac )
+		return qtrue;
+
+	//See if we're looking for a navgoal
+	if ( goal->svFlags & SVF_NAVGOAL )
+	{
+		//Okay, didn't get all the way there, let's see if we got close enough:
+		if ( NAV_HitNavGoal( trace.endpos, NPC->mins, NPC->maxs, goal->currentOrigin, NPCInfo->goalRadius, FlyingCreature( NPC ) ) )
+		{
+			//VectorSubtract(goal->currentOrigin, NPC->currentOrigin, dir);
+			return qtrue;
+		}
+	}
+
+	return qfalse;
+}
+
+qboolean NAV_DirSafe( gentity_t *self, vec3_t dir, float dist )
+{
+	vec3_t	mins, end;
+	trace_t	trace;
+
+	VectorMA( self->currentOrigin, dist, dir, end );
+
+	//Offset the step height
+	VectorSet( mins, self->mins[0], self->mins[1], self->mins[2] + STEPSIZE );
+	
+	gi.trace( &trace, self->currentOrigin, mins, self->maxs, end, self->s.number, CONTENTS_BOTCLIP );
+
+	//Do a simple check
+	if ( ( trace.allsolid == qfalse ) && ( trace.startsolid == qfalse ) && ( trace.fraction == 1.0f ) )
+	{
+		return qtrue;
+	}
+
+	return qfalse;
+}
+
+qboolean NAV_MoveDirSafe( gentity_t *self, usercmd_t *cmd, float distScale = 1.0f )
+{
+	vec3_t	moveDir;
+
+	if ( !self || !self->client )
+	{
+		return qtrue;
+	}
+	if ( !self->client->ps.speed )
+	{
+		return qtrue;
+	}
+	if ( FlyingCreature( self ) )
+	{
+		return qtrue;
+	}
+	if ( VectorCompare( self->client->ps.moveDir, vec3_origin ) )
+	{//no movedir, build from cmd
+		if ( !cmd->forwardmove && !cmd->rightmove )
+		{//not moving at all
+			return qtrue;
+		}
+		vec3_t fwd, right, fwdAngs = {0, self->currentAngles[YAW], 0};
+		AngleVectors( fwdAngs, fwd, right, NULL );
+		VectorScale( fwd, cmd->forwardmove, fwd );
+		VectorScale( right, cmd->rightmove, right );
+		VectorAdd( fwd, right, moveDir );
+		VectorNormalize( moveDir );
+	}
+	else
+	{
+		VectorCopy( self->client->ps.moveDir, moveDir );
+	}
+	return (NAV_DirSafe( self, moveDir, (self->client->ps.speed/10.0f)*distScale ));
+}
diff --git a/code/game/g_object.cpp b/code/game/g_object.cpp
new file mode 100644
index 0000000..34c16af
--- /dev/null
+++ b/code/game/g_object.cpp
@@ -0,0 +1,356 @@
+// leave this line at the top for all g_xxxx.cpp files...
+#include "g_headers.h"
+
+
+#include "g_local.h"
+#include "g_functions.h"
+
+extern void G_MoverTouchPushTriggers( gentity_t *ent, vec3_t oldOrg );
+void G_StopObjectMoving( gentity_t *object );
+
+/*
+================
+G_BounceMissile
+
+================
+*/
+void G_BounceObject( gentity_t *ent, trace_t *trace ) 
+{
+	vec3_t	velocity;
+	float	dot;
+	int		hitTime;
+
+	// reflect the velocity on the trace plane
+	hitTime = level.previousTime + ( level.time - level.previousTime ) * trace->fraction;
+	EvaluateTrajectoryDelta( &ent->s.pos, hitTime, velocity );
+	dot = DotProduct( velocity, trace->plane.normal );
+	float bounceFactor = 60/ent->mass;
+	if ( bounceFactor > 1.0f )
+	{
+		bounceFactor = 1.0f;
+	}
+	VectorMA( velocity, -2*dot*bounceFactor, trace->plane.normal, ent->s.pos.trDelta );
+
+	//FIXME: customized or material-based impact/bounce sounds
+	if ( ent->s.eFlags & EF_BOUNCE_HALF ) 
+	{
+		VectorScale( ent->s.pos.trDelta, 0.5, ent->s.pos.trDelta );
+
+		// check for stop
+		if ( ((trace->plane.normal[2] > 0.7&&g_gravity->value>0) || (trace->plane.normal[2]<-0.7&&g_gravity->value<0)) && ((ent->s.pos.trDelta[2]<40&&g_gravity->value>0)||(ent->s.pos.trDelta[2]>-40&&g_gravity->value<0)) ) //this can happen even on very slightly sloped walls, so changed it from > 0 to > 0.7
+		{
+			//G_SetOrigin( ent, trace->endpos );
+			//ent->nextthink = level.time + 500;
+			ent->s.apos.trType = TR_STATIONARY;
+			VectorCopy( ent->currentAngles, ent->s.apos.trBase );
+			VectorCopy( trace->endpos, ent->currentOrigin );
+			VectorCopy( trace->endpos, ent->s.pos.trBase );
+			ent->s.pos.trTime = level.time;
+			return;
+		}
+	}
+
+	// NEW--It would seem that we want to set our trBase to the trace endpos
+	//	and set the trTime to the actual time of impact....
+	//	FIXME: Should we still consider adding the normal though??
+	VectorCopy( trace->endpos, ent->currentOrigin );
+	ent->s.pos.trTime = hitTime;
+
+	VectorCopy( ent->currentOrigin, ent->s.pos.trBase );
+	VectorCopy( trace->plane.normal, ent->pos1 );//???
+}
+
+/*
+================
+G_RunObject
+
+  TODO:  When transition to 0 grav, push away from surface you were resting on
+  TODO:  When free-floating in air, apply some friction to your trDelta (based on mass?)
+================
+*/
+extern void DoImpact( gentity_t *self, gentity_t *other, qboolean damageSelf, trace_t *trace );
+void G_RunObject( gentity_t *ent ) 
+{
+	vec3_t		origin, oldOrg;
+	trace_t		tr;
+	gentity_t	*traceEnt = NULL;
+
+	//FIXME: floaters need to stop floating up after a while, even if gravity stays negative?
+	if ( ent->s.pos.trType == TR_STATIONARY )//g_gravity->value <= 0 && 
+	{
+		ent->s.pos.trType = TR_GRAVITY;
+		VectorCopy( ent->currentOrigin, ent->s.pos.trBase );
+		ent->s.pos.trTime = level.previousTime;//?necc?
+		if ( !g_gravity->value )
+		{
+			ent->s.pos.trDelta[2] += 100;
+		}
+	}
+
+	ent->nextthink = level.time + FRAMETIME;
+
+	VectorCopy( ent->currentOrigin, oldOrg );
+	// get current position
+	EvaluateTrajectory( &ent->s.pos, level.time, origin );
+	//Get current angles?
+	EvaluateTrajectory( &ent->s.apos, level.time, ent->currentAngles );
+
+	if ( VectorCompare( ent->currentOrigin, origin ) )
+	{//error - didn't move at all!
+		return;
+	}
+	// trace a line from the previous position to the current position,
+	// ignoring interactions with the missile owner
+	gi.trace( &tr, ent->currentOrigin, ent->mins, ent->maxs, origin, 
+		ent->owner ? ent->owner->s.number : ent->s.number, ent->clipmask );
+
+	if ( !tr.startsolid && !tr.allsolid && tr.fraction ) 
+	{
+		VectorCopy( tr.endpos, ent->currentOrigin );
+		gi.linkentity( ent );
+	}
+	else
+	//if ( tr.startsolid ) 
+	{
+		tr.fraction = 0;
+	}
+
+	G_MoverTouchPushTriggers( ent, oldOrg );
+	/*
+	if ( !(ent->s.eFlags & EF_TELEPORT_BIT) && !(ent->svFlags & SVF_NO_TELEPORT) )
+	{
+		G_MoverTouchTeleportTriggers( ent, oldOrg );
+		if ( ent->s.eFlags & EF_TELEPORT_BIT )
+		{//was teleported
+			return;
+		}
+	}
+	else
+	{
+		ent->s.eFlags &= ~EF_TELEPORT_BIT;
+	}
+	*/
+
+	if ( tr.fraction == 1 ) 
+	{
+		if ( g_gravity->value <= 0 )
+		{
+			if ( ent->s.apos.trType == TR_STATIONARY )
+			{
+				VectorCopy( ent->currentAngles, ent->s.apos.trBase );
+				ent->s.apos.trType = TR_LINEAR;
+				ent->s.apos.trDelta[1] = Q_flrand( -300, 300 );
+				ent->s.apos.trDelta[0] = Q_flrand( -10, 10 );
+				ent->s.apos.trDelta[2] = Q_flrand( -10, 10 );
+				ent->s.apos.trTime = level.time;
+			}
+		}
+		//friction in zero-G
+		if ( !g_gravity->value )
+		{
+			float friction = 0.975f;
+			/*friction -= ent->mass/1000.0f;
+			if ( friction < 0.1 )
+			{
+				friction = 0.1f;
+			}
+			*/
+			VectorScale( ent->s.pos.trDelta, friction, ent->s.pos.trDelta );
+			VectorCopy( ent->currentOrigin, ent->s.pos.trBase );
+			ent->s.pos.trTime = level.time;
+		}
+		return;
+	}
+
+	//hit something
+
+	//Do impact damage
+	traceEnt = &g_entities[tr.entityNum];
+	if ( tr.fraction || (traceEnt && traceEnt->takedamage) )
+	{
+		if ( !VectorCompare( ent->currentOrigin, oldOrg ) )
+		{//moved and impacted
+			if ( (traceEnt && traceEnt->takedamage) )
+			{//hurt someone
+				vec3_t fxDir;
+				VectorNormalize2( ent->s.pos.trDelta, fxDir );
+				VectorScale( fxDir, -1, fxDir );
+				G_PlayEffect( G_EffectIndex( "melee/kick_impact" ), tr.endpos, fxDir );
+				//G_Sound( ent, G_SoundIndex( va( "sound/weapons/melee/punch%d", Q_irand( 1, 4 ) ) ) );
+			}
+			else
+			{
+				G_PlayEffect( G_EffectIndex( "melee/kick_impact_silent" ), tr.endpos, tr.plane.normal );
+			}
+			if ( ent->mass > 100 )
+			{
+				G_Sound( ent, G_SoundIndex( "sound/movers/objects/objectHitHeavy.wav" ) );
+			}
+			else
+			{
+				G_Sound( ent, G_SoundIndex( "sound/movers/objects/objectHit.wav" ) );
+			}
+		}
+		DoImpact( ent, traceEnt, !(tr.surfaceFlags&SURF_NODAMAGE), &tr );
+	}
+
+	if ( !ent || (ent->takedamage&&ent->health <= 0) )
+	{//been destroyed by impact
+		//chunks?
+		G_Sound( ent, G_SoundIndex( "sound/movers/objects/objectBreak.wav" ) );
+		return;
+	}
+
+	//do impact physics
+	if ( ent->s.pos.trType == TR_GRAVITY )//tr.fraction < 1.0 && 
+	{//FIXME: only do this if no trDelta
+		if ( g_gravity->value <= 0 || tr.plane.normal[2] < 0.7 )
+		{
+			if ( ent->s.eFlags&(EF_BOUNCE|EF_BOUNCE_HALF) )
+			{
+				if ( tr.fraction <= 0.0f )
+				{
+					VectorCopy( tr.endpos, ent->currentOrigin );
+					VectorCopy( tr.endpos, ent->s.pos.trBase );
+					VectorClear( ent->s.pos.trDelta );
+					ent->s.pos.trTime = level.time;
+				}
+				else
+				{
+					G_BounceObject( ent, &tr );
+				}
+			}
+			else
+			{//slide down?
+				//FIXME: slide off the slope
+			}
+		}
+		else
+		{
+			ent->s.apos.trType = TR_STATIONARY;
+			pitch_roll_for_slope( ent, tr.plane.normal );
+			//ent->currentAngles[0] = 0;//FIXME: match to slope
+			//ent->currentAngles[2] = 0;//FIXME: match to slope
+			VectorCopy( ent->currentAngles, ent->s.apos.trBase );
+			//okay, we hit the floor, might as well stop or prediction will
+			//make us go through the floor!
+			//FIXME: this means we can't fall if something is pulled out from under us...
+			G_StopObjectMoving( ent );
+		}
+	}
+	else
+	{
+		ent->s.apos.trType = TR_STATIONARY;
+		pitch_roll_for_slope( ent, tr.plane.normal );
+		//ent->currentAngles[0] = 0;//FIXME: match to slope
+		//ent->currentAngles[2] = 0;//FIXME: match to slope
+		VectorCopy( ent->currentAngles, ent->s.apos.trBase );
+	}
+
+	//call touch func
+	GEntity_TouchFunc( ent, &g_entities[tr.entityNum], &tr );
+}
+
+void G_StopObjectMoving( gentity_t *object )
+{
+	object->s.pos.trType = TR_STATIONARY;
+	VectorCopy( object->currentOrigin, object->s.origin );
+	VectorCopy( object->currentOrigin, object->s.pos.trBase );
+	VectorClear( object->s.pos.trDelta );
+
+	/*
+	//Stop spinning
+	VectorClear( self->s.apos.trDelta );
+	vectoangles(trace->plane.normal, self->s.angles);
+	VectorCopy(self->s.angles, self->currentAngles );
+	VectorCopy(self->s.angles, self->s.apos.trBase);
+	*/
+}
+
+void G_StartObjectMoving( gentity_t *object, vec3_t dir, float speed, trType_t trType )
+{
+	VectorNormalize (dir);
+
+	//object->s.eType = ET_GENERAL;
+	object->s.pos.trType = trType;
+	VectorCopy( object->currentOrigin, object->s.pos.trBase );
+	VectorScale(dir, speed, object->s.pos.trDelta );
+	object->s.pos.trTime = level.time;
+
+	/*
+	//FIXME: incorporate spin?
+	vectoangles(dir, object->s.angles);
+	VectorCopy(object->s.angles, object->s.apos.trBase);
+	VectorSet(object->s.apos.trDelta, 300, 0, 0 );
+	object->s.apos.trTime = level.time;
+	*/
+
+	//FIXME: make these objects go through G_RunObject automatically, like missiles do
+	if ( object->e_ThinkFunc == thinkF_NULL )
+	{
+		object->nextthink = level.time + FRAMETIME;
+		object->e_ThinkFunc = thinkF_G_RunObject;
+	}
+	else
+	{//You're responsible for calling RunObject
+	}
+}
+
+gentity_t *G_CreateObject ( gentity_t *owner, vec3_t origin, vec3_t angles, int modelIndex, int frame, trType_t trType, int effectID = 0  ) 
+{
+	gentity_t	*object;
+
+	object = G_Spawn();
+
+	if ( object == NULL )
+	{
+		return NULL;
+	}
+
+	object->classname = "object";//?
+	object->nextthink = level.time + FRAMETIME;
+	object->e_ThinkFunc = thinkF_G_RunObject;
+	object->s.eType = ET_GENERAL;
+	object->s.eFlags |= EF_AUTO_SIZE;//CG_Ents will create the mins & max itself based on model bounds
+	object->s.modelindex = modelIndex;
+	//FIXME: allow to set a targetname/script_targetname and animation info?
+	object->s.frame = object->startFrame = object->endFrame = frame;
+	object->owner = owner;
+	//object->damage = 100;
+	//object->splashDamage = 200;
+	//object->splashRadius = 200;
+	//object->methodOfDeath = MOD_EXPLOSIVE;
+	//object->splashMethodOfDeath = MOD_EXPLOSIVE_SPLASH;
+	object->clipmask = MASK_SOLID;//?
+	//object->e_TouchFunc = touchF_charge_stick;
+
+	// The effect to play.
+	object->count = effectID;
+
+	//Give it SOME size for now
+	VectorSet( object->mins, -4, -4, -4 );
+	VectorSet( object->maxs, 4, 4, 4 );
+
+	//Origin
+	G_SetOrigin( object, origin );
+	object->s.pos.trType = trType;
+	VectorCopy( origin, object->s.pos.trBase );
+	//Velocity
+	VectorClear( object->s.pos.trDelta );
+	object->s.pos.trTime = level.time;
+	//VectorScale( dir, 300, object->s.pos.trDelta );
+	//object->s.pos.trTime = level.time;
+
+	//Angles
+	VectorCopy( angles, object->s.angles );
+	VectorCopy( object->s.angles, object->s.apos.trBase );
+	//Angular Velocity
+	VectorClear( object->s.apos.trDelta );
+	object->s.apos.trTime = level.time;
+	//VectorSet( object->s.apos.trDelta, 300, 0, 0 );
+	//object->s.apos.trTime = level.time;
+
+	gi.linkentity( object );
+
+	return object;
+}
diff --git a/code/game/g_objectives.cpp b/code/game/g_objectives.cpp
new file mode 100644
index 0000000..9ad2ec2
--- /dev/null
+++ b/code/game/g_objectives.cpp
@@ -0,0 +1,85 @@
+// leave this line at the top for all g_xxxx.cpp files...
+#include "g_headers.h"
+
+
+//g_objectives.cpp
+//reads in ext_data\objectives.dat to objectives[]
+
+#include "g_local.h"
+#include "g_items.h"
+
+#define	G_OBJECTIVES_CPP
+
+#include "objectives.h"
+
+qboolean	missionInfo_Updated;
+
+
+/*
+============
+OBJ_SetPendingObjectives
+============
+*/
+void OBJ_SetPendingObjectives(gentity_t *ent)
+{
+	int i;
+
+	for (i=0;i<MAX_OBJECTIVES;++i)
+	{
+		if ((ent->client->sess.mission_objectives[i].status == OBJECTIVE_STAT_PENDING) && 
+			(ent->client->sess.mission_objectives[i].display))
+		{
+			ent->client->sess.mission_objectives[i].status = OBJECTIVE_STAT_FAILED;
+		}
+	}
+}
+
+/*
+============
+OBJ_SaveMissionObjectives
+============
+*/
+void OBJ_SaveMissionObjectives( gclient_t *client )
+{
+	gi.AppendToSaveGame('OBJT', client->sess.mission_objectives, sizeof(client->sess.mission_objectives));
+}
+
+
+/*
+============
+OBJ_SaveObjectiveData
+============
+*/
+void OBJ_SaveObjectiveData(void)
+{
+	gclient_t *client;
+
+	client = &level.clients[0];
+
+	OBJ_SaveMissionObjectives( client );
+}
+
+/*
+============
+OBJ_LoadMissionObjectives
+============
+*/
+void OBJ_LoadMissionObjectives( gclient_t *client )
+{
+	gi.ReadFromSaveGame('OBJT', (void *) &client->sess.mission_objectives, sizeof(client->sess.mission_objectives));
+}
+
+
+/*
+============
+OBJ_LoadObjectiveData
+============
+*/
+void OBJ_LoadObjectiveData(void)
+{
+	gclient_t *client;
+
+	client = &level.clients[0];
+
+	OBJ_LoadMissionObjectives( client );
+}
diff --git a/code/game/g_public.h b/code/game/g_public.h
new file mode 100644
index 0000000..7dd183b
--- /dev/null
+++ b/code/game/g_public.h
@@ -0,0 +1,531 @@
+#ifndef __G_PUBLIC_H__
+#define __G_PUBLIC_H__
+// g_public.h -- game module information visible to server
+
+#define	GAME_API_VERSION	8
+
+// entity->svFlags
+// the server does not know how to interpret most of the values
+// in entityStates (level eType), so the game must explicitly flag
+// special server behaviors
+#define	SVF_NOCLIENT			0x00000001	// don't send entity to clients, even if it has effects
+#define SVF_INACTIVE			0x00000002	// Can't be used when this flag is on
+#define SVF_NPC					0x00000004
+#define SVF_BOT					0x00000008
+#define SVF_PLAYER_USABLE		0x00000010	// player can use this with the use button
+#define	SVF_BROADCAST			0x00000020	// send to all connected clients
+#define	SVF_PORTAL				0x00000040	// merge a second pvs at origin2 into snapshots
+#define	SVF_USE_CURRENT_ORIGIN	0x00000080	// entity->currentOrigin instead of entity->s.origin
+											// for link position (missiles and movers)
+#define SVF_TRIMODEL			0x00000100	// Use a three piece model make up like a player does
+#define	SVF_OBJECTIVE			0x00000200	// Draw it's name if crosshair comes across it
+#define	SVF_ANIMATING			0x00000400	// Currently animating from startFrame to endFrame
+#define	SVF_NPC_PRECACHE		0x00000800	// Tell cgame to precache this spawner's NPC stuff
+#define	SVF_KILLED_SELF			0x00001000	// ent killed itself in a script, so don't do ICARUS_FreeEnt on it... or else!
+#define	SVF_NAVGOAL				0x00002000	// Navgoal
+#define	SVF_NOPUSH				0x00004000	// Can't be pushed around
+#define	SVF_ICARUS_FREEZE		0x00008000	// NPCs are frozen, ents don't execute ICARUS commands
+#define SVF_PLAT				0x00010000	// A func_plat or door acting like one
+#define	SVF_BBRUSH				0x00020000	// breakable brush
+#define	SVF_LOCKEDENEMY			0x00040000	// keep current enemy until dead
+#define SVF_IGNORE_ENEMIES		0x00080000	// Ignore all enemies
+#define SVF_BEAMING				0x00100000	// Being transported
+#define SVF_PLAYING_SOUND		0x00200000	// In the middle of playing a sound
+#define SVF_CUSTOM_GRAVITY		0x00400000	// Use personal gravity
+#define SVF_BROKEN				0x00800000	// A broken misc_model_breakable
+#define SVF_NO_TELEPORT			0x01000000	// Will not be teleported
+#define SVF_NONNPC_ENEMY		0x02000000	// Not a client/NPC, but can still be considered a hostile lifeform
+#define SVF_SELF_ANIMATING		0x04000000	// Ent will control it's animation itself in it's think func
+#define SVF_GLASS_BRUSH			0x08000000	// Ent is a glass brush
+#define SVF_NO_BASIC_SOUNDS		0x10000000	// Don't load basic custom sound set
+#define SVF_NO_COMBAT_SOUNDS	0x20000000	// Don't load combat custom sound set
+#define SVF_NO_EXTRA_SOUNDS		0x40000000	// Don't load extra custom sound set
+#define SVF_MOVER_ADJ_AREA_PORTALS	0x80000000	// For scripted movers only- must *explicitly instruct* them to affect area portals
+//===============================================================
+
+//rww - RAGDOLL_BEGIN
+class CRagDollUpdateParams;
+class CRagDollParams;
+//rww - RAGDOLL_END
+
+typedef struct gentity_s gentity_t;
+typedef struct gclient_s gclient_t;
+
+typedef enum
+{
+	eNO = 0,
+	eFULL,
+	eAUTO,
+} SavedGameJustLoaded_e;
+
+
+
+#ifndef GAME_INCLUDE
+
+// the server needs to know enough information to handle collision and snapshot generation
+
+struct gentity_s {
+	entityState_t	s;				// communicated by server to clients
+	struct playerState_s	*client;
+	qboolean	inuse;
+	qboolean	linked;				// qfalse if not in any good cluster
+
+	int			svFlags;			// SVF_NOCLIENT, SVF_BROADCAST, etc
+
+	qboolean	bmodel;				// if false, assume an explicit mins / maxs bounding box
+									// only set by gi.SetBrushModel
+	vec3_t		mins, maxs;
+	int			contents;			// CONTENTS_TRIGGER, CONTENTS_SOLID, CONTENTS_BODY, etc
+									// a non-solid entity should set to 0
+
+	vec3_t		absmin, absmax;		// derived from mins/maxs and origin + rotation
+
+	// currentOrigin will be used for all collision detection and world linking.
+	// it will not necessarily be the same as the trajectory evaluation for the current
+	// time, because each entity must be moved one at a time after time is advanced
+	// to avoid simultanious collision issues
+	vec3_t		currentOrigin;
+	vec3_t		currentAngles;
+
+	gentity_t	*owner;				// objects never interact with their owners, to
+									// prevent player missiles from immediately
+									// colliding with their owner
+/*
+Ghoul2 Insert Start
+*/
+	// this marker thing of Jake's is used for memcpy() length calcs, so don't put any ordinary fields (like above)
+	//	below this point or they won't work, and will mess up all sorts of stuff. 
+	//
+	CGhoul2Info_v	ghoul2;
+/*
+Ghoul2 Insert End
+*/
+	// the game dll can add anything it wants after
+	// this point in the structure
+};
+
+#endif		// GAME_INCLUDE
+
+//===============================================================
+
+#if defined(_XBOX) && !defined(_TRACE_FUNCTOR_T_DEFINED_)
+// Function objects to replace the function pointers used for trace
+// We can't have default arguments on function pointers, but this allows us to
+// do the same thing with minimal impact elsewhere.
+struct Trace_Functor_t
+{
+	typedef void (*trace_func_t)(trace_t *, const vec3_t, const vec3_t, const vec3_t, const vec3_t,
+								 const int, const int, const EG2_Collision, const int);
+	trace_func_t trace_func;
+	void operator()( trace_t *results, const vec3_t start, const vec3_t mins, const vec3_t maxs, const vec3_t end, 
+						const int passEntityNum, const int contentMask, const EG2_Collision eG2TraceType = (EG2_Collision)0, const int useLod = 0 )
+		{ trace_func(results, start, mins, maxs, end, passEntityNum, contentMask, eG2TraceType, useLod); }
+	const Trace_Functor_t &operator=(trace_func_t traceRHS)
+	{
+		trace_func = traceRHS;
+		return *this;
+	}
+};
+
+// Always create this class exactly once
+#define _TRACE_FUNCTOR_T_DEFINED_
+#endif
+
+#ifdef _XBOX
+// Declare all the functions that we use in the inlined member functions
+/*
+extern int		G2API_InitGhoul2Model(CGhoul2Info_v &ghoul2, const char *fileName, int modelIndex, qhandle_t customSkin = NULL,
+									  qhandle_t customShader = NULL, int modelFlags = 0, int lodBias = 0);
+extern qboolean	G2API_SetSkin(CGhoul2Info *ghlInfo, qhandle_t customSkin, qhandle_t renderSkin = 0);
+extern qboolean	G2API_SetBoneAnim(CGhoul2Info *ghlInfo, const char *boneName, const int startFrame, const int endFrame,
+								  const int flags, const float animSpeed, const int currentTime, const float setFrame = -1, const int blendTime = -1);
+extern qboolean	G2API_SetBoneAngles(CGhoul2Info *ghlInfo, const char *boneName, const vec3_t angles, const int flags,
+									const Eorientations up, const Eorientations right, const Eorientations forward, qhandle_t *modelList,
+									int blendTime = 0, int currentTime = 0);
+extern qboolean	G2API_SetBoneAnglesMatrix(CGhoul2Info *ghlInfo, const char *boneName, const mdxaBone_t &matrix, const int flags,
+										  qhandle_t *modelList, int blendTime = 0, int currentTime = 0);
+extern void		G2API_CopyGhoul2Instance(CGhoul2Info_v &Ghoul2From, CGhoul2Info_v &Ghoul2To, int modelIndex = -1);
+extern qboolean	G2API_SetBoneAnglesIndex(CGhoul2Info *ghlInfo, const int index, const vec3_t angles, const int flags,
+										 const Eorientations yaw, const Eorientations pitch, const Eorientations roll,
+										 qhandle_t *modelList, int blendTime, int currentTime);
+extern qboolean	G2API_SetBoneAnimIndex(CGhoul2Info *ghlInfo, const int index, const int startFrame, const int endFrame, const int flags, const float animSpeed, const int currentTime, const float setFrame, const int blendTime);
+*/
+#include "../ghoul2/g2.h"
+extern int		SG_Read			(unsigned long chid, void *pvAddress, int iLength, void **ppvAddressPtr);
+extern int		SG_ReadOptional	(unsigned long chid, void *pvAddress, int iLength, void **ppvAddressPtr);
+#endif
+
+//
+// functions provided by the main engine
+//
+/*
+Ghoul2 Insert Start
+*/
+class CMiniHeap;
+/*
+Ghoul2 Insert End
+*/
+typedef struct {
+	//============== general Quake services ==================
+
+	// print message on the local console
+	void	(*Printf)( const char *fmt, ... );
+
+	// Write a camera ref_tag to cameras.map
+	void	(*WriteCam)( const char *text );
+	void	(*FlushCamFile)();
+
+	// abort the game
+	void	(*Error)( int, const char *fmt, ... );
+
+	// get current time for profiling reasons
+	// this should NOT be used for any game related tasks,
+	// because it is not journaled
+	int		(*Milliseconds)( void );
+
+	// console variable interaction
+	cvar_t	*(*cvar)( const char *var_name, const char *value, int flags );
+	void	(*cvar_set)( const char *var_name, const char *value );
+	int		(*Cvar_VariableIntegerValue)( const char *var_name );
+	void	(*Cvar_VariableStringBuffer)( const char *var_name, char *buffer, int bufsize );
+
+	// ClientCommand and ServerCommand parameter access
+	int		(*argc)( void );
+	char	*(*argv)( int n );
+
+	int		(*FS_FOpenFile)( const char *qpath, fileHandle_t *file, fsMode_t mode );
+	int		(*FS_Read)( void *buffer, int len, fileHandle_t f );
+	int		(*FS_Write)( const void *buffer, int len, fileHandle_t f );
+	void	(*FS_FCloseFile)( fileHandle_t f );
+	int		(*FS_ReadFile)( const char *name, void **buf );
+	void	(*FS_FreeFile)( void *buf );
+	int		(*FS_GetFileList)(  const char *path, const char *extension, char *listbuf, int bufsize );
+
+	// Savegame handling
+	//
+	qboolean	(*AppendToSaveGame)(unsigned long chid, const void *data, int length);
+#ifdef _XBOX	// No default arguments through function pointers
+	int			ReadFromSaveGame(unsigned long chid, void *pvAddress, int iLength, void **ppvAddressPtr = NULL)
+	{
+		return SG_Read(chid, pvAddress, iLength, ppvAddressPtr);
+	}
+
+	int			ReadFromSaveGameOptional(unsigned long chid, void *pvAddress, int iLength, void **ppvAddressPtr = NULL)
+	{
+		return SG_ReadOptional(chid, pvAddress, iLength, ppvAddressPtr);
+	}
+#else
+	int			(*ReadFromSaveGame)(unsigned long chid, void *pvAddress, int iLength, void **ppvAddressPtr = NULL);
+	int			(*ReadFromSaveGameOptional)(unsigned long chid, void *pvAddress, int iLength, void **ppvAddressPtr = NULL);
+#endif
+	// add commands to the console as if they were typed in
+	// for map changing, etc
+	void	(*SendConsoleCommand)( const char *text );
+
+
+	//=========== server specific functionality =============
+
+	// kick a client off the server with a message
+	void	(*DropClient)( int clientNum, const char *reason );
+
+	// reliably sends a command string to be interpreted by the given
+	// client.  If clientNum is -1, it will be sent to all clients
+	void	(*SendServerCommand)( int clientNum, const char *fmt, ... );
+
+	// config strings hold all the index strings, and various other information
+	// that is reliably communicated to all clients
+	// All of the current configstrings are sent to clients when
+	// they connect, and changes are sent to all connected clients.
+	// All confgstrings are cleared at each level start.
+	void	(*SetConfigstring)( int num, const char *string );
+	void	(*GetConfigstring)( int num, char *buffer, int bufferSize );
+
+	// userinfo strings are maintained by the server system, so they
+	// are persistant across level loads, while all other game visible
+	// data is completely reset
+	void	(*GetUserinfo)( int num, char *buffer, int bufferSize );
+	void	(*SetUserinfo)( int num, const char *buffer );
+
+	// the serverinfo info string has all the cvars visible to server browsers
+	void	(*GetServerinfo)( char *buffer, int bufferSize );
+
+	// sets mins and maxs based on the brushmodel name
+	void	(*SetBrushModel)( gentity_t *ent, const char *name );
+
+	// collision detection against all linked entities
+#ifdef _XBOX
+	Trace_Functor_t trace;
+#else
+	void	(*trace)( trace_t *results, const vec3_t start, const vec3_t mins, const vec3_t maxs, const vec3_t end, 
+			const int passEntityNum, const int contentmask , const EG2_Collision eG2TraceType = (EG2_Collision)0, const int useLod = 0);
+#endif
+
+	// point contents against all linked entities
+	int		(*pointcontents)( const vec3_t point, int passEntityNum );
+	// what contents are on the map? 
+	int		(*totalMapContents)();
+
+	qboolean	(*inPVS)( const vec3_t p1, const vec3_t p2 );
+	qboolean	(*inPVSIgnorePortals)( const vec3_t p1, const vec3_t p2 );
+	void		(*AdjustAreaPortalState)( gentity_t *ent, qboolean open );
+	qboolean	(*AreasConnected)( int area1, int area2 );
+
+	// an entity will never be sent to a client or used for collision
+	// if it is not passed to linkentity.  If the size, position, or
+	// solidity changes, it must be relinked.
+	void	(*linkentity)( gentity_t *ent );
+	void	(*unlinkentity)( gentity_t *ent );		// call before removing an interactive entity
+
+	// EntitiesInBox will return brush models based on their bounding box,
+	// so exact determination must still be done with EntityContact
+	int		(*EntitiesInBox)( const vec3_t mins, const vec3_t maxs, gentity_t **list, int maxcount );
+
+	// perform an exact check against inline brush models of non-square shape
+	qboolean	(*EntityContact)( const vec3_t mins, const vec3_t maxs, const gentity_t *ent );
+
+	// sound volume values
+	int		*VoiceVolume;
+
+	// dynamic memory allocator for things that need to be freed
+	void		*(*Malloc)( int iSize, memtag_t eTag, qboolean bZeroIt);	// see qcommon/tags.h for choices
+	int			(*Free)( void *buf );
+	qboolean	(*bIsFromZone)( void *buf, memtag_t eTag);	// see qcommon/tags.h for choices
+
+/*
+Ghoul2 Insert Start
+*/
+qhandle_t	(*G2API_PrecacheGhoul2Model)(const char *fileName);
+
+#ifdef _XBOX	// No default arguments through function pointers
+	int			G2API_InitGhoul2Model(CGhoul2Info_v &ghoul2, const char *fileName, int modelIndex, qhandle_t customSkin = NULL,
+								  qhandle_t customShader = NULL, int modelFlags = 0, int lodBias = 0)
+	{
+		return ::G2API_InitGhoul2Model(ghoul2, fileName, modelIndex, customSkin, customShader, modelFlags, lodBias);
+	}
+
+	qboolean	G2API_SetSkin(CGhoul2Info *ghlInfo, qhandle_t customSkin, qhandle_t renderSkin = 0 )
+	{
+		return ::G2API_SetSkin(ghlInfo, customSkin, renderSkin);
+	}
+
+	qboolean	G2API_SetBoneAnim(CGhoul2Info *ghlInfo, const char *boneName, const int startFrame, const int endFrame,
+							  const int flags, const float animSpeed, const int currentTime, const float setFrame = -1, const int blendTime = -1)
+	{
+		return ::G2API_SetBoneAnim(ghlInfo, boneName, startFrame, endFrame, flags, animSpeed, currentTime, setFrame, blendTime);
+	}
+
+	qboolean	G2API_SetBoneAngles(CGhoul2Info *ghlInfo, const char *boneName, const vec3_t angles,
+								   const int flags, const Eorientations up, const Eorientations right, const Eorientations forward,
+								   qhandle_t *modelList, int blendTime = 0, int blendStart = 0)
+	{
+		return ::G2API_SetBoneAngles(ghlInfo, boneName, angles, flags, up, right, forward, modelList, blendTime, blendStart);
+	}
+
+	qboolean	G2API_SetBoneAnglesMatrix(CGhoul2Info *ghlInfo, const char *boneName, const mdxaBone_t &matrix, const int flags,
+									  qhandle_t *modelList, int blendTime = 0, int currentTime = 0)
+	{
+		return ::G2API_SetBoneAnglesMatrix(ghlInfo, boneName, matrix, flags, modelList, blendTime, currentTime);
+	}
+
+	void		G2API_CopyGhoul2Instance(CGhoul2Info_v &ghoul2From, CGhoul2Info_v &ghoul2To, int modelIndex = -1)
+	{
+		::G2API_CopyGhoul2Instance(ghoul2From, ghoul2To, modelIndex);
+	}
+
+	qboolean	G2API_SetBoneAnglesIndex(CGhoul2Info *ghlInfo, const int index, const vec3_t angles, const int flags,
+							 const Eorientations yaw, const Eorientations pitch, const Eorientations roll,
+							 qhandle_t *modelList, int blendTime = 0, int currentTime = 0)
+	{
+		return ::G2API_SetBoneAnglesIndex(ghlInfo, index, angles, flags, yaw, pitch, roll, modelList, blendTime, currentTime);
+	}
+
+	qboolean	G2API_SetBoneAnimIndex(CGhoul2Info *ghlInfo, const int index, const int startFrame, const int endFrame, const int flags, const float animSpeed, const int currentTime, const float setFrame = -1, const int blendTime = -1)
+	{
+		return ::G2API_SetBoneAnimIndex(ghlInfo, index, startFrame, endFrame, flags, animSpeed, currentTime, setFrame, blendTime);
+	}
+
+#else
+
+int			(*G2API_InitGhoul2Model)(CGhoul2Info_v &ghoul2, const char *fileName, int modelIndex, qhandle_t customSkin = NULL,
+								  qhandle_t customShader = NULL, int modelFlags = 0, int lodBias = 0);
+qboolean	(*G2API_SetSkin)(CGhoul2Info *ghlInfo, qhandle_t customSkin, qhandle_t renderSkin = 0 );
+qboolean	(*G2API_SetBoneAnim)(CGhoul2Info *ghlInfo, const char *boneName, const int startFrame, const int endFrame,
+							  const int flags, const float animSpeed, const int currentTime, const float setFrame = -1, const int blendTime = -1);
+qboolean	(*G2API_SetBoneAngles)(CGhoul2Info *ghlInfo, const char *boneName, const vec3_t angles,
+								   const int flags, const Eorientations up, const Eorientations right, const Eorientations forward,
+								   qhandle_t *modelList, int blendTime = 0, int blendStart = 0);
+qboolean	(*G2API_SetBoneAnglesIndex)(CGhoul2Info *ghlInfo, const int index, const vec3_t angles, const int flags,
+							 const Eorientations yaw, const Eorientations pitch, const Eorientations roll,
+							 qhandle_t *modelList, int blendTime = 0, int currentTime = 0);
+qboolean	(*G2API_SetBoneAnglesMatrix)(CGhoul2Info *ghlInfo, const char *boneName, const mdxaBone_t &matrix, const int flags,
+									  qhandle_t *modelList, int blendTime = 0, int currentTime = 0);
+void		(*G2API_CopyGhoul2Instance)(CGhoul2Info_v &ghoul2From, CGhoul2Info_v &ghoul2To, int modelIndex = -1);
+qboolean	(*G2API_SetBoneAnimIndex)(CGhoul2Info *ghlInfo, const int index, const int startFrame, const int endFrame, const int flags, const float animSpeed, const int currentTime, const float setFrame = -1, const int blendTime = -1);
+#endif
+
+qboolean	(*G2API_SetLodBias)(CGhoul2Info *ghlInfo, int lodBias);
+qboolean	(*G2API_SetShader)(CGhoul2Info *ghlInfo, qhandle_t customShader);
+qboolean	(*G2API_RemoveGhoul2Model)(CGhoul2Info_v &ghlInfo, const int modelIndex);
+qboolean	(*G2API_SetSurfaceOnOff)(CGhoul2Info *ghlInfo, const char *surfaceName, const int flags);
+qboolean	(*G2API_SetRootSurface)(CGhoul2Info_v &ghlInfo, const int modelIndex, const char *surfaceName);
+qboolean	(*G2API_RemoveSurface)(CGhoul2Info *ghlInfo, const int index);
+int			(*G2API_AddSurface)(CGhoul2Info *ghlInfo, int surfaceNumber, int polyNumber, float BarycentricI, float BarycentricJ, int lod );
+qboolean	(*G2API_GetBoneAnim)(CGhoul2Info *ghlInfo, const char *boneName, const int currentTime, float *currentFrame,
+							  int *startFrame, int *endFrame, int *flags, float *animSpeed, int *modelList);
+qboolean	(*G2API_GetBoneAnimIndex)(CGhoul2Info *ghlInfo, const int iBoneIndex, const int currentTime, float *currentFrame,
+							  int *startFrame, int *endFrame, int *flags, float *animSpeed, int *modelList);
+qboolean	(*G2API_GetAnimRange)(CGhoul2Info *ghlInfo, const char *boneName,	int *startFrame, int *endFrame);
+qboolean	(*G2API_GetAnimRangeIndex)(CGhoul2Info *ghlInfo, const int boneIndex,	int *startFrame, int *endFrame);
+
+qboolean	(*G2API_PauseBoneAnim)(CGhoul2Info *ghlInfo, const char *boneName, const int currentTime);
+qboolean	(*G2API_PauseBoneAnimIndex)(CGhoul2Info *ghlInfo, const int boneIndex, const int currentTime);
+qboolean	(*G2API_IsPaused)(CGhoul2Info *ghlInfo, const char *boneName);
+qboolean	(*G2API_StopBoneAnim)(CGhoul2Info *ghlInfo, const char *boneName);
+qboolean	(*G2API_StopBoneAngles)(CGhoul2Info *ghlInfo, const char *boneName);
+qboolean	(*G2API_RemoveBone)(CGhoul2Info *ghlInfo, const char *boneName);
+qboolean	(*G2API_RemoveBolt)(CGhoul2Info *ghlInfo, const int index);
+int			(*G2API_AddBolt)(CGhoul2Info *ghlInfo, const char *boneName);
+int			(*G2API_AddBoltSurfNum)(CGhoul2Info *ghlInfo, const int surfIndex);
+qboolean	(*G2API_AttachG2Model)(CGhoul2Info *ghlInfo, CGhoul2Info *ghlInfoTo, int toBoltIndex, int toModel);
+qboolean	(*G2API_DetachG2Model)(CGhoul2Info *ghlInfo);
+qboolean	(*G2API_AttachEnt)(int *boltInfo, CGhoul2Info *ghlInfoTo, int toBoltIndex, int entNum, int toModelNum);
+void		(*G2API_DetachEnt)(int *boltInfo);
+
+qboolean	(*G2API_GetBoltMatrix)(CGhoul2Info_v &ghoul2, const int modelIndex, const int boltIndex, mdxaBone_t *matrix, const vec3_t angles, const vec3_t position, const int frameNum, qhandle_t *modelList, const vec3_t scale);
+
+void		(*G2API_ListSurfaces)(CGhoul2Info *ghlInfo);
+void		(*G2API_ListBones)(CGhoul2Info *ghlInfo, int frame);
+qboolean	(*G2API_HaveWeGhoul2Models)(CGhoul2Info_v &ghoul2);
+qboolean	(*G2API_SetGhoul2ModelFlags)(CGhoul2Info *ghlInfo, const int flags);
+int			(*G2API_GetGhoul2ModelFlags)(CGhoul2Info *ghlInfo);
+
+qboolean	(*G2API_GetAnimFileName)(CGhoul2Info *ghlInfo, char **filename);
+void		(*G2API_CollisionDetect)(CCollisionRecord *collRecMap, CGhoul2Info_v &ghoul2, const vec3_t angles, const vec3_t position,
+									int frameNumber, int entNum, vec3_t rayStart, vec3_t rayEnd, vec3_t scale, CMiniHeap *G2VertSpace,
+									EG2_Collision eG2TraceType, int useLod, float fRadius);
+void		(*G2API_GiveMeVectorFromMatrix)(mdxaBone_t &boltMatrix, Eorientations flags, vec3_t &vec);
+void		(*G2API_CleanGhoul2Models)(CGhoul2Info_v &ghoul2);
+IGhoul2InfoArray &		(*TheGhoul2InfoArray)();
+int			(*G2API_GetParentSurface)(CGhoul2Info *ghlInfo, const int index);
+int			(*G2API_GetSurfaceIndex)(CGhoul2Info *ghlInfo, const char *surfaceName);
+char		*(*G2API_GetSurfaceName)(CGhoul2Info *ghlInfo, int surfNumber);
+char		*(*G2API_GetGLAName)(CGhoul2Info *ghlInfo);
+qboolean	(*G2API_SetNewOrigin)(CGhoul2Info *ghlInfo, const int boltIndex);
+int			(*G2API_GetBoneIndex)(CGhoul2Info *ghlInfo, const char *boneName, qboolean bAddIfNotFound);
+qboolean	(*G2API_StopBoneAnglesIndex)(CGhoul2Info *ghlInfo, const int index);
+qboolean	(*G2API_StopBoneAnimIndex)(CGhoul2Info *ghlInfo, const int index);
+qboolean	(*G2API_SetBoneAnglesMatrixIndex)(CGhoul2Info *ghlInfo, const int index, const mdxaBone_t &matrix,
+								   const int flags, qhandle_t *modelList, int blendTime, int currentTime);
+qboolean	(*G2API_SetAnimIndex)(CGhoul2Info *ghlInfo, const int index);
+int			(*G2API_GetAnimIndex)(CGhoul2Info *ghlInfo);
+void		(*G2API_SaveGhoul2Models)(CGhoul2Info_v &ghoul2);
+void		(*G2API_LoadGhoul2Models)(CGhoul2Info_v &ghoul2, char *buffer);
+void		(*G2API_LoadSaveCodeDestructGhoul2Info)(CGhoul2Info_v &ghoul2);
+char		*(*G2API_GetAnimFileNameIndex)(qhandle_t modelIndex);
+char		*(*G2API_GetAnimFileInternalNameIndex)(qhandle_t modelIndex);
+int			(*G2API_GetSurfaceRenderStatus)(CGhoul2Info *ghlInfo, const char *surfaceName);
+
+//rww - RAGDOLL_BEGIN
+void		(*G2API_SetRagDoll)(CGhoul2Info_v &ghoul2,CRagDollParams *parms);
+void		(*G2API_AnimateG2Models)(CGhoul2Info_v &ghoul2, int AcurrentTime,CRagDollUpdateParams *params);
+
+qboolean	(*G2API_RagPCJConstraint)(CGhoul2Info_v &ghoul2, const char *boneName, vec3_t min, vec3_t max);
+qboolean	(*G2API_RagPCJGradientSpeed)(CGhoul2Info_v &ghoul2, const char *boneName, const float speed);
+qboolean	(*G2API_RagEffectorGoal)(CGhoul2Info_v &ghoul2, const char *boneName, vec3_t pos);
+qboolean	(*G2API_GetRagBonePos)(CGhoul2Info_v &ghoul2, const char *boneName, vec3_t pos, vec3_t entAngles, vec3_t entPos, vec3_t entScale);
+qboolean	(*G2API_RagEffectorKick)(CGhoul2Info_v &ghoul2, const char *boneName, vec3_t velocity);
+qboolean	(*G2API_RagForceSolve)(CGhoul2Info_v &ghoul2, qboolean force);
+
+qboolean	(*G2API_SetBoneIKState)(CGhoul2Info_v &ghoul2, int time, const char *boneName, int ikState, sharedSetBoneIKStateParams_t *params);
+qboolean	(*G2API_IKMove) (CGhoul2Info_v &ghoul2, int time, sharedIKMoveParams_t *params);
+//rww - RAGDOLL_END
+
+void		(*G2API_AddSkinGore)(CGhoul2Info_v &ghoul2,SSkinGoreData &gore);
+void		(*G2API_ClearSkinGore)( CGhoul2Info_v &ghoul2 );
+
+void		(*RMG_Init)(int terrainID);
+#ifndef _XBOX
+int			(*CM_RegisterTerrain)(const char *info);
+#endif
+const char	*(*SetActiveSubBSP)(int index);
+
+
+int			(*RE_RegisterSkin)(const char *name);
+int			(*RE_GetAnimationCFG)(const char *psCFGFilename, char *psDest, int iDestSize);
+
+bool		(*WE_GetWindVector)(vec3_t windVector, vec3_t atpoint);
+bool		(*WE_GetWindGusting)(vec3_t atpoint);
+bool		(*WE_IsOutside)(vec3_t pos);
+float		(*WE_IsOutsideCausingPain)(vec3_t pos);
+float		(*WE_GetChanceOfSaberFizz)(void);
+bool		(*WE_IsShaking)(vec3_t pos);
+void		(*WE_AddWeatherZone)(vec3_t mins, vec3_t maxs);
+bool		(*WE_SetTempGlobalFogColor)(vec3_t color);
+
+
+/*
+Ghoul2 Insert End
+*/
+
+
+} game_import_t;
+
+//
+// functions exported by the game subsystem
+//
+typedef struct {
+	int			apiversion;
+
+	// init and shutdown will be called every single level
+	// levelTime will be near zero, while globalTime will be a large number
+	// that can be used to track spectator entry times across restarts
+	void		(*Init)( const char *mapname, const char *spawntarget, int checkSum, const char *entstring, int levelTime, int randomSeed, int globalTime, SavedGameJustLoaded_e eSavedGameJustLoaded, qboolean qbLoadTransition );
+	void		(*Shutdown) (void);
+
+	// ReadLevel is called after the default map information has been
+	// loaded with SpawnEntities
+	void		(*WriteLevel) (qboolean qbAutosave);
+	void		(*ReadLevel)  (qboolean qbAutosave, qboolean qbLoadTransition);
+	qboolean	(*GameAllowedToSaveHere)(void);
+
+	// return NULL if the client is allowed to connect, otherwise return
+	// a text string with the reason for denial
+	char		*(*ClientConnect)( int clientNum, qboolean firstTime, SavedGameJustLoaded_e eSavedGameJustLoaded );
+
+	void		(*ClientBegin)( int clientNum, usercmd_t *cmd, SavedGameJustLoaded_e eSavedGameJustLoaded);
+	void		(*ClientUserinfoChanged)( int clientNum );
+	void		(*ClientDisconnect)( int clientNum );
+	void		(*ClientCommand)( int clientNum );
+	void		(*ClientThink)( int clientNum, usercmd_t *cmd );
+
+	void		(*RunFrame)( int levelTime );
+	void		(*ConnectNavs)( const char *mapname, int checkSum );
+
+	// ConsoleCommand will be called when a command has been issued
+	// that is not recognized as a builtin function.
+	// The game can issue gi.argc() / gi.argv() commands to get the command
+	// and parameters.  Return qfalse if the game doesn't recognize it as a command.
+	qboolean	(*ConsoleCommand)( void );
+
+	//void		(*PrintEntClassname)( int clientNum );
+	//int			(*ValidateAnimRange)( int startFrame, int endFrame, float animSpeed );
+
+	void		(*GameSpawnRMGEntity)(char *s);
+	//
+	// global variables shared between game and server
+	//
+
+	// The gentities array is allocated in the game dll so it
+	// can vary in size from one game to another.
+	// 
+	// The size will be fixed when ge->Init() is called
+	// the server can't just use pointer arithmetic on gentities, because the
+	// server's sizeof(struct gentity_s) doesn't equal gentitySize
+	struct gentity_s	*gentities;
+	int			gentitySize;
+	int			num_entities;		// current number, <= MAX_GENTITIES
+} game_export_t;
+
+game_export_t *GetGameApi (game_import_t *import);
+
+#endif//#ifndef __G_PUBLIC_H__
diff --git a/code/game/g_rail.cpp b/code/game/g_rail.cpp
new file mode 100644
index 0000000..ed8db5c
--- /dev/null
+++ b/code/game/g_rail.cpp
@@ -0,0 +1,975 @@
+////////////////////////////////////////////////////////////////////////////////////////
+// RAVEN SOFTWARE - STAR WARS: JK II
+//  (c) 2002 Activision
+//
+// Rail System
+//
+// The rail system is intended to provide a means for generating moving entities along
+// tracks of varying speed and direction.  The entities are pulled from the map based
+// upon their targets and recycled in random positions and order
+//
+////////////////////////////////////////////////////////////////////////////////////////
+#include "g_headers.h"
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Externs & Fwd Decl.
+////////////////////////////////////////////////////////////////////////////////////////
+//extern cvar_t*		g_nav1;
+extern void		G_SoundAtSpot( vec3_t org, int soundIndex, qboolean broadcast );
+
+class	CRailTrack;
+class	CRailLane;
+class	CRailMover;
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Includes
+////////////////////////////////////////////////////////////////////////////////////////
+#include "b_local.h"
+#if !defined(RATL_ARRAY_VS_INC)
+	#include "..\Ratl\array_vs.h"
+#endif
+#if !defined(RATL_VECTOR_VS_INC)
+	#include "..\Ratl\vector_vs.h"
+#endif
+#if !defined(RAVL_VEC_INC)
+	#include "..\Ravl\CVec.h"
+#endif
+#if !defined(RUFL_HSTRING_INC)
+	#include "..\Rufl\hstring.h"
+#endif
+#if !defined(RATL_GRID_VS_INC)
+	#include "..\Ratl\grid_vs.h"
+#endif
+#if !defined(RATL_POOL_VS_INC)
+	#include "..\Ratl\pool_vs.h"
+#endif
+
+#ifdef _XBOX
+using dllNamespace::hstring;
+#endif
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Constants
+////////////////////////////////////////////////////////////////////////////////////////
+#define		MAX_TRACKS			4
+#define		MAX_LANES			8
+#define		MAX_MOVERS			150
+#define		MAX_MOVER_ENTS		10
+#define		MAX_MOVERS_TRACK	80
+#define		MAX_COLS			32
+#define		MAX_ROWS			96
+#define		MAX_ROW_HISTORY		10
+
+#define		WOOSH_DEBUG			0
+#define		WOOSH_ALL_RANGE		1500.0f
+#define		WOOSH_SUPPORT_RANGE	2500.0f
+#define		WOOSH_TUNNEL_RANGE	3000.0f
+
+
+bool		mRailSystemActive = false;
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// The Rail Track
+//
+// Tracks are the central component to the rails system.  They provide the master
+// repositry of all movers and maintain the list of available movers as well as
+//
+////////////////////////////////////////////////////////////////////////////////////////
+class	CRailTrack
+{
+public:
+	void	Setup(gentity_t *ent)
+	{
+		mName						= ent->targetname;
+		mSpeedGridCellsPerSecond	= ent->speed;
+		mNumMoversPerRow			= ent->count;
+		mMins						= ent->mins;
+		mMaxs						= ent->maxs;
+		mStartTime					= ent->delay + level.time;
+		mGridCellSize				= (ent->radius!=0.0f)?(ent->radius):(1.0f);
+		mVertical					= (ent->s.angles[1]==90.0f || ent->s.angles[1]==270.0f);	
+		mNegative					= (ent->s.angles[1]==180.0f || ent->s.angles[1]==270.0f);	// From Maxs To Mins
+		mWAxis						= (mVertical)?(0):(1);
+		mHAxis						= (mVertical)?(1):(0);
+		mTravelDistanceUnits		= ent->maxs[mHAxis] - ent->mins[mHAxis];
+
+		mRow						= 0;
+		mNextUpdateTime				= 0;
+	
+		mCenterLocked				= false;
+
+		SnapVectorToGrid(mMins);
+		SnapVectorToGrid(mMaxs);
+
+		// Calculate Number Of Rows And Columns
+		//--------------------------------------
+		mRows						= ((mMaxs[mHAxis] - mMins[mHAxis]) / mGridCellSize);
+		mCols						= ((mMaxs[mWAxis] - mMins[mWAxis]) / mGridCellSize);
+
+		// Calculate Grid Center
+		//-----------------------
+		mGridCenter = ((mMins+mMaxs)*0.5f);
+		SnapVectorToGrid(mGridCenter);
+
+		// Calculate Speed & Velocity
+		//----------------------------
+		mSpeedUnitsPerMillisecond	= mSpeedGridCellsPerSecond * mGridCellSize / 1000.0f;
+		mTravelTimeMilliseconds		= mTravelDistanceUnits / mSpeedUnitsPerMillisecond;
+
+		AngleVectors(ent->s.angles, mDirection.v, 0, 0);
+		mDirection.SafeNorm();
+		mVelocity					= mDirection;
+		mVelocity					*= (mSpeedGridCellsPerSecond * mGridCellSize);
+
+		mNextUpdateDelay			= 1000.0f / (float)(mSpeedGridCellsPerSecond);
+
+
+		// Calculate Bottom Left Corner
+		//------------------------------
+		mGridBottomLeftCorner = ent->mins;
+		if (ent->s.angles[1]==180.0f)
+		{
+			mGridBottomLeftCorner[0] = mMaxs[0];
+		}
+		else if (ent->s.angles[1]==270.0f)
+		{
+			mGridBottomLeftCorner[1] = mMaxs[1];
+		}
+		SnapVectorToGrid(mGridBottomLeftCorner);
+
+
+		mCells.set_size(mCols/*xSize*/, mRows/*ySize*/);
+		mCells.init(0);
+
+		mMovers.clear();
+
+
+		if (!mNumMoversPerRow)
+		{
+			mNumMoversPerRow = 3;
+		}
+
+		// Safe Clamp Number Of Rows & Cols
+		//----------------------------------
+		if (mRows>(MAX_ROWS-1))
+		{
+			mRows = (MAX_ROWS-1);
+			assert(0);
+		}
+		if (mCols>(MAX_COLS-1))
+		{
+			mCols = (MAX_COLS-1);
+			assert(0);
+		}
+	}
+
+	void	SnapVectorToGrid(CVec3&	Vec)
+	{
+		SnapFloatToGrid(Vec[0]);
+		SnapFloatToGrid(Vec[1]);
+	}
+
+	void	SnapFloatToGrid(float& f)
+	{
+		f = (int)(f);
+
+		bool	fNeg		= (f<0);
+		if (fNeg)
+		{
+			f *= -1;		// Temporarly make it positive
+		}
+
+		int		Offset		= ((int)(f) % (int)(mGridCellSize));
+		int		OffsetAbs	= abs(Offset);
+		if (OffsetAbs>(mGridCellSize/2))
+		{
+			Offset = (mGridCellSize - OffsetAbs) * -1;
+		}
+
+		f -= Offset;
+
+		if (fNeg)
+		{
+			f *= -1;		// Put It Back To Negative
+		}
+
+		f = (int)(f);
+
+		assert(((int)(f)%(int)(mGridCellSize)) == 0);
+	}
+
+
+
+
+
+	void	Update();
+	bool	TestMoverInCells(CRailMover* mover, int atCol);
+	void	InsertMoverInCells(CRailMover* mover, int atCol);
+	void	RandomizeTestCols(int startCol, int stopCol);
+
+
+
+
+
+
+
+public:
+	hstring		mName;
+
+	int			mRow;
+	int			mNumMoversPerRow;
+	
+	int			mNextUpdateTime;
+	int			mNextUpdateDelay;
+	int			mStartTime;
+
+	int			mRows;
+	int			mCols;
+
+	bool		mVertical;
+	bool		mNegative;
+	int			mHAxis;
+	int			mWAxis;
+
+	int			mSpeedGridCellsPerSecond;
+	float		mSpeedUnitsPerMillisecond;
+	int			mTravelTimeMilliseconds;
+	float		mTravelDistanceUnits;
+	CVec3		mDirection;
+	CVec3		mVelocity;
+
+	CVec3		mMins;
+	CVec3		mMaxs;
+
+	CVec3		mGridBottomLeftCorner;
+	CVec3		mGridCenter;
+	float		mGridCellSize;
+
+	bool		mCenterLocked;
+
+	ratl::grid2_vs<CRailMover*, MAX_COLS, MAX_ROWS>	mCells;
+	ratl::vector_vs<CRailMover*, MAX_MOVERS_TRACK>	mMovers;
+	ratl::vector_vs<int, MAX_ROWS>					mTestCols;
+};
+ratl::vector_vs<CRailTrack, MAX_TRACKS>				mRailTracks;
+
+////////////////////////////////////////////////////////////////////////////////////////
+/*QUAKED rail_track (0 .5 .8) ? x x x x x x x x
+A rail track determines what location and direction rail_mover entities go.  Don't bother with any origin brushes.  Make sure to set:
+
+"radius"     Number of units to break down into grid size
+"speed"      Number of grid sized units per second rail_movers will go at
+"angle"      The direction rail_movers will go
+"count"		 The number of mover ents the track will try to add per row
+"delay"		 How long the ent will wait from the start of the level before placing movers
+*/
+////////////////////////////////////////////////////////////////////////////////////////
+void SP_rail_track(gentity_t *ent)
+{
+	gi.SetBrushModel(ent, ent->model);
+	G_SpawnInt("delay", "0", &ent->delay);
+	mRailTracks.push_back().Setup(ent);
+	G_FreeEntity(ent);
+	mRailSystemActive = true;
+}
+
+
+
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// The Rail Lane
+//
+//
+//
+////////////////////////////////////////////////////////////////////////////////////////
+class	CRailLane
+{
+public:
+	////////////////////////////////////////////////////////////////////////////////////
+	// From Entity Setup Spawn
+	////////////////////////////////////////////////////////////////////////////////////
+	void		Setup(gentity_t* ent)
+	{
+		mName		= ent->targetname;
+		mNameTrack	= ent->target;
+		mMins		= ent->mins;
+		mMaxs		= ent->maxs;
+		mStartTime	= ent->delay + level.time;
+	}
+
+	hstring		mName;
+	hstring		mNameTrack;
+	CVec3		mMins;
+	CVec3		mMaxs;
+	int			mStartTime;
+
+public:
+	////////////////////////////////////////////////////////////////////////////////////
+	// Initialize
+	//
+	// This function scans through the list of tracks and hooks itself up with the
+	// track
+	////////////////////////////////////////////////////////////////////////////////////
+	void		Initialize()
+	{
+		mTrack		= 0;
+		mMinCol		= 0;
+		mMaxCol		= 0;
+
+//		int		dummy;
+		for (int i=0; i<mRailTracks.size(); i++)
+		{
+			if (mRailTracks[i].mName==mNameTrack)
+			{
+				mTrack	= &(mRailTracks[i]);
+				mTrack->SnapVectorToGrid(mMins);
+				mTrack->SnapVectorToGrid(mMaxs);
+
+				mMinCol = (int)((mMins[mTrack->mWAxis] - mTrack->mMins[mTrack->mWAxis])/mTrack->mGridCellSize);
+				mMaxCol = (int)((mMaxs[mTrack->mWAxis] - mTrack->mMins[mTrack->mWAxis] - (mTrack->mGridCellSize/2.0f))/mTrack->mGridCellSize);
+
+				//if (mTrack->mNegative)
+				//{
+				//	mMinCol = (mTrack->mCols - mMinCol - 1);
+				//	mMaxCol = (mTrack->mCols - mMaxCol - 1);
+				//}
+
+
+//				mTrack->mCells.get_cell_coords(mMins[mTrack->mWAxis], 0, mMinCol, dummy);
+//				mTrack->mCells.get_cell_coords((mMaxs[mTrack->mWAxis]-10.0f), 0, mMaxCol, dummy);
+				break;
+			}
+		}
+		assert(mTrack!=0);
+	}
+
+	CRailTrack*	mTrack;
+	int			mMinCol;
+	int			mMaxCol;
+};
+ratl::vector_vs<CRailLane, MAX_LANES>		mRailLanes;
+
+////////////////////////////////////////////////////////////////////////////////////////
+/*QUAKED rail_lane (0 .5 .8) ? x x x x x x x x
+Use rail lanes to split up tracks.  Just target it to a track that you want to break up into pieces
+
+"delay"		 How long the ent will wait from the start of the level before placing movers
+*/
+////////////////////////////////////////////////////////////////////////////////////////
+void SP_rail_lane(gentity_t *ent)
+{
+ 	gi.SetBrushModel(ent, ent->model);
+	G_SpawnInt("delay", "0", &ent->delay);
+	mRailLanes.push_back().Setup(ent);
+	G_FreeEntity(ent);
+}
+
+
+
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+//
+////////////////////////////////////////////////////////////////////////////////////////
+class	CRailMover
+{
+public:
+	////////////////////////////////////////////////////////////////////////////////////
+	// From Entity Setup Spawn
+	////////////////////////////////////////////////////////////////////////////////////
+	void		Setup(gentity_t* ent)
+	{
+		mEnt					= ent;
+		mCenter					= (ent->spawnflags&1);
+		mSoundPlayed			= false;
+		mOriginOffset			= ent->mins;
+		mOriginOffset			+= ent->maxs;
+		mOriginOffset			*= 0.5f;
+		mOriginOffset[2]		= 0;//((ent->maxs[2] - ent->mins[2]) * 0.5);
+
+		ent->e_ReachedFunc		= reachedF_NULL;
+		ent->moverState			= MOVER_POS1;
+		ent->svFlags			= SVF_USE_CURRENT_ORIGIN;
+		ent->s.eType			= ET_MOVER;
+		ent->s.eFlags			|= EF_NODRAW;
+		ent->contents			= 0;
+		ent->clipmask			= 0;
+
+		ent->s.pos.trType		= TR_STATIONARY;
+		ent->s.pos.trDuration	= 0;
+		ent->s.pos.trTime		= 0;
+
+		VectorCopy( ent->pos1, ent->currentOrigin );
+		VectorCopy( ent->pos1, ent->s.pos.trBase );
+
+
+		gi.linkentity(ent);
+	}
+	gentity_t*	mEnt;
+	bool		mCenter;
+	CVec3		mOriginOffset;
+	bool		mSoundPlayed;
+
+
+	bool		Active()
+	{
+		assert(mEnt!=0);
+		return (level.time<(mEnt->s.pos.trDuration + mEnt->s.pos.trTime));
+	}
+
+
+public:
+	////////////////////////////////////////////////////////////////////////////////////
+	// Initialize
+	//
+	// This function scans through the list of tracks and hooks itself up with the
+	// track (and possibly lane)
+	////////////////////////////////////////////////////////////////////////////////////
+	void		Initialize()
+	{
+		mTrack	= 0;
+		mLane	= 0;
+		mCols	= 0;
+		mRows	= 0;
+
+		hstring	target = mEnt->target;
+		for (int track=0; track<mRailTracks.size(); track++)
+		{
+			if (mRailTracks[track].mName==target)
+			{
+				mTrack = &(mRailTracks[track]);
+				break;
+			}
+		}
+		if (mTrack==0)
+		{
+			for (int lane=0; lane<mRailLanes.size(); lane++)
+			{
+				if (mRailLanes[lane].mName==target)
+				{
+					mLane	= &(mRailLanes[lane]);
+					mTrack	= mLane->mTrack;
+					break;
+				}
+			}
+		}
+		assert(mTrack!=0);
+		if (mTrack)
+		{
+			mTrack->mMovers.push_back(this);
+			mCols	= (int)((mEnt->maxs[mTrack->mWAxis] - mEnt->mins[mTrack->mWAxis]) / mTrack->mGridCellSize) + 1;
+			mRows	= (int)((mEnt->maxs[mTrack->mHAxis] - mEnt->mins[mTrack->mHAxis]) / mTrack->mGridCellSize) + 1;
+
+			// Make Sure The Mover Fits In The Track And Lane
+			//------------------------------------------------
+			if (mRows>mTrack->mRows)
+			{
+//				assert(0);
+				mRows = mTrack->mRows;
+			}
+			if (mCols>mTrack->mCols)
+			{
+//				assert(0);
+				mCols = mTrack->mCols;
+			}
+			if (mLane && mCols>(mLane->mMaxCol - mLane->mMinCol + 1))
+			{
+//				assert(0);
+				mCols = (mLane->mMaxCol - mLane->mMinCol + 1);
+			}
+		}
+	}
+
+	CRailTrack*	mTrack;
+	CRailLane*	mLane;
+	int			mCols;
+	int			mRows;
+};
+ratl::vector_vs<CRailMover, MAX_MOVERS>		mRailMovers;
+
+////////////////////////////////////////////////////////////////////////////////////////
+/*QUAKED rail_mover (0 .5 .8) ? CENTER x x x x x x x
+Rail Mover will go along the track and lane of your choice.  Just target it to either a track or a lane.  Don't bother with any origin brushes.
+
+CENTER       Will force this mover to attempt to center in the track or lane
+
+"target"     The track or lane you want this entity to move through
+"model"      A model you wish to use, not necessary - can be just a brush
+"angle"      Random angle rotation allowable on this thing
+*/
+////////////////////////////////////////////////////////////////////////////////////////
+void SP_rail_mover(gentity_t *ent)
+{
+	gi.SetBrushModel(ent, ent->model);
+	mRailMovers.push_back().Setup(ent);
+}
+
+
+ratl::vector_vs<int, 20>				mWooshSml;	// Small Building
+ratl::vector_vs<int, 20>				mWooshMed;	// Medium Building
+ratl::vector_vs<int, 10>				mWooshLar;	// Large Building
+ratl::vector_vs<int, 10>				mWooshSup;	// Track Support
+ratl::vector_vs<int, 3>					mWooshTun;	// Tunnel
+
+
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+//
+////////////////////////////////////////////////////////////////////////////////////////
+void	Rail_Reset()
+{
+	mRailSystemActive = false;
+	mRailTracks.clear();
+	mRailLanes.clear();
+	mRailMovers.clear();
+
+	mWooshSml.clear();
+	mWooshMed.clear();
+	mWooshLar.clear();
+	mWooshSup.clear();
+	mWooshTun.clear();
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+//
+////////////////////////////////////////////////////////////////////////////////////////
+void	Rail_Initialize()
+{
+	for (int lane=0; lane<mRailLanes.size(); lane++)
+	{
+		mRailLanes[lane].Initialize();
+	}
+
+	for (int mover=0; mover<mRailMovers.size(); mover++)
+	{
+		mRailMovers[mover].Initialize();
+	}
+
+	// Precache All The Woosh Sounds
+	//-------------------------------
+	if (!mRailMovers.empty())
+	{
+		mWooshMed.push_back(G_SoundIndex("sound/effects/woosh1"));
+		mWooshSml.push_back(G_SoundIndex("sound/effects/woosh2"));
+		mWooshMed.push_back(G_SoundIndex("sound/effects/woosh3"));
+		mWooshSml.push_back(G_SoundIndex("sound/effects/woosh4"));
+		mWooshLar.push_back(G_SoundIndex("sound/effects/woosh5"));
+		mWooshSml.push_back(G_SoundIndex("sound/effects/woosh6"));
+		mWooshSup.push_back(G_SoundIndex("sound/effects/woosh7"));
+		mWooshSup.push_back(G_SoundIndex("sound/effects/woosh8"));
+		mWooshSup.push_back(G_SoundIndex("sound/effects/woosh9"));
+		mWooshLar.push_back(G_SoundIndex("sound/effects/woosh10"));
+		mWooshLar.push_back(G_SoundIndex("sound/effects/woosh11"));
+		mWooshLar.push_back(G_SoundIndex("sound/effects/woosh12"));
+		mWooshSml.push_back(G_SoundIndex("sound/effects/woosh13"));
+		mWooshMed.push_back(G_SoundIndex("sound/effects/woosh14"));
+		mWooshMed.push_back(G_SoundIndex("sound/effects/woosh15"));
+		mWooshMed.push_back(G_SoundIndex("sound/effects/woosh16"));
+		mWooshSml.push_back(G_SoundIndex("sound/effects/woosh17"));
+		mWooshMed.push_back(G_SoundIndex("sound/effects/woosh18"));
+		mWooshMed.push_back(G_SoundIndex("sound/effects/woosh19"));
+		mWooshMed.push_back(G_SoundIndex("sound/effects/woosh20"));
+		mWooshMed.push_back(G_SoundIndex("sound/effects/woosh21"));
+		mWooshLar.push_back(G_SoundIndex("sound/effects/woosh22"));
+		mWooshLar.push_back(G_SoundIndex("sound/effects/woosh23"));
+		mWooshSup.push_back(G_SoundIndex("sound/effects/woosh24"));
+		mWooshSup.push_back(G_SoundIndex("sound/effects/woosh25"));
+		mWooshMed.push_back(G_SoundIndex("sound/effects/woosh26"));
+		mWooshMed.push_back(G_SoundIndex("sound/effects/woosh27"));
+		mWooshMed.push_back(G_SoundIndex("sound/effects/woosh28"));
+		mWooshLar.push_back(G_SoundIndex("sound/effects/woosh29"));
+		mWooshTun.push_back(G_SoundIndex("sound/effects/whoosh_tunnel"));
+	}
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+//
+////////////////////////////////////////////////////////////////////////////////////////
+void	Rail_Update()
+{
+	if (mRailSystemActive)// && false)
+	{
+		for (int track=0; track<mRailTracks.size(); track++)
+		{
+			if (level.time>mRailTracks[track].mNextUpdateTime && !mRailTracks[track].mMovers.empty())
+			{
+				mRailTracks[track].Update();
+			}
+		}
+
+		// Is The Player Outside?
+		//------------------------
+ 		if (player && gi.WE_IsOutside(player->currentOrigin))
+		{
+			int		wooshSound;
+			vec3_t	wooshSoundPos;
+			vec3_t	moverOrigin;
+			vec3_t	playerToMover;
+			float	playerToMoverDistance;
+			float	playerToMoverDistanceFraction;
+
+			// Iterate Over All The Movers
+			//-----------------------------
+ 			for (int moverIndex=0; moverIndex<mRailMovers.size(); moverIndex++)
+			{
+ 				CRailMover&	mover = mRailMovers[moverIndex];
+
+				// Is It Active, And Has The Sound Already Played On It?
+				//--------------------------------------------------------
+   			 	if (mover.Active() && !mover.mSoundPlayed)
+				{ 
+ 					VectorAdd(mover.mEnt->currentOrigin, mover.mOriginOffset.v, moverOrigin);
+ 					VectorSubtract(moverOrigin, player->currentOrigin, playerToMover);
+					playerToMover[2]		= 0.0f;
+ 					playerToMoverDistance	= VectorNormalize(playerToMover);
+
+
+					// Is It Close Enough?
+					//---------------------
+					if ((( mover.mLane || !mover.mCenter) &&								// Not Center Track
+						 (playerToMoverDistance<WOOSH_ALL_RANGE) && 						//  And Close Enough
+						 (DotProduct(playerToMover, mover.mTrack->mDirection.v)>-0.45f))	//  And On The Side
+						||																	//OR
+						((!mover.mLane &&  mover.mCenter) &&								// Is Center Track
+						  (playerToMoverDistance<WOOSH_SUPPORT_RANGE ||						//  And Close Enough for Support
+						  (playerToMoverDistance<WOOSH_TUNNEL_RANGE && mover.mRows>10))		//   Or Close Enough For Tunnel
+						 ))
+					{
+						mover.mSoundPlayed = true;
+						wooshSound = 0;
+
+						// The Centered Entities Play Right On The Player's Head For Full Volume
+						//-----------------------------------------------------------------------
+						if (mover.mCenter && !mover.mLane)
+						{
+ 							VectorCopy(player->currentOrigin, wooshSoundPos);
+ 							wooshSoundPos[2] += 50;
+
+							// If It Is Very Long, Play The Tunnel Sound
+							//-------------------------------------------
+							if (mover.mRows>10)
+							{
+								wooshSound = mWooshTun[Q_irand(0, mWooshTun.size()-1)];
+							}
+
+							// Otherwise It Is A Support
+							//---------------------------
+							else 
+							{ 
+								wooshSound = mWooshSup[Q_irand(0, mWooshSup.size()-1)];
+							}
+						}
+
+						// All Other Entities Play At A Fraction Of Their Normal Range
+						//-------------------------------------------------------------
+ 						else 
+						{
+							// Scale The Play Pos By The Square Of The Distance
+							//--------------------------------------------------
+							playerToMoverDistanceFraction = playerToMoverDistance/WOOSH_ALL_RANGE;
+ 							playerToMoverDistanceFraction *= playerToMoverDistanceFraction;
+							playerToMoverDistanceFraction *= 0.6f;
+							playerToMoverDistance *= playerToMoverDistanceFraction;
+ 							VectorMA(player->currentOrigin, playerToMoverDistance, playerToMover, wooshSoundPos);
+
+							// Large Building
+							//----------------
+							if (mover.mRows>4)
+							{
+								wooshSound = mWooshLar[Q_irand(0, mWooshLar.size()-1)];
+							}
+
+							// Medium Building
+							//-----------------
+							else if (mover.mRows>2)
+							{
+								wooshSound = mWooshMed[Q_irand(0, mWooshMed.size()-1)];
+							}
+
+							// Small Building
+							//----------------
+							else 
+							{ 
+								wooshSound = mWooshSml[Q_irand(0, mWooshSml.size()-1)];
+							}
+						}
+
+						// If A Woosh Sound Was Selected, Play It Now
+						//--------------------------------------------
+						if (wooshSound)
+						{
+							G_SoundAtSpot(wooshSoundPos, wooshSound, qfalse);
+							if (WOOSH_DEBUG)
+							{
+								CG_DrawEdge(player->currentOrigin, wooshSoundPos, EDGE_WHITE_TWOSECOND);
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+//
+////////////////////////////////////////////////////////////////////////////////////////
+void	Rail_LockCenterOfTrack(const char* trackName)
+{
+	hstring	name = trackName;
+	for (int track=0; track<mRailTracks.size(); track++)
+	{
+		if (mRailTracks[track].mName==name)
+		{
+			mRailTracks[track].mCenterLocked = true;
+			return;
+		}
+	}
+	assert(0);
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+//
+////////////////////////////////////////////////////////////////////////////////////////
+void	Rail_UnLockCenterOfTrack(const char* trackName)
+{
+	hstring	name = trackName;
+	for (int track=0; track<mRailTracks.size(); track++)
+	{
+		if (mRailTracks[track].mName==name)
+		{
+			mRailTracks[track].mCenterLocked = false;
+			return;
+		}
+	}
+	assert(0);
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+//
+////////////////////////////////////////////////////////////////////////////////////////
+void	CRailTrack::Update()
+{
+	mNextUpdateTime = level.time + mNextUpdateDelay;
+
+
+	// Now, Attempt To Add A Number Of Movers To The Track
+	//-----------------------------------------------------
+	int		attempt;
+	int		startCol;
+	int		stopCol;
+	int		atCol;
+	int		testColIndex;
+
+	for (attempt=0; attempt<mNumMoversPerRow; attempt++)
+	{
+		// Randomly Select A Mover And Test To See If It Is Active
+		//---------------------------------------------------------
+		CRailMover*	mover = mMovers[Q_irand(0, mMovers.size()-1)];
+		if (mover->Active())
+		{
+			continue;
+		}
+
+		// Don't Spawn Until Start Time Has Expired
+		//------------------------------------------
+		if (level.time < ((mover->mLane)?(mover->mLane->mStartTime):(mStartTime)))
+		{
+			continue;
+		}
+
+		// If Center Locked, Stop Spawning Center Track Movers
+		//-----------------------------------------------------
+		if (mover->mCenter && mCenterLocked)
+		{
+			continue;
+		}
+	
+
+		// Restrict It To A Lane
+		//-----------------------
+		if (mover->mLane)
+		{
+			startCol	= mover->mLane->mMinCol;
+			stopCol		= mover->mLane->mMaxCol+1;
+		}
+
+		// Or Let It Go Anywhere On The Track
+		//------------------------------------
+		else
+		{
+			startCol	= 0;
+			stopCol		= mCols;
+		}
+		stopCol -= (mover->mCols-1);
+
+
+		// If The Mover Is Too Big To Fit In The Lane, Go On To Next Attempt
+		//-------------------------------------------------------------------
+		if (stopCol<=startCol)
+		{
+			assert(0);	// Should Not Happen
+			continue;
+		}
+
+		// Force It To Center
+		//--------------------
+		if (mover->mCenter && stopCol!=(startCol+1))
+		{
+			startCol	= ((mCols/2) - (mover->mCols/2));
+			stopCol		= startCol+1;
+		}
+
+
+		// Construct A List Of Columns To Test For Insertion
+		//---------------------------------------------------
+		mTestCols.clear();
+		for (int i=startCol; i<stopCol; i++)
+		{
+			mTestCols.push_back(i);
+		}
+
+		// Now Try All The Cols To See If The Building Can Fit
+		//-----------------------------------------------------
+		while (!mTestCols.empty())
+		{
+			// Randomly Pick A Column, Then Remove It From The Vector
+			//--------------------------------------------------------
+			testColIndex = Q_irand(0, mTestCols.size()-1);
+			atCol = mTestCols[testColIndex];
+			mTestCols.erase_swap(testColIndex);
+
+			if (TestMoverInCells(mover, atCol))
+			{
+				// Ok, We've Found A Safe Column To Insert This Mover
+				//----------------------------------------------------
+				InsertMoverInCells(mover, atCol);
+
+				// Now Transport The Actual Mover Entity Into Position, Link It & Send It Off
+				//----------------------------------------------------------------------------
+				CVec3	StartPos(mGridBottomLeftCorner);
+				StartPos[mWAxis] += ((atCol * mGridCellSize) + ((mover->mCols/2.0f) * mGridCellSize));
+				StartPos[mHAxis] += (((mover->mRows/2.0f) * mGridCellSize) * ((mNegative)?(1):(-1)));
+				StartPos[2] = 0;
+
+				// If Centered, Actually Put It At EXACTLY The Right Position On The Width Axis
+				//------------------------------------------------------------------------------
+				if (mover->mCenter)
+				{
+					StartPos[mWAxis] = mGridCenter[mWAxis];
+					float	deltaOffset = mGridCenter[mWAxis] - mover->mOriginOffset[mWAxis];
+					if (deltaOffset<(mGridCellSize*0.5f) )
+					{
+						StartPos[mWAxis] -= deltaOffset;
+					}
+				}
+
+				StartPos -= mover->mOriginOffset;
+				G_SetOrigin(mover->mEnt, StartPos.v);
+
+				// Start It Moving
+				//-----------------
+				VectorCopy(StartPos.v, mover->mEnt->s.pos.trBase);
+				VectorCopy(mVelocity.v, mover->mEnt->s.pos.trDelta);
+				mover->mEnt->s.pos.trTime		= level.time;
+				mover->mEnt->s.pos.trDuration	= mTravelTimeMilliseconds + (mNextUpdateDelay*mover->mRows);
+				mover->mEnt->s.pos.trType		= TR_LINEAR_STOP;
+				mover->mEnt->s.eFlags			&= ~EF_NODRAW;
+
+				mover->mSoundPlayed				= false;
+
+
+				// Successfully Inserted This Mover.  Now Move On To The Next Mover
+				//------------------------------------------------------------------
+				break;
+			}
+		}
+	}
+
+	// Incriment The Current Row
+	//---------------------------
+	mRow++;
+	if (mRow>=mRows)
+	{
+		mRow = 0;
+	}
+
+	// Erase The Erase Row
+	//---------------------
+	int	EraseRow = mRow - MAX_ROW_HISTORY;
+	if (EraseRow<0)
+	{
+		EraseRow += mRows;
+	}
+	for (int col=0; col<mCols; col++)
+	{
+		mCells.get(col, EraseRow) = 0;
+	}
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+//
+////////////////////////////////////////////////////////////////////////////////////////
+void	CRailTrack::RandomizeTestCols(int startCol, int stopCol)
+{
+	int numCols = (stopCol - startCol);
+	int swapA;
+	int	swapB;
+
+
+
+	for (int swapNum=0; swapNum<numCols; swapNum++)
+	{
+		swapA = Q_irand(0, numCols-1);
+		swapB = Q_irand(0, numCols-1);
+		if (swapA!=swapB)
+		{
+			mTestCols.swap(swapA, swapB);
+		}
+	}
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+//
+////////////////////////////////////////////////////////////////////////////////////////
+bool	CRailTrack::TestMoverInCells(CRailMover* mover, int atCol)
+{
+	//for (int moverRow=0; (moverRow<mover->mRows); moverRow++)
+	//{
+		for (int moverCol=0; (moverCol<mover->mCols); moverCol++)
+		{
+			if (mCells.get(atCol+moverCol, mRow/*+moverRow*/)!=0)
+			{
+				return false;
+			}
+		}
+	//}
+	return true;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+//
+////////////////////////////////////////////////////////////////////////////////////////
+void	CRailTrack::InsertMoverInCells(CRailMover* mover, int atCol)
+{
+	for (int moverCol=0; (moverCol<mover->mCols); moverCol++)
+	{
+		int col = atCol+moverCol;
+		for (int moverRow=0; (moverRow<mover->mRows); moverRow++)
+		{
+			int row = mRow+moverRow;
+			if (row>=mRows)
+			{
+				row -= mRows;
+			}
+			assert(mCells.get(col, row)==0);
+			mCells.get(col, row) = mover;
+		}
+	}
+}
+
diff --git a/code/game/g_ref.cpp b/code/game/g_ref.cpp
new file mode 100644
index 0000000..8487fbd
--- /dev/null
+++ b/code/game/g_ref.cpp
@@ -0,0 +1,402 @@
+// Reference tag utility functions
+// leave this line at the top for all g_xxxx.cpp files...
+#include "g_headers.h"
+
+
+
+#include "g_local.h"
+#include "g_functions.h"
+#include "g_nav.h"
+
+extern int delayedShutDown;
+
+#define	TAG_GENERIC_NAME	"__WORLD__"	//If a designer chooses this name, cut a finger off as an example to the others
+
+typedef vector < reference_tag_t * >		refTag_v;
+typedef map < string, reference_tag_t * >	refTag_m;
+
+typedef struct tagOwner_s
+{
+	refTag_v	tags;
+	refTag_m	tagMap;
+} tagOwner_t;
+
+typedef map < string, tagOwner_t * >	refTagOwner_m;
+
+refTagOwner_m	refTagOwnerMap;
+
+/*
+-------------------------
+TAG_ShowTags
+-------------------------
+*/
+
+void TAG_ShowTags( int flags )
+{
+	refTagOwner_m::iterator	rtoi;
+
+	STL_ITERATE( rtoi, refTagOwnerMap )
+	{
+		refTag_v::iterator	rti;
+		STL_ITERATE( rti, (((*rtoi).second)->tags) )
+		{
+			if ( (*rti)->flags & RTF_NAVGOAL )
+			{
+				if ( gi.inPVS( g_entities[0].currentOrigin, (*rti)->origin ) )
+					CG_DrawNode( (*rti)->origin, NODE_NAVGOAL );
+			}
+		}
+	}
+}
+
+/*
+-------------------------
+TAG_Init
+-------------------------
+*/
+
+void TAG_Init( void )
+{
+	refTagOwner_m::iterator	rtoi;
+
+	//Delete all owners
+	for ( rtoi = refTagOwnerMap.begin(); rtoi != refTagOwnerMap.end(); rtoi++ )
+	{
+		if ( (*rtoi).second == NULL )
+		{
+			assert( 0 );	//FIXME: This is not good
+			continue;
+		}
+
+		refTag_v::iterator		rti;
+		
+		//Delete all tags within the owner's scope
+		for ( rti = ((*rtoi).second)->tags.begin(); rti != ((*rtoi).second)->tags.end(); rti++ )
+		{
+			if ( (*rti) == NULL )
+			{
+				assert( 0 );	//FIXME: Bad bad
+				continue;
+			}
+
+			//Free it
+			delete (*rti);
+		}
+
+		//Clear the containers
+		((*rtoi).second)->tags.clear();
+		((*rtoi).second)->tagMap.clear();
+
+		//Delete the owner
+		delete ((*rtoi).second);
+	}
+
+	//Clear the container
+	refTagOwnerMap.clear();
+}
+
+/*
+-------------------------
+TAG_FindOwner
+-------------------------
+*/
+
+tagOwner_t	*TAG_FindOwner( const char *owner )
+{
+	refTagOwner_m::iterator	rtoi;
+
+	rtoi = refTagOwnerMap.find( owner );
+
+	if ( rtoi == refTagOwnerMap.end() )
+		return NULL;
+
+	return (*rtoi).second;
+}
+
+/*
+-------------------------
+TAG_Find
+-------------------------
+*/
+
+reference_tag_t	*TAG_Find( const char *owner, const char *name )
+{
+	tagOwner_t	*tagOwner;
+
+	tagOwner = VALIDSTRING( owner ) ? TAG_FindOwner( owner ) : TAG_FindOwner( TAG_GENERIC_NAME );
+
+	//Not found...
+	if ( tagOwner == NULL )
+	{
+		tagOwner = TAG_FindOwner( TAG_GENERIC_NAME );
+
+		if ( tagOwner == NULL )
+			return NULL;
+	}
+
+	refTag_m::iterator	rti;
+
+	rti = tagOwner->tagMap.find( name );
+
+	if ( rti == tagOwner->tagMap.end() )
+	{
+		//Try the generic owner instead
+		tagOwner = TAG_FindOwner( TAG_GENERIC_NAME );
+
+		if ( tagOwner == NULL )
+			return NULL;
+
+		char	tempName[ MAX_REFNAME ];
+
+		Q_strncpyz( (char *) tempName, name, MAX_REFNAME );
+		strlwr( (char *) tempName );	//NOTENOTE: For case insensitive searches on a map
+
+		rti = tagOwner->tagMap.find( tempName );
+		
+		if ( rti == tagOwner->tagMap.end() )
+			return NULL;
+	}
+
+	return (*rti).second;
+}
+
+/*
+-------------------------
+TAG_Add
+-------------------------
+*/
+
+reference_tag_t	*TAG_Add( const char *name, const char *owner, vec3_t origin, vec3_t angles, int radius, int flags )
+{
+	reference_tag_t	*tag = new reference_tag_t;
+	VALIDATEP( tag );
+	
+	//Copy the information
+	VectorCopy( origin, tag->origin );
+	VectorCopy( angles, tag->angles );
+	tag->radius = radius;
+	tag->flags	= flags;
+
+	if ( VALIDSTRING( name ) == false )
+	{
+		//gi.Error("Nameless ref_tag found at (%i %i %i)", (int)origin[0], (int)origin[1], (int)origin[2]);
+		gi.Printf(S_COLOR_RED"ERROR: Nameless ref_tag found at (%i %i %i)\n", (int)origin[0], (int)origin[1], (int)origin[2]);
+		delayedShutDown = level.time + 100;
+		return NULL;
+	}
+
+	//Copy the name
+	Q_strncpyz( (char *) tag->name, name, MAX_REFNAME );
+	strlwr( (char *) tag->name );	//NOTENOTE: For case insensitive searches on a map
+
+	//Make sure this tag's name isn't alread in use
+	if ( TAG_Find( owner, name ) )
+	{
+		delayedShutDown = level.time + 100;
+		gi.Printf(S_COLOR_RED"ERROR: Duplicate tag name \"%s\"\n", name );
+		return NULL;
+	}
+
+	//Attempt to add this to the owner's list
+	if ( VALIDSTRING( owner ) == false )
+	{
+		//If the owner isn't found, use the generic world name
+		owner = TAG_GENERIC_NAME;
+	}
+
+	tagOwner_t	*tagOwner = TAG_FindOwner( owner );
+	
+	//If the owner is valid, add this tag to it
+	if VALID( tagOwner )
+	{
+		tagOwner->tags.insert( tagOwner->tags.end(), tag );
+		tagOwner->tagMap[ (char*) &tag->name ] = tag;
+	}
+	else
+	{
+		//Create a new owner list
+		tagOwner_t	*tagOwner = new	tagOwner_t;
+
+		VALIDATEP( tagOwner );
+
+		//Insert the information
+		tagOwner->tags.insert( tagOwner->tags.end(), tag );
+		tagOwner->tagMap[ (char *) tag->name ] = tag;
+
+		//Map it
+		refTagOwnerMap[ owner ] = tagOwner;
+	}
+
+	return tag;
+}
+
+/*
+-------------------------
+TAG_GetOrigin
+-------------------------
+*/
+
+int	TAG_GetOrigin( const char *owner, const char *name, vec3_t origin )
+{
+	reference_tag_t	*tag = TAG_Find( owner, name );
+
+	if (!tag)
+	{
+		VectorClear(origin);
+		return false;
+	}
+
+	VALIDATEB( tag );
+
+	VectorCopy( tag->origin, origin );
+
+	return true;
+}
+
+/*
+-------------------------
+TAG_GetOrigin2
+Had to get rid of that damn assert for dev
+-------------------------
+*/
+
+int	TAG_GetOrigin2( const char *owner, const char *name, vec3_t origin )
+{
+	reference_tag_t	*tag = TAG_Find( owner, name );
+
+	if( tag == NULL )
+	{
+		return qfalse;
+	}
+
+	VectorCopy( tag->origin, origin );
+
+	return qtrue;
+}
+/*
+-------------------------
+TAG_GetAngles
+-------------------------
+*/
+
+int	TAG_GetAngles( const char *owner, const char *name, vec3_t angles )
+{
+	reference_tag_t	*tag = TAG_Find( owner, name );
+
+	VALIDATEB( tag );
+
+	VectorCopy( tag->angles, angles );
+	
+	return true;
+}
+
+/*
+-------------------------
+TAG_GetRadius
+-------------------------
+*/
+
+int TAG_GetRadius( const char *owner, const char *name )
+{
+	reference_tag_t	*tag = TAG_Find( owner, name );
+
+	VALIDATEB( tag );
+
+	return tag->radius;
+}
+
+/*
+-------------------------
+TAG_GetFlags
+-------------------------
+*/
+
+int TAG_GetFlags( const char *owner, const char *name )
+{
+	reference_tag_t	*tag = TAG_Find( owner, name );
+
+	VALIDATEB( tag );
+
+	return tag->flags;
+}
+
+/*
+==============================================================================
+
+Spawn functions
+
+==============================================================================
+*/
+
+/*QUAKED ref_tag (0.5 0.5 1) (-8 -8 -8) (8 8 8)
+
+Reference tags which can be positioned throughout the level.
+These tags can later be refered to by the scripting system
+so that their origins and angles can be referred to.
+
+If you set angles on the tag, these will be retained.
+
+If you target a ref_tag at an entity, that will set the ref_tag's
+angles toward that entity.
+
+If you set the ref_tag's ownername to the ownername of an entity,
+it makes that entity is the owner of the ref_tag.  This means 
+that the owner, and only the owner, may refer to that tag.
+
+Tags may not have the same name as another tag with the same
+owner.  However, tags with different owners may have the same
+name as one another.  In this way, scripts can generically 
+refer to tags by name, and their owners will automatically
+specifiy which tag is being referred to.
+
+targetname	- the name of this tag
+ownername	- the owner of this tag
+target		- use to point the tag at something for angles
+*/
+
+void ref_link ( gentity_t *ent )
+{
+	reference_tag_t	*tag;
+
+	if ( ent->target )
+	{
+		//TODO: Find the target and set our angles to that direction
+		gentity_t	*target = G_Find( NULL, FOFS(targetname), ent->target );
+		vec3_t	dir;
+
+		if ( target )
+		{
+			//Find the direction to the target
+			VectorSubtract( target->s.origin, ent->s.origin, dir );
+			VectorNormalize( dir );
+			vectoangles( dir, ent->s.angles );
+			
+			//FIXME: Does pitch get flipped?
+		}
+		else
+		{
+			gi.Printf( S_COLOR_RED"ERROR: ref_tag (%s) has invalid target (%s)", ent->targetname, ent->target );
+		}
+	}
+	
+	//Add the tag
+	tag = TAG_Add( ent->targetname, ent->ownername, ent->s.origin, ent->s.angles, 16, 0 );
+
+	//Delete immediately, cannot be refered to as an entity again
+	//NOTE: this means if you wanted to link them in a chain for, say, a path, you can't
+	G_FreeEntity( ent );
+}
+
+void SP_reference_tag ( gentity_t *ent )
+{
+	if ( ent->target )
+	{
+		//Init cannot occur until all entities have been spawned
+		ent->e_ThinkFunc = thinkF_ref_link;
+		ent->nextthink = level.time + START_TIME_LINK_ENTS;
+	}
+	else
+	{
+		ref_link( ent );
+	}
+}
\ No newline at end of file
diff --git a/code/game/g_roff.cpp b/code/game/g_roff.cpp
new file mode 100644
index 0000000..c04f531
--- /dev/null
+++ b/code/game/g_roff.cpp
@@ -0,0 +1,646 @@
+// leave this line at the top for all g_xxxx.cpp files...
+#include "g_headers.h"
+
+
+#include "g_local.h"
+#include "g_roff.h"
+#include "Q3_Interface.h"
+// The list of precached ROFFs
+roff_list_t	roffs[MAX_ROFFS];
+int			num_roffs = 0;
+
+qboolean g_bCollidableRoffs = qfalse;
+
+extern void	Q3_TaskIDComplete( gentity_t *ent, taskID_t taskType );
+
+static void G_RoffNotetrackCallback( gentity_t *cent, const char *notetrack)
+{
+	int i = 0, r = 0, r2 = 0, objectID = 0, anglesGathered = 0, posoffsetGathered = 0;
+	char type[256];
+	char argument[512];
+	char addlArg[512];
+	char errMsg[256];
+	char t[64];
+	char teststr[256];
+	int addlArgs = 0;
+	vec3_t parsedAngles, parsedOffset, useAngles, useOrigin, forward, right, up;
+
+	if (!cent || !notetrack)
+	{
+		return;
+	}
+
+	//notetrack = "effect effects/explosion1.efx 0+0+64 0-0-1";
+
+	while (notetrack[i] && notetrack[i] != ' ')
+	{
+		type[i] = notetrack[i];
+		i++;
+	}
+
+	type[i] = '\0';
+
+	if (notetrack[i] != ' ')
+	{ //didn't pass in a valid notetrack type, or forgot the argument for it
+		return;
+	}
+
+	i++;
+
+	while (notetrack[i] && notetrack[i] != ' ')
+	{
+		if (notetrack[i] != '\n' && notetrack[i] != '\r')
+		{ //don't read line ends for an argument
+			argument[r] = notetrack[i];
+			r++;
+		}
+		i++;
+	}
+	argument[r] = '\0';
+
+	if (!r)
+	{
+		return;
+	}
+
+	if (notetrack[i] == ' ')
+	{ //additional arguments...
+		addlArgs = 1;
+
+		i++;
+		r = 0;
+		while (notetrack[i])
+		{
+			addlArg[r] = notetrack[i];
+			r++;
+			i++;
+		}
+		addlArg[r] = '\0';
+	}
+
+	if (strcmp(type, "effect") == 0)
+	{
+		if (!addlArgs)
+		{
+			VectorClear(parsedOffset);
+			goto defaultoffsetposition;
+		}
+
+		i = 0;
+
+		while (posoffsetGathered < 3)
+		{
+			r = 0;
+			while (addlArg[i] && addlArg[i] != '+' && addlArg[i] != ' ')
+			{
+				t[r] = addlArg[i];
+				r++;
+				i++;
+			}
+			t[r] = '\0';
+			i++;
+			if (!r)
+			{ //failure..
+				VectorClear(parsedOffset);
+				i = 0;
+				goto defaultoffsetposition;
+			}
+			parsedOffset[posoffsetGathered] = atof(t);
+			posoffsetGathered++;
+		}
+
+		if (posoffsetGathered < 3)
+		{
+			sprintf(errMsg, "Offset position argument for 'effect' type is invalid.");
+			goto functionend;
+		}
+
+		i--;
+
+		if (addlArg[i] != ' ')
+		{
+			addlArgs = 0;
+		}
+
+defaultoffsetposition:
+
+		r = 0;
+		if (argument[r] == '/')
+		{
+			r++;
+		}
+		while (argument[r] && argument[r] != '/')
+		{
+			teststr[r2] = argument[r];
+			r2++;
+			r++;
+		}
+		teststr[r2] = '\0';
+
+		if (r2 && strstr(teststr, "effects"))
+		{ //get rid of the leading "effects" since it's auto-inserted
+			r++;
+			r2 = 0;
+
+			while (argument[r])
+			{
+				teststr[r2] = argument[r];
+				r2++;
+				r++;
+			}
+			teststr[r2] = '\0';
+
+			strcpy(argument, teststr);
+		}
+
+		objectID = G_EffectIndex(argument);
+		r = 0;
+
+		if (objectID)
+		{
+			if (addlArgs)
+			{ //if there is an additional argument for an effect it is expected to be XANGLE-YANGLE-ZANGLE
+				i++;
+				while (anglesGathered < 3)
+				{
+					r = 0;
+					while (addlArg[i] && addlArg[i] != '-')
+					{
+						t[r] = addlArg[i];
+						r++;
+						i++;
+					}
+					t[r] = '\0';
+					i++;
+
+					if (!r)
+					{ //failed to get a new part of the vector
+						anglesGathered = 0;
+						break;
+					}
+
+					parsedAngles[anglesGathered] = atof(t);
+					anglesGathered++;
+				}
+
+				if (anglesGathered)
+				{
+					VectorCopy(parsedAngles, useAngles);
+				}
+				else
+				{ //failed to parse angles from the extra argument provided..
+					VectorCopy(cent->s.apos.trBase, useAngles);
+				}
+			}
+			else
+			{ //if no constant angles, play in direction entity is facing
+				VectorCopy(cent->s.apos.trBase, useAngles);
+			}
+
+			AngleVectors(useAngles, forward, right, up);
+
+			VectorCopy(cent->s.pos.trBase, useOrigin);
+
+			//forward
+			useOrigin[0] += forward[0]*parsedOffset[0];
+			useOrigin[1] += forward[1]*parsedOffset[0];
+			useOrigin[2] += forward[2]*parsedOffset[0];
+
+			//right
+			useOrigin[0] += right[0]*parsedOffset[1];
+			useOrigin[1] += right[1]*parsedOffset[1];
+			useOrigin[2] += right[2]*parsedOffset[1];
+
+			//up
+			useOrigin[0] += up[0]*parsedOffset[2];
+			useOrigin[1] += up[1]*parsedOffset[2];
+			useOrigin[2] += up[2]*parsedOffset[2];
+
+			G_PlayEffect(objectID, useOrigin, useAngles);
+		}
+	}
+	else if (strcmp(type, "sound") == 0)
+	{
+		objectID = G_SoundIndex(argument);
+		cgi_S_StartSound(cent->s.pos.trBase, cent->s.number, CHAN_BODY, objectID);
+	}
+	//else if ...
+	else
+	{
+		if (type[0])
+		{
+			Com_Printf("Warning: \"%s\" is an invalid ROFF notetrack function\n", type);
+		}
+		else
+		{
+			Com_Printf("Warning: Notetrack is missing function and/or arguments\n");
+		}
+	}
+
+	return;
+
+functionend:
+	Com_Printf("Type-specific notetrack error: %s\n", errMsg);
+	return;
+}
+
+static qboolean G_ValidRoff( roff_hdr2_t *header )
+{
+	if ( !strncmp( header->mHeader, "ROFF", 4 ))
+	{
+		if ( header->mCount > 0 && header->mVersion == ROFF_VERSION2 )
+		{
+			return qtrue;
+		}
+		else if ( header->mVersion == ROFF_VERSION && ((roff_hdr_t*)header)->mCount > 0.0f )
+		{ // version 1 defines the count as a float, so we best do the count check as a float or we'll get bogus results
+			return qtrue;
+		}
+	}
+
+	return qfalse;
+}
+
+static void G_FreeRoff(int index)
+{
+	if(roffs[index].mNumNoteTracks) {
+		delete [] roffs[index].mNoteTrackIndexes[0];
+		delete [] roffs[index].mNoteTrackIndexes;
+	}
+}
+
+static qboolean G_InitRoff( char *file, unsigned char *data )
+{
+	roff_hdr_t *header = (roff_hdr_t *)data;
+	int	count = (int)header->mCount;
+
+	roffs[num_roffs].fileName = G_NewString( file );
+
+	if ( header->mVersion == ROFF_VERSION )
+	{
+		// We are Old School(tm)
+		roffs[num_roffs].type = 1;
+
+		roffs[num_roffs].data = (void *) G_Alloc( count * sizeof( move_rotate_t ) );
+		move_rotate_t *mem	= (move_rotate_t *)roffs[num_roffs].data;
+
+		roffs[num_roffs].mFrameTime = 100; // old school ones have a hard-coded frame time
+		roffs[num_roffs].mLerp = 10;
+		roffs[num_roffs].mNumNoteTracks = 0;
+		roffs[num_roffs].mNoteTrackIndexes = NULL;
+
+		if ( mem )
+		{
+			// The allocation worked, so stash this stuff off so we can reference the data later if needed
+			roffs[num_roffs].frames		= count;
+
+			// Step past the header to get to the goods
+			move_rotate_t *roff_data = ( move_rotate_t *)&header[1];
+
+			// Copy all of the goods into our ROFF cache
+			for ( int i = 0; i < count; i++, roff_data++, mem++ )
+			{
+				// Copy just the delta position and orientation which can be applied to anything at a later point
+				VectorCopy( roff_data->origin_delta, mem->origin_delta );
+				VectorCopy( roff_data->rotate_delta, mem->rotate_delta );
+			}
+			return qtrue;
+		}
+	}
+	else if ( header->mVersion == ROFF_VERSION2 )
+	{
+		// Version 2.0, heck yeah!
+		roff_hdr2_t *hdr = (roff_hdr2_t *)data;
+		count = hdr->mCount;
+
+		roffs[num_roffs].frames	= count;
+		roffs[num_roffs].data	= (void *) G_Alloc( count * sizeof( move_rotate2_t ));		
+		move_rotate2_t *mem		= (move_rotate2_t *)roffs[num_roffs].data;
+
+		if ( mem )
+		{
+			roffs[num_roffs].mFrameTime			= hdr->mFrameRate;
+			roffs[num_roffs].mLerp				= 1000 / hdr->mFrameRate;
+			roffs[num_roffs].mNumNoteTracks		= hdr->mNumNotes;
+
+			if (roffs[num_roffs].mFrameTime < 50)
+			{
+				Com_Printf(S_COLOR_RED"Error: \"%s\" has an invalid ROFF framerate (%d < 50)\n", file, roffs[num_roffs].mFrameTime);
+			}
+			assert( roffs[num_roffs].mFrameTime >= 50 );//HAS to be at least 50 to be reliable
+
+			 // Step past the header to get to the goods
+			move_rotate2_t *roff_data = ( move_rotate2_t *)&hdr[1];
+
+			roffs[num_roffs].type = 2; //rww - any reason this wasn't being set already?
+
+			// Copy all of the goods into our ROFF cache
+			for ( int i = 0; i < count; i++ )
+			{
+				VectorCopy( roff_data[i].origin_delta, mem[i].origin_delta );
+				VectorCopy( roff_data[i].rotate_delta, mem[i].rotate_delta );
+
+				mem[i].mStartNote = roff_data[i].mStartNote;
+				mem[i].mNumNotes = roff_data[i].mNumNotes;
+			}
+
+			if ( hdr->mNumNotes )
+			{
+				int		size;
+				char	*ptr, *start;
+
+				ptr = start = (char *)&roff_data[i];
+				size = 0;
+
+				for( i = 0; i < hdr->mNumNotes; i++ )
+				{
+					size += strlen(ptr) + 1;
+					ptr += strlen(ptr) + 1;
+				}
+
+				// ? Get rid of dynamic memory ?
+				roffs[num_roffs].mNoteTrackIndexes = new char *[hdr->mNumNotes];
+				ptr = roffs[num_roffs].mNoteTrackIndexes[0] = new char[size];
+				memcpy(roffs[num_roffs].mNoteTrackIndexes[0], start, size);
+
+				for( i = 1; i < hdr->mNumNotes; i++ )
+				{
+					ptr += strlen(ptr) + 1;
+					roffs[num_roffs].mNoteTrackIndexes[i] = ptr;
+				}
+			}
+			return qtrue;
+		}
+	}
+
+	return false;
+}
+
+//-------------------------------------------------------
+// G_LoadRoff
+//
+// Does the fun work of loading and caching a roff file
+//	If the file is already cached, it just returns an
+//	ID to the cached file.
+//-------------------------------------------------------
+
+int G_LoadRoff( const char *fileName )
+{
+	char	file[MAX_QPATH];
+	byte	*data;
+	int		len, i, roff_id = 0;
+
+	// Before even bothering with all of this, make sure we have a place to store it.
+	if ( num_roffs >= MAX_ROFFS )
+	{
+		Com_Printf( S_COLOR_RED"MAX_ROFFS count exceeded.  Skipping load of .ROF '%s'\n", fileName );
+		return roff_id;
+	}
+
+	// The actual path
+	sprintf( file, "%s/%s.rof", Q3_SCRIPT_DIR, fileName );
+
+	// See if I'm already precached
+	for ( i = 0; i < num_roffs; i++ )
+	{
+		if ( stricmp( file, roffs[i].fileName ) == 0 )
+		{
+			// Good, just return me...avoid zero index
+			return i + 1;
+		}
+	}
+
+#ifdef _DEBUG
+//	Com_Printf( S_COLOR_GREEN"Caching ROF: '%s'\n", file );
+#endif
+
+	// Read the file in one fell swoop
+	len = gi.FS_ReadFile( file, (void**) &data);
+
+	if ( len <= 0 )
+	{
+		Com_Printf( S_COLOR_RED"Could not open .ROF file '%s'\n", fileName );
+		return roff_id;
+	}
+
+	// Now let's check the header info...
+	roff_hdr2_t *header = (roff_hdr2_t *)data;
+
+	// ..and make sure it's reasonably valid
+	if ( !G_ValidRoff( header ))
+	{
+		Com_Printf( S_COLOR_RED"Invalid roff format '%s'\n", fileName );
+	}
+	else
+	{
+		G_InitRoff( file, data );
+
+		// Done loading this roff, so save off an id to it..increment first to avoid zero index
+		roff_id = ++num_roffs;
+	}
+
+	gi.FS_FreeFile( data );
+
+	return roff_id;
+}
+
+
+void G_FreeRoffs(void)
+{
+	while(num_roffs) {
+		G_FreeRoff(num_roffs - 1);
+		num_roffs--;
+	}
+}
+
+
+//-------------------------------------------------------
+// G_Roff
+//
+// Handles applying the roff data to the specified ent
+//-------------------------------------------------------
+
+void G_Roff( gentity_t *ent )
+{
+	if ( !ent->next_roff_time )
+	{
+		return;
+	}
+	
+	if ( ent->next_roff_time > level.time )
+	{// either I don't think or it's just not time to have me think yet
+		return;
+	}
+
+	const int roff_id = G_LoadRoff( ent->roff );
+
+	if ( !roff_id )
+	{	// Couldn't cache this rof
+		return;
+	}
+
+	// The ID is one higher than the array index
+	const roff_list_t *  roff	= &roffs[ roff_id - 1 ];
+	vec3_t	org, ang;
+
+	if ( roff->type == 2 )
+	{
+		move_rotate2_t	*data	= &((move_rotate2_t *)roff->data)[ ent->roff_ctr ];
+		VectorCopy( data->origin_delta, org );
+		VectorCopy( data->rotate_delta, ang );
+		if (data->mStartNote != -1 || data->mNumNotes)
+		{
+			G_RoffNotetrackCallback(ent, roffs[roff_id - 1].mNoteTrackIndexes[data->mStartNote]);
+		}
+	}
+	else
+	{
+		move_rotate_t	*data	= &((move_rotate_t *)roff->data)[ ent->roff_ctr ];
+		VectorCopy( data->origin_delta, org );
+		VectorCopy( data->rotate_delta, ang );
+	}
+
+#ifdef _DEBUG
+	if ( g_developer->integer )
+	{
+		Com_Printf( S_COLOR_GREEN"ROFF dat: num: %d o:<%.2f %.2f %.2f> a:<%.2f %.2f %.2f>\n", 
+					ent->roff_ctr,
+					org[0], org[1], org[2],
+					ang[0], ang[1], ang[2] );
+	}
+#endif
+
+	if ( ent->client )
+	{
+		// Set up the angle interpolation
+		//-------------------------------------
+		VectorAdd( ent->s.apos.trBase, ang, ent->s.apos.trBase );
+		ent->s.apos.trTime = level.time;
+		ent->s.apos.trType = TR_INTERPOLATE;
+
+		// Store what the next apos->trBase should be
+		VectorCopy( ent->s.apos.trBase, ent->client->ps.viewangles );
+		VectorCopy( ent->s.apos.trBase, ent->currentAngles );
+		VectorCopy( ent->s.apos.trBase, ent->s.angles );
+		if ( ent->NPC )
+		{
+			//ent->NPC->desiredPitch = ent->s.apos.trBase[PITCH];
+			ent->NPC->desiredYaw = ent->s.apos.trBase[YAW];
+		}
+
+		// Set up the origin interpolation
+		//-------------------------------------
+		VectorAdd( ent->s.pos.trBase, org, ent->s.pos.trBase );
+		ent->s.pos.trTime = level.time;
+		ent->s.pos.trType = TR_INTERPOLATE;
+
+		// Store what the next pos->trBase should be
+		VectorCopy( ent->s.pos.trBase, ent->client->ps.origin );
+		VectorCopy( ent->s.pos.trBase, ent->currentOrigin );
+		//VectorCopy( ent->s.pos.trBase, ent->s.origin );
+	}
+	else
+	{
+		// Set up the angle interpolation
+		//-------------------------------------
+		VectorScale( ang, roff->mLerp, ent->s.apos.trDelta );
+		VectorCopy( ent->pos2, ent->s.apos.trBase );
+		ent->s.apos.trTime = level.time;
+		ent->s.apos.trType = TR_LINEAR;
+
+		// Store what the next apos->trBase should be
+		VectorAdd( ent->pos2, ang, ent->pos2 );
+
+		// Set up the origin interpolation
+		//-------------------------------------
+		VectorScale( org, roff->mLerp, ent->s.pos.trDelta );
+		VectorCopy( ent->pos1, ent->s.pos.trBase );
+		ent->s.pos.trTime = level.time;
+		ent->s.pos.trType = TR_LINEAR;
+
+		// Store what the next apos->trBase should be
+		VectorAdd( ent->pos1, org, ent->pos1 );
+
+		//make it true linear... FIXME: sticks around after ROFF is done, but do we really care?
+		ent->alt_fire = qtrue;
+
+		if ( ent->e_ThinkFunc == thinkF_TieFighterThink || ent->e_ThinkFunc == thinkF_TieBomberThink ||
+			( !ent->e_ThinkFunc
+			&& ent->s.eType != ET_MISSILE
+			&& ent->s.eType != ET_ITEM
+			&& ent->s.eType != ET_MOVER ) )
+		{//will never set currentAngles & currentOrigin itself ( why do we limit which one's get set?, just set all the time? )
+			EvaluateTrajectory( &ent->s.apos, level.time, ent->currentAngles );
+			EvaluateTrajectory( &ent->s.pos, level.time, ent->currentOrigin );
+		}
+	}
+
+	// Link just in case.
+	gi.linkentity( ent );
+
+	// See if the ROFF playback is done
+	//-------------------------------------
+	if ( ++ent->roff_ctr >= roff->frames )
+	{
+		// We are done, so let me think no more, then tell the task that we're done.
+		ent->next_roff_time = 0;
+
+		// Stop any rotation or movement.
+		VectorClear( ent->s.pos.trDelta );
+		VectorClear( ent->s.apos.trDelta );
+
+		Q3_TaskIDComplete( ent, TID_MOVE_NAV );
+
+		return;
+	}
+
+	ent->next_roff_time = level.time + roff->mFrameTime;
+}
+
+
+//-------------------------------------------------------
+// G_SaveCachedRoffs
+//
+// Really fun savegame stuff
+//-------------------------------------------------------
+
+void G_SaveCachedRoffs()
+{
+	int i, len;
+
+	// Write out the number of cached ROFFs
+	gi.AppendToSaveGame( 'ROFF', (void *)&num_roffs, sizeof(num_roffs) );
+
+	// Now dump out the cached ROFF file names in order so they can be loaded on the other end
+	for ( i = 0; i < num_roffs; i++ )
+	{
+		// Dump out the string length to make things a bit easier on the other end...heh heh.
+		len = strlen( roffs[i].fileName ) + 1;
+		gi.AppendToSaveGame( 'SLEN', (void *)&len, sizeof(len) );
+		gi.AppendToSaveGame( 'RSTR', (void *)(*roffs[i].fileName), len );
+	}
+}
+
+
+//-------------------------------------------------------
+// G_LoadCachedRoffs
+//
+// Really fun loadgame stuff
+//-------------------------------------------------------
+
+void G_LoadCachedRoffs()
+{
+	int		i, count, len;
+	char	buffer[MAX_QPATH];
+
+	// Get the count of goodies we need to revive
+	gi.ReadFromSaveGame( 'ROFF', (void *)&count, sizeof(count) );
+
+	// Now bring 'em back to life
+	for ( i = 0; i < count; i++ )
+	{
+		gi.ReadFromSaveGame( 'SLEN', (void *)&len, sizeof(len) );
+		gi.ReadFromSaveGame( 'RSTR', (void *)(buffer), len );
+		G_LoadRoff( buffer );
+	}
+}
diff --git a/code/game/g_roff.h b/code/game/g_roff.h
new file mode 100644
index 0000000..5d471c6
--- /dev/null
+++ b/code/game/g_roff.h
@@ -0,0 +1,88 @@
+#ifndef __G_ROFF_H__
+#define __G_ROFF_H__
+
+
+#include "q_shared.h"
+
+
+// ROFF Defines
+//-------------------
+#define ROFF_VERSION		1	// ver # for the (R)otation (O)bject (F)ile (F)ormat
+#define ROFF_VERSION2		2	// ver # for the (R)otation (O)bject (F)ile (F)ormat
+#define MAX_ROFFS			32	// hard coded number of max roffs per level, sigh..
+#define ROFF_SAMPLE_RATE	20	// 10hz
+
+
+// ROFF Header file definition
+//-------------------------------
+typedef struct roff_hdr_s
+{
+	char	mHeader[4];		// should be "ROFF" (Rotation, Origin File Format)
+	long	mVersion;	
+	float	mCount;			// There isn't any reason for this to be anything other than an int, sigh...
+		//						
+		//		Move - Rotate data follows....vec3_t delta_origin, vec3_t delta_rotation
+		//
+} roff_hdr_t;
+
+
+// ROFF move rotate data element
+//--------------------------------
+typedef struct move_rotate_s
+{
+	vec3_t	origin_delta;
+	vec3_t	rotate_delta;
+
+} move_rotate_t;
+
+typedef struct roff_hdr2_s
+//-------------------------------
+{
+	char	mHeader[4];				// should match roff_string defined above
+	long	mVersion;				// version num, supported version defined above
+	int		mCount;					// I think this is a float because of a limitation of the roff exporter
+	int		mFrameRate;				// Frame rate the roff should be played at
+	int		mNumNotes;				// number of notes (null terminated strings) after the roff data
+
+} roff_hdr2_t;
+
+
+typedef struct move_rotate2_s
+//-------------------------------
+{
+	vec3_t	origin_delta;
+	vec3_t	rotate_delta;
+	int		mStartNote, mNumNotes;		// note track info
+
+} move_rotate2_t;
+
+
+// a precached ROFF list
+//-------------------------
+typedef struct roff_list_s
+{
+	int		type;			// roff type number, 1-old, 2-new
+	char	*fileName;		// roff filename
+	int		frames;			// number of roff entries
+	void	*data;			// delta move and rotate vector list
+	int		mFrameTime;		// frame rate
+	int		mLerp;			// Lerp rate (FPS)
+	int		mNumNoteTracks;
+	char	**mNoteTrackIndexes;
+
+} roff_list_t;
+
+
+
+extern roff_list_t roffs[];
+extern int num_roffs;
+
+
+// Function prototypes
+//-------------------------
+int		G_LoadRoff( const char *fileName );
+void	G_Roff( gentity_t *ent );
+void	G_SaveCachedRoffs();
+void	G_LoadCachedRoffs();
+
+#endif`
\ No newline at end of file
diff --git a/code/game/g_savegame.cpp b/code/game/g_savegame.cpp
new file mode 100644
index 0000000..0a6e53e
--- /dev/null
+++ b/code/game/g_savegame.cpp
@@ -0,0 +1,1272 @@
+// Filename:-	g_savegame.cpp
+//
+// leave this line at the top for all g_xxxx.cpp files...
+#include "g_headers.h"
+
+
+#include "IcarusInterface.h"
+#include "Q3_Interface.h"
+#include "g_local.h"
+#include "fields.h"
+#include "objectives.h"
+#include "../cgame/cg_camera.h"
+#include "../qcommon/sstring.h"
+
+extern void OBJ_LoadTacticalInfo(void);
+
+extern void G_LoadSave_WriteMiscData(void);
+extern void G_LoadSave_ReadMiscData(void);
+extern void G_ReloadSaberData( gentity_t *ent );
+extern void FX_Read( void );
+extern void FX_Write( void );
+
+
+static const save_field_t savefields_gEntity[] =
+{
+	{strFOFS(client),			F_GCLIENT},
+	{strFOFS(owner),			F_GENTITY},
+	{strFOFS(classname),		F_STRING},
+	{strFOFS(model),			F_STRING},
+	{strFOFS(model2),			F_STRING},
+//	{strFOFS(model3),			F_STRING}, - MCG
+	{strFOFS(nextTrain),		F_GENTITY},
+	{strFOFS(prevTrain),		F_GENTITY},
+	{strFOFS(message),			F_STRING},
+	{strFOFS(target),			F_STRING},
+	{strFOFS(target2),			F_STRING},
+	{strFOFS(target3),			F_STRING},
+	{strFOFS(target4),			F_STRING},
+	{strFOFS(targetJump),		F_STRING},
+	{strFOFS(targetname),		F_STRING},
+	{strFOFS(team),				F_STRING},
+	{strFOFS(roff),				F_STRING},
+//	{strFOFS(target_ent),		F_GENTITY}, - MCG
+	{strFOFS(chain),			F_GENTITY},
+	{strFOFS(enemy),			F_GENTITY},
+	{strFOFS(activator),		F_GENTITY},
+	{strFOFS(teamchain),		F_GENTITY},
+	{strFOFS(teammaster),		F_GENTITY},
+	{strFOFS(item),				F_ITEM},
+	{strFOFS(NPC_type),			F_STRING},
+	{strFOFS(closetarget),		F_STRING},
+	{strFOFS(opentarget),		F_STRING},
+	{strFOFS(paintarget),		F_STRING},
+	{strFOFS(NPC_targetname),	F_STRING},
+	{strFOFS(NPC_target),		F_STRING},
+	{strFOFS(ownername),		F_STRING},
+	{strFOFS(lastEnemy),		F_GENTITY},
+	{strFOFS(behaviorSet),		F_BEHAVIORSET},
+	{strFOFS(script_targetname),F_STRING},
+	{strFOFS(m_iIcarusID),		F_NULL},
+	{strFOFS(NPC),				F_BOOLPTR},	
+	{strFOFS(soundSet),			F_STRING},
+	{strFOFS(cameraGroup),		F_STRING},
+	{strFOFS(parms),			F_BOOLPTR},		
+	{strFOFS(m_pVehicle),		F_BOOLPTR},	
+
+	{NULL, 0, F_IGNORE}
+};
+
+static const save_field_t savefields_gNPC[] =
+{
+//	{strNPCOFS(pendingEnemy),		F_GENTITY},
+	{strNPCOFS(touchedByPlayer),	F_GENTITY},
+	{strNPCOFS(aimingBeam),			F_GENTITY},
+	{strNPCOFS(eventOwner),			F_GENTITY},
+	{strNPCOFS(coverTarg),			F_GENTITY},
+	{strNPCOFS(tempGoal),			F_GENTITY},
+	{strNPCOFS(goalEntity),			F_GENTITY},
+	{strNPCOFS(lastGoalEntity),		F_GENTITY},
+	{strNPCOFS(eventualGoal),		F_GENTITY},
+	{strNPCOFS(captureGoal),		F_GENTITY},
+	{strNPCOFS(defendEnt),			F_GENTITY},
+	{strNPCOFS(greetEnt),			F_GENTITY},
+	{strNPCOFS(group),				F_GROUP},
+	{strNPCOFS(blockedEntity),		F_GENTITY},
+	{strNPCOFS(blockedTargetEntity),F_GENTITY},
+	{strNPCOFS(jumpTarget),			F_GENTITY},
+	{strNPCOFS(watchTarget),		F_GENTITY},
+	{NULL, 0, F_IGNORE}
+};
+
+static const save_field_t savefields_LevelLocals[] =
+{
+	{strLLOFS(locationHead),	F_GENTITY},	
+	{strLLOFS(alertEvents),		F_ALERTEVENT},
+	{strLLOFS(groups),			F_AIGROUPS},	
+	{strLLOFS(knownAnimFileSets),F_ANIMFILESETS},	
+	{NULL, 0, F_IGNORE}
+};
+
+static const save_field_t savefields_gVHIC[] =
+{
+	{strVHICOFS(m_pPilot),			F_GENTITY},
+	{strVHICOFS(m_pOldPilot),		F_GENTITY},
+	{strVHICOFS(m_pDroidUnit),		F_GENTITY},
+	{strVHICOFS(m_pParentEntity),	F_GENTITY},
+	
+	//m_ppPassengers	//!ptr array?!
+	{strVHICOFS(m_pVehicleInfo),	F_VEHINFO}, //!another ptr! store name field instead and re-hook on load?
+
+	{NULL, 0, F_IGNORE}
+};
+
+static const save_field_t savefields_gClient[] =
+{
+	// sabers are stomped over by specific code elsewhere, it seems, but the first two fields MUST be saved
+	//	or it crashes on reload
+	{strCLOFS(ps.saber[0].name),F_STRING},	
+/*	{strCLOFS(ps.saber[0].model),F_STRING},
+	{strCLOFS(ps.saber[0].skin),F_STRING},
+	{strCLOFS(ps.saber[0].brokenSaber1),F_STRING},
+	{strCLOFS(ps.saber[0].brokenSaber2),F_STRING},
+*/
+	{strCLOFS(ps.saber[1].name),F_STRING},
+/*	{strCLOFS(ps.saber[1].model),F_STRING},
+	{strCLOFS(ps.saber[1].skin),F_STRING},
+	{strCLOFS(ps.saber[1].brokenSaber1),F_STRING},
+	{strCLOFS(ps.saber[1].brokenSaber2),F_STRING},
+*/
+	{strCLOFS(leader),			F_GENTITY},
+	{strCLOFS(clientInfo.customBasicSoundDir),F_STRING},
+	{strCLOFS(clientInfo.customCombatSoundDir),F_STRING},
+	{strCLOFS(clientInfo.customExtraSoundDir),F_STRING},
+	{strCLOFS(clientInfo.customJediSoundDir),F_STRING},
+
+	{NULL, 0, F_IGNORE}
+};
+
+list<sstring_t> *strList = NULL;
+
+
+/////////// char * /////////////
+//
+//
+static int GetStringNum(const char *psString)
+{
+	assert( psString != (char *)0xcdcdcdcd );
+
+	// NULL ptrs I'll write out as a strlen of -1...
+	//
+	if (!psString)
+	{
+		return -1;
+	}
+
+	strList->push_back( psString );
+	return strlen(psString) + 1;	// this gives us the chunk length for the reader later
+}
+
+static char *GetStringPtr(int iStrlen, char *psOriginal/*may be NULL*/)
+{
+	if (iStrlen != -1)
+	{
+		char sString[768];	// arb, inc if nec.
+
+		sString[0]=0;
+
+		assert(iStrlen+1<=sizeof(sString));
+		
+		gi.ReadFromSaveGame('STRG', sString, iStrlen);
+
+#ifndef _XBOX	// TAG_G_ALLOC is always blown away, we can never recycle
+		if (psOriginal && gi.bIsFromZone(psOriginal, TAG_G_ALLOC)) {
+			if (!strcmp(psOriginal,sString))
+			{//it's a legal ptr and they're the same so let's just reuse it instead of free/alloc
+				return psOriginal;
+			}
+			gi.Free(psOriginal);
+		}
+#endif
+
+		return G_NewString(sString);
+	}
+
+	return NULL;
+}
+//
+//
+////////////////////////////////
+
+
+
+
+/////////// gentity_t * ////////
+//
+//
+static int GetGEntityNum(gentity_t* ent)
+{
+	assert( ent != (gentity_t *) 0xcdcdcdcd);
+
+	if (ent == NULL)
+	{
+		return -1;
+	}
+
+	// note that I now validate the return value (to avoid triggering asserts on re-load) because of the
+	//	way that the level_locals_t alertEvents struct contains a count of which ones are valid, so I'm guessing
+	//	that some of them aren't (valid)...
+	//
+	int iReturnIndex = ent - g_entities;
+
+	if (iReturnIndex < 0 || iReturnIndex >= MAX_GENTITIES)
+	{	
+		iReturnIndex = -1;	// will get a NULL ptr on reload
+	}
+	return iReturnIndex;
+}
+
+static gentity_t *GetGEntityPtr(int iEntNum)
+{
+	if (iEntNum == -1)
+	{
+		return NULL;
+	}
+	assert(iEntNum >= 0);
+	assert(iEntNum < MAX_GENTITIES);
+	return (g_entities + iEntNum);
+}
+//
+//
+////////////////////////////////
+
+
+
+static int GetGroupNumber(AIGroupInfo_t *pGroup)
+{
+	assert( pGroup != (AIGroupInfo_t *) 0xcdcdcdcd);
+
+	if (pGroup == NULL)
+	{
+		return -1;
+	}
+
+	int iReturnIndex = pGroup - level.groups;
+	if (iReturnIndex < 0 || iReturnIndex >= (sizeof(level.groups) / sizeof(level.groups[0])) )
+	{	
+		iReturnIndex = -1;	// will get a NULL ptr on reload
+	}
+	return iReturnIndex;
+}
+
+static AIGroupInfo_t *GetGroupPtr(int iGroupNum)
+{
+	if (iGroupNum == -1)
+	{
+		return NULL;
+	}
+	assert(iGroupNum >= 0);
+	assert(iGroupNum < (sizeof(level.groups) / sizeof(level.groups[0])));
+	return (level.groups + iGroupNum);
+}
+
+
+
+/////////// gclient_t * ////////
+//
+//
+static int GetGClientNum(gclient_t *c, gentity_t *ent)
+{
+	// unfortunately, I now need to see if this is a 'real' client (and therefore resolve to an enum), or
+	//	whether it's one of the NPC or SP_misc_weapon_shooter
+	//
+	assert(c != (gclient_t *)0xcdcdcdcd);
+
+	if (c == NULL)
+	{
+		return -1;
+	}
+	
+	if (ent->s.number < MAX_CLIENTS)
+	{	// regular client...
+		return (c - level.clients);	
+	}
+	else
+	{	// this must be an NPC or weapon_shooter, so mark it as special...
+		return -2;	// yeuch, but distinguishes it from a valid 0 index, or -1 for client==NULL
+	}
+}
+
+static gclient_t *GetGClientPtr(int c)
+{
+	if (c == -1)
+	{
+		return NULL;
+	}
+	if (c == -2)
+	{
+		return (gclient_t *) -2;	// preserve this value so that I know to load in one of Mike's private NPC clients later
+	}
+
+	assert(c >= 0);
+	assert(c < level.maxclients);
+	return (level.clients + c);
+}
+//
+//
+////////////////////////////////
+
+
+/////////// gitem_t * //////////
+//
+//
+static int GetGItemNum (gitem_t *pItem)
+{
+	assert(pItem != (gitem_t*) 0xcdcdcdcd);
+	
+	if (pItem == NULL)
+	{
+		return -1;
+	}
+	
+	return pItem - bg_itemlist;
+}
+
+static gitem_t *GetGItemPtr(int iItem)
+{
+	if (iItem == -1)
+	{
+		return NULL;
+	}
+
+	assert(iItem >= 0);
+	assert(iItem < bg_numItems);
+	return &bg_itemlist[iItem];
+}
+//
+//
+////////////////////////////////
+
+
+/////////// vehicleInfo_t * //////////
+//
+//
+static int GetVehicleInfoNum(vehicleInfo_t *pVehicleInfo)
+{
+	assert(pVehicleInfo != (vehicleInfo_t*) 0xcdcdcdcd);
+	
+	if (pVehicleInfo == NULL)
+	{
+		return -1;
+	}
+	
+	return pVehicleInfo - g_vehicleInfo;
+}
+
+static vehicleInfo_t *GetVehicleInfoPtr(int iVehicleIndex)
+{
+	if (iVehicleIndex == -1)
+	{
+		return NULL;
+	}
+
+	assert(iVehicleIndex > 0);
+	assert(iVehicleIndex < numVehicles);
+	return &g_vehicleInfo[iVehicleIndex];
+}
+//
+//
+////////////////////////////////
+
+
+static void EnumerateField(const save_field_t *pField, const byte *pbBase)
+{
+	void *pv = (void *)(pbBase + pField->iOffset);
+
+	switch (pField->eFieldType)
+	{
+	case F_STRING:
+		*(int *)pv = GetStringNum(*(char **)pv);
+		break;
+
+	case F_GENTITY:
+		*(int *)pv = GetGEntityNum(*(gentity_t **)pv);
+		break;
+
+	case F_GROUP:
+		*(int *)pv = GetGroupNumber(*(AIGroupInfo_t **)pv);
+		break;
+
+	case F_GCLIENT:
+		*(int *)pv = GetGClientNum(*(gclient_t **)pv, (gentity_t *) pbBase);
+		break;
+
+	case F_ITEM:
+		*(int *)pv = GetGItemNum(*(gitem_t **)pv);
+		break;
+
+	case F_VEHINFO:
+		*(int *)pv = GetVehicleInfoNum(*(vehicleInfo_t **)pv);
+		break;
+
+	case F_BEHAVIORSET:
+		{
+			const char **p = (const char **) pv;
+			for (int i=0; i<NUM_BSETS; i++)
+			{
+				pv = &p[i];	// since you can't ++ a void ptr
+				*(int *)pv = GetStringNum(*(char **)pv);
+			}
+		}
+		break;
+
+/*MCG
+	case F_BODYQUEUE:
+		{
+			gentity_t **p = (gentity_t **) pv;
+			for (int i=0; i<BODY_QUEUE_SIZE; i++)
+			{
+				pv = &p[i];	// since you can't ++ a void ptr
+				*(int *)pv = GetGEntityNum(*(gentity_t **)pv);
+			}
+		}
+		break;
+*/
+
+	case F_ALERTEVENT:	// convert all gentity_t ptrs in an alertEvent array into indexes...
+		{
+			alertEvent_t* p = (alertEvent_t *) pv;
+
+			for (int i=0; i<MAX_ALERT_EVENTS; i++)
+			{
+				p[i].owner = (gentity_t *) GetGEntityNum(p[i].owner);
+			}
+		}
+		break;
+
+	case F_AIGROUPS:	// convert to ptrs within this into indexes...
+		{
+			AIGroupInfo_t* p = (AIGroupInfo_t *) pv;
+
+			for (int i=0; i<MAX_FRAME_GROUPS; i++)
+			{
+				p[i].enemy		= (gentity_t *) GetGEntityNum(p[i].enemy);
+				p[i].commander	= (gentity_t *) GetGEntityNum(p[i].commander);
+			}
+		}
+		break;
+
+	case F_ANIMFILESETS:
+		{
+			animFileSet_t* p = (animFileSet_t *) pv;
+
+			for (int i=0; i<MAX_ANIM_FILES; i++)
+			{
+				for ( int j=0; j<MAX_ANIM_EVENTS; j++ )
+				{
+					const char *ptAnimEventStringData = p[i].torsoAnimEvents[j].stringData;
+					*(int *)(&p[i].torsoAnimEvents[j].stringData) = GetStringNum( ptAnimEventStringData );
+					const char *plAnimEventStringData = p[i].legsAnimEvents[j].stringData;
+					*(int *)(&p[i].legsAnimEvents[j].stringData) = GetStringNum( plAnimEventStringData );
+				}
+			}
+		}
+		break;
+
+	case F_BOOLPTR:
+		*(qboolean *)pv = !!(*(int *)pv);
+		break;
+
+	// These are pointers that are always recreated
+	case F_NULL:
+		*(void **)pv = NULL;
+		break;
+
+	case F_IGNORE:
+		break;
+
+	default:
+		G_Error ("EnumerateField: unknown field type");
+		break;
+	}
+}
+
+static void EnumerateFields(const save_field_t *pFields, const byte *pbData, unsigned long ulChid, int iLen)
+{
+	strList = new list<sstring_t>;
+
+	// enumerate all the fields...
+	//
+	if (pFields)
+	{
+		for (const save_field_t *pField = pFields; pField->psName; pField++)
+		{
+			assert(pField->iOffset < iLen);
+			EnumerateField(pField, pbData);
+		}
+	}
+	
+	// save out raw data...
+	//
+	gi.AppendToSaveGame(ulChid, pbData, iLen);
+
+	// save out any associated strings..
+	//
+	list<sstring_t>::iterator it = strList->begin();
+	for (unsigned int i=0; i<strList->size(); i++, ++it)
+	{
+		gi.AppendToSaveGame('STRG', (void *)(*it).c_str(), (*it).length() + 1);
+	}
+	
+	delete strList;
+	strList = NULL;
+}
+
+
+static void EvaluateField(const save_field_t *pField, byte *pbBase, byte *pbOriginalRefData/* may be NULL*/)
+{
+	void *pv		 = (void *)(pbBase			  + pField->iOffset);
+	void *pvOriginal = (void *)(pbOriginalRefData + pField->iOffset);
+
+	switch (pField->eFieldType)
+	{
+	case F_STRING:
+		*(char **)pv = GetStringPtr(*(int *)pv, pbOriginalRefData?*(char**)pvOriginal:NULL);
+		break;
+
+	case F_GENTITY:
+		*(gentity_t **)pv = GetGEntityPtr(*(int *)pv);
+		break;
+
+	case F_GROUP:
+		*(AIGroupInfo_t **)pv = GetGroupPtr(*(int *)pv);
+		break;
+
+	case F_GCLIENT:
+		*(gclient_t **)pv = GetGClientPtr(*(int *)pv);
+		break;
+
+	case F_ITEM:
+		*(gitem_t **)pv = GetGItemPtr(*(int *)pv);
+		break;
+
+	case F_VEHINFO:
+		*(vehicleInfo_t **)pv = GetVehicleInfoPtr(*(int *)pv);
+		break;
+
+	case F_BEHAVIORSET:
+		{
+			char **p = (char **) pv;
+			char **pO= (char **) pvOriginal;
+			for (int i=0; i<NUM_BSETS; i++, p++, pO++)
+			{
+				*p = GetStringPtr(*(int *)p, pbOriginalRefData?*(char **)pO:NULL);
+			}
+		}
+		break;
+
+/*MCG
+	case F_BODYQUEUE:
+		{
+			gentity_t **p = (gentity_t **) pv;
+			for (int i=0; i<BODY_QUEUE_SIZE; i++, p++)
+			{
+				*p = GetGEntityPtr(*(int *)p);
+			}
+		}
+		break;
+*/
+
+	case F_ALERTEVENT:
+		{				
+			alertEvent_t* p = (alertEvent_t *) pv;
+
+			for (int i=0; i<MAX_ALERT_EVENTS; i++)
+			{
+				p[i].owner = GetGEntityPtr((int)(p[i].owner));
+			}
+		}
+		break;
+
+	case F_AIGROUPS:	// convert to ptrs within this into indexes...
+		{
+			AIGroupInfo_t* p = (AIGroupInfo_t *) pv;
+
+			for (int i=0; i<MAX_FRAME_GROUPS; i++)
+			{
+				p[i].enemy		= GetGEntityPtr((int)(p[i].enemy));
+				p[i].commander	= GetGEntityPtr((int)(p[i].commander));
+			}
+		}
+		break;
+
+	case F_ANIMFILESETS:
+		{
+			animFileSet_t* p = (animFileSet_t *) pv;
+			char *pO;
+			for (int i=0; i<MAX_ANIM_FILES; i++)
+			{
+				for ( int j=0; j<MAX_ANIM_EVENTS; j++ )
+				{
+					pO = pbOriginalRefData ? level.knownAnimFileSets[i].torsoAnimEvents[j].stringData : NULL;
+					p[i].torsoAnimEvents[j].stringData = GetStringPtr((int)p[i].torsoAnimEvents[j].stringData, pO);
+					pO = pbOriginalRefData ? level.knownAnimFileSets[i].legsAnimEvents[j].stringData : NULL;
+					p[i].legsAnimEvents[j].stringData = GetStringPtr((int)p[i].legsAnimEvents[j].stringData, pO);
+				}
+			}
+		}
+		break;
+//	// These fields are patched in when their relevant owners are loaded
+	case F_BOOLPTR:
+	case F_NULL:
+		break;
+
+	case F_IGNORE:
+		break;
+
+	default:
+		G_Error ("EvaluateField: unknown field type");
+		break;
+	}
+}
+
+
+// copy of function in sv_savegame
+static LPCSTR SG_GetChidText(unsigned long chid)
+{
+	static char	chidtext[5];
+
+	*(unsigned long *)chidtext = BigLong(chid);
+	chidtext[4] = 0;
+
+	return chidtext;
+}
+
+static void EvaluateFields(const save_field_t *pFields, byte *pbData, byte *pbOriginalRefData, unsigned long ulChid, int iSize, qboolean bOkToSizeMisMatch)
+{	
+	int iReadSize = gi.ReadFromSaveGame(ulChid, pbData, bOkToSizeMisMatch?0:iSize);
+
+	if (iReadSize != iSize)
+	{
+		// handle any chunks that are ok to change length (typically this is a last minute hack, 
+		//	so hopefully we won't need it any more... ;-)
+		//
+		switch (ulChid)
+		{
+			// example chunk handler...
+			//				
+			case 'GCLI':
+/*				assert(iSize>iReadSize);
+				memset(&pbData[iReadSize], 0, iSize-iReadSize);	// zero out new objectives that weren't in old-format save file			
+				break;
+*/
+			default:
+				// won't return...
+				//
+				G_Error(va("EvaluateFields(): variable-sized chunk '%s' without handler!",SG_GetChidText(ulChid)));
+				break;
+		}
+	}
+	
+	if (pFields)
+	{
+		for (const save_field_t *pField = pFields; pField->psName; pField++)
+		{
+			EvaluateField(pField, pbData, pbOriginalRefData);
+		}
+	}
+}
+
+/*
+==============
+WriteLevelLocals
+
+All pointer variables (except function pointers) must be handled specially.
+==============
+*/
+static void WriteLevelLocals ()
+{
+	level_locals_t *temp = (level_locals_t *)gi.Malloc(sizeof(level_locals_t), TAG_TEMP_WORKSPACE, qfalse);
+	*temp = level;	// copy out all data into a temp space
+
+	EnumerateFields(savefields_LevelLocals, (byte *)temp, 'LVLC', LLOFS(LEVEL_LOCALS_T_SAVESTOP));	// sizeof(temp));
+	gi.Free(temp);
+}
+
+/*
+==============
+ReadLevelLocals
+
+All pointer variables (except function pointers) must be handled specially.
+==============
+*/
+static void ReadLevelLocals ()
+{
+	// preserve client ptr either side of the load, because clients are already saved/loaded through Read/Writegame...
+	//
+	gclient_t *pClients = level.clients;	// save clients
+
+	level_locals_t *temp = (level_locals_t *)gi.Malloc(sizeof(level_locals_t), TAG_TEMP_WORKSPACE, qfalse);
+	*temp = level;	// struct copy
+	EvaluateFields(savefields_LevelLocals, (byte *)temp, (byte *)&level, 'LVLC', LLOFS(LEVEL_LOCALS_T_SAVESTOP),qfalse);	// sizeof(level_locals_t));
+	level = *temp;					// struct copy
+
+	level.clients = pClients;				// restore clients
+	gi.Free(temp);
+}
+
+static void WriteGEntities(qboolean qbAutosave)
+{
+	int iCount = 0;
+
+	for (int i=0; i<(qbAutosave?1:globals.num_entities); i++)
+	{
+		gentity_t* ent = &g_entities[i];
+
+		if ( ent->inuse ) 
+		{
+			iCount++;
+		}
+	}
+
+	gi.AppendToSaveGame('NMED', &iCount, sizeof(iCount));
+
+	for (i=0; i<(qbAutosave?1:globals.num_entities); i++)
+	{
+		gentity_t* ent = &g_entities[i];
+
+		if ( ent->inuse)
+		{
+			gi.AppendToSaveGame('EDNM', (void *)&i, sizeof(i));
+
+			qboolean qbLinked = ent->linked;
+			gi.unlinkentity( ent );
+			gentity_t tempEnt = *ent;	// make local copy
+			tempEnt.linked = qbLinked;
+
+			if (qbLinked)
+			{
+				gi.linkentity( ent );
+			}
+
+			EnumerateFields(savefields_gEntity, (byte *)&tempEnt, 'GENT', sizeof(tempEnt));			
+
+			// now for any fiddly bits that would be rather awkward to build into the enumerator...
+			//
+			if (tempEnt.NPC)
+			{
+				gNPC_t npc = *ent->NPC;	// NOT *tempEnt.NPC; !! :-)
+
+				EnumerateFields(savefields_gNPC, (byte *)&npc, 'GNPC', sizeof(npc));
+			}
+
+			if (tempEnt.client == (gclient_t *)-2)	// I know, I know...
+			{
+				gclient_t client = *ent->client;	// NOT *tempEnt.client!!
+				EnumerateFields(savefields_gClient, (byte *)&client, 'GCLI', sizeof(client));
+			}
+
+			if (tempEnt.parms)
+			{
+				gi.AppendToSaveGame('PARM', ent->parms, sizeof(*ent->parms));
+			}
+			
+			if (tempEnt.m_pVehicle)
+			{
+				Vehicle_t vehicle = *ent->m_pVehicle;	// NOT *tempEnt.m_pVehicle!!
+				EnumerateFields(savefields_gVHIC, (byte *)&vehicle, 'VHIC', sizeof(vehicle));
+			}
+			
+			// the scary ghoul2 saver stuff...  (fingers crossed)
+			//
+			gi.G2API_SaveGhoul2Models(tempEnt.ghoul2);								
+			tempEnt.ghoul2.kill(); // this handle was shallow copied from an ent. We don't want it destroyed
+		}
+	}
+
+	//Write out all entity timers
+	TIMER_Save();//WriteEntityTimers();
+
+	if (!qbAutosave)
+	{
+		//Save out ICARUS information
+		IIcarusInterface::GetIcarus()->Save();
+
+		// this marker needs to be here, it lets me know if Icarus doesn't load everything back later, 
+		//	which has happened, and doesn't always show up onscreen until certain game situations. 
+		//	This saves time debugging, and makes things easier to track.
+		//
+		static int iBlah = 1234;
+		gi.AppendToSaveGame('ICOK', &iBlah, sizeof(iBlah));
+	}
+	if (!qbAutosave )//really shouldn't need to write these bits at all, just restore them from the ents...
+	{
+		WriteInUseBits();	
+	}
+}
+
+static void ReadGEntities(qboolean qbAutosave)
+{
+	int		iCount;
+	
+	gi.ReadFromSaveGame('NMED', (void *)&iCount, sizeof(iCount));
+
+	int iPreviousEntRead = -1;
+	for (int i=0; i<iCount; i++)
+	{
+		int iEntIndex;
+		gi.ReadFromSaveGame('EDNM', (void *)&iEntIndex, sizeof(iEntIndex));
+
+		if (iEntIndex >= globals.num_entities)
+		{
+			globals.num_entities = iEntIndex + 1;
+		}
+
+		if (iPreviousEntRead != iEntIndex-1)
+		{
+			for (int j=iPreviousEntRead+1; j!=iEntIndex; j++)
+			{
+				if ( g_entities[j].inuse )		// not actually necessary
+				{
+					G_FreeEntity(&g_entities[j]);
+				}
+			}
+		}
+		iPreviousEntRead = iEntIndex;
+
+		// slightly naff syntax here, but makes a few ops clearer later...
+		//
+		gentity_t  entity;
+		gentity_t* pEntOriginal	= &entity;	
+		gentity_t* pEnt			= &g_entities[iEntIndex];
+		*pEntOriginal = *pEnt;	// struct copy, so we can refer to original
+		
+		pEntOriginal->ghoul2.kill();
+		gi.unlinkentity(pEnt);
+		Quake3Game()->FreeEntity( pEnt );
+	
+		//
+		// sneaky:  destroy the ghoul2 object within this struct before binary-loading over the top of it...
+		//
+		gi.G2API_LoadSaveCodeDestructGhoul2Info(pEnt->ghoul2);
+		pEnt->ghoul2.kill();
+		EvaluateFields(savefields_gEntity, (byte *)pEnt, (byte *)pEntOriginal, 'GENT', sizeof(*pEnt),qfalse);
+		pEnt->ghoul2.kill();
+
+		// now for any fiddly bits...
+		//
+		if (pEnt->NPC)	// will be qtrue/qfalse
+		{
+			gNPC_t tempNPC;
+
+			EvaluateFields(savefields_gNPC, (byte *)&tempNPC,(byte *)pEntOriginal->NPC, 'GNPC', sizeof (*pEnt->NPC),qfalse);
+			
+			// so can we pinch the original's one or do we have to alloc a new one?...
+			//
+			if (pEntOriginal->NPC)
+			{
+				// pinch this G_Alloc handle...
+				//
+				pEnt->NPC = pEntOriginal->NPC;
+			}
+			else
+			{
+				// original didn't have one (hmmm...), so make a new one...
+				//
+				//assert(0);	// I want to know about this, though not in release
+				pEnt->NPC = (gNPC_t *) G_Alloc(sizeof(*pEnt->NPC));
+			}
+
+			// copy over the one we've just loaded...
+			//
+			*pEnt->NPC = tempNPC;	// struct copy
+
+			//FIXME: do we need to do these too?
+			/*
+			if ( pEnt->s.number )
+			{//not player
+				G_LoadAnimFileSet( *pEnt, *pEnt->NPC_type );
+				G_SetSkin( *pEnt, *pEnt->NPC_type, NULL );//  it probably wasn't the default skin, do we need this at all?
+			}
+			*/
+		}
+
+		if (pEnt->client == (gclient_t*) -2)	// one of Mike G's NPC clients?
+		{
+			gclient_t tempGClient;			
+
+			EvaluateFields(savefields_gClient, (byte *)&tempGClient, (byte *)pEntOriginal->client, 'GCLI', sizeof(*pEnt->client),qfalse);
+
+			// can we pinch the original's client handle or do we have to alloc a new one?...
+			//
+			if (pEntOriginal->client)
+			{
+				// pinch this G_Alloc handle...
+				//
+				pEnt->client = pEntOriginal->client;
+			}
+			else
+			{
+				// original didn't have one (hmmm...) so make a new one...
+				//				
+				pEnt->client = (gclient_t *) G_Alloc(sizeof(*pEnt->client));
+			}
+
+			// copy over the one we've just loaded....
+			//
+			*pEnt->client = tempGClient;	// struct copy
+
+			if ( pEnt->s.number )
+			{//not player
+				G_ReloadSaberData( pEnt );
+			}
+		}
+
+		// Some Icarus thing... (probably)
+		//
+		if (pEnt->parms)	// will be qtrue/qfalse
+		{
+			parms_t tempParms;
+			
+			gi.ReadFromSaveGame('PARM', &tempParms, sizeof(tempParms));
+
+			// so can we pinch the original's one or do we have to alloc a new one?...
+			//
+			if (pEntOriginal->parms)
+			{
+				// pinch this G_Alloc handle...
+				//
+				pEnt->parms = pEntOriginal->parms;
+			}
+			else
+			{
+				// original didn't have one, so make a new one...
+				//				
+				pEnt->parms = (parms_t *) G_Alloc(sizeof(*pEnt->parms));
+			}
+
+			// copy over the one we've just loaded...
+			//
+			*pEnt->parms = tempParms;	// struct copy
+		}
+
+		if (pEnt->m_pVehicle)	// will be qtrue/qfalse
+		{
+			Vehicle_t tempVehicle;
+			
+			EvaluateFields(savefields_gVHIC, (byte *)&tempVehicle,(byte *)pEntOriginal->m_pVehicle, 'VHIC', sizeof (*pEnt->m_pVehicle),qfalse);
+
+			// so can we pinch the original's one or do we have to alloc a new one?...
+			//
+			if (pEntOriginal->m_pVehicle)
+			{
+				// pinch this G_Alloc handle...
+				//
+				pEnt->m_pVehicle = pEntOriginal->m_pVehicle;
+			}
+			else
+			{
+				// original didn't have one, so make a new one...
+				//				
+				pEnt->m_pVehicle = (Vehicle_t *) gi.Malloc( sizeof(Vehicle_t), TAG_G_ALLOC, qfalse );
+			}
+
+			// copy over the one we've just loaded...
+			//
+			*pEnt->m_pVehicle = tempVehicle;	// struct copy
+		}
+
+		// the scary ghoul2 stuff...  (fingers crossed)
+		//
+		{
+			char *pGhoul2Data = NULL;
+			gi.ReadFromSaveGame('GHL2', 0, 0, (void**)&pGhoul2Data);
+			gi.G2API_LoadGhoul2Models(pEnt->ghoul2, pGhoul2Data);	// if it's going to crash anywhere...   <g>
+			gi.Free(pGhoul2Data);
+		}
+
+//		gi.unlinkentity (pEntOriginal);		
+//		ICARUS_FreeEnt( pEntOriginal );
+//		*pEntOriginal = *pEnt;	// struct copy				
+//		qboolean qbLinked = pEntOriginal->linked;
+//		pEntOriginal->linked = qfalse;
+//		if (qbLinked)
+//		{
+//			gi.linkentity (pEntOriginal);		
+//		}
+
+		// because the sytem stores sfx_t handles directly instead of the set, we have to reget the set's sfx_t...
+		//
+		if (pEnt->s.eType == ET_MOVER && pEnt->s.loopSound>0)
+		{
+			if ( VALIDSTRING( pEnt->soundSet ))
+			{
+				extern int BMS_MID;	// from g_mover
+				pEnt->s.loopSound = CAS_GetBModelSound( pEnt->soundSet, BMS_MID );
+				if (pEnt->s.loopSound == -1)
+				{
+					pEnt->s.loopSound = 0;
+				}
+			}
+		}
+
+		// NPCs and other ents store waypoints that aren't valid after a load
+		pEnt->waypoint = 0;
+
+		qboolean qbLinked = pEnt->linked;
+		pEnt->linked = qfalse;
+		if (qbLinked)
+		{
+			gi.linkentity (pEnt);		
+		}		
+	}
+
+	//Read in all the entity timers
+	TIMER_Load();//ReadEntityTimers();
+
+	if (!qbAutosave)
+	{
+		// now zap any g_ents that were inuse when the level was loaded, but are no longer in use in the saved version
+		//	that we've just loaded...
+		//
+		for (i=iPreviousEntRead+1; i<globals.num_entities; i++)
+		{
+			if ( g_entities[i].inuse )	// not actually necessary
+			{
+				G_FreeEntity(&g_entities[i]);
+			}
+		}	
+
+		//Load ICARUS information
+		Quake3Game()->ClearEntityList();
+
+		IIcarusInterface::GetIcarus()->Load();
+
+		// check that Icarus has loaded everything it saved out by having a marker chunk after it...
+		//
+		static int iBlah = 1234;
+		gi.ReadFromSaveGame('ICOK', &iBlah, sizeof(iBlah));
+	}
+	if (!qbAutosave)
+	{
+		ReadInUseBits();//really shouldn't need to read these bits in at all, just restore them from the ents...
+	}
+}
+
+
+void WriteLevel(qboolean qbAutosave)
+{
+	if (!qbAutosave) //-always save the client
+	{
+		// write out one client - us!
+		//
+		assert(level.maxclients == 1);	// I'll need to know if this changes, otherwise I'll need to change the way ReadGame works
+		gclient_t client = level.clients[0];
+		EnumerateFields(savefields_gClient, (byte *)&client, 'GCLI', sizeof(client));	
+		WriteLevelLocals();	// level_locals_t level	
+	}
+
+	OBJ_SaveObjectiveData();
+	FX_Write();
+
+	/////////////
+	WriteGEntities(qbAutosave);
+	Quake3Game()->VariableSave();
+	G_LoadSave_WriteMiscData();
+
+	extern void CG_WriteTheEvilCGHackStuff(void);
+	CG_WriteTheEvilCGHackStuff();
+
+	// (Do NOT put any write-code below this line)
+	//
+	// put out an end-marker so that the load code can check everything was read in...
+	//
+	static int iDONE = 1234;
+	gi.AppendToSaveGame('DONE', &iDONE, sizeof(iDONE));
+}
+
+void ReadLevel(qboolean qbAutosave, qboolean qbLoadTransition)
+{
+	if ( qbLoadTransition )
+	{
+		// I STRONGLY SUSPECT THAT THIS WILL JUST ERR_DROP BECAUSE OF THE LOAD SWAPPING OF THE CHUNK-ORDER
+		//	BELOW BETWEEN OBJECTIVES AND LEVEL_LOCALS, SO I'M GUESSING THIS IS SOME OLD EF1 JUNK?
+		// IN ANY CASE, LET'S MAKE SURE...   // -ste (no idea who wrote the comment stuff below, did it ever work?)
+		//
+		assert(0);
+		//
+		//loadtransitions do not need to read the objectives and client data from the level they're going to
+		//In a loadtransition, client data is carried over on the server and will be stomped later anyway.
+		//The objective info (in client->sess data), however, is read in from G_ReadSessionData which is called before this func,
+		//we do NOT want to stomp that session data when doing a load transition
+		
+		//However, we should still save this info out because these savegames may need to be
+		//loaded normally later- perhaps if you die and need to respawn, perhaps as some kind
+		//of emergency savegame for resuming, etc.
+
+		//SO: We read it in, but throw it away.
+		
+		//Read & throw away gclient info
+		gclient_t junkClient;
+		EvaluateFields(savefields_gClient, (byte *)&junkClient, (byte *)&level.clients[0], 'GCLI', sizeof(*level.clients), qfalse);
+
+		//Read & throw away objective info
+		objectives_t	junkObj[MAX_MISSION_OBJ];
+		gi.ReadFromSaveGame('OBJT', (void *) &junkObj, 0);
+
+		ReadLevelLocals();	// level_locals_t level	
+	}
+	else
+	{
+		if (!qbAutosave )//always load the client unless it's an autosave
+		{
+			assert(level.maxclients == 1);	// I'll need to know if this changes, otherwise I'll need to change the way things work
+		
+			gclient_t GClient;
+			EvaluateFields(savefields_gClient, (byte *)&GClient, (byte *)&level.clients[0], 'GCLI', sizeof(*level.clients), qfalse);
+			level.clients[0] = GClient;	// struct copy
+			ReadLevelLocals();	// level_locals_t level	
+		}
+		
+		OBJ_LoadObjectiveData();//loads mission objectives AND tactical info
+	}
+
+	FX_Read();
+
+	/////////////
+
+	ReadGEntities(qbAutosave);
+	Quake3Game()->VariableLoad();
+	G_LoadSave_ReadMiscData();
+
+	extern void CG_ReadTheEvilCGHackStuff(void);
+	CG_ReadTheEvilCGHackStuff();
+
+	// (Do NOT put any read-code below this line)
+	//
+	// check that the whole file content was loaded by specifically requesting an end-marker...
+	//
+	static int iDONE = 1234;
+	gi.ReadFromSaveGame('DONE', &iDONE, sizeof(iDONE));
+}
+
+extern int killPlayerTimer;
+qboolean GameAllowedToSaveHere(void)
+{
+	return (!in_camera&&!killPlayerTimer);
+}
+
+//////////////////// eof /////////////////////
+
+#if 0
+// !!!!!!!!!!!!!!!!!! loadsave affecting structure !!!!!!!!!!!!!!!!!!!!!!!
+struct Vehicle_t
+{
+	// The entity who pilots/drives this vehicle.
+	// NOTE: This is redundant (since m_pParentEntity->owner _should_ be the pilot). This makes things clearer though.
+	gentity_t *m_pPilot;
+
+	int m_iPilotTime; //if spawnflag to die without pilot and this < level.time then die.
+	qboolean m_bHasHadPilot; //qtrue once the vehicle gets its first pilot
+
+	// The passengers of this vehicle.
+	gentity_t **m_ppPassengers;
+
+	// The number of passengers currently in this vehicle.
+	int m_iNumPassengers;
+
+	//the droid unit NPC for this vehicle, if any
+	gentity_t *m_pDroidUnit;
+
+	// The entity from which this NPC comes from.
+	gentity_t *m_pParentEntity;
+
+	// If not zero, how long to wait before we can do anything with the vehicle (we're getting on still).
+	// -1 = board from left, -2 = board from right, -3 = jump/quick board.  -4 & -5 = throw off existing pilot
+	int		m_iBoarding;
+
+	// Used to check if we've just started the boarding process
+	bool	m_bWasBoarding;
+
+	// The speed the vehicle maintains while boarding occurs (often zero)
+	vec3_t	m_vBoardingVelocity;
+
+	// Time modifier (must only be used in ProcessMoveCommands() and ProcessOrientCommands() and is updated in Update()).
+	float m_fTimeModifier;
+
+	// Ghoul2 Animation info.
+	// NOTE: Since each vehicle has their own model instance, these bolts must be local to each vehicle as well.
+	int m_iLeftWingBone;
+	int m_iRightWingBone;
+	//int m_iDriverTag;
+	int m_iExhaustTag[MAX_VEHICLE_EXHAUSTS];
+	int m_iMuzzleTag[MAX_VEHICLE_MUZZLES];
+	int m_iDroidUnitTag;
+	int	m_iGunnerViewTag[MAX_VEHICLE_TURRETS];//Where to put the view origin of the gunner (index)
+
+	// This vehicles weapon muzzles.
+	Muzzle m_Muzzles[MAX_VEHICLE_MUZZLES];
+
+	// The user commands structure.
+	usercmd_t m_ucmd;
+
+	// The direction an entity will eject from the vehicle towards.
+	int m_EjectDir;
+
+	// Flags that describe the vehicles behavior.
+	unsigned long m_ulFlags;
+
+	// NOTE: Vehicle Type ID, Orientation, and Armor MUST be transmitted over the net.
+
+	// Current angles of this vehicle.
+	vec3_t		m_vOrientation;
+
+	// How long you have strafed left or right (increments every frame that you strafe to right, decrements every frame you strafe left)
+	int			m_fStrafeTime;	
+
+	// Previous angles of this vehicle.
+	vec3_t		m_vPrevOrientation;
+
+	// When control is lost on a speeder, current angular velocity is stored here and applied until landing
+	float		m_vAngularVelocity;
+
+	vec3_t		m_vFullAngleVelocity;
+
+	// Current armor and shields of your vehicle (explodes if armor to 0).
+	int			m_iArmor;	//hull strength - STAT_HEALTH on NPC
+	int			m_iShields;	//energy shielding - STAT_ARMOR on NPC
+
+	// Timer for all cgame-FX...? ex: exhaust?
+	int			m_iLastFXTime; 
+
+	// When to die.
+	int			m_iDieTime;
+
+	// This pointer is to a valid VehicleInfo (which could be an animal, speeder, fighter, whatever). This
+	// contains the functions actually used to do things to this specific kind of vehicle as well as shared
+	// information (max speed, type, etc...).
+	vehicleInfo_t *m_pVehicleInfo;
+
+	// This trace tells us if we're within landing height.
+	trace_t m_LandTrace;
+
+	//bitflag of surfaces that have broken off
+	int			m_iRemovedSurfaces;
+
+	// the last time this vehicle fired a turbo burst
+	int			m_iTurboTime;
+
+	//how long it should drop like a rock for after freed from SUSPEND
+	int			m_iDropTime;
+
+	int			m_iSoundDebounceTimer;
+
+	//last time we incremented the shields
+	int			lastShieldInc;
+
+	//so we don't hold it down and toggle it back and forth
+	qboolean	linkWeaponToggleHeld;
+
+	//info about our weapons (linked, ammo, etc.)
+	vehWeaponStatus_t	weaponStatus[MAX_VEHICLE_WEAPONS];
+	vehTurretStatus_t	turretStatus[MAX_VEHICLE_TURRETS];
+
+	//the guy who was previously the pilot
+	gentity_t*	m_pOldPilot;
+
+	// don't need these in mp
+	int			m_safeJumpMountTime;
+	float		m_safeJumpMountRightDot;
+};
+
+#endif
\ No newline at end of file
diff --git a/code/game/g_session.cpp b/code/game/g_session.cpp
new file mode 100644
index 0000000..e933259
--- /dev/null
+++ b/code/game/g_session.cpp
@@ -0,0 +1,221 @@
+// leave this line at the top for all g_xxxx.cpp files...
+#include "g_headers.h"
+
+
+#include "g_local.h"
+#include "objectives.h"
+
+
+/*
+=======================================================================
+
+  SESSION DATA
+
+Session data is the only data that stays persistant across level loads
+and tournament restarts.
+=======================================================================
+*/
+
+/*
+================
+G_WriteClientSessionData
+
+Called on game shutdown
+================
+*/
+void G_WriteClientSessionData( gclient_t *client ) {
+	const char	*s;
+	const char	*s2;
+	const char	*var;
+	int		i;
+
+	s = va("%i", client->sess.sessionTeam );
+	var = va( "session%i", client - level.clients );
+	gi.cvar_set( var, s );
+
+	s2 = "";
+	// Throw all status info into a string
+//	for (i=0;i< MAX_OBJECTIVES; i++)
+//	{
+//		s2 = va("%s %i %i",	s2, client->sess.mission_objectives[i].display,	client->sess.mission_objectives[i].status);
+//	}
+
+	// We're saving only one objective
+	s2 = va("%i %i", client->sess.mission_objectives[LIGHTSIDE_OBJ].display,	client->sess.mission_objectives[LIGHTSIDE_OBJ].status);
+
+	var = va( "sessionobj%i", client - level.clients );
+	gi.cvar_set( var, s2 );
+
+	// Throw all mission stats in to a string
+	s2 = va("%i %i %i %i %i %i %i %i %i %i %i %i",
+			client->sess.missionStats.secretsFound,
+			client->sess.missionStats.totalSecrets,
+			client->sess.missionStats.shotsFired,
+			client->sess.missionStats.hits,
+			client->sess.missionStats.enemiesSpawned,
+			client->sess.missionStats.enemiesKilled,
+			client->sess.missionStats.saberThrownCnt,
+			client->sess.missionStats.saberBlocksCnt,
+			client->sess.missionStats.legAttacksCnt,
+			client->sess.missionStats.armAttacksCnt,
+			client->sess.missionStats.torsoAttacksCnt,
+			client->sess.missionStats.otherAttacksCnt
+			);
+
+	var = va( "missionstats%i", client - level.clients );
+	gi.cvar_set( var, s2 );
+
+
+	s2 = "";
+	for (i=0;i< NUM_FORCE_POWERS; i++)
+	{
+		s2 = va("%s %i",s2, client->sess.missionStats.forceUsed[i]);
+	}
+	var = va( "sessionpowers%i", client - level.clients );
+	gi.cvar_set( var, s2 );
+
+
+	s2 = "";
+	for (i=0;i< WP_NUM_WEAPONS; i++)
+	{
+		s2 = va("%s %i",s2, client->sess.missionStats.weaponUsed[i]);
+	}
+	var = va( "sessionweapons%i", client - level.clients );
+	gi.cvar_set( var, s2 );
+
+
+}
+
+/*
+================
+G_ReadSessionData
+
+Called on a reconnect
+================
+*/
+void G_ReadSessionData( gclient_t *client ) {
+	char	s[MAX_STRING_CHARS];
+	const char	*var;
+	int		i;
+
+	var = va( "session%i", client - level.clients );
+	gi.Cvar_VariableStringBuffer( var, s, sizeof(s) );
+
+	sscanf( s, "%i", &client->sess.sessionTeam );
+
+	var = va( "sessionobj%i", client - level.clients );
+	gi.Cvar_VariableStringBuffer( var, s, sizeof(s) );
+
+	var = s;
+//	var++;
+
+//	for (i=0;i< MAX_OBJECTIVES; i++)
+//	{
+//		sscanf( var, "%i %i", 
+//			&client->sess.mission_objectives[i].display,
+//			&client->sess.mission_objectives[i].status);
+//			var+=4;
+//	}	
+	// Clear the objectives out 
+	for (i=0;i< MAX_OBJECTIVES; i++)
+	{
+		client->sess.mission_objectives[i].display = 0;
+		client->sess.mission_objectives[i].status = OBJECTIVE_STAT_PENDING;
+	}	
+
+	// Now load the LIGHTSIDE objective. That's the only cross level objective.
+	sscanf( var, "%i %i", 
+		&client->sess.mission_objectives[LIGHTSIDE_OBJ].display,
+		&client->sess.mission_objectives[LIGHTSIDE_OBJ].status);
+
+	var = va( "missionstats%i", client - level.clients );
+	gi.Cvar_VariableStringBuffer( var, s, sizeof(s) );
+	sscanf( s, "%i %i %i %i %i %i %i %i %i %i %i %i",
+		&client->sess.missionStats.secretsFound,
+		&client->sess.missionStats.totalSecrets,
+		&client->sess.missionStats.shotsFired,
+		&client->sess.missionStats.hits,
+		&client->sess.missionStats.enemiesSpawned,
+		&client->sess.missionStats.enemiesKilled,
+		&client->sess.missionStats.saberThrownCnt,
+		&client->sess.missionStats.saberBlocksCnt,
+		&client->sess.missionStats.legAttacksCnt,
+		&client->sess.missionStats.armAttacksCnt,
+		&client->sess.missionStats.torsoAttacksCnt,
+		&client->sess.missionStats.otherAttacksCnt);
+
+
+	var = va( "sessionpowers%i", client - level.clients );
+	gi.Cvar_VariableStringBuffer( var, s, sizeof(s) );
+
+	i=0;
+	var = strtok( s, " " );
+	while( var != NULL )
+	{
+      /* While there are tokens in "s" */
+	  client->sess.missionStats.forceUsed[i++] = atoi(var);
+      /* Get next token: */
+      var = strtok( NULL, " " );
+	}
+	assert (i==NUM_FORCE_POWERS);
+
+	var = va( "sessionweapons%i", client - level.clients );
+	gi.Cvar_VariableStringBuffer( var, s, sizeof(s) );
+
+	i=0;
+	var = strtok( s, " " );
+	while( var != NULL )
+	{
+      /* While there are tokens in "s" */
+	  client->sess.missionStats.weaponUsed[i++] = atoi(var);
+      /* Get next token: */
+      var = strtok( NULL, " " );
+	}
+	assert (i==WP_NUM_WEAPONS);
+}
+
+
+/*
+================
+G_InitSessionData
+
+Called on a first-time connect
+================
+*/
+void G_InitSessionData( gclient_t *client, char *userinfo ) {
+	clientSession_t	*sess;
+
+	sess = &client->sess;
+
+	sess->sessionTeam = TEAM_FREE;
+
+	G_WriteClientSessionData( client );
+}
+
+
+/*
+==================
+G_InitWorldSession
+
+==================
+*/
+void G_InitWorldSession( void ) {
+}
+
+/*
+==================
+G_WriteSessionData
+
+==================
+*/
+void G_WriteSessionData( void ) {
+	int		i;
+
+	gi.cvar_set( "session", 0) ;
+
+	for ( i = 0 ; i < level.maxclients ; i++ ) {
+		if ( level.clients[i].pers.connected == CON_CONNECTED ) {
+			G_WriteClientSessionData( &level.clients[i] );
+		}
+	}
+}
diff --git a/code/game/g_shared.h b/code/game/g_shared.h
new file mode 100644
index 0000000..21178c9
--- /dev/null
+++ b/code/game/g_shared.h
@@ -0,0 +1,930 @@
+#ifndef __G_SHARED_H__
+#define __G_SHARED_H__
+
+#include "bg_public.h"
+#include "g_public.h"
+#include "b_public.h"
+#include "../Icarus/Stdafx.h"	//need stl
+#include "../renderer/tr_types.h"
+#include "../cgame/cg_public.h"
+#include "G_Vehicles.h"
+#include "hitlocs.h"
+#include "bset.h"
+
+#define	FOFS(x) ((int)&(((gentity_t *)0)->x))
+
+#ifdef _XBOX
+#define MAX_NPC_WATER_UPDATE_PER_FRAME	2	// maxmum number of NPCs that will get updated water infromation per frame
+#endif
+
+typedef enum //# taskID_e
+{
+	TID_CHAN_VOICE = 0,	// Waiting for a voice sound to complete
+	TID_ANIM_UPPER,		// Waiting to finish a lower anim holdtime
+	TID_ANIM_LOWER,		// Waiting to finish a lower anim holdtime
+	TID_ANIM_BOTH,		// Waiting to finish lower and upper anim holdtimes or normal md3 animating
+	TID_MOVE_NAV,		// Trying to get to a navgoal or For ET_MOVERS
+	TID_ANGLE_FACE,		// Turning to an angle or facing
+	TID_BSTATE,			// Waiting for a certain bState to finish
+	TID_LOCATION,		// Waiting for ent to enter a specific trigger_location
+//	TID_MISSIONSTATUS,	// Waiting for player to finish reading MISSION STATUS SCREEN
+	TID_RESIZE,			// Waiting for clear bbox to inflate size
+	TID_SHOOT,			// Waiting for fire event
+	NUM_TIDS,			// for def of taskID array
+} taskID_t;
+
+
+typedef enum //# material_e
+{
+	MAT_METAL = 0,	// scorched blue-grey metal
+	MAT_GLASS,		// not a real chunk type, just plays an effect with glass sprites
+	MAT_ELECTRICAL,	// sparks only
+	MAT_ELEC_METAL,	// sparks/electrical type metal
+	MAT_DRK_STONE,	// brown
+	MAT_LT_STONE,	// tan
+	MAT_GLASS_METAL,// glass sprites and METAl chunk
+	MAT_METAL2,		// electrical metal type
+	MAT_NONE,		// no chunks
+	MAT_GREY_STONE,	// grey
+	MAT_METAL3,		// METAL and METAL2 chunks
+	MAT_CRATE1,		// yellow multi-colored crate chunks
+	MAT_GRATE1,		// grate chunks
+	MAT_ROPE,		// for yavin trial...no chunks, just wispy bits
+	MAT_CRATE2,		// read multi-colored crate chunks
+	MAT_WHITE_METAL,// white angular chunks
+
+	NUM_MATERIALS
+
+} material_t;
+
+//===From cg_local.h================================================
+#define	DEFAULT_HEADMODEL	""
+#define	DEFAULT_TORSOMODEL	""
+#define	DEFAULT_LEGSMODEL	"mouse"
+
+// each client has an associated clientInfo_t
+// that contains media references necessary to present the
+// client model and other color coded effects
+// this is regenerated each time a userinfo configstring changes
+
+#define	MAX_CUSTOM_BASIC_SOUNDS	14
+#define	MAX_CUSTOM_COMBAT_SOUNDS	17
+#define	MAX_CUSTOM_EXTRA_SOUNDS	36
+#define	MAX_CUSTOM_JEDI_SOUNDS	22
+#define	MAX_CUSTOM_SOUNDS	(MAX_CUSTOM_JEDI_SOUNDS + MAX_CUSTOM_EXTRA_SOUNDS + MAX_CUSTOM_COMBAT_SOUNDS + MAX_CUSTOM_BASIC_SOUNDS)
+// !!!!!!!!!! LOADSAVE-affecting structure !!!!!!!!!!
+typedef struct {
+	qboolean		infoValid;
+
+	char			name[MAX_QPATH];
+	team_t			team;
+
+	int				score;			// updated by score servercmds
+
+	int				handicap;
+
+	qhandle_t		legsModel;
+	qhandle_t		legsSkin;
+
+	qhandle_t		torsoModel;
+	qhandle_t		torsoSkin;
+
+	qhandle_t		headModel;
+	qhandle_t		headSkin;
+
+	int				animFileIndex;
+
+	sfxHandle_t		sounds[MAX_CUSTOM_SOUNDS];
+
+	char			*customBasicSoundDir;
+	char			*customCombatSoundDir;
+	char			*customExtraSoundDir;
+	char			*customJediSoundDir;
+} clientInfo_t;
+
+
+//==================================================================
+typedef enum 
+{
+	MOVER_POS1,
+	MOVER_POS2,
+	MOVER_1TO2,
+	MOVER_2TO1
+} moverState_t;
+
+// Rendering information structure
+
+
+typedef enum 
+{
+	MODEL_LEGS = 0,
+	MODEL_TORSO,
+	MODEL_HEAD,
+	MODEL_WEAPON1,
+	MODEL_WEAPON2,
+	MODEL_WEAPON3,
+	MODEL_EXTRA1,
+	MODEL_EXTRA2,
+	NUM_TARGET_MODELS
+} targetModel_t;
+
+//renderFlags
+#define	RF_LOCKEDANGLE	1
+
+// !!!!!!!!!! LOADSAVE-affecting structure !!!!!!!!!!
+typedef struct renderInfo_s
+{
+	// Legs model, or full model on one piece entities
+
+	union
+	{
+		char	legsModelName[32];		// -slc[]
+		char	modelName[32];			// -slc[]
+	};
+
+	char	torsoModelName[32];			// -slc[]
+	char	headModelName[32];			// -slc[]
+
+	//In whole degrees, How far to let the different model parts yaw and pitch
+	int		headYawRangeLeft;
+	int		headYawRangeRight;
+	int		headPitchRangeUp;
+	int		headPitchRangeDown;
+
+	int		torsoYawRangeLeft;
+	int		torsoYawRangeRight;
+	int		torsoPitchRangeUp;
+	int		torsoPitchRangeDown;
+
+	int		legsFrame;
+	int		torsoFrame;
+
+	float	legsFpsMod;
+	float	torsoFpsMod;
+
+	//Fields to apply to entire model set, individual model's equivalents will modify this value
+	byte	customRGBA[4];//Red Green Blue, 0 = don't apply
+
+	//Allow up to 4 PCJ lookup values to be stored here.
+	//The resolve to configstrings which contain the name of the
+	//desired bone.
+	int		boneIndex1;
+	int		boneIndex2;
+	int		boneIndex3;
+	int		boneIndex4;
+
+	//packed with x, y, z orientations for bone angles
+	int		boneOrient;
+
+	//I.. feel bad for doing this, but NPCs really just need to
+	//be able to control this sort of thing from the server sometimes.
+	//At least it's at the end so this stuff is never going to get sent
+	//over for anything that isn't an NPC.
+	vec3_t	boneAngles1; //angles of boneIndex1
+	vec3_t	boneAngles2; //angles of boneIndex2
+	vec3_t	boneAngles3; //angles of boneIndex3
+	vec3_t	boneAngles4; //angles of boneIndex4
+
+	//RF?
+	int			renderFlags;
+
+	//
+	vec3_t		muzzlePoint;
+	vec3_t		muzzleDir;
+	vec3_t		muzzlePointOld;
+	vec3_t		muzzleDirOld;
+	//vec3_t		muzzlePointNext;	// Muzzle point one server frame in the future!
+	//vec3_t		muzzleDirNext;
+	int			mPCalcTime;//Last time muzzle point was calced
+
+	//
+	float		lockYaw;//
+
+	//
+	vec3_t		headPoint;//Where your tag_head is
+	vec3_t		headAngles;//where the tag_head in the torso is pointing
+	vec3_t		handRPoint;//where your right hand is
+	vec3_t		handLPoint;//where your left hand is
+	vec3_t		crotchPoint;//Where your crotch is
+	vec3_t		footRPoint;//where your right hand is
+	vec3_t		footLPoint;//where your left hand is
+	vec3_t		torsoPoint;//Where your chest is
+	vec3_t		torsoAngles;//Where the chest is pointing
+	vec3_t		eyePoint;//Where your eyes are
+	vec3_t		eyeAngles;//Where your eyes face
+	int			lookTarget;//Which ent to look at with lookAngles
+	lookMode_t	lookMode;
+	int			lookTargetClearTime;//Time to clear the lookTarget
+	int			lastVoiceVolume;//Last frame's voice volume
+	vec3_t		lastHeadAngles;//Last headAngles, NOT actual facing of head model
+	vec3_t		headBobAngles;//headAngle offsets
+	vec3_t		targetHeadBobAngles;//head bob angles will try to get to targetHeadBobAngles
+	int			lookingDebounceTime;//When we can stop using head looking angle behavior
+	float		legsYaw;//yaw angle your legs are actually rendering at
+} renderInfo_t;
+
+// Movement information structure
+
+/*
+typedef struct moveInfo_s	// !!!!!!!!!! LOADSAVE-affecting struct !!!!!!!!
+{
+	vec3_t	desiredAngles;	// Desired facing angles
+	float	speed;	// Speed of movement
+	float	aspeed;	// Speed of angular movement
+	vec3_t	moveDir;	// Direction of movement
+	vec3_t	velocity;	// movement velocity
+	int		flags;			// Special state flags
+} moveInfo_t;
+*/
+
+typedef enum {
+	CON_DISCONNECTED,
+	CON_CONNECTING,
+	CON_CONNECTED
+} clientConnected_t;
+
+typedef enum {
+	TEAM_BEGIN,		// Beginning a team game, spawn at base
+	TEAM_ACTIVE		// Now actively playing
+} playerTeamStateState_t;
+/*
+typedef enum //# race_e
+{
+	RACE_NONE = 0,
+	RACE_HUMAN,
+	RACE_BORG,
+	RACE_KLINGON,
+	RACE_HIROGEN,
+	RACE_MALON,
+	RACE_STASIS,
+	RACE_8472,
+	RACE_BOT,
+	RACE_HARVESTER,
+	RACE_REAVER,
+	RACE_AVATAR,
+	RACE_PARASITE,
+	RACE_VULCAN,
+	RACE_BETAZOID,
+	RACE_BOLIAN,
+	RACE_TALAXIAN,
+	RACE_BAJORAN,
+	RACE_HOLOGRAM
+} race_t;
+*/
+// !!!!!!!!!! LOADSAVE-affecting structure !!!!!!!!!!
+typedef struct {
+	playerTeamStateState_t	state;
+
+	int			captures;
+	int			basedefense;
+	int			carrierdefense;
+	int			flagrecovery;
+	int			fragcarrier;
+	int			assists;
+
+	float		lasthurtcarrier;
+	float		lastreturnedflag;
+	float		flagsince;
+	float		lastfraggedcarrier;
+} playerTeamState_t;
+
+// !!!!!!!!!! LOADSAVE-affecting structure !!!!!!!!!!
+typedef struct objectives_s
+{
+	qboolean	display;	// A displayable objective?
+	int			status;	// Succeed or fail or pending
+} objectives_t;
+// NOTE: This is an arbitrary number greater than our current number of objectives with
+// some fluff just in case we add more in the future.
+#define MAX_MISSION_OBJ 100
+
+// !!!!!!!!!! LOADSAVE-affecting structure !!!!!!!!!!
+typedef struct missionStats_s
+{
+	int				secretsFound;					// # of secret areas found
+	int				totalSecrets;					// # of secret areas that could have been found
+	int				shotsFired;						// total number of shots fired
+	int				hits;							// Shots that did damage
+	int				enemiesSpawned;					// # of enemies spawned
+	int				enemiesKilled;					// # of enemies killed
+	int				saberThrownCnt;					// # of times saber was thrown
+	int				saberBlocksCnt;					// # of times saber was used to block
+	int				legAttacksCnt;					// # of times legs were hit with saber
+	int				armAttacksCnt;					// # of times arm were hit with saber
+	int				torsoAttacksCnt;				// # of times torso was hit with saber
+	int				otherAttacksCnt;				// # of times anything else on a monster was hit with saber
+	int				forceUsed[NUM_FORCE_POWERS];	// # of times each force power was used
+	int				weaponUsed[WP_NUM_WEAPONS];		// # of times each weapon was used
+} missionStats_t;
+
+// the auto following clients don't follow a specific client
+// number, but instead follow the first two active players
+#define	FOLLOW_ACTIVE1	-1
+#define	FOLLOW_ACTIVE2	-2
+
+// client data that stays across multiple levels or tournament restarts
+// this is achieved by writing all the data to cvar strings at game shutdown
+// time and reading them back at connection time.  Anything added here
+// MUST be dealt with in G_InitSessionData() / G_ReadSessionData() / G_WriteSessionData()
+//
+// !!!!!!!!!! LOADSAVE-affecting structure !!!!!!!!!!
+typedef struct {
+	int				missionObjectivesShown;	// Number of times mission objectives have been updated
+	team_t			sessionTeam;
+	objectives_t	mission_objectives[MAX_MISSION_OBJ];
+	missionStats_t	missionStats;			// Various totals while on a mission
+} clientSession_t;
+
+// client data that stays across multiple respawns, but is cleared
+// on each level change or team change at ClientBegin()
+// !!!!!!!!!! LOADSAVE-affecting structure !!!!!!!!!!
+typedef struct {
+	clientConnected_t	connected;	
+	usercmd_t	lastCommand;
+	char		netname[34];
+	int			maxHealth;			// for handicapping
+	int			enterTime;			// level.time the client entered the game
+	short		cmd_angles[3];		// angles sent over in the last command
+
+	playerTeamState_t teamState;	// status in teamplay games
+} clientPersistant_t;
+
+typedef enum {
+	BLK_NO,
+	BLK_TIGHT,		// Block only attacks and shots around the saber itself, a bbox of around 12x12x12
+	BLK_WIDE		// Block all attacks in an area around the player in a rough arc of 180 degrees
+} saberBlockType_t;
+
+typedef enum {
+	BLOCKED_NONE,
+	BLOCKED_PARRY_BROKEN,
+	BLOCKED_ATK_BOUNCE,
+	BLOCKED_UPPER_RIGHT,
+	BLOCKED_UPPER_LEFT,
+	BLOCKED_LOWER_RIGHT,
+	BLOCKED_LOWER_LEFT,
+	BLOCKED_TOP,
+	BLOCKED_UPPER_RIGHT_PROJ,
+	BLOCKED_UPPER_LEFT_PROJ,
+	BLOCKED_LOWER_RIGHT_PROJ,
+	BLOCKED_LOWER_LEFT_PROJ,
+	BLOCKED_TOP_PROJ
+} saberBlockedType_t;
+
+typedef enum //# movetype_e
+{
+	MT_STATIC = 0,
+	MT_WALK,
+	MT_RUNJUMP,
+	MT_FLYSWIM,
+	NUM_MOVETYPES
+} movetype_t;
+
+// !!!!!!!!!! LOADSAVE-affecting structure !!!!!!!!!!
+
+// this structure is cleared on each ClientSpawn(),
+// except for 'client->pers' and 'client->sess'
+struct gclient_s {
+	// ps MUST be the first element, because the server expects it
+	playerState_t	ps;				// communicated by server to clients
+
+	// private to game
+	clientPersistant_t	pers;
+	clientSession_t		sess;
+
+	int			lastCmdTime;		// level.time of last usercmd_t, for EF_CONNECTION
+
+	usercmd_t	usercmd;			// most recent usercmd
+
+	int			buttons;
+	int			oldbuttons;
+	int			latched_buttons;
+
+	// sum up damage over an entire frame, so
+	// shotgun blasts give a single big kick
+	int			damage_armor;		// damage absorbed by armor
+	int			damage_blood;		// damage taken out of health
+	vec3_t		damage_from;		// origin for vector calculation
+	bool		damage_fromWorld;	// if true, don't use the damage_from vector
+	bool		noclip;
+//icarus forced moving.  is this still used?
+	signed char		forced_forwardmove;
+	signed char		forced_rightmove;
+
+	// timers
+	int			respawnTime;		// can respawn when time > this, force after g_forcerespwan
+	int			idleTime;			// for playing idleAnims
+
+	int			airOutTime;
+
+	// timeResidual is used to handle events that happen every second
+	// like health / armor countdowns and regeneration
+	int			timeResidual;
+	
+	// Facial Expression Timers
+
+	float		facial_blink;		// time before next blink. If a minus value, we are in blink mode
+	float		facial_timer;		// time before next alert, frown or smile. If a minus value, we are in anim mode
+	int			facial_anim;		// anim to show in anim mode
+
+	//Client info - updated when ClientInfoChanged is called, instead of using configstrings
+	clientInfo_t	clientInfo;
+	movetype_t		moveType;
+	int				jetPackTime;
+	int				fireDelay;		//msec to delay calling G_FireWeapon after EV_FIREWEAPON event is called
+
+	// The time at which a breath should be triggered. -Aurelio
+	int				breathPuffTime;
+
+	//Used to be in gentity_t, now here.. mostly formation stuff
+	team_t		playerTeam;
+	team_t		enemyTeam;
+	gentity_t	*leader;
+	class_t		NPC_class;
+
+	//FIXME: could combine these
+	float		hiddenDist;//How close ents have to be to pick you up as an enemy
+	vec3_t		hiddenDir;//Normalized direction in which NPCs can't see you (you are hidden)
+
+	renderInfo_t	renderInfo;
+
+	//dismember tracker
+	bool		dismembered;
+	char		dismemberProbLegs;	// probability of the legs being dismembered (located in NPC.cfg, 0 = never, 100 = always)
+	char		dismemberProbHead;  // probability of the head being dismembered (located in NPC.cfg, 0 = never, 100 = always)
+	char		dismemberProbArms;  // probability of the arms being dismembered (located in NPC.cfg, 0 = never, 100 = always)
+	char		dismemberProbHands; // probability of the hands being dismembered (located in NPC.cfg, 0 = never, 100 = always)
+	char		dismemberProbWaist; // probability of the waist being dismembered (located in NPC.cfg, 0 = never, 100 = always)
+
+	int			standheight;
+	int			crouchheight;
+	int			poisonDamage;				// Amount of poison damage to be given
+	int			poisonTime;					// When to apply poison damage
+	int			slopeRecalcTime;			// debouncer for slope-foot-height-diff calcing
+
+	vec3_t		pushVec;
+	int			pushVecTime;
+
+	int			noRagTime; //don't do ragdoll stuff if > level.time
+	qboolean	isRagging;
+	int			overridingBones; //dragging body or doing something else to override one or more ragdoll effector's/pcj's
+
+	vec3_t		ragLastOrigin; //keeping track of positions between rags while dragging corpses
+	int			ragLastOriginTime;
+
+	//push refraction effect vars
+	int			pushEffectFadeTime;
+	vec3_t		pushEffectOrigin;
+
+	//Rocket locking vars for non-player clients (only Vehicles use these right now...)
+	int			rocketLockIndex;
+	float		rocketLastValidTime;
+	float		rocketLockTime;
+	float		rocketTargetTime;
+
+	//for trigger_space brushes
+	int			inSpaceSuffocation;
+	int			inSpaceIndex;
+};
+
+#define	MAX_PARMS	16
+#define	MAX_PARM_STRING_LENGTH	MAX_QPATH//was 16, had to lengthen it so they could take a valid file path
+typedef struct
+{	
+	char	parm[MAX_PARMS][MAX_PARM_STRING_LENGTH];
+} parms_t;
+
+#ifdef GAME_INCLUDE
+//these hold the place for the enums in functions.h so i don't have to recompile everytime it changes
+#define thinkFunc_t int
+#define clThinkFunc_t int
+#define reachedFunc_t int
+#define blockedFunc_t int
+#define touchFunc_t int
+#define useFunc_t int
+#define painFunc_t int
+#define dieFunc_t int
+
+#define MAX_FAILED_NODES 8
+#define MAX_INHAND_WEAPONS	2
+
+
+typedef struct centity_s centity_t;
+// !!!!!!!!!!! LOADSAVE-affecting struct !!!!!!!!!!!!!
+struct gentity_s {
+	entityState_t	s;				// communicated by server to clients
+	struct gclient_s	*client;	// NULL if not a player (unless it's NPC ( if (this->NPC != NULL)  )  <sigh>... -slc)
+	qboolean	inuse;
+	qboolean	linked;				// qfalse if not in any good cluster
+
+	int			svFlags;			// SVF_NOCLIENT, SVF_BROADCAST, etc
+
+	qboolean	bmodel;				// if false, assume an explicit mins / maxs bounding box
+									// only set by gi.SetBrushModel
+	vec3_t		mins, maxs;
+	int			contents;			// CONTENTS_TRIGGER, CONTENTS_SOLID, CONTENTS_BODY, etc
+									// a non-solid entity should set to 0
+
+	vec3_t		absmin, absmax;		// derived from mins/maxs and origin + rotation
+
+	// currentOrigin will be used for all collision detection and world linking.
+	// it will not necessarily be the same as the trajectory evaluation for the current
+	// time, because each entity must be moved one at a time after time is advanced
+	// to avoid simultanious collision issues
+	vec3_t		currentOrigin;
+	vec3_t		currentAngles;
+
+	gentity_t	*owner;				// objects never interact with their owners, to
+									// prevent player missiles from immediately
+									// colliding with their owner
+/*
+Ghoul2 Insert Start
+*/
+	// this marker thing of Jake's is used for memcpy() length calcs, so don't put any ordinary fields (like above)
+	//	below this point or they won't work, and will mess up all sorts of stuff. 
+	//
+	CGhoul2Info_v	ghoul2;
+
+	vec3_t			modelScale; //needed for g2 collision
+/*
+Ghoul2 Insert End
+*/
+
+	// DO NOT MODIFY ANYTHING ABOVE THIS, THE SERVER
+	// EXPECTS THE FIELDS IN THAT ORDER!
+
+//==========================================================================================
+
+//Essential entity fields
+	// note: all the char* fields from here on should be left as ptrs, not declared, because of the way that ent-parsing
+	//	works by forcing field offset ptrs as char* and using G_NewString()!! (see G_ParseField() in gmae/g_spawn.cpp -slc
+	//
+	char		*classname;			// set in QuakeEd
+	int			spawnflags;			// set in QuakeEd
+
+	int			flags;				// FL_* variables
+
+	char		*model;				// Normal model, or legs model on tri-models
+	char		*model2;			// Torso model
+
+	int			freetime;			// sv.time when the object was freed
+	
+	int			eventTime;			// events will be cleared EVENT_VALID_MSEC after set
+	qboolean	freeAfterEvent;
+//	qboolean	unlinkAfterEvent;
+
+//Physics and movement fields
+	float		physicsBounce;		// 1.0 = continuous bounce, 0.0 = no bounce
+	int			clipmask;			// brushes with this content value will be collided against
+									// when moving.  items and corpses do not collide against
+									// players, for instance
+//	moveInfo_t	moveInfo;		//FIXME: use this more?
+	float		speed;
+	float		resultspeed;
+	int			lastMoveTime;
+	vec3_t		movedir;
+	vec3_t		lastOrigin;			//Where you were last frame
+	vec3_t		lastAngles;			//Where you were looking last frame
+	float		mass;				//How heavy you are
+	int			lastImpact;			//Last time you impacted something
+
+//Variables reflecting environment
+	int			watertype;
+	int			waterlevel;
+	short		wupdate;
+	short		prev_waterlevel;
+
+//Targeting/linking fields
+	float		angle;			// set in editor, -1 = up, -2 = down
+	char		*target;
+	char		*target2;		//For multiple targets, not used for firing/triggering/using, though, only for path branches
+	char		*target3;		//For multiple targets, not used for firing/triggering/using, though, only for path branches
+	char		*target4;		//For multiple targets, not used for firing/triggering/using, though, only for path branches
+	char		*targetJump;
+	char		*targetname;
+	char		*team;
+
+	union
+	{
+		char	*roff;			// the roff file to use, if there is one
+		char	*fxFile;		// name of the external effect file
+	};
+
+	int		roff_ctr;		// current roff frame we are playing
+
+	int			next_roff_time;	
+	int			fx_time;		// timer for beam in/out effects.
+
+//Think Functions
+	int			nextthink;//Used to determine if it's time to call e_ThinkFunc again
+	thinkFunc_t		e_ThinkFunc;//Called once every game frame for every ent
+	clThinkFunc_t	e_clThinkFunc;//Think func for equivalent centity
+	reachedFunc_t	e_ReachedFunc;// movers call this when hitting endpoint
+	blockedFunc_t	e_BlockedFunc;
+	touchFunc_t		e_TouchFunc;
+	useFunc_t		e_UseFunc;	//Called by G_UseTargets
+	painFunc_t		e_PainFunc;	//Called by G_Damage when damage is taken
+	dieFunc_t		e_DieFunc;	//Called by G_Damage when health reaches <= 0
+
+//Health and damage fields
+	int			health;
+	int			max_health;
+	qboolean	takedamage;
+	material_t	material;
+	int			damage;
+	int			dflags;
+	//explosives, breakable brushes
+	int			splashDamage;	// quad will increase this without increasing radius
+	int			splashRadius;
+	int			methodOfDeath;
+	int			splashMethodOfDeath;
+	//int			hitLoc;//where you were last hit
+	int			locationDamage[HL_MAX];		// Damage accumulated on different body locations
+
+//Entity pointers
+	gentity_t	*chain;
+	gentity_t	*enemy;
+	gentity_t	*activator;
+	gentity_t	*teamchain;		// next entity in team
+	gentity_t	*teammaster;	// master of the team
+	gentity_t	*lastEnemy;
+
+//Timing variables, counters and debounce times
+	float		wait;
+	float		random;
+	int			delay;
+	qboolean	alt_fire;
+	int			count;
+	int			bounceCount;
+	int			fly_sound_debounce_time;	// wind tunnel
+	int			painDebounceTime;
+	int			disconnectDebounceTime;
+	int			attackDebounceTime;
+	int			pushDebounceTime;
+	int			aimDebounceTime;
+	int			useDebounceTime;
+
+//Unions for miscellaneous fields used under very specific circumstances
+	union
+	{
+		qboolean	trigger_formation;
+		qboolean	misc_dlight_active;
+		qboolean	has_bounced;	// for thermal Det.  we force at least one bounce to happen before it can do proximity checks
+	};
+
+//Navigation
+	int			spawnContents;		// store contents of ents on spawn so nav system can restore them
+	int			waypoint;			//Set once per frame, if you've moved, and if someone asks
+	int			wayedge;			//Used by doors and breakable things to know what edge goes through them
+	int			lastWaypoint;		//To make sure you don't double-back
+	int			lastInAirTime;
+	int			noWaypointTime;		//Debouncer - so don't keep checking every waypoint in existance every frame that you can't find one
+	int			combatPoint;
+	vec3_t		followPos;
+	int			followPosRecalcTime;
+	int			followPosWaypoint;
+
+//Animation
+	qboolean	loopAnim;
+	int		startFrame;
+	int		endFrame;
+
+//Script/ICARUS-related fields
+	int				m_iIcarusID;
+	int				taskID[NUM_TIDS];
+	parms_t			*parms;
+	char		*behaviorSet[NUM_BSETS];
+	char		*script_targetname;
+	int			delayScriptTime;
+
+// Ambient sound info
+	char			*soundSet;	//Only used for local sets
+	int				setTime;
+
+//Used by cameras to locate subjects
+	char			*cameraGroup;
+
+//For damage
+	team_t		noDamageTeam;
+
+// Ghoul2 Animation info
+	short			playerModel;
+	short			weaponModel[MAX_INHAND_WEAPONS];
+	short			handRBolt;
+	short			handLBolt;
+	short			headBolt;
+	short			cervicalBolt;
+	short			chestBolt;
+	short			gutBolt;
+	short			torsoBolt;
+	short			crotchBolt;
+	short			motionBolt;
+	short			kneeLBolt;
+	short			kneeRBolt;
+	short			elbowLBolt;
+	short			elbowRBolt;
+	short			footLBolt;
+	short			footRBolt;
+	short			faceBone;
+	short			craniumBone;
+	short			cervicalBone;
+	short			thoracicBone;
+	short			upperLumbarBone;
+	short			lowerLumbarBone;
+	short			hipsBone;
+	short			motionBone;
+	short			rootBone;
+	short			footLBone;
+	short			footRBone;
+	short			humerusRBone;
+
+	short			genericBone1;		// For bones special to an entity
+	short			genericBone2;
+	short			genericBone3;
+
+	short			genericBolt1;		// For bolts special to an entity
+	short			genericBolt2;
+	short			genericBolt3;
+	short			genericBolt4;
+	short			genericBolt5;
+
+	qhandle_t		cinematicModel;
+
+//==========================================================================================
+	
+//FIELDS USED EXCLUSIVELY BY SPECIFIC CLASSES OF ENTITIES
+	// Vehicle information.
+	// The vehicle object.
+	Vehicle_t *m_pVehicle;
+
+	//NPC/Player entity fields
+	//FIXME: Make these client only?
+	gNPC_t		*NPC;//Only allocated if the entity becomes an NPC
+
+	//Other NPC/Player-related entity fields
+	char		*ownername;//Used by squadpaths to locate owning NPC
+
+//FIXME: Only used by NPCs, move it to gNPC_t
+	int			cantHitEnemyCounter;//HACK - Makes them look for another enemy on the same team if the one they're after can't be hit
+
+//Only used by NPC_spawners
+	char		*NPC_type;
+	char		*NPC_targetname;
+	char		*NPC_target;
+
+//Variables used by movers (most likely exclusively by them)
+	moverState_t moverState;
+	int			soundPos1;
+	int			sound1to2;
+	int			sound2to1;
+	int			soundPos2;
+	int			soundLoop;
+	gentity_t	*nextTrain;
+	gentity_t	*prevTrain;
+	vec3_t		pos1, pos2;
+	vec3_t		pos3;
+	int			sounds;
+	char		*closetarget;
+	char		*opentarget;
+	char		*paintarget;
+	int			lockCount;	//for maglocks- actually get put on the trigger for the door
+
+//Variables used only by waypoints (for the most part)
+	float		radius;
+	
+	union
+	{
+		int		wpIndex;
+		int		fxID;			// id of the external effect file
+	};
+
+	int			noise_index;
+
+	vec4_t		startRGBA;
+
+	union
+	{
+		vec4_t		finalRGBA;
+		vec3_t		pos4;
+		vec3_t		modelAngles;	//for brush entities with an attached md3 model, as an offset to the brush's angles
+	};
+
+//FIXME: Are these being used anymore?
+	gitem_t		*item;			// for bonus items - 
+	char		*message;		//Used by triggers to print a message when activated
+
+	float		lightLevel;
+
+	//FIXME: can these be removed/condensed/absorbed?
+	//Rendering info
+	//int			color;
+
+	//Force effects
+	int			forcePushTime;
+	int			forcePuller;	//who force-pulled me (so we don't damage them if we hit them)
+};
+#endif //#ifdef GAME_INCLUDE
+
+extern	gentity_t		g_entities[MAX_GENTITIES];
+#ifndef _USRDLL
+extern	game_import_t	gi;
+#endif
+
+// each WP_* weapon enum has an associated weaponInfo_t
+// that contains media references necessary to present the
+// weapon and its effects
+typedef struct weaponInfo_s {
+	qboolean		registered;
+	gitem_t			*item;
+
+	qhandle_t		handsModel;			// the hands don't actually draw, they just position the weapon
+	qhandle_t		weaponModel;		//for in view
+	qhandle_t		weaponWorldModel;	//for in their hands
+	qhandle_t		barrelModel[4];
+
+	vec3_t			weaponMidpoint;		// so it will rotate centered instead of by tag
+
+	qhandle_t		weaponIcon;			// The version of the icon with a glowy background
+	qhandle_t		weaponIconNoAmmo;	// The version of the icon with no ammo warning
+	qhandle_t		ammoIcon;
+
+	qhandle_t		ammoModel;
+
+	qhandle_t		missileModel;
+	sfxHandle_t		missileSound;
+	void			(*missileTrailFunc)( centity_t *, const struct weaponInfo_s *wi );
+
+	qhandle_t		alt_missileModel;
+	sfxHandle_t		alt_missileSound;
+	void			(*alt_missileTrailFunc)( centity_t *, const struct weaponInfo_s *wi );
+
+//	sfxHandle_t		flashSound;
+//	sfxHandle_t		altFlashSound;
+
+	sfxHandle_t		firingSound;
+	sfxHandle_t		altFiringSound;
+
+	sfxHandle_t		stopSound;
+
+	sfxHandle_t		missileHitSound;
+	sfxHandle_t		altmissileHitSound;
+
+	sfxHandle_t		chargeSound;
+	sfxHandle_t		altChargeSound;
+
+	sfxHandle_t		selectSound;	// sound played when weapon is selected
+
+#ifdef _IMMERSION
+	ffHandle_t		firingForce;
+	ffHandle_t		altFiringForce;
+	ffHandle_t		stopForce;
+	ffHandle_t		chargeForce;
+	ffHandle_t		altChargeForce;
+	ffHandle_t		selectForce;
+#endif // _IMMERSION
+} weaponInfo_t;
+
+extern sfxHandle_t CAS_GetBModelSound( const char *name, int stage );
+
+enum
+{
+	EDGE_NORMAL,
+	EDGE_PATH,
+	EDGE_BLOCKED,
+	EDGE_FAILED,
+	EDGE_FLY,
+	EDGE_JUMP,
+	EDGE_LARGE,
+	EDGE_PATHBLOCKED,
+	EDGE_NEARESTVALID,
+	EDGE_NEARESTINVALID,
+
+	EDGE_NODE_FLOATING,
+	EDGE_NODE_NORMAL,
+	EDGE_NODE_GOAL,
+	EDGE_NODE_COMBAT,
+
+	EDGE_CELL,
+	EDGE_CELL_EMPTY,
+	EDGE_IMPACT_SAFE,
+	EDGE_IMPACT_POSSIBLE,
+	EDGE_THRUST,
+	EDGE_VELOCITY,
+
+	EDGE_FOLLOWPOS,
+
+	EDGE_WHITE_ONESECOND,
+	EDGE_WHITE_TWOSECOND,
+	EDGE_RED_ONESECOND,
+	EDGE_RED_TWOSECOND,
+};
+
+enum
+{
+	NODE_NORMAL,
+	NODE_FLOATING,
+	NODE_GOAL,
+	NODE_NAVGOAL,
+};
+
+#endif // #ifndef __G_SHARED_H__
diff --git a/code/game/g_spawn.cpp b/code/game/g_spawn.cpp
new file mode 100644
index 0000000..910f833
--- /dev/null
+++ b/code/game/g_spawn.cpp
@@ -0,0 +1,1655 @@
+// leave this line at the top for all g_xxxx.cpp files...
+#include "g_headers.h"
+
+
+#include "Q3_Interface.h"
+#include "g_local.h"
+#include "g_functions.h"
+
+extern cvar_t *g_spskill;
+extern cvar_t *g_delayedShutdown;
+
+// these vars I moved here out of the level_locals_t struct simply because it's pointless to try saving them,
+//	and the level_locals_t struct is included in the save process... -slc
+//
+qboolean	spawning = qfalse;				// the G_Spawn*() functions are valid  (only turned on during one function)
+int			numSpawnVars;
+char		*spawnVars[MAX_SPAWN_VARS][2];	// key / value pairs
+int			numSpawnVarChars;
+char		spawnVarChars[MAX_SPAWN_VARS_CHARS];
+
+int			delayedShutDown = 0;
+
+#include "../qcommon/sstring.h"
+
+//NOTENOTE: Be sure to change the mirrored code in cgmain.cpp
+typedef	map< sstring_t, unsigned char, less<sstring_t>, allocator< unsigned char >  >	namePrecache_m;
+namePrecache_m	*as_preCacheMap = NULL;
+
+char *G_AddSpawnVarToken( const char *string );
+
+void AddSpawnField(char *field, char *value)
+{
+	int	i;
+
+	for(i=0;i<numSpawnVars;i++)
+	{
+		if (Q_stricmp(spawnVars[i][0], field) == 0)
+		{
+			spawnVars[ i ][1] = G_AddSpawnVarToken( value );
+			return;
+		}
+	}
+
+	spawnVars[ numSpawnVars ][0] = G_AddSpawnVarToken( field );
+	spawnVars[ numSpawnVars ][1] = G_AddSpawnVarToken( value );
+	numSpawnVars++;
+}
+
+qboolean	G_SpawnField( unsigned int uiField, char **ppKey, char **ppValue )
+{
+	if ( uiField >= numSpawnVars )
+		return qfalse;
+
+	(*ppKey) = spawnVars[uiField][0];
+	*ppValue = spawnVars[uiField][1];
+
+	return qtrue;
+}
+
+qboolean	G_SpawnString( const char *key, const char *defaultString, char **out ) {
+	int		i;
+
+	if ( !spawning ) {
+		*out = (char *)defaultString;
+//		G_Error( "G_SpawnString() called while not spawning" );
+	}
+
+	for ( i = 0 ; i < numSpawnVars ; i++ ) {
+		if ( !Q_stricmp( key, spawnVars[i][0] ) ) {
+			*out = spawnVars[i][1];
+			return qtrue;
+		}
+	}
+
+	*out = (char *)defaultString;
+	return qfalse;
+}
+
+qboolean	G_SpawnFloat( const char *key, const char *defaultString, float *out ) {
+	char		*s;
+	qboolean	present;
+
+	present = G_SpawnString( key, defaultString, &s );
+	*out = atof( s );
+	return present;
+}
+
+qboolean	G_SpawnInt( const char *key, const char *defaultString, int *out ) {
+	char		*s;
+	qboolean	present;
+
+	present = G_SpawnString( key, defaultString, &s );
+	*out = atoi( s );
+	return present;
+}
+
+qboolean	G_SpawnVector( const char *key, const char *defaultString, float *out ) {
+	char		*s;
+	qboolean	present;
+
+	present = G_SpawnString( key, defaultString, &s );
+	sscanf( s, "%f %f %f", &out[0], &out[1], &out[2] );
+	return present;
+}
+
+qboolean	G_SpawnVector4( const char *key, const char *defaultString, float *out ) {
+	char		*s;
+	qboolean	present;
+
+	present = G_SpawnString( key, defaultString, &s );
+	sscanf( s, "%f %f %f %f", &out[0], &out[1], &out[2], &out[3] );
+	return present;
+}
+
+qboolean	G_SpawnFlag( const char *key, int flag, int *out )
+{
+	//find that key
+	for ( int i = 0 ; i < numSpawnVars ; i++ ) 
+	{
+		if ( !strcmp( key, spawnVars[i][0] ) ) 
+		{
+			//found the key
+			if ( atoi( spawnVars[i][1] ) != 0 )
+			{//if it's non-zero, and in the flag
+				*out |= flag;
+			}
+			else
+			{//if it's zero, or out the flag
+				*out &= ~flag;
+			}
+			return qtrue;
+		}
+	}
+
+	return qfalse;
+}
+
+qboolean G_SpawnAngleHack( const char *key, const char *defaultString, float *out )
+{
+	char		*s;
+	qboolean	present;
+	float		temp = 0;
+
+	present = G_SpawnString( key, defaultString, &s );
+	sscanf( s, "%f", &temp );
+
+	out[0] = 0;
+	out[1] = temp;
+	out[2] = 0;
+
+	return present;
+}
+
+stringID_table_t flagTable [] =
+{
+	//"noTED", EF_NO_TED,
+	//stringID_table_t Must end with a null entry
+	"", NULL
+};
+
+//
+// fields are needed for spawning from the entity string
+//
+typedef enum {
+	F_INT, 
+	F_FLOAT,
+	F_LSTRING,			// string on disk, pointer in memory, TAG_LEVEL
+	F_GSTRING,			// string on disk, pointer in memory, TAG_GAME
+	F_VECTOR,
+	F_VECTOR4,
+	F_ANGLEHACK,
+	F_ENTITY,			// index on disk, pointer in memory
+	F_ITEM,				// index on disk, pointer in memory
+	F_CLIENT,			// index on disk, pointer in memory
+	F_PARM1,			// Special case for parms
+	F_PARM2,			// Special case for parms
+	F_PARM3,			// Special case for parms
+	F_PARM4,			// Special case for parms
+	F_PARM5,			// Special case for parms
+	F_PARM6,			// Special case for parms
+	F_PARM7,			// Special case for parms
+	F_PARM8,			// Special case for parms
+	F_PARM9,			// Special case for parms
+	F_PARM10,			// Special case for parms
+	F_PARM11,			// Special case for parms
+	F_PARM12,			// Special case for parms
+	F_PARM13,			// Special case for parms
+	F_PARM14,			// Special case for parms
+	F_PARM15,			// Special case for parms
+	F_PARM16,			// Special case for parms
+	F_FLAG,				// special case for flags
+	F_IGNORE
+} fieldtype_t;
+
+typedef struct
+{
+	char	*name;
+	int		ofs;
+	fieldtype_t	type;
+	int		flags;
+} field_t;
+
+field_t fields[] = {
+	//Fields for benefit of Radiant only
+	{"autobound", FOFS(classname), F_IGNORE},
+	{"groupname", FOFS(classname), F_IGNORE},
+	{"noBasicSounds", FOFS(classname), F_IGNORE},//will be looked at separately
+	{"noCombatSounds", FOFS(classname), F_IGNORE},//will be looked at separately
+	{"noExtraSounds", FOFS(classname), F_IGNORE},//will be looked at separately
+
+	{"classname", FOFS(classname), F_LSTRING},
+	{"origin", FOFS(s.origin), F_VECTOR},
+	{"mins", FOFS(mins), F_VECTOR},
+	{"maxs", FOFS(maxs), F_VECTOR},
+	{"model", FOFS(model), F_LSTRING},
+	{"model2", FOFS(model2), F_LSTRING},
+	{"model3", FOFS(target), F_LSTRING},//for misc_replicator_item only!!!
+	{"model4", FOFS(target2), F_LSTRING},//for misc_replicator_item only!!!
+	{"model5", FOFS(target3), F_LSTRING},//for misc_replicator_item only!!!
+	{"model6", FOFS(target4), F_LSTRING},//for misc_replicator_item only!!!
+	{"spawnflags", FOFS(spawnflags), F_INT},
+	{"speed", FOFS(speed), F_FLOAT},
+	{"duration", FOFS(speed), F_FLOAT},//for psycho jism
+	{"interest", FOFS(health), F_INT},//For target_interest
+	{"target", FOFS(target), F_LSTRING},
+	{"target2", FOFS(target2), F_LSTRING},
+	{"target3", FOFS(target3), F_LSTRING},
+	{"target4", FOFS(target4), F_LSTRING},
+	{"targetJump", FOFS(targetJump), F_LSTRING},
+	{"targetname", FOFS(targetname), F_LSTRING},
+	{"material", FOFS(material), F_INT},
+	{"message", FOFS(message), F_LSTRING},
+	{"team", FOFS(team), F_LSTRING},
+	{"mapname", FOFS(message), F_LSTRING},
+	{"wait", FOFS(wait), F_FLOAT},
+	{"finaltime", FOFS(wait), F_FLOAT},//For dlight
+	{"random", FOFS(random), F_FLOAT},
+	{"FOV", FOFS(random), F_FLOAT},//for ref_tags and trigger_visibles
+	{"count", FOFS(count), F_INT},
+	{"bounceCount", FOFS(bounceCount), F_INT},
+	{"health", FOFS(health), F_INT},
+	{"friction", FOFS(health), F_INT},//For target_friction_change
+	{"light", 0, F_IGNORE},
+	{"dmg", FOFS(damage), F_INT},
+	{"angles", FOFS(s.angles), F_VECTOR},
+	{"angle", FOFS(s.angles), F_ANGLEHACK},
+	{"modelAngles", FOFS(modelAngles), F_VECTOR},
+	{"cameraGroup", FOFS(cameraGroup), F_LSTRING},
+	{"radius", FOFS(radius), F_FLOAT},
+	{"hiderange", FOFS(radius), F_FLOAT},//for triggers only
+	{"starttime", FOFS(radius), F_FLOAT},//for dlight
+	{"turfrange", FOFS(radius), F_FLOAT},//for sand creatures
+	{"type", FOFS(count), F_FLOAT},//for fx_crew_beam_in
+	{"fxfile", FOFS(fxFile), F_LSTRING},
+	{"fxfile2", FOFS(cameraGroup), F_LSTRING},
+	{"noVisTime", FOFS(endFrame), F_INT},//for NPC_Vehicle
+	{"endFrame", FOFS(endFrame), F_INT},//for func_usable shader animation
+	{"linear", FOFS(alt_fire), F_INT},//for movers to use linear movement
+	{"weapon",FOFS(paintarget),F_LSTRING},//for misc_weapon_shooter only
+
+//Script parms - will this handle clamping to 16 or whatever length of parm[0] is?
+	{"parm1", 0, F_PARM1},
+	{"parm2", 0, F_PARM2},
+	{"parm3", 0, F_PARM3},
+	{"parm4", 0, F_PARM4},
+	{"parm5", 0, F_PARM5},
+	{"parm6", 0, F_PARM6},
+	{"parm7", 0, F_PARM7},
+	{"parm8", 0, F_PARM8},
+	{"parm9", 0, F_PARM9},
+	{"parm10", 0, F_PARM10},
+	{"parm11", 0, F_PARM11},
+	{"parm12", 0, F_PARM12},
+	{"parm13", 0, F_PARM13},
+	{"parm14", 0, F_PARM14},
+	{"parm15", 0, F_PARM15},
+	{"parm16", 0, F_PARM16},
+	//{"noTED", FOFS(s.eFlags), F_FLAG},
+
+//MCG - Begin
+	//extra fields for ents
+	{"delay", FOFS(delay), F_INT},
+	{"sounds", FOFS(sounds), F_INT},
+	{"closetarget", FOFS(closetarget), F_LSTRING},//for doors
+	{"opentarget", FOFS(opentarget), F_LSTRING},//for doors
+	{"paintarget", FOFS(paintarget), F_LSTRING},//for doors
+	{"soundGroup", FOFS(paintarget), F_LSTRING},//for target_speakers
+	{"backwardstarget", FOFS(paintarget), F_LSTRING},//for trigger_bidirectional
+	{"splashDamage", FOFS(splashDamage), F_INT},
+	{"splashRadius", FOFS(splashRadius), F_INT},
+	//Script stuff
+	{"spawnscript", FOFS(behaviorSet[BSET_SPAWN]), F_LSTRING},//name of script to run
+	{"usescript", FOFS(behaviorSet[BSET_USE]), F_LSTRING},//name of script to run
+	{"awakescript", FOFS(behaviorSet[BSET_AWAKE]), F_LSTRING},//name of script to run
+	{"angerscript", FOFS(behaviorSet[BSET_ANGER]), F_LSTRING},//name of script to run
+	{"attackscript", FOFS(behaviorSet[BSET_ATTACK]), F_LSTRING},//name of script to run
+	{"victoryscript", FOFS(behaviorSet[BSET_VICTORY]), F_LSTRING},//name of script to run
+	{"lostenemyscript", FOFS(behaviorSet[BSET_LOSTENEMY]), F_LSTRING},//name of script to run
+	{"painscript", FOFS(behaviorSet[BSET_PAIN]), F_LSTRING},//name of script to run
+	{"fleescript", FOFS(behaviorSet[BSET_FLEE]), F_LSTRING},//name of script to run
+	{"deathscript", FOFS(behaviorSet[BSET_DEATH]), F_LSTRING},//name of script to run
+	{"delayscript", FOFS(behaviorSet[BSET_DELAYED]), F_LSTRING},//name of script to run
+	{"delayscripttime", FOFS(delayScriptTime), F_INT},//name of script to run
+	{"blockedscript", FOFS(behaviorSet[BSET_BLOCKED]), F_LSTRING},//name of script to run
+	{"ffirescript", FOFS(behaviorSet[BSET_FFIRE]), F_LSTRING},//name of script to run
+	{"ffdeathscript", FOFS(behaviorSet[BSET_FFDEATH]), F_LSTRING},//name of script to run
+	{"mindtrickscript", FOFS(behaviorSet[BSET_MINDTRICK]), F_LSTRING},//name of script to run
+	{"script_targetname", FOFS(script_targetname), F_LSTRING},//scripts look for this when "affecting"
+	//For NPCs
+	//{"playerTeam", FOFS(playerTeam), F_INT},
+	//{"enemyTeam", FOFS(enemyTeam), F_INT},
+	{"NPC_targetname", FOFS(NPC_targetname), F_LSTRING},
+	{"NPC_target", FOFS(NPC_target), F_LSTRING},
+	{"NPC_target2", FOFS(target2), F_LSTRING},//NPC_spawner only
+	{"NPC_target4", FOFS(target4), F_LSTRING},//NPC_spawner only
+	{"NPC_type", FOFS(NPC_type), F_LSTRING},
+	{"ownername", FOFS(ownername), F_LSTRING},
+	//for saber
+	{"saberType", FOFS(NPC_type), F_LSTRING},
+	{"saberColor", FOFS(NPC_targetname), F_LSTRING},
+	{"saberSolo", FOFS(alt_fire), F_INT},
+	//freaky camera shit
+	{"startRGBA", FOFS(startRGBA), F_VECTOR4},
+	{"finalRGBA", FOFS(finalRGBA), F_VECTOR4},
+//MCG - End
+
+	{"soundSet", FOFS(soundSet), F_LSTRING},
+	{"mass", FOFS(mass), F_FLOAT},		//really only used for pushable misc_model_breakables
+	
+//q3map stuff
+	{"scale", 0, F_IGNORE},
+	{"modelscale", 0, F_IGNORE},
+	{"modelscale_vec", 0, F_IGNORE},
+	{"style", 0, F_IGNORE},
+	{"lip", 0, F_IGNORE},
+	{"switch_style", 0, F_IGNORE},
+	{"height", 0, F_IGNORE},
+	{"noise", 0, F_IGNORE},	//SP_target_speaker
+	{"gravity", 0, F_IGNORE},	//SP_target_gravity_change
+
+	{"storyhead", 0, F_IGNORE},		//SP_target_level_change
+	{"tier_storyinfo", 0, F_IGNORE},	//SP_target_level_change
+	{"zoffset", 0, F_IGNORE},		//used by misc_model_static
+	{"music", 0, F_IGNORE},		//used by target_play_music
+	{"forcevisible", 0, F_IGNORE},		//for force sight on multiple model entities
+	{"redcrosshair", 0, F_IGNORE},		//for red crosshairs on breakables
+	{"nodelay", 0, F_IGNORE},		//for Reborn & Cultist NPCs
+
+	{NULL}
+};
+
+
+typedef struct {
+	char	*name;
+	void	(*spawn)(gentity_t *ent);
+} spawn_t;
+
+void SP_info_player_start (gentity_t *ent);
+void SP_info_player_deathmatch (gentity_t *ent);
+void SP_info_player_intermission (gentity_t *ent);
+void SP_info_firstplace(gentity_t *ent);
+void SP_info_secondplace(gentity_t *ent);
+void SP_info_thirdplace(gentity_t *ent);
+
+void SP_func_plat (gentity_t *ent);
+void SP_func_static (gentity_t *ent);
+void SP_func_rotating (gentity_t *ent);
+void SP_func_bobbing (gentity_t *ent);
+void SP_func_breakable (gentity_t *self);
+void SP_func_glass( gentity_t *self );
+void SP_func_pendulum( gentity_t *ent );
+void SP_func_button (gentity_t *ent);
+void SP_func_door (gentity_t *ent);
+void SP_func_train (gentity_t *ent);
+void SP_func_timer (gentity_t *self);
+void SP_func_wall (gentity_t *ent);
+void SP_func_usable( gentity_t *self );
+void SP_rail_mover( gentity_t *self );
+void SP_rail_track( gentity_t *self );
+void SP_rail_lane( gentity_t *self );
+
+
+
+void SP_trigger_always (gentity_t *ent);
+void SP_trigger_multiple (gentity_t *ent);
+void SP_trigger_once (gentity_t *ent);
+void SP_trigger_push (gentity_t *ent);
+void SP_trigger_teleport (gentity_t *ent);
+void SP_trigger_hurt (gentity_t *ent);
+void SP_trigger_bidirectional (gentity_t *ent);
+void SP_trigger_entdist (gentity_t *self);
+void SP_trigger_location( gentity_t *ent );
+void SP_trigger_visible( gentity_t *self );
+void SP_trigger_space(gentity_t *self);
+void SP_trigger_shipboundary(gentity_t *self);
+
+void SP_target_give (gentity_t *ent);
+void SP_target_delay (gentity_t *ent);
+void SP_target_speaker (gentity_t *ent);
+void SP_target_print (gentity_t *ent);
+void SP_target_laser (gentity_t *self);
+void SP_target_character (gentity_t *ent);
+void SP_target_score( gentity_t *ent );
+void SP_target_teleporter( gentity_t *ent );
+void SP_target_relay (gentity_t *ent);
+void SP_target_kill (gentity_t *ent);
+void SP_target_position (gentity_t *ent);
+void SP_target_location (gentity_t *ent);
+void SP_target_push (gentity_t *ent);
+void SP_target_random (gentity_t *self);
+void SP_target_counter (gentity_t *self);
+void SP_target_scriptrunner (gentity_t *self);
+void SP_target_interest (gentity_t *self);
+void SP_target_activate (gentity_t *self);
+void SP_target_deactivate (gentity_t *self);
+void SP_target_gravity_change( gentity_t *self );
+void SP_target_friction_change( gentity_t *self );
+void SP_target_level_change( gentity_t *self );
+void SP_target_change_parm( gentity_t *self );
+void SP_target_play_music( gentity_t *self );
+void SP_target_autosave( gentity_t *self );
+void SP_target_secret( gentity_t *self );
+
+void SP_light (gentity_t *self);
+void SP_info_null (gentity_t *self);
+void SP_info_notnull (gentity_t *self);
+void SP_path_corner (gentity_t *self);
+
+void SP_misc_teleporter (gentity_t *self);
+void SP_misc_teleporter_dest (gentity_t *self);
+void SP_misc_model(gentity_t *ent);
+void SP_misc_model_static(gentity_t *ent);
+void SP_misc_turret (gentity_t *base);
+void SP_misc_ns_turret (gentity_t *base);
+void SP_laser_arm (gentity_t *base);
+void SP_misc_ion_cannon( gentity_t *ent );
+void SP_misc_maglock( gentity_t *ent );
+void SP_misc_panel_turret( gentity_t *ent );
+void SP_misc_model_welder( gentity_t *ent );
+void SP_misc_model_jabba_cam( gentity_t *ent );
+
+void SP_misc_model_shield_power_converter( gentity_t *ent );
+void SP_misc_model_ammo_power_converter( gentity_t *ent );
+void SP_misc_model_bomb_planted( gentity_t *ent );
+void SP_misc_model_beacon( gentity_t *ent );
+
+void SP_misc_shield_floor_unit( gentity_t *ent );
+void SP_misc_ammo_floor_unit( gentity_t *ent );
+
+void SP_misc_model_gun_rack( gentity_t *ent );
+void SP_misc_model_ammo_rack( gentity_t *ent );
+void SP_misc_model_cargo_small( gentity_t *ent );
+
+void SP_misc_exploding_crate( gentity_t *ent );
+void SP_misc_gas_tank( gentity_t *ent );
+void SP_misc_crystal_crate( gentity_t *ent );
+void SP_misc_atst_drivable( gentity_t *ent );
+
+void SP_misc_model_breakable(gentity_t *ent);//stays as an ent
+void SP_misc_model_ghoul(gentity_t *ent);//stays as an ent
+void SP_misc_portal_camera(gentity_t *ent);
+
+void SP_misc_bsp(gentity_t *ent);
+void SP_terrain(gentity_t *ent);
+void SP_misc_skyportal (gentity_t *ent);
+
+void SP_misc_portal_surface(gentity_t *ent);
+void SP_misc_camera_focus (gentity_t *self);
+void SP_misc_camera_track (gentity_t *self);
+void SP_misc_dlight (gentity_t *ent);
+void SP_misc_security_panel (gentity_t *ent);
+void SP_misc_camera( gentity_t *ent );
+void SP_misc_spotlight( gentity_t *ent );
+
+void SP_shooter_rocket( gentity_t *ent );
+void SP_shooter_plasma( gentity_t *ent );
+void SP_shooter_grenade( gentity_t *ent );
+void SP_misc_replicator_item( gentity_t *ent );
+void SP_misc_trip_mine( gentity_t *self );
+void SP_PAS( gentity_t *ent );
+void SP_misc_weapon_shooter( gentity_t *self );
+void SP_misc_weather_zone( gentity_t *ent );
+
+//New spawn functions
+void SP_reference_tag ( gentity_t *ent );
+
+void SP_NPC_spawner( gentity_t *self );
+
+void SP_NPC_Vehicle( gentity_t *self );
+void SP_NPC_Player( gentity_t *self );
+void SP_NPC_Kyle( gentity_t *self );
+void SP_NPC_Lando( gentity_t *self );
+void SP_NPC_Jan( gentity_t *self );
+void SP_NPC_Luke( gentity_t *self );
+void SP_NPC_MonMothma( gentity_t *self );
+void SP_NPC_Rosh_Penin( gentity_t *self );
+void SP_NPC_Tavion( gentity_t *self );
+void SP_NPC_Tavion_New( gentity_t *self );
+void SP_NPC_Alora( gentity_t *self );
+void SP_NPC_Reelo( gentity_t *self );
+void SP_NPC_Galak( gentity_t *self );
+void SP_NPC_Desann( gentity_t *self );
+void SP_NPC_Rax( gentity_t *self );
+void SP_NPC_BobaFett( gentity_t *self );
+void SP_NPC_Ragnos( gentity_t *self );
+void SP_NPC_Lannik_Racto( gentity_t *self );
+void SP_NPC_Kothos( gentity_t *self );
+void SP_NPC_Chewbacca( gentity_t *self );
+void SP_NPC_Bartender( gentity_t *self );
+void SP_NPC_MorganKatarn( gentity_t *self );
+void SP_NPC_Jedi( gentity_t *self );
+void SP_NPC_Prisoner( gentity_t *self );
+void SP_NPC_Merchant( gentity_t *self );
+void SP_NPC_Rebel( gentity_t *self );
+void SP_NPC_Human_Merc( gentity_t *self );
+void SP_NPC_Stormtrooper( gentity_t *self );
+void SP_NPC_StormtrooperOfficer( gentity_t *self );
+void SP_NPC_Tie_Pilot( gentity_t *self );
+void SP_NPC_Snowtrooper( gentity_t *self );
+void SP_NPC_RocketTrooper( gentity_t *self);
+void SP_NPC_HazardTrooper( gentity_t *self);
+void SP_NPC_Ugnaught( gentity_t *self );
+void SP_NPC_Jawa( gentity_t *self );
+void SP_NPC_Gran( gentity_t *self );
+void SP_NPC_Rodian( gentity_t *self );
+void SP_NPC_Weequay( gentity_t *self );
+void SP_NPC_Trandoshan( gentity_t *self );
+void SP_NPC_Tusken( gentity_t *self );
+void SP_NPC_Noghri( gentity_t *self );
+void SP_NPC_SwampTrooper( gentity_t *self );
+void SP_NPC_Imperial( gentity_t *self );
+void SP_NPC_ImpWorker( gentity_t *self );
+void SP_NPC_BespinCop( gentity_t *self );
+void SP_NPC_Reborn( gentity_t *self );
+void SP_NPC_Reborn_New( gentity_t *self);
+void SP_NPC_Cultist( gentity_t *self );
+void SP_NPC_Cultist_Saber( gentity_t *self );
+void SP_NPC_Cultist_Saber_Powers( gentity_t *self );
+void SP_NPC_Cultist_Destroyer( gentity_t *self );
+void SP_NPC_Cultist_Commando( gentity_t *self );
+void SP_NPC_ShadowTrooper( gentity_t *self );
+void SP_NPC_Saboteur( gentity_t *self );
+void SP_NPC_Monster_Murjj( gentity_t *self );
+void SP_NPC_Monster_Swamp( gentity_t *self );
+void SP_NPC_Monster_Howler( gentity_t *self );
+void SP_NPC_Monster_Rancor( gentity_t *self );
+void SP_NPC_Monster_Mutant_Rancor( gentity_t *self );
+void SP_NPC_Monster_Wampa( gentity_t *self );
+void SP_NPC_Monster_Claw( gentity_t *self );
+void SP_NPC_Monster_Glider( gentity_t *self );
+void SP_NPC_Monster_Flier2( gentity_t *self );
+void SP_NPC_Monster_Lizard( gentity_t *self );
+void SP_NPC_Monster_Fish( gentity_t *self );
+void SP_NPC_Monster_Sand_Creature( gentity_t *self );
+void SP_NPC_MineMonster( gentity_t *self );
+void SP_NPC_Droid_Interrogator( gentity_t *self );
+void SP_NPC_Droid_Probe( gentity_t *self );
+void SP_NPC_Droid_Mark1( gentity_t *self );
+void SP_NPC_Droid_Mark2( gentity_t *self );
+void SP_NPC_Droid_ATST( gentity_t *self );
+void SP_NPC_Droid_Seeker( gentity_t *self );
+void SP_NPC_Droid_Remote( gentity_t *self );
+void SP_NPC_Droid_Sentry( gentity_t *self );
+void SP_NPC_Droid_Gonk( gentity_t *self );
+void SP_NPC_Droid_Mouse( gentity_t *self );
+void SP_NPC_Droid_R2D2( gentity_t *self );
+void SP_NPC_Droid_R5D2( gentity_t *self );
+void SP_NPC_Droid_Protocol( gentity_t *self );
+void SP_NPC_Droid_Assassin( gentity_t *self);
+void SP_NPC_Droid_Saber( gentity_t *self);
+
+void SP_waypoint (gentity_t *ent);
+void SP_waypoint_small (gentity_t *ent);
+void SP_waypoint_navgoal (gentity_t *ent);
+
+void SP_fx_runner( gentity_t *ent );
+void SP_fx_explosion_trail( gentity_t *ent );
+void SP_fx_target_beam( gentity_t *ent );
+void SP_fx_cloudlayer( gentity_t *ent );
+
+void SP_CreateSnow( gentity_t *ent );
+void SP_CreateRain( gentity_t *ent );
+void SP_CreateWind( gentity_t *ent );
+void SP_CreateWindZone( gentity_t *ent );
+// Added 10/20/02 by Aurelio Reis
+void SP_CreatePuffSystem( gentity_t *ent );
+
+void SP_object_cargo_barrel1( gentity_t *ent );
+
+void SP_point_combat (gentity_t *self);
+
+void SP_emplaced_eweb( gentity_t *self );
+void SP_emplaced_gun( gentity_t *self );
+
+void SP_misc_turbobattery( gentity_t *base );
+
+
+spawn_t	spawns[] = {
+	{"info_player_start", SP_info_player_start},
+	{"info_player_deathmatch", SP_info_player_deathmatch},
+
+	{"func_plat", SP_func_plat},
+	{"func_button", SP_func_button},
+	{"func_door", SP_func_door},
+	{"func_static", SP_func_static},
+	{"func_rotating", SP_func_rotating},
+	{"func_bobbing", SP_func_bobbing},
+	{"func_breakable", SP_func_breakable},
+	{"func_pendulum", SP_func_pendulum},
+	{"func_train", SP_func_train},
+	{"func_timer", SP_func_timer},			// rename trigger_timer?
+	{"func_wall", SP_func_wall},
+	{"func_usable", SP_func_usable},
+	{"func_glass", SP_func_glass},
+
+	{"rail_mover", SP_rail_mover},
+	{"rail_track", SP_rail_track},
+	{"rail_lane", SP_rail_lane},
+
+	{"trigger_always", SP_trigger_always},
+	{"trigger_multiple", SP_trigger_multiple},
+	{"trigger_once", SP_trigger_once},
+	{"trigger_push", SP_trigger_push},
+	{"trigger_teleport", SP_trigger_teleport},
+	{"trigger_hurt", SP_trigger_hurt},
+	{"trigger_bidirectional", SP_trigger_bidirectional},
+	{"trigger_entdist", SP_trigger_entdist},
+	{"trigger_location", SP_trigger_location},
+	{"trigger_visible", SP_trigger_visible},
+	{"trigger_space", SP_trigger_space},
+	{"trigger_shipboundary", SP_trigger_shipboundary},
+
+	{"target_give", SP_target_give},
+	{"target_delay", SP_target_delay},
+	{"target_speaker", SP_target_speaker},
+	{"target_print", SP_target_print},
+	{"target_laser", SP_target_laser},
+	{"target_score", SP_target_score},
+	{"target_teleporter", SP_target_teleporter},
+	{"target_relay", SP_target_relay},
+	{"target_kill", SP_target_kill},
+	{"target_position", SP_target_position},
+	{"target_location", SP_target_location},
+	{"target_push", SP_target_push},
+	{"target_random", SP_target_random},
+	{"target_counter", SP_target_counter},
+	{"target_scriptrunner", SP_target_scriptrunner},
+	{"target_interest", SP_target_interest},
+	{"target_activate", SP_target_activate},
+	{"target_deactivate", SP_target_deactivate},
+	{"target_gravity_change", SP_target_gravity_change},
+	{"target_friction_change", SP_target_friction_change},
+	{"target_level_change", SP_target_level_change},
+	{"target_change_parm", SP_target_change_parm},
+	{"target_play_music", SP_target_play_music},
+	{"target_autosave", SP_target_autosave},
+	{"target_secret", SP_target_secret},
+
+	{"light", SP_light},
+	{"info_null", SP_info_null},
+	{"func_group", SP_info_null},
+	{"info_notnull", SP_info_notnull},		// use target_position instead
+	{"path_corner", SP_path_corner},
+
+	{"misc_teleporter", SP_misc_teleporter},
+	{"misc_teleporter_dest", SP_misc_teleporter_dest},
+	{"misc_model", SP_misc_model},
+	{"misc_model_static", SP_misc_model_static},
+	{"misc_turret", SP_misc_turret},
+	{"misc_ns_turret", SP_misc_ns_turret},
+	{"misc_laser_arm", SP_laser_arm},
+	{"misc_ion_cannon", SP_misc_ion_cannon},
+	{"misc_sentry_turret", SP_PAS},
+	{"misc_maglock", SP_misc_maglock},
+	{"misc_weapon_shooter", SP_misc_weapon_shooter},
+	{"misc_weather_zone", SP_misc_weather_zone},
+	
+	{"misc_model_ghoul", SP_misc_model_ghoul},
+	{"misc_model_breakable", SP_misc_model_breakable},
+	{"misc_portal_surface", SP_misc_portal_surface},
+	{"misc_portal_camera", SP_misc_portal_camera},
+
+	{"misc_bsp",					SP_misc_bsp},
+	{"terrain",						SP_terrain},
+	{"misc_skyportal",				SP_misc_skyportal},
+
+	{"misc_camera_focus", SP_misc_camera_focus},
+	{"misc_camera_track", SP_misc_camera_track},
+	{"misc_dlight", SP_misc_dlight},
+	{"misc_replicator_item", SP_misc_replicator_item},
+	{"misc_trip_mine", SP_misc_trip_mine},
+	{"misc_security_panel", SP_misc_security_panel},
+	{"misc_camera", SP_misc_camera},
+	{"misc_spotlight", SP_misc_spotlight},
+	{"misc_panel_turret", SP_misc_panel_turret},
+	{"misc_model_welder", SP_misc_model_welder},
+	{"misc_model_jabba_cam", SP_misc_model_jabba_cam},
+	{"misc_model_shield_power_converter", SP_misc_model_shield_power_converter},
+	{"misc_model_ammo_power_converter", SP_misc_model_ammo_power_converter},
+	{"misc_model_bomb_planted", SP_misc_model_bomb_planted},
+	{"misc_model_beacon", SP_misc_model_beacon},
+	{"misc_shield_floor_unit", SP_misc_shield_floor_unit},
+	{"misc_ammo_floor_unit", SP_misc_ammo_floor_unit},
+
+	{"misc_model_gun_rack", SP_misc_model_gun_rack},
+	{"misc_model_ammo_rack", SP_misc_model_ammo_rack},
+	{"misc_model_cargo_small", SP_misc_model_cargo_small},
+
+	{"misc_exploding_crate", SP_misc_exploding_crate},
+	{"misc_gas_tank", SP_misc_gas_tank},
+	{"misc_crystal_crate", SP_misc_crystal_crate},
+	{"misc_atst_drivable", SP_misc_atst_drivable},
+	
+	{"shooter_rocket", SP_shooter_rocket},
+	{"shooter_grenade", SP_shooter_grenade},
+	{"shooter_plasma", SP_shooter_plasma},
+
+	{"ref_tag",	SP_reference_tag},
+
+	//new NPC ents
+	{"NPC_spawner", SP_NPC_spawner},
+
+	{"NPC_Vehicle", SP_NPC_Vehicle },
+	{"NPC_Player", SP_NPC_Player },
+	{"NPC_Kyle", SP_NPC_Kyle },
+	{"NPC_Lando", SP_NPC_Lando },
+	{"NPC_Jan", SP_NPC_Jan },
+	{"NPC_Luke", SP_NPC_Luke },
+	{"NPC_MonMothma", SP_NPC_MonMothma },
+	{"NPC_Rosh_Penin", SP_NPC_Rosh_Penin },
+	{"NPC_Tavion", SP_NPC_Tavion },
+	{"NPC_Tavion_New", SP_NPC_Tavion_New },
+	{"NPC_Alora", SP_NPC_Alora },
+	{"NPC_Reelo", SP_NPC_Reelo },
+	{"NPC_Galak", SP_NPC_Galak },
+	{"NPC_Desann", SP_NPC_Desann },
+	{"NPC_Rax", SP_NPC_Rax },
+	{"NPC_BobaFett", SP_NPC_BobaFett },
+	{"NPC_Ragnos", SP_NPC_Ragnos },
+	{"NPC_Lannik_Racto", SP_NPC_Lannik_Racto },
+	{"NPC_Kothos", SP_NPC_Kothos },
+	{"NPC_Chewbacca", SP_NPC_Chewbacca },
+	{"NPC_Bartender", SP_NPC_Bartender },
+	{"NPC_MorganKatarn", SP_NPC_MorganKatarn },
+	{"NPC_Jedi", SP_NPC_Jedi },
+	{"NPC_Prisoner", SP_NPC_Prisoner },
+	{"NPC_Merchant", SP_NPC_Merchant },
+	{"NPC_Rebel", SP_NPC_Rebel },
+	{"NPC_Human_Merc", SP_NPC_Human_Merc },
+	{"NPC_Stormtrooper", SP_NPC_Stormtrooper },
+	{"NPC_StormtrooperOfficer", SP_NPC_StormtrooperOfficer },
+	{"NPC_Tie_Pilot", SP_NPC_Tie_Pilot },
+	{"NPC_Snowtrooper", SP_NPC_Snowtrooper },
+	{"NPC_RocketTrooper", SP_NPC_RocketTrooper },
+	{"NPC_HazardTrooper", SP_NPC_HazardTrooper },
+
+	{"NPC_Ugnaught", SP_NPC_Ugnaught },
+	{"NPC_Jawa", SP_NPC_Jawa },
+	{"NPC_Gran", SP_NPC_Gran },
+	{"NPC_Rodian", SP_NPC_Rodian },
+	{"NPC_Weequay", SP_NPC_Weequay },
+	{"NPC_Trandoshan", SP_NPC_Trandoshan },
+	{"NPC_Tusken", SP_NPC_Tusken },
+	{"NPC_Noghri", SP_NPC_Noghri },
+	{"NPC_SwampTrooper", SP_NPC_SwampTrooper },
+	{"NPC_Imperial", SP_NPC_Imperial },
+	{"NPC_ImpWorker", SP_NPC_ImpWorker },
+	{"NPC_BespinCop", SP_NPC_BespinCop },
+	{"NPC_Reborn", SP_NPC_Reborn },
+	{"NPC_Reborn_New", SP_NPC_Reborn_New },
+	{"NPC_Cultist", SP_NPC_Cultist },
+	{"NPC_Cultist_Saber", SP_NPC_Cultist_Saber },
+	{"NPC_Cultist_Saber_Powers", SP_NPC_Cultist_Saber_Powers },
+	{"NPC_Cultist_Destroyer", SP_NPC_Cultist_Destroyer },
+	{"NPC_Cultist_Commando", SP_NPC_Cultist_Commando },
+	{"NPC_ShadowTrooper", SP_NPC_ShadowTrooper },
+	{"NPC_Saboteur", SP_NPC_Saboteur },
+	{"NPC_Monster_Murjj", SP_NPC_Monster_Murjj },
+	{"NPC_Monster_Swamp", SP_NPC_Monster_Swamp },
+	{"NPC_Monster_Howler", SP_NPC_Monster_Howler },
+	{"NPC_Monster_Rancor", SP_NPC_Monster_Rancor },
+	{"NPC_Monster_Mutant_Rancor", SP_NPC_Monster_Mutant_Rancor },
+	{"NPC_Monster_Wampa", SP_NPC_Monster_Wampa },
+	{"NPC_MineMonster",	SP_NPC_MineMonster },
+	{"NPC_Monster_Claw", SP_NPC_Monster_Claw },
+	{"NPC_Monster_Glider", SP_NPC_Monster_Glider },
+	{"NPC_Monster_Flier2", SP_NPC_Monster_Flier2 },
+	{"NPC_Monster_Lizard", SP_NPC_Monster_Lizard },
+	{"NPC_Monster_Fish", SP_NPC_Monster_Fish },
+	{"NPC_Monster_Sand_Creature", SP_NPC_Monster_Sand_Creature },
+	{"NPC_Droid_Interrogator", SP_NPC_Droid_Interrogator },
+	{"NPC_Droid_Probe", SP_NPC_Droid_Probe },
+	{"NPC_Droid_Mark1", SP_NPC_Droid_Mark1 },
+	{"NPC_Droid_Mark2", SP_NPC_Droid_Mark2 },
+	{"NPC_Droid_ATST", SP_NPC_Droid_ATST },
+	{"NPC_Droid_Seeker", SP_NPC_Droid_Seeker },
+	{"NPC_Droid_Remote", SP_NPC_Droid_Remote },
+	{"NPC_Droid_Sentry", SP_NPC_Droid_Sentry },
+	{"NPC_Droid_Gonk", SP_NPC_Droid_Gonk },
+	{"NPC_Droid_Mouse", SP_NPC_Droid_Mouse },
+	{"NPC_Droid_R2D2", SP_NPC_Droid_R2D2 },
+	{"NPC_Droid_R5D2", SP_NPC_Droid_R5D2 },
+	{"NPC_Droid_Protocol", SP_NPC_Droid_Protocol },
+	{"NPC_Droid_Assassin", SP_NPC_Droid_Assassin },
+	{"NPC_Droid_Saber", SP_NPC_Droid_Saber },
+
+	//rwwFIXMEFIXME: Faked for testing NPCs (another other things) in RMG with sof2 assets
+	{"NPC_Colombian_Soldier", SP_NPC_Reborn },
+	{"NPC_Colombian_Rebel", SP_NPC_Reborn },
+	{"NPC_Colombian_EmplacedGunner", SP_NPC_ShadowTrooper },
+	{"NPC_Manuel_Vergara_RMG", SP_NPC_Desann },
+//	{"info_NPCnav", SP_waypoint},
+
+	{"waypoint", SP_waypoint},
+	{"waypoint_small", SP_waypoint_small},
+	{"waypoint_navgoal", SP_waypoint_navgoal},
+	
+	{"fx_runner", SP_fx_runner},
+	{"fx_explosion_trail", SP_fx_explosion_trail},
+	{"fx_target_beam", SP_fx_target_beam},
+	{"fx_cloudlayer", SP_fx_cloudlayer},
+	{"fx_rain", SP_CreateRain},
+	{"fx_wind", SP_CreateWind},
+	{"fx_snow", SP_CreateSnow},
+	{"fx_puff", SP_CreatePuffSystem},
+	{"fx_wind_zone", SP_CreateWindZone},
+
+	{"object_cargo_barrel1", SP_object_cargo_barrel1},
+	{"point_combat", SP_point_combat},
+
+	{"emplaced_gun", SP_emplaced_gun},
+	{"emplaced_eweb", SP_emplaced_eweb},
+
+	{NULL, NULL}
+};
+
+/*
+===============
+G_CallSpawn
+
+Finds the spawn function for the entity and calls it,
+returning qfalse if not found
+===============
+*/
+qboolean G_CallSpawn( gentity_t *ent ) {
+	spawn_t	*s;
+	gitem_t	*item;
+
+	if ( !ent->classname ) {
+		gi.Printf (S_COLOR_RED"G_CallSpawn: NULL classname\n");
+		return qfalse;
+	}
+
+	// check item spawn functions
+	for ( item=bg_itemlist+1 ; item->classname ; item++ ) {
+		if ( !strcmp(item->classname, ent->classname) ) {
+			// found it
+			G_SpawnItem( ent, item );
+			return qtrue;
+		}
+	}
+
+	// check normal spawn functions
+	for ( s=spawns ; s->name ; s++ ) {
+		if ( !strcmp(s->name, ent->classname) ) {
+			// found it
+			s->spawn(ent);
+			return qtrue;
+		}
+	}
+	char* str;
+	G_SpawnString( "origin", "?", &str );
+	gi.Printf (S_COLOR_RED"ERROR: %s is not a spawn function @(%s)\n", ent->classname, str);
+	delayedShutDown = level.time + 100;
+	return qfalse;
+}
+
+/*
+=============
+G_NewString
+
+Builds a copy of the string, translating \n to real linefeeds
+so message texts can be multi-line
+=============
+*/
+char *G_NewString( const char *string ) {
+	char	*newb, *new_p;
+	int		i,l;
+
+	if(!string || !string[0])
+	{
+		//gi.Printf(S_COLOR_RED"Error: G_NewString called with NULL string!\n");
+		return NULL;
+	}
+
+	l = strlen(string) + 1;
+
+	newb = (char *) G_Alloc( l );
+
+	new_p = newb;
+
+	// turn \n into a real linefeed
+	for ( i=0 ; i< l ; i++ ) {
+		if (string[i] == '\\' && i < l-1) {
+			i++;
+			if (string[i] == 'n') {
+				*new_p++ = '\n';
+			} else {
+				*new_p++ = '\\';
+			}
+		} else {
+			*new_p++ = string[i];
+		}
+	}
+	
+	return newb;
+}
+
+
+
+
+/*
+===============
+G_ParseField
+
+Takes a key/value pair and sets the binary values
+in a gentity
+===============
+*/
+void Q3_SetParm (int entID, int parmNum, const char *parmValue);
+void G_ParseField( const char *key, const char *value, gentity_t *ent ) {
+	field_t	*f;
+	byte	*b;
+	float	v;
+	vec3_t	vec;
+	vec4_t	vec4;
+
+	for ( f=fields ; f->name ; f++ ) {
+		if ( !Q_stricmp(f->name, key) ) {
+			// found it
+			b = (byte *)ent;
+
+			switch( f->type ) {
+			case F_LSTRING:
+				*(char **)(b+f->ofs) = G_NewString (value);
+				break;
+			case F_VECTOR:
+			{
+				int _iFieldsRead = sscanf (value, "%f %f %f", &vec[0], &vec[1], &vec[2]);
+				assert(_iFieldsRead==3);
+				if (_iFieldsRead!=3)
+				{
+					gi.Printf (S_COLOR_YELLOW"G_ParseField: VEC3 sscanf() failed to read 3 floats ('angle' key bug?)\n");
+					delayedShutDown = level.time + 100;
+				}
+				((float *)(b+f->ofs))[0] = vec[0];
+				((float *)(b+f->ofs))[1] = vec[1];
+				((float *)(b+f->ofs))[2] = vec[2];
+				break;
+			}
+			case F_VECTOR4:
+			{
+				int _iFieldsRead =  sscanf (value, "%f %f %f %f", &vec4[0], &vec4[1], &vec4[2], &vec4[3]);
+				assert(_iFieldsRead==4);
+				if (_iFieldsRead!=4)
+				{
+					gi.Printf (S_COLOR_YELLOW"G_ParseField: VEC4 sscanf() failed to read 4 floats\n");
+					delayedShutDown = level.time + 100;
+				}
+				((float *)(b+f->ofs))[0] = vec4[0];
+				((float *)(b+f->ofs))[1] = vec4[1];
+				((float *)(b+f->ofs))[2] = vec4[2];
+				((float *)(b+f->ofs))[3] = vec4[3];
+				break;
+			}
+			case F_INT:
+				*(int *)(b+f->ofs) = atoi(value);
+				break;
+			case F_FLOAT:
+				*(float *)(b+f->ofs) = atof(value);
+				break;
+			case F_ANGLEHACK:
+				v = atof(value);
+				((float *)(b+f->ofs))[0] = 0;
+				((float *)(b+f->ofs))[1] = v;
+				((float *)(b+f->ofs))[2] = 0;
+				break;
+			case F_PARM1:
+			case F_PARM2:
+			case F_PARM3:
+			case F_PARM4:
+			case F_PARM5:
+			case F_PARM6:
+			case F_PARM7:
+			case F_PARM8:
+			case F_PARM9:
+			case F_PARM10:
+			case F_PARM11:
+			case F_PARM12:
+			case F_PARM13:
+			case F_PARM14:
+			case F_PARM15:
+			case F_PARM16:
+				Q3_SetParm( ent->s.number, (f->type - F_PARM1), (char *) value );
+				break;
+			case F_FLAG:
+				{//try to find the proper flag for that key:
+					int flag = GetIDForString ( flagTable, key );
+
+					if ( flag > 0 )
+					{
+						G_SpawnFlag( key, flag, (int *)(b+f->ofs) );
+					}
+					else
+					{
+#ifndef FINAL_BUILD
+						gi.Printf (S_COLOR_YELLOW"WARNING: G_ParseField: can't find flag for key %s\n", key);
+#endif
+					}
+				}
+				break;
+			default:
+			case F_IGNORE:
+				break;
+			}
+			return;
+		}
+	}
+#ifndef FINAL_BUILD
+	//didn't find it?
+	if (key[0]!='_')
+	{
+		gi.Printf ( S_COLOR_YELLOW"WARNING: G_ParseField: no such field: %s\n", key );
+	}
+#endif
+}
+
+static qboolean SpawnForCurrentDifficultySetting( gentity_t *ent )
+{
+extern cvar_t	*com_buildScript;
+	if (com_buildScript->integer) {	//always spawn when building a pak file
+		return qtrue;
+	}
+	if ( ent->spawnflags & ( 1 << (8 + g_spskill->integer )) )	{// easy -256	medium -512		hard -1024
+		return qfalse;
+	} else {
+		return qtrue;
+	}
+}
+
+/*
+===================
+G_SpawnGEntityFromSpawnVars
+
+Spawn an entity and fill in all of the level fields from
+level.spawnVars[], then call the class specfic spawn function
+===================
+*/
+
+void G_SpawnGEntityFromSpawnVars( void ) {
+	int			i;
+	gentity_t	*ent;
+
+	// get the next free entity
+	ent = G_Spawn();
+
+	for ( i = 0 ; i < numSpawnVars ; i++ ) {
+		G_ParseField( spawnVars[i][0], spawnVars[i][1], ent );
+	}
+
+	G_SpawnInt( "notsingle", "0", &i );
+	if ( i || !SpawnForCurrentDifficultySetting( ent ) ) {
+		G_FreeEntity( ent );
+		return;
+	}
+
+	// move editor origin to pos
+	VectorCopy( ent->s.origin, ent->s.pos.trBase );
+	VectorCopy( ent->s.origin, ent->currentOrigin );
+
+	// if we didn't get a classname, don't bother spawning anything
+	if ( !G_CallSpawn( ent ) ) {
+		G_FreeEntity( ent );
+		return;
+	}
+
+	//Tag on the ICARUS scripting information only to valid recipients
+	if ( Quake3Game()->ValidEntity( ent ) )
+	{
+		Quake3Game()->InitEntity( ent ); //ICARUS_InitEnt( ent );
+		
+		if ( ent->classname && ent->classname[0] )
+		{
+			if ( Q_strncmp( "NPC_", ent->classname, 4 ) != 0 )
+			{//Not an NPC_spawner
+				G_ActivateBehavior( ent, BSET_SPAWN );
+			}
+		}
+	}
+}
+
+void G_SpawnSubBSPGEntityFromSpawnVars( vec3_t posOffset, vec3_t angOffset ) {
+	int			i;
+	gentity_t	*ent;
+
+	// get the next free entity
+	ent = G_Spawn();
+
+	for ( i = 0 ; i < numSpawnVars ; i++ ) {
+		G_ParseField( spawnVars[i][0], spawnVars[i][1], ent );
+	}
+
+	G_SpawnInt( "notsingle", "0", &i );
+	if ( i || !SpawnForCurrentDifficultySetting( ent ) ) {
+		G_FreeEntity( ent );
+		return;
+	}
+
+	VectorAdd(ent->s.origin, posOffset, ent->s.origin);
+	VectorAdd(ent->s.angles, angOffset, ent->s.angles);
+
+	VectorCopy(ent->s.angles, ent->s.apos.trBase);
+	VectorCopy(ent->s.angles, ent->currentAngles);
+
+	// move editor origin to pos
+	VectorCopy( ent->s.origin, ent->s.pos.trBase );
+	VectorCopy( ent->s.origin, ent->currentOrigin );
+
+	// if we didn't get a classname, don't bother spawning anything
+	if ( !G_CallSpawn( ent ) ) {
+		G_FreeEntity( ent );
+		return;
+	}
+
+	//Tag on the ICARUS scripting information only to valid recipients
+	if ( Quake3Game()->ValidEntity( ent ) )
+	{
+		
+		Quake3Game()->InitEntity( ent ); // ICARUS_InitEnt( ent );
+
+		if ( ent->classname && ent->classname[0] )
+		{
+			if ( Q_strncmp( "NPC_", ent->classname, 4 ) != 0 )
+			{//Not an NPC_spawner
+				G_ActivateBehavior( ent, BSET_SPAWN );
+			}
+		}
+	}
+}
+
+
+/*
+====================
+G_AddSpawnVarToken
+====================
+*/
+char *G_AddSpawnVarToken( const char *string ) {
+	int		l;
+	char	*dest;
+
+	l = strlen( string );
+	if ( numSpawnVarChars + l + 1 > MAX_SPAWN_VARS_CHARS ) {
+		G_Error( "G_AddSpawnVarToken: MAX_SPAWN_VARS" );
+	}
+
+	dest = spawnVarChars + numSpawnVarChars;
+	memcpy( dest, string, l+1 );
+
+	numSpawnVarChars += l + 1;
+
+	return dest;
+}
+
+/*
+====================
+G_ParseSpawnVars
+
+Parses a brace bounded set of key / value pairs out of the
+level's entity strings into level.spawnVars[]
+
+This does not actually spawn an entity.
+====================
+*/
+qboolean G_ParseSpawnVars( const char **data ) {
+	char		keyname[MAX_STRING_CHARS];
+	const char	*com_token;
+
+	numSpawnVars = 0;
+	numSpawnVarChars = 0;
+
+	// parse the opening brace	
+	com_token = COM_Parse( data );
+	if ( !*data ) {
+		// end of spawn string
+		return qfalse;
+	}
+	if ( com_token[0] != '{' ) {
+		G_Error( "G_ParseSpawnVars: found %s when expecting {",com_token );
+	}
+
+	// go through all the key / value pairs
+	while ( 1 ) {	
+		// parse key
+		com_token = COM_Parse( data );
+		if ( com_token[0] == '}' ) {
+			break;
+		}
+		if ( !data ) {
+			G_Error( "G_ParseSpawnVars: EOF without closing brace" );
+		}
+
+		Q_strncpyz( keyname, com_token, sizeof(keyname) );
+		
+		// parse value	
+		com_token = COM_Parse( data );
+		if ( com_token[0] == '}' ) {
+			G_Error( "G_ParseSpawnVars: closing brace without data" );
+		}
+		if ( !data ) {
+			G_Error( "G_ParseSpawnVars: EOF without closing brace" );
+		}
+		if ( numSpawnVars == MAX_SPAWN_VARS ) {
+			G_Error( "G_ParseSpawnVars: MAX_SPAWN_VARS" );
+		}
+		spawnVars[ numSpawnVars ][0] = G_AddSpawnVarToken( keyname );
+		spawnVars[ numSpawnVars ][1] = G_AddSpawnVarToken( com_token );
+		numSpawnVars++;
+	}
+
+	return qtrue;
+}
+
+static	char *defaultStyles[LS_NUM_STYLES][3] = 
+{
+	{	// 0 normal
+		"z",
+		"z",
+		"z"
+	},
+	{	// 1 FLICKER (first variety)
+		"mmnmmommommnonmmonqnmmo",
+		"mmnmmommommnonmmonqnmmo",
+		"mmnmmommommnonmmonqnmmo"
+	},
+	{	// 2 SLOW STRONG PULSE
+		"abcdefghijklmnopqrstuvwxyzyxwvutsrqponmlkjihgfedcb",
+		"abcdefghijklmnopqrstuvwxyzyxwvutsrqponmlkjihgfedcb",
+		"abcdefghijklmnopqrstuvwxyzyxwvutsrqponmlkjihgfedcb"
+	},
+	{	// 3 CANDLE (first variety)
+		"mmmmmaaaaammmmmaaaaaabcdefgabcdefg",
+		"mmmmmaaaaammmmmaaaaaabcdefgabcdefg",
+		"mmmmmaaaaammmmmaaaaaabcdefgabcdefg"
+	},
+	{	// 4 FAST STROBE
+		"mamamamamama",
+		"mamamamamama",
+		"mamamamamama"
+	},
+	{	// 5 GENTLE PULSE 1
+		"jklmnopqrstuvwxyzyxwvutsrqponmlkj",
+		"jklmnopqrstuvwxyzyxwvutsrqponmlkj",
+		"jklmnopqrstuvwxyzyxwvutsrqponmlkj"
+	},
+	{	// 6 FLICKER (second variety)
+		"nmonqnmomnmomomno",
+		"nmonqnmomnmomomno",
+		"nmonqnmomnmomomno"
+	},
+	{	// 7 CANDLE (second variety)
+		"mmmaaaabcdefgmmmmaaaammmaamm",
+		"mmmaaaabcdefgmmmmaaaammmaamm",
+		"mmmaaaabcdefgmmmmaaaammmaamm"
+	},
+	{	// 8 CANDLE (third variety)
+		"mmmaaammmaaammmabcdefaaaammmmabcdefmmmaaaa",
+		"mmmaaammmaaammmabcdefaaaammmmabcdefmmmaaaa",
+		"mmmaaammmaaammmabcdefaaaammmmabcdefmmmaaaa"
+	},
+	{	// 9 SLOW STROBE (fourth variety)
+		"aaaaaaaazzzzzzzz",
+		"aaaaaaaazzzzzzzz",
+		"aaaaaaaazzzzzzzz"
+	},
+	{	// 10 FLUORESCENT FLICKER
+		"mmamammmmammamamaaamammma",
+		"mmamammmmammamamaaamammma",
+		"mmamammmmammamamaaamammma"
+	},
+	{	// 11 SLOW PULSE NOT FADE TO BLACK
+		"abcdefghijklmnopqrrqponmlkjihgfedcba",
+		"abcdefghijklmnopqrrqponmlkjihgfedcba",
+		"abcdefghijklmnopqrrqponmlkjihgfedcba"
+	},
+	{	// 12 FAST PULSE FOR JEREMY
+		"mkigegik",
+		"mkigegik",
+		"mkigegik"
+	},
+	{	// 13 Test Blending
+		"abcdefghijklmqrstuvwxyz",
+		"zyxwvutsrqmlkjihgfedcba",
+		"aammbbzzccllcckkffyyggp"
+	},
+	{	// 14
+		"",
+		"",
+		""
+	},
+	{	// 15
+		"",
+		"",
+		""
+	},
+	{	// 16
+		"",
+		"",
+		""
+	},
+	{	// 17
+		"",
+		"",
+		""
+	},
+	{	// 18
+		"",
+		"",
+		""
+	},
+	{	// 19
+		"",
+		"",
+		""
+	},
+	{	// 20
+		"",
+		"",
+		""
+	},
+	{	// 21
+		"",
+		"",
+		""
+	},
+	{	// 22
+		"",
+		"",
+		""
+	},
+	{	// 23
+		"",
+		"",
+		""
+	},
+	{	// 24
+		"",
+		"",
+		""
+	},
+	{	// 25
+		"",
+		"",
+		""
+	},
+	{	// 26
+		"",
+		"",
+		""
+	},
+	{	// 27
+		"",
+		"",
+		""
+	},
+	{	// 28
+		"",
+		"",
+		""
+	},
+	{	// 29
+		"",
+		"",
+		""
+	},
+	{	// 30
+		"",
+		"",
+		""
+	},
+	{	// 31
+		"",
+		"",
+		""
+	}
+};
+
+
+/*QUAKED worldspawn (0 0 0) ?
+Every map should have exactly one worldspawn.
+"music"     path to WAV or MP3 files (e.g. "music\intro.mp3 music\loopfile.mp3")
+"gravity"   800 is default gravity
+"message"   Text to print during connection
+"soundSet"  Ambient sound set to play
+"spawnscript" runs this script
+
+BSP Options
+"gridsize"     size of lighting grid to "X Y Z". default="64 64 128"
+"ambient"      amount of global light to add to each surf (uses _color)
+"chopsize"     value for bsp on the maximum polygon / portal size
+"distancecull" value for vis for the maximum viewing distance
+"_minlight"   minimum lighting on a surf.  overrides _mingridlight and _minvertexlight
+
+Game Options
+"fog"          shader name of the global fog texture - must include the full path, such as "textures/rj/fog1"
+"ls_Xr"	override lightstyle X with this pattern for Red.
+"ls_Xg"	green (valid patterns are "a-z")
+"ls_Xb"	blue (a is OFF, z is ON)
+"breath"		Whether the entity's have breath puffs or not (0 = No, 1 = All, 2 = Just cold breath, 3 = Just under water bubbles ).
+"clearstats" default 1, if 0 loading this map will not clear the stats for player
+"tier_storyinfo" sets 'tier_storyinfo' cvar
+*/
+void SP_worldspawn( void ) {
+	char	*s;
+	int		i;
+
+	g_entities[ENTITYNUM_WORLD].max_health = 0;
+
+	for ( i = 0 ; i < numSpawnVars ; i++ ) 
+	{
+		if ( Q_stricmp( "spawnscript", spawnVars[i][0] ) == 0 )
+		{//ONly let them set spawnscript, we don't want them setting an angle or something on the world.
+			G_ParseField( spawnVars[i][0], spawnVars[i][1], &g_entities[ENTITYNUM_WORLD] );
+		}
+		if ( Q_stricmp( "region", spawnVars[i][0] ) == 0 )
+		{
+			g_entities[ENTITYNUM_WORLD].s.radius = atoi(spawnVars[i][1]);
+		}
+		if ( Q_stricmp( "distancecull", spawnVars[i][0] ) == 0 )
+		{
+			g_entities[ENTITYNUM_WORLD].max_health = (int)((float)(atoi(spawnVars[i][1])) * 0.7f);
+		}
+	}
+
+	G_SpawnString( "classname", "", &s );
+	if ( Q_stricmp( s, "worldspawn" ) ) {
+		G_Error( "SP_worldspawn: The first entity isn't 'worldspawn'" );
+	}
+
+	// make some data visible to connecting client
+	G_SpawnString( "music", "", &s );
+	gi.SetConfigstring( CS_MUSIC, s );
+
+	G_SpawnString( "message", "", &s );
+	gi.SetConfigstring( CS_MESSAGE, s );				// map specific message
+
+	G_SpawnString( "gravity", "800", &s );
+	extern SavedGameJustLoaded_e g_eSavedGameJustLoaded;
+	if (g_eSavedGameJustLoaded != eFULL)
+	{
+		gi.cvar_set( "g_gravity", s );
+	}
+
+	G_SpawnString( "soundSet", "default", &s );
+	gi.SetConfigstring( CS_AMBIENT_SET, s );
+
+	//Lightstyles
+	gi.SetConfigstring(CS_LIGHT_STYLES+(LS_STYLES_START*3)+0, defaultStyles[0][0]);
+	gi.SetConfigstring(CS_LIGHT_STYLES+(LS_STYLES_START*3)+1, defaultStyles[0][1]);
+	gi.SetConfigstring(CS_LIGHT_STYLES+(LS_STYLES_START*3)+2, defaultStyles[0][2]);
+
+	for(i=1;i<LS_NUM_STYLES;i++)
+	{
+		char	temp[32];
+		int		lengthRed, lengthBlue, lengthGreen;
+		Com_sprintf(temp, sizeof(temp), "ls_%dr", i);
+		G_SpawnString( temp, defaultStyles[i][0], &s );
+		lengthRed = strlen(s);
+		gi.SetConfigstring(CS_LIGHT_STYLES+((i+LS_STYLES_START)*3)+0, s);
+
+		Com_sprintf(temp, sizeof(temp), "ls_%dg", i);
+		G_SpawnString(temp, defaultStyles[i][1], &s);
+		lengthGreen = strlen(s);
+		gi.SetConfigstring(CS_LIGHT_STYLES+((i+LS_STYLES_START)*3)+1, s);
+
+		Com_sprintf(temp, sizeof(temp), "ls_%db", i);
+		G_SpawnString(temp, defaultStyles[i][2], &s);
+		lengthBlue = strlen(s);
+		gi.SetConfigstring(CS_LIGHT_STYLES+((i+LS_STYLES_START)*3)+2, s);
+
+		if (lengthRed != lengthGreen || lengthGreen != lengthBlue)
+		{
+			Com_Error(ERR_DROP, "Style %d has inconsistent lengths: R %d, G %d, B %d", 
+				i, lengthRed, lengthGreen, lengthBlue);
+		}
+	}	
+
+	G_SpawnString( "breath", "0", &s );
+	gi.cvar_set( "cg_drawBreath", s );
+
+	G_SpawnString( "clearstats", "1", &s );
+	gi.cvar_set( "g_clearstats", s );
+
+	if (G_SpawnString( "tier_storyinfo", "", &s )) 
+	{
+		gi.cvar_set( "tier_storyinfo", s );
+	}
+
+	g_entities[ENTITYNUM_WORLD].s.number = ENTITYNUM_WORLD;
+	g_entities[ENTITYNUM_WORLD].classname = "worldspawn";
+}
+
+/*
+-------------------------
+G_ParsePrecaches
+-------------------------
+*/
+
+void G_ParsePrecaches( void )
+{
+	gentity_t	*ent = NULL;
+
+	//Clear any old lists
+	if(!as_preCacheMap) {
+		as_preCacheMap = new namePrecache_m;
+	}
+
+	as_preCacheMap->clear();
+
+	for ( int i = 0; i < globals.num_entities; i++ )
+	{
+		ent = &g_entities[i];
+
+		if VALIDSTRING( ent->soundSet )
+		{
+			(*as_preCacheMap)[ (char *) ent->soundSet ] = 1;
+		}
+	}
+}
+
+
+void G_ASPreCacheFree(void)
+{
+	if(as_preCacheMap) {
+		delete as_preCacheMap;
+		as_preCacheMap = NULL;
+	}
+}
+
+/*
+==============
+G_SpawnEntitiesFromString
+
+Parses textual entity definitions out of an entstring and spawns gentities.
+==============
+*/
+extern int num_waypoints;
+extern void	RG_RouteGen(void);
+extern qboolean NPCsPrecached;
+
+qboolean SP_bsp_worldspawn ( void )
+{
+	return qtrue;
+}
+
+void G_SubBSPSpawnEntitiesFromString(const char *entityString, vec3_t posOffset, vec3_t angOffset) 
+{
+	const char		*entities;
+
+	entities = entityString;
+
+	// allow calls to G_Spawn*()
+	spawning = qtrue;
+	NPCsPrecached = qfalse;
+	numSpawnVars = 0;
+
+	// the worldspawn is not an actual entity, but it still
+	// has a "spawn" function to perform any global setup
+	// needed by a level (setting configstrings or cvars, etc)
+	if ( !G_ParseSpawnVars( &entities ) ) {
+		G_Error( "SpawnEntities: no entities" );
+	}
+	
+	// Skip this guy if its worldspawn fails
+	if ( !SP_bsp_worldspawn() )
+	{
+		return;
+	}
+
+	// parse ents
+	while( G_ParseSpawnVars(&entities) ) 
+	{
+		G_SpawnSubBSPGEntityFromSpawnVars(posOffset, angOffset);
+	}	
+}
+
+void G_SpawnEntitiesFromString( const char *entityString ) {
+	const char		*entities;
+
+	entities = entityString;
+
+	// allow calls to G_Spawn*()
+	spawning = qtrue;
+	NPCsPrecached = qfalse;
+	numSpawnVars = 0;
+
+	// the worldspawn is not an actual entity, but it still
+	// has a "spawn" function to perform any global setup
+	// needed by a level (setting configstrings or cvars, etc)
+	if ( !G_ParseSpawnVars( &entities ) ) {
+		G_Error( "SpawnEntities: no entities" );
+	}
+	
+	SP_worldspawn();
+
+	// parse ents
+	while( G_ParseSpawnVars( &entities ) ) 
+	{
+		G_SpawnGEntityFromSpawnVars();
+	}	
+
+	//Search the entities for precache information
+	G_ParsePrecaches();
+
+
+	if( g_entities[ENTITYNUM_WORLD].behaviorSet[BSET_SPAWN] && g_entities[ENTITYNUM_WORLD].behaviorSet[BSET_SPAWN][0] )
+	{//World has a spawn script, but we don't want the world in ICARUS and running scripts,
+		//so make a scriptrunner and start it going.
+		gentity_t *script_runner = G_Spawn();
+		if ( script_runner )
+		{
+			script_runner->behaviorSet[BSET_USE] = g_entities[ENTITYNUM_WORLD].behaviorSet[BSET_SPAWN];
+			script_runner->count = 1;
+			script_runner->e_ThinkFunc = thinkF_scriptrunner_run;
+			script_runner->nextthink = level.time + 100;
+
+			if ( Quake3Game()->ValidEntity( script_runner ) )
+			{
+				Quake3Game()->InitEntity( script_runner ); //ICARUS_InitEnt( script_runner );
+			}
+		}
+	}
+
+	//gi.Printf(S_COLOR_YELLOW"Total waypoints: %d\n", num_waypoints);
+	//Automatically run routegen
+	//RG_RouteGen();
+
+	spawning = qfalse;			// any future calls to G_Spawn*() will be errors
+
+	if ( g_delayedShutdown->integer && delayedShutDown )
+	{
+		assert(0);
+		G_Error( "Errors loading map, check the console for them." );
+	}
+}
+
diff --git a/code/game/g_svcmds.cpp b/code/game/g_svcmds.cpp
new file mode 100644
index 0000000..238fb7c
--- /dev/null
+++ b/code/game/g_svcmds.cpp
@@ -0,0 +1,1342 @@
+// leave this line at the top for all g_xxxx.cpp files...
+#include "g_headers.h"
+
+
+
+#include "Q3_Interface.h"
+
+#include "g_local.h"
+#include "wp_saber.h"
+
+extern void G_NextTestAxes( void );
+extern void G_ChangePlayerModel( gentity_t *ent, const char *newModel );
+extern void G_InitPlayerFromCvars( gentity_t *ent );
+extern void Q3_SetViewEntity(int entID, const char *name);
+extern qboolean G_ClearViewEntity( gentity_t *ent );
+extern void G_Knockdown( gentity_t *self, gentity_t *attacker, const vec3_t pushDir, float strength, qboolean breakSaberLock );
+
+extern void WP_SetSaber( gentity_t *ent, int saberNum, char *saberName );
+extern void WP_RemoveSaber( gentity_t *ent, int saberNum );
+extern saber_colors_t TranslateSaberColor( const char *name );
+
+extern void G_SetWeapon( gentity_t *self, int wp );
+extern stringID_table_t WPTable[];
+
+extern cvar_t	*g_char_model;
+extern cvar_t	*g_char_skin_head;
+extern cvar_t	*g_char_skin_torso;
+extern cvar_t	*g_char_skin_legs;
+extern cvar_t	*g_char_color_red;
+extern cvar_t	*g_char_color_green;
+extern cvar_t	*g_char_color_blue;
+extern cvar_t	*g_saber;
+extern cvar_t	*g_saber2;
+extern cvar_t	*g_saber_color;
+extern cvar_t	*g_saber2_color;
+
+/*
+===================
+Svcmd_EntityList_f
+===================
+*/
+void	Svcmd_EntityList_f (void) {
+	int			e;
+	gentity_t		*check;
+
+	check = g_entities+1;
+	for (e = 1; e < globals.num_entities ; e++, check++) {
+		if ( !check->inuse ) {
+			continue;
+		}
+		gi.Printf("%3i:", e);
+		switch ( check->s.eType ) {
+		case ET_GENERAL:
+			gi.Printf("ET_GENERAL ");
+			break;
+		case ET_PLAYER:
+			gi.Printf("ET_PLAYER  ");
+			break;
+		case ET_ITEM:
+			gi.Printf("ET_ITEM    ");
+			break;
+		case ET_MISSILE:
+			gi.Printf("ET_MISSILE ");
+			break;
+		case ET_MOVER:
+			gi.Printf("ET_MOVER   ");
+			break;
+		case ET_BEAM:
+			gi.Printf("ET_BEAM    ");
+			break;
+		default:
+			gi.Printf("#%i", check->s.eType);
+			break;
+		}
+
+		if ( check->classname ) {
+			gi.Printf("%s", check->classname);
+		}
+		gi.Printf("\n");
+	}
+}
+
+gclient_t	*ClientForString( const char *s ) {
+	gclient_t	*cl;
+	int			i;
+	int			idnum;
+
+	// numeric values are just slot numbers
+	if ( s[0] >= '0' && s[0] <= '9' ) {
+		idnum = atoi( s );
+		if ( idnum < 0 || idnum >= level.maxclients ) {
+			Com_Printf( "Bad client slot: %i\n", idnum );
+			return NULL;
+		}
+
+		cl = &level.clients[idnum];
+		if ( cl->pers.connected == CON_DISCONNECTED ) {
+			gi.Printf( "Client %i is not connected\n", idnum );
+			return NULL;
+		}
+		return cl;
+	}
+
+	// check for a name match
+	for ( i=0 ; i < level.maxclients ; i++ ) {
+		cl = &level.clients[i];
+		if ( cl->pers.connected == CON_DISCONNECTED ) {
+			continue;
+		}
+		if ( !Q_stricmp( cl->pers.netname, s ) ) {
+			return cl;
+		}
+	}
+
+	gi.Printf( "User %s is not on the server\n", s );
+
+	return NULL;
+}
+
+//---------------------------
+extern void G_StopCinematicSkip( void );
+extern void G_StartCinematicSkip( void );
+extern void ExitEmplacedWeapon( gentity_t *ent );
+static void Svcmd_ExitView_f( void )
+{
+extern cvar_t	*g_skippingcin;
+	static int exitViewDebounce = 0;
+	if ( exitViewDebounce > level.time )
+	{
+		return;
+	}
+	exitViewDebounce = level.time + 500;
+	if ( in_camera )
+	{//see if we need to exit an in-game cinematic
+		if ( g_skippingcin->integer )	// already doing cinematic skip?
+		{// yes...   so stop skipping...
+			G_StopCinematicSkip();
+		}
+		else
+		{// no... so start skipping...
+			G_StartCinematicSkip();
+		}
+	}
+	else if ( !G_ClearViewEntity( player ) )
+	{//didn't exit control of a droid or turret
+		//okay, now try exiting emplaced guns or AT-ST's
+		if ( player->s.eFlags & EF_LOCKED_TO_WEAPON )
+		{//get out of emplaced gun
+			ExitEmplacedWeapon( player );
+		}
+		else if ( player->client && player->client->NPC_class == CLASS_ATST )
+		{//a player trying to get out of his ATST
+			GEntity_UseFunc( player->activator, player, player );
+		}
+	}
+}
+
+gentity_t *G_GetSelfForPlayerCmd( void )
+{
+	if ( g_entities[0].client->ps.viewEntity > 0 
+		&& g_entities[0].client->ps.viewEntity < ENTITYNUM_WORLD 
+		&& g_entities[g_entities[0].client->ps.viewEntity].client 
+		&& g_entities[g_entities[0].client->ps.viewEntity].s.weapon == WP_SABER )
+	{//you're controlling another NPC
+		return (&g_entities[g_entities[0].client->ps.viewEntity]);
+	}
+	else
+	{
+		return (&g_entities[0]);
+	}
+}
+
+static void Svcmd_Saber_f()
+{
+	char *saber = gi.argv(1);
+	char *saber2 = gi.argv(2);
+
+	if ( !g_entities[0].client || !saber || !saber[0] )
+	{
+		return;
+	}
+
+	gi.cvar_set( "g_saber", saber );
+	WP_SetSaber( &g_entities[0], 0, saber );
+	if ( saber2 && saber2[0] && !g_entities[0].client->ps.saber[0].twoHanded )
+	{//want to use a second saber and first one is not twoHanded
+		gi.cvar_set( "g_saber2", saber2 );
+		WP_SetSaber( &g_entities[0], 1, saber2 );
+	}
+	else
+	{
+		gi.cvar_set( "g_saber2", "" );
+		WP_RemoveSaber( &g_entities[0], 1 );
+	}
+}
+
+static void Svcmd_SaberBlade_f()
+{
+	if ( gi.argc() < 2 )
+	{
+		gi.Printf( "USAGE: saberblade <sabernum> <bladenum> [0 = off, 1 = on, no arg = toggle]\n" );
+		return;
+	}
+	if ( &g_entities[0] == NULL || &g_entities[0].client == NULL )
+	{
+		return;
+	}
+	int sabernum = atoi(gi.argv(1)) - 1;
+	if ( sabernum < 0 || sabernum > 1 )
+	{
+		return;
+	}
+	if ( sabernum > 0 && !g_entities[0].client->ps.dualSabers )
+	{
+		return;
+	}
+	//FIXME: what if don't even have a single saber at all?
+	int bladenum = atoi(gi.argv(2)) - 1;
+	if ( bladenum < 0 || bladenum >= g_entities[0].client->ps.saber[sabernum].numBlades )
+	{
+		return;
+	}
+	qboolean turnOn;
+	if ( gi.argc() > 2 )
+	{//explicit
+		turnOn = (atoi(gi.argv(3))!=0);
+	}
+	else
+	{//toggle
+		turnOn = (g_entities[0].client->ps.saber[sabernum].blade[bladenum].active==qfalse);
+	}
+
+	g_entities[0].client->ps.SaberBladeActivate( sabernum, bladenum, turnOn );
+}
+
+static void Svcmd_SaberColor_f()
+{//FIXME: just list the colors, each additional listing sets that blade
+	int saberNum = atoi(gi.argv(1));
+	char *color[MAX_BLADES];
+	int bladeNum;
+
+	for ( bladeNum = 0; bladeNum < MAX_BLADES; bladeNum++ )
+	{
+		color[bladeNum] = gi.argv(2+bladeNum);
+	}
+
+	if ( !VALIDSTRING( color ) || saberNum < 1 || saberNum > 2 )
+	{
+		gi.Printf( "Usage:  saberColor <saberNum> <blade1 color> <blade2 color> ... <blade8 color> \n" );
+		gi.Printf( "valid saberNums:  1 or 2\n" );
+		gi.Printf( "valid colors:  red, orange, yellow, green, blue, and purple\n" );
+
+		return;
+	}
+	saberNum--;
+	
+	gentity_t *self = G_GetSelfForPlayerCmd();
+
+	for ( bladeNum = 0; bladeNum < MAX_BLADES; bladeNum++ )
+	{
+		if ( !color[bladeNum] || !color[bladeNum][0] )
+		{
+			break;
+		}
+		else
+		{
+			self->client->ps.saber[saberNum].blade[bladeNum].color = TranslateSaberColor( color[bladeNum] );
+		}
+	}
+
+	if ( saberNum == 0 )
+	{
+		gi.cvar_set( "g_saber_color", color[0] );
+	}
+	else if ( saberNum == 1 )
+	{
+		gi.cvar_set( "g_saber2_color", color[0] );
+	}
+}
+
+static void Svcmd_ForceJump_f( void )
+{
+	if ( !&g_entities[0] || !g_entities[0].client )
+	{
+		return;
+	}
+	if ( !g_cheats->integer ) 
+	{
+		gi.SendServerCommand( 0, "print \"Cheats are not enabled on this server.\n\"");
+		return;
+	}
+	char *newVal = gi.argv(1);
+	if ( !VALIDSTRING( newVal ) )
+	{
+		gi.Printf( "Current forceJump level is %d\n", g_entities[0].client->ps.forcePowerLevel[FP_LEVITATION] );
+		gi.Printf( "Usage:  setForceJump <level> (1 - 3)\n" );
+		return;
+	}
+	int val = atoi(newVal);
+	if ( val > FORCE_LEVEL_0 )
+	{
+		g_entities[0].client->ps.forcePowersKnown |= ( 1 << FP_LEVITATION );
+	}
+	else
+	{
+		g_entities[0].client->ps.forcePowersKnown &= ~( 1 << FP_LEVITATION );
+	}
+	g_entities[0].client->ps.forcePowerLevel[FP_LEVITATION] = val;
+	if ( g_entities[0].client->ps.forcePowerLevel[FP_LEVITATION] < FORCE_LEVEL_0 )
+	{
+		g_entities[0].client->ps.forcePowerLevel[FP_LEVITATION] = FORCE_LEVEL_0;
+	}
+	else if ( g_entities[0].client->ps.forcePowerLevel[FP_LEVITATION] > FORCE_LEVEL_3 )
+	{
+		g_entities[0].client->ps.forcePowerLevel[FP_LEVITATION] = FORCE_LEVEL_3;
+	}
+}
+
+static void Svcmd_SaberThrow_f( void )
+{
+	if ( !&g_entities[0] || !g_entities[0].client )
+	{
+		return;
+	}
+	if ( !g_cheats->integer ) 
+	{
+		gi.SendServerCommand( 0, "print \"Cheats are not enabled on this server.\n\"");
+		return;
+	}
+	char *newVal = gi.argv(1);
+	if ( !VALIDSTRING( newVal ) )
+	{
+		gi.Printf( "Current saberThrow level is %d\n", g_entities[0].client->ps.forcePowerLevel[FP_SABERTHROW] );
+		gi.Printf( "Usage:  setSaberThrow <level> (1 - 3)\n" );
+		return;
+	}
+	int val = atoi(newVal);
+	if ( val > FORCE_LEVEL_0 )
+	{
+		g_entities[0].client->ps.forcePowersKnown |= ( 1 << FP_SABERTHROW );
+	}
+	else
+	{
+		g_entities[0].client->ps.forcePowersKnown &= ~( 1 << FP_SABERTHROW );
+	}
+	g_entities[0].client->ps.forcePowerLevel[FP_SABERTHROW] = val;
+	if ( g_entities[0].client->ps.forcePowerLevel[FP_SABERTHROW] < FORCE_LEVEL_0 )
+	{
+		g_entities[0].client->ps.forcePowerLevel[FP_SABERTHROW] = FORCE_LEVEL_0;
+	}
+	else if ( g_entities[0].client->ps.forcePowerLevel[FP_SABERTHROW] > FORCE_LEVEL_3 )
+	{
+		g_entities[0].client->ps.forcePowerLevel[FP_SABERTHROW] = FORCE_LEVEL_3;
+	}
+}
+
+static void Svcmd_ForceHeal_f( void )
+{
+	if ( !&g_entities[0] || !g_entities[0].client )
+	{
+		return;
+	}
+	if ( !g_cheats->integer ) 
+	{
+		gi.SendServerCommand( 0, "print \"Cheats are not enabled on this server.\n\"");
+		return;
+	}
+	char *newVal = gi.argv(1);
+	if ( !VALIDSTRING( newVal ) )
+	{
+		gi.Printf( "Current forceHeal level is %d\n", g_entities[0].client->ps.forcePowerLevel[FP_HEAL] );
+		gi.Printf( "Usage:  forceHeal <level> (1 - 3)\n" );
+		return;
+	}
+	int val = atoi(newVal);
+	if ( val > FORCE_LEVEL_0 )
+	{
+		g_entities[0].client->ps.forcePowersKnown |= ( 1 << FP_HEAL );
+	}
+	else
+	{
+		g_entities[0].client->ps.forcePowersKnown &= ~( 1 << FP_HEAL );
+	}
+	g_entities[0].client->ps.forcePowerLevel[FP_HEAL] = val;
+	if ( g_entities[0].client->ps.forcePowerLevel[FP_HEAL] < FORCE_LEVEL_0 )
+	{
+		g_entities[0].client->ps.forcePowerLevel[FP_HEAL] = FORCE_LEVEL_0;
+	}
+	else if ( g_entities[0].client->ps.forcePowerLevel[FP_HEAL] > FORCE_LEVEL_3 )
+	{
+		g_entities[0].client->ps.forcePowerLevel[FP_HEAL] = FORCE_LEVEL_3;
+	}
+}
+
+static void Svcmd_ForcePush_f( void )
+{
+	if ( !&g_entities[0] || !g_entities[0].client )
+	{
+		return;
+	}
+	if ( !g_cheats->integer ) 
+	{
+		gi.SendServerCommand( 0, "print \"Cheats are not enabled on this server.\n\"");
+		return;
+	}
+	char *newVal = gi.argv(1);
+	if ( !VALIDSTRING( newVal ) )
+	{
+		gi.Printf( "Current forcePush level is %d\n", g_entities[0].client->ps.forcePowerLevel[FP_PUSH] );
+		gi.Printf( "Usage:  forcePush <level> (1 - 3)\n" );
+		return;
+	}
+	int val = atoi(newVal);
+	if ( val > FORCE_LEVEL_0 )
+	{
+		g_entities[0].client->ps.forcePowersKnown |= ( 1 << FP_PUSH );
+	}
+	else
+	{
+		g_entities[0].client->ps.forcePowersKnown &= ~( 1 << FP_PUSH );
+	}
+	g_entities[0].client->ps.forcePowerLevel[FP_PUSH] = val;
+	if ( g_entities[0].client->ps.forcePowerLevel[FP_PUSH] < FORCE_LEVEL_0 )
+	{
+		g_entities[0].client->ps.forcePowerLevel[FP_PUSH] = FORCE_LEVEL_0;
+	}
+	else if ( g_entities[0].client->ps.forcePowerLevel[FP_PUSH] > FORCE_LEVEL_3 )
+	{
+		g_entities[0].client->ps.forcePowerLevel[FP_PUSH] = FORCE_LEVEL_3;
+	}
+}
+
+static void Svcmd_ForcePull_f( void )
+{
+	if ( !&g_entities[0] || !g_entities[0].client )
+	{
+		return;
+	}
+	if ( !g_cheats->integer ) 
+	{
+		gi.SendServerCommand( 0, "print \"Cheats are not enabled on this server.\n\"");
+		return;
+	}
+	char *newVal = gi.argv(1);
+	if ( !VALIDSTRING( newVal ) )
+	{
+		gi.Printf( "Current forcePull level is %d\n", g_entities[0].client->ps.forcePowerLevel[FP_PULL] );
+		gi.Printf( "Usage:  forcePull <level> (1 - 3)\n" );
+		return;
+	}
+	int val = atoi(newVal);
+	if ( val > FORCE_LEVEL_0 )
+	{
+		g_entities[0].client->ps.forcePowersKnown |= ( 1 << FP_PULL );
+	}
+	else
+	{
+		g_entities[0].client->ps.forcePowersKnown &= ~( 1 << FP_PULL );
+	}
+	g_entities[0].client->ps.forcePowerLevel[FP_PULL] = val;
+	if ( g_entities[0].client->ps.forcePowerLevel[FP_PULL] < FORCE_LEVEL_0 )
+	{
+		g_entities[0].client->ps.forcePowerLevel[FP_PULL] = FORCE_LEVEL_0;
+	}
+	else if ( g_entities[0].client->ps.forcePowerLevel[FP_PULL] > FORCE_LEVEL_3 )
+	{
+		g_entities[0].client->ps.forcePowerLevel[FP_PULL] = FORCE_LEVEL_3;
+	}
+}
+
+static void Svcmd_ForceSpeed_f( void )
+{
+	if ( !&g_entities[0] || !g_entities[0].client )
+	{
+		return;
+	}
+	if ( !g_cheats->integer ) 
+	{
+		gi.SendServerCommand( 0, "print \"Cheats are not enabled on this server.\n\"");
+		return;
+	}
+	char *newVal = gi.argv(1);
+	if ( !VALIDSTRING( newVal ) )
+	{
+		gi.Printf( "Current forceSpeed level is %d\n", g_entities[0].client->ps.forcePowerLevel[FP_SPEED] );
+		gi.Printf( "Usage:  forceSpeed <level> (1 - 3)\n" );
+		return;
+	}
+	int val = atoi(newVal);
+	if ( val > FORCE_LEVEL_0 )
+	{
+		g_entities[0].client->ps.forcePowersKnown |= ( 1 << FP_SPEED );
+	}
+	else
+	{
+		g_entities[0].client->ps.forcePowersKnown &= ~( 1 << FP_SPEED );
+	}
+	g_entities[0].client->ps.forcePowerLevel[FP_SPEED] = val;
+	if ( g_entities[0].client->ps.forcePowerLevel[FP_SPEED] < FORCE_LEVEL_0 )
+	{
+		g_entities[0].client->ps.forcePowerLevel[FP_SPEED] = FORCE_LEVEL_0;
+	}
+	else if ( g_entities[0].client->ps.forcePowerLevel[FP_SPEED] > FORCE_LEVEL_3 )
+	{
+		g_entities[0].client->ps.forcePowerLevel[FP_SPEED] = FORCE_LEVEL_3;
+	}
+}
+
+static void Svcmd_ForceGrip_f( void )
+{
+	if ( !&g_entities[0] || !g_entities[0].client )
+	{
+		return;
+	}
+	if ( !g_cheats->integer ) 
+	{
+		gi.SendServerCommand( 0, "print \"Cheats are not enabled on this server.\n\"");
+		return;
+	}
+	char *newVal = gi.argv(1);
+	if ( !VALIDSTRING( newVal ) )
+	{
+		gi.Printf( "Current forceGrip level is %d\n", g_entities[0].client->ps.forcePowerLevel[FP_GRIP] );
+		gi.Printf( "Usage:  forceGrip <level> (1 - 3)\n" );
+		return;
+	}
+	int val = atoi(newVal);
+	if ( val > FORCE_LEVEL_0 )
+	{
+		g_entities[0].client->ps.forcePowersKnown |= ( 1 << FP_GRIP );
+	}
+	else
+	{
+		g_entities[0].client->ps.forcePowersKnown &= ~( 1 << FP_GRIP );
+	}
+	g_entities[0].client->ps.forcePowerLevel[FP_GRIP] = val;
+	if ( g_entities[0].client->ps.forcePowerLevel[FP_GRIP] < FORCE_LEVEL_0 )
+	{
+		g_entities[0].client->ps.forcePowerLevel[FP_GRIP] = FORCE_LEVEL_0;
+	}
+	else if ( g_entities[0].client->ps.forcePowerLevel[FP_GRIP] > FORCE_LEVEL_3 )
+	{
+		g_entities[0].client->ps.forcePowerLevel[FP_GRIP] = FORCE_LEVEL_3;
+	}
+}
+
+static void Svcmd_ForceLightning_f( void )
+{
+	if ( !&g_entities[0] || !g_entities[0].client )
+	{
+		return;
+	}
+	if ( !g_cheats->integer ) 
+	{
+		gi.SendServerCommand( 0, "print \"Cheats are not enabled on this server.\n\"");
+		return;
+	}
+	char *newVal = gi.argv(1);
+	if ( !VALIDSTRING( newVal ) )
+	{
+		gi.Printf( "Current forceLightning level is %d\n", g_entities[0].client->ps.forcePowerLevel[FP_LIGHTNING] );
+		gi.Printf( "Usage:  forceLightning <level> (1 - 3)\n" );
+		return;
+	}
+	int val = atoi(newVal);
+	if ( val > FORCE_LEVEL_0 )
+	{
+		g_entities[0].client->ps.forcePowersKnown |= ( 1 << FP_LIGHTNING );
+	}
+	else
+	{
+		g_entities[0].client->ps.forcePowersKnown &= ~( 1 << FP_LIGHTNING );
+	}
+	g_entities[0].client->ps.forcePowerLevel[FP_LIGHTNING] = val;
+	if ( g_entities[0].client->ps.forcePowerLevel[FP_LIGHTNING] < FORCE_LEVEL_0 )
+	{
+		g_entities[0].client->ps.forcePowerLevel[FP_LIGHTNING] = FORCE_LEVEL_0;
+	}
+	else if ( g_entities[0].client->ps.forcePowerLevel[FP_LIGHTNING] > FORCE_LEVEL_3 )
+	{
+		g_entities[0].client->ps.forcePowerLevel[FP_LIGHTNING] = FORCE_LEVEL_3;
+	}
+}
+
+static void Svcmd_MindTrick_f( void )
+{
+	if ( !&g_entities[0] || !g_entities[0].client )
+	{
+		return;
+	}
+	if ( !g_cheats->integer ) 
+	{
+		gi.SendServerCommand( 0, "print \"Cheats are not enabled on this server.\n\"");
+		return;
+	}
+	char *newVal = gi.argv(1);
+	if ( !VALIDSTRING( newVal ) )
+	{
+		gi.Printf( "Current mindTrick level is %d\n", g_entities[0].client->ps.forcePowerLevel[FP_TELEPATHY] );
+		gi.Printf( "Usage:  mindTrick <level> (1 - 3)\n" );
+		return;
+	}
+	int val = atoi(newVal);
+	if ( val > FORCE_LEVEL_0 )
+	{
+		g_entities[0].client->ps.forcePowersKnown |= ( 1 << FP_TELEPATHY );
+	}
+	else
+	{
+		g_entities[0].client->ps.forcePowersKnown &= ~( 1 << FP_TELEPATHY );
+	}
+	g_entities[0].client->ps.forcePowerLevel[FP_TELEPATHY] = val;
+	if ( g_entities[0].client->ps.forcePowerLevel[FP_TELEPATHY] < FORCE_LEVEL_0 )
+	{
+		g_entities[0].client->ps.forcePowerLevel[FP_TELEPATHY] = FORCE_LEVEL_0;
+	}
+	else if ( g_entities[0].client->ps.forcePowerLevel[FP_TELEPATHY] > FORCE_LEVEL_4 )
+	{
+		g_entities[0].client->ps.forcePowerLevel[FP_TELEPATHY] = FORCE_LEVEL_4;
+	}
+}
+
+static void Svcmd_SaberDefense_f( void )
+{
+	if ( !&g_entities[0] || !g_entities[0].client )
+	{
+		return;
+	}
+	if ( !g_cheats->integer ) 
+	{
+		gi.SendServerCommand( 0, "print \"Cheats are not enabled on this server.\n\"");
+		return;
+	}
+	char *newVal = gi.argv(1);
+	if ( !VALIDSTRING( newVal ) )
+	{
+		gi.Printf( "Current saberDefense level is %d\n", g_entities[0].client->ps.forcePowerLevel[FP_SABER_DEFENSE] );
+		gi.Printf( "Usage:  saberDefense <level> (1 - 3)\n" );
+		return;
+	}
+	int val = atoi(newVal);
+	if ( val > FORCE_LEVEL_0 )
+	{
+		g_entities[0].client->ps.forcePowersKnown |= ( 1 << FP_SABER_DEFENSE );
+	}
+	else
+	{
+		g_entities[0].client->ps.forcePowersKnown &= ~( 1 << FP_SABER_DEFENSE );
+	}
+	g_entities[0].client->ps.forcePowerLevel[FP_SABER_DEFENSE] = val;
+	if ( g_entities[0].client->ps.forcePowerLevel[FP_SABER_DEFENSE] < FORCE_LEVEL_0 )
+	{
+		g_entities[0].client->ps.forcePowerLevel[FP_SABER_DEFENSE] = FORCE_LEVEL_0;
+	}
+	else if ( g_entities[0].client->ps.forcePowerLevel[FP_SABER_DEFENSE] > FORCE_LEVEL_3 )
+	{
+		g_entities[0].client->ps.forcePowerLevel[FP_SABER_DEFENSE] = FORCE_LEVEL_3;
+	}
+}
+
+static void Svcmd_SaberOffense_f( void )
+{
+	if ( !&g_entities[0] || !g_entities[0].client )
+	{
+		return;
+	}
+	if ( !g_cheats->integer ) 
+	{
+		gi.SendServerCommand( 0, "print \"Cheats are not enabled on this server.\n\"");
+		return;
+	}
+	char *newVal = gi.argv(1);
+	if ( !VALIDSTRING( newVal ) )
+	{
+		gi.Printf( "Current saberOffense level is %d\n", g_entities[0].client->ps.forcePowerLevel[FP_SABER_OFFENSE] );
+		gi.Printf( "Usage:  saberOffense <level> (1 - 3)\n" );
+		return;
+	}
+	int val = atoi(newVal);
+	if ( val > FORCE_LEVEL_0 )
+	{
+		g_entities[0].client->ps.forcePowersKnown |= ( 1 << FP_SABER_OFFENSE );
+	}
+	else
+	{
+		g_entities[0].client->ps.forcePowersKnown &= ~( 1 << FP_SABER_OFFENSE );
+	}
+	g_entities[0].client->ps.forcePowerLevel[FP_SABER_OFFENSE] = val;
+	if ( g_entities[0].client->ps.forcePowerLevel[FP_SABER_OFFENSE] < FORCE_LEVEL_0 )
+	{
+		g_entities[0].client->ps.forcePowerLevel[FP_SABER_OFFENSE] = FORCE_LEVEL_0;
+	}
+	else if ( g_entities[0].client->ps.forcePowerLevel[FP_SABER_OFFENSE] >= SS_NUM_SABER_STYLES )
+	{
+		g_entities[0].client->ps.forcePowerLevel[FP_SABER_OFFENSE] = SS_NUM_SABER_STYLES-1;
+	}
+}
+
+static void Svcmd_ForceSetLevel_f( int forcePower )
+{
+	if ( !&g_entities[0] || !g_entities[0].client )
+	{
+		return;
+	}
+	if ( !g_cheats->integer ) 
+	{
+		gi.SendServerCommand( 0, "print \"Cheats are not enabled on this server.\n\"");
+		return;
+	}
+	char *newVal = gi.argv(1);
+	if ( !VALIDSTRING( newVal ) )
+	{
+		gi.Printf( "Current force level is %d\n", g_entities[0].client->ps.forcePowerLevel[forcePower] );
+		gi.Printf( "Usage:  force <level> (1 - 3)\n" );
+		return;
+	}
+	int val = atoi(newVal);
+	if ( val > FORCE_LEVEL_0 )
+	{
+		g_entities[0].client->ps.forcePowersKnown |= ( 1 << forcePower );
+	}
+	else
+	{
+		g_entities[0].client->ps.forcePowersKnown &= ~( 1 << forcePower );
+	}
+	g_entities[0].client->ps.forcePowerLevel[forcePower] = val;
+	if ( g_entities[0].client->ps.forcePowerLevel[forcePower] < FORCE_LEVEL_0 )
+	{
+		g_entities[0].client->ps.forcePowerLevel[forcePower] = FORCE_LEVEL_0;
+	}
+	else if ( g_entities[0].client->ps.forcePowerLevel[forcePower] > FORCE_LEVEL_3 )
+	{
+		g_entities[0].client->ps.forcePowerLevel[forcePower] = FORCE_LEVEL_3;
+	}
+}
+
+extern qboolean PM_SaberInStart( int move );
+extern qboolean PM_SaberInTransition( int move );
+extern qboolean PM_SaberInAttack( int move );
+void Svcmd_SaberAttackCycle_f( void )
+{
+	if ( !&g_entities[0] || !g_entities[0].client )
+	{
+		return;
+	}
+
+	gentity_t *self = G_GetSelfForPlayerCmd();
+	if ( self->s.weapon != WP_SABER )
+	{// saberAttackCycle button also switches to saber
+		gi.SendConsoleCommand("weapon 1" );
+		return;
+	}
+
+	if ( self->client->ps.dualSabers )
+	{//can't cycle styles with dualSabers, so just toggle second saber on/off
+		if ( self->client->ps.saber[1].Active() )
+		{//turn it off
+			self->client->ps.saber[1].Deactivate();
+			G_SoundIndexOnEnt( self, CHAN_WEAPON, self->client->ps.saber[0].soundOff );
+		}
+		else if ( !self->client->ps.saber[0].Active() )
+		{//first one is off, too, so just turn that one on
+			if ( !self->client->ps.saberInFlight )
+			{//but only if it's in your hand!
+				self->client->ps.saber[0].Activate();
+			}
+		}
+		else
+		{//turn on the second one
+			self->client->ps.saber[1].Activate();
+		}
+		return;
+	}
+	else if ( self->client->ps.saber[0].numBlades > 1 )//self->client->ps.saber[0].type == SABER_STAFF )
+	{//can't cycle styles with saberstaff, so just toggles saber blades on/off
+		if ( self->client->ps.saberInFlight )
+		{//can't turn second blade back on if it's in the air, you naughty boy!
+			return;
+		}
+		qboolean playedSound = qfalse;
+		if ( !self->client->ps.saber[0].blade[0].active )
+		{//first one is not even on
+			//turn only it on
+			self->client->ps.SaberBladeActivate( 0, 0, qtrue );
+			return;
+		}
+
+		for ( int i = 1; i < self->client->ps.saber[0].numBlades; i++ )
+		{
+			if ( !self->client->ps.saber[0].blade[i].active )
+			{//extra is off, turn it on
+				self->client->ps.SaberBladeActivate( 0, i, qtrue );
+			}
+			else
+			{//turn extra off
+				self->client->ps.SaberBladeActivate( 0, i, qfalse );
+				if ( !playedSound )
+				{
+					G_SoundIndexOnEnt( self, CHAN_WEAPON, self->client->ps.saber[0].soundOff );
+					playedSound = qtrue;
+				}
+			}
+		}
+		return;
+	}
+
+	//FIXME: if dualSabers and both on, do something here, too... maybe toggle the second one on/off?
+
+	if ( !self->client->ps.saberStylesKnown )
+	{
+		return;
+	}
+
+	int	saberAnimLevel;
+	if ( !self->s.number )
+	{
+		saberAnimLevel = cg.saberAnimLevelPending;
+	}
+	else
+	{
+		saberAnimLevel = self->client->ps.saberAnimLevel;
+	}
+	saberAnimLevel++;
+	int sanityCheck = 0;
+	while ( self->client->ps.saberAnimLevel != saberAnimLevel 
+		&& !(self->client->ps.saberStylesKnown&(1<<saberAnimLevel))
+		&& sanityCheck < SS_NUM_SABER_STYLES+1 )
+	{
+		saberAnimLevel++;
+		if ( saberAnimLevel > SS_STAFF )
+		{
+			saberAnimLevel = SS_FAST;
+		}
+		sanityCheck++;
+	}
+	if ( !(self->client->ps.saberStylesKnown&(1<<saberAnimLevel)) )
+	{
+		return;
+	}
+
+	if ( !self->s.number )
+	{
+		cg.saberAnimLevelPending = saberAnimLevel;
+	}
+	else
+	{
+		self->client->ps.saberAnimLevel = saberAnimLevel;
+	}
+
+#ifndef FINAL_BUILD
+	switch ( saberAnimLevel )
+	{
+	case SS_FAST:
+		gi.Printf( S_COLOR_BLUE"Lightsaber Combat Style: Fast\n" );
+		//LIGHTSABERCOMBATSTYLE_FAST
+		break;
+	case SS_MEDIUM:
+		gi.Printf( S_COLOR_YELLOW"Lightsaber Combat Style: Medium\n" );
+		//LIGHTSABERCOMBATSTYLE_MEDIUM
+		break;
+	case SS_STRONG:
+		gi.Printf( S_COLOR_RED"Lightsaber Combat Style: Strong\n" );
+		//LIGHTSABERCOMBATSTYLE_STRONG
+		break;
+	case SS_DESANN:
+		gi.Printf( S_COLOR_CYAN"Lightsaber Combat Style: Desann\n" );
+		//LIGHTSABERCOMBATSTYLE_DESANN
+		break;
+	case SS_TAVION:
+		gi.Printf( S_COLOR_MAGENTA"Lightsaber Combat Style: Tavion\n" );
+		//LIGHTSABERCOMBATSTYLE_TAVION
+		break;
+	case SS_DUAL:
+		gi.Printf( S_COLOR_MAGENTA"Lightsaber Combat Style: Dual\n" );
+		//LIGHTSABERCOMBATSTYLE_TAVION
+		break;
+	case SS_STAFF:
+		gi.Printf( S_COLOR_MAGENTA"Lightsaber Combat Style: Staff\n" );
+		//LIGHTSABERCOMBATSTYLE_TAVION
+		break;
+	}
+	//gi.Printf("\n");
+#endif
+}
+
+qboolean G_ReleaseEntity( gentity_t *grabber )
+{
+	if ( grabber && grabber->client && grabber->client->ps.heldClient < ENTITYNUM_WORLD )
+	{
+		gentity_t *heldClient = &g_entities[grabber->client->ps.heldClient];
+		grabber->client->ps.heldClient = ENTITYNUM_NONE;
+		if ( heldClient && heldClient->client )
+		{
+			heldClient->client->ps.heldByClient = ENTITYNUM_NONE;
+
+			heldClient->owner = NULL;
+		}
+		return qtrue;
+	}
+	return qfalse;
+}
+
+void G_GrabEntity( gentity_t *grabber, char *target )
+{
+	if ( !grabber || !grabber->client )
+	{
+		return;
+	}
+	gentity_t	*heldClient = G_Find( NULL, FOFS(targetname), (char *)target );
+	if ( heldClient && heldClient->client && heldClient != grabber )//don't grab yourself, it's not polite
+	{//found him
+		grabber->client->ps.heldClient = heldClient->s.number;
+		heldClient->client->ps.heldByClient = grabber->s.number;
+
+		heldClient->owner = grabber;
+	}
+}
+
+/*
+=================
+ConsoleCommand
+// these are added in cg_main, CG_Init so they tab-complete
+=================
+*/
+qboolean	ConsoleCommand( void ) {
+	char	*cmd;
+
+	cmd = gi.argv(0);
+
+	if ( Q_stricmp (cmd, "entitylist") == 0 ) 
+	{
+		Svcmd_EntityList_f();
+		return qtrue;
+	}
+
+	if (Q_stricmp (cmd, "game_memory") == 0) {
+		Svcmd_GameMem_f();
+		return qtrue;
+	}
+
+//	if (Q_stricmp (cmd, "addbot") == 0) {
+//		Svcmd_AddBot_f();
+//		return qtrue;
+//	}
+
+	if (Q_stricmp (cmd, "nav") == 0) 
+	{
+		if ( !g_cheats->integer ) 
+		{
+			gi.SendServerCommand( 0, "print \"Cheats are not enabled on this server.\n\"");
+			return qfalse;
+		}
+		Svcmd_Nav_f ();
+		return qtrue;
+	}
+
+	if (Q_stricmp (cmd, "npc") == 0) 
+	{
+		if ( !g_cheats->integer ) 
+		{
+			gi.SendServerCommand( 0, "print \"Cheats are not enabled on this server.\n\"");
+			return qfalse;
+		}
+		Svcmd_NPC_f ();
+		return qtrue;
+	}
+
+	if (Q_stricmp (cmd, "use") == 0) 
+	{
+		if ( !g_cheats->integer ) 
+		{
+			gi.SendServerCommand( 0, "print \"Cheats are not enabled on this server.\n\"");
+			return qfalse;
+		}
+		Svcmd_Use_f ();
+		return qtrue;
+	}
+
+	if ( Q_stricmp( cmd, "ICARUS" ) == 0 )	
+	{
+		if ( !g_cheats->integer ) 
+		{
+			gi.SendServerCommand( 0, "print \"Cheats are not enabled on this server.\n\"");
+			return qfalse;
+		}
+
+		Quake3Game()->Svcmd();
+
+		return qtrue;
+	}
+
+	if ( Q_stricmp( cmd, "saberColor" ) == 0 )	
+	{
+		if ( !g_cheats->integer ) 
+		{
+			gi.SendServerCommand( 0, "print \"Cheats are not enabled on this server.\n\"");
+			return qfalse;
+		}
+		Svcmd_SaberColor_f();
+		return qtrue;
+	}
+
+	if ( Q_stricmp( cmd, "saber" ) == 0 )
+	{
+		if ( !g_cheats->integer ) 
+		{
+			gi.SendServerCommand( 0, "print \"Cheats are not enabled on this server.\n\"");
+			return qfalse;
+		}
+		Svcmd_Saber_f();
+		return qtrue;
+	}
+
+	if ( Q_stricmp( cmd, "saberblade" ) == 0 )
+	{
+		if ( !g_cheats->integer ) 
+		{
+			gi.SendServerCommand( 0, "print \"Cheats are not enabled on this server.\n\"");
+			return qfalse;
+		}
+		Svcmd_SaberBlade_f();
+		return qtrue;
+	}
+
+
+	if ( Q_stricmp( cmd, "setForceJump" ) == 0 )	
+	{
+		Svcmd_ForceJump_f();
+		return qtrue;
+	}
+	if ( Q_stricmp( cmd, "setSaberThrow" ) == 0 )	
+	{
+		Svcmd_SaberThrow_f();
+		return qtrue;
+	}
+	if ( Q_stricmp( cmd, "setForceHeal" ) == 0 )	
+	{
+		Svcmd_ForceHeal_f();
+		return qtrue;
+	}
+	if ( Q_stricmp( cmd, "setForcePush" ) == 0 )	
+	{
+		Svcmd_ForcePush_f();
+		return qtrue;
+	}
+	if ( Q_stricmp( cmd, "setForcePull" ) == 0 )	
+	{
+		Svcmd_ForcePull_f();
+		return qtrue;
+	}
+	if ( Q_stricmp( cmd, "setForceSpeed" ) == 0 )	
+	{
+		Svcmd_ForceSpeed_f();
+		return qtrue;
+	}
+	if ( Q_stricmp( cmd, "setForceGrip" ) == 0 )	
+	{
+		Svcmd_ForceGrip_f();
+		return qtrue;
+	}
+	if ( Q_stricmp( cmd, "setForceLightning" ) == 0 )	
+	{
+		Svcmd_ForceLightning_f();
+		return qtrue;
+	}
+	if ( Q_stricmp( cmd, "setMindTrick" ) == 0 )	
+	{
+		Svcmd_MindTrick_f();
+		return qtrue;
+	}
+	if ( Q_stricmp( cmd, "setSaberDefense" ) == 0 )	
+	{
+		Svcmd_SaberDefense_f();
+		return qtrue;
+	}
+	if ( Q_stricmp( cmd, "setSaberOffense" ) == 0 )	
+	{
+		Svcmd_SaberOffense_f();
+		return qtrue;
+	}
+	if ( Q_stricmp( cmd, "setForceRage" ) == 0 )	
+	{
+		Svcmd_ForceSetLevel_f( FP_RAGE );
+		return qtrue;
+	}
+	if ( Q_stricmp( cmd, "setForceDrain" ) == 0 )	
+	{
+		Svcmd_ForceSetLevel_f( FP_DRAIN );
+		return qtrue;
+	}
+	if ( Q_stricmp( cmd, "setForceProtect" ) == 0 )	
+	{
+		Svcmd_ForceSetLevel_f( FP_PROTECT );
+		return qtrue;
+	}
+	if ( Q_stricmp( cmd, "setForceAbsorb" ) == 0 )	
+	{
+		Svcmd_ForceSetLevel_f( FP_ABSORB );
+		return qtrue;
+	}
+	if ( Q_stricmp( cmd, "setForceSight" ) == 0 )	
+	{
+		Svcmd_ForceSetLevel_f( FP_SEE );
+		return qtrue;
+	}
+	if ( Q_stricmp( cmd, "setForceAll" ) == 0 )	
+	{
+		Svcmd_ForceJump_f();
+		Svcmd_SaberThrow_f();
+		Svcmd_ForceHeal_f();
+		Svcmd_ForcePush_f();
+		Svcmd_ForcePull_f();
+		Svcmd_ForceSpeed_f();
+		Svcmd_ForceGrip_f();
+		Svcmd_ForceLightning_f();
+		Svcmd_MindTrick_f();
+		Svcmd_SaberDefense_f();
+		Svcmd_SaberOffense_f();
+		Svcmd_ForceSetLevel_f( FP_RAGE );
+		Svcmd_ForceSetLevel_f( FP_DRAIN );
+		Svcmd_ForceSetLevel_f( FP_PROTECT );
+		Svcmd_ForceSetLevel_f( FP_ABSORB );
+		Svcmd_ForceSetLevel_f( FP_SEE );
+		for ( int i = SS_FAST; i < SS_NUM_SABER_STYLES; i++ )
+		{
+			g_entities[0].client->ps.saberStylesKnown |= (1<<i);
+		}
+		return qtrue;
+	}
+	if ( Q_stricmp( cmd, "saberAttackCycle" ) == 0 )	
+	{
+		Svcmd_SaberAttackCycle_f();
+		return qtrue;
+	}
+	if ( Q_stricmp( cmd, "runscript" ) == 0 ) 
+	{
+		if ( !g_cheats->integer ) 
+		{
+			gi.SendServerCommand( 0, "print \"Cheats are not enabled on this server.\n\"");
+			return qfalse;
+		}
+		char *cmd2 = gi.argv(1);
+
+		if ( cmd2 && cmd2[0] )
+		{
+			char *cmd3 = gi.argv(2);
+			if ( cmd3 && cmd3[0] )
+			{
+				gentity_t *found = NULL;
+				if ( (found = G_Find(NULL, FOFS(targetname), cmd2 ) ) != NULL )
+				{
+					Quake3Game()->RunScript( found, cmd3 );
+				}
+				else
+				{
+					//can't find cmd2
+					gi.Printf( S_COLOR_RED"runscript: can't find targetname %s\n", cmd2 );
+				}
+			}
+			else
+			{
+				Quake3Game()->RunScript( &g_entities[0], cmd2 );
+			}
+		}
+		else
+		{
+			gi.Printf( S_COLOR_RED"usage: runscript <ent targetname> scriptname\n" );
+		}
+		//FIXME: else warning
+		return qtrue;
+	}
+
+	if ( Q_stricmp( cmd, "playerteam" ) == 0 ) 
+	{
+		if ( !g_cheats->integer ) 
+		{
+			gi.SendServerCommand( 0, "print \"Cheats are not enabled on this server.\n\"");
+			return qfalse;
+		}
+		char	*cmd2 = gi.argv(1);
+		int		n;
+
+		if ( !*cmd2 || !cmd2[0] )
+		{
+			gi.Printf( S_COLOR_RED"'playerteam' - change player team, requires a team name!\n" );
+			gi.Printf( S_COLOR_RED"Valid team names are:\n");
+			for ( n = (TEAM_FREE + 1); n < TEAM_NUM_TEAMS; n++ )
+			{
+				gi.Printf( S_COLOR_RED"%s\n", GetStringForID( TeamTable, n ) );
+			}
+		}
+		else
+		{
+			team_t	team;
+
+			team = (team_t)GetIDForString( TeamTable, cmd2 );
+			if ( team == -1 )
+			{
+				gi.Printf( S_COLOR_RED"'playerteam' unrecognized team name %s!\n", cmd2 );
+				gi.Printf( S_COLOR_RED"Valid team names are:\n");
+				for ( n = TEAM_FREE; n < TEAM_NUM_TEAMS; n++ )
+				{
+					gi.Printf( S_COLOR_RED"%s\n", GetStringForID( TeamTable, n ) );
+				}
+			}
+			else
+			{
+				g_entities[0].client->playerTeam = team;
+				//FIXME: convert Imperial, Malon, Hirogen and Klingon to Scavenger?
+			}
+		}
+		return qtrue;
+	}
+
+	if ( Q_stricmp( cmd, "control" ) == 0 )
+	{
+		if ( !g_cheats->integer ) 
+		{
+			gi.SendServerCommand( 0, "print \"Cheats are not enabled on this server.\n\"");
+			return qfalse;
+		}
+		char	*cmd2 = gi.argv(1);
+		if ( !*cmd2 || !cmd2[0] )
+		{
+			if ( !G_ClearViewEntity( &g_entities[0] ) )
+			{
+				gi.Printf( S_COLOR_RED"control <NPC_targetname>\n", cmd2 );
+			}
+		}
+		else
+		{
+			Q3_SetViewEntity( 0, cmd2 );
+		}
+		return qtrue;
+	}
+
+	if ( Q_stricmp( cmd, "grab" ) == 0 )
+	{
+		if ( !g_cheats->integer ) 
+		{
+			gi.SendServerCommand( 0, "print \"Cheats are not enabled on this server.\n\"");
+			return qfalse;
+		}
+		char	*cmd2 = gi.argv(1);
+		if ( !*cmd2 || !cmd2[0] )
+		{
+			if ( !G_ReleaseEntity( &g_entities[0] ) )
+			{
+				gi.Printf( S_COLOR_RED"grab <NPC_targetname>\n", cmd2 );
+			}
+		}
+		else
+		{
+			G_GrabEntity( &g_entities[0], cmd2 );
+		}
+		return qtrue;
+	}
+
+	if ( Q_stricmp( cmd, "knockdown" ) == 0 )
+	{
+		if ( !g_cheats->integer ) 
+		{
+			gi.SendServerCommand( 0, "print \"Cheats are not enabled on this server.\n\"");
+			return qfalse;
+		}
+		G_Knockdown( &g_entities[0], &g_entities[0], vec3_origin, 300, qtrue );
+		return qtrue;
+	}
+
+	if ( Q_stricmp( cmd, "playerModel" ) == 0 )
+	{
+		if ( gi.argc() == 1 )
+		{
+			gi.Printf( S_COLOR_RED"USAGE: playerModel <NPC Name>\n       playerModel <g2model> <skinhead> <skintorso> <skinlower>\n       playerModel player (builds player from customized menu settings)\n" );
+			gi.Printf( "playerModel = %s ", va("%s %s %s %s\n", g_char_model->string, g_char_skin_head->string, g_char_skin_torso->string, g_char_skin_legs->string ) );
+		}
+		else if ( gi.argc() == 2 )
+		{
+			G_ChangePlayerModel( &g_entities[0], gi.argv(1) );
+		}
+		else if (  gi.argc() == 5 )
+		{
+			//instead of setting it directly via a command, we now store it in cvars
+			//G_ChangePlayerModel( &g_entities[0], va("%s|%s|%s|%s", gi.argv(1), gi.argv(2), gi.argv(3), gi.argv(4)) );
+			gi.cvar_set("g_char_model", gi.argv(1) );
+			gi.cvar_set("g_char_skin_head", gi.argv(2) );
+			gi.cvar_set("g_char_skin_torso", gi.argv(3) );
+			gi.cvar_set("g_char_skin_legs", gi.argv(4) );
+			G_InitPlayerFromCvars( &g_entities[0] );
+		}
+		return qtrue;
+	}
+
+	if ( Q_stricmp( cmd, "playerTint" ) == 0 )
+	{
+		if ( gi.argc() == 4 )
+		{
+			g_entities[0].client->renderInfo.customRGBA[0] = atoi(gi.argv(1));
+			g_entities[0].client->renderInfo.customRGBA[1] = atoi(gi.argv(2));
+			g_entities[0].client->renderInfo.customRGBA[2] = atoi(gi.argv(3));
+			gi.cvar_set("g_char_color_red", gi.argv(1) );
+			gi.cvar_set("g_char_color_green", gi.argv(2) );
+			gi.cvar_set("g_char_color_blue", gi.argv(3) );
+		}
+		else
+		{
+			gi.Printf( S_COLOR_RED"USAGE: playerTint <red 0 - 255> <green 0 - 255> <blue 0 - 255>\n" );
+			gi.Printf( "playerTint = %s\n", va("%d %d %d", g_char_color_red->integer, g_char_color_green->integer, g_char_color_blue->integer ) );
+		}
+		return qtrue;
+	}
+	if ( Q_stricmp( cmd, "nexttestaxes" ) == 0 )
+	{
+		G_NextTestAxes();
+	}
+
+	if ( Q_stricmp( cmd, "exitview" ) == 0 )
+	{
+		Svcmd_ExitView_f();
+	}
+	
+	if (Q_stricmp (cmd, "iknowkungfu") == 0)
+	{
+		gi.cvar_set( "g_debugMelee", "1" );
+		G_SetWeapon( &g_entities[0], WP_MELEE );
+		for ( int i = FP_FIRST; i < NUM_FORCE_POWERS; i++ )
+		{
+			g_entities[0].client->ps.forcePowersKnown |= ( 1 << i );
+			if ( i == FP_TELEPATHY )
+			{
+				g_entities[0].client->ps.forcePowerLevel[i] = FORCE_LEVEL_4;
+			}
+			else
+			{
+				g_entities[0].client->ps.forcePowerLevel[i] = FORCE_LEVEL_3;
+			}
+		}
+	}
+
+	return qfalse;
+}
+
diff --git a/code/game/g_target.cpp b/code/game/g_target.cpp
new file mode 100644
index 0000000..9326c18
--- /dev/null
+++ b/code/game/g_target.cpp
@@ -0,0 +1,1234 @@
+// leave this line at the top for all g_xxxx.cpp files...
+#include "g_headers.h"
+
+
+#include "Q3_Interface.h"
+#include "g_local.h"
+#include "g_functions.h"
+extern void G_SetEnemy( gentity_t *self, gentity_t *enemy );
+
+//==========================================================
+
+/*QUAKED target_give (1 0 0) (-8 -8 -8) (8 8 8)
+Gives the activator all the items pointed to.
+*/
+void Use_Target_Give( gentity_t *ent, gentity_t *other, gentity_t *activator ) {
+	gentity_t	*t;
+	trace_t		trace;
+
+	if ( !activator->client ) {
+		return;
+	}
+
+	if ( !ent->target ) {
+		return;
+	}
+
+	G_ActivateBehavior(ent,BSET_USE);
+
+	memset( &trace, 0, sizeof( trace ) );
+	t = NULL;
+	while ( (t = G_Find (t, FOFS(targetname), ent->target)) != NULL ) {
+		if ( !t->item ) {
+			continue;
+		}
+		Touch_Item( t, activator, &trace );
+
+		// make sure it isn't going to respawn or show any events
+		t->nextthink = 0;
+		gi.unlinkentity( t );
+	}
+}
+
+void SP_target_give( gentity_t *ent ) {
+	ent->e_UseFunc = useF_Use_Target_Give;
+}
+
+//==========================================================
+
+/*QUAKED target_delay (1 0 0) (-8 -8 -8) (8 8 8)
+"wait" seconds to pause before firing targets.
+"random" delay variance, total delay = delay +/- random seconds
+*/
+void Think_Target_Delay( gentity_t *ent ) 
+{
+	G_UseTargets( ent, ent->activator );
+}
+
+void Use_Target_Delay( gentity_t *ent, gentity_t *other, gentity_t *activator ) 
+{
+	G_ActivateBehavior(ent,BSET_USE);
+
+	ent->nextthink = level.time + ( ent->wait + ent->random * crandom() ) * 1000;
+	ent->e_ThinkFunc = thinkF_Think_Target_Delay;
+	ent->activator = activator;
+}
+
+void SP_target_delay( gentity_t *ent ) 
+{
+	// check delay for backwards compatability
+	if ( !G_SpawnFloat( "delay", "0", &ent->wait ) ) 
+	{
+		G_SpawnFloat( "wait", "1", &ent->wait );
+	}
+
+	if ( !ent->wait ) 
+	{
+		ent->wait = 1;
+	}
+
+	ent->e_UseFunc = useF_Use_Target_Delay;
+}
+
+
+//==========================================================
+
+/*QUAKED target_score (1 0 0) (-8 -8 -8) (8 8 8)
+"count" number of points to add, default 1
+
+The activator is given this many points.
+*/
+void Use_Target_Score (gentity_t *ent, gentity_t *other, gentity_t *activator) 
+{
+	G_ActivateBehavior(ent,BSET_USE);
+
+	AddScore( activator, ent->count );
+}
+
+void SP_target_score( gentity_t *ent ) {
+	if ( !ent->count ) {
+		ent->count = 1;
+	}
+	ent->e_UseFunc = useF_Use_Target_Score;
+}
+
+
+//==========================================================
+
+/*QUAKED target_print (1 0 0) (-8 -8 -8) (8 8 8)
+"message"	text to print
+If "private", only the activator gets the message.  If no checks, all clients get the message.
+*/
+void Use_Target_Print (gentity_t *ent, gentity_t *other, gentity_t *activator) 
+{
+	G_ActivateBehavior(ent,BSET_USE);
+
+	if ( activator->client ) {
+		gi.SendServerCommand( activator-g_entities, "cp \"%s\"", ent->message );
+	}
+}
+
+void SP_target_print( gentity_t *ent ) {
+	ent->e_UseFunc = useF_Use_Target_Print;
+}
+
+
+//==========================================================
+
+
+/*QUAKED target_speaker (1 0 0) (-8 -8 -8) (8 8 8) looped-on looped-off global activator
+"noise"		wav file to play
+
+"sounds" va() min max, so if your sound string is borgtalk%d.wav, and you set a "sounds" value of 4, it will randomly play borgtalk1.wav - borgtalk4.wav when triggered
+to use this, you must store the wav name in "soundGroup", NOT "noise"
+
+A global sound will play full volume throughout the level.
+Activator sounds will play on the player that activated the target.
+Global and activator sounds can't be combined with looping.
+Normal sounds play each time the target is used.
+Looped sounds will be toggled by use functions.
+Multiple identical looping sounds will just increase volume without any speed cost.
+"wait" : Seconds between triggerings, 0 = don't auto trigger
+"random"	wait variance, default is 0
+*/
+void Use_Target_Speaker (gentity_t *ent, gentity_t *other, gentity_t *activator) {
+	if(ent->painDebounceTime > level.time)
+	{
+		return;
+	}
+
+	G_ActivateBehavior(ent,BSET_USE);
+
+	if ( ent->sounds )
+	{
+		ent->noise_index = G_SoundIndex( va( ent->paintarget, Q_irand(1, ent->sounds ) ) );
+	}
+
+	if (ent->spawnflags & 3) {	// looping sound toggles
+		gentity_t *looper = ent;
+		if ( ent->spawnflags & 8 ) {
+			looper = activator;
+		}
+		if (looper->s.loopSound)
+			looper->s.loopSound = 0;	// turn it off
+		else
+			looper->s.loopSound = ent->noise_index;	// start it
+	}else {	// normal sound
+		if ( ent->spawnflags & 8 ) {
+			G_AddEvent( activator, EV_GENERAL_SOUND, ent->noise_index );
+		} else if (ent->spawnflags & 4) {
+			G_AddEvent( ent, EV_GLOBAL_SOUND, ent->noise_index );
+		} else {
+			G_AddEvent( ent, EV_GENERAL_SOUND, ent->noise_index );
+		}
+	}
+
+	if(ent->wait < 0)
+	{//BYE!
+		ent->e_UseFunc = useF_NULL;
+	}
+	else
+	{
+		ent->painDebounceTime = level.time + ent->wait;
+	}
+}
+
+void SP_target_speaker( gentity_t *ent ) {
+	char	buffer[MAX_QPATH];
+	char	*s;
+	int		i;
+
+	if ( VALIDSTRING( ent->soundSet ) )
+	{
+		VectorCopy( ent->s.origin, ent->s.pos.trBase );
+		gi.linkentity (ent);
+		return;
+	}
+
+	G_SpawnFloat( "wait", "0", &ent->wait );
+	G_SpawnFloat( "random", "0", &ent->random );
+
+	if(!ent->sounds)
+	{
+		if ( !G_SpawnString( "noise", "*NOSOUND*", &s ) ) {
+			G_Error( "target_speaker without a noise key at %s", vtos( ent->s.origin ) );
+		}
+
+		Q_strncpyz( buffer, s, sizeof(buffer) );
+		COM_DefaultExtension( buffer, sizeof(buffer), ".wav");
+		ent->noise_index = G_SoundIndex(buffer);
+	}
+	else
+	{//Precache all possible sounds
+		for( i = 0; i < ent->sounds; i++ )
+		{
+			ent->noise_index = G_SoundIndex( va( ent->paintarget, i+1 ) );
+		}
+	}
+
+	// a repeating speaker can be done completely client side
+	ent->s.eType = ET_SPEAKER;
+	ent->s.eventParm = ent->noise_index;
+	ent->s.frame = ent->wait * 10;
+	ent->s.clientNum = ent->random * 10;
+
+	ent->wait *= 1000;
+
+	// check for prestarted looping sound
+	if ( ent->spawnflags & 1 ) {
+		ent->s.loopSound = ent->noise_index;
+	}
+
+	ent->e_UseFunc = useF_Use_Target_Speaker;
+
+	if (ent->spawnflags & 4) {
+		ent->svFlags |= SVF_BROADCAST;
+	}
+
+	VectorCopy( ent->s.origin, ent->s.pos.trBase );
+
+	// must link the entity so we get areas and clusters so
+	// the server can determine who to send updates to
+	gi.linkentity (ent);
+}
+
+
+
+//==========================================================
+
+/*QUAKED target_laser (0 .5 .8) (-8 -8 -8) (8 8 8) START_ON
+When triggered, fires a laser.  You can either set a target or a direction.
+*/
+void target_laser_think (gentity_t *self) {
+	vec3_t	end;
+	trace_t	tr;
+	vec3_t	point;
+
+	// if pointed at another entity, set movedir to point at it
+	if ( self->enemy ) {
+		VectorMA (self->enemy->s.origin, 0.5, self->enemy->mins, point);
+		VectorMA (point, 0.5, self->enemy->maxs, point);
+		VectorSubtract (point, self->s.origin, self->movedir);
+		VectorNormalize (self->movedir);
+	}
+
+	// fire forward and see what we hit
+	VectorMA (self->s.origin, 2048, self->movedir, end);
+
+	gi.trace( &tr, self->s.origin, NULL, NULL, end, self->s.number, CONTENTS_SOLID|CONTENTS_BODY|CONTENTS_CORPSE);
+
+	if ( tr.entityNum ) {
+		// hurt it if we can
+		G_Damage ( &g_entities[tr.entityNum], self, self->activator, self->movedir, 
+			tr.endpos, self->damage, DAMAGE_NO_KNOCKBACK, MOD_ENERGY );
+	}
+
+	VectorCopy (tr.endpos, self->s.origin2);
+
+	gi.linkentity( self );
+	self->nextthink = level.time + FRAMETIME;
+}
+
+void target_laser_on (gentity_t *self)
+{
+	if (!self->activator)
+		self->activator = self;
+	target_laser_think (self);
+}
+
+void target_laser_off (gentity_t *self)
+{
+	gi.unlinkentity( self );
+	self->nextthink = 0;
+}
+
+void target_laser_use (gentity_t *self, gentity_t *other, gentity_t *activator)
+{
+	G_ActivateBehavior(self,BSET_USE);
+
+	self->activator = activator;
+	if ( self->nextthink > 0 )
+		target_laser_off (self);
+	else
+		target_laser_on (self);
+}
+
+void target_laser_start (gentity_t *self)
+{
+	gentity_t *ent;
+
+	self->s.eType = ET_BEAM;
+
+	if (self->target) {
+		ent = G_Find (NULL, FOFS(targetname), self->target);
+		if (!ent) {
+			gi.Printf ("%s at %s: %s is a bad target\n", self->classname, vtos(self->s.origin), self->target);
+		}
+		G_SetEnemy( self, ent );
+	} else {
+		G_SetMovedir (self->s.angles, self->movedir);
+	}
+
+	self->e_UseFunc   = useF_target_laser_use;
+	self->e_ThinkFunc = thinkF_target_laser_think;
+
+	if ( !self->damage ) {
+		self->damage = 1;
+	}
+
+	if (self->spawnflags & 1)
+		target_laser_on (self);
+	else
+		target_laser_off (self);
+}
+
+void SP_target_laser (gentity_t *self)
+{
+	// let everything else get spawned before we start firing
+	self->e_ThinkFunc = thinkF_target_laser_start;
+	self->nextthink = level.time + START_TIME_LINK_ENTS;
+}
+
+
+//==========================================================
+
+void target_teleporter_use( gentity_t *self, gentity_t *other, gentity_t *activator ) {
+	gentity_t	*dest;
+
+	if (!activator->client)
+		return;
+
+	G_ActivateBehavior(self,BSET_USE);
+
+	dest = 	G_PickTarget( self->target );
+	if (!dest) {
+		gi.Printf ("Couldn't find teleporter destination\n");
+		return;
+	}
+
+	TeleportPlayer( activator, dest->s.origin, dest->s.angles );
+}
+
+/*QUAK-ED target_teleporter (1 0 0) (-8 -8 -8) (8 8 8)
+The activator will be teleported away.
+*/
+void SP_target_teleporter( gentity_t *self ) {
+	if (!self->targetname)
+		gi.Printf("untargeted %s at %s\n", self->classname, vtos(self->s.origin));
+
+	self->e_UseFunc = useF_target_teleporter_use;
+}
+
+//==========================================================
+
+
+/*QUAKED target_relay (.5 .5 .5) (-8 -8 -8) (8 8 8) RED_ONLY BLUE_ONLY RANDOM x x x x INACTIVE
+This doesn't perform any actions except fire its targets.
+The activator can be forced to be from a certain team.
+if RANDOM is checked, only one of the targets will be fired, not all of them
+
+INACTIVE  Can't be used until activated
+
+  "delay" - Will actually fire this many seconds after being used
+  "wait" - Cannot be fired again until this many seconds after the last time it was used
+*/
+void target_relay_use_go (gentity_t *self ) 
+{
+	G_ActivateBehavior( self, BSET_USE );
+	
+	if ( self->spawnflags & 4 ) 
+	{
+		gentity_t	*ent;
+
+		ent = G_PickTarget( self->target );
+		if ( ent && (ent->e_UseFunc != useF_NULL) ) 
+		{	// e_UseFunc check can be omitted
+			GEntity_UseFunc( ent, self, self->activator );			
+		}
+		return;
+	}
+
+	G_UseTargets( self, self->activator );
+}
+
+void target_relay_use (gentity_t *self, gentity_t *other, gentity_t *activator) 
+{
+	if ( ( self->spawnflags & 1 ) && activator->client ) 
+	{//&& activator->client->ps.persistant[PERS_TEAM] != TEAM_RED ) {
+		return;
+	}
+
+	if ( ( self->spawnflags & 2 ) && activator->client ) 
+	{//&& activator->client->ps.persistant[PERS_TEAM] != TEAM_BLUE ) {
+		return;
+	}
+
+	if ( self->svFlags & SVF_INACTIVE )
+	{//set by target_deactivate
+		return;
+	}
+
+	if ( self->painDebounceTime > level.time )
+	{
+		return;
+	}
+
+	G_SetEnemy( self, other );
+	self->activator = activator;
+
+	if ( self->delay )
+	{
+		self->e_ThinkFunc = thinkF_target_relay_use_go;
+		self->nextthink = level.time + self->delay;
+		return;
+	}
+
+	target_relay_use_go( self );
+
+	if ( self->wait < 0 )
+	{
+		self->e_UseFunc = useF_NULL;
+	}
+	else
+	{
+		self->painDebounceTime = level.time + self->wait;
+	}
+}
+
+void SP_target_relay (gentity_t *self) 
+{
+	self->e_UseFunc = useF_target_relay_use;
+	self->wait *= 1000;
+	self->delay *= 1000;
+	if ( self->spawnflags&128 )
+	{
+		self->svFlags |= SVF_INACTIVE;
+	}
+}
+
+
+//==========================================================
+
+/*QUAKED target_kill (.5 .5 .5) (-8 -8 -8) (8 8 8) FALLING ELECTRICAL
+Kills the activator.
+*/
+void target_kill_use( gentity_t *self, gentity_t *other, gentity_t *activator ) {
+
+	G_ActivateBehavior(self,BSET_USE);
+
+	if ( self->spawnflags & 1 )
+	{//falling death
+		G_Damage ( activator, NULL, NULL, NULL, NULL, 100000, DAMAGE_NO_PROTECTION, MOD_FALLING );
+		if ( !activator->s.number && activator->health <= 0 && 1 )
+		{
+			extern void CGCam_Fade( vec4_t source, vec4_t dest, float duration );
+			float	src[4] = {0,0,0,0},dst[4]={0,0,0,1};
+			CGCam_Fade( src, dst, 10000 );
+		}
+	}
+	else if ( self->spawnflags & 2 ) // electrical
+	{
+		G_Damage ( activator, NULL, NULL, NULL, NULL, 100000, DAMAGE_NO_PROTECTION, MOD_ELECTROCUTE );
+		
+		if ( activator->client )
+		{
+			activator->s.powerups |= ( 1 << PW_SHOCKED );
+			activator->client->ps.powerups[PW_SHOCKED] = level.time + 4000;
+		}
+	}
+	else
+	{
+		G_Damage ( activator, NULL, NULL, NULL, NULL, 100000, DAMAGE_NO_PROTECTION, MOD_UNKNOWN);
+	}
+}
+
+void SP_target_kill( gentity_t *self ) 
+{
+	self->e_UseFunc = useF_target_kill_use;
+}
+
+/*QUAKED target_position (0 0.5 0) (-4 -4 -4) (4 4 4)
+Used as a positional target for in-game calculation, like jumppad targets.
+info_notnull does the same thing
+*/
+void SP_target_position( gentity_t *self ){
+	G_SetOrigin( self, self->s.origin );
+}
+
+//static -slc
+void target_location_linkup(gentity_t *ent)
+{
+	int i;
+
+	if (level.locationLinked) 
+		return;
+
+	level.locationLinked = qtrue;
+
+	level.locationHead = NULL;
+
+	for (i = 0, ent = g_entities; i < globals.num_entities; i++, ent++) {
+		if (ent->classname && !Q_stricmp(ent->classname, "target_location")) {
+			ent->nextTrain = level.locationHead;
+			level.locationHead = ent;
+		}
+	}
+
+	// All linked together now
+}
+
+/*QUAKED target_location (0 0.5 0) (-8 -8 -8) (8 8 8)
+Set "message" to the name of this location.
+Set "count" to 0-7 for color.
+0:white 1:red 2:green 3:yellow 4:blue 5:cyan 6:magenta 7:white
+
+Closest target_location in sight used for the location, if none
+in site, closest in distance
+*/
+void SP_target_location( gentity_t *self ){
+	self->e_ThinkFunc = thinkF_target_location_linkup;
+	self->nextthink = level.time + 1000;  // Let them all spawn first
+
+	G_SetOrigin( self, self->s.origin );
+}
+
+//===NEW===================================================================
+
+/*QUAKED target_counter (1.0 0 0) (-4 -4 -4) (4 4 4) x x x x x x x INACTIVE
+Acts as an intermediary for an action that takes multiple inputs.
+
+INACTIVE cannot be used until used by a target_activate
+
+target2 - what the counter should fire each time it's incremented and does NOT reach it's count
+
+After the counter has been triggered "count" times (default 2), it will fire all of it's targets and remove itself.
+
+bounceCount - number of times the counter should reset to it's full count when it's done
+*/
+
+void target_counter_use( gentity_t *self, gentity_t *other, gentity_t *activator )
+{
+	if ( self->count == 0 )
+	{
+		return;
+	}
+	
+	//gi.Printf("target_counter %s used by %s, entnum %d\n", self->targetname, activator->targetname, activator->s.number );
+	self->count--;
+
+	if ( activator )
+	{
+		Quake3Game()->DebugPrint( IGameInterface::WL_VERBOSE, "target_counter %s used by %s (%d/%d)\n", self->targetname, activator->targetname, (self->max_health-self->count), self->max_health );
+	}
+
+	if ( self->count )
+	{
+		if ( self->target2 )
+		{
+			//gi.Printf("target_counter %s firing target2 from %s, entnum %d\n", self->targetname, activator->targetname, activator->s.number );
+			G_UseTargets2( self, activator, self->target2 );
+		}
+		return;
+	}
+	
+	G_ActivateBehavior( self,BSET_USE );
+
+	if ( self->spawnflags & 128 )
+	{
+		self->svFlags |= SVF_INACTIVE;
+	}
+
+	self->activator = activator;
+	G_UseTargets( self, activator );
+
+	if ( self->count == 0 )
+	{
+		if ( self->bounceCount == 0 )
+		{
+			return;
+		}
+		self->count = self->max_health;
+		if ( self->bounceCount > 0 )
+		{//-1 means bounce back forever
+			self->bounceCount--; 
+		}
+	}
+}
+
+void SP_target_counter (gentity_t *self)
+{
+	self->wait = -1;
+	if (!self->count)
+	{
+		self->count = 2;
+	}
+	//if ( self->bounceCount > 0 )//let's always set this anyway
+	{//we will reset when we use up our count, remember our initial count
+		self->max_health = self->count;
+	}
+
+	self->e_UseFunc = useF_target_counter_use;
+}
+
+/*QUAKED target_random (.5 .5 .5) (-4 -4 -4) (4 4 4) USEONCE
+Randomly fires off only one of it's targets each time used
+
+USEONCE	set to never fire again
+*/
+
+void target_random_use(gentity_t *self, gentity_t *other, gentity_t *activator)
+{
+	int			t_count = 0, pick;
+	gentity_t	*t = NULL;
+
+	//gi.Printf("target_random %s used by %s (entnum %d)\n", self->targetname, activator->targetname, activator->s.number );
+	G_ActivateBehavior(self,BSET_USE);
+
+	if(self->spawnflags & 1)
+	{
+		self->e_UseFunc = useF_NULL;
+	}
+
+	while ( (t = G_Find (t, FOFS(targetname), self->target)) != NULL )
+	{
+		if (t != self)
+		{
+			t_count++;
+		}
+	}
+
+	if(!t_count)
+	{
+		return;
+	}
+
+	if(t_count == 1)
+	{
+		G_UseTargets (self, activator);
+		return;
+	}
+
+	//FIXME: need a seed
+	pick = Q_irand(1, t_count);
+	t_count = 0;
+	while ( (t = G_Find (t, FOFS(targetname), self->target)) != NULL )
+	{
+		if (t != self)
+		{
+			t_count++;
+		}
+		else
+		{
+			continue;
+		}
+		
+		if (t == self)
+		{
+//				gi.Printf ("WARNING: Entity used itself.\n");
+		}
+		else if(t_count == pick)
+		{
+			if (t->e_UseFunc != useF_NULL)	// check can be omitted
+			{
+				GEntity_UseFunc(t, self, activator);
+				return;
+			}
+		}
+
+		if (!self->inuse)
+		{
+			gi.Printf("entity was removed while using targets\n");
+			return;
+		}
+	}
+}
+
+void SP_target_random (gentity_t *self)
+{
+	self->e_UseFunc = useF_target_random_use;
+}
+
+int	numNewICARUSEnts = 0;
+void scriptrunner_run (gentity_t *self)
+{
+	/*
+	if (self->behaviorSet[BSET_USE])
+	{	
+		char	newname[MAX_FILENAME_LENGTH];
+
+		sprintf((char *) &newname, "%s/%s", Q3_SCRIPT_DIR, self->behaviorSet[BSET_USE] );
+
+		ICARUS_RunScript( self, newname );
+	}
+	*/
+
+	if ( self->count != -1 )
+	{
+		if ( self->count <= 0 )
+		{
+			self->e_UseFunc = useF_NULL;
+			self->behaviorSet[BSET_USE] = NULL;
+			return;
+		}
+		else
+		{
+			--self->count;
+		}
+	}
+
+	if (self->behaviorSet[BSET_USE])
+	{
+		if ( self->spawnflags & 1 )
+		{
+			if ( !self->activator )
+			{
+				Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "target_scriptrunner tried to run on invalid entity!\n");
+				return;
+			}
+
+			if ( self->activator->m_iIcarusID == IIcarusInterface::ICARUS_INVALID )
+			{//Need to be initialized through ICARUS
+				if ( !self->activator->script_targetname || !self->activator->script_targetname[0] )
+				{
+					//We don't have a script_targetname, so create a new one
+					self->activator->script_targetname = va( "newICARUSEnt%d", numNewICARUSEnts++ );
+				}
+
+				if ( Quake3Game()->ValidEntity( self->activator ) )
+				{
+					Quake3Game()->InitEntity( self->activator );
+				}
+				else
+				{
+					Quake3Game()->DebugPrint( IGameInterface::WL_ERROR, "target_scriptrunner tried to run on invalid ICARUS activator!\n");
+					return;
+				}
+			}
+
+			Quake3Game()->DebugPrint( IGameInterface::WL_VERBOSE, "target_scriptrunner running %s on activator %s\n", self->behaviorSet[BSET_USE], self->activator->targetname );
+
+			Quake3Game()->RunScript( self->activator, self->behaviorSet[BSET_USE] );
+		}
+		else
+		{
+			if ( self->activator )
+			{
+				Quake3Game()->DebugPrint( IGameInterface::WL_VERBOSE, "target_scriptrunner %s used by %s\n", self->targetname, self->activator->targetname );
+			}
+			G_ActivateBehavior( self, BSET_USE );
+		}
+	}
+
+	if ( self->wait )
+	{
+		self->nextthink = level.time + self->wait;
+	}
+}
+
+void target_scriptrunner_use(gentity_t *self, gentity_t *other, gentity_t *activator)
+{
+	if ( self->nextthink > level.time )
+	{
+		return;
+	}
+
+	self->activator = activator;
+	G_SetEnemy( self, other );
+	if ( self->delay )
+	{//delay before firing scriptrunner
+		self->e_ThinkFunc = thinkF_scriptrunner_run;
+		self->nextthink = level.time + self->delay;
+	}
+	else
+	{
+		scriptrunner_run (self);
+	}
+}
+
+/*QUAKED target_scriptrunner (1 0 0) (-4 -4 -4) (4 4 4) runonactivator x x x x x x INACTIVE
+--- SPAWNFLAGS ---
+runonactivator - Will run the script on the entity that used this or tripped the trigger that used this
+INACTIVE - start off
+
+----- KEYS ------
+Usescript - Script to run when used
+count - how many times to run, -1 = infinite.  Default is once
+wait - can't be used again in this amount of seconds (Default is 1 second if it's multiple-use)
+delay - how long to wait after use to run script
+
+*/
+void SP_target_scriptrunner( gentity_t *self )
+{
+	if (!self->behaviorSet[BSET_USE])
+	{
+		gi.Printf(S_COLOR_RED "SP_target_scriptrunner %s has no USESCRIPT\n", self->targetname );
+	}
+	if ( self->spawnflags & 128 )
+	{
+		self->svFlags |= SVF_INACTIVE;
+	}
+
+	if ( !self->count )
+	{
+		self->count = 1;//default 1 use only
+	}
+	/*
+	else if ( !self->wait )
+	{
+		self->wait = 1;//default wait of 1 sec
+	}
+	*/
+	// FIXME: this is a hack... because delay is read in as an int, so I'm bypassing that because it's too late in the project to change it and I want to be able to set less than a second delays
+	// no one should be setting a radius on a scriptrunner, if they are this would be bad, take this out for the next project
+	self->radius = 0.0f;
+	G_SpawnFloat( "delay", "0", &self->radius );
+	self->delay = self->radius * 1000;//sec to ms
+	self->wait *= 1000;//sec to ms
+
+	G_SetOrigin( self, self->s.origin );
+	self->e_UseFunc = useF_target_scriptrunner_use;
+}
+
+void target_gravity_change_use(gentity_t *self, gentity_t *other, gentity_t *activator)
+{
+	G_ActivateBehavior(self,BSET_USE);
+
+	if ( self->spawnflags & 1 )
+	{
+		gi.cvar_set("g_gravity", va("%f", self->speed));
+	}
+	else if ( activator->client )
+	{
+		int	grav = floor(self->speed);
+		/*
+		if ( activator->client->ps.gravity != grav )
+		{
+			gi.Printf("%s gravity changed to %d\n", activator->targetname, grav );
+		}
+		*/
+		activator->client->ps.gravity = grav;
+		activator->svFlags |= SVF_CUSTOM_GRAVITY;
+		//FIXME: need a way to set this back to normal?
+	}
+}
+
+/*QUAKED target_gravity_change (1 0 0) (-4 -4 -4) (4 4 4) GLOBAL
+
+"gravity" - Normal = 800, Valid range: any
+
+GLOBAL - Apply to entire world, not just the activator
+*/
+void SP_target_gravity_change( gentity_t *self )
+{
+	G_SetOrigin( self, self->s.origin );
+	G_SpawnFloat( "gravity", "0", &self->speed );
+	self->e_UseFunc = useF_target_gravity_change_use;
+}
+
+void target_friction_change_use(gentity_t *self, gentity_t *other, gentity_t *activator)
+{
+	G_ActivateBehavior(self,BSET_USE);
+
+	if(self->spawnflags & 1)
+	{//FIXME - make a global?
+		//gi.Cvar_Set("g_friction", va("%d", self->health));
+	}
+	else if(activator->client)
+	{
+		activator->client->ps.friction = self->health;
+	}
+}
+
+/*QUAKED target_friction_change (1 0 0) (-4 -4 -4) (4 4 4)
+
+"friction" Normal = 6, Valid range 0 - 10
+
+*/
+void SP_target_friction_change( gentity_t *self )
+{
+	G_SetOrigin( self, self->s.origin );
+	self->e_UseFunc = useF_target_friction_change_use;
+}
+
+void set_mission_stats_cvars( void )
+{
+	char text[1024]={0};
+
+	//we'll assume that the activator is the player
+	gclient_t* const client = &level.clients[0];
+
+	if (!client)
+	{
+		return;
+	}
+	cg_entities[0].gent->client->sess.missionStats.enemiesKilled;
+
+	gi.cvar_set("ui_stats_enemieskilled", va("%d",client->sess.missionStats.enemiesKilled));	//pass this on to the menu
+
+	if (cg_entities[0].gent->client->sess.missionStats.totalSecrets)
+	{
+		cgi_SP_GetStringTextString( "SP_INGAME_SECRETAREAS_OF", text, sizeof(text) );
+		gi.cvar_set("ui_stats_secretsfound", va("%d %s %d",
+			cg_entities[0].gent->client->sess.missionStats.secretsFound,
+			text,
+			cg_entities[0].gent->client->sess.missionStats.totalSecrets));
+	}
+	else	// Setting ui_stats_secretsfound to 0 will hide the text on screen 
+	{
+		gi.cvar_set("ui_stats_secretsfound", "0");
+	}
+
+	// Find the favorite weapon
+	int wpn=0,i;
+	int max_wpn = cg_entities[0].gent->client->sess.missionStats.weaponUsed[0];
+	for (i = 1; i<WP_NUM_WEAPONS; i++)
+	{
+		if (cg_entities[0].gent->client->sess.missionStats.weaponUsed[i] > max_wpn)
+		{
+			max_wpn = cg_entities[0].gent->client->sess.missionStats.weaponUsed[i];
+			wpn = i;
+		}
+	}
+
+	if ( wpn )
+	{
+		gitem_t	*wItem= FindItemForWeapon( (weapon_t)wpn);
+		cgi_SP_GetStringTextString( va("SP_INGAME_%s",wItem->classname ), text, sizeof( text ));
+		gi.cvar_set("ui_stats_fave", va("%s",text));	//pass this on to the menu
+	}
+
+	gi.cvar_set("ui_stats_shots", va("%d",client->sess.missionStats.shotsFired));				//pass this on to the menu
+
+	gi.cvar_set("ui_stats_hits", va("%d",client->sess.missionStats.hits));						//pass this on to the menu
+
+	const float percent = cg_entities[0].gent->client->sess.missionStats.shotsFired? 100.0f * (float)cg_entities[0].gent->client->sess.missionStats.hits / cg_entities[0].gent->client->sess.missionStats.shotsFired : 0;
+	gi.cvar_set("ui_stats_accuracy", va("%.2f%%",percent));						//pass this on to the menu
+
+	gi.cvar_set("ui_stats_thrown", va("%d",client->sess.missionStats.saberThrownCnt));						//pass this on to the menu
+
+	gi.cvar_set("ui_stats_blocks", va("%d",client->sess.missionStats.saberBlocksCnt));
+	gi.cvar_set("ui_stats_legattacks", va("%d",client->sess.missionStats.legAttacksCnt));
+	gi.cvar_set("ui_stats_armattacks", va("%d",client->sess.missionStats.armAttacksCnt));
+	gi.cvar_set("ui_stats_bodyattacks", va("%d",client->sess.missionStats.torsoAttacksCnt));
+
+	gi.cvar_set("ui_stats_absorb", va("%d",client->sess.missionStats.forceUsed[FP_ABSORB]));
+	gi.cvar_set("ui_stats_heal", va("%d",client->sess.missionStats.forceUsed[FP_HEAL]));
+	gi.cvar_set("ui_stats_mindtrick", va("%d",client->sess.missionStats.forceUsed[FP_TELEPATHY]));
+	gi.cvar_set("ui_stats_protect", va("%d",client->sess.missionStats.forceUsed[FP_PROTECT]));
+
+	gi.cvar_set("ui_stats_jump", va("%d",client->sess.missionStats.forceUsed[FP_LEVITATION]));
+	gi.cvar_set("ui_stats_pull", va("%d",client->sess.missionStats.forceUsed[FP_PULL]));
+	gi.cvar_set("ui_stats_push", va("%d",client->sess.missionStats.forceUsed[FP_PUSH]));
+	gi.cvar_set("ui_stats_sense", va("%d",client->sess.missionStats.forceUsed[FP_SEE]));
+	gi.cvar_set("ui_stats_speed", va("%d",client->sess.missionStats.forceUsed[FP_SPEED]));
+	gi.cvar_set("ui_stats_defense", va("%d",client->sess.missionStats.forceUsed[FP_SABER_DEFENSE]));
+	gi.cvar_set("ui_stats_offense", va("%d",client->sess.missionStats.forceUsed[FP_SABER_OFFENSE]));
+	gi.cvar_set("ui_stats_throw", va("%d",client->sess.missionStats.forceUsed[FP_SABERTHROW]));
+
+	gi.cvar_set("ui_stats_drain", va("%d",client->sess.missionStats.forceUsed[FP_DRAIN]));
+	gi.cvar_set("ui_stats_grip", va("%d",client->sess.missionStats.forceUsed[FP_GRIP]));
+	gi.cvar_set("ui_stats_lightning", va("%d",client->sess.missionStats.forceUsed[FP_LIGHTNING]));
+	gi.cvar_set("ui_stats_rage", va("%d",client->sess.missionStats.forceUsed[FP_RAGE]));
+
+}
+
+#include "..\cgame\cg_media.h"	//access to cgs
+extern void G_ChangeMap (const char *mapname, const char *spawntarget, qboolean hub);	//g_utils
+void target_level_change_use(gentity_t *self, gentity_t *other, gentity_t *activator)
+{
+	G_ActivateBehavior(self,BSET_USE);
+
+	if( self->message && !Q_stricmp( "disconnect", self->message ) )
+	{
+		gi.SendConsoleCommand( "disconnect\n");
+	}
+	else
+	{
+		G_ChangeMap( self->message, self->target, (self->spawnflags&1) );
+	}
+	if (self->count>=0)
+	{
+		gi.cvar_set("tier_storyinfo", va("%i",self->count));
+		if (level.mapname[0] == 't' && level.mapname[2] == '_'
+			&& ( level.mapname[1] == '1' || level.mapname[1] == '2' || level.mapname[1] == '3' ) 
+			)
+		{
+			char s[2048];
+			gi.Cvar_VariableStringBuffer("tiers_complete", s, sizeof(s));	//get the current list
+			if (*s)
+			{
+				gi.cvar_set("tiers_complete", va("%s %s", s, level.mapname));	//strcat this level into the existing list
+			}
+			else
+			{
+				gi.cvar_set("tiers_complete", level.mapname);	//set this level into the list
+			}
+		}
+		if (self->noise_index)
+		{
+			cgi_S_StopSounds();
+			cgi_S_StartSound( NULL, 0, CHAN_VOICE, cgs.sound_precache[ self->noise_index ] );
+		}
+	}
+
+	set_mission_stats_cvars();
+
+}
+
+/*QUAKED target_level_change (1 0 0) (-4 -4 -4) (4 4 4) HUB NO_STORYSOUND
+HUB - Will save the current map's status and load the next map with any saved status it may have
+NO_STORYSOUND - will not play storyinfo wav file, even if you '++' or set tier_storyinfo
+
+"mapname" - Name of map to change to or "+menuname" to launch a menu instead
+"target" - Name of spawnpoint to start at in the new map
+"tier_storyinfo" - integer to set cvar or "++" to just increment
+"storyhead"	 - which head to show on menu [luke, kyle, or prot]
+"saber_menu" - integer to set cvar for menu
+"weapon_menu" - integer to set cvar for ingame weapon menu
+*/
+void SP_target_level_change( gentity_t *self )
+{
+	if ( !self->message )
+	{
+		G_Error( "target_level_change with no mapname!\n");
+		return;
+	}
+	
+	char *s;
+	if (G_SpawnString( "tier_storyinfo", "", &s )) 
+	{
+		if (*s == '+')
+		{
+			self->noise_index = G_SoundIndex(va("sound/chars/tiervictory/%s.mp3",level.mapname) );
+			self->count = gi.Cvar_VariableIntegerValue("tier_storyinfo")+1;
+								G_SoundIndex(va("sound/chars/storyinfo/%d.mp3",self->count));	//cache for menu
+		}
+		else
+		{
+			self->count = atoi(s);
+			if( !(self->spawnflags & 2) )
+			{
+				self->noise_index = G_SoundIndex(va("sound/chars/storyinfo/%d.mp3",self->count) );
+			}
+		}
+
+		if (G_SpawnString( "storyhead", "", &s ))
+		{	//[luke, kyle, or prot]
+			gi.cvar_set("storyhead", s);	//pass this on to the menu
+		}
+		else
+		{	//show head based on mapname
+			gi.cvar_set("storyhead", level.mapname);	//pass this on to the menu
+		}
+	}
+	if (G_SpawnString( "saber_menu", "", &s )) 
+	{
+		gi.cvar_set("saber_menu", s);	//pass this on to the menu
+	}
+
+	if (G_SpawnString( "weapon_menu", "1", &s )) 
+	{
+		gi.cvar_set("weapon_menu", s);	//pass this on to the menu
+	}
+	else
+	{
+		gi.cvar_set("weapon_menu", "0");	//pass this on to the menu
+	}
+
+	G_SetOrigin( self, self->s.origin );
+	self->e_UseFunc = useF_target_level_change_use;
+}
+
+/*QUAKED target_change_parm (1 0 0) (-4 -4 -4) (4 4 4)
+Copies any parms set on this ent to the entity that  fired the trigger/button/whatever that uses this
+parm1
+parm2
+parm3
+parm4
+parm5
+parm6
+parm7
+parm8
+parm9
+parm10
+parm11
+parm12
+parm13
+parm14
+parm15
+parm16
+*/
+void Q3_SetParm (int entID, int parmNum, const char *parmValue);
+void target_change_parm_use(gentity_t *self, gentity_t *other, gentity_t *activator)
+{
+	if ( !activator || !self )
+	{
+		return;
+	}
+
+	//FIXME: call capyparms
+	if ( self->parms )
+	{
+		for ( int parmNum = 0; parmNum < MAX_PARMS; parmNum++ )
+		{
+			if ( self->parms->parm[parmNum] && self->parms->parm[parmNum][0] )
+			{
+				Q3_SetParm( activator->s.number, parmNum, self->parms->parm[parmNum] );
+			}
+		}
+	}
+}
+
+void SP_target_change_parm( gentity_t *self )
+{
+	if ( !self->parms )
+	{//ERROR!
+		return;
+	}
+	G_SetOrigin( self, self->s.origin );
+	self->e_UseFunc = useF_target_change_parm_use;
+}
+
+void target_play_music_use(gentity_t *self, gentity_t *other, gentity_t *activator)
+{
+	G_ActivateBehavior(self,BSET_USE);
+	gi.SetConfigstring( CS_MUSIC, self->message );
+}
+
+/*QUAKED target_play_music (1 0 0) (-4 -4 -4) (4 4 4)
+target_play_music
+Plays the requested music files when this target is used.
+
+"targetname"
+"music"		music WAV or MP3 file ( music/introfile.mp3 [optional]  music/loopfile.mp3 )
+
+If an intro file and loop file are specified, the intro plays first, then the looping
+portion will start and loop indefinetly.  If no introfile is entered, only the loopfile
+will play.
+*/
+void SP_target_play_music( gentity_t *self )
+{
+	char *s;
+	G_SetOrigin( self, self->s.origin );
+	if (!G_SpawnString( "music", "", &s )) {
+		G_Error( "target_play_music without a music key at %s", vtos( self->s.origin ) );
+	}
+	self->message = G_NewString (s);
+	self->e_UseFunc = useF_target_play_music_use;
+extern	cvar_t	*com_buildScript;
+	//Precache!
+	if (com_buildScript->integer) {//copy this puppy over
+		char buffer[MAX_QPATH];
+		fileHandle_t	hFile;
+
+		Q_strncpyz( buffer, s, sizeof(buffer) );
+		COM_DefaultExtension( buffer, sizeof(buffer), ".mp3");
+		
+		gi.FS_FOpenFile(buffer, &hFile, FS_READ);
+		if (hFile) {
+			gi.FS_FCloseFile( hFile );
+		}
+	}
+}
+
+void target_autosave_use(gentity_t *self, gentity_t *other, gentity_t *activator)
+{
+	G_ActivateBehavior(self,BSET_USE);
+	//gi.SendServerCommand( NULL, "cp @SP_INGAME_CHECKPOINT" );
+	CG_CenterPrint( "@SP_INGAME_CHECKPOINT", SCREEN_HEIGHT * 0.25 );	//jump the network
+
+	gi.SendConsoleCommand( "wait 2;save auto\n" );
+}
+
+/*QUAKED target_autosave (1 0 0) (-4 -4 -4) (4 4 4)
+Auto save the game in two frames.
+Make sure it won't trigger during dialogue or cinematic or it will stutter!
+*/
+void SP_target_autosave( gentity_t *self )
+{
+	G_SetOrigin( self, self->s.origin );
+	self->e_UseFunc = useF_target_autosave_use;
+}
+
+void target_secret_use(gentity_t *self, gentity_t *other, gentity_t *activator)
+{	 
+	//we'll assume that the activator is the player
+	gclient_t* const client = &level.clients[0];
+	client->sess.missionStats.secretsFound++;
+	if ( activator )
+	{
+		G_Sound( activator, self->noise_index );
+	}
+	else
+	{
+		G_Sound( self, self->noise_index );
+	}
+	gi.SendServerCommand( NULL, "cp @SP_INGAME_SECRET_AREA" );
+	assert(client->sess.missionStats.totalSecrets);
+}
+
+/*QUAKED target_secret (1 0 1) (-4 -4 -4) (4 4 4)
+You found a Secret!
+"count" - how many secrets on this level,
+          if more than one on a level, be sure they all have the same count!
+*/
+void SP_target_secret( gentity_t *self ) 
+{
+	G_SetOrigin( self, self->s.origin );
+	self->e_UseFunc = useF_target_secret_use;
+	self->noise_index = G_SoundIndex("sound/interface/secret_area");
+	if (self->count)
+	{
+		gi.cvar_set("newTotalSecrets", va("%i",self->count));
+	}
+}
diff --git a/code/game/g_trigger.cpp b/code/game/g_trigger.cpp
new file mode 100644
index 0000000..d6180c9
--- /dev/null
+++ b/code/game/g_trigger.cpp
@@ -0,0 +1,1685 @@
+// leave this line at the top for all g_xxxx.cpp files...
+#include "g_headers.h"
+
+
+#include "g_local.h"
+#include "g_functions.h"
+#include "b_local.h"
+#include "anims.h"
+
+#define ENTDIST_PLAYER	1
+#define ENTDIST_NPC		2
+
+extern qboolean G_PointInBounds( const vec3_t point, const vec3_t mins, const vec3_t maxs );
+extern qboolean G_ClearTrace( const vec3_t start, const vec3_t mins, const vec3_t maxs, const vec3_t end, int ignore, int clipmask );
+extern qboolean SpotWouldTelefrag2( gentity_t *mover, vec3_t dest );
+extern qboolean PM_CrouchAnim( int anim );
+extern void Boba_FlyStart( gentity_t *self );
+extern qboolean Boba_Flying( gentity_t *self );
+
+void InitTrigger( gentity_t *self ) {
+	if (!VectorCompare (self->s.angles, vec3_origin))
+		G_SetMovedir (self->s.angles, self->movedir);
+
+	gi.SetBrushModel( self, self->model );
+	self->contents = CONTENTS_TRIGGER;		// replaces the -1 from gi.SetBrushModel
+	self->svFlags = SVF_NOCLIENT;
+
+	if(self->spawnflags & 128)
+	{
+		self->svFlags |= SVF_INACTIVE;
+	}
+}
+
+
+// the wait time has passed, so set back up for another activation
+void multi_wait( gentity_t *ent ) {
+	ent->nextthink = 0;
+}
+
+
+// the trigger was just activated
+// ent->activator should be set to the activator so it can be held through a delay
+// so wait for the delay time before firing
+void multi_trigger_run( gentity_t *ent ) 
+{
+	ent->e_ThinkFunc = thinkF_NULL;
+
+	G_ActivateBehavior( ent, BSET_USE );
+
+	if ( ent->soundSet && ent->soundSet[0] )
+	{
+		gi.SetConfigstring( CS_AMBIENT_SET, ent->soundSet );
+	}
+
+	G_UseTargets (ent, ent->activator);
+	if ( ent->noise_index ) 
+	{
+		G_Sound( ent->activator, ent->noise_index );
+	}
+
+	if ( ent->target2 && ent->target2[0] && ent->wait >= 0 )
+	{
+		ent->e_ThinkFunc = thinkF_trigger_cleared_fire;
+		ent->nextthink = level.time + ent->speed;
+	}
+	else if ( ent->wait > 0 ) 
+	{
+		if ( ent->painDebounceTime != level.time )
+		{//first ent to touch it this frame
+			//ent->e_ThinkFunc = thinkF_multi_wait;
+			ent->nextthink = level.time + ( ent->wait + ent->random * crandom() ) * 1000;
+			ent->painDebounceTime = level.time;
+		}
+	} 
+	else if ( ent->wait < 0 )
+	{
+		// we can't just remove (self) here, because this is a touch function
+		// called while looping through area links...
+		ent->contents &= ~CONTENTS_TRIGGER;//so the EntityContact trace doesn't have to be done against me
+		ent->e_TouchFunc = touchF_NULL;
+		ent->e_UseFunc = useF_NULL;
+		//Don't remove, Icarus may barf?
+		//ent->nextthink = level.time + FRAMETIME;
+		//ent->think = G_FreeEntity;
+	}
+	if( ent->activator && ent->activator->s.number == 0 )
+	{	// mark the trigger as being touched by the player
+		ent->aimDebounceTime = level.time;
+	}
+}
+
+
+void multi_trigger( gentity_t *ent, gentity_t *activator ) 
+{
+	if ( ent->e_ThinkFunc == thinkF_multi_trigger_run )
+	{//already triggered, just waiting to run
+		return;
+	}
+
+	if ( ent->nextthink > level.time ) 
+	{
+		if( ent->spawnflags & 2048 ) // MULTIPLE - allow multiple entities to touch this trigger in a single frame
+		{
+			if ( ent->painDebounceTime && ent->painDebounceTime != level.time )
+			{//this should still allow subsequent ents to fire this trigger in the current frame
+				return;		// can't retrigger until the wait is over
+			}
+		}
+		else
+		{
+			return;
+		}
+
+	}
+	if ( ent->spawnflags & 32)
+	{
+		ent->nextthink = level.time + ent->delay;
+
+	//	trace_t	viewTrace;
+	//	gi.trace(&viewTrace, ent->currentOrigin, 0, 0, activator->currentOrigin, ent->s.number, MASK_SHOT);
+	//	if ((viewTrace.allsolid) || (viewTrace.startsolid) || 	(viewTrace.entityNum!=activator->s.number))
+	//	{
+	//		return;
+	//	}
+	}
+
+
+	// if the player has already activated this trigger this frame
+	if( activator && !activator->s.number && ent->aimDebounceTime == level.time )
+	{
+		return;	
+	}
+
+	if ( ent->svFlags & SVF_INACTIVE )
+	{//Not active at this time
+		return;
+	}
+
+	ent->activator = activator;
+
+	if(ent->delay && ent->painDebounceTime < (level.time + ent->delay) )
+	{//delay before firing trigger
+		ent->e_ThinkFunc = thinkF_multi_trigger_run;
+		ent->nextthink = level.time + ent->delay;
+		ent->painDebounceTime = level.time;
+		
+	}
+	else
+	{
+		multi_trigger_run (ent);
+	}
+}
+
+void Use_Multi( gentity_t *ent, gentity_t *other, gentity_t *activator ) 
+{
+	multi_trigger( ent, activator );
+}
+
+extern	int	Pilot_ActivePilotCount(void);
+
+void Touch_Multi( gentity_t *self, gentity_t *other, trace_t *trace ) 
+{
+	if( !other->client ) 
+	{
+		return;
+	}
+
+	if ( self->svFlags & SVF_INACTIVE )
+	{//set by target_deactivate
+		return;
+	}
+
+	if( self->noDamageTeam )
+	{
+		if ( other->client->playerTeam != self->noDamageTeam )
+		{
+			return;
+		}
+	}
+
+// moved to just above multi_trigger because up here it just checks if the trigger is not being touched
+// we want it to check any conditions set on the trigger, if one of those isn't met, the trigger is considered to be "cleared"
+//	if ( self->e_ThinkFunc == thinkF_trigger_cleared_fire )
+//	{//We're waiting to fire our target2 first
+//		self->nextthink = level.time + self->speed;
+//		return;
+//	}
+
+	if ( self->spawnflags & 1 )
+	{
+		if ( other->s.number != 0 )
+		{
+			return;
+		}
+	}
+	else
+	{
+		if ( self->spawnflags & 16 )
+		{//NPCONLY
+			if ( other->NPC == NULL )
+			{
+				return;
+			}
+		}
+
+		if ( self->NPC_targetname && self->NPC_targetname[0] )
+		{
+			if ( other->script_targetname && other->script_targetname[0] )
+			{
+				if ( Q_stricmp( self->NPC_targetname, other->script_targetname ) != 0 )
+				{//not the right guy to fire me off
+					return;
+				}
+			}
+			else
+			{
+				return;
+			}
+		}
+	}
+
+	if ( self->spawnflags & 4 )
+	{//USE_BUTTON
+		if ( !other->client )
+		{
+			return;
+		}
+
+		if( !( other->client->usercmd.buttons & BUTTON_USE ) )
+		{//not pressing use button
+			return;
+		}
+	}
+
+	if ( self->spawnflags & 2 )
+	{//FACING
+		vec3_t	forward;
+
+		if ( other->client )
+		{
+			AngleVectors( other->client->ps.viewangles, forward, NULL, NULL );
+		}
+		else
+		{
+			AngleVectors( other->currentAngles, forward, NULL, NULL );
+		}
+
+		if ( DotProduct( self->movedir, forward ) < 0.5 )
+		{//Not Within 45 degrees
+			return;
+		}
+	}
+
+	if ( self->spawnflags & 8 )
+	{//FIRE_BUTTON
+		if ( !other->client )
+		{
+			return;
+		}
+
+		if( !( other->client->ps.eFlags & EF_FIRING /*usercmd.buttons & BUTTON_ATTACK*/ ) &&
+			!( other->client->ps.eFlags & EF_ALT_FIRING/*usercmd.buttons & BUTTON_ALT_ATTACK*/ ) )
+		{//not pressing fire button or altfire button
+			return;
+		}
+
+		//FIXME: do we care about the sniper rifle or not?
+
+		if( other->s.number == 0 && ( other->client->ps.weapon > MAX_PLAYER_WEAPONS || other->client->ps.weapon <= WP_NONE ) )
+		{//don't care about non-player weapons if this is the player
+			return;
+		}
+	}
+
+	if ( other->client && self->radius )
+	{
+		vec3_t	eyeSpot;
+
+		//Only works if your head is in it, but we allow leaning out
+		//NOTE: We don't use CalcEntitySpot SPOT_HEAD because we don't want this
+		//to be reliant on the physical model the player uses.
+		VectorCopy(other->currentOrigin, eyeSpot);
+		eyeSpot[2] += other->client->ps.viewheight;
+
+		if ( G_PointInBounds( eyeSpot, self->absmin, self->absmax ) )
+		{
+			if( !( other->client->ps.eFlags & EF_FIRING ) &&
+				!( other->client->ps.eFlags & EF_ALT_FIRING ) )
+			{//not attacking, so hiding bonus
+				//FIXME:  should really have sound events clear the hiddenDist
+				other->client->hiddenDist = self->radius;
+				//NOTE: movedir HAS to be normalized!
+				if ( VectorLength( self->movedir ) )
+				{//They can only be hidden from enemies looking in this direction
+					VectorCopy( self->movedir, other->client->hiddenDir );
+				}
+				else
+				{
+					VectorClear( other->client->hiddenDir );
+				}
+			}
+		}
+	}
+
+	if ( self->spawnflags & 4 )
+	{//USE_BUTTON
+		NPC_SetAnim( other, SETANIM_TORSO, BOTH_BUTTON_HOLD, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+		/*
+		if ( !VectorLengthSquared( other->client->ps.velocity ) && !PM_CrouchAnim( other->client->ps.legsAnim ) )
+		{
+			NPC_SetAnim( other, SETANIM_LEGS, BOTH_BUTTON_HOLD, SETANIM_FLAG_NORMAL|SETANIM_FLAG_HOLD );
+		}
+		*/
+		//other->client->ps.weaponTime = other->client->ps.torsoAnimTimer;
+	}
+	
+	if ( self->e_ThinkFunc == thinkF_trigger_cleared_fire )
+	{//We're waiting to fire our target2 first
+		self->nextthink = level.time + self->speed;
+		return;
+	}
+
+	if ( self->spawnflags & 32)
+	{
+		if (Pilot_ActivePilotCount()>=self->lastInAirTime)
+		{
+			return;
+		}
+	}
+
+	multi_trigger( self, other );
+}
+
+void trigger_cleared_fire (gentity_t *self)
+{
+	G_UseTargets2( self, self->activator, self->target2 );
+	self->e_ThinkFunc = thinkF_NULL;
+	// should start the wait timer now, because the trigger's just been cleared, so we must "wait" from this point
+	if ( self->wait > 0 ) 
+	{
+		self->nextthink = level.time + ( self->wait + self->random * crandom() ) * 1000;
+	}
+}
+
+qboolean G_TriggerActive( gentity_t *self )
+{
+	if ( self->svFlags & SVF_INACTIVE )
+	{//set by target_deactivate
+		return qfalse;
+	}
+
+	if ( self->spawnflags & 1 )
+	{//player only
+		return qfalse;
+	}
+
+	/*
+	???
+	if ( self->spawnflags & 4 )
+	{//USE_BUTTON
+		return qfalse;
+	}
+	*/
+
+	/*
+	???
+	if ( self->spawnflags & 8 )
+	{//FIRE_BUTTON
+		return qfalse;
+	}
+	*/
+
+	/*
+	if ( self->radius )
+	{//Only works if your head is in it, but we allow leaning out
+		//NOTE: We don't use CalcEntitySpot SPOT_HEAD because we don't want this
+		//to be reliant on the physical model the player uses.
+		return qfalse;
+	}
+	*/
+	return qtrue;
+}
+
+/*QUAKED trigger_multiple (.1 .5 .1) ? PLAYERONLY FACING USE_BUTTON FIRE_BUTTON NPCONLY LIMITED_PILOT x INACTIVE MULTIPLE
+PLAYERONLY - only a player can trigger this by touch
+FACING - Won't fire unless triggering ent's view angles are within 45 degrees of trigger's angles (in addition to any other conditions)
+USE_BUTTON - Won't fire unless player is in it and pressing use button (in addition to any other conditions)
+FIRE_BUTTON - Won't fire unless player/NPC is in it and pressing fire button (in addition to any other conditions)
+NPCONLY - only non-player NPCs can trigger this by touch
+LIMITED_PILOT - only spawn if there are open pilot slots
+INACTIVE - Start off, has to be activated to be touchable/usable
+MULTIPLE - multiple entities can touch this trigger in a single frame *and* if needed, the trigger can have a wait of > 0
+
+"wait"		Seconds between triggerings, 0 default, number < 0 means one time only.
+"random"	wait variance, default is 0
+"delay"		how many seconds to wait to fire targets after tripped
+"hiderange" As long as NPC's head is in this trigger, NPCs out of this hiderange cannot see him.  If you set an angle on the trigger, they're only hidden from enemies looking in that direction.  the player's crouch viewheight is 36, his standing viewheight is 54.  So a trigger thast should hide you when crouched but not standing should be 48 tall.
+"target2"	The trigger will fire this only when the trigger has been activated and subsequently 'cleared'( once any of the conditions on the trigger have not been satisfied).  This will not fire the "target" more than once until the "target2" is fired (trigger field is 'cleared')
+"speed"		How many seconds to wait to fire the target2, default is 1
+"noise"		Sound to play when the trigger fires (plays at activator's origin)
+"max_pilots"	Number of pilots this spawner will allow
+
+Variable sized repeatable trigger.  Must be targeted at one or more entities.
+so, the basic time between firing is a random time between
+(wait - random) and (wait + random)
+
+"NPC_targetname" - If set, only an NPC with a matching NPC_targetname will trip this trigger
+"team" - If set, only this team can trip this trigger
+	player
+	enemy
+	neutral
+
+"soundSet"	Ambient sound set to play when this trigger is activated
+*/
+void SP_trigger_multiple( gentity_t *ent ) 
+{
+	char	buffer[MAX_QPATH];
+	char	*s;
+	if ( G_SpawnString( "noise", "*NOSOUND*", &s ) ) 
+	{
+		Q_strncpyz( buffer, s, sizeof(buffer) );
+		COM_DefaultExtension( buffer, sizeof(buffer), ".wav");
+		ent->noise_index = G_SoundIndex(buffer);
+	}
+	
+	G_SpawnFloat( "wait", "0", &ent->wait );//was 0.5 ... but that means wait can never be zero... we should probably put it back to 0.5, though...
+	G_SpawnFloat( "random", "0", &ent->random );
+	G_SpawnInt( "max_pilots", "2", &ent->lastInAirTime );
+
+
+	if ( (ent->wait > 0) && (ent->random >= ent->wait) ) {
+		ent->random = ent->wait - FRAMETIME;
+		gi.Printf(S_COLOR_YELLOW"trigger_multiple has random >= wait\n");
+	}
+
+	ent->delay *= 1000;//1 = 1 msec, 1000 = 1 sec
+	if ( !ent->speed && ent->target2 && ent->target2[0] )
+	{
+		ent->speed = 1000;
+	}
+	else
+	{
+		ent->speed *= 1000;
+	}
+
+	ent->e_TouchFunc = touchF_Touch_Multi;
+	ent->e_UseFunc   = useF_Use_Multi;
+
+	if ( ent->team && ent->team[0] )
+	{
+		ent->noDamageTeam = (team_t)GetIDForString( TeamTable, ent->team );
+		ent->team = NULL;
+	}
+
+	InitTrigger( ent );
+	gi.linkentity (ent);
+}
+
+/*QUAKED trigger_once (.5 1 .5) ? PLAYERONLY FACING USE_BUTTON FIRE_BUTTON NPCONLY x x INACTIVE MULTIPLE
+PLAYERONLY - only a player can trigger this by touch
+FACING - Won't fire unless triggering ent's view angles are within 45 degrees of trigger's angles (in addition to any other conditions)
+USE_BUTTON - Won't fire unless player is in it and pressing use button (in addition to any other conditions)
+FIRE_BUTTON - Won't fire unless player/NPC is in it and pressing fire button (in addition to any other conditions)
+NPCONLY - only non-player NPCs can trigger this by touch
+INACTIVE - Start off, has to be activated to be touchable/usable
+MULTIPLE - multiple entities can touch this trigger in a single frame *and* if needed, the trigger can have a wait of > 0
+
+"random"	wait variance, default is 0
+"delay"		how many seconds to wait to fire targets after tripped
+Variable sized repeatable trigger.  Must be targeted at one or more entities.
+so, the basic time between firing is a random time between
+(wait - random) and (wait + random)
+"noise"		Sound to play when the trigger fires (plays at activator's origin)
+
+"NPC_targetname" - If set, only an NPC with a matching NPC_targetname will trip this trigger
+"team" - If set, only this team can trip this trigger
+	player
+	enemy
+	neutral
+
+"soundSet"	Ambient sound set to play when this trigger is activated
+*/
+void SP_trigger_once( gentity_t *ent ) 
+{
+	char	buffer[MAX_QPATH];
+	char	*s;
+	if ( G_SpawnString( "noise", "*NOSOUND*", &s ) ) 
+	{
+		Q_strncpyz( buffer, s, sizeof(buffer) );
+		COM_DefaultExtension( buffer, sizeof(buffer), ".wav");
+		ent->noise_index = G_SoundIndex(buffer);
+	}
+
+	ent->wait = -1;
+
+	ent->e_TouchFunc = touchF_Touch_Multi;
+	ent->e_UseFunc   = useF_Use_Multi;
+
+	if ( ent->team && ent->team[0] )
+	{
+		ent->noDamageTeam = (team_t)GetIDForString( TeamTable, ent->team );
+		ent->team = NULL;
+	}
+
+	ent->delay *= 1000;//1 = 1 msec, 1000 = 1 sec
+
+	InitTrigger( ent );
+	gi.linkentity (ent);
+}
+
+
+/*QUAKED trigger_bidirectional (.1 .5 .1) ? PLAYER_ONLY x x x x x x INACTIVE
+NOT IMPLEMENTED
+INACTIVE - Start off, has to be activated to be touchable/usable
+
+set "angle" for forward direction
+Fires "target" when someone moves through it in direction of angle
+Fires "backwardstarget" when someone moves through it in the opposite direction of angle
+
+"NPC_targetname" - If set, only an NPC with a matching NPC_targetname will trip this trigger
+
+"wait" - how long to wait between triggerings
+
+  TODO:
+	count
+*/
+void SP_trigger_bidirectional( gentity_t *ent ) 
+{
+	G_FreeEntity(ent);
+	//FIXME: Implement
+/*	if(!ent->wait)
+	{
+		ent->wait = -1;
+	}
+
+	ent->touch = Touch_Multi;
+	ent->use = Use_Multi;
+	
+	InitTrigger( ent );
+	gi.linkentity (ent);
+*/
+}
+
+/*QUAKED trigger_location (.1 .5 .1) ? 
+When an ent is asked for it's location, it will return this ent's "message" field if it is in it.
+  "message" - location name
+
+  NOTE: always rectangular
+*/
+char *G_GetLocationForEnt( gentity_t *ent )
+{
+	vec3_t		mins, maxs;
+	gentity_t	*found = NULL;
+
+	VectorAdd( ent->currentOrigin, ent->mins, mins );
+	VectorAdd( ent->currentOrigin, ent->maxs, maxs );
+
+	while( (found = G_Find(found, FOFS(classname), "trigger_location")) != NULL )
+	{
+		if ( gi.EntityContact( mins, maxs, found ) ) 
+		{
+			return found->message;
+		}
+	}
+
+	return NULL;
+}
+
+void SP_trigger_location( gentity_t *ent ) 
+{
+	if ( !ent->message || !ent->message[0] )
+	{
+		gi.Printf("WARNING: trigger_location with no message!\n");
+		G_FreeEntity(ent);
+		return;
+	}
+
+	gi.SetBrushModel( ent, ent->model );
+	ent->contents = 0;
+	ent->svFlags = SVF_NOCLIENT;
+
+	gi.linkentity (ent);
+}
+/*
+==============================================================================
+
+trigger_always
+
+==============================================================================
+*/
+
+void trigger_always_think( gentity_t *ent ) {
+	G_UseTargets(ent, ent);
+	G_FreeEntity( ent );
+}
+
+/*QUAKED trigger_always (.1 .5 .1) (-8 -8 -8) (8 8 8)
+This trigger will always fire.  It is activated by the world.
+*/
+void SP_trigger_always (gentity_t *ent) {
+	// we must have some delay to make sure our use targets are present
+	ent->nextthink = level.time + 300;
+	ent->e_ThinkFunc = thinkF_trigger_always_think;
+}
+
+
+/*
+==============================================================================
+
+trigger_push
+
+==============================================================================
+*/
+#define PUSH_CONVEYOR 32	
+void trigger_push_touch (gentity_t *self, gentity_t *other, trace_t *trace ) {
+	if ( self->svFlags & SVF_INACTIVE )
+	{//set by target_deactivate
+		return;
+	}
+
+	if( level.time < self->painDebounceTime + self->wait  ) // normal 'wait' check
+	{
+		if( self->spawnflags & 2048 ) // MULTIPLE - allow multiple entities to touch this trigger in one frame
+		{
+			if ( self->painDebounceTime && level.time > self->painDebounceTime ) // if we haven't reached the next frame continue to let ents touch the trigger
+			{
+				return;
+			}
+		}
+		else // only allowing one ent per frame to touch trigger
+		{
+			return;
+		}
+	}
+
+	// if the player has already activated this trigger this frame
+	if( other && !other->s.number && self->aimDebounceTime == level.time )
+	{
+		return;		
+	}
+	
+	
+	if( self->spawnflags & PUSH_CONVEYOR )
+	{   // only push player if he's on the ground
+		if( other->s.groundEntityNum == ENTITYNUM_NONE )
+		{
+			return;
+		}
+	}
+
+	if ( self->spawnflags & 1 )
+	{//PLAYERONLY
+		if ( other->s.number != 0 )
+		{
+			return;
+		}
+	}
+	else
+	{
+		if ( self->spawnflags & 8 )
+		{//NPCONLY
+			if ( other->NPC == NULL )
+			{
+				return;
+			}
+		}
+	}
+
+	if ( !other->client ) {
+		if ( other->s.pos.trType != TR_STATIONARY && other->s.pos.trType != TR_LINEAR_STOP && other->s.pos.trType != TR_NONLINEAR_STOP && VectorLengthSquared( other->s.pos.trDelta ) )
+		{//already moving
+			VectorCopy( other->currentOrigin, other->s.pos.trBase );
+			VectorCopy( self->s.origin2, other->s.pos.trDelta );
+			other->s.pos.trTime = level.time;
+		}
+		return;
+	}
+
+	if ( other->client->ps.pm_type != PM_NORMAL ) {
+		return;
+	}
+	
+	if ( (self->spawnflags&16) )
+	{//relative, dir to it * speed
+		vec3_t dir;
+		VectorSubtract( self->s.origin2, other->currentOrigin, dir );
+		if ( self->speed )
+		{
+			VectorNormalize( dir );
+			VectorScale( dir, self->speed, dir );
+		}
+		VectorCopy( dir, other->client->ps.velocity );
+	}
+	else if ( (self->spawnflags&4) )
+	{//linear dir * speed
+		VectorScale( self->s.origin2, self->speed, other->client->ps.velocity );
+	}
+	else
+	{
+		VectorCopy( self->s.origin2, other->client->ps.velocity );
+	}
+	//so we don't take damage unless we land lower than we start here...
+	other->client->ps.forceJumpZStart = 0;
+	other->client->ps.pm_flags |= PMF_TRIGGER_PUSHED;//pushed by a trigger
+	other->client->ps.jumpZStart = other->client->ps.origin[2];
+
+	if ( self->wait == -1 )
+	{
+		self->e_TouchFunc = touchF_NULL;
+	}
+	else if ( self->wait > 0 )
+	{
+		self->painDebounceTime = level.time;
+		
+	}
+	if( other && !other->s.number )
+	{	// mark that the player has activated this trigger this frame
+		self->aimDebounceTime =level.time;
+	}
+}
+
+#define PUSH_CONSTANT 2
+
+/*
+=================
+AimAtTarget
+
+Calculate origin2 so the target apogee will be hit
+=================
+*/
+void AimAtTarget( gentity_t *self ) 
+{
+	gentity_t	*ent;
+	vec3_t		origin;
+	float		height, gravity, time, forward;
+	float		dist;
+
+	VectorAdd( self->absmin, self->absmax, origin );
+	VectorScale ( origin, 0.5, origin );
+
+	ent = G_PickTarget( self->target );
+	if ( !ent ) 
+	{
+		G_FreeEntity( self );
+		return;
+	}
+
+	if ( self->classname && !Q_stricmp( "trigger_push", self->classname ) )
+	{
+		if ( (self->spawnflags&2) )
+		{//check once a second to see if we should activate or deactivate ourselves
+			self->e_ThinkFunc = thinkF_trigger_push_checkclear;
+			self->nextthink = level.time + FRAMETIME;
+		}
+
+		if ( (self->spawnflags&16) )
+		{//relative, not an arc or linear
+			VectorCopy( ent->currentOrigin, self->s.origin2 );
+			return;
+		}
+		else if ( (self->spawnflags&4) )
+		{//linear, not an arc
+			VectorSubtract( ent->currentOrigin, origin, self->s.origin2 );
+			VectorNormalize( self->s.origin2 );
+			return;
+		}
+	}
+
+	if ( self->classname && !Q_stricmp( "target_push", self->classname ) )
+	{
+		if( self->spawnflags & PUSH_CONSTANT )
+		{
+			VectorSubtract ( ent->s.origin, self->s.origin, self->s.origin2 );
+			VectorNormalize( self->s.origin2);
+			VectorScale (self->s.origin2, self->speed, self->s.origin2);
+			return;
+		}
+	}
+	height = ent->s.origin[2] - origin[2];
+	if ( height < 0 )
+	{//sqrt of negative is bad!
+		height = 0;
+	}
+	gravity = g_gravity->value;
+	if ( gravity < 0 )
+	{
+		gravity = 0;
+	}
+	time = sqrt( height / ( .5 * gravity ) );
+	if ( !time ) {
+		G_FreeEntity( self );
+		return;
+	}
+
+	// set s.origin2 to the push velocity
+	VectorSubtract ( ent->s.origin, origin, self->s.origin2 );
+	self->s.origin2[2] = 0;
+	dist = VectorNormalize( self->s.origin2);
+
+	forward = dist / time;
+	VectorScale( self->s.origin2, forward, self->s.origin2 );
+
+	self->s.origin2[2] = time * gravity;
+}
+
+void trigger_push_checkclear( gentity_t *self )
+{
+	trace_t	trace;
+	vec3_t	center;
+
+	self->nextthink = level.time + 500;
+
+	VectorAdd( self->absmin, self->absmax, center );
+	VectorScale( center, 0.5, center );
+
+	gentity_t *target = G_Find( NULL, FOFS(targetname), self->target );
+	gi.trace( &trace, center, vec3_origin, vec3_origin, target->currentOrigin, ENTITYNUM_NONE, CONTENTS_SOLID );
+
+	if ( trace.fraction >= 1.0f )
+	{//can trace, turn on
+		self->contents |= CONTENTS_TRIGGER;//so the EntityContact trace doesn't have to be done against me
+		self->e_TouchFunc = touchF_trigger_push_touch;
+		gi.linkentity( self );
+	}
+	else
+	{//no trace, turn off
+		self->contents &= ~CONTENTS_TRIGGER;//so the EntityContact trace doesn't have to be done against me
+		self->e_TouchFunc = touchF_NULL;
+		gi.unlinkentity( self );
+	}
+}
+/*QUAKED trigger_push (.1 .5 .1) ? PLAYERONLY CHECKCLEAR LINEAR NPCONLY RELATIVE CONVEYOR x INACTIVE MULTIPLE
+Must point at a target_position, which will be the apex of the leap.
+This will be client side predicted, unlike target_push
+PLAYERONLY - only the player is affected
+LINEAR - Instead of tossing the client at the target_position, it will push them towards it.  Must set a "speed" (see below)
+CHECKCLEAR - Every 1 second, it will check to see if it can trace to the target_position, if it can, the trigger is touchable, if it can't, the trigger is not touchable
+NPCONLY - only NPCs are affected
+RELATIVE - instead of pushing you in a direction that is always from the center of the trigger to the target_position, it pushes *you* toward the target position, relative to your current location (can use with "speed"... if don't set a speed, it will use the distance from you to the target_position)
+CONVEYOR - acts like a conveyor belt, will only push if player is on the ground ( should probably use RELATIVE also, if you want a true conveyor belt )
+INACTIVE - not active until targeted by a target_activate
+MULTIPLE - multiple entities can touch this trigger in a single frame *and* if needed, the trigger can have a wait of > 0
+
+wait - how long to wait between pushes: -1 = push only once
+speed - when used with the LINEAR spawnflag, pushes the client toward the position at a constant speed (default is 1000)
+*/
+void SP_trigger_push( gentity_t *self ) {
+	InitTrigger (self);
+
+	if ( self->wait > 0 )
+	{
+		self->wait *= 1000;
+	}
+
+	// unlike other triggers, we need to send this one to the client
+	self->svFlags &= ~SVF_NOCLIENT;
+
+	self->s.eType = ET_PUSH_TRIGGER;
+	if ( !(self->spawnflags&2) )
+	{//start on
+		self->e_TouchFunc = touchF_trigger_push_touch;
+	}
+	if ( self->spawnflags & 4 )
+	{//linear
+		self->speed = 1000;
+	}
+	self->e_ThinkFunc = thinkF_AimAtTarget;
+	self->nextthink = level.time + START_TIME_LINK_ENTS;
+	gi.linkentity (self);
+}
+
+void Use_target_push( gentity_t *self, gentity_t *other, gentity_t *activator ) {
+	if ( !activator->client ) {
+		return;
+	}
+
+	if ( activator->client->ps.pm_type != PM_NORMAL ) {
+		return;
+	}
+
+	G_ActivateBehavior(self,BSET_USE);
+
+	VectorCopy( self->s.origin2, activator->client->ps.velocity );
+
+	if( self->spawnflags & 4 ) // lower
+	{
+		// reset this so I don't take falling damage when I land
+		activator->client->ps.jumpZStart = activator->currentOrigin[2];
+	}
+
+	//so we don't take damage unless we land lower than we start here...
+	activator->client->ps.forceJumpZStart = 0;
+	activator->client->ps.pm_flags |= PMF_TRIGGER_PUSHED;//pushed by a trigger
+
+	// play fly sound every 1.5 seconds
+	if ( self->noise_index && activator->fly_sound_debounce_time < level.time ) {
+		activator->fly_sound_debounce_time = level.time + 1500;
+		G_Sound( activator, self->noise_index );
+	}
+}
+
+
+/*QUAKED target_push (.5 .5 .5) (-8 -8 -8) (8 8 8) ENERGYNOISE CONSTANT NO_DAMAGE
+When triggered, pushes the activator in the direction of angles
+"speed"		defaults to 1000
+ENERGYNOISE plays energy noise
+CONSTANT will push activator in direction of 'target' at constant 'speed'
+NO_DAMAGE the activator won't take falling damage after being pushed
+*/
+void SP_target_push( gentity_t *self ) {
+	
+	
+	if (!self->speed) {
+		self->speed = 1000;
+	}
+	G_SetMovedir (self->s.angles, self->s.origin2);
+	VectorScale (self->s.origin2, self->speed, self->s.origin2);
+
+	if ( self->spawnflags & 1 ) {
+		//self->noise_index = G_SoundIndex("sound/ambience/forge/antigrav.wav");
+	}
+	if ( self->target ) {
+
+		VectorCopy( self->s.origin, self->absmin );
+		VectorCopy( self->s.origin, self->absmax );
+		self->e_ThinkFunc = thinkF_AimAtTarget;
+		self->nextthink = level.time + START_TIME_LINK_ENTS;
+		
+	}
+	self->e_UseFunc = useF_Use_target_push;
+}
+
+/*
+==============================================================================
+
+trigger_teleport
+
+==============================================================================
+*/
+#define SNAP_ANGLES 1
+#define NO_MISSILES 2
+#define NO_NPCS		4
+#define TTSF_STASIS		8
+#define TTSF_DEAD_OK	16
+void TeleportMover( gentity_t *mover, vec3_t origin, vec3_t diffAngles, qboolean snapAngle );
+void trigger_teleporter_touch (gentity_t *self, gentity_t *other, trace_t *trace ) 
+{
+	gentity_t	*dest;
+
+	if ( self->svFlags & SVF_INACTIVE )
+	{//set by target_deactivate
+		return;
+	}
+	
+	dest = 	G_PickTarget( self->target );
+	if (!dest) 
+	{
+		gi.Printf ("Couldn't find teleporter destination\n");
+		return;
+	}
+
+	if ( other->client ) 
+	{
+		if ( other->client->ps.pm_type == PM_DEAD ) 
+		{
+			if ( !(self->spawnflags&TTSF_DEAD_OK) )
+			{//dead men can't teleport
+				return;
+			}
+		}
+		if ( other->NPC )
+		{
+			if ( self->spawnflags & NO_NPCS )
+			{
+				return;
+			}
+		}
+
+		if ( other->client->playerTeam != TEAM_FREE && SpotWouldTelefrag2( other, dest->currentOrigin ) )//SpotWouldTelefrag( dest, other->client->playerTeam ) )
+		{//Don't go through if something blocking on the other side
+			return;
+		}
+		
+		TeleportPlayer( other, dest->s.origin, dest->s.angles );
+	}
+	//FIXME: check for SVF_NO_TELEPORT
+	else if ( !(self->svFlags & SVF_NO_TELEPORT) && !(self->spawnflags & NO_MISSILES) && VectorLengthSquared( other->s.pos.trDelta ) )
+	{//It's a mover of some sort and is currently moving
+		vec3_t	diffAngles = {0, 0, 0};
+		qboolean	snap = qfalse;
+
+		if ( self->lastEnemy )
+		{
+			VectorSubtract( dest->s.angles, self->lastEnemy->s.angles, diffAngles );
+		}
+		else
+		{//snaps to angle
+			VectorSubtract( dest->s.angles, other->currentAngles, diffAngles );
+			snap = qtrue;
+		}
+
+		TeleportMover( other, dest->s.origin, diffAngles, snap );
+	}
+}
+
+void trigger_teleporter_find_closest_portal( gentity_t *self )
+{
+	gentity_t *found = NULL;
+	vec3_t		org, vec;
+	float		dist, bestDist = 64*64;
+
+	VectorAdd( self->mins, self->maxs, org );
+	VectorScale( org, 0.5, org );
+	while ( (found = G_Find( found, FOFS(classname), "misc_portal_surface" )) != NULL )
+	{
+		VectorSubtract( found->currentOrigin, org, vec );
+		dist = VectorLengthSquared( vec );
+		if ( dist < bestDist )
+		{
+			self->lastEnemy = found;
+			bestDist = dist;
+		}
+	}
+
+	if ( self->lastEnemy )
+	{
+		gi.Printf("trigger_teleporter found misc_portal_surface\n");
+	}
+	self->e_ThinkFunc = thinkF_NULL;
+}
+
+/*QUAKED trigger_teleport (.1 .5 .1) ? SNAP_ANGLES NO_MISSILES NO_NPCS STASIS DEAD_OK x x INACTIVE
+Allows client side prediction of teleportation events.
+Must point at a target_position, which will be the teleport destination.
+
+SNAP_ANGLES - Make the entity that passes through snap to the target_position's angles
+NO_MISSILES - Missiles and thrown objects cannot pass through
+NO_NPCS - NPCs cannot pass through
+STASIS - will play stasis teleport sound and fx instead of starfleet
+DEAD_OK - even if dead, you will teleport
+*/
+void SP_trigger_teleport( gentity_t *self ) 
+{
+	InitTrigger (self);
+
+	// unlike other triggers, we need to send this one to the client
+	self->svFlags &= ~SVF_NOCLIENT;
+
+	self->s.eType = ET_TELEPORT_TRIGGER;
+	self->e_TouchFunc = touchF_trigger_teleporter_touch;
+
+	self->e_ThinkFunc = thinkF_trigger_teleporter_find_closest_portal;
+	self->nextthink = level.time + START_TIME_LINK_ENTS;
+
+	gi.linkentity (self);
+}
+
+
+
+/*
+==============================================================================
+
+trigger_hurt
+
+==============================================================================
+*/
+
+/*QUAKED trigger_hurt (.1 .5 .1) ? START_OFF PLAYERONLY SILENT NO_PROTECTION LOCKCAM FALLING ELECTRICAL INACTIVE MULTIPLE
+Any entity that touches this will be hurt.
+It does dmg points of damage each server frame
+
+PLAYERONLY		only the player is hurt by it
+SILENT			supresses playing the sound
+NO_PROTECTION	*nothing* stops the damage
+LOCKCAM			Falling death results in camera locking in place
+FALLING			Forces a falling scream and anim
+ELECTRICAL		does electrical damage
+INACTIVE		Cannot be triggered until used by a target_activate
+MULTIPLE        multiple entities can touch this trigger in a single frame *and* if needed, the trigger can have a wait of > 0
+
+"dmg"			default 5 (whole numbers only)
+"delay"			How many seconds it takes to get from 0 to "dmg" (default is 0)
+"wait"			Use in instead of "SLOW" - determines how often the player gets hurt, 0.1 is every frame, 1.0 is once per second.  -1 will stop after one use
+"count"			If set, FALLING death causes a fade to black in this many milliseconds (default is 10000 = 10 seconds)
+"NPC_targetname" - If set, only an NPC with a matching NPC_targetname will trip this trigger
+"noise"         sound to play when it hurts something ( default: "sound/world/electro" )
+*/
+void hurt_use( gentity_t *self, gentity_t *other, gentity_t *activator ) {
+
+	G_ActivateBehavior(self,BSET_USE);
+
+	//FIXME: Targeting the trigger will toggle its on / off state???
+	if ( self->linked ) {
+		gi.unlinkentity( self );
+	} else {
+		gi.linkentity( self );
+	}
+}
+
+void trigger_hurt_reset (gentity_t *self)
+{
+	self->attackDebounceTime = 0;
+	self->e_ThinkFunc = thinkF_NULL;
+}
+extern void JET_FlyStart(gentity_t* actor);
+void hurt_touch( gentity_t *self, gentity_t *other, trace_t *trace ) 
+{
+	int		dflags;
+	int		actualDmg = self->damage;
+
+	if ( self->svFlags & SVF_INACTIVE )
+	{//set by target_deactivate
+		return;
+	}
+	
+	if ( !other->takedamage ) 
+	{
+		return;
+	}
+	
+	if( level.time < self->painDebounceTime + self->wait  ) // normal 'wait' check
+	{
+		if( self->spawnflags & 2048 ) // MULTIPLE - allow multiple entities to touch this trigger in one frame
+		{
+			if ( self->painDebounceTime && level.time > self->painDebounceTime ) // if we haven't reached the next frame continue to let ents touch the trigger
+			{
+				return;
+			}
+		}
+		else // only allowing one ent per frame to touch trigger
+		{
+			return;
+		}
+	}
+
+	// if the player has already activated this trigger this frame
+	if( other && !other->s.number && self->aimDebounceTime == level.time )
+	{
+		return;		
+	}
+
+
+	if ( self->spawnflags & 2 )
+	{//player only
+		if ( other->s.number )
+		{
+			return;
+		}
+	}
+
+	if ( self->NPC_targetname && self->NPC_targetname[0] )
+	{//I am for you, Kirk
+		if ( other->script_targetname && other->script_targetname[0] )
+		{//must have a name
+			if ( Q_stricmp( self->NPC_targetname, other->script_targetname ) != 0 )
+			{//not the right guy to fire me off
+				return;
+			}
+		}
+		else
+		{//no name?  No trigger.
+			return;
+		}
+	}
+
+	// play sound
+	if ( !(self->spawnflags & 4) ) 
+	{
+		G_Sound( other, self->noise_index );
+	}
+
+	if ( self->spawnflags & 8 )
+	{
+		dflags = DAMAGE_NO_PROTECTION;
+	}
+	else
+	{
+		dflags = 0;
+	}
+	
+	if ( self->delay )
+	{//Increase dmg over time
+		if ( self->attackDebounceTime < self->delay )
+		{//FIXME: this is for the entire trigger, not per person, so if someone else jumped in after you were in it for 5 seconds, they'd get damaged faster
+			actualDmg = floor( (float)(self->damage * self->attackDebounceTime / self->delay) );
+		}
+		self->attackDebounceTime += FRAMETIME;
+
+		self->e_ThinkFunc = thinkF_trigger_hurt_reset;
+		self->nextthink = level.time + FRAMETIME*2;
+	}
+
+	if ( actualDmg )
+	{
+		if (( self->spawnflags & 64 ) && other->client )//electrical damage
+		{
+			// zap effect
+			other->s.powerups |= ( 1 << PW_SHOCKED );
+			other->client->ps.powerups[PW_SHOCKED] = level.time + 1000;
+		}
+
+		if ( self->spawnflags & 32 )
+		{//falling death
+			if ( other->NPC && other->client && 
+				(other->client->NPC_class == CLASS_BOBAFETT	|| other->client->NPC_class == CLASS_ROCKETTROOPER ))
+			{//boba never falls to his death!
+				//FIXME:  fall through if jetpack broken?
+				JET_FlyStart(other); 
+			}
+			else
+			{
+				G_Damage (other, self, self, NULL, NULL, actualDmg, dflags|DAMAGE_NO_ARMOR, MOD_FALLING);
+				// G_Damage will free this ent, which makes it s.number 0, so we must check inuse...
+				if ( !other->s.number && other->health <= 0 )
+				{
+					if ( self->count )
+					{
+						extern void CGCam_Fade( vec4_t source, vec4_t dest, float duration );
+						float	src[4] = {0,0,0,0},dst[4]={0,0,0,1};
+						CGCam_Fade( src, dst, self->count );
+					}
+					if ( self->spawnflags & 16 )
+					{//lock cam
+						cg.overrides.active |= CG_OVERRIDE_3RD_PERSON_CDP;
+						cg.overrides.thirdPersonCameraDamp = 0;
+					}
+					if ( other->client )
+					{
+						other->client->ps.pm_flags |= PMF_SLOW_MO_FALL;
+					}
+					//G_SoundOnEnt( other, CHAN_VOICE, "*falling1.wav" );//CHAN_VOICE_ATTEN?
+				}
+			}
+		}
+		else
+		{
+			G_Damage (other, self, self, NULL, NULL, actualDmg, dflags, MOD_TRIGGER_HURT);
+		}
+		if( other && !other->s.number )
+		{
+			self->aimDebounceTime = level.time;
+		}
+		if (( self->spawnflags & 64 ) && other->client && other->health <= 0 )//electrical damage
+		{//just killed them, make the effect last longer since dead clients don't touch triggers
+			other->client->ps.powerups[PW_SHOCKED] = level.time + 10000;
+		}
+		self->painDebounceTime = level.time;
+	}
+
+	if ( self->wait < 0 )
+	{
+		self->e_TouchFunc = touchF_NULL;
+	}
+}
+
+void SP_trigger_hurt( gentity_t *self ) 
+{
+	char	buffer[MAX_QPATH];
+	char	*s;
+
+	InitTrigger (self);
+
+	if ( !( self->spawnflags & 4 )) 
+	{
+		G_SpawnString( "noise", "sound/world/electro", &s );
+
+		Q_strncpyz( buffer, s, sizeof(buffer) );
+		self->noise_index = G_SoundIndex(buffer);
+	}
+
+	self->e_TouchFunc = touchF_hurt_touch;
+
+	if ( !self->damage ) {
+		self->damage = 5;
+	}
+	
+	self->delay *= 1000;
+	self->wait *= 1000;
+
+	self->contents = CONTENTS_TRIGGER;
+
+	if ( self->targetname ) {//NOTE: for some reason, this used to be: if(self->spawnflags&2)
+		self->e_UseFunc = useF_hurt_use;
+	}
+
+	// link in to the world if starting active
+	if ( !(self->spawnflags & 1) )
+	{
+		gi.linkentity (self);
+	}
+	else // triggers automatically get linked into the world by SetBrushModel, so we have to unlink it here
+	{
+		gi.unlinkentity(self);
+	}
+}
+
+#define	INITIAL_SUFFOCATION_DELAY	5000 //5 seconds
+void space_touch( gentity_t *self, gentity_t *other, trace_t *trace )
+{
+	if (!other || !other->inuse || !other->client )
+		//NOTE: we need vehicles to know this, too...
+		//|| other->s.number >= MAX_CLIENTS)
+	{
+		return;
+	}
+
+	if (other->s.m_iVehicleNum
+		&& other->s.m_iVehicleNum <= MAX_CLIENTS )
+	{//a player client inside a vehicle
+		gentity_t *veh = &g_entities[other->s.m_iVehicleNum];
+
+		if (veh->inuse && veh->client && veh->m_pVehicle &&
+			veh->m_pVehicle->m_pVehicleInfo->hideRider)
+		{ //if they are "inside" a vehicle, then let that protect them from THE HORRORS OF SPACE.
+			return;
+		}
+	}
+
+	if (!G_PointInBounds(other->client->ps.origin, self->absmin, self->absmax))
+	{ //his origin must be inside the trigger
+		return;
+	}
+
+	if (!other->client->inSpaceIndex ||
+		other->client->inSpaceIndex == ENTITYNUM_NONE)
+	{ //freshly entering space
+		other->client->inSpaceSuffocation = level.time + INITIAL_SUFFOCATION_DELAY;
+	}
+
+	other->client->inSpaceIndex = self->s.number;
+}
+
+/*QUAKED trigger_space (.5 .5 .5) ? 
+causes human clients to suffocate and have no gravity.
+
+*/
+void SP_trigger_space(gentity_t *self)
+{
+	InitTrigger(self);
+	self->contents = CONTENTS_TRIGGER;
+	
+	//FIXME: implement!!!
+	//self->e_TouchFunc = touchF_space_touch;
+
+    gi.linkentity(self);
+}
+
+void shipboundary_touch( gentity_t *self, gentity_t *other, trace_t *trace )
+{
+	gentity_t *ent;
+
+	if (!other || !other->inuse || !other->client ||
+		other->s.number < MAX_CLIENTS ||
+		!other->m_pVehicle)
+	{ //only let vehicles touch
+		return;
+	}
+
+	ent = G_Find (NULL, FOFS(targetname), self->target);
+	if (!ent || !ent->inuse)
+	{ //this is bad
+		G_Error("trigger_shipboundary has invalid target '%s'\n", self->target);
+		return;
+	}
+
+	if (!other->s.m_iVehicleNum || other->m_pVehicle->m_iRemovedSurfaces)
+	{ //if a vehicle touches a boundary without a pilot in it or with parts missing, just blow the thing up
+		G_Damage(other, other, other, NULL, other->client->ps.origin, 99999, DAMAGE_NO_PROTECTION, MOD_SUICIDE);
+		return;
+	}
+
+	other->client->ps.vehTurnaroundIndex = ent->s.number;
+	other->client->ps.vehTurnaroundTime = level.time + self->count;
+}
+
+/*QUAKED trigger_shipboundary (.5 .5 .5) ? 
+causes vehicle to turn toward target and travel in that direction for a set time when hit.
+
+"target"		name of entity to turn toward (can be info_notnull, or whatever).
+"traveltime"	time to travel in this direction
+
+*/
+void SP_trigger_shipboundary(gentity_t *self)
+{
+	InitTrigger(self);
+	self->contents = CONTENTS_TRIGGER;
+	
+	if (!self->target || !self->target[0])
+	{
+		G_Error("trigger_shipboundary without a target.");
+	}
+	G_SpawnInt("traveltime", "0", &self->count);
+
+	if (!self->count)
+	{
+		G_Error("trigger_shipboundary without traveltime.");
+	}
+
+	//FIXME: implement!
+	//self->e_TouchFunc = touchF_shipboundary_touch;
+
+    gi.linkentity(self);
+}
+/*
+==============================================================================
+
+timer
+
+==============================================================================
+*/
+
+
+/*QUAKED func_timer (0.3 0.1 0.6) (-8 -8 -8) (8 8 8) START_ON
+This should be renamed trigger_timer...
+Repeatedly fires its targets.
+Can be turned on or off by using.
+
+"wait"			base time between triggering all targets, default is 1
+"random"		wait variance, default is 0
+so, the basic time between firing is a random time between
+(wait - random) and (wait + random)
+
+*/
+void func_timer_think( gentity_t *self ) {
+	G_UseTargets (self, self->activator);
+	// set time before next firing
+	self->nextthink = level.time + 1000 * ( self->wait + crandom() * self->random );
+}
+
+void func_timer_use( gentity_t *self, gentity_t *other, gentity_t *activator ) {
+	self->activator = activator;
+
+	G_ActivateBehavior(self,BSET_USE);
+
+
+	// if on, turn it off
+	if ( self->nextthink ) {
+		self->nextthink = 0;
+		return;
+	}
+
+	// turn it on
+	func_timer_think (self);
+}
+
+void SP_func_timer( gentity_t *self ) {
+	G_SpawnFloat( "random", "1", &self->random);
+	G_SpawnFloat( "wait", "1", &self->wait );
+
+	self->e_UseFunc   = useF_func_timer_use;
+	self->e_ThinkFunc = thinkF_func_timer_think;
+
+	if ( self->random >= self->wait ) {
+		self->random = self->wait - 1;//NOTE: was - FRAMETIME, but FRAMETIME is in msec (100) and these numbers are in *seconds*!
+		gi.Printf( "func_timer at %s has random >= wait\n", vtos( self->s.origin ) );
+	}
+
+	if ( self->spawnflags & 1 ) {
+		self->nextthink = level.time + FRAMETIME;
+		self->activator = self;
+	}
+
+	self->svFlags = SVF_NOCLIENT;
+}
+
+/*
+==============================================================================
+
+timer
+
+==============================================================================
+*/
+
+
+/*QUAKED trigger_entdist (.1 .5 .1) (-8 -8 -8) (8 8 8) PLAYER NPC
+fires if the given entity is within the given distance.  Sets itself inactive after one use.
+----- KEYS -----
+distance - radius entity can be away to fire trigger
+target - fired if entity is within distance
+target2 - fired if entity not within distance
+
+NPC_target - NPC_types to look for
+ownername - If any, who to calc the distance from- default is the trigger_entdist himself
+example: target "biessman telsia" will look for the biessman and telsia NPC
+if it finds either of these within distance it will fire.
+
+  todo - 
+  add delay, count
+  add monster classnames?????
+  add LOS to it???
+*/
+
+void trigger_entdist_use( gentity_t *self, gentity_t *other, gentity_t *activator )
+{
+	vec3_t		diff;
+	gentity_t	*found = NULL;
+	gentity_t	*owner = NULL;
+	qboolean	useflag;
+	const char	*token, *holdString;
+
+	if ( self->svFlags & SVF_INACTIVE )	// Don't use INACTIVE
+		return;
+
+	G_ActivateBehavior(self,BSET_USE);
+
+	if(self->ownername && self->ownername[0])
+	{
+		owner = G_Find(NULL, FOFS(targetname), self->ownername);
+	}
+
+	if(owner == NULL)
+	{
+		owner = self;
+	}
+
+	self->activator = activator;
+
+	useflag = qfalse;
+
+	self->svFlags |= SVF_INACTIVE;	// Make it inactive after one use
+
+	if (self->spawnflags & ENTDIST_PLAYER)	// Look for player???
+	{
+		found = &g_entities[0];
+
+		if (found)
+		{	
+			VectorSubtract(owner->currentOrigin, found->currentOrigin, diff);
+			if(VectorLength(diff) < self->count)
+			{
+				useflag = qtrue;
+			}
+		}
+	}
+
+	if ((self->spawnflags & ENTDIST_NPC) && (!useflag))
+	{
+		holdString = self->NPC_target;
+
+		while (holdString)
+		{
+			token = COM_Parse( &holdString);
+			if ( !token ) // Nothing left to look at
+			{
+				break;
+			}
+
+			found = G_Find(found, FOFS(targetname), token);	// Look for the specified NPC
+			if (found)	//Found???
+			{	
+				VectorSubtract(owner->currentOrigin, found->currentOrigin, diff);
+				if(VectorLength(diff) < self->count)	// Within distance
+				{
+					useflag = qtrue;
+					break;
+				}
+			}
+		}
+	}
+
+	if (useflag)
+	{
+		G_UseTargets2 (self, self->activator, self->target);
+	}
+	else if (self->target2)
+	{
+		// This is the negative target
+		G_UseTargets2 (self, self->activator, self->target2);
+	}	
+
+
+}
+
+void SP_trigger_entdist( gentity_t *self ) 
+{
+	G_SpawnInt( "distance", "0", &self->count);
+
+	self->e_UseFunc = useF_trigger_entdist_use;
+
+}
+
+// spawnflag
+#define	TRIGGERVISIBLE_FORCESIGHT		2
+
+void trigger_visible_check_player_visibility( gentity_t *self )
+{
+	//Check every FRAMETIME*2
+	self->nextthink = level.time + FRAMETIME*2;
+
+	if ( self->svFlags & SVF_INACTIVE )
+	{
+		return;
+	}
+
+	vec3_t	dir;
+	float	dist;
+	gentity_t	*player = &g_entities[0];
+
+	if (!player || !player->client )
+	{
+		return;
+	}
+
+	// Added 01/20/03 by AReis
+	// If this trigger can only be used if the players force sight is on...
+	if ( self->spawnflags & TRIGGERVISIBLE_FORCESIGHT )
+	{
+		// If their force sight is not on, leave...
+		if ( !( player->client->ps.forcePowersActive & (1 << FP_SEE) ) )
+		{
+			return;
+		}
+	}
+
+	//1: see if player is within 512*512 range
+	VectorSubtract( self->currentOrigin, player->client->renderInfo.eyePoint, dir );
+	dist = VectorNormalize( dir );
+	if ( dist < self->radius )
+	{//Within range
+		vec3_t	forward;
+		float	dot;
+		//2: see if dot to us and player viewangles is > 0.7
+		AngleVectors( player->client->renderInfo.eyeAngles, forward, NULL, NULL );
+		dot = DotProduct( forward, dir );
+		if ( dot > self->random )
+		{//Within the desired FOV
+			//3: see if player is in PVS
+			if ( gi.inPVS( self->currentOrigin, player->client->renderInfo.eyePoint ) )
+			{
+				vec3_t	mins = {-1, -1, -1};
+				vec3_t	maxs = {1, 1, 1};
+				//4: If needbe, trace to see if there is clear LOS from player viewpos
+				if ( (self->spawnflags&1) || G_ClearTrace( player->client->renderInfo.eyePoint, mins, maxs, self->currentOrigin, 0, MASK_OPAQUE ) )
+				{
+					//5: Fire!
+					G_UseTargets( self, player );
+					//6: Remove yourself
+					G_FreeEntity( self );
+				}
+			}
+		}
+	}
+
+}
+
+/*QUAKED trigger_visible (.1 .5 .1) (-8 -8 -8) (8 8 8) NOTRACE FORCESIGHT x x x x x INACTIVE
+
+  Only fires when player is looking at it, fires only once then removes itself.
+
+  NOTRACE - Doesn't check to make sure the line of sight is completely clear (penetrates walls, forcefields, etc)
+  FORCESIGHT - Only activates this trigger if force sight is on.
+  INACTIVE - won't check for player visibility until activated
+
+  radius - how far this ent can be from player's eyes, max, and still be considered "seen"
+  FOV - how far off to the side of the player's field of view this can be, max, and still be considered "seen".  Player FOV is 80, so the default for this value is 30.
+
+  "target" - What to use when it fires.
+*/
+void SP_trigger_visible( gentity_t *self )
+{
+	if ( self->radius <= 0 )
+	{
+		self->radius = 512;
+	}
+
+	if ( self->random <= 0 )
+	{//about 30 degrees
+		self->random = 0.7f;
+	}
+	else
+	{//convert from FOV degrees to number meaningful for dot products
+		self->random = 1.0f - (self->random/90.0f);
+	}
+
+	if ( self->spawnflags & 128 )
+	{// Make it inactive
+		self->svFlags |= SVF_INACTIVE;	
+	}
+
+	G_SetOrigin( self, self->s.origin );
+	gi.linkentity( self );
+
+	self->e_ThinkFunc = thinkF_trigger_visible_check_player_visibility;
+	self->nextthink = level.time + FRAMETIME*2;
+}
\ No newline at end of file
diff --git a/code/game/g_turret.cpp b/code/game/g_turret.cpp
new file mode 100644
index 0000000..8f01558
--- /dev/null
+++ b/code/game/g_turret.cpp
@@ -0,0 +1,2516 @@
+// leave this line at the top for all g_xxxx.cpp files...
+#include "g_headers.h"
+
+#include "g_local.h"
+#include "g_functions.h"
+#include "b_local.h"
+
+extern	cvar_t	*g_spskill;
+
+void G_SetEnemy( gentity_t *self, gentity_t *enemy );
+void finish_spawning_turret( gentity_t *base );
+void ObjectDie (gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int meansOfDeath );
+//special routine for tracking angles between client and server -rww
+void turret_SetBoneAngles(gentity_t *ent, char *bone, const vec3_t angles);
+
+#define	ARM_ANGLE_RANGE		60
+#define	HEAD_ANGLE_RANGE	90
+
+#define SPF_TURRETG2_TURBO		4
+#define SPF_TURRETG2_LEAD_ENEMY	8
+
+#define name "models/map_objects/imp_mine/turret_canon.glm"
+#define name2 "models/map_objects/imp_mine/turret_damage.md3"
+#define name3 "models/map_objects/wedge/laser_cannon_model.glm"
+
+//------------------------------------------------------------------------------------------------------------
+void TurretPain( gentity_t *self, gentity_t *inflictor, gentity_t *attacker, const vec3_t point, int damage, int mod, int hitLoc )
+//------------------------------------------------------------------------------------------------------------
+{
+	vec3_t dir;
+
+	VectorSubtract( point, self->currentOrigin, dir );
+	VectorNormalize( dir );
+
+	if ( mod == MOD_DEMP2 || mod == MOD_DEMP2_ALT )
+	{
+		// DEMP2 makes the turret stop shooting for a bit..and does extra feedback
+		self->attackDebounceTime = level.time + 800 + random() * 500;
+		G_PlayEffect( "sparks/spark_exp_nosnd", point, dir );
+	}
+
+	if ( !self->enemy )
+	{//react to being hit
+		G_SetEnemy( self, attacker );
+	}
+
+	G_PlayEffect( "sparks/spark_exp_nosnd", point, dir );
+}
+
+//------------------------------------------------------------------------------------------------------------
+void turret_die ( gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int meansOfDeath,int dFlags,int hitLoc )
+//------------------------------------------------------------------------------------------------------------
+{
+	vec3_t	forward = { 0,0,-1 }, pos;
+
+	// Turn off the thinking of the base & use it's targets
+	self->e_ThinkFunc = thinkF_NULL;
+	self->e_UseFunc = useF_NULL;
+
+	// clear my data
+	self->e_DieFunc  = dieF_NULL;
+	self->takedamage = qfalse;
+	self->health = 0;
+	self->s.loopSound = 0;
+
+	// hack the effect angle so that explode death can orient the effect properly
+	if ( self->spawnflags & 2 )
+	{
+		VectorSet( forward, 0, 0, 1 );
+	}
+
+//	VectorCopy( self->currentOrigin, self->s.pos.trBase );
+
+	if ( self->spawnflags & SPF_TURRETG2_TURBO )
+	{
+		G_PlayEffect( G_EffectIndex( "explosions/fighter_explosion2" ), self->currentOrigin, self->currentAngles );
+	}
+	else
+	{
+		if ( self->fxID > 0 )
+		{
+			VectorMA( self->currentOrigin, 12, forward, pos );
+			G_PlayEffect( self->fxID, pos, forward );
+		}
+	}
+	
+	if ( self->splashDamage > 0 && self->splashRadius > 0 )
+	{
+		G_RadiusDamage( self->currentOrigin, attacker, self->splashDamage, self->splashRadius, attacker, MOD_UNKNOWN );
+	}
+
+	if ( self->s.eFlags & EF_SHADER_ANIM )
+	{
+		self->s.frame = 1; // black
+	}
+
+	self->s.weapon = 0; // crosshair code uses this to mark crosshair red
+
+	if ( self->s.modelindex2 )
+	{
+		// switch to damage model if we should
+		self->s.modelindex = self->s.modelindex2;
+
+		VectorCopy( self->currentAngles, self->s.apos.trBase );
+		VectorClear( self->s.apos.trDelta );
+		
+		if ( self->target )
+		{
+			G_UseTargets( self, attacker );
+		}
+	}
+	else
+	{
+		ObjectDie( self, inflictor, attacker, damage, meansOfDeath );
+	}
+}
+
+//start an animation on model_root both server side and client side
+void TurboLaser_SetBoneAnim(gentity_t *eweb, int startFrame, int endFrame)
+{
+	//set info on the entity so it knows to start the anim on the client next snapshot.
+	//eweb->s.eFlags |= EF_G2ANIMATING;
+
+	if (eweb->s.torsoAnim == startFrame && eweb->s.legsAnim == endFrame)
+	{ //already playing this anim, let's flag it to restart
+		//eweb->s.torsoFlip = !eweb->s.torsoFlip;
+	}
+	else
+	{
+		eweb->s.torsoAnim = startFrame;
+		eweb->s.legsAnim = endFrame;
+	}
+
+	//now set the animation on the server ghoul2 instance.
+	assert(&eweb->ghoul2[0]);
+	gi.G2API_SetBoneAnim(&eweb->ghoul2[0], "model_root", startFrame, endFrame,
+		(BONE_ANIM_OVERRIDE_FREEZE|BONE_ANIM_BLEND), 1.0f, level.time, -1, 100);
+}
+
+#define START_DIS 15
+
+extern void WP_FireTurboLaserMissile( gentity_t *ent, vec3_t start, vec3_t dir );
+
+//----------------------------------------------------------------
+static void turret_fire ( gentity_t *ent, vec3_t start, vec3_t dir )
+//----------------------------------------------------------------
+{
+	vec3_t		org, ang;
+	gentity_t	*bolt;
+
+	if ( (gi.pointcontents( start, ent->s.number )&MASK_SHOT) )
+	{
+		return;
+	}
+
+	VectorMA( start, -START_DIS, dir, org ); // dumb....
+
+	if ( ent->random )
+	{
+		vectoangles( dir, ang );
+		ang[PITCH] += Q_flrand( -ent->random, ent->random );
+		ang[YAW] += Q_flrand( -ent->random, ent->random );
+		AngleVectors( ang, dir, NULL, NULL );
+	}
+
+	vectoangles(dir, ang);
+
+	if ( (ent->spawnflags&SPF_TURRETG2_TURBO) )
+	{
+		//muzzle flash
+		G_PlayEffect( G_EffectIndex( "turret/turb_muzzle_flash" ), org, ang );
+		G_SoundOnEnt( ent, CHAN_LESS_ATTEN, "sound/vehicles/weapons/turbolaser/fire1" );
+
+		WP_FireTurboLaserMissile( ent, start, dir );
+		if ( ent->alt_fire )
+		{
+			TurboLaser_SetBoneAnim( ent, 2, 3 );
+		}
+		else
+		{
+			TurboLaser_SetBoneAnim( ent, 0, 1 );
+		}
+	}
+	else
+	{
+		G_PlayEffect( "blaster/muzzle_flash", org, dir );
+
+		bolt = G_Spawn();
+		
+		bolt->classname = "turret_proj";
+		bolt->nextthink = level.time + 10000;
+		bolt->e_ThinkFunc = thinkF_G_FreeEntity;
+		bolt->s.eType = ET_MISSILE;
+		bolt->s.weapon = WP_BLASTER;
+		bolt->owner = ent;
+		bolt->damage = ent->damage;
+		bolt->dflags = DAMAGE_NO_KNOCKBACK | DAMAGE_HEAVY_WEAP_CLASS;		// Don't push them around, or else we are constantly re-aiming
+		bolt->splashDamage = 0;
+		bolt->splashRadius = 0;
+		bolt->methodOfDeath = MOD_ENERGY;
+		bolt->clipmask = MASK_SHOT | CONTENTS_LIGHTSABER;
+		bolt->trigger_formation = qfalse;		// don't draw tail on first frame	
+
+		VectorSet( bolt->maxs, 1.5, 1.5, 1.5 );
+		VectorScale( bolt->maxs, -1, bolt->mins );
+		bolt->s.pos.trType = TR_LINEAR;
+		bolt->s.pos.trTime = level.time;
+		VectorCopy( start, bolt->s.pos.trBase );
+		VectorScale( dir, 1100, bolt->s.pos.trDelta );
+		SnapVector( bolt->s.pos.trDelta );		// save net bandwidth
+		VectorCopy( start, bolt->currentOrigin);
+	}
+}
+
+//-----------------------------------------------------
+void turret_head_think( gentity_t *self )
+//-----------------------------------------------------
+{
+	// if it's time to fire and we have an enemy, then gun 'em down!  pushDebounce time controls next fire time
+	if ( self->enemy && self->pushDebounceTime < level.time && self->attackDebounceTime < level.time )
+	{
+		// set up our next fire time
+		self->pushDebounceTime = level.time + self->wait;
+
+		vec3_t		fwd, org;
+		mdxaBone_t	boltMatrix;
+
+		// Getting the flash bolt here
+		gi.G2API_GetBoltMatrix( self->ghoul2,
+					0, 
+					(self->spawnflags&SPF_TURRETG2_TURBO) ? ( (self->alt_fire ? gi.G2API_AddBolt( &self->ghoul2[0], "*muzzle2" ) : gi.G2API_AddBolt( &self->ghoul2[0], "*muzzle1" )) ) : gi.G2API_AddBolt( &self->ghoul2[0], "*flash03" ),
+					&boltMatrix, 
+					self->currentAngles, 
+					self->currentOrigin, 
+					level.time,
+					NULL, 
+					self->modelScale );
+		if ( (self->spawnflags&SPF_TURRETG2_TURBO) )
+		{
+			self->alt_fire = !self->alt_fire;
+		}
+
+		gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, org );
+
+		if ( (self->spawnflags&SPF_TURRETG2_TURBO) ) 
+		{
+			gi.G2API_GiveMeVectorFromMatrix( boltMatrix, NEGATIVE_Y, fwd );
+		}
+		else
+		{
+			gi.G2API_GiveMeVectorFromMatrix( boltMatrix, POSITIVE_Y, fwd );
+		}
+
+		VectorMA( org, START_DIS, fwd, org );
+
+		turret_fire( self, org, fwd );
+		self->fly_sound_debounce_time = level.time;//used as lastShotTime
+	}
+}
+
+//-----------------------------------------------------
+static void turret_aim( gentity_t *self )
+//-----------------------------------------------------
+{
+	vec3_t	enemyDir, org, org2;
+	vec3_t	desiredAngles, setAngle;
+	float	diffYaw = 0.0f, diffPitch = 0.0f;
+	float	maxYawSpeed		= ( self->spawnflags & SPF_TURRETG2_TURBO ) ? 30.0f : 14.0f;
+	float	maxPitchSpeed	= ( self->spawnflags & SPF_TURRETG2_TURBO ) ? 15.0f : 3.0f;
+
+	// move our gun base yaw to where we should be at this time....
+	EvaluateTrajectory( &self->s.apos, level.time, self->currentAngles );
+	self->currentAngles[YAW] = AngleNormalize360( self->currentAngles[YAW] );
+	self->speed = AngleNormalize360( self->speed );
+
+	if ( self->enemy )
+	{
+		// ...then we'll calculate what new aim adjustments we should attempt to make this frame
+		// Aim at enemy
+		if ( self->enemy->client )
+		{
+			VectorCopy( self->enemy->client->renderInfo.eyePoint, org );
+		}
+		else
+		{
+			VectorCopy( self->enemy->currentOrigin, org );
+		}
+		if ( self->spawnflags & 2 )
+		{
+			org[2] -= 15;
+		}
+		else
+		{
+			org[2] -= 5;
+		}
+		mdxaBone_t	boltMatrix;
+
+		// Getting the "eye" here
+		gi.G2API_GetBoltMatrix( self->ghoul2,
+					0, 
+					(self->spawnflags&SPF_TURRETG2_TURBO) ? ( (self->alt_fire ? gi.G2API_AddBolt( &self->ghoul2[0], "*muzzle2" ) : gi.G2API_AddBolt( &self->ghoul2[0], "*muzzle1" )) ) : gi.G2API_AddBolt( &self->ghoul2[0], "*flash03" ),
+					&boltMatrix,
+					self->currentAngles,
+					self->s.origin,
+					level.time,
+					NULL,
+					self->modelScale );
+
+		gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, org2 );
+
+		VectorSubtract( org, org2, enemyDir );
+		vectoangles( enemyDir, desiredAngles );
+
+		diffYaw = AngleSubtract( self->currentAngles[YAW], desiredAngles[YAW] );
+		diffPitch = AngleSubtract( self->speed, desiredAngles[PITCH] );
+	}
+	else
+	{
+		// no enemy, so make us slowly sweep back and forth as if searching for a new one
+//		diffYaw = sin( level.time * 0.0001f + self->count ) * 5.0f;	// don't do this for now since it can make it go into walls.
+	}
+
+	if ( diffYaw )
+	{
+		// cap max speed....
+		if ( fabs(diffYaw) > maxYawSpeed )
+		{
+			diffYaw = ( diffYaw >= 0 ? maxYawSpeed : -maxYawSpeed );
+		}
+
+		// ...then set up our desired yaw
+		VectorSet( setAngle, 0.0f, diffYaw, 0.0f );
+
+		VectorCopy( self->currentAngles, self->s.apos.trBase );
+		VectorScale( setAngle,- 5, self->s.apos.trDelta );
+		self->s.apos.trTime = level.time;
+		self->s.apos.trType = TR_LINEAR;
+	}
+
+	if ( diffPitch )
+	{
+		if ( fabs(diffPitch) > maxPitchSpeed )
+		{
+			// cap max speed
+			self->speed += (diffPitch > 0.0f) ? -maxPitchSpeed : maxPitchSpeed;
+		}
+		else
+		{
+			// small enough, so just add half the diff so we smooth out the stopping
+			self->speed -= ( diffPitch );//desiredAngles[PITCH];
+		}
+
+		// Note that this is NOT interpolated, so it will be less smooth...On the other hand, it does use Ghoul2 to blend, so it may smooth it out a bit?
+		if ( (self->spawnflags&SPF_TURRETG2_TURBO) )
+		{
+			if ( self->spawnflags & 2 )
+			{
+				VectorSet( desiredAngles, 0.0f, 0.0f, -self->speed );
+			}
+			else
+			{
+				VectorSet( desiredAngles, 0.0f, 0.0f, self->speed );
+			}
+			turret_SetBoneAngles(self, "pitch", desiredAngles);
+		}
+		else
+		{
+			// Note that this is NOT interpolated, so it will be less smooth...On the other hand, it does use Ghoul2 to blend, so it may smooth it out a bit?
+			if ( self->spawnflags & 2 )
+			{
+				VectorSet( desiredAngles, self->speed, 0.0f, 0.0f );
+			}
+			else
+			{
+				VectorSet( desiredAngles, -self->speed, 0.0f, 0.0f );
+			}
+			gi.G2API_SetBoneAngles( &self->ghoul2[0], "Bone_body", desiredAngles, 
+							BONE_ANGLES_POSTMULT, POSITIVE_Y, POSITIVE_Z, POSITIVE_X, NULL, 100, cg.time ); 
+		}
+	}
+
+	if ( diffYaw || diffPitch )
+	{
+		self->s.loopSound = G_SoundIndex( "sound/chars/turret/move.wav" );
+	}
+	else
+	{
+		self->s.loopSound = 0;
+	}
+}
+
+//-----------------------------------------------------
+static void turret_turnoff( gentity_t *self )
+//-----------------------------------------------------
+{
+	if ( self->enemy == NULL )
+	{
+		// we don't need to turnoff
+		return;
+	}
+
+	if ( (self->spawnflags&SPF_TURRETG2_TURBO) )
+	{
+		TurboLaser_SetBoneAnim( self, 4, 5 );
+	}
+
+	// shut-down sound
+	G_Sound( self, G_SoundIndex( "sound/chars/turret/shutdown.wav" ));
+	
+	// make turret play ping sound for 5 seconds
+	self->aimDebounceTime = level.time + 5000;
+
+	// Clear enemy
+	self->enemy = NULL;
+}
+
+//-----------------------------------------------------
+static qboolean turret_find_enemies( gentity_t *self )
+//-----------------------------------------------------
+{
+	// HACK for t2_wedge!!!
+	if ( self->spawnflags & SPF_TURRETG2_TURBO )
+		return qfalse;
+
+	qboolean	found = qfalse;
+	int			count;
+	float		bestDist = self->radius * self->radius;
+	float		enemyDist;
+	vec3_t		enemyDir, org, org2;
+	gentity_t	*entity_list[MAX_GENTITIES], *target, *bestTarget = NULL;
+
+	if ( self->aimDebounceTime > level.time ) // time since we've been shut off
+	{
+		// We were active and alert, i.e. had an enemy in the last 3 secs
+		if ( self->painDebounceTime < level.time )
+		{
+			G_Sound(self, G_SoundIndex( "sound/chars/turret/ping.wav" ));
+			self->painDebounceTime = level.time + 1000;
+		}
+	}
+
+	VectorCopy( self->currentOrigin, org2 );
+	if ( self->spawnflags & 2 )
+	{
+		org2[2] += 20;
+	}
+	else
+	{
+		org2[2] -= 20;
+	}
+
+	count = G_RadiusList( org2, self->radius, self, qtrue, entity_list );
+
+	for ( int i = 0; i < count; i++ )
+	{
+		target = entity_list[i];
+
+		if ( !target->client )
+		{
+			// only attack clients
+			continue;
+		}
+		if ( target == self || !target->takedamage || target->health <= 0 || ( target->flags & FL_NOTARGET ))
+		{
+			continue;
+		}
+		if ( target->client->playerTeam == self->noDamageTeam )
+		{ 
+			// A bot we don't want to shoot
+			continue;
+		}
+		if ( !gi.inPVS( org2, target->currentOrigin ))
+		{
+			continue;
+		}
+
+		VectorCopy( target->client->renderInfo.eyePoint, org );
+
+		if ( self->spawnflags & 2 )
+		{
+			org[2] -= 15;
+		}
+		else
+		{
+			org[2] += 5;
+		}
+
+		trace_t	tr;
+		gi.trace( &tr, org2, NULL, NULL, org, self->s.number, MASK_SHOT );
+
+		if ( !tr.allsolid && !tr.startsolid && ( tr.fraction == 1.0 || tr.entityNum == target->s.number ))
+		{
+			// Only acquire if have a clear shot, Is it in range and closer than our best?
+			VectorSubtract( target->currentOrigin, self->currentOrigin, enemyDir );
+			enemyDist = VectorLengthSquared( enemyDir );
+
+			if ( enemyDist < bestDist )// all things equal, keep current
+			{
+				if ( self->attackDebounceTime < level.time )
+				{
+					// We haven't fired or acquired an enemy in the last 2 seconds-start-up sound
+					G_Sound( self, G_SoundIndex( "sound/chars/turret/startup.wav" ));
+
+					// Wind up turrets for a bit
+					self->attackDebounceTime = level.time + 1400;
+				}
+
+				bestTarget = target;
+				bestDist = enemyDist;
+				found = qtrue;
+			}
+		}
+	}
+
+	if ( found )
+	{
+		if ( !self->enemy )
+		{//just aquired one
+			AddSoundEvent( bestTarget, self->currentOrigin, 256, AEL_DISCOVERED );
+			AddSightEvent( bestTarget, self->currentOrigin, 512, AEL_DISCOVERED, 20 );
+		}
+		G_SetEnemy( self, bestTarget );
+		if ( VALIDSTRING( self->target2 ))
+		{
+			G_UseTargets2( self, self, self->target2 );
+		}
+	}
+
+	return found;
+}
+
+//-----------------------------------------------------
+void turret_base_think( gentity_t *self )
+//-----------------------------------------------------
+{
+	qboolean	turnOff = qtrue;
+	float		enemyDist;
+	vec3_t		enemyDir, org, org2;
+
+	self->nextthink = level.time + FRAMETIME;
+
+	if ( self->spawnflags & 1 )
+	{
+		// not turned on
+		turret_turnoff( self );
+		turret_aim( self );
+
+		// No target
+		self->flags |= FL_NOTARGET;
+		return;
+	}
+	else
+	{
+		// I'm all hot and bothered
+		self->flags &= ~FL_NOTARGET;
+	}
+
+	if ( !self->enemy )
+	{
+		if ( turret_find_enemies( self ))
+		{
+			turnOff = qfalse;
+		}
+	}
+	else
+	{
+		if ( self->enemy->health > 0 )
+		{
+			// enemy is alive
+			VectorSubtract( self->enemy->currentOrigin, self->currentOrigin, enemyDir );
+			enemyDist = VectorLengthSquared( enemyDir );
+
+			if ( enemyDist < self->radius * self->radius )
+			{
+				// was in valid radius
+				if ( gi.inPVS( self->currentOrigin, self->enemy->currentOrigin ) )
+				{
+					// Every now and again, check to see if we can even trace to the enemy
+					trace_t tr;
+
+					if ( self->enemy->client )
+					{
+						VectorCopy( self->enemy->client->renderInfo.eyePoint, org );
+					}
+					else
+					{
+						VectorCopy( self->enemy->currentOrigin, org );
+					}
+					VectorCopy( self->currentOrigin, org2 );
+					if ( self->spawnflags & 2 )
+					{
+						org2[2] += 10;
+					}
+					else
+					{
+						org2[2] -= 10;
+					}
+					gi.trace( &tr, org2, NULL, NULL, org, self->s.number, MASK_SHOT );
+
+					if ( self->spawnflags & SPF_TURRETG2_TURBO || ( !tr.allsolid && !tr.startsolid && tr.entityNum == self->enemy->s.number ) )
+					{
+						turnOff = qfalse;	// Can see our enemy
+					}
+				}
+			}
+		}
+
+		turret_head_think( self );
+	}
+
+	if ( turnOff )
+	{
+		if ( self->bounceCount < level.time ) // bounceCount is used to keep the thing from ping-ponging from on to off
+		{
+			turret_turnoff( self );
+		}
+	}
+	else
+	{
+		// keep our enemy for a minimum of 2 seconds from now
+		self->bounceCount = level.time + 2000 + random() * 150;
+	}
+
+	turret_aim( self );
+}
+
+//-----------------------------------------------------------------------------
+void turret_base_use( gentity_t *self, gentity_t *other, gentity_t *activator )
+//-----------------------------------------------------------------------------
+{
+	// Toggle on and off
+	self->spawnflags = (self->spawnflags ^ 1);
+
+	if (( self->s.eFlags & EF_SHADER_ANIM ) && ( self->spawnflags & 1 )) // Start_Off
+	{
+		self->s.frame = 1; // black
+	}
+	else
+	{
+		self->s.frame = 0; // glow
+	}
+}
+
+//special routine for tracking angles between client and server -rww
+void turret_SetBoneAngles(gentity_t *ent, char *bone, const vec3_t angles)
+{
+	/*
+#ifdef _XBOX
+	byte *thebone = &ent->s.boneIndex1;
+	byte *firstFree = NULL;
+#else
+	int *thebone = &ent->s.boneIndex1;
+	int *firstFree = NULL;
+#endif
+	int i = 0;
+	int boneIndex = G_BoneIndex(bone);
+	int flags;
+	Eorientations up, right, forward;
+	vec3_t *boneVector = &ent->s.boneAngles1;
+	vec3_t *freeBoneVec = NULL;
+
+	while (thebone)
+	{
+		if (!*thebone && !firstFree)
+		{ //if the value is 0 then this index is clear, we can use it if we don't find the bone we want already existing.
+			firstFree = thebone;
+			freeBoneVec = boneVector;
+		}
+		else if (*thebone)
+		{
+			if (*thebone == boneIndex)
+			{ //this is it
+				break;
+			}
+		}
+
+		switch (i)
+		{
+		case 0:
+			thebone = &ent->s.boneIndex2;
+			boneVector = &ent->s.boneAngles2;
+			break;
+		case 1:
+			thebone = &ent->s.boneIndex3;
+			boneVector = &ent->s.boneAngles3;
+			break;
+		case 2:
+			thebone = &ent->s.boneIndex4;
+			boneVector = &ent->s.boneAngles4;
+			break;
+		default:
+			thebone = NULL;
+			boneVector = NULL;
+			break;
+		}
+
+		i++;
+	}
+
+	if (!thebone)
+	{ //didn't find it, create it
+		if (!firstFree)
+		{ //no free bones.. can't do a thing then.
+			Com_Printf("WARNING: NPC has no free bone indexes\n");
+			return;
+		}
+
+		thebone = firstFree;
+
+		*thebone = boneIndex;
+		boneVector = freeBoneVec;
+	}
+
+	//If we got here then we have a vector and an index.
+
+	//Copy the angles over the vector in the entitystate, so we can use the corresponding index
+	//to set the bone angles on the client.
+	VectorCopy(angles, *boneVector);
+*/
+	//Now set the angles on our server instance if we have one.
+
+	if ( !ent->ghoul2.size() )
+	{
+		return;
+	}
+
+	int flags = BONE_ANGLES_POSTMULT;
+	Eorientations up, right, forward;
+	up = POSITIVE_Y;
+	right = NEGATIVE_Z;
+	forward = NEGATIVE_X;
+
+	//first 3 bits is forward, second 3 bits is right, third 3 bits is up
+	//ent->s.boneOrient = ((forward)|(right<<3)|(up<<6));
+
+	gi.G2API_SetBoneAngles( &ent->ghoul2[0], bone, angles, flags, up,
+							right, forward, NULL, 100, level.time ); 
+}
+
+void turret_set_models( gentity_t *self, qboolean dying )
+{
+	if ( dying )
+	{
+		if ( !(self->spawnflags&SPF_TURRETG2_TURBO) )
+		{
+			self->s.modelindex = G_ModelIndex( name2 );
+			self->s.modelindex2 = G_ModelIndex( name );
+		}
+		
+		gi.G2API_RemoveGhoul2Model( self->ghoul2, 0 );
+		/*G_KillG2Queue( self->s.number );
+		self->s.modelGhoul2 = 0;
+		
+		gi.G2API_InitGhoul2Model( &self->ghoul2,
+									name2,
+									0, //base->s.modelindex,
+									//note, this is not the same kind of index - this one's referring to the actual
+									//index of the model in the g2 instance, whereas modelindex is the index of a
+									//configstring -rww
+									0,
+									0,
+									0,
+									0);
+		*/
+	}
+	else
+	{
+		if ( !(self->spawnflags&SPF_TURRETG2_TURBO) )
+		{
+			self->s.modelindex = G_ModelIndex( name );
+			self->s.modelindex2 = G_ModelIndex( name2 );
+			//set the new onw
+			gi.G2API_InitGhoul2Model( self->ghoul2,
+										name,
+										0, //base->s.modelindex,
+										//note, this is not the same kind of index - this one's referring to the actual
+										//index of the model in the g2 instance, whereas modelindex is the index of a
+										//configstring -rww
+										0,
+										0,
+										0,
+										0);
+		}
+		else
+		{
+			self->s.modelindex = G_ModelIndex( name3 );
+			//set the new onw
+			gi.G2API_InitGhoul2Model( self->ghoul2,
+										name3,
+										0, //base->s.modelindex,
+										//note, this is not the same kind of index - this one's referring to the actual
+										//index of the model in the g2 instance, whereas modelindex is the index of a
+										//configstring -rww
+										0,
+										0,
+										0,
+										0);
+		}
+		
+		/*self->s.modelGhoul2 = 1;
+		if ( (self->spawnflags&SPF_TURRETG2_TURBO) )
+		{//larger
+			self->s.g2radius = 128;
+		}
+		else
+		{
+			self->s.g2radius = 80;
+		}*/
+
+		if ( (self->spawnflags&SPF_TURRETG2_TURBO) )
+		{//different pitch bone and muzzle flash points
+			turret_SetBoneAngles(self, "pitch", vec3_origin);
+			//self->genericValue11 = gi.G2API_AddBolt( self->ghoul2, 0, "*muzzle1" );
+			//self->genericValue12 = gi.G2API_AddBolt( self->ghoul2, 0, "*muzzle2" );
+		}
+		else
+		{
+			turret_SetBoneAngles(self, "Bone_body", vec3_origin);
+			//self->genericValue11 = gi.G2API_AddBolt( self->ghoul2, 0, "*flash03" );
+		}
+	}
+}
+
+/*QUAKED misc_turret (1 0 0) (-8 -8 -22) (8 8 0) START_OFF UPSIDE_DOWN TURBO
+Turret that hangs from the ceiling, will aim and shoot at enemies
+
+  START_OFF - Starts off
+  UPSIDE_DOWN - make it rest on a surface/floor instead of hanging from the ceiling
+  TURBO - Big-ass, Boxy Death Star Turbo Laser version
+
+  radius - How far away an enemy can be for it to pick it up (default 512)
+  wait	- Time between shots (default 150 ms)
+  dmg	- How much damage each shot does (default 5)
+  health - How much damage it can take before exploding (default 100)
+  
+  splashDamage - How much damage the explosion does
+  splashRadius - The radius of the explosion
+  NOTE: If either of the above two are 0, it will not make an explosion
+  
+  targetname - Toggles it on/off
+  target - What to use when destroyed
+  target2 - What to use when it decides to start shooting at an enemy
+
+  team - team that is not targeted by and does not take damage from this turret
+	"player",
+	"enemy",	(default)
+	"neutral"
+*/
+//-----------------------------------------------------
+void SP_misc_turret( gentity_t *base )
+//-----------------------------------------------------
+{
+	/*base->s.modelindex = G_ModelIndex( "models/map_objects/imp_mine/turret_canon.glm" );
+	base->s.modelindex2 = G_ModelIndex( "models/map_objects/imp_mine/turret_damage.md3" );
+	base->playerModel = gi.G2API_InitGhoul2Model( base->ghoul2, "models/map_objects/imp_mine/turret_canon.glm", base->s.modelindex );
+	base->s.radius = 80.0f;*/
+	turret_set_models( base, qfalse );
+
+	gi.G2API_SetBoneAngles( &base->ghoul2[base->playerModel], "Bone_body", vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_Y, POSITIVE_Z, POSITIVE_X, NULL ); 
+	base->torsoBolt = gi.G2API_AddBolt( &base->ghoul2[base->playerModel], "*flash03" );
+
+	finish_spawning_turret( base );
+
+	if (( base->spawnflags & 1 )) // Start_Off
+	{
+		base->s.frame = 1; // black
+	}
+	else
+	{
+		base->s.frame = 0; // glow
+	}
+	base->s.eFlags |= EF_SHADER_ANIM;
+}
+
+//-----------------------------------------------------
+void finish_spawning_turret( gentity_t *base )
+{
+	vec3_t		fwd;
+
+	if ( base->spawnflags & 2 )
+	{
+		base->s.angles[ROLL] += 180;
+		base->s.origin[2] -= 22.0f;
+	}
+
+	G_SetAngles( base, base->s.angles );
+	AngleVectors( base->currentAngles, fwd, NULL, NULL );
+
+	G_SetOrigin(base, base->s.origin);
+
+	base->noDamageTeam = TEAM_ENEMY;
+	
+	base->s.eType = ET_GENERAL;
+
+	if ( base->team && base->team[0] )
+	{
+		base->noDamageTeam = (team_t)GetIDForString( TeamTable, base->team );
+		base->team = NULL;
+	}
+
+	// Set up our explosion effect for the ExplodeDeath code....
+	base->fxID = G_EffectIndex( "turret/explode" );
+	G_EffectIndex( "sparks/spark_exp_nosnd" );
+
+	base->e_UseFunc = useF_turret_base_use;
+	base->e_PainFunc = painF_TurretPain;
+
+	// don't start working right away
+	base->e_ThinkFunc = thinkF_turret_base_think;
+	base->nextthink = level.time + FRAMETIME * 5;
+
+	// this is really the pitch angle.....
+	base->speed = 0;
+
+	G_SpawnFloat( "shotspeed", "0", &base->mass ); 
+	if ( (base->spawnflags&SPF_TURRETG2_TURBO) )
+	{
+		if ( !base->random )
+		{//error worked into projectile direction
+			base->random = 2.0f;
+		}
+
+		if ( !base->mass )
+		{//misnomer: speed of projectile
+			base->mass = 4000;
+		}
+
+		if ( !base->health )
+		{
+			base->health = 2000;
+		}
+
+		// search radius
+		if ( !base->radius )
+		{
+			base->radius = 32768;
+		}
+
+		// How quickly to fire
+		if ( !base->wait )
+		{
+			base->wait = 500;// + random() * 500;
+		}
+
+		if ( !base->splashDamage )
+		{
+			base->splashDamage = 200;
+		}
+
+		if ( !base->splashRadius )
+		{
+			base->splashRadius = 500;
+		}
+
+		// how much damage each shot does
+		if ( !base->damage )
+		{
+			base->damage = 10;
+		}
+
+		VectorSet( base->s.modelScale, 2.0f, 2.0f, 2.0f );
+		VectorSet( base->maxs, 128.0f, 128.0f, 120.0f );
+		VectorSet( base->mins, -128.0f, -128.0f, -120.0f );  
+
+		// Cull Radius.
+		base->s.radius = 256;
+
+		//start in "off" anim
+		TurboLaser_SetBoneAnim( base, 4, 5 );
+		
+		// Make sure it doesn't do sparks and such when saber contacts with it.
+		base->flags = FL_DMG_BY_HEAVY_WEAP_ONLY;
+		base->takedamage = qfalse; 
+		base->contents = CONTENTS_BODY|CONTENTS_PLAYERCLIP|CONTENTS_MONSTERCLIP|CONTENTS_SHOTCLIP;
+
+		base->noDamageTeam = TEAM_NEUTRAL;
+		base->team = NULL;
+	}
+	else
+	{
+		// this is a random time offset for the no-enemy-search-around-mode
+		base->count = random() * 9000;
+
+		if ( !base->health )
+		{
+			base->health = 100;
+		}
+
+		// search radius
+		if ( !base->radius )
+		{
+			base->radius = 512;
+		}
+
+		// How quickly to fire
+		if ( !base->wait )
+		{
+			base->wait = 150 + random() * 55;
+		}
+
+		if ( !base->splashDamage )
+		{
+			base->splashDamage = 10;
+		}
+
+		if ( !base->splashRadius )
+		{
+			base->splashRadius = 25;
+		}
+
+		// how much damage each shot does
+		if ( !base->damage )
+		{
+			base->damage = 5;
+		}
+
+		if ( base->spawnflags & 2 )
+		{//upside-down, invert mins and maxe
+			VectorSet( base->maxs, 10.0f, 10.0f, 30.0f );
+			VectorSet( base->mins, -10.0f, -10.0f, 0.0f );
+		}
+		else
+		{
+			VectorSet( base->maxs, 10.0f, 10.0f, 0.0f );
+			VectorSet( base->mins, -10.0f, -10.0f, -30.0f );
+		}
+
+		base->takedamage = qtrue;
+		base->contents = CONTENTS_BODY|CONTENTS_PLAYERCLIP|CONTENTS_MONSTERCLIP|CONTENTS_SHOTCLIP;
+	}
+
+	// Precache special FX and moving sounds
+	if ( (base->spawnflags&SPF_TURRETG2_TURBO) ) 
+	{
+		G_EffectIndex( "turret/turb_muzzle_flash" );
+		G_EffectIndex( "turret/turb_shot" );
+		G_EffectIndex( "turret/turb_impact" );
+		//FIXME: Turbo Laser Cannon sounds!
+		G_SoundIndex( "sound/vehicles/weapons/turbolaser/turn.wav" );
+		G_EffectIndex( "explosions/fighter_explosion2" );
+		RegisterItem( FindItemForWeapon( WP_TIE_FIGHTER ));
+	}
+	else
+	{
+		// Precache moving sounds
+		G_SoundIndex( "sound/chars/turret/startup.wav" );
+		G_SoundIndex( "sound/chars/turret/shutdown.wav" );
+		G_SoundIndex( "sound/chars/turret/ping.wav" );
+		G_SoundIndex( "sound/chars/turret/move.wav" );
+	}
+
+	base->max_health = base->health;
+	base->e_DieFunc  = dieF_turret_die;
+
+	base->material = MAT_METAL;
+
+	if ( (base->spawnflags&SPF_TURRETG2_TURBO) )
+	{
+		RegisterItem( FindItemForWeapon( WP_TURRET ));
+
+		base->svFlags |= SVF_NO_TELEPORT|SVF_SELF_ANIMATING;
+	}
+	else
+	{
+		// Register this so that we can use it for the missile effect
+		RegisterItem( FindItemForWeapon( WP_BLASTER ));
+
+		base->svFlags |= SVF_NO_TELEPORT|SVF_NONNPC_ENEMY|SVF_SELF_ANIMATING;
+	}
+
+	// But set us as a turret so that we can be identified as a turret
+	base->s.weapon = WP_TURRET;
+
+	gi.linkentity( base );
+}
+
+/*QUAKED misc_ns_turret (1 0 0) (-8 -8 -32) (8 8 29) START_OFF
+NS turret that only hangs from the ceiling, will aim and shoot at enemies
+
+  START_OFF - Starts off
+
+  radius - How far away an enemy can be for it to pick it up (default 512)
+  wait	- Time between shots (default 150 ms)
+  dmg	- How much damage each shot does (default 5)
+  health - How much damage it can take before exploding (default 100)
+  
+  splashDamage - How much damage the explosion does
+  splashRadius - The radius of the explosion
+  NOTE: If either of the above two are 0, it will not make an explosion
+  
+  targetname - Toggles it on/off
+  target - What to use when destroyed
+
+  team - team that is not targeted by and does not take damage from this turret
+	"player",
+	"enemy",	(default)
+	"neutral"
+*/
+//-----------------------------------------------------
+void SP_misc_ns_turret( gentity_t *base )
+//-----------------------------------------------------
+{
+	base->s.modelindex = G_ModelIndex( "models/map_objects/nar_shaddar/turret/turret.glm" );
+	base->s.modelindex2 = G_ModelIndex( "models/map_objects/imp_mine/turret_damage.md3" ); // FIXME!
+	base->playerModel = gi.G2API_InitGhoul2Model( base->ghoul2, "models/map_objects/nar_shaddar/turret/turret.glm", base->s.modelindex );
+	base->s.radius = 80.0f;
+
+	gi.G2API_SetBoneAngles( &base->ghoul2[base->playerModel], "Bone_body", vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_Y, POSITIVE_Z, POSITIVE_X, NULL ); 
+	base->torsoBolt = gi.G2API_AddBolt( &base->ghoul2[base->playerModel], "*flash02" );
+
+	finish_spawning_turret( base );
+}
+
+//--------------------------------------
+
+void laser_arm_fire (gentity_t *ent)
+{
+	vec3_t	start, end, fwd, rt, up;
+	trace_t	trace;
+
+	if ( ent->attackDebounceTime < level.time && ent->alt_fire )
+	{
+		// If I'm firing the laser and it's time to quit....then quit!
+		ent->alt_fire = qfalse;
+//		ent->e_ThinkFunc = thinkF_NULL;
+//		return;
+	}
+
+	ent->nextthink = level.time + FRAMETIME;
+
+	// If a fool gets in the laser path, fry 'em
+	AngleVectors( ent->currentAngles, fwd, rt, up );
+
+	VectorMA( ent->currentOrigin, 20, fwd, start );	
+	//VectorMA( start, -6, rt, start );
+	//VectorMA( start, -3, up, start );
+	VectorMA( start, 4096, fwd, end );
+	
+	gi.trace( &trace, start, NULL, NULL, end, ENTITYNUM_NONE, MASK_SHOT );//ignore
+	ent->fly_sound_debounce_time = level.time;//used as lastShotTime
+
+	// Only deal damage when in alt-fire mode
+	if ( trace.fraction < 1.0 && ent->alt_fire )
+	{
+		if ( trace.entityNum < ENTITYNUM_WORLD )
+		{
+			gentity_t *hapless_victim = &g_entities[trace.entityNum];
+			if ( hapless_victim && hapless_victim->takedamage && ent->damage )
+			{
+				G_Damage( hapless_victim, ent, ent->nextTrain->activator, fwd, trace.endpos, ent->damage, DAMAGE_IGNORE_TEAM, MOD_UNKNOWN );
+			}
+		}
+	}
+	
+	if ( ent->alt_fire )
+	{
+//		CG_FireLaser( start, trace.endpos, trace.plane.normal, ent->nextTrain->startRGBA, qfalse );
+	}
+	else
+	{
+//		CG_AimLaser( start, trace.endpos, trace.plane.normal );
+	}
+}
+
+void laser_arm_use (gentity_t *self, gentity_t *other, gentity_t *activator)
+{
+	vec3_t	newAngles;
+
+	self->activator = activator;
+	switch( self->count )
+	{
+	case 0:
+	default:
+		//Fire
+		//gi.Printf("FIRE!\n");
+//		self->lastEnemy->lastEnemy->e_ThinkFunc = thinkF_laser_arm_fire;
+//		self->lastEnemy->lastEnemy->nextthink = level.time + FRAMETIME;
+		//For 3 seconds
+		self->lastEnemy->lastEnemy->alt_fire = qtrue; // Let 'er rip!
+		self->lastEnemy->lastEnemy->attackDebounceTime = level.time + self->lastEnemy->lastEnemy->wait;
+		G_Sound(self->lastEnemy->lastEnemy, G_SoundIndex("sound/chars/l_arm/fire.wav"));
+		break;
+	case 1:
+		//Yaw left
+		//gi.Printf("LEFT...\n");
+		VectorCopy( self->lastEnemy->currentAngles, newAngles );
+		newAngles[1] += self->speed;
+		G_SetAngles( self->lastEnemy, newAngles );
+//		bolt_head_to_arm( self->lastEnemy, self->lastEnemy->lastEnemy, LARM_FOFS, LARM_ROFS, LARM_UOFS );
+		G_Sound( self->lastEnemy, G_SoundIndex( "sound/chars/l_arm/move.wav" ) );
+		break;
+	case 2:
+		//Yaw right
+		//gi.Printf("RIGHT...\n");
+		VectorCopy( self->lastEnemy->currentAngles, newAngles );
+		newAngles[1] -= self->speed;
+		G_SetAngles( self->lastEnemy, newAngles );
+//		bolt_head_to_arm( self->lastEnemy, self->lastEnemy->lastEnemy, LARM_FOFS, LARM_ROFS, LARM_UOFS );
+		G_Sound( self->lastEnemy, G_SoundIndex( "sound/chars/l_arm/move.wav" ) );
+		break;
+	case 3:
+		//pitch up
+		//gi.Printf("UP...\n");
+		//FIXME: Clamp
+		VectorCopy( self->lastEnemy->lastEnemy->currentAngles, newAngles );
+		newAngles[0] -= self->speed;
+		if ( newAngles[0] < -45 )
+		{
+			newAngles[0] = -45;
+		}
+		G_SetAngles( self->lastEnemy->lastEnemy, newAngles );
+		G_Sound( self->lastEnemy->lastEnemy, G_SoundIndex( "sound/chars/l_arm/move.wav" ) );
+		break;
+	case 4:
+		//pitch down
+		//gi.Printf("DOWN...\n");
+		//FIXME: Clamp
+		VectorCopy( self->lastEnemy->lastEnemy->currentAngles, newAngles );
+		newAngles[0] += self->speed;
+		if ( newAngles[0] > 90 )
+		{
+			newAngles[0] = 90;
+		}
+		G_SetAngles( self->lastEnemy->lastEnemy, newAngles );
+		G_Sound( self->lastEnemy->lastEnemy, G_SoundIndex( "sound/chars/l_arm/move.wav" ) );
+		break;
+	}
+}
+/*QUAKED misc_laser_arm (1 0 0) (-8 -8 -8) (8 8 8) 
+
+What it does when used depends on it's "count" (can be set by a script)
+	count:
+		0 (default) - Fire in direction facing
+		1 turn left
+		2 turn right
+		3 aim up
+		4 aim down
+
+  speed - How fast it turns (degrees per second, default 30)
+  dmg	- How much damage the laser does 10 times a second (default 5 = 50 points per second)
+  wait  - How long the beam lasts, in seconds (default is 3)
+  
+  targetname - to use it
+  target - What thing for it to be pointing at to start with
+
+  "startRGBA" - laser color, Red Green Blue Alpha, range 0 to 1 (default  1.0 0.85 0.15 0.75 = Yellow-Orange)
+*/
+void laser_arm_start (gentity_t *base)
+{
+	vec3_t	armAngles;
+	vec3_t	headAngles;
+
+	base->e_ThinkFunc = thinkF_NULL;
+	//We're the base, spawn the arm and head
+	gentity_t *arm = G_Spawn();
+	gentity_t *head = G_Spawn();
+
+	VectorCopy( base->s.angles, armAngles );
+	VectorCopy( base->s.angles, headAngles );
+	if ( base->target && base->target[0] )
+	{//Start out pointing at something
+		gentity_t *targ = G_Find( NULL, FOFS(targetname), base->target );
+		if ( !targ )
+		{//couldn't find it!
+			Com_Printf(S_COLOR_RED "ERROR : laser_arm can't find target %s!\n", base->target);
+		}
+		else
+		{//point at it
+			vec3_t	dir, angles;
+
+			VectorSubtract(targ->currentOrigin, base->s.origin, dir );
+			vectoangles( dir, angles );
+			armAngles[1] = angles[1];
+			headAngles[0] = angles[0];
+			headAngles[1] = angles[1];
+		}
+	}
+
+	//Base
+	//Base does the looking for enemies and pointing the arm and head
+	G_SetAngles( base, base->s.angles );
+	//base->s.origin[2] += 4;
+	G_SetOrigin(base, base->s.origin);
+	gi.linkentity(base);
+	//FIXME: need an actual model
+	base->s.modelindex = G_ModelIndex("models/mapobjects/dn/laser_base.md3");
+	base->s.eType = ET_GENERAL;
+	G_SpawnVector4( "startRGBA", "1.0 0.85 0.15 0.75", (float *)&base->startRGBA );
+	//anglespeed - how fast it can track the player, entered in degrees per second, so we divide by FRAMETIME/1000
+	if ( !base->speed )
+	{
+		base->speed = 3.0f;
+	}
+	else
+	{
+		base->speed *= FRAMETIME/1000.0f;
+	}
+	base->e_UseFunc = useF_laser_arm_use;
+	base->nextthink = level.time + FRAMETIME;
+
+	//Arm
+	//Does nothing, not solid, gets removed when head explodes
+	G_SetOrigin( arm, base->s.origin );
+	gi.linkentity(arm);
+	G_SetAngles( arm, armAngles );
+//	bolt_head_to_arm( arm, head, LARM_FOFS, LARM_ROFS, LARM_UOFS );
+	arm->s.modelindex = G_ModelIndex("models/mapobjects/dn/laser_arm.md3");
+
+	//Head
+	//Fires when enemy detected, animates, can be blown up
+	//Need to normalize the headAngles pitch for the clamping later
+	if ( headAngles[0] < -180 )
+	{
+		headAngles[0] += 360;
+	}
+	else if ( headAngles[0] > 180 )
+	{
+		headAngles[0] -= 360;
+	}
+	G_SetAngles( head, headAngles );
+	head->s.modelindex = G_ModelIndex("models/mapobjects/dn/laser_head.md3");
+	head->s.eType = ET_GENERAL;
+//	head->svFlags |= SVF_BROADCAST;// Broadcast to all clients
+	VectorSet( head->mins, -8, -8, -8 );
+	VectorSet( head->maxs, 8, 8, 8 );
+	head->contents = CONTENTS_BODY;
+	gi.linkentity(head);
+
+	//dmg
+	if ( !base->damage )
+	{
+		head->damage = 5;
+	}
+	else
+	{
+		head->damage = base->damage;
+	}
+	base->damage = 0;
+	//lifespan of beam
+	if ( !base->wait )
+	{
+		head->wait = 3000;
+	}
+	else
+	{
+		head->wait = base->wait * 1000;
+	}
+	base->wait = 0;
+
+	//Precache firing and explode sounds
+	G_SoundIndex("sound/weapons/explosions/cargoexplode.wav");
+	G_SoundIndex("sound/chars/l_arm/fire.wav");
+	G_SoundIndex("sound/chars/l_arm/move.wav");
+
+	//Link them up
+	base->lastEnemy = arm;
+	arm->lastEnemy = head;
+	head->owner = arm;
+	arm->nextTrain = head->nextTrain = base;
+
+	// The head should always think, since it will be either firing a damage laser or just a target laser
+	head->e_ThinkFunc = thinkF_laser_arm_fire;
+	head->nextthink = level.time + FRAMETIME;
+	head->alt_fire = qfalse; // Don't do damage until told to
+}
+
+void SP_laser_arm (gentity_t *base)
+{
+	base->e_ThinkFunc = thinkF_laser_arm_start;
+	base->nextthink = level.time + START_TIME_LINK_ENTS;
+}
+
+//--------------------------
+// PERSONAL ASSAULT SENTRY
+//--------------------------
+
+#define PAS_DAMAGE	2
+
+//-----------------------------------------------------------------------------
+void pas_use( gentity_t *self, gentity_t *other, gentity_t *activator )
+//-----------------------------------------------------------------------------
+{
+	// Toggle on and off
+	self->spawnflags = (self->spawnflags ^ 1);
+
+	if ( self->spawnflags & 1 )
+	{
+		self->nextthink = 0; // turn off and do nothing
+		self->e_ThinkFunc = thinkF_NULL;
+	}
+	else
+	{
+		self->nextthink = level.time + 50;
+		self->e_ThinkFunc = thinkF_pas_think;
+	}
+}
+
+//----------------------------------------------------------------
+void pas_fire( gentity_t *ent )
+//----------------------------------------------------------------
+{
+	vec3_t		fwd, org;
+	mdxaBone_t	boltMatrix;
+
+	// Getting the flash bolt here
+	gi.G2API_GetBoltMatrix( ent->ghoul2, ent->playerModel, 
+				ent->torsoBolt,
+				&boltMatrix, ent->currentAngles, ent->s.origin, (cg.time?cg.time:level.time),
+				NULL, ent->s.modelScale );
+
+	gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, org );
+	gi.G2API_GiveMeVectorFromMatrix( boltMatrix, POSITIVE_Y, fwd );
+
+	G_PlayEffect( "turret/muzzle_flash", org, fwd );
+
+	gentity_t	*bolt;
+
+	bolt = G_Spawn();
+	
+	bolt->classname = "turret_proj";
+	bolt->nextthink = level.time + 10000;
+	bolt->e_ThinkFunc = thinkF_G_FreeEntity;
+	bolt->s.eType = ET_MISSILE;
+	bolt->s.weapon = WP_TURRET;
+	bolt->owner = ent;
+	bolt->damage = PAS_DAMAGE;
+	bolt->dflags = DAMAGE_NO_KNOCKBACK;		// Don't push them around, or else we are constantly re-aiming
+	bolt->splashDamage = 0;
+	bolt->splashRadius = 0;
+	bolt->methodOfDeath = MOD_ENERGY;
+	bolt->clipmask = MASK_SHOT | CONTENTS_LIGHTSABER;
+
+	VectorSet( bolt->maxs, 1, 1, 1 );
+	VectorScale( bolt->maxs, -1, bolt->mins );
+
+	bolt->s.pos.trType = TR_LINEAR;
+	bolt->s.pos.trTime = level.time;		// move a bit on the very first frame
+	VectorCopy( org, bolt->s.pos.trBase );
+	VectorScale( fwd, 900, bolt->s.pos.trDelta );
+	SnapVector( bolt->s.pos.trDelta );		// save net bandwidth
+	VectorCopy( org, bolt->currentOrigin);
+}
+
+//-----------------------------------------------------
+static qboolean pas_find_enemies( gentity_t *self )
+//-----------------------------------------------------
+{
+	qboolean	found = qfalse;
+	int			count;
+	float		bestDist = self->radius * self->radius;
+	float		enemyDist;
+	vec3_t		enemyDir, org, org2;
+	gentity_t	*entity_list[MAX_GENTITIES], *target;
+
+	if ( self->aimDebounceTime > level.time ) // time since we've been shut off
+	{
+		// We were active and alert, i.e. had an enemy in the last 3 secs
+		if ( self->painDebounceTime < level.time )
+		{
+			G_Sound(self, G_SoundIndex( "sound/chars/turret/ping.wav" ));
+			self->painDebounceTime = level.time + 1000;
+		}
+	}
+
+	mdxaBone_t	boltMatrix;
+
+	// Getting the "eye" here
+	gi.G2API_GetBoltMatrix( self->ghoul2, self->playerModel, 
+				self->torsoBolt,
+				&boltMatrix, self->currentAngles, self->s.origin, (cg.time?cg.time:level.time),
+				NULL, self->s.modelScale );
+
+	gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, org2 );
+
+	count = G_RadiusList( org2, self->radius, self, qtrue, entity_list );
+
+	for ( int i = 0; i < count; i++ )
+	{
+		target = entity_list[i];
+
+		if ( !target->client )
+		{
+			continue;
+		}
+		if ( target == self || !target->takedamage || target->health <= 0 || ( target->flags & FL_NOTARGET ))
+		{
+			continue;
+		}
+		if ( target->client->playerTeam == self->noDamageTeam )
+		{ 
+			// A bot we don't want to shoot
+			continue;
+		}
+		if ( !gi.inPVS( org2, target->currentOrigin ))
+		{
+			continue;
+		}
+
+		if ( target->client )
+		{
+			VectorCopy( target->client->renderInfo.eyePoint, org );
+			org[2] -= 15;
+		}
+		else
+		{
+			VectorCopy( target->currentOrigin, org );
+		}
+
+		trace_t	tr;
+		gi.trace( &tr, org2, NULL, NULL, org, self->s.number, MASK_SHOT );
+
+		if ( !tr.allsolid && !tr.startsolid && ( tr.fraction == 1.0 || tr.entityNum == target->s.number ))
+		{
+			// Only acquire if have a clear shot, Is it in range and closer than our best?
+			VectorSubtract( target->currentOrigin, self->currentOrigin, enemyDir );
+			enemyDist = VectorLengthSquared( enemyDir );
+
+			if ( target->s.number ) // don't do this for the player
+			{
+				G_StartFlee( target, self, self->currentOrigin, AEL_DANGER, 3000, 5000 );
+			}
+
+			if ( enemyDist < bestDist )// all things equal, keep current
+			{
+				if ( self->attackDebounceTime + 2000 < level.time )
+				{
+					// We haven't fired or acquired an enemy in the last 2 seconds-start-up sound
+					G_Sound( self, G_SoundIndex( "sound/chars/turret/startup.wav" ));
+
+					// Wind up turrets for a bit
+					self->attackDebounceTime = level.time + 900 + random() * 200;
+				}
+
+				G_SetEnemy( self, target );
+				bestDist = enemyDist;
+				found = qtrue;
+			}
+		}
+	}
+
+	if ( found && VALIDSTRING( self->target2 ))
+	{
+		G_UseTargets2( self, self, self->target2 );
+	}
+
+	return found;
+}
+
+//---------------------------------
+void pas_adjust_enemy( gentity_t *ent )
+//---------------------------------
+{
+	qboolean keep = qtrue;
+
+	if ( ent->enemy->health <= 0 )
+	{
+		keep = qfalse;
+	}
+	else// if ( random() > 0.5f )
+	{
+		// do a trace every now and then.
+		mdxaBone_t	boltMatrix;
+		vec3_t		org, org2;
+
+		// Getting the "eye" here
+		gi.G2API_GetBoltMatrix( ent->ghoul2, ent->playerModel, 
+					ent->torsoBolt,
+					&boltMatrix, ent->currentAngles, ent->s.origin, (cg.time?cg.time:level.time),
+					NULL, ent->s.modelScale );
+
+		gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, org2 );
+
+		if ( ent->enemy->client )
+		{
+			VectorCopy( ent->enemy->client->renderInfo.eyePoint, org );
+			org[2] -= 15;
+		}
+		else
+		{
+			VectorCopy( ent->enemy->currentOrigin, org );
+		}
+
+		trace_t	tr;
+		gi.trace( &tr, org2, NULL, NULL, org, ent->s.number, MASK_SHOT );
+
+		if ( tr.allsolid || tr.startsolid || tr.entityNum != ent->enemy->s.number )
+		{
+			// trace failed
+			keep = qfalse;
+		}
+	}
+
+	if ( keep )
+	{
+		ent->bounceCount = level.time + 500 + random() * 150;
+	}
+	else if ( ent->bounceCount < level.time ) // don't ping pong on and off
+	{
+		ent->enemy = NULL;
+		// shut-down sound
+		G_Sound( ent, G_SoundIndex( "sound/chars/turret/shutdown.wav" ));
+	
+		// make turret play ping sound for 5 seconds
+		ent->aimDebounceTime = level.time + 5000;
+	}
+}
+
+//---------------------------------
+void pas_think( gentity_t *ent )
+//---------------------------------
+{
+	if ( !ent->damage )
+	{
+		// let us do our animation, then we are good to go in terms of pounding the crap out of enemies.
+		ent->damage = 1;
+		gi.G2API_SetBoneAnimIndex( &ent->ghoul2[ent->playerModel], ent->rootBone, 0, 11, BONE_ANIM_OVERRIDE_FREEZE, 0.8f, cg.time );
+		ent->nextthink = level.time + 1200;
+		return;
+	}
+
+	if ( !ent->count )
+	{
+		// turrets that have no ammo may as well do nothing
+		return;
+	}
+
+	ent->nextthink = level.time + FRAMETIME;
+
+	if ( ent->enemy )
+	{
+		// make sure that the enemy is still valid
+		pas_adjust_enemy( ent );
+	}
+
+	if ( !ent->enemy )
+	{
+		pas_find_enemies( ent );
+	}
+
+	qboolean	moved = qfalse;
+	float		diffYaw = 0.0f, diffPitch = 0.0f;
+	vec3_t		enemyDir, org;
+	vec3_t		frontAngles, backAngles;
+	vec3_t		desiredAngles;
+
+	ent->speed = AngleNormalize360( ent->speed );
+	ent->random = AngleNormalize360( ent->random );
+
+	if ( ent->enemy )
+	{
+		// ...then we'll calculate what new aim adjustments we should attempt to make this frame
+		// Aim at enemy
+		if ( ent->enemy->client )
+		{
+			VectorCopy( ent->enemy->client->renderInfo.eyePoint, org );
+			org[2] -= 40;
+		}
+		else
+		{
+			VectorCopy( ent->enemy->currentOrigin, org );
+		}
+
+		VectorSubtract( org, ent->currentOrigin, enemyDir );
+		vectoangles( enemyDir, desiredAngles );
+
+		diffYaw = AngleSubtract( ent->speed, desiredAngles[YAW] );
+		diffPitch = AngleSubtract( ent->random, desiredAngles[PITCH] );
+	}
+	else
+	{
+		// no enemy, so make us slowly sweep back and forth as if searching for a new one
+		diffYaw = sin( level.time * 0.0001f + ent->count ) * 2.0f;
+	}
+
+	if ( fabs(diffYaw) > 0.25f )
+	{
+		moved = qtrue;
+
+		if ( fabs(diffYaw) > 10.0f )
+		{
+			// cap max speed
+			ent->speed += (diffYaw > 0.0f) ? -10.0f : 10.0f;
+		}
+		else
+		{
+			// small enough
+			ent->speed -= diffYaw;
+		}
+	}
+
+
+	if ( fabs(diffPitch) > 0.25f )
+	{
+		moved = qtrue;
+
+		if ( fabs(diffPitch) > 4.0f )
+		{
+			// cap max speed
+			ent->random += (diffPitch > 0.0f) ? -4.0f : 4.0f;
+		}
+		else
+		{
+			// small enough
+			ent->random -= diffPitch;
+		}
+	}
+
+	// the bone axes are messed up, so hence some dumbness here
+	VectorSet( frontAngles, -ent->random, 0.0f, 0.0f );
+	VectorSet( backAngles, 0.0f, 0.0f, ent->speed - ent->s.angles[YAW] );
+
+	gi.G2API_SetBoneAngles( &ent->ghoul2[ent->playerModel], "bone_barrel", frontAngles, 
+						BONE_ANGLES_POSTMULT, POSITIVE_Y, POSITIVE_Z, NEGATIVE_X, NULL,100,cg.time); 
+	gi.G2API_SetBoneAngles( &ent->ghoul2[ent->playerModel], "bone_gback", frontAngles, 
+						BONE_ANGLES_POSTMULT, POSITIVE_Y, POSITIVE_Z, NEGATIVE_X, NULL,100,cg.time); 
+	gi.G2API_SetBoneAngles( &ent->ghoul2[ent->playerModel], "bone_hinge", backAngles, 
+						BONE_ANGLES_POSTMULT, POSITIVE_Y, POSITIVE_Z, POSITIVE_X, NULL,100,cg.time); 
+
+	if ( moved )
+	{
+	//ent->s.loopSound = G_SoundIndex( "sound/chars/turret/move.wav" );
+	}
+	else
+	{
+		ent->s.loopSound = 0;
+	}
+
+	if ( ent->enemy && ent->attackDebounceTime < level.time && random() > 0.3f )
+	{
+		ent->count--;
+
+		if ( ent->count )
+		{
+			pas_fire( ent );
+			ent->fly_sound_debounce_time = level.time;//used as lastShotTime
+		}
+		else
+		{
+			ent->nextthink = 0;
+			G_Sound( ent, G_SoundIndex( "sound/chars/turret/shutdown.wav" ));
+		}
+	}
+}
+
+/*QUAKED misc_sentry_turret (1 0 0) (-16 -16 0) (16 16 24) START_OFF RESERVED
+personal assault sentry, like the ones you can carry in your inventory
+
+  RESERVED - do no use this flag for anything, does nothing..etc.
+
+  radius - How far away an enemy can be for it to pick it up (default 512)
+  count - number of shots before thing deactivates. -1 = infinite, default 150
+  health - How much damage it can take before exploding (default 50)
+  
+  splashDamage - How much damage the explosion does
+  splashRadius - The radius of the explosion
+  NOTE: If either of the above two are 0, it will not make an explosion
+  
+  target - What to use when destroyed
+  target2 - What to use when it decides to fire at an enemy
+
+  team - team that does not take damage from this item
+	"player",
+	"enemy",
+	"neutral"
+
+*/
+
+//---------------------------------
+void SP_PAS( gentity_t *base )
+//---------------------------------
+{
+	base->classname = "PAS";
+	G_SetOrigin( base, base->s.origin );
+	G_SetAngles( base, base->s.angles );
+
+	base->speed = base->s.angles[YAW];
+
+	base->s.modelindex = G_ModelIndex( "models/items/psgun.glm" );
+	base->playerModel = gi.G2API_InitGhoul2Model( base->ghoul2, "models/items/psgun.glm", base->s.modelindex );
+	base->s.radius = 30.0f;
+	VectorSet( base->s.modelScale, 1.0f, 1.0f, 1.0f );
+
+	base->rootBone = gi.G2API_GetBoneIndex( &base->ghoul2[base->playerModel], "model_root", qtrue );
+	gi.G2API_SetBoneAngles( &base->ghoul2[base->playerModel], "bone_hinge", vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_Y, POSITIVE_Z, POSITIVE_X, NULL ); 
+	gi.G2API_SetBoneAngles( &base->ghoul2[base->playerModel], "bone_gback", vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_Y, POSITIVE_Z, POSITIVE_X, NULL ); 
+	gi.G2API_SetBoneAngles( &base->ghoul2[base->playerModel], "bone_barrel", vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_Y, POSITIVE_Z, POSITIVE_X, NULL ); 
+
+	base->torsoBolt = gi.G2API_AddBolt( &base->ghoul2[base->playerModel], "*flash02" );
+
+	base->s.eType = ET_GENERAL;
+
+	if ( !base->radius )
+	{
+		base->radius = 512;
+	}
+
+	if ( base->count == 0 )
+	{
+		// give ammo
+		base->count = 150;
+	}
+
+	base->e_UseFunc = useF_pas_use;
+
+	base->damage = 0; // start animation flag
+
+	base->contents = CONTENTS_SHOTCLIP|CONTENTS_CORPSE;//for certain traces
+	VectorSet( base->mins, -8, -8, 0 );
+	VectorSet( base->maxs, 8, 8, 18 );
+
+	if ( !(base->spawnflags & 1 )) // START_OFF
+	{
+		base->nextthink = level.time + 1000; // we aren't starting off, so start working right away
+		base->e_ThinkFunc = thinkF_pas_think;
+	}
+
+	// Set up our explosion effect for the ExplodeDeath code....
+	base->fxID = G_EffectIndex( "turret/explode" );
+	G_EffectIndex( "sparks/spark_exp_nosnd" );
+
+	if ( !base->health )
+	{
+		base->health = 50;
+	}
+	base->max_health = base->health;
+
+	base->takedamage = qtrue;
+	base->e_PainFunc = painF_TurretPain;
+	base->e_DieFunc  = dieF_turret_die;
+
+	// hack this flag on so that when it calls the turret die code, it will orient the effect up
+	// HACK
+	//--------------------------------------
+	base->spawnflags |= 2;
+
+	// Use this for our missile effect
+	RegisterItem( FindItemForWeapon( WP_TURRET ));
+	base->s.weapon = WP_TURRET;
+
+	base->svFlags |= SVF_NONNPC_ENEMY;
+
+	base->noDamageTeam = TEAM_NEUTRAL;
+	if ( base->team && base->team[0] )
+	{
+		base->noDamageTeam = (team_t)GetIDForString( TeamTable, base->team );
+		base->team = NULL;
+	}
+
+	gi.linkentity( base );
+}
+
+//------------------------------------------------------------------------
+qboolean place_portable_assault_sentry( gentity_t *self, vec3_t origin, vec3_t angs )
+//------------------------------------------------------------------------
+{
+	vec3_t		fwd, pos;
+	vec3_t		mins, maxs;
+	trace_t		tr;
+	gentity_t	*pas;
+
+	VectorSet( maxs, 9, 9, 0 );
+	VectorScale( maxs, -1, mins );
+
+	angs[PITCH] = 0;
+	angs[ROLL] = 0;
+	AngleVectors( angs, fwd, NULL, NULL );
+
+	// and move a consistent distance away from us so we don't have the dumb thing spawning inside of us.
+	VectorMA( origin, 30, fwd, pos );
+	gi.trace( &tr, origin, NULL, NULL, pos, self->s.number, MASK_SHOT );
+
+	// find the ground
+	tr.endpos[2] += 20;
+	VectorCopy( tr.endpos, pos );
+	pos[2] -= 64;
+
+	gi.trace( &tr, tr.endpos, mins, maxs, pos, self->s.number, MASK_SHOT );
+
+	// check for a decent surface, meaning mostly flat...should probably also check surface parms so we don't set us down on lava or something.
+	if ( !tr.startsolid && !tr.allsolid && tr.fraction < 1.0f && tr.plane.normal[2] > 0.9f && tr.entityNum >= ENTITYNUM_WORLD )
+	{
+		// Then spawn us if it seems cool.
+		pas = G_Spawn();
+
+		if ( pas )
+		{
+			VectorCopy( tr.endpos, pas->s.origin );
+			SP_PAS( pas );
+
+			pas->contents |= CONTENTS_PLAYERCLIP; // player placed ones can block players but not npcs
+
+			pas->e_UseFunc = useF_NULL; // placeable ones never need to be used
+	
+			// we don't hurt us or anyone who belongs to the same team as us.
+			if ( self->client )
+			{
+				pas->noDamageTeam = self->client->playerTeam;
+			}
+
+			G_Sound( self, G_SoundIndex( "sound/player/use_sentry" ));
+			pas->activator = self;
+			return qtrue;
+		}
+	}
+	return qfalse;
+}
+
+
+//-------------
+// ION CANNON
+//-------------
+
+
+//----------------------------------------
+void ion_cannon_think( gentity_t *self )
+//----------------------------------------
+{
+	if ( self->spawnflags & 2 )
+	{
+		if ( self->count )
+		{
+			// still have bursts left, so keep going
+			self->count--;
+		}
+		else
+		{
+			// done with burst, so wait delay amount, plus a random bit
+			self->nextthink = level.time + ( self->delay + crandom() * self->random );
+			self->count = Q_irand(0,5); // 0-5 bursts
+
+			// Not firing this time
+			return;
+		}
+	}
+
+	if ( self->fxID )
+	{
+		vec3_t		fwd, org;
+		mdxaBone_t	boltMatrix;
+
+		// Getting the flash bolt here
+		gi.G2API_GetBoltMatrix( self->ghoul2, self->playerModel, 
+					self->torsoBolt,
+					&boltMatrix, self->s.angles, self->s.origin, (cg.time?cg.time:level.time),
+					NULL, self->s.modelScale );
+
+		gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, org );
+		gi.G2API_GiveMeVectorFromMatrix( boltMatrix, POSITIVE_Y, fwd );
+
+		G_PlayEffect( self->fxID, org, fwd );
+	}
+
+	if ( self->target2 )
+	{
+		// If we have a target2 fire it off in sync with our gun firing
+		G_UseTargets2( self, self, self->target2 );
+	}
+
+	gi.G2API_SetBoneAnimIndex( &self->ghoul2[self->playerModel], self->rootBone, 0, 8, BONE_ANIM_OVERRIDE_FREEZE, 0.6f, cg.time );
+	self->nextthink = level.time + self->wait + crandom() * self->random;
+}
+
+//----------------------------------------------------------------------------------------------
+void ion_cannon_die( gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int mod,int dFlags,int hitLoc )
+//----------------------------------------------------------------------------------------------
+{
+	vec3_t org;
+
+	// dead, so nuke the ghoul model and put in the damage md3 version
+	if ( self->playerModel >= 0 )
+	{
+		gi.G2API_RemoveGhoul2Model( self->ghoul2, self->playerModel );
+	}
+	self->s.modelindex = self->s.modelindex2;
+	self->s.modelindex2 = 0;
+
+		// Turn off the thinking of the base & use it's targets
+	self->e_ThinkFunc = thinkF_NULL;
+	self->e_UseFunc = useF_NULL;
+
+	if ( self->target )
+	{
+		G_UseTargets( self, attacker );
+	}
+
+	// clear my data
+	self->e_DieFunc  = dieF_NULL;
+	self->takedamage = qfalse;
+	self->health = 0;
+
+	self->takedamage = qfalse;//stop chain reaction runaway loops
+	self->s.loopSound = 0;
+
+	// not solid anymore
+	self->contents = 0;
+
+	VectorCopy( self->currentOrigin, self->s.pos.trBase );
+
+	VectorCopy( self->currentOrigin, org );
+	org[2] += 20;
+	G_PlayEffect( "env/ion_cannon_explosion", org );
+	
+	if ( self->splashDamage > 0 && self->splashRadius > 0 )
+	{
+		G_RadiusDamage( self->currentOrigin, attacker, self->splashDamage, self->splashRadius, 
+				attacker, MOD_UNKNOWN );
+	}
+
+	gi.linkentity( self );
+}
+
+//----------------------------------------------------------------------------
+void ion_cannon_use( gentity_t *self, gentity_t *other, gentity_t *activator )
+//----------------------------------------------------------------------------
+{
+	// toggle
+	if ( self->e_ThinkFunc == thinkF_NULL )
+	{
+		// start thinking now
+		self->e_ThinkFunc = thinkF_ion_cannon_think;
+		self->nextthink = level.time + FRAMETIME; // fires right on being used
+	}
+	else
+	{
+		self->e_ThinkFunc = thinkF_NULL;
+	}
+}
+
+/*QUAKED misc_ion_cannon (1 0 0) (-280 -280 0) (280 280 640) START_OFF BURSTS SHIELDED
+Huge ion cannon, like the ones at the rebel base on Hoth.
+
+  START_OFF - Starts off
+  BURSTS - adds more variation, shots come out in bursts
+  SHIELDED - cannon is shielded, any kind of shot bounces off.
+
+  wait	- How fast it shoots (default 1500 ms between shots, can't be less than 500 ms)
+  random - milliseconds wait variation (default 400 ms...up to plus or minus .4 seconds)
+  delay	- Number of milliseconds between bursts (default 6000 ms, can't be less than 1000 ms, only works when BURSTS checked)
+
+  health - default 2000
+  splashDamage - how much damage to do when it dies, must be greater than 0 to actually work
+  splashRadius - damage radius, must be greater than 0 to actually work
+
+  targetname - Toggles it on/off
+  target - What to use when destroyed
+  target2 - What to use when it fires a shot.
+*/
+//-----------------------------------------------------
+void SP_misc_ion_cannon( gentity_t *base )
+//-----------------------------------------------------
+{
+	G_SetAngles( base, base->s.angles );
+
+	G_SetOrigin(base, base->s.origin);
+
+	base->s.modelindex = G_ModelIndex( "models/map_objects/imp_mine/ion_cannon.glm" );
+	base->playerModel = gi.G2API_InitGhoul2Model( base->ghoul2, "models/map_objects/imp_mine/ion_cannon.glm", base->s.modelindex );
+	base->s.radius = 320.0f;
+	VectorSet( base->s.modelScale, 2.0f, 2.0f, 2.0f );
+
+	base->rootBone = gi.G2API_GetBoneIndex( &base->ghoul2[base->playerModel], "model_root", qtrue );
+	base->torsoBolt = gi.G2API_AddBolt( &base->ghoul2[base->playerModel], "*flash02" );
+
+	// register damage model
+	base->s.modelindex2 = G_ModelIndex( "models/map_objects/imp_mine/ion_cannon_damage.md3" );
+
+	base->e_UseFunc = useF_ion_cannon_use;
+
+	// How quickly to fire
+	if ( base->wait == 0.0f )
+	{
+		base->wait = 1500.0f;
+	}
+	else if ( base->wait < 500.0f )
+	{
+		base->wait = 500.0f;
+	}
+
+	if ( base->random == 0.0f )
+	{
+		base->random = 400.0f;
+	}
+
+	if ( base->delay == 0 )
+	{
+		base->delay = 6000;
+	}
+	else if ( base->delay < 1000 )
+	{
+		base->delay = 1000;
+	}
+
+	// we only take damage from a heavy weapon class missile
+	base->flags |= FL_DMG_BY_HEAVY_WEAP_ONLY;
+
+	if ( base->spawnflags & 4 )//shielded
+	{
+		base->flags |= FL_SHIELDED; //technically, this would only take damage from a lightsaber, but the other flag just above would cancel that out too.
+	}
+
+	G_SpawnInt( "health", "2000", &base->health );
+	base->e_DieFunc = dieF_ion_cannon_die;
+	base->takedamage = qtrue;
+
+	// Start Off?
+	if ( base->spawnflags & 1 )
+	{
+		base->e_ThinkFunc = thinkF_NULL;
+	}
+	else
+	{
+		// start thinking now, otherwise, we'll wait until we are used
+		base->e_ThinkFunc = thinkF_ion_cannon_think;
+		base->nextthink = level.time + base->wait + crandom() * base->random;
+	}
+
+	// Bursts?
+	if ( base->spawnflags & 2 )
+	{
+		base->count = Q_irand(0,5); // 0-5 bursts
+	}
+
+	// precache
+	base->fxID = G_EffectIndex( "env/ion_cannon" );
+
+	// Set up our explosion effect for the ExplodeDeath code....
+	G_EffectIndex( "env/ion_cannon_explosion" );
+
+	base->contents = CONTENTS_BODY;
+
+	VectorSet( base->mins, -141.0f, -148.0f, 0.0f );
+	VectorSet( base->maxs, 142.0f, 135.0f, 245.0f );
+
+	gi.linkentity( base );
+}
+
+
+//-----------------------------------------------------
+void spotlight_use( gentity_t *self, gentity_t *other, gentity_t *activator )
+{
+	if ( self->e_ThinkFunc == thinkF_NULL )
+	{
+		// start thinking now, otherwise, we'll wait until we are used
+		self->e_ThinkFunc = thinkF_spotlight_think;
+		self->nextthink = level.time + FRAMETIME;
+	}
+	else
+	{
+		self->e_ThinkFunc = thinkF_NULL;
+		self->s.eFlags &= ~EF_ALT_FIRING;
+	}
+}
+
+//-----------------------------------------------------
+void spotlight_think( gentity_t *ent )
+{
+	vec3_t		dir, end;
+	trace_t		tr;
+
+	// dumb hack flag so that we can draw an interpolated light cone cgame side.
+	ent->s.eFlags |= EF_ALT_FIRING;
+
+	VectorSubtract( ent->enemy->currentOrigin, ent->currentOrigin, dir );
+	VectorNormalize( dir );
+	vectoangles( dir, ent->s.apos.trBase );
+	ent->s.apos.trType = TR_INTERPOLATE;
+
+	VectorMA( ent->currentOrigin, 2048, dir, end ); // just pick some max trace distance
+	gi.trace( &tr, ent->currentOrigin, vec3_origin, vec3_origin, end, ent->s.number, CONTENTS_SOLID );
+
+	ent->radius = tr.fraction * 2048.0f;
+
+	if ( tr.fraction < 1 )
+	{
+		if ( DistanceSquared( tr.endpos, g_entities[0].currentOrigin ) < 140 * 140 )
+		{
+			// hit player--use target2
+			G_UseTargets2( ent, &g_entities[0], ent->target2 );
+
+#ifndef FINAL_BUILD
+			if ( g_developer->integer == PRINT_DEVELOPER )
+			{
+				Com_Printf( S_COLOR_MAGENTA "Spotlight hit player at time: %d!!!\n", level.time );
+			}
+#endif
+		}
+	}
+
+	ent->nextthink = level.time + 50;
+}
+
+//-----------------------------------------------------
+void spotlight_link( gentity_t *ent )
+{
+	gentity_t *target = 0;
+
+	target = G_Find( target, FOFS(targetname), ent->target );
+
+	if ( !target )
+	{
+		Com_Printf( S_COLOR_RED "ERROR: spotlight_link: bogus target %s\n", ent->target );
+		G_FreeEntity( ent );
+		return;
+	}
+
+	ent->enemy = target;
+
+	// Start Off?
+	if ( ent->spawnflags & 1 )
+	{
+		ent->e_ThinkFunc = thinkF_NULL;
+		ent->s.eFlags &= ~EF_ALT_FIRING;
+	}
+	else
+	{
+		// start thinking now, otherwise, we'll wait until we are used
+		ent->e_ThinkFunc = thinkF_spotlight_think;
+		ent->nextthink = level.time + FRAMETIME;
+	}
+}
+
+/*QUAKED misc_spotlight (1 0 0) (-10 -10 0) (10 10 10) START_OFF
+model="models/map_objects/imp_mine/spotlight.md3"
+Search spotlight that must be targeted at a func_train or other entity
+Uses its target2 when it detects the player
+
+  START_OFF - Starts off
+
+  targetname - Toggles it on/off
+  target - What to point at
+  target2 - What to use when detects player
+*/
+
+//-----------------------------------------------------
+void SP_misc_spotlight( gentity_t *base )
+//-----------------------------------------------------
+{
+	if ( !base->target )
+	{
+		Com_Printf( S_COLOR_RED "ERROR: misc_spotlight must have a target\n" );
+		G_FreeEntity( base );
+		return;
+	}
+	
+	G_SetAngles( base, base->s.angles );
+	G_SetOrigin( base, base->s.origin );
+
+	base->s.modelindex = G_ModelIndex( "models/map_objects/imp_mine/spotlight.md3" );
+
+	G_SpawnInt( "health", "300", &base->health );
+
+	// Set up our lightcone effect, though we will have it draw cgame side so it looks better
+	G_EffectIndex( "env/light_cone" );
+
+	base->contents = CONTENTS_BODY;
+	base->e_UseFunc = useF_spotlight_use;
+
+	// the thing we need to target may not have spawned yet, so try back in a bit
+	base->e_ThinkFunc = thinkF_spotlight_link;
+	base->nextthink = level.time + 100;
+
+	gi.linkentity( base );
+}
+
+/*QUAKED misc_panel_turret (0 0 1) (-8 -8 -12) (8 8 16) HEALTH
+Creates a turret that, when the player uses a panel, takes control of this turret and adopts the turret view
+
+  HEALTH - gun turret has health and displays a hud with its current health
+
+"target" - thing to use when player enters the turret view
+"target2" - thing to use when player leaves the turret view
+"target3" - thing to use when it dies.
+
+  radius - the max yaw range in degrees, (default 90) which means you can move 90 degrees on either side of the start angles.
+  random - the max pitch range in degrees, (default 60) which means you can move 60 degrees above or below the start angles.
+  delay - time between shots, in milliseconds (default 200).
+  damage - amount of damage shots do, (default 50).
+  speed - missile speed, (default 3000)
+
+  heatlh - how much heatlh the thing has, (default 200) only works if HEALTH is checked, otherwise it can't be destroyed. 
+*/
+
+extern gentity_t	*player;
+extern qboolean		G_ClearViewEntity( gentity_t *ent );
+extern void			G_SetViewEntity( gentity_t *self, gentity_t *viewEntity );
+extern gentity_t	*CreateMissile( vec3_t org, vec3_t dir, float vel, int life, gentity_t *owner, qboolean altFire = qfalse );
+
+void panel_turret_shoot( gentity_t *self, vec3_t org, vec3_t dir)
+{
+	gentity_t *missile = CreateMissile( org, dir, self->speed, 10000, self );
+
+	missile->classname = "b_proj";
+	missile->s.weapon = WP_TIE_FIGHTER;
+
+	VectorSet( missile->maxs, 9, 9, 9 ); 
+	VectorScale( missile->maxs, -1, missile->mins );
+
+	missile->bounceCount = 0;
+
+	missile->damage = self->damage;
+	missile->dflags = DAMAGE_DEATH_KNOCKBACK;
+	missile->methodOfDeath = MOD_ENERGY;
+	missile->clipmask = MASK_SHOT | CONTENTS_LIGHTSABER;
+
+	G_SoundOnEnt( self, CHAN_AUTO, "sound/movers/objects/ladygun_fire" );
+
+	VectorMA( org, 32, dir, org );
+	org[2] -= 4;
+	G_PlayEffect( "ships/imp_blastermuzzleflash", org, dir );
+}
+
+//-----------------------------------------
+void misc_panel_turret_die( gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int mod, int dFlags, int hitLoc )
+{
+	if ( self->target3 )
+	{
+		G_UseTargets2( self, player, self->target3 );
+	}
+
+	// FIXME: might need some other kind of logic or functionality in here??
+	G_UseTargets2( self, player, self->target2 );
+	G_ClearViewEntity( player );
+	cg.overrides.active &= ~CG_OVERRIDE_FOV;
+	cg.overrides.fov = 0;
+}
+
+//-----------------------------------------
+void panel_turret_think( gentity_t *self )
+{
+	// Ensure that I am the viewEntity
+	if ( player && player->client && player->client->ps.viewEntity == self->s.number )
+	{
+		usercmd_t *ucmd = &player->client->usercmd;
+
+		// We are the viewEnt so update our new viewangles based on the sum of our start angles and the ucmd angles
+		for ( int i = 0; i < 3; i++ )
+		{
+			// convert our base angle to a short, add with the usercmd.angle ( a short ), then switch use back to a real angle
+			self->s.apos.trBase[i] = AngleNormalize180( SHORT2ANGLE( ucmd->angles[i] + ANGLE2SHORT( self->s.angles[i] ) + self->pos3[i] ));
+		}
+
+		// Only clamp if we have a PITCH clamp
+		if ( self->random != 0.0f )
+		// Angle clamping -- PITCH
+		{
+			if ( self->s.apos.trBase[PITCH] > self->random ) // random is PITCH
+			{
+				self->pos3[PITCH] += ANGLE2SHORT( AngleNormalize180( self->random - self->s.apos.trBase[PITCH]));
+				self->s.apos.trBase[PITCH] = self->random;
+			}
+			else if ( self->s.apos.trBase[PITCH] < -self->random )
+			{
+				self->pos3[PITCH] -= ANGLE2SHORT( AngleNormalize180( self->random + self->s.apos.trBase[PITCH]));
+				self->s.apos.trBase[PITCH] = -self->random;
+			}
+		}
+
+		// Only clamp if we have a YAW clamp
+		if ( self->radius != 0.0f )
+		{
+			float yawDif = AngleSubtract( self->s.apos.trBase[YAW], self->s.angles[YAW] );
+
+			// Angle clamping -- YAW
+			if (  yawDif > self->radius ) // radius is YAW
+			{
+				self->pos3[YAW] += ANGLE2SHORT( self->radius - yawDif );
+				self->s.apos.trBase[YAW] = AngleNormalize180( self->s.angles[YAW] + self->radius );
+			}
+			else if ( yawDif < -self->radius ) // radius is YAW
+			{
+				self->pos3[YAW] -= ANGLE2SHORT( self->radius + yawDif );
+				self->s.apos.trBase[YAW] = AngleNormalize180( self->s.angles[YAW] - self->radius );
+			}
+		}
+
+		// Let cgame interpolation smooth out the angle changes
+		self->s.apos.trType = TR_INTERPOLATE;
+		self->s.pos.trType	= TR_INTERPOLATE; // not really moving, but this fixes an interpolation bug in cg_ents.
+
+		// Check for backing out of turret
+		if ( ( self->useDebounceTime < level.time ) && ((ucmd->buttons & BUTTON_USE) || ucmd->forwardmove || ucmd->rightmove || ucmd->upmove) )
+		{
+			self->useDebounceTime = level.time + 200;
+
+			G_UseTargets2( self, player, self->target2 );
+			G_ClearViewEntity( player );
+			G_Sound( player, self->soundPos2 );
+
+			cg.overrides.active &= ~CG_OVERRIDE_FOV;
+			cg.overrides.fov = 0; 
+			if ( ucmd->upmove > 0 )
+			{//stop player from doing anything for a half second after
+				player->aimDebounceTime = level.time + 500;
+			}
+
+			// can be drawn
+//			self->s.eFlags &= ~EF_NODRAW;
+		}
+		else
+		{
+			// don't draw me when being looked through
+//			self->s.eFlags |= EF_NODRAW;
+//			self->s.modelindex = 0;
+
+			// we only need to think when we are being used
+			self->nextthink = level.time + 50;
+
+			cg.overrides.active |= CG_OVERRIDE_FOV;
+			cg.overrides.fov = 90;
+		}
+
+		if ( ucmd->buttons & BUTTON_ATTACK || ucmd->buttons & BUTTON_ALT_ATTACK )
+		{
+			if ( self->attackDebounceTime < level.time )
+			{
+				vec3_t dir, pt;
+
+				AngleVectors( self->s.apos.trBase, dir, NULL, NULL );
+
+				VectorCopy( self->currentOrigin, pt );
+				pt[2] -= 4;
+				panel_turret_shoot( self, pt, dir );
+
+				self->attackDebounceTime = level.time + self->delay;
+			}
+		}
+	}
+}
+
+//-----------------------------------------
+void panel_turret_use( gentity_t *self, gentity_t *other, gentity_t *activator )
+{
+	// really only usable by the player
+	if ( !activator || !activator->client || activator->s.number )
+	{
+		return;
+	}
+
+	if ( self->useDebounceTime > level.time )
+	{
+		// can't use it again right away.
+		return;
+	}
+
+	if ( self->spawnflags & 1 ) // health...presumably the lady luck gun
+	{
+		G_Sound( self, G_SoundIndex( "sound/movers/objects/ladygun_on" ));
+	}
+
+	self->useDebounceTime = level.time + 200;
+
+	// Compensating for the difference between the players view at the time of use and the start angles that the gun object has
+	self->pos3[PITCH]	= -activator->client->usercmd.angles[PITCH];
+	self->pos3[YAW]		= -activator->client->usercmd.angles[YAW];
+	self->pos3[ROLL]	= 0;
+
+	// set me as view entity
+	G_UseTargets2( self, activator, self->target );
+	G_SetViewEntity( activator, self );
+
+	G_Sound( activator, self->soundPos1 );
+
+	self->e_ThinkFunc = thinkF_panel_turret_think;
+//	panel_turret_think( self );
+	self->nextthink = level.time + 150;
+}
+
+//-----------------------------------------
+void SP_misc_panel_turret( gentity_t *self ) 
+{
+	G_SpawnFloat( "radius", "90", &self->radius );	// yaw
+	G_SpawnFloat( "random", "60", &self->random );	// pitch
+	G_SpawnFloat( "speed" , "3000", &self->speed );
+	G_SpawnInt( "delay", "200", &self->delay );
+	G_SpawnInt( "damage", "50", &self->damage );
+
+	VectorSet( self->pos3, 0.0f, 0.0f, 0.0f );
+
+	if ( self->spawnflags & 1 ) // heatlh
+	{
+		self->takedamage = qtrue;
+		self->contents = CONTENTS_SHOTCLIP;
+		G_SpawnInt( "health", "200", &self->health );
+
+		self->max_health = self->health;
+		self->dflags |= DAMAGE_CUSTOM_HUD; // dumb, but we draw a custom hud
+		G_SoundIndex( "sound/movers/objects/ladygun_on" );
+	}
+
+	self->s.modelindex = G_ModelIndex( "models/map_objects/imp_mine/ladyluck_gun.md3" );
+
+	self->soundPos1 = G_SoundIndex( "sound/movers/camera_on.mp3" );
+	self->soundPos2 = G_SoundIndex( "sound/movers/camera_off.mp3" );
+
+	G_SoundIndex( "sound/movers/objects/ladygun_fire" );
+	G_EffectIndex("ships/imp_blastermuzzleflash");
+
+	G_SetOrigin( self, self->s.origin );
+	G_SetAngles( self, self->s.angles );
+
+	VectorSet( self->mins, -8, -8, -12 );
+	VectorSet( self->maxs, 8, 8, 0 );
+	self->contents = CONTENTS_SOLID;
+
+	self->s.weapon = WP_TURRET;
+
+	RegisterItem( FindItemForWeapon( WP_EMPLACED_GUN ));
+	gi.linkentity( self );
+
+	self->e_UseFunc = useF_panel_turret_use;
+	self->e_DieFunc = dieF_misc_panel_turret_die;
+}
+
+#undef name
+#undef name2
+#undef name3
\ No newline at end of file
diff --git a/code/game/g_usable.cpp b/code/game/g_usable.cpp
new file mode 100644
index 0000000..dce243f
--- /dev/null
+++ b/code/game/g_usable.cpp
@@ -0,0 +1,251 @@
+// leave this line at the top for all g_xxxx.cpp files...
+#include "g_headers.h"
+
+
+#include "g_local.h"
+#include "g_functions.h"
+
+extern void	InitMover( gentity_t *ent );
+
+extern gentity_t	*G_TestEntityPosition( gentity_t *ent );
+void func_wait_return_solid( gentity_t *self )
+{
+	//once a frame, see if it's clear.
+	self->clipmask = CONTENTS_BODY;//|CONTENTS_MONSTERCLIP|CONTENTS_BOTCLIP;
+	if ( !(self->spawnflags&16) || G_TestEntityPosition( self ) == NULL )
+	{
+		gi.SetBrushModel( self, self->model );
+		VectorCopy( self->currentOrigin, self->pos1 );
+		InitMover( self );
+		/*
+		VectorCopy( self->s.origin, self->s.pos.trBase );
+		VectorCopy( self->s.origin, self->currentOrigin );
+		*/
+		//if we moved, we want the *current* origin, not our start origin!
+		VectorCopy( self->currentOrigin, self->s.pos.trBase );
+		gi.linkentity( self );
+		self->svFlags &= ~SVF_NOCLIENT;
+		self->s.eFlags &= ~EF_NODRAW;
+		self->e_UseFunc = useF_func_usable_use;
+		self->clipmask = 0;
+		if ( self->target2 && self->target2[0] )
+		{
+			G_UseTargets2( self, self->activator, self->target2 );
+		}
+		if ( self->s.eFlags & EF_ANIM_ONCE )
+		{//Start our anim
+			self->s.frame = 0;
+		}
+		//NOTE: be sure to reset the brushmodel before doing this or else CONTENTS_OPAQUE may not be on when you call this
+		if ( !(self->spawnflags&1) )
+		{//START_OFF doesn't effect area portals
+			gi.AdjustAreaPortalState( self, qfalse );
+		}
+	}
+	else
+	{
+		self->clipmask = 0;
+		self->e_ThinkFunc = thinkF_func_wait_return_solid;
+		self->nextthink = level.time + FRAMETIME;
+	}
+}
+
+void func_usable_think( gentity_t *self )
+{
+	if ( self->spawnflags & 8 )
+	{
+		self->svFlags |= SVF_PLAYER_USABLE;	//Replace the usable flag
+		self->e_UseFunc = useF_func_usable_use;
+		self->e_ThinkFunc = thinkF_NULL;
+	}
+}
+
+qboolean G_EntIsRemovableUsable( int entNum )
+{
+	gentity_t *ent = &g_entities[entNum];
+	if ( ent->classname && !Q_stricmp( "func_usable", ent->classname ) )
+	{
+		if ( !(ent->s.eFlags&EF_SHADER_ANIM) && !(ent->spawnflags&8) && ent->targetname )
+		{//not just a shader-animator and not ALWAYS_ON, so it must be removable somehow
+			return qtrue;
+		}
+	}
+	return qfalse;
+}
+
+void func_usable_use( gentity_t *self, gentity_t *other, gentity_t *activator )
+{//Toggle on and off
+	if ( other == activator )
+	{//directly used by use button trace
+		if ( (self->spawnflags&32) )
+		{//only usable by NPCs
+			if ( activator->NPC == NULL )
+			{//Not an NPC
+				return;
+			}
+		}
+	}
+
+	G_ActivateBehavior( self, BSET_USE );
+	if ( self->s.eFlags & EF_SHADER_ANIM )
+	{//animate shader when used
+		self->s.frame++;//inc frame
+		if ( self->s.frame > self->endFrame )
+		{//wrap around
+			self->s.frame = 0;
+		}
+		if ( self->target && self->target[0] )
+		{
+			G_UseTargets( self, activator );
+		}
+	}
+	else if ( self->spawnflags & 8 )
+	{//ALWAYS_ON
+		//Remove the ability to use the entity directly
+		self->svFlags &= ~SVF_PLAYER_USABLE;
+		//also remove ability to call any use func at all!
+		self->e_UseFunc = useF_NULL;
+		
+		if(self->target && self->target[0])
+		{
+			G_UseTargets(self, activator);
+		}
+		
+		if ( self->wait )
+		{
+			self->e_ThinkFunc = thinkF_func_usable_think;
+			self->nextthink = level.time + ( self->wait * 1000 );
+		}
+
+		return;
+	}
+	else if ( !self->count )
+	{//become solid again
+		self->count = 1;
+		self->activator = activator;
+		func_wait_return_solid( self );
+	}
+	else
+	{
+		//NOTE: MUST do this BEFORE clearing contents, or you may not open the area portal!!!
+		if ( !(self->spawnflags&1) )
+		{//START_OFF doesn't effect area portals
+			gi.AdjustAreaPortalState( self, qtrue );
+		}
+		self->s.solid = 0;
+		self->contents = 0;
+		self->clipmask = 0;
+		self->svFlags |= SVF_NOCLIENT;
+		self->s.eFlags |= EF_NODRAW;
+		self->count = 0;
+
+		if(self->target && self->target[0])
+		{
+			G_UseTargets(self, activator);
+		}
+		self->e_ThinkFunc = thinkF_NULL;
+		self->nextthink = -1;
+	}
+}
+
+void func_usable_pain(gentity_t *self, gentity_t *inflictor, gentity_t *attacker, const vec3_t point, int damage, int mod,int hitLoc)
+{
+	if ( self->paintarget )
+	{
+		G_UseTargets2 (self, self->activator, self->paintarget);
+	}
+	else
+	{
+		GEntity_UseFunc( self, attacker, attacker );
+	}
+}
+
+void func_usable_die(gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int mod,int dFlags,int hitLoc)
+{
+	self->takedamage = qfalse;
+	GEntity_UseFunc( self, inflictor, attacker );
+}
+
+/*QUAKED func_usable (0 .5 .8) ? STARTOFF AUTOANIMATE ANIM_ONCE ALWAYS_ON BLOCKCHECK NPC_USE PLAYER_USE INACTIVE
+START_OFF - the wall will not be there
+AUTOANIMATE - if a model is used it will animate				
+ANIM_ONCE - When turned on, goes through anim once
+ALWAYS_ON - Doesn't toggle on and off when used, just runs usescript and fires target
+NPC_ONLY - Only NPCs can directly use this
+PLAYER_USE - Player can use it with the use button
+BLOCKCHECK - Will not turn on while something is inside it
+
+A bmodel that just sits there, doing nothing.  Can be used for conditional walls and models.
+"targetname" - When used, will toggle on and off
+"target"	Will fire this target every time it is toggled OFF
+"target2"	Will fire this target every time it is toggled ON
+"model2"	.md3 model to also draw
+"modelAngles" md3 model's angles <pitch yaw roll> (in addition to any rotation on the part of the brush entity itself)
+"color"		constantLight color
+"light"		constantLight radius
+"usescript" script to run when turned on
+"deathscript"  script to run when turned off
+"wait"		amount of time before the object is usable again (only valid with ALWAYS_ON flag)
+"health"	if it has health, it will be used whenever shot at/killed - if you want it to only be used once this way, set health to 1
+"endframe"	Will make it animate to next shader frame when used, not turn on/off... set this to number of frames in the shader, minus 1
+"forcevisible" - When you turn on force sight (any level), you can see these draw through the entire level...
+*/
+
+void SP_func_usable( gentity_t *self ) 
+{
+	gi.SetBrushModel( self, self->model );
+	InitMover( self );
+	VectorCopy( self->s.origin, self->s.pos.trBase );
+	VectorCopy( self->s.origin, self->currentOrigin );
+	VectorCopy( self->s.origin, self->pos1 );
+
+	self->count = 1;
+	if (self->spawnflags & 1)
+	{
+		self->spawnContents = self->contents;	// It Navs can temporarly turn it "on"
+		self->s.solid = 0;
+		self->contents = 0;
+		self->clipmask = 0;
+		self->svFlags |= SVF_NOCLIENT;
+		self->s.eFlags |= EF_NODRAW;
+		self->count = 0;
+	}
+
+	if (self->spawnflags & 2)
+	{
+		self->s.eFlags |= EF_ANIM_ALLFAST;
+	}
+
+	if (self->spawnflags & 4)
+	{//FIXME: need to be able to do change to something when it's done?  Or not be usable until it's done?
+		self->s.eFlags |= EF_ANIM_ONCE;
+	}
+
+	self->e_UseFunc = useF_func_usable_use;
+
+	if ( self->health )
+	{
+		self->takedamage = qtrue;
+		self->e_DieFunc = dieF_func_usable_die;
+		self->e_PainFunc = painF_func_usable_pain;
+	}
+
+	if ( self->endFrame > 0 )
+	{
+		self->s.frame = self->startFrame = 0;
+		self->s.eFlags |= EF_SHADER_ANIM;
+	}
+
+	gi.linkentity (self);
+
+	int forceVisible = 0;
+	G_SpawnInt( "forcevisible", "0", &forceVisible );
+	if ( forceVisible )
+	{//can see these through walls with force sight, so must be broadcast
+		if ( VectorCompare( self->s.origin, vec3_origin ) )
+		{//no origin brush
+			self->svFlags |= SVF_BROADCAST;
+		}
+		self->s.eFlags |= EF_FORCE_VISIBLE;
+	}
+}
\ No newline at end of file
diff --git a/code/game/g_utils.cpp b/code/game/g_utils.cpp
new file mode 100644
index 0000000..52747db
--- /dev/null
+++ b/code/game/g_utils.cpp
@@ -0,0 +1,2149 @@
+// g_utils.c -- misc utility functions for game module
+
+// leave this line at the top for all g_xxxx.cpp files...
+#include "g_headers.h"
+
+
+#include "Q3_Interface.h"
+#include "g_local.h"
+#include "g_functions.h"
+#ifdef _XBOX
+#include "anims.h"
+#include "..\renderer\mdx_format.h"
+#include "..\qcommon\cm_public.h"
+#include "..\qcommon\cm_local.h"
+#endif
+
+#define ACT_ACTIVE		qtrue
+#define ACT_INACTIVE	qfalse
+extern void NPC_UseResponse ( gentity_t *self, gentity_t *user, qboolean useWhenDone );
+extern qboolean PM_CrouchAnim( int anim );
+/*
+=========================================================================
+
+model / sound configstring indexes
+
+=========================================================================
+*/
+
+/*
+================
+G_FindConfigstringIndex
+
+================
+*/
+extern void ForceTelepathy( gentity_t *self );
+int G_FindConfigstringIndex( const char *name, int start, int max, qboolean create ) {
+	int		i;
+	char	s[MAX_STRING_CHARS];
+
+	if ( !name || !name[0] ) {
+		return 0;
+	}
+
+	for ( i=1 ; i<max ; i++ ) {
+		gi.GetConfigstring( start + i, s, sizeof( s ) );
+		if ( !s[0] ) {
+			break;
+		}
+		if ( !stricmp( s, name ) ) {
+			return i;
+		}
+	}
+
+	if ( !create ) {
+		return 0;
+	}
+
+	if ( i == max ) {
+		G_Error( "G_FindConfigstringIndex: overflow adding %s to set %d-%d", name, start, max );
+	}
+
+	gi.SetConfigstring( start + i, name );
+
+	return i;
+}
+/*
+Ghoul2 Insert Start
+*/
+
+int G_SkinIndex( const char *name ) {
+	return G_FindConfigstringIndex (name, CS_CHARSKINS, MAX_CHARSKINS, qtrue);
+}
+
+/*
+Ghoul2 Insert End
+*/
+
+int G_ModelIndex( const char *name ) {
+	return G_FindConfigstringIndex (name, CS_MODELS, MAX_MODELS, qtrue);
+}
+
+int G_SoundIndex( const char *name ) {
+	assert( name && name[0] );
+	char stripped[MAX_QPATH]; 
+	COM_StripExtension(name, stripped);
+
+	return G_FindConfigstringIndex (stripped, CS_SOUNDS, MAX_SOUNDS, qtrue);
+}
+
+int G_EffectIndex( const char *name )
+{
+	char temp[MAX_QPATH];
+
+	// We just don't want extensions on the things we are registering
+	COM_StripExtension( name, temp );
+
+	return G_FindConfigstringIndex( temp, CS_EFFECTS, MAX_FX, qtrue );
+}
+
+int G_BSPIndex( char *name )
+{
+	return G_FindConfigstringIndex (name, CS_BSP_MODELS, MAX_SUB_BSP, qtrue);
+}
+
+#define FX_ENT_RADIUS 32
+
+//-----------------------------
+// Effect playing utilities
+//-----------------------------
+
+//-----------------------------
+void G_PlayEffect( int fxID, const vec3_t origin, const vec3_t fwd )
+{
+	gentity_t	*tent;
+	vec3_t	temp;
+
+	tent = G_TempEntity( origin, EV_PLAY_EFFECT );
+	tent->s.eventParm = fxID;
+
+	VectorSet( tent->maxs, FX_ENT_RADIUS, FX_ENT_RADIUS, FX_ENT_RADIUS );
+	VectorScale( tent->maxs, -1, tent->mins );
+
+	VectorCopy( fwd, tent->pos3 );
+
+	// Assume angles, we'll do a cross product on the other end to finish up
+	MakeNormalVectors( fwd, tent->pos4, temp );
+	gi.linkentity( tent );
+}
+
+// Play an effect at the origin of the specified entity
+//----------------------------
+void G_PlayEffect( int fxID, int entNum, const vec3_t fwd )
+{
+	gentity_t	*tent;
+	vec3_t		temp;
+
+	tent = G_TempEntity( g_entities[entNum].currentOrigin, EV_PLAY_EFFECT );
+	tent->s.eventParm = fxID;
+	tent->s.otherEntityNum = entNum;
+	VectorSet( tent->maxs, FX_ENT_RADIUS, FX_ENT_RADIUS, FX_ENT_RADIUS );
+	VectorScale( tent->maxs, -1, tent->mins );
+	VectorCopy( fwd, tent->pos3 );
+
+	// Assume angles, we'll do a cross product on the other end to finish up
+	MakeNormalVectors( fwd, tent->pos4, temp );
+}
+
+// Play an effect bolted onto the muzzle of the specified client
+//----------------------------
+void G_PlayEffect( const char *name, int clientNum )
+{
+	gentity_t	*tent;
+
+	tent = G_TempEntity( g_entities[clientNum].currentOrigin, EV_PLAY_MUZZLE_EFFECT );
+	tent->s.eventParm = G_EffectIndex( name );
+	tent->s.otherEntityNum = clientNum;
+	VectorSet( tent->maxs, FX_ENT_RADIUS, FX_ENT_RADIUS, FX_ENT_RADIUS );
+	VectorScale( tent->maxs, -1, tent->mins );
+}
+
+#ifdef _IMMERSION
+// Play an effect at a position on an entity.
+// Mostly for G_MissileBounceEffect so we can play an effect on the bouncee.
+//-----------------------------
+void G_PlayEffect( int fxID, int clientNum, const vec3_t origin, const vec3_t fwd )
+{
+	gentity_t	*tent;
+	vec3_t	temp;
+
+	tent = G_TempEntity( origin, EV_PLAY_EFFECT );
+	tent->s.eventParm = fxID;
+	if ( clientNum != -1 )
+	{
+		tent->s.saberActive = 1;
+		tent->s.otherEntityNum = clientNum;
+	}
+	VectorSet( tent->maxs, FX_ENT_RADIUS, FX_ENT_RADIUS, FX_ENT_RADIUS );
+	VectorScale( tent->maxs, -1, tent->mins );
+	VectorCopy( fwd, tent->pos3 );
+
+	// Assume angles, we'll do a cross product on the other end to finish up
+	MakeNormalVectors( fwd, tent->pos4, temp );
+}
+
+//-----------------------------
+void G_PlayEffect( const char *name, int clientNum, const vec3_t origin, const vec3_t fwd )
+{
+	G_PlayEffect( G_EffectIndex( name ), clientNum, origin, fwd );
+}
+
+#endif // _IMMERSION
+//-----------------------------
+void G_PlayEffect( int fxID, const vec3_t origin, const vec3_t axis[3] )
+{
+	gentity_t	*tent;
+
+	tent = G_TempEntity( origin, EV_PLAY_EFFECT );
+	tent->s.eventParm = fxID;
+
+	VectorSet( tent->maxs, FX_ENT_RADIUS, FX_ENT_RADIUS, FX_ENT_RADIUS );
+	VectorScale( tent->maxs, -1, tent->mins );
+
+	// We can just assume axis[2] from doing a cross product on these.
+	VectorCopy( axis[0], tent->pos3 );
+	VectorCopy( axis[1], tent->pos4 );
+}
+
+// Effect playing utilities	- bolt an effect to a ghoul2 models bolton point
+//-----------------------------
+void G_PlayEffect( int fxID, const int modelIndex, const int boltIndex, const int entNum, const vec3_t origin, int iLoopTime, qboolean isRelative )//iLoopTime 0 = not looping, 1 for infinite, else duration
+{
+	gentity_t	*tent;
+
+	tent = G_TempEntity( origin, EV_PLAY_EFFECT );
+	tent->s.eventParm = fxID;
+
+	tent->s.loopSound = iLoopTime;
+	tent->s.weapon = isRelative;
+
+	tent->svFlags |=SVF_BROADCAST;
+	gi.G2API_AttachEnt(&tent->s.boltInfo, &g_entities[entNum].ghoul2[modelIndex], boltIndex, entNum, modelIndex); 
+}
+
+//-----------------------------
+void G_PlayEffect( const char *name, const vec3_t origin )
+{
+	vec3_t	up = {0, 0, 1};
+
+	G_PlayEffect( G_EffectIndex( name ), origin, up );
+}
+
+//-----------------------------
+void G_PlayEffect( const char *name, const vec3_t origin, const vec3_t fwd )
+{
+	G_PlayEffect( G_EffectIndex( name ), origin, fwd );
+}
+
+//-----------------------------
+void G_PlayEffect( const char *name, const vec3_t origin, const vec3_t axis[3] )
+{
+	G_PlayEffect( G_EffectIndex( name ), origin, axis );
+}
+
+void G_StopEffect( int fxID, const int modelIndex, const int boltIndex, const int entNum )
+{
+	gentity_t	*tent;
+
+	tent = G_TempEntity( g_entities[entNum].currentOrigin, EV_STOP_EFFECT );
+	tent->s.eventParm = fxID;
+	tent->svFlags |= SVF_BROADCAST;
+	gi.G2API_AttachEnt( &tent->s.boltInfo, &g_entities[entNum].ghoul2[modelIndex], boltIndex, entNum, modelIndex ); 
+}
+
+void G_StopEffect(const char *name, const int modelIndex, const int boltIndex, const int entNum )
+{
+	G_StopEffect( G_EffectIndex( name ), modelIndex, boltIndex, entNum );
+}
+
+#ifdef _XBOX
+//-----------------------------
+void G_EntityPosition( int i, vec3_t ret )
+{
+	if ( /*g_entities &&*/ i >= 0 && i < MAX_GENTITIES && g_entities[i].inuse)
+	{
+		gentity_t *ent = g_entities + i;
+
+		if (ent->bmodel)
+		{
+			vec3_t mins, maxs;
+			clipHandle_t h = CM_InlineModel( ent->s.modelindex );
+			CM_ModelBounds( cmg, h, mins, maxs );
+			ret[0] = (mins[0] + maxs[0]) / 2 + ent->currentOrigin[0];
+			ret[1] = (mins[1] + maxs[1]) / 2 + ent->currentOrigin[1];
+			ret[2] = (mins[2] + maxs[2]) / 2 + ent->currentOrigin[2];
+		}
+		else
+		{
+			VectorCopy(g_entities[i].currentOrigin, ret);
+		}
+	}
+	else
+	{
+		ret[0] = ret[1] = ret[2] = 0;
+	}
+}
+#endif
+
+//===Bypass network for sounds on specific channels====================
+
+extern void cgi_S_StartSound( const vec3_t origin, int entityNum, int entchannel, sfxHandle_t sfx );
+#include "..\cgame\cg_media.h"	//access to cgs
+extern qboolean CG_TryPlayCustomSound( vec3_t origin, int entityNum, soundChannel_t channel, const char *soundName, int customSoundSet );
+extern cvar_t *g_timescale;
+//NOTE: Do NOT Try to use this before the cgame DLL is valid, it will NOT work!
+void G_SoundOnEnt( gentity_t *ent, soundChannel_t channel, const char *soundPath )
+{
+	int	index = G_SoundIndex( (char *)soundPath );
+
+	if ( !ent )
+	{
+		return;
+	}
+	if ( g_timescale->integer > 50 )
+	{//Skip the sound!
+		return;
+	}
+
+	cgi_S_UpdateEntityPosition( ent->s.number, ent->currentOrigin );
+	if ( cgs.sound_precache[ index ] ) 
+	{
+		cgi_S_StartSound( NULL, ent->s.number, channel, cgs.sound_precache[ index ] );
+	}
+	else
+	{
+		CG_TryPlayCustomSound( NULL, ent->s.number, channel, soundPath, -1 );
+	}
+}
+
+void G_SoundIndexOnEnt( gentity_t *ent, soundChannel_t channel, int index )
+{
+	if ( !ent )
+	{
+		return;
+	}
+
+	cgi_S_UpdateEntityPosition( ent->s.number, ent->currentOrigin );
+	if ( cgs.sound_precache[ index ] ) 
+	{
+		cgi_S_StartSound( NULL, ent->s.number, channel, cgs.sound_precache[ index ] );
+	}
+}
+
+extern cvar_t	*g_skippingcin;
+void G_SpeechEvent( gentity_t *self, int event )
+{
+	if ( in_camera
+		&& g_skippingcin
+		&& g_skippingcin->integer )
+	{//Skipping a cinematic, so skip NPC voice sounds...
+		return;
+	}
+	//update entity pos, too
+	cgi_S_UpdateEntityPosition( self->s.number, self->currentOrigin );
+	switch ( event )
+	{
+	case EV_ANGER1:	//Say when acquire an enemy when didn't have one before
+	case EV_ANGER2:
+	case EV_ANGER3:
+		CG_TryPlayCustomSound( NULL, self->s.number, CHAN_VOICE, va("*anger%i.wav", event - EV_ANGER1 + 1), CS_COMBAT );
+		break;
+	case EV_VICTORY1:	//Say when killed an enemy
+	case EV_VICTORY2:
+	case EV_VICTORY3:
+		CG_TryPlayCustomSound( NULL, self->s.number, CHAN_VOICE, va("*victory%i.wav", event - EV_VICTORY1 + 1), CS_COMBAT );
+		break;
+	case EV_CONFUSE1:	//Say when confused
+	case EV_CONFUSE2:
+	case EV_CONFUSE3:
+		CG_TryPlayCustomSound( NULL, self->s.number, CHAN_VOICE, va("*confuse%i.wav", event - EV_CONFUSE1 + 1), CS_COMBAT );
+		break;
+	case EV_PUSHED1:	//Say when pushed
+	case EV_PUSHED2:
+	case EV_PUSHED3:
+		CG_TryPlayCustomSound( NULL, self->s.number, CHAN_VOICE, va("*pushed%i.wav", event - EV_PUSHED1 + 1), CS_COMBAT );
+		break;
+	case EV_CHOKE1:	//Say when choking
+	case EV_CHOKE2:
+	case EV_CHOKE3:
+		CG_TryPlayCustomSound( NULL, self->s.number, CHAN_VOICE, va("*choke%i.wav", event - EV_CHOKE1 + 1), CS_COMBAT );
+		break;
+	case EV_FFWARN:	//Warn ally to stop shooting you
+		CG_TryPlayCustomSound( NULL, self->s.number, CHAN_VOICE, "*ffwarn.wav", CS_COMBAT );
+		break;
+	case EV_FFTURN:	//Turn on ally after being shot by them
+		CG_TryPlayCustomSound( NULL, self->s.number, CHAN_VOICE, "*ffturn.wav", CS_COMBAT );
+		break;
+	//extra sounds for ST
+	case EV_CHASE1:
+	case EV_CHASE2:
+	case EV_CHASE3:
+		if ( !CG_TryPlayCustomSound( NULL, self->s.number, CHAN_VOICE, va("*chase%i.wav", event - EV_CHASE1 + 1), CS_EXTRA ) )
+		{
+			CG_TryPlayCustomSound( NULL, self->s.number, CHAN_VOICE, va("*anger%i.wav", Q_irand(1,3)), CS_COMBAT );
+		}
+		break;
+	case EV_COVER1:
+	case EV_COVER2:
+	case EV_COVER3:
+	case EV_COVER4:
+	case EV_COVER5:
+		CG_TryPlayCustomSound( NULL, self->s.number, CHAN_VOICE, va("*cover%i.wav", event - EV_COVER1 + 1), CS_EXTRA );
+		break;
+	case EV_DETECTED1:
+	case EV_DETECTED2:
+	case EV_DETECTED3:
+	case EV_DETECTED4:
+	case EV_DETECTED5:
+		CG_TryPlayCustomSound( NULL, self->s.number, CHAN_VOICE, va("*detected%i.wav", event - EV_DETECTED1 + 1), CS_EXTRA );
+		break;
+	case EV_GIVEUP1:
+	case EV_GIVEUP2:
+	case EV_GIVEUP3:
+	case EV_GIVEUP4:
+		CG_TryPlayCustomSound( NULL, self->s.number, CHAN_VOICE, va("*giveup%i.wav", event - EV_GIVEUP1 + 1), CS_EXTRA );
+		break;
+	case EV_LOOK1:
+	case EV_LOOK2:
+		CG_TryPlayCustomSound( NULL, self->s.number, CHAN_VOICE, va("*look%i.wav", event - EV_LOOK1 + 1), CS_EXTRA );
+		break;
+	case EV_LOST1:
+		CG_TryPlayCustomSound( NULL, self->s.number, CHAN_VOICE, "*lost1.wav", CS_EXTRA );
+		break;
+	case EV_OUTFLANK1:
+	case EV_OUTFLANK2:
+		CG_TryPlayCustomSound( NULL, self->s.number, CHAN_VOICE, va("*outflank%i.wav", event - EV_OUTFLANK1 + 1), CS_EXTRA );
+		break;
+	case EV_ESCAPING1:
+	case EV_ESCAPING2:
+	case EV_ESCAPING3:
+		CG_TryPlayCustomSound( NULL, self->s.number, CHAN_VOICE, va("*escaping%i.wav", event - EV_ESCAPING1 + 1), CS_EXTRA );
+		break;
+	case EV_SIGHT1:
+	case EV_SIGHT2:
+	case EV_SIGHT3:
+		CG_TryPlayCustomSound( NULL, self->s.number, CHAN_VOICE, va("*sight%i.wav", event - EV_SIGHT1 + 1), CS_EXTRA );
+		break;
+	case EV_SOUND1:
+	case EV_SOUND2:
+	case EV_SOUND3:
+		CG_TryPlayCustomSound( NULL, self->s.number, CHAN_VOICE, va("*sound%i.wav", event - EV_SOUND1 + 1), CS_EXTRA );
+		break;
+	case EV_SUSPICIOUS1:
+	case EV_SUSPICIOUS2:
+	case EV_SUSPICIOUS3:
+	case EV_SUSPICIOUS4:
+	case EV_SUSPICIOUS5:
+		CG_TryPlayCustomSound( NULL, self->s.number, CHAN_VOICE, va("*suspicious%i.wav", event - EV_SUSPICIOUS1 + 1), CS_EXTRA );
+		break;
+	//extra sounds for Jedi
+	case EV_COMBAT1:
+	case EV_COMBAT2:
+	case EV_COMBAT3:
+		CG_TryPlayCustomSound( NULL, self->s.number, CHAN_VOICE, va("*combat%i.wav", event - EV_COMBAT1 + 1), CS_JEDI );
+		break;
+	case EV_JDETECTED1:
+	case EV_JDETECTED2:
+	case EV_JDETECTED3:
+		CG_TryPlayCustomSound( NULL, self->s.number, CHAN_VOICE, va("*jdetected%i.wav", event - EV_JDETECTED1 + 1), CS_JEDI );
+		break;
+	case EV_TAUNT1:
+	case EV_TAUNT2:
+	case EV_TAUNT3:
+		CG_TryPlayCustomSound( NULL, self->s.number, CHAN_VOICE, va("*taunt%i.wav", event - EV_TAUNT1 + 1), CS_JEDI );
+		break;
+	case EV_JCHASE1:
+	case EV_JCHASE2:
+	case EV_JCHASE3:
+		CG_TryPlayCustomSound( NULL, self->s.number, CHAN_VOICE, va("*jchase%i.wav", event - EV_JCHASE1 + 1), CS_JEDI );
+		break;
+	case EV_JLOST1:
+	case EV_JLOST2:
+	case EV_JLOST3:
+		CG_TryPlayCustomSound( NULL, self->s.number, CHAN_VOICE, va("*jlost%i.wav", event - EV_JLOST1 + 1), CS_JEDI );
+		break;
+	case EV_DEFLECT1:
+	case EV_DEFLECT2:
+	case EV_DEFLECT3:
+		CG_TryPlayCustomSound( NULL, self->s.number, CHAN_VOICE, va("*deflect%i.wav", event - EV_DEFLECT1 + 1), CS_JEDI );
+		break;
+	case EV_GLOAT1:
+	case EV_GLOAT2:
+	case EV_GLOAT3:
+		CG_TryPlayCustomSound( NULL, self->s.number, CHAN_VOICE, va("*gloat%i.wav", event - EV_GLOAT1 + 1), CS_JEDI );
+		break;
+	case EV_PUSHFAIL:
+		CG_TryPlayCustomSound( NULL, self->s.number, CHAN_VOICE, "*pushfail.wav", CS_JEDI );
+		break;
+	}
+}
+//=====================================================================
+
+
+
+/*
+=============
+G_Find
+
+Searches all active entities for the next one that holds
+the matching string at fieldofs (use the FOFS() macro) in the structure.
+
+Searches beginning at the entity after from, or the beginning if NULL
+NULL will be returned if the end of the list is reached.
+
+=============
+*/
+gentity_t *G_Find (gentity_t *from, int fieldofs, const char *match)
+{
+	char	*s;
+	
+	if(!match || !match[0])
+	{
+		return NULL;
+	}
+
+	if (!from)
+		from = g_entities;
+	else
+		from++;
+
+//	for ( ; from < &g_entities[globals.num_entities] ; from++)
+	int i=from-g_entities;
+	for ( ; i < globals.num_entities ; i++)
+	{
+//		if (!from->inuse)	
+		if(!PInUse(i))
+			continue;
+
+		from=&g_entities[i];
+		s = *(char **) ((byte *)from + fieldofs);
+		if (!s)
+			continue;
+		if (!Q_stricmp (s, match))
+			return from;
+	}
+
+	return NULL;
+}
+
+
+/*
+============
+G_RadiusList - given an origin and a radius, return all entities that are in use that are within the list
+============
+*/
+int G_RadiusList ( vec3_t origin, float radius,	gentity_t *ignore, qboolean takeDamage, gentity_t *ent_list[MAX_GENTITIES])					  
+{
+	float		dist;
+	gentity_t	*ent;
+	gentity_t	*entityList[MAX_GENTITIES];
+	int			numListedEntities;
+	vec3_t		mins, maxs;
+	vec3_t		v;
+	int			i, e;
+	int			ent_count = 0;
+
+	if ( radius < 1 ) 
+	{
+		radius = 1;
+	}
+
+	for ( i = 0 ; i < 3 ; i++ ) 
+	{
+		mins[i] = origin[i] - radius;
+		maxs[i] = origin[i] + radius;
+	}
+
+	numListedEntities = gi.EntitiesInBox( mins, maxs, entityList, MAX_GENTITIES );
+	radius *= radius; //square for the length squared below
+	for ( e = 0 ; e < numListedEntities ; e++ ) 
+	{
+		ent = entityList[ e ];
+
+		if ((ent == ignore) || !(ent->inuse) || ent->takedamage != takeDamage)
+			continue;
+
+		// find the distance from the edge of the bounding box
+		for ( i = 0 ; i < 3 ; i++ ) 
+		{
+			if ( origin[i] < ent->absmin[i] ) 
+			{
+				v[i] = ent->absmin[i] - origin[i];
+			} else if ( origin[i] > ent->absmax[i] ) 
+			{
+				v[i] = origin[i] - ent->absmax[i];
+			} else 
+			{
+				v[i] = 0;
+			}
+		}
+
+		dist = VectorLengthSquared( v );
+		if ( dist >= radius ) 
+		{
+			continue;
+		}
+		
+		// ok, we are within the radius, add us to the incoming list
+		ent_list[ent_count] = ent;
+		ent_count++;
+
+	}
+	// we are done, return how many we found
+	return(ent_count);
+}
+
+
+/*
+=============
+G_PickTarget
+
+Selects a random entity from among the targets
+=============
+*/
+#define MAXCHOICES	32
+
+gentity_t *G_PickTarget (char *targetname)
+{
+	gentity_t	*ent = NULL;
+	int		num_choices = 0;
+	gentity_t	*choice[MAXCHOICES];
+
+	if (!targetname)
+	{
+		gi.Printf("G_PickTarget called with NULL targetname\n");
+		return NULL;
+	}
+
+	while(1)
+	{
+		ent = G_Find (ent, FOFS(targetname), targetname);
+		if (!ent)
+			break;
+		choice[num_choices++] = ent;
+		if (num_choices == MAXCHOICES)
+			break;
+	}
+
+	if (!num_choices)
+	{
+		gi.Printf("G_PickTarget: target %s not found\n", targetname);
+		return NULL;
+	}
+
+	return choice[rand() % num_choices];
+}
+
+void G_UseTargets2 (gentity_t *ent, gentity_t *activator, const char *string)
+{
+	gentity_t		*t;
+	
+//
+// fire targets
+//
+	if (string)
+	{
+		if( !stricmp( string, "self") )
+		{
+			t = ent;
+			if (t->e_UseFunc != useF_NULL)	// check can be omitted
+			{
+				GEntity_UseFunc(t, ent, activator);
+			}
+
+			if (!ent->inuse)
+			{
+				gi.Printf("entity was removed while using targets\n");
+				return;
+			}
+		}
+		else
+		{
+			t = NULL;
+			while ( (t = G_Find (t, FOFS(targetname), (char *) string)) != NULL )
+			{
+				if (t == ent)
+				{
+	//				gi.Printf ("WARNING: Entity used itself.\n");
+				}
+				if (t->e_UseFunc != useF_NULL)	// check can be omitted
+				{
+					GEntity_UseFunc(t, ent, activator);
+				}
+
+				if (!ent->inuse)
+				{
+					gi.Printf("entity was removed while using targets\n");
+					return;
+				}
+			}
+		}
+	}
+}
+
+/*
+==============================
+G_UseTargets
+
+"activator" should be set to the entity that initiated the firing.
+
+Search for (string)targetname in all entities that
+match (string)self.target and call their .use function
+
+==============================
+*/
+void G_UseTargets (gentity_t *ent, gentity_t *activator)
+{
+//
+// fire targets
+//
+	G_UseTargets2 (ent, activator, ent->target);
+}
+
+/*
+=============
+VectorToString
+
+This is just a convenience function
+for printing vectors
+=============
+*/
+char	*vtos( const vec3_t v ) {
+	static	int		index;
+	static	char	str[8][32];
+	char	*s;
+
+	// use an array so that multiple vtos won't collide
+	s = str[index];
+	index = (index + 1)&7;
+
+	Com_sprintf (s, 32, "(%4.2f %4.2f %4.2f)", v[0], v[1], v[2]);
+
+	return s;
+}
+
+
+/*
+===============
+G_SetMovedir
+
+The editor only specifies a single value for angles (yaw),
+but we have special constants to generate an up or down direction.
+Angles will be cleared, because it is being used to represent a direction
+instead of an orientation.
+===============
+*/
+void G_SetMovedir( vec3_t angles, vec3_t movedir ) {
+	static vec3_t VEC_UP		= {0, -1, 0};
+	static vec3_t MOVEDIR_UP	= {0, 0, 1};
+	static vec3_t VEC_DOWN		= {0, -2, 0};
+	static vec3_t MOVEDIR_DOWN	= {0, 0, -1};
+
+	if ( VectorCompare (angles, VEC_UP) ) {
+		VectorCopy (MOVEDIR_UP, movedir);
+	} else if ( VectorCompare (angles, VEC_DOWN) ) {
+		VectorCopy (MOVEDIR_DOWN, movedir);
+	} else {
+		AngleVectors (angles, movedir, NULL, NULL);
+	}
+	VectorClear( angles );
+}
+
+
+float vectoyaw( const vec3_t vec ) {
+	float	yaw;
+	
+	if (vec[YAW] == 0 && vec[PITCH] == 0) {
+		yaw = 0;
+	} else {
+		if (vec[PITCH]) {
+			yaw = ( atan2( vec[YAW], vec[PITCH]) * 180 / M_PI );
+		} else if (vec[YAW] > 0) {
+			yaw = 90;
+		} else {
+			yaw = 270;
+		}
+		if (yaw < 0) {
+			yaw += 360;
+		}
+	}
+
+	return yaw;
+}
+
+
+void G_InitGentity( gentity_t *e, qboolean bFreeG2 ) 
+{
+	e->inuse = qtrue;
+	SetInUse(e);
+	e->m_iIcarusID = IIcarusInterface::ICARUS_INVALID;
+	e->classname = "noclass";
+	e->s.number = e - g_entities;
+	
+	// remove any ghoul2 models here in case we're reusing
+	if (bFreeG2 && e->ghoul2.IsValid())
+	{
+		gi.G2API_CleanGhoul2Models(e->ghoul2);
+	}
+	//Navigational setups
+	e->waypoint				= WAYPOINT_NONE;
+	e->lastWaypoint			= WAYPOINT_NONE;
+}
+
+/*
+=================
+G_Spawn
+
+Either finds a free entity, or allocates a new one.
+
+  The slots from 0 to MAX_CLIENTS-1 are always reserved for clients, and will
+never be used by anything else.
+
+Try to avoid reusing an entity that was recently freed, because it
+can cause the client to think the entity morphed into something else
+instead of being removed and recreated, which can cause interpolated
+angles and bad trails.
+=================
+*/
+gentity_t *G_Spawn( void ) 
+{
+	int			i, force;
+	gentity_t	*e;
+
+	e = NULL;	// shut up warning
+	i = 0;		// shut up warning
+	for ( force = 0 ; force < 2 ; force++ ) 
+	{
+		// if we go through all entities and can't find one to free,
+		// override the normal minimum times before use
+		e = &g_entities[MAX_CLIENTS];
+//		for ( i = MAX_CLIENTS ; i<globals.num_entities ; i++, e++)
+//		{
+//			if ( e->inuse )
+//			{
+//				continue;
+//			}
+		for ( i = MAX_CLIENTS ; i<globals.num_entities ; i++) 
+		{
+			if(PInUse(i))
+			{
+				continue;
+			}			
+			e=&g_entities[i];
+
+			// the first couple seconds of server time can involve a lot of
+			// freeing and allocating, so relax the replacement policy
+			if ( !force && e->freetime > 2000 && level.time - e->freetime < 1000 ) {
+				continue;
+			}
+
+			// reuse this slot
+			G_InitGentity( e, qtrue );
+			return e;
+		}
+		e=&g_entities[i];
+		if ( i != ENTITYNUM_MAX_NORMAL )
+		{
+			break;
+		}
+	}
+	if ( i == ENTITYNUM_MAX_NORMAL )
+	{
+#ifndef _XBOX
+//#ifndef FINAL_BUILD
+		e = &g_entities[0];
+
+//--------------Use this to dump directly to a file
+		char buff[256];
+		FILE *fp;
+
+		fp = fopen( "c:/nofreeentities.txt", "w" );
+		for ( i = 0 ; i<globals.num_entities ; i++, e++) 
+		{
+			if ( e->classname )
+			{
+				sprintf( buff, "%d: %s\n", i, e->classname );
+			}
+
+			fputs( buff, fp );
+		}
+		fclose( fp );
+/*
+//---------------Or use this to dump to the console -- beware though, the console will fill quickly and you probably won't see the full list
+		for ( i = 0 ; i<globals.num_entities ; i++, e++) 
+		{
+			if ( e->classname )
+			{
+				Com_Printf( "%d: %s\n", i, e->classname );
+
+			}
+		}
+*/
+#endif//FINAL_BUILD
+		G_Error( "G_Spawn: no free entities" );
+	}
+	
+	// open up a new slot
+	globals.num_entities++;
+	G_InitGentity( e, qtrue );
+	return e;
+}
+
+extern	void	Vehicle_Remove(gentity_t *ent);
+
+/*
+=================
+G_FreeEntity
+
+Marks the entity as free
+=================
+*/
+void G_FreeEntity( gentity_t *ed ) {
+	gi.unlinkentity (ed);		// unlink from world
+
+	// Free the Game Element (the entity) and delete the Icarus ID.
+	Quake3Game()->FreeEntity( ed );
+
+	/*if ( ed->neverFree ) {
+		return;
+	}*/
+
+	if (ed->wayedge!=0)
+	{
+		NAV::WayEdgesNowClear(ed);
+	}
+
+
+	// remove any ghoul2 models here
+	gi.G2API_CleanGhoul2Models(ed->ghoul2);
+
+	if (ed->client && ed->client->NPC_class == CLASS_VEHICLE)
+	{
+		Vehicle_Remove(ed);
+
+		if ( ed->m_pVehicle )
+		{
+			gi.Free( ed->m_pVehicle );
+		}
+		//CVehicleNPC *pVeh = static_cast< CVehicleNPC * >( ed->NPC );
+		//delete pVeh;
+		//gi.Free((char*)ed->NPC-4);//crazy hack for class vtables
+	} 
+
+	//free this stuff now, rather than waiting until the level ends.
+	if (ed->NPC)
+	{
+		gi.Free(ed->NPC);
+
+		if(ed->client->clientInfo.customBasicSoundDir && gi.bIsFromZone(ed->client->clientInfo.customBasicSoundDir, TAG_G_ALLOC)) {
+			gi.Free(ed->client->clientInfo.customBasicSoundDir);
+		}
+		if(ed->client->clientInfo.customCombatSoundDir) {
+			assert(*(int*)ed->client->clientInfo.customCombatSoundDir != 0xfeeefeee);
+			gi.Free(ed->client->clientInfo.customCombatSoundDir);
+		}
+		if(ed->client->clientInfo.customExtraSoundDir) {
+			assert(*(int*)ed->client->clientInfo.customExtraSoundDir != 0xfeeefeee);
+			gi.Free(ed->client->clientInfo.customExtraSoundDir);
+		}
+		if(ed->client->clientInfo.customJediSoundDir) {
+			gi.Free(ed->client->clientInfo.customJediSoundDir);
+		}
+		if(ed->client->ps.saber[0].name && gi.bIsFromZone(ed->client->ps.saber[0].name, TAG_G_ALLOC) ) {
+			gi.Free(ed->client->ps.saber[0].name);
+		}
+		if(ed->client->ps.saber[0].model && gi.bIsFromZone(ed->client->ps.saber[0].model, TAG_G_ALLOC) ) {
+			gi.Free(ed->client->ps.saber[0].model);
+		}
+		if(ed->client->ps.saber[1].name && gi.bIsFromZone(ed->client->ps.saber[1].name, TAG_G_ALLOC) ) {
+			gi.Free(ed->client->ps.saber[1].name);
+		}
+		if(ed->client->ps.saber[1].model && gi.bIsFromZone(ed->client->ps.saber[1].model, TAG_G_ALLOC) ) {
+ 			gi.Free(ed->client->ps.saber[1].model);
+		}
+
+		gi.Free(ed->client);
+	}
+
+	if (ed->soundSet && gi.bIsFromZone(ed->soundSet, TAG_G_ALLOC)) {
+		gi.Free(ed->soundSet);
+	}
+	if (ed->targetname && gi.bIsFromZone(ed->targetname, TAG_G_ALLOC)) {
+		gi.Free(ed->targetname);
+	}
+	if (ed->NPC_targetname && gi.bIsFromZone(ed->NPC_targetname, TAG_G_ALLOC)) {
+		gi.Free(ed->NPC_targetname);
+	}
+	if (ed->NPC_type && gi.bIsFromZone(ed->NPC_type, TAG_G_ALLOC)) {
+		gi.Free(ed->NPC_type);
+	}
+	if (ed->classname && gi.bIsFromZone(ed->classname, TAG_G_ALLOC)) {
+		gi.Free(ed->classname );
+	}
+	if (ed->message && gi.bIsFromZone(ed->message, TAG_G_ALLOC)) {
+		gi.Free(ed->message);
+	}	
+	if (ed->model && gi.bIsFromZone(ed->model, TAG_G_ALLOC)) {
+		gi.Free(ed->model);
+	}	
+
+//scripting
+	if (ed->script_targetname && gi.bIsFromZone(ed->script_targetname, TAG_G_ALLOC)) {
+		gi.Free(ed->script_targetname);
+	}
+	if (ed->cameraGroup && gi.bIsFromZone(ed->cameraGroup, TAG_G_ALLOC)) {
+		gi.Free(ed->cameraGroup);
+	}
+	if (ed->paintarget && gi.bIsFromZone(ed->paintarget, TAG_G_ALLOC)) {
+		gi.Free(ed->paintarget);
+	}
+	if(ed->parms) {
+		gi.Free(ed->parms);
+	}
+	
+//Limbs
+	if (ed->target && gi.bIsFromZone(ed->target , TAG_G_ALLOC)) {
+		gi.Free(ed->target);
+	}
+	if (ed->target2 && gi.bIsFromZone(ed->target2 , TAG_G_ALLOC)) {
+		gi.Free(ed->target2);
+	}
+	if (ed->target3 && gi.bIsFromZone(ed->target3 , TAG_G_ALLOC)) {
+		gi.Free(ed->target3);
+	}
+	if (ed->target4 && gi.bIsFromZone(ed->target4 , TAG_G_ALLOC)) {
+		gi.Free(ed->target4);
+	}
+	if (ed->opentarget) {
+		gi.Free(ed->opentarget);
+	}
+	if (ed->closetarget) {
+		gi.Free(ed->closetarget);
+	}
+	// Free any associated timers
+	TIMER_Clear(ed->s.number);
+
+	memset (ed, 0, sizeof(*ed));
+	ed->s.number = ENTITYNUM_NONE;
+	ed->classname = "freed";
+	ed->freetime = level.time;
+	ed->inuse = qfalse;
+	ClearInUse(ed);
+}
+
+/*
+=================
+G_TempEntity
+
+Spawns an event entity that will be auto-removed
+The origin will be snapped to save net bandwidth, so care
+must be taken if the origin is right on a surface (snap towards start vector first)
+=================
+*/
+gentity_t *G_TempEntity( const vec3_t origin, int event ) {
+	gentity_t		*e;
+	vec3_t		snapped;
+
+	e = G_Spawn();
+	e->s.eType = ET_EVENTS + event;
+
+	e->classname = "tempEntity";
+	e->eventTime = level.time;
+	e->freeAfterEvent = qtrue;
+
+	VectorCopy( origin, snapped );
+	SnapVector( snapped );		// save network bandwidth
+	G_SetOrigin( e, snapped );
+
+	// find cluster for PVS
+	gi.linkentity( e );
+
+	return e;
+}
+
+
+
+/*
+==============================================================================
+
+Kill box
+
+==============================================================================
+*/
+
+/*
+=================
+G_KillBox
+
+Kills all entities that would touch the proposed new positioning
+of ent.  Ent should be unlinked before calling this!
+=================
+*/
+void G_KillBox (gentity_t *ent) {
+	int			i, num;
+	gentity_t	*touch[MAX_GENTITIES], *hit;
+	vec3_t		mins, maxs;
+
+	VectorAdd( ent->client->ps.origin, ent->mins, mins );
+	VectorAdd( ent->client->ps.origin, ent->maxs, maxs );
+	num = gi.EntitiesInBox( mins, maxs, touch, MAX_GENTITIES );
+
+	for (i=0 ; i<num ; i++) {
+		hit = touch[i];
+		if ( !hit->client ) {
+			continue;
+		}
+		if ( hit == ent ) {
+			continue;
+		}
+		if ( ent->s.number && hit->client->ps.stats[STAT_HEALTH] <= 0 ) 
+		{//NPC
+			continue;
+		}
+		if ( ent->s.number )
+		{//NPC
+			if ( !(hit->contents&CONTENTS_BODY) )
+			{
+				continue;
+			}
+		}
+		else 
+		{//player
+			if ( !(hit->contents & ent->contents) ) 
+			{
+				continue;
+			}
+		}
+
+		// nail it
+		G_Damage ( hit, ent, ent, NULL, NULL,
+			100000, DAMAGE_NO_PROTECTION, MOD_UNKNOWN);
+	}
+
+}
+
+//==============================================================================
+
+
+/*
+===============
+G_AddEvent
+
+Adds an event+parm and twiddles the event counter
+===============
+*/
+void G_AddEvent( gentity_t *ent, int event, int eventParm ) {
+	int		bits;
+
+	if ( !event ) {
+		gi.Printf( "G_AddEvent: zero event added for entity %i\n", ent->s.number );
+		return;
+	}
+
+#if 0 // FIXME: allow multiple events on an entity
+	// if the entity has an event that hasn't expired yet, don't overwrite
+	// it unless it is identical (repeated footsteps / muzzleflashes / etc )
+	if ( ent->s.event && ent->s.event != event ) {
+		gentity_t	*temp;
+
+		// generate a temp entity that references the original entity
+		gi.Printf( "eventPush\n" );
+
+		temp = G_Spawn();
+		temp->s.eType = ET_EVENT_ONLY;
+		temp->s.otherEntityNum = ent->s.number;
+		G_SetOrigin( temp, ent->s.origin );
+		G_AddEvent( temp, event, eventParm );
+		temp->freeAfterEvent = qtrue;
+		gi.linkentity( temp );
+		return;
+	}
+#endif
+
+	// clients need to add the event in playerState_t instead of entityState_t
+	if ( !ent->s.number ) //only one client
+	{
+#if 0
+		bits = ent->client->ps.externalEvent & EV_EVENT_BITS;
+		bits = ( bits + EV_EVENT_BIT1 ) & EV_EVENT_BITS;
+		ent->client->ps.externalEvent = event | bits;
+		ent->client->ps.externalEventParm = eventParm;
+		ent->client->ps.externalEventTime = level.time;
+#endif
+		if ( eventParm > 255 )
+		{
+			if ( event == EV_PAIN )
+			{//must have cheated, in undying?
+				eventParm = 255;
+			}
+			else
+			{
+				assert( eventParm < 256 );
+			}
+		}
+		AddEventToPlayerstate( event, eventParm, &ent->client->ps );
+	} else {
+		bits = ent->s.event & EV_EVENT_BITS;
+		bits = ( bits + EV_EVENT_BIT1 ) & EV_EVENT_BITS;
+		ent->s.event = event | bits;
+		ent->s.eventParm = eventParm;
+	}
+	ent->eventTime = level.time;
+}
+
+
+/*
+=============
+G_Sound
+=============
+*/
+void G_Sound( gentity_t *ent, int soundIndex ) 
+{
+	gentity_t	*te;
+
+	te = G_TempEntity( ent->currentOrigin, EV_GENERAL_SOUND );
+	te->s.eventParm = soundIndex;
+}
+
+/*
+=============
+G_Sound
+=============
+*/
+void G_SoundAtSpot( vec3_t org, int soundIndex, qboolean broadcast ) 
+{
+	gentity_t	*te;
+
+	te = G_TempEntity( org, EV_GENERAL_SOUND );
+	te->s.eventParm = soundIndex;
+	if ( broadcast )
+	{
+		te->svFlags |= SVF_BROADCAST;
+	}
+}
+
+/*
+=============
+G_SoundBroadcast
+
+  Plays sound that can permeate PVS blockage
+=============
+*/
+void G_SoundBroadcast( gentity_t *ent, int soundIndex ) 
+{
+	gentity_t	*te;
+
+	te = G_TempEntity( ent->currentOrigin, EV_GLOBAL_SOUND );	//full volume
+	te->s.eventParm = soundIndex;
+	te->svFlags |= SVF_BROADCAST;
+}
+
+//==============================================================================
+
+#ifdef _IMMERSION
+int G_ForceIndex( const char *name, int channel )
+{
+	if ( channel >= 0 && channel < FF_CHANNEL_MAX )
+	{
+		// no point in storing a name with a bogus channel
+		// (registering an effect on multiple channels will eat up memory)
+		char temp[512];
+		sprintf( temp, "%d,%s", channel, name );
+		return G_FindConfigstringIndex ( temp, CS_FORCES, MAX_FORCES, qtrue );
+	}
+
+	return 0;
+}
+
+gentity_t *G_OwnerClient( gentity_t *ent )
+{
+	// This test is not adequate... should check for the following...
+	// 1) owned entity is touching client entity
+	// 2) owned entity is a weapon being used by client
+	for
+	(
+	;	ent
+	&&	!ent->client
+	;	ent = ent->owner
+	);
+
+	return ent;
+}
+
+void G_Force( gentity_t *ent, int forceIndex ) 
+{
+	gentity_t *client = G_OwnerClient( ent );
+	if ( client )
+	{
+		G_AddEvent( client, EV_ENTITY_FORCE, forceIndex );
+	}
+}
+
+void G_ForceArea( gentity_t *ent, int forceIndex )
+{
+	gentity_t	*te;
+
+	te = G_TempEntity( ent->s.origin, EV_AREA_FORCE );
+	te->s.eventParm = forceIndex;
+}
+
+void G_ForceBroadcast( gentity_t *ent, int forceIndex )
+{
+	gentity_t	*te;
+
+	te = G_TempEntity( ent->s.origin, EV_GLOBAL_FORCE );
+	te->s.eventParm = forceIndex;
+	te->svFlags |= SVF_BROADCAST;
+}
+
+void G_ForceStop( gentity_t *ent, int forceIndex )
+{
+	G_AddEvent( ent, EV_FORCE_STOP, forceIndex );
+}
+#endif // _IMMERSION
+
+/*
+================
+G_SetOrigin
+
+Sets the pos trajectory for a fixed position
+================
+*/
+void G_SetOrigin( gentity_t *ent, const vec3_t origin ) 
+{
+	VectorCopy( origin, ent->s.pos.trBase );
+	if(ent->client)
+	{
+		VectorCopy( origin, ent->client->ps.origin );
+		VectorCopy( origin, ent->s.origin );
+	}
+	else
+	{
+		ent->s.pos.trType = TR_STATIONARY;
+	}
+	ent->s.pos.trTime = 0;
+	ent->s.pos.trDuration = 0;
+	VectorClear( ent->s.pos.trDelta );
+
+	VectorCopy( origin, ent->currentOrigin );
+
+	// clear waypoints
+	if( ent->client && ent->NPC )
+	{
+		ent->waypoint = 0;
+		ent->lastWaypoint = 0;
+		if( NAV::HasPath( ent ) )
+		{
+			NAV::ClearPath( ent );
+		}
+	}
+
+}
+
+qboolean G_CheckInSolidTeleport (const vec3_t& teleportPos, gentity_t *self)
+{
+	trace_t	trace;
+	vec3_t	end, mins;
+
+	VectorCopy(teleportPos, end);
+	end[2] += self->mins[2];
+	VectorCopy(self->mins, mins);
+	mins[2] = 0;
+
+	gi.trace(&trace, teleportPos, mins, self->maxs, end, self->s.number, self->clipmask);
+	if(trace.allsolid || trace.startsolid)
+	{
+		return qtrue;
+	}
+	return qfalse;
+}
+
+//===============================================================================
+qboolean G_CheckInSolid (gentity_t *self, qboolean fix)
+{
+	trace_t	trace;
+	vec3_t	end, mins;
+
+	VectorCopy(self->currentOrigin, end);
+	end[2] += self->mins[2];
+	VectorCopy(self->mins, mins);
+	mins[2] = 0;
+
+	gi.trace(&trace, self->currentOrigin, mins, self->maxs, end, self->s.number, self->clipmask);
+	if(trace.allsolid || trace.startsolid)
+	{
+		return qtrue;
+	}
+	
+#ifdef _DEBUG
+	if(trace.fraction < 0.99999713)
+#else
+	if(trace.fraction < 1.0)
+#endif
+	{
+		if(fix)
+		{//Put them at end of trace and check again
+			vec3_t	neworg;
+
+			VectorCopy(trace.endpos, neworg);
+			neworg[2] -= self->mins[2];
+			G_SetOrigin(self, neworg);
+			gi.linkentity(self);
+
+			return G_CheckInSolid(self, qfalse);
+		}
+		else
+		{
+			return qtrue;
+		}
+	}
+		
+	return qfalse;
+}
+
+qboolean infront(gentity_t *from, gentity_t *to)
+{
+	vec3_t	angles, dir, forward;
+	float	dot;
+
+	angles[PITCH] = angles[ROLL] = 0;
+	angles[YAW] = from->s.angles[YAW];
+	AngleVectors(angles, forward, NULL, NULL);
+
+	VectorSubtract(to->s.origin, from->s.origin, dir);
+	VectorNormalize(dir);
+
+	dot = DotProduct(forward, dir);
+	if(dot < 0.0f)
+	{
+		return qfalse;
+	}
+
+	return qtrue;
+}
+
+void Svcmd_Use_f( void )
+{
+	char	*cmd1 = gi.argv(1);
+
+	if ( !cmd1 || !cmd1[0] )
+	{
+		//FIXME: warning message
+		gi.Printf( "'use' takes targetname of ent or 'list' (lists all usable ents)\n" );
+		return;
+	}
+	else if ( !Q_stricmp("list", cmd1) )
+	{
+		gentity_t	*ent;
+
+		gi.Printf("Listing all usable entities:\n");
+
+		for ( int i = 1; i < ENTITYNUM_WORLD; i++ )
+		{
+			 ent = &g_entities[i];
+			 if ( ent )
+			 {
+				 if ( ent->targetname && ent->targetname[0] )
+				 {
+					 if ( ent->e_UseFunc != useF_NULL )
+					 {
+						 if ( ent->NPC )
+						 {
+							gi.Printf( "%s (NPC)\n", ent->targetname );
+						 }
+						 else
+						 {
+							gi.Printf( "%s\n", ent->targetname );
+						 }
+					 }
+				 }
+			 }
+		}
+
+		gi.Printf("End of list.\n");
+	}
+	else
+	{
+		G_UseTargets2( &g_entities[0], &g_entities[0], cmd1 );
+	}
+}
+
+//======================================================
+
+void G_SetActiveState(char *targetstring, qboolean actState)
+{
+	gentity_t	*target = NULL;
+	while( NULL != (target = G_Find(target, FOFS(targetname), targetstring)) )
+	{
+		target->svFlags = actState ? (target->svFlags&~SVF_INACTIVE) : (target->svFlags|SVF_INACTIVE);
+	}
+}
+
+void target_activate_use(gentity_t *self, gentity_t *other, gentity_t *activator)
+{
+	G_ActivateBehavior(self,BSET_USE);
+
+	G_SetActiveState(self->target, ACT_ACTIVE);
+}
+
+void target_deactivate_use(gentity_t *self, gentity_t *other, gentity_t *activator)
+{
+	G_ActivateBehavior(self,BSET_USE);
+
+	G_SetActiveState(self->target, ACT_INACTIVE);
+}
+
+//FIXME: make these apply to doors, etc too?
+/*QUAKED target_activate (1 0 0) (-4 -4 -4) (4 4 4)
+Will set the target(s) to be usable/triggerable
+*/
+void SP_target_activate( gentity_t *self )
+{
+	G_SetOrigin( self, self->s.origin );
+	self->e_UseFunc = useF_target_activate_use;
+}
+
+/*QUAKED target_deactivate (1 0 0) (-4 -4 -4) (4 4 4)
+Will set the target(s) to be non-usable/triggerable
+*/
+void SP_target_deactivate( gentity_t *self )
+{
+	G_SetOrigin( self, self->s.origin );
+	self->e_UseFunc = useF_target_deactivate_use;
+}
+
+
+//======================================================
+
+/*
+==============
+ValidUseTarget
+
+Returns whether or not the targeted entity is useable
+==============
+*/
+qboolean ValidUseTarget( gentity_t *ent )
+{
+	if ( ent->e_UseFunc == useF_NULL )
+	{
+		return qfalse;
+	}
+
+	if ( ent->svFlags & SVF_INACTIVE )
+	{//set by target_deactivate
+		return qfalse;
+	}
+	
+	if ( !(ent->svFlags & SVF_PLAYER_USABLE) )
+	{//Check for flag that denotes BUTTON_USE useability
+		return qfalse;
+	}
+	
+	//FIXME: This is only a temp fix..
+	if ( !Q_strncmp( ent->classname, "trigger", 7) )
+	{
+		return qfalse;
+	}
+
+	return qtrue;
+}
+
+static void DebugTraceForNPC(gentity_t *ent)
+{
+	trace_t		trace;
+	vec3_t		src, dest, vf;
+
+	VectorCopy( ent->client->renderInfo.eyePoint, src );
+	
+	AngleVectors( ent->client->ps.viewangles, vf, NULL, NULL );//ent->client->renderInfo.eyeAngles was cg.refdef.viewangles, basically
+	//extend to find end of use trace
+	VectorMA( src, 4096, vf, dest );
+
+	//Trace ahead to find a valid target
+	gi.trace( &trace, src, vec3_origin, vec3_origin, dest, ent->s.number, MASK_OPAQUE|CONTENTS_SOLID|CONTENTS_TERRAIN|CONTENTS_BODY|CONTENTS_ITEM|CONTENTS_CORPSE );
+
+	if (trace.fraction < 0.99f)
+	{
+		gentity_t	*found = &g_entities[trace.entityNum];
+
+		if (found)
+		{
+			const char *targetName = found->targetname;
+			const char *className = found->classname;
+
+			if (targetName == 0)
+			{
+				targetName = "<NULL>";
+			}
+			if (className == 0)
+			{
+				className = "<NULL>";
+			}
+			Com_Printf("found targetname '%s', classname '%s'\n", targetName, className);
+		}
+	}
+}
+
+static qboolean G_ValidActivateBehavior (gentity_t* self, int bset)
+{
+	if ( !self )
+	{
+		return qfalse;
+	}
+
+	const char *bs_name = self->behaviorSet[bset];
+	
+	if( !(VALIDSTRING( bs_name )) )
+	{
+		return qfalse;
+	}
+
+	return qtrue;
+}
+
+static qboolean G_IsTriggerUsable(gentity_t* self, gentity_t* other)
+{
+	if ( self->svFlags & SVF_INACTIVE )
+	{//set by target_deactivate
+		return qfalse;
+	}
+
+	if( self->noDamageTeam )
+	{
+		if ( other->client->playerTeam != self->noDamageTeam )
+		{
+			return qfalse;
+		}
+	}
+
+
+	if ( self->spawnflags & 4 )
+	{//USE_BUTTON
+		if ( !other->client )
+		{
+			return qfalse;
+		}
+	}
+	else
+	{
+		return qfalse;
+	}
+
+	if ( self->spawnflags & 2 )
+	{//FACING
+		vec3_t	forward;
+
+		if ( other->client )
+		{
+			AngleVectors( other->client->ps.viewangles, forward, NULL, NULL );
+		}
+		else
+		{
+			AngleVectors( other->currentAngles, forward, NULL, NULL );
+		}
+
+		if ( DotProduct( self->movedir, forward ) < 0.5 )
+		{//Not Within 45 degrees
+			return qfalse;
+		}
+	}
+
+	if ((!G_ValidActivateBehavior (self, BSET_USE) && !self->target) ||
+		(self->target && 
+		(stricmp(self->target, "n") == 0 || 
+		(stricmp(self->target, "neveropen") == 0 || 
+		(stricmp(self->target, "run_gran_drop") == 0) ||
+		(stricmp(self->target, "speaker") == 0) ||
+		(stricmp(self->target, "locked") == 0)
+		))))
+	{
+		return qfalse;
+	}
+
+
+	/*
+	//NOTE: This doesn't stop you from using it, just delays the use action!
+	if(self->delay && self->painDebounceTime < (level.time + self->delay) )
+	{
+		return qfalse;
+	}
+	*/
+
+	return qtrue;
+}
+
+static qboolean CanUseInfrontOfPartOfLevel(gentity_t* ent )	//originally from VV
+{
+	int			i, num;
+	gentity_t	*touch[MAX_GENTITIES], *hit;
+	vec3_t		mins, maxs;
+	const vec3_t	range = { 40, 40, 52 };
+
+	if ( !ent->client ) {
+		return qfalse;
+	}
+
+	VectorSubtract( ent->client->ps.origin, range, mins );
+	VectorAdd( ent->client->ps.origin, range, maxs );
+
+	num = gi.EntitiesInBox( mins, maxs, touch, MAX_GENTITIES );
+
+	// can't use ent->absmin, because that has a one unit pad
+	VectorAdd( ent->client->ps.origin, ent->mins, mins );
+	VectorAdd( ent->client->ps.origin, ent->maxs, maxs );
+
+	for ( i=0 ; i<num ; i++ ) {
+		hit = touch[i];
+
+		if ( (hit->e_TouchFunc == touchF_NULL) && (ent->e_TouchFunc == touchF_NULL) ) {
+			continue;
+		}
+		if ( !( hit->contents & CONTENTS_TRIGGER ) ) {
+			continue;
+		}
+
+		if ( !gi.EntityContact( mins, maxs, hit ) ) {
+			continue;
+		}
+		
+		if ( hit->e_TouchFunc != touchF_NULL ) {
+			switch (hit->e_TouchFunc )
+			{
+			case touchF_Touch_Multi:
+				if (G_IsTriggerUsable(hit, ent))
+				{
+					return qtrue;
+				}
+				continue;
+				break;
+			default:
+				continue;
+			}
+		}
+	}
+	return qfalse;
+}
+
+#define USE_DISTANCE	64.0f
+extern qboolean eweb_can_be_used( gentity_t *self, gentity_t *other, gentity_t *activator );
+qboolean CanUseInfrontOf(gentity_t *ent)
+{
+	gentity_t	*target;
+	trace_t		trace;
+	vec3_t		src, dest, vf;
+
+	if ( ent->s.number && ent->client->NPC_class == CLASS_ATST )
+	{//a player trying to get out of his ATST
+//		GEntity_UseFunc( ent->activator, ent, ent );
+		return qfalse;
+	}
+
+	if (ent->client->ps.viewEntity != ent->s.number)
+	{
+		ent = &g_entities[ent->client->ps.viewEntity];
+
+		if ( !Q_stricmp( "misc_camera", ent->classname ) ) 
+		{	// we are in a camera
+			gentity_t *next = 0;
+			if ( ent->target2 != NULL )
+			{
+				next = G_Find( NULL, FOFS(targetname), ent->target2 );
+			}
+			if ( next )
+			{//found another one
+				if ( !Q_stricmp( "misc_camera", next->classname ) )
+				{//make sure it's another camera
+					return qtrue;
+				}
+			}
+			else //if ( ent->health > 0 )
+			{//I was the last (only?) one, clear out the viewentity
+				return qfalse;
+			}
+		}
+	}
+
+	if ( !ent->client ) {
+		return qfalse;
+	}
+
+	
+	//FIXME: this does not match where the new accurate crosshair aims...
+	//cg.refdef.vieworg, basically
+	VectorCopy( ent->client->renderInfo.eyePoint, src );
+	
+	AngleVectors( ent->client->ps.viewangles, vf, NULL, NULL );
+	//extend to find end of use trace
+	VectorMA( src, USE_DISTANCE, vf, dest );
+
+	//Trace ahead to find a valid target
+	gi.trace( &trace, src, vec3_origin, vec3_origin, dest, ent->s.number, MASK_OPAQUE|CONTENTS_SOLID|CONTENTS_TERRAIN|CONTENTS_BODY|CONTENTS_ITEM|CONTENTS_CORPSE , G2_NOCOLLIDE, 10);
+	
+	if ( trace.fraction == 1.0f || trace.entityNum >= ENTITYNUM_WORLD )
+	{
+		return (CanUseInfrontOfPartOfLevel(ent));
+	}
+
+	target = &g_entities[trace.entityNum];
+
+	if ( target && target->client && target->client->NPC_class == CLASS_VEHICLE )
+	{
+		// Attempt to board this vehicle.
+		return qtrue;
+	}
+	//Check for a use command
+	if (ValidUseTarget( target )) {
+		if ( target->s.eType == ET_ITEM )
+		{//item, see if we could actually pick it up
+			if ( !BG_CanItemBeGrabbed( &target->s, &ent->client->ps ) ) 
+			{//nope, so don't indicate that we can use it
+				return qfalse;
+			}
+		}
+		else if ( target->e_UseFunc == useF_misc_atst_use )
+		{//drivable AT-ST from JK2
+			if ( ent->client->ps.groundEntityNum != target->s.number )
+			{//must be standing on it to use it
+				return qfalse;
+			}
+		}
+		else if ( target->NPC!=NULL && target->health<=0 )
+		{
+			return qfalse;
+		}
+		else if ( target->e_UseFunc == useF_eweb_use )
+		{
+			if ( !eweb_can_be_used( target, ent, ent ) )
+			{
+				return qfalse;
+			}
+		}
+		return qtrue;
+	}
+
+	if ( target->client 
+		&& target->client->ps.pm_type < PM_DEAD 
+		&& target->NPC!=NULL 
+		&& target->client->playerTeam 
+		&& (target->client->playerTeam == ent->client->playerTeam || target->client->playerTeam == TEAM_NEUTRAL)
+		&& !(target->NPC->scriptFlags&SCF_NO_RESPONSE)
+		&& G_ValidActivateBehavior (target, BSET_USE))
+	{
+		return qtrue;
+	}
+
+	if (CanUseInfrontOfPartOfLevel(ent)) {
+		return qtrue;
+	}
+
+	return qfalse;
+}
+
+/*
+==============
+TryUse
+
+Try and use an entity in the world, directly ahead of us
+==============
+*/
+
+
+void TryUse( gentity_t *ent )
+{
+	gentity_t	*target;
+	trace_t		trace;
+	vec3_t		src, dest, vf;
+
+	if (ent->s.number == 0 && g_npcdebug->integer == 1)
+	{
+		DebugTraceForNPC(ent);
+	}
+
+	if ( ent->s.number == 0 && ent->client->NPC_class == CLASS_ATST )
+	{//a player trying to get out of his ATST
+		GEntity_UseFunc( ent->activator, ent, ent );
+		return;
+	}
+
+	// TODO: turo-boost.
+/*	if ( ent->client->ps.vehicleIndex != VEHICLE_NONE )
+	{//in a vehicle, use key makes you turbo-boost
+		return;
+	}*/
+
+	//FIXME: this does not match where the new accurate crosshair aims...
+	//cg.refdef.vieworg, basically
+	VectorCopy( ent->client->renderInfo.eyePoint, src );
+	
+	AngleVectors( ent->client->ps.viewangles, vf, NULL, NULL );//ent->client->renderInfo.eyeAngles was cg.refdef.viewangles, basically
+	//extend to find end of use trace
+	VectorMA( src, USE_DISTANCE, vf, dest );
+
+	//Trace ahead to find a valid target
+	gi.trace( &trace, src, vec3_origin, vec3_origin, dest, ent->s.number, MASK_OPAQUE|CONTENTS_SOLID|CONTENTS_TERRAIN|CONTENTS_BODY|CONTENTS_ITEM|CONTENTS_CORPSE , G2_NOCOLLIDE, 10);
+	
+	if ( trace.fraction == 1.0f || trace.entityNum  >= ENTITYNUM_WORLD )
+	{
+		//TODO: Play a failure sound
+		/*
+		if ( ent->s.number == 0 )
+		{//if nothing else, try the force telepathy power
+			ForceTelepathy( ent );
+		}
+		*/
+		return;
+	}
+
+	target = &g_entities[trace.entityNum];
+
+	if ( target && target->client && target->client->NPC_class == CLASS_VEHICLE )
+	{
+		// Attempt to board this vehicle.
+		target->m_pVehicle->m_pVehicleInfo->Board( target->m_pVehicle, ent );
+
+		return;
+	}
+
+	//Check for a use command
+	if ( ValidUseTarget( target ) )
+	{
+		NPC_SetAnim( ent, SETANIM_TORSO, BOTH_BUTTON_HOLD, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+		/*
+		if ( !VectorLengthSquared( ent->client->ps.velocity ) && !PM_CrouchAnim( ent->client->ps.legsAnim ) )
+		{
+			NPC_SetAnim( ent, SETANIM_LEGS, BOTH_BUTTON_HOLD, SETANIM_FLAG_NORMAL|SETANIM_FLAG_HOLD );
+		}
+		*/
+		//ent->client->ps.weaponTime = ent->client->ps.torsoAnimTimer;
+		GEntity_UseFunc( target, ent, ent );
+		return;
+	}
+	else if ( target->client 
+		&& target->client->ps.pm_type < PM_DEAD 
+		&& target->NPC!=NULL 
+		&& target->client->playerTeam 
+		&& (target->client->playerTeam == ent->client->playerTeam || target->client->playerTeam == TEAM_NEUTRAL)
+		&& !(target->NPC->scriptFlags&SCF_NO_RESPONSE) )
+	{
+		NPC_UseResponse ( target, ent, qfalse );
+		return;
+	}
+	/*
+	if ( ent->s.number == 0 )
+	{//if nothing else, try the force telepathy power
+		ForceTelepathy( ent );
+	}
+	*/
+}
+
+extern int killPlayerTimer;
+void G_ChangeMap (const char *mapname, const char *spawntarget, qboolean hub)
+{
+//	gi.Printf("Loading...");
+	//ignore if player is dead
+	if (g_entities[0].client->ps.pm_type == PM_DEAD)
+		return;
+	if ( killPlayerTimer )
+	{//can't go to next map if your allies have turned on you
+		return;
+	}
+
+	if (mapname[0] == '+')	//fire up the menu instead
+	{
+		gi.SendConsoleCommand( va("uimenu %s\n", mapname+1) );
+		gi.cvar_set("skippingCinematic", "0");
+		gi.cvar_set("timescale", "1");
+		return;
+	}
+
+	if ( spawntarget == NULL ) {
+		spawntarget = "";	//prevent it from becoming "(null)"
+	}
+	if ( hub == qtrue )
+	{
+		gi.SendConsoleCommand( va("loadtransition %s %s\n", mapname, spawntarget) );
+	}
+	else
+	{
+		gi.SendConsoleCommand( va("maptransition %s %s\n", mapname, spawntarget) );
+	}
+}
+
+qboolean G_PointInBounds( const vec3_t point, const vec3_t mins, const vec3_t maxs )
+{
+	for(int i = 0; i < 3; i++ )
+	{
+		if ( point[i] < mins[i] )
+		{
+			return qfalse;
+		}
+		if ( point[i] > maxs[i] )
+		{
+			return qfalse;
+		}
+	}
+
+	return qtrue;
+}
+
+qboolean G_BoxInBounds( const vec3_t point, const vec3_t mins, const vec3_t maxs, const vec3_t boundsMins, const vec3_t boundsMaxs )
+{
+	vec3_t boxMins;
+	vec3_t boxMaxs;
+
+	VectorAdd( point, mins, boxMins );
+	VectorAdd( point, maxs, boxMaxs );
+
+	if(boxMaxs[0]>boundsMaxs[0])
+		return qfalse;
+
+	if(boxMaxs[1]>boundsMaxs[1])
+		return qfalse;
+
+	if(boxMaxs[2]>boundsMaxs[2])
+		return qfalse;
+
+	if(boxMins[0]<boundsMins[0])
+		return qfalse;
+
+	if(boxMins[1]<boundsMins[1])
+		return qfalse;
+
+	if(boxMins[2]<boundsMins[2])
+		return qfalse;
+
+	//box is completely contained within bounds
+	return qtrue;
+}
+
+
+void G_SetAngles( gentity_t *ent, const vec3_t angles )
+{
+	VectorCopy( angles, ent->currentAngles );
+	VectorCopy( angles, ent->s.angles );
+	VectorCopy( angles, ent->s.apos.trBase );
+}
+
+qboolean G_ClearTrace( const vec3_t start, const vec3_t mins, const vec3_t maxs, const vec3_t end, int ignore, int clipmask )
+{
+	static	trace_t	tr;
+
+	gi.trace( &tr, start, mins, maxs, end, ignore, clipmask );
+
+	if ( tr.allsolid || tr.startsolid || tr.fraction < 1.0 )
+	{
+		return qfalse;
+	}
+
+	return qtrue;
+}
+
+extern void CG_TestLine( vec3_t start, vec3_t end, int time, unsigned int color, int radius);
+void	G_DebugLine(vec3_t A, vec3_t B, int duration, int color, qboolean deleteornot)
+{
+	/*
+	gentity_t *tent = G_TempEntity( A, EV_DEBUG_LINE );
+	VectorCopy(B, tent->s.origin2 );
+	tent->s.time = duration;		// Pause
+	tent->s.time2 = color;			// Color
+	tent->s.weapon = 1;				// Dimater
+	tent->freeAfterEvent = deleteornot;
+	*/
+
+	CG_TestLine( A, B, duration, color, 1 );
+}
+
+qboolean G_ExpandPointToBBox( vec3_t point, const vec3_t mins, const vec3_t maxs, int ignore, int clipmask )
+{
+	trace_t	tr;
+	vec3_t	start, end;
+
+	VectorCopy( point, start );
+	
+	for ( int i = 0; i < 3; i++ )
+	{
+		VectorCopy( start, end );
+		end[i] += mins[i];
+		gi.trace( &tr, start, vec3_origin, vec3_origin, end, ignore, clipmask );
+		if ( tr.allsolid || tr.startsolid )
+		{
+			return qfalse;
+		}
+		if ( tr.fraction < 1.0 )
+		{
+			VectorCopy( start, end );
+			end[i] += maxs[i]-(mins[i]*tr.fraction);
+			gi.trace( &tr, start, vec3_origin, vec3_origin, end, ignore, clipmask );
+			if ( tr.allsolid || tr.startsolid )
+			{
+				return qfalse;
+			}
+			if ( tr.fraction < 1.0 )
+			{
+				return qfalse;
+			}
+			VectorCopy( end, start );
+		}
+	}
+	//expanded it, now see if it's all clear
+	gi.trace( &tr, start, mins, maxs, start, ignore, clipmask );
+	if ( tr.allsolid || tr.startsolid )
+	{
+		return qfalse;
+	}
+	VectorCopy( start, point );
+	return qtrue;
+}
+/*
+Ghoul2 Insert Start
+*/
+
+void removeBoltSurface( gentity_t *ent)
+{
+	gentity_t	*hitEnt = &g_entities[ent->cantHitEnemyCounter];
+
+	// check first to be sure the bolt is still there on the model
+	if ((hitEnt->ghoul2.size() > ent->damage) &&
+		(hitEnt->ghoul2[ent->damage].mModelindex != -1) &&
+		(hitEnt->ghoul2[ent->damage].mSlist.size() > ent->aimDebounceTime) &&
+		(hitEnt->ghoul2[ent->damage].mSlist[ent->aimDebounceTime].surface != -1) &&
+		(hitEnt->ghoul2[ent->damage].mSlist[ent->aimDebounceTime].offFlags == G2SURFACEFLAG_GENERATED)) 
+	{
+		// remove the bolt
+		gi.G2API_RemoveBolt(&hitEnt->ghoul2[ent->damage], ent->attackDebounceTime);
+		// now remove a surface if there is one
+		if (ent->aimDebounceTime != -1)
+		{
+			gi.G2API_RemoveSurface(&hitEnt->ghoul2[ent->damage], ent->aimDebounceTime);
+		}
+	}
+	// we are done with this entity.
+	G_FreeEntity(ent);
+}
+
+void G_SetBoltSurfaceRemoval( const int entNum, const int modelIndex, const int boltIndex, const int surfaceIndex , float duration ) {
+	gentity_t		*e;
+	vec3_t		snapped = {0,0,0};
+
+	e = G_Spawn();
+
+	e->classname = "BoltRemoval";
+	e->cantHitEnemyCounter = entNum;
+	e->damage = modelIndex;
+	e->attackDebounceTime = boltIndex;
+	e->aimDebounceTime = surfaceIndex;
+
+	G_SetOrigin( e, snapped );
+
+	// find cluster for PVS
+	gi.linkentity( e );
+
+	e->nextthink = level.time + duration;
+	e->e_ThinkFunc = thinkF_removeBoltSurface;
+
+}
+
+/*
+Ghoul2 Insert End
+*/
+
diff --git a/code/game/g_vehicleLoad.cpp b/code/game/g_vehicleLoad.cpp
new file mode 100644
index 0000000..4d82f86
--- /dev/null
+++ b/code/game/g_vehicleLoad.cpp
@@ -0,0 +1,432 @@
+//g_vehicleLoad.cpp
+// leave this line at the top for all NPC_xxxx.cpp files...
+#include "g_headers.h"
+#include "q_shared.h"
+#include "anims.h"
+#include "g_vehicles.h"
+
+extern qboolean G_ParseLiteral( const char **data, const char *string );
+extern void G_CreateG2AttachedWeaponModel( gentity_t *ent, const char *weaponModel, int boltNum, int weaponNum );
+
+vehicleInfo_t g_vehicleInfo[MAX_VEHICLES];
+int		numVehicles = 1;//first one is null/default
+
+typedef enum {
+	VF_INT, 
+	VF_FLOAT,
+	VF_LSTRING,	// string on disk, pointer in memory, TAG_LEVEL
+	VF_VECTOR,
+	VF_BOOL,
+	VF_VEHTYPE,
+	VF_ANIM
+} vehFieldType_t;
+
+typedef struct
+{
+	char	*name;
+	int		ofs;
+	vehFieldType_t	type;
+} vehField_t;
+
+vehField_t vehFields[VEH_PARM_MAX] = 
+{
+	{"name", VFOFS(name), VF_LSTRING},	//unique name of the vehicle
+
+	//general data
+	{"type", VFOFS(type), VF_VEHTYPE},	//what kind of vehicle
+
+	{"numHands", VFOFS(numHands), VF_INT},	//if 2 hands, no weapons, if 1 hand, can use 1-handed weapons, if 0 hands, can use 2-handed weapons
+	{"lookPitch", VFOFS(lookPitch), VF_FLOAT},	//How far you can look up and down off the forward of the vehicle
+	{"lookYaw", VFOFS(lookYaw), VF_FLOAT},	//How far you can look left and right off the forward of the vehicle
+	{"length", VFOFS(length), VF_FLOAT},		//how long it is - used for body length traces when turning/moving?
+	{"width", VFOFS(width), VF_FLOAT},		//how wide it is - used for body length traces when turning/moving?
+	{"height", VFOFS(height), VF_FLOAT},		//how tall it is - used for body length traces when turning/moving?
+	{"centerOfGravity", VFOFS(centerOfGravity), VF_VECTOR},//offset from origin: {forward, right, up} as a modifier on that dimension (-1.0f is all the way back, 1.0f is all the way forward)
+
+	//speed stats
+	{"speedMax", VFOFS(speedMax), VF_FLOAT},		//top speed
+	{"turboSpeed", VFOFS(turboSpeed), VF_FLOAT},	//turbo speed
+	{"speedMin", VFOFS(speedMin), VF_FLOAT},		//if < 0, can go in reverse
+	{"speedIdle", VFOFS(speedIdle), VF_FLOAT},		//what speed it drifts to when no accel/decel input is given
+	{"accelIdle", VFOFS(accelIdle), VF_FLOAT},		//if speedIdle > 0, how quickly it goes up to that speed
+	{"acceleration", VFOFS(acceleration), VF_FLOAT},	//when pressing on accelerator
+	{"decelIdle", VFOFS(decelIdle), VF_FLOAT},		//when giving no input, how quickly it drops to speedIdle
+	{"strafePerc", VFOFS(strafePerc), VF_FLOAT},		//multiplier on current speed for strafing.  If 1.0f, you can strafe at the same speed as you're going forward, 0.5 is half, 0 is no strafing
+
+	//handling stats
+	{"bankingSpeed", VFOFS(bankingSpeed), VF_FLOAT},	//how quickly it pitches and rolls (not under player control)
+	{"pitchLimit", VFOFS(pitchLimit), VF_FLOAT},		//how far it can roll forward or backward
+	{"rollLimit", VFOFS(rollLimit), VF_FLOAT},		//how far it can roll to either side
+	{"braking", VFOFS(braking), VF_FLOAT},		//when pressing on decelerator
+	{"turningSpeed", VFOFS(turningSpeed), VF_FLOAT},	//how quickly you can turn
+	{"turnWhenStopped", VFOFS(turnWhenStopped), VF_BOOL},//whether or not you can turn when not moving
+	{"traction", VFOFS(traction), VF_FLOAT},		//how much your command input affects velocity
+	{"friction", VFOFS(friction), VF_FLOAT},		//how much velocity is cut on its own
+	{"maxSlope", VFOFS(maxSlope), VF_FLOAT},		//the max slope that it can go up with control
+
+	//durability stats
+	{"mass", VFOFS(mass), VF_INT},			//for momentum and impact force (player mass is 10)
+	{"armor", VFOFS(armor), VF_INT},			//total points of damage it can take
+	{"toughness", VFOFS(toughness), VF_FLOAT},		//modifies incoming damage, 1.0 is normal, 0.5 is half, etc.  Simulates being made of tougher materials/construction
+	{"malfunctionArmorLevel", VFOFS(malfunctionArmorLevel), VF_INT},//when armor drops to or below this point, start malfunctioning
+
+	//visuals & sounds
+	{"model", VFOFS(model), VF_LSTRING},			//what model to use - if make it an NPC's primary model, don't need this?
+	{"skin", VFOFS(skin), VF_LSTRING},			//what skin to use - if make it an NPC's primary model, don't need this?
+	{"riderAnim", VFOFS(riderAnim), VF_ANIM},		//what animation the rider uses
+	{"gunswivelBone", VFOFS(gunswivelBone), VF_LSTRING},//gun swivel bones
+	{"lFinBone", VFOFS(lFinBone), VF_LSTRING},			//left fin bone
+	{"rFinBone", VFOFS(rFinBone), VF_LSTRING},			//right fin bone
+	{"lExhaustTag", VFOFS(lExhaustTag), VF_LSTRING},	//left exhaust tag
+	{"rExhaustTag", VFOFS(rExhaustTag), VF_LSTRING},	//right exhaust tag
+
+	{"soundOn", VFOFS(soundOn), VF_LSTRING},		//sound to play when get on it
+	{"soundLoop", VFOFS(soundLoop), VF_LSTRING},		//sound to loop while riding it
+	{"soundOff", VFOFS(soundOff), VF_LSTRING},		//sound to play when get off
+	{"exhaustFX", VFOFS(exhaustFX), VF_LSTRING},		//exhaust effect, played from "*exhaust" bolt(s)
+	{"trailFX", VFOFS(trailFX), VF_LSTRING},		//trail effect, played from "*trail" bolt(s)
+	{"impactFX", VFOFS(impactFX), VF_LSTRING},		//impact effect, for when it bumps into something
+	{"explodeFX", VFOFS(explodeFX), VF_LSTRING},		//explosion effect, for when it blows up (should have the sound built into explosion effect)
+	{"wakeFX", VFOFS(wakeFX), VF_LSTRING},		//effect it makes when going across water
+
+	//other misc stats
+	{"gravity", VFOFS(gravity), VF_INT},			//normal is 800
+	{"hoverHeight", VFOFS(hoverHeight), VF_FLOAT},	//if 0, it's a ground vehicle
+	{"hoverStrength", VFOFS(hoverStrength), VF_FLOAT},	//how hard it pushes off ground when less than hover height... causes "bounce", like shocks
+	{"waterProof", VFOFS(waterProof), VF_BOOL},		//can drive underwater if it has to
+	{"bouyancy", VFOFS(bouyancy), VF_FLOAT},		//when in water, how high it floats (1 is neutral bouyancy)
+	{"fuelMax", VFOFS(fuelMax), VF_INT},		//how much fuel it can hold (capacity)
+	{"fuelRate", VFOFS(fuelRate), VF_INT},		//how quickly is uses up fuel
+	{"visibility", VFOFS(visibility), VF_INT},		//for sight alerts
+	{"loudness", VFOFS(loudness), VF_INT},		//for sound alerts
+	{"explosionRadius", VFOFS(explosionRadius), VF_FLOAT},//range of explosion
+	{"explosionDamage", VFOFS(explosionDamage), VF_INT},//damage of explosion
+
+	//new stuff
+	{"maxPassengers", VFOFS(maxPassengers), VF_INT},	// The max number of passengers this vehicle may have (Default = 0).
+	{"hideRider", VFOFS(hideRider), VF_BOOL },		// rider (and passengers?) should not be drawn
+	{"killRiderOnDeath", VFOFS(killRiderOnDeath), VF_BOOL },//if rider is on vehicle when it dies, they should die
+	{"flammable", VFOFS(flammable), VF_BOOL },		//whether or not the vehicle should catch on fire before it explodes
+	{"explosionDelay", VFOFS(explosionDelay), VF_INT},	//how long the vehicle should be on fire/dying before it explodes
+	//camera stuff
+	{"cameraOverride", VFOFS(cameraOverride), VF_BOOL },	//override the third person camera with the below values - normal is 0 (off)
+	{"cameraRange", VFOFS(cameraRange), VF_FLOAT},	//how far back the camera should be - normal is 80
+	{"cameraVertOffset", VFOFS(cameraVertOffset), VF_FLOAT},//how high over the vehicle origin the camera should be - normal is 16
+	{"cameraHorzOffset", VFOFS(cameraHorzOffset), VF_FLOAT},//how far to left/right (negative/positive) of of the vehicle origin the camera should be - normal is 0
+	{"cameraPitchOffset", VFOFS(cameraPitchOffset), VF_FLOAT},//a modifier on the camera's pitch (up/down angle) to the vehicle - normal is 0
+	{"cameraFOV", VFOFS(cameraFOV), VF_FLOAT},		//third person camera FOV, default is 80
+	{"cameraAlpha", VFOFS(cameraAlpha), VF_BOOL },	//fade out the vehicle if it's in the way of the crosshair
+};
+
+stringID_table_t VehicleTable[VH_NUM_VEHICLES+1] =
+{
+	ENUM2STRING(VH_WALKER),		//something you ride inside of, it walks like you, like an AT-ST
+	ENUM2STRING(VH_FIGHTER),	//something you fly inside of, like an X-Wing or TIE fighter
+	ENUM2STRING(VH_SPEEDER),	//something you ride on that hovers, like a speeder or swoop
+	ENUM2STRING(VH_ANIMAL),		//animal you ride on top of that walks, like a tauntaun
+	ENUM2STRING(VH_FLIER),		//animal you ride on top of that flies, like a giant mynoc?
+	"",	-1
+};
+
+void G_VehicleSetDefaults( vehicleInfo_t *vehicle )
+{
+	vehicle->name = "default";		//unique name of the vehicle
+/*
+	//general data
+	vehicle->type = VH_SPEEDER;				//what kind of vehicle
+	//FIXME: no saber or weapons if numHands = 2, should switch to speeder weapon, no attack anim on player
+	vehicle->numHands = 2;					//if 2 hands, no weapons, if 1 hand, can use 1-handed weapons, if 0 hands, can use 2-handed weapons
+	vehicle->lookPitch = 35;				//How far you can look up and down off the forward of the vehicle
+	vehicle->lookYaw = 5;					//How far you can look left and right off the forward of the vehicle
+	vehicle->length = 0;					//how long it is - used for body length traces when turning/moving?
+	vehicle->width = 0;						//how wide it is - used for body length traces when turning/moving?
+	vehicle->height = 0;					//how tall it is - used for body length traces when turning/moving?
+	VectorClear( vehicle->centerOfGravity );//offset from origin: {forward, right, up} as a modifier on that dimension (-1.0f is all the way back, 1.0f is all the way forward)
+
+	//speed stats - note: these are DESIRED speed, not actual current speed/velocity
+	vehicle->speedMax = VEH_DEFAULT_SPEED_MAX;	//top speed
+	vehicle->turboSpeed = 0;					//turboBoost
+	vehicle->speedMin = 0;						//if < 0, can go in reverse
+	vehicle->speedIdle = 0;						//what speed it drifts to when no accel/decel input is given
+	vehicle->accelIdle = 0;						//if speedIdle > 0, how quickly it goes up to that speed
+	vehicle->acceleration = VEH_DEFAULT_ACCEL;	//when pressing on accelerator (1/2 this when going in reverse)
+	vehicle->decelIdle = VEH_DEFAULT_DECEL;		//when giving no input, how quickly it desired speed drops to speedIdle
+	vehicle->strafePerc = VEH_DEFAULT_STRAFE_PERC;//multiplier on current speed for strafing.  If 1.0f, you can strafe at the same speed as you're going forward, 0.5 is half, 0 is no strafing
+
+	//handling stats
+	vehicle->bankingSpeed = VEH_DEFAULT_BANKING_SPEED;	//how quickly it pitches and rolls (not under player control)
+	vehicle->rollLimit = VEH_DEFAULT_ROLL_LIMIT;		//how far it can roll to either side
+	vehicle->pitchLimit = VEH_DEFAULT_PITCH_LIMIT;		//how far it can pitch forward or backward
+	vehicle->braking = VEH_DEFAULT_BRAKING;				//when pressing on decelerator (backwards)
+	vehicle->turningSpeed = VEH_DEFAULT_TURNING_SPEED;	//how quickly you can turn
+	vehicle->turnWhenStopped = qfalse;					//whether or not you can turn when not moving	
+	vehicle->traction = VEH_DEFAULT_TRACTION;			//how much your command input affects velocity
+	vehicle->friction = VEH_DEFAULT_FRICTION;			//how much velocity is cut on its own
+	vehicle->maxSlope = VEH_DEFAULT_MAX_SLOPE;			//the max slope that it can go up with control
+
+	//durability stats
+	vehicle->mass = VEH_DEFAULT_MASS;			//for momentum and impact force (player mass is 10)
+	vehicle->armor = VEH_DEFAULT_MAX_ARMOR;		//total points of damage it can take
+	vehicle->toughness = VEH_DEFAULT_TOUGHNESS;	//modifies incoming damage, 1.0 is normal, 0.5 is half, etc.  Simulates being made of tougher materials/construction
+	vehicle->malfunctionArmorLevel = 0;			//when armor drops to or below this point, start malfunctioning
+
+	//visuals & sounds
+	vehicle->model = "swoop";								//what model to use - if make it an NPC's primary model, don't need this?
+	vehicle->modelIndex = 0;							//set internally, not until this vehicle is spawned into the level
+	vehicle->skin = NULL;								//what skin to use - if make it an NPC's primary model, don't need this?
+	vehicle->riderAnim = BOTH_GUNSIT1;					//what animation the rider uses
+	vehicle->gunswivelBone = NULL;						//gun swivel bones
+	vehicle->lFinBone = NULL;							//left fin bone
+	vehicle->rFinBone = NULL;							//right fin bone
+	vehicle->lExhaustTag = NULL;						//left exhaust tag
+	vehicle->rExhaustTag = NULL;						//right exhaust tag
+
+	vehicle->soundOn = NULL;							//sound to play when get on it
+	vehicle->soundLoop = NULL;							//sound to loop while riding it
+	vehicle->soundOff = NULL;							//sound to play when get off
+	vehicle->exhaustFX = NULL;							//exhaust effect, played from "*exhaust" bolt(s)
+	vehicle->trailFX = NULL;							//trail effect, played from "*trail" bolt(s)
+	vehicle->impactFX = NULL;							//explosion effect, for when it blows up (should have the sound built into explosion effect)
+	vehicle->explodeFX = NULL;							//explosion effect, for when it blows up (should have the sound built into explosion effect)
+	vehicle->wakeFX = NULL;								//effect itmakes when going across water
+
+	//other misc stats
+	vehicle->gravity = VEH_DEFAULT_GRAVITY;				//normal is 800
+	vehicle->hoverHeight = 0;	//if 0, it's a ground vehicle
+	vehicle->hoverStrength = 0;//how hard it pushes off ground when less than hover height... causes "bounce", like shocks
+	vehicle->waterProof = qtrue;						//can drive underwater if it has to
+	vehicle->bouyancy = 1.0f;							//when in water, how high it floats (1 is neutral bouyancy)
+	vehicle->fuelMax = 1000;							//how much fuel it can hold (capacity)
+	vehicle->fuelRate = 1;								//how quickly is uses up fuel
+	vehicle->visibility = VEH_DEFAULT_VISIBILITY;		//radius for sight alerts
+	vehicle->loudness = VEH_DEFAULT_LOUDNESS;			//radius for sound alerts
+	vehicle->explosionRadius = VEH_DEFAULT_EXP_RAD;
+	vehicle->explosionDamage = VEH_DEFAULT_EXP_DMG;
+
+	//new stuff
+	vehicle->maxPassengers = 0;
+	vehicle->hideRider = qfalse;						// rider (and passengers?) should not be drawn
+	vehicle->killRiderOnDeath = qfalse;					//if rider is on vehicle when it dies, they should die
+	vehicle->flammable = qfalse;						//whether or not the vehicle should catch on fire before it explodes
+	vehicle->explosionDelay = 0;						//how long the vehicle should be on fire/dying before it explodes
+	//camera stuff
+	vehicle->cameraOverride = qfalse;					//whether or not to use all of the following 3rd person camera override values
+	vehicle->cameraRange = 0.0f;						//how far back the camera should be - normal is 80
+	vehicle->cameraVertOffset = 0.0f;					//how high over the vehicle origin the camera should be - normal is 16
+	vehicle->cameraHorzOffset = 0.0f;					//how far to left/right (negative/positive) of of the vehicle origin the camera should be - normal is 0
+	vehicle->cameraPitchOffset = 0.0f;					//a modifier on the camera's pitch (up/down angle) to the vehicle - normal is 0
+	vehicle->cameraFOV = 0.0f;							//third person camera FOV, default is 80
+	vehicle->cameraAlpha = qfalse;						//fade out the vehicle if it's in the way of the crosshair
+*/
+}
+
+void G_VehicleClampData( vehicleInfo_t *vehicle )
+{//sanity check and clamp the vehicle's data
+	int		i;
+
+	for ( i = 0; i < 3; i++ )
+	{
+		if ( vehicle->centerOfGravity[i] > 1.0f )
+		{
+			vehicle->centerOfGravity[i] = 1.0f;
+		}
+		else if ( vehicle->centerOfGravity[i] < -1.0f )
+		{
+			vehicle->centerOfGravity[i] = -1.0f;
+		}
+	}
+
+	// Validate passenger max.
+	if ( vehicle->maxPassengers > VEH_MAX_PASSENGERS )
+	{
+		vehicle->maxPassengers = VEH_MAX_PASSENGERS;
+	}
+	else if ( vehicle->maxPassengers < 0 )
+	{
+		vehicle->maxPassengers = 0;
+	}
+}
+
+
+static void G_ParseVehicleParms( vehicleInfo_t *vehicle, const char **holdBuf )
+{
+	const char	*token;
+	const char	*value;
+	int		i;
+	vec3_t	vec;
+	byte	*b = (byte *)vehicle;
+	int		_iFieldsRead = 0;
+	vehicleType_t vehType;
+
+	while ( holdBuf )
+	{
+		token = COM_ParseExt( holdBuf, qtrue );
+		if ( !token[0] ) 
+		{
+			gi.Printf( S_COLOR_RED"ERROR: unexpected EOF while parsing vehicles!\n" );
+			return;
+		}
+
+		if ( !Q_stricmp( token, "}" ) )	// End of data for this vehicle
+		{
+			break;
+		}
+
+		// Loop through possible parameters
+		for ( i = 0; i < VEH_PARM_MAX; i++ )
+		{
+			if ( vehFields[i].name && !Q_stricmp( vehFields[i].name, token ) )
+			{
+				// found it
+				if ( COM_ParseString( holdBuf, &value ) ) 
+				{
+					continue;
+				}
+				switch( vehFields[i].type ) 
+				{
+				case VF_INT:
+					*(int *)(b+vehFields[i].ofs) = atoi(value);
+					break;
+				case VF_FLOAT:
+					*(float *)(b+vehFields[i].ofs) = atof(value);
+					break;
+				case VF_LSTRING:	// string on disk, pointer in memory, TAG_LEVEL
+					*(char **)(b+vehFields[i].ofs) = G_NewString( value );
+					break;
+				case VF_VECTOR:
+					_iFieldsRead = sscanf (value, "%f %f %f", &vec[0], &vec[1], &vec[2]);
+					assert(_iFieldsRead==3 );
+					if (_iFieldsRead!=3)
+					{
+						gi.Printf (S_COLOR_YELLOW"G_ParseVehicleParms: VEC3 sscanf() failed to read 3 floats ('angle' key bug?)\n");
+					}
+					((float *)(b+vehFields[i].ofs))[0] = vec[0];
+					((float *)(b+vehFields[i].ofs))[1] = vec[1];
+					((float *)(b+vehFields[i].ofs))[2] = vec[2];
+					break;
+				case VF_BOOL:
+					*(qboolean *)(b+vehFields[i].ofs) = (atof(value)!=0);
+					break;
+				case VF_VEHTYPE:
+					vehType = (vehicleType_t)GetIDForString( VehicleTable, value );
+					*(vehicleType_t *)(b+vehFields[i].ofs) = vehType;
+					break;
+				case VF_ANIM:
+					int anim = GetIDForString( animTable, value );
+					*(int *)(b+vehFields[i].ofs) = anim;
+					break;
+				}
+				break;
+			}
+		}
+	}
+}
+
+static void G_VehicleStoreParms( const char *p ) 
+{//load up all into a table: g_vehicleInfo
+	const char	*token;
+	vehicleInfo_t	*vehicle;
+
+	////////////////// HERE //////////////////////
+	// The first vehicle just contains all the base level (not 'overridden') function calls.
+	G_SetSharedVehicleFunctions( &g_vehicleInfo[0] );
+	numVehicles = 1;
+	
+	//try to parse data out
+	COM_BeginParseSession();
+
+	//look for an open brace
+	while ( p )
+	{
+		token = COM_ParseExt( &p, qtrue );
+		if ( token[0] == 0 )
+		{//barf
+			return;
+		}
+
+		if ( !Q_stricmp( token, "{" ) ) 
+		{//found one, parse out the goodies
+			if ( numVehicles >= MAX_VEHICLES )
+			{//sorry, no more vehicle slots!
+				gi.Printf( S_COLOR_RED"Too many vehicles in *.veh (limit %d)\n", MAX_VEHICLES );
+				break;
+			}
+			//token = token;
+			vehicle = &g_vehicleInfo[numVehicles++];
+			G_VehicleSetDefaults( vehicle );
+			G_ParseVehicleParms( vehicle, &p );
+			//sanity check and clamp the vehicle's data
+			G_VehicleClampData( vehicle );
+	////////////////// HERE //////////////////////
+			// Setup the shared function pointers.
+			G_SetSharedVehicleFunctions( vehicle );
+			switch( vehicle->type )
+			{
+				case VH_SPEEDER:
+					G_SetSpeederVehicleFunctions( vehicle );
+					break;
+				case VH_ANIMAL:
+					G_SetAnimalVehicleFunctions( vehicle );
+					break;
+				case VH_FIGHTER:
+					G_SetFighterVehicleFunctions( vehicle );
+					break;
+				case VH_WALKER:
+					G_SetAnimalVehicleFunctions( vehicle );
+					break;
+			}
+		}
+	}
+}
+
+void G_VehicleLoadParms( void ) 
+{//HMM... only do this if there's a vehicle on the level?
+	int			len, totallen, vehExtFNLen, fileCnt, i;
+	char		*buffer, *holdChar, *marker;
+	char		vehExtensionListBuf[2048];			//	The list of file names read in
+
+	#define MAX_VEHICLE_DATA_SIZE 0x20000
+	char	VehicleParms[MAX_VEHICLE_DATA_SIZE]={0};
+
+	//	gi.Printf( "Parsing *.veh vehicle definitions\n" );
+
+	//set where to store the first one
+	totallen = 0;
+	marker = VehicleParms;
+
+	//now load in the .veh vehicle definitions
+	fileCnt = gi.FS_GetFileList("ext_data/vehicles", ".veh", vehExtensionListBuf, sizeof(vehExtensionListBuf) );
+
+	holdChar = vehExtensionListBuf;
+	for ( i = 0; i < fileCnt; i++, holdChar += vehExtFNLen + 1 ) 
+	{
+		vehExtFNLen = strlen( holdChar );
+
+		//gi.Printf( "Parsing %s\n", holdChar );
+
+		len = gi.FS_ReadFile( va( "ext_data/vehicles/%s", holdChar), (void **) &buffer );
+
+		if ( len == -1 ) 
+		{
+			gi.Printf( "G_VehicleLoadParms: error reading file %s\n", holdChar );
+		}
+		else
+		{
+			if ( totallen && *(marker-1) == '}' )
+			{//don't let it end on a } because that should be a stand-alone token
+				strcat( marker, " " );
+				totallen++;
+				marker++; 
+			}
+			if ( totallen + len >= MAX_VEHICLE_DATA_SIZE ) {
+				G_Error( "G_VehicleLoadParms: ran out of space before reading %s\n(you must make the .npc files smaller)", holdChar );
+			}
+			strcat( marker, buffer );
+			gi.FS_FreeFile( buffer );
+
+			totallen += len;
+			marker += len;
+		}
+	}
+	G_VehicleStoreParms(VehicleParms);
+}
diff --git a/code/game/g_vehicles.c b/code/game/g_vehicles.c
new file mode 100644
index 0000000..c3fcf4a
--- /dev/null
+++ b/code/game/g_vehicles.c
@@ -0,0 +1,3196 @@
+// leave this line at the top for all g_xxxx.cpp files...
+#include "g_headers.h"
+
+#include "q_shared.h"
+#include "g_local.h"
+
+#ifdef _JK2 //SP does not have this preprocessor for game like MP does
+#ifndef _JK2MP
+#define _JK2MP
+#endif
+#endif
+
+#ifndef _JK2MP
+#include "g_functions.h"
+#include "g_vehicles.h"
+#include "../CGame/cg_Local.h"
+#else
+#include "bg_vehicles.h"
+#endif
+
+#ifdef _JK2MP
+//this is really horrible, but it works! just be sure not to use any locals or anything
+//with these names (exluding bool, false, true). -rww
+#define currentAngles r.currentAngles
+#define currentOrigin r.currentOrigin
+#define mins r.mins
+#define maxs r.maxs
+#define legsAnimTimer legsTimer
+#define torsoAnimTimer torsoTimer
+#define bool qboolean
+#define false qfalse
+#define true qtrue
+
+#define sqrtf sqrt
+
+#define MOD_EXPLOSIVE MOD_SUICIDE
+#endif
+
+#ifndef _JK2MP
+#define GAME_INLINE inline
+#define bgEntity_t gentity_t
+#endif
+
+#ifdef _JK2MP
+extern gentity_t *NPC_Spawn_Do( gentity_t *ent );
+extern void NPC_SetAnim(gentity_t	*ent,int setAnimParts,int anim,int setAnimFlags);
+#else
+extern gentity_t *NPC_Spawn_Do( gentity_t *pEnt, qboolean fullSpawnNow );
+extern qboolean G_ClearLineOfSight(const vec3_t point1, const vec3_t point2, int ignore, int clipmask);
+
+extern qboolean G_SetG2PlayerModelInfo( gentity_t *pEnt, const char *modelName, const char *customSkin, const char *surfOff, const char *surfOn );
+extern void G_RemovePlayerModel( gentity_t *pEnt );
+extern void G_ChangePlayerModel( gentity_t *pEnt, const char *newModel );
+extern void G_RemoveWeaponModels( gentity_t *pEnt );
+extern void CG_ChangeWeapon( int num );
+extern float DotToSpot( vec3_t spot, vec3_t from, vec3_t fromAngles );
+extern qboolean Q3_TaskIDPending( gentity_t *ent, taskID_t taskType );
+extern void SetClientViewAngle( gentity_t *ent, vec3_t angle );
+
+extern vmCvar_t	cg_thirdPersonAlpha;
+extern vec3_t playerMins;
+extern vec3_t playerMaxs;
+extern cvar_t	*g_speederControlScheme;
+extern cvar_t *in_joystick;
+extern void PM_SetAnim(pmove_t	*pm,int setAnimParts,int anim,int setAnimFlags, int blendTime);
+extern int PM_AnimLength( int index, animNumber_t anim );
+extern void NPC_SetAnim(gentity_t	*ent,int setAnimParts,int anim,int setAnimFlags, int iBlend);
+extern void G_Knockdown( gentity_t *self, gentity_t *attacker, const vec3_t pushDir, float strength, qboolean breakSaberLock );
+#endif
+
+#ifdef _JK2MP
+#include "../namespace_begin.h"
+extern void BG_SetAnim(playerState_t *ps, animation_t *animations, int setAnimParts,int anim,int setAnimFlags, int blendTime);
+extern void BG_SetLegsAnimTimer(playerState_t *ps, int time );
+extern void BG_SetTorsoAnimTimer(playerState_t *ps, int time );
+#include "../namespace_end.h"
+void G_VehUpdateShields( gentity_t *targ );
+#ifdef QAGAME
+extern void VEH_TurretThink( Vehicle_t *pVeh, gentity_t *parent, int turretNum );
+#endif
+#else
+extern void PM_SetTorsoAnimTimer( gentity_t *ent, int *torsoAnimTimer, int time );
+extern void PM_SetLegsAnimTimer( gentity_t *ent, int *legsAnimTimer, int time );
+#endif
+
+extern qboolean BG_UnrestrainedPitchRoll( playerState_t *ps, Vehicle_t *pVeh );
+
+void Vehicle_SetAnim(gentity_t *ent,int setAnimParts,int anim,int setAnimFlags, int iBlend)
+{
+#ifdef _JK2MP
+	assert(ent->client);
+	BG_SetAnim(&ent->client->ps, bgAllAnims[ent->localAnimIndex].anims, setAnimParts, anim, setAnimFlags, iBlend);
+	ent->s.legsAnim = ent->client->ps.legsAnim;
+#else
+	NPC_SetAnim(ent, setAnimParts, anim, setAnimFlags, iBlend);
+#endif
+}
+
+void G_VehicleTrace( trace_t *results, const vec3_t start, const vec3_t tMins, const vec3_t tMaxs, const vec3_t end, int passEntityNum, int contentmask )
+{
+#ifdef _JK2MP
+	trap_Trace(results, start, tMins, tMaxs, end, passEntityNum, contentmask);
+#else
+	gi.trace( results, start, tMins, tMaxs, end, passEntityNum, contentmask );
+#endif
+}
+
+Vehicle_t *G_IsRidingVehicle( gentity_t *pEnt )
+{
+	gentity_t *ent = (gentity_t *)pEnt;
+
+	if ( ent && ent->client && ent->client->NPC_class != CLASS_VEHICLE && ent->s.m_iVehicleNum != 0 ) //ent->client && ( ent->client->ps.eFlags & EF_IN_VEHICLE ) && ent->owner )
+	{
+		return g_entities[ent->s.m_iVehicleNum].m_pVehicle;
+	}
+	return NULL;
+}
+
+bool	G_IsRidingTurboVehicle( gentity_t *pEnt )
+{
+	gentity_t *ent = (gentity_t *)pEnt;
+
+	if ( ent && ent->client && ent->client->NPC_class != CLASS_VEHICLE && ent->s.m_iVehicleNum != 0 ) //ent->client && ( ent->client->ps.eFlags & EF_IN_VEHICLE ) && ent->owner )
+	{
+		return (level.time<g_entities[ent->s.m_iVehicleNum].m_pVehicle->m_iTurboTime);
+	}
+	return false;
+}
+
+
+
+float	G_CanJumpToEnemyVeh(Vehicle_t *pVeh, const usercmd_t *pUcmd )
+{
+#ifndef _JK2MP
+	gentity_t*	rider = pVeh->m_pPilot;
+
+	// If There Is An Enemy And We Are At The Same Z Height
+	//------------------------------------------------------
+	if (rider && 
+		rider->enemy && 
+		pUcmd->rightmove && 
+		fabsf(rider->enemy->currentOrigin[2] - rider->currentOrigin[2])<50.0f)
+	{
+		if (level.time<pVeh->m_safeJumpMountTime)
+		{
+			return pVeh->m_safeJumpMountRightDot;
+		}
+
+
+		// If The Enemy Is Riding Another Vehicle
+		//----------------------------------------
+		Vehicle_t*	enemyVeh = G_IsRidingVehicle(rider->enemy);
+		if (enemyVeh)
+		{
+			vec3_t	enemyFwd;
+			vec3_t	toEnemy;
+			float	toEnemyDistance;
+			vec3_t	riderFwd;
+			vec3_t	riderRight;
+			float	riderRightDot;
+
+			// If He Is Close Enough And Going The Same Speed
+			//------------------------------------------------
+			VectorSubtract(rider->enemy->currentOrigin, rider->currentOrigin, toEnemy);
+		 	toEnemyDistance = VectorNormalize(toEnemy);
+			if (toEnemyDistance<70.0f && 
+				pVeh->m_pParentEntity->resultspeed>100.0f &&
+				fabsf(pVeh->m_pParentEntity->resultspeed - enemyVeh->m_pParentEntity->resultspeed)<100.0f)
+			{
+				// If He Is Either To The Left Or Right Of Me
+				//--------------------------------------------
+				AngleVectors(rider->currentAngles, riderFwd, riderRight, 0);
+				riderRightDot = DotProduct(riderRight, toEnemy);
+				if ((pUcmd->rightmove>0 && riderRightDot>0.2) || (pUcmd->rightmove<0 &&riderRightDot<-0.2))
+				{
+					// If We Are Both Going About The Same Direction
+					//-----------------------------------------------
+					AngleVectors(rider->enemy->currentAngles, enemyFwd, 0, 0);
+					if (DotProduct(enemyFwd, riderFwd)>0.2f)
+					{
+						pVeh->m_safeJumpMountTime = level.time + Q_irand(3000, 4000);	// Ok, now you get a 3 sec window
+						pVeh->m_safeJumpMountRightDot = riderRightDot;
+						return riderRightDot;
+					}// Same Direction?
+				}// To Left Or Right?
+			}// Close Enough & Same Speed?
+		}// Enemy Riding A Vehicle?
+	}// Has Enemy And On Same Z-Height
+#endif
+	return 0.0f;
+}
+
+// Spawn this vehicle into the world.
+void G_VehicleSpawn( gentity_t *self )
+{
+	float yaw;
+	gentity_t *vehEnt;
+
+	VectorCopy( self->currentOrigin, self->s.origin );
+
+#ifdef _JK2MP
+	trap_LinkEntity( self );
+#else
+	gi.linkentity( self );
+#endif
+
+	if ( !self->count )
+	{
+		self->count = 1;
+	}
+
+	//save this because self gets removed in next func
+	yaw = self->s.angles[YAW];
+	
+#ifdef _JK2MP
+	vehEnt = NPC_Spawn_Do( self );
+#else
+	vehEnt = NPC_Spawn_Do( self, qtrue );
+#endif
+	
+	if ( !vehEnt )
+	{
+		return;//return NULL;
+	}
+	
+	vehEnt->s.angles[YAW] = yaw;
+	if ( vehEnt->m_pVehicle->m_pVehicleInfo->type != VH_ANIMAL )
+	{
+		vehEnt->NPC->behaviorState = BS_CINEMATIC;
+	}
+
+#ifdef _JK2MP //special check in case someone disconnects/dies while boarding
+	if (vehEnt->spawnflags & 1)
+	{ //die without pilot
+		if (!vehEnt->damage)
+		{ //default 10 sec
+			vehEnt->damage = 10000;
+		}
+		if (!vehEnt->speed)
+		{ //default 512 units
+			vehEnt->speed = 512.0f;
+		}
+		vehEnt->m_pVehicle->m_iPilotTime = level.time + vehEnt->damage;
+	}
+#else
+	if (vehEnt->spawnflags & 1)
+	{ //die without pilot
+		vehEnt->m_pVehicle->m_iPilotTime = level.time + vehEnt->endFrame;
+	}
+#endif
+	//return vehEnt;
+}
+
+// Attachs an entity to the vehicle it's riding (it's owner).
+void G_AttachToVehicle( gentity_t *pEnt, usercmd_t **ucmd )
+{
+	gentity_t		*vehEnt;
+	mdxaBone_t		boltMatrix;
+	gentity_t		*ent;
+#ifdef _JK2MP
+	int				crotchBolt;
+#endif
+
+	if ( !pEnt || !ucmd )
+		return;
+
+	ent = (gentity_t *)pEnt;
+
+#ifdef _JK2MP
+	vehEnt = &g_entities[ent->r.ownerNum];
+#else
+	vehEnt = ent->owner;
+#endif
+	ent->waypoint = vehEnt->waypoint; // take the veh's waypoint as your own
+
+	if ( !vehEnt->m_pVehicle )
+		return;
+
+#ifdef _JK2MP
+	crotchBolt = trap_G2API_AddBolt(vehEnt->ghoul2, 0, "*driver");
+
+	// Get the driver tag.
+	trap_G2API_GetBoltMatrix( vehEnt->ghoul2, 0, crotchBolt, &boltMatrix,
+							vehEnt->m_pVehicle->m_vOrientation, vehEnt->currentOrigin,
+							level.time, NULL, vehEnt->modelScale );
+	BG_GiveMeVectorFromMatrix( &boltMatrix, ORIGIN, ent->client->ps.origin );
+	G_SetOrigin(ent, ent->client->ps.origin);
+	trap_LinkEntity( ent );
+#else
+	// Get the driver tag.
+	gi.G2API_GetBoltMatrix( vehEnt->ghoul2, vehEnt->playerModel, vehEnt->crotchBolt, &boltMatrix,
+							vehEnt->m_pVehicle->m_vOrientation, vehEnt->currentOrigin,
+							(cg.time?cg.time:level.time), NULL, vehEnt->s.modelScale );
+	gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, ent->client->ps.origin );
+	gi.linkentity( ent );
+#endif
+}
+
+#ifndef _JK2MP
+void G_KnockOffVehicle( gentity_t *pRider, gentity_t *self, qboolean bPull )
+{
+	Vehicle_t *pVeh = NULL;
+	vec3_t riderAngles, fDir, rDir, dir2Me;
+	float	fDot, rDot;
+
+	if ( !pRider || !pRider->client )
+	{
+		return;
+	}
+	
+	pVeh = G_IsRidingVehicle( pRider );
+
+	if ( !pVeh || !pVeh->m_pVehicleInfo )
+	{
+		return;
+	}
+
+	VectorCopy( pRider->currentAngles, riderAngles );
+	riderAngles[0] = 0;
+	AngleVectors( riderAngles, fDir, rDir, NULL );
+	VectorSubtract( self->currentOrigin, pRider->currentOrigin, dir2Me );
+	dir2Me[2] = 0;
+	VectorNormalize( dir2Me );
+	fDot = DotProduct( fDir, dir2Me );
+	if ( fDot >= 0.5f )
+	{//I'm in front of them
+		if ( bPull )
+		{//pull them foward
+			pVeh->m_EjectDir = VEH_EJECT_FRONT;
+		}
+		else
+		{//push them back
+			pVeh->m_EjectDir = VEH_EJECT_REAR;
+		}
+	}
+	else if ( fDot <= -0.5f )
+	{//I'm behind them
+		if ( bPull )
+		{//pull them back
+			pVeh->m_EjectDir = VEH_EJECT_REAR;
+		}
+		else
+		{//push them forward
+			pVeh->m_EjectDir = VEH_EJECT_FRONT;
+		}
+	}
+	else
+	{//to the side of them
+		rDot = DotProduct( fDir, dir2Me );
+		if ( rDot >= 0.0f )
+		{//to the right
+			if ( bPull )
+			{//pull them right
+				pVeh->m_EjectDir = VEH_EJECT_RIGHT;
+			}
+			else
+			{//push them left
+				pVeh->m_EjectDir = VEH_EJECT_LEFT;
+			}
+		}
+		else
+		{//to the left
+			if ( bPull )
+			{//pull them left
+				pVeh->m_EjectDir = VEH_EJECT_LEFT;
+			}
+			else
+			{//push them right
+				pVeh->m_EjectDir = VEH_EJECT_RIGHT;
+			}
+		}
+	}
+	//now forcibly eject them
+	pVeh->m_pVehicleInfo->Eject( pVeh, pRider, qtrue );
+}
+#endif
+
+#ifndef _JK2MP //don't want this in mp at least for now
+void G_DrivableATSTDie( gentity_t *self )
+{
+}
+
+void G_DriveATST( gentity_t *pEnt, gentity_t *atst )
+{
+	if ( pEnt->NPC_type && pEnt->client && (pEnt->client->NPC_class == CLASS_ATST) )
+	{//already an atst, switch back
+		//open hatch
+		G_RemovePlayerModel( pEnt );
+		pEnt->NPC_type = "player";
+		pEnt->client->NPC_class = CLASS_PLAYER;
+		pEnt->flags &= ~FL_SHIELDED;
+		pEnt->client->ps.eFlags &= ~EF_IN_ATST;
+		//size
+		VectorCopy( playerMins, pEnt->mins );
+		VectorCopy( playerMaxs, pEnt->maxs );
+		pEnt->client->crouchheight = CROUCH_MAXS_2;
+		pEnt->client->standheight = DEFAULT_MAXS_2;
+		pEnt->s.radius = 0;//clear it so the G2-model-setting stuff will recalc it
+		G_ChangePlayerModel( pEnt, pEnt->NPC_type );
+		//G_SetG2PlayerModel( pEnt, pEnt->NPC_type, NULL, NULL, NULL );
+
+		//FIXME: reset/4 their weapon
+		pEnt->client->ps.stats[STAT_WEAPONS] &= ~(( 1 << WP_ATST_MAIN )|( 1 << WP_ATST_SIDE ));
+		pEnt->client->ps.ammo[weaponData[WP_ATST_MAIN].ammoIndex] = 0;
+		pEnt->client->ps.ammo[weaponData[WP_ATST_SIDE].ammoIndex] = 0;
+		if ( pEnt->client->ps.stats[STAT_WEAPONS] & (1<<WP_BLASTER) )
+		{
+			CG_ChangeWeapon( WP_BLASTER );
+			//camera
+			if ( cg_gunAutoFirst.integer )
+			{//go back to first person
+				gi.cvar_set( "cg_thirdperson", "0" );
+			}
+		}
+		else
+		{
+			CG_ChangeWeapon( WP_NONE );
+		}
+		cg.overrides.active &= ~(CG_OVERRIDE_3RD_PERSON_RNG|CG_OVERRIDE_3RD_PERSON_VOF|CG_OVERRIDE_3RD_PERSON_POF|CG_OVERRIDE_3RD_PERSON_APH);
+		cg.overrides.thirdPersonRange = cg.overrides.thirdPersonVertOffset = cg.overrides.thirdPersonPitchOffset = 0;
+		cg.overrides.thirdPersonAlpha = cg_thirdPersonAlpha.value;
+		pEnt->client->ps.viewheight = pEnt->maxs[2] + STANDARD_VIEWHEIGHT_OFFSET;
+		//pEnt->mass = 10;
+	}
+	else
+	{//become an atst
+		pEnt->NPC_type = "atst";
+		pEnt->client->NPC_class = CLASS_ATST;
+		pEnt->client->ps.eFlags |= EF_IN_ATST;
+		pEnt->flags |= FL_SHIELDED;
+		//size
+		VectorSet( pEnt->mins, ATST_MINS0, ATST_MINS1, ATST_MINS2 );
+		VectorSet( pEnt->maxs, ATST_MAXS0, ATST_MAXS1, ATST_MAXS2 );
+		pEnt->client->crouchheight = ATST_MAXS2;
+		pEnt->client->standheight = ATST_MAXS2;
+		if ( !atst )
+		{//no pEnt to copy from
+			G_ChangePlayerModel( pEnt, "atst" );
+			//G_SetG2PlayerModel( pEnt, "atst", NULL, NULL, NULL );
+			NPC_SetAnim( pEnt, SETANIM_BOTH, BOTH_STAND1, SETANIM_FLAG_OVERRIDE, 200 );
+		}
+		else
+		{
+			G_RemovePlayerModel( pEnt );
+			G_RemoveWeaponModels( pEnt );
+			gi.G2API_CopyGhoul2Instance( atst->ghoul2, pEnt->ghoul2 );
+			pEnt->playerModel = 0;
+			G_SetG2PlayerModelInfo( pEnt, "atst", NULL, NULL, NULL );
+			//turn off hatch underside
+			gi.G2API_SetSurfaceOnOff( &pEnt->ghoul2[pEnt->playerModel], "head_hatchcover", 0x00000002/*G2SURFACEFLAG_OFF*/ );
+			G_Sound( pEnt, G_SoundIndex( "sound/chars/atst/atst_hatch_close" ));
+		}
+		pEnt->s.radius = 320;
+		//weapon
+		gitem_t	*item = FindItemForWeapon( WP_ATST_MAIN );	//precache the weapon
+		CG_RegisterItemSounds( (item-bg_itemlist) );
+		CG_RegisterItemVisuals( (item-bg_itemlist) );
+		item = FindItemForWeapon( WP_ATST_SIDE );	//precache the weapon
+		CG_RegisterItemSounds( (item-bg_itemlist) );
+		CG_RegisterItemVisuals( (item-bg_itemlist) );
+		pEnt->client->ps.stats[STAT_WEAPONS] |= ( 1 << WP_ATST_MAIN )|( 1 << WP_ATST_SIDE );
+		pEnt->client->ps.ammo[weaponData[WP_ATST_MAIN].ammoIndex] = ammoData[weaponData[WP_ATST_MAIN].ammoIndex].max;
+		pEnt->client->ps.ammo[weaponData[WP_ATST_SIDE].ammoIndex] = ammoData[weaponData[WP_ATST_SIDE].ammoIndex].max;
+		CG_ChangeWeapon( WP_ATST_MAIN );
+		//HACKHACKHACKTEMP
+		item = FindItemForWeapon( WP_EMPLACED_GUN );
+		CG_RegisterItemSounds( (item-bg_itemlist) );
+		CG_RegisterItemVisuals( (item-bg_itemlist) );
+		item = FindItemForWeapon( WP_ROCKET_LAUNCHER );
+		CG_RegisterItemSounds( (item-bg_itemlist) );
+		CG_RegisterItemVisuals( (item-bg_itemlist) );
+		item = FindItemForWeapon( WP_BOWCASTER );
+		CG_RegisterItemSounds( (item-bg_itemlist) );
+		CG_RegisterItemVisuals( (item-bg_itemlist) );
+		//HACKHACKHACKTEMP
+		//FIXME: these get lost in load/save!  Must use variables that are set every frame or saved/loaded
+		//camera
+		gi.cvar_set( "cg_thirdperson", "1" );
+		cg.overrides.active |= CG_OVERRIDE_3RD_PERSON_RNG;
+		cg.overrides.thirdPersonRange = 240;
+		//cg.overrides.thirdPersonVertOffset = 100;
+		//cg.overrides.thirdPersonPitchOffset = -30;
+		//FIXME: this gets stomped in pmove?
+		pEnt->client->ps.viewheight = 120;
+		//FIXME: setting these broke things very badly...?
+		//pEnt->client->standheight = 200;
+		//pEnt->client->crouchheight = 200;
+		//pEnt->mass = 300;
+		//movement
+		//pEnt->client->ps.speed = 0;//FIXME: override speed?
+		//FIXME: slow turn turning/can't turn if not moving?
+	}
+}
+#endif //_JK2MP
+
+// Animate the vehicle and it's riders.
+void Animate( Vehicle_t *pVeh )
+{
+	// Validate a pilot rider.
+	if ( pVeh->m_pPilot )
+	{
+		if (pVeh->m_pVehicleInfo->AnimateRiders)
+		{
+			pVeh->m_pVehicleInfo->AnimateRiders( pVeh );
+		}
+	}
+
+	pVeh->m_pVehicleInfo->AnimateVehicle( pVeh );
+}
+
+// Determine whether this entity is able to board this vehicle or not.
+bool ValidateBoard( Vehicle_t *pVeh, bgEntity_t *pEnt )
+{
+	// Determine where the entity is entering the vehicle from (left, right, or back).
+	vec3_t vVehToEnt;
+	vec3_t vVehDir;
+	const gentity_t *parent = (gentity_t *)pVeh->m_pParentEntity;
+	const gentity_t *ent = (gentity_t *)pEnt;
+	vec3_t vVehAngles;
+	float fDot;
+
+	if ( pVeh->m_iDieTime>0)
+	{
+		return false;
+	}
+
+	if ( ent->health <= 0 )
+	{//dead men can't ride vehicles
+		return false;
+	}
+
+	if ( pVeh->m_pPilot != NULL )
+	{//already have a driver!
+		if ( pVeh->m_pVehicleInfo->type == VH_FIGHTER )
+		{//I know, I know, this should by in the fighters's validateboard()
+			//can never steal a fighter from it's pilot
+			return false;
+		}
+		else if ( pVeh->m_pVehicleInfo->type == VH_WALKER )
+		{//I know, I know, this should by in the walker's validateboard()
+			if ( !ent->client || ent->client->ps.groundEntityNum != parent->s.number )
+			{//can only steal an occupied AT-ST if you're on top (by the hatch)
+				return false;
+			}
+		}
+		else if (pVeh->m_pVehicleInfo->type == VH_SPEEDER)
+		{//you can only steal the bike from the driver if you landed on the driver or bike
+			return (pVeh->m_iBoarding==VEH_MOUNT_THROW_LEFT || pVeh->m_iBoarding==VEH_MOUNT_THROW_RIGHT);
+		}
+	}
+	// Yes, you shouldn't have put this here (you 'should' have made an 'overriden' ValidateBoard func), but in this
+	// instance it's more than adequate (which is why I do it too :-). Making a whole other function for this is silly.
+	else if ( pVeh->m_pVehicleInfo->type == VH_FIGHTER )
+	{
+		// If you're a fighter, you allow everyone to enter you from all directions.
+		return true;
+	}
+
+	// Clear out all orientation axis except for the yaw.
+	VectorSet(vVehAngles, 0, parent->currentAngles[YAW], 0);
+
+	// Vector from Entity to Vehicle.
+	VectorSubtract( ent->currentOrigin, parent->currentOrigin, vVehToEnt );
+	vVehToEnt[2] = 0;
+	VectorNormalize( vVehToEnt );
+
+	// Get the right vector.
+	AngleVectors( vVehAngles, NULL, vVehDir, NULL ); 
+	VectorNormalize( vVehDir );
+
+	// Find the angle between the vehicle right vector and the vehicle to entity vector.
+	fDot = DotProduct( vVehToEnt, vVehDir );
+
+	// If the entity is within a certain angle to the left of the vehicle...
+	if ( fDot >= 0.5f )
+	{
+		// Right board.
+		pVeh->m_iBoarding = -2;
+	}
+	else if ( fDot <= -0.5f )
+	{
+		// Left board.
+		pVeh->m_iBoarding = -1;
+	}
+	// Maybe they're trying to board from the back...
+	else
+	{
+		// The forward vector of the vehicle.
+	//	AngleVectors( vVehAngles, vVehDir, NULL, NULL ); 
+	//	VectorNormalize( vVehDir );
+
+		// Find the angle between the vehicle forward and the vehicle to entity vector.
+	//	fDot = DotProduct( vVehToEnt, vVehDir );
+
+		// If the entity is within a certain angle behind the vehicle...
+		//if ( fDot <= -0.85f )
+		{
+			// Jump board.
+			pVeh->m_iBoarding = -3;
+		}
+	}
+
+	// If for some reason we couldn't board, leave...
+	if ( pVeh->m_iBoarding > -1 )
+		return false;
+
+	return true;
+}
+
+// Board this Vehicle (get on). The first entity to board an empty vehicle becomes the Pilot.
+bool Board( Vehicle_t *pVeh, bgEntity_t *pEnt )
+{
+	vec3_t vPlayerDir;
+	gentity_t *ent = (gentity_t *)pEnt;
+	gentity_t *parent = (gentity_t *)pVeh->m_pParentEntity;
+
+	// If it's not a valid entity, OR if the vehicle is blowing up (it's dead), OR it's not
+	// empty, OR we're already being boarded, OR the person trying to get on us is already
+	// in a vehicle (that was a fun bug :-), leave!
+	if ( !ent || parent->health <= 0 /*|| !( parent->client->ps.eFlags & EF_EMPTY_VEHICLE )*/ || (pVeh->m_iBoarding > 0) ||
+#ifdef _JK2MP
+		 ( ent->client->ps.m_iVehicleNum ) )
+#else
+		 ( ent->s.m_iVehicleNum != 0 ) )
+#endif
+		return false;
+
+	// Bucking so we can't do anything (NOTE: Should probably be a better name since fighters don't buck...).
+	if ( pVeh->m_ulFlags & VEH_BUCKING )
+		return false;
+
+	// Validate the entity's ability to board this vehicle.
+	if ( !pVeh->m_pVehicleInfo->ValidateBoard( pVeh, pEnt ) )
+		return false;
+
+	// FIXME FIXME!!! Ask Mike monday where ent->client->ps.eFlags might be getting changed!!! It is always 0 (when it should
+	// be 1024) so a person riding a vehicle is able to ride another vehicle!!!!!!!!
+
+	// Tell everybody their status.
+	// ALWAYS let the player be the pilot.
+	if ( ent->s.number < MAX_CLIENTS )
+	{
+		pVeh->m_pOldPilot = pVeh->m_pPilot;
+
+
+#ifdef _JK2MP
+		if ( !pVeh->m_pPilot )
+		{ //become the pilot, if there isn't one now
+			pVeh->m_pVehicleInfo->SetPilot( pVeh, (bgEntity_t *)ent );
+		}
+		// If we're not yet full...
+		else if ( pVeh->m_iNumPassengers < pVeh->m_pVehicleInfo->maxPassengers )
+		{
+			int i;
+			// Find an empty slot and put that passenger here.
+			for ( i = 0; i < pVeh->m_pVehicleInfo->maxPassengers; i++ )
+			{
+				if ( pVeh->m_ppPassengers[i] == NULL )
+				{
+					pVeh->m_ppPassengers[i] = (bgEntity_t *)ent;
+#ifdef QAGAME
+					//Server just needs to tell client which passengernum he is
+					if ( ent->client )
+					{
+						ent->client->ps.generic1 = i+1;
+					}
+#endif
+					break;
+				}
+			}
+			pVeh->m_iNumPassengers++;
+		}
+		// We're full, sorry...
+		else
+		{
+			return false;
+		}
+		ent->s.m_iVehicleNum = parent->s.number;
+		if (ent->client)
+		{
+			ent->client->ps.m_iVehicleNum = ent->s.m_iVehicleNum;
+		}
+		if ( pVeh->m_pPilot == (bgEntity_t *)ent )
+		{
+			parent->r.ownerNum = ent->s.number;
+			parent->s.owner = parent->r.ownerNum; //for prediction
+		}
+#else
+		pVeh->m_pVehicleInfo->SetPilot( pVeh, ent );
+		ent->s.m_iVehicleNum = parent->s.number;
+		parent->owner = ent;
+#endif
+
+#ifdef QAGAME		
+		{
+			gentity_t *gParent = (gentity_t *)parent;
+			if ( (gParent->spawnflags&2) )
+			{//was being suspended
+				gParent->spawnflags &= ~2;//SUSPENDED - clear this spawnflag, no longer docked, okay to free-fall if not in space
+				//gParent->client->ps.eFlags &= ~EF_RADAROBJECT;
+				G_Sound( gParent, CHAN_AUTO, G_SoundIndex( "sound/vehicles/common/release.wav" ) );
+				if ( gParent->fly_sound_debounce_time )
+				{//we should drop like a rock for a few seconds
+					pVeh->m_iDropTime = level.time + gParent->fly_sound_debounce_time;
+				}
+			}
+		}
+#endif
+
+#ifndef _JK2MP
+		gi.cvar_set( "cg_thirdperson", "1" );								//go to third person
+		CG_CenterPrint( "@SP_INGAME_EXIT_VIEW", SCREEN_HEIGHT * 0.86 );		//tell them how to get out!
+#endif
+
+		//FIXME: rider needs to look in vehicle's direction when he gets in
+		// Clear these since they're used to turn the vehicle now.
+		/*SetClientViewAngle( ent, pVeh->m_vOrientation );
+		memset( &parent->client->usercmd, 0, sizeof( usercmd_t ) );
+		memset( &pVeh->m_ucmd, 0, sizeof( usercmd_t ) );
+		VectorClear( parent->client->ps.viewangles );
+		VectorClear( parent->client->ps.delta_angles );*/
+
+		// Set the looping sound only when there is a pilot (when the vehicle is "on").
+		if ( pVeh->m_pVehicleInfo->soundLoop )
+		{
+#ifdef _JK2MP
+			parent->client->ps.loopSound = parent->s.loopSound = pVeh->m_pVehicleInfo->soundLoop;
+#else
+			parent->s.loopSound = pVeh->m_pVehicleInfo->soundLoop;
+#endif
+		}
+	}
+	else
+	{
+		// If there's no pilot, try to drive this vehicle.
+		if ( pVeh->m_pPilot == NULL )
+		{
+#ifdef _JK2MP
+			pVeh->m_pVehicleInfo->SetPilot( pVeh, (bgEntity_t *)ent );
+			// TODO: Set pilot should do all this stuff....
+			parent->r.ownerNum = ent->s.number;
+			parent->s.owner = parent->r.ownerNum; //for prediction
+#else
+			pVeh->m_pVehicleInfo->SetPilot( pVeh, ent );
+			// TODO: Set pilot should do all this stuff....
+			parent->owner = ent;
+#endif
+			// Set the looping sound only when there is a pilot (when the vehicle is "on").
+			if ( pVeh->m_pVehicleInfo->soundLoop )
+			{
+#ifdef _JK2MP
+				parent->client->ps.loopSound = parent->s.loopSound = pVeh->m_pVehicleInfo->soundLoop;
+#else
+				parent->s.loopSound = pVeh->m_pVehicleInfo->soundLoop;
+#endif
+			}
+
+			parent->client->ps.speed = 0;
+			memset( &pVeh->m_ucmd, 0, sizeof( usercmd_t ) );
+		}
+		// We're full, sorry...
+		else
+		{
+			return false;
+		}
+	}
+	
+	// Make sure the entity knows it's in a vehicle.
+#ifdef _JK2MP
+	ent->client->ps.m_iVehicleNum = parent->s.number;
+	ent->r.ownerNum = parent->s.number;
+	ent->s.owner = ent->r.ownerNum; //for prediction
+	if (pVeh->m_pPilot == (bgEntity_t *)ent)
+	{
+		parent->client->ps.m_iVehicleNum = ent->s.number+1; //always gonna be under MAX_CLIENTS so no worries about 1 byte overflow
+	}
+#else
+	ent->s.m_iVehicleNum = parent->s.number;
+	ent->owner = parent;
+	parent->s.m_iVehicleNum = ent->s.number+1;
+#endif
+
+	//memset( &ent->client->usercmd, 0, sizeof( usercmd_t ) );
+
+	//FIXME: no saber or weapons if numHands = 2, should switch to speeder weapon, no attack anim on player
+	if ( pVeh->m_pVehicleInfo->numHands == 2 )
+	{//switch to vehicle weapon
+#ifndef _JK2MP //rwwFIXMEFIXMEFIXME
+		if (ent->s.number<MAX_CLIENTS)
+		{// Riding means you get WP_NONE
+			ent->client->ps.stats[ STAT_WEAPONS ] |= (1<<WP_NONE);
+		}
+		if ( ent->client->ps.weapon != WP_SABER
+			&& ent->client->ps.weapon != WP_BLASTER )
+		{//switch to weapon none?
+			if (ent->s.number<MAX_CLIENTS)
+			{
+				CG_ChangeWeapon(WP_NONE);
+			}
+			ent->client->ps.weapon = WP_NONE;
+			G_RemoveWeaponModels( ent );
+		}
+#endif
+	}
+
+	if ( pVeh->m_pVehicleInfo->hideRider )
+	{//hide the rider
+		pVeh->m_pVehicleInfo->Ghost( pVeh, (bgEntity_t *)ent );
+	}
+
+	// Play the start sounds
+	if ( pVeh->m_pVehicleInfo->soundOn )
+	{
+#ifdef _JK2MP
+		G_Sound( parent, CHAN_AUTO, pVeh->m_pVehicleInfo->soundOn );
+#else
+		// NOTE: Use this type so it's spatialized and updates play origin as bike moves - MCG
+		G_SoundIndexOnEnt( parent, CHAN_AUTO, pVeh->m_pVehicleInfo->soundOn );
+#endif
+	}
+
+	VectorCopy( pVeh->m_vOrientation, vPlayerDir );
+	vPlayerDir[ROLL] = 0;
+	SetClientViewAngle( ent, vPlayerDir );
+
+	return true;
+}
+
+bool VEH_TryEject( Vehicle_t *pVeh, 
+				  gentity_t *parent, 
+				  gentity_t *ent, 
+				  int ejectDir, 
+				  vec3_t vExitPos )
+{
+	float		fBias;
+	float		fVehDiag;
+	float		fEntDiag;
+	vec3_t		vEntMins, vEntMaxs, vVehLeaveDir, vVehAngles;
+	trace_t		m_ExitTrace;
+
+	// Make sure that the entity is not 'stuck' inside the vehicle (since their bboxes will now intersect).
+	// This makes the entity leave the vehicle from the right side.
+	VectorSet(vVehAngles, 0, parent->currentAngles[YAW], 0);
+	switch ( ejectDir )
+	{
+		// Left.
+		case VEH_EJECT_LEFT:
+			AngleVectors( vVehAngles, NULL, vVehLeaveDir, NULL ); 
+			vVehLeaveDir[0] = -vVehLeaveDir[0];
+			vVehLeaveDir[1] = -vVehLeaveDir[1];
+			vVehLeaveDir[2] = -vVehLeaveDir[2];
+			break;
+		// Right.
+		case VEH_EJECT_RIGHT:
+			AngleVectors( vVehAngles, NULL, vVehLeaveDir, NULL ); 
+			break;
+		// Front.
+		case VEH_EJECT_FRONT:
+			AngleVectors( vVehAngles, vVehLeaveDir, NULL, NULL ); 
+			break;
+		// Rear.
+		case VEH_EJECT_REAR:
+			AngleVectors( vVehAngles, vVehLeaveDir, NULL, NULL ); 
+			vVehLeaveDir[0] = -vVehLeaveDir[0];
+			vVehLeaveDir[1] = -vVehLeaveDir[1];
+			vVehLeaveDir[2] = -vVehLeaveDir[2];
+			break;
+		// Top.
+		case VEH_EJECT_TOP:
+			AngleVectors( vVehAngles, NULL, NULL, vVehLeaveDir ); 
+			break;
+		// Bottom?.
+		case VEH_EJECT_BOTTOM:
+			break;
+	}
+	VectorNormalize( vVehLeaveDir );
+	//NOTE: not sure why following line was needed - MCG
+	//pVeh->m_EjectDir = VEH_EJECT_LEFT;
+
+	// Since (as of this time) the collidable geometry of the entity is just an axis 
+	// aligned box, we need to get the diagonal length of it in case we come out on that side.
+	// Diagonal Length == squareroot( squared( Sidex / 2 ) + squared( Sidey / 2 ) );
+
+	// TODO: DO diagonal for entity.
+
+	fBias = 1.0f;
+	if (pVeh->m_pVehicleInfo->type == VH_WALKER)
+	{ //hacktastic!
+		fBias += 0.2f;
+	}
+	VectorCopy( ent->currentOrigin, vExitPos );
+	fVehDiag = sqrtf( ( parent->maxs[0] * parent->maxs[0] ) + ( parent->maxs[1] * parent->maxs[1] ) );
+	VectorCopy( ent->maxs, vEntMaxs );
+#ifdef _JK2MP
+	if ( ent->s.number < MAX_CLIENTS )
+	{//for some reason, in MP, player client mins and maxs are never stored permanently, just set to these hardcoded numbers in PMove
+		vEntMaxs[0] = 15;
+		vEntMaxs[1] = 15;
+	}
+#endif
+	fEntDiag = sqrtf( ( vEntMaxs[0] * vEntMaxs[0] ) + ( vEntMaxs[1] * vEntMaxs[1] ) );
+	vVehLeaveDir[0] *= ( fVehDiag + fEntDiag ) * fBias;	// x
+	vVehLeaveDir[1] *= ( fVehDiag + fEntDiag ) * fBias;	// y
+	vVehLeaveDir[2] *= ( fVehDiag + fEntDiag ) * fBias;
+	VectorAdd( vExitPos, vVehLeaveDir, vExitPos );
+
+	//we actually could end up *not* getting off if the trace fails...
+	// Check to see if this new position is a valid place for our entity to go.
+#ifdef _JK2MP
+	VectorSet(vEntMins, -15.0f, -15.0f, DEFAULT_MINS_2);
+	VectorSet(vEntMaxs, 15.0f, 15.0f, DEFAULT_MAXS_2);
+#else
+	VectorCopy(ent->mins, vEntMins);
+	VectorCopy(ent->maxs, vEntMaxs);
+#endif
+	G_VehicleTrace( &m_ExitTrace, ent->currentOrigin, vEntMins, vEntMaxs, vExitPos, ent->s.number, ent->clipmask );
+
+	if ( m_ExitTrace.allsolid//in solid
+		|| m_ExitTrace.startsolid)
+	{
+		return false;
+	}
+	// If the trace hit something, we can't go there!
+	if ( m_ExitTrace.fraction < 1.0f )
+	{//not totally clear
+#ifdef _JK2MP
+		if ( (parent->clipmask&ent->r.contents) )//vehicle could actually get stuck on body
+#else
+		if ( (parent->clipmask&ent->contents) )//vehicle could actually get stuck on body
+#endif
+		{//the trace hit the vehicle, don't let them get out, just in case
+			return false;
+		}
+		//otherwise, use the trace.endpos
+		VectorCopy( m_ExitTrace.endpos, vExitPos );
+	}
+	return true;
+}
+
+void G_EjectDroidUnit( Vehicle_t *pVeh, qboolean kill )
+{
+	pVeh->m_pDroidUnit->s.m_iVehicleNum = ENTITYNUM_NONE;
+#ifdef _JK2MP
+	pVeh->m_pDroidUnit->s.owner = ENTITYNUM_NONE;
+#else
+	pVeh->m_pDroidUnit->owner = NULL;
+#endif
+//	pVeh->m_pDroidUnit->s.otherEntityNum2 = ENTITYNUM_NONE;
+#ifdef QAGAME
+	{
+		gentity_t *droidEnt = (gentity_t *)pVeh->m_pDroidUnit;
+		droidEnt->flags &= ~FL_UNDYING;
+		droidEnt->r.ownerNum = ENTITYNUM_NONE;
+		if ( droidEnt->client )
+		{
+			droidEnt->client->ps.m_iVehicleNum = ENTITYNUM_NONE;
+		}
+		if ( kill )
+		{//Kill them, too
+			//FIXME: proper origin, MOD and attacker (for credit/death message)?  Get from vehicle?
+			G_MuteSound(droidEnt->s.number, CHAN_VOICE);
+			G_Damage( droidEnt, NULL, NULL, NULL, droidEnt->s.origin, 10000, 0, MOD_SUICIDE );//FIXME: proper MOD?  Get from vehicle?
+		}
+	}
+#endif
+	pVeh->m_pDroidUnit = NULL;
+}
+
+// Eject the pilot from the vehicle.
+bool Eject( Vehicle_t *pVeh, bgEntity_t *pEnt, qboolean forceEject )
+{
+	gentity_t	*parent;
+	vec3_t		vExitPos;
+#ifndef _JK2MP
+	vec3_t		vPlayerDir;
+#endif
+	gentity_t	*ent = (gentity_t *)pEnt;
+	int			firstEjectDir;
+
+#ifdef _JK2MP
+	qboolean	taintedRider = qfalse;
+	qboolean	deadRider = qfalse;
+
+	if ( pEnt == pVeh->m_pDroidUnit )
+	{
+		G_EjectDroidUnit( pVeh, qfalse );
+		return true;
+	}
+
+	if (ent)
+	{
+		if (!ent->inuse || !ent->client || ent->client->pers.connected != CON_CONNECTED)
+		{
+			taintedRider = qtrue;
+			parent = (gentity_t *)pVeh->m_pParentEntity;
+			goto getItOutOfMe;
+		}
+		else if (ent->health < 1)
+		{
+			deadRider = qtrue;
+		}
+	}
+#endif
+
+	// Validate.
+	if ( !ent )
+	{
+		return false;
+	}
+	if ( !forceEject )
+	{
+		if ( !( pVeh->m_iBoarding == 0 || pVeh->m_iBoarding == -999 || ( pVeh->m_iBoarding < -3 && pVeh->m_iBoarding >= -9 ) ) )
+		{
+#ifdef _JK2MP //I don't care, if he's dead get him off even if he died while boarding
+			deadRider = qtrue;
+			pVeh->m_iBoarding = 0;
+			pVeh->m_bWasBoarding = false;
+#else
+			return false;
+#endif
+		}
+	}
+
+/*#ifndef _JK2MP //rwwFIXMEFIXMEFIXME
+	if (ent->s.number<MAX_CLIENTS)
+	{
+		CG_ChangeWeapon(WP_NONE);
+	}
+	ent->client->ps.weapon = WP_NONE;
+	G_RemoveWeaponModels( ent );
+#endif*/
+
+	parent = (gentity_t *)pVeh->m_pParentEntity;
+
+	//Try ejecting in every direction
+	if ( pVeh->m_EjectDir < VEH_EJECT_LEFT )
+	{
+		pVeh->m_EjectDir = VEH_EJECT_LEFT;
+	}
+	else if ( pVeh->m_EjectDir > VEH_EJECT_BOTTOM )
+	{
+		pVeh->m_EjectDir = VEH_EJECT_BOTTOM;
+	}
+	firstEjectDir = pVeh->m_EjectDir;
+	while ( !VEH_TryEject( pVeh, parent, ent, pVeh->m_EjectDir, vExitPos ) )
+	{
+		pVeh->m_EjectDir++;
+		if ( pVeh->m_EjectDir > VEH_EJECT_BOTTOM )
+		{
+			pVeh->m_EjectDir = VEH_EJECT_LEFT;
+		}
+		if ( pVeh->m_EjectDir == firstEjectDir )
+		{//they all failed
+#ifdef _JK2MP
+			if (!deadRider)
+			{ //if he's dead.. just shove him in solid, who cares.
+				return false;
+			}
+#endif
+			if ( forceEject )
+			{//we want to always get out, just eject him here
+				VectorCopy( ent->currentOrigin, vExitPos );
+				break;
+			}
+			else
+			{//can't eject
+				return false;
+			}
+		}
+	}
+
+	// Move them to the exit position.
+	G_SetOrigin( ent, vExitPos );
+#ifdef _JK2MP
+	VectorCopy(ent->currentOrigin, ent->client->ps.origin);
+	trap_LinkEntity( ent );
+#else
+	gi.linkentity( ent );
+#endif
+
+	// If it's the player, stop overrides.
+	if ( ent->s.number < MAX_CLIENTS )
+	{
+#ifndef _JK2MP
+		cg.overrides.active = 0;
+#else
+
+#endif
+	}
+
+#ifdef _JK2MP //in MP if someone disconnects on us, we still have to clear our owner
+getItOutOfMe:
+#endif
+
+	// If he's the pilot...
+	if ( (gentity_t *)pVeh->m_pPilot == ent )
+	{
+#ifdef _JK2MP
+		int j = 0;
+#endif
+
+		pVeh->m_pPilot = NULL;
+#ifdef _JK2MP
+		parent->r.ownerNum = ENTITYNUM_NONE;
+		parent->s.owner = parent->r.ownerNum; //for prediction
+
+		//keep these current angles
+		//SetClientViewAngle( parent, pVeh->m_vOrientation );
+		memset( &parent->client->pers.cmd, 0, sizeof( usercmd_t ) );
+#else
+		parent->owner = NULL;
+
+		//keep these current angles
+		//SetClientViewAngle( parent, pVeh->m_vOrientation );
+		memset( &parent->client->usercmd, 0, sizeof( usercmd_t ) );
+#endif
+		memset( &pVeh->m_ucmd, 0, sizeof( usercmd_t ) );
+
+#ifdef _JK2MP //if there are some passengers, promote the first passenger to pilot
+		while (j < pVeh->m_iNumPassengers)
+		{
+			if (pVeh->m_ppPassengers[j])
+			{
+				int k = 1;
+				pVeh->m_pVehicleInfo->SetPilot( pVeh, pVeh->m_ppPassengers[j] );
+				parent->r.ownerNum = pVeh->m_ppPassengers[j]->s.number;
+				parent->s.owner = parent->r.ownerNum; //for prediction
+				parent->client->ps.m_iVehicleNum = pVeh->m_ppPassengers[j]->s.number+1;
+
+				//rearrange the passenger slots now..
+#ifdef QAGAME
+				//Server just needs to tell client he's not a passenger anymore
+				if ( ((gentity_t *)pVeh->m_ppPassengers[j])->client )
+				{
+					((gentity_t *)pVeh->m_ppPassengers[j])->client->ps.generic1 = 0;
+				}
+#endif
+				pVeh->m_ppPassengers[j] = NULL;
+				while (k < pVeh->m_iNumPassengers)
+				{
+					if (!pVeh->m_ppPassengers[k-1])
+					{ //move down
+						pVeh->m_ppPassengers[k-1] = pVeh->m_ppPassengers[k];
+						pVeh->m_ppPassengers[k] = NULL;
+#ifdef QAGAME
+						//Server just needs to tell client which passenger he is
+						if ( ((gentity_t *)pVeh->m_ppPassengers[k-1])->client )
+						{
+							((gentity_t *)pVeh->m_ppPassengers[k-1])->client->ps.generic1 = k;
+						}
+#endif
+					}
+					k++;
+				}
+				pVeh->m_iNumPassengers--;
+
+				break;
+			}
+			j++;
+		}
+#endif
+	}
+	else if (ent==(gentity_t *)pVeh->m_pOldPilot)
+	{
+		pVeh->m_pOldPilot = 0;
+	}
+
+#ifdef _JK2MP //I hate adding these!
+	if (!taintedRider)
+	{
+#endif
+		if ( pVeh->m_pVehicleInfo->hideRider )
+		{
+			pVeh->m_pVehicleInfo->UnGhost( pVeh, (bgEntity_t *)ent );
+		}
+#ifdef _JK2MP
+	}
+#endif
+
+	// If the vehicle now has no pilot...
+	if ( pVeh->m_pPilot == NULL  )
+	{
+#ifdef _JK2MP
+		parent->client->ps.loopSound = parent->s.loopSound = 0;
+#else
+		parent->s.loopSound = 0;
+#endif
+		// Completely empty vehicle...?
+#ifdef _JK2MP
+		parent->client->ps.m_iVehicleNum = 0;
+#else
+		parent->s.m_iVehicleNum = 0;
+#endif
+	}
+
+#ifdef _JK2MP
+	if (taintedRider)
+	{ //you can go now
+		pVeh->m_iBoarding = level.time + 1000;
+		return true;
+	}
+#endif
+
+	// Client not in a vehicle.
+#ifdef _JK2MP
+	ent->client->ps.m_iVehicleNum = 0;
+	ent->r.ownerNum = ENTITYNUM_NONE;
+	ent->s.owner = ent->r.ownerNum; //for prediction
+
+	ent->client->ps.viewangles[PITCH] = 0.0f;
+	ent->client->ps.viewangles[ROLL] = 0.0f;
+	ent->client->ps.viewangles[YAW] = pVeh->m_vOrientation[YAW];
+	SetClientViewAngle(ent, ent->client->ps.viewangles);
+
+	if (ent->client->solidHack)
+	{
+		ent->client->solidHack = 0;
+		ent->r.contents = CONTENTS_BODY;
+	}
+#else
+	ent->owner = NULL;	
+#endif
+	ent->s.m_iVehicleNum = 0;
+
+	// Jump out.
+/*	if ( ent->client->ps.velocity[2] < JUMP_VELOCITY )
+	{
+		ent->client->ps.velocity[2] = JUMP_VELOCITY;
+	}
+	else
+	{
+		ent->client->ps.velocity[2] += JUMP_VELOCITY;
+	}*/
+
+	// Make sure entity is facing the direction it got off at.
+#ifndef _JK2MP
+	VectorCopy( pVeh->m_vOrientation, vPlayerDir );
+	vPlayerDir[ROLL] = 0;
+	SetClientViewAngle( ent, vPlayerDir );
+#endif
+
+	//if was using vehicle weapon, remove it and switch to normal weapon when hop out...
+	if ( ent->client->ps.weapon == WP_NONE )
+	{//FIXME: check against this vehicle's gun from the g_vehicleInfo table
+		//remove the vehicle's weapon from me
+		//ent->client->ps.stats[STAT_WEAPONS] &= ~( 1 << WP_EMPLACED_GUN );
+		//ent->client->ps.ammo[weaponData[WP_EMPLACED_GUN].ammoIndex] = 0;//maybe store this ammo on the vehicle before clearing it?
+		//switch back to a normal weapon we're carrying
+		
+		//FIXME: store the weapon we were using when we got on and restore that when hop off
+/*		if ( (ent->client->ps.stats[STAT_WEAPONS]&(1<<WP_SABER)) )
+		{
+			CG_ChangeWeapon( WP_SABER );
+		}
+		else
+		{//go through all weapons and switch to highest held
+			for ( int checkWp = WP_NUM_WEAPONS-1; checkWp > WP_NONE; checkWp-- )
+			{
+				if ( (ent->client->ps.stats[STAT_WEAPONS]&(1<<checkWp)) )
+				{
+					CG_ChangeWeapon( checkWp );
+				}
+			}
+			if ( checkWp == WP_NONE )
+			{
+				CG_ChangeWeapon( WP_NONE );
+			}
+		}*/
+	}
+	else
+	{//FIXME: if they have their saber out:
+		//if dualSabers, add the second saber into the left hand
+		//saber[0] has more than one blade, turn them all on
+		//NOTE: this is because you're only allowed to use your first saber's first blade on a vehicle
+	}
+
+/*	if ( !ent->s.number && ent->client->ps.weapon != WP_SABER 
+		&& cg_gunAutoFirst.value )
+	{
+		gi.cvar_set( "cg_thirdperson", "0" );
+	}*/
+#ifdef _JK2MP
+	BG_SetLegsAnimTimer( &ent->client->ps, 0 );
+	BG_SetTorsoAnimTimer( &ent->client->ps, 0 );
+#else
+	PM_SetLegsAnimTimer( ent, &ent->client->ps.legsAnimTimer, 0 );
+	PM_SetTorsoAnimTimer( ent, &ent->client->ps.torsoAnimTimer, 0 );
+#endif
+
+	// Set how long until this vehicle can be boarded again.
+	pVeh->m_iBoarding = level.time + 1000;
+
+	return true;
+}
+
+// Eject all the inhabitants of this vehicle.
+bool EjectAll( Vehicle_t *pVeh )
+{
+	// TODO: Setup a default escape for ever vehicle type.
+
+	pVeh->m_EjectDir = VEH_EJECT_TOP;
+	// Make sure no other boarding calls exist. We MUST exit.
+	pVeh->m_iBoarding = 0;
+	pVeh->m_bWasBoarding = false;
+
+	// Throw them off.
+	if ( pVeh->m_pPilot )
+	{
+#ifdef QAGAME
+		gentity_t *pilot = (gentity_t*)pVeh->m_pPilot;
+#endif
+		pVeh->m_pVehicleInfo->Eject( pVeh, pVeh->m_pPilot, qtrue );
+#ifdef QAGAME
+		if ( pVeh->m_pVehicleInfo->killRiderOnDeath && pilot )
+		{//Kill them, too
+			//FIXME: proper origin, MOD and attacker (for credit/death message)?  Get from vehicle?
+			G_MuteSound(pilot->s.number, CHAN_VOICE);
+			G_Damage( pilot, player, player, NULL, pilot->s.origin, 10000, 0, MOD_SUICIDE );
+		}
+#endif
+	}
+	if ( pVeh->m_pOldPilot )
+	{
+#ifdef QAGAME
+		gentity_t *pilot = (gentity_t*)pVeh->m_pOldPilot;
+#endif
+		pVeh->m_pVehicleInfo->Eject( pVeh, pVeh->m_pOldPilot, qtrue );
+#ifdef QAGAME
+		if ( pVeh->m_pVehicleInfo->killRiderOnDeath && pilot )
+		{//Kill them, too
+			//FIXME: proper origin, MOD and attacker (for credit/death message)?  Get from vehicle?
+			G_MuteSound(pilot->s.number, CHAN_VOICE);
+			G_Damage( pilot, player, player, NULL, pilot->s.origin, 10000, 0, MOD_SUICIDE );
+		}
+#endif
+	}
+	
+	if ( pVeh->m_pDroidUnit )
+	{
+		G_EjectDroidUnit( pVeh, pVeh->m_pVehicleInfo->killRiderOnDeath );
+	}
+
+	return true;
+}
+
+// Start a delay until the vehicle explodes.
+static void StartDeathDelay( Vehicle_t *pVeh, int iDelayTimeOverride )
+{
+	gentity_t *parent = (gentity_t *)pVeh->m_pParentEntity;
+
+	if ( iDelayTimeOverride )
+	{
+		pVeh->m_iDieTime = level.time + iDelayTimeOverride;
+	}
+	else
+	{
+		pVeh->m_iDieTime = level.time + pVeh->m_pVehicleInfo->explosionDelay;
+	}
+
+#ifdef _JK2MP
+	if ( pVeh->m_pVehicleInfo->flammable )
+	{
+		parent->client->ps.loopSound = parent->s.loopSound = G_SoundIndex( "sound/vehicles/common/fire_lp.wav" );
+	}
+#else
+	// Armor Gone Effects (Fire)
+	//---------------------------
+	if (pVeh->m_pVehicleInfo->iArmorGoneFX)
+	{
+		if (!(pVeh->m_ulFlags&VEH_ARMORGONE) && (pVeh->m_iArmor <= 0))
+		{
+			pVeh->m_ulFlags |= VEH_ARMORGONE;
+			G_PlayEffect(pVeh->m_pVehicleInfo->iArmorGoneFX, parent->playerModel, parent->crotchBolt, parent->s.number, parent->currentOrigin, 1, qtrue);
+			parent->s.loopSound = G_SoundIndex( "sound/vehicles/common/fire_lp.wav" );
+		}
+	}
+#endif
+}
+
+// Decide whether to explode the vehicle or not.
+static void DeathUpdate( Vehicle_t *pVeh )
+{
+	gentity_t *parent = (gentity_t *)pVeh->m_pParentEntity;
+
+	if ( level.time >= pVeh->m_iDieTime )
+	{
+		// If the vehicle is not empty.
+		if ( pVeh->m_pVehicleInfo->Inhabited( pVeh ) )
+		{
+#ifndef _JK2MP
+			if (pVeh->m_pPilot)
+			{
+				pVeh->m_pPilot->client->noRagTime = -1;		// no ragdoll for you
+			}
+#endif
+
+			pVeh->m_pVehicleInfo->EjectAll( pVeh );
+#ifdef _JK2MP
+			if ( pVeh->m_pVehicleInfo->Inhabited( pVeh ) )
+			{ //if we've still got people in us, just kill the bastards
+				if ( pVeh->m_pPilot )
+				{
+					//FIXME: does this give proper credit to the enemy who shot you down?
+					G_Damage((gentity_t *)pVeh->m_pPilot, (gentity_t *)pVeh->m_pParentEntity, (gentity_t *)pVeh->m_pParentEntity,
+						NULL, pVeh->m_pParentEntity->playerState->origin, 999, DAMAGE_NO_PROTECTION, MOD_EXPLOSIVE);
+				}
+				if ( pVeh->m_iNumPassengers )
+				{
+					int i;
+
+					for ( i = 0; i < pVeh->m_pVehicleInfo->maxPassengers; i++ )
+					{
+						if ( pVeh->m_ppPassengers[i] )
+						{
+							//FIXME: does this give proper credit to the enemy who shot you down?
+							G_Damage((gentity_t *)pVeh->m_ppPassengers[i], (gentity_t *)pVeh->m_pParentEntity, (gentity_t *)pVeh->m_pParentEntity,
+								NULL, pVeh->m_pParentEntity->playerState->origin, 999, DAMAGE_NO_PROTECTION, MOD_EXPLOSIVE);
+						}
+					}
+				}				
+			}
+#endif
+		}
+
+		if ( !pVeh->m_pVehicleInfo->Inhabited( pVeh ) )
+		{ //explode now as long as we managed to kick everyone out
+			vec3_t	lMins, lMaxs, bottom;
+			trace_t	trace;
+
+
+#ifndef _JK2MP
+			// Kill All Client Side Looping Effects
+			//--------------------------------------
+			if (pVeh->m_pVehicleInfo->iExhaustFX)
+			{
+				for (int i=0; (i<MAX_VEHICLE_EXHAUSTS && pVeh->m_iExhaustTag[i]!=-1); i++)
+				{
+					G_StopEffect(pVeh->m_pVehicleInfo->iExhaustFX, parent->playerModel, pVeh->m_iExhaustTag[i], parent->s.number);
+				}
+			}
+			if (pVeh->m_pVehicleInfo->iArmorLowFX)
+			{
+				G_StopEffect(pVeh->m_pVehicleInfo->iArmorLowFX,  parent->playerModel, parent->crotchBolt, parent->s.number);
+			}
+			if (pVeh->m_pVehicleInfo->iArmorGoneFX)
+			{
+				G_StopEffect(pVeh->m_pVehicleInfo->iArmorGoneFX, parent->playerModel, parent->crotchBolt, parent->s.number);
+			}
+			//--------------------------------------
+#endif
+			if ( pVeh->m_pVehicleInfo->iExplodeFX )
+			{
+#ifdef _JK2MP
+				vec3_t fxAng;
+
+				VectorSet(fxAng, -90.0f, 0.0f, 0.0f);
+				G_PlayEffectID( pVeh->m_pVehicleInfo->iExplodeFX, parent->currentOrigin, fxAng );
+#else
+				G_PlayEffect( pVeh->m_pVehicleInfo->iExplodeFX, parent->currentOrigin, vec3_origin );
+#endif
+				//trace down and place mark
+				VectorCopy( parent->currentOrigin, bottom );
+				bottom[2] -= 80;
+				G_VehicleTrace( &trace, parent->currentOrigin, vec3_origin, vec3_origin, bottom, parent->s.number, CONTENTS_SOLID );
+				if ( trace.fraction < 1.0f )
+				{
+					VectorCopy( trace.endpos, bottom );
+					bottom[2] += 2;
+#ifdef _JK2MP
+					VectorSet(fxAng, -90.0f, 0.0f, 0.0f);
+					G_PlayEffectID( G_EffectIndex("ships/ship_explosion_mark"), trace.endpos, fxAng );
+#else
+					G_PlayEffect( "ships/ship_explosion_mark", trace.endpos );
+#endif
+				}
+			}
+
+			parent->takedamage = qfalse;//so we don't recursively damage ourselves
+			if ( pVeh->m_pVehicleInfo->explosionRadius > 0 && pVeh->m_pVehicleInfo->explosionDamage > 0 )
+			{
+				VectorCopy( parent->mins, lMins );
+				lMins[2] = -4;//to keep it off the ground a *little*
+				VectorCopy( parent->maxs, lMaxs );
+				VectorCopy( parent->currentOrigin, bottom );
+				bottom[2] += parent->mins[2] - 32;
+				G_VehicleTrace( &trace, parent->currentOrigin, lMins, lMaxs, bottom, parent->s.number, CONTENTS_SOLID );
+#ifdef _JK2MP
+				G_RadiusDamage( trace.endpos, NULL, pVeh->m_pVehicleInfo->explosionDamage, pVeh->m_pVehicleInfo->explosionRadius, NULL, NULL, MOD_EXPLOSIVE );//FIXME: extern damage and radius or base on fuel
+#else
+				G_RadiusDamage( trace.endpos, player, pVeh->m_pVehicleInfo->explosionDamage, pVeh->m_pVehicleInfo->explosionRadius, NULL, MOD_EXPLOSIVE );//FIXME: extern damage and radius or base on fuel
+#endif
+			}
+
+#ifdef _JK2MP
+			parent->think = G_FreeEntity;
+#else
+			parent->e_ThinkFunc = thinkF_G_FreeEntity;
+#endif
+			parent->nextthink = level.time + FRAMETIME;
+		}
+	}
+#ifndef _JK2MP
+	else
+	{//let everyone around me know I'm gonna blow!
+		if ( !Q_irand( 0, 10 ) )
+		{//not so often...
+			AddSoundEvent( parent, parent->currentOrigin, 512, AEL_DANGER );
+			AddSightEvent( parent, parent->currentOrigin, 512, AEL_DANGER, 100 );
+		}
+	}
+#endif
+}
+
+// Register all the assets used by this vehicle.
+void RegisterAssets( Vehicle_t *pVeh )
+{
+}
+
+extern void ChangeWeapon( gentity_t *ent, int newWeapon );
+
+// Initialize the vehicle.
+bool Initialize( Vehicle_t *pVeh )
+{
+	gentity_t *parent = (gentity_t *)pVeh->m_pParentEntity;
+	int i = 0;
+
+	if ( !parent || !parent->client )
+		return false;
+
+#ifdef _JK2MP
+	parent->client->ps.m_iVehicleNum = 0;
+#endif
+	parent->s.m_iVehicleNum = 0;
+	{
+	pVeh->m_iArmor = pVeh->m_pVehicleInfo->armor;
+	parent->client->pers.maxHealth = parent->client->ps.stats[STAT_MAX_HEALTH] = parent->NPC->stats.health = parent->health = parent->client->ps.stats[STAT_HEALTH] = pVeh->m_iArmor;
+	pVeh->m_iShields = pVeh->m_pVehicleInfo->shields;
+#ifdef _JK2MP
+	G_VehUpdateShields( parent );
+#endif
+	parent->client->ps.stats[STAT_ARMOR] = pVeh->m_iShields;
+	}
+	parent->mass = pVeh->m_pVehicleInfo->mass;
+	//initialize the ammo to max
+	for ( i = 0; i < MAX_VEHICLE_WEAPONS; i++ )
+	{
+		parent->client->ps.ammo[i] = pVeh->weaponStatus[i].ammo = pVeh->m_pVehicleInfo->weapon[i].ammoMax;
+	}
+	for ( i = 0; i < MAX_VEHICLE_TURRETS; i++ )
+	{
+		pVeh->turretStatus[i].nextMuzzle = (pVeh->m_pVehicleInfo->turret[i].iMuzzle[i]-1);
+		parent->client->ps.ammo[MAX_VEHICLE_WEAPONS+i] = pVeh->turretStatus[i].ammo = pVeh->m_pVehicleInfo->turret[i].iAmmoMax;
+		if ( pVeh->m_pVehicleInfo->turret[i].bAI )
+		{//they're going to be finding enemies, init this to NONE
+			pVeh->turretStatus[i].enemyEntNum = ENTITYNUM_NONE;
+		}
+	}
+	//begin stopped...?
+	parent->client->ps.speed = 0; 
+	
+	VectorClear( pVeh->m_vOrientation );
+	pVeh->m_vOrientation[YAW] = parent->s.angles[YAW];
+
+#ifdef _JK2MP
+	if ( pVeh->m_pVehicleInfo->gravity &&
+		pVeh->m_pVehicleInfo->gravity != g_gravity.value )
+	{//not normal gravity
+		if ( parent->NPC )
+		{
+			parent->NPC->aiFlags |= NPCAI_CUSTOM_GRAVITY;
+		}
+		parent->client->ps.gravity = pVeh->m_pVehicleInfo->gravity;
+	}
+#else
+	if ( pVeh->m_pVehicleInfo->gravity &&
+		pVeh->m_pVehicleInfo->gravity != g_gravity->value )
+	{//not normal gravity
+		parent->svFlags |= SVF_CUSTOM_GRAVITY;
+		parent->client->ps.gravity = pVeh->m_pVehicleInfo->gravity;
+	}
+#endif
+
+	/*
+	if ( pVeh->m_iVehicleTypeID == VH_FIGHTER )
+	{
+		pVeh->m_ulFlags = VEH_GEARSOPEN;
+	}
+	else
+	*/
+	//why?! -rww
+	{
+		pVeh->m_ulFlags = 0;
+	}
+	pVeh->m_fTimeModifier = 1.0f;
+	pVeh->m_iBoarding = 0;
+	pVeh->m_bWasBoarding = false;
+	pVeh->m_pOldPilot = NULL;
+	VectorClear(pVeh->m_vBoardingVelocity);
+	pVeh->m_pPilot = NULL;
+	memset( &pVeh->m_ucmd, 0, sizeof( usercmd_t ) );
+	pVeh->m_iDieTime = 0;
+	pVeh->m_EjectDir = VEH_EJECT_LEFT;
+
+	//pVeh->m_iDriverTag = -1;
+	//pVeh->m_iLeftExhaustTag = -1;
+	//pVeh->m_iRightExhaustTag = -1;
+	//pVeh->m_iGun1Tag = -1;
+	//pVeh->m_iGun1Bone = -1;
+	//pVeh->m_iLeftWingBone = -1;
+	//pVeh->m_iRightWingBone = -1;
+	memset( pVeh->m_iExhaustTag, -1, sizeof( int ) * MAX_VEHICLE_EXHAUSTS );
+	memset( pVeh->m_iMuzzleTag, -1, sizeof( int ) * MAX_VEHICLE_MUZZLES );
+	// FIXME! Use external values read from the vehicle data file!
+#ifndef _JK2MP //blargh, fixme
+	memset( pVeh->m_Muzzles, 0, sizeof( Muzzle ) * MAX_VEHICLE_MUZZLES );
+#endif
+	pVeh->m_iDroidUnitTag = -1;
+
+	//initialize to blaster, just since it's a basic weapon and there's no lightsaber crap...?
+	parent->client->ps.weapon = WP_BLASTER;
+	parent->client->ps.weaponstate = WEAPON_READY;
+	parent->client->ps.stats[STAT_WEAPONS] |= (1<<WP_BLASTER);
+
+	//Initialize to landed (wings closed, gears down) animation
+	{
+		int iFlags = SETANIM_FLAG_NORMAL, iBlend = 300;
+#ifdef _JK2MP
+		pVeh->m_ulFlags |= VEH_GEARSOPEN;
+		BG_SetAnim(pVeh->m_pParentEntity->playerState, 
+			bgAllAnims[pVeh->m_pParentEntity->localAnimIndex].anims,
+			SETANIM_BOTH, BOTH_VS_IDLE, iFlags, iBlend);
+#else
+		NPC_SetAnim( pVeh->m_pParentEntity, SETANIM_BOTH, BOTH_VS_IDLE, iFlags, iBlend );
+#endif
+	}
+
+	return true;
+}
+
+
+
+// Like a think or move command, this updates various vehicle properties.
+#ifdef _JK2MP
+void G_VehicleDamageBoxSizing(Vehicle_t *pVeh); //declared below
+#endif
+static bool Update( Vehicle_t *pVeh, const usercmd_t *pUmcd )
+{
+	gentity_t *parent = (gentity_t *)pVeh->m_pParentEntity;
+	gentity_t *pilotEnt;
+	//static float fMod = 1000.0f / 60.0f;
+	vec3_t vVehAngles;
+	int i;
+	int	prevSpeed;
+	int	nextSpeed;
+	int	curTime;
+	int halfMaxSpeed;
+	playerState_t *parentPS;
+	qboolean linkHeld = qfalse;
+
+
+#ifdef _JK2MP
+	parentPS =  pVeh->m_pParentEntity->playerState;
+#else
+	parentPS = &pVeh->m_pParentEntity->client->ps;
+#endif
+
+#ifndef _JK2MP//SP
+	curTime = level.time;
+#elif QAGAME//MP GAME
+	curTime = level.time;
+#elif CGAME//MP CGAME
+	//FIXME: pass in ucmd?  Not sure if this is reliable...
+	curTime = pm->cmd.serverTime;
+#endif
+
+	//increment the ammo for all rechargeable weapons
+	for ( i = 0; i < MAX_VEHICLE_WEAPONS; i++ )
+	{
+		if ( pVeh->m_pVehicleInfo->weapon[i].ID > VEH_WEAPON_BASE//have a weapon in this slot
+			&& pVeh->m_pVehicleInfo->weapon[i].ammoRechargeMS//its ammo is rechargable
+			&& pVeh->weaponStatus[i].ammo < pVeh->m_pVehicleInfo->weapon[i].ammoMax//its ammo is below max
+			&& pUmcd->serverTime-pVeh->weaponStatus[i].lastAmmoInc >= pVeh->m_pVehicleInfo->weapon[i].ammoRechargeMS )//enough time has passed
+		{//add 1 to the ammo
+			pVeh->weaponStatus[i].lastAmmoInc = pUmcd->serverTime;
+			pVeh->weaponStatus[i].ammo++;
+			//NOTE: in order to send the vehicle's ammo info to the client, we copy the ammo into the first 2 ammo slots on the vehicle NPC's client->ps.ammo array
+			if ( parent && parent->client )
+			{
+				parent->client->ps.ammo[i] = pVeh->weaponStatus[i].ammo;
+			}
+		}
+	}
+	for ( i = 0; i < MAX_VEHICLE_TURRETS; i++ )
+	{
+		if ( pVeh->m_pVehicleInfo->turret[i].iWeapon > VEH_WEAPON_BASE//have a weapon in this slot
+			&& pVeh->m_pVehicleInfo->turret[i].iAmmoRechargeMS//its ammo is rechargable
+			&& pVeh->turretStatus[i].ammo < pVeh->m_pVehicleInfo->turret[i].iAmmoMax//its ammo is below max
+			&& pUmcd->serverTime-pVeh->turretStatus[i].lastAmmoInc >= pVeh->m_pVehicleInfo->turret[i].iAmmoRechargeMS )//enough time has passed
+		{//add 1 to the ammo
+			pVeh->turretStatus[i].lastAmmoInc = pUmcd->serverTime;
+			pVeh->turretStatus[i].ammo++;
+			//NOTE: in order to send the vehicle's ammo info to the client, we copy the ammo into the first 2 ammo slots on the vehicle NPC's client->ps.ammo array
+			if ( parent && parent->client )
+			{
+				parent->client->ps.ammo[MAX_VEHICLE_WEAPONS+i] = pVeh->turretStatus[i].ammo;
+			}
+		}
+	}
+
+	//increment shields for rechargable shields
+	if ( pVeh->m_pVehicleInfo->shieldRechargeMS
+		&& parentPS->stats[STAT_ARMOR] > 0 //still have some shields left
+		&& parentPS->stats[STAT_ARMOR] < pVeh->m_pVehicleInfo->shields//its below max
+		&& pUmcd->serverTime-pVeh->lastShieldInc >= pVeh->m_pVehicleInfo->shieldRechargeMS )//enough time has passed
+	{
+		parentPS->stats[STAT_ARMOR]++;
+		if ( parentPS->stats[STAT_ARMOR] > pVeh->m_pVehicleInfo->shields )
+		{
+			parentPS->stats[STAT_ARMOR] = pVeh->m_pVehicleInfo->shields;
+		}
+		pVeh->m_iShields = parentPS->stats[STAT_ARMOR];
+#ifdef _JK2MP
+		G_VehUpdateShields( parent );
+#endif
+	}
+
+#ifdef _JK2MP //sometimes this gets out of whack, probably init'ing
+	if (parent && parent->r.ownerNum != parent->s.owner)
+	{
+		parent->s.owner = parent->r.ownerNum;
+	}
+
+	//keep the PS value in sync. set it up here in case we return below at some point.
+	if (pVeh->m_iBoarding)
+	{
+		parent->client->ps.vehBoarding = qtrue;
+	}
+	else
+	{
+		parent->client->ps.vehBoarding = qfalse;
+	}
+#endif
+
+	// See whether this vehicle should be dieing or dead.
+	if ( pVeh->m_iDieTime != 0 
+#ifndef _JK2MP //sometimes this gets out of whack, probably init'ing
+		|| (parent->health <= 0)
+#endif
+		)
+	{//NOTE!!!: This HAS to be consistent with cgame!!!
+		// Keep track of the old orientation.
+		VectorCopy( pVeh->m_vOrientation, pVeh->m_vPrevOrientation );
+
+		// Process the orient commands.
+		pVeh->m_pVehicleInfo->ProcessOrientCommands( pVeh );
+		// Need to copy orientation to our entity's viewangles so that it renders at the proper angle and currentAngles is correct.
+		SetClientViewAngle( parent, pVeh->m_vOrientation ); 
+		if ( pVeh->m_pPilot )
+		{
+			SetClientViewAngle( (gentity_t *)pVeh->m_pPilot, pVeh->m_vOrientation );
+		}
+		/*
+		for ( i = 0; i < pVeh->m_pVehicleInfo->maxPassengers; i++ )
+		{
+			if ( pVeh->m_ppPassengers[i] )
+			{
+				SetClientViewAngle( (gentity_t *)pVeh->m_ppPassengers[i], pVeh->m_vOrientation );
+			}
+		}
+		*/
+
+		// Process the move commands.
+		pVeh->m_pVehicleInfo->ProcessMoveCommands( pVeh );
+
+		// Setup the move direction.
+		if ( pVeh->m_pVehicleInfo->type == VH_FIGHTER )
+		{
+			AngleVectors( pVeh->m_vOrientation, parent->client->ps.moveDir, NULL, NULL ); 
+		}
+		else
+		{
+			VectorSet(vVehAngles, 0, pVeh->m_vOrientation[YAW], 0);
+			AngleVectors( vVehAngles, parent->client->ps.moveDir, NULL, NULL ); 
+		}
+		pVeh->m_pVehicleInfo->DeathUpdate( pVeh );
+		return false;
+	}
+	// Vehicle dead!
+
+#ifdef _JK2MP
+	else if ( parent->health <= 0 )
+	{
+		// Instant kill.
+		if (pVeh->m_pVehicleInfo->type == VH_FIGHTER &&
+			pVeh->m_iLastImpactDmg > 500)
+		{ //explode instantly in inferno-y death
+			pVeh->m_pVehicleInfo->StartDeathDelay( pVeh, -1/* -1 causes instant death */);
+		}
+		else
+		{
+			pVeh->m_pVehicleInfo->StartDeathDelay( pVeh, 0 );
+		}
+		pVeh->m_pVehicleInfo->DeathUpdate( pVeh );
+		return false;
+	}
+#endif
+	
+#ifdef _JK2MP //special check in case someone disconnects/dies while boarding
+#ifdef QAGAME
+	if (parent->spawnflags & 1)
+	{
+		if (pVeh->m_pPilot || !pVeh->m_bHasHadPilot)
+		{
+			if (pVeh->m_pPilot && !pVeh->m_bHasHadPilot)
+			{
+				pVeh->m_bHasHadPilot = qtrue;
+				pVeh->m_iPilotLastIndex = pVeh->m_pPilot->s.number;
+			}
+			pVeh->m_iPilotTime = level.time + parent->damage;
+		}
+		else if (pVeh->m_iPilotTime)
+		{ //die
+			gentity_t *oldPilot = &g_entities[pVeh->m_iPilotLastIndex];
+
+			if (!oldPilot->inuse || !oldPilot->client ||
+				oldPilot->client->pers.connected != CON_CONNECTED)
+			{ //no longer in the game?
+				G_Damage(parent, parent, parent, NULL, parent->client->ps.origin, 99999, DAMAGE_NO_PROTECTION, MOD_SUICIDE);
+			}
+			else
+			{
+				vec3_t v;
+				VectorSubtract(parent->client->ps.origin, oldPilot->client->ps.origin, v);
+
+				if (VectorLength(v) < parent->speed)
+				{ //they are still within the minimum distance to their vehicle
+					pVeh->m_iPilotTime = level.time + parent->damage;
+				}
+				else if (pVeh->m_iPilotTime < level.time)
+				{ //dying time
+					G_Damage(parent, parent, parent, NULL, parent->client->ps.origin, 99999, DAMAGE_NO_PROTECTION, MOD_SUICIDE);
+				}
+			}
+		}
+	}
+#endif
+#else
+	if (parent->spawnflags & 1)
+	{//NOTE: in SP, this actually just checks LOS to the Player
+		if (pVeh->m_iPilotTime < level.time)
+		{//do another check?
+			if ( !player || G_ClearLineOfSight(pVeh->m_pParentEntity->currentOrigin, player->currentOrigin, pVeh->m_pParentEntity->s.number, MASK_OPAQUE ) )
+			{
+				pVeh->m_iPilotTime = level.time + pVeh->m_pParentEntity->endFrame;
+			}
+		}
+		if (pVeh->m_iPilotTime && pVeh->m_iPilotTime < level.time)
+		{ //die
+			//FIXME: does this give proper credit to the enemy who shot you down?
+            G_Damage(parent, player, player, NULL, parent->client->ps.origin, 99999, DAMAGE_NO_PROTECTION, MOD_SUICIDE);
+		}
+	}
+#endif
+
+#ifndef _JK2MP
+//	if (level.time<pVeh->m_iTurboTime || pVeh->m_pVehicleInfo->type==VH_ANIMAL)
+	// always knock guys around now...
+	{
+		vec3_t	dir;						
+		vec3_t	projectedPosition;
+		VectorCopy(parent->client->ps.velocity, dir);
+		VectorMA(parent->currentOrigin, 0.1f, dir, projectedPosition);
+
+		float	force = VectorNormalize(dir);
+		force /= 10.0f;
+		if (force>30.0f)
+		{
+			trace_t	tr;
+			G_VehicleTrace(&tr, parent->currentOrigin, parent->mins, parent->maxs, projectedPosition, parent->s.number, CONTENTS_BODY);
+			if (tr.fraction<1.0f && 
+				!tr.allsolid && 
+				!tr.startsolid && 
+				tr.entityNum!=ENTITYNUM_NONE && 
+				tr.entityNum!=ENTITYNUM_WORLD &&
+				(level.time<pVeh->m_iTurboTime || Q_irand(0,3)==0))
+			{
+				gentity_t*	other = &g_entities[tr.entityNum];
+				if (other && other->client && !other->s.m_iVehicleNum)
+				{
+					G_Throw( other, dir, force/10.0f );
+					G_Knockdown( other, parent, dir, force, qtrue );
+					G_Damage( other, player, player, parent->client->ps.velocity, parent->currentOrigin, force, DAMAGE_NO_ARMOR|DAMAGE_EXTRA_KNOCKBACK, MOD_IMPACT);
+				}
+			}
+		}
+	}
+#endif
+
+#ifdef _JK2MP //special check in case someone disconnects/dies while boarding
+	if (pVeh->m_iBoarding != 0)
+	{
+		pilotEnt = (gentity_t *)pVeh->m_pPilot;
+		if (pilotEnt)
+		{
+			if (!pilotEnt->inuse || !pilotEnt->client || pilotEnt->health <= 0 ||
+				pilotEnt->client->pers.connected != CON_CONNECTED)
+			{
+				pVeh->m_pVehicleInfo->Eject( pVeh, pVeh->m_pPilot, qtrue );
+				return false;
+			}
+		}
+	}
+#endif
+
+	// If we're not done mounting, can't do anything.
+	if ( pVeh->m_iBoarding != 0 )
+	{
+		if (!pVeh->m_bWasBoarding)
+		{
+			VectorCopy(parentPS->velocity, pVeh->m_vBoardingVelocity);
+			pVeh->m_bWasBoarding = true;
+		}
+
+		// See if we're done boarding.
+		if ( pVeh->m_iBoarding > -1 && pVeh->m_iBoarding <= level.time )
+		{
+			pVeh->m_bWasBoarding = false;
+			pVeh->m_iBoarding = 0;
+		}
+		else
+		{
+#ifdef _JK2MP
+			goto maintainSelfDuringBoarding;
+#else
+			return false;
+#endif
+		}
+	}
+
+	parent = (gentity_t *)pVeh->m_pParentEntity;
+
+	// Validate vehicle.
+	if ( !parent || !parent->client || parent->health <= 0 )
+		return false;
+
+	// See if any of the riders are dead and if so kick em off.
+	if ( pVeh->m_pPilot )
+	{
+		pilotEnt = (gentity_t *)pVeh->m_pPilot;
+		
+#ifdef _JK2MP
+		if (!pilotEnt->inuse || !pilotEnt->client || pilotEnt->health <= 0 ||
+			pilotEnt->client->pers.connected != CON_CONNECTED)
+#else
+		if (pilotEnt->health <= 0)
+#endif
+		{
+			pVeh->m_pVehicleInfo->Eject( pVeh, pVeh->m_pPilot, qtrue );
+		}
+	}
+
+#ifdef _JK2MP
+	// Copy over the commands for local storage.
+	memcpy( &parent->client->pers.cmd, &pVeh->m_ucmd, sizeof( usercmd_t ) );
+	pVeh->m_ucmd.buttons &= ~(BUTTON_TALK);//|BUTTON_GESTURE); //don't want some of these buttons
+#else
+	// Copy over the commands for local storage.
+	memcpy( &pVeh->m_ucmd, pUmcd, sizeof( usercmd_t ) );
+	memcpy( &parent->client->pers.lastCommand, pUmcd, sizeof( usercmd_t ) );
+#endif
+
+	/*
+	// Update time modifier.
+	pVeh->m_fTimeModifier = pVeh->m_ucmd.serverTime - parent->client->ps.commandTime;
+	//sanity check
+	if ( pVeh->m_fTimeModifier < 1 ) 
+	{
+		pVeh->m_fTimeModifier = 1;
+	} 
+	else if ( pVeh->m_fTimeModifier > 200 ) 
+	{
+		pVeh->m_fTimeModifier = 200;
+	}
+	//normalize to 1.0f at 20fps
+	pVeh->m_fTimeModifier = pVeh->m_fTimeModifier / fMod;
+	*/
+	
+	//check for weapon linking/unlinking command
+	for ( i = 0; i < MAX_VEHICLE_WEAPONS; i++ )
+	{//HMM... can't get a seperate command for each weapon, so do them all...?
+		if ( pVeh->m_pVehicleInfo->weapon[i].linkable == 2 )
+		{//always linked
+			//FIXME: just set this once, on Initialize...?
+			if ( !pVeh->weaponStatus[i].linked )
+			{
+				pVeh->weaponStatus[i].linked = qtrue;
+			}
+		}
+#ifdef _JK2MP
+		else if ( (pVeh->m_ucmd.buttons&BUTTON_USE_HOLDABLE) ) 
+#else
+		//FIXME: implement... just a console command bound to a key?
+		else if ( 0 )
+#endif	
+		{//pilot pressed the "weapon link" toggle button
+			playerState_t *pilotPS;
+#ifdef _JK2MP
+			bgEntity_t *rider = NULL;
+			if (parent->s.owner != ENTITYNUM_NONE)
+			{
+				rider = PM_BGEntForNum(parent->s.owner); //&g_entities[parent->r.ownerNum];
+			}
+			pilotPS = rider->playerState;
+#else
+			gentity_t *rider = parent->owner;
+			pilotPS = &rider->client->ps;
+#endif
+			if ( !pVeh->linkWeaponToggleHeld )//so we don't hold it down and toggle it back and forth
+			{//okay to toggle
+				if ( pVeh->m_pVehicleInfo->weapon[i].linkable == 1 )
+				{//link-toggleable
+					pVeh->weaponStatus[i].linked = !pVeh->weaponStatus[i].linked;
+				}
+			}
+			linkHeld = qtrue;
+		}
+	}
+	if ( linkHeld )
+	{
+		//so we don't hold it down and toggle it back and forth
+		pVeh->linkWeaponToggleHeld = qtrue;
+	}
+	else
+	{
+		//so we don't hold it down and toggle it back and forth
+		pVeh->linkWeaponToggleHeld = qfalse;
+	}
+#ifdef _JK2MP
+	//now pass it over the network so cgame knows about it
+	//NOTE: SP can just cheat and check directly
+	parentPS->vehWeaponsLinked = qfalse;
+	for ( i = 0; i < MAX_VEHICLE_WEAPONS; i++ )
+	{//HMM... can't get a seperate command for each weapon, so do them all...?
+		if ( pVeh->weaponStatus[i].linked )
+		{
+			parentPS->vehWeaponsLinked = qtrue;
+		}
+	}
+#endif
+
+#ifdef QAGAME
+	for ( i = 0; i < MAX_VEHICLE_TURRETS; i++ )
+	{//HMM... can't get a seperate command for each weapon, so do them all...?
+		VEH_TurretThink( pVeh, parent, i );
+	}
+#endif
+
+#ifdef _JK2MP
+maintainSelfDuringBoarding:
+
+	if (pVeh->m_pPilot && pVeh->m_pPilot->playerState && pVeh->m_iBoarding != 0)
+	{
+        VectorCopy(pVeh->m_vOrientation, pVeh->m_pPilot->playerState->viewangles);
+		pVeh->m_ucmd.buttons = 0;
+		pVeh->m_ucmd.forwardmove = 0;
+		pVeh->m_ucmd.rightmove = 0;
+		pVeh->m_ucmd.upmove = 0;
+	}
+#endif
+
+	// Keep track of the old orientation.
+	VectorCopy( pVeh->m_vOrientation, pVeh->m_vPrevOrientation );
+
+	// Process the orient commands.
+	pVeh->m_pVehicleInfo->ProcessOrientCommands( pVeh );
+	// Need to copy orientation to our entity's viewangles so that it renders at the proper angle and currentAngles is correct.
+	SetClientViewAngle( parent, pVeh->m_vOrientation ); 
+	if ( pVeh->m_pPilot )
+	{
+#ifdef _JK2MP
+		if ( !BG_UnrestrainedPitchRoll( pVeh->m_pPilot->playerState, pVeh ) )
+		{
+			vec3_t newVAngle;
+			newVAngle[PITCH] = pVeh->m_pPilot->playerState->viewangles[PITCH];
+			newVAngle[YAW] = pVeh->m_pPilot->playerState->viewangles[YAW];
+			newVAngle[ROLL] = pVeh->m_vOrientation[ROLL];
+			SetClientViewAngle( (gentity_t *)pVeh->m_pPilot, newVAngle );
+		}
+#else
+		if ( !BG_UnrestrainedPitchRoll( &pVeh->m_pPilot->client->ps, pVeh ) )
+		{
+			SetClientViewAngle( (gentity_t *)pVeh->m_pPilot, pVeh->m_vOrientation );
+		}
+#endif
+	}
+	/*
+	for ( i = 0; i < pVeh->m_pVehicleInfo->maxPassengers; i++ )
+	{
+		if ( pVeh->m_ppPassengers[i] )
+		{
+			SetClientViewAngle( (gentity_t *)pVeh->m_ppPassengers[i], pVeh->m_vOrientation );
+		}
+	}
+	*/
+
+	// Process the move commands.
+	prevSpeed = parentPS->speed;
+	pVeh->m_pVehicleInfo->ProcessMoveCommands( pVeh );
+	nextSpeed = parentPS->speed;
+	halfMaxSpeed = pVeh->m_pVehicleInfo->speedMax*0.5f;
+	
+
+// Shifting Sounds
+//=====================================================================
+	if (pVeh->m_iTurboTime<curTime && 
+		pVeh->m_iSoundDebounceTimer<curTime && 
+		((nextSpeed>prevSpeed && nextSpeed>halfMaxSpeed &&	prevSpeed<halfMaxSpeed) || (nextSpeed>halfMaxSpeed && !Q_irand(0,1000)))
+ 		)
+	{
+		int	shiftSound = Q_irand(1,4);
+		switch (shiftSound)
+		{
+		case 1: shiftSound=pVeh->m_pVehicleInfo->soundShift1; break;
+		case 2: shiftSound=pVeh->m_pVehicleInfo->soundShift2; break;
+		case 3: shiftSound=pVeh->m_pVehicleInfo->soundShift3; break;
+		case 4: shiftSound=pVeh->m_pVehicleInfo->soundShift4; break;
+		}
+		if (shiftSound)
+		{
+			pVeh->m_iSoundDebounceTimer = curTime + Q_irand(1000, 4000);
+#ifdef _JK2MP
+			// TODO: MP Shift Sound Playback
+#else
+			// NOTE: Use this type so it's spatialized and updates play origin as bike moves - MCG
+			G_SoundIndexOnEnt( pVeh->m_pParentEntity, CHAN_AUTO, shiftSound);
+#endif
+		}
+	}
+//=====================================================================
+
+
+	// Setup the move direction.
+	if ( pVeh->m_pVehicleInfo->type == VH_FIGHTER )
+	{
+		AngleVectors( pVeh->m_vOrientation, parent->client->ps.moveDir, NULL, NULL ); 
+	}
+	else
+	{
+		VectorSet(vVehAngles, 0, pVeh->m_vOrientation[YAW], 0);
+		AngleVectors( vVehAngles, parent->client->ps.moveDir, NULL, NULL ); 
+	}
+
+#ifdef _JK2MP
+	if (pVeh->m_pVehicleInfo->surfDestruction)
+	{
+		if (pVeh->m_iRemovedSurfaces)
+		{
+			gentity_t *killer = parent;
+			G_VehicleDamageBoxSizing(pVeh);
+
+			//damage him constantly if any chunks are currently taken off
+			if (parent->client->ps.otherKiller < ENTITYNUM_WORLD &&
+				parent->client->ps.otherKillerTime > level.time)
+			{
+				gentity_t *potentialKiller = &g_entities[parent->client->ps.otherKiller];
+
+				if (potentialKiller->inuse && potentialKiller->client)
+				{ //he's valid I guess
+					killer = potentialKiller;
+				}
+			}
+			//FIXME: aside from bypassing shields, maybe set m_iShields to 0, too... ?
+			G_Damage(parent, killer, killer, NULL, parent->client->ps.origin, Q_irand(2, 5), DAMAGE_NO_PROTECTION|DAMAGE_NO_ARMOR, MOD_SUICIDE);
+		}
+		
+		//make sure playerstate value stays in sync
+		parent->client->ps.vehSurfaces = pVeh->m_iRemovedSurfaces;
+	}
+#endif
+
+#ifdef _JK2MP
+	//keep the PS value in sync
+	if (pVeh->m_iBoarding)
+	{
+		parent->client->ps.vehBoarding = qtrue;
+	}
+	else
+	{
+		parent->client->ps.vehBoarding = qfalse;
+	}
+#endif
+
+#ifndef _JK2MP
+	// Make sure the vehicle takes on the enemy of it's rider (for homing missles for instance).
+	if ( pVeh->m_pPilot )
+	{
+		parent->enemy = pVeh->m_pPilot->enemy;
+	}
+#endif
+	
+
+	return true;
+}
+
+
+// Update the properties of a Rider (that may reflect what happens to the vehicle).
+static bool UpdateRider( Vehicle_t *pVeh, bgEntity_t *pRider, usercmd_t *pUmcd )
+{
+	gentity_t *parent;
+	gentity_t *rider;
+
+	if ( pVeh->m_iBoarding != 0 && pVeh->m_iDieTime==0)
+		return true;
+
+	parent = (gentity_t *)pVeh->m_pParentEntity;
+	rider = (gentity_t *)pRider;
+#ifdef _JK2MP
+	//MG FIXME !! Single player needs update!
+	if ( rider && rider->client 
+		&& parent && parent->client )
+	{//so they know who we're locking onto with our rockets, if anyone
+		rider->client->ps.rocketLockIndex = parent->client->ps.rocketLockIndex;
+		rider->client->ps.rocketLockTime = parent->client->ps.rocketLockTime;
+		rider->client->ps.rocketTargetTime = parent->client->ps.rocketTargetTime;
+	}
+#endif
+	// Regular exit.
+	if ( pUmcd->buttons & BUTTON_USE && pVeh->m_pVehicleInfo->type!=VH_SPEEDER)
+	{
+		if ( pVeh->m_pVehicleInfo->type == VH_WALKER )
+		{//just get the fuck out
+			pVeh->m_EjectDir = VEH_EJECT_REAR;
+			if ( pVeh->m_pVehicleInfo->Eject( pVeh, pRider, qfalse ) )
+				return false;
+		}
+		else if ( !(pVeh->m_ulFlags & VEH_FLYING))
+		{
+			// If going too fast, roll off.
+			if ((parent->client->ps.speed<=600) && pUmcd->rightmove!=0)
+			{
+				if ( pVeh->m_pVehicleInfo->Eject( pVeh, pRider, qfalse ) )
+				{
+					animNumber_t Anim;
+					int iFlags = SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLD | SETANIM_FLAG_HOLDLESS, iBlend = 300;
+					if ( pUmcd->rightmove > 0 )
+					{
+						Anim = BOTH_ROLL_R;
+						pVeh->m_EjectDir = VEH_EJECT_RIGHT;
+					}
+					else
+					{
+						Anim = BOTH_ROLL_L;
+						pVeh->m_EjectDir = VEH_EJECT_LEFT;
+					}
+					VectorScale( parent->client->ps.velocity, 0.25f, rider->client->ps.velocity );
+#if 1
+					Vehicle_SetAnim( rider, SETANIM_BOTH, Anim, iFlags, iBlend );
+#else
+
+#endif
+					//PM_SetAnim(pm,SETANIM_BOTH,anim,SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD|SETANIM_FLAG_HOLDLESS);
+					rider->client->ps.weaponTime = rider->client->ps.torsoAnimTimer - 200;//just to make sure it's cleared when roll is done
+					G_AddEvent( rider, EV_ROLL, 0 );
+					return false;
+				}
+			}
+			else
+			{
+				// FIXME: Check trace to see if we should start playing the animation.
+				animNumber_t Anim;
+				int iFlags = SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLD, iBlend = 500;
+				if ( pUmcd->rightmove > 0 )
+				{
+					Anim = BOTH_VS_DISMOUNT_R;
+					pVeh->m_EjectDir = VEH_EJECT_RIGHT;
+				}
+				else
+				{
+					Anim = BOTH_VS_DISMOUNT_L;
+					pVeh->m_EjectDir = VEH_EJECT_LEFT;
+				}
+				
+				if ( pVeh->m_iBoarding <= 1 )
+				{
+					int iAnimLen;
+					// NOTE: I know I shouldn't reuse pVeh->m_iBoarding so many times for so many different
+					// purposes, but it's not used anywhere else right here so why waste memory???
+#ifdef _JK2MP
+					iAnimLen = BG_AnimLength( rider->localAnimIndex, Anim );
+#else
+					iAnimLen = PM_AnimLength( pRider->client->clientInfo.animFileIndex, Anim );
+#endif
+					pVeh->m_iBoarding = level.time + iAnimLen;
+					// Weird huh? Well I wanted to reuse flags and this should never be set in an
+					// entity, so what the heck.
+#ifdef _JK2MP
+					rider->flags |= FL_VEH_BOARDING;
+#else
+					rider->client->ps.eFlags |= EF_VEH_BOARDING;
+#endif
+
+					// Make sure they can't fire when leaving.
+					rider->client->ps.weaponTime = iAnimLen;
+				}
+
+				VectorScale( parent->client->ps.velocity, 0.25f, rider->client->ps.velocity );
+
+				Vehicle_SetAnim( rider, SETANIM_BOTH, Anim, iFlags, iBlend );
+			}
+		}
+		// Flying, so just fall off.
+		else
+		{
+			pVeh->m_EjectDir = VEH_EJECT_LEFT;
+			if ( pVeh->m_pVehicleInfo->Eject( pVeh, pRider, qfalse ) )
+				return false;
+		}
+	}
+
+	// Getting off animation complete (if we had one going)?
+#ifdef _JK2MP
+	if ( pVeh->m_iBoarding < level.time && (rider->flags & FL_VEH_BOARDING) )
+	{
+		rider->flags &= ~FL_VEH_BOARDING;
+#else
+	if ( pVeh->m_iBoarding < level.time && (rider->client->ps.eFlags & EF_VEH_BOARDING) )
+	{
+		rider->client->ps.eFlags &= ~EF_VEH_BOARDING;
+#endif
+		// Eject this guy now.
+		if ( pVeh->m_pVehicleInfo->Eject( pVeh, pRider, qfalse ) )
+		{
+			return false;
+		}
+	}
+
+	if ( pVeh->m_pVehicleInfo->type != VH_FIGHTER 
+		&& pVeh->m_pVehicleInfo->type != VH_WALKER  )
+	{
+		// Jump off.
+		if ( pUmcd->upmove > 0 )
+		{
+
+// NOT IN MULTI PLAYER!
+//===================================================================
+#ifndef _JK2MP
+			float riderRightDot = G_CanJumpToEnemyVeh(pVeh, pUmcd);
+			if (riderRightDot!=0.0f)
+			{
+				// Eject Player From Current Vehicle
+				//-----------------------------------
+				pVeh->m_EjectDir = VEH_EJECT_TOP;
+				pVeh->m_pVehicleInfo->Eject( pVeh, pRider, qtrue );
+
+				// Send Current Vehicle Spinning Out Of Control
+				//----------------------------------------------
+				pVeh->m_pVehicleInfo->StartDeathDelay(pVeh, 10000);
+				pVeh->m_ulFlags |= (VEH_OUTOFCONTROL);
+ 				VectorScale(pVeh->m_pParentEntity->client->ps.velocity, 1.0f, pVeh->m_pParentEntity->pos3);
+
+				// Todo: Throw Old Vehicle Away From The New Vehicle Some
+				//-------------------------------------------------------
+				vec3_t	toEnemy;
+				VectorSubtract(pVeh->m_pParentEntity->currentOrigin, rider->enemy->currentOrigin, toEnemy);
+				VectorNormalize(toEnemy);
+				G_Throw(pVeh->m_pParentEntity, toEnemy, 50);
+
+				// Start Boarding On Enemy's Vehicle
+				//-----------------------------------
+				Vehicle_t*	enemyVeh = G_IsRidingVehicle(rider->enemy);
+				enemyVeh->m_iBoarding = (riderRightDot>0)?(VEH_MOUNT_THROW_RIGHT):(VEH_MOUNT_THROW_LEFT);
+				enemyVeh->m_pVehicleInfo->Board(enemyVeh, rider);
+			}
+
+			// Don't Jump Off If Holding Strafe Key and Moving Fast
+			else if (pUmcd->rightmove && (parent->client->ps.speed>=10))
+			{
+				return true;
+			}
+#endif
+//===================================================================
+
+			if ( pVeh->m_pVehicleInfo->Eject( pVeh, pRider, qfalse ) )
+			{
+				// Allow them to force jump off.
+				VectorScale( parent->client->ps.velocity, 0.5f, rider->client->ps.velocity );
+				rider->client->ps.velocity[2] += JUMP_VELOCITY;
+#ifdef _JK2MP
+				rider->client->ps.fd.forceJumpZStart = rider->client->ps.origin[2];
+
+				if (!trap_ICARUS_TaskIDPending(rider, TID_CHAN_VOICE))
+#else
+				rider->client->ps.pm_flags |= ( PMF_JUMPING | PMF_JUMP_HELD );
+				rider->client->ps.forceJumpZStart = rider->client->ps.origin[2];
+
+				if ( !Q3_TaskIDPending( rider, TID_CHAN_VOICE ) )
+#endif
+				{
+					G_AddEvent( rider, EV_JUMP, 0 );
+				}
+#if 1
+				Vehicle_SetAnim( rider, SETANIM_BOTH, BOTH_JUMP1, SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLD, 300 );
+#else
+
+#endif
+				return false;
+			}
+		}
+
+		// Roll off.
+#ifdef _JK2MP
+		if ( pUmcd->upmove < 0 )
+		{
+			animNumber_t Anim = BOTH_ROLL_B;
+			pVeh->m_EjectDir = VEH_EJECT_REAR;
+			if ( pUmcd->rightmove > 0 )
+			{
+				Anim = BOTH_ROLL_R;
+				pVeh->m_EjectDir = VEH_EJECT_RIGHT;
+			}
+			else if ( pUmcd->rightmove < 0 )
+			{
+				Anim = BOTH_ROLL_L;
+				pVeh->m_EjectDir = VEH_EJECT_LEFT;
+			}
+			else if ( pUmcd->forwardmove < 0 )
+			{
+				Anim = BOTH_ROLL_B;
+				pVeh->m_EjectDir = VEH_EJECT_REAR;
+			}
+			else if ( pUmcd->forwardmove > 0 )
+			{
+				Anim = BOTH_ROLL_F;
+				pVeh->m_EjectDir = VEH_EJECT_FRONT;
+			}
+
+			if ( pVeh->m_pVehicleInfo->Eject( pVeh, pRider, qfalse ) )
+			{
+				if ( !(pVeh->m_ulFlags & VEH_FLYING) )
+				{
+					VectorScale( parent->client->ps.velocity, 0.25f, rider->client->ps.velocity );
+#if 1
+					Vehicle_SetAnim( rider, SETANIM_BOTH, Anim, SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLD | SETANIM_FLAG_HOLDLESS, 300 );
+#else
+
+#endif
+					//PM_SetAnim(pm,SETANIM_BOTH,anim,SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD|SETANIM_FLAG_HOLDLESS);
+					rider->client->ps.weaponTime = rider->client->ps.torsoAnimTimer - 200;//just to make sure it's cleared when roll is done
+					G_AddEvent( rider, EV_ROLL, 0 );
+				}
+				return false;
+			}
+
+		}
+#endif
+	}
+
+	return true;
+}
+
+#ifdef _JK2MP //we want access to this one clientside, but it's the only
+//generic vehicle function we care about over there
+#include "../namespace_begin.h"
+extern void AttachRidersGeneric( Vehicle_t *pVeh );
+#include "../namespace_end.h"
+#endif
+
+// Attachs all the riders of this vehicle to their appropriate tag (*driver, *pass1, *pass2, whatever...).
+static void AttachRiders( Vehicle_t *pVeh )
+{
+#ifdef _JK2MP
+	int i = 0;
+
+	AttachRidersGeneric(pVeh);
+
+	if (pVeh->m_pPilot)
+	{
+		gentity_t *parent = (gentity_t *)pVeh->m_pParentEntity;
+		gentity_t *pilot = (gentity_t *)pVeh->m_pPilot;
+		pilot->waypoint = parent->waypoint; // take the veh's waypoint as your own
+
+		//assuming we updated him relative to the bolt in AttachRidersGeneric
+		G_SetOrigin( pilot, pilot->client->ps.origin );
+		trap_LinkEntity( pilot );
+	}
+
+	if (pVeh->m_pOldPilot)
+	{
+		gentity_t *parent = (gentity_t *)pVeh->m_pParentEntity;
+		gentity_t *oldpilot = (gentity_t *)pVeh->m_pOldPilot;
+		oldpilot->waypoint = parent->waypoint; // take the veh's waypoint as your own
+
+		//assuming we updated him relative to the bolt in AttachRidersGeneric
+		G_SetOrigin( oldpilot, oldpilot->client->ps.origin );
+		trap_LinkEntity( oldpilot );
+	}
+
+	//attach passengers
+	while (i < pVeh->m_iNumPassengers)
+	{
+		if (pVeh->m_ppPassengers[i])
+		{
+			mdxaBone_t boltMatrix;
+			vec3_t	yawOnlyAngles;
+			gentity_t *parent = (gentity_t *)pVeh->m_pParentEntity;
+			gentity_t *pilot = (gentity_t *)pVeh->m_ppPassengers[i];
+			int crotchBolt;
+
+			assert(parent->ghoul2);
+			crotchBolt = trap_G2API_AddBolt(parent->ghoul2, 0, "*driver");
+			assert(parent->client);
+			assert(pilot->client);
+
+			VectorSet(yawOnlyAngles, 0, parent->client->ps.viewangles[YAW], 0);
+
+			// Get the driver tag.
+			trap_G2API_GetBoltMatrix( parent->ghoul2, 0, crotchBolt, &boltMatrix,
+									yawOnlyAngles, parent->client->ps.origin,
+									level.time, NULL, parent->modelScale );
+			BG_GiveMeVectorFromMatrix( &boltMatrix, ORIGIN, pilot->client->ps.origin );
+
+			G_SetOrigin( pilot, pilot->client->ps.origin );
+			trap_LinkEntity( pilot );
+		}
+		i++;
+	}
+
+	//attach droid
+	if (pVeh->m_pDroidUnit
+		&& pVeh->m_iDroidUnitTag != -1)
+	{
+		mdxaBone_t boltMatrix;
+		vec3_t	yawOnlyAngles, fwd;
+		gentity_t *parent = (gentity_t *)pVeh->m_pParentEntity;
+		gentity_t *droid = (gentity_t *)pVeh->m_pDroidUnit;
+
+		assert(parent->ghoul2);
+		assert(parent->client);
+		//assert(droid->client);
+
+		if ( droid->client )
+		{
+			VectorSet(yawOnlyAngles, 0, parent->client->ps.viewangles[YAW], 0);
+
+			// Get the droid tag.
+			trap_G2API_GetBoltMatrix( parent->ghoul2, 0, pVeh->m_iDroidUnitTag, &boltMatrix,
+									yawOnlyAngles, parent->currentOrigin,
+									level.time, NULL, parent->modelScale );
+			BG_GiveMeVectorFromMatrix( &boltMatrix, ORIGIN, droid->client->ps.origin );
+			BG_GiveMeVectorFromMatrix( &boltMatrix, NEGATIVE_Y, fwd );
+			vectoangles( fwd, droid->client->ps.viewangles );
+
+			G_SetOrigin( droid, droid->client->ps.origin );
+			G_SetAngles( droid, droid->client->ps.viewangles);
+			SetClientViewAngle( droid, droid->client->ps.viewangles );
+			trap_LinkEntity( droid );
+
+			if ( droid->NPC )
+			{
+				NPC_SetAnim( droid, SETANIM_BOTH, BOTH_STAND2, (SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD) );
+				droid->client->ps.legsTimer = 500;
+				droid->client->ps.torsoTimer = 500;
+			}
+		}
+	}
+#else
+	// If we have a pilot, attach him to the driver tag.
+	if ( pVeh->m_pPilot )
+	{
+		gentity_t * const parent = pVeh->m_pParentEntity;
+		gentity_t * const pilot = pVeh->m_pPilot;
+		mdxaBone_t	boltMatrix;
+
+		pilot->waypoint = parent->waypoint; // take the veh's waypoint as your own
+
+		// Get the driver tag.
+		gi.G2API_GetBoltMatrix( parent->ghoul2, parent->playerModel, parent->crotchBolt, &boltMatrix,
+								pVeh->m_vOrientation, parent->currentOrigin,
+								(cg.time?cg.time:level.time), NULL, parent->s.modelScale );
+		gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, pilot->client->ps.origin );
+		G_SetOrigin( pilot, pilot->client->ps.origin );
+		gi.linkentity( pilot );
+	}
+	// If we have a pilot, attach him to the driver tag.
+	if ( pVeh->m_pOldPilot )
+	{
+		gentity_t * const parent = pVeh->m_pParentEntity;
+		gentity_t * const pilot = pVeh->m_pOldPilot;
+		mdxaBone_t	boltMatrix;
+
+		pilot->waypoint = parent->waypoint; // take the veh's waypoint as your own
+
+		// Get the driver tag.
+		gi.G2API_GetBoltMatrix( parent->ghoul2, parent->playerModel, parent->crotchBolt, &boltMatrix,
+								pVeh->m_vOrientation, parent->currentOrigin,
+								(cg.time?cg.time:level.time), NULL, parent->s.modelScale );
+		gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, pilot->client->ps.origin );
+		G_SetOrigin( pilot, pilot->client->ps.origin );
+		gi.linkentity( pilot );
+	}
+#endif
+}
+
+// Make someone invisible and un-collidable.
+static void Ghost( Vehicle_t *pVeh, bgEntity_t *pEnt )
+{
+	gentity_t *ent;
+
+	if ( !pEnt )
+		return;
+
+	ent = (gentity_t *)pEnt;
+
+	ent->s.eFlags |= EF_NODRAW;
+	if ( ent->client )
+	{
+		ent->client->ps.eFlags |= EF_NODRAW;
+	}
+#ifdef _JK2MP
+	ent->r.contents = 0;
+#else
+	ent->contents = 0;
+#endif
+}
+
+// Make someone visible and collidable.
+static void UnGhost( Vehicle_t *pVeh, bgEntity_t *pEnt )
+{
+	gentity_t *ent;
+
+	if ( !pEnt )
+		return;
+
+	ent = (gentity_t *)pEnt;
+
+	ent->s.eFlags &= ~EF_NODRAW;
+	if ( ent->client )
+	{
+		ent->client->ps.eFlags &= ~EF_NODRAW;
+	}
+#ifdef _JK2MP
+	ent->r.contents = CONTENTS_BODY;
+#else
+	ent->contents = CONTENTS_BODY;
+#endif
+}
+
+#ifdef _JK2MP
+//try to resize the bounding box around a torn apart ship
+void G_VehicleDamageBoxSizing(Vehicle_t *pVeh)
+{
+	vec3_t fwd, right, up;
+	vec3_t nose; //maxs
+	vec3_t back; //mins
+	trace_t trace;
+	const float fDist = 256.0f; //estimated distance to nose from origin
+	const float bDist = 256.0f; //estimated distance to back from origin
+	const float wDist = 32.0f; //width on each side from origin
+	const float hDist = 32.0f; //height on each side from origin
+	gentity_t *parent = (gentity_t *)pVeh->m_pParentEntity;
+
+	if (!parent->ghoul2 || !parent->m_pVehicle || !parent->client)
+	{ //shouldn't have gotten in here then
+		return;
+	}
+
+	//for now, let's only do anything if all wings are stripped off.
+	//this is because I want to be able to tear my wings off and fling
+	//myself down narrow hallways to my death. Because it's fun! -rww
+	if (!(pVeh->m_iRemovedSurfaces & SHIPSURF_BROKEN_C) ||
+		!(pVeh->m_iRemovedSurfaces & SHIPSURF_BROKEN_D) ||
+		!(pVeh->m_iRemovedSurfaces & SHIPSURF_BROKEN_E) ||
+		!(pVeh->m_iRemovedSurfaces & SHIPSURF_BROKEN_F) )
+	{
+		return;
+	}
+
+	//get directions based on orientation
+	AngleVectors(pVeh->m_vOrientation, fwd, right, up);
+
+	//get the nose and back positions (relative to 0, they're gonna be mins/maxs)
+	VectorMA(vec3_origin, fDist, fwd, nose);
+	VectorMA(vec3_origin, -bDist, fwd, back);
+
+	//move the nose and back to opposite right/left, they will end up as our relative mins and maxs
+	VectorMA(nose, wDist, right, nose);
+	VectorMA(nose, -wDist, right, back);
+
+	//use the same concept for up/down now
+	VectorMA(nose, hDist, up, nose);
+	VectorMA(nose, -hDist, up, back);
+
+	//and now, let's trace and see if our new mins/maxs are safe..
+	trap_Trace(&trace, parent->client->ps.origin, back, nose, parent->client->ps.origin, parent->s.number, parent->clipmask);
+	if (!trace.allsolid && !trace.startsolid && trace.fraction == 1.0f)
+	{ //all clear!
+		VectorCopy(nose, parent->maxs);
+		VectorCopy(back, parent->mins);
+	}
+	else
+	{ //oh well, DIE!
+		//FIXME: does this give proper credit to the enemy who shot you down?
+		G_Damage(parent, parent, parent, NULL, parent->client->ps.origin, 9999, DAMAGE_NO_PROTECTION, MOD_SUICIDE);
+	}
+}
+
+//get one of 4 possible impact locations based on the trace direction
+int G_FlyVehicleImpactDir(gentity_t *veh, trace_t *trace)
+{
+	float impactAngle;
+	float relativeAngle;
+	trace_t localTrace;
+	vec3_t testMins, testMaxs;
+	vec3_t rWing, lWing;
+	vec3_t fwd, right;
+	vec3_t fPos;
+	Vehicle_t *pVeh = veh->m_pVehicle;
+	qboolean noseClear = qfalse;
+
+	if (!trace || !pVeh || !veh->client)
+	{
+		return -1;
+	}
+
+	AngleVectors(veh->client->ps.viewangles, fwd, right, 0);
+	VectorSet(testMins, -24.0f, -24.0f, -24.0f);
+	VectorSet(testMaxs, 24.0f, 24.0f, 24.0f);
+
+	//do a trace to determine if the nose is clear
+	VectorMA(veh->client->ps.origin, 256.0f, fwd, fPos);
+	trap_Trace(&localTrace, veh->client->ps.origin, testMins, testMaxs, fPos, veh->s.number, veh->clipmask);
+	if (!localTrace.startsolid && !localTrace.allsolid && localTrace.fraction == 1.0f)
+	{ //otherwise I guess it's not clear..
+		noseClear = qtrue;
+	}
+
+	if (noseClear)
+	{ //if nose is clear check for tearing the wings off
+		//sadly, the trace endpos given always matches the vehicle origin, so we
+		//can't get a real impact direction. First we'll trace forward and see if the wings are colliding
+		//with anything, and if not, we'll fall back to checking the trace plane normal.
+		VectorMA(veh->client->ps.origin, 128.0f, right, rWing);
+		VectorMA(veh->client->ps.origin, -128.0f, right, lWing);
+
+		//test the right wing - unless it's already removed
+		if (!(pVeh->m_iRemovedSurfaces & SHIPSURF_BROKEN_E) ||
+			!(pVeh->m_iRemovedSurfaces & SHIPSURF_BROKEN_F))
+		{
+			VectorMA(rWing, 256.0f, fwd, fPos);
+			trap_Trace(&localTrace, rWing, testMins, testMaxs, fPos, veh->s.number, veh->clipmask);
+			if (localTrace.startsolid || localTrace.allsolid || localTrace.fraction != 1.0f)
+			{ //impact
+				return SHIPSURF_RIGHT;
+			}
+		}
+
+		//test the left wing - unless it's already removed
+		if (!(pVeh->m_iRemovedSurfaces & SHIPSURF_BROKEN_C) ||
+			!(pVeh->m_iRemovedSurfaces & SHIPSURF_BROKEN_D))
+		{
+			VectorMA(lWing, 256.0f, fwd, fPos);
+			trap_Trace(&localTrace, lWing, testMins, testMaxs, fPos, veh->s.number, veh->clipmask);
+			if (localTrace.startsolid || localTrace.allsolid || localTrace.fraction != 1.0f)
+			{ //impact
+				return SHIPSURF_LEFT;
+			}
+		}
+	}
+
+	//try to use the trace plane normal
+	impactAngle = vectoyaw(trace->plane.normal);
+	relativeAngle = AngleSubtract(impactAngle, veh->client->ps.viewangles[YAW]);
+
+	if (relativeAngle > 130 ||
+		relativeAngle < -130)
+	{ //consider this front
+		return SHIPSURF_FRONT;
+	}
+	else if (relativeAngle > 0)
+	{
+		return SHIPSURF_RIGHT;
+	}
+	else if (relativeAngle < 0)
+	{
+		return SHIPSURF_LEFT;
+	}
+
+	return SHIPSURF_BACK;
+}
+
+//try to break surfaces off the ship on impact
+#define TURN_ON				0x00000000
+#define TURN_OFF			0x00000100
+extern void NPC_SetSurfaceOnOff(gentity_t *ent, const char *surfaceName, int surfaceFlags); //NPC_utils.c
+int G_ShipSurfaceForSurfName( const char *surfaceName )
+{
+	if ( !surfaceName )
+	{
+		return -1;
+	}
+	if ( !Q_strncmp( "nose", surfaceName, 4 )
+		|| !Q_strncmp( "f_gear", surfaceName, 6 )
+		|| !Q_strncmp( "glass", surfaceName, 5 ) )
+	{
+		return SHIPSURF_FRONT;
+	}
+	if ( !Q_strncmp( "body", surfaceName, 4 ) )
+	{
+		return SHIPSURF_BACK;
+	}
+	if ( !Q_strncmp( "r_wing1", surfaceName, 7 )
+		|| !Q_strncmp( "r_wing2", surfaceName, 7 )
+		|| !Q_strncmp( "r_gear", surfaceName, 6 ) )
+	{
+		return SHIPSURF_RIGHT;
+	}
+	if ( !Q_strncmp( "l_wing1", surfaceName, 7 )
+		|| !Q_strncmp( "l_wing2", surfaceName, 7 )
+		|| !Q_strncmp( "l_gear", surfaceName, 6 ) )
+	{
+		return SHIPSURF_LEFT;
+	}
+	return -1;
+}
+
+void G_SetVehDamageFlags( gentity_t *veh, int shipSurf, int damageLevel )
+{
+	int dmgFlag;
+	switch ( damageLevel )
+	{
+	case 3://destroyed
+		//add both flags so cgame side knows this surf is GONE
+		//add heavy
+		dmgFlag = SHIPSURF_DAMAGE_FRONT_HEAVY+(shipSurf-SHIPSURF_FRONT);
+		veh->client->ps.brokenLimbs |= (1<<dmgFlag);
+		//add light
+		dmgFlag = SHIPSURF_DAMAGE_FRONT_LIGHT+(shipSurf-SHIPSURF_FRONT);
+		veh->client->ps.brokenLimbs |= (1<<dmgFlag);
+		//copy down
+		veh->s.brokenLimbs = veh->client->ps.brokenLimbs;
+		//check droid
+		if ( shipSurf == SHIPSURF_BACK )
+		{//destroy the droid if we have one
+			if ( veh->m_pVehicle
+				&& veh->m_pVehicle->m_pDroidUnit )
+			{//we have one
+				gentity_t *droidEnt = (gentity_t *)veh->m_pVehicle->m_pDroidUnit;
+				if ( droidEnt 
+					&& ((droidEnt->flags&FL_UNDYING) || droidEnt->health > 0) )
+				{//boom
+					//make it vulnerable
+					droidEnt->flags &= ~FL_UNDYING;
+					//blow it up
+					G_Damage( droidEnt, veh->enemy, veh->enemy, NULL, NULL, 99999, 0, MOD_UNKNOWN );
+				}
+			}
+		}
+		break;
+	case 2://heavy only
+		dmgFlag = SHIPSURF_DAMAGE_FRONT_HEAVY+(shipSurf-SHIPSURF_FRONT);
+		veh->client->ps.brokenLimbs |= (1<<dmgFlag);
+		//remove light
+		dmgFlag = SHIPSURF_DAMAGE_FRONT_LIGHT+(shipSurf-SHIPSURF_FRONT);
+		veh->client->ps.brokenLimbs &= ~(1<<dmgFlag);
+		//copy down
+		veh->s.brokenLimbs = veh->client->ps.brokenLimbs;
+		//check droid
+		if ( shipSurf == SHIPSURF_BACK )
+		{//make the droid vulnerable if we have one
+			if ( veh->m_pVehicle
+				&& veh->m_pVehicle->m_pDroidUnit )
+			{//we have one
+				gentity_t *droidEnt = (gentity_t *)veh->m_pVehicle->m_pDroidUnit;
+				if ( droidEnt 
+					&& (droidEnt->flags&FL_UNDYING) )
+				{//make it vulnerab;e
+					droidEnt->flags &= ~FL_UNDYING;
+				}
+			}
+		}
+		break;
+	case 1://light only
+		//add light
+		dmgFlag = SHIPSURF_DAMAGE_FRONT_LIGHT+(shipSurf-SHIPSURF_FRONT);
+		veh->client->ps.brokenLimbs |= (1<<dmgFlag);
+		//remove heavy (shouldn't have to do this, but...
+		dmgFlag = SHIPSURF_DAMAGE_FRONT_HEAVY+(shipSurf-SHIPSURF_FRONT);
+		veh->client->ps.brokenLimbs &= ~(1<<dmgFlag);
+		//copy down
+		veh->s.brokenLimbs = veh->client->ps.brokenLimbs;
+		break;
+	case 0://no damage
+	default:
+		//remove heavy
+		dmgFlag = SHIPSURF_DAMAGE_FRONT_HEAVY+(shipSurf-SHIPSURF_FRONT);
+		veh->client->ps.brokenLimbs &= ~(1<<dmgFlag);
+		//remove light
+		dmgFlag = SHIPSURF_DAMAGE_FRONT_LIGHT+(shipSurf-SHIPSURF_FRONT);
+		veh->client->ps.brokenLimbs &= ~(1<<dmgFlag);
+		//copy down
+		veh->s.brokenLimbs = veh->client->ps.brokenLimbs;
+		break;
+	}
+}
+
+void G_VehicleSetDamageLocFlags( gentity_t *veh, int impactDir, int deathPoint )
+{
+	if ( !veh->client )
+	{
+		return;
+	}
+	else
+	{
+		int	deathPoint, heavyDamagePoint, lightDamagePoint;
+		switch(impactDir)
+		{
+		case SHIPSURF_FRONT:
+			deathPoint = veh->m_pVehicle->m_pVehicleInfo->health_front;
+			break;
+		case SHIPSURF_BACK:
+			deathPoint = veh->m_pVehicle->m_pVehicleInfo->health_back;
+			break;
+		case SHIPSURF_RIGHT:
+			deathPoint = veh->m_pVehicle->m_pVehicleInfo->health_right;
+			break;
+		case SHIPSURF_LEFT:
+			deathPoint = veh->m_pVehicle->m_pVehicleInfo->health_left;
+			break;
+		default:
+			return;
+			break;
+		}
+		if ( veh->m_pVehicle
+			&& veh->m_pVehicle->m_pVehicleInfo
+			&& veh->m_pVehicle->m_pVehicleInfo->malfunctionArmorLevel 
+			&& veh->m_pVehicle->m_pVehicleInfo->armor )
+		{
+			float perc = ((float)veh->m_pVehicle->m_pVehicleInfo->malfunctionArmorLevel/(float)veh->m_pVehicle->m_pVehicleInfo->armor);
+			if ( perc > 0.99f )
+			{
+				perc = 0.99f;
+			}
+			heavyDamagePoint = ceil( deathPoint*perc*0.25f );
+			lightDamagePoint = ceil( deathPoint*perc );
+		}
+		else
+		{
+			heavyDamagePoint = ceil( deathPoint*0.66f );
+			lightDamagePoint = ceil( deathPoint*0.14f );
+		}
+
+		if ( veh->locationDamage[impactDir] >= deathPoint)
+		{//destroyed
+			G_SetVehDamageFlags( veh, impactDir, 3 );
+		}
+		else if ( veh->locationDamage[impactDir] <= heavyDamagePoint )
+		{//heavy only
+			G_SetVehDamageFlags( veh, impactDir, 2 );
+		}
+		else if ( veh->locationDamage[impactDir] <= lightDamagePoint )
+		{//light only
+			G_SetVehDamageFlags( veh, impactDir, 1 );
+		}
+	}
+}
+
+qboolean G_FlyVehicleDestroySurface( gentity_t *veh, int surface )
+{
+	char *surfName[4]; //up to 4 surfs at once
+	int numSurfs = 0;
+	int smashedBits = 0;
+
+	if (surface == -1)
+	{ //not valid?
+		return qfalse;
+	}
+
+	switch(surface)
+	{
+	case SHIPSURF_FRONT: //break the nose off
+		surfName[0] = "nose";
+
+		smashedBits = (SHIPSURF_BROKEN_G);
+
+		numSurfs = 1;
+		break;
+	case SHIPSURF_BACK: //break both the bottom wings off for a backward impact I guess
+		surfName[0] = "r_wing2";
+		surfName[1] = "l_wing2";
+
+		//get rid of the landing gear
+		surfName[2] = "r_gear";
+		surfName[3] = "l_gear";
+
+		smashedBits = (SHIPSURF_BROKEN_A|SHIPSURF_BROKEN_B|SHIPSURF_BROKEN_D|SHIPSURF_BROKEN_F);
+
+		numSurfs = 4;
+		break;
+	case SHIPSURF_RIGHT: //break both right wings off
+		surfName[0] = "r_wing1";
+		surfName[1] = "r_wing2";
+
+		//get rid of the landing gear
+		surfName[2] = "r_gear";
+
+		smashedBits = (SHIPSURF_BROKEN_B|SHIPSURF_BROKEN_E|SHIPSURF_BROKEN_F);
+
+		numSurfs = 3;
+		break;
+	case SHIPSURF_LEFT: //break both left wings off
+		surfName[0] = "l_wing1";
+		surfName[1] = "l_wing2";
+
+		//get rid of the landing gear
+		surfName[2] = "l_gear";
+
+		smashedBits = (SHIPSURF_BROKEN_A|SHIPSURF_BROKEN_C|SHIPSURF_BROKEN_D);
+
+		numSurfs = 3;
+		break;
+	default:
+		break;
+	}
+
+	if (numSurfs < 1)
+	{ //didn't get any valid surfs..
+		return qfalse;
+	}
+
+	while (numSurfs > 0)
+	{ //use my silly system of automatically managing surf status on both client and server
+		numSurfs--;
+		NPC_SetSurfaceOnOff(veh, surfName[numSurfs], TURN_OFF);
+	}
+
+	if ( !veh->m_pVehicle->m_iRemovedSurfaces )
+	{//first time something got blown off
+		if ( veh->m_pVehicle->m_pPilot )
+		{//make the pilot scream to his death
+			G_EntitySound((gentity_t*)veh->m_pVehicle->m_pPilot, CHAN_VOICE, G_SoundIndex("*falling1.wav"));
+		}
+	}
+	//so we can check what's broken
+	veh->m_pVehicle->m_iRemovedSurfaces |= smashedBits;
+
+	//do some explosive damage, but don't damage this ship with it
+	G_RadiusDamage(veh->client->ps.origin, veh, 100, 500, veh, NULL, MOD_SUICIDE);
+
+	//when spiraling to your death, do the electical shader
+	veh->client->ps.electrifyTime = level.time + 10000;
+
+	return qtrue;
+}
+
+void G_FlyVehicleSurfaceDestruction(gentity_t *veh, trace_t *trace, int magnitude, qboolean force)
+{
+	int impactDir;
+	int secondImpact;
+	int deathPoint = -1;
+	qboolean alreadyRebroken = qfalse;
+
+	if (!veh->ghoul2 || !veh->m_pVehicle)
+	{ //no g2 instance.. or no vehicle instance
+		return;
+	}
+
+    impactDir = G_FlyVehicleImpactDir(veh, trace);
+
+anotherImpact:
+	if (impactDir == -1)
+	{ //not valid?
+		return;
+	}
+
+	veh->locationDamage[impactDir] += magnitude*7;
+
+	switch(impactDir)
+	{
+	case SHIPSURF_FRONT:
+		deathPoint = veh->m_pVehicle->m_pVehicleInfo->health_front;
+		break;
+	case SHIPSURF_BACK:
+		deathPoint = veh->m_pVehicle->m_pVehicleInfo->health_back;
+		break;
+	case SHIPSURF_RIGHT:
+		deathPoint = veh->m_pVehicle->m_pVehicleInfo->health_right;
+		break;
+	case SHIPSURF_LEFT:
+		deathPoint = veh->m_pVehicle->m_pVehicleInfo->health_left;
+		break;
+	default:
+		break;
+	}
+
+	if ( deathPoint != -1 )
+	{//got a valid health value
+		if ( force && veh->locationDamage[impactDir] < deathPoint )
+		{//force that surf to be destroyed
+			veh->locationDamage[impactDir] = deathPoint;
+		}
+		if ( veh->locationDamage[impactDir] >= deathPoint)
+		{ //do it
+			if ( G_FlyVehicleDestroySurface( veh, impactDir ) )
+			{//actually took off a surface
+				G_VehicleSetDamageLocFlags( veh, impactDir, deathPoint );
+			}
+		}
+		else
+		{
+			G_VehicleSetDamageLocFlags( veh, impactDir, deathPoint );
+		}
+	}
+
+	if (!alreadyRebroken)
+	{
+		secondImpact = G_FlyVehicleImpactDir(veh, trace);
+		if (impactDir != secondImpact)
+		{ //can break off another piece in this same impact.. but only break off up to 2 at once
+			alreadyRebroken = qtrue;
+			impactDir = secondImpact;
+			goto anotherImpact;
+		}
+	}
+}
+
+void G_VehUpdateShields( gentity_t *targ )
+{
+	if ( !targ || !targ->client 
+		|| !targ->m_pVehicle || !targ->m_pVehicle->m_pVehicleInfo )
+	{
+		return;
+	}
+	if ( targ->m_pVehicle->m_pVehicleInfo->shields <= 0 )
+	{//doesn't have shields, so don't have to send it
+		return;
+	}
+	targ->client->ps.activeForcePass = floor(((float)targ->m_pVehicle->m_iShields/(float)targ->m_pVehicle->m_pVehicleInfo->shields)*10.0f);
+}
+#endif
+
+// Set the parent entity of this Vehicle NPC.
+GAME_INLINE void SetParent( Vehicle_t *pVeh, bgEntity_t *pParentEntity ) { pVeh->m_pParentEntity = pParentEntity; }
+
+// Add a pilot to the vehicle.
+GAME_INLINE void SetPilot( Vehicle_t *pVeh, bgEntity_t *pPilot ) { pVeh->m_pPilot = pPilot; }
+
+// Add a passenger to the vehicle (false if we're full).
+GAME_INLINE bool AddPassenger( Vehicle_t *pVeh ) { return false; }
+
+// Whether this vehicle is currently inhabited (by anyone) or not.
+GAME_INLINE bool Inhabited( Vehicle_t *pVeh ) { return ( pVeh->m_pPilot ) ? true : false; }
+
+
+// Setup the shared functions (one's that all vehicles would generally use).
+void G_SetSharedVehicleFunctions( vehicleInfo_t *pVehInfo )
+{
+//	pVehInfo->AnimateVehicle				=		AnimateVehicle;
+//	pVehInfo->AnimateRiders					=		AnimateRiders;
+	pVehInfo->ValidateBoard					=		ValidateBoard;
+	pVehInfo->SetParent						=		SetParent;
+	pVehInfo->SetPilot						=		SetPilot;
+	pVehInfo->AddPassenger					=		AddPassenger;
+	pVehInfo->Animate						=		Animate;
+	pVehInfo->Board							=		Board;
+	pVehInfo->Eject							=		Eject;
+	pVehInfo->EjectAll						=		EjectAll;
+	pVehInfo->StartDeathDelay				=		StartDeathDelay;
+	pVehInfo->DeathUpdate					=		DeathUpdate;
+	pVehInfo->RegisterAssets				=		RegisterAssets;
+	pVehInfo->Initialize					=		Initialize;
+	pVehInfo->Update						=		Update;
+	pVehInfo->UpdateRider					=		UpdateRider;
+//	pVehInfo->ProcessMoveCommands			=		ProcessMoveCommands;
+//	pVehInfo->ProcessOrientCommands			=		ProcessOrientCommands;
+	pVehInfo->AttachRiders					=		AttachRiders;
+	pVehInfo->Ghost							=		Ghost;
+	pVehInfo->UnGhost						=		UnGhost;
+	pVehInfo->Inhabited						=		Inhabited;
+}
+
+#ifdef _JK2MP
+//get rid of all the crazy defs we added for this file
+#undef currentAngles
+#undef currentOrigin
+#undef mins
+#undef maxs
+#undef legsAnimTimer
+#undef torsoAnimTimer
+#undef bool
+#undef false
+#undef true
+
+#undef sqrtf
+
+#undef MOD_EXPLOSIVE
+#endif
diff --git a/code/game/g_vehicles.h b/code/game/g_vehicles.h
new file mode 100644
index 0000000..0b12152
--- /dev/null
+++ b/code/game/g_vehicles.h
@@ -0,0 +1,624 @@
+#ifndef __G_VEHICLES_H
+#define __G_VEHICLES_H
+
+#include "q_shared.h"
+#include "g_public.h"			   
+
+typedef enum
+{
+	VH_NONE = 0,
+	VH_WALKER,		//something you ride inside of, it walks like you, like an AT-ST
+	VH_FIGHTER,		//something you fly inside of, like an X-Wing or TIE fighter
+	VH_SPEEDER,		//something you ride on that hovers, like a speeder or swoop
+	VH_ANIMAL,		//animal you ride on top of that walks, like a tauntaun
+	VH_FLIER,		//animal you ride on top of that flies, like a giant mynoc?
+	VH_NUM_VEHICLES
+} vehicleType_t;
+
+enum	EWeaponPose
+{
+	WPOSE_NONE	= 0,
+	WPOSE_BLASTER,
+	WPOSE_SABERLEFT,
+	WPOSE_SABERRIGHT,
+};
+
+extern stringID_table_t VehicleTable[VH_NUM_VEHICLES+1];
+
+#define NO_PILOT_DIE_TIME 10000
+
+//===========================================================================================================
+//START VEHICLE WEAPONS
+//===========================================================================================================
+typedef struct
+{
+//*** IMPORTANT!!! *** the number of variables in the vehWeaponStats_t struct (including all elements of arrays) must be reflected by NUM_VWEAP_PARMS!!!
+//*** IMPORTANT!!! *** vWeapFields table correponds to this structure!
+	char	*name;
+	qboolean	bIsProjectile;	//traceline or entity?
+	qboolean	bHasGravity;	//if a projectile, drops
+	qboolean	bIonWeapon;//disables ship shields and sends them out of control
+	qboolean	bSaberBlockable;//lightsabers can deflect this projectile
+	int		iMuzzleFX;	//index of Muzzle Effect
+	int		iModel;		//handle to the model used by this projectile
+	int		iShotFX;	//index of Shot Effect
+	int		iImpactFX;	//index of Impact Effect
+	int		iG2MarkShaderHandle;	//index of shader to use for G2 marks made on other models when hit by this projectile
+	float	fG2MarkSize;//size (diameter) of the ghoul2 mark
+	int		iLoopSound;	//index of loopSound
+	float	fSpeed;		//speed of projectile/range of traceline
+	float	fHoming;		//0.0 = not homing, 0.5 = half vel to targ, half cur vel, 1.0 = all vel to targ
+	int		iLockOnTime;	//0 = no lock time needed, else # of ms needed to lock on
+	int		iDamage;		//damage done when traceline or projectile directly hits target
+	int		iSplashDamage;//damage done to ents in splashRadius of end of traceline or projectile origin on impact
+	float	fSplashRadius;//radius that ent must be in to take splashDamage (linear fall-off)
+	int		iAmmoPerShot;	//how much "ammo" each shot takes
+	int		iHealth;		//if non-zero, projectile can be shot, takes this much damage before being destroyed
+	float	fWidth;		//width of traceline or bounding box of projecile (non-rotating!)
+	float	fHeight;		//height of traceline or bounding box of projecile (non-rotating!)
+	int		iLifeTime;	//removes itself after this amount of time
+	qboolean	bExplodeOnExpire;	//when iLifeTime is up, explodes rather than simply removing itself
+} vehWeaponInfo_t;
+//NOTE: this MUST stay up to date with the number of variables in the vehFields table!!!
+#define NUM_VWEAP_PARMS	24
+
+#define	VWFOFS(x) ((int)&(((vehWeaponInfo_t *)0)->x))
+
+#define MAX_VEH_WEAPONS	16	//sigh... no more than 16 different vehicle weapons
+#define VEH_WEAPON_BASE	0
+#define VEH_WEAPON_NONE	-1
+
+extern vehWeaponInfo_t g_vehWeaponInfo[MAX_VEH_WEAPONS];
+extern int	numVehicleWeapons;
+
+//===========================================================================================================
+//END VEHICLE WEAPONS
+//===========================================================================================================
+
+// The maximum number of muzzles a vehicle may have.
+#define		MAX_VEHICLE_MUZZLES			10
+
+// The maximum number of exhausts a vehicle may have.
+#define		MAX_VEHICLE_EXHAUSTS		4
+
+// The maxiumum number of different weapons a vehicle may have
+#define		MAX_VEHICLE_WEAPONS			2
+#define		MAX_VEHICLE_TURRETS			2
+#define		MAX_VEHICLE_TURRET_MUZZLES	2
+
+typedef struct
+{
+	int			iWeapon;	//what vehWeaponInfo index to use
+	int			iDelay;		//delay between turret muzzle shots
+	int			iAmmoMax;	//how much ammo it has
+	int			iAmmoRechargeMS;	//how many MS between every point of recharged ammo
+	char		*yawBone;	//bone on ship that this turret uses to yaw
+	char		*pitchBone;	//bone on ship that this turret uses to pitch
+	int			yawAxis;	//axis on yawBone to which we should to apply the yaw angles
+	int			pitchAxis;	//axis on pitchBone to which we should to apply the pitch angles
+	float		yawClampLeft;	//how far the turret is allowed to turn left
+	float		yawClampRight;	//how far the turret is allowed to turn right
+	float		pitchClampUp;	//how far the turret is allowed to title up
+	float		pitchClampDown; //how far the turret is allowed to tilt down
+	int			iMuzzle[MAX_VEHICLE_TURRET_MUZZLES];//iMuzzle-1 = index of ship's muzzle to fire this turret's 1st and 2nd shots from
+	char		*gunnerViewTag;//Where to put the view origin of the gunner (name)
+	float		fTurnSpeed;	//how quickly the turret can turn
+	qboolean	bAI;	//whether or not the turret auto-targets enemies when it's not manned
+	qboolean	bAILead;//whether
+	float		fAIRange;	//how far away the AI will look for enemies
+	int			passengerNum;//which passenger, if any, has control of this turret (overrides AI)
+} turretStats_t;
+
+typedef struct
+{
+//*** IMPORTANT!!! *** See note at top of next structure!!! ***
+	// Weapon stuff.
+	int			ID;//index into the weapon data
+	// The delay between shots for each weapon.
+	int			delay;
+	// Whether or not all the muzzles for each weapon can be linked together (linked delay = weapon delay * number of muzzles linked!)
+	int			linkable;
+	// Whether or not to auto-aim the projectiles/tracelines at the thing under the crosshair when we fire
+	qboolean	aimCorrect;
+	//maximum ammo
+	int			ammoMax;
+	//ammo recharge rate - milliseconds per unit (minimum of 100, which is 10 ammo per second)
+	int			ammoRechargeMS;
+	//sound to play when out of ammo (plays default "no ammo" sound if none specified)
+	int			soundNoAmmo;
+} vehWeaponStats_t;
+
+// Compiler pre-define.
+struct Vehicle_t;
+
+typedef struct
+{
+//*** IMPORTANT!!! *** vehFields table correponds to this structure!
+	char		*name;	//unique name of the vehicle
+
+	//general data
+	vehicleType_t	type;	//what kind of vehicle
+	int			numHands;	//if 2 hands, no weapons, if 1 hand, can use 1-handed weapons, if 0 hands, can use 2-handed weapons
+	float		lookPitch;	//How far you can look up and down off the forward of the vehicle
+	float		lookYaw;	//How far you can look left and right off the forward of the vehicle
+	float		length;		//how long it is - used for body length traces when turning/moving?
+	float		width;		//how wide it is - used for body length traces when turning/moving?
+	float		height;		//how tall it is - used for body length traces when turning/moving?
+	vec3_t		centerOfGravity;//offset from origin: {forward, right, up} as a modifier on that dimension (-1.0f is all the way back, 1.0f is all the way forward)
+
+	//speed stats
+	float		speedMax;		//top speed
+	float		turboSpeed;		//turbo speed
+	float		speedMin;		//if < 0, can go in reverse
+	float		speedIdle;		//what speed it drifts to when no accel/decel input is given
+	float		accelIdle;		//if speedIdle > 0, how quickly it goes up to that speed
+	float		acceleration;	//when pressing on accelerator
+	float		decelIdle;		//when giving no input, how quickly it drops to speedIdle
+	float		throttleSticks;	//if true, speed stays at whatever you accel/decel to, unless you turbo or brake
+	float		strafePerc;		//multiplier on current speed for strafing.  If 1.0f, you can strafe at the same speed as you're going forward, 0.5 is half, 0 is no strafing
+
+	//handling stats
+	float		bankingSpeed;	//how quickly it pitches and rolls (not under player control)
+	float		rollLimit;		//how far it can roll to either side
+	float		pitchLimit;		//how far it can roll forward or backward
+	float		braking;		//when pressing on decelerator
+	float		mouseYaw;		// The mouse yaw override.
+	float		mousePitch;		// The mouse pitch override.
+	float		turningSpeed;	//how quickly you can turn
+	qboolean	turnWhenStopped;//whether or not you can turn when not moving
+	float		traction;		//how much your command input affects velocity
+	float		friction;		//how much velocity is cut on its own
+	float		maxSlope;		//the max slope that it can go up with control
+	qboolean	speedDependantTurning;//vehicle turns faster the faster it's going
+
+	//durability stats
+	int			mass;			//for momentum and impact force (player mass is 10)
+	int			armor;			//total points of damage it can take
+	int			shields;		//energy shield damage points
+	int			shieldRechargeMS;//energy shield milliseconds per point recharged
+	float		toughness;		//modifies incoming damage, 1.0 is normal, 0.5 is half, etc.  Simulates being made of tougher materials/construction
+	int			malfunctionArmorLevel;//when armor drops to or below this point, start malfunctioning
+	int			surfDestruction; //can parts of this thing be torn off on impact? -rww
+
+	//individual "area" health -rww
+	int			health_front;
+	int			health_back;
+	int			health_right;
+	int			health_left;
+
+	//visuals & sounds
+	char		*model;			//what model to use - if make it an NPC's primary model, don't need this?
+	char		*skin;			//what skin to use - if make it an NPC's primary model, don't need this?
+	int			g2radius;		//render radius for the ghoul2 model
+	int			riderAnim;		//what animation the rider uses
+	int			radarIconHandle;//what icon to show on radar in MP
+	char		*droidNPC;		//NPC to attach to *droidunit tag (if it exists in the model)
+
+	int			soundOn;		//sound to play when get on it
+	int			soundOff;		//sound to play when get off
+	int			soundLoop;		//sound to loop while riding it
+	int			soundTakeOff;	//sound to play when ship takes off
+	int			soundEngineStart;//sound to play when ship's thrusters first activate
+	int			soundSpin;		//sound to loop while spiraling out of control
+	int			soundTurbo;		//sound to play when turbo/afterburner kicks in
+	int			soundHyper;		//sound to play when ship lands
+	int			soundLand;		//sound to play when ship lands
+	int			soundFlyBy;		//sound to play when they buzz you
+	int			soundFlyBy2;	//alternate sound to play when they buzz you
+	int			soundShift1;	//sound to play when accelerating
+	int			soundShift2;	//sound to play when accelerating
+	int			soundShift3;	//sound to play when decelerating
+	int			soundShift4;	//sound to play when decelerating
+
+	int			iExhaustFX;		//exhaust effect, played from "*exhaust" bolt(s)
+	int			iTurboFX;		//turbo exhaust effect, played from "*exhaust" bolt(s) when ship is in "turbo" mode
+	int			iTurboStartFX;	//turbo begin effect, played from "*exhaust" bolts when "turbo" mode begins
+	int			iTrailFX;		//trail effect, played from "*trail" bolt(s)
+	int			iImpactFX;		//impact effect, for when it bumps into something
+	int			iExplodeFX;		//explosion effect, for when it blows up (should have the sound built into explosion effect)
+	int			iWakeFX;		//effect it makes when going across water
+	int			iDmgFX;			//effect to play on damage from a weapon or something
+	int			iArmorLowFX;	//played when armor is less than 30% of full
+	int			iArmorGoneFX;	//played when on armor is completely gone
+	
+	//Weapon stats
+	vehWeaponStats_t	weapon[MAX_VEHICLE_WEAPONS];
+
+	// Which weapon a muzzle fires (has to match one of the weapons this vehicle has). So 1 would be weapon 1,
+	// 2 would be weapon 2 and so on.
+	int			weapMuzzle[MAX_VEHICLE_MUZZLES];
+
+	//turrets (if any) on the vehicle
+	turretStats_t	turret[MAX_VEHICLE_TURRETS];
+
+	// The max height before this ship (?) starts (auto)landing.
+	float landingHeight;
+
+	//other misc stats
+	int			gravity;		//normal is 800
+	float		hoverHeight;	//if 0, it's a ground vehicle
+	float		hoverStrength;	//how hard it pushes off ground when less than hover height... causes "bounce", like shocks
+	qboolean	waterProof;		//can drive underwater if it has to
+	float		bouyancy;		//when in water, how high it floats (1 is neutral bouyancy)
+	int			fuelMax;		//how much fuel it can hold (capacity)
+	int			fuelRate;		//how quickly is uses up fuel
+	int			turboDuration;	//how long turbo lasts
+	int			turboRecharge;	//how long turbo takes to recharge
+	int			visibility;		//for sight alerts
+	int			loudness;		//for sound alerts
+	float		explosionRadius;//range of explosion
+	int			explosionDamage;//damage of explosion
+
+	int			maxPassengers;	// The max number of passengers this vehicle may have (Default = 0).
+	qboolean	hideRider;		// rider (and passengers?) should not be drawn
+	qboolean	killRiderOnDeath;//if rider is on vehicle when it dies, they should die
+	qboolean	flammable;		//whether or not the vehicle should catch on fire before it explodes
+	int			explosionDelay;	//how long the vehicle should be on fire/dying before it explodes
+	//camera stuff
+	qboolean	cameraOverride;	//whether or not to use all of the following 3rd person camera override values
+	float		cameraRange;	//how far back the camera should be - normal is 80
+	float		cameraVertOffset;//how high over the vehicle origin the camera should be - normal is 16
+	float		cameraHorzOffset;//how far to left/right (negative/positive) of of the vehicle origin the camera should be - normal is 0
+	float		cameraPitchOffset;//a modifier on the camera's pitch (up/down angle) to the vehicle - normal is 0
+	float		cameraFOV;		//third person camera FOV, default is 80
+	float		cameraAlpha;	//fade out the vehicle to this alpha (0.1-1.0f) if it's in the way of the crosshair
+	qboolean	cameraPitchDependantVertOffset;//use the hacky AT-ST pitch dependant vertical offset
+
+	//NOTE: some info on what vehicle weapon to use?  Like ATST or TIE bomber or TIE fighter or X-Wing...?
+
+//===VEH_PARM_MAX========================================================================
+//*** IMPORTANT!!! *** vehFields table correponds to this structure!
+
+//THE FOLLOWING FIELDS are not in the vehFields table because they are internal variables, not read in from the .veh file
+	int			modelIndex;		//set internally, not until this vehicle is spawned into the level
+
+	// NOTE: Please note that most of this stuff has been converted from C++ classes to generic C.
+	// This part of the structure is used to simulate inheritance for vehicles. The basic idea is that all vehicle use
+	// this vehicle interface since they declare their own functions and assign the function pointer to the
+	// corresponding function. Meanwhile, the base logic can still call the appropriate functions. In C++ talk all
+	// of these functions (pointers) are pure virtuals and this is an abstract base class (although it cannot be
+	// inherited from, only contained and reimplemented (through an object and a setup function respectively)). -AReis
+
+	// Makes sure that the vehicle is properly animated.
+	void (*AnimateVehicle)( Vehicle_t *pVeh );
+
+	// Makes sure that the rider's in this vehicle are properly animated.
+	void (*AnimateRiders)( Vehicle_t *pVeh );
+
+	// Determine whether this entity is able to board this vehicle or not.
+	bool (*ValidateBoard)( Vehicle_t *pVeh, gentity_t *pEnt );
+
+	// Set the parent entity of this Vehicle NPC.
+	void (*SetParent)( Vehicle_t *pVeh, gentity_t *pParentEntity );
+
+	// Add a pilot to the vehicle.
+	void (*SetPilot)( Vehicle_t *pVeh, gentity_t *pPilot );
+
+	// Add a passenger to the vehicle (false if we're full).
+	bool (*AddPassenger)( Vehicle_t *pVeh );
+
+	// Animate the vehicle and it's riders.
+	void (*Animate)( Vehicle_t *pVeh );
+
+	// Board this Vehicle (get on). The first entity to board an empty vehicle becomes the Pilot.
+	bool (*Board)( Vehicle_t *pVeh, gentity_t *pEnt );
+
+	// Eject an entity from the vehicle.
+	bool (*Eject)( Vehicle_t *pVeh, gentity_t *pEnt, qboolean forceEject );
+
+	// Eject all the inhabitants of this vehicle.
+	bool (*EjectAll)( Vehicle_t *pVeh );	
+
+	// Start a delay until the vehicle dies.
+	void (*StartDeathDelay)( Vehicle_t *pVeh, int iDelayTime );
+
+	// Update death sequence.
+	void (*DeathUpdate)( Vehicle_t *pVeh );
+	
+	// Register all the assets used by this vehicle.
+	void (*RegisterAssets)( Vehicle_t *pVeh );
+	
+	// Initialize the vehicle (should be called by Spawn?).
+	bool (*Initialize)( Vehicle_t *pVeh );
+
+	// Like a think or move command, this updates various vehicle properties.
+	bool (*Update)( Vehicle_t *pVeh, const usercmd_t *pUcmd );
+
+	// Update the properties of a Rider (that may reflect what happens to the vehicle).
+	//
+	//	[return]		bool			True if still in vehicle, false if otherwise.
+	bool (*UpdateRider)( Vehicle_t *pVeh, gentity_t *pRider, usercmd_t *pUcmd );
+
+	// ProcessMoveCommands the Vehicle.
+	void (*ProcessMoveCommands)( Vehicle_t *pVeh );
+
+	// ProcessOrientCommands the Vehicle.
+	void (*ProcessOrientCommands)( Vehicle_t *pVeh );
+	
+	// Attachs all the riders of this vehicle to their appropriate position/tag (*driver, *pass1, *pass2, whatever...).
+	void (*AttachRiders)( Vehicle_t *pVeh );
+
+	// Make someone invisible and un-collidable.
+	void (*Ghost)( Vehicle_t *pVeh, gentity_t *pEnt );
+
+	// Make someone visible and collidable.
+	void (*UnGhost)( Vehicle_t *pVeh, gentity_t *pEnt );
+
+	// Get the pilot of this vehicle.
+	const gentity_t *(*GetPilot)( Vehicle_t *pVeh );
+
+	// Whether this vehicle is currently inhabited (by anyone) or not.
+	bool (*Inhabited)( Vehicle_t *pVeh );
+} vehicleInfo_t;
+
+#define	VFOFS(x) ((int)&(((vehicleInfo_t *)0)->x))
+
+#define MAX_VEHICLES	16	//sigh... no more than 64 individual vehicles
+extern vehicleInfo_t g_vehicleInfo[MAX_VEHICLES];
+extern int	numVehicles;
+
+// Load the function pointers for a vehicle into this shared vehicle info structure.
+extern void G_SetSpeederVehicleFunctions( vehicleInfo_t *pVehInfo );
+extern void G_SetAnimalVehicleFunctions( vehicleInfo_t *pVehInfo );
+extern void G_SetFighterVehicleFunctions( vehicleInfo_t *pVehInfo );
+extern void G_SetWalkerVehicleFunctions( vehicleInfo_t *pVehInfo );
+
+// Setup the shared functions (one's that all vehicles would generally use).
+extern void G_SetSharedVehicleFunctions( vehicleInfo_t *pVehInfo );
+
+// Create/Allocate a new Animal Vehicle (initializing it as well).
+extern void G_CreateSpeederNPC( Vehicle_t **pVeh, const char *strType );
+extern void G_CreateAnimalNPC( Vehicle_t **pVeh, const char *strType );
+extern void G_CreateFighterNPC( Vehicle_t **pVeh, const char *strType );
+extern void G_CreateWalkerNPC( Vehicle_t **pVeh, const char *strType );
+
+#define VEH_DEFAULT_SPEED_MAX		800.0f
+#define VEH_DEFAULT_ACCEL			10.0f
+#define VEH_DEFAULT_DECEL			10.0f
+#define VEH_DEFAULT_STRAFE_PERC		0.5f
+#define VEH_DEFAULT_BANKING_SPEED	0.5f
+#define VEH_DEFAULT_ROLL_LIMIT		60.0f
+#define VEH_DEFAULT_PITCH_LIMIT		90.0f
+#define VEH_DEFAULT_BRAKING			10.0f
+#define VEH_DEFAULT_TURNING_SPEED	1.0f
+#define VEH_DEFAULT_TRACTION		8.0f
+#define VEH_DEFAULT_FRICTION		1.0f
+#define VEH_DEFAULT_MAX_SLOPE		0.85f
+#define VEH_DEFAULT_MASS			200
+#define VEH_DEFAULT_MAX_ARMOR		200
+#define VEH_DEFAULT_TOUGHNESS		2.5f
+#define VEH_DEFAULT_GRAVITY			800
+#define VEH_DEFAULT_HOVER_HEIGHT	64.0f
+#define VEH_DEFAULT_HOVER_STRENGTH	10.0f
+#define VEH_DEFAULT_VISIBILITY		0
+#define VEH_DEFAULT_LOUDNESS		0
+#define VEH_DEFAULT_EXP_RAD			400.0f
+#define VEH_DEFAULT_EXP_DMG			1000
+#define VEH_MAX_PASSENGERS			10
+
+#define VEH_MOUNT_THROW_LEFT		-5
+#define	VEH_MOUNT_THROW_RIGHT		-6
+
+#define MAX_STRAFE_TIME				2000.0f//FIXME: extern?
+#define	MIN_LANDING_SPEED			200//equal to or less than this and close to ground = auto-slow-down to land
+#define	MIN_LANDING_SLOPE			0.8f//must be pretty flat to land on the surf
+
+#define VEHICLE_BASE				0
+#define VEHICLE_NONE				-1
+
+enum
+{
+	VEH_EJECT_LEFT, 
+	VEH_EJECT_RIGHT, 
+	VEH_EJECT_FRONT, 
+	VEH_EJECT_REAR, 
+	VEH_EJECT_TOP, 
+	VEH_EJECT_BOTTOM
+};
+
+// Vehicle flags.
+enum
+{
+	VEH_NONE = 0, VEH_FLYING = 0x00000001, VEH_CRASHING = 0x00000002,
+	VEH_LANDING = 0x00000004, VEH_BUCKING = 0x00000010, VEH_WINGSOPEN = 0x00000020,
+	VEH_GEARSOPEN = 0x00000040, VEH_SLIDEBREAKING = 0x00000080, VEH_SPINNING = 0x00000100,
+	VEH_OUTOFCONTROL = 0x00000200,
+	VEH_SABERINLEFTHAND = 0x00000400,
+	VEH_STRAFERAM = 0x00000800,
+	VEH_ACCELERATORON = 0x00001000,
+	VEH_ARMORLOW = 0x00002000,
+	VEH_ARMORGONE = 0x00004000
+};
+//externed functions
+//extern void G_DriveVehicle( gentity_t *ent, gentity_t *vehEnt, char *vehicleName );
+/*extern void G_VehicleStartExplosionDelay( gentity_t *self );
+extern void VehicleExplosionDelay( gentity_t *self );
+extern void G_VehicleRegisterAssets( int vehicleIndex );
+extern void G_DriveATST( gentity_t *ent, gentity_t *atst );
+extern void G_VehicleInitialize( gentity_t *vehEnt );*/
+extern void G_VehicleSpawn( gentity_t *self );
+
+// A vehicle weapon muzzle.
+struct Muzzle
+{
+	// These are updated every frame and represent the current position and direction for the specific muzzle.
+	vec3_t m_vMuzzlePos;
+	vec3_t m_vMuzzleDir;
+
+	// This is how long to wait before being able to fire a specific muzzle again. This is based on the firing rate
+	// so that a firing rate of 10 rounds/sec would make this value initially 100 miliseconds. 
+	int m_iMuzzleWait;
+
+	// whether this Muzzle was just fired or not (reset at muzzle flash code).
+	bool m_bFired;
+
+};
+
+//defines for impact damage surface stuff
+#define	SHIPSURF_FRONT		1
+#define	SHIPSURF_BACK		2
+#define	SHIPSURF_RIGHT		3
+#define	SHIPSURF_LEFT		4
+
+#define	SHIPSURF_DAMAGE_FRONT_LIGHT		1
+#define	SHIPSURF_DAMAGE_BACK_LIGHT		2
+#define	SHIPSURF_DAMAGE_RIGHT_LIGHT		3
+#define	SHIPSURF_DAMAGE_LEFT_LIGHT		4
+#define	SHIPSURF_DAMAGE_FRONT_HEAVY		5
+#define	SHIPSURF_DAMAGE_BACK_HEAVY		6
+#define	SHIPSURF_DAMAGE_RIGHT_HEAVY		7
+#define	SHIPSURF_DAMAGE_LEFT_HEAVY		8
+
+//generic part bits
+#define SHIPSURF_BROKEN_A	(1<<0) //gear 1
+#define SHIPSURF_BROKEN_B	(1<<1) //gear 1
+#define SHIPSURF_BROKEN_C	(1<<2) //wing 1
+#define SHIPSURF_BROKEN_D	(1<<3) //wing 2
+#define SHIPSURF_BROKEN_E	(1<<4) //wing 3
+#define SHIPSURF_BROKEN_F	(1<<5) //wing 4
+
+typedef struct
+{
+	//linked firing mode
+	qboolean	linked;//weapon 1's muzzles are in linked firing mode
+	//current weapon ammo
+	int			ammo;
+	//debouncer for ammo recharge
+	int			lastAmmoInc;
+	//which muzzle will fire next
+	int			nextMuzzle;
+} vehWeaponStatus_t;
+
+typedef struct
+{
+	//current weapon ammo
+	int			ammo;
+	//debouncer for ammo recharge
+	int			lastAmmoInc;
+	//which muzzle will fire next
+	int			nextMuzzle;
+	//which entity they're after
+	int			enemyEntNum;
+	//how long to hold on to our current enemy
+	int			enemyHoldTime;
+} vehTurretStatus_t;
+
+// This is the implementation of the vehicle interface and any of the other variables needed. This
+// is what actually represents a vehicle. -AReis.
+// !!!!!!!!!!!!!!!!!! loadsave affecting structure !!!!!!!!!!!!!!!!!!!!!!!
+struct Vehicle_t
+{
+	// The entity who pilots/drives this vehicle.
+	// NOTE: This is redundant (since m_pParentEntity->owner _should_ be the pilot). This makes things clearer though.
+	gentity_t *m_pPilot;
+
+	int m_iPilotTime; //if spawnflag to die without pilot and this < level.time then die.
+	qboolean m_bHasHadPilot; //qtrue once the vehicle gets its first pilot
+
+	//the droid unit NPC for this vehicle, if any
+	gentity_t *m_pDroidUnit;
+
+	// The entity from which this NPC comes from.
+	gentity_t *m_pParentEntity;
+
+	// If not zero, how long to wait before we can do anything with the vehicle (we're getting on still).
+	// -1 = board from left, -2 = board from right, -3 = jump/quick board.  -4 & -5 = throw off existing pilot
+	int		m_iBoarding;
+
+	// Used to check if we've just started the boarding process
+	bool	m_bWasBoarding;
+
+	// The speed the vehicle maintains while boarding occurs (often zero)
+	vec3_t	m_vBoardingVelocity;
+
+	// Time modifier (must only be used in ProcessMoveCommands() and ProcessOrientCommands() and is updated in Update()).
+	float m_fTimeModifier;
+
+	// Ghoul2 Animation info.
+	// NOTE: Since each vehicle has their own model instance, these bolts must be local to each vehicle as well.
+	int m_iLeftWingBone;
+	int m_iRightWingBone;
+	//int m_iDriverTag;
+	int m_iExhaustTag[MAX_VEHICLE_EXHAUSTS];
+	int m_iMuzzleTag[MAX_VEHICLE_MUZZLES];
+	int m_iDroidUnitTag;
+	int	m_iGunnerViewTag[MAX_VEHICLE_TURRETS];//Where to put the view origin of the gunner (index)
+
+	// This vehicles weapon muzzles.
+	Muzzle m_Muzzles[MAX_VEHICLE_MUZZLES];
+
+	// The user commands structure.
+	usercmd_t m_ucmd;
+
+	// The direction an entity will eject from the vehicle towards.
+	int m_EjectDir;
+
+	// Flags that describe the vehicles behavior.
+	unsigned long m_ulFlags;
+
+	// NOTE: Vehicle Type ID, Orientation, and Armor MUST be transmitted over the net.
+
+	// Current angles of this vehicle.
+	vec3_t		m_vOrientation;
+
+	// How long you have strafed left or right (increments every frame that you strafe to right, decrements every frame you strafe left)
+	int			m_fStrafeTime;	
+
+	// Previous angles of this vehicle.
+	vec3_t		m_vPrevOrientation;
+
+	// When control is lost on a speeder, current angular velocity is stored here and applied until landing
+	float		m_vAngularVelocity;
+
+	vec3_t		m_vFullAngleVelocity;
+
+	// Current armor and shields of your vehicle (explodes if armor to 0).
+	int			m_iArmor;	//hull strength - STAT_HEALTH on NPC
+	int			m_iShields;	//energy shielding - STAT_ARMOR on NPC
+
+	// Timer for all cgame-FX...? ex: exhaust?
+	int			m_iLastFXTime; 
+
+	// When to die.
+	int			m_iDieTime;
+
+	// This pointer is to a valid VehicleInfo (which could be an animal, speeder, fighter, whatever). This
+	// contains the functions actually used to do things to this specific kind of vehicle as well as shared
+	// information (max speed, type, etc...).
+	vehicleInfo_t *m_pVehicleInfo;
+
+	// This trace tells us if we're within landing height.
+	trace_t m_LandTrace;
+
+	//bitflag of surfaces that have broken off
+	int			m_iRemovedSurfaces;
+
+	// the last time this vehicle fired a turbo burst
+	int			m_iTurboTime;
+
+	//how long it should drop like a rock for after freed from SUSPEND
+	int			m_iDropTime;
+
+	int			m_iSoundDebounceTimer;
+
+	//last time we incremented the shields
+	int			lastShieldInc;
+
+	//so we don't hold it down and toggle it back and forth
+	qboolean	linkWeaponToggleHeld;
+
+	//info about our weapons (linked, ammo, etc.)
+	vehWeaponStatus_t	weaponStatus[MAX_VEHICLE_WEAPONS];
+	vehTurretStatus_t	turretStatus[MAX_VEHICLE_TURRETS];
+
+	//the guy who was previously the pilot
+	gentity_t*	m_pOldPilot;
+
+	// don't need these in mp
+	int			m_safeJumpMountTime;
+	float		m_safeJumpMountRightDot;
+};
+
+extern int BG_VehicleGetIndex( const char *vehicleName );
+
+#endif	// __G_VEHICLES_H
diff --git a/code/game/g_weapon.cpp b/code/game/g_weapon.cpp
new file mode 100644
index 0000000..f6435f7
--- /dev/null
+++ b/code/game/g_weapon.cpp
@@ -0,0 +1,5357 @@
+// g_weapon.c 
+// perform the server side effects of a weapon firing
+
+// leave this line at the top for all g_xxxx.cpp files...
+#include "g_headers.h"
+
+
+
+#include "g_local.h"
+#include "g_functions.h"
+#include "anims.h"
+#include "b_local.h"
+#include "wp_saber.h"
+#include "g_vehicles.h"
+
+static	vec3_t	forward, vright, up;
+static	vec3_t	muzzle;
+
+void drop_charge(gentity_t *ent, vec3_t start, vec3_t dir);
+void ViewHeightFix( const gentity_t * const ent );
+qboolean LogAccuracyHit( gentity_t *target, gentity_t *attacker );
+extern qboolean G_BoxInBounds( const vec3_t point, const vec3_t mins, const vec3_t maxs, const vec3_t boundsMins, const vec3_t boundsMaxs );
+extern qboolean Jedi_DodgeEvasion( gentity_t *self, gentity_t *shooter, trace_t *tr, int hitLoc );
+extern qboolean PM_DroidMelee( int npc_class );
+extern void G_Knockdown( gentity_t *self, gentity_t *attacker, const vec3_t pushDir, float strength, qboolean breakSaberLock );
+extern qboolean G_HasKnockdownAnims( gentity_t *ent );
+
+static gentity_t *ent_list[MAX_GENTITIES];
+extern cvar_t	*g_debugMelee;
+
+// Bryar Pistol
+//--------
+#define BRYAR_PISTOL_VEL			1800
+#define BRYAR_PISTOL_DAMAGE			14
+#define BRYAR_CHARGE_UNIT			200.0f	// bryar charging gives us one more unit every 200ms--if you change this, you'll have to do the same in bg_pmove
+
+// E11 Blaster
+//---------
+#define BLASTER_MAIN_SPREAD			0.5f
+#define BLASTER_ALT_SPREAD			1.5f
+#define BLASTER_NPC_SPREAD			0.5f
+#define BLASTER_VELOCITY			2300
+#define BLASTER_NPC_VEL_CUT			0.5f
+#define BLASTER_NPC_HARD_VEL_CUT	0.7f
+#define BLASTER_DAMAGE				20
+#define	BLASTER_NPC_DAMAGE_EASY		6
+#define	BLASTER_NPC_DAMAGE_NORMAL	12 // 14
+#define	BLASTER_NPC_DAMAGE_HARD		16 // 18
+
+// Tenloss Disruptor
+//----------
+#define DISRUPTOR_MAIN_DAMAGE			14
+#define DISRUPTOR_NPC_MAIN_DAMAGE_EASY	5
+#define DISRUPTOR_NPC_MAIN_DAMAGE_MEDIUM	10
+#define DISRUPTOR_NPC_MAIN_DAMAGE_HARD	15
+
+#define DISRUPTOR_ALT_DAMAGE			12
+#define DISRUPTOR_NPC_ALT_DAMAGE_EASY	15
+#define DISRUPTOR_NPC_ALT_DAMAGE_MEDIUM	25
+#define DISRUPTOR_NPC_ALT_DAMAGE_HARD	30
+#define DISRUPTOR_ALT_TRACES			3		// can go through a max of 3 entities
+#define DISRUPTOR_CHARGE_UNIT			150.0f	// distruptor charging gives us one more unit every 150ms--if you change this, you'll have to do the same in bg_pmove
+
+// Wookie Bowcaster
+//----------
+#define	BOWCASTER_DAMAGE			45
+#define	BOWCASTER_VELOCITY			1300
+#define	BOWCASTER_NPC_DAMAGE_EASY	12
+#define	BOWCASTER_NPC_DAMAGE_NORMAL	24
+#define	BOWCASTER_NPC_DAMAGE_HARD	36
+#define BOWCASTER_SPLASH_DAMAGE		0
+#define BOWCASTER_SPLASH_RADIUS		0
+#define BOWCASTER_SIZE				2
+
+#define BOWCASTER_ALT_SPREAD		5.0f
+#define BOWCASTER_VEL_RANGE			0.3f
+#define BOWCASTER_CHARGE_UNIT		200.0f	// bowcaster charging gives us one more unit every 200ms--if you change this, you'll have to do the same in bg_pmove
+
+// Heavy Repeater
+//----------
+#define REPEATER_SPREAD				1.4f
+#define REPEATER_NPC_SPREAD			0.7f
+#define	REPEATER_DAMAGE				8
+#define	REPEATER_VELOCITY			1600
+#define	REPEATER_NPC_DAMAGE_EASY	2
+#define	REPEATER_NPC_DAMAGE_NORMAL	4
+#define	REPEATER_NPC_DAMAGE_HARD	6
+
+#define REPEATER_ALT_SIZE				3	// half of bbox size
+#define	REPEATER_ALT_DAMAGE				60
+#define REPEATER_ALT_SPLASH_DAMAGE		60
+#define REPEATER_ALT_SPLASH_RADIUS		128
+#define	REPEATER_ALT_VELOCITY			1100
+#define	REPEATER_ALT_NPC_DAMAGE_EASY	15
+#define	REPEATER_ALT_NPC_DAMAGE_NORMAL	30
+#define	REPEATER_ALT_NPC_DAMAGE_HARD	45
+
+// DEMP2
+//----------
+#define	DEMP2_DAMAGE				15
+#define	DEMP2_VELOCITY				1800
+#define	DEMP2_NPC_DAMAGE_EASY		6
+#define	DEMP2_NPC_DAMAGE_NORMAL		12
+#define	DEMP2_NPC_DAMAGE_HARD		18
+#define	DEMP2_SIZE					2		// half of bbox size
+
+#define DEMP2_ALT_DAMAGE			15
+#define DEMP2_CHARGE_UNIT			500.0f	// demp2 charging gives us one more unit every 500ms--if you change this, you'll have to do the same in bg_pmove
+#define DEMP2_ALT_RANGE				4096
+#define DEMP2_ALT_SPLASHRADIUS		256
+
+// Golan Arms Flechette
+//---------
+#define FLECHETTE_SHOTS				6
+#define FLECHETTE_SPREAD			4.0f
+#define FLECHETTE_DAMAGE			15
+#define FLECHETTE_VEL				3500
+#define FLECHETTE_SIZE				1
+
+#define FLECHETTE_ALT_DAMAGE		20
+#define FLECHETTE_ALT_SPLASH_DAM	20
+#define FLECHETTE_ALT_SPLASH_RAD	128
+
+// NOT CURRENTLY USED
+#define FLECHETTE_MINE_RADIUS_CHECK		200
+#define FLECHETTE_MINE_VEL				1000
+#define FLECHETTE_MINE_DAMAGE			100
+#define FLECHETTE_MINE_SPLASH_DAMAGE	200
+#define FLECHETTE_MINE_SPLASH_RADIUS	200
+
+// Personal Rocket Launcher
+//---------
+#define	ROCKET_VELOCITY				900
+#define	ROCKET_DAMAGE				100
+#define	ROCKET_SPLASH_DAMAGE		100
+#define	ROCKET_SPLASH_RADIUS		160
+#define ROCKET_NPC_DAMAGE_EASY		20
+#define ROCKET_NPC_DAMAGE_NORMAL	40
+#define ROCKET_NPC_DAMAGE_HARD		60
+#define ROCKET_SIZE					3
+
+#define	ROCKET_ALT_VELOCITY			(ROCKET_VELOCITY*0.5)
+#define ROCKET_ALT_THINK_TIME		100
+
+// some naughty little things that are used cg side
+int g_rocketLockEntNum = ENTITYNUM_NONE;
+int g_rocketLockTime = 0;
+int	g_rocketSlackTime = 0;
+
+// Concussion Rifle
+//---------
+//primary
+#define	CONC_VELOCITY				3000
+#define	CONC_DAMAGE					150
+#define CONC_NPC_SPREAD				0.7f
+#define	CONC_NPC_DAMAGE_EASY		15
+#define	CONC_NPC_DAMAGE_NORMAL		30
+#define	CONC_NPC_DAMAGE_HARD		50
+#define	CONC_SPLASH_DAMAGE			50
+#define	CONC_SPLASH_RADIUS			300
+//alt
+#define CONC_ALT_DAMAGE				225//100
+#define CONC_ALT_NPC_DAMAGE_EASY	10
+#define CONC_ALT_NPC_DAMAGE_MEDIUM	20
+#define CONC_ALT_NPC_DAMAGE_HARD	30
+
+// Emplaced Gun
+//--------------
+#define EMPLACED_VEL				6000	// very fast
+#define EMPLACED_DAMAGE				150		// and very damaging
+#define EMPLACED_SIZE				5		// make it easier to hit things
+
+// ATST Main Gun
+//--------------
+#define ATST_MAIN_VEL				4000	// 
+#define ATST_MAIN_DAMAGE			25		// 
+#define ATST_MAIN_SIZE				3		// make it easier to hit things
+
+// ATST Side Gun
+//---------------
+#define ATST_SIDE_MAIN_DAMAGE				75
+#define ATST_SIDE_MAIN_VELOCITY				1300
+#define ATST_SIDE_MAIN_NPC_DAMAGE_EASY		30
+#define ATST_SIDE_MAIN_NPC_DAMAGE_NORMAL	40
+#define ATST_SIDE_MAIN_NPC_DAMAGE_HARD		50
+#define ATST_SIDE_MAIN_SIZE					4
+#define ATST_SIDE_MAIN_SPLASH_DAMAGE		10	// yeah, pretty small, either zero out or make it worth having?
+#define ATST_SIDE_MAIN_SPLASH_RADIUS		16	// yeah, pretty small, either zero out or make it worth having?
+
+#define ATST_SIDE_ALT_VELOCITY				1100
+#define ATST_SIDE_ALT_NPC_VELOCITY			600
+#define ATST_SIDE_ALT_DAMAGE				130
+
+#define ATST_SIDE_ROCKET_NPC_DAMAGE_EASY	30
+#define ATST_SIDE_ROCKET_NPC_DAMAGE_NORMAL	50
+#define ATST_SIDE_ROCKET_NPC_DAMAGE_HARD	90
+
+#define	ATST_SIDE_ALT_SPLASH_DAMAGE			130
+#define	ATST_SIDE_ALT_SPLASH_RADIUS			200
+#define ATST_SIDE_ALT_ROCKET_SIZE			5
+#define ATST_SIDE_ALT_ROCKET_SPLASH_SCALE	0.5f	// scales splash for NPC's
+
+// Stun Baton
+//--------------
+#define STUN_BATON_DAMAGE			22
+#define STUN_BATON_ALT_DAMAGE		22
+#define STUN_BATON_RANGE			25
+
+// Laser Trip Mine
+//--------------
+#define LT_DAMAGE			150
+#define LT_SPLASH_RAD		256.0f
+#define LT_SPLASH_DAM		90
+
+#define LT_VELOCITY			250.0f
+#define LT_ALT_VELOCITY		1000.0f
+
+#define PROX_MINE_RADIUS_CHECK		190
+
+#define LT_SIZE				3.0f
+#define LT_ALT_TIME			2000
+#define	LT_ACTIVATION_DELAY	1000
+#define	LT_DELAY_TIME		50
+
+// Thermal Detonator
+//--------------
+#define TD_DAMAGE			100
+#define TD_NPC_DAMAGE_CUT	0.6f	// NPC thrown dets deliver only 60% of the damage that a player thrown one does
+#define TD_SPLASH_RAD		128
+#define TD_SPLASH_DAM		90
+#define TD_VELOCITY			900
+#define TD_MIN_CHARGE		0.15f
+#define TD_TIME				4000
+#define TD_THINK_TIME		300		// don't think too often?
+#define TD_TEST_RAD			(TD_SPLASH_RAD * 0.8f) // no sense in auto-blowing up if exactly on the radius edge--it would hardly do any damage
+#define TD_ALT_TIME			3000
+
+#define TD_ALT_DAMAGE		100
+#define TD_ALT_SPLASH_RAD	128
+#define TD_ALT_SPLASH_DAM	90
+#define TD_ALT_VELOCITY		600
+#define TD_ALT_MIN_CHARGE	0.15f
+#define TD_ALT_TIME			3000
+
+// Tusken Rifle Shot
+//--------------
+#define TUSKEN_RIFLE_VEL			3000	// fast
+#define TUSKEN_RIFLE_DAMAGE_EASY	20		// damaging
+#define TUSKEN_RIFLE_DAMAGE_MEDIUM	30		// very damaging
+#define TUSKEN_RIFLE_DAMAGE_HARD	50		// extremely damaging
+
+// Weapon Helper Functions
+float weaponSpeed[WP_NUM_WEAPONS][2] =
+{
+	0,0,//WP_NONE,
+	0,0,//WP_SABER,				 // NOTE: lots of code assumes this is the first weapon (... which is crap) so be careful -Ste.
+	BRYAR_PISTOL_VEL,BRYAR_PISTOL_VEL,//WP_BLASTER_PISTOL,
+	BLASTER_VELOCITY,BLASTER_VELOCITY,//WP_BLASTER,
+	Q3_INFINITE,Q3_INFINITE,//WP_DISRUPTOR,
+	BOWCASTER_VELOCITY,BOWCASTER_VELOCITY,//WP_BOWCASTER,
+	REPEATER_VELOCITY,REPEATER_ALT_VELOCITY,//WP_REPEATER,
+	DEMP2_VELOCITY,DEMP2_ALT_RANGE,//WP_DEMP2,
+	FLECHETTE_VEL,FLECHETTE_MINE_VEL,//WP_FLECHETTE,
+	ROCKET_VELOCITY,ROCKET_ALT_VELOCITY,//WP_ROCKET_LAUNCHER,
+	TD_VELOCITY,TD_ALT_VELOCITY,//WP_THERMAL,
+	0,0,//WP_TRIP_MINE,
+	0,0,//WP_DET_PACK,
+	CONC_VELOCITY,Q3_INFINITE,//WP_CONCUSSION,
+	0,0,//WP_MELEE,			// Any ol' melee attack
+	0,0,//WP_STUN_BATON,
+	BRYAR_PISTOL_VEL,BRYAR_PISTOL_VEL,//WP_BRYAR_PISTOL,
+	EMPLACED_VEL,EMPLACED_VEL,//WP_EMPLACED_GUN,
+	BRYAR_PISTOL_VEL,BRYAR_PISTOL_VEL,//WP_BOT_LASER,		// Probe droid	- Laser blast
+	0,0,//WP_TURRET,			// turret guns 
+	ATST_MAIN_VEL,ATST_MAIN_VEL,//WP_ATST_MAIN,
+	ATST_SIDE_MAIN_VELOCITY,ATST_SIDE_ALT_NPC_VELOCITY,//WP_ATST_SIDE,
+	EMPLACED_VEL,EMPLACED_VEL,//WP_TIE_FIGHTER,
+	EMPLACED_VEL,REPEATER_ALT_VELOCITY,//WP_RAPID_FIRE_CONC,
+	0,0,//WP_JAWA,
+	TUSKEN_RIFLE_VEL,TUSKEN_RIFLE_VEL,//WP_TUSKEN_RIFLE,
+	0,0,//WP_TUSKEN_STAFF,
+	0,0,//WP_SCEPTER,
+	0,0,//WP_NOGHRI_STICK,
+};
+
+float WP_SpeedOfMissileForWeapon( int wp, qboolean alt_fire )
+{
+	if ( alt_fire )
+	{
+		return weaponSpeed[wp][1];
+	}
+	return weaponSpeed[wp][0];
+}
+
+//-----------------------------------------------------------------------------
+static void WP_TraceSetStart( const gentity_t *ent, vec3_t start, const vec3_t mins, const vec3_t maxs )
+//-----------------------------------------------------------------------------
+{
+	//make sure our start point isn't on the other side of a wall
+	trace_t	tr;
+	vec3_t	entMins, newstart;
+	vec3_t	entMaxs;
+
+	VectorSet( entMaxs, 5, 5, 5 );
+	VectorScale( entMaxs, -1, entMins );
+
+	if ( !ent->client )
+	{
+		return;
+	}
+
+	VectorCopy( ent->currentOrigin, newstart );
+	newstart[2] = start[2]; // force newstart to be on the same plane as the muzzle ( start )
+
+	gi.trace( &tr, newstart, entMins, entMaxs, start, ent->s.number, MASK_SOLID|CONTENTS_SHOTCLIP );
+
+	if ( tr.startsolid || tr.allsolid )
+	{
+		// there is a problem here..
+		return;
+	}
+
+	if ( tr.fraction < 1.0f )
+	{
+		VectorCopy( tr.endpos, start );
+	}
+}
+
+extern Vehicle_t *G_IsRidingVehicle( gentity_t *ent );
+//-----------------------------------------------------------------------------
+gentity_t *CreateMissile( vec3_t org, vec3_t dir, float vel, int life, gentity_t *owner, qboolean altFire = qfalse )
+//-----------------------------------------------------------------------------
+{
+	gentity_t	*missile;
+
+	missile = G_Spawn();
+	
+	missile->nextthink = level.time + life;
+	missile->e_ThinkFunc = thinkF_G_FreeEntity;
+	missile->s.eType = ET_MISSILE;
+	missile->owner = owner;
+
+	Vehicle_t*	pVeh = G_IsRidingVehicle(owner);
+
+	missile->alt_fire = altFire;
+
+	missile->s.pos.trType = TR_LINEAR;
+	missile->s.pos.trTime = level.time;// - 10;	// move a bit on the very first frame
+	VectorCopy( org, missile->s.pos.trBase );
+	VectorScale( dir, vel, missile->s.pos.trDelta );
+ 	if (pVeh)
+	{
+ 		missile->s.eFlags |= EF_USE_ANGLEDELTA;
+	 	vectoangles(missile->s.pos.trDelta, missile->s.angles);
+	  	VectorMA(missile->s.pos.trDelta, 2.0f, pVeh->m_pParentEntity->client->ps.velocity, missile->s.pos.trDelta);
+	}
+
+	VectorCopy( org, missile->currentOrigin);
+	gi.linkentity( missile );
+
+	return missile;
+}
+
+
+//-----------------------------------------------------------------------------
+static void WP_Stick( gentity_t *missile, trace_t *trace, float fudge_distance = 0.0f )
+//-----------------------------------------------------------------------------
+{
+	vec3_t org, ang;
+
+	// not moving or rotating
+	missile->s.pos.trType = TR_STATIONARY;
+	VectorClear( missile->s.pos.trDelta );
+	VectorClear( missile->s.apos.trDelta );
+
+	// so we don't stick into the wall
+	VectorMA( trace->endpos, fudge_distance, trace->plane.normal, org ); 
+	G_SetOrigin( missile, org );
+
+	vectoangles( trace->plane.normal, ang );
+	G_SetAngles( missile, ang );
+
+	// I guess explode death wants me as the normal?
+//	VectorCopy( trace->plane.normal, missile->pos1 );
+	gi.linkentity( missile );
+}
+
+// This version shares is in the thinkFunc format
+//-----------------------------------------------------------------------------
+void WP_Explode( gentity_t *self )
+//-----------------------------------------------------------------------------
+{
+	gentity_t	*attacker = self;
+	vec3_t		forward={0,0,1};
+
+	// stop chain reaction runaway loops
+	self->takedamage = qfalse;
+
+	self->s.loopSound = 0;
+
+//	VectorCopy( self->currentOrigin, self->s.pos.trBase );
+	if ( !self->client )
+	{
+	AngleVectors( self->s.angles, forward, NULL, NULL );
+	}
+
+	if ( self->fxID > 0 )
+	{
+		G_PlayEffect( self->fxID, self->currentOrigin, forward );
+	}
+	
+	if ( self->owner )
+	{
+		attacker = self->owner;
+	}
+	else if ( self->activator )
+	{
+		attacker = self->activator;
+	}
+
+	if ( self->splashDamage > 0 && self->splashRadius > 0 )
+	{ 
+		G_RadiusDamage( self->currentOrigin, attacker, self->splashDamage, self->splashRadius, 0/*don't ignore attacker*/, MOD_EXPLOSIVE_SPLASH );
+	}
+
+	if ( self->target )
+	{
+		G_UseTargets( self, attacker );
+	}
+
+	G_SetOrigin( self, self->currentOrigin );
+
+	self->nextthink = level.time + 50;
+	self->e_ThinkFunc = thinkF_G_FreeEntity;
+}
+
+// We need to have a dieFunc, otherwise G_Damage won't actually make us die.  I could modify G_Damage, but that entails too many changes
+//-----------------------------------------------------------------------------
+void WP_ExplosiveDie( gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int meansOfDeath,int dFlags,int hitLoc )
+//-----------------------------------------------------------------------------
+{
+	self->enemy = attacker;
+
+	if ( attacker && !attacker->s.number )
+	{
+		// less damage when shot by player
+		self->splashDamage /= 3;
+		self->splashRadius /= 3;
+	}
+
+	self->s.eFlags &= ~EF_FIRING; // don't draw beam if we are dead
+
+	WP_Explode( self );
+}
+
+
+/*
+----------------------------------------------
+	PLAYER ITEMS
+----------------------------------------------
+*/
+/*
+#define		SEEKER_RADIUS	500
+
+gentity_t *SeekerAcquiresTarget ( gentity_t *ent, vec3_t pos )
+{
+	vec3_t		seekerPos;
+	float		angle;
+	gentity_t	*entityList[MAX_GENTITIES]; // targets within inital radius
+	gentity_t	*visibleTargets[MAX_GENTITIES]; // final filtered target list
+	int			numListedEntities;
+	int			i, e;
+	gentity_t	*target;
+	vec3_t		mins, maxs;
+
+	angle = cg.time * 0.004f;
+
+	// must match cg_effects ( CG_Seeker ) & g_weapon ( SeekerAcquiresTarget ) & cg_weapons ( CG_FireSeeker )
+	seekerPos[0] = ent->currentOrigin[0] + 18 * cos(angle);
+	seekerPos[1] = ent->currentOrigin[1] + 18 * sin(angle);
+	seekerPos[2] = ent->currentOrigin[2] + ent->client->ps.viewheight + 8 + (3*cos(level.time*0.001f));
+
+	for ( i = 0 ; i < 3 ; i++ )
+	{
+		mins[i] = seekerPos[i] - SEEKER_RADIUS;
+		maxs[i] = seekerPos[i] + SEEKER_RADIUS;
+	}
+
+	//	get potential targets within radius
+	numListedEntities = gi.EntitiesInBox( mins, maxs, entityList, MAX_GENTITIES );
+
+	i = 0; // reset counter
+
+	for ( e = 0 ; e < numListedEntities ; e++ )
+	{
+		target = entityList[e];
+
+		// seeker owner not a valid target
+		if ( target == ent )
+		{
+			continue;
+		}
+		
+		// only players are valid targets
+		if ( !target->client )
+		{
+			continue;
+		}
+
+		// teammates not valid targets
+		if ( OnSameTeam( ent, target ) )
+		{
+			continue;
+		}
+
+		// don't shoot at dead things
+		if ( target->health <= 0 )
+		{
+			continue;
+		}
+
+		if( CanDamage( target, seekerPos ) ) // visible target, so add it to the list
+		{
+			visibleTargets[i++] = entityList[e];
+		}
+	}
+
+	if ( i )
+	{
+		// ok, now we know there are i visible targets.  Pick one as the seeker's target
+		target = visibleTargets[Q_irand(0,i-1)];
+		VectorCopy( seekerPos, pos );
+		return target;
+	}
+
+	return NULL;
+}
+
+static void WP_FireBlasterMissile( gentity_t *ent, vec3_t start, vec3_t dir, qboolean altFire );
+void FireSeeker( gentity_t *owner, gentity_t *target, vec3_t origin, vec3_t dir )
+{
+	VectorSubtract( target->currentOrigin, origin, dir );
+	VectorNormalize( dir );
+
+	// for now I'm just using the scavenger bullet.
+	WP_FireBlasterMissile( owner, origin, dir, qfalse );
+}
+*/
+
+
+#ifdef _XBOX	// Auto-aim
+
+static float VectorDistanceSquared(vec3_t p1, vec3_t p2)
+{
+	vec3_t dir;
+	VectorSubtract(p2, p1, dir);
+	return VectorLengthSquared(dir);
+}
+
+int WP_FindClosestBodyPart(gentity_t *ent, gentity_t *other, vec3_t point, vec3_t out, int c = 0)
+{
+	int shortestLen = 509999;
+	char where = -1;
+	int len;
+	renderInfo_t *ri = NULL;
+	
+	ri = &ent->client->renderInfo;
+
+	if (ent->client)
+	{
+		if (c > 0)
+		{
+			where = c - 1;		// Fail safe, set to torso
+		}
+		else
+		{
+			len = VectorDistanceSquared(point, ri->eyePoint);
+			if (len < shortestLen) {
+				shortestLen = len;		where = 0;
+			}
+
+			len = VectorDistanceSquared(point, ri->headPoint);
+			if (len < shortestLen) {
+				shortestLen = len;		where = 1;
+			}
+
+			len = VectorDistanceSquared(point, ri->handRPoint);
+			if (len < shortestLen) {
+				shortestLen = len;		where = 2;
+			}
+
+			len = VectorDistanceSquared(point, ri->handLPoint);
+			if (len < shortestLen) {
+				shortestLen = len;		where = 3;
+			}
+
+			len = VectorDistanceSquared(point, ri->crotchPoint);
+			if (len < shortestLen)	{
+				shortestLen = len;		where = 4;
+			}
+
+			len = VectorDistanceSquared(point, ri->footRPoint);
+			if (len < shortestLen) {
+				shortestLen = len;		where = 5;
+			}
+
+			len = VectorDistanceSquared(point, ri->footLPoint);
+			if (len < shortestLen)	{
+				shortestLen = len;		where = 6;
+			}
+
+			len = VectorDistanceSquared(point, ri->torsoPoint);
+			if (len < shortestLen)	{
+				shortestLen = len;		where = 7;
+			}
+		}
+
+		if (where < 2 && c == 0) 
+		{
+			if (random() < .75f)		// 25% chance to actualy hit the head or eye
+				where = 7;
+		}
+
+		switch (where)
+		{
+		case 0:
+			VectorCopy(ri->eyePoint, out);
+			break;
+		case 1:
+			VectorCopy(ri->headPoint, out);
+			break;
+		case 2:
+			VectorCopy(ri->handRPoint, out);
+			break;
+		case 3:
+			VectorCopy(ri->handLPoint, out);
+			break;
+		case 4:
+			VectorCopy(ri->crotchPoint, out);
+			break;
+		case 5:
+			VectorCopy(ri->footRPoint, out);
+			break;
+		case 6:
+			VectorCopy(ri->footLPoint, out);
+			break;
+		case 7:
+			VectorCopy(ri->torsoPoint, out);
+			break;
+		}
+	}
+	else
+	{
+		VectorCopy(ent->s.pos.trBase, out);
+		// Really bad hack
+		if (strcmp(ent->classname, "misc_turret") == 0)
+		{
+			out[2] = point[2];	
+		}
+		
+	}
+
+	if (ent && ent->client && ent->client->NPC_class == CLASS_MINEMONSTER)
+	{
+		out[2] -= 24;		// not a clue???
+		return shortestLen;	// mine critters are too small to randomize
+	}
+
+	if (ent->NPC_type && !Q_stricmp(ent->NPC_type, "atst"))
+	{
+		// Dont randomize those atst's they have some pretty small legs
+		return shortestLen;
+	}
+
+	if (c == 0)
+	{
+		// Add a bit of chance to the actual location
+		float r = random() * 8.0f - 4.0f;
+		float r2 = random() * 8.0f - 4.0f;
+		float r3 = random() * 10.0f - 5.0f;
+
+		out[0] += r;
+		out[1] += r2;
+		out[2] += r3;
+	}
+
+	return shortestLen;
+}
+#endif // Auto-aim
+
+//extern cvar_t *cv_autoAim;
+#ifdef _XBOX // Auto-aim
+static bool cv_autoAim = qtrue;
+#endif // Auto-aim
+
+bool WP_MissileTargetHint(gentity_t* shooter, vec3_t start, vec3_t out)
+{
+#ifdef _XBOX
+	extern short cg_crossHairStatus;
+	extern int g_crosshairEntNum;
+//	int allow = 0;
+//	allow = Cvar_VariableIntegerValue("cv_autoAim");
+
+//	if ((!cg.snap) || !allow ) return false;
+	if ((!cg.snap) || !cv_autoAim ) return false;
+	if (shooter->s.clientNum != 0) return false;		// assuming shooter must be client, using 0 for cg_entities[0] a few lines down if you change this
+//	if (cg_crossHairStatus != 1 || cg_crosshairEntNum < 0 || cg_crosshairEntNum >= ENTITYNUM_WORLD) return false;
+	if (cg_crossHairStatus != 1 || g_crosshairEntNum < 0 || g_crosshairEntNum >= ENTITYNUM_WORLD) return false;
+	
+	gentity_t* traceEnt = &g_entities[g_crosshairEntNum];
+
+	vec3_t		d_f, d_rt, d_up;
+	vec3_t		end;
+	trace_t		trace;
+
+	// Calculate the end point
+	AngleVectors( cg_entities[0].lerpAngles, d_f, d_rt, d_up );			
+	VectorMA( start, 8192, d_f, end );//4028 is max for mind trick
+
+	// This will get a detailed trace
+	gi.trace( &trace, start, vec3_origin, vec3_origin, end, cg.snap->ps.clientNum, MASK_OPAQUE|CONTENTS_SHOTCLIP|CONTENTS_BODY|CONTENTS_ITEM, G2_COLLIDE, 10);
+	// If the trace came up with a different entity then our crosshair, then you are not actualy over the enemy
+	if (trace.entityNum != g_crosshairEntNum)
+	{
+		// Must trace again to find out where the crosshair will end up
+		gi.trace( &trace, start, vec3_origin, vec3_origin, end, cg.snap->ps.clientNum, MASK_OPAQUE|CONTENTS_SHOTCLIP|CONTENTS_BODY|CONTENTS_ITEM, G2_NOCOLLIDE, 10 );
+	
+		// Find the closest body part to the trace
+		WP_FindClosestBodyPart(traceEnt, shooter, trace.endpos, out);
+
+		// Compute the direction vector between the shooter and the guy being shot
+		VectorSubtract(out,	start, out);
+		VectorNormalize(out);
+
+		for (int i = 1; i < 8; i++)		/// do this 7 times to make sure we get it
+		{
+			/// Where will this direction end up?
+			VectorMA( start, 8192, out, end );//4028 is max for mind trick
+
+			// Try it one more time, ??? are we trying to shoot through solid space??
+			gi.trace( &trace, start, vec3_origin, vec3_origin, end, cg.snap->ps.clientNum, MASK_OPAQUE|CONTENTS_SHOTCLIP|CONTENTS_BODY|CONTENTS_ITEM, G2_COLLIDE, 10);
+			if (trace.entityNum != g_crosshairEntNum)
+			{
+				// Find the closest body part to the trace
+				WP_FindClosestBodyPart(traceEnt, shooter, trace.endpos, out, i);
+
+				// Computer the direction vector between the shooter and the guy being shot
+				VectorSubtract(out,	start, out);
+				VectorNormalize(out);	
+			}
+			else
+			{
+				break;	/// a hit wahoo
+			}
+		}
+	} 
+
+	return true;
+#else // Auto-aim
+	return false;
+#endif
+}
+
+/*
+----------------------------------------------
+	PLAYER WEAPONS
+----------------------------------------------
+*/
+
+//---------------
+//	Bryar Pistol
+//---------------
+
+//---------------------------------------------------------
+static void WP_FireBryarPistol( gentity_t *ent, qboolean alt_fire )
+//---------------------------------------------------------
+{
+	vec3_t	start;
+	int		damage = BRYAR_PISTOL_DAMAGE;
+
+	VectorCopy( muzzle, start );
+	WP_TraceSetStart( ent, start, vec3_origin, vec3_origin );//make sure our start point isn't on the other side of a wall
+
+	if ( !(ent->client->ps.forcePowersActive&(1<<FP_SEE))
+		|| ent->client->ps.forcePowerLevel[FP_SEE] < FORCE_LEVEL_2 )
+	{//force sight 2+ gives perfect aim
+		//FIXME: maybe force sight level 3 autoaims some?
+		if ( ent->NPC && ent->NPC->currentAim < 5 )
+		{
+			vec3_t	angs;
+
+			vectoangles( forward, angs );
+
+			if ( ent->client->NPC_class == CLASS_IMPWORKER )
+			{//*sigh*, hack to make impworkers less accurate without affecteing imperial officer accuracy
+				angs[PITCH] += ( crandom() * (BLASTER_NPC_SPREAD+(6-ent->NPC->currentAim)*0.25f));//was 0.5f
+				angs[YAW]	+= ( crandom() * (BLASTER_NPC_SPREAD+(6-ent->NPC->currentAim)*0.25f));//was 0.5f
+			}
+			else
+			{
+				angs[PITCH] += ( crandom() * ((5-ent->NPC->currentAim)*0.25f) );
+				angs[YAW]	+= ( crandom() * ((5-ent->NPC->currentAim)*0.25f) );
+			}
+
+			AngleVectors( angs, forward, NULL, NULL );
+		}
+	}
+
+	WP_MissileTargetHint(ent, start, forward);
+
+	gentity_t	*missile = CreateMissile( start, forward, BRYAR_PISTOL_VEL, 10000, ent, alt_fire );
+
+	missile->classname = "bryar_proj";
+	if ( ent->s.weapon == WP_BLASTER_PISTOL
+		|| ent->s.weapon == WP_JAWA )
+	{//*SIGH*... I hate our weapon system...
+		missile->s.weapon = ent->s.weapon;
+	}
+	else
+	{
+		missile->s.weapon = WP_BRYAR_PISTOL;
+	}
+
+	if ( alt_fire )
+	{
+		int count = ( level.time - ent->client->ps.weaponChargeTime ) / BRYAR_CHARGE_UNIT;
+
+		if ( count < 1 )
+		{
+			count = 1;
+		}
+		else if ( count > 5 )
+		{
+			count = 5;
+		}
+
+		damage *= count;
+		missile->count = count; // this will get used in the projectile rendering code to make a beefier effect
+	}
+
+//	if ( ent->client && ent->client->ps.powerups[PW_WEAPON_OVERCHARGE] > 0 && ent->client->ps.powerups[PW_WEAPON_OVERCHARGE] > cg.time )
+//	{
+//		// in overcharge mode, so doing double damage
+//		missile->flags |= FL_OVERCHARGED;
+//		damage *= 2;
+//	}
+
+	missile->damage = damage;
+	missile->dflags = DAMAGE_DEATH_KNOCKBACK;
+
+	if ( alt_fire )
+	{
+		missile->methodOfDeath = MOD_BRYAR_ALT;
+	}
+	else
+	{
+		missile->methodOfDeath = MOD_BRYAR;
+	}
+
+	missile->clipmask = MASK_SHOT | CONTENTS_LIGHTSABER;
+
+	// we don't want it to bounce forever
+	missile->bounceCount = 8;
+
+	if ( ent->weaponModel[1] > 0 )
+	{//dual pistols, toggle the muzzle point back and forth between the two pistols each time he fires
+		ent->count = (ent->count)?0:1;
+	}
+}
+
+
+//---------------
+//	Blaster
+//---------------
+
+//---------------------------------------------------------
+static void WP_FireBlasterMissile( gentity_t *ent, vec3_t start, vec3_t dir, qboolean altFire )
+//---------------------------------------------------------
+{
+	int velocity	= BLASTER_VELOCITY;
+	int	damage		= BLASTER_DAMAGE;
+
+	if ( ent && ent->client && ent->client->NPC_class == CLASS_VEHICLE )
+	{
+		damage *= 3;
+		velocity = ATST_MAIN_VEL + ent->client->ps.speed;
+	}
+	else
+	{
+		// If an enemy is shooting at us, lower the velocity so you have a chance to evade
+		if ( ent->client && ent->client->ps.clientNum != 0 && ent->client->NPC_class != CLASS_BOBAFETT )
+		{
+			if ( g_spskill->integer < 2 )
+			{		
+				velocity *= BLASTER_NPC_VEL_CUT;
+			}
+			else
+			{
+				velocity *= BLASTER_NPC_HARD_VEL_CUT;
+			}
+		}
+	}
+
+	WP_TraceSetStart( ent, start, vec3_origin, vec3_origin );//make sure our start point isn't on the other side of a wall
+
+	WP_MissileTargetHint(ent, start, dir);
+
+	gentity_t *missile = CreateMissile( start, dir, velocity, 10000, ent, altFire );
+
+	missile->classname = "blaster_proj";
+	missile->s.weapon = WP_BLASTER;
+
+	// Do the damages
+	if ( ent->s.number != 0 && ent->client->NPC_class != CLASS_BOBAFETT )
+	{
+		if ( g_spskill->integer == 0 )
+		{
+			damage = BLASTER_NPC_DAMAGE_EASY;
+		}
+		else if ( g_spskill->integer == 1 )
+		{
+			damage = BLASTER_NPC_DAMAGE_NORMAL;
+		}
+		else
+		{
+			damage = BLASTER_NPC_DAMAGE_HARD;
+		}
+	}
+
+//	if ( ent->client )
+//	{
+//		if ( ent->client->ps.powerups[PW_WEAPON_OVERCHARGE] > 0 && ent->client->ps.powerups[PW_WEAPON_OVERCHARGE] > cg.time )
+//		{
+//			// in overcharge mode, so doing double damage
+//			missile->flags |= FL_OVERCHARGED;
+//			damage *= 2;
+//		}
+//	}
+
+	missile->damage = damage;
+	missile->dflags = DAMAGE_DEATH_KNOCKBACK;
+	if ( altFire )
+	{
+		missile->methodOfDeath = MOD_BLASTER_ALT;
+	}
+	else
+	{
+		missile->methodOfDeath = MOD_BLASTER;
+	}
+	missile->clipmask = MASK_SHOT | CONTENTS_LIGHTSABER;
+
+	// we don't want it to bounce forever
+	missile->bounceCount = 8;
+}
+
+//---------------------------------------------------------
+void WP_FireTurboLaserMissile( gentity_t *ent, vec3_t start, vec3_t dir )
+//---------------------------------------------------------
+{
+	int velocity	= ent->mass; //FIXME: externalize
+	gentity_t *missile;
+
+	missile = CreateMissile( start, dir, velocity, 10000, ent, qfalse );
+	
+	//use a custom shot effect
+	//missile->s.otherEntityNum2 = G_EffectIndex( "turret/turb_shot" );
+	//use a custom impact effect
+	//missile->s.emplacedOwner = G_EffectIndex( "turret/turb_impact" );
+
+	missile->classname = "turbo_proj";
+	missile->s.weapon = WP_TIE_FIGHTER;
+
+	missile->damage = ent->damage;		//FIXME: externalize
+	missile->splashDamage = ent->splashDamage;	//FIXME: externalize
+	missile->splashRadius = ent->splashRadius;	//FIXME: externalize
+	missile->dflags = DAMAGE_DEATH_KNOCKBACK;
+	missile->methodOfDeath = MOD_EMPLACED; //MOD_TURBLAST; //count as a heavy weap
+	missile->splashMethodOfDeath = MOD_EMPLACED; //MOD_TURBLAST;// ?SPLASH;
+	missile->clipmask = MASK_SHOT;
+
+	// we don't want it to bounce forever
+	missile->bounceCount = 8;
+
+	//set veh as cgame side owner for purpose of fx overrides
+	//missile->s.owner = ent->s.number;
+
+	//don't let them last forever
+	missile->e_ThinkFunc = thinkF_G_FreeEntity;
+	missile->nextthink = level.time + 10000;//at 20000 speed, that should be more than enough
+}
+
+//---------------------------------------------------------
+static void WP_FireBlaster( gentity_t *ent, qboolean alt_fire )
+//---------------------------------------------------------
+{
+	vec3_t	dir, angs;
+
+	vectoangles( forward, angs );
+
+	if ( ent->client && ent->client->NPC_class == CLASS_VEHICLE )
+	{//no inherent aim screw up
+	}
+	else if ( !(ent->client->ps.forcePowersActive&(1<<FP_SEE))
+		|| ent->client->ps.forcePowerLevel[FP_SEE] < FORCE_LEVEL_2 )
+	{//force sight 2+ gives perfect aim
+		//FIXME: maybe force sight level 3 autoaims some?
+		if ( alt_fire )
+		{
+			// add some slop to the alt-fire direction
+			angs[PITCH] += crandom() * BLASTER_ALT_SPREAD;
+			angs[YAW]	+= crandom() * BLASTER_ALT_SPREAD;
+		}
+		else
+		{
+			// Troopers use their aim values as well as the gun's inherent inaccuracy
+			// so check for all classes of stormtroopers and anyone else that has aim error
+			if ( ent->client && ent->NPC &&
+				( ent->client->NPC_class == CLASS_STORMTROOPER ||
+				ent->client->NPC_class == CLASS_SWAMPTROOPER ) )
+			{
+				angs[PITCH] += ( crandom() * (BLASTER_NPC_SPREAD+(6-ent->NPC->currentAim)*0.25f));//was 0.5f
+				angs[YAW]	+= ( crandom() * (BLASTER_NPC_SPREAD+(6-ent->NPC->currentAim)*0.25f));//was 0.5f
+			}
+			else
+			{
+				// add some slop to the main-fire direction
+				angs[PITCH] += crandom() * BLASTER_MAIN_SPREAD;
+				angs[YAW]	+= crandom() * BLASTER_MAIN_SPREAD;
+			}
+		}
+	}
+
+	AngleVectors( angs, dir, NULL, NULL );
+
+	// FIXME: if temp_org does not have clear trace to inside the bbox, don't shoot!
+	WP_FireBlasterMissile( ent, muzzle, dir, alt_fire );
+}
+
+
+//---------------------
+//	Tenloss Disruptor
+//---------------------
+int G_GetHitLocFromTrace( trace_t *trace, int mod )
+{
+	int hitLoc = HL_NONE;
+	for (int i=0; i < MAX_G2_COLLISIONS; i++)
+	{
+		if ( trace->G2CollisionMap[i].mEntityNum == -1 )
+		{
+			break;
+		}
+
+		CCollisionRecord &coll = trace->G2CollisionMap[i];
+		if ( (coll.mFlags & G2_FRONTFACE) )
+		{
+			G_GetHitLocFromSurfName( &g_entities[coll.mEntityNum], gi.G2API_GetSurfaceName( &g_entities[coll.mEntityNum].ghoul2[coll.mModelIndex], coll.mSurfaceIndex ), &hitLoc, coll.mCollisionPosition, NULL, NULL, mod );
+			//we only want the first "entrance wound", so break
+			break;
+		}
+	}
+	return hitLoc;
+}
+
+//---------------------------------------------------------
+static void WP_DisruptorMainFire( gentity_t *ent )
+//---------------------------------------------------------
+{
+	int			damage = DISRUPTOR_MAIN_DAMAGE;
+	qboolean	render_impact = qtrue;
+	vec3_t		start, end, spot;
+	trace_t		tr;
+	gentity_t	*traceEnt = NULL, *tent;
+	float		dist, shotDist, shotRange = 8192;
+
+	if ( ent->NPC )
+	{
+		switch ( g_spskill->integer )
+		{
+		case 0:
+			damage = DISRUPTOR_NPC_MAIN_DAMAGE_EASY;
+			break;
+		case 1:
+			damage = DISRUPTOR_NPC_MAIN_DAMAGE_MEDIUM;
+			break;
+		case 2:
+		default:
+			damage = DISRUPTOR_NPC_MAIN_DAMAGE_HARD;
+			break;
+		}
+	}
+
+	VectorCopy( muzzle, start );
+	WP_TraceSetStart( ent, start, vec3_origin, vec3_origin );
+
+//	if ( ent->client && ent->client->ps.powerups[PW_WEAPON_OVERCHARGE] > 0 && ent->client->ps.powerups[PW_WEAPON_OVERCHARGE] > cg.time )
+//	{
+//		// in overcharge mode, so doing double damage
+//		damage *= 2;
+//	}
+
+	WP_MissileTargetHint(ent, start, forward);
+	VectorMA( start, shotRange, forward, end );
+
+	int ignore = ent->s.number;
+	int traces = 0;
+	while ( traces < 10 )
+	{//need to loop this in case we hit a Jedi who dodges the shot
+		gi.trace( &tr, start, NULL, NULL, end, ignore, MASK_SHOT, G2_RETURNONHIT, 0 );
+
+		traceEnt = &g_entities[tr.entityNum];
+		if ( traceEnt 
+			&& ( traceEnt->s.weapon == WP_SABER || (traceEnt->client && (traceEnt->client->NPC_class == CLASS_BOBAFETT||traceEnt->client->NPC_class == CLASS_REBORN) ) ) )
+		{//FIXME: need a more reliable way to know we hit a jedi?
+			if ( Jedi_DodgeEvasion( traceEnt, ent, &tr, HL_NONE ) )
+			{//act like we didn't even hit him
+				VectorCopy( tr.endpos, start );
+				ignore = tr.entityNum;
+				traces++;
+				continue;
+			}
+		}
+		//a Jedi is not dodging this shot
+		break;
+	}
+
+	if ( tr.surfaceFlags & SURF_NOIMPACT ) 
+	{
+		render_impact = qfalse;
+	}
+
+	// always render a shot beam, doing this the old way because I don't much feel like overriding the effect.
+	tent = G_TempEntity( tr.endpos, EV_DISRUPTOR_MAIN_SHOT );
+	tent->svFlags |= SVF_BROADCAST;
+	VectorCopy( muzzle, tent->s.origin2 );
+
+	if ( render_impact )
+	{
+		if ( tr.entityNum < ENTITYNUM_WORLD && traceEnt->takedamage )
+		{
+			// Create a simple impact type mark that doesn't last long in the world
+			G_PlayEffect( G_EffectIndex( "disruptor/flesh_impact" ), tr.endpos, tr.plane.normal );
+
+			if ( traceEnt->client && LogAccuracyHit( traceEnt, ent )) 
+			{
+				ent->client->ps.persistant[PERS_ACCURACY_HITS]++;
+			} 
+
+			int hitLoc = G_GetHitLocFromTrace( &tr, MOD_DISRUPTOR );
+			if ( traceEnt && traceEnt->client && traceEnt->client->NPC_class == CLASS_GALAKMECH )
+			{//hehe
+				G_Damage( traceEnt, ent, ent, forward, tr.endpos, 3, DAMAGE_DEATH_KNOCKBACK, MOD_DISRUPTOR, hitLoc );
+			}
+			else
+			{
+				G_Damage( traceEnt, ent, ent, forward, tr.endpos, damage, DAMAGE_DEATH_KNOCKBACK, MOD_DISRUPTOR, hitLoc );
+			}
+		}
+		else 
+		{
+			G_PlayEffect( G_EffectIndex( "disruptor/wall_impact" ), tr.endpos, tr.plane.normal );		
+		}
+	}
+
+	shotDist = shotRange * tr.fraction;
+
+	for ( dist = 0; dist < shotDist; dist += 64 )
+	{
+		//FIXME: on a really long shot, this could make a LOT of alerts in one frame...
+		VectorMA( start, dist, forward, spot );
+		AddSightEvent( ent, spot, 256, AEL_DISCOVERED, 50 );
+	}
+	VectorMA( start, shotDist-4, forward, spot );
+	AddSightEvent( ent, spot, 256, AEL_DISCOVERED, 50 );
+}
+
+//---------------------------------------------------------
+void WP_DisruptorAltFire( gentity_t *ent )
+//---------------------------------------------------------
+{
+	int			damage = DISRUPTOR_ALT_DAMAGE, skip, traces = DISRUPTOR_ALT_TRACES;
+	qboolean	render_impact = qtrue;
+	vec3_t		start, end;
+	vec3_t		muzzle2, spot, dir;
+	trace_t		tr;
+	gentity_t	*traceEnt, *tent;
+	float		dist, shotDist, shotRange = 8192;
+	qboolean	hitDodged = qfalse, fullCharge = qfalse;
+
+	VectorCopy( muzzle, muzzle2 ); // making a backup copy
+
+	// The trace start will originate at the eye so we can ensure that it hits the crosshair.
+	if ( ent->NPC )
+	{
+		switch ( g_spskill->integer )
+		{
+		case 0:
+			damage = DISRUPTOR_NPC_ALT_DAMAGE_EASY;
+			break;
+		case 1:
+			damage = DISRUPTOR_NPC_ALT_DAMAGE_MEDIUM;
+			break;
+		case 2:
+		default:
+			damage = DISRUPTOR_NPC_ALT_DAMAGE_HARD;
+			break;
+		}
+		VectorCopy( muzzle, start );
+
+		fullCharge = qtrue;
+	}
+	else
+	{
+		VectorCopy( ent->client->renderInfo.eyePoint, start );
+		AngleVectors( ent->client->renderInfo.eyeAngles, forward, NULL, NULL );
+
+		// don't let NPC's do charging
+		int count = ( level.time - ent->client->ps.weaponChargeTime - 50 ) / DISRUPTOR_CHARGE_UNIT;
+
+		if ( count < 1 )
+		{
+			count = 1;
+		}
+		else if ( count >= 10 )
+		{
+			count = 10;
+			fullCharge = qtrue;
+		}
+
+		// more powerful charges go through more things
+		if ( count < 3 )
+		{
+			traces = 1;
+		}
+		else if ( count < 6 )
+		{
+			traces = 2;
+		}
+		//else do full traces
+
+		damage = damage * count + DISRUPTOR_MAIN_DAMAGE * 0.5f; // give a boost to low charge shots
+	}
+
+	skip = ent->s.number;
+
+//	if ( ent->client && ent->client->ps.powerups[PW_WEAPON_OVERCHARGE] > 0 && ent->client->ps.powerups[PW_WEAPON_OVERCHARGE] > cg.time )
+//	{
+//		// in overcharge mode, so doing double damage
+//		damage *= 2;
+//	}
+
+	for ( int i = 0; i < traces; i++ )
+	{
+		VectorMA( start, shotRange, forward, end );
+
+		//NOTE: if you want to be able to hit guys in emplaced guns, use "G2_COLLIDE, 10" instead of "G2_RETURNONHIT, 0"
+		//alternately, if you end up hitting an emplaced_gun that has a sitter, just redo this one trace with the "G2_COLLIDE, 10" to see if we it the sitter
+		gi.trace( &tr, start, NULL, NULL, end, skip, MASK_SHOT, G2_COLLIDE, 10 );//G2_RETURNONHIT, 0 );
+
+		if ( tr.surfaceFlags & SURF_NOIMPACT ) 
+		{
+			render_impact = qfalse;
+		}
+
+		if ( tr.entityNum == ent->s.number )
+		{
+			// should never happen, but basically we don't want to consider a hit to ourselves?
+			// Get ready for an attempt to trace through another person
+			VectorCopy( tr.endpos, muzzle2 );
+			VectorCopy( tr.endpos, start );
+			skip = tr.entityNum;
+#ifdef _DEBUG
+			gi.Printf( "BAD! Disruptor gun shot somehow traced back and hit the owner!\n" );			
+#endif
+			continue;
+		}
+
+		// always render a shot beam, doing this the old way because I don't much feel like overriding the effect.
+		//NOTE: let's just draw one beam, at the end
+		//tent = G_TempEntity( tr.endpos, EV_DISRUPTOR_SNIPER_SHOT );
+		//tent->svFlags |= SVF_BROADCAST;
+		//tent->alt_fire = fullCharge; // mark us so we can alter the effect
+
+		//VectorCopy( muzzle2, tent->s.origin2 );
+
+		if ( tr.fraction >= 1.0f )
+		{
+			// draw the beam but don't do anything else
+			break;
+		}
+
+		traceEnt = &g_entities[tr.entityNum];
+
+		if ( traceEnt //&& traceEnt->NPC 
+			&& ( traceEnt->s.weapon == WP_SABER || (traceEnt->client && (traceEnt->client->NPC_class == CLASS_BOBAFETT||traceEnt->client->NPC_class == CLASS_REBORN) ) ) )
+		{//FIXME: need a more reliable way to know we hit a jedi?
+			hitDodged = Jedi_DodgeEvasion( traceEnt, ent, &tr, HL_NONE );
+			//acts like we didn't even hit him
+		}
+		if ( !hitDodged )
+		{
+			if ( render_impact )
+			{
+				if (( tr.entityNum < ENTITYNUM_WORLD && traceEnt->takedamage ) 
+					|| !Q_stricmp( traceEnt->classname, "misc_model_breakable" ) 
+					|| traceEnt->s.eType == ET_MOVER )
+				{
+					// Create a simple impact type mark that doesn't last long in the world
+					G_PlayEffect( G_EffectIndex( "disruptor/alt_hit" ), tr.endpos, tr.plane.normal );
+
+					if ( traceEnt->client && LogAccuracyHit( traceEnt, ent )) 
+					{//NOTE: hitting multiple ents can still get you over 100% accuracy
+						ent->client->ps.persistant[PERS_ACCURACY_HITS]++;
+					} 
+
+					int hitLoc = G_GetHitLocFromTrace( &tr, MOD_DISRUPTOR );
+					if ( traceEnt && traceEnt->client && traceEnt->client->NPC_class == CLASS_GALAKMECH )
+					{//hehe
+						G_Damage( traceEnt, ent, ent, forward, tr.endpos, 10, DAMAGE_NO_KNOCKBACK|DAMAGE_NO_HIT_LOC, fullCharge ? MOD_SNIPER : MOD_DISRUPTOR, hitLoc );			
+						break;
+					}
+					G_Damage( traceEnt, ent, ent, forward, tr.endpos, damage, DAMAGE_NO_KNOCKBACK|DAMAGE_NO_HIT_LOC, fullCharge ? MOD_SNIPER : MOD_DISRUPTOR, hitLoc );
+					if ( traceEnt->s.eType == ET_MOVER )
+					{//stop the traces on any mover
+						break;
+					}
+				}
+				else 
+				{
+					 // we only make this mark on things that can't break or move
+					tent = G_TempEntity( tr.endpos, EV_DISRUPTOR_SNIPER_MISS );
+					tent->svFlags |= SVF_BROADCAST;
+					VectorCopy( tr.plane.normal, tent->pos1 );
+					break; // hit solid, but doesn't take damage, so stop the shot...we _could_ allow it to shoot through walls, might be cool?
+				}
+			}
+			else // not rendering impact, must be a skybox or other similar thing?
+			{
+				break; // don't try anymore traces
+			}
+		}
+		// Get ready for an attempt to trace through another person
+		VectorCopy( tr.endpos, muzzle2 );
+		VectorCopy( tr.endpos, start );
+		skip = tr.entityNum;
+		hitDodged = qfalse;
+	}
+	//just draw one solid beam all the way to the end...
+	tent = G_TempEntity( tr.endpos, EV_DISRUPTOR_SNIPER_SHOT );
+	tent->svFlags |= SVF_BROADCAST;
+	tent->alt_fire = fullCharge; // mark us so we can alter the effect
+	VectorCopy( muzzle, tent->s.origin2 );
+
+	// now go along the trail and make sight events
+	VectorSubtract( tr.endpos, muzzle, dir );
+
+	shotDist = VectorNormalize( dir );
+
+	//FIXME: if shoot *really* close to someone, the alert could be way out of their FOV
+	for ( dist = 0; dist < shotDist; dist += 64 )
+	{
+		//FIXME: on a really long shot, this could make a LOT of alerts in one frame...
+		VectorMA( muzzle, dist, dir, spot );
+		AddSightEvent( ent, spot, 256, AEL_DISCOVERED, 50 );
+	}
+	//FIXME: spawn a temp ent that continuously spawns sight alerts here?  And 1 sound alert to draw their attention?
+	VectorMA( start, shotDist-4, forward, spot );
+	AddSightEvent( ent, spot, 256, AEL_DISCOVERED, 50 );
+}
+
+//---------------------------------------------------------
+static void WP_FireDisruptor( gentity_t *ent, qboolean alt_fire )
+//---------------------------------------------------------
+{
+	if ( alt_fire )
+	{
+		WP_DisruptorAltFire( ent );
+	}
+	else
+	{
+		WP_DisruptorMainFire( ent );
+	}
+
+	G_PlayEffect( G_EffectIndex( "disruptor/line_cap" ), muzzle, forward );
+}
+
+
+//-------------------
+//	Wookiee Bowcaster
+//-------------------
+
+//---------------------------------------------------------
+static void WP_BowcasterMainFire( gentity_t *ent )
+//---------------------------------------------------------
+{
+	int			damage	= BOWCASTER_DAMAGE, count;
+	float		vel;
+	vec3_t		angs, dir, start;
+	gentity_t	*missile;
+
+	VectorCopy( muzzle, start );
+	WP_TraceSetStart( ent, start, vec3_origin, vec3_origin );//make sure our start point isn't on the other side of a wall
+
+	// Do the damages
+	if ( ent->s.number != 0 )
+	{
+		if ( g_spskill->integer == 0 )
+		{
+			damage = BOWCASTER_NPC_DAMAGE_EASY;
+		}
+		else if ( g_spskill->integer == 1 )
+		{
+			damage = BOWCASTER_NPC_DAMAGE_NORMAL;
+		}
+		else
+		{
+			damage = BOWCASTER_NPC_DAMAGE_HARD;
+		}
+	}
+
+	count = ( level.time - ent->client->ps.weaponChargeTime ) / BOWCASTER_CHARGE_UNIT;
+
+	if ( count < 1 )
+	{
+		count = 1;
+	}
+	else if ( count > 5 )
+	{
+		count = 5;
+	}
+
+	if ( !(count & 1 ))
+	{
+		// if we aren't odd, knock us down a level
+		count--;
+	}
+
+//	if ( ent->client && ent->client->ps.powerups[PW_WEAPON_OVERCHARGE] > 0 && ent->client->ps.powerups[PW_WEAPON_OVERCHARGE] > cg.time )
+//	{
+//		// in overcharge mode, so doing double damage
+//		damage *= 2;
+//	}
+
+	WP_MissileTargetHint(ent, start, forward);
+	for ( int i = 0; i < count; i++ )
+	{
+		// create a range of different velocities
+		vel = BOWCASTER_VELOCITY * ( crandom() * BOWCASTER_VEL_RANGE + 1.0f );
+
+		vectoangles( forward, angs );
+
+		if ( !(ent->client->ps.forcePowersActive&(1<<FP_SEE))
+			|| ent->client->ps.forcePowerLevel[FP_SEE] < FORCE_LEVEL_2 )
+		{//force sight 2+ gives perfect aim
+			//FIXME: maybe force sight level 3 autoaims some?
+			// add some slop to the fire direction
+			angs[PITCH] += crandom() * BOWCASTER_ALT_SPREAD * 0.2f;
+			angs[YAW]	+= ((i+0.5f) * BOWCASTER_ALT_SPREAD - count * 0.5f * BOWCASTER_ALT_SPREAD );
+			if ( ent->NPC )
+			{
+				angs[PITCH] += ( crandom() * (BLASTER_NPC_SPREAD+(6-ent->NPC->currentAim)*0.25f) );
+				angs[YAW]	+= ( crandom() * (BLASTER_NPC_SPREAD+(6-ent->NPC->currentAim)*0.25f) );
+			}
+		}
+		
+		AngleVectors( angs, dir, NULL, NULL );
+
+		missile = CreateMissile( start, dir, vel, 10000, ent );
+
+		missile->classname = "bowcaster_proj";
+		missile->s.weapon = WP_BOWCASTER;
+
+		VectorSet( missile->maxs, BOWCASTER_SIZE, BOWCASTER_SIZE, BOWCASTER_SIZE );
+		VectorScale( missile->maxs, -1, missile->mins );
+
+//		if ( ent->client && ent->client->ps.powerups[PW_WEAPON_OVERCHARGE] > 0 && ent->client->ps.powerups[PW_WEAPON_OVERCHARGE] > cg.time )
+//		{
+//			missile->flags |= FL_OVERCHARGED;
+//		}
+
+		missile->damage = damage;
+		missile->dflags = DAMAGE_DEATH_KNOCKBACK;
+		missile->methodOfDeath = MOD_BOWCASTER;
+		missile->clipmask = MASK_SHOT | CONTENTS_LIGHTSABER;
+		missile->splashDamage = BOWCASTER_SPLASH_DAMAGE;
+		missile->splashRadius = BOWCASTER_SPLASH_RADIUS;
+
+		// we don't want it to bounce
+		missile->bounceCount = 0;
+		ent->client->sess.missionStats.shotsFired++;
+	}
+}
+
+//---------------------------------------------------------
+static void WP_BowcasterAltFire( gentity_t *ent )
+//---------------------------------------------------------
+{
+	vec3_t	start;
+	int		damage	= BOWCASTER_DAMAGE;
+
+	VectorCopy( muzzle, start );
+	WP_TraceSetStart( ent, start, vec3_origin, vec3_origin );//make sure our start point isn't on the other side of a wall
+
+	WP_MissileTargetHint(ent, start, forward);
+
+	gentity_t *missile = CreateMissile( start, forward, BOWCASTER_VELOCITY, 10000, ent, qtrue );
+
+	missile->classname = "bowcaster_alt_proj";
+	missile->s.weapon = WP_BOWCASTER;
+
+	// Do the damages
+	if ( ent->s.number != 0 )
+	{
+		if ( g_spskill->integer == 0 )
+		{
+			damage = BOWCASTER_NPC_DAMAGE_EASY;
+		}
+		else if ( g_spskill->integer == 1 )
+		{
+			damage = BOWCASTER_NPC_DAMAGE_NORMAL;
+		}
+		else
+		{
+			damage = BOWCASTER_NPC_DAMAGE_HARD;
+		}
+	}
+
+	VectorSet( missile->maxs, BOWCASTER_SIZE, BOWCASTER_SIZE, BOWCASTER_SIZE );
+	VectorScale( missile->maxs, -1, missile->mins );
+
+//	if ( ent->client && ent->client->ps.powerups[PW_WEAPON_OVERCHARGE] > 0 && ent->client->ps.powerups[PW_WEAPON_OVERCHARGE] > cg.time )
+//	{
+//		// in overcharge mode, so doing double damage
+//		missile->flags |= FL_OVERCHARGED;
+//		damage *= 2;
+//	}
+
+	missile->s.eFlags |= EF_BOUNCE;
+	missile->bounceCount = 3;
+
+	missile->damage = damage;
+	missile->dflags = DAMAGE_DEATH_KNOCKBACK;
+	missile->methodOfDeath = MOD_BOWCASTER_ALT;
+	missile->clipmask = MASK_SHOT | CONTENTS_LIGHTSABER;
+	missile->splashDamage = BOWCASTER_SPLASH_DAMAGE;
+	missile->splashRadius = BOWCASTER_SPLASH_RADIUS;
+}
+
+//---------------------------------------------------------
+static void WP_FireBowcaster( gentity_t *ent, qboolean alt_fire )
+//---------------------------------------------------------
+{
+	if ( alt_fire )
+	{
+		WP_BowcasterAltFire( ent );
+	}
+	else
+	{
+		WP_BowcasterMainFire( ent );
+	}
+}
+
+
+//-------------------
+//	Heavy Repeater
+//-------------------
+
+//---------------------------------------------------------
+static void WP_RepeaterMainFire( gentity_t *ent, vec3_t dir )
+//---------------------------------------------------------
+{
+	vec3_t	start;
+	int		damage	= REPEATER_DAMAGE;
+
+	VectorCopy( muzzle, start );
+	WP_TraceSetStart( ent, start, vec3_origin, vec3_origin );//make sure our start point isn't on the other side of a wall
+
+	WP_MissileTargetHint(ent, start, dir);
+
+	gentity_t *missile = CreateMissile( start, dir, REPEATER_VELOCITY, 10000, ent );
+
+	missile->classname = "repeater_proj";
+	missile->s.weapon = WP_REPEATER;
+
+	// Do the damages
+	if ( ent->s.number != 0 )
+	{
+		if ( g_spskill->integer == 0 )
+		{
+			damage = REPEATER_NPC_DAMAGE_EASY;
+		}
+		else if ( g_spskill->integer == 1 )
+		{
+			damage = REPEATER_NPC_DAMAGE_NORMAL;
+		}
+		else
+		{
+			damage = REPEATER_NPC_DAMAGE_HARD;
+		}
+	}
+
+//	if ( ent->client && ent->client->ps.powerups[PW_WEAPON_OVERCHARGE] > 0 && ent->client->ps.powerups[PW_WEAPON_OVERCHARGE] > cg.time )
+//	{
+//		// in overcharge mode, so doing double damage
+//		missile->flags |= FL_OVERCHARGED;
+//		damage *= 2;
+//	}
+
+	missile->damage = damage;
+	missile->dflags = DAMAGE_DEATH_KNOCKBACK;
+	missile->methodOfDeath = MOD_REPEATER;
+	missile->clipmask = MASK_SHOT | CONTENTS_LIGHTSABER;
+
+	// we don't want it to bounce forever
+	missile->bounceCount = 8;
+}
+
+//---------------------------------------------------------
+static void WP_RepeaterAltFire( gentity_t *ent )
+//---------------------------------------------------------
+{
+	vec3_t	start;
+	int		damage	= REPEATER_ALT_DAMAGE;
+	gentity_t *missile = NULL;
+
+	VectorCopy( muzzle, start );
+	WP_TraceSetStart( ent, start, vec3_origin, vec3_origin );//make sure our start point isn't on the other side of a wall
+
+	if ( ent->client && ent->client->NPC_class == CLASS_GALAKMECH )
+	{
+		missile = CreateMissile( start, ent->client->hiddenDir, ent->client->hiddenDist, 10000, ent, qtrue );
+	}
+	else
+	{
+		WP_MissileTargetHint(ent, start, forward);
+		missile = CreateMissile( start, forward, REPEATER_ALT_VELOCITY, 10000, ent, qtrue );
+	}
+
+	missile->classname = "repeater_alt_proj";
+	missile->s.weapon = WP_REPEATER;
+	missile->mass = 10;
+
+	// Do the damages
+	if ( ent->s.number != 0 )
+	{
+		if ( g_spskill->integer == 0 )
+		{
+			damage = REPEATER_ALT_NPC_DAMAGE_EASY;
+		}
+		else if ( g_spskill->integer == 1 )
+		{
+			damage = REPEATER_ALT_NPC_DAMAGE_NORMAL;
+		}
+		else
+		{
+			damage = REPEATER_ALT_NPC_DAMAGE_HARD;
+		}
+	}
+
+	VectorSet( missile->maxs, REPEATER_ALT_SIZE, REPEATER_ALT_SIZE, REPEATER_ALT_SIZE );
+	VectorScale( missile->maxs, -1, missile->mins );
+	missile->s.pos.trType = TR_GRAVITY;
+	missile->s.pos.trDelta[2] += 40.0f; //give a slight boost in the upward direction
+
+//	if ( ent->client && ent->client->ps.powerups[PW_WEAPON_OVERCHARGE] > 0 && ent->client->ps.powerups[PW_WEAPON_OVERCHARGE] > cg.time )
+//	{
+//		// in overcharge mode, so doing double damage
+//		missile->flags |= FL_OVERCHARGED;
+//		damage *= 2;
+//	}
+
+	missile->damage = damage;
+	missile->dflags = DAMAGE_DEATH_KNOCKBACK;
+	missile->methodOfDeath = MOD_REPEATER_ALT;
+	missile->splashMethodOfDeath = MOD_REPEATER_ALT;
+	missile->clipmask = MASK_SHOT | CONTENTS_LIGHTSABER;
+	missile->splashDamage = REPEATER_ALT_SPLASH_DAMAGE;
+	missile->splashRadius = REPEATER_ALT_SPLASH_RADIUS;
+
+	// we don't want it to bounce forever
+	missile->bounceCount = 8;
+}
+
+//---------------------------------------------------------
+static void WP_FireRepeater( gentity_t *ent, qboolean alt_fire )
+//---------------------------------------------------------
+{
+	vec3_t	dir, angs;
+
+	vectoangles( forward, angs );
+
+	if ( alt_fire )
+	{
+		WP_RepeaterAltFire( ent );
+	}
+	else
+	{
+		if ( !(ent->client->ps.forcePowersActive&(1<<FP_SEE))
+			|| ent->client->ps.forcePowerLevel[FP_SEE] < FORCE_LEVEL_2 )
+		{//force sight 2+ gives perfect aim
+			//FIXME: maybe force sight level 3 autoaims some?
+			// Troopers use their aim values as well as the gun's inherent inaccuracy
+			// so check for all classes of stormtroopers and anyone else that has aim error
+			if ( ent->client && ent->NPC &&
+				( ent->client->NPC_class == CLASS_STORMTROOPER ||
+				  ent->client->NPC_class == CLASS_SWAMPTROOPER ||
+				  ent->client->NPC_class == CLASS_SHADOWTROOPER ) )
+			{
+				angs[PITCH] += ( crandom() * (REPEATER_NPC_SPREAD+(6-ent->NPC->currentAim)*0.25f) );
+				angs[YAW]	+= ( crandom() * (REPEATER_NPC_SPREAD+(6-ent->NPC->currentAim)*0.25f) );
+			}
+			else
+			{
+				// add some slop to the alt-fire direction
+				angs[PITCH] += crandom() * REPEATER_SPREAD;
+				angs[YAW]	+= crandom() * REPEATER_SPREAD;
+			}
+		}
+
+		AngleVectors( angs, dir, NULL, NULL );
+
+		// FIXME: if temp_org does not have clear trace to inside the bbox, don't shoot!
+		WP_RepeaterMainFire( ent, dir );
+	}
+}
+
+//-------------------
+//	DEMP2
+//-------------------
+
+//---------------------------------------------------------
+static void WP_DEMP2_MainFire( gentity_t *ent )
+//---------------------------------------------------------
+{
+	vec3_t	start;
+	int		damage	= DEMP2_DAMAGE;
+
+	VectorCopy( muzzle, start );
+	WP_TraceSetStart( ent, start, vec3_origin, vec3_origin );//make sure our start point isn't on the other side of a wall
+
+	WP_MissileTargetHint(ent, start, forward);
+
+	gentity_t *missile = CreateMissile( start, forward, DEMP2_VELOCITY, 10000, ent );
+
+	missile->classname = "demp2_proj";
+	missile->s.weapon = WP_DEMP2;
+
+	// Do the damages
+	if ( ent->s.number != 0 )
+	{
+		if ( g_spskill->integer == 0 )
+		{
+			damage = DEMP2_NPC_DAMAGE_EASY;
+		}
+		else if ( g_spskill->integer == 1 )
+		{
+			damage = DEMP2_NPC_DAMAGE_NORMAL;
+		}
+		else
+		{
+			damage = DEMP2_NPC_DAMAGE_HARD;
+		}
+	}
+
+	VectorSet( missile->maxs, DEMP2_SIZE, DEMP2_SIZE, DEMP2_SIZE );
+	VectorScale( missile->maxs, -1, missile->mins );
+
+//	if ( ent->client && ent->client->ps.powerups[PW_WEAPON_OVERCHARGE] > 0 && ent->client->ps.powerups[PW_WEAPON_OVERCHARGE] > cg.time )
+//	{
+//		// in overcharge mode, so doing double damage
+//		missile->flags |= FL_OVERCHARGED;
+//		damage *= 2;
+//	}
+
+	missile->damage = damage;
+	missile->dflags = DAMAGE_DEATH_KNOCKBACK;
+	missile->methodOfDeath = MOD_DEMP2;
+	missile->clipmask = MASK_SHOT | CONTENTS_LIGHTSABER;
+
+	// we don't want it to ever bounce
+	missile->bounceCount = 0;
+}
+
+// NOTE: this is 100% for the demp2 alt-fire effect, so changes to the visual effect will affect game side demp2 code
+//--------------------------------------------------
+void DEMP2_AltRadiusDamage( gentity_t *ent )
+{
+	float		frac = ( level.time - ent->fx_time ) / 1300.0f; // synchronize with demp2 effect
+	float		dist, radius;
+	gentity_t	*gent;
+	gentity_t	*entityList[MAX_GENTITIES];
+	int			numListedEntities, i, e;
+	vec3_t		mins, maxs;
+	vec3_t		v, dir;
+
+	frac *= frac * frac; // yes, this is completely ridiculous...but it causes the shell to grow slowly then "explode" at the end
+	
+	radius = frac * 200.0f; // 200 is max radius...the model is aprox. 100 units tall...the fx draw code mults. this by 2.
+
+	for ( i = 0 ; i < 3 ; i++ ) 
+	{
+		mins[i] = ent->currentOrigin[i] - radius;
+		maxs[i] = ent->currentOrigin[i] + radius;
+	}
+
+	numListedEntities = gi.EntitiesInBox( mins, maxs, entityList, MAX_GENTITIES );
+
+	for ( e = 0 ; e < numListedEntities ; e++ ) 
+	{
+		gent = entityList[ e ];
+
+		if ( !gent->takedamage || !gent->contents )
+		{
+			continue;
+		}
+
+		// find the distance from the edge of the bounding box
+		for ( i = 0 ; i < 3 ; i++ ) 
+		{
+			if ( ent->currentOrigin[i] < gent->absmin[i] ) 
+			{
+				v[i] = gent->absmin[i] - ent->currentOrigin[i];
+			} 
+			else if ( ent->currentOrigin[i] > gent->absmax[i] ) 
+			{
+				v[i] = ent->currentOrigin[i] - gent->absmax[i];
+			} 
+			else 
+			{
+				v[i] = 0;
+			}
+		}
+
+		// shape is an ellipsoid, so cut vertical distance in half`
+		v[2] *= 0.5f;
+
+		dist = VectorLength( v );
+
+		if ( dist >= radius ) 
+		{
+			// shockwave hasn't hit them yet
+			continue;
+		}
+
+		if ( dist < ent->radius )
+		{
+			// shockwave has already hit this thing...
+			continue;
+		}
+
+		VectorCopy( gent->currentOrigin, v );
+		VectorSubtract( v, ent->currentOrigin, dir);
+
+		// push the center of mass higher than the origin so players get knocked into the air more
+		dir[2] += 12;
+
+		G_Damage( gent, ent, ent->owner, dir, ent->currentOrigin, DEMP2_ALT_DAMAGE, DAMAGE_DEATH_KNOCKBACK, ent->splashMethodOfDeath );
+		if ( gent->takedamage && gent->client ) 
+		{
+			gent->s.powerups |= ( 1 << PW_SHOCKED );
+			gent->client->ps.powerups[PW_SHOCKED] = level.time + 2000;
+			Saboteur_Decloak( gent, Q_irand( 3000, 10000 ) );
+		}
+	}
+
+	// store the last fraction so that next time around we can test against those things that fall between that last point and where the current shockwave edge is
+	ent->radius = radius;
+
+	if ( frac < 1.0f )
+	{
+		// shock is still happening so continue letting it expand
+		ent->nextthink = level.time + 50;
+	}
+}
+
+
+//---------------------------------------------------------
+void DEMP2_AltDetonate( gentity_t *ent )
+//---------------------------------------------------------
+{
+	G_SetOrigin( ent, ent->currentOrigin );
+
+	// start the effects, unfortunately, I wanted to do some custom things that I couldn't easily do with the fx system, so part of it uses an event and localEntities
+	G_PlayEffect( "demp2/altDetonate", ent->currentOrigin, ent->pos1 );
+	G_AddEvent( ent, EV_DEMP2_ALT_IMPACT, ent->count * 2 );
+
+	ent->fx_time = level.time;
+	ent->radius = 0;
+	ent->nextthink = level.time + 50;
+	ent->e_ThinkFunc = thinkF_DEMP2_AltRadiusDamage;
+	ent->s.eType = ET_GENERAL; // make us a missile no longer
+}
+
+//---------------------------------------------------------
+static void WP_DEMP2_AltFire( gentity_t *ent )
+//---------------------------------------------------------
+{
+	int		damage	= DEMP2_ALT_DAMAGE;
+	int		count;
+	vec3_t	start;
+	trace_t	tr;
+
+	VectorCopy( muzzle, start );
+	WP_TraceSetStart( ent, start, vec3_origin, vec3_origin );//make sure our start point isn't on the other side of a wall
+
+	count = ( level.time - ent->client->ps.weaponChargeTime ) / DEMP2_CHARGE_UNIT;
+
+	if ( count < 1 )
+	{
+		count = 1;
+	}
+	else if ( count > 3 )
+	{
+		count = 3;
+	}
+
+	damage *= ( 1 + ( count * ( count - 1 )));// yields damage of 12,36,84...gives a higher bonus for longer charge
+
+	// the shot can travel a whopping 4096 units in 1 second. Note that the shot will auto-detonate at 4096 units...we'll see if this looks cool or not
+	WP_MissileTargetHint(ent, start, forward);
+	gentity_t *missile = CreateMissile( start, forward, DEMP2_ALT_RANGE, 1000, ent, qtrue );
+
+	// letting it know what the charge size is.
+	missile->count = count;
+
+//	missile->speed = missile->nextthink;
+	VectorCopy( tr.plane.normal, missile->pos1 );
+
+	missile->classname = "demp2_alt_proj";
+	missile->s.weapon = WP_DEMP2;
+
+	missile->e_ThinkFunc = thinkF_DEMP2_AltDetonate;
+
+	missile->splashDamage = missile->damage = damage;
+	missile->splashMethodOfDeath = missile->methodOfDeath = MOD_DEMP2_ALT;
+	missile->splashRadius = DEMP2_ALT_SPLASHRADIUS;
+
+	missile->dflags = DAMAGE_DEATH_KNOCKBACK;
+	missile->clipmask = MASK_SHOT | CONTENTS_LIGHTSABER;
+
+	// we don't want it to ever bounce
+	missile->bounceCount = 0;
+}
+
+//---------------------------------------------------------
+static void WP_FireDEMP2( gentity_t *ent, qboolean alt_fire )
+//---------------------------------------------------------
+{
+	if ( alt_fire )
+	{
+		WP_DEMP2_AltFire( ent );
+	}
+	else
+	{
+		WP_DEMP2_MainFire( ent );
+	}
+}
+
+
+//-----------------------
+//	Golan Arms Flechette
+//-----------------------
+
+//---------------------------------------------------------
+static void WP_FlechetteMainFire( gentity_t *ent )
+//---------------------------------------------------------
+{
+	vec3_t		fwd, angs, start;
+	gentity_t	*missile;
+	float		damage = FLECHETTE_DAMAGE, vel = FLECHETTE_VEL;
+
+	VectorCopy( muzzle, start );
+	WP_TraceSetStart( ent, start, vec3_origin, vec3_origin );//make sure our start point isn't on the other side of a wall
+
+	// If we aren't the player, we will cut the velocity and damage of the shots
+	if ( ent->s.number )
+	{
+		damage *= 0.75f;
+		vel *= 0.5f;
+	}
+
+//	if ( ent->client && ent->client->ps.powerups[PW_WEAPON_OVERCHARGE] > 0 && ent->client->ps.powerups[PW_WEAPON_OVERCHARGE] > cg.time )
+//	{
+//		// in overcharge mode, so doing double damage
+//		damage *= 2;
+//	}
+
+	for ( int i = 0; i < FLECHETTE_SHOTS; i++ )
+	{
+		vectoangles( forward, angs );
+
+		if ( i == 0 && ent->s.number == 0 )
+		{
+			// do nothing on the first shot for the player, this one will hit the crosshairs
+		}
+		else
+		{
+			angs[PITCH] += crandom() * FLECHETTE_SPREAD;
+			angs[YAW]	+= crandom() * FLECHETTE_SPREAD;
+		}
+
+		AngleVectors( angs, fwd, NULL, NULL );
+
+		WP_MissileTargetHint(ent, start, fwd);
+
+		missile = CreateMissile( start, fwd, vel, 10000, ent );
+
+		missile->classname = "flech_proj";
+		missile->s.weapon = WP_FLECHETTE;
+
+		VectorSet( missile->maxs, FLECHETTE_SIZE, FLECHETTE_SIZE, FLECHETTE_SIZE );
+		VectorScale( missile->maxs, -1, missile->mins );
+
+		missile->damage = damage;
+
+//		if ( ent->client && ent->client->ps.powerups[PW_WEAPON_OVERCHARGE] > 0 && ent->client->ps.powerups[PW_WEAPON_OVERCHARGE] > cg.time )
+//		{
+//			missile->flags |= FL_OVERCHARGED;
+//		}
+			
+		missile->dflags = (DAMAGE_DEATH_KNOCKBACK|DAMAGE_EXTRA_KNOCKBACK);
+		
+		missile->methodOfDeath = MOD_FLECHETTE;
+		missile->clipmask = MASK_SHOT | CONTENTS_LIGHTSABER;
+
+		// we don't want it to bounce forever
+		missile->bounceCount = Q_irand(1,2);
+
+		missile->s.eFlags |= EF_BOUNCE_SHRAPNEL;
+		ent->client->sess.missionStats.shotsFired++;
+	}
+}
+
+//---------------------------------------------------------
+void prox_mine_think( gentity_t *ent )
+//---------------------------------------------------------
+{
+	int			count;
+	qboolean	blow = qfalse;
+
+	// if it isn't time to auto-explode, do a small proximity check
+	if ( ent->delay > level.time )
+	{
+		count = G_RadiusList( ent->currentOrigin, FLECHETTE_MINE_RADIUS_CHECK, ent, qtrue, ent_list );
+
+		for ( int i = 0; i < count; i++ )
+		{
+			if ( ent_list[i]->client && ent_list[i]->health > 0 && ent->activator && ent_list[i]->s.number != ent->activator->s.number )
+			{
+				blow = qtrue;
+				break;
+			}
+		}
+	}
+	else
+	{
+		// well, we must die now
+		blow = qtrue;
+	}
+
+	if ( blow )
+	{
+//		G_Sound( ent, G_SoundIndex( "sound/weapons/flechette/warning.wav" ));
+		ent->e_ThinkFunc = thinkF_WP_Explode;
+		ent->nextthink = level.time + 200;
+	}
+	else
+	{
+		// we probably don't need to do this thinking logic very often...maybe this is fast enough?
+		ent->nextthink = level.time + 500;
+	}
+}
+
+//---------------------------------------------------------
+void prox_mine_stick( gentity_t *self, gentity_t *other, trace_t *trace )
+//---------------------------------------------------------
+{
+	// turn us into a generic entity so we aren't running missile code
+	self->s.eType = ET_GENERAL;
+
+	self->s.modelindex = G_ModelIndex("models/weapons2/golan_arms/prox_mine.md3");
+	self->e_TouchFunc = touchF_NULL;
+
+	self->contents = CONTENTS_SOLID;
+	self->takedamage = qtrue;
+	self->health = 5;
+	self->e_DieFunc = dieF_WP_ExplosiveDie;
+
+	VectorSet( self->maxs, 5, 5, 5 );
+	VectorScale( self->maxs, -1, self->mins );
+
+	self->activator = self->owner;
+	self->owner = NULL;
+
+	WP_Stick( self, trace );
+	
+	self->e_ThinkFunc = thinkF_prox_mine_think;
+	self->nextthink = level.time + 450;
+
+	// sticks for twenty seconds, then auto blows.
+	self->delay = level.time + 20000;
+
+	gi.linkentity( self );
+}
+/* Old Flechette alt-fire code....
+//---------------------------------------------------------
+static void WP_FlechetteProxMine( gentity_t *ent )
+//---------------------------------------------------------
+{
+	gentity_t	*missile = CreateMissile( muzzle, forward, FLECHETTE_MINE_VEL, 10000, ent, qtrue );
+
+	missile->fxID = G_EffectIndex( "flechette/explosion" );
+
+	missile->classname = "proxMine";
+	missile->s.weapon = WP_FLECHETTE;
+
+	missile->s.pos.trType = TR_GRAVITY;
+
+	missile->s.eFlags |= EF_MISSILE_STICK;
+	missile->e_TouchFunc = touchF_prox_mine_stick;
+
+	missile->damage = FLECHETTE_MINE_DAMAGE;
+	missile->methodOfDeath = MOD_EXPLOSIVE;
+
+	missile->splashDamage = FLECHETTE_MINE_SPLASH_DAMAGE;
+	missile->splashRadius = FLECHETTE_MINE_SPLASH_RADIUS;
+	missile->splashMethodOfDeath = MOD_EXPLOSIVE_SPLASH;
+
+	missile->clipmask = MASK_SHOT;
+
+	// we don't want it to bounce forever
+	missile->bounceCount = 0; 
+}
+*/
+//----------------------------------------------
+void WP_flechette_alt_blow( gentity_t *ent )
+//----------------------------------------------
+{
+	EvaluateTrajectory( &ent->s.pos, level.time, ent->currentOrigin ); // Not sure if this is even necessary, but correct origins are cool?
+
+	G_RadiusDamage( ent->currentOrigin, ent->owner, ent->splashDamage, ent->splashRadius, NULL, MOD_EXPLOSIVE_SPLASH );
+	G_PlayEffect( "flechette/alt_blow", ent->currentOrigin );
+
+	G_FreeEntity( ent );
+}
+
+//------------------------------------------------------------------------------
+static void WP_CreateFlechetteBouncyThing( vec3_t start, vec3_t fwd, gentity_t *self )
+//------------------------------------------------------------------------------
+{
+	gentity_t	*missile = CreateMissile( start, fwd, 950 + random() * 700, 1500 + random() * 2000, self, qtrue );
+	
+	missile->e_ThinkFunc = thinkF_WP_flechette_alt_blow;
+
+	missile->s.weapon = WP_FLECHETTE;
+	missile->classname = "flech_alt";
+	missile->mass = 4;
+
+	// How 'bout we give this thing a size...
+	VectorSet( missile->mins, -3.0f, -3.0f, -3.0f );
+	VectorSet( missile->maxs, 3.0f, 3.0f, 3.0f );
+	missile->clipmask = MASK_SHOT;
+	missile->clipmask &= ~CONTENTS_CORPSE;
+
+	// normal ones bounce, alt ones explode on impact
+	missile->s.pos.trType = TR_GRAVITY;
+
+	missile->s.eFlags |= EF_BOUNCE_HALF;
+
+	missile->damage = FLECHETTE_ALT_DAMAGE;
+	missile->dflags = 0;
+	missile->splashDamage = FLECHETTE_ALT_SPLASH_DAM;
+	missile->splashRadius = FLECHETTE_ALT_SPLASH_RAD;
+
+	missile->svFlags = SVF_USE_CURRENT_ORIGIN;
+
+	missile->methodOfDeath = MOD_FLECHETTE_ALT;
+	missile->splashMethodOfDeath = MOD_FLECHETTE_ALT;
+
+	VectorCopy( start, missile->pos2 );
+}
+
+//---------------------------------------------------------
+static void WP_FlechetteAltFire( gentity_t *self )
+//---------------------------------------------------------
+{
+	vec3_t 	dir, fwd, start, angs;
+
+	vectoangles( forward, angs );
+	VectorCopy( muzzle, start );
+
+	WP_TraceSetStart( self, start, vec3_origin, vec3_origin );//make sure our start point isn't on the other side of a wall
+
+	for ( int i = 0; i < 2; i++ )
+	{
+		VectorCopy( angs, dir );
+
+		dir[PITCH] -= random() * 4 + 8; // make it fly upwards
+		dir[YAW] += crandom() * 2;
+		AngleVectors( dir, fwd, NULL, NULL );
+
+		WP_CreateFlechetteBouncyThing( start, fwd, self );
+		self->client->sess.missionStats.shotsFired++;
+	}
+}
+
+//---------------------------------------------------------
+static void WP_FireFlechette( gentity_t *ent, qboolean alt_fire )
+//---------------------------------------------------------
+{
+	if ( alt_fire )
+	{
+		WP_FlechetteAltFire( ent );
+	}
+	else
+	{
+		WP_FlechetteMainFire( ent );
+	}
+}
+
+
+//-----------------------
+//	Rocket Launcher
+//-----------------------
+
+//---------------------------------------------------------
+void rocketThink( gentity_t *ent )
+//---------------------------------------------------------
+{
+	vec3_t newdir, targetdir, 
+			up={0,0,1}, right; 
+	vec3_t	org;
+	float dot, dot2;
+
+	if ( ent->disconnectDebounceTime && ent->disconnectDebounceTime < level.time )
+	{//time's up, we're done, remove us
+		if ( ent->lockCount )
+		{//explode when die
+			WP_ExplosiveDie( ent, ent->owner, ent->owner, 0, MOD_UNKNOWN, 0, HL_NONE );
+		}
+		else
+		{//just remove when die
+			G_FreeEntity( ent );
+		}
+		return;
+	}
+	if ( ent->enemy && ent->enemy->inuse )
+	{
+		float vel = (ent->spawnflags&1)?ent->speed:ROCKET_VELOCITY;
+		float newDirMult = ent->angle?ent->angle*2.0f:1.0f;
+		float oldDirMult = ent->angle?(1.0f-ent->angle)*2.0f:1.0f;
+
+		if ( (ent->spawnflags&1) )
+		{//vehicle rocket
+			if ( ent->enemy->client && ent->enemy->client->NPC_class == CLASS_VEHICLE )
+			{//tracking another vehicle
+				if ( ent->enemy->client->ps.speed+ent->speed > vel )
+				{
+					vel = ent->enemy->client->ps.speed+ent->speed;
+				}
+			}
+		}
+
+		VectorCopy( ent->enemy->currentOrigin, org );
+		org[2] += (ent->enemy->mins[2] + ent->enemy->maxs[2]) * 0.5f;
+
+		if ( ent->enemy->client )
+		{
+			switch( ent->enemy->client->NPC_class )
+			{
+			case CLASS_ATST:
+				org[2] += 80;
+				break;
+			case CLASS_MARK1:
+				org[2] += 40;
+				break;
+			case CLASS_PROBE:
+				org[2] += 60;
+				break;
+			}
+			if ( !TIMER_Done( ent->enemy, "flee" ) )
+			{
+				TIMER_Set( ent->enemy, "rocketChasing", 500 );
+			}
+		}
+
+		VectorSubtract( org, ent->currentOrigin, targetdir );
+		VectorNormalize( targetdir );
+
+		// Now the rocket can't do a 180 in space, so we'll limit the turn to about 45 degrees.
+		dot = DotProduct( targetdir, ent->movedir );
+
+		// a dot of 1.0 means right-on-target.
+		if ( dot < 0.0f )
+		{	
+			// Go in the direction opposite, start a 180.
+			CrossProduct( ent->movedir, up, right );
+			dot2 = DotProduct( targetdir, right );
+
+			if ( dot2 > 0 )
+			{	
+				// Turn 45 degrees right.
+				VectorMA( ent->movedir, 0.3f*newDirMult, right, newdir );
+			}
+			else
+			{	
+				// Turn 45 degrees left.
+				VectorMA(ent->movedir, -0.3f*newDirMult, right, newdir);
+			}
+
+			// Yeah we've adjusted horizontally, but let's split the difference vertically, so we kinda try to move towards it.
+			newdir[2] = ( (targetdir[2]*newDirMult) + (ent->movedir[2]*oldDirMult) ) * 0.5;
+
+			// slowing down coupled with fairly tight turns can lead us to orbit an enemy..looks bad so don't do it!
+//			vel *= 0.5f;
+		}
+		else if ( dot < 0.70f )
+		{	
+			// Still a bit off, so we turn a bit softer
+			VectorMA( ent->movedir, 0.5f*newDirMult, targetdir, newdir );
+		}
+		else
+		{	
+			// getting close, so turn a bit harder
+			VectorMA( ent->movedir, 0.9f*newDirMult, targetdir, newdir );
+		}
+
+		// add crazy drunkenness
+		for ( int i = 0; i < 3; i++ )
+		{
+			newdir[i] += crandom() * ent->random * 0.25f;
+		}
+
+		// decay the randomness
+		ent->random *= 0.9f;
+
+		if ( ent->enemy->client
+			&& ent->enemy->client->ps.groundEntityNum != ENTITYNUM_NONE )
+		{//tracking a client who's on the ground, aim at the floor...?
+			// Try to crash into the ground if we get close enough to do splash damage
+			float dis = Distance( ent->currentOrigin, org );
+
+			if ( dis < 128 )
+			{
+				// the closer we get, the more we push the rocket down, heh heh.
+				newdir[2] -= (1.0f - (dis / 128.0f)) * 0.6f;
+			}
+		}
+
+		VectorNormalize( newdir );
+
+		VectorScale( newdir, vel * 0.5f, ent->s.pos.trDelta );
+		VectorCopy( newdir, ent->movedir );
+		SnapVector( ent->s.pos.trDelta );			// save net bandwidth
+		VectorCopy( ent->currentOrigin, ent->s.pos.trBase );
+		ent->s.pos.trTime = level.time;
+	}
+
+	ent->nextthink = level.time + ROCKET_ALT_THINK_TIME;	// Nothing at all spectacular happened, continue.
+	return;
+}
+
+//---------------------------------------------------------
+static void WP_FireRocket( gentity_t *ent, qboolean alt_fire )
+//---------------------------------------------------------
+{
+	vec3_t	start;
+	int		damage	= ROCKET_DAMAGE;
+	float	vel = ROCKET_VELOCITY;
+
+	if ( alt_fire )
+	{
+		vel *= 0.5f;
+	}
+
+	VectorCopy( muzzle, start );
+	WP_TraceSetStart( ent, start, vec3_origin, vec3_origin );//make sure our start point isn't on the other side of a wall
+
+	gentity_t *missile = CreateMissile( start, forward, vel, 10000, ent, alt_fire );
+
+	missile->classname = "rocket_proj";
+	missile->s.weapon = WP_ROCKET_LAUNCHER;
+	missile->mass = 10;
+
+	// Do the damages
+	if ( ent->s.number != 0 )
+	{
+		if ( g_spskill->integer == 0 )
+		{
+			damage = ROCKET_NPC_DAMAGE_EASY;
+		}
+		else if ( g_spskill->integer == 1 )
+		{
+			damage = ROCKET_NPC_DAMAGE_NORMAL;
+		}
+		else
+		{
+			damage = ROCKET_NPC_DAMAGE_HARD;
+		}
+		if (ent->client && ent->client->NPC_class==CLASS_BOBAFETT)
+		{
+			damage = damage/2;
+		}
+	}
+
+	if ( alt_fire )
+	{
+		int	lockEntNum, lockTime;
+		if ( ent->NPC && ent->enemy )
+		{
+			lockEntNum = ent->enemy->s.number;
+			lockTime = Q_irand( 600, 1200 );
+		}
+		else
+		{
+			lockEntNum = g_rocketLockEntNum;
+			lockTime = g_rocketLockTime;
+		}
+		// we'll consider attempting to lock this little poochie onto some baddie.
+		if ( (lockEntNum > 0||ent->NPC&&lockEntNum>=0) && lockEntNum < ENTITYNUM_WORLD && lockTime > 0 )
+		{
+			// take our current lock time and divide that by 8 wedge slices to get the current lock amount
+			int dif = ( level.time - lockTime ) / ( 1200.0f / 8.0f );
+
+			if ( dif < 0 )
+			{
+				dif = 0;
+			}
+			else if ( dif > 8 )
+			{
+				dif = 8;
+			}
+
+			// if we are fully locked, always take on the enemy.  
+			//	Also give a slight advantage to higher, but not quite full charges.  
+			//	Finally, just give any amount of charge a very slight random chance of locking.
+			if ( dif == 8 || random() * dif > 2 || random() > 0.97f )
+			{
+				missile->enemy = &g_entities[lockEntNum];
+
+				if ( missile->enemy 
+					&& missile->enemy->inuse )//&& DistanceSquared( missile->currentOrigin, missile->enemy->currentOrigin ) < 262144 && InFOV( missile->currentOrigin, missile->enemy->currentOrigin, missile->enemy->client->ps.viewangles, 45, 45 ) )
+				{
+					if ( missile->enemy->client
+						&& (missile->enemy->client->ps.forcePowersKnown&(1<<FP_PUSH))
+						&& missile->enemy->client->ps.forcePowerLevel[FP_PUSH] > FORCE_LEVEL_0 )
+					{//have force push, don't flee from homing rockets
+					}
+					else
+					{
+						vec3_t dir, dir2;
+
+						AngleVectors( missile->enemy->currentAngles, dir, NULL, NULL );
+						AngleVectors( ent->client->renderInfo.eyeAngles, dir2, NULL, NULL );
+
+						if ( DotProduct( dir, dir2 ) < 0.0f )
+						{
+							G_StartFlee( missile->enemy, ent, missile->enemy->currentOrigin, AEL_DANGER_GREAT, 3000, 5000 );
+							if ( !TIMER_Done( missile->enemy, "flee" ) )
+							{
+								TIMER_Set( missile->enemy, "rocketChasing", 500 );
+							}
+						}
+					}
+				}
+			}
+		}
+
+		VectorCopy( forward, missile->movedir );
+
+		missile->e_ThinkFunc = thinkF_rocketThink;
+		missile->random = 1.0f;
+		missile->nextthink = level.time + ROCKET_ALT_THINK_TIME;
+	}
+
+	// Make it easier to hit things
+	VectorSet( missile->maxs, ROCKET_SIZE, ROCKET_SIZE, ROCKET_SIZE );
+	VectorScale( missile->maxs, -1, missile->mins );
+
+	missile->damage = damage;
+	missile->dflags = DAMAGE_DEATH_KNOCKBACK;
+
+	if ( alt_fire )
+	{
+		missile->methodOfDeath = MOD_ROCKET_ALT;
+		missile->splashMethodOfDeath = MOD_ROCKET_ALT;// ?SPLASH;
+	}
+	else
+	{
+		missile->methodOfDeath = MOD_ROCKET;
+		missile->splashMethodOfDeath = MOD_ROCKET;// ?SPLASH;
+	}
+
+	missile->clipmask = MASK_SHOT | CONTENTS_LIGHTSABER;
+	missile->splashDamage = ROCKET_SPLASH_DAMAGE;
+	missile->splashRadius = ROCKET_SPLASH_RADIUS;
+
+	// we don't want it to ever bounce
+	missile->bounceCount = 0;
+}
+
+static void WP_FireConcussionAlt( gentity_t *ent )
+{//a rail-gun-like beam
+	int			damage = CONC_ALT_DAMAGE, skip, traces = DISRUPTOR_ALT_TRACES;
+	qboolean	render_impact = qtrue;
+	vec3_t		start, end;
+	vec3_t		muzzle2, spot, dir;
+	trace_t		tr;
+	gentity_t	*traceEnt, *tent;
+	float		dist, shotDist, shotRange = 8192;
+	qboolean	hitDodged = qfalse;
+
+	if (ent->s.number >= MAX_CLIENTS)
+	{
+		vec3_t angles;
+		vectoangles(forward, angles);
+		angles[PITCH] += ( crandom() * (CONC_NPC_SPREAD+(6-ent->NPC->currentAim)*0.25f));//was 0.5f
+		angles[YAW]	  += ( crandom() * (CONC_NPC_SPREAD+(6-ent->NPC->currentAim)*0.25f));//was 0.5f
+		AngleVectors(angles, forward, vright, up);
+	}
+
+	//Shove us backwards for half a second
+	VectorMA( ent->client->ps.velocity, -200, forward, ent->client->ps.velocity );
+	ent->client->ps.groundEntityNum = ENTITYNUM_NONE;
+	if ( (ent->client->ps.pm_flags&PMF_DUCKED) )
+	{//hunkered down
+		ent->client->ps.pm_time = 100;
+	}
+	else
+	{
+		ent->client->ps.pm_time = 250;
+	}
+	ent->client->ps.pm_flags |= PMF_TIME_KNOCKBACK|PMF_TIME_NOFRICTION;
+	//FIXME: only if on ground?  So no "rocket jump"?  Or: (see next FIXME)
+	//FIXME: instead, set a forced ucmd backmove instead of this sliding
+
+	VectorCopy( muzzle, muzzle2 ); // making a backup copy
+
+	// The trace start will originate at the eye so we can ensure that it hits the crosshair.
+	if ( ent->NPC )
+	{
+		switch ( g_spskill->integer )
+		{
+		case 0:
+			damage = CONC_ALT_NPC_DAMAGE_EASY;
+			break;
+		case 1:
+			damage = CONC_ALT_NPC_DAMAGE_MEDIUM;
+			break;
+		case 2:
+		default:
+			damage = CONC_ALT_NPC_DAMAGE_HARD;
+			break;
+		}
+	}
+	VectorCopy( muzzle, start );
+	WP_TraceSetStart( ent, start, vec3_origin, vec3_origin );
+
+	skip = ent->s.number;
+
+//	if ( ent->client && ent->client->ps.powerups[PW_WEAPON_OVERCHARGE] > 0 && ent->client->ps.powerups[PW_WEAPON_OVERCHARGE] > cg.time )
+//	{
+//		// in overcharge mode, so doing double damage
+//		damage *= 2;
+//	}
+	
+	//Make it a little easier to hit guys at long range
+	vec3_t shot_mins, shot_maxs;
+	VectorSet( shot_mins, -1, -1, -1 );
+	VectorSet( shot_maxs, 1, 1, 1 );
+
+	for ( int i = 0; i < traces; i++ )
+	{
+		VectorMA( start, shotRange, forward, end );
+
+		//NOTE: if you want to be able to hit guys in emplaced guns, use "G2_COLLIDE, 10" instead of "G2_RETURNONHIT, 0"
+		//alternately, if you end up hitting an emplaced_gun that has a sitter, just redo this one trace with the "G2_COLLIDE, 10" to see if we it the sitter
+		//gi.trace( &tr, start, NULL, NULL, end, skip, MASK_SHOT, G2_COLLIDE, 10 );//G2_RETURNONHIT, 0 );
+		gi.trace( &tr, start, shot_mins, shot_maxs, end, skip, MASK_SHOT, G2_COLLIDE, 10 );//G2_RETURNONHIT, 0 );
+
+		if ( tr.surfaceFlags & SURF_NOIMPACT ) 
+		{
+			render_impact = qfalse;
+		}
+
+		if ( tr.entityNum == ent->s.number )
+		{
+			// should never happen, but basically we don't want to consider a hit to ourselves?
+			// Get ready for an attempt to trace through another person
+			VectorCopy( tr.endpos, muzzle2 );
+			VectorCopy( tr.endpos, start );
+			skip = tr.entityNum;
+#ifdef _DEBUG
+			gi.Printf( "BAD! Concussion gun shot somehow traced back and hit the owner!\n" );			
+#endif
+			continue;
+		}
+
+		// always render a shot beam, doing this the old way because I don't much feel like overriding the effect.
+		//NOTE: let's just draw one beam at the end
+		//tent = G_TempEntity( tr.endpos, EV_CONC_ALT_SHOT );
+		//tent->svFlags |= SVF_BROADCAST;
+
+		//VectorCopy( muzzle2, tent->s.origin2 );
+
+		if ( tr.fraction >= 1.0f )
+		{
+			// draw the beam but don't do anything else
+			break;
+		}
+
+		traceEnt = &g_entities[tr.entityNum];
+
+		if ( traceEnt //&& traceEnt->NPC 
+			&& ( traceEnt->s.weapon == WP_SABER || (traceEnt->client && (traceEnt->client->NPC_class == CLASS_BOBAFETT||traceEnt->client->NPC_class == CLASS_REBORN) ) ) )
+		{//FIXME: need a more reliable way to know we hit a jedi?
+			hitDodged = Jedi_DodgeEvasion( traceEnt, ent, &tr, HL_NONE );
+			//acts like we didn't even hit him
+		}
+		if ( !hitDodged )
+		{
+			if ( render_impact )
+			{
+				if (( tr.entityNum < ENTITYNUM_WORLD && traceEnt->takedamage ) 
+					|| !Q_stricmp( traceEnt->classname, "misc_model_breakable" ) 
+					|| traceEnt->s.eType == ET_MOVER )
+				{
+					// Create a simple impact type mark that doesn't last long in the world
+					G_PlayEffect( G_EffectIndex( "concussion/alt_hit" ), tr.endpos, tr.plane.normal );
+
+					if ( traceEnt->client && LogAccuracyHit( traceEnt, ent )) 
+					{//NOTE: hitting multiple ents can still get you over 100% accuracy
+						ent->client->ps.persistant[PERS_ACCURACY_HITS]++;
+					} 
+
+					int hitLoc = G_GetHitLocFromTrace( &tr, MOD_CONC_ALT );
+					qboolean noKnockBack = (traceEnt->flags&FL_NO_KNOCKBACK);//will be set if they die, I want to know if it was on *before* they died
+					if ( traceEnt && traceEnt->client && traceEnt->client->NPC_class == CLASS_GALAKMECH )
+					{//hehe
+						G_Damage( traceEnt, ent, ent, forward, tr.endpos, 10, DAMAGE_NO_KNOCKBACK|DAMAGE_NO_HIT_LOC, MOD_CONC_ALT, hitLoc );
+						break;
+					}
+					G_Damage( traceEnt, ent, ent, forward, tr.endpos, damage, DAMAGE_NO_KNOCKBACK|DAMAGE_NO_HIT_LOC, MOD_CONC_ALT, hitLoc );
+
+					//do knockback and knockdown manually
+					if ( traceEnt->client )
+					{//only if we hit a client
+						vec3_t pushDir;
+						VectorCopy( forward, pushDir );
+						if ( pushDir[2] < 0.2f )
+						{
+							pushDir[2] = 0.2f;
+						}//hmm, re-normalize?  nah...
+						//if ( traceEnt->NPC || Q_irand(0,g_spskill->integer+1) )
+						{
+							if ( !noKnockBack )
+							{//knock-backable
+								G_Throw( traceEnt, pushDir, 200 );
+								if ( traceEnt->client->NPC_class == CLASS_ROCKETTROOPER )
+								{
+									traceEnt->client->ps.pm_time = Q_irand( 1500, 3000 );
+								}
+							}
+							if ( traceEnt->health > 0 )
+							{//alive
+								if ( G_HasKnockdownAnims( traceEnt ) )
+								{//knock-downable
+									G_Knockdown( traceEnt, ent, pushDir, 400, qtrue );
+								}
+							}
+						}
+					}
+
+					if ( traceEnt->s.eType == ET_MOVER )
+					{//stop the traces on any mover
+						break;
+					}
+				}
+				else 
+				{
+					 // we only make this mark on things that can't break or move
+					tent = G_TempEntity( tr.endpos, EV_CONC_ALT_MISS );
+					tent->svFlags |= SVF_BROADCAST;
+					VectorCopy( tr.plane.normal, tent->pos1 );
+					break; // hit solid, but doesn't take damage, so stop the shot...we _could_ allow it to shoot through walls, might be cool?
+				}
+			}
+			else // not rendering impact, must be a skybox or other similar thing?
+			{
+				break; // don't try anymore traces
+			}
+		}
+		// Get ready for an attempt to trace through another person
+		VectorCopy( tr.endpos, muzzle2 );
+		VectorCopy( tr.endpos, start );
+		skip = tr.entityNum;
+		hitDodged = qfalse;
+	}
+	//just draw one beam all the way to the end
+	tent = G_TempEntity( tr.endpos, EV_CONC_ALT_SHOT );
+	tent->svFlags |= SVF_BROADCAST;
+	VectorCopy( muzzle, tent->s.origin2 );
+
+	// now go along the trail and make sight events
+	VectorSubtract( tr.endpos, muzzle, dir );
+
+	shotDist = VectorNormalize( dir );
+
+	//FIXME: if shoot *really* close to someone, the alert could be way out of their FOV
+	for ( dist = 0; dist < shotDist; dist += 64 )
+	{
+		//FIXME: on a really long shot, this could make a LOT of alerts in one frame...
+		VectorMA( muzzle, dist, dir, spot );
+		AddSightEvent( ent, spot, 256, AEL_DISCOVERED, 50 );
+		//FIXME: creates *way* too many effects, make it one effect somehow?
+		G_PlayEffect( G_EffectIndex( "concussion/alt_ring" ), spot, forward );
+	}
+	//FIXME: spawn a temp ent that continuously spawns sight alerts here?  And 1 sound alert to draw their attention?
+	VectorMA( start, shotDist-4, forward, spot );
+	AddSightEvent( ent, spot, 256, AEL_DISCOVERED, 50 );
+
+	G_PlayEffect( G_EffectIndex( "concussion/altmuzzle_flash" ), muzzle, forward );
+}
+
+static void WP_FireConcussion( gentity_t *ent )
+{//a fast rocket-like projectile
+	vec3_t	start;
+	int		damage	= CONC_DAMAGE;
+	float	vel = CONC_VELOCITY;
+
+	if (ent->s.number >= MAX_CLIENTS)
+	{
+		vec3_t angles;
+		vectoangles(forward, angles);
+		angles[PITCH] += ( crandom() * (CONC_NPC_SPREAD+(6-ent->NPC->currentAim)*0.25f));//was 0.5f
+		angles[YAW]	  += ( crandom() * (CONC_NPC_SPREAD+(6-ent->NPC->currentAim)*0.25f));//was 0.5f
+		AngleVectors(angles, forward, vright, up);
+	}
+
+	//hold us still for a bit
+	ent->client->ps.pm_time = 300;
+	ent->client->ps.pm_flags |= PMF_TIME_KNOCKBACK;
+	//add viewkick
+	if ( ent->s.number < MAX_CLIENTS//player only
+		&& !cg.renderingThirdPerson )//gives an advantage to being in 3rd person, but would look silly otherwise
+	{//kick the view back
+		cg.kick_angles[PITCH] = Q_flrand( -10, -15 );
+		cg.kick_time = level.time;
+	}
+
+	VectorCopy( muzzle, start );
+	WP_TraceSetStart( ent, start, vec3_origin, vec3_origin );//make sure our start point isn't on the other side of a wall
+
+	gentity_t *missile = CreateMissile( start, forward, vel, 10000, ent, qfalse );
+
+	missile->classname = "conc_proj";
+	missile->s.weapon = WP_CONCUSSION;
+	missile->mass = 10;
+
+	// Do the damages
+	if ( ent->s.number != 0 )
+	{
+		if ( g_spskill->integer == 0 )
+		{
+			damage = CONC_NPC_DAMAGE_EASY;
+		}
+		else if ( g_spskill->integer == 1 )
+		{
+			damage = CONC_NPC_DAMAGE_NORMAL;
+		}
+		else
+		{
+			damage = CONC_NPC_DAMAGE_HARD;
+		}
+	}
+
+	// Make it easier to hit things
+	VectorSet( missile->maxs, ROCKET_SIZE, ROCKET_SIZE, ROCKET_SIZE );
+	VectorScale( missile->maxs, -1, missile->mins );
+
+	missile->damage = damage;
+	missile->dflags = DAMAGE_EXTRA_KNOCKBACK;
+
+	missile->methodOfDeath = MOD_CONC;
+	missile->splashMethodOfDeath = MOD_CONC;
+
+	missile->clipmask = MASK_SHOT | CONTENTS_LIGHTSABER;
+	missile->splashDamage = CONC_SPLASH_DAMAGE;
+	missile->splashRadius = CONC_SPLASH_RADIUS;
+
+	// we don't want it to ever bounce
+	missile->bounceCount = 0;
+}
+
+//-----------------------
+//	Det Pack
+//-----------------------
+
+//---------------------------------------------------------
+void charge_stick( gentity_t *self, gentity_t *other, trace_t *trace )
+//---------------------------------------------------------
+{
+	self->s.eType = ET_GENERAL;
+
+	// make us so we can take damage
+	self->clipmask = MASK_SHOT;
+	self->contents = CONTENTS_SHOTCLIP;
+	self->takedamage = qtrue;
+	self->health = 25;
+
+	self->e_DieFunc = dieF_WP_ExplosiveDie;
+
+	VectorSet( self->maxs, 10, 10, 10 );
+	VectorScale( self->maxs, -1, self->mins );
+
+	self->activator = self->owner;
+	self->owner = NULL; 
+
+	self->e_TouchFunc = touchF_NULL;
+	self->e_ThinkFunc = thinkF_NULL;
+	self->nextthink = -1;
+
+	WP_Stick( self, trace, 1.0f );
+}
+
+//---------------------------------------------------------
+static void WP_DropDetPack( gentity_t *self, vec3_t start, vec3_t dir ) 
+//---------------------------------------------------------
+{
+	// Chucking a new one
+	AngleVectors( self->client->ps.viewangles, forward, vright, up );
+	CalcMuzzlePoint( self, forward, vright, up, muzzle, 0 );
+	VectorNormalize( forward );
+	VectorMA( muzzle, -4, forward, muzzle );
+
+	VectorCopy( muzzle, start );
+	WP_TraceSetStart( self, start, vec3_origin, vec3_origin );//make sure our start point isn't on the other side of a wall
+
+	gentity_t	*missile = CreateMissile( start, forward, 300, 10000, self, qfalse );
+
+	missile->fxID = G_EffectIndex( "detpack/explosion" ); // if we set an explosion effect, explode death can use that instead
+
+	missile->classname = "detpack";
+	missile->s.weapon = WP_DET_PACK;
+
+	missile->s.pos.trType = TR_GRAVITY;
+
+	missile->s.eFlags |= EF_MISSILE_STICK;
+	missile->e_TouchFunc = touchF_charge_stick;
+	
+	missile->damage = FLECHETTE_MINE_DAMAGE;
+	missile->methodOfDeath = MOD_DETPACK;
+
+	missile->splashDamage = FLECHETTE_MINE_SPLASH_DAMAGE;
+	missile->splashRadius = FLECHETTE_MINE_SPLASH_RADIUS;
+	missile->splashMethodOfDeath = MOD_DETPACK;// ?SPLASH;
+
+	missile->clipmask = (CONTENTS_SOLID|CONTENTS_BODY|CONTENTS_SHOTCLIP);//MASK_SHOT;
+
+	// we don't want it to ever bounce
+	missile->bounceCount = 0;
+
+	missile->s.radius = 30;
+	VectorSet( missile->s.modelScale, 1.0f, 1.0f, 1.0f );
+	gi.G2API_InitGhoul2Model( missile->ghoul2, weaponData[WP_DET_PACK].missileMdl, G_ModelIndex( weaponData[WP_DET_PACK].missileMdl ));
+
+	AddSoundEvent( NULL, missile->currentOrigin, 128, AEL_MINOR, qtrue );
+	AddSightEvent( NULL, missile->currentOrigin, 128, AEL_SUSPICIOUS, 10 );
+}
+
+//---------------------------------------------------------
+static void WP_FireDetPack( gentity_t *ent, qboolean alt_fire )
+//---------------------------------------------------------
+{
+	if ( !ent || !ent->client )
+	{
+		return;
+	}
+
+	if ( alt_fire  )
+	{
+		if ( ent->client->ps.eFlags & EF_PLANTED_CHARGE )
+		{
+			gentity_t *found = NULL;
+
+			// loop through all ents and blow the crap out of them!
+			while (( found = G_Find( found, FOFS( classname ), "detpack" )) != NULL )
+			{
+				if ( found->activator == ent )
+				{
+					VectorCopy( found->currentOrigin, found->s.origin );
+					found->e_ThinkFunc = thinkF_WP_Explode;
+					found->nextthink = level.time + 100 + random() * 100;
+					G_Sound( found, G_SoundIndex( "sound/weapons/detpack/warning.wav" ));
+
+					// would be nice if this actually worked?
+					AddSoundEvent( NULL, found->currentOrigin, found->splashRadius*2, AEL_DANGER, qfalse, qtrue );//FIXME: are we on ground or not?
+					AddSightEvent( NULL, found->currentOrigin, found->splashRadius*2, AEL_DISCOVERED, 100 );
+				}
+			}
+
+			ent->client->ps.eFlags &= ~EF_PLANTED_CHARGE;
+		}
+	}
+	else
+	{
+		WP_DropDetPack( ent, muzzle, forward );
+
+		ent->client->ps.eFlags |= EF_PLANTED_CHARGE;
+	}
+}
+
+
+//-----------------------
+//	Laser Trip Mine
+//-----------------------
+
+#define PROXIMITY_STYLE 1
+#define TRIPWIRE_STYLE	2
+
+//---------------------------------------------------------
+void touchLaserTrap( gentity_t *ent, gentity_t *other, trace_t *trace )
+//---------------------------------------------------------
+{
+	ent->s.eType = ET_GENERAL;
+
+	// a tripwire so add draw line flag
+	VectorCopy( trace->plane.normal, ent->movedir );
+
+	// make it shootable
+	VectorSet( ent->mins, -4, -4, -4 );
+	VectorSet( ent->maxs, 4, 4, 4 );
+
+	ent->clipmask = MASK_SHOT;
+	ent->contents = CONTENTS_SHOTCLIP;
+	ent->takedamage = qtrue;
+	ent->health = 15;
+
+	ent->e_DieFunc = dieF_WP_ExplosiveDie;
+	ent->e_TouchFunc = touchF_NULL;
+
+	// so we can trip it too
+	ent->activator = ent->owner;
+	ent->owner = NULL;
+
+	WP_Stick( ent, trace );
+
+	if ( ent->count == TRIPWIRE_STYLE )
+	{
+		vec3_t		mins = {-4,-4,-4}, maxs = {4,4,4};//FIXME: global these
+		trace_t		tr;
+		VectorMA( ent->currentOrigin, 32, ent->movedir, ent->s.origin2 );
+		gi.trace( &tr, ent->s.origin2, mins, maxs, ent->currentOrigin, ent->s.number, MASK_SHOT, G2_RETURNONHIT, 0 );
+		VectorCopy( tr.endpos, ent->s.origin2 );
+
+		ent->e_ThinkFunc = thinkF_laserTrapThink;
+	}
+	else
+	{
+		ent->e_ThinkFunc = thinkF_WP_prox_mine_think;
+	}
+
+	ent->nextthink = level.time + LT_ACTIVATION_DELAY;
+}
+
+// copied from flechette prox above...which will not be used if this gets approved
+//---------------------------------------------------------
+void WP_prox_mine_think( gentity_t *ent )
+//---------------------------------------------------------
+{
+	int			count;
+	qboolean	blow = qfalse;
+
+	// first time through?
+	if ( ent->count )
+	{
+		// play activated warning
+		ent->count = 0;
+		ent->s.eFlags |= EF_PROX_TRIP;
+		G_Sound( ent, G_SoundIndex( "sound/weapons/laser_trap/warning.wav" ));
+	}
+
+	// if it isn't time to auto-explode, do a small proximity check
+	if ( ent->delay > level.time )
+	{
+		count = G_RadiusList( ent->currentOrigin, PROX_MINE_RADIUS_CHECK, ent, qtrue, ent_list );
+
+		for ( int i = 0; i < count; i++ )
+		{
+			if ( ent_list[i]->client && ent_list[i]->health > 0 && ent->activator && ent_list[i]->s.number != ent->activator->s.number )
+			{
+				blow = qtrue;
+				break;
+			}
+		}
+	}
+	else
+	{
+		// well, we must die now
+		blow = qtrue;
+	}
+
+	if ( blow )
+	{
+//		G_Sound( ent, G_SoundIndex( "sound/weapons/flechette/warning.wav" ));
+		ent->e_ThinkFunc = thinkF_WP_Explode;
+		ent->nextthink = level.time + 200;
+	}
+	else
+	{
+		// we probably don't need to do this thinking logic very often...maybe this is fast enough?
+		ent->nextthink = level.time + 500;
+	}
+}
+
+//---------------------------------------------------------
+void laserTrapThink( gentity_t *ent )
+//---------------------------------------------------------
+{
+	gentity_t	*traceEnt;
+	vec3_t		end, mins = {-4,-4,-4}, maxs = {4,4,4};
+	trace_t		tr;
+
+	// turn on the beam effect
+	if ( !(ent->s.eFlags & EF_FIRING ))
+	{
+		// arm me
+		G_Sound( ent, G_SoundIndex( "sound/weapons/laser_trap/warning.wav" ));
+		ent->s.loopSound = G_SoundIndex( "sound/weapons/laser_trap/hum_loop.wav" );
+		ent->s.eFlags |= EF_FIRING;
+	}
+
+	ent->e_ThinkFunc = thinkF_laserTrapThink;
+	ent->nextthink = level.time + FRAMETIME;
+
+	// Find the main impact point
+	VectorMA( ent->s.pos.trBase, 2048, ent->movedir, end );
+	gi.trace( &tr, ent->s.origin2, mins, maxs, end, ent->s.number, MASK_SHOT, G2_RETURNONHIT, 0 );
+	
+	traceEnt = &g_entities[ tr.entityNum ];
+
+	// Adjust this so that the effect has a relatively fresh endpoint
+	VectorCopy( tr.endpos, ent->pos4 );
+
+	if ( traceEnt->client || tr.startsolid )
+	{
+		// go boom
+		WP_Explode( ent );
+		ent->s.eFlags &= ~EF_FIRING; // don't draw beam if we are dead
+	}
+	else
+	{
+		/*
+		// FIXME: they need to avoid the beam!
+		AddSoundEvent( ent->owner, ent->currentOrigin, ent->splashRadius*2, AEL_DANGER );
+		AddSightEvent( ent->owner, ent->currentOrigin, ent->splashRadius*2, AEL_DANGER, 50 );
+		*/
+	}
+}
+
+//---------------------------------------------------------
+void CreateLaserTrap( gentity_t *laserTrap, vec3_t start, gentity_t *owner )
+//---------------------------------------------------------
+{
+	if ( !VALIDSTRING( laserTrap->classname ))
+	{
+		// since we may be coming from a map placed trip mine, we don't want to override that class name....
+		//	That would be bad because the player drop code tries to limit number of placed items...so it would have removed map placed ones as well.
+		laserTrap->classname = "tripmine";
+	}
+
+	laserTrap->splashDamage = LT_SPLASH_DAM;
+	laserTrap->splashRadius = LT_SPLASH_RAD;
+	laserTrap->damage = LT_DAMAGE;
+	laserTrap->methodOfDeath = MOD_LASERTRIP;
+	laserTrap->splashMethodOfDeath = MOD_LASERTRIP;//? SPLASH;
+
+	laserTrap->s.eType = ET_MISSILE;
+	laserTrap->svFlags = SVF_USE_CURRENT_ORIGIN;
+	laserTrap->s.weapon = WP_TRIP_MINE;
+
+	laserTrap->owner = owner;
+//	VectorSet( laserTrap->mins, -LT_SIZE, -LT_SIZE, -LT_SIZE );
+//	VectorSet( laserTrap->maxs, LT_SIZE, LT_SIZE, LT_SIZE );
+	laserTrap->clipmask = (CONTENTS_SOLID|CONTENTS_BODY|CONTENTS_SHOTCLIP);//MASK_SHOT;
+
+	laserTrap->s.pos.trTime = level.time;		// move a bit on the very first frame
+	VectorCopy( start, laserTrap->s.pos.trBase );
+	VectorCopy( start, laserTrap->currentOrigin);
+
+	VectorCopy( start, laserTrap->pos2 ); // ?? wtf ?
+	
+	laserTrap->fxID = G_EffectIndex( "tripMine/explosion" );
+
+	laserTrap->e_TouchFunc = touchF_touchLaserTrap;
+
+	laserTrap->s.radius = 60;
+	VectorSet( laserTrap->s.modelScale, 1.0f, 1.0f, 1.0f );
+	gi.G2API_InitGhoul2Model( laserTrap->ghoul2, weaponData[WP_TRIP_MINE].missileMdl, G_ModelIndex( weaponData[WP_TRIP_MINE].missileMdl ));
+}
+
+//---------------------------------------------------------
+static void WP_RemoveOldTraps( gentity_t *ent )
+//---------------------------------------------------------
+{
+	gentity_t	*found = NULL;
+	int			trapcount = 0, i;
+	int			foundLaserTraps[MAX_GENTITIES] = {ENTITYNUM_NONE};
+	int			trapcount_org, lowestTimeStamp;
+	int			removeMe;
+
+	// see how many there are now
+	while (( found = G_Find( found, FOFS(classname), "tripmine" )) != NULL )
+	{
+		if ( found->activator != ent ) // activator is really the owner?
+		{
+			continue;
+		}
+		foundLaserTraps[trapcount++] = found->s.number;
+	}
+
+	// now remove first ones we find until there are only 9 left
+	found = NULL;
+	trapcount_org = trapcount;
+	lowestTimeStamp = level.time;
+
+	while ( trapcount > 9 )
+	{
+		removeMe = -1;
+		for ( i = 0; i < trapcount_org; i++ )
+		{
+			if ( foundLaserTraps[i] == ENTITYNUM_NONE )
+			{
+				continue;
+			}
+			found = &g_entities[foundLaserTraps[i]];
+			if ( found->setTime < lowestTimeStamp )
+			{
+				removeMe = i;
+				lowestTimeStamp = found->setTime;
+			}
+		}
+		if ( removeMe != -1 )
+		{
+			//remove it... or blow it?
+			if ( &g_entities[foundLaserTraps[removeMe]] == NULL )
+			{
+				break;
+			}
+			else
+			{
+				G_FreeEntity( &g_entities[foundLaserTraps[removeMe]] );
+			}
+			foundLaserTraps[removeMe] = ENTITYNUM_NONE;
+			trapcount--;
+		}
+		else
+		{
+			break;
+		}
+	}
+}
+
+//---------------------------------------------------------
+void WP_PlaceLaserTrap( gentity_t *ent, qboolean alt_fire )
+//---------------------------------------------------------
+{
+	vec3_t		start;
+	gentity_t	*laserTrap;
+
+	// limit to 10 placed at any one time
+	WP_RemoveOldTraps( ent );
+
+	//FIXME: surface must be within 64
+	laserTrap = G_Spawn();
+
+	if ( laserTrap )
+	{
+		// now make the new one
+		VectorCopy( muzzle, start );
+		WP_TraceSetStart( ent, start, vec3_origin, vec3_origin );//make sure our start point isn't on the other side of a wall
+
+		CreateLaserTrap( laserTrap, start, ent );
+
+		// set player-created-specific fields
+		laserTrap->setTime = level.time;//remember when we placed it
+
+		laserTrap->s.eFlags |= EF_MISSILE_STICK;
+		laserTrap->s.pos.trType = TR_GRAVITY;
+		VectorScale( forward, LT_VELOCITY, laserTrap->s.pos.trDelta );
+
+		if ( alt_fire )
+		{
+			laserTrap->count = PROXIMITY_STYLE;
+			laserTrap->delay = level.time + 40000; // will auto-blow in 40 seconds.
+			laserTrap->methodOfDeath = MOD_LASERTRIP_ALT;
+			laserTrap->splashMethodOfDeath = MOD_LASERTRIP_ALT;//? SPLASH;
+		}
+		else
+		{
+			laserTrap->count = TRIPWIRE_STYLE;
+		}
+	}
+}
+
+
+//---------------------
+//	Thermal Detonator
+//---------------------
+
+//---------------------------------------------------------
+void thermalDetonatorExplode( gentity_t *ent )
+//---------------------------------------------------------
+{
+	if ( (ent->s.eFlags&EF_HELD_BY_SAND_CREATURE) )
+	{
+		ent->takedamage = qfalse; // don't allow double deaths!
+
+		G_Damage( ent->activator, ent, ent->owner, vec3_origin, ent->currentOrigin, TD_ALT_DAMAGE, 0, MOD_EXPLOSIVE );
+		G_PlayEffect( "thermal/explosion", ent->currentOrigin );
+		G_PlayEffect( "thermal/shockwave", ent->currentOrigin );
+
+		G_FreeEntity( ent );
+	}
+	else if ( !ent->count )
+	{
+		G_Sound( ent, G_SoundIndex( "sound/weapons/thermal/warning.wav" ) );
+		ent->count = 1;
+		ent->nextthink = level.time + 800;
+		ent->svFlags |= SVF_BROADCAST;//so everyone hears/sees the explosion?
+	}
+	else
+	{
+		vec3_t	pos;
+
+		VectorSet( pos, ent->currentOrigin[0], ent->currentOrigin[1], ent->currentOrigin[2] + 8 );
+
+		ent->takedamage = qfalse; // don't allow double deaths!
+
+		G_RadiusDamage( ent->currentOrigin, ent->owner, TD_SPLASH_DAM, TD_SPLASH_RAD, NULL, MOD_EXPLOSIVE_SPLASH );
+
+		G_PlayEffect( "thermal/explosion", ent->currentOrigin );
+		G_PlayEffect( "thermal/shockwave", ent->currentOrigin );
+
+		G_FreeEntity( ent );
+	}
+}
+
+//-------------------------------------------------------------------------------------------------------------
+void thermal_die( gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int mod, int dFlags, int hitLoc )
+//-------------------------------------------------------------------------------------------------------------
+{
+	thermalDetonatorExplode( self );
+}
+
+//---------------------------------------------------------
+qboolean WP_LobFire( gentity_t *self, vec3_t start, vec3_t target, vec3_t mins, vec3_t maxs, int clipmask, 
+				vec3_t velocity, qboolean tracePath, int ignoreEntNum, int enemyNum,
+				float minSpeed = 0, float maxSpeed = 0, float idealSpeed = 0, qboolean mustHit = qfalse )
+//---------------------------------------------------------
+{
+	float	targetDist, shotSpeed, speedInc = 100, travelTime, impactDist, bestImpactDist = Q3_INFINITE;//fireSpeed, 
+	vec3_t	targetDir, shotVel, failCase; 
+	trace_t	trace;
+	trajectory_t	tr;
+	qboolean	blocked;
+	int		elapsedTime, skipNum, timeStep = 500, hitCount = 0, maxHits = 7;
+	vec3_t	lastPos, testPos;
+	gentity_t	*traceEnt;
+	
+	if ( !idealSpeed )
+	{
+		idealSpeed = 300;
+	}
+	else if ( idealSpeed < speedInc )
+	{
+		idealSpeed = speedInc;
+	}
+	shotSpeed = idealSpeed;
+	skipNum = (idealSpeed-speedInc)/speedInc;
+	if ( !minSpeed )
+	{
+		minSpeed = 100;
+	}
+	if ( !maxSpeed )
+	{
+		maxSpeed = 900;
+	}
+	while ( hitCount < maxHits )
+	{
+		VectorSubtract( target, start, targetDir );
+		targetDist = VectorNormalize( targetDir );
+
+		VectorScale( targetDir, shotSpeed, shotVel );
+		travelTime = targetDist/shotSpeed;
+		shotVel[2] += travelTime * 0.5 * g_gravity->value;
+
+		if ( !hitCount )		
+		{//save the first (ideal) one as the failCase (fallback value)
+			if ( !mustHit )
+			{//default is fine as a return value
+				VectorCopy( shotVel, failCase );
+			}
+		}
+
+		if ( tracePath )
+		{//do a rough trace of the path
+			blocked = qfalse;
+
+			VectorCopy( start, tr.trBase );
+			VectorCopy( shotVel, tr.trDelta );
+			tr.trType = TR_GRAVITY;
+			tr.trTime = level.time;
+			travelTime *= 1000.0f;
+			VectorCopy( start, lastPos );
+			
+			//This may be kind of wasteful, especially on long throws... use larger steps?  Divide the travelTime into a certain hard number of slices?  Trace just to apex and down?
+			for ( elapsedTime = timeStep; elapsedTime < floor(travelTime)+timeStep; elapsedTime += timeStep )
+			{
+				if ( (float)elapsedTime > travelTime )
+				{//cap it
+					elapsedTime = floor( travelTime );
+				}
+				EvaluateTrajectory( &tr, level.time + elapsedTime, testPos );
+				gi.trace( &trace, lastPos, mins, maxs, testPos, ignoreEntNum, clipmask );
+
+				if ( trace.allsolid || trace.startsolid )
+				{
+					blocked = qtrue;
+					break;
+				}
+				if ( trace.fraction < 1.0f )
+				{//hit something
+					if ( trace.entityNum == enemyNum )
+					{//hit the enemy, that's perfect!
+						break;
+					}
+					else if ( trace.plane.normal[2] > 0.7 && DistanceSquared( trace.endpos, target ) < 4096 )//hit within 64 of desired location, should be okay
+					{//close enough!
+						break;
+					}
+					else
+					{//FIXME: maybe find the extents of this brush and go above or below it on next try somehow?
+						impactDist = DistanceSquared( trace.endpos, target );
+						if ( impactDist < bestImpactDist )
+						{
+							bestImpactDist = impactDist;
+							VectorCopy( shotVel, failCase );
+						}
+						blocked = qtrue;
+						//see if we should store this as the failCase
+						if ( trace.entityNum < ENTITYNUM_WORLD )
+						{//hit an ent
+							traceEnt = &g_entities[trace.entityNum];
+							if ( traceEnt && traceEnt->takedamage && !OnSameTeam( self, traceEnt ) )
+							{//hit something breakable, so that's okay
+								//we haven't found a clear shot yet so use this as the failcase
+								VectorCopy( shotVel, failCase );
+							}
+						}
+						break;
+					}
+				}
+				if ( elapsedTime == floor( travelTime ) )
+				{//reached end, all clear
+					break;
+				}
+				else
+				{
+					//all clear, try next slice
+					VectorCopy( testPos, lastPos );
+				}
+			}
+			if ( blocked )
+			{//hit something, adjust speed (which will change arc)
+				hitCount++;
+				shotSpeed = idealSpeed + ((hitCount-skipNum) * speedInc);//from min to max (skipping ideal)
+				if ( hitCount >= skipNum )
+				{//skip ideal since that was the first value we tested
+					shotSpeed += speedInc;
+				}
+			}
+			else
+			{//made it!
+				break;
+			}
+		}
+		else
+		{//no need to check the path, go with first calc
+			break;
+		}
+	}
+
+	if ( hitCount >= maxHits )
+	{//NOTE: worst case scenario, use the one that impacted closest to the target (or just use the first try...?)
+		VectorCopy( failCase, velocity );
+		return qfalse;
+	}
+	VectorCopy( shotVel, velocity );
+	return qtrue;
+}
+
+//---------------------------------------------------------
+void WP_ThermalThink( gentity_t *ent )
+//---------------------------------------------------------
+{
+	int			count;
+	qboolean	blow = qfalse;
+
+	// Thermal detonators for the player do occasional radius checks and blow up if there are entities in the blast radius
+	//	This is done so that the main fire is actually useful as an attack.  We explode anyway after delay expires.
+
+	if ( (ent->s.eFlags&EF_HELD_BY_SAND_CREATURE) )
+	{//blow once creature is underground (done with anim)
+		//FIXME: chance of being spit out?  Especially if lots of delay left...
+		ent->e_TouchFunc = NULL;//don't impact on anything
+		if ( !ent->activator 
+			|| !ent->activator->client
+			|| !ent->activator->client->ps.legsAnimTimer )
+		{//either something happened to the sand creature or it's done with it's attack anim
+			//blow!
+			ent->e_ThinkFunc = thinkF_thermalDetonatorExplode;
+			ent->nextthink = level.time + Q_irand( 50, 2000 );
+		}
+		else
+		{//keep checking
+			ent->nextthink = level.time + TD_THINK_TIME;
+		}
+		return;
+	}
+	else if ( ent->delay > level.time )
+	{
+		//	Finally, we force it to bounce at least once before doing the special checks, otherwise it's just too easy for the player?
+		if ( ent->has_bounced )
+		{
+			count = G_RadiusList( ent->currentOrigin, TD_TEST_RAD, ent, qtrue, ent_list );
+
+			for ( int i = 0; i < count; i++ )
+			{
+				if ( ent_list[i]->s.number == 0 )
+				{
+					// avoid deliberately blowing up next to the player, no matter how close any enemy is..
+					//	...if the delay time expires though, there is no saving the player...muwhaaa haa ha
+					blow = qfalse;
+					break;
+				}
+				else if ( ent_list[i]->client 
+					&& ent_list[i]->client->NPC_class != CLASS_SAND_CREATURE//ignore sand creatures
+					&& ent_list[i]->health > 0 )
+				{
+					//FIXME! sometimes the ent_list order changes, so we should make sure that the player isn't anywhere in this list
+					blow = qtrue;
+				}
+			}
+		}
+	}
+	else
+	{
+		// our death time has arrived, even if nothing is near us
+		blow = qtrue;
+	}
+
+	if ( blow )
+	{
+		ent->e_ThinkFunc = thinkF_thermalDetonatorExplode;
+		ent->nextthink = level.time + 50;
+	}
+	else
+	{
+		// we probably don't need to do this thinking logic very often...maybe this is fast enough?
+		ent->nextthink = level.time + TD_THINK_TIME;
+	}
+}
+
+//---------------------------------------------------------
+gentity_t *WP_FireThermalDetonator( gentity_t *ent, qboolean alt_fire )
+//---------------------------------------------------------
+{
+	gentity_t	*bolt;
+	vec3_t		dir, start;
+	float		damageScale = 1.0f;
+
+	VectorCopy( forward, dir );
+	VectorCopy( muzzle, start );
+
+	bolt = G_Spawn();
+	
+	bolt->classname = "thermal_detonator";
+
+	if ( ent->s.number != 0 )
+	{
+		// If not the player, cut the damage a bit so we don't get pounded on so much
+		damageScale = TD_NPC_DAMAGE_CUT;
+	}
+
+	if ( !alt_fire && ent->s.number == 0 )
+	{
+		// Main fires for the players do a little bit of extra thinking
+		bolt->e_ThinkFunc = thinkF_WP_ThermalThink;
+		bolt->nextthink = level.time + TD_THINK_TIME;
+		bolt->delay = level.time + TD_TIME; // How long 'til she blows
+	}
+	else
+	{
+		bolt->e_ThinkFunc = thinkF_thermalDetonatorExplode;
+		bolt->nextthink = level.time + TD_TIME; // How long 'til she blows
+	}
+
+	bolt->mass = 10;
+
+	// How 'bout we give this thing a size...
+	VectorSet( bolt->mins, -4.0f, -4.0f, -4.0f );
+	VectorSet( bolt->maxs, 4.0f, 4.0f, 4.0f );
+	bolt->clipmask = MASK_SHOT;
+	bolt->clipmask &= ~CONTENTS_CORPSE;
+	bolt->contents = CONTENTS_SHOTCLIP;
+	bolt->takedamage = qtrue;
+	bolt->health = 15;
+	bolt->e_DieFunc = dieF_thermal_die;
+
+	WP_TraceSetStart( ent, start, bolt->mins, bolt->maxs );//make sure our start point isn't on the other side of a wall
+
+	float chargeAmount = 1.0f; // default of full charge
+	
+	if ( ent->client )
+	{
+		chargeAmount = level.time - ent->client->ps.weaponChargeTime;
+	}
+
+	// get charge amount
+	chargeAmount = chargeAmount / (float)TD_VELOCITY;
+
+	if ( chargeAmount > 1.0f )
+	{
+		chargeAmount = 1.0f;
+	}
+	else if ( chargeAmount < TD_MIN_CHARGE )
+	{
+		chargeAmount = TD_MIN_CHARGE;
+	}
+
+	float	thrownSpeed = TD_VELOCITY;
+	const qboolean thisIsAShooter = !Q_stricmp( "misc_weapon_shooter", ent->classname);
+
+	if (thisIsAShooter)
+	{
+		if (ent->delay != 0)
+		{
+			thrownSpeed = ent->delay;
+		}
+	}
+
+	// normal ones bounce, alt ones explode on impact
+	bolt->s.pos.trType = TR_GRAVITY;
+	bolt->owner = ent;
+	VectorScale( dir, thrownSpeed * chargeAmount, bolt->s.pos.trDelta );
+
+	if ( ent->health > 0 )
+	{
+		bolt->s.pos.trDelta[2] += 120;
+
+		if ( (ent->NPC || (ent->s.number && thisIsAShooter) )
+			&& ent->enemy )
+		{//NPC or misc_weapon_shooter
+			//FIXME: we're assuming he's actually facing this direction...
+			vec3_t	target;
+			
+			VectorCopy( ent->enemy->currentOrigin, target );
+			if ( target[2] <= start[2] )
+			{
+				vec3_t	vec;
+				VectorSubtract( target, start, vec );
+				VectorNormalize( vec );
+				VectorMA( target, Q_flrand( 0, -32 ), vec, target );//throw a little short
+			}
+
+			target[0] += Q_flrand( -5, 5 )+(crandom()*(6-ent->NPC->currentAim)*2);
+			target[1] += Q_flrand( -5, 5 )+(crandom()*(6-ent->NPC->currentAim)*2);
+			target[2] += Q_flrand( -5, 5 )+(crandom()*(6-ent->NPC->currentAim)*2);
+
+			WP_LobFire( ent, start, target, bolt->mins, bolt->maxs, bolt->clipmask, bolt->s.pos.trDelta, qtrue, ent->s.number, ent->enemy->s.number );
+		}
+		else if ( thisIsAShooter && ent->target && !VectorCompare( ent->pos1, vec3_origin ) )
+		{//misc_weapon_shooter firing at a position
+			WP_LobFire( ent, start, ent->pos1, bolt->mins, bolt->maxs, bolt->clipmask, bolt->s.pos.trDelta, qtrue, ent->s.number, ent->enemy->s.number );
+		}
+	}
+
+	if ( alt_fire )
+	{
+		bolt->alt_fire = qtrue;
+	}
+	else
+	{
+		bolt->s.eFlags |= EF_BOUNCE_HALF;
+	}
+
+	bolt->s.loopSound = G_SoundIndex( "sound/weapons/thermal/thermloop.wav" );
+
+	bolt->damage = TD_DAMAGE * damageScale;
+	bolt->dflags = 0;
+	bolt->splashDamage = TD_SPLASH_DAM * damageScale;
+	bolt->splashRadius = TD_SPLASH_RAD;
+
+	bolt->s.eType = ET_MISSILE;
+	bolt->svFlags = SVF_USE_CURRENT_ORIGIN;
+	bolt->s.weapon = WP_THERMAL;
+
+	if ( alt_fire )
+	{
+		bolt->methodOfDeath = MOD_THERMAL_ALT;
+		bolt->splashMethodOfDeath = MOD_THERMAL_ALT;//? SPLASH;
+	}
+	else
+	{
+		bolt->methodOfDeath = MOD_THERMAL;
+		bolt->splashMethodOfDeath = MOD_THERMAL;//? SPLASH;
+	}
+
+	bolt->s.pos.trTime = level.time;		// move a bit on the very first frame
+	VectorCopy( start, bolt->s.pos.trBase );
+	
+	SnapVector( bolt->s.pos.trDelta );			// save net bandwidth
+	VectorCopy (start, bolt->currentOrigin);
+
+	VectorCopy( start, bolt->pos2 );
+
+	return bolt;
+}
+
+//---------------------------------------------------------
+gentity_t *WP_DropThermal( gentity_t *ent )
+//---------------------------------------------------------
+{
+	AngleVectors( ent->client->ps.viewangles, forward, vright, up );
+	CalcEntitySpot( ent, SPOT_WEAPON, muzzle );
+	return (WP_FireThermalDetonator( ent, qfalse ));
+}
+
+
+//	Bot Laser
+//---------------------------------------------------------
+void WP_BotLaser( gentity_t *ent )
+//---------------------------------------------------------
+{
+	gentity_t	*missile = CreateMissile( muzzle, forward, BRYAR_PISTOL_VEL, 10000, ent );
+
+	missile->classname = "bryar_proj";
+	missile->s.weapon = WP_BRYAR_PISTOL;
+
+	missile->damage = BRYAR_PISTOL_DAMAGE;
+	missile->dflags = DAMAGE_DEATH_KNOCKBACK;
+	missile->methodOfDeath = MOD_ENERGY;
+	missile->clipmask = MASK_SHOT | CONTENTS_LIGHTSABER;
+}
+
+
+// Emplaced Gun
+//---------------------------------------------------------
+void WP_EmplacedFire( gentity_t *ent )
+//---------------------------------------------------------
+{
+	float damage = EMPLACED_DAMAGE * ( ent->NPC ? 0.1f : 1.0f );
+	float vel = EMPLACED_VEL * ( ent->NPC ? 0.4f : 1.0f );
+
+	WP_MissileTargetHint(ent, muzzle, forward);
+
+	gentity_t	*missile = CreateMissile( muzzle, forward, vel, 10000, ent );
+
+	missile->classname = "emplaced_proj";
+	missile->s.weapon = WP_EMPLACED_GUN;
+
+	missile->damage = damage; 
+	missile->dflags = DAMAGE_DEATH_KNOCKBACK | DAMAGE_HEAVY_WEAP_CLASS;
+	missile->methodOfDeath = MOD_EMPLACED;
+	missile->clipmask = MASK_SHOT | CONTENTS_LIGHTSABER;
+
+	// do some weird switchery on who the real owner is, we do this so the projectiles don't hit the gun object
+	if ( ent && ent->client && !(ent->client->ps.eFlags&EF_LOCKED_TO_WEAPON) )
+	{
+		missile->owner = ent;
+	}
+	else
+	{
+		missile->owner = ent->owner;
+	}
+
+	if ( missile->owner->e_UseFunc == useF_eweb_use )
+	{
+		missile->alt_fire = qtrue;
+	}
+
+	VectorSet( missile->maxs, EMPLACED_SIZE, EMPLACED_SIZE, EMPLACED_SIZE );
+	VectorScale( missile->maxs, -1, missile->mins );
+
+	// alternate muzzles
+	ent->fxID = !ent->fxID;
+}
+
+// ATST Main
+//---------------------------------------------------------
+void WP_ATSTMainFire( gentity_t *ent )
+//---------------------------------------------------------
+{
+	float vel = ATST_MAIN_VEL;
+
+//	if ( ent->client && (ent->client->ps.eFlags & EF_IN_ATST ))
+//	{
+//		vel = 4500.0f;
+//	}
+
+	if ( !ent->s.number )
+	{
+		// player shoots faster
+		vel *= 1.6f;
+	}
+
+	WP_MissileTargetHint(ent, muzzle, forward);
+
+	gentity_t	*missile = CreateMissile( muzzle, forward, vel, 10000, ent );
+
+	missile->classname = "atst_main_proj";
+	missile->s.weapon = WP_ATST_MAIN;
+
+	missile->damage = ATST_MAIN_DAMAGE;
+	missile->dflags = DAMAGE_DEATH_KNOCKBACK|DAMAGE_HEAVY_WEAP_CLASS;
+	missile->methodOfDeath = MOD_ENERGY;
+	missile->clipmask = MASK_SHOT | CONTENTS_LIGHTSABER;
+
+	missile->owner = ent;
+
+	VectorSet( missile->maxs, ATST_MAIN_SIZE, ATST_MAIN_SIZE, ATST_MAIN_SIZE );
+	VectorScale( missile->maxs, -1, missile->mins );
+
+}
+
+// ATST Alt Side
+//---------------------------------------------------------
+void WP_ATSTSideAltFire( gentity_t *ent )
+//---------------------------------------------------------
+{
+	int	damage	= ATST_SIDE_ALT_DAMAGE;
+	float	vel = ATST_SIDE_ALT_NPC_VELOCITY;
+
+	if ( ent->client && (ent->client->ps.eFlags & EF_IN_ATST ))
+	{
+		vel = ATST_SIDE_ALT_VELOCITY;
+	}
+
+	gentity_t *missile = CreateMissile( muzzle, forward, vel, 10000, ent, qtrue );
+
+	missile->classname = "atst_rocket";
+	missile->s.weapon = WP_ATST_SIDE;
+
+	missile->mass = 10;
+
+	// Do the damages
+	if ( ent->s.number != 0 )
+	{
+		if ( g_spskill->integer == 0 )
+		{
+			damage = ATST_SIDE_ROCKET_NPC_DAMAGE_EASY;
+		}
+		else if ( g_spskill->integer == 1 )
+		{
+			damage = ATST_SIDE_ROCKET_NPC_DAMAGE_NORMAL;
+		}
+		else
+		{
+			damage = ATST_SIDE_ROCKET_NPC_DAMAGE_HARD;
+		}
+	}
+
+	VectorCopy( forward, missile->movedir );
+
+	// Make it easier to hit things
+	VectorSet( missile->maxs, ATST_SIDE_ALT_ROCKET_SIZE, ATST_SIDE_ALT_ROCKET_SIZE, ATST_SIDE_ALT_ROCKET_SIZE );
+	VectorScale( missile->maxs, -1, missile->mins );
+
+	missile->damage = damage;
+	missile->dflags = DAMAGE_DEATH_KNOCKBACK | DAMAGE_HEAVY_WEAP_CLASS;
+	missile->methodOfDeath = MOD_EXPLOSIVE;
+	missile->splashMethodOfDeath = MOD_EXPLOSIVE_SPLASH;
+	missile->clipmask = MASK_SHOT | CONTENTS_LIGHTSABER;
+
+	// Scale damage down a bit if it is coming from an NPC
+	missile->splashDamage = ATST_SIDE_ALT_SPLASH_DAMAGE * ( ent->s.number == 0 ? 1.0f : ATST_SIDE_ALT_ROCKET_SPLASH_SCALE );
+	missile->splashRadius = ATST_SIDE_ALT_SPLASH_RADIUS;
+
+	// we don't want it to ever bounce
+	missile->bounceCount = 0;
+}
+
+// ATST Side
+//---------------------------------------------------------
+void WP_ATSTSideFire( gentity_t *ent )
+//---------------------------------------------------------
+{
+	int	damage	= ATST_SIDE_MAIN_DAMAGE;
+
+	gentity_t *missile = CreateMissile( muzzle, forward, ATST_SIDE_MAIN_VELOCITY, 10000, ent, qfalse );
+
+	missile->classname = "atst_side_proj";
+	missile->s.weapon = WP_ATST_SIDE;
+
+	// Do the damages
+	if ( ent->s.number != 0 )
+	{
+		if ( g_spskill->integer == 0 )
+		{
+			damage = ATST_SIDE_MAIN_NPC_DAMAGE_EASY;
+		}
+		else if ( g_spskill->integer == 1 )
+		{
+			damage = ATST_SIDE_MAIN_NPC_DAMAGE_NORMAL;
+		}
+		else
+		{
+			damage = ATST_SIDE_MAIN_NPC_DAMAGE_HARD;
+		}
+	}
+
+	VectorSet( missile->maxs, ATST_SIDE_MAIN_SIZE, ATST_SIDE_MAIN_SIZE, ATST_SIDE_MAIN_SIZE );
+	VectorScale( missile->maxs, -1, missile->mins );
+
+	missile->damage = damage;
+	missile->dflags = DAMAGE_DEATH_KNOCKBACK|DAMAGE_HEAVY_WEAP_CLASS;
+	missile->methodOfDeath = MOD_ENERGY;
+	missile->clipmask = MASK_SHOT | CONTENTS_LIGHTSABER;
+
+	missile->splashDamage = ATST_SIDE_MAIN_SPLASH_DAMAGE * ( ent->s.number == 0 ? 1.0f : 0.6f );
+	missile->splashRadius = ATST_SIDE_MAIN_SPLASH_RADIUS;
+
+	// we don't want it to bounce
+	missile->bounceCount = 0;
+}
+
+//---------------------------------------------------------
+void WP_FireStunBaton( gentity_t *ent, qboolean alt_fire )
+{
+	gentity_t	*tr_ent;
+	trace_t		tr;
+	vec3_t		mins, maxs, end, start;
+
+	G_Sound( ent, G_SoundIndex( "sound/weapons/baton/fire" ));
+#ifdef _IMMERSION
+	G_Force( ent, G_ForceIndex( "fffx/weapons/baton/fire", FF_CHANNEL_WEAPON ) );
+#endif // _IMMERSION
+
+	VectorCopy( muzzle, start );
+	WP_TraceSetStart( ent, start, vec3_origin, vec3_origin );
+
+	VectorMA( start, STUN_BATON_RANGE, forward, end );
+
+	VectorSet( maxs, 5, 5, 5 );
+	VectorScale( maxs, -1, mins );
+
+	gi.trace ( &tr, start, mins, maxs, end, ent->s.number, CONTENTS_SOLID|CONTENTS_BODY|CONTENTS_SHOTCLIP );
+
+	if ( tr.entityNum >= ENTITYNUM_WORLD || tr.entityNum < 0 )
+	{
+		return;
+	}
+
+	tr_ent = &g_entities[tr.entityNum];
+
+	if ( tr_ent && tr_ent->takedamage && tr_ent->client )
+	{
+		G_PlayEffect( "stunBaton/flesh_impact", tr.endpos, tr.plane.normal );
+
+		// TEMP!
+//		G_Sound( tr_ent, G_SoundIndex( va("sound/weapons/melee/punch%d", Q_irand(1, 4)) ) );
+		tr_ent->client->ps.powerups[PW_SHOCKED] = level.time + 1500;
+
+		G_Damage( tr_ent, ent, ent, forward, tr.endpos, STUN_BATON_DAMAGE, DAMAGE_NO_KNOCKBACK, MOD_MELEE );
+	}
+	else if ( tr_ent->svFlags & SVF_GLASS_BRUSH || ( tr_ent->svFlags & SVF_BBRUSH && tr_ent->material == 12 )) // material grate...we are breaking a grate!
+	{
+		G_Damage( tr_ent, ent, ent, forward, tr.endpos, 999, DAMAGE_NO_KNOCKBACK, MOD_MELEE ); // smash that puppy
+	}
+}
+
+void WP_Melee( gentity_t *ent )
+//---------------------------------------------------------
+{
+	gentity_t	*tr_ent;
+	trace_t		tr;
+	vec3_t		mins, maxs, end;
+	int			damage = ent->s.number ? (g_spskill->integer*2)+1 : 3;
+	float		range = ent->s.number ? 64 : 32;
+
+	VectorMA( muzzle, range, forward, end );
+
+	VectorSet( maxs, 6, 6, 6 );
+	VectorScale( maxs, -1, mins );
+
+	gi.trace ( &tr, muzzle, mins, maxs, end, ent->s.number, MASK_SHOT );
+
+	if ( tr.entityNum >= ENTITYNUM_WORLD )
+	{
+		return;
+	}
+
+	tr_ent = &g_entities[tr.entityNum];
+
+	if ( ent->client && !PM_DroidMelee( ent->client->NPC_class ) )
+	{
+		if ( ent->s.number || ent->alt_fire )
+		{
+			damage *= Q_irand( 2, 3 );
+		}
+		else
+		{
+			damage *= Q_irand( 1, 2 );
+		}
+	}
+
+	if ( tr_ent && tr_ent->takedamage )
+	{
+		int dflags = DAMAGE_NO_KNOCKBACK;
+		G_PlayEffect( G_EffectIndex( "melee/punch_impact" ), tr.endpos, forward );
+		//G_Sound( tr_ent, G_SoundIndex( va("sound/weapons/melee/punch%d", Q_irand(1, 4)) ) );
+		if ( ent->NPC && (ent->NPC->aiFlags&NPCAI_HEAVY_MELEE) )
+		{ //4x damage for heavy melee class
+			damage *= 4;
+			dflags &= ~DAMAGE_NO_KNOCKBACK;
+			dflags |= DAMAGE_DISMEMBER;
+		}
+
+		G_Damage( tr_ent, ent, ent, forward, tr.endpos, damage, dflags, MOD_MELEE );
+	}
+}
+
+//---------------------------------------------------------
+static void WP_FireTuskenRifle( gentity_t *ent )
+//---------------------------------------------------------
+{
+	vec3_t	start;
+
+	VectorCopy( muzzle, start );
+	WP_TraceSetStart( ent, start, vec3_origin, vec3_origin );//make sure our start point isn't on the other side of a wall
+
+	if ( !(ent->client->ps.forcePowersActive&(1<<FP_SEE))
+		|| ent->client->ps.forcePowerLevel[FP_SEE] < FORCE_LEVEL_2 )
+	{//force sight 2+ gives perfect aim
+		//FIXME: maybe force sight level 3 autoaims some?
+		if ( ent->NPC && ent->NPC->currentAim < 5 )
+		{
+			vec3_t	angs;
+
+			vectoangles( forward, angs );
+
+			if ( ent->client->NPC_class == CLASS_IMPWORKER )
+			{//*sigh*, hack to make impworkers less accurate without affecteing imperial officer accuracy
+				angs[PITCH] += ( crandom() * (BLASTER_NPC_SPREAD+(6-ent->NPC->currentAim)*0.25f));//was 0.5f
+				angs[YAW]	+= ( crandom() * (BLASTER_NPC_SPREAD+(6-ent->NPC->currentAim)*0.25f));//was 0.5f
+			}
+			else
+			{
+				angs[PITCH] += ( crandom() * ((5-ent->NPC->currentAim)*0.25f) );
+				angs[YAW]	+= ( crandom() * ((5-ent->NPC->currentAim)*0.25f) );
+			}
+
+			AngleVectors( angs, forward, NULL, NULL );
+		}
+	}
+
+	WP_MissileTargetHint(ent, start, forward);
+
+	gentity_t	*missile = CreateMissile( start, forward, TUSKEN_RIFLE_VEL, 10000, ent, qfalse );
+
+	missile->classname = "trifle_proj";
+	missile->s.weapon = WP_TUSKEN_RIFLE;
+
+	if ( ent->s.number < MAX_CLIENTS || g_spskill->integer >= 2 )
+	{
+		missile->damage = TUSKEN_RIFLE_DAMAGE_HARD;
+	}
+	else if ( g_spskill->integer > 0 )
+	{
+		missile->damage = TUSKEN_RIFLE_DAMAGE_MEDIUM;
+	}
+	else
+	{
+		missile->damage = TUSKEN_RIFLE_DAMAGE_EASY;
+	}
+	missile->dflags = DAMAGE_DEATH_KNOCKBACK;
+
+	missile->methodOfDeath = MOD_BRYAR;//???
+
+	missile->clipmask = MASK_SHOT | CONTENTS_LIGHTSABER;
+
+	// we don't want it to bounce forever
+	missile->bounceCount = 8;
+}
+
+//---------------------------------------------------------
+static void WP_FireNoghriStick( gentity_t *ent )
+//---------------------------------------------------------
+{
+	vec3_t	dir, angs;
+
+	vectoangles( forward, angs );
+
+	if ( !(ent->client->ps.forcePowersActive&(1<<FP_SEE))
+		|| ent->client->ps.forcePowerLevel[FP_SEE] < FORCE_LEVEL_2 )
+	{//force sight 2+ gives perfect aim
+		//FIXME: maybe force sight level 3 autoaims some?
+		// add some slop to the main-fire direction
+		angs[PITCH] += ( crandom() * (BLASTER_NPC_SPREAD+(6-ent->NPC->currentAim)*0.25f));//was 0.5f
+		angs[YAW]	+= ( crandom() * (BLASTER_NPC_SPREAD+(6-ent->NPC->currentAim)*0.25f));//was 0.5f
+	}
+
+	AngleVectors( angs, dir, NULL, NULL );
+
+	// FIXME: if temp_org does not have clear trace to inside the bbox, don't shoot!
+	int velocity	= 1200;
+
+	WP_TraceSetStart( ent, muzzle, vec3_origin, vec3_origin );//make sure our start point isn't on the other side of a wall
+
+	WP_MissileTargetHint(ent, muzzle, dir);
+
+	gentity_t *missile = CreateMissile( muzzle, dir, velocity, 10000, ent, qfalse );
+
+	missile->classname = "noghri_proj";
+	missile->s.weapon = WP_NOGHRI_STICK;
+
+	// Do the damages
+	if ( ent->s.number != 0 )
+	{
+		if ( g_spskill->integer == 0 )
+		{
+			missile->damage = 1;
+		}
+		else if ( g_spskill->integer == 1 )
+		{
+			missile->damage = 5;
+		}
+		else
+		{
+			missile->damage = 10;
+		}
+	}
+
+//	if ( ent->client )
+//	{
+//		if ( ent->client->ps.powerups[PW_WEAPON_OVERCHARGE] > 0 && ent->client->ps.powerups[PW_WEAPON_OVERCHARGE] > cg.time )
+//		{
+//			// in overcharge mode, so doing double damage
+//			missile->flags |= FL_OVERCHARGED;
+//			damage *= 2;
+//		}
+//	}
+
+	missile->dflags = DAMAGE_NO_KNOCKBACK;
+	missile->methodOfDeath = MOD_BLASTER;
+	missile->clipmask = MASK_SHOT | CONTENTS_LIGHTSABER;
+	missile->splashDamage = 0;
+	missile->splashRadius = 100;
+	missile->splashMethodOfDeath = MOD_GAS;
+	
+	//Hmm: maybe spew gas on impact?
+}
+
+//---------------------------------------------------------
+void AddLeanOfs(const gentity_t *const ent, vec3_t point)
+//---------------------------------------------------------
+{
+	if(ent->client)
+	{
+		if(ent->client->ps.leanofs)
+		{
+			vec3_t	right;
+			//add leaning offset
+			AngleVectors(ent->client->ps.viewangles, NULL, right, NULL);
+			VectorMA(point, (float)ent->client->ps.leanofs, right, point);
+		}
+	}
+}
+
+//---------------------------------------------------------
+void SubtractLeanOfs(const gentity_t *const ent, vec3_t point)
+//---------------------------------------------------------
+{
+	if(ent->client)
+	{
+		if(ent->client->ps.leanofs)
+		{
+			vec3_t	right;
+			//add leaning offset
+			AngleVectors( ent->client->ps.viewangles, NULL, right, NULL );
+			VectorMA( point, ent->client->ps.leanofs*-1, right, point );
+		}
+	}
+}
+
+//---------------------------------------------------------
+void ViewHeightFix(const gentity_t *const ent)
+//---------------------------------------------------------
+{
+	//FIXME: this is hacky and doesn't need to be here.  Was only put here to make up
+	//for the times a crouch anim would be used but not actually crouching.
+	//When we start calcing eyepos (SPOT_HEAD) from the tag_eyes, we won't need
+	//this (or viewheight at all?)
+	if ( !ent )
+		return;
+
+	if ( !ent->client || !ent->NPC )
+		return;
+
+	if ( ent->client->ps.stats[STAT_HEALTH] <= 0 )
+		return;//dead
+
+	if ( ent->client->ps.legsAnim == BOTH_CROUCH1IDLE || ent->client->ps.legsAnim == BOTH_CROUCH1 || ent->client->ps.legsAnim == BOTH_CROUCH1WALK )
+	{
+		if ( ent->client->ps.viewheight!=ent->client->crouchheight + STANDARD_VIEWHEIGHT_OFFSET )
+			ent->client->ps.viewheight = ent->client->crouchheight + STANDARD_VIEWHEIGHT_OFFSET;
+	}
+	else
+	{
+		if ( ent->client->ps.viewheight!=ent->client->standheight + STANDARD_VIEWHEIGHT_OFFSET )
+			ent->client->ps.viewheight = ent->client->standheight + STANDARD_VIEWHEIGHT_OFFSET;
+	}
+}
+
+qboolean W_AccuracyLoggableWeapon( int weapon, qboolean alt_fire, int mod )
+{
+	if ( mod != MOD_UNKNOWN )
+	{
+		switch( mod ) 
+		{
+		//standard weapons
+		case MOD_BRYAR:
+		case MOD_BRYAR_ALT:
+		case MOD_BLASTER:
+		case MOD_BLASTER_ALT:
+		case MOD_DISRUPTOR:
+		case MOD_SNIPER:
+		case MOD_BOWCASTER:
+		case MOD_BOWCASTER_ALT:
+		case MOD_ROCKET:
+		case MOD_ROCKET_ALT:
+		case MOD_CONC:
+		case MOD_CONC_ALT:
+			return qtrue;
+			break;
+		//non-alt standard
+		case MOD_REPEATER:
+		case MOD_DEMP2:
+		case MOD_FLECHETTE:
+			return qtrue;
+			break;
+		//emplaced gun
+		case MOD_EMPLACED:
+			return qtrue;
+			break;
+		//atst
+		case MOD_ENERGY:
+		case MOD_EXPLOSIVE:
+			if ( weapon == WP_ATST_MAIN || weapon == WP_ATST_SIDE )
+			{
+				return qtrue;
+			}
+			break;
+		}
+	}
+	else if ( weapon != WP_NONE )
+	{	
+		switch( weapon ) 
+		{
+		case WP_BRYAR_PISTOL:
+		case WP_BLASTER_PISTOL:
+		case WP_BLASTER:
+		case WP_DISRUPTOR:
+		case WP_BOWCASTER:
+		case WP_ROCKET_LAUNCHER:
+		case WP_CONCUSSION:
+			return qtrue;
+			break;
+		//non-alt standard
+		case WP_REPEATER:
+		case WP_DEMP2:
+		case WP_FLECHETTE:
+			if ( !alt_fire )
+			{
+				return qtrue;
+			}
+			break;
+		//emplaced gun
+		case WP_EMPLACED_GUN:
+			return qtrue;
+			break;
+		//atst
+		case WP_ATST_MAIN:
+		case WP_ATST_SIDE:
+			return qtrue;
+			break;
+		}
+	}
+	return qfalse;
+}
+
+/*
+===============
+LogAccuracyHit
+===============
+*/
+qboolean LogAccuracyHit( gentity_t *target, gentity_t *attacker ) {
+	if( !target->takedamage ) {
+		return qfalse;
+	}
+
+	if ( target == attacker ) {
+		return qfalse;
+	}
+
+	if( !target->client ) {
+		return qfalse;
+	}
+
+	if( !attacker->client ) {
+		return qfalse;
+	}
+
+	if( target->client->ps.stats[STAT_HEALTH] <= 0 ) {
+		return qfalse;
+	}
+
+	if ( OnSameTeam( target, attacker ) ) {
+		return qfalse;
+	}
+
+	return qtrue;
+}
+
+//---------------------------------------------------------
+void CalcMuzzlePoint( gentity_t *const ent, vec3_t forward, vec3_t right, vec3_t up, vec3_t muzzlePoint, float lead_in ) 
+//---------------------------------------------------------
+{
+	vec3_t		org;
+	mdxaBone_t	boltMatrix;
+
+	if( !lead_in ) //&& ent->s.number != 0 
+	{//Not players or melee
+		if( ent->client )
+		{
+			if ( ent->client->renderInfo.mPCalcTime >= level.time - FRAMETIME*2 )
+			{//Our muzz point was calced no more than 2 frames ago
+				VectorCopy(ent->client->renderInfo.muzzlePoint, muzzlePoint);
+				return;
+			}
+		}
+	}
+
+	VectorCopy( ent->currentOrigin, muzzlePoint );
+	
+	switch( ent->s.weapon )
+	{
+	case WP_BRYAR_PISTOL:
+	case WP_BLASTER_PISTOL:
+		ViewHeightFix(ent);
+		muzzlePoint[2] += ent->client->ps.viewheight;//By eyes
+		muzzlePoint[2] -= 16;
+		VectorMA( muzzlePoint, 28, forward, muzzlePoint );
+		VectorMA( muzzlePoint, 6, vright, muzzlePoint );
+		break;
+
+	case WP_ROCKET_LAUNCHER:
+	case WP_CONCUSSION:
+	case WP_THERMAL:
+		ViewHeightFix(ent);
+		muzzlePoint[2] += ent->client->ps.viewheight;//By eyes
+		muzzlePoint[2] -= 2;
+		break;
+
+	case WP_BLASTER:
+		ViewHeightFix(ent);
+		muzzlePoint[2] += ent->client->ps.viewheight;//By eyes
+		muzzlePoint[2] -= 1;
+		if ( ent->s.number == 0 )
+			VectorMA( muzzlePoint, 12, forward, muzzlePoint ); // player, don't set this any lower otherwise the projectile will impact immediately when your back is to a wall
+		else
+			VectorMA( muzzlePoint, 2, forward, muzzlePoint ); // NPC, don't set too far forward otherwise the projectile can go through doors
+
+		VectorMA( muzzlePoint, 1, vright, muzzlePoint );
+		break;
+
+	case WP_SABER:
+		if(ent->NPC!=NULL &&
+			(ent->client->ps.torsoAnim == TORSO_WEAPONREADY2 ||
+			ent->client->ps.torsoAnim == BOTH_ATTACK2))//Sniper pose
+		{
+			ViewHeightFix(ent);
+			muzzle[2] += ent->client->ps.viewheight;//By eyes
+		}
+		else
+		{
+			muzzlePoint[2] += 16;
+		}
+		VectorMA( muzzlePoint, 8, forward, muzzlePoint );
+		VectorMA( muzzlePoint, 16, vright, muzzlePoint );
+		break;
+
+	case WP_BOT_LASER:
+		muzzlePoint[2] -= 16;	//
+		break;
+	case WP_ATST_MAIN:
+
+		if (ent->count > 0)
+		{
+			ent->count = 0;
+			gi.G2API_GetBoltMatrix( ent->ghoul2, ent->playerModel, 
+						ent->handLBolt,
+						&boltMatrix, ent->s.angles, ent->s.origin, (cg.time?cg.time:level.time),
+						NULL, ent->s.modelScale );
+		}
+		else
+		{
+			ent->count = 1;
+			gi.G2API_GetBoltMatrix( ent->ghoul2, ent->playerModel, 
+						ent->handRBolt,
+						&boltMatrix, ent->s.angles, ent->s.origin, (cg.time?cg.time:level.time),
+						NULL, ent->s.modelScale );
+		}
+
+		gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, org );
+
+		VectorCopy(org,muzzlePoint);
+
+		break;
+	}
+
+	AddLeanOfs(ent, muzzlePoint);
+}
+
+// Muzzle point table...
+vec3_t WP_MuzzlePoint[WP_NUM_WEAPONS] = 
+{//	Fwd,	right,	up.
+	{0,		0,		0	},	// WP_NONE,
+	{8	,	16,		0	},	// WP_SABER,				 
+	{12,	6,		-6	},	// WP_BLASTER_PISTOL,
+	{12,	6,		-6	},	// WP_BLASTER,
+	{12,	6,		-6	},	// WP_DISRUPTOR,
+	{12,	2,		-6	},	// WP_BOWCASTER,
+	{12,	4.5,	-6	},	// WP_REPEATER,
+	{12,	6,		-6	},	// WP_DEMP2,
+	{12,	6,		-6	},	// WP_FLECHETTE,
+	{12,	8,		-4	},	// WP_ROCKET_LAUNCHER,
+	{12,	0,		-4	},	// WP_THERMAL,
+	{12,	0,		-10	},	// WP_TRIP_MINE,
+	{12,	0,		-4	},	// WP_DET_PACK,
+	{12,	8,		-4	},	// WP_CONCUSSION,
+	{0	,	8,		0	},	// WP_MELEE,
+	{0,		0,		0	},	// WP_ATST_MAIN,
+	{0,		0,		0	},	// WP_ATST_SIDE,
+	{0	,	8,		0	},	// WP_STUN_BATON,
+	{12,	6,		-6	},	// WP_BRYAR_PISTOL,
+};
+
+void WP_RocketLock( gentity_t *ent, float lockDist )
+{
+	// Not really a charge weapon, but we still want to delay fire until the button comes up so that we can
+	//	implement our alt-fire locking stuff
+	vec3_t		ang;
+	trace_t		tr;
+	
+	vec3_t muzzleOffPoint, muzzlePoint, forward, right, up;
+
+	AngleVectors( ent->client->ps.viewangles, forward, right, up );
+
+	AngleVectors(ent->client->ps.viewangles, ang, NULL, NULL);
+
+	VectorCopy( ent->client->ps.origin, muzzlePoint );
+	VectorCopy(WP_MuzzlePoint[WP_ROCKET_LAUNCHER], muzzleOffPoint);
+
+	VectorMA(muzzlePoint, muzzleOffPoint[0], forward, muzzlePoint);
+	VectorMA(muzzlePoint, muzzleOffPoint[1], right, muzzlePoint);
+	muzzlePoint[2] += ent->client->ps.viewheight + muzzleOffPoint[2];
+
+	ang[0] = muzzlePoint[0] + ang[0]*lockDist;
+	ang[1] = muzzlePoint[1] + ang[1]*lockDist;
+	ang[2] = muzzlePoint[2] + ang[2]*lockDist;
+
+	gi.trace(&tr, muzzlePoint, NULL, NULL, ang, ent->client->ps.clientNum, MASK_PLAYERSOLID);
+
+	if (tr.fraction != 1 && tr.entityNum < ENTITYNUM_NONE && tr.entityNum != ent->client->ps.clientNum)
+	{
+		gentity_t *bgEnt = &g_entities[tr.entityNum];
+		if ( bgEnt && (bgEnt->s.powerups&PW_CLOAKED) )
+		{
+			ent->client->rocketLockIndex = ENTITYNUM_NONE;
+			ent->client->rocketLockTime = 0;
+		}
+		else if (bgEnt && bgEnt->s.eType == ET_PLAYER )
+		{
+			if (ent->client->rocketLockIndex == ENTITYNUM_NONE)
+			{
+				ent->client->rocketLockIndex = tr.entityNum;
+				ent->client->rocketLockTime = level.time;
+			}
+			else if (ent->client->rocketLockIndex != tr.entityNum && ent->client->rocketTargetTime < level.time)
+			{
+				ent->client->rocketLockIndex = tr.entityNum;
+				ent->client->rocketLockTime = level.time;
+			}
+			else if (ent->client->rocketLockIndex == tr.entityNum)
+			{
+				if (ent->client->rocketLockTime == -1)
+				{
+					ent->client->rocketLockTime = ent->client->rocketLastValidTime;
+				}
+			}
+
+			if (ent->client->rocketLockIndex == tr.entityNum)
+			{
+				ent->client->rocketTargetTime = level.time + 500;
+			}
+		}
+	}
+	else if (ent->client->rocketTargetTime < level.time)
+	{
+		ent->client->rocketLockIndex = ENTITYNUM_NONE;
+		ent->client->rocketLockTime = 0;
+	}
+	else
+	{
+		if (ent->client->rocketLockTime != -1)
+		{
+			ent->client->rocketLastValidTime = ent->client->rocketLockTime;
+		}
+		ent->client->rocketLockTime = -1;
+	}
+}
+
+#define VEH_HOMING_MISSILE_THINK_TIME		100
+void WP_FireVehicleWeapon( gentity_t *ent, vec3_t start, vec3_t dir, vehWeaponInfo_t *vehWeapon )
+{
+	if ( !vehWeapon )
+	{//invalid vehicle weapon
+		return;
+	}
+	else if ( vehWeapon->bIsProjectile )
+	{//projectile entity
+		gentity_t	*missile;
+		vec3_t		mins, maxs;
+
+		VectorSet( maxs, vehWeapon->fWidth/2.0f,vehWeapon->fWidth/2.0f,vehWeapon->fHeight/2.0f );
+		VectorScale( maxs, -1, mins );
+
+		//make sure our start point isn't on the other side of a wall
+		WP_TraceSetStart( ent, start, mins, maxs );
+		
+		//QUERY: alt_fire true or not?  Does it matter?
+		missile = CreateMissile( start, dir, vehWeapon->fSpeed, 10000, ent, qfalse );
+		if ( vehWeapon->bHasGravity )
+		{//TESTME: is this all we need to do?
+			missile->s.pos.trType = TR_GRAVITY;
+		}
+
+		missile->classname = "vehicle_proj";
+		
+		missile->damage = vehWeapon->iDamage;
+		missile->splashDamage = vehWeapon->iSplashDamage;
+		missile->splashRadius = vehWeapon->fSplashRadius;
+
+		// HUGE HORRIBLE HACK
+		if (ent->owner && ent->owner->s.number==0)
+		{
+			missile->damage			*= 20.0f;
+			missile->splashDamage	*= 20.0f;
+			missile->splashRadius	*= 20.0f; 
+		}
+
+		//FIXME: externalize some of these properties?
+		missile->dflags = DAMAGE_DEATH_KNOCKBACK;
+		missile->clipmask = MASK_SHOT;
+		//Maybe by checking flags...?
+		if ( vehWeapon->bSaberBlockable )
+		{
+			missile->clipmask |= CONTENTS_LIGHTSABER;
+		}
+		/*
+		if ( (vehWeapon->iFlags&VWF_KNOCKBACK) )
+		{
+			missile->dflags &= ~DAMAGE_DEATH_KNOCKBACK;
+		}
+		if ( (vehWeapon->iFlags&VWF_DISTORTION_TRAIL) )
+		{
+			missile->s.eFlags |= EF_DISTORTION_TRAIL;
+		}
+		if ( (vehWeapon->iFlags&VWF_RADAR) )
+		{
+			missile->s.eFlags |= EF_RADAROBJECT;
+		}
+		*/
+		missile->s.weapon = WP_BLASTER;//does this really matter?
+
+		// Make it easier to hit things
+		VectorCopy( mins, missile->mins );
+		VectorCopy( maxs, missile->maxs );
+		//some slightly different stuff for things with bboxes
+		if ( vehWeapon->fWidth || vehWeapon->fHeight )
+		{//we assume it's a rocket-like thing
+			missile->methodOfDeath = MOD_ROCKET;
+			missile->splashMethodOfDeath = MOD_ROCKET;// ?SPLASH;
+
+			// we don't want it to ever bounce
+			missile->bounceCount = 0;
+
+			missile->mass = 10;
+		}
+		else
+		{//a blaster-laser-like thing
+			missile->s.weapon = WP_BLASTER;//does this really matter?
+			missile->methodOfDeath = MOD_EMPLACED;//MOD_TURBLAST; //count as a heavy weap
+			missile->splashMethodOfDeath = MOD_EMPLACED;//MOD_TURBLAST;// ?SPLASH;
+			// we don't want it to bounce forever
+			missile->bounceCount = 8;
+		}
+
+		if ( vehWeapon->iHealth )
+		{//the missile can take damage
+			missile->health = vehWeapon->iHealth;
+			missile->takedamage = qtrue;
+			missile->contents = MASK_SHOT;
+			missile->e_DieFunc = dieF_WP_ExplosiveDie;//dieF_RocketDie;
+		}
+
+		//set veh as cgame side owner for purpose of fx overrides
+		if (ent->m_pVehicle && ent->m_pVehicle->m_pPilot)
+		{
+			missile->owner = ent->m_pVehicle->m_pPilot;
+		}
+		else
+		{
+			missile->owner = ent;
+		}
+		missile->s.otherEntityNum = ent->s.number;
+
+		if ( vehWeapon->iLifeTime )
+		{//expire after a time
+			if ( vehWeapon->bExplodeOnExpire )
+			{//blow up when your lifetime is up
+				missile->e_ThinkFunc = thinkF_WP_Explode;//FIXME: custom func?
+			}
+			else
+			{//just remove yourself
+				missile->e_ThinkFunc = thinkF_G_FreeEntity;//FIXME: custom func?
+			}
+			missile->nextthink = level.time + vehWeapon->iLifeTime;
+		}
+		if ( vehWeapon->fHoming )
+		{//homing missile
+			//crap, we need to set up the homing stuff like it is in MP...
+			WP_RocketLock( ent, 16384 );
+			if ( ent->client && ent->client->rocketLockIndex != ENTITYNUM_NONE )
+			{
+				int dif = 0;
+				float rTime;
+				rTime = ent->client->rocketLockTime;
+
+				if (rTime == -1)
+				{
+					rTime = ent->client->rocketLastValidTime;
+				}
+
+				if ( !vehWeapon->iLockOnTime )
+				{//no minimum lock-on time
+					dif = 10;//guaranteed lock-on
+				}
+				else
+				{
+					float lockTimeInterval = vehWeapon->iLockOnTime/16.0f;
+					dif = ( level.time - rTime ) / lockTimeInterval;
+				}
+
+				if (dif < 0)
+				{
+					dif = 0;
+				}
+
+				//It's 10 even though it locks client-side at 8, because we want them to have a sturdy lock first, and because there's a slight difference in time between server and client
+				if ( dif >= 10 && rTime != -1 )
+				{
+					missile->enemy = &g_entities[ent->client->rocketLockIndex];
+
+					if (missile->enemy && missile->enemy->client && missile->enemy->health > 0 && !OnSameTeam(ent, missile->enemy))
+					{ //if enemy became invalid, died, or is on the same team, then don't seek it
+						missile->spawnflags |= 1;//just to let it know it should be faster... FIXME: EXTERNALIZE
+						missile->speed = vehWeapon->fSpeed;
+						missile->angle = vehWeapon->fHoming;
+						if ( vehWeapon->iLifeTime )
+						{//expire after a time
+							missile->disconnectDebounceTime = level.time + vehWeapon->iLifeTime;
+							missile->lockCount = (int)(vehWeapon->bExplodeOnExpire);
+						}
+						missile->e_ThinkFunc = thinkF_rocketThink;
+						missile->nextthink = level.time + VEH_HOMING_MISSILE_THINK_TIME;
+						//FIXME: implement radar in SP?
+						//missile->s.eFlags |= EF_RADAROBJECT;
+					}
+				}
+
+				ent->client->rocketLockIndex = ENTITYNUM_NONE;
+				ent->client->rocketLockTime = 0;
+				ent->client->rocketTargetTime = 0;
+
+				VectorCopy( dir, missile->movedir );
+				missile->random = 1.0f;//FIXME: externalize?
+			}
+		}
+	}
+	else
+	{//traceline
+		//FIXME: implement
+	}
+}
+
+//---------------------------------------------------------
+void FireVehicleWeapon( gentity_t *ent, qboolean alt_fire ) 
+//---------------------------------------------------------
+{
+	Vehicle_t *pVeh = ent->m_pVehicle;
+
+	if ( !pVeh )
+	{
+		return;
+	}
+
+	if (pVeh->m_iRemovedSurfaces)
+	{ //can't fire when the thing is breaking apart
+		return;
+	}
+
+
+	if (ent->owner && ent->owner->client && ent->owner->client->ps.weapon!=WP_NONE)
+	{
+		return;
+	}
+
+	// TODO?: If possible (probably not enough time), it would be nice if secondary fire was actually a mode switch/toggle
+	// so that, for instance, an x-wing can have 4-gun fire, or individual muzzle fire. If you wanted a different weapon, you
+	// would actually have to press the 2 key or something like that (I doubt I'd get a graphic for it anyways though). -AReis
+
+	// If this is not the alternate fire, fire a normal blaster shot...
+ 	if ( true )//(pVeh->m_ulFlags & VEH_FLYING) || (pVeh->m_ulFlags & VEH_WINGSOPEN) ) // NOTE: Wings open also denotes that it has already launched.
+	{
+		int	weaponNum = 0, vehWeaponIndex = VEH_WEAPON_NONE;
+		int	delay = 1000;
+		qboolean aimCorrect = qfalse;
+		qboolean linkedFiring = qfalse;
+
+		if ( !alt_fire )
+		{
+			weaponNum = 0;
+		}
+		else
+		{
+			weaponNum = 1;
+		}
+		vehWeaponIndex = pVeh->m_pVehicleInfo->weapon[weaponNum].ID;
+		delay = pVeh->m_pVehicleInfo->weapon[weaponNum].delay;
+		aimCorrect = pVeh->m_pVehicleInfo->weapon[weaponNum].aimCorrect;
+		if ( pVeh->m_pVehicleInfo->weapon[weaponNum].linkable == 1//optionally linkable
+			 && pVeh->weaponStatus[weaponNum].linked )//linked
+		{//we're linking the primary or alternate weapons, so we'll do *all* the muzzles
+			linkedFiring = qtrue;
+		}
+
+		if ( vehWeaponIndex <= VEH_WEAPON_BASE || vehWeaponIndex >= MAX_VEH_WEAPONS )
+		{//invalid vehicle weapon
+			return;
+		}
+		else
+		{
+			vehWeaponInfo_t *vehWeapon = &g_vehWeaponInfo[vehWeaponIndex];
+			int i, cumulativeDelay = 0;
+
+			for ( i = 0; i < MAX_VEHICLE_MUZZLES; i++ )
+			{
+				if ( pVeh->m_pVehicleInfo->weapMuzzle[i] != vehWeaponIndex )
+				{//this muzzle doesn't match the weapon we're trying to use
+					continue;
+				}
+
+				// Fire this muzzle.
+				if ( pVeh->m_iMuzzleTag[i] != -1 && pVeh->m_Muzzles[i].m_iMuzzleWait < level.time )
+				{
+					vec3_t	start, dir;
+					// Prepare weapon delay.
+					if ( linkedFiring )
+					{//linked firing, add the delay up for each muzzle, then apply to all of them at the end
+						cumulativeDelay += delay;
+					}
+					else
+					{//normal delay - NOTE: always-linked muzzles use normal delay, not cumulative
+						pVeh->m_Muzzles[i].m_iMuzzleWait = level.time + delay;
+					}
+					
+					if ( pVeh->weaponStatus[weaponNum].ammo < vehWeapon->iAmmoPerShot )
+					{//out of ammo!
+					}
+					else
+					{//have enough ammo to shoot
+						//take the ammo
+						pVeh->weaponStatus[weaponNum].ammo -= vehWeapon->iAmmoPerShot;
+						//do the firing
+						//FIXME: do we still need to calc the muzzle here in SP?
+						//WP_CalcVehMuzzle(ent, i);
+						VectorCopy( pVeh->m_Muzzles[i].m_vMuzzlePos, start );
+						VectorCopy( pVeh->m_Muzzles[i].m_vMuzzleDir, dir );
+						if ( aimCorrect )
+						{//auto-aim the missile at the crosshair
+							trace_t trace;
+							vec3_t	end;
+							AngleVectors( pVeh->m_vOrientation, dir, NULL, NULL );
+							//VectorMA( ent->currentOrigin, 32768, dir, end );
+							VectorMA( ent->currentOrigin, 8192, dir, end );
+							gi.trace( &trace, ent->currentOrigin, vec3_origin, vec3_origin, end, ent->s.number, MASK_SHOT );
+							//if ( trace.fraction < 1.0f && !trace.allsolid && !trace.startsolid )
+							//bah, always point at end of trace
+							{
+								VectorSubtract( trace.endpos, start, dir );
+								VectorNormalize( dir );
+							}
+
+							// Mounted lazer cannon auto aiming at enemy
+							//-------------------------------------------
+							if (ent->enemy)
+							{
+								Vehicle_t*	enemyVeh = G_IsRidingVehicle(ent->enemy);
+
+								// Don't Auto Aim At A Person Who Is Slide Breaking
+								if (!enemyVeh || !(enemyVeh->m_ulFlags&VEH_SLIDEBREAKING))
+								{
+									vec3_t dir2;
+									VectorSubtract( ent->enemy->currentOrigin, start, dir2 );
+									VectorNormalize( dir2 );
+									if (DotProduct(dir, dir2)>0.95f)
+									{
+										VectorCopy(dir2, dir);
+									}
+								}
+							}
+						}
+
+						//play the weapon's muzzle effect if we have one
+						if ( vehWeapon->iMuzzleFX )
+						{
+							G_PlayEffect( vehWeapon->iMuzzleFX, pVeh->m_Muzzles[i].m_vMuzzlePos, pVeh->m_Muzzles[i].m_vMuzzleDir );
+						}
+						WP_FireVehicleWeapon( ent, start, dir, vehWeapon );
+					}
+
+					if ( pVeh->weaponStatus[weaponNum].linked )//NOTE: we don't check linkedFiring here because that does *not* get set if the cannons are *always* linked
+					{//we're linking the weapon, so continue on and fire all appropriate muzzles
+						continue;
+					}
+					//ok, just break, we'll get in here again next frame and try the next muzzle...
+					break;
+				}
+			}
+			if ( cumulativeDelay )
+			{//we linked muzzles so we need to apply the cumulative delay now, to each of the linked muzzles
+				for ( i = 0; i < MAX_VEHICLE_MUZZLES; i++ )
+				{
+					if ( pVeh->m_pVehicleInfo->weapMuzzle[i] != vehWeaponIndex )
+					{//this muzzle doesn't match the weapon we're trying to use
+						continue;
+					}
+					//apply the cumulative delay
+					pVeh->m_Muzzles[i].m_iMuzzleWait = level.time + cumulativeDelay;
+				}
+			}
+		}
+	}
+}
+
+void WP_FireScepter( gentity_t *ent, qboolean alt_fire )
+{//just a straight beam
+	int			damage = 1;
+	vec3_t		start, end;
+	trace_t		tr;
+	gentity_t	*traceEnt = NULL, *tent;
+	float		shotRange = 8192;
+	qboolean	render_impact = qtrue;
+
+	VectorCopy( muzzle, start );
+	WP_TraceSetStart( ent, start, vec3_origin, vec3_origin );
+
+	WP_MissileTargetHint(ent, start, forward);
+	VectorMA( start, shotRange, forward, end );
+
+	gi.trace( &tr, start, NULL, NULL, end, ent->s.number, MASK_SHOT, G2_RETURNONHIT, 10 );
+	traceEnt = &g_entities[tr.entityNum];
+
+	if ( tr.surfaceFlags & SURF_NOIMPACT ) 
+	{
+		render_impact = qfalse;
+	}
+
+	// always render a shot beam, doing this the old way because I don't much feel like overriding the effect.
+	tent = G_TempEntity( tr.endpos, EV_DISRUPTOR_MAIN_SHOT );
+	tent->svFlags |= SVF_BROADCAST;
+	VectorCopy( muzzle, tent->s.origin2 );
+
+	if ( render_impact )
+	{
+		if ( tr.entityNum < ENTITYNUM_WORLD && traceEnt->takedamage )
+		{
+			// Create a simple impact type mark that doesn't last long in the world
+			G_PlayEffect( G_EffectIndex( "disruptor/flesh_impact" ), tr.endpos, tr.plane.normal );
+
+			int hitLoc = G_GetHitLocFromTrace( &tr, MOD_DISRUPTOR );
+			G_Damage( traceEnt, ent, ent, forward, tr.endpos, damage, DAMAGE_EXTRA_KNOCKBACK, MOD_DISRUPTOR, hitLoc );
+		}
+		else 
+		{
+			G_PlayEffect( G_EffectIndex( "disruptor/wall_impact" ), tr.endpos, tr.plane.normal );		
+		}
+	}
+
+	/*
+	shotDist = shotRange * tr.fraction;
+
+	for ( dist = 0; dist < shotDist; dist += 64 )
+	{
+		//FIXME: on a really long shot, this could make a LOT of alerts in one frame...
+		VectorMA( start, dist, forward, spot );
+		AddSightEvent( ent, spot, 256, AEL_DISCOVERED, 50 );
+	}
+	VectorMA( start, shotDist-4, forward, spot );
+	AddSightEvent( ent, spot, 256, AEL_DISCOVERED, 50 );
+	*/
+}
+
+extern Vehicle_t *G_IsRidingVehicle( gentity_t *ent );
+//---------------------------------------------------------
+void FireWeapon( gentity_t *ent, qboolean alt_fire ) 
+//---------------------------------------------------------
+{
+	float alert = 256;
+	Vehicle_t *pVeh = NULL;
+
+	// track shots taken for accuracy tracking. 
+	ent->client->ps.persistant[PERS_ACCURACY_SHOTS]++;
+
+	// If this is a vehicle, fire it's weapon and we're done.
+	if ( ent && ent->client && ent->client->NPC_class == CLASS_VEHICLE )
+	{
+		FireVehicleWeapon( ent, alt_fire );
+		return;
+	}
+
+	// set aiming directions
+	if ( ent->s.weapon == WP_DISRUPTOR && alt_fire )
+	{
+		if ( ent->NPC )
+		{
+			//snipers must use the angles they actually did their shot trace with
+			AngleVectors( ent->lastAngles, forward, vright, up );
+		}
+	}
+	else if ( ent->s.weapon == WP_ATST_SIDE || ent->s.weapon == WP_ATST_MAIN ) 
+	{
+		vec3_t	delta1, enemy_org1, muzzle1;
+		vec3_t	angleToEnemy1;
+
+		VectorCopy( ent->client->renderInfo.muzzlePoint, muzzle1 );
+
+		if ( !ent->s.number )
+		{//player driving an AT-ST
+			//SIGH... because we can't anticipate alt-fire, must calc muzzle here and now
+			mdxaBone_t		boltMatrix;
+			int				bolt;
+
+			if ( ent->client->ps.weapon == WP_ATST_MAIN )
+			{//FIXME: alt_fire should fire both barrels, but slower?
+				if ( ent->alt_fire )
+				{
+					bolt = ent->handRBolt;
+				}
+				else
+				{
+					bolt = ent->handLBolt;
+				}
+			}
+			else
+			{// ATST SIDE weapons
+				if ( ent->alt_fire )
+				{
+					if ( gi.G2API_GetSurfaceRenderStatus( &ent->ghoul2[ent->playerModel], "head_light_blaster_cann" ) )
+					{//don't have it!
+						return;
+					}
+					bolt = ent->genericBolt2;
+				}
+				else
+				{
+					if ( gi.G2API_GetSurfaceRenderStatus( &ent->ghoul2[ent->playerModel], "head_concussion_charger" ) )
+					{//don't have it!
+						return;
+					}
+					bolt = ent->genericBolt1;
+				}
+			}
+
+			vec3_t yawOnlyAngles = {0, ent->currentAngles[YAW], 0};
+			if ( ent->currentAngles[YAW] != ent->client->ps.legsYaw )
+			{
+				yawOnlyAngles[YAW] = ent->client->ps.legsYaw;
+			}
+			gi.G2API_GetBoltMatrix( ent->ghoul2, ent->playerModel, bolt, &boltMatrix, yawOnlyAngles, ent->currentOrigin, (cg.time?cg.time:level.time), NULL, ent->s.modelScale );
+
+			// work the matrix axis stuff into the original axis and origins used.
+			gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, ent->client->renderInfo.muzzlePoint );
+			gi.G2API_GiveMeVectorFromMatrix( boltMatrix, NEGATIVE_Y, ent->client->renderInfo.muzzleDir );
+			ent->client->renderInfo.mPCalcTime = level.time;
+
+			AngleVectors( ent->client->ps.viewangles, forward, vright, up );
+			//CalcMuzzlePoint( ent, forward, vright, up, muzzle, 0 );
+		}
+		else if ( !ent->enemy )
+		{//an NPC with no enemy to auto-aim at
+			VectorCopy( ent->client->renderInfo.muzzleDir, forward );
+		}
+		else
+		{//NPC, auto-aim at enemy
+			CalcEntitySpot( ent->enemy, SPOT_HEAD, enemy_org1 );
+			
+			VectorSubtract (enemy_org1, muzzle1, delta1);
+
+			vectoangles ( delta1, angleToEnemy1 );
+			AngleVectors (angleToEnemy1, forward, vright, up);
+		}
+	} 
+	else if ( ent->s.weapon == WP_BOT_LASER && ent->enemy ) 
+	{
+		vec3_t	delta1, enemy_org1, muzzle1;
+		vec3_t	angleToEnemy1;
+
+		CalcEntitySpot( ent->enemy, SPOT_HEAD, enemy_org1 );
+		CalcEntitySpot( ent, SPOT_WEAPON, muzzle1 );
+		
+		VectorSubtract (enemy_org1, muzzle1, delta1);
+
+		vectoangles ( delta1, angleToEnemy1 );
+		AngleVectors (angleToEnemy1, forward, vright, up);
+	}
+	else 
+	{
+  		if ( (pVeh = G_IsRidingVehicle( ent )) != NULL) //riding a vehicle
+		{//use our muzzleDir, can't use viewangles or vehicle m_vOrientation because we may be animated to shoot left or right...
+			if ((ent->s.eFlags&EF_NODRAW))//we're inside it
+			{
+				vec3_t	aimAngles;
+				VectorCopy( ent->client->renderInfo.muzzleDir, forward );
+				vectoangles( forward, aimAngles );
+				//we're only keeping the yaw
+				aimAngles[PITCH] = ent->client->ps.viewangles[PITCH];
+				aimAngles[ROLL] = 0;
+				AngleVectors( aimAngles, forward, vright, up );
+			}
+			else
+			{
+				vec3_t	actorRight;
+				vec3_t	actorFwd;
+
+				VectorCopy( ent->client->renderInfo.muzzlePoint, muzzle );
+				AngleVectors(ent->currentAngles, actorFwd, actorRight, 0);
+ 
+				// Aiming Left
+				//-------------
+				if (ent->client->ps.torsoAnim==BOTH_VT_ATL_G || ent->client->ps.torsoAnim==BOTH_VS_ATL_G)
+				{
+ 					VectorScale(actorRight, -1.0f, forward);
+				}
+
+				// Aiming Right
+				//--------------
+				else if (ent->client->ps.torsoAnim==BOTH_VT_ATR_G || ent->client->ps.torsoAnim==BOTH_VS_ATR_G)
+				{
+ 					VectorCopy(actorRight, forward);
+				}
+
+				// Aiming Forward
+				//----------------
+				else
+				{
+	 				VectorCopy(actorFwd, forward);
+				}
+
+				// If We Have An Enemy, Fudge The Aim To Hit The Enemy
+				if (ent->enemy)
+				{
+					vec3_t	toEnemy;
+					VectorSubtract(ent->enemy->currentOrigin, ent->currentOrigin, toEnemy);
+					VectorNormalize(toEnemy);
+					if (DotProduct(toEnemy, forward)>0.75f && 
+						((ent->s.number==0 && !Q_irand(0,2)) ||		// the player has a 1 in 3 chance
+						 (ent->s.number!=0 && !Q_irand(0,5))))		// other guys have a 1 in 6 chance
+					{
+						VectorCopy(toEnemy, forward);
+					}
+					else
+					{
+						forward[0] += Q_flrand(-0.1f, 0.1f);
+						forward[1] += Q_flrand(-0.1f, 0.1f);
+						forward[2] += Q_flrand(-0.1f, 0.1f);
+					}
+				}
+			}
+		}
+		else
+		{
+			AngleVectors( ent->client->ps.viewangles, forward, vright, up );
+		}
+	}
+
+	ent->alt_fire = alt_fire;
+	if (!pVeh)
+	{
+		if (ent->NPC && (ent->NPC->scriptFlags&SCF_FIRE_WEAPON_NO_ANIM))
+		{
+		 	VectorCopy( ent->client->renderInfo.muzzlePoint, muzzle );
+			VectorCopy( ent->client->renderInfo.muzzleDir, forward );
+			MakeNormalVectors(forward, vright, up);
+		}
+		else
+		{
+			CalcMuzzlePoint ( ent, forward, vright, up, muzzle , 0);
+		}
+	}
+
+	// fire the specific weapon
+	switch( ent->s.weapon ) 
+	{
+	// Player weapons
+	//-----------------
+	case WP_SABER:
+		return;
+		break;
+
+	case WP_BRYAR_PISTOL:
+	case WP_BLASTER_PISTOL:
+		WP_FireBryarPistol( ent, alt_fire );
+		break;
+
+	case WP_BLASTER:
+		WP_FireBlaster( ent, alt_fire );
+		break;
+
+	case WP_TUSKEN_RIFLE:
+		if ( alt_fire )
+		{
+			WP_FireTuskenRifle( ent );
+		}
+		else
+		{
+			WP_Melee( ent );
+		}
+		break;
+
+	case WP_DISRUPTOR:
+		alert = 50; // if you want it to alert enemies, remove this
+		WP_FireDisruptor( ent, alt_fire );
+		break;
+
+	case WP_BOWCASTER:
+		WP_FireBowcaster( ent, alt_fire );
+		break;
+
+	case WP_REPEATER:
+		WP_FireRepeater( ent, alt_fire );
+		break;
+
+	case WP_DEMP2:
+		WP_FireDEMP2( ent, alt_fire );
+		break;
+
+	case WP_FLECHETTE:
+		WP_FireFlechette( ent, alt_fire );
+		break;
+
+	case WP_ROCKET_LAUNCHER:
+		WP_FireRocket( ent, alt_fire );
+		break;
+
+	case WP_CONCUSSION:
+		if ( alt_fire )
+		{
+			WP_FireConcussionAlt( ent );
+		}
+		else
+		{
+			WP_FireConcussion( ent );
+		}
+		break;
+
+	case WP_THERMAL:
+		WP_FireThermalDetonator( ent, alt_fire );
+		break;
+
+	case WP_TRIP_MINE:
+		alert = 0; // if you want it to alert enemies, remove this
+		WP_PlaceLaserTrap( ent, alt_fire );
+		break;
+
+	case WP_DET_PACK:
+		alert = 0; // if you want it to alert enemies, remove this
+		WP_FireDetPack( ent, alt_fire );
+		break;
+
+	case WP_BOT_LASER:
+		WP_BotLaser( ent );
+		break;
+
+	case WP_EMPLACED_GUN:
+		// doesn't care about whether it's alt-fire or not.  We can do an alt-fire if needed
+		WP_EmplacedFire( ent );
+		break;
+
+	case WP_MELEE:
+		alert = 0; // if you want it to alert enemies, remove this
+		if ( !alt_fire || !g_debugMelee->integer )
+		{
+			WP_Melee( ent );
+		}
+		break;
+
+	case WP_ATST_MAIN:
+		WP_ATSTMainFire( ent );
+		break;
+
+	case WP_ATST_SIDE:
+
+		// TEMP
+		if ( alt_fire )
+		{
+//			WP_FireRocket( ent, qfalse );
+			WP_ATSTSideAltFire(ent);
+		}
+		else
+		{
+			// FIXME!
+		/*	if ( ent->s.number == 0 
+				&& ent->client->NPC_class == CLASS_VEHICLE
+				&& vehicleData[((CVehicleNPC *)ent->NPC)->m_iVehicleTypeID].type == VH_FIGHTER )
+			{
+				WP_ATSTMainFire( ent );
+			}
+			else*/
+			{
+				WP_ATSTSideFire(ent);
+			}
+		}
+		break;
+
+	case WP_TIE_FIGHTER:
+		// TEMP
+		WP_EmplacedFire( ent );
+		break;
+
+	case WP_RAPID_FIRE_CONC:
+		// TEMP
+		if ( alt_fire )
+		{
+			WP_FireRepeater( ent, alt_fire );	
+		}
+		else
+		{
+			WP_EmplacedFire( ent );
+		}
+		break;
+
+	case WP_STUN_BATON:
+		WP_FireStunBaton( ent, alt_fire );
+		break;
+
+//	case WP_BLASTER_PISTOL:
+	case WP_JAWA:
+		WP_FireBryarPistol( ent, qfalse ); // never an alt-fire?
+		break;
+
+	case WP_SCEPTER:
+		WP_FireScepter( ent, alt_fire );
+		break;
+
+	case WP_NOGHRI_STICK:
+		if ( !alt_fire )
+		{
+			WP_FireNoghriStick( ent );
+		}
+		//else does melee attack/damage/func
+		break;
+
+	case WP_TUSKEN_STAFF:
+	default:
+		return;
+		break;
+	}
+
+	if ( !ent->s.number )
+	{
+		if ( ent->s.weapon == WP_FLECHETTE || (ent->s.weapon == WP_BOWCASTER && !alt_fire) )
+		{//these can fire multiple shots, count them individually within the firing functions
+		}
+		else if ( W_AccuracyLoggableWeapon( ent->s.weapon, alt_fire, MOD_UNKNOWN ) )
+		{
+			ent->client->sess.missionStats.shotsFired++;
+		}
+	}
+	// We should probably just use this as a default behavior, in special cases, just set alert to false.
+	if ( ent->s.number == 0 && alert > 0 )
+	{
+		if ( ent->client->ps.groundEntityNum == ENTITYNUM_WORLD//FIXME: check for sand contents type?
+			&& ent->s.weapon != WP_STUN_BATON
+			&& ent->s.weapon != WP_MELEE
+			&& ent->s.weapon != WP_TUSKEN_STAFF
+			&& ent->s.weapon != WP_THERMAL
+			&& ent->s.weapon != WP_TRIP_MINE
+			&& ent->s.weapon != WP_DET_PACK )
+		{//the vibration of the shot carries through your feet into the ground
+			AddSoundEvent( ent, muzzle, alert, AEL_DISCOVERED, qfalse, qtrue );
+		}
+		else
+		{//an in-air alert
+			AddSoundEvent( ent, muzzle, alert, AEL_DISCOVERED );
+		}
+		AddSightEvent( ent, muzzle, alert*2, AEL_DISCOVERED, 20 );
+	}
+}
+
+//NOTE: Emplaced gun moved to g_emplaced.cpp
+
+/*QUAKED misc_weapon_shooter (1 0 0) (-8 -8 -8) (8 8 8) ALTFIRE TOGGLE
+ALTFIRE - fire the alt-fire of the chosen weapon
+TOGGLE - keep firing until used again (fires at intervals of "wait")
+
+"wait" - debounce time between refires (defaults to 500)
+"delay" - speed of WP_THERMAL (default is 900)
+"random" - ranges from 0 to random, added to wait (defaults to 0)
+
+"target" - what to aim at (will update aim every frame if it's a moving target)  
+
+"weapon" - specify the weapon to use (default is WP_BLASTER)
+	WP_BRYAR_PISTOL
+	WP_BLASTER
+	WP_DISRUPTOR
+	WP_BOWCASTER
+	WP_REPEATER
+	WP_DEMP2
+	WP_FLECHETTE
+	WP_ROCKET_LAUNCHER
+	WP_CONCUSSION
+	WP_THERMAL
+	WP_TRIP_MINE
+	WP_DET_PACK
+	WP_STUN_BATON
+	WP_EMPLACED_GUN
+	WP_BOT_LASER
+	WP_TURRET
+	WP_ATST_MAIN
+	WP_ATST_SIDE
+	WP_TIE_FIGHTER
+	WP_RAPID_FIRE_CONC
+	WP_BLASTER_PISTOL
+*/
+void misc_weapon_shooter_fire( gentity_t *self )
+{
+	FireWeapon( self, (self->spawnflags&1) );
+	if ( (self->spawnflags&2) )
+	{//repeat
+		self->e_ThinkFunc = thinkF_misc_weapon_shooter_fire;
+		if (self->random)
+		{
+			self->nextthink = level.time + self->wait + (int)(random()*self->random);
+		}
+		else
+		{
+			self->nextthink = level.time + self->wait;
+		}
+	}
+}
+
+void misc_weapon_shooter_use ( gentity_t *self, gentity_t *other, gentity_t *activator )
+{
+	if ( self->e_ThinkFunc == thinkF_misc_weapon_shooter_fire )
+	{//repeating fire, stop
+		self->e_ThinkFunc = thinkF_NULL;
+		self->nextthink = -1;
+		return;
+	}
+	//otherwise, fire
+	misc_weapon_shooter_fire( self );
+}
+
+void misc_weapon_shooter_aim( gentity_t *self )
+{
+	//update my aim
+	if ( self->target )
+	{
+		gentity_t *targ = G_Find( NULL, FOFS(targetname), self->target );
+		if ( targ )
+		{
+			self->enemy = targ;
+			VectorSubtract( targ->currentOrigin, self->currentOrigin, self->client->renderInfo.muzzleDir );
+			VectorCopy( targ->currentOrigin, self->pos1 );
+			vectoangles( self->client->renderInfo.muzzleDir, self->client->ps.viewangles );
+			SetClientViewAngle( self, self->client->ps.viewangles );
+			//FIXME: don't keep doing this unless target is a moving target?
+			self->nextthink = level.time + FRAMETIME;
+		}
+		else
+		{
+			self->enemy = NULL;
+		}
+	}
+}
+
+extern stringID_table_t WPTable[];
+void SP_misc_weapon_shooter( gentity_t *self )
+{
+	//alloc a client just for the weapon code to use
+	self->client = (gclient_s *)gi.Malloc(sizeof(gclient_s), TAG_G_ALLOC, qtrue);
+
+	//set weapon
+	self->s.weapon = self->client->ps.weapon = WP_BLASTER;
+	if ( self->paintarget )
+	{//use a different weapon
+		self->s.weapon = self->client->ps.weapon = GetIDForString( WPTable, self->paintarget );
+	}
+
+	//set where our muzzle is
+	VectorCopy( self->s.origin, self->client->renderInfo.muzzlePoint );
+	//permanently updated
+	self->client->renderInfo.mPCalcTime = Q3_INFINITE;
+
+	//set up to link
+	if ( self->target )
+	{
+        self->e_ThinkFunc = thinkF_misc_weapon_shooter_aim;
+		self->nextthink = level.time + START_TIME_LINK_ENTS;
+	}
+	else
+	{//just set aim angles
+		VectorCopy( self->s.angles, self->client->ps.viewangles );
+		AngleVectors( self->s.angles, self->client->renderInfo.muzzleDir, NULL, NULL );
+	}
+
+	//set up to fire when used
+    self->e_UseFunc = useF_misc_weapon_shooter_use;
+
+	if ( !self->wait )
+	{
+		self->wait = 500;
+	}
+}
\ No newline at end of file
diff --git a/code/game/g_weaponLoad.cpp b/code/game/g_weaponLoad.cpp
new file mode 100644
index 0000000..7096d83
--- /dev/null
+++ b/code/game/g_weaponLoad.cpp
@@ -0,0 +1,1362 @@
+// g_weaponLoad.cpp 
+// fills in memory struct with ext_dat\weapons.dat
+
+// this is excluded from PCH usage 'cos it looks kinda scary to me, being game and ui.... -Ste
+
+#ifdef _USRDLL	//UI dll
+
+#include "../ui/gameinfo.h"
+#include "weapons.h"
+extern	gameinfo_import_t	gi;
+extern weaponData_t weaponData[];
+extern ammoData_t ammoData[];
+
+#else	//we are in the game
+
+// ONLY DO THIS ON THE GAME SIDE
+#include "g_local.h"
+
+typedef struct {
+	char	*name;
+	void	(*func)(centity_t *cent, const struct weaponInfo_s *weapon );
+} func_t;
+
+// Bryar
+void FX_BryarProjectileThink(  centity_t *cent, const struct weaponInfo_s *weapon );
+void FX_BryarAltProjectileThink(  centity_t *cent, const struct weaponInfo_s *weapon );
+
+// Blaster
+void FX_BlasterProjectileThink( centity_t *cent, const struct weaponInfo_s *weapon );
+void FX_BlasterAltFireThink( centity_t *cent, const struct weaponInfo_s *weapon );
+
+// Bowcaster
+void FX_BowcasterProjectileThink( centity_t *cent, const struct weaponInfo_s *weapon );
+
+// Heavy Repeater
+void FX_RepeaterProjectileThink( centity_t *cent, const struct weaponInfo_s *weapon );
+void FX_RepeaterAltProjectileThink( centity_t *cent, const struct weaponInfo_s *weapon );
+
+// DEMP2
+void FX_DEMP2_ProjectileThink( centity_t *cent, const struct weaponInfo_s *weapon );
+void FX_DEMP2_AltProjectileThink( centity_t *cent, const struct weaponInfo_s *weapon );
+
+// Golan Arms Flechette
+void FX_FlechetteProjectileThink( centity_t *cent, const struct weaponInfo_s *weapon );
+void FX_FlechetteAltProjectileThink( centity_t *cent, const struct weaponInfo_s *weapon );
+
+// Personal Rocket Launcher
+void FX_RocketProjectileThink( centity_t *cent, const struct weaponInfo_s *weapon );
+void FX_RocketAltProjectileThink( centity_t *cent, const struct weaponInfo_s *weapon );
+
+// Concussion Rifle
+void FX_ConcProjectileThink( centity_t *cent, const struct weaponInfo_s *weapon );
+
+// Emplaced weapon
+void FX_EmplacedProjectileThink( centity_t *cent, const struct weaponInfo_s *weapon );
+
+// Turret weapon
+void FX_TurretProjectileThink( centity_t *cent, const struct weaponInfo_s *weapon );
+
+// ATST Main weapon
+void FX_ATSTMainProjectileThink( centity_t *cent, const struct weaponInfo_s *weapon );
+
+// ATST Side weapons
+void FX_ATSTSideMainProjectileThink( centity_t *cent, const struct weaponInfo_s *weapon );
+void FX_ATSTSideAltProjectileThink( centity_t *cent, const struct weaponInfo_s *weapon );
+
+//Tusken projectile
+void FX_TuskenShotProjectileThink( centity_t *cent, const struct weaponInfo_s *weapon );
+
+//Noghri projectile
+void FX_NoghriShotProjectileThink( centity_t *cent, const struct weaponInfo_s *weapon );
+
+// Table used to attach an extern missile function string to the actual cgame function
+func_t	funcs[] = {
+	{"bryar_func",			FX_BryarProjectileThink},
+	{"bryar_alt_func",		FX_BryarAltProjectileThink},
+	{"blaster_func",		FX_BlasterProjectileThink},
+	{"blaster_alt_func",	FX_BlasterAltFireThink},
+	{"bowcaster_func",		FX_BowcasterProjectileThink},
+	{"repeater_func",		FX_RepeaterProjectileThink},
+	{"repeater_alt_func",	FX_RepeaterAltProjectileThink},
+	{"demp2_func",			FX_DEMP2_ProjectileThink},
+	{"demp2_alt_func",		FX_DEMP2_AltProjectileThink},
+	{"flechette_func",		FX_FlechetteProjectileThink},
+	{"flechette_alt_func",	FX_FlechetteAltProjectileThink},
+	{"rocket_func",			FX_RocketProjectileThink},
+	{"rocket_alt_func",		FX_RocketAltProjectileThink},
+	{"conc_func",			FX_ConcProjectileThink},
+	{"emplaced_func",		FX_EmplacedProjectileThink},
+	{"turret_func",			FX_TurretProjectileThink},
+	{"atstmain_func",		FX_ATSTMainProjectileThink},
+	{"atst_side_alt_func",	FX_ATSTSideAltProjectileThink},
+	{"atst_side_main_func",	FX_ATSTSideMainProjectileThink},
+	{"tusk_shot_func",		FX_TuskenShotProjectileThink},
+	{"noghri_shot_func",	FX_NoghriShotProjectileThink},
+	{NULL,					NULL}
+};
+#endif
+
+
+//qboolean COM_ParseInt( char **data, int *i );
+//qboolean COM_ParseString( char **data, char **s ); 
+//qboolean COM_ParseFloat( char **data, float *f );
+
+struct 
+{
+	int	weaponNum;	// Current weapon number
+	int	ammoNum;
+} wpnParms;
+
+void WPN_Ammo (const char **holdBuf);
+void WPN_AmmoIcon (const char **holdBuf);
+void WPN_AmmoMax (const char **holdBuf);
+void WPN_AmmoLowCnt (const char **holdBuf);
+void WPN_AmmoType (const char **holdBuf);
+void WPN_EnergyPerShot (const char **holdBuf);
+void WPN_FireTime (const char **holdBuf);
+void WPN_FiringSnd (const char **holdBuf);
+void WPN_AltFiringSnd(const char **holdBuf );
+void WPN_StopSnd( const char **holdBuf );
+//void WPN_FlashSnd (char **holdBuf);
+//void WPN_AltFlashSnd (char **holdBuf);
+void WPN_ChargeSnd (const char **holdBuf);
+void WPN_AltChargeSnd (const char **holdBuf);
+void WPN_SelectSnd (const char **holdBuf);
+void WPN_Range (const char **holdBuf);
+void WPN_WeaponClass ( const char **holdBuf);
+void WPN_WeaponIcon (const char **holdBuf);
+void WPN_WeaponModel (const char **holdBuf);
+void WPN_WeaponType (const char **holdBuf);
+void WPN_AltEnergyPerShot (const char **holdBuf);
+void WPN_AltFireTime (const char **holdBuf);
+void WPN_AltRange (const char **holdBuf);
+void WPN_BarrelCount(const char **holdBuf);
+void WPN_MissileName(const char **holdBuf);
+void WPN_AltMissileName(const char **holdBuf);
+void WPN_MissileSound(const char **holdBuf);
+void WPN_AltMissileSound(const char **holdBuf);
+void WPN_MissileLight(const char **holdBuf);
+void WPN_AltMissileLight(const char **holdBuf);
+void WPN_MissileLightColor(const char **holdBuf);
+void WPN_AltMissileLightColor(const char **holdBuf);
+void WPN_FuncName(const char **holdBuf);
+void WPN_AltFuncName(const char **holdBuf);
+void WPN_MissileHitSound(const char **holdBuf);
+void WPN_AltMissileHitSound(const char **holdBuf);
+void WPN_MuzzleEffect(const char **holdBuf);
+void WPN_AltMuzzleEffect(const char **holdBuf);
+//#ifdef _IMMERSION
+void WPN_FiringFrc(const char **holdBuf);
+void WPN_AltFiringFrc(const char **holdBuf);
+void WPN_ChargeFrc(const char **holdBuf);
+void WPN_AltChargeFrc(const char **holdBuf);
+void WPN_StopFrc(const char **holdBuf);
+void WPN_SelectFrc(const char **holdBuf);
+//#endif // _IMMERSION
+
+typedef struct 
+{
+	char	*parmName;
+	void	(*func)(const char **holdBuf);
+} wpnParms_t;
+
+wpnParms_t WpnParms[] = 
+{
+	"ammo",				WPN_Ammo,	//ammo
+	"ammoicon",			WPN_AmmoIcon,
+	"ammomax",			WPN_AmmoMax,
+	"ammolowcount",		WPN_AmmoLowCnt, //weapons
+	"ammotype",			WPN_AmmoType,
+	"energypershot",	WPN_EnergyPerShot,
+	"fireTime",			WPN_FireTime,
+	"firingsound",		WPN_FiringSnd,
+	"altfiringsound",	WPN_AltFiringSnd,
+//	"flashsound",		WPN_FlashSnd,
+//	"altflashsound",	WPN_AltFlashSnd,
+	"stopsound",		WPN_StopSnd,
+	"chargesound",		WPN_ChargeSnd,
+	"altchargesound",	WPN_AltChargeSnd,
+	"selectsound",		WPN_SelectSnd,
+	"range",			WPN_Range,
+	"weaponclass",		WPN_WeaponClass,
+	"weaponicon",		WPN_WeaponIcon,
+	"weaponmodel",		WPN_WeaponModel,
+	"weapontype",		WPN_WeaponType,
+	"altenergypershot",	WPN_AltEnergyPerShot,
+	"altfireTime",		WPN_AltFireTime,
+	"altrange",			WPN_AltRange,
+	"barrelcount",		WPN_BarrelCount,
+	"missileModel",		WPN_MissileName,
+	"altmissileModel", 	WPN_AltMissileName,
+	"missileSound",		WPN_MissileSound,
+	"altmissileSound", 	WPN_AltMissileSound,
+	"missileLight",		WPN_MissileLight,
+	"altmissileLight", 	WPN_AltMissileLight,
+	"missileLightColor",WPN_MissileLightColor,
+	"altmissileLightColor",	WPN_AltMissileLightColor,
+	"missileFuncName",		WPN_FuncName,
+	"altmissileFuncName",	WPN_AltFuncName,
+	"missileHitSound",		WPN_MissileHitSound,
+	"altmissileHitSound",	WPN_AltMissileHitSound,
+	"muzzleEffect",			WPN_MuzzleEffect,
+	"altmuzzleEffect",		WPN_AltMuzzleEffect
+//#ifdef _IMMERSION
+,	"firingForce",		WPN_FiringFrc
+,	"altFiringForce",	WPN_AltFiringFrc
+,	"chargeForce",		WPN_ChargeFrc
+,	"altChargeForce",	WPN_AltChargeFrc
+,	"stopForce",		WPN_StopFrc
+,	"selectForce",		WPN_SelectFrc
+//#endif // _IMMERSION
+};
+
+const int WPN_PARM_MAX =  sizeof(WpnParms) / sizeof(WpnParms[0]);
+
+void WPN_WeaponType( const char **holdBuf)
+{
+	int weaponNum;
+	const char	*tokenStr;
+
+	if (COM_ParseString(holdBuf,&tokenStr)) 
+	{
+		return;
+	}
+
+	// FIXME : put this in an array (maybe a weaponDataInternal array???)
+	if (!Q_stricmp(tokenStr,"WP_NONE"))	
+		weaponNum = WP_NONE;
+	else if (!Q_stricmp(tokenStr,"WP_SABER"))	
+		weaponNum = WP_SABER;
+	else if (!Q_stricmp(tokenStr,"WP_BLASTER_PISTOL"))	
+		weaponNum = WP_BLASTER_PISTOL;
+	else if (!Q_stricmp(tokenStr,"WP_BRYAR_PISTOL"))	
+		weaponNum = WP_BRYAR_PISTOL;
+	else if (!Q_stricmp(tokenStr,"WP_BLASTER"))	
+		weaponNum = WP_BLASTER;
+	else if (!Q_stricmp(tokenStr,"WP_DISRUPTOR"))	
+		weaponNum = WP_DISRUPTOR;
+	else if (!Q_stricmp(tokenStr,"WP_BOWCASTER"))	
+		weaponNum = WP_BOWCASTER;
+	else if (!Q_stricmp(tokenStr,"WP_REPEATER"))	
+		weaponNum = WP_REPEATER;
+	else if (!Q_stricmp(tokenStr,"WP_DEMP2"))	
+		weaponNum = WP_DEMP2;
+	else if (!Q_stricmp(tokenStr,"WP_FLECHETTE"))	
+		weaponNum = WP_FLECHETTE;
+	else if (!Q_stricmp(tokenStr,"WP_ROCKET_LAUNCHER"))	
+		weaponNum = WP_ROCKET_LAUNCHER;
+	else if (!Q_stricmp(tokenStr,"WP_CONCUSSION"))	
+		weaponNum = WP_CONCUSSION;
+	else if (!Q_stricmp(tokenStr,"WP_THERMAL"))	
+		weaponNum = WP_THERMAL;
+	else if (!Q_stricmp(tokenStr,"WP_TRIP_MINE"))	
+		weaponNum = WP_TRIP_MINE;
+	else if (!Q_stricmp(tokenStr,"WP_DET_PACK"))	
+		weaponNum = WP_DET_PACK;
+	else if (!Q_stricmp(tokenStr,"WP_STUN_BATON"))	
+		weaponNum = WP_STUN_BATON;
+	else if (!Q_stricmp(tokenStr,"WP_BOT_LASER"))	
+		weaponNum = WP_BOT_LASER;
+	else if (!Q_stricmp(tokenStr,"WP_EMPLACED_GUN"))	
+		weaponNum = WP_EMPLACED_GUN;
+	else if (!Q_stricmp(tokenStr,"WP_MELEE"))	
+		weaponNum = WP_MELEE;
+	else if (!Q_stricmp(tokenStr,"WP_TURRET"))
+		weaponNum = WP_TURRET;
+	else if (!Q_stricmp(tokenStr,"WP_ATST_MAIN"))
+		weaponNum = WP_ATST_MAIN;
+	else if (!Q_stricmp(tokenStr,"WP_ATST_SIDE"))
+		weaponNum = WP_ATST_SIDE;
+	else if (!Q_stricmp(tokenStr,"WP_TIE_FIGHTER"))
+		weaponNum = WP_TIE_FIGHTER;
+	else if (!Q_stricmp(tokenStr,"WP_RAPID_FIRE_CONC"))
+		weaponNum = WP_RAPID_FIRE_CONC;
+	else if (!Q_stricmp(tokenStr,"WP_JAWA"))
+		weaponNum = WP_JAWA;
+	else if (!Q_stricmp(tokenStr,"WP_TUSKEN_RIFLE"))
+		weaponNum = WP_TUSKEN_RIFLE;
+	else if (!Q_stricmp(tokenStr,"WP_TUSKEN_STAFF"))
+		weaponNum = WP_TUSKEN_STAFF;
+	else if (!Q_stricmp(tokenStr,"WP_SCEPTER"))
+		weaponNum = WP_SCEPTER;
+	else if (!Q_stricmp(tokenStr,"WP_NOGHRI_STICK"))
+		weaponNum = WP_NOGHRI_STICK;
+	else
+	{
+		weaponNum = 0;
+		gi.Printf(S_COLOR_YELLOW"WARNING: bad weapontype in external weapon data '%s'\n", tokenStr);
+	}
+
+	wpnParms.weaponNum = weaponNum;
+}
+
+//--------------------------------------------
+void WPN_WeaponClass(const char **holdBuf)
+{
+	int len;
+	const char	*tokenStr;
+
+	if (COM_ParseString(holdBuf,&tokenStr)) 
+	{
+		return;
+	}
+
+	len = strlen(tokenStr);
+	len++;
+	if (len > 32)
+	{
+		len = 32;
+		gi.Printf(S_COLOR_YELLOW"WARNING: weaponclass too long in external WEAPONS.DAT '%s'\n", tokenStr);
+	}
+
+	Q_strncpyz(weaponData[wpnParms.weaponNum].classname,tokenStr,len);
+}
+
+
+//--------------------------------------------
+void WPN_WeaponModel(const char **holdBuf)
+{
+	int len;
+	const char	*tokenStr;
+
+	if ( COM_ParseString(holdBuf,&tokenStr)) 
+	{
+		return;
+	}
+
+	len = strlen(tokenStr);
+	len++;
+	if (len > 64)
+	{
+		len = 64;
+		gi.Printf(S_COLOR_YELLOW"WARNING: weaponMdl too long in external WEAPONS.DAT '%s'\n", tokenStr);
+	}
+
+	Q_strncpyz(weaponData[wpnParms.weaponNum].weaponMdl,tokenStr,len);
+}
+
+//--------------------------------------------
+void WPN_WeaponIcon(const char **holdBuf)
+{
+	int len;
+	const char	*tokenStr;
+
+	if ( COM_ParseString(holdBuf,&tokenStr)) 
+	{
+		return;
+	}
+
+	len = strlen(tokenStr);
+	len++;
+	if (len > 64)
+	{
+		len = 64;
+		gi.Printf(S_COLOR_YELLOW"WARNING: weaponIcon too long in external WEAPONS.DAT '%s'\n", tokenStr);
+	}
+
+	Q_strncpyz(weaponData[wpnParms.weaponNum].weaponIcon,tokenStr,len);
+}
+
+//--------------------------------------------
+void WPN_AmmoType(const char **holdBuf)
+{
+	int		tokenInt;
+
+	if ( COM_ParseInt(holdBuf,&tokenInt)) 
+	{
+		SkipRestOfLine(holdBuf);
+		return;
+	}
+
+	if ((tokenInt < AMMO_NONE ) || (tokenInt >= AMMO_MAX ))
+	{
+		gi.Printf(S_COLOR_YELLOW"WARNING: bad Ammotype in external weapon data '%d'\n", tokenInt);
+		return;
+	}
+
+	weaponData[wpnParms.weaponNum].ammoIndex = tokenInt;
+}
+
+//--------------------------------------------
+void WPN_AmmoLowCnt(const char **holdBuf)
+{
+	int		tokenInt;
+
+	if ( COM_ParseInt(holdBuf,&tokenInt)) 
+	{
+		SkipRestOfLine(holdBuf);
+		return;
+	}
+
+	if ((tokenInt < 0) || (tokenInt > 200 )) // FIXME :What are the right values?
+	{
+		gi.Printf(S_COLOR_YELLOW"WARNING: bad Ammolowcount in external weapon data '%d'\n", tokenInt);
+		return;
+	}
+
+	weaponData[wpnParms.weaponNum].ammoLow = tokenInt;
+}
+
+//--------------------------------------------
+void WPN_FiringSnd(const char **holdBuf)
+{
+	const char	*tokenStr;
+	int		len;
+
+	if ( COM_ParseString(holdBuf,&tokenStr)) 
+	{
+		return;
+	}
+
+	len = strlen(tokenStr);
+	len++;
+	if (len > 64)
+	{
+		len = 64;
+		gi.Printf(S_COLOR_YELLOW"WARNING: firingSnd too long in external WEAPONS.DAT '%s'\n", tokenStr);
+	}
+
+	Q_strncpyz(weaponData[wpnParms.weaponNum].firingSnd,tokenStr,len);
+}
+
+//--------------------------------------------
+void WPN_AltFiringSnd( const char **holdBuf )
+{
+	const char	*tokenStr;
+	int		len;
+
+	if ( COM_ParseString(holdBuf,&tokenStr)) 
+	{
+		return;
+	}
+
+	len = strlen(tokenStr);
+	len++;
+	if (len > 64)
+	{
+		len = 64;
+		gi.Printf(S_COLOR_YELLOW"WARNING: altFiringSnd too long in external WEAPONS.DAT '%s'\n", tokenStr);
+	}
+
+	Q_strncpyz(weaponData[wpnParms.weaponNum].altFiringSnd,tokenStr,len);
+}
+
+//--------------------------------------------
+void WPN_StopSnd( const char **holdBuf )
+{
+	const char	*tokenStr;
+	int		len;
+
+	if ( COM_ParseString(holdBuf,&tokenStr)) 
+	{
+		return;
+	}
+
+	len = strlen(tokenStr);
+	len++;
+	if (len > 64)
+	{
+		len = 64;
+		gi.Printf(S_COLOR_YELLOW"WARNING: stopSnd too long in external WEAPONS.DAT '%s'\n", tokenStr);
+	}
+
+	Q_strncpyz(weaponData[wpnParms.weaponNum].stopSnd,tokenStr,len);
+}
+/*
+//--------------------------------------------
+void WPN_FlashSnd(const char **holdBuf)
+{
+	const char	*tokenStr;
+	int		len;
+
+	if ( COM_ParseString(holdBuf,&tokenStr)) 
+	{
+		return;
+	}
+
+	len = strlen(tokenStr);
+	len++;
+	if (len > 64)
+	{
+		len = 64;
+		gi.Printf(S_COLOR_YELLOW"WARNING: flashSnd too long in external WEAPONS.DAT '%s'\n", tokenStr);
+	}
+
+	Q_strncpyz(weaponData[wpnParms.weaponNum].flashSnd,tokenStr,len);
+}
+
+//--------------------------------------------
+void WPN_AltFlashSnd(const char **holdBuf)
+{
+	const char	*tokenStr;
+	int		len;
+
+	if ( COM_ParseString(holdBuf,&tokenStr)) 
+	{
+		return;
+	}
+
+	len = strlen(tokenStr);
+	len++;
+	if (len > 64)
+	{
+		len = 64;
+		gi.Printf(S_COLOR_YELLOW"WARNING: altFlashSnd too long in external WEAPONS.DAT '%s'\n", tokenStr);
+	}
+
+	Q_strncpyz(weaponData[wpnParms.weaponNum].altFlashSnd,tokenStr,len);
+}
+*/
+//--------------------------------------------
+void WPN_ChargeSnd(const char **holdBuf)
+{
+	const char	*tokenStr;
+	int		len;
+
+	if ( COM_ParseString(holdBuf,&tokenStr)) 
+	{
+		return;
+	}
+
+	len = strlen(tokenStr);
+	len++;
+	if (len > 64)
+	{
+		len = 64;
+		gi.Printf(S_COLOR_YELLOW"WARNING: chargeSnd too long in external WEAPONS.DAT '%s'\n", tokenStr);
+	}
+
+	Q_strncpyz(weaponData[wpnParms.weaponNum].chargeSnd,tokenStr,len);
+}
+
+//--------------------------------------------
+void WPN_AltChargeSnd(const char **holdBuf)
+{
+	const char	*tokenStr;
+	int		len;
+
+	if ( COM_ParseString(holdBuf,&tokenStr)) 
+	{
+		return;
+	}
+
+	len = strlen(tokenStr);
+	len++;
+	if (len > 64)
+	{
+		len = 64;
+		gi.Printf(S_COLOR_YELLOW"WARNING: altChargeSnd too long in external WEAPONS.DAT '%s'\n", tokenStr);
+	}
+
+	Q_strncpyz(weaponData[wpnParms.weaponNum].altChargeSnd,tokenStr,len);
+}
+
+//--------------------------------------------
+void WPN_SelectSnd( const char **holdBuf )
+{
+	const char	*tokenStr;
+	int		len;
+
+	if ( COM_ParseString( holdBuf,&tokenStr )) 
+	{
+		return;
+	}
+
+	len = strlen( tokenStr );
+	len++;
+
+	if (len > 64)
+	{
+		len = 64;
+		gi.Printf(S_COLOR_YELLOW"WARNING: selectSnd too long in external WEAPONS.DAT '%s'\n", tokenStr);
+	}
+
+	Q_strncpyz( weaponData[wpnParms.weaponNum].selectSnd,tokenStr,len);
+}
+
+//#ifdef _IMMERSION
+
+//--------------------------------------------
+void WPN_FiringFrc( const char **holdBuf )
+{
+	const char	*tokenStr;
+	int		len;
+
+	if ( COM_ParseString( holdBuf,&tokenStr )) 
+	{
+		return;
+	}
+
+	len = strlen( tokenStr );
+	len++;
+
+	if (len > 64)
+	{
+		len = 64;
+		gi.Printf(S_COLOR_YELLOW"WARNING: firingFrc too long in external WEAPONS.DAT '%s'\n", tokenStr);
+	}
+
+#ifdef _IMMERSION
+	Q_strncpyz( weaponData[wpnParms.weaponNum].firingFrc,tokenStr,len);
+#endif
+}
+
+//--------------------------------------------
+void WPN_AltFiringFrc( const char **holdBuf )
+{
+	const char	*tokenStr;
+	int		len;
+
+	if ( COM_ParseString( holdBuf,&tokenStr )) 
+	{
+		return;
+	}
+
+	len = strlen( tokenStr );
+	len++;
+
+	if (len > 64)
+	{
+		len = 64;
+		gi.Printf(S_COLOR_YELLOW"WARNING: altFiringFrc too long in external WEAPONS.DAT '%s'\n", tokenStr);
+	}
+
+#ifdef _IMMERSION
+	Q_strncpyz( weaponData[wpnParms.weaponNum].altFiringFrc,tokenStr,len);
+#endif
+}
+
+//--------------------------------------------
+void WPN_ChargeFrc( const char **holdBuf )
+{
+	const char	*tokenStr;
+	int		len;
+
+	if ( COM_ParseString( holdBuf,&tokenStr )) 
+	{
+		return;
+	}
+
+	len = strlen( tokenStr );
+	len++;
+
+	if (len > 64)
+	{
+		len = 64;
+		gi.Printf(S_COLOR_YELLOW"WARNING: chargeFrc too long in external WEAPONS.DAT '%s'\n", tokenStr);
+	}
+
+#ifdef _IMMERSION
+	Q_strncpyz( weaponData[wpnParms.weaponNum].chargeFrc,tokenStr,len);
+#endif
+}
+
+//--------------------------------------------
+void WPN_AltChargeFrc( const char **holdBuf )
+{
+	const char	*tokenStr;
+	int		len;
+
+	if ( COM_ParseString( holdBuf,&tokenStr )) 
+	{
+		return;
+	}
+
+	len = strlen( tokenStr );
+	len++;
+
+	if (len > 64)
+	{
+		len = 64;
+		gi.Printf(S_COLOR_YELLOW"WARNING: altChargeFrc too long in external WEAPONS.DAT '%s'\n", tokenStr);
+	}
+
+#ifdef _IMMERSION
+	Q_strncpyz( weaponData[wpnParms.weaponNum].altChargeFrc,tokenStr,len);
+#endif
+}
+
+//--------------------------------------------
+void WPN_StopFrc( const char **holdBuf )
+{
+	const char	*tokenStr;
+	int		len;
+
+	if ( COM_ParseString( holdBuf,&tokenStr )) 
+	{
+		return;
+	}
+
+	len = strlen( tokenStr );
+	len++;
+
+	if (len > 64)
+	{
+		len = 64;
+		gi.Printf(S_COLOR_YELLOW"WARNING: stopFrc too long in external WEAPONS.DAT '%s'\n", tokenStr);
+	}
+
+#ifdef _IMMERSION
+	Q_strncpyz( weaponData[wpnParms.weaponNum].stopFrc,tokenStr,len);
+#endif
+}
+
+//--------------------------------------------
+void WPN_SelectFrc( const char **holdBuf )
+{
+	const char	*tokenStr;
+	int		len;
+
+	if ( COM_ParseString( holdBuf,&tokenStr )) 
+	{
+		return;
+	}
+
+	len = strlen( tokenStr );
+	len++;
+
+	if (len > 64)
+	{
+		len = 64;
+		gi.Printf(S_COLOR_YELLOW"WARNING: selectFrc too long in external WEAPONS.DAT '%s'\n", tokenStr);
+	}
+
+#ifdef _IMMERSION
+	Q_strncpyz( weaponData[wpnParms.weaponNum].selectFrc,tokenStr,len);
+#endif
+}
+
+//#endif // _IMMERSION
+
+//--------------------------------------------
+void WPN_FireTime(const char **holdBuf)
+{
+	int		tokenInt;
+
+	if ( COM_ParseInt(holdBuf,&tokenInt)) 
+	{
+		SkipRestOfLine(holdBuf);
+		return;
+	}
+
+	if ((tokenInt < 0) || (tokenInt > 10000 )) // FIXME :What are the right values?
+	{
+		gi.Printf(S_COLOR_YELLOW"WARNING: bad Firetime in external weapon data '%d'\n", tokenInt);
+		return;
+	}
+	weaponData[wpnParms.weaponNum].fireTime = tokenInt;
+}
+
+//--------------------------------------------
+void WPN_Range(const char **holdBuf)
+{
+	int		tokenInt;
+
+	if ( COM_ParseInt(holdBuf,&tokenInt)) 
+	{
+		SkipRestOfLine(holdBuf);
+		return;
+	}
+
+	if ((tokenInt < 0) || (tokenInt > 10000 )) // FIXME :What are the right values?
+	{
+		gi.Printf(S_COLOR_YELLOW"WARNING: bad Range in external weapon data '%d'\n", tokenInt);
+		return;
+	}
+
+	weaponData[wpnParms.weaponNum].range = tokenInt;
+}
+
+//--------------------------------------------
+void WPN_EnergyPerShot(const char **holdBuf)
+{
+	int		tokenInt;
+
+	if ( COM_ParseInt(holdBuf,&tokenInt)) 
+	{
+		SkipRestOfLine(holdBuf);
+		return;
+	}
+
+	if ((tokenInt < 0) || (tokenInt > 1000 )) // FIXME :What are the right values?
+	{
+		gi.Printf(S_COLOR_YELLOW"WARNING: bad EnergyPerShot in external weapon data '%d'\n", tokenInt);
+		return;
+	}
+	weaponData[wpnParms.weaponNum].energyPerShot = tokenInt;
+}
+
+//--------------------------------------------
+void WPN_AltFireTime(const char **holdBuf)
+{
+	int		tokenInt;
+
+	if ( COM_ParseInt(holdBuf,&tokenInt)) 
+	{
+		SkipRestOfLine(holdBuf);
+		return;
+	}
+
+	if ((tokenInt < 0) || (tokenInt > 10000 )) // FIXME :What are the right values?
+	{
+		gi.Printf(S_COLOR_YELLOW"WARNING: bad altFireTime in external weapon data '%d'\n", tokenInt);
+		return;
+	}
+	weaponData[wpnParms.weaponNum].altFireTime = tokenInt;
+}
+
+//--------------------------------------------
+void WPN_AltRange(const char **holdBuf)
+{
+	int		tokenInt;
+
+	if ( COM_ParseInt(holdBuf,&tokenInt)) 
+	{
+		SkipRestOfLine(holdBuf);
+		return;
+	}
+
+	if ((tokenInt < 0) || (tokenInt > 10000 )) // FIXME :What are the right values?
+	{
+		gi.Printf(S_COLOR_YELLOW"WARNING: bad AltRange in external weapon data '%d'\n", tokenInt);
+		return;
+	}
+
+	weaponData[wpnParms.weaponNum].altRange = tokenInt;
+}
+
+//--------------------------------------------
+void WPN_AltEnergyPerShot(const char **holdBuf)
+{
+	int		tokenInt;
+
+	if ( COM_ParseInt(holdBuf,&tokenInt)) 
+	{
+		SkipRestOfLine(holdBuf);
+		return;
+	}
+
+	if ((tokenInt < 0) || (tokenInt > 1000 )) // FIXME :What are the right values?
+	{
+		gi.Printf(S_COLOR_YELLOW"WARNING: bad AltEnergyPerShot in external weapon data '%d'\n", tokenInt);
+		return;
+	}
+	weaponData[wpnParms.weaponNum].altEnergyPerShot = tokenInt;
+}
+
+//--------------------------------------------
+void WPN_Ammo(const char **holdBuf)
+{
+	const char	*tokenStr;
+
+	if ( COM_ParseString(holdBuf,&tokenStr)) 
+	{
+		return;
+	}
+
+	if (!Q_stricmp(tokenStr,"AMMO_NONE"))	
+		wpnParms.ammoNum = AMMO_NONE;
+	else if (!Q_stricmp(tokenStr,"AMMO_FORCE"))	
+		wpnParms.ammoNum = AMMO_FORCE;
+	else if (!Q_stricmp(tokenStr,"AMMO_BLASTER"))	
+		wpnParms.ammoNum = AMMO_BLASTER;
+	else if (!Q_stricmp(tokenStr,"AMMO_POWERCELL"))	
+		wpnParms.ammoNum = AMMO_POWERCELL;
+	else if (!Q_stricmp(tokenStr,"AMMO_METAL_BOLTS"))	
+		wpnParms.ammoNum = AMMO_METAL_BOLTS;
+	else if (!Q_stricmp(tokenStr,"AMMO_ROCKETS"))	
+		wpnParms.ammoNum = AMMO_ROCKETS;
+	else if (!Q_stricmp(tokenStr,"AMMO_EMPLACED"))	
+		wpnParms.ammoNum = AMMO_EMPLACED;
+	else if (!Q_stricmp(tokenStr,"AMMO_THERMAL"))	
+		wpnParms.ammoNum = AMMO_THERMAL;
+	else if (!Q_stricmp(tokenStr,"AMMO_TRIPMINE"))	
+		wpnParms.ammoNum = AMMO_TRIPMINE;
+	else if (!Q_stricmp(tokenStr,"AMMO_DETPACK"))	
+		wpnParms.ammoNum = AMMO_DETPACK;
+	else
+	{
+		gi.Printf(S_COLOR_YELLOW"WARNING: bad ammotype in external weapon data '%s'\n", tokenStr);
+		wpnParms.ammoNum = 0;
+	}
+}
+
+//--------------------------------------------
+void WPN_AmmoIcon(const char **holdBuf)
+{
+	const char	*tokenStr;
+	int		len;
+
+	if ( COM_ParseString(holdBuf,&tokenStr)) 
+	{
+		return;
+	}
+
+	len = strlen(tokenStr);
+	len++;
+	if (len > 64)
+	{
+		len = 64;
+		gi.Printf(S_COLOR_YELLOW"WARNING: ammoicon too long in external WEAPONS.DAT '%s'\n", tokenStr);
+	}
+
+	Q_strncpyz(ammoData[wpnParms.ammoNum].icon,tokenStr,len);
+
+}
+
+//--------------------------------------------
+void WPN_AmmoMax(const char **holdBuf)
+{
+	int		tokenInt;
+
+	if ( COM_ParseInt(holdBuf,&tokenInt)) 
+	{
+		SkipRestOfLine(holdBuf);
+		return;
+	}
+
+	if ((tokenInt < 0) || (tokenInt > 1000 )) 
+	{
+		gi.Printf(S_COLOR_YELLOW"WARNING: bad Ammo Max in external weapon data '%d'\n", tokenInt);
+		return;
+	}
+	ammoData[wpnParms.ammoNum].max = tokenInt;
+}
+
+//--------------------------------------------
+void WPN_BarrelCount(const char **holdBuf)
+{
+	int		tokenInt;
+
+	if ( COM_ParseInt(holdBuf,&tokenInt)) 
+	{
+		SkipRestOfLine(holdBuf);
+		return;
+	}
+
+	if ((tokenInt < 0) || (tokenInt > 4 )) 
+	{
+		gi.Printf(S_COLOR_YELLOW"WARNING: bad Range in external weapon data '%d'\n", tokenInt);
+		return;
+	}
+
+	weaponData[wpnParms.weaponNum].numBarrels = tokenInt;
+}
+
+
+//--------------------------------------------
+static void WP_ParseWeaponParms(const char **holdBuf)
+{
+	const char	*token;
+	int		i;
+
+
+	while (holdBuf)
+	{
+		token = COM_ParseExt( holdBuf, qtrue );
+
+		if (!Q_stricmp( token, "}" ))	// End of data for this weapon
+			break;
+
+		// Loop through possible parameters
+		for (i=0;i<WPN_PARM_MAX;++i)
+		{
+			if (!Q_stricmp(token,WpnParms[i].parmName))	
+			{
+				WpnParms[i].func(holdBuf);
+				break;
+			}
+		}
+
+		if (i < WPN_PARM_MAX)	// Find parameter???
+		{
+			continue;
+		}
+		Com_Error(ERR_FATAL,"bad parameter in external weapon data '%s'\n", token);		
+	}
+}
+
+//--------------------------------------------
+void WPN_MissileName(const char **holdBuf)
+{
+	int len;
+	const char	*tokenStr;
+
+	if ( COM_ParseString(holdBuf,&tokenStr)) 
+	{
+		return;
+	}
+
+	len = strlen(tokenStr);
+	len++;
+	if (len > 64)
+	{
+		len = 64;
+		gi.Printf(S_COLOR_YELLOW"WARNING: MissileName too long in external WEAPONS.DAT '%s'\n", tokenStr);
+	}
+
+	Q_strncpyz(weaponData[wpnParms.weaponNum].missileMdl,tokenStr,len);
+
+}
+
+//--------------------------------------------
+void WPN_AltMissileName(const char **holdBuf)
+{
+	int len;
+	const char	*tokenStr;
+
+	if ( COM_ParseString(holdBuf,&tokenStr)) 
+	{
+		return;
+	}
+
+	len = strlen(tokenStr);
+	len++;
+	if (len > 64)
+	{
+		len = 64;
+		gi.Printf(S_COLOR_YELLOW"WARNING: AltMissileName too long in external WEAPONS.DAT '%s'\n", tokenStr);
+	}
+
+	Q_strncpyz(weaponData[wpnParms.weaponNum].alt_missileMdl,tokenStr,len);
+
+}
+
+
+//--------------------------------------------
+void WPN_MissileHitSound(const char **holdBuf)
+{
+	int len;
+	const char	*tokenStr;
+
+	if ( COM_ParseString(holdBuf,&tokenStr)) 
+	{
+		return;
+	}
+
+	len = strlen(tokenStr);
+	len++;
+	if (len > 64)
+	{
+		len = 64;
+		gi.Printf(S_COLOR_YELLOW"WARNING: MissileHitSound too long in external WEAPONS.DAT '%s'\n", tokenStr);
+	}
+
+	Q_strncpyz(weaponData[wpnParms.weaponNum].missileHitSound,tokenStr,len);
+}
+
+//--------------------------------------------
+void WPN_AltMissileHitSound(const char **holdBuf)
+{
+	int len;
+	const char	*tokenStr;
+
+	if ( COM_ParseString(holdBuf,&tokenStr)) 
+	{
+		return;
+	}
+
+	len = strlen(tokenStr);
+	len++;
+	if (len > 64)
+	{
+		len = 64;
+		gi.Printf(S_COLOR_YELLOW"WARNING: AltMissileHitSound too long in external WEAPONS.DAT '%s'\n", tokenStr);
+	}
+
+	Q_strncpyz(weaponData[wpnParms.weaponNum].altmissileHitSound,tokenStr,len);
+}
+
+//--------------------------------------------
+void WPN_MissileSound(const char **holdBuf)
+{
+	int len;
+	const char	*tokenStr;
+
+	if ( COM_ParseString(holdBuf,&tokenStr)) 
+	{
+		return;
+	}
+
+	len = strlen(tokenStr);
+	len++;
+	if (len > 64)
+	{
+		len = 64;
+		gi.Printf(S_COLOR_YELLOW"WARNING: MissileSound too long in external WEAPONS.DAT '%s'\n", tokenStr);
+	}
+
+	Q_strncpyz(weaponData[wpnParms.weaponNum].missileSound,tokenStr,len);
+
+}
+
+
+//--------------------------------------------
+void WPN_AltMissileSound(const char **holdBuf)
+{
+	int len;
+	const char	*tokenStr;
+
+	if ( COM_ParseString(holdBuf,&tokenStr)) 
+	{
+		return;
+	}
+
+	len = strlen(tokenStr);
+	len++;
+	if (len > 64)
+	{
+		len = 64;
+		gi.Printf(S_COLOR_YELLOW"WARNING: AltMissileSound too long in external WEAPONS.DAT '%s'\n", tokenStr);
+	}
+
+	Q_strncpyz(weaponData[wpnParms.weaponNum].alt_missileSound,tokenStr,len);
+
+}
+
+//--------------------------------------------
+void WPN_MissileLightColor(const char **holdBuf)
+{
+	int i;
+	float	tokenFlt;
+
+	for (i=0;i<3;++i)
+	{
+		if ( COM_ParseFloat(holdBuf,&tokenFlt)) 
+		{
+			SkipRestOfLine(holdBuf);
+			continue;
+		}
+
+		if ((tokenFlt < 0) || (tokenFlt > 1 ))
+		{
+			gi.Printf(S_COLOR_YELLOW"WARNING: bad missilelightcolor in external weapon data '%f'\n", tokenFlt);
+			continue;
+		}
+		weaponData[wpnParms.weaponNum].missileDlightColor[i] = tokenFlt;
+	}
+
+}
+
+//--------------------------------------------
+void WPN_AltMissileLightColor(const char **holdBuf)
+{
+	int i;
+	float	tokenFlt;
+
+	for (i=0;i<3;++i)
+	{
+		if ( COM_ParseFloat(holdBuf,&tokenFlt)) 
+		{
+			SkipRestOfLine(holdBuf);
+			continue;
+		}
+
+		if ((tokenFlt < 0) || (tokenFlt > 1 ))
+		{
+			gi.Printf(S_COLOR_YELLOW"WARNING: bad altmissilelightcolor in external weapon data '%f'\n", tokenFlt);
+			continue;
+		}
+		weaponData[wpnParms.weaponNum].alt_missileDlightColor[i] = tokenFlt;
+	}
+
+}
+
+
+//--------------------------------------------
+void WPN_MissileLight(const char **holdBuf)
+{
+	float	tokenFlt;
+
+	if ( COM_ParseFloat(holdBuf,&tokenFlt)) 
+	{
+		SkipRestOfLine(holdBuf);
+	}
+
+	if ((tokenFlt < 0) || (tokenFlt > 255 )) // FIXME :What are the right values?
+	{
+		gi.Printf(S_COLOR_YELLOW"WARNING: bad missilelight in external weapon data '%f'\n", tokenFlt);
+	}
+	weaponData[wpnParms.weaponNum].missileDlight = tokenFlt;
+}
+
+//--------------------------------------------
+void WPN_AltMissileLight(const char **holdBuf)
+{
+	float	tokenFlt;
+
+	if ( COM_ParseFloat(holdBuf,&tokenFlt)) 
+	{
+		SkipRestOfLine(holdBuf);
+	}
+
+	if ((tokenFlt < 0) || (tokenFlt > 255 )) // FIXME :What are the right values?
+	{
+		gi.Printf(S_COLOR_YELLOW"WARNING: bad altmissilelight in external weapon data '%f'\n", tokenFlt);
+	}
+	weaponData[wpnParms.weaponNum].alt_missileDlight = tokenFlt;
+}
+
+
+//--------------------------------------------
+void WPN_FuncName(const char **holdBuf)
+{
+	const char	*tokenStr;
+
+	if ( COM_ParseString(holdBuf,&tokenStr)) 
+	{
+		return;
+	}
+	// ONLY DO THIS ON THE GAME SIDE
+#ifndef _USRDLL
+	int len = strlen(tokenStr);
+
+	len++;
+	if (len > 64)
+	{
+		len = 64;
+		gi.Printf(S_COLOR_YELLOW"WARNING: FuncName '%s' too long in external WEAPONS.DAT\n", tokenStr);
+	}
+
+	for ( func_t* s=funcs ; s->name ; s++ ) {
+		if ( !Q_stricmp(s->name, tokenStr) ) {
+			// found it
+			weaponData[wpnParms.weaponNum].func = (void*)s->func;
+			return;
+		}
+	}
+	gi.Printf(S_COLOR_YELLOW"WARNING: FuncName '%s' in external WEAPONS.DAT does not exist\n", tokenStr);
+#endif
+}
+
+
+//--------------------------------------------
+void WPN_AltFuncName(const char **holdBuf)
+{
+	const char	*tokenStr;
+
+	if ( COM_ParseString(holdBuf,&tokenStr)) 
+	{
+		return;
+	}
+
+	// ONLY DO THIS ON THE GAME SIDE
+#ifndef _USRDLL
+	int len = strlen(tokenStr);
+	len++;
+	if (len > 64)
+	{
+		len = 64;
+		gi.Printf(S_COLOR_YELLOW"WARNING: AltFuncName '%s' too long in external WEAPONS.DAT\n", tokenStr);
+	}
+
+	for ( func_t* s=funcs ; s->name ; s++ ) {
+		if ( !Q_stricmp(s->name, tokenStr) ) {
+			// found it
+			weaponData[wpnParms.weaponNum].altfunc = (void*)s->func;
+			return;
+		}
+	}
+	gi.Printf(S_COLOR_YELLOW"WARNING: AltFuncName %s in external WEAPONS.DAT does not exist\n", tokenStr);
+
+#endif
+}
+
+//--------------------------------------------
+void WPN_MuzzleEffect(const char **holdBuf)
+{
+	const char	*tokenStr;
+
+	if ( COM_ParseString(holdBuf,&tokenStr)) 
+	{
+		return;
+	}
+	// ONLY DO THIS ON THE GAME SIDE
+#ifndef _USRDLL
+
+	int len = strlen(tokenStr);
+
+	len++;
+	if (len > 64)
+	{
+		len = 64;
+		gi.Printf(S_COLOR_YELLOW"WARNING: MuzzleEffect '%s' too long in external WEAPONS.DAT\n", tokenStr);
+	}
+
+	G_EffectIndex( tokenStr );
+	Q_strncpyz(weaponData[wpnParms.weaponNum].mMuzzleEffect,tokenStr,len);
+
+#endif
+}
+
+//--------------------------------------------
+void WPN_AltMuzzleEffect(const char **holdBuf)
+{
+	const char	*tokenStr;
+
+	if ( COM_ParseString(holdBuf,&tokenStr)) 
+	{
+		return;
+	}
+	// ONLY DO THIS ON THE GAME SIDE
+#ifndef _USRDLL
+
+	int len = strlen(tokenStr);
+
+	len++;
+	if (len > 64)
+	{
+		len = 64;
+		gi.Printf(S_COLOR_YELLOW"WARNING: AltMuzzleEffect '%s' too long in external WEAPONS.DAT\n", tokenStr);
+	}
+
+	G_EffectIndex( tokenStr );
+	Q_strncpyz(weaponData[wpnParms.weaponNum].mAltMuzzleEffect,tokenStr,len);
+
+#endif
+}
+
+//--------------------------------------------
+static void WP_ParseParms(const char *buffer)
+{
+	const char	*holdBuf;
+	const char	*token;
+
+	holdBuf = buffer;
+	COM_BeginParseSession();
+
+	while ( holdBuf ) 
+	{
+		token = COM_ParseExt( &holdBuf, qtrue );
+
+		if ( !Q_stricmp( token, "{" ) ) 
+		{
+			token =token;
+			WP_ParseWeaponParms(&holdBuf);
+		}
+		 
+	}
+
+}
+
+//--------------------------------------------
+void WP_LoadWeaponParms (void)
+{
+	char *buffer;
+	int len;
+
+	len = gi.FS_ReadFile("ext_data/weapons.dat",(void **) &buffer);
+
+	if (len == -1)
+	{
+		Com_Error(ERR_FATAL,"Cannot find ext_data/weapons.dat!\n");		
+	}
+
+	// initialise the data area
+	memset(weaponData, 0, WP_NUM_WEAPONS * sizeof(weaponData_t));	
+
+	WP_ParseParms(buffer);
+
+	gi.FS_FreeFile( buffer );	//let go of the buffer
+}
\ No newline at end of file
diff --git a/code/game/game.def b/code/game/game.def
new file mode 100644
index 0000000..d405f05
--- /dev/null
+++ b/code/game/game.def
@@ -0,0 +1,4 @@
+EXPORTS
+	GetGameAPI
+	vmMain
+	dllEntry
diff --git a/code/game/game.vcproj b/code/game/game.vcproj
new file mode 100644
index 0000000..34a11a6
--- /dev/null
+++ b/code/game/game.vcproj
@@ -0,0 +1,2916 @@
+<?xml version="1.0" encoding = "Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="7.00"
+	Name="game"
+	SccProjectName="&quot;$/jedi/code&quot;, ROBAAAAA"
+	SccAuxPath=""
+	SccLocalPath=".."
+	SccProvider="MSSCCI:Microsoft Visual SourceSafe">
+	<Platforms>
+		<Platform
+			Name="Win32"/>
+	</Platforms>
+	<Configurations>
+		<Configuration
+			Name="SHDebug|Win32"
+			OutputDirectory=".\..\SHDebug"
+			IntermediateDirectory=".\..\SHDebug\game"
+			ConfigurationType="2"
+			UseOfMFC="0"
+			ATLMinimizesCRunTimeLibraryUsage="FALSE">
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				OptimizeForProcessor="2"
+				AdditionalIncludeDirectories="..\ICARUS"
+				PreprocessorDefinitions="_DEBUG;MEM_DEBUG;WIN32;_WINDOWS;_IMMERSION"
+				MinimalRebuild="TRUE"
+				RuntimeLibrary="5"
+				UsePrecompiledHeader="3"
+				PrecompiledHeaderThrough="g_headers.h"
+				PrecompiledHeaderFile=".\..\SHDebug\game/game.pch"
+				AssemblerListingLocation=".\..\SHDebug\game/"
+				ObjectFile=".\..\SHDebug\game/"
+				ProgramDataBaseFileName=".\..\SHDebug\game/"
+				BrowseInformation="1"
+				WarningLevel="4"
+				SuppressStartupBanner="TRUE"
+				DebugInformationFormat="4"
+				CompileAs="0"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalOptions="/MACHINE:I386"
+				AdditionalDependencies="../shdebug/game/smrtheap.obj winmm.lib"
+				OutputFile="..\SHDebug/jk2gamex86.dll"
+				LinkIncremental="2"
+				SuppressStartupBanner="TRUE"
+				ModuleDefinitionFile=".\game.def"
+				GenerateDebugInformation="TRUE"
+				ProgramDatabaseFile=".\..\SHDebug/jk3gamex86.pdb"
+				SubSystem="2"
+				BaseAddress="0x20000000"
+				ImportLibrary=".\..\SHDebug/jk2gamex86.lib"/>
+			<Tool
+				Name="VCMIDLTool"
+				PreprocessorDefinitions="_DEBUG"
+				MkTypLibCompatible="TRUE"
+				SuppressStartupBanner="TRUE"
+				TargetEnvironment="1"
+				TypeLibraryName=".\..\SHDebug/game.tlb"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="VCResourceCompilerTool"
+				PreprocessorDefinitions="_DEBUG"
+				Culture="1033"/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"/>
+			<Tool
+				Name="VCWebDeploymentTool"/>
+		</Configuration>
+		<Configuration
+			Name="Debug|Win32"
+			OutputDirectory=".\..\Debug"
+			IntermediateDirectory=".\..\Debug\game"
+			ConfigurationType="2"
+			UseOfMFC="0"
+			ATLMinimizesCRunTimeLibraryUsage="FALSE">
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				OptimizeForProcessor="2"
+				AdditionalIncludeDirectories="..\ICARUS"
+				PreprocessorDefinitions="_DEBUG;WIN32;_WINDOWS;_IMMERSION"
+				MinimalRebuild="TRUE"
+				RuntimeLibrary="5"
+				EnableFunctionLevelLinking="TRUE"
+				UsePrecompiledHeader="3"
+				PrecompiledHeaderThrough="g_headers.h"
+				PrecompiledHeaderFile=".\..\Debug\game/game.pch"
+				AssemblerListingLocation=".\..\Debug\game/"
+				ObjectFile=".\..\Debug\game/"
+				ProgramDataBaseFileName=".\..\Debug\game/"
+				BrowseInformation="1"
+				WarningLevel="4"
+				SuppressStartupBanner="TRUE"
+				DebugInformationFormat="4"
+				CompileAs="0"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalOptions="/MACHINE:I386"
+				AdditionalDependencies="winmm.lib"
+				OutputFile="..\Debug/jagamex86.dll"
+				LinkIncremental="2"
+				SuppressStartupBanner="TRUE"
+				ModuleDefinitionFile=".\game.def"
+				GenerateDebugInformation="TRUE"
+				ProgramDatabaseFile=".\..\Debug/jagamex86.pdb"
+				GenerateMapFile="TRUE"
+				MapFileName="..\debug\jagamex86.map"
+				SubSystem="2"
+				BaseAddress="0x20000000"
+				ImportLibrary=".\..\Debug/jagamex86.lib"/>
+			<Tool
+				Name="VCMIDLTool"
+				PreprocessorDefinitions="_DEBUG"
+				MkTypLibCompatible="TRUE"
+				SuppressStartupBanner="TRUE"
+				TargetEnvironment="1"
+				TypeLibraryName=".\..\Debug/game.tlb"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="VCResourceCompilerTool"
+				PreprocessorDefinitions="_DEBUG"
+				Culture="1033"/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"/>
+			<Tool
+				Name="VCWebDeploymentTool"/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			OutputDirectory=".\..\Release"
+			IntermediateDirectory=".\..\Release\game"
+			ConfigurationType="2"
+			UseOfMFC="0"
+			ATLMinimizesCRunTimeLibraryUsage="FALSE">
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="2"
+				InlineFunctionExpansion="1"
+				EnableIntrinsicFunctions="TRUE"
+				OptimizeForProcessor="2"
+				AdditionalIncludeDirectories="..\ICARUS"
+				PreprocessorDefinitions="NDEBUG;WIN32;_WINDOWS;_IMMERSION"
+				StringPooling="TRUE"
+				MinimalRebuild="TRUE"
+				RuntimeLibrary="4"
+				EnableFunctionLevelLinking="TRUE"
+				UsePrecompiledHeader="3"
+				PrecompiledHeaderThrough="g_headers.h"
+				PrecompiledHeaderFile=".\..\Release\game/game.pch"
+				AssemblerListingLocation=".\..\Release\game/"
+				ObjectFile=".\..\Release\game/"
+				ProgramDataBaseFileName=".\..\Release\game/"
+				WarningLevel="4"
+				SuppressStartupBanner="TRUE"
+				DebugInformationFormat="3"
+				CompileAs="0"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalOptions="/MACHINE:I386"
+				AdditionalDependencies="winmm.lib"
+				OutputFile="..\Release/jagamex86.dll"
+				LinkIncremental="1"
+				SuppressStartupBanner="TRUE"
+				ModuleDefinitionFile=".\game.def"
+				GenerateDebugInformation="TRUE"
+				ProgramDatabaseFile=".\..\Release/jagamex86.pdb"
+				GenerateMapFile="TRUE"
+				MapFileName="..\Release\jagamex86.map"
+				SubSystem="2"
+				BaseAddress="0x20000000"
+				ImportLibrary=".\..\Release/jagamex86.lib"/>
+			<Tool
+				Name="VCMIDLTool"
+				PreprocessorDefinitions="NDEBUG"
+				MkTypLibCompatible="TRUE"
+				SuppressStartupBanner="TRUE"
+				TargetEnvironment="1"
+				TypeLibraryName=".\..\Release/game.tlb"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="VCResourceCompilerTool"
+				PreprocessorDefinitions="NDEBUG"
+				Culture="1033"/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"/>
+			<Tool
+				Name="VCWebDeploymentTool"/>
+		</Configuration>
+		<Configuration
+			Name="FinalBuild|Win32"
+			OutputDirectory=".\..\FinalBuild"
+			IntermediateDirectory=".\..\FinalBuild\game"
+			ConfigurationType="2"
+			UseOfMFC="0"
+			ATLMinimizesCRunTimeLibraryUsage="FALSE"
+			WholeProgramOptimization="FALSE">
+			<Tool
+				Name="VCCLCompilerTool"
+				InlineFunctionExpansion="1"
+				OptimizeForProcessor="2"
+				AdditionalIncludeDirectories="..\ICARUS"
+				PreprocessorDefinitions="NDEBUG;FINAL_BUILD;WIN32;_WINDOWS;_IMMERSION"
+				StringPooling="TRUE"
+				RuntimeLibrary="4"
+				BufferSecurityCheck="FALSE"
+				EnableFunctionLevelLinking="FALSE"
+				UsePrecompiledHeader="3"
+				PrecompiledHeaderThrough="g_headers.h"
+				PrecompiledHeaderFile=".\..\FinalBuild\game/game.pch"
+				AssemblerListingLocation=".\..\FinalBuild\game/"
+				ObjectFile=".\..\FinalBuild\game/"
+				ProgramDataBaseFileName=".\..\FinalBuild\game/"
+				WarningLevel="4"
+				SuppressStartupBanner="TRUE"
+				CompileAs="0"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalOptions="/MACHINE:I386"
+				AdditionalDependencies="winmm.lib"
+				OutputFile="..\FinalBuild/jagamex86.dll"
+				LinkIncremental="1"
+				SuppressStartupBanner="TRUE"
+				ModuleDefinitionFile=".\game.def"
+				ProgramDatabaseFile=""
+				GenerateMapFile="TRUE"
+				MapFileName="..\FinalBuild\jagamex86.map"
+				SubSystem="2"
+				SetChecksum="TRUE"
+				BaseAddress="0x20000000"
+				ImportLibrary=".\..\FinalBuild/jagamex86.lib"/>
+			<Tool
+				Name="VCMIDLTool"
+				PreprocessorDefinitions="NDEBUG"
+				MkTypLibCompatible="TRUE"
+				SuppressStartupBanner="TRUE"
+				TargetEnvironment="1"
+				TypeLibraryName=".\..\FinalBuild/game.tlb"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="VCResourceCompilerTool"
+				PreprocessorDefinitions="NDEBUG"
+				Culture="1033"/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"/>
+			<Tool
+				Name="VCWebDeploymentTool"/>
+		</Configuration>
+	</Configurations>
+	<Files>
+		<Filter
+			Name="Source Files"
+			Filter="cpp;c;cxx;rc;def;r;odl;hpj;bat;for;f90">
+			<File
+				RelativePath="AI_Animal.cpp">
+			</File>
+			<File
+				RelativePath="AI_AssassinDroid.cpp">
+			</File>
+			<File
+				RelativePath=".\AI_Atst.cpp">
+			</File>
+			<File
+				RelativePath="AI_BobaFett.cpp">
+			</File>
+			<File
+				RelativePath="AI_Civilian.cpp">
+			</File>
+			<File
+				RelativePath=".\AI_Default.cpp">
+			</File>
+			<File
+				RelativePath=".\AI_Droid.cpp">
+			</File>
+			<File
+				RelativePath=".\AI_GalakMech.cpp">
+			</File>
+			<File
+				RelativePath="AI_Glider.cpp">
+			</File>
+			<File
+				RelativePath=".\AI_Grenadier.cpp">
+			</File>
+			<File
+				RelativePath="AI_HazardTrooper.cpp">
+			</File>
+			<File
+				RelativePath=".\AI_Howler.cpp">
+			</File>
+			<File
+				RelativePath=".\AI_ImperialProbe.cpp">
+			</File>
+			<File
+				RelativePath=".\AI_Interrogator.cpp">
+			</File>
+			<File
+				RelativePath=".\AI_Jedi.cpp">
+			</File>
+			<File
+				RelativePath=".\AI_Mark1.cpp">
+			</File>
+			<File
+				RelativePath=".\AI_Mark2.cpp">
+			</File>
+			<File
+				RelativePath=".\AI_MineMonster.cpp">
+			</File>
+			<File
+				RelativePath="AI_Rancor.cpp">
+			</File>
+			<File
+				RelativePath=".\AI_Remote.cpp">
+			</File>
+			<File
+				RelativePath="AI_RocketTrooper.cpp">
+			</File>
+			<File
+				RelativePath="AI_SaberDroid.cpp">
+			</File>
+			<File
+				RelativePath="AI_SandCreature.cpp">
+			</File>
+			<File
+				RelativePath=".\AI_Seeker.cpp">
+			</File>
+			<File
+				RelativePath=".\AI_Sentry.cpp">
+			</File>
+			<File
+				RelativePath=".\AI_Sniper.cpp">
+			</File>
+			<File
+				RelativePath=".\AI_Stormtrooper.cpp">
+			</File>
+			<File
+				RelativePath="AI_Tusken.cpp">
+			</File>
+			<File
+				RelativePath=".\AI_Utils.cpp">
+			</File>
+			<File
+				RelativePath="AI_Wampa.cpp">
+			</File>
+			<File
+				RelativePath=".\G_Timer.cpp">
+			</File>
+			<File
+				RelativePath=".\NPC.cpp">
+			</File>
+			<File
+				RelativePath=".\NPC_behavior.cpp">
+			</File>
+			<File
+				RelativePath=".\NPC_combat.cpp">
+			</File>
+			<File
+				RelativePath=".\NPC_goal.cpp">
+			</File>
+			<File
+				RelativePath=".\NPC_misc.cpp">
+			</File>
+			<File
+				RelativePath=".\NPC_move.cpp">
+			</File>
+			<File
+				RelativePath=".\NPC_reactions.cpp">
+			</File>
+			<File
+				RelativePath=".\NPC_senses.cpp">
+			</File>
+			<File
+				RelativePath=".\NPC_sounds.cpp">
+			</File>
+			<File
+				RelativePath=".\NPC_spawn.cpp">
+			</File>
+			<File
+				RelativePath=".\NPC_stats.cpp">
+			</File>
+			<File
+				RelativePath=".\NPC_utils.cpp">
+			</File>
+			<File
+				RelativePath="..\smartheap\SMRTHEAP.C">
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32"
+					ExcludedFromBuild="TRUE">
+					<Tool
+						Name="VCCLCompilerTool"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32"
+					ExcludedFromBuild="TRUE">
+					<Tool
+						Name="VCCLCompilerTool"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32"
+					ExcludedFromBuild="TRUE">
+					<Tool
+						Name="VCCLCompilerTool"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\g_active.cpp">
+			</File>
+			<File
+				RelativePath=".\g_breakable.cpp">
+			</File>
+			<File
+				RelativePath=".\g_camera.cpp">
+			</File>
+			<File
+				RelativePath=".\g_client.cpp">
+			</File>
+			<File
+				RelativePath=".\g_cmds.cpp">
+			</File>
+			<File
+				RelativePath=".\g_combat.cpp">
+			</File>
+			<File
+				RelativePath="g_emplaced.cpp">
+			</File>
+			<File
+				RelativePath=".\g_functions.cpp">
+			</File>
+			<File
+				RelativePath=".\g_fx.cpp">
+			</File>
+			<File
+				RelativePath=".\g_headers.cpp">
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="1"
+						PrecompiledHeaderThrough="../cgame/cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="1"
+						PrecompiledHeaderThrough="../cgame/cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="1"
+						PrecompiledHeaderThrough="../cgame/cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="1"
+						PrecompiledHeaderThrough="../cgame/cg_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\g_inventory.cpp">
+			</File>
+			<File
+				RelativePath=".\g_itemLoad.cpp">
+			</File>
+			<File
+				RelativePath=".\g_items.cpp">
+			</File>
+			<File
+				RelativePath=".\g_main.cpp">
+			</File>
+			<File
+				RelativePath=".\g_mem.cpp">
+			</File>
+			<File
+				RelativePath=".\g_misc.cpp">
+			</File>
+			<File
+				RelativePath=".\g_misc_model.cpp">
+			</File>
+			<File
+				RelativePath=".\g_missile.cpp">
+			</File>
+			<File
+				RelativePath=".\g_mover.cpp">
+			</File>
+			<File
+				RelativePath=".\g_nav.cpp">
+			</File>
+			<File
+				RelativePath=".\g_navigator.cpp">
+			</File>
+			<File
+				RelativePath=".\g_navnew.cpp">
+			</File>
+			<File
+				RelativePath=".\g_object.cpp">
+			</File>
+			<File
+				RelativePath=".\g_objectives.cpp">
+			</File>
+			<File
+				RelativePath="g_rail.cpp">
+			</File>
+			<File
+				RelativePath=".\g_ref.cpp">
+			</File>
+			<File
+				RelativePath=".\g_roff.cpp">
+			</File>
+			<File
+				RelativePath=".\g_savegame.cpp">
+			</File>
+			<File
+				RelativePath=".\g_session.cpp">
+			</File>
+			<File
+				RelativePath=".\g_spawn.cpp">
+			</File>
+			<File
+				RelativePath=".\g_svcmds.cpp">
+			</File>
+			<File
+				RelativePath=".\g_target.cpp">
+			</File>
+			<File
+				RelativePath=".\g_trigger.cpp">
+			</File>
+			<File
+				RelativePath=".\g_turret.cpp">
+			</File>
+			<File
+				RelativePath=".\g_usable.cpp">
+			</File>
+			<File
+				RelativePath=".\g_utils.cpp">
+			</File>
+			<File
+				RelativePath=".\g_weapon.cpp">
+			</File>
+			<File
+				RelativePath=".\g_weaponLoad.cpp">
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\win32\game.rc">
+			</File>
+			<File
+				RelativePath="..\ui\gameinfo.cpp">
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\genericparser2.cpp">
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\q_math.cpp">
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="common_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="common_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="common_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="common_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\q_shared.cpp">
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="common_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="common_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="common_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="common_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\qcommon\tri_coll_test.cpp">
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="common_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="common_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="common_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="common_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\wp_saber.cpp">
+			</File>
+			<File
+				RelativePath=".\wp_saberLoad.cpp">
+			</File>
+		</Filter>
+		<Filter
+			Name="Header Files"
+			Filter="h;hpp;hxx;hm;inl;fi;fd">
+			<File
+				RelativePath=".\AI.h">
+			</File>
+			<File
+				RelativePath="..\ghoul2\G2.h">
+			</File>
+			<File
+				RelativePath=".\anims.h">
+			</File>
+			<File
+				RelativePath=".\b_local.h">
+			</File>
+			<File
+				RelativePath=".\b_public.h">
+			</File>
+			<File
+				RelativePath=".\bg_local.h">
+			</File>
+			<File
+				RelativePath=".\bg_public.h">
+			</File>
+			<File
+				RelativePath=".\bset.h">
+			</File>
+			<File
+				RelativePath=".\bstate.h">
+			</File>
+			<File
+				RelativePath="..\cgame\cg_camera.h">
+			</File>
+			<File
+				RelativePath="..\cgame\cg_lights.h">
+			</File>
+			<File
+				RelativePath=".\channels.h">
+			</File>
+			<File
+				RelativePath=".\common_headers.h">
+			</File>
+			<File
+				RelativePath=".\dmstates.h">
+			</File>
+			<File
+				RelativePath=".\events.h">
+			</File>
+			<File
+				RelativePath="..\ff\ff.h">
+			</File>
+			<File
+				RelativePath="..\ff\ff_public.h">
+			</File>
+			<File
+				RelativePath="..\client\fffx.h">
+			</File>
+			<File
+				RelativePath=".\fields.h">
+			</File>
+			<File
+				RelativePath=".\g_functions.h">
+			</File>
+			<File
+				RelativePath=".\g_headers.h">
+			</File>
+			<File
+				RelativePath=".\g_items.h">
+			</File>
+			<File
+				RelativePath=".\g_local.h">
+			</File>
+			<File
+				RelativePath=".\g_nav.h">
+			</File>
+			<File
+				RelativePath=".\g_navigator.h">
+			</File>
+			<File
+				RelativePath=".\g_public.h">
+			</File>
+			<File
+				RelativePath=".\g_roff.h">
+			</File>
+			<File
+				RelativePath=".\g_shared.h">
+			</File>
+			<File
+				RelativePath="..\ui\gameinfo.h">
+			</File>
+			<File
+				RelativePath=".\genericparser2.h">
+			</File>
+			<File
+				RelativePath="..\ghoul2\ghoul2_gore.h">
+			</File>
+			<File
+				RelativePath=".\ghoul2_shared.h">
+			</File>
+			<File
+				RelativePath="hitlocs.h">
+			</File>
+			<File
+				RelativePath="..\renderer\mdx_format.h">
+			</File>
+			<File
+				RelativePath=".\npc_headers.h">
+			</File>
+			<File
+				RelativePath=".\objectives.h">
+			</File>
+			<File
+				RelativePath=".\q_shared.h">
+			</File>
+			<File
+				RelativePath=".\say.h">
+			</File>
+			<File
+				RelativePath="..\qcommon\sstring.h">
+			</File>
+			<File
+				RelativePath=".\statindex.h">
+			</File>
+			<File
+				RelativePath=".\surfaceflags.h">
+			</File>
+			<File
+				RelativePath="..\qcommon\tags.h">
+			</File>
+			<File
+				RelativePath=".\teams.h">
+			</File>
+			<File
+				RelativePath="..\qcommon\timing.h">
+			</File>
+			<File
+				RelativePath=".\weapons.h">
+			</File>
+			<File
+				RelativePath=".\wp_saber.h">
+			</File>
+		</Filter>
+		<Filter
+			Name="Resource Files"
+			Filter="ico;cur;bmp;dlg;rc2;rct;bin;cnt;rtf;gif;jpg;jpeg;jpe">
+			<File
+				RelativePath="..\smartheap\HAW32M.LIB">
+				<FileConfiguration
+					Name="Debug|Win32"
+					ExcludedFromBuild="TRUE">
+					<Tool
+						Name="VCCustomBuildTool"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32"
+					ExcludedFromBuild="TRUE">
+					<Tool
+						Name="VCCustomBuildTool"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32"
+					ExcludedFromBuild="TRUE">
+					<Tool
+						Name="VCCustomBuildTool"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\game.def">
+			</File>
+		</Filter>
+		<Filter
+			Name="ICARUS"
+			Filter="*.cpp, *.h">
+			<File
+				RelativePath="..\icarus\BlockStream.cpp">
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						PrecompiledHeaderThrough=""
+						PrecompiledHeaderFile=" "/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						PrecompiledHeaderThrough=""
+						PrecompiledHeaderFile=" "/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						PrecompiledHeaderThrough=""
+						PrecompiledHeaderFile=" "/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						PrecompiledHeaderThrough=""
+						PrecompiledHeaderFile=" "/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\icarus\IcarusImplementation.cpp">
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						PrecompiledHeaderThrough=""
+						PrecompiledHeaderFile=" "/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						PrecompiledHeaderThrough=""
+						PrecompiledHeaderFile=" "/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						PrecompiledHeaderThrough=""
+						PrecompiledHeaderFile=" "/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						PrecompiledHeaderThrough=""
+						PrecompiledHeaderFile=" "/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\icarus\IcarusImplementation.h">
+			</File>
+			<File
+				RelativePath="..\icarus\IcarusInterface.h">
+			</File>
+			<File
+				RelativePath=".\Q3_Interface.cpp">
+			</File>
+			<File
+				RelativePath=".\Q3_Interface.h">
+			</File>
+			<File
+				RelativePath="..\icarus\Sequence.cpp">
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						PrecompiledHeaderThrough=""
+						PrecompiledHeaderFile=" "/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						PrecompiledHeaderThrough=""
+						PrecompiledHeaderFile=" "/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						PrecompiledHeaderThrough=""
+						PrecompiledHeaderFile=" "/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						PrecompiledHeaderThrough=""
+						PrecompiledHeaderFile=" "/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\icarus\Sequencer.cpp">
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						PrecompiledHeaderThrough=""
+						PrecompiledHeaderFile=" "/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						PrecompiledHeaderThrough=""
+						PrecompiledHeaderFile=" "/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						PrecompiledHeaderThrough=""
+						PrecompiledHeaderFile=" "/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						PrecompiledHeaderThrough=""
+						PrecompiledHeaderFile=" "/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\icarus\StdAfx.h">
+			</File>
+			<File
+				RelativePath="..\icarus\TaskManager.cpp">
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						PrecompiledHeaderThrough=""
+						PrecompiledHeaderFile=" "/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						PrecompiledHeaderThrough=""
+						PrecompiledHeaderFile=" "/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						PrecompiledHeaderThrough=""
+						PrecompiledHeaderFile=" "/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						PrecompiledHeaderThrough=""
+						PrecompiledHeaderFile=" "/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\icarus\blockstream.h">
+			</File>
+			<File
+				RelativePath="..\icarus\sequence.h">
+			</File>
+			<File
+				RelativePath="..\icarus\sequencer.h">
+			</File>
+			<File
+				RelativePath="..\icarus\taskmanager.h">
+			</File>
+		</Filter>
+		<Filter
+			Name="Cgame"
+			Filter="*.cpp">
+			<File
+				RelativePath="..\cgame\FX_ATSTMain.cpp">
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\cgame\FX_Blaster.cpp">
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\cgame\FX_Bowcaster.cpp">
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\cgame\FX_BryarPistol.cpp">
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\cgame\FX_Concussion.cpp">
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"
+						PrecompiledHeaderFile=".\..\Release\game/game.pch"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\cgame\FX_DEMP2.cpp">
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\cgame\FX_Disruptor.cpp">
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\cgame\FX_Emplaced.cpp">
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\cgame\FX_Flechette.cpp">
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\cgame\FX_HeavyRepeater.cpp">
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\cgame\FX_NoghriShot.cpp">
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\cgame\FX_RocketLauncher.cpp">
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\cgame\FX_TuskenShot.cpp">
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\cgame\FxPrimitives.cpp">
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="common_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="common_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="common_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="common_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\cgame\FxScheduler.cpp">
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="common_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="common_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="common_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="common_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\cgame\FxSystem.cpp">
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="common_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="common_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="common_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="common_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\cgame\FxTemplate.cpp">
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="common_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="common_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="common_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="common_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\cgame\FxUtil.cpp">
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="common_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="common_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="common_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="common_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\bg_lib.cpp">
+				<FileConfiguration
+					Name="SHDebug|Win32"
+					ExcludedFromBuild="TRUE">
+					<Tool
+						Name="VCCLCompilerTool"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32"
+					ExcludedFromBuild="TRUE">
+					<Tool
+						Name="VCCLCompilerTool"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32"
+					ExcludedFromBuild="TRUE">
+					<Tool
+						Name="VCCLCompilerTool"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32"
+					ExcludedFromBuild="TRUE">
+					<Tool
+						Name="VCCLCompilerTool"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\bg_misc.cpp">
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="common_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="common_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="common_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="common_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\bg_pangles.cpp">
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="common_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="common_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="common_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="common_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\bg_panimate.cpp">
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="common_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="common_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="common_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="common_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\bg_pmove.cpp">
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="common_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="common_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="common_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="common_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\bg_slidemove.cpp">
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="common_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="common_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="common_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="common_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\cgame\cg_camera.cpp">
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\cgame\cg_consolecmds.cpp">
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\cgame\cg_credits.cpp">
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\cgame\cg_draw.cpp">
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\cgame\cg_drawtools.cpp">
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\cgame\cg_effects.cpp">
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\cgame\cg_ents.cpp">
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\cgame\cg_event.cpp">
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\cgame\cg_headers.cpp">
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\cgame\cg_info.cpp">
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\cgame\cg_lights.cpp">
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\cgame\cg_localents.cpp">
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\cgame\cg_main.cpp">
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\cgame\cg_marks.cpp">
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\cgame\cg_players.cpp">
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\cgame\cg_playerstate.cpp">
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\cgame\cg_predict.cpp">
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\cgame\cg_scoreboard.cpp">
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\cgame\cg_servercmds.cpp">
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\cgame\cg_snapshot.cpp">
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\cgame\cg_syscalls.cpp">
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\cgame\cg_text.cpp">
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\cgame\cg_view.cpp">
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\cgame\cg_weapons.cpp">
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						PrecompiledHeaderThrough="cg_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<Filter
+				Name="CGame Headers"
+				Filter="*.h">
+				<File
+					RelativePath="..\cgame\FxParsing.h">
+				</File>
+				<File
+					RelativePath="..\cgame\FxPrimitives.h">
+				</File>
+				<File
+					RelativePath="..\cgame\FxScheduler.h">
+				</File>
+				<File
+					RelativePath="..\cgame\FxSystem.h">
+				</File>
+				<File
+					RelativePath="..\cgame\FxUtil.h">
+				</File>
+				<File
+					RelativePath="..\cgame\animtable.h">
+				</File>
+				<File
+					RelativePath="..\cgame\cg_headers.h">
+				</File>
+				<File
+					RelativePath="..\cgame\cg_local.h">
+				</File>
+				<File
+					RelativePath="..\cgame\cg_media.h">
+				</File>
+				<File
+					RelativePath="..\cgame\cg_public.h">
+				</File>
+				<File
+					RelativePath="..\cgame\common_headers.h">
+				</File>
+				<File
+					RelativePath="..\cgame\strip_objectives.h">
+				</File>
+				<File
+					RelativePath="..\renderer\tr_types.h">
+				</File>
+				<File
+					RelativePath="..\client\vmachine.h">
+				</File>
+			</Filter>
+		</Filter>
+		<Filter
+			Name="Ratl"
+			Filter="">
+			<File
+				RelativePath="..\Ratl\array_vs.h">
+			</File>
+			<File
+				RelativePath="..\Ratl\bits_vs.h">
+			</File>
+			<File
+				RelativePath="..\Ratl\grid_vs.h">
+			</File>
+			<File
+				RelativePath="..\Ratl\handle_pool_vs.h">
+			</File>
+			<File
+				RelativePath="..\Ratl\hash_pool_vs.h">
+			</File>
+			<File
+				RelativePath="..\Ratl\heap_vs.h">
+			</File>
+			<File
+				RelativePath="..\Ratl\list_vs.h">
+			</File>
+			<File
+				RelativePath="..\Ratl\map_vs.h">
+			</File>
+			<File
+				RelativePath="..\Ratl\pool_vs.h">
+			</File>
+			<File
+				RelativePath="..\Ratl\queue_vs.h">
+			</File>
+			<File
+				RelativePath="..\Ratl\ratl.cpp">
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\Ratl\ratl_common.h">
+			</File>
+			<File
+				RelativePath="..\Ratl\scheduler_vs.h">
+			</File>
+			<File
+				RelativePath="..\Ratl\stack_vs.h">
+			</File>
+			<File
+				RelativePath="..\Ratl\string_vs.h">
+			</File>
+			<File
+				RelativePath="..\Ratl\vector_vs.h">
+			</File>
+		</Filter>
+		<Filter
+			Name="Ragl"
+			Filter="">
+			<File
+				RelativePath="..\Ragl\graph_region.h">
+			</File>
+			<File
+				RelativePath="..\Ragl\graph_triangulate.h">
+			</File>
+			<File
+				RelativePath="..\Ragl\graph_vs.h">
+			</File>
+			<File
+				RelativePath="..\Ragl\kdtree_vs.h">
+			</File>
+			<File
+				RelativePath="..\Ragl\ragl_common.h">
+			</File>
+		</Filter>
+		<Filter
+			Name="Ravl"
+			Filter="">
+			<File
+				RelativePath="..\Ravl\CBounds.cpp">
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\Ravl\CBounds.h">
+			</File>
+			<File
+				RelativePath="..\Ravl\CMatrix.h">
+			</File>
+			<File
+				RelativePath="..\Ravl\CVec.cpp">
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\Ravl\CVec.h">
+			</File>
+		</Filter>
+		<Filter
+			Name="Rufl"
+			Filter="">
+			<File
+				RelativePath="..\Rufl\hfile.cpp">
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\Rufl\hfile.h">
+			</File>
+			<File
+				RelativePath="..\Rufl\hstring.cpp">
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\Rufl\hstring.h">
+			</File>
+			<File
+				RelativePath="..\Rufl\random.cpp">
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\Rufl\random.h">
+			</File>
+		</Filter>
+		<Filter
+			Name="Vehicles"
+			Filter="">
+			<File
+				RelativePath="AnimalNPC.c">
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="FighterNPC.c">
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="SpeederNPC.c">
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						PrecompiledHeaderThrough=""
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="WalkerNPC.c">
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						PrecompiledHeaderThrough=""
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						PrecompiledHeaderThrough=""
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="bg_vehicleLoad.c">
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="g_vehicles.c">
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="g_vehicles.h">
+			</File>
+		</Filter>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>
diff --git a/code/game/game.vcproj.vspscc b/code/game/game.vcproj.vspscc
new file mode 100644
index 0000000..794f014
--- /dev/null
+++ b/code/game/game.vcproj.vspscc
@@ -0,0 +1,10 @@
+""
+{
+"FILE_VERSION" = "9237"
+"ENLISTMENT_CHOICE" = "NEVER"
+"PROJECT_FILE_RELATIVE_PATH" = ""
+"NUMBER_OF_EXCLUDED_FILES" = "0"
+"ORIGINAL_PROJECT_FILE_PATH" = ""
+"NUMBER_OF_NESTED_PROJECTS" = "0"
+"SOURCE_CONTROL_SETTINGS_PROVIDER" = "PROJECT"
+}
diff --git a/code/game/genericparser2.cpp b/code/game/genericparser2.cpp
new file mode 100644
index 0000000..fa61fd7
--- /dev/null
+++ b/code/game/genericparser2.cpp
@@ -0,0 +1,1136 @@
+// Filename:-	genericparser2.cpp
+
+// leave this at the top for PCH reasons...
+
+#include "common_headers.h"
+
+#ifdef _JK2EXE
+#include "../qcommon/qcommon.h"
+#else
+#include "g_headers.h"
+#endif
+
+
+
+
+
+
+//#define _EXE
+
+
+#define MAX_TOKEN_SIZE	1024
+static char	token[MAX_TOKEN_SIZE];
+
+static char *GetToken(char **text, bool allowLineBreaks, bool readUntilEOL = false)
+{
+	char	*pointer = *text;
+	int		length = 0;
+	int		c = 0;
+	bool	foundLineBreak;
+
+	token[0] = 0;
+	if (!pointer)
+	{
+		return token;
+	}
+
+	while(1)
+	{
+		foundLineBreak = false;
+		while(1)
+		{
+			c = *pointer;
+			if (c > ' ')
+			{
+				break;
+			}
+			if (!c)
+			{
+				*text = 0;
+				return token;
+			}
+			if (c == '\n')
+			{
+				foundLineBreak = true;
+			}
+			pointer++;
+		}
+		if (foundLineBreak && !allowLineBreaks)
+		{
+			*text = pointer;
+			return token;
+		}
+
+		c = *pointer;
+
+		// skip single line comment
+		if (c == '/' && pointer[1] == '/')
+		{
+			pointer += 2;
+			while (*pointer && *pointer != '\n') 
+			{
+				pointer++;
+			}
+		}
+		// skip multi line comments
+		else if (c == '/' && pointer[1] == '*') 
+		{
+			pointer += 2;
+			while (*pointer && (*pointer != '*' || pointer[1] != '/')) 
+			{
+				pointer++;
+			}
+			if (*pointer) 
+			{
+				pointer += 2;
+			}
+		}
+		else
+		{	// found the start of a token
+			break;
+		}
+	}
+
+	if (c == '\"')
+	{	// handle a string
+		pointer++;
+		while (1)
+		{
+			c = *pointer++;
+			if (c == '\"')
+			{
+//				token[length++] = c;
+				break;
+			}
+			else if (!c)
+			{
+				break;
+			}
+			else if (length < MAX_TOKEN_SIZE)
+			{
+				token[length++] = c;
+			}
+		}
+	}
+	else if (readUntilEOL)
+	{
+		// absorb all characters until EOL
+		while(c != '\n' && c != '\r')
+		{
+			if (c == '/' && ((*(pointer+1)) == '/' || (*(pointer+1)) == '*'))
+			{
+				break;
+			}
+
+			if (length < MAX_TOKEN_SIZE)
+			{
+				token[length++] = c;
+			}
+			pointer++;
+			c = *pointer;
+		}
+		// remove trailing white space
+		while(length && token[length-1] < ' ')
+		{
+			length--;
+		}
+	}
+	else
+	{
+		while(c > ' ')
+		{
+			if (length < MAX_TOKEN_SIZE)
+			{
+				token[length++] = c;
+			}
+			pointer++;
+			c = *pointer;
+		}
+	}
+
+	if (token[0] == '\"')
+	{	// remove start quote
+		length--;
+		memmove(token, token+1, length);
+
+		if (length && token[length-1] == '\"')
+		{	// remove end quote
+			length--;
+		}
+	}
+
+	if (length >= MAX_TOKEN_SIZE)
+	{
+		length = 0;
+	}
+	token[length] = 0;
+	*text = (char *)pointer;
+
+	return token;
+}
+
+
+
+
+CTextPool::CTextPool(int initSize) :
+	mNext(0),
+	mSize(initSize),
+	mUsed(0)
+{
+#ifdef _EXE
+//	mPool = (char *)Z_Malloc(mSize, TAG_GP2);
+	mPool = (char *)Z_Malloc(mSize, TAG_TEXTPOOL, qtrue);
+#else
+	mPool = (char *)trap_Z_Malloc(mSize, TAG_GP2);
+#endif
+}
+
+CTextPool::~CTextPool(void)
+{
+#ifdef _EXE
+	Z_Free(mPool);
+#else
+	trap_Z_Free(mPool);
+#endif
+}
+
+char *CTextPool::AllocText(char *text, bool addNULL, CTextPool **poolPtr)
+{
+	int	length = strlen(text) + (addNULL ? 1 : 0);
+
+	if (mUsed + length + 1> mSize)
+	{	// extra 1 to put a null on the end
+		if (poolPtr)
+		{
+			(*poolPtr)->SetNext(new CTextPool(mSize));
+			*poolPtr = (*poolPtr)->GetNext();
+
+			return (*poolPtr)->AllocText(text, addNULL);
+		}
+
+		return 0;
+	}
+
+	strcpy(mPool + mUsed, text);
+	mUsed += length;
+	mPool[mUsed] = 0;
+
+	return mPool + mUsed - length;
+}
+
+void CleanTextPool(CTextPool *pool)
+{
+	CTextPool *next;
+
+	while(pool)
+	{
+		next = pool->GetNext();
+		delete pool;
+		pool = next;
+	}
+}
+
+
+
+
+
+
+
+CGPObject::CGPObject(const char *initName) :
+	mName(initName),
+	mNext(0),
+	mInOrderNext(0),
+	mInOrderPrevious(0)
+{
+}
+
+bool CGPObject::WriteText(CTextPool **textPool, const char *text)
+{
+   if (strchr(text, ' ') || !text[0])
+   {
+	   (*textPool)->AllocText("\"", false, textPool);
+	   (*textPool)->AllocText((char *)text, false, textPool);
+	   (*textPool)->AllocText("\"", false, textPool);
+   }
+   else
+   {
+	   (*textPool)->AllocText((char *)text, false, textPool);
+   }
+
+   return true;
+}
+
+
+	
+	
+	
+
+
+
+
+
+
+	
+	
+
+CGPValue::CGPValue(const char *initName, const char *initValue) :
+	CGPObject(initName),
+	mList(0)
+{
+	if (initValue)
+	{
+		AddValue(initValue);
+	}
+}
+
+CGPValue::~CGPValue(void)
+{
+	CGPObject	*next;
+
+	while(mList)
+	{
+		next = mList->GetNext();
+		delete mList;
+		mList = next;
+	}
+}
+
+CGPValue *CGPValue::Duplicate(CTextPool **textPool)
+{
+	CGPValue	*newValue;
+	CGPObject	*iterator;
+	char		*name;
+
+	if (textPool)
+	{
+		name = (*textPool)->AllocText((char *)mName, true, textPool);
+	}
+	else
+	{
+		name = (char *)mName;
+	}
+
+	newValue = new CGPValue(name);
+	iterator = mList;
+	while(iterator)
+	{
+		if (textPool)
+		{
+			name = (*textPool)->AllocText((char *)iterator->GetName(), true, textPool);
+		}
+		else
+		{
+			name = (char *)iterator->GetName();
+		}
+		newValue->AddValue(name);
+		iterator = iterator->GetNext();
+	}
+
+	return newValue;
+}
+
+bool CGPValue::IsList(void)
+{
+	if (!mList || !mList->GetNext())
+	{
+		return false;
+	}
+
+	return true;
+}
+
+const char *CGPValue::GetTopValue(void) 
+{ 
+	if (mList)
+	{
+		return mList->GetName();
+	}
+
+	return 0;
+}
+
+void CGPValue::AddValue(const char *newValue, CTextPool **textPool)
+{
+	if (textPool)
+	{
+		newValue = (*textPool)->AllocText((char *)newValue, true, textPool);
+	}
+
+	if (mList == 0)
+	{
+		mList = new CGPObject(newValue);
+		mList->SetInOrderNext(mList);
+	}
+	else
+	{
+		mList->GetInOrderNext()->SetNext(new CGPObject(newValue));
+		mList->SetInOrderNext(mList->GetInOrderNext()->GetNext());
+	}
+}
+
+bool CGPValue::Parse(char **dataPtr, CTextPool **textPool)
+{
+	char		*token;
+	char		*value;
+
+	while(1)
+	{
+		token = GetToken(dataPtr, true, true);
+
+		if (!token[0])
+		{	// end of data - error!
+			return false;
+		}
+		else if (strcmpi(token, "]") == 0)
+		{	// ending brace for this list
+			break;
+		}
+
+		value = (*textPool)->AllocText(token, true, textPool);
+		AddValue(value);
+	}
+
+	return true;
+}
+
+bool CGPValue::Write(CTextPool **textPool, int depth)
+{
+	int				i;
+	CGPObject	*next;
+
+	if (!mList)
+	{
+		return true;
+	}
+
+	for(i=0;i<depth;i++)
+	{
+		(*textPool)->AllocText("\t", false, textPool);
+	}
+
+	WriteText(textPool, mName);
+
+	if (!mList->GetNext())
+	{
+		(*textPool)->AllocText("\t\t", false, textPool);
+		mList->WriteText(textPool, mList->GetName());
+		(*textPool)->AllocText("\r\n", false, textPool);
+	}
+	else
+	{
+		(*textPool)->AllocText("\r\n", false, textPool);
+
+		for(i=0;i<depth;i++)
+		{
+			(*textPool)->AllocText("\t", false, textPool);
+		}
+		(*textPool)->AllocText("[\r\n", false, textPool);
+
+		next = mList;
+		while(next)
+		{
+			for(i=0;i<depth+1;i++)
+			{
+				(*textPool)->AllocText("\t", false, textPool);
+			}
+			mList->WriteText(textPool, next->GetName());
+			(*textPool)->AllocText("\r\n", false, textPool);
+
+			next = next->GetNext();
+		}
+
+		for(i=0;i<depth;i++)
+		{
+			(*textPool)->AllocText("\t", false, textPool);
+		}
+		(*textPool)->AllocText("]\r\n", false, textPool);
+	}
+
+	return true;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+CGPGroup::CGPGroup(const char *initName, CGPGroup *initParent) :
+	CGPObject(initName),
+	mPairs(0),
+	mInOrderPairs(0),
+	mCurrentPair(0),
+	mSubGroups(0),
+	mInOrderSubGroups(0),
+	mCurrentSubGroup(0),
+	mParent(initParent),
+	mWriteable(false)
+{
+}
+
+CGPGroup::~CGPGroup(void)
+{
+	Clean();
+}
+
+int CGPGroup::GetNumSubGroups(void)
+{
+	int			count;
+	CGPGroup	*group;
+
+	count = 0;
+	group = mSubGroups;
+	while(group)
+	{
+		count++;
+		group = (CGPGroup *)group->GetNext();
+	}
+
+	return(count);
+}
+
+int CGPGroup::GetNumPairs(void)
+{
+	int			count;
+	CGPValue	*pair;
+
+	count = 0;
+	pair = mPairs;
+	while(pair)
+	{
+		count++;
+		pair = (CGPValue *)pair->GetNext();
+	}
+
+	return(count);
+}
+
+void CGPGroup::Clean(void)
+{
+	while(mPairs)
+	{
+		mCurrentPair = (CGPValue *)mPairs->GetNext();
+		delete mPairs;
+		mPairs = mCurrentPair;
+	}
+
+	while(mSubGroups)
+	{
+		mCurrentSubGroup = (CGPGroup *)mSubGroups->GetNext();
+		delete mSubGroups;
+		mSubGroups = mCurrentSubGroup;
+	}
+
+	mPairs = mInOrderPairs = mCurrentPair = 0;
+	mSubGroups = mInOrderSubGroups = mCurrentSubGroup = 0;
+	mParent = 0;
+	mWriteable = false;
+}
+
+CGPGroup *CGPGroup::Duplicate(CTextPool **textPool, CGPGroup *initParent)
+{
+	CGPGroup	*newGroup, *subSub, *newSub;
+	CGPValue	*newPair, *subPair;
+	char		*name;
+
+	if (textPool)
+	{
+		name = (*textPool)->AllocText((char *)mName, true, textPool);
+	}
+	else
+	{
+		name = (char *)mName;
+	}
+
+	newGroup = new CGPGroup(name);
+
+	subSub = mSubGroups;
+	while(subSub)
+	{
+		newSub = subSub->Duplicate(textPool, newGroup);
+		newGroup->AddGroup(newSub);
+
+		subSub = (CGPGroup *)subSub->GetNext();
+	}
+
+	subPair = mPairs;
+	while(subPair)
+	{
+		newPair = subPair->Duplicate(textPool);
+		newGroup->AddPair(newPair);
+
+		subPair = (CGPValue *)subPair->GetNext();
+	}
+
+	return newGroup;
+}
+
+void CGPGroup::SortObject(CGPObject *object, CGPObject **unsortedList, CGPObject **sortedList,
+							 CGPObject **lastObject)
+{
+	CGPObject	*test, *last;
+
+	if (!*unsortedList)
+	{
+		*unsortedList = *sortedList = object;
+	}
+	else
+	{
+		(*lastObject)->SetNext(object);
+
+		test = *sortedList;
+		last = 0;
+		while(test)
+		{
+			if (strcmpi(object->GetName(), test->GetName()) < 0)
+			{
+				break;
+			}
+
+			last = test;
+			test = test->GetInOrderNext();
+		}
+
+		if (test)
+		{
+			test->SetInOrderPrevious(object);
+			object->SetInOrderNext(test);
+		}
+		if (last)
+		{
+			last->SetInOrderNext(object);
+			object->SetInOrderPrevious(last);
+		}
+		else
+		{
+			*sortedList = object;
+		}
+	}
+
+	*lastObject = object;
+}
+
+CGPValue *CGPGroup::AddPair(const char *name, const char *value, CTextPool **textPool)
+{
+	CGPValue	*newPair;
+
+	if (textPool)
+	{
+		name = (*textPool)->AllocText((char *)name, true, textPool);
+		if (value)
+		{
+			value = (*textPool)->AllocText((char *)value, true, textPool);
+		}
+	}
+
+	newPair = new CGPValue(name, value);
+
+	AddPair(newPair);
+
+	return newPair;
+}
+
+void CGPGroup::AddPair(CGPValue *NewPair)
+{
+	SortObject(NewPair, (CGPObject **)&mPairs, (CGPObject **)&mInOrderPairs, 
+		(CGPObject **)&mCurrentPair);
+}
+
+CGPGroup *CGPGroup::AddGroup(const char *name, CTextPool **textPool)
+{
+	CGPGroup	*newGroup;
+
+	if (textPool)
+	{
+		name = (*textPool)->AllocText((char *)name, true, textPool);
+	}
+
+	newGroup = new CGPGroup(name);
+
+	AddGroup(newGroup);
+
+	return newGroup;
+}
+	
+void CGPGroup::AddGroup(CGPGroup *NewGroup)
+{
+	SortObject(NewGroup, (CGPObject **)&mSubGroups, (CGPObject **)&mInOrderSubGroups, 
+		(CGPObject **)&mCurrentSubGroup);
+}
+	
+CGPGroup *CGPGroup::FindSubGroup(const char *name)
+{
+	CGPGroup	*group;
+
+	group = mSubGroups;
+	while(group)
+	{
+		if(!stricmp(name, group->GetName()))
+		{
+			return(group);
+		}
+		group = (CGPGroup *)group->GetNext();
+	}
+	return(NULL);
+}
+
+bool CGPGroup::Parse(char **dataPtr, CTextPool **textPool)
+{
+	char		*token;
+	char		lastToken[MAX_TOKEN_SIZE];
+	CGPGroup	*newSubGroup;
+	CGPValue	*newPair;
+
+	while(1)
+	{
+		token = GetToken(dataPtr, true);
+
+		if (!token[0])
+		{	// end of data - error!
+			if (mParent)
+			{
+				return false;
+			}
+			else
+			{
+				break;
+			}
+		}
+		else if (strcmpi(token, "}") == 0)
+		{	// ending brace for this group
+			break;
+		}
+
+		strcpy(lastToken, token);
+
+		// read ahead to see what we are doing
+		token = GetToken(dataPtr, true, true);
+		if (strcmpi(token, "{") == 0)
+		{	// new sub group
+			newSubGroup = AddGroup(lastToken, textPool);
+			newSubGroup->SetWriteable(mWriteable);
+			if (!newSubGroup->Parse(dataPtr, textPool))
+			{
+				return false;
+			}
+		}
+		else if (strcmpi(token, "[") == 0)
+		{	// new pair list
+			newPair = AddPair(lastToken, 0, textPool);
+			if (!newPair->Parse(dataPtr, textPool))
+			{
+				return false;
+			}
+		}
+		else
+		{	// new pair
+			AddPair(lastToken, token, textPool);
+		}
+	}
+
+	return true;
+}
+
+bool CGPGroup::Write(CTextPool **textPool, int depth)
+{
+	int				i;
+	CGPValue		*mPair = mPairs;
+	CGPGroup		*mSubGroup = mSubGroups;
+
+	if (depth >= 0)
+	{
+		for(i=0;i<depth;i++)
+		{
+			(*textPool)->AllocText("\t", false, textPool);
+		}
+		WriteText(textPool, mName);
+		(*textPool)->AllocText("\r\n", false, textPool);
+		
+		for(i=0;i<depth;i++)
+		{
+			(*textPool)->AllocText("\t", false, textPool);
+		}
+		(*textPool)->AllocText("{\r\n", false, textPool);
+	}
+
+	while(mPair)
+	{
+		mPair->Write(textPool, depth+1);
+		mPair = (CGPValue *)mPair->GetNext();
+	}
+
+	while(mSubGroup)
+	{
+		mSubGroup->Write(textPool, depth+1);
+		mSubGroup = (CGPGroup *)mSubGroup->GetNext();
+	}
+
+	if (depth >= 0)
+	{
+		for(i=0;i<depth;i++)
+		{
+			(*textPool)->AllocText("\t", false, textPool);
+		}
+		(*textPool)->AllocText("}\r\n", false, textPool);
+	}
+
+	return true;
+}
+
+CGPValue *CGPGroup::FindPair(const char *key)
+{
+	CGPValue		*pair = mPairs;
+
+	while(pair)
+	{
+		if (strcmpi(pair->GetName(), key) == 0)
+		{
+			return pair;
+		}
+
+		pair = pair->GetNext();
+	}
+
+	return 0;	
+}
+
+const char *CGPGroup::FindPairValue(const char *key, const char *defaultVal)
+{
+	CGPValue		*pair = FindPair(key);
+
+	if (pair)
+	{
+		return pair->GetTopValue();
+	}
+
+	return defaultVal;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+CGenericParser2::CGenericParser2(void) :
+	mTextPool(0),
+	mWriteable(false)
+{
+}
+
+CGenericParser2::~CGenericParser2(void)
+{
+	Clean();
+}
+
+bool CGenericParser2::Parse(char **dataPtr, bool cleanFirst, bool writeable)
+{
+	CTextPool	*topPool;
+
+#ifdef _XBOX
+	// Parsers are temporary structures.  They exist mainly at load time.
+	extern void Z_SetNewDeleteTemporary(bool bTemp);
+	Z_SetNewDeleteTemporary(true);
+#endif
+
+	if (cleanFirst)
+	{
+		Clean();
+	}
+
+	if (!mTextPool)
+	{
+		mTextPool = new CTextPool;
+	}
+
+	SetWriteable(writeable);
+	mTopLevel.SetWriteable(writeable);
+	topPool = mTextPool;
+	bool ret = mTopLevel.Parse(dataPtr, &topPool);
+
+#ifdef _XBOX
+	Z_SetNewDeleteTemporary(false);
+#endif
+
+	return ret;
+}
+
+void CGenericParser2::Clean(void)
+{
+	mTopLevel.Clean();
+
+	CleanTextPool(mTextPool);
+	mTextPool = 0;
+}
+
+bool CGenericParser2::Write(CTextPool *textPool)
+{
+	return mTopLevel.Write(&textPool, -1);
+}
+
+
+
+
+
+
+
+
+
+// The following groups of routines are used for a C interface into GP2.
+// C++ users should just use the objects as normally and not call these routines below
+//
+// CGenericParser2 (void *) routines
+TGenericParser2 GP_Parse(char **dataPtr, bool cleanFirst, bool writeable)
+{
+	CGenericParser2		*parse;
+
+	parse = new CGenericParser2;
+	if (parse->Parse(dataPtr, cleanFirst, writeable))
+	{
+		return parse;
+	}
+
+	delete parse;
+	return 0;
+}
+
+void GP_Clean(TGenericParser2 GP2)
+{
+	if (!GP2)
+	{
+		return;
+	}
+
+	((CGenericParser2 *)GP2)->Clean();
+}
+
+void GP_Delete(TGenericParser2 *GP2)
+{
+	if (!GP2 || !(*GP2))
+	{
+		return;
+	}
+
+	delete ((CGenericParser2 *)(*GP2));
+	(*GP2) = 0;
+}
+
+TGPGroup GP_GetBaseParseGroup(TGenericParser2 GP2)
+{
+	if (!GP2)
+	{
+		return 0;
+	}
+	
+	return ((CGenericParser2 *)GP2)->GetBaseParseGroup();
+}
+
+
+
+
+// CGPGroup (void *) routines
+const char	*GPG_GetName(TGPGroup GPG)
+{
+	if (!GPG)
+	{
+		return "";
+	}
+
+	return ((CGPGroup *)GPG)->GetName();
+}
+
+TGPGroup GPG_GetNext(TGPGroup GPG)
+{
+	if (!GPG)
+	{
+		return 0;
+	}
+
+	return ((CGPGroup *)GPG)->GetNext();
+}
+
+TGPGroup GPG_GetInOrderNext(TGPGroup GPG)
+{
+	if (!GPG)
+	{
+		return 0;
+	}
+
+	return ((CGPGroup *)GPG)->GetInOrderNext();
+}
+
+TGPGroup GPG_GetInOrderPrevious(TGPGroup GPG)
+{
+	if (!GPG)
+	{
+		return 0;
+	}
+
+	return ((CGPGroup *)GPG)->GetInOrderPrevious();
+}
+
+TGPGroup GPG_GetPairs(TGPGroup GPG)
+{
+	if (!GPG)
+	{
+		return 0;
+	}
+
+	return ((CGPGroup *)GPG)->GetPairs();
+}
+
+TGPGroup GPG_GetInOrderPairs(TGPGroup GPG)
+{
+	if (!GPG)
+	{
+		return 0;
+	}
+
+	return ((CGPGroup *)GPG)->GetInOrderPairs();
+}
+
+TGPGroup GPG_GetSubGroups(TGPGroup GPG)
+{
+	if (!GPG)
+	{
+		return 0;
+	}
+
+	return ((CGPGroup *)GPG)->GetSubGroups();
+}
+
+TGPGroup GPG_GetInOrderSubGroups(TGPGroup GPG)
+{
+	if (!GPG)
+	{
+		return 0;
+	}
+
+	return ((CGPGroup *)GPG)->GetInOrderSubGroups();
+}
+
+TGPGroup GPG_FindSubGroup(TGPGroup GPG, const char *name)
+{
+	if (!GPG)
+	{
+		return 0;
+	}
+
+	return ((CGPGroup *)GPG)->FindSubGroup(name);
+}
+
+TGPValue GPG_FindPair(TGPGroup GPG, const char *key)
+{
+	if (!GPG)
+	{
+		return 0;
+	}
+
+	return ((CGPGroup *)GPG)->FindPair(key);
+}
+
+const char *GPG_FindPairValue(TGPGroup GPG, const char *key, const char *defaultVal)
+{
+	if (!GPG)
+	{
+		return defaultVal;
+	}
+
+	return ((CGPGroup *)GPG)->FindPairValue(key, defaultVal);
+}
+
+
+
+
+// CGPValue (void *) routines
+const char	*GPV_GetName(TGPValue GPV)
+{
+	if (!GPV)
+	{
+		return "";
+	}
+
+	return ((CGPValue *)GPV)->GetName();
+}
+
+TGPValue GPV_GetNext(TGPValue GPV)
+{
+	if (!GPV)
+	{
+		return 0;
+	}
+
+	return ((CGPValue *)GPV)->GetNext();
+}
+
+TGPValue GPV_GetInOrderNext(TGPValue GPV)
+{
+	if (!GPV)
+	{
+		return 0;
+	}
+
+	return ((CGPValue *)GPV)->GetInOrderNext();
+}
+
+TGPValue GPV_GetInOrderPrevious(TGPValue GPV)
+{
+	if (!GPV)
+	{
+		return 0;
+	}
+
+	return ((CGPValue *)GPV)->GetInOrderPrevious();
+}
+
+bool GPV_IsList(TGPValue GPV)
+{
+	if (!GPV)
+	{
+		return 0;
+	}
+
+	return ((CGPValue *)GPV)->IsList();
+}
+
+const char *GPV_GetTopValue(TGPValue GPV)
+{
+	if (!GPV)
+	{
+		return "";
+	}
+
+	return ((CGPValue *)GPV)->GetTopValue();
+}
+
+TGPValue GPV_GetList(TGPValue GPV)
+{
+	if (!GPV)
+	{
+		return 0;
+	}
+
+	return ((CGPValue *)GPV)->GetList();
+}
+
+
+
+//////////////////// eof /////////////////////
+
diff --git a/code/game/genericparser2.h b/code/game/genericparser2.h
new file mode 100644
index 0000000..e0975d9
--- /dev/null
+++ b/code/game/genericparser2.h
@@ -0,0 +1,211 @@
+// Filename:-	genericparser2.h
+
+
+#ifndef GENERICPARSER2_H
+#define GENERICPARSER2_H
+
+
+// conditional expression is constant
+// conversion from int to char, possible loss of data
+// unreferenced inline funciton has been removed
+#pragma warning( disable : 4127 4244 4514 )
+
+
+#ifdef DEBUG_LINKING
+	#pragma message("...including GenericParser2.h")
+#endif
+
+//#include "disablewarnings.h"
+
+#ifdef _JK2EXE
+#define trap_Z_Malloc(x, y)		Z_Malloc(x,y,qtrue)
+#define trap_Z_Free(x)			Z_Free(x)
+#else
+#define trap_Z_Malloc(x, y)		gi.Malloc(x,y,qtrue)
+#define trap_Z_Free(x)			gi.Free(x)
+#endif
+
+
+class CTextPool;
+class CGPObject;
+
+class CTextPool
+{
+private:
+	char		*mPool;
+	CTextPool	*mNext;
+	int			mSize, mUsed;
+
+public:
+	CTextPool(int initSize = 10240);
+	~CTextPool(void);
+
+	CTextPool	*GetNext(void) { return mNext; }
+	void		SetNext(CTextPool *which) { mNext = which; }
+	char		*GetPool(void) { return mPool; }
+	int			GetUsed(void) { return mUsed; }
+
+	char		*AllocText(char *text, bool addNULL = true, CTextPool **poolPtr = 0);
+};
+
+void CleanTextPool(CTextPool *pool);
+
+class CGPObject
+{
+protected:
+	const char	*mName;
+	CGPObject	*mNext, *mInOrderNext, *mInOrderPrevious;
+
+public:
+				CGPObject(const char *initName);
+
+	const char	*GetName(void) { return mName; }
+
+	CGPObject	*GetNext(void) { return mNext; }
+	void		SetNext(CGPObject *which) { mNext = which; }
+	CGPObject	*GetInOrderNext(void) { return mInOrderNext; }
+	void		SetInOrderNext(CGPObject *which) { mInOrderNext = which; }
+	CGPObject	*GetInOrderPrevious(void) { return mInOrderPrevious; }
+	void		SetInOrderPrevious(CGPObject *which) { mInOrderPrevious = which; }
+
+	bool		WriteText(CTextPool **textPool, const char *text);
+};
+
+
+
+class CGPValue : public CGPObject
+{
+private:
+	CGPObject	*mList;
+
+public:
+					CGPValue(const char *initName, const char *initValue = 0);
+					~CGPValue(void);
+
+	CGPValue		*GetNext(void) { return (CGPValue *)mNext; }
+
+	CGPValue		*Duplicate(CTextPool **textPool = 0);
+
+	bool			IsList(void);
+	const char		*GetTopValue(void);
+	CGPObject		*GetList(void) { return mList; }
+	void			AddValue(const char *newValue, CTextPool **textPool = 0);
+
+	bool			Parse(char **dataPtr, CTextPool **textPool);
+
+	bool			Write(CTextPool **textPool, int depth);
+};
+
+
+
+class CGPGroup : public CGPObject
+{
+private:
+	CGPValue			*mPairs, *mInOrderPairs;
+	CGPValue			*mCurrentPair;
+	CGPGroup			*mSubGroups, *mInOrderSubGroups;
+	CGPGroup			*mCurrentSubGroup;
+	CGPGroup			*mParent;
+	bool				mWriteable;
+
+	void	SortObject(CGPObject *object, CGPObject **unsortedList, CGPObject **sortedList, 
+					   CGPObject **lastObject);
+
+public:
+				CGPGroup(const char *initName = "Top Level", CGPGroup *initParent = 0);
+				~CGPGroup(void);
+
+	CGPGroup	*GetParent(void) { return mParent; }
+	CGPGroup	*GetNext(void) { return (CGPGroup *)mNext; }
+	int			GetNumSubGroups(void); 
+	int			GetNumPairs(void);
+
+	void		Clean(void); 
+	CGPGroup	*Duplicate(CTextPool **textPool = 0, CGPGroup *initParent = 0);
+
+	void		SetWriteable(const bool writeable) { mWriteable = writeable; }
+	CGPValue	*GetPairs(void) { return mPairs; }
+	CGPValue	*GetInOrderPairs(void) { return mInOrderPairs; }
+	CGPGroup	*GetSubGroups(void) { return mSubGroups; }
+	CGPGroup	*GetInOrderSubGroups(void) { return mInOrderSubGroups; }
+
+	CGPValue	*AddPair(const char *name, const char *value, CTextPool **textPool = 0);
+	void		AddPair(CGPValue *NewPair);
+	CGPGroup	*AddGroup(const char *name, CTextPool **textPool = 0);
+	void		AddGroup(CGPGroup *NewGroup);
+	CGPGroup	*FindSubGroup(const char *name);
+	bool		Parse(char **dataPtr, CTextPool **textPool);
+	bool		Write(CTextPool **textPool, int depth);
+
+	CGPValue	*FindPair(const char *key);
+	const char	*FindPairValue(const char *key, const char *defaultVal = 0);
+};
+
+class CGenericParser2
+{
+private:
+	CGPGroup		mTopLevel;
+	CTextPool		*mTextPool;
+	bool			mWriteable;
+
+public:
+	CGenericParser2(void);
+	~CGenericParser2(void);
+
+	void		SetWriteable(const bool writeable) { mWriteable = writeable; }
+	CGPGroup	*GetBaseParseGroup(void) { return &mTopLevel; }
+
+	bool	Parse(char **dataPtr, bool cleanFirst = true, bool writeable = false);
+	bool	Parse(char *dataPtr, bool cleanFirst = true, bool writeable = false)
+	{
+		return Parse(&dataPtr, cleanFirst, writeable);
+	}
+	void	Clean(void);
+
+	bool	Write(CTextPool *textPool);
+};
+
+
+
+// The following groups of routines are used for a C interface into GP2.
+// C++ users should just use the objects as normally and not call these routines below
+//
+
+typedef		void	*TGenericParser2;
+typedef		void	*TGPGroup;
+typedef		void	*TGPValue;
+
+// CGenericParser2 (void *) routines
+TGenericParser2		GP_Parse(char **dataPtr, bool cleanFirst, bool writeable);
+void				GP_Clean(TGenericParser2 GP2);
+void				GP_Delete(TGenericParser2 *GP2);
+TGPGroup			GP_GetBaseParseGroup(TGenericParser2 GP2);
+
+// CGPGroup (void *) routines
+const char	*GPG_GetName(TGPGroup GPG);
+TGPGroup	GPG_GetNext(TGPGroup GPG);
+TGPGroup	GPG_GetInOrderNext(TGPGroup GPG);
+TGPGroup	GPG_GetInOrderPrevious(TGPGroup GPG);
+TGPGroup	GPG_GetPairs(TGPGroup GPG);
+TGPGroup	GPG_GetInOrderPairs(TGPGroup GPG);
+TGPGroup	GPG_GetSubGroups(TGPGroup GPG);
+TGPGroup	GPG_GetInOrderSubGroups(TGPGroup GPG);
+TGPGroup	GPG_FindSubGroup(TGPGroup GPG, const char *name);
+TGPValue	GPG_FindPair(TGPGroup GPG, const char *key);
+const char	*GPG_FindPairValue(TGPGroup GPG, const char *key, const char *defaultVal);
+
+// CGPValue (void *) routines
+const char	*GPV_GetName(TGPValue GPV);
+TGPValue	GPV_GetNext(TGPValue GPV);
+TGPValue	GPV_GetInOrderNext(TGPValue GPV);
+TGPValue	GPV_GetInOrderPrevious(TGPValue GPV);
+bool		GPV_IsList(TGPValue GPV);
+const char	*GPV_GetTopValue(TGPValue GPV);
+TGPValue	GPV_GetList(TGPValue GPV);
+
+
+#endif	// #ifndef GENERICPARSER2_H
+
+
+//////////////////// eof /////////////////////
+
diff --git a/code/game/ghoul2_shared.h b/code/game/ghoul2_shared.h
new file mode 100644
index 0000000..ca5a506
--- /dev/null
+++ b/code/game/ghoul2_shared.h
@@ -0,0 +1,495 @@
+#pragma once
+#if !defined(GHOUL2_SHARED_H_INC)
+#define GHOUL2_SHARED_H_INC
+
+/*
+Ghoul2 Insert Start
+*/
+#pragma warning (push, 3)	//go back down to 3 for the stl include
+#pragma warning (disable:4503)	// decorated name length xceeded, name was truncated
+#pragma warning(disable:4702)	//unreachable code
+#include <vector>
+#include <map>
+#pragma warning (pop)
+#pragma warning (disable:4503)	// decorated name length xceeded, name was truncated
+using namespace std;
+/*
+Ghoul2 Insert End
+*/
+
+#define G2T_SV_TIME (0)
+#define G2T_CG_TIME (1)
+#define NUM_G2T_TIME (2)
+
+void		G2API_SetTime(int currentTime,int clock);
+int			G2API_GetTime(int argTime); // this may or may not return arg depending on ghoul2_time cvar
+
+
+//===================================================================
+//
+//   G H O U L  I I  D E F I N E S
+//
+// we save the whole surfaceInfo_t struct
+struct surfaceInfo_t 
+{
+	int			offFlags;		// what the flags are for this model
+	int			surface;		// index into array held inside the model definition of pointers to the actual surface data loaded in - used by both client and game
+	float		genBarycentricJ;	// point 0 barycentric coors
+	float		genBarycentricI;	// point 1 barycentric coors - point 2 is 1 - point0 - point1
+	int			genPolySurfaceIndex; // used to point back to the original surface and poly if this is a generated surface
+	int			genLod;			// used to determine original lod of original surface and poly hit location
+	
+surfaceInfo_t():
+	offFlags(0),
+	surface(0),
+	genBarycentricJ(0),
+	genBarycentricI(0),
+	genPolySurfaceIndex(0),
+	genLod(0)
+	{}
+
+};
+
+#define BONE_ANGLES_PREMULT			0x0001
+#define BONE_ANGLES_POSTMULT		0x0002
+#define BONE_ANGLES_REPLACE			0x0004
+//rww - RAGDOLL_BEGIN
+#define BONE_ANGLES_RAGDOLL			0x2000  // the rag flags give more details
+#define BONE_ANGLES_IK				0x4000  // the rag flags give more details
+//rww - RAGDOLL_END
+#define BONE_ANGLES_TOTAL			( BONE_ANGLES_PREMULT | BONE_ANGLES_POSTMULT | BONE_ANGLES_REPLACE )
+
+#define BONE_ANIM_OVERRIDE			0x0008
+#define BONE_ANIM_OVERRIDE_LOOP		0x0010	// Causes Last Frame To Lerp to First Frame And Start Over
+#define BONE_ANIM_OVERRIDE_FREEZE	(0x0040 + BONE_ANIM_OVERRIDE)	// Causes Last Frame To Freeze And Not Loop To Beginning
+#define BONE_ANIM_BLEND				0x0080		// Blends to and from previously played frame on same bone for given time
+#define	BONE_ANIM_NO_LERP			0x1000
+#define BONE_ANIM_TOTAL				(BONE_ANIM_NO_LERP| BONE_ANIM_OVERRIDE | BONE_ANIM_OVERRIDE_LOOP | BONE_ANIM_OVERRIDE_FREEZE | BONE_ANIM_BLEND )
+
+#define BONE_INDEX_INVALID			-1
+
+/*#define MDXABONEDEF				// used in the mdxformat.h file to stop redefinitions of the bone struct.
+
+typedef struct {
+	float		matrix[3][4];
+} mdxaBone_t;
+*/
+#include "../renderer/mdx_format.h"
+
+// we save the whole structure here.
+struct  boneInfo_t
+{
+	int			boneNumber;		// what bone are we overriding?
+	mdxaBone_t	matrix;			// details of bone angle overrides - some are pre-done on the server, some in ghoul2
+	int			flags;			// flags for override
+	int			startFrame;		// start frame for animation
+	int			endFrame;		// end frame for animation NOTE anim actually ends on endFrame+1
+	int			startTime;		// time we started this animation
+	int			pauseTime;		// time we paused this animation - 0 if not paused
+	float		animSpeed;		// speed at which this anim runs. 1.0f means full speed of animation incoming - ie if anim is 20hrtz, we run at 20hrts. If 5hrts, we run at 5 hrts
+	float		blendFrame;		// frame PLUS LERP value to blend from
+	int			blendLerpFrame;	// frame to lerp the blend frame with.
+	int			blendTime;		// Duration time for blending - used to calc amount each frame of new anim is blended with last frame of the last anim
+	int			blendStart;		// Time when blending starts - not necessarily the same as startTime since we might start half way through an anim
+	int			boneBlendTime;	// time for duration of bone angle blend with normal animation
+	int			boneBlendStart;	// time bone angle blend with normal animation began
+	mdxaBone_t	newMatrix;		// This is the lerped matrix that Ghoul2 uses on the client side - does not go across the network
+
+	//rww - RAGDOLL_BEGIN
+	int			lastTimeUpdated;  // if non-zero this is all intialized
+	int			lastContents;
+	vec3_t		lastPosition;
+	vec3_t		velocityEffector;
+	vec3_t		lastAngles;
+	vec3_t		minAngles;
+	vec3_t		maxAngles;
+	vec3_t		currentAngles;
+	vec3_t		anglesOffset;
+	vec3_t		positionOffset;
+	float		radius;
+	float		weight;   // current radius cubed
+	int			ragIndex;
+	vec3_t		velocityRoot;		// I am really tired of recomiling the whole game to add a param here
+	int			ragStartTime;
+	int			firstTime;
+	int			firstCollisionTime;
+	int			restTime;
+	int			RagFlags;
+	int			DependentRagIndexMask;
+	mdxaBone_t	originalTrueBoneMatrix;	
+	mdxaBone_t	parentTrueBoneMatrix;			// figure I will need this sooner or later
+	mdxaBone_t	parentOriginalTrueBoneMatrix;	// figure I will need this sooner or later
+	vec3_t		originalOrigin;
+	vec3_t		originalAngles;
+	vec3_t		lastShotDir;		
+	mdxaBone_t  *basepose;
+	mdxaBone_t  *baseposeInv;
+	mdxaBone_t  *baseposeParent;
+	mdxaBone_t  *baseposeInvParent;
+	int			parentRawBoneIndex;
+	mdxaBone_t	ragOverrideMatrix;	// figure I will need this sooner or later
+
+	mdxaBone_t	extraMatrix;	// figure I will need this sooner or later
+	vec3_t		extraVec1;		// I am really tired of recomiling the whole game to add a param here
+	float		extraFloat1;		
+	int			extraInt1;
+
+	vec3_t		ikPosition;
+	float		ikSpeed;
+
+	//new ragdoll stuff -rww
+	vec3_t		epVelocity; //velocity factor, can be set, and is also maintained by physics based on gravity, mass, etc.
+	float		epGravFactor; //gravity factor maintained by bone physics
+	int			solidCount; //incremented every time we try to move and are in solid - if we get out of solid, it is reset to 0
+	bool		physicsSettled; //true when the bone is on ground and finished bouncing, etc. but may still be pushed into solid by other bones
+	bool		snapped; //the bone is broken out of standard constraints
+
+	int			parentBoneIndex;
+
+	float		offsetRotation;
+
+	//user api overrides
+	float		overGradSpeed;
+
+	vec3_t		overGoalSpot;
+	bool		hasOverGoal;
+
+	mdxaBone_t	animFrameMatrix; //matrix for the bone in the desired settling pose -rww
+	int			hasAnimFrameMatrix;
+
+	int			airTime; //base is in air, be more quick and sensitive about collisions
+	//rww - RAGDOLL_END
+
+boneInfo_t():
+	boneNumber(-1),
+	flags(0),
+	startFrame(0),
+	endFrame(0),
+	startTime(0),
+	pauseTime(0),
+	animSpeed(0),
+	blendFrame(0),
+	blendLerpFrame(0),
+	blendTime(0),
+	blendStart(0),
+	boneBlendTime(0),
+	boneBlendStart(0)
+	{
+		matrix.matrix[0][0] = matrix.matrix[0][1] = matrix.matrix[0][2] = matrix.matrix[0][3] = 
+		matrix.matrix[1][0] = matrix.matrix[1][1] = matrix.matrix[1][2] = matrix.matrix[1][3] = 
+		matrix.matrix[2][0] = matrix.matrix[2][1] = matrix.matrix[2][2] = matrix.matrix[2][3] = 0.0f;
+	}
+
+};
+//we save from top to boltUsed here. Don't bother saving the position, it gets rebuilt every frame anyway
+struct boltInfo_t{
+	int			boneNumber;		// bone number bolt attaches to	
+	int			surfaceNumber;	// surface number bolt attaches to 
+	int			surfaceType;	// if we attach to a surface, this tells us if it is an original surface or a generated one - doesn't go across the network
+	int			boltUsed;		// nor does this
+	boltInfo_t():
+	boneNumber(-1),
+	surfaceNumber(-1),
+	surfaceType(0),
+	boltUsed(0)
+	{}
+};
+
+
+#define MAX_GHOUL_COUNT_BITS 8 // bits required to send across the MAX_G2_MODELS inside of the networking - this is the only restriction on ghoul models possible per entity
+
+typedef vector <surfaceInfo_t> surfaceInfo_v;
+typedef vector <boneInfo_t> boneInfo_v;
+typedef vector <boltInfo_t> boltInfo_v;
+typedef vector <mdxaBone_t> mdxaBone_v;
+
+// defines for stuff to go into the mflags
+#define		GHOUL2_NOCOLLIDE 0x001
+#define		GHOUL2_NORENDER	 0x002
+#define		GHOUL2_NOMODEL	 0x004
+#define		GHOUL2_NEWORIGIN 0x008
+
+
+// NOTE order in here matters. We save out from mModelindex to mFlags, but not the STL vectors that are at the top or the bottom.
+class CBoneCache;
+struct model_s;
+//struct mdxaHeader_t;
+
+#ifdef VV_GHOUL_HACKS
+class CRenderableSurface
+{
+public:
+	int				ident;			// ident of this surface - required so the materials renderer knows what sort of surface this refers to 
+ 	CBoneCache 		*boneCache;		// pointer to transformed bone list for this surf
+	mdxmSurface_t	*surfaceData;	// pointer to surface data loaded into file - only used by client renderer DO NOT USE IN GAME SIDE - if there is a vid restart this will be out of wack on the game
+
+CRenderableSurface():	
+	ident(8), //SF_MDX
+	boneCache(0),
+	surfaceData(0)
+	{}
+
+CRenderableSurface(const CRenderableSurface& rs):
+	ident(rs.ident),
+	boneCache(rs.boneCache),
+	surfaceData(rs.surfaceData)
+	{}
+};
+#endif
+
+class CGhoul2Info
+{
+public:
+	surfaceInfo_v 	mSlist;
+	boltInfo_v		mBltlist;
+	boneInfo_v		mBlist;
+// save from here (do not put any ptrs etc within this save block unless you adds special handlers to G2_SaveGhoul2Models / G2_LoadGhoul2Models!!!!!!!!!!!!
+#define BSAVE_START_FIELD mModelindex	// this is the start point for loadsave, keep it up to date it you change anything
+	int				mModelindex;
+	int				animModelIndexOffset;
+	qhandle_t		mCustomShader;
+	qhandle_t		mCustomSkin;
+	int				mModelBoltLink;
+	int				mSurfaceRoot;
+	int				mLodBias;
+	int				mNewOrigin;	// this contains the bolt index of the new origin for this model
+#ifdef _G2_GORE
+	int				mGoreSetTag;
+#endif
+	qhandle_t		mModel;		// this and the next entries do NOT go across the network. They are for gameside access ONLY
+	char			mFileName[MAX_QPATH];
+	int				mAnimFrameDefault;
+	int				mSkelFrameNum;
+	int				mMeshFrameNum;
+	int				mFlags;	// used for determining whether to do full collision detection against this object
+// to here
+#define BSAVE_END_FIELD mTransformedVertsArray	// this is the end point for loadsave, keep it up to date it you change anything
+	int				*mTransformedVertsArray;	// used to create an array of pointers to transformed verts per surface for collision detection
+	CBoneCache		*mBoneCache;
+	int				mSkin;
+
+	// these occasionally are not valid (like after a vid_restart)
+	// call the questionably efficient G2_SetupModelPointers(this) to insure validity
+	bool				mValid; // all the below are proper and valid
+	const model_s		*currentModel;
+	int					currentModelSize;
+	const model_s		*animModel;
+	int					currentAnimModelSize;
+	const mdxaHeader_t	*aHeader;
+
+	CGhoul2Info():
+	mModelindex(-1),
+	mCustomShader(0),
+	mCustomSkin(0),
+	mModelBoltLink(0),
+	mModel(0),
+	mSurfaceRoot(0),
+	mAnimFrameDefault(0),
+	mSkelFrameNum(-1),
+	mMeshFrameNum(-1),
+	mFlags(0),
+	mTransformedVertsArray(0),
+	mLodBias(0),
+	mSkin(0),
+	mNewOrigin(-1),
+#ifdef _G2_GORE
+	mGoreSetTag(0),
+#endif
+	mBoneCache(0),
+	currentModel(0),
+	currentModelSize(0),
+	animModel(0),
+	animModelIndexOffset(0),
+	currentAnimModelSize(0),
+	aHeader(0),
+	mValid(false)
+	{
+		mFileName[0] = 0;
+	}
+}; 
+
+class CGhoul2Info_v;
+
+class IGhoul2InfoArray
+{
+public:
+	virtual int New()=0;
+	virtual void Delete(int handle)=0;
+	virtual bool IsValid(int handle) const=0;
+	virtual vector<CGhoul2Info> &Get(int handle)=0;
+	virtual const vector<CGhoul2Info> &Get(int handle) const=0;
+};
+
+IGhoul2InfoArray &TheGhoul2InfoArray();
+IGhoul2InfoArray &TheGameGhoul2InfoArray();
+
+class CGhoul2Info_v
+{
+	int mItem;
+
+	IGhoul2InfoArray &InfoArray() const
+	{
+#ifdef _JK2EXE
+		return TheGhoul2InfoArray();
+#else
+		return TheGameGhoul2InfoArray();
+#endif
+	}
+
+	void Alloc()
+	{
+		assert(!mItem); //already alloced
+		mItem=InfoArray().New();
+		assert(!Array().size());
+	}
+	void Free()
+	{
+		if (mItem)
+		{
+			assert(InfoArray().IsValid(mItem));
+			InfoArray().Delete(mItem);
+			mItem=0;
+		}
+	}
+	vector<CGhoul2Info> &Array()
+	{
+		assert(InfoArray().IsValid(mItem));
+		return InfoArray().Get(mItem);
+	}
+	const vector<CGhoul2Info> &Array() const
+	{
+		assert(InfoArray().IsValid(mItem));
+		return InfoArray().Get(mItem);
+	}
+public:
+	CGhoul2Info_v()
+	{
+		mItem=0;
+	}
+	~CGhoul2Info_v()
+	{
+		Free(); //this had better be taken care of via the clean ghoul2 models call
+	}
+	void operator=(const CGhoul2Info_v &other)
+	{
+		mItem=other.mItem;
+	}
+	void DeepCopy(const CGhoul2Info_v &other)
+	{
+		Free();
+		if (other.mItem)
+		{
+			Alloc();
+			Array()=other.Array();
+			int i;
+			for (i=0;i<size();i++)
+			{
+				Array()[i].mBoneCache=0;
+				Array()[i].mTransformedVertsArray=0;
+				Array()[i].mSkelFrameNum=0;
+				Array()[i].mMeshFrameNum=0;
+			}
+		}
+	}
+	CGhoul2Info &operator[](int idx)
+	{
+		assert(mItem);
+		assert(idx>=0&&idx<size());
+		return Array()[idx];
+	}
+	const CGhoul2Info &operator[](int idx) const
+	{
+		assert(mItem);
+		assert(idx>=0&&idx<size());
+		return Array()[idx];
+	}
+	void resize(int num)
+	{
+		assert(num>=0);
+		if (num)
+		{
+			if (!mItem)
+			{
+				Alloc();
+			}
+		}
+		if (mItem||num)
+		{
+			Array().resize(num);
+		}
+	}
+	void clear()
+	{
+		Free();
+	}
+	void push_back(const CGhoul2Info &model)
+	{
+		if (!mItem)
+		{
+			Alloc();
+		}
+		Array().push_back(model);
+	}
+	int size() const
+	{
+		if (!IsValid())
+		{
+			return 0;
+		}
+		return Array().size();
+	}
+	bool IsValid() const
+	{
+		return InfoArray().IsValid(mItem);
+	}
+	void kill()
+	{
+		// this scary method zeros the infovector handle without actually freeing it
+		// it is used for some places where a copy is made, but we don't want to go through the trouble
+		// of making a deep copy
+		mItem=0;
+	}
+};
+
+
+
+// collision detection stuff
+#define G2_FRONTFACE 1
+#define	G2_BACKFACE	 0
+
+
+class CCollisionRecord
+{
+public:
+	float		mDistance;
+	int			mEntityNum;
+	int			mModelIndex;
+	int			mPolyIndex;
+	int			mSurfaceIndex;
+	vec3_t		mCollisionPosition;
+	vec3_t		mCollisionNormal;
+	int			mFlags;
+	int			mMaterial;
+	int			mLocation;
+	float		mBarycentricI; // two barycentic coodinates for the hit point
+	float		mBarycentricJ; // K = 1-I-J
+
+	CCollisionRecord():
+	mEntityNum(-1),
+	mDistance(100000)
+	{}
+};
+
+// calling defines for the trace function
+enum EG2_Collision
+{
+	G2_NOCOLLIDE,
+	G2_COLLIDE,
+	G2_RETURNONHIT
+};
+
+
+
+//====================================================================
+
+#endif // GHOUL2_SHARED_H_INC
\ No newline at end of file
diff --git a/code/game/hitlocs.h b/code/game/hitlocs.h
new file mode 100644
index 0000000..a4d64c2
--- /dev/null
+++ b/code/game/hitlocs.h
@@ -0,0 +1,35 @@
+#ifndef HITLOCS_H
+#define HITLOCS_H
+
+typedef enum //# hitloc_e
+{
+	HL_NONE = 0,
+	HL_FOOT_RT,
+	HL_FOOT_LT,
+	HL_LEG_RT,
+	HL_LEG_LT,
+	HL_WAIST,
+	HL_BACK_RT,
+	HL_BACK_LT,
+	HL_BACK,
+	HL_CHEST_RT,
+	HL_CHEST_LT,
+	HL_CHEST,
+	HL_ARM_RT,
+	HL_ARM_LT,
+	HL_HAND_RT,
+	HL_HAND_LT,
+	HL_HEAD,
+	HL_GENERIC1,
+	HL_GENERIC2,
+	HL_GENERIC3,
+	HL_GENERIC4,
+	HL_GENERIC5,
+	HL_GENERIC6,
+	//# #eol
+	HL_MAX
+};
+
+extern stringID_table_t HLTable[];
+
+#endif	// #ifndef HITLOCS_H
diff --git a/code/game/mssccprj.scc b/code/game/mssccprj.scc
new file mode 100644
index 0000000..b1297bc
--- /dev/null
+++ b/code/game/mssccprj.scc
@@ -0,0 +1,5 @@
+SCC = This is a Source Code Control file
+
+[game.vcproj]
+SCC_Aux_Path = "\\ravendata1\vss\central_code"
+SCC_Project_Name = "$/jedi/code/game", IVBAAAAA
diff --git a/code/game/npc_headers.h b/code/game/npc_headers.h
new file mode 100644
index 0000000..0ad76eb
--- /dev/null
+++ b/code/game/npc_headers.h
@@ -0,0 +1,7 @@
+// PCH header file organiser for  NPC_xxxx cpp files' most commonly used headers
+
+#include "b_local.h"
+#include "anims.h"
+#include "g_functions.h"
+#include "g_nav.h"
+#include "g_navigator.h"
diff --git a/code/game/objectives.h b/code/game/objectives.h
new file mode 100644
index 0000000..4983147
--- /dev/null
+++ b/code/game/objectives.h
@@ -0,0 +1,341 @@
+#ifndef __OBJECTIVES_H__
+#define __OBJECTIVES_H__
+
+// mission Objectives
+
+
+// DO NOT CHANGE MAX_MISSION_OBJ. IT AFFECTS THE SAVEGAME STRUCTURE
+
+typedef enum //# Objective_e
+{
+	//=================================================
+	//
+	//=================================================
+
+	LIGHTSIDE_OBJ = 0,
+	HOTH2_OBJ1,
+	HOTH2_OBJ2,
+	HOTH2_OBJ3,
+	HOTH3_OBJ1,
+	HOTH3_OBJ2,
+	HOTH3_OBJ3,
+	T2_DPREDICAMENT_OBJ1,
+	T2_DPREDICAMENT_OBJ2,
+	T2_DPREDICAMENT_OBJ3,
+	T2_DPREDICAMENT_OBJ4,
+	T2_RANCOR_OBJ1,
+	T2_RANCOR_OBJ2,
+	T2_RANCOR_OBJ3,
+	T2_RANCOR_OBJ4,
+	T2_RANCOR_OBJ5,
+	T2_RANCOR_OBJ5_2,
+	T2_RANCOR_OBJ6,
+	T2_WEDGE_OBJ1,
+	T2_WEDGE_OBJ2,
+	T2_WEDGE_OBJ3,
+	T2_WEDGE_OBJ4,
+	T2_WEDGE_OBJ5,
+	T2_WEDGE_OBJ6,
+	T2_WEDGE_OBJ7,
+	T2_WEDGE_OBJ8,
+	T2_WEDGE_OBJ9,
+	T2_WEDGE_OBJ10,
+	T2_WEDGE_OBJ11,
+	T2_WEDGE_OBJ12,
+	T3_RIFT_OBJ1,
+	T3_RIFT_OBJ2,
+	T3_RIFT_OBJ3,
+	T1_DANGER_OBJ1,
+	T1_DANGER_OBJ2,
+	T1_DANGER_OBJ3,
+	T1_DANGER_OBJ4,
+	T1_DANGER_OBJ5,
+	T3_BOUNTY_OBJ1,
+	T3_BOUNTY_OBJ2,
+	T3_BOUNTY_OBJ3,
+	T3_BOUNTY_OBJ4,
+	T3_BOUNTY_OBJ5,
+	T3_BOUNTY_OBJ6,
+	T3_BOUNTY_OBJ7,
+	T3_BOUNTY_OBJ8,
+	T3_BOUNTY_OBJ9,
+	T2_ROGUE_OBJ1,
+	T2_ROGUE_OBJ2,
+	T2_TRIP_OBJ1,
+	T2_TRIP_OBJ2,
+	T3_BYSS_OBJ1,
+	T3_BYSS_OBJ2,
+	T3_BYSS_OBJ3,
+	T3_HEVIL_OBJ1,
+	T3_HEVIL_OBJ2,
+	T3_HEVIL_OBJ3,
+	T3_STAMP_OBJ1,
+	T3_STAMP_OBJ2,
+	T3_STAMP_OBJ3,
+	T3_STAMP_OBJ4,
+	TASPIR1_OBJ1,
+	TASPIR1_OBJ2,
+	TASPIR1_OBJ3,
+	TASPIR1_OBJ4,
+	TASPIR2_OBJ1,
+	TASPIR2_OBJ2,
+	VJUN1_OBJ1,
+	VJUN1_OBJ2,
+	VJUN2_OBJ1,
+	VJUN3_OBJ1,
+	YAVIN1_OBJ1,
+	YAVIN1_OBJ2,
+	YAVIN2_OBJ1,
+	T1_FATAL_OBJ1,
+	T1_FATAL_OBJ2,
+	T1_FATAL_OBJ3,
+	T1_FATAL_OBJ4,
+	T1_FATAL_OBJ5,
+	T1_FATAL_OBJ6,
+	KOR1_OBJ1,
+	KOR1_OBJ2,
+	KOR2_OBJ1,
+	KOR2_OBJ2,
+	KOR2_OBJ3,
+	KOR2_OBJ4,
+	T1_RAIL_OBJ1,
+	T1_RAIL_OBJ2,
+	T1_RAIL_OBJ3,
+	T1_SOUR_OBJ1,
+	T1_SOUR_OBJ2,
+	T1_SOUR_OBJ3,
+	T1_SOUR_OBJ4,
+	T1_SURPRISE_OBJ1,
+	T1_SURPRISE_OBJ2,
+	T1_SURPRISE_OBJ3,
+	T1_SURPRISE_OBJ4,
+
+	//# #eol
+	MAX_OBJECTIVES,
+} objectiveNumber_t;
+
+
+typedef enum //# MissionFailed_e
+{
+	MISSIONFAILED_JAN=0,		//#
+	MISSIONFAILED_LUKE,			//#
+	MISSIONFAILED_LANDO,		//#
+	MISSIONFAILED_R5D2,			//#
+	MISSIONFAILED_WARDEN,		//#
+	MISSIONFAILED_PRISONERS,	//#
+	MISSIONFAILED_EMPLACEDGUNS,	//#
+	MISSIONFAILED_LADYLUCK,		//#
+	MISSIONFAILED_KYLECAPTURE,	//#
+	MISSIONFAILED_TOOMANYALLIESDIED,	//#
+	MISSIONFAILED_CHEWIE,		//#
+	MISSIONFAILED_KYLE,			//#
+	MISSIONFAILED_ROSH,			//#
+	MISSIONFAILED_WEDGE,		//#
+	MISSIONFAILED_TURNED,		//# Turned on your friends.
+
+	//# #eol
+	MAX_MISSIONFAILED,
+} missionFailed_t;
+
+
+typedef enum //# StatusText_e
+{
+	//=================================================
+	//
+	//=================================================
+	STAT_INSUBORDINATION = 0,		//# Starfleet will not tolerate such insubordination
+	STAT_YOUCAUSEDDEATHOFTEAMMATE,	//# You caused the death of a teammate.
+	STAT_DIDNTPROTECTTECH,			//# You failed to protect Chell, your technician.
+	STAT_DIDNTPROTECT7OF9,			//# You failed to protect 7 of 9
+	STAT_NOTSTEALTHYENOUGH,			//# You weren't quite stealthy enough
+	STAT_STEALTHTACTICSNECESSARY,	//# Starfleet will not tolerate such insubordination
+	STAT_WATCHYOURSTEP,				//# Watch your step
+	STAT_JUDGEMENTMUCHDESIRED,		//# Your judgement leaves much to be desired
+
+	//# #eol
+	MAX_STATUSTEXT,
+} statusText_t;
+
+extern qboolean	missionInfo_Updated;
+
+#define SET_TACTICAL_OFF	0
+#define SET_TACTICAL_ON		1
+
+#define SET_OBJ_HIDE		0
+#define SET_OBJ_SHOW		1
+#define SET_OBJ_PENDING		2
+#define SET_OBJ_SUCCEEDED	3
+#define SET_OBJ_FAILED		4
+
+#define OBJECTIVE_HIDE 0
+#define OBJECTIVE_SHOW 1
+
+#define OBJECTIVE_STAT_PENDING		0
+#define OBJECTIVE_STAT_SUCCEEDED	1
+#define OBJECTIVE_STAT_FAILED		2
+
+extern int statusTextIndex;
+
+void OBJ_SaveObjectiveData(void);
+void OBJ_LoadObjectiveData(void);
+extern void OBJ_SetPendingObjectives(gentity_t *ent);
+
+#ifndef G_OBJECTIVES_CPP
+
+extern stringID_table_t objectiveTable [];
+extern stringID_table_t statusTextTable [];
+extern stringID_table_t missionFailedTable [];
+
+#else
+
+stringID_table_t objectiveTable [] =
+{
+	//=================================================
+	//
+	//=================================================
+	ENUM2STRING(LIGHTSIDE_OBJ),
+	ENUM2STRING(HOTH2_OBJ1),
+	ENUM2STRING(HOTH2_OBJ2),
+	ENUM2STRING(HOTH2_OBJ3),
+	ENUM2STRING(HOTH3_OBJ1),
+	ENUM2STRING(HOTH3_OBJ2),
+	ENUM2STRING(HOTH3_OBJ3),
+	ENUM2STRING(T2_DPREDICAMENT_OBJ1),
+	ENUM2STRING(T2_DPREDICAMENT_OBJ2),
+	ENUM2STRING(T2_DPREDICAMENT_OBJ3),
+	ENUM2STRING(T2_DPREDICAMENT_OBJ4),
+	ENUM2STRING(T2_RANCOR_OBJ1),
+	ENUM2STRING(T2_RANCOR_OBJ2),
+	ENUM2STRING(T2_RANCOR_OBJ3),
+	ENUM2STRING(T2_RANCOR_OBJ4),
+	ENUM2STRING(T2_RANCOR_OBJ5),
+	ENUM2STRING(T2_RANCOR_OBJ5_2),
+	ENUM2STRING(T2_RANCOR_OBJ6),
+	ENUM2STRING(T2_WEDGE_OBJ1),
+	ENUM2STRING(T2_WEDGE_OBJ2),
+	ENUM2STRING(T2_WEDGE_OBJ3),
+	ENUM2STRING(T2_WEDGE_OBJ4),
+	ENUM2STRING(T2_WEDGE_OBJ5),
+	ENUM2STRING(T2_WEDGE_OBJ6),
+	ENUM2STRING(T2_WEDGE_OBJ7),
+	ENUM2STRING(T2_WEDGE_OBJ8),
+	ENUM2STRING(T2_WEDGE_OBJ9),
+	ENUM2STRING(T2_WEDGE_OBJ10),
+	ENUM2STRING(T2_WEDGE_OBJ11),
+	ENUM2STRING(T2_WEDGE_OBJ12),
+	ENUM2STRING(T3_RIFT_OBJ1),
+	ENUM2STRING(T3_RIFT_OBJ2),
+	ENUM2STRING(T3_RIFT_OBJ3),
+	ENUM2STRING(T1_DANGER_OBJ1),
+	ENUM2STRING(T1_DANGER_OBJ2),
+	ENUM2STRING(T1_DANGER_OBJ3),
+	ENUM2STRING(T1_DANGER_OBJ4),
+	ENUM2STRING(T1_DANGER_OBJ5),
+	ENUM2STRING(T3_BOUNTY_OBJ1),
+	ENUM2STRING(T3_BOUNTY_OBJ2),
+	ENUM2STRING(T3_BOUNTY_OBJ3),
+	ENUM2STRING(T3_BOUNTY_OBJ4),
+	ENUM2STRING(T3_BOUNTY_OBJ5),
+	ENUM2STRING(T3_BOUNTY_OBJ6),
+	ENUM2STRING(T3_BOUNTY_OBJ7),
+	ENUM2STRING(T3_BOUNTY_OBJ8),
+	ENUM2STRING(T3_BOUNTY_OBJ9),
+	ENUM2STRING(T2_ROGUE_OBJ1),
+	ENUM2STRING(T2_ROGUE_OBJ2),
+	ENUM2STRING(T2_TRIP_OBJ1),
+	ENUM2STRING(T2_TRIP_OBJ2),
+	ENUM2STRING(T3_BYSS_OBJ1),
+	ENUM2STRING(T3_BYSS_OBJ2),
+	ENUM2STRING(T3_BYSS_OBJ3),
+	ENUM2STRING(T3_HEVIL_OBJ1),
+	ENUM2STRING(T3_HEVIL_OBJ2),
+	ENUM2STRING(T3_HEVIL_OBJ3),
+	ENUM2STRING(T3_STAMP_OBJ1),
+	ENUM2STRING(T3_STAMP_OBJ2),
+	ENUM2STRING(T3_STAMP_OBJ3),
+	ENUM2STRING(T3_STAMP_OBJ4),
+	ENUM2STRING(TASPIR1_OBJ1),
+	ENUM2STRING(TASPIR1_OBJ2),
+	ENUM2STRING(TASPIR1_OBJ3),
+	ENUM2STRING(TASPIR1_OBJ4),
+	ENUM2STRING(TASPIR2_OBJ1),
+	ENUM2STRING(TASPIR2_OBJ2),
+	ENUM2STRING(VJUN1_OBJ1),
+	ENUM2STRING(VJUN1_OBJ2),
+	ENUM2STRING(VJUN2_OBJ1),
+	ENUM2STRING(VJUN3_OBJ1),
+	ENUM2STRING(YAVIN1_OBJ1),
+	ENUM2STRING(YAVIN1_OBJ2),
+	ENUM2STRING(YAVIN2_OBJ1),
+	ENUM2STRING(T1_FATAL_OBJ1),
+	ENUM2STRING(T1_FATAL_OBJ2),
+	ENUM2STRING(T1_FATAL_OBJ3),
+	ENUM2STRING(T1_FATAL_OBJ4),
+	ENUM2STRING(T1_FATAL_OBJ5),
+	ENUM2STRING(T1_FATAL_OBJ6),
+	ENUM2STRING(KOR1_OBJ1),
+	ENUM2STRING(KOR1_OBJ2),
+	ENUM2STRING(KOR2_OBJ1),
+	ENUM2STRING(KOR2_OBJ2),
+	ENUM2STRING(KOR2_OBJ3),
+	ENUM2STRING(KOR2_OBJ4),
+	ENUM2STRING(T1_RAIL_OBJ1),
+	ENUM2STRING(T1_RAIL_OBJ2),
+	ENUM2STRING(T1_RAIL_OBJ3),
+	ENUM2STRING(T1_SOUR_OBJ1),
+	ENUM2STRING(T1_SOUR_OBJ2),
+	ENUM2STRING(T1_SOUR_OBJ3),
+	ENUM2STRING(T1_SOUR_OBJ4),
+	ENUM2STRING(T1_SURPRISE_OBJ1),
+	ENUM2STRING(T1_SURPRISE_OBJ2),
+	ENUM2STRING(T1_SURPRISE_OBJ3),
+	ENUM2STRING(T1_SURPRISE_OBJ4),
+
+	//stringID_table_t Must end with a null entry
+	"", NULL
+};
+
+stringID_table_t missionFailedTable [] =
+{
+	ENUM2STRING(MISSIONFAILED_JAN),			//# JAN DIED
+	ENUM2STRING(MISSIONFAILED_LUKE),		//# LUKE DIED
+	ENUM2STRING(MISSIONFAILED_LANDO),		//# LANDO DIED
+	ENUM2STRING(MISSIONFAILED_R5D2),		//# R5D2 DIED
+	ENUM2STRING(MISSIONFAILED_WARDEN),		//# THE WARDEN DIED
+	ENUM2STRING(MISSIONFAILED_PRISONERS),	//#	TOO MANY PRISONERS DIED
+	ENUM2STRING(MISSIONFAILED_EMPLACEDGUNS),//#	ALL EMPLACED GUNS GONE
+	ENUM2STRING(MISSIONFAILED_LADYLUCK),	//#	LADY LUCK DISTROYED
+	ENUM2STRING(MISSIONFAILED_KYLECAPTURE),	//# KYLE HAS BEEN CAPTURED	
+	ENUM2STRING(MISSIONFAILED_TOOMANYALLIESDIED),	//# TOO MANY ALLIES DIED
+	ENUM2STRING(MISSIONFAILED_CHEWIE),
+	ENUM2STRING(MISSIONFAILED_KYLE),
+	ENUM2STRING(MISSIONFAILED_ROSH),
+	ENUM2STRING(MISSIONFAILED_WEDGE),
+	ENUM2STRING(MISSIONFAILED_TURNED),		//# Turned on your friends.
+
+	//stringID_table_t Must end with a null entry
+	"", NULL
+};
+
+stringID_table_t statusTextTable [] =
+{
+	//=================================================
+	//
+	//=================================================
+	ENUM2STRING(STAT_INSUBORDINATION),				//# Starfleet will not tolerate such insubordination
+	ENUM2STRING(STAT_YOUCAUSEDDEATHOFTEAMMATE),		//# You caused the death of a teammate.
+	ENUM2STRING(STAT_DIDNTPROTECTTECH),				//# You failed to protect Chell, your technician.
+	ENUM2STRING(STAT_DIDNTPROTECT7OF9),				//# You failed to protect 7 of 9
+	ENUM2STRING(STAT_NOTSTEALTHYENOUGH),			//# You weren't quite stealthy enough
+	ENUM2STRING(STAT_STEALTHTACTICSNECESSARY),		//# Starfleet will not tolerate such insubordination
+	ENUM2STRING(STAT_WATCHYOURSTEP),				//# Watch your step
+	ENUM2STRING(STAT_JUDGEMENTMUCHDESIRED),			//# Your judgement leaves much to be desired
+	//stringID_table_t Must end with a null entry
+	"", NULL
+};
+
+#endif// #ifndef G_OBJECTIVES_CPP
+
+
+#endif// #ifndef __OBJECTIVES_H__
+
diff --git a/code/game/q_math.cpp b/code/game/q_math.cpp
new file mode 100644
index 0000000..2eaeb1a
--- /dev/null
+++ b/code/game/q_math.cpp
@@ -0,0 +1,1273 @@
+// q_math.c -- stateless support routines that are included in each code module
+
+// leave this at the top for PCH reasons...
+#include "common_headers.h"
+
+
+//#include "q_shared.h"
+
+
+const vec3_t	vec3_origin = {0,0,0};
+const vec3_t	axisDefault[3] = { { 1, 0, 0 }, { 0, 1, 0 }, { 0, 0, 1 } };
+
+vec4_t colorTable[CT_MAX] = 
+{
+{0, 0, 0, 0},			// CT_NONE
+{0, 0, 0, 1},			// CT_BLACK
+{1, 0, 0, 1},			// CT_RED
+{0, 1, 0, 1},			// CT_GREEN
+{0, 0, 1, 1},			// CT_BLUE
+{1, 1, 0, 1},			// CT_YELLOW
+{1, 0, 1, 1},			// CT_MAGENTA
+{0, 1, 1, 1},			// CT_CYAN
+{1, 1, 1, 1},			// CT_WHITE
+{0.75f, 0.75f, 0.75f, 1},	// CT_LTGREY
+{0.50f, 0.50f, 0.50f, 1},	// CT_MDGREY
+{0.25f, 0.25f, 0.25f, 1},	// CT_DKGREY
+{0.15f, 0.15f, 0.15f, 1},	// CT_DKGREY2
+
+{0.992f, 0.652f, 0.0f,  1},	// CT_VLTORANGE -- needs values
+{0.810f, 0.530f, 0.0f,  1},	// CT_LTORANGE
+{0.610f, 0.330f, 0.0f,  1},	// CT_DKORANGE
+{0.402f, 0.265f, 0.0f,  1},	// CT_VDKORANGE
+
+{0.503f, 0.375f, 0.996f, 1},	// CT_VLTBLUE1
+{0.367f, 0.261f, 0.722f, 1},	// CT_LTBLUE1
+{0.199f, 0.0f,   0.398f, 1},	// CT_DKBLUE1
+{0.160f, 0.117f, 0.324f, 1},	// CT_VDKBLUE1
+
+{0.300f, 0.628f, 0.816f, 1},	// CT_VLTBLUE2 -- needs values
+{0.300f, 0.628f, 0.816f, 1},	// CT_LTBLUE2
+{0.191f, 0.289f, 0.457f, 1},	// CT_DKBLUE2
+{0.125f, 0.250f, 0.324f, 1},	// CT_VDKBLUE2
+
+{0.796f, 0.398f, 0.199f, 1},	// CT_VLTBROWN1 -- needs values
+{0.796f, 0.398f, 0.199f, 1},	// CT_LTBROWN1
+{0.558f, 0.207f, 0.027f, 1},	// CT_DKBROWN1
+{0.328f, 0.125f, 0.035f, 1},	// CT_VDKBROWN1
+
+{0.996f, 0.796f, 0.398f, 1},	// CT_VLTGOLD1 -- needs values
+{0.996f, 0.796f, 0.398f, 1},	// CT_LTGOLD1
+{0.605f, 0.441f, 0.113f, 1},	// CT_DKGOLD1
+{0.386f, 0.308f, 0.148f, 1},	// CT_VDKGOLD1
+
+{0.648f, 0.562f, 0.784f, 1},	// CT_VLTPURPLE1 -- needs values
+{0.648f, 0.562f, 0.784f, 1},	// CT_LTPURPLE1
+{0.437f, 0.335f, 0.597f, 1},	// CT_DKPURPLE1
+{0.308f, 0.269f, 0.375f, 1},	// CT_VDKPURPLE1
+
+{0.816f, 0.531f, 0.710f, 1},	// CT_VLTPURPLE2 -- needs values
+{0.816f, 0.531f, 0.710f, 1},	// CT_LTPURPLE2
+{0.566f, 0.269f, 0.457f, 1},	// CT_DKPURPLE2
+{0.343f, 0.226f, 0.316f, 1},	// CT_VDKPURPLE2
+
+{0.929f, 0.597f, 0.929f, 1},	// CT_VLTPURPLE3
+{0.570f, 0.371f, 0.570f, 1},	// CT_LTPURPLE3
+{0.355f, 0.199f, 0.355f, 1},	// CT_DKPURPLE3
+{0.285f, 0.136f, 0.230f, 1},	// CT_VDKPURPLE3
+
+{0.953f, 0.378f, 0.250f, 1},	// CT_VLTRED1
+{0.953f, 0.378f, 0.250f, 1},	// CT_LTRED1
+{0.593f, 0.121f, 0.109f, 1},	// CT_DKRED1
+{0.429f, 0.171f, 0.113f, 1},	// CT_VDKRED1
+{.25f, 0, 0, 1},					// CT_VDKRED
+{.70f, 0, 0, 1},					// CT_DKRED
+
+{0.717f, 0.902f, 1.0f,   1},	// CT_VLTAQUA
+{0.574f, 0.722f, 0.804f, 1},	// CT_LTAQUA
+{0.287f, 0.361f, 0.402f, 1},	// CT_DKAQUA
+{0.143f, 0.180f, 0.201f, 1},	// CT_VDKAQUA
+
+{0.871f, 0.386f, 0.375f, 1},	// CT_LTPINK
+{0.435f, 0.193f, 0.187f, 1},	// CT_DKPINK
+{	  0,    .5f,    .5f, 1},	// CT_LTCYAN
+{	  0,   .25f,   .25f, 1},	// CT_DKCYAN
+{   .179f, .51f,   .92f, 1},	// CT_LTBLUE3
+{   .199f, .71f,   .92f, 1},	// CT_LTBLUE3
+{   .5f,   .05f,    .4f, 1},	// CT_DKBLUE3
+
+{   0.0f,   .613f,  .097f, 1},	// CT_HUD_GREEN
+{   0.835f, .015f,  .015f, 1},	// CT_HUD_RED
+{	.567f,	.685f,	1.0f,	.75f},	// CT_ICON_BLUE
+{	.515f,	.406f,	.507f,	1},	// CT_NO_AMMO_RED
+
+{   1.0f,   .658f,  .062f, 1},	// CT_HUD_ORANGE
+{	0.549f, .854f,  1.0f,  1.0f},	//	CT_TITLE
+};
+
+
+vec4_t	g_color_table[8] =
+	{
+	{0.0, 0.0, 0.0, 1.0},
+	{1.0, 0.0, 0.0, 1.0},
+	{0.0, 1.0, 0.0, 1.0},
+	{1.0, 1.0, 0.0, 1.0},
+	{0.0, 0.0, 1.0, 1.0},
+	{0.0, 1.0, 1.0, 1.0},
+	{1.0, 0.0, 1.0, 1.0},
+	{1.0, 1.0, 1.0, 1.0},
+	};
+
+#pragma warning(disable : 4305)		// truncation from const double to float
+
+vec3_t	bytedirs[NUMVERTEXNORMALS] =
+{
+{-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}
+};
+#pragma warning(default : 4305)		// truncation from const double to float
+
+//==============================================================
+
+
+//=======================================================
+
+/*
+erandom
+
+This function produces a random number with a exponential
+distribution and the specified mean value.
+*/
+float erandom( float mean ) {
+	float	r;
+
+	do {
+		r = random();
+	} while ( r == 0.0 );
+
+	return -mean * log( r );
+}
+
+signed char ClampChar( int i ) {
+	if ( i < -128 ) {
+		return -128;
+	}
+	if ( i > 127 ) {
+		return 127;
+	}
+	return i;
+}
+
+signed short ClampShort( int i ) {
+	if ( i < (short)0x8000 ) {
+		return (short)0x8000;
+	}
+	if ( i > 0x7fff ) {
+		return 0x7fff;
+	}
+	return i;
+}
+
+
+// this isn't a real cheap function to call!
+int DirToByte( vec3_t dir ) {
+	int		i, best;
+	float	d, bestd;
+
+	if ( !dir ) {
+		return 0;
+	}
+
+	bestd = 0;
+	best = 0;
+	for (i=0 ; i<NUMVERTEXNORMALS ; i++)
+	{
+		d = DotProduct (dir, bytedirs[i]);
+		if (d > bestd)
+		{
+			bestd = d;
+			best = i;
+		}
+	}
+
+	return best;
+}
+
+void ByteToDir( int b, vec3_t dir ) {
+	if ( b < 0 || b >= NUMVERTEXNORMALS ) {
+		VectorCopy( vec3_origin, dir );
+		return;
+	}
+	VectorCopy (bytedirs[b], dir);
+}
+
+
+unsigned ColorBytes3 (float r, float g, float b) {
+	unsigned	i;
+
+	( (byte *)&i )[0] = r * 255;
+	( (byte *)&i )[1] = g * 255;
+	( (byte *)&i )[2] = b * 255;
+
+	return i;
+}
+
+unsigned ColorBytes4 (float r, float g, float b, float a) {
+	unsigned	i;
+
+	( (byte *)&i )[0] = r * 255;
+	( (byte *)&i )[1] = g * 255;
+	( (byte *)&i )[2] = b * 255;
+	( (byte *)&i )[3] = a * 255;
+
+	return i;
+}
+
+float NormalizeColor( const vec3_t in, vec3_t out ) {
+	float	max;
+	
+	max = in[0];
+	if ( in[1] > max ) {
+		max = in[1];
+	}
+	if ( in[2] > max ) {
+		max = in[2];
+	}
+
+	if ( !max ) {
+		VectorClear( out );
+	} else {
+		out[0] = in[0] / max;
+		out[1] = in[1] / max;
+		out[2] = in[2] / max;
+	}
+	return max;
+}
+
+void VectorAdvance( const vec3_t veca, const float scale, const vec3_t vecb, vec3_t vecc)
+{
+	vecc[0] = veca[0] + (scale * (vecb[0] - veca[0]));
+	vecc[1] = veca[1] + (scale * (vecb[1] - veca[1]));
+	vecc[2] = veca[2] + (scale * (vecb[2] - veca[2]));
+}
+
+//============================================================================
+
+/*
+=====================
+PlaneFromPoints
+
+Returns false if the triangle is degenrate.
+The normal will point out of the clock for clockwise ordered points
+=====================
+*/
+qboolean PlaneFromPoints( vec4_t plane, const vec3_t a, const vec3_t b, const vec3_t c ) {
+	vec3_t	d1, d2;
+
+	VectorSubtract( b, a, d1 );
+	VectorSubtract( c, a, d2 );
+	CrossProduct( d2, d1, plane );
+	if ( VectorNormalize( plane ) == 0 ) {
+		return qfalse;
+	}
+
+	plane[3] = DotProduct( a, plane );
+	return qtrue;
+}
+
+#ifdef _XBOX
+qboolean PlaneFromPoints( vec4_t plane, const short a[3], const short b[3], const short c[3] ) {
+	vec3_t	d1, d2;
+
+	VectorSubtract( b, a, d1 );
+	VectorSubtract( c, a, d2 );
+	CrossProduct( d2, d1, plane );
+	if ( VectorNormalize( plane ) == 0 ) {
+		return qfalse;
+	}
+
+	plane[3] = DotProduct( a, plane );
+	return qtrue;
+}
+#endif
+
+/*
+===============
+RotatePointAroundVector
+
+This is not implemented very well...
+===============
+*/
+void RotatePointAroundVector( vec3_t dst, const vec3_t dir, const vec3_t point,
+							 float degrees ) {
+	float	m[3][3];
+	float	im[3][3];
+	float	zrot[3][3];
+	float	tmpmat[3][3];
+	float	rot[3][3];
+	int	i;
+	vec3_t vr, vup, vf;
+	float	rad;
+
+	vf[0] = dir[0];
+	vf[1] = dir[1];
+	vf[2] = dir[2];
+
+	PerpendicularVector( vr, dir );
+	CrossProduct( vr, vf, vup );
+
+	m[0][0] = vr[0];
+	m[1][0] = vr[1];
+	m[2][0] = vr[2];
+
+	m[0][1] = vup[0];
+	m[1][1] = vup[1];
+	m[2][1] = vup[2];
+
+	m[0][2] = vf[0];
+	m[1][2] = vf[1];
+	m[2][2] = vf[2];
+
+	memcpy( im, m, sizeof( im ) );
+
+	im[0][1] = m[1][0];
+	im[0][2] = m[2][0];
+	im[1][0] = m[0][1];
+	im[1][2] = m[2][1];
+	im[2][0] = m[0][2];
+	im[2][1] = m[1][2];
+
+	memset( zrot, 0, sizeof( zrot ) );
+	zrot[0][0] = zrot[1][1] = zrot[2][2] = 1.0F;
+
+	rad = DEG2RAD( degrees );
+	zrot[0][0] = cos( rad );
+	zrot[0][1] = sin( rad );
+	zrot[1][0] = -sin( rad );
+	zrot[1][1] = cos( rad );
+
+	MatrixMultiply( m, zrot, tmpmat );
+	MatrixMultiply( tmpmat, im, rot );
+
+	for ( i = 0; i < 3; i++ ) {
+		dst[i] = rot[i][0] * point[0] + rot[i][1] * point[1] + rot[i][2] * point[2];
+	}
+}
+
+/*
+===============
+RotateAroundDirection
+===============
+*/
+void RotateAroundDirection( vec3_t axis[3], float yaw ) {
+
+	// create an arbitrary axis[1] 
+	PerpendicularVector( axis[1], axis[0] );
+
+	// rotate it around axis[0] by yaw
+	if ( yaw ) {
+		vec3_t	temp;
+
+		VectorCopy( axis[1], temp );
+		RotatePointAroundVector( axis[1], axis[0], temp, yaw );
+	}
+
+	// cross to get axis[2]
+	CrossProduct( axis[0], axis[1], axis[2] );
+}
+
+
+
+void vectoangles( const vec3_t value1, vec3_t angles ) {
+	float	forward;
+	float	yaw, pitch;
+	
+	if ( value1[1] == 0 && value1[0] == 0 ) {
+		yaw = 0;
+		if ( value1[2] > 0 ) {
+			pitch = 90;
+		}
+		else {
+			pitch = 270;
+		}
+	}
+	else {
+		if ( value1[0] ) {
+			yaw = ( atan2 ( value1[1], value1[0] ) * 180 / M_PI );
+		}
+		else if ( value1[1] > 0 ) {
+			yaw = 90;
+		}
+		else {
+			yaw = 270;
+		}
+		if ( yaw < 0 ) {
+			yaw += 360;
+		}
+
+		forward = sqrt ( value1[0]*value1[0] + value1[1]*value1[1] );
+		pitch = ( atan2(value1[2], forward) * 180 / M_PI );
+		if ( pitch < 0 ) {
+			pitch += 360;
+		}
+	}
+
+	angles[PITCH] = -pitch;
+	angles[YAW] = yaw;
+	angles[ROLL] = 0;
+}
+
+void ProjectPointOnPlane( vec3_t dst, const vec3_t p, const vec3_t normal )
+{
+	float d;
+	vec3_t n;
+	float inv_denom;
+
+	inv_denom = 1.0F / DotProduct( normal, normal );
+
+	d = DotProduct( normal, p ) * inv_denom;
+
+	n[0] = normal[0] * inv_denom;
+	n[1] = normal[1] * inv_denom;
+	n[2] = normal[2] * inv_denom;
+
+	dst[0] = p[0] - d * n[0];
+	dst[1] = p[1] - d * n[1];
+	dst[2] = p[2] - d * n[2];
+}
+
+/*
+================
+MakeNormalVectors
+
+Given a normalized forward vector, create two
+other perpendicular vectors
+================
+*/
+void MakeNormalVectors( const vec3_t forward, vec3_t right, vec3_t up) {
+	float		d;
+
+	// this rotate and negate guarantees a vector
+	// not colinear with the original
+	right[1] = -forward[0];
+	right[2] = forward[1];
+	right[0] = forward[2];
+
+	d = DotProduct (right, forward);
+	VectorMA (right, -d, forward, right);
+	VectorNormalize (right);
+	CrossProduct (right, forward, up);
+}
+
+//============================================================================
+
+/*
+** float q_rsqrt( float number )
+*/
+float Q_rsqrt( float number )
+{
+	long i;
+	float x2, y;
+	const float threehalfs = 1.5F;
+
+	x2 = number * 0.5F;
+	y  = number;
+	i  = * ( long * ) &y;						// evil floating point bit level hacking
+	i  = 0x5f3759df - ( i >> 1 );               // what the fuck?
+	y  = * ( float * ) &i;
+	y  = y * ( threehalfs - ( x2 * y * y ) );   // 1st iteration
+//	y  = y * ( threehalfs - ( x2 * y * y ) );   // 2nd iteration, this can be removed
+
+	return y;
+}
+
+float Q_fabs( float f ) {
+	int tmp = * ( int * ) &f;
+	tmp &= 0x7FFFFFFF;
+	return * ( float * ) &tmp;
+}
+
+//============================================================
+
+
+//float	AngleMod(float a) {
+//	a = (360.0/65536) * ((int)(a*(65536/360.0)) & 65535);
+//	return a;
+//}
+
+
+
+//============================================================
+
+
+/*
+=================
+SetPlaneSignbits
+=================
+*/
+void SetPlaneSignbits (cplane_t *out) {
+	int	bits, j;
+
+	// for fast box on planeside test
+	bits = 0;
+	for (j=0 ; j<3 ; j++) {
+		if (out->normal[j] < 0) {
+			bits |= 1<<j;
+		}
+	}
+	out->signbits = bits;
+}
+
+
+/*
+==================
+BoxOnPlaneSide
+
+Returns 1, 2, or 1 + 2
+
+// this is the slow, general version
+int BoxOnPlaneSide2 (vec3_t emins, vec3_t emaxs, struct cplane_s *p)
+{
+	int		i;
+	float	dist1, dist2;
+	int		sides;
+	vec3_t	corners[2];
+
+	for (i=0 ; i<3 ; i++)
+	{
+		if (p->normal[i] < 0)
+		{
+			corners[0][i] = emins[i];
+			corners[1][i] = emaxs[i];
+		}
+		else
+		{
+			corners[1][i] = emins[i];
+			corners[0][i] = emaxs[i];
+		}
+	}
+	dist1 = DotProduct (p->normal, corners[0]) - p->dist;
+	dist2 = DotProduct (p->normal, corners[1]) - p->dist;
+	sides = 0;
+	if (dist1 >= 0)
+		sides = 1;
+	if (dist2 < 0)
+		sides |= 2;
+
+	return sides;
+}
+
+==================
+*/
+
+#if !(defined __linux__ && defined __i386__) || defined __LCC__
+#if !id386
+
+int BoxOnPlaneSide (vec3_t emins, vec3_t emaxs, struct cplane_s *p)
+{
+	float	dist1, dist2;
+	int		sides;
+
+// fast axial cases
+	if (p->type < 3)
+	{
+		if (p->dist <= emins[p->type])
+			return 1;
+		if (p->dist >= emaxs[p->type])
+			return 2;
+		return 3;
+	}
+	
+// general case
+	switch (p->signbits)
+	{
+	case 0:
+		dist1 = p->normal[0]*emaxs[0] + p->normal[1]*emaxs[1] + p->normal[2]*emaxs[2];
+		dist2 = p->normal[0]*emins[0] + p->normal[1]*emins[1] + p->normal[2]*emins[2];
+		break;
+	case 1:
+		dist1 = p->normal[0]*emins[0] + p->normal[1]*emaxs[1] + p->normal[2]*emaxs[2];
+		dist2 = p->normal[0]*emaxs[0] + p->normal[1]*emins[1] + p->normal[2]*emins[2];
+		break;
+	case 2:
+		dist1 = p->normal[0]*emaxs[0] + p->normal[1]*emins[1] + p->normal[2]*emaxs[2];
+		dist2 = p->normal[0]*emins[0] + p->normal[1]*emaxs[1] + p->normal[2]*emins[2];
+		break;
+	case 3:
+		dist1 = p->normal[0]*emins[0] + p->normal[1]*emins[1] + p->normal[2]*emaxs[2];
+		dist2 = p->normal[0]*emaxs[0] + p->normal[1]*emaxs[1] + p->normal[2]*emins[2];
+		break;
+	case 4:
+		dist1 = p->normal[0]*emaxs[0] + p->normal[1]*emaxs[1] + p->normal[2]*emins[2];
+		dist2 = p->normal[0]*emins[0] + p->normal[1]*emins[1] + p->normal[2]*emaxs[2];
+		break;
+	case 5:
+		dist1 = p->normal[0]*emins[0] + p->normal[1]*emaxs[1] + p->normal[2]*emins[2];
+		dist2 = p->normal[0]*emaxs[0] + p->normal[1]*emins[1] + p->normal[2]*emaxs[2];
+		break;
+	case 6:
+		dist1 = p->normal[0]*emaxs[0] + p->normal[1]*emins[1] + p->normal[2]*emins[2];
+		dist2 = p->normal[0]*emins[0] + p->normal[1]*emaxs[1] + p->normal[2]*emaxs[2];
+		break;
+	case 7:
+		dist1 = p->normal[0]*emins[0] + p->normal[1]*emins[1] + p->normal[2]*emins[2];
+		dist2 = p->normal[0]*emaxs[0] + p->normal[1]*emaxs[1] + p->normal[2]*emaxs[2];
+		break;
+	default:
+		dist1 = dist2 = 0;		// shut up compiler
+		break;
+	}
+
+	sides = 0;
+	if (dist1 >= p->dist)
+		sides = 1;
+	if (dist2 < p->dist)
+		sides |= 2;
+
+	return sides;
+}
+#else
+#pragma warning( disable: 4035 )
+
+__declspec( naked ) int BoxOnPlaneSide (vec3_t emins, vec3_t emaxs, struct cplane_s *p)
+{
+	static int bops_initialized;
+	static int Ljmptab[8];
+
+	__asm {
+
+		push ebx
+			
+		cmp bops_initialized, 1
+		je  initialized
+		mov bops_initialized, 1
+		
+		mov Ljmptab[0*4], offset Lcase0
+		mov Ljmptab[1*4], offset Lcase1
+		mov Ljmptab[2*4], offset Lcase2
+		mov Ljmptab[3*4], offset Lcase3
+		mov Ljmptab[4*4], offset Lcase4
+		mov Ljmptab[5*4], offset Lcase5
+		mov Ljmptab[6*4], offset Lcase6
+		mov Ljmptab[7*4], offset Lcase7
+			
+initialized:
+
+		mov edx,dword ptr[4+12+esp]
+		mov ecx,dword ptr[4+4+esp]
+		xor eax,eax
+		mov ebx,dword ptr[4+8+esp]
+		mov al,byte ptr[17+edx]
+		cmp al,8
+		jge Lerror
+		fld dword ptr[0+edx]
+		fld st(0)
+		jmp dword ptr[Ljmptab+eax*4]
+Lcase0:
+		fmul dword ptr[ebx]
+		fld dword ptr[0+4+edx]
+		fxch st(2)
+		fmul dword ptr[ecx]
+		fxch st(2)
+		fld st(0)
+		fmul dword ptr[4+ebx]
+		fld dword ptr[0+8+edx]
+		fxch st(2)
+		fmul dword ptr[4+ecx]
+		fxch st(2)
+		fld st(0)
+		fmul dword ptr[8+ebx]
+		fxch st(5)
+		faddp st(3),st(0)
+		fmul dword ptr[8+ecx]
+		fxch st(1)
+		faddp st(3),st(0)
+		fxch st(3)
+		faddp st(2),st(0)
+		jmp LSetSides
+Lcase1:
+		fmul dword ptr[ecx]
+		fld dword ptr[0+4+edx]
+		fxch st(2)
+		fmul dword ptr[ebx]
+		fxch st(2)
+		fld st(0)
+		fmul dword ptr[4+ebx]
+		fld dword ptr[0+8+edx]
+		fxch st(2)
+		fmul dword ptr[4+ecx]
+		fxch st(2)
+		fld st(0)
+		fmul dword ptr[8+ebx]
+		fxch st(5)
+		faddp st(3),st(0)
+		fmul dword ptr[8+ecx]
+		fxch st(1)
+		faddp st(3),st(0)
+		fxch st(3)
+		faddp st(2),st(0)
+		jmp LSetSides
+Lcase2:
+		fmul dword ptr[ebx]
+		fld dword ptr[0+4+edx]
+		fxch st(2)
+		fmul dword ptr[ecx]
+		fxch st(2)
+		fld st(0)
+		fmul dword ptr[4+ecx]
+		fld dword ptr[0+8+edx]
+		fxch st(2)
+		fmul dword ptr[4+ebx]
+		fxch st(2)
+		fld st(0)
+		fmul dword ptr[8+ebx]
+		fxch st(5)
+		faddp st(3),st(0)
+		fmul dword ptr[8+ecx]
+		fxch st(1)
+		faddp st(3),st(0)
+		fxch st(3)
+		faddp st(2),st(0)
+		jmp LSetSides
+Lcase3:
+		fmul dword ptr[ecx]
+		fld dword ptr[0+4+edx]
+		fxch st(2)
+		fmul dword ptr[ebx]
+		fxch st(2)
+		fld st(0)
+		fmul dword ptr[4+ecx]
+		fld dword ptr[0+8+edx]
+		fxch st(2)
+		fmul dword ptr[4+ebx]
+		fxch st(2)
+		fld st(0)
+		fmul dword ptr[8+ebx]
+		fxch st(5)
+		faddp st(3),st(0)
+		fmul dword ptr[8+ecx]
+		fxch st(1)
+		faddp st(3),st(0)
+		fxch st(3)
+		faddp st(2),st(0)
+		jmp LSetSides
+Lcase4:
+		fmul dword ptr[ebx]
+		fld dword ptr[0+4+edx]
+		fxch st(2)
+		fmul dword ptr[ecx]
+		fxch st(2)
+		fld st(0)
+		fmul dword ptr[4+ebx]
+		fld dword ptr[0+8+edx]
+		fxch st(2)
+		fmul dword ptr[4+ecx]
+		fxch st(2)
+		fld st(0)
+		fmul dword ptr[8+ecx]
+		fxch st(5)
+		faddp st(3),st(0)
+		fmul dword ptr[8+ebx]
+		fxch st(1)
+		faddp st(3),st(0)
+		fxch st(3)
+		faddp st(2),st(0)
+		jmp LSetSides
+Lcase5:
+		fmul dword ptr[ecx]
+		fld dword ptr[0+4+edx]
+		fxch st(2)
+		fmul dword ptr[ebx]
+		fxch st(2)
+		fld st(0)
+		fmul dword ptr[4+ebx]
+		fld dword ptr[0+8+edx]
+		fxch st(2)
+		fmul dword ptr[4+ecx]
+		fxch st(2)
+		fld st(0)
+		fmul dword ptr[8+ecx]
+		fxch st(5)
+		faddp st(3),st(0)
+		fmul dword ptr[8+ebx]
+		fxch st(1)
+		faddp st(3),st(0)
+		fxch st(3)
+		faddp st(2),st(0)
+		jmp LSetSides
+Lcase6:
+		fmul dword ptr[ebx]
+		fld dword ptr[0+4+edx]
+		fxch st(2)
+		fmul dword ptr[ecx]
+		fxch st(2)
+		fld st(0)
+		fmul dword ptr[4+ecx]
+		fld dword ptr[0+8+edx]
+		fxch st(2)
+		fmul dword ptr[4+ebx]
+		fxch st(2)
+		fld st(0)
+		fmul dword ptr[8+ecx]
+		fxch st(5)
+		faddp st(3),st(0)
+		fmul dword ptr[8+ebx]
+		fxch st(1)
+		faddp st(3),st(0)
+		fxch st(3)
+		faddp st(2),st(0)
+		jmp LSetSides
+Lcase7:
+		fmul dword ptr[ecx]
+		fld dword ptr[0+4+edx]
+		fxch st(2)
+		fmul dword ptr[ebx]
+		fxch st(2)
+		fld st(0)
+		fmul dword ptr[4+ecx]
+		fld dword ptr[0+8+edx]
+		fxch st(2)
+		fmul dword ptr[4+ebx]
+		fxch st(2)
+		fld st(0)
+		fmul dword ptr[8+ecx]
+		fxch st(5)
+		faddp st(3),st(0)
+		fmul dword ptr[8+ebx]
+		fxch st(1)
+		faddp st(3),st(0)
+		fxch st(3)
+		faddp st(2),st(0)
+LSetSides:
+		faddp st(2),st(0)
+		fcomp dword ptr[12+edx]
+		xor ecx,ecx
+		fnstsw ax
+		fcomp dword ptr[12+edx]
+		and ah,1
+		xor ah,1
+		add cl,ah
+		fnstsw ax
+		and ah,1
+		add ah,ah
+		add cl,ah
+		pop ebx
+		mov eax,ecx
+		ret
+Lerror:
+		int 3
+	}
+}
+#pragma warning( default: 4035 )
+
+#endif
+#endif
+
+/*
+=================
+RadiusFromBounds
+=================
+*/
+float RadiusFromBounds( const vec3_t mins, const vec3_t maxs ) {
+	int		i;
+	vec3_t	corner;
+	float	a, b;
+
+	for (i=0 ; i<3 ; i++) {
+		a = Q_fabs( mins[i] );
+		b = Q_fabs( maxs[i] );
+		corner[i] = a > b ? a : b;
+	}
+
+	return VectorLength (corner);
+}
+
+
+void ClearBounds( vec3_t mins, vec3_t maxs ) {
+	mins[0] = mins[1] = mins[2] =  WORLD_SIZE;	//99999;	// I used WORLD_SIZE instead of MAX_WORLD_COORD...
+	maxs[0] = maxs[1] = maxs[2] = -WORLD_SIZE;	//-99999;	// ... so it would definately be beyond furthese legal.
+}
+
+
+vec_t DistanceHorizontal( const vec3_t p1, const vec3_t p2 ) {
+	vec3_t	v;
+
+	VectorSubtract( p2, p1, v );
+	return sqrt( v[0]*v[0] + v[1]*v[1] );	//Leave off the z component
+}
+
+vec_t DistanceHorizontalSquared( const vec3_t p1, const vec3_t p2 ) {
+	vec3_t	v;
+
+	VectorSubtract( p2, p1, v );
+	return v[0]*v[0] + v[1]*v[1];	//Leave off the z component
+}
+
+int Q_log2( int val ) {
+	int answer;
+
+	answer = 0;
+	while ( ( val>>=1 ) != 0 ) {
+		answer++;
+	}
+	return answer;
+}
+
+
+/*
+=================
+PlaneTypeForNormal
+=================
+*/
+int	PlaneTypeForNormal (vec3_t normal) {
+	if ( normal[0] == 1.0 )
+		return PLANE_X;
+	if ( normal[1] == 1.0 )
+		return PLANE_Y;
+	if ( normal[2] == 1.0 )
+		return PLANE_Z;
+	
+	return PLANE_NON_AXIAL;
+}
+
+
+
+/*
+================
+MatrixMultiply
+================
+*/
+void MatrixMultiply(float in1[3][3], float in2[3][3], float out[3][3]) {
+	out[0][0] = in1[0][0] * in2[0][0] + in1[0][1] * in2[1][0] +
+				in1[0][2] * in2[2][0];
+	out[0][1] = in1[0][0] * in2[0][1] + in1[0][1] * in2[1][1] +
+				in1[0][2] * in2[2][1];
+	out[0][2] = in1[0][0] * in2[0][2] + in1[0][1] * in2[1][2] +
+				in1[0][2] * in2[2][2];
+	out[1][0] = in1[1][0] * in2[0][0] + in1[1][1] * in2[1][0] +
+				in1[1][2] * in2[2][0];
+	out[1][1] = in1[1][0] * in2[0][1] + in1[1][1] * in2[1][1] +
+				in1[1][2] * in2[2][1];
+	out[1][2] = in1[1][0] * in2[0][2] + in1[1][1] * in2[1][2] +
+				in1[1][2] * in2[2][2];
+	out[2][0] = in1[2][0] * in2[0][0] + in1[2][1] * in2[1][0] +
+				in1[2][2] * in2[2][0];
+	out[2][1] = in1[2][0] * in2[0][1] + in1[2][1] * in2[1][1] +
+				in1[2][2] * in2[2][1];
+	out[2][2] = in1[2][0] * in2[0][2] + in1[2][1] * in2[1][2] +
+				in1[2][2] * in2[2][2];
+}
+
+
+void AngleVectors( const vec3_t angles, vec3_t forward, vec3_t right, vec3_t up) {
+	float		angle;
+	static float		sr, sp, sy, cr, cp, cy;
+	// static to help MS compiler fp bugs
+
+	angle = angles[YAW] * (M_PI*2 / 360.0);
+	sy = sin(angle);
+	cy = cos(angle);
+	angle = angles[PITCH] * (M_PI*2 / 360.0);
+	sp = sin(angle);
+	cp = cos(angle);
+
+	if (forward)
+	{
+		forward[0] = cp*cy;
+		forward[1] = cp*sy;
+		forward[2] = -sp;
+	}
+	if (right || up)
+	{
+		angle = angles[ROLL] * (M_PI*2 / 360.0);
+		sr = sin(angle);
+		cr = cos(angle);
+		if (right)
+		{
+			right[0] = (-sr*sp*cy + cr*sy);
+			right[1] = (-sr*sp*sy + -cr*cy);
+			right[2] = -sr*cp;
+		}
+		if (up)
+		{
+			up[0] = (cr*sp*cy + sr*sy);
+			up[1] = (cr*sp*sy + -sr*cy);
+			up[2] = cr*cp;
+		}
+	}
+}
+
+/*
+** assumes "src" is normalized
+*/
+void PerpendicularVector( vec3_t dst, const vec3_t src )
+{
+	int	pos;
+	int i;
+	float minelem = 1.0F;
+	vec3_t tempvec;
+
+	/*
+	** find the smallest magnitude axially aligned vector
+	** bias towards using z instead of x or y
+	*/
+	for ( pos = 0, i = 2; i >= 0; i-- )
+	{
+		if ( Q_fabs( src[i] ) < minelem )
+		{
+			pos = i;
+			minelem = Q_fabs( src[i] );
+		}
+	}
+	tempvec[0] = tempvec[1] = tempvec[2] = 0.0F;
+	tempvec[pos] = 1.0F;
+
+	/*
+	** project the point onto the plane defined by src
+	*/
+	ProjectPointOnPlane( dst, tempvec, src );
+
+	/*
+	** normalize the result
+	*/
+	VectorNormalize( dst );
+}
+
+/*
+-------------------------
+DotProductNormalize
+-------------------------
+*/
+
+float DotProductNormalize( const vec3_t inVec1, const vec3_t inVec2 )
+{
+	vec3_t	v1, v2;
+
+	VectorNormalize2( inVec1, v1 );
+	VectorNormalize2( inVec2, v2 );
+
+	return DotProduct(v1, v2);
+}
+
+/*
+-------------------------
+G_FindClosestPointOnLineSegment
+-------------------------
+*/
+
+qboolean G_FindClosestPointOnLineSegment( const vec3_t start, const vec3_t end, const vec3_t from, vec3_t result )
+{
+	vec3_t	vecStart2From, vecStart2End, vecEnd2Start, vecEnd2From;
+	float	distEnd2From, distEnd2Result, theta, cos_theta;
+
+	//Find the perpendicular vector to vec from start to end
+	VectorSubtract( from, start, vecStart2From);
+	VectorSubtract( end, start, vecStart2End);
+
+	float dot = DotProductNormalize( vecStart2From, vecStart2End );
+
+	if ( dot <= 0 )
+	{
+		//The perpendicular would be beyond or through the start point
+		VectorCopy( start, result );
+		return qfalse;
+	}
+
+	if ( dot == 1 )
+	{
+		//parallel, closer of 2 points will be the target
+		if( (VectorLengthSquared( vecStart2From )) < (VectorLengthSquared( vecStart2End )) )
+		{
+			VectorCopy( from, result );
+		}
+		else
+		{
+			VectorCopy( end, result );
+		}
+		return qfalse;
+	}
+
+	//Try other end
+	VectorSubtract( from, end, vecEnd2From);
+	VectorSubtract( start, end, vecEnd2Start);
+
+	dot = DotProductNormalize( vecEnd2From, vecEnd2Start );
+
+	if ( dot <= 0 )
+	{//The perpendicular would be beyond or through the start point
+		VectorCopy( end, result );
+		return qfalse;
+	}
+
+	if ( dot == 1 )
+	{//parallel, closer of 2 points will be the target
+		if( (VectorLengthSquared( vecEnd2From )) < (VectorLengthSquared( vecEnd2Start )))
+		{
+			VectorCopy( from, result );
+		}
+		else
+		{
+			VectorCopy( end, result );
+		}
+		return qfalse;
+	}
+
+	//		      /|
+	//		  c  / |
+	//		    /  |a
+	//	theta  /)__|    
+	//		      b
+	//cos(theta) = b / c
+	//solve for b
+	//b = cos(theta) * c
+
+	//angle between vecs end2from and end2start, should be between 0 and 90
+	theta = 90 * (1 - dot);//theta
+	
+	//Get length of side from End2Result using sine of theta
+	distEnd2From = VectorLength( vecEnd2From );//c
+	cos_theta = cos(DEG2RAD(theta));//cos(theta)
+	distEnd2Result = cos_theta * distEnd2From;//b
+
+	//Extrapolate to find result
+	VectorNormalize( vecEnd2Start );
+	VectorMA( end, distEnd2Result, vecEnd2Start, result );
+	
+	//perpendicular intersection is between the 2 endpoints
+	return qtrue;
+}
+
+float G_PointDistFromLineSegment( const vec3_t start, const vec3_t end, const vec3_t from )
+{
+	vec3_t	vecStart2From, vecStart2End, vecEnd2Start, vecEnd2From, intersection;
+	float	distEnd2From, distStart2From, distEnd2Result, theta, cos_theta;
+
+	//Find the perpendicular vector to vec from start to end
+	VectorSubtract( from, start, vecStart2From);
+	VectorSubtract( end, start, vecStart2End);
+	VectorSubtract( from, end, vecEnd2From);
+	VectorSubtract( start, end, vecEnd2Start);
+
+	float dot = DotProductNormalize( vecStart2From, vecStart2End );
+
+	distStart2From = Distance( start, from );
+	distEnd2From = Distance( end, from );
+
+	if ( dot <= 0 )
+	{
+		//The perpendicular would be beyond or through the start point
+		return distStart2From;
+	}
+
+	if ( dot == 1 )
+	{
+		//parallel, closer of 2 points will be the target
+		return ((distStart2From<distEnd2From)?distStart2From:distEnd2From);
+	}
+
+	//Try other end
+
+	dot = DotProductNormalize( vecEnd2From, vecEnd2Start );
+
+	if ( dot <= 0 )
+	{//The perpendicular would be beyond or through the end point
+		return distEnd2From;
+	}
+
+	if ( dot == 1 )
+	{//parallel, closer of 2 points will be the target
+		return ((distStart2From<distEnd2From)?distStart2From:distEnd2From);
+	}
+
+	//		      /|
+	//		  c  / |
+	//		    /  |a
+	//	theta  /)__|    
+	//		      b
+	//cos(theta) = b / c
+	//solve for b
+	//b = cos(theta) * c
+
+	//angle between vecs end2from and end2start, should be between 0 and 90
+	theta = 90 * (1 - dot);//theta
+	
+	//Get length of side from End2Result using sine of theta
+	cos_theta = cos(DEG2RAD(theta));//cos(theta)
+	distEnd2Result = cos_theta * distEnd2From;//b
+
+	//Extrapolate to find result
+	VectorNormalize( vecEnd2Start );
+	VectorMA( end, distEnd2Result, vecEnd2Start, intersection );
+	
+	//perpendicular intersection is between the 2 endpoints, return dist to it from from
+	return Distance( intersection, from );
+}
diff --git a/code/game/q_shared.cpp b/code/game/q_shared.cpp
new file mode 100644
index 0000000..a97baf1
--- /dev/null
+++ b/code/game/q_shared.cpp
@@ -0,0 +1,1213 @@
+// q_shared.c -- stateless support routines that are included in each code dll
+
+// leave this at the top for PCH reasons...
+#include "common_headers.h"
+
+//#include "q_shared.h"
+
+float Com_Clamp( float min, float max, float value ) {
+	if ( value < min ) {
+		return min;
+	}
+	if ( value > max ) {
+		return max;
+	}
+	return value;
+}
+
+
+/*
+============
+COM_SkipPath
+============
+*/
+char *COM_SkipPath (char *pathname)
+{
+	char	*last;
+	
+	last = pathname;
+	while (*pathname)
+	{
+		if (*pathname=='/')
+			last = pathname+1;
+		pathname++;
+	}
+	return last;
+}
+
+/*
+============
+COM_StripExtension
+============
+*/
+void COM_StripExtension( const char *in, char *out ) {
+	while ( *in && *in != '.' ) {
+		*out++ = *in++;
+	}
+	*out = 0;
+}
+
+
+/*
+==================
+COM_DefaultExtension
+==================
+*/
+void COM_DefaultExtension (char *path, int maxSize, const char *extension ) {
+	char    *src;
+
+	if (path[0])	// or the strlen()-1 stuff gets a bad ptr for blank string
+	{
+	//
+	// if path doesn't have a .EXT, append extension
+	// (extension should include the .)
+	//
+		src = path + strlen(path) - 1;
+
+		while (*src != '/' && src != path) {
+			if ( *src == '.' ) {
+				return;                 // it has an extension
+			}
+			src--;
+		}
+	}
+
+	if (strlen(path)+strlen(extension) >= maxSize)
+	{
+		Com_Printf ("COM_DefaultExtension: overflow adding %s to %s\n", extension, path);
+	}
+	else
+	{
+		strcat(path, extension);
+	}
+}
+
+/*
+============================================================================
+
+					BYTE ORDER FUNCTIONS
+
+============================================================================
+*/
+
+// can't just use function pointers, or dll linkage can
+// mess up when qcommon is included in multiple places
+static short	(*_BigShort) (short l);
+static short	(*_LittleShort) (short l);
+static int		(*_BigLong) (int l);
+static int		(*_LittleLong) (int l);
+static float	(*_BigFloat) (float l);
+static float	(*_LittleFloat) (float l);
+
+#ifdef _M_IX86
+//
+// optimised stuff for Intel, since most of our data is in that format anyway...
+//
+short	BigShort(short l){return _BigShort(l);}
+int		BigLong (int l) {return _BigLong(l);}
+float	BigFloat (float l) {return _BigFloat(l);}
+//short	LittleShort(short l) {return _LittleShort(l);}	// these are now macros in q_shared.h
+//int		LittleLong (int l) {return _LittleLong(l);}	//
+//float	LittleFloat (float l) {return _LittleFloat(l);}	//
+//
+#else
+//
+// standard smart-swap code...
+//
+short	BigShort(short l){return _BigShort(l);}
+short	LittleShort(short l) {return _LittleShort(l);}
+int		BigLong (int l) {return _BigLong(l);}
+int		LittleLong (int l) {return _LittleLong(l);}
+float	BigFloat (float l) {return _BigFloat(l);}
+float	LittleFloat (float l) {return _LittleFloat(l);}
+//
+#endif
+
+short   ShortSwap (short l)
+{
+	byte    b1,b2;
+
+	b1 = l&255;
+	b2 = (l>>8)&255;
+
+	return (b1<<8) + b2;
+}
+
+short	ShortNoSwap (short l)
+{
+	return l;
+}
+
+int    LongSwap (int l)
+{
+	byte    b1,b2,b3,b4;
+
+	b1 = l&255;
+	b2 = (l>>8)&255;
+	b3 = (l>>16)&255;
+	b4 = (l>>24)&255;
+
+	return ((int)b1<<24) + ((int)b2<<16) + ((int)b3<<8) + b4;
+}
+
+int	LongNoSwap (int l)
+{
+	return l;
+}
+
+float FloatSwap (float f)
+{
+	union
+	{
+		float	f;
+		byte	b[4];
+	} dat1, dat2;
+	
+	
+	dat1.f = f;
+	dat2.b[0] = dat1.b[3];
+	dat2.b[1] = dat1.b[2];
+	dat2.b[2] = dat1.b[1];
+	dat2.b[3] = dat1.b[0];
+	return dat2.f;
+}
+
+float FloatNoSwap (float f)
+{
+	return f;
+}
+
+/*
+================
+Swap_Init
+================
+*/
+void Swap_Init (void)
+{
+	byte	swaptest[2] = {1,0};
+
+// set the byte swapping variables in a portable manner	
+	if ( *(short *)swaptest == 1)
+	{
+		_BigShort = ShortSwap;
+		_LittleShort = ShortNoSwap;
+		_BigLong = LongSwap;
+		_LittleLong = LongNoSwap;
+		_BigFloat = FloatSwap;
+		_LittleFloat = FloatNoSwap;
+	}
+	else
+	{
+		_BigShort = ShortNoSwap;
+		_LittleShort = ShortSwap;
+		_BigLong = LongNoSwap;
+		_LittleLong = LongSwap;
+		_BigFloat = FloatNoSwap;
+		_LittleFloat = FloatSwap;
+	}
+
+}
+
+
+/*
+============================================================================
+
+PARSING
+
+============================================================================
+*/
+
+static	char	com_token[MAX_TOKEN_CHARS];
+//JLFCALLOUT MPNOTUSED
+//#include functionality for files
+int parseDataCount = -1;
+parseData_t parseData[2];
+
+void COM_ParseInit( void )
+{
+	memset(&(parseData[0]),0,sizeof(parseData_t));
+	memset(&(parseData[1]),0,sizeof(parseData_t));
+	COM_BeginParseSession();
+}
+
+#ifdef _XBOX
+void COM_BeginParseSession( bool nested )
+{
+	if (nested)
+		parseDataCount =1;
+	else
+		parseDataCount = 0;
+	parseData[parseDataCount].com_lines = 1;
+	
+}
+#else
+void COM_BeginParseSession( void )
+{
+	parseDataCount =0;
+	parseData[parseDataCount].com_lines = 1;
+	
+}
+
+#endif
+
+int COM_GetCurrentParseLine( int index )
+{
+	return parseData[parseDataCount].com_lines;
+}
+
+char *COM_Parse( const char **data_p )
+{
+	return COM_ParseExt( data_p, qtrue );
+}
+
+/*
+==============
+COM_Parse
+
+Parse a token out of a string
+Will never return NULL, just empty strings
+
+If "allowLineBreaks" is qtrue then an empty
+string will be returned if the next token is
+a newline.
+==============
+*/
+const char *SkipWhitespace( const char *data, qboolean *hasNewLines ) 
+{
+	int c;
+
+	while( (c = *data) <= ' ') 
+	{
+		if( !c ) 
+		{
+			return NULL;
+		}
+		if( c == '\n' ) 
+		{
+			parseData[parseDataCount].com_lines++;
+			*hasNewLines = qtrue;
+		}
+		data++;
+	}
+
+	return data;
+}
+
+char *COM_ParseExt( const char **data_p, qboolean allowLineBreaks )
+{
+	int c = 0, len;
+	qboolean hasNewLines = qfalse;
+	const char *data;
+
+	data = *data_p;
+	len = 0;
+	com_token[0] = 0;
+
+	// make sure incoming data is valid
+	if ( !data )
+	{
+		*data_p = NULL;
+		return com_token;
+	}
+
+	while ( 1 )
+	{
+		// skip whitespace
+		data = SkipWhitespace( data, &hasNewLines );
+		if ( !data )
+		{
+			*data_p = NULL;
+			return com_token;
+		}
+		if ( hasNewLines && !allowLineBreaks )
+		{
+			*data_p = data;
+			return com_token;
+		}
+
+		c = *data;
+
+		// skip double slash comments
+		if ( c == '/' && data[1] == '/' )
+		{
+			while (*data && *data != '\n')	// Advance to the end of the line
+			{
+				data++;
+			}
+		}
+		// skip /* */ comments
+		else if ( c=='/' && data[1] == '*' ) 
+		{
+			while ( *data && ( *data != '*' || data[1] != '/' ) )	// Advance to the */ characters
+			{
+				data++;
+			}
+
+			if ( *data ) 
+			{
+				data += 2;
+			}
+		}
+		else
+		{
+			break;
+		}
+	}
+
+	// handle quoted strings
+	if (c == '\"')
+	{
+		data++;
+		while (1)
+		{
+			c = *data++;
+			if (c=='\"' || !c)
+			{
+				com_token[len] = 0;
+				*data_p = ( char * ) data;
+				return com_token;
+			}
+			if (len < MAX_TOKEN_CHARS)
+			{
+				com_token[len] = c;
+				len++;
+			}
+		}
+	}
+
+	// parse a regular word
+	do
+	{
+		if (len < MAX_TOKEN_CHARS)
+		{
+			com_token[len] = c;
+			len++;
+		}
+		data++;
+		c = *data;
+		if ( c == '\n' )
+		{
+			parseData[parseDataCount].com_lines++;
+		}
+	} while (c>32);
+
+	if (len == MAX_TOKEN_CHARS)
+	{
+		Com_Printf ("Token exceeded %i chars, discarded.\n", MAX_TOKEN_CHARS);
+		len = 0;
+	}
+	com_token[len] = 0;
+
+	*data_p = ( char * ) data;
+	return com_token;
+}
+
+
+/*
+==============
+COM_Compress
+remove blank space and comments from source
+==============
+*/
+
+int COM_Compress( char *data_p ) {
+	char *in, *out;
+	int c;
+	qboolean newline = qfalse, whitespace = qfalse;
+	
+	in = out = data_p;
+	if (in) {
+		while ((c = *in) != 0) {
+			// skip double slash comments
+			if ( c == '/' && in[1] == '/' ) {
+				while (*in && *in != '\n') {
+					in++;
+				}
+				// skip /* */ comments
+			} else if ( c == '/' && in[1] == '*' ) {
+				while ( *in && ( *in != '*' || in[1] != '/' ) ) 
+					in++;
+				if ( *in ) 
+					in += 2;
+				// record when we hit a newline
+			} else if ( c == '\n' || c == '\r' ) {
+				newline = qtrue;
+				in++;
+				// record when we hit whitespace
+			} else if ( c == ' ' || c == '\t') {
+				whitespace = qtrue;
+				in++;
+				// an actual token
+			} else {
+				// if we have a pending newline, emit it (and it counts as whitespace)
+				if (newline) {
+					*out++ = '\n';
+					newline = qfalse;
+					whitespace = qfalse;
+				} if (whitespace) {
+					*out++ = ' ';
+					whitespace = qfalse;
+				}
+				
+				// copy quoted strings unmolested
+				if (c == '"') {
+					*out++ = c;
+					in++;
+					while (1) {
+						c = *in;
+						if (c && c != '"') {
+							*out++ = c;
+							in++;
+						} else {
+							break;
+						}
+					}
+					if (c == '"') {
+						*out++ = c;
+						in++;
+					}
+				} else {
+					*out = c;
+					out++;
+					in++;
+				}
+			}
+		}
+	}
+	*out = 0;
+	return out - data_p;
+}
+
+
+/*
+==================
+COM_MatchToken
+==================
+*/
+void COM_MatchToken( const char **buf_p, const char *match ) {
+	const char	*token;
+
+	token = COM_Parse( buf_p );
+	if ( strcmp( token, match ) ) 
+	{
+		Com_Error( ERR_DROP, "MatchToken: %s != %s", token, match );
+	}
+}
+
+
+/*
+=================
+SkipBracedSection
+
+The next token should be an open brace.
+Skips until a matching close brace is found.
+Internal brace depths are properly skipped.
+=================
+*/
+void SkipBracedSection ( const char **program) {
+	const char			*token;
+	int				depth=0;
+
+	if (com_token[0]=='{') {	//for tr_shader which just ate the brace
+		depth = 1;
+	}
+	do {
+		token = COM_ParseExt( program, qtrue );
+		if( token[1] == 0 ) {
+			if( token[0] == '{' ) {
+				depth++;
+
+			}
+			else if( token[0] == '}' ) {
+				depth--;
+			}
+		}
+
+	} while (depth && *program);
+}
+
+/*
+=================
+SkipRestOfLine
+=================
+*/
+void SkipRestOfLine ( const char **data ) {
+	const char	*p;
+	int		c;
+
+	p = *data;
+	while ( (c = *p++) != 0 ) {
+		if ( c == '\n' ) {
+			parseData[parseDataCount].com_lines++;
+			break;
+		}
+	}
+
+	*data = p;
+}
+
+
+void Parse1DMatrix ( const char **buf_p, int x, float *m) {
+	const char	*token;
+	int		i;
+
+	COM_MatchToken( buf_p, "(" );
+
+	for (i = 0 ; i < x ; i++) {
+		token = COM_Parse(buf_p);
+		m[i] = atof(token);
+	}
+
+	COM_MatchToken( buf_p, ")" );
+}
+
+void Parse2DMatrix ( const char **buf_p, int y, int x, float *m) {
+	int		i;
+
+	COM_MatchToken( buf_p, "(" );
+
+	for (i = 0 ; i < y ; i++) {
+		Parse1DMatrix (buf_p, x, m + i * x);
+	}
+
+	COM_MatchToken( buf_p, ")" );
+}
+
+void Parse3DMatrix ( const char **buf_p, int z, int y, int x, float *m) {
+	int		i;
+
+	COM_MatchToken( buf_p, "(" );
+
+	for (i = 0 ; i < z ; i++) {
+		Parse2DMatrix (buf_p, y, x, m + i * x*y);
+	}
+
+	COM_MatchToken( buf_p, ")" );
+}
+
+
+/*
+============================================================================
+
+					LIBRARY REPLACEMENT FUNCTIONS
+
+============================================================================
+*/
+
+int Q_isprint( int c )
+{
+	if ( c >= 0x20 && c <= 0x7E )
+		return ( 1 );
+	return ( 0 );
+}
+
+int Q_islower( int c )
+{
+	if (c >= 'a' && c <= 'z')
+		return ( 1 );
+	return ( 0 );
+}
+
+int Q_isupper( int c )
+{
+	if (c >= 'A' && c <= 'Z')
+		return ( 1 );
+	return ( 0 );
+}
+
+int Q_isalpha( int c )
+{
+	if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'))
+		return ( 1 );
+	return ( 0 );
+}
+
+/*
+char* Q_strrchr( const char* string, int c )
+{
+	char cc = c;
+	char *s;
+	char *sp=(char *)0;
+
+	s = (char*)string;
+
+	while (*s)
+	{
+		if (*s == cc)
+			sp = s;
+		s++;
+	}
+	if (cc == 0)
+		sp = s;
+
+	return sp;
+}
+*/
+/*
+=============
+Q_strncpyz
+ 
+Safe strncpy that ensures a trailing zero
+=============
+*/
+void Q_strncpyz( char *dest, const char *src, int destsize, qboolean bBarfIfTooLong/* = qfalse */ )
+{
+	if ( !src ) {
+		Com_Error( ERR_FATAL, "Q_strncpyz: NULL src" );
+	}
+	if ( destsize < 1 ) {
+		Com_Error(ERR_FATAL,"Q_strncpyz: destsize < 1" ); 
+	}
+
+	if (bBarfIfTooLong)
+	{
+		if ( strlen(src)+1 > destsize)
+		{
+			Com_Error(ERR_FATAL,"String dest buffer too small to hold string \"%s\" %d > %d\n(source addr = %x, dest addr = %x",src, strlen(src)+1, destsize, src, dest);
+		}
+	}
+	strncpy( dest, src, destsize-1 );
+    dest[destsize-1] = 0;
+}
+/*                 
+int Q_stricmpn (const char *s1, const char *s2, int n) {
+	int		c1, c2;
+	
+	do {
+		c1 = *s1++;
+		c2 = *s2++;
+
+		if (!n--) {
+			return 0;		// strings are equal until end point
+		}
+		
+		if (c1 != c2) {
+			if (c1 >= 'a' && c1 <= 'z') {
+				c1 -= ('a' - 'A');
+			}
+			if (c2 >= 'a' && c2 <= 'z') {
+				c2 -= ('a' - 'A');
+			}
+			if (c1 != c2) {
+				return c1 < c2 ? -1 : 1;
+			}
+		}
+	} while (c1);
+	
+	return 0;		// strings are equal
+}
+
+int Q_strncmp (const char *s1, const char *s2, int n) {
+	int		c1, c2;
+	
+	do {
+		c1 = *s1++;
+		c2 = *s2++;
+
+		if (!n--) {
+			return 0;		// strings are equal until end point
+		}
+		
+		if (c1 != c2) {
+			return c1 < c2 ? -1 : 1;
+		}
+	} while (c1);
+	
+	return 0;		// strings are equal
+}
+
+
+
+char *Q_strlwr( char *s1 ) {
+    char	*s;
+
+    s = s1;
+	while ( *s ) {
+		*s = tolower(*s);
+		s++;
+	}
+    return s1;
+}
+
+char *Q_strupr( char *s1 ) {
+    char	*s;
+
+    s = s1;
+	while ( *s ) {
+		*s = toupper(*s);
+		s++;
+	}
+    return s1;
+}
+*/
+
+// never goes past bounds or leaves without a terminating 0
+void Q_strcat( char *dest, int size, const char *src ) {
+	int		l1;
+
+	l1 = strlen( dest );
+	if ( l1 >= size ) {
+		Com_Error( ERR_FATAL, "Q_strcat: already overflowed" );
+	}
+	if ( strlen(src)+1 > size - l1)
+	{	//do the error here instead of in Q_strncpyz to get a meaningful msg
+		Com_Error(ERR_FATAL,"Q_strcat: cannot append \"%s\" to \"%s\"", src, dest);
+	}
+	Q_strncpyz( dest + l1, src, size - l1 );
+}
+
+
+int Q_PrintStrlen( const char *string ) {
+	int			len;
+	const char	*p;
+
+	if( !string ) {
+		return 0;
+	}
+
+	len = 0;
+	p = string;
+	while( *p ) {
+		if( Q_IsColorString( p ) ) {
+			p += 2;
+			continue;
+		}
+		p++;
+		len++;
+	}
+
+	return len;
+}
+
+
+char *Q_CleanStr( char *string ) {
+	char*	d;
+	char*	s;
+	int		c;
+
+	s = string;
+	d = string;
+	while ((c = *s) != 0 ) {
+		if ( Q_IsColorString( s ) ) {
+			s++;
+		}		
+		else if ( c >= 0x20 && c <= 0x7E ) {
+			*d++ = c;
+		}
+		s++;
+	}
+	*d = '\0';
+
+	return string;
+}
+
+
+void QDECL Com_sprintf( char *dest, int size, const char *fmt, ...) {
+	int			len;
+	va_list		argptr;
+	char		bigbuffer[1024];
+
+	va_start (argptr,fmt);
+	len = vsprintf (bigbuffer,fmt,argptr);
+	va_end (argptr);
+	if ( len >= sizeof( bigbuffer ) ) {
+		Com_Error( ERR_FATAL, "Com_sprintf: overflowed bigbuffer" );
+	}
+	if (len >= size) {
+		Com_Printf ("Com_sprintf: overflow of %i in %i\n", len, size);
+	}
+	Q_strncpyz (dest, bigbuffer, size );
+}
+
+
+/*
+============
+va
+
+does a varargs printf into a temp buffer, so I don't need to have
+varargs versions of all text functions.
+FIXME: make this buffer size safe someday
+============
+*/
+char	* QDECL va( const char *format, ... ) {
+	int len;
+	va_list			argptr;
+	static char		buffers[4][1024];	// in case va is called by nested functions
+	static int		index = 0;
+	char *const buf = buffers[index % 4];
+	index++;
+
+	va_start (argptr, format);
+	len = vsprintf (buf, format,argptr);
+	va_end (argptr);
+
+	assert(len<sizeof(buffers[0]));
+
+	return buf;
+}
+
+
+/*
+=====================================================================
+
+  INFO STRINGS
+
+=====================================================================
+*/
+
+/*
+===============
+Info_ValueForKey
+
+Searches the string for the given
+key and returns the associated value, or an empty string.
+FIXME: overflow check?
+===============
+*/
+char *Info_ValueForKey( const char *s, const char *key ) {
+	char	pkey[MAX_INFO_KEY];
+	static	char value[2][MAX_INFO_VALUE];	// use two buffers so compares
+											// work without stomping on each other
+	static	int	valueindex = 0;
+	char	*o;
+	
+	if ( !s || !key ) {
+		return "";
+	}
+
+	if ( strlen( s ) >= MAX_INFO_STRING ) {
+		Com_Error( ERR_DROP, "Info_ValueForKey: oversize infostring" );
+	}
+
+	valueindex ^= 1;
+	if (*s == '\\')
+		s++;
+	while (1)
+	{
+		o = pkey;
+		while (*s != '\\')
+		{
+			if (!*s)
+				return "";
+			*o++ = *s++;
+		}
+		*o = 0;
+		s++;
+
+		o = value[valueindex];
+
+		while (*s != '\\' && *s)
+		{
+			*o++ = *s++;
+		}
+		*o = 0;
+
+		if (!Q_stricmp (key, pkey) )
+			return value[valueindex];
+
+		if (!*s)
+			break;
+		s++;
+	}
+
+	return "";
+}
+
+
+/*
+===================
+Info_NextPair
+
+Used to itterate through all the key/value pairs in an info string
+===================
+*/
+void Info_NextPair( const char **head, char key[MAX_INFO_KEY], char value[MAX_INFO_VALUE] ) {
+	char	*o;
+	const char	*s;
+
+	s = *head;
+
+	if ( *s == '\\' ) {
+		s++;
+	}
+	key[0] = 0;
+	value[0] = 0;
+
+	o = key;
+	while ( *s != '\\' ) {
+		if ( !*s ) {
+			*o = 0;
+			*head = s;
+			return;
+		}
+		*o++ = *s++;
+	}
+	*o = 0;
+	s++;
+
+	o = value;
+	while ( *s != '\\' && *s ) {
+		*o++ = *s++;
+	}
+	*o = 0;
+
+	*head = s;
+}
+
+
+/*
+===================
+Info_RemoveKey
+===================
+*/
+void Info_RemoveKey( char *s, const char *key ) {
+	char	*start;
+	char	pkey[MAX_INFO_KEY];
+	char	value[MAX_INFO_VALUE];
+	char	*o;
+
+	if ( strlen( s ) >= MAX_INFO_STRING ) {
+		Com_Error( ERR_DROP, "Info_RemoveKey: oversize infostring" );
+	}
+
+	if (strchr (key, '\\')) {
+		return;
+	}
+
+	while (1)
+	{
+		start = s;
+		if (*s == '\\')
+			s++;
+		o = pkey;
+		while (*s != '\\')
+		{
+			if (!*s)
+				return;
+			*o++ = *s++;
+		}
+		*o = 0;
+		s++;
+
+		o = value;
+		while (*s != '\\' && *s)
+		{
+			if (!*s)
+				return;
+			*o++ = *s++;
+		}
+		*o = 0;
+
+		if (!strcmp (key, pkey) )
+		{
+			strcpy (start, s);	// remove this part
+			return;
+		}
+
+		if (!*s)
+			return;
+	}
+
+}
+
+
+/*
+==================
+Info_Validate
+
+Some characters are illegal in info strings because they
+can mess up the server's parsing
+==================
+*/
+qboolean Info_Validate( const char *s ) {
+	if ( strchr( s, '\"' ) ) {
+		return qfalse;
+	}
+	if ( strchr( s, ';' ) ) {
+		return qfalse;
+	}
+	return qtrue;
+}
+
+/*
+==================
+Info_SetValueForKey
+
+Changes or adds a key/value pair
+==================
+*/
+void Info_SetValueForKey( char *s, const char *key, const char *value ) {
+	char	newi[MAX_INFO_STRING];
+
+	if ( strlen( s ) >= MAX_INFO_STRING ) {
+		Com_Error( ERR_DROP, "Info_SetValueForKey: oversize infostring" );
+	}
+
+	if (strchr (key, '\\') || strchr (value, '\\'))
+	{
+		Com_Printf ("Can't use keys or values with a \\(%s, %s)\n",key,value);
+		return;
+	}
+
+	if (strchr (key, ';') || strchr (value, ';'))
+	{
+		Com_Printf ("Can't use keys or values with a semicolon(%s, %s)\n",key,value);
+		return;
+	}
+
+	if (strchr (key, '\"') || strchr (value, '\"'))
+	{
+		Com_Printf ("Can't use keys or values with a \"(%s, %s)\n",key,value);
+		return;
+	}
+
+	Info_RemoveKey (s, key);
+	if (!value || !strlen(value))
+		return;
+
+	Com_sprintf (newi, sizeof(newi), "\\%s\\%s", key, value);
+
+	if (strlen(newi) + strlen(s) > MAX_INFO_STRING)
+	{
+		Com_Printf ("Info string length exceeded\n");
+		return;
+	}
+
+	strcat (s, newi);
+}
+
+/*
+========================================================================
+
+String ID Tables
+
+========================================================================
+*/
+
+
+/*
+-------------------------
+GetIDForString 
+-------------------------
+*/
+
+#define VALIDSTRING( a )	( ( a != NULL ) && ( a[0] != NULL ) )
+
+int GetIDForString ( const stringID_table_t *table, const char *string )
+{
+	int	index = 0;
+
+	while ( VALIDSTRING( table[index].name ) )
+	{
+		if ( !Q_stricmp( table[index].name, string ) )
+			return table[index].id;
+
+		index++;
+	}
+
+	return -1;
+}
+
+/*
+-------------------------
+GetStringForID
+-------------------------
+*/
+
+const char *GetStringForID( const stringID_table_t *table, int id )
+{
+	int	index = 0;
+
+	while ( VALIDSTRING( table[index].name ) )
+	{
+		if ( table[index].id == id )
+			return table[index].name;
+
+		index++;
+	}
+
+	return NULL;
+}
+
+/*
+===============
+COM_ParseString
+===============
+*/
+qboolean COM_ParseString( const char **data, const char **s ) 
+{
+//	*s = COM_ParseExt( data, qtrue );
+	*s = COM_ParseExt( data, qfalse );
+	if ( s[0] == 0 ) 
+	{
+		Com_Printf("unexpected EOF in COM_ParseString\n");
+		return qtrue;
+	}
+	return qfalse;
+}
+
+/*
+===============
+COM_ParseInt
+===============
+*/
+qboolean COM_ParseInt( const char **data, int *i ) 
+{
+	const char	*token;
+
+	token = COM_ParseExt( data, qfalse );
+	if ( token[0] == 0 ) 
+	{
+		Com_Printf( "unexpected EOF in COM_ParseInt\n" );
+		return qtrue;
+	}
+
+	*i = atoi( token );
+	return qfalse;
+}
+
+/*
+===============
+COM_ParseFloat
+===============
+*/
+qboolean COM_ParseFloat( const char **data, float *f ) 
+{
+	const char	*token;
+
+	token = COM_ParseExt( data, qfalse );
+	if ( token[0] == 0 ) 
+	{
+		Com_Printf( "unexpected EOF in COM_ParseFloat\n" );
+		return qtrue;
+	}
+
+	*f = atof( token );
+	return qfalse;
+}
+
+/*
+===============
+COM_ParseVec4
+===============
+*/
+qboolean COM_ParseVec4( const char **buffer, vec4_t *c) 
+{
+	int i;
+	float f;
+
+	for (i = 0; i < 4; i++) 
+	{
+		if (COM_ParseFloat(buffer, &f)) 
+		{
+			return qtrue;
+		}
+		(*c)[i] = f;
+	}
+	return qfalse;
+}
+
+
+
+// end
+
diff --git a/code/game/q_shared.h b/code/game/q_shared.h
new file mode 100644
index 0000000..2b9c011
--- /dev/null
+++ b/code/game/q_shared.h
@@ -0,0 +1,2419 @@
+#ifndef __Q_SHARED_H
+#define __Q_SHARED_H
+
+// q_shared.h -- included first by ALL program modules.
+// A user mod should never modify this file
+
+#ifdef _WIN32
+
+#pragma warning(disable : 4018)     // signed/unsigned mismatch
+//#pragma warning(disable : 4032)		//formal parameter 'number' has different type when promoted
+//#pragma warning(disable : 4051)		//type conversion; possible loss of data
+//#pragma warning(disable : 4057)		// slightly different base types
+#pragma warning(disable : 4100)		// unreferenced formal parameter
+//#pragma warning(disable : 4115)		//'type' : named type definition in parentheses
+#pragma warning(disable : 4125)		// decimal digit terminates octal escape sequence
+#pragma warning(disable : 4127)		// conditional expression is constant
+//#pragma warning(disable : 4136)		//conversion between different floating-point types
+//#pragma warning(disable : 4201)		//nonstandard extension used : nameless struct/union
+//#pragma warning(disable : 4214)		//nonstandard extension used : bit field types other than int
+//#pragma warning(disable : 4220)		// varargs matches remaining parameters
+#pragma warning(disable : 4244)		//'conversion' conversion from 'type1' to 'type2', possible loss of data
+#pragma warning(disable : 4284)		// return type not UDT
+//#pragma warning(disable : 4305)		// truncation from const double to float
+#pragma warning(disable : 4310)		// cast truncates constant value
+#pragma warning(disable : 4514)		//unreferenced inline/local function has been removed
+#pragma warning(disable : 4710)		// not inlined
+#pragma warning(disable : 4711)		// selected for automatic inline expansion
+#pragma warning(disable : 4786)		// identifier was truncated
+
+#endif
+
+//rww - conveniently toggle "gore" code, for model decals and stuff.
+#ifndef _XBOX
+#define _G2_GORE
+#endif
+
+#ifndef FINAL_BUILD
+#define G2_PERFORMANCE_ANALYSIS
+#endif
+
+#include <assert.h>
+#include <math.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <string.h>
+#include <stdlib.h>
+#include <time.h>
+#include <ctype.h>
+
+#ifdef _XBOX
+#define tvector(T) std::vector< T >
+#define tdeque(T) std::deque< T >
+
+#define tlist(T) std::list< T >
+#define tslist(T) std::slist< T >
+
+#define tset(T) std::set< T, std::less< T > >
+#define tmultiset(T) std::multiset< T, std::less< T > >
+
+#define tcset(T,C) std::set< T, C >
+#define tcmultiset(T,C) std::multiset< T, C >
+
+#define tmap(K,T) std::map< K, T, std::less< K > >
+#define tmultimap(K,T) std::multimap< K, T, std::less< K > >
+
+#define tcmap(K,T,C) std::map< K, T, C >
+#define tcmultimap(K,T,C) std::multimap< K, T, C >
+#endif // _XBOX
+
+
+// this is the define for determining if we have an asm version of a C function
+#if (defined _M_IX86 || defined __i386__) && !defined __sun__  && !defined __LCC__
+#define id386	1
+#else
+#define id386	0
+#endif
+
+// for windows fastcall option
+
+#define	QDECL
+
+//======================= WIN32 DEFINES =================================
+
+#ifdef WIN32
+
+#define	MAC_STATIC
+
+#undef QDECL
+#define	QDECL	__cdecl
+
+// buildstring will be incorporated into the version string
+#ifdef NDEBUG
+#ifdef _M_IX86
+#define	CPUSTRING	"win-x86"
+#elif defined _M_ALPHA
+#define	CPUSTRING	"win-AXP"
+#endif
+#else
+#ifdef _M_IX86
+#define	CPUSTRING	"win-x86-debug"
+#elif defined _M_ALPHA
+#define	CPUSTRING	"win-AXP-debug"
+#endif
+#endif
+
+
+#define	PATH_SEP '\\'
+
+#endif
+
+//======================= MAC OS X SERVER DEFINES =====================
+
+#if defined(__MACH__) && defined(__APPLE__)
+
+#define MAC_STATIC
+
+#ifdef __ppc__
+#define CPUSTRING	"MacOSXS-ppc"
+#elif defined __i386__
+#define CPUSTRING	"MacOSXS-i386"
+#else
+#define CPUSTRING	"MacOSXS-other"
+#endif
+
+#define	PATH_SEP	'/'
+
+#define	GAME_HARD_LINKED
+#define	CGAME_HARD_LINKED
+#define	UI_HARD_LINKED
+
+#endif
+
+//======================= MAC DEFINES =================================
+
+#ifdef __MACOS__
+
+#define	MAC_STATIC	static
+
+#define	CPUSTRING	"MacOS-PPC"
+
+#define	PATH_SEP ':'
+
+#define	GAME_HARD_LINKED
+#define	CGAME_HARD_LINKED
+#define	UI_HARD_LINKED
+
+void Sys_PumpEvents( void );
+
+#endif
+
+//======================= LINUX DEFINES =================================
+
+// the mac compiler can't handle >32k of locals, so we
+// just waste space and make big arrays static...
+#ifdef __linux__
+
+#define	MAC_STATIC
+
+#ifdef __i386__
+#define	CPUSTRING	"linux-i386"
+#elif defined __axp__
+#define	CPUSTRING	"linux-alpha"
+#else
+#define	CPUSTRING	"linux-other"
+#endif
+
+#define	PATH_SEP '/'
+
+#endif
+
+//=============================================================
+
+typedef unsigned long		ulong;
+typedef unsigned short		word;
+
+typedef unsigned char 		byte;
+
+typedef const char *LPCSTR;
+
+typedef enum {qfalse, qtrue}	qboolean;
+#define	qboolean	int		//don't want strict type checking on the qboolean
+
+typedef int		qhandle_t;
+typedef int		thandle_t;
+typedef int		fxHandle_t;
+typedef int		sfxHandle_t;
+typedef int		fileHandle_t;
+typedef int		clipHandle_t;
+
+
+#ifndef NULL
+#define NULL ((void *)0)
+#endif
+
+#define	MAX_QINT			0x7fffffff
+#define	MIN_QINT			(-MAX_QINT-1)
+
+
+// angle indexes
+#define	PITCH				0		// up / down
+#define	YAW					1		// left / right
+#define	ROLL				2		// fall over
+
+// the game guarantees that no string from the network will ever
+// exceed MAX_STRING_CHARS
+#define	MAX_STRING_CHARS	1024	// max length of a string passed to Cmd_TokenizeString
+#define	MAX_STRING_TOKENS	256		// max tokens resulting from Cmd_TokenizeString
+#define	MAX_TOKEN_CHARS		1024	// max length of an individual token
+
+#define	MAX_INFO_STRING		1024
+#define	MAX_INFO_KEY		1024
+#define	MAX_INFO_VALUE		1024
+
+
+#define	MAX_QPATH			64		// max length of a quake game pathname
+#define	MAX_OSPATH			260		// max length of a filesystem pathname
+
+#define	MAX_NAME_LENGTH		32		// max length of a client name
+
+// paramters for command buffer stuffing
+typedef enum {
+	EXEC_NOW,			// don't return until completed, a VM should NEVER use this,
+						// because some commands might cause the VM to be unloaded...
+	EXEC_INSERT,		// insert at current position, but don't run yet
+	EXEC_APPEND			// add to end of the command buffer (normal case)
+} cbufExec_t;
+
+
+//
+// these aren't needed by any of the VMs.  put in another header?
+//
+#define	MAX_MAP_AREA_BYTES		32		// bit vector of area visibility
+
+// Light Style Constants
+
+#define LS_STYLES_START			0
+#define LS_NUM_STYLES			32
+#define	LS_SWITCH_START			(LS_STYLES_START+LS_NUM_STYLES)
+#define LS_NUM_SWITCH			32
+#define MAX_LIGHT_STYLES		64
+
+// print levels from renderer (FIXME: set up for game / cgame?)
+typedef enum {
+	PRINT_ALL,
+	PRINT_DEVELOPER,		// only print when "developer 1"
+	PRINT_WARNING,
+	PRINT_ERROR
+} printParm_t;
+
+// parameters to the main Error routine
+typedef enum {
+	ERR_FATAL,					// exit the entire game with a popup window
+	ERR_DROP,					// print to console and disconnect from game
+	ERR_DISCONNECT,				// don't kill server
+	ERR_NEED_CD					// pop up the need-cd dialog
+} errorParm_t;
+
+// font rendering values used by ui and cgame
+#define PROP_GAP_WIDTH			2
+//#define PROP_GAP_WIDTH			3
+#define PROP_SPACE_WIDTH		4
+#define PROP_HEIGHT				16
+
+#define PROP_TINY_SIZE_SCALE	1
+#define PROP_SMALL_SIZE_SCALE	1
+#define PROP_BIG_SIZE_SCALE		1
+#define PROP_GIANT_SIZE_SCALE	2
+
+#define PROP_TINY_HEIGHT		10
+#define PROP_GAP_TINY_WIDTH		1
+#define PROP_SPACE_TINY_WIDTH	3
+
+#define PROP_BIG_HEIGHT			24
+#define PROP_GAP_BIG_WIDTH		3
+#define PROP_SPACE_BIG_WIDTH	6
+
+
+#define BLINK_DIVISOR			600
+#define PULSE_DIVISOR			75
+
+#define UI_LEFT			0x00000000	// default
+#define UI_CENTER		0x00000001
+#define UI_RIGHT		0x00000002
+#define UI_FORMATMASK	0x00000007
+#define UI_SMALLFONT	0x00000010
+#define UI_BIGFONT		0x00000020	// default
+#define UI_GIANTFONT	0x00000040
+#define UI_DROPSHADOW	0x00000800
+#define UI_BLINK		0x00001000
+#define UI_INVERSE		0x00002000
+#define UI_PULSE		0x00004000
+#define UI_UNDERLINE	0x00008000
+#define UI_TINYFONT		0x00010000
+
+
+// stuff for TA's ROQ cinematic code...
+//
+#define CIN_system	1
+#define CIN_loop	2
+#define	CIN_hold	4
+#define CIN_silent	8
+#define CIN_shader	16
+
+
+/*
+==============================================================
+
+MATHLIB
+
+==============================================================
+*/
+
+
+typedef float vec_t;
+typedef vec_t vec2_t[2];
+typedef vec_t vec3_t[3];
+typedef vec_t vec4_t[4];
+typedef vec_t vec5_t[5];
+
+typedef vec3_t	vec3pair_t[2];
+
+typedef int ivec2_t[2];
+typedef int ivec3_t[3];
+typedef int ivec4_t[4];
+typedef int ivec5_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
+
+#define NUMVERTEXNORMALS	162
+extern	vec3_t	bytedirs[NUMVERTEXNORMALS];
+
+// all drawing is done to a 640*480 virtual screen size
+// and will be automatically scaled to the real resolution
+#define	SCREEN_WIDTH		640
+#define	SCREEN_HEIGHT		480
+
+#define TINYCHAR_WIDTH		(SMALLCHAR_WIDTH)
+#define TINYCHAR_HEIGHT		(SMALLCHAR_HEIGHT/2)
+
+#define SMALLCHAR_WIDTH		8
+#define SMALLCHAR_HEIGHT	16
+
+#define BIGCHAR_WIDTH		16
+#define BIGCHAR_HEIGHT		16
+
+#define	GIANTCHAR_WIDTH		32
+#define	GIANTCHAR_HEIGHT	48
+
+typedef enum
+{
+CT_NONE,
+CT_BLACK,
+CT_RED,
+CT_GREEN,
+CT_BLUE,
+CT_YELLOW,
+CT_MAGENTA,
+CT_CYAN,
+CT_WHITE,
+CT_LTGREY,
+CT_MDGREY,
+CT_DKGREY,
+CT_DKGREY2,
+
+CT_VLTORANGE,
+CT_LTORANGE,
+CT_DKORANGE,
+CT_VDKORANGE,
+
+CT_VLTBLUE1,
+CT_LTBLUE1,
+CT_DKBLUE1,
+CT_VDKBLUE1,
+
+CT_VLTBLUE2,
+CT_LTBLUE2,
+CT_DKBLUE2,
+CT_VDKBLUE2,
+
+CT_VLTBROWN1,
+CT_LTBROWN1,
+CT_DKBROWN1,
+CT_VDKBROWN1,
+
+CT_VLTGOLD1,
+CT_LTGOLD1,
+CT_DKGOLD1,
+CT_VDKGOLD1,
+
+CT_VLTPURPLE1,
+CT_LTPURPLE1,
+CT_DKPURPLE1,
+CT_VDKPURPLE1,
+
+CT_VLTPURPLE2,
+CT_LTPURPLE2,
+CT_DKPURPLE2,
+CT_VDKPURPLE2,
+
+CT_VLTPURPLE3,
+CT_LTPURPLE3,
+CT_DKPURPLE3,
+CT_VDKPURPLE3,
+
+CT_VLTRED1,
+CT_LTRED1,
+CT_DKRED1,
+CT_VDKRED1,
+CT_VDKRED,
+CT_DKRED,
+
+CT_VLTAQUA,
+CT_LTAQUA,
+CT_DKAQUA,
+CT_VDKAQUA,
+
+CT_LTPINK,
+CT_DKPINK,
+CT_LTCYAN,
+CT_DKCYAN,
+CT_LTBLUE3,
+CT_BLUE3,
+CT_DKBLUE3,
+
+CT_HUD_GREEN,
+CT_HUD_RED,
+CT_ICON_BLUE,
+CT_NO_AMMO_RED,
+CT_HUD_ORANGE,
+
+CT_TITLE,
+
+CT_MAX
+} ct_table_t;
+
+extern vec4_t colorTable[CT_MAX];
+
+
+#define Q_COLOR_ESCAPE	'^'
+// you MUST have the last bit on here about colour strings being less than 7 or taiwanese strings register as colour!!!!
+#define Q_IsColorString(p)	( p && *(p) == Q_COLOR_ESCAPE && *((p)+1) && *((p)+1) != Q_COLOR_ESCAPE && *((p)+1) <= '7' && *((p)+1) >= '0' )
+
+#define COLOR_BLACK		'0'
+#define COLOR_RED		'1'
+#define COLOR_GREEN		'2'
+#define COLOR_YELLOW	'3'
+#define COLOR_BLUE		'4'
+#define COLOR_CYAN		'5'
+#define COLOR_MAGENTA	'6'
+#define COLOR_WHITE		'7'
+#define ColorIndex(c)	( ( (c) - '0' ) & 7 )
+
+#define S_COLOR_BLACK	"^0"
+#define S_COLOR_RED		"^1"
+#define S_COLOR_GREEN	"^2"
+#define S_COLOR_YELLOW	"^3"
+#define S_COLOR_BLUE	"^4"
+#define S_COLOR_CYAN	"^5"
+#define S_COLOR_MAGENTA	"^6"
+#define S_COLOR_WHITE	"^7"
+
+extern vec4_t	g_color_table[8];
+
+#define	MAKERGB( v, r, g, b ) v[0]=r;v[1]=g;v[2]=b
+#define	MAKERGBA( v, r, g, b, a ) v[0]=r;v[1]=g;v[2]=b;v[3]=a
+
+// Player weapons effects
+typedef enum
+{
+	SABER_RED,
+	SABER_ORANGE,
+	SABER_YELLOW,
+	SABER_GREEN,
+	SABER_BLUE,
+	SABER_PURPLE
+
+} saber_colors_t;
+
+#define MAX_BATTERIES	2500
+
+#define PI_DIV_180		0.017453292519943295769236907684886
+#define INV_PI_DIV_180	57.295779513082320876798154814105
+
+// Punish Aurelio if you don't like these performance enhancements. :-)
+#define DEG2RAD( a ) ( ( (a) * PI_DIV_180 ) )
+#define RAD2DEG( a ) ( ( (a) * INV_PI_DIV_180 ) )
+
+// A divide can be avoided by just multiplying by PI_DIV_180 which is PI divided by 180. - Aurelio
+//#define DEG2RAD( a ) ( ( (a) * M_PI ) / 180.0F )
+// A divide can be avoided by just multiplying by INV_PI_DIV_180(inverse of PI/180) which is 180 divided by PI. - Aurelio
+//#define RAD2DEG( a ) ( ( (a) * 180.0f ) / M_PI )
+
+#define ENUM2STRING(arg)   #arg,arg
+
+struct cplane_s;
+
+extern	const vec3_t	vec3_origin;
+extern	const vec3_t	axisDefault[3];
+
+#define	nanmask (255<<23)
+
+#define	IS_NAN(x) (((*(int *)&x)&nanmask)==nanmask)
+
+#ifdef _XBOX
+inline void Q_CastShort2Float(float *f, const short *s)
+{
+	*f = ((float)*s);
+}
+
+inline void Q_CastUShort2Float(float *f, const unsigned short *s)
+{
+	*f = ((float)*s);
+}
+
+inline void Q_CastShort2FloatScale(float *f, const short *s, float scale)
+{
+	*f = ((float)*s) * scale;
+}
+
+inline void Q_CastUShort2FloatScale(float *f, const unsigned short *s, float scale)
+{
+	*f = ((float)*s) * scale;
+}
+#endif
+
+float Q_fabs( float f );
+float Q_rsqrt( float f );		// reciprocal square root
+
+#define SQRTFAST( x ) ( 1.0f / Q_rsqrt( x ) )
+
+signed char ClampChar( int i );
+signed short ClampShort( int i );
+
+// this isn't a real cheap function to call!
+int DirToByte( vec3_t dir );
+void ByteToDir( int b, vec3_t dir );
+
+#define _DotProduct(x,y)		((x)[0]*(y)[0]+(x)[1]*(y)[1]+(x)[2]*(y)[2])
+#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	_VectorScale(v, s, o)	((o)[0]=(v)[0]*(s),(o)[1]=(v)[1]*(s),(o)[2]=(v)[2]*(s))
+#define	_VectorMA(v, s, b, o)	((o)[0]=(v)[0]+(b)[0]*(s),(o)[1]=(v)[1]+(b)[1]*(s),(o)[2]=(v)[2]+(b)[2]*(s))
+
+
+#define VectorClear(a)			((a)[0]=(a)[1]=(a)[2]=0)
+#define VectorNegate(a,b)		((b)[0]=-(a)[0],(b)[1]=-(a)[1],(b)[2]=-(a)[2])
+#define VectorSet(v, x, y, z)	((v)[0]=(x), (v)[1]=(y), (v)[2]=(z))
+#define Vector4Copy(a,b)		((b)[0]=(a)[0],(b)[1]=(a)[1],(b)[2]=(a)[2],(b)[3]=(a)[3])
+
+#define	SnapVector(v) {v[0]=(int)v[0];v[1]=(int)v[1];v[2]=(int)v[2];}
+
+// just in case you do't want to use the macros
+inline void VectorMA( const vec3_t veca, float scale, const vec3_t vecb, vec3_t vecc) {
+	vecc[0] = veca[0] + scale*vecb[0];
+	vecc[1] = veca[1] + scale*vecb[1];
+	vecc[2] = veca[2] + scale*vecb[2];
+}
+
+#ifdef _XBOX
+inline void VectorMA( const vec3_t veca, float scale, const short vecb[3], vec3_t vecc) {
+	// The only time this overload gets used is with normals, so
+	// (I think) it's safe to do this....
+	vecc[0] = veca[0] + scale * ((float)vecb[0] / 32767.0f);
+	vecc[1] = veca[1] + scale * ((float)vecb[1] / 32767.0f);
+	vecc[2] = veca[2] + scale * ((float)vecb[2] / 32767.0f);
+}
+#endif
+
+inline vec_t DotProduct( const vec3_t v1, const vec3_t v2 ) {
+#ifdef _XBOX		/// use SSE
+	float res;
+    __asm {
+        mov     edx, v1
+        movss   xmm1, [edx]
+        movhps  xmm1, [edx+4]
+
+        mov     edx, v2
+        movss   xmm2, [edx]
+        movhps  xmm2, [edx+4]
+
+        mulps   xmm1, xmm2
+
+        movaps  xmm0, xmm1
+
+        shufps  xmm0, xmm0, 32h
+        addps   xmm1, xmm0
+
+        shufps  xmm0, xmm0, 32h
+        addps   xmm1, xmm0
+
+        movss   [res], xmm1
+    }
+    return res;
+#else
+	return v1[0]*v2[0] + v1[1]*v2[1] + v1[2]*v2[2];
+#endif
+}
+
+#ifdef _XBOX
+inline vec_t DotProduct( const short v1[3], const vec3_t v2 ) {
+	return v1[0]*v2[0] + v1[1]*v2[1] + v1[2]*v2[2];
+}
+#endif
+
+inline void CrossProduct( const vec3_t v1, const vec3_t v2, vec3_t cross ) {
+	cross[0] = v1[1]*v2[2] - v1[2]*v2[1];
+	cross[1] = v1[2]*v2[0] - v1[0]*v2[2];
+	cross[2] = v1[0]*v2[1] - v1[1]*v2[0];
+}
+
+inline void VectorSubtract( const vec3_t veca, const vec3_t vecb, vec3_t o ) {
+#ifdef _XBOX
+	__asm {
+        mov      ecx, veca
+        movss    xmm0, [ecx]
+        movhps   xmm0, [ecx+4]
+
+        mov      edx, vecb
+        movss    xmm1, [edx]
+        movhps   xmm1, [edx+4]
+
+        subps    xmm0, xmm1
+
+        mov      eax, o
+        movss    [eax], xmm0
+        movhps   [eax+4], xmm0
+    }
+#else
+	o[0] = veca[0]-vecb[0];
+	o[1] = veca[1]-vecb[1];
+	o[2] = veca[2]-vecb[2];
+#endif
+}
+
+#ifdef _XBOX
+inline void VectorSubtract( const short veca[3], const vec3_t vecb, vec3_t o ) {
+	o[0] = veca[0]-vecb[0];
+	o[1] = veca[1]-vecb[1];
+	o[2] = veca[2]-vecb[2];
+}
+
+inline void VectorSubtract( const vec3_t veca, const short vecb[3], vec3_t o ) {
+	o[0] = veca[0]-vecb[0];
+	o[1] = veca[1]-vecb[1];
+	o[2] = veca[2]-vecb[2];
+}
+
+inline void VectorSubtract( const short veca[3], const short vecb[3], vec3_t o ) {
+	o[0] = veca[0]-vecb[0];
+	o[1] = veca[1]-vecb[1];
+	o[2] = veca[2]-vecb[2];
+}
+#endif
+
+inline void VectorAdd( const vec3_t veca, const vec3_t vecb, vec3_t o ) {
+#ifdef _XBOX
+  __asm {
+        mov      ecx, veca
+        movss    xmm0, [ecx]
+        movhps   xmm0, [ecx+4]
+
+        mov      edx, vecb
+        movss    xmm1, [edx]
+        movhps   xmm1, [edx+4]
+
+        addps    xmm0, xmm1
+
+        mov      eax, o
+        movss    [eax], xmm0
+        movhps   [eax+4], xmm0
+    }
+#else
+	o[0] = veca[0]+vecb[0];
+	o[1] = veca[1]+vecb[1];
+	o[2] = veca[2]+vecb[2];
+#endif
+}
+
+inline void VectorCopy( const vec3_t in, vec3_t out ) {
+	out[0] = in[0];
+	out[1] = in[1];
+	out[2] = in[2];
+}
+
+#ifdef _XBOX
+inline void VectorCopy( const short in[3], vec3_t out ) {
+	out[0] = (float)in[0];
+	out[1] = (float)in[1];
+	out[2] = (float)in[2];
+}
+#endif
+
+inline void VectorScale( const vec3_t i, vec_t scale, vec3_t o ) {
+#ifdef _XBOX
+__asm {
+        movss    xmm0, scale
+        shufps   xmm0, xmm0, 0h
+
+        mov      edx, i
+        movss    xmm1, [edx]
+        movhps   xmm1, [edx+4]
+
+        mulps    xmm0, xmm1
+
+        mov      eax, o
+        movss    [eax], xmm0
+        movhps   [eax+4], xmm0
+    }
+#else
+	o[0] = i[0]*scale;
+	o[1] = i[1]*scale;
+	o[2] = i[2]*scale;
+#endif
+}
+
+float DotProductNormalize( const vec3_t inVec1, const vec3_t inVec2 );
+
+unsigned ColorBytes3 (float r, float g, float b);
+unsigned ColorBytes4 (float r, float g, float b, float a);
+
+float NormalizeColor( const vec3_t in, vec3_t out );
+float RadiusFromBounds( const vec3_t mins, const vec3_t maxs );
+
+void ClearBounds( vec3_t mins, vec3_t maxs );
+
+#ifdef _XBOX
+inline void AddPointToBounds( const short v[3], vec3_t mins, vec3_t maxs ) {
+	if ( v[0] < mins[0] ) {
+		mins[0] = v[0];
+	}
+	if ( v[0] > maxs[0]) {
+		maxs[0] = v[0];
+	}
+
+	if ( v[1] < mins[1] ) {
+		mins[1] = v[1];
+	}
+	if ( v[1] > maxs[1]) {
+		maxs[1] = v[1];
+	}
+
+	if ( v[2] < mins[2] ) {
+		mins[2] = v[2];
+	}
+	if ( v[2] > maxs[2]) {
+		maxs[2] = v[2];
+	}
+}
+#endif
+
+inline void AddPointToBounds( const vec3_t v, vec3_t mins, vec3_t maxs ) {
+	if ( v[0] < mins[0] ) {
+		mins[0] = v[0];
+	}
+	if ( v[0] > maxs[0]) {
+		maxs[0] = v[0];
+	}
+
+	if ( v[1] < mins[1] ) {
+		mins[1] = v[1];
+	}
+	if ( v[1] > maxs[1]) {
+		maxs[1] = v[1];
+	}
+
+	if ( v[2] < mins[2] ) {
+		mins[2] = v[2];
+	}
+	if ( v[2] > maxs[2]) {
+		maxs[2] = v[2];
+	}
+}
+
+inline int VectorCompare( const vec3_t v1, const vec3_t v2 ) {
+	if (v1[0] != v2[0] || v1[1] != v2[1] || v1[2] != v2[2]) {
+		return 0;
+	}			
+	return 1;
+}
+
+//NOTE: less precise
+inline int VectorCompare2( const vec3_t v1, const vec3_t v2 ) {
+	if ( v1[0] > v2[0]+0.0001f || v1[0] < v2[0]-0.0001f
+		|| v1[1] > v2[1]+0.0001f || v1[1] < v2[1]-0.0001f
+		|| v1[2] > v2[2]+0.0001f || v1[2] < v2[2]-0.0001f ) {
+		return 0;
+	}			
+	return 1;
+}
+inline vec_t VectorLength( const vec3_t v ) {
+#ifdef _XBOX
+	float res;
+
+	__asm {
+        mov     edx, v
+        movss   xmm1, [edx]
+        movhps  xmm1, [edx+4]
+
+        movaps  xmm2, xmm1
+
+        mulps   xmm1, xmm2
+
+        movaps  xmm0, xmm1
+
+        shufps  xmm0, xmm0, 32h
+        addps   xmm1, xmm0
+
+        shufps  xmm0, xmm0, 32h
+        addps   xmm1, xmm0
+
+        sqrtss  xmm1, xmm1
+        movss   [res], xmm1
+    }
+
+    return res;
+#else
+	return (vec_t)sqrt (v[0]*v[0] + v[1]*v[1] + v[2]*v[2]);
+#endif
+}
+
+inline vec_t VectorLengthSquared( const vec3_t v ) {
+#ifdef _XBOX
+	float res;
+	__asm {
+        mov     edx, v
+        movss   xmm1, [edx]
+        movhps  xmm1, [edx+4]
+
+        movaps  xmm2, xmm1
+
+        mulps   xmm1, xmm2
+
+        movaps  xmm0, xmm1
+
+        shufps  xmm0, xmm0, 32h
+        addps   xmm1, xmm0
+
+        shufps  xmm0, xmm0, 32h
+        addps   xmm1, xmm0
+
+        movss   [res], xmm1
+    }
+
+    return res;
+#else
+	return (v[0]*v[0] + v[1]*v[1] + v[2]*v[2]);
+#endif
+}
+
+inline vec_t Distance( const vec3_t p1, const vec3_t p2 ) {
+	vec3_t	v;
+
+	VectorSubtract (p2, p1, v);
+	return VectorLength( v );
+}
+
+inline vec_t DistanceSquared( const vec3_t p1, const vec3_t p2 ) {
+	vec3_t	v;
+
+	VectorSubtract (p2, p1, v);
+	return v[0]*v[0] + v[1]*v[1] + v[2]*v[2];
+}
+
+// fast vector normalize routine that does not check to make sure
+// that length != 0, nor does it return length, uses rsqrt approximation
+inline void VectorNormalizeFast( vec3_t v )
+{
+	float ilength;
+
+	ilength = Q_rsqrt( DotProduct( v, v ) );
+
+	v[0] *= ilength;
+	v[1] *= ilength;
+	v[2] *= ilength;
+}
+
+inline void VectorInverse( vec3_t v ){
+	v[0] = -v[0];
+	v[1] = -v[1];
+	v[2] = -v[2];
+}
+
+inline void VectorRotate( vec3_t in, vec3_t matrix[3], vec3_t out )
+{
+	out[0] = DotProduct( in, matrix[0] );
+	out[1] = DotProduct( in, matrix[1] );
+	out[2] = DotProduct( in, matrix[2] );
+}
+
+//if length is 0, v is untouched otherwise v is normalized
+inline vec_t VectorNormalize( vec3_t v ) {
+	float	length, ilength;
+
+	length = v[0]*v[0] + v[1]*v[1] + v[2]*v[2];
+	length = sqrt (length);
+
+	if ( length > 0.0001f ) {
+		ilength = 1/length;
+		v[0] *= ilength;
+		v[1] *= ilength;
+		v[2] *= ilength;
+	}
+		
+	return length;
+}
+
+
+//if length is 0, out is cleared, otherwise out is normalized
+inline vec_t VectorNormalize2( const vec3_t v, vec3_t out) {
+	float	length, ilength;
+
+	length = v[0]*v[0] + v[1]*v[1] + v[2]*v[2];
+	length = sqrt (length);
+
+	if (length)
+	{
+		ilength = 1/length;
+		out[0] = v[0]*ilength;
+		out[1] = v[1]*ilength;
+		out[2] = v[2]*ilength;
+	} else {
+		VectorClear( out );
+	}
+		
+	return length;
+}
+
+#ifdef _XBOX
+inline vec_t VectorNormalize2( const vec3_t v, short out[3]) {
+	float	length, ilength;
+
+	length = v[0]*v[0] + v[1]*v[1] + v[2]*v[2];
+	length = sqrt (length);
+
+	if (length)
+	{
+		ilength = 1/length;
+		out[0] = (short)(v[0]*ilength * 32767.0f);
+		out[1] = (short)(v[1]*ilength * 32767.0f);
+		out[2] = (short)(v[2]*ilength * 32767.0f);
+	} else {
+		VectorClear( out );
+	}
+
+	return length;
+}
+#endif
+
+int Q_log2(int val);
+
+inline int Q_rand( int *seed ) {
+	*seed = (69069 * *seed + 1);
+	return *seed;
+}
+
+inline float Q_random( int *seed ) {
+	return ( Q_rand( seed ) & 0xffff ) / (float)0x10000;
+}
+
+inline float Q_crandom( int *seed ) {
+	return 2.0F * ( Q_random( seed ) - 0.5f );
+}
+
+//  Returns a float min <= x < max (exclusive; will get max - 0.00001; but never max
+inline float Q_flrand(float min, float max) {
+	return ((rand() * (max - min)) / 32768.0F) + min;
+}
+
+// Returns an integer min <= x <= max (ie inclusive)
+inline int Q_irand(int min, int max) {
+	max++; //so it can round down
+	return ((rand() * (max - min)) >> 15) + min;
+}
+
+//returns a float between 0 and 1.0
+inline float random() {
+	return (rand() / ((float)0x7fff));
+}
+
+//returns a float between -1 and 1.0
+inline float crandom() {
+	return (2.0F * (random() - 0.5F));
+}
+
+float erandom( float mean );
+
+void AngleVectors( const vec3_t angles, vec3_t forward, vec3_t right, vec3_t up);
+
+/*
+=================
+AnglesToAxis
+=================
+*/
+inline void AnglesToAxis( const vec3_t angles, vec3_t axis[3] ) {
+	vec3_t	right;
+
+	// angle vectors returns "right" instead of "y axis"
+	AngleVectors( angles, axis[0], right, axis[2] );
+	VectorSubtract( vec3_origin, right, axis[1] );
+}
+
+inline void AxisClear( vec3_t axis[3] ) {
+	axis[0][0] = 1;
+	axis[0][1] = 0;
+	axis[0][2] = 0;
+	axis[1][0] = 0;
+	axis[1][1] = 1;
+	axis[1][2] = 0;
+	axis[2][0] = 0;
+	axis[2][1] = 0;
+	axis[2][2] = 1;
+}
+
+inline void AxisCopy( const vec3_t in[3], vec3_t out[3] ) {
+	VectorCopy( in[0], out[0] );
+	VectorCopy( in[1], out[1] );
+	VectorCopy( in[2], out[2] );
+}
+
+void vectoangles( const vec3_t value1, vec3_t angles);
+
+vec_t DistanceHorizontal( const vec3_t p1, const vec3_t p2 );
+vec_t DistanceHorizontalSquared( const vec3_t p1, const vec3_t p2 );
+
+inline vec_t GetYawForDirection( const vec3_t p1, const vec3_t p2 ) {
+	vec3_t v, angles;
+
+	VectorSubtract( p2, p1, v );
+	vectoangles( v, angles );
+
+	return angles[YAW];
+}
+
+inline void GetAnglesForDirection( const vec3_t p1, const vec3_t p2, vec3_t out ) {
+	vec3_t v;
+
+	VectorSubtract( p2, p1, v );
+	vectoangles( v, out );
+}
+
+
+void SetPlaneSignbits( struct cplane_s *out );
+int BoxOnPlaneSide (vec3_t emins, vec3_t emaxs, struct cplane_s *plane);
+//float	AngleMod(float a);
+
+inline float LerpAngle (float from, float to, float frac) {
+	float	a;
+
+	if ( to - from > 180 ) {
+		to -= 360;
+	}
+	if ( to - from < -180 ) {
+		to += 360;
+	}
+	a = from + frac * (to - from);
+
+	return a;
+}
+
+/*
+=================
+AngleSubtract
+
+Always returns a value from -180 to 180
+=================
+*/
+inline float	AngleSubtract( float a1, float a2 ) {
+	float	a;
+
+	a = a1 - a2;
+	while ( a > 180 ) {
+		a -= 360;
+	}
+	while ( a < -180 ) {
+		a += 360;
+	}
+	return a;
+}
+
+inline void AnglesSubtract( vec3_t v1, vec3_t v2, vec3_t v3 ) {
+	v3[0] = AngleSubtract( v1[0], v2[0] );
+	v3[1] = AngleSubtract( v1[1], v2[1] );
+	v3[2] = AngleSubtract( v1[2], v2[2] );
+}
+
+/*
+=================
+AngleNormalize360
+
+returns angle normalized to the range [0 <= angle < 360]
+=================
+*/
+inline float AngleNormalize360 ( float angle ) {
+	return (360.0 / 65536) * ((int)(angle * (65536 / 360.0)) & 65535);
+}
+
+/*
+=================
+AngleNormalize180
+
+returns angle normalized to the range [-180 < angle <= 180]
+=================
+*/
+inline float AngleNormalize180 ( float angle ) {
+	angle = AngleNormalize360( angle );
+	if ( angle > 180.0 ) {
+		angle -= 360.0;
+	}
+	return angle;
+}
+
+/*
+=================
+AngleDelta
+
+returns the normalized delta from angle1 to angle2
+=================
+*/
+inline float AngleDelta ( float angle1, float angle2 ) {
+	return AngleNormalize180( angle1 - angle2 );
+}
+
+qboolean PlaneFromPoints( vec4_t plane, const vec3_t a, const vec3_t b, const vec3_t c );
+#ifdef _XBOX
+qboolean PlaneFromPoints( vec4_t plane, const short a[3], const short b[3], const short c[3] );
+#endif
+void ProjectPointOnPlane( vec3_t dst, const vec3_t p, const vec3_t normal );
+void RotatePointAroundVector( vec3_t dst, const vec3_t dir, const vec3_t point, float degrees );
+void RotateAroundDirection( vec3_t axis[3], float yaw );
+void MakeNormalVectors( const vec3_t forward, vec3_t right, vec3_t up );
+// perpendicular vector could be replaced by this
+
+int	PlaneTypeForNormal (vec3_t normal);
+
+void MatrixMultiply(float in1[3][3], float in2[3][3], float out[3][3]);
+void PerpendicularVector( vec3_t dst, const vec3_t src );
+
+
+
+//=============================================
+
+float Com_Clamp( float min, float max, float value );
+
+char	*COM_SkipPath( char *pathname );
+void	COM_StripExtension( const char *in, char *out );
+void	COM_DefaultExtension( char *path, int maxSize, const char *extension );
+
+//JLFCALLOUT include MPNOTUSED
+#ifdef _XBOX
+void	 COM_BeginParseSession( bool nested = false );
+#else
+void	 COM_BeginParseSession( void );
+#endif
+
+int		 COM_GetCurrentParseLine( void );
+char	*COM_Parse( const char **data_p );
+char	*COM_ParseExt( const char **data_p, qboolean allowLineBreak );
+int		 COM_Compress( char *data_p );
+qboolean COM_ParseString( const char **data, const char **s );
+qboolean COM_ParseInt( const char **data, int *i );
+qboolean COM_ParseFloat( const char **data, float *f );
+qboolean COM_ParseVec4( const char **buffer, vec4_t *c);
+
+// data is an in/out parm, returns a parsed out token
+
+void	COM_MatchToken( char**buf_p, char *match );
+
+void SkipBracedSection (const char **program);
+void SkipRestOfLine ( const char **data );
+
+void Parse1DMatrix (const char **buf_p, int x, float *m);
+void Parse2DMatrix (const char **buf_p, int y, int x, float *m);
+void Parse3DMatrix (const char **buf_p, int z, int y, int x, float *m);
+
+void	QDECL Com_sprintf (char *dest, int size, const char *fmt, ...);
+
+
+// mode parm for FS_FOpenFile
+typedef enum {
+	FS_READ,
+	FS_WRITE,
+	FS_APPEND,
+	FS_APPEND_SYNC
+} fsMode_t;
+
+typedef enum {
+	FS_SEEK_CUR,
+	FS_SEEK_END,
+	FS_SEEK_SET
+} fsOrigin_t;
+
+//=============================================
+
+int Q_isprint( int c );
+int Q_islower( int c );
+int Q_isupper( int c );
+int Q_isalpha( int c );
+
+// portable case insensitive compare
+//inline  int Q_stricmp (const char *s1, const char *s2) {return Q_stricmpn (s1, s2, 99999);}
+//int		Q_strncmp (const char *s1, const char *s2, int n);
+//int		Q_stricmpn (const char *s1, const char *s2, int n);
+//char	*Q_strlwr( char *s1 );
+//char	*Q_strupr( char *s1 );
+//char	*Q_strrchr( const char* string, int c );
+
+// NON-portable (but faster) versions
+inline int	Q_stricmp (const char *s1, const char *s2) { return stricmp(s1, s2); }
+inline int	Q_strncmp (const char *s1, const char *s2, int n) { return strncmp(s1, s2, n); }
+inline int	Q_stricmpn (const char *s1, const char *s2, int n) { return strnicmp(s1, s2, n); }
+inline char	*Q_strlwr( char *s1 ) { return strlwr(s1); }
+inline char	*Q_strupr( char *s1 ) { return strupr(s1); }
+inline char	*Q_strrchr( const char* str, int c ) { return strrchr(str, c); }
+
+
+// buffer size safe library replacements
+void	Q_strncpyz( char *dest, const char *src, int destsize, qboolean bBarfIfTooLong=qfalse );
+void	Q_strcat( char *dest, int size, const char *src );
+
+// strlen that discounts Quake color sequences
+int Q_PrintStrlen( const char *string );
+// removes color sequences from string
+char *Q_CleanStr( char *string );
+
+//=============================================
+
+#ifdef _M_IX86
+//
+// optimised stuff for Intel, since most of our data is in that format anyway...
+//
+short	BigShort(short l);
+int		BigLong (int l);
+float	BigFloat (float l);
+#define LittleShort(l) l
+#define LittleLong(l)  l
+#define LittleFloat(l) l
+//
+#else
+//
+// standard smart-swap code...
+//
+short	BigShort(short l);
+short	LittleShort(short l);
+int		BigLong (int l);
+int		LittleLong (int l);
+float	BigFloat (float l);
+float	LittleFloat (float l);
+//
+#endif
+
+
+void	Swap_Init (void);
+char	* QDECL va(const char *format, ...);
+
+//=============================================
+
+//
+// key / value info strings
+//
+char *Info_ValueForKey( const char *s, const char *key );
+void Info_RemoveKey( char *s, const char *key );
+void Info_SetValueForKey( char *s, const char *key, const char *value );
+qboolean Info_Validate( const char *s );
+void Info_NextPair( const char **s, char key[MAX_INFO_KEY], char value[MAX_INFO_VALUE] );
+
+// this is only here so the functions in q_shared.c and bg_*.c can link
+void	QDECL Com_Error( int level, const char *error, ... );
+void	QDECL Com_Printf( const char *msg, ... );
+
+
+/*
+==========================================================
+
+CVARS (console variables)
+
+Many variables can be used for cheating purposes, so when
+cheats is zero, force all unspecified variables to their
+default values.
+==========================================================
+*/
+
+#define	CVAR_TEMP			0	// can be set even when cheats are disabled, but is not archived
+#define	CVAR_ARCHIVE		1	// set to cause it to be saved to vars.rc
+								// used for system variables, not for player
+								// specific configurations
+#define	CVAR_USERINFO		2	// sent to server on connect or change
+#define	CVAR_SERVERINFO		4	// sent in response to front end requests
+#define	CVAR_SYSTEMINFO		8	// these cvars will be duplicated on all clients
+#define	CVAR_INIT			16	// don't allow change from console at all,
+								// but can be set from the command line
+#define	CVAR_LATCH			32	// will only change when C code next does
+								// a Cvar_Get(), so it can't be changed
+								// without proper initialization.  modified
+								// will be set, even though the value hasn't
+								// changed yet
+#define	CVAR_ROM			64	// display only, cannot be set by user at all
+#define	CVAR_USER_CREATED	128	// created by a set command
+#define	CVAR_SAVEGAME		256	// store this in the savegame
+#define CVAR_CHEAT			512	// can not be changed if cheats are disabled
+#define CVAR_NORESTART		1024	// do not clear when a cvar_restart is issued
+
+// nothing outside the Cvar_*() functions should modify these fields!
+typedef struct cvar_s {
+	char		*name;
+	char		*string;
+	char		*resetString;		// cvar_restart will reset to this value
+	char		*latchedString;		// for CVAR_LATCH vars
+	int			flags;
+	qboolean	modified;			// set each time the cvar is changed
+	int			modificationCount;	// incremented each time the cvar is changed
+	float		value;				// atof( string )
+	int			integer;			// atoi( string )
+	struct cvar_s *next;
+} cvar_t;
+
+#define	MAX_CVAR_VALUE_STRING	256
+
+typedef int	cvarHandle_t;
+
+// the modules that run in the virtual machine can't access the cvar_t directly,
+// so they must ask for structured updates
+typedef struct {
+	cvarHandle_t	handle;
+	int			modificationCount;
+	float		value;
+	int			integer;
+	char		string[MAX_CVAR_VALUE_STRING];
+} vmCvar_t;
+
+/*
+==============================================================
+
+COLLISION DETECTION
+
+==============================================================
+*/
+
+#include "surfaceflags.h"			// shared with the q3map utility
+
+// plane types are used to speed some tests
+// 0-2 are axial planes
+#define	PLANE_X			0
+#define	PLANE_Y			1
+#define	PLANE_Z			2
+#define	PLANE_NON_AXIAL	3
+
+
+// plane_t structure
+// !!! if this is changed, it must be changed in asm code too !!!
+typedef struct cplane_s {
+	vec3_t	normal;
+	float	dist;
+	byte	type;			// for fast side tests: 0,1,2 = axial, 3 = nonaxial
+	byte	signbits;		// signx + (signy<<1) + (signz<<2), used as lookup during collision
+	byte	pad[2];
+} cplane_t;
+
+/*
+Ghoul2 Insert Start
+*/
+
+#if !defined(GHOUL2_SHARED_H_INC)
+	#include "..\game\ghoul2_shared.h"	//for CGhoul2Info_v
+#endif
+
+/*
+Ghoul2 Insert End
+*/
+
+#define MAX_G2_COLLISIONS 16
+// a trace is returned when a box is swept through the world
+typedef struct {
+	qboolean	allsolid;	// if true, plane is not valid
+	qboolean	startsolid;	// if true, the initial point was in a solid area
+	float		fraction;	// time completed, 1.0 = didn't hit anything
+	vec3_t		endpos;		// final position
+	cplane_t	plane;		// surface normal at impact, transformed to world space
+	int			surfaceFlags;	// surface hit
+	int			contents;	// contents on other side of surface hit
+	int			entityNum;	// entity the contacted sirface is a part of
+/*
+Ghoul2 Insert Start
+*/
+	CCollisionRecord G2CollisionMap[MAX_G2_COLLISIONS];	// map that describes all of the parts of ghoul2 models that got hit
+/*
+Ghoul2 Insert End
+*/
+} trace_t;
+
+// trace->entityNum can also be 0 to (MAX_GENTITIES-1)
+// or ENTITYNUM_NONE, ENTITYNUM_WORLD
+
+
+// markfragments are returned by CM_MarkFragments()
+typedef struct {
+	int		firstPoint;
+	int		numPoints;
+} markFragment_t;
+
+
+
+typedef struct {
+	vec3_t		origin;
+	vec3_t		axis[3];
+} orientation_t;
+
+//=====================================================================
+
+
+// in order from highest priority to lowest
+// if none of the catchers are active, bound key strings will be executed
+#define KEYCATCH_CONSOLE	1
+#define	KEYCATCH_UI			2
+#define	KEYCATCH_MESSAGE	4
+
+
+// sound channels
+// channel 0 never willingly overrides
+// other channels will allways override a playing sound on that channel
+#include "channels.h"
+
+/*
+========================================================================
+
+  ELEMENTS COMMUNICATED ACROSS THE NET
+
+========================================================================
+*/
+
+#define	ANGLE2SHORT(x)	((int)((x)*65536/360) & 65535)
+#define	SHORT2ANGLE(x)	((x)*(360.0/65536))
+
+#define	SNAPFLAG_RATE_DELAYED	1
+#define	SNAPFLAG_NOT_ACTIVE		2	// snapshot used during connection and for zombies
+#define SNAPFLAG_SERVERCOUNT	4	// toggled every map_restart so transitions can be detected
+
+//
+// per-level limits
+//
+#define	MAX_CLIENTS			1 // 128		// absolute limit
+#define MAX_TERRAINS		1 //32
+
+#define	GENTITYNUM_BITS		10		// don't need to send any more
+#define	MAX_GENTITIES		(1<<GENTITYNUM_BITS)
+
+// entitynums are communicated with GENTITY_BITS, so any reserved
+// values thatare going to be communcated over the net need to
+// also be in this range
+#define	ENTITYNUM_NONE		(MAX_GENTITIES-1)
+#define	ENTITYNUM_WORLD		(MAX_GENTITIES-2)
+#define	ENTITYNUM_MAX_NORMAL	(MAX_GENTITIES-2)
+
+
+#define	MAX_MODELS			256
+#define	MAX_SOUNDS			380
+
+#define MAX_SUB_BSP			32
+
+#ifdef _IMMERSION
+#define MAX_FORCES			96
+#endif // _IMMERSION
+#define	MAX_SUBMODELS		512		// nine bits
+
+#define MAX_FX				128
+#define MAX_WORLD_FX		66		// was 16 // was 4
+
+/*
+Ghoul2 Insert Start
+*/
+#define	MAX_CHARSKINS		64		// character skins
+/*
+Ghoul2 Insert End
+*/
+
+#define	MAX_CONFIGSTRINGS	1300//1024 //rww - I had to up this for terrains
+
+// these are the only configstrings that the system reserves, all the
+// other ones are strictly for servergame to clientgame communication
+#define	CS_SERVERINFO		0		// an info string with all the serverinfo cvars
+#define	CS_SYSTEMINFO		1		// an info string for server system to client system configuration (timescale, etc)
+
+#define	RESERVED_CONFIGSTRINGS	2	// game can't modify below this, only the system can
+//
+// config strings are a general means of communicating variable length strings
+// from the server to all connected clients.
+//
+
+// CS_SERVERINFO and CS_SYSTEMINFO are defined in q_shared.h
+#define	CS_MUSIC			2
+#define	CS_MESSAGE			3		// from the map worldspawn's message field
+#define	CS_ITEMS			4		// string of 0's and 1's that tell which items are present
+#define CS_AMBIENT_SET		5		// ambient set information for the player
+
+#define	CS_MODELS			10
+
+#define	CS_SKYBOXORG		(CS_MODELS+MAX_MODELS)		//rww - skybox info
+
+#define	CS_SOUNDS			(CS_SKYBOXORG+1)
+#ifdef _IMMERSION
+#define CS_FORCES			(CS_SOUNDS+MAX_SOUNDS)
+#define CS_PLAYERS			(CS_FORCES+MAX_FORCES)
+#else
+#define	CS_PLAYERS			(CS_SOUNDS+MAX_SOUNDS)
+#endif // _IMMERSION
+#define	CS_LIGHT_STYLES		(CS_PLAYERS+MAX_CLIENTS)
+#define CS_TERRAINS			(CS_LIGHT_STYLES + (MAX_LIGHT_STYLES*3))
+#define CS_BSP_MODELS		(CS_TERRAINS + MAX_TERRAINS)
+#define CS_EFFECTS			(CS_BSP_MODELS + MAX_SUB_BSP)//(CS_LIGHT_STYLES + (MAX_LIGHT_STYLES*3))
+/*
+Ghoul2 Insert Start
+*/
+#define CS_CHARSKINS 		(CS_EFFECTS + MAX_FX)
+/*
+Ghoul2 Insert End
+*/
+#define CS_DYNAMIC_MUSIC_STATE	(CS_CHARSKINS + MAX_CHARSKINS)
+#define CS_WORLD_FX				(CS_DYNAMIC_MUSIC_STATE + 1)	
+#define CS_MAX					(CS_WORLD_FX + MAX_WORLD_FX)
+
+#if (CS_MAX) > MAX_CONFIGSTRINGS
+#error overflow: (CS_MAX) > MAX_CONFIGSTRINGS
+#endif
+
+#define	MAX_GAMESTATE_CHARS	16000
+typedef struct {
+	int			stringOffsets[MAX_CONFIGSTRINGS];
+	char		stringData[MAX_GAMESTATE_CHARS];
+	int			dataCount;
+} gameState_t;
+
+typedef enum
+{
+	FP_FIRST = 0,//marker
+	FP_HEAL = 0,//instant
+	FP_LEVITATION,//hold/duration
+	FP_SPEED,//duration
+	FP_PUSH,//hold/duration
+	FP_PULL,//hold/duration
+	FP_TELEPATHY,//instant
+	FP_GRIP,//hold/duration
+	FP_LIGHTNING,//hold/duration
+	FP_SABERTHROW,
+	FP_SABER_DEFENSE,
+	FP_SABER_OFFENSE,
+	//new Jedi Academy powers
+	FP_RAGE,//duration - speed, invincibility and extra damage for short period, drains your health and leaves you weak and slow afterwards.
+	FP_PROTECT,//duration - protect against physical/energy (level 1 stops blaster/energy bolts, level 2 stops projectiles, level 3 protects against explosions)
+	FP_ABSORB,//duration - protect against dark force powers (grip, lightning, drain - maybe push/pull, too?)
+	FP_DRAIN,//hold/duration - drain force power for health
+	FP_SEE,//duration - detect/see hidden enemies
+	NUM_FORCE_POWERS
+} forcePowers_t;
+
+typedef enum
+{
+	SABER_NONE = 0,
+	SABER_SINGLE,
+	SABER_STAFF,
+	SABER_DAGGER,
+	SABER_BROAD,
+	SABER_PRONG,
+	SABER_ARC,
+	SABER_SAI,
+	SABER_CLAW,
+	SABER_LANCE,
+	SABER_STAR,
+	SABER_TRIDENT,
+	SABER_SITH_SWORD,
+	NUM_SABERS
+} saberType_t;
+
+//=========================================================
+
+// bit field limits
+#define	MAX_STATS				16
+
+// NOTE!!! be careful about altering this because although it's used to define an array size, the entry indexes come from
+//	the typedef'd enum "persEnum_t" in bg_public.h, and there's no compile-tie between the 2 -slc
+//
+#define	MAX_PERSISTANT			16
+
+#define	MAX_POWERUPS			16
+#define	MAX_WEAPONS				32		
+#define MAX_AMMO				10		
+#define MAX_INVENTORY			15		// See INV_MAX
+#define MAX_SECURITY_KEYS		5
+#define MAX_SECURITY_KEY_MESSSAGE		24
+
+#define	MAX_PS_EVENTS			2		// this must be a power of 2 unless you change some &'s to %'s -ste
+
+
+#define MAX_WORLD_COORD		( 64*1024 )
+#define MIN_WORLD_COORD		( -64*1024 )
+#define WORLD_SIZE			( MAX_WORLD_COORD - MIN_WORLD_COORD )
+
+typedef enum
+{
+	WHL_NONE,
+	WHL_ANKLES,
+	WHL_KNEES,
+	WHL_WAIST,
+	WHL_TORSO,
+	WHL_SHOULDERS,
+	WHL_HEAD,
+	WHL_UNDER
+} waterHeightLevel_t;
+
+// !!!!!!! loadsave affecting struct !!!!!!!
+typedef struct 
+{
+	// Actual trail stuff
+	int		inAction;	// controls whether should we even consider starting one
+	int		duration;	// how long each trail seg stays in existence
+	int		lastTime;	// time a saber segement was last stored
+	vec3_t	base;
+	vec3_t	tip;
+
+	// Marks stuff
+	qboolean	haveOldPos[2];
+	vec3_t		oldPos[2];		
+	vec3_t		oldNormal[2];	// store this in case we don't have a connect-the-dots situation
+							//	..then we'll need the normal to project a mark blob onto the impact point
+} saberTrail_t;
+#define MAX_SABER_TRAIL_SEGS 8
+
+// !!!!!!!!!!!!! loadsave affecting struct !!!!!!!!!!!!!!!
+typedef struct
+{
+	qboolean	active;
+	saber_colors_t	color;
+	float		radius;
+	float		length;
+	float		lengthMax;
+	float		lengthOld;
+	vec3_t		muzzlePoint;
+	vec3_t		muzzlePointOld;
+	vec3_t		muzzleDir;
+	vec3_t		muzzleDirOld;
+	saberTrail_t	trail;
+	void		ActivateTrail ( float duration )
+				{
+					trail.inAction = qtrue;
+					trail.duration = duration;
+				};
+	void		DeactivateTrail ( float duration )
+				{
+					trail.inAction = qfalse;
+					trail.duration = duration;
+				};
+} bladeInfo_t;
+#define MAX_BLADES 8
+
+typedef enum
+{
+	SS_NONE = 0,
+	SS_FAST,
+	SS_MEDIUM,
+	SS_STRONG,
+	SS_DESANN,
+	SS_TAVION,
+	SS_DUAL,
+	SS_STAFF,
+	SS_NUM_SABER_STYLES
+} saber_styles_t;
+
+// !!!!!!!!!!!! loadsave affecting struct !!!!!!!!!!!!!!!!!!!!!!!!!!
+typedef struct
+{
+	char		*name;						//entry in sabers.cfg, if any
+	char		*fullName;					//the "Proper Name" of the saber, shown in the UI
+	saberType_t	type;						//none, single or staff
+	char		*model;						//hilt model
+	char		*skin;						//hilt custom skin
+	int			soundOn;					//game soundindex for turning on sound
+	int			soundLoop;					//game soundindex for hum/loop sound
+	int			soundOff;					//game soundindex for turning off sound
+	int			numBlades;
+	bladeInfo_t	blade[MAX_BLADES];			//blade info - like length, trail, origin, dir, etc.
+	saber_styles_t	style;					//locked style to use, if any
+	int			maxChain;					//how many moves can be chained in a row with this weapon (-1 is infinite, 0 is use default behavior)
+	qboolean	lockable;					//can get into a saberlock
+	qboolean	throwable;					//whether or not this saber can be thrown - FIXME: maybe make this a max level of force saber throw that can be used with this saber?
+	qboolean	disarmable;					//whether or not this saber can be dropped
+	qboolean	activeBlocking;				//whether or not to try to block incoming shots with this saber
+	qboolean	twoHanded;					//uses both hands
+	int			forceRestrictions;			//force powers that cannot be used while this saber is on (bitfield) - FIXME: maybe make this a limit on the max level, per force power, that can be used with this type?
+	int			lockBonus;					//in saberlocks, this type of saber pushes harder or weaker
+	int			parryBonus;					//added to strength of parry with this saber
+	int			breakParryBonus;			//added to strength when hit a parry
+	int			disarmBonus;				//added to disarm chance when win saberlock or have a good parry (knockaway)
+	saber_styles_t	singleBladeStyle;		//makes it so that you use a different style if you only have the first blade active
+	qboolean	singleBladeThrowable;		//makes it so that you can throw this saber if only the first blade is on
+	char		*brokenSaber1;				//if saber is actually hit by another saber, it can be cut in half/broken and will be replaced with this saber in your right hand
+	char		*brokenSaber2;				//if saber is actually hit by another saber, it can be cut in half/broken and will be replaced with this saber in your left hand
+	qboolean	returnDamage;				//when returning from a saber throw, it keeps spinning and doing damage
+	void		Activate( void )
+				{
+					for ( int i = 0; i < numBlades; i++ )
+					{
+						blade[i].active = qtrue;
+					}
+				};
+
+	void		Deactivate( void )
+				{
+					for ( int i = 0; i < numBlades; i++ )
+					{
+						blade[i].active = qfalse;
+					}
+				};
+
+	// Description: Activate a specific Blade of this Saber.
+	// Created: 10/03/02 by Aurelio Reis, Modified: 10/03/02 by Aurelio Reis.
+	//	[in]		int iBlade		Which Blade to activate.
+	//	[in]		bool bActive	Whether to activate it (default true), or deactivate it (false).
+	//	[return]	void
+	void		BladeActivate( int iBlade, qboolean bActive = qtrue )
+				{
+					// Validate blade ID/Index.
+					if ( iBlade < 0 || iBlade >= numBlades )
+						return;
+
+					blade[iBlade].active = bActive;
+				}
+
+	qboolean	Active() 
+				{
+					for ( int i = 0; i < numBlades; i++ )
+					{
+						if ( blade[i].active )
+						{
+							return qtrue;
+						}
+					}
+					return qfalse;
+				}
+	void		SetLength( float length )
+				{
+					for ( int i = 0; i < numBlades; i++ )
+					{
+						blade[i].length = length;
+					}
+				}
+	float		Length() 
+				{//return largest length
+					float len1 = 0;
+					for ( int i = 0; i < numBlades; i++ )
+					{
+						if ( blade[i].length > len1 )
+						{
+							len1 = blade[i].length; 
+						}
+					}
+					return len1;
+				};
+	float		LengthMax() 
+				{ 
+					float len1 = 0;
+					for ( int i = 0; i < numBlades; i++ )
+					{
+						if ( blade[i].lengthMax > len1 )
+						{
+							len1 = blade[i].lengthMax; 
+						}
+					}
+					return len1;
+				};
+	void		ActivateTrail ( float duration )
+				{
+					for ( int i = 0; i < numBlades; i++ )
+					{
+						blade[i].ActivateTrail( duration );
+					}
+				};
+	void		DeactivateTrail ( float duration )
+				{
+					for ( int i = 0; i < numBlades; i++ )
+					{
+						blade[i].DeactivateTrail( duration );
+					}
+				};
+} saberInfo_t;
+
+
+#define MAX_SABERS 2	// if this ever changes then update the table "static const save_field_t savefields_gClient[]"!!!!!!!!!!!!
+
+// playerState_t is the information needed by both the client and server
+// to predict player motion and actions
+// nothing outside of pmove should modify these, or some degree of prediction error
+// will occur
+
+// you can't add anything to this without modifying the code in msg.c
+
+// playerState_t is a full superset of entityState_t as it is used by players,
+// so if a playerState_t is transmitted, the entityState_t can be fully derived
+// from it.
+// !!!!!!!!!! LOADSAVE-affecting structure !!!!!!!!!!
+typedef struct playerState_s {
+	int			commandTime;		// cmd->serverTime of last executed command
+	int			pm_type;
+	int			bobCycle;			// for view bobbing and footstep generation
+	int			pm_flags;			// ducked, jump_held, etc
+	int			pm_time;
+
+	vec3_t		origin;
+	vec3_t		velocity;
+	int			weaponTime;
+	int			weaponChargeTime;
+	int			rechargeTime;		// for the phaser
+	int			gravity;
+	int			leanofs;			
+	int			friction;
+	int			speed;
+	int			delta_angles[3];	// add to command angles to get view direction
+									// changed by spawns, rotating objects, and teleporters
+
+	int			groundEntityNum;// ENTITYNUM_NONE = in air
+	int			legsAnim;		// 
+	int			legsAnimTimer;	// don't change low priority animations on legs until this runs out
+	int			torsoAnim;		// 
+	int			torsoAnimTimer;	// don't change low priority animations on torso until this runs out
+	int			movementDir;	// a number 0 to 7 that represents the relative angle
+								// of movement to the view angle (axial and diagonals)
+								// when at rest, the value will remain unchanged
+								// used to twist the legs during strafing
+
+	int			eFlags;			// copied to entityState_t->eFlags
+
+	int			eventSequence;	// pmove generated events
+	int			events[MAX_PS_EVENTS];
+	int			eventParms[MAX_PS_EVENTS];
+
+	int			externalEvent;	// events set on player from another source
+	int			externalEventParm;
+	int			externalEventTime;
+
+	int			clientNum;		// ranges from 0 to MAX_CLIENTS-1
+	int			weapon;			// copied to entityState_t->weapon
+	int			weaponstate;
+
+	int			batteryCharge;
+
+	vec3_t		viewangles;		// for fixed views
+	float		legsYaw;		// actual legs forward facing
+	int			viewheight;
+
+	// damage feedback
+	int			damageEvent;							// when it changes, latch the other parms
+	int			damageYaw;
+	int			damagePitch;
+	int			damageCount;
+
+	int			stats[MAX_STATS];
+	int			persistant[MAX_PERSISTANT];				// stats that aren't cleared on death
+	int			powerups[MAX_POWERUPS];					// level.time that the powerup runs out
+	int			ammo[MAX_AMMO];
+	int			inventory[MAX_INVENTORY];							// Count of each inventory item.
+	char  		security_key_message[MAX_SECURITY_KEYS][MAX_SECURITY_KEY_MESSSAGE];	// Security key types 
+
+	vec3_t		serverViewOrg;
+
+	qboolean	saberInFlight;
+
+	int			viewEntity;		// For overriding player movement controls and vieworg
+	int			forcePowersActive;	//prediction needs to know this
+
+	//NEW vehicle stuff
+	// This has been localized to the vehicle stuff (NOTE: We can still use it later, I'm just commenting it to
+	// root out all the calls. We can store the data in vehicles and update by copying it here).
+	//int			vehicleIndex;	// Index into vehicleData table
+	//vec3_t		vehicleAngles;	// current angles of your vehicle
+	//int			vehicleArmor;	// current armor of your vehicle (explodes if drops to 0)
+
+	// !!
+	// not communicated over the net at all
+	// !!
+	//int			vehicleLastFXTime;				//timer for all cgame-FX...?
+	//int			vehicleExplodeTime;				//when it will go BOOM!
+
+	int			useTime;	//not sent
+	int			lastShotTime;//last time you shot your weapon
+	int			ping;			// server to game info for scoreboard
+	int			lastOnGround;	//last time you were on the ground
+	int			lastStationary;	//last time you were on the ground
+	int			weaponShotCount;
+
+	//FIXME: maybe allocate all these structures (saber, force powers, vehicles) 
+	//			or descend them as classes - so not every client has all this info
+	saberInfo_t	saber[MAX_SABERS];
+	qboolean	dualSabers;
+	qboolean	SaberStaff( void ) { return ( saber[0].type == SABER_STAFF || (dualSabers && saber[1].type == SABER_STAFF) ); };
+	qboolean	SaberActive() { return ( saber[0].Active() || (dualSabers&&saber[1].Active()) ); };
+	void		SetSaberLength( float length )
+				{
+					saber[0].SetLength( length );
+					if ( dualSabers )
+					{
+						saber[1].SetLength( length );
+					}
+				}
+	float		SaberLength() 
+				{//return largest length
+					float len1 = saber[0].Length();
+					if ( dualSabers && saber[1].Length() > len1 )
+					{
+						return saber[1].Length(); 
+					}
+					return len1;
+				};
+	float		SaberLengthMax() 
+				{ 
+					if ( saber[0].LengthMax() > saber[1].LengthMax() )
+					{
+						return saber[0].LengthMax();
+					}
+					else if ( dualSabers )
+					{
+						return saber[1].LengthMax(); 
+					}
+					return 0.0f;
+				};
+
+	// Activate or deactivate a specific Blade of a Saber.
+	// Created: 10/03/02 by Aurelio Reis, Modified: 10/03/02 by Aurelio Reis.
+	//	[in]	int iSaber		Which Saber to modify.
+	//	[in]	int iBlade		Which blade to modify (0 - (NUM_BLADES - 1)).
+	//	[in]	bool bActive	Whether to make it active (default true) or inactive (false).
+	//	[return]	void
+	void		SaberBladeActivate( int iSaber, int iBlade, qboolean bActive = qtrue )
+	{
+		// Validate saber (if it's greater than or equal to zero, OR it above the first saber but we
+		// are not doing duel Sabers, leave, something is not right.
+		if ( iSaber < 0 || ( iSaber > 0  && !dualSabers ) )
+			return;
+
+		saber[iSaber].BladeActivate( iBlade, bActive );
+	}
+
+	void		SaberActivate( void )
+				{
+					saber[0].Activate();
+					if ( dualSabers )
+					{
+						saber[1].Activate();
+					}
+				}
+	void		SaberDeactivate( void ) 
+				{ 
+					saber[0].Deactivate(); 
+					saber[1].Deactivate();
+				};
+	void		SaberActivateTrail ( float duration )
+				{
+					saber[0].ActivateTrail( duration );
+					if ( dualSabers )
+					{
+						saber[1].ActivateTrail( duration );
+					}
+				};
+	void		SaberDeactivateTrail ( float duration )
+				{
+					saber[0].DeactivateTrail( duration );
+					if ( dualSabers )
+					{
+						saber[1].DeactivateTrail( duration );
+					}
+				};
+	int			SaberDisarmBonus( void )
+				{
+					int disarmBonus = 0;
+					if ( saber[0].Active() )
+					{
+						disarmBonus += saber[0].disarmBonus;
+					}
+					if ( dualSabers && saber[1].Active() )
+					{//bonus for having 2 sabers
+						disarmBonus += 1 + saber[1].disarmBonus;
+					}
+					return disarmBonus;
+				};
+	int			SaberParryBonus( void )
+				{
+					int parryBonus = 0;
+					if ( saber[0].Active() )
+					{
+						parryBonus += saber[0].parryBonus;
+					}
+					if ( dualSabers && saber[1].Active() )
+					{//bonus for having 2 sabers
+						parryBonus += 1 + saber[1].parryBonus;
+					}
+					return parryBonus;
+				};
+
+	short		saberMove;
+	short		saberMoveNext;
+	short		saberBounceMove;
+	short		saberBlocking;
+	short		saberBlocked;
+	short		leanStopDebounceTime;
+
+	int			saberEntityNum;
+	float		saberEntityDist;
+	int			saberThrowTime;
+	int			saberEntityState;
+	int			saberDamageDebounceTime;
+	int			saberHitWallSoundDebounceTime;
+	int			saberEventFlags;
+	int			saberBlockingTime;
+	int			saberAnimLevel;
+	int			saberAttackChainCount;
+	int			saberLockTime;
+	int			saberLockEnemy;
+	int			saberStylesKnown;
+
+	int			forcePowersKnown;
+	int			forcePowerDuration[NUM_FORCE_POWERS];	//for effects that have a duration
+	int			forcePowerDebounce[NUM_FORCE_POWERS];	//for effects that must have an interval
+	int			forcePower;
+	int			forcePowerMax;
+	int			forcePowerRegenDebounceTime;
+	int			forcePowerRegenRate;				//default is 100ms
+	int			forcePowerRegenAmount;				//default is 1
+	int			forcePowerLevel[NUM_FORCE_POWERS];		//so we know the max forceJump power you have
+	float		forceJumpZStart;					//So when you land, you don't get hurt as much
+	float		forceJumpCharge;					//you're current forceJump charge-up level, increases the longer you hold the force jump button down
+	int			forceGripEntityNum;					//what entity I'm gripping
+	vec3_t		forceGripOrg;						//where the gripped ent should be lifted to
+	int			forceDrainEntityNum;				//what entity I'm draining
+	vec3_t		forceDrainOrg;						//where the drained ent should be lifted to
+	int			forceHealCount;						//how many points of force heal have been applied so far
+	
+	//new Jedi Academy force powers
+	int			forceAllowDeactivateTime;
+	int			forceRageDrainTime;
+	int			forceRageRecoveryTime;
+	int			forceDrainEntNum;
+	float		forceDrainTime;
+	int			forcePowersForced;					//client is being forced to use these powers (FIXME: and only these?)
+	int			pullAttackEntNum;
+	int			pullAttackTime;
+	int			lastKickedEntNum;
+
+	int			taunting;							//replaced BUTTON_GESTURE
+
+	float		jumpZStart;							//So when you land, you don't get hurt as much
+	vec3_t		moveDir;
+
+	float		waterheight;						//exactly what the z org of the water is (will be +4 above if under water, -4 below if not in water)
+	waterHeightLevel_t	waterHeightLevel;					//how high it really is
+
+	//testing IK grabbing
+	qboolean	ikStatus;		//for IK
+	int			heldClient;		//for IK, who I'm grabbing, if anyone
+	int			heldByClient;	//for IK, someone is grabbing me
+	int			heldByBolt;		//for IK, what bolt I'm attached to on the holdersomeone is grabbing me by
+	int			heldByBone;		//for IK, what bone I'm being held by
+
+	//vehicle turn-around stuff... FIXME: only vehicles need this in SP...
+	int			vehTurnaroundIndex;
+	int			vehTurnaroundTime;
+
+	//NOTE: not really used in SP, just for Fighter Vehicle damage stuff
+	int			brokenLimbs;
+	int			electrifyTime;
+} playerState_t;
+
+
+//====================================================================
+
+
+//
+// usercmd_t->button bits, many of which are generated by the client system,
+// so they aren't game/cgame only definitions
+//
+#define	BUTTON_ATTACK		1
+#define	BUTTON_FORCE_LIGHTNING	2			// displays talk balloon and disables actions
+#define	BUTTON_USE_FORCE	4
+#define	BUTTON_FORCE_DRAIN	8			// draining
+#define	BUTTON_VEH_SPEED	8			// used for some horrible vehicle hack... :)
+#define	BUTTON_WALKING		16			// walking can't just be infered from MOVE_RUN because a key pressed late in the frame will
+										// only generate a small move value for that frame walking will use different animations and
+										// won't generate footsteps 
+#define	BUTTON_USE			32			// the ol' use key returns!
+#define BUTTON_FORCEGRIP	64			// 
+#define BUTTON_ALT_ATTACK	128
+
+#define	BUTTON_FORCE_FOCUS	256			// any key whatsoever
+
+#define	MOVE_RUN			120			// if forwardmove or rightmove are >= MOVE_RUN,
+										// then BUTTON_WALKING should be set
+
+
+typedef enum
+{
+	GENCMD_FORCE_HEAL = 1,
+	GENCMD_FORCE_SPEED,
+	GENCMD_FORCE_THROW,
+	GENCMD_FORCE_PULL,
+	GENCMD_FORCE_DISTRACT,
+	GENCMD_FORCE_GRIP,
+	GENCMD_FORCE_LIGHTNING,
+	GENCMD_FORCE_RAGE,
+	GENCMD_FORCE_PROTECT,
+	GENCMD_FORCE_ABSORB,
+	GENCMD_FORCE_DRAIN,
+	GENCMD_FORCE_SEEING,
+} genCmds_t;
+
+
+// usercmd_t is sent to the server each client frame
+// !!!!!!!!!! LOADSAVE-affecting structure !!!!!!!!!!
+typedef struct usercmd_s {
+	int		serverTime;
+	int		buttons;
+	byte	weapon;
+	int		angles[3];
+	byte	generic_cmd;
+	signed char	forwardmove, rightmove, upmove;
+} usercmd_t;
+
+//===================================================================
+
+// if entityState->solid == SOLID_BMODEL, modelindex is an inline model number
+#define	SOLID_BMODEL	0xffffff
+
+typedef enum {// !!!!!!!!!!! LOADSAVE-affecting struct !!!!!!!!!!
+	TR_STATIONARY,
+	TR_INTERPOLATE,				// non-parametric, but interpolate between snapshots
+	TR_LINEAR,
+	TR_LINEAR_STOP,
+	TR_NONLINEAR_STOP,
+	TR_SINE,					// value = base + sin( time / duration ) * delta
+	TR_GRAVITY
+} trType_t;
+
+typedef struct {// !!!!!!!!!!! LOADSAVE-affecting struct !!!!!!!!!!
+	trType_t	trType;
+	int		trTime;
+	int		trDuration;			// if non 0, trTime + trDuration = stop time
+	vec3_t	trBase;
+	vec3_t	trDelta;			// velocity, etc
+} trajectory_t;
+
+
+// entityState_t is the information conveyed from the server
+// in an update message about entities that the client will
+// need to render in some way
+// Different eTypes may use the information in different ways
+// The messages are delta compressed, so it doesn't really matter if
+// the structure size is fairly large
+
+typedef struct entityState_s {// !!!!!!!!!!! LOADSAVE-affecting struct !!!!!!!!!!!!!
+	int		number;			// entity index
+	int		eType;			// entityType_t
+	int		eFlags;
+
+	trajectory_t	pos;	// for calculating position
+	trajectory_t	apos;	// for calculating angles
+
+	int		time;
+	int		time2;
+
+	vec3_t	origin;
+	vec3_t	origin2;
+
+	vec3_t	angles;
+	vec3_t	angles2;
+
+	int		otherEntityNum;	// shotgun sources, etc
+	int		otherEntityNum2;
+
+	int		groundEntityNum;	// -1 = in air
+
+	int		constantLight;	// r + (g<<8) + (b<<16) + (intensity<<24)
+	int		loopSound;		// constantly loop this sound
+
+	int		modelindex;
+	int		modelindex2;
+	int		modelindex3;
+	int		clientNum;		// 0 to (MAX_CLIENTS - 1), for players and corpses
+	int		frame;
+
+	int		solid;			// for client side prediction, gi.linkentity sets this properly
+
+	int		event;			// impulse events -- muzzle flashes, footsteps, etc
+	int		eventParm;
+
+	// for players
+	int		powerups;		// bit flags
+	int		weapon;			// determines weapon and flash model, etc
+	int		legsAnim;		// 
+	int		legsAnimTimer;	// don't change low priority animations on legs until this runs out
+	int		torsoAnim;		// 
+	int		torsoAnimTimer;	// don't change low priority animations on torso until this runs out
+
+	int		scale;			//Scale players
+
+	//FIXME: why did IMMERSION dupe these 2 fields here?  There's no reason for this!!!
+	qboolean	saberInFlight;
+	qboolean	saberActive;
+
+	//int		vehicleIndex;		// What kind of vehicle you're driving
+	vec3_t	vehicleAngles;		// 
+	int		vehicleArmor;		// current armor of your vehicle (explodes if drops to 0)
+	// 0 if not in a vehicle, otherwise the client number.
+	int m_iVehicleNum;
+
+/*
+Ghoul2 Insert Start
+*/
+	vec3_t	modelScale;		// used to scale models in any axis
+	int		radius;			// used for culling all the ghoul models attached to this ent NOTE - this is automatically scaled by Ghoul2 if/when you scale the model. This is a 100% size value
+	int		boltInfo;		// info used for bolting entities to Ghoul2 models - NOT used for bolting ghoul2 models to themselves, more for stuff like bolting effects to ghoul2 models
+/*
+Ghoul2 Insert End
+*/
+
+	qboolean	isPortalEnt;
+
+} entityState_t;
+
+typedef enum {
+	CA_UNINITIALIZED,
+	CA_DISCONNECTED, 	// not talking to a server
+	CA_CONNECTING,		// sending request packets to the server
+	CA_CHALLENGING,		// sending challenge packets to the server
+	CA_CONNECTED,		// netchan_t established, getting gamestate
+	CA_LOADING,			// only during cgame initialization, never during main loop
+	CA_PRIMED,			// got gamestate, waiting for first frame
+	CA_ACTIVE,			// game views should be displayed
+	CA_CINEMATIC		// playing a cinematic or a static pic, not connected to a server
+} connstate_t;
+
+typedef struct SSkinGoreData_s
+{
+	vec3_t			angles;
+	vec3_t			position;
+	int				currentTime;
+	int				entNum;
+	vec3_t			rayDirection;	// in world space
+	vec3_t			hitLocation;	// in world space
+	vec3_t			scale;
+	float			SSize;			// size of splotch in the S texture direction in world units
+	float			TSize;			// size of splotch in the T texture direction in world units
+	float			theta;			// angle to rotate the splotch
+	vec3_t			uaxis;			//mark direction
+	float			depthStart;		// limit marks begin depth
+	float			depthEnd;		// depth to stop making marks
+
+	bool			useTheta;
+	bool			frontFaces;
+	bool			backFaces;
+	bool			fadeRGB; //specify fade method to modify RGB (by default, the alpha is set instead)
+
+	// growing stuff
+	int				growDuration;			// time over which we want this to scale up, set to -1 for no scaling
+	float			goreScaleStartFraction; // fraction of the final size at which we want the gore to initially appear
+
+	//qboolean		baseModelOnly;
+	int				lifeTime;				// effect expires after this amount of time
+	int				fadeOutTime;			//specify the duration of fading, from the lifeTime (e.g. 3000 will start fading 3 seconds before removal and be faded entirely by removal)
+	//int				shrinkOutTime;			// unimplemented
+	//float			alphaModulate;			// unimplemented
+	//vec3_t			tint;					// unimplemented
+	//float			impactStrength;			// unimplemented
+
+	int				shader; // shader handle
+
+	int				myIndex; // used internally
+
+} SSkinGoreData;
+
+//rww - used for my ik stuff (ported directly from mp)
+typedef struct
+{
+	vec3_t angles;
+	vec3_t position;
+	vec3_t scale;
+	vec3_t velocity;
+	int	me;
+} sharedRagDollUpdateParams_t;
+
+//rww - update parms for ik bone stuff
+typedef struct
+{
+	char boneName[512]; //name of bone
+	vec3_t desiredOrigin; //world coordinate that this bone should be attempting to reach
+	vec3_t origin; //world coordinate of the entity who owns the g2 instance that owns the bone
+	float movementSpeed; //how fast the bone should move toward the destination
+} sharedIKMoveParams_t;
+
+
+typedef struct
+{
+	vec3_t pcjMins; //ik joint limit
+	vec3_t pcjMaxs; //ik joint limit
+	vec3_t origin; //origin of caller
+	vec3_t angles; //angles of caller
+	vec3_t scale; //scale of caller
+	float radius; //bone rad
+	int blendTime; //bone blend time
+	int pcjOverrides; //override ik bone flags
+	int startFrame; //base pose start
+	int endFrame; //base pose end
+} sharedSetBoneIKStateParams_t;
+
+enum sharedEIKMoveState
+{
+	IKS_NONE = 0,
+	IKS_DYNAMIC
+};
+
+/*
+========================================================================
+
+String ID Tables
+
+========================================================================
+*/
+typedef struct stringID_table_s
+{
+	char	*name;
+	int		id;
+} stringID_table_t;
+
+int GetIDForString ( const stringID_table_t *table, const char *string );
+const char *GetStringForID( const stringID_table_t *table, int id );
+
+// savegame screenshot size stuff...
+//
+//#define SG_SCR_WIDTH			512	//256
+//#define SG_SCR_HEIGHT			512	//256
+#define iSG_COMMENT_SIZE		64
+
+#define sCVARNAME_PLAYERSAVE	"playersave"	// used for level-transition, accessed by game and server modules
+
+
+/*
+Ghoul2 Insert Start
+*/
+
+// For ghoul2 axis use
+
+enum Eorientations
+{
+	ORIGIN = 0, 
+	POSITIVE_X,
+	POSITIVE_Z,
+	POSITIVE_Y,
+	NEGATIVE_X,
+	NEGATIVE_Z,
+	NEGATIVE_Y
+};
+/*
+Ghoul2 Insert End
+*/
+
+#define MAX_PARSEFILES	16
+typedef struct parseData_s
+{
+	char	fileName[MAX_QPATH];			// Name of current file being read in
+	int		com_lines;						// Number of lines read in
+	const char	*bufferStart;					// Start address of buffer holding data that was read in
+	const char	*bufferCurrent;					// Where data is currently being parsed from buffer
+} parseData_t;
+
+//JFLCALLOUT include
+//changed to array
+extern parseData_t  parseData[];
+extern int parseDataCount;
+
+
+// cinematic states
+typedef enum {
+	FMV_IDLE,
+	FMV_PLAY,		// play
+	FMV_EOF,		// all other conditions, i.e. stop/EOF/abort
+	FMV_ID_BLT,
+	FMV_ID_IDLE,
+	FMV_LOOPED,
+	FMV_ID_WAIT
+} e_status;
+
+
+// define the new memory tags for the zone, used by all modules now
+//
+#define TAGDEF(blah) TAG_ ## blah
+enum {
+	#include "../qcommon/tags.h"
+};
+typedef char memtag_t;
+
+// stuff to help out during development process, force reloading/uncacheing of certain filetypes...
+//
+typedef enum
+{
+	eForceReload_NOTHING,
+	eForceReload_BSP,
+	eForceReload_MODELS,
+	eForceReload_ALL
+
+} ForceReload_e;
+
+
+#include "../game/genericparser2.h"
+
+#ifdef _IMMERSION
+#include "../ff/ff_public.h"
+#endif // _IMMERSION
+
+#endif	// __Q_SHARED_H
diff --git a/code/game/say.h b/code/game/say.h
new file mode 100644
index 0000000..0d47401
--- /dev/null
+++ b/code/game/say.h
@@ -0,0 +1,30 @@
+#ifndef __SAY_H__
+#define __SAY_H__
+
+typedef enum //# saying_e
+{
+	//Acknowledge command
+	SAY_ACKCOMM1,
+	SAY_ACKCOMM2,
+	SAY_ACKCOMM3,
+	SAY_ACKCOMM4,
+	//Refuse command
+	SAY_REFCOMM1,
+	SAY_REFCOMM2,
+	SAY_REFCOMM3,
+	SAY_REFCOMM4,
+	//Bad command
+	SAY_BADCOMM1,
+	SAY_BADCOMM2,
+	SAY_BADCOMM3,
+	SAY_BADCOMM4,
+	//Unfinished hail
+	SAY_BADHAIL1,
+	SAY_BADHAIL2,
+	SAY_BADHAIL3,
+	SAY_BADHAIL4,
+	//# #eol
+	NUM_SAYINGS
+} saying_t;
+
+#endif //#ifndef __SAY_H__
diff --git a/code/game/statindex.h b/code/game/statindex.h
new file mode 100644
index 0000000..2b7d3ff
--- /dev/null
+++ b/code/game/statindex.h
@@ -0,0 +1,26 @@
+// Filename:	statindex.h
+//
+// accessed from both server and game modules
+
+#ifndef STATINDEX_H
+#define STATINDEX_H
+
+
+// player_state->stats[] indexes
+typedef enum {
+	STAT_HEALTH,
+	STAT_ITEMS,
+	STAT_WEAPONS,					// 16 bit fields
+	STAT_ARMOR,				
+	STAT_DEAD_YAW,					// look this direction when dead (FIXME: get rid of?)
+	STAT_CLIENTS_READY,				// bit mask of clients wishing to exit the intermission (FIXME: configstring?)
+	STAT_MAX_HEALTH					// health / armor limit, changable by handicap
+} statIndex_t;	   
+
+
+
+#endif	// #ifndef STATINDEX_H
+
+
+/////////////////////// eof /////////////////////
+
diff --git a/code/game/surfaceflags.h b/code/game/surfaceflags.h
new file mode 100644
index 0000000..a439ec3
--- /dev/null
+++ b/code/game/surfaceflags.h
@@ -0,0 +1,190 @@
+// Copyright (C) 1999-2000 Id Software, Inc.
+//
+// This file must be identical in the quake and utils directories
+
+// contents flags are seperate bits
+// a given brush can contribute multiple content bits
+
+// these definitions also need to be in q_shared.h!
+
+#if 1
+// flags pasted from SOF2, be VERY CAREFUL when adding new ones since we share their tools!!!
+#define CONTENTS_NONE			0x00000000
+#define	CONTENTS_SOLID			0x00000001	// Default setting. An eye is never valid in a solid
+#define	CONTENTS_LAVA			0x00000002
+#define	CONTENTS_WATER			0x00000004
+#define	CONTENTS_FOG			0x00000008
+#define	CONTENTS_PLAYERCLIP		0x00000010	// Player physically blocked
+#define	CONTENTS_MONSTERCLIP	0x00000020	// NPCs cannot physically pass through
+#define CONTENTS_BOTCLIP		0x00000040	// do not enter - NPCs try not to enter these
+#define CONTENTS_SHOTCLIP		0x00000080	// shots physically blocked
+#define	CONTENTS_BODY			0x00000100	// should never be on a brush, only in game
+#define	CONTENTS_CORPSE			0x00000200	// should never be on a brush, only in game
+#define	CONTENTS_TRIGGER		0x00000400
+#define	CONTENTS_NODROP			0x00000800	// don't leave bodies or items (death fog, lava)
+#define CONTENTS_TERRAIN		0x00001000	// volume contains terrain data
+#define CONTENTS_LADDER			0x00002000
+#define CONTENTS_ABSEIL			0x00004000  // used like ladder to define where an NPC can abseil
+#define CONTENTS_OPAQUE			0x00008000	// defaults to on, when off, solid can be seen through
+#define CONTENTS_OUTSIDE		0x00010000	// volume is considered to be in the outside (i.e. not indoors)
+// CONTENTS_INSIDE added 10/31/02 by Aurelio.
+#define	CONTENTS_INSIDE			0x10000000	// volume is considered to be inside (i.e. indoors)
+#define CONTENTS_SLIME			0x00020000	// CHC needs this since we use same tools
+#define CONTENTS_LIGHTSABER		0x00040000	// ""
+#define CONTENTS_TELEPORTER		0x00080000	// ""
+#define CONTENTS_ITEM			0x00100000	// ""
+#define	CONTENTS_DETAIL			0x08000000	// brushes not used for the bsp
+#define	CONTENTS_TRANSLUCENT	0x80000000	// don't consume surface fragments inside
+
+
+// flags pasted from SOF2, be VERY CAREFUL when adding new ones since we share their tools!!!
+
+#define	SURF_SKY				0x00002000	// lighting from environment map
+#define	SURF_SLICK				0x00004000	// affects game physics
+#define	SURF_METALSTEPS			0x00008000	// CHC needs this since we use same tools (though this flag is temp?)
+#define SURF_FORCEFIELD			0x00010000	// CHC ""			(but not temp)
+#define	SURF_NODAMAGE			0x00040000	// never give falling damage
+#define	SURF_NOIMPACT			0x00080000	// don't make missile explosions
+#define	SURF_NOMARKS			0x00100000	// don't leave missile marks
+#define	SURF_NODRAW				0x00200000	// don't generate a drawsurface at all
+#define	SURF_NOSTEPS			0x00400000	// no footstep sounds
+#define	SURF_NODLIGHT			0x00800000	// don't dlight even if solid (solid lava, skies)
+#define	SURF_NOMISCENTS			0x01000000	// no client models allowed on this surface
+#define	SURF_FORCESIGHT			0x02000000	// not visible without Force Sight
+
+#define SURF_PATCH				0x80000000	// Mark this face as a patch(editor only)
+
+#define MATERIAL_BITS			5
+#define MATERIAL_MASK			0x1f	// mask to get the material type
+
+#define MATERIAL_NONE			0			// for when the artist hasn't set anything up =)
+#define MATERIAL_SOLIDWOOD		1			// freshly cut timber
+#define MATERIAL_HOLLOWWOOD		2			// termite infested creaky wood
+#define MATERIAL_SOLIDMETAL		3			// solid girders
+#define MATERIAL_HOLLOWMETAL	4			// hollow metal machines
+#define MATERIAL_SHORTGRASS		5			// manicured lawn
+#define MATERIAL_LONGGRASS		6			// long jungle grass
+#define MATERIAL_DIRT			7			// hard mud
+#define MATERIAL_SAND			8			// sandy beach
+#define MATERIAL_GRAVEL			9			// lots of small stones
+#define MATERIAL_GLASS			10			// 
+#define MATERIAL_CONCRETE		11			// hardened concrete pavement
+#define MATERIAL_MARBLE			12			// marble floors
+#define MATERIAL_WATER			13			// light covering of water on a surface
+#define MATERIAL_SNOW			14			// freshly laid snow
+#define MATERIAL_ICE			15			// packed snow/solid ice
+#define MATERIAL_FLESH			16			// hung meat, corpses in the world
+#define MATERIAL_MUD			17			// wet soil
+#define MATERIAL_BPGLASS		18			// bulletproof glass
+#define MATERIAL_DRYLEAVES		19			// dried up leaves on the floor
+#define MATERIAL_GREENLEAVES	20			// fresh leaves still on a tree
+#define MATERIAL_FABRIC			21			// Cotton sheets
+#define MATERIAL_CANVAS			22			// tent material
+#define MATERIAL_ROCK			23			//
+#define MATERIAL_RUBBER			24			// hard tire like rubber
+#define MATERIAL_PLASTIC		25			// 
+#define MATERIAL_TILES			26			// tiled floor
+#define MATERIAL_CARPET			27			// lush carpet
+#define MATERIAL_PLASTER		28			// drywall style plaster
+#define MATERIAL_SHATTERGLASS	29			// glass with the Crisis Zone style shattering
+#define MATERIAL_ARMOR			30			// body armor
+#define MATERIAL_COMPUTER		31			// computers/electronic equipment
+#define MATERIAL_LAST			32			// number of materials
+
+// Defined as a macro here so one change will affect all the relevant files
+
+#define MATERIALS	\
+	"none",			\
+	"solidwood",	\
+	"hollowwood",	\
+	"solidmetal",	\
+	"hollowmetal",	\
+	"shortgrass",	\
+	"longgrass",	\
+	"dirt",	   		\
+	"sand",	   		\
+	"gravel",		\
+	"glass",		\
+	"concrete",		\
+	"marble",		\
+	"water",		\
+	"snow",	   		\
+	"ice",			\
+	"flesh",		\
+	"mud",			\
+	"bpglass",		\
+	"dryleaves",	\
+	"greenleaves",	\
+	"fabric",		\
+	"canvas",		\
+	"rock",			\
+	"rubber",		\
+	"plastic",		\
+	"tiles",		\
+	"carpet",		\
+	"plaster",		\
+	"shatterglass",	\
+	"armor",		\
+	"computer"/* this was missing, see enums above, plus ShaderEd2 pulldown options */
+#else
+/*
+#define CONTENTS_NONE			0
+#define	CONTENTS_SOLID			1		// an eye is never valid in a solid
+#define	CONTENTS_LAVA			8
+#define	CONTENTS_SLIME			16
+#define	CONTENTS_WATER			32
+#define	CONTENTS_FOG			64
+#define	CONTENTS_LADDER			128
+
+#define CONTENTS_LIGHTSABER		0x1000	// Used for lightsaber buddies, blocking, deflecting.
+
+#define	CONTENTS_AREAPORTAL		0x8000
+
+Ghoul2 Insert Start
+
+#define CONTENTS_GHOUL2			0x4000  // used to set trace to do point to poly ghoul2 checks. Never set as a contents of an object/surface
+
+Ghoul2 Insert End
+
+#define	CONTENTS_PLAYERCLIP		0x10000
+#define	CONTENTS_MONSTERCLIP	0x20000
+#define	CONTENTS_SHOTCLIP		0x40000	//These are not needed if CONTENTS_SOLID is included
+
+//q3 bot specific contents types
+#define	CONTENTS_TELEPORTER		0x40000
+#define	CONTENTS_JUMPPAD		0x80000	//needed for bspc
+#define	CONTENTS_ITEM			0x80000	//Items can be touched but do not block movement (like triggers) but can be hit by the infoString trace
+#define CONTENTS_CLUSTERPORTAL	0x100000
+#define CONTENTS_DONOTENTER		0x200000
+#define CONTENTS_BOTCLIP		0x400000
+
+#define	CONTENTS_ORIGIN			0x1000000	// removed before bsping an entity
+
+#define	CONTENTS_BODY			0x2000000	// should never be on a brush, only in game
+#define	CONTENTS_CORPSE			0x4000000
+#define	CONTENTS_DETAIL			0x8000000	// brushes not used for the bsp
+#define	CONTENTS_STRUCTURAL		0x10000000	// brushes used for the bsp
+#define	CONTENTS_TRANSLUCENT	0x20000000	// don't consume surface fragments inside
+#define	CONTENTS_TRIGGER		0x40000000
+#define	CONTENTS_NODROP			0x80000000	// don't leave bodies or items (death fog, lava)
+
+#define	SURF_NODAMAGE			0x1		// never give falling damage
+#define	SURF_SLICK				0x2		// effects game physics
+#define	SURF_SKY				0x4		// lighting from environment map
+#define	SURF_NOIMPACT			0x10	// don't make missile explosions
+#define	SURF_NOMARKS			0x20	// don't leave missile marks
+#define	SURF_FLESH				0x40	// make flesh sounds and effects
+#define	SURF_NODRAW				0x80	// don't generate a drawsurface at all
+#define	SURF_HINT				0x100	// make a primary bsp splitter
+#define	SURF_SKIP				0x200	// completely ignore, allowing non-closed brushes
+#define	SURF_NOLIGHTMAP			0x400	// surface doesn't need a lightmap
+#define	SURF_POINTLIGHT			0x800	// generate lighting info at vertexes
+#define	SURF_METALSTEPS			0x1000	// clanking footsteps
+#define	SURF_NOSTEPS			0x2000	// no footstep sounds
+#define	SURF_NONSOLID			0x4000	// don't collide against curves with this set
+#define SURF_LIGHTFILTER		0x8000	// act as a light filter during q3map -light
+#define	SURF_ALPHASHADOW		0x10000	// do per-pixel light shadow casting in q3map
+#define	SURF_NODLIGHT			0x20000	// don't dlight even if solid (solid lava, skies)
+#define SURF_FORCEFIELD			0x40000	// the surface in question is a forcefield
+*/
+#endif
\ No newline at end of file
diff --git a/code/game/teams.h b/code/game/teams.h
new file mode 100644
index 0000000..3721cdd
--- /dev/null
+++ b/code/game/teams.h
@@ -0,0 +1,92 @@
+#ifndef TEAMS_H
+#define TEAMS_H
+
+typedef enum //# team_e
+{
+	TEAM_FREE,			// caution, some code checks a team_t via "if (!team_t_varname)" so I guess this should stay as entry 0, great or what? -slc
+	TEAM_PLAYER,
+	TEAM_ENEMY,
+	TEAM_NEUTRAL,	// most droids are team_neutral, there are some exceptions like Probe,Seeker,Interrogator
+
+	//# #eol
+	TEAM_NUM_TEAMS
+} team_t;
+
+extern stringID_table_t TeamTable[];
+
+// This list is made up from the model directories, this MUST be in the same order as the ClassNames array in NPC_stats.cpp
+typedef enum 
+{
+	CLASS_NONE,				// hopefully this will never be used by an npc, just covering all bases
+	CLASS_ATST,				// technically droid...
+	CLASS_BARTENDER,
+	CLASS_BESPIN_COP,		
+	CLASS_CLAW,
+	CLASS_COMMANDO,
+	CLASS_DESANN,			
+	CLASS_FISH,
+	CLASS_FLIER2,
+	CLASS_GALAK,
+	CLASS_GLIDER,
+	CLASS_GONK,				// droid
+	CLASS_GRAN,
+	CLASS_HOWLER,
+	CLASS_RANCOR,
+	CLASS_SAND_CREATURE,
+	CLASS_WAMPA,
+	CLASS_IMPERIAL,
+	CLASS_IMPWORKER,
+	CLASS_INTERROGATOR,		// droid 
+	CLASS_JAN,				
+	CLASS_JEDI,				
+	CLASS_KYLE,
+	CLASS_LANDO,			
+	CLASS_LIZARD,
+	CLASS_LUKE,				
+	CLASS_MARK1,			// droid
+	CLASS_MARK2,			// droid
+	CLASS_GALAKMECH,		// droid
+	CLASS_MINEMONSTER,
+	CLASS_MONMOTHA,			
+	CLASS_MORGANKATARN,
+	CLASS_MOUSE,			// droid
+	CLASS_MURJJ,
+	CLASS_PRISONER,
+	CLASS_PROBE,			// droid
+	CLASS_PROTOCOL,			// droid
+	CLASS_R2D2,				// droid
+	CLASS_R5D2,				// droid
+	CLASS_REBEL,
+	CLASS_REBORN,
+	CLASS_REELO,
+	CLASS_REMOTE,
+	CLASS_RODIAN,
+	CLASS_SEEKER,			// droid
+	CLASS_SENTRY,
+	CLASS_SHADOWTROOPER,
+	CLASS_SABOTEUR,
+	CLASS_STORMTROOPER,
+	CLASS_SWAMP,
+	CLASS_SWAMPTROOPER,
+	CLASS_NOGHRI,
+	CLASS_TAVION,
+	CLASS_ALORA,
+	CLASS_TRANDOSHAN,
+	CLASS_UGNAUGHT,
+	CLASS_JAWA,
+	CLASS_WEEQUAY,
+	CLASS_TUSKEN,
+	CLASS_BOBAFETT,
+	CLASS_ROCKETTROOPER,
+	CLASS_SABER_DROID,
+	CLASS_ASSASSIN_DROID,
+	CLASS_HAZARD_TROOPER,
+	CLASS_PLAYER,
+	CLASS_VEHICLE,
+
+	CLASS_NUM_CLASSES
+} class_t;
+
+extern stringID_table_t ClassTable[];
+
+#endif	// #ifndef TEAMS_H
diff --git a/code/game/vssver.scc b/code/game/vssver.scc
new file mode 100644
index 0000000..3cc7cbe
Binary files /dev/null and b/code/game/vssver.scc differ
diff --git a/code/game/weapons.h b/code/game/weapons.h
new file mode 100644
index 0000000..f33263a
--- /dev/null
+++ b/code/game/weapons.h
@@ -0,0 +1,149 @@
+// Filename:-	weapons.h
+//
+// Note that this is now included from both server and game modules, so don't include any other header files
+//	within this one that might break stuff...
+
+#ifndef __WEAPONS_H__
+#define __WEAPONS_H__
+
+typedef enum //# weapon_e
+{
+	WP_NONE,
+
+	// Player weapons
+	WP_SABER,			// player and NPC weapon
+	WP_BLASTER_PISTOL,	// player and NPC weapon
+	WP_BLASTER,			// player and NPC weapon
+	WP_DISRUPTOR,		// player and NPC weapon
+	WP_BOWCASTER,		// NPC weapon - player can pick this up, but never starts with them
+	WP_REPEATER,		// NPC weapon - player can pick this up, but never starts with them
+	WP_DEMP2,			// NPC weapon - player can pick this up, but never starts with them
+	WP_FLECHETTE,		// NPC weapon - player can pick this up, but never starts with them
+	WP_ROCKET_LAUNCHER,	// NPC weapon - player can pick this up, but never starts with them
+	WP_THERMAL,			// player and NPC weapon
+	WP_TRIP_MINE,		// NPC weapon - player can pick this up, but never starts with them
+	WP_DET_PACK,		// NPC weapon - player can pick this up, but never starts with them
+	WP_CONCUSSION,		// NPC weapon - player can pick this up, but never starts with them
+
+	//extras
+	WP_MELEE,			// player and NPC weapon - Any ol' melee attack
+
+	//when in atst
+	WP_ATST_MAIN,
+	WP_ATST_SIDE,
+
+	// These can never be gotten directly by the player
+	WP_STUN_BATON,		// stupid weapon, should remove
+	
+	//NPC weapons
+	WP_BRYAR_PISTOL,	// NPC weapon - player can pick this up, but never starts with them
+
+	WP_EMPLACED_GUN,
+
+	WP_BOT_LASER,		// Probe droid	- Laser blast
+
+	WP_TURRET,			// turret guns 
+
+	WP_TIE_FIGHTER,
+
+	WP_RAPID_FIRE_CONC,
+
+	WP_JAWA,
+	WP_TUSKEN_RIFLE,
+	WP_TUSKEN_STAFF,
+	WP_SCEPTER,
+	WP_NOGHRI_STICK,
+
+	//# #eol
+	WP_NUM_WEAPONS
+} weapon_t;
+
+#define FIRST_WEAPON		WP_SABER		// this is the first weapon for next and prev weapon switching
+#define MAX_PLAYER_WEAPONS	WP_STUN_BATON	// this is the max you can switch to and get with the give all. - FIXME: it's actually this one *minus* one... why?
+
+// AMMO_NONE must be first and AMMO_MAX must be last, cause weapon load validates based off of these vals
+typedef enum //# ammo_e
+{
+	AMMO_NONE,
+	AMMO_FORCE,		// AMMO_PHASER
+	AMMO_BLASTER,	// AMMO_STARFLEET,
+	AMMO_POWERCELL,	// AMMO_ALIEN,
+	AMMO_METAL_BOLTS,
+	AMMO_ROCKETS,
+	AMMO_EMPLACED,
+	AMMO_THERMAL,
+	AMMO_TRIPMINE,
+	AMMO_DETPACK,
+	AMMO_MAX
+} ammo_t;
+
+
+typedef struct weaponData_s
+{
+	char	classname[32];		// Spawning name
+	char	weaponMdl[64];		// Weapon Model
+	char	firingSnd[64];		// Sound made when fired
+	char	altFiringSnd[64];	// Sound made when alt-fired
+//	char	flashSnd[64];		// Sound made by flash
+//	char	altFlashSnd[64];	// Sound made by an alt-flash
+	char	stopSnd[64];		// Sound made when weapon stops firing
+	char	chargeSnd[64];		// sound to start when the weapon initiates the charging sequence
+	char	altChargeSnd[64];	// alt sound to start when the weapon initiates the charging sequence
+	char	selectSnd[64];		// the sound to play when this weapon gets selected
+
+#ifdef _IMMERSION
+	char	firingFrc[64];
+	char	altFiringFrc[64];
+	char	stopFrc[64];
+	char	chargeFrc[64];
+	char	altChargeFrc[64];
+	char	selectFrc[64];
+#endif // _IMMERSION
+	int		ammoIndex;			// Index to proper ammo slot
+	int		ammoLow;			// Count when ammo is low
+
+	int		energyPerShot;		// Amount of energy used per shot
+	int		fireTime;			// Amount of time between firings
+	int		range;				// Range of weapon
+	
+	int		altEnergyPerShot;	// Amount of energy used for alt-fire
+	int		altFireTime;		// Amount of time between alt-firings
+	int		altRange;			// Range of alt-fire
+
+	char	weaponIcon[64];		// Name of weapon icon file
+	int		numBarrels;			// how many barrels should we expect for this weapon?
+
+	char	missileMdl[64];		// Missile Model
+	char	missileSound[64];	// Missile flight sound
+	float  	missileDlight;		// what is says
+	vec3_t 	missileDlightColor;	// ditto
+
+	char	alt_missileMdl[64];		// Missile Model
+	char	alt_missileSound[64];	// Missile sound
+	float  	alt_missileDlight;		// what is says
+	vec3_t 	alt_missileDlightColor;	// ditto
+
+	char	missileHitSound[64];	// Missile impact sound
+	char	altmissileHitSound[64];	// alt Missile impact sound
+#ifndef _USRDLL
+	void	*func;
+	void	*altfunc;
+
+	char	mMuzzleEffect[64];
+	int		mMuzzleEffectID;
+	char	mAltMuzzleEffect[64];
+	int		mAltMuzzleEffectID;
+
+#endif
+
+} weaponData_t;
+
+
+typedef struct ammoData_s
+{
+	char	icon[32];	// Name of ammo icon file
+	int		max;		// Max amount player can hold of ammo
+} ammoData_t;
+
+
+#endif//#ifndef __WEAPONS_H__
diff --git a/code/game/wp_saber.cpp b/code/game/wp_saber.cpp
new file mode 100644
index 0000000..4433fa2
--- /dev/null
+++ b/code/game/wp_saber.cpp
@@ -0,0 +1,13660 @@
+// leave this line at the top for all g_xxxx.cpp files...
+#include "g_headers.h"
+
+
+
+#include "g_local.h"
+#include "anims.h"
+#include "b_local.h"
+#include "bg_local.h"			   
+#include "g_functions.h"
+#include "wp_saber.h"
+#include "g_vehicles.h"
+
+#define JK2_RAGDOLL_GRIPNOHEALTH
+
+#define MAX_SABER_VICTIMS 16
+static int		victimEntityNum[MAX_SABER_VICTIMS];
+static float	totalDmg[MAX_SABER_VICTIMS];
+static vec3_t	dmgDir[MAX_SABER_VICTIMS];
+static vec3_t	dmgSpot[MAX_SABER_VICTIMS];
+static float	dmgFraction[MAX_SABER_VICTIMS];
+static int		hitLoc[MAX_SABER_VICTIMS];
+static qboolean	hitDismember[MAX_SABER_VICTIMS];
+static int		hitDismemberLoc[MAX_SABER_VICTIMS];
+static vec3_t	saberHitLocation, saberHitNormal={0,0,1.0};
+static float	saberHitFraction;
+static float	sabersCrossed;
+static int		saberHitEntity;
+static int		numVictims = 0;
+
+#define SABER_PITCH_HACK 90
+
+
+extern cvar_t	*g_sex;
+extern cvar_t	*g_timescale;
+extern cvar_t	*g_dismemberment;
+extern cvar_t	*g_debugSaberLock;
+extern cvar_t	*g_saberLockRandomNess;
+extern cvar_t	*d_slowmodeath;
+extern cvar_t	*g_cheats;
+extern cvar_t	*g_debugMelee;
+extern cvar_t	*g_saberRestrictForce;
+
+extern qboolean Q3_TaskIDPending( gentity_t *ent, taskID_t taskType );
+extern qboolean		G_ClearViewEntity( gentity_t *ent );
+extern void			G_SetViewEntity( gentity_t *self, gentity_t *viewEntity );
+extern qboolean G_ControlledByPlayer( gentity_t *self );
+extern void G_AddVoiceEvent( gentity_t *self, int event, int speakDebounceTime );
+extern void CG_ChangeWeapon( int num );
+extern void G_AngerAlert( gentity_t *self );
+extern void G_ReflectMissile( gentity_t *ent, gentity_t *missile, vec3_t forward );
+extern int G_CheckLedgeDive( gentity_t *self, float checkDist, const vec3_t checkVel, qboolean tryOpposite, qboolean tryPerp );
+extern void G_BounceMissile( gentity_t *ent, trace_t *trace );
+extern qboolean G_PointInBounds( const vec3_t point, const vec3_t mins, const vec3_t maxs );
+extern void NPC_UseResponse( gentity_t *self, gentity_t *user, qboolean useWhenDone );
+extern void WP_FireDreadnoughtBeam( gentity_t *ent );
+extern void G_MissileImpacted( gentity_t *ent, gentity_t *other, vec3_t impactPos, vec3_t normal, int hitLoc=HL_NONE );
+extern evasionType_t Jedi_SaberBlockGo( gentity_t *self, usercmd_t *cmd, vec3_t pHitloc, vec3_t phitDir, gentity_t *incoming, float dist = 0.0f );
+extern void Jedi_RageStop( gentity_t *self );
+extern int PM_PickAnim( gentity_t *self, int minAnim, int maxAnim );
+extern void NPC_SetPainEvent( gentity_t *self );
+extern qboolean PM_SwimmingAnim( int anim );
+extern qboolean PM_InAnimForSaberMove( int anim, int saberMove );
+extern qboolean PM_SpinningSaberAnim( int anim );
+extern qboolean PM_SaberInSpecialAttack( int anim );
+extern qboolean PM_SaberInAttack( int move );
+extern qboolean PM_SaberInTransition( int move );
+extern qboolean PM_SaberInStart( int move );
+extern qboolean PM_SaberInTransitionAny( int move );
+extern qboolean PM_SaberInReturn( int move );
+extern qboolean PM_SaberInBounce( int move );
+extern qboolean PM_SaberInParry( int move );
+extern qboolean PM_SaberInKnockaway( int move );
+extern qboolean PM_SaberInBrokenParry( int move );
+extern qboolean PM_SpinningSaberAnim( int anim );
+extern saberMoveName_t PM_SaberBounceForAttack( int move );
+extern saberMoveName_t PM_BrokenParryForAttack( int move );
+extern saberMoveName_t PM_KnockawayForParry( int move );
+extern qboolean PM_FlippingAnim( int anim );
+extern qboolean PM_RollingAnim( int anim );
+extern qboolean PM_CrouchAnim( int anim );
+extern qboolean PM_SaberInIdle( int move );
+extern qboolean PM_SaberInReflect( int move );
+extern qboolean PM_InSpecialJump( int anim );
+extern qboolean PM_InKnockDown( playerState_t *ps );
+extern qboolean PM_ForceUsingSaberAnim( int anim );
+extern qboolean PM_SuperBreakLoseAnim( int anim );
+extern qboolean PM_SuperBreakWinAnim( int anim );
+extern qboolean PM_SaberLockBreakAnim( int anim );
+extern qboolean PM_InOnGroundAnim ( playerState_t *ps );
+extern qboolean PM_KnockDownAnim( int anim );
+extern qboolean PM_SaberInKata( saberMoveName_t saberMove );
+extern qboolean PM_StabDownAnim( int anim );
+extern int PM_PowerLevelForSaberAnim( playerState_t *ps, int saberNum = 0 );
+extern void PM_VelocityForSaberMove( playerState_t *ps, vec3_t throwDir );
+extern qboolean PM_VelocityForBlockedMove( playerState_t *ps, vec3_t throwDir );
+extern int Jedi_ReCalcParryTime( gentity_t *self, evasionType_t evasionType );
+extern qboolean Jedi_DodgeEvasion( gentity_t *self, gentity_t *shooter, trace_t *tr, int hitLoc );
+extern void Jedi_PlayDeflectSound( gentity_t *self );
+extern void Jedi_PlayBlockedPushSound( gentity_t *self );
+extern qboolean Jedi_WaitingAmbush( gentity_t *self );
+extern void Jedi_Ambush( gentity_t *self );
+extern qboolean Jedi_SaberBusy( gentity_t *self );
+extern qboolean Jedi_CultistDestroyer( gentity_t *self ); 
+extern qboolean Boba_Flying( gentity_t *self );
+extern void JET_FlyStart( gentity_t *self );
+extern void Boba_DoFlameThrower( gentity_t *self );
+extern Vehicle_t *G_IsRidingVehicle( gentity_t *ent );
+extern int SaberDroid_PowerLevelForSaberAnim( gentity_t *self );
+extern qboolean G_ValidEnemy( gentity_t *self, gentity_t *enemy );
+extern void G_StartMatrixEffect( gentity_t *ent, int meFlags = 0, int length = 1000, float timeScale = 0.0f, int spinTime = 0 );
+extern int PM_AnimLength( int index, animNumber_t anim );
+extern void G_Knockdown( gentity_t *self, gentity_t *attacker, const vec3_t pushDir, float strength, qboolean breakSaberLock );
+extern void G_KnockOffVehicle( gentity_t *pRider, gentity_t *self, qboolean bPull );
+extern qboolean PM_LockedAnim( int anim );
+extern qboolean Rosh_BeingHealed( gentity_t *self );
+extern qboolean G_OkayToLean( playerState_t *ps, usercmd_t *cmd, qboolean interruptOkay );
+
+int WP_AbsorbConversion(gentity_t *attacked, int atdAbsLevel, gentity_t *attacker, int atPower, int atPowerLevel, int atForceSpent);
+void WP_ForcePowerStart( gentity_t *self, forcePowers_t forcePower, int overrideAmt );
+void WP_ForcePowerStop( gentity_t *self, forcePowers_t forcePower );
+qboolean WP_ForcePowerUsable( gentity_t *self, forcePowers_t forcePower, int overrideAmt );
+void WP_SaberInFlightReflectCheck( gentity_t *self, usercmd_t *ucmd  );
+
+void WP_SaberDrop( gentity_t *self, gentity_t *saber );
+qboolean WP_SaberLose( gentity_t *self, vec3_t throwDir );
+void WP_SaberReturn( gentity_t *self, gentity_t *saber );
+void WP_SaberBlock( gentity_t *saber, vec3_t hitloc, qboolean missleBlock );
+void WP_SaberBlockNonRandom( gentity_t *self, vec3_t hitloc, qboolean missileBlock );
+qboolean WP_ForcePowerAvailable( gentity_t *self, forcePowers_t forcePower, int overrideAmt );
+void WP_ForcePowerDrain( gentity_t *self, forcePowers_t forcePower, int overrideAmt );
+void WP_DeactivateSaber( gentity_t *self, qboolean clearLength = qfalse );
+qboolean FP_ForceDrainGrippableEnt( gentity_t *victim );
+
+extern cvar_t	*g_saberAutoBlocking;
+extern cvar_t	*g_saberRealisticCombat;
+extern cvar_t	*g_saberDamageCapping;
+extern cvar_t	*g_saberNewControlScheme;
+extern int g_crosshairEntNum;
+
+qboolean g_saberNoEffects = qfalse;
+int		g_saberFlashTime = 0;
+vec3_t	g_saberFlashPos = {0,0,0};
+
+int forcePowerDarkLight[NUM_FORCE_POWERS] = //0 == neutral
+{ //nothing should be usable at rank 0..
+	FORCE_LIGHTSIDE,//FP_HEAL,//instant
+	0,//FP_LEVITATION,//hold/duration
+	0,//FP_SPEED,//duration
+	0,//FP_PUSH,//hold/duration
+	0,//FP_PULL,//hold/duration
+	FORCE_LIGHTSIDE,//FP_TELEPATHY,//instant
+	FORCE_DARKSIDE,//FP_GRIP,//hold/duration
+	FORCE_DARKSIDE,//FP_LIGHTNING,//hold/duration
+	0,//FP_SABERATTACK,
+	0,//FP_SABERDEFEND,
+	0,//FP_SABERTHROW,
+	//new Jedi Academy powers
+	FORCE_DARKSIDE,//FP_RAGE,//duration
+	FORCE_LIGHTSIDE,//FP_PROTECT,//duration
+	FORCE_LIGHTSIDE,//FP_ABSORB,//duration
+	FORCE_DARKSIDE,//FP_DRAIN,//hold/duration
+	0,//FP_SEE,//duration
+	//NUM_FORCE_POWERS
+};
+
+int forcePowerNeeded[NUM_FORCE_POWERS] = 
+{
+	0,//FP_HEAL,//instant
+	10,//FP_LEVITATION,//hold/duration
+	50,//FP_SPEED,//duration
+	15,//FP_PUSH,//hold/duration
+	15,//FP_PULL,//hold/duration
+	20,//FP_TELEPATHY,//instant
+	1,//FP_GRIP,//hold/duration - FIXME: 30?
+	1,//FP_LIGHTNING,//hold/duration
+	20,//FP_SABERTHROW,
+	1,//FP_SABER_DEFENSE,
+	0,//FP_SABER_OFFENSE,
+	//new Jedi Academy powers
+	50,//FP_RAGE,//duration - speed, invincibility and extra damage for short period, drains your health and leaves you weak and slow afterwards.
+	30,//FP_PROTECT,//duration - protect against physical/energy (level 1 stops blaster/energy bolts, level 2 stops projectiles, level 3 protects against explosions)
+	30,//FP_ABSORB,//duration - protect against dark force powers (grip, lightning, drain)
+	1,//FP_DRAIN,//hold/duration - drain force power for health
+	20//FP_SEE,//duration - detect/see hidden enemies
+	//NUM_FORCE_POWERS
+};
+
+float forceJumpStrength[NUM_FORCE_POWER_LEVELS] = 
+{
+	JUMP_VELOCITY,//normal jump
+	420,
+	590,
+	840
+};
+
+float forceJumpHeight[NUM_FORCE_POWER_LEVELS] = 
+{
+	32,//normal jump (+stepheight+crouchdiff = 66)
+	96,//(+stepheight+crouchdiff = 130)
+	192,//(+stepheight+crouchdiff = 226)
+	384//(+stepheight+crouchdiff = 418)
+};
+
+float forceJumpHeightMax[NUM_FORCE_POWER_LEVELS] = 
+{
+	66,//normal jump (32+stepheight(18)+crouchdiff(24) = 74)
+	130,//(96+stepheight(18)+crouchdiff(24) = 138)
+	226,//(192+stepheight(18)+crouchdiff(24) = 234)
+	418//(384+stepheight(18)+crouchdiff(24) = 426)
+};
+
+float forcePushPullRadius[NUM_FORCE_POWER_LEVELS] =
+{
+	0,//none
+	384,//256,
+	448,//384,
+	512
+};
+
+float forcePushCone[NUM_FORCE_POWER_LEVELS] =
+{
+	1.0f,//none
+	1.0f,
+	0.8f,
+	0.6f
+};
+
+float forcePullCone[NUM_FORCE_POWER_LEVELS] =
+{
+	1.0f,//none
+	1.0f,
+	1.0f,
+	0.8f
+};
+
+float forceSpeedValue[NUM_FORCE_POWER_LEVELS] =
+{
+	1.0f,//none
+	0.75f,
+	0.5f,
+	0.25f
+};
+
+float forceSpeedRangeMod[NUM_FORCE_POWER_LEVELS] =
+{
+	0.0f,//none
+	30.0f,
+	45.0f,
+	60.0f
+};
+
+float forceSpeedFOVMod[NUM_FORCE_POWER_LEVELS] =
+{
+	0.0f,//none
+	20.0f,
+	30.0f,
+	40.0f
+};
+
+int forceGripDamage[NUM_FORCE_POWER_LEVELS] =
+{
+	0,//none
+	0,
+	6,
+	9
+};
+
+int mindTrickTime[NUM_FORCE_POWER_LEVELS] =
+{
+	0,//none
+	10000,//5000,
+	15000,//10000,
+	30000//15000
+};
+
+//NOTE: keep in synch with table below!!!
+int saberThrowDist[NUM_FORCE_POWER_LEVELS] =
+{
+	0,//none
+	256,
+	400,
+	400
+};
+
+//NOTE: keep in synch with table above!!!
+int saberThrowDistSquared[NUM_FORCE_POWER_LEVELS] =
+{
+	0,//none
+	65536,
+	160000,
+	160000
+};
+
+int parryDebounce[NUM_FORCE_POWER_LEVELS] =
+{
+	500,//if don't even have defense, can't use defense!
+	300,
+	150,
+	50
+};
+
+float saberAnimSpeedMod[NUM_FORCE_POWER_LEVELS] =
+{
+	0.0f,//if don't even have offense, can't use offense!
+	0.75f,
+	1.0f,
+	2.0f
+};
+
+stringID_table_t SaberStyleTable[] =
+{
+	"NULL",SS_NONE,
+	ENUM2STRING(SS_FAST),
+	"fast",SS_FAST,
+	ENUM2STRING(SS_MEDIUM),
+	"medium",SS_MEDIUM,
+	ENUM2STRING(SS_STRONG),
+	"strong",SS_STRONG,
+	ENUM2STRING(SS_DESANN),
+	"desann",SS_DESANN,
+	ENUM2STRING(SS_TAVION),
+	"tavion",SS_TAVION,
+	ENUM2STRING(SS_DUAL),
+	"dual",SS_DUAL,
+	ENUM2STRING(SS_STAFF),
+	"staff",SS_STAFF,
+	"", NULL
+};
+//SABER INITIALIZATION======================================================================
+
+void G_CreateG2AttachedWeaponModel( gentity_t *ent, const char *psWeaponModel, int boltNum, int weaponNum )
+{
+	if (!psWeaponModel)
+	{
+		assert (psWeaponModel);
+		return;
+	}
+	if ( ent->playerModel == -1 )
+	{
+		return;
+	}
+	if ( boltNum == -1 )
+	{
+		return;
+	}
+
+	if ( ent && ent->client && ent->client->NPC_class == CLASS_GALAKMECH )
+	{//hack for galakmech, no weaponmodel
+		ent->weaponModel[0] = ent->weaponModel[1] = -1;
+		return;
+	}
+	if ( weaponNum < 0 || weaponNum >= MAX_INHAND_WEAPONS )
+	{
+		return;
+	}
+	char weaponModel[64];
+
+	strcpy (weaponModel, psWeaponModel);	
+	if (char *spot = strstr(weaponModel, ".md3") ) {
+		*spot = 0;
+		spot = strstr(weaponModel, "_w");//i'm using the in view weapon array instead of scanning the item list, so put the _w back on
+		if (!spot&&!strstr(weaponModel, "noweap")) 
+		{
+			strcat (weaponModel, "_w");
+		}
+		strcat (weaponModel, ".glm");	//and change to ghoul2
+	}
+
+	// give us a saber model
+	int wModelIndex = G_ModelIndex( weaponModel );
+	if ( wModelIndex )
+	{
+		ent->weaponModel[weaponNum] = gi.G2API_InitGhoul2Model(ent->ghoul2, weaponModel, wModelIndex );
+		if ( ent->weaponModel[weaponNum] != -1 )
+		{
+			// attach it to the hand
+			gi.G2API_AttachG2Model(&ent->ghoul2[ent->weaponModel[weaponNum]], &ent->ghoul2[ent->playerModel], 
+						boltNum, ent->playerModel);
+			// set up a bolt on the end so we can get where the sabre muzzle is - we can assume this is always bolt 0
+			gi.G2API_AddBolt(&ent->ghoul2[ent->weaponModel[weaponNum]], "*flash");
+	  		//gi.G2API_SetLodBias( &ent->ghoul2[ent->weaponModel[weaponNum]], 0 );
+		}
+	}
+
+}
+
+void WP_SaberAddG2SaberModels( gentity_t *ent, int specificSaberNum )
+{
+	int saberNum = 0, maxSaber = 1;
+	if ( specificSaberNum != -1 && specificSaberNum <= maxSaber )
+	{
+		saberNum = maxSaber = specificSaberNum;
+	}
+	for ( ; saberNum <= maxSaber; saberNum++ )
+	{
+		if ( ent->weaponModel[saberNum] > 0 )
+		{//we already have a weapon model in this slot
+			//remove it
+			gi.G2API_SetSkin( &ent->ghoul2[ent->weaponModel[saberNum]], -1, 0 );
+			gi.G2API_RemoveGhoul2Model( ent->ghoul2, ent->weaponModel[saberNum] );
+			ent->weaponModel[saberNum] = -1;
+		}
+		if ( saberNum > 0 )
+		{//second saber
+			if ( !ent->client->ps.dualSabers 
+				|| G_IsRidingVehicle( ent ) )
+			{//only have one saber or riding a vehicle and can only use one saber
+				return;
+			}
+		}
+		else if ( saberNum == 0 )
+		{//first saber
+			if ( ent->client->ps.saberInFlight )
+			{//it's still out there somewhere, don't add it
+				//FIXME: call it back?
+				continue;
+			}
+		}
+		int handBolt = ((saberNum == 0) ? ent->handRBolt : ent->handLBolt);
+		G_CreateG2AttachedWeaponModel( ent, ent->client->ps.saber[saberNum].model, handBolt, saberNum );
+
+		if ( ent->client->ps.saber[saberNum].skin != NULL )
+		{//if this saber has a customSkin, use it
+			// lets see if it's out there
+			int saberSkin = gi.RE_RegisterSkin( ent->client->ps.saber[saberNum].skin );
+			if ( saberSkin )
+			{
+				// put it in the config strings
+				// and set the ghoul2 model to use it
+				gi.G2API_SetSkin( &ent->ghoul2[ent->weaponModel[saberNum]], G_SkinIndex( ent->client->ps.saber[saberNum].skin ), saberSkin );
+			}
+		}
+	}
+}
+
+//----------------------------------------------------------
+void G_Throw( gentity_t *targ, const vec3_t newDir, float push )
+//----------------------------------------------------------
+{
+	vec3_t	kvel;
+	float	mass;
+
+	if ( targ 
+		&& targ->client 
+		&& ( targ->client->NPC_class == CLASS_ATST
+			|| targ->client->NPC_class == CLASS_RANCOR
+			|| targ->client->NPC_class == CLASS_SAND_CREATURE ) )
+	{//much to large to *ever* throw
+		return;
+	}
+
+	if ( targ->physicsBounce > 0 )	//overide the mass
+	{
+		mass = targ->physicsBounce;
+	}
+	else
+	{
+		mass = 200;
+	}
+
+	if ( g_gravity->value > 0 )
+	{
+		VectorScale( newDir, g_knockback->value * (float)push / mass * 0.8, kvel );
+		if ( !targ->client || targ->client->ps.groundEntityNum != ENTITYNUM_NONE )
+		{//give them some z lift to get them off the ground
+			kvel[2] = newDir[2] * g_knockback->value * (float)push / mass * 1.5;
+		}
+	}
+	else
+	{
+		VectorScale( newDir, g_knockback->value * (float)push / mass, kvel );
+	}
+
+	if ( targ->client )
+	{
+		VectorAdd( targ->client->ps.velocity, kvel, targ->client->ps.velocity );
+	}
+	else if ( targ->s.pos.trType != TR_STATIONARY && targ->s.pos.trType != TR_LINEAR_STOP && targ->s.pos.trType != TR_NONLINEAR_STOP )
+	{
+		VectorAdd( targ->s.pos.trDelta, kvel, targ->s.pos.trDelta );
+		VectorCopy( targ->currentOrigin, targ->s.pos.trBase );
+		targ->s.pos.trTime = level.time;
+	}
+
+	// set the timer so that the other client can't cancel
+	// out the movement immediately
+	if ( targ->client && !targ->client->ps.pm_time ) 
+	{
+		int		t;
+
+		t = push * 2;
+
+		if ( t < 50 ) 
+		{
+			t = 50;
+		}
+		if ( t > 200 ) 
+		{
+			t = 200;
+		}
+		targ->client->ps.pm_time = t;
+		targ->client->ps.pm_flags |= PMF_TIME_KNOCKBACK;
+	}
+}
+
+int WP_SetSaberModel( gclient_t *client, class_t npcClass )
+{//FIXME: read from NPCs.cfg
+	if ( client )
+	{
+		switch ( npcClass )
+		{
+		case CLASS_DESANN://Desann
+			client->ps.saber[0].model = "models/weapons2/saber_desann/saber_w.glm";
+			break;
+		case CLASS_LUKE://Luke
+			client->ps.saber[0].model = "models/weapons2/saber_luke/saber_w.glm";
+			break;
+		case CLASS_PLAYER://Kyle NPC and player
+		case CLASS_KYLE://Kyle NPC and player
+			client->ps.saber[0].model = "models/weapons2/saber/saber_w.glm";
+			break;
+		default://reborn and tavion and everyone else
+			client->ps.saber[0].model = "models/weapons2/saber_reborn/saber_w.glm";
+			break;
+		}
+		return ( G_ModelIndex( client->ps.saber[0].model ) );
+	}
+	else
+	{
+		switch ( npcClass )
+		{
+		case CLASS_DESANN://Desann
+			return ( G_ModelIndex( "models/weapons2/saber_desann/saber_w.glm" ) );
+			break;
+		case CLASS_LUKE://Luke
+			return ( G_ModelIndex( "models/weapons2/saber_luke/saber_w.glm" ) );
+			break;
+		case CLASS_PLAYER://Kyle NPC and player
+		case CLASS_KYLE://Kyle NPC and player
+			return ( G_ModelIndex( "models/weapons2/saber/saber_w.glm" ) );
+			break;
+		default://reborn and tavion and everyone else
+			return ( G_ModelIndex( "models/weapons2/saber_reborn/saber_w.glm" ) );
+			break;
+		}
+	}
+}
+
+void WP_SetSaberEntModelSkin( gentity_t *ent, gentity_t *saberent )
+{
+	int	saberModel = 0;
+	qboolean	newModel = qfalse;
+	//FIXME: get saberModel from NPCs.cfg
+	if ( !ent->client->ps.saber[0].model )
+	{
+		saberModel = WP_SetSaberModel( ent->client, ent->client->NPC_class );
+	}
+	else
+	{
+		//got saberModel from NPCs.cfg
+		saberModel = G_ModelIndex( ent->client->ps.saber[0].model );
+	}
+	if ( saberModel && saberent->s.modelindex != saberModel )
+	{
+		if ( saberent->playerModel >= 0 )
+		{//remove the old one, if there is one
+			gi.G2API_RemoveGhoul2Model( saberent->ghoul2, saberent->playerModel );
+		}
+		//add the new one
+		saberent->playerModel = gi.G2API_InitGhoul2Model( saberent->ghoul2, ent->client->ps.saber[0].model, saberModel);
+		saberent->s.modelindex = saberModel; 
+		newModel = qtrue;
+	}
+	//set skin, too
+	if ( ent->client->ps.saber[0].skin == NULL )
+	{
+		gi.G2API_SetSkin( &saberent->ghoul2[0], -1, 0 );
+	}
+	else
+	{//if this saber has a customSkin, use it
+		// lets see if it's out there
+		int saberSkin = gi.RE_RegisterSkin( ent->client->ps.saber[0].skin );
+		if ( saberSkin && (newModel || saberent->s.modelindex2 != saberSkin) )
+		{
+			// put it in the config strings
+			// and set the ghoul2 model to use it
+			gi.G2API_SetSkin( &saberent->ghoul2[0], G_SkinIndex( ent->client->ps.saber[0].skin ), saberSkin );
+			saberent->s.modelindex2 = saberSkin;
+		}
+	}
+}
+
+void WP_SaberSwingSound( gentity_t *ent, int saberNum, swingType_t swingType )
+{
+	int index = 1;
+	if ( !ent || !ent->client )
+	{
+		return;
+	}
+	if ( swingType == SWING_FAST )
+	{
+		index = Q_irand( 1, 3 );
+	}
+	else if ( swingType == SWING_MEDIUM )
+	{
+		index = Q_irand( 4, 6 );
+	}
+	else if ( swingType == SWING_STRONG )
+	{
+		index = Q_irand( 7, 9 );
+	}
+#ifdef _IMMERSION
+	if ( ent->client->ps.saber[saberNum].type == SABER_SITH_SWORD )
+	{
+		G_SoundOnEnt( ent, CHAN_WEAPON, va( "sound/weapons/sword/swing%d.wav", Q_irand( 1, 4 ) ) );
+	}
+	else
+	{
+		G_SoundOnEnt( ent, CHAN_WEAPON, va( "sound/weapons/saber/saberhup%d.wav", index ) );
+	}
+	G_Force( ent, G_ForceIndex( va( "fffx/weapons/saber/saberhup%d", index ), FF_CHANNEL_WEAPON ) );
+#else
+	if ( ent->client->ps.saber[saberNum].type == SABER_SITH_SWORD )
+	{
+		G_SoundOnEnt( ent, CHAN_WEAPON, va( "sound/weapons/sword/swing%d.wav", Q_irand( 1, 4 ) ) );
+	}
+	else
+	{
+		G_SoundOnEnt( ent, CHAN_WEAPON, va( "sound/weapons/saber/saberhup%d.wav", index ) );
+	}
+#endif // _IMMERSION
+}
+
+void WP_SaberHitSound( gentity_t *ent, int saberNum )
+{
+	int index = 1;
+	if ( !ent || !ent->client )
+	{
+		return;
+	}
+#ifdef _IMMERSION
+	index = Q_irand( 1, 3 );
+	if ( ent->client->ps.saber[saberNum].type == SABER_SITH_SWORD )
+	{
+		G_Sound( ent, G_SoundIndex( va( "sound/weapons/sword/stab%d.wav", Q_irand( 1, 4 ) ) ) );
+	}
+	else
+	{	
+		G_Sound( ent, G_SoundIndex( va( "sound/weapons/saber/saberhit%d.wav", index ) ) );
+	}
+	G_Force( ent, G_ForceIndex( va( "fffx/weapons/saber/saberhit%d", index), FF_CHANNEL_WEAPON ) );
+#else
+	if ( ent->client->ps.saber[saberNum].type == SABER_SITH_SWORD )
+	{
+		G_Sound( ent, G_SoundIndex( va( "sound/weapons/sword/stab%d.wav", Q_irand( 1, 4 ) ) ) );
+	}
+	else
+	{
+		G_Sound( ent, G_SoundIndex( va( "sound/weapons/saber/saberhit%d.wav", Q_irand( 1, 3 ) ) ) );
+	}
+#endif // _IMMERSION
+}
+
+int WP_SaberInitBladeData( gentity_t *ent )
+{
+	if ( !ent->client )
+	{
+		return 0;
+	}
+	if ( 1 )
+	{
+		VectorClear( ent->client->renderInfo.muzzlePoint );
+		VectorClear( ent->client->renderInfo.muzzlePointOld );
+		//VectorClear( ent->client->renderInfo.muzzlePointNext );
+		VectorClear( ent->client->renderInfo.muzzleDir );
+		VectorClear( ent->client->renderInfo.muzzleDirOld );
+		//VectorClear( ent->client->renderInfo.muzzleDirNext );
+		for ( int saberNum = 0; saberNum < MAX_SABERS; saberNum++ )
+		{
+			for ( int bladeNum = 0; bladeNum < MAX_BLADES; bladeNum++ )
+			{
+				VectorClear( ent->client->ps.saber[saberNum].blade[bladeNum].muzzlePoint );
+				VectorClear( ent->client->ps.saber[saberNum].blade[bladeNum].muzzlePointOld );
+				VectorClear( ent->client->ps.saber[saberNum].blade[bladeNum].muzzleDir );
+				VectorClear( ent->client->ps.saber[saberNum].blade[bladeNum].muzzleDirOld );
+				ent->client->ps.saber[saberNum].blade[bladeNum].lengthOld = ent->client->ps.saber[saberNum].blade[bladeNum].length = 0;
+				if ( !ent->client->ps.saber[saberNum].blade[bladeNum].lengthMax )
+				{
+					if ( ent->client->NPC_class == CLASS_DESANN )
+					{//longer saber
+						ent->client->ps.saber[saberNum].blade[bladeNum].lengthMax = 48;
+					}
+					else if ( ent->client->NPC_class == CLASS_REBORN )
+					{//shorter saber
+						ent->client->ps.saber[saberNum].blade[bladeNum].lengthMax = 32;
+					}
+					else
+					{//standard saber length
+						ent->client->ps.saber[saberNum].blade[bladeNum].lengthMax = 40;
+					}
+				}
+			}
+		}
+		ent->client->ps.saberLockEnemy = ENTITYNUM_NONE;
+		ent->client->ps.saberLockTime = 0;
+		if ( ent->s.number )
+		{
+			if ( !ent->client->ps.saberAnimLevel )
+			{
+				if ( ent->client->NPC_class == CLASS_DESANN )
+				{
+					ent->client->ps.saberAnimLevel = SS_DESANN;
+				}
+				else if ( ent->client->NPC_class == CLASS_TAVION )
+				{
+					ent->client->ps.saberAnimLevel = SS_TAVION;
+				}
+				else if ( ent->client->NPC_class == CLASS_ALORA )
+				{
+					ent->client->ps.saberAnimLevel = SS_DUAL;
+				}
+				//FIXME: CLASS_CULTIST instead of this Q_stricmpn?
+				else if ( !Q_stricmpn( "cultist", ent->NPC_type, 7 ) )
+				{//should already be set in the .npc file
+					ent->client->ps.saberAnimLevel = Q_irand( SS_FAST, SS_STRONG );
+				}
+				else if ( ent->NPC && ent->client->playerTeam == TEAM_ENEMY && (ent->NPC->rank == RANK_CIVILIAN || ent->NPC->rank == RANK_LT_JG) )
+				{//grunt and fencer always uses quick attacks
+					ent->client->ps.saberAnimLevel = SS_FAST;
+				}
+				else if ( ent->NPC && ent->client->playerTeam == TEAM_ENEMY && (ent->NPC->rank == RANK_CREWMAN || ent->NPC->rank == RANK_ENSIGN) )
+				{//acrobat & force-users always use medium attacks
+					ent->client->ps.saberAnimLevel = SS_MEDIUM;
+				}
+				else if ( ent->client->playerTeam == TEAM_ENEMY && ent->client->NPC_class == CLASS_SHADOWTROOPER )
+				{//shadowtroopers
+					ent->client->ps.saberAnimLevel = Q_irand( SS_FAST, SS_STRONG );
+				}
+				else if ( ent->NPC && ent->client->playerTeam == TEAM_ENEMY && ent->NPC->rank == RANK_LT ) 
+				{//boss always starts with strong attacks
+					ent->client->ps.saberAnimLevel = SS_STRONG;
+				}
+				else if ( ent->client->NPC_class == CLASS_PLAYER )
+				{
+					ent->client->ps.saberAnimLevel = g_entities[0].client->ps.saberAnimLevel;
+				}
+				else
+				{//?
+					ent->client->ps.saberAnimLevel = Q_irand( SS_FAST, SS_STRONG );
+				}
+			}
+		}
+		else
+		{
+			if ( !ent->client->ps.saberAnimLevel )
+			{//initialize, but don't reset
+				if (ent->s.number < MAX_CLIENTS)
+				{
+					if (!ent->client->ps.saberStylesKnown)
+					{
+						ent->client->ps.saberStylesKnown = (1<<SS_MEDIUM);
+					}
+
+
+					if (ent->client->ps.saberStylesKnown & (1<<SS_FAST))
+					{
+						ent->client->ps.saberAnimLevel = SS_FAST;
+					}
+					else if (ent->client->ps.saberStylesKnown & (1<<SS_STRONG))
+					{
+						ent->client->ps.saberAnimLevel = SS_STRONG;
+					}
+					else
+					{
+						ent->client->ps.saberAnimLevel = SS_MEDIUM;
+					}
+
+				}
+				else
+				{
+					ent->client->ps.saberAnimLevel = SS_MEDIUM;
+				}
+			}
+
+			cg.saberAnimLevelPending = ent->client->ps.saberAnimLevel;
+			if ( ent->client->sess.missionStats.weaponUsed[WP_SABER] <= 0 )
+			{//let missionStats know that we actually do have the saber, even if we never use it
+				ent->client->sess.missionStats.weaponUsed[WP_SABER] = 1;
+			}
+		}
+		ent->client->ps.saberAttackChainCount = 0;
+
+		if ( ent->client->ps.saberEntityNum <= 0 || ent->client->ps.saberEntityNum >= ENTITYNUM_WORLD )
+		{//FIXME: if you do have a saber already, be sure to re-set the model if it's changed (say, via a script).
+			gentity_t *saberent = G_Spawn();
+			ent->client->ps.saberEntityNum = saberent->s.number;
+			saberent->classname = "lightsaber";
+			
+			saberent->s.eType = ET_GENERAL;
+			saberent->svFlags = SVF_USE_CURRENT_ORIGIN;
+			saberent->s.weapon = WP_SABER;
+			saberent->owner = ent;
+			saberent->s.otherEntityNum = ent->s.number;
+			//clear the enemy
+			saberent->enemy = NULL;
+
+			saberent->clipmask = MASK_SOLID | CONTENTS_LIGHTSABER;
+			saberent->contents = CONTENTS_LIGHTSABER;//|CONTENTS_SHOTCLIP;
+
+			VectorSet( saberent->mins, -3.0f, -3.0f, -3.0f );
+			VectorSet( saberent->maxs, 3.0f, 3.0f, 3.0f );
+			saberent->mass = 10;//necc?
+
+			saberent->s.eFlags |= EF_NODRAW;
+			saberent->svFlags |= SVF_NOCLIENT;
+/*
+Ghoul2 Insert Start
+*/
+			saberent->playerModel = -1;
+			WP_SetSaberEntModelSkin( ent, saberent );
+
+			// set up a bolt on the end so we can get where the sabre muzzle is - we can assume this is always bolt 0
+			gi.G2API_AddBolt( &saberent->ghoul2[0], "*flash" );
+			//gi.G2API_SetLodBias( &saberent->ghoul2[0], 0 );
+			if ( ent->client->ps.dualSabers )
+			{
+				//int saber2 = 
+				G_ModelIndex( ent->client->ps.saber[1].model );
+				//gi.G2API_InitGhoul2Model( saberent->ghoul2, ent->client->ps.saber[1].model, saber2 );
+				// set up a bolt on the end so we can get where the sabre muzzle is - we can assume this is always bolt 0
+				//gi.G2API_AddBolt( &saberent->ghoul2[0], "*flash" );
+				//gi.G2API_SetLodBias( &saberent->ghoul2[0], 0 );
+			}
+			
+/*
+Ghoul2 Insert End
+*/
+
+			ent->client->ps.saberInFlight = qfalse;
+			ent->client->ps.saberEntityDist = 0;
+			ent->client->ps.saberEntityState = SES_LEAVING;
+
+			ent->client->ps.saberMove = ent->client->ps.saberMoveNext = LS_NONE;
+
+			//FIXME: need a think function to create alerts when turned on or is on, etc.
+		}
+		else
+		{//already have one, might just be changing sabers, register the model and skin and use them if different from what we're using now.
+			WP_SetSaberEntModelSkin( ent, &g_entities[ent->client->ps.saberEntityNum] );
+		}
+	}
+	else
+	{
+		ent->client->ps.saberEntityNum = ENTITYNUM_NONE;
+		ent->client->ps.saberInFlight = qfalse;
+		ent->client->ps.saberEntityDist = 0;
+		ent->client->ps.saberEntityState = SES_LEAVING;
+	}
+
+	if ( ent->client->ps.dualSabers )
+	{
+		return 2;
+	}
+	
+	return 1;
+}
+
+void WP_SaberUpdateOldBladeData( gentity_t *ent )
+{
+	if ( ent->client )
+	{
+		qboolean didEvent = qfalse;
+		for ( int saberNum = 0; saberNum < 2; saberNum++ )
+		{
+			for ( int bladeNum = 0; bladeNum < ent->client->ps.saber[saberNum].numBlades; bladeNum++ )
+			{
+				VectorCopy( ent->client->ps.saber[saberNum].blade[bladeNum].muzzlePoint, ent->client->ps.saber[saberNum].blade[bladeNum].muzzlePointOld );
+				VectorCopy( ent->client->ps.saber[saberNum].blade[bladeNum].muzzleDir, ent->client->ps.saber[saberNum].blade[bladeNum].muzzleDirOld );
+				if ( !didEvent )
+				{
+					if ( ent->client->ps.saber[saberNum].blade[bladeNum].lengthOld <= 0 && ent->client->ps.saber[saberNum].blade[bladeNum].length > 0 )
+					{//just turned on
+						//do sound event
+						vec3_t	saberOrg;
+						VectorCopy( g_entities[ent->client->ps.saberEntityNum].currentOrigin, saberOrg );
+						if ( (!ent->client->ps.saberInFlight && ent->client->ps.groundEntityNum == ENTITYNUM_WORLD)//holding saber and on ground
+							|| g_entities[ent->client->ps.saberEntityNum].s.pos.trType == TR_STATIONARY )//saber out there somewhere and on ground
+						{//a ground alert
+							AddSoundEvent( ent, saberOrg, 256, AEL_SUSPICIOUS, qfalse, qtrue );
+						}
+						else
+						{//an in-air alert
+							AddSoundEvent( ent, saberOrg, 256, AEL_SUSPICIOUS );
+						}
+						didEvent = qtrue;
+					}
+				}
+				ent->client->ps.saber[saberNum].blade[bladeNum].lengthOld = ent->client->ps.saber[saberNum].blade[bladeNum].length;
+			}
+		}
+		VectorCopy( ent->client->renderInfo.muzzlePoint, ent->client->renderInfo.muzzlePointOld );
+		VectorCopy( ent->client->renderInfo.muzzleDir, ent->client->renderInfo.muzzleDirOld );
+	}
+}
+
+
+
+//SABER DAMAGE==============================================================================
+//SABER DAMAGE==============================================================================
+//SABER DAMAGE==============================================================================
+//SABER DAMAGE==============================================================================
+//SABER DAMAGE==============================================================================
+//SABER DAMAGE==============================================================================
+int WPDEBUG_SaberColor( saber_colors_t saberColor )
+{
+	switch( (int)(saberColor) )
+	{
+		case SABER_RED:
+			return 0x000000ff;
+			break;
+		case SABER_ORANGE:
+			return 0x000088ff;
+			break;
+		case SABER_YELLOW:
+			return 0x0000ffff;
+			break;
+		case SABER_GREEN:
+			return 0x0000ff00;
+			break;
+		case SABER_BLUE:
+			return 0x00ff0000;
+			break;
+		case SABER_PURPLE:
+			return 0x00ff00ff;
+			break;
+		default:
+			return 0x00ffffff;//white
+			break;
+	}
+}
+
+qboolean WP_GetSaberDeflectionAngle( gentity_t *attacker, gentity_t *defender )
+{
+	vec3_t	temp, att_SaberBase, att_StartPos, saberMidNext, att_HitDir, att_HitPos, def_BladeDir;
+	float	att_SaberHitLength, hitDot;
+
+	if ( !attacker || !attacker->client || attacker->client->ps.saberInFlight || attacker->client->ps.SaberLength() <= 0 )
+	{
+		return qfalse;
+	}
+	if ( !defender || !defender->client || defender->client->ps.saberInFlight || defender->client->ps.SaberLength() <= 0 )
+	{
+		return qfalse;
+	}
+	if ( PM_SuperBreakLoseAnim( attacker->client->ps.torsoAnim ) 
+		|| PM_SuperBreakWinAnim( attacker->client->ps.torsoAnim ) )
+	{
+		return qfalse;
+	}
+	attacker->client->ps.saberBounceMove = LS_NONE;
+
+	//get the attacker's saber base pos at time of impact
+	VectorSubtract( attacker->client->renderInfo.muzzlePoint, attacker->client->renderInfo.muzzlePointOld, temp );
+	VectorMA( attacker->client->renderInfo.muzzlePointOld, saberHitFraction, temp, att_SaberBase );
+
+	//get the position along the length of the blade where the hit occured
+	att_SaberHitLength = Distance( saberHitLocation, att_SaberBase )/attacker->client->ps.SaberLength();
+
+	//now get the start of that midpoint in the swing and the actual impact point in the swing (shouldn't the latter just be saberHitLocation?)
+	VectorMA( attacker->client->renderInfo.muzzlePointOld, att_SaberHitLength, attacker->client->renderInfo.muzzleDirOld, att_StartPos );
+	VectorMA( attacker->client->renderInfo.muzzlePoint, att_SaberHitLength, attacker->client->renderInfo.muzzleDir, saberMidNext );
+	VectorSubtract( saberMidNext, att_StartPos, att_HitDir );
+	VectorMA( att_StartPos, saberHitFraction, att_HitDir, att_HitPos );
+	VectorNormalize( att_HitDir );
+
+	//get the defender's saber dir at time of impact
+	VectorSubtract( defender->client->renderInfo.muzzleDirOld, defender->client->renderInfo.muzzleDir, temp );
+	VectorMA( defender->client->renderInfo.muzzleDirOld, saberHitFraction, temp, def_BladeDir );
+
+	//now compare
+	hitDot = DotProduct( att_HitDir, def_BladeDir );
+	if ( hitDot < 0.25f && hitDot > -0.25f )
+	{//hit pretty much perpendicular, pop straight back
+		attacker->client->ps.saberBounceMove = PM_SaberBounceForAttack( attacker->client->ps.saberMove );
+		return qfalse;
+	}
+	else 
+	{//a deflection
+		vec3_t	att_Right, att_Up, att_DeflectionDir;
+		float	swingRDot, swingUDot;
+
+		//get the direction of the deflection
+		VectorScale( def_BladeDir, hitDot, att_DeflectionDir );
+		//get our bounce straight back direction
+		VectorScale( att_HitDir, -1.0f, temp );
+		//add the bounce back and deflection
+		VectorAdd( att_DeflectionDir, temp, att_DeflectionDir );
+		//normalize the result to determine what direction our saber should bounce back toward
+		VectorNormalize( att_DeflectionDir );
+
+		//need to know the direction of the deflectoin relative to the attacker's facing
+		VectorSet( temp, 0, attacker->client->ps.viewangles[YAW], 0 );//presumes no pitch!
+		AngleVectors( temp, NULL, att_Right, att_Up );
+		swingRDot = DotProduct( att_Right, att_DeflectionDir );
+		swingUDot = DotProduct( att_Up, att_DeflectionDir );
+
+		if ( swingRDot > 0.25f )
+		{//deflect to right
+			if ( swingUDot > 0.25f )
+			{//deflect to top
+				attacker->client->ps.saberBounceMove = LS_D1_TR;
+			}
+			else if ( swingUDot < -0.25f )
+			{//deflect to bottom
+				attacker->client->ps.saberBounceMove = LS_D1_BR;
+			}
+			else
+			{//deflect horizontally
+				attacker->client->ps.saberBounceMove = LS_D1__R;
+			}
+		}
+		else if ( swingRDot < -0.25f )
+		{//deflect to left
+			if ( swingUDot > 0.25f )
+			{//deflect to top
+				attacker->client->ps.saberBounceMove = LS_D1_TL;
+			}
+			else if ( swingUDot < -0.25f )
+			{//deflect to bottom
+				attacker->client->ps.saberBounceMove = LS_D1_BL;
+			}
+			else
+			{//deflect horizontally
+				attacker->client->ps.saberBounceMove = LS_D1__L;
+			}
+		}
+		else
+		{//deflect in middle
+			if ( swingUDot > 0.25f )
+			{//deflect to top
+				attacker->client->ps.saberBounceMove = LS_D1_T_;
+			}
+			else if ( swingUDot < -0.25f )
+			{//deflect to bottom
+				attacker->client->ps.saberBounceMove = LS_D1_B_;
+			}
+			else
+			{//deflect horizontally?  Well, no such thing as straight back in my face, so use top
+				if ( swingRDot > 0 )
+				{
+					attacker->client->ps.saberBounceMove = LS_D1_TR;
+				}
+				else if ( swingRDot < 0 )
+				{
+					attacker->client->ps.saberBounceMove = LS_D1_TL;
+				}
+				else
+				{
+					attacker->client->ps.saberBounceMove = LS_D1_T_;
+				}
+			}
+		}
+#ifndef FINAL_BUILD
+		if ( d_saberCombat->integer )
+		{
+			gi.Printf( S_COLOR_BLUE"%s deflected from %s to %s\n", attacker->targetname, saberMoveData[attacker->client->ps.saberMove].name, saberMoveData[attacker->client->ps.saberBounceMove].name );
+		}
+#endif
+		return qtrue;
+	}
+}
+
+
+void WP_SaberClearDamageForEntNum( int entityNum )
+{
+#ifndef FINAL_BUILD
+	if ( d_saberCombat->integer )
+	{
+		if ( entityNum )
+		{
+			Com_Printf( "clearing damage for entnum %d\n", entityNum );
+		}
+	}
+#endif// FINAL_BUILD
+	if ( g_saberRealisticCombat->integer > 1 )
+	{
+		return;
+	}
+	for ( int i = 0; i < numVictims; i++ )
+	{
+		if ( victimEntityNum[i] == entityNum )
+		{
+			totalDmg[i] = 0;//no damage
+			hitLoc[i] = HL_NONE;
+			hitDismemberLoc[i] = HL_NONE;
+			hitDismember[i] = qfalse;
+			victimEntityNum[i] = ENTITYNUM_NONE;//like we never hit him
+		}
+	}
+}
+
+extern float damageModifier[];
+extern float hitLocHealthPercentage[];
+qboolean WP_SaberApplyDamage( gentity_t *ent, float baseDamage, int baseDFlags, qboolean brokenParry, saberType_t saberType, qboolean thrownSaber )
+{
+	qboolean	didDamage = qfalse;
+	gentity_t	*victim;
+	int			dFlags = baseDFlags;
+	float		maxDmg;
+
+
+	if ( !numVictims )
+	{
+		return qfalse;
+	}
+	for ( int i = 0; i < numVictims; i++ )
+	{
+		dFlags = baseDFlags|DAMAGE_DEATH_KNOCKBACK|DAMAGE_NO_HIT_LOC;
+		if ( victimEntityNum[i] != ENTITYNUM_NONE && &g_entities[victimEntityNum[i]] != NULL )
+		{	// Don't bother with this damage if the fraction is higher than the saber's fraction
+			if ( dmgFraction[i] < saberHitFraction || brokenParry )
+			{
+				victim = &g_entities[victimEntityNum[i]];
+				if ( !victim )
+				{
+					continue;
+				}
+				
+				if ( victim->e_DieFunc == dieF_maglock_die )
+				{//*sigh*, special check for maglocks
+					vec3_t testFrom;
+					if ( ent->client->ps.saberInFlight )
+					{
+						VectorCopy( g_entities[ent->client->ps.saberEntityNum].currentOrigin, testFrom );
+					}
+					else
+					{
+						VectorCopy( ent->currentOrigin, testFrom );
+					}
+					testFrom[2] = victim->currentOrigin[2];
+					trace_t testTrace;
+					gi.trace( &testTrace, testFrom, vec3_origin, vec3_origin, victim->currentOrigin, ent->s.number, MASK_SHOT );
+					if ( testTrace.entityNum != victim->s.number )
+					{//can only damage maglocks if have a clear trace to the thing's origin
+						continue;
+					}
+				}
+				if ( totalDmg[i] > 0 )
+				{//actually want to do *some* damage here
+					if ( victim->client
+						&& victim->client->NPC_class==CLASS_WAMPA
+						&& victim->activator == ent )
+					{
+					}
+					else if ( PM_SuperBreakWinAnim( ent->client->ps.torsoAnim ) 
+						|| PM_StabDownAnim( ent->client->ps.torsoAnim ) )
+					{//never cap the superbreak wins
+					}
+					else 
+					{
+						if ( victim->client
+							&& (victim->s.weapon == WP_SABER || (victim->client->NPC_class==CLASS_REBORN) || (victim->client->NPC_class==CLASS_WAMPA))
+							&& !g_saberRealisticCombat->integer )
+						{//dmg vs other saber fighters is modded by hitloc and capped
+							totalDmg[i] *= damageModifier[hitLoc[i]];
+							if ( hitLoc[i] == HL_NONE )
+							{
+								maxDmg = 33*baseDamage;
+							}
+							else
+							{
+								maxDmg = 50*hitLocHealthPercentage[hitLoc[i]]*baseDamage;//*victim->client->ps.stats[STAT_MAX_HEALTH]*2.0f;
+							}
+							if ( maxDmg < totalDmg[i] )
+							{
+								totalDmg[i] = maxDmg;
+							}
+							//dFlags |= DAMAGE_NO_HIT_LOC;
+						}
+						//clamp the dmg
+						if ( victim->s.weapon != WP_SABER )
+						{//clamp the dmg between 25 and maxhealth
+							/*
+							if ( totalDmg[i] > victim->max_health )
+							{
+								totalDmg[i] = victim->max_health;
+							}
+							else */if ( totalDmg[i] < 25 )
+							{
+								totalDmg[i] = 25;
+							}
+							if ( totalDmg[i] > 100 )//+(50*g_spskill->integer) )
+							{//clamp using same adjustment as in NPC_Begin
+								totalDmg[i] = 100;//+(50*g_spskill->integer);
+							}
+						}
+						else
+						{//clamp the dmg between 5 and 100
+							if ( !victim->s.number && totalDmg[i] > 50 )
+							{//never do more than half full health damage to player
+								//prevents one-hit kills
+								totalDmg[i] = 50;
+							}
+							else if ( totalDmg[i] > 100 )
+							{
+								totalDmg[i] = 100;
+							}
+							else
+							{
+								if ( totalDmg[i] < 5 )
+								{
+									totalDmg[i] = 5;
+								}
+							}
+						}
+					}
+
+					if ( totalDmg[i] > 0 )
+					{
+						gentity_t *inflictor = ent;
+						didDamage = qtrue;
+
+						if ( baseDamage <= 0.1f )
+						{//just get their attention?
+							dFlags |= DAMAGE_NO_DAMAGE;
+						}
+
+						if( victim->client )
+						{
+							if ( victim->client->ps.pm_time > 0 && victim->client->ps.pm_flags & PMF_TIME_KNOCKBACK && victim->client->ps.velocity[2] > 0 )
+							{//already being knocked around
+								dFlags |= DAMAGE_NO_KNOCKBACK;
+							}
+							if ( g_dismemberment->integer == 113811381138 || g_saberRealisticCombat->integer )
+							{
+								dFlags |= DAMAGE_DISMEMBER;
+								if ( hitDismember[i] )
+								{
+									victim->client->dismembered = false;
+								}
+							}
+							else if ( hitDismember[i] )
+							{
+								dFlags |= DAMAGE_DISMEMBER;
+							}
+							if ( baseDamage <= 1.0f )
+							{//very mild damage
+								if ( victim->s.number == 0 || victim->client->ps.weapon == WP_SABER || victim->client->NPC_class == CLASS_GALAKMECH )
+								{//if it's the player or a saber-user, don't kill them with this blow
+									dFlags |= DAMAGE_NO_KILL;
+								}
+							}
+						}
+						else
+						{
+							if ( victim->takedamage )
+							{//some other breakable thing
+								//create a flash here
+								g_saberFlashTime = level.time-50;
+								VectorCopy( dmgSpot[i], g_saberFlashPos );
+							}
+						}
+						if ( !PM_SuperBreakWinAnim( ent->client->ps.torsoAnim ) 
+							&& !PM_StabDownAnim( ent->client->ps.torsoAnim )
+							&& !g_saberRealisticCombat->integer
+							&& g_saberDamageCapping->integer ) 
+						{//never cap the superbreak wins
+							if ( victim->client
+								&& victim->s.number >= MAX_CLIENTS )
+							{
+								if ( victim->client->NPC_class == CLASS_SHADOWTROOPER
+									|| ( victim->NPC && (victim->NPC->aiFlags&NPCAI_BOSS_CHARACTER) ) )
+								{//hit a boss character
+									int maxDmg = ((3-g_spskill->integer)*5)+10; 
+									if ( totalDmg[i] > maxDmg )
+									{
+										totalDmg[i] = maxDmg;
+									} 
+								}
+								else if ( victim->client->ps.weapon == WP_SABER
+									|| victim->client->NPC_class == CLASS_REBORN
+									|| victim->client->NPC_class == CLASS_JEDI )
+								{//hit a non-boss saber-user
+									int maxDmg = ((3-g_spskill->integer)*15)+30;  
+									if ( totalDmg[i] > maxDmg )
+									{
+										totalDmg[i] = maxDmg;
+									} 
+								}
+							}
+							if ( victim->s.number < MAX_CLIENTS 
+								&& ent->NPC )
+							{
+                                if ( (ent->NPC->aiFlags&NPCAI_BOSS_CHARACTER)
+									|| (ent->NPC->aiFlags&NPCAI_SUBBOSS_CHARACTER)
+									|| ent->client->NPC_class == CLASS_SHADOWTROOPER )
+								{//player hit by a boss character
+									int maxDmg = ((g_spskill->integer+1)*4)+3; 
+									if ( totalDmg[i] > maxDmg )
+									{
+										totalDmg[i] = maxDmg; 
+									}
+								}
+								else if ( g_spskill->integer < 3 ) //was < 2
+								{//player hit by any enemy //on easy or medium?
+									int maxDmg = ((g_spskill->integer+1)*10)+20;  
+									if ( totalDmg[i] > maxDmg )
+									{
+										totalDmg[i] = maxDmg;
+									}
+								}
+							}
+						}
+						//victim->hitLoc = hitLoc[i];
+
+						dFlags |= DAMAGE_NO_KNOCKBACK;//okay, let's try no knockback whatsoever...
+						dFlags &= ~DAMAGE_DEATH_KNOCKBACK;
+						if ( g_saberRealisticCombat->integer )
+						{
+							dFlags |= DAMAGE_NO_KNOCKBACK;
+							dFlags &= ~DAMAGE_DEATH_KNOCKBACK;
+							dFlags &= ~DAMAGE_NO_KILL;
+						}
+						if ( ent->client && !ent->s.number )
+						{
+							switch( hitLoc[i] )
+							{
+							case HL_FOOT_RT:
+							case HL_FOOT_LT:
+							case HL_LEG_RT:
+							case HL_LEG_LT:
+								ent->client->sess.missionStats.legAttacksCnt++;
+								break;
+							case HL_WAIST:
+							case HL_BACK_RT:
+							case HL_BACK_LT:
+							case HL_BACK:
+							case HL_CHEST_RT:
+							case HL_CHEST_LT:
+							case HL_CHEST:
+								ent->client->sess.missionStats.torsoAttacksCnt++;
+								break;
+							case HL_ARM_RT:
+							case HL_ARM_LT:
+							case HL_HAND_RT:
+							case HL_HAND_LT:
+								ent->client->sess.missionStats.armAttacksCnt++;
+								break;
+							default:
+								ent->client->sess.missionStats.otherAttacksCnt++;
+								break;
+							}
+						}
+
+						if ( saberType == SABER_SITH_SWORD )
+						{//do knockback
+							dFlags &= ~(DAMAGE_NO_KNOCKBACK|DAMAGE_DEATH_KNOCKBACK);
+						}
+						if ( thrownSaber )
+						{
+							inflictor = &g_entities[ent->client->ps.saberEntityNum];
+						}
+						G_Damage( victim, inflictor, ent, dmgDir[i], dmgSpot[i], ceil(totalDmg[i]), dFlags, MOD_SABER, hitDismemberLoc[i] );
+#ifndef FINAL_BUILD
+						if ( d_saberCombat->integer )
+						{
+							if ( (dFlags&DAMAGE_NO_DAMAGE) )
+							{
+								gi.Printf( S_COLOR_RED"damage: fake, hitLoc %d\n", hitLoc[i] );
+							}
+							else
+							{
+								gi.Printf( S_COLOR_RED"damage: %4.2f, hitLoc %d\n", totalDmg[i], hitLoc[i] );
+							}
+						}
+#endif
+						//do the effect
+						//G_PlayEffect( G_EffectIndex( "blood_sparks" ), dmgSpot[i], dmgDir[i] );
+						if ( ent->s.number == 0 )
+						{
+							AddSoundEvent( victim->owner, dmgSpot[i], 256, AEL_DISCOVERED );
+							AddSightEvent( victim->owner, dmgSpot[i], 512, AEL_DISCOVERED, 50 );
+						}
+						if ( ent->client )
+						{
+							if ( ent->enemy && ent->enemy == victim )
+							{//just so Jedi knows that he hit his enemy
+								ent->client->ps.saberEventFlags |= SEF_HITENEMY;
+							}
+							else
+							{
+								ent->client->ps.saberEventFlags |= SEF_HITOBJECT;
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+	return didDamage;
+}
+
+void WP_SaberDamageAdd( float trDmg, int trVictimEntityNum, vec3_t trDmgDir, vec3_t trDmgSpot, float dmg, float fraction, int trHitLoc, qboolean trDismember, int trDismemberLoc )
+{
+	int curVictim = 0;
+
+	if ( trVictimEntityNum < 0 || trVictimEntityNum >= ENTITYNUM_WORLD )
+	{
+		return;
+	}
+	if ( trDmg * dmg < 10.0f )
+	{//too piddly an amount of damage to really count?
+		//FIXME: but already did the effect, didn't we... sigh...
+		//return;
+	}
+	if ( trDmg )
+	{//did some damage to something
+		for ( int i = 0; i < numVictims; i++ )
+		{
+			if ( victimEntityNum[i] == trVictimEntityNum )
+			{//already hit this guy before
+				curVictim = i;
+				break;
+			}
+		}
+		if ( i == numVictims )
+		{//haven't hit his guy before
+			if ( numVictims + 1 >= MAX_SABER_VICTIMS )
+			{//can't add another victim at this time
+				return;
+			}
+			//add a new victim to the list
+			curVictim = numVictims;
+			victimEntityNum[numVictims++] = trVictimEntityNum;
+		}
+
+		float addDmg = trDmg*dmg;
+		if ( trHitLoc!=HL_NONE && (hitLoc[curVictim]==HL_NONE||hitLocHealthPercentage[trHitLoc]>hitLocHealthPercentage[hitLoc[curVictim]]) )
+		{//this hitLoc is more critical than the previous one this frame
+			hitLoc[curVictim] = trHitLoc;
+		}
+		
+		totalDmg[curVictim] += addDmg;
+		if ( !VectorLengthSquared( dmgDir[curVictim] ) )
+		{
+			VectorCopy( trDmgDir, dmgDir[curVictim] );
+		}
+		if ( !VectorLengthSquared( dmgSpot[curVictim] ) )
+		{
+			VectorCopy( trDmgSpot, dmgSpot[curVictim] );
+		}
+
+		// Make sure we keep track of the fraction.  Why?  
+		// Well, if the saber hits something that stops it, the damage isn't done past that point.
+		dmgFraction[curVictim] = fraction;
+		if ( (trDismemberLoc != HL_NONE && hitDismemberLoc[curVictim] == HL_NONE)
+			|| (!hitDismember[curVictim] && trDismember) )
+		{//either this is the first dismember loc we got or we got a loc before, but it wasn't a dismember loc, so take the new one
+			hitDismemberLoc[curVictim] = trDismemberLoc;
+		}
+		if ( trDismember )
+		{//we scored a dismemberment hit...
+			hitDismember[curVictim] = trDismember;
+		}
+	}
+}
+
+/*
+WP_SabersIntersect
+
+Breaks the two saber paths into 2 tris each and tests each tri for the first saber path against each of the other saber path's tris
+
+FIXME: subdivide the arc into a consistant increment
+FIXME: test the intersection to see if the sabers really did intersect (weren't going in the same direction and/or passed through same point at different times)?
+*/
+extern qboolean tri_tri_intersect(vec3_t V0,vec3_t V1,vec3_t V2,vec3_t U0,vec3_t U1,vec3_t U2);
+qboolean WP_SabersIntersect( gentity_t *ent1, int ent1SaberNum, int ent1BladeNum, gentity_t *ent2, qboolean checkDir )
+{
+	vec3_t	saberBase1, saberTip1, saberBaseNext1, saberTipNext1;
+	vec3_t	saberBase2, saberTip2, saberBaseNext2, saberTipNext2;
+	int		ent2SaberNum = 0, ent2BladeNum = 0;
+	vec3_t	dir;
+
+	/*
+#ifndef FINAL_BUILD
+	if ( d_saberCombat->integer )
+	{
+		gi.Printf( S_COLOR_GREEN"Doing precise saber intersection check\n" );
+	}
+#endif
+	*/
+
+	if ( !ent1 || !ent2 )
+	{
+		return qfalse;
+	}
+	if ( !ent1->client || !ent2->client )
+	{
+		return qfalse;
+	}
+	if ( ent1->client->ps.SaberLength() <= 0 || ent2->client->ps.SaberLength() <= 0 )
+	{
+		return qfalse;
+	}
+
+	for ( ent2SaberNum = 0; ent2SaberNum < MAX_SABERS; ent2SaberNum++ )
+	{
+		for ( ent2BladeNum = 0; ent2BladeNum < ent2->client->ps.saber[ent2SaberNum].numBlades; ent2BladeNum++ )
+		{
+			if ( ent2->client->ps.saber[ent2SaberNum].type != SABER_NONE
+				&& ent2->client->ps.saber[ent2SaberNum].blade[ent2BladeNum].length > 0 )
+			{//valid saber and this blade is on
+				//if ( ent1->client->ps.saberInFlight )
+				{
+					VectorCopy( ent1->client->ps.saber[ent1SaberNum].blade[ent1BladeNum].muzzlePointOld, saberBase1 );
+					VectorCopy( ent1->client->ps.saber[ent1SaberNum].blade[ent1BladeNum].muzzlePoint, saberBaseNext1 );
+
+					VectorSubtract( ent1->client->ps.saber[ent1SaberNum].blade[ent1BladeNum].muzzlePoint, ent1->client->ps.saber[ent1SaberNum].blade[ent1BladeNum].muzzlePointOld, dir );
+					VectorNormalize( dir );
+					VectorMA( saberBaseNext1, SABER_EXTRAPOLATE_DIST, dir, saberBaseNext1 );
+
+					VectorMA( saberBase1, ent1->client->ps.saber[ent1SaberNum].blade[ent1BladeNum].length, ent1->client->ps.saber[ent1SaberNum].blade[ent1BladeNum].muzzleDirOld, saberTip1 );
+					VectorMA( saberBaseNext1, ent1->client->ps.saber[ent1SaberNum].blade[ent1BladeNum].length, ent1->client->ps.saber[ent1SaberNum].blade[ent1BladeNum].muzzleDir, saberTipNext1 );
+
+					VectorSubtract( saberTipNext1, saberTip1, dir );
+					VectorNormalize( dir );
+					VectorMA( saberTipNext1, SABER_EXTRAPOLATE_DIST, dir, saberTipNext1 );
+				}
+				/*
+				else
+				{
+					VectorCopy( ent1->client->ps.saber[ent1SaberNum].blade[ent1BladeNum].muzzlePoint, saberBase1 );
+					VectorCopy( ent1->client->ps.saber[ent1SaberNum].blade[ent1BladeNum].muzzlePointNext, saberBaseNext1 );
+					VectorMA( saberBase1, ent1->client->ps.saber[ent1SaberNum].blade[ent1BladeNum].length, ent1->client->ps.saber[ent1SaberNum].blade[ent1BladeNum].muzzleDir, saberTip1 );
+					VectorMA( saberBaseNext1, ent1->client->ps.saber[ent1SaberNum].blade[ent1BladeNum].length, ent1->client->ps.saber[ent1SaberNum].blade[ent1BladeNum].muzzleDirNext, saberTipNext1 );
+				}
+				*/
+
+				//if ( ent2->client->ps.saberInFlight )
+				{
+					VectorCopy( ent2->client->ps.saber[ent2SaberNum].blade[ent2BladeNum].muzzlePointOld, saberBase2 );
+					VectorCopy( ent2->client->ps.saber[ent2SaberNum].blade[ent2BladeNum].muzzlePoint, saberBaseNext2 );
+
+					VectorSubtract( ent2->client->ps.saber[ent2SaberNum].blade[ent2BladeNum].muzzlePoint, ent2->client->ps.saber[ent2SaberNum].blade[ent2BladeNum].muzzlePointOld, dir );
+					VectorNormalize( dir );
+					VectorMA( saberBaseNext2, SABER_EXTRAPOLATE_DIST, dir, saberBaseNext2 );
+
+					VectorMA( saberBase2, ent2->client->ps.saber[ent2SaberNum].blade[ent2BladeNum].length, ent2->client->ps.saber[ent2SaberNum].blade[ent2BladeNum].muzzleDirOld, saberTip2 );
+					VectorMA( saberBaseNext2, ent2->client->ps.saber[ent2SaberNum].blade[ent2BladeNum].length, ent2->client->ps.saber[ent2SaberNum].blade[ent2BladeNum].muzzleDir, saberTipNext2 );
+
+					VectorSubtract( saberTipNext2, saberTip2, dir );
+					VectorNormalize( dir );
+					VectorMA( saberTipNext2, SABER_EXTRAPOLATE_DIST, dir, saberTipNext2 );
+				}
+				/*
+				else
+				{
+					VectorCopy( ent2->client->ps.saber[ent2SaberNum].blade[ent2BladeNum].muzzlePoint, saberBase2 );
+					VectorCopy( ent2->client->ps.saber[ent2SaberNum].blade[ent2BladeNum].muzzlePointNext, saberBaseNext2 );
+					VectorMA( saberBase2, ent2->client->ps.saber[ent2SaberNum].blade[ent2BladeNum].length, ent2->client->ps.saber[ent2SaberNum].blade[ent2BladeNum].muzzleDir, saberTip2 );
+					VectorMA( saberBaseNext2, ent2->client->ps.saber[ent2SaberNum].blade[ent2BladeNum].length, ent2->client->ps.saber[ent2SaberNum].blade[ent2BladeNum].muzzleDirNext, saberTipNext2 );
+				}
+				*/
+				if ( checkDir )
+				{//check the direction of the two swings to make sure the sabers are swinging towards each other
+					vec3_t saberDir1, saberDir2;
+
+					VectorSubtract( saberTipNext1, saberTip1, saberDir1 );
+					VectorSubtract( saberTipNext2, saberTip2, saberDir2 );
+					VectorNormalize( saberDir1 );
+					VectorNormalize( saberDir2 );
+					if ( DotProduct( saberDir1, saberDir2 ) > 0.6f )
+					{//sabers moving in same dir, probably didn't actually hit
+						continue;
+					}
+					//now check orientation of sabers, make sure they're not parallel or close to it
+					float dot = DotProduct( ent1->client->ps.saber[ent1SaberNum].blade[ent1BladeNum].muzzleDir, ent2->client->ps.saber[ent2SaberNum].blade[ent2BladeNum].muzzleDir );
+					if ( dot > 0.9f || dot < -0.9f )
+					{//too parallel to really block effectively?
+						continue;
+					}
+				}
+
+				if ( tri_tri_intersect( saberBase1, saberTip1, saberBaseNext1, saberBase2, saberTip2, saberBaseNext2 ) )
+				{
+					return qtrue;
+				}
+				if ( tri_tri_intersect( saberBase1, saberTip1, saberBaseNext1, saberBase2, saberTip2, saberTipNext2 ) )
+				{
+					return qtrue;
+				}
+				if ( tri_tri_intersect( saberBase1, saberTip1, saberTipNext1, saberBase2, saberTip2, saberBaseNext2 ) )
+				{
+					return qtrue;
+				}
+				if ( tri_tri_intersect( saberBase1, saberTip1, saberTipNext1, saberBase2, saberTip2, saberTipNext2 ) )
+				{
+					return qtrue;
+				}
+			}
+		}
+	}
+	return qfalse;
+}
+
+extern float ShortestLineSegBewteen2LineSegs( vec3_t start1, vec3_t end1, vec3_t start2, vec3_t end2, vec3_t close_pnt1, vec3_t close_pnt2 );
+float WP_SabersDistance( gentity_t *ent1, gentity_t *ent2 )
+{
+	vec3_t	saberBaseNext1, saberTipNext1, saberPoint1;
+	vec3_t	saberBaseNext2, saberTipNext2, saberPoint2;
+
+	/*
+#ifndef FINAL_BUILD
+	if ( d_saberCombat->integer )
+	{
+		gi.Printf( S_COLOR_GREEN"Doing precise saber intersection check\n" );
+	}
+#endif
+	*/
+
+	if ( !ent1 || !ent2 )
+	{
+		return qfalse;
+	}
+	if ( !ent1->client || !ent2->client )
+	{
+		return qfalse;
+	}
+	if ( ent1->client->ps.SaberLength() <= 0 || ent2->client->ps.SaberLength() <= 0 )
+	{
+		return qfalse;
+	}
+
+	//FIXME: UGH, how do we make this work for multiply-bladed sabers?
+
+	//if ( ent1->client->ps.saberInFlight )
+	{
+		VectorCopy( ent1->client->ps.saber[0].blade[0].muzzlePoint, saberBaseNext1 );
+		VectorMA( saberBaseNext1, ent1->client->ps.saber[0].blade[0].length, ent1->client->ps.saber[0].blade[0].muzzleDir, saberTipNext1 );
+	}
+	/*
+	else
+	{
+		VectorCopy( ent1->client->ps.saber[0].blade[0].muzzlePointNext, saberBaseNext1 );
+		VectorMA( saberBaseNext1, ent1->client->ps.saber[0].blade[0].length, ent1->client->ps.saber[0].blade[0].muzzleDirNext, saberTipNext1 );
+	}
+	*/
+
+	//if ( ent2->client->ps.saberInFlight )
+	{
+		VectorCopy( ent2->client->ps.saber[0].blade[0].muzzlePoint, saberBaseNext2 );
+		VectorMA( saberBaseNext2, ent2->client->ps.saber[0].blade[0].length, ent2->client->ps.saber[0].blade[0].muzzleDir, saberTipNext2 );
+	}
+	/*
+	else
+	{
+		VectorCopy( ent2->client->ps.saber[0].blade[0].muzzlePointNext, saberBaseNext2 );
+		VectorMA( saberBaseNext2, ent2->client->ps.saber[0].blade[0].length, ent2->client->ps.saber[0].blade[0].muzzleDirNext, saberTipNext2 );
+	}
+	*/
+
+	float sabersDist = ShortestLineSegBewteen2LineSegs( saberBaseNext1, saberTipNext1, saberBaseNext2, saberTipNext2, saberPoint1, saberPoint2 );
+
+	//okay, this is a super hack, but makes saber collisions look better from the player point of view
+	/*
+	if ( sabersDist < 16.0f )
+	{
+		vec3_t	saberDistDir, saberMidPoint, camLookDir;
+
+		VectorSubtract( saberPoint2, saberPoint1, saberDistDir );
+		VectorMA( saberPoint1, 0.5f, saberDistDir, saberMidPoint );
+		VectorSubtract( saberMidPoint, cg.refdef.vieworg, camLookDir );
+		VectorNormalize( saberDistDir );
+		VectorNormalize( camLookDir );
+		float dot = fabs(DotProduct( camLookDir, saberDistDir ));
+		sabersDist -= 8.0f*dot;
+		if ( sabersDist < 0.0f )
+		{
+			sabersDist = 0.0f;
+		}
+	}
+	*/
+
+#ifndef FINAL_BUILD
+	if ( d_saberCombat->integer > 2 )
+	{
+		G_DebugLine( saberPoint1, saberPoint2, FRAMETIME, 0x00ffffff, qtrue );
+	}
+#endif
+	return sabersDist;
+}
+
+qboolean WP_SabersIntersection( gentity_t *ent1, gentity_t *ent2, vec3_t intersect )
+{
+	vec3_t	saberBaseNext1, saberTipNext1, saberPoint1;
+	vec3_t	saberBaseNext2, saberTipNext2, saberPoint2;
+	int		saberNum1, saberNum2, bladeNum1, bladeNum2;
+	float	lineSegLength, bestLineSegLength = Q3_INFINITE;
+
+	if ( !ent1 || !ent2 )
+	{
+		return qfalse;
+	}
+	if ( !ent1->client || !ent2->client )
+	{
+		return qfalse;
+	}
+	if ( ent1->client->ps.SaberLength() <= 0 || ent2->client->ps.SaberLength() <= 0 )
+	{
+		return qfalse;
+	}
+
+	//UGH, had to make this work for multiply-bladed sabers
+	for ( saberNum1 = 0; saberNum1 < MAX_SABERS; saberNum1++ )
+	{
+		for ( bladeNum1 = 0; bladeNum1 < ent1->client->ps.saber[saberNum1].numBlades; bladeNum1++ )
+		{
+			if ( ent1->client->ps.saber[saberNum1].type != SABER_NONE
+				&& ent1->client->ps.saber[saberNum1].blade[bladeNum1].length > 0 )
+			{//valid saber and this blade is on
+				for ( saberNum2 = 0; saberNum2 < MAX_SABERS; saberNum2++ )
+				{
+					for ( bladeNum2 = 0; bladeNum2 < ent2->client->ps.saber[saberNum2].numBlades; bladeNum2++ )
+					{
+						if ( ent2->client->ps.saber[saberNum2].type != SABER_NONE
+							&& ent2->client->ps.saber[saberNum2].blade[bladeNum2].length > 0 )
+						{//valid saber and this blade is on
+							VectorCopy( ent1->client->ps.saber[saberNum1].blade[bladeNum1].muzzlePoint, saberBaseNext1 );
+							VectorMA( saberBaseNext1, ent1->client->ps.saber[saberNum1].blade[bladeNum1].length, ent1->client->ps.saber[saberNum1].blade[bladeNum1].muzzleDir, saberTipNext1 );
+
+							VectorCopy( ent2->client->ps.saber[saberNum2].blade[bladeNum2].muzzlePoint, saberBaseNext2 );
+							VectorMA( saberBaseNext2, ent2->client->ps.saber[saberNum2].blade[bladeNum2].length, ent2->client->ps.saber[saberNum2].blade[bladeNum2].muzzleDir, saberTipNext2 );
+
+							lineSegLength = ShortestLineSegBewteen2LineSegs( saberBaseNext1, saberTipNext1, saberBaseNext2, saberTipNext2, saberPoint1, saberPoint2 );
+							if ( lineSegLength < bestLineSegLength )
+							{
+								bestLineSegLength = lineSegLength;
+								VectorAdd( saberPoint1, saberPoint2, intersect );
+								VectorScale( intersect, 0.5, intersect );
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+	return qtrue;
+}
+
+const char *hit_blood_sparks = "sparks/blood_sparks2"; // could have changed this effect directly, but this is just safer in case anyone anywhere else is using the old one for something?
+const char *hit_sparks = "saber/saber_cut";
+
+//extern char *hitLocName[];
+qboolean WP_SaberDamageEffects( trace_t *tr, const vec3_t start, float length, float dmg, vec3_t dmgDir, vec3_t bladeDir, int enemyTeam, saberType_t saberType )
+{
+
+	int			hitEntNum[MAX_G2_COLLISIONS];
+	for ( int hen = 0; hen < MAX_G2_COLLISIONS; hen++ )
+	{
+		hitEntNum[hen] = ENTITYNUM_NONE;
+	}
+	//NOTE: = {0} does NOT work on anything but bytes?
+	float		hitEntDmgAdd[MAX_G2_COLLISIONS] = {0};
+	float		hitEntDmgSub[MAX_G2_COLLISIONS] = {0};
+	vec3_t		hitEntPoint[MAX_G2_COLLISIONS];
+	vec3_t		hitEntDir[MAX_G2_COLLISIONS];
+	float		hitEntStartFrac[MAX_G2_COLLISIONS] = {0};
+	int			trHitLoc[MAX_G2_COLLISIONS] = {HL_NONE};//same as 0
+	int			trDismemberLoc[MAX_G2_COLLISIONS] = {HL_NONE};//same as 0
+	qboolean	trDismember[MAX_G2_COLLISIONS] = {qfalse};//same as 0
+	int			i,z;
+	int			numHitEnts = 0;
+	float		distFromStart,doDmg;
+	const char	*hitEffect, *trSurfName;
+	gentity_t	*hitEnt;
+	
+	for (z=0; z < MAX_G2_COLLISIONS; z++)
+	{
+		if ( tr->G2CollisionMap[z].mEntityNum == -1 )
+		{//actually, completely break out of this for loop since nothing after this in the aray should ever be valid either
+			continue;//break;//
+		}
+
+		CCollisionRecord &coll	= tr->G2CollisionMap[z];
+		//distFromStart			= Distance( start, coll.mCollisionPosition );
+		distFromStart			= coll.mDistance;
+
+		/*
+		//FIXME: (distFromStart/length) is not guaranteed to be from 0 to 1... *sigh*...
+		if ( length && saberHitFraction < 1.0f && (distFromStart/length) < 1.0f && (distFromStart/length) > saberHitFraction )
+		{//a saber was hit before this point, don't count it
+#ifndef FINAL_BUILD
+			if ( d_saberCombat->integer )
+			{
+				gi.Printf( S_COLOR_MAGENTA"rejecting G2 collision- %4.2f farther than saberHitFraction %4.2f\n", (distFromStart/length), saberHitFraction  );
+			}
+#endif
+			continue;
+		}
+		*/
+
+		for ( i = 0; i < numHitEnts; i++ )
+		{
+			if ( hitEntNum[i] == coll.mEntityNum )
+			{//we hit this ent before
+				//we'll want to add this dist
+				hitEntDmgAdd[i] = distFromStart;
+				break;
+			}
+		}
+		if ( i == numHitEnts )
+		{//first time we hit this ent
+			if ( numHitEnts == MAX_G2_COLLISIONS )
+			{//hit too many damn ents!
+				continue;
+			}
+			hitEntNum[numHitEnts] = coll.mEntityNum;
+			if ( !coll.mFlags )
+			{//hmm, we came out first, so we must have started inside
+				//we'll want to subtract this dist
+				hitEntDmgAdd[numHitEnts] = distFromStart;
+			}
+			else
+			{//we're entering the model
+				//we'll want to subtract this dist
+				hitEntDmgSub[numHitEnts] = distFromStart;
+			}
+			//keep track of how far in the damage was done
+			hitEntStartFrac[numHitEnts] = hitEntDmgSub[numHitEnts]/length;
+			//remember the entrance point
+			VectorCopy( coll.mCollisionPosition, hitEntPoint[numHitEnts] );
+			//remember the entrance dir
+			VectorCopy( coll.mCollisionNormal, hitEntDir[numHitEnts] );
+			VectorNormalize( hitEntDir[numHitEnts] );
+			
+			//do the effect
+
+			//FIXME: check material rather than team?
+			hitEnt = &g_entities[hitEntNum[numHitEnts]];
+			hitEffect = hit_blood_sparks;
+			if ( hitEnt != NULL )
+			{
+				if ( hitEnt->client )
+				{
+					class_t npc_class = hitEnt->client->NPC_class;
+					if ( npc_class == CLASS_SEEKER || npc_class == CLASS_PROBE || npc_class == CLASS_MOUSE || npc_class == CLASS_REMOTE ||
+					     npc_class == CLASS_GONK || npc_class == CLASS_R2D2 || npc_class == CLASS_R5D2 ||
+					     npc_class == CLASS_PROTOCOL || npc_class == CLASS_MARK1 || npc_class == CLASS_MARK2 ||
+					     npc_class == CLASS_INTERROGATOR || npc_class == CLASS_ATST || npc_class == CLASS_SENTRY )  
+					{
+						hitEffect = hit_sparks;
+					}
+				}
+				else
+				{
+					// So sue me, this is the easiest way to check to see if this is the turbo laser from t2_wedge,
+					// in which case I don't want the saber effects goin off on it.
+					if ( (hitEnt->flags&FL_DMG_BY_HEAVY_WEAP_ONLY)
+						&& hitEnt->takedamage == qfalse
+						&& Q_stricmp( hitEnt->classname, "misc_turret" ) == 0 )
+					{
+						continue;
+					}
+					else
+					{
+						if ( dmg )
+						{//only do these effects if actually trying to damage the thing...
+							if ( (hitEnt->svFlags&SVF_BBRUSH)//a breakable brush
+								&& ( (hitEnt->spawnflags&1)//INVINCIBLE
+									||(hitEnt->flags&FL_DMG_BY_HEAVY_WEAP_ONLY) )//HEAVY weapon damage only
+								)	
+							{//no hit effect (besides regular client-side one)
+								hitEffect = NULL;
+							}
+							else
+							{
+								hitEffect = hit_sparks;
+							}
+						}
+					}
+				}
+			}
+
+			//FIXME: play less if damage is less?
+			if ( !g_saberNoEffects )
+			{ 
+				if ( hitEffect != NULL )
+				{
+					G_PlayEffect( hitEffect, coll.mCollisionPosition, coll.mCollisionNormal );
+				}
+				/*
+				if ( hitEnt && hitEnt->client )
+				{
+					CG_AddGhoul2Mark( PGORE_DECAL02, Q_flrand(3.5, 4.0), coll.mCollisionPosition, hitEntDir[numHitEnts], hitEnt->s.number,
+						hitEnt->client->ps.origin, hitEnt->client->renderInfo.legsYaw, hitEnt->ghoul2 );
+					CG_AddGhoul2Mark( PGORE_DECAL03, Q_flrand(3.5, 4.0), coll.mCollisionPosition, hitEntDir[numHitEnts], hitEnt->s.number,
+						hitEnt->client->ps.origin, hitEnt->client->renderInfo.legsYaw, hitEnt->ghoul2 );
+				}
+				*/
+			}
+
+			//Get the hit location based on surface name
+			if ( (hitLoc[hitEntNum[numHitEnts]] == HL_NONE && trHitLoc[numHitEnts] == HL_NONE)
+				|| (hitDismemberLoc[hitEntNum[numHitEnts]] == HL_NONE && trDismemberLoc[numHitEnts] == HL_NONE)
+				|| (!hitDismember[hitEntNum[numHitEnts]] && !trDismember[numHitEnts]) )
+			{//no hit loc set for this ent this damage cycle yet
+				//FIXME: find closest impact surf *first* (per ent), then call G_GetHitLocFromSurfName?
+				//FIXED: if hit multiple ents in this collision record, these trSurfName, trDismember and trDismemberLoc will get stomped/confused over the multiple ents I hit
+				trSurfName = gi.G2API_GetSurfaceName( &g_entities[coll.mEntityNum].ghoul2[coll.mModelIndex], coll.mSurfaceIndex );
+				trDismember[numHitEnts] = G_GetHitLocFromSurfName( &g_entities[coll.mEntityNum], trSurfName, &trHitLoc[numHitEnts], coll.mCollisionPosition, dmgDir, bladeDir, MOD_SABER, saberType );
+				if ( trDismember[numHitEnts] )
+				{
+					trDismemberLoc[numHitEnts] = trHitLoc[numHitEnts];
+				}
+				/*
+				if ( trDismember[numHitEnts] )
+				{
+					Com_Printf( S_COLOR_RED"Okay to dismember %s on ent %d\n", hitLocName[trDismemberLoc[numHitEnts]], hitEntNum[numHitEnts] );
+				}
+				else
+				{
+					Com_Printf( "Hit (no dismember) %s on ent %d\n", hitLocName[trHitLoc[numHitEnts]], hitEntNum[numHitEnts] );
+				}
+				*/
+			}
+			numHitEnts++;
+		}
+	}
+
+	//now go through all the ents we hit and do the damage
+	for ( i = 0; i < numHitEnts; i++ )
+	{
+		doDmg = dmg;
+		if ( hitEntNum[i] != ENTITYNUM_NONE )
+		{
+			if ( doDmg < 10 )
+			{//base damage is less than 10
+				if ( hitEntNum[i] != 0 )
+				{//not the player
+					hitEnt = &g_entities[hitEntNum[i]];
+					if ( !hitEnt->client || (hitEnt->client->ps.weapon!=WP_SABER&&hitEnt->client->NPC_class!=CLASS_GALAKMECH&&hitEnt->client->playerTeam==enemyTeam) )
+					{//did *not* hit a jedi and did *not* hit the player
+						//make sure the base damage is high against non-jedi, feels better
+						doDmg = 10;
+					}
+				}
+			}
+			if ( !hitEntDmgAdd[i] && !hitEntDmgSub[i] )
+			{//spent entire time in model
+				//NOTE: will we even get a collision then?
+				doDmg *= length;
+			}
+			else if ( hitEntDmgAdd[i] && hitEntDmgSub[i] )
+			{//we did enter and exit
+				doDmg *= hitEntDmgAdd[i] - hitEntDmgSub[i];
+			}
+			else if ( !hitEntDmgAdd[i] )
+			{//we didn't exit, just entered
+				doDmg *= length - hitEntDmgSub[i];
+			}
+			else if ( !hitEntDmgSub[i] )
+			{//we didn't enter, only exited
+				doDmg *= hitEntDmgAdd[i];
+			}
+			if ( doDmg > 0 )
+			{
+				WP_SaberDamageAdd( 1.0, hitEntNum[i], hitEntDir[i], hitEntPoint[i], ceil(doDmg), hitEntStartFrac[i], trHitLoc[i], trDismember[i], trDismemberLoc[i] );
+			}
+		}
+	}
+	return (numHitEnts>0);
+}
+
+void WP_SaberKnockaway( gentity_t *attacker, trace_t *tr )
+{
+	WP_SaberDrop( attacker, &g_entities[attacker->client->ps.saberEntityNum] );
+	G_Sound( &g_entities[attacker->client->ps.saberEntityNum], G_SoundIndex( va( "sound/weapons/saber/saberblock%d.wav", Q_irand(1, 9) ) ) );
+	G_PlayEffect( "saber/saber_block", tr->endpos );
+	saberHitFraction = tr->fraction;
+#ifndef FINAL_BUILD
+	if ( d_saberCombat->integer )
+	{
+		gi.Printf( S_COLOR_MAGENTA"WP_SaberKnockaway: saberHitFraction %4.2f\n", saberHitFraction );
+	}
+#endif
+	VectorCopy( tr->endpos, saberHitLocation );
+	saberHitEntity = tr->entityNum;
+	g_saberFlashTime = level.time-50;
+	VectorCopy( saberHitLocation, g_saberFlashPos );
+
+	//FIXME: make hitEnt play an attack anim or some other special anim when this happens
+	//gentity_t *hitEnt = &g_entities[tr->entityNum];
+	//NPC_SetAnim( hitEnt, SETANIM_BOTH, BOTH_KNOCKSABER, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+}
+
+qboolean G_InCinematicSaberAnim( gentity_t *self )
+{
+	if ( self->NPC 
+		&& self->NPC->behaviorState == BS_CINEMATIC 
+		&& (self->client->ps.torsoAnim == BOTH_CIN_16 ||self->client->ps.torsoAnim == BOTH_CIN_17) )
+	{
+		return qtrue;
+	}
+	return qfalse;
+}
+
+#define SABER_COLLISION_DIST 6//was 2//was 4//was 8//was 16
+extern qboolean InFront( vec3_t spot, vec3_t from, vec3_t fromAngles, float threshHold = 0.0f );
+qboolean WP_SaberDamageForTrace( int ignore, vec3_t start, vec3_t end, float dmg, 
+								vec3_t bladeDir, qboolean noGhoul, int attackStrength,
+								saberType_t saberType, qboolean extrapolate,
+								int saberNum, int bladeNum )
+{
+	trace_t		tr;
+	vec3_t		dir;
+	int			mask = (MASK_SHOT|CONTENTS_LIGHTSABER);
+	gentity_t	*attacker = &g_entities[ignore];
+
+	vec3_t		end2;
+	VectorCopy( end, end2 );
+	if ( extrapolate )
+	{
+		//NOTE: since we can no longer use the predicted point, extrapolate the trace some.
+		//		this may allow saber hits that aren't actually hits, but it doesn't look too bad
+		vec3_t diff;
+		VectorSubtract( end, start, diff );
+		VectorNormalize( diff );
+		VectorMA( end2, SABER_EXTRAPOLATE_DIST, diff, end2 );
+	}
+
+	if ( !noGhoul )
+	{
+		if ( !attacker->s.number 
+			|| (attacker->client 
+				&& (attacker->client->playerTeam==TEAM_PLAYER 
+					|| attacker->client->NPC_class==CLASS_SHADOWTROOPER
+					|| attacker->client->NPC_class==CLASS_ALORA
+					|| (attacker->NPC && (attacker->NPC->aiFlags&NPCAI_BOSS_CHARACTER)) 
+					) 
+				)
+			)//&&attackStrength==FORCE_LEVEL_3)
+		{//player,. player allies, shadowtroopers, tavion and desann use larger traces
+			vec3_t	traceMins = {-2,-2,-2}, traceMaxs = {2,2,2};
+			gi.trace( &tr, start, traceMins, traceMaxs, end2, ignore, mask, G2_COLLIDE, 10 );//G2_SUPERSIZEDBBOX
+		}
+		/*
+		else if ( !attacker->s.number )
+		{
+			vec3_t	traceMins = {-1,-1,-1}, traceMaxs = {1,1,1};
+			gi.trace( &tr, start, traceMins, traceMaxs, end2, ignore, mask, G2_COLLIDE, 10 );//G2_SUPERSIZEDBBOX
+		}
+		*/
+		else
+		{//reborn use smaller traces
+			gi.trace( &tr, start, NULL, NULL, end2, ignore, mask, G2_COLLIDE, 10 );//G2_SUPERSIZEDBBOX
+		}
+	}
+	else
+	{
+		gi.trace( &tr, start, NULL, NULL, end2, ignore, mask, G2_NOCOLLIDE, 10 );
+	}
+
+
+#ifndef FINAL_BUILD
+	if ( d_saberCombat->integer > 1 )
+	{
+		if ( attacker != NULL && attacker->client != NULL )
+		{
+			G_DebugLine(start, end2, FRAMETIME, WPDEBUG_SaberColor( attacker->client->ps.saber[0].blade[0].color ), qtrue);
+		}
+	}
+#endif
+
+	if ( tr.entityNum == ENTITYNUM_NONE )
+	{
+		return qfalse;
+	}
+
+	if ( tr.entityNum == ENTITYNUM_WORLD )
+	{
+		return qtrue;
+	}
+
+	if ( &g_entities[tr.entityNum] )
+	{
+		gentity_t *hitEnt = &g_entities[tr.entityNum];
+		gentity_t *owner = g_entities[tr.entityNum].owner;
+		if ( hitEnt->contents & CONTENTS_LIGHTSABER )
+		{
+			if ( attacker && attacker->client && attacker->client->ps.saberInFlight )
+			{//thrown saber hit something
+				 if ( owner 
+					 && owner->s.number
+					 && owner->client 
+					 && owner->NPC 
+					 && owner->health > 0 )
+				 {
+					 if ( owner->client->NPC_class == CLASS_ALORA )
+					 {//alora takes less damage
+						dmg *= 0.25f;
+					 }
+					 else if ( owner->client->NPC_class == CLASS_TAVION 
+							/*|| (owner->client->NPC_class == CLASS_SHADOWTROOPER && !Q_irand( 0, g_spskill->integer*3 ))
+							|| (Q_irand( -5, owner->NPC->rank ) > RANK_CIVILIAN && !Q_irand( 0, g_spskill->integer*3 ))*/ )
+					{//Tavion can toss a blocked thrown saber aside
+						WP_SaberKnockaway( attacker, &tr );
+						Jedi_PlayDeflectSound( owner );
+						return qfalse;
+					}
+				}
+			}
+			//FIXME: take target FP_SABER_DEFENSE and attacker FP_SABER_OFFENSE into account here somehow?
+			qboolean sabersIntersect = WP_SabersIntersect( attacker, saberNum, bladeNum, owner, qfalse );//qtrue );
+			float sabersDist;
+			if ( attacker && attacker->client && attacker->client->ps.saberInFlight 
+				&& owner && owner->s.number == 0 && (g_saberAutoBlocking->integer||attacker->client->ps.saberBlockingTime>level.time) )//NPC flying saber hit player's saber bounding box
+			{//players have g_saberAutoBlocking, do the more generous check against flying sabers
+				//FIXME: instead of hitting the player's saber bounding box 
+				//and picking an anim afterwards, have him use AI similar 
+				//to the AI the jedi use for picking a saber melee block...?
+				sabersDist = 0;
+			}
+			else
+			{//sabers must actually collide with the attacking saber
+				sabersDist = WP_SabersDistance( attacker, owner );
+				if ( attacker && attacker->client && attacker->client->ps.saberInFlight )
+				{
+					sabersDist /= 2.0f;
+					if ( sabersDist <= 16.0f )
+					{
+						sabersIntersect = qtrue;
+					}
+				}
+#ifndef FINAL_BUILD
+				if ( d_saberCombat->integer > 1 )
+				{
+					gi.Printf( "sabersDist: %4.2f\n", sabersDist );
+				}
+#endif//FINAL_BUILD
+			}
+			if ( sabersCrossed == -1 || sabersCrossed > sabersDist )
+			{
+				sabersCrossed = sabersDist;
+			}
+			float	collisionDist;
+			if ( g_saberRealisticCombat->integer )
+			{
+				collisionDist = SABER_COLLISION_DIST;
+			}
+			else
+			{
+				collisionDist = SABER_COLLISION_DIST+6+g_spskill->integer*4;
+			}
+			{
+			if ( G_InCinematicSaberAnim( owner ) 
+				&& G_InCinematicSaberAnim( attacker ) )
+			{
+				sabersIntersect = qtrue;
+			}
+			}
+			if ( owner && owner->client && (attacker != NULL) 
+				&& (sabersDist > collisionDist )//|| !InFront( attacker->currentOrigin, owner->currentOrigin, owner->client->ps.viewangles, 0.35f )) 
+				&& !sabersIntersect )//was qtrue, but missed too much?
+			{//swing came from behind and/or was not stopped by a lightsaber
+				//re-try the trace without checking for lightsabers
+				gi.trace ( &tr, start, NULL, NULL, end2, ignore, mask&~CONTENTS_LIGHTSABER, G2_NOCOLLIDE, 10 );
+				if ( tr.entityNum == ENTITYNUM_WORLD )
+				{
+ 					return qtrue;
+				}
+				if ( tr.entityNum == ENTITYNUM_NONE || &g_entities[tr.entityNum] == NULL )
+				{//didn't hit the owner
+					/*
+					if ( attacker 
+						&& attacker->client 
+						&& (PM_SaberInAttack( attacker->client->ps.saberMove ) || PM_SaberInStart( attacker->client->ps.saberMove ))
+						&& DistanceSquared( tr.endpos, owner->currentOrigin ) < 10000 )
+					{
+						if ( owner->NPC 
+							&& !owner->client->ps.saberInFlight 
+							&& owner->client->ps.saberBlocked != BLOCKED_PARRY_BROKEN 
+							&& !Jedi_SaberBusy( owner ) )
+						{//owner parried, just make sure they're saber is in the right spot - only does this if they're not already doing something with saber
+							if ( g_spskill->integer && (g_spskill->integer > 1 || Q_irand( 0, 1 )))
+							{//if on easy, they don't cheat like this, if on medium, they cheat 50% of the time, if on hard, they always cheat
+								//FIXME: also take into account the owner's FP_DEFENSE?
+								if ( Q_irand( 0, owner->NPC->rank ) >= RANK_CIVILIAN )
+								{//lower-rank Jedi aren't as good blockers
+									vec3_t attDir;
+									VectorSubtract( end2, start, attDir );
+									VectorNormalize( attDir );
+									Jedi_SaberBlockGo( owner, owner->NPC->last_ucmd, start, attDir, NULL );
+								}
+							}
+						}
+					}
+					*/
+  					return qfalse;	// Exit, but we didn't hit the wall.
+				}
+#ifndef FINAL_BUILD
+				if ( d_saberCombat->integer > 1 )
+				{
+					if ( !attacker->s.number )
+					{
+						gi.Printf( S_COLOR_MAGENTA"%d saber hit owner through saber %4.2f, dist = %4.2f\n", level.time, saberHitFraction, sabersDist );
+					}
+				}
+#endif//FINAL_BUILD
+				hitEnt = &g_entities[tr.entityNum];
+				owner = g_entities[tr.entityNum].owner;
+			}
+			else 
+			{//hit a lightsaber
+				if ( (tr.fraction < saberHitFraction || tr.startsolid)
+					&& sabersDist < (8.0f+g_spskill->value)*4.0f// 50.0f//16.0f 
+					&& (sabersIntersect || sabersDist < (4.0f+g_spskill->value)*2.0f) )//32.0f) )
+				{	// This saber hit closer than the last one.
+					if ( (tr.allsolid || tr.startsolid) && owner && owner->client )
+					{//tr.fraction will be 0, unreliable... so calculate actual
+						float dist = Distance( start, end2 );
+						if ( dist )
+						{
+							float hitFrac = WP_SabersDistance( attacker, owner )/dist;
+							if ( hitFrac > 1.0f )
+							{//umm... minimum distance between sabers was longer than trace...?
+								hitFrac = 1.0f;
+							}
+							if ( hitFrac < saberHitFraction )
+							{
+								saberHitFraction = hitFrac;
+							}
+						}
+						else
+						{
+							saberHitFraction = 0.0f;
+						}
+#ifndef FINAL_BUILD
+						if ( d_saberCombat->integer > 1 )
+						{
+							if ( !attacker->s.number )
+							{
+								gi.Printf( S_COLOR_GREEN"%d saber hit saber dist %4.2f allsolid %4.2f\n", level.time, sabersDist, saberHitFraction );
+							}
+						}
+#endif//FINAL_BUILD
+					}
+					else
+					{
+#ifndef FINAL_BUILD
+						if ( d_saberCombat->integer > 1 )
+						{
+							if ( !attacker->s.number )
+							{
+								gi.Printf( S_COLOR_BLUE"%d saber hit saber dist %4.2f, frac %4.2f\n", level.time, sabersDist, saberHitFraction );
+							}
+							saberHitFraction = tr.fraction;
+						}
+#endif//FINAL_BUILD
+					}
+#ifndef FINAL_BUILD
+					if ( d_saberCombat->integer )
+					{
+						gi.Printf( S_COLOR_MAGENTA"hit saber: saberHitFraction %4.2f, allsolid %d, startsolid %d\n", saberHitFraction, tr.allsolid, tr.startsolid );
+					}
+#endif//FINAL_BUILD
+					VectorCopy(tr.endpos, saberHitLocation);
+					saberHitEntity = tr.entityNum;
+				}
+				/*
+				if ( owner 
+					&& owner->client 
+					&& attacker 
+					&& attacker->client 
+					&& (PM_SaberInAttack( attacker->client->ps.saberMove ) || PM_SaberInStart( attacker->client->ps.saberMove ))
+					&& DistanceSquared( tr.endpos, owner->currentOrigin ) < 10000 )
+				{
+					if ( owner->NPC 
+						&& !owner->client->ps.saberInFlight 
+						&& owner->client->ps.saberBlocked != BLOCKED_PARRY_BROKEN 
+						&& !Jedi_SaberBusy( owner ) )
+					{//owner parried, just make sure they're saber is in the right spot - only does this if they're not already doing something with saber
+						if ( g_spskill->integer && (g_spskill->integer > 1 || Q_irand( 0, 1 )))
+						{//if on easy, they don't cheat like this, if on medium, they cheat 50% of the time, if on hard, they always cheat
+							//FIXME: also take into account the owner's FP_DEFENSE?
+							if ( Q_irand( 0, owner->NPC->rank ) >= RANK_CIVILIAN )
+							{//lower-rank Jedi aren't as good blockers
+								vec3_t attDir;
+								VectorSubtract( end2, start, attDir );
+								VectorNormalize( attDir );
+								Jedi_SaberBlockGo( owner, owner->NPC->last_ucmd, start, attDir, NULL );
+							}
+						}
+					}
+				}
+				*/
+				//FIXME: check to see if we broke the saber
+				//		go through the impacted surfaces and call WP_BreakSaber
+				//		PROBLEM: saberEnt doesn't actually have a saber g2 model 
+				//		and/or isn't in same location as saber model attached
+				//		to the client.  We'd have to fake it somehow...
+  				return qfalse;	// Exit, but we didn't hit the wall.
+			}
+		}
+		else
+		{
+#ifndef FINAL_BUILD
+			if ( d_saberCombat->integer > 1 )
+			{
+				if ( !attacker->s.number )
+				{
+					gi.Printf( S_COLOR_RED"%d saber hit owner directly %4.2f\n", level.time, saberHitFraction );
+				}
+			}
+#endif//FINAL_BUILD
+		}
+
+		if ( attacker && attacker->client && attacker->client->ps.saberInFlight )
+		{//thrown saber hit something
+			if ( ( hitEnt && hitEnt->client && hitEnt->health > 0 && ( hitEnt->client->NPC_class == CLASS_DESANN || !Q_stricmp("Yoda",hitEnt->NPC_type) || hitEnt->client->NPC_class == CLASS_LUKE || hitEnt->client->NPC_class == CLASS_BOBAFETT || (hitEnt->client->ps.powerups[PW_GALAK_SHIELD] > 0) ) ) ||
+				 ( owner && owner->client && owner->health > 0 && ( owner->client->NPC_class == CLASS_DESANN || !Q_stricmp("Yoda",owner->NPC_type) || owner->client->NPC_class == CLASS_LUKE || hitEnt->client->NPC_class == CLASS_BOBAFETT || (owner->client->ps.powerups[PW_GALAK_SHIELD] > 0) ) ) )
+			{//Luke and Desann slap thrown sabers aside
+				//FIXME: control the direction of the thrown saber... if hit Galak's shield, bounce directly away from his origin?
+				WP_SaberKnockaway( attacker, &tr );
+				if ( hitEnt->client )
+				{
+					Jedi_PlayDeflectSound( hitEnt );
+				}
+				else
+				{
+					Jedi_PlayDeflectSound( owner );
+				}
+  				return qfalse;	// Exit, but we didn't hit the wall.
+			}
+		}
+
+		if ( hitEnt->takedamage )
+		{
+			//no team damage: if ( !hitEnt->client || attacker == NULL || !attacker->client || (hitEnt->client->playerTeam != attacker->client->playerTeam) )
+			{
+				//multiply the damage by the total distance of the swipe
+				VectorSubtract( end2, start, dir );
+				float len = VectorNormalize( dir );//VectorLength( dir );
+				if ( noGhoul || !hitEnt->ghoul2.size() )
+				{//we weren't doing a ghoul trace
+					const char	*hitEffect = NULL;
+					if ( dmg >= 1.0 && hitEnt->bmodel )
+					{
+						dmg = 1.0;
+					}
+					if ( len > 1 )
+					{
+						dmg *= len;
+					}
+#ifndef FINAL_BUILD
+					if ( d_saberCombat->integer > 1 )
+					{
+						if ( !(hitEnt->contents & CONTENTS_LIGHTSABER) )
+						{
+							gi.Printf( S_COLOR_GREEN"Hit ent, but no ghoul collisions\n" );
+						}
+					}
+#endif
+					float	trFrac, dmgFrac;
+					if ( tr.allsolid )
+					{//totally inside them
+						trFrac = 1.0;
+						dmgFrac = 0.0;
+					}
+					else if ( tr.startsolid )
+					{//started inside them
+						//we don't know how much was inside, we know it's less than all, so use half?
+						trFrac = 0.5;
+						dmgFrac = 0.0;
+					}
+					else
+					{//started outside them and hit them
+						//yeah. this doesn't account for coming out the other wide, but we can worry about that later (use ghoul2)
+						trFrac = (1.0f - tr.fraction);
+						dmgFrac = tr.fraction;
+					}
+					WP_SaberDamageAdd( trFrac, tr.entityNum, dir, tr.endpos, dmg, dmgFrac, HL_NONE, qfalse, HL_NONE );
+					if ( !tr.allsolid && !tr.startsolid )
+					{
+						VectorScale( dir, -1, dir );
+					}
+					if ( hitEnt != NULL )
+					{
+						if ( hitEnt->client )
+						{
+							//don't do blood sparks on non-living things
+							class_t npc_class = hitEnt->client->NPC_class;
+							if ( npc_class == CLASS_SEEKER || npc_class == CLASS_PROBE || npc_class == CLASS_MOUSE ||
+								 npc_class == CLASS_GONK || npc_class == CLASS_R2D2 || npc_class == CLASS_R5D2 || npc_class == CLASS_REMOTE ||
+								 npc_class == CLASS_PROTOCOL || npc_class == CLASS_MARK1 || npc_class == CLASS_MARK2 ||
+							     npc_class == CLASS_INTERROGATOR || npc_class == CLASS_ATST || npc_class == CLASS_SENTRY )  
+							{
+								hitEffect = hit_sparks;
+							}
+						}
+						else
+						{
+							if ( dmg )
+							{//only do these effects if actually trying to damage the thing...
+								if ( (hitEnt->svFlags&SVF_BBRUSH)//a breakable brush
+									&& ( (hitEnt->spawnflags&1)//INVINCIBLE
+										||(hitEnt->flags&FL_DMG_BY_HEAVY_WEAP_ONLY)//HEAVY weapon damage only
+										||(hitEnt->NPC_targetname&&attacker&&attacker->targetname&&Q_stricmp(attacker->targetname,hitEnt->NPC_targetname)) ) )//only breakable by an entity who is not the attacker
+								{//no hit effect (besides regular client-side one)
+								}
+								else
+								{
+									hitEffect = hit_sparks;
+								}
+							}
+						}
+					}
+
+					if ( !g_saberNoEffects && hitEffect != NULL )
+					{
+						G_PlayEffect( hitEffect, tr.endpos, dir );//"saber_cut"
+					}
+				}
+				else
+				{//we were doing a ghoul trace
+					if ( !WP_SaberDamageEffects( &tr, start, len, dmg, dir, bladeDir, attacker->client->enemyTeam, saberType ) )
+					{//didn't hit a ghoul ent
+						/*
+						if ( && hitEnt->ghoul2.size() )
+						{//it was a ghoul2 model so we should have hit it
+							return qfalse;
+						}
+						*/
+					}
+				}
+			}
+		}
+	}
+
+	return qfalse;
+}
+
+#define LOCK_IDEAL_DIST_TOP 32.0f
+#define LOCK_IDEAL_DIST_CIRCLE 48.0f
+#define LOCK_IDEAL_DIST_JKA 46.0f//all of the new saberlocks are 46.08 from each other because Richard Lico is da MAN
+extern void PM_SetAnimFrame( gentity_t *gent, int frame, qboolean torso, qboolean legs );
+extern qboolean ValidAnimFileIndex ( int index );
+int G_SaberLockAnim( int attackerSaberStyle, int defenderSaberStyle, int topOrSide, int lockOrBreakOrSuperBreak, int winOrLose )
+{
+	int baseAnim = -1;
+	if ( lockOrBreakOrSuperBreak == SABERLOCK_LOCK )
+	{//special case: if we're using the same style and locking
+		if ( attackerSaberStyle == defenderSaberStyle 
+			|| (attackerSaberStyle>=SS_FAST&&attackerSaberStyle<=SS_TAVION&&defenderSaberStyle>=SS_FAST&&defenderSaberStyle<=SS_TAVION) )
+		{//using same style
+			if ( winOrLose == SABERLOCK_LOSE )
+			{//you want the defender's stance...
+				switch ( defenderSaberStyle )
+				{
+				case SS_DUAL:
+					if ( topOrSide == SABERLOCK_TOP )
+					{
+						baseAnim = BOTH_LK_DL_DL_T_L_2;
+					}
+					else
+					{
+						baseAnim = BOTH_LK_DL_DL_S_L_2;
+					}
+					break;
+				case SS_STAFF:
+					if ( topOrSide == SABERLOCK_TOP )
+					{
+						baseAnim = BOTH_LK_ST_ST_T_L_2;
+					}
+					else
+					{
+						baseAnim = BOTH_LK_ST_ST_S_L_2;
+					}
+					break;
+				default:
+					if ( topOrSide == SABERLOCK_TOP )
+					{
+						baseAnim = BOTH_LK_S_S_T_L_2;
+					}
+					else
+					{
+						baseAnim = BOTH_LK_S_S_S_L_2;
+					}
+					break;
+				}
+			}
+		}
+	}
+	if ( baseAnim == -1 )
+	{
+		switch ( attackerSaberStyle )
+		{
+		case SS_DUAL:
+			switch ( defenderSaberStyle )
+			{
+				case SS_DUAL:
+					baseAnim = BOTH_LK_DL_DL_S_B_1_L;
+					break;
+				case SS_STAFF:
+					baseAnim = BOTH_LK_DL_ST_S_B_1_L;
+					break;
+				default://single
+					baseAnim = BOTH_LK_DL_S_S_B_1_L;
+					break;
+			}
+			break;
+		case SS_STAFF:
+			switch ( defenderSaberStyle )
+			{
+				case SS_DUAL:
+					baseAnim = BOTH_LK_ST_DL_S_B_1_L;
+					break;
+				case SS_STAFF:
+					baseAnim = BOTH_LK_ST_ST_S_B_1_L;
+					break;
+				default://single
+					baseAnim = BOTH_LK_ST_S_S_B_1_L;
+					break;
+			}
+			break;
+		default://single
+			switch ( defenderSaberStyle )
+			{
+				case SS_DUAL:
+					baseAnim = BOTH_LK_S_DL_S_B_1_L;
+					break;
+				case SS_STAFF:
+					baseAnim = BOTH_LK_S_ST_S_B_1_L;
+					break;
+				default://single
+					baseAnim = BOTH_LK_S_S_S_B_1_L;
+					break;
+			}
+			break;
+		}
+		//side lock or top lock?
+		if ( topOrSide == SABERLOCK_TOP )
+		{
+			baseAnim += 5;
+		}
+		//lock, break or superbreak?
+		if ( lockOrBreakOrSuperBreak == SABERLOCK_LOCK )
+		{
+			baseAnim += 2;
+		}
+		else 
+		{//a break or superbreak
+			if ( lockOrBreakOrSuperBreak == SABERLOCK_SUPERBREAK )
+			{
+				baseAnim += 3;
+			}
+			//winner or loser?
+			if ( winOrLose == SABERLOCK_WIN )
+			{
+				baseAnim += 1;
+			}
+		}
+	}
+	return baseAnim;
+}
+
+qboolean G_CheckIncrementLockAnim( int anim, int winOrLose )
+{
+	qboolean increment = qfalse;//???
+	//RULE: if you are the first style in the lock anim, you advance from LOSING position to WINNING position
+	//		if you are the second style in the lock anim, you advance from WINNING position to LOSING position
+	switch ( anim )
+	{
+	//increment to win:
+	case BOTH_LK_DL_DL_S_L_1:	//lock if I'm using dual vs. dual and I initiated
+	case BOTH_LK_DL_DL_S_L_2:	//lock if I'm using dual vs. dual and other initiated
+	case BOTH_LK_DL_DL_T_L_1:	//lock if I'm using dual vs. dual and I initiated
+	case BOTH_LK_DL_DL_T_L_2:	//lock if I'm using dual vs. dual and other initiated
+	case BOTH_LK_DL_S_S_L_1:		//lock if I'm using dual vs. a single
+	case BOTH_LK_DL_S_T_L_1:		//lock if I'm using dual vs. a single
+	case BOTH_LK_DL_ST_S_L_1:	//lock if I'm using dual vs. a staff
+	case BOTH_LK_DL_ST_T_L_1:	//lock if I'm using dual vs. a staff
+	case BOTH_LK_S_S_S_L_1:		//lock if I'm using single vs. a single and I initiated
+	case BOTH_LK_S_S_T_L_2:		//lock if I'm using single vs. a single and other initiated
+	case BOTH_LK_ST_S_S_L_1:		//lock if I'm using staff vs. a single
+	case BOTH_LK_ST_S_T_L_1:		//lock if I'm using staff vs. a single
+	case BOTH_LK_ST_ST_T_L_1:	//lock if I'm using staff vs. a staff and I initiated
+	case BOTH_LK_ST_ST_T_L_2:	//lock if I'm using staff vs. a staff and other initiated
+		if ( winOrLose == SABERLOCK_WIN )
+		{
+			increment = qtrue;
+		}
+		else
+		{
+			increment = qfalse;
+		}
+		break;
+
+	//decrement to win:
+	case BOTH_LK_S_DL_S_L_1:		//lock if I'm using single vs. a dual
+	case BOTH_LK_S_DL_T_L_1:		//lock if I'm using single vs. a dual
+	case BOTH_LK_S_S_S_L_2:		//lock if I'm using single vs. a single and other intitiated
+	case BOTH_LK_S_S_T_L_1:		//lock if I'm using single vs. a single and I initiated
+	case BOTH_LK_S_ST_S_L_1:		//lock if I'm using single vs. a staff
+	case BOTH_LK_S_ST_T_L_1:		//lock if I'm using single vs. a staff
+	case BOTH_LK_ST_DL_S_L_1:	//lock if I'm using staff vs. dual
+	case BOTH_LK_ST_DL_T_L_1:	//lock if I'm using staff vs. dual
+	case BOTH_LK_ST_ST_S_L_1:	//lock if I'm using staff vs. a staff and I initiated
+	case BOTH_LK_ST_ST_S_L_2:	//lock if I'm using staff vs. a staff and other initiated
+		if ( winOrLose == SABERLOCK_WIN )
+		{
+			increment = qfalse;
+		}
+		else
+		{
+			increment = qtrue;
+		}
+		break;
+	default:
+#ifndef FINAL_BUILD
+		Com_Printf( S_COLOR_RED"ERROR: unknown Saber Lock Anim: %s!!!\n", animTable[anim].name );
+#endif
+		break;
+	}
+	return increment;
+}
+
+qboolean WP_SabersCheckLock2( gentity_t *attacker, gentity_t *defender, sabersLockMode_t lockMode )
+{
+	animation_t *anim;
+	int		attAnim, defAnim, advance = 0;
+	float	attStart = 0.5f, defStart = 0.5f;
+	float	idealDist = 48.0f;
+	//FIXME: this distances need to be modified by the lengths of the sabers involved...
+	//MATCH ANIMS
+	if ( lockMode == LOCK_KYLE_GRAB1 
+		|| lockMode == LOCK_KYLE_GRAB2
+		|| lockMode == LOCK_KYLE_GRAB3 )
+	{
+		float	numSpins = 1.0f;
+		idealDist = 46.0f;//42.0f;
+		attStart = defStart = 0.0f;
+
+		switch ( lockMode )
+		{
+		default:
+		case LOCK_KYLE_GRAB1:
+			attAnim = BOTH_KYLE_PA_1;
+			defAnim = BOTH_PLAYER_PA_1;
+			numSpins = 2.0f;
+			break;
+		case LOCK_KYLE_GRAB2:
+			attAnim = BOTH_KYLE_PA_3;
+			defAnim = BOTH_PLAYER_PA_3;
+			numSpins = 1.0f;
+			break;
+		case LOCK_KYLE_GRAB3:
+			attAnim = BOTH_KYLE_PA_2;
+			defAnim = BOTH_PLAYER_PA_2;
+			defender->forcePushTime = level.time + PM_AnimLength( defender->client->clientInfo.animFileIndex, BOTH_PLAYER_PA_2 );
+			numSpins = 3.0f;
+			break;
+		}
+		attacker->client->ps.SaberDeactivate();
+		defender->client->ps.SaberDeactivate();
+		if ( d_slowmodeath->integer > 3
+			&& ( defender->s.number < MAX_CLIENTS
+				|| attacker->s.number < MAX_CLIENTS ) )
+		{
+			if( ValidAnimFileIndex( attacker->client->clientInfo.animFileIndex ) )
+			{
+				int effectTime = PM_AnimLength( attacker->client->clientInfo.animFileIndex, (animNumber_t)attAnim );
+				int spinTime = floor((float)effectTime/numSpins);
+				int meFlags = (MEF_MULTI_SPIN);//MEF_NO_TIMESCALE|MEF_NO_VERTBOB|
+				if ( Q_irand( 0, 1 ) )
+				{
+					meFlags |= MEF_REVERSE_SPIN;
+				}
+				G_StartMatrixEffect( attacker, meFlags, effectTime, 0.75f, spinTime );
+			}
+		}
+	}
+	else if ( lockMode == LOCK_FORCE_DRAIN )
+	{
+		idealDist = 46.0f;//42.0f;
+		attStart = defStart = 0.0f;
+
+		attAnim = BOTH_FORCE_DRAIN_GRAB_START;
+		defAnim = BOTH_FORCE_DRAIN_GRABBED;
+		attacker->client->ps.SaberDeactivate();
+		defender->client->ps.SaberDeactivate();
+	}
+	else
+	{
+		if ( lockMode == LOCK_RANDOM )
+		{
+			lockMode = (sabersLockMode_t)Q_irand( (int)LOCK_FIRST, (int)(LOCK_RANDOM)-1 );
+		}
+		//FIXME: attStart% and idealDist will change per saber lock anim pairing... do we need a big table like in bg_panimate.cpp?
+		if ( attacker->client->ps.saberAnimLevel >= SS_FAST
+			&& attacker->client->ps.saberAnimLevel <= SS_TAVION
+			&& defender->client->ps.saberAnimLevel >= SS_FAST
+			&& defender->client->ps.saberAnimLevel <= SS_TAVION )
+		{//2 single sabers?  Just do it the old way...
+			switch ( lockMode )
+			{
+			case LOCK_TOP:
+				attAnim = BOTH_BF2LOCK;// - starts in middle
+				defAnim = BOTH_BF1LOCK;// - starts in middle
+				attStart = defStart = 0.5f;
+				idealDist = LOCK_IDEAL_DIST_TOP;
+				break;
+			case LOCK_DIAG_TR:
+				attAnim = BOTH_CCWCIRCLELOCK; //- starts in middle
+				defAnim = BOTH_CWCIRCLELOCK;// - starts in middle
+				attStart = defStart = 0.5f;
+				idealDist = LOCK_IDEAL_DIST_CIRCLE;
+				break;
+			case LOCK_DIAG_TL:
+				attAnim = BOTH_CWCIRCLELOCK;// - starts in middle
+				defAnim = BOTH_CCWCIRCLELOCK;// - starts in middle
+				attStart = defStart = 0.5f;
+				idealDist = LOCK_IDEAL_DIST_CIRCLE;
+				break;
+			case LOCK_DIAG_BR:
+				attAnim = BOTH_CWCIRCLELOCK;// - starts on left, to right
+				defAnim = BOTH_CCWCIRCLELOCK;// - starts on right, to left
+				attStart = defStart = 0.85f;//move to end of anim
+				idealDist = LOCK_IDEAL_DIST_CIRCLE;
+				break;
+			case LOCK_DIAG_BL:
+				attAnim = BOTH_CCWCIRCLELOCK;// - starts on right, to left
+				defAnim = BOTH_CWCIRCLELOCK;// - starts on left, to right
+				attStart = defStart = 0.85f;//move to end of anim
+				idealDist = LOCK_IDEAL_DIST_CIRCLE;
+				break;
+			case LOCK_R:
+				attAnim = BOTH_CWCIRCLELOCK;// - starts on left, to right
+				defAnim = BOTH_CCWCIRCLELOCK;// - starts on right, to left
+				attStart = defStart = 0.75f;//move to end of anim
+				idealDist = LOCK_IDEAL_DIST_CIRCLE;
+				break;
+			case LOCK_L:
+				attAnim = BOTH_CCWCIRCLELOCK;// - starts on right, to left
+				defAnim = BOTH_CWCIRCLELOCK;// - starts on left, to right
+				attStart = defStart = 0.75f;//move to end of anim
+				idealDist = LOCK_IDEAL_DIST_CIRCLE;
+				break;
+			default:
+				return qfalse;
+				break;
+			}
+		}
+		else
+		{//use the new system
+			idealDist = LOCK_IDEAL_DIST_JKA;//all of the new saberlocks are 46.08 from each other because Richard Lico is da MAN
+			if ( lockMode == LOCK_TOP )
+			{//top lock
+				attAnim = G_SaberLockAnim( attacker->client->ps.saberAnimLevel, defender->client->ps.saberAnimLevel, SABERLOCK_TOP, SABERLOCK_LOCK, SABERLOCK_WIN );
+				defAnim = G_SaberLockAnim( defender->client->ps.saberAnimLevel, attacker->client->ps.saberAnimLevel, SABERLOCK_TOP, SABERLOCK_LOCK, SABERLOCK_LOSE );
+				attStart = defStart = 0.5f;
+			}
+			else
+			{//side lock
+				switch ( lockMode )
+				{
+				case LOCK_DIAG_TR:
+					attAnim = G_SaberLockAnim( attacker->client->ps.saberAnimLevel, defender->client->ps.saberAnimLevel, SABERLOCK_SIDE, SABERLOCK_LOCK, SABERLOCK_WIN );
+					defAnim = G_SaberLockAnim( defender->client->ps.saberAnimLevel, attacker->client->ps.saberAnimLevel, SABERLOCK_SIDE, SABERLOCK_LOCK, SABERLOCK_LOSE );
+					attStart = defStart = 0.5f;
+					break;
+				case LOCK_DIAG_TL:
+					attAnim = G_SaberLockAnim( attacker->client->ps.saberAnimLevel, defender->client->ps.saberAnimLevel, SABERLOCK_SIDE, SABERLOCK_LOCK, SABERLOCK_LOSE );
+					defAnim = G_SaberLockAnim( defender->client->ps.saberAnimLevel, attacker->client->ps.saberAnimLevel, SABERLOCK_SIDE, SABERLOCK_LOCK, SABERLOCK_WIN );
+					attStart = defStart = 0.5f;
+					break;
+				case LOCK_DIAG_BR:
+					attAnim = G_SaberLockAnim( attacker->client->ps.saberAnimLevel, defender->client->ps.saberAnimLevel, SABERLOCK_SIDE, SABERLOCK_LOCK, SABERLOCK_WIN );
+					defAnim = G_SaberLockAnim( defender->client->ps.saberAnimLevel, attacker->client->ps.saberAnimLevel, SABERLOCK_SIDE, SABERLOCK_LOCK, SABERLOCK_LOSE );
+					if ( G_CheckIncrementLockAnim( attAnim, SABERLOCK_WIN ) )
+					{
+						attStart = 0.85f;//move to end of anim
+					}
+					else
+					{
+						attStart = 0.15f;//start at beginning of anim
+					}
+					if ( G_CheckIncrementLockAnim( defAnim, SABERLOCK_LOSE ) )
+					{
+						defStart = 0.85f;//start at end of anim
+					}
+					else
+					{
+						defStart = 0.15f;//start at beginning of anim
+					}
+					break;
+				case LOCK_DIAG_BL:
+					attAnim = G_SaberLockAnim( attacker->client->ps.saberAnimLevel, defender->client->ps.saberAnimLevel, SABERLOCK_SIDE, SABERLOCK_LOCK, SABERLOCK_LOSE );
+					defAnim = G_SaberLockAnim( defender->client->ps.saberAnimLevel, attacker->client->ps.saberAnimLevel, SABERLOCK_SIDE, SABERLOCK_LOCK, SABERLOCK_WIN );
+					if ( G_CheckIncrementLockAnim( attAnim, SABERLOCK_WIN ) )
+					{
+						attStart = 0.85f;//move to end of anim
+					}
+					else
+					{
+						attStart = 0.15f;//start at beginning of anim
+					}
+					if ( G_CheckIncrementLockAnim( defAnim, SABERLOCK_LOSE ) )
+					{
+						defStart = 0.85f;//start at end of anim
+					}
+					else
+					{
+						defStart = 0.15f;//start at beginning of anim
+					}
+					break;
+				case LOCK_R:
+					attAnim = G_SaberLockAnim( attacker->client->ps.saberAnimLevel, defender->client->ps.saberAnimLevel, SABERLOCK_SIDE, SABERLOCK_LOCK, SABERLOCK_LOSE );
+					defAnim = G_SaberLockAnim( defender->client->ps.saberAnimLevel, attacker->client->ps.saberAnimLevel, SABERLOCK_SIDE, SABERLOCK_LOCK, SABERLOCK_WIN );
+					if ( G_CheckIncrementLockAnim( attAnim, SABERLOCK_WIN ) )
+					{
+						attStart = 0.75f;//move to end of anim
+					}
+					else
+					{
+						attStart = 0.25f;//start at beginning of anim
+					}
+					if ( G_CheckIncrementLockAnim( defAnim, SABERLOCK_LOSE ) )
+					{
+						defStart = 0.75f;//start at end of anim
+					}
+					else
+					{
+						defStart = 0.25f;//start at beginning of anim
+					}
+					break;
+				case LOCK_L:
+					attAnim = G_SaberLockAnim( attacker->client->ps.saberAnimLevel, defender->client->ps.saberAnimLevel, SABERLOCK_SIDE, SABERLOCK_LOCK, SABERLOCK_WIN );
+					defAnim = G_SaberLockAnim( defender->client->ps.saberAnimLevel, attacker->client->ps.saberAnimLevel, SABERLOCK_SIDE, SABERLOCK_LOCK, SABERLOCK_LOSE );
+					//attacker starts with advantage
+					if ( G_CheckIncrementLockAnim( attAnim, SABERLOCK_WIN ) )
+					{
+						attStart = 0.75f;//move to end of anim
+					}
+					else
+					{
+						attStart = 0.25f;//start at beginning of anim
+					}
+					if ( G_CheckIncrementLockAnim( defAnim, SABERLOCK_LOSE ) )
+					{
+						defStart = 0.75f;//start at end of anim
+					}
+					else
+					{
+						defStart = 0.25f;//start at beginning of anim
+					}
+					break;
+				default:
+					return qfalse;
+					break;
+				}
+			}
+		}
+	}
+	//set the proper anims
+	NPC_SetAnim( attacker, SETANIM_BOTH, attAnim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+	NPC_SetAnim( defender, SETANIM_BOTH, defAnim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+	//don't let them store a kick for the whole saberlock....
+	attacker->client->ps.saberMoveNext = defender->client->ps.saberMoveNext = LS_NONE;
+	//
+	if ( attStart > 0.0f )
+	{
+		if( ValidAnimFileIndex( attacker->client->clientInfo.animFileIndex ) )
+		{
+			anim = &level.knownAnimFileSets[attacker->client->clientInfo.animFileIndex].animations[attAnim];
+			advance = floor( anim->numFrames*attStart );
+			PM_SetAnimFrame( attacker, anim->firstFrame + advance, qtrue, qtrue );
+#ifndef FINAL_BUILD
+			if ( d_saberCombat->integer )
+			{
+				Com_Printf( "%s starting saber lock, anim = %s, %d frames to go!\n", attacker->NPC_type, animTable[attAnim].name, anim->numFrames-advance );
+			}
+#endif
+		}
+	}
+	if ( defStart > 0.0f )
+	{
+		if( ValidAnimFileIndex( defender->client->clientInfo.animFileIndex ) )
+		{
+			anim = &level.knownAnimFileSets[defender->client->clientInfo.animFileIndex].animations[defAnim];
+			advance = ceil( anim->numFrames*defStart );
+			PM_SetAnimFrame( defender, anim->firstFrame + advance, qtrue, qtrue );//was anim->firstFrame + anim->numFrames - advance, but that's wrong since they are matched anims
+#ifndef FINAL_BUILD
+			if ( d_saberCombat->integer )
+			{
+				Com_Printf( "%s starting saber lock, anim = %s, %d frames to go!\n", defender->NPC_type, animTable[defAnim].name, advance );
+			}
+#endif
+		}
+	}
+	VectorClear( attacker->client->ps.velocity );
+	VectorClear( attacker->client->ps.moveDir );
+	VectorClear( defender->client->ps.velocity );
+	VectorClear( defender->client->ps.moveDir );
+	if ( lockMode == LOCK_KYLE_GRAB1
+		|| lockMode == LOCK_KYLE_GRAB2 
+		|| lockMode == LOCK_KYLE_GRAB3
+		|| lockMode == LOCK_FORCE_DRAIN )
+	{//not a real lock, just freeze them both in place
+		//can't move or attack
+		attacker->client->ps.pm_time = attacker->client->ps.weaponTime = attacker->client->ps.legsAnimTimer;
+		attacker->client->ps.pm_flags |= PMF_TIME_KNOCKBACK;
+		attacker->painDebounceTime = level.time + attacker->client->ps.pm_time;
+		if ( lockMode != LOCK_FORCE_DRAIN )
+		{
+			defender->client->ps.torsoAnimTimer += 200;
+			defender->client->ps.legsAnimTimer += 200;
+		}
+		defender->client->ps.pm_time = defender->client->ps.weaponTime = defender->client->ps.legsAnimTimer;
+		defender->client->ps.pm_flags |= PMF_TIME_KNOCKBACK;
+		if ( lockMode != LOCK_FORCE_DRAIN )
+		{
+			attacker->aimDebounceTime = level.time + attacker->client->ps.pm_time;
+		}
+	}
+	else
+	{
+		attacker->client->ps.saberLockTime = defender->client->ps.saberLockTime = level.time + SABER_LOCK_TIME;
+		attacker->client->ps.legsAnimTimer = attacker->client->ps.torsoAnimTimer = defender->client->ps.legsAnimTimer = defender->client->ps.torsoAnimTimer = SABER_LOCK_TIME;
+		//attacker->client->ps.weaponTime = defender->client->ps.weaponTime = SABER_LOCK_TIME;
+		attacker->client->ps.saberLockEnemy = defender->s.number;
+		defender->client->ps.saberLockEnemy = attacker->s.number;
+	}
+
+	//MATCH ANGLES
+	if ( lockMode == LOCK_KYLE_GRAB1
+		|| lockMode == LOCK_KYLE_GRAB2
+		|| lockMode == LOCK_KYLE_GRAB3 )
+	{//not a real lock, just set pitch to 0
+		attacker->client->ps.viewangles[PITCH] = defender->client->ps.viewangles[PITCH] = 0;
+	}
+	else
+	{
+		//FIXME: if zDiff in elevation, make lower look up and upper look down and move them closer?
+		float defPitchAdd = 0, zDiff = ((attacker->currentOrigin[2]+attacker->client->standheight)-(defender->currentOrigin[2]+defender->client->standheight));
+		if ( zDiff > 24 )
+		{
+			defPitchAdd = -30;
+		}
+		else if ( zDiff < -24 )
+		{
+			defPitchAdd = 30;
+		}
+		else
+		{
+			defPitchAdd = zDiff/24.0f*-30.0f;
+		}
+		if ( attacker->NPC && defender->NPC )
+		{//if 2 NPCs, just set pitch to 0
+			attacker->client->ps.viewangles[PITCH] = -defPitchAdd;
+			defender->client->ps.viewangles[PITCH] = defPitchAdd;
+		}
+		else
+		{//if a player is involved, clamp player's pitch and match NPC's to player
+			if ( !attacker->s.number )
+			{
+				//clamp to defPitch
+				if ( attacker->client->ps.viewangles[PITCH] > -defPitchAdd + 10 )
+				{
+					attacker->client->ps.viewangles[PITCH] = -defPitchAdd + 10;
+				}
+				else if ( attacker->client->ps.viewangles[PITCH] < -defPitchAdd-10 )
+				{
+					attacker->client->ps.viewangles[PITCH] = -defPitchAdd-10;
+				}
+				//clamp to sane numbers
+				if ( attacker->client->ps.viewangles[PITCH] > 50 )
+				{
+					attacker->client->ps.viewangles[PITCH] = 50;
+				}
+				else if ( attacker->client->ps.viewangles[PITCH] < -50 )
+				{
+					attacker->client->ps.viewangles[PITCH] = -50;
+				}
+				defender->client->ps.viewangles[PITCH] = attacker->client->ps.viewangles[PITCH]*-1;
+				defPitchAdd = defender->client->ps.viewangles[PITCH];
+			}
+			else if ( !defender->s.number )
+			{
+				//clamp to defPitch
+				if ( defender->client->ps.viewangles[PITCH] > defPitchAdd + 10 )
+				{
+					defender->client->ps.viewangles[PITCH] = defPitchAdd + 10;
+				}
+				else if ( defender->client->ps.viewangles[PITCH] < defPitchAdd-10 )
+				{
+					defender->client->ps.viewangles[PITCH] = defPitchAdd-10;
+				}
+				//clamp to sane numbers
+				if ( defender->client->ps.viewangles[PITCH] > 50 )
+				{
+					defender->client->ps.viewangles[PITCH] = 50;
+				}
+				else if ( defender->client->ps.viewangles[PITCH] < -50 )
+				{
+					defender->client->ps.viewangles[PITCH] = -50;
+				}
+				defPitchAdd = defender->client->ps.viewangles[PITCH];
+				attacker->client->ps.viewangles[PITCH] = defender->client->ps.viewangles[PITCH]*-1;
+			}
+		}
+	}
+	vec3_t	attAngles, defAngles, defDir;
+	VectorSubtract( defender->currentOrigin, attacker->currentOrigin, defDir );
+	VectorCopy( attacker->client->ps.viewangles, attAngles );
+	attAngles[YAW] = vectoyaw( defDir );
+	SetClientViewAngle( attacker, attAngles );
+	defAngles[PITCH] = attAngles[PITCH]*-1;
+	defAngles[YAW] = AngleNormalize180( attAngles[YAW] + 180);
+	defAngles[ROLL] = 0;
+	SetClientViewAngle( defender, defAngles );
+	
+	//MATCH POSITIONS
+	vec3_t	newOrg;
+	/*
+	idealDist -= fabs(defPitchAdd)/8.0f;
+	*/
+	float scale = (attacker->s.modelScale[0]+attacker->s.modelScale[1])*0.5f;
+	if ( scale && scale != 1.0f )
+	{
+		idealDist += 8*(scale-1.0f);
+	}
+	scale = (defender->s.modelScale[0]+defender->s.modelScale[1])*0.5f;
+	if ( scale && scale != 1.0f )
+	{
+		idealDist += 8*(scale-1.0f);
+	}
+
+	float diff = VectorNormalize( defDir ) - idealDist;//diff will be the total error in dist
+	//try to move attacker half the diff towards the defender
+	VectorMA( attacker->currentOrigin, diff*0.5f, defDir, newOrg );
+	trace_t	trace;
+	gi.trace( &trace, attacker->currentOrigin, attacker->mins, attacker->maxs, newOrg, attacker->s.number, attacker->clipmask );
+	if ( !trace.startsolid && !trace.allsolid )
+	{
+		G_SetOrigin( attacker, trace.endpos );
+		gi.linkentity( attacker );
+	}
+	//now get the defender's dist and do it for him too
+	vec3_t	attDir;
+	VectorSubtract( attacker->currentOrigin, defender->currentOrigin, attDir );
+	diff = VectorNormalize( attDir ) - idealDist;//diff will be the total error in dist
+	//try to move defender all of the remaining diff towards the attacker
+	VectorMA( defender->currentOrigin, diff, attDir, newOrg );
+	gi.trace( &trace, defender->currentOrigin, defender->mins, defender->maxs, newOrg, defender->s.number, defender->clipmask );
+	if ( !trace.startsolid && !trace.allsolid )
+	{
+		G_SetOrigin( defender, trace.endpos );
+		gi.linkentity( defender );
+	}
+
+	//DONE!
+
+	return qtrue;
+}
+
+qboolean WP_SabersCheckLock( gentity_t *ent1, gentity_t *ent2 )
+{
+	if ( ent1->client->playerTeam == ent2->client->playerTeam )
+	{
+		return qfalse;
+	}
+	if ( ent1->client->NPC_class == CLASS_SABER_DROID
+		|| ent2->client->NPC_class == CLASS_SABER_DROID )
+	{//they don't have saberlock anims
+		return qfalse;
+	}
+	if ( ent1->client->ps.groundEntityNum == ENTITYNUM_NONE ||
+		ent2->client->ps.groundEntityNum == ENTITYNUM_NONE )
+	{
+		return qfalse;
+	}
+	if ( !ent1->client->ps.saber[0].lockable || !ent2->client->ps.saber[0].lockable )
+	{//one of these sabers cannot lock (like a lance)
+		//FIXME: check the second sabers too?
+		return qfalse;
+	}
+	if ( ent1->painDebounceTime > level.time-1000 || ent2->painDebounceTime > level.time-1000 )
+	{//can't saberlock if you're not ready
+		return qfalse;
+	}
+	if ( fabs( ent1->currentOrigin[2]-ent2->currentOrigin[2]) > 18 )
+	{
+		return qfalse;
+	}
+	float dist = DistanceSquared(ent1->currentOrigin,ent2->currentOrigin);
+	if ( dist < 64 || dist > 6400 )//( dist < 128 || dist > 2304 )
+	{//between 8 and 80 from each other//was 16 and 48
+		return qfalse;
+	}
+	if ( !InFOV( ent1, ent2, 40, 180 ) || !InFOV( ent2, ent1, 40, 180 ) )
+	{
+		return qfalse;
+	}
+	//Check for certain anims that *cannot* lock
+	//FIXME: there should probably be a whole *list* of these, but I'll put them in as they come up
+	if ( ent1->client->ps.torsoAnim == BOTH_A2_STABBACK1 && ent1->client->ps.torsoAnimTimer > 300 )
+	{//can't lock when saber is behind you
+		return qfalse;
+	}
+	if ( ent2->client->ps.torsoAnim == BOTH_A2_STABBACK1 && ent2->client->ps.torsoAnimTimer > 300 )
+	{//can't lock when saber is behind you
+		return qfalse;
+	}
+	if ( PM_LockedAnim( ent1->client->ps.torsoAnim ) 
+		|| PM_LockedAnim( ent2->client->ps.torsoAnim ) )
+	{//stuck doing something else
+		return qfalse;
+	}
+	if ( PM_SaberLockBreakAnim( ent1->client->ps.torsoAnim ) 
+		|| PM_SaberLockBreakAnim( ent2->client->ps.torsoAnim ) )
+	{//still finishing the last lock break!
+		return qfalse;
+	}
+	//BR to TL lock
+	if ( ent1->client->ps.torsoAnim == BOTH_A1_BR_TL ||
+		ent1->client->ps.torsoAnim == BOTH_A2_BR_TL ||
+		ent1->client->ps.torsoAnim == BOTH_A3_BR_TL ||
+		ent1->client->ps.torsoAnim == BOTH_A4_BR_TL ||
+		ent1->client->ps.torsoAnim == BOTH_A5_BR_TL ||
+		ent1->client->ps.torsoAnim == BOTH_A6_BR_TL ||
+		ent1->client->ps.torsoAnim == BOTH_A7_BR_TL )
+	{//ent1 is attacking in the opposite diagonal
+		return WP_SabersCheckLock2( ent1, ent2, LOCK_DIAG_BR );
+	}
+	if ( ent2->client->ps.torsoAnim == BOTH_A1_BR_TL ||
+		ent2->client->ps.torsoAnim == BOTH_A2_BR_TL ||
+		ent2->client->ps.torsoAnim == BOTH_A3_BR_TL ||
+		ent2->client->ps.torsoAnim == BOTH_A4_BR_TL ||
+		ent2->client->ps.torsoAnim == BOTH_A5_BR_TL ||
+		ent2->client->ps.torsoAnim == BOTH_A6_BR_TL ||
+		ent2->client->ps.torsoAnim == BOTH_A7_BR_TL )
+	{//ent2 is attacking in the opposite diagonal
+		return WP_SabersCheckLock2( ent2, ent1, LOCK_DIAG_BR );
+	}
+	//BL to TR lock
+	if ( ent1->client->ps.torsoAnim == BOTH_A1_BL_TR ||
+		ent1->client->ps.torsoAnim == BOTH_A2_BL_TR ||
+		ent1->client->ps.torsoAnim == BOTH_A3_BL_TR ||
+		ent1->client->ps.torsoAnim == BOTH_A4_BL_TR ||
+		ent1->client->ps.torsoAnim == BOTH_A5_BL_TR ||
+		ent1->client->ps.torsoAnim == BOTH_A6_BL_TR ||
+		ent1->client->ps.torsoAnim == BOTH_A7_BL_TR )
+	{//ent1 is attacking in the opposite diagonal
+		return WP_SabersCheckLock2( ent1, ent2, LOCK_DIAG_BL );
+	}
+	if ( ent2->client->ps.torsoAnim == BOTH_A1_BL_TR ||
+		ent2->client->ps.torsoAnim == BOTH_A2_BL_TR ||
+		ent2->client->ps.torsoAnim == BOTH_A3_BL_TR ||
+		ent2->client->ps.torsoAnim == BOTH_A4_BL_TR ||
+		ent2->client->ps.torsoAnim == BOTH_A5_BL_TR ||
+		ent2->client->ps.torsoAnim == BOTH_A6_BL_TR ||
+		ent2->client->ps.torsoAnim == BOTH_A7_BL_TR )
+	{//ent2 is attacking in the opposite diagonal
+		return WP_SabersCheckLock2( ent2, ent1, LOCK_DIAG_BL );
+	}
+	//L to R lock
+	if ( ent1->client->ps.torsoAnim == BOTH_A1__L__R ||
+		ent1->client->ps.torsoAnim == BOTH_A2__L__R ||
+		ent1->client->ps.torsoAnim == BOTH_A3__L__R ||
+		ent1->client->ps.torsoAnim == BOTH_A4__L__R ||
+		ent1->client->ps.torsoAnim == BOTH_A5__L__R ||
+		ent1->client->ps.torsoAnim == BOTH_A6__L__R ||
+		ent1->client->ps.torsoAnim == BOTH_A7__L__R )
+	{//ent1 is attacking l to r
+		return WP_SabersCheckLock2( ent1, ent2, LOCK_L );
+		/*
+		if ( ent2BlockingPlayer )
+		{//player will block this anyway
+			return WP_SabersCheckLock2( ent1, ent2, LOCK_L );
+		}
+		if ( ent2->client->ps.torsoAnim == BOTH_A1_TL_BR ||
+			ent2->client->ps.torsoAnim == BOTH_A2_TL_BR ||
+			ent2->client->ps.torsoAnim == BOTH_A3_TL_BR ||
+			ent2->client->ps.torsoAnim == BOTH_A4_TL_BR ||
+			ent2->client->ps.torsoAnim == BOTH_A5_TL_BR ||
+			ent2->client->ps.torsoAnim == BOTH_A6_TL_BR ||
+			ent2->client->ps.torsoAnim == BOTH_A7_TL_BR ||
+			ent2->client->ps.torsoAnim == BOTH_P1_S1_TR ||
+			ent2->client->ps.torsoAnim == BOTH_P1_S1_BL )
+		{//ent2 is attacking or blocking on the r
+			return WP_SabersCheckLock2( ent1, ent2, LOCK_L );
+		}
+		if ( ent2Boss && !Q_irand( 0, 3 ) )
+		{
+			return WP_SabersCheckLock2( ent1, ent2, LOCK_L );
+		}
+		*/
+	}
+	if ( ent2->client->ps.torsoAnim == BOTH_A1__L__R ||
+		ent2->client->ps.torsoAnim == BOTH_A2__L__R ||
+		ent2->client->ps.torsoAnim == BOTH_A3__L__R ||
+		ent2->client->ps.torsoAnim == BOTH_A4__L__R ||
+		ent2->client->ps.torsoAnim == BOTH_A5__L__R ||
+		ent2->client->ps.torsoAnim == BOTH_A6__L__R ||
+		ent2->client->ps.torsoAnim == BOTH_A7__L__R )
+	{//ent2 is attacking l to r
+		return WP_SabersCheckLock2( ent2, ent1, LOCK_L );
+		/*
+		if ( ent1BlockingPlayer )
+		{//player will block this anyway
+			return WP_SabersCheckLock2( ent2, ent1, LOCK_L );
+		}
+		if ( ent1->client->ps.torsoAnim == BOTH_A1_TL_BR ||
+			ent1->client->ps.torsoAnim == BOTH_A2_TL_BR ||
+			ent1->client->ps.torsoAnim == BOTH_A3_TL_BR ||
+			ent1->client->ps.torsoAnim == BOTH_A4_TL_BR ||
+			ent1->client->ps.torsoAnim == BOTH_A5_TL_BR ||
+			ent1->client->ps.torsoAnim == BOTH_A6_TL_BR ||
+			ent1->client->ps.torsoAnim == BOTH_A7_TL_BR ||
+			ent1->client->ps.torsoAnim == BOTH_P1_S1_TR ||
+			ent1->client->ps.torsoAnim == BOTH_P1_S1_BL )
+		{//ent1 is attacking or blocking on the r
+			return WP_SabersCheckLock2( ent2, ent1, LOCK_L );
+		}
+		if ( ent1Boss && !Q_irand( 0, 3 ) )
+		{
+			return WP_SabersCheckLock2( ent2, ent1, LOCK_L );
+		}
+		*/
+	}
+	//R to L lock
+	if ( ent1->client->ps.torsoAnim == BOTH_A1__R__L ||
+		ent1->client->ps.torsoAnim == BOTH_A2__R__L ||
+		ent1->client->ps.torsoAnim == BOTH_A3__R__L ||
+		ent1->client->ps.torsoAnim == BOTH_A4__R__L ||
+		ent1->client->ps.torsoAnim == BOTH_A5__R__L ||
+		ent1->client->ps.torsoAnim == BOTH_A6__R__L ||
+		ent1->client->ps.torsoAnim == BOTH_A7__R__L )
+	{//ent1 is attacking r to l
+		return WP_SabersCheckLock2( ent1, ent2, LOCK_R );
+		/*
+		if ( ent2BlockingPlayer )
+		{//player will block this anyway
+			return WP_SabersCheckLock2( ent1, ent2, LOCK_R );
+		}
+		if ( ent2->client->ps.torsoAnim == BOTH_A1_TR_BL ||
+			ent2->client->ps.torsoAnim == BOTH_A2_TR_BL ||
+			ent2->client->ps.torsoAnim == BOTH_A3_TR_BL ||
+			ent2->client->ps.torsoAnim == BOTH_A4_TR_BL ||
+			ent2->client->ps.torsoAnim == BOTH_A5_TR_BL ||
+			ent2->client->ps.torsoAnim == BOTH_A6_TR_BL ||
+			ent2->client->ps.torsoAnim == BOTH_A7_TR_BL ||
+			ent2->client->ps.torsoAnim == BOTH_P1_S1_TL ||
+			ent2->client->ps.torsoAnim == BOTH_P1_S1_BR )
+		{//ent2 is attacking or blocking on the l
+			return WP_SabersCheckLock2( ent1, ent2, LOCK_R );
+		}
+		if ( ent2Boss && !Q_irand( 0, 3 ) )
+		{
+			return WP_SabersCheckLock2( ent1, ent2, LOCK_R );
+		}
+		*/
+	}
+	if ( ent2->client->ps.torsoAnim == BOTH_A1__R__L ||
+		ent2->client->ps.torsoAnim == BOTH_A2__R__L ||
+		ent2->client->ps.torsoAnim == BOTH_A3__R__L ||
+		ent2->client->ps.torsoAnim == BOTH_A4__R__L ||
+		ent2->client->ps.torsoAnim == BOTH_A5__R__L ||
+		ent2->client->ps.torsoAnim == BOTH_A6__R__L ||
+		ent2->client->ps.torsoAnim == BOTH_A7__R__L )
+	{//ent2 is attacking r to l
+		return WP_SabersCheckLock2( ent2, ent1, LOCK_R );
+		/*
+		if ( ent1BlockingPlayer )
+		{//player will block this anyway
+			return WP_SabersCheckLock2( ent2, ent1, LOCK_R );
+		}
+		if ( ent1->client->ps.torsoAnim == BOTH_A1_TR_BL ||
+			ent1->client->ps.torsoAnim == BOTH_A2_TR_BL ||
+			ent1->client->ps.torsoAnim == BOTH_A3_TR_BL ||
+			ent1->client->ps.torsoAnim == BOTH_A4_TR_BL ||
+			ent1->client->ps.torsoAnim == BOTH_A5_TR_BL ||
+			ent1->client->ps.torsoAnim == BOTH_A6_TR_BL ||
+			ent1->client->ps.torsoAnim == BOTH_A7_TR_BL ||
+			ent1->client->ps.torsoAnim == BOTH_P1_S1_TL ||
+			ent1->client->ps.torsoAnim == BOTH_P1_S1_BR )
+		{//ent1 is attacking or blocking on the l
+			return WP_SabersCheckLock2( ent2, ent1, LOCK_R );
+		}
+		if ( ent1Boss && !Q_irand( 0, 3 ) )
+		{
+			return WP_SabersCheckLock2( ent2, ent1, LOCK_R );
+		}
+		*/
+	}
+	//TR to BL lock
+	if ( ent1->client->ps.torsoAnim == BOTH_A1_TR_BL ||
+		ent1->client->ps.torsoAnim == BOTH_A2_TR_BL ||
+		ent1->client->ps.torsoAnim == BOTH_A3_TR_BL ||
+		ent1->client->ps.torsoAnim == BOTH_A4_TR_BL ||
+		ent1->client->ps.torsoAnim == BOTH_A5_TR_BL ||
+		ent1->client->ps.torsoAnim == BOTH_A6_TR_BL ||
+		ent1->client->ps.torsoAnim == BOTH_A7_TR_BL )
+	{//ent1 is attacking diagonally
+		return WP_SabersCheckLock2( ent1, ent2, LOCK_DIAG_TR );
+		/*
+		if ( ent2BlockingPlayer )
+		{//player will block this anyway
+			return WP_SabersCheckLock2( ent1, ent2, LOCK_DIAG_TR );
+		}
+		if ( ent2->client->ps.torsoAnim == BOTH_A1_TR_BL ||
+			ent2->client->ps.torsoAnim == BOTH_A2_TR_BL ||
+			ent2->client->ps.torsoAnim == BOTH_A3_TR_BL ||
+			ent2->client->ps.torsoAnim == BOTH_A4_TR_BL ||
+			ent2->client->ps.torsoAnim == BOTH_A5_TR_BL ||
+			ent2->client->ps.torsoAnim == BOTH_A6_TR_BL ||
+			ent2->client->ps.torsoAnim == BOTH_A7_TR_BL ||
+			ent2->client->ps.torsoAnim == BOTH_P1_S1_TL )
+		{//ent2 is attacking in the opposite diagonal
+			return WP_SabersCheckLock2( ent1, ent2, LOCK_DIAG_TR );
+		}
+		if ( ent2->client->ps.torsoAnim == BOTH_A1_BR_TL ||
+			ent2->client->ps.torsoAnim == BOTH_A2_BR_TL ||
+			ent2->client->ps.torsoAnim == BOTH_A3_BR_TL ||
+			ent2->client->ps.torsoAnim == BOTH_A4_BR_TL ||
+			ent2->client->ps.torsoAnim == BOTH_A5_BR_TL ||
+			ent2->client->ps.torsoAnim == BOTH_A6_BR_TL ||
+			ent2->client->ps.torsoAnim == BOTH_A7_BR_TL ||
+			ent2->client->ps.torsoAnim == BOTH_P1_S1_BL )
+		{//ent2 is attacking in the opposite diagonal
+			return WP_SabersCheckLock2( ent1, ent2, LOCK_DIAG_BL );
+		}
+		if ( ent2Boss && !Q_irand( 0, 3 ) )
+		{
+			return WP_SabersCheckLock2( ent1, ent2, LOCK_DIAG_TR );
+		}
+		*/
+	}
+
+	if ( ent2->client->ps.torsoAnim == BOTH_A1_TR_BL ||
+		ent2->client->ps.torsoAnim == BOTH_A2_TR_BL ||
+		ent2->client->ps.torsoAnim == BOTH_A3_TR_BL ||
+		ent2->client->ps.torsoAnim == BOTH_A4_TR_BL ||
+		ent2->client->ps.torsoAnim == BOTH_A5_TR_BL ||
+		ent2->client->ps.torsoAnim == BOTH_A6_TR_BL ||
+		ent2->client->ps.torsoAnim == BOTH_A7_TR_BL )
+	{//ent2 is attacking diagonally
+		return WP_SabersCheckLock2( ent2, ent1, LOCK_DIAG_TR );
+		/*
+		if ( ent1BlockingPlayer )
+		{//player will block this anyway
+			return WP_SabersCheckLock2( ent2, ent1, LOCK_DIAG_TR );
+		}
+		if ( ent1->client->ps.torsoAnim == BOTH_A1_TR_BL ||
+			ent1->client->ps.torsoAnim == BOTH_A2_TR_BL ||
+			ent1->client->ps.torsoAnim == BOTH_A3_TR_BL ||
+			ent1->client->ps.torsoAnim == BOTH_A4_TR_BL ||
+			ent1->client->ps.torsoAnim == BOTH_A5_TR_BL ||
+			ent1->client->ps.torsoAnim == BOTH_A6_TR_BL ||
+			ent1->client->ps.torsoAnim == BOTH_A7_TR_BL ||
+			ent1->client->ps.torsoAnim == BOTH_P1_S1_TL )
+		{//ent1 is attacking in the opposite diagonal
+			return WP_SabersCheckLock2( ent2, ent1, LOCK_DIAG_TR );
+		}
+		if ( ent1->client->ps.torsoAnim == BOTH_A1_BR_TL ||
+			ent1->client->ps.torsoAnim == BOTH_A2_BR_TL ||
+			ent1->client->ps.torsoAnim == BOTH_A3_BR_TL ||
+			ent1->client->ps.torsoAnim == BOTH_A4_BR_TL ||
+			ent1->client->ps.torsoAnim == BOTH_A5_BR_TL ||
+			ent1->client->ps.torsoAnim == BOTH_A6_BR_TL ||
+			ent1->client->ps.torsoAnim == BOTH_A7_BR_TL ||
+			ent1->client->ps.torsoAnim == BOTH_P1_S1_BL )
+		{//ent1 is attacking in the opposite diagonal
+			return WP_SabersCheckLock2( ent2, ent1, LOCK_DIAG_BL );
+		}
+		if ( ent1Boss && !Q_irand( 0, 3 ) )
+		{
+			return WP_SabersCheckLock2( ent2, ent1, LOCK_DIAG_TR );
+		}
+		*/
+	}
+
+	//TL to BR lock
+	if ( ent1->client->ps.torsoAnim == BOTH_A1_TL_BR ||
+		ent1->client->ps.torsoAnim == BOTH_A2_TL_BR ||
+		ent1->client->ps.torsoAnim == BOTH_A3_TL_BR ||
+		ent1->client->ps.torsoAnim == BOTH_A4_TL_BR ||
+		ent1->client->ps.torsoAnim == BOTH_A5_TL_BR ||
+		ent1->client->ps.torsoAnim == BOTH_A6_TL_BR ||
+		ent1->client->ps.torsoAnim == BOTH_A7_TL_BR )
+	{//ent1 is attacking diagonally
+		return WP_SabersCheckLock2( ent1, ent2, LOCK_DIAG_TL );
+		/*
+		if ( ent2BlockingPlayer )
+		{//player will block this anyway
+			return WP_SabersCheckLock2( ent1, ent2, LOCK_DIAG_TL );
+		}
+		if ( ent2->client->ps.torsoAnim == BOTH_A1_TL_BR ||
+			ent2->client->ps.torsoAnim == BOTH_A2_TL_BR ||
+			ent2->client->ps.torsoAnim == BOTH_A3_TL_BR ||
+			ent2->client->ps.torsoAnim == BOTH_A4_TL_BR ||
+			ent2->client->ps.torsoAnim == BOTH_A5_TL_BR ||
+			ent2->client->ps.torsoAnim == BOTH_A6_TL_BR ||
+			ent2->client->ps.torsoAnim == BOTH_A7_TL_BR ||
+			ent2->client->ps.torsoAnim == BOTH_P1_S1_TR )
+		{//ent2 is attacking in the opposite diagonal
+			return WP_SabersCheckLock2( ent1, ent2, LOCK_DIAG_TL );
+		}
+		if ( ent2->client->ps.torsoAnim == BOTH_A1_BL_TR ||
+			ent2->client->ps.torsoAnim == BOTH_A2_BL_TR ||
+			ent2->client->ps.torsoAnim == BOTH_A3_BL_TR ||
+			ent2->client->ps.torsoAnim == BOTH_A4_BL_TR ||
+			ent2->client->ps.torsoAnim == BOTH_A5_BL_TR ||
+			ent2->client->ps.torsoAnim == BOTH_A6_BL_TR ||
+			ent2->client->ps.torsoAnim == BOTH_A7_BL_TR ||
+			ent2->client->ps.torsoAnim == BOTH_P1_S1_BR )
+		{//ent2 is attacking in the opposite diagonal
+			return WP_SabersCheckLock2( ent1, ent2, LOCK_DIAG_BR );
+		}
+		if ( ent2Boss && !Q_irand( 0, 3 ) )
+		{
+			return WP_SabersCheckLock2( ent1, ent2, LOCK_DIAG_TL );
+		}
+		*/
+	}
+
+	if ( ent2->client->ps.torsoAnim == BOTH_A1_TL_BR ||
+		ent2->client->ps.torsoAnim == BOTH_A2_TL_BR ||
+		ent2->client->ps.torsoAnim == BOTH_A3_TL_BR ||
+		ent2->client->ps.torsoAnim == BOTH_A4_TL_BR ||
+		ent2->client->ps.torsoAnim == BOTH_A5_TL_BR ||
+		ent2->client->ps.torsoAnim == BOTH_A6_TL_BR ||
+		ent2->client->ps.torsoAnim == BOTH_A7_TL_BR )
+	{//ent2 is attacking diagonally
+		return WP_SabersCheckLock2( ent2, ent1, LOCK_DIAG_TL );
+		/*
+		if ( ent1BlockingPlayer )
+		{//player will block this anyway
+			return WP_SabersCheckLock2( ent2, ent1, LOCK_DIAG_TL );
+		}
+		if ( ent1->client->ps.torsoAnim == BOTH_A1_TL_BR ||
+			ent1->client->ps.torsoAnim == BOTH_A2_TL_BR ||
+			ent1->client->ps.torsoAnim == BOTH_A3_TL_BR ||
+			ent1->client->ps.torsoAnim == BOTH_A4_TL_BR ||
+			ent1->client->ps.torsoAnim == BOTH_A5_TL_BR ||
+			ent1->client->ps.torsoAnim == BOTH_A6_TL_BR ||
+			ent1->client->ps.torsoAnim == BOTH_A7_TL_BR ||
+			ent1->client->ps.torsoAnim == BOTH_P1_S1_TR )
+		{//ent1 is attacking in the opposite diagonal
+			return WP_SabersCheckLock2( ent2, ent1, LOCK_DIAG_TL );
+		}
+		if ( ent1->client->ps.torsoAnim == BOTH_A1_BL_TR ||
+			ent1->client->ps.torsoAnim == BOTH_A2_BL_TR ||
+			ent1->client->ps.torsoAnim == BOTH_A3_BL_TR ||
+			ent1->client->ps.torsoAnim == BOTH_A4_BL_TR ||
+			ent1->client->ps.torsoAnim == BOTH_A5_BL_TR ||
+			ent1->client->ps.torsoAnim == BOTH_A6_BL_TR ||
+			ent1->client->ps.torsoAnim == BOTH_A7_BL_TR ||
+			ent1->client->ps.torsoAnim == BOTH_P1_S1_BR )
+		{//ent1 is attacking in the opposite diagonal
+			return WP_SabersCheckLock2( ent2, ent1, LOCK_DIAG_BR );
+		}
+		if ( ent1Boss && !Q_irand( 0, 3 ) )
+		{
+			return WP_SabersCheckLock2( ent2, ent1, LOCK_DIAG_TL );
+		}
+		*/
+	}
+	//T to B lock
+	if ( ent1->client->ps.torsoAnim == BOTH_A1_T__B_ ||
+		ent1->client->ps.torsoAnim == BOTH_A2_T__B_ ||
+		ent1->client->ps.torsoAnim == BOTH_A3_T__B_ ||
+		ent1->client->ps.torsoAnim == BOTH_A4_T__B_ ||
+		ent1->client->ps.torsoAnim == BOTH_A5_T__B_ ||
+		ent1->client->ps.torsoAnim == BOTH_A6_T__B_ ||
+		ent1->client->ps.torsoAnim == BOTH_A7_T__B_ )
+	{//ent1 is attacking top-down
+		/*
+		if ( ent2->client->ps.torsoAnim == BOTH_P1_S1_T_ ||
+			ent2->client->ps.torsoAnim == BOTH_K1_S1_T_ )
+		*/
+		{//ent2 is blocking at top
+			return WP_SabersCheckLock2( ent1, ent2, LOCK_TOP );
+		}
+	}
+
+	if ( ent2->client->ps.torsoAnim == BOTH_A1_T__B_ ||
+		ent2->client->ps.torsoAnim == BOTH_A2_T__B_ ||
+		ent2->client->ps.torsoAnim == BOTH_A3_T__B_ ||
+		ent2->client->ps.torsoAnim == BOTH_A4_T__B_ ||
+		ent2->client->ps.torsoAnim == BOTH_A5_T__B_ ||
+		ent2->client->ps.torsoAnim == BOTH_A6_T__B_ ||
+		ent2->client->ps.torsoAnim == BOTH_A7_T__B_ )
+	{//ent2 is attacking top-down
+		/*
+		if ( ent1->client->ps.torsoAnim == BOTH_P1_S1_T_ ||
+			ent1->client->ps.torsoAnim == BOTH_K1_S1_T_ )
+		*/
+		{//ent1 is blocking at top
+			return WP_SabersCheckLock2( ent2, ent1, LOCK_TOP );
+		}
+	}
+	/*
+	if ( !Q_irand( 0, 10 ) )
+	{
+		return WP_SabersCheckLock2( ent1, ent2, LOCK_RANDOM );
+	}
+	*/
+	return qfalse;
+}
+
+qboolean WP_SaberParry( gentity_t *victim, gentity_t *attacker )
+{
+	if ( !victim || !victim->client || !attacker )
+	{
+		return qfalse;
+	}
+	if ( Rosh_BeingHealed( victim ) )
+	{
+		return qfalse;
+	}
+	if ( G_InCinematicSaberAnim( victim ) )
+	{
+		return qfalse;
+	}
+	if ( PM_SuperBreakLoseAnim( victim->client->ps.torsoAnim ) 
+		|| PM_SuperBreakWinAnim( victim->client->ps.torsoAnim ) )
+	{
+		return qfalse;
+	}
+	if ( victim->s.number || g_saberAutoBlocking->integer || victim->client->ps.saberBlockingTime > level.time )
+	{//either an NPC or a player who is blocking
+		if ( !PM_SaberInTransitionAny( victim->client->ps.saberMove ) 
+			&& !PM_SaberInBounce( victim->client->ps.saberMove ) 
+			&& !PM_SaberInKnockaway( victim->client->ps.saberMove ) )
+		{//I'm not attacking, in transition or in a bounce or knockaway, so play a parry
+			WP_SaberBlockNonRandom( victim, saberHitLocation, qfalse );
+		}
+		victim->client->ps.saberEventFlags |= SEF_PARRIED;
+
+		//since it was parried, take away any damage done
+		//FIXME: what if the damage was done before the parry?
+		WP_SaberClearDamageForEntNum( victim->s.number );
+
+		//tell the victim to get mad at me
+		if ( victim->enemy != attacker && victim->client->playerTeam != attacker->client->playerTeam )
+		{//they're not mad at me and they're not on my team
+			G_ClearEnemy( victim );
+			G_SetEnemy( victim, attacker );
+		}
+		return qtrue;
+	}
+	return qfalse;
+}
+
+qboolean WP_BrokenParryKnockDown( gentity_t *victim )
+{
+	if ( !victim || !victim->client )
+	{
+		return qfalse;
+	}
+	if ( PM_SuperBreakLoseAnim( victim->client->ps.torsoAnim ) 
+		|| PM_SuperBreakWinAnim( victim->client->ps.torsoAnim ) )
+	{
+		return qfalse;
+	}
+	if ( victim->client->ps.saberMove == LS_PARRY_UP 
+		|| victim->client->ps.saberMove == LS_PARRY_UR
+		|| victim->client->ps.saberMove == LS_PARRY_UL
+		|| victim->client->ps.saberMove == LS_H1_BR
+		|| victim->client->ps.saberMove == LS_H1_B_
+		|| victim->client->ps.saberMove == LS_H1_BL )
+	{//knock their asses down!
+		int knockAnim = BOTH_KNOCKDOWN1;
+		if ( PM_CrouchAnim( victim->client->ps.legsAnim ) )
+		{
+			knockAnim = BOTH_KNOCKDOWN4;
+		}
+		NPC_SetAnim( victim, SETANIM_BOTH, knockAnim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+		G_AddEvent( victim, EV_PAIN, victim->health );
+		return qtrue;
+	}
+	return qfalse;
+}
+
+qboolean G_TryingKataAttack( gentity_t *self, usercmd_t *cmd )
+{
+	if ( g_saberNewControlScheme->integer )
+	{//use the new control scheme: force focus button
+		if ( (cmd->buttons&BUTTON_FORCE_FOCUS) )
+		{
+			return qtrue;
+		}
+		else
+		{
+			return qfalse;
+		}
+	}
+	else //if ( self && self->client )
+	{//use the old control scheme
+		if ( (cmd->buttons&BUTTON_ALT_ATTACK) )
+		{//pressing alt-attack
+			//if ( !(self->client->ps.pm_flags&PMF_ALT_ATTACK_HELD) )
+			{//haven't been holding alt-attack
+				if ( (cmd->buttons&BUTTON_ATTACK) )
+				{//pressing attack
+					return qtrue;
+				}
+			}
+		}
+	}
+	return qfalse;
+}
+
+qboolean G_TryingPullAttack( gentity_t *self, usercmd_t *cmd, qboolean amPulling )
+{
+	if ( g_saberNewControlScheme->integer )
+	{//use the new control scheme: force focus button
+		if ( (cmd->buttons&BUTTON_FORCE_FOCUS) )
+		{
+			if ( self && self->client )
+			{
+				if ( self->client->ps.forcePowerLevel[FP_PULL] >= FORCE_LEVEL_3 )
+				{//force pull 3
+					if ( amPulling
+						|| (self->client->ps.forcePowersActive&(1<<FP_PULL))
+						|| self->client->ps.forcePowerDebounce[FP_PULL] > level.time ) //force-pulling
+					{//pulling
+						return qtrue;
+					}
+				}
+			}
+		}
+		else
+		{
+			return qfalse;
+		}
+	}
+	else
+	{//use the old control scheme
+		if ( (cmd->buttons&BUTTON_ATTACK) )
+		{//pressing attack
+			if ( self && self->client )
+			{
+				if ( self->client->ps.forcePowerLevel[FP_PULL] >= FORCE_LEVEL_3 )
+				{//force pull 3
+					if ( amPulling
+						|| (self->client->ps.forcePowersActive&(1<<FP_PULL))
+						|| self->client->ps.forcePowerDebounce[FP_PULL] > level.time ) //force-pulling
+					{//pulling
+						return qtrue;
+					}
+				}
+			}
+		}
+	}
+	return qfalse;
+}
+
+qboolean G_TryingCartwheel( gentity_t *self, usercmd_t *cmd )
+{
+	if ( g_saberNewControlScheme->integer )
+	{//use the new control scheme: force focus button
+		if ( (cmd->buttons&BUTTON_FORCE_FOCUS) )
+		{
+			return qtrue;
+		}
+		else
+		{
+			return qfalse;
+		}
+	}
+	else
+	{//use the old control scheme
+		if ( (cmd->buttons&BUTTON_ATTACK) )
+		{//pressing attack
+			if ( cmd->rightmove )
+			{
+				if ( self && self->client )
+				{
+					if ( cmd->upmove>0 //)
+						&& self->client->ps.groundEntityNum != ENTITYNUM_NONE )
+					{//on ground, pressing jump
+						return qtrue;
+					}
+					else
+					{//just jumped?
+						if ( self->client->ps.groundEntityNum == ENTITYNUM_NONE
+							&& level.time - self->client->ps.lastOnGround <= 50//250 
+							&& (self->client->ps.pm_flags&PMF_JUMPING) )//jumping
+						{//just jumped this or last frame
+							return qtrue;
+						}
+					}
+				}
+			}
+		}
+	}
+	return qfalse;
+}
+
+qboolean G_TryingSpecial( gentity_t *self, usercmd_t *cmd )
+{
+	if ( g_saberNewControlScheme->integer )
+	{//use the new control scheme: force focus button
+		if ( (cmd->buttons&BUTTON_FORCE_FOCUS) )
+		{
+			return qtrue;
+		}
+		else
+		{
+			return qfalse;
+		}
+	}
+	else
+	{//use the old control scheme
+		return qfalse;
+	}
+}
+
+qboolean G_TryingJumpAttack( gentity_t *self, usercmd_t *cmd )
+{
+	if ( g_saberNewControlScheme->integer )
+	{//use the new control scheme: force focus button
+		if ( (cmd->buttons&BUTTON_FORCE_FOCUS) )
+		{
+			return qtrue;
+		}
+		else
+		{
+			return qfalse;
+		}
+	}
+	else
+	{//use the old control scheme
+		if ( (cmd->buttons&BUTTON_ATTACK) )
+		{//pressing attack
+			if ( cmd->upmove>0 )
+			{//pressing jump
+				return qtrue;
+			}
+			else if ( self && self->client )
+			{//just jumped?
+				if ( self->client->ps.groundEntityNum == ENTITYNUM_NONE
+					&& level.time - self->client->ps.lastOnGround <= 250
+					&& (self->client->ps.pm_flags&PMF_JUMPING) )//jumping
+				{//jumped within the last quarter second
+					return qtrue;
+				}
+			}
+		}
+	}
+	return qfalse;
+}
+
+qboolean G_TryingJumpForwardAttack( gentity_t *self, usercmd_t *cmd )
+{
+	if ( g_saberNewControlScheme->integer )
+	{//use the new control scheme: force focus button
+		if ( (cmd->buttons&BUTTON_FORCE_FOCUS) )
+		{
+			return qtrue;
+		}
+		else
+		{
+			return qfalse;
+		}
+	}
+	else
+	{//use the old control scheme
+		if ( (cmd->buttons&BUTTON_ATTACK) )
+		{//pressing attack
+			if ( cmd->forwardmove > 0 )
+			{//moving forward
+				if ( self && self->client )
+				{
+					if ( cmd->upmove>0 
+						&& self->client->ps.groundEntityNum != ENTITYNUM_NONE )
+					{//pressing jump
+						return qtrue;
+					}
+					else
+					{//no slop on forward jumps - must be precise!
+						if ( self->client->ps.groundEntityNum == ENTITYNUM_NONE
+							&& level.time - self->client->ps.lastOnGround <= 50
+							&& (self->client->ps.pm_flags&PMF_JUMPING) )//jumping
+						{//just jumped this or last frame
+							return qtrue;
+						}
+					}
+				}
+			}
+		}
+	}
+	return qfalse;
+}
+
+qboolean G_TryingLungeAttack( gentity_t *self, usercmd_t *cmd )
+{
+	if ( g_saberNewControlScheme->integer )
+	{//use the new control scheme: force focus button
+		if ( (cmd->buttons&BUTTON_FORCE_FOCUS) )
+		{
+			return qtrue;
+		}
+		else
+		{
+			return qfalse;
+		}
+	}
+	else
+	{//use the old control scheme
+		if ( (cmd->buttons&BUTTON_ATTACK) )
+		{//pressing attack
+			if ( cmd->upmove<0 )
+			{//pressing crouch
+				return qtrue;
+			}
+			else if ( self && self->client )
+			{//just unducked?
+				if ( (self->client->ps.pm_flags&PMF_DUCKED) )
+				{//just unducking
+					return qtrue;
+				}
+			}
+		}
+	}
+	return qfalse;
+}
+
+
+//FIXME: for these below funcs, maybe in the old control scheme some moves should still cost power... if so, pass in the saberMove and use a switch statement
+qboolean G_EnoughPowerForSpecialMove( int forcePower, int cost, qboolean kataMove )
+{
+	if ( g_saberNewControlScheme->integer || kataMove )
+	{//special moves cost power
+		if ( forcePower >= cost )
+		{
+			return qtrue;
+		}
+		else
+		{
+			cg.forceHUDTotalFlashTime = level.time + 1000;
+			return qfalse;
+		}
+	}
+	else
+	{//old control scheme: uses no power, so just do it
+		return qtrue;
+	}
+}
+
+void G_DrainPowerForSpecialMove( gentity_t *self, forcePowers_t fp, int cost, qboolean kataMove )
+{
+	if ( !self || !self->client || self->s.number >= MAX_CLIENTS )
+	{
+		return;
+	}
+	if ( g_saberNewControlScheme->integer || kataMove )
+	{//special moves cost power
+		WP_ForcePowerDrain( self, fp, cost );//drain the required force power
+	}
+	else
+	{//old control scheme: uses no power, so just do it
+	}
+}
+
+int G_CostForSpecialMove( int cost, qboolean kataMove )
+{
+	if ( g_saberNewControlScheme->integer || kataMove )
+	{//special moves cost power
+		return cost;
+	}
+	else
+	{//old control scheme: uses no power, so just do it
+		return 0;
+	}
+}
+
+/*
+---------------------------------------------------------
+void WP_SaberDamageTrace( gentity_t *ent, int saberNum, int bladeNum )
+
+  Constantly trace from the old blade pos to new, down the saber beam and do damage
+
+  FIXME: if the dot product of the old muzzle dir and the new muzzle dir is < 0.75, subdivide it and do multiple traces so we don't flatten out the arc!
+---------------------------------------------------------
+*/
+#define MAX_SABER_SWING_INC 0.33f
+void WP_SaberDamageTrace( gentity_t *ent, int saberNum, int bladeNum )
+{
+	vec3_t		mp1, mp2, md1, md2, baseOld, baseNew, baseDiff, endOld, endNew, bladePointOld, bladePointNew;
+	float		tipDmgMod = 1.0f;
+	float		baseDamage;
+	int			baseDFlags = 0;
+	qboolean	hit_wall = qfalse;
+	qboolean	brokenParry = qfalse;
+
+	for ( int ven = 0; ven < MAX_SABER_VICTIMS; ven++ )
+	{
+		victimEntityNum[ven] = ENTITYNUM_NONE;
+	}
+	memset( totalDmg, 0, sizeof( totalDmg) );
+	memset( dmgDir, 0, sizeof( dmgDir ) );
+	memset( dmgSpot, 0, sizeof( dmgSpot ) );
+	memset( dmgFraction, 0, sizeof( dmgFraction ) );
+	memset( hitLoc, HL_NONE, sizeof( hitLoc ) );
+	memset( hitDismemberLoc, HL_NONE, sizeof( hitDismemberLoc ) );
+	memset( hitDismember, qfalse, sizeof( hitDismember ) );
+	numVictims = 0;
+	VectorClear(saberHitLocation);
+	VectorClear(saberHitNormal);
+	saberHitFraction = 1.0;	// Closest saber hit.  The saber can do no damage past this point.
+	saberHitEntity = ENTITYNUM_NONE;
+	sabersCrossed = -1;
+
+	if ( !ent->client )
+	{
+		return;
+	}
+
+	if ( !ent->s.number )
+	{//player never uses these
+		ent->client->ps.saberEventFlags &= ~SEF_EVENTS;
+	}
+
+	if ( ent->client->ps.saber[saberNum].blade[bladeNum].length <= 1 )//cen get down to 1 when in a wall
+	{//saber is not on
+		return;
+	}
+
+	if ( VectorCompare( ent->client->renderInfo.muzzlePointOld, vec3_origin ) || VectorCompare( ent->client->renderInfo.muzzleDirOld, vec3_origin ) )
+	{
+		//just started up the saber?
+		return;
+	}
+
+	int saberContents = gi.pointcontents( ent->client->renderInfo.muzzlePoint, ent->client->ps.saberEntityNum );
+	if ( (saberContents&CONTENTS_WATER)||
+		(saberContents&CONTENTS_SLIME)||
+		(saberContents&CONTENTS_LAVA) )
+	{//um... turn off?  Or just set length to 1?
+		//FIXME: short-out effect/sound?
+		ent->client->ps.saber[saberNum].blade[bladeNum].active = qfalse;
+		return;
+	}
+	else if (!g_saberNoEffects && gi.WE_IsOutside(ent->client->renderInfo.muzzlePoint))
+	{
+		float chanceOfFizz = gi.WE_GetChanceOfSaberFizz();
+		if (chanceOfFizz>0 && Q_flrand(0.0f, 1.0f)<chanceOfFizz)
+		{
+			vec3_t	end; /*normal = {0,0,1};//FIXME: opposite of rain angles?*/
+			VectorMA( ent->client->ps.saber[saberNum].blade[bladeNum].muzzlePoint, ent->client->ps.saber[saberNum].blade[bladeNum].length*Q_flrand(0, 1), ent->client->ps.saber[saberNum].blade[bladeNum].muzzleDir, end );
+			G_PlayEffect( "saber/fizz", end );
+		}
+	}
+
+	//FIXMEFIXMEFIXME: When in force speed (esp. lvl 3), need to interpolate this because
+	//		we animate so much faster that the arc is pretty much flat...
+
+	int entPowerLevel = 0;
+	if ( ent->client->NPC_class == CLASS_SABER_DROID )
+	{
+		entPowerLevel = SaberDroid_PowerLevelForSaberAnim( ent );
+	}
+	else if ( !ent->s.number && (ent->client->ps.forcePowersActive&(1<<FP_SPEED)) )
+	{
+		entPowerLevel = FORCE_LEVEL_3;
+	}
+	else
+	{
+		entPowerLevel = PM_PowerLevelForSaberAnim( &ent->client->ps, saberNum );
+	}
+
+	if ( entPowerLevel )
+	{
+		if ( ent->client->ps.forceRageRecoveryTime > level.time )
+		{
+			entPowerLevel = FORCE_LEVEL_1;
+		}
+		else if ( ent->client->ps.forcePowersActive & (1 << FP_RAGE) )
+		{
+			entPowerLevel += ent->client->ps.forcePowerLevel[FP_RAGE];
+		}
+	}
+
+	if ( ent->client->ps.saberInFlight )
+	{//flying sabers are much more deadly
+		//unless you're dead
+		if ( ent->health <= 0 && g_saberRealisticCombat->integer < 2 )
+		{//so enemies don't keep trying to block it
+			//FIXME: still do damage, just not to humanoid clients who should try to avoid it
+			//baseDamage = 0.0f;
+			return;
+		}
+		//or unless returning
+		else if ( ent->client->ps.saberEntityState == SES_RETURNING 
+			&& ent->client->ps.saber[0].returnDamage == qfalse )//type != SABER_STAR )
+		{//special case, since we're returning, chances are if we hit something
+			//it's going to be butt-first.  So do less damage.
+			baseDamage = 0.1f;
+		}
+		else
+		{
+			if ( !ent->s.number )
+			{//cheat for player
+				baseDamage = 10.0f;
+			}
+			else
+			{
+				baseDamage = 2.5f;
+			}
+		}
+		//Use old to current since can't predict it
+		VectorCopy( ent->client->ps.saber[saberNum].blade[bladeNum].muzzlePointOld, mp1 );
+		VectorCopy( ent->client->ps.saber[saberNum].blade[bladeNum].muzzleDirOld, md1 );
+		VectorCopy( ent->client->ps.saber[saberNum].blade[bladeNum].muzzlePoint, mp2 );
+		VectorCopy( ent->client->ps.saber[saberNum].blade[bladeNum].muzzleDir, md2 );
+	}
+	else
+	{
+		if ( ent->client->ps.torsoAnim == BOTH_A7_HILT ) 
+		{//no effects, no damage
+			return;
+		}
+		else if ( G_InCinematicSaberAnim( ent ) )
+		{
+			baseDFlags = DAMAGE_NO_KILL;
+			baseDamage = 0.1f;
+		}
+		else if ( ent->client->ps.saberMove == LS_READY 
+			&& !PM_SaberInSpecialAttack( ent->client->ps.torsoAnim ) )
+		{//just do effects
+			if ( g_saberRealisticCombat->integer < 2 )
+			{//don't kill with this hit
+				baseDFlags = DAMAGE_NO_KILL;
+			}
+			baseDamage = 0;
+		}
+		else if ( ent->client->ps.saberLockTime > level.time )
+		{//just do effects
+			baseDamage = 0;
+		}
+		else if ( ent->client->ps.saberBlocked > BLOCKED_NONE 
+				 || ( !PM_SaberInAttack( ent->client->ps.saberMove ) 
+					  && !PM_SaberInSpecialAttack( ent->client->ps.torsoAnim ) 
+					  && !PM_SaberInTransitionAny( ent->client->ps.saberMove ) 
+					) 
+				)
+		{//don't do damage if parrying/reflecting/bouncing/deflecting or not actually attacking or in a transition to/from/between attacks
+			baseDamage = 0;
+		}
+		else 
+		{//okay, in a saberMove that does damage
+			//make sure we're in the right anim
+			if ( !PM_SaberInSpecialAttack( ent->client->ps.torsoAnim ) 
+				&& !PM_InAnimForSaberMove( ent->client->ps.torsoAnim, ent->client->ps.saberMove ) )
+			{//forced into some other animation somehow, like a pain or death?
+				baseDamage = 0;
+			}
+			else if ( ent->client->ps.weaponstate == WEAPON_FIRING && ent->client->ps.saberBlocked == BLOCKED_NONE && 
+				( PM_SaberInAttack(ent->client->ps.saberMove) || PM_SaberInSpecialAttack( ent->client->ps.torsoAnim ) || PM_SpinningSaberAnim(ent->client->ps.torsoAnim) || entPowerLevel > FORCE_LEVEL_2 ) )// || ent->client->ps.saberAnimLevel == SS_STAFF ) )
+			{//normal attack swing swinging/spinning (or if using strong set), do normal damage //FIXME: or if using staff?
+				//FIXME: more damage for higher attack power levels?
+				//		More damage based on length/color of saber?
+				//FIXME: Desann does double damage?
+				if ( g_saberRealisticCombat->integer )
+				{
+					switch ( entPowerLevel )
+					{
+					default:
+					case FORCE_LEVEL_3:
+						baseDamage = 10.0f;
+						break;
+					case FORCE_LEVEL_2:
+						baseDamage = 5.0f;
+						break;
+					case FORCE_LEVEL_0:
+					case FORCE_LEVEL_1:
+						baseDamage = 2.5f;
+						break;
+					}
+				}
+				else
+				{
+					if ( g_spskill->integer > 0
+						&& ent->s.number < MAX_CLIENTS
+						&& ( ent->client->ps.torsoAnim == BOTH_ROLL_STAB
+							|| ent->client->ps.torsoAnim == BOTH_SPINATTACK6
+							|| ent->client->ps.torsoAnim == BOTH_SPINATTACK7
+							|| ent->client->ps.torsoAnim == BOTH_LUNGE2_B__T_ ) )
+					{//*sigh*, these anim do less damage since they're so easy to do
+						baseDamage = 2.5f;
+					}
+					else
+					{
+						baseDamage = 2.5f * (float)entPowerLevel;
+					}
+				}
+			}
+			else
+			{//saber is transitioning, defending or idle, don't do as much damage
+				//FIXME: strong attacks and returns should do damage and be unblockable
+				if ( g_timescale->value < 1.0 )
+				{//in slow mo or force speed, we need to do damage during the transitions
+					if ( g_saberRealisticCombat->integer )
+					{
+						switch ( entPowerLevel )
+						{
+						case FORCE_LEVEL_3:
+							baseDamage = 10.0f;
+							break;
+						case FORCE_LEVEL_2:
+							baseDamage = 5.0f;
+							break;
+						default:
+						case FORCE_LEVEL_1:
+							baseDamage = 2.5f;
+							break;
+						}
+					}
+					else
+					{
+						baseDamage = 2.5f * (float)entPowerLevel;
+					}
+				}
+				else// if ( !ent->s.number )
+				{//I have to do *some* damage in transitions or else you feel like a total gimp
+					baseDamage = 0.1f;
+				}
+				/*
+				else
+				{
+					baseDamage = 0;//was 1.0f;//was 0.25
+				}
+				*/
+			}
+		}
+
+		//Use current to next since can predict it
+		//FIXME: if they're closer than the saber blade start, we don't want the
+		//		arm to pass through them without any damage... so check the radius
+		//		and push them away (do pain & knockback)
+		//FIXME: if going into/coming from a parry/reflection or going into a deflection, don't use old mp & dir?  Otherwise, deflections will cut through?
+		//VectorCopy( ent->client->renderInfo.muzzlePoint, mp1 );
+		//VectorCopy( ent->client->renderInfo.muzzleDir, md1 );
+		//VectorCopy( ent->client->renderInfo.muzzlePointNext, mp2 );
+		//VectorCopy( ent->client->renderInfo.muzzleDirNext, md2 );
+		//prediction was causing gaps in swing (G2 problem) so *don't* predict
+		VectorCopy( ent->client->ps.saber[saberNum].blade[bladeNum].muzzlePointOld, mp1 );
+		VectorCopy( ent->client->ps.saber[saberNum].blade[bladeNum].muzzleDirOld, md1 );
+		VectorCopy( ent->client->ps.saber[saberNum].blade[bladeNum].muzzlePoint, mp2 );
+		VectorCopy( ent->client->ps.saber[saberNum].blade[bladeNum].muzzleDir, md2 );
+
+		//NOTE: this is a test, may not be necc, as I can still swing right through someone without hitting them, somehow...
+		//see if anyone is so close that they're within the dist from my origin to the start of the saber
+		if ( ent->health > 0 && !ent->client->ps.saberLockTime && saberNum == 0 && bladeNum == 0 
+			&& !G_InCinematicSaberAnim( ent ) )
+		{//only do once - for first blade
+			trace_t trace;
+			gi.trace( &trace, ent->currentOrigin, vec3_origin, vec3_origin, mp1, ent->s.number, (MASK_SHOT&~(CONTENTS_CORPSE|CONTENTS_ITEM)) );
+			if ( trace.entityNum < ENTITYNUM_WORLD && (trace.entityNum > 0||ent->client->NPC_class == CLASS_DESANN) )//NPCs don't push player away, unless it's Desann
+			{//a valid ent
+				gentity_t *traceEnt = &g_entities[trace.entityNum];
+				if ( traceEnt 
+					&& traceEnt->client 
+					&& traceEnt->client->NPC_class != CLASS_RANCOR
+					&& traceEnt->client->NPC_class != CLASS_ATST
+					&& traceEnt->client->NPC_class != CLASS_WAMPA
+					&& traceEnt->client->NPC_class != CLASS_SAND_CREATURE
+					&& traceEnt->health > 0 
+					&& traceEnt->client->playerTeam != ent->client->playerTeam 
+					&& !PM_SuperBreakLoseAnim( traceEnt->client->ps.legsAnim )
+					&& !PM_SuperBreakLoseAnim( traceEnt->client->ps.torsoAnim )
+					&& !PM_SuperBreakWinAnim( traceEnt->client->ps.legsAnim )
+					&& !PM_SuperBreakWinAnim( traceEnt->client->ps.torsoAnim )
+					&& !PM_InKnockDown( &traceEnt->client->ps )
+					&& !PM_LockedAnim( traceEnt->client->ps.legsAnim )
+					&& !PM_LockedAnim( traceEnt->client->ps.torsoAnim ) 
+					&& !G_InCinematicSaberAnim( traceEnt ))
+				{//enemy client, push them away
+					if ( !traceEnt->client->ps.saberLockTime 
+						&& !traceEnt->message
+						&& !(traceEnt->flags&FL_NO_KNOCKBACK)
+						&& (!traceEnt->NPC||traceEnt->NPC->jumpState!=JS_JUMPING) )
+					{//don't push people in saberlock or with security keys or who are in BS_JUMP
+						vec3_t hitDir;
+						VectorSubtract( trace.endpos, ent->currentOrigin, hitDir );
+						float totalDist = Distance( mp1, ent->currentOrigin );
+						float knockback = (totalDist-VectorNormalize( hitDir ))/totalDist * 200.0f;
+						hitDir[2] = 0;
+						//FIXME: do we need to call G_Throw?  Seems unfair to put actual knockback on them, stops the attack
+						//G_Throw( traceEnt, hitDir, knockback );
+						VectorMA( traceEnt->client->ps.velocity, knockback, hitDir, traceEnt->client->ps.velocity );
+						traceEnt->client->ps.pm_time = 200;
+						traceEnt->client->ps.pm_flags |= PMF_TIME_NOFRICTION;
+#ifndef FINAL_BUILD
+						if ( d_saberCombat->integer )
+						{
+							gi.Printf( "%s pushing away %s at %s\n", ent->NPC_type, traceEnt->NPC_type, vtos( traceEnt->client->ps.velocity ) );
+						}
+#endif
+					}
+				}
+			}
+		}
+	}
+
+	//the thicker the blade, the more damage... the thinner, the less damage
+	baseDamage *= ent->client->ps.saber[saberNum].blade[bladeNum].radius/SABER_RADIUS_STANDARD;
+
+	if ( g_saberRealisticCombat->integer > 1 )
+	{//always do damage, and lots of it
+		if ( g_saberRealisticCombat->integer > 2 )
+		{//always do damage, and lots of it
+			baseDamage = 25.0f;
+		}
+		else if ( baseDamage > 0.1f )
+		{//only do super damage if we would have done damage according to normal rules
+			baseDamage = 25.0f;
+		}
+	}
+	else if ( ((!ent->s.number&&ent->client->ps.forcePowersActive&(1<<FP_SPEED))||ent->client->ps.forcePowersActive&(1<<FP_RAGE))
+		&& g_timescale->value < 1.0f )
+	{
+		baseDamage *= (1.0f-g_timescale->value);
+	}
+	if ( baseDamage > 0.1f )
+	{
+		if ( (ent->client->ps.forcePowersActive&(1<<FP_RAGE)) )
+		{//add some damage if raged
+			baseDamage += ent->client->ps.forcePowerLevel[FP_RAGE] * 5.0f;
+		}
+		else if ( ent->client->ps.forceRageRecoveryTime )
+		{//halve it if recovering
+			baseDamage *= 0.5f;
+		}
+	}
+	// Get the old state of the blade
+	VectorCopy( mp1, baseOld );
+	VectorMA( baseOld, ent->client->ps.saber[saberNum].blade[bladeNum].length, md1, endOld );
+	// Get the future state of the blade
+	VectorCopy( mp2, baseNew );
+	VectorMA( baseNew, ent->client->ps.saber[saberNum].blade[bladeNum].length, md2, endNew );
+
+	sabersCrossed = -1;
+	if ( VectorCompare2( baseOld, baseNew ) && VectorCompare2( endOld, endNew ) )
+	{
+		hit_wall = WP_SaberDamageForTrace( ent->s.number, mp2, endNew, baseDamage*4, md2, 
+			qfalse, entPowerLevel, ent->client->ps.saber[saberNum].type, qfalse,
+			saberNum, bladeNum );
+	}
+	else
+	{
+		float aveLength, step = 8, stepsize = 8;
+		vec3_t	ma1, ma2, md2ang, curBase1, curBase2;
+		int	xx;
+		//do the trace at the base first
+		hit_wall = WP_SaberDamageForTrace( ent->s.number, baseOld, baseNew, baseDamage, md2, 
+			qfalse, entPowerLevel, ent->client->ps.saber[saberNum].type, qtrue,
+			saberNum, bladeNum );
+		
+		//if hit a saber, shorten rest of traces to match
+		if ( saberHitFraction < 1.0 )
+		{
+			//adjust muzzleDir...
+			vec3_t ma1, ma2;
+			vectoangles( md1, ma1 );
+			vectoangles( md2, ma2 );
+			for ( xx = 0; xx < 3; xx++ )
+			{
+				md2ang[xx] = LerpAngle( ma1[xx], ma2[xx], saberHitFraction );
+			}
+			AngleVectors( md2ang, md2, NULL, NULL );
+			//shorten the base pos
+			VectorSubtract( mp2, mp1, baseDiff );
+			VectorMA( mp1, saberHitFraction, baseDiff, baseNew );
+			VectorMA( baseNew, ent->client->ps.saber[saberNum].blade[bladeNum].length, md2, endNew );
+		}
+
+		//If the angle diff in the blade is high, need to do it in chunks of 33 to avoid flattening of the arc
+		float dirInc, curDirFrac;
+		if ( PM_SaberInAttack( ent->client->ps.saberMove ) 
+			|| PM_SaberInSpecialAttack( ent->client->ps.torsoAnim ) 
+			|| PM_SpinningSaberAnim( ent->client->ps.torsoAnim ) 
+			|| PM_InSpecialJump( ent->client->ps.torsoAnim ) 
+			|| (g_timescale->value<1.0f&&PM_SaberInTransitionAny( ent->client->ps.saberMove )) )
+		{
+			curDirFrac = DotProduct( md1, md2 );
+		}
+		else
+		{
+			curDirFrac = 1.0f;
+		}
+		//NOTE: if saber spun at least 180 degrees since last damage trace, this is not reliable...!
+		if ( fabs(curDirFrac) < 1.0f - MAX_SABER_SWING_INC )
+		{//the saber blade spun more than 33 degrees since the last damage trace
+			curDirFrac = dirInc = 1.0f/((1.0f - curDirFrac)/MAX_SABER_SWING_INC);
+		}
+		else
+		{
+			curDirFrac = 1.0f;
+			dirInc = 0.0f;
+		}
+		qboolean hit_saber = qfalse;
+
+		vectoangles( md1, ma1 );
+		vectoangles( md2, ma2 );
+
+		vec3_t curMD1, curMD2;//, mdDiff, dirDiff;
+		//VectorSubtract( md2, md1, mdDiff );
+		VectorCopy( md1, curMD2 );
+		VectorCopy( baseOld, curBase2 );
+
+		while ( 1 )
+		{
+			VectorCopy( curMD2, curMD1 );
+			VectorCopy( curBase2, curBase1 );
+			if ( curDirFrac >= 1.0f )
+			{
+				VectorCopy( md2, curMD2 );
+				VectorCopy( baseNew, curBase2 );
+			}
+			else
+			{
+				for ( xx = 0; xx < 3; xx++ )
+				{
+					md2ang[xx] = LerpAngle( ma1[xx], ma2[xx], curDirFrac );
+				}
+				AngleVectors( md2ang, curMD2, NULL, NULL );
+				//VectorMA( md1, curDirFrac, mdDiff, curMD2 );
+				VectorSubtract( baseNew, baseOld, baseDiff );
+				VectorMA( baseOld, curDirFrac, baseDiff, curBase2 );
+			}
+			// Move up the blade in intervals of stepsize
+			for ( step = stepsize; step < ent->client->ps.saber[saberNum].blade[bladeNum].length && step < ent->client->ps.saber[saberNum].blade[bladeNum].lengthOld; step+=12 )
+			{
+				VectorMA( curBase1, step, curMD1, bladePointOld );
+				VectorMA( curBase2, step, curMD2, bladePointNew );
+				if ( WP_SaberDamageForTrace( ent->s.number, bladePointOld, bladePointNew, baseDamage, curMD2, 
+					qfalse, entPowerLevel, ent->client->ps.saber[saberNum].type, qtrue,
+					saberNum, bladeNum ) )
+				{
+					hit_wall = qtrue;
+				}
+
+				//if hit a saber, shorten rest of traces to match
+				if ( saberHitFraction < 1.0 )
+				{
+					//adjust muzzle endpoint
+					VectorSubtract( mp2, mp1, baseDiff );
+					VectorMA( mp1, saberHitFraction, baseDiff, baseNew );
+					VectorMA( baseNew, ent->client->ps.saber[saberNum].blade[bladeNum].length, curMD2, endNew );
+					//adjust muzzleDir...
+					vec3_t curMA1, curMA2;
+					vectoangles( curMD1, curMA1 );
+					vectoangles( curMD2, curMA2 );
+					for ( xx = 0; xx < 3; xx++ )
+					{
+						md2ang[xx] = LerpAngle( curMA1[xx], curMA2[xx], saberHitFraction );
+					}
+					AngleVectors( md2ang, curMD2, NULL, NULL );
+					/*
+					VectorSubtract( curMD2, curMD1, dirDiff );
+					VectorMA( curMD1, saberHitFraction, dirDiff, curMD2 );
+					*/
+					hit_saber = qtrue;
+				}
+				if (hit_wall)
+				{
+					break;
+				}
+			}
+			if ( hit_wall || hit_saber )
+			{
+				break;
+			}
+			if ( curDirFrac >= 1.0f )
+			{
+				break;
+			}
+			else
+			{
+				curDirFrac += dirInc;
+				if ( curDirFrac >= 1.0f )
+				{
+					curDirFrac = 1.0f;
+				}
+			}
+		}
+
+		//do the trace at the end last
+		//Special check- adjust for length of blade not being a multiple of 12
+		aveLength = (ent->client->ps.saber[saberNum].blade[bladeNum].lengthOld + ent->client->ps.saber[saberNum].blade[bladeNum].length)/2;
+		if ( step > aveLength )
+		{//less dmg if the last interval was not stepsize
+			tipDmgMod = (stepsize-(step-aveLength))/stepsize;
+		}
+		//NOTE: since this is the tip, we do not extrapolate the extra 16
+		if ( WP_SaberDamageForTrace( ent->s.number, endOld, endNew, tipDmgMod*baseDamage, md2, 
+			qfalse, entPowerLevel, ent->client->ps.saber[saberNum].type, qfalse,
+			saberNum, bladeNum ) )
+		{
+			hit_wall = qtrue;
+		}
+	}
+
+	if ( (saberHitFraction < 1.0f||(sabersCrossed>=0&&sabersCrossed<=32.0f)) && (ent->client->ps.weaponstate == WEAPON_FIRING || ent->client->ps.saberInFlight || G_InCinematicSaberAnim( ent ) ) )
+	{// The saber (in-hand) hit another saber, mano.
+		qboolean inFlightSaberBlocked = qfalse;
+		qboolean collisionResolved = qfalse;
+		qboolean deflected = qfalse;
+
+		gentity_t *hitEnt = &g_entities[saberHitEntity];
+		gentity_t *hitOwner = NULL;
+		int hitOwnerPowerLevel = FORCE_LEVEL_0;
+
+		if ( hitEnt )
+		{
+			hitOwner = hitEnt->owner;
+		}
+		if ( hitOwner && hitOwner->client )
+		{
+			hitOwnerPowerLevel = PM_PowerLevelForSaberAnim( &hitOwner->client->ps );
+			/*
+			if ( entPowerLevel >= FORCE_LEVEL_3 
+				&& PM_SaberInSpecialAttack( ent->client->ps.torsoAnim ) )
+			{//a special "unblockable" attack
+				if ( hitOwner->client->NPC_class == CLASS_ALORA
+					|| hitOwner->client->NPC_class == CLASS_SHADOWTROOPER
+					|| (hitOwner->NPC&&(hitOwner->NPC->aiFlags&NPCAI_BOSS_CHARACTER)) )
+				{//these masters can even block unblockables (stops cheap kills)
+					entPowerLevel = FORCE_LEVEL_2;
+				}
+			}
+			*/
+		}
+
+		//FIXME: check for certain anims, facing, etc, to make them lock into a sabers-locked pose
+		//SEF_LOCKED
+
+		if ( ent->client->ps.saberInFlight && saberNum == 0 &&
+			ent->client->ps.saber[saberNum].blade[bladeNum].active && 
+			ent->client->ps.saberEntityNum != ENTITYNUM_NONE &&
+			ent->client->ps.saberEntityState != SES_RETURNING )
+		{//saber was blocked, return it
+			inFlightSaberBlocked = qtrue;
+		}
+
+		//FIXME: based on strength, position and angle of attack & defense, decide if:
+		//	defender and attacker lock sabers
+		//	*defender's parry should hold and attack bounces (or deflects, based on angle of sabers)
+		//	*defender's parry is somewhat broken and both bounce (or deflect)
+		//	*defender's parry is broken and they bounce while attacker's attack deflects or carries through (especially if they're dead)
+		//	defender is knocked down and attack goes through
+
+		//Check deflections and broken parries
+		if ( hitOwner && hitOwner->health > 0 && ent->health > 0 //both are alive
+			&& !inFlightSaberBlocked && hitOwner->client && !hitOwner->client->ps.saberInFlight && !ent->client->ps.saberInFlight//both have sabers in-hand
+			&& ent->client->ps.saberBlocked != BLOCKED_PARRY_BROKEN 
+			&& ent->client->ps.saberLockTime < level.time
+			&& hitOwner->client->ps.saberLockTime < level.time )
+		{//2 in-hand sabers hit
+			//FIXME: defender should not parry or block at all if not in a saber anim... like, if in a roll or knockdown...
+			if ( baseDamage )
+			{//there is damage involved, not just effects
+				qboolean entAttacking = qfalse;
+				qboolean hitOwnerAttacking = qfalse;
+				qboolean entDefending = qfalse;
+				qboolean hitOwnerDefending = qfalse;
+				qboolean forceLock = qfalse;
+
+				if ( (ent->client->NPC_class == CLASS_KYLE && (ent->spawnflags&1) && hitOwner->s.number < MAX_CLIENTS )
+					|| (hitOwner->client->NPC_class == CLASS_KYLE && (hitOwner->spawnflags&1) && ent->s.number < MAX_CLIENTS ) )
+				{//Player vs. Kyle Boss == lots of saberlocks
+					if ( !Q_irand( 0, 2 ) )
+					{
+						forceLock = qtrue;
+					}
+				}
+				
+				if ( PM_SaberInAttack( ent->client->ps.saberMove ) || PM_SaberInSpecialAttack( ent->client->ps.torsoAnim ) )
+				{
+					entAttacking = qtrue;
+				}
+				else if ( entPowerLevel > FORCE_LEVEL_2 )
+				{//stronger styles count as attacking even if in a transition
+					if ( PM_SaberInTransitionAny( ent->client->ps.saberMove ) )
+					{
+						entAttacking = qtrue;
+					}
+				}
+				if ( PM_SaberInParry( ent->client->ps.saberMove ) 
+					|| ent->client->ps.saberMove == LS_READY )
+				{
+					entDefending = qtrue;
+				}
+
+				if ( ent->client->ps.torsoAnim == BOTH_A1_SPECIAL
+					|| ent->client->ps.torsoAnim == BOTH_A2_SPECIAL
+					|| ent->client->ps.torsoAnim == BOTH_A3_SPECIAL )
+				{//parry/block/break-parry bonus for single-style kata moves
+					entPowerLevel++;
+				}
+				if ( entAttacking )
+				{//add twoHanded bonus and breakParryBonus to entPowerLevel here
+					//This makes staff too powerful
+					if ( ent->client->ps.saber[saberNum].twoHanded )
+					{
+						entPowerLevel++;
+					}
+					//FIXME: what if dualSabers && both sabers are hitting at same time?
+					entPowerLevel += ent->client->ps.saber[saberNum].breakParryBonus;
+				}
+				else if ( entDefending )
+				{//add twoHanded bonus and dualSaber bonus and parryBonus to entPowerLevel here
+					if ( ent->client->ps.saber[saberNum].twoHanded 
+						|| (ent->client->ps.dualSabers && ent->client->ps.saber[1].Active()) )
+					{
+						entPowerLevel++;
+					}
+					//FIXME: what about second saber if dualSabers?
+					entPowerLevel += ent->client->ps.saber[saberNum].parryBonus;
+				}
+
+				if ( PM_SaberInAttack( hitOwner->client->ps.saberMove ) || PM_SaberInSpecialAttack( hitOwner->client->ps.torsoAnim ) )
+				{
+					hitOwnerAttacking = qtrue;
+				}
+				else if ( hitOwnerPowerLevel > FORCE_LEVEL_2 )
+				{//stronger styles count as attacking even if in a transition
+					if ( PM_SaberInTransitionAny( hitOwner->client->ps.saberMove ) )
+					{
+						hitOwnerAttacking = qtrue;
+					}
+				}
+				if ( PM_SaberInParry( hitOwner->client->ps.saberMove ) 
+					 || hitOwner->client->ps.saberMove == LS_READY )
+				{
+					hitOwnerDefending = qtrue;
+				}
+
+				if ( hitOwner->client->ps.torsoAnim == BOTH_A1_SPECIAL
+					|| hitOwner->client->ps.torsoAnim == BOTH_A2_SPECIAL
+					|| hitOwner->client->ps.torsoAnim == BOTH_A3_SPECIAL )
+				{//parry/block/break-parry bonus for single-style kata moves
+					hitOwnerPowerLevel++;
+				}
+				if ( hitOwnerAttacking )
+				{//add twoHanded bonus and breakParryBonus to entPowerLevel here
+					if ( hitOwner->client->ps.saber[0].twoHanded )
+					{
+						hitOwnerPowerLevel++;
+					}
+					hitOwnerPowerLevel += hitOwner->client->ps.saber[0].breakParryBonus;
+					if ( hitOwner->client->ps.dualSabers && Q_irand( 0, 1 ) )
+					{//FIXME: assumes both sabers are hitting at same time...?
+						hitOwnerPowerLevel += 1 + hitOwner->client->ps.saber[1].breakParryBonus;
+					}
+				}
+				else if ( hitOwnerDefending )
+				{//add twoHanded bonus and dualSaber bonus and parryBonus to entPowerLevel here
+					if ( hitOwner->client->ps.saber[0].twoHanded || (hitOwner->client->ps.dualSabers && hitOwner->client->ps.saber[1].Active()) )
+					{
+						hitOwnerPowerLevel++;
+					}
+					hitOwnerPowerLevel += hitOwner->client->ps.saber[0].parryBonus;
+					if ( hitOwner->client->ps.dualSabers && Q_irand( 0, 1 ) )
+					{//FIXME: assumes both sabers are defending at same time...?
+						hitOwnerPowerLevel += 1 + hitOwner->client->ps.saber[1].parryBonus;
+					}
+				}
+
+				if ( PM_SuperBreakLoseAnim( ent->client->ps.torsoAnim ) 
+					|| PM_SuperBreakWinAnim( ent->client->ps.torsoAnim ) 
+					|| PM_SuperBreakLoseAnim( hitOwner->client->ps.torsoAnim ) 
+					|| PM_SuperBreakWinAnim( hitOwner->client->ps.torsoAnim ) )
+				{//don't mess with this
+					collisionResolved = qtrue;
+				}
+				else if ( entAttacking 
+					&& hitOwnerAttacking 
+					&& !Q_irand( 0, g_saberLockRandomNess->integer )
+					&& ( g_debugSaberLock->integer || forceLock
+						|| entPowerLevel == hitOwnerPowerLevel 
+						|| (entPowerLevel > FORCE_LEVEL_2 && hitOwnerPowerLevel > FORCE_LEVEL_2 )
+						|| (entPowerLevel < FORCE_LEVEL_3 && hitOwnerPowerLevel < FORCE_LEVEL_3 && hitOwner->client->ps.forcePowerLevel[FP_SABER_OFFENSE] > FORCE_LEVEL_2 && Q_irand( 0, 3 ))
+						|| (entPowerLevel < FORCE_LEVEL_2 && hitOwnerPowerLevel < FORCE_LEVEL_3 && hitOwner->client->ps.forcePowerLevel[FP_SABER_OFFENSE] > FORCE_LEVEL_1 && Q_irand( 0, 2 ))
+						|| (hitOwnerPowerLevel < FORCE_LEVEL_3 && entPowerLevel < FORCE_LEVEL_3 && ent->client->ps.forcePowerLevel[FP_SABER_OFFENSE] > FORCE_LEVEL_2 && !Q_irand( 0, 1 ))
+						|| (hitOwnerPowerLevel < FORCE_LEVEL_2 && entPowerLevel < FORCE_LEVEL_3 && ent->client->ps.forcePowerLevel[FP_SABER_OFFENSE] > FORCE_LEVEL_1 && !Q_irand( 0, 1 )))
+					&& WP_SabersCheckLock( ent, hitOwner ) )
+				{
+					collisionResolved = qtrue;
+				}
+				else if ( hitOwnerAttacking 
+					&& entDefending 
+					&& !Q_irand( 0, g_saberLockRandomNess->integer*3 )
+					&& (g_debugSaberLock->integer || forceLock ||
+						((ent->client->ps.saberMove != LS_READY || (hitOwnerPowerLevel-ent->client->ps.forcePowerLevel[FP_SABER_DEFENSE]) < Q_irand( -6, 0 ) )
+							&& ((hitOwnerPowerLevel < FORCE_LEVEL_3 && ent->client->ps.forcePowerLevel[FP_SABER_DEFENSE] > FORCE_LEVEL_2 )||
+								(hitOwnerPowerLevel < FORCE_LEVEL_2 && ent->client->ps.forcePowerLevel[FP_SABER_DEFENSE] > FORCE_LEVEL_1 )||
+								(hitOwnerPowerLevel < FORCE_LEVEL_3 && ent->client->ps.forcePowerLevel[FP_SABER_DEFENSE] > FORCE_LEVEL_0 && !Q_irand( 0, (hitOwnerPowerLevel-ent->client->ps.forcePowerLevel[FP_SABER_DEFENSE]+1)*2 ))) ))
+					&& WP_SabersCheckLock( hitOwner, ent ) )
+				{
+					collisionResolved = qtrue;
+				}
+				else if ( entAttacking && hitOwnerDefending )
+				{//I'm attacking hit, they're parrying
+					qboolean activeDefense = (hitOwner->s.number||g_saberAutoBlocking->integer||hitOwner->client->ps.saberBlockingTime > level.time);
+					if ( !Q_irand( 0, g_saberLockRandomNess->integer*3 )
+						&& activeDefense
+						&& (g_debugSaberLock->integer || forceLock ||
+							((hitOwner->client->ps.saberMove != LS_READY || (entPowerLevel-hitOwner->client->ps.forcePowerLevel[FP_SABER_DEFENSE]) < Q_irand( -6, 0 ) )
+								&& ( ( entPowerLevel < FORCE_LEVEL_3 && hitOwner->client->ps.forcePowerLevel[FP_SABER_DEFENSE] > FORCE_LEVEL_2 )
+									|| ( entPowerLevel < FORCE_LEVEL_2 && hitOwner->client->ps.forcePowerLevel[FP_SABER_DEFENSE] > FORCE_LEVEL_1 )
+									|| ( entPowerLevel < FORCE_LEVEL_3 && hitOwner->client->ps.forcePowerLevel[FP_SABER_DEFENSE] > FORCE_LEVEL_0 && !Q_irand( 0, (entPowerLevel-hitOwner->client->ps.forcePowerLevel[FP_SABER_DEFENSE]+1)*2 )) )  ))
+						&& WP_SabersCheckLock( ent, hitOwner ) )
+					{
+						collisionResolved = qtrue;
+					}
+					else if ( saberHitFraction < 1.0f )
+					{//an actual collision
+						if ( entPowerLevel < FORCE_LEVEL_3 && activeDefense )
+						{//strong attacks cannot be deflected
+							//based on angle of attack & angle of defensive saber, see if I should deflect off in another dir rather than bounce back
+							deflected = WP_GetSaberDeflectionAngle( ent, hitOwner );
+							//just so Jedi knows that he was blocked
+							ent->client->ps.saberEventFlags |= SEF_BLOCKED;
+						}
+						//base parry breaks on animation (saber attack level), not FP_SABER_OFFENSE
+						if ( entPowerLevel < FORCE_LEVEL_3 
+							//&& ent->client->ps.forcePowerLevel[FP_SABER_OFFENSE] < FORCE_LEVEL_3//if you have high saber offense, you cannot have your attack knocked away, regardless of what style you're using?
+							//&& hitOwner->client->ps.saberAnimLevel != FORCE_LEVEL_5 
+							&& activeDefense
+							&& (hitOwnerPowerLevel > FORCE_LEVEL_2||(hitOwner->client->ps.forcePowerLevel[FP_SABER_DEFENSE]>FORCE_LEVEL_2&&Q_irand(0,hitOwner->client->ps.forcePowerLevel[FP_SABER_OFFENSE]))) )
+						{//knockaways can make fast-attacker go into a broken parry anim if the ent is using fast or med (but not Tavion)
+							//make me parry
+							WP_SaberParry( hitOwner, ent );
+							//turn the parry into a knockaway
+							hitOwner->client->ps.saberBounceMove = PM_KnockawayForParry( hitOwner->client->ps.saberBlocked );
+							//make them go into a broken parry
+							ent->client->ps.saberBounceMove = PM_BrokenParryForAttack( ent->client->ps.saberMove );
+							ent->client->ps.saberBlocked = BLOCKED_PARRY_BROKEN;
+							if ( saberNum == 0 )
+							{//FIXME: can only lose right-hand saber for now
+								if ( ent->client->ps.saber[saberNum].disarmable 
+									&& ent->client->ps.forcePowerLevel[FP_SABER_DEFENSE] < FORCE_LEVEL_2 
+									//&& (ent->s.number||g_saberRealisticCombat->integer) 
+									&& Q_irand( 0, hitOwner->client->ps.SaberDisarmBonus() ) > 0 
+									&& (hitOwner->s.number || g_saberAutoBlocking->integer || !Q_irand( 0, 2 )) )//if player defending and autoblocking is on, this is less likely to happen, so don't do the random check
+								{//knocked the saber right out of his hand! (never happens to player)
+									//Get a good velocity to send the saber in based on my parry move
+									vec3_t	throwDir;
+									if ( !PM_VelocityForBlockedMove( &hitOwner->client->ps, throwDir ) )
+									{
+										PM_VelocityForSaberMove( &ent->client->ps, throwDir );
+									}
+									WP_SaberLose( ent, throwDir );
+								}
+							}
+							//just so Jedi knows that he was blocked
+							ent->client->ps.saberEventFlags |= SEF_BLOCKED;
+#ifndef FINAL_BUILD
+							if ( d_saberCombat->integer )
+							{
+								gi.Printf( S_COLOR_RED"%s knockaway %s's attack, new move = %s, anim = %s\n", hitOwner->NPC_type, ent->NPC_type, saberMoveData[ent->client->ps.saberBounceMove].name, animTable[saberMoveData[ent->client->ps.saberBounceMove].animToUse].name );
+							}
+#endif
+						}
+						else if ( !activeDefense//they're not defending
+							|| (entPowerLevel > FORCE_LEVEL_2 //I hit hard
+								&& hitOwnerPowerLevel < entPowerLevel)//they are defending, but their defense strength is lower than my attack...
+							|| (!deflected && Q_irand( 0, PM_PowerLevelForSaberAnim( &ent->client->ps, saberNum ) - hitOwner->client->ps.forcePowerLevel[FP_SABER_DEFENSE]/*PM_PowerLevelForSaberAnim( &hitOwner->client->ps )*/ ) > 0 ) )
+						{//broke their parry altogether
+							if ( entPowerLevel > FORCE_LEVEL_2 || Q_irand( 0, ent->client->ps.forcePowerLevel[FP_SABER_OFFENSE] - hitOwner->client->ps.forcePowerLevel[FP_SABER_DEFENSE] ) )
+							{//chance of continuing with the attack (not bouncing back)
+								ent->client->ps.saberEventFlags &= ~SEF_BLOCKED;
+								ent->client->ps.saberBounceMove = LS_NONE;
+								brokenParry = qtrue;
+							}
+							//do some time-consuming saber-knocked-aside broken parry anim
+							hitOwner->client->ps.saberBlocked = BLOCKED_PARRY_BROKEN;
+							hitOwner->client->ps.saberBounceMove = LS_NONE;
+							//FIXME: for now, you always disarm the right-hand saber
+							if ( hitOwner->client->ps.saber[0].disarmable
+								&& hitOwner->client->ps.forcePowerLevel[FP_SABER_DEFENSE] < FORCE_LEVEL_2 
+								//&& (ent->s.number||g_saberRealisticCombat->integer)
+								&& Q_irand( 0, 2-ent->client->ps.SaberDisarmBonus() ) <= 0 )
+							{//knocked the saber right out of his hand!
+								//get the right velocity for my attack direction
+								vec3_t	throwDir;
+								PM_VelocityForSaberMove( &ent->client->ps, throwDir );
+								WP_SaberLose( hitOwner, throwDir );
+								if ( (ent->client->ps.saberAnimLevel == SS_STRONG && !Q_irand(0,3) ) 
+									|| ( ent->client->ps.saberAnimLevel==SS_DESANN&&!Q_irand(0,1) ) )
+								{// a strong attack
+									if ( WP_BrokenParryKnockDown( hitOwner ) )
+									{
+										hitOwner->client->ps.saberBlocked = BLOCKED_NONE;
+										hitOwner->client->ps.saberBounceMove = LS_NONE;
+									}
+								}
+							}
+							else
+							{
+								if ( (ent->client->ps.saberAnimLevel == SS_STRONG && !Q_irand(0,5) ) 
+									|| ( ent->client->ps.saberAnimLevel==SS_DESANN&&!Q_irand(0,3) ) )
+								{// a strong attack
+									if ( WP_BrokenParryKnockDown( hitOwner ) )
+									{
+										hitOwner->client->ps.saberBlocked = BLOCKED_NONE;
+										hitOwner->client->ps.saberBounceMove = LS_NONE;
+									}
+								}
+							}
+#ifndef FINAL_BUILD
+							if ( d_saberCombat->integer )
+							{
+								if ( ent->client->ps.saberEventFlags&SEF_BLOCKED )
+								{
+									gi.Printf( S_COLOR_RED"%s parry broken (bounce/deflect)!\n", hitOwner->targetname );
+								}
+								else
+								{
+									gi.Printf( S_COLOR_RED"%s parry broken (follow-through)!\n", hitOwner->targetname );
+								}
+							}
+#endif
+						}
+						else
+						{//just a parry, possibly the hitOwner can knockaway the ent
+							WP_SaberParry( hitOwner, ent );
+							if ( PM_SaberInBounce( ent->client->ps.saberMove ) //FIXME: saberMove not set until pmove!
+								&& activeDefense
+								&& hitOwner->client->ps.saberAnimLevel != SS_FAST //&& hitOwner->client->ps.saberAnimLevel != FORCE_LEVEL_5
+								&& hitOwner->client->ps.forcePowerLevel[FP_SABER_DEFENSE] > FORCE_LEVEL_2 )
+							{//attacker bounced off, and defender has ability to do knockaways, so do one unless we're using fast attacks
+								//turn the parry into a knockaway
+								hitOwner->client->ps.saberBounceMove = PM_KnockawayForParry( hitOwner->client->ps.saberBlocked );
+							}
+							else if ( (ent->client->ps.saberAnimLevel == SS_STRONG && !Q_irand(0,6) ) 
+									|| ( ent->client->ps.saberAnimLevel==SS_DESANN && !Q_irand(0,3) ) )
+							{// a strong attack can sometimes do a knockdown
+								//HMM... maybe only if they're moving backwards?
+								if ( WP_BrokenParryKnockDown( hitOwner ) )
+								{
+									hitOwner->client->ps.saberBlocked = BLOCKED_NONE;
+									hitOwner->client->ps.saberBounceMove = LS_NONE;
+								}
+							}
+						}
+						collisionResolved = qtrue;
+					}
+				}
+				/*
+				else if ( entDefending && hitOwnerAttacking )
+				{//I'm parrying, they're attacking
+					if ( hitOwnerPowerLevel < FORCE_LEVEL_3 )
+					{//strong attacks cannot be deflected
+						//based on angle of attack & angle of defensive saber, see if I should deflect off in another dir rather than bounce back
+						deflected = WP_GetSaberDeflectionAngle( hitOwner, ent );
+						//just so Jedi knows that he was blocked
+						hitOwner->client->ps.saberEventFlags |= SEF_BLOCKED;
+					}
+					//FIXME: base parry breaks on animation (saber attack level), not FP_SABER_OFFENSE
+					if ( hitOwnerPowerLevel > FORCE_LEVEL_2 || (!deflected && Q_irand( 0, PM_PowerLevelForSaberAnim( &hitOwner->client->ps ) - ent->client->ps.forcePowerLevel[FP_SABER_DEFENSE] ) > 0 ) )
+					{//broke my parry altogether
+						if ( hitOwnerPowerLevel > FORCE_LEVEL_2 || Q_irand( 0, hitOwner->client->ps.forcePowerLevel[FP_SABER_OFFENSE] - ent->client->ps.forcePowerLevel[FP_SABER_DEFENSE] ) )
+						{//chance of continuing with the attack (not bouncing back)
+							hitOwner->client->ps.saberEventFlags &= ~SEF_BLOCKED;
+							hitOwner->client->ps.saberBounceMove = LS_NONE;
+						}
+						//do some time-consuming saber-knocked-aside broken parry anim
+						ent->client->ps.saberBlocked = BLOCKED_PARRY_BROKEN;
+#ifndef FINAL_BUILD
+						if ( d_saberCombat->integer )
+						{
+							if ( hitOwner->client->ps.saberEventFlags&SEF_BLOCKED )
+							{
+								gi.Printf( S_COLOR_RED"%s parry broken (bounce/deflect)!\n", ent->targetname );
+							}
+							else
+							{
+								gi.Printf( S_COLOR_RED"%s parry broken (follow-through)!\n", ent->targetname );
+							}
+						}
+#endif
+					}
+					else
+					{
+						WP_SaberParry( ent, hitOwner );
+					}
+					collisionResolved = qtrue;
+				}
+				*/
+				else
+				{//some other kind of in-hand saber collision
+				}
+			}
+		}
+		else
+		{//some kind of in-flight collision
+		}
+
+		if ( saberHitFraction < 1.0f )
+		{
+			if ( !collisionResolved && baseDamage )
+			{//some other kind of in-hand saber collision
+				//handle my reaction
+				if ( !ent->client->ps.saberInFlight 
+					&& ent->client->ps.saberLockTime < level.time )
+				{//my saber is in hand
+					if ( ent->client->ps.saberBlocked != BLOCKED_PARRY_BROKEN )
+					{
+						if ( PM_SaberInAttack( ent->client->ps.saberMove ) || PM_SaberInSpecialAttack( ent->client->ps.torsoAnim ) ||
+							(entPowerLevel > FORCE_LEVEL_2&&!PM_SaberInIdle(ent->client->ps.saberMove)&&!PM_SaberInParry(ent->client->ps.saberMove)&&!PM_SaberInReflect(ent->client->ps.saberMove)) )
+						{//in the middle of attacking
+							if ( entPowerLevel < FORCE_LEVEL_3 && hitOwner->health > 0 )
+							{//don't deflect/bounce in strong attack or when enemy is dead
+								WP_GetSaberDeflectionAngle( ent, hitOwner );
+								ent->client->ps.saberEventFlags |= SEF_BLOCKED;
+								//since it was blocked/deflected, take away any damage done
+								//FIXME: what if the damage was done before the parry?
+								WP_SaberClearDamageForEntNum( hitOwner->s.number );
+							}
+						}
+						else
+						{//saber collided when not attacking, parry it
+							//since it was blocked/deflected, take away any damage done
+							//FIXME: what if the damage was done before the parry?
+							WP_SaberClearDamageForEntNum( hitOwner->s.number );
+							/*
+							if ( ent->s.number || g_saberAutoBlocking->integer || ent->client->ps.saberBlockingTime > level.time )
+							{//either an NPC or a player who has blocking
+								if ( !PM_SaberInTransitionAny( ent->client->ps.saberMove ) && !PM_SaberInBounce( ent->client->ps.saberMove ) )
+								{//I'm not attacking, in transition or in a bounce, so play a parry
+									//just so Jedi knows that he parried something
+									WP_SaberBlockNonRandom( ent, saberHitLocation, qfalse );
+								}
+								ent->client->ps.saberEventFlags |= SEF_PARRIED;
+							}
+							*/
+						}
+					}
+					else
+					{
+						//since it was blocked/deflected, take away any damage done
+						//FIXME: what if the damage was done before the parry?
+						WP_SaberClearDamageForEntNum( hitOwner->s.number );
+					}
+				}
+				else
+				{//nothing happens to *me* when my inFlight saber hits something
+				}
+				//handle their reaction
+				if ( hitOwner 
+					&& hitOwner->health > 0 
+					&& hitOwner->client 
+					&& !hitOwner->client->ps.saberInFlight 
+					&& hitOwner->client->ps.saberLockTime < level.time )
+				{//their saber is in hand
+					if ( PM_SaberInAttack( hitOwner->client->ps.saberMove ) || PM_SaberInSpecialAttack( hitOwner->client->ps.torsoAnim ) ||
+						(hitOwner->client->ps.saberAnimLevel > SS_MEDIUM&&!PM_SaberInIdle(hitOwner->client->ps.saberMove)&&!PM_SaberInParry(hitOwner->client->ps.saberMove)&&!PM_SaberInReflect(hitOwner->client->ps.saberMove)) )
+					{//in the middle of attacking
+						/*
+						if ( hitOwner->client->ps.saberAnimLevel < SS_STRONG )
+						{//don't deflect/bounce in strong attack
+							WP_GetSaberDeflectionAngle( hitOwner, ent );
+							hitOwner->client->ps.saberEventFlags |= SEF_BLOCKED;
+						}
+						*/
+					}
+					else
+					{//saber collided when not attacking, parry it
+						if ( !PM_SaberInBrokenParry( hitOwner->client->ps.saberMove ) )
+						{//not currently in a broken parry
+							if ( !WP_SaberParry( hitOwner, ent ) )
+							{//FIXME: hitOwner can't parry, do some time-consuming saber-knocked-aside broken parry anim?
+								//hitOwner->client->ps.saberBlocked = BLOCKED_PARRY_BROKEN;
+							}
+						}
+					}
+				}
+				else
+				{//nothing happens to *hitOwner* when their inFlight saber hits something
+				}
+			}
+
+			//collision must have been handled by now
+			//Set the blocked attack bounce value in saberBlocked so we actually play our saberBounceMove anim
+			if ( ent->client->ps.saberEventFlags & SEF_BLOCKED )
+			{
+				if ( ent->client->ps.saberBlocked != BLOCKED_PARRY_BROKEN )
+				{
+					ent->client->ps.saberBlocked = BLOCKED_ATK_BOUNCE;
+				}
+			}
+			/*
+			if ( hitOwner && hitOwner->client->ps.saberEventFlags & SEF_BLOCKED )
+			{
+				hitOwner->client->ps.saberBlocked = BLOCKED_ATK_BOUNCE;
+			}
+			*/
+		}
+
+		if ( saberHitFraction < 1.0f || collisionResolved )
+		{//either actually hit or locked
+			if ( ent->client->ps.saberLockTime < level.time )
+			{
+				if ( inFlightSaberBlocked )
+				{//FIXME: never hear this sound
+					G_Sound( &g_entities[ent->client->ps.saberEntityNum], G_SoundIndex( va( "sound/weapons/saber/saberbounce%d.wav", Q_irand(1,3) ) ) );
+				}
+				else
+				{
+					if ( deflected )
+					{
+#ifdef _IMMERSION
+						int index = Q_irand(1,3);
+						G_Sound( ent, G_SoundIndex( va("sound/weapons/saber/saberbounce%d.wav", index) ) );
+						int ff = G_ForceIndex( va("fffx/weapons/saber/saberbounce%d", index), FF_CHANNEL_WEAPON );
+						if ( !ent->s.saberInFlight )
+						{
+							G_Force( ent, ff );
+						}
+						if ( hitOwner && !hitOwner->s.saberInFlight )
+						{
+							G_Force( hitOwner, ff );
+						}
+#else
+						G_Sound( ent, G_SoundIndex( va( "sound/weapons/saber/saberbounce%d.wav", Q_irand(1,3) ) ) );
+#endif // _IMMERSION
+					}
+					else
+					{
+#ifdef _IMMERSION
+						int index = Q_irand(1, 9);
+						G_Sound( ent, G_SoundIndex( va( "sound/weapons/saber/saberblock%d.wav", index) ) );
+						int ff = G_ForceIndex( va("fffx/weapons/saber/saberblock%d", index), FF_CHANNEL_WEAPON );
+						if ( !ent->s.saberInFlight )
+						{
+							G_Force( ent, ff );
+						}
+						if ( hitOwner && !hitOwner->s.saberInFlight )
+						{
+							G_Force( hitOwner, ff );
+						}
+#else
+						G_Sound( ent, G_SoundIndex( va( "sound/weapons/saber/saberblock%d.wav", Q_irand(1, 9) ) ) );
+#endif // _IMMERSION
+					}
+				}
+				if ( !g_saberNoEffects )
+				{
+					G_PlayEffect( "saber/saber_block", saberHitLocation, saberHitNormal );
+				}
+			}
+			// Set the little screen flash - only when an attack is blocked
+			g_saberFlashTime = level.time-50;
+			VectorCopy( saberHitLocation, g_saberFlashPos );
+		}
+
+		if ( saberHitFraction < 1.0f )
+		{
+			if ( inFlightSaberBlocked )
+			{//we threw a saber and it was blocked, do any effects, etc.
+				int	knockAway = 5;
+				if ( hitEnt 
+					&& hitOwner 
+					&& hitOwner->client 
+					&& (PM_SaberInAttack( hitOwner->client->ps.saberMove ) || PM_SaberInSpecialAttack( hitOwner->client->ps.torsoAnim ) || PM_SpinningSaberAnim( hitOwner->client->ps.torsoAnim )) )
+				{//if hit someone who was in an attack or spin anim, more likely to have in-flight saber knocked away
+					if ( hitOwnerPowerLevel > FORCE_LEVEL_2 )
+					{//strong attacks almost always knock it aside!
+						knockAway = 1;
+					}
+					else
+					{//33% chance
+						knockAway = 2;
+					}
+					knockAway -= hitOwner->client->ps.SaberDisarmBonus();
+				}
+				if ( Q_irand( 0, knockAway ) <= 0 || //random
+						( hitOwner 
+							&& hitOwner->client 
+							&& hitOwner->NPC 
+							&& (hitOwner->NPC->aiFlags&NPCAI_BOSS_CHARACTER)
+						) //or if blocked by a Boss character FIXME: or base on defense level?
+					)//FIXME: player should not auto-block a flying saber, let him override the parry with an attack to knock the saber from the air, rather than this random chance
+				{//knock it aside and turn it off
+					if ( !g_saberNoEffects )
+					{
+						G_PlayEffect( "saber/saber_cut", saberHitLocation, saberHitNormal );
+					}
+					if ( hitEnt )
+					{
+						vec3_t newDir;
+
+						VectorSubtract( g_entities[ent->client->ps.saberEntityNum].currentOrigin, hitEnt->currentOrigin, newDir );
+						VectorNormalize( newDir );
+						G_ReflectMissile( ent, &g_entities[ent->client->ps.saberEntityNum], newDir );
+					}
+					Jedi_PlayDeflectSound( hitOwner );
+					WP_SaberDrop( ent, &g_entities[ent->client->ps.saberEntityNum] );
+				}
+				else
+				{
+					if ( !Q_irand( 0, 2 ) && hitEnt )
+					{
+						vec3_t newDir;
+						VectorSubtract( g_entities[ent->client->ps.saberEntityNum].currentOrigin, hitEnt->currentOrigin, newDir );
+						VectorNormalize( newDir );
+						G_ReflectMissile( ent, &g_entities[ent->client->ps.saberEntityNum], newDir );
+					}
+					WP_SaberReturn( ent, &g_entities[ent->client->ps.saberEntityNum] );
+				}
+			}
+		}
+	}
+
+	if ( ent->client->ps.saberLockTime > level.time 
+		&& ent->s.number < ent->client->ps.saberLockEnemy 
+		&& !Q_irand( 0, 3 ) )
+	{//need to make some kind of effect
+		vec3_t	hitNorm = {0,0,1};
+		if ( WP_SabersIntersection( ent, &g_entities[ent->client->ps.saberLockEnemy], g_saberFlashPos ) )
+		{
+			if ( Q_irand( 0, 10 ) )
+			{
+				if ( !g_saberNoEffects )
+				{
+					G_PlayEffect( "saber/saber_block", g_saberFlashPos, hitNorm );
+				}
+			}
+			else
+			{
+				g_saberFlashTime = level.time-50;
+				if ( !g_saberNoEffects )
+				{
+					G_PlayEffect( "saber/saber_cut", g_saberFlashPos, hitNorm );
+				}
+			}
+#ifdef _IMMERSION
+			int index = Q_irand(1, 9);
+			G_Sound( ent, G_SoundIndex( va( "sound/weapons/saber/saberblock%d.wav", index ) ) );
+			int ff = G_ForceIndex( va("fffx/weapons/saber/saberblock%d", index), FF_CHANNEL_WEAPON );
+			if ( !ent->s.saberInFlight )
+			{
+				G_Force( ent, ff );
+			}
+			if ( !g_entities[ent->client->ps.saberLockEnemy].s.saberInFlight )
+			{
+				G_Force( &g_entities[ent->client->ps.saberLockEnemy], ff );
+			}
+#else
+			G_Sound( ent, G_SoundIndex( va( "sound/weapons/saber/saberblock%d.wav", Q_irand(1, 9) ) ) );
+#endif // _IMMERSION
+		}
+	}
+
+	if ( WP_SaberApplyDamage( ent, baseDamage, baseDFlags, brokenParry, ent->client->ps.saber[saberNum].type, (qboolean)(saberNum==0&&ent->client->ps.saberInFlight) ) )
+	{//actually did damage to something
+#ifndef FINAL_BUILD
+		if ( d_saberCombat->integer )
+		{
+			gi.Printf( "base damage was %4.2f\n", baseDamage );
+		}
+#endif
+		WP_SaberHitSound( ent, saberNum );
+	}
+	
+	if ( hit_wall )
+	{
+		//just so Jedi knows that he hit a wall
+		ent->client->ps.saberEventFlags |= SEF_HITWALL;
+		if ( ent->s.number == 0 )
+		{
+			AddSoundEvent( ent, ent->currentOrigin, 128, AEL_DISCOVERED, qfalse, qtrue );//FIXME: is this impact on ground or not?
+			AddSightEvent( ent, ent->currentOrigin, 256, AEL_DISCOVERED, 50 );
+		}
+	}
+}
+
+void WP_SabersDamageTrace( gentity_t *ent, qboolean noEffects )
+{
+	if ( !ent->client )
+	{
+		return;
+	}
+	if ( PM_SuperBreakLoseAnim( ent->client->ps.torsoAnim ) )
+	{
+		return;
+	}
+	// Saber 1.
+	g_saberNoEffects = noEffects;
+	for ( int i = 0; i < ent->client->ps.saber[0].numBlades; i++ )
+	{
+		// If the Blade is not active and the length is 0, don't trace it, try the next blade...
+		if ( !ent->client->ps.saber[0].blade[i].active && ent->client->ps.saber[0].blade[i].length == 0 )
+			continue;
+
+		if ( i != 0 )
+		{//not first blade
+			if ( ent->client->ps.saber[0].type == SABER_BROAD || 
+				ent->client->ps.saber[0].type == SABER_SAI || 
+				ent->client->ps.saber[0].type == SABER_CLAW )
+			{
+				g_saberNoEffects = qtrue;
+			}
+		}
+		WP_SaberDamageTrace( ent, 0, i );
+	}
+	// Saber 2.
+	g_saberNoEffects = noEffects;
+	if ( ent->client->ps.dualSabers )
+	{
+		for ( int i = 0; i < ent->client->ps.saber[1].numBlades; i++ )
+		{
+			// If the Blade is not active and the length is 0, don't trace it, try the next blade...
+			if ( !ent->client->ps.saber[1].blade[i].active && ent->client->ps.saber[1].blade[i].length == 0 )
+				continue;
+
+			if ( i != 0 )
+			{//not first blade
+				if ( ent->client->ps.saber[1].type == SABER_BROAD || 
+					ent->client->ps.saber[1].type == SABER_SAI || 
+					ent->client->ps.saber[1].type == SABER_CLAW )
+				{
+					g_saberNoEffects = qtrue;
+				}
+			}
+			WP_SaberDamageTrace( ent, 1, i );
+		}
+	}
+	g_saberNoEffects = qfalse;
+}
+
+//SABER THROWING============================================================================
+//SABER THROWING============================================================================
+//SABER THROWING============================================================================
+//SABER THROWING============================================================================
+//SABER THROWING============================================================================
+//SABER THROWING============================================================================
+
+/*
+================
+WP_SaberImpact
+
+================
+*/
+void WP_SaberImpact( gentity_t *owner, gentity_t *saber, trace_t *trace ) 
+{
+	gentity_t		*other;
+
+	other = &g_entities[trace->entityNum];
+
+	if ( other->takedamage && (other->svFlags&SVF_BBRUSH) )
+	{//a breakable brush?  break it!
+		if ( (other->spawnflags&1)//INVINCIBLE
+			||(other->flags&FL_DMG_BY_HEAVY_WEAP_ONLY) )//HEAVY weapon damage only
+		{//can't actually break it
+			//no hit effect (besides regular client-side one)
+		}
+		else if ( other->NPC_targetname && 
+			(!owner||!owner->targetname||Q_stricmp(owner->targetname,other->NPC_targetname)) ) 
+		{//only breakable by an entity who is not the attacker
+			//no hit effect (besides regular client-side one)
+		}
+		else
+		{
+			vec3_t dir;
+			VectorCopy( saber->s.pos.trDelta, dir );
+			VectorNormalize( dir );
+
+			int dmg = other->health*2;
+			if ( other->health > 50 && dmg > 20 && !(other->svFlags&SVF_GLASS_BRUSH) )
+			{
+				dmg = 20;
+			}
+			G_Damage( other, saber, owner, dir, trace->endpos, dmg, 0, MOD_SABER );
+			G_PlayEffect( "saber/saber_cut", trace->endpos, dir );
+			if ( owner->s.number == 0 )
+			{
+				AddSoundEvent( owner, trace->endpos, 256, AEL_DISCOVERED );
+				AddSightEvent( owner, trace->endpos, 512, AEL_DISCOVERED, 50 );
+			}
+			return;		
+		}
+	}
+
+	if ( saber->s.pos.trType == TR_LINEAR )
+	{
+		//hit a wall? send it back
+		WP_SaberReturn( saber->owner, saber );
+	}
+
+	if ( other && !other->client && (other->contents&CONTENTS_LIGHTSABER) )//&& other->s.weapon == WP_SABER )
+	{//2 in-flight sabers collided!
+		//Big flash
+		//FIXME: bigger effect/sound?
+		//FIXME: STILL DOESNT WORK!!!
+		G_Sound( saber, G_SoundIndex( va( "sound/weapons/saber/saberblock%d.wav", Q_irand(1, 9) ) ) );
+		G_PlayEffect( "saber/saber_block", trace->endpos );
+		g_saberFlashTime = level.time-50;
+		VectorCopy( trace->endpos, g_saberFlashPos );
+	}
+
+	if ( owner && owner->s.number == 0 && owner->client ) 
+	{
+		//Add the event
+		if ( owner->client->ps.SaberLength() > 0 )
+		{//saber is on, very suspicious
+			if ( (!owner->client->ps.saberInFlight && owner->client->ps.groundEntityNum == ENTITYNUM_WORLD)//holding saber and on ground
+				|| saber->s.pos.trType == TR_STATIONARY )//saber out there somewhere and on ground
+			{//an on-ground alert
+				AddSoundEvent( owner, saber->currentOrigin, 128, AEL_DISCOVERED, qfalse, qtrue );
+			}
+			else
+			{//an in-air alert
+				AddSoundEvent( owner, saber->currentOrigin, 128, AEL_DISCOVERED );
+			}
+			AddSightEvent( owner, saber->currentOrigin, 256, AEL_DISCOVERED, 50 );
+		}
+		else
+		{//saber is off, not as suspicious
+			AddSoundEvent( owner, saber->currentOrigin, 128, AEL_SUSPICIOUS );
+			AddSightEvent( owner, saber->currentOrigin, 256, AEL_SUSPICIOUS );
+		}
+	}
+
+	// check for bounce
+	if ( !other->takedamage && ( saber->s.eFlags & ( EF_BOUNCE | EF_BOUNCE_HALF ) ) ) 
+	{
+		// Check to see if there is a bounce count
+		if ( saber->bounceCount ) {
+			// decrement number of bounces and then see if it should be done bouncing
+			if ( --saber->bounceCount <= 0 ) {
+				// He (or she) will bounce no more (after this current bounce, that is).
+				saber->s.eFlags &= !( EF_BOUNCE | EF_BOUNCE_HALF );
+				if ( saber->s.pos.trType == TR_LINEAR && owner && owner->client && owner->client->ps.saberEntityState == SES_RETURNING )
+				{
+					WP_SaberDrop( saber->owner, saber );
+				}
+				return;
+			}
+			else 
+			{//bounced and still have bounces left
+				if ( saber->s.pos.trType == TR_LINEAR && owner && owner->client && owner->client->ps.saberEntityState == SES_RETURNING )
+				{//under telekinetic control
+					if ( !gi.inPVS( saber->currentOrigin, owner->client->renderInfo.handRPoint ) )
+					{//not in the PVS of my master
+						saber->bounceCount -= 25;
+					}
+				}
+			}
+		}
+
+		if ( saber->s.pos.trType == TR_LINEAR && owner && owner->client && owner->client->ps.saberEntityState == SES_RETURNING )
+		{
+			//don't home for a few frames so we can get around this thing
+			trace_t	bounceTr;
+			vec3_t	end;
+			float owner_dist = Distance( owner->client->renderInfo.handRPoint, saber->currentOrigin );
+
+			VectorMA( saber->currentOrigin, 10, trace->plane.normal, end );
+			gi.trace( &bounceTr, saber->currentOrigin, saber->mins, saber->maxs, end, owner->s.number, saber->clipmask );
+			VectorCopy( bounceTr.endpos, saber->currentOrigin );
+			if ( owner_dist > 0 )
+			{
+				if ( owner_dist > 50 )
+				{
+					owner->client->ps.saberEntityDist = owner_dist-50;
+				}
+				else
+				{
+					owner->client->ps.saberEntityDist = 0;
+				}
+			}
+			return;
+		}
+		
+		G_BounceMissile( saber, trace );
+		
+		if ( saber->s.pos.trType == TR_GRAVITY )
+		{//bounced
+			//play a bounce sound
+			if ( owner
+				&& owner->client
+				&& owner->client->ps.saber[0].type == SABER_SITH_SWORD )
+			{
+				G_Sound( saber, G_SoundIndex( va( "sound/weapons/sword/fall%d.wav", Q_irand( 1, 7 ) ) ) );
+			}
+			else
+			{
+				G_Sound( saber, G_SoundIndex( va( "sound/weapons/saber/bounce%d.wav", Q_irand( 1, 3 ) ) ) );
+			}
+			//change rotation
+			VectorCopy( saber->currentAngles, saber->s.apos.trBase );
+			saber->s.apos.trType = TR_LINEAR;
+			saber->s.apos.trTime = level.time;
+			VectorSet( saber->s.apos.trDelta, Q_irand( -300, 300 ), Q_irand( -300, 300 ), Q_irand( -300, 300 ) );
+		}
+		//see if we stopped
+		else if ( saber->s.pos.trType == TR_STATIONARY )
+		{//stopped
+			//play a bounce sound
+			if ( owner
+				&& owner->client
+				&& owner->client->ps.saber[0].type == SABER_SITH_SWORD )
+			{
+				G_Sound( saber, G_SoundIndex( va( "sound/weapons/sword/fall%d.wav", Q_irand( 1, 7 ) ) ) );
+			}
+			else
+			{
+				G_Sound( saber, G_SoundIndex( va( "sound/weapons/saber/bounce%d.wav", Q_irand( 1, 3 ) ) ) );
+			}
+			//stop rotation
+			VectorClear( saber->s.apos.trDelta );
+			saber->currentAngles[0] = SABER_PITCH_HACK;
+			VectorCopy( saber->currentAngles, saber->s.apos.trBase );
+			//remember when it fell so it can return automagically
+			saber->aimDebounceTime = level.time;
+		}
+	}
+	else if ( other->client && other->health > 0 
+		&& ( (other->NPC && (other->NPC->aiFlags&NPCAI_BOSS_CHARACTER))
+			//|| other->client->NPC_class == CLASS_ALORA 
+			|| other->client->NPC_class == CLASS_BOBAFETT 
+			|| ( other->client->ps.powerups[PW_GALAK_SHIELD] > 0 ) ) )
+	{//Luke, Desann and Tavion slap thrown sabers aside
+		WP_SaberDrop( owner, saber );
+		G_Sound( saber, G_SoundIndex( va( "sound/weapons/saber/saberblock%d.wav", Q_irand(1, 9) ) ) );
+		G_PlayEffect( "saber/saber_block", trace->endpos );
+		g_saberFlashTime = level.time-50;
+		VectorCopy( trace->endpos, g_saberFlashPos );
+		//FIXME: make Luke/Desann/Tavion play an attack anim or some other special anim when this happens
+		Jedi_PlayDeflectSound( other );
+	}
+}
+
+extern float G_PointDistFromLineSegment( const vec3_t start, const vec3_t end, const vec3_t from );
+void WP_SaberInFlightReflectCheck( gentity_t *self, usercmd_t *ucmd  )
+{
+	gentity_t	*ent;
+	gentity_t	*entityList[MAX_GENTITIES];
+	gentity_t	*missile_list[MAX_GENTITIES];
+	int			numListedEntities;
+	vec3_t		mins, maxs;
+	int			i, e, numSabers;
+	int			ent_count = 0;
+	int			radius = 180;
+	vec3_t		center;
+	vec3_t		tip;
+	vec3_t		up = {0,0,1};
+	qboolean	willHit = qfalse;
+
+	if ( self->NPC && (self->NPC->scriptFlags&SCF_IGNORE_ALERTS) )
+	{//don't react to things flying at me...
+		return;
+	}
+	//sanity checks: make sure we actually have a saberent
+	if ( self->client->ps.weapon != WP_SABER )
+	{
+		return;
+	}
+	if ( !self->client->ps.saberInFlight )
+	{
+		return;
+	}
+	if ( !self->client->ps.SaberLength() )
+	{
+		return;
+	}
+	if ( self->client->ps.saberEntityNum == ENTITYNUM_NONE )
+	{
+		return;
+	}
+	gentity_t *saberent = &g_entities[self->client->ps.saberEntityNum];
+	if ( !saberent )
+	{
+		return;
+	}
+	//okay, enough damn sanity checks
+
+	VectorCopy( saberent->currentOrigin, center );
+
+	for ( i = 0 ; i < 3 ; i++ ) 
+	{
+		mins[i] = center[i] - radius;
+		maxs[i] = center[i] + radius;
+	}
+
+	numListedEntities = gi.EntitiesInBox( mins, maxs, entityList, MAX_GENTITIES );
+
+	//FIXME: check visibility?
+	for ( e = 0 ; e < numListedEntities ; e++ ) 
+	{
+		ent = entityList[ e ];
+
+		if (ent == self)
+			continue;
+		if (ent->owner == self)
+			continue;
+		if ( !(ent->inuse) )
+			continue;
+		if ( ent->s.eType != ET_MISSILE )
+		{
+			if ( ent->client || ent->s.weapon != WP_SABER )
+			{//FIXME: wake up bad guys?
+				continue;
+			}
+			if ( ent->s.eFlags & EF_NODRAW )
+			{
+				continue;
+			}
+			if ( Q_stricmp( "lightsaber", ent->classname ) != 0 )
+			{//not a lightsaber
+				continue;
+			}
+		}
+		else
+		{//FIXME: make exploding missiles explode?
+			if ( ent->s.pos.trType == TR_STATIONARY )
+			{//nothing you can do with a stationary missile
+				continue;
+			}
+			if ( ent->splashDamage || ent->splashRadius )
+			{//can't deflect exploding missiles
+				if ( DistanceSquared( ent->currentOrigin, center ) < 256 )//16 squared
+				{
+					G_MissileImpacted( ent, saberent, ent->currentOrigin, up );
+				}
+				continue;
+			}
+		}
+
+		//don't deflect it if it's not within 16 units of the blade
+		//do this for all blades
+		willHit = qfalse;
+		numSabers = 1;
+		if ( self->client->ps.dualSabers )
+		{
+			numSabers = 2;
+		}
+		for ( int saberNum = 0; saberNum < numSabers; saberNum++ )
+		{
+			for ( int bladeNum = 0; bladeNum < self->client->ps.saber[saberNum].numBlades; bladeNum++ )
+			{
+				VectorMA( self->client->ps.saber[saberNum].blade[bladeNum].muzzlePoint, self->client->ps.saber[saberNum].blade[bladeNum].length, self->client->ps.saber[saberNum].blade[bladeNum].muzzleDir, tip );
+				
+				if( G_PointDistFromLineSegment( self->client->ps.saber[saberNum].blade[bladeNum].muzzlePoint, tip, ent->currentOrigin ) <= 32 )
+				{
+					willHit = qtrue;
+					break;
+				}
+			}
+			if ( willHit )
+			{
+				break;
+			}
+		}
+		if ( !willHit )
+		{
+			continue;
+		}
+		// ok, we are within the radius, add us to the incoming list
+		missile_list[ent_count] = ent;
+		ent_count++;
+
+	}
+
+	if ( ent_count )
+	{
+		vec3_t	fx_dir;
+		// we are done, do we have any to deflect?
+		if ( ent_count )
+		{
+			for ( int x = 0; x < ent_count; x++ )
+			{
+				if ( missile_list[x]->s.weapon == WP_SABER )
+				{//just send it back
+					if ( missile_list[x]->owner && missile_list[x]->owner->client && missile_list[x]->owner->client->ps.saber[0].Active() && missile_list[x]->s.pos.trType == TR_LINEAR && missile_list[x]->owner->client->ps.saberEntityState != SES_RETURNING )
+					{//it's on and being controlled
+						//FIXME: prevent it from damaging me?
+						WP_SaberReturn( missile_list[x]->owner, missile_list[x] );
+						VectorNormalize2( missile_list[x]->s.pos.trDelta, fx_dir );
+						G_PlayEffect( "saber/saber_block", missile_list[x]->currentOrigin, fx_dir );
+						if ( missile_list[x]->owner->client->ps.saberInFlight && self->client->ps.saberInFlight )
+						{
+							G_Sound( missile_list[x], G_SoundIndex( va( "sound/weapons/saber/saberblock%d.wav", Q_irand(1, 9) ) ) );
+							g_saberFlashTime = level.time-50;
+							gentity_t *saber = &g_entities[self->client->ps.saberEntityNum];
+							vec3_t	org;
+							VectorSubtract( missile_list[x]->currentOrigin, saber->currentOrigin, org );
+							VectorMA( saber->currentOrigin, 0.5, org, org );
+							VectorCopy( org, g_saberFlashPos );
+						}
+					}
+				}
+				else
+				{//bounce it
+					vec3_t	reflectAngle, forward;
+					if ( self->client && !self->s.number )
+					{
+						self->client->sess.missionStats.saberBlocksCnt++;
+					}
+					VectorCopy( saberent->s.apos.trBase, reflectAngle );
+					reflectAngle[PITCH] = Q_flrand( -90, 90 );
+					AngleVectors( reflectAngle, forward, NULL, NULL );
+					
+					G_ReflectMissile( self, missile_list[x], forward );
+					//do an effect
+					VectorNormalize2( missile_list[x]->s.pos.trDelta, fx_dir );
+					G_PlayEffect( "blaster/deflect", missile_list[x]->currentOrigin, fx_dir );
+				}
+			}
+		}
+	}
+}
+
+qboolean WP_SaberValidateEnemy( gentity_t *self, gentity_t *enemy )
+{
+	if ( !enemy )
+	{
+		return qfalse;
+	}
+
+	if ( !enemy || enemy == self || !enemy->inuse || !enemy->client )
+	{//not valid
+		return qfalse;
+	}
+
+	if ( enemy->health <= 0 )
+	{//corpse
+		return qfalse;
+	}
+
+	/*
+	if ( enemy->client->ps.weapon == WP_SABER
+		&& enemy->client->ps.SaberActive() )
+	{//not other saber-users?
+		return qfalse;
+	}
+	*/
+	if ( enemy->client->ps.forcePowersKnown )
+	{//not other jedi?
+		return qfalse;
+	}
+
+	if ( DistanceSquared( self->client->renderInfo.handRPoint, enemy->currentOrigin ) > saberThrowDistSquared[self->client->ps.forcePowerLevel[FP_SABERTHROW]] )
+	{//too far
+		return qfalse;
+	}
+
+	if ( (!InFront( enemy->currentOrigin, self->currentOrigin, self->client->ps.viewangles, 0.0f) || !G_ClearLOS( self, self->client->renderInfo.eyePoint, enemy ) ) 
+		&& ( DistanceHorizontalSquared( enemy->currentOrigin, self->currentOrigin ) > 65536 || fabs(enemy->currentOrigin[2]-self->currentOrigin[2]) > 384 )  )
+	{//(not in front or not clear LOS) & greater than 256 away
+		return qfalse;
+	}
+
+	if ( enemy->client->playerTeam == self->client->playerTeam )
+	{//on same team
+		return qfalse;
+	}
+
+	//LOS?
+
+	return qtrue;
+}
+
+float WP_SaberRateEnemy( gentity_t *enemy, vec3_t center, vec3_t forward, float radius )
+{
+	float rating;
+	vec3_t	dir;
+
+	VectorSubtract( enemy->currentOrigin, center, dir );
+	rating = (1.0f-(VectorNormalize( dir )/radius));
+	rating *= DotProduct( forward, dir );
+	return rating;
+}
+
+gentity_t *WP_SaberFindEnemy( gentity_t *self, gentity_t *saber )
+{
+//FIXME: should be a more intelligent way of doing this, like auto aim?
+//closest, most in front... did damage to... took damage from?  How do we know who the player is focusing on?
+	gentity_t	*ent, *bestEnt = NULL;
+	gentity_t	*entityList[MAX_GENTITIES];
+	int			numListedEntities;
+	vec3_t		center, mins, maxs, fwdangles, forward;
+	int			i, e;
+	float		radius = 400;
+	float		rating, bestRating = 0.0f;
+
+	//FIXME: no need to do this in 1st person?
+	fwdangles[1] = self->client->ps.viewangles[1];
+	AngleVectors( fwdangles, forward, NULL, NULL );
+
+	VectorCopy( saber->currentOrigin, center );
+
+	for ( i = 0 ; i < 3 ; i++ ) 
+	{
+		mins[i] = center[i] - radius;
+		maxs[i] = center[i] + radius;
+	}
+
+	//if the saber has an enemy from the last time it looked, init to that one
+	if ( WP_SaberValidateEnemy( self, saber->enemy ) )
+	{
+		if ( gi.inPVS( self->currentOrigin, saber->enemy->currentOrigin ) )
+		{//potentially visible
+			if ( G_ClearLOS( self, self->client->renderInfo.eyePoint, saber->enemy ) )
+			{//can see him
+				bestEnt = saber->enemy;
+				bestRating = WP_SaberRateEnemy( bestEnt, center, forward, radius );
+			}
+		}
+	}
+
+	//If I have an enemy, see if that's even better
+	if ( WP_SaberValidateEnemy( self, self->enemy ) )
+	{
+		float myEnemyRating = WP_SaberRateEnemy( self->enemy, center, forward, radius );
+		if ( myEnemyRating > bestRating )
+		{
+			if ( gi.inPVS( self->currentOrigin, self->enemy->currentOrigin ) )
+			{//potentially visible
+				if ( G_ClearLOS( self, self->client->renderInfo.eyePoint, self->enemy ) )
+				{//can see him
+					bestEnt = self->enemy;
+					bestRating = myEnemyRating;
+				}
+			}
+		}
+	}
+
+	numListedEntities = gi.EntitiesInBox( mins, maxs, entityList, MAX_GENTITIES );
+	
+	if ( !numListedEntities )
+	{//should we clear the enemy?
+		return bestEnt;
+	}
+
+	for ( e = 0 ; e < numListedEntities ; e++ ) 
+	{
+		ent = entityList[ e ];
+
+		if ( ent == self || ent == saber || ent == bestEnt )
+		{
+			continue;
+		}
+		if ( !WP_SaberValidateEnemy( self, ent ) )
+		{//doesn't meet criteria of valid look enemy (don't check current since we would have done that before this func's call
+			continue;
+		}
+		if ( !gi.inPVS( self->currentOrigin, ent->currentOrigin ) )
+		{//not even potentially visible
+			continue;
+		}
+		if ( !G_ClearLOS( self, self->client->renderInfo.eyePoint, ent ) )
+		{//can't see him
+			continue;
+		}
+		//rate him based on how close & how in front he is
+		rating = WP_SaberRateEnemy( ent, center, forward, radius );
+		if ( rating > bestRating )
+		{
+			bestEnt = ent;
+			bestRating = rating;
+		}
+	}
+	return bestEnt;
+}
+
+void WP_RunSaber( gentity_t *self, gentity_t *saber ) 
+{
+	vec3_t		origin, oldOrg;
+	trace_t		tr;
+
+	VectorCopy( saber->currentOrigin, oldOrg );
+	// get current position
+	EvaluateTrajectory( &saber->s.pos, level.time, origin );
+	// get current angles
+	EvaluateTrajectory( &saber->s.apos, level.time, saber->currentAngles );
+
+	// trace a line from the previous position to the current position,
+	// ignoring interactions with the missile owner
+	int clipmask = saber->clipmask;
+	if ( !self || !self->client || self->client->ps.SaberLength() <= 0 )
+	{//don't keep hitting other sabers when turned off
+		clipmask &= ~CONTENTS_LIGHTSABER;
+	}
+	gi.trace( &tr, saber->currentOrigin, saber->mins, saber->maxs, origin, 
+		saber->owner ? saber->owner->s.number : ENTITYNUM_NONE, clipmask );
+
+	VectorCopy( tr.endpos, saber->currentOrigin );
+
+	if ( self->client->ps.SaberActive() )
+	{
+		if ( self->client->ps.saberInFlight || (self->client->ps.weaponTime&&!Q_irand( 0, 100 )) )
+		{//make enemies run from a lit saber in flight or from me when I'm attacking
+			if ( !Q_irand( 0, 10 ) )
+			{//not so often...
+				AddSightEvent( self, saber->currentOrigin, self->client->ps.SaberLength()*3, AEL_DANGER, 100 );
+			}
+		}
+	}
+
+	if ( tr.startsolid ) 
+	{
+		tr.fraction = 0;
+	}
+
+	gi.linkentity( saber );
+
+	//touch push triggers?
+
+	if ( tr.fraction != 1 ) 
+	{
+		WP_SaberImpact( self, saber, &tr );
+	}
+
+	if ( saber->s.pos.trType == TR_LINEAR )
+	{//home
+		//figure out where saber should be
+		vec3_t	forward, saberHome, saberDest, fwdangles = {0};
+
+		VectorCopy( self->client->ps.viewangles, fwdangles );
+		if ( self->s.number )
+		{
+			fwdangles[0] -= 8;
+		}
+		else if ( cg.renderingThirdPerson )
+		{
+			fwdangles[0] -= 5;
+		}
+
+		if ( self->client->ps.forcePowerLevel[FP_SABERTHROW] > FORCE_LEVEL_1 
+			|| self->client->ps.saberEntityState == SES_RETURNING 
+			|| VectorCompare( saber->s.pos.trDelta, vec3_origin ) )
+		{//control if it's returning or just starting
+			float	saberSpeed = 500;//FIXME: based on force level?
+			float	dist;
+			gentity_t *enemy = NULL;
+
+			AngleVectors( fwdangles, forward, NULL, NULL );
+
+			if ( self->client->ps.saberEntityDist < 100 )
+			{//make the saber head to my hand- the bolt it was attached to
+				VectorCopy( self->client->renderInfo.handRPoint, saberHome );
+			}
+			else
+			{//aim saber from eyes
+				VectorCopy( self->client->renderInfo.eyePoint, saberHome );
+			}
+			VectorMA( saberHome, self->client->ps.saberEntityDist, forward, saberDest );
+
+			if ( self->client->ps.forcePowerLevel[FP_SABERTHROW] > FORCE_LEVEL_2 
+				&& self->client->ps.saberEntityState == SES_LEAVING )
+			{//max level
+				if ( self->enemy && 
+					!WP_SaberValidateEnemy( self, self->enemy ) )
+				{//if my enemy isn't valid to auto-aim at, don't autoaim
+				}
+				else
+				{
+					//pick an enemy
+					enemy = WP_SaberFindEnemy( self, saber );
+					if ( enemy )
+					{//home in on enemy
+						float enemyDist = Distance( self->client->renderInfo.handRPoint, enemy->currentOrigin );
+						VectorCopy( enemy->currentOrigin, saberDest );
+						saberDest[2] += enemy->maxs[2]/2.0f;//FIXME: when in a knockdown anim, the saber float above them... do we care?
+						self->client->ps.saberEntityDist = enemyDist;
+						//once you pick an enemy, stay with it!
+						saber->enemy = enemy;
+						//FIXME: lock onto that enemy for a minimum amount of time (unless they become invalid?)
+					}
+				}
+			}
+			
+
+			//Make the saber head there
+			VectorSubtract( saberDest, saber->currentOrigin, saber->s.pos.trDelta );
+			dist = VectorNormalize( saber->s.pos.trDelta );
+			if ( self->client->ps.forcePowerLevel[FP_SABERTHROW] > FORCE_LEVEL_2 && self->client->ps.saberEntityState == SES_LEAVING && !enemy )
+			{
+				if ( dist < 200 )
+				{
+					saberSpeed = 400 - (dist*2);
+				}
+			}
+			else if ( self->client->ps.saberEntityState == SES_LEAVING && dist < 50 )
+			{
+				saberSpeed = dist * 2 + 30;
+				if ( (enemy && dist > enemy->maxs[0]) || (!enemy && dist > 24) )
+				{//auto-tracking an enemy and we can't hit him
+					if ( saberSpeed < 120 )
+					{//clamp to a minimum speed
+						saberSpeed = 120;
+					}
+				}
+			}
+			/*
+			if ( self->client->ps.saberEntityState == SES_RETURNING )
+			{//FIXME: if returning, move faster?
+				saberSpeed = 800;
+				if ( dist < 200 )
+				{
+					saberSpeed -= 400 - (dist*2);
+				}
+			}
+			*/
+			VectorScale( saber->s.pos.trDelta, saberSpeed, saber->s.pos.trDelta );
+			//SnapVector( saber->s.pos.trDelta );	// save net bandwidth
+			VectorCopy( saber->currentOrigin, saber->s.pos.trBase );
+			saber->s.pos.trTime = level.time;
+			saber->s.pos.trType = TR_LINEAR;
+		}
+		else
+		{
+			VectorCopy( saber->currentOrigin, saber->s.pos.trBase );
+			saber->s.pos.trTime = level.time;
+			saber->s.pos.trType = TR_LINEAR;
+		}
+
+		//if it's heading back, point it's base at us
+		if ( self->client->ps.saberEntityState == SES_RETURNING 
+			&& self->client->ps.saber[0].returnDamage == qfalse )//type != SABER_STAR )
+		{
+			fwdangles[0] += SABER_PITCH_HACK;
+			VectorCopy( fwdangles, saber->s.apos.trBase );
+			saber->s.apos.trTime = level.time;
+			saber->s.apos.trType = TR_INTERPOLATE;
+			VectorClear( saber->s.apos.trDelta );
+		}
+	}
+}
+
+
+qboolean WP_SaberLaunch( gentity_t *self, gentity_t *saber, qboolean thrown, qboolean noFail = qfalse )
+{//FIXME: probably need a debounce time
+	vec3_t	saberMins={-3.0f,-3.0f,-3.0f};
+	vec3_t	saberMaxs={3.0f,3.0f,3.0f};
+	trace_t	trace;
+
+	if ( self->client->NPC_class == CLASS_SABER_DROID )
+	{//saber droids can't drop their saber
+		return qfalse;
+	}
+	if ( !noFail )
+	{
+		if ( thrown )
+		{//this is a regular throw, so see if it's legal
+			if ( self->client->ps.forcePowerLevel[FP_SABERTHROW] > FORCE_LEVEL_2 )
+			{
+				if ( !WP_ForcePowerUsable( self, FP_SABERTHROW, 20 ) )
+				{
+					return qfalse;
+				}
+			}
+			else
+			{
+				if ( !WP_ForcePowerUsable( self, FP_SABERTHROW, 0 ) )
+				{
+					return qfalse;
+				}
+			}
+		}
+		if ( !self->s.number && (cg.zoomMode || in_camera) )
+		{//can't saber throw when zoomed in or in cinematic
+			return qfalse;
+		}
+		//make sure it won't start in solid
+		gi.trace( &trace, self->client->renderInfo.handRPoint, saberMins, saberMaxs, self->client->renderInfo.handRPoint, saber->s.number, MASK_SOLID );
+		if ( trace.startsolid || trace.allsolid )
+		{
+			return qfalse;
+		}
+		//make sure I'm not throwing it on the other side of a door or wall or whatever
+		gi.trace( &trace, self->currentOrigin, vec3_origin, vec3_origin, self->client->renderInfo.handRPoint, self->s.number, MASK_SOLID );
+		if ( trace.startsolid || trace.allsolid || trace.fraction < 1.0f )
+		{
+			return qfalse;
+		}
+
+		if ( thrown )
+		{//this is a regular throw, so take force power
+			if ( self->client->ps.forcePowerLevel[FP_SABERTHROW] > FORCE_LEVEL_2 )
+			{//at max skill, the cost increases as keep it out
+				WP_ForcePowerStart( self, FP_SABERTHROW, 10 );
+			}
+			else
+			{
+				WP_ForcePowerStart( self, FP_SABERTHROW, 0 );
+			}
+		}
+	}
+	//clear the enemy
+	saber->enemy = NULL;
+	//draw it
+	saber->s.eFlags &= ~EF_NODRAW;
+	saber->svFlags |= SVF_BROADCAST;
+	saber->svFlags &= ~SVF_NOCLIENT;
+	
+	//place it
+	VectorCopy( self->client->renderInfo.handRPoint, saber->currentOrigin );//muzzlePoint
+	VectorCopy( saber->currentOrigin, saber->s.pos.trBase );
+	saber->s.pos.trTime = level.time;
+	saber->s.pos.trType = TR_LINEAR;
+	VectorClear( saber->s.pos.trDelta );
+	gi.linkentity( saber );
+
+	//spin it
+	VectorClear( saber->s.apos.trBase );
+	saber->s.apos.trTime = level.time;
+	saber->s.apos.trType = TR_LINEAR;
+	if ( self->health > 0 && thrown )
+	{//throwing it
+		saber->s.apos.trBase[1] = self->client->ps.viewangles[1];
+		saber->s.apos.trBase[0] = SABER_PITCH_HACK;
+	}
+	else
+	{//dropping it
+		vectoangles( self->client->renderInfo.muzzleDir, saber->s.apos.trBase );
+	}
+	VectorClear( saber->s.apos.trDelta );
+
+	switch ( self->client->ps.forcePowerLevel[FP_SABERTHROW] )
+	{//FIXME: make a table?
+	default:
+	case FORCE_LEVEL_1:
+		saber->s.apos.trDelta[1] = 600;
+		break;
+	case FORCE_LEVEL_2:
+		saber->s.apos.trDelta[1] = 800;
+		break;
+	case FORCE_LEVEL_3:
+		saber->s.apos.trDelta[1] = 1200;
+		break;
+	}
+
+	//Take it out of my hand
+	self->client->ps.saberInFlight = qtrue;
+	self->client->ps.saberEntityState = SES_LEAVING;
+	self->client->ps.saberEntityDist = saberThrowDist[self->client->ps.forcePowerLevel[FP_SABERTHROW]];
+	self->client->ps.saberThrowTime = level.time;
+	//if ( self->client->ps.forcePowerLevel[FP_SABERTHROW] > FORCE_LEVEL_2 )
+	{
+		self->client->ps.forcePowerDebounce[FP_SABERTHROW] = level.time + 1000;//so we can keep it out for a minimum amount of time
+	}
+	
+	if ( thrown )
+	{//this is a regular throw, so turn the saber on
+		//turn saber on
+		if ( self->client->ps.saber[0].singleBladeThrowable )//SaberStaff() )
+		{//only first blade can be on
+			if ( !self->client->ps.saber[0].blade[0].active )
+			{//turn on first one
+				self->client->ps.SaberBladeActivate( 0, 0 );
+			}
+			for ( int i = 1; i < self->client->ps.saber[0].numBlades; i++ )
+			{//turn off all others
+				if ( self->client->ps.saber[0].blade[i].active )
+				{
+					self->client->ps.SaberBladeActivate( 0, i, qfalse );
+				}
+			}
+		}
+		else
+		{//turn the sabers, all blades...?
+			self->client->ps.saber[0].Activate();
+			//self->client->ps.SaberActivate();
+		}
+		//turn on the saber trail
+		self->client->ps.saber[0].ActivateTrail( 150 );
+	}
+
+	//reset the mins
+	VectorCopy( saberMins, saber->mins );
+	VectorCopy( saberMaxs, saber->maxs );
+	saber->contents = 0;//CONTENTS_LIGHTSABER;
+	saber->clipmask = MASK_SOLID | CONTENTS_LIGHTSABER;
+
+	// remove the ghoul2 right-hand saber model on the player
+	if ( self->weaponModel[0] > 0 )
+	{
+		gi.G2API_RemoveGhoul2Model(self->ghoul2, self->weaponModel[0]);
+		self->weaponModel[0] = -1;
+	}
+
+	return qtrue;
+}
+
+qboolean WP_SaberLose( gentity_t *self, vec3_t throwDir )
+{
+	if ( !self || !self->client || self->client->ps.saberEntityNum <= 0 )
+	{//WTF?!!  We lost it already?
+		return qfalse;
+	}
+	if ( self->client->NPC_class == CLASS_SABER_DROID )
+	{//saber droids can't drop their saber
+		return qfalse;
+	}
+	gentity_t *dropped = &g_entities[self->client->ps.saberEntityNum];
+	if ( !self->client->ps.saberInFlight )
+	{//not alreay in air
+		/*
+		qboolean noForceThrow = qfalse;
+		//make it so we can throw it
+		self->client->ps.forcePowersKnown |= (1<<FP_SABERTHROW);
+		if ( self->client->ps.forcePowerLevel[FP_SABERTHROW] < FORCE_LEVEL_1 )
+		{
+			noForceThrow = qtrue;
+			self->client->ps.forcePowerLevel[FP_SABERTHROW] = FORCE_LEVEL_1;
+		}
+		*/
+		//throw it
+		if ( !WP_SaberLaunch( self, dropped, qfalse ) )
+		{//couldn't throw it
+			return qfalse;
+		}
+		/*
+		if ( noForceThrow )
+		{
+			self->client->ps.forcePowerLevel[FP_SABERTHROW] = FORCE_LEVEL_0;
+		}
+		*/
+	}
+	if ( self->client->ps.saber[0].Active() )
+	{//on
+		//drop it instantly
+		WP_SaberDrop( self, dropped );
+	}
+	//optionally give it some thrown velocity
+	if ( throwDir && !VectorCompare( throwDir, vec3_origin ) )
+	{
+		VectorCopy( throwDir, dropped->s.pos.trDelta ); 
+	}
+	//don't pull it back on the next frame
+	if ( self->NPC )
+	{
+		self->NPC->last_ucmd.buttons &= ~BUTTON_ATTACK;
+	}
+	return qtrue;
+}
+
+void WP_SetSaberOrigin( gentity_t *self, vec3_t newOrg )
+{
+	if ( !self || !self->client )
+	{
+		return;
+	}
+	if ( self->client->ps.saberEntityNum <= 0 || self->client->ps.saberEntityNum >= ENTITYNUM_WORLD )
+	{//no saber ent to reposition
+		return;
+	}
+	if ( self->client->NPC_class == CLASS_SABER_DROID )
+	{//saber droids can't drop their saber
+		return;
+	}
+	gentity_t *dropped = &g_entities[self->client->ps.saberEntityNum];
+	if ( !self->client->ps.saberInFlight )
+	{//not already in air
+		qboolean noForceThrow = qfalse;
+		//make it so we can throw it
+		self->client->ps.forcePowersKnown |= (1<<FP_SABERTHROW);
+		if ( self->client->ps.forcePowerLevel[FP_SABERTHROW] < FORCE_LEVEL_1 )
+		{
+			noForceThrow = qtrue;
+			self->client->ps.forcePowerLevel[FP_SABERTHROW] = FORCE_LEVEL_1;
+		}
+		//throw it
+		if ( !WP_SaberLaunch( self, dropped, qfalse, qtrue ) )
+		{//couldn't throw it
+			return;
+		}
+		if ( noForceThrow )
+		{
+			self->client->ps.forcePowerLevel[FP_SABERTHROW] = FORCE_LEVEL_0;
+		}
+	}
+	VectorCopy( newOrg, dropped->s.origin );
+	VectorCopy( newOrg, dropped->currentOrigin );
+	VectorCopy( newOrg, dropped->s.pos.trBase );
+	//drop it instantly
+	WP_SaberDrop( self, dropped );
+	//don't pull it back on the next frame
+	if ( self->NPC )
+	{
+		self->NPC->last_ucmd.buttons &= ~BUTTON_ATTACK;
+	}
+}
+
+void WP_SaberCatch( gentity_t *self, gentity_t *saber, qboolean switchToSaber )
+{//FIXME: probably need a debounce time
+	if ( self->health > 0 && !PM_SaberInBrokenParry( self->client->ps.saberMove ) && self->client->ps.saberBlocked != BLOCKED_PARRY_BROKEN )
+	{
+		//clear the enemy
+		saber->enemy = NULL;
+		//don't draw it
+		saber->s.eFlags |= EF_NODRAW;
+		saber->svFlags &= SVF_BROADCAST;
+		saber->svFlags |= SVF_NOCLIENT;
+
+		//take off any gravity stuff if we'd dropped it
+		saber->s.pos.trType = TR_LINEAR;
+		saber->s.eFlags &= ~EF_BOUNCE_HALF;
+
+		//Put it in my hand
+		self->client->ps.saberInFlight = qfalse;
+		self->client->ps.saberEntityState = SES_LEAVING;
+
+		//turn off the saber trail
+		self->client->ps.saber[0].DeactivateTrail( 75 );
+
+		//reset its contents/clipmask
+		saber->contents = CONTENTS_LIGHTSABER;// | CONTENTS_SHOTCLIP;
+		saber->clipmask = MASK_SHOT | CONTENTS_LIGHTSABER;
+
+		//play catch sound
+		G_Sound( saber, G_SoundIndex( "sound/weapons/saber/saber_catch.wav" ) );
+		//FIXME: if an NPC, don't turn it back on if no enemy or enemy is dead...
+		//if it's not our current weapon, make it our current weapon
+		if ( self->client->ps.weapon == WP_SABER )
+		{//only do the first saber since we only throw the first one
+			WP_SaberAddG2SaberModels( self, qfalse );
+		}
+		if ( switchToSaber )
+		{
+			if ( self->client->ps.weapon != WP_SABER )
+			{
+				CG_ChangeWeapon( WP_SABER );
+			}
+			else
+			{//if it's not active, turn it on
+				if ( self->client->ps.saber[0].singleBladeThrowable )//SaberStaff() )
+				{//only first blade can be on
+					if ( !self->client->ps.saber[0].blade[0].active )
+					{//only turn it on if first blade is off, otherwise, leave as-is
+						self->client->ps.saber[0].Activate();
+					}
+				}
+				else
+				{//turn all blades on
+					self->client->ps.saber[0].Activate();
+				}
+			}
+		}
+	}
+}
+
+
+void WP_SaberReturn( gentity_t *self, gentity_t *saber )
+{
+	if ( PM_SaberInBrokenParry( self->client->ps.saberMove ) || self->client->ps.saberBlocked == BLOCKED_PARRY_BROKEN )
+	{
+		return;
+	}
+	if ( self && self->client )
+	{//still alive and stuff
+		//FIXME: when it's returning, flies butt first, but seems to do a lot of damage when going through people... hmm...
+		self->client->ps.saberEntityState = SES_RETURNING;
+		//turn down the saber trail
+		if ( self->client->ps.saber[0].returnDamage == qfalse )//type != SABER_STAR )
+		{
+			self->client->ps.saber[0].DeactivateTrail( 75 );
+		}
+	}
+	if ( !(saber->s.eFlags&EF_BOUNCE) )
+	{
+		saber->s.eFlags |= EF_BOUNCE;
+		saber->bounceCount = 300;
+	}
+}
+
+
+void WP_SaberDrop( gentity_t *self, gentity_t *saber )
+{
+	//clear the enemy
+	saber->enemy = NULL;
+	saber->s.eFlags &= ~EF_BOUNCE;
+	saber->bounceCount = 0;
+	//make it fall
+	saber->s.pos.trType = TR_GRAVITY;
+	//make it bounce some
+	saber->s.eFlags |= EF_BOUNCE_HALF;
+	//make it spin
+	VectorCopy( saber->currentAngles, saber->s.apos.trBase );
+	saber->s.apos.trType = TR_LINEAR;
+	saber->s.apos.trTime = level.time;
+	VectorSet( saber->s.apos.trDelta, Q_irand( -300, 300 ), saber->s.apos.trDelta[1], Q_irand( -300, 300 ) );
+	if ( !saber->s.apos.trDelta[1] )
+	{
+		saber->s.apos.trDelta[1] = Q_irand( -300, 300 );
+	}
+	//force it to be ready to return
+	self->client->ps.saberEntityDist = 0;
+	self->client->ps.saberEntityState = SES_RETURNING;
+	//turn it off
+	self->client->ps.saber[0].Deactivate();
+	//turn off the saber trail
+	self->client->ps.saber[0].DeactivateTrail( 75 );
+	//play the saber turning off sound
+	G_SoundIndexOnEnt( saber, CHAN_AUTO, self->client->ps.saber[0].soundOff );
+#ifdef _IMMERSION
+	if ( self->client->playerTeam == TEAM_PLAYER )
+	{
+		G_Force( self, G_ForceIndex( "fffx/weapons/saber/saberoff", FF_CHANNEL_WEAPON ) );
+	}
+	else
+	{
+		G_Force( self, G_ForceIndex( "fffx/weapons/saber/enemy_saber_off", FF_CHANNEL_WEAPON ) );
+	}
+#endif // _IMMERSION
+
+	if ( self->health <= 0 )
+	{//owner is dead!
+		saber->s.time = level.time;//will make us free ourselves after a time
+	}
+}
+
+
+void WP_SaberPull( gentity_t *self, gentity_t *saber )
+{
+	if ( PM_SaberInBrokenParry( self->client->ps.saberMove ) || self->client->ps.saberBlocked == BLOCKED_PARRY_BROKEN )
+	{
+		return;
+	}
+	if ( self->health > 0 )
+	{
+		//take off gravity
+		saber->s.pos.trType = TR_LINEAR;
+		//take off bounce
+		saber->s.eFlags &= EF_BOUNCE_HALF;
+		//play sound
+		G_Sound( self, G_SoundIndex( "sound/weapons/force/pull.wav" ) );
+#ifdef _IMMERSION
+		G_Force( self, G_ForceIndex( "fffx/weapons/force/pull", FF_CHANNEL_WEAPON ) );
+#endif // _IMMERSION
+	}
+}
+
+
+// Check if we are throwing it, launch it if needed, update position if needed.
+void WP_SaberThrow( gentity_t *self, usercmd_t *ucmd )
+{
+	static float	MAX_SABER_DIST = 400;
+	vec3_t			saberDiff;
+	trace_t			tr;
+	//static float	SABER_SPEED = 10;
+
+	gentity_t *saberent;
+	
+	if ( self->client->ps.saberEntityNum <= 0 || self->client->ps.saberEntityNum >= ENTITYNUM_WORLD )
+	{//WTF?!!  We lost it?
+		return;
+	}
+	
+	if ( self->client->ps.torsoAnim == BOTH_LOSE_SABER )
+	{//can't catch it while it's being yanked from your hand!
+		return;
+	}
+
+	if ( !g_saberNewControlScheme->integer )
+	{
+		if ( PM_SaberInKata( (saberMoveName_t)self->client->ps.saberMove ) )
+		{//don't throw saber when in special attack (alt+attack)
+			return;
+		}
+		if ( (ucmd->buttons&BUTTON_ATTACK) 
+			&& (ucmd->buttons&BUTTON_ALT_ATTACK) 
+			&& !self->client->ps.saberInFlight )
+		{//trying to do special attack, don't throw it
+			return;
+		}
+		else if ( self->client->ps.torsoAnim == BOTH_A1_SPECIAL
+			|| self->client->ps.torsoAnim == BOTH_A2_SPECIAL
+			|| self->client->ps.torsoAnim == BOTH_A3_SPECIAL )
+		{//don't throw in these anims!
+			return;
+		}
+	}
+	saberent = &g_entities[self->client->ps.saberEntityNum];
+
+	VectorSubtract( self->client->renderInfo.handRPoint, saberent->currentOrigin, saberDiff );
+
+	//is our saber in flight?
+	if ( !self->client->ps.saberInFlight )
+	{//saber is not in flight right now
+		if ( self->client->ps.weapon != WP_SABER )
+		{//don't even have it out
+			return;
+		}
+		else if ( (ucmd->buttons&BUTTON_ALT_ATTACK) && !(self->client->ps.pm_flags&PMF_ALT_ATTACK_HELD) )
+		{//still holding it, not still holding attack from a previous throw, so throw it.
+			if ( !(self->client->ps.saberEventFlags&SEF_INWATER) && WP_SaberLaunch( self, saberent, qtrue ) )
+			{
+				if ( self->client && !self->s.number )
+				{
+					self->client->sess.missionStats.saberThrownCnt++;
+				}
+				//need to recalc this because we just moved it
+				VectorSubtract( self->client->renderInfo.handRPoint, saberent->currentOrigin, saberDiff );
+			}
+			else
+			{//couldn't throw it
+				return;
+			}
+		}
+		else
+		{//holding it, don't want to throw it, go away.
+			return;
+		}
+	}
+	else 
+	{//inflight
+		//is our saber currently on it's way back to us?
+		if ( self->client->ps.saberEntityState == SES_RETURNING )
+		{//see if we're close enough to pick it up
+			if ( VectorLengthSquared( saberDiff ) <= 256 )//16 squared//G_BoundsOverlap( self->absmin, self->absmax, saberent->absmin, saberent->absmax ) )//
+			{//caught it
+				vec3_t	axisPoint;
+				trace_t	trace;
+				VectorCopy( self->currentOrigin, axisPoint );
+				axisPoint[2] = self->client->renderInfo.handRPoint[2];
+				gi.trace( &trace, axisPoint, vec3_origin, vec3_origin, self->client->renderInfo.handRPoint, self->s.number, MASK_SOLID );
+				if ( !trace.startsolid && trace.fraction >= 1.0f )
+				{//our hand isn't through a wall
+					WP_SaberCatch( self, saberent, qtrue );
+					//NPC_SetAnim( self, SETANIM_TORSO, TORSO_HANDRETRACT1, SETANIM_FLAG_OVERRIDE );
+				}
+				return;
+			}
+		}
+
+		if ( saberent->s.pos.trType != TR_STATIONARY )
+		{//saber is in flight, lerp it
+			WP_RunSaber( self, saberent );
+		}
+		else
+		{//it fell on the ground
+			if ( self->health <= 0 && level.time > saberent->s.time + 5000 )
+			{//make us free ourselves after a time
+				G_FreeEntity( saberent );
+				self->client->ps.saberEntityNum = ENTITYNUM_NONE;
+				return;
+			}
+			if ( (!self->s.number && level.time - saberent->aimDebounceTime > 15000)
+				|| (self->s.number && level.time - saberent->aimDebounceTime > 5000) )
+			{//(only for player) been missing for 15 seconds, automagicially return
+				WP_SaberCatch( self, saberent, qfalse );
+				return;
+			}
+		}
+	}
+
+	//are we still trying to use the saber?
+	if ( self->client->ps.weapon != WP_SABER )
+	{//switched away
+		if ( !self->client->ps.saberInFlight )
+		{//wasn't throwing saber
+			return;
+		}
+		else if ( saberent->s.pos.trType == TR_LINEAR )
+		{//switched away while controlling it, just drop the saber
+			WP_SaberDrop( self, saberent );
+			return;
+		}
+		else
+		{//it's on the ground, see if it's inside us (touching)
+			if ( G_PointInBounds( saberent->currentOrigin, self->absmin, self->absmax ) )
+			{//it's in us, pick it up automatically
+				WP_SaberPull( self, saberent );
+			}
+		}
+	}
+	else if ( saberent->s.pos.trType != TR_LINEAR )
+	{//weapon is saber and not flying
+		if ( self->client->ps.saberInFlight )
+		{//we dropped it
+			if ( ucmd->buttons & BUTTON_ATTACK )//|| self->client->ps.weaponstate == WEAPON_RAISING )//ucmd->buttons & BUTTON_ALT_ATTACK || 
+			{//we actively want to pick it up or we just switched to it, so pull it back
+				gi.trace( &tr, saberent->currentOrigin, saberent->mins, saberent->maxs, self->client->renderInfo.handRPoint, self->s.number, MASK_SOLID );
+
+				if ( tr.allsolid || tr.startsolid || tr.fraction < 1.0f )
+				{//can't pick it up yet, no LOS
+					return;
+				}
+				//clear LOS, pick it up
+				WP_SaberPull( self, saberent );
+			}
+			else
+			{//see if it's inside us (touching)
+				if ( G_PointInBounds( saberent->currentOrigin, self->absmin, self->absmax ) )
+				{//it's in us, pick it up automatically
+					WP_SaberPull( self, saberent );
+				}
+			}
+		}
+	}
+	else if ( self->health <= 0 && self->client->ps.saberInFlight )
+	{//we died, drop it
+		WP_SaberDrop( self, saberent );
+		return;
+	}
+	else if ( !self->client->ps.saber[0].Active() && self->client->ps.saberEntityState != SES_RETURNING )
+	{//we turned it off, drop it
+		WP_SaberDrop( self, saberent );
+		return;
+	}
+	
+	//TODO: if deactivate saber in flight, should it drop?
+	
+	if ( saberent->s.pos.trType != TR_LINEAR )
+	{//don't home
+		return;
+	}
+
+	float saberDist = VectorLength( saberDiff );
+	if ( self->client->ps.saberEntityState == SES_LEAVING )
+	{//saber still flying forward
+		if ( self->client->ps.forcePowerLevel[FP_SABERTHROW] > FORCE_LEVEL_2 )
+		{//still holding it out
+			if ( !(ucmd->buttons&BUTTON_ALT_ATTACK) && self->client->ps.forcePowerDebounce[FP_SABERTHROW] < level.time )
+			{//done throwing, return to me
+				if ( self->client->ps.saber[0].Active() )
+				{//still on
+					WP_SaberReturn( self, saberent );
+				}
+			}
+			else if ( level.time - self->client->ps.saberThrowTime >= 100 )
+			{
+				if ( WP_ForcePowerAvailable( self, FP_SABERTHROW, 1 ) )
+				{
+					WP_ForcePowerDrain( self, FP_SABERTHROW, 1 );
+					self->client->ps.saberThrowTime = level.time;
+				}
+				else
+				{//out of force power, return to me
+					WP_SaberReturn( self, saberent );
+				}
+			}
+		}
+		else
+		{
+			if ( !(ucmd->buttons&BUTTON_ALT_ATTACK) && self->client->ps.forcePowerDebounce[FP_SABERTHROW] < level.time )
+			{//not holding button and has been out at least 1 second, return to me
+				if ( self->client->ps.saber[0].Active() )
+				{//still on
+					WP_SaberReturn( self, saberent );
+				}
+			}
+			else if ( level.time - self->client->ps.saberThrowTime > 3000 
+				|| (self->client->ps.forcePowerLevel[FP_SABERTHROW]==FORCE_LEVEL_1&&saberDist>=self->client->ps.saberEntityDist) )
+			{//been out too long, or saber throw 1 went too far, return to me
+				if ( self->client->ps.saber[0].Active() )
+				{//still on
+					WP_SaberReturn( self, saberent );
+				}
+			}
+		}
+	}
+	if ( self->client->ps.saberEntityState == SES_RETURNING )
+	{
+		if ( self->client->ps.saberEntityDist > 0 )
+		{
+			self->client->ps.saberEntityDist -= 25;
+		}
+		if ( self->client->ps.saberEntityDist < 0 )
+		{
+			self->client->ps.saberEntityDist = 0;
+		}
+		else if ( saberDist < self->client->ps.saberEntityDist )
+		{//if it's coming back to me, never push it away
+			self->client->ps.saberEntityDist = saberDist;
+		}
+	}
+}
+
+
+//SABER BLOCKING============================================================================
+//SABER BLOCKING============================================================================
+//SABER BLOCKING============================================================================
+//SABER BLOCKING============================================================================
+//SABER BLOCKING============================================================================
+int WP_MissileBlockForBlock( int saberBlock )
+{
+	switch( saberBlock )
+	{
+	case BLOCKED_UPPER_RIGHT:
+		return BLOCKED_UPPER_RIGHT_PROJ;
+		break;
+	case BLOCKED_UPPER_LEFT:
+		return BLOCKED_UPPER_LEFT_PROJ;
+		break;
+	case BLOCKED_LOWER_RIGHT:
+		return BLOCKED_LOWER_RIGHT_PROJ;
+		break;
+	case BLOCKED_LOWER_LEFT:
+		return BLOCKED_LOWER_LEFT_PROJ;
+		break;
+	case BLOCKED_TOP:
+		return BLOCKED_TOP_PROJ;
+		break;
+	}
+	return saberBlock;
+}
+
+void WP_SaberBlockNonRandom( gentity_t *self, vec3_t hitloc, qboolean missileBlock )
+{
+	vec3_t diff, fwdangles={0,0,0}, right;
+	float rightdot;
+	float zdiff;
+
+	if ( self->client->ps.weaponstate == WEAPON_DROPPING ||
+		self->client->ps.weaponstate == WEAPON_RAISING )
+	{//don't block while changing weapons
+		return;
+	}
+	if ( PM_SuperBreakLoseAnim( self->client->ps.torsoAnim ) 
+		|| PM_SuperBreakWinAnim( self->client->ps.torsoAnim ) )
+	{
+		return;
+	}
+	//NPCs don't auto-block
+	if ( !missileBlock && self->s.number != 0 && self->client->ps.saberBlocked != BLOCKED_NONE )
+	{
+		return;
+	}
+
+	VectorSubtract( hitloc, self->client->renderInfo.eyePoint, diff );
+	diff[2] = 0;
+	VectorNormalize( diff );
+
+	fwdangles[1] = self->client->ps.viewangles[1];
+	// Ultimately we might care if the shot was ahead or behind, but for now, just quadrant is fine.
+	AngleVectors( fwdangles, NULL, right, NULL );
+
+	rightdot = DotProduct(right, diff);
+	zdiff = hitloc[2] - self->client->renderInfo.eyePoint[2];
+	
+	//FIXME: take torsoAngles into account?
+	if ( zdiff > -5 )//0 )//40 )
+	{
+		if ( rightdot > 0.3 )
+		{
+			self->client->ps.saberBlocked = BLOCKED_UPPER_RIGHT;
+		}
+		else if ( rightdot < -0.3 )
+		{
+			self->client->ps.saberBlocked = BLOCKED_UPPER_LEFT;
+		}
+		else
+		{
+			self->client->ps.saberBlocked = BLOCKED_TOP;
+		}
+	}
+	else if ( zdiff > -22 )//-20 )//20 )
+	{
+		if ( zdiff < -10 )//30 )
+		{//hmm, pretty low, but not low enough to use the low block, so we need to duck
+			//NPC should duck, but NPC should never get here
+		}
+		if ( rightdot > 0.1 )
+		{
+			self->client->ps.saberBlocked = BLOCKED_UPPER_RIGHT;
+		}
+		else if ( rightdot < -0.1 )
+		{
+			self->client->ps.saberBlocked = BLOCKED_UPPER_LEFT;
+		}
+		else
+		{//FIXME: this looks really weird if the shot is too low!
+			self->client->ps.saberBlocked = BLOCKED_TOP;
+		}
+	}
+	else
+	{
+		if ( rightdot >= 0 )
+		{
+			self->client->ps.saberBlocked = BLOCKED_LOWER_RIGHT;
+		}
+		else
+		{
+			self->client->ps.saberBlocked = BLOCKED_LOWER_LEFT;
+		}
+	}
+
+#ifndef FINAL_BUILD
+	if ( d_saberCombat->integer )
+	{
+		if ( !self->s.number )
+		{
+			gi.Printf( "EyeZ: %4.2f  HitZ: %4.2f  zdiff: %4.2f  rdot: %4.2f\n", self->client->renderInfo.eyePoint[2], hitloc[2], zdiff, rightdot );
+			switch ( self->client->ps.saberBlocked )
+			{
+			case BLOCKED_TOP:
+				gi.Printf( "BLOCKED_TOP\n" );
+				break;
+			case BLOCKED_UPPER_RIGHT:
+				gi.Printf( "BLOCKED_UPPER_RIGHT\n" );
+				break;
+			case BLOCKED_UPPER_LEFT:
+				gi.Printf( "BLOCKED_UPPER_LEFT\n" );
+				break;
+			case BLOCKED_LOWER_RIGHT:
+				gi.Printf( "BLOCKED_LOWER_RIGHT\n" );
+				break;
+			case BLOCKED_LOWER_LEFT:
+				gi.Printf( "BLOCKED_LOWER_LEFT\n" );
+				break;
+			default:
+				break;
+			}
+		}
+	}
+#endif
+
+	if ( missileBlock )
+	{
+		self->client->ps.saberBlocked = WP_MissileBlockForBlock( self->client->ps.saberBlocked );
+	}
+
+	if ( self->client->ps.saberBlocked != BLOCKED_NONE )
+	{
+		int parryReCalcTime = Jedi_ReCalcParryTime( self, EVASION_PARRY );
+		if ( self->client->ps.forcePowerDebounce[FP_SABER_DEFENSE] < level.time + parryReCalcTime )
+		{
+			self->client->ps.forcePowerDebounce[FP_SABER_DEFENSE] = level.time + parryReCalcTime;
+		}
+	}
+}
+
+void WP_SaberBlock( gentity_t *saber, vec3_t hitloc, qboolean missileBlock )
+{
+	gentity_t *playerent;
+	vec3_t diff, fwdangles={0,0,0}, right;
+	float rightdot;
+	float zdiff;
+
+	if (saber && saber->owner)
+	{
+		playerent = saber->owner;
+		if (!playerent->client)
+		{
+			return;
+		}
+		if ( playerent->client->ps.weaponstate == WEAPON_DROPPING ||
+			playerent->client->ps.weaponstate == WEAPON_RAISING )
+		{//don't block while changing weapons
+			return;
+		}
+	}
+	else
+	{	// Bad entity passed.
+		return;
+	}
+	
+	//temporarily disabling auto-blocking for NPCs...
+	if ( !missileBlock && playerent->s.number != 0 && playerent->client->ps.saberBlocked != BLOCKED_NONE )
+	{
+		return;
+	}
+
+	if ( PM_SuperBreakLoseAnim( playerent->client->ps.torsoAnim ) )
+	{
+		return;
+	}
+
+	VectorSubtract(hitloc, playerent->currentOrigin, diff);
+	VectorNormalize(diff);
+
+	fwdangles[1] = playerent->client->ps.viewangles[1];
+	// Ultimately we might care if the shot was ahead or behind, but for now, just quadrant is fine.
+	AngleVectors( fwdangles, NULL, right, NULL );
+
+	rightdot = DotProduct(right, diff) + Q_flrand(-0.2f,0.2f);
+	zdiff = hitloc[2] - playerent->currentOrigin[2] + Q_irand(-8,8);
+	
+	// Figure out what quadrant the block was in.
+	if (zdiff > 24)
+	{	// Attack from above
+		if (Q_irand(0,1))
+		{
+			playerent->client->ps.saberBlocked = BLOCKED_TOP;
+		}
+		else
+		{
+			playerent->client->ps.saberBlocked = BLOCKED_UPPER_LEFT;
+		}
+	}
+	else if (zdiff > 13)
+	{	// The upper half has three viable blocks...
+		if (rightdot > 0.25)
+		{	// In the right quadrant...
+			if (Q_irand(0,1))
+			{
+				playerent->client->ps.saberBlocked = BLOCKED_UPPER_LEFT;
+			}
+			else
+			{
+				playerent->client->ps.saberBlocked = BLOCKED_LOWER_LEFT;
+			}
+		}
+		else
+		{
+			switch(Q_irand(0,3))
+			{
+			case 0:
+				playerent->client->ps.saberBlocked = BLOCKED_UPPER_RIGHT;
+				break;
+			case 1:
+			case 2:
+				playerent->client->ps.saberBlocked = BLOCKED_LOWER_RIGHT;
+				break;
+			case 3:
+				playerent->client->ps.saberBlocked = BLOCKED_TOP;
+				break;
+			}
+		}
+	}
+	else
+	{	// The lower half is a bit iffy as far as block coverage.  Pick one of the "low" ones at random.
+		if (Q_irand(0,1))
+		{
+			playerent->client->ps.saberBlocked = BLOCKED_LOWER_RIGHT;
+		}
+		else
+		{
+			playerent->client->ps.saberBlocked = BLOCKED_LOWER_LEFT;
+		}
+	}
+
+	if ( missileBlock )
+	{
+		playerent->client->ps.saberBlocked = WP_MissileBlockForBlock( playerent->client->ps.saberBlocked );
+	}
+}
+
+void WP_SaberStartMissileBlockCheck( gentity_t *self, usercmd_t *ucmd  )
+{
+	float		dist;
+	gentity_t	*ent, *incoming = NULL;
+	gentity_t	*entityList[MAX_GENTITIES];
+	int			numListedEntities;
+	vec3_t		mins, maxs;
+	int			i, e;
+	float		closestDist, radius = 256;
+	vec3_t		forward, dir, missile_dir, fwdangles = {0};
+	trace_t		trace;
+	vec3_t		traceTo, entDir;
+	qboolean	dodgeOnlySabers = qfalse;
+
+
+	if ( self->NPC && (self->NPC->scriptFlags&SCF_IGNORE_ALERTS) )
+	{//don't react to things flying at me...
+		return;
+	}
+	if ( self->health <= 0 )
+	{//dead don't try to block (NOTE: actual deflection happens in missile code)
+		return;
+	}
+
+	if ( PM_InKnockDown( &self->client->ps ) )
+	{//can't block when knocked down
+		return;
+	}
+
+	if ( PM_SuperBreakLoseAnim( self->client->ps.torsoAnim ) 
+		|| PM_SuperBreakWinAnim( self->client->ps.torsoAnim ) )
+	{//can't block while in break anim
+		return;
+	}
+
+	if ( Rosh_BeingHealed( self ) )
+	{
+		return;
+	}
+
+	if ( self->client->NPC_class == CLASS_ROCKETTROOPER )
+	{//rockettrooper
+		if ( self->client->ps.groundEntityNum != ENTITYNUM_NONE )
+		{//must be in air
+			return;
+		}
+		if ( Q_irand( 0, 4-(g_spskill->integer*2) ) )
+		{//easier level guys do this less
+			return;
+		}
+		if ( Q_irand( 0, 3 ) )
+		{//base level: 25% chance of looking for something to dodge
+			if ( Q_irand( 0, 1 ) )
+			{//dodge sabers twice as frequently as other projectiles
+				dodgeOnlySabers = qtrue;
+			}
+			else
+			{
+				return;
+			}
+		}
+	}
+
+	if ( self->client->NPC_class == CLASS_BOBAFETT )
+	{//Boba doesn't dodge quite as much
+		if ( Q_irand( 0, 2-g_spskill->integer) )
+		{//easier level guys do this less
+			return;
+		}
+	}
+
+	if ( self->client->NPC_class != CLASS_BOBAFETT 
+		&& (self->client->NPC_class != CLASS_REBORN || self->s.weapon == WP_SABER)
+		&& (self->client->NPC_class != CLASS_ROCKETTROOPER||!self->NPC||self->NPC->rank<RANK_LT)//if a rockettrooper, but not an officer, do these normal checks
+		)
+	{
+		if ( g_debugMelee->integer
+			&& (ucmd->buttons & BUTTON_USE)
+			&& cg.renderingThirdPerson
+			&& G_OkayToLean( &self->client->ps, ucmd, qfalse ) 
+			&& (self->client->ps.forcePowersActive&(1<<FP_SPEED)) )
+		{
+		}
+		else
+		{
+			if ( self->client->ps.weapon != WP_SABER )
+			{
+				return;
+			}
+
+			if ( self->client->ps.saberInFlight )
+			{
+				return;
+			}
+
+			if ( self->s.number < MAX_CLIENTS )
+			{
+				if ( !self->client->ps.SaberLength() )
+				{//player doesn't auto-activate
+					return;
+				}
+
+				if ( !g_saberAutoBlocking->integer && self->client->ps.saberBlockingTime<level.time )
+				{
+					return;
+				}
+			}
+
+			if ( !self->client->ps.saber[0].activeBlocking )
+			{//can't actively block with this saber type
+				return;
+			}
+		}
+
+		if ( !self->s.number )
+		{//don't do this if already attacking!
+			if ( ucmd->buttons & BUTTON_ATTACK 
+				|| PM_SaberInAttack( self->client->ps.saberMove )
+				|| PM_SaberInSpecialAttack( self->client->ps.torsoAnim )
+				|| PM_SaberInTransitionAny( self->client->ps.saberMove ))
+			{
+				return;
+			}
+		}
+
+		if ( self->client->ps.forcePowerLevel[FP_SABER_DEFENSE] < FORCE_LEVEL_1 )
+		{//you have not the SKILLZ
+			return;
+		}
+
+		if ( self->client->ps.forcePowerDebounce[FP_SABER_DEFENSE] > level.time )
+		{//can't block while already blocking
+			return;
+		}
+
+		if ( self->client->ps.forcePowersActive&(1<<FP_LIGHTNING) )
+		{//can't block while zapping
+			return;
+		}
+
+		if ( self->client->ps.forcePowersActive&(1<<FP_DRAIN) )
+		{//can't block while draining
+			return;
+		}
+
+		if ( self->client->ps.forcePowersActive&(1<<FP_PUSH) )
+		{//can't block while shoving
+			return;
+		}
+
+		if ( self->client->ps.forcePowersActive&(1<<FP_GRIP) )
+		{//can't block while gripping (FIXME: or should it break the grip?  Pain should break the grip, I think...)
+			return;
+		}
+	}
+
+	fwdangles[1] = self->client->ps.viewangles[1];
+	AngleVectors( fwdangles, forward, NULL, NULL );
+
+	for ( i = 0 ; i < 3 ; i++ ) 
+	{
+		mins[i] = self->currentOrigin[i] - radius;
+		maxs[i] = self->currentOrigin[i] + radius;
+	}
+
+	numListedEntities = gi.EntitiesInBox( mins, maxs, entityList, MAX_GENTITIES );
+
+	closestDist = radius;
+
+	for ( e = 0 ; e < numListedEntities ; e++ ) 
+	{
+		ent = entityList[ e ];
+
+		if (ent == self)
+			continue;
+		if (ent->owner == self)
+			continue;
+		if ( !(ent->inuse) )
+			continue;
+		if ( dodgeOnlySabers )
+		{//only care about thrown sabers
+			if ( ent->client
+				|| ent->s.weapon != WP_SABER
+				|| !ent->classname
+				|| !ent->classname[0]
+				|| Q_stricmp( "lightsaber", ent->classname ) )
+			{//not a lightsaber, ignore it
+				continue;
+			}
+		}
+		if ( ent->s.eType != ET_MISSILE && !(ent->s.eFlags&EF_MISSILE_STICK) )
+		{//not a normal projectile
+			if ( ent->client || ent->s.weapon != WP_SABER )
+			{//FIXME: wake up bad guys?
+				continue;
+			}
+			if ( ent->s.eFlags & EF_NODRAW )
+			{
+				continue;
+			}
+			if ( Q_stricmp( "lightsaber", ent->classname ) != 0 )
+			{//not a lightsaber
+				//FIXME: what about general objects that are small in size- like rocks, etc...
+				continue;
+			}
+			//a lightsaber.. make sure it's on and inFlight
+			if ( !ent->owner || !ent->owner->client )
+			{
+				continue;
+			}
+			if ( !ent->owner->client->ps.saberInFlight )
+			{//not in flight
+				continue;
+			}
+			if ( ent->owner->client->ps.SaberLength() <= 0 )
+			{//not on
+				continue;
+			}
+			if ( ent->owner->health <= 0 && g_saberRealisticCombat->integer < 2 )
+			{//it's not doing damage, so ignore it
+				continue;
+			}
+		}
+		else
+		{
+			if ( ent->s.pos.trType == TR_STATIONARY && !self->s.number )
+			{//nothing you can do with a stationary missile if you're the player
+				continue;
+			}
+		}
+
+		float		dot1, dot2;
+		//see if they're in front of me
+		VectorSubtract( ent->currentOrigin, self->currentOrigin, dir );
+		dist = VectorNormalize( dir );
+		//FIXME: handle detpacks, proximity mines and tripmines
+		if ( ent->s.weapon == WP_THERMAL )
+		{//thermal detonator!
+			if ( self->NPC && dist < ent->splashRadius )
+			{
+				if ( dist < ent->splashRadius && 
+					ent->nextthink < level.time + 600 && 
+					ent->count && 
+					self->client->ps.groundEntityNum != ENTITYNUM_NONE && 
+						(ent->s.pos.trType == TR_STATIONARY||
+						ent->s.pos.trType == TR_INTERPOLATE||
+						(dot1 = DotProduct( dir, forward )) < SABER_REFLECT_MISSILE_CONE||
+						!WP_ForcePowerUsable( self, FP_PUSH, 0 )) )
+				{//TD is close enough to hurt me, I'm on the ground and the thing is at rest or behind me and about to blow up, or I don't have force-push so force-jump!
+					//FIXME: sometimes this might make me just jump into it...?
+					self->client->ps.forceJumpCharge = 480;
+				}
+				else if ( self->client->NPC_class != CLASS_BOBAFETT 
+					&& (self->client->NPC_class != CLASS_REBORN || self->s.weapon == WP_SABER)
+					&& self->client->NPC_class != CLASS_ROCKETTROOPER )
+				{//FIXME: check forcePushRadius[NPC->client->ps.forcePowerLevel[FP_PUSH]]
+					if ( !ent->owner || !OnSameTeam( self, ent->owner ) )
+					{
+						ForceThrow( self, qfalse );
+					}
+				}
+			}
+			continue;
+		}
+		else if ( ent->splashDamage && ent->splashRadius )
+		{//exploding missile
+			//FIXME: handle tripmines and detpacks somehow... 
+			//			maybe do a force-gesture that makes them explode?  
+			//			But what if we're within it's splashradius?
+			if ( !self->s.number )
+			{//players don't auto-handle these at all
+				continue;
+			}
+			else 
+			{
+				if ( self->client->NPC_class == CLASS_BOBAFETT 
+					|| self->client->NPC_class == CLASS_ROCKETTROOPER )
+				{
+					/*
+					if ( ent->s.pos.trType == TR_STATIONARY && (ent->s.eFlags&EF_MISSILE_STICK) )
+					{//sorry, you're scrooged here
+						//FIXME: maybe jump or go up if on ground?
+						continue;
+					}
+					//else it's a rocket, try to evade it
+					*/
+					//HMM... let's see what happens if these guys try to avoid tripmines and detpacks, too...?
+				}
+				else
+				{//normal Jedi
+					if ( ent->s.pos.trType == TR_STATIONARY && (ent->s.eFlags&EF_MISSILE_STICK) 
+						&& (self->client->NPC_class != CLASS_REBORN || self->s.weapon == WP_SABER) )
+					{//a placed explosive like a tripmine or detpack
+						if ( InFOV( ent->currentOrigin, self->client->renderInfo.eyePoint, self->client->ps.viewangles, 90, 90 ) )
+						{//in front of me
+							if ( G_ClearLOS( self, ent ) )
+							{//can see it
+								vec3_t throwDir;
+								//make the gesture
+								ForceThrow( self, qfalse );
+								//take it off the wall and toss it
+								ent->s.pos.trType = TR_GRAVITY;
+								ent->s.eType = ET_MISSILE;
+								ent->s.eFlags &= ~EF_MISSILE_STICK;
+								ent->s.eFlags |= EF_BOUNCE_HALF;
+								AngleVectors( ent->currentAngles, throwDir, NULL, NULL );
+								VectorMA( ent->currentOrigin, ent->maxs[0]+4, throwDir, ent->currentOrigin );
+								VectorCopy( ent->currentOrigin, ent->s.pos.trBase );
+								VectorScale( throwDir, 300, ent->s.pos.trDelta );
+								ent->s.pos.trDelta[2] += 150;
+								VectorMA( ent->s.pos.trDelta, 800, dir, ent->s.pos.trDelta );
+								ent->s.pos.trTime = level.time;		// move a bit on the very first frame
+								VectorCopy( ent->currentOrigin, ent->s.pos.trBase );
+								ent->owner = self;
+								// make it explode, but with less damage
+								ent->splashDamage /= 3;
+								ent->splashRadius /= 3;
+								ent->e_ThinkFunc = thinkF_WP_Explode;
+								ent->nextthink = level.time + Q_irand( 500, 3000 );
+							}
+						}
+					}
+					else if ( dist < ent->splashRadius 
+						&& self->client->ps.groundEntityNum != ENTITYNUM_NONE 
+						&& ( DotProduct( dir, forward ) < SABER_REFLECT_MISSILE_CONE
+							|| !WP_ForcePowerUsable( self, FP_PUSH, 0 ) ) )
+					{//NPCs try to evade it
+						self->client->ps.forceJumpCharge = 480;
+					}
+					else if ( (self->client->NPC_class != CLASS_REBORN || self->s.weapon == WP_SABER) )
+					{//else, try to force-throw it away
+						if ( !ent->owner || !OnSameTeam( self, ent->owner ) )
+						{
+							//FIXME: check forcePushRadius[NPC->client->ps.forcePowerLevel[FP_PUSH]]
+							ForceThrow( self, qfalse );
+						}
+					}
+					//otherwise, can't block it, so we're screwed
+					continue;
+				}
+			}
+		}
+
+		if ( ent->s.weapon != WP_SABER )
+		{//only block shots coming from behind
+			if ( (dot1 = DotProduct( dir, forward )) < SABER_REFLECT_MISSILE_CONE )
+				continue;
+		}
+		else if ( !self->s.number )
+		{//player never auto-blocks thrown sabers
+			continue;
+		}//NPCs always try to block sabers coming from behind!
+
+		//see if they're heading towards me
+		VectorCopy( ent->s.pos.trDelta, missile_dir );
+		VectorNormalize( missile_dir );
+		if ( (dot2 = DotProduct( dir, missile_dir )) > 0 )
+			continue;
+
+		//FIXME: must have a clear trace to me, too...
+		if ( dist < closestDist )
+		{
+			VectorCopy( self->currentOrigin, traceTo );
+			traceTo[2] = self->absmax[2] - 4;
+			gi.trace( &trace, ent->currentOrigin, ent->mins, ent->maxs, traceTo, ent->s.number, ent->clipmask );
+			if ( trace.allsolid || trace.startsolid || (trace.fraction < 1.0f && trace.entityNum != self->s.number && trace.entityNum != self->client->ps.saberEntityNum) )
+			{//okay, try one more check
+				VectorNormalize2( ent->s.pos.trDelta, entDir );
+				VectorMA( ent->currentOrigin, radius, entDir, traceTo );
+				gi.trace( &trace, ent->currentOrigin, ent->mins, ent->maxs, traceTo, ent->s.number, ent->clipmask );
+				if ( trace.allsolid || trace.startsolid || (trace.fraction < 1.0f && trace.entityNum != self->s.number && trace.entityNum != self->client->ps.saberEntityNum) )
+				{//can't hit me, ignore it
+					continue;
+				}
+			}
+			if ( self->s.number != 0 )
+			{//An NPC
+				if ( self->NPC && !self->enemy && ent->owner )
+				{
+					if ( ent->owner->health >= 0 && (!ent->owner->client || ent->owner->client->playerTeam != self->client->playerTeam) )
+					{
+						G_SetEnemy( self, ent->owner );
+					}
+				}
+			}
+			//FIXME: if NPC, predict the intersection between my current velocity/path and the missile's, see if it intersects my bounding box (+/-saberLength?), don't try to deflect unless it does?
+			closestDist = dist;
+			incoming = ent;
+		}
+	}
+
+	if ( incoming )
+	{
+		if ( self->NPC && !G_ControlledByPlayer( self ) )
+		{
+			if ( Jedi_WaitingAmbush( self ) )
+			{
+				Jedi_Ambush( self );
+			}
+			if ( ( self->client->NPC_class == CLASS_BOBAFETT || self->client->NPC_class == CLASS_ROCKETTROOPER )
+				&& self->client->moveType == MT_FLYSWIM 
+				&& incoming->methodOfDeath != MOD_ROCKET_ALT )
+			{//a hovering Boba Fett, not a tracking rocket
+				if ( !Q_irand( 0, 1 ) )
+				{//strafe
+					self->NPC->standTime = 0;
+					self->client->ps.forcePowerDebounce[FP_SABER_DEFENSE] = level.time + Q_irand( 1000, 2000 );
+				}
+				if ( !Q_irand( 0, 1 ) )
+				{//go up/down
+					TIMER_Set( self, "heightChange", Q_irand( 1000, 3000 ) );
+					self->client->ps.forcePowerDebounce[FP_SABER_DEFENSE] = level.time + Q_irand( 1000, 2000 );
+				}
+			}
+			else if ( self->client->NPC_class != CLASS_ROCKETTROOPER 
+				&& Jedi_SaberBlockGo( self, &self->NPC->last_ucmd, NULL, NULL, incoming ) != EVASION_NONE )
+			{//make sure to turn on your saber if it's not on
+				if ( self->client->NPC_class != CLASS_BOBAFETT
+					&& (self->client->NPC_class != CLASS_REBORN || self->s.weapon == WP_SABER) )
+				{
+					self->client->ps.SaberActivate();
+				}
+			}
+		}
+		else//player
+		{
+			if ( !(ucmd->buttons & BUTTON_USE) )//self->s.weapon == WP_SABER && self->client->ps.SaberActive() )
+			{
+				WP_SaberBlockNonRandom( self, incoming->currentOrigin, qtrue );
+			}
+			else
+			{
+				vec3_t diff, start, end;
+				float dist;
+				VectorSubtract( incoming->currentOrigin, self->currentOrigin, diff );
+				dist = VectorLength( diff );
+				VectorNormalize2( incoming->s.pos.trDelta, entDir );
+				VectorMA( incoming->currentOrigin, dist, entDir, start );
+				VectorCopy( self->currentOrigin, end );
+				end[2] += self->maxs[2]*0.75f;
+				gi.trace( &trace, start, incoming->mins, incoming->maxs, end, incoming->s.number, MASK_SHOT, G2_COLLIDE, 10 );
+
+				Jedi_DodgeEvasion( self, incoming->owner, &trace, HL_NONE );
+			}
+			if ( incoming->owner && incoming->owner->client && (!self->enemy || self->enemy->s.weapon != WP_SABER) )//keep enemy jedi over shooters
+			{
+				self->enemy = incoming->owner;
+				NPC_SetLookTarget( self, incoming->owner->s.number, level.time+1000 );
+			}
+		}
+	}
+}
+
+
+//GENERAL SABER============================================================================
+//GENERAL SABER============================================================================
+//GENERAL SABER============================================================================
+//GENERAL SABER============================================================================
+//GENERAL SABER============================================================================
+
+void WP_SetSaberMove(gentity_t *self, short blocked)
+{
+	self->client->ps.saberBlocked = blocked;
+}
+
+extern void CG_CubeOutline( vec3_t mins, vec3_t maxs, int time, unsigned int color, float alpha );
+void WP_SaberUpdate( gentity_t *self, usercmd_t *ucmd )
+{
+	//float	swap;
+	float	minsize = 16;
+
+	if(0)//	if ( self->s.number != 0 )
+	{//for now only the player can do this		// not anymore
+		return;
+	}
+
+	if ( !self->client )
+	{
+		return;
+	}
+	
+	if ( self->client->ps.saberEntityNum < 0 || self->client->ps.saberEntityNum >= ENTITYNUM_WORLD )
+	{//never got one
+		return;
+	}
+
+	// Check if we are throwing it, launch it if needed, update position if needed.
+	WP_SaberThrow(self, ucmd);
+
+
+	//vec3_t saberloc;
+	//vec3_t sabermins={-8,-8,-8}, sabermaxs={8,8,8};
+
+	gentity_t *saberent;
+	
+	if (self->client->ps.saberEntityNum <= 0)
+	{//WTF?!!  We lost it?
+		return;
+	}
+
+	saberent = &g_entities[self->client->ps.saberEntityNum];
+
+	//FIXME: Based on difficulty level/jedi saber combat skill, make this bounding box fatter/smaller
+	if ( self->client->ps.saberBlocked != BLOCKED_NONE )
+	{//we're blocking, increase min size
+		minsize = 32;
+	}
+
+	if ( G_InCinematicSaberAnim( self ) )
+	{//fake some blocking
+		self->client->ps.saberBlocking = BLK_TIGHT;
+		if ( self->client->ps.saber[0].Active() )
+		{
+			self->client->ps.saber[0].ActivateTrail( 150 );
+		}
+		if ( self->client->ps.saber[1].Active() )
+		{
+			self->client->ps.saber[1].ActivateTrail( 150 );
+		}
+	}
+	
+	//is our saber in flight?
+	if ( !self->client->ps.saberInFlight )
+	{	// It isn't, which means we can update its position as we will.
+		Vehicle_t *pVeh = G_IsRidingVehicle( self );
+		if ( !self->client->ps.SaberActive() 
+			|| PM_InKnockDown( &self->client->ps ) 
+			|| PM_SuperBreakLoseAnim( self->client->ps.torsoAnim ) 
+			|| (pVeh && pVeh->m_pVehicleInfo && pVeh->m_pVehicleInfo->type != VH_ANIMAL && pVeh->m_pVehicleInfo->type != VH_FLIER) )//riding a vehicle that you cannot block shots on
+		{//can't block if saber isn't on
+			VectorClear(saberent->mins);
+			VectorClear(saberent->maxs);
+			G_SetOrigin(saberent, self->currentOrigin);
+		}
+		else if ( self->client->ps.saberBlocking == BLK_TIGHT || self->client->ps.saberBlocking == BLK_WIDE )
+		{//FIXME: keep bbox in front of player, even when wide?
+			vec3_t	saberOrg;
+			if ( ( (self->s.number&&!Jedi_SaberBusy(self)&&!g_saberRealisticCombat->integer) || (self->s.number == 0 && self->client->ps.saberBlocking == BLK_WIDE && (g_saberAutoBlocking->integer||self->client->ps.saberBlockingTime>level.time)) )
+				&& self->client->ps.weaponTime <= 0 
+				&& !G_InCinematicSaberAnim( self ) )
+			{//full-size blocking for non-attacking player with g_saberAutoBlocking on
+				vec3_t saberang={0,0,0}, fwd, sabermins={-8,-8,-8}, sabermaxs={8,8,8};
+
+				saberang[YAW] = self->client->ps.viewangles[YAW];
+				AngleVectors( saberang, fwd, NULL, NULL );
+
+				VectorMA( self->currentOrigin, 12, fwd, saberOrg );
+				
+				VectorAdd( self->mins, sabermins, saberent->mins );
+				VectorAdd( self->maxs, sabermaxs, saberent->maxs );
+
+				saberent->contents = CONTENTS_LIGHTSABER;
+
+				G_SetOrigin( saberent, saberOrg );
+			}
+			else
+			{
+				vec3_t	saberBase, saberTip;
+				int numSabers = 1;
+				if ( self->client->ps.dualSabers )
+				{
+					numSabers = 2;
+				}
+				for ( int saberNum = 0; saberNum < numSabers; saberNum++ )
+				{
+					for ( int bladeNum = 0; bladeNum < self->client->ps.saber[saberNum].numBlades; bladeNum++ )
+					{
+						VectorCopy( self->client->ps.saber[saberNum].blade[bladeNum].muzzlePoint, saberBase );
+						VectorMA( saberBase, self->client->ps.saber[saberNum].blade[bladeNum].length, self->client->ps.saber[saberNum].blade[bladeNum].muzzleDir, saberTip );
+						VectorMA( saberBase, self->client->ps.saber[saberNum].blade[bladeNum].length*0.5, self->client->ps.saber[saberNum].blade[bladeNum].muzzleDir, saberOrg );
+						for ( int i = 0; i < 3; i++ )
+						{
+							/*
+							if ( saberTip[i] > self->client->ps.saber[saberNum].blade[bladeNum].muzzlePoint[i] )
+							{
+								saberent->maxs[i] = saberTip[i] - saberOrg[i] + 8;//self->client->renderInfo.muzzlePoint[i];
+								saberent->mins[i] = self->client->ps.saber[saberNum].blade[bladeNum].muzzlePoint[i] - saberOrg[i] - 8;
+							}
+							else //if ( saberTip[i] < self->client->renderInfo.muzzlePoint[i] )
+							{
+								saberent->maxs[i] = self->client->ps.saber[saberNum].blade[bladeNum].muzzlePoint[i] - saberOrg[i] + 8;
+								saberent->mins[i] = saberTip[i] - saberOrg[i] - 8;//self->client->ps.saber[saberNum].blade[bladeNum].muzzlePoint[i];
+							}
+							*/
+							float newSizeTip = (saberTip[i] - saberOrg[i]);
+							newSizeTip += (newSizeTip>=0)?8:-8;
+							float newSizeBase = (saberBase[i] - saberOrg[i]);
+							newSizeBase += (newSizeBase>=0)?8:-8;
+							if ( newSizeTip > saberent->maxs[i] )
+							{
+								saberent->maxs[i] = newSizeTip;
+							}
+							if ( newSizeBase > saberent->maxs[i] )
+							{
+								saberent->maxs[i] = newSizeBase;
+							}
+							if ( newSizeTip < saberent->mins[i] )
+							{
+								saberent->mins[i] = newSizeTip;
+							}
+							if ( newSizeBase < saberent->mins[i] )
+							{
+								saberent->mins[i] = newSizeBase;
+							}
+						}
+					}
+				}
+				if ( self->client->ps.weaponTime > 0 
+					|| self->s.number 
+					|| g_saberAutoBlocking->integer 
+					|| self->client->ps.saberBlockingTime > level.time )
+				{//if attacking or blocking (or an NPC), inflate to a minimum size
+					for ( int i = 0; i < 3; i++ )
+					{
+						if ( saberent->maxs[i] < minsize )
+						{
+							saberent->maxs[i] = minsize;
+						}
+						if ( saberent->mins[i] > -minsize )
+						{
+							saberent->mins[i] = -minsize;
+						}
+					}
+				}
+				saberent->contents = CONTENTS_LIGHTSABER;
+				G_SetOrigin( saberent, saberOrg );
+			}
+		}
+		/*
+		else if (self->client->ps.saberBlocking == BLK_WIDE)
+		{	// Assuming that we are not swinging, the saber's bounding box should be around the player.
+			vec3_t saberang={0,0,0}, fwd;
+
+			saberang[YAW] = self->client->ps.viewangles[YAW];
+			AngleVectors( saberang, fwd, NULL, NULL );
+
+			VectorMA(self->currentOrigin, 12, fwd, saberloc);
+			
+			VectorAdd(self->mins, sabermins, saberent->mins);
+			VectorAdd(self->maxs, sabermaxs, saberent->maxs);
+
+			saberent->contents = CONTENTS_LIGHTSABER;
+
+			G_SetOrigin( saberent, saberloc);
+		}
+		else if (self->client->ps.saberBlocking == BLK_TIGHT)
+		{	// If the player is swinging, the bbox is around just the saber
+			VectorCopy(self->client->renderInfo.muzzlePoint, sabermins);
+			// Put the limits of the bbox around the saber size.
+			VectorMA(sabermins, self->client->ps.saberLength, self->client->renderInfo.muzzleDir, sabermaxs);
+
+			// Now make the mins into mins and the maxs into maxs
+			if (sabermins[0] > sabermaxs[0])
+			{
+				swap = sabermins[0];
+				sabermins[0] = sabermaxs[0];
+				sabermaxs[0] = swap;
+			}
+			if (sabermins[1] > sabermaxs[1])
+			{
+				swap = sabermins[1];
+				sabermins[1] = sabermaxs[1];
+				sabermaxs[1] = swap;
+			}
+			if (sabermins[2] > sabermaxs[2])
+			{
+				swap = sabermins[2];
+				sabermins[2] = sabermaxs[2];
+				sabermaxs[2] = swap;
+			}
+
+			// Now the loc is halfway between the (absolute) mins and maxs
+			VectorAdd(sabermins, sabermaxs, saberloc);
+			VectorScale(saberloc, 0.5, saberloc);
+
+			// Finally, turn the mins and maxs, which are absolute, into relative mins and maxs.
+			VectorSubtract(sabermins, saberloc, saberent->mins);
+			VectorSubtract(sabermaxs, saberloc, saberent->maxs);
+
+			saberent->contents = CONTENTS_LIGHTSABER;// | CONTENTS_SHOTCLIP;
+
+			G_SetOrigin( saberent, saberloc);
+		}
+		*/
+		else
+		{	// Otherwise there is no blocking possible.
+			VectorClear(saberent->mins);
+			VectorClear(saberent->maxs);
+			G_SetOrigin(saberent, self->currentOrigin);
+		}
+		saberent->clipmask = MASK_SHOT | CONTENTS_LIGHTSABER;
+		gi.linkentity(saberent);
+	}
+	else
+	{
+		WP_SaberInFlightReflectCheck( self, ucmd );
+	}
+#ifndef FINAL_BUILD
+	if ( d_saberCombat->integer > 2 )
+	{
+		CG_CubeOutline( saberent->absmin, saberent->absmax, 50, WPDEBUG_SaberColor( self->client->ps.saber[0].blade[0].color ), 1 );
+	}
+#endif
+}
+
+#define	MAX_RADIUS_ENTS			256	//NOTE: This can cause entities to be lost
+qboolean G_CheckEnemyPresence( gentity_t *ent, int dir, float radius, float tolerance )
+{
+	gentity_t	*radiusEnts[ MAX_RADIUS_ENTS ];
+	vec3_t		mins, maxs;
+	int			numEnts;
+	vec3_t		checkDir, dir2checkEnt;
+	float		dist;
+
+	switch( dir )
+	{
+	case DIR_RIGHT:
+		AngleVectors( ent->currentAngles, NULL, checkDir, NULL );
+		break;
+	case DIR_LEFT:
+		AngleVectors( ent->currentAngles, NULL, checkDir, NULL );
+		VectorScale( checkDir, -1, checkDir );
+		break;
+	case DIR_FRONT:
+		AngleVectors( ent->currentAngles, checkDir, NULL, NULL );
+		break;
+	case DIR_BACK:
+		AngleVectors( ent->currentAngles, checkDir, NULL, NULL );
+		VectorScale( checkDir, -1, checkDir );
+		break;
+	}
+	//Get all ents in range, see if they're living clients and enemies, then check dot to them...
+
+	//Setup the bbox to search in
+	for ( int i = 0; i < 3; i++ )
+	{
+		mins[i] = ent->currentOrigin[i] - radius;
+		maxs[i] = ent->currentOrigin[i] + radius;
+	}
+
+	//Get a number of entities in a given space
+	numEnts = gi.EntitiesInBox( mins, maxs, radiusEnts, MAX_RADIUS_ENTS );
+
+	for ( i = 0; i < numEnts; i++ )
+	{
+		//Don't consider self
+		if ( radiusEnts[i] == ent )
+			continue;
+
+		//Must be valid
+		if ( G_ValidEnemy( ent, radiusEnts[i] ) == qfalse )
+			continue;
+
+		VectorSubtract( radiusEnts[i]->currentOrigin, ent->currentOrigin, dir2checkEnt );
+		dist = VectorNormalize( dir2checkEnt );
+		if ( dist <= radius
+			&& DotProduct( dir2checkEnt, checkDir ) >= tolerance )
+		{
+			//stop on the first one
+			return qtrue;
+		}
+	}
+
+	return qfalse;
+}
+//OTHER JEDI POWERS=========================================================================
+//OTHER JEDI POWERS=========================================================================
+//OTHER JEDI POWERS=========================================================================
+//OTHER JEDI POWERS=========================================================================
+//OTHER JEDI POWERS=========================================================================
+extern gentity_t *TossClientItems( gentity_t *self );
+extern void ChangeWeapon( gentity_t *ent, int newWeapon );
+void WP_DropWeapon( gentity_t *dropper, vec3_t velocity )
+{
+	if ( !dropper || !dropper->client )
+	{
+		return;
+	}
+	int	replaceWeap = WP_NONE;
+	int oldWeap = dropper->s.weapon;
+	gentity_t *weapon = TossClientItems( dropper );
+	if ( oldWeap == WP_THERMAL && dropper->NPC )
+	{//Hmm, maybe all NPCs should go into melee?  Not too many, though, or they mob you and look silly
+		replaceWeap = WP_MELEE;
+	}
+	if ( dropper->ghoul2.IsValid() )
+	{
+		if ( dropper->weaponModel[0] > 0 )
+		{//NOTE: guess you never drop the left-hand weapon, eh?
+			gi.G2API_RemoveGhoul2Model( dropper->ghoul2, dropper->weaponModel[0] );
+			dropper->weaponModel[0] = -1;
+		}
+	}
+	//FIXME: does this work on the player?
+	dropper->client->ps.stats[STAT_WEAPONS] |= ( 1 << replaceWeap );
+	if ( !dropper->s.number )
+	{
+		if ( oldWeap == WP_THERMAL )
+		{
+			dropper->client->ps.ammo[weaponData[oldWeap].ammoIndex] -= weaponData[oldWeap].energyPerShot;
+		}
+		else
+		{
+			dropper->client->ps.stats[STAT_WEAPONS] &= ~( 1 << oldWeap );
+		}
+		CG_ChangeWeapon( replaceWeap );
+	}
+	else
+	{
+		dropper->client->ps.stats[STAT_WEAPONS] &= ~( 1 << oldWeap );
+	}
+	ChangeWeapon( dropper, replaceWeap );
+	dropper->s.weapon = replaceWeap;
+	if ( dropper->NPC )
+	{
+		dropper->NPC->last_ucmd.weapon = replaceWeap;
+	}
+	if ( weapon != NULL && velocity && !VectorCompare( velocity, vec3_origin ) )
+	{//weapon should have a direction to it's throw
+		VectorScale( velocity, 3, weapon->s.pos.trDelta );//NOTE: Presumes it is moving already...?
+		if ( weapon->s.pos.trDelta[2] < 150 )
+		{//this is presuming you don't want them to drop the weapon down on you...
+			weapon->s.pos.trDelta[2] = 150;
+		}
+		//FIXME: gets stuck inside it's former owner...
+		weapon->forcePushTime = level.time + 600; // let the push effect last for 600 ms
+	}
+}
+
+void WP_KnockdownTurret( gentity_t *self, gentity_t *pas )
+{
+	//knock it over
+	VectorCopy( pas->currentOrigin, pas->s.pos.trBase );
+	pas->s.pos.trType = TR_LINEAR_STOP;
+	pas->s.pos.trDuration = 250;
+	pas->s.pos.trTime = level.time; 
+	pas->s.pos.trDelta[2] = ( 12.0f / ( pas->s.pos.trDuration * 0.001f ) );
+
+	VectorCopy( pas->currentAngles, pas->s.apos.trBase );
+	pas->s.apos.trType = TR_LINEAR_STOP;
+	pas->s.apos.trDuration = 250; 
+	pas->s.apos.trTime = level.time; 
+	//FIXME: pick pitch/roll that always tilts it directly away from pusher
+	pas->s.apos.trDelta[PITCH] = ( 100.0f / ( pas->s.apos.trDuration * 0.001f ) );
+
+	//kill it
+	pas->count = 0;
+	pas->nextthink = -1;
+	G_Sound( pas, G_SoundIndex( "sound/chars/turret/shutdown.wav" ));
+	//push effect?
+	pas->forcePushTime = level.time + 600; // let the push effect last for 600 ms
+}
+
+void WP_ForceThrowHazardTrooper( gentity_t *self, gentity_t *trooper, qboolean pull )
+{
+	if ( !self || !self->client )
+	{
+		return;
+	}
+	if ( !trooper || !trooper->client )
+	{
+		return;
+	}
+
+	//all levels: see effect on them, they notice us
+	trooper->forcePushTime = level.time + 600; // let the push effect last for 600 ms
+
+	if ( (pull&&self->client->ps.forcePowerLevel[FP_PULL]>FORCE_LEVEL_1)
+		|| (!pull&&self->client->ps.forcePowerLevel[FP_PUSH]>FORCE_LEVEL_1) )
+	{//level 2: they stop for a couple seconds and make a sound
+		trooper->painDebounceTime = level.time + Q_irand( 1500, 2500 );
+		G_AddVoiceEvent( trooper, Q_irand(EV_PUSHED1, EV_PUSHED3), Q_irand( 1000, 3000 ) );
+		GEntity_PainFunc( trooper, self, self, trooper->currentOrigin, 0, MOD_MELEE );
+
+		if ( (pull&&self->client->ps.forcePowerLevel[FP_PULL]>FORCE_LEVEL_2)
+			|| (!pull&&self->client->ps.forcePowerLevel[FP_PUSH]>FORCE_LEVEL_2) )
+		{//level 3: they actually play a pushed anim and stumble a bit
+			vec3_t hazAngles = {0,trooper->currentAngles[YAW],0};
+			int anim = -1;
+			if ( InFront( self->currentOrigin, trooper->currentOrigin, hazAngles ) )
+			{//I'm on front of him
+				if ( pull )
+				{
+					anim = BOTH_PAIN4;
+				}
+				else
+				{
+					anim = BOTH_PAIN1;
+				}
+			}
+			else
+			{//I'm behind him
+				if ( pull )
+				{
+					anim = BOTH_PAIN1;
+				}
+				else
+				{
+					anim = BOTH_PAIN4;
+				}
+			}
+			if ( anim != -1 )
+			{
+				if ( anim == BOTH_PAIN1 )
+				{//make them take a couple steps back
+					AngleVectors( hazAngles, trooper->client->ps.velocity, NULL, NULL );
+					VectorScale( trooper->client->ps.velocity, -40.0f, trooper->client->ps.velocity );
+					trooper->client->ps.pm_flags |= PMF_TIME_NOFRICTION;
+				}
+				else if ( anim == BOTH_PAIN4 )
+				{//make them stumble forward
+					AngleVectors( hazAngles, trooper->client->ps.velocity, NULL, NULL );
+					VectorScale( trooper->client->ps.velocity, 80.0f, trooper->client->ps.velocity );
+					trooper->client->ps.pm_flags |= PMF_TIME_NOFRICTION;
+				}
+				NPC_SetAnim( trooper, SETANIM_BOTH, anim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+				trooper->painDebounceTime += trooper->client->ps.torsoAnimTimer;
+				trooper->client->ps.pm_time = trooper->client->ps.torsoAnimTimer;
+			}
+		}
+		if ( trooper->NPC )
+		{
+			if ( trooper->NPC->shotTime < trooper->painDebounceTime )
+			{
+				trooper->NPC->shotTime = trooper->painDebounceTime;
+			}
+		}
+		trooper->client->ps.weaponTime = trooper->painDebounceTime-level.time;
+	}
+	else
+	{//level 1: no pain reaction, but they should still notice
+		if ( trooper->enemy == NULL//not mad at anyone
+			&& trooper->client->playerTeam != self->client->playerTeam//not on our team
+			&& !(trooper->svFlags&SVF_LOCKEDENEMY)//not locked on an enemy
+			&& !(trooper->svFlags&SVF_IGNORE_ENEMIES)//not ignoring enemie
+			&& !(self->flags&FL_NOTARGET) )//I'm not in notarget
+		{//not already mad at them and can get mad at them, do so
+			G_SetEnemy( trooper, self );
+		}
+	}
+}
+
+void WP_ResistForcePush( gentity_t *self, gentity_t *pusher, qboolean noPenalty )
+{
+	int parts;
+	qboolean runningResist = qfalse;
+
+	if ( !self || self->health <= 0 || !self->client || !pusher || !pusher->client ) 
+	{
+		return;
+	}
+	if ( (!self->s.number 
+			||( self->NPC && (self->NPC->aiFlags&NPCAI_BOSS_CHARACTER) )
+			||( self->client && self->client->NPC_class == CLASS_SHADOWTROOPER )
+			/*
+			|| self->client->NPC_class == CLASS_DESANN 
+			|| !Q_stricmp("Yoda",self->NPC_type) 
+			|| self->client->NPC_class == CLASS_LUKE*/
+		  )
+		&& (VectorLengthSquared( self->client->ps.velocity ) > 10000 || self->client->ps.forcePowerLevel[FP_PUSH] >= FORCE_LEVEL_3 || self->client->ps.forcePowerLevel[FP_PULL] >= FORCE_LEVEL_3 ) )
+	{
+		runningResist = qtrue;
+	}
+	if ( !runningResist
+		&& self->client->ps.groundEntityNum != ENTITYNUM_NONE 
+		&& !PM_SpinningSaberAnim( self->client->ps.legsAnim ) 
+		&& !PM_FlippingAnim( self->client->ps.legsAnim ) 
+		&& !PM_RollingAnim( self->client->ps.legsAnim ) 
+		&& !PM_InKnockDown( &self->client->ps ) 
+		&& !PM_CrouchAnim( self->client->ps.legsAnim ))
+	{//if on a surface and not in a spin or flip, play full body resist
+		parts = SETANIM_BOTH;
+	}
+	else
+	{//play resist just in torso
+		parts = SETANIM_TORSO;
+	}
+	//FIXME: don't interrupt big anims with this!
+	NPC_SetAnim( self, parts, BOTH_RESISTPUSH, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+	if ( !noPenalty )
+	{
+		if ( !runningResist )
+		{
+			VectorClear( self->client->ps.velocity );
+			//still stop them from attacking or moving for a bit, though
+			//FIXME: maybe push just a little (like, slide)?
+			self->client->ps.weaponTime = 1000;
+			if ( self->client->ps.forcePowersActive&(1<<FP_SPEED) )
+			{
+				self->client->ps.weaponTime = floor( self->client->ps.weaponTime * g_timescale->value );
+			}
+			self->client->ps.pm_time = self->client->ps.weaponTime;
+			self->client->ps.pm_flags |= PMF_TIME_KNOCKBACK;
+			//play the full body push effect on me
+			self->forcePushTime = level.time + 600; // let the push effect last for 600 ms
+		}
+		else
+		{
+			self->client->ps.weaponTime = 600;
+			if ( self->client->ps.forcePowersActive&(1<<FP_SPEED) )
+			{
+				self->client->ps.weaponTime = floor( self->client->ps.weaponTime * g_timescale->value );
+			}
+		}
+	}
+	//play my force push effect on my hand
+	//self->client->ps.powerups[PW_FORCE_PUSH] = level.time + self->client->ps.torsoAnimTimer + 500;
+
+	//reset to 0 in case it's still > 0 from a previous push
+	//self->client->pushEffectFadeTime = 0;
+	if ( !pusher //???
+		|| pusher == self->enemy//my enemy tried to push me
+		|| (pusher->client && pusher->client->playerTeam != self->client->playerTeam) )//someone not on my team tried to push me
+	{
+		Jedi_PlayBlockedPushSound( self );
+	}
+}
+
+extern qboolean Boba_StopKnockdown( gentity_t *self, gentity_t *pusher, const vec3_t pushDir, qboolean forceKnockdown );
+extern qboolean Jedi_StopKnockdown( gentity_t *self, gentity_t *pusher, const vec3_t pushDir );
+void WP_ForceKnockdown( gentity_t *self, gentity_t *pusher, qboolean pull, qboolean strongKnockdown, qboolean breakSaberLock )
+{
+	if ( !self || !self->client || !pusher || !pusher->client )
+	{
+		return;
+	}
+
+	if ( self->client->NPC_class == CLASS_ROCKETTROOPER )
+	{
+		return;
+	}
+	else if ( PM_LockedAnim( self->client->ps.legsAnim ) )
+	{//stuck doing something else
+		return;
+	}
+	else if ( Rosh_BeingHealed( self ) )
+	{
+		return;
+	}
+
+	//break out of a saberLock?
+	if ( self->client->ps.saberLockTime > level.time )
+	{
+		if ( breakSaberLock 
+			|| (pusher && self->client->ps.saberLockEnemy == pusher->s.number) )
+		{
+			self->client->ps.saberLockTime = 0;
+			self->client->ps.saberLockEnemy = ENTITYNUM_NONE;
+		}
+		else
+		{
+			return;
+		}
+	}
+
+	if ( self->health > 0 )
+	{
+		if ( !self->s.number )
+		{
+			NPC_SetPainEvent( self );
+		}
+		else
+		{
+			GEntity_PainFunc( self, pusher, pusher, self->currentOrigin, 0, MOD_MELEE );
+		}
+
+		vec3_t	pushDir;
+		if ( pull )
+		{
+			VectorSubtract( pusher->currentOrigin, self->currentOrigin, pushDir );
+		}
+		else
+		{
+			VectorSubtract( self->currentOrigin, pusher->currentOrigin, pushDir );
+		}
+
+		//FIXME: sometimes do this for some NPC force-users, too!
+		if ( Boba_StopKnockdown( self, pusher, pushDir, qtrue ) )
+		{//He can backflip instead of be knocked down
+			return;
+		}
+		else if ( Jedi_StopKnockdown( self, pusher, pushDir ) )
+		{//They can backflip instead of be knocked down
+			return;
+		}
+		
+		G_CheckLedgeDive( self, 72, pushDir, qfalse, qfalse );
+
+		if ( !PM_SpinningSaberAnim( self->client->ps.legsAnim ) 
+			&& !PM_FlippingAnim( self->client->ps.legsAnim ) 
+			&& !PM_RollingAnim( self->client->ps.legsAnim ) 
+			&& !PM_InKnockDown( &self->client->ps ) )
+		{
+			int knockAnim = BOTH_KNOCKDOWN1;//default knockdown
+			if ( pusher->client->NPC_class == CLASS_DESANN && self->client->NPC_class != CLASS_LUKE )
+			{//desann always knocks down, unless you're Luke
+				strongKnockdown = qtrue;
+			}
+			if ( !self->s.number 
+				&& !strongKnockdown 
+				&& ( (!pull&&(self->client->ps.forcePowerLevel[FP_PUSH]>FORCE_LEVEL_1||!g_spskill->integer)) || (pull&&(self->client->ps.forcePowerLevel[FP_PULL]>FORCE_LEVEL_1||!g_spskill->integer)) )	)
+			{//player only knocked down if pushed *hard*
+				if ( self->s.weapon == WP_SABER )
+				{//temp HACK: these are the only 2 pain anims that look good when holding a saber
+					knockAnim = PM_PickAnim( self, BOTH_PAIN2, BOTH_PAIN3 );
+				}
+				else
+				{
+					knockAnim = PM_PickAnim( self, BOTH_PAIN1, BOTH_PAIN18 );
+				}
+			}
+			else if ( PM_CrouchAnim( self->client->ps.legsAnim ) )
+			{//crouched knockdown
+				knockAnim = BOTH_KNOCKDOWN4;
+			}
+			else
+			{//plain old knockdown
+				vec3_t pLFwd, pLAngles = {0,self->client->ps.viewangles[YAW],0};
+				vec3_t sFwd, sAngles = {0,pusher->client->ps.viewangles[YAW],0};
+				AngleVectors( pLAngles, pLFwd, NULL, NULL );
+				AngleVectors( sAngles, sFwd, NULL, NULL );
+				if ( DotProduct( sFwd, pLFwd ) > 0.2f )
+				{//pushing him from behind
+					//FIXME: check to see if we're aiming below or above the waist?
+					if ( pull )
+					{
+						knockAnim = BOTH_KNOCKDOWN1;
+					}
+					else
+					{
+						knockAnim = BOTH_KNOCKDOWN3;
+					}
+				}
+				else
+				{//pushing him from front
+					if ( pull )
+					{
+						knockAnim = BOTH_KNOCKDOWN3;
+					}
+					else
+					{
+						knockAnim = BOTH_KNOCKDOWN1;
+					}
+				}
+			}
+			if ( knockAnim == BOTH_KNOCKDOWN1 && strongKnockdown )
+			{//push *hard*
+				knockAnim = BOTH_KNOCKDOWN2;
+			}
+			NPC_SetAnim( self, SETANIM_BOTH, knockAnim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+			if ( self->s.number >= MAX_CLIENTS )
+			{//randomize getup times - but not for boba
+				int addTime;
+				if ( self->client->NPC_class == CLASS_BOBAFETT )
+				{
+					addTime = Q_irand( -500, 0 );
+				}
+				else
+				{
+					addTime = Q_irand( -300, 300 );
+				}
+				self->client->ps.legsAnimTimer += addTime;
+				self->client->ps.torsoAnimTimer += addTime;
+			}
+			else
+			{//player holds extra long so you have more time to decide to do the quick getup
+				if ( PM_KnockDownAnim( self->client->ps.legsAnim ) )
+				{
+					self->client->ps.legsAnimTimer += PLAYER_KNOCKDOWN_HOLD_EXTRA_TIME;
+					self->client->ps.torsoAnimTimer += PLAYER_KNOCKDOWN_HOLD_EXTRA_TIME;
+				}
+			}
+			//
+			if ( pusher->NPC && pusher->enemy == self )
+			{//pushed pushed down his enemy
+				G_AddVoiceEvent( pusher, Q_irand( EV_GLOAT1, EV_GLOAT3 ), 3000 );
+				pusher->NPC->blockedSpeechDebounceTime = level.time + 3000;
+			}
+		}
+	}
+	self->forcePushTime = level.time + 600; // let the push effect last for 600 ms
+}
+
+qboolean WP_ForceThrowable( gentity_t *ent, gentity_t *forwardEnt, gentity_t *self, qboolean pull, float cone, float radius, vec3_t forward )
+{
+	if (ent == self)
+		return qfalse;
+	if ( ent->owner == self && ent->s.weapon != WP_THERMAL )//can push your own thermals
+		return qfalse;
+	if ( !(ent->inuse) )
+		return qfalse;
+	if ( ent->NPC && ent->NPC->scriptFlags & SCF_NO_FORCE )
+	{
+		if ( ent->s.weapon == WP_SABER )
+		{//Hmm, should jedi do the resist behavior?  If this is on, perhaps it's because of a cinematic?
+			WP_ResistForcePush( ent, self, qtrue );
+		}
+		return qfalse;
+	}
+	if ( (ent->flags&FL_FORCE_PULLABLE_ONLY) && !pull )
+	{//simple HACK: cannot force-push ammo rack items (because they may start in solid)
+		return qfalse;
+	}
+	//FIXME: don't push it if I already pushed it a little while ago
+	if ( ent->s.eType != ET_MISSILE )
+	{
+		if ( ent->client )
+		{
+			if ( ent->client->ps.pullAttackTime > level.time )
+			{
+				return qfalse;
+			}
+		}
+		if ( cone >= 1.0f )
+		{//must be pointing right at them
+			if ( ent != forwardEnt )
+			{//must be the person I'm looking right at
+				if ( ent->client && !pull
+					&& ent->client->ps.forceGripEntityNum == self->s.number
+					&& (self->s.eFlags&EF_FORCE_GRIPPED) )
+				{//this is the guy that's force-gripping me, use a wider cone regardless of force power level
+				}
+				else
+				{
+					if ( ent->client && !pull
+						&& ent->client->ps.forceDrainEntityNum == self->s.number
+						&& (self->s.eFlags&EF_FORCE_DRAINED) )
+					{//this is the guy that's force-draining me, use a wider cone regardless of force power level
+					}
+					else
+					{
+						return qfalse;
+					}
+				}
+			}
+		}
+		if ( ent->s.eType != ET_ITEM && ent->e_ThinkFunc != thinkF_G_RunObject )//|| !(ent->flags&FL_DROPPED_ITEM) )//was only dropped items
+		{
+			//FIXME: need pushable objects
+			if ( ent->s.eFlags & EF_NODRAW )
+			{
+				return qfalse;
+			}
+			if ( !ent->client )
+			{
+				if ( Q_stricmp( "lightsaber", ent->classname ) != 0 )
+				{//not a lightsaber 
+					if ( !(ent->svFlags&SVF_GLASS_BRUSH) )
+					{//and not glass
+						if ( Q_stricmp( "func_door", ent->classname ) != 0 || !(ent->spawnflags & 2/*MOVER_FORCE_ACTIVATE*/) )
+						{//not a force-usable door
+							if ( Q_stricmp( "func_static", ent->classname ) != 0 || (!(ent->spawnflags&1/*F_PUSH*/)&&!(ent->spawnflags&2/*F_PULL*/)) || (ent->spawnflags&32/*SOLITARY*/) )
+							{//not a force-usable func_static or, it is one, but it's solitary, so you only press it when looking right at it
+								if ( Q_stricmp( "limb", ent->classname ) )
+								{//not a limb
+									if ( ent->s.weapon == WP_TURRET && !Q_stricmp( "PAS", ent->classname ) && ent->s.apos.trType == TR_STATIONARY )
+									{//can knock over placed turrets
+										if ( !self->s.number || self->enemy != ent )
+										{//only NPCs who are actively mad at this turret can push it over
+											return qfalse;
+										}
+									}
+									else
+									{
+										return qfalse;
+									}
+								}
+							}
+						}
+						else if ( ent->moverState != MOVER_POS1 && ent->moverState != MOVER_POS2 )
+						{//not at rest
+							return qfalse;
+						}
+					}
+				}
+				//return qfalse;
+			}
+			else if ( ent->client->NPC_class == CLASS_MARK1 )
+			{//can't push Mark1 unless push 3
+				if ( pull || self->client->ps.forcePowerLevel[FP_PUSH] < FORCE_LEVEL_3 )
+				{
+					return qfalse;
+				}
+			}
+			else if ( ent->client->NPC_class == CLASS_GALAKMECH 
+				|| ent->client->NPC_class == CLASS_ATST
+				|| ent->client->NPC_class == CLASS_RANCOR 
+				|| ent->client->NPC_class == CLASS_WAMPA
+				|| ent->client->NPC_class == CLASS_SAND_CREATURE )
+			{//can't push ATST or Galak or Rancor or Wampa
+				return qfalse;
+			}
+			else if ( ent->s.weapon == WP_EMPLACED_GUN )
+			{//FIXME: maybe can pull them out?
+				return qfalse;
+			}
+			else if ( ent->client->playerTeam == self->client->playerTeam && self->enemy && self->enemy != ent )
+			{//can't accidently push a teammate while in combat
+				return qfalse;
+			}
+			else if ( G_IsRidingVehicle( ent ) 
+				&& (ent->s.eFlags&EF_NODRAW) )
+			{//can't push/pull anyone riding *inside* vehicle
+				return qfalse;
+			}
+		}
+		else if ( ent->s.eType == ET_ITEM 
+			&& ent->item 
+			&& ent->item->giType == IT_HOLDABLE 
+			&& ent->item->giTag == INV_SECURITY_KEY )
+			//&& (ent->flags&FL_DROPPED_ITEM) ???
+		{//dropped security keys can't be pushed?  But placed ones can...?  does this make any sense?
+			if ( !pull || self->s.number )
+			{//can't push, NPC's can't do anything to it
+				return qfalse;
+			}
+			else 
+			{
+				if ( g_crosshairEntNum != ent->s.number )
+				{//player can pull it if looking *right* at it
+					if ( cone >= 1.0f )
+					{//we did a forwardEnt trace
+						if ( forwardEnt != ent )
+						{//must be pointing right at them
+							return qfalse;
+						}
+					}
+					else if ( forward )
+					{//do a forwardEnt trace
+						trace_t tr;
+						vec3_t end;
+						VectorMA( self->client->renderInfo.eyePoint, radius, forward, end );
+						gi.trace( &tr, self->client->renderInfo.eyePoint, vec3_origin, vec3_origin, end, self->s.number, MASK_OPAQUE|CONTENTS_SOLID|CONTENTS_BODY|CONTENTS_ITEM|CONTENTS_CORPSE );//was MASK_SHOT, changed to match crosshair trace
+						if ( tr.entityNum != ent->s.number )
+						{//last chance
+							return qfalse;
+						}
+					}
+				}
+			}
+		}
+	}
+	else
+	{
+		switch ( ent->s.weapon )
+		{//only missiles with mass are force-pushable
+		case WP_SABER:
+		case WP_FLECHETTE:
+		case WP_ROCKET_LAUNCHER:
+		case WP_CONCUSSION:
+		case WP_THERMAL:
+		case WP_TRIP_MINE:
+		case WP_DET_PACK:
+			break;
+		//only alt-fire of this weapon is force-pushable
+		case WP_REPEATER:
+			if ( ent->methodOfDeath != MOD_REPEATER_ALT )
+			{//not an alt-fire missile
+				return qfalse;
+			}
+			break;
+		//everything else cannot be pushed
+		case WP_ATST_SIDE:
+			if ( ent->methodOfDeath != MOD_EXPLOSIVE )
+			{//not a rocket
+				return qfalse;
+			}
+			break;
+		default:
+			return qfalse;
+			break;
+		}
+
+		if ( ent->s.pos.trType == TR_STATIONARY && (ent->s.eFlags&EF_MISSILE_STICK) )
+		{//can't force-push/pull stuck missiles (detpacks, tripmines)
+			return qfalse;
+		}
+		if ( ent->s.pos.trType == TR_STATIONARY && ent->s.weapon != WP_THERMAL )
+		{//only thermal detonators can be pushed once stopped
+			return qfalse;
+		}
+	}
+	return qtrue;
+}
+
+void ForceThrow( gentity_t *self, qboolean pull, qboolean fake )
+{//FIXME: pass in a target ent so we (an NPC) can push/pull just one targeted ent.
+	//shove things in front of you away
+	float		dist;
+	gentity_t	*ent, *forwardEnt = NULL;
+	gentity_t	*entityList[MAX_GENTITIES];
+	gentity_t	*push_list[MAX_GENTITIES];
+	int			numListedEntities = 0;
+	vec3_t		mins, maxs;
+	vec3_t		v;
+	int			i, e;
+	int			ent_count = 0;
+	int			radius;
+	vec3_t		center, ent_org, size, forward, right, end, dir, fwdangles = {0};
+	float		dot1, cone;
+	trace_t		tr;
+	int			anim, hold, soundIndex, cost, actualCost;
+	qboolean	noResist = qfalse;
+
+#ifdef _IMMERSION
+	int			forceIndex;
+#endif // _IMMERSION
+	if ( self->health <= 0 )
+	{
+		return;
+	}
+	if ( self->client->ps.leanofs )
+	{//can't force-throw while leaning
+		return;
+	}
+	if ( self->client->ps.forcePowerDebounce[FP_PUSH] > level.time )
+	{//already pushing- now you can't haul someone across the room, sorry
+		return;
+	}
+	if ( self->client->ps.forcePowerDebounce[FP_PULL] > level.time )
+	{//already pulling- now you can't haul someone across the room, sorry
+		return;
+	}
+	if ( self->client->ps.pullAttackTime > level.time )
+	{//already pull-attacking
+		return;
+	}
+	if ( !self->s.number && (cg.zoomMode || in_camera) )
+	{//can't force throw/pull when zoomed in or in cinematic
+		return;
+	}
+	if ( self->client->ps.saberLockTime > level.time )
+	{
+		if ( pull || self->client->ps.forcePowerLevel[FP_PUSH] < FORCE_LEVEL_3 )
+		{//this can be a way to break out
+			return;
+		}
+		//else, I'm breaking my half of the saberlock
+		self->client->ps.saberLockTime = 0;
+		self->client->ps.saberLockEnemy = ENTITYNUM_NONE;
+	}
+
+	if ( self->client->ps.legsAnim == BOTH_KNOCKDOWN3 
+		|| (self->client->ps.torsoAnim == BOTH_FORCE_GETUP_F1 && self->client->ps.torsoAnimTimer > 400)
+		|| (self->client->ps.torsoAnim == BOTH_FORCE_GETUP_F2 && self->client->ps.torsoAnimTimer > 900)
+		|| (self->client->ps.torsoAnim == BOTH_GETUP3 && self->client->ps.torsoAnimTimer > 500)
+		|| (self->client->ps.torsoAnim == BOTH_GETUP4 && self->client->ps.torsoAnimTimer > 300)
+		|| (self->client->ps.torsoAnim == BOTH_GETUP5 && self->client->ps.torsoAnimTimer > 500) )
+	{//we're face-down, so we'd only be force-push/pulling the floor
+		return;
+	}
+	if ( pull )
+	{
+		radius = forcePushPullRadius[self->client->ps.forcePowerLevel[FP_PULL]];
+	}
+	else
+	{
+		radius = forcePushPullRadius[self->client->ps.forcePowerLevel[FP_PUSH]];
+	}
+
+	if ( !radius )
+	{//no ability to do this yet
+		return; 
+	}
+
+	if ( pull )
+	{
+		cost = forcePowerNeeded[FP_PULL];
+		if ( !WP_ForcePowerUsable( self, FP_PULL, cost ) )
+		{
+			return;
+		}
+		//make sure this plays and that you cannot press fire for about 200ms after this
+		anim = BOTH_FORCEPULL;
+		soundIndex = G_SoundIndex( "sound/weapons/force/pull.wav" );
+#ifdef _IMMERSION
+		forceIndex = G_ForceIndex( "fffx/weapons/force/pull", FF_CHANNEL_WEAPON );
+#endif // _IMMERSION
+		hold = 200;
+	}
+	else
+	{
+		cost = forcePowerNeeded[FP_PUSH];
+		if ( !WP_ForcePowerUsable( self, FP_PUSH, cost ) )
+		{
+			return;
+		}
+		//make sure this plays and that you cannot press fire for about 1 second after this
+		anim = BOTH_FORCEPUSH;
+		soundIndex = G_SoundIndex( "sound/weapons/force/push.wav" );
+#ifdef _IMMERSION
+		forceIndex = G_ForceIndex( "fffx/weapons/force/push", FF_CHANNEL_WEAPON );
+#endif // _IMMERSION
+		hold = 650;
+	}
+
+	int parts = SETANIM_TORSO;
+	if ( !PM_InKnockDown( &self->client->ps ) )
+	{
+		if ( self->client->ps.saberLockTime > level.time )
+		{
+			self->client->ps.saberLockTime = 0;
+			self->painDebounceTime = level.time + 2000;
+			hold += 1000;
+			parts = SETANIM_BOTH;
+		}
+		else if ( !VectorLengthSquared( self->client->ps.velocity ) && !(self->client->ps.pm_flags&PMF_DUCKED)) 
+		{
+			parts = SETANIM_BOTH;
+		}
+	}
+	NPC_SetAnim( self, parts, anim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD|SETANIM_FLAG_RESTART );
+	self->client->ps.saberMove = self->client->ps.saberBounceMove = LS_READY;//don't finish whatever saber anim you may have been in
+	self->client->ps.saberBlocked = BLOCKED_NONE;
+	if ( self->client->ps.forcePowersActive&(1<<FP_SPEED) )
+	{
+		hold = floor( hold*g_timescale->value );
+	}
+	self->client->ps.weaponTime = hold;//was 1000, but want to swing sooner
+	//do effect... FIXME: build-up or delay this until in proper part of anim
+	self->client->ps.powerups[PW_FORCE_PUSH] = level.time + self->client->ps.torsoAnimTimer + 500;
+	//reset to 0 in case it's still > 0 from a previous push
+	self->client->pushEffectFadeTime = 0;
+
+	G_Sound( self, soundIndex );
+#ifdef _IMMERSION
+	G_Force( self, forceIndex );
+#endif // _IMMERSION
+
+	if ( (!pull && self->client->ps.forcePowersForced&(1<<FP_PUSH))
+		|| (pull && self->client->ps.forcePowersForced&(1<<FP_PULL)) 
+		|| (pull&&self->client->NPC_class==CLASS_KYLE&&(self->spawnflags&1)&&TIMER_Done( self, "kyleTakesSaber" )) )
+	{
+		noResist = qtrue;
+	}
+
+	VectorCopy( self->client->ps.viewangles, fwdangles );
+	//fwdangles[1] = self->client->ps.viewangles[1];
+	AngleVectors( fwdangles, forward, right, NULL );
+	VectorCopy( self->currentOrigin, center );
+
+	if ( pull )
+	{
+		cone = forcePullCone[self->client->ps.forcePowerLevel[FP_PULL]];
+	}
+	else
+	{
+		cone = forcePushCone[self->client->ps.forcePowerLevel[FP_PUSH]];
+	}
+
+	//	if ( cone >= 1.0f )
+	{//must be pointing right at them
+		VectorMA( self->client->renderInfo.eyePoint, radius, forward, end );
+		gi.trace( &tr, self->client->renderInfo.eyePoint, vec3_origin, vec3_origin, end, self->s.number, MASK_OPAQUE|CONTENTS_SOLID|CONTENTS_BODY|CONTENTS_ITEM|CONTENTS_CORPSE );//was MASK_SHOT, changed to match crosshair trace
+		if ( tr.entityNum < ENTITYNUM_WORLD )
+		{//found something right in front of self,
+			forwardEnt = &g_entities[tr.entityNum];
+			if ( !forwardEnt->client && !Q_stricmp( "func_static", forwardEnt->classname ) )
+			{
+				if ( (forwardEnt->spawnflags&1/*F_PUSH*/)||(forwardEnt->spawnflags&2/*F_PULL*/) )
+				{//push/pullable
+					if ( (forwardEnt->spawnflags&32/*SOLITARY*/) )
+					{//can only push/pull ME, ignore all others
+						if ( forwardEnt->NPC_targetname == NULL
+							|| (self->targetname&&Q_stricmp( forwardEnt->NPC_targetname, self->targetname ) == 0) )
+						{//anyone can push it or only 1 person can push it and it's me
+							push_list[0] = forwardEnt;
+							ent_count = numListedEntities = 1;
+						}
+					}
+				}
+			}
+		}
+	}
+
+	if ( forwardEnt )
+	{
+		if ( G_TryingPullAttack( self, &self->client->usercmd, qtrue ) )
+		{//we're going to try to do a pull attack on our forwardEnt
+			if ( WP_ForceThrowable( forwardEnt, forwardEnt, self, pull, cone, radius, forward ) )
+			{//we will actually pull-attack him, so don't pull him or anything else here
+				//activate the power, here, though, so the later check that actually does the pull attack knows we tried to pull
+				self->client->ps.forcePowersActive |= (1<<FP_PULL);
+				self->client->ps.forcePowerDebounce[FP_PULL] = level.time + 100; //force-pulling
+				return;
+			}
+		}
+	}
+
+	if ( !numListedEntities )
+	{
+		for ( i = 0 ; i < 3 ; i++ ) 
+		{
+			mins[i] = center[i] - radius;
+			maxs[i] = center[i] + radius;
+		}
+
+		numListedEntities = gi.EntitiesInBox( mins, maxs, entityList, MAX_GENTITIES );
+
+		for ( e = 0 ; e < numListedEntities ; e++ ) 
+		{
+			ent = entityList[ e ];
+
+			if ( !WP_ForceThrowable( ent, forwardEnt, self, pull, cone, radius, forward ) )
+			{
+				continue;
+			}
+
+			//this is all to see if we need to start a saber attack, if it's in flight, this doesn't matter
+			// find the distance from the edge of the bounding box
+			for ( i = 0 ; i < 3 ; i++ ) 
+			{
+				if ( center[i] < ent->absmin[i] ) 
+				{
+					v[i] = ent->absmin[i] - center[i];
+				} else if ( center[i] > ent->absmax[i] ) 
+				{
+					v[i] = center[i] - ent->absmax[i];
+				} else 
+				{
+					v[i] = 0;
+				}
+			}
+
+			VectorSubtract( ent->absmax, ent->absmin, size );
+			VectorMA( ent->absmin, 0.5, size, ent_org );
+
+			//see if they're in front of me
+			VectorSubtract( ent_org, center, dir );
+			VectorNormalize( dir );
+			if ( cone < 1.0f )
+			{//must be within the forward cone
+				if ( ent->client && !pull
+					&& ent->client->ps.forceGripEntityNum == self->s.number
+					&& (self->s.eFlags&EF_FORCE_GRIPPED) )
+				{//this is the guy that's force-gripping me, use a wider cone regardless of force power level
+					if ( (dot1 = DotProduct( dir, forward )) < cone-0.3f )
+						continue;
+				}
+				else if ( ent->client && !pull
+					&& ent->client->ps.forceDrainEntityNum == self->s.number
+					&& (self->s.eFlags&EF_FORCE_DRAINED) )
+				{//this is the guy that's force-draining me, use a wider cone regardless of force power level
+					if ( (dot1 = DotProduct( dir, forward )) < cone-0.3f )
+						continue;
+				}
+				else if ( ent->s.eType == ET_MISSILE )//&& ent->s.eType != ET_ITEM && ent->e_ThinkFunc != thinkF_G_RunObject )
+				{//missiles are easier to force-push, never require direct trace (FIXME: maybe also items and general physics objects)
+					if ( (dot1 = DotProduct( dir, forward )) < cone-0.3f )
+						continue;
+				}
+				else if ( (dot1 = DotProduct( dir, forward )) < cone )
+				{
+					continue;
+				}
+			}
+			else if ( ent->s.eType == ET_MISSILE )
+			{//a missile and we're at force level 1... just use a small cone, but not ridiculously small
+				if ( (dot1 = DotProduct( dir, forward )) < 0.75f )
+				{
+					continue;
+				}
+			}//else is an NPC or brush entity that our forward trace would have to hit
+
+			dist = VectorLength( v );
+
+			//Now check and see if we can actually deflect it
+			//method1
+			//if within a certain range, deflect it
+			if ( ent->s.eType == ET_MISSILE && cone >= 1.0f )
+			{//smaller radius on missile checks at force push 1
+				if ( dist >= 192 ) 
+				{
+					continue;
+				}
+			}
+			else if ( dist >= radius ) 
+			{
+				continue;
+			}
+		
+			//in PVS?
+			if ( !ent->bmodel && !gi.inPVS( ent_org, self->client->renderInfo.eyePoint ) )
+			{//must be in PVS
+				continue;
+			}
+
+			if ( ent != forwardEnt )
+			{//don't need to trace against forwardEnt again
+			//really should have a clear LOS to this thing...
+				gi.trace( &tr, self->client->renderInfo.eyePoint, vec3_origin, vec3_origin, ent_org, self->s.number, MASK_FORCE_PUSH );//was MASK_SHOT, but changed to match above trace and crosshair trace
+				if ( tr.fraction < 1.0f && tr.entityNum != ent->s.number )
+				{//must have clear LOS
+					continue;
+				}
+			}
+
+			// ok, we are within the radius, add us to the incoming list
+			push_list[ent_count] = ent;
+			ent_count++;
+		}
+	}
+
+	if ( ent_count )
+	{
+		for ( int x = 0; x < ent_count; x++ )
+		{
+			if ( push_list[x]->client )
+			{
+				vec3_t	pushDir;
+				float	knockback = pull?0:200;
+				
+				//SIGH band-aid...
+				if ( push_list[x]->s.number >= MAX_CLIENTS
+					&& self->s.number < MAX_CLIENTS )
+				{
+					if ( (push_list[x]->client->ps.forcePowersActive&(1<<FP_GRIP)) 
+						//&& push_list[x]->client->ps.forcePowerDebounce[FP_GRIP] < level.time
+						&& push_list[x]->client->ps.forceGripEntityNum == self->s.number )
+					{
+						WP_ForcePowerStop( push_list[x], FP_GRIP );
+					}
+					if ( (push_list[x]->client->ps.forcePowersActive&(1<<FP_DRAIN)) 
+						//&& push_list[x]->client->ps.forcePowerDebounce[FP_DRAIN] < level.time
+						&& push_list[x]->client->ps.forceDrainEntityNum == self->s.number )
+					{
+						WP_ForcePowerStop( push_list[x], FP_DRAIN );
+					}
+				}
+
+				if ( Rosh_BeingHealed( push_list[x] ) )
+				{
+					continue;
+				}
+				if ( push_list[x]->client->NPC_class == CLASS_HAZARD_TROOPER 
+					&& push_list[x]->health > 0 )
+				{//living hazard troopers resist push/pull
+					WP_ForceThrowHazardTrooper( self, push_list[x], pull );
+					continue;
+				}
+				if ( fake )
+				{//always resist
+					WP_ResistForcePush( push_list[x], self, qfalse );
+					continue;
+				}
+//FIXMEFIXMEFIXMEFIXMEFIXME: extern a lot of this common code when I have the time!!!
+				int powerLevel, powerUse;
+				if (pull)
+				{
+					powerLevel = self->client->ps.forcePowerLevel[FP_PULL];
+					powerUse = FP_PULL;
+				}
+				else
+				{
+					powerLevel = self->client->ps.forcePowerLevel[FP_PUSH];
+					powerUse = FP_PUSH;
+				}
+				int modPowerLevel = WP_AbsorbConversion( push_list[x], push_list[x]->client->ps.forcePowerLevel[FP_ABSORB], self, powerUse, powerLevel, forcePowerNeeded[self->client->ps.forcePowerLevel[powerUse]] );
+				if (push_list[x]->client->NPC_class==CLASS_ASSASSIN_DROID ||
+					push_list[x]->client->NPC_class==CLASS_HAZARD_TROOPER)
+				{
+					modPowerLevel = 0;	// devides throw by 10
+				}
+
+				//First, if this is the player we're push/pulling, see if he can counter it
+				if ( modPowerLevel != -1 
+					&& !noResist
+					&& InFront( self->currentOrigin, push_list[x]->client->renderInfo.eyePoint, push_list[x]->client->ps.viewangles, 0.3f ) )
+				{//absorbed and I'm in front of them
+					//counter it
+					if ( push_list[x]->client->ps.forcePowerLevel[FP_ABSORB] > FORCE_LEVEL_2 )
+					{//no reaction at all
+					}
+					else
+					{
+						WP_ResistForcePush( push_list[x], self, qfalse );
+						push_list[x]->client->ps.saberMove = push_list[x]->client->ps.saberBounceMove = LS_READY;//don't finish whatever saber anim you may have been in
+						push_list[x]->client->ps.saberBlocked = BLOCKED_NONE;
+					}
+					continue;
+				}
+				else if ( !push_list[x]->s.number )
+				{//player
+					if ( !noResist
+						&& push_list[x]->health > 0 //alive
+						&& push_list[x]->client //client
+						&& push_list[x]->client->ps.forceRageRecoveryTime < level.time //not recobering from rage
+						&& push_list[x]->client->ps.torsoAnim != BOTH_FORCEGRIP_HOLD// BOTH_FORCEGRIP1//wasn't trying to grip anyone
+						//&& push_list[x]->client->ps.torsoAnim != BOTH_HUGGER1// wasn't trying to grip-drain anyone
+						&& push_list[x]->client->ps.torsoAnim != BOTH_FORCE_DRAIN_GRAB_START// wasn't trying to grip-drain anyone
+						&& push_list[x]->client->ps.torsoAnim != BOTH_FORCE_DRAIN_GRAB_HOLD// wasn't trying to grip-drain anyone
+						&& ((self->client->NPC_class != CLASS_DESANN&&Q_stricmp("Yoda",self->NPC_type)) || !Q_irand( 0, 2 ) )//only 30% chance of resisting a Desann push
+						&& push_list[x]->client->ps.groundEntityNum != ENTITYNUM_NONE//on the ground
+						&& !PM_InKnockDown( &push_list[x]->client->ps )//not knocked down already
+						&& push_list[x]->client->ps.saberLockTime < level.time//not involved in a saberLock
+						&& push_list[x]->client->ps.weaponTime < level.time//not attacking or otherwise busy
+						&& (push_list[x]->client->ps.weapon == WP_SABER||push_list[x]->client->ps.weapon == WP_MELEE) )//using saber or fists
+					{//trying to push or pull the player!
+						if ( push_list[x]->client->ps.powerups[PW_FORCE_PUSH] > level.time//player was pushing/pulling too
+							||( pull && Q_irand( 0, (push_list[x]->client->ps.forcePowerLevel[FP_PULL] - self->client->ps.forcePowerLevel[FP_PULL])*2+1 ) > 0 )//player's pull is high enough
+							||( !pull && Q_irand( 0, (push_list[x]->client->ps.forcePowerLevel[FP_PUSH] - self->client->ps.forcePowerLevel[FP_PUSH])*2+1 ) > 0 ) )//player's push is high enough
+						{//player's force push/pull is high enough to try to stop me
+							if ( InFront( self->currentOrigin, push_list[x]->client->renderInfo.eyePoint, push_list[x]->client->ps.viewangles, 0.3f ) )
+							{//I'm in front of player
+								WP_ResistForcePush( push_list[x], self, qfalse );
+								push_list[x]->client->ps.saberMove = push_list[x]->client->ps.saberBounceMove = LS_READY;//don't finish whatever saber anim you may have been in
+								push_list[x]->client->ps.saberBlocked = BLOCKED_NONE;
+								continue;
+							}
+						}
+					}
+				}
+				else if ( push_list[x]->client && Jedi_WaitingAmbush( push_list[x] ) )
+				{
+					WP_ForceKnockdown( push_list[x], self, pull, qtrue, qfalse );
+					continue;
+				}
+
+				G_KnockOffVehicle( push_list[x], self, pull );
+				
+				if ( !pull
+					&& push_list[x]->client->ps.forceDrainEntityNum == self->s.number
+					&& (self->s.eFlags&EF_FORCE_DRAINED) )
+				{//stop them from draining me now, dammit!
+					WP_ForcePowerStop( push_list[x], FP_DRAIN );
+				}
+
+				//okay, everyone else (or player who couldn't resist it)...
+				if ( ((self->s.number == 0 && Q_irand( 0, 2 ) ) || Q_irand( 0, 2 ) ) && push_list[x]->client && push_list[x]->health > 0 //a living client
+						&& push_list[x]->client->ps.weapon == WP_SABER //Jedi
+						&& push_list[x]->health > 0 //alive
+						&& push_list[x]->client->ps.forceRageRecoveryTime < level.time //not recobering from rage
+						&& ((self->client->NPC_class != CLASS_DESANN&&Q_stricmp("Yoda",self->NPC_type)) || !Q_irand( 0, 2 ) )//only 30% chance of resisting a Desann push
+						&& push_list[x]->client->ps.groundEntityNum != ENTITYNUM_NONE //on the ground
+						&& InFront( self->currentOrigin, push_list[x]->currentOrigin, push_list[x]->client->ps.viewangles, 0.3f ) //I'm in front of him
+						&& ( push_list[x]->client->ps.powerups[PW_FORCE_PUSH] > level.time ||//he's pushing too
+								(push_list[x]->s.number != 0 && push_list[x]->client->ps.weaponTime < level.time)//not the player and not attacking (NPC jedi auto-defend against pushes)
+						   )
+					)
+				{//Jedi don't get pushed, they resist as long as they aren't already attacking and are on the ground
+					if ( push_list[x]->client->ps.saberLockTime > level.time )
+					{//they're in a lock
+						if ( push_list[x]->client->ps.saberLockEnemy != self->s.number )
+						{//they're not in a lock with me
+							continue;
+						}
+						else if ( pull || self->client->ps.forcePowerLevel[FP_PUSH] < FORCE_LEVEL_3 ||
+							push_list[x]->client->ps.forcePowerLevel[FP_PUSH] > FORCE_LEVEL_2 )
+						{//they're in a lock with me, but my push is too weak
+							continue;
+						}
+						else
+						{//we will knock them down
+							self->painDebounceTime = 0;
+							self->client->ps.weaponTime = 500;
+							if ( self->client->ps.forcePowersActive&(1<<FP_SPEED) )
+							{
+								self->client->ps.weaponTime = floor( self->client->ps.weaponTime * g_timescale->value );
+							}
+						}
+					}
+					int resistChance = Q_irand(0, 2);
+					if ( push_list[x]->s.number >= MAX_CLIENTS )
+					{//NPC
+						if ( g_spskill->integer == 1 )
+						{//stupid tweak for graham
+							resistChance = Q_irand(0, 3);
+						}
+					}
+					if ( noResist ||
+							( !pull 
+							&& modPowerLevel == -1
+							&& self->client->ps.forcePowerLevel[FP_PUSH] > FORCE_LEVEL_2 
+							&& !resistChance
+							&& push_list[x]->client->ps.forcePowerLevel[FP_PUSH] < FORCE_LEVEL_3 )
+						)
+					{//a level 3 push can even knock down a jedi
+						if ( PM_InKnockDown( &push_list[x]->client->ps ) )
+						{//can't knock them down again
+							continue;
+						}
+						WP_ForceKnockdown( push_list[x], self, pull, qfalse, qtrue );
+					}
+					else
+					{
+						WP_ResistForcePush( push_list[x], self, qfalse );
+					}
+				}
+				else 
+				{
+					//UGH: FIXME: for enemy jedi, they should probably always do force pull 3, and not your weapon (if player?)!
+					//shove them
+					if ( push_list[x]->NPC 
+						&& push_list[x]->NPC->jumpState == JS_JUMPING )
+					{//don't interrupt a scripted jump
+						//WP_ResistForcePush( push_list[x], self, qfalse );
+						push_list[x]->forcePushTime = level.time + 600; // let the push effect last for 600 ms
+						continue;
+					}
+
+					if ( push_list[x]->s.number 
+						&& (push_list[x]->message || (push_list[x]->flags&FL_NO_KNOCKBACK)) )
+					{//an NPC who has a key
+						//don't push me... FIXME: maybe can pull the key off me?
+						WP_ForceKnockdown( push_list[x], self, pull, qfalse, qfalse );
+						continue;
+					}
+					if ( pull )
+					{
+						VectorSubtract( self->currentOrigin, push_list[x]->currentOrigin, pushDir );
+						if ( self->client->ps.forcePowerLevel[FP_PULL] >= FORCE_LEVEL_3 
+							&& self->client->NPC_class == CLASS_KYLE 
+							&& (self->spawnflags&1) 
+							&& TIMER_Done( self, "kyleTakesSaber" )
+							&& push_list[x]->client
+							&& push_list[x]->client->ps.weapon == WP_SABER 
+							&& !push_list[x]->client->ps.saberInFlight
+							&& push_list[x]->client->ps.saberEntityNum < ENTITYNUM_WORLD 
+							&& !PM_InOnGroundAnim( &push_list[x]->client->ps ) )
+						{
+							vec3_t throwVec;
+							VectorScale( pushDir, 10.0f, throwVec );
+							WP_SaberLose( push_list[x], throwVec );
+							NPC_SetAnim( push_list[x], SETANIM_BOTH, BOTH_LOSE_SABER, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+							push_list[x]->client->ps.torsoAnimTimer += 500;
+							push_list[x]->client->ps.pm_time = push_list[x]->client->ps.weaponTime = push_list[x]->client->ps.torsoAnimTimer;
+							push_list[x]->client->ps.pm_flags |= PMF_TIME_KNOCKBACK;
+							push_list[x]->client->ps.saberMove = LS_NONE;
+							push_list[x]->aimDebounceTime = level.time + push_list[x]->client->ps.torsoAnimTimer;
+							VectorClear( push_list[x]->client->ps.velocity );
+							VectorClear( push_list[x]->client->ps.moveDir );
+							//Kyle will stand around for a bit, too...
+							self->client->ps.pm_time = self->client->ps.weaponTime = 2000;
+							self->client->ps.pm_flags |= PMF_TIME_KNOCKBACK;
+							self->painDebounceTime = level.time + self->client->ps.weaponTime;
+							TIMER_Set( self, "kyleTakesSaber", Q_irand( 60000, 180000 ) );//don't do this again for a while
+							G_AddVoiceEvent( self, Q_irand(EV_TAUNT1,EV_TAUNT3), Q_irand( 4000, 6000 ) );
+							VectorClear( self->client->ps.velocity );
+							VectorClear( self->client->ps.moveDir );
+							continue;
+						}
+						else if ( push_list[x]->NPC
+							&& (push_list[x]->NPC->scriptFlags&SCF_DONT_FLEE) )
+						{//*SIGH*... if an NPC can't flee, they can't run after and pick up their weapon, do don't drop it
+						}
+						else if ( self->client->ps.forcePowerLevel[FP_PULL] > FORCE_LEVEL_1 
+							&& push_list[x]->client->NPC_class != CLASS_ROCKETTROOPER//rockettroopers never drop their weapon
+							&& push_list[x]->client->NPC_class != CLASS_VEHICLE
+							&& push_list[x]->client->NPC_class != CLASS_BOBAFETT
+							&& push_list[x]->client->NPC_class != CLASS_TUSKEN
+							&& push_list[x]->client->NPC_class != CLASS_HAZARD_TROOPER
+							&& push_list[x]->client->NPC_class != CLASS_ASSASSIN_DROID
+							&& push_list[x]->s.weapon != WP_SABER 
+							&& push_list[x]->s.weapon != WP_MELEE 
+							&& push_list[x]->s.weapon != WP_THERMAL 
+							&& push_list[x]->s.weapon != WP_CONCUSSION	// so rax can't drop his
+							) 
+						{//yank the weapon - NOTE: level 1 just knocks them down, not take weapon
+							//FIXME: weapon yank anim if not a knockdown?
+							if ( InFront( self->currentOrigin, push_list[x]->currentOrigin, push_list[x]->client->ps.viewangles, 0.0f ) )
+							{//enemy has to be facing me, too...
+								WP_DropWeapon( push_list[x], pushDir );
+							}
+						}
+						knockback += VectorNormalize( pushDir );
+						if ( knockback > 200 )
+						{
+							knockback = 200;
+						}
+						if ( self->client->ps.forcePowerLevel[FP_PULL] < FORCE_LEVEL_3 )
+						{//maybe just knock them down
+							knockback /= 3;
+						}
+					}
+					else
+					{
+						VectorSubtract( push_list[x]->currentOrigin, self->currentOrigin, pushDir );
+						knockback -= VectorNormalize( pushDir );
+						if ( knockback < 100 )
+						{
+							knockback = 100;
+						}
+						//scale for push level
+						if ( self->client->ps.forcePowerLevel[FP_PUSH] < FORCE_LEVEL_2 )
+						{//maybe just knock them down
+							knockback /= 3;
+						}
+						else if ( self->client->ps.forcePowerLevel[FP_PUSH] > FORCE_LEVEL_2 )
+						{//super-hard push
+							//Hmm, maybe in this case can even nudge/knockdown a jedi?  Especially if close?
+							//knockback *= 5;
+						}
+					}
+
+					if ( modPowerLevel != -1 )
+					{
+						if ( !modPowerLevel )
+						{
+							knockback /= 10.0f;
+						}
+						else if ( modPowerLevel == 1 )
+						{
+							knockback /= 6.0f;
+						}
+						else// if ( modPowerLevel == 2 )
+						{
+							knockback /= 2.0f;
+						}
+					}
+					//actually push/pull the enemy
+					G_Throw( push_list[x], pushDir, knockback );
+					//make it so they don't actually hurt me when pulled at me...
+					push_list[x]->forcePuller = self->s.number;
+
+					if ( push_list[x]->client->ps.groundEntityNum != ENTITYNUM_NONE )
+					{//if on the ground, make sure they get shoved up some
+						if ( push_list[x]->client->ps.velocity[2] < knockback )
+						{
+							push_list[x]->client->ps.velocity[2] = knockback;
+						}
+					}
+
+					if ( push_list[x]->health > 0 )
+					{//target is still alive
+						if ( (push_list[x]->s.number||(cg.renderingThirdPerson&&!cg.zoomMode)) //NPC or 3rd person player
+							&& ((!pull&&self->client->ps.forcePowerLevel[FP_PUSH] < FORCE_LEVEL_2 && push_list[x]->client->ps.forcePowerLevel[FP_PUSH] < FORCE_LEVEL_1) //level 1 push
+								|| (pull && self->client->ps.forcePowerLevel[FP_PULL] < FORCE_LEVEL_2 && push_list[x]->client->ps.forcePowerLevel[FP_PULL] < FORCE_LEVEL_1)) )//level 1 pull
+						{//NPC or third person player (without force push/pull skill), and force push/pull level is at 1
+							WP_ForceKnockdown( push_list[x], self, pull, (!pull&&knockback>150), qfalse );
+						}
+						else if ( !push_list[x]->s.number )
+						{//player, have to force an anim on him
+							WP_ForceKnockdown( push_list[x], self, pull, (!pull&&knockback>150), qfalse );
+						}
+						else
+						{//NPC and force-push/pull at level 2 or higher
+							WP_ForceKnockdown( push_list[x], self, pull, (!pull&&knockback>100), qfalse );
+						}
+					}
+					push_list[x]->forcePushTime = level.time + 600; // let the push effect last for 600 ms
+				}
+			}
+			else if ( !fake )
+			{//not a fake push/pull
+				if ( push_list[x]->s.weapon == WP_SABER && (push_list[x]->contents&CONTENTS_LIGHTSABER) )
+				{//a thrown saber, just send it back
+					/*
+					if ( pull )
+					{//steal it?
+					}
+					else */if ( push_list[x]->owner && push_list[x]->owner->client && push_list[x]->owner->client->ps.SaberActive() && push_list[x]->s.pos.trType == TR_LINEAR && push_list[x]->owner->client->ps.saberEntityState != SES_RETURNING )
+					{//it's on and being controlled
+						//FIXME: prevent it from damaging me?
+						if ( self->s.number == 0 || Q_irand( 0, 2 ) )
+						{//certain chance of throwing it aside and turning it off?
+							//give it some velocity away from me
+							//FIXME: maybe actually push or pull it?
+							if ( Q_irand( 0, 1 ) )
+							{
+								VectorScale( right, -1, right );
+							}
+							G_ReflectMissile( self, push_list[x], right );
+							//FIXME: isn't turning off!!!
+							WP_SaberDrop( push_list[x]->owner, push_list[x] );
+						}
+						else
+						{
+							WP_SaberReturn( push_list[x]->owner, push_list[x] );
+						}
+						//different effect?
+					}
+				}
+				else if ( push_list[x]->s.eType == ET_MISSILE 
+					&& push_list[x]->s.pos.trType != TR_STATIONARY 
+					&& (push_list[x]->s.pos.trType != TR_INTERPOLATE||push_list[x]->s.weapon != WP_THERMAL) )//rolling and stationary thermal detonators are dealt with below
+				{
+					vec3_t dir2Me;
+					VectorSubtract( self->currentOrigin, push_list[x]->currentOrigin, dir2Me );
+					float dot = DotProduct( push_list[x]->s.pos.trDelta, dir2Me );
+					if ( pull )
+					{//deflect rather than reflect?
+					}
+					else 
+					{
+						if ( push_list[x]->s.eFlags&EF_MISSILE_STICK )
+						{//caught a sticky in-air
+							push_list[x]->s.eType = ET_MISSILE;
+							push_list[x]->s.eFlags &= ~EF_MISSILE_STICK;
+							push_list[x]->s.eFlags |= EF_BOUNCE_HALF;
+							push_list[x]->splashDamage /= 3;
+							push_list[x]->splashRadius /= 3;
+							push_list[x]->e_ThinkFunc = thinkF_WP_Explode;
+							push_list[x]->nextthink = level.time + Q_irand( 500, 3000 );
+						}
+						if ( dot >= 0 )
+						{//it's heading towards me
+							G_ReflectMissile( self, push_list[x], forward );
+						}
+						else
+						{
+							VectorScale( push_list[x]->s.pos.trDelta, 1.25f, push_list[x]->s.pos.trDelta );
+						}
+						//deflect sound
+						//G_Sound( push_list[x], G_SoundIndex( va("sound/weapons/blaster/reflect%d.wav", Q_irand( 1, 3 ) ) ) );
+						//push_list[x]->forcePushTime = level.time + 600; // let the push effect last for 600 ms
+					}
+					if ( push_list[x]->s.eType == ET_MISSILE 
+						&& push_list[x]->s.weapon == WP_ROCKET_LAUNCHER 
+						&& push_list[x]->damage < 60 )
+					{//pushing away a rocket raises it's damage to the max for NPCs
+						push_list[x]->damage = 60;
+					}
+				}
+				else if ( push_list[x]->svFlags & SVF_GLASS_BRUSH )
+				{//break the glass
+					trace_t tr;
+					vec3_t	pushDir;
+					float	damage = 800;
+
+					AngleVectors( self->client->ps.viewangles, forward, NULL, NULL );
+					VectorNormalize( forward );
+					VectorMA( self->client->renderInfo.eyePoint, radius, forward, end );
+					gi.trace( &tr, self->client->renderInfo.eyePoint, vec3_origin, vec3_origin, end, self->s.number, MASK_SHOT );
+					if ( tr.entityNum != push_list[x]->s.number || tr.fraction == 1.0 || tr.allsolid || tr.startsolid )
+					{//must be pointing right at it
+						continue;
+					}
+
+					if ( pull )
+					{
+						VectorSubtract( self->client->renderInfo.eyePoint, tr.endpos, pushDir );
+					}
+					else
+					{
+						VectorSubtract( tr.endpos, self->client->renderInfo.eyePoint, pushDir );
+					}
+					/*
+					VectorSubtract( push_list[x]->absmax, push_list[x]->absmin, size );
+					VectorMA( push_list[x]->absmin, 0.5, size, center );
+					if ( pull )
+					{
+						VectorSubtract( self->client->renderInfo.eyePoint, center, pushDir );
+					}
+					else
+					{
+						VectorSubtract( center, self->client->renderInfo.eyePoint, pushDir );
+					}
+					*/
+					damage -= VectorNormalize( pushDir );
+					if ( damage < 200 )
+					{
+						damage = 200;
+					}
+					VectorScale( pushDir, damage, pushDir );
+
+					G_Damage( push_list[x], self, self, pushDir, tr.endpos, damage, 0, MOD_UNKNOWN );
+				}
+				else if ( !Q_stricmp( "func_static", push_list[x]->classname ) )
+				{//force-usable func_static
+					if ( !pull && (push_list[x]->spawnflags&1/*F_PUSH*/) )
+					{
+						if ( push_list[x]->NPC_targetname == NULL
+							|| (self->targetname&&Q_stricmp( push_list[x]->NPC_targetname, self->targetname ) == 0) )
+						{//anyone can pull it or only 1 person can push it and it's me
+							GEntity_UseFunc( push_list[x], self, self );
+						}
+					}
+					else if ( pull && (push_list[x]->spawnflags&2/*F_PULL*/) )
+					{
+						if ( push_list[x]->NPC_targetname == NULL
+							|| (self->targetname&&Q_stricmp( push_list[x]->NPC_targetname, self->NPC_targetname ) == 0) )
+						{//anyone can push it or only 1 person can push it and it's me
+							GEntity_UseFunc( push_list[x], self, self );
+						}
+					}
+				}
+				else if ( !Q_stricmp( "func_door", push_list[x]->classname ) && (push_list[x]->spawnflags&2/*MOVER_FORCE_ACTIVATE*/) )
+				{//push/pull the door
+					vec3_t	pos1, pos2;
+
+					AngleVectors( self->client->ps.viewangles, forward, NULL, NULL );
+					VectorNormalize( forward );
+					VectorMA( self->client->renderInfo.eyePoint, radius, forward, end );
+					gi.trace( &tr, self->client->renderInfo.eyePoint, vec3_origin, vec3_origin, end, self->s.number, MASK_SHOT );
+					if ( tr.entityNum != push_list[x]->s.number || tr.fraction == 1.0 || tr.allsolid || tr.startsolid )
+					{//must be pointing right at it
+						continue;
+					}
+
+					if ( VectorCompare( vec3_origin, push_list[x]->s.origin ) )
+					{//does not have an origin brush, so pos1 & pos2 are relative to world origin, need to calc center
+						VectorSubtract( push_list[x]->absmax, push_list[x]->absmin, size );
+						VectorMA( push_list[x]->absmin, 0.5, size, center );
+						if ( (push_list[x]->spawnflags&1) && push_list[x]->moverState == MOVER_POS1 )
+						{//if at pos1 and started open, make sure we get the center where it *started* because we're going to add back in the relative values pos1 and pos2
+							VectorSubtract( center, push_list[x]->pos1, center );
+						}
+						else if ( !(push_list[x]->spawnflags&1) && push_list[x]->moverState == MOVER_POS2 )
+						{//if at pos2, make sure we get the center where it *started* because we're going to add back in the relative values pos1 and pos2
+							VectorSubtract( center, push_list[x]->pos2, center );
+						}
+						VectorAdd( center, push_list[x]->pos1, pos1 );
+						VectorAdd( center, push_list[x]->pos2, pos2 );
+					}
+					else
+					{//actually has an origin, pos1 and pos2 are absolute
+						VectorCopy( push_list[x]->currentOrigin, center );
+						VectorCopy( push_list[x]->pos1, pos1 );
+						VectorCopy( push_list[x]->pos2, pos2 );
+					}
+
+					if ( Distance( pos1, self->client->renderInfo.eyePoint ) < Distance( pos2, self->client->renderInfo.eyePoint ) )
+					{//pos1 is closer
+						if ( push_list[x]->moverState == MOVER_POS1 )
+						{//at the closest pos
+							if ( pull )
+							{//trying to pull, but already at closest point, so screw it
+								continue;
+							}
+						}
+						else if ( push_list[x]->moverState == MOVER_POS2 )
+						{//at farthest pos
+							if ( !pull )
+							{//trying to push, but already at farthest point, so screw it
+								continue;
+							}
+						}
+					}
+					else
+					{//pos2 is closer
+						if ( push_list[x]->moverState == MOVER_POS1 )
+						{//at the farthest pos
+							if ( !pull )
+							{//trying to push, but already at farthest point, so screw it
+								continue;
+							}
+						}
+						else if ( push_list[x]->moverState == MOVER_POS2 )
+						{//at closest pos
+							if ( pull )
+							{//trying to pull, but already at closest point, so screw it
+								continue;
+							}
+						}
+					}
+					GEntity_UseFunc( push_list[x], self, self );
+				}
+				else if ( push_list[x]->s.eType == ET_MISSILE/*thermal resting on ground*/ 
+					|| push_list[x]->s.eType == ET_ITEM 
+					|| push_list[x]->e_ThinkFunc == thinkF_G_RunObject || Q_stricmp( "limb", push_list[x]->classname ) == 0 )
+				{//general object, toss it
+					vec3_t	pushDir, kvel;
+					float	knockback = pull?0:200;
+					float	mass = 200;
+
+					if ( pull )
+					{
+						if ( push_list[x]->s.eType == ET_ITEM )
+						{//pull it to a little higher point
+							vec3_t	adjustedOrg;
+							VectorCopy( self->currentOrigin, adjustedOrg );
+							adjustedOrg[2] += self->maxs[2]/3;
+							VectorSubtract( adjustedOrg, push_list[x]->currentOrigin, pushDir );
+						}
+						else if ( self->enemy //I have an enemy
+							//&& push_list[x]->s.eType != ET_ITEM //not an item
+							&& self->client->ps.forcePowerLevel[FP_PUSH] > FORCE_LEVEL_2 //have push 3 or greater
+							&& InFront(push_list[x]->currentOrigin, self->currentOrigin, self->currentAngles, 0.25f)//object is generally in front of me
+							&& InFront(self->enemy->currentOrigin, self->currentOrigin, self->currentAngles, 0.75f)//enemy is pretty much right in front of me
+							&& !InFront(push_list[x]->currentOrigin, self->enemy->currentOrigin, self->enemy->currentAngles, -0.25f)//object is generally behind enemy
+							//FIXME: check dist to enemy and clear LOS to enemy and clear Path between object and enemy?
+							&& ( (self->NPC&&(noResist||Q_irand(0,RANK_CAPTAIN)<self->NPC->rank) )//NPC with enough skill
+								||( self->s.number<MAX_CLIENTS ) )
+							)
+						{//if I have an auto-enemy & he's in front of me, push it toward him!
+							/*
+							if ( targetedObjectMassTotal + push_list[x]->mass > TARGETED_OBJECT_PUSH_MASS_MAX )
+							{//already pushed too many things
+								//FIXME: pick closest?
+								continue;
+							}
+							targetedObjectMassTotal += push_list[x]->mass;
+							*/
+							VectorSubtract( self->enemy->currentOrigin, push_list[x]->currentOrigin, pushDir );
+						}
+						else
+						{
+							VectorSubtract( self->currentOrigin, push_list[x]->currentOrigin, pushDir );
+						}
+						knockback += VectorNormalize( pushDir );
+						if ( knockback > 200 )
+						{
+							knockback = 200;
+						}
+						if ( push_list[x]->s.eType == ET_ITEM 
+							&& push_list[x]->item 
+							&& push_list[x]->item->giType == IT_HOLDABLE 
+							&& push_list[x]->item->giTag == INV_SECURITY_KEY )
+						{//security keys are pulled with less enthusiasm
+							if ( knockback > 100 )
+							{
+								knockback = 100;
+							}
+						}
+						else if ( knockback > 200 )
+						{
+							knockback = 200;
+						}
+					}
+					else
+					{
+						if ( self->enemy //I have an enemy
+							&& push_list[x]->s.eType != ET_ITEM //not an item
+							&& self->client->ps.forcePowerLevel[FP_PUSH] > FORCE_LEVEL_2 //have push 3 or greater
+							&& InFront(push_list[x]->currentOrigin, self->currentOrigin, self->currentAngles, 0.25f)//object is generally in front of me
+							&& InFront(self->enemy->currentOrigin, self->currentOrigin, self->currentAngles, 0.75f)//enemy is pretty much right in front of me
+							&& InFront(push_list[x]->currentOrigin, self->enemy->currentOrigin, self->enemy->currentAngles, 0.25f)//object is generally in front of enemy
+							//FIXME: check dist to enemy and clear LOS to enemy and clear Path between object and enemy?
+							&& ( (self->NPC&&(noResist||Q_irand(0,RANK_CAPTAIN)<self->NPC->rank) )//NPC with enough skill
+								||( self->s.number<MAX_CLIENTS ) )
+							)
+						{//if I have an auto-enemy & he's in front of me, push it toward him!
+							/*
+							if ( targetedObjectMassTotal + push_list[x]->mass > TARGETED_OBJECT_PUSH_MASS_MAX )
+							{//already pushed too many things
+								//FIXME: pick closest?
+								continue;
+							}
+							targetedObjectMassTotal += push_list[x]->mass;
+							*/
+							VectorSubtract( self->enemy->currentOrigin, push_list[x]->currentOrigin, pushDir );
+						}
+						else
+						{
+							VectorSubtract( push_list[x]->currentOrigin, self->currentOrigin, pushDir );
+						}
+						knockback -= VectorNormalize( pushDir );
+						if ( knockback < 100 )
+						{
+							knockback = 100;
+						}
+					}
+					//FIXME: if pull a FL_FORCE_PULLABLE_ONLY, clear the flag, assuming it's no longer in solid?  or check?
+					VectorCopy( push_list[x]->currentOrigin, push_list[x]->s.pos.trBase );
+					push_list[x]->s.pos.trTime = level.time;								// move a bit on the very first frame
+					if ( push_list[x]->s.pos.trType != TR_INTERPOLATE )
+					{//don't do this to rolling missiles
+						push_list[x]->s.pos.trType = TR_GRAVITY;
+					}
+
+					if ( push_list[x]->e_ThinkFunc == thinkF_G_RunObject && push_list[x]->physicsBounce )
+					{//it's a pushable misc_model_breakable, use it's mass instead of our one-size-fits-all mass
+						mass = push_list[x]->physicsBounce;//same as push_list[x]->mass, right?
+					}
+					if ( mass < 50 )
+					{//???
+						mass = 50;
+					}
+					if ( g_gravity->value > 0 )
+					{
+						VectorScale( pushDir, g_knockback->value * knockback / mass * 0.8, kvel );
+						kvel[2] = pushDir[2] * g_knockback->value * knockback / mass * 1.5;
+					}
+					else
+					{
+						VectorScale( pushDir, g_knockback->value * knockback / mass, kvel );
+					}
+					VectorAdd( push_list[x]->s.pos.trDelta, kvel, push_list[x]->s.pos.trDelta );
+					if ( g_gravity->value > 0 )
+					{
+						if ( push_list[x]->s.pos.trDelta[2] < knockback )
+						{
+							push_list[x]->s.pos.trDelta[2] = knockback;
+						}
+					}
+					//no trDuration?
+					if ( push_list[x]->e_ThinkFunc != thinkF_G_RunObject )
+					{//objects spin themselves?
+						//spin it
+						//FIXME: messing with roll ruins the rotational center???
+						push_list[x]->s.apos.trTime = level.time;
+						push_list[x]->s.apos.trType = TR_LINEAR;
+						VectorClear( push_list[x]->s.apos.trDelta );
+						push_list[x]->s.apos.trDelta[1] = Q_irand( -800, 800 );
+					}
+
+					if ( Q_stricmp( "limb", push_list[x]->classname ) == 0 )
+					{//make sure it runs it's physics
+						push_list[x]->e_ThinkFunc = thinkF_LimbThink;
+						push_list[x]->nextthink = level.time + FRAMETIME;
+					}
+					push_list[x]->forcePushTime = level.time + 600; // let the push effect last for 600 ms
+					push_list[x]->forcePuller = self->s.number;//remember this regardless
+					if ( push_list[x]->item && push_list[x]->item->giTag == INV_SECURITY_KEY )
+					{
+						AddSightEvent( player, push_list[x]->currentOrigin, 128, AEL_DISCOVERED );//security keys are more important
+					}
+					else
+					{
+						AddSightEvent( player, push_list[x]->currentOrigin, 128, AEL_SUSPICIOUS );//hmm... or should this always be discovered?
+					}
+				}
+				else if ( push_list[x]->s.weapon == WP_TURRET 
+					&& !Q_stricmp( "PAS", push_list[x]->classname ) 
+					&& push_list[x]->s.apos.trType == TR_STATIONARY )
+				{//a portable turret
+					WP_KnockdownTurret( self, push_list[x] );
+				}
+			}
+		}
+		if ( pull )
+		{
+			if ( self->client->ps.forcePowerLevel[FP_PULL] > FORCE_LEVEL_2 )
+			{//at level 3, can pull multiple, so it costs more
+				actualCost = forcePowerNeeded[FP_PULL]*ent_count;
+				if ( actualCost > 50 )
+				{
+					actualCost = 50;
+				}
+				else if ( actualCost < cost )
+				{
+					actualCost = cost;
+				}
+			}
+			else
+			{
+				actualCost = cost;
+			}
+			WP_ForcePowerStart( self, FP_PULL, actualCost );
+		}
+		else
+		{
+			if ( self->client->ps.forcePowerLevel[FP_PUSH] > FORCE_LEVEL_2 )
+			{//at level 3, can push multiple, so costs more
+				actualCost = forcePowerNeeded[FP_PUSH]*ent_count;
+				if ( actualCost > 50 )
+				{
+					actualCost = 50;
+				}
+				else if ( actualCost < cost )
+				{
+					actualCost = cost;
+				}
+			}
+			else if ( self->client->ps.forcePowerLevel[FP_PUSH] > FORCE_LEVEL_1 )
+			{//at level 2, can push multiple, so costs more
+				actualCost = floor(forcePowerNeeded[FP_PUSH]*ent_count/1.5f);
+				if ( actualCost > 50 )
+				{
+					actualCost = 50;
+				}
+				else if ( actualCost < cost )
+				{
+					actualCost = cost;
+				}
+			}
+			else
+			{
+				actualCost = cost;
+			}
+			WP_ForcePowerStart( self, FP_PUSH, actualCost );
+		}
+	}
+	else
+	{//didn't push or pull anything?  don't penalize them too much
+		if ( pull )
+		{
+			WP_ForcePowerStart( self, FP_PULL, 5 );
+		}
+		else
+		{
+			WP_ForcePowerStart( self, FP_PUSH, 5 );
+		}
+	}
+	if ( pull )
+	{
+		if ( self->NPC )
+		{//NPCs can push more often
+			//FIXME: vary by rank and game skill?
+			self->client->ps.forcePowerDebounce[FP_PULL] = level.time + 200;
+		}
+		else
+		{
+			self->client->ps.forcePowerDebounce[FP_PULL] = level.time + self->client->ps.torsoAnimTimer + 500;
+		}
+	}
+	else
+	{
+		if ( self->NPC )
+		{//NPCs can push more often
+			//FIXME: vary by rank and game skill?
+			self->client->ps.forcePowerDebounce[FP_PUSH] = level.time + 200;
+		}
+		else
+		{
+			self->client->ps.forcePowerDebounce[FP_PUSH] = level.time + self->client->ps.torsoAnimTimer + 500;
+		}
+	}
+}
+
+void WP_DebounceForceDeactivateTime( gentity_t *self )
+{
+	//FIXME: if these are interruptable, should they also drain power at a constant rate
+	//		rather than just taking one lump sum of force power upfront?
+	if ( self && self->client )
+	{
+		if ( self->client->ps.forcePowersActive&(1<<FP_SPEED) 
+			|| self->client->ps.forcePowersActive&(1<<FP_PROTECT)
+			|| self->client->ps.forcePowersActive&(1<<FP_ABSORB)
+			|| self->client->ps.forcePowersActive&(1<<FP_RAGE)
+			|| self->client->ps.forcePowersActive&(1<<FP_SEE) )
+		{//already running another power that can be manually, stopped don't debounce so long
+			self->client->ps.forceAllowDeactivateTime = level.time + 500;
+		}
+		else
+		{//not running one of the interruptable powers
+			//FIXME: this should be shorter for force speed and rage (because of timescaling)
+			self->client->ps.forceAllowDeactivateTime = level.time + 1500;
+		}
+	}
+}
+
+void ForceSpeed( gentity_t *self, int duration )
+{
+	if ( self->health <= 0 )
+	{
+		return;
+	}
+	if (self->client->ps.forceAllowDeactivateTime < level.time &&
+		(self->client->ps.forcePowersActive & (1 << FP_SPEED)) )
+	{//stop using it
+		WP_ForcePowerStop( self, FP_SPEED );
+		return;
+	}
+	if ( !WP_ForcePowerUsable( self, FP_SPEED, 0 ) )
+	{
+		return;
+	}
+	if ( self->client->ps.saberLockTime > level.time )
+	{//FIXME: can this be a way to break out?
+		return;
+	}
+	
+	WP_DebounceForceDeactivateTime( self );
+
+	WP_ForcePowerStart( self, FP_SPEED, 0 );
+	if ( duration )
+	{
+		self->client->ps.forcePowerDuration[FP_SPEED] = level.time + duration;
+	}
+	G_Sound( self, G_SoundIndex( "sound/weapons/force/speed.wav" ) );
+#ifdef _IMMERSION
+	G_Force( self, G_ForceIndex( "fffx/weapons/force/speed", FF_CHANNEL_WEAPON ) );
+#endif // _IMMERSION
+}
+
+void WP_StartForceHealEffects( gentity_t *self )
+{
+	if ( self->ghoul2.size() )
+	{
+		if ( self->chestBolt != -1 )
+		{
+			G_PlayEffect( G_EffectIndex( "force/heal2" ), self->playerModel, self->chestBolt, self->s.number, self->currentOrigin, 3000, qtrue );
+		}
+		/*
+		if ( self->headBolt != -1 )
+		{
+			G_PlayEffect( G_EffectIndex( "force/heal_joint" ), self->playerModel, self->headBolt, self->s.number, self->currentOrigin, 3000, qtrue );
+		}
+		if ( self->cervicalBolt != -1 )
+		{
+			G_PlayEffect( G_EffectIndex( "force/heal_joint" ), self->playerModel, self->cervicalBolt, self->s.number, self->currentOrigin, 3000, qtrue );
+		}
+		if ( self->chestBolt != -1 )
+		{
+			G_PlayEffect( G_EffectIndex( "force/heal_joint" ), self->playerModel, self->chestBolt, self->s.number, self->currentOrigin, 3000, qtrue );
+		}
+		if ( self->gutBolt != -1 )
+		{
+			G_PlayEffect( G_EffectIndex( "force/heal_joint" ), self->playerModel, self->gutBolt, self->s.number, self->currentOrigin, 3000, qtrue );
+		}
+		if ( self->kneeLBolt != -1 )
+		{
+			G_PlayEffect( G_EffectIndex( "force/heal_joint" ), self->playerModel, self->kneeLBolt, self->s.number, self->currentOrigin, 3000, qtrue );
+		}
+		if ( self->kneeRBolt != -1 )
+		{
+			G_PlayEffect( G_EffectIndex( "force/heal_joint" ), self->playerModel, self->kneeRBolt, self->s.number, self->currentOrigin, 3000, qtrue );
+		}
+		if ( self->elbowLBolt != -1 )
+		{
+			G_PlayEffect( G_EffectIndex( "force/heal_joint" ), self->playerModel, self->elbowLBolt, self->s.number, self->currentOrigin, 3000, qtrue );
+		}
+		if ( self->elbowRBolt != -1 )
+		{
+			G_PlayEffect( G_EffectIndex( "force/heal_joint" ), self->playerModel, self->elbowRBolt, self->s.number, self->currentOrigin, 3000, qtrue );
+		}
+		*/
+	}
+}
+
+void WP_StopForceHealEffects( gentity_t *self )
+{
+	if ( self->ghoul2.size() )
+	{
+		if ( self->chestBolt != -1 )
+		{
+			G_StopEffect( G_EffectIndex( "force/heal2" ), self->playerModel, self->chestBolt, self->s.number );
+		}
+		/*
+		if ( self->headBolt != -1 )
+		{
+			G_StopEffect( G_EffectIndex( "force/heal_joint" ), self->playerModel, self->headBolt, self->s.number );
+		}
+		if ( self->cervicalBolt != -1 )
+		{
+			G_StopEffect( G_EffectIndex( "force/heal_joint" ), self->playerModel, self->cervicalBolt, self->s.number );
+		}
+		if ( self->chestBolt != -1 )
+		{
+			G_StopEffect( G_EffectIndex( "force/heal_joint" ), self->playerModel, self->chestBolt, self->s.number );
+		}
+		if ( self->gutBolt != -1 )
+		{
+			G_StopEffect( G_EffectIndex( "force/heal_joint" ), self->playerModel, self->gutBolt, self->s.number );
+		}
+		if ( self->kneeLBolt != -1 )
+		{
+			G_StopEffect( G_EffectIndex( "force/heal_joint" ), self->playerModel, self->kneeLBolt, self->s.number );
+		}
+		if ( self->kneeRBolt != -1 )
+		{
+			G_StopEffect( G_EffectIndex( "force/heal_joint" ), self->playerModel, self->kneeRBolt, self->s.number );
+		}
+		if ( self->elbowLBolt != -1 )
+		{
+			G_StopEffect( G_EffectIndex( "force/heal_joint" ), self->playerModel, self->elbowLBolt, self->s.number );
+		}
+		if ( self->elbowRBolt != -1 )
+		{
+			G_StopEffect( G_EffectIndex( "force/heal_joint" ), self->playerModel, self->elbowRBolt, self->s.number );
+		}
+		*/
+	}
+}
+
+int FP_MaxForceHeal( gentity_t *self )
+{
+	if ( self->s.number >= MAX_CLIENTS )
+	{
+		return MAX_FORCE_HEAL_HARD;
+	}
+	switch ( g_spskill->integer )
+	{
+	case 0://easy
+		return MAX_FORCE_HEAL_EASY;
+		break;
+	case 1://medium
+		return MAX_FORCE_HEAL_MEDIUM;
+		break;
+	case 2://hard
+	default:
+		return MAX_FORCE_HEAL_HARD;
+		break;
+	}
+}
+
+int FP_ForceHealInterval( gentity_t *self )
+{
+	return (self->client->ps.forcePowerLevel[FP_HEAL]>FORCE_LEVEL_2)?50:FORCE_HEAL_INTERVAL;
+}
+
+void ForceHeal( gentity_t *self )
+{
+	if ( self->health <= 0 || self->client->ps.stats[STAT_MAX_HEALTH] <= self->health )
+	{
+		return;
+	}
+
+	if ( !WP_ForcePowerUsable( self, FP_HEAL, 20 ) )
+	{//must have enough force power for at least 5 points of health
+		return;
+	}
+
+	if ( self->painDebounceTime > level.time || (self->client->ps.weaponTime&&self->client->ps.weapon!=WP_NONE) )
+	{//can't initiate a heal while taking pain or attacking
+		return;
+	}
+
+	if ( self->client->ps.saberLockTime > level.time )
+	{//FIXME: can this be a way to break out?
+		return;
+	}
+	/*
+	if ( self->client->ps.forcePowerLevel[FP_HEAL] > FORCE_LEVEL_2 )
+	{//instant heal
+		//no more than available force power
+		int max = self->client->ps.forcePower;
+		if ( max > MAX_FORCE_HEAL )
+		{//no more than max allowed
+			max = MAX_FORCE_HEAL;
+		}
+		if ( max > self->client->ps.stats[STAT_MAX_HEALTH] - self->health )
+		{//no more than what's missing
+			max = self->client->ps.stats[STAT_MAX_HEALTH] - self->health;
+		}
+		self->health += max;
+		WP_ForcePowerDrain( self, FP_HEAL, max );
+		G_SoundOnEnt( self, CHAN_VOICE, va( "sound/weapons/force/heal%d.mp3", Q_irand( 1, 4 ) ) );
+	}
+	else
+	*/
+	{
+		//start health going up
+		//NPC_SetAnim( self, SETANIM_TORSO, ?, SETANIM_FLAG_OVERRIDE );
+		WP_ForcePowerStart( self, FP_HEAL, 0 );
+		if ( self->client->ps.forcePowerLevel[FP_HEAL] < FORCE_LEVEL_2 )
+		{//must meditate
+			//FIXME: holster weapon (select WP_NONE?)
+			//FIXME: BOTH_FORCEHEAL_START
+			NPC_SetAnim( self, SETANIM_BOTH, BOTH_FORCEHEAL_START, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+			self->client->ps.saberMove = self->client->ps.saberBounceMove = LS_READY;//don't finish whatever saber anim you may have been in
+			self->client->ps.saberBlocked = BLOCKED_NONE;
+			self->client->ps.torsoAnimTimer = self->client->ps.legsAnimTimer = FP_ForceHealInterval(self)*FP_MaxForceHeal(self) + 2000;//???
+			WP_DeactivateSaber( self );//turn off saber when meditating
+		}
+		else
+		{//just a quick gesture
+			/*
+			//Can't get an anim that looks good...
+			NPC_SetAnim( self, SETANIM_TORSO, BOTH_FORCEHEAL_QUICK, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+			self->client->ps.saberMove = self->client->ps.saberBounceMove = LS_READY;//don't finish whatever saber anim you may have been in
+			self->client->ps.saberBlocked = BLOCKED_NONE;
+			*/
+		}
+	}
+	
+	//FIXME: always play healing effect
+	G_SoundOnEnt( self, CHAN_ITEM, "sound/weapons/force/heal.mp3" );
+#ifdef _IMMERSION
+	G_Force( self, G_ForceIndex( "fffx/weapons/force/heal", FF_CHANNEL_WEAPON ) );
+#endif // _IMMERSION
+}
+
+extern void NPC_PlayConfusionSound( gentity_t *self );
+extern void NPC_Jedi_PlayConfusionSound( gentity_t *self );
+qboolean WP_CheckBreakControl( gentity_t *self )
+{
+	if ( !self )
+	{
+		return qfalse;
+	}
+	if ( !self->s.number )
+	{//player
+		if ( self->client && self->client->ps.forcePowerLevel[FP_TELEPATHY] > FORCE_LEVEL_3 )
+		{//control-level
+			if ( self->client->ps.viewEntity > 0 && self->client->ps.viewEntity < ENTITYNUM_WORLD )
+			{//we are in a viewentity
+				gentity_t *controlled = &g_entities[self->client->ps.viewEntity];
+				if ( controlled->NPC && controlled->NPC->controlledTime > level.time )
+				{//it is an NPC we controlled
+					//clear it and return
+					G_ClearViewEntity( self );
+					return qtrue;
+				}
+			}
+		}
+	}
+	else
+	{//NPC
+		if ( self->NPC && self->NPC->controlledTime > level.time )
+		{//being controlled
+			gentity_t *controller = &g_entities[0];
+			if ( controller->client && controller->client->ps.viewEntity == self->s.number )
+			{//we are being controlled by player
+				if ( controller->client->ps.forcePowerLevel[FP_TELEPATHY] > FORCE_LEVEL_3 )
+				{//control-level mind trick
+					//clear the control and return
+					G_ClearViewEntity( controller );
+					return qtrue;
+				}
+			}
+		}
+	}
+	return qfalse;
+}
+extern bool	Pilot_AnyVehiclesRegistered();
+
+void ForceTelepathy( gentity_t *self )
+{
+	trace_t	tr;
+	vec3_t	end, forward;
+	gentity_t	*traceEnt;
+	qboolean	targetLive = qfalse;
+
+	if ( WP_CheckBreakControl( self ) )
+	{
+		return;
+	}
+	if ( self->health <= 0 )
+	{
+		return;
+	}
+	//FIXME: if mind trick 3 and aiming at an enemy need more force power
+	if ( !WP_ForcePowerUsable( self, FP_TELEPATHY, 0 ) )
+	{
+		return;
+	}
+
+	if ( self->client->ps.weaponTime >= 800 )
+	{//just did one!
+		return;
+	}
+	if ( self->client->ps.saberLockTime > level.time )
+	{//FIXME: can this be a way to break out?
+		return;
+	}
+
+	AngleVectors( self->client->ps.viewangles, forward, NULL, NULL );
+	VectorNormalize( forward );
+	VectorMA( self->client->renderInfo.eyePoint, 2048, forward, end );
+	
+	//Cause a distraction if enemy is not fighting
+	gi.trace( &tr, self->client->renderInfo.eyePoint, vec3_origin, vec3_origin, end, self->s.number, MASK_OPAQUE|CONTENTS_BODY );
+	if ( tr.entityNum == ENTITYNUM_NONE || tr.fraction == 1.0 || tr.allsolid || tr.startsolid )
+	{
+		return;
+	}
+	
+	traceEnt = &g_entities[tr.entityNum];
+	
+	if( traceEnt->NPC && traceEnt->NPC->scriptFlags & SCF_NO_FORCE )
+	{
+		return;
+	}
+
+	if ( traceEnt && traceEnt->client  )
+	{
+		switch ( traceEnt->client->NPC_class )
+		{
+		case CLASS_GALAKMECH://cant grip him, he's in armor
+		case CLASS_ATST://much too big to grip!
+		//no droids either
+		case CLASS_PROBE:
+		case CLASS_GONK:
+		case CLASS_R2D2:
+		case CLASS_R5D2:
+		case CLASS_MARK1:
+		case CLASS_MARK2:
+		case CLASS_MOUSE:
+		case CLASS_SEEKER:
+		case CLASS_REMOTE:
+		case CLASS_PROTOCOL:
+		case CLASS_ASSASSIN_DROID:
+		case CLASS_SABER_DROID:
+		case CLASS_BOBAFETT:
+			break;
+		case CLASS_RANCOR:
+			if ( !(traceEnt->spawnflags&1) )
+			{
+				targetLive = qtrue;
+			}
+			break;
+		default:
+			targetLive = qtrue;
+			break;
+		}
+	}
+	if ( targetLive 
+		&& traceEnt->NPC 
+		&& traceEnt->health > 0 )
+	{//hit an organic non-player
+		if ( G_ActivateBehavior( traceEnt, BSET_MINDTRICK ) )
+		{//activated a script on him
+			//FIXME: do the visual sparkles effect on their heads, still?
+			WP_ForcePowerStart( self, FP_TELEPATHY, 0 );
+		}
+		else if ( traceEnt->client->playerTeam != self->client->playerTeam )
+		{//an enemy
+			int override = 0;
+			if ( (traceEnt->NPC->scriptFlags&SCF_NO_MIND_TRICK) )
+			{
+				if ( traceEnt->client->NPC_class == CLASS_GALAKMECH )
+				{
+					G_AddVoiceEvent( traceEnt, Q_irand( EV_CONFUSE1, EV_CONFUSE3 ), Q_irand( 3000, 5000 ) );
+				}
+			}
+			else if ( self->client->ps.forcePowerLevel[FP_TELEPATHY] > FORCE_LEVEL_3 )
+			{//control them, even jedi
+				G_SetViewEntity( self, traceEnt );
+				traceEnt->NPC->controlledTime = level.time + 30000;
+			}
+			else if ( traceEnt->s.weapon != WP_SABER 
+				&& traceEnt->client->NPC_class != CLASS_REBORN )
+			{//haha!  Jedi aren't easily confused!
+				if ( self->client->ps.forcePowerLevel[FP_TELEPATHY] > FORCE_LEVEL_2 
+					&& traceEnt->s.weapon != WP_NONE		//don't charm people who aren't capable of fighting... like ugnaughts and droids, just confuse them
+					&& traceEnt->client->NPC_class != CLASS_TUSKEN//don't charm them, just confuse them
+					&& traceEnt->client->NPC_class != CLASS_NOGHRI//don't charm them, just confuse them
+					&& !Pilot_AnyVehiclesRegistered()		//also, don't charm guys when bikes are near
+					)
+				{//turn them to our side
+					//if mind trick 3 and aiming at an enemy need more force power
+					override = 50;
+					if ( self->client->ps.forcePower < 50 )
+					{
+						return;
+					}
+					if ( traceEnt->enemy )
+					{
+						G_ClearEnemy( traceEnt );
+					}
+					if ( traceEnt->NPC )
+					{
+						//traceEnt->NPC->tempBehavior = BS_FOLLOW_LEADER;
+						traceEnt->client->leader = self;
+					}
+					//FIXME: maybe pick an enemy right here?
+					//FIXME: does nothing to TEAM_FREE and TEAM_NEUTRALs!!!
+					team_t	saveTeam = traceEnt->client->enemyTeam;
+					traceEnt->client->enemyTeam = traceEnt->client->playerTeam;
+					traceEnt->client->playerTeam = saveTeam;
+					//FIXME: need a *charmed* timer on this...?  Or do TEAM_PLAYERS assume that "confusion" means they should switch to team_enemy when done?
+					traceEnt->NPC->charmedTime = level.time + mindTrickTime[self->client->ps.forcePowerLevel[FP_TELEPATHY]];
+					if ( traceEnt->ghoul2.size() && traceEnt->headBolt != -1 )
+					{//FIXME: what if already playing effect?
+						G_PlayEffect( G_EffectIndex( "force/confusion" ), traceEnt->playerModel, traceEnt->headBolt, traceEnt->s.number, traceEnt->currentOrigin, mindTrickTime[self->client->ps.forcePowerLevel[FP_TELEPATHY]], qtrue );
+					}
+				}
+				else
+				{//just confuse them
+					//somehow confuse them?  Set don't fire to true for a while?  Drop their aggression?  Maybe just take their enemy away and don't let them pick one up for a while unless shot?
+					traceEnt->NPC->confusionTime = level.time + mindTrickTime[self->client->ps.forcePowerLevel[FP_TELEPATHY]];//confused for about 10 seconds
+					if ( traceEnt->ghoul2.size() && traceEnt->headBolt != -1 )
+					{//FIXME: what if already playing effect?
+						G_PlayEffect( G_EffectIndex( "force/confusion" ), traceEnt->playerModel, traceEnt->headBolt, traceEnt->s.number, traceEnt->currentOrigin, mindTrickTime[self->client->ps.forcePowerLevel[FP_TELEPATHY]], qtrue );
+					}
+					NPC_PlayConfusionSound( traceEnt );
+					if ( traceEnt->enemy )
+					{
+						G_ClearEnemy( traceEnt );
+					}
+				}
+			}
+			else
+			{
+				NPC_Jedi_PlayConfusionSound( traceEnt );
+			}
+			WP_ForcePowerStart( self, FP_TELEPATHY, override );
+		}
+		else if ( traceEnt->client->playerTeam == self->client->playerTeam )
+		{//an ally
+			//maybe just have him look at you?  Respond?  Take your enemy?
+			if ( traceEnt->client->ps.pm_type < PM_DEAD && traceEnt->NPC!=NULL && !(traceEnt->NPC->scriptFlags&SCF_NO_RESPONSE) )
+			{
+				NPC_UseResponse( traceEnt, self, qfalse );
+				WP_ForcePowerStart( self, FP_TELEPATHY, 1 );
+			}
+		}//NOTE: no effect on TEAM_NEUTRAL?
+		vec3_t	eyeDir;
+		AngleVectors( traceEnt->client->renderInfo.eyeAngles, eyeDir, NULL, NULL );
+		VectorNormalize( eyeDir );
+		G_PlayEffect( "force/force_touch", traceEnt->client->renderInfo.eyePoint, eyeDir );
+
+		//make sure this plays and that you cannot press fire for about 1 second after this
+		//FIXME: BOTH_FORCEMINDTRICK or BOTH_FORCEDISTRACT
+		NPC_SetAnim( self, SETANIM_TORSO, BOTH_MINDTRICK1, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_RESTART|SETANIM_FLAG_HOLD );
+		//FIXME: build-up or delay this until in proper part of anim
+	}
+	else 
+	{
+		if ( self->client->ps.forcePowerLevel[FP_TELEPATHY] > FORCE_LEVEL_1 && tr.fraction * 2048 > 64 )
+		{//don't create a diversion less than 64 from you of if at power level 1
+			//use distraction anim instead
+			G_PlayEffect( G_EffectIndex( "force/force_touch" ), tr.endpos, tr.plane.normal );
+			//FIXME: these events don't seem to always be picked up...?
+			AddSoundEvent( self, tr.endpos, 512, AEL_SUSPICIOUS, qtrue, qtrue );
+			AddSightEvent( self, tr.endpos, 512, AEL_SUSPICIOUS, 50 );
+			WP_ForcePowerStart( self, FP_TELEPATHY, 0 );
+		}
+		NPC_SetAnim( self, SETANIM_TORSO, BOTH_MINDTRICK2, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_RESTART|SETANIM_FLAG_HOLD );
+	}
+	self->client->ps.saberMove = self->client->ps.saberBounceMove = LS_READY;//don't finish whatever saber anim you may have been in
+	self->client->ps.saberBlocked = BLOCKED_NONE;
+	self->client->ps.weaponTime = 1000;
+	if ( self->client->ps.forcePowersActive&(1<<FP_SPEED) )
+	{
+		self->client->ps.weaponTime = floor( self->client->ps.weaponTime * g_timescale->value );
+	}
+}
+
+//rww - RAGDOLL_BEGIN
+//#define JK2_RAGDOLL_GRIPNOHEALTH
+//rww - RAGDOLL_END
+
+void ForceGrip( gentity_t *self )
+{//FIXME: make enemy Jedi able to use this
+	trace_t	tr;
+	vec3_t	end, forward;
+	gentity_t	*traceEnt = NULL;
+
+	if ( self->health <= 0 )
+	{
+		return;
+	}
+	if ( !self->s.number && (cg.zoomMode || in_camera) )
+	{//can't force grip when zoomed in or in cinematic
+		return;
+	}
+	if ( self->client->ps.leanofs )
+	{//can't force-grip while leaning
+		return;
+	}
+
+	if ( self->client->ps.forceGripEntityNum <= ENTITYNUM_WORLD )
+	{//already gripping
+		if ( self->client->ps.forcePowerLevel[FP_GRIP] > FORCE_LEVEL_1 )
+		{
+			self->client->ps.forcePowerDuration[FP_GRIP] = level.time + 100;
+			self->client->ps.weaponTime = 1000;
+			if ( self->client->ps.forcePowersActive&(1<<FP_SPEED) )
+			{
+				self->client->ps.weaponTime = floor( self->client->ps.weaponTime * g_timescale->value );
+			}
+		}
+		return;
+	}
+
+	if ( !WP_ForcePowerUsable( self, FP_GRIP, 0 ) )
+	{//can't use it right now
+		return;
+	}
+
+	if ( self->client->ps.forcePower < 26 )
+	{//need 20 to start, 6 to hold it for any decent amount of time...
+		return;
+	}
+
+	if ( self->client->ps.weaponTime )
+	{//busy
+		return;
+	}
+
+	if ( self->client->ps.saberLockTime > level.time )
+	{//FIXME: can this be a way to break out?
+		return;
+	}
+	//Cause choking anim + health drain in ent in front of me
+	NPC_SetAnim( self, SETANIM_TORSO, BOTH_FORCEGRIP_HOLD, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+	self->client->ps.saberMove = self->client->ps.saberBounceMove = LS_READY;//don't finish whatever saber anim you may have been in
+	self->client->ps.saberBlocked = BLOCKED_NONE;
+
+	self->client->ps.weaponTime = 1000;
+	if ( self->client->ps.forcePowersActive&(1<<FP_SPEED) )
+	{
+		self->client->ps.weaponTime = floor( self->client->ps.weaponTime * g_timescale->value );
+	}
+
+	AngleVectors( self->client->ps.viewangles, forward, NULL, NULL );
+	VectorNormalize( forward );
+	VectorMA( self->client->renderInfo.handLPoint, FORCE_GRIP_DIST, forward, end );
+	
+	if ( self->enemy )
+	{//I have an enemy
+		if ( !self->enemy->message
+			&& !(self->flags&FL_NO_KNOCKBACK) )
+		{//don't auto-pickup guys with keys
+			if ( DistanceSquared( self->enemy->currentOrigin, self->currentOrigin ) < FORCE_GRIP_DIST_SQUARED )
+			{//close enough to grab
+				float minDot = 0.5f;
+				if ( self->s.number < MAX_CLIENTS )
+				{//player needs to be facing more directly
+					minDot = 0.2f;
+				}
+				if ( InFront( self->enemy->currentOrigin, self->client->renderInfo.eyePoint, self->client->ps.viewangles, minDot ) ) //self->s.number || //NPCs can always lift enemy since we assume they're looking at them...?
+				{//need to be facing the enemy
+					if ( gi.inPVS( self->enemy->currentOrigin, self->client->renderInfo.eyePoint ) )
+					{//must be in PVS
+						gi.trace( &tr, self->client->renderInfo.eyePoint, vec3_origin, vec3_origin, self->enemy->currentOrigin, self->s.number, MASK_SHOT );
+						if ( tr.fraction == 1.0f || tr.entityNum == self->enemy->s.number )
+						{//must have clear LOS
+							traceEnt = self->enemy;
+						}
+					}
+				}
+			}
+		}
+	}
+	if ( !traceEnt )
+	{//okay, trace straight ahead and see what's there
+		gi.trace( &tr, self->client->renderInfo.handLPoint, vec3_origin, vec3_origin, end, self->s.number, MASK_SHOT );
+		if ( tr.entityNum >= ENTITYNUM_WORLD || tr.fraction == 1.0 || tr.allsolid || tr.startsolid )
+		{
+			return;
+		}
+
+		traceEnt = &g_entities[tr.entityNum];
+	}
+//rww - RAGDOLL_BEGIN
+#ifdef JK2_RAGDOLL_GRIPNOHEALTH
+	if ( !traceEnt || traceEnt == self/*???*/ || traceEnt->bmodel || (traceEnt->NPC && traceEnt->NPC->scriptFlags & SCF_NO_FORCE) )
+	{
+		return;
+	}
+#else
+//rww - RAGDOLL_END
+	if ( !traceEnt || traceEnt == self/*???*/ || traceEnt->bmodel || (traceEnt->health <= 0 && traceEnt->takedamage) || (traceEnt->NPC && traceEnt->NPC->scriptFlags & SCF_NO_FORCE) )
+	{
+		return;
+	}
+//rww - RAGDOLL_BEGIN
+#endif
+//rww - RAGDOLL_END
+
+	if ( traceEnt->m_pVehicle != NULL )
+	{//is it a vehicle
+		//grab pilot if there is one
+		if ( traceEnt->m_pVehicle->m_pPilot != NULL 
+			&& traceEnt->m_pVehicle->m_pPilot->client != NULL )
+		{//grip the pilot
+			traceEnt = traceEnt->m_pVehicle->m_pPilot;
+		}
+		else
+		{//can't grip a vehicle
+			return;
+		}
+	}
+	if ( traceEnt->client )
+	{
+		if ( traceEnt->client->ps.forceJumpZStart )
+		{//can't catch them in mid force jump - FIXME: maybe base it on velocity?
+			return;
+		}
+		if ( traceEnt->client->ps.pullAttackTime > level.time )
+		{//can't grip someone who is being pull-attacked or is pull-attacking
+			return;
+		}
+		if ( !Q_stricmp("Yoda",traceEnt->NPC_type) )
+		{
+			Jedi_PlayDeflectSound( traceEnt );
+			ForceThrow( traceEnt, qfalse );
+			return;
+		}
+
+		if ( G_IsRidingVehicle( traceEnt ) 
+			&& (traceEnt->s.eFlags&EF_NODRAW) )
+		{//riding *inside* vehicle
+			return;
+		}
+
+		switch ( traceEnt->client->NPC_class )
+		{
+		case CLASS_GALAKMECH://cant grip him, he's in armor
+			G_AddVoiceEvent( traceEnt, Q_irand(EV_PUSHED1, EV_PUSHED3), Q_irand( 3000, 5000 ) );
+			return;
+			break;
+		case CLASS_HAZARD_TROOPER://cant grip him, he's in armor
+			return;
+			break;
+		case CLASS_ATST://much too big to grip!
+		case CLASS_RANCOR://much too big to grip!
+		case CLASS_WAMPA://much too big to grip!
+		case CLASS_SAND_CREATURE://much too big to grip!
+			return;
+			break;
+		//no droids either...?
+		case CLASS_GONK:
+		case CLASS_R2D2:
+		case CLASS_R5D2:
+		case CLASS_MARK1:
+		case CLASS_MARK2:
+		case CLASS_MOUSE://?
+		case CLASS_PROTOCOL:
+			//*sigh*... in JK3, you'll be able to grab and move *anything*...
+			return;
+			break;
+		//not even combat droids?  (No animation for being gripped...)
+		case CLASS_SABER_DROID:
+		case CLASS_ASSASSIN_DROID:
+			//*sigh*... in JK3, you'll be able to grab and move *anything*...
+			return;
+			break;
+		case CLASS_PROBE:
+		case CLASS_SEEKER:
+		case CLASS_REMOTE:
+		case CLASS_SENTRY:
+		case CLASS_INTERROGATOR:
+			//*sigh*... in JK3, you'll be able to grab and move *anything*...
+			return;
+			break;
+		case CLASS_DESANN://Desann cannot be gripped, he just pushes you back instantly
+		case CLASS_KYLE:
+		case CLASS_TAVION:
+		case CLASS_LUKE:
+			Jedi_PlayDeflectSound( traceEnt );
+			ForceThrow( traceEnt, qfalse );
+			return;
+			break;
+		case CLASS_REBORN:
+		case CLASS_SHADOWTROOPER:
+		case CLASS_ALORA:
+		case CLASS_JEDI:
+			if ( traceEnt->NPC && traceEnt->NPC->rank > RANK_CIVILIAN && self->client->ps.forcePowerLevel[FP_GRIP] < FORCE_LEVEL_2 )
+			{
+				Jedi_PlayDeflectSound( traceEnt );
+				ForceThrow( traceEnt, qfalse );
+				return;
+			}
+			break;
+		}
+		if ( traceEnt->s.weapon == WP_EMPLACED_GUN )
+		{//FIXME: maybe can pull them out?
+			return;
+		}
+		if ( self->enemy && traceEnt != self->enemy && traceEnt->client->playerTeam == self->client->playerTeam )
+		{//can't accidently grip your teammate in combat
+			return;
+		}
+//=CHECKABSORB===
+		if ( -1 != WP_AbsorbConversion( traceEnt, traceEnt->client->ps.forcePowerLevel[FP_ABSORB], self, FP_GRIP, self->client->ps.forcePowerLevel[FP_GRIP], forcePowerNeeded[self->client->ps.forcePowerLevel[FP_GRIP]]) )
+		{
+			//WP_ForcePowerStop( self, FP_GRIP );
+			return;
+		}
+//===============
+	}
+	else
+	{//can't grip non-clients... right?
+		//FIXME: Make it so objects flagged as "grabbable" are let through
+		//if ( Q_stricmp( "misc_model_breakable", traceEnt->classname ) || !(traceEnt->s.eFlags&EF_BOUNCE_HALF) || !traceEnt->physicsBounce )
+		{
+			return;
+		}
+	}
+
+	// Make sure to turn off Force Protection and Force Absorb.
+	if (self->client->ps.forcePowersActive & (1 << FP_PROTECT) )
+	{
+		WP_ForcePowerStop( self, FP_PROTECT );
+	}
+	if (self->client->ps.forcePowersActive & (1 << FP_ABSORB) )
+	{
+		WP_ForcePowerStop( self, FP_ABSORB );
+	}
+
+	WP_ForcePowerStart( self, FP_GRIP, 20 );
+	//FIXME: rule out other things?
+	//FIXME: Jedi resist, like the push and pull?
+	self->client->ps.forceGripEntityNum = traceEnt->s.number;
+	if ( traceEnt->client ) 
+	{
+		Vehicle_t *pVeh;
+		if ( ( pVeh = G_IsRidingVehicle( traceEnt ) ) != NULL )
+		{//riding vehicle? pull him off!
+			//FIXME: if in an AT-ST or X-Wing, shouldn't do this... :)
+			//pull him off of it
+			//((CVehicleNPC *)traceEnt->NPC)->Eject( traceEnt );
+			pVeh->m_pVehicleInfo->Eject( pVeh, traceEnt, qtrue );
+			//G_DriveVehicle( traceEnt, NULL, NULL );
+		}
+		G_AddVoiceEvent( traceEnt, Q_irand(EV_PUSHED1, EV_PUSHED3), 2000 );
+		if ( self->client->ps.forcePowerLevel[FP_GRIP] > FORCE_LEVEL_2 || traceEnt->s.weapon == WP_SABER )
+		{//if we pick up & carry, drop their weap
+			if ( traceEnt->s.weapon 
+				&& traceEnt->client->NPC_class != CLASS_ROCKETTROOPER
+				&& traceEnt->client->NPC_class != CLASS_VEHICLE
+				&& traceEnt->client->NPC_class != CLASS_HAZARD_TROOPER
+				&& traceEnt->client->NPC_class != CLASS_TUSKEN
+				&& traceEnt->client->NPC_class != CLASS_BOBAFETT
+				&& traceEnt->client->NPC_class != CLASS_ASSASSIN_DROID
+				&& traceEnt->s.weapon != WP_CONCUSSION	// so rax can't drop his
+				) 
+			{
+				if ( traceEnt->client->NPC_class == CLASS_BOBAFETT )
+				{//he doesn't drop them, just puts it away
+					ChangeWeapon( traceEnt, WP_MELEE );
+				}
+				else if ( traceEnt->s.weapon == WP_MELEE )
+				{//they can't take that away from me, oh no...
+				}
+				else if ( traceEnt->NPC
+					&& (traceEnt->NPC->scriptFlags&SCF_DONT_FLEE) )
+				{//*SIGH*... if an NPC can't flee, they can't run after and pick up their weapon, do don't drop it
+				}
+				else if ( traceEnt->s.weapon != WP_SABER )
+				{
+					WP_DropWeapon( traceEnt, NULL );
+				}
+				else
+				{
+					//turn it off?
+					traceEnt->client->ps.SaberDeactivate();
+					G_SoundOnEnt( traceEnt, CHAN_WEAPON, "sound/weapons/saber/saberoffquick.wav" );
+#ifdef _IMMERSION
+					G_Force( traceEnt, G_ForceIndex( "fffx/weapons/saber/saberoffquick", FF_CHANNEL_WEAPON ) );
+#endif // _IMMERSION
+				}
+			}
+		}
+		//else FIXME: need a one-armed choke if we're not on a high enough level to make them drop their gun
+		VectorCopy( traceEnt->client->renderInfo.headPoint, self->client->ps.forceGripOrg );
+	}
+	else
+	{
+		VectorCopy( traceEnt->currentOrigin, self->client->ps.forceGripOrg );
+	}
+	self->client->ps.forceGripOrg[2] += 48;//FIXME: define?
+	if ( self->client->ps.forcePowerLevel[FP_GRIP] < FORCE_LEVEL_2 )
+	{//just a duration
+		self->client->ps.forcePowerDebounce[FP_GRIP] = level.time + 250;
+		self->client->ps.forcePowerDuration[FP_GRIP] = level.time + 5000;
+		
+		if ( self->m_pVehicle && self->m_pVehicle->m_pVehicleInfo->Inhabited( self->m_pVehicle ) )
+		{//empty vehicles don't make gripped noise
+			traceEnt->s.loopSound = G_SoundIndex( "sound/weapons/force/grip.mp3" );
+		}
+#ifdef _IMMERSION
+		G_Force( self, G_ForceIndex( "fffx/weapons/force/gripcast", FF_CHANNEL_FORCE ) );
+		//G_Force( traceEnt, G_ForceIndex( "fffx/weapons/force/grip", FF_CHANNEL_DAMAGE ) );
+#endif // _IMMERSION
+	}
+	else
+	{
+		if ( self->client->ps.forcePowerLevel[FP_GRIP] == FORCE_LEVEL_2 )
+		{//lifting sound?  or always?
+		}
+		//if ( traceEnt->s.number )
+		{//picks them up for a second first
+			self->client->ps.forcePowerDebounce[FP_GRIP] = level.time + 1000;
+		}
+		/*
+		else
+		{//player should take damage right away
+			self->client->ps.forcePowerDebounce[FP_GRIP] = level.time + 250;
+		}
+		*/
+	// force grip sound should only play when the target is alive?
+	//	if (traceEnt->health>0)
+	//	{
+			self->s.loopSound = G_SoundIndex( "sound/weapons/force/grip.mp3" );
+	//	}
+	}
+}
+
+qboolean ForceLightningCheck2Handed( gentity_t *self )
+{
+	if ( self && self->client )
+	{
+		if ( self->s.weapon == WP_NONE
+			||  self->s.weapon == WP_MELEE
+			|| (self->s.weapon == WP_SABER && !self->client->ps.SaberActive()) )
+		{
+			return qtrue;
+		}
+	}
+	return qfalse;
+}
+
+void ForceLightningAnim( gentity_t *self )
+{
+	if ( !self || !self->client )
+	{
+		return;
+	}
+
+	//one-handed lightning 2 and above
+	int startAnim = BOTH_FORCELIGHTNING_START;
+	int holdAnim = BOTH_FORCELIGHTNING_HOLD;
+
+	if ( self->client->ps.forcePowerLevel[FP_LIGHTNING] >= FORCE_LEVEL_3
+		&& ForceLightningCheck2Handed( self ) )
+	{//empty handed lightning 3
+		startAnim = BOTH_FORCE_2HANDEDLIGHTNING_START;
+		holdAnim = BOTH_FORCE_2HANDEDLIGHTNING_HOLD;
+	}
+
+	//FIXME: if standing still, play on whole body?  Especially 2-handed version
+	if ( self->client->ps.torsoAnim == startAnim )
+	{
+		if ( !self->client->ps.torsoAnimTimer )
+		{
+			NPC_SetAnim( self, SETANIM_TORSO, holdAnim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+		}
+		else
+		{
+			NPC_SetAnim( self, SETANIM_TORSO, startAnim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+		}
+	}
+	else
+	{
+		NPC_SetAnim( self, SETANIM_TORSO, holdAnim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+	}
+}
+
+void ForceLightning( gentity_t *self )
+{
+	if ( self->health <= 0 )
+	{
+		return;
+	}
+	if ( !self->s.number && (cg.zoomMode || in_camera) )
+	{//can't force lightning when zoomed in or in cinematic
+		return;
+	}
+	if ( self->client->ps.leanofs )
+	{//can't force-lightning while leaning
+		return;
+	}
+	if ( self->client->ps.forcePower < 25 || !WP_ForcePowerUsable( self, FP_LIGHTNING, 0 ) )
+	{
+		return;
+	}
+	if ( self->client->ps.forcePowerDebounce[FP_LIGHTNING] > level.time )
+	{//stops it while using it and also after using it, up to 3 second delay
+		return;
+	}
+	if ( self->client->ps.saberLockTime > level.time )
+	{//FIXME: can this be a way to break out?
+		return;
+	}
+	// Make sure to turn off Force Protection and Force Absorb.
+	if (self->client->ps.forcePowersActive & (1 << FP_PROTECT) )
+	{
+		WP_ForcePowerStop( self, FP_PROTECT );
+	}
+	if (self->client->ps.forcePowersActive & (1 << FP_ABSORB) )
+	{
+		WP_ForcePowerStop( self, FP_ABSORB );
+	}
+	//Shoot lightning from hand
+	//make sure this plays and that you cannot press fire for about 1 second after this
+	if ( self->client->ps.forcePowerLevel[FP_LIGHTNING] < FORCE_LEVEL_2 )
+	{
+		NPC_SetAnim( self, SETANIM_TORSO, BOTH_FORCELIGHTNING, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+	}
+	else
+	{
+		ForceLightningAnim( self );
+		/*
+		if ( ForceLightningCheck2Handed( self ) )
+		{//empty handed lightning 3
+			NPC_SetAnim( self, SETANIM_TORSO, BOTH_FORCE_2HANDEDLIGHTNING_START, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+		}
+		else
+		{//one-handed lightning 3
+			NPC_SetAnim( self, SETANIM_TORSO, BOTH_FORCELIGHTNING_START, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+		}
+		*/
+	}
+	self->client->ps.saberMove = self->client->ps.saberBounceMove = LS_READY;//don't finish whatever saber anim you may have been in
+	self->client->ps.saberBlocked = BLOCKED_NONE;
+
+	G_SoundOnEnt( self, CHAN_BODY, "sound/weapons/force/lightning.wav" );
+#ifdef _IMMERSION
+	G_Force( self, G_ForceIndex( "fffx/weapons/force/lightning", FF_CHANNEL_WEAPON ) );
+#endif // _IMMERSION
+	if ( self->client->ps.forcePowerLevel[FP_LIGHTNING] < FORCE_LEVEL_2 )
+	{//short burst
+		//G_SoundOnEnt( self, CHAN_BODY, "sound/weapons/force/lightning.wav" );
+	}
+	else
+	{//holding it
+		self->s.loopSound = G_SoundIndex( "sound/weapons/force/lightning2.wav" );
+	}
+	
+	//FIXME: build-up or delay this until in proper part of anim
+	self->client->ps.weaponTime = self->client->ps.torsoAnimTimer;
+	WP_ForcePowerStart( self, FP_LIGHTNING, self->client->ps.torsoAnimTimer );
+}
+
+void ForceLightningDamage( gentity_t *self, gentity_t *traceEnt, vec3_t dir, float dist, float dot, vec3_t impactPoint )
+{
+	if( traceEnt->NPC && traceEnt->NPC->scriptFlags & SCF_NO_FORCE )
+	{
+		return;
+	}
+
+	if ( traceEnt && traceEnt->takedamage )
+	{
+		if ( !traceEnt->client || traceEnt->client->playerTeam != self->client->playerTeam || self->enemy == traceEnt || traceEnt->enemy == self )
+		{//an enemy or object
+			int	dmg;
+			//FIXME: check for client using FP_ABSORB
+			if ( self->client->ps.forcePowerLevel[FP_LIGHTNING] > FORCE_LEVEL_2 )
+			{//more damage if closer and more in front
+				dmg = 1;
+				if ( self->client->NPC_class == CLASS_REBORN
+					&& self->client->ps.weapon == WP_NONE )
+				{//Cultist: looks fancy, but does less damage
+				}
+				else
+				{
+					if ( dist < 100 )
+					{
+						dmg += 2;
+					}
+					else if ( dist < 200 )
+					{
+						dmg += 1;
+					}
+					if ( dot > 0.9f )
+					{
+						dmg += 2;
+					}
+					else if ( dot > 0.7f )
+					{
+						dmg += 1;
+					}
+				}
+				if ( self->client->ps.torsoAnim == BOTH_FORCE_2HANDEDLIGHTNING
+					|| self->client->ps.torsoAnim == BOTH_FORCE_2HANDEDLIGHTNING_START
+					|| self->client->ps.torsoAnim == BOTH_FORCE_2HANDEDLIGHTNING_HOLD
+					|| self->client->ps.torsoAnim == BOTH_FORCE_2HANDEDLIGHTNING_RELEASE )
+				{//jackin' 'em up, Palpatine-style
+					dmg *= 2;
+				}
+			}
+			else
+			{
+				dmg = Q_irand( 1, 3 );//*self->client->ps.forcePowerLevel[FP_LIGHTNING];
+			}
+
+			if ( traceEnt->client 
+				&& traceEnt->health > 0 
+				&& traceEnt->NPC 
+				&& (traceEnt->NPC->aiFlags&NPCAI_BOSS_CHARACTER) )
+			{//Luke, Desann Tavion and Kyle can shield themselves from the attack
+				//FIXME: shield effect or something?
+				int parts;
+				if ( traceEnt->client->ps.groundEntityNum != ENTITYNUM_NONE && !PM_SpinningSaberAnim( traceEnt->client->ps.legsAnim ) && !PM_FlippingAnim( traceEnt->client->ps.legsAnim ) && !PM_RollingAnim( traceEnt->client->ps.legsAnim ) )
+				{//if on a surface and not in a spin or flip, play full body resist
+					parts = SETANIM_BOTH;
+				}
+				else
+				{//play resist just in torso
+					parts = SETANIM_TORSO;
+				}
+				//FIXME: don't interrupt big anims with this!
+				NPC_SetAnim( traceEnt, parts, BOTH_RESISTPUSH, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+				Jedi_PlayDeflectSound( traceEnt );
+				dmg = Q_irand(0,1);
+			}
+			else if ( traceEnt->s.weapon == WP_SABER )
+			{//saber can block lightning
+				if ( traceEnt->client //a client
+					&& !traceEnt->client->ps.saberInFlight//saber in hand
+					&& ( traceEnt->client->ps.saberMove == LS_READY || PM_SaberInParry( traceEnt->client->ps.saberMove ) || PM_SaberInReturn( traceEnt->client->ps.saberMove ) )//not attacking with saber
+					&& InFOV( self->currentOrigin, traceEnt->currentOrigin, traceEnt->client->ps.viewangles, 20, 35 ) //I'm in front of them
+					&& !PM_InKnockDown( &traceEnt->client->ps ) //they're not in a knockdown
+					&& !PM_SuperBreakLoseAnim( traceEnt->client->ps.torsoAnim )
+					&& !PM_SuperBreakWinAnim( traceEnt->client->ps.torsoAnim )
+					&& !PM_SaberInSpecialAttack( traceEnt->client->ps.torsoAnim )
+					&& !PM_InSpecialJump( traceEnt->client->ps.torsoAnim )
+					&& (!traceEnt->s.number||(traceEnt->NPC&&traceEnt->NPC->rank>=RANK_LT_COMM)) )//the player or a tough jedi/reborn
+				{
+					if ( Q_irand( 0, traceEnt->client->ps.forcePowerLevel[FP_SABER_DEFENSE]*3 ) > 0 )//more of a chance of defending if saber defense is high
+					{
+						dmg = 0;
+					}
+					if ( (traceEnt->client->ps.forcePowersActive&(1<<FP_ABSORB))
+						&& traceEnt->client->ps.forcePowerLevel[FP_ABSORB] > FORCE_LEVEL_2 )
+					{//no parry, just absorb
+					}
+					else
+					{
+						//make them do a parry
+						traceEnt->client->ps.saberBlocked = BLOCKED_UPPER_LEFT;
+						int parryReCalcTime = Jedi_ReCalcParryTime( traceEnt, EVASION_PARRY );
+						if ( traceEnt->client->ps.forcePowerDebounce[FP_SABER_DEFENSE] < level.time + parryReCalcTime )
+						{
+							traceEnt->client->ps.forcePowerDebounce[FP_SABER_DEFENSE] = level.time + parryReCalcTime;
+						}
+						traceEnt->client->ps.weaponTime = Q_irand( 100, 300 );//hold this move - can't attack! - FIXME: unless dual sabers?
+					}
+				}
+				else if ( Q_irand( 0, 1 ) )
+				{//jedi less likely to be damaged
+					dmg = 0;
+				}
+				else
+				{
+					dmg = 1;
+				}
+			}
+			if ( traceEnt && traceEnt->client && traceEnt->client->ps.powerups[PW_GALAK_SHIELD] )
+			{
+				//has shield up
+				dmg = 0;
+			}
+			int modPowerLevel = -1;
+			
+			if (traceEnt->client)
+			{
+				modPowerLevel = WP_AbsorbConversion(traceEnt, traceEnt->client->ps.forcePowerLevel[FP_ABSORB], self, FP_LIGHTNING, self->client->ps.forcePowerLevel[FP_LIGHTNING], 1);
+			}
+
+			if (modPowerLevel != -1)
+			{
+				if ( !modPowerLevel )
+				{
+					dmg = 0;
+				}
+				else if ( modPowerLevel == 1 )
+				{
+					dmg = floor((float)dmg/4.0f);
+				}
+				else if ( modPowerLevel == 2 )
+				{
+					dmg = floor((float)dmg/2.0f);
+				}
+			}
+			//FIXME: if ForceDrain, sap force power and add health to self, use different sound & effects
+			if ( dmg )
+			{
+				G_Damage( traceEnt, self, self, dir, impactPoint, dmg, 0, MOD_FORCE_LIGHTNING );
+			}
+			if ( traceEnt->client )
+			{
+				if ( !Q_irand( 0, 2 ) )
+				{
+					G_Sound( traceEnt, G_SoundIndex( va( "sound/weapons/force/lightninghit%d.wav", Q_irand( 1, 3 ) ) ) );
+				}
+				traceEnt->s.powerups |= ( 1 << PW_SHOCKED );
+
+				// If we are dead or we are a bot, we can do the full version
+				class_t npc_class = traceEnt->client->NPC_class;
+				if ( traceEnt->health <= 0 || ( npc_class == CLASS_SEEKER || npc_class == CLASS_PROBE ||
+					 npc_class == CLASS_MOUSE || npc_class == CLASS_GONK || npc_class == CLASS_R2D2 || npc_class == CLASS_REMOTE ||
+					 npc_class == CLASS_R5D2 || npc_class == CLASS_PROTOCOL || npc_class == CLASS_MARK1 ||
+					 npc_class == CLASS_MARK2 || npc_class == CLASS_INTERROGATOR || npc_class == CLASS_ATST ) ||
+					 npc_class == CLASS_SENTRY )
+				{
+					traceEnt->client->ps.powerups[PW_SHOCKED] = level.time + 4000;
+				}
+				else //short version
+				{
+					traceEnt->client->ps.powerups[PW_SHOCKED] = level.time + 500;
+				}
+			}
+		}
+	}
+}
+
+void ForceShootLightning( gentity_t *self )
+{
+	trace_t	tr;
+	vec3_t	end, forward;
+	gentity_t	*traceEnt;
+
+	if ( self->health <= 0 )
+	{
+		return;
+	}
+	if ( !self->s.number && cg.zoomMode )
+	{//can't force lightning when zoomed in
+		return;
+	}
+
+	AngleVectors( self->client->ps.viewangles, forward, NULL, NULL );
+	VectorNormalize( forward );
+
+	//FIXME: if lightning hits water, do water-only-flagged radius damage from that point
+	if ( self->client->ps.forcePowerLevel[FP_LIGHTNING] > FORCE_LEVEL_2 )
+	{//arc
+		vec3_t	center, mins, maxs, dir, ent_org, size, v;
+		float	radius = 512, dot, dist;
+		gentity_t	*entityList[MAX_GENTITIES];
+		int		e, numListedEntities, i;
+
+		VectorCopy( self->currentOrigin, center );
+		for ( i = 0 ; i < 3 ; i++ ) 
+		{
+			mins[i] = center[i] - radius;
+			maxs[i] = center[i] + radius;
+		}
+		numListedEntities = gi.EntitiesInBox( mins, maxs, entityList, MAX_GENTITIES );
+
+		for ( e = 0 ; e < numListedEntities ; e++ ) 
+		{
+			traceEnt = entityList[e];
+
+			if ( !traceEnt )
+				continue;
+			if ( traceEnt == self )
+				continue;
+			if ( traceEnt->owner == self && traceEnt->s.weapon != WP_THERMAL )//can push your own thermals
+				continue;
+			if ( !traceEnt->inuse )
+				continue;
+			if ( !traceEnt->takedamage )
+				continue;
+			/*
+			if ( traceEnt->health <= 0 )//no torturing corpses
+				continue;
+			*/
+			//this is all to see if we need to start a saber attack, if it's in flight, this doesn't matter
+			// find the distance from the edge of the bounding box
+			for ( i = 0 ; i < 3 ; i++ ) 
+			{
+				if ( center[i] < traceEnt->absmin[i] ) 
+				{
+					v[i] = traceEnt->absmin[i] - center[i];
+				} else if ( center[i] > traceEnt->absmax[i] ) 
+				{
+					v[i] = center[i] - traceEnt->absmax[i];
+				} else 
+				{
+					v[i] = 0;
+				}
+			}
+
+			VectorSubtract( traceEnt->absmax, traceEnt->absmin, size );
+			VectorMA( traceEnt->absmin, 0.5, size, ent_org );
+
+			//see if they're in front of me
+			//must be within the forward cone
+			VectorSubtract( ent_org, center, dir );
+			VectorNormalize( dir );
+			if ( (dot = DotProduct( dir, forward )) < 0.5 )
+				continue;
+
+			//must be close enough
+			dist = VectorLength( v );
+			if ( dist >= radius ) 
+			{
+				continue;
+			}
+		
+			//in PVS?
+			if ( !traceEnt->bmodel && !gi.inPVS( ent_org, self->client->renderInfo.handLPoint ) )
+			{//must be in PVS
+				continue;
+			}
+
+			//Now check and see if we can actually hit it
+			gi.trace( &tr, self->client->renderInfo.handLPoint, vec3_origin, vec3_origin, ent_org, self->s.number, MASK_SHOT );
+			if ( tr.fraction < 1.0f && tr.entityNum != traceEnt->s.number )
+			{//must have clear LOS
+				continue;
+			}
+
+			// ok, we are within the radius, add us to the incoming list
+			//FIXME: maybe add up the ents and do more damage the less ents there are
+			//		as if we're spreading out the damage?
+			ForceLightningDamage( self, traceEnt, dir, dist, dot, ent_org );
+		}
+
+	}
+	else
+	{//trace-line
+		int ignore = self->s.number;
+		int traces = 0;
+		vec3_t	start;
+
+		VectorCopy( self->client->renderInfo.handLPoint, start );
+		VectorMA( self->client->renderInfo.handLPoint, 2048, forward, end );
+		
+		while ( traces < 10 )
+		{//need to loop this in case we hit a Jedi who dodges the shot
+			gi.trace( &tr, start, vec3_origin, vec3_origin, end, ignore, MASK_SHOT, G2_RETURNONHIT, 10 );
+			if ( tr.entityNum == ENTITYNUM_NONE || tr.fraction == 1.0 || tr.allsolid || tr.startsolid )
+			{
+				return;
+			}
+
+			traceEnt = &g_entities[tr.entityNum];
+			//NOTE: only NPCs do this auto-dodge
+			if ( traceEnt 
+				&& traceEnt->s.number >= MAX_CLIENTS
+				&& traceEnt->client
+				&& traceEnt->client->ps.forcePowerLevel[FP_LEVITATION] > FORCE_LEVEL_0 )//&& traceEnt->NPC 
+			{//FIXME: need a more reliable way to know we hit a jedi?
+				if ( !Jedi_DodgeEvasion( traceEnt, self, &tr, HL_NONE ) )
+				{//act like we didn't even hit him
+					VectorCopy( tr.endpos, start );
+					ignore = tr.entityNum;
+					traces++;
+					continue;
+				}
+			}
+			//a Jedi is not dodging this shot
+			break;
+		}
+		
+		traceEnt = &g_entities[tr.entityNum];
+		ForceLightningDamage( self, traceEnt, forward, 0, 0, tr.endpos );
+	}
+}
+
+void WP_DeactivateSaber( gentity_t *self, qboolean clearLength )
+{
+	if ( !self || !self->client )
+	{
+		return;
+	}
+	//keep my saber off!
+	if ( self->client->ps.SaberActive() )
+	{
+		self->client->ps.SaberDeactivate();
+		if ( clearLength )
+		{
+			self->client->ps.SetSaberLength( 0 );
+		}
+		G_SoundIndexOnEnt( self, CHAN_WEAPON, self->client->ps.saber[0].soundOff );
+#ifdef _IMMERSION
+		if ( !self->s.number )
+		{//this is kind of silly to try to do on an NPC
+			if ( self->client->playerTeam == TEAM_PLAYER )
+			{
+				G_Force( self, G_ForceIndex( "fffx/weapons/saber/saberoff", FF_CHANNEL_WEAPON ) );
+			}
+			else
+			{
+				G_Force( self, G_ForceIndex( "fffx/weapons/saber/enemy_saber_off", FF_CHANNEL_WEAPON ) );
+			}
+		}
+#endif // _IMMERSION
+	}
+}
+
+static void ForceShootDrain( gentity_t *self );
+
+void ForceDrainGrabStart( gentity_t *self )
+{
+	NPC_SetAnim( self, SETANIM_BOTH, BOTH_FORCE_DRAIN_GRAB_START, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+	self->client->ps.saberMove = self->client->ps.saberBounceMove = LS_READY;//don't finish whatever saber anim you may have been in
+	self->client->ps.saberBlocked = BLOCKED_NONE;
+
+	self->client->ps.weaponTime = 1000;
+	if ( self->client->ps.forcePowersActive&(1<<FP_SPEED) )
+	{
+		self->client->ps.weaponTime = floor( self->client->ps.weaponTime * g_timescale->value );
+	}
+	//actually grabbing someone, so turn off the saber!
+	WP_DeactivateSaber( self, qtrue );
+}
+
+qboolean ForceDrain2( gentity_t *self )
+{//FIXME: make enemy Jedi able to use this
+	trace_t	tr;
+	vec3_t	end, forward;
+	gentity_t	*traceEnt = NULL;
+
+	if ( self->health <= 0 )
+	{
+		return qtrue;
+	}
+
+	if ( !self->s.number && (cg.zoomMode || in_camera) )
+	{//can't force grip when zoomed in or in cinematic
+		return qtrue;
+	}
+
+	if ( self->client->ps.leanofs )
+	{//can't force-drain while leaning
+		return qtrue;
+	}
+
+	/*
+	if ( self->client->ps.SaberLength() > 0 )
+	{//can't do this if saber is on!
+		return qfalse;
+	}
+	*/
+
+	if ( self->client->ps.forceDrainEntityNum <= ENTITYNUM_WORLD )
+	{//already draining
+		//keep my saber off!
+		WP_DeactivateSaber( self, qtrue );
+		if ( self->client->ps.forcePowerLevel[FP_DRAIN] > FORCE_LEVEL_1 )
+		{
+			self->client->ps.forcePowerDuration[FP_DRAIN] = level.time + 100;
+			self->client->ps.weaponTime = 1000;
+			if ( self->client->ps.forcePowersActive&(1<<FP_SPEED) )
+			{
+				self->client->ps.weaponTime = floor( self->client->ps.weaponTime * g_timescale->value );
+			}
+		}
+		return qtrue;
+	}
+
+	if ( self->client->ps.forcePowerDebounce[FP_DRAIN] > level.time )
+	{//stops it while using it and also after using it, up to 3 second delay
+		return qtrue;
+	}
+
+	if ( self->client->ps.weaponTime > 0 )
+	{//busy
+		return qtrue;
+	}
+
+	if ( self->client->ps.forcePower < 25 || !WP_ForcePowerUsable( self, FP_DRAIN, 0 ) )
+	{
+		return qtrue;
+	}
+
+	if ( self->client->ps.saberLockTime > level.time )
+	{//in saberlock
+		return qtrue;
+	}
+
+	//NOTE: from here on, if it fails, it's okay to try a normal drain, so return qfalse
+	if ( self->client->ps.groundEntityNum == ENTITYNUM_NONE )
+	{//in air
+		return qfalse;
+	}
+
+	//Cause choking anim + health drain in ent in front of me
+	AngleVectors( self->client->ps.viewangles, forward, NULL, NULL );
+	VectorNormalize( forward );
+	VectorMA( self->client->renderInfo.eyePoint, FORCE_DRAIN_DIST, forward, end );
+	
+	//okay, trace straight ahead and see what's there
+	gi.trace( &tr, self->client->renderInfo.eyePoint, vec3_origin, vec3_origin, end, self->s.number, MASK_SHOT );
+	if ( tr.entityNum >= ENTITYNUM_WORLD || tr.fraction == 1.0 || tr.allsolid || tr.startsolid )
+	{
+		return qfalse;
+	}
+	traceEnt = &g_entities[tr.entityNum];
+	if ( !traceEnt || traceEnt == self/*???*/ || traceEnt->bmodel || (traceEnt->health <= 0 && traceEnt->takedamage) || (traceEnt->NPC && traceEnt->NPC->scriptFlags & SCF_NO_FORCE) )
+	{
+		return qfalse;
+	}
+
+	if ( traceEnt->client )
+	{
+		if ( traceEnt->client->ps.forceJumpZStart )
+		{//can't catch them in mid force jump - FIXME: maybe base it on velocity?
+			return qfalse;
+		}
+		if ( traceEnt->client->ps.groundEntityNum == ENTITYNUM_NONE )
+		{//can't catch them in mid air
+			return qfalse;
+		}
+		if ( !Q_stricmp("Yoda",traceEnt->NPC_type) )
+		{
+			Jedi_PlayDeflectSound( traceEnt );
+			ForceThrow( traceEnt, qfalse );
+			return qtrue;
+		}
+		switch ( traceEnt->client->NPC_class )
+		{
+		case CLASS_GALAKMECH://cant grab him, he's in armor
+			G_AddVoiceEvent( traceEnt, Q_irand(EV_PUSHED1, EV_PUSHED3), Q_irand( 3000, 5000 ) );
+			return qfalse;
+			break;
+		case CLASS_ROCKETTROOPER://cant grab him, he's in armor
+		case CLASS_HAZARD_TROOPER://cant grab him, he's in armor
+			return qfalse;
+			break;
+		case CLASS_ATST://much too big to grab!
+			return qfalse;
+			break;
+		//no droids either
+		case CLASS_GONK:
+		case CLASS_R2D2:
+		case CLASS_R5D2:
+		case CLASS_MARK1:
+		case CLASS_MARK2:
+		case CLASS_MOUSE:
+		case CLASS_PROTOCOL:
+		case CLASS_SABER_DROID:
+		case CLASS_ASSASSIN_DROID:
+			return qfalse;
+			break;
+		case CLASS_PROBE:
+		case CLASS_SEEKER:
+		case CLASS_REMOTE:
+		case CLASS_SENTRY:
+		case CLASS_INTERROGATOR:
+			return qfalse;
+			break;
+		case CLASS_DESANN://Desann cannot be gripped, he just pushes you back instantly
+		case CLASS_KYLE:
+		case CLASS_TAVION:
+		case CLASS_LUKE:
+			Jedi_PlayDeflectSound( traceEnt );
+			ForceThrow( traceEnt, qfalse );
+			return qtrue;
+			break;
+		case CLASS_REBORN:
+		case CLASS_SHADOWTROOPER:
+		//case CLASS_ALORA:
+		case CLASS_JEDI:
+			if ( traceEnt->NPC 
+				&& traceEnt->NPC->rank > RANK_CIVILIAN 
+				&& self->client->ps.forcePowerLevel[FP_DRAIN] < FORCE_LEVEL_2 
+				&& traceEnt->client->ps.weaponTime <= 0 )
+			{
+				ForceDrainGrabStart( self );
+				Jedi_PlayDeflectSound( traceEnt );
+				ForceThrow( traceEnt, qfalse );
+				return qtrue;
+			}
+			break;
+		}
+		if ( traceEnt->s.weapon == WP_EMPLACED_GUN )
+		{//FIXME: maybe can pull them out?
+			return qfalse;
+		}
+		if ( traceEnt != self->enemy && OnSameTeam(self, traceEnt) )
+		{//can't accidently grip-drain your teammate
+			return qfalse;
+		}
+//=CHECKABSORB===
+		/*
+		if ( -1 != WP_AbsorbConversion( traceEnt, traceEnt->client->ps.forcePowerLevel[FP_ABSORB], self, FP_DRAIN, self->client->ps.forcePowerLevel[FP_DRAIN], forcePowerNeeded[self->client->ps.forcePowerLevel[FP_DRAIN]]) )
+		{
+			//WP_ForcePowerStop( self, FP_DRAIN );
+			return;
+		}
+		*/
+//===============
+		if ( !FP_ForceDrainGrippableEnt( traceEnt ) )
+		{
+			return qfalse;
+		}
+	}
+	else
+	{//can't drain non-clients
+		return qfalse;
+	}
+
+	ForceDrainGrabStart( self );
+
+	WP_ForcePowerStart( self, FP_DRAIN, 10 );
+	self->client->ps.forceDrainEntityNum = traceEnt->s.number;
+
+//	G_AddVoiceEvent( traceEnt, Q_irand(EV_PUSHED1, EV_PUSHED3), 2000 );
+	G_AddVoiceEvent( traceEnt, Q_irand(EV_CHOKE1, EV_CHOKE3), 2000 );
+	if ( /*self->client->ps.forcePowerLevel[FP_DRAIN] > FORCE_LEVEL_2 ||*/ traceEnt->s.weapon == WP_SABER )
+	{//if we pick up, turn off their weapon
+		WP_DeactivateSaber( traceEnt, qtrue );
+	}
+
+	/*
+	if ( self->client->ps.forcePowerLevel[FP_DRAIN] < FORCE_LEVEL_2 )
+	{//just a duration
+		self->client->ps.forcePowerDebounce[FP_DRAIN] = level.time + 250;
+		self->client->ps.forcePowerDuration[FP_DRAIN] = level.time + 5000;
+	}
+	*/
+
+	G_SoundOnEnt( self, CHAN_BODY, "sound/weapons/force/drain.mp3" );
+
+//	NPC_SetAnim( traceEnt, SETANIM_BOTH, BOTH_HUGGEE1, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+	NPC_SetAnim( traceEnt, SETANIM_BOTH, BOTH_FORCE_DRAIN_GRABBED, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+	
+	WP_SabersCheckLock2( self, traceEnt, LOCK_FORCE_DRAIN );
+
+	return qtrue;
+}
+
+void ForceDrain( gentity_t *self, qboolean triedDrain2 )
+{
+	if ( self->health <= 0 )
+	{
+		return;
+	}
+
+	if ( !triedDrain2 && self->client->ps.weaponTime > 0 )
+	{
+		return;
+	}
+
+	if ( self->client->ps.forcePower < 25 || !WP_ForcePowerUsable( self, FP_DRAIN, 0 ) )
+	{
+		return;
+	}
+	if ( self->client->ps.forcePowerDebounce[FP_DRAIN] > level.time )
+	{//stops it while using it and also after using it, up to 3 second delay
+		return;
+	}
+
+	if ( self->client->ps.saberLockTime > level.time )
+	{//FIXME: can this be a way to break out?
+		return;
+	}
+
+	// Make sure to turn off Force Protection and Force Absorb.
+	if ( self->client->ps.forcePowersActive & (1 << FP_PROTECT) )
+	{
+		WP_ForcePowerStop( self, FP_PROTECT );
+	}
+	if ( self->client->ps.forcePowersActive & (1 << FP_ABSORB) )
+	{
+		WP_ForcePowerStop( self, FP_ABSORB );
+	}
+
+	G_SoundOnEnt( self, CHAN_BODY, "sound/weapons/force/drain.mp3" );
+	
+	WP_ForcePowerStart( self, FP_DRAIN, 0 );
+}
+
+
+qboolean FP_ForceDrainableEnt( gentity_t *victim )
+{
+	if ( !victim || !victim->client )
+	{
+		return qfalse;
+	}
+	switch ( victim->client->NPC_class )
+	{
+	case CLASS_SAND_CREATURE://??
+	case CLASS_ATST:				// technically droid...
+	case CLASS_GONK:				// droid
+	case CLASS_INTERROGATOR:		// droid 
+	case CLASS_MARK1:			// droid
+	case CLASS_MARK2:			// droid
+	case CLASS_GALAKMECH:		// droid
+	case CLASS_MINEMONSTER:
+	case CLASS_MOUSE:			// droid
+	case CLASS_PROBE:			// droid
+	case CLASS_PROTOCOL:			// droid
+	case CLASS_R2D2:				// droid
+	case CLASS_R5D2:				// droid
+	case CLASS_REMOTE:
+	case CLASS_SEEKER:			// droid
+	case CLASS_SENTRY:
+	case CLASS_SABER_DROID:
+	case CLASS_ASSASSIN_DROID:
+	case CLASS_VEHICLE:
+		return qfalse;
+		break;
+	}
+	return qtrue;
+}
+
+qboolean FP_ForceDrainGrippableEnt( gentity_t *victim )
+{
+	if ( !victim || !victim->client )
+	{
+		return qfalse;
+	}
+	if ( !FP_ForceDrainableEnt( victim ) )
+	{
+		return qfalse;
+	}
+	switch ( victim->client->NPC_class )
+	{
+	case CLASS_RANCOR:
+	case CLASS_SAND_CREATURE:
+	case CLASS_WAMPA:
+	case CLASS_LIZARD:
+	case CLASS_MINEMONSTER:
+	case CLASS_MURJJ:
+	case CLASS_SWAMP:
+	case CLASS_ROCKETTROOPER:
+	case CLASS_HAZARD_TROOPER:
+		return qfalse;
+	}
+	return qtrue;
+}
+
+void ForceDrainDamage( gentity_t *self, gentity_t *traceEnt, vec3_t dir, vec3_t impactPoint )
+{
+	if ( traceEnt 
+		&& traceEnt->health > 0 
+		&& traceEnt->takedamage 
+		&& FP_ForceDrainableEnt( traceEnt ) )
+	{
+		if ( traceEnt->client 
+			&& (!OnSameTeam(self, traceEnt)||self->enemy==traceEnt)//don't drain an ally unless that is actually my current enemy
+			&& self->client->ps.forceDrainTime < level.time )
+		{//an enemy or object
+			int modPowerLevel = -1;
+			int	dmg = self->client->ps.forcePowerLevel[FP_DRAIN] + 1;
+			int dflags = (DAMAGE_NO_ARMOR|DAMAGE_NO_KNOCKBACK|DAMAGE_NO_HIT_LOC);//|DAMAGE_NO_KILL);
+			if ( traceEnt->s.number == self->client->ps.forceDrainEntityNum )
+			{//grabbing hold of them does more damage/drains more, and can actually kill them
+				dmg += 3;
+				dflags |= DAMAGE_IGNORE_TEAM;
+				//dflags &= ~DAMAGE_NO_KILL;
+			}
+		
+			if (traceEnt->client)
+			{
+				//check for client using FP_ABSORB
+				modPowerLevel = WP_AbsorbConversion(traceEnt, traceEnt->client->ps.forcePowerLevel[FP_ABSORB], self, FP_DRAIN, self->client->ps.forcePowerLevel[FP_DRAIN], 0);
+				//Since this is drain, don't absorb any power, but nullify the affect it has
+			}
+
+			if ( modPowerLevel != -1 )
+			{
+				if ( !modPowerLevel )
+				{
+					dmg = 0;
+				}
+				else if ( modPowerLevel == 1 )
+				{
+					dmg = 1;
+				}
+				else if ( modPowerLevel == 2 )
+				{
+					dmg = 2;
+				}
+			}
+
+			if ( dmg )
+			{
+				int	drain = 0; 
+				if ( traceEnt->client->ps.forcePower )
+				{
+					if ( dmg > traceEnt->client->ps.forcePower )
+					{
+						drain = traceEnt->client->ps.forcePower;
+						dmg -= drain;
+						traceEnt->client->ps.forcePower = 0;
+					}
+					else
+					{
+						drain = dmg;
+						traceEnt->client->ps.forcePower -= (dmg);
+						dmg = 0;
+					}
+				}
+
+				/*
+				if ( (dflags&DAMAGE_NO_KILL) )
+				{//must cap damage
+					if ( traceEnt->health <= 1 )
+					{//can't drain more than they have
+						dmg = 0;
+					}
+					else if ( dmg >= traceEnt->health )
+					{//no more than they have, leaving one for them
+						dmg = traceEnt->health-1;
+					}
+				}
+				*/
+
+				int maxHealth = self->client->ps.stats[STAT_MAX_HEALTH];
+				if ( self->client->ps.forcePowerLevel[FP_DRAIN] > FORCE_LEVEL_2 )
+				{//overcharge health
+					maxHealth = floor( (float)self->client->ps.stats[STAT_MAX_HEALTH] * 1.25f );
+				}
+				if (self->client->ps.stats[STAT_HEALTH] < maxHealth &&
+					self->health > 0 && self->client->ps.stats[STAT_HEALTH] > 0)
+				{
+					self->health += (drain+dmg);
+					if (self->health > maxHealth )
+					{
+						self->health = maxHealth;
+					}
+					self->client->ps.stats[STAT_HEALTH] = self->health;
+					if ( self->health > self->client->ps.stats[STAT_MAX_HEALTH] )
+					{
+						self->flags |= FL_OVERCHARGED_HEALTH;
+					}
+				}
+
+				if ( dmg )
+				{//do damage, too
+					G_Damage( traceEnt, self, self, dir, impactPoint, dmg, dflags, MOD_FORCE_DRAIN );
+				}
+				else if ( drain )
+				{
+					/*
+					if ( traceEnt->s.number == self->client->ps.forceDrainEntityNum 
+						|| traceEnt->s.number < MAX_CLIENTS )
+					{//grip-draining (or player - only does sound)
+					*/
+						NPC_SetPainEvent( traceEnt );
+					/*
+					}
+					else
+					{
+						GEntity_PainFunc( traceEnt, self, self, impactPoint, 0, MOD_FORCE_DRAIN );
+					}
+					*/
+				}
+
+				if ( !Q_irand( 0, 2 ) )
+				{
+					G_Sound( traceEnt, G_SoundIndex( "sound/weapons/force/drained.mp3" ) );
+				}
+
+				traceEnt->client->ps.forcePowerRegenDebounceTime = level.time + 800; //don't let the client being drained get force power back right away
+			}
+		}
+	}
+}
+
+qboolean WP_CheckForceDraineeStopMe( gentity_t *self, gentity_t *drainee )
+{
+	if ( drainee->NPC 
+		&& drainee->client  
+		&& (drainee->client->ps.forcePowersKnown&(1<<FP_PUSH))
+		&& level.time-(self->client->ps.forcePowerDebounce[FP_DRAIN]>self->client->ps.forcePowerLevel[FP_DRAIN]*500)//at level 1, I always get at least 500ms of drain, at level 3 I get 1500ms
+		&& !Q_irand( 0, 100-(drainee->NPC->stats.evasion*10)-(g_spskill->integer*12) ) ) 
+	{//a jedi who broke free
+		ForceThrow( drainee, qfalse );
+		//FIXME: I need to go into some pushed back anim...
+		WP_ForcePowerStop( self, FP_DRAIN );
+		//can't drain again for 2 seconds
+		self->client->ps.forcePowerDebounce[FP_DRAIN] = level.time + 4000;
+		return qtrue;
+	}
+	return qfalse;
+}
+
+void ForceShootDrain( gentity_t *self )
+{
+	trace_t	tr;
+	vec3_t	end, forward;
+	gentity_t	*traceEnt;
+	int			numDrained = 0;
+
+	if ( self->health <= 0 )
+	{
+		return;
+	}
+	
+	if ( self->client->ps.forcePowerDebounce[FP_DRAIN] <= level.time )
+	{
+		AngleVectors( self->client->ps.viewangles, forward, NULL, NULL );
+		VectorNormalize( forward );
+
+		if ( self->client->ps.forcePowerLevel[FP_DRAIN] > FORCE_LEVEL_2 )
+		{//arc
+			vec3_t	center, mins, maxs, dir, ent_org, size, v;
+			float	radius = MAX_DRAIN_DISTANCE, dot, dist;
+			gentity_t	*entityList[MAX_GENTITIES];
+			int		e, numListedEntities, i;
+
+			VectorCopy( self->client->ps.origin, center );
+			for ( i = 0 ; i < 3 ; i++ ) 
+			{
+				mins[i] = center[i] - radius;
+				maxs[i] = center[i] + radius;
+			}
+			numListedEntities = gi.EntitiesInBox( mins, maxs, entityList, MAX_GENTITIES );
+
+			for ( e = 0 ; e < numListedEntities ; e++ ) 
+			{
+				traceEnt = entityList[e];
+
+				if ( !traceEnt )
+					continue;
+				if ( traceEnt == self )
+					continue;
+				if ( !traceEnt->inuse )
+					continue;
+				if ( !traceEnt->takedamage )
+					continue;
+				if ( traceEnt->health <= 0 )//no torturing corpses
+					continue;
+				if ( !traceEnt->client )
+					continue;
+				/*
+				if ( !traceEnt->client->ps.forcePower )
+					continue;
+				*/
+	//			if (traceEnt->client->ps.forceSide == FORCE_DARKSIDE)	// We no longer care if the victim is dark or light
+	//				continue;
+				if (self->enemy != traceEnt//not my enemy
+					&& OnSameTeam(self, traceEnt))//on my team
+					continue;
+				//this is all to see if we need to start a saber attack, if it's in flight, this doesn't matter
+				// find the distance from the edge of the bounding box
+				for ( i = 0 ; i < 3 ; i++ ) 
+				{
+					if ( center[i] < traceEnt->absmin[i] ) 
+					{
+						v[i] = traceEnt->absmin[i] - center[i];
+					} else if ( center[i] > traceEnt->absmax[i] ) 
+					{
+						v[i] = center[i] - traceEnt->absmax[i];
+					} else 
+					{
+						v[i] = 0;
+					}
+				}
+
+				VectorSubtract( traceEnt->absmax, traceEnt->absmin, size );
+				VectorMA( traceEnt->absmin, 0.5, size, ent_org );
+
+				//see if they're in front of me
+				//must be within the forward cone
+				VectorSubtract( ent_org, center, dir );
+				VectorNormalize( dir );
+				if ( (dot = DotProduct( dir, forward )) < 0.5 )
+					continue;
+
+				//must be close enough
+				dist = VectorLength( v );
+				if ( dist >= radius ) 
+				{
+					continue;
+				}
+			
+				//in PVS?
+				if ( !traceEnt->bmodel && !gi.inPVS( ent_org, self->client->renderInfo.handLPoint ) )
+				{//must be in PVS
+					continue;
+				}
+
+				//Now check and see if we can actually hit it
+				gi.trace( &tr, self->client->ps.origin, vec3_origin, vec3_origin, ent_org, self->s.number, MASK_SHOT, G2_RETURNONHIT, 10 );
+				if ( tr.fraction < 1.0f && tr.entityNum != traceEnt->s.number )
+				{//must have clear LOS
+					continue;
+				}
+
+				if ( traceEnt 
+					&& traceEnt->s.number >= MAX_CLIENTS
+					&& traceEnt->client
+					&& traceEnt->client->ps.forcePowerLevel[FP_LEVITATION] > FORCE_LEVEL_0 )//&& traceEnt->NPC 
+				{  
+					if ( !Q_irand( 0, 4 ) && !Jedi_DodgeEvasion( traceEnt, self, &tr, HL_NONE ) )
+					{//act like we didn't even hit him
+						continue;
+					}
+				} 
+
+				// ok, we are within the radius, add us to the incoming list
+				if ( WP_CheckForceDraineeStopMe( self, traceEnt ) )
+				{
+					continue;
+				}
+				ForceDrainDamage( self, traceEnt, dir, ent_org );
+				numDrained++;
+			}
+
+		}
+		else
+		{//trace-line
+			int ignore = self->s.number;
+			int traces = 0;
+			vec3_t	start;
+
+			VectorCopy( self->client->renderInfo.handLPoint, start );
+			VectorMA( start, MAX_DRAIN_DISTANCE, forward, end );
+			
+			while ( traces < 10 )
+			{//need to loop this in case we hit a Jedi who dodges the shot
+				gi.trace( &tr, start, vec3_origin, vec3_origin, end, ignore, MASK_SHOT, G2_RETURNONHIT, 10 );
+				if ( tr.entityNum == ENTITYNUM_NONE || tr.fraction == 1.0 || tr.allsolid || tr.startsolid )
+				{
+					//always take 1 force point per frame that we're shooting this
+					WP_ForcePowerDrain( self, FP_DRAIN, 1 );
+					return;
+				}
+
+				traceEnt = &g_entities[tr.entityNum];
+				//NOTE: only NPCs do this auto-dodge
+				if ( traceEnt 
+					&& traceEnt->s.number >= MAX_CLIENTS
+					&& traceEnt->client
+					&& traceEnt->client->ps.forcePowerLevel[FP_LEVITATION] > FORCE_LEVEL_0 )//&& traceEnt->NPC 
+				{ 
+					if ( !Q_irand( 0, 2 ) && !Jedi_DodgeEvasion( traceEnt, self, &tr, HL_NONE ) )
+					{//act like we didn't even hit him  
+						VectorCopy( tr.endpos, start );
+						ignore = tr.entityNum;
+						traces++;
+						continue;
+					}
+				}
+				//a Jedi is not dodging this shot
+				break;
+			}
+			traceEnt = &g_entities[tr.entityNum];
+			if ( !WP_CheckForceDraineeStopMe( self, traceEnt ) )
+			{
+				ForceDrainDamage( self, traceEnt, forward, tr.endpos );
+			}
+			numDrained = 1;
+		}
+
+		self->client->ps.forcePowerDebounce[FP_DRAIN] = level.time + 200;//so we don't drain so damn fast!
+	}
+	self->client->ps.forcePowerRegenDebounceTime = level.time + 500;
+	
+	if ( !numDrained )
+	{//always take 1 force point per frame that we're shooting this
+		WP_ForcePowerDrain( self, FP_DRAIN, 1 );
+	}
+	else
+	{
+		WP_ForcePowerDrain( self, FP_DRAIN, numDrained );//was 2, but...
+	}
+
+	return;
+}
+
+void ForceDrainEnt( gentity_t *self, gentity_t *drainEnt )
+{
+	if ( self->health <= 0 )
+	{
+		return;
+	}
+	
+	if ( self->client->ps.forcePowerDebounce[FP_DRAIN] <= level.time )
+	{
+		if ( !drainEnt )
+			return;
+		if ( drainEnt == self )
+			return;
+		if ( !drainEnt->inuse )
+			return;
+		if ( !drainEnt->takedamage )
+			return;
+		if ( drainEnt->health <= 0 )//no torturing corpses
+			return;
+		if ( !drainEnt->client )
+			return;
+		if (OnSameTeam(self, drainEnt))
+			return;
+
+		vec3_t fwd;
+		AngleVectors( self->client->ps.viewangles, fwd, NULL, NULL );
+
+		drainEnt->painDebounceTime = 0;
+		ForceDrainDamage( self, drainEnt, fwd, drainEnt->currentOrigin );
+		drainEnt->painDebounceTime = level.time + 2000;
+
+		if ( drainEnt->s.number )
+		{
+			if ( self->client->ps.forcePowerLevel[FP_DRAIN] > FORCE_LEVEL_2 )
+			{//do damage faster at level 3
+				self->client->ps.forcePowerDebounce[FP_DRAIN] = level.time + Q_irand( 100, 500 );
+			}
+			else
+			{
+				self->client->ps.forcePowerDebounce[FP_DRAIN] = level.time + Q_irand( 200, 800 );
+			}
+		}
+		else
+		{//player takes damage faster
+			self->client->ps.forcePowerDebounce[FP_DRAIN] = level.time + Q_irand( 100, 500 );
+		}
+	}
+
+	self->client->ps.forcePowerRegenDebounceTime = level.time + 500;
+}
+
+void ForceSeeing( gentity_t *self )
+{
+	if ( self->health <= 0 )
+	{
+		return;
+	}
+
+	if (self->client->ps.forceAllowDeactivateTime < level.time &&
+		(self->client->ps.forcePowersActive & (1 << FP_SEE)) )
+	{
+		WP_ForcePowerStop( self, FP_SEE );
+		return;
+	}
+
+	if ( !WP_ForcePowerUsable( self, FP_SEE, 0 ) )
+	{
+		return;
+	}
+
+	WP_DebounceForceDeactivateTime( self );
+
+	WP_ForcePowerStart( self, FP_SEE, 0 );
+
+	G_SoundOnEnt( self, CHAN_ITEM, "sound/weapons/force/see.wav" );
+}
+
+void ForceProtect( gentity_t *self )
+{
+	if ( self->health <= 0 )
+	{
+		return;
+	}
+
+	if (self->client->ps.forceAllowDeactivateTime < level.time &&
+		(self->client->ps.forcePowersActive & (1 << FP_PROTECT)) )
+	{
+		WP_ForcePowerStop( self, FP_PROTECT );
+		return;
+	}
+
+	if ( !WP_ForcePowerUsable( self, FP_PROTECT, 0 ) )
+	{
+		return;
+	}
+
+	// Make sure to turn off Force Rage and Force Absorb.
+	if (self->client->ps.forcePowersActive & (1 << FP_RAGE) )
+	{
+		WP_ForcePowerStop( self, FP_RAGE );
+	}
+
+	WP_DebounceForceDeactivateTime( self );
+
+	WP_ForcePowerStart( self, FP_PROTECT, 0 );
+
+	if ( self->client->ps.saberLockTime < level.time )
+	{
+		if ( self->client->ps.forcePowerLevel[FP_PROTECT] < FORCE_LEVEL_3 )
+		{//animate
+			int parts = SETANIM_BOTH;
+			int anim = BOTH_FORCE_PROTECT;
+			if ( self->client->ps.forcePowerLevel[FP_PROTECT] > FORCE_LEVEL_1 )
+			{//level 2 only does it on torso (can keep running)
+				parts = SETANIM_TORSO;
+				anim = BOTH_FORCE_PROTECT_FAST;
+			}
+			else
+			{
+				if ( self->client->ps.groundEntityNum != ENTITYNUM_NONE )
+				{
+					VectorClear( self->client->ps.velocity );
+				}
+				if ( self->NPC )
+				{
+					VectorClear( self->client->ps.moveDir );
+					self->client->ps.speed = 0;
+				}
+				//FIXME: what if in air?
+			}
+			NPC_SetAnim( self, SETANIM_BOTH, anim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+			//don't move or attack during this anim
+			if ( self->client->ps.forcePowerLevel[FP_PROTECT] < FORCE_LEVEL_2 )
+			{
+				self->client->ps.pm_flags |= PMF_TIME_KNOCKBACK;
+				self->client->ps.pm_time = self->client->ps.weaponTime = self->client->ps.torsoAnimTimer;
+				if ( self->s.number )
+				{//NPC
+					self->painDebounceTime = level.time + self->client->ps.torsoAnimTimer;
+				}
+				else
+				{//player
+					self->aimDebounceTime = level.time + self->client->ps.torsoAnimTimer;
+				}
+			}
+			else
+			{
+				self->client->ps.weaponTime = self->client->ps.torsoAnimTimer;
+			}
+		}
+	}
+}
+
+void ForceAbsorb( gentity_t *self )
+{
+	if ( self->health <= 0 )
+	{
+		return;
+	}
+
+	if (self->client->ps.forceAllowDeactivateTime < level.time &&
+		(self->client->ps.forcePowersActive & (1 << FP_ABSORB)) )
+	{
+		WP_ForcePowerStop( self, FP_ABSORB );
+		return;
+	}
+
+	if ( !WP_ForcePowerUsable( self, FP_ABSORB, 0 ) )
+	{
+		return;
+	}
+
+	// Make sure to turn off Force Rage and Force Protection.
+	if (self->client->ps.forcePowersActive & (1 << FP_RAGE) )
+	{
+		WP_ForcePowerStop( self, FP_RAGE );
+	}
+
+	WP_DebounceForceDeactivateTime( self );
+
+	WP_ForcePowerStart( self, FP_ABSORB, 0 );
+
+	if ( self->client->ps.saberLockTime < level.time )
+	{
+		if ( self->client->ps.forcePowerLevel[FP_ABSORB] < FORCE_LEVEL_3 )
+		{//must animate
+			int parts = SETANIM_BOTH;
+			if ( self->client->ps.forcePowerLevel[FP_ABSORB] > FORCE_LEVEL_1 )
+			{//level 2 only does it on torso (can keep running)
+				parts = SETANIM_TORSO;
+			}
+			else
+			{
+				if ( self->client->ps.groundEntityNum != ENTITYNUM_NONE )
+				{
+					VectorClear( self->client->ps.velocity );
+				}
+				if ( self->NPC )
+				{
+					VectorClear( self->client->ps.moveDir );
+					self->client->ps.speed = 0;
+				}
+				//FIXME: what if in air?
+			}
+			/*
+			//if in air, only do on torso - NOTE: or moving?
+			if ( self->client->ps.groundEntityNum == ENTITYNUM_NONE )//|| !VectorCompare( self->client->ps.velocity, vec3_origin ) )
+			{
+				parts = SETANIM_TORSO;
+			}
+			*/
+			NPC_SetAnim( self, parts, BOTH_FORCE_ABSORB, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+			self->client->ps.weaponTime = self->client->ps.torsoAnimTimer;
+			if ( parts == SETANIM_BOTH )
+			{//can't move
+				self->client->ps.pm_flags |= PMF_TIME_KNOCKBACK;
+				self->client->ps.pm_time = self->client->ps.legsAnimTimer = self->client->ps.torsoAnimTimer;// = self->client->ps.forcePowerDuration[FP_ABSORB];
+				if ( self->s.number )
+				{//NPC
+					self->painDebounceTime = level.time + self->client->ps.pm_time;//self->client->ps.forcePowerDuration[FP_ABSORB];
+				}
+				else
+				{//player
+					self->aimDebounceTime = level.time + self->client->ps.pm_time;//self->client->ps.forcePowerDuration[FP_ABSORB];
+				}
+			}
+			//stop saber
+			//WP_DeactivateSaber( self );//turn off saber when meditating
+			self->client->ps.saberMove = self->client->ps.saberBounceMove = LS_READY;//don't finish whatever saber anim you may have been in
+			self->client->ps.saberBlocked = BLOCKED_NONE;
+		}
+	}
+}
+
+void ForceRage( gentity_t *self )
+{
+	if ( self->health <= 0 )
+	{
+		return;
+	}
+
+	//FIXME: prevent them from using any other force powers when raging?
+
+	if (self->client->ps.forceAllowDeactivateTime < level.time &&
+		(self->client->ps.forcePowersActive & (1 << FP_RAGE)) )
+	{
+		WP_ForcePowerStop( self, FP_RAGE );
+		return;
+	}
+
+	if ( !WP_ForcePowerUsable( self, FP_RAGE, 0 ) )
+	{
+		return;
+	}
+
+	if (self->client->ps.forceRageRecoveryTime >= level.time)
+	{
+		return;
+	}
+
+	if ( self->s.number < MAX_CLIENTS
+		&& self->health < 25 )
+	{//have to have at least 25 health to start it
+		return;
+	}
+
+	if (self->health < 10)
+	{
+		return;
+	}
+
+	// Make sure to turn off Force Protection and Force Absorb.
+	if (self->client->ps.forcePowersActive & (1 << FP_PROTECT) )
+	{
+		WP_ForcePowerStop( self, FP_PROTECT );
+	}
+	if (self->client->ps.forcePowersActive & (1 << FP_ABSORB) )
+	{
+		WP_ForcePowerStop( self, FP_ABSORB );
+	}
+
+	WP_DebounceForceDeactivateTime( self );
+
+	WP_ForcePowerStart( self, FP_RAGE, 0 );
+
+	if ( self->client->ps.saberLockTime < level.time )
+	{
+		if ( self->client->ps.forcePowerLevel[FP_RAGE] < FORCE_LEVEL_3 )
+		{//must animate
+			if ( self->client->ps.forcePowerLevel[FP_RAGE] < FORCE_LEVEL_2 )
+			{//have to stand still for whole length of anim
+				//FIXME: if in air, only do on torso?
+				NPC_SetAnim( self, SETANIM_BOTH, BOTH_FORCE_RAGE, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+				//don't attack during this anim
+				self->client->ps.weaponTime = self->client->ps.torsoAnimTimer;
+				self->client->ps.pm_flags |= PMF_TIME_KNOCKBACK;
+				self->client->ps.pm_time = self->client->ps.torsoAnimTimer;
+				if ( self->s.number )
+				{//NPC
+					self->painDebounceTime = level.time + self->client->ps.torsoAnimTimer;
+				}
+				else
+				{//player
+					self->aimDebounceTime = level.time + self->client->ps.torsoAnimTimer;
+				}
+			}
+			else
+			{
+				NPC_SetAnim( self, SETANIM_TORSO, BOTH_FORCE_RAGE, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+				//don't attack during this anim
+				self->client->ps.weaponTime = self->client->ps.torsoAnimTimer;
+			}
+			//stop saber
+			self->client->ps.saberMove = self->client->ps.saberBounceMove = LS_READY;//don't finish whatever saber anim you may have been in
+			self->client->ps.saberBlocked = BLOCKED_NONE;
+		}
+	}
+}
+
+void ForceJumpCharge( gentity_t *self, usercmd_t *ucmd )
+{
+	float forceJumpChargeInterval = forceJumpStrength[0] / (FORCE_JUMP_CHARGE_TIME/FRAMETIME);
+
+	if ( self->health <= 0 )
+	{
+		return;
+	}
+	if ( !self->s.number && cg.zoomMode )
+	{//can't force jump when zoomed in
+		return;
+	}
+
+	//need to play sound
+	if ( !self->client->ps.forceJumpCharge )
+	{//FIXME: this should last only as long as the actual charge-up
+		G_SoundOnEnt( self, CHAN_BODY, "sound/weapons/force/jumpbuild.wav" );
+#ifdef _IMMERSION
+		G_Force( self, G_ForceIndex( "fffx/weapons/force/jumpbuild", FF_CHANNEL_WEAPON ) );
+#endif // _IMMERSION
+	}
+	//Increment
+	self->client->ps.forceJumpCharge += forceJumpChargeInterval;
+
+	//clamp to max strength for current level
+	if ( self->client->ps.forceJumpCharge > forceJumpStrength[self->client->ps.forcePowerLevel[FP_LEVITATION]] )
+	{
+		self->client->ps.forceJumpCharge = forceJumpStrength[self->client->ps.forcePowerLevel[FP_LEVITATION]];
+	}
+
+	//clamp to max available force power
+	if ( self->client->ps.forceJumpCharge/forceJumpChargeInterval/(FORCE_JUMP_CHARGE_TIME/FRAMETIME)*forcePowerNeeded[FP_LEVITATION] > self->client->ps.forcePower )
+	{//can't use more than you have
+		self->client->ps.forceJumpCharge = self->client->ps.forcePower*forceJumpChargeInterval/(FORCE_JUMP_CHARGE_TIME/FRAMETIME);
+	}
+	//FIXME: a simple tap should always do at least a normal height's jump?
+}
+
+int WP_GetVelocityForForceJump( gentity_t *self, vec3_t jumpVel, usercmd_t *ucmd )
+{
+	float pushFwd = 0, pushRt = 0;
+	vec3_t	view, forward, right;
+	VectorCopy( self->client->ps.viewangles, view );
+	view[0] = 0;
+	AngleVectors( view, forward, right, NULL );
+	if ( ucmd->forwardmove && ucmd->rightmove )
+	{
+		if ( ucmd->forwardmove > 0 )
+		{
+			pushFwd = 50;
+		}
+		else
+		{
+			pushFwd = -50;
+		}
+		if ( ucmd->rightmove > 0 )
+		{
+			pushRt = 50;
+		}
+		else
+		{
+			pushRt = -50;
+		}
+	}
+	else if ( ucmd->forwardmove || ucmd->rightmove )
+	{
+		if ( ucmd->forwardmove > 0 )
+		{
+			pushFwd = 100;
+		}
+		else if ( ucmd->forwardmove < 0 )
+		{
+			pushFwd = -100;
+		}
+		else if ( ucmd->rightmove > 0 )
+		{
+			pushRt = 100;
+		}
+		else if ( ucmd->rightmove < 0 )
+		{
+			pushRt = -100;
+		}
+	}
+	VectorMA( self->client->ps.velocity, pushFwd, forward, jumpVel );
+	VectorMA( self->client->ps.velocity, pushRt, right, jumpVel );
+	jumpVel[2] += self->client->ps.forceJumpCharge;//forceJumpStrength;
+	if ( pushFwd > 0 && self->client->ps.forceJumpCharge > 200 )
+	{
+		return FJ_FORWARD;
+	}
+	else if ( pushFwd < 0 && self->client->ps.forceJumpCharge > 200 )
+	{
+		return FJ_BACKWARD;
+	}
+	else if ( pushRt > 0 && self->client->ps.forceJumpCharge > 200 )
+	{
+		return FJ_RIGHT;
+	}
+	else if ( pushRt < 0 && self->client->ps.forceJumpCharge > 200 )
+	{
+		return FJ_LEFT;
+	}
+	else
+	{//FIXME: jump straight up anim
+		return FJ_UP;
+	}
+}
+
+void ForceJump( gentity_t *self, usercmd_t *ucmd )
+{
+	if ( self->client->ps.forcePowerDuration[FP_LEVITATION] > level.time )
+	{
+		return;
+	}
+	if ( !WP_ForcePowerUsable( self, FP_LEVITATION, 0 ) )
+	{
+		return;
+	}
+	if ( self->s.groundEntityNum == ENTITYNUM_NONE )
+	{
+		return;
+	}
+	if ( self->client->ps.pm_flags&PMF_JUMP_HELD )
+	{
+		return;
+	}
+	if ( self->health <= 0 )
+	{
+		return;
+	}
+	if ( !self->s.number && (cg.zoomMode || in_camera) )
+	{//can't force jump when zoomed in or in cinematic
+		return;
+	}
+	if ( self->client->ps.saberLockTime > level.time )
+	{//FIXME: can this be a way to break out?
+		return;
+	}
+
+	if ( self->client->NPC_class == CLASS_BOBAFETT 
+		|| self->client->NPC_class == CLASS_ROCKETTROOPER )
+	{
+		if ( self->client->ps.forceJumpCharge > 300 )
+		{
+			JET_FlyStart(NPC);
+		}
+		else
+		{
+			G_AddEvent( self, EV_JUMP, 0 );
+		}
+	}
+	else
+	{
+		G_SoundOnEnt( self, CHAN_BODY, "sound/weapons/force/jump.wav" );
+	}
+#ifdef _IMMERSION
+	G_Force( self, G_ForceIndex( "fffx/weapons/force/jump", FF_CHANNEL_WEAPON ) );
+#endif // _IMMERSION
+
+	float forceJumpChargeInterval = forceJumpStrength[self->client->ps.forcePowerLevel[FP_LEVITATION]]/(FORCE_JUMP_CHARGE_TIME/FRAMETIME);
+
+	int anim;
+	vec3_t	jumpVel;
+
+	switch( WP_GetVelocityForForceJump( self, jumpVel, ucmd ) )
+	{
+	case FJ_FORWARD:
+		if ( ((self->client->NPC_class == CLASS_BOBAFETT||self->client->NPC_class == CLASS_ROCKETTROOPER) && self->client->ps.forceJumpCharge > 300 )
+			|| ( self->NPC && 
+				self->NPC->rank != RANK_CREWMAN && 
+				self->NPC->rank <= RANK_LT_JG ) )
+		{//can't do acrobatics
+			anim = BOTH_FORCEJUMP1;
+		}
+		else
+		{
+			if ( self->client->NPC_class == CLASS_ALORA && Q_irand( 0, 3 ) )
+			{
+				anim = Q_irand( BOTH_ALORA_FLIP_1, BOTH_ALORA_FLIP_3 );
+			}
+			else
+			{
+				anim = BOTH_FLIP_F;
+			}
+		}
+		break;
+	case FJ_BACKWARD:
+		if ( ((self->client->NPC_class == CLASS_BOBAFETT||self->client->NPC_class == CLASS_ROCKETTROOPER) && self->client->ps.forceJumpCharge > 300 )
+			|| ( self->NPC && 
+				self->NPC->rank != RANK_CREWMAN && 
+				self->NPC->rank <= RANK_LT_JG ) )
+		{//can't do acrobatics
+			anim = BOTH_FORCEJUMPBACK1;
+		}
+		else
+		{
+			anim = BOTH_FLIP_B;
+		}
+		break;
+	case FJ_RIGHT:
+		if ( ((self->client->NPC_class == CLASS_BOBAFETT||self->client->NPC_class == CLASS_ROCKETTROOPER) && self->client->ps.forceJumpCharge > 300 )
+			|| ( self->NPC && 
+				self->NPC->rank != RANK_CREWMAN && 
+				self->NPC->rank <= RANK_LT_JG ) )
+		{//can't do acrobatics
+			anim = BOTH_FORCEJUMPRIGHT1;
+		}
+		else
+		{
+			anim = BOTH_FLIP_R;
+		}
+		break;
+	case FJ_LEFT:
+		if ( ((self->client->NPC_class == CLASS_BOBAFETT||self->client->NPC_class == CLASS_ROCKETTROOPER) && self->client->ps.forceJumpCharge > 300 )
+			|| ( self->NPC && 
+				self->NPC->rank != RANK_CREWMAN && 
+				self->NPC->rank <= RANK_LT_JG ) )
+		{//can't do acrobatics
+			anim = BOTH_FORCEJUMPLEFT1;
+		}
+		else
+		{
+			anim = BOTH_FLIP_L;
+		}
+		break;
+	default:
+	case FJ_UP:
+		anim = BOTH_JUMP1;
+		break;
+	}
+
+	int	parts = SETANIM_BOTH;
+	if ( self->client->ps.weaponTime )
+	{//FIXME: really only care if we're in a saber attack anim.. maybe trail length?
+		parts = SETANIM_LEGS;
+	}
+
+	NPC_SetAnim( self, parts, anim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+
+	//FIXME: sound effect
+	self->client->ps.forceJumpZStart = self->currentOrigin[2];//remember this for when we land
+	VectorCopy( jumpVel, self->client->ps.velocity );
+	//wasn't allowing them to attack when jumping, but that was annoying
+	//self->client->ps.weaponTime = self->client->ps.torsoAnimTimer;
+
+	WP_ForcePowerStart( self, FP_LEVITATION, self->client->ps.forceJumpCharge/forceJumpChargeInterval/(FORCE_JUMP_CHARGE_TIME/FRAMETIME)*forcePowerNeeded[FP_LEVITATION] );
+	//self->client->ps.forcePowerDuration[FP_LEVITATION] = level.time + self->client->ps.weaponTime;
+	self->client->ps.forceJumpCharge = 0;
+}
+
+int WP_AbsorbConversion(gentity_t *attacked, int atdAbsLevel, gentity_t *attacker, int atPower, int atPowerLevel, int atForceSpent)
+{
+	int getLevel = 0;
+	int addTot = 0;
+
+	if (atPower != FP_LIGHTNING &&
+		atPower != FP_DRAIN &&
+		atPower != FP_GRIP &&
+		atPower != FP_PUSH &&
+		atPower != FP_PULL)
+	{ //Only these powers can be absorbed
+		return -1;
+	}
+
+	if (!atdAbsLevel)
+	{ //looks like attacker doesn't have any absorb power
+		return -1;
+	}
+
+	if (!(attacked->client->ps.forcePowersActive & (1 << FP_ABSORB)))
+	{ //absorb is not active
+		return -1;
+	}
+
+	//Subtract absorb power level from the offensive force power
+	getLevel = atPowerLevel;
+	getLevel -= atdAbsLevel;
+
+	if (getLevel < 0)
+	{
+		getLevel = 0;
+	}
+
+	//let the attacker absorb an amount of force used in this attack based on his level of absorb
+	addTot = (atForceSpent/3)*attacked->client->ps.forcePowerLevel[FP_ABSORB];
+
+	if (addTot < 1 && atForceSpent >= 1)
+	{
+		addTot = 1;
+	}
+	attacked->client->ps.forcePower += addTot;
+	if (attacked->client->ps.forcePower > 100)
+	{
+		attacked->client->ps.forcePower = 100;
+	}
+
+	G_SoundOnEnt( attacked, CHAN_ITEM, "sound/weapons/force/absorbhit.wav" );
+
+	return getLevel;
+}
+
+void WP_ForcePowerRegenerate( gentity_t *self, int overrideAmt )
+{
+	if ( !self->client )
+	{
+		return;
+	}
+
+	if ( self->client->ps.forcePower < self->client->ps.forcePowerMax )
+	{
+		if ( overrideAmt )
+		{
+			self->client->ps.forcePower += overrideAmt;
+		}
+		else
+		{
+			self->client->ps.forcePower++;
+		}
+		if ( self->client->ps.forcePower > self->client->ps.forcePowerMax )
+		{
+			self->client->ps.forcePower = self->client->ps.forcePowerMax;
+		}
+	}
+}
+
+void WP_ForcePowerDrain( gentity_t *self, forcePowers_t forcePower, int overrideAmt )
+{
+	if ( self->NPC )
+	{//For now, NPCs have infinite force power
+		return;
+	}
+	//take away the power
+	int	drain = overrideAmt;
+	if ( !drain )
+	{
+		drain = forcePowerNeeded[forcePower];
+	}
+	if ( !drain )
+	{
+		return;
+	}
+	self->client->ps.forcePower -= drain;
+	if ( self->client->ps.forcePower < 0 )
+	{
+		self->client->ps.forcePower = 0;
+	}
+}
+
+void WP_ForcePowerStart( gentity_t *self, forcePowers_t forcePower, int overrideAmt )
+{
+	int	duration = 0;
+
+	//FIXME: debounce some of these?
+	self->client->ps.forcePowerDebounce[forcePower] = 0;
+
+	//and it in
+	//set up duration time
+	switch( (int)forcePower )
+	{
+	case FP_HEAL:
+		self->client->ps.forcePowersActive |= ( 1 << forcePower );
+		self->client->ps.forceHealCount = 0;
+		WP_StartForceHealEffects( self );
+		break;
+	case FP_LEVITATION:
+		self->client->ps.forcePowersActive |= ( 1 << forcePower );
+		break;
+	case FP_SPEED:
+		//duration is always 5 seconds, player time
+		duration = ceil(FORCE_SPEED_DURATION*forceSpeedValue[self->client->ps.forcePowerLevel[FP_SPEED]]);//FIXME: because the timescale scales down (not instant), this doesn't end up being exactly right...
+		self->client->ps.forcePowersActive |= ( 1 << forcePower );
+		self->s.loopSound = G_SoundIndex( "sound/weapons/force/speedloop.wav" );
+		if ( self->client->ps.forcePowerLevel[FP_SPEED] > FORCE_LEVEL_2 )
+		{//HACK: just using this as a timestamp for when the power started, setting debounce to current time shouldn't adversely affect anything else
+			self->client->ps.forcePowerDebounce[FP_SPEED] = level.time;
+		}
+		break;
+	case FP_PUSH:
+		break;
+	case FP_PULL:
+		self->client->ps.forcePowersActive |= ( 1 << forcePower );
+		break;
+	case FP_TELEPATHY:
+		break;
+	case FP_GRIP:
+		duration = 1000;
+		self->client->ps.forcePowersActive |= ( 1 << forcePower );
+		//HACK: just using this as a timestamp for when the power started, setting debounce to current time shouldn't adversely affect anything else
+		//self->client->ps.forcePowerDebounce[forcePower] = level.time;
+		break;
+	case FP_LIGHTNING:
+		duration = overrideAmt;
+		overrideAmt = 0;
+		self->client->ps.forcePowersActive |= ( 1 << forcePower );
+		break;
+	//new Jedi Academy force powers
+	case FP_RAGE:
+		//duration is always 5 seconds, player time
+		duration = ceil(FORCE_RAGE_DURATION*forceSpeedValue[self->client->ps.forcePowerLevel[FP_RAGE]-1]);//FIXME: because the timescale scales down (not instant), this doesn't end up being exactly right...
+		self->client->ps.forcePowersActive |= ( 1 << forcePower );
+		G_SoundOnEnt( self, CHAN_ITEM, "sound/weapons/force/rage.mp3" );
+		self->s.loopSound = G_SoundIndex( "sound/weapons/force/rageloop.wav" );
+		if ( self->chestBolt != -1 )
+		{
+			G_PlayEffect( G_EffectIndex( "force/rage2" ), self->playerModel, self->chestBolt, self->s.number, self->currentOrigin, duration, qtrue );
+		}
+		break;
+	case FP_DRAIN:
+		if ( self->client->ps.forcePowerLevel[forcePower] > FORCE_LEVEL_1 
+			&& self->client->ps.forceDrainEntityNum >= ENTITYNUM_WORLD )
+		{
+			duration = overrideAmt;
+			overrideAmt = 0;
+			//HACK: just using this as a timestamp for when the power started, setting debounce to current time shouldn't adversely affect anything else
+			self->client->ps.forcePowerDebounce[forcePower] = level.time;
+		}
+		else
+		{
+			duration = 1000;
+		}
+		self->client->ps.forcePowersActive |= ( 1 << forcePower );
+		break;
+	case FP_PROTECT:
+		switch ( self->client->ps.forcePowerLevel[FP_PROTECT] )
+		{
+		case FORCE_LEVEL_3:
+			duration = 20000;
+			break;
+		case FORCE_LEVEL_2:
+			duration = 15000;
+			break;
+		case FORCE_LEVEL_1:
+		default:
+
+			duration = 10000;
+			break;
+		}
+		self->client->ps.forcePowersActive |= ( 1 << forcePower );
+		G_SoundOnEnt( self, CHAN_ITEM, "sound/weapons/force/protect.mp3" );
+		self->s.loopSound = G_SoundIndex( "sound/weapons/force/protectloop.wav" );
+		break;
+	case FP_ABSORB:
+		duration = 20000;
+		self->client->ps.forcePowersActive |= ( 1 << forcePower );
+		G_SoundOnEnt( self, CHAN_ITEM, "sound/weapons/force/absorb.mp3" );
+		self->s.loopSound = G_SoundIndex( "sound/weapons/force/absorbloop.wav" );
+		break;
+	case FP_SEE:
+		if ( self->client->ps.forcePowerLevel[FP_SEE] == FORCE_LEVEL_1 )
+		{
+			duration = 5000;
+		}
+		else if ( self->client->ps.forcePowerLevel[FP_SEE] == FORCE_LEVEL_2 )
+		{
+			duration = 10000;
+		}
+		else// if ( self->client->ps.forcePowerLevel[FP_SEE] == FORCE_LEVEL_3 )
+		{
+			duration = 20000;
+		}
+
+		self->client->ps.forcePowersActive |= ( 1 << forcePower );
+		G_SoundOnEnt( self, CHAN_ITEM, "sound/weapons/force/see.mp3" );
+		self->s.loopSound = G_SoundIndex( "sound/weapons/force/seeloop.wav" );
+		break;
+	default:
+		break;
+	}
+	if ( duration )
+	{
+		self->client->ps.forcePowerDuration[forcePower] = level.time + duration;
+	}
+	else
+	{
+		self->client->ps.forcePowerDuration[forcePower] = 0;
+	}
+	
+	WP_ForcePowerDrain( self, forcePower, overrideAmt );
+
+	if ( !self->s.number )
+	{
+		self->client->sess.missionStats.forceUsed[(int)forcePower]++;
+	}
+}
+
+qboolean WP_ForcePowerAvailable( gentity_t *self, forcePowers_t forcePower, int overrideAmt )
+{
+	if ( forcePower == FP_LEVITATION )
+	{
+		return qtrue;
+	}
+	int	drain = overrideAmt?overrideAmt:forcePowerNeeded[forcePower];
+	if ( !drain )
+	{
+		return qtrue;
+	}
+	if ( self->client->ps.forcePower < drain )
+	{
+		//G_AddEvent( self, EV_NOAMMO, 0 );
+		return qfalse;
+	}
+	return qtrue;
+}
+
+extern void CG_PlayerLockedWeaponSpeech( int jumping );
+extern qboolean Rosh_TwinNearBy( gentity_t *self );
+qboolean WP_ForcePowerUsable( gentity_t *self, forcePowers_t forcePower, int overrideAmt )
+{
+	if ( !(self->client->ps.forcePowersKnown & ( 1 << forcePower )) )
+	{//don't know this power
+		return qfalse;
+	}
+	else if ( self->NPC && (self->NPC->aiFlags&NPCAI_ROSH) )
+	{
+		if ( ((1<<forcePower)&FORCE_POWERS_ROSH_FROM_TWINS) )
+		{//this is a force power we can only use when a twin is near us
+			if ( !Rosh_TwinNearBy( self ) )
+			{
+				return qfalse;
+			}
+		}
+	}
+	
+	if ( self->client->ps.forcePowerLevel[forcePower] <= 0 )
+	{//can't use this power
+		return qfalse;
+	}
+
+	if( (self->flags&FL_LOCK_PLAYER_WEAPONS) ) // yes this locked weapons check also includes force powers, if we need a separate check later I'll make one
+	{
+		if ( self->s.number < MAX_CLIENTS )
+		{
+			CG_PlayerLockedWeaponSpeech( qfalse );
+		}
+		return qfalse;
+	}
+
+	if ( in_camera && self->s.number < MAX_CLIENTS )
+	{//player can't turn on force powers duing cinematics
+		return qfalse;
+	}
+
+	if ( PM_LockedAnim( self->client->ps.torsoAnim ) && self->client->ps.torsoAnimTimer )
+	{//no force powers during these special anims
+		return qfalse;
+	}
+	if ( PM_SuperBreakLoseAnim( self->client->ps.torsoAnim ) 
+		|| PM_SuperBreakWinAnim( self->client->ps.torsoAnim ) )
+	{
+		return qfalse;
+	}
+
+	if ( (self->client->ps.forcePowersActive & ( 1 << forcePower )) )
+	{//already using this power
+		return qfalse;
+	}
+	/*
+	if ( !self->client->ps.forcePowerLevel[(int)(forcePower)] )
+	{
+		return qfalse;
+	}
+	*/
+	if ( self->client->NPC_class == CLASS_ATST )
+	{//Doh!  No force powers in an AT-ST!
+		return qfalse;
+	}
+	Vehicle_t *pVeh = NULL;
+	if ( (pVeh = G_IsRidingVehicle( self )) != NULL )
+	{//Doh!  No force powers when flying a vehicle!
+		if ( pVeh->m_pVehicleInfo->numHands > 1 )
+		{//if in a two-handed vehicle
+			return qfalse;
+		}
+	}
+	if ( self->client->ps.viewEntity > 0 && self->client->ps.viewEntity < ENTITYNUM_WORLD )
+	{//Doh!  No force powers when controlling an NPC
+		return qfalse;
+	}
+	if ( self->client->ps.eFlags & EF_LOCKED_TO_WEAPON )
+	{//Doh!  No force powers when in an emplaced gun!
+		return qfalse;
+	}
+	
+	if ( self->client->ps.saber[0].singleBladeThrowable//SaberStaff() //using staff
+		&& !self->client->ps.dualSabers //only 1, in right hand
+		&& !self->client->ps.saber[0].blade[1].active )//only first blade is on
+	{//allow power
+		//FIXME: externalize this condition seperately?
+	}
+	else
+	{
+		if ( forcePower == FP_SABERTHROW && !self->client->ps.saber[0].throwable )
+		{//cannot throw this kind of saber
+			return qfalse;
+		}
+
+		if ( self->client->ps.saber[0].Active() )
+		{
+			if ( self->client->ps.saber[0].twoHanded )
+			{
+				if ( g_saberRestrictForce->integer )
+				{
+					switch ( forcePower )
+					{
+					case FP_PUSH:
+					case FP_PULL:
+					case FP_TELEPATHY:
+					case FP_GRIP:
+					case FP_LIGHTNING:
+					case FP_DRAIN:
+						return qfalse;
+						break;
+					}
+				}
+			}
+			if ( self->client->ps.saber[0].twoHanded || (self->client->ps.dualSabers && self->client->ps.saber[1].Active()) )
+			{//this saber requires the use of two hands OR our other hand is using an active saber too
+				if ( (self->client->ps.saber[0].forceRestrictions&(1<<forcePower)) )
+				{//this power is verboten when using this saber
+					return qfalse;
+				}
+			}
+		}
+		if ( self->client->ps.dualSabers && self->client->ps.saber[1].Active() )
+		{
+			if ( g_saberRestrictForce->integer )
+			{
+				switch ( forcePower )
+				{
+				case FP_PUSH:
+				case FP_PULL:
+				case FP_TELEPATHY:
+				case FP_GRIP:
+				case FP_LIGHTNING:
+				case FP_DRAIN:
+					return qfalse;
+					break;
+				}
+			}
+			if ( (self->client->ps.saber[1].forceRestrictions&(1<<forcePower)) )
+			{//this power is verboten when using this saber
+				return qfalse;
+			}
+		}
+	}
+
+	return WP_ForcePowerAvailable( self, forcePower, overrideAmt );
+}
+
+void WP_ForcePowerStop( gentity_t *self, forcePowers_t forcePower )
+{
+	gentity_t	*gripEnt;
+	gentity_t	*drainEnt;
+
+	if ( !(self->client->ps.forcePowersActive&(1<<forcePower)) )
+	{//umm, wasn't doing it, so...
+		return;
+	}
+
+	self->client->ps.forcePowersActive &= ~( 1 << forcePower );
+
+	switch( (int)forcePower )
+	{
+	case FP_HEAL:
+		//if ( self->client->ps.forcePowerLevel[FP_HEAL] < FORCE_LEVEL_3 )
+		{//wasn't an instant heal and heal is now done
+			if ( self->client->ps.forcePowerLevel[FP_HEAL] < FORCE_LEVEL_2 )
+			{//if in meditation pose, must come out of it
+				//FIXME: BOTH_FORCEHEAL_STOP
+				if ( self->client->ps.legsAnim == BOTH_FORCEHEAL_START )
+				{
+					NPC_SetAnim( self, SETANIM_LEGS, BOTH_FORCEHEAL_STOP, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+				}
+				if ( self->client->ps.torsoAnim == BOTH_FORCEHEAL_START )
+				{
+					NPC_SetAnim( self, SETANIM_TORSO, BOTH_FORCEHEAL_STOP, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+				}
+				self->client->ps.saberMove = self->client->ps.saberBounceMove = LS_READY;//don't finish whatever saber anim you may have been in
+				self->client->ps.saberBlocked = BLOCKED_NONE;
+			}
+		}
+		WP_StopForceHealEffects( self );
+		if (self->health >= self->client->ps.stats[STAT_MAX_HEALTH]/3)
+		{
+			gi.G2API_ClearSkinGore(self->ghoul2);
+		}
+		break;
+	case FP_LEVITATION:
+		self->client->ps.forcePowerDebounce[FP_LEVITATION] = 0;
+		break;
+	case FP_SPEED:
+		if ( !self->s.number )
+		{//player using force speed
+			if ( g_timescale->value != 1.0 )
+			{
+				if ( !(self->client->ps.forcePowersActive&(1<<FP_RAGE))||self->client->ps.forcePowerLevel[FP_RAGE] < FORCE_LEVEL_2 )
+				{//not slowed down because of force rage
+					gi.cvar_set("timescale", "1");
+				}
+			}
+		}
+		//FIXME: reset my current anim, keeping current frame, but with proper anim speed
+		//		otherwise, the anim will continue playing at high speed
+		self->s.loopSound = 0;
+		break;
+	case FP_PUSH:
+		break;
+	case FP_PULL:
+		break;
+	case FP_TELEPATHY:
+		break;
+	case FP_GRIP:
+		if ( self->NPC )
+		{
+			TIMER_Set( self, "gripping", -level.time );
+		}
+		if ( self->client->ps.forceGripEntityNum < ENTITYNUM_WORLD )
+		{
+			gripEnt = &g_entities[self->client->ps.forceGripEntityNum];
+			if ( gripEnt )
+			{
+				gripEnt->s.loopSound = 0;
+				if ( gripEnt->client )
+				{
+					gripEnt->client->ps.eFlags &= ~EF_FORCE_GRIPPED;
+					if ( self->client->ps.forcePowerLevel[FP_GRIP] > FORCE_LEVEL_1 )
+					{//sanity-cap the velocity
+						float gripVel = VectorNormalize( gripEnt->client->ps.velocity );
+						if ( gripVel > 500.0f )
+						{
+							gripVel = 500.0f;
+						}
+						VectorScale( gripEnt->client->ps.velocity, gripVel, gripEnt->client->ps.velocity );
+					}
+
+					//FIXME: they probably dropped their weapon, should we make them flee?  Or should AI handle no-weapon behavior?
+//rww - RAGDOLL_BEGIN
+#ifndef JK2_RAGDOLL_GRIPNOHEALTH
+//rww - RAGDOLL_END
+					if ( gripEnt->health > 0 )
+//rww - RAGDOLL_BEGIN
+#endif
+//rww - RAGDOLL_END
+					{
+						int	holdTime = 500;
+						if ( gripEnt->health > 0 )
+						{
+							G_AddEvent( gripEnt, EV_WATER_CLEAR, 0 );
+						}
+						if ( gripEnt->client->ps.forcePowerDebounce[FP_PUSH] > level.time )
+						{//they probably pushed out of it
+							holdTime = 0;
+						}
+						else if ( gripEnt->s.weapon == WP_SABER )
+						{//jedi recover faster
+							holdTime = self->client->ps.forcePowerLevel[FP_GRIP]*200;
+						}
+						else
+						{
+							holdTime = self->client->ps.forcePowerLevel[FP_GRIP]*500;
+						}
+						//stop the anims soon, keep them locked in place for a bit
+						if ( gripEnt->client->ps.torsoAnim == BOTH_CHOKE1 || gripEnt->client->ps.torsoAnim == BOTH_CHOKE3 )
+						{//stop choking anim on torso
+							if ( gripEnt->client->ps.torsoAnimTimer > holdTime )
+							{
+								gripEnt->client->ps.torsoAnimTimer = holdTime;
+							}
+						}
+						if ( gripEnt->client->ps.legsAnim == BOTH_CHOKE1 || gripEnt->client->ps.legsAnim == BOTH_CHOKE3 )
+						{//stop choking anim on legs
+							gripEnt->client->ps.legsAnimTimer = 0;
+							if ( holdTime )
+							{
+								//lock them in place for a bit
+								gripEnt->client->ps.pm_time = gripEnt->client->ps.torsoAnimTimer;
+								gripEnt->client->ps.pm_flags |= PMF_TIME_KNOCKBACK;
+								if ( gripEnt->s.number )
+								{//NPC
+									gripEnt->painDebounceTime = level.time + gripEnt->client->ps.torsoAnimTimer;
+								}
+								else
+								{//player
+									gripEnt->aimDebounceTime = level.time + gripEnt->client->ps.torsoAnimTimer;
+								}
+							}
+						}
+						if ( gripEnt->NPC )
+						{
+							if ( !(gripEnt->NPC->aiFlags&NPCAI_DIE_ON_IMPACT) )
+							{//not falling to their death
+								gripEnt->NPC->nextBStateThink = level.time + holdTime;
+							}
+							//if still alive after stopped gripping, let them wake others up
+							if ( gripEnt->health > 0 )
+							{
+								G_AngerAlert( gripEnt );
+							}
+						}
+					}
+				}
+				else
+				{
+					gripEnt->s.eFlags &= ~EF_FORCE_GRIPPED;
+					if ( gripEnt->s.eType == ET_MISSILE )
+					{//continue normal movement
+						if ( gripEnt->s.weapon == WP_THERMAL )
+						{
+							gripEnt->s.pos.trType = TR_INTERPOLATE;
+						}
+						else
+						{
+							gripEnt->s.pos.trType = TR_LINEAR;//FIXME: what about gravity-effected projectiles?
+						}
+						VectorCopy( gripEnt->currentOrigin, gripEnt->s.pos.trBase );
+						gripEnt->s.pos.trTime = level.time;
+					}
+					else
+					{//drop it
+						gripEnt->e_ThinkFunc = thinkF_G_RunObject;
+						gripEnt->nextthink = level.time + FRAMETIME;
+						gripEnt->s.pos.trType = TR_GRAVITY;
+						VectorCopy( gripEnt->currentOrigin, gripEnt->s.pos.trBase );
+						gripEnt->s.pos.trTime = level.time;
+					}
+				}
+			}
+			self->s.loopSound = 0;
+			self->client->ps.forceGripEntityNum = ENTITYNUM_NONE;
+		}
+		if ( self->client->ps.torsoAnim == BOTH_FORCEGRIP_HOLD )
+		{
+			NPC_SetAnim( self, SETANIM_BOTH, BOTH_FORCEGRIP_RELEASE, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+		}
+		break;
+	case FP_LIGHTNING:
+		if ( self->NPC )
+		{
+			TIMER_Set( self, "holdLightning", -level.time );
+		}
+		if ( self->client->ps.torsoAnim == BOTH_FORCELIGHTNING_HOLD 
+			|| self->client->ps.torsoAnim == BOTH_FORCELIGHTNING_START )
+		{
+			NPC_SetAnim( self, SETANIM_TORSO, BOTH_FORCELIGHTNING_RELEASE, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+		}
+		else if ( self->client->ps.torsoAnim == BOTH_FORCE_2HANDEDLIGHTNING_HOLD 
+			|| self->client->ps.torsoAnim == BOTH_FORCE_2HANDEDLIGHTNING_START )
+		{
+			NPC_SetAnim( self, SETANIM_TORSO, BOTH_FORCE_2HANDEDLIGHTNING_RELEASE, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+		}
+		if ( self->client->ps.forcePowerLevel[FP_LIGHTNING] < FORCE_LEVEL_2 )
+		{//don't do it again for 3 seconds, minimum... FIXME: this should be automatic once regeneration is slower (normal)
+			self->client->ps.forcePowerDebounce[FP_LIGHTNING] = level.time + 3000;//FIXME: define?
+		}
+		else
+		{//stop the looping sound
+			self->client->ps.forcePowerDebounce[FP_LIGHTNING] = level.time + 1000;//FIXME: define?
+			self->s.loopSound = 0;
+		}
+		break;
+	case FP_RAGE:
+		self->client->ps.forceRageRecoveryTime = level.time + 10000;//recover for 10 seconds 
+		if ( self->client->ps.forcePowerDuration[FP_RAGE] > level.time )
+		{//still had time left, we cut it short
+			self->client->ps.forceRageRecoveryTime -= (self->client->ps.forcePowerDuration[FP_RAGE] - level.time);//minus however much time you had left when you cut it short
+		}
+		if ( !self->s.number )
+		{//player using force speed
+			if ( g_timescale->value != 1.0 )
+			{
+				if ( !(self->client->ps.forcePowersActive&(1<<FP_SPEED)) )
+				{//not slowed down because of force speed
+					gi.cvar_set("timescale", "1");
+				}
+			}
+		}
+		//FIXME: reset my current anim, keeping current frame, but with proper anim speed
+		//		otherwise, the anim will continue playing at high speed
+		self->s.loopSound = 0;
+		if ( self->NPC )
+		{
+			Jedi_RageStop( self );
+		}
+		if ( self->chestBolt != -1 )
+		{
+			G_StopEffect("force/rage2", self->playerModel, self->chestBolt, self->s.number );
+		}
+		break;
+	case FP_DRAIN:
+		if ( self->NPC )
+		{
+			TIMER_Set( self, "draining", -level.time );
+		}
+		if ( self->client->ps.forcePowerLevel[FP_DRAIN] < FORCE_LEVEL_2 )
+		{//don't do it again for 3 seconds, minimum... FIXME: this should be automatic once regeneration is slower (normal)
+			self->client->ps.forcePowerDebounce[FP_DRAIN] = level.time + 3000;//FIXME: define?
+		}
+		else
+		{//stop the looping sound
+			self->client->ps.forcePowerDebounce[FP_DRAIN] = level.time + 1000;//FIXME: define?
+			self->s.loopSound = 0;
+		}
+		//drop them
+		if ( self->client->ps.forceDrainEntityNum < ENTITYNUM_WORLD )
+		{
+			drainEnt = &g_entities[self->client->ps.forceDrainEntityNum];
+			if ( drainEnt )
+			{
+				if ( drainEnt->client )
+				{
+					drainEnt->client->ps.eFlags &= ~EF_FORCE_DRAINED;
+					//VectorClear( drainEnt->client->ps.velocity );
+					if ( drainEnt->health > 0 )
+					{
+						if ( drainEnt->client->ps.forcePowerDebounce[FP_PUSH] > level.time )
+						{//they probably pushed out of it 
+						}
+						else
+						{
+							//NPC_SetAnim( drainEnt, SETANIM_BOTH, BOTH_HUGGEESTOP1, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+							if ( drainEnt->client->ps.torsoAnim != BOTH_FORCEPUSH )
+							{//don't stop the push
+								drainEnt->client->ps.torsoAnimTimer = 0;
+							}
+							drainEnt->client->ps.legsAnimTimer = 0;
+						}
+						if ( drainEnt->NPC )
+						{//if still alive after stopped draining, let them wake others up
+							G_AngerAlert( drainEnt );
+						}
+					}
+					else
+					{//leave the effect playing on them for a few seconds
+						//drainEnt->client->ps.eFlags |= EF_FORCE_DRAINED;
+						drainEnt->s.powerups |= ( 1 << PW_DRAINED );
+						drainEnt->client->ps.powerups[PW_DRAINED] = level.time + Q_irand( 1000, 4000 );
+					}
+				}
+			}
+			self->client->ps.forceDrainEntityNum = ENTITYNUM_NONE;
+		}
+		if ( self->client->ps.torsoAnim == BOTH_HUGGER1 )
+		{//old anim
+			NPC_SetAnim( self, SETANIM_BOTH, BOTH_HUGGERSTOP1, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+		}
+		else if ( self->client->ps.torsoAnim == BOTH_FORCE_DRAIN_GRAB_START
+			|| self->client->ps.torsoAnim ==  BOTH_FORCE_DRAIN_GRAB_HOLD )
+		{//new anim
+			NPC_SetAnim( self, SETANIM_BOTH, BOTH_FORCE_DRAIN_GRAB_END, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+		}
+		else if ( self->client->ps.torsoAnim == BOTH_FORCE_DRAIN_HOLD 
+			|| self->client->ps.torsoAnim == BOTH_FORCE_DRAIN_START )
+		{
+			NPC_SetAnim( self, SETANIM_TORSO, BOTH_FORCE_DRAIN_RELEASE, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+		}
+		break;
+	case FP_PROTECT:
+		self->s.loopSound = 0;
+		break;
+	case FP_ABSORB:
+		self->s.loopSound = 0;
+		if ( self->client->ps.legsAnim == BOTH_FORCE_ABSORB_START )
+		{
+			NPC_SetAnim( self, SETANIM_LEGS, BOTH_FORCE_ABSORB_END, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+		}
+		if ( self->client->ps.torsoAnim == BOTH_FORCE_ABSORB_START )
+		{
+			NPC_SetAnim( self, SETANIM_TORSO, BOTH_FORCE_ABSORB_END, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+		}
+		if ( self->client->ps.forcePowerLevel[FP_ABSORB] < FORCE_LEVEL_2 )
+		{//was stuck, free us in case we interrupted it or something
+			self->client->ps.weaponTime = 0;
+			self->client->ps.pm_flags &= ~PMF_TIME_KNOCKBACK;
+			self->client->ps.pm_time = 0;
+			if ( self->s.number )
+			{//NPC
+				self->painDebounceTime = 0;
+			}
+			else
+			{//player
+				self->aimDebounceTime = 0;
+			}
+		}
+		break;
+	case FP_SEE:
+		self->s.loopSound = 0;
+		break;
+	default:
+		break;
+	}
+}
+
+void WP_ForceForceThrow( gentity_t *thrower )
+{
+	if ( !thrower || !thrower->client )
+	{
+		return;
+	}
+	qboolean removePush = qfalse;
+	qboolean relock = qfalse;
+	if ( !(thrower->client->ps.forcePowersKnown&(1<<FP_PUSH)) )
+	{//give them push just for this specific purpose
+		thrower->client->ps.forcePowersKnown |= (1<<FP_PUSH);
+		thrower->client->ps.forcePowerLevel[FP_PUSH] = FORCE_LEVEL_1;
+		removePush = qtrue;
+	}
+
+	if ( thrower->NPC
+		&& (thrower->NPC->aiFlags&NPCAI_HEAL_ROSH)
+		&& (thrower->flags&FL_LOCK_PLAYER_WEAPONS) )
+	{
+		thrower->flags &= ~FL_LOCK_PLAYER_WEAPONS;
+		relock = qtrue;
+	}
+ 
+	ForceThrow( thrower, qfalse );
+
+	if ( relock )
+	{
+		thrower->flags |= FL_LOCK_PLAYER_WEAPONS;
+	}
+
+	if ( thrower )
+	{//take it back off
+		thrower->client->ps.forcePowersKnown &= ~(1<<FP_PUSH);
+		thrower->client->ps.forcePowerLevel[FP_PUSH] = FORCE_LEVEL_0;
+	}
+}
+
+extern qboolean PM_ForceJumpingUp( gentity_t *gent );
+static void WP_ForcePowerRun( gentity_t *self, forcePowers_t forcePower, usercmd_t *cmd )
+{
+	float				speed, newSpeed;
+	gentity_t			*gripEnt, *drainEnt;
+	vec3_t				angles, dir, gripOrg, gripEntOrg;
+	float				dist;
+	extern usercmd_t	ucmd;
+
+	switch( (int)forcePower )
+	{
+	case FP_HEAL:
+		if ( self->client->ps.forceHealCount >= FP_MaxForceHeal(self) || self->health >= self->client->ps.stats[STAT_MAX_HEALTH] )
+		{//fully healed or used up all 25
+			if ( !Q3_TaskIDPending( self, TID_CHAN_VOICE ) )
+			{
+				int index = Q_irand( 1, 4 );
+				if ( self->s.number < MAX_CLIENTS )
+				{
+					G_SoundOnEnt( self, CHAN_VOICE, va( "sound/weapons/force/heal%d_%c.mp3", index, g_sex->string[0] ) );
+				}
+				else if ( self->NPC )
+				{
+					if ( self->NPC->blockedSpeechDebounceTime <= level.time )
+					{//enough time has passed since our last speech
+						if ( Q3_TaskIDPending( self, TID_CHAN_VOICE ) )
+						{//not playing a scripted line
+							//say "Ahhh...."
+							if ( self->NPC->stats.sex == SEX_MALE 
+								|| self->NPC->stats.sex == SEX_NEUTRAL )
+							{
+								G_SoundOnEnt( self, CHAN_VOICE, va( "sound/weapons/force/heal%d_m.mp3", index ) );
+							}
+							else//all other sexes use female sounds
+							{
+								G_SoundOnEnt( self, CHAN_VOICE, va( "sound/weapons/force/heal%d_f.mp3", index ) );
+							}
+						}
+					}
+				}
+#ifdef _IMMERSION
+				G_Force( self, G_ForceIndex( va( "fffx/weapons/force/heal%d", index ), FF_CHANNEL_WEAPON ) );
+#endif // _IMMERSION
+			}
+			WP_ForcePowerStop( self, forcePower );
+		}
+		else if ( self->client->ps.forcePowerLevel[FP_HEAL] < FORCE_LEVEL_3 && ( (cmd->buttons&BUTTON_ATTACK) || (cmd->buttons&BUTTON_ALT_ATTACK) || self->painDebounceTime > level.time || (self->client->ps.weaponTime&&self->client->ps.weapon!=WP_NONE) ) )
+		{//attacked or was hit while healing...
+			//stop healing
+			WP_ForcePowerStop( self, forcePower );
+		}
+		else if ( self->client->ps.forcePowerLevel[FP_HEAL] < FORCE_LEVEL_2 && ( cmd->rightmove || cmd->forwardmove || cmd->upmove > 0 ) )
+		{//moved while healing... FIXME: also, in WP_ForcePowerStart, stop healing if any other force power is used
+			//stop healing
+			WP_ForcePowerStop( self, forcePower );
+		}
+		else if ( self->client->ps.forcePowerDebounce[FP_HEAL] < level.time )
+		{//time to heal again
+			if ( WP_ForcePowerAvailable( self, forcePower, 4 ) )
+			{//have available power
+				int healInterval = FP_ForceHealInterval( self );
+				int	healAmount = 1;//hard, normal healing rate
+				if ( self->s.number < MAX_CLIENTS )
+				{
+					if ( g_spskill->integer == 1 )
+					{//medium, heal twice as fast
+						healAmount *= 2;
+					}
+					else if ( g_spskill->integer == 0 )
+					{//easy, heal 3 times as fast...
+						healAmount *= 3;
+					}
+				}
+				if ( self->health + healAmount > self->client->ps.stats[STAT_MAX_HEALTH] )
+				{
+					healAmount = self->client->ps.stats[STAT_MAX_HEALTH] - self->health;
+				}
+				self->health += healAmount;
+				self->client->ps.forceHealCount += healAmount;
+				self->client->ps.forcePowerDebounce[FP_HEAL] = level.time + healInterval;
+				WP_ForcePowerDrain( self, forcePower, 4 );
+			}
+			else
+			{//stop
+				WP_ForcePowerStop( self, forcePower );
+			}
+		}
+		break;
+	case FP_LEVITATION:
+		if ( self->client->ps.groundEntityNum != ENTITYNUM_NONE && !self->client->ps.forceJumpZStart )
+		{//done with jump
+			WP_ForcePowerStop( self, forcePower );
+		}
+		else
+		{
+			if ( PM_ForceJumpingUp( self ) )
+			{//holding jump in air
+				if ( cmd->upmove > 10 )
+				{//still trying to go up
+					if ( WP_ForcePowerAvailable( self, FP_LEVITATION, 1 ) )
+					{
+						if ( self->client->ps.forcePowerDebounce[FP_LEVITATION] < level.time )
+						{
+							WP_ForcePowerDrain( self, FP_LEVITATION, 5 );
+							self->client->ps.forcePowerDebounce[FP_LEVITATION] = level.time + 100;
+						}
+						self->client->ps.forcePowersActive |= ( 1 << FP_LEVITATION );
+						self->client->ps.forceJumpCharge = 1;//just used as a flag for the player, cleared when he lands
+					}
+					else
+					{//cut the jump short
+						WP_ForcePowerStop( self, forcePower );
+					}
+				}
+				else
+				{//cut the jump short
+					WP_ForcePowerStop( self, forcePower );
+				}
+			}
+			else
+			{
+				WP_ForcePowerStop( self, forcePower );
+			}
+		}
+		break;
+	case FP_SPEED:
+		speed = forceSpeedValue[self->client->ps.forcePowerLevel[FP_SPEED]];
+		if ( !self->s.number )
+		{//player using force speed
+			if ( !(self->client->ps.forcePowersActive&(1<<FP_RAGE))
+				|| self->client->ps.forcePowerLevel[FP_SPEED] >= self->client->ps.forcePowerLevel[FP_RAGE] )
+			{//either not using rage or rage is at a lower level than speed
+				gi.cvar_set("timescale", va("%4.2f", speed));
+				if ( g_timescale->value > speed )
+				{
+					newSpeed = g_timescale->value - 0.05;
+					if ( newSpeed < speed )
+					{
+						newSpeed = speed;
+					}
+					gi.cvar_set("timescale", va("%4.2f", newSpeed));
+				}
+			}
+		}
+		break;
+	case FP_PUSH:
+		break;
+	case FP_PULL:
+		break;
+	case FP_TELEPATHY:
+		break;
+	case FP_GRIP:
+		if ( !WP_ForcePowerAvailable( self, FP_GRIP, 0 ) 
+			|| (self->client->ps.forcePowerLevel[FP_GRIP]>FORCE_LEVEL_1&&!self->s.number&&!(cmd->buttons&BUTTON_FORCEGRIP)) )
+		{
+			WP_ForcePowerStop( self, FP_GRIP );
+			return;
+		}
+		else if ( self->client->ps.forceGripEntityNum >= 0 && self->client->ps.forceGripEntityNum < ENTITYNUM_WORLD )
+		{
+			gripEnt = &g_entities[self->client->ps.forceGripEntityNum];
+
+			if ( !gripEnt || !gripEnt->inuse )
+			{//invalid or freed ent
+				WP_ForcePowerStop( self, FP_GRIP );
+				return;
+			}
+			else 
+//rww - RAGDOLL_BEGIN
+#ifndef JK2_RAGDOLL_GRIPNOHEALTH
+//rww - RAGDOLL_END
+			if ( gripEnt->health <= 0 && gripEnt->takedamage )//FIXME: what about things that never had health or lose takedamage when they die?
+			{//either invalid ent, or dead ent
+				WP_ForcePowerStop( self, FP_GRIP );
+				return;
+			}
+			else 
+//rww - RAGDOLL_BEGIN
+#endif
+//rww - RAGDOLL_END
+			if ( self->client->ps.forcePowerLevel[FP_GRIP] == FORCE_LEVEL_1 
+				&& gripEnt->client
+				&& gripEnt->client->ps.groundEntityNum == ENTITYNUM_NONE 
+				&& gripEnt->client->moveType != MT_FLYSWIM )
+			{
+				WP_ForcePowerStop( self, FP_GRIP );
+				return;
+			}
+			else if ( gripEnt->client && gripEnt->client->moveType == MT_FLYSWIM && VectorLengthSquared( gripEnt->client->ps.velocity ) > (300*300) )
+			{//flying creature broke free
+				WP_ForcePowerStop( self, FP_GRIP );
+				return;
+			}
+			else if ( gripEnt->client 
+				&& gripEnt->health>0	//dead dudes don't fly
+				&& (gripEnt->client->NPC_class == CLASS_BOBAFETT || gripEnt->client->NPC_class == CLASS_ROCKETTROOPER)
+				&& self->client->ps.forcePowerDebounce[FP_GRIP] < level.time
+				&& !Q_irand( 0, 3 )
+				)
+			{//boba fett - fly away!
+				gripEnt->client->ps.forceJumpCharge = 0;//so we don't play the force flip anim
+				gripEnt->client->ps.velocity[2] = 250;
+				gripEnt->client->ps.forceJumpZStart = gripEnt->currentOrigin[2];//so we don't take damage if we land at same height
+				gripEnt->client->ps.pm_flags |= PMF_JUMPING;
+				G_AddEvent( gripEnt, EV_JUMP, 0 );
+				JET_FlyStart( gripEnt );
+				WP_ForcePowerStop( self, FP_GRIP );
+				return;
+			}
+			else if ( gripEnt->NPC 
+				&& gripEnt->client 
+				&& gripEnt->client->ps.forcePowersKnown 
+				&& (gripEnt->client->NPC_class==CLASS_REBORN||gripEnt->client->ps.weapon==WP_SABER)
+				&& !Jedi_CultistDestroyer(gripEnt)
+				&& !Q_irand( 0, 100-(gripEnt->NPC->stats.evasion*8)-(g_spskill->integer*20) ) ) 
+			{//a jedi who broke free FIXME: maybe have some minimum grip length- a reaction time?
+				WP_ForceForceThrow( gripEnt );
+				//FIXME: I need to go into some pushed back anim...
+				WP_ForcePowerStop( self, FP_GRIP );
+				return;
+			}
+			else if ( PM_SaberInAttack( self->client->ps.saberMove )
+				|| PM_SaberInStart( self->client->ps.saberMove ) )
+			{//started an attack
+				WP_ForcePowerStop( self, FP_GRIP );
+				return;
+			}
+			else
+			{
+				int gripLevel = self->client->ps.forcePowerLevel[FP_GRIP];
+				if ( gripEnt->client )
+				{
+					gripLevel = WP_AbsorbConversion( gripEnt, gripEnt->client->ps.forcePowerLevel[FP_ABSORB], self, FP_GRIP, self->client->ps.forcePowerLevel[FP_GRIP], forcePowerNeeded[gripLevel] );
+				}
+				if ( !gripLevel )
+				{
+					WP_ForcePowerStop( self, forcePower );
+					return;
+				}
+
+				if ( self->client->ps.forcePowerLevel[FP_GRIP] > FORCE_LEVEL_1 )
+				{//holding it
+					NPC_SetAnim( self, SETANIM_TORSO, BOTH_FORCEGRIP_HOLD, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+					if ( self->client->ps.torsoAnimTimer < 100 ){//we were already playing this anim, we didn't want to restart it, but we want to hold it for at least 100ms, sooo....
+					
+						self->client->ps.torsoAnimTimer = 100;
+					}
+				}
+				//get their org
+				VectorCopy( self->client->ps.viewangles, angles );
+				angles[0] -= 10;
+				AngleVectors( angles, dir, NULL, NULL );
+				if ( gripEnt->client )
+				{//move
+					VectorCopy( gripEnt->client->renderInfo.headPoint, gripEntOrg );
+				}
+				else
+				{
+					VectorCopy( gripEnt->currentOrigin, gripEntOrg );
+				}
+
+				//how far are they
+				dist = Distance( self->client->renderInfo.handLPoint, gripEntOrg );
+				if ( self->client->ps.forcePowerLevel[FP_GRIP] == FORCE_LEVEL_2 &&
+					(!InFront( gripEntOrg, self->client->renderInfo.handLPoint, self->client->ps.viewangles, 0.3f ) ||
+						DistanceSquared( gripEntOrg, self->client->renderInfo.handLPoint ) > FORCE_GRIP_DIST_SQUARED))
+				{//must face them
+					WP_ForcePowerStop( self, FP_GRIP );
+					return;
+				}
+
+				//check for lift or carry
+				if ( self->client->ps.forcePowerLevel[FP_GRIP] > FORCE_LEVEL_2 
+					&& (!gripEnt->client || (!gripEnt->message&&!(gripEnt->flags&FL_NO_KNOCKBACK))) )
+				{//carry
+					//cap dist
+					if ( dist > FORCE_GRIP_3_MAX_DIST )
+					{
+						dist = FORCE_GRIP_3_MAX_DIST;
+					}
+					else if ( dist < FORCE_GRIP_3_MIN_DIST )
+					{
+						dist = FORCE_GRIP_3_MIN_DIST;
+					}
+					VectorMA( self->client->renderInfo.handLPoint, dist, dir, gripOrg );
+				}
+				else if ( self->client->ps.forcePowerLevel[FP_GRIP] > FORCE_LEVEL_1 )
+				{//just lift
+					VectorCopy( self->client->ps.forceGripOrg, gripOrg );
+				}
+				else
+				{
+					VectorCopy( gripEnt->currentOrigin, gripOrg );
+				}
+				if ( self->client->ps.forcePowerLevel[FP_GRIP] > FORCE_LEVEL_1 )
+				{//if holding him, make sure there's a clear LOS between my hand and him
+					trace_t gripTrace;
+					gi.trace( &gripTrace, self->client->renderInfo.handLPoint, NULL, NULL, gripEntOrg, ENTITYNUM_NONE, MASK_FORCE_PUSH );
+					if ( gripTrace.startsolid
+						|| gripTrace.startsolid
+						|| gripTrace.fraction < 1.0f )
+					{//no clear trace, drop them
+						WP_ForcePowerStop( self, FP_GRIP );
+						return;
+					}
+				}
+				//now move them
+				if ( gripEnt->client )
+				{
+					if ( self->client->ps.forcePowerLevel[FP_GRIP] > FORCE_LEVEL_1 )
+					{//level 1 just holds them
+ 						VectorSubtract( gripOrg, gripEntOrg, gripEnt->client->ps.velocity );
+						if ( self->client->ps.forcePowerLevel[FP_GRIP] > FORCE_LEVEL_2 
+							&& (!gripEnt->client || (!gripEnt->message&&!(gripEnt->flags&FL_NO_KNOCKBACK)) ) )
+						{//level 2 just lifts them
+							float gripDist = VectorNormalize( gripEnt->client->ps.velocity )/3.0f;
+							if ( gripDist < 20.0f )
+							{
+								if (gripDist<2.0f)
+								{
+									VectorClear(gripEnt->client->ps.velocity);
+								}
+								else
+								{
+									VectorScale( gripEnt->client->ps.velocity, (gripDist*gripDist), gripEnt->client->ps.velocity );
+								}
+							}
+							else
+							{
+								VectorScale( gripEnt->client->ps.velocity, (gripDist*gripDist), gripEnt->client->ps.velocity );
+							}
+						}
+					}
+					//stop them from thinking
+					gripEnt->client->ps.pm_time = 2000;
+					gripEnt->client->ps.pm_flags |= PMF_TIME_KNOCKBACK;
+					if ( gripEnt->NPC )
+					{
+						if ( !(gripEnt->NPC->aiFlags&NPCAI_DIE_ON_IMPACT) )
+						{//not falling to their death
+							gripEnt->NPC->nextBStateThink = level.time + 2000;
+						}
+						if ( self->client->ps.forcePowerLevel[FP_GRIP] > FORCE_LEVEL_1 )
+						{//level 1 just holds them
+							vectoangles( dir, angles );
+							gripEnt->NPC->desiredYaw = AngleNormalize180(angles[YAW]+180);
+							gripEnt->NPC->desiredPitch = -angles[PITCH];
+							SaveNPCGlobals();
+							SetNPCGlobals( gripEnt );
+							NPC_UpdateAngles( qtrue, qtrue );
+							gripEnt->NPC->last_ucmd.angles[0] = ucmd.angles[0];
+							gripEnt->NPC->last_ucmd.angles[1] = ucmd.angles[1];
+							gripEnt->NPC->last_ucmd.angles[2] = ucmd.angles[2];
+							RestoreNPCGlobals();
+							//FIXME: why does he turn back to his original angles once he dies or is let go?
+						}
+					}
+					else if ( !gripEnt->s.number )
+					{
+						//vectoangles( dir, angles );
+						//gripEnt->client->ps.viewangles[0] = -angles[0];
+						//gripEnt->client->ps.viewangles[1] = AngleNormalize180(angles[YAW]+180);
+						gripEnt->enemy = self;
+						NPC_SetLookTarget( gripEnt, self->s.number, level.time+1000 );
+					}
+
+					gripEnt->client->ps.eFlags |= EF_FORCE_GRIPPED;
+					//dammit!  Make sure that saber stays off!
+					WP_DeactivateSaber( gripEnt );
+				}
+				else
+				{//move
+					if ( self->client->ps.forcePowerLevel[FP_GRIP] > FORCE_LEVEL_1 )
+					{//level 1 just holds them
+						VectorCopy( gripEnt->currentOrigin, gripEnt->s.pos.trBase );
+						VectorSubtract( gripOrg, gripEntOrg, gripEnt->s.pos.trDelta );
+						if ( self->client->ps.forcePowerLevel[FP_GRIP] > FORCE_LEVEL_2 
+							&& (!gripEnt->client || (!gripEnt->message&&!(gripEnt->flags&FL_NO_KNOCKBACK))) )
+						{//level 2 just lifts them
+							VectorScale( gripEnt->s.pos.trDelta, 10, gripEnt->s.pos.trDelta );
+						}
+						gripEnt->s.pos.trType = TR_LINEAR;
+						gripEnt->s.pos.trTime = level.time;
+					}
+
+					gripEnt->s.eFlags |= EF_FORCE_GRIPPED;
+				}
+				
+				//Shouldn't this be discovered?
+				//AddSightEvent( self, gripOrg, 128, AEL_DANGER, 20 );
+				AddSightEvent( self, gripOrg, 128, AEL_DISCOVERED, 20 );
+
+				if ( self->client->ps.forcePowerDebounce[FP_GRIP] < level.time )
+				{
+					//GEntity_PainFunc( gripEnt, self, self, gripOrg, 0, MOD_CRUSH );
+					if ( !gripEnt->client 
+						|| gripEnt->client->NPC_class != CLASS_VEHICLE
+						|| (gripEnt->m_pVehicle
+							&& gripEnt->m_pVehicle->m_pVehicleInfo 
+							&& gripEnt->m_pVehicle->m_pVehicleInfo->type == VH_ANIMAL) )
+					{//we don't damage the empty vehicle
+						gripEnt->painDebounceTime = 0;
+						int gripDmg = forceGripDamage[self->client->ps.forcePowerLevel[FP_GRIP]];
+						if ( gripLevel != -1 )
+						{
+							if ( gripLevel == 1 )
+							{
+								gripDmg = floor((float)gripDmg/3.0f);
+							}
+							else //if ( gripLevel == 2 )
+							{
+								gripDmg = floor((float)gripDmg/1.5f);
+							}
+						}
+						G_Damage( gripEnt, self, self, dir, gripOrg, gripDmg, DAMAGE_NO_ARMOR, MOD_CRUSH );//MOD_???
+					}
+					if ( gripEnt->s.number )
+					{
+						if ( self->client->ps.forcePowerLevel[FP_GRIP] > FORCE_LEVEL_2 )
+						{//do damage faster at level 3
+							self->client->ps.forcePowerDebounce[FP_GRIP] = level.time + Q_irand( 150, 750 );
+						}
+						else
+						{
+							self->client->ps.forcePowerDebounce[FP_GRIP] = level.time + Q_irand( 250, 1000 );
+						}
+					}
+					else
+					{//player takes damage faster
+						self->client->ps.forcePowerDebounce[FP_GRIP] = level.time + Q_irand( 100, 600 );
+					}
+					if ( forceGripDamage[self->client->ps.forcePowerLevel[FP_GRIP]] > 0 )
+					{//no damage at level 1
+						WP_ForcePowerDrain( self, FP_GRIP, 3 );
+					}
+					if ( self->client->NPC_class == CLASS_KYLE
+						&& (self->spawnflags&1) )
+					{//"Boss" Kyle
+						if ( gripEnt->client )
+						{
+							if ( !Q_irand( 0, 2 ) )
+							{//toss him aside!
+								vec3_t vRt;
+								AngleVectors( self->currentAngles, NULL, vRt, NULL );
+								//stop gripping
+								TIMER_Set( self, "gripping", -level.time );
+								WP_ForcePowerStop( self, FP_GRIP );
+								//now toss him
+								if ( Q_irand( 0, 1 ) )
+								{//throw him to my left
+									NPC_SetAnim( self, SETANIM_BOTH, BOTH_TOSS1, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+									VectorScale( vRt, -1500.0f, gripEnt->client->ps.velocity );
+									G_Knockdown( gripEnt, self, vRt, 500, qfalse );
+								}
+								else
+								{//throw him to my right
+									NPC_SetAnim( self, SETANIM_BOTH, BOTH_TOSS2, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+									VectorScale( vRt, 1500.0f, gripEnt->client->ps.velocity );
+									G_Knockdown( gripEnt, self, vRt, 500, qfalse );
+								}
+								//don't do anything for a couple seconds
+								self->client->ps.weaponTime = self->client->ps.torsoAnimTimer + 2000;
+								self->painDebounceTime = level.time + self->client->ps.weaponTime;
+								//stop moving
+								VectorClear( self->client->ps.velocity );
+								VectorClear( self->client->ps.moveDir );
+								return;
+							}
+						}
+					}
+				}
+				else
+				{
+					//WP_ForcePowerDrain( self, FP_GRIP, 0 );
+					if ( !gripEnt->enemy )
+					{
+						if ( gripEnt->client 
+							&& gripEnt->client->playerTeam == TEAM_PLAYER
+							&& self->s.number < MAX_CLIENTS
+							&& self->client
+							&& self->client->playerTeam == TEAM_PLAYER )
+						{//this shouldn't make allies instantly turn on you, let the damage->pain routine determine how allies should react to this
+						}
+						else
+						{
+							G_SetEnemy( gripEnt, self );
+						}
+					}
+				}
+				if ( gripEnt->client && gripEnt->health > 0 )
+				{
+					int anim = BOTH_CHOKE3; //left-handed choke
+					if ( gripEnt->client->ps.weapon == WP_NONE || gripEnt->client->ps.weapon == WP_MELEE )
+					{
+						anim = BOTH_CHOKE1; //two-handed choke
+					}
+					if ( self->client->ps.forcePowerLevel[FP_GRIP] < FORCE_LEVEL_2 )
+					{//still on ground, only set anim on torso
+						NPC_SetAnim( gripEnt, SETANIM_TORSO, anim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+					}
+					else
+					{//in air, set on whole body
+						NPC_SetAnim( gripEnt, SETANIM_BOTH, anim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+					}
+					gripEnt->painDebounceTime = level.time + 2000;
+				}
+			}
+		}
+		break;
+	case FP_LIGHTNING:
+		if ( self->client->ps.forcePowerLevel[FP_LIGHTNING] > FORCE_LEVEL_1 )
+		{//higher than level 1
+			if ( cmd->buttons & BUTTON_FORCE_LIGHTNING )
+			{//holding it keeps it going
+				self->client->ps.forcePowerDuration[FP_LIGHTNING] = level.time + 500;
+				ForceLightningAnim( self );
+			}
+		}
+		if ( !WP_ForcePowerAvailable( self, forcePower, 0 ) )
+		{
+			WP_ForcePowerStop( self, forcePower );
+		}
+		else
+		{
+			ForceShootLightning( self );
+			if ( self->client->ps.torsoAnim == BOTH_FORCE_2HANDEDLIGHTNING
+				|| self->client->ps.torsoAnim == BOTH_FORCE_2HANDEDLIGHTNING_START
+				|| self->client->ps.torsoAnim == BOTH_FORCE_2HANDEDLIGHTNING_HOLD
+				|| self->client->ps.torsoAnim == BOTH_FORCE_2HANDEDLIGHTNING_RELEASE )
+			{//jackin' 'em up, Palpatine-style
+				//extra cost
+				WP_ForcePowerDrain( self, forcePower, 0 );
+			}
+			WP_ForcePowerDrain( self, forcePower, 0 );
+		}
+		break;
+	//new Jedi Academy force powers
+	case FP_RAGE:
+		if (self->health < 1)
+		{
+			WP_ForcePowerStop(self, forcePower);
+			break;
+		}
+		if (self->client->ps.forceRageDrainTime < level.time)
+		{
+			int addTime = 400;
+
+			self->health -= 2;
+
+			if (self->client->ps.forcePowerLevel[FP_RAGE] == FORCE_LEVEL_1)
+			{
+				addTime = 100;
+			}
+			else if (self->client->ps.forcePowerLevel[FP_RAGE] == FORCE_LEVEL_2)
+			{
+				addTime = 250;
+			}
+			else if (self->client->ps.forcePowerLevel[FP_RAGE] == FORCE_LEVEL_3)
+			{
+				addTime = 500;
+			}
+			self->client->ps.forceRageDrainTime = level.time + addTime;
+		}
+
+		if ( self->health < 1 )
+		{
+			self->health = 1;
+			//WP_ForcePowerStop( self, forcePower );
+		}
+		else
+		{
+			self->client->ps.stats[STAT_HEALTH] = self->health;
+
+			speed = forceSpeedValue[self->client->ps.forcePowerLevel[FP_RAGE]-1];
+			if ( !self->s.number )
+			{//player using force rage
+				if ( !(self->client->ps.forcePowersActive&(1<<FP_SPEED))
+					|| self->client->ps.forcePowerLevel[FP_RAGE] > self->client->ps.forcePowerLevel[FP_SPEED]+1 )
+				{//either not using speed or speed is at a lower level than rage
+					gi.cvar_set("timescale", va("%4.2f", speed));
+					if ( g_timescale->value > speed )
+					{
+						newSpeed = g_timescale->value - 0.05;
+						if ( newSpeed < speed )
+						{
+							newSpeed = speed;
+						}
+						gi.cvar_set("timescale", va("%4.2f", newSpeed));
+					}
+				}
+			}
+		}
+		break;
+	case FP_DRAIN:
+		if ( cmd->buttons & BUTTON_FORCE_DRAIN )
+		{//holding it keeps it going
+			self->client->ps.forcePowerDuration[FP_DRAIN] = level.time + 500;
+		}
+		if ( !WP_ForcePowerAvailable( self, forcePower, 0 ) )
+		{//no more force power, stop
+			WP_ForcePowerStop( self, forcePower );
+		}
+		else if ( self->client->ps.forceDrainEntityNum >= 0 && self->client->ps.forceDrainEntityNum < ENTITYNUM_WORLD )
+		{//holding someone
+			if ( !WP_ForcePowerAvailable( self, FP_DRAIN, 0 ) 
+				|| (self->client->ps.forcePowerLevel[FP_DRAIN]>FORCE_LEVEL_1
+					&& !self->s.number
+					&& !(cmd->buttons&BUTTON_FORCE_DRAIN)
+					&& self->client->ps.forcePowerDuration[FP_DRAIN]<level.time) )
+			{
+				WP_ForcePowerStop( self, FP_DRAIN );
+				return;
+			}
+			else
+			{
+				drainEnt = &g_entities[self->client->ps.forceDrainEntityNum];
+
+				if ( !drainEnt )
+				{//invalid ent
+					WP_ForcePowerStop( self, FP_DRAIN );
+					return;
+				}
+				else if ( (drainEnt->health <= 0&&drainEnt->takedamage) )//FIXME: what about things that never had health or lose takedamage when they die?
+				{//dead ent
+					WP_ForcePowerStop( self, FP_DRAIN );
+					return;
+				}
+				else if ( drainEnt->client && drainEnt->client->moveType == MT_FLYSWIM && VectorLengthSquared( NPC->client->ps.velocity ) > (300*300) )
+				{//flying creature broke free
+					WP_ForcePowerStop( self, FP_DRAIN );
+					return;
+				}
+				else if ( drainEnt->client 
+					&& drainEnt->health>0	//dead dudes don't fly
+					&& (drainEnt->client->NPC_class == CLASS_BOBAFETT || drainEnt->client->NPC_class == CLASS_ROCKETTROOPER)
+					&& self->client->ps.forcePowerDebounce[FP_DRAIN] < level.time
+					&& !Q_irand( 0, 10 ) )
+				{//boba fett - fly away!
+					drainEnt->client->ps.forceJumpCharge = 0;//so we don't play the force flip anim
+					drainEnt->client->ps.velocity[2] = 250;
+					drainEnt->client->ps.forceJumpZStart = drainEnt->currentOrigin[2];//so we don't take damage if we land at same height
+					drainEnt->client->ps.pm_flags |= PMF_JUMPING;
+					G_AddEvent( drainEnt, EV_JUMP, 0 );
+					JET_FlyStart( drainEnt );
+					WP_ForcePowerStop( self, FP_DRAIN );
+					return;
+				}
+				else if ( drainEnt->NPC 
+					&& drainEnt->client  
+					&& drainEnt->client->ps.forcePowersKnown
+					&& (drainEnt->client->NPC_class==CLASS_REBORN||drainEnt->client->ps.weapon==WP_SABER)
+					&& !Jedi_CultistDestroyer(drainEnt)
+					&& level.time-(self->client->ps.forcePowerDebounce[FP_DRAIN]>self->client->ps.forcePowerLevel[FP_DRAIN]*500)//at level 1, I always get at least 500ms of drain, at level 3 I get 1500ms
+					&& !Q_irand( 0, 100-(drainEnt->NPC->stats.evasion*8)-(g_spskill->integer*15) ) ) 
+				{//a jedi who broke free FIXME: maybe have some minimum grip length- a reaction time?
+					WP_ForceForceThrow( drainEnt );
+					//FIXME: I need to go into some pushed back anim...
+					WP_ForcePowerStop( self, FP_DRAIN );
+					//can't drain again for 2 seconds
+					self->client->ps.forcePowerDebounce[FP_DRAIN] = level.time + 4000;
+					return;
+				}
+				else
+				{
+					/*
+					int drainLevel = WP_AbsorbConversion( drainEnt, drainEnt->client->ps.forcePowerLevel[FP_ABSORB], self, FP_DRAIN, self->client->ps.forcePowerLevel[FP_DRAIN], forcePowerNeeded[self->client->ps.forcePowerLevel[FP_DRAIN]] );
+					if ( !drainLevel )
+					{
+						WP_ForcePowerStop( self, forcePower );
+						return;
+					}
+					*/
+
+					//NPC_SetAnim( self, SETANIM_BOTH, BOTH_HUGGER1, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+					if ( self->client->ps.torsoAnim != BOTH_FORCE_DRAIN_GRAB_START
+						|| !self->client->ps.torsoAnimTimer )
+					{
+						NPC_SetAnim( self, SETANIM_BOTH, BOTH_FORCE_DRAIN_GRAB_HOLD, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+					}
+					if ( self->handLBolt != -1 )
+					{
+						G_PlayEffect( G_EffectIndex( "force/drain_hand" ), self->playerModel, self->handLBolt, self->s.number, self->currentOrigin, 200, qtrue );
+					}
+					if ( self->handRBolt != -1 )
+					{
+						G_PlayEffect( G_EffectIndex( "force/drain_hand" ), self->playerModel, self->handRBolt, self->s.number, self->currentOrigin, 200, qtrue );
+					}
+					
+					//how far are they
+					dist = Distance( self->client->renderInfo.eyePoint, drainEnt->currentOrigin );
+					if ( DistanceSquared( drainEnt->currentOrigin, self->currentOrigin ) > FORCE_DRAIN_DIST_SQUARED )
+					{//must be close, got away somehow!
+						WP_ForcePowerStop( self, FP_DRAIN );
+						return;
+					}
+
+					//keep my saber off!
+					WP_DeactivateSaber( self, qtrue );
+					if ( drainEnt->client )
+					{
+						//now move them
+						VectorCopy( self->client->ps.viewangles, angles );
+						angles[0] = 0;
+						AngleVectors( angles, dir, NULL, NULL );
+						/*
+						VectorMA( self->currentOrigin, self->maxs[0], dir, drainEnt->client->ps.forceDrainOrg );
+						trace_t	trace;
+						gi.trace( &trace, drainEnt->currentOrigin, drainEnt->mins, drainEnt->maxs, drainEnt->client->ps.forceDrainOrg, drainEnt->s.number, drainEnt->clipmask );
+						if ( !trace.startsolid && !trace.allsolid )
+						{
+							G_SetOrigin( drainEnt, trace.endpos );
+							gi.linkentity( drainEnt );
+							VectorClear( drainEnt->client->ps.velocity );
+						}
+						VectorMA( self->currentOrigin, self->maxs[0]*0.5f, dir, drainEnt->client->ps.forceDrainOrg );
+						*/
+						//stop them from thinking
+						drainEnt->client->ps.pm_time = 2000;
+						drainEnt->client->ps.pm_flags |= PMF_TIME_KNOCKBACK;
+						if ( drainEnt->NPC )
+						{
+							if ( !(drainEnt->NPC->aiFlags&NPCAI_DIE_ON_IMPACT) )
+							{//not falling to their death
+								drainEnt->NPC->nextBStateThink = level.time + 2000;
+							}
+							vectoangles( dir, angles );
+							drainEnt->NPC->desiredYaw = AngleNormalize180(angles[YAW]+180);
+							drainEnt->NPC->desiredPitch = -angles[PITCH];
+							SaveNPCGlobals();
+							SetNPCGlobals( drainEnt );
+							NPC_UpdateAngles( qtrue, qtrue );
+							drainEnt->NPC->last_ucmd.angles[0] = ucmd.angles[0];
+							drainEnt->NPC->last_ucmd.angles[1] = ucmd.angles[1];
+							drainEnt->NPC->last_ucmd.angles[2] = ucmd.angles[2];
+							RestoreNPCGlobals();
+							//FIXME: why does he turn back to his original angles once he dies or is let go?
+						}
+						else if ( !drainEnt->s.number )
+						{
+							drainEnt->enemy = self;
+							NPC_SetLookTarget( drainEnt, self->s.number, level.time+1000 );
+						}
+
+						drainEnt->client->ps.eFlags |= EF_FORCE_DRAINED;
+						//dammit!  Make sure that saber stays off!
+						WP_DeactivateSaber( drainEnt, qtrue );
+					}
+					//Shouldn't this be discovered?
+					AddSightEvent( self, drainEnt->currentOrigin, 128, AEL_DISCOVERED, 20 );
+
+					if ( self->client->ps.forcePowerDebounce[FP_DRAIN] < level.time )
+					{
+						int drainLevel = WP_AbsorbConversion( drainEnt, drainEnt->client->ps.forcePowerLevel[FP_ABSORB], self, FP_DRAIN, self->client->ps.forcePowerLevel[FP_DRAIN], forcePowerNeeded[self->client->ps.forcePowerLevel[FP_DRAIN]] );
+						if ( (drainLevel && drainLevel == -1) 
+							|| Q_irand( drainLevel, 3 ) < 3 ) 
+						{//the drain is being absorbed
+							ForceDrainEnt( self, drainEnt );
+						}
+						WP_ForcePowerDrain( self, FP_DRAIN, 3 );
+					}
+					else
+					{
+						if ( !Q_irand( 0, 4 ) )
+						{
+							WP_ForcePowerDrain( self, FP_DRAIN, 1 );
+						}
+						if ( !drainEnt->enemy )
+						{
+							G_SetEnemy( drainEnt, self );
+						}
+					}
+					if ( drainEnt->health > 0 )
+					{//still alive
+						//NPC_SetAnim( drainEnt, SETANIM_BOTH, BOTH_HUGGEE1, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+						NPC_SetAnim( drainEnt, SETANIM_BOTH, BOTH_FORCE_DRAIN_GRABBED, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+					}
+				}
+			}
+		}
+		else if ( self->client->ps.forcePowerLevel[forcePower] > FORCE_LEVEL_1 )
+		{//regular distance-drain
+			if ( cmd->buttons & BUTTON_FORCE_DRAIN )
+			{//holding it keeps it going
+				self->client->ps.forcePowerDuration[FP_DRAIN] = level.time + 500;
+				if ( self->client->ps.torsoAnim == BOTH_FORCE_DRAIN_START )
+				{
+					if ( !self->client->ps.torsoAnimTimer )
+					{
+						NPC_SetAnim( self, SETANIM_TORSO, BOTH_FORCE_DRAIN_HOLD, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+					}
+					else
+					{
+						NPC_SetAnim( self, SETANIM_TORSO, BOTH_FORCE_DRAIN_START, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+					}
+				}
+				else
+				{
+					NPC_SetAnim( self, SETANIM_TORSO, BOTH_FORCE_DRAIN_HOLD, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+				}
+			}
+			if ( !WP_ForcePowerAvailable( self, forcePower, 0 ) )
+			{
+				WP_ForcePowerStop( self, forcePower );
+			}
+			else
+			{
+				ForceShootDrain( self );
+			}
+		}
+		break;
+	case FP_PROTECT:
+		break;
+	case FP_ABSORB:
+		break;
+	case FP_SEE:
+		break;
+	default:
+		break;
+	}
+}
+
+void WP_CheckForcedPowers( gentity_t *self, usercmd_t *ucmd )
+{
+	for ( int forcePower = FP_FIRST; forcePower < NUM_FORCE_POWERS; forcePower++ )
+	{
+		if ( (self->client->ps.forcePowersForced&(1<<forcePower)) )
+		{
+			switch ( forcePower )
+			{
+			case FP_HEAL:
+				ForceHeal( self );
+				//do only once
+				self->client->ps.forcePowersForced &= ~(1<<forcePower);
+				break;
+			case FP_LEVITATION:
+				//nothing
+				break;
+			case FP_SPEED:
+				ForceSpeed( self );
+				//do only once
+				self->client->ps.forcePowersForced &= ~(1<<forcePower);
+				break;
+			case FP_PUSH:
+				ForceThrow( self, qfalse );
+				//do only once
+				self->client->ps.forcePowersForced &= ~(1<<forcePower);
+				break;
+			case FP_PULL:
+				ForceThrow( self, qtrue );
+				//do only once
+				self->client->ps.forcePowersForced &= ~(1<<forcePower);
+				break;
+			case FP_TELEPATHY:
+				//FIXME: target at enemy?
+				ForceTelepathy( self );
+				//do only once
+				self->client->ps.forcePowersForced &= ~(1<<forcePower);
+				break;
+			case FP_GRIP:
+				ucmd->buttons &= ~(BUTTON_ATTACK|BUTTON_ALT_ATTACK|BUTTON_FORCE_FOCUS|BUTTON_FORCE_DRAIN|BUTTON_FORCE_LIGHTNING);
+				ucmd->buttons |= BUTTON_FORCEGRIP;
+				//holds until cleared
+				break;
+			case FP_LIGHTNING:
+				ucmd->buttons &= ~(BUTTON_ATTACK|BUTTON_ALT_ATTACK|BUTTON_FORCE_FOCUS|BUTTON_FORCEGRIP|BUTTON_FORCE_DRAIN);
+				ucmd->buttons |= BUTTON_FORCE_LIGHTNING;
+				//holds until cleared
+				break;
+			case FP_SABERTHROW:
+				ucmd->buttons &= ~(BUTTON_ATTACK|BUTTON_FORCE_FOCUS|BUTTON_FORCEGRIP|BUTTON_FORCE_DRAIN|BUTTON_FORCE_LIGHTNING);
+				ucmd->buttons |= BUTTON_ALT_ATTACK;
+				//holds until cleared?
+				break;
+			case FP_SABER_DEFENSE:
+				//nothing
+				break;
+			case FP_SABER_OFFENSE:
+				//nothing
+				break;
+			case FP_RAGE:
+				ForceRage( self );
+				//do only once
+				self->client->ps.forcePowersForced &= ~(1<<forcePower);
+				break;
+			case FP_PROTECT:
+				ForceProtect( self );
+				//do only once
+				self->client->ps.forcePowersForced &= ~(1<<forcePower);
+				break;
+			case FP_ABSORB:
+				ForceAbsorb( self );
+				//do only once
+				self->client->ps.forcePowersForced &= ~(1<<forcePower);
+				break;
+			case FP_DRAIN:
+				ucmd->buttons &= ~(BUTTON_ATTACK|BUTTON_ALT_ATTACK|BUTTON_FORCE_FOCUS|BUTTON_FORCEGRIP|BUTTON_FORCE_LIGHTNING);
+				ucmd->buttons |= BUTTON_FORCE_DRAIN;
+				//holds until cleared
+				break;
+			case FP_SEE:
+				//nothing
+				break;
+			}
+		}
+	}
+}
+
+void WP_ForcePowersUpdate( gentity_t *self, usercmd_t *ucmd )
+{
+	qboolean	usingForce = qfalse;
+	int			i;
+	//see if any force powers are running
+	if ( !self )
+	{
+		return;
+	}
+	if ( !self->client )
+	{
+		return;
+	}
+
+	if ( self->health <= 0 )
+	{//if dead, deactivate any active force powers
+		for ( i = 0; i < NUM_FORCE_POWERS; i++ )
+		{
+			if ( self->client->ps.forcePowerDuration[i] || (self->client->ps.forcePowersActive&( 1 << i )) )
+			{
+				WP_ForcePowerStop( self, (forcePowers_t)i );
+				self->client->ps.forcePowerDuration[i] = 0;
+			}
+		}
+		return;
+	}
+
+	WP_CheckForcedPowers( self, ucmd );
+
+	if ( !self->s.number )
+	{//player uses different kind of force-jump
+	}
+	else
+	{
+		/*
+		if ( ucmd->buttons & BUTTON_FORCEJUMP )
+		{//just charging up
+			ForceJumpCharge( self, ucmd );
+		}
+		else */
+		if ( self->client->ps.forceJumpCharge ) 
+		{//let go of charge button, have charge
+			//if leave the ground by some other means, cancel the force jump so we don't suddenly jump when we land.
+			if ( self->client->ps.groundEntityNum == ENTITYNUM_NONE 
+				&& !PM_SwimmingAnim( self->client->ps.legsAnim ) )
+			{//FIXME: stop sound?
+				//self->client->ps.forceJumpCharge = 0;
+				//FIXME: actually, we want this to still be cleared... don't clear it if the button isn't being pressed, but clear it if not holding button and not on ground.
+			}
+			else
+			{//still on ground, so jump
+				ForceJump( self, ucmd );
+				return;
+			}
+		}
+	}
+
+	if ( ucmd->buttons & BUTTON_FORCEGRIP )
+	{
+		ForceGrip( self );
+	}
+
+	if ( ucmd->buttons & BUTTON_FORCE_LIGHTNING )
+	{
+		ForceLightning( self );
+	}
+
+	if ( ucmd->buttons & BUTTON_FORCE_DRAIN )
+	{
+		if ( !ForceDrain2( self ) )
+		{//can't drain-grip someone right in front
+			if ( self->client->ps.forcePowerLevel[FP_DRAIN] > FORCE_LEVEL_1 )
+			{//try ranged
+				ForceDrain( self, qtrue );
+			}
+		}
+	}
+
+	for ( i = 0; i < NUM_FORCE_POWERS; i++ )
+	{
+		if ( self->client->ps.forcePowerDuration[i] )
+		{
+			if ( self->client->ps.forcePowerDuration[i] < level.time )
+			{
+				if ( (self->client->ps.forcePowersActive&( 1 << i )) )
+				{//turn it off
+					WP_ForcePowerStop( self, (forcePowers_t)i );
+				}
+				self->client->ps.forcePowerDuration[i] = 0;
+			}
+		}
+		if ( (self->client->ps.forcePowersActive&( 1 << i )) )
+		{
+			usingForce = qtrue;
+			WP_ForcePowerRun( self, (forcePowers_t)i, ucmd );
+		}
+	}
+	if ( self->client->ps.saberInFlight )
+	{//don't regen force power while throwing saber
+		if ( self->client->ps.saberEntityNum < ENTITYNUM_NONE && self->client->ps.saberEntityNum > 0 )//player is 0
+		{//
+			if ( &g_entities[self->client->ps.saberEntityNum] != NULL && g_entities[self->client->ps.saberEntityNum].s.pos.trType == TR_LINEAR )
+			{//fell to the ground and we're trying to pull it back
+				usingForce = qtrue;
+			}
+		}
+	}
+	if ( PM_ForceUsingSaberAnim( self->client->ps.torsoAnim ) )
+	{
+		usingForce = qtrue;
+	}
+	if ( !usingForce )
+	{//when not using the force, regenerate at 10 points per second
+		if ( self->client->ps.forcePowerRegenDebounceTime < level.time )
+		{
+			WP_ForcePowerRegenerate( self, self->client->ps.forcePowerRegenAmount );
+			self->client->ps.forcePowerRegenDebounceTime = level.time + self->client->ps.forcePowerRegenRate;
+			if ( self->client->ps.forceRageRecoveryTime >= level.time )
+			{//regen half as fast
+				self->client->ps.forcePowerRegenDebounceTime += self->client->ps.forcePowerRegenRate;
+			}
+		}
+	}
+}
+
+void WP_InitForcePowers( gentity_t *ent )
+{
+	if ( !ent || !ent->client )
+	{
+		return;
+	}
+
+	if ( !ent->client->ps.forcePowerMax )
+	{
+		ent->client->ps.forcePowerMax = FORCE_POWER_MAX;
+	}
+	if ( !ent->client->ps.forcePowerRegenRate )
+	{
+		ent->client->ps.forcePowerRegenRate = 100;
+	}
+	ent->client->ps.forcePower = ent->client->ps.forcePowerMax;
+	ent->client->ps.forcePowerRegenDebounceTime = 0;
+
+	ent->client->ps.forceGripEntityNum = ent->client->ps.forceDrainEntityNum = ent->client->ps.pullAttackEntNum = ENTITYNUM_NONE;
+	ent->client->ps.forceRageRecoveryTime = 0;
+	ent->client->ps.forceDrainTime = 0;
+	ent->client->ps.pullAttackTime = 0;
+
+	if ( ent->s.number < MAX_CLIENTS )
+	{//player
+		if ( !g_cheats->integer )//devmaps give you all the FP
+		{
+			ent->client->ps.forcePowerLevel[FP_SABER_DEFENSE] = FORCE_LEVEL_1;
+			ent->client->ps.forcePowerLevel[FP_SABER_OFFENSE] = FORCE_LEVEL_1;
+		}
+		else
+		{
+			ent->client->ps.forcePowersKnown = ( 1 << FP_HEAL )|( 1 << FP_LEVITATION )|( 1 << FP_SPEED )|( 1 << FP_PUSH )|( 1 << FP_PULL )|( 1 << FP_TELEPATHY )|( 1 << FP_GRIP )|( 1 << FP_LIGHTNING)|( 1 << FP_SABERTHROW)|( 1 << FP_SABER_DEFENSE )|( 1 << FP_SABER_OFFENSE )|( 1<< FP_RAGE )|( 1<< FP_DRAIN )|( 1<< FP_PROTECT )|( 1<< FP_ABSORB )|( 1<< FP_SEE );
+			ent->client->ps.forcePowerLevel[FP_HEAL] = FORCE_LEVEL_2;
+			ent->client->ps.forcePowerLevel[FP_LEVITATION] = FORCE_LEVEL_2;
+			ent->client->ps.forcePowerLevel[FP_PUSH] = FORCE_LEVEL_1;
+			ent->client->ps.forcePowerLevel[FP_PULL] = FORCE_LEVEL_1;
+			ent->client->ps.forcePowerLevel[FP_SABERTHROW] = FORCE_LEVEL_2;
+			ent->client->ps.forcePowerLevel[FP_SPEED] = FORCE_LEVEL_2;
+			ent->client->ps.forcePowerLevel[FP_LIGHTNING] = FORCE_LEVEL_1;
+			ent->client->ps.forcePowerLevel[FP_TELEPATHY] = FORCE_LEVEL_2;
+
+			ent->client->ps.forcePowerLevel[FP_RAGE] = FORCE_LEVEL_1;
+			ent->client->ps.forcePowerLevel[FP_PROTECT] = FORCE_LEVEL_1;
+			ent->client->ps.forcePowerLevel[FP_ABSORB] = FORCE_LEVEL_1;
+			ent->client->ps.forcePowerLevel[FP_DRAIN] = FORCE_LEVEL_1;
+			ent->client->ps.forcePowerLevel[FP_SEE] = FORCE_LEVEL_1;
+
+			ent->client->ps.forcePowerLevel[FP_SABER_DEFENSE] = FORCE_LEVEL_3;
+			ent->client->ps.forcePowerLevel[FP_SABER_OFFENSE] = FORCE_LEVEL_3;
+			ent->client->ps.forcePowerLevel[FP_GRIP] = FORCE_LEVEL_2;
+		}
+	}
+}
\ No newline at end of file
diff --git a/code/game/wp_saber.h b/code/game/wp_saber.h
new file mode 100644
index 0000000..a1a7b34
--- /dev/null
+++ b/code/game/wp_saber.h
@@ -0,0 +1,440 @@
+#ifndef __WP_SABER_H
+#define __WP_SABER_H
+
+#define ARMOR_EFFECT_TIME	500
+
+#define JSF_AMBUSH		16	//ambusher Jedi
+
+//saberEventFlags
+#define	SEF_HITENEMY	0x1		//Hit the enemy
+#define	SEF_HITOBJECT	0x2		//Hit some other object
+#define	SEF_HITWALL		0x4		//Hit a wall
+#define	SEF_PARRIED		0x8		//Parried a saber swipe
+#define	SEF_DEFLECTED	0x10	//Deflected a missile or saberInFlight
+#define	SEF_BLOCKED		0x20	//Was blocked by a parry
+#define	SEF_EVENTS		(SEF_HITENEMY|SEF_HITOBJECT|SEF_HITWALL|SEF_PARRIED|SEF_DEFLECTED|SEF_BLOCKED)
+#define	SEF_LOCKED		0x40	//Sabers locked with someone else
+#define	SEF_INWATER		0x80	//Saber is in water
+#define	SEF_LOCK_WON	0x100	//Won a saberLock
+//saberEntityState
+#define SES_LEAVING		1
+#define SES_HOVERING	2
+#define SES_RETURNING	3
+
+#define SABER_EXTRAPOLATE_DIST 16.0f
+
+#define	SABER_MAX_DIST	400.0f
+#define	SABER_MAX_DIST_SQUARED	(SABER_MAX_DIST*SABER_MAX_DIST)
+
+#define	FORCE_POWER_MAX	100
+
+#define	SABER_REFLECT_MISSILE_CONE	0.2f
+
+#define SABER_RADIUS_STANDARD	3.0f
+
+#define	SABER_LOCK_TIME			10000
+#define	SABER_LOCK_DELAYED_TIME 9500
+typedef enum
+{
+	LOCK_VICTORY = 0,//one side won
+	LOCK_STALEMATE,//neither side won
+	LOCK_DRAW//both people fall back
+} saberLockResult_t;
+
+typedef enum
+{
+	LOCK_FIRST = 0,
+	LOCK_TOP = LOCK_FIRST,
+	LOCK_DIAG_TR,
+	LOCK_DIAG_TL,
+	LOCK_DIAG_BR,
+	LOCK_DIAG_BL,
+	LOCK_R,
+	LOCK_L,
+	LOCK_RANDOM,
+	LOCK_KYLE_GRAB1,
+	LOCK_KYLE_GRAB2,
+	LOCK_KYLE_GRAB3,
+	LOCK_FORCE_DRAIN
+} sabersLockMode_t;
+
+typedef enum
+{
+	SABERLOCK_TOP,
+	SABERLOCK_SIDE,
+	SABERLOCK_LOCK,
+	SABERLOCK_BREAK,
+	SABERLOCK_SUPERBREAK,
+	SABERLOCK_WIN,
+	SABERLOCK_LOSE
+};
+
+typedef enum
+{
+	DIR_RIGHT,
+	DIR_LEFT,
+	DIR_FRONT,
+	DIR_BACK
+};
+
+#define FORCE_LIGHTSIDE			1
+#define FORCE_DARKSIDE			2
+
+#define	MAX_FORCE_HEAL_HARD		25
+#define	MAX_FORCE_HEAL_MEDIUM	50
+#define	MAX_FORCE_HEAL_EASY		75
+#define	FORCE_HEAL_INTERVAL	200//FIXME: maybe level 1 is slower or level 2 is faster?
+
+#define	FORCE_GRIP_3_MIN_DIST	128.0f
+#define	FORCE_GRIP_3_MAX_DIST	256.0f
+#define	FORCE_GRIP_DIST			512.0f//FIXME: vary by power level?
+#define	FORCE_GRIP_DIST_SQUARED	(FORCE_GRIP_DIST*FORCE_GRIP_DIST)
+
+#define	FORCE_DRAIN_DIST	64.0f//FIXME: vary by power level?
+#define	FORCE_DRAIN_DIST_SQUARED	(FORCE_DRAIN_DIST*FORCE_DRAIN_DIST)
+
+#define MAX_DRAIN_DISTANCE 512
+
+#define MIN_SABERBLADE_DRAW_LENGTH 0.5f
+
+#define STAFF_KICK_RANGE 16
+
+#define	JUMP_OFF_WALL_SPEED	200.0f
+
+#define	FORCE_LONG_LEAP_SPEED	475.0f//300
+
+
+//#define DUAL_SPIN_PROTECT_POWER	50	//power required to do the dual spin attack
+//#define SINGLE_SPECIAL_POWER	20	//power required to do the single saber special attacks
+
+#define SABER_ALT_ATTACK_POWER		50//75?
+#define SABER_ALT_ATTACK_POWER_LR	10//30?
+#define SABER_ALT_ATTACK_POWER_FB	25//30/50?
+
+#define FORCE_LONGJUMP_POWER	20
+
+#define WALL_RUN_UP_BACKFLIP_SPEED	-150.0f//was -300.0f
+#define	MAX_WALL_RUN_Z_NORMAL	0.4f//was 0.0f
+
+#define	PLAYER_KNOCKDOWN_HOLD_EXTRA_TIME	4000	//player stays down after a knockdown for 4 whole seconds before automatically doing one of the slow get-ups
+
+#define MAX_WALL_GRAB_SLOPE	0.2f
+
+//"Matrix" effect flags
+#define MEF_NO_TIMESCALE		0x000001	//no timescale
+#define MEF_NO_VERTBOB			0x000002	//no vert bob 
+#define MEF_NO_SPIN				0x000004	//no spin
+#define MEF_NO_RANGEVAR			0x000008	//no camera range variation
+#define MEF_HIT_GROUND_STOP		0x000010	//stop effect when subject hits the ground
+#define MEF_REVERSE_SPIN		0x000020	//spin counter-clockwise instead of clockwise
+#define MEF_MULTI_SPIN			0x000040	//spin once every second, until the effect stops
+#define	MEF_LOOK_AT_ENEMY		0x000200
+
+extern float forceJumpStrength[];
+extern float forceJumpHeight[];
+extern float forceJumpHeightMax[];
+
+extern float forcePushPullRadius[];
+
+extern void ForceSpeed( gentity_t *self, int duration = 0 );
+extern float forceSpeedValue[];
+extern float forceSpeedRangeMod[];
+extern float forceSpeedFOVMod[];
+#define FORCE_SPEED_DURATION 10000.0f
+#define FORCE_RAGE_DURATION 10000.0f
+
+#define MASK_FORCE_PUSH (MASK_OPAQUE|CONTENTS_SOLID)
+
+typedef enum
+{
+	FORCE_LEVEL_0,
+	FORCE_LEVEL_1,
+	FORCE_LEVEL_2,
+	FORCE_LEVEL_3,
+	NUM_FORCE_POWER_LEVELS
+};
+#define	FORCE_LEVEL_4 (FORCE_LEVEL_3+1)
+#define	FORCE_LEVEL_5 (FORCE_LEVEL_4+1)
+
+typedef enum
+{
+	FJ_FORWARD,
+	FJ_BACKWARD,
+	FJ_RIGHT,
+	FJ_LEFT,
+	FJ_UP
+};
+
+#define FORCE_JUMP_CHARGE_TIME 1000.0f	//Force jump reaches maximum power in one second
+
+#define FORCE_POWERS_ROSH_FROM_TWINS ((1<<FP_SPEED)|(1<<FP_GRIP)|(1<<FP_RAGE)|(1<<FP_SABERTHROW))
+
+extern void WP_InitForcePowers( gentity_t *ent );
+extern int WP_GetVelocityForForceJump( gentity_t *self, vec3_t jumpVel, usercmd_t *ucmd );
+extern int WP_SaberInitBladeData( gentity_t *ent );
+extern void G_CreateG2AttachedWeaponModel( gentity_t *ent, const char *weaponModel, int boltNum, int weaponNum );
+extern void WP_SaberAddG2SaberModels( gentity_t *ent, int specificSaberNum = -1 );
+extern qboolean WP_SaberParseParms( const char *SaberName, saberInfo_t *saber, qboolean setColors = qtrue );
+extern qboolean WP_BreakSaber( gentity_t *ent, const char *surfName, saberType_t saberType = SABER_NONE );
+extern void ForceThrow( gentity_t *self, qboolean pull, qboolean fake = qfalse );
+extern qboolean G_GetHitLocFromSurfName( gentity_t *ent, const char *surfName, int *hitLoc, vec3_t point, vec3_t dir, vec3_t bladeDir, int mod, saberType_t saberType = SABER_NONE );
+extern qboolean G_CheckEnemyPresence( gentity_t *ent, int dir, float radius, float tolerance = 0.75f );
+extern void WP_SaberFreeStrings( saberInfo_t &saber );
+extern qboolean G_EnoughPowerForSpecialMove( int forcePower, int cost, qboolean kataMove = qfalse );
+extern void G_DrainPowerForSpecialMove( gentity_t *self, forcePowers_t fp, int cost, qboolean kataMove = qfalse );
+extern int G_CostForSpecialMove( int cost, qboolean kataMove = qfalse );
+
+typedef enum
+{
+	EVASION_NONE = 0,
+	EVASION_PARRY,
+	EVASION_DUCK_PARRY,
+	EVASION_JUMP_PARRY,
+	EVASION_DODGE,
+	EVASION_JUMP,
+	EVASION_DUCK,
+	EVASION_FJUMP,
+	EVASION_CARTWHEEL,
+	EVASION_OTHER,
+	NUM_EVASION_TYPES
+} evasionType_t;
+
+typedef enum
+{
+	SWING_FAST,
+	SWING_MEDIUM,
+	SWING_STRONG
+} swingType_t;
+// Okay, here lies the much-dreaded Pat-created FSM movement chart...  Heretic II strikes again!
+// Why am I inflicting this on you?  Well, it's better than hardcoded states.
+// Ideally this will be replaced with an external file or more sophisticated move-picker
+// once the game gets out of prototype stage. <- HAHA!
+
+#ifdef LS_NONE
+#undef LS_NONE
+#endif
+
+typedef enum {
+	// Invalid, or saber not armed
+	LS_INVALID	= -1,
+	LS_NONE		= 0,
+
+	// General movements with saber
+	LS_READY,
+	LS_DRAW,
+	LS_PUTAWAY,
+
+	// Attacks
+	LS_A_TL2BR,//4
+	LS_A_L2R,
+	LS_A_BL2TR,
+	LS_A_BR2TL,
+	LS_A_R2L,
+	LS_A_TR2BL,
+	LS_A_T2B,
+	LS_A_BACKSTAB,
+	LS_A_BACK,
+	LS_A_BACK_CR,
+	LS_ROLL_STAB,
+	LS_A_LUNGE,
+	LS_A_JUMP_T__B_,
+	LS_A_FLIP_STAB,
+	LS_A_FLIP_SLASH,
+	LS_JUMPATTACK_DUAL,
+	LS_JUMPATTACK_ARIAL_LEFT,
+	LS_JUMPATTACK_ARIAL_RIGHT,
+	LS_JUMPATTACK_CART_LEFT,
+	LS_JUMPATTACK_CART_RIGHT,
+	LS_JUMPATTACK_STAFF_LEFT,
+	LS_JUMPATTACK_STAFF_RIGHT,
+	LS_BUTTERFLY_LEFT,
+	LS_BUTTERFLY_RIGHT,
+	LS_A_BACKFLIP_ATK,
+	LS_SPINATTACK_DUAL,
+	LS_SPINATTACK,
+	LS_LEAP_ATTACK,
+	LS_SWOOP_ATTACK_RIGHT,
+	LS_SWOOP_ATTACK_LEFT,
+	LS_TAUNTAUN_ATTACK_RIGHT,
+	LS_TAUNTAUN_ATTACK_LEFT,
+	LS_KICK_F,
+	LS_KICK_B,
+	LS_KICK_R,
+	LS_KICK_L,
+	LS_KICK_S,
+	LS_KICK_BF,
+	LS_KICK_RL,
+	LS_KICK_F_AIR,
+	LS_KICK_B_AIR,
+	LS_KICK_R_AIR,
+	LS_KICK_L_AIR,
+	LS_STABDOWN,
+	LS_STABDOWN_STAFF,
+	LS_STABDOWN_DUAL,
+	LS_DUAL_SPIN_PROTECT,
+	LS_STAFF_SOULCAL,
+	LS_A1_SPECIAL,
+	LS_A2_SPECIAL,
+	LS_A3_SPECIAL,
+	LS_UPSIDE_DOWN_ATTACK,
+	LS_PULL_ATTACK_STAB,
+	LS_PULL_ATTACK_SWING,
+	LS_SPINATTACK_ALORA,
+	LS_DUAL_FB,
+	LS_DUAL_LR,
+	LS_HILT_BASH,
+
+	//starts
+	LS_S_TL2BR,//26
+	LS_S_L2R,
+	LS_S_BL2TR,//# Start of attack chaining to SLASH LR2UL
+	LS_S_BR2TL,//# Start of attack chaining to SLASH LR2UL
+	LS_S_R2L,
+	LS_S_TR2BL,
+	LS_S_T2B,
+
+	//returns
+	LS_R_TL2BR,//33
+	LS_R_L2R,
+	LS_R_BL2TR,
+	LS_R_BR2TL,
+	LS_R_R2L,
+	LS_R_TR2BL,
+	LS_R_T2B,
+
+	//transitions
+	LS_T1_BR__R,//40
+	LS_T1_BR_TR,
+	LS_T1_BR_T_,
+	LS_T1_BR_TL,
+	LS_T1_BR__L,
+	LS_T1_BR_BL,
+	LS_T1__R_BR,//46
+	LS_T1__R_TR,
+	LS_T1__R_T_,
+	LS_T1__R_TL,
+	LS_T1__R__L,
+	LS_T1__R_BL,
+	LS_T1_TR_BR,//52
+	LS_T1_TR__R,
+	LS_T1_TR_T_,
+	LS_T1_TR_TL,
+	LS_T1_TR__L,
+	LS_T1_TR_BL,
+	LS_T1_T__BR,//58
+	LS_T1_T___R,
+	LS_T1_T__TR,
+	LS_T1_T__TL,
+	LS_T1_T___L,
+	LS_T1_T__BL,
+	LS_T1_TL_BR,//64
+	LS_T1_TL__R,
+	LS_T1_TL_TR,
+	LS_T1_TL_T_,
+	LS_T1_TL__L,
+	LS_T1_TL_BL,
+	LS_T1__L_BR,//70
+	LS_T1__L__R,
+	LS_T1__L_TR,
+	LS_T1__L_T_,
+	LS_T1__L_TL,
+	LS_T1__L_BL,
+	LS_T1_BL_BR,//76
+	LS_T1_BL__R,
+	LS_T1_BL_TR,
+	LS_T1_BL_T_,
+	LS_T1_BL_TL,
+	LS_T1_BL__L,
+
+	//Bounces
+	LS_B1_BR,
+	LS_B1__R,
+	LS_B1_TR,
+	LS_B1_T_,
+	LS_B1_TL,
+	LS_B1__L,
+	LS_B1_BL,
+
+	//Deflected attacks
+	LS_D1_BR,
+	LS_D1__R,
+	LS_D1_TR,
+	LS_D1_T_,
+	LS_D1_TL,
+	LS_D1__L,
+	LS_D1_BL,
+	LS_D1_B_,
+
+	//Reflected attacks
+	LS_V1_BR,
+	LS_V1__R,
+	LS_V1_TR,
+	LS_V1_T_,
+	LS_V1_TL,
+	LS_V1__L,
+	LS_V1_BL,
+	LS_V1_B_,
+
+	// Broken parries
+	LS_H1_T_,//
+	LS_H1_TR,
+	LS_H1_TL,
+	LS_H1_BR,
+	LS_H1_B_,
+	LS_H1_BL,
+
+	// Knockaways
+	LS_K1_T_,//
+	LS_K1_TR,
+	LS_K1_TL,
+	LS_K1_BR,
+	LS_K1_BL,
+
+	// Parries
+	LS_PARRY_UP,//
+	LS_PARRY_UR,
+	LS_PARRY_UL,
+	LS_PARRY_LR,
+	LS_PARRY_LL,
+
+	// Projectile Reflections
+	LS_REFLECT_UP,//
+	LS_REFLECT_UR,
+	LS_REFLECT_UL,
+	LS_REFLECT_LR,
+	LS_REFLECT_LL,
+
+	LS_MOVE_MAX//
+} saberMoveName_t;
+
+void PM_SetSaberMove(saberMoveName_t newMove);
+
+typedef enum {
+	Q_BR,
+	Q_R,
+	Q_TR,
+	Q_T,
+	Q_TL,
+	Q_L,
+	Q_BL,
+	Q_B,
+	Q_NUM_QUADS
+} saberQuadrant_t;
+
+typedef struct
+{
+	char *name;
+	int animToUse;
+	int	startQuad;
+	int	endQuad;
+	unsigned animSetFlags;
+	int blendTime;
+	int blocking;
+	saberMoveName_t chain_idle;			// What move to call if the attack button is not pressed at the end of this anim
+	saberMoveName_t chain_attack;		// What move to call if the attack button (and nothing else) is pressed
+	qboolean trailLength;
+} saberMoveData_t;
+
+extern saberMoveData_t	saberMoveData[LS_MOVE_MAX];
+
+#endif	// __WP_SABER_H
diff --git a/code/game/wp_saberLoad.cpp b/code/game/wp_saberLoad.cpp
new file mode 100644
index 0000000..7ef6446
--- /dev/null
+++ b/code/game/wp_saberLoad.cpp
@@ -0,0 +1,945 @@
+//wp_saberLoad.cpp
+// leave this line at the top for all NPC_xxxx.cpp files...
+#include "g_headers.h"
+
+#include "q_shared.h"
+#include "wp_saber.h"
+
+extern qboolean G_ParseLiteral( const char **data, const char *string );
+extern saber_colors_t TranslateSaberColor( const char *name );
+extern qboolean PM_SaberInStart( int move );
+extern qboolean PM_SaberInTransition( int move );
+extern qboolean PM_SaberInAttack( int move );
+
+extern stringID_table_t FPTable[];
+
+#define MAX_SABER_DATA_SIZE 0x8000
+char	SaberParms[MAX_SABER_DATA_SIZE];
+
+void Saber_SithSwordPrecache( void )
+{//*SIGH* special sounds used by the sith sword
+	for ( int i = 1; i < 5; i++ )
+	{
+		G_SoundIndex( va( "sound/weapons/sword/stab%d.wav", i ) );
+	}
+	for ( i = 1; i < 5; i++ )
+	{
+		G_SoundIndex( va( "sound/weapons/sword/swing%d.wav", i ) );
+	}
+	for ( i = 1; i < 7; i++ )
+	{
+		G_SoundIndex( va( "sound/weapons/sword/fall%d.wav", i ) );
+	}
+	/*
+	for ( i = 1; i < 4; i++ )
+	{
+		G_SoundIndex( va( "sound/weapons/sword/spin%d.wav", i ) );
+	}
+	*/
+}
+
+stringID_table_t SaberTable[] =
+{
+	ENUM2STRING(SABER_NONE),
+	ENUM2STRING(SABER_SINGLE),
+	ENUM2STRING(SABER_STAFF),
+	ENUM2STRING(SABER_BROAD),
+	ENUM2STRING(SABER_PRONG),
+	ENUM2STRING(SABER_DAGGER),
+	ENUM2STRING(SABER_ARC),
+	ENUM2STRING(SABER_SAI),
+	ENUM2STRING(SABER_CLAW),
+	ENUM2STRING(SABER_LANCE),
+	ENUM2STRING(SABER_STAR),
+	ENUM2STRING(SABER_TRIDENT),
+	ENUM2STRING(SABER_SITH_SWORD),
+	"",	-1
+};
+
+saber_styles_t TranslateSaberStyle( const char *name ) 
+{
+	if ( !Q_stricmp( name, "fast" ) ) 
+	{
+		return SS_FAST;
+	}
+	if ( !Q_stricmp( name, "medium" ) ) 
+	{
+		return SS_MEDIUM;
+	}
+	if ( !Q_stricmp( name, "strong" ) ) 
+	{
+		return SS_STRONG;
+	}
+	if ( !Q_stricmp( name, "desann" ) ) 
+	{
+		return SS_DESANN;
+	}
+	if ( !Q_stricmp( name, "tavion" ) ) 
+	{
+		return SS_TAVION;
+	}
+	if ( !Q_stricmp( name, "dual" ) ) 
+	{
+		return SS_DUAL;
+	}
+	if ( !Q_stricmp( name, "staff" ) ) 
+	{
+		return SS_STAFF;
+	}
+	return SS_NONE;
+}
+
+void WP_SaberFreeStrings( saberInfo_t &saber )
+{
+	if (saber.name && gi.bIsFromZone(saber.name , TAG_G_ALLOC)) {
+		gi.Free (saber.name);
+		saber.name=0;
+	}
+	if (saber.fullName && gi.bIsFromZone(saber.fullName , TAG_G_ALLOC)) {
+		gi.Free (saber.fullName);
+		saber.fullName=0;
+	}
+	if (saber.model && gi.bIsFromZone(saber.model , TAG_G_ALLOC)) {
+		gi.Free (saber.model);
+		saber.model=0;
+	}
+	if (saber.skin && gi.bIsFromZone(saber.skin , TAG_G_ALLOC)) {
+		gi.Free (saber.skin);
+		saber.skin=0;
+	}
+	if (saber.brokenSaber1 && gi.bIsFromZone(saber.brokenSaber1 , TAG_G_ALLOC)) {
+		gi.Free (saber.brokenSaber1);
+		saber.brokenSaber1=0;
+	}
+	if (saber.brokenSaber2 && gi.bIsFromZone(saber.brokenSaber2 , TAG_G_ALLOC)) {
+		gi.Free (saber.brokenSaber2);
+		saber.brokenSaber2=0;
+	}
+}
+
+void WP_SaberSetDefaults( saberInfo_t *saber, qboolean setColors = qtrue )
+{
+	//Set defaults so that, if it fails, there's at least something there
+	saber->name = NULL;
+	saber->fullName = NULL;
+	for ( int i = 0; i < MAX_BLADES; i++ )
+	{
+		if ( setColors )
+		{
+			saber->blade[i].color = SABER_RED;
+		}
+		saber->blade[i].radius = SABER_RADIUS_STANDARD;
+		saber->blade[i].lengthMax = 32;
+	}
+	saber->model = "models/weapons2/saber_reborn/saber_w.glm";
+	saber->skin = NULL;
+	saber->soundOn = G_SoundIndex( "sound/weapons/saber/enemy_saber_on.wav" );
+	saber->soundLoop = G_SoundIndex( "sound/weapons/saber/saberhum3.wav" );
+	saber->soundOff = G_SoundIndex( "sound/weapons/saber/enemy_saber_off.wav" );
+	saber->numBlades = 1;
+	saber->type = SABER_SINGLE;
+	saber->style = SS_NONE;
+	saber->maxChain = 0;//0 = use default behavior
+	saber->lockable = qtrue;
+	saber->throwable = qtrue;
+	saber->disarmable = qtrue;
+	saber->activeBlocking = qtrue;
+	saber->twoHanded = qfalse;
+	saber->forceRestrictions = 0;
+	saber->lockBonus = 0;
+	saber->parryBonus = 0;
+	saber->breakParryBonus = 0;
+	saber->disarmBonus = 0;
+	saber->singleBladeStyle = SS_NONE;//makes it so that you use a different style if you only have the first blade active
+	saber->singleBladeThrowable = qfalse;//makes it so that you can throw this saber if only the first blade is on
+	saber->brokenSaber1 = NULL;//if saber is actually hit by another saber, it can be cut in half/broken and will be replaced with this saber in your right hand
+	saber->brokenSaber2 = NULL;//if saber is actually hit by another saber, it can be cut in half/broken and will be replaced with this saber in your left hand
+	saber->returnDamage = qfalse;//when returning from a saber throw, it keeps spinning and doing damage
+}
+
+qboolean WP_SaberParseParms( const char *SaberName, saberInfo_t *saber, qboolean setColors ) 
+{
+	const char	*token;
+	const char	*value;
+	const char	*p;
+	float	f;
+	int		n;
+
+	if ( !saber ) 
+	{
+		return qfalse;
+	}
+	
+	//Set defaults so that, if it fails, there's at least something there
+	WP_SaberSetDefaults( saber, setColors );
+
+	if ( !SaberName || !SaberName[0] ) 
+	{
+		return qfalse;
+	}
+
+	saber->name = G_NewString( SaberName );
+	//try to parse it out
+	p = SaberParms;
+	COM_BeginParseSession();
+
+	// look for the right saber
+	while ( p )
+	{
+		token = COM_ParseExt( &p, qtrue );
+		if ( token[0] == 0 )
+		{
+			return qfalse;
+		}
+
+		if ( !Q_stricmp( token, SaberName ) ) 
+		{
+			break;
+		}
+
+		SkipBracedSection( &p );
+	}
+	if ( !p ) 
+	{
+		return qfalse;
+	}
+
+	if ( G_ParseLiteral( &p, "{" ) ) 
+	{
+		return qfalse;
+	}
+		
+	// parse the saber info block
+	while ( 1 ) 
+	{
+		token = COM_ParseExt( &p, qtrue );
+		if ( !token[0] ) 
+		{
+			gi.Printf( S_COLOR_RED"ERROR: unexpected EOF while parsing '%s'\n", SaberName );
+			return qfalse;
+		}
+
+		if ( !Q_stricmp( token, "}" ) ) 
+		{
+			break;
+		}
+
+		//saber fullName
+		if ( !Q_stricmp( token, "name" ) ) 
+		{
+			if ( COM_ParseString( &p, &value ) ) 
+			{
+				continue;
+			}
+			saber->fullName = G_NewString( value );
+			continue;
+		}
+
+		//saber type
+		if ( !Q_stricmp( token, "saberType" ) ) 
+		{
+			if ( COM_ParseString( &p, &value ) ) 
+			{
+				continue;
+			}
+			int saberType = GetIDForString( SaberTable, value );
+			if ( saberType >= SABER_SINGLE && saberType <= NUM_SABERS )
+			{
+				saber->type = (saberType_t)saberType;
+			}
+			continue;
+		}
+
+		//saber hilt
+		if ( !Q_stricmp( token, "saberModel" ) ) 
+		{
+			if ( COM_ParseString( &p, &value ) ) 
+			{
+				continue;
+			}
+			saber->model = G_NewString( value );
+			continue;
+		}
+
+		if ( !Q_stricmp( token, "customSkin" ) )
+		{
+			if ( COM_ParseString( &p, &value ) ) 
+			{
+				continue;
+			}
+			saber->skin = G_NewString( value );
+			continue;
+		}
+
+		//on sound
+		if ( !Q_stricmp( token, "soundOn" ) ) 
+		{
+			if ( COM_ParseString( &p, &value ) ) 
+			{
+				continue;
+			}
+			saber->soundOn = G_SoundIndex( G_NewString( value ) );
+			continue;
+		}
+
+		//loop sound
+		if ( !Q_stricmp( token, "soundLoop" ) ) 
+		{
+			if ( COM_ParseString( &p, &value ) ) 
+			{
+				continue;
+			}
+			saber->soundLoop = G_SoundIndex( G_NewString( value ) );
+			continue;
+		}
+
+		//off sound
+		if ( !Q_stricmp( token, "soundOff" ) ) 
+		{
+			if ( COM_ParseString( &p, &value ) ) 
+			{
+				continue;
+			}
+			saber->soundOff = G_SoundIndex( G_NewString( value ) );
+			continue;
+		}
+
+		if ( !Q_stricmp( token, "numBlades" ) ) 
+		{
+			if ( COM_ParseInt( &p, &n ) ) 
+			{
+				SkipRestOfLine( &p );
+				continue;
+			}
+			if ( n < 1 || n >= MAX_BLADES )
+			{
+				G_Error( "WP_SaberParseParms: saber %s has illegal number of blades (%d) max: %d", SaberName, n, MAX_BLADES );
+				continue;
+			}
+			saber->numBlades = n;
+			continue;
+		}
+
+		// saberColor
+		if ( !Q_stricmpn( token, "saberColor", 10 ) ) 
+		{
+			if ( !setColors )
+			{//don't actually want to set the colors
+				//read the color out anyway just to advance the *p pointer
+				COM_ParseString( &p, &value );
+				continue;
+			}
+			else
+			{
+				if (strlen(token)==10)
+				{
+					n = -1;
+				}
+				else if (strlen(token)==11)
+				{
+					n = atoi(&token[10])-1;
+					if (n > 7 || n < 1 )
+					{
+						gi.Printf( S_COLOR_YELLOW"WARNING: bad saberColor '%s' in %s\n", token, SaberName );
+						//read the color out anyway just to advance the *p pointer
+						COM_ParseString( &p, &value );
+						continue;
+					}
+				}
+				else
+				{
+					gi.Printf( S_COLOR_YELLOW"WARNING: bad saberColor '%s' in %s\n", token, SaberName );
+					//read the color out anyway just to advance the *p pointer
+					COM_ParseString( &p, &value );
+					continue;
+				}
+
+				if ( COM_ParseString( &p, &value ) )	//read the color
+				{
+					continue;
+				}
+
+				if (n==-1)
+				{//NOTE: this fills in the rest of the blades with the same color by default
+					saber_colors_t color = TranslateSaberColor( value );
+					for ( n = 0; n < MAX_BLADES; n++ )
+					{
+						saber->blade[n].color = color;
+					}
+				} else 
+				{
+					saber->blade[n].color = TranslateSaberColor( value );
+				}
+				continue;
+			}
+		}
+
+		//saber length
+		if ( !Q_stricmpn( token, "saberLength", 11 ) ) 
+		{
+			if (strlen(token)==11)
+			{
+				n = -1;
+			}
+			else if (strlen(token)==12)
+			{
+				n = atoi(&token[11])-1;
+				if (n > 7 || n < 1 )
+				{
+					gi.Printf( S_COLOR_YELLOW"WARNING: bad saberLength '%s' in %s\n", token, SaberName );
+					continue;
+				}
+			}
+			else
+			{
+				gi.Printf( S_COLOR_YELLOW"WARNING: bad saberLength '%s' in %s\n", token, SaberName );
+				continue;
+			}
+
+			if ( COM_ParseFloat( &p, &f ) ) 
+			{
+				SkipRestOfLine( &p );
+				continue;
+			}
+			//cap
+			if ( f < 4.0f )
+			{
+				f = 4.0f;
+			}
+
+			if (n==-1)
+			{//NOTE: this fills in the rest of the blades with the same length by default
+				for ( n = 0; n < MAX_BLADES; n++ )
+				{
+					saber->blade[n].lengthMax = f;
+				}
+			}
+			else
+			{
+				saber->blade[n].lengthMax = f;
+			}
+			continue;
+		}
+
+		//blade radius
+		if ( !Q_stricmpn( token, "saberRadius", 11 ) ) 
+		{
+			if (strlen(token)==11)
+			{
+				n = -1;
+			}
+			else if (strlen(token)==12)
+			{
+				n = atoi(&token[11])-1;
+				if (n > 7 || n < 1 )
+				{
+					gi.Printf( S_COLOR_YELLOW"WARNING: bad saberRadius '%s' in %s\n", token, SaberName );
+					continue;
+				}
+			}
+			else
+			{
+				gi.Printf( S_COLOR_YELLOW"WARNING: bad saberRadius '%s' in %s\n", token, SaberName );
+				continue;
+			}
+
+			if ( COM_ParseFloat( &p, &f ) ) 
+			{
+				SkipRestOfLine( &p );
+				continue;
+			}
+			//cap
+			if ( f < 0.25f )
+			{
+				f = 0.25f;
+			}
+			if (n==-1)
+			{//NOTE: this fills in the rest of the blades with the same length by default
+				for ( n = 0; n < MAX_BLADES; n++ )
+				{
+					saber->blade[n].radius = f;
+				}
+			}
+			else
+			{
+				saber->blade[n].radius = f;
+			}
+			continue;
+		}
+
+		//locked saber style
+		if ( !Q_stricmp( token, "saberStyle" ) ) 
+		{
+			if ( COM_ParseString( &p, &value ) ) 
+			{
+				continue;
+			}
+			saber->style = TranslateSaberStyle( value );
+			continue;
+		}
+
+		//maxChain
+		if ( !Q_stricmp( token, "maxChain" ) ) 
+		{
+			if ( COM_ParseInt( &p, &n ) ) 
+			{
+				SkipRestOfLine( &p );
+				continue;
+			}
+			saber->maxChain = n;
+			continue;
+		}
+
+		//lockable
+		if ( !Q_stricmp( token, "lockable" ) ) 
+		{
+			if ( COM_ParseInt( &p, &n ) ) 
+			{
+				SkipRestOfLine( &p );
+				continue;
+			}
+			saber->lockable = ((qboolean)(n!=0));
+			continue;
+		}
+
+		//throwable
+		if ( !Q_stricmp( token, "throwable" ) ) 
+		{
+			if ( COM_ParseInt( &p, &n ) ) 
+			{
+				SkipRestOfLine( &p );
+				continue;
+			}
+			saber->throwable = ((qboolean)(n!=0));
+			continue;
+		}
+
+		//disarmable
+		if ( !Q_stricmp( token, "disarmable" ) ) 
+		{
+			if ( COM_ParseInt( &p, &n ) ) 
+			{
+				SkipRestOfLine( &p );
+				continue;
+			}
+			saber->disarmable = ((qboolean)(n!=0));
+			continue;
+		}
+
+		//active blocking
+		if ( !Q_stricmp( token, "blocking" ) ) 
+		{
+			if ( COM_ParseInt( &p, &n ) ) 
+			{
+				SkipRestOfLine( &p );
+				continue;
+			}
+			saber->activeBlocking = ((qboolean)(n!=0));
+			continue;
+		}
+
+		//twoHanded
+		if ( !Q_stricmp( token, "twoHanded" ) ) 
+		{
+			if ( COM_ParseInt( &p, &n ) ) 
+			{
+				SkipRestOfLine( &p );
+				continue;
+			}
+			saber->twoHanded = ((qboolean)(n!=0));
+			continue;
+		}
+
+		//force power restrictions
+		if ( !Q_stricmp( token, "forceRestrict" ) ) 
+		{
+			if ( COM_ParseString( &p, &value ) ) 
+			{
+				continue;
+			}
+			int fp = GetIDForString( FPTable, value );
+			if ( fp >= FP_FIRST && fp < NUM_FORCE_POWERS )
+			{
+				saber->forceRestrictions |= (1<<fp);
+			}
+			continue;
+		}
+
+		//lockBonus
+		if ( !Q_stricmp( token, "lockBonus" ) ) 
+		{
+			if ( COM_ParseInt( &p, &n ) ) 
+			{
+				SkipRestOfLine( &p );
+				continue;
+			}
+			saber->lockBonus = n;
+			continue;
+		}
+
+		//parryBonus
+		if ( !Q_stricmp( token, "parryBonus" ) ) 
+		{
+			if ( COM_ParseInt( &p, &n ) ) 
+			{
+				SkipRestOfLine( &p );
+				continue;
+			}
+			saber->parryBonus = n;
+			continue;
+		}
+
+		//breakParryBonus
+		if ( !Q_stricmp( token, "breakParryBonus" ) ) 
+		{
+			if ( COM_ParseInt( &p, &n ) ) 
+			{
+				SkipRestOfLine( &p );
+				continue;
+			}
+			saber->breakParryBonus = n;
+			continue;
+		}
+
+		//disarmBonus
+		if ( !Q_stricmp( token, "disarmBonus" ) ) 
+		{
+			if ( COM_ParseInt( &p, &n ) ) 
+			{
+				SkipRestOfLine( &p );
+				continue;
+			}
+			saber->disarmBonus = n;
+			continue;
+		}
+
+		//single blade saber style
+		if ( !Q_stricmp( token, "singleBladeStyle" ) ) 
+		{
+			if ( COM_ParseString( &p, &value ) ) 
+			{
+				continue;
+			}
+			saber->singleBladeStyle = TranslateSaberStyle( value );
+			continue;
+		}
+
+		//single blade throwable
+		if ( !Q_stricmp( token, "singleBladeThrowable" ) ) 
+		{
+			if ( COM_ParseInt( &p, &n ) ) 
+			{
+				SkipRestOfLine( &p );
+				continue;
+			}
+			saber->singleBladeThrowable = ((qboolean)(n!=0));
+			continue;
+		}
+
+		//broken replacement saber1 (right hand)
+		if ( !Q_stricmp( token, "brokenSaber1" ) ) 
+		{
+			if ( COM_ParseString( &p, &value ) ) 
+			{
+				continue;
+			}
+			saber->brokenSaber1 = G_NewString( value );
+			continue;
+		}
+		
+		//broken replacement saber2 (left hand)
+		if ( !Q_stricmp( token, "brokenSaber2" ) ) 
+		{
+			if ( COM_ParseString( &p, &value ) ) 
+			{
+				continue;
+			}
+			saber->brokenSaber2 = G_NewString( value );
+			continue;
+		}
+
+		//spins and does damage on return from saberthrow
+		if ( !Q_stricmp( token, "returnDamage" ) ) 
+		{
+			if ( COM_ParseInt( &p, &n ) ) 
+			{
+				SkipRestOfLine( &p );
+				continue;
+			}
+			saber->returnDamage = ((qboolean)(n!=0));
+			continue;
+		}
+
+		if ( !Q_stricmp( token, "notInMP" ) ) 
+		{//ignore this
+			SkipRestOfLine( &p );
+			continue;
+		}
+
+		gi.Printf( "WARNING: unknown keyword '%s' while parsing '%s'\n", token, SaberName );
+		SkipRestOfLine( &p );
+	}
+
+	//FIXME: precache the saberModel(s)?
+
+	if ( saber->type == SABER_SITH_SWORD )
+	{//precache all the sith sword sounds
+		Saber_SithSwordPrecache();
+	}
+
+	return qtrue;
+}
+
+void WP_RemoveSaber( gentity_t *ent, int saberNum )
+{
+	if ( !ent || !ent->client )
+	{
+		return;
+	}
+	//reset everything for this saber just in case
+	WP_SaberSetDefaults( &ent->client->ps.saber[saberNum] );
+
+	ent->client->ps.dualSabers = qfalse;
+	ent->client->ps.saber[saberNum].Deactivate();
+	ent->client->ps.saber[saberNum].SetLength( 0.0f );
+	if ( ent->weaponModel[saberNum] > 0 )
+	{
+		gi.G2API_SetSkin( &ent->ghoul2[ent->weaponModel[saberNum]], -1, 0 );
+		gi.G2API_RemoveGhoul2Model( ent->ghoul2, ent->weaponModel[saberNum] );
+		ent->weaponModel[saberNum] = -1;
+	}
+	if ( ent->client->ps.saberAnimLevel == SS_DUAL
+		|| ent->client->ps.saberAnimLevel == SS_STAFF )
+	{//change to the style to the default
+		for ( int i = SS_FAST; i < SS_NUM_SABER_STYLES; i++ )
+		{
+			if ( (ent->client->ps.saberStylesKnown&(1<<i)) )
+			{
+				ent->client->ps.saberAnimLevel = i;
+				if ( ent->s.number < MAX_CLIENTS )
+				{
+					cg.saberAnimLevelPending = ent->client->ps.saberAnimLevel; 
+				}
+				break;
+			}
+		}
+	}
+}
+
+void WP_SetSaber( gentity_t *ent, int saberNum, char *saberName )
+{
+	if ( !ent || !ent->client )
+	{
+		return;
+	}
+	if ( Q_stricmp( "none", saberName ) == 0 || Q_stricmp( "remove", saberName ) == 0 )
+	{
+		WP_RemoveSaber( ent, saberNum );
+		return;
+	}
+	if ( ent->weaponModel[saberNum] > 0 )
+	{
+		gi.G2API_RemoveGhoul2Model(ent->ghoul2, ent->weaponModel[saberNum]);
+		ent->weaponModel[saberNum] = -1;
+	}
+	WP_SaberParseParms( saberName, &ent->client->ps.saber[saberNum] );//get saber info
+	if ( ent->client->ps.saber[saberNum].style )
+	{
+		ent->client->ps.saberStylesKnown |= (1<<ent->client->ps.saber[saberNum].style);
+	}
+	if ( saberNum == 1 && ent->client->ps.saber[1].twoHanded )
+	{//not allowed to use a 2-handed saber as second saber
+		WP_RemoveSaber( ent, saberNum );
+		return;
+	}
+	G_ModelIndex( ent->client->ps.saber[saberNum].model );
+	WP_SaberInitBladeData( ent );
+	//int boltNum = ent->handRBolt;
+	if ( saberNum == 1 )
+	{
+		ent->client->ps.dualSabers = qtrue;
+		//boltNum = ent->handLBolt;
+	}
+	WP_SaberAddG2SaberModels( ent, saberNum );
+	ent->client->ps.saber[saberNum].SetLength( 0.0f );
+	ent->client->ps.saber[saberNum].Activate();
+
+	if ( ent->client->ps.saber[saberNum].style != SS_NONE )
+	{//change to the style we're supposed to be using
+		ent->client->ps.saberAnimLevel = ent->client->ps.saber[saberNum].style;
+		ent->client->ps.saberStylesKnown |= (1<<ent->client->ps.saberAnimLevel);
+		if ( ent->s.number < MAX_CLIENTS )
+		{
+			cg.saberAnimLevelPending = ent->client->ps.saberAnimLevel; 
+		}
+	}
+}
+
+void WP_SaberSetColor( gentity_t *ent, int saberNum, int bladeNum, char *colorName )
+{
+	if ( !ent || !ent->client )
+	{
+		return;
+	}
+	ent->client->ps.saber[saberNum].blade[bladeNum].color = TranslateSaberColor( colorName );
+}
+
+extern void WP_SetSaberEntModelSkin( gentity_t *ent, gentity_t *saberent );
+qboolean WP_BreakSaber( gentity_t *ent, const char *surfName, saberType_t saberType )
+{//Make sure there *is* one specified and not using dualSabers
+	if ( ent == NULL || ent->client == NULL )
+	{//invalid ent or client
+		return qfalse;
+	}
+
+	if ( ent->s.number < MAX_CLIENTS )
+	{//player
+		//if ( g_spskill->integer < 3 )
+		{//only on the hardest level?
+			//FIXME: add a cvar?
+			return qfalse;
+		}
+	}
+
+	if ( ent->health <= 0 )
+	{//not if they're dead
+		return qfalse;
+	}
+
+	if ( ent->client->ps.weapon != WP_SABER )
+	{//not holding saber
+		return qfalse;
+	}
+
+	if ( ent->client->ps.dualSabers )
+	{//FIXME: handle this?
+		return qfalse;
+	}
+
+	if ( !ent->client->ps.saber[0].brokenSaber1 ) 
+	{//not breakable into another type of saber
+		return qfalse;
+	}
+
+	if ( PM_SaberInStart( ent->client->ps.saberMove ) //in a start
+		|| PM_SaberInTransition( ent->client->ps.saberMove ) //in a transition
+		|| PM_SaberInAttack( ent->client->ps.saberMove ) )//in an attack
+	{//don't break when in the middle of an attack
+		return qfalse;
+	}
+
+	if ( Q_stricmpn( "w_", surfName, 2 ) 
+		&& Q_stricmpn( "saber_", surfName, 6 ) //hack because using mod-community made saber
+		&& Q_stricmp( "cylinder01", surfName ) )//hack because using mod-community made saber
+	{//didn't hit my weapon
+		return qfalse;
+	}
+
+	//Sith Sword should ALWAYS do this
+	if ( saberType != SABER_SITH_SWORD && Q_irand( 0, 50 ) )//&& Q_irand( 0, 10 ) )
+	{//10% chance - FIXME: extern this, too?
+		return qfalse;
+	}
+
+	//break it
+	char	*replacementSaber1 = G_NewString( ent->client->ps.saber[0].brokenSaber1 );
+	char	*replacementSaber2 = G_NewString( ent->client->ps.saber[0].brokenSaber2 );
+	int		i, originalNumBlades = ent->client->ps.saber[0].numBlades;
+	qboolean	broken = qfalse;
+	saber_colors_t	colors[MAX_BLADES];
+
+	//store the colors
+	for ( i = 0; i < MAX_BLADES; i++ )
+	{
+		colors[i] = ent->client->ps.saber[0].blade[i].color;
+	}
+
+	//FIXME: chance of dropping the right-hand one?  Based on damage, or...?
+	//FIXME: sound & effect when this happens, and send them into a broken parry?
+
+	//remove saber[0], replace with replacementSaber1
+	if ( replacementSaber1 )
+	{
+		WP_RemoveSaber( ent, 0 );
+		WP_SetSaber( ent, 0, replacementSaber1 );
+		for ( i = 0; i < ent->client->ps.saber[0].numBlades; i++ )
+		{
+			ent->client->ps.saber[0].blade[i].color = colors[i];
+		}
+		broken = qtrue;
+		//change my saberent's model and skin to match my new right-hand saber
+		WP_SetSaberEntModelSkin( ent, &g_entities[ent->client->ps.saberEntityNum] );
+	}
+
+	if ( originalNumBlades <= 1 ) 
+	{//nothing to split off
+		//FIXME: handle this?
+	}
+	else
+	{
+		//remove saber[1], replace with replacementSaber2
+		if ( replacementSaber2 )
+		{//FIXME: 25% chance that it just breaks - just spawn the second saber piece and toss it away immediately, can't be picked up.
+			//shouldn't be one in this hand, but just in case, remove it
+			WP_RemoveSaber( ent, 1 );
+			WP_SetSaber( ent, 1, replacementSaber2 );
+
+			//put the remainder of the original saber's blade colors onto this saber's blade(s)
+			for ( i = ent->client->ps.saber[0].numBlades; i < MAX_BLADES; i++ )
+			{
+				ent->client->ps.saber[1].blade[i-ent->client->ps.saber[0].numBlades].color = colors[i];
+			}
+			broken = qtrue;
+		}
+	}
+	return broken;
+}
+
+void WP_SaberLoadParms( void ) 
+{
+	int			len, totallen, saberExtFNLen, fileCnt, i;
+	char		*buffer, *holdChar, *marker;
+	char		saberExtensionListBuf[2048];			//	The list of file names read in
+
+	//gi.Printf( "Parsing *.sab saber definitions\n" );
+
+	//set where to store the first one
+	totallen = 0;
+	marker = SaberParms;
+	marker[0] = '\0';
+
+	//now load in the .sab definitions
+	fileCnt = gi.FS_GetFileList("ext_data/sabers", ".sab", saberExtensionListBuf, sizeof(saberExtensionListBuf) );
+
+	holdChar = saberExtensionListBuf;
+	for ( i = 0; i < fileCnt; i++, holdChar += saberExtFNLen + 1 ) 
+	{
+		saberExtFNLen = strlen( holdChar );
+
+		len = gi.FS_ReadFile( va( "ext_data/sabers/%s", holdChar), (void **) &buffer );
+
+		if ( len == -1 ) 
+		{
+			gi.Printf( "WP_SaberLoadParms: error reading %s\n", holdChar );
+		}
+		else
+		{
+			if ( totallen && *(marker-1) == '}' )
+			{//don't let it end on a } because that should be a stand-alone token
+				strcat( marker, " " );
+				totallen++;
+				marker++; 
+			}
+			len = COM_Compress( buffer );
+
+			if ( totallen + len >= MAX_SABER_DATA_SIZE ) {
+				G_Error( "WP_SaberLoadParms: ran out of space before reading %s\n(you must make the .npc files smaller)", holdChar  );
+			}
+			strcat( marker, buffer );
+			gi.FS_FreeFile( buffer );
+
+			totallen += len;
+			marker += len;
+		}
+	}
+}
diff --git a/code/ghoul2/G2.h b/code/ghoul2/G2.h
new file mode 100644
index 0000000..b029095
--- /dev/null
+++ b/code/ghoul2/G2.h
@@ -0,0 +1,201 @@
+#pragma once
+#if !defined(G2_H_INC)
+#define G2_H_INC
+
+class CMiniHeap;
+
+// defines to setup the
+#define		ENTITY_WIDTH 12
+#define		MODEL_WIDTH	10
+#define		BOLT_WIDTH	10
+ 
+#define		MODEL_AND	((1<<MODEL_WIDTH)-1)
+#define		BOLT_AND	((1<<BOLT_WIDTH)-1)
+#define		ENTITY_AND	((1<<ENTITY_WIDTH)-1)
+
+#define		BOLT_SHIFT	0
+#define		MODEL_SHIFT	(BOLT_SHIFT + BOLT_WIDTH)
+#define		ENTITY_SHIFT (MODEL_SHIFT + MODEL_WIDTH)
+
+//rww - RAGDOLL_BEGIN
+class CRagDollUpdateParams;
+//rww - RAGDOLL_END
+
+struct model_s;
+// internal surface calls  G2_surfaces.cpp
+qboolean	G2_SetSurfaceOnOff (CGhoul2Info *ghlInfo, const char *surfaceName, const int offFlags);
+qboolean	G2_SetRootSurface( CGhoul2Info_v &ghoul2, const int modelIndex,const char *surfaceName);
+int			G2_AddSurface(CGhoul2Info *ghoul2, int surfaceNumber, int polyNumber, float BarycentricI, float BarycentricJ, int lod );
+qboolean	G2_RemoveSurface(surfaceInfo_v &slist, const int index);
+const surfaceInfo_t *G2_FindOverrideSurface(int surfaceNum, const surfaceInfo_v &surfaceList);
+int			G2_IsSurfaceLegal(const model_s *, const char *surfaceName, int *flags);
+int			G2_GetParentSurface(CGhoul2Info *ghlInfo, const int index);
+int			G2_GetSurfaceIndex(CGhoul2Info *ghlInfo, const char *surfaceName);
+int			G2_IsSurfaceRendered(CGhoul2Info *ghlInfo, const char *surfaceName, surfaceInfo_v &slist);
+
+// internal bone calls - G2_Bones.cpp
+qboolean	G2_Set_Bone_Angles(CGhoul2Info *ghlInfo, boneInfo_v &blist, const char *boneName, const float *angles, const int flags,
+							   const Eorientations up, const Eorientations left, const Eorientations forward,
+							   const int blendTime, const int currentTime);
+qboolean	G2_Remove_Bone (CGhoul2Info *ghlInfo, boneInfo_v &blist, const char *boneName);
+qboolean	G2_Remove_Bone_Index (boneInfo_v &blist, int index);
+qboolean	G2_Set_Bone_Anim(CGhoul2Info *ghlInfo, boneInfo_v &blist, const char *boneName, const int startFrame, 
+							 const int endFrame, const int flags, const float animSpeed, const int currentTime, const float setFrame, const int blendTime);
+qboolean	G2_Get_Bone_Anim(CGhoul2Info *ghlInfo, boneInfo_v &blist, const char *boneName, const int currentTime, 
+						  float *currentFrame, int *startFrame, int *endFrame, int *flags, float *retAnimSpeed);
+qboolean	G2_Get_Bone_Anim_Range(CGhoul2Info *ghlInfo, boneInfo_v &blist, const char *boneName, int *startFrame, int *endFrame);
+qboolean	G2_Get_Bone_Anim_Range_Index(boneInfo_v &blist, const int boneIndex, int *startFrame, int *endFrame);
+qboolean	G2_Pause_Bone_Anim(CGhoul2Info *ghlInfo, boneInfo_v &blist, const char *boneName, const int currentTime);
+qboolean	G2_Pause_Bone_Anim_Index(boneInfo_v &blist, const int boneIndex, const int currentTime,int numFrames );
+qboolean	G2_IsPaused(CGhoul2Info *ghlInfo, boneInfo_v &blist, const char *boneName);
+qboolean	G2_Stop_Bone_Anim(CGhoul2Info *ghlInfo, boneInfo_v &blist, const char *boneName);
+qboolean	G2_Stop_Bone_Angles(CGhoul2Info *ghlInfo, boneInfo_v &blist, const char *boneName);
+//rww - RAGDOLL_BEGIN
+void		G2_Animate_Bone_List(CGhoul2Info_v &ghoul2, const int currentTime, const int index,CRagDollUpdateParams *params);
+//rww - RAGDOLL_END
+
+void		G2_Init_Bone_List(boneInfo_v &blist);
+int			G2_Find_Bone_In_List(boneInfo_v &blist, const int boneNum);
+qboolean	G2_Set_Bone_Angles_Matrix(CGhoul2Info *ghlInfo, boneInfo_v &blist, const char *boneName, const mdxaBone_t &matrix,
+									  const int flags, const int blendTime, const int currentTime);
+int			G2_Get_Bone_Index(CGhoul2Info *ghoul2, const char *boneName, qboolean bAddIfNotFound);
+qboolean	G2_Set_Bone_Angles_Index(CGhoul2Info *ghlInfo, boneInfo_v &blist, const int index,
+							const float *angles, const int flags, const Eorientations yaw,
+							const Eorientations pitch, const Eorientations roll,
+							const int blendTime, const int currentTime);
+qboolean	G2_Set_Bone_Angles_Matrix_Index(boneInfo_v &blist, const int index,
+								   const mdxaBone_t &matrix, const int flags, 
+								   const int blendTime, const int currentTime);
+qboolean	G2_Stop_Bone_Anim_Index(boneInfo_v &blist, const int index);
+qboolean	G2_Stop_Bone_Angles_Index(boneInfo_v &blist, const int index);
+qboolean	G2_Set_Bone_Anim_Index(boneInfo_v &blist, const int index, const int startFrame, 
+						  const int endFrame, const int flags, const float animSpeed, const int currentTime, const float setFrame, const int blendTime,int numFrames);
+qboolean	G2_Get_Bone_Anim_Index( boneInfo_v &blist, const int index, const int currentTime, 
+						  float *currentFrame, int *startFrame, int *endFrame, int *flags, float *retAnimSpeed,int numFrames);
+
+// misc functions G2_misc.cpp
+void		G2_List_Model_Surfaces(const char *fileName);
+void		G2_List_Model_Bones(const char *fileName, int frame);
+qboolean	G2_GetAnimFileName(const char *fileName, char **filename);
+#ifdef _G2_GORE
+void		G2_TraceModels(CGhoul2Info_v &ghoul2, vec3_t rayStart, vec3_t rayEnd, CCollisionRecord *collRecMap, int entNum, EG2_Collision eG2TraceType, int useLod, float fRadius, float ssize,float tsize,float theta,int shader, SSkinGoreData *gore);
+#else
+void		G2_TraceModels(CGhoul2Info_v &ghoul2, vec3_t rayStart, vec3_t rayEnd, CCollisionRecord *collRecMap, int entNum, EG2_Collision eG2TraceType, int useLod, float fRadius);
+#endif
+void		TransformAndTranslatePoint (const vec3_t in, vec3_t out, mdxaBone_t *mat);
+#ifdef _G2_GORE
+void		G2_TransformModel(CGhoul2Info_v &ghoul2, const int frameNum, vec3_t scale, CMiniHeap *G2VertSpace, int useLod, bool ApplyGore);
+#else
+void		G2_TransformModel(CGhoul2Info_v &ghoul2, const int frameNum, vec3_t scale, CMiniHeap *G2VertSpace, int useLod);
+#endif
+void		G2_GenerateWorldMatrix(const vec3_t angles, const vec3_t origin);
+void		TransformPoint (const vec3_t in, vec3_t out, mdxaBone_t *mat);
+void		Inverse_Matrix(mdxaBone_t *src, mdxaBone_t *dest);
+void		*G2_FindSurface(const model_s *, int index, int lod);
+void		G2_SaveGhoul2Models(CGhoul2Info_v &ghoul2);
+void		G2_LoadGhoul2Model(CGhoul2Info_v &ghoul2, char *buffer);
+
+// internal bolt calls. G2_bolts.cpp
+int			G2_Add_Bolt(CGhoul2Info *ghlInfo, boltInfo_v &bltlist, surfaceInfo_v &slist, const char *boneName);
+qboolean	G2_Remove_Bolt (boltInfo_v &bltlist, int index);
+void		G2_Init_Bolt_List(boltInfo_v &bltlist);
+int			G2_Find_Bolt_Bone_Num(boltInfo_v &bltlist, const int boneNum);
+int			G2_Find_Bolt_Surface_Num(boltInfo_v &bltlist, const int surfaceNum, const int flags);
+int			G2_Add_Bolt_Surf_Num(CGhoul2Info *ghlInfo, boltInfo_v &bltlist, surfaceInfo_v &slist, const int surfNum);
+
+
+// API calls - G2_API.cpp
+qhandle_t	G2API_PrecacheGhoul2Model(const char *fileName);
+
+int			G2API_InitGhoul2Model(CGhoul2Info_v &ghoul2, const char *fileName, int modelIndex, qhandle_t customSkin = NULL,
+								  qhandle_t customShader = NULL, int modelFlags = 0, int lodBias = 0);
+qboolean	G2API_SetLodBias(CGhoul2Info *ghlInfo, int lodBias);
+qboolean	G2API_SetSkin(CGhoul2Info *ghlInfo, qhandle_t customSkin, qhandle_t renderSkin = 0);
+qboolean	G2API_SetShader(CGhoul2Info *ghlInfo, qhandle_t customShader);
+qboolean	G2API_RemoveGhoul2Model(CGhoul2Info_v &ghlInfo, const int modelIndex);
+qboolean	G2API_SetSurfaceOnOff(CGhoul2Info *ghlInfo, const char *surfaceName, const int flags);
+qboolean	G2API_SetRootSurface(CGhoul2Info_v &ghlInfo, const int modelIndex, const char *surfaceName);
+qboolean	G2API_RemoveSurface(CGhoul2Info *ghlInfo, const int index);
+int			G2API_AddSurface(CGhoul2Info *ghlInfo, int surfaceNumber, int polyNumber, float BarycentricI, float BarycentricJ, int lod );
+qboolean	G2API_SetBoneAnim(CGhoul2Info *ghlInfo, const char *boneName, const int startFrame, const int endFrame,
+							  const int flags, const float animSpeed, const int currentTime, const float setFrame = -1, const int blendTime = -1);
+qboolean	G2API_GetBoneAnim(CGhoul2Info *ghlInfo, const char *boneName, const int currentTime, float *currentFrame,
+							  int *startFrame, int *endFrame, int *flags, float *animSpeed, qhandle_t *modelList);
+qboolean	G2API_GetBoneAnimIndex(CGhoul2Info *ghlInfo, const int iBoneIndex, const int currentTime, float *currentFrame,
+							  int *startFrame, int *endFrame, int *flags, float *animSpeed, qhandle_t *modelList);
+qboolean	G2API_GetAnimRange(CGhoul2Info *ghlInfo, const char *boneName,	int *startFrame, int *endFrame);
+qboolean	G2API_GetAnimRangeIndex(CGhoul2Info *ghlInfo, const int boneIndex,	int *startFrame, int *endFrame);
+qboolean	G2API_PauseBoneAnim(CGhoul2Info *ghlInfo, const char *boneName, const int currentTime);
+qboolean	G2API_PauseBoneAnimIndex(CGhoul2Info *ghlInfo, const int boneIndex, const int currentTime);
+qboolean	G2API_IsPaused(CGhoul2Info *ghlInfo, const char *boneName);
+qboolean	G2API_StopBoneAnim(CGhoul2Info *ghlInfo, const char *boneName);
+qboolean	G2API_SetBoneAngles(CGhoul2Info *ghlInfo, const char *boneName, const vec3_t angles, const int flags,
+								const Eorientations up, const Eorientations right, const Eorientations forward, qhandle_t *modelList,
+								int blendTime = 0, int currentTime = 0);
+qboolean	G2API_StopBoneAngles(CGhoul2Info *ghlInfo, const char *boneName);
+qboolean	G2API_RemoveBone(CGhoul2Info *ghlInfo, const char *boneName);
+qboolean	G2API_RemoveBolt(CGhoul2Info *ghlInfo, const int index);
+int			G2API_AddBolt(CGhoul2Info *ghlInfo, const char *boneName);
+int			G2API_AddBoltSurfNum(CGhoul2Info *ghlInfo, const int surfIndex);
+qboolean	G2API_AttachG2Model(CGhoul2Info *ghlInfo, CGhoul2Info *ghlInfoTo, int toBoltIndex, int toModel);
+qboolean	G2API_DetachG2Model(CGhoul2Info *ghlInfo);
+qboolean	G2API_AttachEnt(int *boltInfo, CGhoul2Info *ghlInfoTo, int toBoltIndex, int entNum, int toModelNum);
+void		G2API_DetachEnt(int *boltInfo);
+
+qboolean	G2API_GetBoltMatrix(CGhoul2Info_v &ghoul2, const int modelIndex, const int boltIndex, mdxaBone_t *matrix,
+								const vec3_t angles, const vec3_t position, const int frameNum, qhandle_t *modelList, const vec3_t scale);
+
+void		G2API_ListSurfaces(CGhoul2Info *ghlInfo);
+void		G2API_ListBones(CGhoul2Info *ghlInfo, int frame);
+qboolean	G2API_HaveWeGhoul2Models(CGhoul2Info_v &ghoul2);
+void		G2API_SetGhoul2ModelIndexes(CGhoul2Info_v &ghoul2, qhandle_t *modelList, qhandle_t *skinList);
+qboolean	G2API_SetGhoul2ModelFlags(CGhoul2Info *ghlInfo, const int flags);
+int			G2API_GetGhoul2ModelFlags(CGhoul2Info *ghlInfo);
+
+qboolean	G2API_GetAnimFileName(CGhoul2Info *ghlInfo, char **filename);
+void		G2API_CollisionDetect(CCollisionRecord *collRecMap, CGhoul2Info_v &ghoul2, const vec3_t angles, const vec3_t position,
+									int frameNumber, int entNum, vec3_t rayStart, vec3_t rayEnd, vec3_t scale, CMiniHeap *G2VertSpace,
+									EG2_Collision eG2TraceType, int useLod, float fRadius);
+void		G2API_GiveMeVectorFromMatrix(mdxaBone_t &boltMatrix, Eorientations flags, vec3_t &vec);
+void		G2API_CopyGhoul2Instance(CGhoul2Info_v &Ghoul2From, CGhoul2Info_v &Ghoul2To, int modelIndex = -1);
+void		G2API_CleanGhoul2Models(CGhoul2Info_v &ghoul2);
+int			G2API_GetParentSurface(CGhoul2Info *ghlInfo, const int index);
+int			G2API_GetSurfaceIndex(CGhoul2Info *ghlInfo, const char *surfaceName);
+char		*G2API_GetSurfaceName(CGhoul2Info *ghlInfo, int surfNumber);
+char		*G2API_GetGLAName(CGhoul2Info *ghlInfo);
+qboolean	G2API_SetBoneAnglesMatrix(CGhoul2Info *ghlInfo, const char *boneName, const mdxaBone_t &matrix, const int flags,
+									  qhandle_t *modelList, int blendTime = 0, int currentTime = 0);
+qboolean	G2API_SetNewOrigin(CGhoul2Info *ghlInfo, const int boltIndex);
+int			G2API_GetBoneIndex(CGhoul2Info *ghlInfo, const char *boneName, qboolean bAddIfNotFound);
+qboolean	G2API_StopBoneAnglesIndex(CGhoul2Info *ghlInfo, const int index);
+qboolean	G2API_StopBoneAnimIndex(CGhoul2Info *ghlInfo, const int index);
+qboolean	G2API_SetBoneAnglesIndex(CGhoul2Info *ghlInfo, const int index, const vec3_t angles, const int flags,
+							 const Eorientations yaw, const Eorientations pitch, const Eorientations roll,
+							 qhandle_t *modelList, int blendTime, int currentTime);
+qboolean	G2API_SetBoneAnglesMatrixIndex(CGhoul2Info *ghlInfo, const int index, const mdxaBone_t &matrix,
+								   const int flags, qhandle_t *modelList, int blendTime, int currentTime);
+qboolean	G2API_SetBoneAnimIndex(CGhoul2Info *ghlInfo, const int index, const int startFrame, const int endFrame, const int flags, const float animSpeed, const int currentTime, const float setFrame, const int blendTime);
+qboolean	G2API_SetAnimIndex(CGhoul2Info *ghlInfo, const int index);
+int			G2API_GetAnimIndex(CGhoul2Info *ghlInfo);
+void		G2API_SaveGhoul2Models(CGhoul2Info_v &ghoul2);
+void		G2API_LoadGhoul2Models(CGhoul2Info_v &ghoul2, char *buffer);
+void		G2API_LoadSaveCodeDestructGhoul2Info(CGhoul2Info_v &ghoul2);
+char		*G2API_GetAnimFileNameIndex(qhandle_t modelIndex);
+char		*G2API_GetAnimFileInternalNameIndex(qhandle_t modelIndex);
+int			G2API_GetSurfaceRenderStatus(CGhoul2Info *ghlInfo, const char *surfaceName);
+
+// From tr_ghoul2.cpp
+void		G2_ConstructGhoulSkeleton( CGhoul2Info_v &ghoul2,const int frameNum,bool checkForNewOrigin,const vec3_t scale);
+void		G2_GetBoltMatrixLow(CGhoul2Info &ghoul2,int boltNum,const vec3_t scale,mdxaBone_t &retMatrix);
+void		G2_TimingModel(boneInfo_t &bone,int time,int numFramesInFile,int &currentFrame,int &newFrame,float &lerp);
+
+
+bool G2_SetupModelPointers(CGhoul2Info_v &ghoul2); // returns true if any model is properly set up
+bool G2_SetupModelPointers(CGhoul2Info *ghlInfo); // returns true if the model is properly set up
+
+//#ifdef _G2_GORE	// These exist regardless, non-gore versions are empty
+void		G2API_AddSkinGore(CGhoul2Info_v &ghoul2,SSkinGoreData &gore);
+void		G2API_ClearSkinGore ( CGhoul2Info_v &ghoul2 );
+//#endif
+
+#endif // G2_H_INC
\ No newline at end of file
diff --git a/code/ghoul2/G2_API.cpp b/code/ghoul2/G2_API.cpp
new file mode 100644
index 0000000..17d62c7
--- /dev/null
+++ b/code/ghoul2/G2_API.cpp
@@ -0,0 +1,2145 @@
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+#pragma warning( disable : 4786) 
+#pragma warning( disable : 4100) 
+#pragma warning( disable : 4511) 
+
+#pragma warning (push, 3)	//go back down to 3 for the stl include
+#include <list>
+#include <string>
+#pragma warning (pop)
+
+#ifndef __Q_SHARED_H
+	#include "../game/q_shared.h"
+#endif
+
+#if !defined(TR_LOCAL_H)
+	#include "../renderer/tr_local.h"
+#endif
+
+#if !defined(G2_H_INC)
+	#include "G2.h"
+#endif
+
+#if !defined(MINIHEAP_H_INC)
+	#include "..\qcommon\MiniHeap.h"
+#endif
+
+
+#ifdef FINAL_BUILD
+#define G2API_DEBUG (0) // please don't change this
+#else
+#if defined(_DEBUG) && !defined(_XBOX)
+#define G2API_DEBUG (1)
+#else
+#define G2API_DEBUG (0) // change this to test g2api in release
+#endif 
+#endif
+
+//rww - RAGDOLL_BEGIN
+#include "ghoul2_gore.h"
+//rww - RAGDOLL_END
+
+using namespace std;
+
+extern mdxaBone_t		worldMatrix;
+extern mdxaBone_t		worldMatrixInv;
+
+extern	cvar_t	*r_Ghoul2TimeBase;
+
+#define G2_MODEL_OK(g) ((g)&&(g)->mValid&&(g)->aHeader&&(g)->currentModel&&(g)->animModel)
+
+
+#define G2_DEBUG_TIME (0)
+
+static int G2TimeBases[NUM_G2T_TIME];
+
+bool G2_TestModelPointers(CGhoul2Info *ghlInfo);
+
+#if G2API_DEBUG
+#include <float.h> //for isnan
+
+
+#define MAX_ERROR_PRINTS (3)
+class ErrorReporter
+{
+	string mName;
+	map<string,int> mErrors;
+public:
+	ErrorReporter(const string &name) :
+	  mName(name)
+	{
+	}
+	~ErrorReporter()
+	{
+		char mess[1000];
+		int total=0;
+		sprintf(mess,"****** %s Error Report Begin******\n",mName.c_str());
+		OutputDebugString(mess);
+
+		map<string,int>::iterator i;
+		for (i=mErrors.begin();i!=mErrors.end();i++)
+		{
+			total+=(*i).second;
+			sprintf(mess,"%s (hits %d)\n",(*i).first.c_str(),(*i).second);
+			OutputDebugString(mess);
+		}
+		
+		sprintf(mess,"****** %s Error Report End   %d errors of %d kinds******\n",mName.c_str(),total,mErrors.size());
+		OutputDebugString(mess);
+	}
+	int AnimTest(CGhoul2Info_v &ghoul2,const char *m,const char *, int line)
+	{
+		if (G2_SetupModelPointers(ghoul2))
+		{
+			int i;
+			for (i=0; i<ghoul2.size(); i++)
+			{
+				AnimTest(&ghoul2[i],m,0,line);
+			}
+			return i;
+		}
+		return 666; //these return values are to saisfy the optimizer
+	}
+	int AnimTest(CGhoul2Info *ghlInfo,const char *m,const char *, int line)
+	{
+		bool ok=G2_TestModelPointers(ghlInfo);
+		if (!ok)
+		{
+			return 5; // I guess this happens from time to time
+		}
+		int i,ret=0;
+
+		char GLAName1[1000];
+		char GLAName2[1000];
+		char GLMName1[1000];
+		char GLMName2[1000];
+
+		strcpy(GLAName1,ghlInfo->animModel->name);
+		strcpy(GLAName2,ghlInfo->aHeader->name);
+		strcpy(GLMName1,ghlInfo->mFileName);
+		strcpy(GLMName2,ghlInfo->currentModel->name);
+
+		int numFramesInFile=ghlInfo->aHeader->numFrames;
+
+		int numActiveBones=0;
+		for (i=0;i<ghlInfo->mBlist.size();i++)
+		{
+			if (ghlInfo->mBlist[i].boneNumber!=-1) // slot used?
+			{
+				if (ghlInfo->mBlist[i].flags&BONE_ANIM_TOTAL) // anim on this?
+				{
+					numActiveBones++;
+					bool loop=!!(ghlInfo->mBlist[i].flags&BONE_ANIM_OVERRIDE_LOOP);
+					bool not_loop=!!(ghlInfo->mBlist[i].flags&BONE_ANIM_OVERRIDE);
+
+					if (loop==not_loop)
+					{
+						Error("Unusual animation flags, should have some sort of override, but not both",1,0,line);
+					}
+
+					bool freeze=(ghlInfo->mBlist[i].flags&BONE_ANIM_OVERRIDE_FREEZE) == BONE_ANIM_OVERRIDE_FREEZE;
+
+					if (loop&&freeze)
+					{
+						Error("Unusual animation flags, loop and freeze",1,0,line);
+					}
+					bool no_lerp=!!(ghlInfo->mBlist[i].flags&BONE_ANIM_NO_LERP);
+					bool blend=!!(ghlInfo->mBlist[i].flags&BONE_ANIM_BLEND);
+				
+					
+					//comments according to jake
+					int			startFrame=ghlInfo->mBlist[i].startFrame;		// start frame for animation
+					int			endFrame=ghlInfo->mBlist[i].endFrame;		// end frame for animation NOTE anim actually ends on endFrame+1
+					int			startTime=ghlInfo->mBlist[i].startTime;		// time we started this animation
+					int			pauseTime=ghlInfo->mBlist[i].pauseTime;		// time we paused this animation - 0 if not paused
+					float		animSpeed=ghlInfo->mBlist[i].animSpeed;		// speed at which this anim runs. 1.0f means full speed of animation incoming - ie if anim is 20hrtz, we run at 20hrts. If 5hrts, we run at 5 hrts
+
+					float		blendFrame=0.0f;		// frame PLUS LERP value to blend 
+					int			blendLerpFrame=0;	// frame to lerp the blend frame with.
+
+					if (blend)
+					{
+						blendFrame=ghlInfo->mBlist[i].blendFrame;
+						blendLerpFrame=ghlInfo->mBlist[i].blendLerpFrame;
+						if (floor(blendFrame)<0.0f)
+						{
+							Error("negative blendFrame",1,0,line);
+						}
+						if (ceil(blendFrame)>=float(numFramesInFile))
+						{
+							Error("blendFrame >= numFramesInFile",1,0,line);
+						}
+						if (blendLerpFrame<0)
+						{
+							Error("negative blendLerpFrame",1,0,line);
+						}
+						if (blendLerpFrame>=numFramesInFile)
+						{
+							Error("blendLerpFrame >= numFramesInFile",1,0,line);
+						}
+					}
+					if (startFrame<0)
+					{
+						Error("negative startFrame",1,0,line);
+					}
+					if (startFrame>=numFramesInFile)
+					{
+						Error("startFrame >= numFramesInFile",1,0,line);
+					}
+					if (endFrame<0)
+					{
+						Error("negative endFrame",1,0,line);
+					}
+					if (endFrame==0&&animSpeed>0.0f)
+					{
+						Error("Zero endFrame",1,0,line);
+					}
+					if (endFrame>numFramesInFile)
+					{
+						Error("endFrame > numFramesInFile",1,0,line);
+					}
+					// mikeg call out here for further checks.
+					ret=(int)startTime+(int)pauseTime+(int)no_lerp; // quiet VC.
+				}
+			}
+		}
+		return ret;
+	}
+	int Error(const char *m,int kind,const char *, int line)
+	{
+		char mess[1000];
+		assert(m);
+		string full=mName;
+		if (kind==2)
+		{
+			full+=":NOTE:     ";
+		}
+		else if (kind==1)
+		{
+//			assert(!"G2API Warning");
+			full+=":WARNING:  ";
+		}
+		else
+		{
+//			assert(!"G2API Error");
+			full+=":ERROR  :  ";
+		}
+		full+=m;
+		sprintf(mess,"  [line %d]",line);
+		full+=mess;
+
+		// assert(0);
+		int ret=0; //place a breakpoint here
+		map<string,int>::iterator f=mErrors.find(full);
+		if (f==mErrors.end())
+		{
+			ret++; // or a breakpoint here for the first occurance
+			mErrors.insert(pair<string,int>(full,0));
+			f=mErrors.find(full);
+		}
+		assert(f!=mErrors.end());
+		(*f).second++;
+		if ((*f).second==1000)
+		{
+			ret*=-1; // breakpoint to find a specific occurance of an error
+		}
+		if ((*f).second<=MAX_ERROR_PRINTS&&kind<2)
+		{
+			Com_Printf("%s (hit # %d)\n",full.c_str(),(*f).second);
+			if (1)
+			{
+				sprintf(mess,"%s (hit # %d)\n",full.c_str(),(*f).second);
+				OutputDebugString(mess);
+			}
+		}
+		return ret;
+	}
+};
+
+#include "assert.h"
+ErrorReporter &G2APIError()
+{
+	static ErrorReporter singleton("G2API");
+	return singleton;
+}
+
+#define G2ERROR(exp,m) (void)( (exp) || (G2APIError().Error(m,0,__FILE__,__LINE__), 0) )
+#define G2WARNING(exp,m) (void)( (exp) || (G2APIError().Error(m,1,__FILE__,__LINE__), 0) )
+#define G2NOTE(exp,m) (void)( (exp) || (G2APIError().Error(m,2,__FILE__,__LINE__), 0) )
+#define G2ANIM(ghlInfo,m) (void)((G2APIError().AnimTest(ghlInfo,m,__FILE__,__LINE__), 0) )
+#else
+
+#define G2ERROR(exp,m)		((void)0)
+#define G2WARNING(exp,m)     ((void)0)
+#define G2NOTE(exp,m)     ((void)0)
+#define G2ANIM(ghlInfo,m) ((void)0)
+
+#endif
+
+#ifdef _DEBUG
+void G2_Bone_Not_Found(const char *boneName,const char *modName)
+{
+	G2ERROR(boneName,"NULL Bone Name");
+	G2ERROR(boneName[0],"Empty Bone Name");
+	if (boneName)
+	{
+		G2NOTE(0,va("Bone Not Found (%s:%s)",boneName,modName));
+	}
+}
+
+void G2_Bolt_Not_Found(const char *boneName,const char *modName)
+{
+	G2ERROR(boneName,"NULL Bolt/Bone Name");
+	G2ERROR(boneName[0],"Empty Bolt/Bone Name");
+	if (boneName)
+	{
+		G2NOTE(0,va("Bolt/Bone Not Found (%s:%s)",boneName,modName));
+	}
+}
+#endif
+
+void G2API_SetTime(int currentTime,int clock)
+{
+	assert(clock>=0&&clock<NUM_G2T_TIME);
+#if G2_DEBUG_TIME
+	Com_Printf("Set Time: before c%6d  s%6d",G2TimeBases[1],G2TimeBases[0]);
+#endif
+	G2TimeBases[clock]=currentTime;
+	if (G2TimeBases[1]>G2TimeBases[0]+200)
+	{
+		G2TimeBases[1]=0; // use server time instead
+		return;
+	}
+#if G2_DEBUG_TIME
+	Com_Printf(" after c%6d  s%6d\n",G2TimeBases[1],G2TimeBases[0]);
+#endif
+}
+
+int	G2API_GetTime(int argTime) // this may or may not return arg depending on ghoul2_time cvar
+{
+	int ret=G2TimeBases[1];
+	if ( !ret )
+	{
+		ret = G2TimeBases[0];
+	}
+	return ret;
+}
+
+
+// must be a power of two
+#define MAX_G2_MODELS (512)
+#define G2_MODEL_BITS (9)
+#define G2_INDEX_MASK (MAX_G2_MODELS-1)
+
+void RemoveBoneCache(CBoneCache *boneCache);
+
+class Ghoul2InfoArray : public IGhoul2InfoArray
+{
+	vector<CGhoul2Info>	mInfos[MAX_G2_MODELS];
+	int					mIds[MAX_G2_MODELS];
+	list<int>			mFreeIndecies;
+	void DeleteLow(int idx)
+	{
+		{
+			int				model;
+			for (model=0; model< mInfos[idx].size(); model++)
+			{
+				RemoveBoneCache(mInfos[idx][model].mBoneCache);
+				mInfos[idx][model].mBoneCache=0;
+			}
+		}
+		mInfos[idx].clear();
+
+		if ((mIds[idx]>>G2_MODEL_BITS)>(1<<(31-G2_MODEL_BITS)))
+		{
+			mIds[idx]=MAX_G2_MODELS+idx; //rollover reset id to minimum value
+			mFreeIndecies.push_back(idx);
+		}
+		else
+		{
+			mIds[idx]+=MAX_G2_MODELS;
+			mFreeIndecies.push_front(idx);
+		}
+	}
+public:
+	Ghoul2InfoArray()
+	{
+		int i;
+		for (i=0;i<MAX_G2_MODELS;i++)
+		{
+			mIds[i]=MAX_G2_MODELS+i;
+			mFreeIndecies.push_back(i);
+		}
+	}
+	~Ghoul2InfoArray()
+	{
+		if (mFreeIndecies.size()<MAX_G2_MODELS)
+		{
+#if G2API_DEBUG
+			char mess[1000];
+			sprintf(mess,"************************\nLeaked %d ghoul2info slots\n", MAX_G2_MODELS - mFreeIndecies.size());
+			OutputDebugString(mess);
+#endif
+			int i;
+			for (i=0;i<MAX_G2_MODELS;i++)
+			{
+				list<int>::iterator j;
+				for (j=mFreeIndecies.begin();j!=mFreeIndecies.end();j++)
+				{
+					if (*j==i)
+						break;
+				}
+				if (j==mFreeIndecies.end())
+				{
+#if G2API_DEBUG
+					sprintf(mess,"Leaked Info idx=%d id=%d sz=%d\n", i, mIds[i], mInfos[i].size());
+					OutputDebugString(mess);
+					if (mInfos[i].size())
+					{
+						sprintf(mess,"%s\n", mInfos[i][0].mFileName);
+						OutputDebugString(mess);
+					}
+#endif
+					DeleteLow(i);
+				}
+			}
+		}
+#if G2API_DEBUG
+		else
+		{
+			OutputDebugString("No ghoul2 info slots leaked\n");
+		}
+#endif
+	}
+
+#ifdef _XBOX
+	// I'm sorry, but I really don't trust this thing any other way.
+	void Clear()
+	{
+		mFreeIndecies.clear();
+		for (int i=0;i<MAX_G2_MODELS;i++)
+		{
+			mInfos[i].clear();
+		}
+	}
+	
+	void Reset()
+	{
+		for (int i=0;i<MAX_G2_MODELS;i++)
+		{
+			mIds[i]=MAX_G2_MODELS+i;
+			mFreeIndecies.push_back(i);
+		}
+	}
+#endif
+
+	int New()
+	{
+		if (mFreeIndecies.empty())
+		{
+			assert(0);
+			Com_Error(ERR_FATAL, "Out of ghoul2 info slots");
+
+		}
+		// gonna pull from the front, doing a 
+		int idx=*mFreeIndecies.begin();
+		mFreeIndecies.erase(mFreeIndecies.begin());
+		return mIds[idx];
+	}
+	bool IsValid(int handle) const
+	{
+		if (!handle)
+		{
+			return false;
+		}
+		assert(handle>0); //negative handle???
+		assert((handle&G2_INDEX_MASK)>=0&&(handle&G2_INDEX_MASK)<MAX_G2_MODELS); //junk handle
+		if (mIds[handle&G2_INDEX_MASK]!=handle) // not a valid handle, could be old
+		{
+			return false;
+		}
+		return true;
+	}
+	void Delete(int handle)
+	{
+		if (!handle)
+		{
+			return;
+		}
+		assert(handle>0); //null handle
+		assert((handle&G2_INDEX_MASK)>=0&&(handle&G2_INDEX_MASK)<MAX_G2_MODELS); //junk handle
+		assert(mIds[handle&G2_INDEX_MASK]==handle); // not a valid handle, could be old or garbage
+		if (mIds[handle&G2_INDEX_MASK]==handle)
+		{
+			DeleteLow(handle&G2_INDEX_MASK);
+		}
+	}
+	vector<CGhoul2Info> &Get(int handle)
+	{
+		static vector<CGhoul2Info> null;
+		assert(handle>0); //null handle
+		assert((handle&G2_INDEX_MASK)>=0&&(handle&G2_INDEX_MASK)<MAX_G2_MODELS); //junk handle
+		assert(mIds[handle&G2_INDEX_MASK]==handle); // not a valid handle, could be old or garbage
+		if (handle<=0||(handle&G2_INDEX_MASK)<0||(handle&G2_INDEX_MASK)>=MAX_G2_MODELS||mIds[handle&G2_INDEX_MASK]!=handle)
+		{
+			null.clear();
+			return null;
+		}
+		return mInfos[handle&G2_INDEX_MASK];
+	}
+	const vector<CGhoul2Info> &Get(int handle) const
+	{
+		assert(handle>0);
+		assert(mIds[handle&G2_INDEX_MASK]==handle); // not a valid handle, could be old or garbage
+		return mInfos[handle&G2_INDEX_MASK];
+	}
+
+#if G2API_DEBUG
+	vector<CGhoul2Info> &GetDebug(int handle)
+	{
+		static vector<CGhoul2Info> null;
+		if (handle<=0||(handle&G2_INDEX_MASK)<0||(handle&G2_INDEX_MASK)>=MAX_G2_MODELS||mIds[handle&G2_INDEX_MASK]!=handle)
+		{
+			return *(vector<CGhoul2Info> *)0; // null reference, intentional
+		}
+		return mInfos[handle&G2_INDEX_MASK];
+	}
+	void TestAllAnims()
+	{
+		int j;
+		for (j=0;j<MAX_G2_MODELS;j++)
+		{
+			vector<CGhoul2Info> &ghoul2=mInfos[j];
+			int i;
+			for (i=0; i<ghoul2.size(); i++)
+			{
+				if (G2_SetupModelPointers(&ghoul2[i]))
+				{
+					G2ANIM(&ghoul2[i],"Test All");
+				}
+			}
+		}
+	}
+
+#endif
+};
+
+
+IGhoul2InfoArray &TheGhoul2InfoArray()
+{
+	static Ghoul2InfoArray singleton;
+	return singleton;
+}
+
+#ifdef _XBOX
+void Ghoul2InfoArray_Free(void)
+{
+	((Ghoul2InfoArray *)(&TheGhoul2InfoArray()))->Clear();
+}
+
+void Ghoul2InfoArray_Reset(void)
+{
+	((Ghoul2InfoArray *)(&TheGhoul2InfoArray()))->Reset();
+}
+#endif
+
+#if G2API_DEBUG
+vector<CGhoul2Info> &DebugG2Info(int handle)
+{
+	return ((Ghoul2InfoArray *)(&TheGhoul2InfoArray()))->GetDebug(handle);
+}
+
+CGhoul2Info &DebugG2InfoI(int handle,int item)
+{
+	return ((Ghoul2InfoArray *)(&TheGhoul2InfoArray()))->GetDebug(handle)[item];
+}
+
+void TestAllGhoul2Anims()
+{
+	((Ghoul2InfoArray *)(&TheGhoul2InfoArray()))->TestAllAnims();
+}
+
+#endif
+
+
+
+
+// this is the ONLY function to read entity states directly
+void G2API_CleanGhoul2Models(CGhoul2Info_v &ghoul2)
+{
+#ifdef _G2_GORE
+	G2API_ClearSkinGore ( ghoul2 );
+#endif
+	ghoul2.~CGhoul2Info_v();	
+}
+
+qhandle_t G2API_PrecacheGhoul2Model(const char *fileName)
+{
+	return RE_RegisterModel((char *)fileName);
+}
+
+// initialise all that needs to be on a new Ghoul II model
+int G2API_InitGhoul2Model(CGhoul2Info_v &ghoul2, const char *fileName, int, qhandle_t customSkin,
+						  qhandle_t customShader, int modelFlags, int lodBias)
+{
+	int				model = -1;
+
+	G2ERROR(fileName&&fileName[0],"NULL filename");
+
+	if (!fileName||!fileName[0])
+	{
+		assert(fileName[0]);
+		return -1;
+	}
+
+	// find a free spot in the list
+	for (model=0; model< ghoul2.size(); model++)
+	{
+		if (ghoul2[model].mModelindex == -1)
+		{
+			ghoul2[model]=CGhoul2Info();
+			break;
+		}
+	}
+	if (model==ghoul2.size())
+	{
+		assert(model < 8);	//arb, just catching run-away models
+		CGhoul2Info info;
+		strcpy(info.mFileName, fileName);
+		info.mModelindex = 0;
+		if(G2_TestModelPointers(&info)) {
+		ghoul2.push_back(CGhoul2Info());
+		} else {
+			return -1;
+		}
+	}
+
+	strcpy(ghoul2[model].mFileName, fileName);
+	ghoul2[model].mModelindex = model;
+	if (!G2_TestModelPointers(&ghoul2[model]))
+	{
+		ghoul2[model].mFileName[0]=0;
+		ghoul2[model].mModelindex = -1;
+	}
+	else
+	{
+		G2_Init_Bone_List(ghoul2[model].mBlist);
+		G2_Init_Bolt_List(ghoul2[model].mBltlist);
+		ghoul2[model].mCustomShader = customShader;
+		ghoul2[model].mCustomSkin = customSkin;
+		ghoul2[model].mLodBias = lodBias;
+		ghoul2[model].mAnimFrameDefault = 0;
+		ghoul2[model].mFlags = 0;
+
+		ghoul2[model].mModelBoltLink = -1;
+	}
+	return ghoul2[model].mModelindex;
+}
+
+qboolean G2API_SetLodBias(CGhoul2Info *ghlInfo, int lodBias)
+{
+	G2ERROR(ghlInfo,"NULL ghlInfo");
+	if (ghlInfo)
+	{
+		ghlInfo->mLodBias = lodBias;
+		return qtrue;
+	}
+	return qfalse;
+}
+
+qboolean G2API_SetSkin(CGhoul2Info *ghlInfo, qhandle_t customSkin, qhandle_t renderSkin)
+{
+	G2ERROR(ghlInfo,"NULL ghlInfo");
+	if (ghlInfo)
+	{
+		ghlInfo->mCustomSkin = customSkin;
+		if (renderSkin)
+		{//this is going to set the surfs on/off matching the skin file
+extern void G2API_SetSurfaceOnOffFromSkin (CGhoul2Info *ghlInfo, qhandle_t renderSkin);	//tr_ghoul2.cpp
+			G2API_SetSurfaceOnOffFromSkin( ghlInfo, renderSkin );
+		}
+		return qtrue;
+	}
+	return qfalse;
+}
+
+qboolean G2API_SetShader(CGhoul2Info *ghlInfo, qhandle_t customShader)
+{
+	G2ERROR(ghlInfo,"NULL ghlInfo");
+	if (ghlInfo)
+	{
+		ghlInfo->mCustomShader = customShader;
+		return qtrue;
+	}
+	return qfalse;
+}
+
+qboolean G2API_SetSurfaceOnOff(CGhoul2Info *ghlInfo, const char *surfaceName, const int flags)
+{
+	if (G2_SetupModelPointers(ghlInfo))
+	{
+		G2ERROR(!(flags&~(G2SURFACEFLAG_OFF | G2SURFACEFLAG_NODESCENDANTS)),"G2API_SetSurfaceOnOff Illegal Flags");
+		// ensure we flush the cache
+		ghlInfo->mMeshFrameNum = 0;
+		return G2_SetSurfaceOnOff(ghlInfo, surfaceName, flags);
+	}
+	return qfalse;
+}
+
+
+qboolean G2API_SetRootSurface(CGhoul2Info_v &ghlInfo, const int modelIndex, const char *surfaceName)
+{
+	G2ERROR(ghlInfo.IsValid(),"Invalid ghlInfo");
+	G2ERROR(surfaceName,"Invalid surfaceName");
+	if (G2_SetupModelPointers(ghlInfo))
+	{
+		G2ERROR(modelIndex>=0&&modelIndex<ghlInfo.size(),"Bad Model Index");
+		if (modelIndex>=0&&modelIndex<ghlInfo.size())
+		{
+			return G2_SetRootSurface(ghlInfo, modelIndex,  surfaceName);
+		}
+	}
+	return qfalse;
+}
+
+int G2API_AddSurface(CGhoul2Info *ghlInfo, int surfaceNumber, int polyNumber, float BarycentricI, float BarycentricJ, int lod )
+{
+	if (G2_SetupModelPointers(ghlInfo))
+	{
+		// ensure we flush the cache
+		ghlInfo->mMeshFrameNum = 0;
+		return G2_AddSurface(ghlInfo, surfaceNumber, polyNumber, BarycentricI, BarycentricJ, lod);
+	}
+	return -1;
+}
+
+qboolean G2API_RemoveSurface(CGhoul2Info *ghlInfo, const int index)
+{
+	if (G2_SetupModelPointers(ghlInfo))
+	{
+		// ensure we flush the cache
+		ghlInfo->mMeshFrameNum = 0;
+		return G2_RemoveSurface(ghlInfo->mSlist, index);
+	}
+	return qfalse;
+}
+
+int G2API_GetParentSurface(CGhoul2Info *ghlInfo, const int index)
+{
+	if (G2_SetupModelPointers(ghlInfo))
+	{
+		return G2_GetParentSurface(ghlInfo, index);
+	}
+	return -1;
+}
+
+int G2API_GetSurfaceRenderStatus(CGhoul2Info *ghlInfo, const char *surfaceName)
+{
+	G2ERROR(surfaceName,"Invalid surfaceName");
+	if (G2_SetupModelPointers(ghlInfo))
+	{
+		return G2_IsSurfaceRendered(ghlInfo, surfaceName, ghlInfo->mSlist);
+	}
+	return -1;
+}
+
+qboolean G2API_RemoveGhoul2Model(CGhoul2Info_v &ghlInfo, const int modelIndex)
+{
+	// sanity check
+	if (!ghlInfo.size() || (ghlInfo.size() <= modelIndex) || modelIndex < 0 || (ghlInfo[modelIndex].mModelindex <0))
+	{
+		// if we hit this assert then we are trying to delete a ghoul2 model on a ghoul2 instance that
+		// one way or another is already gone.
+		G2ERROR(0,"Remove Nonexistant Model");
+		assert(0 && "remove non existing model");
+		return qfalse;
+	}
+
+#ifdef _G2_GORE
+	// Cleanup the gore attached to this model
+	if ( ghlInfo[modelIndex].mGoreSetTag )
+	{
+		DeleteGoreSet ( ghlInfo[modelIndex].mGoreSetTag );
+		ghlInfo[modelIndex].mGoreSetTag = 0;
+	}
+#endif
+
+	RemoveBoneCache(ghlInfo[modelIndex].mBoneCache);
+	ghlInfo[modelIndex].mBoneCache=0;
+
+	 // set us to be the 'not active' state
+	ghlInfo[modelIndex].mModelindex = -1;
+	ghlInfo[modelIndex].mFileName[0]=0;
+
+	ghlInfo[modelIndex]=CGhoul2Info();
+	return qtrue;
+}
+
+//rww - RAGDOLL_BEGIN
+#define		GHOUL2_RAG_STARTED						0x0010
+#define		GHOUL2_RAG_FORCESOLVE					0x1000		//api-override, determine if ragdoll should be forced to continue solving even if it thinks it is settled
+//rww - RAGDOLL_END
+
+int		 G2API_GetAnimIndex(CGhoul2Info *ghlInfo)
+{
+	if (ghlInfo)
+	{
+		return ghlInfo->animModelIndexOffset;
+	}
+	return 0;
+}
+
+qboolean G2API_SetAnimIndex(CGhoul2Info *ghlInfo, const int index)
+{
+	// Is This A Valid G2 Model?
+	//---------------------------
+	if (ghlInfo)
+	{
+		// Is This A New Anim Index?
+		//---------------------------
+		if (ghlInfo->animModelIndexOffset != index)
+		{
+			ghlInfo->animModelIndexOffset = index;
+			ghlInfo->currentAnimModelSize = 0;					// Clear anim size so SetupModelPointers recalcs
+
+//			RemoveBoneCache(ghlInfo[0].mBoneCache);
+//			ghlInfo[0].mBoneCache=0;
+			
+			// Kill All Existing Animation, Blending, Etc.
+			//---------------------------------------------
+			for (int index=0; index<ghlInfo->mBlist.size(); index++)
+			{
+				ghlInfo->mBlist[index].flags &= ~(BONE_ANIM_TOTAL);
+				ghlInfo->mBlist[index].flags &= ~(BONE_ANGLES_TOTAL);
+//				G2_Remove_Bone_Index(ghlInfo->mBlist, index);
+			}
+		}		
+		return qtrue;
+	}
+	return qfalse;
+}
+
+qboolean G2API_SetBoneAnimIndex(CGhoul2Info *ghlInfo, const int index, const int startFrame, const int endFrame, const int flags, const float animSpeed, const int AcurrentTime, const float setFrame, const int blendTime)
+{
+	//rww - RAGDOLL_BEGIN
+	if (ghlInfo && (ghlInfo->mFlags & GHOUL2_RAG_STARTED))
+	{
+		return qfalse;
+	}
+	//rww - RAGDOLL_END
+
+	qboolean ret=qfalse;
+	if (G2_SetupModelPointers(ghlInfo))
+	{
+		G2ERROR(startFrame>=0,"startframe<0");
+		G2ERROR(startFrame<ghlInfo->aHeader->numFrames,"startframe>=numframes");
+		G2ERROR(endFrame>0,"endframe<=0");
+		G2ERROR(endFrame<=ghlInfo->aHeader->numFrames,"endframe>numframes");
+		G2ERROR(setFrame<ghlInfo->aHeader->numFrames,"setframe>=numframes");
+		G2ERROR(setFrame==-1.0f||setFrame>=0.0f,"setframe<0 but not -1");
+		if (startFrame<0||startFrame>=ghlInfo->aHeader->numFrames)
+		{
+			*(int *)&startFrame=0; // cast away const
+		}
+		if (endFrame<=0||endFrame>ghlInfo->aHeader->numFrames)
+		{
+			*(int *)&endFrame=1;
+		}
+		if (setFrame!=-1.0f&&(setFrame<0.0f||setFrame>=(float)ghlInfo->aHeader->numFrames))
+		{
+			*(float *)&setFrame=0.0f;
+		}
+		ghlInfo->mSkelFrameNum = 0;
+		G2ERROR(index>=0&&index<ghlInfo->mBlist.size(),va("Out of Range Bone Index (%s)",ghlInfo->mFileName));
+		if (index>=0&&index<ghlInfo->mBlist.size())
+		{
+			G2ERROR(ghlInfo->mBlist[index].boneNumber>=0,va("Bone Index is not Active (%s)",ghlInfo->mFileName));
+			int currentTime=G2API_GetTime(AcurrentTime);
+#if 0
+			/*
+			if ( ge->ValidateAnimRange( startFrame, endFrame, animSpeed ) == -1 )
+			{
+				int wtf = 1;
+			}
+			*/
+#endif
+ 			ret=G2_Set_Bone_Anim_Index(ghlInfo->mBlist, index, startFrame, endFrame, flags, animSpeed, currentTime, setFrame, blendTime,ghlInfo->aHeader->numFrames);
+			G2ANIM(ghlInfo,"G2API_SetBoneAnimIndex");
+		}
+	}
+	G2WARNING(ret,va("G2API_SetBoneAnimIndex Failed (%s)",ghlInfo->mFileName));
+	return ret;
+}
+
+qboolean G2API_SetBoneAnim(CGhoul2Info *ghlInfo, const char *boneName, const int startFrame, const int endFrame, const int flags, const float animSpeed, const int AcurrentTime, const float setFrame, const int blendTime)
+{
+	//rww - RAGDOLL_BEGIN
+	if (ghlInfo && ghlInfo->mFlags & GHOUL2_RAG_STARTED)
+	{
+		return qfalse;
+	}
+	//rww - RAGDOLL_END
+
+	qboolean ret=qfalse;
+	G2ERROR(boneName,"NULL boneName");
+	if (boneName&&G2_SetupModelPointers(ghlInfo))
+	{
+		G2ERROR(startFrame>=0,"startframe<0");
+		G2ERROR(startFrame<ghlInfo->aHeader->numFrames,"startframe>=numframes");
+		G2ERROR(endFrame>0,"endframe<=0");
+		G2ERROR(endFrame<=ghlInfo->aHeader->numFrames,"endframe>numframes");
+		G2ERROR(setFrame<ghlInfo->aHeader->numFrames,"setframe>=numframes");
+		G2ERROR(setFrame==-1.0f||setFrame>=0.0f,"setframe<0 but not -1");
+		if (startFrame<0||startFrame>=ghlInfo->aHeader->numFrames)
+		{
+			*(int *)&startFrame=0; // cast away const
+		}
+		if (endFrame<=0||endFrame>ghlInfo->aHeader->numFrames)
+		{
+			*(int *)&endFrame=1;
+		}
+		if (setFrame!=-1.0f&&(setFrame<0.0f||setFrame>=(float)ghlInfo->aHeader->numFrames))
+		{
+			*(float *)&setFrame=0.0f;
+		}
+		ghlInfo->mSkelFrameNum = 0;
+		int currentTime=G2API_GetTime(AcurrentTime);
+ 		ret=G2_Set_Bone_Anim(ghlInfo, ghlInfo->mBlist, boneName, startFrame, endFrame, flags, animSpeed, currentTime, setFrame, blendTime);
+		G2ANIM(ghlInfo,"G2API_SetBoneAnim");
+	}
+	G2WARNING(ret,"G2API_SetBoneAnim Failed");
+	return ret;
+}
+
+qboolean G2API_GetBoneAnim(CGhoul2Info *ghlInfo, const char *boneName, const int AcurrentTime, float *currentFrame,
+						   int *startFrame, int *endFrame, int *flags, float *animSpeed, int *)
+{
+	qboolean ret=qfalse;
+	G2ERROR(boneName,"NULL boneName");
+	if (G2_SetupModelPointers(ghlInfo))
+	{
+		int currentTime=G2API_GetTime(AcurrentTime);
+ 		ret=G2_Get_Bone_Anim(ghlInfo, ghlInfo->mBlist, boneName, currentTime, currentFrame,
+			startFrame, endFrame, flags, animSpeed);
+	}
+	G2WARNING(ret,"G2API_GetBoneAnim Failed");
+	return ret;
+}
+
+qboolean G2API_GetBoneAnimIndex(CGhoul2Info *ghlInfo, const int iBoneIndex, const int AcurrentTime, float *currentFrame,
+						   int *startFrame, int *endFrame, int *flags, float *animSpeed, int *)
+{
+	qboolean ret=qfalse;
+	if (G2_SetupModelPointers(ghlInfo))
+	{
+		int currentTime=G2API_GetTime(AcurrentTime);
+		G2NOTE(iBoneIndex>=0&&iBoneIndex<ghlInfo->mBlist.size(),va("Bad Bone Index (%d:%s)",iBoneIndex,ghlInfo->mFileName));
+		if (iBoneIndex>=0&&iBoneIndex<ghlInfo->mBlist.size())
+		{
+			G2NOTE(ghlInfo->mBlist[iBoneIndex].flags & (BONE_ANIM_OVERRIDE_LOOP | BONE_ANIM_OVERRIDE),"GetBoneAnim on non-animating bone.");
+			if ((ghlInfo->mBlist[iBoneIndex].flags & (BONE_ANIM_OVERRIDE_LOOP | BONE_ANIM_OVERRIDE)))
+			{
+				int sf,ef;
+				ret=G2_Get_Bone_Anim_Index(	ghlInfo->mBlist,// boneInfo_v &blist, 
+											iBoneIndex,		// const int index, 
+											currentTime,	// const int currentTime, 
+											currentFrame,	// float *currentFrame,
+											&sf,		// int *startFrame, 
+											&ef,		// int *endFrame, 
+											flags,			// int *flags, 
+											animSpeed,		// float *retAnimSpeed,
+											ghlInfo->aHeader->numFrames
+											);
+				G2ERROR(sf>=0,"returning startframe<0");
+				G2ERROR(sf<ghlInfo->aHeader->numFrames,"returning startframe>=numframes");
+				G2ERROR(ef>0,"returning endframe<=0");
+				G2ERROR(ef<=ghlInfo->aHeader->numFrames,"returning endframe>numframes");
+				if (currentFrame)
+				{
+					G2ERROR(*currentFrame>=0.0f,"returning currentframe<0");
+					G2ERROR(((int)(*currentFrame))<ghlInfo->aHeader->numFrames,"returning currentframe>=numframes");
+				}
+				if (endFrame)
+				{
+					*endFrame=ef;
+				}
+				if (startFrame)
+				{
+					*startFrame=sf;
+				}
+				G2ANIM(ghlInfo,"G2API_GetBoneAnimIndex");
+			}
+		}
+	}
+	if (!ret)
+	{
+		*endFrame=1;
+		*startFrame=0;
+		*flags=0;
+		*currentFrame=0.0f;
+		*animSpeed=1.0f;
+	}
+	G2NOTE(ret,"G2API_GetBoneAnimIndex Failed");
+	return ret;
+}
+
+qboolean G2API_GetAnimRange(CGhoul2Info *ghlInfo, const char *boneName,	int *startFrame, int *endFrame)
+{
+	qboolean ret=qfalse;
+	G2ERROR(boneName,"NULL boneName");
+	if (boneName&&G2_SetupModelPointers(ghlInfo))
+	{
+ 		ret=G2_Get_Bone_Anim_Range(ghlInfo, ghlInfo->mBlist, boneName, startFrame, endFrame);
+		G2ANIM(ghlInfo,"G2API_GetAnimRange");
+	}
+//	looks like the game checks the return value
+//	G2WARNING(ret,"G2API_GetAnimRange Failed");
+	return ret;
+}
+
+qboolean G2API_GetAnimRangeIndex(CGhoul2Info *ghlInfo, const int boneIndex, int *startFrame, int *endFrame)
+{
+	qboolean ret=qfalse;
+	if (G2_SetupModelPointers(ghlInfo))
+	{
+		G2ERROR(boneIndex>=0&&boneIndex<ghlInfo->mBlist.size(),"Bad Bone Index");
+		if (boneIndex>=0&&boneIndex<ghlInfo->mBlist.size())
+		{
+ 			ret=G2_Get_Bone_Anim_Range_Index(ghlInfo->mBlist, boneIndex, startFrame, endFrame);
+			G2ANIM(ghlInfo,"G2API_GetAnimRange");
+		}
+	}
+//	looks like the game checks the return value
+//	G2WARNING(ret,"G2API_GetAnimRangeIndex Failed");
+	return ret;
+}
+
+qboolean G2API_PauseBoneAnim(CGhoul2Info *ghlInfo, const char *boneName, const int AcurrentTime)
+{
+	qboolean ret=qfalse;
+	G2ERROR(boneName,"NULL boneName");
+	if (boneName&&G2_SetupModelPointers(ghlInfo))
+	{
+		int currentTime=G2API_GetTime(AcurrentTime);
+ 		ret=G2_Pause_Bone_Anim(ghlInfo, ghlInfo->mBlist, boneName, currentTime);
+		G2ANIM(ghlInfo,"G2API_PauseBoneAnim");
+	}
+	G2NOTE(ret,"G2API_PauseBoneAnim Failed");
+	return ret;
+}
+
+qboolean G2API_PauseBoneAnimIndex(CGhoul2Info *ghlInfo, const int boneIndex, const int AcurrentTime)
+{
+	qboolean ret=qfalse;
+	if (G2_SetupModelPointers(ghlInfo))
+	{
+		int currentTime=G2API_GetTime(AcurrentTime);
+		G2ERROR(boneIndex>=0&&boneIndex<ghlInfo->mBlist.size(),"Bad Bone Index");
+		if (boneIndex>=0&&boneIndex<ghlInfo->mBlist.size())
+		{
+	 		ret=G2_Pause_Bone_Anim_Index(ghlInfo->mBlist, boneIndex, currentTime,ghlInfo->aHeader->numFrames);
+			G2ANIM(ghlInfo,"G2API_PauseBoneAnimIndex");
+		}
+	}
+	G2WARNING(ret,"G2API_PauseBoneAnimIndex Failed");
+	return ret;
+}
+
+qboolean	G2API_IsPaused(CGhoul2Info *ghlInfo, const char *boneName)
+{
+	qboolean ret=qfalse;
+	G2ERROR(boneName,"NULL boneName");
+	if (boneName&&G2_SetupModelPointers(ghlInfo))
+	{
+ 		ret=G2_IsPaused(ghlInfo, ghlInfo->mBlist, boneName);
+	}
+	G2WARNING(ret,"G2API_IsPaused Failed");
+	return ret;
+}
+
+qboolean G2API_StopBoneAnimIndex(CGhoul2Info *ghlInfo, const int index)
+{
+	qboolean ret=qfalse;
+	G2ERROR(ghlInfo,"NULL ghlInfo");
+	if (G2_SetupModelPointers(ghlInfo))
+	{
+		G2ERROR(index>=0&&index<ghlInfo->mBlist.size(),"Bad Bone Index");
+		if (index>=0&&index<ghlInfo->mBlist.size())
+		{
+ 			ret=G2_Stop_Bone_Anim_Index(ghlInfo->mBlist, index);
+			G2ANIM(ghlInfo,"G2API_StopBoneAnimIndex");
+		}
+	}
+	//G2WARNING(ret,"G2API_StopBoneAnimIndex Failed");
+	return ret;
+}
+
+qboolean G2API_StopBoneAnim(CGhoul2Info *ghlInfo, const char *boneName)
+{
+	qboolean ret=qfalse;
+	G2ERROR(boneName,"NULL boneName");
+	if (boneName&&G2_SetupModelPointers(ghlInfo))
+	{
+ 		ret=G2_Stop_Bone_Anim(ghlInfo, ghlInfo->mBlist, boneName);
+		G2ANIM(ghlInfo,"G2API_StopBoneAnim");
+	}
+	G2WARNING(ret,"G2API_StopBoneAnim Failed");
+	return ret;
+}
+
+qboolean G2API_SetBoneAnglesIndex(CGhoul2Info *ghlInfo, const int index, const vec3_t angles, const int flags,
+							 const Eorientations yaw, const Eorientations pitch, const Eorientations roll,
+							 qhandle_t *, int blendTime, int AcurrentTime)
+{
+	//rww - RAGDOLL_BEGIN
+	if (ghlInfo && ghlInfo->mFlags & GHOUL2_RAG_STARTED)
+	{
+		return qfalse;
+	}
+	//rww - RAGDOLL_END
+
+	qboolean ret=qfalse;
+	if (G2_SetupModelPointers(ghlInfo))
+	{
+		int currentTime=G2API_GetTime(AcurrentTime);
+		// ensure we flush the cache
+		ghlInfo->mSkelFrameNum = 0;
+		G2ERROR(index>=0&&index<ghlInfo->mBlist.size(),"G2API_SetBoneAnglesIndex:Invalid bone index");
+		if (index>=0&&index<ghlInfo->mBlist.size())
+		{
+			ret=G2_Set_Bone_Angles_Index(ghlInfo, ghlInfo->mBlist, index, angles, flags, yaw, pitch, roll,blendTime, currentTime);
+		}
+	}
+	G2WARNING(ret,"G2API_SetBoneAnglesIndex Failed");
+	return ret;
+}
+
+qboolean G2API_SetBoneAngles(CGhoul2Info *ghlInfo, const char *boneName, const vec3_t angles, const int flags,
+							 const Eorientations up, const Eorientations left, const Eorientations forward,
+							 qhandle_t *, int blendTime, int AcurrentTime )
+{
+	//rww - RAGDOLL_BEGIN
+	if (ghlInfo && ghlInfo->mFlags & GHOUL2_RAG_STARTED)
+	{
+		return qfalse;
+	}
+	//rww - RAGDOLL_END
+
+	qboolean ret=qfalse;
+	G2ERROR(boneName,"NULL boneName");
+	if (boneName&&G2_SetupModelPointers(ghlInfo))
+	{
+		int currentTime=G2API_GetTime(AcurrentTime);
+			// ensure we flush the cache
+		ghlInfo->mSkelFrameNum = 0;
+		ret=G2_Set_Bone_Angles(ghlInfo, ghlInfo->mBlist, boneName, angles, flags, up, left, forward, blendTime, currentTime);
+	}
+	G2WARNING(ret,"G2API_SetBoneAngles Failed");
+	return ret;
+}
+
+qboolean G2API_SetBoneAnglesMatrixIndex(CGhoul2Info *ghlInfo, const int index, const mdxaBone_t &matrix,
+								   const int flags, qhandle_t *, int blendTime, int AcurrentTime)
+{
+	qboolean ret=qfalse;
+	if (G2_SetupModelPointers(ghlInfo))
+	{
+		int currentTime=G2API_GetTime(AcurrentTime);
+		// ensure we flush the cache
+		ghlInfo->mSkelFrameNum = 0;
+		G2ERROR(index>=0&&index<ghlInfo->mBlist.size(),"Bad Bone Index");
+		if (index>=0&&index<ghlInfo->mBlist.size())
+		{
+			ret=G2_Set_Bone_Angles_Matrix_Index(ghlInfo->mBlist, index, matrix, flags, blendTime, currentTime);
+		}
+	}
+	G2WARNING(ret,"G2API_SetBoneAnglesMatrixIndex Failed");
+	return ret;
+}
+
+qboolean G2API_SetBoneAnglesMatrix(CGhoul2Info *ghlInfo, const char *boneName, const mdxaBone_t &matrix,
+								   const int flags, qhandle_t *modelList, int blendTime, int AcurrentTime)
+{
+	qboolean ret=qfalse;
+	G2ERROR(boneName,"NULL boneName");
+	if (boneName&&G2_SetupModelPointers(ghlInfo))
+	{
+		int currentTime=G2API_GetTime(AcurrentTime);
+		// ensure we flush the cache
+		ghlInfo->mSkelFrameNum = 0;
+		ret=G2_Set_Bone_Angles_Matrix(ghlInfo, ghlInfo->mBlist, boneName, matrix, flags, blendTime, currentTime);
+	}
+	G2WARNING(ret,"G2API_SetBoneAnglesMatrix Failed");
+	return ret;
+}
+
+qboolean G2API_StopBoneAnglesIndex(CGhoul2Info *ghlInfo, const int index)
+{
+	qboolean ret=qfalse;
+	if (G2_SetupModelPointers(ghlInfo))
+	{
+		// ensure we flush the cache
+		ghlInfo->mSkelFrameNum = 0;
+		G2ERROR(index>=0&&index<ghlInfo->mBlist.size(),"Bad Bone Index");
+		if (index>=0&&index<ghlInfo->mBlist.size())
+		{
+	 		ret=G2_Stop_Bone_Angles_Index(ghlInfo->mBlist, index);
+		}
+	}
+	G2WARNING(ret,"G2API_StopBoneAnglesIndex Failed");
+	return ret;
+}
+
+qboolean G2API_StopBoneAngles(CGhoul2Info *ghlInfo, const char *boneName)
+{
+	qboolean ret=qfalse;
+	G2ERROR(boneName,"NULL boneName");
+	if (boneName&&G2_SetupModelPointers(ghlInfo))
+	{
+		// ensure we flush the cache
+		ghlInfo->mSkelFrameNum = 0;
+ 		ret=G2_Stop_Bone_Angles(ghlInfo, ghlInfo->mBlist, boneName);
+	}
+	G2WARNING(ret,"G2API_StopBoneAngles Failed");
+	return ret;
+}
+
+//rww - RAGDOLL_BEGIN
+class CRagDollParams;
+void G2_SetRagDoll(CGhoul2Info_v &ghoul2V,CRagDollParams *parms);
+void G2API_SetRagDoll(CGhoul2Info_v &ghoul2,CRagDollParams *parms)
+{
+	G2_SetRagDoll(ghoul2,parms);
+}
+//rww - RAGDOLL_END
+
+qboolean G2API_RemoveBone(CGhoul2Info *ghlInfo, const char *boneName)
+{
+	qboolean ret=qfalse;
+	G2ERROR(boneName,"NULL boneName");
+	if (boneName&&G2_SetupModelPointers(ghlInfo))
+	{
+		// ensure we flush the cache
+		ghlInfo->mSkelFrameNum = 0;
+ 		ret=G2_Remove_Bone(ghlInfo, ghlInfo->mBlist, boneName);
+		G2ANIM(ghlInfo,"G2API_RemoveBone");
+	}
+	G2WARNING(ret,"G2API_RemoveBone Failed");
+	return ret;
+}
+
+//rww - RAGDOLL_BEGIN
+#ifdef _DEBUG
+extern int ragTraceTime;
+extern int ragSSCount;
+extern int ragTraceCount;
+#endif
+
+void G2API_AnimateG2Models(CGhoul2Info_v &ghoul2, int AcurrentTime,CRagDollUpdateParams *params)
+{
+	int model;
+	int currentTime=G2API_GetTime(AcurrentTime);
+
+#ifdef _DEBUG
+	ragTraceTime = 0;
+	ragSSCount = 0;
+	ragTraceCount = 0;
+#endif
+
+	// Walk the list and find all models that are active
+	for (model = 0; model < ghoul2.size(); model++)
+	{
+		if (ghoul2[model].mModel)
+		{
+			G2_Animate_Bone_List(ghoul2,currentTime,model,params);	
+		}
+	}
+#ifdef _DEBUG
+//	Com_Printf("Rag trace time: %i (%i STARTSOLID, %i TOTAL)\n", ragTraceTime, ragSSCount, ragTraceCount);
+
+//	assert(ragTraceTime < 15);
+	//assert(ragTraceCount < 600);
+#endif
+}
+//rww - RAGDOLL_END
+
+int G2_Find_Bone_Rag(CGhoul2Info *ghlInfo, boneInfo_v &blist, const char *boneName);
+#define RAG_PCJ						(0x00001)
+#define RAG_EFFECTOR				(0x00100)
+
+static inline boneInfo_t *G2_GetRagBoneConveniently(CGhoul2Info_v &ghoul2, const char *boneName)
+{
+	assert(ghoul2.size());
+	CGhoul2Info *ghlInfo = &ghoul2[0];
+
+	if (!(ghlInfo->mFlags & GHOUL2_RAG_STARTED))
+	{ //can't do this if not in ragdoll
+		return NULL;
+	}
+
+	int boneIndex = G2_Find_Bone_Rag(ghlInfo, ghlInfo->mBlist, boneName);
+
+	if (boneIndex < 0)
+	{ //bad bone specification
+		return NULL;
+	}
+
+	boneInfo_t *bone = &ghlInfo->mBlist[boneIndex];
+
+	if (!(bone->flags & BONE_ANGLES_RAGDOLL))
+	{ //only want to return rag bones
+		return NULL;
+	}
+
+	return bone;
+}
+
+qboolean G2API_RagPCJConstraint(CGhoul2Info_v &ghoul2, const char *boneName, vec3_t min, vec3_t max)
+{
+	boneInfo_t *bone = G2_GetRagBoneConveniently(ghoul2, boneName);
+
+	if (!bone)
+	{
+		return qfalse;
+	}
+
+	if (!(bone->RagFlags & RAG_PCJ))
+	{ //this function is only for PCJ bones
+		return qfalse;
+	}
+
+	VectorCopy(min, bone->minAngles);
+	VectorCopy(max, bone->maxAngles);
+
+	return qtrue;
+}
+
+qboolean G2API_RagPCJGradientSpeed(CGhoul2Info_v &ghoul2, const char *boneName, const float speed)
+{
+	boneInfo_t *bone = G2_GetRagBoneConveniently(ghoul2, boneName);
+
+	if (!bone)
+	{
+		return qfalse;
+	}
+
+	if (!(bone->RagFlags & RAG_PCJ))
+	{ //this function is only for PCJ bones
+		return qfalse;
+	}
+
+	bone->overGradSpeed = speed;
+
+	return qtrue;
+}
+
+qboolean G2API_RagEffectorGoal(CGhoul2Info_v &ghoul2, const char *boneName, vec3_t pos)
+{
+	boneInfo_t *bone = G2_GetRagBoneConveniently(ghoul2, boneName);
+
+	if (!bone)
+	{
+		return qfalse;
+	}
+
+	if (!(bone->RagFlags & RAG_EFFECTOR))
+	{ //this function is only for effectors
+		return qfalse;
+	}
+
+	if (!pos)
+	{ //go back to none in case we have one then
+		bone->hasOverGoal = false;
+	}
+	else
+	{
+		VectorCopy(pos, bone->overGoalSpot);
+		bone->hasOverGoal = true;
+	}
+	return qtrue;
+}
+
+qboolean G2API_GetRagBonePos(CGhoul2Info_v &ghoul2, const char *boneName, vec3_t pos, vec3_t entAngles, vec3_t entPos, vec3_t entScale)
+{ //do something?
+	return qfalse;
+}
+
+qboolean G2API_RagEffectorKick(CGhoul2Info_v &ghoul2, const char *boneName, vec3_t velocity)
+{
+	boneInfo_t *bone = G2_GetRagBoneConveniently(ghoul2, boneName);
+
+	if (!bone)
+	{
+		return qfalse;
+	}
+
+	if (!(bone->RagFlags & RAG_EFFECTOR))
+	{ //this function is only for effectors
+		return qfalse;
+	}
+
+	bone->epVelocity[2] = 0;
+	VectorAdd(bone->epVelocity, velocity, bone->epVelocity);
+	bone->physicsSettled = false;
+
+	return qtrue;
+}
+
+qboolean G2API_RagForceSolve(CGhoul2Info_v &ghoul2, qboolean force)
+{
+	assert(ghoul2.size());
+	CGhoul2Info *ghlInfo = &ghoul2[0];
+
+	if (!(ghlInfo->mFlags & GHOUL2_RAG_STARTED))
+	{ //can't do this if not in ragdoll
+		return qfalse;
+	}
+
+	if (force)
+	{
+		ghlInfo->mFlags |= GHOUL2_RAG_FORCESOLVE;
+	}
+	else
+	{
+		ghlInfo->mFlags &= ~GHOUL2_RAG_FORCESOLVE;
+	}
+
+	return qtrue;
+}
+
+qboolean G2_SetBoneIKState(CGhoul2Info_v &ghoul2, int time, const char *boneName, int ikState, sharedSetBoneIKStateParams_t *params);
+qboolean G2API_SetBoneIKState(CGhoul2Info_v &ghoul2, int time, const char *boneName, int ikState, sharedSetBoneIKStateParams_t *params)
+{
+	return G2_SetBoneIKState(ghoul2, time, boneName, ikState, params);
+}
+
+qboolean G2_IKMove(CGhoul2Info_v &ghoul2, int time, sharedIKMoveParams_t *params);
+qboolean G2API_IKMove(CGhoul2Info_v &ghoul2, int time, sharedIKMoveParams_t *params)
+{
+	return G2_IKMove(ghoul2, time, params);
+}
+
+qboolean G2API_RemoveBolt(CGhoul2Info *ghlInfo, const int index)
+{
+	qboolean ret=qfalse;
+	if (G2_SetupModelPointers(ghlInfo))
+	{
+ 		ret=G2_Remove_Bolt( ghlInfo->mBltlist, index);
+	}
+	G2WARNING(ret,"G2API_RemoveBolt Failed");
+	return ret;
+}
+
+int G2API_AddBolt(CGhoul2Info *ghlInfo, const char *boneName)
+{
+	int ret=-1;
+	G2ERROR(boneName,"NULL boneName");
+	if (boneName&&G2_SetupModelPointers(ghlInfo))
+	{
+		ret=G2_Add_Bolt(ghlInfo, ghlInfo->mBltlist, ghlInfo->mSlist, boneName);
+		G2NOTE(ret>=0,va("G2API_AddBolt Failed (%s:%s)",boneName,ghlInfo->mFileName));
+	}
+	return ret;
+}
+
+int G2API_AddBoltSurfNum(CGhoul2Info *ghlInfo, const int surfIndex)
+{
+	int ret=-1;
+	if (G2_SetupModelPointers(ghlInfo))
+	{
+		ret=G2_Add_Bolt_Surf_Num(ghlInfo, ghlInfo->mBltlist, ghlInfo->mSlist, surfIndex);
+	}
+	G2WARNING(ret>=0,"G2API_AddBoltSurfNum Failed");
+	return ret;
+}
+
+
+qboolean G2API_AttachG2Model(CGhoul2Info *ghlInfo, CGhoul2Info *ghlInfoTo, int toBoltIndex, int toModel)
+{
+	qboolean ret=qfalse;
+	if (G2_SetupModelPointers(ghlInfo)&&G2_SetupModelPointers(ghlInfoTo))
+	{
+		G2ERROR(toBoltIndex>=0&&toBoltIndex<ghlInfoTo->mBltlist.size(),"Invalid Bolt Index");
+		G2ERROR(ghlInfoTo->mBltlist.size()>0,"Empty Bolt List");
+		assert( toBoltIndex >= 0 );
+		if ( toBoltIndex >= 0 && ghlInfoTo->mBltlist.size())
+		{
+			// make sure we have a model to attach, a model to attach to, and a bolt on that model
+			if (((ghlInfoTo->mBltlist[toBoltIndex].boneNumber != -1) || (ghlInfoTo->mBltlist[toBoltIndex].surfaceNumber != -1)))
+			{
+				// encode the bolt address into the model bolt link
+			   toModel &= MODEL_AND;
+			   toBoltIndex &= BOLT_AND;
+			   ghlInfo->mModelBoltLink = (toModel << MODEL_SHIFT)  | (toBoltIndex << BOLT_SHIFT);
+			   ret=qtrue;
+			}
+		}
+	}
+	G2WARNING(ret,"G2API_AttachG2Model Failed");
+	return ret;
+}
+
+
+qboolean G2API_DetachG2Model(CGhoul2Info *ghlInfo)
+{
+	if (G2_SetupModelPointers(ghlInfo))
+	{
+	   ghlInfo->mModelBoltLink = -1;
+	   return qtrue;
+	}
+	return qfalse;
+}
+
+qboolean G2API_AttachEnt(int *boltInfo, CGhoul2Info *ghlInfoTo, int toBoltIndex, int entNum, int toModelNum)
+{  	
+	qboolean ret=qfalse;
+	G2ERROR(boltInfo,"NULL boltInfo");
+	if (boltInfo&&G2_SetupModelPointers(ghlInfoTo))
+	{
+		// make sure we have a model to attach, a model to attach to, and a bolt on that model
+		if ( ghlInfoTo->mBltlist.size() && ((ghlInfoTo->mBltlist[toBoltIndex].boneNumber != -1) || (ghlInfoTo->mBltlist[toBoltIndex].surfaceNumber != -1)))
+		{
+			// encode the bolt address into the model bolt link
+		   toModelNum &= MODEL_AND;	
+		   toBoltIndex &= BOLT_AND;
+		   entNum &= ENTITY_AND;
+		   *boltInfo =  (toBoltIndex << BOLT_SHIFT) | (toModelNum << MODEL_SHIFT) | (entNum << ENTITY_SHIFT);
+		   ret=qtrue;
+		}
+	}
+	G2WARNING(ret,"G2API_AttachEnt Failed");
+	return ret;
+}
+
+void G2API_DetachEnt(int *boltInfo)
+{
+	G2ERROR(boltInfo,"NULL boltInfo");
+	if (boltInfo)
+	{
+		*boltInfo = 0;
+	}
+}
+
+
+bool G2_NeedsRecalc(CGhoul2Info *ghlInfo,int frameNum);
+
+qboolean G2API_GetBoltMatrix(CGhoul2Info_v &ghoul2, const int modelIndex, const int boltIndex, mdxaBone_t *matrix, const vec3_t angles, 
+							 const vec3_t position, const int AframeNum, qhandle_t *modelList, const vec3_t scale )
+{
+	G2ERROR(ghoul2.IsValid(),"Invalid ghlInfo");
+	G2ERROR(matrix,"NULL matrix");
+	G2ERROR(modelIndex>=0&&modelIndex<ghoul2.size(),"Invalid ModelIndex");
+	const static mdxaBone_t		identityMatrix = 
+	{ 
+		0.0f, -1.0f, 0.0f, 0.0f,
+		1.0f, 0.0f, 0.0f, 0.0f,
+		0.0f, 0.0f, 1.0f, 0.0f
+	};
+	G2_GenerateWorldMatrix(angles, position);
+	if (G2_SetupModelPointers(ghoul2))
+	{
+		if (matrix&&modelIndex>=0&&modelIndex<ghoul2.size())
+		{
+			int frameNum=G2API_GetTime(AframeNum);
+			CGhoul2Info *ghlInfo = &ghoul2[modelIndex];
+			G2ERROR(boltIndex >= 0 && (boltIndex < ghlInfo->mBltlist.size()),va("Invalid Bolt Index (%d:%s)",boltIndex,ghlInfo->mFileName));
+
+			if (boltIndex >= 0 && ghlInfo && (boltIndex < ghlInfo->mBltlist.size()) )
+			{
+				mdxaBone_t bolt;
+
+				if (G2_NeedsRecalc(ghlInfo,frameNum))
+				{
+					G2_ConstructGhoulSkeleton(ghoul2,frameNum,true,scale);
+				}
+
+				G2_GetBoltMatrixLow(*ghlInfo,boltIndex,scale,bolt);
+				// scale the bolt position by the scale factor for this model since at this point its still in model space
+				if (scale[0])
+				{
+					bolt.matrix[0][3] *= scale[0];
+				}
+				if (scale[1])
+				{
+					bolt.matrix[1][3] *= scale[1];
+				}
+				if (scale[2])
+				{
+					bolt.matrix[2][3] *= scale[2];
+				}
+				VectorNormalize((float*)&bolt.matrix[0]);
+				VectorNormalize((float*)&bolt.matrix[1]);
+				VectorNormalize((float*)&bolt.matrix[2]);
+
+				Multiply_3x4Matrix(matrix, &worldMatrix, &bolt);												
+#if G2API_DEBUG
+				for ( int i = 0; i < 3; i++ )
+				{
+					for ( int j = 0; j < 4; j++ )
+					{
+						assert( !_isnan(matrix->matrix[i][j]));
+					}
+				}
+#endif// _DEBUG
+				G2ANIM(ghlInfo,"G2API_GetBoltMatrix");
+				return qtrue;
+			}
+		}
+	}
+	else
+	{
+		G2WARNING(0,"G2API_GetBoltMatrix Failed on empty or bad model");
+	}
+	Multiply_3x4Matrix(matrix, &worldMatrix, &identityMatrix);
+	return qfalse;
+}
+
+void G2API_ListSurfaces(CGhoul2Info *ghlInfo)
+{
+	if (G2_SetupModelPointers(ghlInfo))
+	{
+		G2_List_Model_Surfaces(ghlInfo->mFileName);
+	}
+}
+
+void G2API_ListBones(CGhoul2Info *ghlInfo, int frame)
+{
+	if (G2_SetupModelPointers(ghlInfo))
+	{
+		G2_List_Model_Bones(ghlInfo->mFileName, frame);
+	}
+}
+
+// decide if we have Ghoul2 models associated with this ghoul list or not
+qboolean G2API_HaveWeGhoul2Models(CGhoul2Info_v &ghoul2)
+{
+	return !!ghoul2.IsValid();
+}
+
+// run through the Ghoul2 models and set each of the mModel values to the correct one from the cgs.gameModel offset lsit
+void G2API_SetGhoul2ModelIndexes(CGhoul2Info_v &ghoul2, qhandle_t *modelList, qhandle_t *skinList)
+{
+	G2ERROR(ghoul2.IsValid(),"Invalid ghlInfo");
+	int i;
+	for (i=0; i<ghoul2.size(); i++)
+	{
+		if (ghoul2[i].mModelindex != -1)
+		{
+			ghoul2[i].mSkin = skinList[ghoul2[i].mCustomSkin];
+		}
+	}
+}
+
+
+char *G2API_GetAnimFileNameIndex(qhandle_t modelIndex)
+{
+	model_t		*mod_m = R_GetModelByHandle(modelIndex);
+	G2ERROR(mod_m&&mod_m->mdxm,"Bad Model");
+	if (mod_m&&mod_m->mdxm)
+	{
+		return mod_m->mdxm->animName;
+	}
+	return "";
+}
+
+// as above, but gets the internal embedded name, not the name of the disk file.
+// This is needed for some unfortunate jiggery-hackery to do with frameskipping & the animevents.cfg file
+//
+char *G2API_GetAnimFileInternalNameIndex(qhandle_t modelIndex)
+{
+	model_t		*mod_a = R_GetModelByHandle(modelIndex);
+	G2ERROR(mod_a&&mod_a->mdxa,"Bad Model");
+	if (mod_a&&mod_a->mdxa)
+	{
+		return mod_a->mdxa->name;
+	}
+	return "";
+}
+
+/************************************************************************************************
+ * G2API_GetAnimFileName
+ *    obtains the name of a model's .gla (animation) file 
+ *
+ * Input
+ *    pointer to list of CGhoul2Info's, WraithID of specific model in that list
+ *
+ * Output
+ *    true if a good filename was obtained, false otherwise
+ *
+ ************************************************************************************************/
+qboolean G2API_GetAnimFileName(CGhoul2Info *ghlInfo, char **filename)
+{
+	qboolean ret=qfalse;
+	if (G2_SetupModelPointers(ghlInfo))
+	{
+		ret=G2_GetAnimFileName(ghlInfo->mFileName, filename);
+	}
+	G2WARNING(ret,"G2API_GetAnimFileName Failed");
+	return ret;
+}
+
+/*
+=======================
+SV_QsortEntityNumbers
+=======================
+*/
+static int QDECL QsortDistance( const void *a, const void *b ) {
+	const float	&ea = ((CCollisionRecord*)a)->mDistance;
+	const float	&eb = ((CCollisionRecord*)b)->mDistance;
+
+	if ( ea < eb ) {
+		return -1;
+	}
+	return 1;
+}
+
+
+void G2API_CollisionDetect(CCollisionRecord *collRecMap, CGhoul2Info_v &ghoul2, const vec3_t angles, const vec3_t position,
+							int AframeNumber, int entNum, vec3_t rayStart, vec3_t rayEnd, vec3_t scale, CMiniHeap *,
+							EG2_Collision eG2TraceType, int useLod, float fRadius)
+{
+	G2ERROR(ghoul2.IsValid(),"Invalid ghlInfo");
+	G2ERROR(collRecMap,"NULL Collision Rec");
+	if (G2_SetupModelPointers(ghoul2)&&collRecMap)
+	{
+		int frameNumber=G2API_GetTime(AframeNumber);
+
+		vec3_t	transRayStart, transRayEnd;
+
+		// make sure we have transformed the whole skeletons for each model
+		G2_ConstructGhoulSkeleton(ghoul2, frameNumber,true, scale);
+
+		// pre generate the world matrix - used to transform the incoming ray
+		G2_GenerateWorldMatrix(angles, position);
+
+		G2VertSpaceServer->ResetHeap();
+
+		// now having done that, time to build the model
+#ifdef _G2_GORE
+		G2_TransformModel(ghoul2, frameNumber, scale, G2VertSpaceServer, useLod, false);
+#else
+		G2_TransformModel(ghoul2, frameNumber, scale,G2VertSpaceServer, useLod);
+#endif
+
+		// model is built. Lets check to see if any triangles are actually hit.
+		// first up, translate the ray to model space
+		TransformAndTranslatePoint(rayStart, transRayStart, &worldMatrixInv);
+		TransformAndTranslatePoint(rayEnd, transRayEnd, &worldMatrixInv);
+
+		// now walk each model and check the ray against each poly - sigh, this is SO expensive. I wish there was a better way to do this.
+#ifdef _G2_GORE
+		G2_TraceModels(ghoul2, transRayStart, transRayEnd, collRecMap, entNum, eG2TraceType, useLod, fRadius,0,0,0,0,0);
+#else
+		G2_TraceModels(ghoul2, transRayStart, transRayEnd, collRecMap, entNum, eG2TraceType, useLod, fRadius);
+#endif
+
+		G2VertSpaceServer->ResetHeap();
+		// now sort the resulting array of collision records so they are distance ordered
+		qsort( collRecMap, MAX_G2_COLLISIONS, 
+			sizeof( CCollisionRecord ), QsortDistance );
+		G2ANIM(ghoul2,"G2API_CollisionDetect");
+	}
+}
+
+qboolean G2API_SetGhoul2ModelFlags(CGhoul2Info *ghlInfo, const int flags)
+{
+	if (G2_SetupModelPointers(ghlInfo))
+	{
+		ghlInfo->mFlags &= GHOUL2_NEWORIGIN;
+		ghlInfo->mFlags |= flags;
+		return qtrue;
+	}
+	return qfalse;
+}
+
+int G2API_GetGhoul2ModelFlags(CGhoul2Info *ghlInfo)
+{
+	if (G2_SetupModelPointers(ghlInfo))
+	{
+		return (ghlInfo->mFlags & ~GHOUL2_NEWORIGIN);
+	}
+	return 0;
+}
+
+// given a boltmatrix, return in vec a normalised vector for the axis requested in flags
+void G2API_GiveMeVectorFromMatrix(mdxaBone_t &boltMatrix, Eorientations flags, vec3_t &vec)
+{
+	switch (flags)
+	{
+	case ORIGIN:
+		vec[0] = boltMatrix.matrix[0][3];
+		vec[1] = boltMatrix.matrix[1][3];
+		vec[2] = boltMatrix.matrix[2][3];
+		break;
+	case POSITIVE_Y:
+		vec[0] = boltMatrix.matrix[0][1];
+		vec[1] = boltMatrix.matrix[1][1];
+		vec[2] = boltMatrix.matrix[2][1];
+ 		break;
+	case POSITIVE_X:
+		vec[0] = boltMatrix.matrix[0][0];
+		vec[1] = boltMatrix.matrix[1][0];
+		vec[2] = boltMatrix.matrix[2][0];
+		break;
+	case POSITIVE_Z:
+		vec[0] = boltMatrix.matrix[0][2];
+		vec[1] = boltMatrix.matrix[1][2];
+		vec[2] = boltMatrix.matrix[2][2];
+		break;
+	case NEGATIVE_Y:
+		vec[0] = -boltMatrix.matrix[0][1];
+		vec[1] = -boltMatrix.matrix[1][1];
+		vec[2] = -boltMatrix.matrix[2][1];
+		break;
+	case NEGATIVE_X:
+		vec[0] = -boltMatrix.matrix[0][0];
+		vec[1] = -boltMatrix.matrix[1][0];
+		vec[2] = -boltMatrix.matrix[2][0];
+		break;
+	case NEGATIVE_Z:
+		vec[0] = -boltMatrix.matrix[0][2];
+		vec[1] = -boltMatrix.matrix[1][2];
+		vec[2] = -boltMatrix.matrix[2][2];
+		break;
+	}
+}
+
+// copy a model from one ghoul2 instance to another, and reset the root surface on the new model if need be
+// NOTE if modelIndex = -1 then copy all the models
+void G2API_CopyGhoul2Instance(CGhoul2Info_v &ghoul2From, CGhoul2Info_v &ghoul2To, int modelIndex)
+{
+	assert(modelIndex==-1); // copy individual bolted parts is not used in jk2 and I didn't want to deal with it
+							// if ya want it, we will add it back correctly
+	
+	G2ERROR(ghoul2From.IsValid(),"Invalid ghlInfo");
+	if (ghoul2From.IsValid())
+	{
+		ghoul2To.DeepCopy(ghoul2From);
+#ifdef _G2_GORE //check through gore stuff then, as well.
+		int model = 0;
+
+		//(since we are sharing this gore set with the copied instance we will have to increment
+		//the reference count - if the goreset is "removed" while the refcount is > 0, the refcount
+		//is decremented to avoid giving other instances an invalid pointer -rww)
+		while (model < ghoul2To.size())
+		{
+			if ( ghoul2To[model].mGoreSetTag )
+			{
+				CGoreSet* gore = FindGoreSet ( ghoul2To[model].mGoreSetTag );
+				assert(gore);
+				if (gore)
+				{
+					gore->mRefCount++;
+				}
+			}
+
+			model++;
+		}
+#endif
+		G2ANIM(ghoul2From,"G2API_CopyGhoul2Instance (source)");
+		G2ANIM(ghoul2To,"G2API_CopyGhoul2Instance (dest)");
+	}
+}
+
+char *G2API_GetSurfaceName(CGhoul2Info *ghlInfo, int surfNumber)
+{
+	static char noSurface[1] = "";
+	if (G2_SetupModelPointers(ghlInfo))
+	{
+		mdxmSurface_t		*surf = 0;
+		mdxmSurfHierarchy_t	*surfInfo = 0;
+		
+
+		surf = (mdxmSurface_t *)G2_FindSurface(ghlInfo->currentModel, surfNumber, 0);
+		if (surf)
+		{
+			assert(G2_MODEL_OK(ghlInfo));
+			mdxmHierarchyOffsets_t	*surfIndexes = (mdxmHierarchyOffsets_t *)((byte *)ghlInfo->currentModel->mdxm + sizeof(mdxmHeader_t));
+			surfInfo = (mdxmSurfHierarchy_t *)((byte *)surfIndexes + surfIndexes->offsets[surf->thisSurfaceIndex]);
+			return surfInfo->name;
+		}
+	}
+	G2WARNING(0,"Surface Not Found");
+	return noSurface;
+}
+
+
+int	G2API_GetSurfaceIndex(CGhoul2Info *ghlInfo, const char *surfaceName)
+{
+	int ret=-1;
+	G2ERROR(surfaceName,"NULL surfaceName");
+	if (surfaceName&&G2_SetupModelPointers(ghlInfo))
+	{
+		ret=G2_GetSurfaceIndex(ghlInfo, surfaceName);
+	}
+	G2WARNING(ret>=0,"G2API_GetSurfaceIndex Failed");
+	return ret;
+}
+
+char *G2API_GetGLAName(CGhoul2Info *ghlInfo)
+{
+	if (G2_SetupModelPointers(ghlInfo))
+	{
+		assert(G2_MODEL_OK(ghlInfo));
+		return (char*)ghlInfo->aHeader->name;
+		//return ghlInfo->currentModel->mdxm->animName;
+	}
+	return 0;
+}
+
+qboolean G2API_SetNewOrigin(CGhoul2Info *ghlInfo, const int boltIndex)
+{
+	if (G2_SetupModelPointers(ghlInfo))
+	{
+		G2ERROR(boltIndex>=0&&boltIndex<ghlInfo->mBltlist.size(),"invalid boltIndex");
+
+		if (boltIndex>=0&&boltIndex<ghlInfo->mBltlist.size())
+		{
+			ghlInfo->mNewOrigin = boltIndex;
+			ghlInfo->mFlags |= GHOUL2_NEWORIGIN;
+		}
+		return qtrue;
+	}
+	return qfalse;
+}
+
+int G2API_GetBoneIndex(CGhoul2Info *ghlInfo, const char *boneName, qboolean bAddIfNotFound)
+{
+	int ret=-1;
+	G2ERROR(boneName,"NULL boneName");
+	if (boneName&&G2_SetupModelPointers(ghlInfo))
+	{			
+		ret=G2_Get_Bone_Index(ghlInfo, boneName, bAddIfNotFound);
+		G2ANIM(ghlInfo,"G2API_GetBoneIndex");
+	}
+	G2NOTE(ret>=0,"G2API_GetBoneIndex Failed");
+	return ret;
+}
+
+void G2API_SaveGhoul2Models(CGhoul2Info_v &ghoul2)
+{
+	G2ANIM(ghoul2,"G2API_SaveGhoul2Models");
+	G2_SaveGhoul2Models(ghoul2);
+}
+
+void G2API_LoadGhoul2Models(CGhoul2Info_v &ghoul2, char *buffer)
+{
+	G2_LoadGhoul2Model(ghoul2, buffer);
+	G2ANIM(ghoul2,"G2API_LoadGhoul2Models");
+//	G2ERROR(ghoul2.IsValid(),"Invalid ghlInfo after load");
+}
+
+// this is kinda sad, but I need to call the destructor in this module (exe), not the game.dll...
+//
+void G2API_LoadSaveCodeDestructGhoul2Info(CGhoul2Info_v &ghoul2)
+{
+	ghoul2.~CGhoul2Info_v();	// so I can load junk over it then memset to 0 without orphaning
+}
+
+#ifdef _G2_GORE
+void ResetGoreTag(); // put here to reduce coupling
+
+void G2API_ClearSkinGore ( CGhoul2Info_v &ghoul2 )
+{
+	int i;
+
+	for (i=0; i<ghoul2.size(); i++)
+	{
+		if ( ghoul2[i].mGoreSetTag )
+		{
+			DeleteGoreSet ( ghoul2[i].mGoreSetTag );
+			ghoul2[i].mGoreSetTag = 0;
+		}
+	}
+}
+
+extern int		G2_DecideTraceLod(CGhoul2Info &ghoul2, int useLod);
+void G2API_AddSkinGore(CGhoul2Info_v &ghoul2,SSkinGoreData &gore)
+{
+	if (VectorLength(gore.rayDirection)<.1f)
+	{
+		assert(0); // can't add gore without a shot direction
+		return;
+	}
+
+	// make sure we have transformed the whole skeletons for each model
+	//G2_ConstructGhoulSkeleton(ghoul2, gore.currentTime, NULL, true, gore.angles, gore.position, gore.scale, false);
+	G2_ConstructGhoulSkeleton(ghoul2, gore.currentTime, true, gore.scale);
+
+	// pre generate the world matrix - used to transform the incoming ray
+	G2_GenerateWorldMatrix(gore.angles, gore.position);
+
+	// first up, translate the ray to model space
+	vec3_t	transRayDirection, transHitLocation;
+	TransformAndTranslatePoint(gore.hitLocation, transHitLocation, &worldMatrixInv);
+	TransformPoint(gore.rayDirection, transRayDirection, &worldMatrixInv);
+	if (!gore.useTheta)
+	{
+		vec3_t t;
+		VectorCopy(gore.uaxis,t);
+		TransformPoint(t, gore.uaxis, &worldMatrixInv);
+	}
+
+	int lod;
+	ResetGoreTag();
+	const int lodbias=Com_Clamp ( 0, 2,G2_DecideTraceLod(ghoul2[0],r_lodbias->integer));
+	const int maxLod =Com_Clamp (0,ghoul2[0].currentModel->numLods,3);	//limit to the number of lods the main model has
+	for(lod=lodbias;lod<maxLod;lod++)
+	{
+		// now having done that, time to build the model
+		G2VertSpaceServer->ResetHeap();
+
+		G2_TransformModel(ghoul2, gore.currentTime, gore.scale,G2VertSpaceServer,lod,true);
+
+		// now walk each model and compute new texture coordinates
+		G2_TraceModels(ghoul2, transHitLocation, transRayDirection, 0, gore.entNum, G2_NOCOLLIDE,lod,1.0f,gore.SSize,gore.TSize,gore.theta,gore.shader,&gore);
+	}
+ }
+#else
+void G2API_ClearSkinGore ( CGhoul2Info_v &ghoul2 )
+{
+}
+
+void G2API_AddSkinGore(CGhoul2Info_v &ghoul2,SSkinGoreData &gore)
+{
+}
+#endif
+
+bool G2_TestModelPointers(CGhoul2Info *ghlInfo) // returns true if the model is properly set up
+{
+	G2ERROR(ghlInfo,"NULL ghlInfo");
+	if (!ghlInfo)
+	{
+		return false;
+	}
+	ghlInfo->mValid=false;
+	if (ghlInfo->mModelindex != -1)
+	{
+		ghlInfo->mModel = RE_RegisterModel(ghlInfo->mFileName);
+		ghlInfo->currentModel = R_GetModelByHandle(ghlInfo->mModel);
+		if (ghlInfo->currentModel)
+		{
+			if (ghlInfo->currentModel->mdxm)
+			{
+				if (ghlInfo->currentModelSize)
+				{
+					if (ghlInfo->currentModelSize!=ghlInfo->currentModel->mdxm->ofsEnd)
+					{
+						Com_Error(ERR_DROP, "Ghoul2 model was reloaded and has changed, map must be restarted.\n");
+					}
+				}
+				ghlInfo->currentModelSize=ghlInfo->currentModel->mdxm->ofsEnd;
+				ghlInfo->animModel =  R_GetModelByHandle(ghlInfo->currentModel->mdxm->animIndex + ghlInfo->animModelIndexOffset);
+				if (ghlInfo->animModel)
+				{
+					ghlInfo->aHeader =ghlInfo->animModel->mdxa;
+					G2ERROR(ghlInfo->aHeader,va("Model has no mdxa (gla) %s",ghlInfo->mFileName));
+					if (!ghlInfo->aHeader)
+					{
+						Com_Error(ERR_DROP, "Ghoul2 Model has no mdxa (gla) %s",ghlInfo->mFileName);
+					}
+					if (ghlInfo->currentAnimModelSize)
+					{
+						if (ghlInfo->currentAnimModelSize!=ghlInfo->aHeader->ofsEnd)
+						{
+							Com_Error(ERR_DROP, "Ghoul2 model was reloaded and has changed, map must be restarted.\n");
+						}
+					}
+					ghlInfo->currentAnimModelSize=ghlInfo->aHeader->ofsEnd;
+					ghlInfo->mValid=true;
+				}
+			}
+		}
+	}
+	if (!ghlInfo->mValid)
+	{
+		ghlInfo->currentModel=0;
+		ghlInfo->currentModelSize=0;
+		ghlInfo->animModel=0;
+		ghlInfo->currentAnimModelSize=0;
+		ghlInfo->aHeader=0;
+	}
+	return ghlInfo->mValid;
+}
+
+bool G2_SetupModelPointers(CGhoul2Info *ghlInfo) // returns true if the model is properly set up
+{
+	G2ERROR(ghlInfo,"NULL ghlInfo");
+	if (!ghlInfo)
+	{
+		return false;
+	}
+	ghlInfo->mValid=false;
+//	G2WARNING(ghlInfo->mModelindex != -1,"Setup request on non-used info slot?");
+	if (ghlInfo->mModelindex != -1)
+	{
+		G2ERROR(ghlInfo->mFileName[0],"empty ghlInfo->mFileName");
+		ghlInfo->mModel = RE_RegisterModel(ghlInfo->mFileName);
+		ghlInfo->currentModel = R_GetModelByHandle(ghlInfo->mModel);
+		G2ERROR(ghlInfo->currentModel,va("NULL Model (glm) %s",ghlInfo->mFileName));
+		if (ghlInfo->currentModel)
+		{
+			G2ERROR(ghlInfo->currentModel->mdxm,va("Model has no mdxm (glm) %s",ghlInfo->mFileName));
+			if (ghlInfo->currentModel->mdxm)
+			{
+				if (ghlInfo->currentModelSize)
+				{
+					if (ghlInfo->currentModelSize!=ghlInfo->currentModel->mdxm->ofsEnd)
+					{
+						Com_Error(ERR_DROP, "Ghoul2 model was reloaded and has changed, map must be restarted.\n");
+					}
+				}
+				ghlInfo->currentModelSize=ghlInfo->currentModel->mdxm->ofsEnd;
+				G2ERROR(ghlInfo->currentModelSize,va("Zero sized Model? (glm) %s",ghlInfo->mFileName));
+
+				ghlInfo->animModel =  R_GetModelByHandle(ghlInfo->currentModel->mdxm->animIndex + ghlInfo->animModelIndexOffset);
+				G2ERROR(ghlInfo->animModel,va("NULL Model (gla) %s",ghlInfo->mFileName));
+				if (ghlInfo->animModel)
+				{
+					ghlInfo->aHeader =ghlInfo->animModel->mdxa;
+					G2ERROR(ghlInfo->aHeader,va("Model has no mdxa (gla) %s",ghlInfo->mFileName));
+					if (!ghlInfo->aHeader)
+					{
+						Com_Error(ERR_DROP, "Ghoul2 Model has no mdxa (gla) %s",ghlInfo->mFileName);
+					}
+					if (ghlInfo->currentAnimModelSize)
+					{
+						if (ghlInfo->currentAnimModelSize!=ghlInfo->aHeader->ofsEnd)
+						{
+							Com_Error(ERR_DROP, "Ghoul2 model was reloaded and has changed, map must be restarted.\n");
+						}
+					}
+					ghlInfo->currentAnimModelSize=ghlInfo->aHeader->ofsEnd;
+					G2ERROR(ghlInfo->currentAnimModelSize,va("Zero sized Model? (gla) %s",ghlInfo->mFileName));
+					ghlInfo->mValid=true;
+				}
+			}
+		}
+	}
+	if (!ghlInfo->mValid)
+	{
+		ghlInfo->currentModel=0;
+		ghlInfo->currentModelSize=0;
+		ghlInfo->animModel=0;
+		ghlInfo->currentAnimModelSize=0;
+		ghlInfo->aHeader=0;
+	}
+	return ghlInfo->mValid;
+}
+
+bool G2_SetupModelPointers(CGhoul2Info_v &ghoul2) // returns true if any model is properly set up
+{
+	bool ret=false;
+	int i;
+	for (i=0; i<ghoul2.size(); i++)
+	{
+		bool r=G2_SetupModelPointers(&ghoul2[i]);
+		ret=ret||r;
+	}
+	return ret;
+}
+
+
diff --git a/code/ghoul2/G2_bolts.cpp b/code/ghoul2/G2_bolts.cpp
new file mode 100644
index 0000000..6b87142
--- /dev/null
+++ b/code/ghoul2/G2_bolts.cpp
@@ -0,0 +1,253 @@
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+
+
+#ifndef __Q_SHARED_H
+	#include "../game/q_shared.h"
+#endif
+
+#if !defined(TR_LOCAL_H)
+	#include "../renderer/tr_local.h"
+#endif
+
+#if !defined(G2_H_INC)
+	#include "G2.h"
+#endif
+
+#define G2_MODEL_OK(g) ((g)&&(g)->mValid&&(g)->aHeader&&(g)->currentModel&&(g)->animModel)
+
+//=====================================================================================================================
+// Bolt List handling routines - so entities can attach themselves to any part of the model in question
+
+// Given a bone number, see if that bone is already in our bone list
+int G2_Find_Bolt_Bone_Num(boltInfo_v &bltlist, const int boneNum)
+{
+	int		i;
+
+	// look through entire list
+	for(i=0; i<bltlist.size(); i++)
+	{
+		if (bltlist[i].boneNumber == boneNum)
+		{
+			return i;
+		}
+	}
+
+	// didn't find it
+	return -1;
+}
+
+// Given a bone number, see if that surface is already in our surfacelist list
+int G2_Find_Bolt_Surface_Num(boltInfo_v &bltlist, const int surfaceNum, const int flags)
+{
+	int		i;
+
+	// look through entire list
+	for(i=0; i<bltlist.size(); i++)
+	{
+		if ((bltlist[i].surfaceNumber == surfaceNum) && ((bltlist[i].surfaceType & flags) == flags))
+		{
+			return i;
+		}
+	}
+
+	// didn't find it
+	return -1;
+}
+			
+//=========================================================================================
+//// Public Bolt Routines
+int G2_Add_Bolt_Surf_Num(CGhoul2Info *ghlInfo, boltInfo_v &bltlist, surfaceInfo_v &slist, const int surfNum)
+{
+	assert(ghlInfo&&ghlInfo->mValid);
+	boltInfo_t			tempBolt;
+	int					i;
+
+	assert(surfNum>=0&&surfNum<slist.size());
+	// ensure surface num is valid
+	if (surfNum >= slist.size())
+	{
+		return -1;
+	}
+
+	 // look through entire list - see if it's already there first
+	for(i=0; i<bltlist.size(); i++)
+	{
+		// already there??
+		if (bltlist[i].surfaceNumber == surfNum)
+		{
+			// increment the usage count
+			bltlist[i].boltUsed++;
+			return i;
+		}
+	}
+
+	// we have a surface 
+	// look through entire list - see if it's already there first
+	for(i=0; i<bltlist.size(); i++)
+	{
+		// if this surface entry has info in it, bounce over it
+	  	if (bltlist[i].boneNumber == -1 && bltlist[i].surfaceNumber == -1)
+		{
+			// if we found an entry that had a -1 for the bone / surface number, then we hit a surface / bone slot that was empty
+			bltlist[i].surfaceNumber = surfNum;
+			bltlist[i].surfaceType = G2SURFACEFLAG_GENERATED;
+			bltlist[i].boltUsed = 1;
+	 		return i;
+		}
+	}
+	
+	// ok, we didn't find an existing surface of that name, or an empty slot. Lets add an entry
+	tempBolt.surfaceNumber = surfNum;
+	tempBolt.surfaceType = G2SURFACEFLAG_GENERATED;
+	tempBolt.boneNumber = -1;
+	tempBolt.boltUsed = 1;
+	bltlist.push_back(tempBolt);
+	return bltlist.size()-1;
+
+}
+
+void G2_Bolt_Not_Found(const char *boneName,const char *modName);
+int G2_Add_Bolt(CGhoul2Info *ghlInfo, boltInfo_v &bltlist, surfaceInfo_v &slist, const char *boneName)
+{
+	assert(ghlInfo&&ghlInfo->mValid);
+	int					i, x, surfNum = -1;
+	mdxaSkel_t			*skel;
+	mdxaSkelOffsets_t	*offsets;
+	mdxmHierarchyOffsets_t	*surfOffsets;
+	boltInfo_t			tempBolt;
+	int					flags;
+
+	assert(G2_MODEL_OK(ghlInfo));
+  
+	surfOffsets = (mdxmHierarchyOffsets_t *)((byte*)ghlInfo->currentModel->mdxm + sizeof(mdxmHeader_t));
+	// first up, we'll search for that which this bolt names in all the surfaces
+	surfNum = G2_IsSurfaceLegal(ghlInfo->currentModel, boneName, &flags);
+
+	// did we find it as a surface?
+	if (surfNum != -1)
+	{
+		 // look through entire list - see if it's already there first
+		for(i=0; i<bltlist.size(); i++)
+		{
+			// already there??
+			if (bltlist[i].surfaceNumber == surfNum)
+			{
+				// increment the usage count
+				bltlist[i].boltUsed++;
+				return i;
+			}
+		}
+
+		 // look through entire list - see if we can re-use one
+		for(i=0; i<bltlist.size(); i++)
+		{
+			// if this surface entry has info in it, bounce over it
+		  	if (bltlist[i].boneNumber == -1 && bltlist[i].surfaceNumber == -1)
+			{
+				// if we found an entry that had a -1 for the bone / surface number, then we hit a surface / bone slot that was empty
+				bltlist[i].surfaceNumber = surfNum;
+				bltlist[i].boltUsed = 1;
+				bltlist[i].surfaceType = 0;
+		 		return i;
+			}
+		}
+	
+		// ok, we didn't find an existing surface of that name, or an empty slot. Lets add an entry
+		tempBolt.surfaceNumber = surfNum;
+		tempBolt.boneNumber = -1;
+		tempBolt.boltUsed = 1;
+		tempBolt.surfaceType = 0;
+		bltlist.push_back(tempBolt);
+		return bltlist.size()-1;
+	}
+
+	// no, check to see if it's a bone then
+
+   	offsets = (mdxaSkelOffsets_t *)((byte *)ghlInfo->aHeader + sizeof(mdxaHeader_t));
+
+ 	// walk the entire list of bones in the gla file for this model and see if any match the name of the bone we want to find
+ 	for (x=0; x< ghlInfo->aHeader->numBones; x++)
+ 	{
+ 		skel = (mdxaSkel_t *)((byte *)ghlInfo->aHeader + sizeof(mdxaHeader_t) + offsets->offsets[x]);
+ 		// if name is the same, we found it
+ 		if (!stricmp(skel->name, boneName))
+		{
+			break;
+		}
+	}
+
+	// check to see we did actually make a match with a bone in the model
+	if (x == ghlInfo->aHeader->numBones)
+	{
+		// didn't find it? Error
+		//assert(0&&x == mod_a->mdxa->numBones);
+#if _DEBUG
+		G2_Bolt_Not_Found(boneName,ghlInfo->mFileName);
+#endif
+		return -1;
+	}
+
+	// look through entire list - see if it's already there first
+	for(i=0; i<bltlist.size(); i++)
+	{
+		// already there??
+		if (bltlist[i].boneNumber == x)
+		{
+			// increment the usage count
+			bltlist[i].boltUsed++;
+			return i;
+		}
+	}
+
+	// look through entire list - see if we can re-use it
+	for(i=0; i<bltlist.size(); i++)
+	{
+		// if this bone entry has info in it, bounce over it
+		if (bltlist[i].boneNumber == -1 && bltlist[i].surfaceNumber == -1)
+		{
+			// if we found an entry that had a -1 for the bonenumber, then we hit a bone slot that was empty
+			bltlist[i].boneNumber = x;
+			bltlist[i].boltUsed = 1;
+			bltlist[i].surfaceType = 0;
+	 		return i;
+		}
+	}
+	
+	// ok, we didn't find an existing bone of that name, or an empty slot. Lets add an entry
+	tempBolt.boneNumber = x;
+	tempBolt.surfaceNumber = -1;
+	tempBolt.boltUsed = 1;
+ 	tempBolt.surfaceType = 0;
+	bltlist.push_back(tempBolt);
+	return bltlist.size()-1;
+
+}
+
+// Given a model handle, and a bone name, we want to remove this bone from the bone override list
+qboolean G2_Remove_Bolt (boltInfo_v &bltlist, int index)
+{
+	assert(index>=0&&index<bltlist.size());
+	// did we find it?
+	if (index != -1)
+	{
+		bltlist[index].boltUsed--;
+		if (!bltlist[index].boltUsed)
+		{
+			// set this bone to not used
+			bltlist[index].boneNumber = -1;
+			bltlist[index].surfaceNumber = -1;
+		}
+		return qtrue;
+	}
+	return qfalse;
+}
+
+// set the bolt list to all unused so the bone transformation routine ignores it.
+void G2_Init_Bolt_List(boltInfo_v &bltlist)
+{
+	bltlist.clear();
+}
+
diff --git a/code/ghoul2/G2_bones.cpp b/code/ghoul2/G2_bones.cpp
new file mode 100644
index 0000000..d14b30a
--- /dev/null
+++ b/code/ghoul2/G2_bones.cpp
@@ -0,0 +1,4756 @@
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+
+
+#ifndef __Q_SHARED_H
+	#include "../game/q_shared.h"
+#endif
+
+#if !defined(TR_LOCAL_H)
+	#include "../renderer/tr_local.h"
+#endif
+#if !defined(_QCOMMON_H_)
+	#include "../qcommon/qcommon.h"
+#endif
+
+#include "../renderer/MatComp.h"
+
+#if !defined(G2_H_INC)
+	#include "G2.h"
+#endif
+
+//rww - RAGDOLL_BEGIN
+#include <FLOAT.H>
+#include "ghoul2_gore.h"
+//rww - RAGDOLL_END
+
+extern	cvar_t	*r_Ghoul2BlendMultiplier;
+
+void G2_Bone_Not_Found(const char *boneName,const char *modName);
+	 
+//=====================================================================================================================
+// Bone List handling routines - so entities can override bone info on a bone by bone level, and also interrogate this info
+
+// Given a bone name, see if that bone is already in our bone list - note the model_t pointer that gets passed in here MUST point at the 
+// gla file, not the glm file type.
+int G2_Find_Bone(CGhoul2Info *ghlInfo, boneInfo_v &blist, const char *boneName)
+{
+	int					i;
+	mdxaSkel_t			*skel;
+	mdxaSkelOffsets_t	*offsets;
+   	offsets = (mdxaSkelOffsets_t *)((byte *)ghlInfo->aHeader + sizeof(mdxaHeader_t));
+	skel = (mdxaSkel_t *)((byte *)ghlInfo->aHeader + sizeof(mdxaHeader_t) + offsets->offsets[0]);
+
+	// look through entire list
+	for(i=0; i<blist.size(); i++)
+	{
+		// if this bone entry has no info in it, bounce over it
+		if (blist[i].boneNumber == -1)
+		{
+			continue;
+		}
+
+		// figure out what skeletal info structure this bone entry is looking at
+		skel = (mdxaSkel_t *)((byte *)ghlInfo->aHeader + sizeof(mdxaHeader_t) + offsets->offsets[blist[i].boneNumber]);
+
+		// if name is the same, we found it
+		if (!stricmp(skel->name, boneName))
+		{
+			return i;
+		}
+	}
+#if _DEBUG
+	G2_Bone_Not_Found(boneName,ghlInfo->mFileName);
+#endif	
+	// didn't find it
+	return -1;
+}
+
+#define DEBUG_G2_BONES (0)
+
+// we need to add a bone to the list - find a free one and see if we can find a corresponding bone in the gla file
+int G2_Add_Bone (const model_t *mod, boneInfo_v &blist, const char *boneName)
+{
+	int i, x;
+	mdxaSkel_t			*skel;
+	mdxaSkelOffsets_t	*offsets;
+	boneInfo_t			tempBone;
+	
+	//rww - RAGDOLL_BEGIN
+	memset(&tempBone, 0, sizeof(tempBone));
+	//rww - RAGDOLL_END
+
+   	offsets = (mdxaSkelOffsets_t *)((byte *)mod->mdxa + sizeof(mdxaHeader_t));
+
+ 	// walk the entire list of bones in the gla file for this model and see if any match the name of the bone we want to find
+ 	for (x=0; x< mod->mdxa->numBones; x++)
+ 	{
+ 		skel = (mdxaSkel_t *)((byte *)mod->mdxa + sizeof(mdxaHeader_t) + offsets->offsets[x]);
+ 		// if name is the same, we found it
+ 		if (!stricmp(skel->name, boneName))
+		{
+			break;
+		}
+	}
+
+	// check to see we did actually make a match with a bone in the model
+	if (x == mod->mdxa->numBones)
+	{
+#if _DEBUG
+		G2_Bone_Not_Found(boneName,mod->name);
+#endif	
+		return -1;
+	}
+
+	// look through entire list - see if it's already there first
+	for(i=0; i<blist.size(); i++)
+	{
+		// if this bone entry has info in it, bounce over it
+		if (blist[i].boneNumber != -1)
+		{
+			skel = (mdxaSkel_t *)((byte *)mod->mdxa + sizeof(mdxaHeader_t) + offsets->offsets[blist[i].boneNumber]);
+			// if name is the same, we found it
+			if (!stricmp(skel->name, boneName))
+			{
+#if DEBUG_G2_BONES
+				{
+					char mess[1000];
+					sprintf(mess,"ADD BONE1 blistIndex=%3d    physicalIndex=%3d   %s\n",
+						i,
+						x,
+						boneName);
+					OutputDebugString(mess);
+				}
+#endif
+				return i;
+			}
+		}
+		else
+		{
+			// if we found an entry that had a -1 for the bonenumber, then we hit a bone slot that was empty
+			blist[i].boneNumber = x;
+			blist[i].flags = 0;
+#if DEBUG_G2_BONES
+			{
+				char mess[1000];
+				sprintf(mess,"ADD BONE1 blistIndex=%3d    physicalIndex=%3d   %s\n",
+					i,
+					x,
+					boneName);
+				OutputDebugString(mess);
+			}
+#endif
+	 		return i;
+		}
+	}
+	
+	// ok, we didn't find an existing bone of that name, or an empty slot. Lets add an entry
+	tempBone.boneNumber = x;
+	tempBone.flags = 0;
+	blist.push_back(tempBone);
+#if DEBUG_G2_BONES
+	{
+		char mess[1000];
+		sprintf(mess,"ADD BONE1 blistIndex=%3d    physicalIndex=%3d   %s\n",
+			blist.size()-1,
+			x,
+			boneName);
+		OutputDebugString(mess);
+	}
+#endif
+	return blist.size()-1;
+}
+
+
+// Given a model handle, and a bone name, we want to remove this bone from the bone override list
+qboolean G2_Remove_Bone_Index ( boneInfo_v &blist, int index)
+{
+	// did we find it?
+	if (index != -1)
+	{
+		// check the flags first - if it's still being used Do NOT remove it
+		if (!blist[index].flags)
+		{
+			// set this bone to not used
+			blist[index].boneNumber = -1;
+		}
+		return qtrue;
+	}
+	return qfalse;
+}
+
+// given a bone number, see if there is an override bone in the bone list
+int	G2_Find_Bone_In_List(boneInfo_v &blist, const int boneNum)
+{
+	int i; 
+	
+	// look through entire list
+	for(i=0; i<blist.size(); i++)
+	{
+		if (blist[i].boneNumber == boneNum)
+		{
+			return i;
+		}
+	}
+	return -1;
+}
+
+// given a model, bonelist and bonename, lets stop an anim if it's playing.
+qboolean G2_Stop_Bone_Index( boneInfo_v &blist, int index, int flags)
+{
+	// did we find it?
+	if (index != -1)
+	{
+		blist[index].flags &= ~(flags);
+		// try and remove this bone if we can
+		return G2_Remove_Bone_Index(blist, index);
+	}
+
+	assert(0);
+	return qfalse;
+}
+
+// generate a matrix for a given bone given some new angles for it.
+void G2_Generate_Matrix(const model_t *mod, boneInfo_v &blist, int index, const float *angles, int flags,
+						const Eorientations up, const Eorientations left, const Eorientations forward)
+{
+	mdxaSkel_t		*skel;
+	mdxaSkelOffsets_t *offsets;
+	mdxaBone_t		temp1;
+	mdxaBone_t		permutation;
+	mdxaBone_t		*boneOverride = &blist[index].matrix;
+	vec3_t			newAngles;
+
+	if (flags & (BONE_ANGLES_PREMULT | BONE_ANGLES_POSTMULT))
+	{
+		// build us a matrix out of the angles we are fed - but swap y and z because of wacky Quake setup
+		vec3_t	newAngles;
+
+		// determine what axis newAngles Yaw should revolve around
+		switch (up)
+		{
+		case NEGATIVE_X:
+			newAngles[1] = angles[2] + 180;
+			break;
+		case POSITIVE_X:
+			newAngles[1] = angles[2];
+			break;
+		case NEGATIVE_Y:
+			newAngles[1] = angles[0];
+			break;
+		case POSITIVE_Y:
+			newAngles[1] = angles[0];
+			break;
+		case NEGATIVE_Z:
+			newAngles[1] = angles[1] + 180;
+			break;
+		case POSITIVE_Z:
+			newAngles[1] = angles[1];
+			break;
+		}
+
+		// determine what axis newAngles pitch should revolve around
+		switch (left)
+		{
+		case NEGATIVE_X:
+			newAngles[0] = angles[2];
+			break;
+		case POSITIVE_X:
+			newAngles[0] = angles[2] + 180;
+			break;
+		case NEGATIVE_Y:
+			newAngles[0] = angles[0];
+			break;
+		case POSITIVE_Y:
+			newAngles[0] = angles[0] + 180;
+			break;
+		case NEGATIVE_Z:
+			newAngles[0] = angles[1];
+			break;
+		case POSITIVE_Z:
+			newAngles[0] = angles[1];
+			break;
+		}
+
+		// determine what axis newAngles Roll should revolve around
+		switch (forward)
+		{
+		case NEGATIVE_X:
+			newAngles[2] = angles[2];
+			break;
+		case POSITIVE_X:
+			newAngles[2] = angles[2];
+			break;
+		case NEGATIVE_Y:
+			newAngles[2] = angles[0];
+			break;
+		case POSITIVE_Y:
+			newAngles[2] = angles[0] + 180;
+			break;
+		case NEGATIVE_Z:
+			newAngles[2] = angles[1];
+			break;
+		case POSITIVE_Z:
+			newAngles[2] = angles[1] + 180;
+			break;
+		}
+
+		Create_Matrix(newAngles, boneOverride);
+
+		// figure out where the bone hirearchy info is
+		offsets = (mdxaSkelOffsets_t *)((byte *)mod->mdxa + sizeof(mdxaHeader_t));
+		skel = (mdxaSkel_t *)((byte *)mod->mdxa + sizeof(mdxaHeader_t) + offsets->offsets[blist[index].boneNumber]);
+
+		Multiply_3x4Matrix(&temp1,  boneOverride,&skel->BasePoseMatInv);
+		Multiply_3x4Matrix(boneOverride,&skel->BasePoseMat, &temp1);
+	
+	}
+	else
+	{
+		VectorCopy(angles, newAngles);
+
+		// why I should need do this Fuck alone knows. But I do.
+		if (left == POSITIVE_Y)
+		{
+			newAngles[0] +=180;
+		}
+
+		Create_Matrix(newAngles, &temp1);
+
+		permutation.matrix[0][0] = permutation.matrix[0][1] = permutation.matrix[0][2] = permutation.matrix[0][3] = 0;
+		permutation.matrix[1][0] = permutation.matrix[1][1] = permutation.matrix[1][2] = permutation.matrix[1][3] = 0;
+		permutation.matrix[2][0] = permutation.matrix[2][1] = permutation.matrix[2][2] = permutation.matrix[2][3] = 0;
+
+		// determine what axis newAngles Yaw should revolve around
+		switch (forward)
+		{
+		case NEGATIVE_X:
+			permutation.matrix[0][0] = -1;		// works
+			break;
+		case POSITIVE_X:
+			permutation.matrix[0][0] = 1;		// works
+			break;
+		case NEGATIVE_Y:
+			permutation.matrix[1][0] = -1;
+			break;
+		case POSITIVE_Y:
+			permutation.matrix[1][0] = 1;
+			break;
+		case NEGATIVE_Z:
+			permutation.matrix[2][0] = -1;
+			break;
+		case POSITIVE_Z:
+			permutation.matrix[2][0] = 1;
+			break;
+		}
+
+		// determine what axis newAngles pitch should revolve around
+		switch (left)
+		{
+		case NEGATIVE_X:
+			permutation.matrix[0][1] = -1;
+			break;
+		case POSITIVE_X:
+			permutation.matrix[0][1] = 1;
+			break;
+		case NEGATIVE_Y:
+			permutation.matrix[1][1] = -1;		// works
+			break;
+		case POSITIVE_Y:
+			permutation.matrix[1][1] = 1;		// works
+			break;
+		case NEGATIVE_Z:
+			permutation.matrix[2][1] = -1;
+			break;
+		case POSITIVE_Z:
+			permutation.matrix[2][1] = 1;
+			break;
+		}
+
+		// determine what axis newAngles Roll should revolve around
+		switch (up)
+		{
+		case NEGATIVE_X:
+			permutation.matrix[0][2] = -1;
+			break;
+		case POSITIVE_X:
+			permutation.matrix[0][2] = 1;
+			break;
+		case NEGATIVE_Y:
+			permutation.matrix[1][2] = -1;
+			break;
+		case POSITIVE_Y:
+			permutation.matrix[1][2] = 1;
+			break;
+		case NEGATIVE_Z:
+			permutation.matrix[2][2] = -1;		// works
+			break;
+		case POSITIVE_Z:
+			permutation.matrix[2][2] = 1;		// works
+			break;
+		}
+
+		Multiply_3x4Matrix(boneOverride, &temp1,&permutation);
+
+	}
+
+	// keep a copy of the matrix in the newmatrix which is actually what we use
+	memcpy(&blist[index].newMatrix, &blist[index].matrix, sizeof(mdxaBone_t));
+
+}
+
+//=========================================================================================
+//// Public Bone Routines
+
+
+// Given a model handle, and a bone name, we want to remove this bone from the bone override list
+qboolean G2_Remove_Bone (CGhoul2Info *ghlInfo, boneInfo_v &blist, const char *boneName)
+{
+	int			index = G2_Find_Bone(ghlInfo, blist, boneName);
+	if (index==-1)
+	{
+		return false;
+	}
+ 
+	return G2_Remove_Bone_Index(blist, index);
+}
+
+#define DEBUG_PCJ (0)
+
+// Given a model handle, and a bone name, we want to set angles specifically for overriding
+qboolean G2_Set_Bone_Angles_Index(CGhoul2Info *ghlInfo, boneInfo_v &blist, const int index,
+							const float *angles, const int flags, const Eorientations yaw,
+							const Eorientations pitch, const Eorientations roll,
+							const int blendTime, const int currentTime)
+{
+	
+	if (index<0||(index >= blist.size()) || (blist[index].boneNumber == -1))
+	{
+		return qfalse;
+	}
+	
+	// yes, so set the angles and flags correctly
+	blist[index].flags &= ~(BONE_ANGLES_TOTAL);
+	blist[index].flags |= flags;
+	blist[index].boneBlendStart = currentTime;
+	blist[index].boneBlendTime = blendTime;
+#if DEBUG_PCJ
+	OutputDebugString(va("%8x  %2d %6d   (%6.2f,%6.2f,%6.2f) %d %d %d %d\n",(int)ghlInfo,index,currentTime,angles[0],angles[1],angles[2],yaw,pitch,roll,flags));
+#endif
+	G2_Generate_Matrix(ghlInfo->animModel, blist, index, angles, flags, yaw, pitch, roll);
+	return qtrue;
+
+}
+
+// Given a model handle, and a bone name, we want to set angles specifically for overriding
+qboolean G2_Set_Bone_Angles(CGhoul2Info *ghlInfo, boneInfo_v &blist, const char *boneName, const float *angles,
+							const int flags, const Eorientations up, const Eorientations left, const Eorientations forward,
+							const int blendTime, const int currentTime)
+{
+	int			index = G2_Find_Bone(ghlInfo, blist, boneName);
+	if (index == -1)
+	{
+		index = G2_Add_Bone(ghlInfo->animModel, blist, boneName);
+	}
+	if (index != -1)
+	{
+		blist[index].flags &= ~(BONE_ANGLES_TOTAL);
+		blist[index].flags |= flags;
+		blist[index].boneBlendStart = currentTime;
+		blist[index].boneBlendTime = blendTime;
+
+		G2_Generate_Matrix(ghlInfo->animModel, blist, index, angles, flags, up, left, forward);
+		return qtrue;
+	}
+	return qfalse;
+}
+
+// Given a model handle, and a bone name, we want to set angles specifically for overriding - using a matrix directly
+qboolean G2_Set_Bone_Angles_Matrix_Index(boneInfo_v &blist, const int index,
+								   const mdxaBone_t &matrix, const int flags,
+								   const int blendTime, const int currentTime)
+{
+
+	if (index<0||(index >= blist.size()) || (blist[index].boneNumber == -1))
+	{
+		// we are attempting to set a bone override that doesn't exist
+		assert(0);
+		return qfalse;
+	}
+	// yes, so set the angles and flags correctly
+	blist[index].flags &= ~(BONE_ANGLES_TOTAL);
+	blist[index].flags |= flags;
+	blist[index].boneBlendStart = currentTime;
+	blist[index].boneBlendTime = blendTime;
+
+	memcpy(&blist[index].matrix, &matrix, sizeof(mdxaBone_t));
+	memcpy(&blist[index].newMatrix, &matrix, sizeof(mdxaBone_t));
+	return qtrue;
+
+}
+
+// Given a model handle, and a bone name, we want to set angles specifically for overriding - using a matrix directly
+qboolean G2_Set_Bone_Angles_Matrix(CGhoul2Info *ghlInfo, boneInfo_v &blist, const char *boneName, const mdxaBone_t &matrix,
+								   const int flags,const int blendTime, const int currentTime)
+{
+	int			index = G2_Find_Bone(ghlInfo, blist, boneName);
+ 	if (index == -1)
+	{
+		index = G2_Add_Bone(ghlInfo->animModel, blist, boneName);
+	}
+	if (index != -1)
+	{
+		blist[index].flags &= ~(BONE_ANGLES_TOTAL);
+		blist[index].flags |= flags;
+		memcpy(&blist[index].matrix, &matrix, sizeof(mdxaBone_t));
+		memcpy(&blist[index].newMatrix, &matrix, sizeof(mdxaBone_t));
+		return qtrue;
+	}
+	return qfalse;
+}
+
+#define DEBUG_G2_TIMING (0)
+
+// given a model, bone name, a bonelist, a start/end frame number, a anim speed and some anim flags, set up or modify an existing bone entry for a new set of anims
+qboolean G2_Set_Bone_Anim_Index(boneInfo_v &blist, const int index, const int startFrame, 
+						  const int endFrame, const int flags, const float animSpeed, const int currentTime, const float setFrame, const int AblendTime,int numFrames)
+{
+	int			modFlags = flags;
+	int			blendTime=AblendTime;
+
+	if (r_Ghoul2BlendMultiplier)
+	{
+		if (r_Ghoul2BlendMultiplier->value!=1.0f)
+		{
+			if (r_Ghoul2BlendMultiplier->value<=0.0f)
+			{
+				modFlags&=~BONE_ANIM_BLEND;
+			}
+			else
+			{
+				blendTime=ceil(float(AblendTime)*r_Ghoul2BlendMultiplier->value);
+			}
+		}
+	}
+ 
+
+	if (index<0||index >= blist.size()||blist[index].boneNumber<0)
+	{
+		return qfalse;
+	}
+
+	// sanity check to see if setfram is within animation bounds
+	assert((setFrame==-1) || ((setFrame>=startFrame) && (setFrame<endFrame)) || ((setFrame>endFrame) && (setFrame<=(startFrame+1))));
+
+
+	// since we already existed, we can check to see if we want to start some blending
+	if (modFlags & BONE_ANIM_BLEND)
+	{
+		float	currentFrame, animSpeed; 
+		int 	startFrame, endFrame, flags;
+		// figure out where we are now
+		if (G2_Get_Bone_Anim_Index(blist, index, currentTime, &currentFrame, &startFrame, &endFrame, &flags, &animSpeed,numFrames))
+		{
+			if (blist[index].blendStart == currentTime)	//we're replacing a blend in progress which hasn't started
+			{
+				// set the amount of time it's going to take to blend this anim with the last frame of the last one
+				blist[index].blendTime = blendTime;
+			}
+			else
+			{
+				if (animSpeed<0.0f)
+				{
+					blist[index].blendFrame = floor(currentFrame);
+					blist[index].blendLerpFrame = floor(currentFrame);
+				}
+				else
+				{
+					blist[index].blendFrame = currentFrame;
+					blist[index].blendLerpFrame = currentFrame+1;
+					
+					// cope with if the lerp frame is actually off the end of the anim
+					if (blist[index].blendFrame >= blist[index].endFrame )
+					{
+						// we only want to lerp with the first frame of the anim if we are looping 
+						if (blist[index].flags & BONE_ANIM_OVERRIDE_LOOP)
+						{
+							blist[index].blendFrame = blist[index].startFrame;
+						}
+						// if we intend to end this anim or freeze after this, then just keep on the last frame
+						else
+						{
+							assert(blist[index].endFrame>0);
+							blist[index].blendFrame = blist[index].endFrame -1;
+						}
+					}
+					
+					// cope with if the lerp frame is actually off the end of the anim
+					if (blist[index].blendLerpFrame >= blist[index].endFrame )
+					{
+						// we only want to lerp with the first frame of the anim if we are looping 
+						if (blist[index].flags & BONE_ANIM_OVERRIDE_LOOP)
+						{
+							blist[index].blendLerpFrame = blist[index].startFrame;
+						}
+						// if we intend to end this anim or freeze after this, then just keep on the last frame
+						else
+						{
+							assert(blist[index].endFrame>0);
+							blist[index].blendLerpFrame = blist[index].endFrame - 1;
+						}
+					}
+				}
+				// set the amount of time it's going to take to blend this anim with the last frame of the last one
+				blist[index].blendTime = blendTime;
+				blist[index].blendStart = currentTime;
+			}
+		}
+		// hmm, we weren't animating on this bone. In which case disable the blend
+		else
+		{
+			blist[index].blendFrame = blist[index].blendLerpFrame = 0;
+			blist[index].blendTime = 0;
+			// we aren't blending, so remove the option to do so
+			modFlags &= ~BONE_ANIM_BLEND;
+			//return qfalse;
+		}
+	}
+	else
+	{
+		blist[index].blendFrame = blist[index].blendLerpFrame = 0;
+		blist[index].blendTime = blist[index].blendStart = 0;
+		// we aren't blending, so remove the option to do so
+		modFlags &= ~BONE_ANIM_BLEND;
+	}
+
+	// yes, so set the anim data and flags correctly
+	blist[index].endFrame = endFrame;
+	blist[index].startFrame = startFrame;
+	blist[index].animSpeed = animSpeed;
+	blist[index].pauseTime = 0;
+	assert(blist[index].blendFrame>=0&&blist[index].blendFrame<numFrames);
+	assert(blist[index].blendLerpFrame>=0&&blist[index].blendLerpFrame<numFrames);
+	// start up the animation:)
+	if (setFrame != -1)
+	{
+		blist[index].startTime = (currentTime - (((setFrame - (float)startFrame) * 50.0)/ animSpeed));
+/*
+		setFrame = bone.startFrame + ((currentTime - bone.startTime) / 50.0f * animSpeed);
+
+		(setFrame - bone.startFrame) = ((currentTime - bone.startTime) / 50.0f * animSpeed);
+
+		(setFrame - bone.startFrame)*50/animSpeed - currentTime = - bone.startTime;
+
+		currentTime - (setFrame - bone.startFrame)*50/animSpeed  =  bone.startTime;
+*/
+	}
+	else
+	{
+		blist[index].startTime = currentTime;
+	}
+	blist[index].flags &= ~(BONE_ANIM_TOTAL);
+	blist[index].flags |= modFlags;
+
+#if DEBUG_G2_TIMING
+	if (index>-10) 
+	{
+		const boneInfo_t &bone=blist[index];
+		char mess[1000];
+		if (bone.flags&BONE_ANIM_BLEND)
+		{
+			sprintf(mess,"sab[%2d] %5d  %5d  (%5d-%5d) %4.2f %4x   bt(%5d-%5d) %7.2f %5d\n",
+				index,
+				currentTime,
+				bone.startTime,
+				bone.startFrame,
+				bone.endFrame,
+				bone.animSpeed,
+				bone.flags,
+				bone.blendStart,
+				bone.blendStart+bone.blendTime,
+				bone.blendFrame,
+				bone.blendLerpFrame
+				);
+		}
+		else
+		{
+			sprintf(mess,"saa[%2d] %5d  %5d  (%5d-%5d) %4.2f %4x\n",
+				index,
+				currentTime,
+				bone.startTime,
+				bone.startFrame,
+				bone.endFrame,
+				bone.animSpeed,
+				bone.flags
+				);
+		}
+		OutputDebugString(mess);
+	}
+#endif
+//		assert(blist[index].startTime <= currentTime);
+	return qtrue;
+
+}
+
+// given a model, bone name, a bonelist, a start/end frame number, a anim speed and some anim flags, set up or modify an existing bone entry for a new set of anims
+qboolean G2_Set_Bone_Anim(CGhoul2Info *ghlInfo, boneInfo_v &blist, const char *boneName, const int startFrame, 
+						  const int endFrame, const int flags, const float animSpeed, const int currentTime, const float setFrame, const int blendTime)
+{
+	int			modFlags = flags;
+	int			index = G2_Find_Bone(ghlInfo, blist, boneName);
+ 
+	// sanity check to see if setfram is within animation bounds
+	if (setFrame != -1)
+	{
+		assert((setFrame >= startFrame) && (setFrame <= endFrame));
+	}
+
+	// did we find it?
+	if (index != -1)
+	{
+		return G2_Set_Bone_Anim_Index(blist, index, startFrame, endFrame, flags, animSpeed, currentTime, setFrame, blendTime,ghlInfo->aHeader->numFrames);
+	}
+	// no - lets try and add this bone in
+	index = G2_Add_Bone(ghlInfo->animModel, blist, boneName);
+	
+	// did we find a free one?
+	if (index != -1)
+	{	
+		blist[index].blendFrame = blist[index].blendLerpFrame = 0;
+		blist[index].blendTime = 0;
+		// we aren't blending, so remove the option to do so
+		modFlags &= ~BONE_ANIM_BLEND;
+		// yes, so set the anim data and flags correctly
+		blist[index].endFrame = endFrame;
+		blist[index].startFrame = startFrame;
+		blist[index].animSpeed = animSpeed;
+		blist[index].pauseTime = 0;
+		// start up the animation:)
+		if (setFrame != -1)
+		{
+			blist[index].startTime = (currentTime - (((setFrame - (float)startFrame) * 50.0)/ animSpeed));
+		}
+		else
+		{
+			blist[index].startTime = currentTime;
+		}
+		blist[index].flags &= ~BONE_ANIM_TOTAL;
+		blist[index].flags |= modFlags;
+		assert(blist[index].blendFrame>=0&&blist[index].blendFrame<ghlInfo->aHeader->numFrames);
+		assert(blist[index].blendLerpFrame>=0&&blist[index].blendLerpFrame<ghlInfo->aHeader->numFrames);
+#if DEBUG_G2_TIMING
+		if (index>-10) 
+		{
+			const boneInfo_t &bone=blist[index];
+			char mess[1000];
+			if (bone.flags&BONE_ANIM_BLEND)
+			{
+				sprintf(mess,"s2b[%2d] %5d  %5d  (%5d-%5d) %4.2f %4x   bt(%5d-%5d) %7.2f %5d\n",
+					index,
+					currentTime,
+					bone.startTime,
+					bone.startFrame,
+					bone.endFrame,
+					bone.animSpeed,
+					bone.flags,
+					bone.blendStart,
+					bone.blendStart+bone.blendTime,
+					bone.blendFrame,
+					bone.blendLerpFrame
+					);
+			}
+			else
+			{
+				sprintf(mess,"s2a[%2d] %5d  %5d  (%5d-%5d) %4.2f %4x\n",
+					index,
+					currentTime,
+					bone.startTime,
+					bone.startFrame,
+					bone.endFrame,
+					bone.animSpeed,
+					bone.flags
+					);
+			}
+			OutputDebugString(mess);
+		}
+#endif
+		return qtrue;
+	}
+
+	//assert(index != -1);
+	// no
+	return qfalse;
+}
+
+qboolean G2_Get_Bone_Anim_Range_Index(boneInfo_v &blist, const int boneIndex, int *startFrame, int *endFrame)
+{
+	if (boneIndex != -1)
+	{ 
+		assert(boneIndex>=0&&boneIndex<blist.size());
+		// are we an animating bone?
+		if (blist[boneIndex].flags & (BONE_ANIM_OVERRIDE_LOOP | BONE_ANIM_OVERRIDE))
+		{
+			*startFrame = blist[boneIndex].startFrame;
+			*endFrame = blist[boneIndex].endFrame;
+			return qtrue;
+		}
+	}
+	return qfalse;
+}
+qboolean G2_Get_Bone_Anim_Range(CGhoul2Info *ghlInfo, boneInfo_v &blist, const char *boneName, int *startFrame, int *endFrame)
+{
+	int			index = G2_Find_Bone(ghlInfo, blist, boneName);
+	if (index==-1)
+	{
+		return qfalse;
+	}	
+	if (G2_Get_Bone_Anim_Range_Index( blist, index, startFrame, endFrame))
+	{
+		assert(*startFrame>=0&&*startFrame<ghlInfo->aHeader->numFrames);
+		assert(*endFrame>0&&*endFrame<=ghlInfo->aHeader->numFrames);
+		return qtrue;
+	}
+	return qfalse;
+}
+
+// given a model, bonelist and bonename, return the current frame, startframe and endframe of the current animation
+// NOTE if we aren't running an animation, then qfalse is returned
+qboolean G2_Get_Bone_Anim_Index( boneInfo_v &blist, const int index, const int currentTime, 
+						  float *retcurrentFrame, int *startFrame, int *endFrame, int *flags, float *retAnimSpeed,int numFrames)
+{
+  
+	// did we find it?
+	if ((index>=0) && !((index >= blist.size()) || (blist[index].boneNumber == -1)))
+	{ 
+
+		// are we an animating bone?
+		if (blist[index].flags & (BONE_ANIM_OVERRIDE_LOOP | BONE_ANIM_OVERRIDE))
+		{
+			int currentFrame,newFrame;
+			float lerp;
+			G2_TimingModel(blist[index],currentTime,numFrames,currentFrame,newFrame,lerp);
+
+			if (retcurrentFrame)
+			{
+				*retcurrentFrame =float(currentFrame)+lerp;
+			}
+			if (startFrame)
+			{
+				*startFrame = blist[index].startFrame;
+			}
+			if (endFrame)
+			{
+				*endFrame = blist[index].endFrame;
+			}
+			if (flags)
+			{
+				*flags = blist[index].flags;
+			}
+			if (retAnimSpeed)
+			{
+				*retAnimSpeed = blist[index].animSpeed;
+			}
+			return qtrue;
+		}
+	}
+	if (startFrame)
+	{
+		*startFrame=0;
+	}
+	if (endFrame)
+	{
+		*endFrame=1;
+	}
+	if (retcurrentFrame)
+	{
+		*retcurrentFrame=0.0f;
+	}
+	if (flags)
+	{
+		*flags=0;
+	}
+	if (retAnimSpeed)
+	{
+		*retAnimSpeed=0.0f;
+	}
+	return qfalse;
+}
+
+// given a model, bonelist and bonename, return the current frame, startframe and endframe of the current animation
+// NOTE if we aren't running an animation, then qfalse is returned
+qboolean G2_Get_Bone_Anim(CGhoul2Info *ghlInfo, boneInfo_v &blist, const char *boneName, const int currentTime, 
+						  float *currentFrame, int *startFrame, int *endFrame, int *flags, float *retAnimSpeed)
+{
+	int			index = G2_Find_Bone(ghlInfo, blist, boneName);
+	if (index==-1)
+	{
+		return qfalse;
+	}
+ 
+	assert(ghlInfo->aHeader);
+	if (G2_Get_Bone_Anim_Index(blist, index, currentTime, currentFrame, startFrame, endFrame, flags, retAnimSpeed,ghlInfo->aHeader->numFrames))
+	{
+		assert(*startFrame>=0&&*startFrame<ghlInfo->aHeader->numFrames);
+		assert(*endFrame>0&&*endFrame<=ghlInfo->aHeader->numFrames);
+		assert(*currentFrame>=0.0f&&((int)(*currentFrame))<ghlInfo->aHeader->numFrames);
+		return qtrue;
+	}
+	return qfalse;
+}
+
+
+// given a model, bonelist and bonename, lets pause an anim if it's playing.
+qboolean G2_Pause_Bone_Anim_Index( boneInfo_v &blist, const int boneIndex, const int currentTime,int numFrames)
+{
+	if (boneIndex>=0&&boneIndex<blist.size())
+	{
+		// are we pausing or un pausing?
+		if (blist[boneIndex].pauseTime)
+		{
+			int		startFrame, endFrame, flags;
+			float	currentFrame, animSpeed;
+
+			// figure out what frame we are on now
+			if	(G2_Get_Bone_Anim_Index( blist, boneIndex, blist[boneIndex].pauseTime, &currentFrame, &startFrame, &endFrame, &flags, &animSpeed,numFrames))
+			{
+				// reset start time so we are actually on this frame right now
+				G2_Set_Bone_Anim_Index( blist, boneIndex, startFrame, endFrame, flags, animSpeed, currentTime, currentFrame, 0,numFrames);
+				// no pausing anymore
+				blist[boneIndex].pauseTime = 0;
+			}
+			else
+			{
+				return qfalse;
+			}
+		}
+		// ahh, just pausing, the easy bit
+		else
+		{
+			blist[boneIndex].pauseTime = currentTime;
+		}
+		
+		return qtrue;
+	}
+	assert(0);
+	return qfalse;
+}
+qboolean G2_Pause_Bone_Anim(CGhoul2Info *ghlInfo, boneInfo_v &blist, const char *boneName, const int currentTime)
+{
+	int			index = G2_Find_Bone(ghlInfo, blist, boneName);
+	if (index==-1)
+	{
+		return qfalse;
+	}
+	
+	return (G2_Pause_Bone_Anim_Index( blist, index, currentTime,ghlInfo->aHeader->numFrames) );
+}
+
+qboolean	G2_IsPaused(CGhoul2Info *ghlInfo, boneInfo_v &blist, const char *boneName)
+{
+	int			index = G2_Find_Bone(ghlInfo, blist, boneName);
+	if (index != -1)
+	{
+		// are we paused?
+		if (blist[index].pauseTime)
+		{
+			// yup. paused.
+			return qtrue;
+		}
+		return qfalse;
+	}
+
+	return qfalse;
+}
+
+// given a model, bonelist and bonename, lets stop an anim if it's playing.
+qboolean G2_Stop_Bone_Anim_Index(boneInfo_v &blist, const int index)
+{
+ 
+	if (index<0 || (index >= blist.size()) || (blist[index].boneNumber == -1))
+	{
+		// we are attempting to set a bone override that doesn't exist
+		return qfalse;
+	}
+
+	blist[index].flags &= ~(BONE_ANIM_TOTAL);
+	return G2_Remove_Bone_Index(blist, index);
+}
+
+// given a model, bonelist and bonename, lets stop an anim if it's playing.
+qboolean G2_Stop_Bone_Anim(CGhoul2Info *ghlInfo, boneInfo_v &blist, const char *boneName)
+{
+	int			index = G2_Find_Bone(ghlInfo, blist, boneName);
+	if (index != -1)
+	{
+		blist[index].flags &= ~(BONE_ANIM_TOTAL);
+		return G2_Remove_Bone_Index(blist, index);
+	}
+	assert(0);
+	return qfalse;
+}
+
+// given a model, bonelist and bonename, lets stop an anim if it's playing.
+qboolean G2_Stop_Bone_Angles_Index(boneInfo_v &blist, const int index)
+{
+ 
+	if ((index >= blist.size()) || (blist[index].boneNumber == -1))
+	{
+		// we are attempting to set a bone override that doesn't exist
+		assert(0);
+		return qfalse;
+	} 
+	blist[index].flags &= ~(BONE_ANGLES_TOTAL);
+	return G2_Remove_Bone_Index(blist, index);
+
+}
+
+// given a model, bonelist and bonename, lets stop an anim if it's playing.
+qboolean G2_Stop_Bone_Angles(CGhoul2Info *ghlInfo, boneInfo_v &blist, const char *boneName)
+{
+	int			index = G2_Find_Bone(ghlInfo, blist, boneName);
+	if (index != -1)
+	{
+		blist[index].flags &= ~(BONE_ANGLES_TOTAL);
+		return G2_Remove_Bone_Index(blist, index);
+	}
+	assert(0);
+	return qfalse;
+}
+
+//rww - RAGDOLL_BEGIN
+/*
+
+
+  rag stuff
+
+*/
+static void G2_RagDollSolve(CGhoul2Info_v &ghoul2V,int g2Index,float decay,int frameNum,const vec3_t currentOrg,bool LimitAngles,CRagDollUpdateParams *params = NULL);
+static void G2_RagDollCurrentPosition(CGhoul2Info_v &ghoul2V,int g2Index,int frameNum,const vec3_t angles,const vec3_t position,const vec3_t scale);
+static bool G2_RagDollSettlePositionNumeroTrois(CGhoul2Info_v &ghoul2V,const vec3_t currentOrg,CRagDollUpdateParams *params, int curTime);
+static bool G2_RagDollSetup(CGhoul2Info &ghoul2,int frameNum,bool resetOrigin,const vec3_t origin,bool anyRendered);
+
+void G2_GetBoneBasepose(CGhoul2Info &ghoul2,int boneNum,mdxaBone_t *&retBasepose,mdxaBone_t *&retBaseposeInv);
+int G2_GetBoneDependents(CGhoul2Info &ghoul2,int boneNum,int *tempDependents,int maxDep);
+void G2_GetBoneMatrixLow(CGhoul2Info &ghoul2,int boneNum,const vec3_t scale,mdxaBone_t &retMatrix,mdxaBone_t *&retBasepose,mdxaBone_t *&retBaseposeInv);
+int G2_GetParentBoneMatrixLow(CGhoul2Info &ghoul2,int boneNum,const vec3_t scale,mdxaBone_t &retMatrix,mdxaBone_t *&retBasepose,mdxaBone_t *&retBaseposeInv);
+bool G2_WasBoneRendered(CGhoul2Info &ghoul2,int boneNum);
+
+#define MAX_BONES_RAG (256)
+
+struct SRagEffector
+{
+	vec3_t		currentOrigin;
+	vec3_t		desiredDirection;
+	vec3_t		desiredOrigin;
+	float		radius;
+	float		weight;
+};
+
+#define RAG_MASK (CONTENTS_SOLID|CONTENTS_TERRAIN)//|CONTENTS_SHOTCLIP|CONTENTS_TERRAIN//(/*MASK_SOLID|*/CONTENTS_SOLID|CONTENTS_PLAYERCLIP|CONTENTS_SHOTCLIP|CONTENTS_TERRAIN|CONTENTS_BODY)
+
+extern cvar_t	*broadsword;
+extern cvar_t	*broadsword_kickbones;
+extern cvar_t	*broadsword_kickorigin;
+extern cvar_t	*broadsword_dontstopanim;
+extern cvar_t	*broadsword_waitforshot;
+extern cvar_t	*broadsword_playflop;
+
+extern cvar_t	*broadsword_effcorr;
+
+extern cvar_t	*broadsword_ragtobase;
+
+extern cvar_t	*broadsword_dircap;
+
+extern cvar_t	*broadsword_extra1;
+extern cvar_t	*broadsword_extra2;
+
+#define RAG_PCJ						(0x00001)
+#define RAG_PCJ_POST_MULT			(0x00002)	// has the pcj flag as well
+#define RAG_PCJ_MODEL_ROOT			(0x00004)	// has the pcj flag as well
+#define RAG_PCJ_PELVIS				(0x00008)	// has the pcj flag and POST_MULT as well
+#define RAG_EFFECTOR				(0x00100)
+#define RAG_WAS_NOT_RENDERED		(0x01000)		// not particularily reliable, more of a hint
+#define RAG_WAS_EVER_RENDERED		(0x02000)		// not particularily reliable, more of a hint
+#define RAG_BONE_LIGHTWEIGHT		(0x04000)		//used to indicate a bone's velocity treatment
+#define RAG_PCJ_IK_CONTROLLED		(0x08000)		//controlled from IK move input
+#define RAG_UNSNAPPABLE				(0x10000)		//cannot be broken out of constraints ever
+
+// thiese flags are on the model and correspond to...
+//#define		GHOUL2_RESERVED_FOR_RAGDOLL 0x0ff0  // these are not defined here for dependecies sake
+#define		GHOUL2_RAG_STARTED						0x0010  // we are actually a ragdoll
+#define		GHOUL2_RAG_PENDING						0x0100  // got start death anim but not end death anim
+#define		GHOUL2_RAG_DONE							0x0200		// got end death anim
+#define		GHOUL2_RAG_COLLISION_DURING_DEATH		0x0400		// ever have gotten a collision (da) event
+#define		GHOUL2_RAG_COLLISION_SLIDE				0x0800		// ever have gotten a collision (slide) event
+#define		GHOUL2_RAG_FORCESOLVE					0x1000		//api-override, determine if ragdoll should be forced to continue solving even if it thinks it is settled
+
+#define flrand	Q_flrand
+
+static mdxaBone_t*		ragBasepose[MAX_BONES_RAG];
+static mdxaBone_t*		ragBaseposeInv[MAX_BONES_RAG];
+static mdxaBone_t		ragBones[MAX_BONES_RAG];
+static SRagEffector		ragEffectors[MAX_BONES_RAG];
+static boneInfo_t		*ragBoneData[MAX_BONES_RAG];
+static int				tempDependents[MAX_BONES_RAG];
+static int				ragBlistIndex[MAX_BONES_RAG];
+static int				numRags;
+static vec3_t			ragBoneMins;
+static vec3_t			ragBoneMaxs;
+static vec3_t			ragBoneCM;
+static bool				haveDesiredPelvisOffset=false;
+static vec3_t			desiredPelvisOffset; // this is for the root
+static float			ragOriginChange=0.0f;
+static vec3_t			ragOriginChangeDir;
+//debug
+static vec3_t			handPos={0,0,0};
+static vec3_t			handPos2={0,0,0};
+
+enum ERagState
+{
+	ERS_DYNAMIC,
+	ERS_SETTLING,
+	ERS_SETTLED
+};
+static int				ragState;
+
+static vector<boneInfo_t *>		*rag = NULL;  // once we get the dependents precomputed this can be local
+
+
+static void G2_Generate_MatrixRag(
+			// caution this must not be called before the whole skeleton is "remembered"
+	boneInfo_v			&blist, 
+	int					index)
+{
+
+
+	boneInfo_t &bone=blist[index];//.sent;
+
+	memcpy(&bone.matrix,&bone.ragOverrideMatrix, sizeof(mdxaBone_t));
+#ifdef _DEBUG
+	int i,j;
+	for (i = 0; i < 3; i++ )
+	{
+		for (j = 0; j < 4; j++ )
+		{
+			assert( !_isnan(bone.matrix.matrix[i][j]));
+		}
+	}
+#endif// _DEBUG
+	memcpy(&blist[index].newMatrix,&bone.matrix, sizeof(mdxaBone_t));
+}
+
+int G2_Find_Bone_Rag(CGhoul2Info *ghlInfo, boneInfo_v &blist, const char *boneName)
+{
+	int					i;
+	mdxaSkel_t			*skel;
+	mdxaSkelOffsets_t	*offsets;
+
+   	offsets = (mdxaSkelOffsets_t *)((byte *)ghlInfo->aHeader + sizeof(mdxaHeader_t));
+	skel = (mdxaSkel_t *)((byte *)ghlInfo->aHeader + sizeof(mdxaHeader_t) + offsets->offsets[0]);
+
+	/*
+	model_t			*currentModel;
+	model_t			*animModel;
+	mdxaHeader_t	*aHeader;
+
+	currentModel = R_GetModelByHandle(RE_RegisterModel(ghlInfo->mFileName));
+	assert(currentModel);
+	animModel =  R_GetModelByHandle(currentModel->mdxm->animIndex);
+	assert(animModel);
+	aHeader = animModel->mdxa;
+	assert(aHeader);
+
+   	offsets = (mdxaSkelOffsets_t *)((byte *)aHeader + sizeof(mdxaHeader_t));
+	skel = (mdxaSkel_t *)((byte *)aHeader + sizeof(mdxaHeader_t) + offsets->offsets[0]);
+	*/
+
+	// look through entire list
+	for(i=0; i<blist.size(); i++)
+	{
+		// if this bone entry has no info in it, bounce over it
+		if (blist[i].boneNumber == -1)
+		{
+			continue;
+		}
+
+		// figure out what skeletal info structure this bone entry is looking at
+		skel = (mdxaSkel_t *)((byte *)ghlInfo->aHeader + sizeof(mdxaHeader_t) + offsets->offsets[blist[i].boneNumber]);
+		//skel = (mdxaSkel_t *)((byte *)aHeader + sizeof(mdxaHeader_t) + offsets->offsets[blist[i].boneNumber]);
+
+		// if name is the same, we found it
+		if (!stricmp(skel->name, boneName))
+		{
+			return i;
+		}
+	}
+#if _DEBUG
+//	G2_Bone_Not_Found(boneName,ghlInfo->mFileName);
+#endif	
+	// didn't find it
+	return -1;
+}
+
+static int G2_Set_Bone_Rag(const mdxaHeader_t *mod_a,
+	boneInfo_v &blist, 
+	const char *boneName,
+	CGhoul2Info &ghoul2,
+	const vec3_t scale,
+	const vec3_t origin)
+{
+	// do not change the state of the skeleton here
+	int	index = G2_Find_Bone_Rag(&ghoul2, blist, boneName);
+
+	if (index == -1)
+	{
+		index = G2_Add_Bone(ghoul2.animModel, blist, boneName);
+	}
+
+	if (index != -1)
+	{
+		boneInfo_t &bone=blist[index];
+		VectorCopy(origin,bone.extraVec1);
+
+		G2_GetBoneMatrixLow(ghoul2,bone.boneNumber,scale,bone.originalTrueBoneMatrix,bone.basepose,bone.baseposeInv);
+//		bone.parentRawBoneIndex=G2_GetParentBoneMatrixLow(ghoul2,bone.boneNumber,scale,bone.parentTrueBoneMatrix,bone.baseposeParent,bone.baseposeInvParent);
+		assert( !_isnan(bone.originalTrueBoneMatrix.matrix[1][1]));
+		assert( !_isnan(bone.originalTrueBoneMatrix.matrix[1][3]));
+		bone.originalOrigin[0]=bone.originalTrueBoneMatrix.matrix[0][3];
+		bone.originalOrigin[1]=bone.originalTrueBoneMatrix.matrix[1][3];
+		bone.originalOrigin[2]=bone.originalTrueBoneMatrix.matrix[2][3];
+	}
+	return index;
+}
+
+static int G2_Set_Bone_Angles_Rag(
+	CGhoul2Info &ghoul2,
+	const mdxaHeader_t *mod_a,
+	boneInfo_v &blist, 
+	const char *boneName,
+	const int flags,
+	const float radius,
+	const vec3_t angleMin=0,
+	const vec3_t angleMax=0,
+	const int blendTime=500)
+{
+	int			index = G2_Find_Bone_Rag(&ghoul2, blist, boneName);
+
+	if (index == -1)
+	{
+		index = G2_Add_Bone(ghoul2.animModel, blist, boneName);
+	}
+	if (index != -1)
+	{
+		boneInfo_t &bone=blist[index];
+		bone.flags &= ~(BONE_ANGLES_TOTAL);
+		bone.flags |= BONE_ANGLES_RAGDOLL;
+		if (flags&RAG_PCJ)
+		{
+			if (flags&RAG_PCJ_POST_MULT)
+			{
+				bone.flags |= BONE_ANGLES_POSTMULT;
+			}
+			else if (flags&RAG_PCJ_MODEL_ROOT)
+			{
+				bone.flags |= BONE_ANGLES_PREMULT;
+//				bone.flags |= BONE_ANGLES_POSTMULT;
+			}
+			else
+			{
+				assert(!"Invalid RAG PCJ\n");
+			}
+		}
+		bone.ragStartTime=G2API_GetTime(0);
+		bone.boneBlendStart = bone.ragStartTime;
+		bone.boneBlendTime = blendTime;
+		bone.radius=radius;
+		bone.weight=1.0f;
+
+		//init the others to valid values
+		bone.epGravFactor = 0;
+		VectorClear(bone.epVelocity);
+		bone.solidCount = 0;
+		bone.physicsSettled = false;
+		bone.snapped = false;
+
+		bone.parentBoneIndex = -1;
+
+		bone.offsetRotation = 0.0f;
+
+		bone.overGradSpeed = 0.0f;
+		VectorClear(bone.overGoalSpot);
+		bone.hasOverGoal = false;
+		bone.hasAnimFrameMatrix = -1;
+
+//		bone.weight=pow(radius,1.7f); //cubed was too harsh
+//		bone.weight=radius*radius*radius;
+		if (angleMin&&angleMax)
+		{
+			VectorCopy(angleMin,bone.minAngles);
+			VectorCopy(angleMax,bone.maxAngles);
+		}
+		else
+		{
+			VectorCopy(bone.currentAngles,bone.minAngles); // I guess this isn't a rag pcj then
+			VectorCopy(bone.currentAngles,bone.maxAngles);
+		}
+		if (!bone.lastTimeUpdated)
+		{
+			static mdxaBone_t		id = 
+			{ 
+				1.0f, 0.0f, 0.0f, 0.0f,
+				0.0f, 1.0f, 0.0f, 0.0f,
+				0.0f, 0.0f, 1.0f, 0.0f
+			};
+			memcpy(&bone.ragOverrideMatrix,&id, sizeof(mdxaBone_t));
+			VectorClear(bone.anglesOffset);
+			VectorClear(bone.positionOffset);
+			VectorClear(bone.velocityEffector);  // this is actually a velocity now
+			VectorClear(bone.velocityRoot);  // this is actually a velocity now
+			VectorClear(bone.lastPosition);
+			VectorClear(bone.lastShotDir);
+			bone.lastContents=0;
+			// if this is non-zero, we are in a dynamic state
+			bone.firstCollisionTime=bone.ragStartTime;
+			// if this is non-zero, we are in a settling state
+			bone.restTime=0;
+			// if they are both zero, we are in a settled state
+
+			bone.firstTime=0;
+
+			bone.RagFlags=flags;
+			bone.DependentRagIndexMask=0;
+
+			G2_Generate_MatrixRag(blist,index); // set everything to th id
+
+#if 0
+			VectorClear(bone.currentAngles);
+//			VectorAdd(bone.minAngles,bone.maxAngles,bone.currentAngles);
+//			VectorScale(bone.currentAngles,0.5f,bone.currentAngles);
+#else
+			{
+				if (
+					(flags&RAG_PCJ_MODEL_ROOT) ||
+					(flags&RAG_PCJ_PELVIS) ||
+					!(flags&RAG_PCJ))
+				{
+					VectorClear(bone.currentAngles);
+				}
+				else
+				{
+					int k;
+					for (k=0;k<3;k++)
+					{
+						float scalar=flrand(-1.0f,1.0f);
+						scalar*=flrand(-1.0f,1.0f)*flrand(-1.0f,1.0f);
+						// this is a heavily central distribution
+						// center it on .5 (and make it small)
+						scalar*=0.5f;
+						scalar+=0.5f;
+
+						bone.currentAngles[k]=(bone.minAngles[k]-bone.maxAngles[k])*scalar+bone.maxAngles[k];
+					}
+				}
+			}
+//			VectorClear(bone.currentAngles);
+#endif
+			VectorCopy(bone.currentAngles,bone.lastAngles);
+		}
+	}
+	return index;
+}
+
+class CRagDollParams;
+const mdxaHeader_t *G2_GetModA(CGhoul2Info &ghoul2);
+
+
+static void G2_RagDollMatchPosition()
+{
+	haveDesiredPelvisOffset=false;
+	int i;
+	for (i=0;i<numRags;i++)
+	{
+		boneInfo_t &bone=*ragBoneData[i];
+		SRagEffector &e=ragEffectors[i];
+
+		vec3_t &desiredPos=e.desiredOrigin; // we will save this
+
+		if (0&&(bone.RagFlags & RAG_PCJ_PELVIS))
+		{
+			// just move to quake origin
+			VectorCopy(bone.originalOrigin,desiredPos);
+			VectorSubtract(desiredPos,e.currentOrigin,desiredPelvisOffset); // last arg is dest
+			haveDesiredPelvisOffset=true;
+			VectorCopy(e.currentOrigin,bone.lastPosition); // last arg is dest
+			continue; 
+		}
+
+		if (!(bone.RagFlags & RAG_EFFECTOR))
+		{
+			continue; 
+		}
+		VectorCopy(bone.originalOrigin,desiredPos);
+		VectorSubtract(desiredPos,e.currentOrigin,e.desiredDirection);
+		VectorCopy(e.currentOrigin,bone.lastPosition); // last arg is dest
+	}
+}
+
+qboolean G2_Set_Bone_Anim_No_BS(CGhoul2Info &ghoul2, const mdxaHeader_t *mod,boneInfo_v &blist, const char *boneName, const int argStartFrame,
+						  const int argEndFrame, const int flags, const float animSpeed, const int currentTime, const float setFrame,
+						  const int blendTime, const int creationID, bool resetBonemap=true)
+{
+	int			index = G2_Find_Bone_Rag(&ghoul2, blist, boneName);
+	int			modFlags = flags;
+
+	int startFrame=argStartFrame;
+	int endFrame=argEndFrame;
+
+	if (index != -1)
+	{
+		blist[index].blendFrame = blist[index].blendLerpFrame = 0;
+		blist[index].blendTime = blist[index].blendStart = 0;
+		modFlags &= ~(BONE_ANIM_BLEND);
+
+		blist[index].endFrame = endFrame;
+		blist[index].startFrame = startFrame;
+		blist[index].animSpeed = animSpeed;
+		blist[index].pauseTime = 0;
+//		blist[index].boneMap = NULL;
+//		blist[index].lastTime = blist[index].startTime = (currentTime - (((setFrame - (float)startFrame) * 50.0)/ animSpeed));
+		blist[index].flags &= ~(BONE_ANIM_TOTAL);
+		blist[index].flags |= modFlags;
+
+		return qtrue;
+	}
+	
+	index = G2_Add_Bone(ghoul2.animModel, blist, boneName);
+
+	if (index != -1)
+	{
+		blist[index].blendFrame = blist[index].blendLerpFrame = 0;
+		blist[index].blendTime = 0;
+		modFlags &= ~(BONE_ANIM_BLEND);
+		blist[index].endFrame = endFrame;
+		blist[index].startFrame = startFrame;
+		blist[index].animSpeed = animSpeed;
+		blist[index].pauseTime = 0;
+//		blist[index].boneMap = NULL;
+//		blist[index].lastTime = blist[index].startTime = (currentTime - (((setFrame - (float)startFrame) * 50.0f)/ animSpeed));
+		blist[index].flags &= ~(BONE_ANIM_TOTAL);
+		blist[index].flags |= modFlags;
+
+		return qtrue;
+	}
+
+	assert(0);
+	return qfalse;
+}
+
+void G2_ResetRagDoll(CGhoul2Info_v &ghoul2V)
+{
+	int model;
+
+	for (model = 0; model < ghoul2V.size(); model++)
+	{
+		if (ghoul2V[model].mModelindex != -1)
+		{
+			break;
+		}
+	}
+	
+	if (model == ghoul2V.size())
+	{
+		return;
+	}
+
+	CGhoul2Info &ghoul2 = ghoul2V[model];
+
+	if (!(ghoul2.mFlags & GHOUL2_RAG_STARTED))
+	{ //no use in doing anything if we aren't ragging
+		return;
+	}
+
+	boneInfo_v &blist = ghoul2.mBlist;
+#if 1
+	//Eh, screw it. Ragdoll does a lot of terrible things to the bones that probably aren't directly reversible, so just reset it all.
+	//rwwFIXMEFIXME: I think SP might store bone indecies gameside.. which would make this cause terrible terrible things to happen.
+	//If so this needs to be done a better way somehow. Providing SP ever even needs to reset ragdoll, it's only used in MP on respawn.
+	G2_Init_Bone_List(blist);
+#else //The anims on every bone are messed up too, as are the angles. There's not really any way to get back to a normal state, so just clear the list
+	  //and let them re-set their anims/angles gameside.
+	int i = 0;
+	while (i < blist.size())
+	{
+		boneInfo_t &bone = blist[i];
+		if (bone.boneNumber != -1 && (bone.flags & BONE_ANGLES_RAGDOLL))
+		{
+			bone.flags &= ~BONE_ANGLES_RAGDOLL;
+			bone.flags &= ~BONE_ANGLES_IK;
+			bone.RagFlags = 0;
+			bone.lastTimeUpdated = 0;
+			VectorClear(bone.currentAngles);
+			bone.ragStartTime = 0;
+		}
+		i++;
+	}
+#endif
+	ghoul2.mFlags &= ~(GHOUL2_RAG_PENDING|GHOUL2_RAG_DONE|GHOUL2_RAG_STARTED);
+}
+
+//This is just a shell to avoid asserts on the initial position tracing
+class CRagDollInitialUpdateParams : public CRagDollUpdateParams
+{
+public:
+	virtual void EffectorCollision(const SRagDollEffectorCollision &data) 
+	{
+	}
+	virtual void RagDollBegin() 
+	{
+	}
+	virtual void RagDollSettled() 
+	{
+	}
+	virtual void Collision() 
+	{
+	}  
+	
+#ifdef _DEBUG
+	virtual void DebugLine(vec3_t p1,vec3_t p2,int color,bool bbox)
+	{
+	}
+#endif
+};
+
+void G2_SetRagDoll(CGhoul2Info_v &ghoul2V,CRagDollParams *parms)
+{
+	if (parms)
+	{
+		parms->CallRagDollBegin=false;
+	}
+	if (!broadsword||!broadsword->integer||!parms)
+	{
+		return;
+	}
+	int model;
+	for (model = 0; model < ghoul2V.size(); model++)
+	{
+		if (ghoul2V[model].mModelindex != -1)
+		{
+			break;
+		}
+	}
+	if (model==ghoul2V.size())
+	{
+		return;
+	}
+	CGhoul2Info &ghoul2=ghoul2V[model];
+	const mdxaHeader_t *mod_a=G2_GetModA(ghoul2);
+	if (!mod_a)
+	{
+		return;
+	}
+	int curTime=G2API_GetTime(0);
+	boneInfo_v &blist = ghoul2.mBlist;
+	int	index = G2_Find_Bone_Rag(&ghoul2, blist, "model_root");
+	switch (parms->RagPhase)
+	{
+	case CRagDollParams::ERagPhase::RP_START_DEATH_ANIM:
+		ghoul2.mFlags|=GHOUL2_RAG_PENDING;
+		return;  /// not doing anything with this yet
+		break;
+	case CRagDollParams::ERagPhase::RP_END_DEATH_ANIM:
+		ghoul2.mFlags|=GHOUL2_RAG_PENDING|GHOUL2_RAG_DONE;
+		if (broadsword_waitforshot &&
+			broadsword_waitforshot->integer)
+		{
+			if (broadsword_waitforshot->integer==2)
+			{
+				if (!(ghoul2.mFlags&(GHOUL2_RAG_COLLISION_DURING_DEATH|GHOUL2_RAG_COLLISION_SLIDE)))
+				{
+					//nothing was encountered, lets just wait for the first shot
+					return; // we ain't starting yet
+				}
+			}
+			else
+			{
+				return; // we ain't starting yet
+			}
+		}
+		break;
+	case CRagDollParams::ERagPhase::RP_DEATH_COLLISION:
+		if (parms->collisionType)
+		{
+			ghoul2.mFlags|=GHOUL2_RAG_COLLISION_SLIDE;
+		}
+		else
+		{
+			ghoul2.mFlags|=GHOUL2_RAG_COLLISION_DURING_DEATH;
+		}
+		if (broadsword_dontstopanim && broadsword_waitforshot &&
+			(broadsword_dontstopanim->integer || broadsword_waitforshot->integer)
+			)
+		{
+			if (!(ghoul2.mFlags&GHOUL2_RAG_DONE))
+			{
+				return; // we ain't starting yet
+			}
+		}
+		break;
+	case CRagDollParams::ERagPhase::RP_CORPSE_SHOT:
+		if (broadsword_kickorigin &&
+			broadsword_kickorigin->integer)
+		{
+			if (index>=0&&index<blist.size())
+			{
+				boneInfo_t &bone=blist[index];
+				if (bone.boneNumber>=0)
+				{
+					if (bone.flags & BONE_ANGLES_RAGDOLL)
+					{
+						//rww - Would need ent pointer here. But.. since this is SW, we aren't even having corpse shooting anyway I'd imagine.
+						/*
+						float magicFactor14=8.0f; //64.0f; // kick strength
+
+						if (parms->fShotStrength)
+						{ //if there is a shot strength, use it instead
+							magicFactor14 = parms->fShotStrength;
+						}
+
+						parms->me->s.pos.trType = TR_GRAVITY;
+						parms->me->s.pos.trDelta[0] += bone.lastShotDir[0]*magicFactor14;
+						parms->me->s.pos.trDelta[1] += bone.lastShotDir[1]*magicFactor14;
+						//parms->me->s.pos.trDelta[2] = fabsf(bone.lastShotDir[2])*magicFactor14;
+						//rww - The vertical portion of this doesn't seem to work very well
+						//I am just leaving it whatever it is for now, because my velocity scaling
+						//only works on x and y and the gravity stuff for NPCs is a bit unpleasent
+						//trying to change/work with
+						assert( !_isnan(bone.lastShotDir[1]));
+						*/
+					}
+				}
+			}
+		}
+		break;
+	case CRagDollParams::ERagPhase::RP_GET_PELVIS_OFFSET:
+		if (parms->RagPhase==CRagDollParams::ERagPhase::RP_GET_PELVIS_OFFSET)
+		{
+			VectorClear(parms->pelvisAnglesOffset);
+			VectorClear(parms->pelvisPositionOffset);
+		}
+		// intentional lack of a break
+	case CRagDollParams::ERagPhase::RP_SET_PELVIS_OFFSET:
+		if (index>=0&&index<blist.size())
+		{
+			boneInfo_t &bone=blist[index];
+			if (bone.boneNumber>=0)
+			{
+				if (bone.flags & BONE_ANGLES_RAGDOLL)
+				{
+					if (parms->RagPhase==CRagDollParams::ERagPhase::RP_GET_PELVIS_OFFSET)
+					{
+						VectorCopy(bone.anglesOffset,parms->pelvisAnglesOffset);
+						VectorCopy(bone.positionOffset,parms->pelvisPositionOffset);
+					}
+					else
+					{
+						VectorCopy(parms->pelvisAnglesOffset,bone.anglesOffset);
+						VectorCopy(parms->pelvisPositionOffset,bone.positionOffset);
+					}
+				}
+			}
+		}
+		return;
+		break;
+	case CRagDollParams::ERagPhase::RP_DISABLE_EFFECTORS:
+		// not doing anything with this yet
+		return;
+		break;
+	default:
+		assert(0);
+		return;
+		break;
+	}
+
+	if (ghoul2.mFlags&GHOUL2_RAG_STARTED)
+	{
+		// only going to begin ragdoll once, everything else depends on what happens to the origin
+		return;
+	}
+#if 0
+if (index>=0)
+{
+	OutputDebugString(va("death %d %d\n",blist[index].startFrame,blist[index].endFrame));
+}
+#endif
+
+	ghoul2.mFlags|=GHOUL2_RAG_PENDING|GHOUL2_RAG_DONE|GHOUL2_RAG_STARTED;  // well anyway we are going live
+	parms->CallRagDollBegin=true;
+
+	G2_GenerateWorldMatrix(parms->angles, parms->position);
+	G2_ConstructGhoulSkeleton(ghoul2V, curTime, false, parms->scale);
+#if 1
+	G2_Set_Bone_Rag(mod_a,blist,"model_root",ghoul2,parms->scale,parms->position);
+	G2_Set_Bone_Rag(mod_a,blist,"pelvis",ghoul2,parms->scale,parms->position);
+
+	G2_Set_Bone_Rag(mod_a,blist,"lower_lumbar",ghoul2,parms->scale,parms->position);
+	G2_Set_Bone_Rag(mod_a,blist,"upper_lumbar",ghoul2,parms->scale,parms->position);
+	G2_Set_Bone_Rag(mod_a,blist,"thoracic",ghoul2,parms->scale,parms->position);
+	G2_Set_Bone_Rag(mod_a,blist,"cranium",ghoul2,parms->scale,parms->position);
+	G2_Set_Bone_Rag(mod_a,blist,"rhumerus",ghoul2,parms->scale,parms->position);
+	G2_Set_Bone_Rag(mod_a,blist,"lhumerus",ghoul2,parms->scale,parms->position);
+	G2_Set_Bone_Rag(mod_a,blist,"rradius",ghoul2,parms->scale,parms->position);
+	G2_Set_Bone_Rag(mod_a,blist,"lradius",ghoul2,parms->scale,parms->position);
+	G2_Set_Bone_Rag(mod_a,blist,"rfemurYZ",ghoul2,parms->scale,parms->position);
+	G2_Set_Bone_Rag(mod_a,blist,"lfemurYZ",ghoul2,parms->scale,parms->position);
+	G2_Set_Bone_Rag(mod_a,blist,"rtibia",ghoul2,parms->scale,parms->position);
+	G2_Set_Bone_Rag(mod_a,blist,"ltibia",ghoul2,parms->scale,parms->position);
+	G2_Set_Bone_Rag(mod_a,blist,"rhand",ghoul2,parms->scale,parms->position);
+	G2_Set_Bone_Rag(mod_a,blist,"lhand",ghoul2,parms->scale,parms->position);
+	//G2_Set_Bone_Rag(mod_a,blist,"rtarsal",ghoul2,parms->scale,parms->position);
+	//G2_Set_Bone_Rag(mod_a,blist,"ltarsal",ghoul2,parms->scale,parms->position);
+	G2_Set_Bone_Rag(mod_a,blist,"rtalus",ghoul2,parms->scale,parms->position);
+	G2_Set_Bone_Rag(mod_a,blist,"ltalus",ghoul2,parms->scale,parms->position);
+	G2_Set_Bone_Rag(mod_a,blist,"rradiusX",ghoul2,parms->scale,parms->position);
+	G2_Set_Bone_Rag(mod_a,blist,"lradiusX",ghoul2,parms->scale,parms->position);
+	G2_Set_Bone_Rag(mod_a,blist,"rfemurX",ghoul2,parms->scale,parms->position);
+	G2_Set_Bone_Rag(mod_a,blist,"lfemurX",ghoul2,parms->scale,parms->position);
+	G2_Set_Bone_Rag(mod_a,blist,"ceyebrow",ghoul2,parms->scale,parms->position);
+#else
+	G2_Set_Bone_Rag(mod_a,blist,"model_root",ghoul2,parms->scale,parms->position);
+	G2_Set_Bone_Rag(mod_a,blist,"pelvis",ghoul2,parms->scale,parms->position);
+	G2_Set_Bone_Rag(mod_a,blist,"lfemurYZ",ghoul2,parms->scale,parms->position);
+	G2_Set_Bone_Rag(mod_a,blist,"ltibia",ghoul2,parms->scale,parms->position);
+	G2_Set_Bone_Rag(mod_a,blist,"rfemurYZ",ghoul2,parms->scale,parms->position);
+	G2_Set_Bone_Rag(mod_a,blist,"rtibia",ghoul2,parms->scale,parms->position);
+	G2_Set_Bone_Rag(mod_a,blist,"lower_lumbar",ghoul2,parms->scale,parms->position);
+	G2_Set_Bone_Rag(mod_a,blist,"upper_lumbar",ghoul2,parms->scale,parms->position);
+	G2_Set_Bone_Rag(mod_a,blist,"thoracic",ghoul2,parms->scale,parms->position);
+	G2_Set_Bone_Rag(mod_a,blist,"cervical",ghoul2,parms->scale,parms->position);
+	G2_Set_Bone_Rag(mod_a,blist,"ceyebrow",ghoul2,parms->scale,parms->position);
+	G2_Set_Bone_Rag(mod_a,blist,"rhumerus",ghoul2,parms->scale,parms->position);
+	G2_Set_Bone_Rag(mod_a,blist,"rradius",ghoul2,parms->scale,parms->position);
+	G2_Set_Bone_Rag(mod_a,blist,"lhumerus",ghoul2,parms->scale,parms->position);
+	G2_Set_Bone_Rag(mod_a,blist,"lradius",ghoul2,parms->scale,parms->position);
+	G2_Set_Bone_Rag(mod_a,blist,"lfemurX",ghoul2,parms->scale,parms->position);
+	G2_Set_Bone_Rag(mod_a,blist,"ltalus",ghoul2,parms->scale,parms->position);
+	G2_Set_Bone_Rag(mod_a,blist,"rfemurX",ghoul2,parms->scale,parms->position);
+	G2_Set_Bone_Rag(mod_a,blist,"rtalus",ghoul2,parms->scale,parms->position);
+	G2_Set_Bone_Rag(mod_a,blist,"rhumerusX",ghoul2,parms->scale,parms->position);
+	G2_Set_Bone_Rag(mod_a,blist,"rradiusX",ghoul2,parms->scale,parms->position);
+	G2_Set_Bone_Rag(mod_a,blist,"rhand",ghoul2,parms->scale,parms->position);
+	G2_Set_Bone_Rag(mod_a,blist,"lhumerusX",ghoul2,parms->scale,parms->position);
+	G2_Set_Bone_Rag(mod_a,blist,"lradiusX",ghoul2,parms->scale,parms->position);
+	G2_Set_Bone_Rag(mod_a,blist,"lhand",ghoul2,parms->scale,parms->position);
+#endif
+	//int startFrame = 3665, endFrame = 3665+1;
+	int startFrame = parms->startFrame, endFrame = parms->endFrame;
+	assert(startFrame < mod_a->numFrames);
+	assert(endFrame   < mod_a->numFrames);
+
+	G2_Set_Bone_Anim_No_BS(ghoul2, mod_a,blist,"upper_lumbar",startFrame,endFrame-1,
+		BONE_ANIM_OVERRIDE_FREEZE|BONE_ANIM_BLEND,
+		1.0f,curTime,float(startFrame),150,0,true);
+	G2_Set_Bone_Anim_No_BS(ghoul2, mod_a,blist,"lower_lumbar",startFrame,endFrame-1,
+		BONE_ANIM_OVERRIDE_FREEZE|BONE_ANIM_BLEND,
+		1.0f,curTime,float(startFrame),150,0,true);
+	G2_Set_Bone_Anim_No_BS(ghoul2, mod_a,blist,"Motion",startFrame,endFrame-1,
+		BONE_ANIM_OVERRIDE_FREEZE|BONE_ANIM_BLEND,
+		1.0f,curTime,float(startFrame),150,0,true);
+//	G2_Set_Bone_Anim_No_BS(ghoul2, mod_a,blist,"model_root",startFrame,endFrame-1,
+//		BONE_ANIM_OVERRIDE_FREEZE|BONE_ANIM_BLEND,
+//		1.0f,curTime,float(startFrame),150,0,true);
+	G2_Set_Bone_Anim_No_BS(ghoul2, mod_a,blist,"lfemurYZ",startFrame,endFrame-1,
+		BONE_ANIM_OVERRIDE_FREEZE|BONE_ANIM_BLEND,
+		1.0f,curTime,float(startFrame),150,0,true);
+	G2_Set_Bone_Anim_No_BS(ghoul2, mod_a,blist,"rfemurYZ",startFrame,endFrame-1,
+		BONE_ANIM_OVERRIDE_FREEZE|BONE_ANIM_BLEND,
+		1.0f,curTime,float(startFrame),150,0,true);
+
+	G2_Set_Bone_Anim_No_BS(ghoul2, mod_a,blist,"rhumerus",startFrame,endFrame-1,
+		BONE_ANIM_OVERRIDE_FREEZE|BONE_ANIM_BLEND,
+		1.0f,curTime,float(startFrame),150,0,true);
+	G2_Set_Bone_Anim_No_BS(ghoul2, mod_a,blist,"lhumerus",startFrame,endFrame-1,
+		BONE_ANIM_OVERRIDE_FREEZE|BONE_ANIM_BLEND,
+		1.0f,curTime,float(startFrame),150,0,true);
+
+//    should already be set					G2_GenerateWorldMatrix(parms->angles, parms->position);
+	G2_ConstructGhoulSkeleton(ghoul2V, curTime, false, parms->scale);
+#if 1
+	static const float fRadScale = 0.3f;//0.5f;
+
+	vec3_t pcjMin,pcjMax;
+	VectorSet(pcjMin,-90.0f,-45.0f,-45.0f);
+	VectorSet(pcjMax,90.0f,45.0f,45.0f);
+	G2_Set_Bone_Angles_Rag(ghoul2, mod_a,blist,"model_root",RAG_PCJ_MODEL_ROOT|RAG_PCJ|RAG_UNSNAPPABLE,10.0f*fRadScale,pcjMin,pcjMax,100);
+	VectorSet(pcjMin,-45.0f,-45.0f,-45.0f);
+	VectorSet(pcjMax,45.0f,45.0f,45.0f);
+	G2_Set_Bone_Angles_Rag(ghoul2, mod_a,blist,"pelvis",RAG_PCJ_PELVIS|RAG_PCJ|RAG_PCJ_POST_MULT|RAG_UNSNAPPABLE,10.0f*fRadScale,pcjMin,pcjMax,100);
+
+	// new base anim, unconscious flop
+	int pcjflags=RAG_PCJ|RAG_PCJ_POST_MULT;//|RAG_EFFECTOR;
+
+	VectorSet(pcjMin,-15.0f,-15.0f,-15.0f);
+	VectorSet(pcjMax,15.0f,15.0f,15.0f);
+	G2_Set_Bone_Angles_Rag(ghoul2, mod_a,blist,"lower_lumbar",pcjflags|RAG_UNSNAPPABLE,10.0f*fRadScale,pcjMin,pcjMax,500);
+	G2_Set_Bone_Angles_Rag(ghoul2, mod_a,blist,"upper_lumbar",pcjflags|RAG_UNSNAPPABLE,10.0f*fRadScale,pcjMin,pcjMax,500);
+	VectorSet(pcjMin,-25.0f,-25.0f,-25.0f);
+	VectorSet(pcjMax,25.0f,25.0f,25.0f);
+	G2_Set_Bone_Angles_Rag(ghoul2, mod_a,blist,"thoracic",pcjflags|RAG_EFFECTOR|RAG_UNSNAPPABLE,12.0f*fRadScale,pcjMin,pcjMax,500);
+
+	VectorSet(pcjMin,-10.0f,-10.0f,-90.0f);
+	VectorSet(pcjMax,10.0f,10.0f,90.0f);
+	G2_Set_Bone_Angles_Rag(ghoul2, mod_a,blist,"cranium",pcjflags|RAG_BONE_LIGHTWEIGHT|RAG_UNSNAPPABLE,6.0f*fRadScale,pcjMin,pcjMax,500);
+
+	static const float sFactLeg = 1.0f;
+	static const float sFactArm = 1.0f;
+	static const float sRadArm = 1.0f;
+	static const float sRadLeg = 1.0f;
+
+	VectorSet(pcjMin,-100.0f,-40.0f,-15.0f);
+	VectorSet(pcjMax,-15.0f,80.0f,15.0f);
+	VectorScale(pcjMin, sFactArm, pcjMin);
+	VectorScale(pcjMax, sFactArm, pcjMax);
+	G2_Set_Bone_Angles_Rag(ghoul2, mod_a,blist,"rhumerus",pcjflags|RAG_BONE_LIGHTWEIGHT|RAG_UNSNAPPABLE,(4.0f*sRadArm)*fRadScale,pcjMin,pcjMax,500);
+	VectorSet(pcjMin,-50.0f,-80.0f,-15.0f);
+	VectorSet(pcjMax,15.0f,40.0f,15.0f);
+	VectorScale(pcjMin, sFactArm, pcjMin);
+	VectorScale(pcjMax, sFactArm, pcjMax);
+	G2_Set_Bone_Angles_Rag(ghoul2, mod_a,blist,"lhumerus",pcjflags|RAG_BONE_LIGHTWEIGHT|RAG_UNSNAPPABLE,(4.0f*sRadArm)*fRadScale,pcjMin,pcjMax,500);
+
+	VectorSet(pcjMin,-25.0f,-20.0f,-20.0f);
+	VectorSet(pcjMax,90.0f,20.0f,-20.0f);
+	VectorScale(pcjMin, sFactArm, pcjMin);
+	VectorScale(pcjMax, sFactArm, pcjMax);
+	G2_Set_Bone_Angles_Rag(ghoul2, mod_a,blist,"rradius",pcjflags|RAG_BONE_LIGHTWEIGHT,(3.0f*sRadArm)*fRadScale,pcjMin,pcjMax,500);
+	VectorSet(pcjMin,-90.0f,-20.0f,-20.0f);
+	VectorSet(pcjMax,30.0f,20.0f,-20.0f);
+	VectorScale(pcjMin, sFactArm, pcjMin);
+	VectorScale(pcjMax, sFactArm, pcjMax);
+	G2_Set_Bone_Angles_Rag(ghoul2, mod_a,blist,"lradius",pcjflags|RAG_BONE_LIGHTWEIGHT,(3.0f*sRadArm)*fRadScale,pcjMin,pcjMax,500);
+
+
+	VectorSet(pcjMin,-80.0f,-50.0f,-20.0f);
+	VectorSet(pcjMax,30.0f,5.0f,20.0f);
+	VectorScale(pcjMin, sFactLeg, pcjMin);
+	VectorScale(pcjMax, sFactLeg, pcjMax);
+	G2_Set_Bone_Angles_Rag(ghoul2, mod_a,blist,"rfemurYZ",pcjflags|RAG_BONE_LIGHTWEIGHT,(6.0f*sRadLeg)*fRadScale,pcjMin,pcjMax,500);
+	VectorSet(pcjMin,-60.0f,-5.0f,-20.0f);
+	VectorSet(pcjMax,50.0f,50.0f,20.0f);
+	VectorScale(pcjMin, sFactLeg, pcjMin);
+	VectorScale(pcjMax, sFactLeg, pcjMax);
+	G2_Set_Bone_Angles_Rag(ghoul2, mod_a,blist,"lfemurYZ",pcjflags|RAG_BONE_LIGHTWEIGHT,(6.0f*sRadLeg)*fRadScale,pcjMin,pcjMax,500);
+
+	VectorSet(pcjMin,-20.0f,-15.0f,-15.0f);
+	VectorSet(pcjMax,100.0f,15.0f,15.0f);
+	VectorScale(pcjMin, sFactLeg, pcjMin);
+	VectorScale(pcjMax, sFactLeg, pcjMax);
+	G2_Set_Bone_Angles_Rag(ghoul2, mod_a,blist,"rtibia",pcjflags|RAG_EFFECTOR|RAG_BONE_LIGHTWEIGHT,(4.0f*sRadLeg)*fRadScale,pcjMin,pcjMax,500);
+	VectorSet(pcjMin,20.0f,-15.0f,-15.0f);
+	VectorSet(pcjMax,100.0f,15.0f,15.0f);
+	VectorScale(pcjMin, sFactLeg, pcjMin);
+	VectorScale(pcjMax, sFactLeg, pcjMax);
+	G2_Set_Bone_Angles_Rag(ghoul2, mod_a,blist,"ltibia",pcjflags|RAG_EFFECTOR|RAG_BONE_LIGHTWEIGHT,(4.0f*sRadLeg)*fRadScale,pcjMin,pcjMax,500);
+
+	float sRadEArm = 1.2f;
+	float sRadELeg = 1.2f;
+
+//	int rhand=
+	G2_Set_Bone_Angles_Rag(ghoul2, mod_a,blist,"rhand",RAG_EFFECTOR|RAG_BONE_LIGHTWEIGHT,(6.0f*sRadEArm)*fRadScale);
+	G2_Set_Bone_Angles_Rag(ghoul2, mod_a,blist,"lhand",RAG_EFFECTOR|RAG_BONE_LIGHTWEIGHT,(6.0f*sRadEArm)*fRadScale);
+	//G2_Set_Bone_Angles_Rag(ghoul2, mod_a,blist,"rtarsal",RAG_EFFECTOR|RAG_BONE_LIGHTWEIGHT,(4.0f*sRadELeg)*fRadScale);
+	//G2_Set_Bone_Angles_Rag(ghoul2, mod_a,blist,"ltarsal",RAG_EFFECTOR|RAG_BONE_LIGHTWEIGHT,(4.0f*sRadELeg)*fRadScale);
+	G2_Set_Bone_Angles_Rag(ghoul2, mod_a,blist,"rtalus",RAG_EFFECTOR|RAG_BONE_LIGHTWEIGHT,(4.0f*sRadELeg)*fRadScale);
+	G2_Set_Bone_Angles_Rag(ghoul2, mod_a,blist,"ltalus",RAG_EFFECTOR|RAG_BONE_LIGHTWEIGHT,(4.0f*sRadELeg)*fRadScale);
+	G2_Set_Bone_Angles_Rag(ghoul2, mod_a,blist,"rradiusX",RAG_EFFECTOR|RAG_BONE_LIGHTWEIGHT,(6.0f*sRadEArm)*fRadScale);
+	G2_Set_Bone_Angles_Rag(ghoul2, mod_a,blist,"lradiusX",RAG_EFFECTOR|RAG_BONE_LIGHTWEIGHT,(6.0f*sRadEArm)*fRadScale);
+	G2_Set_Bone_Angles_Rag(ghoul2, mod_a,blist,"rfemurX",RAG_EFFECTOR|RAG_BONE_LIGHTWEIGHT,(10.0f*sRadELeg)*fRadScale);
+	G2_Set_Bone_Angles_Rag(ghoul2, mod_a,blist,"lfemurX",RAG_EFFECTOR|RAG_BONE_LIGHTWEIGHT,(10.0f*sRadELeg)*fRadScale);
+	//G2_Set_Bone_Angles_Rag(ghoul2, mod_a,blist,"ceyebrow",RAG_EFFECTOR|RAG_BONE_LIGHTWEIGHT,10.0f*fRadScale);
+	G2_Set_Bone_Angles_Rag(ghoul2, mod_a,blist,"ceyebrow",RAG_EFFECTOR|RAG_BONE_LIGHTWEIGHT,5.0f);
+#else
+	static const float fRadScale = 0.3f;//0.5f;
+	static int pcjflags = RAG_PCJ|RAG_PCJ_POST_MULT;//|RAG_EFFECTOR;
+	static const float sFactLeg = 1.0f;
+	static const float sFactArm = 1.0f;
+	static const float sRadArm = 1.0f;
+	static const float sRadLeg = 1.0f;
+
+	vec3_t pcjMin,pcjMax;
+	VectorSet(pcjMin,-90.0f,-45.0f,-45.0f);
+	VectorSet(pcjMax,90.0f,45.0f,45.0f);
+	G2_Set_Bone_Angles_Rag(ghoul2, mod_a,blist,"model_root",RAG_PCJ_MODEL_ROOT|RAG_PCJ|RAG_UNSNAPPABLE,10.0f*fRadScale,pcjMin,pcjMax,100);
+	VectorSet(pcjMin,-45.0f,-45.0f,-45.0f);
+	VectorSet(pcjMax,45.0f,45.0f,45.0f);
+	G2_Set_Bone_Angles_Rag(ghoul2, mod_a,blist,"pelvis",RAG_PCJ_PELVIS|RAG_PCJ|RAG_PCJ_POST_MULT|RAG_UNSNAPPABLE,10.0f*fRadScale,pcjMin,pcjMax,100);
+
+	//PCJ/EFFECTORS
+	VectorSet(pcjMin,-80.0f,-50.0f,-20.0f);
+	VectorSet(pcjMax,30.0f,5.0f,20.0f);
+	VectorScale(pcjMin, sFactLeg, pcjMin);
+	VectorScale(pcjMax, sFactLeg, pcjMax);
+	G2_Set_Bone_Angles_Rag(ghoul2, mod_a,blist,"rfemurYZ",pcjflags|RAG_BONE_LIGHTWEIGHT,(6.0f*sRadLeg)*fRadScale,pcjMin,pcjMax,500);
+	VectorSet(pcjMin,-60.0f,-5.0f,-20.0f);
+	VectorSet(pcjMax,50.0f,50.0f,20.0f);
+	VectorScale(pcjMin, sFactLeg, pcjMin);
+	VectorScale(pcjMax, sFactLeg, pcjMax);
+	G2_Set_Bone_Angles_Rag(ghoul2, mod_a,blist,"lfemurYZ",pcjflags|RAG_BONE_LIGHTWEIGHT,(6.0f*sRadLeg)*fRadScale,pcjMin,pcjMax,500);
+
+	VectorSet(pcjMin,-20.0f,-15.0f,-15.0f);
+	VectorSet(pcjMax,100.0f,15.0f,15.0f);
+	VectorScale(pcjMin, sFactLeg, pcjMin);
+	VectorScale(pcjMax, sFactLeg, pcjMax);
+	G2_Set_Bone_Angles_Rag(ghoul2, mod_a,blist,"rtibia",pcjflags|RAG_EFFECTOR|RAG_BONE_LIGHTWEIGHT,(4.0f*sRadLeg)*fRadScale,pcjMin,pcjMax,500);
+	VectorSet(pcjMin,20.0f,-15.0f,-15.0f);
+	VectorSet(pcjMax,100.0f,15.0f,15.0f);
+	VectorScale(pcjMin, sFactLeg, pcjMin);
+	VectorScale(pcjMax, sFactLeg, pcjMax);
+	G2_Set_Bone_Angles_Rag(ghoul2, mod_a,blist,"ltibia",pcjflags|RAG_EFFECTOR|RAG_BONE_LIGHTWEIGHT,(4.0f*sRadLeg)*fRadScale,pcjMin,pcjMax,500);
+
+
+	VectorSet(pcjMin,-15.0f,-15.0f,-15.0f);
+	VectorSet(pcjMax,15.0f,15.0f,15.0f);
+	G2_Set_Bone_Angles_Rag(ghoul2, mod_a,blist,"lower_lumbar",pcjflags|RAG_EFFECTOR|RAG_UNSNAPPABLE,10.0f*fRadScale,pcjMin,pcjMax,500);
+	G2_Set_Bone_Angles_Rag(ghoul2, mod_a,blist,"upper_lumbar",pcjflags|RAG_EFFECTOR|RAG_UNSNAPPABLE,10.0f*fRadScale,pcjMin,pcjMax,500);
+	VectorSet(pcjMin,-25.0f,-25.0f,-25.0f);
+	VectorSet(pcjMax,25.0f,25.0f,25.0f);
+	G2_Set_Bone_Angles_Rag(ghoul2, mod_a,blist,"thoracic",pcjflags|RAG_EFFECTOR|RAG_UNSNAPPABLE,12.0f*fRadScale,pcjMin,pcjMax,500);
+
+	VectorSet(pcjMin,-10.0f,-10.0f,-90.0f);
+	VectorSet(pcjMax,10.0f,10.0f,90.0f);
+	G2_Set_Bone_Angles_Rag(ghoul2, mod_a,blist,"cranium",RAG_PCJ|RAG_PCJ_POST_MULT|RAG_BONE_LIGHTWEIGHT|RAG_UNSNAPPABLE,6.0f*fRadScale,pcjMin,pcjMax,500);
+
+	VectorSet(pcjMin,-100.0f,-40.0f,-15.0f);
+	VectorSet(pcjMax,-15.0f,80.0f,15.0f);
+	VectorScale(pcjMin, sFactArm, pcjMin);
+	VectorScale(pcjMax, sFactArm, pcjMax);
+	G2_Set_Bone_Angles_Rag(ghoul2, mod_a,blist,"rhumerus",pcjflags|RAG_BONE_LIGHTWEIGHT,(4.0f*sRadArm)*fRadScale,pcjMin,pcjMax,500);
+	VectorSet(pcjMin,-50.0f,-80.0f,-15.0f);
+	VectorSet(pcjMax,15.0f,40.0f,15.0f);
+	VectorScale(pcjMin, sFactArm, pcjMin);
+	VectorScale(pcjMax, sFactArm, pcjMax);
+	G2_Set_Bone_Angles_Rag(ghoul2, mod_a,blist,"lhumerus",pcjflags|RAG_BONE_LIGHTWEIGHT,(4.0f*sRadArm)*fRadScale,pcjMin,pcjMax,500);
+
+	VectorSet(pcjMin,-25.0f,-20.0f,-20.0f);
+	VectorSet(pcjMax,90.0f,20.0f,-20.0f);
+	VectorScale(pcjMin, sFactArm, pcjMin);
+	VectorScale(pcjMax, sFactArm, pcjMax);
+	G2_Set_Bone_Angles_Rag(ghoul2, mod_a,blist,"rradius",pcjflags|RAG_EFFECTOR|RAG_BONE_LIGHTWEIGHT,(3.0f*sRadArm)*fRadScale,pcjMin,pcjMax,500);
+	VectorSet(pcjMin,-90.0f,-20.0f,-20.0f);
+	VectorSet(pcjMax,30.0f,20.0f,-20.0f);
+	VectorScale(pcjMin, sFactArm, pcjMin);
+	VectorScale(pcjMax, sFactArm, pcjMax);
+	G2_Set_Bone_Angles_Rag(ghoul2, mod_a,blist,"lradius",pcjflags|RAG_EFFECTOR|RAG_BONE_LIGHTWEIGHT,(3.0f*sRadArm)*fRadScale,pcjMin,pcjMax,500);
+
+
+	//EFFECTORS
+	static const float sRadEArm = 1.2f;
+	static const float sRadELeg = 1.2f;
+
+	G2_Set_Bone_Angles_Rag(ghoul2, mod_a,blist,"cervical",RAG_EFFECTOR|RAG_BONE_LIGHTWEIGHT,10.0f*fRadScale);
+	G2_Set_Bone_Angles_Rag(ghoul2, mod_a,blist,"ceyebrow",RAG_EFFECTOR|RAG_BONE_LIGHTWEIGHT,10.0f*fRadScale);
+//	G2_Set_Bone_Angles_Rag(ghoul2, mod_a,blist,"rfemurX",RAG_EFFECTOR|RAG_BONE_LIGHTWEIGHT,(10.0f*sRadELeg)*fRadScale);
+//	G2_Set_Bone_Angles_Rag(ghoul2, mod_a,blist,"lfemurX",RAG_EFFECTOR|RAG_BONE_LIGHTWEIGHT,(10.0f*sRadELeg)*fRadScale);
+	G2_Set_Bone_Angles_Rag(ghoul2, mod_a,blist,"rtalus",RAG_EFFECTOR|RAG_BONE_LIGHTWEIGHT,(4.0f*sRadELeg)*fRadScale);
+	G2_Set_Bone_Angles_Rag(ghoul2, mod_a,blist,"ltalus",RAG_EFFECTOR|RAG_BONE_LIGHTWEIGHT,(4.0f*sRadELeg)*fRadScale);
+//	G2_Set_Bone_Angles_Rag(ghoul2, mod_a,blist,"rhumerusX",RAG_EFFECTOR|RAG_BONE_LIGHTWEIGHT,(6.0f*sRadEArm)*fRadScale);
+//	G2_Set_Bone_Angles_Rag(ghoul2, mod_a,blist,"lhumerusX",RAG_EFFECTOR|RAG_BONE_LIGHTWEIGHT,(6.0f*sRadEArm)*fRadScale);
+//	G2_Set_Bone_Angles_Rag(ghoul2, mod_a,blist,"rradiusX",RAG_EFFECTOR|RAG_BONE_LIGHTWEIGHT,(6.0f*sRadEArm)*fRadScale);
+//	G2_Set_Bone_Angles_Rag(ghoul2, mod_a,blist,"lradiusX",RAG_EFFECTOR|RAG_BONE_LIGHTWEIGHT,(6.0f*sRadEArm)*fRadScale);
+	G2_Set_Bone_Angles_Rag(ghoul2, mod_a,blist,"rhand",RAG_EFFECTOR|RAG_BONE_LIGHTWEIGHT,(6.0f*sRadEArm)*fRadScale);
+	G2_Set_Bone_Angles_Rag(ghoul2, mod_a,blist,"lhand",RAG_EFFECTOR|RAG_BONE_LIGHTWEIGHT,(6.0f*sRadEArm)*fRadScale);
+#endif
+//match the currrent animation
+	if (!G2_RagDollSetup(ghoul2,curTime,true,parms->position,false))
+	{
+		assert(!"failed to add any rag bones");
+		return;
+	}
+	G2_RagDollCurrentPosition(ghoul2V,model,curTime,parms->angles,parms->position,parms->scale);
+
+	int k;
+
+	CRagDollInitialUpdateParams fparms;
+	VectorCopy(parms->position, fparms.position);
+	VectorCopy(parms->angles, fparms.angles);
+	VectorCopy(parms->scale, fparms.scale);
+	VectorClear(fparms.velocity);
+	fparms.me = parms->me;
+	fparms.settleFrame = parms->endFrame;
+	fparms.groundEnt = parms->groundEnt;
+
+	//Guess I don't need to do this, do I?
+	G2_ConstructGhoulSkeleton(ghoul2V, curTime, false, parms->scale);
+
+	vec3_t dPos;
+	VectorCopy(parms->position, dPos);
+#ifdef _OLD_STYLE_SETTLE
+	dPos[2] -= 6;
+#endif
+
+	for (k=0;k</*10*/20;k++)
+	{
+		G2_RagDollSettlePositionNumeroTrois(ghoul2V,dPos,&fparms,curTime);
+
+		G2_RagDollCurrentPosition(ghoul2V,model,curTime,parms->angles,dPos,parms->scale);
+		G2_RagDollMatchPosition();
+		G2_RagDollSolve(ghoul2V,model,1.0f*(1.0f-k/40.0f),curTime,dPos,false);
+	}
+}
+
+void G2_SetRagDollBullet(CGhoul2Info &ghoul2,const vec3_t rayStart,const vec3_t hit)
+{
+	if (!broadsword||!broadsword->integer)
+	{
+		return;
+	}
+	vec3_t shotDir;
+	VectorSubtract(hit,rayStart,shotDir);
+	float len=VectorLength(shotDir);
+	if (len<1.0f)
+	{
+		return;
+	}
+	float lenr=1.0f/len;
+	shotDir[0]*=lenr;
+	shotDir[1]*=lenr;
+	shotDir[2]*=lenr;
+
+	bool firstOne=false;
+	if (broadsword_kickbones&&broadsword_kickbones->integer)
+	{
+		int i;
+		int		magicFactor13=150.0f; // squared radius multiplier for shot effects
+		boneInfo_v &blist = ghoul2.mBlist;
+		for(i=blist.size()-1;i>=0;i--)
+		{
+			boneInfo_t &bone=blist[i];
+			if ((bone.flags & BONE_ANGLES_TOTAL))
+			{
+				if (bone.flags & BONE_ANGLES_RAGDOLL)
+				{
+					if (!firstOne)
+					{
+						firstOne=true;
+#if 0
+						int curTime=G2API_GetTime(0);
+						const mdxaHeader_t *mod_a=G2_GetModA(ghoul2);
+						int startFrame = 0, endFrame = 0;
+#if 1
+						TheGhoul2Wraith()->GetAnimFrames(ghoul2.mID, "unconsciousdeadflop01", startFrame, endFrame);
+						if (startFrame == -1 && endFrame == -1)
+						{ //A bad thing happened! Just use the hardcoded numbers even though they could be wrong.
+							startFrame = 3573;
+							endFrame = 3583;
+							assert(0);
+						}
+						G2_Set_Bone_Anim_No_BS(mod_a,blist,"upper_lumbar",startFrame,endFrame-1,
+							BONE_ANIM_OVERRIDE_FREEZE|BONE_ANIM_BLEND,
+							1.0f,curTime,float(startFrame),75,0,true);
+						G2_Set_Bone_Anim_No_BS(mod_a,blist,"lfemurYZ",startFrame,endFrame-1,
+							BONE_ANIM_OVERRIDE_FREEZE|BONE_ANIM_BLEND,
+							1.0f,curTime,float(startFrame),75,0,true);
+						G2_Set_Bone_Anim_No_BS(mod_a,blist,"rfemurYZ",startFrame,endFrame-1,
+							BONE_ANIM_OVERRIDE_FREEZE|BONE_ANIM_BLEND,
+							1.0f,curTime,float(startFrame),75,0,true);
+#else
+						TheGhoul2Wraith()->GetAnimFrames(ghoul2.mID, "backdeadflop01", startFrame, endFrame);
+						if (startFrame == -1 && endFrame == -1)
+						{ //A bad thing happened! Just use the hardcoded numbers even though they could be wrong.
+							startFrame = 3581;
+							endFrame = 3592;
+							assert(0);
+						}
+						G2_Set_Bone_Anim_No_BS(mod_a,blist,"upper_lumbar",endFrame,startFrame+1,
+							BONE_ANIM_OVERRIDE_FREEZE,
+							-1.0f,curTime,float(endFrame-1),50,0,true);
+						G2_Set_Bone_Anim_No_BS(mod_a,blist,"lfemurYZ",endFrame,startFrame+1,
+							BONE_ANIM_OVERRIDE_FREEZE,
+							-1.0f,curTime,float(endFrame-1),50,0,true);
+						G2_Set_Bone_Anim_No_BS(mod_a,blist,"rfemurYZ",endFrame,startFrame+1,
+							BONE_ANIM_OVERRIDE_FREEZE,
+							-1.0f,curTime,float(endFrame-1),50,0,true);
+#endif
+#endif
+					}
+
+					VectorCopy(shotDir,bone.lastShotDir);
+					vec3_t dir;
+					VectorSubtract(bone.lastPosition,hit,dir);
+					len=VectorLength(dir);
+					if (len<1.0f)
+					{
+						len=1.0f;
+					}
+					lenr=1.0f/len;
+					float effect=lenr;
+					effect*=magicFactor13*effect; // this is cubed, one of them is absorbed by the next calc
+					bone.velocityEffector[0]=shotDir[0]*(effect+flrand(0.0f,0.05f));
+					bone.velocityEffector[1]=shotDir[1]*(effect+flrand(0.0f,0.05f));
+					bone.velocityEffector[2]=fabs(shotDir[2])*(effect+flrand(0.0f,0.05f));
+//					bone.velocityEffector[0]=shotDir[0]*(effect+flrand(0.0f,0.05f))*flrand(-0.1f,3.0f);
+//					bone.velocityEffector[1]=shotDir[1]*(effect+flrand(0.0f,0.05f))*flrand(-0.1f,3.0f);
+//					bone.velocityEffector[2]=fabs(shotDir[2])*(effect+flrand(0.0f,0.05f))*flrand(-0.1f,3.0f);
+					assert( !_isnan(shotDir[2]));
+	//				bone.currentAngles[0]+=flrand(-10.0f*lenr,10.0f*lenr);
+	//				bone.currentAngles[1]+=flrand(-10.0f*lenr,10.0f*lenr);
+	//				bone.currentAngles[2]+=flrand(-10.0f*lenr,10.0f*lenr);
+	//				bone.lastAngles[0]+=flrand(-10.0f*lenr,10.0f*lenr);
+	//				bone.lastAngles[1]+=flrand(-10.0f*lenr,10.0f*lenr);
+	//				bone.lastAngles[2]+=flrand(-10.0f*lenr,10.0f*lenr);
+
+					// go dynamic
+					bone.firstCollisionTime=G2API_GetTime(0);
+//					bone.firstCollisionTime=0;
+					bone.restTime=0;
+				}
+			}
+		}
+	}
+}
+
+
+static float G2_RagSetState(CGhoul2Info &ghoul2, boneInfo_t &bone,int frameNum,const vec3_t origin,bool &resetOrigin)
+{
+	ragOriginChange=DistanceSquared(origin,bone.extraVec1);
+	VectorSubtract(origin,bone.extraVec1,ragOriginChangeDir);
+
+	float decay=1.0f;
+
+	int dynamicTime=1000;
+	int settleTime=1000;
+
+	if (ghoul2.mFlags & GHOUL2_RAG_FORCESOLVE)
+	{
+		ragState=ERS_DYNAMIC;
+		if (frameNum>bone.firstCollisionTime+dynamicTime)
+		{
+			VectorCopy(origin,bone.extraVec1);
+			if (ragOriginChange>15.0f)
+			{ //if we moved, or if this bone is still in solid
+				bone.firstCollisionTime=frameNum;
+			}
+			else
+			{
+				// settle out
+				bone.firstCollisionTime=0;
+				bone.restTime=frameNum;
+				ragState=ERS_SETTLING;
+			}
+		}
+	}
+	else if (bone.firstCollisionTime>0)
+	{
+		ragState=ERS_DYNAMIC;
+		if (frameNum>bone.firstCollisionTime+dynamicTime)
+		{
+			VectorCopy(origin,bone.extraVec1);
+			if (ragOriginChange>15.0f)
+			{ //if we moved
+				bone.firstCollisionTime=frameNum;
+			}
+			else
+			{
+				// settle out
+				bone.firstCollisionTime=0;
+				bone.restTime=frameNum;
+				ragState=ERS_SETTLING;
+			}
+		}
+//decay=0.0f;
+	}
+	else if (bone.restTime>0)
+	{
+		decay=1.0f-(frameNum-bone.restTime)/float(dynamicTime);
+		if (decay<0.0f)
+		{
+			decay=0.0f;
+		}
+		if (decay>1.0f)
+		{
+			decay=1.0f;
+		}
+		float	magicFactor8=1.0f; // Power for decay
+		decay=pow(decay,magicFactor8);
+		ragState=ERS_SETTLING;
+		if (frameNum>bone.restTime+settleTime)
+		{
+			VectorCopy(origin,bone.extraVec1);
+			if (ragOriginChange>15.0f)
+			{
+				bone.restTime=frameNum;
+			}
+			else
+			{
+				// stop
+				bone.restTime=0;
+				ragState=ERS_SETTLED;
+			}
+		}
+//decay=0.0f;
+	}
+	else
+	{
+		if (bone.RagFlags & RAG_PCJ_IK_CONTROLLED)
+		{
+			bone.firstCollisionTime=frameNum;
+			ragState=ERS_DYNAMIC;
+		}
+		else if (ragOriginChange>15.0f)
+		{
+			bone.firstCollisionTime=frameNum;
+			ragState=ERS_DYNAMIC;
+		}
+		else
+		{
+			ragState=ERS_SETTLED;
+		}
+		decay=0.0f;
+	}
+//			ragState=ERS_SETTLED;
+//			decay=0.0f;
+	return decay;
+}
+
+static bool G2_RagDollSetup(CGhoul2Info &ghoul2,int frameNum,bool resetOrigin,const vec3_t origin,bool anyRendered)
+{
+	int i;
+	int minSurvivingBone=10000;
+	int minSurvivingBoneAt=-1;
+	int minSurvivingBoneAlt=10000;
+	int minSurvivingBoneAtAlt=-1;
+
+	assert(ghoul2.mFileName[0]);
+	boneInfo_v &blist = ghoul2.mBlist;
+	if(!rag) {
+		rag = new vector<boneInfo_t*>;
+	}
+	rag->clear();
+	int numRendered=0;
+	int numNotRendered=0;
+	int pelvisAt=-1;
+	for(i=0; i<blist.size(); i++)
+	{
+		boneInfo_t &bone=blist[i];
+		if (bone.boneNumber>=0)
+		{
+			assert(bone.boneNumber<MAX_BONES_RAG);
+			if ((bone.flags & BONE_ANGLES_RAGDOLL) || (bone.flags & BONE_ANGLES_IK))
+			{
+				//rww - this was (!anyRendered) before. Isn't that wrong? (if anyRendered, then wasRendered should be true)
+				bool wasRendered=
+					(!anyRendered) ||   // offscreeen or something
+					G2_WasBoneRendered(ghoul2,bone.boneNumber);
+				if (!wasRendered)
+				{
+					bone.RagFlags|=RAG_WAS_NOT_RENDERED;
+					numNotRendered++;
+				}
+				else
+				{
+					bone.RagFlags&=~RAG_WAS_NOT_RENDERED;
+					bone.RagFlags|=RAG_WAS_EVER_RENDERED;
+					numRendered++;
+				}
+				if	(bone.RagFlags&RAG_PCJ_PELVIS)
+				{
+					pelvisAt=i;
+				}
+				else if	(bone.RagFlags&RAG_PCJ_MODEL_ROOT)
+				{
+				}
+				else if	(wasRendered && (bone.RagFlags&RAG_PCJ))
+				{
+					if (minSurvivingBone>bone.boneNumber)
+					{
+						minSurvivingBone=bone.boneNumber;
+						minSurvivingBoneAt=i;
+					}
+				}
+				else if	(wasRendered)
+				{
+					if (minSurvivingBoneAlt>bone.boneNumber)
+					{
+						minSurvivingBoneAlt=bone.boneNumber;
+						minSurvivingBoneAtAlt=i;
+					}
+				}
+				if (
+					anyRendered &&
+					(bone.RagFlags&RAG_WAS_EVER_RENDERED) &&
+					!(bone.RagFlags&RAG_PCJ_MODEL_ROOT) &&
+					!(bone.RagFlags&RAG_PCJ_PELVIS) &&
+					!wasRendered &&
+					(bone.RagFlags&RAG_EFFECTOR)
+					)
+				{
+					// this thing was rendered in the past, but wasn't now, although other bones were, lets get rid of it
+//					bone.flags &= ~BONE_ANGLES_RAGDOLL;
+//					bone.RagFlags = 0;
+//OutputDebugString(va("Deleted Effector %d\n",i));
+//					continue;
+				}
+				if (rag->size()<bone.boneNumber+1)
+				{
+					rag->resize(bone.boneNumber+1,0);
+				}
+				(*rag)[bone.boneNumber]=&bone;
+				ragBlistIndex[bone.boneNumber]=i;
+
+				bone.lastTimeUpdated=frameNum;
+				if (resetOrigin)
+				{
+					VectorCopy(origin,bone.extraVec1); // this is only done incase a limb is removed
+				}
+			}
+		}
+	}
+#if 0
+	if (numRendered<5)  // I think this is a limb
+	{
+//OutputDebugString(va("limb %3d/%3d  (r,N).\n",numRendered,numNotRendered));
+		if (minSurvivingBoneAt<0)
+		{
+			// pelvis is gone, but we have no remaining pcj's
+			// just find any remain rag effector
+			minSurvivingBoneAt=minSurvivingBoneAtAlt;
+		}
+		if (
+			minSurvivingBoneAt>=0 &&
+			pelvisAt>=0)
+		{
+			{
+				 // remove the pelvis as a rag
+				boneInfo_t &bone=blist[minSurvivingBoneAt];
+				bone.flags&=~BONE_ANGLES_RAGDOLL;
+				bone.RagFlags=0;
+			}
+			{
+				// the root-est bone is now our "pelvis
+				boneInfo_t &bone=blist[minSurvivingBoneAt];
+				VectorSet(bone.minAngles,-14500.0f,-14500.0f,-14500.0f);
+				VectorSet(bone.maxAngles,14500.0f,14500.0f,14500.0f);
+				bone.RagFlags|=RAG_PCJ_PELVIS|RAG_PCJ; // this guy is our new "pelvis"
+				bone.flags |= BONE_ANGLES_POSTMULT;
+				bone.ragStartTime=G2API_GetTime(0);
+			}
+		}
+	}
+#endif
+	numRags=0;
+	int ragStartTime=0;
+	for(i=0; i<rag->size(); i++)
+	{
+		if ((*rag)[i])
+		{
+			boneInfo_t &bone=*(*rag)[i];
+			assert(bone.boneNumber>=0);
+			assert(numRags<MAX_BONES_RAG);
+
+			ragStartTime=bone.ragStartTime;
+
+			bone.ragIndex=numRags;
+			ragBoneData[numRags]=&bone;
+			ragEffectors[numRags].radius=bone.radius;
+			ragEffectors[numRags].weight=bone.weight;
+			G2_GetBoneBasepose(ghoul2,bone.boneNumber,bone.basepose,bone.baseposeInv);
+			numRags++;
+		}
+	}
+	if (!numRags)
+	{
+		return false;
+	}
+	return true;
+}
+
+static void G2_RagDoll(CGhoul2Info_v &ghoul2V,int g2Index,CRagDollUpdateParams *params, int curTime)
+{
+	int i;
+	if (!broadsword||!broadsword->integer)
+	{
+		return;
+	}
+
+	if (!params)
+	{
+		assert(0);
+		return;
+	}
+
+	vec3_t dPos;
+	VectorCopy(params->position, dPos);
+#ifdef _OLD_STYLE_SETTLE
+	dPos[2] -= 6;
+#endif
+
+//	params->DebugLine(handPos,handPos2,false);
+	int frameNum=G2API_GetTime(0);
+	CGhoul2Info &ghoul2=ghoul2V[g2Index];
+	assert(ghoul2.mFileName[0]);
+	boneInfo_v &blist = ghoul2.mBlist;
+
+	// hack for freezing ragdoll (no idea if it works)
+#if 0
+	if (0)
+	{
+		// we gotta hack this to basically freeze the timers
+		for(i=0; i<blist.size(); i++)
+		{
+			boneInfo_t &bone=blist[i];
+			if (bone.boneNumber>=0)
+			{
+				assert(bone.boneNumber<MAX_BONES_RAG);
+				if (bone.flags & BONE_ANGLES_RAGDOLL)
+				{
+					bone.ragStartTime+=50;
+					if (bone.firstTime)
+					{
+						bone.firstTime+=50;
+					}
+					if (bone.firstCollisionTime)
+					{
+						bone.firstCollisionTime+=50;
+					}
+					if (bone.restTime)
+					{
+						bone.restTime+=50;
+					}
+				}
+			}
+		}
+		return;
+	}
+#endif
+
+	float decay=1.0f;
+	bool resetOrigin=false;
+	bool anyRendered=false;
+
+	// this loop checks for settled
+	for(i=0; i<blist.size(); i++)
+	{
+		boneInfo_t &bone=blist[i];
+		if (bone.boneNumber>=0)
+		{
+			assert(bone.boneNumber<MAX_BONES_RAG);
+			if (bone.flags & BONE_ANGLES_RAGDOLL)
+			{
+				// check for state transitions
+				decay=G2_RagSetState(ghoul2,bone,frameNum,dPos,resetOrigin); // set the current state
+				if (ragState==ERS_SETTLED)
+				{
+#if 0
+					bool noneInSolid = true;
+
+					//first iterate through and make sure no bones are still in solid a lot
+					for(int j = 0; j < blist.size(); j++)
+					{
+						boneInfo_t &bone2 = blist[j];
+
+						if (bone2.boneNumber >= 0 && bone2.solidCount > 8)
+						{
+							noneInSolid = false;
+							break;
+						}
+					}
+
+					if (noneInSolid)
+					{ //we're settled then
+						params->RagDollSettled();
+						return;
+					}
+					else
+					{
+						continue;
+					}
+#else
+					params->RagDollSettled();
+					return;
+#endif
+				}
+				if (G2_WasBoneRendered(ghoul2,bone.boneNumber))
+				{
+					anyRendered=true;
+					break;
+				}
+			}
+		}
+	}
+	//int iters=(ragState==ERS_DYNAMIC)?2:1;
+	int iters=(ragState==ERS_DYNAMIC)?4:2;
+/*
+	bool kicked=false;
+	if (ragOriginChangeDir[2]<-100.0f)
+	{
+		kicked=true;
+		//iters*=8;
+		iters*=5; //rww - changed to this.. it was getting up to around 600 traces at times before (which is insane)
+	}
+*/
+	if (iters)
+	{
+		if (!G2_RagDollSetup(ghoul2,frameNum,resetOrigin,dPos,anyRendered))
+		{
+			return;
+		}
+		// ok, now our data structures are compact and set up in topological order
+
+		for (i=0;i<iters;i++)
+		{
+			G2_RagDollCurrentPosition(ghoul2V,g2Index,frameNum,params->angles,dPos,params->scale);
+
+			if (G2_RagDollSettlePositionNumeroTrois(ghoul2V,dPos,params,curTime))
+			{
+#if 0
+				//effectors are start solid alot, so this was pretty extreme
+				if (!kicked&&iters<4)
+				{
+					kicked=true;
+					//iters*=4;
+					iters*=2;
+				}
+#endif
+			}
+			//params->position[2] += 16;
+			G2_RagDollSolve(ghoul2V,g2Index,decay*2.0f,frameNum,dPos,true,params);
+		}
+	}
+
+	if (params->me != ENTITYNUM_NONE)
+	{
+#if 0
+		vec3_t worldMins,worldMaxs;
+		worldMins[0]=params->position[0]-17;
+		worldMins[1]=params->position[1]-17;
+		worldMins[2]=params->position[2];
+		worldMaxs[0]=params->position[0]+17;
+		worldMaxs[1]=params->position[1]+17;
+		worldMaxs[2]=params->position[2];
+//OutputDebugString(va("%f \n",worldMins[2]));
+//		params->DebugLine(worldMins,worldMaxs,true);
+#endif
+		G2_RagDollCurrentPosition(ghoul2V,g2Index,frameNum,params->angles,params->position,params->scale);
+//		SV_UnlinkEntity(params->me);
+//		params->me->SetMins(BB_SHOOTING_SIZE,ragBoneMins);
+//		params->me->SetMaxs(BB_SHOOTING_SIZE,ragBoneMaxs);
+//		SV_LinkEntity(params->me);
+	}
+}
+
+//#define _DEBUG_BONE_NAMES
+
+static inline char *G2_Get_Bone_Name(CGhoul2Info *ghlInfo, boneInfo_v &blist, int boneNum)
+{
+	int					i;
+	mdxaSkel_t			*skel;
+	mdxaSkelOffsets_t	*offsets;
+   	offsets = (mdxaSkelOffsets_t *)((byte *)ghlInfo->aHeader + sizeof(mdxaHeader_t));
+	skel = (mdxaSkel_t *)((byte *)ghlInfo->aHeader + sizeof(mdxaHeader_t) + offsets->offsets[0]);
+
+	// look through entire list
+	for(i=0; i<blist.size(); i++)
+	{
+		// if this bone entry has no info in it, bounce over it
+		if (blist[i].boneNumber != boneNum)
+		{
+			continue;
+		}
+
+		// figure out what skeletal info structure this bone entry is looking at
+		skel = (mdxaSkel_t *)((byte *)ghlInfo->aHeader + sizeof(mdxaHeader_t) + offsets->offsets[blist[i].boneNumber]);
+
+		return skel->name;
+	}
+
+	// didn't find it
+	return "BONE_NOT_FOUND";
+}
+
+char *G2_GetBoneNameFromSkel(CGhoul2Info &ghoul2, int boneNum);
+static void G2_RagDollCurrentPosition(CGhoul2Info_v &ghoul2V,int g2Index,int frameNum,const vec3_t angles,const vec3_t position,const vec3_t scale)
+{
+	CGhoul2Info &ghoul2=ghoul2V[g2Index];
+	assert(ghoul2.mFileName[0]);
+//OutputDebugString(va("angles %f %f %f\n",angles[0],angles[1],angles[2]));
+	G2_GenerateWorldMatrix(angles,position);
+	G2_ConstructGhoulSkeleton(ghoul2V, frameNum, false, scale);
+
+	float totalWt=0.0f;
+	int i;
+	for (i=0;i<numRags;i++)
+	{
+		boneInfo_t &bone=*ragBoneData[i];
+		G2_GetBoneMatrixLow(ghoul2,bone.boneNumber,scale,ragBones[i],ragBasepose[i],ragBaseposeInv[i]);
+
+#ifdef _DEBUG_BONE_NAMES
+		char *debugBoneName = G2_Get_Bone_Name(&ghoul2, ghoul2.mBlist, bone.boneNumber);
+		assert(debugBoneName);
+#endif
+
+		int k;
+		//float cmweight=ragEffectors[numRags].weight;
+		float cmweight=1.0f;
+		for (k=0;k<3;k++)
+		{
+			ragEffectors[i].currentOrigin[k]=ragBones[i].matrix[k][3];
+			assert( !_isnan(ragEffectors[i].currentOrigin[k]));
+			if (!i)
+			{
+				// set mins, maxs and cm
+				ragBoneCM[k]=ragEffectors[i].currentOrigin[k]*cmweight;
+				ragBoneMaxs[k]=ragEffectors[i].currentOrigin[k];
+				ragBoneMins[k]=ragEffectors[i].currentOrigin[k];
+			}
+			else
+			{
+				ragBoneCM[k]+=ragEffectors[i].currentOrigin[k]*ragEffectors[i].weight;
+				if (ragEffectors[i].currentOrigin[k]>ragBoneMaxs[k])
+				{
+					ragBoneMaxs[k]=ragEffectors[i].currentOrigin[k];
+				}
+				if (ragEffectors[i].currentOrigin[k]<ragBoneMins[k])
+				{
+					ragBoneMins[k]=ragEffectors[i].currentOrigin[k];
+				}
+			}
+		}
+
+		totalWt+=cmweight;
+	}
+
+	assert(totalWt>0.0f);
+	int k;
+	{
+		float wtInv=1.0f/totalWt;
+		for (k=0;k<3;k++)
+		{
+			ragBoneMaxs[k]-=position[k];
+			ragBoneMins[k]-=position[k];
+			ragBoneMaxs[k]+=10.0f;
+			ragBoneMins[k]-=10.0f;
+			ragBoneCM[k]*=wtInv;
+
+			ragBoneCM[k]=ragEffectors[0].currentOrigin[k]; // use the pelvis
+		}
+	}
+}
+
+void VectorAdvance( const vec3_t veca, const float scale, const vec3_t vecb, vec3_t vecc);
+
+#ifdef _DEBUG
+int ragTraceTime = 0;
+int ragSSCount = 0;
+int ragTraceCount = 0;
+#endif
+
+void Rag_Trace( trace_t *results, const vec3_t start, const vec3_t mins, const vec3_t maxs, const vec3_t end, const int passEntityNum, const int contentmask, const EG2_Collision eG2TraceType, const int useLod )
+{
+#ifdef _DEBUG
+	int ragPreTrace = Sys_Milliseconds();
+#endif
+	SV_Trace(results, start, mins, maxs, end, passEntityNum, contentmask, eG2TraceType, useLod);
+#ifdef _DEBUG
+	int ragPostTrace = Sys_Milliseconds();
+
+	ragTraceTime += (ragPostTrace - ragPreTrace);
+	if (results->startsolid)
+	{
+		ragSSCount++;
+	}
+	ragTraceCount++;
+#endif
+}
+
+//run advanced physics on each bone indivudually
+//an adaption of my "exphys" custom game physics model
+#define MAX_GRAVITY_PULL 256//512
+
+static inline bool G2_BoneOnGround(const vec3_t org, const vec3_t mins, const vec3_t maxs, const int ignoreNum)
+{
+	trace_t tr;
+	vec3_t gSpot;
+
+	VectorCopy(org, gSpot);
+	gSpot[2] -= 1.0f; //seems reasonable to me
+
+	Rag_Trace(&tr, org, mins, maxs, gSpot, ignoreNum, RAG_MASK, G2_NOCOLLIDE, 0);
+
+	if (tr.fraction != 1.0f && !tr.startsolid && !tr.allsolid)
+	{ //not in solid, and hit something. Guess it's ground.
+		return true;
+	}
+
+	return false;
+}
+
+static inline bool G2_ApplyRealBonePhysics(boneInfo_t &bone, SRagEffector &e, CRagDollUpdateParams *params, vec3_t goalSpot, const vec3_t goalBase, const vec3_t testMins, const vec3_t testMaxs,
+										   const float gravity, const float mass, const float bounce)
+{
+	trace_t tr;
+	vec3_t projectedOrigin;
+	vec3_t vNorm;
+	vec3_t ground;
+	vec3_t usedOrigin;
+	float velScaling = 0.1f;
+	float vTotal = 0.0f;
+	bool boneOnGround = false;
+
+	assert(mass <= 1.0f && mass >= 0.01f);
+
+	if (bone.physicsSettled)
+	{ //then we have no need to continue
+		return true;
+	}
+
+	if (goalBase)
+	{
+		VectorCopy(goalBase, usedOrigin);
+	}
+	else
+	{
+		VectorCopy(e.currentOrigin, usedOrigin);
+	}
+
+	if (gravity)
+	{ //factor it in before we do anything.
+		VectorCopy(usedOrigin, ground);
+		ground[2] -= 1.0f;
+
+		Rag_Trace(&tr, usedOrigin, testMins, testMaxs, ground, params->me, RAG_MASK, G2_NOCOLLIDE, 0);
+
+		if (tr.entityNum == ENTITYNUM_NONE)
+		{
+			boneOnGround = false;
+		}
+		else
+		{
+			boneOnGround = true;
+		}
+
+		if (!boneOnGround)
+		{
+			if (!params->velocity[2])
+			{ //only increase gravitational pull once the actual entity is still
+				bone.epGravFactor += gravity;
+			}
+
+			if (bone.epGravFactor > MAX_GRAVITY_PULL)
+			{ //cap it off if needed
+				bone.epGravFactor = MAX_GRAVITY_PULL;
+			}
+
+			bone.epVelocity[2] -= bone.epGravFactor;
+		}
+		else
+		{ //if we're sitting on something then reset the gravity factor.
+			bone.epGravFactor = 0;
+		}
+	}
+	else
+	{
+		boneOnGround = G2_BoneOnGround(usedOrigin, testMins, testMaxs, params->me);
+	}
+
+	if (!bone.epVelocity[0] && !bone.epVelocity[1] && !bone.epVelocity[2])
+	{ //nothing to do if we have no velocity even after gravity.
+		VectorCopy(usedOrigin, goalSpot);
+		return true;
+	}
+
+	//get the projected origin based on velocity.
+	VectorMA(usedOrigin, velScaling, bone.epVelocity, projectedOrigin);
+
+	//scale it down based on mass
+	VectorScale(bone.epVelocity, 1.0f-mass, bone.epVelocity);
+
+	VectorCopy(bone.epVelocity, vNorm);
+	vTotal = VectorNormalize(vNorm);
+
+	if (vTotal < 1 && boneOnGround)
+	{ //we've pretty much stopped moving anyway, just clear it out then.
+		VectorClear(bone.epVelocity);
+		bone.epGravFactor = 0;
+		VectorCopy(usedOrigin, goalSpot);
+		return true;
+	}
+
+	Rag_Trace(&tr, usedOrigin, testMins, testMaxs, projectedOrigin, params->me, RAG_MASK, G2_NOCOLLIDE, 0);
+
+	if (tr.startsolid || tr.allsolid)
+	{ //can't go anywhere from here
+		return false;
+	}
+
+	//Go ahead and set it to the trace endpoint regardless of what it hit
+	VectorCopy(tr.endpos, goalSpot);
+
+	if (tr.fraction == 1.0f)
+	{ //Nothing was in the way.
+		return true;
+	}
+
+	if (bounce)
+	{
+		vTotal *= bounce; //scale it by bounce
+
+		VectorScale(tr.plane.normal, vTotal, vNorm); //scale the trace plane normal by the bounce factor
+
+		if (vNorm[2] > 0)
+		{
+			bone.epGravFactor -= vNorm[2]*(1.0f-mass); //The lighter it is the more gravity will be reduced by bouncing vertically.
+			if (bone.epGravFactor < 0)
+			{
+				bone.epGravFactor = 0;
+			}
+		}
+
+		VectorAdd(bone.epVelocity, vNorm, bone.epVelocity); //add it into the existing velocity.
+
+		//I suppose it could be sort of neat to make a game callback here to actual do stuff
+		//when bones slam into things. But it could be slow too.
+		/*
+		if (tr.entityNum != ENTITYNUM_NONE && ent->touch)
+		{ //then call the touch function
+			ent->touch(ent, &g_entities[tr.entityNum], &tr);
+		}
+		*/
+	}
+	else
+	{ //if no bounce, kill when it hits something.
+		bone.epVelocity[0] = 0;
+		bone.epVelocity[1] = 0;
+
+		if (!gravity)
+		{
+			bone.epVelocity[2] = 0;
+		}
+	}
+	return true;
+}
+
+#ifdef _DEBUG_BONE_NAMES
+static inline void G2_RagDebugBox(vec3_t mins, vec3_t maxs, int duration)
+{
+	return; //do something
+}
+
+static inline void G2_RagDebugLine(vec3_t start, vec3_t end, int time, int color, int radius)
+{
+	return; //do something
+}
+#endif
+
+#ifdef _OLD_STYLE_SETTLE
+static bool G2_RagDollSettlePositionNumeroTrois(CGhoul2Info_v &ghoul2V, const vec3_t currentOrg, CRagDollUpdateParams *params, int curTime)
+{
+	haveDesiredPelvisOffset=false;
+	vec3_t desiredPos;
+	int i;
+
+	assert(params);
+	//assert(params->me); //no longer valid, because me is an index!
+	int ignoreNum=params->me;
+
+	bool anyStartSolid=false;
+
+	vec3_t groundSpot={0,0,0};
+	// lets find the floor at our quake origin
+	{
+		vec3_t testStart;
+		VectorCopy(currentOrg,testStart); //last arg is dest
+		vec3_t testEnd;
+		VectorCopy(testStart,testEnd); //last arg is dest
+		testEnd[2]-=200.0f;
+
+		vec3_t testMins;
+		vec3_t testMaxs;
+		VectorSet(testMins,-10,-10,-10);
+		VectorSet(testMaxs,10,10,10);
+
+		{
+			trace_t		tr;
+			assert( !_isnan(testStart[1]));
+			assert( !_isnan(testEnd[1]));
+			assert( !_isnan(testMins[1]));
+			assert( !_isnan(testMaxs[1]));
+			Rag_Trace(&tr,testStart,testMins,testMaxs,testEnd,ignoreNum,RAG_MASK,G2_NOCOLLIDE,0/*SV_TRACE_NO_PLAYER*/);
+			if (tr.entityNum==0)
+			{
+				VectorAdvance(testStart,.5f,testEnd,tr.endpos);
+			}
+			if (tr.startsolid)
+			{
+				//hmmm, punt
+				VectorCopy(currentOrg,groundSpot); //last arg is dest
+				groundSpot[2]-=30.0f;
+			}
+			else
+			{
+				VectorCopy(tr.endpos,groundSpot); //last arg is dest
+			}
+		}
+	}
+
+	for (i=0;i<numRags;i++)
+	{
+		boneInfo_t &bone=*ragBoneData[i];
+		SRagEffector &e=ragEffectors[i];
+		if (bone.RagFlags & RAG_PCJ_PELVIS)
+		{
+			// just move to quake origin
+			VectorCopy(currentOrg,desiredPos);
+			//desiredPos[2]-=35.0f;
+			desiredPos[2]-=20.0f;
+//old deathflop			desiredPos[2]-=40.0f;
+			VectorSubtract(desiredPos,e.currentOrigin,desiredPelvisOffset); // last arg is dest
+			haveDesiredPelvisOffset=true;
+			VectorCopy(e.currentOrigin,bone.lastPosition); // last arg is dest
+			continue; 
+		}
+
+		if (!(bone.RagFlags & RAG_EFFECTOR))
+		{
+			continue; 
+		}
+		vec3_t testMins;
+		vec3_t testMaxs;
+		VectorSet(testMins,-e.radius,-e.radius,-e.radius);
+		VectorSet(testMaxs,e.radius,e.radius,e.radius);
+#ifdef _DEBUG_BONE_NAMES
+		char *debugBoneName = G2_Get_Bone_Name(ghlInfo, ghlInfo->mBlist, bone.boneNumber);
+		assert(debugBoneName);
+#endif
+		// first we will see if we are start solid
+		// if so, we are gonna run some bonus iterations
+		bool iAmStartSolid=false;
+		vec3_t testStart;
+		VectorCopy(e.currentOrigin,testStart); //last arg is dest
+		testStart[2]+=12.0f; // we are no so concerned with minor penetration
+
+		vec3_t testEnd;
+		VectorCopy(testStart,testEnd); //last arg is dest
+		testEnd[2]-=8.0f;
+		assert( !_isnan(testStart[1]));
+		assert( !_isnan(testEnd[1]));
+		assert( !_isnan(testMins[1]));
+		assert( !_isnan(testMaxs[1]));
+		float vertEffectorTraceFraction=0.0f;
+		{
+			trace_t		tr;
+			Rag_Trace(&tr,testStart,testMins,testMaxs,testEnd,ignoreNum,RAG_MASK,G2_NOCOLLIDE,0);
+			if (tr.entityNum==0)
+			{
+				VectorAdvance(testStart,.5f,testEnd,tr.endpos);
+			}
+			if (tr.startsolid)
+			{
+				// above the origin, so lets try lower
+				if (e.currentOrigin[2] > groundSpot[2])
+				{
+					testStart[2]=groundSpot[2]+(e.radius-10.0f); 
+				}
+				else
+				{
+					// lets try higher
+					testStart[2]=groundSpot[2]+8.0f; 
+					Rag_Trace(&tr,testStart,testMins,testMaxs,testEnd,ignoreNum,RAG_MASK,G2_NOCOLLIDE,0);
+					if (tr.entityNum==0)
+					{
+						VectorAdvance(testStart,.5f,testEnd,tr.endpos);
+					}
+				}
+
+			}
+			if (tr.startsolid)
+			{
+				iAmStartSolid=true;
+				anyStartSolid=true;
+				// above the origin, so lets slide away
+				if (e.currentOrigin[2] > groundSpot[2])
+				{
+					if (params)
+					{
+						SRagDollEffectorCollision args(e.currentOrigin,tr);
+						params->EffectorCollision(args);
+					}
+				}
+				else
+				{
+					//harumph, we are really screwed
+				}
+			}
+			else
+			{
+				vertEffectorTraceFraction=tr.fraction;
+				if (params && 
+					vertEffectorTraceFraction < .95f &&
+					fabsf(tr.plane.normal[2]) < .707f)
+				{
+					SRagDollEffectorCollision args(e.currentOrigin,tr);
+					args.useTracePlane=true;
+					params->EffectorCollision(args);
+				}
+			}
+		}
+		vec3_t effectorGroundSpot;
+		VectorAdvance(testStart,vertEffectorTraceFraction,testEnd,effectorGroundSpot);//  VA(a,t,b,c)-> c := (1-t)a+tb
+		// trace from the quake origin horzontally to the effector
+		// gonna choose the maximum of the ground spot or the effector location 
+		// and clamp it to be roughly in the bbox
+		VectorCopy(groundSpot,testStart); //last arg is dest
+		if (iAmStartSolid)
+		{
+			// we don't have a meaningful ground spot
+			VectorCopy(e.currentOrigin,testEnd); //last arg is dest
+			bone.solidCount++;
+		}
+		else
+		{
+			VectorCopy(effectorGroundSpot,testEnd); //last arg is dest
+			bone.solidCount = 0;
+		}
+		assert( !_isnan(testStart[1]));
+		assert( !_isnan(testEnd[1]));
+		assert( !_isnan(testMins[1]));
+		assert( !_isnan(testMaxs[1]));
+
+		float ztest;
+
+		if (testEnd[2]>testStart[2])
+		{
+			ztest=testEnd[2];
+		}
+		else
+		{
+			ztest=testStart[2];
+		}
+		if (ztest<currentOrg[2]-30.0f)
+		{
+			ztest=currentOrg[2]-30.0f;
+		}
+		if (ztest<currentOrg[2]+10.0f)
+		{
+			ztest=currentOrg[2]+10.0f;			
+		}
+		testStart[2]=ztest;
+		testEnd[2]=ztest;
+
+		float		magicFactor44=1.0f; // going to trace a bit longer, this also serves as an expansion parameter
+		VectorAdvance(testStart,magicFactor44,testEnd,testEnd);//  VA(a,t,b,c)-> c := (1-t)a+tb
+
+		float horzontalTraceFraction=0.0f;
+		vec3_t HorizontalHitSpot={0,0,0};
+		{
+			trace_t		tr;
+			Rag_Trace(&tr,testStart,testMins,testMaxs,testEnd,ignoreNum,RAG_MASK,G2_NOCOLLIDE,0);
+			if (tr.entityNum==0)
+			{
+				VectorAdvance(testStart,.5f,testEnd,tr.endpos);
+			}
+			horzontalTraceFraction=tr.fraction;
+			if (tr.startsolid)
+			{
+				horzontalTraceFraction=1.0f;
+				// punt
+				VectorCopy(e.currentOrigin,HorizontalHitSpot);
+			}
+			else
+			{
+				VectorCopy(tr.endpos,HorizontalHitSpot);
+				int		magicFactor46=0.98f; // shorten percetage to make sure we can go down along a wall
+				//float		magicFactor46=0.98f; // shorten percetage to make sure we can go down along a wall
+				//rww - An..int?
+				VectorAdvance(tr.endpos,magicFactor46,testStart,HorizontalHitSpot);//  VA(a,t,b,c)-> c := (1-t)a+tb
+
+				// roughly speaking this is a wall
+				if (horzontalTraceFraction<0.9f)
+				{
+				
+					// roughly speaking this is a wall
+					if (fabsf(tr.plane.normal[2])<0.7f)
+					{
+						SRagDollEffectorCollision args(e.currentOrigin,tr);
+						args.useTracePlane=true;
+						params->EffectorCollision(args);
+					}
+				}
+				else if (!iAmStartSolid &&
+					effectorGroundSpot[2] < groundSpot[2] - 8.0f)
+				{
+					// this is a situation where we have something dangling below the pelvis, we want to find the plane going downhill away from the origin
+					// for various reasons, without this correction the body will actually move away from places it can fall off.
+					//gotta run the trace backwards to get a plane
+					{
+						trace_t		tr;
+						VectorCopy(effectorGroundSpot,testStart);
+						VectorCopy(groundSpot,testEnd);
+
+						// this can be a line trace, we just want the plane normal
+						Rag_Trace(&tr,testEnd,0,0,testStart,ignoreNum,RAG_MASK,G2_NOCOLLIDE,0);
+						if (tr.entityNum==0)
+						{
+							VectorAdvance(testStart,.5f,testEnd,tr.endpos);
+						}
+						horzontalTraceFraction=tr.fraction;
+						if (!tr.startsolid && tr.fraction< 0.7f)
+						{
+							SRagDollEffectorCollision args(e.currentOrigin,tr);
+							args.useTracePlane=true;
+							params->EffectorCollision(args);
+						}
+					}
+				}
+			}
+		}
+		vec3_t goalSpot={0,0,0};
+		// now lets trace down
+		VectorCopy(HorizontalHitSpot,testStart);
+		VectorCopy(testStart,testEnd); //last arg is dest
+		testEnd[2]=e.currentOrigin[2]-30.0f;
+		{
+			trace_t		tr;
+			Rag_Trace(&tr,testStart,NULL,NULL,testEnd,ignoreNum,RAG_MASK,G2_NOCOLLIDE,0);
+			if (tr.entityNum==0)
+			{
+				VectorAdvance(testStart,.5f,testEnd,tr.endpos);
+			}
+			if (tr.startsolid)
+			{
+				// punt, go to the origin I guess
+				VectorCopy(currentOrg,goalSpot);
+			}
+			else
+			{
+				VectorCopy(tr.endpos,goalSpot);
+				int		magicFactor47=0.5f; // shorten percentage to make sure we can go down along a wall
+				VectorAdvance(tr.endpos,magicFactor47,testStart,goalSpot);//  VA(a,t,b,c)-> c := (1-t)a+tb
+			}
+		}
+
+		// ok now as the horizontal trace fraction approaches zero, we want to head toward the horizontalHitSpot
+		//geeze I would like some reasonable trace fractions
+		assert(horzontalTraceFraction>=0.0f&&horzontalTraceFraction<=1.0f);
+		VectorAdvance(HorizontalHitSpot,horzontalTraceFraction*horzontalTraceFraction,goalSpot,goalSpot);//  VA(a,t,b,c)-> c := (1-t)a+tb
+#if 0
+		if ((bone.RagFlags & RAG_EFFECTOR) && (bone.RagFlags & RAG_BONE_LIGHTWEIGHT))
+		{ //new rule - don't even bother unless it's a lightweight effector
+			//rww - Factor object velocity into the final desired spot..
+			//We want the limbs with a "light" weight to drag behind the general mass.
+			//If we got here, we shouldn't be the pelvis or the root, so we should be
+			//fine to treat as lightweight. However, we can flag bones as being particularly
+			//light. They're given less downscale for the reduction factor.
+			vec3_t givenVelocity;
+			vec3_t vSpot;
+			trace_t vtr;
+			float vSpeed = 0;
+			float verticalSpeed = 0;
+			float vReductionFactor = 0.03f;
+			float verticalSpeedReductionFactor = 0.06f; //want this to be more obvious
+			float lwVReductionFactor = 0.1f;
+			float lwVerticalSpeedReductionFactor = 0.3f; //want this to be more obvious
+			
+
+			VectorCopy(params->velocity, givenVelocity);
+			vSpeed = VectorNormalize(givenVelocity);
+			vSpeed = -vSpeed; //go in the opposite direction of velocity
+
+			verticalSpeed = vSpeed;
+
+			if (bone.RagFlags & RAG_BONE_LIGHTWEIGHT)
+			{
+				vSpeed *= lwVReductionFactor;
+				verticalSpeed *= lwVerticalSpeedReductionFactor;
+			}
+			else
+			{
+				vSpeed *= vReductionFactor;
+				verticalSpeed *= verticalSpeedReductionFactor;
+			}
+
+			vSpot[0] = givenVelocity[0]*vSpeed;
+			vSpot[1] = givenVelocity[1]*vSpeed;
+			vSpot[2] = givenVelocity[2]*verticalSpeed;
+			VectorAdd(goalSpot, vSpot, vSpot);
+
+			if (vSpot[0] || vSpot[1] || vSpot[2])
+			{
+				Rag_Trace(&vtr, goalSpot, testMins, testMaxs, vSpot, ignoreNum, RAG_MASK, G2_NOCOLLIDE,0);
+				if (vtr.fraction == 1)
+				{
+					VectorCopy(vSpot, goalSpot);
+				}
+			}
+		}
+#endif
+
+		int k;
+		int		magicFactor12=0.8f; // dampening of velocity applied
+		int		magicFactor16=10.0f; // effect multiplier of velocity applied
+
+		if (iAmStartSolid)
+		{
+			magicFactor16 = 30.0f;
+		}
+
+		for (k=0;k<3;k++)
+		{
+			e.desiredDirection[k]=goalSpot[k]-e.currentOrigin[k];
+			e.desiredDirection[k]+=magicFactor16*bone.velocityEffector[k];
+			e.desiredDirection[k]+=flrand(-0.75f,0.75f)*flrand(-0.75f,0.75f);
+			bone.velocityEffector[k]*=magicFactor12;
+		}
+		VectorCopy(e.currentOrigin,bone.lastPosition); // last arg is dest
+	}
+	return anyStartSolid;
+}
+#else
+#if 0
+static inline int G2_RagIndexForBoneNum(int boneNum)
+{
+	for (int i = 0; i < numRags; i++)
+	{		
+		// these are used for affecting the end result
+		if (ragBoneData[i].boneNum == boneNum)
+		{
+			return i;
+		}
+	}
+
+	return -1;
+}
+#endif
+
+extern mdxaBone_t		worldMatrix;
+void G2_RagGetBoneBasePoseMatrixLow(CGhoul2Info &ghoul2, int boneNum, mdxaBone_t &boneMatrix, mdxaBone_t &retMatrix, vec3_t scale);
+void G2_RagGetAnimMatrix(CGhoul2Info &ghoul2, const int boneNum, mdxaBone_t &matrix, const int frame);
+
+static inline void G2_RagGetWorldAnimMatrix(CGhoul2Info &ghoul2, boneInfo_t &bone, CRagDollUpdateParams *params, mdxaBone_t &retMatrix)
+{
+	static mdxaBone_t trueBaseMatrix, baseBoneMatrix;
+
+	//get matrix for the settleFrame to use as an ideal
+	G2_RagGetAnimMatrix(ghoul2, bone.boneNumber, trueBaseMatrix, params->settleFrame);
+	assert(bone.hasAnimFrameMatrix == params->settleFrame);
+
+	G2_RagGetBoneBasePoseMatrixLow(ghoul2, bone.boneNumber,
+		trueBaseMatrix, baseBoneMatrix, params->scale);
+
+	//Use params to multiply world coordinate/dir matrix into the
+	//bone matrix and give us a useable world position
+	Multiply_3x4Matrix(&retMatrix, &worldMatrix, &baseBoneMatrix);
+
+	assert(!_isnan(retMatrix.matrix[2][3]));
+}
+
+//get the current pelvis Z direction and the base anim matrix Z direction
+//so they can be compared and used to offset -rww
+static inline void G2_RagGetPelvisLumbarOffsets(CGhoul2Info &ghoul2, CRagDollUpdateParams *params, vec3_t &pos, vec3_t &dir, vec3_t &animPos, vec3_t &animDir)
+{
+	static mdxaBone_t final;
+	static mdxaBone_t x;
+//	static mdxaBone_t *unused1, *unused2;
+	//static vec3_t lumbarPos;
+
+	assert(ghoul2.animModel);
+	int boneIndex = G2_Find_Bone(&ghoul2, ghoul2.mBlist, "pelvis");
+	assert(boneIndex != -1);
+
+	G2_RagGetWorldAnimMatrix(ghoul2, ghoul2.mBlist[boneIndex], params, final);
+	G2API_GiveMeVectorFromMatrix(final, ORIGIN, animPos);
+	G2API_GiveMeVectorFromMatrix(final, POSITIVE_X, animDir);
+
+	//We have the anim matrix pelvis pos now, so get the normal one as well
+	int bolt = G2API_AddBolt(&ghoul2, "pelvis");
+	G2_GetBoltMatrixLow(ghoul2, bolt, params->scale, x);
+	Multiply_3x4Matrix(&final, &worldMatrix, &x);
+	G2API_GiveMeVectorFromMatrix(final, ORIGIN, pos);
+	G2API_GiveMeVectorFromMatrix(final, POSITIVE_X, dir);
+
+	/*
+	//now get lumbar
+	boneIndex = G2_Find_Bone(ghoul2.animModel, ghoul2.mBlist, "lower_lumbar");
+	assert(boneIndex != -1);
+
+	G2_RagGetWorldAnimMatrix(ghoul2, ghoul2.mBlist[boneIndex], params, final);
+	G2API_GiveMeVectorFromMatrix(&final, ORIGIN, lumbarPos);
+
+	VectorSubtract(animPos, lumbarPos, animDir);
+	VectorNormalize(animDir);
+
+	//We have the anim matrix lumbar dir now, so get the normal one as well
+	G2_GetBoneMatrixLow(ghoul2, boneIndex, params->scale, final, unused1, unused2);
+	G2API_GiveMeVectorFromMatrix(&final, ORIGIN, lumbarPos);
+
+	VectorSubtract(pos, lumbarPos, dir);
+	VectorNormalize(dir);
+	*/
+}
+
+static bool G2_RagDollSettlePositionNumeroTrois(CGhoul2Info_v &ghoul2V, const vec3_t currentOrg, CRagDollUpdateParams *params, int curTime)
+{ //now returns true if any bone was in solid, otherwise false
+	int ignoreNum = params->me;
+	static int i;
+	static vec3_t goalSpot;
+	static trace_t tr;
+	static trace_t solidTr;
+	static int k;
+	static const float velocityDampening = 1.0f;
+	static const float velocityMultiplier = 60.0f;
+	static vec3_t testMins;
+	static vec3_t testMaxs;
+	vec3_t velDir;
+	static bool startSolid;
+	bool anySolid = false;
+	static mdxaBone_t worldBaseMatrix;
+	static vec3_t parentOrigin;
+	static vec3_t basePos;
+	static vec3_t entScale;
+	static bool hasDaddy;
+	static bool hasBasePos;
+	static vec3_t animPelvisDir, pelvisDir, animPelvisPos, pelvisPos;
+
+	//Maybe customize per-bone?
+	static const float gravity = 3.0f;
+	static const float mass = 0.09f;
+	static const float bounce = 0.0f;//1.3f;
+	//Bouncing and stuff unfortunately does not work too well at the moment.
+	//Need to keep a seperate "physics origin" or make the filthy solve stuff
+	//better.
+
+	bool inAir = false;
+
+	if (params->velocity[0] || params->velocity[1] || params->velocity[2])
+	{
+		inAir = true;
+	}
+
+	if (!params->scale[0] && !params->scale[1] && !params->scale[2])
+	{
+		VectorSet(entScale, 1.0f, 1.0f, 1.0f);
+	}
+	else
+	{
+		VectorCopy(params->scale, entScale);
+	}
+
+	if (broadsword_ragtobase &&
+		broadsword_ragtobase->integer > 1)
+	{
+		//grab the pelvis directions to offset base positions for bones
+		G2_RagGetPelvisLumbarOffsets(ghoul2V[0], params, pelvisPos, pelvisDir, animPelvisPos,
+			animPelvisDir);
+
+		//don't care about the pitch offsets
+		pelvisDir[2] = 0;
+		animPelvisDir[2] = 0;
+
+		/*
+		vec3_t blah;
+		VectorMA(pelvisPos, 32.0f, pelvisDir, blah);
+		//G2_RagDebugLine(pelvisPos, blah, 50, 0x00ff00, 1);
+		params->DebugLine(pelvisPos, blah, 0x00ff00, false);
+		VectorMA(animPelvisPos, 32.0f, animPelvisDir, blah);
+		//G2_RagDebugLine(animPelvisPos, blah, 50, 0xff0000, 1);
+		params->DebugLine(animPelvisPos, blah, 0xff0000, false);
+		*/
+
+		//just convert to angles now, that's all we'll ever use them for
+		vectoangles(pelvisDir, pelvisDir);
+		vectoangles(animPelvisDir, animPelvisDir);
+	}
+
+	for (i = 0; i < numRags; i++)
+	{
+		boneInfo_t &bone = *ragBoneData[i];
+		SRagEffector &e = ragEffectors[i];
+
+		if (inAir)
+		{
+			bone.airTime = curTime + 30;
+		}
+
+		if (bone.RagFlags & RAG_PCJ_PELVIS)
+		{
+			VectorSet(goalSpot, params->position[0], params->position[1], (params->position[2]+DEFAULT_MINS_2)+((bone.radius*entScale[2])+2));
+
+			VectorSubtract(goalSpot, e.currentOrigin, desiredPelvisOffset);
+			haveDesiredPelvisOffset = true;
+			VectorCopy(e.currentOrigin, bone.lastPosition);
+			continue; 
+		}
+
+		if (!(bone.RagFlags & RAG_EFFECTOR))
+		{
+			continue; 
+		}
+
+		if (bone.hasOverGoal)
+		{ //api call was made to override the goal spot
+			VectorCopy(bone.overGoalSpot, goalSpot);
+			bone.solidCount = 0;
+			for (k = 0; k < 3; k++)
+			{
+				e.desiredDirection[k] = (goalSpot[k] - e.currentOrigin[k]);
+				e.desiredDirection[k] += (velocityMultiplier * bone.velocityEffector[k]);
+				bone.velocityEffector[k] *= velocityDampening;
+			}
+			VectorCopy(e.currentOrigin, bone.lastPosition);
+
+			continue;
+		}
+
+		VectorSet(testMins, -e.radius*entScale[0], -e.radius*entScale[1], -e.radius*entScale[2]);
+		VectorSet(testMaxs, e.radius*entScale[0], e.radius*entScale[1], e.radius*entScale[2]);
+
+		assert(ghoul2V[0].mBoneCache);
+
+		//get the parent bone's position
+		hasDaddy = false;
+		if (bone.boneNumber)
+		{
+			assert(ghoul2V[0].animModel);
+			assert(ghoul2V[0].aHeader);
+
+			if (bone.parentBoneIndex == -1)
+			{
+				mdxaSkel_t			*skel;
+				mdxaSkelOffsets_t	*offsets;
+				int bParentIndex, bParentListIndex = -1;
+
+				offsets = (mdxaSkelOffsets_t *)((byte *)ghoul2V[0].aHeader + sizeof(mdxaHeader_t));
+				skel = (mdxaSkel_t *)((byte *)ghoul2V[0].aHeader + sizeof(mdxaHeader_t) + offsets->offsets[bone.boneNumber]);
+
+				bParentIndex = skel->parent;
+
+				while (bParentIndex > 0)
+				{ //go upward through hierarchy searching for the first parent that is a rag bone
+					skel = (mdxaSkel_t *)((byte *)ghoul2V[0].aHeader + sizeof(mdxaHeader_t) + offsets->offsets[bParentIndex]);
+					bParentIndex = skel->parent;
+					bParentListIndex = G2_Find_Bone(&ghoul2V[0], ghoul2V[0].mBlist, skel->name);
+
+					if (bParentListIndex != -1)
+					{
+						boneInfo_t &pbone = ghoul2V[0].mBlist[bParentListIndex];
+						if (pbone.flags & BONE_ANGLES_RAGDOLL)
+						{ //valid rag bone
+							break;
+						}
+					}
+
+					//didn't work out, reset to -1 again
+					bParentListIndex = -1;
+				}
+
+				bone.parentBoneIndex = bParentListIndex;
+			}
+
+			if (bone.parentBoneIndex != -1)
+			{
+				boneInfo_t &pbone = ghoul2V[0].mBlist[bone.parentBoneIndex];
+
+				if (pbone.flags & BONE_ANGLES_RAGDOLL)
+				{ //has origin calculated for us already
+					VectorCopy(ragEffectors[pbone.ragIndex].currentOrigin, parentOrigin);
+					hasDaddy = true;
+				}
+			}
+		}
+
+		//get the position this bone would be in if we were in the desired frame
+		hasBasePos = false;
+		if (broadsword_ragtobase &&
+			broadsword_ragtobase->integer)
+		{
+			vec3_t v, a;
+			float f;
+
+			G2_RagGetWorldAnimMatrix(ghoul2V[0], bone, params, worldBaseMatrix);
+			G2API_GiveMeVectorFromMatrix(worldBaseMatrix, ORIGIN, basePos);
+
+			if (broadsword_ragtobase->integer > 1)
+			{
+				float fa = AngleNormalize180(animPelvisDir[YAW]-pelvisDir[YAW]);
+				float d = fa-bone.offsetRotation;
+				float tolerance = 16.0f;
+
+				if (d > tolerance ||
+					d < -tolerance)
+				{ //don't update unless x degrees away from the ideal to avoid moving goal spots too much if pelvis rotates
+					bone.offsetRotation = fa;
+				}
+				else
+				{
+					fa = bone.offsetRotation;
+				}
+				//Rotate the point around the pelvis based on the offsets between pelvis positions
+				VectorSubtract(basePos, animPelvisPos, v);
+				f = VectorLength(v);
+				vectoangles(v, a);
+				a[YAW] -= fa;
+				AngleVectors(a, v, 0, 0);
+				VectorNormalize(v);
+				VectorMA(animPelvisPos, f, v, basePos);
+
+				//re-orient the position of the bone to the current position of the pelvis
+				VectorSubtract(basePos, animPelvisPos, v);
+				//push the spots outward? (to stretch the skeleton more)
+				//v[0] *= 1.5f;
+				//v[1] *= 1.5f;
+				VectorAdd(pelvisPos, v, basePos);
+			}
+#if 0 //for debugging frame skeleton
+			mdxaSkel_t			*skel;
+			mdxaSkelOffsets_t	*offsets;
+
+			offsets = (mdxaSkelOffsets_t *)((byte *)ghoul2V[0].aHeader + sizeof(mdxaHeader_t));
+			skel = (mdxaSkel_t *)((byte *)ghoul2V[0].aHeader + sizeof(mdxaHeader_t) + offsets->offsets[bone.boneNumber]);
+
+			vec3_t pu;
+			VectorCopy(basePos, pu);
+			pu[2] += 32;
+			if (bone.boneNumber < 11)
+			{
+				params->DebugLine(basePos, pu, 0xff00ff, false);
+				//G2_RagDebugLine(basePos, pu, 50, 0xff00ff, 1);
+			}
+			else if (skel->name[0] == 'l')
+			{
+				params->DebugLine(basePos, pu, 0xffff00, false);
+				//G2_RagDebugLine(basePos, pu, 50, 0xffff00, 1);
+			}
+			else if (skel->name[0] == 'r')
+			{
+				params->DebugLine(basePos, pu, 0xffffff, false);
+				//G2_RagDebugLine(basePos, pu, 50, 0xffffff, 1);
+			}
+			else
+			{
+				params->DebugLine(basePos, pu, 0x00ffff, false);
+				//G2_RagDebugLine(basePos, pu, 50, 0x00ffff, 1);
+			}
+#endif
+			hasBasePos = true;
+		}
+
+		//Are we in solid?
+		if (hasDaddy)
+		{
+			Rag_Trace(&tr, e.currentOrigin, testMins, testMaxs, parentOrigin, ignoreNum, RAG_MASK, G2_NOCOLLIDE, 0);
+			//Rag_Trace(&tr, parentOrigin, testMins, testMaxs, e.currentOrigin, ignoreNum, RAG_MASK, G2_NOCOLLIDE, 0);
+		}
+		else
+		{
+			Rag_Trace(&tr, e.currentOrigin, testMins, testMaxs, params->position, ignoreNum, RAG_MASK, G2_NOCOLLIDE, 0);
+		}
+
+
+		if (tr.startsolid || tr.allsolid || tr.fraction != 1.0f)
+		{ //currently in solid, see what we can do about it
+			vec3_t vSub;
+
+			startSolid = true;
+			anySolid = true;
+
+			if (hasBasePos)// && bone.solidCount < 32)
+			{ //only go to the base pos for slightly in solid bones
+#if 0 //over-compensation
+				float fl;
+				float floorBase;
+
+				VectorSubtract(basePos, e.currentOrigin, vSub);
+				fl = VectorNormalize(vSub);
+				VectorMA(e.currentOrigin, /*fl*8.0f*/64.0f, vSub, goalSpot);
+
+				floorBase = ((params->position[2]-23)-testMins[2])+8;
+
+				if (goalSpot[2] > floorBase)
+				{
+					goalSpot[2] = floorBase;
+				}
+#else
+				VectorCopy(basePos, goalSpot);
+				goalSpot[2] = (params->position[2]-23)-testMins[2];
+#endif
+				//Com_Printf("%i: %f %f %f\n", bone.boneNumber, basePos[0], basePos[1], basePos[2]);
+			}
+			else
+			{ //if deep in solid want to try to rise up out of solid before hinting back to base
+				VectorSubtract(e.currentOrigin, params->position, vSub);
+				VectorNormalize(vSub);
+				VectorMA(params->position, 40.0f, vSub, goalSpot);
+
+				//should be 1 unit above the ground taking bounding box sizes into account
+				goalSpot[2] = (params->position[2]-23)-testMins[2];
+			}
+
+			//Trace from the entity origin in the direction between the origin and current bone position to
+			//find a good eventual goal position
+			Rag_Trace(&tr, params->position, testMins, testMaxs, goalSpot, params->me, RAG_MASK, G2_NOCOLLIDE, 0);
+			VectorCopy(tr.endpos, goalSpot);
+		}
+		else
+		{
+			startSolid = false;
+
+#if 1 //do hinting?
+			//Hint the bone back to the base origin
+			if (hasDaddy || hasBasePos)
+			{
+				if (hasBasePos)
+				{
+					VectorSubtract(basePos, e.currentOrigin, velDir);					
+				}
+				else
+				{
+					VectorSubtract(e.currentOrigin, parentOrigin, velDir);
+				}
+			}
+			else
+			{
+				VectorSubtract(e.currentOrigin, params->position, velDir);
+			}
+
+			if (VectorLength(velDir) > 2.0f)
+			{ //don't bother if already close
+				VectorNormalize(velDir);
+				VectorScale(velDir, 8.0f, velDir);
+				velDir[2] = 0; //don't want to nudge on Z, the gravity will take care of things.
+				VectorAdd(bone.epVelocity, velDir, bone.epVelocity);
+			}
+#endif
+
+			//Factor the object's velocity into the bone's velocity, by pushing the bone
+			//opposite the velocity to give the apperance the lighter limbs are being "dragged"
+			//behind those of greater mass.
+			if (bone.RagFlags & RAG_BONE_LIGHTWEIGHT)
+			{
+				vec3_t vel;
+				float vellen;
+
+				VectorCopy(params->velocity, vel);
+
+				//Scale down since our velocity scale is different from standard game physics
+				VectorScale(vel, 0.5f, vel);
+
+				vellen = VectorLength(vel);
+
+				if (vellen > 64.0f)
+				{ //cap it off
+					VectorScale(vel, 64.0f/vellen, vel);
+				}
+
+				//Invert the velocity so we go opposite the heavier parts and drag behind
+				VectorInverse(vel);
+
+				if (vel[2])
+				{ //want to override entirely instead then
+					VectorCopy(vel, bone.epVelocity);
+				}
+				else
+				{
+					VectorAdd(bone.epVelocity, vel, bone.epVelocity);
+				}
+			}
+
+			//We're not in solid so we can apply physics freely now.
+			if (!G2_ApplyRealBonePhysics(bone, e, params, goalSpot, NULL, testMins, testMaxs,
+				gravity, mass, bounce))
+			{ //if this is the case then somehow we failed to apply physics/get a good goal spot, just use the ent origin
+				VectorCopy(params->position, goalSpot);
+			}
+		}
+
+		//Set this now so we know what to do for angle limiting
+		if (startSolid)
+		{
+			bone.solidCount++;
+
+			/*
+			if (cgvm)
+			{ //make a callback and see if the cgame wants to help us out
+				ragCallbackBoneInSolid_t *callData = (ragCallbackBoneInSolid_t *)cl.mSharedMemory;
+
+				VectorCopy(e.currentOrigin, callData->bonePos);
+				callData->entNum = params->me;
+				callData->solidCount = bone.solidCount;
+
+				VM_Call(cgvm, CG_RAG_CALLBACK, RAG_CALLBACK_BONEINSOLID);
+			}
+			*/
+
+			Rag_Trace(&solidTr, params->position, testMins, testMaxs, e.currentOrigin, ignoreNum, RAG_MASK, G2_NOCOLLIDE, 0);
+
+			if (solidTr.fraction != 1.0f &&
+				(solidTr.plane.normal[0] || solidTr.plane.normal[1]) &&
+				(solidTr.plane.normal[2] < 0.1f || solidTr.plane.normal[2] > -0.1f))// && //don't do anything against flat around
+			//	e.currentOrigin[2] > pelvisPos[2])
+			{ //above pelvis, means not "even" with on ground level
+				SRagDollEffectorCollision args(e.currentOrigin,tr);
+				args.useTracePlane = false;
+				params->EffectorCollision(args);
+			}
+
+#ifdef _DEBUG_BONE_NAMES
+			if (bone.solidCount > 64)
+			{
+				char *debugBoneName = G2_Get_Bone_Name(&ghoul2V[0], ghoul2V[0].mBlist, bone.boneNumber);
+				vec3_t absmin, absmax;
+
+				assert(debugBoneName);
+
+				Com_Printf("High bone (%s, %i) solid count: %i\n", debugBoneName, bone.boneNumber, bone.solidCount);
+
+				VectorAdd(e.currentOrigin, testMins, absmin);
+				VectorAdd(e.currentOrigin, testMaxs, absmax);
+				G2_RagDebugBox(absmin, absmax, 50);
+
+				G2_RagDebugLine(e.currentOrigin, goalSpot, 50, 0x00ff00, 1);
+			}
+#endif
+		}
+		else
+		{
+			bone.solidCount = 0;
+		}
+
+#if 0 //standard goalSpot capping?
+		//unless we are really in solid, we should keep adjustments minimal
+        if (/*bone.epGravFactor < 64 &&*/ bone.solidCount < 2 &&
+			!inAir)
+		{
+			vec3_t moveDist;
+			const float extent = 32.0f;
+			float len;
+
+			VectorSubtract(goalSpot, e.currentOrigin, moveDist);
+			len = VectorLength(moveDist);
+
+			if (len > extent)
+			{ //if greater than the extent then scale the vector down to the extent and factor it back into the goalspot
+                VectorScale(moveDist, extent/len, moveDist);
+				VectorAdd(e.currentOrigin, moveDist, goalSpot);
+			}
+		}
+#endif
+
+		//params->DebugLine(e.currentOrigin, goalSpot, 0xff0000, false);
+
+		//Set the desired direction based on the goal position and other factors.
+		for (k = 0; k < 3; k++)
+		{
+			e.desiredDirection[k] = (goalSpot[k] - e.currentOrigin[k]);
+
+			if (broadsword_dircap &&
+				broadsword_dircap->value)
+			{
+				float cap = broadsword_dircap->value;
+
+				if (bone.solidCount > 5)
+				{
+					float solidFactor = bone.solidCount*0.2f;
+
+					if (solidFactor > 16.0f)
+					{ //don't go too high or something ugly might happen
+						solidFactor = 16.0f;
+					}
+
+					e.desiredDirection[k] *= solidFactor;
+					cap *= 8;
+				}
+
+				if (e.desiredDirection[k] > cap)
+				{
+					e.desiredDirection[k] = cap;
+				}
+				else if (e.desiredDirection[k] < -cap)
+				{
+					e.desiredDirection[k] = -cap;
+				}
+			}
+
+			e.desiredDirection[k] += (velocityMultiplier * bone.velocityEffector[k]);
+			e.desiredDirection[k] += (flrand(-0.75f, 0.75f) * flrand(-0.75f, 0.75f));
+
+			bone.velocityEffector[k] *= velocityDampening;
+		}
+		VectorCopy(e.currentOrigin, bone.lastPosition);
+	}
+
+	return anySolid;
+}
+#endif
+
+static float AngleNormZero(float theta)
+{
+	float ret=fmodf(theta,360.0f);
+	if (ret<-180.0f)
+	{
+		ret+=360.0f;
+	}
+	else if (ret>180.0f)
+	{
+		ret-=360.0f;
+	}
+	assert(ret>=-180.0f&&ret<=180.0f);
+	return ret;
+}
+
+static inline void G2_BoneSnap(CGhoul2Info_v &ghoul2V, boneInfo_t &bone, CRagDollUpdateParams *params)
+{
+	/*
+	if (!cgvm || !params)
+	{
+		return;
+	}
+
+	ragCallbackBoneSnap_t *callData = (ragCallbackBoneSnap_t *)cl.mSharedMemory;
+
+	callData->entNum = params->me;
+	strcpy(callData->boneName, G2_Get_Bone_Name(&ghoul2V[0], ghoul2V[0].mBlist, bone.boneNumber));
+
+	VM_Call(cgvm, CG_RAG_CALLBACK, RAG_CALLBACK_BONESNAP);
+	*/
+	//fixme: add params callback I suppose
+}
+
+static void G2_RagDollSolve(CGhoul2Info_v &ghoul2V,int g2Index,float decay,int frameNum,const vec3_t currentOrg,bool limitAngles,CRagDollUpdateParams *params)
+{
+
+	int i;
+
+	CGhoul2Info &ghoul2=ghoul2V[g2Index];
+
+	mdxaBone_t N;
+	mdxaBone_t P;
+	mdxaBone_t temp1;
+	mdxaBone_t temp2;
+	mdxaBone_t curRot;
+	mdxaBone_t curRotInv;
+	mdxaBone_t Gs[3];
+	mdxaBone_t Enew[3];
+
+	assert(ghoul2.mFileName[0]);
+	boneInfo_v &blist = ghoul2.mBlist;
+
+
+	// END this is the objective function thing
+	for (i=0;i<numRags;i++)
+	{		
+		// these are used for affecting the end result
+		boneInfo_t &bone=*ragBoneData[i];
+		if (!(bone.RagFlags & RAG_PCJ))
+		{
+			continue; // not an active ragdoll PCJ
+		}
+						/* the situation is thus. (the dependent bone is in essence an effector)
+
+							The effector true bone matrix is:
+								Ecur = ragBones[depIndex] =
+									EntToWorld * [skeletal heirachy1] * 
+									MyAnimMatrix * ragBasepose[i] * current_rot_matrix * ragBaseposeInv[i] *
+									[skeletal heirachy2] * EffectorAnimMatrix * ragBasepose[depIndex]
+
+						My ( sub-i) true bone matrix is:
+								M = ragBones[i] = EntToWorld * [skeletal heirachry1] * 
+								MyAnimMatrix * ragBasepose[i] * current_rot_matrix * ragBaseposeInv[i] * ragBasepose[i]
+
+							Simplifies to:
+								M = ragBones[i] = EntToWorld * [skeletal heirachry1] * 
+								MyAnimMatrix * ragBasepose[i] * current_rot_matrix
+
+
+							Enew is:
+
+								Enew = M * 
+									inv(current_rot_matrix) * ragBaseposeInv[i] *
+									ragBasepose[i] * new_rot_matrix * ragBaseposeInv[i] *
+									inv(M*ragBaseposeInv[i]) * Ecur
+
+							We can simplify a bit:
+
+								Enew = M * 
+									inv(current_rot_matrix) * ragBaseposeInv[i] *
+									ragBasepose[i] * new_rot_matrix * ragBaseposeInv[i] *
+									ragBasepose[i] * inv(M) * Ecur
+
+								Enew = 
+									M * inv(current_rot_matrix) * 
+									new_rot_matrix * inv(M) * Ecur
+
+							We define P to be:
+								P = M * inv(current_rot_matrix)
+
+							We define N to be:
+								N = inv(M) 
+
+							then it is just:
+
+								Enew= P * new_rot_matrix * N * Ecur
+
+							Ri=new_rot_matrix (for each euler angle)
+							we are gonna use three R's, so will will precompute them as Gi = P * Ri * N
+
+
+							and then Enewi= Gi * Ecur
+
+							we are gonna evaluate Enewi for "goodness" and accumulate changes in delAngles
+
+						*/
+
+		Inverse_Matrix(&ragBones[i], &N);  // dest 2nd arg
+
+		int k;
+		vec3_t tAngles;
+		VectorCopy(bone.currentAngles,tAngles);
+		Create_Matrix(tAngles,&curRot);  //dest 2nd arg
+		Inverse_Matrix(&curRot,&curRotInv);  // dest 2nd arg
+
+		Multiply_3x4Matrix(&P,&ragBones[i],&curRotInv); //dest first arg
+
+
+
+		if (bone.RagFlags & RAG_PCJ_MODEL_ROOT)
+		{
+			if (haveDesiredPelvisOffset)
+			{
+				float	magicFactor12=0.25f; // dampfactor for pelvis pos
+				float	magicFactor13=0.20f; //controls the speed of the gradient descent (pelvis pos)
+
+				/*
+				if (params->groundEnt != ENTITYNUM_NONE)
+				{
+					magicFactor13 = 0.2f;
+				}
+				*/
+
+				assert( !_isnan(bone.ragOverrideMatrix.matrix[2][3]));
+				vec3_t deltaInEntitySpace;
+				TransformPoint(desiredPelvisOffset,deltaInEntitySpace,&N); // dest middle arg
+				for (k=0;k<3;k++)
+				{
+					float moveTo=bone.velocityRoot[k]+deltaInEntitySpace[k]*magicFactor13;
+					bone.velocityRoot[k]=(bone.velocityRoot[k]-moveTo)*magicFactor12+moveTo;
+					/*
+					if (bone.velocityRoot[k]>50.0f)
+					{
+						bone.velocityRoot[k]=50.0f;
+					}
+					if (bone.velocityRoot[k]<-50.0f)
+					{
+						bone.velocityRoot[k]=-50.0f;
+					}
+					*/
+					//No -rww
+					bone.ragOverrideMatrix.matrix[k][3]=bone.velocityRoot[k];
+				}
+			}
+		}
+		else
+		{ 
+			vec3_t delAngles;
+			VectorClear(delAngles);
+
+			for (k=0;k<3;k++)
+			{
+				tAngles[k]+=0.5f;
+				Create_Matrix(tAngles,&temp2);  //dest 2nd arg
+				tAngles[k]-=0.5f;
+				Multiply_3x4Matrix(&temp1,&P,&temp2); //dest first arg
+				Multiply_3x4Matrix(&Gs[k],&temp1,&N); //dest first arg
+
+			}
+
+			int allSolidCount = 0;//bone.solidCount;
+
+			// fixme precompute this
+			int numDep=G2_GetBoneDependents(ghoul2,bone.boneNumber,tempDependents,MAX_BONES_RAG);
+			int j;
+			int numRagDep=0;
+			for (j=0;j<numDep;j++)
+			{
+				//fixme why do this for the special roots?
+				if (!(tempDependents[j]<(*rag).size()&&(*rag)[tempDependents[j]]))
+				{
+					continue;
+				}
+				int depIndex=(*rag)[tempDependents[j]]->ragIndex;
+				assert(depIndex>i); // these are supposed to be topologically sorted
+				assert(ragBoneData[depIndex]);
+				boneInfo_t &depBone=*ragBoneData[depIndex];
+				if (depBone.RagFlags & RAG_EFFECTOR)						// rag doll effector
+				{
+					// this is a dependent of me, and also a rag
+					numRagDep++;
+					for (k=0;k<3;k++)
+					{
+						Multiply_3x4Matrix(&Enew[k],&Gs[k],&ragBones[depIndex]); //dest first arg
+						vec3_t tPosition;
+						tPosition[0]=Enew[k].matrix[0][3];
+						tPosition[1]=Enew[k].matrix[1][3];
+						tPosition[2]=Enew[k].matrix[2][3];
+
+						vec3_t change;
+						VectorSubtract(tPosition,ragEffectors[depIndex].currentOrigin,change); // dest is last arg
+						float goodness=DotProduct(change,ragEffectors[depIndex].desiredDirection);
+						assert( !_isnan(goodness));
+						goodness*=depBone.weight;
+						delAngles[k]+=goodness; // keep bigger stuff more out of wall or something
+						assert( !_isnan(delAngles[k]));
+					}
+					allSolidCount += depBone.solidCount;
+				}
+			}
+
+			allSolidCount += bone.solidCount;
+
+			VectorCopy(bone.currentAngles,bone.lastAngles);
+			//		Update angles
+			float	magicFactor9=0.75f; // dampfactor for angle changes
+			float	magicFactor1=0.40f; //controls the speed of the gradient descent
+			float	magicFactor32 = 1.5f;
+			float recip=0.0f;
+			if (numRagDep)
+			{
+				recip=sqrt(4.0f/float(numRagDep));
+			}
+			
+			if (allSolidCount > 32)
+			{
+				magicFactor1 = 0.6f;
+			}
+			else if (allSolidCount > 10)
+			{
+				magicFactor1 = 0.5f;
+			}
+
+			if (bone.overGradSpeed)
+			{ //api call was made to specify a speed for this bone
+				magicFactor1 = bone.overGradSpeed;
+			}
+
+			float fac=decay*recip*magicFactor1;
+			assert(fac>=0.0f);
+#if 0
+			if (bone.RagFlags & RAG_PCJ_PELVIS) 
+			{
+				magicFactor9=.85f; // we don't want this swinging radically, make the whole thing kindof unstable
+			}
+#endif
+			if (ragState==ERS_DYNAMIC)
+			{
+				magicFactor9=.85f; // we don't want this swinging radically, make the whole thing kindof unstable
+			}
+
+#if 1 //constraint breaks?
+			if (bone.RagFlags & RAG_UNSNAPPABLE)
+			{
+				magicFactor32 = 1.0f;
+			}
+#endif
+
+			for (k=0;k<3;k++)
+			{
+				bone.currentAngles[k]+=delAngles[k]*fac;
+
+				bone.currentAngles[k]=(bone.lastAngles[k]-bone.currentAngles[k])*magicFactor9 + bone.currentAngles[k];
+				bone.currentAngles[k]=AngleNormZero(bone.currentAngles[k]);
+//	bone.currentAngles[k]=flrand(bone.minAngles[k],bone.maxAngles[k]);
+#if 1 //constraint breaks?
+				if (limitAngles && ( allSolidCount < 16 || (bone.RagFlags & RAG_UNSNAPPABLE) )) //16 tries and still in solid? Then we'll let you move freely
+#else
+				if (limitAngles)
+#endif
+				{
+					if (!bone.snapped || (bone.RagFlags & RAG_UNSNAPPABLE))
+					{
+						//magicFactor32 += (allSolidCount/32);
+
+						if (bone.currentAngles[k]>bone.maxAngles[k]*magicFactor32)
+						{
+							bone.currentAngles[k]=bone.maxAngles[k]*magicFactor32;
+						}
+						if (bone.currentAngles[k]<bone.minAngles[k]*magicFactor32)
+						{
+							bone.currentAngles[k]=bone.minAngles[k]*magicFactor32;
+						}
+					}
+				}
+			}
+
+			bool isSnapped = false;
+			for (k=0;k<3;k++)
+			{
+				if (bone.currentAngles[k]>bone.maxAngles[k]*magicFactor32)
+				{
+					isSnapped = true;
+					break;
+				}
+				if (bone.currentAngles[k]<bone.minAngles[k]*magicFactor32)
+				{
+					isSnapped = true;
+					break;
+				}
+			}
+
+			if (isSnapped != bone.snapped)
+			{
+				G2_BoneSnap(ghoul2V, bone, params);
+				bone.snapped = isSnapped;
+			}
+
+			Create_Matrix(bone.currentAngles,&temp1);
+			Multiply_3x4Matrix(&temp2,&temp1,bone.baseposeInv);
+			Multiply_3x4Matrix(&bone.ragOverrideMatrix,bone.basepose, &temp2);
+			assert( !_isnan(bone.ragOverrideMatrix.matrix[2][3]));
+		}
+		G2_Generate_MatrixRag(blist,ragBlistIndex[bone.boneNumber]);
+	}
+}
+
+static void G2_IKReposition(const vec3_t currentOrg,CRagDollUpdateParams *params)
+{
+	int i;
+
+	assert(params);
+
+	for (i=0;i<numRags;i++)
+	{
+		boneInfo_t &bone=*ragBoneData[i];
+		SRagEffector &e=ragEffectors[i];
+
+		if (!(bone.RagFlags & RAG_EFFECTOR))
+		{
+			continue; 
+		}
+		
+		//Most effectors are not going to be PCJ, so this is not appplicable.
+		//The actual desired angle of the PCJ is factored around the desired
+		//directions of the effectors which are dependant on it.
+		/*
+		if (!(bone.RagFlags & RAG_PCJ_IK_CONTROLLED))
+		{
+			continue; 
+		}
+		*/
+
+		int k;
+		float		magicFactor12=0.8f; // dampening of velocity applied
+		float		magicFactor16=10.0f; // effect multiplier of velocity applied
+		for (k=0;k<3;k++)
+		{
+			e.desiredDirection[k]=bone.ikPosition[k]-e.currentOrigin[k];
+			e.desiredDirection[k]+=magicFactor16*bone.velocityEffector[k];
+			e.desiredDirection[k]+=flrand(-0.75f,0.75f)*flrand(-0.75f,0.75f);
+			bone.velocityEffector[k]*=magicFactor12;
+		}
+		VectorCopy(e.currentOrigin,bone.lastPosition); // last arg is dest
+	}
+}
+
+static void G2_IKSolve(CGhoul2Info_v &ghoul2V,int g2Index,float decay,int frameNum,const vec3_t currentOrg,bool limitAngles)
+{
+	int i;
+
+	CGhoul2Info &ghoul2 = ghoul2V[g2Index];
+
+	mdxaBone_t N;
+	mdxaBone_t P;
+	mdxaBone_t temp1;
+	mdxaBone_t temp2;
+	mdxaBone_t curRot;
+	mdxaBone_t curRotInv;
+	mdxaBone_t Gs[3];
+	mdxaBone_t Enew[3];
+
+	assert(ghoul2.mFileName[0]);
+	boneInfo_v &blist = ghoul2.mBlist;
+
+	// END this is the objective function thing
+	for (i = 0; i < numRags; i++)
+	{		
+		// these are used for affecting the end result
+		boneInfo_t &bone = *ragBoneData[i];
+
+		if (bone.RagFlags & RAG_PCJ_MODEL_ROOT)
+		{
+			continue;
+		}
+
+		if (!(bone.RagFlags & RAG_PCJ_IK_CONTROLLED))
+		{
+			continue;
+		}
+
+		Inverse_Matrix(&ragBones[i], &N);  // dest 2nd arg
+		
+		int k;
+		vec3_t tAngles;
+		VectorCopy(bone.currentAngles, tAngles);
+		Create_Matrix(tAngles, &curRot);  //dest 2nd arg
+		Inverse_Matrix(&curRot, &curRotInv);  // dest 2nd arg
+
+		Multiply_3x4Matrix(&P, &ragBones[i], &curRotInv); //dest first arg
+
+
+		vec3_t delAngles;
+		VectorClear(delAngles);
+
+		for (k = 0; k < 3; k++)
+		{
+			tAngles[k] += 0.5f;
+			Create_Matrix(tAngles, &temp2);  //dest 2nd arg
+			tAngles[k] -= 0.5f;
+			Multiply_3x4Matrix(&temp1, &P, &temp2); //dest first arg
+			Multiply_3x4Matrix(&Gs[k], &temp1, &N); //dest first arg
+		}
+
+		// fixme precompute this
+		int numDep=G2_GetBoneDependents(ghoul2,bone.boneNumber,tempDependents,MAX_BONES_RAG);
+		int j;
+		int numRagDep=0;
+		for (j=0;j<numDep;j++)
+		{
+			//fixme why do this for the special roots?
+			if (!(tempDependents[j]<(*rag).size()&&(*rag)[tempDependents[j]]))
+			{
+				continue;
+			}
+			int depIndex=(*rag)[tempDependents[j]]->ragIndex;
+			if (!ragBoneData[depIndex])
+			{
+				continue;
+			}
+			boneInfo_t &depBone=*ragBoneData[depIndex];
+
+			if (depBone.RagFlags & RAG_EFFECTOR)
+			{
+				// this is a dependent of me, and also a rag
+				numRagDep++;
+				for (k=0;k<3;k++)
+				{
+					Multiply_3x4Matrix(&Enew[k],&Gs[k],&ragBones[depIndex]); //dest first arg
+					vec3_t tPosition;
+					tPosition[0]=Enew[k].matrix[0][3];
+					tPosition[1]=Enew[k].matrix[1][3];
+					tPosition[2]=Enew[k].matrix[2][3];
+
+					vec3_t change;
+					VectorSubtract(tPosition,ragEffectors[depIndex].currentOrigin,change); // dest is last arg
+					float goodness=DotProduct(change,ragEffectors[depIndex].desiredDirection);
+					assert( !_isnan(goodness));
+					goodness*=depBone.weight;
+					delAngles[k]+=goodness; // keep bigger stuff more out of wall or something
+					assert( !_isnan(delAngles[k]));
+				}
+			}
+		}
+
+		VectorCopy(bone.currentAngles, bone.lastAngles);
+
+		//		Update angles
+		float	magicFactor9 = 0.75f; // dampfactor for angle changes
+		float	magicFactor1 = bone.ikSpeed; //controls the speed of the gradient descent
+		float	magicFactor32 = 1.0f;
+		float	recip = 0.0f;
+		bool	freeThisBone = false;
+
+		if (!magicFactor1)
+		{
+			magicFactor1 = 0.40f;
+		}
+	
+		recip = sqrt(4.0f/1.0f);
+
+		float fac = (decay*recip*magicFactor1);
+		assert(fac >= 0.0f);
+
+		if (ragState == ERS_DYNAMIC)
+		{
+			magicFactor9 = 0.85f; // we don't want this swinging radically, make the whole thing kindof unstable
+		}
+
+
+		if (!bone.maxAngles[0] && !bone.maxAngles[1] && !bone.maxAngles[2] &&
+			!bone.minAngles[0] && !bone.minAngles[1] && !bone.minAngles[2])
+		{
+			freeThisBone = true;
+		}
+
+		for (k = 0; k < 3; k++)
+		{
+			bone.currentAngles[k] += delAngles[k]*fac;
+
+			bone.currentAngles[k] = (bone.lastAngles[k]-bone.currentAngles[k])*magicFactor9 + bone.currentAngles[k];
+			bone.currentAngles[k] = AngleNormZero(bone.currentAngles[k]);
+			if (limitAngles && !freeThisBone)
+			{
+				if (bone.currentAngles[k] > bone.maxAngles[k]*magicFactor32)
+				{
+					bone.currentAngles[k] = bone.maxAngles[k]*magicFactor32;
+				}
+				if (bone.currentAngles[k] < bone.minAngles[k]*magicFactor32)
+				{
+					bone.currentAngles[k] = bone.minAngles[k]*magicFactor32;
+				}
+			}
+		}
+		Create_Matrix(bone.currentAngles, &temp1);
+		Multiply_3x4Matrix(&temp2, &temp1, bone.baseposeInv);
+		Multiply_3x4Matrix(&bone.ragOverrideMatrix, bone.basepose, &temp2);
+		assert( !_isnan(bone.ragOverrideMatrix.matrix[2][3]));
+
+		G2_Generate_MatrixRag(blist, ragBlistIndex[bone.boneNumber]);
+	}
+}
+
+static void G2_DoIK(CGhoul2Info_v &ghoul2V,int g2Index,CRagDollUpdateParams *params)
+{
+	int i;
+
+	if (!params)
+	{
+		assert(0);
+		return;
+	}
+
+	int frameNum=G2API_GetTime(0);
+	CGhoul2Info &ghoul2=ghoul2V[g2Index];
+	assert(ghoul2.mFileName[0]);
+
+	float decay=1.0f;
+	bool resetOrigin=false;
+	bool anyRendered=false;
+
+	int iters = 12; //since we don't trace or anything, we can afford this.
+
+	if (iters)
+	{
+		if (!G2_RagDollSetup(ghoul2,frameNum,resetOrigin,params->position,anyRendered))
+		{
+			return;
+		}
+
+		// ok, now our data structures are compact and set up in topological order
+		for (i=0;i<iters;i++)
+		{
+			G2_RagDollCurrentPosition(ghoul2V,g2Index,frameNum,params->angles,params->position,params->scale);
+
+			G2_IKReposition(params->position, params);
+
+			G2_IKSolve(ghoul2V,g2Index,decay*2.0f,frameNum,params->position,true);
+		}
+	}
+
+	if (params->me != ENTITYNUM_NONE)
+	{
+		G2_RagDollCurrentPosition(ghoul2V,g2Index,frameNum,params->angles,params->position,params->scale);
+	}
+}
+
+//rww - cut out the entire non-ragdoll section of this..
+void G2_Animate_Bone_List(CGhoul2Info_v &ghoul2, const int currentTime, const int index,CRagDollUpdateParams *params)
+{
+	int i;
+	bool anyRagDoll=false;
+	bool anyIK = false;
+	for(i=0; i<ghoul2[index].mBlist.size(); i++)
+	{
+		if (ghoul2[index].mBlist[i].boneNumber != -1)
+		{
+			if (ghoul2[index].mBlist[i].flags & BONE_ANGLES_RAGDOLL)
+			{
+				if (ghoul2[index].mBlist[i].RagFlags & RAG_PCJ_IK_CONTROLLED)
+				{
+					anyIK = true;
+				}
+				anyRagDoll=true;
+
+				if (anyIK && anyRagDoll)
+				{
+					break;
+				}
+			}
+		}
+	}
+	if (!index&&params)
+	{
+		if (anyIK)
+		{ //we use ragdoll params so we know what our current position, etc. is.
+			G2_DoIK(ghoul2, 0, params);
+		}
+		else
+		{
+			G2_RagDoll(ghoul2,0,params,currentTime);
+		}
+	}
+}
+//rww - RAGDOLL_END
+
+static int G2_Set_Bone_Angles_IK(
+	CGhoul2Info &ghoul2,
+	const mdxaHeader_t *mod_a,
+	boneInfo_v &blist, 
+	const char *boneName,
+	const int flags,
+	const float radius,
+	const vec3_t angleMin=0,
+	const vec3_t angleMax=0,
+	const int blendTime=500)
+{
+	int			index = G2_Find_Bone_Rag(&ghoul2, blist, boneName);
+
+	if (index == -1)
+	{
+		index = G2_Add_Bone(ghoul2.animModel, blist, boneName);
+	}
+	if (index != -1)
+	{
+		boneInfo_t &bone=blist[index];
+		bone.flags |= BONE_ANGLES_IK;
+		bone.flags &= ~BONE_ANGLES_RAGDOLL;
+
+		bone.ragStartTime=G2API_GetTime(0);
+		bone.radius=radius;
+		bone.weight=1.0f;
+
+		if (angleMin&&angleMax)
+		{
+			VectorCopy(angleMin,bone.minAngles);
+			VectorCopy(angleMax,bone.maxAngles);
+		}
+		else
+		{
+			VectorCopy(bone.currentAngles,bone.minAngles); // I guess this isn't a rag pcj then
+			VectorCopy(bone.currentAngles,bone.maxAngles);
+		}
+		if (!bone.lastTimeUpdated)
+		{
+			static mdxaBone_t		id = 
+			{ 
+				1.0f, 0.0f, 0.0f, 0.0f,
+				0.0f, 1.0f, 0.0f, 0.0f,
+				0.0f, 0.0f, 1.0f, 0.0f
+			};
+			memcpy(&bone.ragOverrideMatrix,&id, sizeof(mdxaBone_t));
+			VectorClear(bone.anglesOffset);
+			VectorClear(bone.positionOffset);
+			VectorClear(bone.velocityEffector);  // this is actually a velocity now
+			VectorClear(bone.velocityRoot);  // this is actually a velocity now
+			VectorClear(bone.lastPosition);
+			VectorClear(bone.lastShotDir);
+			bone.lastContents=0;
+			// if this is non-zero, we are in a dynamic state
+			bone.firstCollisionTime=bone.ragStartTime;
+			// if this is non-zero, we are in a settling state
+			bone.restTime=0;
+			// if they are both zero, we are in a settled state
+
+			bone.firstTime=0;
+
+			bone.RagFlags=flags;
+			bone.DependentRagIndexMask=0;
+
+			G2_Generate_MatrixRag(blist,index); // set everything to th id
+
+			VectorClear(bone.currentAngles);
+			VectorCopy(bone.currentAngles,bone.lastAngles);
+		}
+	}
+	return index;
+}
+
+void G2_InitIK(CGhoul2Info_v &ghoul2V, sharedRagDollUpdateParams_t *parms, int time, const mdxaHeader_t *mod_a, int model)
+{
+	CGhoul2Info &ghoul2=ghoul2V[model];
+	int curTime=time;
+	boneInfo_v &blist = ghoul2.mBlist;
+
+	G2_GenerateWorldMatrix(parms->angles, parms->position);
+	G2_ConstructGhoulSkeleton(ghoul2V, curTime, false, parms->scale);
+
+	// new base anim, unconscious flop
+	int pcjFlags;
+#if 0
+	vec3_t pcjMin, pcjMax;
+	VectorClear(pcjMin);
+	VectorClear(pcjMax);
+
+	pcjFlags=RAG_PCJ|RAG_PCJ_POST_MULT;//|RAG_EFFECTOR;
+
+	G2_Set_Bone_Angles_IK(ghoul2, mod_a,blist,"model_root",RAG_PCJ_MODEL_ROOT|RAG_PCJ,10.0f,pcjMin,pcjMax,100);
+	G2_Set_Bone_Angles_IK(ghoul2, mod_a,blist,"pelvis",RAG_PCJ_PELVIS|RAG_PCJ|RAG_PCJ_POST_MULT,10.0f,pcjMin,pcjMax,100);
+
+	G2_Set_Bone_Angles_IK(ghoul2, mod_a,blist,"lower_lumbar",pcjFlags,10.0f,pcjMin,pcjMax,500);
+	G2_Set_Bone_Angles_IK(ghoul2, mod_a,blist,"upper_lumbar",pcjFlags,10.0f,pcjMin,pcjMax,500);
+	G2_Set_Bone_Angles_IK(ghoul2, mod_a,blist,"thoracic",pcjFlags|RAG_EFFECTOR,12.0f,pcjMin,pcjMax,500);
+	G2_Set_Bone_Angles_IK(ghoul2, mod_a,blist,"cranium",pcjFlags,6.0f,pcjMin,pcjMax,500);
+	G2_Set_Bone_Angles_IK(ghoul2, mod_a,blist,"rhumerus",pcjFlags,4.0f,pcjMin,pcjMax,500);
+	G2_Set_Bone_Angles_IK(ghoul2, mod_a,blist,"lhumerus",pcjFlags,4.0f,pcjMin,pcjMax,500);
+	G2_Set_Bone_Angles_IK(ghoul2, mod_a,blist,"rradius",pcjFlags,3.0f,pcjMin,pcjMax,500);
+	G2_Set_Bone_Angles_IK(ghoul2, mod_a,blist,"lradius",pcjFlags,3.0f,pcjMin,pcjMax,500);
+	G2_Set_Bone_Angles_IK(ghoul2, mod_a,blist,"rfemurYZ",pcjFlags,6.0f,pcjMin,pcjMax,500);
+	G2_Set_Bone_Angles_IK(ghoul2, mod_a,blist,"lfemurYZ",pcjFlags,6.0f,pcjMin,pcjMax,500);
+	G2_Set_Bone_Angles_IK(ghoul2, mod_a,blist,"rtibia",pcjFlags,4.0f,pcjMin,pcjMax,500);
+	G2_Set_Bone_Angles_IK(ghoul2, mod_a,blist,"ltibia",pcjFlags,4.0f,pcjMin,pcjMax,500);
+
+	G2_ConstructGhoulSkeleton(ghoul2V, curTime, false, parms->scale);
+#endif
+	//Only need the standard effectors for this.
+	pcjFlags = RAG_PCJ|RAG_PCJ_POST_MULT|RAG_EFFECTOR;
+
+	G2_Set_Bone_Angles_IK(ghoul2, mod_a,blist,"rhand",pcjFlags,6.0f);
+	G2_Set_Bone_Angles_IK(ghoul2, mod_a,blist,"lhand",pcjFlags,6.0f);
+//	G2_Set_Bone_Angles_IK(ghoul2, mod_a,blist,"rtarsal",pcjFlags,4.0f);
+//	G2_Set_Bone_Angles_IK(ghoul2, mod_a,blist,"ltarsal",pcjFlags,4.0f);
+	G2_Set_Bone_Angles_IK(ghoul2, mod_a,blist,"rtibia",pcjFlags,4.0f);
+	G2_Set_Bone_Angles_IK(ghoul2, mod_a,blist,"ltibia",pcjFlags,4.0f);
+	G2_Set_Bone_Angles_IK(ghoul2, mod_a,blist,"rtalus",pcjFlags,4.0f);
+	G2_Set_Bone_Angles_IK(ghoul2, mod_a,blist,"ltalus",pcjFlags,4.0f);
+	G2_Set_Bone_Angles_IK(ghoul2, mod_a,blist,"rradiusX",pcjFlags,6.0f);
+	G2_Set_Bone_Angles_IK(ghoul2, mod_a,blist,"lradiusX",pcjFlags,6.0f);
+	G2_Set_Bone_Angles_IK(ghoul2, mod_a,blist,"rfemurX",pcjFlags,10.0f);
+	G2_Set_Bone_Angles_IK(ghoul2, mod_a,blist,"lfemurX",pcjFlags,10.0f);
+	G2_Set_Bone_Angles_IK(ghoul2, mod_a,blist,"ceyebrow",pcjFlags,10.0f);
+}
+
+qboolean G2_SetBoneIKState(CGhoul2Info_v &ghoul2, int time, const char *boneName, int ikState, sharedSetBoneIKStateParams_t *params)
+{
+	model_t		*mod_a;
+	int g2index = 0;
+	int curTime = time;
+	CGhoul2Info &g2 = ghoul2[g2index];
+	const mdxaHeader_t *rmod_a = G2_GetModA(g2);
+
+	boneInfo_v &blist = g2.mBlist;
+	mod_a = (model_t *)g2.animModel;
+
+	if (!boneName)
+	{ //null bonename param means it's time to init the ik stuff on this instance
+		sharedRagDollUpdateParams_t sRDUP;
+
+		if (ikState == IKS_NONE)
+		{ //this means we want to reset the IK state completely.. run through the bone list, and reset all the appropriate flags
+			int i = 0;
+			while (i < blist.size())
+			{ //we can't use this method for ragdoll. However, since we expect them to set their anims/angles again on the PCJ
+			  //limb after they reset it gameside, it's reasonable for IK bones.
+				boneInfo_t &bone = blist[i];
+				if (bone.boneNumber != -1)
+				{
+					bone.flags &= ~BONE_ANGLES_RAGDOLL;
+					bone.flags &= ~BONE_ANGLES_IK;
+					bone.RagFlags = 0;
+					bone.lastTimeUpdated = 0;
+				}
+				i++;
+			}
+			return qtrue;
+		}
+		assert(params);
+
+		if (!params)
+		{
+			return qfalse;
+		}
+
+		sRDUP.me = 0;
+		VectorCopy(params->angles, sRDUP.angles);
+		VectorCopy(params->origin, sRDUP.position);
+		VectorCopy(params->scale, sRDUP.scale);
+		VectorClear(sRDUP.velocity);
+		G2_InitIK(ghoul2, &sRDUP, curTime, rmod_a, g2index);
+		return qtrue;
+	}
+
+	if (!rmod_a || !mod_a)
+	{
+		return qfalse;
+	}
+
+	int index = G2_Find_Bone(&g2, blist, boneName);
+ 
+	if (index == -1)
+	{
+		index = G2_Add_Bone(mod_a, blist, boneName);
+	}
+
+	if (index == -1)
+	{ //couldn't find or add the bone..
+		return qfalse;
+	}
+
+	boneInfo_t &bone = blist[index];
+
+	if (ikState == IKS_NONE)
+	{ //remove the bone from the list then, so it has to reinit. I don't think this should hurt anything since
+	  //we don't store bone index handles gameside anywhere.
+		if (!(bone.flags & BONE_ANGLES_RAGDOLL))
+		{ //you can't set the ik state to none if it's not a rag/ik bone.
+			return qfalse;
+		}
+		//bone.flags = 0;
+		//G2_Remove_Bone_Index(blist, index);
+		//actually, I want to keep it on the rag list, and remove it as an IK bone instead.
+		bone.flags &= ~BONE_ANGLES_RAGDOLL;
+		bone.flags |= BONE_ANGLES_IK;
+		bone.RagFlags &= ~RAG_PCJ_IK_CONTROLLED;
+		return qtrue;
+	}
+
+	//need params if we're not resetting.
+	if (!params)
+	{
+		assert(0);
+		return qfalse;
+	}
+
+	/*
+	if (bone.flags & BONE_ANGLES_RAGDOLL)
+	{ //otherwise if the bone is already flagged as rag, then we can't set it again. (non-active ik bones will be BONE_ANGLES_IK, active are considered rag)
+		return qfalse;
+	}
+	*/
+#if 0 //this is wrong now.. we're only initing effectors with initik now.. which SHOULDN'T be used as pcj's
+	if (!(bone.flags & BONE_ANGLES_IK) && !(bone.flags & BONE_ANGLES_RAGDOLL))
+	{ //IK system has not been inited yet, because any bone that can be IK should be in the ragdoll list, not flagged as BONE_ANGLES_RAGDOLL but as BONE_ANGLES_IK
+		sharedRagDollUpdateParams_t sRDUP;
+		sRDUP.me = 0;
+		VectorCopy(params->angles, sRDUP.angles);
+		VectorCopy(params->origin, sRDUP.position);
+		VectorCopy(params->scale, sRDUP.scale);
+		VectorClear(sRDUP.velocity);
+		G2_InitIK(ghoul2, &sRDUP, curTime, rmod_a, g2index);
+
+		G2_ConstructGhoulSkeleton(ghoul2, curTime, false, params->scale);
+	}
+	else
+	{
+		G2_GenerateWorldMatrix(params->angles, params->origin);
+		G2_ConstructGhoulSkeleton(ghoul2, curTime, false, params->scale);
+	}
+#else
+	G2_GenerateWorldMatrix(params->angles, params->origin);
+	G2_ConstructGhoulSkeleton(ghoul2, curTime, false, params->scale);
+#endif
+
+	int pcjFlags = RAG_PCJ|RAG_PCJ_IK_CONTROLLED|RAG_PCJ_POST_MULT|RAG_EFFECTOR;
+
+	if (params->pcjOverrides)
+	{
+		pcjFlags = params->pcjOverrides;
+	}
+
+	bone.ikSpeed = 0.4f;
+	VectorClear(bone.ikPosition);
+
+	G2_Set_Bone_Rag(rmod_a, blist, boneName, g2, params->scale, params->origin);
+
+	int startFrame = params->startFrame, endFrame = params->endFrame;
+
+	G2_Set_Bone_Anim_No_BS(g2, rmod_a, blist, boneName, startFrame, endFrame-1,
+		BONE_ANIM_OVERRIDE_FREEZE|BONE_ANIM_BLEND,
+		1.0f, curTime, float(startFrame), 150, 0, true);
+
+	G2_ConstructGhoulSkeleton(ghoul2, curTime, false, params->scale);
+
+	bone.lastTimeUpdated = 0;
+	G2_Set_Bone_Angles_Rag(g2, rmod_a, blist, boneName, pcjFlags, params->radius, params->pcjMins, params->pcjMaxs, params->blendTime);
+
+	if (!G2_RagDollSetup(g2,curTime,true,params->origin,false))
+	{
+		assert(!"failed to add any rag bones");
+		return qfalse;
+	}
+
+	return qtrue;
+}
+
+qboolean G2_IKMove(CGhoul2Info_v &ghoul2, int time, sharedIKMoveParams_t *params)
+{
+#if 0
+	model_t		*mod_a;
+	int g2index = 0;
+	int curTime = time;
+	CGhoul2Info &g2 = ghoul2[g2index];
+
+	boneInfo_v &blist = g2.mBlist;
+	mod_a = (model_t *)g2.animModel;
+
+	if (!mod_a)
+	{
+		return qfalse;
+	}
+
+	int index = G2_Find_Bone(mod_a, blist, params->boneName);
+ 
+	//don't add here if you can't find it.. ik bones should already be there, because they need to have special stuff done to them anyway.
+	if (index == -1)
+	{ //couldn't find the bone..
+		return qfalse;
+	}
+
+	if (!params)
+	{
+		assert(0);
+		return qfalse;
+	}
+
+	if (!(blist[index].flags & BONE_ANGLES_RAGDOLL) && !(blist[index].flags & BONE_ANGLES_IK))
+	{ //no-can-do, buddy
+		return qfalse;
+	}
+
+	VectorCopy(params->desiredOrigin, blist[index].ikPosition);
+	blist[index].ikSpeed = params->movementSpeed;
+#else
+	int g2index = 0;
+	int curTime = time;
+	CGhoul2Info &g2 = ghoul2[g2index];
+
+	//rwwFIXMEFIXME: Doing this on all bones at the moment, fix this later?
+	if (!G2_RagDollSetup(g2,curTime,true,params->origin,false))
+	{ //changed models, possibly.
+		return qfalse;
+	}
+
+	for (int i=0;i<numRags;i++)
+	{
+		boneInfo_t &bone=*ragBoneData[i];
+
+		//if (bone.boneNumber == blist[index].boneNumber)
+		{
+			VectorCopy(params->desiredOrigin, bone.ikPosition);
+			bone.ikSpeed = params->movementSpeed;
+		}
+	}
+#endif
+	return qtrue;
+}
+
+// set the bone list to all unused so the bone transformation routine ignores it.
+void G2_Init_Bone_List(boneInfo_v &blist)
+{
+	blist.clear();
+}
+
+int	G2_Get_Bone_Index(CGhoul2Info *ghoul2, const char *boneName, qboolean bAddIfNotFound)
+{
+	if (bAddIfNotFound)
+	{
+		return G2_Add_Bone(ghoul2->animModel, ghoul2->mBlist, boneName);
+	}
+	else
+	{
+		return G2_Find_Bone(ghoul2, ghoul2->mBlist, boneName);
+	}
+}
+
+
+void G2_FreeRag(void)
+{
+	if(rag) {
+		delete rag;
+		rag = NULL;
+	}
+}
diff --git a/code/ghoul2/G2_misc.cpp b/code/ghoul2/G2_misc.cpp
new file mode 100644
index 0000000..58f2a94
--- /dev/null
+++ b/code/ghoul2/G2_misc.cpp
@@ -0,0 +1,1873 @@
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+
+
+#ifndef __Q_SHARED_H
+	#include "../game/q_shared.h"
+#endif
+
+#if !defined(TR_LOCAL_H)
+	#include "../renderer/tr_local.h"
+#endif
+
+#include "../renderer/MatComp.h"
+
+#if !defined(G2_H_INC)
+	#include "G2.h"
+#endif
+
+#if !defined (MINIHEAP_H_INC)
+	#include "../qcommon/miniheap.h"
+#endif
+
+#define G2_MODEL_OK(g) ((g)&&(g)->mValid&&(g)->aHeader&&(g)->currentModel&&(g)->animModel)
+
+#include "../server/server.h"
+
+#include <FLOAT.H>
+
+#ifdef _G2_GORE
+#include "ghoul2_gore.h"
+
+#define GORE_TAG_UPPER (256)
+#define GORE_TAG_MASK (~255)
+
+static int CurrentTag=GORE_TAG_UPPER+1;
+static int CurrentTagUpper=GORE_TAG_UPPER;
+
+static map<int,GoreTextureCoordinates> GoreRecords;
+static map<pair<int,int>,int> GoreTagsTemp; // this is a surface index to gore tag map used only 
+								  // temporarily during the generation phase so we reuse gore tags per LOD
+int goreModelIndex;
+
+bool AddGoreToAllModels=false;
+
+GoreTextureCoordinates *FindGoreRecord(int tag);
+static inline void DestroyGoreTexCoordinates(int tag)
+{
+	GoreTextureCoordinates *gTC = FindGoreRecord(tag);
+	if (!gTC)
+	{
+		return;
+	}
+	(*gTC).~GoreTextureCoordinates();
+	//I don't know what's going on here, it should call the destructor for
+	//this when it erases the record but sometimes it doesn't. -rww
+}
+
+//TODO: This needs to be set via a scalability cvar with some reasonable minimum value if pgore is used at all
+#define MAX_GORE_RECORDS (500)
+
+int AllocGoreRecord()
+{
+	while (GoreRecords.size()>MAX_GORE_RECORDS)
+	{
+		int tagHigh=(*GoreRecords.begin()).first&GORE_TAG_MASK;
+		map<int,GoreTextureCoordinates>::iterator it;
+		GoreTextureCoordinates *gTC;
+
+		it = GoreRecords.begin();
+		gTC = &(*it).second;
+
+		if (gTC)
+		{
+			gTC->~GoreTextureCoordinates();
+		}
+		GoreRecords.erase(GoreRecords.begin());
+		while (GoreRecords.size())
+		{
+			if (((*GoreRecords.begin()).first&GORE_TAG_MASK)!=tagHigh)
+			{
+				break;
+			}
+			it = GoreRecords.begin();
+			gTC = &(*it).second;
+
+			if (gTC)
+			{
+				gTC->~GoreTextureCoordinates();
+			}
+			GoreRecords.erase(GoreRecords.begin());
+		}
+	}
+	int ret=CurrentTag;
+	GoreRecords[CurrentTag]=GoreTextureCoordinates();
+	CurrentTag++;
+	return ret;
+}
+
+void ResetGoreTag()
+{
+	GoreTagsTemp.clear();
+	CurrentTag=CurrentTagUpper;
+	CurrentTagUpper+=GORE_TAG_UPPER;
+}
+
+GoreTextureCoordinates *FindGoreRecord(int tag)
+{
+	map<int,GoreTextureCoordinates>::iterator i=GoreRecords.find(tag);
+	if (i!=GoreRecords.end())
+	{
+		return &(*i).second;
+	}
+	return 0;
+}
+
+void *G2_GetGoreRecord(int tag)
+{
+	return FindGoreRecord(tag);
+}
+
+void DeleteGoreRecord(int tag)
+{
+	DestroyGoreTexCoordinates(tag);
+	GoreRecords.erase(tag);
+}
+
+static int CurrentGoreSet=1; // this is a UUID for gore sets
+static map<int,CGoreSet *> GoreSets; // map from uuid to goreset
+
+CGoreSet *FindGoreSet(int goreSetTag)
+{
+	map<int,CGoreSet *>::iterator f=GoreSets.find(goreSetTag);
+	if (f!=GoreSets.end())
+	{
+		return (*f).second;
+	}
+	return 0;
+}
+
+CGoreSet *NewGoreSet()
+{
+	CGoreSet *ret=new CGoreSet(CurrentGoreSet++);
+	GoreSets[ret->mMyGoreSetTag]=ret;
+	ret->mRefCount = 1;
+	return ret;
+}
+
+void DeleteGoreSet(int goreSetTag)
+{
+	map<int,CGoreSet *>::iterator f=GoreSets.find(goreSetTag);
+	if (f!=GoreSets.end())
+	{
+		if ( (*f).second->mRefCount == 0 || (*f).second->mRefCount - 1 == 0 )
+		{
+			delete (*f).second;
+			GoreSets.erase(f);
+		}
+		else
+		{
+			(*f).second->mRefCount--;
+		}
+	}
+}
+
+
+CGoreSet::~CGoreSet()
+{
+	multimap<int,SGoreSurface>::iterator i;
+	for (i=mGoreRecords.begin();i!=mGoreRecords.end();i++)
+	{
+		DeleteGoreRecord((*i).second.mGoreTag);
+	}
+};
+#endif
+
+extern mdxaBone_t		worldMatrix;
+extern mdxaBone_t		worldMatrixInv;
+
+const mdxaBone_t &EvalBoneCache(int index,CBoneCache *boneCache);
+
+#pragma warning(disable : 4512)		//assignment op could not be genereated
+class CTraceSurface
+{
+public:
+	int					surfaceNum;
+	surfaceInfo_v		&rootSList;
+	const model_t		*currentModel;
+	const int			lod;
+	vec3_t		rayStart;
+	vec3_t		rayEnd;
+	CCollisionRecord	*collRecMap;
+	const int			entNum;
+	const int			modelIndex;
+	const skin_t		*skin;
+	const shader_t		*cust_shader;
+	int					*TransformedVertsArray;
+	const EG2_Collision	eG2TraceType;
+	bool				hitOne;
+	float				m_fRadius;
+	
+#ifdef _G2_GORE
+	//gore application thing
+	float				ssize;
+	float				tsize;
+	float				theta;
+	int					goreShader;
+	CGhoul2Info			*ghoul2info;
+
+	//	Procedural-gore application things
+	SSkinGoreData		*gore;
+#endif
+
+	CTraceSurface(
+		int					initsurfaceNum,
+		surfaceInfo_v		&initrootSList,
+		const model_t		*initcurrentModel,
+		int					initlod,
+		vec3_t				initrayStart,
+		vec3_t				initrayEnd,
+		CCollisionRecord	*initcollRecMap,
+		int					initentNum,
+		int					initmodelIndex,
+		const skin_t		*initskin,
+		const shader_t		*initcust_shader,
+		int					*initTransformedVertsArray,
+		const EG2_Collision	einitG2TraceType,
+#ifdef _G2_GORE
+		float				fRadius,
+		float				initssize,
+		float				inittsize,
+		float				inittheta,
+		int					initgoreShader,
+		CGhoul2Info			*initghoul2info,
+		SSkinGoreData		*initgore):
+#else
+		float				fRadius):
+#endif		):
+	
+		surfaceNum(initsurfaceNum),
+		rootSList(initrootSList),   
+		currentModel(initcurrentModel),
+		lod(initlod),          
+		collRecMap(initcollRecMap),  
+		entNum(initentNum),       
+		modelIndex(initmodelIndex),
+		skin(initskin),
+		cust_shader(initcust_shader),
+		eG2TraceType(einitG2TraceType),
+		hitOne(false),
+		TransformedVertsArray(initTransformedVertsArray),
+#ifdef _G2_GORE
+		m_fRadius(fRadius),
+		ssize(initssize),
+		tsize(inittsize),
+		theta(inittheta),
+		goreShader(initgoreShader),
+		ghoul2info(initghoul2info),
+		gore(initgore)
+#else
+		m_fRadius(fRadius)
+#endif
+		{
+		VectorCopy(initrayStart, rayStart);
+		VectorCopy(initrayEnd, rayEnd);
+	}         
+};
+
+// assorted Ghoul 2 functions.
+// list all surfaces associated with a model
+void G2_List_Model_Surfaces(const char *fileName)
+{
+	int			i, x;
+  	model_t		*mod_m = R_GetModelByHandle(RE_RegisterModel(fileName));
+	mdxmSurfHierarchy_t	*surf;
+
+	surf = (mdxmSurfHierarchy_t *) ( (byte *)mod_m->mdxm + mod_m->mdxm->ofsSurfHierarchy );
+	mdxmSurface_t *surface = (mdxmSurface_t *)((byte *)mod_m->mdxm + mod_m->mdxm->ofsLODs + sizeof(mdxmLOD_t));
+
+	for ( x = 0 ; x < mod_m->mdxm->numSurfaces ; x++) 
+	{
+		Com_Printf("Surface %i Name %s\n", x, surf->name);
+		if (r_verbose->value)
+		{
+			Com_Printf("Num Descendants %i\n",  surf->numChildren);
+			for (i=0; i<surf->numChildren; i++)
+			{
+				Com_Printf("Descendant %i\n", surf->childIndexes[i]);
+			}
+		}
+		// find the next surface
+  		surf = (mdxmSurfHierarchy_t *)( (byte *)surf + (int)( &((mdxmSurfHierarchy_t *)0)->childIndexes[ surf->numChildren ] ));
+  		surface =(mdxmSurface_t *)( (byte *)surface + surface->ofsEnd );
+	}
+
+}
+
+// list all bones associated with a model
+void G2_List_Model_Bones(const char *fileName, int frame)
+{
+	int				x, i;
+	mdxaSkel_t		*skel;
+	mdxaSkelOffsets_t	*offsets;
+  	model_t			*mod_m = R_GetModelByHandle(RE_RegisterModel(fileName)); 
+	model_t			*mod_a = R_GetModelByHandle(mod_m->mdxm->animIndex);
+// 	mdxaFrame_t		*aframe=0;
+//	int				frameSize;
+	mdxaHeader_t	*header = mod_a->mdxa;
+
+	// figure out where the offset list is
+	offsets = (mdxaSkelOffsets_t *)((byte *)header + sizeof(mdxaHeader_t));
+
+//    frameSize = (int)( &((mdxaFrame_t *)0)->boneIndexes[ header->numBones ] );   
+
+//	aframe = (mdxaFrame_t *)((byte *)header + header->ofsFrames + (frame * frameSize));
+	// walk each bone and list it's name
+	for (x=0; x< mod_a->mdxa->numBones; x++)
+	{
+		skel = (mdxaSkel_t *)((byte *)header + sizeof(mdxaHeader_t) + offsets->offsets[x]);
+		Com_Printf("Bone %i Name %s\n", x, skel->name);
+
+		Com_Printf("X pos %f, Y pos %f, Z pos %f\n", skel->BasePoseMat.matrix[0][3], skel->BasePoseMat.matrix[1][3], skel->BasePoseMat.matrix[2][3]);
+
+		// if we are in verbose mode give us more details
+		if (r_verbose->value)
+		{
+			Com_Printf("Num Descendants %i\n",  skel->numChildren);
+			for (i=0; i<skel->numChildren; i++)
+			{
+				Com_Printf("Num Descendants %i\n",  skel->numChildren);
+			}
+		}
+	}
+}
+
+
+/************************************************************************************************
+ * G2_GetAnimFileName
+ *    obtain the .gla filename for a model
+ *
+ * Input
+ *    filename of model 
+ *
+ * Output
+ *    true if we successfully obtained a filename, false otherwise
+ *
+ ************************************************************************************************/
+qboolean G2_GetAnimFileName(const char *fileName, char **filename)
+{
+	// find the model we want
+	model_t				*mod = R_GetModelByHandle(RE_RegisterModel(fileName));
+
+	if (mod && mod->mdxm && (mod->mdxm->animName[0] != 0))
+	{
+		*filename = mod->mdxm->animName;
+		return qtrue;
+	}
+	return qfalse;
+}
+
+
+/////////////////////////////////////////////////////////////////////
+// 
+//	Code for collision detection for models gameside
+//
+/////////////////////////////////////////////////////////////////////
+
+int G2_DecideTraceLod(CGhoul2Info &ghoul2, int useLod)
+{
+	int returnLod = useLod;
+
+   	// if we are overriding the LOD at top level, then we can afford to only check this level of model
+   	if (ghoul2.mLodBias > returnLod)
+   	{
+   		returnLod =  ghoul2.mLodBias;
+   	}
+	assert(G2_MODEL_OK(&ghoul2));
+	
+	assert(ghoul2.currentModel);
+	assert(ghoul2.currentModel->mdxm);
+	//what about r_lodBias?
+
+	// now ensure that we haven't selected a lod that doesn't exist for this model
+	if ( returnLod >= ghoul2.currentModel->mdxm->numLODs )
+ 	{
+ 		returnLod = ghoul2.currentModel->mdxm->numLODs - 1;
+ 	}
+
+	return returnLod;
+}
+
+#ifdef _XBOX
+// This is in tr_ghoul2 for various reasons.
+extern void R_TransformEachSurface( const mdxmSurface_t *surface, vec3_t scale, CMiniHeap *G2VertSpace, int *TransformedVertsArray,CBoneCache *boneCache);
+#else
+void R_TransformEachSurface( const mdxmSurface_t *surface, vec3_t scale, CMiniHeap *G2VertSpace, int *TransformedVertsArray,CBoneCache *boneCache) 
+{
+	int				 j, k;
+	mdxmVertex_t 	*v;
+	float			*TransformedVerts;
+
+	//
+	// deform the vertexes by the lerped bones
+	//
+	int *piBoneReferences = (int*) ((byte*)surface + surface->ofsBoneReferences);
+   
+	// alloc some space for the transformed verts to get put in
+	TransformedVerts = (float *)G2VertSpace->MiniHeapAlloc(surface->numVerts * 5 * 4);
+	TransformedVertsArray[surface->thisSurfaceIndex] = (int)TransformedVerts;
+	if (!TransformedVerts)
+	{
+		assert(TransformedVerts);
+		Com_Error(ERR_DROP, "Ran out of transform space for Ghoul2 Models. Adjust MiniHeapSize in SV_SpawnServer.\n");
+	}
+
+	// whip through and actually transform each vertex
+	const int numVerts = surface->numVerts;
+	v = (mdxmVertex_t *) ((byte *)surface + surface->ofsVerts);
+	mdxmVertexTexCoord_t *pTexCoords = (mdxmVertexTexCoord_t *) &v[numVerts];
+
+	// optimisation issue
+	if ((scale[0] != 1.0) || (scale[1] != 1.0) || (scale[2] != 1.0))
+	{
+		for ( j = 0; j < numVerts; j++ ) 
+		{
+			vec3_t			tempVert, tempNormal;
+//			mdxmWeight_t	*w;
+
+			VectorClear( tempVert );
+			VectorClear( tempNormal );
+//			w = v->weights;
+
+			const int iNumWeights = G2_GetVertWeights( v );
+
+			float fTotalWeight = 0.0f;
+			for ( k = 0 ; k < iNumWeights ; k++ ) 
+			{
+				int		iBoneIndex	= G2_GetVertBoneIndex( v, k );
+				float	fBoneWeight	= G2_GetVertBoneWeight( v, k, fTotalWeight, iNumWeights );
+
+				const mdxaBone_t &bone=EvalBoneCache(piBoneReferences[iBoneIndex],boneCache);
+
+				tempVert[0] += fBoneWeight * ( DotProduct( bone.matrix[0], v->vertCoords ) + bone.matrix[0][3] );
+				tempVert[1] += fBoneWeight * ( DotProduct( bone.matrix[1], v->vertCoords ) + bone.matrix[1][3] );
+				tempVert[2] += fBoneWeight * ( DotProduct( bone.matrix[2], v->vertCoords ) + bone.matrix[2][3] );
+
+				tempNormal[0] += fBoneWeight * DotProduct( bone.matrix[0], v->normal );
+				tempNormal[1] += fBoneWeight * DotProduct( bone.matrix[1], v->normal );
+				tempNormal[2] += fBoneWeight * DotProduct( bone.matrix[2], v->normal );
+			}
+			int pos = j * 5;
+
+			// copy tranformed verts into temp space
+			TransformedVerts[pos++] = tempVert[0] * scale[0];
+			TransformedVerts[pos++] = tempVert[1] * scale[1];
+			TransformedVerts[pos++] = tempVert[2] * scale[2];
+			// we will need the S & T coors too for hitlocation and hitmaterial stuff
+			TransformedVerts[pos++] = pTexCoords[j].texCoords[0];
+			TransformedVerts[pos] = pTexCoords[j].texCoords[1];
+
+			v++;// = (mdxmVertex_t *)&v->weights[/*v->numWeights*/surface->maxVertBoneWeights];
+		}
+	}
+	else
+	{
+		int pos = 0;
+	  	for ( j = 0; j < numVerts; j++ ) 
+		{
+			vec3_t			tempVert, tempNormal;
+//			const mdxmWeight_t	*w;
+
+			VectorClear( tempVert );
+			VectorClear( tempNormal );
+//			w = v->weights;
+
+			const int iNumWeights = G2_GetVertWeights( v );
+
+			float fTotalWeight = 0.0f;
+			for ( k = 0 ; k < iNumWeights ; k++ ) 
+			{
+				int		iBoneIndex	= G2_GetVertBoneIndex( v, k );
+				float	fBoneWeight	= G2_GetVertBoneWeight( v, k, fTotalWeight, iNumWeights );
+
+				const mdxaBone_t &bone=EvalBoneCache(piBoneReferences[iBoneIndex],boneCache);
+
+				tempVert[0] += fBoneWeight * ( DotProduct( bone.matrix[0], v->vertCoords ) + bone.matrix[0][3] );
+				tempVert[1] += fBoneWeight * ( DotProduct( bone.matrix[1], v->vertCoords ) + bone.matrix[1][3] );
+				tempVert[2] += fBoneWeight * ( DotProduct( bone.matrix[2], v->vertCoords ) + bone.matrix[2][3] );
+
+				tempNormal[0] += fBoneWeight * DotProduct( bone.matrix[0], v->normal );
+				tempNormal[1] += fBoneWeight * DotProduct( bone.matrix[1], v->normal );
+				tempNormal[2] += fBoneWeight * DotProduct( bone.matrix[2], v->normal );
+			}
+
+			// copy tranformed verts into temp space
+			TransformedVerts[pos++] = tempVert[0];
+			TransformedVerts[pos++] = tempVert[1];
+			TransformedVerts[pos++] = tempVert[2];
+			// we will need the S & T coors too for hitlocation and hitmaterial stuff
+			TransformedVerts[pos++] = pTexCoords[j].texCoords[0];
+			TransformedVerts[pos++] = pTexCoords[j].texCoords[1];
+
+			v++;// = (mdxmVertex_t *)&v->weights[/*v->numWeights*/surface->maxVertBoneWeights];
+		}
+	}
+}
+
+#endif
+
+void G2_TransformSurfaces(int surfaceNum, surfaceInfo_v &rootSList, 
+					CBoneCache *boneCache, const model_t *currentModel, int lod, vec3_t scale, CMiniHeap *G2VertSpace, int *TransformedVertArray, bool secondTimeAround)
+{
+	int	i;
+	assert(currentModel);
+	assert(currentModel->mdxm);
+	// back track and get the surfinfo struct for this surface
+	const mdxmSurface_t			*surface = (mdxmSurface_t *)G2_FindSurface(currentModel, surfaceNum, lod);
+	const mdxmHierarchyOffsets_t	*surfIndexes = (mdxmHierarchyOffsets_t *)((byte *)currentModel->mdxm + sizeof(mdxmHeader_t));
+	const mdxmSurfHierarchy_t		*surfInfo = (mdxmSurfHierarchy_t *)((byte *)surfIndexes + surfIndexes->offsets[surface->thisSurfaceIndex]);
+	
+	// see if we have an override surface in the surface list
+	const surfaceInfo_t	*surfOverride = G2_FindOverrideSurface(surfaceNum, rootSList);
+
+	// really, we should use the default flags for this surface unless it's been overriden
+	int offFlags = surfInfo->flags;
+
+  	if (surfOverride)
+	{
+		offFlags = surfOverride->offFlags;
+	}
+	// if this surface is not off, add it to the shader render list
+	if (!offFlags)
+	{
+
+		R_TransformEachSurface(surface, scale, G2VertSpace, TransformedVertArray, boneCache);
+	}
+
+	// if we are turning off all descendants, then stop this recursion now
+	if (offFlags & G2SURFACEFLAG_NODESCENDANTS)
+	{
+		return;
+	}
+
+	// now recursively call for the children
+	for (i=0; i< surfInfo->numChildren; i++)
+	{
+		G2_TransformSurfaces(surfInfo->childIndexes[i], rootSList, boneCache, currentModel, lod, scale, G2VertSpace, TransformedVertArray, secondTimeAround);
+	}
+}
+
+// main calling point for the model transform for collision detection. At this point all of the skeleton has been transformed.
+#ifdef _G2_GORE
+void G2_TransformModel(CGhoul2Info_v &ghoul2, const int frameNum, vec3_t scale, CMiniHeap *G2VertSpace, int useLod, bool ApplyGore)
+#else
+void G2_TransformModel(CGhoul2Info_v &ghoul2, const int frameNum, vec3_t scale, CMiniHeap *G2VertSpace, int useLod)
+#endif
+{
+	int				i, lod;
+	vec3_t			correctScale;
+
+
+	VectorCopy(scale, correctScale);
+	// check for scales of 0 - that's the default I believe
+	if (!scale[0])
+	{
+		correctScale[0] = 1.0;
+	}
+	if (!scale[1])
+	{
+		correctScale[1] = 1.0;
+	}
+	if (!scale[2])
+	{
+		correctScale[2] = 1.0;
+	}
+
+	// walk each possible model for this entity and try rendering it out
+	for (i=0; i<ghoul2.size(); i++)
+	{
+		CGhoul2Info &g=ghoul2[i];
+		// don't bother with models that we don't care about.
+		if (!g.mValid)
+		{
+			continue;
+		}
+		assert(g.mBoneCache);
+		assert(G2_MODEL_OK(&g));
+		// stop us building this model more than once per frame
+		g.mMeshFrameNum = frameNum;
+
+		// decide the LOD
+#ifdef _G2_GORE
+		if (ApplyGore)
+		{
+			lod=useLod;
+			assert(g.currentModel);
+			if (lod>=g.currentModel->numLods)
+			{
+				g.mTransformedVertsArray = 0;
+				return;
+			}
+		}
+		else
+#endif
+		{
+			lod = G2_DecideTraceLod(g, useLod);
+		}
+
+		// give us space for the transformed vertex array to be put in
+		g.mTransformedVertsArray = (int*)G2VertSpace->MiniHeapAlloc(g.currentModel->mdxm->numSurfaces * 4);
+		if (!g.mTransformedVertsArray)
+		{
+			Com_Error(ERR_DROP, "Ran out of transform space for Ghoul2 Models. Adjust MiniHeapSize in SV_SpawnServer.\n");
+		}
+
+		memset(g.mTransformedVertsArray, 0,(g.currentModel->mdxm->numSurfaces * 4)); 
+
+		G2_FindOverrideSurface(-1,g.mSlist); //reset the quick surface override lookup;
+		// recursively call the model surface transform
+		G2_TransformSurfaces(g.mSurfaceRoot, g.mSlist, g.mBoneCache,  g.currentModel, lod, correctScale, G2VertSpace, g.mTransformedVertsArray, false);
+
+#ifdef _G2_GORE
+		if (ApplyGore&&!AddGoreToAllModels)
+		{
+			// we don't really need to do multiple models for gore.
+			break;
+		}
+#endif
+	}
+}
+
+
+// work out how much space a triangle takes
+static float	G2_AreaOfTri(const vec3_t A, const vec3_t B, const vec3_t C)
+{
+	vec3_t	cross, ab, cb;
+	VectorSubtract(A, B, ab);
+	VectorSubtract(C, B, cb);
+
+	CrossProduct(ab, cb, cross);
+
+	return VectorLength(cross);
+}
+
+// actually determine the S and T of the coordinate we hit in a given poly
+static void G2_BuildHitPointST( const vec3_t A, const float SA, const float TA,
+						 const vec3_t B, const float SB, const float TB,
+						 const vec3_t C, const float SC, const float TC,
+						 const vec3_t P, float *s, float *t,float &bary_i,float &bary_j)
+{
+	float	areaABC = G2_AreaOfTri(A, B, C);
+
+	float i = G2_AreaOfTri(P, B, C) / areaABC;
+	bary_i=i;
+	float j = G2_AreaOfTri(A, P, C) / areaABC;
+	bary_j=j;
+	float k = G2_AreaOfTri(A, B, P) / areaABC;
+
+	*s = SA * i + SB * j + SC * k;
+	*t = TA * i + TB * j + TC * k;
+
+	*s=fmod(*s, 1);
+	if (*s< 0)
+	{
+		*s+= 1.0;
+	}
+
+	*t=fmod(*t, 1);
+	if (*t< 0)
+	{
+		*t+= 1.0;
+	}
+
+}
+
+
+// routine that works out given a ray whether or not it hits a poly
+static inline qboolean G2_SegmentTriangleTest( const vec3_t start, const vec3_t end,
+	const vec3_t A, const vec3_t B, const vec3_t C,
+	qboolean backFaces,qboolean frontFaces,vec3_t returnedPoint,vec3_t returnedNormal, float *denom)
+{
+	static const float tiny=1E-10f;
+	vec3_t returnedNormalT;
+	vec3_t edgeAC;
+
+	VectorSubtract(C, A, edgeAC);
+	VectorSubtract(B, A, returnedNormalT); 
+
+	CrossProduct(returnedNormalT, edgeAC, returnedNormal);
+	
+	vec3_t ray;
+	VectorSubtract(end, start, ray);
+
+	*denom=DotProduct(ray, returnedNormal);
+	
+	if (Q_fabs(*denom)<tiny||        // triangle parallel to ray
+		(!backFaces && *denom>0)||		// not accepting back faces
+		(!frontFaces && *denom<0))		//not accepting front faces
+	{
+		return qfalse;
+	}
+
+	vec3_t toPlane;
+	VectorSubtract(A, start, toPlane);
+	
+	float t=DotProduct(toPlane, returnedNormal)/ *denom;
+	
+	if (t<0.0f||t>1.0f)
+	{
+		return qfalse; // off segment
+	}
+	
+	VectorScale(ray, t, ray);
+	
+	VectorAdd(ray, start, returnedPoint);
+
+	vec3_t edgePA;
+	VectorSubtract(A, returnedPoint, edgePA);
+
+	vec3_t edgePB;
+	VectorSubtract(B, returnedPoint, edgePB);
+
+	vec3_t edgePC;
+	VectorSubtract(C, returnedPoint, edgePC);
+	
+	vec3_t temp;
+	
+	CrossProduct(edgePA, edgePB, temp);
+	if (DotProduct(temp, returnedNormal)<0.0f)
+	{
+		return qfalse; // off triangle
+	}
+
+	CrossProduct(edgePC, edgePA, temp);
+	if (DotProduct(temp,returnedNormal)<0.0f)
+	{
+		return qfalse; // off triangle
+	}
+	
+	CrossProduct(edgePB, edgePC, temp);
+	if (DotProduct(temp, returnedNormal)<0.0f)
+	{
+		return qfalse; // off triangle
+	}	
+	return qtrue;
+}
+
+#ifdef _G2_GORE
+struct SVertexTemp
+{
+	int flags;
+	int touch;
+	int newindex;
+	float tex[2];
+	SVertexTemp()
+	{
+		touch=0;
+	}
+};
+
+#define MAX_GORE_VERTS (3000)
+static SVertexTemp GoreVerts[MAX_GORE_VERTS];
+static int GoreIndexCopy[MAX_GORE_VERTS];
+static int GoreTouch=1;
+
+#define MAX_GORE_INDECIES (6000)
+static int GoreIndecies[MAX_GORE_INDECIES];
+
+#define GORE_MARGIN (0.0f)
+int	G2API_GetTime(int argTime);
+
+// now we at poly level, check each model space transformed poly against the model world transfomed ray
+static void G2_GorePolys( const mdxmSurface_t *surface, CTraceSurface &TS, const mdxmSurfHierarchy_t *surfInfo)
+{ 
+	int			j;
+	vec3_t basis1;
+	vec3_t basis2;
+	vec3_t taxis;
+	vec3_t saxis;
+
+	if (!TS.gore)
+	{
+		return;
+	}
+
+	if (!TS.gore->useTheta)
+	{
+		VectorCopy(TS.gore->uaxis,basis2);
+		CrossProduct(TS.rayEnd,basis2,basis1);
+		if (DotProduct(basis1,basis1)<0.005f)
+		{	//shot dir and slash dir are too close
+			return;
+		}
+	}
+
+	if (TS.gore->useTheta)
+	{
+		basis2[0]=0.0f;
+		basis2[1]=0.0f;
+		basis2[2]=1.0f;
+
+		CrossProduct(TS.rayEnd,basis2,basis1);
+
+		if (DotProduct(basis1,basis1)<.1f)
+		{
+			basis2[0]=0.0f;
+			basis2[1]=1.0f;
+			basis2[2]=0.0f;
+			CrossProduct(TS.rayEnd,basis2,basis1);
+		}
+		CrossProduct(TS.rayEnd,basis1,basis2);
+	}
+
+	// Give me a shot direction not a bunch of zeros :) -Gil
+	assert(DotProduct(basis1,basis1)>.0001f);
+	assert(DotProduct(basis2,basis2)>.0001f);
+
+	VectorNormalize(basis1);
+	VectorNormalize(basis2);
+
+	float c=cos(TS.theta);
+	float s=sin(TS.theta);
+
+	VectorScale(basis1,.5f*c/TS.tsize,taxis);
+	VectorMA(taxis,.5f*s/TS.tsize,basis2,taxis);
+
+	VectorScale(basis1,-.5f*s/TS.ssize,saxis);
+	VectorMA(saxis,.5f*c/TS.ssize,basis2,saxis);
+
+	//fixme, everything above here should be pre-calculated in G2API_AddSkinGore
+	float *verts = (float *)TS.TransformedVertsArray[surface->thisSurfaceIndex];
+	int numVerts = surface->numVerts;
+	int flags=63;
+	assert(numVerts<MAX_GORE_VERTS);
+	for ( j = 0; j < numVerts; j++ ) 
+	{
+		int pos=j*5;
+		vec3_t delta;
+		delta[0]=verts[pos+0]-TS.rayStart[0];
+		delta[1]=verts[pos+1]-TS.rayStart[1];
+		delta[2]=verts[pos+2]-TS.rayStart[2];
+		float s=DotProduct(delta,saxis)+0.5f;
+		float t=DotProduct(delta,taxis)+0.5f;
+		float depth = DotProduct(delta,TS.rayEnd);
+		int vflags=0;
+		if (s>GORE_MARGIN)
+		{
+			vflags|=1;
+		}
+		if (s<1.0f-GORE_MARGIN)
+		{
+			vflags|=2;
+		}
+		if (t>GORE_MARGIN)
+		{
+			vflags|=4;
+		}
+		if (t<1.0f-GORE_MARGIN)
+		{
+			vflags|=8;
+		}
+		if (depth > TS.gore->depthStart)
+		{
+			vflags|=16;
+		}
+		if (depth < TS.gore->depthEnd)
+		{
+			vflags|=32;
+		}
+		vflags=(~vflags);
+		flags&=vflags;
+		GoreVerts[j].flags=vflags;
+		GoreVerts[j].tex[0]=s;
+		GoreVerts[j].tex[1]=t;
+	}
+	if (flags)
+	{
+		return; // completely off the gore splotch.
+	}
+	int				numTris,newNumTris,newNumVerts;
+	numTris = surface->numTriangles;
+	mdxmTriangle_t	*tris;
+	tris = (mdxmTriangle_t *) ((byte *)surface + surface->ofsTriangles);
+	verts = (float *)TS.TransformedVertsArray[surface->thisSurfaceIndex];
+	newNumTris=0;
+	newNumVerts=0;
+	GoreTouch++;
+	for ( j = 0; j < numTris; j++ ) 
+	{
+		assert(tris[j].indexes[0]>=0&&tris[j].indexes[0]<numVerts);
+		assert(tris[j].indexes[1]>=0&&tris[j].indexes[1]<numVerts);
+		assert(tris[j].indexes[2]>=0&&tris[j].indexes[2]<numVerts);
+		flags=63&
+			GoreVerts[tris[j].indexes[0]].flags&
+			GoreVerts[tris[j].indexes[1]].flags&
+			GoreVerts[tris[j].indexes[2]].flags;
+		if (flags)
+		{
+			continue;
+		}
+		if (!TS.gore->frontFaces || !TS.gore->backFaces)
+		{
+			// we need to back/front face cull
+			vec3_t e1,e2,n;
+
+			VectorSubtract(&verts[tris[j].indexes[1]*5],&verts[tris[j].indexes[0]*5],e1);
+			VectorSubtract(&verts[tris[j].indexes[2]*5],&verts[tris[j].indexes[0]*5],e2);
+			CrossProduct(e1,e2,n);
+			if (DotProduct(TS.rayEnd,n)>0.0f)
+			{
+				if (!TS.gore->frontFaces)
+				{
+					continue;
+				}
+			}
+			else
+			{
+				if (!TS.gore->backFaces)
+				{
+					continue;
+				}
+			}
+
+		}
+
+		int k;
+
+		assert(newNumTris*3+3<MAX_GORE_INDECIES);
+		for (k=0;k<3;k++)
+		{
+			if (GoreVerts[tris[j].indexes[k]].touch==GoreTouch)
+			{
+				GoreIndecies[newNumTris*3+k]=GoreVerts[tris[j].indexes[k]].newindex;
+			}
+			else
+			{
+				GoreVerts[tris[j].indexes[k]].touch=GoreTouch;
+				GoreVerts[tris[j].indexes[k]].newindex=newNumVerts;
+				GoreIndecies[newNumTris*3+k]=newNumVerts;
+				GoreIndexCopy[newNumVerts]=tris[j].indexes[k];
+				newNumVerts++;
+			}
+		}
+		newNumTris++;
+	}
+	if (!newNumVerts)
+	{
+		return;
+	}
+
+	int newTag;
+	map<pair<int,int>,int>::iterator f=GoreTagsTemp.find(pair<int,int>(goreModelIndex,TS.surfaceNum));
+	if (f==GoreTagsTemp.end()) // need to generate a record
+	{
+		newTag=AllocGoreRecord();
+		CGoreSet *goreSet=0;
+		if (TS.ghoul2info->mGoreSetTag)
+		{
+			goreSet=FindGoreSet(TS.ghoul2info->mGoreSetTag);
+		}
+		if (!goreSet)
+		{
+			goreSet=NewGoreSet();
+			TS.ghoul2info->mGoreSetTag=goreSet->mMyGoreSetTag;
+		}
+		assert(goreSet);
+		SGoreSurface add;
+		add.shader=TS.goreShader;
+		add.mDeleteTime=0;
+		if (TS.gore->lifeTime)
+		{
+			add.mDeleteTime=G2API_GetTime(0) + TS.gore->lifeTime;
+		}
+		add.mFadeTime = TS.gore->fadeOutTime;
+		add.mFadeRGB = TS.gore->fadeRGB;
+		add.mGoreTag = newTag;
+
+		add.mGoreGrowStartTime=G2API_GetTime(0);
+		if( TS.gore->growDuration == -1)
+		{
+			add.mGoreGrowEndTime = -1;    // set this to -1 to disable growing
+		}
+		else
+		{
+			add.mGoreGrowEndTime = G2API_GetTime(0) + TS.gore->growDuration;
+		}
+
+		assert(TS.gore->growDuration != 0);
+		add.mGoreGrowFactor = ( 1.0f - TS.gore->goreScaleStartFraction) / (float)(TS.gore->growDuration);	//curscale = (curtime-mGoreGrowStartTime)*mGoreGrowFactor;
+		add.mGoreGrowOffset = TS.gore->goreScaleStartFraction;	
+
+		goreSet->mGoreRecords.insert(pair<int,SGoreSurface>(TS.surfaceNum,add));
+		GoreTagsTemp[pair<int,int>(goreModelIndex,TS.surfaceNum)]=newTag;
+	}
+	else
+	{
+		newTag=(*f).second;
+	}
+	GoreTextureCoordinates *gore=FindGoreRecord(newTag);
+	if (gore)
+	{
+		assert(sizeof(float)==sizeof(int));
+		// data block format:
+		unsigned int size=
+			sizeof(int)+ // num verts
+			sizeof(int)+ // num tris
+			sizeof(int)*newNumVerts+ // which verts to copy from original surface
+			sizeof(float)*4*newNumVerts+ // storgage for deformed verts
+			sizeof(float)*4*newNumVerts+ // storgage for deformed normal
+			sizeof(float)*2*newNumVerts+ // texture coordinates
+			sizeof(int)*newNumTris*3;  // new indecies
+		
+		int *data=(int *)Z_Malloc ( sizeof(int)*size, TAG_GHOUL2, qtrue );
+
+		if ( gore->tex[TS.lod] )
+			Z_Free(gore->tex[TS.lod]);
+
+		gore->tex[TS.lod]=(float *)data;
+		*data++=newNumVerts;
+		*data++=newNumTris;
+
+		memcpy(data,GoreIndexCopy,sizeof(int)*newNumVerts);
+		data+=newNumVerts*9; // skip verts and normals
+		float *fdata=(float *)data;
+
+		for (j=0;j<newNumVerts;j++)
+		{
+			*fdata++=GoreVerts[GoreIndexCopy[j]].tex[0];
+			*fdata++=GoreVerts[GoreIndexCopy[j]].tex[1];
+		}
+		data=(int *)fdata;
+		memcpy(data,GoreIndecies,sizeof(int)*newNumTris*3);
+		data+=newNumTris*3;
+		assert((data-(int *)gore->tex[TS.lod])*sizeof(int)==size);
+		fdata = (float *)data;
+		// build the entity to gore matrix
+		VectorCopy(saxis,fdata+0);
+		VectorCopy(taxis,fdata+4);
+		VectorCopy(TS.rayEnd,fdata+8);
+		VectorNormalize(fdata+0);
+		VectorNormalize(fdata+4);
+		VectorNormalize(fdata+8);
+		fdata[3]=-0.5f; // subtract texture center
+		fdata[7]=-0.5f;
+		fdata[11]=0.0f;
+		vec3_t shotOriginInCurrentSpace; // unknown space
+		TransformPoint(TS.rayStart,shotOriginInCurrentSpace,(mdxaBone_t *)fdata); // dest middle arg
+		// this will insure the shot origin in our unknown space is now the shot origin, making it a known space
+		fdata[3]-=shotOriginInCurrentSpace[0];
+		fdata[7]-=shotOriginInCurrentSpace[1];
+		fdata[11]-=shotOriginInCurrentSpace[2];
+		Inverse_Matrix((mdxaBone_t *)fdata,(mdxaBone_t *)(fdata+12));  // dest 2nd arg
+		data+=24;
+
+//		assert((data - (int *)gore->tex[TS.lod]) * sizeof(int) == size);
+	}
+}
+#else
+struct SVertexTemp
+{
+	int flags;
+//	int touch;
+//	int newindex;
+//	float tex[2];
+	SVertexTemp()
+	{
+//		touch=0;
+	}
+};
+
+#define MAX_GORE_VERTS (3000)
+static SVertexTemp GoreVerts[MAX_GORE_VERTS];
+#endif
+
+// now we're at poly level, check each model space transformed poly against the model world transfomed ray
+static bool G2_TracePolys(const mdxmSurface_t *surface, const mdxmSurfHierarchy_t *surfInfo, CTraceSurface &TS)
+{
+	int				j, numTris;
+	
+	// whip through and actually transform each vertex
+	const mdxmTriangle_t *tris = (mdxmTriangle_t *) ((byte *)surface + surface->ofsTriangles);
+	const float *verts = (float *)TS.TransformedVertsArray[surface->thisSurfaceIndex];
+	numTris = surface->numTriangles;
+	for ( j = 0; j < numTris; j++ ) 
+	{
+		float			face;
+		vec3_t	hitPoint, normal;
+		// determine actual coords for this triangle
+		const float *point1 = &verts[(tris[j].indexes[0] * 5)];
+		const float *point2 = &verts[(tris[j].indexes[1] * 5)];
+		const float *point3 = &verts[(tris[j].indexes[2] * 5)];
+		// did we hit it?
+		if (G2_SegmentTriangleTest(TS.rayStart, TS.rayEnd, point1, point2, point3, qtrue, qtrue, hitPoint, normal, &face))
+		{	// find space in the collision records for this record
+			for (int i=0; i<MAX_G2_COLLISIONS;i++)
+			{
+				if (TS.collRecMap[i].mEntityNum == -1)
+				{
+					CCollisionRecord  	&newCol = TS.collRecMap[i];
+					vec3_t			  	distVect;
+					float				x_pos = 0, y_pos = 0;
+					
+					newCol.mPolyIndex = j;
+					newCol.mEntityNum = TS.entNum;
+					newCol.mSurfaceIndex = surface->thisSurfaceIndex;
+					newCol.mModelIndex = TS.modelIndex;
+					if (face>0)
+					{
+						newCol.mFlags = G2_FRONTFACE;
+					}
+					else
+					{
+						newCol.mFlags = G2_BACKFACE;
+					}
+
+					VectorSubtract(hitPoint, TS.rayStart, distVect);
+					newCol.mDistance = VectorLength(distVect);
+					assert( !_isnan(newCol.mDistance) );
+
+					// put the hit point back into world space
+					TransformAndTranslatePoint(hitPoint, newCol.mCollisionPosition, &worldMatrix);
+
+					// transform normal (but don't translate) into world angles
+					TransformPoint(normal, newCol.mCollisionNormal, &worldMatrix);
+					VectorNormalize(newCol.mCollisionNormal);
+
+					newCol.mMaterial = newCol.mLocation = 0;
+
+					// Determine our location within the texture, and barycentric coordinates
+					G2_BuildHitPointST(point1, point1[3], point1[4],
+									   point2, point2[3], point2[4],
+									   point3, point3[3], point3[4],
+									   hitPoint, &x_pos, &y_pos,newCol.mBarycentricI,newCol.mBarycentricJ); 
+									
+/*
+					const shader_t		*shader = 0;
+					// now, we know what surface this hit belongs to, we need to go get the shader handle so we can get the correct hit location and hit material info
+					if ( cust_shader ) 
+					{
+						shader = cust_shader;
+					} 
+					else if ( skin ) 
+					{
+						int		j;
+							
+						// match the surface name to something in the skin file
+						shader = tr.defaultShader;
+						for ( j = 0 ; j < skin->numSurfaces ; j++ )
+						{
+							// the names have both been lowercased
+							if ( !strcmp( skin->surfaces[j]->name, surfInfo->name ) ) 
+							{
+								shader = skin->surfaces[j]->shader;
+								break;
+							}
+						}
+					} 
+					else 
+					{
+						shader = R_GetShaderByHandle( surfInfo->shaderIndex );
+					}
+
+					// do we even care to decide what the hit or location area's are? If we don't have them in the shader there is little point
+					if ((shader->hitLocation) || (shader->hitMaterial))
+					{
+ 						// ok, we have a floating point position. - determine location in data we need to look at
+						if (shader->hitLocation)
+						{
+							newCol.mLocation = *(hitMatReg[shader->hitLocation].loc +
+												((int)(y_pos * hitMatReg[shader->hitLocation].height) * hitMatReg[shader->hitLocation].width) +
+												((int)(x_pos * hitMatReg[shader->hitLocation].width)));
+							Com_Printf("G2_TracePolys hit location: %d\n", newCol.mLocation); 
+						}
+
+						if (shader->hitMaterial)
+						{
+							newCol.mMaterial = *(hitMatReg[shader->hitMaterial].loc +
+												((int)(y_pos * hitMatReg[shader->hitMaterial].height) * hitMatReg[shader->hitMaterial].width) +
+												((int)(x_pos * hitMatReg[shader->hitMaterial].width)));
+						}
+					}
+*/
+					// exit now if we should
+					if (TS.eG2TraceType == G2_RETURNONHIT)
+					{
+						TS.hitOne = true;
+						return true;
+					}
+
+					break;
+				}
+			}
+			if (i==MAX_G2_COLLISIONS)
+			{
+				assert(i!=MAX_G2_COLLISIONS);		// run out of collision record space - will probalbly never happen
+				TS.hitOne = true;	//force stop recursion
+				return true;	// return true to avoid wasting further time, but no hit will result without a record
+			}
+		}
+	}
+	return false;
+}
+
+
+// now we're at poly level, check each model space transformed poly against the model world transfomed ray
+static bool G2_RadiusTracePolys(
+								const mdxmSurface_t *surface, 
+								CTraceSurface &TS
+								)
+{
+	int		j;
+	vec3_t basis1;
+	vec3_t basis2;
+	vec3_t taxis;
+	vec3_t saxis;
+
+	basis2[0]=0.0f;
+	basis2[1]=0.0f;
+	basis2[2]=1.0f;
+
+	vec3_t v3RayDir;
+	VectorSubtract(TS.rayEnd, TS.rayStart, v3RayDir);
+
+	CrossProduct(v3RayDir,basis2,basis1);
+
+	if (DotProduct(basis1,basis1)<.1f)
+	{
+		basis2[0]=0.0f;
+		basis2[1]=1.0f;
+		basis2[2]=0.0f;
+		CrossProduct(v3RayDir,basis2,basis1);
+	}
+
+	CrossProduct(v3RayDir,basis1,basis2);
+	// Give me a shot direction not a bunch of zeros :) -Gil
+//	assert(DotProduct(basis1,basis1)>.0001f);
+//	assert(DotProduct(basis2,basis2)>.0001f);
+
+	VectorNormalize(basis1);
+	VectorNormalize(basis2);
+
+	const float c=cos(0.0f);//theta
+	const float s=sin(0.0f);//theta
+
+	VectorScale(basis1, 0.5f * c / TS.m_fRadius,taxis);
+	VectorMA(taxis,     0.5f * s / TS.m_fRadius,basis2,taxis);
+
+	VectorScale(basis1,-0.5f * s /TS.m_fRadius,saxis);
+	VectorMA(    saxis, 0.5f * c /TS.m_fRadius,basis2,saxis);
+
+	const float * const verts = (float *)TS.TransformedVertsArray[surface->thisSurfaceIndex];
+	const int numVerts = surface->numVerts;
+	
+	int flags=63;
+	//rayDir/=lengthSquared(raydir);
+	const float f = VectorLengthSquared(v3RayDir); 
+	v3RayDir[0]/=f;
+	v3RayDir[1]/=f;
+	v3RayDir[2]/=f;
+
+	for ( j = 0; j < numVerts; j++ ) 
+	{
+		const int pos=j*5;
+		vec3_t delta;
+		delta[0]=verts[pos+0]-TS.rayStart[0];
+		delta[1]=verts[pos+1]-TS.rayStart[1];
+		delta[2]=verts[pos+2]-TS.rayStart[2];
+		const float s=DotProduct(delta,saxis)+0.5f;
+		const float t=DotProduct(delta,taxis)+0.5f;
+		const float u=DotProduct(delta,v3RayDir);
+		int vflags=0;
+
+		if (s>0)
+		{
+			vflags|=1;
+		}
+		if (s<1)
+		{
+			vflags|=2;
+		}
+		if (t>0)
+		{
+			vflags|=4;
+		}
+		if (t<1)
+		{
+			vflags|=8;
+		}
+		if (u>0)
+		{
+			vflags|=16;
+		}
+		if (u<1)
+		{
+			vflags|=32;
+		}
+
+		vflags=(~vflags);
+		flags&=vflags;
+		GoreVerts[j].flags=vflags;
+	}
+
+	if (flags)
+	{
+		return false; // completely off the gore splotch  (so presumably hit nothing? -Ste)
+	}
+	const int numTris = surface->numTriangles;
+	const mdxmTriangle_t * const tris = (mdxmTriangle_t *) ((byte *)surface + surface->ofsTriangles);
+
+	for ( j = 0; j < numTris; j++ ) 
+	{
+		assert(tris[j].indexes[0]>=0&&tris[j].indexes[0]<numVerts);
+		assert(tris[j].indexes[1]>=0&&tris[j].indexes[1]<numVerts);
+		assert(tris[j].indexes[2]>=0&&tris[j].indexes[2]<numVerts);
+		flags=63&
+			GoreVerts[tris[j].indexes[0]].flags&
+			GoreVerts[tris[j].indexes[1]].flags&
+			GoreVerts[tris[j].indexes[2]].flags;
+		if (flags)
+		{
+			continue;
+		}
+		else
+		{
+			// we hit a triangle, so init a collision record...
+			//
+			for (int i=0; i<MAX_G2_COLLISIONS;i++)
+			{
+				if (TS.collRecMap[i].mEntityNum == -1)
+				{
+					CCollisionRecord  	&newCol = TS.collRecMap[i];
+					
+					newCol.mPolyIndex = j;
+					newCol.mEntityNum = TS.entNum;
+					newCol.mSurfaceIndex = surface->thisSurfaceIndex;
+					newCol.mModelIndex = TS.modelIndex;
+//					if (face>0)
+//					{
+						newCol.mFlags = G2_FRONTFACE;
+//					}
+//					else
+//					{
+//						newCol.mFlags = G2_BACKFACE;
+//					}
+
+					//get normal from triangle				
+					const float *A = &verts[(tris[j].indexes[0] * 5)];
+					const float *B = &verts[(tris[j].indexes[1] * 5)];
+					const float *C = &verts[(tris[j].indexes[2] * 5)];
+					vec3_t normal;
+					vec3_t edgeAC, edgeBA;
+
+					VectorSubtract(C, A, edgeAC);
+					VectorSubtract(B, A, edgeBA);
+					CrossProduct(edgeBA, edgeAC, normal);
+
+					// transform normal (but don't translate) into world angles
+					TransformPoint(normal, newCol.mCollisionNormal, &worldMatrix);
+					VectorNormalize(newCol.mCollisionNormal);
+
+					newCol.mMaterial = newCol.mLocation = 0;
+					// exit now if we should
+					if (TS.eG2TraceType == G2_RETURNONHIT)
+					{
+						TS.hitOne = true;
+						return true;
+					}
+
+					vec3_t			  distVect;
+#if 0
+					//i don't know the hitPoint, but let's just assume it's the first vert for now...
+					float *hitPoint = (float *)A;
+#else
+					//yeah, I want the collision point. Let's work out the impact point on the triangle. -rww
+					vec3_t hitPoint;
+					float side, side2;
+					float dist;
+					float third = -(A[0]*(B[1]*C[2] - C[1]*B[2]) + B[0]*(C[1]*A[2] - A[1]*C[2]) + C[0]*(A[1]*B[2] - B[1]*A[2]) );
+
+					VectorSubtract(TS.rayEnd, TS.rayStart, distVect);
+					side = normal[0]*TS.rayStart[0] + normal[1]*TS.rayStart[1] + normal[2]*TS.rayStart[2] + third;
+                    side2 = normal[0]*distVect[0] + normal[1]*distVect[1] + normal[2]*distVect[2];
+					if (fabsf(side2)<1E-8f)
+					{
+						//i don't know the hitPoint, but let's just assume it's the first vert for now...
+						VectorSubtract(A, TS.rayStart, distVect);
+						dist = VectorLength(distVect);
+						VectorSubtract(TS.rayEnd, TS.rayStart, distVect);
+						VectorMA(TS.rayStart, dist/VectorLength(distVect), distVect, hitPoint);
+					}
+					else
+					{
+						dist = side/side2;
+						VectorMA(TS.rayStart, -dist, distVect, hitPoint);
+					}
+#endif
+
+					VectorSubtract(hitPoint, TS.rayStart, distVect);
+					newCol.mDistance = VectorLength(distVect);
+					assert( !_isnan(newCol.mDistance) );
+
+					// put the hit point back into world space
+					TransformAndTranslatePoint(hitPoint, newCol.mCollisionPosition, &worldMatrix);
+					newCol.mBarycentricI = newCol.mBarycentricJ = 0.0f;
+
+					break;
+				}
+			}
+			if (i==MAX_G2_COLLISIONS)
+			{
+				//assert(i!=MAX_G2_COLLISIONS);		// run out of collision record space - happens OFTEN
+				TS.hitOne = true;	//force stop recursion
+				return true;	// return true to avoid wasting further time, but no hit will result without a record
+			}
+		}
+	}
+
+	return false;
+}
+
+
+// look at a surface and then do the trace on each poly
+static void G2_TraceSurfaces(CTraceSurface &TS)
+{
+	int	i;
+	// back track and get the surfinfo struct for this surface
+	assert(TS.currentModel);
+	assert(TS.currentModel->mdxm);
+	const mdxmSurface_t		*surface = (mdxmSurface_t *)G2_FindSurface(TS.currentModel, TS.surfaceNum, TS.lod);
+	const mdxmHierarchyOffsets_t	*surfIndexes = (mdxmHierarchyOffsets_t *)((byte *)TS.currentModel->mdxm + sizeof(mdxmHeader_t));
+	const mdxmSurfHierarchy_t		*surfInfo = (mdxmSurfHierarchy_t *)((byte *)surfIndexes + surfIndexes->offsets[surface->thisSurfaceIndex]);
+	
+	// see if we have an override surface in the surface list
+	const surfaceInfo_t	*surfOverride = G2_FindOverrideSurface(TS.surfaceNum, TS.rootSList);
+
+	// don't allow recursion if we've already hit a polygon
+	if (TS.hitOne)
+	{
+		return;
+	}
+
+	// really, we should use the default flags for this surface unless it's been overriden
+	int offFlags = surfInfo->flags;
+
+	// set the off flags if we have some
+	if (surfOverride)
+	{
+		offFlags = surfOverride->offFlags;
+	}
+
+	// if this surface is not off, try to hit it
+	if (!offFlags)
+	{
+#ifdef _G2_GORE
+		if (TS.collRecMap)
+		{
+#endif
+			if (!(Q_fabs(TS.m_fRadius) < 0.1))	// if not a point-trace
+			{
+				// .. then use radius check
+				//
+				if (G2_RadiusTracePolys(surface,		// const mdxmSurface_t *surface, 
+										TS
+										)
+					&& (TS.eG2TraceType == G2_RETURNONHIT)
+					)
+				{
+					TS.hitOne = true;
+					return;
+				}
+			}
+			else
+			{
+				// go away and trace the polys in this surface
+				if (G2_TracePolys(surface, surfInfo, TS)
+					&& (TS.eG2TraceType == G2_RETURNONHIT)
+					)
+				{
+					// ok, we hit one, *and* we want to return instantly because the returnOnHit is set
+					// so indicate we've hit one, so other surfaces don't get hit and return
+					TS.hitOne = true;
+					return;
+				}
+			}
+#ifdef _G2_GORE
+		}
+		else
+		{
+			G2_GorePolys(surface, TS, surfInfo);
+		}
+#endif
+	}
+
+	// if we are turning off all descendants, then stop this recursion now
+	if (offFlags & G2SURFACEFLAG_NODESCENDANTS)
+	{
+		return;
+	}
+
+	// now recursively call for the children
+	for (i=0; i< surfInfo->numChildren && !TS.hitOne; i++)
+	{
+		TS.surfaceNum = surfInfo->childIndexes[i];
+		G2_TraceSurfaces(TS);
+	}
+}
+
+#ifdef _G2_GORE
+void G2_TraceModels(CGhoul2Info_v &ghoul2, vec3_t rayStart, vec3_t rayEnd, CCollisionRecord *collRecMap, int entNum, EG2_Collision eG2TraceType, int useLod, float fRadius, float ssize,float tsize,float theta,int shader, SSkinGoreData *gore)
+#else
+void G2_TraceModels(CGhoul2Info_v &ghoul2, vec3_t rayStart, vec3_t rayEnd, CCollisionRecord *collRecMap, int entNum, EG2_Collision eG2TraceType, int useLod, float fRadius)
+#endif
+{
+	int				i, lod;
+	skin_t			*skin;
+	shader_t		*cust_shader;
+
+	// walk each possible model for this entity and try tracing against it
+	for (i=0; i<ghoul2.size(); i++)
+	{
+		CGhoul2Info &g=ghoul2[i];
+#ifdef _G2_GORE
+		goreModelIndex=i;
+		// don't bother with models that we don't care about.
+		if (g.mModelindex == -1)
+		{
+			continue;
+		}
+#endif
+		// don't bother with models that we don't care about.
+		if (!g.mValid)
+		{
+			continue;
+		}
+		assert(G2_MODEL_OK(&ghoul2[i]));
+		// do we really want to collide with this object?
+		if (g.mFlags & GHOUL2_NOCOLLIDE) 
+		{
+			continue;
+		}
+		
+		if (g.mCustomShader)
+		{
+			cust_shader = R_GetShaderByHandle(g.mCustomShader );
+		}
+		else
+		{
+			cust_shader = NULL;
+		}
+
+		// figure out the custom skin thing
+		if ( g.mSkin > 0 && g.mSkin < tr.numSkins ) 
+		{
+			skin = R_GetSkinByHandle( g.mSkin );
+		}
+		else
+		{
+			skin = NULL;
+		}
+
+		lod = G2_DecideTraceLod(g,useLod);
+
+		//reset the quick surface override lookup
+		G2_FindOverrideSurface(-1, g.mSlist); 
+
+#ifdef _G2_GORE
+		CTraceSurface TS(g.mSurfaceRoot, g.mSlist,  g.currentModel, lod, rayStart, rayEnd, collRecMap, entNum, i, skin, cust_shader, g.mTransformedVertsArray, eG2TraceType, fRadius, ssize, tsize, theta, shader, &g, gore);
+#else
+		CTraceSurface TS(g.mSurfaceRoot, g.mSlist,  g.currentModel, lod, rayStart, rayEnd, collRecMap, entNum, i, skin, cust_shader, g.mTransformedVertsArray, eG2TraceType, fRadius);
+#endif
+		// start the surface recursion loop
+		G2_TraceSurfaces(TS);
+
+		// if we've hit one surface on one model, don't bother doing the rest
+		if (TS.hitOne)
+		{
+			break;
+		}
+#ifdef _G2_GORE
+		if (!collRecMap&&!AddGoreToAllModels)
+		{
+			// we don't really need to do multiple models for gore.
+			break;
+		}
+#endif
+	}
+}
+
+void TransformPoint (const vec3_t in, vec3_t out, mdxaBone_t *mat) {
+	for (int i=0;i<3;i++)
+	{
+		out[i]= in[0]*mat->matrix[i][0] + in[1]*mat->matrix[i][1] + in[2]*mat->matrix[i][2];
+	}
+}
+
+void TransformAndTranslatePoint (const vec3_t in, vec3_t out, mdxaBone_t *mat) {
+
+	for (int i=0;i<3;i++)
+	{
+		out[i]= in[0]*mat->matrix[i][0] + in[1]*mat->matrix[i][1] + in[2]*mat->matrix[i][2] + mat->matrix[i][3];
+	}
+}
+
+
+// create a matrix using a set of angles
+void Create_Matrix(const float *angle, mdxaBone_t *matrix)
+{
+	vec3_t		axis[3];
+
+	// convert angles to axis
+	AnglesToAxis( angle, axis );
+	matrix->matrix[0][0] = axis[0][0];
+	matrix->matrix[1][0] = axis[0][1];
+	matrix->matrix[2][0] = axis[0][2];
+
+	matrix->matrix[0][1] = axis[1][0];
+	matrix->matrix[1][1] = axis[1][1];
+	matrix->matrix[2][1] = axis[1][2];
+
+	matrix->matrix[0][2] = axis[2][0];
+	matrix->matrix[1][2] = axis[2][1];
+	matrix->matrix[2][2] = axis[2][2];
+
+	matrix->matrix[0][3] = 0;
+	matrix->matrix[1][3] = 0;
+	matrix->matrix[2][3] = 0;
+
+
+}
+
+// given a matrix, generate the inverse of that matrix
+void Inverse_Matrix(mdxaBone_t *src, mdxaBone_t *dest)
+{
+	int i, j;
+
+    for (i = 0; i < 3; i++)
+	{
+        for (j = 0; j < 3; j++)
+		{
+            dest->matrix[i][j]=src->matrix[j][i];
+		}
+	}
+    for (i = 0; i < 3; i++)
+	{
+        dest->matrix[i][3]=0;
+        for (j = 0; j < 3; j++)
+		{
+            dest->matrix[i][3]-=dest->matrix[i][j]*src->matrix[j][3];
+		}
+	}
+}
+
+// generate the world matrix for a given set of angles and origin - called from lots of places
+void G2_GenerateWorldMatrix(const vec3_t angles, const vec3_t origin)
+{
+	Create_Matrix(angles, &worldMatrix);
+	worldMatrix.matrix[0][3] = origin[0];
+	worldMatrix.matrix[1][3] = origin[1];
+	worldMatrix.matrix[2][3] = origin[2];
+
+	Inverse_Matrix(&worldMatrix, &worldMatrixInv);
+}
+
+// go away and determine what the pointer for a specific surface definition within the model definition is
+void *G2_FindSurface(const model_s *mod, int index, int lod)
+{
+	assert(mod);
+	assert(mod->mdxm);
+
+	// point at first lod list
+	byte	*current = (byte*)((int)mod->mdxm + (int)mod->mdxm->ofsLODs);
+	int i;
+
+	//walk the lods
+	assert(lod>=0&&lod<mod->mdxm->numLODs);
+	for (i=0; i<lod; i++)
+	{
+		mdxmLOD_t *lodData = (mdxmLOD_t *)current;
+		current += lodData->ofsEnd;
+	}
+
+	// avoid the lod pointer data structure
+	current += sizeof(mdxmLOD_t);
+
+	mdxmLODSurfOffset_t *indexes = (mdxmLODSurfOffset_t *)current;
+	// we are now looking at the offset array
+	assert(index>=0&&index<mod->mdxm->numSurfaces);
+	current += indexes->offsets[index];
+
+	return (void *)current;
+}
+
+#define SURFACE_SAVE_BLOCK_SIZE	sizeof(surfaceInfo_t)
+#define BOLT_SAVE_BLOCK_SIZE sizeof(boltInfo_t)
+#define BONE_SAVE_BLOCK_SIZE sizeof(boneInfo_t)
+
+void G2_SaveGhoul2Models(CGhoul2Info_v &ghoul2)
+{
+	char *pGhoul2Data = NULL;
+	int   iGhoul2Size = 0;
+
+	// is there anything to save?
+	if (!ghoul2.IsValid()||!ghoul2.size())
+	{
+		SG_Append('GHL2',&pGhoul2Data, 4);	//write out a zero buffer
+		return;
+	}
+
+	// this one isn't a define since I couldn't work out how to figure it out at compile time
+	const int ghoul2BlockSize = (int)&ghoul2[0].BSAVE_END_FIELD - (int)&ghoul2[0].BSAVE_START_FIELD;
+
+	// add in count for number of ghoul2 models
+	iGhoul2Size += 4;	
+	// start out working out the total size of the buffer we need to allocate
+	for (int i=0; i<ghoul2.size();i++)
+	{
+		iGhoul2Size += ghoul2BlockSize;
+		// add in count for number of surfaces
+		iGhoul2Size += 4;	
+		iGhoul2Size += (ghoul2[i].mSlist.size() * SURFACE_SAVE_BLOCK_SIZE);
+		// add in count for number of bones
+		iGhoul2Size += 4;	
+		iGhoul2Size += (ghoul2[i].mBlist.size() * BONE_SAVE_BLOCK_SIZE);
+		// add in count for number of bolts
+		iGhoul2Size += 4;	
+		iGhoul2Size += (ghoul2[i].mBltlist.size() * BOLT_SAVE_BLOCK_SIZE);
+	}
+
+	// ok, we should know how much space we need now
+	pGhoul2Data = (char*)Z_Malloc(iGhoul2Size, TAG_GHOUL2, qfalse);
+
+	// now lets start putting the data we care about into the buffer
+	char *tempBuffer = pGhoul2Data;
+
+	// save out how many ghoul2 models we have
+	*(int *)tempBuffer = ghoul2.size();
+	tempBuffer +=4;
+
+	for (i=0; i<ghoul2.size();i++)
+	{
+		// first save out the ghoul2 details themselves
+//		OutputDebugString(va("G2_SaveGhoul2Models(): ghoul2[%d].mModelindex = %d\n",i,ghoul2[i].mModelindex));
+		memcpy(tempBuffer, &ghoul2[i].mModelindex, ghoul2BlockSize);
+		tempBuffer += ghoul2BlockSize;
+
+		// save out how many surfaces we have
+		*(int*)tempBuffer = ghoul2[i].mSlist.size();
+		tempBuffer +=4;
+
+		// now save the all the surface list info
+		for (int x=0; x<ghoul2[i].mSlist.size(); x++)
+		{
+			memcpy(tempBuffer, &ghoul2[i].mSlist[x], SURFACE_SAVE_BLOCK_SIZE);
+			tempBuffer += SURFACE_SAVE_BLOCK_SIZE;
+		}
+		
+		// save out how many bones we have
+		*(int*)tempBuffer = ghoul2[i].mBlist.size();
+		tempBuffer +=4;
+
+		// now save the all the bone list info
+		for (x=0; x<ghoul2[i].mBlist.size(); x++)
+		{
+			memcpy(tempBuffer, &ghoul2[i].mBlist[x], BONE_SAVE_BLOCK_SIZE);
+			tempBuffer += BONE_SAVE_BLOCK_SIZE;
+		}
+
+		// save out how many bolts we have
+		*(int*)tempBuffer = ghoul2[i].mBltlist.size();
+		tempBuffer +=4;
+
+		// lastly save the all the bolt list info
+		for (x=0; x<ghoul2[i].mBltlist.size(); x++)
+		{
+			memcpy(tempBuffer, &ghoul2[i].mBltlist[x], BOLT_SAVE_BLOCK_SIZE);
+			tempBuffer += BOLT_SAVE_BLOCK_SIZE;
+		}
+	}
+
+	SG_Append('GHL2',pGhoul2Data, iGhoul2Size);
+	Z_Free(pGhoul2Data);
+}
+
+int G2_FindConfigStringSpace(char *name, int start, int max)
+{
+	char	s[MAX_STRING_CHARS];
+
+	for (int  i=1 ; i<max ; i++ ) 
+	{
+		SV_GetConfigstring( start + i, s, sizeof( s ) );
+		if ( !s[0] ) 
+		{
+			break;
+		}
+		if ( !stricmp( s, name ) ) 
+		{
+			return i;
+		}
+	}
+
+	SV_SetConfigstring(start + i, name);
+	return i;
+}
+
+void G2_LoadGhoul2Model(CGhoul2Info_v &ghoul2, char *buffer)
+{
+	// first thing, lets see how many ghoul2 models we have, and resize our buffers accordingly
+	int newSize = *(int*)buffer;
+	ghoul2.resize(newSize);
+	buffer += 4;
+
+	// did we actually resize to a value?
+	if (!newSize)
+	{
+		// no, ok, well, done then.
+		return;
+	}
+
+	// this one isn't a define since I couldn't work out how to figure it out at compile time
+	const int ghoul2BlockSize = (int)&ghoul2[0].mTransformedVertsArray - (int)&ghoul2[0].mModelindex;
+
+	// now we have enough instances, lets go through each one and load up the relevant details
+	for (int i=0; i<ghoul2.size(); i++)
+	{
+		ghoul2[i].mSkelFrameNum = 0;
+		ghoul2[i].mModelindex=-1;
+		ghoul2[i].mFileName[0]=0;
+		ghoul2[i].mValid=false;
+		// load the ghoul2 info from the buffer
+		memcpy(&ghoul2[i].mModelindex, buffer, ghoul2BlockSize);
+		buffer +=ghoul2BlockSize;
+
+		if (ghoul2[i].mModelindex!=-1&&ghoul2[i].mFileName[0])
+		{
+			ghoul2[i].mModelindex = i;
+			G2_SetupModelPointers(&ghoul2[i]);
+		}
+
+		// give us enough surfaces to load up the data
+		ghoul2[i].mSlist.resize(*(int*)buffer);
+		buffer +=4;
+
+		// now load all the surfaces
+		for (int x=0; x<ghoul2[i].mSlist.size(); x++)
+		{
+			memcpy(&ghoul2[i].mSlist[x], buffer, SURFACE_SAVE_BLOCK_SIZE);
+			buffer += SURFACE_SAVE_BLOCK_SIZE;
+		}
+
+		// give us enough bones to load up the data
+		ghoul2[i].mBlist.resize(*(int*)buffer);
+		buffer +=4;
+
+		// now load all the bones
+		for (x=0; x<ghoul2[i].mBlist.size(); x++)
+		{
+			memcpy(&ghoul2[i].mBlist[x], buffer, BONE_SAVE_BLOCK_SIZE);
+			buffer += BONE_SAVE_BLOCK_SIZE;
+		}
+
+		// give us enough bolts to load up the data
+		ghoul2[i].mBltlist.resize(*(int*)buffer);
+		buffer +=4;
+
+		// now load all the bolts
+		for (x=0; x<ghoul2[i].mBltlist.size(); x++)
+		{
+			memcpy(&ghoul2[i].mBltlist[x], buffer, BOLT_SAVE_BLOCK_SIZE);
+			buffer += BOLT_SAVE_BLOCK_SIZE;
+		}
+	}
+}
\ No newline at end of file
diff --git a/code/ghoul2/G2_surfaces.cpp b/code/ghoul2/G2_surfaces.cpp
new file mode 100644
index 0000000..6805a07
--- /dev/null
+++ b/code/ghoul2/G2_surfaces.cpp
@@ -0,0 +1,428 @@
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+
+
+#ifndef __Q_SHARED_H
+	#include "../game/q_shared.h"
+#endif
+
+#if !defined(TR_LOCAL_H)
+	#include "../renderer/tr_local.h"
+#endif
+
+#if !defined(G2_H_INC)
+	#include "G2.h"
+#endif
+
+#define G2_MODEL_OK(g) ((g)&&(g)->mValid&&(g)->aHeader&&(g)->currentModel&&(g)->animModel)
+
+#pragma warning(disable : 4512)		//assignment op could not be genereated
+
+class CQuickOverride
+{
+	int mOverride[512];
+	int mAt[512];
+	int mCurrentTouch;
+public:
+	CQuickOverride()
+	{
+		mCurrentTouch=1;
+		int i;
+		for (i=0;i<512;i++)
+		{
+			mOverride[i]=0;
+		}
+	}
+	void Invalidate()
+	{
+		mCurrentTouch++;
+	}
+	void Set(int index,int pos)
+	{
+		if (index==10000)
+		{
+			return;
+		}
+		assert(index>=0&&index<512);
+		mOverride[index]=mCurrentTouch;
+		mAt[index]=pos;
+	}
+	int Test(int index)
+	{
+		assert(index>=0&&index<512);
+		if (mOverride[index]!=mCurrentTouch)
+		{
+			return -1;
+		}
+		else
+		{
+			return mAt[index];
+		}
+	}
+};
+
+static CQuickOverride QuickOverride;
+
+
+// find a particular surface in the surface override list
+const surfaceInfo_t *G2_FindOverrideSurface(int surfaceNum,const surfaceInfo_v &surfaceList)
+{
+	
+	if (surfaceNum<0)
+	{
+		// starting a new lookup
+		QuickOverride.Invalidate();
+		int i; 
+		for(i=0; i<surfaceList.size(); i++)
+		{
+			if (surfaceList[i].surface>=0)
+			{
+				QuickOverride.Set(surfaceList[i].surface,i);
+			}
+		}
+		return NULL;
+	}
+	int idx=QuickOverride.Test(surfaceNum);
+	if (idx<0)
+	{
+		unsigned int i; 
+		if (surfaceNum==10000)
+		{
+			for(i=0; i<surfaceList.size(); i++)
+			{
+				if (surfaceList[i].surface == surfaceNum)
+				{
+					return &surfaceList[i];
+				}
+			}
+		}
+#if _DEBUG
+		// look through entire list
+		for(i=0; i<surfaceList.size(); i++)
+		{
+			if (surfaceList[i].surface == surfaceNum)
+			{
+				break;
+			}
+		}
+		// didn't find it.
+		assert(i==surfaceList.size()); // our quickoverride is not working right
+#endif
+		return NULL;
+	}
+	assert(idx>=0&&idx<surfaceList.size());
+	assert(surfaceList[idx].surface == surfaceNum);
+	return &surfaceList[idx];
+}
+
+
+// given a surface name, lets see if it's legal in the model
+int G2_IsSurfaceLegal(const model_s *mod_m, const char *surfaceName, int *flags)
+{
+	assert(mod_m);
+	assert(mod_m->mdxm);
+	// damn include file dependancies
+	mdxmSurfHierarchy_t	*surf;
+	surf = (mdxmSurfHierarchy_t *) ( (byte *)mod_m->mdxm + mod_m->mdxm->ofsSurfHierarchy );
+
+	for ( int i = 0 ; i < mod_m->mdxm->numSurfaces ; i++) 
+	{
+	 	if (!stricmp(surfaceName, surf->name))
+	 	{
+			*flags = surf->flags;
+			return i;
+		}
+		// find the next surface
+  		surf = (mdxmSurfHierarchy_t *)( (byte *)surf + (int)( &((mdxmSurfHierarchy_t *)0)->childIndexes[ surf->numChildren ] ));
+	}
+	return -1;
+}
+
+
+/************************************************************************************************
+ * G2_FindSurface
+ *    find a surface in a ghoul2 surface override list based on it's name
+ *
+ * Input
+ *    filename of model, surface list of model instance, name of surface, int to be filled in
+ * with the index of this surface (defaults to NULL)
+ *
+ * Output
+ *    pointer to surface if successful, false otherwise
+ *
+ ************************************************************************************************/
+const mdxmSurface_t *G2_FindSurface(CGhoul2Info *ghlInfo, surfaceInfo_v &slist, const char *surfaceName,
+							 int *surfIndex/*NULL*/)
+{
+	int						i = 0;
+	// find the model we want
+	assert(G2_MODEL_OK(ghlInfo));
+
+	const mdxmHierarchyOffsets_t *surfIndexes = (mdxmHierarchyOffsets_t *)((byte *)ghlInfo->currentModel->mdxm + sizeof(mdxmHeader_t));
+   
+ 	// first find if we already have this surface in the list
+	for (i = slist.size() - 1; i >= 0; i--)
+	{
+		if ((slist[i].surface != 10000) && (slist[i].surface != -1))
+		{
+			const mdxmSurface_t	*surf = (mdxmSurface_t *)G2_FindSurface(ghlInfo->currentModel, slist[i].surface, 0);
+			// back track and get the surfinfo struct for this surface
+			const mdxmSurfHierarchy_t	*surfInfo = (mdxmSurfHierarchy_t *)((byte *)surfIndexes + surfIndexes->offsets[surf->thisSurfaceIndex]);
+
+  			// are these the droids we're looking for?
+			if (!stricmp (surfInfo->name, surfaceName))
+			{
+				// yup
+				if (surfIndex)
+				{
+					*surfIndex = i;
+				}
+				return surf;
+			}
+		}
+	}
+	// didn't find it
+	if (surfIndex)
+	{
+		*surfIndex = -1;
+	}
+	return 0;
+}
+
+// set a named surface offFlags - if it doesn't find a surface with this name in the list then it will add one.
+qboolean G2_SetSurfaceOnOff (CGhoul2Info *ghlInfo, const char *surfaceName, const int offFlags)
+{
+	int					surfIndex = -1;
+	surfaceInfo_t		temp_slist_entry;
+
+	// find the model we want
+ 	// first find if we already have this surface in the list
+	const mdxmSurface_t *surf = G2_FindSurface(ghlInfo, ghlInfo->mSlist, surfaceName, &surfIndex);
+	if (surf)
+	{
+		// set descendants value
+
+		// slist[surfIndex].offFlags = offFlags;
+		// seems to me that we shouldn't overwrite the other flags.
+		// the only bit we really care about in the incoming flags is the off bit
+		ghlInfo->mSlist[surfIndex].offFlags &= ~(G2SURFACEFLAG_OFF | G2SURFACEFLAG_NODESCENDANTS);
+		ghlInfo->mSlist[surfIndex].offFlags |= offFlags & (G2SURFACEFLAG_OFF | G2SURFACEFLAG_NODESCENDANTS);
+		return qtrue;
+	}
+	else
+	{
+		// ok, not in the list already - in that case, lets verify this surface exists in the model mesh
+		int	flags;
+		int surfaceNum = G2_IsSurfaceLegal(ghlInfo->currentModel, surfaceName, &flags);
+		if (surfaceNum != -1)
+		{
+			int newflags = flags;
+			// the only bit we really care about in the incoming flags is the off bit
+			newflags &= ~(G2SURFACEFLAG_OFF | G2SURFACEFLAG_NODESCENDANTS);
+			newflags |= offFlags & (G2SURFACEFLAG_OFF | G2SURFACEFLAG_NODESCENDANTS);
+
+			if (newflags != flags)
+			{	// insert here then because it changed, no need to add an override otherwise
+				temp_slist_entry.offFlags = newflags;
+				temp_slist_entry.surface = surfaceNum;
+				
+				ghlInfo->mSlist.push_back(temp_slist_entry);
+			}
+			return qtrue;
+		}
+	}
+	return qfalse;
+}
+
+void G2_FindRecursiveSurface(const model_t *currentModel, int surfaceNum, surfaceInfo_v &rootList, int *activeSurfaces)
+{
+	assert(currentModel);
+	assert(currentModel->mdxm);
+	int							i;
+ 	const mdxmSurface_t			*surface = (mdxmSurface_t *)G2_FindSurface(currentModel, surfaceNum, 0);
+	const mdxmHierarchyOffsets_t	*surfIndexes = (mdxmHierarchyOffsets_t *)((byte *)currentModel->mdxm + sizeof(mdxmHeader_t));
+	const mdxmSurfHierarchy_t		*surfInfo = (mdxmSurfHierarchy_t *)((byte *)surfIndexes + surfIndexes->offsets[surface->thisSurfaceIndex]);
+
+	// see if we have an override surface in the surface list
+	const surfaceInfo_t	*surfOverride = G2_FindOverrideSurface(surfaceNum, rootList);
+
+	// really, we should use the default flags for this surface unless it's been overriden
+	int offFlags = surfInfo->flags;
+
+	// set the off flags if we have some
+	if (surfOverride)
+	{
+		offFlags = surfOverride->offFlags;
+	}
+
+	// if this surface is not off, indicate as such in the active surface list
+	if (!(offFlags & G2SURFACEFLAG_OFF))
+	{
+		activeSurfaces[surfaceNum] = 1;
+	}
+ 	else
+	// if we are turning off all descendants, then stop this recursion now
+	if (offFlags & G2SURFACEFLAG_NODESCENDANTS)
+	{
+		return;
+	}
+
+	// now recursively call for the children
+	for (i=0; i< surfInfo->numChildren; i++)
+	{
+		surfaceNum = surfInfo->childIndexes[i];
+		G2_FindRecursiveSurface(currentModel, surfaceNum, rootList, activeSurfaces);
+	}
+
+}
+
+qboolean G2_SetRootSurface( CGhoul2Info_v &ghoul2, const int modelIndex, const char *surfaceName)
+{
+	int					surf;
+	int					flags;   
+	assert(modelIndex>=0&&modelIndex<ghoul2.size());
+	assert(ghoul2[modelIndex].currentModel);
+	assert(ghoul2[modelIndex].currentModel->mdxm);
+ 	// first find if we already have this surface in the list
+	surf = G2_IsSurfaceLegal(ghoul2[modelIndex].currentModel, surfaceName, &flags);
+	if (surf != -1)
+	{
+		ghoul2[modelIndex].mSurfaceRoot = surf;
+		return qtrue;
+	}
+	assert(0);
+	return qfalse;
+}
+
+
+extern int			G2_DecideTraceLod(CGhoul2Info &ghoul2, int useLod);
+int G2_AddSurface(CGhoul2Info *ghoul2, int surfaceNumber, int polyNumber, float BarycentricI, float BarycentricJ, int lod )
+{
+	lod = G2_DecideTraceLod(*ghoul2, lod);
+
+	// first up, see if we have a free one already set up  - look only from the end of the constant surfaces onwards
+	unsigned int i;
+	for (i=0; i<ghoul2->mSlist.size(); i++)
+	{
+		// is the surface count -1? That would indicate it's free
+		if (ghoul2->mSlist[i].surface == -1)
+		{
+			break;
+		}
+	}
+	if (i==ghoul2->mSlist.size())
+	{
+		ghoul2->mSlist.push_back(surfaceInfo_t());
+	}
+	ghoul2->mSlist[i].offFlags = G2SURFACEFLAG_GENERATED;
+	ghoul2->mSlist[i].surface = 10000;		// no model will ever have 10000 surfaces
+	ghoul2->mSlist[i].genBarycentricI = BarycentricI;
+	ghoul2->mSlist[i].genBarycentricJ = BarycentricJ;
+	ghoul2->mSlist[i].genPolySurfaceIndex = ((polyNumber & 0xffff) << 16) | (surfaceNumber & 0xffff);
+	ghoul2->mSlist[i].genLod = lod;
+	return i;
+}
+
+qboolean G2_RemoveSurface(surfaceInfo_v &slist, const int index)
+{
+	if (index != -1)
+	{
+		slist[index].surface = -1;
+		return qtrue;
+	}
+	assert(0);
+	return qfalse;
+}
+
+
+int G2_GetParentSurface(CGhoul2Info *ghlInfo, const int index)
+{
+	assert(ghlInfo->currentModel);
+	assert(ghlInfo->currentModel->mdxm);
+	const mdxmHierarchyOffsets_t	*surfIndexes = (mdxmHierarchyOffsets_t *)((byte *)ghlInfo->currentModel->mdxm + sizeof(mdxmHeader_t));
+
+	// walk each surface and see if this index is listed in it's children
+	const mdxmSurface_t				*surf = (mdxmSurface_t *)G2_FindSurface(ghlInfo->currentModel, index, 0);
+	const mdxmSurfHierarchy_t		*surfInfo = (mdxmSurfHierarchy_t *)((byte *)surfIndexes + surfIndexes->offsets[surf->thisSurfaceIndex]);
+
+	return surfInfo->parentIndex;
+
+}
+
+int G2_GetSurfaceIndex(CGhoul2Info *ghlInfo, const char *surfaceName)
+{
+	int				flags;
+	assert(ghlInfo->currentModel);
+	return G2_IsSurfaceLegal(ghlInfo->currentModel, surfaceName, &flags);
+}
+
+int G2_IsSurfaceRendered(CGhoul2Info *ghlInfo, const char *surfaceName, surfaceInfo_v &slist)
+{
+	int						flags = 0;//, surfFlags = 0;
+	int						surfIndex = 0;
+	assert(ghlInfo->currentModel);
+	assert(ghlInfo->currentModel->mdxm);
+	if (!ghlInfo->currentModel->mdxm)
+	{
+		return -1;
+	}
+
+	// now travel up the skeleton to see if any of it's ancestors have a 'no descendants' turned on
+
+	// find the original surface in the surface list
+	int surfNum = G2_IsSurfaceLegal(ghlInfo->currentModel, surfaceName, &flags);
+	if ( surfNum != -1 )
+	{//must be legal
+		const mdxmHierarchyOffsets_t	*surfIndexes = (mdxmHierarchyOffsets_t *)((byte *)ghlInfo->currentModel->mdxm + sizeof(mdxmHeader_t));
+		const mdxmSurfHierarchy_t *surfInfo = (mdxmSurfHierarchy_t *)((byte *)surfIndexes + surfIndexes->offsets[surfNum]);
+		surfNum = surfInfo->parentIndex;
+		// walk the surface hierarchy up until we hit the root
+		while (surfNum != -1)
+		{
+			const mdxmSurface_t		*parentSurf;
+			int						parentFlags;
+			const mdxmSurfHierarchy_t		*parentSurfInfo;
+
+			parentSurfInfo = (mdxmSurfHierarchy_t *)((byte *)surfIndexes + surfIndexes->offsets[surfNum]);
+
+			// find the original surface in the surface list
+			//G2 was bug, above comment was accurate, but we don't want the original flags, we want the parent flags
+			G2_IsSurfaceLegal(ghlInfo->currentModel, parentSurfInfo->name, &parentFlags);
+
+			// now see if we already have overriden this surface in the slist 
+			parentSurf = G2_FindSurface(ghlInfo, slist, parentSurfInfo->name, &surfIndex);
+			if (parentSurf)
+			{
+				// set descendants value
+				parentFlags = slist[surfIndex].offFlags;
+			}
+			// now we have the parent flags, lets see if any have the 'no descendants' flag set
+			if (parentFlags & G2SURFACEFLAG_NODESCENDANTS)
+			{
+				flags |= G2SURFACEFLAG_OFF;
+				break; 
+			}
+			// set up scan of next parent
+			surfNum = parentSurfInfo->parentIndex;
+		}
+	}
+	else
+	{
+		return -1;
+	}
+	if ( flags == 0 )
+	{//it's not being overridden by a parent
+		// now see if we already have overriden this surface in the slist 
+		const mdxmSurface_t *surf = G2_FindSurface(ghlInfo, slist, surfaceName, &surfIndex);
+		if (surf)
+		{
+			// set descendants value
+			flags = slist[surfIndex].offFlags;
+		}
+	  	// ok, at this point in flags we have what this surface is set to, and the index of the surface itself
+	}
+	return flags;
+
+}
diff --git a/code/ghoul2/ghoul2_gore.h b/code/ghoul2/ghoul2_gore.h
new file mode 100644
index 0000000..b86cf52
--- /dev/null
+++ b/code/ghoul2/ghoul2_gore.h
@@ -0,0 +1,191 @@
+#ifdef _G2_GORE
+
+#define MAX_LODS (8)
+struct GoreTextureCoordinates
+{
+	float *tex[MAX_LODS];
+
+	GoreTextureCoordinates()
+	{
+		int i;
+		for (i=0;i<MAX_LODS;i++)
+		{
+			tex[i]=0;
+		}
+	}
+	~GoreTextureCoordinates()
+	{
+		int i;
+		for (i=0;i<MAX_LODS;i++)
+		{
+			if ( tex[i] )
+			{
+				extern int Z_Free(void *pvAddress);
+				Z_Free(tex[i]);
+				tex[i] = 0;
+			}
+		}
+	}
+};
+
+int AllocGoreRecord();
+GoreTextureCoordinates *FindGoreRecord(int tag);
+void DeleteGoreRecord(int tag);
+
+struct SGoreSurface
+{
+	int			shader;
+	int			mGoreTag;
+	int			mDeleteTime;
+	int			mFadeTime;
+	bool		mFadeRGB;
+
+	int			mGoreGrowStartTime;
+	int			mGoreGrowEndTime;    // set this to -1 to disable growing
+	//curscale = (curtime-mGoreGrowStartTime)*mGoreGrowFactor + mGoreGrowOffset;
+	float		mGoreGrowFactor;	
+	float		mGoreGrowOffset;	
+};
+
+class CGoreSet
+{
+public:
+	int		 mMyGoreSetTag;
+	unsigned char mRefCount;
+	multimap<int,SGoreSurface> mGoreRecords; // a map from surface index
+	CGoreSet(int tag) : mMyGoreSetTag(tag), mRefCount(0) {}
+	~CGoreSet();
+};
+
+CGoreSet	*FindGoreSet(int goreSetTag);
+CGoreSet	*NewGoreSet();
+void		DeleteGoreSet(int goreSetTag);
+
+#endif // _G2_GORE
+
+//rww - RAGDOLL_BEGIN
+#pragma warning(disable: 4512)
+
+struct SRagDollEffectorCollision
+{
+	vec3_t			effectorPosition;
+	const trace_t	&tr;
+	bool			useTracePlane;
+	SRagDollEffectorCollision(const vec3_t effectorPos,const trace_t &t) :
+		tr(t),
+		useTracePlane(false)
+	{
+		VectorCopy(effectorPos,effectorPosition);
+	}
+};
+
+class CRagDollUpdateParams
+{
+public:
+	vec3_t angles;
+	vec3_t position;
+	vec3_t scale;
+	vec3_t velocity;
+	//CServerEntity *me;
+	int	me; //index!
+	int settleFrame;
+
+	int groundEnt;
+
+	virtual void EffectorCollision(const SRagDollEffectorCollision &data) 
+	{
+		assert(0); // you probably meant to override this
+	}
+	virtual void RagDollBegin() 
+	{
+		assert(0); // you probably meant to override this
+	}
+	virtual void RagDollSettled() 
+	{
+		assert(0); // you probably meant to override this
+	}
+
+	virtual void Collision() 
+	{
+		assert(0); // you probably meant to override this
+		// we had a collision, uhh I guess call SetRagDoll RP_DEATH_COLLISION
+	}  
+	
+#ifdef _DEBUG
+	virtual void DebugLine(vec3_t p1,vec3_t p2,int color,bool bbox) {assert(0);}
+#endif
+};
+
+
+class CRagDollParams
+{
+public:
+
+	enum ERagPhase
+	{
+		RP_START_DEATH_ANIM,
+		RP_END_DEATH_ANIM,
+		RP_DEATH_COLLISION,
+		RP_CORPSE_SHOT,
+		RP_GET_PELVIS_OFFSET,  // this actually does nothing but set the pelvisAnglesOffset, and pelvisPositionOffset
+		RP_SET_PELVIS_OFFSET,  // this actually does nothing but set the pelvisAnglesOffset, and pelvisPositionOffset
+		RP_DISABLE_EFFECTORS  // this removes effectors given by the effectorsToTurnOff member
+	};
+	vec3_t angles;
+	vec3_t position;
+	vec3_t scale;
+	vec3_t pelvisAnglesOffset;    // always set on return, an argument for RP_SET_PELVIS_OFFSET
+	vec3_t pelvisPositionOffset; // always set on return, an argument for RP_SET_PELVIS_OFFSET
+
+	float fImpactStrength; //should be applicable when RagPhase is RP_DEATH_COLLISION
+	float fShotStrength; //should be applicable for setting velocity of corpse on shot (probably only on RP_CORPSE_SHOT)
+	//CServerEntity *me;
+	int me;
+
+	int groundEnt;
+
+	//rww - we have convenient animation/frame access in the game, so just send this info over from there.
+	int startFrame;
+	int endFrame;
+
+	int collisionType; // 1 = from a fall, 0 from effectors, this will be going away soon, hence no enum 
+
+	bool CallRagDollBegin; // a return value, means that we are now begininng ragdoll and the NPC stuff needs to happen
+
+	ERagPhase RagPhase;
+
+// effector control, used for RP_DISABLE_EFFECTORS call
+
+	enum ERagEffector
+	{
+		RE_MODEL_ROOT=			0x00000001, //"model_root"
+		RE_PELVIS=				0x00000002, //"pelvis"
+		RE_LOWER_LUMBAR=		0x00000004, //"lower_lumbar"
+		RE_UPPER_LUMBAR=		0x00000008, //"upper_lumbar"
+		RE_THORACIC=			0x00000010, //"thoracic"
+		RE_CRANIUM=				0x00000020, //"cranium"
+		RE_RHUMEROUS=			0x00000040, //"rhumerus"
+		RE_LHUMEROUS=			0x00000080, //"lhumerus"
+		RE_RRADIUS=				0x00000100, //"rradius"
+		RE_LRADIUS=				0x00000200, //"lradius"
+		RE_RFEMURYZ=			0x00000400, //"rfemurYZ"
+		RE_LFEMURYZ=			0x00000800, //"lfemurYZ"
+		RE_RTIBIA=				0x00001000, //"rtibia"
+		RE_LTIBIA=				0x00002000, //"ltibia"
+		RE_RHAND=				0x00004000, //"rhand"
+		RE_LHAND=				0x00008000, //"lhand"
+		RE_RTARSAL=				0x00010000, //"rtarsal"
+		RE_LTARSAL=				0x00020000, //"ltarsal"
+		RE_RTALUS=				0x00040000, //"rtalus"
+		RE_LTALUS=				0x00080000, //"ltalus"
+		RE_RRADIUSX=			0x00100000, //"rradiusX"
+		RE_LRADIUSX=			0x00200000, //"lradiusX"
+		RE_RFEMURX=				0x00400000, //"rfemurX"
+		RE_LFEMURX=				0x00800000, //"lfemurX"
+		RE_CEYEBROW=			0x01000000 //"ceyebrow"
+	};
+
+	ERagEffector effectorsToTurnOff;  // set this to an | of the above flags for a RP_DISABLE_EFFECTORS
+
+};
+//rww - RAGDOLL_END
diff --git a/code/ghoul2/vssver.scc b/code/ghoul2/vssver.scc
new file mode 100644
index 0000000..7ffc18e
Binary files /dev/null and b/code/ghoul2/vssver.scc differ
diff --git a/code/goblib/goblib.cpp b/code/goblib/goblib.cpp
new file mode 100644
index 0000000..11553f7
--- /dev/null
+++ b/code/goblib/goblib.cpp
@@ -0,0 +1,1876 @@
+/*****************************************
+ *
+ * GOB File System
+ *
+ * Here's what Merriam-Webster says about "gob":  --Chuck
+ *		Entry:     gob
+ *		Function:  noun
+ *		Etymology: Middle English gobbe, from Middle French gobe large piece of food,
+ *		           back-formation from gobet
+ *		Date:      14th century
+ *		1 : LUMP
+ *		2 : a large amount -- usually used in plural <gobs of money>
+ *
+ * Purpose: Provide fast, efficient disk access on a variety of platforms.
+ *
+ * Implementation:
+ *		The GOB system maintains two files -- GOB and GFC.  The GOB file is actually
+ *		an archive of many files split into variable size, compressed blocks.  The GFC,
+ *		GOB File Control, contains 3 tables -- a block table, basic file table, and
+ *		extended file table.  The block table is analogous to a DOS FAT.  The basic
+ *		file table contains a minimal set of file information to handle basic reading
+ *		tasks.  The extended file table is optionally loaded and contains additional
+ *		file information.  File names are case insensitive.
+ *		  
+ *		Files can be read in a normal manner.  Open, read, seek and close
+ *		operations are all provided.  Files can only be written in a single
+ *		contiguous chunk of blocks at the end of an archive.  Reads are processed
+ *		through a configurable number of read ahead buffers to in an effort to
+ *		minimize both reads and seeks.  Other operations including delete, verify, 
+ *		access, and get size are also supported on files inside an archive.
+ *
+ *		The system supports read profiling.  By supplying a file read callback 
+ *		function, the library will output the block number of each read.  This can 
+ *		be used rearrange block in the archive to minimize seek times.  The 
+ *		GOBRearrange sorts files in an archive.
+ *
+ *		Supports block based caching.  Primarily aimed at caching files off a DVD/CD
+ *		to a faster hard disk.
+ *
+ * Future Work: 
+ *
+ * Dependencies: vvInt, snprintf, zlib
+ * Owner: Chris McEvoy
+ * History:
+ *     09/23/2001 Original version
+ *     10/28/2002 Merged into vvtech
+ *
+ * Copyright (C) 2002, Vicarious Visions, Inc.  All Rights Reserved.
+ *
+ * UNPUBLISHED -- Rights  reserved  under  the  copyright  laws  of the 
+ * United States.  Use  of a copyright notice is precautionary only and 
+ * does not imply publication or disclosure.                            
+ *                                                                      
+ * THIS DOCUMENTATION CONTAINS CONFIDENTIAL AND PROPRIETARY INFORMATION 
+ * OF    VICARIOUS   VISIONS,  INC.    ANY  DUPLICATION,  MODIFICATION, 
+ * DISTRIBUTION, OR DISCLOSURE IS STRICTLY PROHIBITED WITHOUT THE PRIOR 
+ * EXPRESS WRITTEN PERMISSION OF VICARIOUS VISIONS, INC.
+ *
+ *****************************************/
+
+/*
+	This is an unofficial branch of GOB, for Jedi Academy
+	Maintainer: Brian Osman
+*/
+
+#include "goblib.h"
+#include "../zlib/zlib.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+#include <assert.h>
+
+#if (VV_PLATFORM == VV_PLATFORM_WIN) || (VV_PLATFORM == VV_PLATFORM_XBOX)
+#	define CDECL __cdecl
+#else
+#	define CDECL 
+#endif
+
+// Profiling data
+static GOBProfileReadFunc ProfileReadCallback = NULL;
+static GOBBool ProfileEnabled = GOB_FALSE;
+
+// Indicates whether or not the library has been initialized
+static GOBBool LibraryInit = GOB_FALSE;
+
+// Callbacks for handling low-level compression/decompression
+static struct GOBCodecFuncSet CodecFuncs;
+
+// Callbacks for handling low-level memory alloc and free
+static struct GOBMemoryFuncSet MemFuncs;
+
+// Callbacks for handling low-level file access
+static struct GOBFileSysFuncSet FSFuncs;
+
+// Callbacks for handling block caching (ie Xbox temp space)
+static struct GOBCacheFileFuncSet CacheFileFuncs;
+static GOBBool CacheFileActive = GOB_FALSE;
+
+// Name of the GFC file
+static GOBChar ControlFileName[GOB_MAX_FILE_NAME_LEN];
+
+// Handle to the GOB archive
+static GOBFSHandle ArchiveHandle = (GOBFSHandle*)0xFFFFFFFF;
+
+// Size of the active GOB archive
+static GOBUInt32 ArchiveSize = 0;
+static GOBUInt32 ArchiveNumBlocks = 0;
+static GOBUInt32 ArchiveNumFiles = 0;
+
+// Cached blocks
+struct GOBBlockCache
+{
+	GOBChar* data;
+	GOBUInt32 block;
+	GOBUInt32 time;
+	GOBUInt32 size;
+};
+static struct GOBBlockCache* CacheBlocks = NULL;
+static GOBUInt32 NumCacheBlocks = 0;
+static GOBUInt32 CacheBlockCounter = 0;
+
+// Read ahead buffer
+struct GOBReadBuffer
+{
+	GOBChar* data;
+	GOBChar* dataStart;
+	GOBUInt32 pos;
+	GOBUInt32 size;
+};
+static struct GOBReadBuffer ReadBuffer;
+
+// Decompression buffer
+static GOBChar* DecompBuffer = NULL;
+
+// Stats gathering
+static struct GOBReadStats ReadStats;
+static GOBUInt32 CurrentArchivePos = 0;
+
+// File tables (from the GFC)
+static struct GOBFileTableBasicEntry* FileTableBasic = NULL;
+static struct GOBFileTableExtEntry* FileTableExt = NULL;
+
+// Block tables (from the GFC)
+static struct GOBBlockTableEntry* BlockTable = NULL;
+static GOBUInt32* BlockCRC = NULL;
+static GOBUInt32* CacheFileTable = NULL;
+
+// Do the tables need to be written?
+static GOBBool FileTableDirty = GOB_FALSE;
+
+// Information about open files
+struct OpenFileInfo
+{
+	GOBBool valid;
+	GOBUInt32 startBlock;
+	GOBUInt32 block;
+	GOBUInt32 offset;
+
+	GOBUInt32 pos;
+	GOBUInt32 size;
+};
+
+// Open file table -- indices in this array are passed
+// back to the caller as pseudo file handles.
+static struct OpenFileInfo OpenFiles[GOB_MAX_OPEN_FILES];
+
+// Converting text to lower case -- this isn't very
+// clean.  A common buffer is used to store lower case
+// text.  So its not thread safe... among other things. ;)
+static GOBChar LowerCaseBuffer[GOB_MAX_FILE_NAME_LEN];
+static GOBChar* LowerCase(const GOBChar* name)
+{
+	GOBInt32 i;
+	for (i = 0; name[i]; ++i) {
+		LowerCaseBuffer[i] = (GOBChar)tolower(name[i]);
+	}
+	LowerCaseBuffer[i] = 0;
+
+	return LowerCaseBuffer;
+}
+
+// Checks if a file handle is invalid
+static GOBBool InvalidHandle(GOBFSHandle h)
+{
+	return (GOBUInt32)h == 0xFFFFFFFF ? GOB_TRUE : GOB_FALSE;
+}
+
+// Endian conversion
+#if VV_ENDIAN == VV_ENDIAN_LITTLE
+static GOBUInt32 SwapBytes(GOBUInt32 x)
+{
+	return
+		(x >> 24) |
+		((x >> 8) & 0xFF00) |
+		((x << 8) & 0xFF0000) |
+		(x << 24);
+
+}
+#else
+static GOBUInt32 SwapBytes(GOBUInt32 x)
+{
+	return x;
+}
+#endif
+
+
+// Given a file name, get its index in the FileTable
+static GOBInt32 GetFileTableEntry(const GOBChar* file)
+{
+	GOBUInt32 entry;
+	GOBUInt32 hash;
+	
+	// hash the file name
+	hash = crc32(0L, Z_NULL, 0);
+	hash = crc32(hash, (const unsigned char*)file, strlen(file));
+
+	// linear search for matching a matching hash
+	for (entry = 0; entry < ArchiveNumFiles; ++entry) {
+		if (FileTableBasic[entry].block != GOB_INVALID_BLOCK &&
+			FileTableBasic[entry].hash == hash) 
+		{
+			return entry;
+		}
+	}
+
+	return -1;
+}
+
+// Mark the contents of cache and read buffer invalid
+static GOBVoid InvalidateCache(GOBVoid)
+{
+	GOBUInt32 i;
+	for (i = 0; i < NumCacheBlocks; ++i) {
+		CacheBlocks[i].block = 0xFFFFFFFF;
+	}
+	ReadBuffer.pos = 0xFFFFFFFF;
+}
+
+// Deallocate memory used by cache and read buffer
+static GOBVoid FreeCache(GOBVoid)
+{
+	GOBUInt32 i;
+
+	if (CacheBlocks) {
+		for (i = 0; i < NumCacheBlocks; ++i) {
+			if (CacheBlocks[i].data) MemFuncs.free(CacheBlocks[i].data);
+			CacheBlocks[i].data = NULL;
+		}
+
+		MemFuncs.free(CacheBlocks);
+		NumCacheBlocks = 0;
+		CacheBlocks = NULL;
+	}
+}
+
+// Write the file table to disk if the form of a GFC
+static GOBError CommitFileTable(GOBVoid)
+{
+	GOBUInt32 num;
+	struct GOBFileTableBasicEntry basic;
+	struct GOBFileTableExtEntry ext;
+	struct GOBBlockTableEntry block;
+	
+	// open the GFC
+	GOBFSHandle handle = FSFuncs.open(ControlFileName, GOBACCESS_WRITE);
+	if (InvalidHandle(handle)) return GOBERR_FILE_WRITE;
+
+	// write the magic identifier
+	num = SwapBytes(GOB_MAGIC_IDENTIFIER);
+	if (!FSFuncs.write(handle, &num, sizeof(num))) return GOBERR_FILE_WRITE;
+
+	// write the size of the GOB
+	num = SwapBytes(ArchiveSize);
+	if (!FSFuncs.write(handle, &num, sizeof(num))) return GOBERR_FILE_WRITE;
+
+	// write number of blocks in archive
+	num = SwapBytes(ArchiveNumBlocks);
+	if (!FSFuncs.write(handle, &num, sizeof(num))) return GOBERR_FILE_WRITE;
+
+	// write number of file in archive
+	num = SwapBytes(ArchiveNumFiles);
+	if (!FSFuncs.write(handle, &num, sizeof(num))) return GOBERR_FILE_WRITE;
+
+	// write block table -- with endian conversion
+	for (num = 0; num < ArchiveNumBlocks; ++num) {
+		block.next = SwapBytes(BlockTable[num].next);
+		block.offset = SwapBytes(BlockTable[num].offset);
+		block.size = SwapBytes(BlockTable[num].size);
+
+		if (!FSFuncs.write(handle, &block, sizeof(block))) return GOBERR_FILE_WRITE;
+	}
+	
+	// write block CRCs -- with endian conversion
+	for (num = 0; num < ArchiveNumBlocks; ++num) {
+		BlockCRC[num] = SwapBytes(BlockCRC[num]);
+		if (!FSFuncs.write(handle, &BlockCRC[num], sizeof(BlockCRC[num]))) {
+			return GOBERR_FILE_WRITE;
+		}
+	}
+	
+	// write each basic table entry -- with endian conversion
+	for (num = 0; num < ArchiveNumFiles; ++num) {
+		basic.hash = SwapBytes(FileTableBasic[num].hash);
+		basic.block = SwapBytes(FileTableBasic[num].block);
+		basic.size = SwapBytes(FileTableBasic[num].size);
+
+		if (!FSFuncs.write(handle, &basic, sizeof(basic))) return GOBERR_FILE_WRITE;
+	}
+	
+	// write each extended table entry -- with endian conversion
+	for (num = 0; num < ArchiveNumFiles; ++num) {
+		strcpy(ext.name, FileTableExt[num].name);
+		ext.crc = SwapBytes(FileTableExt[num].crc);
+		ext.time = SwapBytes(FileTableExt[num].time);
+
+		if (!FSFuncs.write(handle, &ext, sizeof(ext))) return GOBERR_FILE_WRITE;
+	}
+
+	// all done
+	FSFuncs.close(&handle);
+	FileTableDirty = GOB_FALSE;
+
+	return GOBERR_OK;
+}
+
+
+static GOBVoid DeallocTables(GOBVoid)
+{
+	if (BlockTable) {
+		// free the block table
+		MemFuncs.free(BlockTable);
+		BlockTable = NULL;
+	}
+
+	if (BlockCRC) {
+		// free the block crc table
+		MemFuncs.free(BlockCRC);
+		BlockCRC = NULL;
+	}
+
+	if (CacheFileTable)
+	{
+		// free the block cache table
+		MemFuncs.free(CacheFileTable);
+		CacheFileTable = NULL;
+	}
+
+	if (FileTableBasic) {
+		// free the basic file table
+		MemFuncs.free(FileTableBasic);
+		FileTableBasic = NULL;
+	}
+
+	if (FileTableExt) {
+		// free the extended file table
+		MemFuncs.free(FileTableExt);
+		FileTableExt = NULL;
+	}
+}
+
+static GOBError AllocTables(GOBUInt32 num_blocks, GOBUInt32 num_files, 
+	GOBBool extended, GOBBool safe)
+{
+	GOBUInt32 num;
+
+	// dump any old tables
+	DeallocTables();
+	
+	// allocate the block table
+	BlockTable = (struct GOBBlockTableEntry*)
+		MemFuncs.alloc(num_blocks * sizeof(struct GOBBlockTableEntry));
+	if (!BlockTable) return GOBERR_NO_MEMORY;
+
+	if (safe) {
+		// allocate the block crc table for verifying data validity
+		BlockCRC = (GOBUInt32*)MemFuncs.alloc(num_blocks * sizeof(GOBUInt32));
+		if (!BlockCRC) return GOBERR_NO_MEMORY;
+	}
+	else {
+		BlockCRC = NULL;
+	}
+
+	if (CacheFileActive)
+	{
+		// allocate the block cache bitfield
+		CacheFileTable = (GOBUInt32*)
+			MemFuncs.alloc((num_blocks / 32 + 1) * 4);
+		if (!CacheFileTable) return GOBERR_NO_MEMORY;
+	}
+
+	// allocate the basic file table
+	FileTableBasic = (struct GOBFileTableBasicEntry*)
+		MemFuncs.alloc(num_files * sizeof(struct GOBFileTableBasicEntry));
+	if (!FileTableBasic) return GOBERR_NO_MEMORY;
+
+	if (extended) {
+		// allocate the extended file table
+		FileTableExt = (struct GOBFileTableExtEntry*)
+			MemFuncs.alloc(num_files * sizeof(struct GOBFileTableExtEntry));
+		if (!FileTableExt) return GOBERR_NO_MEMORY;
+	}
+	else {
+		FileTableExt = NULL;
+	}
+
+	// clear the tables
+	for (num = 0; num < num_files; ++num) {
+		FileTableBasic[num].block = GOB_INVALID_BLOCK;
+		if (FileTableExt) FileTableExt[num].name[0] = 0;
+	}
+
+	for (num = 0; num < num_blocks; ++num) {
+		BlockTable[num].next = GOB_INVALID_BLOCK;
+		BlockTable[num].size = GOB_INVALID_SIZE;
+	}
+
+	return GOBERR_OK;
+}
+
+
+// GOBInit
+// Public function.  Initialize the library.
+GOBError GOBInit(struct GOBMemoryFuncSet* mem, 
+	struct GOBFileSysFuncSet* file, 
+	struct GOBCodecFuncSet* codec,
+	struct GOBCacheFileFuncSet* cache)
+{
+	GOBInt32 i;
+	GOBError err;
+	
+	if (LibraryInit) return GOBERR_ALREADY_INIT;
+	
+	// setup the callbacks
+	MemFuncs = *mem;
+	FSFuncs = *file;
+	CodecFuncs = *codec;
+	if (cache) {
+		CacheFileFuncs = *cache;
+		CacheFileActive = GOB_TRUE;
+	} else {
+		CacheFileActive = GOB_FALSE;
+	}
+
+	// allocate decompression buffer
+	DecompBuffer = (GOBChar*)MemFuncs.alloc(GOB_BLOCK_SIZE + GOB_COMPRESS_OVERHEAD);
+	if (!DecompBuffer) return GOBERR_NO_MEMORY;
+
+	// clear open table
+	for (i = 0; i < GOB_MAX_OPEN_FILES; ++i) {
+		OpenFiles[i].valid = GOB_FALSE;
+	}
+
+	LibraryInit = GOB_TRUE;
+
+	err = GOBSetCacheSize(1);
+	if (err != GOBERR_OK) {
+		LibraryInit = GOB_FALSE;
+		return err;
+	}
+
+	ReadBuffer.data = NULL;
+	err = GOBSetReadBufferSize(128*1024);
+	if (err != GOBERR_OK) {
+		LibraryInit = GOB_FALSE;
+		return err;
+	}
+
+	return GOBERR_OK;
+}
+
+// GOBShutdown
+// Public function.  Close the library.
+GOBError GOBShutdown(GOBVoid)
+{
+	if (!LibraryInit) return GOBERR_NOT_INIT;
+	
+	// if we have an open archive, close it
+	if (!InvalidHandle(ArchiveHandle)) GOBArchiveClose();
+	
+	FreeCache();
+
+	// free read ahead buffer
+	if (ReadBuffer.data) {
+		MemFuncs.free(ReadBuffer.data);
+		ReadBuffer.data = NULL;
+	}
+
+	// free decompression buffer
+	MemFuncs.free(DecompBuffer);
+
+	// free the file and block tables
+	DeallocTables();
+
+	LibraryInit = GOB_FALSE;
+	return GOBERR_OK;
+}
+
+
+// GOBArchiveCreate
+// Public function.  Create an empty GFC and GOB.
+GOBError GOBArchiveCreate(const GOBChar* file)
+{
+	GOBChar fname[GOB_MAX_FILE_NAME_LEN];
+	GOBFSHandle handle;
+	GOBError error;
+
+	if (!LibraryInit) return GOBERR_NOT_INIT;
+	if (!InvalidHandle(ArchiveHandle)) return GOBERR_ALREADY_OPEN;
+
+	// Allocate the max space for tables
+	error = AllocTables(GOB_MAX_BLOCKS, GOB_MAX_FILES, GOB_TRUE, GOB_TRUE);
+	if (GOBERR_OK != error) {
+		return error;
+	}
+	
+	// create an empty GFC
+	_snprintf(ControlFileName, GOB_MAX_FILE_NAME_LEN, "%s.gfc", file);
+
+	ArchiveSize = 0;
+	ArchiveNumBlocks = 0;
+	ArchiveNumFiles = 0;
+	CacheFileActive = GOB_FALSE;
+	
+	CommitFileTable();
+
+	// create an empty GOB
+	_snprintf(fname, GOB_MAX_FILE_NAME_LEN, "%s.gob", file);
+	handle = FSFuncs.open(fname, GOBACCESS_WRITE);
+	if (InvalidHandle(handle)) return GOBERR_CANNOT_CREATE;
+	
+	FSFuncs.close(&handle);
+
+	return GOBERR_OK;	
+}
+
+// GOBArchiveOpen
+// Public function.  Open a GOB file and cache file tables.
+GOBError GOBArchiveOpen(const GOBChar* file, GOBAccessType atype, 
+	GOBBool extended, GOBBool safe)
+{
+	GOBChar fname[GOB_MAX_FILE_NAME_LEN];
+	GOBFSHandle handle;
+	GOBUInt32 magic;
+	GOBUInt32 i;
+	GOBError error;
+
+	if (!LibraryInit) return GOBERR_NOT_INIT;
+	if (!InvalidHandle(ArchiveHandle)) return GOBERR_ALREADY_OPEN;
+
+	// open the GFC
+	_snprintf(ControlFileName, GOB_MAX_FILE_NAME_LEN, "%s.gfc", file);
+	handle = FSFuncs.open(ControlFileName, atype);
+	if (InvalidHandle(handle)) return GOBERR_FILE_NOT_FOUND;
+
+	// read and check the magic
+	if (!FSFuncs.read(handle, &magic, sizeof(magic))) return GOBERR_FILE_READ;
+	if (SwapBytes(magic) != GOB_MAGIC_IDENTIFIER) return GOBERR_NOT_GOB_FILE;
+
+	// read the GOB archive size
+	if (!FSFuncs.read(handle, &ArchiveSize, sizeof(ArchiveSize))) return GOBERR_FILE_READ;
+	ArchiveSize = SwapBytes(ArchiveSize);
+
+	// read the number of blocks
+	if (!FSFuncs.read(handle, &ArchiveNumBlocks, sizeof(ArchiveNumBlocks))) return GOBERR_FILE_READ;
+	ArchiveNumBlocks = SwapBytes(ArchiveNumBlocks);
+
+	// read the number of files
+	if (!FSFuncs.read(handle, &ArchiveNumFiles, sizeof(ArchiveNumFiles))) return GOBERR_FILE_READ;
+	ArchiveNumFiles = SwapBytes(ArchiveNumFiles);
+	
+	// Allocate the space for tables
+	if (atype == GOBACCESS_READ) {
+		error = AllocTables(ArchiveNumBlocks, ArchiveNumFiles, extended, safe);
+	}
+	else {
+		error = AllocTables(GOB_MAX_BLOCKS, GOB_MAX_FILES, extended, safe);
+	}
+	if (GOBERR_OK != error) {
+		return error;
+	}
+
+	// read the block table
+	if (ArchiveNumBlocks && 
+		!FSFuncs.read(handle, BlockTable, 
+		sizeof(struct GOBBlockTableEntry) * ArchiveNumBlocks))
+	{
+		return GOBERR_FILE_READ;
+	}
+
+	if (BlockCRC) {
+		// read the block CRCs
+		if (ArchiveNumBlocks && 
+			!FSFuncs.read(handle, BlockCRC, 
+			sizeof(GOBUInt32) * ArchiveNumBlocks))
+		{
+			return GOBERR_FILE_READ;
+		}
+	}
+	else {
+		// skip block CRCs
+		FSFuncs.seek(handle, sizeof(GOBUInt32) * ArchiveNumBlocks, 
+			GOBSEEK_CURRENT);
+	}
+
+	if (CacheFileActive)
+	{
+		// clear the block cache table
+		for (i = 0; i < ArchiveNumBlocks / 32; ++i) {
+			CacheFileTable[i] = 0;
+		}
+	}
+
+	// open the cache file
+	if (CacheFileActive && !CacheFileFuncs.open(ArchiveSize)) {
+		CacheFileActive = GOB_FALSE;
+	}
+
+	// endian convert the table
+	for (i = 0; i < ArchiveNumBlocks; ++i) {
+		BlockTable[i].next = SwapBytes(BlockTable[i].next);
+		BlockTable[i].offset = SwapBytes(BlockTable[i].offset);
+		BlockTable[i].size = SwapBytes(BlockTable[i].size);
+
+		if (BlockCRC) {
+			BlockCRC[i] = SwapBytes(BlockCRC[i]);
+		}
+	}
+
+	// read the basic file table
+	if (ArchiveNumFiles &&
+		!FSFuncs.read(handle, FileTableBasic, 
+		sizeof(struct GOBFileTableBasicEntry) * ArchiveNumFiles))
+	{
+		return GOBERR_FILE_READ;
+	}
+
+	// endian convert the table
+	for (i = 0; i < ArchiveNumFiles; ++i) {
+		FileTableBasic[i].hash = SwapBytes(FileTableBasic[i].hash);
+		FileTableBasic[i].block = SwapBytes(FileTableBasic[i].block);
+		FileTableBasic[i].size = SwapBytes(FileTableBasic[i].size);
+	}
+
+	// if we have memory for the extended file table
+	if (FileTableExt) {
+		// read the table
+		if (ArchiveNumFiles &&
+			!FSFuncs.read(handle, FileTableExt, 
+			sizeof(struct GOBFileTableExtEntry) * ArchiveNumFiles))
+		{
+			return GOBERR_FILE_READ;
+		}
+
+		// endian convert the table
+		for (i = 0; i < ArchiveNumFiles; ++i) {
+			FileTableExt[i].crc = SwapBytes(FileTableExt[i].crc);
+			FileTableExt[i].time = SwapBytes(FileTableExt[i].time);
+		}
+	}
+	
+	FSFuncs.close(&handle);
+
+	// open the GOB
+	_snprintf(fname, GOB_MAX_FILE_NAME_LEN, "%s.gob", file);
+	ArchiveHandle = FSFuncs.open(fname, atype);
+	if (InvalidHandle(ArchiveHandle)) return GOBERR_FILE_NOT_FOUND;
+
+	// initialize stats gathering
+	CurrentArchivePos = 0;
+	ReadStats.bufferUsed = 0;
+	ReadStats.bytesRead = 0;
+	ReadStats.cacheBytesRead = 0;
+	ReadStats.cacheBytesWrite = 0;
+	ReadStats.totalSeeks = 0;
+	ReadStats.farSeeks = 0;
+	ReadStats.filesOpened = 0;
+
+	return GOBERR_OK;
+}
+
+// GOBArchiveClose
+// Public function.  Close an open GOB archive.
+GOBError GOBArchiveClose(GOBVoid)
+{
+	GOBInt32 i;
+
+	if (!LibraryInit) return GOBERR_NOT_INIT;
+	if (InvalidHandle(ArchiveHandle)) return GOBERR_NOT_OPEN;
+
+	// close any open files
+	for (i = 0; i < GOB_MAX_OPEN_FILES; ++i) {
+		GOBClose(i);
+	}
+
+	// close the GOB
+	FSFuncs.close(&ArchiveHandle);
+	ArchiveHandle = (GOBFSHandle*)0xFFFFFFFF;
+
+	// commit the file table if we're updated it
+	if (FileTableDirty) {
+		CommitFileTable();
+	}
+	
+	// close the cache file
+	if (CacheFileActive) {
+		CacheFileFuncs.close();
+		CacheFileActive = GOB_FALSE;
+	}
+
+	return GOBERR_OK;
+}
+
+static int CDECL SortBlockDescsCallback(const void* elem1, const void* elem2)
+{
+	return (int)((struct GOBBlockTableEntry *)elem1)->offset - 
+		(int)((struct GOBBlockTableEntry *)elem2)->offset;
+}
+
+// GOBArchiveCheckMarkers
+// Public function.  Check start/end markers to check approximate validity of GOB file
+GOBError GOBArchiveCheckMarkers(GOBVoid)
+{
+	GOBUInt32 i;
+	GOBUInt32 valid_blocks;
+	struct GOBBlockTableEntry *blocks;
+	GOBUInt32 block;
+	GOBUInt32 start_marker;
+	GOBUInt32 end_marker;
+	GOBBool ok;
+
+	if (!LibraryInit) return GOBERR_NOT_INIT;
+	if (InvalidHandle(ArchiveHandle)) return GOBERR_NOT_OPEN;
+
+	// count valid blocks
+	valid_blocks = 0;
+	for (i = 0; i < ArchiveNumBlocks; i++)
+	{
+		if (BlockTable[i].size != GOB_INVALID_SIZE && 
+			BlockTable[i].next != GOB_INVALID_BLOCK)
+		{
+			valid_blocks++;
+		}
+	}
+
+	// arcvive is empty
+	if (valid_blocks == 0)
+	{
+		return GOBERR_OK;
+	}
+
+	// alloc mem for valid block list
+	blocks = (GOBBlockTableEntry *) MemFuncs.alloc(sizeof(*blocks) * valid_blocks);
+	if (blocks == NULL)
+	{
+		return GOBERR_NO_MEMORY;
+	}
+
+	// copy valid blocks descriptions
+	block = 0;
+	for (i = 0; i < ArchiveNumBlocks; ++i)
+	{
+		if (BlockTable[i].size != GOB_INVALID_SIZE && 
+			BlockTable[i].next != GOB_INVALID_BLOCK)
+		{
+			blocks[block++] = BlockTable[i];
+		}
+	}
+	assert(block == valid_blocks);
+
+	// and sort 'em
+	qsort(blocks, valid_blocks, sizeof(*blocks), SortBlockDescsCallback);
+
+	// suppress some warnings
+	start_marker = 0;
+	end_marker = 0;
+
+	// now scan entire archive for start-of-block and end-of-block markers
+	for (i = 0; i < valid_blocks; i++)
+	{
+		ok = GOB_TRUE;
+		ok = ok && !FSFuncs.seek(ArchiveHandle, blocks[i].offset, GOBSEEK_START);
+		ok = ok && FSFuncs.read(ArchiveHandle, &start_marker, sizeof(GOBUInt32)) == sizeof(GOBUInt32);
+		ok = ok && !FSFuncs.seek(ArchiveHandle, blocks[i].offset + blocks[i].size - sizeof(GOBUInt32), GOBSEEK_START);
+		ok = ok && FSFuncs.read(ArchiveHandle, &end_marker, sizeof(GOBUInt32)) == sizeof(GOBUInt32);
+		if (!ok || 
+			SwapBytes(start_marker) != GOBMARKER_STARTBLOCK || 
+			SwapBytes(end_marker) != GOBMARKER_ENDBLOCK)
+		{
+			MemFuncs.free(blocks);
+			
+			return GOBERR_NOT_GOB_FILE;
+		}
+	}
+	
+	MemFuncs.free(blocks);
+	
+	return GOBERR_OK;
+}
+
+// GOBArchiveCreate
+// Public function.  Create an empty GFC and GOB.
+GOBUInt32 GOBGetSlack(GOBUInt32 x)
+{
+	GOBUInt32 align = x % GOB_BLOCK_ALIGNMENT;
+	if (align) return GOB_BLOCK_ALIGNMENT - align;
+	return 0;
+}
+
+// GOBOpen
+// Public function.  Open a file inside a GOB.
+GOBError GOBOpen(GOBChar* file, GOBHandle* handle)
+{
+	GOBInt32 entry;
+	GOBChar* lfile;
+	
+	if (!LibraryInit) return GOBERR_NOT_INIT;
+	if (InvalidHandle(ArchiveHandle)) return GOBERR_NOT_OPEN;
+
+	// find a free handle
+	for (*handle = 0; *handle < GOB_MAX_OPEN_FILES; (*handle) += 1) {
+		if (!OpenFiles[*handle].valid) break;
+	}
+
+	if (*handle >= GOB_MAX_OPEN_FILES) return GOBERR_TOO_MANY_OPEN;
+
+	// find the file in the table
+	lfile = LowerCase(file);
+
+	entry = GetFileTableEntry(lfile);
+
+	if (entry == -1) return GOBERR_FILE_NOT_FOUND;
+
+	// setup the open file
+	OpenFiles[*handle].startBlock = OpenFiles[*handle].block = 
+		FileTableBasic[entry].block;
+	OpenFiles[*handle].size = FileTableBasic[entry].size;
+	OpenFiles[*handle].offset = 0;
+	OpenFiles[*handle].pos = 0;
+
+	OpenFiles[*handle].valid = GOB_TRUE;
+
+	++ReadStats.filesOpened;
+	
+	return GOBERR_OK;
+}
+
+// GOBOpenCode
+// Public function.  Open file with a code inside a GOB.
+GOBError GOBOpenCode(GOBInt32 code, GOBHandle* handle)
+{	
+	if (!LibraryInit) return GOBERR_NOT_INIT;
+	if (InvalidHandle(ArchiveHandle)) return GOBERR_NOT_OPEN;
+
+	// find a free handle
+	for (*handle = 0; *handle < GOB_MAX_OPEN_FILES; (*handle) += 1) {
+		if (!OpenFiles[*handle].valid) break;
+	}
+
+	if (*handle >= GOB_MAX_OPEN_FILES) return GOBERR_TOO_MANY_OPEN;
+
+	// setup the open file
+	OpenFiles[*handle].startBlock = OpenFiles[*handle].block = 
+		FileTableBasic[code].block;
+	OpenFiles[*handle].size = FileTableBasic[code].size;
+	OpenFiles[*handle].offset = 0;
+	OpenFiles[*handle].pos = 0;
+
+	OpenFiles[*handle].valid = GOB_TRUE;
+
+	++ReadStats.filesOpened;
+	
+	return GOBERR_OK;
+}
+
+// GOBClose
+// Public function.  Close a file.
+GOBError GOBClose(GOBHandle handle)
+{
+	if (!LibraryInit) return GOBERR_NOT_INIT;
+	if (InvalidHandle(ArchiveHandle)) return GOBERR_NOT_OPEN;
+	if (!OpenFiles[handle].valid) return GOBERR_NOT_OPEN;
+	
+	// close the file by simply invalidating the open
+	// file table entry
+	OpenFiles[handle].valid = GOB_FALSE;
+	
+	return GOBERR_OK;
+}
+
+static GOBUInt32 RawRead(GOBVoid* buffer, GOBUInt32 size, GOBUInt32 pos)
+{
+	GOBUInt32 bytes;
+
+	// Reads _must_ be aligned otherwise things get very slow
+	if (pos % GOB_BLOCK_ALIGNMENT) {
+		return 0;
+	}
+	if ((GOBUInt32)buffer % GOB_MEM_ALIGNMENT) {
+		return 0;
+	}
+	
+	// seek
+	if (FSFuncs.seek(ArchiveHandle, pos, GOBSEEK_START)) return 0;
+	
+	if (CurrentArchivePos != pos) ++ReadStats.totalSeeks;
+	if (pos > CurrentArchivePos + GOB_BLOCK_ALIGNMENT ||
+		CurrentArchivePos > pos + GOB_BLOCK_ALIGNMENT)
+	{
+		++ReadStats.farSeeks;
+	}
+
+	// read
+	bytes = FSFuncs.read(ArchiveHandle, buffer, size);
+	
+	ReadStats.bytesRead += bytes;
+	CurrentArchivePos = pos + bytes;
+	
+	return bytes;
+}
+
+static GOBUInt32 CacheRawRead(GOBVoid* buffer, GOBUInt32 size, GOBUInt32 pos)
+{
+	GOBUInt32 bytes;
+
+	// Reads _must_ be aligned otherwise things get very slow
+	if (pos % GOB_BLOCK_ALIGNMENT) {
+		return 0;
+	}
+	if ((GOBUInt32)buffer % GOB_MEM_ALIGNMENT) {
+		return 0;
+	}
+	
+	// seek
+	if (CacheFileFuncs.seek(pos)) return 0;
+	
+	// read
+	bytes = CacheFileFuncs.read(buffer, size);
+	ReadStats.cacheBytesRead += bytes;
+
+	return bytes;
+}
+
+static GOBUInt32 CacheRawWrite(GOBVoid* buffer, GOBUInt32 size, GOBUInt32 pos)
+{
+	GOBUInt32 bytes;
+
+	// Writes _must_ be aligned otherwise things get very slow
+	if (pos % GOB_BLOCK_ALIGNMENT) {
+		return 0;
+	}
+	if ((GOBUInt32)buffer % GOB_MEM_ALIGNMENT) {
+		return 0;
+	}
+	
+	// seek
+	if (CacheFileFuncs.seek(pos)) return 0;
+	
+	// write
+	bytes = CacheFileFuncs.write(buffer, size);	
+	ReadStats.cacheBytesWrite += bytes;
+	
+	return bytes;
+}
+
+static GOBInt32 BlockReadLow(GOBUInt32 block)
+{
+	GOBUInt32 pos;
+	GOBUInt32 bytes;
+	GOBBool cache_read;
+	GOBBool cache_write;
+	GOBBool cache_fail;
+
+	pos = 0;
+	cache_read = GOB_FALSE;
+	cache_write = GOB_FALSE;
+	cache_fail = GOB_FALSE;
+	
+	for (;;) {	
+		// is the block in the read ahead buffer?
+		if (ReadBuffer.pos <= BlockTable[block].offset + pos &&
+			ReadBuffer.pos + ReadBuffer.size > BlockTable[block].offset + pos)
+		{
+			GOBUInt32 buffer_offset;
+			GOBUInt32 buffer_size;
+			
+			// use data in the read buffer
+			buffer_offset = BlockTable[block].offset + pos - ReadBuffer.pos;
+			buffer_size = ReadBuffer.size - buffer_offset;
+
+			// clamp size
+			if (buffer_size > BlockTable[block].size - pos) {
+				buffer_size = BlockTable[block].size - pos;
+			}
+			
+			memcpy(&DecompBuffer[pos], &ReadBuffer.dataStart[buffer_offset], buffer_size);
+
+			pos += buffer_size;
+		}
+
+		// got enough data
+		if (pos == BlockTable[block].size) break;
+
+		// refill read buffer
+		ReadBuffer.pos = BlockTable[block].offset + pos;
+		ReadBuffer.pos -= ReadBuffer.pos % GOB_BLOCK_ALIGNMENT;
+
+		// check if block is in the external cache system
+		if (CacheFileActive &&
+			CacheFileTable[block / 32] & (1 << (block % 32)))
+		{
+			if (CacheRawRead(ReadBuffer.dataStart, 
+				ReadBuffer.size, ReadBuffer.pos))
+			{
+				cache_read = GOB_TRUE;
+				continue;
+			}
+		}
+
+		// read block from archive
+		bytes = RawRead(ReadBuffer.dataStart, ReadBuffer.size, ReadBuffer.pos);
+		if (bytes != ReadBuffer.size && 
+			bytes != ArchiveSize - ReadBuffer.pos) 
+		{
+			return -1; // Main read fail error code
+		}
+		
+		// write block to cache file
+		if (CacheFileActive)
+		{
+			if (CacheRawWrite(ReadBuffer.dataStart, bytes, 
+				ReadBuffer.pos) == bytes)
+			{
+				cache_write = GOB_TRUE;
+			}
+			else
+			{
+				cache_fail = GOB_TRUE;
+			}
+		}
+	}
+
+	if (cache_write) {
+		if (!cache_fail) return 2;
+		return 0;
+	}
+
+	if (cache_read) return 1;
+	return 0;
+}
+
+static GOBBool BlockReadWithCache(GOBUInt32 block)
+{
+	GOBInt32 i;
+	
+	for (i = 0; i < GOB_READ_RETRYS; ++i) {
+		GOBInt32 result;
+
+		// read the data
+		result = BlockReadLow(block);
+		if (result >= 0)
+		{
+			if (BlockCRC) {
+				// crc check
+				GOBUInt32 crc;
+
+				crc = adler32(0L, Z_NULL, 0);
+				crc = adler32(crc, (const unsigned char*)DecompBuffer, 
+					BlockTable[block].size);
+				
+				if (BlockCRC[block] != crc) {
+					// crc mismatch, we must have got bad data --
+					// try invalidating the cache and retrying...
+					if (CacheFileActive) {
+						CacheFileTable[block / 32] &= ~(1 << (block % 32));
+					}
+					ReadBuffer.pos = 0xFFFFFFFF;
+					continue;
+				}
+			}
+
+			// if cache write occurred -- mark block as cached
+			if (result == 2) {
+				CacheFileTable[block / 32] |= (1 << (block % 32));
+			}
+			
+			// read success, crc success (or no check performed)
+			return GOB_TRUE;
+		}
+	}
+
+	// multiple read/crc failures
+	return GOB_FALSE;
+}
+
+static GOBUInt32 BlockRead(GOBVoid* buffer, GOBUInt32 block)
+{
+	GOBUInt32 size;
+	GOBInt32 codec_index;
+	GOBChar *compressed_data;
+	
+	// read block from cache or archive
+	if (!BlockReadWithCache(block))
+	{
+		return GOB_INVALID_SIZE;
+	}
+	
+	// decompress
+	codec_index = 0;
+	size = 0; // Initialize to satisfy compiler
+	compressed_data = DecompBuffer + sizeof(GOBUInt32); // skip start-of-block marker
+	while (codec_index < CodecFuncs.codecs) {
+		// Check if codec matches
+		if (*compressed_data == CodecFuncs.codec[codec_index].tag) {
+			size = GOB_BLOCK_SIZE;
+			if (CodecFuncs.codec[codec_index].decompress(compressed_data + 1, 
+				BlockTable[block].size - 1 - sizeof(GOBUInt32) * 2, buffer, &size)) {
+				return GOB_INVALID_SIZE;
+			}
+			break;
+		}
+		codec_index++;
+	}
+
+	// If no suitable codecs were found, we're screwed
+	if (codec_index == CodecFuncs.codecs) {
+		return GOB_INVALID_SIZE;
+	}
+
+	if (ProfileReadCallback && ProfileEnabled) {
+		// register current read command
+		ProfileReadCallback(block);
+	}
+
+	return size;
+}
+
+static GOBVoid FillCacheBlock(GOBUInt32 block, GOBUInt32 index)
+{
+	CacheBlocks[index].time = CacheBlockCounter++;
+	CacheBlocks[index].block = block;
+	CacheBlocks[index].size = BlockRead(CacheBlocks[index].data, block);
+}
+
+static GOBInt32 FindBestCacheBlock(GOBUInt32 block)
+{
+	GOBInt32 i;
+	GOBUInt32 oldest_time;
+	GOBInt32 oldest_index;
+
+	oldest_time = 0xFFFFFFFF;
+	oldest_index = -1;
+
+	for (i = 0; i < (signed)NumCacheBlocks; ++i) {
+		if (CacheBlocks[i].block == block) {
+			// if block is in this read buffer, use it
+			return i;
+		}
+		
+		// find the buffer that hasn't been accessed
+		// for the longest time
+		if (CacheBlocks[i].time < oldest_time) {
+			oldest_time = CacheBlocks[i].time;
+			oldest_index = i;
+		}
+	}
+
+	// use the buffer that hasn't been accessed
+	// in the longest time
+	return oldest_index;
+}
+
+// GOBRead
+// Public function.  Read from an open file using
+// a funky read-ahead buffer system.
+GOBUInt32 GOBRead(GOBVoid* buffer, GOBUInt32 size, GOBHandle handle)
+{
+	GOBUInt32 pos;
+	GOBInt32 cache_id;
+	
+	if (!LibraryInit) return 0;
+	if (InvalidHandle(ArchiveHandle)) return 0;
+	if (!OpenFiles[handle].valid) return 0;
+
+	// make sure we're reading within the file
+	if (OpenFiles[handle].pos + size > OpenFiles[handle].size) {
+		size = OpenFiles[handle].size - OpenFiles[handle].pos;
+		if (!size) return 0;
+	}
+	
+	cache_id = FindBestCacheBlock(OpenFiles[handle].block);
+	if (cache_id < 0) return GOB_INVALID_SIZE;
+
+	pos = OpenFiles[handle].pos;
+
+	for (;;) {
+		// are looking for data inside the read buffer?
+		if (CacheBlocks[cache_id].block == OpenFiles[handle].block) {
+			// move any relevant data from the read buffer to the target buffer
+			GOBUInt32 buffer_size;
+			
+			// calc size of data we want from current buffer
+			buffer_size = CacheBlocks[cache_id].size - OpenFiles[handle].offset;
+			if (buffer_size > size) buffer_size = size;
+			
+			// move from read buffer into output buffer
+			memcpy(&((char*)buffer)[OpenFiles[handle].pos - pos], 
+				&CacheBlocks[cache_id].data[OpenFiles[handle].offset], 
+				buffer_size);
+
+			// update file position
+			OpenFiles[handle].pos += buffer_size;
+			OpenFiles[handle].offset += buffer_size;
+			
+			// if we've completed this block -- move to next
+			if (OpenFiles[handle].offset == CacheBlocks[cache_id].size) {
+				OpenFiles[handle].block = BlockTable[OpenFiles[handle].block].next;
+				OpenFiles[handle].offset = 0;
+			}
+			
+			CacheBlocks[cache_id].time = CacheBlockCounter++;
+		
+			ReadStats.bufferUsed += buffer_size;
+			size -= buffer_size;
+			if (size == 0) break;
+		}
+
+		// refill the buffer
+		FillCacheBlock(OpenFiles[handle].block, cache_id);
+		if (CacheBlocks[cache_id].size == GOB_INVALID_SIZE) {
+			CacheBlocks[cache_id].block = GOB_INVALID_BLOCK;
+			return GOB_INVALID_SIZE;
+		}
+
+		// reading off the end of the archive
+		if (CacheBlocks[cache_id].block != OpenFiles[handle].block) break;
+	}
+	
+	return OpenFiles[handle].pos - pos;
+}
+
+// GOBSeek
+// Public function.  Seek to a position in an open file.
+GOBError GOBSeek(GOBHandle handle, GOBUInt32 offset, GOBSeekType type, GOBUInt32* pos)
+{
+	GOBUInt32 blocks;
+	
+	if (!LibraryInit) return GOBERR_NOT_INIT;
+	if (InvalidHandle(ArchiveHandle)) return GOBERR_NOT_OPEN;
+	if (!OpenFiles[handle].valid) return GOBERR_NOT_OPEN;
+	
+	// find a new position based on the seek type
+	switch (type) {
+	case GOBSEEK_START:
+		*pos = offset;
+		break;
+
+	case GOBSEEK_CURRENT:
+		*pos = OpenFiles[handle].pos + offset;
+		break;
+
+	case GOBSEEK_END:
+		*pos = OpenFiles[handle].size + offset;
+		break;
+
+	default:
+		return GOBERR_INVALID_SEEK;
+	}
+
+	// check to make sure we're still in the file
+	if (*pos > OpenFiles[handle].size) {
+		return GOBERR_INVALID_SEEK;
+	}
+
+	// update the file position
+	OpenFiles[handle].pos = *pos;
+
+	// update block
+	blocks = *pos / GOB_BLOCK_SIZE;
+	OpenFiles[handle].block = OpenFiles[handle].startBlock;
+	while (blocks--) {
+		OpenFiles[handle].block = BlockTable[OpenFiles[handle].block].next;
+	}
+
+	// update position inside block
+	OpenFiles[handle].offset = *pos % GOB_BLOCK_SIZE;
+
+	return GOBERR_OK;
+}
+
+
+static GOBUInt32 FindFreeBlock(GOBVoid)
+{
+	GOBInt32 i;
+	for (i = 0; i < GOB_MAX_BLOCKS; ++i) {
+		if (BlockTable[i].next == GOB_INVALID_BLOCK) return i;
+	}
+	return GOB_MAX_BLOCKS;
+}
+
+// GOBWrite
+// Public function.  Write an entire file.  The file should not be open!
+GOBError GOBWrite(GOBVoid* buffer, GOBUInt32 size, GOBUInt32 mtime, const GOBChar* file, GOBUInt32 codec_mask)
+{
+	GOBHandle handle;
+	GOBInt32 slack;
+	GOBChar* lfile;
+	GOBUInt32 hash;
+	GOBUInt32 crc;
+	GOBInt32 i;
+	GOBChar* out;
+	GOBUInt32 pos;
+	GOBUInt32 last_block;
+	GOBInt32 codec_index;
+	GOBInt32 compression_ratio;
+	GOBChar* out_data;
+	GOBUInt32 compressed_size;
+	
+	if (!LibraryInit) return GOBERR_NOT_INIT;
+	if (InvalidHandle(ArchiveHandle)) return GOBERR_NOT_OPEN;
+	if (!FileTableExt) return GOBERR_NO_EXTENDED;
+	if (!BlockCRC) return GOBERR_NO_EXTENDED;
+
+	InvalidateCache();
+
+	// delete the file if it exists
+	GOBDelete(file);
+
+	// find a free entry in the file table
+	for (handle = 0; handle < GOB_MAX_FILES; ++handle) {
+		if (FileTableBasic[handle].block == GOB_INVALID_BLOCK) break;
+	}
+
+	if (handle >= GOB_MAX_FILES) return GOBERR_TOO_MANY_FILES;
+	if (handle >= (GOBInt32)ArchiveNumFiles) ArchiveNumFiles = handle + 1;
+
+	// move to the end of the GOB
+	if (FSFuncs.seek(ArchiveHandle, 0, GOBSEEK_END)) {
+		return GOBERR_FILE_WRITE;
+	}
+	
+	// alloc compression buffer
+	out = (GOBChar*)MemFuncs.alloc(GOB_BLOCK_SIZE + GOB_COMPRESS_OVERHEAD);
+
+	last_block = GOB_MAX_BLOCKS - 1;
+
+	for (pos = 0; pos < size; pos += GOB_BLOCK_SIZE) {
+		GOBUInt32 block;
+		GOBUInt32 in_size;
+
+		// get a free block
+		block = FindFreeBlock();
+		if (block >= GOB_MAX_BLOCKS) return GOBERR_TOO_MANY_BLOCKS;
+		if (block >= ArchiveNumBlocks) ArchiveNumBlocks = block + 1;
+
+		// if this is not the first block, mark next block for the last block
+		// else assign the first block in file table
+		if (pos != 0) BlockTable[last_block].next = block;
+		else FileTableBasic[handle].block = block;
+		
+		// invalidate the next block
+		BlockTable[block].next = GOB_MAX_BLOCKS;
+
+		// compute the decompressed block size
+		in_size = size - pos;
+		if (in_size > GOB_BLOCK_SIZE) in_size = GOB_BLOCK_SIZE;
+
+		// compress block
+		
+		for (
+			codec_index = 0;
+			codec_index < CodecFuncs.codecs;
+			codec_index++)
+		{
+			if ( ! (GOB_CODEC_MASK(codec_index) & codec_mask) )
+			{
+				// skip if this codec is not listed as one of the allowed ones
+				continue;
+			}
+			BlockTable[block].size = GOB_BLOCK_SIZE + GOB_COMPRESS_OVERHEAD;
+			out_data = out;
+			*(GOBUInt32*)out_data = SwapBytes(GOBMARKER_STARTBLOCK);
+			out_data += sizeof(GOBUInt32);
+			*out_data = CodecFuncs.codec[codec_index].tag;
+			out_data++;
+			if (CodecFuncs.codec[codec_index].compress(&((GOBChar*)buffer)[pos],
+				in_size, out_data, &BlockTable[block].size)) 
+			{
+				return GOBERR_COMPRESS_FAIL;
+			}
+			out_data += BlockTable[block].size;
+			*(GOBUInt32*)out_data = SwapBytes(GOBMARKER_ENDBLOCK);
+			out_data += sizeof(GOBUInt32);
+
+			// Adjust for the prefixed start-of-block marker and codec tag and trailing end-of-block marker
+			compressed_size = BlockTable[block].size;
+			BlockTable[block].size += 1 + sizeof(GOBUInt32) * 2;
+
+			// Check compression result
+			compression_ratio = compressed_size * 100 / in_size;
+			if (compression_ratio <= CodecFuncs.codec[codec_index].max_ratio)
+			{
+				// Compressed result is under par.  Let's go with it
+				break;
+			}
+
+			// Otherwise, try the next compressor
+		}
+
+		// If no suitable codecs were found, take our ball and go home
+		if (codec_index == CodecFuncs.codecs) return GOBERR_NO_SUITABLE_CODEC;
+
+		// compute and store the CRC
+		BlockCRC[block] = adler32(0L, Z_NULL, 0);
+		BlockCRC[block] = adler32(BlockCRC[block], (const unsigned char*)out, 
+					BlockTable[block].size);
+
+		// write block
+		if (FSFuncs.write(ArchiveHandle, out, BlockTable[block].size) != 
+			(signed)BlockTable[block].size) 
+		{
+			return GOBERR_FILE_WRITE;
+		}
+
+		// compute the slack (to keep alignment)
+		slack = GOBGetSlack(BlockTable[block].size);
+	
+		// write the slack space
+		memset(out, 0, slack);
+		if (FSFuncs.write(ArchiveHandle, out, slack) != slack) {
+			return GOBERR_FILE_WRITE;
+		}
+	
+		BlockTable[block].offset = ArchiveSize;
+		ArchiveSize += BlockTable[block].size + slack;
+
+		last_block = block;
+	}
+
+	MemFuncs.free(out);
+
+	lfile = LowerCase(file);
+
+	// calculate file name hash
+	hash = crc32(0L, Z_NULL, 0);
+	hash = crc32(hash, (const unsigned char*)lfile, strlen(lfile));
+	
+	// make sure hash is unique
+	for (i = 0; i < GOB_MAX_FILES; ++i) {
+		if (i != handle &&
+			FileTableBasic[i].block != GOB_INVALID_BLOCK && 
+			FileTableBasic[i].hash == hash) 
+		{
+			return GOBERR_DUP_HASH;
+		}
+	}
+
+	// update the file tables
+	FileTableBasic[handle].hash = hash;
+	FileTableBasic[handle].size = size;
+
+	strcpy(FileTableExt[handle].name, lfile);
+	
+	crc = crc32(0L, Z_NULL, 0);
+	crc = crc32(crc, (const unsigned char*)buffer, size);
+	FileTableExt[handle].crc = crc;
+	
+	FileTableExt[handle].time = mtime;
+
+	FileTableDirty = GOB_TRUE;
+	return GOBERR_OK;
+}
+
+// GOBDelete
+// Public function.  Delete a file from a GOB.  The file should not be open!
+GOBError GOBDelete(const GOBChar* file)
+{
+	GOBInt32 entry;
+	GOBChar* lfile;
+	GOBUInt32 block;
+
+	if (!LibraryInit) return GOBERR_NOT_INIT;
+	if (InvalidHandle(ArchiveHandle)) return GOBERR_NOT_OPEN;
+	if (!FileTableExt) return GOBERR_NO_EXTENDED;
+	if (!BlockCRC) return GOBERR_NO_EXTENDED;
+
+	// find the file in the table
+	lfile = LowerCase(file);
+	
+	entry = GetFileTableEntry(lfile);
+	if (entry == -1) return GOBERR_FILE_NOT_FOUND;
+
+	// invalidate blocks
+	block = FileTableBasic[entry].block;
+	do {
+		GOBUInt32 next;
+		next = BlockTable[block].next;
+		BlockTable[block].next = GOB_INVALID_BLOCK;
+		block = next;
+	 } while(block != GOB_MAX_BLOCKS);
+
+	// invalidate the file
+	FileTableBasic[entry].block = GOB_INVALID_BLOCK;
+
+	FileTableDirty = GOB_TRUE;
+
+	return GOBERR_OK;
+}
+
+// GOBRearrange
+// Public function.  Sorts the blocks in an archive.
+GOBError GOBRearrange(const GOBChar* file, const GOBUInt32* xlat, GOBFileSysRenameFunc _rename)
+{
+	GOBError err;
+	GOBVoid* buffer;
+	GOBInt32 slack;
+	GOBVoid* slack_buf;
+	GOBUInt32 i;
+	GOBUInt32 size;
+	GOBFSHandle temp_handle;
+	GOBChar full_name[GOB_MAX_FILE_NAME_LEN];
+	
+	if (!LibraryInit) return GOBERR_NOT_INIT;
+	if (!InvalidHandle(ArchiveHandle)) return GOBERR_ALREADY_OPEN;
+	if (!FileTableExt) return GOBERR_NO_EXTENDED;
+	if (!BlockCRC) return GOBERR_NO_EXTENDED;
+
+	// start things up
+	err = GOBArchiveOpen(file, GOBACCESS_READ, GOB_TRUE, GOB_TRUE);
+	if (err != GOBERR_OK) return err;
+
+	// create temporary file
+	temp_handle = FSFuncs.open("~temp.tmp", GOBACCESS_WRITE);
+	if (InvalidHandle(temp_handle)) return GOBERR_FILE_WRITE;
+
+	size = 0;
+
+	// create an empty buffer for slack
+	slack_buf = MemFuncs.alloc(GOB_BLOCK_ALIGNMENT);
+	if (!slack_buf) return GOBERR_NO_MEMORY;
+	memset(slack_buf, 0, GOB_BLOCK_ALIGNMENT);
+
+	// get memory for block
+	buffer = MemFuncs.alloc(GOB_BLOCK_SIZE + GOB_COMPRESS_OVERHEAD);
+	if (!buffer) return GOBERR_NO_MEMORY;
+
+	// copy files in new order to end of archive
+	for (i = 0; i < ArchiveNumBlocks; ++i) {
+		if (BlockTable[xlat[i]].next != GOB_INVALID_BLOCK) {
+			// seek to the block
+			if (FSFuncs.seek(ArchiveHandle, 
+				BlockTable[xlat[i]].offset, GOBSEEK_START)) 
+			{
+				return GOBERR_FILE_READ;
+			}
+			
+			// read the block
+			if (FSFuncs.read(ArchiveHandle, buffer, BlockTable[xlat[i]].size) !=
+				(signed)BlockTable[xlat[i]].size) 
+			{
+				return GOBERR_FILE_READ;
+			}
+
+			// write block
+			if (FSFuncs.write(temp_handle, buffer, BlockTable[xlat[i]].size) !=
+				(signed)BlockTable[xlat[i]].size) 
+			{
+				return GOBERR_FILE_WRITE;
+			}
+			
+			// write the slack
+			slack = GOBGetSlack(BlockTable[xlat[i]].size);
+			if (FSFuncs.write(temp_handle, slack_buf, slack) != slack) {
+				return GOBERR_FILE_WRITE;
+			}
+			
+			// update block pos
+			BlockTable[xlat[i]].offset = size;
+			size += BlockTable[xlat[i]].size + slack;
+		}
+	}
+
+	MemFuncs.free(buffer);
+	MemFuncs.free(slack_buf);
+	
+	// close the archive
+	err = GOBArchiveClose();
+	if (err != GOBERR_OK) return err;
+
+	// close temp file
+	FSFuncs.close(&temp_handle);
+
+	// overrwrite archive with temp file
+	_snprintf(full_name, GOB_MAX_FILE_NAME_LEN, "%s.gob", file);
+	if (_rename("~temp.tmp", full_name)) return GOBERR_FILE_RENAME;
+
+	ArchiveSize = size;
+
+	CommitFileTable();
+			
+	return GOBERR_OK;
+}
+
+
+// GOBVerify
+// Public function.  Verifies the integrity of a file.
+GOBError GOBVerify(const GOBChar* file, GOBBool* status)
+{
+	GOBHandle handle;
+	GOBError err;
+	GOBVoid* buffer;
+	GOBUInt32 size, junk;
+	GOBUInt32 crc;
+	GOBInt32 entry;
+	GOBChar* lfile;
+
+	if (!LibraryInit) return GOBERR_NOT_INIT;
+	if (InvalidHandle(ArchiveHandle)) return GOBERR_NOT_OPEN;
+	if (!FileTableExt) return GOBERR_NO_EXTENDED;
+	if (!BlockCRC) return GOBERR_NO_EXTENDED;
+
+	// get the file size
+	size = 0; // assign to avoid compiler warning
+	err = GOBGetSize(file, &size, &junk, &junk);
+	if (err != GOBERR_OK) return err;
+	
+	// open the file
+	err = GOBOpen((GOBChar*)file, &handle);
+	if (err != GOBERR_OK) return err;
+
+	lfile = LowerCase(file);
+	entry = GetFileTableEntry(lfile);
+
+	// alloc space for the file 
+	buffer = MemFuncs.alloc(size);
+	if (!buffer) return GOBERR_NO_MEMORY;
+
+	// read it into the buffer
+	crc = GOBRead(buffer, size, handle);
+	if (crc != size) return GOBERR_FILE_READ;
+	
+	// calc the crc
+	crc = crc32(0L, Z_NULL, 0);
+	crc = crc32(crc, (const unsigned char*)buffer, size);
+	
+	MemFuncs.free(buffer);
+
+	// verify the crc matches
+	if (crc != FileTableExt[entry].crc) *status = GOB_FALSE;
+	else *status = GOB_TRUE;
+	
+	err = GOBClose(handle);
+	if (err != GOBERR_OK) return err;
+	
+	return GOBERR_OK;
+}
+
+// GOBGetSize
+// Public function.  Get a file compressed, decompressed, slack sizes.
+GOBError GOBGetSize(const GOBChar* file, 
+	GOBUInt32* decomp, GOBUInt32* comp, GOBUInt32* slack)
+{
+	GOBInt32 entry;
+	GOBChar* lfile;
+	GOBUInt32 block;
+
+	if (!LibraryInit) return GOBERR_NOT_INIT;
+	if (InvalidHandle(ArchiveHandle)) return GOBERR_NOT_OPEN;
+
+	// get file table entry
+	lfile = LowerCase(file);
+	entry = GetFileTableEntry(lfile);
+	if (entry == -1) return GOBERR_FILE_NOT_FOUND;
+
+	// decompressed size from file table
+	*decomp = FileTableBasic[entry].size;
+	
+	// compressed size is sum of block sizes
+	*comp = 0;
+	*slack = 0;
+	block = FileTableBasic[entry].block;
+	while (block != GOB_MAX_BLOCKS) {
+		*comp += BlockTable[block].size;
+		*slack += GOBGetSlack(BlockTable[block].size);
+		block = BlockTable[block].next;
+	}
+
+	return GOBERR_OK;
+}
+
+// GOBGetTime
+// Public function.  Get a file modification time.
+GOBError GOBGetTime(const GOBChar* file, GOBUInt32* time)
+{
+	GOBInt32 entry;
+	GOBChar* lfile;
+
+	if (!LibraryInit) return GOBERR_NOT_INIT;
+	if (InvalidHandle(ArchiveHandle)) return GOBERR_NOT_OPEN;
+	if (!FileTableExt) return GOBERR_NO_EXTENDED;
+	if (!BlockCRC) return GOBERR_NO_EXTENDED;
+
+	lfile = LowerCase(file);
+	entry = GetFileTableEntry(lfile);
+	if (entry == -1) return GOBERR_FILE_NOT_FOUND;
+
+	*time = FileTableExt[entry].time;
+	return GOBERR_OK;
+}
+
+// GOBGetCRC
+// Public function.  Get a file CRC.
+GOBError GOBGetCRC(const GOBChar* file, GOBUInt32* crc)
+{
+	GOBInt32 entry;
+	GOBChar* lfile;
+
+	if (!LibraryInit) return GOBERR_NOT_INIT;
+	if (InvalidHandle(ArchiveHandle)) return GOBERR_NOT_OPEN;
+	if (!FileTableExt) return GOBERR_NO_EXTENDED;
+	if (!BlockCRC) return GOBERR_NO_EXTENDED;
+
+	lfile = LowerCase(file);
+	entry = GetFileTableEntry(lfile);
+	if (entry == -1) return GOBERR_FILE_NOT_FOUND;
+
+	*crc = FileTableExt[entry].crc;
+	return GOBERR_OK;
+}
+
+// GOBAccess
+// Public function.  Determine if a file exists in the archive.
+GOBError GOBAccess(const GOBChar* file, GOBBool* status)
+{
+	GOBInt32 entry;
+	GOBChar* lfile;
+
+	if (!LibraryInit) return GOBERR_NOT_INIT;
+	if (InvalidHandle(ArchiveHandle)) return GOBERR_NOT_OPEN;
+
+	lfile = LowerCase(file);
+	entry = GetFileTableEntry(lfile);
+	if (entry == -1) *status = GOB_FALSE;
+	else *status = GOB_TRUE;
+
+	return GOBERR_OK;
+}
+
+// GOBGetFileCode
+// Public function.  Find the index into the file table of a file.
+GOBInt32 GOBGetFileCode(const GOBChar* file)
+{
+	GOBInt32 entry;
+	GOBChar* lfile;
+
+	if (!LibraryInit) return -1;
+	if (InvalidHandle(ArchiveHandle)) return -1;
+
+	lfile = LowerCase(file);
+	entry = GetFileTableEntry(lfile);
+
+	return entry;
+}
+
+// GOBGetFileTables
+// Public function.  Return the active file tables.
+GOBError GOBGetFileTables(struct GOBFileTableBasicEntry** basic, 
+	struct GOBFileTableExtEntry** ext)
+{
+	if (!LibraryInit) return GOBERR_NOT_INIT;
+	if (InvalidHandle(ArchiveHandle)) return GOBERR_NOT_OPEN;
+	*basic = FileTableBasic;
+	*ext = FileTableExt;
+	return GOBERR_OK;
+}
+
+// GOBGetBlockTable
+// Public function.  Return the active block table.
+GOBError GOBGetBlockTable(struct GOBBlockTableEntry** table, GOBUInt32* num)
+{
+	if (!LibraryInit) return GOBERR_NOT_INIT;
+	if (InvalidHandle(ArchiveHandle)) return GOBERR_NOT_OPEN;
+	*table = BlockTable;
+	*num = ArchiveNumBlocks;
+	return GOBERR_OK;
+}
+
+// GOBSetCacheSize
+// Public function.  Allocates buffers to cache blocks.
+GOBError GOBSetCacheSize(GOBUInt32 num)
+{
+	GOBUInt32 i;
+
+	if (!LibraryInit) return GOBERR_NOT_INIT;
+
+	// only continue if we actually need to resize
+	if (num == NumCacheBlocks) return GOBERR_OK;
+
+	// free old cache buffers
+	FreeCache();
+
+	NumCacheBlocks = 0;
+	
+	CacheBlocks = (struct GOBBlockCache*)MemFuncs.alloc(
+			sizeof(struct GOBBlockCache) * num);
+	if (!CacheBlocks) return GOBERR_NO_MEMORY;
+
+	// allocate cache blocks and initialize
+	for (i = 0; i < num; ++i) {
+		CacheBlocks[i].data = (GOBChar*)MemFuncs.alloc(GOB_BLOCK_SIZE);
+		if (!CacheBlocks[i].data) return GOBERR_NO_MEMORY;
+		
+		CacheBlocks[i].size = 0;
+		CacheBlocks[i].time = 0;
+		CacheBlocks[i].block = 0xFFFFFFFF;
+		
+		++NumCacheBlocks;
+	}
+	
+	return GOBERR_OK;
+}
+
+// GOBSetReadBufferSize
+// Public function.  Allocate a read ahead buffer.
+GOBError GOBSetReadBufferSize(GOBUInt32 size)
+{
+	if (!LibraryInit) return GOBERR_NOT_INIT;
+
+	// only continue if we actually need to resize
+	if (size == ReadBuffer.size) return GOBERR_OK;
+
+	// remove old buffer
+	if (ReadBuffer.data) MemFuncs.free(ReadBuffer.data);
+
+	// allocate new buffer
+	ReadBuffer.data = (GOBChar*)MemFuncs.alloc(size + GOB_MEM_ALIGNMENT);
+	if (!ReadBuffer.data) return GOB_INVALID_SIZE;
+	
+	// set aligned pointer
+	ReadBuffer.dataStart = 
+		&ReadBuffer.data[GOB_MEM_ALIGNMENT - 
+		((GOBUInt32)(ReadBuffer.data) % GOB_MEM_ALIGNMENT)];
+
+	ReadBuffer.pos = 0xFFFFFFFF;
+	ReadBuffer.size = size;
+	
+	return GOBERR_OK;
+}
+
+// GOBGetReadStats
+// Public function.  Get file read statistics (seeks, sizes).
+struct GOBReadStats GOBGetReadStats(GOBVoid)
+{
+	return ReadStats;
+}
+
+
+GOBVoid GOBSetProfileFuncs(struct GOBProfileFuncSet* fset)
+{
+	ProfileReadCallback = fset->read;
+}
+
+GOBError GOBStartProfile(GOBVoid)
+{
+	if (ProfileEnabled) return GOBERR_PROFILE_ON;
+	ProfileEnabled = GOB_TRUE;
+	return GOBERR_OK;
+}
+
+GOBError GOBStopProfile(GOBVoid)
+{
+	if (!ProfileEnabled) return GOBERR_PROFILE_OFF;
+	ProfileEnabled = GOB_FALSE;
+	return GOBERR_OK;
+}
diff --git a/code/goblib/goblib.h b/code/goblib/goblib.h
new file mode 100644
index 0000000..d975935
--- /dev/null
+++ b/code/goblib/goblib.h
@@ -0,0 +1,299 @@
+/*****************************************
+ *
+ * GOB File System
+ *
+ * Here's what Merriam-Webster says about "gob":  --Chuck
+ *		Entry:     gob
+ *		Function:  noun
+ *		Etymology: Middle English gobbe, from Middle French gobe large piece of food,
+ *		           back-formation from gobet
+ *		Date:      14th century
+ *		1 : LUMP
+ *		2 : a large amount -- usually used in plural <gobs of money>
+ *
+ * Purpose: Provide fast, efficient disk access on a variety of platforms.
+ *
+ * Implementation:
+ *		The GOB system maintains two files -- GOB and GFC.  The GOB file is actually
+ *		an archive of many files split into variable size, compressed blocks.  The GFC,
+ *		GOB File Control, contains 3 tables -- a block table, basic file table, and
+ *		extended file table.  The block table is analogous to a DOS FAT.  The basic
+ *		file table contains a minimal set of file information to handle basic reading
+ *		tasks.  The extended file table is optionally loaded and contains additional
+ *		file information.  File names are case insensitive.
+ *		  
+ *		Files can be read in a normal manner.  Open, read, seek and close
+ *		operations are all provided.  Files can only be written in a single
+ *		contiguous chunk of blocks at the end of an archive.  Reads are processed
+ *		through a configurable number of read ahead buffers to in an effort to
+ *		minimize both reads and seeks.  Other operations including delete, verify, 
+ *		access, and get size are also supported on files inside an archive.
+ *
+ *		The system supports read profiling.  By supplying a file read callback 
+ *		function, the library will output the block number of each read.  This can 
+ *		be used rearrange block in the archive to minimize seek times.  The 
+ *		GOBRearrange sorts files in an archive.
+ *
+ *		Supports block based caching.  Primarily aimed at caching files off a DVD/CD
+ *		to a faster hard disk.
+ *
+ * Future Work: 
+ *
+ * Dependencies: vvInt, snprintf, zlib
+ * Owner: Chris McEvoy
+ * History:
+ *     09/23/2001 Original version
+ *     10/28/2002 Merged into vvtech
+ *
+ * Copyright (C) 2002, Vicarious Visions, Inc.  All Rights Reserved.
+ *
+ * UNPUBLISHED -- Rights  reserved  under  the  copyright  laws  of the 
+ * United States.  Use  of a copyright notice is precautionary only and 
+ * does not imply publication or disclosure.                            
+ *                                                                      
+ * THIS DOCUMENTATION CONTAINS CONFIDENTIAL AND PROPRIETARY INFORMATION 
+ * OF    VICARIOUS   VISIONS,  INC.    ANY  DUPLICATION,  MODIFICATION, 
+ * DISTRIBUTION, OR DISCLOSURE IS STRICTLY PROHIBITED WITHOUT THE PRIOR 
+ * EXPRESS WRITTEN PERMISSION OF VICARIOUS VISIONS, INC.
+ *
+ *****************************************/
+
+/*
+	This is an unofficial branch of GOB, for Jedi Academy
+	Maintainer: Brian Osman
+*/
+
+#ifndef GOBLIB_H__
+#define GOBLIB_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define GOB_MAGIC_IDENTIFIER		0x8008
+#define GOB_MAX_FILE_NAME_LEN		96
+#define GOB_MAX_OPEN_FILES			16
+#define GOB_MAX_CODECS				2
+#define GOB_INFINITE_RATIO			1000
+#define GOB_READ_RETRYS				3
+
+#define GOB_MAX_FILES				(16*1024)
+#define GOB_MAX_BLOCKS				32767
+
+#define GOB_BLOCK_SIZE				(64*1024)
+#define GOB_BLOCK_ALIGNMENT			2048
+#define GOB_MEM_ALIGNMENT			64
+#define GOB_COMPRESS_OVERHEAD		1024
+
+#define GOB_INVALID_SIZE			0xFFFFFFFF
+#define GOB_INVALID_BLOCK			0xFFFFFFFF
+
+#define GOB_TRUE					1
+#define GOB_FALSE					0
+
+#define GOBERR_OK					0
+#define GOBERR_NOT_INIT				1
+#define GOBERR_FILE_NOT_FOUND		2
+#define GOBERR_FILE_READ			3
+#define GOBERR_FILE_WRITE			4
+#define GOBERR_NO_MEMORY			5
+#define GOBERR_ALREADY_INIT			6
+#define GOBERR_ALREADY_OPEN			7
+#define GOBERR_INVALID_ACCESS		8
+#define GOBERR_NOT_GOB_FILE			9
+#define GOBERR_NOT_OPEN				10
+#define GOBERR_CANNOT_CREATE		11
+#define GOBERR_TOO_MANY_OPEN		12
+#define GOBERR_INVALID_SEEK			13
+#define GOBERR_TOO_MANY_FILES		14
+#define GOBERR_FILE_RENAME			15
+#define GOBERR_PROFILE_OFF			16
+#define GOBERR_PROFILE_ON			17
+#define GOBERR_NO_EXTENDED			18
+#define GOBERR_DUP_HASH				19
+#define GOBERR_TOO_MANY_BLOCKS		20
+#define GOBERR_COMPRESS_FAIL		21
+#define GOBERR_NO_SUITABLE_CODEC	22
+
+#define GOBACCESS_READ				0
+#define GOBACCESS_WRITE				1
+#define GOBACCESS_RW				2
+
+#define GOBSEEK_START				0
+#define GOBSEEK_CURRENT				1
+#define GOBSEEK_END					2
+
+#define GOB_CODEC_MASK(n)			((GOBUInt32)(1u<<(n)))
+#define GOB_CODEC_MASK_ANY			((GOBUInt32)(-1))
+
+#define GOBMARKER_STARTBLOCK		('L' | 'B' << 8 | 'T' << 16 | 'S' << 24)
+#define GOBMARKER_ENDBLOCK			('L' | 'B' << 8 | 'N' << 16 | 'E' << 24)
+
+typedef int						int32;
+typedef unsigned int			uint32;
+//#define bool					int
+//#define false					0
+//#define true					1
+typedef unsigned long			ulong;
+typedef unsigned char			byte;
+
+typedef int32					GOBInt32;
+typedef uint32					GOBUInt32;
+typedef char					GOBChar;
+typedef bool					GOBBool;
+typedef int32					GOBError;
+typedef int32					GOBSeekType;
+typedef int32					GOBHandle;
+typedef int32					GOBAccessType;
+typedef void*					GOBFSHandle;
+typedef void					GOBVoid;
+
+typedef GOBFSHandle (*GOBFileSysOpenFunc)(GOBChar*, GOBAccessType);
+typedef GOBBool (*GOBFileSysCloseFunc)(GOBFSHandle*);
+typedef GOBInt32 (*GOBFileSysReadFunc)(GOBFSHandle, GOBVoid*, GOBInt32);
+typedef GOBInt32 (*GOBFileSysWriteFunc)(GOBFSHandle, GOBVoid*, GOBInt32);
+typedef GOBInt32 (*GOBFileSysSeekFunc)(GOBFSHandle, GOBInt32, GOBSeekType);
+typedef GOBInt32 (*GOBFileSysRenameFunc)(GOBChar*, GOBChar*);
+
+typedef GOBVoid* (*GOBMemAllocFunc)(GOBUInt32);
+typedef GOBVoid (*GOBMemFreeFunc)(GOBVoid*);
+
+typedef GOBInt32 (*GOBCompressFunc)(GOBVoid*, GOBUInt32, GOBVoid*, GOBUInt32*);
+typedef GOBInt32 (*GOBDecompressFunc)(GOBVoid*, GOBUInt32, GOBVoid*, GOBUInt32*);
+
+typedef GOBBool (*GOBCacheFileOpenFunc)(GOBUInt32);
+typedef GOBBool (*GOBCacheFileCloseFunc)(GOBVoid);
+typedef GOBInt32 (*GOBCacheFileReadFunc)(GOBVoid*, GOBInt32);
+typedef GOBInt32 (*GOBCacheFileWriteFunc)(GOBVoid*, GOBInt32);
+typedef GOBInt32 (*GOBCacheFileSeekFunc)(GOBInt32);
+
+struct GOBBlockTableEntry
+{
+	GOBUInt32 size; // compressed size
+	GOBUInt32 offset;
+	GOBUInt32 next;
+};
+
+struct GOBFileTableBasicEntry
+{
+	GOBUInt32	hash;
+	GOBUInt32	size; // decompressed size
+	GOBUInt32	block;
+};
+
+struct GOBFileTableExtEntry
+{
+	GOBChar		name[GOB_MAX_FILE_NAME_LEN];
+	GOBUInt32	crc;
+	GOBUInt32	time;
+};
+
+struct GOBMemoryFuncSet
+{
+	GOBMemAllocFunc		alloc;
+	GOBMemFreeFunc		free;
+};
+
+struct GOBSingleCodecDesc
+{
+	GOBChar				tag;
+	GOBInt32			max_ratio;
+	GOBCompressFunc		compress;
+	GOBDecompressFunc	decompress;
+};
+
+struct GOBCodecFuncSet
+{
+	GOBInt32 codecs;
+	struct GOBSingleCodecDesc codec[GOB_MAX_CODECS];
+};
+
+struct GOBFileSysFuncSet
+{
+	GOBFileSysOpenFunc		open;
+	GOBFileSysCloseFunc		close;
+	GOBFileSysReadFunc		read;
+	GOBFileSysWriteFunc		write;
+	GOBFileSysSeekFunc		seek;
+};
+
+struct GOBCacheFileFuncSet
+{
+	GOBCacheFileOpenFunc		open;
+	GOBCacheFileCloseFunc		close;
+	GOBCacheFileReadFunc		read;
+	GOBCacheFileWriteFunc		write;
+	GOBCacheFileSeekFunc		seek;
+};
+
+struct GOBReadStats
+{
+	GOBUInt32 bufferUsed;
+	GOBUInt32 bytesRead;
+	GOBUInt32 cacheBytesRead;
+	GOBUInt32 cacheBytesWrite;
+	GOBUInt32 totalSeeks;
+	GOBUInt32 farSeeks;
+	GOBUInt32 filesOpened;
+};
+
+extern GOBError GOBInit(struct GOBMemoryFuncSet* mem, 
+	struct GOBFileSysFuncSet* file, 
+	struct GOBCodecFuncSet* codec,
+	struct GOBCacheFileFuncSet* cache);
+extern GOBError GOBShutdown(GOBVoid);
+
+extern GOBError GOBArchiveCreate(const GOBChar* file);
+extern GOBError GOBArchiveOpen(const GOBChar* file, GOBAccessType atype,
+	GOBBool extended, GOBBool safe);
+extern GOBError GOBArchiveClose(GOBVoid);
+extern GOBError GOBArchiveCheckMarkers(GOBVoid);
+
+extern GOBError GOBOpen(GOBChar* file, GOBHandle* handle);
+extern GOBError GOBOpenCode(GOBInt32 code, GOBHandle* handle);
+extern GOBError GOBClose(GOBHandle handle);
+
+extern GOBUInt32 GOBRead(GOBVoid* buffer, GOBUInt32 size, GOBHandle handle);
+extern GOBError GOBSeek(GOBHandle handle, GOBUInt32 offset, GOBSeekType type, GOBUInt32* pos);
+
+extern GOBError GOBWrite(GOBVoid* buffer, GOBUInt32 size, GOBUInt32 mtime, const GOBChar* file, GOBUInt32 codec_mask);
+extern GOBError GOBDelete(const GOBChar* file);
+
+extern GOBError GOBRearrange(const GOBChar* file, const GOBUInt32* xlat, GOBFileSysRenameFunc _rename);
+
+extern GOBError GOBVerify(const GOBChar* file, GOBBool* status);
+
+extern GOBError GOBGetSize(const GOBChar* file, GOBUInt32* decomp, GOBUInt32* comp, GOBUInt32* slack);
+extern GOBError GOBGetTime(const GOBChar* file, GOBUInt32* time);
+extern GOBError GOBGetCRC(const GOBChar* file, GOBUInt32* crc);
+
+extern GOBError GOBAccess(const GOBChar* file, GOBBool* status);
+extern GOBInt32 GOBGetFileCode(const GOBChar* file);
+
+extern GOBError GOBGetFileTables(struct GOBFileTableBasicEntry** basic, struct GOBFileTableExtEntry** ext);
+extern GOBError GOBGetBlockTable(struct GOBBlockTableEntry** table, GOBUInt32* num);
+extern GOBUInt32 GOBGetSlack(GOBUInt32 x);
+
+extern GOBError GOBSetCacheSize(GOBUInt32 num);
+extern GOBError GOBSetReadBufferSize(GOBUInt32 size);
+
+extern struct GOBReadStats GOBGetReadStats(GOBVoid);
+
+
+typedef GOBVoid (*GOBProfileReadFunc)(GOBUInt32);
+struct GOBProfileFuncSet
+{
+	GOBProfileReadFunc read;
+};
+extern GOBVoid GOBSetProfileFuncs(struct GOBProfileFuncSet* fset);
+
+extern GOBError GOBStartProfile(GOBVoid);
+extern GOBError GOBStopProfile(GOBVoid);
+
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+
+#endif /* GOBLIB_H__ */
diff --git a/code/goblib/goblib.vcproj b/code/goblib/goblib.vcproj
new file mode 100644
index 0000000..038a4fb
--- /dev/null
+++ b/code/goblib/goblib.vcproj
@@ -0,0 +1,461 @@
+<?xml version="1.0" encoding = "Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="7.00"
+	Name="goblib"
+	ProjectGUID="{68A067E3-BB9E-435B-9AA3-DD45DB2AA4DB}"
+	Keyword="XboxProj">
+	<Platforms>
+		<Platform
+			Name="Xbox"/>
+	</Platforms>
+	<Configurations>
+		<Configuration
+			Name="Debug|Xbox"
+			OutputDirectory="Debug"
+			IntermediateDirectory="Debug"
+			ConfigurationType="4"
+			CharacterSet="2">
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				OptimizeForProcessor="2"
+				PreprocessorDefinitions="_DEBUG;_XBOX;_LIB"
+				MinimalRebuild="TRUE"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="1"
+				UsePrecompiledHeader="0"
+				PrecompiledHeaderFile="$(OutDir)/$(ProjectName).pch"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="FALSE"
+				DebugInformationFormat="4"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLibrarianTool"
+				OutputFile=".\..\x_exe\Debug\goblib.lib"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+		</Configuration>
+		<Configuration
+			Name="Release|Xbox"
+			OutputDirectory="Release"
+			IntermediateDirectory="Release"
+			ConfigurationType="4"
+			CharacterSet="2">
+			<Tool
+				Name="VCCLCompilerTool"
+				AdditionalOptions="/Oy-"
+				Optimization="2"
+				InlineFunctionExpansion="1"
+				OmitFramePointers="FALSE"
+				OptimizeForProcessor="2"
+				PreprocessorDefinitions="NDEBUG;_XBOX;_LIB"
+				StringPooling="TRUE"
+				RuntimeLibrary="0"
+				BufferSecurityCheck="TRUE"
+				EnableFunctionLevelLinking="TRUE"
+				EnableEnhancedInstructionSet="1"
+				UsePrecompiledHeader="0"
+				PrecompiledHeaderFile="$(OutDir)/$(ProjectName).pch"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="FALSE"
+				DebugInformationFormat="3"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLibrarianTool"
+				OutputFile=".\..\x_exe\Release\goblib.lib"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+		</Configuration>
+		<Configuration
+			Name="FinalBuild|Xbox"
+			OutputDirectory="FinalBuild"
+			IntermediateDirectory="FinalBuild"
+			ConfigurationType="4"
+			CharacterSet="2">
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="3"
+				GlobalOptimizations="TRUE"
+				InlineFunctionExpansion="2"
+				EnableIntrinsicFunctions="TRUE"
+				FavorSizeOrSpeed="1"
+				OmitFramePointers="TRUE"
+				OptimizeForProcessor="2"
+				PreprocessorDefinitions="FINAL_BUILD;NDEBUG;_XBOX;_LIB"
+				StringPooling="TRUE"
+				RuntimeLibrary="0"
+				BufferSecurityCheck="TRUE"
+				EnableFunctionLevelLinking="TRUE"
+				EnableEnhancedInstructionSet="1"
+				UsePrecompiledHeader="0"
+				PrecompiledHeaderFile="$(OutDir)/$(ProjectName).pch"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="FALSE"
+				DebugInformationFormat="3"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLibrarianTool"
+				OutputFile=".\..\x_exe\FinalBuild\goblib.lib"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+		</Configuration>
+	</Configurations>
+	<Files>
+		<Filter
+			Name="Source Files"
+			Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm">
+			<File
+				RelativePath="..\zlib\adler32.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\zlib\compress.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\zlib\crc32.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\zlib\deflate.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="goblib.cpp">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\zlib\infblock.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\zlib\infcodes.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\zlib\inffast.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\zlib\inflate.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\zlib\inftrees.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\zlib\infutil.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\zlib\trees.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\zlib\uncompr.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\zlib\zutil.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+		</Filter>
+		<Filter
+			Name="Header Files"
+			Filter="h;hpp;hxx;hm;inl;inc">
+			<File
+				RelativePath="..\zlib\deflate.h">
+			</File>
+			<File
+				RelativePath="goblib.h">
+			</File>
+			<File
+				RelativePath="..\zlib\infblock.h">
+			</File>
+			<File
+				RelativePath="..\zlib\infcodes.h">
+			</File>
+			<File
+				RelativePath="..\zlib\inffast.h">
+			</File>
+			<File
+				RelativePath="..\zlib\inffixed.h">
+			</File>
+			<File
+				RelativePath="..\zlib\inftrees.h">
+			</File>
+			<File
+				RelativePath="..\zlib\infutil.h">
+			</File>
+			<File
+				RelativePath="..\zlib\trees.h">
+			</File>
+			<File
+				RelativePath="..\zlib\zconf.h">
+			</File>
+			<File
+				RelativePath="..\zlib\zlib.h">
+			</File>
+			<File
+				RelativePath="..\zlib\zutil.h">
+			</File>
+		</Filter>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>
diff --git a/code/goblib/goblib.vcproj.vspscc b/code/goblib/goblib.vcproj.vspscc
new file mode 100644
index 0000000..c231424
--- /dev/null
+++ b/code/goblib/goblib.vcproj.vspscc
@@ -0,0 +1,10 @@
+""
+{
+"FILE_VERSION" = "9237"
+"ENLISTMENT_CHOICE" = "NEVER"
+"PROJECT_FILE_RELATIVE_PATH" = "relative:goblib"
+"NUMBER_OF_EXCLUDED_FILES" = "0"
+"ORIGINAL_PROJECT_FILE_PATH" = ""
+"NUMBER_OF_NESTED_PROJECTS" = "0"
+"SOURCE_CONTROL_SETTINGS_PROVIDER" = "PROJECT"
+}
diff --git a/code/goblib/mssccprj.scc b/code/goblib/mssccprj.scc
new file mode 100644
index 0000000..af6c0e7
--- /dev/null
+++ b/code/goblib/mssccprj.scc
@@ -0,0 +1,5 @@
+SCC = This is a Source Code Control file
+
+[goblib.vcproj]
+SCC_Aux_Path = "\\ravendata1\vss\central_code"
+SCC_Project_Name = "$/jedi/code/goblib", AAIAAAAA
diff --git a/code/goblib/vssver.scc b/code/goblib/vssver.scc
new file mode 100644
index 0000000..1a91362
Binary files /dev/null and b/code/goblib/vssver.scc differ
diff --git a/code/icarus/BlockStream.cpp b/code/icarus/BlockStream.cpp
new file mode 100644
index 0000000..f6fc13e
--- /dev/null
+++ b/code/icarus/BlockStream.cpp
@@ -0,0 +1,586 @@
+// Interpreted Block Stream Functions
+//
+//	-- jweier
+
+// this include must remain at the top of every Icarus CPP file
+#include "stdafx.h"
+
+#include "IcarusInterface.h"
+#include "IcarusImplementation.h"
+
+#include "BlockStream.h"
+
+/*
+===================================================================================================
+
+  CBlockMember
+
+===================================================================================================
+*/
+
+inline CBlockMember::CBlockMember( void )
+{
+	m_id = -1;
+	m_size = -1;
+	m_data = NULL;
+}
+
+inline CBlockMember::~CBlockMember( void )
+{
+}
+
+/*
+-------------------------
+Free
+-------------------------
+*/
+
+void CBlockMember::Free(IGameInterface* game)
+{
+	if ( m_data != NULL )
+	{
+		game->Free ( m_data );
+		m_data = NULL;
+
+		m_id = m_size = -1;
+	}
+	delete this;
+}
+
+/*
+-------------------------
+GetInfo
+-------------------------
+*/
+
+void CBlockMember::GetInfo( int *id, int *size, void **data )
+{	
+	*id = m_id;
+	*size = m_size;
+	*data = m_data;
+}
+
+/*
+-------------------------
+SetData overloads
+-------------------------
+*/
+
+void CBlockMember::SetData( const char *data , CIcarus* icarus)
+{
+	WriteDataPointer( data, strlen(data)+1, icarus );
+}
+
+void CBlockMember::SetData( vec3_t data , CIcarus* icarus)
+{
+	WriteDataPointer( data, 3 , icarus);
+}
+
+void CBlockMember::SetData( void *data, int size, CIcarus* icarus)
+{
+	IGameInterface* game = icarus->GetGame();
+	if ( m_data )
+		game->Free( m_data );
+
+	m_data = game->Malloc( size );
+	memcpy( m_data, data, size );
+	m_size = size;
+}
+
+//	Member I/O functions
+
+/*
+-------------------------
+ReadMember
+-------------------------
+*/
+
+int CBlockMember::ReadMember( char **stream, long *streamPos, CIcarus* icarus )
+{
+	IGameInterface* game = icarus->GetGame();
+	m_id = *(int *) (*stream + *streamPos);
+	*streamPos += sizeof( int );
+
+	if ( m_id == CIcarus::ID_RANDOM )
+	{//special case, need to initialize this member's data to Q3_INFINITE so we can randomize the number only the first time random is checked when inside a wait
+		m_size = sizeof( float );
+		*streamPos += sizeof( long );
+		m_data = game->Malloc( m_size );
+		float infinite = game->MaxFloat();
+		memcpy( m_data, &infinite, m_size );
+	}
+	else
+	{
+		m_size = *(long *) (*stream + *streamPos);
+		*streamPos += sizeof( long );
+		m_data = game->Malloc( m_size );
+		memcpy( m_data, (*stream + *streamPos), m_size );
+	}
+	*streamPos += m_size;
+	
+	return true;
+}
+
+/*
+-------------------------
+WriteMember
+-------------------------
+*/
+
+int CBlockMember::WriteMember( FILE *m_fileHandle )
+{
+	fwrite( &m_id, sizeof(m_id), 1, m_fileHandle );
+	fwrite( &m_size, sizeof(m_size), 1, m_fileHandle );
+	fwrite( m_data, m_size, 1, m_fileHandle );
+
+	return true;
+}
+
+/*
+-------------------------
+Duplicate
+-------------------------
+*/
+
+CBlockMember *CBlockMember::Duplicate( CIcarus* icarus )
+{
+	CBlockMember	*newblock = new CBlockMember;
+
+	if ( newblock == NULL )
+		return NULL;
+
+	newblock->SetData( m_data, m_size, icarus );
+	newblock->SetSize( m_size );
+	newblock->SetID( m_id );
+
+	return newblock;
+}
+
+/*
+===================================================================================================
+
+  CBlock
+
+===================================================================================================
+*/
+
+
+/*
+-------------------------
+Init
+-------------------------
+*/
+
+int CBlock::Init( void )
+{
+	m_flags			= 0;
+	m_id			= 0;
+
+	return true;
+}
+
+/*
+-------------------------
+Create
+-------------------------
+*/
+
+int CBlock::Create( int block_id )
+{
+	Init();
+
+	m_id = block_id;
+
+	return true;
+}
+
+/*
+-------------------------
+Free
+-------------------------
+*/
+
+int CBlock::Free( CIcarus* icarus )
+{
+	IGameInterface* game = icarus->GetGame();
+	int	numMembers = GetNumMembers();
+	CBlockMember	*bMember;
+
+	while ( numMembers-- )
+	{
+		bMember = GetMember( numMembers );
+
+		if (!bMember)
+			return false;
+
+		bMember->Free(game);
+	}
+
+	m_members.clear();			//List of all CBlockMembers owned by this list
+
+	return true;
+}
+
+//	Write overloads
+
+/*
+-------------------------
+Write
+-------------------------
+*/
+
+int CBlock::Write( int member_id, const char *member_data, CIcarus* icarus )
+{
+	CBlockMember *bMember = new CBlockMember;
+
+	bMember->SetID( member_id );
+	
+	bMember->SetData( member_data, icarus );
+	bMember->SetSize( strlen(member_data) + 1 );
+
+	AddMember( bMember );
+
+	return true;
+}
+
+int CBlock::Write( int member_id, vec3_t member_data, CIcarus* icarus )
+{
+	CBlockMember *bMember; 
+
+	bMember = new CBlockMember;
+
+	bMember->SetID( member_id );
+	bMember->SetData( member_data, icarus );
+	bMember->SetSize( sizeof(vec3_t) );
+
+	AddMember( bMember );
+
+	return true;
+}
+
+int CBlock::Write( int member_id, float member_data, CIcarus* icarus )
+{
+	CBlockMember *bMember = new CBlockMember;
+
+	bMember->SetID( member_id );
+	bMember->WriteData( member_data, icarus );
+	bMember->SetSize( sizeof(member_data) );
+
+	AddMember( bMember );
+
+	return true;
+}
+
+int CBlock::Write( int member_id, int member_data, CIcarus* icarus )
+{
+	CBlockMember *bMember = new CBlockMember;
+
+	bMember->SetID( member_id );
+	bMember->WriteData( member_data , icarus);
+	bMember->SetSize( sizeof(member_data) );
+
+	AddMember( bMember );
+
+	return true;
+}
+
+
+int CBlock::Write( CBlockMember *bMember, CIcarus* )
+{
+// findme: this is wrong:	bMember->SetSize( sizeof(bMember->GetData()) );
+	
+	AddMember( bMember );
+
+	return true;
+}
+
+// Member list functions
+
+/*
+-------------------------
+AddMember
+-------------------------
+*/
+
+int	CBlock::AddMember( CBlockMember *member )
+{
+	m_members.insert( m_members.end(), member );
+	return true;
+}
+
+/*
+-------------------------
+GetMember
+-------------------------
+*/
+
+CBlockMember *CBlock::GetMember( int memberNum )
+{
+	if ( memberNum > GetNumMembers()-1 )
+	{
+		return false;
+	}
+	return m_members[ memberNum ];
+}
+
+/*
+-------------------------
+GetMemberData
+-------------------------
+*/
+
+void *CBlock::GetMemberData( int memberNum )
+{
+	if ( memberNum > GetNumMembers()-1 )
+	{
+		return NULL;
+	}
+	return (void *) ((GetMember( memberNum ))->GetData());
+}
+
+/*
+-------------------------
+Duplicate
+-------------------------
+*/
+
+CBlock *CBlock::Duplicate( CIcarus* icarus )
+{
+	blockMember_v::iterator	mi;
+	CBlock					*newblock;
+
+	newblock = new CBlock;
+
+	if ( newblock == NULL )
+		return false;
+
+	newblock->Create( m_id );
+
+	//Duplicate entire block and return the cc
+	for ( mi = m_members.begin(); mi != m_members.end(); mi++ )
+	{
+		newblock->AddMember( (*mi)->Duplicate(icarus) );
+	}
+
+	return newblock;
+}
+
+/*
+===================================================================================================
+
+  CBlockStream
+
+===================================================================================================
+*/
+
+char* CBlockStream::s_IBI_EXT				= ".IBI";	//(I)nterpreted (B)lock (I)nstructions
+char* CBlockStream::s_IBI_HEADER_ID			= "IBI";
+const float	CBlockStream::s_IBI_VERSION		= 1.57f;
+
+/*
+-------------------------
+Free
+-------------------------
+*/
+
+int CBlockStream::Free( void )
+{
+	//NOTENOTE: It is assumed that the user will free the passed memory block (m_stream) immediately after the run call
+	//			That's why this doesn't free the memory, it only clears its internal pointer
+
+	m_stream = NULL;
+	m_streamPos = 0;
+
+	return true;
+}
+
+/*
+-------------------------
+Create
+-------------------------
+*/
+
+int CBlockStream::Create( char *filename )
+{	
+	// strip extension
+	int		extensionloc = strlen(filename);
+	while ( (filename[extensionloc] != '.') && (extensionloc >= 0) )
+	{
+		extensionloc--;
+	}
+	if ( extensionloc < 0 )
+	{
+		strcpy(m_fileName, filename);
+	}
+	else
+	{
+		strncpy(m_fileName, filename, extensionloc);
+		m_fileName[extensionloc] = '\0';
+	}
+	// add extension
+	strcat((char *) m_fileName, s_IBI_EXT);
+
+	if ( ((m_fileHandle = fopen(m_fileName, "wb")) == NULL) )
+	{
+		return false;
+	}
+
+	fwrite( s_IBI_HEADER_ID, 1, sizeof(s_IBI_HEADER_ID), m_fileHandle );
+	fwrite( &s_IBI_VERSION, 1, sizeof(s_IBI_VERSION), m_fileHandle );
+
+	return true;
+}
+
+/*
+-------------------------
+Init
+-------------------------
+*/
+
+int CBlockStream::Init( void )
+{
+	m_fileHandle = NULL;
+	memset(m_fileName, 0, sizeof(m_fileName));
+
+	m_stream = NULL;
+	m_streamPos = 0;
+
+	return true;
+}
+
+//	Block I/O functions
+
+/*
+-------------------------
+WriteBlock
+-------------------------
+*/
+
+int CBlockStream::WriteBlock( CBlock *block, CIcarus* icarus )
+{
+	CBlockMember	*bMember;
+	int				id = block->GetBlockID();
+	int				numMembers = block->GetNumMembers();
+	unsigned char	flags = block->GetFlags();
+
+	fwrite ( &id, sizeof(id), 1, m_fileHandle ); 
+	fwrite ( &numMembers, sizeof(numMembers), 1, m_fileHandle );
+	fwrite ( &flags, sizeof( flags ), 1, m_fileHandle );
+
+	for ( int i = 0; i < numMembers; i++ )
+	{	
+		bMember = block->GetMember( i );
+		bMember->WriteMember( m_fileHandle );
+	}
+
+	block->Free(icarus);
+
+	return true;
+}
+
+/*
+-------------------------
+BlockAvailable
+-------------------------
+*/
+
+int CBlockStream::BlockAvailable( void )
+{
+	if ( m_streamPos >= m_fileSize )
+		return false;
+
+	return true;
+}
+
+/*
+-------------------------
+ReadBlock
+-------------------------
+*/
+
+int CBlockStream::ReadBlock( CBlock *get, CIcarus* icarus )
+{
+	CBlockMember	*bMember;
+	int				b_id, numMembers;
+	unsigned char	flags;
+
+	if (!BlockAvailable())
+		return false;
+
+	b_id		= *(int *) (m_stream + m_streamPos);
+	m_streamPos += sizeof( b_id );
+
+	numMembers	= *(int *) (m_stream + m_streamPos);
+	m_streamPos += sizeof( numMembers );
+
+	flags		= *(unsigned char*) (m_stream + m_streamPos);
+	m_streamPos += sizeof( flags );
+
+	if (numMembers < 0)
+		return false;
+
+	get->Create( b_id );
+	get->SetFlags( flags );
+
+	// Stream blocks are generally temporary as they
+	// are just used in an initial parsing phase...
+#ifdef _XBOX
+	extern void Z_SetNewDeleteTemporary(bool bTemp);
+	Z_SetNewDeleteTemporary(true);
+#endif
+
+	while ( numMembers-- > 0)
+	{	
+		bMember = new CBlockMember;
+		bMember->ReadMember( &m_stream, &m_streamPos, icarus );
+		get->AddMember( bMember );
+	}
+
+#ifdef _XBOX
+	Z_SetNewDeleteTemporary(false);
+#endif
+
+	return true;
+}
+
+/*
+-------------------------
+Open
+-------------------------
+*/
+
+int CBlockStream::Open( char *buffer, long size )
+{
+	char	id_header[sizeof(s_IBI_HEADER_ID)];
+	float	version;
+	
+	Init();
+
+	m_fileSize = size;
+
+	m_stream = buffer;
+
+	for ( int i = 0; i < sizeof( id_header ); i++ )
+	{
+		id_header[i] = *(m_stream + m_streamPos++);
+	}
+
+	version = *(float *) (m_stream + m_streamPos);
+	m_streamPos += sizeof( version );
+
+	//Check for valid header
+	if ( strcmp( id_header, s_IBI_HEADER_ID ) )
+	{
+		Free();
+		return false;
+	}
+
+	//Check for valid version
+	if ( version != s_IBI_VERSION )
+	{
+		Free();
+		return false;
+	}
+
+	return true;
+}
diff --git a/code/icarus/IcarusImplementation.cpp b/code/icarus/IcarusImplementation.cpp
new file mode 100644
index 0000000..907ab29
--- /dev/null
+++ b/code/icarus/IcarusImplementation.cpp
@@ -0,0 +1,809 @@
+// IcarusImplementation.cpp
+
+#include "stdafx.h"
+#include "IcarusImplementation.h"
+
+#include "BlockStream.h"
+#include "Sequence.h"
+#include "TaskManager.h"
+#include "Sequencer.h"
+
+#define STL_ITERATE( a, b )		for ( a = b.begin(); a != b.end(); a++ )
+#define STL_INSERT( a, b )		a.insert( a.end(), b );
+
+
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////
+//
+// required implementation of CIcarusInterface
+
+IIcarusInterface* IIcarusInterface::GetIcarus(int flavor,bool constructIfNecessary)
+{
+	if(!CIcarus::s_instances && constructIfNecessary)
+	{
+		CIcarus::s_flavorsAvailable = IGameInterface::s_IcarusFlavorsNeeded;
+		if (!CIcarus::s_flavorsAvailable)
+		{
+			return NULL;
+		}
+		CIcarus::s_instances = new CIcarus*[CIcarus::s_flavorsAvailable];
+		for (int index = 0; index < CIcarus::s_flavorsAvailable; index++)
+		{
+			CIcarus::s_instances[index] = new CIcarus(index);
+			//OutputDebugString( "ICARUS flavor successfully created\n" );
+		}
+	}
+	
+	if(flavor >= CIcarus::s_flavorsAvailable || !CIcarus::s_instances )
+	{
+		return NULL;
+	}
+	return CIcarus::s_instances[flavor];
+}
+
+void IIcarusInterface::DestroyIcarus()
+{
+	for(int index = 0; index < CIcarus::s_flavorsAvailable; index++)
+	{
+		delete CIcarus::s_instances[index];
+	}
+	delete[] CIcarus::s_instances;
+	CIcarus::s_instances = NULL;
+	CIcarus::s_flavorsAvailable = 0;
+}
+
+IIcarusInterface::~IIcarusInterface()
+{
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////
+//
+// CIcarus
+
+double CIcarus::ICARUS_VERSION = 1.40;
+
+int CIcarus::s_flavorsAvailable = 0;
+
+CIcarus** CIcarus::s_instances = NULL;
+
+CIcarus::CIcarus(int flavor) : 
+	m_flavor(flavor), m_nextSequencerID(0)
+{
+
+	m_GUID = 0;
+
+#ifdef _DEBUG
+
+	m_DEBUG_NumSequencerAlloc		= 0;
+	m_DEBUG_NumSequencerFreed		= 0;
+	m_DEBUG_NumSequencerResidual	= 0;
+
+	m_DEBUG_NumSequenceAlloc	= 0;
+	m_DEBUG_NumSequenceFreed	= 0;
+	m_DEBUG_NumSequenceResidual	= 0;
+
+#endif 
+
+	m_ulBufferCurPos = 0;
+	m_ulBytesRead = 0;
+	m_byBuffer = NULL;
+}
+
+CIcarus::~CIcarus()
+{
+	Delete();
+}
+
+#if defined (_DEBUG) && defined (_WIN32)
+#include "../qcommon/platform.h" // for OutputDebugString
+#endif
+
+void CIcarus::Delete( void )
+{
+
+	Free();
+
+#ifdef _DEBUG
+	
+	char	buffer[1024];
+
+	OutputDebugString( "\nICARUS Instance Debug Info:\n---------------------------\n" );
+
+	sprintf( (char *) buffer, "Sequencers Allocated:\t%d\n", m_DEBUG_NumSequencerAlloc );
+	OutputDebugString( (const char *) &buffer );
+
+	sprintf( (char *) buffer, "Sequencers Freed:\t\t%d\n", m_DEBUG_NumSequencerFreed );
+	OutputDebugString( (const char *) &buffer );
+
+	sprintf( (char *) buffer, "Sequencers Residual:\t%d\n\n", m_DEBUG_NumSequencerResidual );
+	OutputDebugString( (const char *) &buffer );
+
+	sprintf( (char *) buffer, "Sequences Allocated:\t%d\n", m_DEBUG_NumSequenceAlloc );
+	OutputDebugString( (const char *) &buffer );
+
+	sprintf( (char *) buffer, "Sequences Freed:\t\t%d\n", m_DEBUG_NumSequenceFreed );
+	OutputDebugString( (const char *) &buffer );
+
+	sprintf( (char *) buffer, "Sequences Residual:\t\t%d\n\n", m_DEBUG_NumSequenceResidual );
+	OutputDebugString( (const char *) &buffer );
+
+	OutputDebugString( "\n" );
+
+#endif
+}
+
+void CIcarus::Signal( const char *identifier )
+{
+	m_signals[ identifier ] = 1;
+}
+
+bool CIcarus::CheckSignal( const char *identifier )
+{
+	signal_m::iterator	smi;
+
+	smi = m_signals.find( identifier );
+
+	if ( smi == m_signals.end() )
+		return false;
+
+	return true;
+}
+
+void CIcarus::ClearSignal( const char *identifier )
+{
+	m_signals.erase( identifier );
+}
+
+void CIcarus::Free( void )
+{
+	sequencer_l::iterator	sri;
+
+	//Delete any residual sequencers
+	STL_ITERATE( sri, m_sequencers )
+	{
+		(*sri)->Free(this);
+		
+#ifdef _DEBUG
+
+		m_DEBUG_NumSequencerResidual++;
+
+#endif
+
+	}
+
+	m_sequencers.clear();
+	m_signals.clear();
+
+	sequence_l::iterator	si;
+
+	//Delete any residual sequences
+	STL_ITERATE( si, m_sequences )
+	{
+		(*si)->Delete(this);
+		delete (*si);
+
+#ifdef _DEBUG
+
+		m_DEBUG_NumSequenceResidual++;
+
+#endif
+
+	}
+
+	m_sequences.clear();
+
+	m_sequencerMap.clear();
+}
+
+int CIcarus::GetIcarusID( int gameID )
+{
+	CSequencer		*sequencer = CSequencer::Create();
+	CTaskManager	*taskManager = CTaskManager::Create();
+	
+	sequencer->Init( gameID, taskManager );
+
+	taskManager->Init( sequencer );
+
+	STL_INSERT( m_sequencers, sequencer );
+
+	m_sequencerMap[sequencer->GetID()] = sequencer;
+
+#ifdef _DEBUG
+
+	m_DEBUG_NumSequencerAlloc++;
+
+#endif
+	
+	return sequencer->GetID();
+}
+
+void CIcarus::DeleteIcarusID( int& icarusID )
+{
+	CSequencer* sequencer = FindSequencer(icarusID);
+	if(!sequencer)
+	{
+		icarusID = -1;
+		return;
+	}
+
+	CTaskManager	*taskManager = sequencer->GetTaskManager();
+	if (taskManager->IsResident())
+	{
+		IGameInterface::GetGame()->DebugPrint( IGameInterface::WL_ERROR, "Refusing DeleteIcarusID(%d) because it is running!\n", icarusID);
+		assert(0);
+		return;
+	}
+
+	m_sequencerMap.erase(icarusID);
+
+	// added 2/12/2 to properly delete blocks that were passed to the task manager
+	sequencer->Recall(this);
+
+
+	if ( taskManager )
+	{
+		taskManager->Free();
+		delete taskManager;
+	}
+
+	m_sequencers.remove( sequencer );	
+
+	sequencer->Free(this);
+
+#ifdef _DEBUG
+
+	m_DEBUG_NumSequencerFreed++;
+
+#endif
+	icarusID = -1;
+}
+
+CSequence *CIcarus::GetSequence( void )
+{
+	CSequence	*sequence = CSequence::Create();
+
+	//Assign the GUID
+	sequence->SetID( m_GUID++ );
+
+	STL_INSERT( m_sequences, sequence );
+
+#ifdef _DEBUG
+
+	m_DEBUG_NumSequenceAlloc++;
+
+#endif 
+
+	return sequence;
+}
+
+CSequence *CIcarus::GetSequence( int id )
+{
+	sequence_l::iterator	si;
+	STL_ITERATE( si, m_sequences )
+	{
+		if ( (*si)->GetID() == id )
+			return (*si);
+	}
+
+	return NULL;
+}
+
+void CIcarus::DeleteSequence( CSequence *sequence )
+{
+	m_sequences.remove( sequence );	
+
+	sequence->Delete(this);
+	delete sequence;
+
+#ifdef _DEBUG
+
+	m_DEBUG_NumSequenceFreed++;
+
+#endif 
+}
+
+int CIcarus::AllocateSequences( int numSequences, int *idTable )
+{
+	CSequence	*sequence;
+
+	for ( int i = 0; i < numSequences; i++ )
+	{
+		//If the GUID of this sequence is higher than the current, take this a the "current" GUID
+		if ( idTable[i] > m_GUID )
+			m_GUID = idTable[i];
+
+		//Allocate the container sequence
+		if ( ( sequence = GetSequence() ) == NULL )
+			return false;
+
+		//Override the given GUID with the real one
+		sequence->SetID( idTable[i] );
+	}
+
+	return true;
+}
+
+void CIcarus::Precache(char* buffer, long length)
+{
+	IGameInterface* game = IGameInterface::GetGame(m_flavor);
+	CBlockStream	stream;
+	CBlockMember	*blockMember;
+	CBlock			block;
+
+	if ( stream.Open( buffer, length ) == 0 )
+		return;
+
+	const char	*sVal1, *sVal2;
+
+	//Now iterate through all blocks of the script, searching for keywords
+	while ( stream.BlockAvailable() )
+	{
+		//Get a block
+		if ( stream.ReadBlock( &block, this ) == 0 )
+			return;
+
+		//Determine what type of block this is
+		switch( block.GetBlockID() )
+		{
+		case ID_CAMERA:	// to cache ROFF files
+			{
+				float f = *(float *) block.GetMemberData( 0 );
+
+				if (f == TYPE_PATH)
+				{
+					sVal1 = (const char *) block.GetMemberData( 1 );
+
+					game->PrecacheRoff(sVal1);
+				}
+			}
+			break;
+
+		case ID_PLAY:	// to cache ROFF files
+			
+			sVal1 = (const char *) block.GetMemberData( 0 );
+
+			if (!stricmp(sVal1,"PLAY_ROFF"))
+			{
+				sVal1 = (const char *) block.GetMemberData( 1 );
+
+				game->PrecacheRoff(sVal1);
+			}			
+			break;
+
+		//Run commands
+		case ID_RUN:
+			sVal1 = (const char *) block.GetMemberData( 0 );
+			game->PrecacheScript( sVal1 );
+			break;
+		
+		case ID_SOUND:
+			sVal1 = (const char *) block.GetMemberData( 1 );	//0 is channel, 1 is filename
+			game->PrecacheSound(sVal1);
+			break;
+
+		case ID_SET:
+			blockMember = block.GetMember( 0 );
+
+			//NOTENOTE: This will not catch special case get() inlines! (There's not really a good way to do that)
+
+			//Make sure we're testing against strings
+			if ( blockMember->GetID() == TK_STRING )
+			{
+				sVal1 = (const char *) block.GetMemberData( 0 );
+				sVal2 = (const char *) block.GetMemberData( 1 );
+		
+				game->PrecacheFromSet( sVal1 , sVal2);
+			}
+			break;
+
+		default:
+			break;
+		}
+
+		//Clean out the block for the next pass
+		block.Free(this);
+	}
+
+	//All done
+	stream.Free();
+}
+
+CSequencer* CIcarus::FindSequencer(int sequencerID)
+{
+	sequencer_m::iterator mi = m_sequencerMap.find( sequencerID );
+
+	if ( mi == m_sequencerMap.end() )
+		return NULL;
+
+	return (*mi).second;
+}
+
+int CIcarus::Run(int icarusID, char* buffer, long length)
+{
+	CSequencer* sequencer = FindSequencer(icarusID);
+	if(sequencer)
+	{
+		return sequencer->Run(buffer, length, this);
+	}
+	return ICARUS_INVALID;
+}
+
+int CIcarus::SaveSequenceIDTable()
+{
+	//Save out the number of sequences to follow
+	int		numSequences = m_sequences.size();
+
+	BufferWrite( &numSequences, sizeof( numSequences ) );
+
+	//Sequences are saved first, by ID and information
+	sequence_l::iterator	sqi;
+
+	//First pass, save all sequences ID for reconstruction
+	int	*idTable = new int[ numSequences ];
+	int	itr = 0;
+
+	if ( idTable == NULL )
+		return false;
+
+	STL_ITERATE( sqi, m_sequences )
+	{
+		idTable[itr++] = (*sqi)->GetID();
+	}
+
+	//game->WriteSaveData( 'SQTB', idTable, sizeof( int ) * numSequences );
+	BufferWrite( idTable, sizeof( int ) * numSequences );
+
+	delete[] idTable;
+
+	return true;
+}
+
+int CIcarus::SaveSequences()
+{
+	//Save out a listing of all the used sequences by ID
+	SaveSequenceIDTable();
+
+	//Save all the information in order
+	sequence_l::iterator	sqi;
+	STL_ITERATE( sqi, m_sequences )
+	{
+		(*sqi)->Save();
+	}
+
+	return true;
+}
+
+int CIcarus::SaveSequencers()
+{
+	//Save out the number of sequences to follow
+	int		numSequencers = m_sequencers.size();
+	BufferWrite( &numSequencers, sizeof( numSequencers ) );
+
+	//The sequencers are then saved
+	int sequencessaved = 0;
+	sequencer_l::iterator	si;
+	STL_ITERATE( si, m_sequencers )
+	{
+		(*si)->Save();
+		sequencessaved++;
+	}
+
+	assert( sequencessaved == numSequencers );
+
+	return true;
+}
+
+int CIcarus::SaveSignals()
+{
+	int	numSignals = m_signals.size();
+
+	//game->WriteSaveData( 'ISIG', &numSignals, sizeof( numSignals ) );
+	BufferWrite( &numSignals, sizeof( numSignals ) );
+
+	signal_m::iterator	si;
+	STL_ITERATE( si, m_signals )
+	{
+		//game->WriteSaveData( 'ISIG', &numSignals, sizeof( numSignals ) );
+		const char *name = ((*si).first).c_str();
+		
+		int length = strlen( name ) + 1;
+
+		//Save out the string size
+		BufferWrite( &length, sizeof( length ) );
+
+		//Write out the string
+		BufferWrite( (void *) name, length );
+	}
+
+	return true;
+}
+
+// Get the current Game flavor.
+int CIcarus::GetFlavor()
+{
+	return m_flavor;
+}
+
+int CIcarus::Save()
+{
+	// Allocate the temporary buffer.
+	CreateBuffer();
+
+	IGameInterface* game = IGameInterface::GetGame(m_flavor);
+
+	//Save out a ICARUS save block header with the ICARUS version
+	double	version = ICARUS_VERSION;
+	game->WriteSaveData( 'ICAR', &version, sizeof( version ) );
+
+	//Save out the signals
+	if ( SaveSignals() == false )
+	{
+		DestroyBuffer();
+		return false;
+	}
+
+	//Save out the sequences
+	if ( SaveSequences() == false )
+	{
+		DestroyBuffer();
+		return false;
+	}
+
+	//Save out the sequencers
+	if ( SaveSequencers() == false )
+	{
+		DestroyBuffer();
+		return false;
+	}
+
+	// Write out the buffer with all our collected data.
+	game->WriteSaveData( 'ISEQ', m_byBuffer, m_ulBufferCurPos );
+
+	// De-allocate the temporary buffer.
+	DestroyBuffer();
+
+	return true;
+}
+
+int CIcarus::LoadSignals()
+{
+	int numSignals;
+
+	BufferRead( &numSignals, sizeof( numSignals ) );
+
+	for ( int i = 0; i < numSignals; i++ )
+	{
+		char	buffer[1024];
+		int		length;
+
+		//Get the size of the string
+		BufferRead( &length, sizeof( length ) );
+
+		//Get the string
+		BufferRead( &buffer, length );
+
+		//Turn it on and add it to the system
+		Signal( (const char *) &buffer );
+	}
+
+	return true;
+}
+
+int CIcarus::LoadSequence()
+{
+	CSequence	*sequence = GetSequence();
+
+	//Load the sequence back in
+	sequence->Load(this);
+
+	//If this sequence had a higher GUID than the current, save it
+	if ( sequence->GetID() > m_GUID )
+		m_GUID = sequence->GetID();
+
+	return true;
+}
+
+int CIcarus::LoadSequences()
+{
+	CSequence	*sequence;
+	int			numSequences;
+
+	//Get the number of sequences to read in
+	BufferRead( &numSequences, sizeof( numSequences ) );
+
+	int	*idTable = new int[ numSequences ];
+
+	if ( idTable == NULL )
+		return false;
+
+	//Load the sequencer ID table
+	BufferRead( idTable, sizeof( int ) * numSequences );
+
+	//First pass, allocate all container sequences and give them their proper IDs
+	if ( AllocateSequences( numSequences, idTable ) == false )
+		return false;
+
+	//Second pass, load all sequences
+	for ( int i = 0; i < numSequences; i++ )
+	{
+		//Get the proper sequence for this load
+		if ( ( sequence = GetSequence( idTable[i] ) ) == NULL )
+			return false;
+
+		//Load the sequence
+		if ( ( sequence->Load(this) ) == false )
+			return false;
+	}
+
+	//Free the idTable
+	delete[] idTable;
+
+	return true;
+}
+
+int CIcarus::LoadSequencers()
+{
+	CSequencer	*sequencer;
+	int			numSequencers;
+	IGameInterface* game = IGameInterface::GetGame(m_flavor);
+
+	//Get the number of sequencers to load
+	BufferRead( &numSequencers, sizeof( numSequencers ) );
+
+	//Load all sequencers
+	for ( int i = 0; i < numSequencers; i++ )
+	{
+		//NOTENOTE: The ownerID will be replaced in the loading process
+		int sequencerID = GetIcarusID(-1);
+		if ( ( sequencer = FindSequencer(sequencerID) ) == NULL )
+			return false;
+
+		if ( sequencer->Load(this, game) == false )
+			return false;
+	}
+
+	return true;
+}
+
+int CIcarus::Load()
+{
+	CreateBuffer();
+
+	IGameInterface* game = IGameInterface::GetGame(m_flavor);
+
+	//Clear out any old information
+	Free();
+
+	//Check to make sure we're at the ICARUS save block
+	double	version;
+	game->ReadSaveData( 'ICAR', &version, sizeof( version ) );
+
+	//Versions must match!
+	if ( version != ICARUS_VERSION )
+	{
+		DestroyBuffer();
+		game->DebugPrint( IGameInterface::WL_ERROR, "save game data contains outdated ICARUS version information!\n");
+		return false;
+	}
+
+	// Read into the buffer all our data.
+	/*m_ulBytesAvailable = */game->ReadSaveData( 'ISEQ', m_byBuffer, 0 );	//fixme, use real buff size
+
+	//Load all signals
+	if ( LoadSignals() == false )
+	{
+		DestroyBuffer();
+		game->DebugPrint( IGameInterface::WL_ERROR, "failed to load signals from save game!\n");
+		return false;
+	}
+
+	//Load in all sequences
+	if ( LoadSequences() == false )
+	{
+		DestroyBuffer();
+		game->DebugPrint( IGameInterface::WL_ERROR, "failed to load sequences from save game!\n");
+		return false;
+	}
+
+	//Load in all sequencers
+	if ( LoadSequencers() == false )
+	{
+		DestroyBuffer();
+		game->DebugPrint( IGameInterface::WL_ERROR, "failed to load sequencers from save game!\n");
+		return false;
+	}
+
+	DestroyBuffer();
+
+	return true;
+}
+
+int CIcarus::Update(int icarusID)
+{
+	CSequencer* sequencer = FindSequencer(icarusID);
+	if(sequencer)
+	{
+		return sequencer->GetTaskManager()->Update(this);
+	}
+	return -1;
+}
+
+int CIcarus::IsRunning(int icarusID)
+{
+	CSequencer* sequencer = FindSequencer(icarusID);
+	if(sequencer)
+	{
+		return sequencer->GetTaskManager()->IsRunning();
+	}
+	return false;
+}
+
+void CIcarus::Completed( int icarusID, int taskID )
+{
+	CSequencer* sequencer = FindSequencer(icarusID);
+	if(sequencer)
+	{
+		sequencer->GetTaskManager()->Completed(taskID);
+	}
+}
+
+// Destroy the File Buffer.
+void CIcarus::DestroyBuffer()
+{
+	if ( m_byBuffer )
+	{
+		IGameInterface::GetGame()->Free( m_byBuffer );
+		m_byBuffer = NULL;
+	}
+}
+
+// Create the File Buffer.
+void CIcarus::CreateBuffer()
+{
+	DestroyBuffer();
+	m_byBuffer = (unsigned char *)IGameInterface::GetGame()->Malloc( MAX_BUFFER_SIZE );
+	m_ulBufferCurPos = 0;
+}
+
+// Write to a buffer.
+void CIcarus::BufferWrite( void *pSrcData, unsigned long ulNumBytesToWrite )
+{
+	if ( !pSrcData )
+		return;
+
+	// Make sure we have enough space in the buffer to write to.
+	if ( MAX_BUFFER_SIZE - m_ulBufferCurPos < ulNumBytesToWrite )
+	{	// Write out the buffer with all our collected data so far...
+		IGameInterface::GetGame()->DebugPrint( IGameInterface::WL_ERROR, "BufferWrite: Out of buffer space, Flushing." );
+		IGameInterface::GetGame()->WriteSaveData( 'ISEQ', m_byBuffer, m_ulBufferCurPos );
+		m_ulBufferCurPos = 0;	//reset buffer
+	}
+	
+	assert( MAX_BUFFER_SIZE - m_ulBufferCurPos >= ulNumBytesToWrite );
+	{
+		memcpy( m_byBuffer + m_ulBufferCurPos, pSrcData, ulNumBytesToWrite );
+		m_ulBufferCurPos += ulNumBytesToWrite;
+	}
+}
+
+// Read from a buffer.
+void CIcarus::BufferRead( void *pDstBuff, unsigned long ulNumBytesToRead )
+{
+	if ( !pDstBuff )
+		return;
+
+	// If we can read this data...
+	if ( m_ulBytesRead + ulNumBytesToRead > MAX_BUFFER_SIZE )
+	{// We've tried to read past the buffer...
+		IGameInterface::GetGame()->DebugPrint( IGameInterface::WL_ERROR, "BufferRead: Buffer underflow, Looking for new block." );
+		// Read in the next block.
+		/*m_ulBytesAvailable = */IGameInterface::GetGame()->ReadSaveData( 'ISEQ', m_byBuffer, 0 );	//FIXME, to actually check underflows, use real buff size
+		m_ulBytesRead = 0;	//reset buffer
+	}
+
+	assert(m_ulBytesRead + ulNumBytesToRead <= MAX_BUFFER_SIZE);
+	{
+		memcpy( pDstBuff, m_byBuffer + m_ulBytesRead, ulNumBytesToRead );
+		m_ulBytesRead += ulNumBytesToRead;
+	}
+}
\ No newline at end of file
diff --git a/code/icarus/IcarusImplementation.h b/code/icarus/IcarusImplementation.h
new file mode 100644
index 0000000..74d7e87
--- /dev/null
+++ b/code/icarus/IcarusImplementation.h
@@ -0,0 +1,253 @@
+// IcarusImplementation.h
+#ifndef ICARUSIMPLEMENTATION_DEFINED
+#define ICARUSIMPLEMENTATION_DEFINED
+
+#ifndef ICARUSINTERFACE_DEFINED
+#include "IcarusInterface.h"
+#endif
+
+#pragma warning( disable : 4786 )	// identifier was truncated 
+#pragma warning (push, 3)			// go back down to 3 for the stl include
+#pragma warning (disable:4503)		// decorated name length xceeded, name was truncated
+#include <string>
+#include <vector>
+#include <map>
+#include <list>
+#include <algorithm>
+#pragma warning (pop)
+#pragma warning (disable:4503)		// decorated name length xceeded, name was truncated
+using namespace std;
+
+
+class CSequence;
+class CSequencer;
+
+class CIcarusSequencer;
+class CIcarusSequence;
+
+class CIcarus : public IIcarusInterface
+{
+public:
+	CIcarus(int flavor);
+	virtual ~CIcarus();
+
+	inline IGameInterface* GetGame() {return IGameInterface::GetGame(m_flavor);};
+
+	enum
+	{
+		MAX_STRING_SIZE			= 256,
+		MAX_FILENAME_LENGTH		= 1024,
+	};
+
+protected:
+	int						m_flavor;
+	int						m_nextSequencerID;
+
+	int						m_GUID;
+
+	typedef list< CSequence * >				sequence_l;
+	typedef list< CSequencer * >			sequencer_l;
+	typedef map < int, CSequencer* >		sequencer_m;
+
+	sequence_l				m_sequences;
+	sequencer_l				m_sequencers;
+	sequencer_m				m_sequencerMap;
+
+	typedef map < string, unsigned char >	signal_m;
+	signal_m				m_signals;
+
+	static double ICARUS_VERSION;
+
+#ifdef _DEBUG
+
+	int	m_DEBUG_NumSequencerAlloc;
+	int	m_DEBUG_NumSequencerFreed;
+	int m_DEBUG_NumSequencerResidual;
+
+	int	m_DEBUG_NumSequenceAlloc;
+	int	m_DEBUG_NumSequenceFreed;
+	int m_DEBUG_NumSequenceResidual;
+
+#endif
+
+public:
+	static int				s_flavorsAvailable;
+	static CIcarus**		s_instances;
+
+	// mandatory overrides
+	// Get the current Game flavor.
+	int GetFlavor();
+
+	int Save();
+	int Load();
+	int Run(int icarusID, char* buffer, long length);
+	void DeleteIcarusID(int& icarusID);
+	int GetIcarusID(int ownerID);
+	int Update(int icarusID);
+
+	int IsRunning(int icarusID);
+	void Completed( int icarusID, int taskID );
+	void Precache(char* buffer, long length);
+
+protected:
+	void Delete();
+	void Free();
+
+public:
+	CSequence* GetSequence(int id);
+	void DeleteSequence( CSequence *sequence );
+	int AllocateSequences( int numSequences, int *idTable );
+	CSequencer* FindSequencer(int sequencerID);
+	CSequence* GetSequence();
+
+protected:
+	int SaveSequenceIDTable();
+	int SaveSequences();
+	int SaveSequencers();
+	int SaveSignals();
+
+	int LoadSignals();
+	int LoadSequence();
+	int LoadSequences();
+	int LoadSequencers();
+
+public:
+	void Signal( const char *identifier );
+	bool CheckSignal( const char *identifier );
+	void ClearSignal( const char *identifier );
+
+	// Overloaded new operator.
+	inline void *operator new( size_t size )
+	{
+		return IGameInterface::GetGame()->Malloc( size );
+	}
+
+	// Overloaded delete operator.
+	inline void operator delete( void *pRawData )
+	{
+		// Free the Memory.
+		IGameInterface::GetGame()->Free( pRawData );
+	}
+
+public:
+	enum 
+	{
+		TK_EOF = -1,
+		TK_UNDEFINED,
+		TK_COMMENT,
+		TK_EOL,
+		TK_CHAR,
+		TK_STRING,
+		TK_INT,
+		TK_INTEGER = TK_INT,
+		TK_FLOAT,
+		TK_IDENTIFIER,
+		TK_USERDEF,
+		TK_BLOCK_START = TK_USERDEF,
+		TK_BLOCK_END,
+		TK_VECTOR_START,
+		TK_VECTOR_END,
+		TK_OPEN_PARENTHESIS,
+		TK_CLOSED_PARENTHESIS,
+		TK_VECTOR,
+		TK_GREATER_THAN,
+		TK_LESS_THAN,
+		TK_EQUALS,
+		TK_NOT,
+
+		NUM_USER_TOKENS
+	};
+
+	//ID defines
+	enum
+	{
+		ID_AFFECT = NUM_USER_TOKENS,
+		ID_SOUND,
+		ID_MOVE,
+		ID_ROTATE,
+		ID_WAIT,
+		ID_BLOCK_START,
+		ID_BLOCK_END,
+		ID_SET,
+		ID_LOOP,
+		ID_LOOPEND,
+		ID_PRINT,
+		ID_USE,
+		ID_FLUSH,
+		ID_RUN,
+		ID_KILL,
+		ID_REMOVE,
+		ID_CAMERA,
+		ID_GET,
+		ID_RANDOM,
+		ID_IF,
+		ID_ELSE,
+		ID_REM,
+		ID_TASK,
+		ID_DO,
+		ID_DECLARE,
+		ID_FREE,
+		ID_DOWAIT,
+		ID_SIGNAL,
+		ID_WAITSIGNAL,
+		ID_PLAY,
+
+		ID_TAG,
+		ID_EOF,
+		NUM_IDS
+	};
+
+	//Type defines
+	enum
+	{
+		//Wait types
+		TYPE_WAIT_COMPLETE	 = NUM_IDS,
+		TYPE_WAIT_TRIGGERED,
+
+		//Set types
+		TYPE_ANGLES,
+		TYPE_ORIGIN,
+
+		//Affect types
+		TYPE_INSERT,	
+		TYPE_FLUSH,	
+		
+		//Camera types
+		TYPE_PAN,
+		TYPE_ZOOM,
+		TYPE_MOVE,
+		TYPE_FADE,
+		TYPE_PATH,
+		TYPE_ENABLE,
+		TYPE_DISABLE,
+		TYPE_SHAKE,
+		TYPE_ROLL,
+		TYPE_TRACK,
+		TYPE_DISTANCE,
+		TYPE_FOLLOW,
+			
+		//Variable type
+		TYPE_VARIABLE,
+
+		TYPE_EOF,
+		NUM_TYPES
+	};
+
+	// Used by the new Icarus Save code.
+	enum { MAX_BUFFER_SIZE = 100000 };
+	unsigned long m_ulBufferCurPos;
+	unsigned long m_ulBytesRead;
+	unsigned char *m_byBuffer;
+	// Destroy the File Buffer.
+	void DestroyBuffer();
+	// Create the File Buffer.
+	void CreateBuffer();
+	// Reset the buffer completely.
+	void ResetBuffer();
+	// Write to a buffer.
+	void BufferWrite( void *pSrcData, unsigned long ulNumBytesToWrite );
+	// Read from a buffer.
+	void BufferRead( void *pDstBuff, unsigned long ulNumBytesToRead );
+};
+
+#endif
\ No newline at end of file
diff --git a/code/icarus/IcarusInterface.h b/code/icarus/IcarusInterface.h
new file mode 100644
index 0000000..8a10f87
--- /dev/null
+++ b/code/icarus/IcarusInterface.h
@@ -0,0 +1,143 @@
+#pragma once
+#ifndef ICARUSINTERFACE_DEFINED
+#define ICARUSINTERFACE_DEFINED
+
+// IcarusInterface.h: ICARUS Interface header file.
+// -Date: ~October, 2002
+// -Created by: Mike Crowns and Aurelio Reis.
+// -Description: The new interface between a Game Engine and the Icarus Scripting Language.
+// An Interface is an Abstract Base Class with pure virtual members that MUST be implemented
+// in order for the compile to succeed. Because of this, all needed functionality can be
+// added without compromising other core systems.
+// -Usage: To use the new Icarus Interface, two classes must be derived. The first is the
+// actual Icarus Interface class which contains all relevent functionality to the scripting
+// system. The second is the Game Interface which is very much more broad and thus implemented
+// by the user. Icarus functions by calling the Game Interface to do certain tasks for it. This
+// is why the Game Interface is required to have certain functions implemented.
+
+
+// The basic Icarus Interface ABC.
+class IIcarusInterface
+{
+public:
+	enum { ICARUS_INVALID = 0 };
+	virtual ~IIcarusInterface();
+
+	// Get a static singleton instance (of a specific flavor).
+	static IIcarusInterface* GetIcarus(int flavor = 0,bool constructIfNecessary=true);		// must be implemented along with concrete class
+	static void DestroyIcarus();		// Destroy the static singleton instance.
+
+	virtual int GetFlavor() = 0;
+
+	virtual int Save() = 0;				// Save all Icarus states.
+	virtual int Load() = 0;				// Load all Icarus states.
+
+	virtual int Run(int icarusID, char* buffer, long length) = 0;	// Execute a script.
+	virtual void DeleteIcarusID(int &icarusID) = 0;				// Delete an Icarus ID from the list (making the ID Invalid on the other end through reference).
+	virtual int GetIcarusID(int gameID) = 0;					// Get an Icarus ID.
+	virtual int Update( int icarusID ) = 0;						// Update all internal Icarus structures.
+	virtual int IsRunning( int icarusID ) = 0;					// Whether a Icarus is running or not.
+	virtual void Completed( int icarusID, int taskID ) = 0;		// Tells Icarus a task is completed.
+	virtual void Precache( char* buffer, long length ) = 0;		// Precache a Script in memory.
+};
+
+// Description: The Game Interface is used by the Icarus Interface to access specific
+// data or initiate certain things within the engine being used. It is made to be
+// as generic as possible to allow any engine to derive it's own interface for use.
+// Created: 10/08/02 by Aurelio Reis.
+class IGameInterface
+{
+protected:
+	// Pure Virtual Destructor.
+	virtual ~IGameInterface();
+
+public:
+	//For system-wide prints
+	enum e_DebugPrintLevel { WL_ERROR = 1, WL_WARNING, WL_VERBOSE, WL_DEBUG };
+
+	// How many flavors are needed.
+	static int s_IcarusFlavorsNeeded;
+
+	// Get a static singleton instance (of a specific flavor).
+	static IGameInterface *GetGame( int flavor = 0 );
+
+	// Destroy the static singleton instance (NOTE: Destroy the Game Interface BEFORE the Icarus Interface).
+	static void Destroy();
+
+	// General
+	// Load a script File into the destination buffer. If the script has already been loaded
+	// NOTE: This is what was called before:
+	/*
+	// Description	: Reads in a file and attaches the script directory properly
+	extern int ICARUS_GetScript( const char *name, char **buf );	//g_icarus.cpp
+	static int Q3_ReadScript( const char *name, void **buf )
+	{
+		return ICARUS_GetScript( va( "%s/%s", Q3_SCRIPT_DIR, name ), (char**)buf );	//get a (hopefully) cached file
+	}
+	*/
+	virtual int		GetFlavor() = 0;
+
+	virtual int		LoadFile( const char *name, void **buf ) = 0;
+	virtual void	CenterPrint( const char *format, ... ) = 0;
+	virtual void	DebugPrint( e_DebugPrintLevel, const char *, ... ) = 0;
+	virtual unsigned int GetTime( void ) = 0;							//Gets the current time
+	virtual int 	PlaySound( int taskID, int gameID, const char *name, const char *channel ) = 0;
+	virtual void	Lerp2Pos( int taskID, int gameID, float origin[3], float angles[3], float duration ) = 0;
+	virtual void	Lerp2Angles( int taskID, int gameID, float angles[3], float duration ) = 0;
+	virtual int		GetTag( int gameID, const char *name, int lookup, float info[3] ) = 0;
+	virtual void	Set( int taskID, int gameID, const char *type_name, const char *data ) = 0;
+	virtual void	Use( int gameID, const char *name ) = 0;
+	virtual void	Activate( int gameID, const char *name ) = 0;
+	virtual void	Deactivate( int gameID, const char *name ) = 0;
+	virtual void	Kill( int gameID, const char *name ) = 0;
+	virtual void	Remove( int gameID, const char *name )  = 0;
+	virtual float	Random( float min, float max ) = 0;
+	virtual void	Play( int taskID, int gameID, const char *type, const char *name ) = 0;
+
+	// Camera functions
+	virtual void	CameraPan( float angles[3], float dir[3], float duration ) = 0;
+	virtual void	CameraMove( float origin[3], float duration ) = 0;
+	virtual void	CameraZoom( float fov, float duration ) = 0;
+	virtual void	CameraRoll( float angle, float duration ) = 0;
+	virtual void	CameraFollow( const char *name, float speed, float initLerp ) = 0;
+	virtual void	CameraTrack( const char *name, float speed, float initLerp ) = 0;
+	virtual void	CameraDistance( float dist, float initLerp ) = 0;
+	virtual void	CameraFade( float sr, float sg, float sb, float sa, float dr, float dg, float db, float da, float duration ) = 0;
+	virtual void	CameraPath( const char *name ) = 0;
+	virtual void	CameraEnable( void ) = 0;
+	virtual void	CameraDisable( void ) = 0;
+	virtual void	CameraShake( float intensity, int duration ) = 0;
+
+	virtual int		GetFloat( int gameID, const char *name, float *value ) = 0;
+	// Should be float return type?
+	virtual int		GetVector( int gameID, const char *name, float value[3] ) = 0;
+	virtual int		GetString( int gameID, const char *name, char **value ) = 0;
+
+	virtual int		Evaluate( int p1Type, const char *p1, int p2Type, const char *p2, int operatorType ) = 0;
+
+	virtual void	DeclareVariable( int type, const char *name ) = 0;
+	virtual void	FreeVariable( const char *name ) = 0;
+
+	// Save / Load functions
+
+	virtual int		WriteSaveData( unsigned long chid, void *data, int length ) = 0;
+	virtual int		ReadSaveData( unsigned long chid, void *address, int length, void **addressptr = NULL )  = 0;
+	virtual int		LinkGame( int gameID, int icarusID ) = 0;
+	
+	// Access functions
+
+	virtual int		CreateIcarus( int gameID) = 0;
+	virtual int		GetByName( const char *name ) = 0;		//Polls the engine for the sequencer of the entity matching the name passed
+	virtual int		IsFrozen(int gameID) = 0;					// (g_entities[m_ownerID].svFlags&SVF_ICARUS_FREEZE)																	// return -1 indicates invalid
+	virtual void	Free(void* data) = 0;
+	virtual void*	Malloc( int size ) = 0;
+	virtual float	MaxFloat(void) = 0;
+
+	// Script precache functions.
+	virtual void	PrecacheRoff(const char* name) = 0;		// G_LoadRoff
+	virtual void	PrecacheScript(const char* name) = 0;	// must strip extension COM_StripExtension()
+	virtual void	PrecacheSound(const char* name) = 0;	// G_SoundIndex
+	virtual void	PrecacheFromSet(const char* setname, const char* filename) = 0;
+};
+
+#endif
\ No newline at end of file
diff --git a/code/icarus/Sequence.cpp b/code/icarus/Sequence.cpp
new file mode 100644
index 0000000..db3f2bf
--- /dev/null
+++ b/code/icarus/Sequence.cpp
@@ -0,0 +1,674 @@
+// Script Command Sequences
+//
+//	-- jweier
+
+// this include must remain at the top of every Icarus CPP file
+#include "stdafx.h"
+#include "IcarusImplementation.h"
+
+#include "BlockStream.h"
+#include "Sequence.h"
+
+#define STL_ITERATE( a, b )		for ( a = b.begin(); a != b.end(); a++ )
+#define STL_INSERT( a, b )		a.insert( a.end(), b );
+
+
+inline CSequence::CSequence( void )
+{
+	m_numCommands	= 0;
+//	m_numChildren	= 0;
+	m_flags			= 0;
+	m_iterations	= 1;
+
+	m_parent		= NULL;
+	m_return		= NULL;
+}
+
+CSequence::~CSequence( void )
+{
+	assert(!m_commands.size());
+	//assert(!m_numChildren);
+}
+
+/*
+-------------------------
+Create
+-------------------------
+*/
+
+CSequence *CSequence::Create( void )
+{
+	CSequence *seq = new CSequence;
+
+	//TODO: Emit warning
+	assert(seq);
+	if ( seq == NULL )
+		return NULL;
+
+	seq->SetFlag( SQ_COMMON );
+
+	return seq;
+}
+
+/*
+-------------------------
+Delete
+-------------------------
+*/
+
+void CSequence::Delete( CIcarus* icarus )
+{
+	block_l::iterator	bi;
+	sequence_l::iterator si;
+
+	//Notify the parent of the deletion
+	if ( m_parent )
+	{
+		m_parent->RemoveChild( this );
+	}
+
+	//Clear all children
+	if ( m_children.size() > 0 )
+	{
+		/*for ( iterSeq = m_childrenMap.begin(); iterSeq != m_childrenMap.end(); iterSeq++ )
+		{
+			(*iterSeq).second->SetParent( NULL );
+		}*/
+		
+		for ( si = m_children.begin(); si != m_children.end(); si++ )
+		{
+			(*si)->SetParent( NULL );
+		}
+	}
+	m_children.clear();
+	//m_childrenMap.clear();
+
+	//Clear all held commands
+	for ( bi = m_commands.begin(); bi != m_commands.end(); bi++ )
+	{
+		(*bi)->Free(icarus);
+		delete (*bi);	//Free() handled internally -- not any more!!
+	}
+
+	m_commands.clear();
+	
+}
+
+
+/*
+-------------------------
+AddChild
+-------------------------
+*/
+
+void CSequence::AddChild( CSequence *child )
+{
+	assert( child );
+	if ( child == NULL )
+		return;
+
+	m_children.insert( m_children.end(), child );
+//	m_childrenMap[ m_numChildren ] = child;
+//	m_numChildren++;
+}
+
+/*
+-------------------------
+RemoveChild
+-------------------------
+*/
+
+void CSequence::RemoveChild( CSequence *child )
+{
+	assert( child );
+	if ( child == NULL )
+		return;
+	
+	m_children.remove( child );
+
+	//Remove the child
+/*	sequenceID_m::iterator iterSeq = m_childrenMap.find( child->GetID() );
+	if ( iterSeq != m_childrenMap.end() )
+	{
+		m_childrenMap.erase( iterSeq );
+	}
+
+	m_numChildren--;*/
+}
+
+/*
+-------------------------
+HasChild
+-------------------------
+*/
+
+bool CSequence::HasChild( CSequence *sequence )
+{
+	sequence_l::iterator	ci;
+
+	for ( ci = m_children.begin(); ci != m_children.end(); ci++ )
+	{
+		if ( (*ci) == sequence )
+			return true;
+
+		if ( (*ci)->HasChild( sequence ) )
+			return true;
+	}
+
+/*	sequenceID_m::iterator iterSeq = NULL;
+	for ( iterSeq = m_childrenMap.begin(); iterSeq != m_childrenMap.end(); iterSeq++ )
+	{
+		if ( ((*iterSeq).second) == sequence )
+			return true;
+
+		if ( (*iterSeq).second->HasChild( sequence ) )
+			return true;
+	}*/
+
+	return false;
+}
+
+/*
+-------------------------
+SetParent
+-------------------------
+*/
+
+void CSequence::SetParent( CSequence *parent )
+{
+	m_parent = parent;
+
+	if ( parent == NULL )
+		return;
+
+	//Inherit the parent's properties (this avoids messy tree walks later on)
+	if ( parent->m_flags & SQ_RETAIN )
+		m_flags |= SQ_RETAIN;
+
+	if ( parent->m_flags & SQ_PENDING )
+		m_flags |= SQ_PENDING;	
+}
+
+/*
+-------------------------
+PopCommand
+-------------------------
+*/
+
+CBlock *CSequence::PopCommand( int type )
+{
+	CBlock	*command = NULL;
+
+	//Make sure everything is ok
+	assert( (type == POP_FRONT) || (type == POP_BACK) );
+
+	if ( m_commands.empty() )
+		return NULL;
+
+	switch ( type )
+	{
+	case POP_FRONT:
+
+		command = m_commands.front();
+		m_commands.pop_front();
+		m_numCommands--;
+	
+		return command;
+		break;
+
+	case POP_BACK:
+
+		command = m_commands.back();
+		m_commands.pop_back();
+		m_numCommands--;
+		
+		return command;
+		break;
+	}
+
+	//Invalid flag
+	return NULL;
+}
+
+/*
+-------------------------
+PushCommand
+-------------------------
+*/
+
+int CSequence::PushCommand( CBlock *block, int type )
+{
+	//Make sure everything is ok
+	assert( (type == PUSH_FRONT) || (type == PUSH_BACK) );
+	assert( block );
+
+	switch ( type )
+	{
+	case PUSH_FRONT:
+		
+		m_commands.push_front( block );
+		m_numCommands++;
+
+		return true;
+		break;
+
+	case PUSH_BACK:
+
+		m_commands.push_back( block );
+		m_numCommands++;
+
+		return true;
+		break;
+	}
+
+	//Invalid flag
+	return false;
+}
+
+/*
+-------------------------
+SetFlag
+-------------------------
+*/
+
+void CSequence::SetFlag( int flag )
+{
+	m_flags |= flag;
+}
+
+/*
+-------------------------
+RemoveFlag
+-------------------------
+*/
+
+void CSequence::RemoveFlag( int flag, bool children )
+{
+	m_flags &= ~flag;
+
+	if ( children )
+	{
+/*		sequenceID_m::iterator iterSeq = NULL;
+		for ( iterSeq = m_childrenMap.begin(); iterSeq != m_childrenMap.end(); iterSeq++ )
+		{
+			(*iterSeq).second->RemoveFlag( flag, true );
+		}*/
+
+		sequence_l::iterator	si;
+		for ( si = m_children.begin(); si != m_children.end(); si++ )
+		{
+			(*si)->RemoveFlag( flag, true );
+		}
+	}
+}
+
+/*
+-------------------------
+HasFlag
+-------------------------
+*/
+
+int CSequence::HasFlag( int flag )
+{
+	return (m_flags & flag);
+}
+
+/*
+-------------------------
+SetReturn
+-------------------------
+*/
+
+void CSequence::SetReturn ( CSequence *sequence )
+{
+	assert( sequence != this );
+	m_return = sequence;
+}
+
+/*
+-------------------------
+GetChildByID
+-------------------------
+*/
+
+CSequence *CSequence::GetChildByID( int id )
+{
+	if ( id < 0 )
+		return NULL;
+
+	//NOTENOTE: Done for safety reasons, I don't know what this template will return on underflow ( sigh... )
+/*	sequenceID_m::iterator mi = m_childrenMap.find( id );
+
+	if ( mi == m_childrenMap.end() )
+		return NULL;
+
+	return (*mi).second;*/
+
+	sequence_l::iterator iterSeq;
+	STL_ITERATE( iterSeq, m_children )
+	{
+		if ( (*iterSeq)->GetID() == id )
+			return (*iterSeq);
+	}
+
+	return NULL;
+}
+
+/*
+-------------------------
+GetChildByIndex
+-------------------------
+*/
+
+CSequence *CSequence::GetChildByIndex( int iIndex )
+{
+	if ( iIndex < 0 || iIndex >= (int)m_children.size() )
+		return NULL;
+
+	sequence_l::iterator iterSeq = m_children.begin();
+	for ( int i = 0; i < iIndex; i++  )
+	{
+		++iterSeq;
+	}
+	return (*iterSeq);
+}
+
+/*
+-------------------------
+SaveCommand
+-------------------------
+*/
+
+int CSequence::SaveCommand( CBlock *block )
+{
+	CIcarus *pIcarus = (CIcarus *)IIcarusInterface::GetIcarus();
+
+	unsigned char	flags;
+	int				numMembers, bID, size;
+	CBlockMember	*bm;
+
+	// Data saved here (IBLK):
+	//	Block ID.
+	//	Block Flags.
+	//	Number of Block Members.
+	//	Block Members:
+	//				- Block Member ID.
+	//				- Block Data Size.
+	//				- Block (Raw) Data.
+
+	//Save out the block ID
+	bID = block->GetBlockID();
+	pIcarus->BufferWrite( &bID, sizeof ( bID ) );
+
+	//Save out the block's flags
+	flags = block->GetFlags();
+	pIcarus->BufferWrite( &flags, sizeof ( flags ) );
+
+	//Save out the number of members to read
+	numMembers = block->GetNumMembers();
+	pIcarus->BufferWrite( &numMembers, sizeof ( numMembers ) );
+
+	for ( int i = 0; i < numMembers; i++ )
+	{
+		bm = block->GetMember( i );
+
+		//Save the block id
+		bID = bm->GetID();
+		pIcarus->BufferWrite( &bID, sizeof ( bID ) );
+		
+		//Save out the data size
+		size = bm->GetSize();
+		pIcarus->BufferWrite( &size, sizeof ( size ) );
+		
+		//Save out the raw data
+		pIcarus->BufferWrite( bm->GetData(), size );
+	}
+
+	return true;
+}
+
+int CSequence::LoadCommand( CBlock *block, CIcarus *icarus )
+{
+	IGameInterface* game = icarus->GetGame();
+	int				bID, bSize;
+	void			*bData;
+	unsigned char	flags; 
+	int				id, numMembers;
+
+	// Data expected/loaded here (IBLK) (with the size as : 'IBSZ' ).
+	//	Block ID.
+	//	Block Flags.
+	//	Number of Block Members.
+	//	Block Members:
+	//				- Block Member ID.
+	//				- Block Data Size.
+	//				- Block (Raw) Data.
+	
+	//Get the block ID.
+	icarus->BufferRead( &id, sizeof( id ) );
+	block->Create( id );
+
+	//Read the block's flags
+	icarus->BufferRead( &flags, sizeof( flags ) );
+	block->SetFlags( flags );
+
+	//Get the number of block members
+	icarus->BufferRead( &numMembers, sizeof( numMembers ) );
+	
+	for ( int j = 0; j < numMembers; j++ )
+	{
+		//Get the member ID
+		icarus->BufferRead( &bID, sizeof( bID ) );
+		
+		//Get the member size
+		icarus->BufferRead( &bSize, sizeof( bSize ) );
+
+		//Get the member's data
+		if ( ( bData = game->Malloc( bSize ) ) == NULL )
+			return false;
+
+		//Get the actual raw data
+		icarus->BufferRead( bData, bSize );
+
+		//Write out the correct type
+		switch ( bID )
+		{
+		case CIcarus::TK_INT:
+			{
+				assert(0);
+				int data = *(int *) bData;
+				block->Write( CIcarus::TK_FLOAT, (float) data, icarus );
+			}
+			break;
+
+		case CIcarus::TK_FLOAT:
+			block->Write( CIcarus::TK_FLOAT, *(float *) bData, icarus );
+			break;
+
+		case CIcarus::TK_STRING:
+		case CIcarus::TK_IDENTIFIER:
+		case CIcarus::TK_CHAR:
+			block->Write( CIcarus::TK_STRING, (char *) bData, icarus );
+			break;
+
+		case CIcarus::TK_VECTOR:
+		case CIcarus::TK_VECTOR_START:
+			block->Write( CIcarus::TK_VECTOR, *(vec3_t *) bData, icarus );
+			break;
+
+		case CIcarus::ID_TAG:
+			block->Write( CIcarus::ID_TAG, (float) CIcarus::ID_TAG, icarus );
+			break;
+
+		case CIcarus::ID_GET:
+			block->Write( CIcarus::ID_GET, (float) CIcarus::ID_GET, icarus );
+			break;
+
+		case CIcarus::ID_RANDOM:
+			block->Write( CIcarus::ID_RANDOM, *(float *) bData, icarus );//(float) ID_RANDOM );
+			break;
+		
+		case CIcarus::TK_EQUALS:
+		case CIcarus::TK_GREATER_THAN:
+		case CIcarus::TK_LESS_THAN:
+		case CIcarus::TK_NOT:
+			block->Write( bID, 0, icarus );
+			break;
+
+		default:
+			assert(0);
+			return false;
+			break;
+		}
+		
+		//Get rid of the temp memory
+		game->Free( bData );
+	}
+
+	return true;
+}
+
+/*
+-------------------------
+Save
+-------------------------
+*/
+
+int CSequence::Save()
+{
+	// Data saved here.
+	//	Parent ID.
+	//	Return ID.
+	//	Number of Children.
+	//	Children.
+	//			- Child ID
+	//	Save Flags.
+	//	Save Iterations.
+	//	Number of Commands
+	//			- Commands (raw) data.
+
+	CIcarus *pIcarus = (CIcarus *)IIcarusInterface::GetIcarus();
+
+	block_l::iterator		bi;
+	int						id;
+
+	// Save the parent (by GUID).
+	id = ( m_parent != NULL ) ? m_parent->GetID() : -1;
+	pIcarus->BufferWrite( &id, sizeof( id ) );
+
+	//Save the return (by GUID)
+	id = ( m_return != NULL ) ? m_return->GetID() : -1;
+	pIcarus->BufferWrite( &id, sizeof( id ) );
+	
+	//Save the number of children
+	int iNumChildren = m_children.size();
+	pIcarus->BufferWrite( &iNumChildren, sizeof( iNumChildren ) );
+
+	//Save out the children (only by GUID)
+	/*STL_ITERATE( iterSeq, m_childrenMap )
+	{
+		id = (*iterSeq).second->GetID();
+		pIcarus->BufferWrite( &id, sizeof( id ) );
+	}*/
+	sequence_l::iterator iterSeq;
+	STL_ITERATE( iterSeq, m_children )
+	{
+		id = (*iterSeq)->GetID();
+		pIcarus->BufferWrite( &id, sizeof( id ) );
+	}
+
+	//Save flags
+	pIcarus->BufferWrite( &m_flags, sizeof( m_flags ) );
+
+	//Save iterations
+	pIcarus->BufferWrite( &m_iterations, sizeof( m_iterations ) );
+
+	//Save the number of commands
+	pIcarus->BufferWrite( &m_numCommands, sizeof( m_numCommands ) );
+
+	//Save the commands
+	STL_ITERATE( bi, m_commands )
+	{
+		SaveCommand( (*bi) );
+	}
+
+	return true;
+}
+
+/*
+-------------------------
+Load
+-------------------------
+*/
+
+int CSequence::Load( CIcarus* icarus )
+{
+	CSequence		*sequence;
+	CBlock			*block;
+	int				id;
+
+	// Data expected/loaded here (ISEQ) (with the size as : 'ISSZ' ).
+	//	Parent ID.
+	//	Return ID.
+	//	Number of Children.
+	//	Children.
+	//			- Child ID
+	//	Save Flags.
+	//	Save Iterations.
+	//	Number of Commands
+	//			- Commands (raw) data.
+
+	//Get the parent sequence
+	icarus->BufferRead( &id, sizeof( id ) );
+	m_parent = ( id != -1 ) ? icarus->GetSequence( id ) : NULL;
+	
+	//Get the return sequence
+	icarus->BufferRead( &id, sizeof( id ) );
+	m_return = ( id != -1 ) ? icarus->GetSequence( id ) : NULL;
+
+	//Get the number of children
+	int iNumChildren = 0;
+	icarus->BufferRead( &iNumChildren, sizeof( iNumChildren ) );
+
+	//Reload all children
+	for ( int i = 0; i < iNumChildren; i++ )
+	{
+		//Get the child sequence ID
+		icarus->BufferRead( &id, sizeof( id ) );
+
+		//Get the desired sequence
+		if ( ( sequence = icarus->GetSequence( id ) ) == NULL )
+			return false;
+		
+		//Insert this into the list
+		STL_INSERT( m_children, sequence );
+
+		//Restore the connection in the child / ID map
+//		m_childrenMap[ i ] = sequence;
+	}
+
+	
+	//Get the sequence flags
+	icarus->BufferRead( &m_flags, sizeof( m_flags ) );
+
+	//Get the number of iterations
+	icarus->BufferRead( &m_iterations, sizeof( m_iterations ) );
+
+	int	numCommands;
+
+	//Get the number of commands
+	icarus->BufferRead( &numCommands, sizeof( numCommands ) );
+
+	//Get all the commands
+	for ( i = 0; i < numCommands; i++ )
+	{
+		block = new CBlock;
+		LoadCommand( block, icarus );
+
+		//Save the block
+		//STL_INSERT( m_commands, block );
+		PushCommand( block, PUSH_BACK );
+	}
+
+	return true;
+}
\ No newline at end of file
diff --git a/code/icarus/Sequencer.cpp b/code/icarus/Sequencer.cpp
new file mode 100644
index 0000000..51dcafb
--- /dev/null
+++ b/code/icarus/Sequencer.cpp
@@ -0,0 +1,2614 @@
+// Script Command Sequencer
+//
+//	-- jweier
+
+// this include must remain at the top of every Icarus CPP file
+#include "stdafx.h"
+#include "IcarusImplementation.h"
+
+#include "BlockStream.h"
+#include "Sequence.h"
+#include "TaskManager.h"
+#include "Sequencer.h"
+
+#define S_FAILED(a) (a!=SEQ_OK)
+
+#define STL_ITERATE( a, b )		for ( a = b.begin(); a != b.end(); a++ )
+#define STL_INSERT( a, b )		a.insert( a.end(), b );
+
+
+// Save/Load restructuring.
+// Date: 10/29/02
+// By: Aurelio Reis
+// Purpose: In an effort to reduce file size and overhead, it was decided that
+// using a chunks for EVERYTHING is vastly inefficient and wasteful. Thus, the saving
+// is now primary focused on saving large chunks with *expected* data read from there.
+
+
+// Sequencer 
+
+CSequencer::CSequencer( void )
+{
+	static int uniqueID = 1;
+	m_id = uniqueID++;
+
+	m_numCommands	= 0;
+
+	m_curStream		= NULL;
+	m_curSequence	= NULL;
+
+	m_elseValid = 0;
+	m_elseOwner = NULL;
+
+	m_curGroup = NULL;
+}
+
+CSequencer::~CSequencer( void )
+{
+}
+
+/*
+========================
+Create
+
+Static creation function
+========================
+*/
+
+CSequencer *CSequencer::Create ( void )
+{
+	CSequencer *sequencer = new CSequencer;
+
+	return sequencer;
+}
+
+/*
+========================
+Init
+
+Initializes the sequencer
+========================
+*/
+int CSequencer::Init( int ownerID, CTaskManager *taskManager )
+{
+	m_ownerID		= ownerID;
+	m_taskManager	= taskManager;
+
+	return SEQ_OK;
+}
+
+/*
+========================
+Free
+
+Releases all resources and re-inits the sequencer
+========================
+*/
+void CSequencer::Free( CIcarus* icarus )
+{
+	//Flush the sequences
+/*	sequenceID_m::iterator iterSeq = NULL;
+	for ( iterSeq = m_sequenceMap.begin(); iterSeq != m_sequenceMap.end(); iterSeq++ )
+	{
+		icarus->DeleteSequence( (*iterSeq).second );
+	}
+	m_sequenceMap.clear();*/
+
+	// OLD STUFF!
+	sequence_l::iterator	sli;
+	for ( sli = m_sequences.begin(); sli != m_sequences.end(); sli++ )
+	{
+		icarus->DeleteSequence( (*sli) );
+	}
+	m_sequences.clear();
+
+	m_taskSequences.clear();
+
+	//Clean up any other info
+	m_numCommands = 0;
+	m_curSequence = NULL;
+
+	bstream_t *streamToDel;
+	while(!m_streamsCreated.empty())
+	{
+		streamToDel = m_streamsCreated.back();
+		DeleteStream(streamToDel);
+	}
+
+	delete this;
+}
+
+/*
+-------------------------
+Flush
+-------------------------
+*/
+
+int CSequencer::Flush( CSequence *owner, CIcarus* icarus )
+{
+	if ( owner == NULL )
+		return SEQ_FAILED;
+	
+	Recall(icarus);
+
+
+	//Flush the sequences
+/*	sequenceID_m::iterator iterSeq = NULL;
+	for ( iterSeq = m_sequenceMap.begin(); iterSeq != m_sequenceMap.end(); )
+	{
+		if ( ( (*iterSeq).second == owner ) || ( owner->HasChild( (*iterSeq).second ) ) || ( (*iterSeq).second->HasFlag( CSequence::SQ_PENDING ) ) || ( (*iterSeq).second->HasFlag( CSequence::SQ_TASK ) ) )
+		{
+			iterSeq++;
+			continue;
+		}
+
+		//Delete it, and remove all references
+		RemoveSequence( (*iterSeq).second, icarus );
+		icarus->DeleteSequence( (*iterSeq).second );
+
+		//Remove it from the map
+		//Delete from the sequence list and move on
+		iterSeq = m_sequenceMap.erase( iterSeq );
+	}*/
+
+
+	// OLD STUFF!
+	//Flush the sequences
+	sequence_l::iterator sli;
+	for ( sli = m_sequences.begin(); sli != m_sequences.end(); )
+	{
+		if ( ( (*sli) == owner ) || ( owner->HasChild( (*sli) ) ) || ( (*sli)->HasFlag( CSequence::SQ_PENDING ) ) || ( (*sli)->HasFlag( CSequence::SQ_TASK ) ) )
+		{
+			sli++;
+			continue;
+		}
+
+		//Remove it from the map
+		//m_sequenceMap.erase( (*sli)->GetID() );
+		
+		//Delete it, and remove all references
+		RemoveSequence( (*sli), icarus );
+		icarus->DeleteSequence( (*sli) );
+		
+		//Delete from the sequence list and move on
+		sli = m_sequences.erase( sli );
+	}
+
+	//Make sure this owner knows it's now the root sequence
+	owner->SetParent( NULL );
+	owner->SetReturn( NULL );
+
+	return SEQ_OK;
+}
+
+/*
+========================
+AddStream
+
+Creates a stream for parsing
+========================
+*/
+
+bstream_t *CSequencer::AddStream( void )
+{
+	bstream_t	*stream;
+
+	stream = new bstream_t;				//deleted in Route()
+	stream->stream = new CBlockStream;	//deleted in Route()
+	stream->last = m_curStream;
+
+	m_streamsCreated.push_back(stream);
+
+	return stream;
+}
+
+/*
+========================
+DeleteStream
+
+Deletes parsing stream
+========================
+*/
+void CSequencer::DeleteStream( bstream_t *bstream )
+{
+	vector<bstream_t*>::iterator finder = find(m_streamsCreated.begin(), m_streamsCreated.end(), bstream);
+	if(finder != m_streamsCreated.end())
+	{
+		m_streamsCreated.erase(finder);
+	}
+
+	bstream->stream->Free();
+	
+	delete bstream->stream;
+	delete bstream;
+
+	bstream = NULL;
+}
+
+/*
+-------------------------
+AddTaskSequence
+-------------------------
+*/
+
+void CSequencer::AddTaskSequence( CSequence *sequence, CTaskGroup *group )
+{
+	m_taskSequences[ group ] = sequence;
+}
+
+/*
+-------------------------
+GetTaskSequence
+-------------------------
+*/
+
+CSequence *CSequencer::GetTaskSequence( CTaskGroup *group )
+{
+	taskSequence_m::iterator	tsi;
+
+	tsi = m_taskSequences.find( group );
+
+	if ( tsi == m_taskSequences.end() )
+		return NULL;
+
+	return (*tsi).second;
+}
+
+/*
+========================
+AddSequence
+
+Creates and adds a sequence to the sequencer
+========================
+*/
+
+CSequence *CSequencer::AddSequence( CIcarus* icarus )
+{
+	CSequence	*sequence = (CSequence*)icarus->GetSequence();
+
+	assert( sequence );
+	if ( sequence == NULL )
+		return NULL;
+
+	//The rest is handled internally to the class
+	//m_sequenceMap[ sequence->GetID() ] = sequence;
+
+	// OLD STUFF!
+	//Add it to the list
+	m_sequences.insert( m_sequences.end(), sequence );
+
+	//FIXME: Temp fix
+	sequence->SetFlag( CSequence::SQ_PENDING );
+
+	return sequence;
+}
+
+CSequence *CSequencer::AddSequence( CSequence *parent, CSequence *returnSeq, int flags, CIcarus* icarus )
+{
+	CSequence	*sequence = (CSequence*)icarus->GetSequence();
+
+	assert( sequence );
+	if ( sequence == NULL )
+		return NULL;
+
+	//The rest is handled internally to the class
+//	m_sequenceMap[ sequence->GetID() ] = sequence;
+
+	// OLD STUFF!
+	//Add it to the list
+	m_sequences.insert( m_sequences.end(), sequence );
+
+	sequence->SetFlags( flags );
+	sequence->SetParent( parent );
+	sequence->SetReturn( returnSeq );
+	
+	return sequence;
+}
+
+/*
+========================
+GetSequence
+
+Retrieves a sequence by its ID
+========================
+*/
+
+CSequence *CSequencer::GetSequence( int id )
+{
+/*	sequenceID_m::iterator mi;
+	
+	mi = m_sequenceMap.find( id );
+
+	if ( mi == m_sequenceMap.end() )
+		return NULL;
+	
+	return (*mi).second;*/
+	
+	sequence_l::iterator iterSeq;
+	STL_ITERATE( iterSeq, m_sequences )
+	{
+		if ( (*iterSeq)->GetID() == id )
+			return (*iterSeq);
+	}
+
+	return NULL;
+}
+
+/*
+-------------------------
+Interrupt
+-------------------------
+*/
+
+void CSequencer::Interrupt( void )
+{
+	CBlock	*command = m_taskManager->GetCurrentTask();
+
+	if ( command == NULL )
+		return;
+
+	//Save it
+	PushCommand( command, CSequence::PUSH_BACK );
+}
+
+/*
+========================
+Run
+
+Runs a script
+========================
+*/
+int CSequencer::Run( char *buffer, long size, CIcarus* icarus )
+{
+	bstream_t		*blockStream;
+
+	IGameInterface* game = icarus->GetGame();
+	
+	Recall(icarus);
+
+	//Create a new stream
+	blockStream = AddStream();
+	
+	//Open the stream as an IBI stream
+	if (!blockStream->stream->Open( buffer, size ))
+	{
+		game->DebugPrint(IGameInterface::WL_ERROR, "invalid stream" );
+		return SEQ_FAILED;
+	}
+
+	CSequence *sequence = AddSequence( NULL, m_curSequence, CSequence::SQ_COMMON, icarus );
+
+	// Interpret the command blocks and route them properly 
+	if ( S_FAILED( Route( sequence, blockStream, icarus )) )
+	{
+		//Error code is set inside of Route()
+		return SEQ_FAILED;
+	}
+
+	return SEQ_OK;
+}
+
+/*
+========================
+ParseRun
+
+Parses a user triggered run command
+========================
+*/
+
+int CSequencer::ParseRun( CBlock *block , CIcarus* icarus)
+{
+	IGameInterface* game = icarus->GetGame();
+	CSequence	*new_sequence;
+	bstream_t	*new_stream;
+	char		*buffer;
+	char		newname[ CIcarus::MAX_STRING_SIZE ];
+	int			buffer_size;
+
+	//Get the name and format it
+	StripExtension( (char*) block->GetMemberData( 0 ), (char *) newname );
+
+	//Get the file from the game engine
+  	buffer_size = game->LoadFile( newname, (void **) &buffer );
+
+	if ( buffer_size <= 0 )
+	{
+		game->DebugPrint(IGameInterface::WL_ERROR, "'%s' : could not open file\n", (char*) block->GetMemberData( 0 ));
+		block->Free(icarus);
+		delete block;
+		block = NULL;
+		return SEQ_FAILED;
+	}
+
+	//Create a new stream for this file
+	new_stream = AddStream();
+
+	//Begin streaming the file
+	if (!new_stream->stream->Open( buffer, buffer_size ))
+	{
+		game->DebugPrint(IGameInterface::WL_ERROR, "invalid stream" );
+		block->Free(icarus);
+		delete block;
+		block = NULL;
+		return SEQ_FAILED;
+	}
+
+	//Create a new sequence
+	new_sequence = AddSequence( m_curSequence, m_curSequence, ( CSequence::SQ_RUN | CSequence::SQ_PENDING ), icarus );
+
+	m_curSequence->AddChild( new_sequence );
+
+	// Interpret the command blocks and route them properly 
+	if ( S_FAILED( Route( new_sequence, new_stream, icarus )) )
+	{
+		//Error code is set inside of Route()
+		block->Free(icarus);
+		delete block;
+		block = NULL;
+		return SEQ_FAILED;
+	}
+
+	m_curSequence = m_curSequence->GetReturn();
+
+	assert( m_curSequence );
+
+	block->Write( CIcarus::TK_FLOAT, (float) new_sequence->GetID() , icarus);
+	PushCommand( block, CSequence::PUSH_FRONT );
+
+	return SEQ_OK;
+}
+
+/*
+========================
+ParseIf
+
+Parses an if statement
+========================
+*/
+
+int CSequencer::ParseIf( CBlock *block, bstream_t *bstream , CIcarus* icarus)
+{
+	IGameInterface* game = icarus->GetGame();
+	CSequence	*sequence;
+		
+	//Create the container sequence
+	sequence = AddSequence( m_curSequence, m_curSequence, CSequence::SQ_CONDITIONAL, icarus);
+	
+	assert( sequence );
+	if ( sequence == NULL )
+	{
+		game->DebugPrint(IGameInterface::WL_ERROR, "ParseIf: failed to allocate container sequence" );
+		block->Free(icarus);
+		delete block;
+		block = NULL;
+		return SEQ_FAILED;
+	}
+
+	m_curSequence->AddChild( sequence );
+
+	//Add a unique conditional identifier to the block for reference later
+	block->Write( CIcarus::TK_FLOAT, (float) sequence->GetID(), icarus );
+
+	//Push this onto the stack to mark the conditional entrance
+	PushCommand( block, CSequence::PUSH_FRONT );
+	
+	//Recursively obtain the conditional body
+	Route( sequence, bstream, icarus );
+
+	m_elseValid = 2;
+	m_elseOwner = block;
+
+	return SEQ_OK;
+}
+
+/*
+========================
+ParseElse
+
+Parses an else statement
+========================
+*/
+
+int CSequencer::ParseElse( CBlock *block, bstream_t *bstream , CIcarus* icarus)
+{
+	IGameInterface* game = icarus->GetGame();
+	//The else is not retained
+	block->Free(icarus);
+	delete block;
+	block = NULL;
+	
+	CSequence	*sequence;
+		
+	//Create the container sequence
+	sequence = AddSequence( m_curSequence, m_curSequence, CSequence::SQ_CONDITIONAL, icarus );
+	
+	assert( sequence );
+	if ( sequence == NULL )
+	{
+		game->DebugPrint(IGameInterface::WL_ERROR, "ParseIf: failed to allocate container sequence" );
+		return SEQ_FAILED;
+	}
+
+	m_curSequence->AddChild( sequence );
+
+	//Add a unique conditional identifier to the block for reference later
+	//TODO: Emit warning
+	if ( m_elseOwner == NULL )
+	{
+		game->DebugPrint(IGameInterface::WL_ERROR, "Invalid 'else' found!\n" );
+		return SEQ_FAILED;
+	}
+
+	m_elseOwner->Write( CIcarus::TK_FLOAT, (float) sequence->GetID(), icarus );
+	
+	m_elseOwner->SetFlag( BF_ELSE );
+
+	//Recursively obtain the conditional body
+	Route( sequence, bstream, icarus );
+
+	m_elseValid = 0;
+	m_elseOwner = NULL;
+
+	return SEQ_OK;
+}
+
+/*
+========================
+ParseLoop
+
+Parses a loop command
+========================
+*/
+
+int CSequencer::ParseLoop( CBlock *block, bstream_t *bstream , CIcarus* icarus)
+{
+	IGameInterface* game = icarus->GetGame();
+	CSequence		*sequence;
+	CBlockMember	*bm;
+	float			min, max;
+	int				rIter;
+	int				memberNum = 0;
+		
+	//Set the parent
+	sequence = AddSequence( m_curSequence, m_curSequence, ( CSequence::SQ_LOOP | CSequence::SQ_RETAIN ), icarus );
+	
+	assert( sequence );
+	if ( sequence == NULL )
+	{
+		game->DebugPrint(IGameInterface::WL_ERROR, "ParseLoop : failed to allocate container sequence" );
+		block->Free(icarus);
+		delete block;
+		block = NULL;	
+		return SEQ_FAILED;
+	}
+
+	m_curSequence->AddChild( sequence );
+
+	//Set the number of iterations of this sequence
+	
+	bm = block->GetMember( memberNum++ );
+
+	if ( bm->GetID() == CIcarus::ID_RANDOM )
+	{
+		//Parse out the random number
+		min = *(float *) block->GetMemberData( memberNum++ );
+		max = *(float *) block->GetMemberData( memberNum++ );
+		
+		rIter = (int) game->Random( min, max );
+		sequence->SetIterations( rIter );
+	}
+	else
+	{
+		sequence->SetIterations ( (int) (*(float *) bm->GetData()) );
+	}
+	
+	//Add a unique loop identifier to the block for reference later
+	block->Write( CIcarus::TK_FLOAT, (float) sequence->GetID(), icarus );
+
+	//Push this onto the stack to mark the loop entrance
+	PushCommand( block, CSequence::PUSH_FRONT );
+	
+	//Recursively obtain the loop
+	Route( sequence, bstream , icarus);
+
+	return SEQ_OK;
+}
+
+/*
+========================
+AddAffect
+
+Adds a sequence that is saved until the affect is called by the parent
+========================
+*/
+
+int CSequencer::AddAffect( bstream_t *bstream, int retain, int *id, CIcarus* icarus )
+{
+	CSequence	*sequence = AddSequence(icarus);
+	bstream_t	new_stream;
+
+	sequence->SetFlag( CSequence::SQ_AFFECT | CSequence::SQ_PENDING );
+
+	if ( retain )
+		sequence->SetFlag( CSequence::SQ_RETAIN );
+
+	//This will be replaced once it's actually used, but this will restore the route state properly
+	sequence->SetReturn( m_curSequence );
+	
+	//We need this as a temp holder
+	new_stream.last = m_curStream;
+	new_stream.stream = bstream->stream;
+
+	if S_FAILED( Route( sequence, &new_stream , icarus) )
+	{
+		return SEQ_FAILED;
+	}
+
+	*id = sequence->GetID();
+
+	sequence->SetReturn( NULL );
+
+	return SEQ_OK;
+}
+
+/*
+========================
+ParseAffect
+
+Parses an affect command
+========================
+*/
+
+int CSequencer::ParseAffect( CBlock *block, bstream_t *bstream, CIcarus* icarus )
+{
+	IGameInterface* game = icarus->GetGame();
+	CSequencer	*stream_sequencer = NULL;
+	char		*entname = NULL;
+	int			ret;
+	int			ent = -1;
+
+	entname	= (char*) block->GetMemberData( 0 );
+	ent		= game->GetByName( entname );
+
+	if( ent < 0 ) // if there wasn't a valid entname in the affect, we need to check if it's a get command
+	{
+		//try to parse a 'get' command that is embeded in this 'affect'
+	
+		int				id;
+		char			*p1 = NULL;
+		char			*name = 0;
+		CBlockMember	*bm = NULL;
+		//
+		//	Get the first parameter (this should be the get)
+		//
+		bm = block->GetMember( 0 );
+		id = bm->GetID();
+	
+		switch ( id )
+		{
+			// these 3 cases probably aren't necessary
+		case CIcarus::TK_STRING:
+		case CIcarus::TK_IDENTIFIER:
+		case CIcarus::TK_CHAR:
+				p1 = (char *) bm->GetData();
+			break;
+
+		case CIcarus::ID_GET:		
+			{
+				int		type;				
+
+				//get( TYPE, NAME )
+				type = (int) (*(float *) block->GetMemberData( 1 ));
+				name = (char *) block->GetMemberData( 2 );
+
+				switch ( type ) // what type are they attempting to get
+				{
+			
+				case CIcarus::TK_STRING:
+						//only string is acceptable for affect, store result in p1
+						if ( game->GetString( m_ownerID, name, &p1 ) == false)
+						{
+							block->Free(icarus);
+							delete block;
+							block = NULL;
+							return false;
+						}
+						break;
+					default:
+						//FIXME: Make an enum id for the error...
+						game->DebugPrint(IGameInterface::WL_ERROR, "Invalid parameter type on affect _1" );
+						block->Free(icarus);
+						delete block;
+						block = NULL;
+						return false;
+						break;
+				}
+
+				break;
+			}
+
+			default:
+			//FIXME: Make an enum id for the error...
+				game->DebugPrint(IGameInterface::WL_ERROR, "Invalid parameter type on affect _2" );
+				block->Free(icarus);
+				delete block;
+				block = NULL;
+				return false;
+				break;
+		}//end id switch
+
+		if(p1)
+		{
+			ent = game->GetByName( p1 );
+		}
+		if(ent < 0)
+		{	// a valid entity name was not returned from the get command
+			game->DebugPrint(IGameInterface::WL_WARNING, "'%s' : invalid affect() target\n");
+		}
+	
+	} // end if(!ent)
+
+	if( ent >= 0 )
+	{
+		int sequencerID = game->CreateIcarus(ent);
+		stream_sequencer = icarus->FindSequencer(sequencerID);
+	}
+
+	if (stream_sequencer == NULL)
+	{
+		game->DebugPrint(IGameInterface::WL_WARNING, "'%s' : invalid affect() target\n", entname );
+		
+		//Fast-forward out of this affect block onto the next valid code
+		CSequence *backSeq = m_curSequence;
+
+		CSequence *trashSeq = (CSequence*)icarus->GetSequence();
+		Route( trashSeq, bstream , icarus);
+		Recall(icarus);
+		DestroySequence( trashSeq, icarus );
+		m_curSequence = backSeq;
+		block->Free(icarus);
+		delete block;
+		block = NULL;
+		return SEQ_OK;
+	}
+
+	if S_FAILED ( stream_sequencer->AddAffect( bstream, (int) m_curSequence->HasFlag( CSequence::SQ_RETAIN ), &ret, icarus) )
+	{
+		block->Free(icarus);
+		delete block;
+		block = NULL;
+		return SEQ_FAILED;
+	}
+
+	//Hold onto the id for later use
+	//FIXME: If the target sequence is freed, what then?		(!suspect!)
+
+	block->Write( CIcarus::TK_FLOAT, (float) ret, icarus );
+	
+	PushCommand( block, CSequence::PUSH_FRONT );
+	/*
+	//Don't actually do these right now, we're just pre-processing (parsing) the affect
+	if( ent )
+	{	// ents need to update upon being affected 
+		ent->taskManager->Update();
+	}
+	*/
+
+	return SEQ_OK;
+}
+
+/*
+-------------------------
+ParseTask
+-------------------------
+*/
+
+int CSequencer::ParseTask( CBlock *block, bstream_t *bstream , CIcarus* icarus)
+{
+	IGameInterface* game = icarus->GetGame();
+	CSequence	*sequence;
+	CTaskGroup	*group;
+	const char	*taskName;
+
+	//Setup the container sequence
+	sequence = AddSequence( m_curSequence, m_curSequence, CSequence::SQ_TASK | CSequence::SQ_RETAIN, icarus);
+	m_curSequence->AddChild( sequence );
+
+	//Get the name of this task for reference later
+	taskName = (const char *) block->GetMemberData( 0 );
+
+	//Get a new task group from the task manager
+	group = m_taskManager->AddTaskGroup( taskName, icarus );
+
+	if ( group == NULL )
+	{
+		game->DebugPrint(IGameInterface::WL_ERROR, "error : unable to allocate a new task group" );
+		block->Free(icarus);
+		delete block;
+		block = NULL;
+		return SEQ_FAILED;
+	}
+
+	//The current group is set to this group, all subsequent commands (until a block end) will fall into this task group
+	group->SetParent( m_curGroup );
+	m_curGroup = group;
+	
+	//Keep an association between this task and the container sequence
+	AddTaskSequence( sequence, group );
+
+	//PushCommand( block, PUSH_FRONT );
+	block->Free(icarus);
+	delete block;
+	block = NULL;
+
+	//Recursively obtain the loop
+	Route( sequence, bstream, icarus );
+
+	return SEQ_OK;
+}
+
+/*
+========================
+Route
+
+Properly handles and routes commands to the sequencer
+========================
+*/
+
+//FIXME: Re-entering this code will produce unpredictable results if a script has already been routed and is running currently
+
+//FIXME: A sequencer cannot properly affect itself
+
+int CSequencer::Route( CSequence *sequence, bstream_t *bstream , CIcarus* icarus)
+{
+	IGameInterface* game = icarus->GetGame();
+	CBlockStream	*stream;
+	CBlock			*block;
+
+	//Take the stream as the current stream
+	m_curStream = bstream;
+	stream = bstream->stream;
+
+	m_curSequence = sequence;
+
+	//Obtain all blocks
+	while ( stream->BlockAvailable() )
+	{
+		block = new CBlock;		//deleted in Free()
+		stream->ReadBlock( block , icarus);
+
+		//TEMP: HACK!
+		if ( m_elseValid )
+			m_elseValid--;
+
+		switch( block->GetBlockID() )
+		{
+		//Marks the end of a blocked section
+		case CIcarus::ID_BLOCK_END:
+			
+			//Save this as a pre-process marker
+			PushCommand( block, CSequence::PUSH_FRONT );
+	
+			if ( m_curSequence->HasFlag( CSequence::SQ_RUN ) || m_curSequence->HasFlag( CSequence::SQ_AFFECT ) )
+			{
+				//Go back to the last stream
+				m_curStream = bstream->last;
+			}
+
+			if ( m_curSequence->HasFlag( CSequence::SQ_TASK ) )
+			{
+				//Go back to the last stream
+				m_curStream = bstream->last;
+				m_curGroup = m_curGroup->GetParent();
+			}
+	
+			m_curSequence = m_curSequence->GetReturn();
+
+			return SEQ_OK;
+			break;
+
+		//Affect pre-processor
+		case CIcarus::ID_AFFECT:
+
+			if S_FAILED( ParseAffect( block, bstream, icarus ) )
+				return SEQ_FAILED;
+
+			break;
+
+		//Run pre-processor
+		case CIcarus::ID_RUN:
+
+			if S_FAILED( ParseRun( block, icarus ) )
+				return SEQ_FAILED;
+
+			break;
+
+		//Loop pre-processor
+		case CIcarus::ID_LOOP:
+			
+			if S_FAILED( ParseLoop( block, bstream, icarus ) )
+				return SEQ_FAILED;
+
+			break;
+
+		//Conditional pre-processor
+		case CIcarus::ID_IF:
+
+			if S_FAILED( ParseIf( block, bstream, icarus ) )
+				return SEQ_FAILED;
+
+			break;
+
+		case CIcarus::ID_ELSE:
+
+			//TODO: Emit warning
+			if ( m_elseValid == 0 )
+			{
+				game->DebugPrint(IGameInterface::WL_ERROR, "Invalid 'else' found!\n" );
+				return SEQ_FAILED;
+			}
+
+			if S_FAILED( ParseElse( block, bstream, icarus ) )
+				return SEQ_FAILED;
+
+			break;
+
+		case CIcarus::ID_TASK:
+			
+			if S_FAILED( ParseTask( block, bstream, icarus ) )
+				return SEQ_FAILED;
+
+			break;
+
+		//FIXME: For now this is to catch problems, but can ultimately be removed
+		case CIcarus::ID_WAIT:
+		case CIcarus::ID_PRINT:
+		case CIcarus::ID_SOUND:
+		case CIcarus::ID_MOVE:
+		case CIcarus::ID_ROTATE:
+		case CIcarus::ID_SET:
+		case CIcarus::ID_USE:
+		case CIcarus::ID_REMOVE:
+		case CIcarus::ID_KILL:
+		case CIcarus::ID_FLUSH:
+		case CIcarus::ID_CAMERA:
+		case CIcarus::ID_DO:
+		case CIcarus::ID_DECLARE:
+		case CIcarus::ID_FREE:
+		case CIcarus::ID_SIGNAL:
+		case CIcarus::ID_WAITSIGNAL:
+		case CIcarus::ID_PLAY:
+
+			//Commands go directly into the sequence without pre-process
+			PushCommand( block, CSequence::PUSH_FRONT );
+			break;
+
+		//Error
+		default:
+			
+			game->DebugPrint(IGameInterface::WL_ERROR, "'%d' : invalid block ID", block->GetBlockID() );
+			
+			return SEQ_FAILED;
+			break;
+		}
+	}
+
+	//Check for a run sequence, it must be marked
+	if ( m_curSequence->HasFlag( CSequence::SQ_RUN ) )
+	{
+		block = new CBlock;
+		block->Create( CIcarus::ID_BLOCK_END );
+		PushCommand( block, CSequence::PUSH_FRONT );	//mark the end of the run
+
+		/*
+		//Free the stream
+		m_curStream = bstream->last;
+		DeleteStream( bstream );
+		*/
+
+		return SEQ_OK;
+	}
+
+	//Check to start the communication
+	if ( ( bstream->last == NULL ) && ( m_numCommands > 0 ) )
+	{	
+		//Everything is routed, so get it all rolling
+		Prime( m_taskManager, PopCommand( CSequence::POP_BACK ), icarus );
+	}
+
+	m_curStream = bstream->last;
+
+	//Free the stream
+	DeleteStream( bstream );
+		
+	return SEQ_OK;
+}
+
+/*
+========================
+CheckRun
+
+Checks for run command pre-processing
+========================
+*/
+
+//Directly changes the parameter to avoid excess push/pop
+
+void CSequencer::CheckRun( CBlock **command , CIcarus* icarus)
+{
+	IGameInterface* game = icarus->GetGame();
+	CBlock	*block = *command;
+
+	if ( block == NULL )
+		return;
+
+	//Check for a run command
+	if ( block->GetBlockID() == CIcarus::ID_RUN )
+	{
+		int id = (int) (*(float *) block->GetMemberData( 1 ));
+
+		game->DebugPrint(IGameInterface::WL_DEBUG, "%4d run( \"%s\" ); [%d]", m_ownerID, (char *) block->GetMemberData(0), game->GetTime() );
+
+		if ( m_curSequence->HasFlag( CSequence::SQ_RETAIN ) )
+		{
+			PushCommand( block, CSequence::PUSH_FRONT );
+		}
+		else
+		{
+			block->Free(icarus);
+			delete block;
+			block = NULL;
+
+			*command = NULL;
+		}
+
+		m_curSequence = GetSequence( id );
+		
+		//TODO: Emit warning
+		assert( m_curSequence );
+		if ( m_curSequence == NULL )
+		{
+			game->DebugPrint(IGameInterface::WL_ERROR, "Unable to find 'run' sequence!\n" );
+			*command = NULL;
+			return;
+		}
+
+		if ( m_curSequence->GetNumCommands() > 0 )
+		{
+			*command = PopCommand( CSequence::POP_BACK );
+			
+			Prep( command , icarus);	//Account for any other pre-processes
+			return;
+		}
+
+		return;
+	}
+	
+	//Check for the end of a run
+	if ( ( block->GetBlockID() == CIcarus::ID_BLOCK_END ) && ( m_curSequence->HasFlag( CSequence::SQ_RUN ) ) )
+	{
+		if ( m_curSequence->HasFlag( CSequence::SQ_RETAIN ) )
+		{
+			PushCommand( block, CSequence::PUSH_FRONT );
+		}
+		else
+		{
+			block->Free(icarus);
+			delete block;
+			block = NULL;
+			*command = NULL;
+		}
+
+		m_curSequence = ReturnSequence( m_curSequence );
+
+		if ( m_curSequence && m_curSequence->GetNumCommands() > 0 )
+		{
+			*command = PopCommand( CSequence::POP_BACK );
+			
+			Prep( command, icarus );	//Account for any other pre-processes
+			return;
+		}	
+
+		//FIXME: Check this...
+	}
+}
+
+/*
+-------------------------
+EvaluateConditional
+-------------------------
+*/
+
+//FIXME: This function will be written better later once the functionality of the ideas here are tested
+
+int CSequencer::EvaluateConditional( CBlock *block , CIcarus* icarus)
+{
+	IGameInterface* game = icarus->GetGame();
+	CBlockMember	*bm;
+	char			tempString1[128], tempString2[128];
+	vec3_t			vec;
+	int				id, i, oper, memberNum = 0;
+	char			*p1 = NULL, *p2 = NULL;
+	int				t1, t2;
+
+	//
+	//	Get the first parameter
+	//
+
+	bm = block->GetMember( memberNum++ );
+	id = bm->GetID();
+
+	t1 = id;
+
+	switch ( id )
+	{
+	case CIcarus::TK_FLOAT:
+		sprintf( (char *) tempString1, "%.3f", *(float *) bm->GetData() );
+		p1 = (char *) tempString1;
+		break;
+
+	case CIcarus::TK_VECTOR:
+
+		tempString1[0] = NULL;
+
+		for ( i = 0; i < 3; i++ )
+		{
+			bm = block->GetMember( memberNum++ );
+			vec[i] = *(float *) bm->GetData();
+		}
+
+		sprintf( (char *) tempString1, "%.3f %.3f %.3f", vec[0], vec[1], vec[2] );
+		p1 = (char *) tempString1;
+
+		break;
+
+	case CIcarus::TK_STRING:
+	case CIcarus::TK_IDENTIFIER:
+	case CIcarus::TK_CHAR:
+
+		p1 = (char *) bm->GetData();
+		break;
+
+	case CIcarus::ID_GET:		
+	{
+			int		type;
+			char	*name;
+
+			//get( TYPE, NAME )
+			type = (int) (*(float *) block->GetMemberData( memberNum++ ));
+			name = (char *) block->GetMemberData( memberNum++ );
+
+			//Get the type returned and hold onto it
+			t1 = type;
+
+			switch ( type )
+			{
+			case CIcarus::TK_FLOAT:
+				{
+					float	fVal;
+
+					if ( game->GetFloat( m_ownerID, name, &fVal ) == false)
+						return false;
+
+					sprintf( (char *) tempString1, "%.3f", fVal );
+					p1 = (char *) tempString1;
+				}
+				
+				break;
+
+			case CIcarus::TK_INT:
+				{
+					float	fVal;
+
+					if ( game->GetFloat( m_ownerID, name, &fVal ) == false)
+						return false;
+
+					sprintf( (char *) tempString1, "%d", (int) fVal );
+					p1 = (char *) tempString1;
+				}
+				break;
+
+			case CIcarus::TK_STRING:
+
+				if ( game->GetString( m_ownerID, name, &p1 ) == false)
+					return false;
+			
+				break;
+
+			case CIcarus::TK_VECTOR:
+				{
+					vec3_t	vVal;
+
+					if ( game->GetVector( m_ownerID, name, vVal ) == false)
+						return false;
+
+					sprintf( (char *) tempString1, "%.3f %.3f %.3f", vVal[0], vVal[1], vVal[2] );
+					p1 = (char *) tempString1;
+				}
+				
+				break;
+		}
+
+		break;
+	}
+
+	case CIcarus::ID_RANDOM:
+		{
+			float	min, max;
+			//FIXME: This will not account for nested random() statements
+
+			min	= *(float *) block->GetMemberData( memberNum++ );
+			max	= *(float *) block->GetMemberData( memberNum++ );
+
+			//A float value is returned from the function
+			t1 = CIcarus::TK_FLOAT;
+
+			sprintf( (char *) tempString1, "%.3f", game->Random( min, max ) );
+			p1 = (char *) tempString1;
+		}
+
+		break;
+
+	case CIcarus::ID_TAG:
+		{
+			char	*name;
+			float	type;
+
+			name = (char *) block->GetMemberData( memberNum++ );
+			type = *(float *) block->GetMemberData( memberNum++ );
+
+			t1 = CIcarus::TK_VECTOR;
+
+			//TODO: Emit warning
+			if ( game->GetTag( m_ownerID, name, (int) type, vec ) == false)
+			{
+				game->DebugPrint(IGameInterface::WL_ERROR, "Unable to find tag \"%s\"!\n", name );
+				return false;
+			}
+
+			sprintf( (char *) tempString1, "%.3f %.3f %.3f", vec[0], vec[1], vec[2] );
+			p1 = (char *) tempString1;
+
+			break;
+		}
+
+	default:
+		//FIXME: Make an enum id for the error...
+		game->DebugPrint(IGameInterface::WL_ERROR, "Invalid parameter type on conditional" );
+		return false;
+		break;
+	}
+
+	//
+	//	Get the comparison operator
+	//
+
+	bm = block->GetMember( memberNum++ );
+	id = bm->GetID();
+
+	switch ( id )
+	{
+	case CIcarus::TK_EQUALS:
+	case CIcarus::TK_GREATER_THAN:
+	case CIcarus::TK_LESS_THAN:
+	case CIcarus::TK_NOT:
+		oper = id;
+		break;
+
+	default:
+		game->DebugPrint(IGameInterface::WL_ERROR, "Invalid operator type found on conditional!\n" );
+		return false;	//FIXME: Emit warning
+		break;
+	}
+
+	//
+	//	Get the second parameter
+	//
+
+	bm = block->GetMember( memberNum++ );
+	id = bm->GetID();
+
+	t2 = id;
+
+	switch ( id )
+	{
+	case CIcarus::TK_FLOAT:
+		sprintf( (char *) tempString2, "%.3f", *(float *) bm->GetData() );
+		p2 = (char *) tempString2;
+		break;
+
+	case CIcarus::TK_VECTOR:
+
+		tempString2[0] = NULL;
+
+		for ( i = 0; i < 3; i++ )
+		{
+			bm = block->GetMember( memberNum++ );
+			vec[i] = *(float *) bm->GetData();
+		}
+
+		sprintf( (char *) tempString2, "%.3f %.3f %.3f", vec[0], vec[1], vec[2] );
+		p2 = (char *) tempString2;
+
+		break;
+
+	case CIcarus::TK_STRING:
+	case CIcarus::TK_IDENTIFIER:
+	case CIcarus::TK_CHAR:
+
+		p2 = (char *) bm->GetData();
+		break;
+
+	case CIcarus::ID_GET:		
+	{
+			int		type;
+			char	*name;
+
+			//get( TYPE, NAME )
+			type = (int) (*(float *) block->GetMemberData( memberNum++ ));
+			name = (char *) block->GetMemberData( memberNum++ );
+
+			//Get the type returned and hold onto it
+			t2 = type;
+
+			switch ( type )
+			{
+			case CIcarus::TK_FLOAT:
+				{
+					float	fVal;
+
+					if ( game->GetFloat( m_ownerID, name, &fVal ) == false)
+						return false;
+
+					sprintf( (char *) tempString2, "%.3f", fVal );
+					p2 = (char *) tempString2;
+				}
+				
+				break;
+
+			case CIcarus::TK_INT:
+				{
+					float	fVal;
+
+					if ( game->GetFloat( m_ownerID, name, &fVal ) == false)
+						return false;
+
+					sprintf( (char *) tempString2, "%d", (int) fVal );
+					p2 = (char *) tempString2;
+				}
+				break;
+
+			case CIcarus::TK_STRING:
+
+				if ( game->GetString( m_ownerID, name, &p2 ) == false)
+					return false;
+			
+				break;
+
+			case CIcarus::TK_VECTOR:
+				{
+					vec3_t	vVal;
+
+					if ( game->GetVector( m_ownerID, name, vVal ) == false)
+						return false;
+
+					sprintf( (char *) tempString2, "%.3f %.3f %.3f", vVal[0], vVal[1], vVal[2] );
+					p2 = (char *) tempString2;
+				}
+				
+				break;
+		}
+
+		break;
+	}
+
+	case CIcarus::ID_RANDOM:
+		
+		{
+			float	min, max;
+			//FIXME: This will not account for nested random() statements
+
+			min	= *(float *) block->GetMemberData( memberNum++ );
+			max	= *(float *) block->GetMemberData( memberNum++ );
+
+			//A float value is returned from the function
+			t2 = CIcarus::TK_FLOAT;
+
+			sprintf( (char *) tempString2, "%.3f", game->Random( min, max ) );
+			p2 = (char *) tempString2;
+		}
+
+		break;
+
+	case CIcarus::ID_TAG:
+
+		{
+			char	*name;
+			float	type;
+
+			name = (char *) block->GetMemberData( memberNum++ );
+			type = *(float *) block->GetMemberData( memberNum++ );
+
+			t2 = CIcarus::TK_VECTOR;
+
+			//TODO: Emit warning
+			if ( game->GetTag( m_ownerID, name, (int) type, vec ) == false)
+			{
+				game->DebugPrint(IGameInterface::WL_ERROR, "Unable to find tag \"%s\"!\n", name );
+				return false;
+			}
+
+			sprintf( (char *) tempString2, "%.3f %.3f %.3f", vec[0], vec[1], vec[2] );
+			p2 = (char *) tempString2;
+
+			break;
+		}
+
+	default:
+		//FIXME: Make an enum id for the error...
+		game->DebugPrint(IGameInterface::WL_ERROR, "Invalid parameter type on conditional" );
+		return false;
+		break;
+	}
+
+	return game->Evaluate( t1, p1, t2, p2, oper );
+}
+
+/*
+========================
+CheckIf
+
+Checks for if statement pre-processing
+========================
+*/
+
+void CSequencer::CheckIf( CBlock **command , CIcarus* icarus)
+{
+	IGameInterface* game = icarus->GetGame();
+	CBlock		*block = *command;
+	int			successID, failureID;
+	CSequence	*successSeq, *failureSeq;
+
+	if ( block == NULL )
+		return;
+
+	if ( block->GetBlockID() == CIcarus::ID_IF )
+	{
+		int ret = EvaluateConditional( block, icarus );
+
+		if ( ret /*TRUE*/ )
+		{
+			if ( block->HasFlag( BF_ELSE ) )
+			{
+				successID = (int) (*(float *) block->GetMemberData( block->GetNumMembers() - 2 ));
+			}
+			else
+			{
+				successID = (int) (*(float *) block->GetMemberData( block->GetNumMembers() - 1 ));
+			}
+
+			successSeq = GetSequence( successID );
+
+			//TODO: Emit warning
+			assert( successSeq );
+			if ( successSeq == NULL )
+			{
+				game->DebugPrint(IGameInterface::WL_ERROR, "Unable to find conditional success sequence!\n" );
+				*command = NULL;
+				return;
+			}
+
+			//Only save the conditional statement if the calling sequence is retained
+			if ( m_curSequence->HasFlag( CSequence::SQ_RETAIN ) )
+			{
+				PushCommand( block, CSequence::PUSH_FRONT );
+			}
+			else
+			{
+				block->Free(icarus);
+				delete block;
+				block = NULL;
+				*command = NULL;
+			}
+			
+			m_curSequence = successSeq;
+
+			//Recursively work out any other pre-processors
+			*command = PopCommand( CSequence::POP_BACK );
+			Prep( command , icarus);
+			
+			return;			
+		}
+
+		if ( ( ret == false ) && ( block->HasFlag( BF_ELSE ) ) )
+		{
+			failureID = (int) (*(float *) block->GetMemberData( block->GetNumMembers() - 1 ));
+			failureSeq = GetSequence( failureID );
+
+			//TODO: Emit warning
+			assert( failureSeq );
+			if ( failureSeq == NULL )
+			{
+				game->DebugPrint(IGameInterface::WL_ERROR, "Unable to find conditional failure sequence!\n" );
+				*command = NULL;
+				return;
+			}
+
+			//Only save the conditional statement if the calling sequence is retained
+			if ( m_curSequence->HasFlag( CSequence::SQ_RETAIN ) )
+			{
+				PushCommand( block, CSequence::PUSH_FRONT );
+			}
+			else
+			{
+				block->Free(icarus);
+				delete block;
+				block = NULL;
+				*command = NULL;
+			}
+			
+			m_curSequence = failureSeq;
+
+			//Recursively work out any other pre-processors
+			*command = PopCommand( CSequence::POP_BACK );
+			Prep( command , icarus);
+			
+			return;			
+		}
+
+		//Only save the conditional statement if the calling sequence is retained
+		if ( m_curSequence->HasFlag( CSequence::SQ_RETAIN ) )
+		{
+			PushCommand( block, CSequence::PUSH_FRONT );
+		}
+		else
+		{
+			block->Free(icarus);
+			delete block;
+			block = NULL;
+			*command = NULL;
+		}
+
+		//Conditional failed, just move on to the next command
+		*command = PopCommand( CSequence::POP_BACK );
+		Prep( command , icarus);
+		
+		return;			
+	}
+
+	if ( ( block->GetBlockID() == CIcarus::ID_BLOCK_END ) && ( m_curSequence->HasFlag( CSequence::SQ_CONDITIONAL ) ) )
+	{
+		assert( m_curSequence->GetReturn() );
+		if ( m_curSequence->GetReturn() == NULL )
+		{
+			*command = NULL;
+			return;
+		}
+
+		//Check to retain it
+		if ( m_curSequence->GetParent()->HasFlag( CSequence::SQ_RETAIN ) )
+		{
+			PushCommand( block, CSequence::PUSH_FRONT );
+		}
+		else
+		{
+			block->Free(icarus);
+			delete block;
+			block = NULL;
+			*command = NULL;
+		}
+		
+		//Back out of the conditional and resume the previous sequence
+		m_curSequence = ReturnSequence( m_curSequence );
+		
+		//This can safely happen
+		if ( m_curSequence == NULL )
+		{
+			*command = NULL;
+			return;
+		}
+
+		*command = PopCommand( CSequence::POP_BACK );
+		Prep( command , icarus);
+	}
+}
+
+/*
+========================
+CheckLoop
+
+Checks for loop command pre-processing
+========================
+*/
+
+void CSequencer::CheckLoop( CBlock **command , CIcarus* icarus)
+{
+	IGameInterface* game = icarus->GetGame();
+	CBlockMember	*bm;
+	CBlock			*block = *command;
+	float			min, max;
+	int				iterations;
+	int				loopID;
+	int				memberNum = 0;
+			
+	if ( block == NULL )
+		return;
+
+	//Check for a loop
+	if ( block->GetBlockID() == CIcarus::ID_LOOP )
+	{
+		//Get the loop ID
+		bm = block->GetMember( memberNum++ );
+
+		if ( bm->GetID() == CIcarus::ID_RANDOM )
+		{
+			//Parse out the random number
+			min = *(float *) block->GetMemberData( memberNum++ );
+			max = *(float *) block->GetMemberData( memberNum++ );
+			
+			iterations = (int) game->Random( min, max );
+		}
+		else
+		{
+			iterations = (int) (*(float *) bm->GetData());
+		}
+		
+		loopID = (int) (*(float *) block->GetMemberData( memberNum++ ));
+
+		CSequence *loop = GetSequence( loopID );
+				
+		//TODO: Emit warning
+		assert( loop );
+		if ( loop == NULL )
+		{
+			game->DebugPrint(IGameInterface::WL_ERROR, "Unable to find 'loop' sequence!\n" );
+			*command = NULL;
+			return;
+		}
+
+		assert( loop->GetParent() );
+		if ( loop->GetParent() == NULL )
+		{
+			*command = NULL;
+			return;
+		}
+
+		//Restore the count if it has been lost
+		loop->SetIterations( iterations );
+
+		//Only save the loop command if the calling sequence is retained
+		if ( m_curSequence->HasFlag( CSequence::SQ_RETAIN ) )
+		{
+			PushCommand( block, CSequence::PUSH_FRONT );
+		}
+		else
+		{
+			block->Free(icarus);
+			delete block;
+			block = NULL;
+			*command = NULL;
+		}
+		
+		m_curSequence = loop;
+
+		//Recursively work out any other pre-processors
+		*command = PopCommand( CSequence::POP_BACK );
+		Prep( command , icarus);
+		
+		return;
+	}
+	
+	//Check for the end of the loop
+	if ( ( block->GetBlockID() == CIcarus::ID_BLOCK_END ) && ( m_curSequence->HasFlag( CSequence::SQ_LOOP ) ) )
+	{
+		//We don't want to decrement -1
+		if ( m_curSequence->GetIterations() > 0 )
+			m_curSequence->SetIterations( m_curSequence->GetIterations()-1 );	//Nice, eh?
+
+		//Either there's another iteration, or it's infinite
+		if ( m_curSequence->GetIterations() != 0 )
+		{
+			//Another iteration is going to happen, so this will need to be considered again
+			PushCommand( block, CSequence::PUSH_FRONT );
+			
+			*command = PopCommand( CSequence::POP_BACK );
+			Prep( command, icarus );
+			
+			return;
+		}
+		else
+		{
+			assert( m_curSequence->GetReturn() );
+			if ( m_curSequence->GetReturn() == NULL )
+			{
+				*command = NULL;
+				return;
+			}
+
+			//Check to retain it
+			if ( m_curSequence->GetParent()->HasFlag( CSequence::SQ_RETAIN ) )
+			{
+				PushCommand( block, CSequence::PUSH_FRONT );
+			}
+			else
+			{
+				block->Free(icarus);
+				delete block;
+				block = NULL;
+				*command = NULL;
+			}
+			
+			//Back out of the loop and resume the previous sequence
+			m_curSequence = ReturnSequence( m_curSequence );
+			
+			//This can safely happen
+			if ( m_curSequence == NULL )
+			{
+				*command = NULL;
+				return;
+			}
+
+			*command = PopCommand( CSequence::POP_BACK );
+			Prep( command, icarus);
+		}
+	}
+}
+
+/*
+========================
+CheckFlush
+
+Checks for flush command pre-processing
+========================
+*/
+
+void CSequencer::CheckFlush( CBlock **command, CIcarus* icarus)
+{
+	CBlock *block =			*command;
+
+	if ( block == NULL )
+		return;
+
+	if ( block->GetBlockID() == CIcarus::ID_FLUSH )
+	{
+		//Flush the sequence
+		Flush( m_curSequence, icarus );
+
+		//Check to retain it
+		if ( m_curSequence->HasFlag( CSequence::SQ_RETAIN ) )
+		{
+			PushCommand( block, CSequence::PUSH_FRONT );
+		}
+		else
+		{
+			block->Free(icarus);
+			delete block;
+			block = NULL;
+			*command = NULL;
+		}
+
+		*command = PopCommand( CSequence::POP_BACK );
+		Prep( command , icarus);
+
+		return;
+	}
+}
+
+/*
+========================
+CheckAffect
+
+Checks for affect command pre-processing
+========================
+*/
+
+void CSequencer::CheckAffect( CBlock **command , CIcarus* icarus)
+{
+	IGameInterface* game = icarus->GetGame();
+	CBlock *block = *command;
+	int			ent = -1;
+	char		*entname = NULL;
+	int			memberNum = 0;
+
+	if ( block == NULL )
+	{
+		return;
+	}
+
+	if ( block->GetBlockID() == CIcarus::ID_AFFECT )
+	{
+		CSequencer *sequencer	= NULL;
+		entname = (char*) block->GetMemberData( memberNum++ );
+		ent		= game->GetByName( entname );
+		
+		if( ent < 0 ) // if there wasn't a valid entname in the affect, we need to check if it's a get command
+		{
+			//try to parse a 'get' command that is embeded in this 'affect'
+		
+			int				id;
+			char			*p1 = NULL;
+			char			*name = 0;
+			CBlockMember	*bm = NULL;
+			//
+			//	Get the first parameter (this should be the get)
+			//
+			bm = block->GetMember( 0 );
+			id = bm->GetID();
+		
+			switch ( id )
+			{
+				// these 3 cases probably aren't necessary
+				case CIcarus::TK_STRING:
+				case CIcarus::TK_IDENTIFIER:
+				case CIcarus::TK_CHAR:
+					p1 = (char *) bm->GetData();
+				break;
+
+				case CIcarus::ID_GET:		
+				{
+					int		type;				
+
+					//get( TYPE, NAME )
+					type = (int) (*(float *) block->GetMemberData( memberNum++ ));
+					name = (char *) block->GetMemberData( memberNum++ );
+
+					switch ( type ) // what type are they attempting to get
+					{
+				
+						case CIcarus::TK_STRING:
+							//only string is acceptable for affect, store result in p1
+							if ( game->GetString( m_ownerID, name, &p1 ) == false)
+							{
+								return;
+							}
+							break;
+						default:
+							//FIXME: Make an enum id for the error...
+							game->DebugPrint(IGameInterface::WL_ERROR, "Invalid parameter type on affect _1" );
+							return;
+							break;
+					}
+
+					break;
+				}
+
+				default:
+				//FIXME: Make an enum id for the error...
+					game->DebugPrint(IGameInterface::WL_ERROR, "Invalid parameter type on affect _2" );
+					return;
+					break;
+			}//end id switch
+
+			if(p1)
+			{
+				ent = game->GetByName( p1 );
+			}
+			if(ent < 0)
+			{	// a valid entity name was not returned from the get command
+				game->DebugPrint(IGameInterface::WL_WARNING, "'%s' : invalid affect() target\n");
+			}
+		
+		} // end if(!ent)
+
+		if( ent >= 0)
+		{
+			int sequencerID = game->CreateIcarus(ent);
+			sequencer = icarus->FindSequencer(sequencerID);
+		}
+		if(memberNum == 0)
+		{	//there was no get, increment manually before next step
+			memberNum++;
+		}
+		int	type	= (int) (*(float *) block->GetMemberData( memberNum ));  
+		int	id		= (int) (*(float *) block->GetMemberData( memberNum+1 ));
+		
+		if ( m_curSequence->HasFlag( CSequence::SQ_RETAIN ) )
+		{
+			PushCommand( block, CSequence::PUSH_FRONT );
+		}
+		else
+		{
+			block->Free(icarus);
+			delete block;
+			block = NULL;
+			*command = NULL;
+		}
+		
+		//NOTENOTE: If this isn't found, continue on to the next command
+		if ( sequencer == NULL )
+		{
+			*command = PopCommand( CSequence::POP_BACK );
+			Prep( command , icarus);
+			return;
+		}
+
+		sequencer->Affect( id, type , icarus);
+
+		*command = PopCommand( CSequence::POP_BACK );
+		Prep( command, icarus );
+		if( ent >= 0 )
+		{	// ents need to update upon being affected 
+			int sequencerID = game->CreateIcarus(ent);
+			CSequencer* entsequencer = icarus->FindSequencer(sequencerID);
+			CTaskManager* taskmanager = entsequencer->GetTaskManager();
+			if(taskmanager)
+			{
+				taskmanager->Update(icarus);
+			}
+		}
+
+		return;
+	}
+
+	if ( ( block->GetBlockID() == CIcarus::ID_BLOCK_END ) && ( m_curSequence->HasFlag( CSequence::SQ_AFFECT ) ) )
+	{
+		if ( m_curSequence->HasFlag(CSequence::SQ_RETAIN ) )
+		{
+			PushCommand( block, CSequence::PUSH_FRONT );
+		}
+		else
+		{
+			block->Free(icarus);
+			delete block;
+			block = NULL;
+			*command = NULL;
+		}
+		
+		m_curSequence = ReturnSequence( m_curSequence );
+
+		if ( m_curSequence == NULL )
+		{
+			*command = NULL;
+			return;
+		}
+
+		*command = PopCommand( CSequence::POP_BACK );
+		Prep( command , icarus);
+		if( ent >= 0)
+		{	// ents need to update upon being affected 
+			int sequencerID = game->CreateIcarus(ent);
+			CSequencer* entsequencer = icarus->FindSequencer(sequencerID);
+			CTaskManager* taskmanager = entsequencer->GetTaskManager();
+			if(taskmanager)
+			{
+				taskmanager->Update(icarus);
+			}
+		}
+
+	}
+}
+
+/*
+-------------------------
+CheckDo
+-------------------------
+*/
+
+void CSequencer::CheckDo( CBlock **command , CIcarus* icarus)
+{
+	IGameInterface* game = icarus->GetGame();
+	CBlock *block = *command;
+
+	if ( block == NULL )
+		return;
+
+	if ( block->GetBlockID() == CIcarus::ID_DO )
+	{
+		//Get the sequence
+		const char	*groupName = (const char *) block->GetMemberData( 0 );
+		CTaskGroup	*group = m_taskManager->GetTaskGroup( groupName, icarus );
+		CSequence	*sequence = GetTaskSequence( group );
+
+		//TODO: Emit warning
+		assert( group );
+		if ( group == NULL )
+		{
+			//TODO: Give name/number of entity trying to execute, too
+			game->DebugPrint(IGameInterface::WL_ERROR, "ICARUS Unable to find task group \"%s\"!\n", groupName );
+			*command = NULL;
+			return;
+		}
+
+		//TODO: Emit warning
+		assert( sequence );
+		if ( sequence == NULL )
+		{
+			//TODO: Give name/number of entity trying to execute, too
+			game->DebugPrint(IGameInterface::WL_ERROR, "ICARUS Unable to find task 'group' sequence!\n", groupName );
+			*command = NULL;
+			return;
+		}
+
+		//Only save the loop command if the calling sequence is retained
+		if ( m_curSequence->HasFlag( CSequence::SQ_RETAIN ) )
+		{
+			PushCommand( block, CSequence::PUSH_FRONT );
+		}
+		else
+		{
+			block->Free(icarus);
+			delete block;
+			block = NULL;
+			*command = NULL;
+		}
+
+		//Set this to our current sequence
+		sequence->SetReturn( m_curSequence );
+		m_curSequence = sequence;
+
+		group->SetParent( m_curGroup );
+		m_curGroup = group;
+
+		//Mark all the following commands as being in the task
+		m_taskManager->MarkTask( group->GetGUID(), TASK_START, icarus );
+
+		//Recursively work out any other pre-processors
+		*command = PopCommand( CSequence::POP_BACK );
+		Prep( command , icarus);
+		
+		return;
+	}
+
+	if ( ( block->GetBlockID() == CIcarus::ID_BLOCK_END ) && ( m_curSequence->HasFlag( CSequence::SQ_TASK ) ) )
+	{
+		if ( m_curSequence->HasFlag( CSequence::SQ_RETAIN ) )
+		{
+			PushCommand( block, CSequence::PUSH_FRONT );
+		}
+		else
+		{
+			block->Free(icarus);
+			delete block;
+			block = NULL;
+			*command = NULL;
+		}
+		
+		m_taskManager->MarkTask( m_curGroup->GetGUID(), TASK_END, icarus );
+		m_curGroup = m_curGroup->GetParent();
+
+		CSequence *returnSeq = ReturnSequence( m_curSequence );
+		m_curSequence->SetReturn( NULL );
+		m_curSequence = returnSeq;
+
+		if ( m_curSequence == NULL )
+		{
+			*command = NULL;
+			return;
+		}
+
+		*command = PopCommand( CSequence::POP_BACK );
+		Prep( command , icarus);
+	}
+}
+
+/*
+========================
+Prep
+
+Handles internal sequencer maintenance
+========================
+*/
+
+void CSequencer::Prep( CBlock **command , CIcarus* icarus)
+{
+	//Check all pre-processes
+	CheckAffect( command , icarus);
+	CheckFlush( command , icarus);
+	CheckLoop( command , icarus);
+	CheckRun( command , icarus);
+	CheckIf( command , icarus);
+	CheckDo( command , icarus);
+}
+
+/*
+========================
+Prime
+
+Starts communication between the task manager and this sequencer
+========================
+*/
+
+int CSequencer::Prime( CTaskManager *taskManager, CBlock *command , CIcarus* icarus)
+{
+	Prep( &command , icarus);
+
+	if ( command )
+	{
+		taskManager->SetCommand( command, CSequence::PUSH_BACK, icarus );
+	}
+
+	return SEQ_OK;
+}
+
+/*
+========================
+Callback
+
+Handles a completed task and returns a new task to be completed
+========================
+*/
+
+int CSequencer::Callback( CTaskManager *taskManager, CBlock *block, int returnCode, CIcarus* icarus )
+{
+	IGameInterface* game = icarus->GetGame();
+	CBlock	*command;
+
+	if (returnCode == TASK_RETURN_COMPLETE)
+	{
+		//There are no more pending commands
+		if ( m_curSequence == NULL )
+		{
+			block->Free(icarus);
+			delete block;
+			block = NULL;
+			return SEQ_OK;
+		}
+
+		//Check to retain the command
+		if ( m_curSequence->HasFlag( CSequence::SQ_RETAIN ) )	//This isn't true for affect sequences...?
+		{
+			PushCommand( block, CSequence::PUSH_FRONT );
+		}
+		else
+		{
+			block->Free(icarus);
+			delete block;
+			block = NULL;
+		}
+
+		//Check for pending commands
+		if ( m_curSequence->GetNumCommands() <= 0 )
+		{
+			if ( m_curSequence->GetReturn() == NULL)
+				return SEQ_OK;
+
+			m_curSequence = m_curSequence->GetReturn();
+		}
+
+		command = PopCommand( CSequence::POP_BACK );
+		Prep( &command , icarus);
+
+		if ( command )
+			taskManager->SetCommand( command, CSequence::PUSH_FRONT, icarus );
+
+		return SEQ_OK;
+	}
+
+	//FIXME: This could be more descriptive
+	game->DebugPrint(IGameInterface::WL_ERROR,  "command could not be called back\n" );
+	assert(0);
+
+	return SEQ_FAILED;
+}
+
+/*
+-------------------------
+Recall
+-------------------------
+*/
+
+int CSequencer::Recall( CIcarus* icarus )
+{
+	CBlock	*block	= NULL;
+
+	while ( ( block = m_taskManager->RecallTask() ) != NULL )
+	{
+		if (m_curSequence)
+		{
+			PushCommand( block, CSequence::PUSH_BACK );
+		}
+		else
+		{
+			block->Free(icarus);
+			delete block;
+			block = NULL;
+		}
+	}
+
+	return true;
+}
+
+/*
+-------------------------
+Affect
+-------------------------
+*/
+
+int CSequencer::Affect( int id, int type, CIcarus* icarus )
+{
+	IGameInterface* game = icarus->GetGame();
+	CSequence	*sequence = GetSequence( id );
+
+	if ( sequence == NULL )
+	{
+		return SEQ_FAILED;
+	}
+
+	switch ( type )
+	{
+
+	case CIcarus::TYPE_FLUSH:
+
+		//Get rid of all old code
+		Flush( sequence, icarus );
+
+		sequence->RemoveFlag( CSequence::SQ_PENDING, true );	
+		
+		m_curSequence = sequence;
+
+		Prime( m_taskManager, PopCommand( CSequence::POP_BACK ), icarus );
+
+		break;
+		
+	case CIcarus::TYPE_INSERT:
+
+		Recall(icarus);
+		
+		sequence->SetReturn( m_curSequence );
+		
+		sequence->RemoveFlag( CSequence::SQ_PENDING, true );
+		
+		m_curSequence = sequence;
+
+		Prime( m_taskManager, PopCommand( CSequence::POP_BACK ), icarus );
+
+		break;
+
+
+	default:
+		game->DebugPrint(IGameInterface::WL_ERROR, "unknown affect type found" );
+		break;
+	}
+
+	return SEQ_OK;
+}
+
+/*
+========================
+PushCommand
+
+Pushes a commands onto the current sequence
+========================
+*/
+
+int CSequencer::PushCommand( CBlock *command, int flag )
+{
+	//Make sure everything is ok
+	assert( m_curSequence );
+	if ( m_curSequence == NULL )
+		return SEQ_FAILED;
+
+	m_curSequence->PushCommand( command, flag );
+	m_numCommands++;
+	
+	//Invalid flag
+	return SEQ_OK;
+}
+
+/*
+========================
+PopCommand
+
+Pops a command off the current sequence
+========================
+*/
+
+CBlock *CSequencer::PopCommand( int flag )
+{
+	//Make sure everything is ok
+	assert( m_curSequence );
+	if ( m_curSequence == NULL )
+		return NULL;
+
+	CBlock *block = m_curSequence->PopCommand( flag );	
+
+	if ( block != NULL )
+		m_numCommands--;
+
+	return block;
+}
+
+/*
+========================
+StripExtension
+
+Filename ultility.  Probably get rid of this if I decided to use CStrings...
+========================
+*/
+
+void CSequencer::StripExtension( const char *in, char *out )
+{
+	int		i = strlen(in) + 1;
+	
+	while ( (in[i] != '.') && (i >= 0) )
+	 i--;
+
+	if ( i < 0 )
+	{
+		strcpy(out, in);
+		return;
+	}
+
+	strncpy(out, in, i);
+}
+
+
+/*
+-------------------------
+RemoveSequence
+-------------------------
+*/
+
+//NOTENOTE: This only removes references to the sequence, IT DOES NOT FREE THE ALLOCATED MEMORY!  You've be warned! =)
+
+int CSequencer::RemoveSequence( CSequence *sequence, CIcarus* icarus )
+{
+	IGameInterface* game = icarus->GetGame();
+	CSequence *temp;
+
+	int numChildren = sequence->GetNumChildren();
+
+	//Add all the children
+	for ( int i = 0; i < numChildren; i++ )
+	{
+		temp = sequence->GetChildByIndex( i );
+
+		//TODO: Emit warning
+		assert( temp );
+		if ( temp == NULL )
+		{
+			game->DebugPrint(IGameInterface::WL_WARNING, "Unable to find child sequence on RemoveSequence call!\n" );
+			continue;
+		}
+
+		//Remove the references to this sequence
+		temp->SetParent( NULL );
+		temp->SetReturn( NULL );
+
+	}
+		
+	return SEQ_OK;
+}
+
+int CSequencer::DestroySequence( CSequence *sequence, CIcarus* icarus )
+{
+	if ( !sequence || !icarus )
+		return SEQ_FAILED;
+
+	//m_sequenceMap.erase( sequence->GetID() );
+	m_sequences.remove( sequence );
+
+	taskSequence_m::iterator	tsi;
+	for ( tsi = m_taskSequences.begin(); tsi != m_taskSequences.end(); )
+	{
+		if((*tsi).second == sequence)
+		{
+			tsi = m_taskSequences.erase(tsi);
+		}
+		else
+		{
+			++tsi;
+		}
+	}
+
+	// Remove this guy from his parents list.
+	CSequence* parent = sequence->GetParent();
+	if ( parent )
+	{
+		parent->RemoveChild( sequence );
+		parent = NULL;
+	}
+	
+	int curChild = sequence->GetNumChildren();
+	while( curChild )
+	{
+		// Stop if we're about to go negative (invalid index!).
+		if ( curChild > 0 )
+		{
+			DestroySequence( sequence->GetChildByIndex( --curChild ), icarus);
+		}
+		else
+			break;
+	}
+
+	icarus->DeleteSequence( sequence );
+		
+	return SEQ_OK;
+}
+
+/*
+-------------------------
+ReturnSequence
+-------------------------
+*/
+
+inline CSequence *CSequencer::ReturnSequence( CSequence *sequence )
+{
+	while ( sequence->GetReturn() )
+	{
+		assert(sequence != sequence->GetReturn() );
+		if ( sequence == sequence->GetReturn() )
+			return NULL;
+
+		sequence = sequence->GetReturn();
+
+		if ( sequence->GetNumCommands() > 0 )
+			return sequence;
+	}
+	return NULL;
+}
+
+//Save / Load
+
+/*
+-------------------------
+Save
+-------------------------
+*/
+
+int	CSequencer::Save()
+{
+	taskSequence_m::iterator	ti;
+	int							numSequences = 0, id, numTasks;
+
+	// Data saved here.
+	//	Owner Sequence.
+	//	Number of Sequences.
+	//	Sequences (data).
+	//	Taskmanager.
+	//	Number of Task Sequences.
+	//	Task Sequences (data):
+	//				-Task group ID.
+	//				-Sequence ID.
+	//	Group ID.
+	//	Number of Commands.
+	//	ID of current Sequence.
+
+	CIcarus *pIcarus = (CIcarus *)IIcarusInterface::GetIcarus();
+
+	//Get the number of sequences to save out
+	numSequences = /*m_sequenceMap.size();*/ m_sequences.size();
+
+	//Save out the owner sequence
+	pIcarus->BufferWrite( &m_ownerID, sizeof( m_ownerID ) );
+
+	//Write out the number of sequences we need to read
+	pIcarus->BufferWrite( &numSequences, sizeof( numSequences ) );
+
+	//Second pass, save out all sequences, in order
+	sequence_l::iterator iterSeq = NULL;
+	STL_ITERATE( iterSeq, m_sequences )
+	{
+		id = (*iterSeq)->GetID();
+		pIcarus->BufferWrite( &id, sizeof( id ) );
+	}
+
+	//Save out the taskManager
+	m_taskManager->Save();
+
+	//Save out the task sequences mapping the name to the GUIDs
+	numTasks = m_taskSequences.size();
+	pIcarus->BufferWrite( &numTasks, sizeof( numTasks ) );
+
+	STL_ITERATE( ti, m_taskSequences )
+	{	
+		//Save the task group's ID
+		id = ((*ti).first)->GetGUID();
+		pIcarus->BufferWrite( &id, sizeof( id ) );
+
+		//Save the sequence's ID
+		id = ((*ti).second)->GetID();
+		pIcarus->BufferWrite( &id, sizeof( id ) );
+	}
+
+	int	curGroupID = ( m_curGroup == NULL ) ? -1 : m_curGroup->GetGUID();
+
+	// Right the group ID.
+	pIcarus->BufferWrite( &curGroupID, sizeof( curGroupID ) );
+
+	//Output the number of commands
+	pIcarus->BufferWrite( &m_numCommands, sizeof( m_numCommands ) );
+
+	//Output the ID of the current sequence
+	id = ( m_curSequence != NULL ) ? m_curSequence->GetID() : -1;
+	pIcarus->BufferWrite( &id, sizeof( id ) );
+
+	return true;
+}
+
+/*
+-------------------------
+Load
+-------------------------
+*/
+
+int	CSequencer::Load( CIcarus* icarus, IGameInterface* game )
+{	
+	// Data expected/loaded here.
+	//	Owner Sequence.
+	//	Number of Sequences.
+	//	Sequences (data).
+	//	Taskmanager.
+	//	Number of Task Sequences.
+	//	Task Sequences (data):
+	//				-Task group ID.
+	//				-Sequence ID.
+	//	Group ID.
+	//	Number of Commands.
+	//	ID of current Sequence.
+
+	CIcarus *pIcarus = (CIcarus *)IIcarusInterface::GetIcarus();
+
+	//Get the owner of this sequencer
+	pIcarus->BufferRead( &m_ownerID, sizeof( m_ownerID ) );
+
+	//Link the entity back to the sequencer
+	game->LinkGame( m_ownerID, m_id );
+
+	CTaskGroup	*taskGroup;
+	CSequence	*seq;
+	int			numSequences, seqID, taskID, numTasks;
+
+	//Get the number of sequences to read
+	pIcarus->BufferRead( &numSequences, sizeof( numSequences ) );
+
+	//Read in all the sequences
+	for ( int i = 0; i < numSequences; i++ )
+	{
+		pIcarus->BufferRead( &seqID, sizeof( seqID ) );
+
+		seq = (CSequence*)icarus->GetSequence( seqID );
+
+		assert( seq );
+
+		STL_INSERT( m_sequences, seq );
+		//m_sequenceMap[ seqID ] = seq;
+	}
+
+	//Setup the task manager
+	m_taskManager->Init( this );
+
+	//Load the task manager
+	m_taskManager->Load(icarus);
+
+	//Get the number of tasks in the map
+	pIcarus->BufferRead( &numTasks, sizeof( numTasks ) );
+
+	//Read in, and reassociate the tasks to the sequences
+	for ( i = 0; i < numTasks; i++ )
+	{
+		//Read in the task's ID
+		pIcarus->BufferRead( &taskID, sizeof( taskID ) );
+		
+		//Read in the sequence's ID
+		pIcarus->BufferRead( &seqID, sizeof( seqID ) );
+
+		taskGroup = m_taskManager->GetTaskGroup( taskID , icarus);
+
+		assert( taskGroup );
+
+		seq = icarus->GetSequence( seqID );
+
+		assert( seq );
+
+		//Associate the values
+		m_taskSequences[ taskGroup ] = seq;
+	}
+
+	int	curGroupID;
+
+	//Get the current task group
+	pIcarus->BufferRead( &curGroupID, sizeof( curGroupID ) );
+
+	m_curGroup = ( curGroupID == -1 ) ? NULL : m_taskManager->GetTaskGroup( curGroupID , icarus);
+
+	//Get the number of commands
+	pIcarus->BufferRead( &m_numCommands, sizeof( m_numCommands ) );
+
+	//Get the current sequence
+	pIcarus->BufferRead( &seqID, sizeof( seqID ) );
+
+	m_curSequence = ( seqID != -1 ) ? (CSequence*)icarus->GetSequence( seqID ) : NULL;
+
+	return true;
+}
diff --git a/code/icarus/StdAfx.h b/code/icarus/StdAfx.h
new file mode 100644
index 0000000..b7086af
--- /dev/null
+++ b/code/icarus/StdAfx.h
@@ -0,0 +1,19 @@
+#ifndef __ICR_STDAFX__
+#define __ICR_STDAFX__
+
+#pragma warning( disable : 4786 )  // identifier was truncated 
+
+#pragma warning (push, 3)
+#include <string>
+#include <list>
+#include <vector>
+#include <map>
+#include <algorithm>
+#pragma warning (pop)
+
+using namespace std;
+
+#define STL_ITERATE( a, b )		for ( a = b.begin(); a != b.end(); a++ )
+#define STL_INSERT( a, b )		a.insert( a.end(), b );
+
+#endif
\ No newline at end of file
diff --git a/code/icarus/TaskManager.cpp b/code/icarus/TaskManager.cpp
new file mode 100644
index 0000000..eb94a2a
--- /dev/null
+++ b/code/icarus/TaskManager.cpp
@@ -0,0 +1,2036 @@
+// Task Manager 
+//
+//	-- jweier
+
+
+// this include must remain at the top of every Icarus CPP file
+#include "stdafx.h"
+#include "IcarusImplementation.h"
+
+#include "BlockStream.h"
+#include "Sequence.h"
+#include "TaskManager.h"
+#include "Sequencer.h"
+
+#define ICARUS_VALIDATE(a) if ( a == false ) return TASK_FAILED;
+
+#define STL_ITERATE( a, b )		for ( a = b.begin(); a != b.end(); a++ )
+#define STL_INSERT( a, b )		a.insert( a.end(), b );
+
+/*
+=================================================
+
+CTask
+
+=================================================
+*/
+
+CTask::CTask( void )
+{
+}
+
+CTask::~CTask( void )
+{
+}
+
+CTask *CTask::Create( int GUID, CBlock *block )
+{
+	CTask *task = new CTask;
+
+	//TODO: Emit warning
+	if ( task == NULL )
+		return NULL;
+
+	task->SetTimeStamp( 0 );
+	task->SetBlock( block );
+	task->SetGUID( GUID );
+
+	return task;
+}
+
+/*
+-------------------------
+Free
+-------------------------
+*/
+
+void CTask::Free( void )
+{
+	//NOTENOTE: The block is not consumed by the task, it is the sequencer's job to clean blocks up	
+	delete this;
+}
+
+/*
+=================================================
+
+CTaskGroup
+
+=================================================
+*/
+
+CTaskGroup::CTaskGroup( void )
+{
+	Init();
+
+	m_GUID		= 0;
+	m_parent	= NULL;
+}
+
+CTaskGroup::~CTaskGroup( void )
+{
+	m_completedTasks.clear();
+}
+
+/*
+-------------------------
+SetGUID
+-------------------------
+*/
+
+void CTaskGroup::SetGUID( int GUID )
+{
+	m_GUID = GUID;
+}
+
+/*
+-------------------------
+Init
+-------------------------
+*/
+
+void CTaskGroup::Init( void )
+{
+	m_completedTasks.clear();
+
+	m_numCompleted	= 0;
+	m_parent		= NULL;
+}
+
+/*
+-------------------------
+Add
+-------------------------
+*/
+
+int CTaskGroup::Add( CTask *task )
+{
+	m_completedTasks[ task->GetGUID() ] = false;
+	return TASK_OK;	
+}
+
+/*
+-------------------------
+MarkTaskComplete
+-------------------------
+*/
+
+bool CTaskGroup::MarkTaskComplete( int id )
+{
+	if ( (m_completedTasks.find( id )) != m_completedTasks.end() )
+	{
+		m_completedTasks[ id ] = true;
+		m_numCompleted++;
+
+		return true;
+	}
+
+	return false;
+}
+
+/*
+=================================================
+
+CTaskManager
+
+=================================================
+*/
+
+CTaskManager::CTaskManager( void )
+{
+	static int uniqueID = 0;
+	m_id = uniqueID++;
+}
+
+CTaskManager::~CTaskManager( void )
+{
+}
+
+/*
+-------------------------
+Create
+-------------------------
+*/
+
+CTaskManager *CTaskManager::Create( void )
+{
+	return new CTaskManager;
+}
+
+/*
+-------------------------
+Init
+-------------------------
+*/
+
+int	CTaskManager::Init( CSequencer *owner )
+{
+	//TODO: Emit warning
+	if ( owner == NULL )
+		return TASK_FAILED;
+
+	m_tasks.clear();
+	m_owner		= owner;
+	m_ownerID	= owner->GetOwnerID();
+	m_curGroup	= NULL;
+	m_GUID		= 0;
+	m_resident	= false;
+
+	return TASK_OK;
+}
+
+/*
+-------------------------
+Free
+-------------------------
+*/
+int CTaskManager::Free( void )
+{
+	taskGroup_v::iterator	gi;
+	tasks_l::iterator		ti;
+
+	assert(!m_resident);	//don't free me, i'm currently running!
+	//Clear out all pending tasks
+	for ( ti = m_tasks.begin(); ti != m_tasks.end(); ti++ )
+	{
+		(*ti)->Free();
+	}
+
+	m_tasks.clear();
+
+	//Clear out all taskGroups
+	for ( gi = m_taskGroups.begin(); gi != m_taskGroups.end(); gi++ )
+	{
+		delete (*gi);
+	}
+	
+	m_taskGroups.clear();
+	m_taskGroupNameMap.clear();
+	m_taskGroupIDMap.clear();
+
+	return TASK_OK;
+}
+
+/*
+-------------------------
+Flush
+-------------------------
+*/
+
+int CTaskManager::Flush( void )
+{	
+	//FIXME: Rewrite
+	
+	return true;
+}
+
+/*
+-------------------------
+AddTaskGroup
+-------------------------
+*/
+
+CTaskGroup *CTaskManager::AddTaskGroup( const char *name, CIcarus* icarus )
+{
+	CTaskGroup *group;
+
+	//Collect any garbage
+	taskGroupName_m::iterator	tgni;
+	tgni = m_taskGroupNameMap.find( name );
+
+	if ( tgni != m_taskGroupNameMap.end() )
+	{
+		group = (*tgni).second;
+		
+		//Clear it and just move on
+		group->Init();
+		
+		return group;
+	}
+
+	//Allocate a new one
+	group = new CTaskGroup;
+
+	//TODO: Emit warning
+	assert( group );
+	if ( group == NULL )
+	{
+		icarus->GetGame()->DebugPrint(IGameInterface::WL_ERROR, "Unable to allocate task group \"%s\"\n", name );
+		return NULL;
+	}
+
+	//Setup the internal information
+	group->SetGUID( m_GUID++ );
+
+	//Add it to the list and associate it for retrieval later
+	m_taskGroups.insert( m_taskGroups.end(), group );
+	m_taskGroupNameMap[ name ] = group;
+	m_taskGroupIDMap[ group->GetGUID() ] = group;
+
+	return group;
+}
+
+/*
+-------------------------
+GetTaskGroup
+-------------------------
+*/
+
+CTaskGroup *CTaskManager::GetTaskGroup( const char *name, CIcarus* icarus )
+{
+	taskGroupName_m::iterator	tgi;
+
+	tgi = m_taskGroupNameMap.find( name );
+
+	if ( tgi == m_taskGroupNameMap.end() )
+	{
+		icarus->GetGame()->DebugPrint(IGameInterface::WL_WARNING, "Could not find task group \"%s\"\n", name );
+		return NULL;
+	}
+
+	return (*tgi).second;
+}
+
+CTaskGroup *CTaskManager::GetTaskGroup( int id, CIcarus* icarus )
+{
+	taskGroupID_m::iterator	tgi;
+
+	tgi = m_taskGroupIDMap.find( id );
+
+	if ( tgi == m_taskGroupIDMap.end() )
+	{
+		icarus->GetGame()->DebugPrint(IGameInterface::WL_WARNING, "Could not find task group \"%d\"\n", id );
+		return NULL;
+	}
+
+	return (*tgi).second;
+}
+
+/*
+-------------------------
+Update
+-------------------------
+*/
+
+int CTaskManager::Update( CIcarus* icarus )
+{
+	if ( icarus->GetGame()->IsFrozen(m_ownerID) )
+	{
+		return TASK_FAILED;
+	}
+	m_count = 0;	//Needed for runaway init
+	m_resident = true;
+
+	int returnVal = Go(icarus);
+
+	m_resident = false;
+
+	return returnVal;
+}
+
+/*
+-------------------------
+Check
+-------------------------
+*/
+
+inline bool CTaskManager::Check( int targetID, CBlock *block, int memberNum ) const
+{
+	if ( (block->GetMember( memberNum ))->GetID() == targetID )
+		return true;
+
+	return false;
+}
+
+/*
+-------------------------
+GetFloat
+-------------------------
+*/
+
+int CTaskManager::GetFloat( int entID, CBlock *block, int &memberNum, float &value, CIcarus* icarus )
+{
+	char	*name;
+	int		type;
+
+	//See if this is a get() command replacement
+	if ( Check( CIcarus::ID_GET, block, memberNum ) )
+	{
+		//Update the member past the header id
+		memberNum++;
+
+		//get( TYPE, NAME )
+		type = (int) (*(float *) block->GetMemberData( memberNum++ ));
+		name = (char *) block->GetMemberData( memberNum++ );
+
+		//TODO: Emit warning
+		if ( type != CIcarus::TK_FLOAT )
+		{
+			icarus->GetGame()->DebugPrint(IGameInterface::WL_ERROR, "Get() call tried to return a non-FLOAT parameter!\n" );
+			return false; 
+		}
+
+		return icarus->GetGame()->GetFloat( entID, name, &value );
+	}
+
+	//Look for a random() inline call
+	if ( Check( CIcarus::ID_RANDOM, block, memberNum ) )
+	{
+		float	min, max;
+
+		memberNum++;
+
+		min	= *(float *) block->GetMemberData( memberNum++ );
+		max	= *(float *) block->GetMemberData( memberNum++ );
+
+		value = icarus->GetGame()->Random( min, max );
+
+		return true;
+	}
+
+	//Look for a tag() inline call
+	if ( Check( CIcarus::ID_TAG, block, memberNum ) )
+	{
+		icarus->GetGame()->DebugPrint(IGameInterface::WL_WARNING, "Invalid use of \"tag\" inline.  Not a valid replacement for type FLOAT\n" );
+		return false;
+	}
+
+	CBlockMember	*bm	= block->GetMember( memberNum );
+	
+	if ( bm->GetID() == CIcarus::TK_INT )
+	{
+		value = (float) (*(int *) block->GetMemberData( memberNum++ ));
+	}
+	else if ( bm->GetID() == CIcarus::TK_FLOAT )
+	{
+		value = *(float *) block->GetMemberData( memberNum++ );
+	}
+	else
+	{
+		assert(0);
+		icarus->GetGame()->DebugPrint(IGameInterface::WL_WARNING, "Unexpected value; expected type FLOAT\n" );
+		return false;
+	}
+
+	return true;
+}
+
+/*
+-------------------------
+GetVector
+-------------------------
+*/
+
+int CTaskManager::GetVector( int entID, CBlock *block, int &memberNum, vec3_t &value, CIcarus* icarus )
+{
+	char	*name;
+	int		type, i;
+
+	//See if this is a get() command replacement
+	if ( Check( CIcarus::ID_GET, block, memberNum ) )
+	{
+		//Update the member past the header id
+		memberNum++;
+
+		//get( TYPE, NAME )
+		type = (int) (*(float *) block->GetMemberData( memberNum++ ));
+		name = (char *) block->GetMemberData( memberNum++ );
+
+		//TODO: Emit warning
+		if ( type != CIcarus::TK_VECTOR )
+		{
+			icarus->GetGame()->DebugPrint(IGameInterface::WL_ERROR, "Get() call tried to return a non-VECTOR parameter!\n" );
+		}
+
+		return icarus->GetGame()->GetVector( entID, name, value );
+	}
+
+	//Look for a random() inline call
+	if ( Check( CIcarus::ID_RANDOM, block, memberNum ) )
+	{
+		float	min, max;
+
+		memberNum++;
+
+		min	= *(float *) block->GetMemberData( memberNum++ );
+		max	= *(float *) block->GetMemberData( memberNum++ );
+
+		for ( i = 0; i < 3; i++ )
+		{
+			value[i] = (float) icarus->GetGame()->Random( min, max );	//FIXME: Just truncating it for now.. should be fine though
+		}
+
+		return true;
+	}
+
+	//Look for a tag() inline call
+	if ( Check( CIcarus::ID_TAG, block, memberNum ) )
+	{
+		char	*tagName;
+		float	tagLookup;
+
+		memberNum++;
+		ICARUS_VALIDATE ( Get( entID, block, memberNum, &tagName, icarus ) );
+		ICARUS_VALIDATE ( GetFloat( entID, block, memberNum, tagLookup, icarus ) );
+
+		if ( icarus->GetGame()->GetTag( entID, tagName, (int) tagLookup, value ) == false)
+		{
+			icarus->GetGame()->DebugPrint(IGameInterface::WL_ERROR, "Unable to find tag \"%s\"!\n", tagName );
+			assert(0&&"Unable to find tag");
+			return TASK_FAILED;
+		}		
+
+		return true;
+	}
+
+	//Check for a real vector here
+	type = (int) (*(float *) block->GetMemberData( memberNum ));
+
+	if ( type != CIcarus::TK_VECTOR )
+	{
+//		icarus->GetGame()->DPrintf( WL_WARNING, "Unexpected value; expected type VECTOR\n" );
+		return false;
+	}
+
+	memberNum++;
+
+	for ( i = 0; i < 3; i++ )
+	{
+		if ( GetFloat( entID, block, memberNum, value[i], icarus ) == false )
+			return false;
+	}
+
+	return true;
+}
+
+/*
+-------------------------
+Get
+-------------------------
+*/
+
+int CTaskManager::GetID()
+{
+	return m_id;
+}
+
+int CTaskManager::Get( int entID, CBlock *block, int &memberNum, char **value, CIcarus* icarus )
+{
+	static	char	tempBuffer[128];	//FIXME: EEEK!
+	vec3_t			vector;
+	char			*name, *tagName;
+	float			tagLookup;
+	int				type;
+
+	//Look for a get() inline call
+	if ( Check( CIcarus::ID_GET, block, memberNum ) )
+	{
+		//Update the member past the header id
+		memberNum++;
+
+		//get( TYPE, NAME )
+		type = (int) (*(float *) block->GetMemberData( memberNum++ ));
+		name = (char *) block->GetMemberData( memberNum++ );
+
+		//Format the return properly
+		//FIXME: This is probably doing double formatting in certain cases...
+		//FIXME: STRING MANAGEMENT NEEDS TO BE IMPLEMENTED, MY CURRENT SOLUTION IS NOT ACCEPTABLE!!
+		switch ( type )
+		{
+		case CIcarus::TK_STRING:
+			if ( icarus->GetGame()->GetString( entID, name, value ) == false )
+			{
+				icarus->GetGame()->DebugPrint(IGameInterface::WL_ERROR, "Get() parameter \"%s\" could not be found!\n", name );
+				return false;
+			}
+			
+			return true;
+			break;
+
+		case CIcarus::TK_FLOAT:
+			{
+				float	temp;
+
+				if ( icarus->GetGame()->GetFloat( entID, name, &temp ) == false )
+				{
+					icarus->GetGame()->DebugPrint(IGameInterface::WL_ERROR, "Get() parameter \"%s\" could not be found!\n", name );	
+					return false;
+				}
+
+				sprintf( (char *) tempBuffer, "%f", temp );
+				*value = (char *) tempBuffer;
+			}
+			
+			return true;
+			break;
+
+		case CIcarus::TK_VECTOR:
+			{
+				vec3_t	vval;
+
+				if ( icarus->GetGame()->GetVector( entID, name, vval )  == false )
+				{
+					icarus->GetGame()->DebugPrint(IGameInterface::WL_ERROR, "Get() parameter \"%s\" could not be found!\n", name );	
+					return false;
+				}
+
+				sprintf( (char *) tempBuffer, "%f %f %f", vval[0], vval[1], vval[2] );
+				*value = (char *) tempBuffer;
+			}
+			
+			return true;
+			break;
+
+		default:
+			icarus->GetGame()->DebugPrint(IGameInterface::WL_ERROR, "Get() call tried to return an unknown type!\n" );
+			return false;
+			break;
+		}
+	}
+
+	//Look for a random() inline call
+	if ( Check( CIcarus::ID_RANDOM, block, memberNum ) )
+	{
+		float	min, max, ret;
+
+		memberNum++;
+
+		min	= *(float *) block->GetMemberData( memberNum++ );
+		max	= *(float *) block->GetMemberData( memberNum++ );
+
+		ret = icarus->GetGame()->Random( min, max );
+
+		sprintf( (char *) tempBuffer, "%f", ret );
+		*value = (char *) tempBuffer;
+
+		return true;
+	}
+
+	//Look for a tag() inline call
+	if ( Check( CIcarus::ID_TAG, block, memberNum ) )
+	{
+		memberNum++;
+		ICARUS_VALIDATE ( Get( entID, block, memberNum, &tagName, icarus ) );
+		ICARUS_VALIDATE ( GetFloat( entID, block, memberNum, tagLookup, icarus ) );
+
+		if (icarus->GetGame()->GetTag( entID, tagName, (int) tagLookup, vector ) == false)
+		{
+			icarus->GetGame()->DebugPrint(IGameInterface::WL_ERROR, "Unable to find tag \"%s\"!\n", tagName );
+			assert(0 && "Unable to find tag");
+			return false;
+		}
+
+		sprintf( (char *) tempBuffer, "%f %f %f", vector[0], vector[1], vector[2] );
+		*value = (char *) tempBuffer;
+
+		return true;
+	}
+
+	//Get an actual piece of data
+
+	CBlockMember	*bm	= block->GetMember( memberNum );
+
+	if ( bm->GetID() == CIcarus::TK_INT )
+	{
+		float fval = (float) (*(int *) block->GetMemberData( memberNum++ ));
+		sprintf( (char *) tempBuffer, "%f", fval );
+		*value = (char *) tempBuffer;
+
+		return true;
+	}
+	else if ( bm->GetID() == CIcarus::TK_FLOAT )
+	{
+		float fval = *(float *) block->GetMemberData( memberNum++ );
+		sprintf( (char *) tempBuffer, "%f", fval );
+		*value = (char *) tempBuffer;
+
+		return true;
+	}
+	else if ( bm->GetID() == CIcarus::TK_VECTOR )
+	{
+		vec3_t	vval;
+
+		memberNum++;
+
+		for ( int i = 0; i < 3; i++ )
+		{
+			if ( GetFloat( entID, block, memberNum, vval[i], icarus ) == false )
+				return false;
+
+			sprintf( (char *) tempBuffer, "%f %f %f", vval[0], vval[1], vval[2] );
+			*value = (char *) tempBuffer;
+		}
+		
+		return true;
+	}
+	else if ( ( bm->GetID() == CIcarus::TK_STRING ) || ( bm->GetID() == CIcarus::TK_IDENTIFIER ) )
+	{
+		*value = (char *) block->GetMemberData( memberNum++ );
+
+		return true;
+	}
+	
+	//TODO: Emit warning
+	assert( 0 );
+	icarus->GetGame()->DebugPrint(IGameInterface::WL_WARNING, "Unexpected value; expected type STRING\n" );
+
+	return false;
+}
+
+/*
+-------------------------
+Go
+-------------------------
+*/
+
+int	CTaskManager::Go( CIcarus* icarus )
+{
+	CTask	*task = NULL;
+	bool	completed = false;
+
+	//Check for run away scripts
+	if ( m_count++ > RUNAWAY_LIMIT )
+	{
+		assert(0);
+		icarus->GetGame()->DebugPrint(IGameInterface::WL_ERROR, "Runaway loop detected!\n" );
+		return TASK_FAILED;
+	}
+
+	//If there are tasks to complete, do so
+	if ( m_tasks.empty() == false )
+	{
+		//Get the next task
+		task = PopTask( CSequence::POP_BACK );
+
+		assert( task );
+		if ( task == NULL )
+		{
+			icarus->GetGame()->DebugPrint(IGameInterface::WL_ERROR, "Invalid task found in Go()!\n" );
+			return TASK_FAILED;
+		}
+	
+		//If this hasn't been stamped, do so
+		if ( task->GetTimeStamp() == 0 )
+			task->SetTimeStamp( icarus->GetGame()->GetTime() );
+			
+		//Switch and call the proper function
+		switch( task->GetID() )
+		{
+		case CIcarus::ID_WAIT:
+			
+			Wait( task, completed, icarus );
+
+			//Push it to consider it again on the next frame if not complete
+			if ( completed == false )
+			{
+				PushTask( task, CSequence::PUSH_BACK );
+				return TASK_OK;
+			}
+
+			Completed( task->GetGUID() );
+
+			break;
+
+		case CIcarus::ID_WAITSIGNAL:
+			
+			WaitSignal( task, completed , icarus);
+
+			//Push it to consider it again on the next frame if not complete
+			if ( completed == false )
+			{
+				PushTask( task, CSequence::PUSH_BACK );
+				return TASK_OK;
+			}
+
+			Completed( task->GetGUID() );
+
+			break;
+		
+		case CIcarus::ID_PRINT:	//print( STRING )
+			Print( task, icarus );
+			break;
+
+		case CIcarus::ID_SOUND:	//sound( name )
+			Sound( task, icarus );
+			break;
+
+		case CIcarus::ID_MOVE:	//move ( ORIGIN, ANGLES, DURATION )
+			Move( task, icarus );
+			break;
+
+		case CIcarus::ID_ROTATE:	//rotate( ANGLES, DURATION )
+			Rotate( task, icarus );
+			break;
+
+		case CIcarus::ID_KILL:	//kill( NAME )
+			Kill( task, icarus );
+			break;
+
+		case CIcarus::ID_REMOVE:	//remove( NAME )
+			Remove( task, icarus );
+			break;
+
+		case CIcarus::ID_CAMERA:	//camera( ? )
+			Camera( task, icarus );
+			break;
+
+		case CIcarus::ID_SET:	//set( NAME, ? )
+			Set( task, icarus );
+			break;
+
+		case CIcarus::ID_USE:	//use( NAME )
+			Use( task, icarus );
+			break;
+
+		case CIcarus::ID_DECLARE://declare( TYPE, NAME )
+			DeclareVariable( task, icarus );
+			break;
+
+		case CIcarus::ID_FREE:	//free( NAME )
+			FreeVariable( task, icarus );
+			break;
+
+		case CIcarus::ID_SIGNAL:	//signal( NAME )
+			Signal( task, icarus );
+			break;
+
+		case CIcarus::ID_PLAY:	//play ( NAME )
+			Play( task, icarus );
+			break;
+
+		default:
+			assert(0);
+			task->Free();
+			icarus->GetGame()->DebugPrint(IGameInterface::WL_ERROR, "Found unknown task type!\n" );
+			return TASK_FAILED;
+			break;
+		}
+
+		//Pump the sequencer for another task
+		CallbackCommand( task, TASK_RETURN_COMPLETE , icarus);
+
+		task->Free();
+	}
+	
+	//FIXME: A command surge limiter could be implemented at this point to be sure a script doesn't
+	//		 execute too many commands in one cycle.  This may, however, cause timing errors to surface.
+	return TASK_OK;
+}
+
+/*
+-------------------------
+SetCommand
+-------------------------
+*/
+
+int	CTaskManager::SetCommand( CBlock *command, int type, CIcarus* icarus )
+{
+	CTask	*task = CTask::Create( m_GUID++, command );
+
+	//If this is part of a task group, add it in
+	if ( m_curGroup )
+	{
+		m_curGroup->Add( task );
+	}
+
+	//TODO: Emit warning
+	assert( task );
+	if ( task == NULL )
+	{
+		icarus->GetGame()->DebugPrint(IGameInterface::WL_ERROR, "Unable to allocate new task!\n" );
+		return TASK_FAILED;
+	}
+
+	PushTask( task, type );
+
+	return TASK_OK;
+}
+
+/*
+-------------------------
+MarkTask
+-------------------------
+*/
+
+int CTaskManager::MarkTask( int id, int operation, CIcarus* icarus )
+{
+	CTaskGroup *group	= GetTaskGroup( id, icarus );
+
+	assert( group );
+
+	if ( group == NULL )
+		return TASK_FAILED;
+
+	if ( operation == TASK_START )
+	{
+		//Reset all the completion information
+		group->Init();
+
+		group->SetParent( m_curGroup );
+		m_curGroup = group;
+	}
+	else if ( operation == TASK_END )
+	{
+		assert( m_curGroup );
+		if ( m_curGroup == NULL )
+			return TASK_FAILED;
+
+		m_curGroup = m_curGroup->GetParent();
+	}
+
+#ifdef _DEBUG
+	else
+	{
+		assert(0);
+	}
+#endif
+
+	return TASK_OK;
+}
+
+/*
+-------------------------
+Completed
+-------------------------
+*/
+
+int CTaskManager::Completed( int id )
+{
+	taskGroup_v::iterator	tgi;
+
+	//Mark the task as completed
+	for ( tgi = m_taskGroups.begin(); tgi != m_taskGroups.end(); tgi++ )
+	{
+		//If this returns true, then the task was marked properly
+		if ( (*tgi)->MarkTaskComplete( id ) )
+			break;
+	}
+
+	return TASK_OK;
+}
+
+/*
+-------------------------
+CallbackCommand
+-------------------------
+*/
+
+int	CTaskManager::CallbackCommand( CTask *task, int returnCode, CIcarus* icarus )
+{
+	if ( m_owner->Callback( this, task->GetBlock(), returnCode, icarus ) == CSequencer::SEQ_OK, icarus )
+		return Go(icarus);
+
+	assert(0);
+
+	icarus->GetGame()->DebugPrint(IGameInterface::WL_ERROR, "Command callback failure!\n" );
+	return TASK_FAILED;
+}
+
+/*
+-------------------------
+RecallTask
+-------------------------
+*/
+
+CBlock *CTaskManager::RecallTask( void )
+{
+	CTask	*task;
+
+	task = PopTask( CSequence::POP_BACK );
+
+	if ( task )
+	{
+	// fixed 2/12/2 to free the task that has been popped (called from sequencer Recall)
+		CBlock* retBlock = task->GetBlock();
+		task->Free();
+
+		return retBlock;
+	//	return task->GetBlock();
+	}
+
+	return NULL;
+}
+
+/*
+-------------------------
+PushTask
+-------------------------
+*/
+
+int	CTaskManager::PushTask( CTask *task, int flag )
+{
+	assert( (flag == CSequence::PUSH_FRONT) || (flag == CSequence::PUSH_BACK) );
+
+	switch ( flag )
+	{
+	case CSequence::PUSH_FRONT:
+		m_tasks.insert(m_tasks.begin(), task);
+
+		return TASK_OK;
+		break;
+
+	case CSequence::PUSH_BACK:
+		m_tasks.insert(m_tasks.end(), task);
+
+		return TASK_OK;
+		break;
+	}
+
+	//Invalid flag
+	return CSequencer::SEQ_FAILED;
+}
+
+/*
+-------------------------
+PopTask
+-------------------------
+*/
+
+CTask *CTaskManager::PopTask( int flag )
+{
+	CTask	*task;
+
+	assert( (flag == CSequence::POP_FRONT) || (flag == CSequence::POP_BACK) );
+
+	if ( m_tasks.empty() )
+		return NULL;
+
+	switch ( flag )
+	{
+	case CSequence::POP_FRONT:
+		task = m_tasks.front();
+		m_tasks.pop_front();
+		
+		return task;
+		break;
+
+	case CSequence::POP_BACK:
+		task = m_tasks.back();
+		m_tasks.pop_back();
+		
+		return task;
+		break;
+	}
+
+	//Invalid flag
+	return NULL;
+}
+
+/*
+-------------------------
+GetCurrentTask
+-------------------------
+*/
+
+CBlock *CTaskManager::GetCurrentTask( void )
+{
+	CTask *task = PopTask( CSequence::POP_BACK );
+
+	if ( task == NULL )
+		return NULL;
+// fixed 2/12/2 to free the task that has been popped (called from sequencer Interrupt)
+	CBlock* retBlock = task->GetBlock();
+	task->Free();
+
+	return retBlock;
+//	return task->GetBlock();
+}
+
+/*
+=================================================
+
+  Task Functions
+
+=================================================
+*/
+
+int CTaskManager::Wait( CTask *task, bool &completed , CIcarus* icarus )
+{
+	CBlockMember	*bm;
+	CBlock			*block = task->GetBlock();	
+	char			*sVal;
+	float			dwtime;
+	int				memberNum = 0;
+
+	completed = false;
+
+	bm = block->GetMember( 0 );
+
+	//Check if this is a task completion wait
+	if ( bm->GetID() == CIcarus::TK_STRING )
+	{
+		ICARUS_VALIDATE( Get( m_ownerID, block, memberNum, &sVal, icarus ) );
+
+		if ( task->GetTimeStamp() == icarus->GetGame()->GetTime() )
+		{
+			//Print out the debug info
+			icarus->GetGame()->DebugPrint(IGameInterface::WL_DEBUG, "%4d wait(\"%s\"); [%d]", m_ownerID, sVal, task->GetTimeStamp() );
+		}
+
+		CTaskGroup	*group = GetTaskGroup( sVal , icarus);
+
+		if ( group == NULL )
+		{
+			//TODO: Emit warning
+			completed = false;
+			return TASK_FAILED;
+		}
+
+		completed = group->Complete();
+	}
+	else	//Otherwise it's a time completion wait
+	{
+		if ( Check( CIcarus::ID_RANDOM, block, memberNum ) )
+		{//get it random only the first time
+			float	min, max;
+
+			dwtime = *(float *) block->GetMemberData( memberNum++ );
+			if ( dwtime == icarus->GetGame()->MaxFloat() )
+			{//we have not evaluated this random yet
+				min	= *(float *) block->GetMemberData( memberNum++ );
+				max	= *(float *) block->GetMemberData( memberNum++ );
+
+				dwtime = icarus->GetGame()->Random( min, max );
+
+				//store the result in the first member
+				bm->SetData( &dwtime, sizeof( dwtime ) , icarus);
+			}
+		}
+		else
+		{
+			ICARUS_VALIDATE( GetFloat( m_ownerID, block, memberNum, dwtime, icarus ) );
+		}
+		
+		if ( task->GetTimeStamp() == icarus->GetGame()->GetTime() )
+		{
+			//Print out the debug info
+			icarus->GetGame()->DebugPrint(IGameInterface::WL_DEBUG, "%4d wait( %d ); [%d]", m_ownerID, (int) dwtime, task->GetTimeStamp() );
+		}
+
+		if ( (task->GetTimeStamp() + dwtime) < (icarus->GetGame()->GetTime()) )
+		{
+			completed = true;
+			memberNum = 0;
+			if ( Check( CIcarus::ID_RANDOM, block, memberNum ) )
+			{//set the data back to 0 so it will be re-randomized next time
+				dwtime = icarus->GetGame()->MaxFloat();
+				bm->SetData( &dwtime, sizeof( dwtime ), icarus );
+			}
+		}
+	}
+
+	return TASK_OK;
+}
+
+/*
+-------------------------
+WaitSignal
+-------------------------
+*/
+
+int CTaskManager::WaitSignal( CTask *task, bool &completed , CIcarus* icarus )
+{
+	CBlock	*block = task->GetBlock();
+	char	*sVal;
+	int		memberNum = 0;
+
+	completed = false;
+
+	ICARUS_VALIDATE( Get( m_ownerID, block, memberNum, &sVal , icarus) );
+
+	if ( task->GetTimeStamp() == icarus->GetGame()->GetTime() )
+	{
+		//Print out the debug info
+		icarus->GetGame()->DebugPrint(IGameInterface::WL_DEBUG, "%4d waitsignal(\"%s\"); [%d]", m_ownerID, sVal, task->GetTimeStamp() );
+	}
+
+	if ( icarus->CheckSignal( sVal ) )
+	{
+		completed = true;
+		icarus->ClearSignal( sVal );
+	}
+
+	return TASK_OK;
+}
+
+/*
+-------------------------
+Print
+-------------------------
+*/
+
+int CTaskManager::Print( CTask *task , CIcarus* icarus)
+{
+	CBlock	*block = task->GetBlock();
+	char	*sVal;
+	int		memberNum = 0;
+
+	ICARUS_VALIDATE( Get( m_ownerID, block, memberNum, &sVal, icarus ) );
+
+	icarus->GetGame()->DebugPrint(IGameInterface::WL_DEBUG, "%4d print(\"%s\"); [%d]", m_ownerID, sVal, task->GetTimeStamp() );
+
+	icarus->GetGame()->CenterPrint( sVal );
+
+	Completed( task->GetGUID() );
+	
+	return TASK_OK;
+}
+
+/*
+-------------------------
+Sound
+-------------------------
+*/
+
+int CTaskManager::Sound( CTask *task, CIcarus* icarus )
+{
+	CBlock	*block = task->GetBlock();
+	char	*sVal, *sVal2;
+	int		memberNum = 0;
+
+	ICARUS_VALIDATE( Get( m_ownerID, block, memberNum, &sVal, icarus ) );
+	ICARUS_VALIDATE( Get( m_ownerID, block, memberNum, &sVal2, icarus ) );
+
+	icarus->GetGame()->DebugPrint(IGameInterface::WL_DEBUG, "%4d sound(\"%s\", \"%s\"); [%d]", m_ownerID, sVal, sVal2, task->GetTimeStamp() );
+
+	//Only instantly complete if the user has requested it
+	if( icarus->GetGame()->PlaySound( task->GetGUID(), m_ownerID, sVal2, sVal ) )
+		Completed( task->GetGUID() );
+	
+	return TASK_OK;
+}
+
+/*
+-------------------------
+Rotate
+-------------------------
+*/
+
+int CTaskManager::Rotate( CTask *task , CIcarus* icarus)
+{
+	vec3_t		vector;
+	CBlock		*block = task->GetBlock();
+	char		*tagName;
+	float		tagLookup, duration;
+	int			memberNum = 0;
+
+	//Check for a tag reference
+	if ( Check( CIcarus::ID_TAG, block, memberNum ) )
+	{
+		memberNum++;
+
+		ICARUS_VALIDATE( Get( m_ownerID, block, memberNum, &tagName, icarus ) );
+		ICARUS_VALIDATE( GetFloat( m_ownerID, block, memberNum, tagLookup, icarus ) );
+
+		if ( icarus->GetGame()->GetTag( m_ownerID, tagName, (int) tagLookup, vector ) == false )
+		{
+			//TODO: Emit warning
+			icarus->GetGame()->DebugPrint(IGameInterface::WL_ERROR, "Unable to find tag \"%s\"!\n", tagName );
+			assert(0);
+			return TASK_FAILED;
+		}
+	}
+	else
+	{
+		//Get a normal vector
+		ICARUS_VALIDATE( GetVector( m_ownerID, block, memberNum, vector, icarus ) );
+	}
+
+	//Find the duration
+	ICARUS_VALIDATE( GetFloat( m_ownerID, block, memberNum, duration, icarus ) );
+
+	icarus->GetGame()->DebugPrint(IGameInterface::WL_DEBUG, "%4d rotate( <%f,%f,%f>, %d); [%d]", m_ownerID, vector[0], vector[1], vector[2], (int) duration, task->GetTimeStamp() );
+	icarus->GetGame()->Lerp2Angles( task->GetGUID(), m_ownerID, vector, duration );
+	
+	return TASK_OK;
+}
+
+/*
+-------------------------
+Remove
+-------------------------
+*/
+
+int CTaskManager::Remove( CTask *task, CIcarus* icarus )
+{
+	CBlock	*block = task->GetBlock();
+	char	*sVal;
+	int		memberNum = 0;
+
+	ICARUS_VALIDATE( Get( m_ownerID, block, memberNum, &sVal, icarus ) );
+	
+	icarus->GetGame()->DebugPrint(IGameInterface::WL_DEBUG, "%4d remove(\"%s\"); [%d]", m_ownerID, sVal, task->GetTimeStamp() );
+	icarus->GetGame()->Remove( m_ownerID, sVal );
+
+	Completed( task->GetGUID() );
+	
+	return TASK_OK;
+}
+
+/*
+-------------------------
+Camera
+-------------------------
+*/
+
+int CTaskManager::Camera( CTask *task , CIcarus* icarus)
+{
+	CBlock		*block = task->GetBlock();
+	vec3_t		vector, vector2;
+	float		type, fVal, fVal2, fVal3;
+	char		*sVal;
+	int			memberNum = 0;
+
+	//Get the camera function type
+	ICARUS_VALIDATE( GetFloat( m_ownerID, block, memberNum, type, icarus ) );
+
+	switch ( (int) type )
+	{
+	case CIcarus::TYPE_PAN:
+		
+		ICARUS_VALIDATE( GetVector( m_ownerID, block, memberNum, vector, icarus ) );
+		ICARUS_VALIDATE( GetVector( m_ownerID, block, memberNum, vector2, icarus ) );
+
+		ICARUS_VALIDATE( GetFloat( m_ownerID, block, memberNum, fVal, icarus ) );
+
+		icarus->GetGame()->DebugPrint(IGameInterface::WL_DEBUG, "%4d camera( PAN, <%f %f %f>, <%f %f %f>, %f); [%d]", m_ownerID, vector[0], vector[1], vector[2], vector2[0], vector2[1], vector2[2], fVal, task->GetTimeStamp() );
+		icarus->GetGame()->CameraPan( vector, vector2, fVal );
+		break;
+
+	case CIcarus::TYPE_ZOOM:
+		
+		ICARUS_VALIDATE( GetFloat( m_ownerID, block, memberNum, fVal, icarus ) );
+		ICARUS_VALIDATE( GetFloat( m_ownerID, block, memberNum, fVal2, icarus ) );
+
+		icarus->GetGame()->DebugPrint(IGameInterface::WL_DEBUG, "%4d camera( ZOOM, %f, %f); [%d]", m_ownerID, fVal, fVal2, task->GetTimeStamp() );
+		icarus->GetGame()->CameraZoom( fVal, fVal2 );
+		break;
+
+	case CIcarus::TYPE_MOVE:
+
+		ICARUS_VALIDATE( GetVector( m_ownerID, block, memberNum, vector, icarus ) );
+		ICARUS_VALIDATE( GetFloat( m_ownerID, block, memberNum, fVal, icarus ) );
+
+		icarus->GetGame()->DebugPrint(IGameInterface::WL_DEBUG, "%4d camera( MOVE, <%f %f %f>, %f); [%d]", m_ownerID, vector[0], vector[1], vector[2], fVal, task->GetTimeStamp() );
+		icarus->GetGame()->CameraMove( vector, fVal );
+		break;
+
+	case CIcarus::TYPE_ROLL:
+
+		ICARUS_VALIDATE( GetFloat( m_ownerID, block, memberNum, fVal, icarus ) );
+		ICARUS_VALIDATE( GetFloat( m_ownerID, block, memberNum, fVal2, icarus ) );
+
+		icarus->GetGame()->DebugPrint(IGameInterface::WL_DEBUG, "%4d camera( ROLL, %f, %f); [%d]", m_ownerID, fVal, fVal2, task->GetTimeStamp() );
+		icarus->GetGame()->CameraRoll( fVal, fVal2 );
+
+		break;
+
+	case CIcarus::TYPE_FOLLOW:
+
+		ICARUS_VALIDATE( Get( m_ownerID, block, memberNum, &sVal, icarus ) );
+		ICARUS_VALIDATE( GetFloat( m_ownerID, block, memberNum, fVal, icarus ) );
+		ICARUS_VALIDATE( GetFloat( m_ownerID, block, memberNum, fVal2, icarus ) );
+
+		icarus->GetGame()->DebugPrint(IGameInterface::WL_DEBUG, "%4d camera( FOLLOW, \"%s\", %f, %f); [%d]", m_ownerID, sVal, fVal, fVal2, task->GetTimeStamp() );
+		icarus->GetGame()->CameraFollow( (const char *) sVal, fVal, fVal2 );
+
+		break;
+
+	case CIcarus::TYPE_TRACK:
+		
+		ICARUS_VALIDATE( Get( m_ownerID, block, memberNum, &sVal, icarus ) );
+		ICARUS_VALIDATE( GetFloat( m_ownerID, block, memberNum, fVal, icarus ) );
+		ICARUS_VALIDATE( GetFloat( m_ownerID, block, memberNum, fVal2, icarus ) );
+
+		icarus->GetGame()->DebugPrint(IGameInterface::WL_DEBUG, "%4d camera( TRACK, \"%s\", %f, %f); [%d]", m_ownerID, sVal, fVal, fVal2, task->GetTimeStamp() );
+		icarus->GetGame()->CameraTrack( (const char *) sVal, fVal, fVal2 );
+		break;
+
+	case CIcarus::TYPE_DISTANCE:
+
+		ICARUS_VALIDATE( GetFloat( m_ownerID, block, memberNum, fVal, icarus ) );
+		ICARUS_VALIDATE( GetFloat( m_ownerID, block, memberNum, fVal2, icarus ) );
+		
+		icarus->GetGame()->DebugPrint(IGameInterface::WL_DEBUG, "%4d camera( DISTANCE, %f, %f); [%d]", m_ownerID, fVal, fVal2, task->GetTimeStamp() );
+		icarus->GetGame()->CameraDistance( fVal, fVal2 );
+		break;
+
+	case CIcarus::TYPE_FADE:
+
+		ICARUS_VALIDATE( GetVector( m_ownerID, block, memberNum, vector, icarus ) );
+		ICARUS_VALIDATE( GetFloat( m_ownerID, block, memberNum, fVal, icarus ) );
+
+		ICARUS_VALIDATE( GetVector( m_ownerID, block, memberNum, vector2, icarus ) );
+		ICARUS_VALIDATE( GetFloat( m_ownerID, block, memberNum, fVal2, icarus ) );
+		
+		ICARUS_VALIDATE( GetFloat( m_ownerID, block, memberNum, fVal3, icarus ) );
+
+		icarus->GetGame()->DebugPrint(IGameInterface::WL_DEBUG, "%4d camera( FADE, <%f %f %f>, %f, <%f %f %f>, %f, %f); [%d]", m_ownerID, vector[0], vector[1], vector[2], fVal, vector2[0], vector2[1], vector2[2], fVal2, fVal3, task->GetTimeStamp() );
+		icarus->GetGame()->CameraFade( vector[0], vector[1], vector[2], fVal, vector2[0], vector2[1], vector2[2], fVal2, fVal3 );
+		break;
+
+	case CIcarus::TYPE_PATH:
+		ICARUS_VALIDATE( Get( m_ownerID, block, memberNum, &sVal, icarus ) );
+
+		icarus->GetGame()->DebugPrint(IGameInterface::WL_DEBUG, "%4d camera( PATH, \"%s\"); [%d]", m_ownerID, sVal, task->GetTimeStamp() );
+		icarus->GetGame()->CameraPath( sVal );
+		break;
+
+	case CIcarus::TYPE_ENABLE:
+		icarus->GetGame()->DebugPrint(IGameInterface::WL_DEBUG, "%4d camera( ENABLE ); [%d]", m_ownerID, task->GetTimeStamp() );
+		icarus->GetGame()->CameraEnable();
+		break;
+
+	case CIcarus::TYPE_DISABLE:
+		icarus->GetGame()->DebugPrint(IGameInterface::WL_DEBUG, "%4d camera( DISABLE ); [%d]", m_ownerID, task->GetTimeStamp() );
+		icarus->GetGame()->CameraDisable();
+		break;
+	
+	case CIcarus::TYPE_SHAKE:
+		ICARUS_VALIDATE( GetFloat( m_ownerID, block, memberNum, fVal, icarus ) );
+		ICARUS_VALIDATE( GetFloat( m_ownerID, block, memberNum, fVal2, icarus ) );
+
+		icarus->GetGame()->DebugPrint(IGameInterface::WL_DEBUG, "%4d camera( SHAKE, %f, %f ); [%d]", m_ownerID, fVal, fVal2, task->GetTimeStamp() );
+		icarus->GetGame()->CameraShake( fVal, (int) fVal2 );
+		break;
+	}
+
+	Completed( task->GetGUID() );
+
+	return TASK_OK;
+}
+
+/*
+-------------------------
+Move
+-------------------------
+*/
+
+int CTaskManager::Move( CTask *task, CIcarus* icarus )
+{
+	vec3_t		vector, vector2;
+	CBlock		*block = task->GetBlock();
+	float		duration;
+	int			memberNum = 0;
+
+	//Get the goal position
+	ICARUS_VALIDATE( GetVector( m_ownerID, block, memberNum, vector, icarus ) );
+
+	//Check for possible angles field
+	if ( GetVector( m_ownerID, block, memberNum, vector2, icarus ) == false )
+	{
+		ICARUS_VALIDATE( GetFloat( m_ownerID, block, memberNum, duration, icarus ) );
+		
+		
+		icarus->GetGame()->DebugPrint(IGameInterface::WL_DEBUG, "%4d move( <%f %f %f>, %f ); [%d]", m_ownerID, vector[0], vector[1], vector[2], duration, task->GetTimeStamp() );
+		icarus->GetGame()->Lerp2Pos( task->GetGUID(), m_ownerID, vector, NULL, duration );
+
+		return TASK_OK;
+	}
+
+	//Get the duration and make the call
+	ICARUS_VALIDATE( GetFloat( m_ownerID, block, memberNum, duration, icarus ) );
+	
+	icarus->GetGame()->DebugPrint(IGameInterface::WL_DEBUG, "%4d move( <%f %f %f>, <%f %f %f>, %f ); [%d]", m_ownerID, vector[0], vector[1], vector[2], vector2[0], vector2[1], vector2[2], duration, task->GetTimeStamp() );
+	icarus->GetGame()->Lerp2Pos( task->GetGUID(), m_ownerID, vector, vector2, duration );
+	
+	return TASK_OK;
+}
+
+/*
+-------------------------
+Kill
+-------------------------
+*/
+
+int CTaskManager::Kill( CTask *task, CIcarus* icarus )
+{
+	CBlock	*block = task->GetBlock();
+	char	*sVal;
+	int		memberNum = 0;
+
+	ICARUS_VALIDATE( Get( m_ownerID, block, memberNum, &sVal, icarus ) );
+
+	icarus->GetGame()->DebugPrint(IGameInterface::WL_DEBUG, "%4d kill( \"%s\" ); [%d]", m_ownerID, sVal, task->GetTimeStamp() );
+	icarus->GetGame()->Kill( m_ownerID, sVal );
+
+	Completed( task->GetGUID() );
+
+	return TASK_OK;
+}
+
+/*
+-------------------------
+Set
+-------------------------
+*/
+
+int CTaskManager::Set( CTask *task, CIcarus* icarus )
+{
+	CBlock			*block = task->GetBlock();
+	char			*sVal, *sVal2;
+	int				memberNum = 0;
+
+	ICARUS_VALIDATE( Get( m_ownerID, block, memberNum, &sVal, icarus ) );
+	ICARUS_VALIDATE( Get( m_ownerID, block, memberNum, &sVal2, icarus ) );
+
+	icarus->GetGame()->DebugPrint(IGameInterface::WL_DEBUG, "%4d set( \"%s\", \"%s\" ); [%d]", m_ownerID, sVal, sVal2, task->GetTimeStamp() );
+	icarus->GetGame()->Set( task->GetGUID(), m_ownerID, sVal, sVal2 );
+
+	return TASK_OK;
+}
+
+/*
+-------------------------
+Use
+-------------------------
+*/
+
+int CTaskManager::Use( CTask *task , CIcarus* icarus)
+{
+	CBlock	*block = task->GetBlock();
+	char	*sVal;
+	int		memberNum = 0;
+
+	ICARUS_VALIDATE( Get( m_ownerID, block, memberNum, &sVal, icarus ) );
+
+	icarus->GetGame()->DebugPrint(IGameInterface::WL_DEBUG, "%4d use( \"%s\" ); [%d]", m_ownerID, sVal, task->GetTimeStamp() );
+	icarus->GetGame()->Use( m_ownerID, sVal );
+
+	Completed( task->GetGUID() );
+
+	return TASK_OK;
+}
+
+/*
+-------------------------
+DeclareVariable
+-------------------------
+*/
+
+int CTaskManager::DeclareVariable( CTask *task , CIcarus* icarus)
+{
+	CBlock	*block = task->GetBlock();
+	char	*sVal;
+	int		memberNum = 0;
+	float	fVal;
+
+	ICARUS_VALIDATE( GetFloat( m_ownerID, block, memberNum, fVal, icarus ) );
+	ICARUS_VALIDATE( Get( m_ownerID, block, memberNum, &sVal, icarus ) );
+
+	icarus->GetGame()->DebugPrint(IGameInterface::WL_DEBUG, "%4d declare( %d, \"%s\" ); [%d]", m_ownerID, (int) fVal, sVal, task->GetTimeStamp() );
+	icarus->GetGame()->DeclareVariable( (int) fVal, sVal );
+
+	Completed( task->GetGUID() );
+
+	return TASK_OK;
+
+}
+
+/*
+-------------------------
+FreeVariable
+-------------------------
+*/
+
+int CTaskManager::FreeVariable( CTask *task, CIcarus* icarus )
+{
+	CBlock	*block = task->GetBlock();
+	char	*sVal;
+	int		memberNum = 0;
+
+	ICARUS_VALIDATE( Get( m_ownerID, block, memberNum, &sVal, icarus ) );
+
+	icarus->GetGame()->DebugPrint(IGameInterface::WL_DEBUG, "%4d free( \"%s\" ); [%d]", m_ownerID, sVal, task->GetTimeStamp() );
+	icarus->GetGame()->FreeVariable( sVal );
+
+	Completed( task->GetGUID() );
+
+	return TASK_OK;
+
+}
+
+/*
+-------------------------
+Signal
+-------------------------
+*/
+
+int CTaskManager::Signal( CTask *task, CIcarus* icarus )
+{
+	CBlock	*block = task->GetBlock();
+	char	*sVal;
+	int		memberNum = 0;
+
+	ICARUS_VALIDATE( Get( m_ownerID, block, memberNum, &sVal, icarus ) );
+
+	icarus->GetGame()->DebugPrint(IGameInterface::WL_DEBUG, "%4d signal( \"%s\" ); [%d]", m_ownerID, sVal, task->GetTimeStamp() );
+	icarus->Signal( (const char *) sVal );
+
+	Completed( task->GetGUID() );
+
+	return TASK_OK;
+}
+
+/*
+-------------------------
+Play
+-------------------------
+*/
+
+int CTaskManager::Play( CTask *task, CIcarus* icarus )
+{
+	CBlock	*block = task->GetBlock();
+	char	*sVal, *sVal2;
+	int		memberNum = 0;
+
+	ICARUS_VALIDATE( Get( m_ownerID, block, memberNum, &sVal, icarus ) );
+	ICARUS_VALIDATE( Get( m_ownerID, block, memberNum, &sVal2, icarus ) );
+
+	icarus->GetGame()->DebugPrint(IGameInterface::WL_DEBUG, "%4d play( \"%s\", \"%s\" ); [%d]", m_ownerID, sVal, sVal2, task->GetTimeStamp() );
+	icarus->GetGame()->Play( task->GetGUID(), m_ownerID, (const char *) sVal, (const char *) sVal2 );
+
+	return TASK_OK;
+}
+
+/*
+-------------------------
+SaveCommand
+-------------------------
+*/
+
+//FIXME: ARGH!  This is duplicated from CSequence because I can't directly link it any other way...
+
+int CTaskManager::SaveCommand( CBlock *block )
+{
+	CIcarus *pIcarus = (CIcarus *)IIcarusInterface::GetIcarus();
+
+	unsigned char	flags;
+	int				numMembers, bID, size;
+	CBlockMember	*bm;
+	
+	//Save out the block ID
+	bID = block->GetBlockID();
+	pIcarus->BufferWrite( &bID, sizeof( bID ) );
+
+	//Save out the block's flags
+	flags = block->GetFlags();
+	pIcarus->BufferWrite( &flags, sizeof( flags ) );
+
+	//Save out the number of members to read
+	numMembers = block->GetNumMembers();
+	pIcarus->BufferWrite( &numMembers, sizeof( numMembers ) );
+
+	for ( int i = 0; i < numMembers; i++ )
+	{
+		bm = block->GetMember( i );
+
+		//Save the block id
+		bID = bm->GetID();
+		pIcarus->BufferWrite( &bID, sizeof( bID ) );
+		
+		//Save out the data size
+		size = bm->GetSize();
+		pIcarus->BufferWrite( &size, sizeof( size ) );
+		
+		//Save out the raw data
+		pIcarus->BufferWrite( bm->GetData(), size );
+	}
+
+	return true;
+}
+
+/*
+-------------------------
+Save
+-------------------------
+*/
+
+void CTaskManager::Save()
+{
+	CTaskGroup	*taskGroup;
+	const char	*name;
+	CBlock		*block;
+	DWORD		timeStamp;
+	bool		completed;
+	int			id, numCommands;
+	int			numWritten;
+
+	// Data saved here.
+	//	Taskmanager GUID.
+	//	Number of Tasks.
+	//	Tasks:
+	//				- GUID.
+	//				- Timestamp.
+	//				- Block/Command.
+	//	Number of task groups.
+	//	Task groups ID's.
+	//	Task groups (data).
+	//				- Parent.
+	//				- Number of Commands.
+	//				- Commands:
+	//						+ ID.
+	//						+ State of Completion.
+	//				- Number of Completed Commands.
+	//	Currently active group.
+	//	Task group names:
+	//				- String Size.
+	//				- String.
+	//				- ID.
+
+	CIcarus *pIcarus = (CIcarus *)IIcarusInterface::GetIcarus();
+
+	//Save the taskmanager's GUID
+	pIcarus->BufferWrite( &m_GUID, sizeof( m_GUID ) );
+
+	//Save out the number of tasks that will follow
+	int iNumTasks = m_tasks.size();
+	pIcarus->BufferWrite( &iNumTasks, sizeof( iNumTasks ) );
+
+	//Save out all the tasks
+	tasks_l::iterator	ti;
+	
+	STL_ITERATE( ti, m_tasks )
+	{
+		//Save the GUID
+		id = (*ti)->GetGUID();
+		pIcarus->BufferWrite( &id, sizeof( id ) );
+
+		//Save the timeStamp (FIXME: Although, this is going to be worthless if time is not consistent...)
+		timeStamp = (*ti)->GetTimeStamp();
+		pIcarus->BufferWrite( &timeStamp, sizeof( timeStamp ) );
+
+		//Save out the block
+		block = (*ti)->GetBlock();
+		SaveCommand( block );
+	}
+
+	//Save out the number of task groups
+	int numTaskGroups = m_taskGroups.size();
+	pIcarus->BufferWrite( &numTaskGroups, sizeof( numTaskGroups ) );
+
+	//Save out the IDs of all the task groups
+	numWritten = 0;
+	taskGroup_v::iterator	tgi;
+	STL_ITERATE( tgi, m_taskGroups )
+	{
+		id = (*tgi)->GetGUID();
+		pIcarus->BufferWrite( &id, sizeof( id ) );
+		numWritten++;
+	}
+	assert (numWritten == numTaskGroups);
+
+	//Save out the task groups
+	numWritten = 0;
+	STL_ITERATE( tgi, m_taskGroups )
+	{
+		//Save out the parent
+		id = ( (*tgi)->GetParent() == NULL ) ? -1 : ((*tgi)->GetParent())->GetGUID();
+		pIcarus->BufferWrite( &id, sizeof( id ) );
+
+		//Save out the number of commands
+		numCommands = (*tgi)->m_completedTasks.size();
+		pIcarus->BufferWrite( &numCommands, sizeof( numCommands ) );
+
+		//Save out the command map
+		CTaskGroup::taskCallback_m::iterator	tci;
+		
+		STL_ITERATE( tci, (*tgi)->m_completedTasks )
+		{
+			//Write out the ID
+			id = (*tci).first;
+			pIcarus->BufferWrite( &id, sizeof( id ) );
+
+			//Write out the state of completion
+			completed = (*tci).second;
+			pIcarus->BufferWrite( &completed, sizeof( completed ) );
+		}
+
+		//Save out the number of completed commands
+		id = (*tgi)->m_numCompleted;
+		pIcarus->BufferWrite( &id, sizeof( id ) );
+		numWritten++;
+	}
+	assert (numWritten == numTaskGroups);
+
+	//Only bother if we've got tasks present
+	if ( m_taskGroups.size() )
+	{
+		//Save out the currently active group
+		int	curGroupID = ( m_curGroup == NULL ) ? -1 : m_curGroup->GetGUID();
+		pIcarus->BufferWrite( &curGroupID, sizeof( curGroupID ) );
+	}
+
+	//Save out the task group name maps
+	taskGroupName_m::iterator	tmi;
+	numWritten = 0;
+	STL_ITERATE( tmi, m_taskGroupNameMap )
+	{
+		name = ((*tmi).first).c_str();
+		
+		//Make sure this is a valid string
+		assert( ( name != NULL ) && ( name[0] != NULL ) );
+
+		int length = strlen( name ) + 1;
+
+		//Save out the string size
+		//icarus->GetGame()->WriteSaveData( 'TGNL', &length, sizeof ( length ) );
+		pIcarus->BufferWrite( &length, sizeof( length ) );
+
+		//Write out the string
+		pIcarus->BufferWrite( (void *) name, length );
+
+		taskGroup = (*tmi).second;
+
+		id = taskGroup->GetGUID();
+
+		//Write out the ID
+		pIcarus->BufferWrite( &id, sizeof( id ) );
+		numWritten++;
+	}
+	assert (numWritten == numTaskGroups);
+}
+
+/*
+-------------------------
+Load
+-------------------------
+*/
+
+void CTaskManager::Load( CIcarus* icarus )
+{
+	unsigned char	flags;
+	CTaskGroup		*taskGroup;
+	CBlock			*block;
+	CTask			*task;
+	DWORD			timeStamp;
+	bool			completed;
+	void			*bData;
+	int				id, numTasks, numMembers;
+	int				bID, bSize;
+
+	// Data expected/loaded here.
+	//	Taskmanager GUID.
+	//	Number of Tasks.
+	//	Tasks:
+	//				- GUID.
+	//				- Timestamp.
+	//				- Block/Command.
+	//	Number of task groups.
+	//	Task groups ID's.
+	//	Task groups (data).
+	//				- Parent.
+	//				- Number of Commands.
+	//				- Commands:
+	//						+ ID.
+	//						+ State of Completion.
+	//				- Number of Completed Commands.
+	//	Currently active group.
+	//	Task group names:
+	//				- String Size.
+	//				- String.
+	//				- ID.
+
+	CIcarus *pIcarus = (CIcarus *)IIcarusInterface::GetIcarus();
+
+	//Get the GUID
+	pIcarus->BufferRead( &m_GUID, sizeof( m_GUID ) );
+
+	//Get the number of tasks to follow
+	pIcarus->BufferRead( &numTasks, sizeof( numTasks ) );
+	
+	//Reload all the tasks
+	for ( int i = 0; i < numTasks; i++ )
+	{
+		task = new CTask;
+
+		assert( task );
+
+		//Get the GUID
+		pIcarus->BufferRead( &id, sizeof( id ) );
+		task->SetGUID( id );
+
+		//Get the time stamp
+		pIcarus->BufferRead( &timeStamp, sizeof( timeStamp ) );
+		task->SetTimeStamp( timeStamp );
+
+		//
+		// BLOCK LOADING
+		//
+
+		//Get the block ID and create a new container
+		pIcarus->BufferRead( &id, sizeof( id ) );
+		block = new CBlock;
+		
+		block->Create( id );
+		
+		//Read the block's flags
+		pIcarus->BufferRead( &flags, sizeof( flags ) );
+		block->SetFlags( flags );
+
+		//Get the number of block members
+		pIcarus->BufferRead( &numMembers, sizeof( numMembers ) );
+		
+		for ( int j = 0; j < numMembers; j++ )
+		{
+			//Get the member ID
+			pIcarus->BufferRead( &bID, sizeof( bID ) );
+			
+			//Get the member size
+			pIcarus->BufferRead( &bSize, sizeof( bSize ) );
+
+			//Get the member's data
+			if ( ( bData = icarus->GetGame()->Malloc( bSize ) ) == NULL )
+			{
+				assert( 0 );
+				return;
+			}
+
+			//Get the actual raw data
+			pIcarus->BufferRead( bData, bSize );
+
+			//Write out the correct type
+			switch ( bID )
+			{
+			case CIcarus::TK_FLOAT:
+				block->Write( CIcarus::TK_FLOAT, *(float *) bData, icarus );
+				break;
+
+			case CIcarus::TK_IDENTIFIER:
+				block->Write( CIcarus::TK_IDENTIFIER, (char *) bData , icarus);
+				break;
+
+			case CIcarus::TK_STRING:
+				block->Write( CIcarus::TK_STRING, (char *) bData , icarus);
+				break;
+
+			case CIcarus::TK_VECTOR:
+				block->Write( CIcarus::TK_VECTOR, *(vec3_t *) bData, icarus );
+				break;
+
+			case CIcarus::ID_RANDOM:
+				block->Write( CIcarus::ID_RANDOM, *(float *) bData, icarus );//ID_RANDOM );
+				break;
+
+			case CIcarus::ID_TAG:
+				block->Write( CIcarus::ID_TAG, (float) CIcarus::ID_TAG , icarus);
+				break;
+
+			case CIcarus::ID_GET:
+				block->Write( CIcarus::ID_GET, (float) CIcarus::ID_GET , icarus);
+				break;
+
+			default:
+				icarus->GetGame()->DebugPrint(IGameInterface::WL_ERROR, "Invalid Block id %d\n", bID);
+				assert( 0 );
+				break;
+			}
+			
+			//Get rid of the temp memory
+			icarus->GetGame()->Free( bData );
+		}
+		
+		task->SetBlock( block );
+
+		STL_INSERT( m_tasks, task );
+	}
+
+	//Load the task groups
+	int numTaskGroups;
+	
+	//icarus->GetGame()->ReadSaveData( 'TG#G', &numTaskGroups, sizeof( numTaskGroups ) );
+	pIcarus->BufferRead( &numTaskGroups, sizeof( numTaskGroups ) );
+
+	if ( numTaskGroups == 0 )
+		return;
+
+	int *taskIDs = new int[ numTaskGroups ];
+
+	//Get the task group IDs
+	for ( i = 0; i < numTaskGroups; i++ )
+	{
+		//Creat a new task group
+		taskGroup = new CTaskGroup;
+		assert( taskGroup );
+
+		//Get this task group's ID
+		pIcarus->BufferRead( &taskIDs[i], sizeof( taskIDs[i] ) );
+		taskGroup->m_GUID = taskIDs[i];
+		
+		m_taskGroupIDMap[ taskIDs[i] ] = taskGroup;
+
+		STL_INSERT( m_taskGroups, taskGroup );
+	}
+
+	//Recreate and load the task groups
+	for ( i = 0; i < numTaskGroups; i++ )
+	{
+		taskGroup = GetTaskGroup( taskIDs[i], icarus );
+		assert( taskGroup );
+
+		//Load the parent ID
+		pIcarus->BufferRead( &id, sizeof( id ) );
+		
+		if ( id != -1 )
+			taskGroup->m_parent = ( GetTaskGroup( id, icarus ) != NULL ) ? GetTaskGroup( id, icarus ) : NULL;
+
+		//Get the number of commands in this group
+		pIcarus->BufferRead( &numMembers, sizeof( numMembers ) );
+
+		//Get each command and its completion state
+		for ( int j = 0; j < numMembers; j++ )
+		{
+			//Get the ID
+			pIcarus->BufferRead( &id, sizeof( id ) );
+
+			//Write out the state of completion
+			pIcarus->BufferRead( &completed, sizeof( completed ) );
+
+			//Save it out
+			taskGroup->m_completedTasks[ id ] = completed;
+		}
+
+		//Get the number of completed tasks
+		pIcarus->BufferRead( &taskGroup->m_numCompleted, sizeof( taskGroup->m_numCompleted ) );
+	}
+
+	//Reload the currently active group
+	int curGroupID;
+
+	pIcarus->BufferRead( &curGroupID, sizeof( curGroupID ) );
+
+	//Reload the map entries
+	for ( i = 0; i < numTaskGroups; i++ )
+	{
+		char	name[1024];
+		int		length;
+		
+		//Get the size of the string
+		pIcarus->BufferRead( &length, sizeof( length ) );
+
+		//Get the string
+		pIcarus->BufferRead( &name, length );
+
+		//Get the id
+		pIcarus->BufferRead( &id, sizeof( id ) );
+
+		taskGroup = GetTaskGroup( id, icarus );
+		assert( taskGroup );
+
+		m_taskGroupNameMap[ name ] = taskGroup;
+		m_taskGroupIDMap[ taskGroup->GetGUID() ] = taskGroup;
+	}
+
+	m_curGroup = ( curGroupID == -1 ) ? NULL : m_taskGroupIDMap[curGroupID];
+
+	delete[] taskIDs;
+}
diff --git a/code/icarus/blockstream.h b/code/icarus/blockstream.h
new file mode 100644
index 0000000..66a49fb
--- /dev/null
+++ b/code/icarus/blockstream.h
@@ -0,0 +1,213 @@
+// BlockStream.h
+
+#ifndef __INTERPRETED_BLOCK_STREAM__
+#define	__INTERPRETED_BLOCK_STREAM__
+
+#include <assert.h>
+
+typedef float vec3_t[3];
+
+
+// Templates
+
+// CBlockMember
+
+class CBlockMember
+{
+public:
+	CBlockMember();	
+
+protected:
+	~CBlockMember();
+
+public:
+	void Free(IGameInterface* game);
+
+	int WriteMember ( FILE * );				//Writes the member's data, in block format, to FILE *
+	int	ReadMember( char **, long *, CIcarus* icarus );		//Reads the member's data, in block format, from FILE *
+
+	void SetID( int id )		{	m_id = id;		}	//Set the ID member variable
+	void SetSize( int size )	{	m_size = size;	}	//Set the size member variable
+
+	void GetInfo( int *, int *, void **);
+
+	//SetData overloads
+	void SetData( const char * ,CIcarus* icarus);
+	void SetData( vec3_t , CIcarus* icarus);
+	void SetData( void *data, int size, CIcarus* icarus);
+
+	int	GetID( void )		const	{	return m_id;	}	//Get ID member variables
+	void *GetData( void )	const	{	return m_data;	}	//Get data member variable
+	int	GetSize( void )		const	{	return m_size;	}	//Get size member variable
+
+	// Overloaded new operator.
+	inline void *operator new( size_t size )
+	{	// Allocate the memory.
+		return IGameInterface::GetGame()->Malloc( size );
+	}
+
+	// Overloaded delete operator.
+	inline void operator delete( void *pRawData )
+	{	// Free the Memory.
+		IGameInterface::GetGame()->Free( pRawData );
+	}
+
+	CBlockMember *Duplicate( CIcarus* icarus );
+
+	template <class T> void WriteData(T &data, CIcarus* icarus)
+	{
+		IGameInterface* game = icarus->GetGame();
+		if ( m_data )
+		{
+			game->Free( m_data );
+		}
+
+		m_data = game->Malloc( sizeof(T) );
+		*((T *) m_data) = data;
+		m_size = sizeof(T);
+	}
+
+	template <class T> void WriteDataPointer(const T *data, int num, CIcarus* icarus)
+	{
+		IGameInterface* game =icarus->GetGame();
+		if ( m_data )
+		{
+			game->Free( m_data );
+		}
+
+		m_data = game->Malloc( num*sizeof(T) );
+		memcpy( m_data, data, num*sizeof(T) );
+		m_size = num*sizeof(T);
+	}
+
+protected:
+
+	int		m_id;		//ID of the value contained in data
+	int		m_size;		//Size of the data member variable
+	void	*m_data;	//Data for this member
+
+};
+	
+//CBlock
+
+class CBlock
+{
+	typedef vector< CBlockMember * >	blockMember_v;
+
+public:
+
+	CBlock()
+	{
+		m_flags			= 0;
+		m_id			= 0;
+	}
+	~CBlock() {	assert(!GetNumMembers()); }
+
+	int Init( void );
+
+	int Create( int );
+	int Free(CIcarus* icarus);
+
+	//Write Overloads
+
+	int Write( int, vec3_t, CIcarus* icaru );
+	int Write( int, float, CIcarus* icaru );
+	int Write( int, const char *, CIcarus* icaru );
+	int Write( int, int, CIcarus* icaru );
+	int Write( CBlockMember *, CIcarus* icaru );
+
+	//Member push / pop functions
+
+	int AddMember( CBlockMember * );
+	CBlockMember *GetMember( int memberNum );
+
+	void	*GetMemberData( int memberNum );
+
+	CBlock *Duplicate( CIcarus* icarus );
+
+	int	GetBlockID( void )		const	{	return m_id;			}	//Get the ID for the block
+	int	GetNumMembers( void )	const	{	return m_members.size();}	//Get the number of member in the block's list
+
+	void SetFlags( unsigned char flags )	{	m_flags = flags;	}
+	void SetFlag( unsigned char flag )		{	m_flags |= flag;	}
+	
+	int HasFlag( unsigned char flag )	const	{	return ( m_flags & flag );	}
+	unsigned char GetFlags( void )		const	{	return m_flags;				}
+
+	// Overloaded new operator.
+	inline void *operator new( size_t size )
+	{	// Allocate the memory.
+		return IGameInterface::GetGame()->Malloc( size );
+	}
+
+	// Overloaded delete operator.
+	inline void operator delete( void *pRawData )
+	{	// Validate data.
+		if ( pRawData == 0 )
+			return;
+
+		// Free the Memory.
+		IGameInterface::GetGame()->Free( pRawData );
+	}
+
+
+protected:
+
+	blockMember_v				m_members;			//List of all CBlockMembers owned by this list
+	int							m_id;				//ID of the block
+	unsigned char				m_flags;
+};
+
+// CBlockStream
+
+class CBlockStream
+{
+public:
+
+	CBlockStream()
+	{
+		m_stream = NULL;
+		m_streamPos = 0;
+	}
+	~CBlockStream() {};
+
+	int Init( void );
+
+	int Create( char * );
+	int Free( void );
+
+	// Stream I/O functions
+
+	int BlockAvailable( void );
+
+	int WriteBlock( CBlock *, CIcarus* icarus );	//Write the block out
+	int ReadBlock( CBlock *, CIcarus* icarus );	//Read the block in
+	
+	int Open( char *, long );	//Open a stream for reading / writing
+
+	// Overloaded new operator.
+	static void *operator new( size_t size )
+	{	// Allocate the memory.
+		return IGameInterface::GetGame()->Malloc( size );
+	}
+
+	// Overloaded delete operator.
+	static void operator delete( void *pRawData )
+	{	// Free the Memory.
+		IGameInterface::GetGame()->Free( pRawData );
+	}
+
+protected:
+	long	m_fileSize;							//Size of the file	
+	FILE	*m_fileHandle;						//Global file handle of current I/O source
+	char	m_fileName[CIcarus::MAX_FILENAME_LENGTH];	//Name of the current file
+
+	char	*m_stream;							//Stream of data to be parsed
+	long	m_streamPos;
+
+	static char*			s_IBI_EXT;
+	static char*			s_IBI_HEADER_ID;
+	static const float		s_IBI_VERSION;
+};
+
+#endif	//__INTERPRETED_BLOCK_STREAM__
\ No newline at end of file
diff --git a/code/icarus/sequence.h b/code/icarus/sequence.h
new file mode 100644
index 0000000..b287902
--- /dev/null
+++ b/code/icarus/sequence.h
@@ -0,0 +1,115 @@
+// Sequence Header File
+
+#ifndef __SEQUENCE__
+#define __SEQUENCE__
+
+class CSequence
+{
+
+	typedef list < CSequence * >	sequence_l;
+//	typedef	map	< int, CSequence *> sequenceID_m;
+	typedef list < CBlock * >		block_l;
+
+public:
+
+	//Constructors / Destructors
+	CSequence( void );
+	~CSequence( void );
+
+	//Creation and deletion
+	static CSequence *Create( void );
+	void Delete( CIcarus* icarus );
+
+	//Organization functions
+	void AddChild( CSequence * );
+	void RemoveChild( CSequence * );
+
+	void SetParent( CSequence * );
+	CSequence *GetParent( void )	const	{	return m_parent;	}
+
+	//Block manipulation
+	CBlock *PopCommand( int );
+	int PushCommand( CBlock *, int );
+
+	//Flag utilties
+	void SetFlag( int );
+	void RemoveFlag( int, bool = false );
+	int  HasFlag( int );
+	int	 GetFlags( void )		const	{	return m_flags;		}
+	void SetFlags( int flags )	{	m_flags = flags;	}
+
+	//Various encapsulation utilities
+	int GetIterations( void )		const	{	return m_iterations;	}
+	void SetIterations( int it )	{	m_iterations = it;		}
+
+	int GetID( void )		const	{	return m_id;			}
+	void SetID( int id )	{	m_id = id;				}
+
+	CSequence *GetReturn( void )	const	{	return m_return;		}
+
+	void SetReturn ( CSequence *sequence );
+
+	int GetNumCommands( void )	const	{	return m_numCommands;	}
+	int GetNumChildren( void )	const	{	return m_children.size();	}
+
+	CSequence *GetChildByID( int id );
+	CSequence *GetChildByIndex( int iIndex );
+	bool HasChild( CSequence *sequence );
+
+	int Save();
+	int Load( CIcarus* icarus );
+
+	// Overloaded new operator.
+	inline void *operator new( size_t size )
+	{	// Allocate the memory.
+		return IGameInterface::GetGame()->Malloc( size );
+	}
+
+	// Overloaded delete operator.
+	inline void operator delete( void *pRawData )
+	{	// Free the Memory.
+		IGameInterface::GetGame()->Free( pRawData );
+	}
+
+	enum
+	{
+		SQ_COMMON		= 0x00000000, 	//Common one-pass sequence
+		SQ_LOOP			= 0x00000001, 	//Looping sequence
+		SQ_RETAIN		= 0x00000002, 	//Inside a looping sequence list, retain the information
+		SQ_AFFECT		= 0x00000004, 	//Affect sequence 
+		SQ_RUN			= 0x00000008,	//A run block
+		SQ_PENDING		= 0x00000010,	//Pending use, don't free when flushing the sequences
+		SQ_CONDITIONAL	= 0x00000020,	//Conditional statement
+		SQ_TASK			= 0x00000040,	//Task block
+	};
+
+	enum 
+	{
+		POP_FRONT,
+		POP_BACK,
+		PUSH_FRONT,
+		PUSH_BACK
+	};
+
+protected:
+
+	int SaveCommand( CBlock *block );
+	int LoadCommand( CBlock *block, CIcarus *icarus );
+
+	//Organization information
+	sequence_l				m_children;
+	//sequenceID_m			m_childrenMap;
+
+	//int						m_numChildren;
+	CSequence				*m_parent;
+	CSequence				*m_return;
+
+	//Data information
+	block_l					m_commands;
+	int						m_flags;
+	int						m_iterations;
+	int						m_id;
+	int						m_numCommands;
+};
+
+#endif	//__SEQUENCE__
\ No newline at end of file
diff --git a/code/icarus/sequencer.h b/code/icarus/sequencer.h
new file mode 100644
index 0000000..1b7d269
--- /dev/null
+++ b/code/icarus/sequencer.h
@@ -0,0 +1,163 @@
+// Sequencer Header File
+
+#ifndef __SEQUENCER__
+#define __SEQUENCER__
+
+//Defines
+
+
+//const int MAX_ERROR_LENGTH	= 256;
+
+//Typedefs
+
+typedef struct bstream_s
+{
+	CBlockStream *stream;
+	bstream_s	 *last;
+} bstream_t;
+
+// Sequencer
+
+/*
+==================================================================================================
+
+  CSequencer
+
+==================================================================================================
+*/
+
+class CSequencer
+{
+	//typedef	map < int, CSequence * >			sequenceID_m;
+	typedef list < CSequence * >				sequence_l;
+	typedef map < CTaskGroup *, CSequence * >	taskSequence_m;
+
+public:
+	enum
+	{
+		BF_ELSE			= 0x00000001,	//Block has an else id	//FIXME: This was a sloppy fix for a problem that arose from conditionals
+	};
+
+	enum
+	{
+		SEQ_OK,				//Command was successfully added
+		SEQ_FAILED,			//An error occured while trying to insert the command
+	};
+
+	CSequencer();
+
+protected:
+	~CSequencer();
+
+public:
+	int GetID() { return m_id;};
+
+	int Init( int ownerID, CTaskManager *taskManager);
+	static CSequencer *Create ( void );
+	void Free( CIcarus* icarus );
+
+	int Run( char *buffer, long size, CIcarus* icarus);
+	int Callback( CTaskManager *taskManager, CBlock *block, int returnCode, CIcarus* icarus );
+
+	void SetOwnerID( int owner )	{	m_ownerID = owner;}
+
+	int	GetOwnerID( void )						const	{	return m_ownerID;	}
+
+	CTaskManager *GetTaskManager( void )		const	{	return m_taskManager;	}
+
+	void SetTaskManager( CTaskManager *tm)	{	if ( tm )	m_taskManager = tm;	}
+
+	int Save();
+	int Load( CIcarus* icarus, IGameInterface* game );
+
+	// Overloaded new operator.
+	inline void *operator new( size_t size )
+	{	// Allocate the memory.
+		return IGameInterface::GetGame()->Malloc( size );
+	}
+
+	// Overloaded delete operator.
+	inline void operator delete( void *pRawData )
+	{	// Free the Memory.
+		IGameInterface::GetGame()->Free( pRawData );
+	}
+
+// moved to public on 2/12/2 to allow calling during shutdown
+	int Recall( CIcarus* icarus );
+protected:
+
+	int EvaluateConditional( CBlock *block, CIcarus* icarus );
+
+	int Route( CSequence *sequence, bstream_t *bstream , CIcarus* icarus);
+	int Flush( CSequence *owner, CIcarus* icarus );
+	void Interrupt( void );
+
+	bstream_t *AddStream( void );
+	void DeleteStream( bstream_t *bstream );
+
+	int AddAffect( bstream_t *bstream, int retain, int *id, CIcarus* icarus );
+
+	CSequence *AddSequence( CIcarus* icarus );
+	CSequence *AddSequence( CSequence *parent, CSequence *returnSeq, int flags, CIcarus* icarus );
+
+	CSequence *GetSequence( int id );
+
+	//NOTENOTE: This only removes references to the sequence, IT DOES NOT FREE THE ALLOCATED MEMORY!
+	int RemoveSequence( CSequence *sequence, CIcarus* icarus);
+	int DestroySequence( CSequence *sequence, CIcarus* icarus);
+
+	int PushCommand( CBlock *command, int flag );
+	CBlock *PopCommand( int flag );
+
+	inline CSequence *ReturnSequence( CSequence *sequence );
+
+	void CheckRun( CBlock ** , CIcarus* icarus);
+	void CheckLoop( CBlock ** , CIcarus* icarus);
+	void CheckAffect( CBlock ** , CIcarus* icarus);
+	void CheckIf( CBlock ** , CIcarus* icarus);
+	void CheckDo( CBlock ** , CIcarus* icarus);
+	void CheckFlush( CBlock ** , CIcarus* icarus);
+
+	void Prep( CBlock ** , CIcarus* icarus);
+
+	int Prime( CTaskManager *taskManager, CBlock *command,  CIcarus* icarus);
+
+	void StripExtension( const char *in, char *out );
+
+	int ParseRun( CBlock *block , CIcarus* icarus);
+	int ParseLoop( CBlock *block, bstream_t *bstream , CIcarus* icarus);
+	int ParseAffect( CBlock *block, bstream_t *bstream, CIcarus* icarus );
+	int ParseIf( CBlock *block, bstream_t *bstream, CIcarus* icarus );
+	int ParseElse( CBlock *block, bstream_t *bstream, CIcarus* icarus );
+	int ParseTask( CBlock *block, bstream_t *bstream , CIcarus* icarus);
+
+	int Affect( int id, int type , CIcarus* icarus);
+
+	void AddTaskSequence( CSequence *sequence, CTaskGroup *group );
+	CSequence *GetTaskSequence( CTaskGroup *group );
+
+	//Member variables
+	
+	int					m_ownerID;
+
+	CTaskManager		*m_taskManager;
+
+	int					m_numCommands;		//Total number of commands for the sequencer (including all child sequences)
+
+	//sequenceID_m		m_sequenceMap;
+	sequence_l			m_sequences;
+	taskSequence_m		m_taskSequences;
+
+	CSequence			*m_curSequence;
+	CTaskGroup			*m_curGroup;
+
+	bstream_t			*m_curStream;
+
+	int					m_elseValid;
+	CBlock				*m_elseOwner;
+	vector<bstream_t*>  m_streamsCreated;
+
+	int					m_id;
+};
+
+#endif	//__SEQUENCER__
\ No newline at end of file
diff --git a/code/icarus/taskmanager.h b/code/icarus/taskmanager.h
new file mode 100644
index 0000000..283db55
--- /dev/null
+++ b/code/icarus/taskmanager.h
@@ -0,0 +1,227 @@
+// Task Manager header file
+
+#ifndef __TASK_MANAGER__
+#define __TASK_MANAGER__
+
+typedef unsigned long DWORD;
+
+#define MAX_TASK_NAME	64
+#define TASKFLAG_NORMAL	0x00000000
+const int RUNAWAY_LIMIT	= 256;
+
+enum
+{
+	TASK_RETURN_COMPLETE,
+	TASK_RETURN_FAILED,
+};
+
+enum 
+{
+	TASK_OK,
+	TASK_FAILED,
+	TASK_START,
+	TASK_END,
+};
+	
+// CTask
+
+class CTask
+{
+public:
+
+	CTask();
+	~CTask();
+
+	static CTask *Create( int GUID, CBlock *block );
+
+	void	Free( void );
+
+	DWORD	GetTimeStamp( void )	const	{	return m_timeStamp;				}
+	CBlock	*GetBlock( void )		const	{	return m_block;					}
+	int		GetGUID( void)			const	{	return m_id;					}
+	int		GetID( void )			const	{	return m_block->GetBlockID();	}
+
+	void	SetTimeStamp( DWORD	timeStamp )		{	m_timeStamp = timeStamp;	}
+	void	SetBlock( CBlock *block )			{	m_block = block;			}
+	void	SetGUID( int id )					{	m_id = id;					}
+
+	// Overloaded new operator.
+	inline void *operator new( size_t size )
+	{	// Allocate the memory.
+		return IGameInterface::GetGame()->Malloc( size );
+	}
+
+	// Overloaded delete operator.
+	inline void operator delete( void *pRawData )
+	{	// Free the Memory.
+		IGameInterface::GetGame()->Free( pRawData );
+	}
+
+protected:
+
+	int		m_id;
+	DWORD	m_timeStamp;
+	CBlock	*m_block;
+};
+
+// CTaskGroup
+
+class CTaskGroup
+{
+public:
+
+	typedef map < int, bool > taskCallback_m;
+
+	CTaskGroup( void );
+	~CTaskGroup( void );
+
+	void Init( void );
+
+	int Add( CTask *task );
+	
+	void SetGUID( int GUID );
+	void SetParent( CTaskGroup *group )	{	m_parent = group;	}
+
+	bool Complete(void)		const { return ( m_numCompleted == m_completedTasks.size() ); }
+
+	bool MarkTaskComplete( int id );
+
+	CTaskGroup *GetParent( void )	const	{	return m_parent;	}
+	int	GetGUID( void )				const	{	return m_GUID;		}
+
+	// Overloaded new operator.
+	static void *operator new( size_t size )
+	{	// Allocate the memory.
+		return IGameInterface::GetGame()->Malloc( size );
+	}
+	// Overloaded delete operator.
+	static void operator delete( void *pRawData )
+	{	// Free the Memory.
+		IGameInterface::GetGame()->Free( pRawData );
+	}
+
+//protected:
+
+	taskCallback_m	m_completedTasks;
+
+	CTaskGroup		*m_parent;
+
+	unsigned int	m_numCompleted;
+	int				m_GUID;
+};
+
+// CTaskManager
+class CSequencer;
+
+class CTaskManager
+{
+
+	typedef	map < int, CTask * >			taskID_m;
+	typedef map < string, CTaskGroup * >	taskGroupName_m;
+	typedef map < int, CTaskGroup * >		taskGroupID_m;
+	typedef vector < CTaskGroup * >			taskGroup_v;
+	typedef list < CTask *>					tasks_l;
+
+public:
+
+	CTaskManager();
+	~CTaskManager();
+
+	int GetID();
+
+	static CTaskManager *Create( void );
+
+	CBlock *GetCurrentTask( void );
+
+	int Init( CSequencer *owner );
+	int	Free( void );
+
+	int	Flush( void );
+
+	int	SetCommand( CBlock *block, int type, CIcarus* icarus );
+	int Completed( int id );
+
+	int Update( CIcarus* icarus );
+	int IsRunning( void ) const { return(!m_tasks.empty()); };
+	bool IsResident( void ) const { return m_resident;};
+
+	CTaskGroup *AddTaskGroup( const char *name , CIcarus* icarus);
+	CTaskGroup *GetTaskGroup( const char *name, CIcarus* icarus);
+	CTaskGroup *GetTaskGroup( int id, CIcarus* icarus );
+
+	int MarkTask( int id, int operation, CIcarus* icarus );
+	CBlock *RecallTask( void );
+
+	void Save();
+	void Load( CIcarus* icarus );
+
+	// Overloaded new operator.
+	inline void* operator new( size_t size )
+	{	// Allocate the memory.
+		return IGameInterface::GetGame()->Malloc( size );
+	}
+
+	// Overloaded delete operator.
+	inline void operator delete( void *pRawData )
+	{	// Free the Memory.
+		IGameInterface::GetGame()->Free( pRawData );
+	}
+
+protected:
+
+	int	Go( CIcarus* icarus );	//Heartbeat function called once per game frame
+	int CallbackCommand( CTask *task, int returnCode, CIcarus* icarus );
+
+	inline bool Check( int targetID, CBlock *block, int memberNum ) const;
+
+	int GetVector( int entID, CBlock *block, int &memberNum, vec3_t &value, CIcarus* icarus );
+	int GetFloat( int entID, CBlock *block, int &memberNum, float &value, CIcarus* icarus );
+	int Get( int entID, CBlock *block, int &memberNum, char **value, CIcarus* icarus );
+
+	int	PushTask( CTask *task, int flag );
+	CTask *PopTask( int flag );
+
+	// Task functions
+	int Rotate( CTask *task, CIcarus* icarus );
+	int Remove( CTask *task , CIcarus* icarus);
+	int Camera( CTask *task, CIcarus* icarus );
+	int Print( CTask *task , CIcarus* icarus);
+	int Sound( CTask *task, CIcarus* icarus );
+	int Move( CTask *task , CIcarus* icarus);
+	int Kill( CTask *task , CIcarus* icarus);
+	int Set( CTask *task, CIcarus* icarus );
+	int Use( CTask *task , CIcarus* icarus);
+	int DeclareVariable( CTask *task , CIcarus* icarus);
+	int FreeVariable( CTask *task, CIcarus* icarus );
+	int Signal( CTask *task , CIcarus* icarus);
+	int Play( CTask *task , CIcarus* icarus);
+
+	int Wait( CTask *task, bool &completed, CIcarus* icarus );
+	int WaitSignal( CTask *task, bool &completed, CIcarus* icarus);
+
+	int	SaveCommand( CBlock *block );
+
+	// Variables
+
+	CSequencer				*m_owner;
+	int						m_ownerID;
+
+	CTaskGroup				*m_curGroup;
+
+	taskGroup_v				m_taskGroups;
+	tasks_l					m_tasks;
+
+	int						m_GUID;
+	int						m_count;
+	
+	taskGroupName_m			m_taskGroupNameMap;
+	taskGroupID_m			m_taskGroupIDMap;
+
+	bool					m_resident;
+
+	int						m_id;
+
+	//CTask	*m_waitTask;		//Global pointer to the current task that is waiting for callback completion
+};
+
+#endif	//__TASK_MANAGER__
diff --git a/code/icarus/vssver.scc b/code/icarus/vssver.scc
new file mode 100644
index 0000000..04c37f1
Binary files /dev/null and b/code/icarus/vssver.scc differ
diff --git a/code/jpeg-6/jcapimin.cpp b/code/jpeg-6/jcapimin.cpp
new file mode 100644
index 0000000..3a28d01
--- /dev/null
+++ b/code/jpeg-6/jcapimin.cpp
@@ -0,0 +1,234 @@
+/*
+ * jcapimin.c
+ *
+ * Copyright (C) 1994-1995, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains application interface code for the compression half
+ * of the JPEG library.  These are the "minimum" API routines that may be
+ * needed in either the normal full-compression case or the transcoding-only
+ * case.
+ *
+ * Most of the routines intended to be called directly by an application
+ * are in this file or in jcapistd.c.  But also see jcparam.c for
+ * parameter-setup helper routines, jcomapi.c for routines shared by
+ * compression and decompression, and jctrans.c for the transcoding case.
+ */
+
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/*
+ * Initialization of a JPEG compression object.
+ * The error manager must already be set up (in case memory manager fails).
+ */
+
+GLOBAL void
+jpeg_create_compress (j_compress_ptr cinfo)
+{
+  int i;
+
+  /* For debugging purposes, zero the whole master structure.
+   * But error manager pointer is already there, so save and restore it.
+   */
+  {
+    struct jpeg_error_mgr * err = cinfo->err;
+    MEMZERO(cinfo, SIZEOF(struct jpeg_compress_struct));
+    cinfo->err = err;
+  }
+  cinfo->is_decompressor = FALSE;
+
+  /* Initialize a memory manager instance for this object */
+  jinit_memory_mgr((j_common_ptr) cinfo);
+
+  /* Zero out pointers to permanent structures. */
+  cinfo->progress = NULL;
+  cinfo->dest = NULL;
+
+  cinfo->comp_info = NULL;
+
+  for (i = 0; i < NUM_QUANT_TBLS; i++)
+    cinfo->quant_tbl_ptrs[i] = NULL;
+
+  for (i = 0; i < NUM_HUFF_TBLS; i++) {
+    cinfo->dc_huff_tbl_ptrs[i] = NULL;
+    cinfo->ac_huff_tbl_ptrs[i] = NULL;
+  }
+
+  cinfo->input_gamma = 1.0;	/* in case application forgets */
+
+  /* OK, I'm ready */
+  cinfo->global_state = CSTATE_START;
+}
+
+
+/*
+ * Destruction of a JPEG compression object
+ */
+
+GLOBAL void
+jpeg_destroy_compress (j_compress_ptr cinfo)
+{
+  jpeg_destroy((j_common_ptr) cinfo); /* use common routine */
+}
+
+
+/*
+ * Abort processing of a JPEG compression operation,
+ * but don't destroy the object itself.
+ */
+
+GLOBAL void
+jpeg_abort_compress (j_compress_ptr cinfo)
+{
+  jpeg_abort((j_common_ptr) cinfo); /* use common routine */
+}
+
+
+/*
+ * Forcibly suppress or un-suppress all quantization and Huffman tables.
+ * Marks all currently defined tables as already written (if suppress)
+ * or not written (if !suppress).  This will control whether they get emitted
+ * by a subsequent jpeg_start_compress call.
+ *
+ * This routine is exported for use by applications that want to produce
+ * abbreviated JPEG datastreams.  It logically belongs in jcparam.c, but
+ * since it is called by jpeg_start_compress, we put it here --- otherwise
+ * jcparam.o would be linked whether the application used it or not.
+ */
+
+GLOBAL void
+jpeg_suppress_tables (j_compress_ptr cinfo, boolean suppress)
+{
+  int i;
+  JQUANT_TBL * qtbl;
+  JHUFF_TBL * htbl;
+
+  for (i = 0; i < NUM_QUANT_TBLS; i++) {
+    if ((qtbl = cinfo->quant_tbl_ptrs[i]) != NULL)
+      qtbl->sent_table = suppress;
+  }
+
+  for (i = 0; i < NUM_HUFF_TBLS; i++) {
+    if ((htbl = cinfo->dc_huff_tbl_ptrs[i]) != NULL)
+      htbl->sent_table = suppress;
+    if ((htbl = cinfo->ac_huff_tbl_ptrs[i]) != NULL)
+      htbl->sent_table = suppress;
+  }
+}
+
+
+/*
+ * Finish JPEG compression.
+ *
+ * If a multipass operating mode was selected, this may do a great deal of
+ * work including most of the actual output.
+ */
+
+GLOBAL void
+jpeg_finish_compress (j_compress_ptr cinfo)
+{
+  JDIMENSION iMCU_row;
+
+  if (cinfo->global_state == CSTATE_SCANNING ||
+      cinfo->global_state == CSTATE_RAW_OK) {
+    /* Terminate first pass */
+    if (cinfo->next_scanline < cinfo->image_height)
+      ERREXIT(cinfo, JERR_TOO_LITTLE_DATA);
+    (*cinfo->master->finish_pass) (cinfo);
+  } else if (cinfo->global_state != CSTATE_WRCOEFS)
+    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+  /* Perform any remaining passes */
+  while (! cinfo->master->is_last_pass) {
+    (*cinfo->master->prepare_for_pass) (cinfo);
+    for (iMCU_row = 0; iMCU_row < cinfo->total_iMCU_rows; iMCU_row++) {
+      if (cinfo->progress != NULL) {
+	cinfo->progress->pass_counter = (long) iMCU_row;
+	cinfo->progress->pass_limit = (long) cinfo->total_iMCU_rows;
+	(*cinfo->progress->progress_monitor) ((j_common_ptr) cinfo);
+      }
+      /* We bypass the main controller and invoke coef controller directly;
+       * all work is being done from the coefficient buffer.
+       */
+      if (! (*cinfo->coef->compress_data) (cinfo, (JSAMPIMAGE) NULL))
+	ERREXIT(cinfo, JERR_CANT_SUSPEND);
+    }
+    (*cinfo->master->finish_pass) (cinfo);
+  }
+  /* Write EOI, do final cleanup */
+  (*cinfo->marker->write_file_trailer) (cinfo);
+  (*cinfo->dest->term_destination) (cinfo);
+  /* We can use jpeg_abort to release memory and reset global_state */
+  jpeg_abort((j_common_ptr) cinfo);
+}
+
+
+/*
+ * Write a special marker.
+ * This is only recommended for writing COM or APPn markers.
+ * Must be called after jpeg_start_compress() and before
+ * first call to jpeg_write_scanlines() or jpeg_write_raw_data().
+ */
+
+GLOBAL void
+jpeg_write_marker (j_compress_ptr cinfo, int marker,
+		   const JOCTET *dataptr, unsigned int datalen)
+{
+  if (cinfo->next_scanline != 0 ||
+      (cinfo->global_state != CSTATE_SCANNING &&
+       cinfo->global_state != CSTATE_RAW_OK &&
+       cinfo->global_state != CSTATE_WRCOEFS))
+    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+
+  (*cinfo->marker->write_any_marker) (cinfo, marker, dataptr, datalen);
+}
+
+
+/*
+ * Alternate compression function: just write an abbreviated table file.
+ * Before calling this, all parameters and a data destination must be set up.
+ *
+ * To produce a pair of files containing abbreviated tables and abbreviated
+ * image data, one would proceed as follows:
+ *
+ *		initialize JPEG object
+ *		set JPEG parameters
+ *		set destination to table file
+ *		jpeg_write_tables(cinfo);
+ *		set destination to image file
+ *		jpeg_start_compress(cinfo, FALSE);
+ *		write data...
+ *		jpeg_finish_compress(cinfo);
+ *
+ * jpeg_write_tables has the side effect of marking all tables written
+ * (same as jpeg_suppress_tables(..., TRUE)).  Thus a subsequent start_compress
+ * will not re-emit the tables unless it is passed write_all_tables=TRUE.
+ */
+
+GLOBAL void
+jpeg_write_tables (j_compress_ptr cinfo)
+{
+  if (cinfo->global_state != CSTATE_START)
+    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+
+  /* (Re)initialize error mgr and destination modules */
+  (*cinfo->err->reset_error_mgr) ((j_common_ptr) cinfo);
+  (*cinfo->dest->init_destination) (cinfo);
+  /* Initialize the marker writer ... bit of a crock to do it here. */
+  jinit_marker_writer(cinfo);
+  /* Write them tables! */
+  (*cinfo->marker->write_tables_only) (cinfo);
+  /* And clean up. */
+  (*cinfo->dest->term_destination) (cinfo);
+  /* We can use jpeg_abort to release memory. */
+  jpeg_abort((j_common_ptr) cinfo);
+}
diff --git a/code/jpeg-6/jccoefct.cpp b/code/jpeg-6/jccoefct.cpp
new file mode 100644
index 0000000..464f9b2
--- /dev/null
+++ b/code/jpeg-6/jccoefct.cpp
@@ -0,0 +1,454 @@
+/*
+ * jccoefct.c
+ *
+ * Copyright (C) 1994-1995, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains the coefficient buffer controller for compression.
+ * This controller is the top level of the JPEG compressor proper.
+ * The coefficient buffer lies between forward-DCT and entropy encoding steps.
+ */
+
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/* We use a full-image coefficient buffer when doing Huffman optimization,
+ * and also for writing multiple-scan JPEG files.  In all cases, the DCT
+ * step is run during the first pass, and subsequent passes need only read
+ * the buffered coefficients.
+ */
+#ifdef ENTROPY_OPT_SUPPORTED
+#define FULL_COEF_BUFFER_SUPPORTED
+#else
+#ifdef C_MULTISCAN_FILES_SUPPORTED
+#define FULL_COEF_BUFFER_SUPPORTED
+#endif
+#endif
+
+
+/* Private buffer controller object */
+
+typedef struct {
+  struct jpeg_c_coef_controller pub; /* public fields */
+
+  JDIMENSION iMCU_row_num;	/* iMCU row # within image */
+  JDIMENSION mcu_ctr;		/* counts MCUs processed in current row */
+  int MCU_vert_offset;		/* counts MCU rows within iMCU row */
+  int MCU_rows_per_iMCU_row;	/* number of such rows needed */
+
+  /* For single-pass compression, it's sufficient to buffer just one MCU
+   * (although this may prove a bit slow in practice).  We allocate a
+   * workspace of C_MAX_BLOCKS_IN_MCU coefficient blocks, and reuse it for each
+   * MCU constructed and sent.  (On 80x86, the workspace is FAR even though
+   * it's not really very big; this is to keep the module interfaces unchanged
+   * when a large coefficient buffer is necessary.)
+   * In multi-pass modes, this array points to the current MCU's blocks
+   * within the virtual arrays.
+   */
+  JBLOCKROW MCU_buffer[C_MAX_BLOCKS_IN_MCU];
+
+  /* In multi-pass modes, we need a virtual block array for each component. */
+  jvirt_barray_ptr whole_image[MAX_COMPONENTS];
+} my_coef_controller;
+
+typedef my_coef_controller * my_coef_ptr;
+
+
+/* Forward declarations */
+METHODDEF boolean compress_data
+    JPP((j_compress_ptr cinfo, JSAMPIMAGE input_buf));
+#ifdef FULL_COEF_BUFFER_SUPPORTED
+METHODDEF boolean compress_first_pass
+    JPP((j_compress_ptr cinfo, JSAMPIMAGE input_buf));
+METHODDEF boolean compress_output
+    JPP((j_compress_ptr cinfo, JSAMPIMAGE input_buf));
+#endif
+
+
+LOCAL void
+start_iMCU_row (j_compress_ptr cinfo)
+/* Reset within-iMCU-row counters for a new row */
+{
+  my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
+
+  /* In an interleaved scan, an MCU row is the same as an iMCU row.
+   * In a noninterleaved scan, an iMCU row has v_samp_factor MCU rows.
+   * But at the bottom of the image, process only what's left.
+   */
+  if (cinfo->comps_in_scan > 1) {
+    coef->MCU_rows_per_iMCU_row = 1;
+  } else {
+    if (coef->iMCU_row_num < (cinfo->total_iMCU_rows-1))
+      coef->MCU_rows_per_iMCU_row = cinfo->cur_comp_info[0]->v_samp_factor;
+    else
+      coef->MCU_rows_per_iMCU_row = cinfo->cur_comp_info[0]->last_row_height;
+  }
+
+  coef->mcu_ctr = 0;
+  coef->MCU_vert_offset = 0;
+}
+
+
+/*
+ * Initialize for a processing pass.
+ */
+
+METHODDEF void
+start_pass_coef (j_compress_ptr cinfo, J_BUF_MODE pass_mode)
+{
+  my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
+
+  coef->iMCU_row_num = 0;
+  start_iMCU_row(cinfo);
+
+  switch (pass_mode) {
+  case JBUF_PASS_THRU:
+    if (coef->whole_image[0] != NULL)
+      ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+    coef->pub.compress_data = compress_data;
+    break;
+#ifdef FULL_COEF_BUFFER_SUPPORTED
+  case JBUF_SAVE_AND_PASS:
+    if (coef->whole_image[0] == NULL)
+      ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+    coef->pub.compress_data = compress_first_pass;
+    break;
+  case JBUF_CRANK_DEST:
+    if (coef->whole_image[0] == NULL)
+      ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+    coef->pub.compress_data = compress_output;
+    break;
+#endif
+  default:
+    ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+    break;
+  }
+}
+
+
+/*
+ * Process some data in the single-pass case.
+ * We process the equivalent of one fully interleaved MCU row ("iMCU" row)
+ * per call, ie, v_samp_factor block rows for each component in the image.
+ * Returns TRUE if the iMCU row is completed, FALSE if suspended.
+ *
+ * NB: input_buf contains a plane for each component in image.
+ * For single pass, this is the same as the components in the scan.
+ */
+
+METHODDEF boolean
+compress_data (j_compress_ptr cinfo, JSAMPIMAGE input_buf)
+{
+  my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
+  JDIMENSION MCU_col_num;	/* index of current MCU within row */
+  JDIMENSION last_MCU_col = cinfo->MCUs_per_row - 1;
+  JDIMENSION last_iMCU_row = cinfo->total_iMCU_rows - 1;
+  int blkn, bi, ci, yindex, yoffset, blockcnt;
+  JDIMENSION ypos, xpos;
+  jpeg_component_info *compptr;
+
+  /* Loop to write as much as one whole iMCU row */
+  for (yoffset = coef->MCU_vert_offset; yoffset < coef->MCU_rows_per_iMCU_row;
+       yoffset++) {
+    for (MCU_col_num = coef->mcu_ctr; MCU_col_num <= last_MCU_col;
+	 MCU_col_num++) {
+      /* Determine where data comes from in input_buf and do the DCT thing.
+       * Each call on forward_DCT processes a horizontal row of DCT blocks
+       * as wide as an MCU; we rely on having allocated the MCU_buffer[] blocks
+       * sequentially.  Dummy blocks at the right or bottom edge are filled in
+       * specially.  The data in them does not matter for image reconstruction,
+       * so we fill them with values that will encode to the smallest amount of
+       * data, viz: all zeroes in the AC entries, DC entries equal to previous
+       * block's DC value.  (Thanks to Thomas Kinsman for this idea.)
+       */
+      blkn = 0;
+      for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+	compptr = cinfo->cur_comp_info[ci];
+	blockcnt = (MCU_col_num < last_MCU_col) ? compptr->MCU_width
+						: compptr->last_col_width;
+	xpos = MCU_col_num * compptr->MCU_sample_width;
+	ypos = yoffset * DCTSIZE; /* ypos == (yoffset+yindex) * DCTSIZE */
+	for (yindex = 0; yindex < compptr->MCU_height; yindex++) {
+	  if (coef->iMCU_row_num < last_iMCU_row ||
+	      yoffset+yindex < compptr->last_row_height) {
+	    (*cinfo->fdct->forward_DCT) (cinfo, compptr,
+					 input_buf[ci], coef->MCU_buffer[blkn],
+					 ypos, xpos, (JDIMENSION) blockcnt);
+	    if (blockcnt < compptr->MCU_width) {
+	      /* Create some dummy blocks at the right edge of the image. */
+	      jzero_far((void FAR *) coef->MCU_buffer[blkn + blockcnt],
+			(compptr->MCU_width - blockcnt) * SIZEOF(JBLOCK));
+	      for (bi = blockcnt; bi < compptr->MCU_width; bi++) {
+		coef->MCU_buffer[blkn+bi][0][0] = coef->MCU_buffer[blkn+bi-1][0][0];
+	      }
+	    }
+	  } else {
+	    /* Create a row of dummy blocks at the bottom of the image. */
+	    jzero_far((void FAR *) coef->MCU_buffer[blkn],
+		      compptr->MCU_width * SIZEOF(JBLOCK));
+	    for (bi = 0; bi < compptr->MCU_width; bi++) {
+	      coef->MCU_buffer[blkn+bi][0][0] = coef->MCU_buffer[blkn-1][0][0];
+	    }
+	  }
+	  blkn += compptr->MCU_width;
+	  ypos += DCTSIZE;
+	}
+      }
+      /* Try to write the MCU.  In event of a suspension failure, we will
+       * re-DCT the MCU on restart (a bit inefficient, could be fixed...)
+       */
+      if (! (*cinfo->entropy->encode_mcu) (cinfo, coef->MCU_buffer)) {
+	/* Suspension forced; update state counters and exit */
+	coef->MCU_vert_offset = yoffset;
+	coef->mcu_ctr = MCU_col_num;
+	return FALSE;
+      }
+    }
+    /* Completed an MCU row, but perhaps not an iMCU row */
+    coef->mcu_ctr = 0;
+  }
+  /* Completed the iMCU row, advance counters for next one */
+  coef->iMCU_row_num++;
+  start_iMCU_row(cinfo);
+  return TRUE;
+}
+
+
+#ifdef FULL_COEF_BUFFER_SUPPORTED
+
+/*
+ * Process some data in the first pass of a multi-pass case.
+ * We process the equivalent of one fully interleaved MCU row ("iMCU" row)
+ * per call, ie, v_samp_factor block rows for each component in the image.
+ * This amount of data is read from the source buffer, DCT'd and quantized,
+ * and saved into the virtual arrays.  We also generate suitable dummy blocks
+ * as needed at the right and lower edges.  (The dummy blocks are constructed
+ * in the virtual arrays, which have been padded appropriately.)  This makes
+ * it possible for subsequent passes not to worry about real vs. dummy blocks.
+ *
+ * We must also emit the data to the entropy encoder.  This is conveniently
+ * done by calling compress_output() after we've loaded the current strip
+ * of the virtual arrays.
+ *
+ * NB: input_buf contains a plane for each component in image.  All
+ * components are DCT'd and loaded into the virtual arrays in this pass.
+ * However, it may be that only a subset of the components are emitted to
+ * the entropy encoder during this first pass; be careful about looking
+ * at the scan-dependent variables (MCU dimensions, etc).
+ */
+
+METHODDEF boolean
+compress_first_pass (j_compress_ptr cinfo, JSAMPIMAGE input_buf)
+{
+  my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
+  JDIMENSION last_iMCU_row = cinfo->total_iMCU_rows - 1;
+  JDIMENSION blocks_across, MCUs_across, MCUindex;
+  int bi, ci, h_samp_factor, block_row, block_rows, ndummy;
+  JCOEF lastDC;
+  jpeg_component_info *compptr;
+  JBLOCKARRAY buffer;
+  JBLOCKROW thisblockrow, lastblockrow;
+
+  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+       ci++, compptr++) {
+    /* Align the virtual buffer for this component. */
+    buffer = (*cinfo->mem->access_virt_barray)
+      ((j_common_ptr) cinfo, coef->whole_image[ci],
+       coef->iMCU_row_num * compptr->v_samp_factor,
+       (JDIMENSION) compptr->v_samp_factor, TRUE);
+    /* Count non-dummy DCT block rows in this iMCU row. */
+    if (coef->iMCU_row_num < last_iMCU_row)
+      block_rows = compptr->v_samp_factor;
+    else {
+      /* NB: can't use last_row_height here, since may not be set! */
+      block_rows = (int) (compptr->height_in_blocks % compptr->v_samp_factor);
+      if (block_rows == 0) block_rows = compptr->v_samp_factor;
+    }
+    blocks_across = compptr->width_in_blocks;
+    h_samp_factor = compptr->h_samp_factor;
+    /* Count number of dummy blocks to be added at the right margin. */
+    ndummy = (int) (blocks_across % h_samp_factor);
+    if (ndummy > 0)
+      ndummy = h_samp_factor - ndummy;
+    /* Perform DCT for all non-dummy blocks in this iMCU row.  Each call
+     * on forward_DCT processes a complete horizontal row of DCT blocks.
+     */
+    for (block_row = 0; block_row < block_rows; block_row++) {
+      thisblockrow = buffer[block_row];
+      (*cinfo->fdct->forward_DCT) (cinfo, compptr,
+				   input_buf[ci], thisblockrow,
+				   (JDIMENSION) (block_row * DCTSIZE),
+				   (JDIMENSION) 0, blocks_across);
+      if (ndummy > 0) {
+	/* Create dummy blocks at the right edge of the image. */
+	thisblockrow += blocks_across; /* => first dummy block */
+	jzero_far((void FAR *) thisblockrow, ndummy * SIZEOF(JBLOCK));
+	lastDC = thisblockrow[-1][0];
+	for (bi = 0; bi < ndummy; bi++) {
+	  thisblockrow[bi][0] = lastDC;
+	}
+      }
+    }
+    /* If at end of image, create dummy block rows as needed.
+     * The tricky part here is that within each MCU, we want the DC values
+     * of the dummy blocks to match the last real block's DC value.
+     * This squeezes a few more bytes out of the resulting file...
+     */
+    if (coef->iMCU_row_num == last_iMCU_row) {
+      blocks_across += ndummy;	/* include lower right corner */
+      MCUs_across = blocks_across / h_samp_factor;
+      for (block_row = block_rows; block_row < compptr->v_samp_factor;
+	   block_row++) {
+	thisblockrow = buffer[block_row];
+	lastblockrow = buffer[block_row-1];
+	jzero_far((void FAR *) thisblockrow,
+		  (size_t) (blocks_across * SIZEOF(JBLOCK)));
+	for (MCUindex = 0; MCUindex < MCUs_across; MCUindex++) {
+	  lastDC = lastblockrow[h_samp_factor-1][0];
+	  for (bi = 0; bi < h_samp_factor; bi++) {
+	    thisblockrow[bi][0] = lastDC;
+	  }
+	  thisblockrow += h_samp_factor; /* advance to next MCU in row */
+	  lastblockrow += h_samp_factor;
+	}
+      }
+    }
+  }
+  /* NB: compress_output will increment iMCU_row_num if successful.
+   * A suspension return will result in redoing all the work above next time.
+   */
+
+  /* Emit data to the entropy encoder, sharing code with subsequent passes */
+  return compress_output(cinfo, input_buf);
+}
+
+
+/*
+ * Process some data in subsequent passes of a multi-pass case.
+ * We process the equivalent of one fully interleaved MCU row ("iMCU" row)
+ * per call, ie, v_samp_factor block rows for each component in the scan.
+ * The data is obtained from the virtual arrays and fed to the entropy coder.
+ * Returns TRUE if the iMCU row is completed, FALSE if suspended.
+ *
+ * NB: input_buf is ignored; it is likely to be a NULL pointer.
+ */
+
+METHODDEF boolean
+compress_output (j_compress_ptr cinfo, JSAMPIMAGE input_buf)
+{
+  my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
+  JDIMENSION MCU_col_num;	/* index of current MCU within row */
+  int blkn, ci, xindex, yindex, yoffset;
+  JDIMENSION start_col;
+  JBLOCKARRAY buffer[MAX_COMPS_IN_SCAN];
+  JBLOCKROW buffer_ptr;
+  jpeg_component_info *compptr;
+
+  /* Align the virtual buffers for the components used in this scan.
+   * NB: during first pass, this is safe only because the buffers will
+   * already be aligned properly, so jmemmgr.c won't need to do any I/O.
+   */
+  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+    compptr = cinfo->cur_comp_info[ci];
+    buffer[ci] = (*cinfo->mem->access_virt_barray)
+      ((j_common_ptr) cinfo, coef->whole_image[compptr->component_index],
+       coef->iMCU_row_num * compptr->v_samp_factor,
+       (JDIMENSION) compptr->v_samp_factor, FALSE);
+  }
+
+  /* Loop to process one whole iMCU row */
+  for (yoffset = coef->MCU_vert_offset; yoffset < coef->MCU_rows_per_iMCU_row;
+       yoffset++) {
+    for (MCU_col_num = coef->mcu_ctr; MCU_col_num < cinfo->MCUs_per_row;
+	 MCU_col_num++) {
+      /* Construct list of pointers to DCT blocks belonging to this MCU */
+      blkn = 0;			/* index of current DCT block within MCU */
+      for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+	compptr = cinfo->cur_comp_info[ci];
+	start_col = MCU_col_num * compptr->MCU_width;
+	for (yindex = 0; yindex < compptr->MCU_height; yindex++) {
+	  buffer_ptr = buffer[ci][yindex+yoffset] + start_col;
+	  for (xindex = 0; xindex < compptr->MCU_width; xindex++) {
+	    coef->MCU_buffer[blkn++] = buffer_ptr++;
+	  }
+	}
+      }
+      /* Try to write the MCU. */
+      if (! (*cinfo->entropy->encode_mcu) (cinfo, coef->MCU_buffer)) {
+	/* Suspension forced; update state counters and exit */
+	coef->MCU_vert_offset = yoffset;
+	coef->mcu_ctr = MCU_col_num;
+	return FALSE;
+      }
+    }
+    /* Completed an MCU row, but perhaps not an iMCU row */
+    coef->mcu_ctr = 0;
+  }
+  /* Completed the iMCU row, advance counters for next one */
+  coef->iMCU_row_num++;
+  start_iMCU_row(cinfo);
+  return TRUE;
+}
+
+#endif /* FULL_COEF_BUFFER_SUPPORTED */
+
+
+/*
+ * Initialize coefficient buffer controller.
+ */
+
+GLOBAL void
+jinit_c_coef_controller (j_compress_ptr cinfo, boolean need_full_buffer)
+{
+  my_coef_ptr coef;
+
+  coef = (my_coef_ptr)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				SIZEOF(my_coef_controller));
+  cinfo->coef = (struct jpeg_c_coef_controller *) coef;
+  coef->pub.start_pass = start_pass_coef;
+
+  /* Create the coefficient buffer. */
+  if (need_full_buffer) {
+#ifdef FULL_COEF_BUFFER_SUPPORTED
+    /* Allocate a full-image virtual array for each component, */
+    /* padded to a multiple of samp_factor DCT blocks in each direction. */
+    int ci;
+    jpeg_component_info *compptr;
+
+    for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+	 ci++, compptr++) {
+      coef->whole_image[ci] = (*cinfo->mem->request_virt_barray)
+	((j_common_ptr) cinfo, JPOOL_IMAGE, FALSE,
+	 (JDIMENSION) jround_up((long) compptr->width_in_blocks,
+				(long) compptr->h_samp_factor),
+	 (JDIMENSION) jround_up((long) compptr->height_in_blocks,
+				(long) compptr->v_samp_factor),
+	 (JDIMENSION) compptr->v_samp_factor);
+    }
+#else
+    ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+#endif
+  } else {
+    /* We only need a single-MCU buffer. */
+    JBLOCKROW buffer;
+    int i;
+
+    buffer = (JBLOCKROW)
+      (*cinfo->mem->alloc_large) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				  C_MAX_BLOCKS_IN_MCU * SIZEOF(JBLOCK));
+    for (i = 0; i < C_MAX_BLOCKS_IN_MCU; i++) {
+      coef->MCU_buffer[i] = buffer + i;
+    }
+    coef->whole_image[0] = NULL; /* flag for no virtual arrays */
+  }
+}
diff --git a/code/jpeg-6/jccolor.cpp b/code/jpeg-6/jccolor.cpp
new file mode 100644
index 0000000..4454de1
--- /dev/null
+++ b/code/jpeg-6/jccolor.cpp
@@ -0,0 +1,465 @@
+/*
+ * jccolor.c
+ *
+ * Copyright (C) 1991-1994, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains input colorspace conversion routines.
+ */
+
+
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/* Private subobject */
+
+typedef struct {
+  struct jpeg_color_converter pub; /* public fields */
+
+  /* Private state for RGB->YCC conversion */
+  INT32 * rgb_ycc_tab;		/* => table for RGB to YCbCr conversion */
+} my_color_converter;
+
+typedef my_color_converter * my_cconvert_ptr;
+
+
+/**************** RGB -> YCbCr conversion: most common case **************/
+
+/*
+ * YCbCr is defined per CCIR 601-1, except that Cb and Cr are
+ * normalized to the range 0..MAXJSAMPLE rather than -0.5 .. 0.5.
+ * The conversion equations to be implemented are therefore
+ *	Y  =  0.29900 * R + 0.58700 * G + 0.11400 * B
+ *	Cb = -0.16874 * R - 0.33126 * G + 0.50000 * B  + CENTERJSAMPLE
+ *	Cr =  0.50000 * R - 0.41869 * G - 0.08131 * B  + CENTERJSAMPLE
+ * (These numbers are derived from TIFF 6.0 section 21, dated 3-June-92.)
+ * Note: older versions of the IJG code used a zero offset of MAXJSAMPLE/2,
+ * rather than CENTERJSAMPLE, for Cb and Cr.  This gave equal positive and
+ * negative swings for Cb/Cr, but meant that grayscale values (Cb=Cr=0)
+ * were not represented exactly.  Now we sacrifice exact representation of
+ * maximum red and maximum blue in order to get exact grayscales.
+ *
+ * To avoid floating-point arithmetic, we represent the fractional constants
+ * as integers scaled up by 2^16 (about 4 digits precision); we have to divide
+ * the products by 2^16, with appropriate rounding, to get the correct answer.
+ *
+ * For even more speed, we avoid doing any multiplications in the inner loop
+ * by precalculating the constants times R,G,B for all possible values.
+ * For 8-bit JSAMPLEs this is very reasonable (only 256 entries per table);
+ * for 12-bit samples it is still acceptable.  It's not very reasonable for
+ * 16-bit samples, but if you want lossless storage you shouldn't be changing
+ * colorspace anyway.
+ * The CENTERJSAMPLE offsets and the rounding fudge-factor of 0.5 are included
+ * in the tables to save adding them separately in the inner loop.
+ */
+
+#define SCALEBITS	16	/* speediest right-shift on some machines */
+#define CBCR_OFFSET	((INT32) CENTERJSAMPLE << SCALEBITS)
+#define ONE_HALF	((INT32) 1 << (SCALEBITS-1))
+#define FIX(x)		((INT32) ((x) * (1L<<SCALEBITS) + 0.5))
+
+/* We allocate one big table and divide it up into eight parts, instead of
+ * doing eight alloc_small requests.  This lets us use a single table base
+ * address, which can be held in a register in the inner loops on many
+ * machines (more than can hold all eight addresses, anyway).
+ */
+
+#define R_Y_OFF		0			/* offset to R => Y section */
+#define G_Y_OFF		(1*(MAXJSAMPLE+1))	/* offset to G => Y section */
+#define B_Y_OFF		(2*(MAXJSAMPLE+1))	/* etc. */
+#define R_CB_OFF	(3*(MAXJSAMPLE+1))
+#define G_CB_OFF	(4*(MAXJSAMPLE+1))
+#define B_CB_OFF	(5*(MAXJSAMPLE+1))
+#define R_CR_OFF	B_CB_OFF		/* B=>Cb, R=>Cr are the same */
+#define G_CR_OFF	(6*(MAXJSAMPLE+1))
+#define B_CR_OFF	(7*(MAXJSAMPLE+1))
+#define TABLE_SIZE	(8*(MAXJSAMPLE+1))
+
+
+/*
+ * Initialize for RGB->YCC colorspace conversion.
+ */
+
+METHODDEF void
+rgb_ycc_start (j_compress_ptr cinfo)
+{
+  my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
+  INT32 * rgb_ycc_tab;
+  INT32 i;
+
+  /* Allocate and fill in the conversion tables. */
+  cconvert->rgb_ycc_tab = rgb_ycc_tab = (INT32 *)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				(TABLE_SIZE * SIZEOF(INT32)));
+
+  for (i = 0; i <= MAXJSAMPLE; i++) {
+    rgb_ycc_tab[i+R_Y_OFF] = FIX(0.29900) * i;
+    rgb_ycc_tab[i+G_Y_OFF] = FIX(0.58700) * i;
+    rgb_ycc_tab[i+B_Y_OFF] = FIX(0.11400) * i     + ONE_HALF;
+    rgb_ycc_tab[i+R_CB_OFF] = (-FIX(0.16874)) * i;
+    rgb_ycc_tab[i+G_CB_OFF] = (-FIX(0.33126)) * i;
+    /* We use a rounding fudge-factor of 0.5-epsilon for Cb and Cr.
+     * This ensures that the maximum output will round to MAXJSAMPLE
+     * not MAXJSAMPLE+1, and thus that we don't have to range-limit.
+     */
+    rgb_ycc_tab[i+B_CB_OFF] = FIX(0.50000) * i    + CBCR_OFFSET + ONE_HALF-1;
+/*  B=>Cb and R=>Cr tables are the same
+    rgb_ycc_tab[i+R_CR_OFF] = FIX(0.50000) * i    + CBCR_OFFSET + ONE_HALF-1;
+*/
+    rgb_ycc_tab[i+G_CR_OFF] = (-FIX(0.41869)) * i;
+    rgb_ycc_tab[i+B_CR_OFF] = (-FIX(0.08131)) * i;
+  }
+}
+
+
+/*
+ * Convert some rows of samples to the JPEG colorspace.
+ *
+ * Note that we change from the application's interleaved-pixel format
+ * to our internal noninterleaved, one-plane-per-component format.
+ * The input buffer is therefore three times as wide as the output buffer.
+ *
+ * A starting row offset is provided only for the output buffer.  The caller
+ * can easily adjust the passed input_buf value to accommodate any row
+ * offset required on that side.
+ */
+
+METHODDEF void
+rgb_ycc_convert (j_compress_ptr cinfo,
+		 JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+		 JDIMENSION output_row, int num_rows)
+{
+  my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
+  register int r, g, b;
+  register INT32 * ctab = cconvert->rgb_ycc_tab;
+  register JSAMPROW inptr;
+  register JSAMPROW outptr0, outptr1, outptr2;
+  register JDIMENSION col;
+  JDIMENSION num_cols = cinfo->image_width;
+
+  while (--num_rows >= 0) {
+    inptr = *input_buf++;
+    outptr0 = output_buf[0][output_row];
+    outptr1 = output_buf[1][output_row];
+    outptr2 = output_buf[2][output_row];
+    output_row++;
+    for (col = 0; col < num_cols; col++) {
+      r = GETJSAMPLE(inptr[RGB_RED]);
+      g = GETJSAMPLE(inptr[RGB_GREEN]);
+      b = GETJSAMPLE(inptr[RGB_BLUE]);
+      inptr += RGB_PIXELSIZE;
+      /* If the inputs are 0..MAXJSAMPLE, the outputs of these equations
+       * must be too; we do not need an explicit range-limiting operation.
+       * Hence the value being shifted is never negative, and we don't
+       * need the general RIGHT_SHIFT macro.
+       */
+      /* Y */
+      outptr0[col] = (JSAMPLE)
+		((ctab[r+R_Y_OFF] + ctab[g+G_Y_OFF] + ctab[b+B_Y_OFF])
+		 >> SCALEBITS);
+      /* Cb */
+      outptr1[col] = (JSAMPLE)
+		((ctab[r+R_CB_OFF] + ctab[g+G_CB_OFF] + ctab[b+B_CB_OFF])
+		 >> SCALEBITS);
+      /* Cr */
+      outptr2[col] = (JSAMPLE)
+		((ctab[r+R_CR_OFF] + ctab[g+G_CR_OFF] + ctab[b+B_CR_OFF])
+		 >> SCALEBITS);
+    }
+  }
+}
+
+
+/**************** Cases other than RGB -> YCbCr **************/
+
+
+/*
+ * Convert some rows of samples to the JPEG colorspace.
+ * This version handles RGB->grayscale conversion, which is the same
+ * as the RGB->Y portion of RGB->YCbCr.
+ * We assume rgb_ycc_start has been called (we only use the Y tables).
+ */
+
+METHODDEF void
+rgb_gray_convert (j_compress_ptr cinfo,
+		  JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+		  JDIMENSION output_row, int num_rows)
+{
+  my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
+  register int r, g, b;
+  register INT32 * ctab = cconvert->rgb_ycc_tab;
+  register JSAMPROW inptr;
+  register JSAMPROW outptr;
+  register JDIMENSION col;
+  JDIMENSION num_cols = cinfo->image_width;
+
+  while (--num_rows >= 0) {
+    inptr = *input_buf++;
+    outptr = output_buf[0][output_row];
+    output_row++;
+    for (col = 0; col < num_cols; col++) {
+      r = GETJSAMPLE(inptr[RGB_RED]);
+      g = GETJSAMPLE(inptr[RGB_GREEN]);
+      b = GETJSAMPLE(inptr[RGB_BLUE]);
+      inptr += RGB_PIXELSIZE;
+      /* Y */
+      outptr[col] = (JSAMPLE)
+		((ctab[r+R_Y_OFF] + ctab[g+G_Y_OFF] + ctab[b+B_Y_OFF])
+		 >> SCALEBITS);
+    }
+  }
+}
+
+
+/*
+ * Convert some rows of samples to the JPEG colorspace.
+ * This version handles Adobe-style CMYK->YCCK conversion,
+ * where we convert R=1-C, G=1-M, and B=1-Y to YCbCr using the same
+ * conversion as above, while passing K (black) unchanged.
+ * We assume rgb_ycc_start has been called.
+ */
+
+METHODDEF void
+cmyk_ycck_convert (j_compress_ptr cinfo,
+		   JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+		   JDIMENSION output_row, int num_rows)
+{
+  my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
+  register int r, g, b;
+  register INT32 * ctab = cconvert->rgb_ycc_tab;
+  register JSAMPROW inptr;
+  register JSAMPROW outptr0, outptr1, outptr2, outptr3;
+  register JDIMENSION col;
+  JDIMENSION num_cols = cinfo->image_width;
+
+  while (--num_rows >= 0) {
+    inptr = *input_buf++;
+    outptr0 = output_buf[0][output_row];
+    outptr1 = output_buf[1][output_row];
+    outptr2 = output_buf[2][output_row];
+    outptr3 = output_buf[3][output_row];
+    output_row++;
+    for (col = 0; col < num_cols; col++) {
+      r = MAXJSAMPLE - GETJSAMPLE(inptr[0]);
+      g = MAXJSAMPLE - GETJSAMPLE(inptr[1]);
+      b = MAXJSAMPLE - GETJSAMPLE(inptr[2]);
+      /* K passes through as-is */
+      outptr3[col] = inptr[3];	/* don't need GETJSAMPLE here */
+      inptr += 4;
+      /* If the inputs are 0..MAXJSAMPLE, the outputs of these equations
+       * must be too; we do not need an explicit range-limiting operation.
+       * Hence the value being shifted is never negative, and we don't
+       * need the general RIGHT_SHIFT macro.
+       */
+      /* Y */
+      outptr0[col] = (JSAMPLE)
+		((ctab[r+R_Y_OFF] + ctab[g+G_Y_OFF] + ctab[b+B_Y_OFF])
+		 >> SCALEBITS);
+      /* Cb */
+      outptr1[col] = (JSAMPLE)
+		((ctab[r+R_CB_OFF] + ctab[g+G_CB_OFF] + ctab[b+B_CB_OFF])
+		 >> SCALEBITS);
+      /* Cr */
+      outptr2[col] = (JSAMPLE)
+		((ctab[r+R_CR_OFF] + ctab[g+G_CR_OFF] + ctab[b+B_CR_OFF])
+		 >> SCALEBITS);
+    }
+  }
+}
+
+
+/*
+ * Convert some rows of samples to the JPEG colorspace.
+ * This version handles grayscale output with no conversion.
+ * The source can be either plain grayscale or YCbCr (since Y == gray).
+ */
+
+METHODDEF void
+grayscale_convert (j_compress_ptr cinfo,
+		   JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+		   JDIMENSION output_row, int num_rows)
+{
+  register JSAMPROW inptr;
+  register JSAMPROW outptr;
+  register JDIMENSION col;
+  JDIMENSION num_cols = cinfo->image_width;
+  int instride = cinfo->input_components;
+
+  while (--num_rows >= 0) {
+    inptr = *input_buf++;
+    outptr = output_buf[0][output_row];
+    output_row++;
+    for (col = 0; col < num_cols; col++) {
+      outptr[col] = inptr[0];	/* don't need GETJSAMPLE() here */
+      inptr += instride;
+    }
+  }
+}
+
+
+/*
+ * Convert some rows of samples to the JPEG colorspace.
+ * This version handles multi-component colorspaces without conversion.
+ * We assume input_components == num_components.
+ */
+
+METHODDEF void
+null_convert (j_compress_ptr cinfo,
+	      JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+	      JDIMENSION output_row, int num_rows)
+{
+  register JSAMPROW inptr;
+  register JSAMPROW outptr;
+  register JDIMENSION col;
+  register int ci;
+  int nc = cinfo->num_components;
+  JDIMENSION num_cols = cinfo->image_width;
+
+  while (--num_rows >= 0) {
+    /* It seems fastest to make a separate pass for each component. */
+    for (ci = 0; ci < nc; ci++) {
+      inptr = *input_buf;
+      outptr = output_buf[ci][output_row];
+      for (col = 0; col < num_cols; col++) {
+	outptr[col] = inptr[ci]; /* don't need GETJSAMPLE() here */
+	inptr += nc;
+      }
+    }
+    input_buf++;
+    output_row++;
+  }
+}
+
+
+/*
+ * Empty method for start_pass.
+ */
+
+METHODDEF void
+null_method (j_compress_ptr cinfo)
+{
+  /* no work needed */
+}
+
+
+/*
+ * Module initialization routine for input colorspace conversion.
+ */
+
+GLOBAL void
+jinit_color_converter (j_compress_ptr cinfo)
+{
+  my_cconvert_ptr cconvert;
+
+  cconvert = (my_cconvert_ptr)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				SIZEOF(my_color_converter));
+  cinfo->cconvert = (struct jpeg_color_converter *) cconvert;
+  /* set start_pass to null method until we find out differently */
+  cconvert->pub.start_pass = null_method;
+
+  /* Make sure input_components agrees with in_color_space */
+  switch (cinfo->in_color_space) {
+  case JCS_GRAYSCALE:
+    if (cinfo->input_components != 1)
+      ERREXIT(cinfo, JERR_BAD_IN_COLORSPACE);
+    break;
+
+  case JCS_RGB:
+#if RGB_PIXELSIZE != 3
+    if (cinfo->input_components != RGB_PIXELSIZE)
+      ERREXIT(cinfo, JERR_BAD_IN_COLORSPACE);
+    break;
+#endif /* else share code with YCbCr */
+
+  case JCS_YCbCr:
+    if (cinfo->input_components != 3)
+      ERREXIT(cinfo, JERR_BAD_IN_COLORSPACE);
+    break;
+
+  case JCS_CMYK:
+  case JCS_YCCK:
+    if (cinfo->input_components != 4)
+      ERREXIT(cinfo, JERR_BAD_IN_COLORSPACE);
+    break;
+
+  default:			/* JCS_UNKNOWN can be anything */
+    if (cinfo->input_components < 1)
+      ERREXIT(cinfo, JERR_BAD_IN_COLORSPACE);
+    break;
+  }
+
+  /* Check num_components, set conversion method based on requested space */
+  switch (cinfo->jpeg_color_space) {
+  case JCS_GRAYSCALE:
+    if (cinfo->num_components != 1)
+      ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
+    if (cinfo->in_color_space == JCS_GRAYSCALE)
+      cconvert->pub.color_convert = grayscale_convert;
+    else if (cinfo->in_color_space == JCS_RGB) {
+      cconvert->pub.start_pass = rgb_ycc_start;
+      cconvert->pub.color_convert = rgb_gray_convert;
+    } else if (cinfo->in_color_space == JCS_YCbCr)
+      cconvert->pub.color_convert = grayscale_convert;
+    else
+      ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
+    break;
+
+  case JCS_RGB:
+    if (cinfo->num_components != 3)
+      ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
+    if (cinfo->in_color_space == JCS_RGB && RGB_PIXELSIZE == 3)
+      cconvert->pub.color_convert = null_convert;
+    else
+      ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
+    break;
+
+  case JCS_YCbCr:
+    if (cinfo->num_components != 3)
+      ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
+    if (cinfo->in_color_space == JCS_RGB) {
+      cconvert->pub.start_pass = rgb_ycc_start;
+      cconvert->pub.color_convert = rgb_ycc_convert;
+    } else if (cinfo->in_color_space == JCS_YCbCr)
+      cconvert->pub.color_convert = null_convert;
+    else
+      ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
+    break;
+
+  case JCS_CMYK:
+    if (cinfo->num_components != 4)
+      ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
+    if (cinfo->in_color_space == JCS_CMYK)
+      cconvert->pub.color_convert = null_convert;
+    else
+      ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
+    break;
+
+  case JCS_YCCK:
+    if (cinfo->num_components != 4)
+      ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
+    if (cinfo->in_color_space == JCS_CMYK) {
+      cconvert->pub.start_pass = rgb_ycc_start;
+      cconvert->pub.color_convert = cmyk_ycck_convert;
+    } else if (cinfo->in_color_space == JCS_YCCK)
+      cconvert->pub.color_convert = null_convert;
+    else
+      ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
+    break;
+
+  default:			/* allow null conversion of JCS_UNKNOWN */
+    if (cinfo->jpeg_color_space != cinfo->in_color_space ||
+	cinfo->num_components != cinfo->input_components)
+      ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
+    cconvert->pub.color_convert = null_convert;
+    break;
+  }
+}
diff --git a/code/jpeg-6/jcdctmgr.cpp b/code/jpeg-6/jcdctmgr.cpp
new file mode 100644
index 0000000..0a8b1cc
--- /dev/null
+++ b/code/jpeg-6/jcdctmgr.cpp
@@ -0,0 +1,397 @@
+/*
+ * jcdctmgr.c
+ *
+ * Copyright (C) 1994-1995, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains the forward-DCT management logic.
+ * This code selects a particular DCT implementation to be used,
+ * and it performs related housekeeping chores including coefficient
+ * quantization.
+ */
+
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jdct.h"		/* Private declarations for DCT subsystem */
+
+
+/* Private subobject for this module */
+
+typedef struct {
+  struct jpeg_forward_dct pub;	/* public fields */
+
+  /* Pointer to the DCT routine actually in use */
+  forward_DCT_method_ptr do_dct;
+
+  /* The actual post-DCT divisors --- not identical to the quant table
+   * entries, because of scaling (especially for an unnormalized DCT).
+   * Each table is given in normal array order; note that this must
+   * be converted from the zigzag order of the quantization tables.
+   */
+  DCTELEM * divisors[NUM_QUANT_TBLS];
+
+#ifdef DCT_FLOAT_SUPPORTED
+  /* Same as above for the floating-point case. */
+  float_DCT_method_ptr do_float_dct;
+  FAST_FLOAT * float_divisors[NUM_QUANT_TBLS];
+#endif
+} my_fdct_controller;
+
+typedef my_fdct_controller * my_fdct_ptr;
+
+
+/*
+ * Initialize for a processing pass.
+ * Verify that all referenced Q-tables are present, and set up
+ * the divisor table for each one.
+ * In the current implementation, DCT of all components is done during
+ * the first pass, even if only some components will be output in the
+ * first scan.  Hence all components should be examined here.
+ */
+
+METHODDEF void
+start_pass_fdctmgr (j_compress_ptr cinfo)
+{
+  my_fdct_ptr fdct = (my_fdct_ptr) cinfo->fdct;
+  int ci, qtblno, i;
+  jpeg_component_info *compptr;
+  JQUANT_TBL * qtbl;
+#ifdef DCT_ISLOW_SUPPORTED
+  DCTELEM * dtbl;
+#endif
+
+  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+       ci++, compptr++) {
+    qtblno = compptr->quant_tbl_no;
+    /* Make sure specified quantization table is present */
+    if (qtblno < 0 || qtblno >= NUM_QUANT_TBLS ||
+	cinfo->quant_tbl_ptrs[qtblno] == NULL)
+      ERREXIT1(cinfo, JERR_NO_QUANT_TABLE, qtblno);
+    qtbl = cinfo->quant_tbl_ptrs[qtblno];
+    /* Compute divisors for this quant table */
+    /* We may do this more than once for same table, but it's not a big deal */
+    switch (cinfo->dct_method) {
+#ifdef DCT_ISLOW_SUPPORTED
+    case JDCT_ISLOW:
+      /* For LL&M IDCT method, divisors are equal to raw quantization
+       * coefficients multiplied by 8 (to counteract scaling).
+       */
+      if (fdct->divisors[qtblno] == NULL) {
+	fdct->divisors[qtblno] = (DCTELEM *)
+	  (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				      DCTSIZE2 * SIZEOF(DCTELEM));
+      }
+      dtbl = fdct->divisors[qtblno];
+      for (i = 0; i < DCTSIZE2; i++) {
+	dtbl[i] = ((DCTELEM) qtbl->quantval[jpeg_zigzag_order[i]]) << 3;
+      }
+      break;
+#endif
+#ifdef DCT_IFAST_SUPPORTED
+    case JDCT_IFAST:
+      {
+	/* For AA&N IDCT method, divisors are equal to quantization
+	 * coefficients scaled by scalefactor[row]*scalefactor[col], where
+	 *   scalefactor[0] = 1
+	 *   scalefactor[k] = cos(k*PI/16) * sqrt(2)    for k=1..7
+	 * We apply a further scale factor of 8.
+	 */
+#define CONST_BITS 14
+	static const INT16 aanscales[DCTSIZE2] = {
+	  /* precomputed values scaled up by 14 bits: in natural order */
+	  16384, 22725, 21407, 19266, 16384, 12873,  8867,  4520,
+	  22725, 31521, 29692, 26722, 22725, 17855, 12299,  6270,
+	  21407, 29692, 27969, 25172, 21407, 16819, 11585,  5906,
+	  19266, 26722, 25172, 22654, 19266, 15137, 10426,  5315,
+	  16384, 22725, 21407, 19266, 16384, 12873,  8867,  4520,
+	  12873, 17855, 16819, 15137, 12873, 10114,  6967,  3552,
+	   8867, 12299, 11585, 10426,  8867,  6967,  4799,  2446,
+	   4520,  6270,  5906,  5315,  4520,  3552,  2446,  1247
+	};
+	SHIFT_TEMPS
+
+	if (fdct->divisors[qtblno] == NULL) {
+	  fdct->divisors[qtblno] = (DCTELEM *)
+	    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+					DCTSIZE2 * SIZEOF(DCTELEM));
+	}
+	dtbl = fdct->divisors[qtblno];
+	for (i = 0; i < DCTSIZE2; i++) {
+	  dtbl[i] = (DCTELEM)
+	    DESCALE(MULTIPLY16V16((INT32) qtbl->quantval[jpeg_zigzag_order[i]],
+				  (INT32) aanscales[i]),
+		    CONST_BITS-3);
+	}
+      }
+      break;
+#endif
+#ifdef DCT_FLOAT_SUPPORTED
+    case JDCT_FLOAT:
+      {
+	/* For float AA&N IDCT method, divisors are equal to quantization
+	 * coefficients scaled by scalefactor[row]*scalefactor[col], where
+	 *   scalefactor[0] = 1
+	 *   scalefactor[k] = cos(k*PI/16) * sqrt(2)    for k=1..7
+	 * We apply a further scale factor of 8.
+	 * What's actually stored is 1/divisor so that the inner loop can
+	 * use a multiplication rather than a division.
+	 */
+	FAST_FLOAT * fdtbl;
+	int row, col;
+	static const double aanscalefactor[DCTSIZE] = {
+	  1.0, 1.387039845, 1.306562965, 1.175875602,
+	  1.0, 0.785694958, 0.541196100, 0.275899379
+	};
+
+	if (fdct->float_divisors[qtblno] == NULL) {
+	  fdct->float_divisors[qtblno] = (FAST_FLOAT *)
+	    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+					DCTSIZE2 * SIZEOF(FAST_FLOAT));
+	}
+	fdtbl = fdct->float_divisors[qtblno];
+	i = 0;
+	for (row = 0; row < DCTSIZE; row++) {
+	  for (col = 0; col < DCTSIZE; col++) {
+	    fdtbl[i] = (FAST_FLOAT)
+	      (1.0 / (((double) qtbl->quantval[jpeg_zigzag_order[i]] *
+		       aanscalefactor[row] * aanscalefactor[col] * 8.0)));
+	    i++;
+	  }
+	}
+      }
+      break;
+#endif
+    default:
+      ERREXIT(cinfo, JERR_NOT_COMPILED);
+      break;
+    }
+  }
+}
+
+
+/*
+ * Perform forward DCT on one or more blocks of a component.
+ *
+ * The input samples are taken from the sample_data[] array starting at
+ * position start_row/start_col, and moving to the right for any additional
+ * blocks. The quantized coefficients are returned in coef_blocks[].
+ */
+
+#if 0 // bk001204
+METHODDEF void
+forward_DCT (j_compress_ptr cinfo, jpeg_component_info * compptr,
+	     JSAMPARRAY sample_data, JBLOCKROW coef_blocks,
+	     JDIMENSION start_row, JDIMENSION start_col,
+	     JDIMENSION num_blocks)
+/* This version is used for integer DCT implementations. */
+{
+  /* This routine is heavily used, so it's worth coding it tightly. */
+  my_fdct_ptr fdct = (my_fdct_ptr) cinfo->fdct;
+  forward_DCT_method_ptr do_dct = fdct->do_dct;
+  DCTELEM * divisors = fdct->divisors[compptr->quant_tbl_no];
+  DCTELEM workspace[DCTSIZE2];	/* work area for FDCT subroutine */
+  JDIMENSION bi;
+
+  sample_data += start_row;	/* fold in the vertical offset once */
+
+  for (bi = 0; bi < num_blocks; bi++, start_col += DCTSIZE) {
+    /* Load data into workspace, applying unsigned->signed conversion */
+    { register DCTELEM *workspaceptr;
+      register JSAMPROW elemptr;
+      register int elemr;
+
+      workspaceptr = workspace;
+      for (elemr = 0; elemr < DCTSIZE; elemr++) {
+	elemptr = sample_data[elemr] + start_col;
+#if DCTSIZE == 8		/* unroll the inner loop */
+	*workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
+	*workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
+	*workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
+	*workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
+	*workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
+	*workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
+	*workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
+	*workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
+#else
+	{ register int elemc;
+	  for (elemc = DCTSIZE; elemc > 0; elemc--) {
+	    *workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
+	  }
+	}
+#endif
+      }
+    }
+
+    /* Perform the DCT */
+    (*do_dct) (workspace);
+
+    /* Quantize/descale the coefficients, and store into coef_blocks[] */
+    { register DCTELEM temp, qval;
+      register int i;
+      register JCOEFPTR output_ptr = coef_blocks[bi];
+
+      for (i = 0; i < DCTSIZE2; i++) {
+	qval = divisors[i];
+	temp = workspace[i];
+	/* Divide the coefficient value by qval, ensuring proper rounding.
+	 * Since C does not specify the direction of rounding for negative
+	 * quotients, we have to force the dividend positive for portability.
+	 *
+	 * In most files, at least half of the output values will be zero
+	 * (at default quantization settings, more like three-quarters...)
+	 * so we should ensure that this case is fast.  On many machines,
+	 * a comparison is enough cheaper than a divide to make a special test
+	 * a win.  Since both inputs will be nonnegative, we need only test
+	 * for a < b to discover whether a/b is 0.
+	 * If your machine's division is fast enough, define FAST_DIVIDE.
+	 */
+#ifdef FAST_DIVIDE
+#define DIVIDE_BY(a,b)	a /= b
+#else
+#define DIVIDE_BY(a,b)	if (a >= b) a /= b; else a = 0
+#endif
+	if (temp < 0) {
+	  temp = -temp;
+	  temp += qval>>1;	/* for rounding */
+	  DIVIDE_BY(temp, qval);
+	  temp = -temp;
+	} else {
+	  temp += qval>>1;	/* for rounding */
+	  DIVIDE_BY(temp, qval);
+	}
+	output_ptr[i] = (JCOEF) temp;
+      }
+    }
+  }
+}
+#endif // 0
+
+#ifdef DCT_FLOAT_SUPPORTED
+
+METHODDEF void
+forward_DCT_float (j_compress_ptr cinfo, jpeg_component_info * compptr,
+		   JSAMPARRAY sample_data, JBLOCKROW coef_blocks,
+		   JDIMENSION start_row, JDIMENSION start_col,
+		   JDIMENSION num_blocks)
+/* This version is used for floating-point DCT implementations. */
+{
+  /* This routine is heavily used, so it's worth coding it tightly. */
+  my_fdct_ptr fdct = (my_fdct_ptr) cinfo->fdct;
+  float_DCT_method_ptr do_dct = fdct->do_float_dct;
+  FAST_FLOAT * divisors = fdct->float_divisors[compptr->quant_tbl_no];
+  FAST_FLOAT workspace[DCTSIZE2]; /* work area for FDCT subroutine */
+  JDIMENSION bi;
+
+  sample_data += start_row;	/* fold in the vertical offset once */
+
+  for (bi = 0; bi < num_blocks; bi++, start_col += DCTSIZE) {
+    /* Load data into workspace, applying unsigned->signed conversion */
+    { register FAST_FLOAT *workspaceptr;
+      register JSAMPROW elemptr;
+      register int elemr;
+
+      workspaceptr = workspace;
+      for (elemr = 0; elemr < DCTSIZE; elemr++) {
+	elemptr = sample_data[elemr] + start_col;
+#if DCTSIZE == 8		/* unroll the inner loop */
+	*workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
+	*workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
+	*workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
+	*workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
+	*workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
+	*workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
+	*workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
+	*workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
+#else
+	{ register int elemc;
+	  for (elemc = DCTSIZE; elemc > 0; elemc--) {
+	    *workspaceptr++ = (FAST_FLOAT)
+	      (GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
+	  }
+	}
+#endif
+      }
+    }
+
+    /* Perform the DCT */
+    (*do_dct) (workspace);
+
+    /* Quantize/descale the coefficients, and store into coef_blocks[] */
+    { register FAST_FLOAT temp;
+      register int i;
+      register JCOEFPTR output_ptr = coef_blocks[bi];
+
+      for (i = 0; i < DCTSIZE2; i++) {
+	/* Apply the quantization and scaling factor */
+	temp = workspace[i] * divisors[i];
+	/* Round to nearest integer.
+	 * Since C does not specify the direction of rounding for negative
+	 * quotients, we have to force the dividend positive for portability.
+	 * The maximum coefficient size is +-16K (for 12-bit data), so this
+	 * code should work for either 16-bit or 32-bit ints.
+	 */
+	output_ptr[i] = (JCOEF) ((int) (temp + (FAST_FLOAT) 16384.5) - 16384);
+      }
+    }
+  }
+}
+
+#endif /* DCT_FLOAT_SUPPORTED */
+
+
+/*
+ * Initialize FDCT manager.
+ */
+
+GLOBAL void
+jinit_forward_dct (j_compress_ptr cinfo)
+{
+  my_fdct_ptr fdct;
+  int i;
+
+  fdct = (my_fdct_ptr)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				SIZEOF(my_fdct_controller));
+  cinfo->fdct = (struct jpeg_forward_dct *) fdct;
+  fdct->pub.start_pass = start_pass_fdctmgr;
+
+  switch (cinfo->dct_method) {
+#ifdef DCT_ISLOW_SUPPORTED
+  case JDCT_ISLOW:
+    fdct->pub.forward_DCT = forward_DCT;
+    fdct->do_dct = jpeg_fdct_islow;
+    break;
+#endif
+#ifdef DCT_IFAST_SUPPORTED
+  case JDCT_IFAST:
+    fdct->pub.forward_DCT = forward_DCT;
+    fdct->do_dct = jpeg_fdct_ifast;
+    break;
+#endif
+#ifdef DCT_FLOAT_SUPPORTED
+  case JDCT_FLOAT:
+    fdct->pub.forward_DCT = forward_DCT_float;
+    fdct->do_float_dct = jpeg_fdct_float;
+    break;
+#endif
+  default:
+    ERREXIT(cinfo, JERR_NOT_COMPILED);
+    break;
+  }
+
+  /* Mark divisor tables unallocated */
+  for (i = 0; i < NUM_QUANT_TBLS; i++) {
+    fdct->divisors[i] = NULL;
+#ifdef DCT_FLOAT_SUPPORTED
+    fdct->float_divisors[i] = NULL;
+#endif
+  }
+}
diff --git a/code/jpeg-6/jchuff.cpp b/code/jpeg-6/jchuff.cpp
new file mode 100644
index 0000000..2950660
--- /dev/null
+++ b/code/jpeg-6/jchuff.cpp
@@ -0,0 +1,853 @@
+/*
+ * jchuff.c
+ *
+ * Copyright (C) 1991-1995, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains Huffman entropy encoding routines.
+ *
+ * Much of the complexity here has to do with supporting output suspension.
+ * If the data destination module demands suspension, we want to be able to
+ * back up to the start of the current MCU.  To do this, we copy state
+ * variables into local working storage, and update them back to the
+ * permanent JPEG objects only upon successful completion of an MCU.
+ */
+
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+
+
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jchuff.h"		/* Declarations shared with jcphuff.c */
+
+
+/* Expanded entropy encoder object for Huffman encoding.
+ *
+ * The savable_state subrecord contains fields that change within an MCU,
+ * but must not be updated permanently until we complete the MCU.
+ */
+
+typedef struct {
+  INT32 put_buffer;		/* current bit-accumulation buffer */
+  int put_bits;			/* # of bits now in it */
+  int last_dc_val[MAX_COMPS_IN_SCAN]; /* last DC coef for each component */
+} savable_state;
+
+/* This macro is to work around compilers with missing or broken
+ * structure assignment.  You'll need to fix this code if you have
+ * such a compiler and you change MAX_COMPS_IN_SCAN.
+ */
+
+#ifndef NO_STRUCT_ASSIGN
+#define ASSIGN_STATE(dest,src)  ((dest) = (src))
+#else
+#if MAX_COMPS_IN_SCAN == 4
+#define ASSIGN_STATE(dest,src)  \
+	((dest).put_buffer = (src).put_buffer, \
+	 (dest).put_bits = (src).put_bits, \
+	 (dest).last_dc_val[0] = (src).last_dc_val[0], \
+	 (dest).last_dc_val[1] = (src).last_dc_val[1], \
+	 (dest).last_dc_val[2] = (src).last_dc_val[2], \
+	 (dest).last_dc_val[3] = (src).last_dc_val[3])
+#endif
+#endif
+
+
+typedef struct {
+  struct jpeg_entropy_encoder pub; /* public fields */
+
+  savable_state saved;		/* Bit buffer & DC state at start of MCU */
+
+  /* These fields are NOT loaded into local working state. */
+  unsigned int restarts_to_go;	/* MCUs left in this restart interval */
+  int next_restart_num;		/* next restart number to write (0-7) */
+
+  /* Pointers to derived tables (these workspaces have image lifespan) */
+  c_derived_tbl * dc_derived_tbls[NUM_HUFF_TBLS];
+  c_derived_tbl * ac_derived_tbls[NUM_HUFF_TBLS];
+
+#ifdef ENTROPY_OPT_SUPPORTED	/* Statistics tables for optimization */
+  long * dc_count_ptrs[NUM_HUFF_TBLS];
+  long * ac_count_ptrs[NUM_HUFF_TBLS];
+#endif
+} huff_entropy_encoder;
+
+typedef huff_entropy_encoder * huff_entropy_ptr;
+
+/* Working state while writing an MCU.
+ * This struct contains all the fields that are needed by subroutines.
+ */
+
+typedef struct {
+  JOCTET * next_output_byte;	/* => next byte to write in buffer */
+  size_t free_in_buffer;	/* # of byte spaces remaining in buffer */
+  savable_state cur;		/* Current bit buffer & DC state */
+  j_compress_ptr cinfo;		/* dump_buffer needs access to this */
+} working_state;
+
+
+/* Forward declarations */
+METHODDEF boolean encode_mcu_huff JPP((j_compress_ptr cinfo,
+				       JBLOCKROW *MCU_data));
+METHODDEF void finish_pass_huff JPP((j_compress_ptr cinfo));
+#ifdef ENTROPY_OPT_SUPPORTED
+METHODDEF boolean encode_mcu_gather JPP((j_compress_ptr cinfo,
+					 JBLOCKROW *MCU_data));
+METHODDEF void finish_pass_gather JPP((j_compress_ptr cinfo));
+#endif
+
+
+/*
+ * Initialize for a Huffman-compressed scan.
+ * If gather_statistics is TRUE, we do not output anything during the scan,
+ * just count the Huffman symbols used and generate Huffman code tables.
+ */
+
+METHODDEF void
+start_pass_huff (j_compress_ptr cinfo, boolean gather_statistics)
+{
+  huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
+  int ci, dctbl, actbl;
+  jpeg_component_info * compptr;
+
+  if (gather_statistics) {
+#ifdef ENTROPY_OPT_SUPPORTED
+    entropy->pub.encode_mcu = encode_mcu_gather;
+    entropy->pub.finish_pass = finish_pass_gather;
+#else
+    ERREXIT(cinfo, JERR_NOT_COMPILED);
+#endif
+  } else {
+    entropy->pub.encode_mcu = encode_mcu_huff;
+    entropy->pub.finish_pass = finish_pass_huff;
+  }
+
+  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+    compptr = cinfo->cur_comp_info[ci];
+    dctbl = compptr->dc_tbl_no;
+    actbl = compptr->ac_tbl_no;
+    /* Make sure requested tables are present */
+    /* (In gather mode, tables need not be allocated yet) */
+    if (dctbl < 0 || dctbl >= NUM_HUFF_TBLS ||
+	(cinfo->dc_huff_tbl_ptrs[dctbl] == NULL && !gather_statistics))
+      ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, dctbl);
+    if (actbl < 0 || actbl >= NUM_HUFF_TBLS ||
+	(cinfo->ac_huff_tbl_ptrs[actbl] == NULL && !gather_statistics))
+      ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, actbl);
+    if (gather_statistics) {
+#ifdef ENTROPY_OPT_SUPPORTED
+      /* Allocate and zero the statistics tables */
+      /* Note that jpeg_gen_optimal_table expects 257 entries in each table! */
+      if (entropy->dc_count_ptrs[dctbl] == NULL)
+	entropy->dc_count_ptrs[dctbl] = (long *)
+	  (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				      257 * SIZEOF(long));
+      MEMZERO(entropy->dc_count_ptrs[dctbl], 257 * SIZEOF(long));
+      if (entropy->ac_count_ptrs[actbl] == NULL)
+	entropy->ac_count_ptrs[actbl] = (long *)
+	  (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				      257 * SIZEOF(long));
+      MEMZERO(entropy->ac_count_ptrs[actbl], 257 * SIZEOF(long));
+#endif
+    } else {
+      /* Compute derived values for Huffman tables */
+      /* We may do this more than once for a table, but it's not expensive */
+      jpeg_make_c_derived_tbl(cinfo, cinfo->dc_huff_tbl_ptrs[dctbl],
+			      & entropy->dc_derived_tbls[dctbl]);
+      jpeg_make_c_derived_tbl(cinfo, cinfo->ac_huff_tbl_ptrs[actbl],
+			      & entropy->ac_derived_tbls[actbl]);
+    }
+    /* Initialize DC predictions to 0 */
+    entropy->saved.last_dc_val[ci] = 0;
+  }
+
+  /* Initialize bit buffer to empty */
+  entropy->saved.put_buffer = 0;
+  entropy->saved.put_bits = 0;
+
+  /* Initialize restart stuff */
+  entropy->restarts_to_go = cinfo->restart_interval;
+  entropy->next_restart_num = 0;
+}
+
+
+/*
+ * Compute the derived values for a Huffman table.
+ * Note this is also used by jcphuff.c.
+ */
+
+GLOBAL void
+jpeg_make_c_derived_tbl (j_compress_ptr cinfo, JHUFF_TBL * htbl,
+			 c_derived_tbl ** pdtbl)
+{
+  c_derived_tbl *dtbl;
+  int p, i, l, lastp, si;
+  char huffsize[257];
+  unsigned int huffcode[257];
+  unsigned int code;
+
+  /* Allocate a workspace if we haven't already done so. */
+  if (*pdtbl == NULL)
+    *pdtbl = (c_derived_tbl *)
+      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				  SIZEOF(c_derived_tbl));
+  dtbl = *pdtbl;
+  
+  /* Figure C.1: make table of Huffman code length for each symbol */
+  /* Note that this is in code-length order. */
+
+  p = 0;
+  for (l = 1; l <= 16; l++) {
+    for (i = 1; i <= (int) htbl->bits[l]; i++)
+      huffsize[p++] = (char) l;
+  }
+  huffsize[p] = 0;
+  lastp = p;
+  
+  /* Figure C.2: generate the codes themselves */
+  /* Note that this is in code-length order. */
+  
+  code = 0;
+  si = huffsize[0];
+  p = 0;
+  while (huffsize[p]) {
+    while (((int) huffsize[p]) == si) {
+      huffcode[p++] = code;
+      code++;
+    }
+    code <<= 1;
+    si++;
+  }
+  
+  /* Figure C.3: generate encoding tables */
+  /* These are code and size indexed by symbol value */
+
+  /* Set any codeless symbols to have code length 0;
+   * this allows emit_bits to detect any attempt to emit such symbols.
+   */
+  MEMZERO(dtbl->ehufsi, SIZEOF(dtbl->ehufsi));
+
+  for (p = 0; p < lastp; p++) {
+    dtbl->ehufco[htbl->huffval[p]] = huffcode[p];
+    dtbl->ehufsi[htbl->huffval[p]] = huffsize[p];
+  }
+}
+
+
+/* Outputting bytes to the file */
+
+/* Emit a byte, taking 'action' if must suspend. */
+#define emit_byte(state,val,action)  \
+	{ *(state)->next_output_byte++ = (JOCTET) (val);  \
+	  if (--(state)->free_in_buffer == 0)  \
+	    if (! dump_buffer(state))  \
+	      { action; } }
+
+
+LOCAL boolean
+dump_buffer (working_state * state)
+/* Empty the output buffer; return TRUE if successful, FALSE if must suspend */
+{
+  struct jpeg_destination_mgr * dest = state->cinfo->dest;
+
+  if (! (*dest->empty_output_buffer) (state->cinfo))
+    return FALSE;
+  /* After a successful buffer dump, must reset buffer pointers */
+  state->next_output_byte = dest->next_output_byte;
+  state->free_in_buffer = dest->free_in_buffer;
+  return TRUE;
+}
+
+
+/* Outputting bits to the file */
+
+/* Only the right 24 bits of put_buffer are used; the valid bits are
+ * left-justified in this part.  At most 16 bits can be passed to emit_bits
+ * in one call, and we never retain more than 7 bits in put_buffer
+ * between calls, so 24 bits are sufficient.
+ */
+
+INLINE
+LOCAL boolean
+emit_bits (working_state * state, unsigned int code, int size)
+/* Emit some bits; return TRUE if successful, FALSE if must suspend */
+{
+  /* This routine is heavily used, so it's worth coding tightly. */
+  register INT32 put_buffer = (INT32) code;
+  register int put_bits = state->cur.put_bits;
+
+  /* if size is 0, caller used an invalid Huffman table entry */
+  if (size == 0)
+    ERREXIT(state->cinfo, JERR_HUFF_MISSING_CODE);
+
+  put_buffer &= (((INT32) 1)<<size) - 1; /* mask off any extra bits in code */
+  
+  put_bits += size;		/* new number of bits in buffer */
+  
+  put_buffer <<= 24 - put_bits; /* align incoming bits */
+
+  put_buffer |= state->cur.put_buffer; /* and merge with old buffer contents */
+  
+  while (put_bits >= 8) {
+    int c = (int) ((put_buffer >> 16) & 0xFF);
+    
+    emit_byte(state, c, return FALSE);
+    if (c == 0xFF) {		/* need to stuff a zero byte? */
+      emit_byte(state, 0, return FALSE);
+    }
+    put_buffer <<= 8;
+    put_bits -= 8;
+  }
+
+  state->cur.put_buffer = put_buffer; /* update state variables */
+  state->cur.put_bits = put_bits;
+
+  return TRUE;
+}
+
+
+LOCAL boolean
+flush_bits (working_state * state)
+{
+  if (! emit_bits(state, 0x7F, 7)) /* fill any partial byte with ones */
+    return FALSE;
+  state->cur.put_buffer = 0;	/* and reset bit-buffer to empty */
+  state->cur.put_bits = 0;
+  return TRUE;
+}
+
+
+/* Encode a single block's worth of coefficients */
+
+LOCAL boolean
+encode_one_block (working_state * state, JCOEFPTR block, int last_dc_val,
+		  c_derived_tbl *dctbl, c_derived_tbl *actbl)
+{
+  register int temp, temp2;
+  register int nbits;
+  register int k, r, i;
+  
+  /* Encode the DC coefficient difference per section F.1.2.1 */
+  
+  temp = temp2 = block[0] - last_dc_val;
+
+  if (temp < 0) {
+    temp = -temp;		/* temp is abs value of input */
+    /* For a negative input, want temp2 = bitwise complement of abs(input) */
+    /* This code assumes we are on a two's complement machine */
+    temp2--;
+  }
+  
+  /* Find the number of bits needed for the magnitude of the coefficient */
+  nbits = 0;
+  while (temp) {
+    nbits++;
+    temp >>= 1;
+  }
+  
+  /* Emit the Huffman-coded symbol for the number of bits */
+  if (! emit_bits(state, dctbl->ehufco[nbits], dctbl->ehufsi[nbits]))
+    return FALSE;
+
+  /* Emit that number of bits of the value, if positive, */
+  /* or the complement of its magnitude, if negative. */
+  if (nbits)			/* emit_bits rejects calls with size 0 */
+    if (! emit_bits(state, (unsigned int) temp2, nbits))
+      return FALSE;
+
+  /* Encode the AC coefficients per section F.1.2.2 */
+  
+  r = 0;			/* r = run length of zeros */
+  
+  for (k = 1; k < DCTSIZE2; k++) {
+    if ((temp = block[jpeg_natural_order[k]]) == 0) {
+      r++;
+    } else {
+      /* if run length > 15, must emit special run-length-16 codes (0xF0) */
+      while (r > 15) {
+	if (! emit_bits(state, actbl->ehufco[0xF0], actbl->ehufsi[0xF0]))
+	  return FALSE;
+	r -= 16;
+      }
+
+      temp2 = temp;
+      if (temp < 0) {
+	temp = -temp;		/* temp is abs value of input */
+	/* This code assumes we are on a two's complement machine */
+	temp2--;
+      }
+      
+      /* Find the number of bits needed for the magnitude of the coefficient */
+      nbits = 1;		/* there must be at least one 1 bit */
+      while ((temp >>= 1))
+	nbits++;
+      
+      /* Emit Huffman symbol for run length / number of bits */
+      i = (r << 4) + nbits;
+      if (! emit_bits(state, actbl->ehufco[i], actbl->ehufsi[i]))
+	return FALSE;
+
+      /* Emit that number of bits of the value, if positive, */
+      /* or the complement of its magnitude, if negative. */
+      if (! emit_bits(state, (unsigned int) temp2, nbits))
+	return FALSE;
+      
+      r = 0;
+    }
+  }
+
+  /* If the last coef(s) were zero, emit an end-of-block code */
+  if (r > 0)
+    if (! emit_bits(state, actbl->ehufco[0], actbl->ehufsi[0]))
+      return FALSE;
+
+  return TRUE;
+}
+
+
+/*
+ * Emit a restart marker & resynchronize predictions.
+ */
+
+LOCAL boolean
+emit_restart (working_state * state, int restart_num)
+{
+  int ci;
+
+  if (! flush_bits(state))
+    return FALSE;
+
+  emit_byte(state, 0xFF, return FALSE);
+  emit_byte(state, JPEG_RST0 + restart_num, return FALSE);
+
+  /* Re-initialize DC predictions to 0 */
+  for (ci = 0; ci < state->cinfo->comps_in_scan; ci++)
+    state->cur.last_dc_val[ci] = 0;
+
+  /* The restart counter is not updated until we successfully write the MCU. */
+
+  return TRUE;
+}
+
+
+/*
+ * Encode and output one MCU's worth of Huffman-compressed coefficients.
+ */
+
+METHODDEF boolean
+encode_mcu_huff (j_compress_ptr cinfo, JBLOCKROW *MCU_data)
+{
+  huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
+  working_state state;
+  int blkn, ci;
+  jpeg_component_info * compptr;
+
+  /* Load up working state */
+  state.next_output_byte = cinfo->dest->next_output_byte;
+  state.free_in_buffer = cinfo->dest->free_in_buffer;
+  ASSIGN_STATE(state.cur, entropy->saved);
+  state.cinfo = cinfo;
+
+  /* Emit restart marker if needed */
+  if (cinfo->restart_interval) {
+    if (entropy->restarts_to_go == 0)
+      if (! emit_restart(&state, entropy->next_restart_num))
+	return FALSE;
+  }
+
+  /* Encode the MCU data blocks */
+  for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
+    ci = cinfo->MCU_membership[blkn];
+    compptr = cinfo->cur_comp_info[ci];
+    if (! encode_one_block(&state,
+			   MCU_data[blkn][0], state.cur.last_dc_val[ci],
+			   entropy->dc_derived_tbls[compptr->dc_tbl_no],
+			   entropy->ac_derived_tbls[compptr->ac_tbl_no]))
+      return FALSE;
+    /* Update last_dc_val */
+    state.cur.last_dc_val[ci] = MCU_data[blkn][0][0];
+  }
+
+  /* Completed MCU, so update state */
+  cinfo->dest->next_output_byte = state.next_output_byte;
+  cinfo->dest->free_in_buffer = state.free_in_buffer;
+  ASSIGN_STATE(entropy->saved, state.cur);
+
+  /* Update restart-interval state too */
+  if (cinfo->restart_interval) {
+    if (entropy->restarts_to_go == 0) {
+      entropy->restarts_to_go = cinfo->restart_interval;
+      entropy->next_restart_num++;
+      entropy->next_restart_num &= 7;
+    }
+    entropy->restarts_to_go--;
+  }
+
+  return TRUE;
+}
+
+
+/*
+ * Finish up at the end of a Huffman-compressed scan.
+ */
+
+METHODDEF void
+finish_pass_huff (j_compress_ptr cinfo)
+{
+  huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
+  working_state state;
+
+  /* Load up working state ... flush_bits needs it */
+  state.next_output_byte = cinfo->dest->next_output_byte;
+  state.free_in_buffer = cinfo->dest->free_in_buffer;
+  ASSIGN_STATE(state.cur, entropy->saved);
+  state.cinfo = cinfo;
+
+  /* Flush out the last data */
+  if (! flush_bits(&state))
+    ERREXIT(cinfo, JERR_CANT_SUSPEND);
+
+  /* Update state */
+  cinfo->dest->next_output_byte = state.next_output_byte;
+  cinfo->dest->free_in_buffer = state.free_in_buffer;
+  ASSIGN_STATE(entropy->saved, state.cur);
+}
+
+
+/*
+ * Huffman coding optimization.
+ *
+ * This actually is optimization, in the sense that we find the best possible
+ * Huffman table(s) for the given data.  We first scan the supplied data and
+ * count the number of uses of each symbol that is to be Huffman-coded.
+ * (This process must agree with the code above.)  Then we build an
+ * optimal Huffman coding tree for the observed counts.
+ *
+ * The JPEG standard requires Huffman codes to be no more than 16 bits long.
+ * If some symbols have a very small but nonzero probability, the Huffman tree
+ * must be adjusted to meet the code length restriction.  We currently use
+ * the adjustment method suggested in the JPEG spec.  This method is *not*
+ * optimal; it may not choose the best possible limited-length code.  But
+ * since the symbols involved are infrequently used, it's not clear that
+ * going to extra trouble is worthwhile.
+ */
+
+#ifdef ENTROPY_OPT_SUPPORTED
+
+
+/* Process a single block's worth of coefficients */
+
+LOCAL void
+htest_one_block (JCOEFPTR block, int last_dc_val,
+		 long dc_counts[], long ac_counts[])
+{
+  register int temp;
+  register int nbits;
+  register int k, r;
+  
+  /* Encode the DC coefficient difference per section F.1.2.1 */
+  
+  temp = block[0] - last_dc_val;
+  if (temp < 0)
+    temp = -temp;
+  
+  /* Find the number of bits needed for the magnitude of the coefficient */
+  nbits = 0;
+  while (temp) {
+    nbits++;
+    temp >>= 1;
+  }
+
+  /* Count the Huffman symbol for the number of bits */
+  dc_counts[nbits]++;
+  
+  /* Encode the AC coefficients per section F.1.2.2 */
+  
+  r = 0;			/* r = run length of zeros */
+  
+  for (k = 1; k < DCTSIZE2; k++) {
+    if ((temp = block[jpeg_natural_order[k]]) == 0) {
+      r++;
+    } else {
+      /* if run length > 15, must emit special run-length-16 codes (0xF0) */
+      while (r > 15) {
+	ac_counts[0xF0]++;
+	r -= 16;
+      }
+      
+      /* Find the number of bits needed for the magnitude of the coefficient */
+      if (temp < 0)
+	temp = -temp;
+      
+      /* Find the number of bits needed for the magnitude of the coefficient */
+      nbits = 1;		/* there must be at least one 1 bit */
+      while ((temp >>= 1))
+	nbits++;
+      
+      /* Count Huffman symbol for run length / number of bits */
+      ac_counts[(r << 4) + nbits]++;
+      
+      r = 0;
+    }
+  }
+
+  /* If the last coef(s) were zero, emit an end-of-block code */
+  if (r > 0)
+    ac_counts[0]++;
+}
+
+
+/*
+ * Trial-encode one MCU's worth of Huffman-compressed coefficients.
+ * No data is actually output, so no suspension return is possible.
+ */
+
+METHODDEF boolean
+encode_mcu_gather (j_compress_ptr cinfo, JBLOCKROW *MCU_data)
+{
+  huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
+  int blkn, ci;
+  jpeg_component_info * compptr;
+
+  /* Take care of restart intervals if needed */
+  if (cinfo->restart_interval) {
+    if (entropy->restarts_to_go == 0) {
+      /* Re-initialize DC predictions to 0 */
+      for (ci = 0; ci < cinfo->comps_in_scan; ci++)
+	entropy->saved.last_dc_val[ci] = 0;
+      /* Update restart state */
+      entropy->restarts_to_go = cinfo->restart_interval;
+    }
+    entropy->restarts_to_go--;
+  }
+
+  for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
+    ci = cinfo->MCU_membership[blkn];
+    compptr = cinfo->cur_comp_info[ci];
+    htest_one_block(MCU_data[blkn][0], entropy->saved.last_dc_val[ci],
+		    entropy->dc_count_ptrs[compptr->dc_tbl_no],
+		    entropy->ac_count_ptrs[compptr->ac_tbl_no]);
+    entropy->saved.last_dc_val[ci] = MCU_data[blkn][0][0];
+  }
+
+  return TRUE;
+}
+
+
+/*
+ * Generate the optimal coding for the given counts, fill htbl.
+ * Note this is also used by jcphuff.c.
+ */
+
+GLOBAL void
+jpeg_gen_optimal_table (j_compress_ptr cinfo, JHUFF_TBL * htbl, long freq[])
+{
+#define MAX_CLEN 32		/* assumed maximum initial code length */
+  UINT8 bits[MAX_CLEN+1];	/* bits[k] = # of symbols with code length k */
+  int codesize[257];		/* codesize[k] = code length of symbol k */
+  int others[257];		/* next symbol in current branch of tree */
+  int c1, c2;
+  int p, i, j;
+  long v;
+
+  /* This algorithm is explained in section K.2 of the JPEG standard */
+
+  MEMZERO(bits, SIZEOF(bits));
+  MEMZERO(codesize, SIZEOF(codesize));
+  for (i = 0; i < 257; i++)
+    others[i] = -1;		/* init links to empty */
+  
+  freq[256] = 1;		/* make sure there is a nonzero count */
+  /* Including the pseudo-symbol 256 in the Huffman procedure guarantees
+   * that no real symbol is given code-value of all ones, because 256
+   * will be placed in the largest codeword category.
+   */
+
+  /* Huffman's basic algorithm to assign optimal code lengths to symbols */
+
+  for (;;) {
+    /* Find the smallest nonzero frequency, set c1 = its symbol */
+    /* In case of ties, take the larger symbol number */
+    c1 = -1;
+    v = 1000000000L;
+    for (i = 0; i <= 256; i++) {
+      if (freq[i] && freq[i] <= v) {
+	v = freq[i];
+	c1 = i;
+      }
+    }
+
+    /* Find the next smallest nonzero frequency, set c2 = its symbol */
+    /* In case of ties, take the larger symbol number */
+    c2 = -1;
+    v = 1000000000L;
+    for (i = 0; i <= 256; i++) {
+      if (freq[i] && freq[i] <= v && i != c1) {
+	v = freq[i];
+	c2 = i;
+      }
+    }
+
+    /* Done if we've merged everything into one frequency */
+    if (c2 < 0)
+      break;
+    
+    /* Else merge the two counts/trees */
+    freq[c1] += freq[c2];
+    freq[c2] = 0;
+
+    /* Increment the codesize of everything in c1's tree branch */
+    codesize[c1]++;
+    while (others[c1] >= 0) {
+      c1 = others[c1];
+      codesize[c1]++;
+    }
+    
+    others[c1] = c2;		/* chain c2 onto c1's tree branch */
+    
+    /* Increment the codesize of everything in c2's tree branch */
+    codesize[c2]++;
+    while (others[c2] >= 0) {
+      c2 = others[c2];
+      codesize[c2]++;
+    }
+  }
+
+  /* Now count the number of symbols of each code length */
+  for (i = 0; i <= 256; i++) {
+    if (codesize[i]) {
+      /* The JPEG standard seems to think that this can't happen, */
+      /* but I'm paranoid... */
+      if (codesize[i] > MAX_CLEN)
+	ERREXIT(cinfo, JERR_HUFF_CLEN_OVERFLOW);
+
+      bits[codesize[i]]++;
+    }
+  }
+
+  /* JPEG doesn't allow symbols with code lengths over 16 bits, so if the pure
+   * Huffman procedure assigned any such lengths, we must adjust the coding.
+   * Here is what the JPEG spec says about how this next bit works:
+   * Since symbols are paired for the longest Huffman code, the symbols are
+   * removed from this length category two at a time.  The prefix for the pair
+   * (which is one bit shorter) is allocated to one of the pair; then,
+   * skipping the BITS entry for that prefix length, a code word from the next
+   * shortest nonzero BITS entry is converted into a prefix for two code words
+   * one bit longer.
+   */
+  
+  for (i = MAX_CLEN; i > 16; i--) {
+    while (bits[i] > 0) {
+      j = i - 2;		/* find length of new prefix to be used */
+      while (bits[j] == 0)
+	j--;
+      
+      bits[i] -= 2;		/* remove two symbols */
+      bits[i-1]++;		/* one goes in this length */
+      bits[j+1] += 2;		/* two new symbols in this length */
+      bits[j]--;		/* symbol of this length is now a prefix */
+    }
+  }
+
+  /* Remove the count for the pseudo-symbol 256 from the largest codelength */
+  while (bits[i] == 0)		/* find largest codelength still in use */
+    i--;
+  bits[i]--;
+  
+  /* Return final symbol counts (only for lengths 0..16) */
+  MEMCOPY(htbl->bits, bits, SIZEOF(htbl->bits));
+  
+  /* Return a list of the symbols sorted by code length */
+  /* It's not real clear to me why we don't need to consider the codelength
+   * changes made above, but the JPEG spec seems to think this works.
+   */
+  p = 0;
+  for (i = 1; i <= MAX_CLEN; i++) {
+    for (j = 0; j <= 255; j++) {
+      if (codesize[j] == i) {
+	htbl->huffval[p] = (UINT8) j;
+	p++;
+      }
+    }
+  }
+
+  /* Set sent_table FALSE so updated table will be written to JPEG file. */
+  htbl->sent_table = FALSE;
+}
+
+
+/*
+ * Finish up a statistics-gathering pass and create the new Huffman tables.
+ */
+
+METHODDEF void
+finish_pass_gather (j_compress_ptr cinfo)
+{
+  huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
+  int ci, dctbl, actbl;
+  jpeg_component_info * compptr;
+  JHUFF_TBL **htblptr;
+  boolean did_dc[NUM_HUFF_TBLS];
+  boolean did_ac[NUM_HUFF_TBLS];
+
+  /* It's important not to apply jpeg_gen_optimal_table more than once
+   * per table, because it clobbers the input frequency counts!
+   */
+  MEMZERO(did_dc, SIZEOF(did_dc));
+  MEMZERO(did_ac, SIZEOF(did_ac));
+
+  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+    compptr = cinfo->cur_comp_info[ci];
+    dctbl = compptr->dc_tbl_no;
+    actbl = compptr->ac_tbl_no;
+    if (! did_dc[dctbl]) {
+      htblptr = & cinfo->dc_huff_tbl_ptrs[dctbl];
+      if (*htblptr == NULL)
+	*htblptr = jpeg_alloc_huff_table((j_common_ptr) cinfo);
+      jpeg_gen_optimal_table(cinfo, *htblptr, entropy->dc_count_ptrs[dctbl]);
+      did_dc[dctbl] = TRUE;
+    }
+    if (! did_ac[actbl]) {
+      htblptr = & cinfo->ac_huff_tbl_ptrs[actbl];
+      if (*htblptr == NULL)
+	*htblptr = jpeg_alloc_huff_table((j_common_ptr) cinfo);
+      jpeg_gen_optimal_table(cinfo, *htblptr, entropy->ac_count_ptrs[actbl]);
+      did_ac[actbl] = TRUE;
+    }
+  }
+}
+
+
+#endif /* ENTROPY_OPT_SUPPORTED */
+
+
+/*
+ * Module initialization routine for Huffman entropy encoding.
+ */
+
+GLOBAL void
+jinit_huff_encoder (j_compress_ptr cinfo)
+{
+  huff_entropy_ptr entropy;
+  int i;
+
+  entropy = (huff_entropy_ptr)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				SIZEOF(huff_entropy_encoder));
+  cinfo->entropy = (struct jpeg_entropy_encoder *) entropy;
+  entropy->pub.start_pass = start_pass_huff;
+
+  /* Mark tables unallocated */
+  for (i = 0; i < NUM_HUFF_TBLS; i++) {
+    entropy->dc_derived_tbls[i] = entropy->ac_derived_tbls[i] = NULL;
+#ifdef ENTROPY_OPT_SUPPORTED
+    entropy->dc_count_ptrs[i] = entropy->ac_count_ptrs[i] = NULL;
+#endif
+  }
+}
diff --git a/code/jpeg-6/jchuff.h b/code/jpeg-6/jchuff.h
new file mode 100644
index 0000000..0a81d54
--- /dev/null
+++ b/code/jpeg-6/jchuff.h
@@ -0,0 +1,34 @@
+/*
+ * jchuff.h
+ *
+ * Copyright (C) 1991-1995, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains declarations for Huffman entropy encoding routines
+ * that are shared between the sequential encoder (jchuff.c) and the
+ * progressive encoder (jcphuff.c).  No other modules need to see these.
+ */
+
+/* Derived data constructed for each Huffman table */
+
+typedef struct {
+  unsigned int ehufco[256];	/* code for each symbol */
+  char ehufsi[256];		/* length of code for each symbol */
+  /* If no code has been allocated for a symbol S, ehufsi[S] contains 0 */
+} c_derived_tbl;
+
+/* Short forms of external names for systems with brain-damaged linkers. */
+
+#ifdef NEED_SHORT_EXTERNAL_NAMES
+#define jpeg_make_c_derived_tbl	jMkCDerived
+#define jpeg_gen_optimal_table	jGenOptTbl
+#endif /* NEED_SHORT_EXTERNAL_NAMES */
+
+/* Expand a Huffman table definition into the derived format */
+EXTERN void jpeg_make_c_derived_tbl JPP((j_compress_ptr cinfo,
+				JHUFF_TBL * htbl, c_derived_tbl ** pdtbl));
+
+/* Generate an optimal table definition given the specified counts */
+EXTERN void jpeg_gen_optimal_table JPP((j_compress_ptr cinfo,
+					JHUFF_TBL * htbl, long freq[]));
diff --git a/code/jpeg-6/jcinit.cpp b/code/jpeg-6/jcinit.cpp
new file mode 100644
index 0000000..b41a246
--- /dev/null
+++ b/code/jpeg-6/jcinit.cpp
@@ -0,0 +1,79 @@
+/*
+ * jcinit.c
+ *
+ * Copyright (C) 1991-1995, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains initialization logic for the JPEG compressor.
+ * This routine is in charge of selecting the modules to be executed and
+ * making an initialization call to each one.
+ *
+ * Logically, this code belongs in jcmaster.c.  It's split out because
+ * linking this routine implies linking the entire compression library.
+ * For a transcoding-only application, we want to be able to use jcmaster.c
+ * without linking in the whole library.
+ */
+
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+
+
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/*
+ * Master selection of compression modules.
+ * This is done once at the start of processing an image.  We determine
+ * which modules will be used and give them appropriate initialization calls.
+ */
+
+GLOBAL void
+jinit_compress_master (j_compress_ptr cinfo)
+{
+  /* Initialize master control (includes parameter checking/processing) */
+  jinit_c_master_control(cinfo, FALSE /* full compression */);
+
+  /* Preprocessing */
+  if (! cinfo->raw_data_in) {
+    jinit_color_converter(cinfo);
+    jinit_downsampler(cinfo);
+    jinit_c_prep_controller(cinfo, FALSE /* never need full buffer here */);
+  }
+  /* Forward DCT */
+  jinit_forward_dct(cinfo);
+  /* Entropy encoding: either Huffman or arithmetic coding. */
+  if (cinfo->arith_code) {
+    ERREXIT(cinfo, JERR_ARITH_NOTIMPL);
+  } else {
+    if (cinfo->progressive_mode) {
+#ifdef C_PROGRESSIVE_SUPPORTED
+      jinit_phuff_encoder(cinfo);
+#else
+      ERREXIT(cinfo, JERR_NOT_COMPILED);
+#endif
+    } else
+      jinit_huff_encoder(cinfo);
+  }
+
+  /* Need a full-image coefficient buffer in any multi-pass mode. */
+  jinit_c_coef_controller(cinfo,
+			  (cinfo->num_scans > 1 || cinfo->optimize_coding));
+  jinit_c_main_controller(cinfo, FALSE /* never need full buffer here */);
+
+  jinit_marker_writer(cinfo);
+
+  /* We can now tell the memory manager to allocate virtual arrays. */
+  (*cinfo->mem->realize_virt_arrays) ((j_common_ptr) cinfo);
+
+  /* Write the datastream header (SOI) immediately.
+   * Frame and scan headers are postponed till later.
+   * This lets application insert special markers after the SOI.
+   */
+  (*cinfo->marker->write_file_header) (cinfo);
+}
diff --git a/code/jpeg-6/jcmainct.cpp b/code/jpeg-6/jcmainct.cpp
new file mode 100644
index 0000000..1268802
--- /dev/null
+++ b/code/jpeg-6/jcmainct.cpp
@@ -0,0 +1,302 @@
+/*
+ * jcmainct.c
+ *
+ * Copyright (C) 1994-1995, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains the main buffer controller for compression.
+ * The main buffer lies between the pre-processor and the JPEG
+ * compressor proper; it holds downsampled data in the JPEG colorspace.
+ */
+
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/* Note: currently, there is no operating mode in which a full-image buffer
+ * is needed at this step.  If there were, that mode could not be used with
+ * "raw data" input, since this module is bypassed in that case.  However,
+ * we've left the code here for possible use in special applications.
+ */
+#undef FULL_MAIN_BUFFER_SUPPORTED
+
+
+/* Private buffer controller object */
+
+typedef struct {
+  struct jpeg_c_main_controller pub; /* public fields */
+
+  JDIMENSION cur_iMCU_row;	/* number of current iMCU row */
+  JDIMENSION rowgroup_ctr;	/* counts row groups received in iMCU row */
+  boolean suspended;		/* remember if we suspended output */
+  J_BUF_MODE pass_mode;		/* current operating mode */
+
+  /* If using just a strip buffer, this points to the entire set of buffers
+   * (we allocate one for each component).  In the full-image case, this
+   * points to the currently accessible strips of the virtual arrays.
+   */
+  JSAMPARRAY buffer[MAX_COMPONENTS];
+
+#ifdef FULL_MAIN_BUFFER_SUPPORTED
+  /* If using full-image storage, this array holds pointers to virtual-array
+   * control blocks for each component.  Unused if not full-image storage.
+   */
+  jvirt_sarray_ptr whole_image[MAX_COMPONENTS];
+#endif
+} my_main_controller;
+
+typedef my_main_controller * my_main_ptr;
+
+
+/* Forward declarations */
+METHODDEF void process_data_simple_main
+	JPP((j_compress_ptr cinfo, JSAMPARRAY input_buf,
+	     JDIMENSION *in_row_ctr, JDIMENSION in_rows_avail));
+#ifdef FULL_MAIN_BUFFER_SUPPORTED
+METHODDEF void process_data_buffer_main
+	JPP((j_compress_ptr cinfo, JSAMPARRAY input_buf,
+	     JDIMENSION *in_row_ctr, JDIMENSION in_rows_avail));
+#endif
+
+
+/*
+ * Initialize for a processing pass.
+ */
+
+METHODDEF void
+start_pass_main (j_compress_ptr cinfo, J_BUF_MODE pass_mode)
+{
+  // bk001204 - don't use main...
+  my_main_ptr jmain = (my_main_ptr) cinfo->main;
+
+  /* Do nothing in raw-data mode. */
+  if (cinfo->raw_data_in)
+    return;
+
+  jmain->cur_iMCU_row = 0;	/* initialize counters */
+  jmain->rowgroup_ctr = 0;
+  jmain->suspended = FALSE;
+  jmain->pass_mode = pass_mode;	/* save mode for use by process_data */
+
+  switch (pass_mode) {
+  case JBUF_PASS_THRU:
+#ifdef FULL_MAIN_BUFFER_SUPPORTED
+    if (jmain->whole_image[0] != NULL)
+      ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+#endif
+    jmain->pub.process_data = process_data_simple_main;
+    break;
+#ifdef FULL_MAIN_BUFFER_SUPPORTED
+  case JBUF_SAVE_SOURCE:
+  case JBUF_CRANK_DEST:
+  case JBUF_SAVE_AND_PASS:
+    if (jmain->whole_image[0] == NULL)
+      ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+    jmain->pub.process_data = process_data_buffer_main;
+    break;
+#endif
+  default:
+    ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+    break;
+  }
+}
+
+
+/*
+ * Process some data.
+ * This routine handles the simple pass-through mode,
+ * where we have only a strip buffer.
+ */
+
+METHODDEF void
+process_data_simple_main (j_compress_ptr cinfo,
+			  JSAMPARRAY input_buf, JDIMENSION *in_row_ctr,
+			  JDIMENSION in_rows_avail)
+{
+  // bk001204 - don't use main
+  my_main_ptr jmain = (my_main_ptr) cinfo->main;
+
+  while (jmain->cur_iMCU_row < cinfo->total_iMCU_rows) {
+    /* Read input data if we haven't filled the main buffer yet */
+    if (jmain->rowgroup_ctr < DCTSIZE)
+      (*cinfo->prep->pre_process_data) (cinfo,
+					input_buf, in_row_ctr, in_rows_avail,
+					jmain->buffer, &jmain->rowgroup_ctr,
+					(JDIMENSION) DCTSIZE);
+
+    /* If we don't have a full iMCU row buffered, return to application for
+     * more data.  Note that preprocessor will always pad to fill the iMCU row
+     * at the bottom of the image.
+     */
+    if (jmain->rowgroup_ctr != DCTSIZE)
+      return;
+
+    /* Send the completed row to the compressor */
+    if (! (*cinfo->coef->compress_data) (cinfo, jmain->buffer)) {
+      /* If compressor did not consume the whole row, then we must need to
+       * suspend processing and return to the application.  In this situation
+       * we pretend we didn't yet consume the last input row; otherwise, if
+       * it happened to be the last row of the image, the application would
+       * think we were done.
+       */
+      if (! jmain->suspended) {
+	(*in_row_ctr)--;
+	jmain->suspended = TRUE;
+      }
+      return;
+    }
+    /* We did finish the row.  Undo our little suspension hack if a previous
+     * call suspended; then mark the main buffer empty.
+     */
+    if (jmain->suspended) {
+      (*in_row_ctr)++;
+      jmain->suspended = FALSE;
+    }
+    jmain->rowgroup_ctr = 0;
+    jmain->cur_iMCU_row++;
+  }
+}
+
+
+#ifdef FULL_MAIN_BUFFER_SUPPORTED
+
+/*
+ * Process some data.
+ * This routine handles all of the modes that use a full-size buffer.
+ */
+
+METHODDEF void
+process_data_buffer_main (j_compress_ptr cinfo,
+			  JSAMPARRAY input_buf, JDIMENSION *in_row_ctr,
+			  JDIMENSION in_rows_avail)
+{
+  my_main_ptr main = (my_main_ptr) cinfo->main;
+  int ci;
+  jpeg_component_info *compptr;
+  boolean writing = (main->pass_mode != JBUF_CRANK_DEST);
+
+  while (main->cur_iMCU_row < cinfo->total_iMCU_rows) {
+    /* Realign the virtual buffers if at the start of an iMCU row. */
+    if (main->rowgroup_ctr == 0) {
+      for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+	   ci++, compptr++) {
+	main->buffer[ci] = (*cinfo->mem->access_virt_sarray)
+	  ((j_common_ptr) cinfo, main->whole_image[ci],
+	   main->cur_iMCU_row * (compptr->v_samp_factor * DCTSIZE),
+	   (JDIMENSION) (compptr->v_samp_factor * DCTSIZE), writing);
+      }
+      /* In a read pass, pretend we just read some source data. */
+      if (! writing) {
+	*in_row_ctr += cinfo->max_v_samp_factor * DCTSIZE;
+	main->rowgroup_ctr = DCTSIZE;
+      }
+    }
+
+    /* If a write pass, read input data until the current iMCU row is full. */
+    /* Note: preprocessor will pad if necessary to fill the last iMCU row. */
+    if (writing) {
+      (*cinfo->prep->pre_process_data) (cinfo,
+					input_buf, in_row_ctr, in_rows_avail,
+					main->buffer, &main->rowgroup_ctr,
+					(JDIMENSION) DCTSIZE);
+      /* Return to application if we need more data to fill the iMCU row. */
+      if (main->rowgroup_ctr < DCTSIZE)
+	return;
+    }
+
+    /* Emit data, unless this is a sink-only pass. */
+    if (main->pass_mode != JBUF_SAVE_SOURCE) {
+      if (! (*cinfo->coef->compress_data) (cinfo, main->buffer)) {
+	/* If compressor did not consume the whole row, then we must need to
+	 * suspend processing and return to the application.  In this situation
+	 * we pretend we didn't yet consume the last input row; otherwise, if
+	 * it happened to be the last row of the image, the application would
+	 * think we were done.
+	 */
+	if (! main->suspended) {
+	  (*in_row_ctr)--;
+	  main->suspended = TRUE;
+	}
+	return;
+      }
+      /* We did finish the row.  Undo our little suspension hack if a previous
+       * call suspended; then mark the main buffer empty.
+       */
+      if (main->suspended) {
+	(*in_row_ctr)++;
+	main->suspended = FALSE;
+      }
+    }
+
+    /* If get here, we are done with this iMCU row.  Mark buffer empty. */
+    main->rowgroup_ctr = 0;
+    main->cur_iMCU_row++;
+  }
+}
+
+#endif /* FULL_MAIN_BUFFER_SUPPORTED */
+
+
+/*
+ * Initialize main buffer controller.
+ */
+
+GLOBAL void
+jinit_c_main_controller (j_compress_ptr cinfo, boolean need_full_buffer)
+{
+  // bk001204 - don't use main
+  my_main_ptr jmain;
+  int ci;
+  jpeg_component_info *compptr;
+
+  jmain = (my_main_ptr)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				SIZEOF(my_main_controller));
+  cinfo->main = (struct jpeg_c_main_controller *) jmain;
+  jmain->pub.start_pass = start_pass_main;
+
+  /* We don't need to create a buffer in raw-data mode. */
+  if (cinfo->raw_data_in)
+    return;
+
+  /* Create the buffer.  It holds downsampled data, so each component
+   * may be of a different size.
+   */
+  if (need_full_buffer) {
+#ifdef FULL_MAIN_BUFFER_SUPPORTED
+    /* Allocate a full-image virtual array for each component */
+    /* Note we pad the bottom to a multiple of the iMCU height */
+    for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+	 ci++, compptr++) {
+      jmain->whole_image[ci] = (*cinfo->mem->request_virt_sarray)
+	((j_common_ptr) cinfo, JPOOL_IMAGE, FALSE,
+	 compptr->width_in_blocks * DCTSIZE,
+	 (JDIMENSION) jround_up((long) compptr->height_in_blocks,
+				(long) compptr->v_samp_factor) * DCTSIZE,
+	 (JDIMENSION) (compptr->v_samp_factor * DCTSIZE));
+    }
+#else
+    ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+#endif
+  } else {
+#ifdef FULL_MAIN_BUFFER_SUPPORTED
+    jmain->whole_image[0] = NULL; /* flag for no virtual arrays */
+#endif
+    /* Allocate a strip buffer for each component */
+    for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+	 ci++, compptr++) {
+      jmain->buffer[ci] = (*cinfo->mem->alloc_sarray)
+	((j_common_ptr) cinfo, JPOOL_IMAGE,
+	 compptr->width_in_blocks * DCTSIZE,
+	 (JDIMENSION) (compptr->v_samp_factor * DCTSIZE));
+    }
+  }
+}
diff --git a/code/jpeg-6/jcmarker.cpp b/code/jpeg-6/jcmarker.cpp
new file mode 100644
index 0000000..79e725e
--- /dev/null
+++ b/code/jpeg-6/jcmarker.cpp
@@ -0,0 +1,645 @@
+/*
+ * jcmarker.c
+ *
+ * Copyright (C) 1991-1995, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains routines to write JPEG datastream markers.
+ */
+
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+typedef enum {			/* JPEG marker codes */
+  M_SOF0  = 0xc0,
+  M_SOF1  = 0xc1,
+  M_SOF2  = 0xc2,
+  M_SOF3  = 0xc3,
+  
+  M_SOF5  = 0xc5,
+  M_SOF6  = 0xc6,
+  M_SOF7  = 0xc7,
+  
+  M_JPG   = 0xc8,
+  M_SOF9  = 0xc9,
+  M_SOF10 = 0xca,
+  M_SOF11 = 0xcb,
+  
+  M_SOF13 = 0xcd,
+  M_SOF14 = 0xce,
+  M_SOF15 = 0xcf,
+  
+  M_DHT   = 0xc4,
+  
+  M_DAC   = 0xcc,
+  
+  M_RST0  = 0xd0,
+  M_RST1  = 0xd1,
+  M_RST2  = 0xd2,
+  M_RST3  = 0xd3,
+  M_RST4  = 0xd4,
+  M_RST5  = 0xd5,
+  M_RST6  = 0xd6,
+  M_RST7  = 0xd7,
+  
+  M_SOI   = 0xd8,
+  M_EOI   = 0xd9,
+  M_SOS   = 0xda,
+  M_DQT   = 0xdb,
+  M_DNL   = 0xdc,
+  M_DRI   = 0xdd,
+  M_DHP   = 0xde,
+  M_EXP   = 0xdf,
+  
+  M_APP0  = 0xe0,
+  M_APP1  = 0xe1,
+  M_APP2  = 0xe2,
+  M_APP3  = 0xe3,
+  M_APP4  = 0xe4,
+  M_APP5  = 0xe5,
+  M_APP6  = 0xe6,
+  M_APP7  = 0xe7,
+  M_APP8  = 0xe8,
+  M_APP9  = 0xe9,
+  M_APP10 = 0xea,
+  M_APP11 = 0xeb,
+  M_APP12 = 0xec,
+  M_APP13 = 0xed,
+  M_APP14 = 0xee,
+  M_APP15 = 0xef,
+  
+  M_JPG0  = 0xf0,
+  M_JPG13 = 0xfd,
+  M_COM   = 0xfe,
+  
+  M_TEM   = 0x01,
+  
+  M_ERROR = 0x100
+} JPEG_MARKER;
+
+
+/*
+ * Basic output routines.
+ *
+ * Note that we do not support suspension while writing a marker.
+ * Therefore, an application using suspension must ensure that there is
+ * enough buffer space for the initial markers (typ. 600-700 bytes) before
+ * calling jpeg_start_compress, and enough space to write the trailing EOI
+ * (a few bytes) before calling jpeg_finish_compress.  Multipass compression
+ * modes are not supported at all with suspension, so those two are the only
+ * points where markers will be written.
+ */
+
+LOCAL void
+emit_byte (j_compress_ptr cinfo, int val)
+/* Emit a byte */
+{
+  struct jpeg_destination_mgr * dest = cinfo->dest;
+
+  *(dest->next_output_byte)++ = (JOCTET) val;
+  if (--dest->free_in_buffer == 0) {
+    if (! (*dest->empty_output_buffer) (cinfo))
+      ERREXIT(cinfo, JERR_CANT_SUSPEND);
+  }
+}
+
+
+LOCAL void
+emit_marker (j_compress_ptr cinfo, JPEG_MARKER mark)
+/* Emit a marker code */
+{
+  emit_byte(cinfo, 0xFF);
+  emit_byte(cinfo, (int) mark);
+}
+
+
+LOCAL void
+emit_2bytes (j_compress_ptr cinfo, int value)
+/* Emit a 2-byte integer; these are always MSB first in JPEG files */
+{
+  emit_byte(cinfo, (value >> 8) & 0xFF);
+  emit_byte(cinfo, value & 0xFF);
+}
+
+
+/*
+ * Routines to write specific marker types.
+ */
+
+LOCAL int
+emit_dqt (j_compress_ptr cinfo, int index)
+/* Emit a DQT marker */
+/* Returns the precision used (0 = 8bits, 1 = 16bits) for baseline checking */
+{
+  JQUANT_TBL * qtbl = cinfo->quant_tbl_ptrs[index];
+  int prec;
+  int i;
+
+  if (qtbl == NULL)
+    ERREXIT1(cinfo, JERR_NO_QUANT_TABLE, index);
+
+  prec = 0;
+  for (i = 0; i < DCTSIZE2; i++) {
+    if (qtbl->quantval[i] > 255)
+      prec = 1;
+  }
+
+  if (! qtbl->sent_table) {
+    emit_marker(cinfo, M_DQT);
+
+    emit_2bytes(cinfo, prec ? DCTSIZE2*2 + 1 + 2 : DCTSIZE2 + 1 + 2);
+
+    emit_byte(cinfo, index + (prec<<4));
+
+    for (i = 0; i < DCTSIZE2; i++) {
+      if (prec)
+	emit_byte(cinfo, qtbl->quantval[i] >> 8);
+      emit_byte(cinfo, qtbl->quantval[i] & 0xFF);
+    }
+
+    qtbl->sent_table = TRUE;
+  }
+
+  return prec;
+}
+
+
+LOCAL void
+emit_dht (j_compress_ptr cinfo, int index, boolean is_ac)
+/* Emit a DHT marker */
+{
+  JHUFF_TBL * htbl;
+  int length, i;
+  
+  if (is_ac) {
+    htbl = cinfo->ac_huff_tbl_ptrs[index];
+    index += 0x10;		/* output index has AC bit set */
+  } else {
+    htbl = cinfo->dc_huff_tbl_ptrs[index];
+  }
+
+  if (htbl == NULL)
+    ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, index);
+  
+  if (! htbl->sent_table) {
+    emit_marker(cinfo, M_DHT);
+    
+    length = 0;
+    for (i = 1; i <= 16; i++)
+      length += htbl->bits[i];
+    
+    emit_2bytes(cinfo, length + 2 + 1 + 16);
+    emit_byte(cinfo, index);
+    
+    for (i = 1; i <= 16; i++)
+      emit_byte(cinfo, htbl->bits[i]);
+    
+    for (i = 0; i < length; i++)
+      emit_byte(cinfo, htbl->huffval[i]);
+    
+    htbl->sent_table = TRUE;
+  }
+}
+
+
+LOCAL void
+emit_dac (j_compress_ptr cinfo)
+/* Emit a DAC marker */
+/* Since the useful info is so small, we want to emit all the tables in */
+/* one DAC marker.  Therefore this routine does its own scan of the table. */
+{
+#ifdef C_ARITH_CODING_SUPPORTED
+  char dc_in_use[NUM_ARITH_TBLS];
+  char ac_in_use[NUM_ARITH_TBLS];
+  int length, i;
+  jpeg_component_info *compptr;
+  
+  for (i = 0; i < NUM_ARITH_TBLS; i++)
+    dc_in_use[i] = ac_in_use[i] = 0;
+  
+  for (i = 0; i < cinfo->comps_in_scan; i++) {
+    compptr = cinfo->cur_comp_info[i];
+    dc_in_use[compptr->dc_tbl_no] = 1;
+    ac_in_use[compptr->ac_tbl_no] = 1;
+  }
+  
+  length = 0;
+  for (i = 0; i < NUM_ARITH_TBLS; i++)
+    length += dc_in_use[i] + ac_in_use[i];
+  
+  emit_marker(cinfo, M_DAC);
+  
+  emit_2bytes(cinfo, length*2 + 2);
+  
+  for (i = 0; i < NUM_ARITH_TBLS; i++) {
+    if (dc_in_use[i]) {
+      emit_byte(cinfo, i);
+      emit_byte(cinfo, cinfo->arith_dc_L[i] + (cinfo->arith_dc_U[i]<<4));
+    }
+    if (ac_in_use[i]) {
+      emit_byte(cinfo, i + 0x10);
+      emit_byte(cinfo, cinfo->arith_ac_K[i]);
+    }
+  }
+#endif /* C_ARITH_CODING_SUPPORTED */
+}
+
+
+LOCAL void
+emit_dri (j_compress_ptr cinfo)
+/* Emit a DRI marker */
+{
+  emit_marker(cinfo, M_DRI);
+  
+  emit_2bytes(cinfo, 4);	/* fixed length */
+
+  emit_2bytes(cinfo, (int) cinfo->restart_interval);
+}
+
+
+LOCAL void
+emit_sof (j_compress_ptr cinfo, JPEG_MARKER code)
+/* Emit a SOF marker */
+{
+  int ci;
+  jpeg_component_info *compptr;
+  
+  emit_marker(cinfo, code);
+  
+  emit_2bytes(cinfo, 3 * cinfo->num_components + 2 + 5 + 1); /* length */
+
+  /* Make sure image isn't bigger than SOF field can handle */
+  if ((long) cinfo->image_height > 65535L ||
+      (long) cinfo->image_width > 65535L)
+    ERREXIT1(cinfo, JERR_IMAGE_TOO_BIG, (unsigned int) 65535);
+
+  emit_byte(cinfo, cinfo->data_precision);
+  emit_2bytes(cinfo, (int) cinfo->image_height);
+  emit_2bytes(cinfo, (int) cinfo->image_width);
+
+  emit_byte(cinfo, cinfo->num_components);
+
+  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+       ci++, compptr++) {
+    emit_byte(cinfo, compptr->component_id);
+    emit_byte(cinfo, (compptr->h_samp_factor << 4) + compptr->v_samp_factor);
+    emit_byte(cinfo, compptr->quant_tbl_no);
+  }
+}
+
+
+LOCAL void
+emit_sos (j_compress_ptr cinfo)
+/* Emit a SOS marker */
+{
+  int i, td, ta;
+  jpeg_component_info *compptr;
+  
+  emit_marker(cinfo, M_SOS);
+  
+  emit_2bytes(cinfo, 2 * cinfo->comps_in_scan + 2 + 1 + 3); /* length */
+  
+  emit_byte(cinfo, cinfo->comps_in_scan);
+  
+  for (i = 0; i < cinfo->comps_in_scan; i++) {
+    compptr = cinfo->cur_comp_info[i];
+    emit_byte(cinfo, compptr->component_id);
+    td = compptr->dc_tbl_no;
+    ta = compptr->ac_tbl_no;
+    if (cinfo->progressive_mode) {
+      /* Progressive mode: only DC or only AC tables are used in one scan;
+       * furthermore, Huffman coding of DC refinement uses no table at all.
+       * We emit 0 for unused field(s); this is recommended by the P&M text
+       * but does not seem to be specified in the standard.
+       */
+      if (cinfo->Ss == 0) {
+	ta = 0;			/* DC scan */
+	if (cinfo->Ah != 0 && !cinfo->arith_code)
+	  td = 0;		/* no DC table either */
+      } else {
+	td = 0;			/* AC scan */
+      }
+    }
+    emit_byte(cinfo, (td << 4) + ta);
+  }
+
+  emit_byte(cinfo, cinfo->Ss);
+  emit_byte(cinfo, cinfo->Se);
+  emit_byte(cinfo, (cinfo->Ah << 4) + cinfo->Al);
+}
+
+
+LOCAL void
+emit_jfif_app0 (j_compress_ptr cinfo)
+/* Emit a JFIF-compliant APP0 marker */
+{
+  /*
+   * Length of APP0 block	(2 bytes)
+   * Block ID			(4 bytes - ASCII "JFIF")
+   * Zero byte			(1 byte to terminate the ID string)
+   * Version Major, Minor	(2 bytes - 0x01, 0x01)
+   * Units			(1 byte - 0x00 = none, 0x01 = inch, 0x02 = cm)
+   * Xdpu			(2 bytes - dots per unit horizontal)
+   * Ydpu			(2 bytes - dots per unit vertical)
+   * Thumbnail X size		(1 byte)
+   * Thumbnail Y size		(1 byte)
+   */
+  
+  emit_marker(cinfo, M_APP0);
+  
+  emit_2bytes(cinfo, 2 + 4 + 1 + 2 + 1 + 2 + 2 + 1 + 1); /* length */
+
+  emit_byte(cinfo, 0x4A);	/* Identifier: ASCII "JFIF" */
+  emit_byte(cinfo, 0x46);
+  emit_byte(cinfo, 0x49);
+  emit_byte(cinfo, 0x46);
+  emit_byte(cinfo, 0);
+  /* We currently emit version code 1.01 since we use no 1.02 features.
+   * This may avoid complaints from some older decoders.
+   */
+  emit_byte(cinfo, 1);		/* Major version */
+  emit_byte(cinfo, 1);		/* Minor version */
+  emit_byte(cinfo, cinfo->density_unit); /* Pixel size information */
+  emit_2bytes(cinfo, (int) cinfo->X_density);
+  emit_2bytes(cinfo, (int) cinfo->Y_density);
+  emit_byte(cinfo, 0);		/* No thumbnail image */
+  emit_byte(cinfo, 0);
+}
+
+
+LOCAL void
+emit_adobe_app14 (j_compress_ptr cinfo)
+/* Emit an Adobe APP14 marker */
+{
+  /*
+   * Length of APP14 block	(2 bytes)
+   * Block ID			(5 bytes - ASCII "Adobe")
+   * Version Number		(2 bytes - currently 100)
+   * Flags0			(2 bytes - currently 0)
+   * Flags1			(2 bytes - currently 0)
+   * Color transform		(1 byte)
+   *
+   * Although Adobe TN 5116 mentions Version = 101, all the Adobe files
+   * now in circulation seem to use Version = 100, so that's what we write.
+   *
+   * We write the color transform byte as 1 if the JPEG color space is
+   * YCbCr, 2 if it's YCCK, 0 otherwise.  Adobe's definition has to do with
+   * whether the encoder performed a transformation, which is pretty useless.
+   */
+  
+  emit_marker(cinfo, M_APP14);
+  
+  emit_2bytes(cinfo, 2 + 5 + 2 + 2 + 2 + 1); /* length */
+
+  emit_byte(cinfo, 0x41);	/* Identifier: ASCII "Adobe" */
+  emit_byte(cinfo, 0x64);
+  emit_byte(cinfo, 0x6F);
+  emit_byte(cinfo, 0x62);
+  emit_byte(cinfo, 0x65);
+  emit_2bytes(cinfo, 100);	/* Version */
+  emit_2bytes(cinfo, 0);	/* Flags0 */
+  emit_2bytes(cinfo, 0);	/* Flags1 */
+  switch (cinfo->jpeg_color_space) {
+  case JCS_YCbCr:
+    emit_byte(cinfo, 1);	/* Color transform = 1 */
+    break;
+  case JCS_YCCK:
+    emit_byte(cinfo, 2);	/* Color transform = 2 */
+    break;
+  default:
+    emit_byte(cinfo, 0);	/* Color transform = 0 */
+    break;
+  }
+}
+
+
+/*
+ * This routine is exported for possible use by applications.
+ * The intended use is to emit COM or APPn markers after calling
+ * jpeg_start_compress() and before the first jpeg_write_scanlines() call
+ * (hence, after write_file_header but before write_frame_header).
+ * Other uses are not guaranteed to produce desirable results.
+ */
+
+METHODDEF void
+write_any_marker (j_compress_ptr cinfo, int marker,
+		  const JOCTET *dataptr, unsigned int datalen)
+/* Emit an arbitrary marker with parameters */
+{
+  if (datalen <= (unsigned int) 65533) { /* safety check */
+    emit_marker(cinfo, (JPEG_MARKER) marker);
+  
+    emit_2bytes(cinfo, (int) (datalen + 2)); /* total length */
+
+    while (datalen--) {
+      emit_byte(cinfo, *dataptr);
+      dataptr++;
+    }
+  }
+}
+
+
+/*
+ * Write datastream header.
+ * This consists of an SOI and optional APPn markers.
+ * We recommend use of the JFIF marker, but not the Adobe marker,
+ * when using YCbCr or grayscale data.  The JFIF marker should NOT
+ * be used for any other JPEG colorspace.  The Adobe marker is helpful
+ * to distinguish RGB, CMYK, and YCCK colorspaces.
+ * Note that an application can write additional header markers after
+ * jpeg_start_compress returns.
+ */
+
+METHODDEF void
+write_file_header (j_compress_ptr cinfo)
+{
+  emit_marker(cinfo, M_SOI);	/* first the SOI */
+
+  if (cinfo->write_JFIF_header)	/* next an optional JFIF APP0 */
+    emit_jfif_app0(cinfo);
+  if (cinfo->write_Adobe_marker) /* next an optional Adobe APP14 */
+    emit_adobe_app14(cinfo);
+}
+
+
+/*
+ * Write frame header.
+ * This consists of DQT and SOFn markers.
+ * Note that we do not emit the SOF until we have emitted the DQT(s).
+ * This avoids compatibility problems with incorrect implementations that
+ * try to error-check the quant table numbers as soon as they see the SOF.
+ */
+
+METHODDEF void
+write_frame_header (j_compress_ptr cinfo)
+{
+  int ci, prec;
+  boolean is_baseline;
+  jpeg_component_info *compptr;
+  
+  /* Emit DQT for each quantization table.
+   * Note that emit_dqt() suppresses any duplicate tables.
+   */
+  prec = 0;
+  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+       ci++, compptr++) {
+    prec += emit_dqt(cinfo, compptr->quant_tbl_no);
+  }
+  /* now prec is nonzero iff there are any 16-bit quant tables. */
+
+  /* Check for a non-baseline specification.
+   * Note we assume that Huffman table numbers won't be changed later.
+   */
+  if (cinfo->arith_code || cinfo->progressive_mode ||
+      cinfo->data_precision != 8) {
+    is_baseline = FALSE;
+  } else {
+    is_baseline = TRUE;
+    for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+	 ci++, compptr++) {
+      if (compptr->dc_tbl_no > 1 || compptr->ac_tbl_no > 1)
+	is_baseline = FALSE;
+    }
+    if (prec && is_baseline) {
+      is_baseline = FALSE;
+      /* If it's baseline except for quantizer size, warn the user */
+      TRACEMS(cinfo, 0, JTRC_16BIT_TABLES);
+    }
+  }
+
+  /* Emit the proper SOF marker */
+  if (cinfo->arith_code) {
+    emit_sof(cinfo, M_SOF9);	/* SOF code for arithmetic coding */
+  } else {
+    if (cinfo->progressive_mode)
+      emit_sof(cinfo, M_SOF2);	/* SOF code for progressive Huffman */
+    else if (is_baseline)
+      emit_sof(cinfo, M_SOF0);	/* SOF code for baseline implementation */
+    else
+      emit_sof(cinfo, M_SOF1);	/* SOF code for non-baseline Huffman file */
+  }
+}
+
+
+/*
+ * Write scan header.
+ * This consists of DHT or DAC markers, optional DRI, and SOS.
+ * Compressed data will be written following the SOS.
+ */
+
+METHODDEF void
+write_scan_header (j_compress_ptr cinfo)
+{
+  int i;
+  jpeg_component_info *compptr;
+
+  if (cinfo->arith_code) {
+    /* Emit arith conditioning info.  We may have some duplication
+     * if the file has multiple scans, but it's so small it's hardly
+     * worth worrying about.
+     */
+    emit_dac(cinfo);
+  } else {
+    /* Emit Huffman tables.
+     * Note that emit_dht() suppresses any duplicate tables.
+     */
+    for (i = 0; i < cinfo->comps_in_scan; i++) {
+      compptr = cinfo->cur_comp_info[i];
+      if (cinfo->progressive_mode) {
+	/* Progressive mode: only DC or only AC tables are used in one scan */
+	if (cinfo->Ss == 0) {
+	  if (cinfo->Ah == 0)	/* DC needs no table for refinement scan */
+	    emit_dht(cinfo, compptr->dc_tbl_no, FALSE);
+	} else {
+	  emit_dht(cinfo, compptr->ac_tbl_no, TRUE);
+	}
+      } else {
+	/* Sequential mode: need both DC and AC tables */
+	emit_dht(cinfo, compptr->dc_tbl_no, FALSE);
+	emit_dht(cinfo, compptr->ac_tbl_no, TRUE);
+      }
+    }
+  }
+
+  /* Emit DRI if required --- note that DRI value could change for each scan.
+   * If it doesn't, a tiny amount of space is wasted in multiple-scan files.
+   * We assume DRI will never be nonzero for one scan and zero for a later one.
+   */
+  if (cinfo->restart_interval)
+    emit_dri(cinfo);
+
+  emit_sos(cinfo);
+}
+
+
+/*
+ * Write datastream trailer.
+ */
+
+METHODDEF void
+write_file_trailer (j_compress_ptr cinfo)
+{
+  emit_marker(cinfo, M_EOI);
+}
+
+
+/*
+ * Write an abbreviated table-specification datastream.
+ * This consists of SOI, DQT and DHT tables, and EOI.
+ * Any table that is defined and not marked sent_table = TRUE will be
+ * emitted.  Note that all tables will be marked sent_table = TRUE at exit.
+ */
+
+METHODDEF void
+write_tables_only (j_compress_ptr cinfo)
+{
+  int i;
+
+  emit_marker(cinfo, M_SOI);
+
+  for (i = 0; i < NUM_QUANT_TBLS; i++) {
+    if (cinfo->quant_tbl_ptrs[i] != NULL)
+      (void) emit_dqt(cinfo, i);
+  }
+
+  if (! cinfo->arith_code) {
+    for (i = 0; i < NUM_HUFF_TBLS; i++) {
+      if (cinfo->dc_huff_tbl_ptrs[i] != NULL)
+	emit_dht(cinfo, i, FALSE);
+      if (cinfo->ac_huff_tbl_ptrs[i] != NULL)
+	emit_dht(cinfo, i, TRUE);
+    }
+  }
+
+  emit_marker(cinfo, M_EOI);
+}
+
+
+/*
+ * Initialize the marker writer module.
+ */
+
+GLOBAL void
+jinit_marker_writer (j_compress_ptr cinfo)
+{
+  /* Create the subobject */
+  cinfo->marker = (struct jpeg_marker_writer *)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				SIZEOF(struct jpeg_marker_writer));
+  /* Initialize method pointers */
+  cinfo->marker->write_any_marker = write_any_marker;
+  cinfo->marker->write_file_header = write_file_header;
+  cinfo->marker->write_frame_header = write_frame_header;
+  cinfo->marker->write_scan_header = write_scan_header;
+  cinfo->marker->write_file_trailer = write_file_trailer;
+  cinfo->marker->write_tables_only = write_tables_only;
+}
diff --git a/code/jpeg-6/jcmaster.cpp b/code/jpeg-6/jcmaster.cpp
new file mode 100644
index 0000000..ae4b3c1
--- /dev/null
+++ b/code/jpeg-6/jcmaster.cpp
@@ -0,0 +1,584 @@
+/*
+ * jcmaster.c
+ *
+ * Copyright (C) 1991-1995, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains master control logic for the JPEG compressor.
+ * These routines are concerned with parameter validation, initial setup,
+ * and inter-pass control (determining the number of passes and the work 
+ * to be done in each pass).
+ */
+
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/* Private state */
+
+typedef enum {
+	main_pass,		/* input data, also do first output step */
+	huff_opt_pass,		/* Huffman code optimization pass */
+	output_pass		/* data output pass */
+} c_pass_type;
+
+typedef struct {
+  struct jpeg_comp_master pub;	/* public fields */
+
+  c_pass_type pass_type;	/* the type of the current pass */
+
+  int pass_number;		/* # of passes completed */
+  int total_passes;		/* total # of passes needed */
+
+  int scan_number;		/* current index in scan_info[] */
+} my_comp_master;
+
+typedef my_comp_master * my_master_ptr;
+
+
+/*
+ * Support routines that do various essential calculations.
+ */
+
+LOCAL void
+initial_setup (j_compress_ptr cinfo)
+/* Do computations that are needed before master selection phase */
+{
+  int ci;
+  jpeg_component_info *compptr;
+  long samplesperrow;
+  JDIMENSION jd_samplesperrow;
+
+  /* Sanity check on image dimensions */
+  if (cinfo->image_height <= 0 || cinfo->image_width <= 0
+      || cinfo->num_components <= 0 || cinfo->input_components <= 0)
+    ERREXIT(cinfo, JERR_EMPTY_IMAGE);
+
+  /* Make sure image isn't bigger than I can handle */
+  if ((long) cinfo->image_height > (long) JPEG_MAX_DIMENSION ||
+      (long) cinfo->image_width > (long) JPEG_MAX_DIMENSION)
+    ERREXIT1(cinfo, JERR_IMAGE_TOO_BIG, (unsigned int) JPEG_MAX_DIMENSION);
+
+  /* Width of an input scanline must be representable as JDIMENSION. */
+  samplesperrow = (long) cinfo->image_width * (long) cinfo->input_components;
+  jd_samplesperrow = (JDIMENSION) samplesperrow;
+  if ((long) jd_samplesperrow != samplesperrow)
+    ERREXIT(cinfo, JERR_WIDTH_OVERFLOW);
+
+  /* For now, precision must match compiled-in value... */
+  if (cinfo->data_precision != BITS_IN_JSAMPLE)
+    ERREXIT1(cinfo, JERR_BAD_PRECISION, cinfo->data_precision);
+
+  /* Check that number of components won't exceed internal array sizes */
+  if (cinfo->num_components > MAX_COMPONENTS)
+    ERREXIT2(cinfo, JERR_COMPONENT_COUNT, cinfo->num_components,
+	     MAX_COMPONENTS);
+
+  /* Compute maximum sampling factors; check factor validity */
+  cinfo->max_h_samp_factor = 1;
+  cinfo->max_v_samp_factor = 1;
+  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+       ci++, compptr++) {
+    if (compptr->h_samp_factor<=0 || compptr->h_samp_factor>MAX_SAMP_FACTOR ||
+	compptr->v_samp_factor<=0 || compptr->v_samp_factor>MAX_SAMP_FACTOR)
+      ERREXIT(cinfo, JERR_BAD_SAMPLING);
+    cinfo->max_h_samp_factor = MAX(cinfo->max_h_samp_factor,
+				   compptr->h_samp_factor);
+    cinfo->max_v_samp_factor = MAX(cinfo->max_v_samp_factor,
+				   compptr->v_samp_factor);
+  }
+
+  /* Compute dimensions of components */
+  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+       ci++, compptr++) {
+    /* Fill in the correct component_index value; don't rely on application */
+    compptr->component_index = ci;
+    /* For compression, we never do DCT scaling. */
+    compptr->DCT_scaled_size = DCTSIZE;
+    /* Size in DCT blocks */
+    compptr->width_in_blocks = (JDIMENSION)
+      jdiv_round_up((long) cinfo->image_width * (long) compptr->h_samp_factor,
+		    (long) (cinfo->max_h_samp_factor * DCTSIZE));
+    compptr->height_in_blocks = (JDIMENSION)
+      jdiv_round_up((long) cinfo->image_height * (long) compptr->v_samp_factor,
+		    (long) (cinfo->max_v_samp_factor * DCTSIZE));
+    /* Size in samples */
+    compptr->downsampled_width = (JDIMENSION)
+      jdiv_round_up((long) cinfo->image_width * (long) compptr->h_samp_factor,
+		    (long) cinfo->max_h_samp_factor);
+    compptr->downsampled_height = (JDIMENSION)
+      jdiv_round_up((long) cinfo->image_height * (long) compptr->v_samp_factor,
+		    (long) cinfo->max_v_samp_factor);
+    /* Mark component needed (this flag isn't actually used for compression) */
+    compptr->component_needed = TRUE;
+  }
+
+  /* Compute number of fully interleaved MCU rows (number of times that
+   * main controller will call coefficient controller).
+   */
+  cinfo->total_iMCU_rows = (JDIMENSION)
+    jdiv_round_up((long) cinfo->image_height,
+		  (long) (cinfo->max_v_samp_factor*DCTSIZE));
+}
+
+
+#ifdef C_MULTISCAN_FILES_SUPPORTED
+
+LOCAL void
+validate_script (j_compress_ptr cinfo)
+/* Verify that the scan script in cinfo->scan_info[] is valid; also
+ * determine whether it uses progressive JPEG, and set cinfo->progressive_mode.
+ */
+{
+  const jpeg_scan_info * scanptr;
+  int scanno, ncomps, ci, coefi, thisi;
+  int Ss, Se, Ah, Al;
+  boolean component_sent[MAX_COMPONENTS];
+#ifdef C_PROGRESSIVE_SUPPORTED
+  int * last_bitpos_ptr;
+  int last_bitpos[MAX_COMPONENTS][DCTSIZE2];
+  /* -1 until that coefficient has been seen; then last Al for it */
+#endif
+
+  if (cinfo->num_scans <= 0)
+    ERREXIT1(cinfo, JERR_BAD_SCAN_SCRIPT, 0);
+
+  /* For sequential JPEG, all scans must have Ss=0, Se=DCTSIZE2-1;
+   * for progressive JPEG, no scan can have this.
+   */
+  scanptr = cinfo->scan_info;
+  if (scanptr->Ss != 0 || scanptr->Se != DCTSIZE2-1) {
+#ifdef C_PROGRESSIVE_SUPPORTED
+    cinfo->progressive_mode = TRUE;
+    last_bitpos_ptr = & last_bitpos[0][0];
+    for (ci = 0; ci < cinfo->num_components; ci++) 
+      for (coefi = 0; coefi < DCTSIZE2; coefi++)
+	*last_bitpos_ptr++ = -1;
+#else
+    ERREXIT(cinfo, JERR_NOT_COMPILED);
+#endif
+  } else {
+    cinfo->progressive_mode = FALSE;
+    for (ci = 0; ci < cinfo->num_components; ci++) 
+      component_sent[ci] = FALSE;
+  }
+
+  for (scanno = 1; scanno <= cinfo->num_scans; scanptr++, scanno++) {
+    /* Validate component indexes */
+    ncomps = scanptr->comps_in_scan;
+    if (ncomps <= 0 || ncomps > MAX_COMPS_IN_SCAN)
+      ERREXIT2(cinfo, JERR_COMPONENT_COUNT, ncomps, MAX_COMPS_IN_SCAN);
+    for (ci = 0; ci < ncomps; ci++) {
+      thisi = scanptr->component_index[ci];
+      if (thisi < 0 || thisi >= cinfo->num_components)
+	ERREXIT1(cinfo, JERR_BAD_SCAN_SCRIPT, scanno);
+      /* Components must appear in SOF order within each scan */
+      if (ci > 0 && thisi <= scanptr->component_index[ci-1])
+	ERREXIT1(cinfo, JERR_BAD_SCAN_SCRIPT, scanno);
+    }
+    /* Validate progression parameters */
+    Ss = scanptr->Ss;
+    Se = scanptr->Se;
+    Ah = scanptr->Ah;
+    Al = scanptr->Al;
+    if (cinfo->progressive_mode) {
+#ifdef C_PROGRESSIVE_SUPPORTED
+      if (Ss < 0 || Ss >= DCTSIZE2 || Se < Ss || Se >= DCTSIZE2 ||
+	  Ah < 0 || Ah > 13 || Al < 0 || Al > 13)
+	ERREXIT1(cinfo, JERR_BAD_PROG_SCRIPT, scanno);
+      if (Ss == 0) {
+	if (Se != 0)		/* DC and AC together not OK */
+	  ERREXIT1(cinfo, JERR_BAD_PROG_SCRIPT, scanno);
+      } else {
+	if (ncomps != 1)	/* AC scans must be for only one component */
+	  ERREXIT1(cinfo, JERR_BAD_PROG_SCRIPT, scanno);
+      }
+      for (ci = 0; ci < ncomps; ci++) {
+	last_bitpos_ptr = & last_bitpos[scanptr->component_index[ci]][0];
+	if (Ss != 0 && last_bitpos_ptr[0] < 0) /* AC without prior DC scan */
+	  ERREXIT1(cinfo, JERR_BAD_PROG_SCRIPT, scanno);
+	for (coefi = Ss; coefi <= Se; coefi++) {
+	  if (last_bitpos_ptr[coefi] < 0) {
+	    /* first scan of this coefficient */
+	    if (Ah != 0)
+	      ERREXIT1(cinfo, JERR_BAD_PROG_SCRIPT, scanno);
+	  } else {
+	    /* not first scan */
+	    if (Ah != last_bitpos_ptr[coefi] || Al != Ah-1)
+	      ERREXIT1(cinfo, JERR_BAD_PROG_SCRIPT, scanno);
+	  }
+	  last_bitpos_ptr[coefi] = Al;
+	}
+      }
+#endif
+    } else {
+      /* For sequential JPEG, all progression parameters must be these: */
+      if (Ss != 0 || Se != DCTSIZE2-1 || Ah != 0 || Al != 0)
+	ERREXIT1(cinfo, JERR_BAD_PROG_SCRIPT, scanno);
+      /* Make sure components are not sent twice */
+      for (ci = 0; ci < ncomps; ci++) {
+	thisi = scanptr->component_index[ci];
+	if (component_sent[thisi])
+	  ERREXIT1(cinfo, JERR_BAD_SCAN_SCRIPT, scanno);
+	component_sent[thisi] = TRUE;
+      }
+    }
+  }
+
+  /* Now verify that everything got sent. */
+  if (cinfo->progressive_mode) {
+#ifdef C_PROGRESSIVE_SUPPORTED
+    /* For progressive mode, we only check that at least some DC data
+     * got sent for each component; the spec does not require that all bits
+     * of all coefficients be transmitted.  Would it be wiser to enforce
+     * transmission of all coefficient bits??
+     */
+    for (ci = 0; ci < cinfo->num_components; ci++) {
+      if (last_bitpos[ci][0] < 0)
+	ERREXIT(cinfo, JERR_MISSING_DATA);
+    }
+#endif
+  } else {
+    for (ci = 0; ci < cinfo->num_components; ci++) {
+      if (! component_sent[ci])
+	ERREXIT(cinfo, JERR_MISSING_DATA);
+    }
+  }
+}
+
+#endif /* C_MULTISCAN_FILES_SUPPORTED */
+
+
+LOCAL void
+select_scan_parameters (j_compress_ptr cinfo)
+/* Set up the scan parameters for the current scan */
+{
+  int ci;
+
+#ifdef C_MULTISCAN_FILES_SUPPORTED
+  if (cinfo->scan_info != NULL) {
+    /* Prepare for current scan --- the script is already validated */
+    my_master_ptr master = (my_master_ptr) cinfo->master;
+    const jpeg_scan_info * scanptr = cinfo->scan_info + master->scan_number;
+
+    cinfo->comps_in_scan = scanptr->comps_in_scan;
+    for (ci = 0; ci < scanptr->comps_in_scan; ci++) {
+      cinfo->cur_comp_info[ci] =
+	&cinfo->comp_info[scanptr->component_index[ci]];
+    }
+    cinfo->Ss = scanptr->Ss;
+    cinfo->Se = scanptr->Se;
+    cinfo->Ah = scanptr->Ah;
+    cinfo->Al = scanptr->Al;
+  }
+  else
+#endif
+  {
+    /* Prepare for single sequential-JPEG scan containing all components */
+    if (cinfo->num_components > MAX_COMPS_IN_SCAN)
+      ERREXIT2(cinfo, JERR_COMPONENT_COUNT, cinfo->num_components,
+	       MAX_COMPS_IN_SCAN);
+    cinfo->comps_in_scan = cinfo->num_components;
+    for (ci = 0; ci < cinfo->num_components; ci++) {
+      cinfo->cur_comp_info[ci] = &cinfo->comp_info[ci];
+    }
+    cinfo->Ss = 0;
+    cinfo->Se = DCTSIZE2-1;
+    cinfo->Ah = 0;
+    cinfo->Al = 0;
+  }
+}
+
+
+LOCAL void
+per_scan_setup (j_compress_ptr cinfo)
+/* Do computations that are needed before processing a JPEG scan */
+/* cinfo->comps_in_scan and cinfo->cur_comp_info[] are already set */
+{
+  int ci, mcublks, tmp;
+  jpeg_component_info *compptr;
+  
+  if (cinfo->comps_in_scan == 1) {
+    
+    /* Noninterleaved (single-component) scan */
+    compptr = cinfo->cur_comp_info[0];
+    
+    /* Overall image size in MCUs */
+    cinfo->MCUs_per_row = compptr->width_in_blocks;
+    cinfo->MCU_rows_in_scan = compptr->height_in_blocks;
+    
+    /* For noninterleaved scan, always one block per MCU */
+    compptr->MCU_width = 1;
+    compptr->MCU_height = 1;
+    compptr->MCU_blocks = 1;
+    compptr->MCU_sample_width = DCTSIZE;
+    compptr->last_col_width = 1;
+    /* For noninterleaved scans, it is convenient to define last_row_height
+     * as the number of block rows present in the last iMCU row.
+     */
+    tmp = (int) (compptr->height_in_blocks % compptr->v_samp_factor);
+    if (tmp == 0) tmp = compptr->v_samp_factor;
+    compptr->last_row_height = tmp;
+    
+    /* Prepare array describing MCU composition */
+    cinfo->blocks_in_MCU = 1;
+    cinfo->MCU_membership[0] = 0;
+    
+  } else {
+    
+    /* Interleaved (multi-component) scan */
+    if (cinfo->comps_in_scan <= 0 || cinfo->comps_in_scan > MAX_COMPS_IN_SCAN)
+      ERREXIT2(cinfo, JERR_COMPONENT_COUNT, cinfo->comps_in_scan,
+	       MAX_COMPS_IN_SCAN);
+    
+    /* Overall image size in MCUs */
+    cinfo->MCUs_per_row = (JDIMENSION)
+      jdiv_round_up((long) cinfo->image_width,
+		    (long) (cinfo->max_h_samp_factor*DCTSIZE));
+    cinfo->MCU_rows_in_scan = (JDIMENSION)
+      jdiv_round_up((long) cinfo->image_height,
+		    (long) (cinfo->max_v_samp_factor*DCTSIZE));
+    
+    cinfo->blocks_in_MCU = 0;
+    
+    for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+      compptr = cinfo->cur_comp_info[ci];
+      /* Sampling factors give # of blocks of component in each MCU */
+      compptr->MCU_width = compptr->h_samp_factor;
+      compptr->MCU_height = compptr->v_samp_factor;
+      compptr->MCU_blocks = compptr->MCU_width * compptr->MCU_height;
+      compptr->MCU_sample_width = compptr->MCU_width * DCTSIZE;
+      /* Figure number of non-dummy blocks in last MCU column & row */
+      tmp = (int) (compptr->width_in_blocks % compptr->MCU_width);
+      if (tmp == 0) tmp = compptr->MCU_width;
+      compptr->last_col_width = tmp;
+      tmp = (int) (compptr->height_in_blocks % compptr->MCU_height);
+      if (tmp == 0) tmp = compptr->MCU_height;
+      compptr->last_row_height = tmp;
+      /* Prepare array describing MCU composition */
+      mcublks = compptr->MCU_blocks;
+      if (cinfo->blocks_in_MCU + mcublks > C_MAX_BLOCKS_IN_MCU)
+	ERREXIT(cinfo, JERR_BAD_MCU_SIZE);
+      while (mcublks-- > 0) {
+	cinfo->MCU_membership[cinfo->blocks_in_MCU++] = ci;
+      }
+    }
+    
+  }
+
+  /* Convert restart specified in rows to actual MCU count. */
+  /* Note that count must fit in 16 bits, so we provide limiting. */
+  if (cinfo->restart_in_rows > 0) {
+    long nominal = (long) cinfo->restart_in_rows * (long) cinfo->MCUs_per_row;
+    cinfo->restart_interval = (unsigned int) MIN(nominal, 65535L);
+  }
+}
+
+
+/*
+ * Per-pass setup.
+ * This is called at the beginning of each pass.  We determine which modules
+ * will be active during this pass and give them appropriate start_pass calls.
+ * We also set is_last_pass to indicate whether any more passes will be
+ * required.
+ */
+
+METHODDEF void
+prepare_for_pass (j_compress_ptr cinfo)
+{
+  my_master_ptr master = (my_master_ptr) cinfo->master;
+
+  switch (master->pass_type) {
+  case main_pass:
+    /* Initial pass: will collect input data, and do either Huffman
+     * optimization or data output for the first scan.
+     */
+    select_scan_parameters(cinfo);
+    per_scan_setup(cinfo);
+    if (! cinfo->raw_data_in) {
+      (*cinfo->cconvert->start_pass) (cinfo);
+      (*cinfo->downsample->start_pass) (cinfo);
+      (*cinfo->prep->start_pass) (cinfo, JBUF_PASS_THRU);
+    }
+    (*cinfo->fdct->start_pass) (cinfo);
+    (*cinfo->entropy->start_pass) (cinfo, cinfo->optimize_coding);
+    (*cinfo->coef->start_pass) (cinfo,
+				(master->total_passes > 1 ?
+				 JBUF_SAVE_AND_PASS : JBUF_PASS_THRU));
+    (*cinfo->main->start_pass) (cinfo, JBUF_PASS_THRU);
+    if (cinfo->optimize_coding) {
+      /* No immediate data output; postpone writing frame/scan headers */
+      master->pub.call_pass_startup = FALSE;
+    } else {
+      /* Will write frame/scan headers at first jpeg_write_scanlines call */
+      master->pub.call_pass_startup = TRUE;
+    }
+    break;
+#ifdef ENTROPY_OPT_SUPPORTED
+  case huff_opt_pass:
+    /* Do Huffman optimization for a scan after the first one. */
+    select_scan_parameters(cinfo);
+    per_scan_setup(cinfo);
+    if (cinfo->Ss != 0 || cinfo->Ah == 0 || cinfo->arith_code) {
+      (*cinfo->entropy->start_pass) (cinfo, TRUE);
+      (*cinfo->coef->start_pass) (cinfo, JBUF_CRANK_DEST);
+      master->pub.call_pass_startup = FALSE;
+      break;
+    }
+    /* Special case: Huffman DC refinement scans need no Huffman table
+     * and therefore we can skip the optimization pass for them.
+     */
+    master->pass_type = output_pass;
+    master->pass_number++;
+    /*FALLTHROUGH*/
+#endif
+  case output_pass:
+    /* Do a data-output pass. */
+    /* We need not repeat per-scan setup if prior optimization pass did it. */
+    if (! cinfo->optimize_coding) {
+      select_scan_parameters(cinfo);
+      per_scan_setup(cinfo);
+    }
+    (*cinfo->entropy->start_pass) (cinfo, FALSE);
+    (*cinfo->coef->start_pass) (cinfo, JBUF_CRANK_DEST);
+    /* We emit frame/scan headers now */
+    if (master->scan_number == 0)
+      (*cinfo->marker->write_frame_header) (cinfo);
+    (*cinfo->marker->write_scan_header) (cinfo);
+    master->pub.call_pass_startup = FALSE;
+    break;
+  default:
+    ERREXIT(cinfo, JERR_NOT_COMPILED);
+  }
+
+  master->pub.is_last_pass = (master->pass_number == master->total_passes-1);
+
+  /* Set up progress monitor's pass info if present */
+  if (cinfo->progress != NULL) {
+    cinfo->progress->completed_passes = master->pass_number;
+    cinfo->progress->total_passes = master->total_passes;
+  }
+}
+
+
+/*
+ * Special start-of-pass hook.
+ * This is called by jpeg_write_scanlines if call_pass_startup is TRUE.
+ * In single-pass processing, we need this hook because we don't want to
+ * write frame/scan headers during jpeg_start_compress; we want to let the
+ * application write COM markers etc. between jpeg_start_compress and the
+ * jpeg_write_scanlines loop.
+ * In multi-pass processing, this routine is not used.
+ */
+
+METHODDEF void
+pass_startup (j_compress_ptr cinfo)
+{
+  cinfo->master->call_pass_startup = FALSE; /* reset flag so call only once */
+
+  (*cinfo->marker->write_frame_header) (cinfo);
+  (*cinfo->marker->write_scan_header) (cinfo);
+}
+
+
+/*
+ * Finish up at end of pass.
+ */
+
+METHODDEF void
+finish_pass_master (j_compress_ptr cinfo)
+{
+  my_master_ptr master = (my_master_ptr) cinfo->master;
+
+  /* The entropy coder always needs an end-of-pass call,
+   * either to analyze statistics or to flush its output buffer.
+   */
+  (*cinfo->entropy->finish_pass) (cinfo);
+
+  /* Update state for next pass */
+  switch (master->pass_type) {
+  case main_pass:
+    /* next pass is either output of scan 0 (after optimization)
+     * or output of scan 1 (if no optimization).
+     */
+    master->pass_type = output_pass;
+    if (! cinfo->optimize_coding)
+      master->scan_number++;
+    break;
+  case huff_opt_pass:
+    /* next pass is always output of current scan */
+    master->pass_type = output_pass;
+    break;
+  case output_pass:
+    /* next pass is either optimization or output of next scan */
+    if (cinfo->optimize_coding)
+      master->pass_type = huff_opt_pass;
+    master->scan_number++;
+    break;
+  }
+
+  master->pass_number++;
+}
+
+
+/*
+ * Initialize master compression control.
+ */
+
+GLOBAL void
+jinit_c_master_control (j_compress_ptr cinfo, boolean transcode_only)
+{
+  my_master_ptr master;
+
+  master = (my_master_ptr)
+      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				  SIZEOF(my_comp_master));
+  cinfo->master = (struct jpeg_comp_master *) master;
+  master->pub.prepare_for_pass = prepare_for_pass;
+  master->pub.pass_startup = pass_startup;
+  master->pub.finish_pass = finish_pass_master;
+  master->pub.is_last_pass = FALSE;
+
+  /* Validate parameters, determine derived values */
+  initial_setup(cinfo);
+
+  if (cinfo->scan_info != NULL) {
+#ifdef C_MULTISCAN_FILES_SUPPORTED
+    validate_script(cinfo);
+#else
+    ERREXIT(cinfo, JERR_NOT_COMPILED);
+#endif
+  } else {
+    cinfo->progressive_mode = FALSE;
+    cinfo->num_scans = 1;
+  }
+
+  if (cinfo->progressive_mode)	/*  TEMPORARY HACK ??? */
+    cinfo->optimize_coding = TRUE; /* assume default tables no good for progressive mode */
+
+  /* Initialize my private state */
+  if (transcode_only) {
+    /* no main pass in transcoding */
+    if (cinfo->optimize_coding)
+      master->pass_type = huff_opt_pass;
+    else
+      master->pass_type = output_pass;
+  } else {
+    /* for normal compression, first pass is always this type: */
+    master->pass_type = main_pass;
+  }
+  master->scan_number = 0;
+  master->pass_number = 0;
+  if (cinfo->optimize_coding)
+    master->total_passes = cinfo->num_scans * 2;
+  else
+    master->total_passes = cinfo->num_scans;
+}
diff --git a/code/jpeg-6/jcomapi.cpp b/code/jpeg-6/jcomapi.cpp
new file mode 100644
index 0000000..40de85f
--- /dev/null
+++ b/code/jpeg-6/jcomapi.cpp
@@ -0,0 +1,100 @@
+/*
+ * jcomapi.c
+ *
+ * Copyright (C) 1994, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains application interface routines that are used for both
+ * compression and decompression.
+ */
+
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/*
+ * Abort processing of a JPEG compression or decompression operation,
+ * but don't destroy the object itself.
+ *
+ * For this, we merely clean up all the nonpermanent memory pools.
+ * Note that temp files (virtual arrays) are not allowed to belong to
+ * the permanent pool, so we will be able to close all temp files here.
+ * Closing a data source or destination, if necessary, is the application's
+ * responsibility.
+ */
+
+GLOBAL void
+jpeg_abort (j_common_ptr cinfo)
+{
+  int pool;
+
+  /* Releasing pools in reverse order might help avoid fragmentation
+   * with some (brain-damaged) malloc libraries.
+   */
+  for (pool = JPOOL_NUMPOOLS-1; pool > JPOOL_PERMANENT; pool--) {
+    (*cinfo->mem->free_pool) (cinfo, pool);
+  }
+
+  /* Reset overall state for possible reuse of object */
+  cinfo->global_state = (cinfo->is_decompressor ? DSTATE_START : CSTATE_START);
+}
+
+
+/*
+ * Destruction of a JPEG object.
+ *
+ * Everything gets deallocated except the master jpeg_compress_struct itself
+ * and the error manager struct.  Both of these are supplied by the application
+ * and must be freed, if necessary, by the application.  (Often they are on
+ * the stack and so don't need to be freed anyway.)
+ * Closing a data source or destination, if necessary, is the application's
+ * responsibility.
+ */
+
+GLOBAL void
+jpeg_destroy (j_common_ptr cinfo)
+{
+  /* We need only tell the memory manager to release everything. */
+  /* NB: mem pointer is NULL if memory mgr failed to initialize. */
+  if (cinfo->mem != NULL)
+    (*cinfo->mem->self_destruct) (cinfo);
+  cinfo->mem = NULL;		/* be safe if jpeg_destroy is called twice */
+  cinfo->global_state = 0;	/* mark it destroyed */
+}
+
+
+/*
+ * Convenience routines for allocating quantization and Huffman tables.
+ * (Would jutils.c be a more reasonable place to put these?)
+ */
+
+GLOBAL JQUANT_TBL *
+jpeg_alloc_quant_table (j_common_ptr cinfo)
+{
+  JQUANT_TBL *tbl;
+
+  tbl = (JQUANT_TBL *)
+    (*cinfo->mem->alloc_small) (cinfo, JPOOL_PERMANENT, SIZEOF(JQUANT_TBL));
+  tbl->sent_table = FALSE;	/* make sure this is false in any new table */
+  return tbl;
+}
+
+
+GLOBAL JHUFF_TBL *
+jpeg_alloc_huff_table (j_common_ptr cinfo)
+{
+  JHUFF_TBL *tbl;
+
+  tbl = (JHUFF_TBL *)
+    (*cinfo->mem->alloc_small) (cinfo, JPOOL_PERMANENT, SIZEOF(JHUFF_TBL));
+  tbl->sent_table = FALSE;	/* make sure this is false in any new table */
+  return tbl;
+}
diff --git a/code/jpeg-6/jconfig.h b/code/jpeg-6/jconfig.h
new file mode 100644
index 0000000..187ecfc
--- /dev/null
+++ b/code/jpeg-6/jconfig.h
@@ -0,0 +1,41 @@
+/* jconfig.wat --- jconfig.h for Watcom C/C++ on MS-DOS or OS/2. */
+/* see jconfig.doc for explanations */
+
+#define HAVE_PROTOTYPES
+#define HAVE_UNSIGNED_CHAR
+#define HAVE_UNSIGNED_SHORT
+/* #define void char */
+/* #define const */
+#define CHAR_IS_UNSIGNED
+#define HAVE_STDDEF_H
+#define HAVE_STDLIB_H
+#undef NEED_BSD_STRINGS
+#undef NEED_SYS_TYPES_H
+#undef NEED_FAR_POINTERS	/* Watcom uses flat 32-bit addressing */
+#undef NEED_SHORT_EXTERNAL_NAMES
+#undef INCOMPLETE_TYPES_BROKEN
+
+#define JDCT_DEFAULT  JDCT_FLOAT
+#define JDCT_FASTEST  JDCT_FLOAT
+
+#ifdef JPEG_INTERNALS
+
+#undef RIGHT_SHIFT_IS_UNSIGNED
+
+#endif /* JPEG_INTERNALS */
+
+#ifdef JPEG_CJPEG_DJPEG
+
+#define BMP_SUPPORTED		/* BMP image file format */
+#define GIF_SUPPORTED		/* GIF image file format */
+#define PPM_SUPPORTED		/* PBMPLUS PPM/PGM image file format */
+#undef RLE_SUPPORTED		/* Utah RLE image file format */
+#define TARGA_SUPPORTED		/* Targa image file format */
+
+#undef TWO_FILE_COMMANDLINE	/* optional */
+#define USE_SETMODE		/* Needed to make one-file style work in Watcom */
+#undef NEED_SIGNAL_CATCHER	/* Define this if you use jmemname.c */
+#undef DONT_USE_B_MODE
+#undef PROGRESS_REPORT		/* optional */
+
+#endif /* JPEG_CJPEG_DJPEG */
diff --git a/code/jpeg-6/jcparam.cpp b/code/jpeg-6/jcparam.cpp
new file mode 100644
index 0000000..990cb30
--- /dev/null
+++ b/code/jpeg-6/jcparam.cpp
@@ -0,0 +1,580 @@
+/*
+ * jcparam.c
+ *
+ * Copyright (C) 1991-1995, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains optional default-setting code for the JPEG compressor.
+ * Applications do not have to use this file, but those that don't use it
+ * must know a lot more about the innards of the JPEG code.
+ */
+
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/*
+ * Quantization table setup routines
+ */
+
+GLOBAL void
+jpeg_add_quant_table (j_compress_ptr cinfo, int which_tbl,
+		      const unsigned int *basic_table,
+		      int scale_factor, boolean force_baseline)
+/* Define a quantization table equal to the basic_table times
+ * a scale factor (given as a percentage).
+ * If force_baseline is TRUE, the computed quantization table entries
+ * are limited to 1..255 for JPEG baseline compatibility.
+ */
+{
+  JQUANT_TBL ** qtblptr = & cinfo->quant_tbl_ptrs[which_tbl];
+  int i;
+  long temp;
+
+  /* Safety check to ensure start_compress not called yet. */
+  if (cinfo->global_state != CSTATE_START)
+    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+
+  if (*qtblptr == NULL)
+    *qtblptr = jpeg_alloc_quant_table((j_common_ptr) cinfo);
+
+  for (i = 0; i < DCTSIZE2; i++) {
+    temp = ((long) basic_table[i] * scale_factor + 50L) / 100L;
+    /* limit the values to the valid range */
+    if (temp <= 0L) temp = 1L;
+    if (temp > 32767L) temp = 32767L; /* max quantizer needed for 12 bits */
+    if (force_baseline && temp > 255L)
+      temp = 255L;		/* limit to baseline range if requested */
+    (*qtblptr)->quantval[i] = (UINT16) temp;
+  }
+
+  /* Initialize sent_table FALSE so table will be written to JPEG file. */
+  (*qtblptr)->sent_table = FALSE;
+}
+
+
+GLOBAL void
+jpeg_set_linear_quality (j_compress_ptr cinfo, int scale_factor,
+			 boolean force_baseline)
+/* Set or change the 'quality' (quantization) setting, using default tables
+ * and a straight percentage-scaling quality scale.  In most cases it's better
+ * to use jpeg_set_quality (below); this entry point is provided for
+ * applications that insist on a linear percentage scaling.
+ */
+{
+  /* This is the sample quantization table given in the JPEG spec section K.1,
+   * but expressed in zigzag order (as are all of our quant. tables).
+   * The spec says that the values given produce "good" quality, and
+   * when divided by 2, "very good" quality.
+   */
+  static const unsigned int std_luminance_quant_tbl[DCTSIZE2] = {
+    16,  11,  12,  14,  12,  10,  16,  14,
+    13,  14,  18,  17,  16,  19,  24,  40,
+    26,  24,  22,  22,  24,  49,  35,  37,
+    29,  40,  58,  51,  61,  60,  57,  51,
+    56,  55,  64,  72,  92,  78,  64,  68,
+    87,  69,  55,  56,  80, 109,  81,  87,
+    95,  98, 103, 104, 103,  62,  77, 113,
+    121, 112, 100, 120,  92, 101, 103,  99
+    };
+  static const unsigned int std_chrominance_quant_tbl[DCTSIZE2] = {
+    17,  18,  18,  24,  21,  24,  47,  26,
+    26,  47,  99,  66,  56,  66,  99,  99,
+    99,  99,  99,  99,  99,  99,  99,  99,
+    99,  99,  99,  99,  99,  99,  99,  99,
+    99,  99,  99,  99,  99,  99,  99,  99,
+    99,  99,  99,  99,  99,  99,  99,  99,
+    99,  99,  99,  99,  99,  99,  99,  99,
+    99,  99,  99,  99,  99,  99,  99,  99
+    };
+
+  /* Set up two quantization tables using the specified scaling */
+  jpeg_add_quant_table(cinfo, 0, std_luminance_quant_tbl,
+		       scale_factor, force_baseline);
+  jpeg_add_quant_table(cinfo, 1, std_chrominance_quant_tbl,
+		       scale_factor, force_baseline);
+}
+
+
+GLOBAL int
+jpeg_quality_scaling (int quality)
+/* Convert a user-specified quality rating to a percentage scaling factor
+ * for an underlying quantization table, using our recommended scaling curve.
+ * The input 'quality' factor should be 0 (terrible) to 100 (very good).
+ */
+{
+  /* Safety limit on quality factor.  Convert 0 to 1 to avoid zero divide. */
+  if (quality <= 0) quality = 1;
+  if (quality > 100) quality = 100;
+
+  /* The basic table is used as-is (scaling 100) for a quality of 50.
+   * Qualities 50..100 are converted to scaling percentage 200 - 2*Q;
+   * note that at Q=100 the scaling is 0, which will cause j_add_quant_table
+   * to make all the table entries 1 (hence, no quantization loss).
+   * Qualities 1..50 are converted to scaling percentage 5000/Q.
+   */
+  if (quality < 50)
+    quality = 5000 / quality;
+  else
+    quality = 200 - quality*2;
+
+  return quality;
+}
+
+
+GLOBAL void
+jpeg_set_quality (j_compress_ptr cinfo, int quality, boolean force_baseline)
+/* Set or change the 'quality' (quantization) setting, using default tables.
+ * This is the standard quality-adjusting entry point for typical user
+ * interfaces; only those who want detailed control over quantization tables
+ * would use the preceding three routines directly.
+ */
+{
+  /* Convert user 0-100 rating to percentage scaling */
+  quality = jpeg_quality_scaling(quality);
+
+  /* Set up standard quality tables */
+  jpeg_set_linear_quality(cinfo, quality, force_baseline);
+}
+
+
+/*
+ * Huffman table setup routines
+ */
+
+LOCAL void
+add_huff_table (j_compress_ptr cinfo,
+		JHUFF_TBL **htblptr, const UINT8 *bits, const UINT8 *val)
+/* Define a Huffman table */
+{
+  if (*htblptr == NULL)
+    *htblptr = jpeg_alloc_huff_table((j_common_ptr) cinfo);
+  
+  MEMCOPY((*htblptr)->bits, bits, SIZEOF((*htblptr)->bits));
+  MEMCOPY((*htblptr)->huffval, val, SIZEOF((*htblptr)->huffval));
+
+  /* Initialize sent_table FALSE so table will be written to JPEG file. */
+  (*htblptr)->sent_table = FALSE;
+}
+
+
+LOCAL void
+std_huff_tables (j_compress_ptr cinfo)
+/* Set up the standard Huffman tables (cf. JPEG standard section K.3) */
+/* IMPORTANT: these are only valid for 8-bit data precision! */
+{
+  static const UINT8 bits_dc_luminance[17] =
+    { /* 0-base */ 0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0 };
+  static const UINT8 val_dc_luminance[] =
+    { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
+  
+  static const UINT8 bits_dc_chrominance[17] =
+    { /* 0-base */ 0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0 };
+  static const UINT8 val_dc_chrominance[] =
+    { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
+  
+  static const UINT8 bits_ac_luminance[17] =
+    { /* 0-base */ 0, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 0x7d };
+  static const UINT8 val_ac_luminance[] =
+    { 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12,
+      0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07,
+      0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08,
+      0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0,
+      0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16,
+      0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28,
+      0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
+      0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
+      0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
+      0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
+      0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
+      0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
+      0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98,
+      0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
+      0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6,
+      0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5,
+      0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4,
+      0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2,
+      0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea,
+      0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
+      0xf9, 0xfa };
+  
+  static const UINT8 bits_ac_chrominance[17] =
+    { /* 0-base */ 0, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 0x77 };
+  static const UINT8 val_ac_chrominance[] =
+    { 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21,
+      0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
+      0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91,
+      0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0,
+      0x15, 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34,
+      0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26,
+      0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38,
+      0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,
+      0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
+      0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
+      0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
+      0x79, 0x7a, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
+      0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96,
+      0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5,
+      0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4,
+      0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3,
+      0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2,
+      0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda,
+      0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9,
+      0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
+      0xf9, 0xfa };
+  
+  add_huff_table(cinfo, &cinfo->dc_huff_tbl_ptrs[0],
+		 bits_dc_luminance, val_dc_luminance);
+  add_huff_table(cinfo, &cinfo->ac_huff_tbl_ptrs[0],
+		 bits_ac_luminance, val_ac_luminance);
+  add_huff_table(cinfo, &cinfo->dc_huff_tbl_ptrs[1],
+		 bits_dc_chrominance, val_dc_chrominance);
+  add_huff_table(cinfo, &cinfo->ac_huff_tbl_ptrs[1],
+		 bits_ac_chrominance, val_ac_chrominance);
+}
+
+
+/*
+ * Default parameter setup for compression.
+ *
+ * Applications that don't choose to use this routine must do their
+ * own setup of all these parameters.  Alternately, you can call this
+ * to establish defaults and then alter parameters selectively.  This
+ * is the recommended approach since, if we add any new parameters,
+ * your code will still work (they'll be set to reasonable defaults).
+ */
+
+GLOBAL void
+jpeg_set_defaults (j_compress_ptr cinfo)
+{
+  int i;
+
+  /* Safety check to ensure start_compress not called yet. */
+  if (cinfo->global_state != CSTATE_START)
+    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+
+  /* Allocate comp_info array large enough for maximum component count.
+   * Array is made permanent in case application wants to compress
+   * multiple images at same param settings.
+   */
+  if (cinfo->comp_info == NULL)
+    cinfo->comp_info = (jpeg_component_info *)
+      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
+				  MAX_COMPONENTS * SIZEOF(jpeg_component_info));
+
+  /* Initialize everything not dependent on the color space */
+
+  cinfo->data_precision = BITS_IN_JSAMPLE;
+  /* Set up two quantization tables using default quality of 75 */
+  jpeg_set_quality(cinfo, 75, TRUE);
+  /* Set up two Huffman tables */
+  std_huff_tables(cinfo);
+
+  /* Initialize default arithmetic coding conditioning */
+  for (i = 0; i < NUM_ARITH_TBLS; i++) {
+    cinfo->arith_dc_L[i] = 0;
+    cinfo->arith_dc_U[i] = 1;
+    cinfo->arith_ac_K[i] = 5;
+  }
+
+  /* Default is no multiple-scan output */
+  cinfo->scan_info = NULL;
+  cinfo->num_scans = 0;
+
+  /* Expect normal source image, not raw downsampled data */
+  cinfo->raw_data_in = FALSE;
+
+  /* Use Huffman coding, not arithmetic coding, by default */
+  cinfo->arith_code = FALSE;
+
+  /* By default, do extra passes to optimize entropy coding */
+  cinfo->optimize_coding = TRUE;
+  /* The standard Huffman tables are only valid for 8-bit data precision.
+   * If the precision is higher, force optimization on so that usable
+   * tables will be computed.  This test can be removed if default tables
+   * are supplied that are valid for the desired precision.
+   */
+  if (cinfo->data_precision > 8)
+    cinfo->optimize_coding = TRUE;
+
+  /* By default, use the simpler non-cosited sampling alignment */
+  cinfo->CCIR601_sampling = FALSE;
+
+  /* No input smoothing */
+  cinfo->smoothing_factor = 0;
+
+  /* DCT algorithm preference */
+  cinfo->dct_method = JDCT_DEFAULT;
+
+  /* No restart markers */
+  cinfo->restart_interval = 0;
+  cinfo->restart_in_rows = 0;
+
+  /* Fill in default JFIF marker parameters.  Note that whether the marker
+   * will actually be written is determined by jpeg_set_colorspace.
+   */
+  cinfo->density_unit = 0;	/* Pixel size is unknown by default */
+  cinfo->X_density = 1;		/* Pixel aspect ratio is square by default */
+  cinfo->Y_density = 1;
+
+  /* Choose JPEG colorspace based on input space, set defaults accordingly */
+
+  jpeg_default_colorspace(cinfo);
+}
+
+
+/*
+ * Select an appropriate JPEG colorspace for in_color_space.
+ */
+
+GLOBAL void
+jpeg_default_colorspace (j_compress_ptr cinfo)
+{
+  switch (cinfo->in_color_space) {
+  case JCS_GRAYSCALE:
+    jpeg_set_colorspace(cinfo, JCS_GRAYSCALE);
+    break;
+  case JCS_RGB:
+    jpeg_set_colorspace(cinfo, JCS_YCbCr);
+    break;
+  case JCS_YCbCr:
+    jpeg_set_colorspace(cinfo, JCS_YCbCr);
+    break;
+  case JCS_CMYK:
+    jpeg_set_colorspace(cinfo, JCS_CMYK); /* By default, no translation */
+    break;
+  case JCS_YCCK:
+    jpeg_set_colorspace(cinfo, JCS_YCCK);
+    break;
+  case JCS_UNKNOWN:
+    jpeg_set_colorspace(cinfo, JCS_UNKNOWN);
+    break;
+  default:
+    ERREXIT(cinfo, JERR_BAD_IN_COLORSPACE);
+  }
+}
+
+
+/*
+ * Set the JPEG colorspace, and choose colorspace-dependent default values.
+ */
+
+GLOBAL void
+jpeg_set_colorspace (j_compress_ptr cinfo, J_COLOR_SPACE colorspace)
+{
+  jpeg_component_info * compptr;
+  int ci;
+
+#define SET_COMP(index,id,hsamp,vsamp,quant,dctbl,actbl)  \
+  (compptr = &cinfo->comp_info[index], \
+   compptr->component_id = (id), \
+   compptr->h_samp_factor = (hsamp), \
+   compptr->v_samp_factor = (vsamp), \
+   compptr->quant_tbl_no = (quant), \
+   compptr->dc_tbl_no = (dctbl), \
+   compptr->ac_tbl_no = (actbl) )
+
+  /* Safety check to ensure start_compress not called yet. */
+  if (cinfo->global_state != CSTATE_START)
+    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+
+  /* For all colorspaces, we use Q and Huff tables 0 for luminance components,
+   * tables 1 for chrominance components.
+   */
+
+  cinfo->jpeg_color_space = colorspace;
+
+  cinfo->write_JFIF_header = FALSE; /* No marker for non-JFIF colorspaces */
+  cinfo->write_Adobe_marker = FALSE; /* write no Adobe marker by default */
+
+  switch (colorspace) {
+  case JCS_GRAYSCALE:
+    cinfo->write_JFIF_header = TRUE; /* Write a JFIF marker */
+    cinfo->num_components = 1;
+    /* JFIF specifies component ID 1 */
+    SET_COMP(0, 1, 1,1, 0, 0,0);
+    break;
+  case JCS_RGB:
+    cinfo->write_Adobe_marker = TRUE; /* write Adobe marker to flag RGB */
+    cinfo->num_components = 3;
+    SET_COMP(0, 0x52 /* 'R' */, 1,1, 0, 0,0);
+    SET_COMP(1, 0x47 /* 'G' */, 1,1, 0, 0,0);
+    SET_COMP(2, 0x42 /* 'B' */, 1,1, 0, 0,0);
+    break;
+  case JCS_YCbCr:
+    cinfo->write_JFIF_header = TRUE; /* Write a JFIF marker */
+    cinfo->num_components = 3;
+    /* JFIF specifies component IDs 1,2,3 */
+    /* We default to 2x2 subsamples of chrominance */
+    SET_COMP(0, 1, 2,2, 0, 0,0);
+    SET_COMP(1, 2, 1,1, 1, 1,1);
+    SET_COMP(2, 3, 1,1, 1, 1,1);
+    break;
+  case JCS_CMYK:
+    cinfo->write_Adobe_marker = TRUE; /* write Adobe marker to flag CMYK */
+    cinfo->num_components = 4;
+    SET_COMP(0, 0x43 /* 'C' */, 1,1, 0, 0,0);
+    SET_COMP(1, 0x4D /* 'M' */, 1,1, 0, 0,0);
+    SET_COMP(2, 0x59 /* 'Y' */, 1,1, 0, 0,0);
+    SET_COMP(3, 0x4B /* 'K' */, 1,1, 0, 0,0);
+    break;
+  case JCS_YCCK:
+    cinfo->write_Adobe_marker = TRUE; /* write Adobe marker to flag YCCK */
+    cinfo->num_components = 4;
+    SET_COMP(0, 1, 2,2, 0, 0,0);
+    SET_COMP(1, 2, 1,1, 1, 1,1);
+    SET_COMP(2, 3, 1,1, 1, 1,1);
+    SET_COMP(3, 4, 2,2, 0, 0,0);
+    break;
+  case JCS_UNKNOWN:
+    cinfo->num_components = cinfo->input_components;
+    if (cinfo->num_components < 1 || cinfo->num_components > MAX_COMPONENTS)
+      ERREXIT2(cinfo, JERR_COMPONENT_COUNT, cinfo->num_components,
+	       MAX_COMPONENTS);
+    for (ci = 0; ci < cinfo->num_components; ci++) {
+      SET_COMP(ci, ci, 1,1, 0, 0,0);
+    }
+    break;
+  default:
+    ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
+  }
+}
+
+
+#ifdef C_PROGRESSIVE_SUPPORTED
+
+LOCAL jpeg_scan_info *
+fill_a_scan (jpeg_scan_info * scanptr, int ci,
+	     int Ss, int Se, int Ah, int Al)
+/* Support routine: generate one scan for specified component */
+{
+  scanptr->comps_in_scan = 1;
+  scanptr->component_index[0] = ci;
+  scanptr->Ss = Ss;
+  scanptr->Se = Se;
+  scanptr->Ah = Ah;
+  scanptr->Al = Al;
+  scanptr++;
+  return scanptr;
+}
+
+LOCAL jpeg_scan_info *
+fill_scans (jpeg_scan_info * scanptr, int ncomps,
+	    int Ss, int Se, int Ah, int Al)
+/* Support routine: generate one scan for each component */
+{
+  int ci;
+
+  for (ci = 0; ci < ncomps; ci++) {
+    scanptr->comps_in_scan = 1;
+    scanptr->component_index[0] = ci;
+    scanptr->Ss = Ss;
+    scanptr->Se = Se;
+    scanptr->Ah = Ah;
+    scanptr->Al = Al;
+    scanptr++;
+  }
+  return scanptr;
+}
+
+LOCAL jpeg_scan_info *
+fill_dc_scans (jpeg_scan_info * scanptr, int ncomps, int Ah, int Al)
+/* Support routine: generate interleaved DC scan if possible, else N scans */
+{
+  int ci;
+
+  if (ncomps <= MAX_COMPS_IN_SCAN) {
+    /* Single interleaved DC scan */
+    scanptr->comps_in_scan = ncomps;
+    for (ci = 0; ci < ncomps; ci++)
+      scanptr->component_index[ci] = ci;
+    scanptr->Ss = scanptr->Se = 0;
+    scanptr->Ah = Ah;
+    scanptr->Al = Al;
+    scanptr++;
+  } else {
+    /* Noninterleaved DC scan for each component */
+    scanptr = fill_scans(scanptr, ncomps, 0, 0, Ah, Al);
+  }
+  return scanptr;
+}
+
+
+/*
+ * Create a recommended progressive-JPEG script.
+ * cinfo->num_components and cinfo->jpeg_color_space must be correct.
+ */
+
+GLOBAL void
+jpeg_simple_progression (j_compress_ptr cinfo)
+{
+  int ncomps = cinfo->num_components;
+  int nscans;
+  jpeg_scan_info * scanptr;
+
+  /* Safety check to ensure start_compress not called yet. */
+  if (cinfo->global_state != CSTATE_START)
+    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+
+  /* Figure space needed for script.  Calculation must match code below! */
+  if (ncomps == 3 && cinfo->jpeg_color_space == JCS_YCbCr) {
+    /* Custom script for YCbCr color images. */
+    nscans = 10;
+  } else {
+    /* All-purpose script for other color spaces. */
+    if (ncomps > MAX_COMPS_IN_SCAN)
+      nscans = 6 * ncomps;	/* 2 DC + 4 AC scans per component */
+    else
+      nscans = 2 + 4 * ncomps;	/* 2 DC scans; 4 AC scans per component */
+  }
+
+  /* Allocate space for script. */
+  /* We use permanent pool just in case application re-uses script. */
+  scanptr = (jpeg_scan_info *)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
+				nscans * SIZEOF(jpeg_scan_info));
+  cinfo->scan_info = scanptr;
+  cinfo->num_scans = nscans;
+
+  if (ncomps == 3 && cinfo->jpeg_color_space == JCS_YCbCr) {
+    /* Custom script for YCbCr color images. */
+    /* Initial DC scan */
+    scanptr = fill_dc_scans(scanptr, ncomps, 0, 1);
+    /* Initial AC scan: get some luma data out in a hurry */
+    scanptr = fill_a_scan(scanptr, 0, 1, 5, 0, 2);
+    /* Chroma data is too small to be worth expending many scans on */
+    scanptr = fill_a_scan(scanptr, 2, 1, 63, 0, 1);
+    scanptr = fill_a_scan(scanptr, 1, 1, 63, 0, 1);
+    /* Complete spectral selection for luma AC */
+    scanptr = fill_a_scan(scanptr, 0, 6, 63, 0, 2);
+    /* Refine next bit of luma AC */
+    scanptr = fill_a_scan(scanptr, 0, 1, 63, 2, 1);
+    /* Finish DC successive approximation */
+    scanptr = fill_dc_scans(scanptr, ncomps, 1, 0);
+    /* Finish AC successive approximation */
+    scanptr = fill_a_scan(scanptr, 2, 1, 63, 1, 0);
+    scanptr = fill_a_scan(scanptr, 1, 1, 63, 1, 0);
+    /* Luma bottom bit comes last since it's usually largest scan */
+    scanptr = fill_a_scan(scanptr, 0, 1, 63, 1, 0);
+  } else {
+    /* All-purpose script for other color spaces. */
+    /* Successive approximation first pass */
+    scanptr = fill_dc_scans(scanptr, ncomps, 0, 1);
+    scanptr = fill_scans(scanptr, ncomps, 1, 5, 0, 2);
+    scanptr = fill_scans(scanptr, ncomps, 6, 63, 0, 2);
+    /* Successive approximation second pass */
+    scanptr = fill_scans(scanptr, ncomps, 1, 63, 2, 1);
+    /* Successive approximation final pass */
+    scanptr = fill_dc_scans(scanptr, ncomps, 1, 0);
+    scanptr = fill_scans(scanptr, ncomps, 1, 63, 1, 0);
+  }
+}
+
+#endif /* C_PROGRESSIVE_SUPPORTED */
diff --git a/code/jpeg-6/jcphuff.cpp b/code/jpeg-6/jcphuff.cpp
new file mode 100644
index 0000000..ed9d0ac
--- /dev/null
+++ b/code/jpeg-6/jcphuff.cpp
@@ -0,0 +1,835 @@
+/*
+ * jcphuff.c
+ *
+ * Copyright (C) 1995, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains Huffman entropy encoding routines for progressive JPEG.
+ *
+ * We do not support output suspension in this module, since the library
+ * currently does not allow multiple-scan files to be written with output
+ * suspension.
+ */
+
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jchuff.h"		/* Declarations shared with jchuff.c */
+
+#ifdef C_PROGRESSIVE_SUPPORTED
+
+/* Expanded entropy encoder object for progressive Huffman encoding. */
+
+typedef struct {
+  struct jpeg_entropy_encoder pub; /* public fields */
+
+  /* Mode flag: TRUE for optimization, FALSE for actual data output */
+  boolean gather_statistics;
+
+  /* Bit-level coding status.
+   * next_output_byte/free_in_buffer are local copies of cinfo->dest fields.
+   */
+  JOCTET * next_output_byte;	/* => next byte to write in buffer */
+  size_t free_in_buffer;	/* # of byte spaces remaining in buffer */
+  INT32 put_buffer;		/* current bit-accumulation buffer */
+  int put_bits;			/* # of bits now in it */
+  j_compress_ptr cinfo;		/* link to cinfo (needed for dump_buffer) */
+
+  /* Coding status for DC components */
+  int last_dc_val[MAX_COMPS_IN_SCAN]; /* last DC coef for each component */
+
+  /* Coding status for AC components */
+  int ac_tbl_no;		/* the table number of the single component */
+  unsigned int EOBRUN;		/* run length of EOBs */
+  unsigned int BE;		/* # of buffered correction bits before MCU */
+  char * bit_buffer;		/* buffer for correction bits (1 per char) */
+  /* packing correction bits tightly would save some space but cost time... */
+
+  unsigned int restarts_to_go;	/* MCUs left in this restart interval */
+  int next_restart_num;		/* next restart number to write (0-7) */
+
+  /* Pointers to derived tables (these workspaces have image lifespan).
+   * Since any one scan codes only DC or only AC, we only need one set
+   * of tables, not one for DC and one for AC.
+   */
+  c_derived_tbl * derived_tbls[NUM_HUFF_TBLS];
+
+  /* Statistics tables for optimization; again, one set is enough */
+  long * count_ptrs[NUM_HUFF_TBLS];
+} phuff_entropy_encoder;
+
+typedef phuff_entropy_encoder * phuff_entropy_ptr;
+
+/* MAX_CORR_BITS is the number of bits the AC refinement correction-bit
+ * buffer can hold.  Larger sizes may slightly improve compression, but
+ * 1000 is already well into the realm of overkill.
+ * The minimum safe size is 64 bits.
+ */
+
+#define MAX_CORR_BITS  1000	/* Max # of correction bits I can buffer */
+
+/* IRIGHT_SHIFT is like RIGHT_SHIFT, but works on int rather than INT32.
+ * We assume that int right shift is unsigned if INT32 right shift is,
+ * which should be safe.
+ */
+
+#ifdef RIGHT_SHIFT_IS_UNSIGNED
+#define ISHIFT_TEMPS	int ishift_temp;
+#define IRIGHT_SHIFT(x,shft)  \
+	((ishift_temp = (x)) < 0 ? \
+	 (ishift_temp >> (shft)) | ((~0) << (16-(shft))) : \
+	 (ishift_temp >> (shft)))
+#else
+#define ISHIFT_TEMPS
+#define IRIGHT_SHIFT(x,shft)	((x) >> (shft))
+#endif
+
+/* Forward declarations */
+METHODDEF boolean encode_mcu_DC_first JPP((j_compress_ptr cinfo,
+					   JBLOCKROW *MCU_data));
+METHODDEF boolean encode_mcu_AC_first JPP((j_compress_ptr cinfo,
+					   JBLOCKROW *MCU_data));
+METHODDEF boolean encode_mcu_DC_refine JPP((j_compress_ptr cinfo,
+					    JBLOCKROW *MCU_data));
+METHODDEF boolean encode_mcu_AC_refine JPP((j_compress_ptr cinfo,
+					    JBLOCKROW *MCU_data));
+METHODDEF void finish_pass_phuff JPP((j_compress_ptr cinfo));
+METHODDEF void finish_pass_gather_phuff JPP((j_compress_ptr cinfo));
+
+
+/*
+ * Initialize for a Huffman-compressed scan using progressive JPEG.
+ */
+
+METHODDEF void
+start_pass_phuff (j_compress_ptr cinfo, boolean gather_statistics)
+{  
+  phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy;
+  boolean is_DC_band;
+  int ci, tbl;
+  jpeg_component_info * compptr;
+
+  entropy->cinfo = cinfo;
+  entropy->gather_statistics = gather_statistics;
+
+  is_DC_band = (cinfo->Ss == 0);
+
+  /* We assume jcmaster.c already validated the scan parameters. */
+
+  /* Select execution routines */
+  if (cinfo->Ah == 0) {
+    if (is_DC_band)
+      entropy->pub.encode_mcu = encode_mcu_DC_first;
+    else
+      entropy->pub.encode_mcu = encode_mcu_AC_first;
+  } else {
+    if (is_DC_band)
+      entropy->pub.encode_mcu = encode_mcu_DC_refine;
+    else {
+      entropy->pub.encode_mcu = encode_mcu_AC_refine;
+      /* AC refinement needs a correction bit buffer */
+      if (entropy->bit_buffer == NULL)
+	entropy->bit_buffer = (char *)
+	  (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				      MAX_CORR_BITS * SIZEOF(char));
+    }
+  }
+  if (gather_statistics)
+    entropy->pub.finish_pass = finish_pass_gather_phuff;
+  else
+    entropy->pub.finish_pass = finish_pass_phuff;
+
+  /* Only DC coefficients may be interleaved, so cinfo->comps_in_scan = 1
+   * for AC coefficients.
+   */
+  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+    compptr = cinfo->cur_comp_info[ci];
+    /* Initialize DC predictions to 0 */
+    entropy->last_dc_val[ci] = 0;
+    /* Make sure requested tables are present */
+    /* (In gather mode, tables need not be allocated yet) */
+    if (is_DC_band) {
+      if (cinfo->Ah != 0)	/* DC refinement needs no table */
+	continue;
+      tbl = compptr->dc_tbl_no;
+      if (tbl < 0 || tbl >= NUM_HUFF_TBLS ||
+	  (cinfo->dc_huff_tbl_ptrs[tbl] == NULL && !gather_statistics))
+	ERREXIT1(cinfo,JERR_NO_HUFF_TABLE, tbl);
+    } else {
+      entropy->ac_tbl_no = tbl = compptr->ac_tbl_no;
+      if (tbl < 0 || tbl >= NUM_HUFF_TBLS ||
+          (cinfo->ac_huff_tbl_ptrs[tbl] == NULL && !gather_statistics))
+        ERREXIT1(cinfo,JERR_NO_HUFF_TABLE, tbl);
+    }
+    if (gather_statistics) {
+      /* Allocate and zero the statistics tables */
+      /* Note that jpeg_gen_optimal_table expects 257 entries in each table! */
+      if (entropy->count_ptrs[tbl] == NULL)
+	entropy->count_ptrs[tbl] = (long *)
+	  (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				      257 * SIZEOF(long));
+      MEMZERO(entropy->count_ptrs[tbl], 257 * SIZEOF(long));
+    } else {
+      /* Compute derived values for Huffman tables */
+      /* We may do this more than once for a table, but it's not expensive */
+      if (is_DC_band)
+        jpeg_make_c_derived_tbl(cinfo, cinfo->dc_huff_tbl_ptrs[tbl],
+				& entropy->derived_tbls[tbl]);
+      else
+        jpeg_make_c_derived_tbl(cinfo, cinfo->ac_huff_tbl_ptrs[tbl],
+				& entropy->derived_tbls[tbl]);
+    }
+  }
+
+  /* Initialize AC stuff */
+  entropy->EOBRUN = 0;
+  entropy->BE = 0;
+
+  /* Initialize bit buffer to empty */
+  entropy->put_buffer = 0;
+  entropy->put_bits = 0;
+
+  /* Initialize restart stuff */
+  entropy->restarts_to_go = cinfo->restart_interval;
+  entropy->next_restart_num = 0;
+}
+
+
+/* Outputting bytes to the file.
+ * NB: these must be called only when actually outputting,
+ * that is, entropy->gather_statistics == FALSE.
+ */
+
+/* Emit a byte */
+#define emit_byte(entropy,val)  \
+	{ *(entropy)->next_output_byte++ = (JOCTET) (val);  \
+	  if (--(entropy)->free_in_buffer == 0)  \
+	    dump_buffer(entropy); }
+
+
+LOCAL void
+dump_buffer (phuff_entropy_ptr entropy)
+/* Empty the output buffer; we do not support suspension in this module. */
+{
+  struct jpeg_destination_mgr * dest = entropy->cinfo->dest;
+
+  if (! (*dest->empty_output_buffer) (entropy->cinfo))
+    ERREXIT(entropy->cinfo, JERR_CANT_SUSPEND);
+  /* After a successful buffer dump, must reset buffer pointers */
+  entropy->next_output_byte = dest->next_output_byte;
+  entropy->free_in_buffer = dest->free_in_buffer;
+}
+
+
+/* Outputting bits to the file */
+
+/* Only the right 24 bits of put_buffer are used; the valid bits are
+ * left-justified in this part.  At most 16 bits can be passed to emit_bits
+ * in one call, and we never retain more than 7 bits in put_buffer
+ * between calls, so 24 bits are sufficient.
+ */
+
+INLINE
+LOCAL void
+emit_bits (phuff_entropy_ptr entropy, unsigned int code, int size)
+/* Emit some bits, unless we are in gather mode */
+{
+  /* This routine is heavily used, so it's worth coding tightly. */
+  register INT32 put_buffer = (INT32) code;
+  register int put_bits = entropy->put_bits;
+
+  /* if size is 0, caller used an invalid Huffman table entry */
+  if (size == 0)
+    ERREXIT(entropy->cinfo, JERR_HUFF_MISSING_CODE);
+
+  if (entropy->gather_statistics)
+    return;			/* do nothing if we're only getting stats */
+
+  put_buffer &= (((INT32) 1)<<size) - 1; /* mask off any extra bits in code */
+  
+  put_bits += size;		/* new number of bits in buffer */
+  
+  put_buffer <<= 24 - put_bits; /* align incoming bits */
+
+  put_buffer |= entropy->put_buffer; /* and merge with old buffer contents */
+
+  while (put_bits >= 8) {
+    int c = (int) ((put_buffer >> 16) & 0xFF);
+    
+    emit_byte(entropy, c);
+    if (c == 0xFF) {		/* need to stuff a zero byte? */
+      emit_byte(entropy, 0);
+    }
+    put_buffer <<= 8;
+    put_bits -= 8;
+  }
+
+  entropy->put_buffer = put_buffer; /* update variables */
+  entropy->put_bits = put_bits;
+}
+
+
+LOCAL void
+flush_bits (phuff_entropy_ptr entropy)
+{
+  emit_bits(entropy, 0x7F, 7); /* fill any partial byte with ones */
+  entropy->put_buffer = 0;     /* and reset bit-buffer to empty */
+  entropy->put_bits = 0;
+}
+
+
+/*
+ * Emit (or just count) a Huffman symbol.
+ */
+
+INLINE
+LOCAL void
+emit_symbol (phuff_entropy_ptr entropy, int tbl_no, int symbol)
+{
+  if (entropy->gather_statistics)
+    entropy->count_ptrs[tbl_no][symbol]++;
+  else {
+    c_derived_tbl * tbl = entropy->derived_tbls[tbl_no];
+    emit_bits(entropy, tbl->ehufco[symbol], tbl->ehufsi[symbol]);
+  }
+}
+
+
+/*
+ * Emit bits from a correction bit buffer.
+ */
+
+LOCAL void
+emit_buffered_bits (phuff_entropy_ptr entropy, char * bufstart,
+		    unsigned int nbits)
+{
+  if (entropy->gather_statistics)
+    return;			/* no real work */
+
+  while (nbits > 0) {
+    emit_bits(entropy, (unsigned int) (*bufstart), 1);
+    bufstart++;
+    nbits--;
+  }
+}
+
+
+/*
+ * Emit any pending EOBRUN symbol.
+ */
+
+LOCAL void
+emit_eobrun (phuff_entropy_ptr entropy)
+{
+  register int temp, nbits;
+
+  if (entropy->EOBRUN > 0) {	/* if there is any pending EOBRUN */
+    temp = entropy->EOBRUN;
+    nbits = 0;
+    while ((temp >>= 1))
+      nbits++;
+
+    emit_symbol(entropy, entropy->ac_tbl_no, nbits << 4);
+    if (nbits)
+      emit_bits(entropy, entropy->EOBRUN, nbits);
+
+    entropy->EOBRUN = 0;
+
+    /* Emit any buffered correction bits */
+    emit_buffered_bits(entropy, entropy->bit_buffer, entropy->BE);
+    entropy->BE = 0;
+  }
+}
+
+
+/*
+ * Emit a restart marker & resynchronize predictions.
+ */
+
+LOCAL void
+emit_restart (phuff_entropy_ptr entropy, int restart_num)
+{
+  int ci;
+
+  emit_eobrun(entropy);
+
+  if (! entropy->gather_statistics) {
+    flush_bits(entropy);
+    emit_byte(entropy, 0xFF);
+    emit_byte(entropy, JPEG_RST0 + restart_num);
+  }
+
+  if (entropy->cinfo->Ss == 0) {
+    /* Re-initialize DC predictions to 0 */
+    for (ci = 0; ci < entropy->cinfo->comps_in_scan; ci++)
+      entropy->last_dc_val[ci] = 0;
+  } else {
+    /* Re-initialize all AC-related fields to 0 */
+    entropy->EOBRUN = 0;
+    entropy->BE = 0;
+  }
+}
+
+
+/*
+ * MCU encoding for DC initial scan (either spectral selection,
+ * or first pass of successive approximation).
+ */
+
+METHODDEF boolean
+encode_mcu_DC_first (j_compress_ptr cinfo, JBLOCKROW *MCU_data)
+{
+  phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy;
+  register int temp, temp2;
+  register int nbits;
+  int blkn, ci;
+  int Al = cinfo->Al;
+  JBLOCKROW block;
+  jpeg_component_info * compptr;
+  ISHIFT_TEMPS
+
+  entropy->next_output_byte = cinfo->dest->next_output_byte;
+  entropy->free_in_buffer = cinfo->dest->free_in_buffer;
+
+  /* Emit restart marker if needed */
+  if (cinfo->restart_interval)
+    if (entropy->restarts_to_go == 0)
+      emit_restart(entropy, entropy->next_restart_num);
+
+  /* Encode the MCU data blocks */
+  for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
+    block = MCU_data[blkn];
+    ci = cinfo->MCU_membership[blkn];
+    compptr = cinfo->cur_comp_info[ci];
+
+    /* Compute the DC value after the required point transform by Al.
+     * This is simply an arithmetic right shift.
+     */
+    temp2 = IRIGHT_SHIFT((int) ((*block)[0]), Al);
+
+    /* DC differences are figured on the point-transformed values. */
+    temp = temp2 - entropy->last_dc_val[ci];
+    entropy->last_dc_val[ci] = temp2;
+
+    /* Encode the DC coefficient difference per section G.1.2.1 */
+    temp2 = temp;
+    if (temp < 0) {
+      temp = -temp;		/* temp is abs value of input */
+      /* For a negative input, want temp2 = bitwise complement of abs(input) */
+      /* This code assumes we are on a two's complement machine */
+      temp2--;
+    }
+    
+    /* Find the number of bits needed for the magnitude of the coefficient */
+    nbits = 0;
+    while (temp) {
+      nbits++;
+      temp >>= 1;
+    }
+    
+    /* Count/emit the Huffman-coded symbol for the number of bits */
+    emit_symbol(entropy, compptr->dc_tbl_no, nbits);
+    
+    /* Emit that number of bits of the value, if positive, */
+    /* or the complement of its magnitude, if negative. */
+    if (nbits)			/* emit_bits rejects calls with size 0 */
+      emit_bits(entropy, (unsigned int) temp2, nbits);
+  }
+
+  cinfo->dest->next_output_byte = entropy->next_output_byte;
+  cinfo->dest->free_in_buffer = entropy->free_in_buffer;
+
+  /* Update restart-interval state too */
+  if (cinfo->restart_interval) {
+    if (entropy->restarts_to_go == 0) {
+      entropy->restarts_to_go = cinfo->restart_interval;
+      entropy->next_restart_num++;
+      entropy->next_restart_num &= 7;
+    }
+    entropy->restarts_to_go--;
+  }
+
+  return TRUE;
+}
+
+
+/*
+ * MCU encoding for AC initial scan (either spectral selection,
+ * or first pass of successive approximation).
+ */
+
+METHODDEF boolean
+encode_mcu_AC_first (j_compress_ptr cinfo, JBLOCKROW *MCU_data)
+{
+  phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy;
+  register int temp, temp2;
+  register int nbits;
+  register int r, k;
+  int Se = cinfo->Se;
+  int Al = cinfo->Al;
+  JBLOCKROW block;
+
+  entropy->next_output_byte = cinfo->dest->next_output_byte;
+  entropy->free_in_buffer = cinfo->dest->free_in_buffer;
+
+  /* Emit restart marker if needed */
+  if (cinfo->restart_interval)
+    if (entropy->restarts_to_go == 0)
+      emit_restart(entropy, entropy->next_restart_num);
+
+  /* Encode the MCU data block */
+  block = MCU_data[0];
+
+  /* Encode the AC coefficients per section G.1.2.2, fig. G.3 */
+  
+  r = 0;			/* r = run length of zeros */
+   
+  for (k = cinfo->Ss; k <= Se; k++) {
+    if ((temp = (*block)[jpeg_natural_order[k]]) == 0) {
+      r++;
+      continue;
+    }
+    /* We must apply the point transform by Al.  For AC coefficients this
+     * is an integer division with rounding towards 0.  To do this portably
+     * in C, we shift after obtaining the absolute value; so the code is
+     * interwoven with finding the abs value (temp) and output bits (temp2).
+     */
+    if (temp < 0) {
+      temp = -temp;		/* temp is abs value of input */
+      temp >>= Al;		/* apply the point transform */
+      /* For a negative coef, want temp2 = bitwise complement of abs(coef) */
+      temp2 = ~temp;
+    } else {
+      temp >>= Al;		/* apply the point transform */
+      temp2 = temp;
+    }
+    /* Watch out for case that nonzero coef is zero after point transform */
+    if (temp == 0) {
+      r++;
+      continue;
+    }
+
+    /* Emit any pending EOBRUN */
+    if (entropy->EOBRUN > 0)
+      emit_eobrun(entropy);
+    /* if run length > 15, must emit special run-length-16 codes (0xF0) */
+    while (r > 15) {
+      emit_symbol(entropy, entropy->ac_tbl_no, 0xF0);
+      r -= 16;
+    }
+
+    /* Find the number of bits needed for the magnitude of the coefficient */
+    nbits = 1;			/* there must be at least one 1 bit */
+    while ((temp >>= 1))
+      nbits++;
+
+    /* Count/emit Huffman symbol for run length / number of bits */
+    emit_symbol(entropy, entropy->ac_tbl_no, (r << 4) + nbits);
+
+    /* Emit that number of bits of the value, if positive, */
+    /* or the complement of its magnitude, if negative. */
+    emit_bits(entropy, (unsigned int) temp2, nbits);
+
+    r = 0;			/* reset zero run length */
+  }
+
+  if (r > 0) {			/* If there are trailing zeroes, */
+    entropy->EOBRUN++;		/* count an EOB */
+    if (entropy->EOBRUN == 0x7FFF)
+      emit_eobrun(entropy);	/* force it out to avoid overflow */
+  }
+
+  cinfo->dest->next_output_byte = entropy->next_output_byte;
+  cinfo->dest->free_in_buffer = entropy->free_in_buffer;
+
+  /* Update restart-interval state too */
+  if (cinfo->restart_interval) {
+    if (entropy->restarts_to_go == 0) {
+      entropy->restarts_to_go = cinfo->restart_interval;
+      entropy->next_restart_num++;
+      entropy->next_restart_num &= 7;
+    }
+    entropy->restarts_to_go--;
+  }
+
+  return TRUE;
+}
+
+
+/*
+ * MCU encoding for DC successive approximation refinement scan.
+ * Note: we assume such scans can be multi-component, although the spec
+ * is not very clear on the point.
+ */
+
+METHODDEF boolean
+encode_mcu_DC_refine (j_compress_ptr cinfo, JBLOCKROW *MCU_data)
+{
+  phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy;
+  register int temp;
+  int blkn;
+  int Al = cinfo->Al;
+  JBLOCKROW block;
+
+  entropy->next_output_byte = cinfo->dest->next_output_byte;
+  entropy->free_in_buffer = cinfo->dest->free_in_buffer;
+
+  /* Emit restart marker if needed */
+  if (cinfo->restart_interval)
+    if (entropy->restarts_to_go == 0)
+      emit_restart(entropy, entropy->next_restart_num);
+
+  /* Encode the MCU data blocks */
+  for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
+    block = MCU_data[blkn];
+
+    /* We simply emit the Al'th bit of the DC coefficient value. */
+    temp = (*block)[0];
+    emit_bits(entropy, (unsigned int) (temp >> Al), 1);
+  }
+
+  cinfo->dest->next_output_byte = entropy->next_output_byte;
+  cinfo->dest->free_in_buffer = entropy->free_in_buffer;
+
+  /* Update restart-interval state too */
+  if (cinfo->restart_interval) {
+    if (entropy->restarts_to_go == 0) {
+      entropy->restarts_to_go = cinfo->restart_interval;
+      entropy->next_restart_num++;
+      entropy->next_restart_num &= 7;
+    }
+    entropy->restarts_to_go--;
+  }
+
+  return TRUE;
+}
+
+
+/*
+ * MCU encoding for AC successive approximation refinement scan.
+ */
+
+METHODDEF boolean
+encode_mcu_AC_refine (j_compress_ptr cinfo, JBLOCKROW *MCU_data)
+{
+  phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy;
+  register int temp;
+  register int r, k;
+  int EOB;
+  char *BR_buffer;
+  unsigned int BR;
+  int Se = cinfo->Se;
+  int Al = cinfo->Al;
+  JBLOCKROW block;
+  int absvalues[DCTSIZE2];
+
+  entropy->next_output_byte = cinfo->dest->next_output_byte;
+  entropy->free_in_buffer = cinfo->dest->free_in_buffer;
+
+  /* Emit restart marker if needed */
+  if (cinfo->restart_interval)
+    if (entropy->restarts_to_go == 0)
+      emit_restart(entropy, entropy->next_restart_num);
+
+  /* Encode the MCU data block */
+  block = MCU_data[0];
+
+  /* It is convenient to make a pre-pass to determine the transformed
+   * coefficients' absolute values and the EOB position.
+   */
+  EOB = 0;
+  for (k = cinfo->Ss; k <= Se; k++) {
+    temp = (*block)[jpeg_natural_order[k]];
+    /* We must apply the point transform by Al.  For AC coefficients this
+     * is an integer division with rounding towards 0.  To do this portably
+     * in C, we shift after obtaining the absolute value.
+     */
+    if (temp < 0)
+      temp = -temp;		/* temp is abs value of input */
+    temp >>= Al;		/* apply the point transform */
+    absvalues[k] = temp;	/* save abs value for main pass */
+    if (temp == 1)
+      EOB = k;			/* EOB = index of last newly-nonzero coef */
+  }
+
+  /* Encode the AC coefficients per section G.1.2.3, fig. G.7 */
+  
+  r = 0;			/* r = run length of zeros */
+  BR = 0;			/* BR = count of buffered bits added now */
+  BR_buffer = entropy->bit_buffer + entropy->BE; /* Append bits to buffer */
+
+  for (k = cinfo->Ss; k <= Se; k++) {
+    if ((temp = absvalues[k]) == 0) {
+      r++;
+      continue;
+    }
+
+    /* Emit any required ZRLs, but not if they can be folded into EOB */
+    while (r > 15 && k <= EOB) {
+      /* emit any pending EOBRUN and the BE correction bits */
+      emit_eobrun(entropy);
+      /* Emit ZRL */
+      emit_symbol(entropy, entropy->ac_tbl_no, 0xF0);
+      r -= 16;
+      /* Emit buffered correction bits that must be associated with ZRL */
+      emit_buffered_bits(entropy, BR_buffer, BR);
+      BR_buffer = entropy->bit_buffer; /* BE bits are gone now */
+      BR = 0;
+    }
+
+    /* If the coef was previously nonzero, it only needs a correction bit.
+     * NOTE: a straight translation of the spec's figure G.7 would suggest
+     * that we also need to test r > 15.  But if r > 15, we can only get here
+     * if k > EOB, which implies that this coefficient is not 1.
+     */
+    if (temp > 1) {
+      /* The correction bit is the next bit of the absolute value. */
+      BR_buffer[BR++] = (char) (temp & 1);
+      continue;
+    }
+
+    /* Emit any pending EOBRUN and the BE correction bits */
+    emit_eobrun(entropy);
+
+    /* Count/emit Huffman symbol for run length / number of bits */
+    emit_symbol(entropy, entropy->ac_tbl_no, (r << 4) + 1);
+
+    /* Emit output bit for newly-nonzero coef */
+    temp = ((*block)[jpeg_natural_order[k]] < 0) ? 0 : 1;
+    emit_bits(entropy, (unsigned int) temp, 1);
+
+    /* Emit buffered correction bits that must be associated with this code */
+    emit_buffered_bits(entropy, BR_buffer, BR);
+    BR_buffer = entropy->bit_buffer; /* BE bits are gone now */
+    BR = 0;
+    r = 0;			/* reset zero run length */
+  }
+
+  if (r > 0 || BR > 0) {	/* If there are trailing zeroes, */
+    entropy->EOBRUN++;		/* count an EOB */
+    entropy->BE += BR;		/* concat my correction bits to older ones */
+    /* We force out the EOB if we risk either:
+     * 1. overflow of the EOB counter;
+     * 2. overflow of the correction bit buffer during the next MCU.
+     */
+    if (entropy->EOBRUN == 0x7FFF || entropy->BE > (MAX_CORR_BITS-DCTSIZE2+1))
+      emit_eobrun(entropy);
+  }
+
+  cinfo->dest->next_output_byte = entropy->next_output_byte;
+  cinfo->dest->free_in_buffer = entropy->free_in_buffer;
+
+  /* Update restart-interval state too */
+  if (cinfo->restart_interval) {
+    if (entropy->restarts_to_go == 0) {
+      entropy->restarts_to_go = cinfo->restart_interval;
+      entropy->next_restart_num++;
+      entropy->next_restart_num &= 7;
+    }
+    entropy->restarts_to_go--;
+  }
+
+  return TRUE;
+}
+
+
+/*
+ * Finish up at the end of a Huffman-compressed progressive scan.
+ */
+
+METHODDEF void
+finish_pass_phuff (j_compress_ptr cinfo)
+{   
+  phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy;
+
+  entropy->next_output_byte = cinfo->dest->next_output_byte;
+  entropy->free_in_buffer = cinfo->dest->free_in_buffer;
+
+  /* Flush out any buffered data */
+  emit_eobrun(entropy);
+  flush_bits(entropy);
+
+  cinfo->dest->next_output_byte = entropy->next_output_byte;
+  cinfo->dest->free_in_buffer = entropy->free_in_buffer;
+}
+
+
+/*
+ * Finish up a statistics-gathering pass and create the new Huffman tables.
+ */
+
+METHODDEF void
+finish_pass_gather_phuff (j_compress_ptr cinfo)
+{
+  phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy;
+  boolean is_DC_band;
+  int ci, tbl;
+  jpeg_component_info * compptr;
+  JHUFF_TBL **htblptr;
+  boolean did[NUM_HUFF_TBLS];
+
+  /* Flush out buffered data (all we care about is counting the EOB symbol) */
+  emit_eobrun(entropy);
+
+  is_DC_band = (cinfo->Ss == 0);
+
+  /* It's important not to apply jpeg_gen_optimal_table more than once
+   * per table, because it clobbers the input frequency counts!
+   */
+  MEMZERO(did, SIZEOF(did));
+
+  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+    compptr = cinfo->cur_comp_info[ci];
+    if (is_DC_band) {
+      if (cinfo->Ah != 0)	/* DC refinement needs no table */
+	continue;
+      tbl = compptr->dc_tbl_no;
+    } else {
+      tbl = compptr->ac_tbl_no;
+    }
+    if (! did[tbl]) {
+      if (is_DC_band)
+        htblptr = & cinfo->dc_huff_tbl_ptrs[tbl];
+      else
+        htblptr = & cinfo->ac_huff_tbl_ptrs[tbl];
+      if (*htblptr == NULL)
+        *htblptr = jpeg_alloc_huff_table((j_common_ptr) cinfo);
+      jpeg_gen_optimal_table(cinfo, *htblptr, entropy->count_ptrs[tbl]);
+      did[tbl] = TRUE;
+    }
+  }
+}
+
+
+/*
+ * Module initialization routine for progressive Huffman entropy encoding.
+ */
+
+GLOBAL void
+jinit_phuff_encoder (j_compress_ptr cinfo)
+{
+  phuff_entropy_ptr entropy;
+  int i;
+
+  entropy = (phuff_entropy_ptr)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				SIZEOF(phuff_entropy_encoder));
+  cinfo->entropy = (struct jpeg_entropy_encoder *) entropy;
+  entropy->pub.start_pass = start_pass_phuff;
+
+  /* Mark tables unallocated */
+  for (i = 0; i < NUM_HUFF_TBLS; i++) {
+    entropy->derived_tbls[i] = NULL;
+    entropy->count_ptrs[i] = NULL;
+  }
+  entropy->bit_buffer = NULL;	/* needed only in AC refinement scan */
+}
+
+#endif /* C_PROGRESSIVE_SUPPORTED */
diff --git a/code/jpeg-6/jcprepct.cpp b/code/jpeg-6/jcprepct.cpp
new file mode 100644
index 0000000..323e862
--- /dev/null
+++ b/code/jpeg-6/jcprepct.cpp
@@ -0,0 +1,377 @@
+/*
+ * jcprepct.c
+ *
+ * Copyright (C) 1994, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains the compression preprocessing controller.
+ * This controller manages the color conversion, downsampling,
+ * and edge expansion steps.
+ *
+ * Most of the complexity here is associated with buffering input rows
+ * as required by the downsampler.  See the comments at the head of
+ * jcsample.c for the downsampler's needs.
+ */
+
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/* At present, jcsample.c can request context rows only for smoothing.
+ * In the future, we might also need context rows for CCIR601 sampling
+ * or other more-complex downsampling procedures.  The code to support
+ * context rows should be compiled only if needed.
+ */
+#ifdef INPUT_SMOOTHING_SUPPORTED
+#define CONTEXT_ROWS_SUPPORTED
+#endif
+
+
+/*
+ * For the simple (no-context-row) case, we just need to buffer one
+ * row group's worth of pixels for the downsampling step.  At the bottom of
+ * the image, we pad to a full row group by replicating the last pixel row.
+ * The downsampler's last output row is then replicated if needed to pad
+ * out to a full iMCU row.
+ *
+ * When providing context rows, we must buffer three row groups' worth of
+ * pixels.  Three row groups are physically allocated, but the row pointer
+ * arrays are made five row groups high, with the extra pointers above and
+ * below "wrapping around" to point to the last and first real row groups.
+ * This allows the downsampler to access the proper context rows.
+ * At the top and bottom of the image, we create dummy context rows by
+ * copying the first or last real pixel row.  This copying could be avoided
+ * by pointer hacking as is done in jdmainct.c, but it doesn't seem worth the
+ * trouble on the compression side.
+ */
+
+
+/* Private buffer controller object */
+
+typedef struct {
+  struct jpeg_c_prep_controller pub; /* public fields */
+
+  /* Downsampling input buffer.  This buffer holds color-converted data
+   * until we have enough to do a downsample step.
+   */
+  JSAMPARRAY color_buf[MAX_COMPONENTS];
+
+  JDIMENSION rows_to_go;	/* counts rows remaining in source image */
+  int next_buf_row;		/* index of next row to store in color_buf */
+
+#ifdef CONTEXT_ROWS_SUPPORTED	/* only needed for context case */
+  int this_row_group;		/* starting row index of group to process */
+  int next_buf_stop;		/* downsample when we reach this index */
+#endif
+} my_prep_controller;
+
+typedef my_prep_controller * my_prep_ptr;
+
+
+/*
+ * Initialize for a processing pass.
+ */
+
+METHODDEF void
+start_pass_prep (j_compress_ptr cinfo, J_BUF_MODE pass_mode)
+{
+  my_prep_ptr prep = (my_prep_ptr) cinfo->prep;
+
+  if (pass_mode != JBUF_PASS_THRU)
+    ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+
+  /* Initialize total-height counter for detecting bottom of image */
+  prep->rows_to_go = cinfo->image_height;
+  /* Mark the conversion buffer empty */
+  prep->next_buf_row = 0;
+#ifdef CONTEXT_ROWS_SUPPORTED
+  /* Preset additional state variables for context mode.
+   * These aren't used in non-context mode, so we needn't test which mode.
+   */
+  prep->this_row_group = 0;
+  /* Set next_buf_stop to stop after two row groups have been read in. */
+  prep->next_buf_stop = 2 * cinfo->max_v_samp_factor;
+#endif
+}
+
+
+/*
+ * Expand an image vertically from height input_rows to height output_rows,
+ * by duplicating the bottom row.
+ */
+
+LOCAL void
+expand_bottom_edge (JSAMPARRAY image_data, JDIMENSION num_cols,
+		    int input_rows, int output_rows)
+{
+  register int row;
+
+  for (row = input_rows; row < output_rows; row++) {
+    jcopy_sample_rows(image_data, input_rows-1, image_data, row,
+		      1, num_cols);
+  }
+}
+
+
+/*
+ * Process some data in the simple no-context case.
+ *
+ * Preprocessor output data is counted in "row groups".  A row group
+ * is defined to be v_samp_factor sample rows of each component.
+ * Downsampling will produce this much data from each max_v_samp_factor
+ * input rows.
+ */
+
+METHODDEF void
+pre_process_data (j_compress_ptr cinfo,
+		  JSAMPARRAY input_buf, JDIMENSION *in_row_ctr,
+		  JDIMENSION in_rows_avail,
+		  JSAMPIMAGE output_buf, JDIMENSION *out_row_group_ctr,
+		  JDIMENSION out_row_groups_avail)
+{
+  my_prep_ptr prep = (my_prep_ptr) cinfo->prep;
+  int numrows, ci;
+  JDIMENSION inrows;
+  jpeg_component_info * compptr;
+
+  while (*in_row_ctr < in_rows_avail &&
+	 *out_row_group_ctr < out_row_groups_avail) {
+    /* Do color conversion to fill the conversion buffer. */
+    inrows = in_rows_avail - *in_row_ctr;
+    numrows = cinfo->max_v_samp_factor - prep->next_buf_row;
+    numrows = (int) MIN((JDIMENSION) numrows, inrows);
+    (*cinfo->cconvert->color_convert) (cinfo, input_buf + *in_row_ctr,
+				       prep->color_buf,
+				       (JDIMENSION) prep->next_buf_row,
+				       numrows);
+    *in_row_ctr += numrows;
+    prep->next_buf_row += numrows;
+    prep->rows_to_go -= numrows;
+    /* If at bottom of image, pad to fill the conversion buffer. */
+    if (prep->rows_to_go == 0 &&
+	prep->next_buf_row < cinfo->max_v_samp_factor) {
+      for (ci = 0; ci < cinfo->num_components; ci++) {
+	expand_bottom_edge(prep->color_buf[ci], cinfo->image_width,
+			   prep->next_buf_row, cinfo->max_v_samp_factor);
+      }
+      prep->next_buf_row = cinfo->max_v_samp_factor;
+    }
+    /* If we've filled the conversion buffer, empty it. */
+    if (prep->next_buf_row == cinfo->max_v_samp_factor) {
+      (*cinfo->downsample->downsample) (cinfo,
+					prep->color_buf, (JDIMENSION) 0,
+					output_buf, *out_row_group_ctr);
+      prep->next_buf_row = 0;
+      (*out_row_group_ctr)++;
+    }
+    /* If at bottom of image, pad the output to a full iMCU height.
+     * Note we assume the caller is providing a one-iMCU-height output buffer!
+     */
+    if (prep->rows_to_go == 0 &&
+	*out_row_group_ctr < out_row_groups_avail) {
+      for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+	   ci++, compptr++) {
+	expand_bottom_edge(output_buf[ci],
+			   compptr->width_in_blocks * DCTSIZE,
+			   (int) (*out_row_group_ctr * compptr->v_samp_factor),
+			   (int) (out_row_groups_avail * compptr->v_samp_factor));
+      }
+      *out_row_group_ctr = out_row_groups_avail;
+      break;			/* can exit outer loop without test */
+    }
+  }
+}
+
+
+#ifdef CONTEXT_ROWS_SUPPORTED
+
+/*
+ * Process some data in the context case.
+ */
+
+METHODDEF void
+pre_process_context (j_compress_ptr cinfo,
+		     JSAMPARRAY input_buf, JDIMENSION *in_row_ctr,
+		     JDIMENSION in_rows_avail,
+		     JSAMPIMAGE output_buf, JDIMENSION *out_row_group_ctr,
+		     JDIMENSION out_row_groups_avail)
+{
+  my_prep_ptr prep = (my_prep_ptr) cinfo->prep;
+  int numrows, ci;
+  int buf_height = cinfo->max_v_samp_factor * 3;
+  JDIMENSION inrows;
+  jpeg_component_info * compptr;
+
+  while (*out_row_group_ctr < out_row_groups_avail) {
+    if (*in_row_ctr < in_rows_avail) {
+      /* Do color conversion to fill the conversion buffer. */
+      inrows = in_rows_avail - *in_row_ctr;
+      numrows = prep->next_buf_stop - prep->next_buf_row;
+      numrows = (int) MIN((JDIMENSION) numrows, inrows);
+      (*cinfo->cconvert->color_convert) (cinfo, input_buf + *in_row_ctr,
+					 prep->color_buf,
+					 (JDIMENSION) prep->next_buf_row,
+					 numrows);
+      /* Pad at top of image, if first time through */
+      if (prep->rows_to_go == cinfo->image_height) {
+	for (ci = 0; ci < cinfo->num_components; ci++) {
+	  int row;
+	  for (row = 1; row <= cinfo->max_v_samp_factor; row++) {
+	    jcopy_sample_rows(prep->color_buf[ci], 0,
+			      prep->color_buf[ci], -row,
+			      1, cinfo->image_width);
+	  }
+	}
+      }
+      *in_row_ctr += numrows;
+      prep->next_buf_row += numrows;
+      prep->rows_to_go -= numrows;
+    } else {
+      /* Return for more data, unless we are at the bottom of the image. */
+      if (prep->rows_to_go != 0)
+	break;
+    }
+    /* If at bottom of image, pad to fill the conversion buffer. */
+    if (prep->rows_to_go == 0 &&
+	prep->next_buf_row < prep->next_buf_stop) {
+      for (ci = 0; ci < cinfo->num_components; ci++) {
+	expand_bottom_edge(prep->color_buf[ci], cinfo->image_width,
+			   prep->next_buf_row, prep->next_buf_stop);
+      }
+      prep->next_buf_row = prep->next_buf_stop;
+    }
+    /* If we've gotten enough data, downsample a row group. */
+    if (prep->next_buf_row == prep->next_buf_stop) {
+      (*cinfo->downsample->downsample) (cinfo,
+					prep->color_buf,
+					(JDIMENSION) prep->this_row_group,
+					output_buf, *out_row_group_ctr);
+      (*out_row_group_ctr)++;
+      /* Advance pointers with wraparound as necessary. */
+      prep->this_row_group += cinfo->max_v_samp_factor;
+      if (prep->this_row_group >= buf_height)
+	prep->this_row_group = 0;
+      if (prep->next_buf_row >= buf_height)
+	prep->next_buf_row = 0;
+      prep->next_buf_stop = prep->next_buf_row + cinfo->max_v_samp_factor;
+    }
+    /* If at bottom of image, pad the output to a full iMCU height.
+     * Note we assume the caller is providing a one-iMCU-height output buffer!
+     */
+    if (prep->rows_to_go == 0 &&
+	*out_row_group_ctr < out_row_groups_avail) {
+      for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+	   ci++, compptr++) {
+	expand_bottom_edge(output_buf[ci],
+			   compptr->width_in_blocks * DCTSIZE,
+			   (int) (*out_row_group_ctr * compptr->v_samp_factor),
+			   (int) (out_row_groups_avail * compptr->v_samp_factor));
+      }
+      *out_row_group_ctr = out_row_groups_avail;
+      break;			/* can exit outer loop without test */
+    }
+  }
+}
+
+
+/*
+ * Create the wrapped-around downsampling input buffer needed for context mode.
+ */
+
+LOCAL void
+create_context_buffer (j_compress_ptr cinfo)
+{
+  my_prep_ptr prep = (my_prep_ptr) cinfo->prep;
+  int rgroup_height = cinfo->max_v_samp_factor;
+  int ci, i;
+  jpeg_component_info * compptr;
+  JSAMPARRAY true_buffer, fake_buffer;
+
+  /* Grab enough space for fake row pointers for all the components;
+   * we need five row groups' worth of pointers for each component.
+   */
+  fake_buffer = (JSAMPARRAY)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				(cinfo->num_components * 5 * rgroup_height) *
+				SIZEOF(JSAMPROW));
+
+  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+       ci++, compptr++) {
+    /* Allocate the actual buffer space (3 row groups) for this component.
+     * We make the buffer wide enough to allow the downsampler to edge-expand
+     * horizontally within the buffer, if it so chooses.
+     */
+    true_buffer = (*cinfo->mem->alloc_sarray)
+      ((j_common_ptr) cinfo, JPOOL_IMAGE,
+       (JDIMENSION) (((long) compptr->width_in_blocks * DCTSIZE *
+		      cinfo->max_h_samp_factor) / compptr->h_samp_factor),
+       (JDIMENSION) (3 * rgroup_height));
+    /* Copy true buffer row pointers into the middle of the fake row array */
+    MEMCOPY(fake_buffer + rgroup_height, true_buffer,
+	    3 * rgroup_height * SIZEOF(JSAMPROW));
+    /* Fill in the above and below wraparound pointers */
+    for (i = 0; i < rgroup_height; i++) {
+      fake_buffer[i] = true_buffer[2 * rgroup_height + i];
+      fake_buffer[4 * rgroup_height + i] = true_buffer[i];
+    }
+    prep->color_buf[ci] = fake_buffer + rgroup_height;
+    fake_buffer += 5 * rgroup_height; /* point to space for next component */
+  }
+}
+
+#endif /* CONTEXT_ROWS_SUPPORTED */
+
+
+/*
+ * Initialize preprocessing controller.
+ */
+
+GLOBAL void
+jinit_c_prep_controller (j_compress_ptr cinfo, boolean need_full_buffer)
+{
+  my_prep_ptr prep;
+  int ci;
+  jpeg_component_info * compptr;
+
+  if (need_full_buffer)		/* safety check */
+    ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+
+  prep = (my_prep_ptr)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				SIZEOF(my_prep_controller));
+  cinfo->prep = (struct jpeg_c_prep_controller *) prep;
+  prep->pub.start_pass = start_pass_prep;
+
+  /* Allocate the color conversion buffer.
+   * We make the buffer wide enough to allow the downsampler to edge-expand
+   * horizontally within the buffer, if it so chooses.
+   */
+  if (cinfo->downsample->need_context_rows) {
+    /* Set up to provide context rows */
+#ifdef CONTEXT_ROWS_SUPPORTED
+    prep->pub.pre_process_data = pre_process_context;
+    create_context_buffer(cinfo);
+#else
+    ERREXIT(cinfo, JERR_NOT_COMPILED);
+#endif
+  } else {
+    /* No context, just make it tall enough for one row group */
+    prep->pub.pre_process_data = pre_process_data;
+    for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+	 ci++, compptr++) {
+      prep->color_buf[ci] = (*cinfo->mem->alloc_sarray)
+	((j_common_ptr) cinfo, JPOOL_IMAGE,
+	 (JDIMENSION) (((long) compptr->width_in_blocks * DCTSIZE *
+			cinfo->max_h_samp_factor) / compptr->h_samp_factor),
+	 (JDIMENSION) cinfo->max_v_samp_factor);
+    }
+  }
+}
diff --git a/code/jpeg-6/jcsample.cpp b/code/jpeg-6/jcsample.cpp
new file mode 100644
index 0000000..3cb4a96
--- /dev/null
+++ b/code/jpeg-6/jcsample.cpp
@@ -0,0 +1,525 @@
+/*
+ * jcsample.c
+ *
+ * Copyright (C) 1991-1994, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains downsampling routines.
+ *
+ * Downsampling input data is counted in "row groups".  A row group
+ * is defined to be max_v_samp_factor pixel rows of each component,
+ * from which the downsampler produces v_samp_factor sample rows.
+ * A single row group is processed in each call to the downsampler module.
+ *
+ * The downsampler is responsible for edge-expansion of its output data
+ * to fill an integral number of DCT blocks horizontally.  The source buffer
+ * may be modified if it is helpful for this purpose (the source buffer is
+ * allocated wide enough to correspond to the desired output width).
+ * The caller (the prep controller) is responsible for vertical padding.
+ *
+ * The downsampler may request "context rows" by setting need_context_rows
+ * during startup.  In this case, the input arrays will contain at least
+ * one row group's worth of pixels above and below the passed-in data;
+ * the caller will create dummy rows at image top and bottom by replicating
+ * the first or last real pixel row.
+ *
+ * An excellent reference for image resampling is
+ *   Digital Image Warping, George Wolberg, 1990.
+ *   Pub. by IEEE Computer Society Press, Los Alamitos, CA. ISBN 0-8186-8944-7.
+ *
+ * The downsampling algorithm used here is a simple average of the source
+ * pixels covered by the output pixel.  The hi-falutin sampling literature
+ * refers to this as a "box filter".  In general the characteristics of a box
+ * filter are not very good, but for the specific cases we normally use (1:1
+ * and 2:1 ratios) the box is equivalent to a "triangle filter" which is not
+ * nearly so bad.  If you intend to use other sampling ratios, you'd be well
+ * advised to improve this code.
+ *
+ * A simple input-smoothing capability is provided.  This is mainly intended
+ * for cleaning up color-dithered GIF input files (if you find it inadequate,
+ * we suggest using an external filtering program such as pnmconvol).  When
+ * enabled, each input pixel P is replaced by a weighted sum of itself and its
+ * eight neighbors.  P's weight is 1-8*SF and each neighbor's weight is SF,
+ * where SF = (smoothing_factor / 1024).
+ * Currently, smoothing is only supported for 2h2v sampling factors.
+ */
+
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/* Pointer to routine to downsample a single component */
+typedef JMETHOD(void, downsample1_ptr,
+		(j_compress_ptr cinfo, jpeg_component_info * compptr,
+		 JSAMPARRAY input_data, JSAMPARRAY output_data));
+
+/* Private subobject */
+
+typedef struct {
+  struct jpeg_downsampler pub;	/* public fields */
+
+  /* Downsampling method pointers, one per component */
+  downsample1_ptr methods[MAX_COMPONENTS];
+} my_downsampler;
+
+typedef my_downsampler * my_downsample_ptr;
+
+
+/*
+ * Initialize for a downsampling pass.
+ */
+
+METHODDEF void
+start_pass_downsample (j_compress_ptr cinfo)
+{
+  /* no work for now */
+}
+
+
+/*
+ * Expand a component horizontally from width input_cols to width output_cols,
+ * by duplicating the rightmost samples.
+ */
+
+LOCAL void
+expand_right_edge (JSAMPARRAY image_data, int num_rows,
+		   JDIMENSION input_cols, JDIMENSION output_cols)
+{
+  register JSAMPROW ptr;
+  register JSAMPLE pixval;
+  register int count;
+  int row;
+  int numcols = (int) (output_cols - input_cols);
+
+  if (numcols > 0) {
+    for (row = 0; row < num_rows; row++) {
+      ptr = image_data[row] + input_cols;
+      pixval = ptr[-1];		/* don't need GETJSAMPLE() here */
+      for (count = numcols; count > 0; count--)
+	*ptr++ = pixval;
+    }
+  }
+}
+
+
+/*
+ * Do downsampling for a whole row group (all components).
+ *
+ * In this version we simply downsample each component independently.
+ */
+
+METHODDEF void
+sep_downsample (j_compress_ptr cinfo,
+		JSAMPIMAGE input_buf, JDIMENSION in_row_index,
+		JSAMPIMAGE output_buf, JDIMENSION out_row_group_index)
+{
+  my_downsample_ptr downsample = (my_downsample_ptr) cinfo->downsample;
+  int ci;
+  jpeg_component_info * compptr;
+  JSAMPARRAY in_ptr, out_ptr;
+
+  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+       ci++, compptr++) {
+    in_ptr = input_buf[ci] + in_row_index;
+    out_ptr = output_buf[ci] + (out_row_group_index * compptr->v_samp_factor);
+    (*downsample->methods[ci]) (cinfo, compptr, in_ptr, out_ptr);
+  }
+}
+
+
+/*
+ * Downsample pixel values of a single component.
+ * One row group is processed per call.
+ * This version handles arbitrary integral sampling ratios, without smoothing.
+ * Note that this version is not actually used for customary sampling ratios.
+ */
+
+METHODDEF void
+int_downsample (j_compress_ptr cinfo, jpeg_component_info * compptr,
+		JSAMPARRAY input_data, JSAMPARRAY output_data)
+{
+  int inrow, outrow, h_expand, v_expand, numpix, numpix2, h, v;
+  JDIMENSION outcol, outcol_h;	/* outcol_h == outcol*h_expand */
+  JDIMENSION output_cols = compptr->width_in_blocks * DCTSIZE;
+  JSAMPROW inptr, outptr;
+  INT32 outvalue;
+
+  h_expand = cinfo->max_h_samp_factor / compptr->h_samp_factor;
+  v_expand = cinfo->max_v_samp_factor / compptr->v_samp_factor;
+  numpix = h_expand * v_expand;
+  numpix2 = numpix/2;
+
+  /* Expand input data enough to let all the output samples be generated
+   * by the standard loop.  Special-casing padded output would be more
+   * efficient.
+   */
+  expand_right_edge(input_data, cinfo->max_v_samp_factor,
+		    cinfo->image_width, output_cols * h_expand);
+
+  inrow = 0;
+  for (outrow = 0; outrow < compptr->v_samp_factor; outrow++) {
+    outptr = output_data[outrow];
+    for (outcol = 0, outcol_h = 0; outcol < output_cols;
+	 outcol++, outcol_h += h_expand) {
+      outvalue = 0;
+      for (v = 0; v < v_expand; v++) {
+	inptr = input_data[inrow+v] + outcol_h;
+	for (h = 0; h < h_expand; h++) {
+	  outvalue += (INT32) GETJSAMPLE(*inptr++);
+	}
+      }
+      *outptr++ = (JSAMPLE) ((outvalue + numpix2) / numpix);
+    }
+    inrow += v_expand;
+  }
+}
+
+
+/*
+ * Downsample pixel values of a single component.
+ * This version handles the special case of a full-size component,
+ * without smoothing.
+ */
+
+METHODDEF void
+fullsize_downsample (j_compress_ptr cinfo, jpeg_component_info * compptr,
+		     JSAMPARRAY input_data, JSAMPARRAY output_data)
+{
+  /* Copy the data */
+  jcopy_sample_rows(input_data, 0, output_data, 0,
+		    cinfo->max_v_samp_factor, cinfo->image_width);
+  /* Edge-expand */
+  expand_right_edge(output_data, cinfo->max_v_samp_factor,
+		    cinfo->image_width, compptr->width_in_blocks * DCTSIZE);
+}
+
+
+/*
+ * Downsample pixel values of a single component.
+ * This version handles the common case of 2:1 horizontal and 1:1 vertical,
+ * without smoothing.
+ *
+ * A note about the "bias" calculations: when rounding fractional values to
+ * integer, we do not want to always round 0.5 up to the next integer.
+ * If we did that, we'd introduce a noticeable bias towards larger values.
+ * Instead, this code is arranged so that 0.5 will be rounded up or down at
+ * alternate pixel locations (a simple ordered dither pattern).
+ */
+
+METHODDEF void
+h2v1_downsample (j_compress_ptr cinfo, jpeg_component_info * compptr,
+		 JSAMPARRAY input_data, JSAMPARRAY output_data)
+{
+  int outrow;
+  JDIMENSION outcol;
+  JDIMENSION output_cols = compptr->width_in_blocks * DCTSIZE;
+  register JSAMPROW inptr, outptr;
+  register int bias;
+
+  /* Expand input data enough to let all the output samples be generated
+   * by the standard loop.  Special-casing padded output would be more
+   * efficient.
+   */
+  expand_right_edge(input_data, cinfo->max_v_samp_factor,
+		    cinfo->image_width, output_cols * 2);
+
+  for (outrow = 0; outrow < compptr->v_samp_factor; outrow++) {
+    outptr = output_data[outrow];
+    inptr = input_data[outrow];
+    bias = 0;			/* bias = 0,1,0,1,... for successive samples */
+    for (outcol = 0; outcol < output_cols; outcol++) {
+      *outptr++ = (JSAMPLE) ((GETJSAMPLE(*inptr) + GETJSAMPLE(inptr[1])
+			      + bias) >> 1);
+      bias ^= 1;		/* 0=>1, 1=>0 */
+      inptr += 2;
+    }
+  }
+}
+
+
+/*
+ * Downsample pixel values of a single component.
+ * This version handles the standard case of 2:1 horizontal and 2:1 vertical,
+ * without smoothing.
+ */
+
+METHODDEF void
+h2v2_downsample (j_compress_ptr cinfo, jpeg_component_info * compptr,
+		 JSAMPARRAY input_data, JSAMPARRAY output_data)
+{
+  int inrow, outrow;
+  JDIMENSION outcol;
+  JDIMENSION output_cols = compptr->width_in_blocks * DCTSIZE;
+  register JSAMPROW inptr0, inptr1, outptr;
+  register int bias;
+
+  /* Expand input data enough to let all the output samples be generated
+   * by the standard loop.  Special-casing padded output would be more
+   * efficient.
+   */
+  expand_right_edge(input_data, cinfo->max_v_samp_factor,
+		    cinfo->image_width, output_cols * 2);
+
+  inrow = 0;
+  for (outrow = 0; outrow < compptr->v_samp_factor; outrow++) {
+    outptr = output_data[outrow];
+    inptr0 = input_data[inrow];
+    inptr1 = input_data[inrow+1];
+    bias = 1;			/* bias = 1,2,1,2,... for successive samples */
+    for (outcol = 0; outcol < output_cols; outcol++) {
+      *outptr++ = (JSAMPLE) ((GETJSAMPLE(*inptr0) + GETJSAMPLE(inptr0[1]) +
+			      GETJSAMPLE(*inptr1) + GETJSAMPLE(inptr1[1])
+			      + bias) >> 2);
+      bias ^= 3;		/* 1=>2, 2=>1 */
+      inptr0 += 2; inptr1 += 2;
+    }
+    inrow += 2;
+  }
+}
+
+
+#ifdef INPUT_SMOOTHING_SUPPORTED
+
+/*
+ * Downsample pixel values of a single component.
+ * This version handles the standard case of 2:1 horizontal and 2:1 vertical,
+ * with smoothing.  One row of context is required.
+ */
+
+METHODDEF void
+h2v2_smooth_downsample (j_compress_ptr cinfo, jpeg_component_info * compptr,
+			JSAMPARRAY input_data, JSAMPARRAY output_data)
+{
+  int inrow, outrow;
+  JDIMENSION colctr;
+  JDIMENSION output_cols = compptr->width_in_blocks * DCTSIZE;
+  register JSAMPROW inptr0, inptr1, above_ptr, below_ptr, outptr;
+  INT32 membersum, neighsum, memberscale, neighscale;
+
+  /* Expand input data enough to let all the output samples be generated
+   * by the standard loop.  Special-casing padded output would be more
+   * efficient.
+   */
+  expand_right_edge(input_data - 1, cinfo->max_v_samp_factor + 2,
+		    cinfo->image_width, output_cols * 2);
+
+  /* We don't bother to form the individual "smoothed" input pixel values;
+   * we can directly compute the output which is the average of the four
+   * smoothed values.  Each of the four member pixels contributes a fraction
+   * (1-8*SF) to its own smoothed image and a fraction SF to each of the three
+   * other smoothed pixels, therefore a total fraction (1-5*SF)/4 to the final
+   * output.  The four corner-adjacent neighbor pixels contribute a fraction
+   * SF to just one smoothed pixel, or SF/4 to the final output; while the
+   * eight edge-adjacent neighbors contribute SF to each of two smoothed
+   * pixels, or SF/2 overall.  In order to use integer arithmetic, these
+   * factors are scaled by 2^16 = 65536.
+   * Also recall that SF = smoothing_factor / 1024.
+   */
+
+  memberscale = 16384 - cinfo->smoothing_factor * 80; /* scaled (1-5*SF)/4 */
+  neighscale = cinfo->smoothing_factor * 16; /* scaled SF/4 */
+
+  inrow = 0;
+  for (outrow = 0; outrow < compptr->v_samp_factor; outrow++) {
+    outptr = output_data[outrow];
+    inptr0 = input_data[inrow];
+    inptr1 = input_data[inrow+1];
+    above_ptr = input_data[inrow-1];
+    below_ptr = input_data[inrow+2];
+
+    /* Special case for first column: pretend column -1 is same as column 0 */
+    membersum = GETJSAMPLE(*inptr0) + GETJSAMPLE(inptr0[1]) +
+		GETJSAMPLE(*inptr1) + GETJSAMPLE(inptr1[1]);
+    neighsum = GETJSAMPLE(*above_ptr) + GETJSAMPLE(above_ptr[1]) +
+	       GETJSAMPLE(*below_ptr) + GETJSAMPLE(below_ptr[1]) +
+	       GETJSAMPLE(*inptr0) + GETJSAMPLE(inptr0[2]) +
+	       GETJSAMPLE(*inptr1) + GETJSAMPLE(inptr1[2]);
+    neighsum += neighsum;
+    neighsum += GETJSAMPLE(*above_ptr) + GETJSAMPLE(above_ptr[2]) +
+		GETJSAMPLE(*below_ptr) + GETJSAMPLE(below_ptr[2]);
+    membersum = membersum * memberscale + neighsum * neighscale;
+    *outptr++ = (JSAMPLE) ((membersum + 32768) >> 16);
+    inptr0 += 2; inptr1 += 2; above_ptr += 2; below_ptr += 2;
+
+    for (colctr = output_cols - 2; colctr > 0; colctr--) {
+      /* sum of pixels directly mapped to this output element */
+      membersum = GETJSAMPLE(*inptr0) + GETJSAMPLE(inptr0[1]) +
+		  GETJSAMPLE(*inptr1) + GETJSAMPLE(inptr1[1]);
+      /* sum of edge-neighbor pixels */
+      neighsum = GETJSAMPLE(*above_ptr) + GETJSAMPLE(above_ptr[1]) +
+		 GETJSAMPLE(*below_ptr) + GETJSAMPLE(below_ptr[1]) +
+		 GETJSAMPLE(inptr0[-1]) + GETJSAMPLE(inptr0[2]) +
+		 GETJSAMPLE(inptr1[-1]) + GETJSAMPLE(inptr1[2]);
+      /* The edge-neighbors count twice as much as corner-neighbors */
+      neighsum += neighsum;
+      /* Add in the corner-neighbors */
+      neighsum += GETJSAMPLE(above_ptr[-1]) + GETJSAMPLE(above_ptr[2]) +
+		  GETJSAMPLE(below_ptr[-1]) + GETJSAMPLE(below_ptr[2]);
+      /* form final output scaled up by 2^16 */
+      membersum = membersum * memberscale + neighsum * neighscale;
+      /* round, descale and output it */
+      *outptr++ = (JSAMPLE) ((membersum + 32768) >> 16);
+      inptr0 += 2; inptr1 += 2; above_ptr += 2; below_ptr += 2;
+    }
+
+    /* Special case for last column */
+    membersum = GETJSAMPLE(*inptr0) + GETJSAMPLE(inptr0[1]) +
+		GETJSAMPLE(*inptr1) + GETJSAMPLE(inptr1[1]);
+    neighsum = GETJSAMPLE(*above_ptr) + GETJSAMPLE(above_ptr[1]) +
+	       GETJSAMPLE(*below_ptr) + GETJSAMPLE(below_ptr[1]) +
+	       GETJSAMPLE(inptr0[-1]) + GETJSAMPLE(inptr0[1]) +
+	       GETJSAMPLE(inptr1[-1]) + GETJSAMPLE(inptr1[1]);
+    neighsum += neighsum;
+    neighsum += GETJSAMPLE(above_ptr[-1]) + GETJSAMPLE(above_ptr[1]) +
+		GETJSAMPLE(below_ptr[-1]) + GETJSAMPLE(below_ptr[1]);
+    membersum = membersum * memberscale + neighsum * neighscale;
+    *outptr = (JSAMPLE) ((membersum + 32768) >> 16);
+
+    inrow += 2;
+  }
+}
+
+
+/*
+ * Downsample pixel values of a single component.
+ * This version handles the special case of a full-size component,
+ * with smoothing.  One row of context is required.
+ */
+
+METHODDEF void
+fullsize_smooth_downsample (j_compress_ptr cinfo, jpeg_component_info *compptr,
+			    JSAMPARRAY input_data, JSAMPARRAY output_data)
+{
+  int outrow;
+  JDIMENSION colctr;
+  JDIMENSION output_cols = compptr->width_in_blocks * DCTSIZE;
+  register JSAMPROW inptr, above_ptr, below_ptr, outptr;
+  INT32 membersum, neighsum, memberscale, neighscale;
+  int colsum, lastcolsum, nextcolsum;
+
+  /* Expand input data enough to let all the output samples be generated
+   * by the standard loop.  Special-casing padded output would be more
+   * efficient.
+   */
+  expand_right_edge(input_data - 1, cinfo->max_v_samp_factor + 2,
+		    cinfo->image_width, output_cols);
+
+  /* Each of the eight neighbor pixels contributes a fraction SF to the
+   * smoothed pixel, while the main pixel contributes (1-8*SF).  In order
+   * to use integer arithmetic, these factors are multiplied by 2^16 = 65536.
+   * Also recall that SF = smoothing_factor / 1024.
+   */
+
+  memberscale = 65536L - cinfo->smoothing_factor * 512L; /* scaled 1-8*SF */
+  neighscale = cinfo->smoothing_factor * 64; /* scaled SF */
+
+  for (outrow = 0; outrow < compptr->v_samp_factor; outrow++) {
+    outptr = output_data[outrow];
+    inptr = input_data[outrow];
+    above_ptr = input_data[outrow-1];
+    below_ptr = input_data[outrow+1];
+
+    /* Special case for first column */
+    colsum = GETJSAMPLE(*above_ptr++) + GETJSAMPLE(*below_ptr++) +
+	     GETJSAMPLE(*inptr);
+    membersum = GETJSAMPLE(*inptr++);
+    nextcolsum = GETJSAMPLE(*above_ptr) + GETJSAMPLE(*below_ptr) +
+		 GETJSAMPLE(*inptr);
+    neighsum = colsum + (colsum - membersum) + nextcolsum;
+    membersum = membersum * memberscale + neighsum * neighscale;
+    *outptr++ = (JSAMPLE) ((membersum + 32768) >> 16);
+    lastcolsum = colsum; colsum = nextcolsum;
+
+    for (colctr = output_cols - 2; colctr > 0; colctr--) {
+      membersum = GETJSAMPLE(*inptr++);
+      above_ptr++; below_ptr++;
+      nextcolsum = GETJSAMPLE(*above_ptr) + GETJSAMPLE(*below_ptr) +
+		   GETJSAMPLE(*inptr);
+      neighsum = lastcolsum + (colsum - membersum) + nextcolsum;
+      membersum = membersum * memberscale + neighsum * neighscale;
+      *outptr++ = (JSAMPLE) ((membersum + 32768) >> 16);
+      lastcolsum = colsum; colsum = nextcolsum;
+    }
+
+    /* Special case for last column */
+    membersum = GETJSAMPLE(*inptr);
+    neighsum = lastcolsum + (colsum - membersum) + colsum;
+    membersum = membersum * memberscale + neighsum * neighscale;
+    *outptr = (JSAMPLE) ((membersum + 32768) >> 16);
+
+  }
+}
+
+#endif /* INPUT_SMOOTHING_SUPPORTED */
+
+
+/*
+ * Module initialization routine for downsampling.
+ * Note that we must select a routine for each component.
+ */
+
+GLOBAL void
+jinit_downsampler (j_compress_ptr cinfo)
+{
+  my_downsample_ptr downsample;
+  int ci;
+  jpeg_component_info * compptr;
+  boolean smoothok = TRUE;
+
+  downsample = (my_downsample_ptr)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				SIZEOF(my_downsampler));
+  cinfo->downsample = (struct jpeg_downsampler *) downsample;
+  downsample->pub.start_pass = start_pass_downsample;
+  downsample->pub.downsample = sep_downsample;
+  downsample->pub.need_context_rows = FALSE;
+
+  if (cinfo->CCIR601_sampling)
+    ERREXIT(cinfo, JERR_CCIR601_NOTIMPL);
+
+  /* Verify we can handle the sampling factors, and set up method pointers */
+  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+       ci++, compptr++) {
+    if (compptr->h_samp_factor == cinfo->max_h_samp_factor &&
+	compptr->v_samp_factor == cinfo->max_v_samp_factor) {
+#ifdef INPUT_SMOOTHING_SUPPORTED
+      if (cinfo->smoothing_factor) {
+	downsample->methods[ci] = fullsize_smooth_downsample;
+	downsample->pub.need_context_rows = TRUE;
+      } else
+#endif
+	downsample->methods[ci] = fullsize_downsample;
+    } else if (compptr->h_samp_factor * 2 == cinfo->max_h_samp_factor &&
+	       compptr->v_samp_factor == cinfo->max_v_samp_factor) {
+      smoothok = FALSE;
+      downsample->methods[ci] = h2v1_downsample;
+    } else if (compptr->h_samp_factor * 2 == cinfo->max_h_samp_factor &&
+	       compptr->v_samp_factor * 2 == cinfo->max_v_samp_factor) {
+#ifdef INPUT_SMOOTHING_SUPPORTED
+      if (cinfo->smoothing_factor) {
+	downsample->methods[ci] = h2v2_smooth_downsample;
+	downsample->pub.need_context_rows = TRUE;
+      } else
+#endif
+	downsample->methods[ci] = h2v2_downsample;
+    } else if ((cinfo->max_h_samp_factor % compptr->h_samp_factor) == 0 &&
+	       (cinfo->max_v_samp_factor % compptr->v_samp_factor) == 0) {
+      smoothok = FALSE;
+      downsample->methods[ci] = int_downsample;
+    } else
+      ERREXIT(cinfo, JERR_FRACT_SAMPLE_NOTIMPL);
+  }
+
+#ifdef INPUT_SMOOTHING_SUPPORTED
+  if (cinfo->smoothing_factor && !smoothok)
+    TRACEMS(cinfo, 0, JTRC_SMOOTH_NOTIMPL);
+#endif
+}
diff --git a/code/jpeg-6/jctrans.cpp b/code/jpeg-6/jctrans.cpp
new file mode 100644
index 0000000..1e98fb2
--- /dev/null
+++ b/code/jpeg-6/jctrans.cpp
@@ -0,0 +1,378 @@
+/*
+ * jctrans.c
+ *
+ * Copyright (C) 1995, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains library routines for transcoding compression,
+ * that is, writing raw DCT coefficient arrays to an output JPEG file.
+ * The routines in jcapimin.c will also be needed by a transcoder.
+ */
+
+
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/* Forward declarations */
+LOCAL void transencode_master_selection
+	JPP((j_compress_ptr cinfo, jvirt_barray_ptr * coef_arrays));
+LOCAL void transencode_coef_controller
+	JPP((j_compress_ptr cinfo, jvirt_barray_ptr * coef_arrays));
+
+
+/*
+ * Compression initialization for writing raw-coefficient data.
+ * Before calling this, all parameters and a data destination must be set up.
+ * Call jpeg_finish_compress() to actually write the data.
+ *
+ * The number of passed virtual arrays must match cinfo->num_components.
+ * Note that the virtual arrays need not be filled or even realized at
+ * the time write_coefficients is called; indeed, if the virtual arrays
+ * were requested from this compression object's memory manager, they
+ * typically will be realized during this routine and filled afterwards.
+ */
+
+GLOBAL void
+jpeg_write_coefficients (j_compress_ptr cinfo, jvirt_barray_ptr * coef_arrays)
+{
+  if (cinfo->global_state != CSTATE_START)
+    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+  /* Mark all tables to be written */
+  jpeg_suppress_tables(cinfo, FALSE);
+  /* (Re)initialize error mgr and destination modules */
+  (*cinfo->err->reset_error_mgr) ((j_common_ptr) cinfo);
+  (*cinfo->dest->init_destination) (cinfo);
+  /* Perform master selection of active modules */
+  transencode_master_selection(cinfo, coef_arrays);
+  /* Wait for jpeg_finish_compress() call */
+  cinfo->next_scanline = 0;	/* so jpeg_write_marker works */
+  cinfo->global_state = CSTATE_WRCOEFS;
+}
+
+
+/*
+ * Initialize the compression object with default parameters,
+ * then copy from the source object all parameters needed for lossless
+ * transcoding.  Parameters that can be varied without loss (such as
+ * scan script and Huffman optimization) are left in their default states.
+ */
+
+GLOBAL void
+jpeg_copy_critical_parameters (j_decompress_ptr srcinfo,
+			       j_compress_ptr dstinfo)
+{
+  JQUANT_TBL ** qtblptr;
+  jpeg_component_info *incomp, *outcomp;
+  JQUANT_TBL *c_quant, *slot_quant;
+  int tblno, ci, coefi;
+
+  /* Safety check to ensure start_compress not called yet. */
+  if (dstinfo->global_state != CSTATE_START)
+    ERREXIT1(dstinfo, JERR_BAD_STATE, dstinfo->global_state);
+  /* Copy fundamental image dimensions */
+  dstinfo->image_width = srcinfo->image_width;
+  dstinfo->image_height = srcinfo->image_height;
+  dstinfo->input_components = srcinfo->num_components;
+  dstinfo->in_color_space = srcinfo->jpeg_color_space;
+  /* Initialize all parameters to default values */
+  jpeg_set_defaults(dstinfo);
+  /* jpeg_set_defaults may choose wrong colorspace, eg YCbCr if input is RGB.
+   * Fix it to get the right header markers for the image colorspace.
+   */
+  jpeg_set_colorspace(dstinfo, srcinfo->jpeg_color_space);
+  dstinfo->data_precision = srcinfo->data_precision;
+  dstinfo->CCIR601_sampling = srcinfo->CCIR601_sampling;
+  /* Copy the source's quantization tables. */
+  for (tblno = 0; tblno < NUM_QUANT_TBLS; tblno++) {
+    if (srcinfo->quant_tbl_ptrs[tblno] != NULL) {
+      qtblptr = & dstinfo->quant_tbl_ptrs[tblno];
+      if (*qtblptr == NULL)
+	*qtblptr = jpeg_alloc_quant_table((j_common_ptr) dstinfo);
+      MEMCOPY((*qtblptr)->quantval,
+	      srcinfo->quant_tbl_ptrs[tblno]->quantval,
+	      SIZEOF((*qtblptr)->quantval));
+      (*qtblptr)->sent_table = FALSE;
+    }
+  }
+  /* Copy the source's per-component info.
+   * Note we assume jpeg_set_defaults has allocated the dest comp_info array.
+   */
+  dstinfo->num_components = srcinfo->num_components;
+  if (dstinfo->num_components < 1 || dstinfo->num_components > MAX_COMPONENTS)
+    ERREXIT2(dstinfo, JERR_COMPONENT_COUNT, dstinfo->num_components,
+	     MAX_COMPONENTS);
+  for (ci = 0, incomp = srcinfo->comp_info, outcomp = dstinfo->comp_info;
+       ci < dstinfo->num_components; ci++, incomp++, outcomp++) {
+    outcomp->component_id = incomp->component_id;
+    outcomp->h_samp_factor = incomp->h_samp_factor;
+    outcomp->v_samp_factor = incomp->v_samp_factor;
+    outcomp->quant_tbl_no = incomp->quant_tbl_no;
+    /* Make sure saved quantization table for component matches the qtable
+     * slot.  If not, the input file re-used this qtable slot.
+     * IJG encoder currently cannot duplicate this.
+     */
+    tblno = outcomp->quant_tbl_no;
+    if (tblno < 0 || tblno >= NUM_QUANT_TBLS ||
+	srcinfo->quant_tbl_ptrs[tblno] == NULL)
+      ERREXIT1(dstinfo, JERR_NO_QUANT_TABLE, tblno);
+    slot_quant = srcinfo->quant_tbl_ptrs[tblno];
+    c_quant = incomp->quant_table;
+    if (c_quant != NULL) {
+      for (coefi = 0; coefi < DCTSIZE2; coefi++) {
+	if (c_quant->quantval[coefi] != slot_quant->quantval[coefi])
+	  ERREXIT1(dstinfo, JERR_MISMATCHED_QUANT_TABLE, tblno);
+      }
+    }
+    /* Note: we do not copy the source's Huffman table assignments;
+     * instead we rely on jpeg_set_colorspace to have made a suitable choice.
+     */
+  }
+}
+
+
+/*
+ * Master selection of compression modules for transcoding.
+ * This substitutes for jcinit.c's initialization of the full compressor.
+ */
+
+LOCAL void
+transencode_master_selection (j_compress_ptr cinfo,
+			      jvirt_barray_ptr * coef_arrays)
+{
+  /* Although we don't actually use input_components for transcoding,
+   * jcmaster.c's initial_setup will complain if input_components is 0.
+   */
+  cinfo->input_components = 1;
+  /* Initialize master control (includes parameter checking/processing) */
+  jinit_c_master_control(cinfo, TRUE /* transcode only */);
+
+  /* Entropy encoding: either Huffman or arithmetic coding. */
+  if (cinfo->arith_code) {
+    ERREXIT(cinfo, JERR_ARITH_NOTIMPL);
+  } else {
+    if (cinfo->progressive_mode) {
+#ifdef C_PROGRESSIVE_SUPPORTED
+      jinit_phuff_encoder(cinfo);
+#else
+      ERREXIT(cinfo, JERR_NOT_COMPILED);
+#endif
+    } else
+      jinit_huff_encoder(cinfo);
+  }
+
+  /* We need a special coefficient buffer controller. */
+  transencode_coef_controller(cinfo, coef_arrays);
+
+  jinit_marker_writer(cinfo);
+
+  /* We can now tell the memory manager to allocate virtual arrays. */
+  (*cinfo->mem->realize_virt_arrays) ((j_common_ptr) cinfo);
+
+  /* Write the datastream header (SOI) immediately.
+   * Frame and scan headers are postponed till later.
+   * This lets application insert special markers after the SOI.
+   */
+  (*cinfo->marker->write_file_header) (cinfo);
+}
+
+
+/*
+ * The rest of this file is a special implementation of the coefficient
+ * buffer controller.  This is similar to jccoefct.c, but it handles only
+ * output from presupplied virtual arrays.  Furthermore, we generate any
+ * dummy padding blocks on-the-fly rather than expecting them to be present
+ * in the arrays.
+ */
+
+/* Private buffer controller object */
+
+typedef struct {
+  struct jpeg_c_coef_controller pub; /* public fields */
+
+  JDIMENSION iMCU_row_num;	/* iMCU row # within image */
+  JDIMENSION mcu_ctr;		/* counts MCUs processed in current row */
+  int MCU_vert_offset;		/* counts MCU rows within iMCU row */
+  int MCU_rows_per_iMCU_row;	/* number of such rows needed */
+
+  /* Virtual block array for each component. */
+  jvirt_barray_ptr * whole_image;
+
+  /* Workspace for constructing dummy blocks at right/bottom edges. */
+  JBLOCKROW dummy_buffer[C_MAX_BLOCKS_IN_MCU];
+} my_coef_controller;
+
+typedef my_coef_controller * my_coef_ptr;
+
+
+LOCAL void
+start_iMCU_row (j_compress_ptr cinfo)
+/* Reset within-iMCU-row counters for a new row */
+{
+  my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
+
+  /* In an interleaved scan, an MCU row is the same as an iMCU row.
+   * In a noninterleaved scan, an iMCU row has v_samp_factor MCU rows.
+   * But at the bottom of the image, process only what's left.
+   */
+  if (cinfo->comps_in_scan > 1) {
+    coef->MCU_rows_per_iMCU_row = 1;
+  } else {
+    if (coef->iMCU_row_num < (cinfo->total_iMCU_rows-1))
+      coef->MCU_rows_per_iMCU_row = cinfo->cur_comp_info[0]->v_samp_factor;
+    else
+      coef->MCU_rows_per_iMCU_row = cinfo->cur_comp_info[0]->last_row_height;
+  }
+
+  coef->mcu_ctr = 0;
+  coef->MCU_vert_offset = 0;
+}
+
+
+/*
+ * Initialize for a processing pass.
+ */
+
+METHODDEF void
+start_pass_coef (j_compress_ptr cinfo, J_BUF_MODE pass_mode)
+{
+  my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
+
+  if (pass_mode != JBUF_CRANK_DEST)
+    ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+
+  coef->iMCU_row_num = 0;
+  start_iMCU_row(cinfo);
+}
+
+
+/*
+ * Process some data.
+ * We process the equivalent of one fully interleaved MCU row ("iMCU" row)
+ * per call, ie, v_samp_factor block rows for each component in the scan.
+ * The data is obtained from the virtual arrays and fed to the entropy coder.
+ * Returns TRUE if the iMCU row is completed, FALSE if suspended.
+ *
+ * NB: input_buf is ignored; it is likely to be a NULL pointer.
+ */
+
+METHODDEF boolean
+compress_output (j_compress_ptr cinfo, JSAMPIMAGE input_buf)
+{
+  my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
+  JDIMENSION MCU_col_num;	/* index of current MCU within row */
+  JDIMENSION last_MCU_col = cinfo->MCUs_per_row - 1;
+  JDIMENSION last_iMCU_row = cinfo->total_iMCU_rows - 1;
+  int blkn, ci, xindex, yindex, yoffset, blockcnt;
+  JDIMENSION start_col;
+  JBLOCKARRAY buffer[MAX_COMPS_IN_SCAN];
+  JBLOCKROW MCU_buffer[C_MAX_BLOCKS_IN_MCU];
+  JBLOCKROW buffer_ptr;
+  jpeg_component_info *compptr;
+
+  /* Align the virtual buffers for the components used in this scan. */
+  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+    compptr = cinfo->cur_comp_info[ci];
+    buffer[ci] = (*cinfo->mem->access_virt_barray)
+      ((j_common_ptr) cinfo, coef->whole_image[compptr->component_index],
+       coef->iMCU_row_num * compptr->v_samp_factor,
+       (JDIMENSION) compptr->v_samp_factor, FALSE);
+  }
+
+  /* Loop to process one whole iMCU row */
+  for (yoffset = coef->MCU_vert_offset; yoffset < coef->MCU_rows_per_iMCU_row;
+       yoffset++) {
+    for (MCU_col_num = coef->mcu_ctr; MCU_col_num < cinfo->MCUs_per_row;
+	 MCU_col_num++) {
+      /* Construct list of pointers to DCT blocks belonging to this MCU */
+      blkn = 0;			/* index of current DCT block within MCU */
+      for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+	compptr = cinfo->cur_comp_info[ci];
+	start_col = MCU_col_num * compptr->MCU_width;
+	blockcnt = (MCU_col_num < last_MCU_col) ? compptr->MCU_width
+						: compptr->last_col_width;
+	for (yindex = 0; yindex < compptr->MCU_height; yindex++) {
+	  if (coef->iMCU_row_num < last_iMCU_row ||
+	      yindex+yoffset < compptr->last_row_height) {
+	    /* Fill in pointers to real blocks in this row */
+	    buffer_ptr = buffer[ci][yindex+yoffset] + start_col;
+	    for (xindex = 0; xindex < blockcnt; xindex++)
+	      MCU_buffer[blkn++] = buffer_ptr++;
+	  } else {
+	    /* At bottom of image, need a whole row of dummy blocks */
+	    xindex = 0;
+	  }
+	  /* Fill in any dummy blocks needed in this row.
+	   * Dummy blocks are filled in the same way as in jccoefct.c:
+	   * all zeroes in the AC entries, DC entries equal to previous
+	   * block's DC value.  The init routine has already zeroed the
+	   * AC entries, so we need only set the DC entries correctly.
+	   */
+	  for (; xindex < compptr->MCU_width; xindex++) {
+	    MCU_buffer[blkn] = coef->dummy_buffer[blkn];
+	    MCU_buffer[blkn][0][0] = MCU_buffer[blkn-1][0][0];
+	    blkn++;
+	  }
+	}
+      }
+      /* Try to write the MCU. */
+      if (! (*cinfo->entropy->encode_mcu) (cinfo, MCU_buffer)) {
+	/* Suspension forced; update state counters and exit */
+	coef->MCU_vert_offset = yoffset;
+	coef->mcu_ctr = MCU_col_num;
+	return FALSE;
+      }
+    }
+    /* Completed an MCU row, but perhaps not an iMCU row */
+    coef->mcu_ctr = 0;
+  }
+  /* Completed the iMCU row, advance counters for next one */
+  coef->iMCU_row_num++;
+  start_iMCU_row(cinfo);
+  return TRUE;
+}
+
+
+/*
+ * Initialize coefficient buffer controller.
+ *
+ * Each passed coefficient array must be the right size for that
+ * coefficient: width_in_blocks wide and height_in_blocks high,
+ * with unitheight at least v_samp_factor.
+ */
+
+LOCAL void
+transencode_coef_controller (j_compress_ptr cinfo,
+			     jvirt_barray_ptr * coef_arrays)
+{
+  my_coef_ptr coef;
+  JBLOCKROW buffer;
+  int i;
+
+  coef = (my_coef_ptr)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				SIZEOF(my_coef_controller));
+  cinfo->coef = (struct jpeg_c_coef_controller *) coef;
+  coef->pub.start_pass = start_pass_coef;
+  coef->pub.compress_data = compress_output;
+
+  /* Save pointer to virtual arrays */
+  coef->whole_image = coef_arrays;
+
+  /* Allocate and pre-zero space for dummy DCT blocks. */
+  buffer = (JBLOCKROW)
+    (*cinfo->mem->alloc_large) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				C_MAX_BLOCKS_IN_MCU * SIZEOF(JBLOCK));
+  jzero_far((void FAR *) buffer, C_MAX_BLOCKS_IN_MCU * SIZEOF(JBLOCK));
+  for (i = 0; i < C_MAX_BLOCKS_IN_MCU; i++) {
+    coef->dummy_buffer[i] = buffer + i;
+  }
+}
diff --git a/code/jpeg-6/jdapimin.cpp b/code/jpeg-6/jdapimin.cpp
new file mode 100644
index 0000000..f4aafd7
--- /dev/null
+++ b/code/jpeg-6/jdapimin.cpp
@@ -0,0 +1,404 @@
+/*
+ * jdapimin.c
+ *
+ * Copyright (C) 1994-1995, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains application interface code for the decompression half
+ * of the JPEG library.  These are the "minimum" API routines that may be
+ * needed in either the normal full-decompression case or the
+ * transcoding-only case.
+ *
+ * Most of the routines intended to be called directly by an application
+ * are in this file or in jdapistd.c.  But also see jcomapi.c for routines
+ * shared by compression and decompression, and jdtrans.c for the transcoding
+ * case.
+ */
+
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/*
+ * Initialization of a JPEG decompression object.
+ * The error manager must already be set up (in case memory manager fails).
+ */
+
+GLOBAL void
+jpeg_create_decompress (j_decompress_ptr cinfo)
+{
+  int i;
+
+  /* For debugging purposes, zero the whole master structure.
+   * But error manager pointer is already there, so save and restore it.
+   */
+  {
+    struct jpeg_error_mgr * err = cinfo->err;
+    MEMZERO(cinfo, SIZEOF(struct jpeg_decompress_struct));
+    cinfo->err = err;
+  }
+  cinfo->is_decompressor = TRUE;
+
+  /* Initialize a memory manager instance for this object */
+  jinit_memory_mgr((j_common_ptr) cinfo);
+
+  /* Zero out pointers to permanent structures. */
+  cinfo->progress = NULL;
+  cinfo->src = NULL;
+
+  for (i = 0; i < NUM_QUANT_TBLS; i++)
+    cinfo->quant_tbl_ptrs[i] = NULL;
+
+  for (i = 0; i < NUM_HUFF_TBLS; i++) {
+    cinfo->dc_huff_tbl_ptrs[i] = NULL;
+    cinfo->ac_huff_tbl_ptrs[i] = NULL;
+  }
+
+  /* Initialize marker processor so application can override methods
+   * for COM, APPn markers before calling jpeg_read_header.
+   */
+  jinit_marker_reader(cinfo);
+
+  /* And initialize the overall input controller. */
+  jinit_input_controller(cinfo);
+
+  /* OK, I'm ready */
+  cinfo->global_state = DSTATE_START;
+}
+
+
+/*
+ * Destruction of a JPEG decompression object
+ */
+
+GLOBAL void
+jpeg_destroy_decompress (j_decompress_ptr cinfo)
+{
+  jpeg_destroy((j_common_ptr) cinfo); /* use common routine */
+}
+
+
+/*
+ * Abort processing of a JPEG decompression operation,
+ * but don't destroy the object itself.
+ */
+
+GLOBAL void
+jpeg_abort_decompress (j_decompress_ptr cinfo)
+{
+  jpeg_abort((j_common_ptr) cinfo); /* use common routine */
+}
+
+
+/*
+ * Install a special processing method for COM or APPn markers.
+ */
+
+GLOBAL void
+jpeg_set_marker_processor (j_decompress_ptr cinfo, int marker_code,
+			   jpeg_marker_parser_method routine)
+{
+  if (marker_code == JPEG_COM)
+    cinfo->marker->process_COM = routine;
+  else if (marker_code >= JPEG_APP0 && marker_code <= JPEG_APP0+15)
+    cinfo->marker->process_APPn[marker_code-JPEG_APP0] = routine;
+  else
+    ERREXIT1(cinfo, JERR_UNKNOWN_MARKER, marker_code);
+}
+
+
+/*
+ * Set default decompression parameters.
+ */
+
+LOCAL void
+default_decompress_parms (j_decompress_ptr cinfo)
+{
+  /* Guess the input colorspace, and set output colorspace accordingly. */
+  /* (Wish JPEG committee had provided a real way to specify this...) */
+  /* Note application may override our guesses. */
+  switch (cinfo->num_components) {
+  case 1:
+    cinfo->jpeg_color_space = JCS_GRAYSCALE;
+    cinfo->out_color_space = JCS_GRAYSCALE;
+    break;
+    
+  case 3:
+    if (cinfo->saw_JFIF_marker) {
+      cinfo->jpeg_color_space = JCS_YCbCr; /* JFIF implies YCbCr */
+    } else if (cinfo->saw_Adobe_marker) {
+      switch (cinfo->Adobe_transform) {
+      case 0:
+	cinfo->jpeg_color_space = JCS_RGB;
+	break;
+      case 1:
+	cinfo->jpeg_color_space = JCS_YCbCr;
+	break;
+      default:
+	WARNMS1(cinfo, JWRN_ADOBE_XFORM, cinfo->Adobe_transform);
+	cinfo->jpeg_color_space = JCS_YCbCr; /* assume it's YCbCr */
+	break;
+      }
+    } else {
+      /* Saw no special markers, try to guess from the component IDs */
+      int cid0 = cinfo->comp_info[0].component_id;
+      int cid1 = cinfo->comp_info[1].component_id;
+      int cid2 = cinfo->comp_info[2].component_id;
+
+      if (cid0 == 1 && cid1 == 2 && cid2 == 3)
+	cinfo->jpeg_color_space = JCS_YCbCr; /* assume JFIF w/out marker */
+      else if (cid0 == 82 && cid1 == 71 && cid2 == 66)
+	cinfo->jpeg_color_space = JCS_RGB; /* ASCII 'R', 'G', 'B' */
+      else {
+	TRACEMS3(cinfo, 1, JTRC_UNKNOWN_IDS, cid0, cid1, cid2);
+	cinfo->jpeg_color_space = JCS_YCbCr; /* assume it's YCbCr */
+      }
+    }
+    /* Always guess RGB is proper output colorspace. */
+    cinfo->out_color_space = JCS_RGB;
+    break;
+    
+  case 4:
+    if (cinfo->saw_Adobe_marker) {
+      switch (cinfo->Adobe_transform) {
+      case 0:
+	cinfo->jpeg_color_space = JCS_CMYK;
+	break;
+      case 2:
+	cinfo->jpeg_color_space = JCS_YCCK;
+	break;
+      default:
+	WARNMS1(cinfo, JWRN_ADOBE_XFORM, cinfo->Adobe_transform);
+	cinfo->jpeg_color_space = JCS_YCCK; /* assume it's YCCK */
+	break;
+      }
+    } else {
+      /* No special markers, assume straight CMYK. */
+      cinfo->jpeg_color_space = JCS_CMYK;
+    }
+    cinfo->out_color_space = JCS_CMYK;
+    break;
+    
+  default:
+    cinfo->jpeg_color_space = JCS_UNKNOWN;
+    cinfo->out_color_space = JCS_UNKNOWN;
+    break;
+  }
+
+  /* Set defaults for other decompression parameters. */
+  cinfo->scale_num = 1;		/* 1:1 scaling */
+  cinfo->scale_denom = 1;
+  cinfo->output_gamma = 1.0;
+  cinfo->buffered_image = FALSE;
+  cinfo->raw_data_out = FALSE;
+  cinfo->dct_method = JDCT_DEFAULT;
+  cinfo->do_fancy_upsampling = TRUE;
+  cinfo->do_block_smoothing = TRUE;
+  cinfo->quantize_colors = FALSE;
+  /* We set these in case application only sets quantize_colors. */
+  cinfo->dither_mode = JDITHER_FS;
+#ifdef QUANT_2PASS_SUPPORTED
+  cinfo->two_pass_quantize = TRUE;
+#else
+  cinfo->two_pass_quantize = FALSE;
+#endif
+  cinfo->desired_number_of_colors = 256;
+  cinfo->colormap = NULL;
+  /* Initialize for no mode change in buffered-image mode. */
+  cinfo->enable_1pass_quant = FALSE;
+  cinfo->enable_external_quant = FALSE;
+  cinfo->enable_2pass_quant = FALSE;
+}
+
+
+/*
+ * Decompression startup: read start of JPEG datastream to see what's there.
+ * Need only initialize JPEG object and supply a data source before calling.
+ *
+ * This routine will read as far as the first SOS marker (ie, actual start of
+ * compressed data), and will save all tables and parameters in the JPEG
+ * object.  It will also initialize the decompression parameters to default
+ * values, and finally return JPEG_HEADER_OK.  On return, the application may
+ * adjust the decompression parameters and then call jpeg_start_decompress.
+ * (Or, if the application only wanted to determine the image parameters,
+ * the data need not be decompressed.  In that case, call jpeg_abort or
+ * jpeg_destroy to release any temporary space.)
+ * If an abbreviated (tables only) datastream is presented, the routine will
+ * return JPEG_HEADER_TABLES_ONLY upon reaching EOI.  The application may then
+ * re-use the JPEG object to read the abbreviated image datastream(s).
+ * It is unnecessary (but OK) to call jpeg_abort in this case.
+ * The JPEG_SUSPENDED return code only occurs if the data source module
+ * requests suspension of the decompressor.  In this case the application
+ * should load more source data and then re-call jpeg_read_header to resume
+ * processing.
+ * If a non-suspending data source is used and require_image is TRUE, then the
+ * return code need not be inspected since only JPEG_HEADER_OK is possible.
+ *
+ * This routine is now just a front end to jpeg_consume_input, with some
+ * extra error checking.
+ */
+
+GLOBAL int
+jpeg_read_header (j_decompress_ptr cinfo, boolean require_image)
+{
+  int retcode;
+
+  if (cinfo->global_state != DSTATE_START &&
+      cinfo->global_state != DSTATE_INHEADER)
+    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+
+  retcode = jpeg_consume_input(cinfo);
+
+  switch (retcode) {
+  case JPEG_REACHED_SOS:
+    retcode = JPEG_HEADER_OK;
+    break;
+  case JPEG_REACHED_EOI:
+    if (require_image)		/* Complain if application wanted an image */
+      ERREXIT(cinfo, JERR_NO_IMAGE);
+    /* Reset to start state; it would be safer to require the application to
+     * call jpeg_abort, but we can't change it now for compatibility reasons.
+     * A side effect is to free any temporary memory (there shouldn't be any).
+     */
+    jpeg_abort((j_common_ptr) cinfo); /* sets state = DSTATE_START */
+    retcode = JPEG_HEADER_TABLES_ONLY;
+    break;
+  case JPEG_SUSPENDED:
+    /* no work */
+    break;
+  }
+
+  return retcode;
+}
+
+
+/*
+ * Consume data in advance of what the decompressor requires.
+ * This can be called at any time once the decompressor object has
+ * been created and a data source has been set up.
+ *
+ * This routine is essentially a state machine that handles a couple
+ * of critical state-transition actions, namely initial setup and
+ * transition from header scanning to ready-for-start_decompress.
+ * All the actual input is done via the input controller's consume_input
+ * method.
+ */
+
+GLOBAL int
+jpeg_consume_input (j_decompress_ptr cinfo)
+{
+  int retcode = JPEG_SUSPENDED;
+
+  /* NB: every possible DSTATE value should be listed in this switch */
+  switch (cinfo->global_state) {
+  case DSTATE_START:
+    /* Start-of-datastream actions: reset appropriate modules */
+    (*cinfo->inputctl->reset_input_controller) (cinfo);
+    /* Initialize application's data source module */
+    (*cinfo->src->init_source) (cinfo);
+    cinfo->global_state = DSTATE_INHEADER;
+    /*FALLTHROUGH*/
+  case DSTATE_INHEADER:
+    retcode = (*cinfo->inputctl->consume_input) (cinfo);
+    if (retcode == JPEG_REACHED_SOS) { /* Found SOS, prepare to decompress */
+      /* Set up default parameters based on header data */
+      default_decompress_parms(cinfo);
+      /* Set global state: ready for start_decompress */
+      cinfo->global_state = DSTATE_READY;
+    }
+    break;
+  case DSTATE_READY:
+    /* Can't advance past first SOS until start_decompress is called */
+    retcode = JPEG_REACHED_SOS;
+    break;
+  case DSTATE_PRELOAD:
+  case DSTATE_PRESCAN:
+  case DSTATE_SCANNING:
+  case DSTATE_RAW_OK:
+  case DSTATE_BUFIMAGE:
+  case DSTATE_BUFPOST:
+  case DSTATE_STOPPING:
+    retcode = (*cinfo->inputctl->consume_input) (cinfo);
+    break;
+  default:
+    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+  }
+  return retcode;
+}
+
+
+/*
+ * Have we finished reading the input file?
+ */
+
+GLOBAL boolean
+jpeg_input_complete (j_decompress_ptr cinfo)
+{
+  /* Check for valid jpeg object */
+  if (cinfo->global_state < DSTATE_START ||
+      cinfo->global_state > DSTATE_STOPPING)
+    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+  return cinfo->inputctl->eoi_reached;
+}
+
+
+/*
+ * Is there more than one scan?
+ */
+
+GLOBAL boolean
+jpeg_has_multiple_scans (j_decompress_ptr cinfo)
+{
+  /* Only valid after jpeg_read_header completes */
+  if (cinfo->global_state < DSTATE_READY ||
+      cinfo->global_state > DSTATE_STOPPING)
+    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+  return cinfo->inputctl->has_multiple_scans;
+}
+
+
+/*
+ * Finish JPEG decompression.
+ *
+ * This will normally just verify the file trailer and release temp storage.
+ *
+ * Returns FALSE if suspended.  The return value need be inspected only if
+ * a suspending data source is used.
+ */
+
+GLOBAL boolean
+jpeg_finish_decompress (j_decompress_ptr cinfo)
+{
+  if ((cinfo->global_state == DSTATE_SCANNING ||
+       cinfo->global_state == DSTATE_RAW_OK) && ! cinfo->buffered_image) {
+    /* Terminate final pass of non-buffered mode */
+    if (cinfo->output_scanline < cinfo->output_height)
+      ERREXIT(cinfo, JERR_TOO_LITTLE_DATA);
+    (*cinfo->master->finish_output_pass) (cinfo);
+    cinfo->global_state = DSTATE_STOPPING;
+  } else if (cinfo->global_state == DSTATE_BUFIMAGE) {
+    /* Finishing after a buffered-image operation */
+    cinfo->global_state = DSTATE_STOPPING;
+  } else if (cinfo->global_state != DSTATE_STOPPING) {
+    /* STOPPING = repeat call after a suspension, anything else is error */
+    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+  }
+  /* Read until EOI */
+  while (! cinfo->inputctl->eoi_reached) {
+    if ((*cinfo->inputctl->consume_input) (cinfo) == JPEG_SUSPENDED)
+      return FALSE;		/* Suspend, come back later */
+  }
+  /* Do final cleanup */
+  (*cinfo->src->term_source) (cinfo);
+  /* We can use jpeg_abort to release memory and reset global_state */
+  jpeg_abort((j_common_ptr) cinfo);
+  return TRUE;
+}
diff --git a/code/jpeg-6/jdapistd.cpp b/code/jpeg-6/jdapistd.cpp
new file mode 100644
index 0000000..71390df
--- /dev/null
+++ b/code/jpeg-6/jdapistd.cpp
@@ -0,0 +1,281 @@
+/*
+ * jdapistd.c
+ *
+ * Copyright (C) 1994-1995, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains application interface code for the decompression half
+ * of the JPEG library.  These are the "standard" API routines that are
+ * used in the normal full-decompression case.  They are not used by a
+ * transcoding-only application.  Note that if an application links in
+ * jpeg_start_decompress, it will end up linking in the entire decompressor.
+ * We thus must separate this file from jdapimin.c to avoid linking the
+ * whole decompression library into a transcoder.
+ */
+
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/* Forward declarations */
+LOCAL boolean output_pass_setup JPP((j_decompress_ptr cinfo));
+
+
+/*
+ * Decompression initialization.
+ * jpeg_read_header must be completed before calling this.
+ *
+ * If a multipass operating mode was selected, this will do all but the
+ * last pass, and thus may take a great deal of time.
+ *
+ * Returns FALSE if suspended.  The return value need be inspected only if
+ * a suspending data source is used.
+ */
+
+GLOBAL boolean
+jpeg_start_decompress (j_decompress_ptr cinfo)
+{
+  if (cinfo->global_state == DSTATE_READY) {
+    /* First call: initialize master control, select active modules */
+    jinit_master_decompress(cinfo);
+    if (cinfo->buffered_image) {
+      /* No more work here; expecting jpeg_start_output next */
+      cinfo->global_state = DSTATE_BUFIMAGE;
+      return TRUE;
+    }
+    cinfo->global_state = DSTATE_PRELOAD;
+  }
+  if (cinfo->global_state == DSTATE_PRELOAD) {
+    /* If file has multiple scans, absorb them all into the coef buffer */
+    if (cinfo->inputctl->has_multiple_scans) {
+#ifdef D_MULTISCAN_FILES_SUPPORTED
+      for (;;) {
+	int retcode;
+	/* Call progress monitor hook if present */
+	if (cinfo->progress != NULL)
+	  (*cinfo->progress->progress_monitor) ((j_common_ptr) cinfo);
+	/* Absorb some more input */
+	retcode = (*cinfo->inputctl->consume_input) (cinfo);
+	if (retcode == JPEG_SUSPENDED)
+	  return FALSE;
+	if (retcode == JPEG_REACHED_EOI)
+	  break;
+	/* Advance progress counter if appropriate */
+	if (cinfo->progress != NULL &&
+	    (retcode == JPEG_ROW_COMPLETED || retcode == JPEG_REACHED_SOS)) {
+	  if (++cinfo->progress->pass_counter >= cinfo->progress->pass_limit) {
+	    /* jdmaster underestimated number of scans; ratchet up one scan */
+	    cinfo->progress->pass_limit += (long) cinfo->total_iMCU_rows;
+	  }
+	}
+      }
+#else
+      ERREXIT(cinfo, JERR_NOT_COMPILED);
+#endif /* D_MULTISCAN_FILES_SUPPORTED */
+    }
+    cinfo->output_scan_number = cinfo->input_scan_number;
+  } else if (cinfo->global_state != DSTATE_PRESCAN)
+    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+  /* Perform any dummy output passes, and set up for the final pass */
+  return output_pass_setup(cinfo);
+}
+
+
+/*
+ * Set up for an output pass, and perform any dummy pass(es) needed.
+ * Common subroutine for jpeg_start_decompress and jpeg_start_output.
+ * Entry: global_state = DSTATE_PRESCAN only if previously suspended.
+ * Exit: If done, returns TRUE and sets global_state for proper output mode.
+ *       If suspended, returns FALSE and sets global_state = DSTATE_PRESCAN.
+ */
+
+LOCAL boolean
+output_pass_setup (j_decompress_ptr cinfo)
+{
+  if (cinfo->global_state != DSTATE_PRESCAN) {
+    /* First call: do pass setup */
+    (*cinfo->master->prepare_for_output_pass) (cinfo);
+    cinfo->output_scanline = 0;
+    cinfo->global_state = DSTATE_PRESCAN;
+  }
+  /* Loop over any required dummy passes */
+  while (cinfo->master->is_dummy_pass) {
+#ifdef QUANT_2PASS_SUPPORTED
+    /* Crank through the dummy pass */
+    while (cinfo->output_scanline < cinfo->output_height) {
+      JDIMENSION last_scanline;
+      /* Call progress monitor hook if present */
+      if (cinfo->progress != NULL) {
+	cinfo->progress->pass_counter = (long) cinfo->output_scanline;
+	cinfo->progress->pass_limit = (long) cinfo->output_height;
+	(*cinfo->progress->progress_monitor) ((j_common_ptr) cinfo);
+      }
+      /* Process some data */
+      last_scanline = cinfo->output_scanline;
+      (*cinfo->main->process_data) (cinfo, (JSAMPARRAY) NULL,
+				    &cinfo->output_scanline, (JDIMENSION) 0);
+      if (cinfo->output_scanline == last_scanline)
+	return FALSE;		/* No progress made, must suspend */
+    }
+    /* Finish up dummy pass, and set up for another one */
+    (*cinfo->master->finish_output_pass) (cinfo);
+    (*cinfo->master->prepare_for_output_pass) (cinfo);
+    cinfo->output_scanline = 0;
+#else
+    ERREXIT(cinfo, JERR_NOT_COMPILED);
+#endif /* QUANT_2PASS_SUPPORTED */
+  }
+  /* Ready for application to drive output pass through
+   * jpeg_read_scanlines or jpeg_read_raw_data.
+   */
+  cinfo->global_state = cinfo->raw_data_out ? DSTATE_RAW_OK : DSTATE_SCANNING;
+  return TRUE;
+}
+
+
+/*
+ * Read some scanlines of data from the JPEG decompressor.
+ *
+ * The return value will be the number of lines actually read.
+ * This may be less than the number requested in several cases,
+ * including bottom of image, data source suspension, and operating
+ * modes that emit multiple scanlines at a time.
+ *
+ * Note: we warn about excess calls to jpeg_read_scanlines() since
+ * this likely signals an application programmer error.  However,
+ * an oversize buffer (max_lines > scanlines remaining) is not an error.
+ */
+
+GLOBAL JDIMENSION
+jpeg_read_scanlines (j_decompress_ptr cinfo, JSAMPARRAY scanlines,
+		     JDIMENSION max_lines)
+{
+  JDIMENSION row_ctr;
+
+  if (cinfo->global_state != DSTATE_SCANNING)
+    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+  if (cinfo->output_scanline >= cinfo->output_height) {
+    WARNMS(cinfo, JWRN_TOO_MUCH_DATA);
+    return 0;
+  }
+
+  /* Call progress monitor hook if present */
+  if (cinfo->progress != NULL) {
+    cinfo->progress->pass_counter = (long) cinfo->output_scanline;
+    cinfo->progress->pass_limit = (long) cinfo->output_height;
+    (*cinfo->progress->progress_monitor) ((j_common_ptr) cinfo);
+  }
+
+  /* Process some data */
+  row_ctr = 0;
+  (*cinfo->main->process_data) (cinfo, scanlines, &row_ctr, max_lines);
+  cinfo->output_scanline += row_ctr;
+  return row_ctr;
+}
+
+
+/*
+ * Alternate entry point to read raw data.
+ * Processes exactly one iMCU row per call, unless suspended.
+ */
+
+GLOBAL JDIMENSION
+jpeg_read_raw_data (j_decompress_ptr cinfo, JSAMPIMAGE data,
+		    JDIMENSION max_lines)
+{
+  JDIMENSION lines_per_iMCU_row;
+
+  if (cinfo->global_state != DSTATE_RAW_OK)
+    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+  if (cinfo->output_scanline >= cinfo->output_height) {
+    WARNMS(cinfo, JWRN_TOO_MUCH_DATA);
+    return 0;
+  }
+
+  /* Call progress monitor hook if present */
+  if (cinfo->progress != NULL) {
+    cinfo->progress->pass_counter = (long) cinfo->output_scanline;
+    cinfo->progress->pass_limit = (long) cinfo->output_height;
+    (*cinfo->progress->progress_monitor) ((j_common_ptr) cinfo);
+  }
+
+  /* Verify that at least one iMCU row can be returned. */
+  lines_per_iMCU_row = cinfo->max_v_samp_factor * cinfo->min_DCT_scaled_size;
+  if (max_lines < lines_per_iMCU_row)
+    ERREXIT(cinfo, JERR_BUFFER_SIZE);
+
+  /* Decompress directly into user's buffer. */
+  if (! (*cinfo->coef->decompress_data) (cinfo, data))
+    return 0;			/* suspension forced, can do nothing more */
+
+  /* OK, we processed one iMCU row. */
+  cinfo->output_scanline += lines_per_iMCU_row;
+  return lines_per_iMCU_row;
+}
+
+
+/* Additional entry points for buffered-image mode. */
+
+#ifdef D_MULTISCAN_FILES_SUPPORTED
+
+/*
+ * Initialize for an output pass in buffered-image mode.
+ */
+
+GLOBAL boolean
+jpeg_start_output (j_decompress_ptr cinfo, int scan_number)
+{
+  if (cinfo->global_state != DSTATE_BUFIMAGE &&
+      cinfo->global_state != DSTATE_PRESCAN)
+    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+  /* Limit scan number to valid range */
+  if (scan_number <= 0)
+    scan_number = 1;
+  if (cinfo->inputctl->eoi_reached &&
+      scan_number > cinfo->input_scan_number)
+    scan_number = cinfo->input_scan_number;
+  cinfo->output_scan_number = scan_number;
+  /* Perform any dummy output passes, and set up for the real pass */
+  return output_pass_setup(cinfo);
+}
+
+
+/*
+ * Finish up after an output pass in buffered-image mode.
+ *
+ * Returns FALSE if suspended.  The return value need be inspected only if
+ * a suspending data source is used.
+ */
+
+GLOBAL boolean
+jpeg_finish_output (j_decompress_ptr cinfo)
+{
+  if ((cinfo->global_state == DSTATE_SCANNING ||
+       cinfo->global_state == DSTATE_RAW_OK) && cinfo->buffered_image) {
+    /* Terminate this pass. */
+    /* We do not require the whole pass to have been completed. */
+    (*cinfo->master->finish_output_pass) (cinfo);
+    cinfo->global_state = DSTATE_BUFPOST;
+  } else if (cinfo->global_state != DSTATE_BUFPOST) {
+    /* BUFPOST = repeat call after a suspension, anything else is error */
+    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+  }
+  /* Read markers looking for SOS or EOI */
+  while (cinfo->input_scan_number <= cinfo->output_scan_number &&
+	 ! cinfo->inputctl->eoi_reached) {
+    if ((*cinfo->inputctl->consume_input) (cinfo) == JPEG_SUSPENDED)
+      return FALSE;		/* Suspend, come back later */
+  }
+  cinfo->global_state = DSTATE_BUFIMAGE;
+  return TRUE;
+}
+
+#endif /* D_MULTISCAN_FILES_SUPPORTED */
diff --git a/code/jpeg-6/jdatadst.cpp b/code/jpeg-6/jdatadst.cpp
new file mode 100644
index 0000000..c7f3506
--- /dev/null
+++ b/code/jpeg-6/jdatadst.cpp
@@ -0,0 +1,158 @@
+/*
+ * jdatadst.c
+ *
+ * Copyright (C) 1994, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains compression data destination routines for the case of
+ * emitting JPEG data to a file (or any stdio stream).  While these routines
+ * are sufficient for most applications, some will want to use a different
+ * destination manager.
+ * IMPORTANT: we assume that fwrite() will correctly transcribe an array of
+ * JOCTETs into 8-bit-wide elements on external storage.  If char is wider
+ * than 8 bits on your machine, you may need to do some tweaking.
+ */
+
+
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+
+
+/* this is not a core library module, so it doesn't define JPEG_INTERNALS */
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jerror.h"
+
+
+/* Expanded data destination object for stdio output */
+
+typedef struct {
+  struct jpeg_destination_mgr pub; /* public fields */
+
+  FILE * outfile;		/* target stream */
+  JOCTET * buffer;		/* start of buffer */
+} my_destination_mgr;
+
+typedef my_destination_mgr * my_dest_ptr;
+
+#define OUTPUT_BUF_SIZE  4096	/* choose an efficiently fwrite'able size */
+
+
+/*
+ * Initialize destination --- called by jpeg_start_compress
+ * before any data is actually written.
+ */
+
+METHODDEF void
+init_destination (j_compress_ptr cinfo)
+{
+  my_dest_ptr dest = (my_dest_ptr) cinfo->dest;
+
+  /* Allocate the output buffer --- it will be released when done with image */
+  dest->buffer = (JOCTET *)
+      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				  OUTPUT_BUF_SIZE * SIZEOF(JOCTET));
+
+  dest->pub.next_output_byte = dest->buffer;
+  dest->pub.free_in_buffer = OUTPUT_BUF_SIZE;
+}
+
+
+/*
+ * Empty the output buffer --- called whenever buffer fills up.
+ *
+ * In typical applications, this should write the entire output buffer
+ * (ignoring the current state of next_output_byte & free_in_buffer),
+ * reset the pointer & count to the start of the buffer, and return TRUE
+ * indicating that the buffer has been dumped.
+ *
+ * In applications that need to be able to suspend compression due to output
+ * overrun, a FALSE return indicates that the buffer cannot be emptied now.
+ * In this situation, the compressor will return to its caller (possibly with
+ * an indication that it has not accepted all the supplied scanlines).  The
+ * application should resume compression after it has made more room in the
+ * output buffer.  Note that there are substantial restrictions on the use of
+ * suspension --- see the documentation.
+ *
+ * When suspending, the compressor will back up to a convenient restart point
+ * (typically the start of the current MCU). next_output_byte & free_in_buffer
+ * indicate where the restart point will be if the current call returns FALSE.
+ * Data beyond this point will be regenerated after resumption, so do not
+ * write it out when emptying the buffer externally.
+ */
+
+METHODDEF boolean
+empty_output_buffer (j_compress_ptr cinfo)
+{
+  my_dest_ptr dest = (my_dest_ptr) cinfo->dest;
+
+  if (JFWRITE(dest->outfile, dest->buffer, OUTPUT_BUF_SIZE) !=
+      (size_t) OUTPUT_BUF_SIZE)
+    ERREXIT(cinfo, JERR_FILE_WRITE);
+
+  dest->pub.next_output_byte = dest->buffer;
+  dest->pub.free_in_buffer = OUTPUT_BUF_SIZE;
+
+  return TRUE;
+}
+
+
+/*
+ * Terminate destination --- called by jpeg_finish_compress
+ * after all data has been written.  Usually needs to flush buffer.
+ *
+ * NB: *not* called by jpeg_abort or jpeg_destroy; surrounding
+ * application must deal with any cleanup that should happen even
+ * for error exit.
+ */
+
+METHODDEF void
+term_destination (j_compress_ptr cinfo)
+{
+  my_dest_ptr dest = (my_dest_ptr) cinfo->dest;
+  size_t datacount = OUTPUT_BUF_SIZE - dest->pub.free_in_buffer;
+
+  /* Write any data remaining in the buffer */
+  if (datacount > 0) {
+    if (JFWRITE(dest->outfile, dest->buffer, datacount) != datacount)
+      ERREXIT(cinfo, JERR_FILE_WRITE);
+  }
+  fflush(dest->outfile);
+  /* Make sure we wrote the output file OK */
+  if (ferror(dest->outfile))
+    ERREXIT(cinfo, JERR_FILE_WRITE);
+}
+
+
+/*
+ * Prepare for output to a stdio stream.
+ * The caller must have already opened the stream, and is responsible
+ * for closing it after finishing compression.
+ */
+
+GLOBAL void
+jpeg_stdio_dest (j_compress_ptr cinfo, FILE * outfile)
+{
+  my_dest_ptr dest;
+
+  /* The destination object is made permanent so that multiple JPEG images
+   * can be written to the same file without re-executing jpeg_stdio_dest.
+   * This makes it dangerous to use this manager and a different destination
+   * manager serially with the same JPEG object, because their private object
+   * sizes may be different.  Caveat programmer.
+   */
+  if (cinfo->dest == NULL) {	/* first time for this JPEG object? */
+    cinfo->dest = (struct jpeg_destination_mgr *)
+      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
+				  SIZEOF(my_destination_mgr));
+  }
+
+  dest = (my_dest_ptr) cinfo->dest;
+  dest->pub.init_destination = init_destination;
+  dest->pub.empty_output_buffer = empty_output_buffer;
+  dest->pub.term_destination = term_destination;
+  dest->outfile = outfile;
+}
diff --git a/code/jpeg-6/jdatasrc.cpp b/code/jpeg-6/jdatasrc.cpp
new file mode 100644
index 0000000..8e27693
--- /dev/null
+++ b/code/jpeg-6/jdatasrc.cpp
@@ -0,0 +1,210 @@
+/*
+ * jdatasrc.c
+ *
+ * Copyright (C) 1994, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains decompression data source routines for the case of
+ * reading JPEG data from a file (or any stdio stream).  While these routines
+ * are sufficient for most applications, some will want to use a different
+ * source manager.
+ * IMPORTANT: we assume that fread() will correctly transcribe an array of
+ * JOCTETs from 8-bit-wide elements on external storage.  If char is wider
+ * than 8 bits on your machine, you may need to do some tweaking.
+ */
+
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+
+
+
+/* this is not a core library module, so it doesn't define JPEG_INTERNALS */
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jerror.h"
+
+
+/* Expanded data source object for stdio input */
+
+typedef struct {
+  struct jpeg_source_mgr pub;	/* public fields */
+
+  unsigned char *infile;		/* source stream */
+  JOCTET * buffer;		/* start of buffer */
+  boolean start_of_file;	/* have we gotten any data yet? */
+} my_source_mgr;
+
+typedef my_source_mgr * my_src_ptr;
+
+#define INPUT_BUF_SIZE  4096	/* choose an efficiently fread'able size */
+
+
+/*
+ * Initialize source --- called by jpeg_read_header
+ * before any data is actually read.
+ */
+
+METHODDEF void
+init_source (j_decompress_ptr cinfo)
+{
+  my_src_ptr src = (my_src_ptr) cinfo->src;
+
+  /* We reset the empty-input-file flag for each image,
+   * but we don't clear the input buffer.
+   * This is correct behavior for reading a series of images from one source.
+   */
+  src->start_of_file = TRUE;
+}
+
+
+/*
+ * Fill the input buffer --- called whenever buffer is emptied.
+ *
+ * In typical applications, this should read fresh data into the buffer
+ * (ignoring the current state of next_input_byte & bytes_in_buffer),
+ * reset the pointer & count to the start of the buffer, and return TRUE
+ * indicating that the buffer has been reloaded.  It is not necessary to
+ * fill the buffer entirely, only to obtain at least one more byte.
+ *
+ * There is no such thing as an EOF return.  If the end of the file has been
+ * reached, the routine has a choice of ERREXIT() or inserting fake data into
+ * the buffer.  In most cases, generating a warning message and inserting a
+ * fake EOI marker is the best course of action --- this will allow the
+ * decompressor to output however much of the image is there.  However,
+ * the resulting error message is misleading if the real problem is an empty
+ * input file, so we handle that case specially.
+ *
+ * In applications that need to be able to suspend compression due to input
+ * not being available yet, a FALSE return indicates that no more data can be
+ * obtained right now, but more may be forthcoming later.  In this situation,
+ * the decompressor will return to its caller (with an indication of the
+ * number of scanlines it has read, if any).  The application should resume
+ * decompression after it has loaded more data into the input buffer.  Note
+ * that there are substantial restrictions on the use of suspension --- see
+ * the documentation.
+ *
+ * When suspending, the decompressor will back up to a convenient restart point
+ * (typically the start of the current MCU). next_input_byte & bytes_in_buffer
+ * indicate where the restart point will be if the current call returns FALSE.
+ * Data beyond this point must be rescanned after resumption, so move it to
+ * the front of the buffer rather than discarding it.
+ */
+
+METHODDEF boolean
+fill_input_buffer (j_decompress_ptr cinfo)
+{
+  my_src_ptr src = (my_src_ptr) cinfo->src;
+
+  memcpy( src->buffer, src->infile, INPUT_BUF_SIZE );
+
+  src->infile += INPUT_BUF_SIZE;
+
+  src->pub.next_input_byte = src->buffer;
+  src->pub.bytes_in_buffer = INPUT_BUF_SIZE;
+  src->start_of_file = FALSE;
+
+  return TRUE;
+}
+
+
+/*
+ * Skip data --- used to skip over a potentially large amount of
+ * uninteresting data (such as an APPn marker).
+ *
+ * Writers of suspendable-input applications must note that skip_input_data
+ * is not granted the right to give a suspension return.  If the skip extends
+ * beyond the data currently in the buffer, the buffer can be marked empty so
+ * that the next read will cause a fill_input_buffer call that can suspend.
+ * Arranging for additional bytes to be discarded before reloading the input
+ * buffer is the application writer's problem.
+ */
+
+METHODDEF void
+skip_input_data (j_decompress_ptr cinfo, long num_bytes)
+{
+  my_src_ptr src = (my_src_ptr) cinfo->src;
+
+  /* Just a dumb implementation for now.  Could use fseek() except
+   * it doesn't work on pipes.  Not clear that being smart is worth
+   * any trouble anyway --- large skips are infrequent.
+   */
+  if (num_bytes > 0) {
+    while (num_bytes > (long) src->pub.bytes_in_buffer) {
+      num_bytes -= (long) src->pub.bytes_in_buffer;
+      (void) fill_input_buffer(cinfo);
+      /* note we assume that fill_input_buffer will never return FALSE,
+       * so suspension need not be handled.
+       */
+    }
+    src->pub.next_input_byte += (size_t) num_bytes;
+    src->pub.bytes_in_buffer -= (size_t) num_bytes;
+  }
+}
+
+
+/*
+ * An additional method that can be provided by data source modules is the
+ * resync_to_restart method for error recovery in the presence of RST markers.
+ * For the moment, this source module just uses the default resync method
+ * provided by the JPEG library.  That method assumes that no backtracking
+ * is possible.
+ */
+
+
+/*
+ * Terminate source --- called by jpeg_finish_decompress
+ * after all data has been read.  Often a no-op.
+ *
+ * NB: *not* called by jpeg_abort or jpeg_destroy; surrounding
+ * application must deal with any cleanup that should happen even
+ * for error exit.
+ */
+
+METHODDEF void
+term_source (j_decompress_ptr cinfo)
+{
+  /* no work necessary here */
+}
+
+
+/*
+ * Prepare for input from a stdio stream.
+ * The caller must have already opened the stream, and is responsible
+ * for closing it after finishing decompression.
+ */
+
+GLOBAL void
+jpeg_stdio_src (j_decompress_ptr cinfo, unsigned char *infile)
+{
+  my_src_ptr src;
+
+  /* The source object and input buffer are made permanent so that a series
+   * of JPEG images can be read from the same file by calling jpeg_stdio_src
+   * only before the first one.  (If we discarded the buffer at the end of
+   * one image, we'd likely lose the start of the next one.)
+   * This makes it unsafe to use this manager and a different source
+   * manager serially with the same JPEG object.  Caveat programmer.
+   */
+  if (cinfo->src == NULL) {	/* first time for this JPEG object? */
+    cinfo->src = (struct jpeg_source_mgr *)
+      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
+				  SIZEOF(my_source_mgr));
+    src = (my_src_ptr) cinfo->src;
+    src->buffer = (JOCTET *)
+      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
+				  INPUT_BUF_SIZE * SIZEOF(JOCTET));
+  }
+
+  src = (my_src_ptr) cinfo->src;
+  src->pub.init_source = init_source;
+  src->pub.fill_input_buffer = fill_input_buffer;
+  src->pub.skip_input_data = skip_input_data;
+  src->pub.resync_to_restart = jpeg_resync_to_restart; /* use default method */
+  src->pub.term_source = term_source;
+  src->infile = infile;
+  src->pub.bytes_in_buffer = 0; /* forces fill_input_buffer on first read */
+  src->pub.next_input_byte = NULL; /* until buffer loaded */
+}
diff --git a/code/jpeg-6/jdcoefct.cpp b/code/jpeg-6/jdcoefct.cpp
new file mode 100644
index 0000000..611330a
--- /dev/null
+++ b/code/jpeg-6/jdcoefct.cpp
@@ -0,0 +1,731 @@
+/*
+ * jdcoefct.c
+ *
+ * Copyright (C) 1994-1995, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains the coefficient buffer controller for decompression.
+ * This controller is the top level of the JPEG decompressor proper.
+ * The coefficient buffer lies between entropy decoding and inverse-DCT steps.
+ *
+ * In buffered-image mode, this controller is the interface between
+ * input-oriented processing and output-oriented processing.
+ * Also, the input side (only) is used when reading a file for transcoding.
+ */
+
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+/* Block smoothing is only applicable for progressive JPEG, so: */
+#ifndef D_PROGRESSIVE_SUPPORTED
+#undef BLOCK_SMOOTHING_SUPPORTED
+#endif
+
+/* Private buffer controller object */
+
+typedef struct {
+  struct jpeg_d_coef_controller pub; /* public fields */
+
+  /* These variables keep track of the current location of the input side. */
+  /* cinfo->input_iMCU_row is also used for this. */
+  JDIMENSION MCU_ctr;		/* counts MCUs processed in current row */
+  int MCU_vert_offset;		/* counts MCU rows within iMCU row */
+  int MCU_rows_per_iMCU_row;	/* number of such rows needed */
+
+  /* The output side's location is represented by cinfo->output_iMCU_row. */
+
+  /* In single-pass modes, it's sufficient to buffer just one MCU.
+   * We allocate a workspace of D_MAX_BLOCKS_IN_MCU coefficient blocks,
+   * and let the entropy decoder write into that workspace each time.
+   * (On 80x86, the workspace is FAR even though it's not really very big;
+   * this is to keep the module interfaces unchanged when a large coefficient
+   * buffer is necessary.)
+   * In multi-pass modes, this array points to the current MCU's blocks
+   * within the virtual arrays; it is used only by the input side.
+   */
+  JBLOCKROW MCU_buffer[D_MAX_BLOCKS_IN_MCU];
+
+#ifdef D_MULTISCAN_FILES_SUPPORTED
+  /* In multi-pass modes, we need a virtual block array for each component. */
+  jvirt_barray_ptr whole_image[MAX_COMPONENTS];
+#endif
+
+#ifdef BLOCK_SMOOTHING_SUPPORTED
+  /* When doing block smoothing, we latch coefficient Al values here */
+  int * coef_bits_latch;
+#define SAVED_COEFS  6		/* we save coef_bits[0..5] */
+#endif
+} my_coef_controller;
+
+typedef my_coef_controller * my_coef_ptr;
+
+/* Forward declarations */
+METHODDEF int decompress_onepass
+	JPP((j_decompress_ptr cinfo, JSAMPIMAGE output_buf));
+#ifdef D_MULTISCAN_FILES_SUPPORTED
+METHODDEF int decompress_data
+	JPP((j_decompress_ptr cinfo, JSAMPIMAGE output_buf));
+#endif
+#ifdef BLOCK_SMOOTHING_SUPPORTED
+LOCAL boolean smoothing_ok JPP((j_decompress_ptr cinfo));
+METHODDEF int decompress_smooth_data
+	JPP((j_decompress_ptr cinfo, JSAMPIMAGE output_buf));
+#endif
+
+
+LOCAL void
+start_iMCU_row (j_decompress_ptr cinfo)
+/* Reset within-iMCU-row counters for a new row (input side) */
+{
+  my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
+
+  /* In an interleaved scan, an MCU row is the same as an iMCU row.
+   * In a noninterleaved scan, an iMCU row has v_samp_factor MCU rows.
+   * But at the bottom of the image, process only what's left.
+   */
+  if (cinfo->comps_in_scan > 1) {
+    coef->MCU_rows_per_iMCU_row = 1;
+  } else {
+    if (cinfo->input_iMCU_row < (cinfo->total_iMCU_rows-1))
+      coef->MCU_rows_per_iMCU_row = cinfo->cur_comp_info[0]->v_samp_factor;
+    else
+      coef->MCU_rows_per_iMCU_row = cinfo->cur_comp_info[0]->last_row_height;
+  }
+
+  coef->MCU_ctr = 0;
+  coef->MCU_vert_offset = 0;
+}
+
+
+/*
+ * Initialize for an input processing pass.
+ */
+
+METHODDEF void
+start_input_pass (j_decompress_ptr cinfo)
+{
+  cinfo->input_iMCU_row = 0;
+  start_iMCU_row(cinfo);
+}
+
+
+/*
+ * Initialize for an output processing pass.
+ */
+
+METHODDEF void
+start_output_pass (j_decompress_ptr cinfo)
+{
+#ifdef BLOCK_SMOOTHING_SUPPORTED
+  my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
+
+  /* If multipass, check to see whether to use block smoothing on this pass */
+  if (coef->pub.coef_arrays != NULL) {
+    if (cinfo->do_block_smoothing && smoothing_ok(cinfo))
+      coef->pub.decompress_data = decompress_smooth_data;
+    else
+      coef->pub.decompress_data = decompress_data;
+  }
+#endif
+  cinfo->output_iMCU_row = 0;
+}
+
+
+/*
+ * Decompress and return some data in the single-pass case.
+ * Always attempts to emit one fully interleaved MCU row ("iMCU" row).
+ * Input and output must run in lockstep since we have only a one-MCU buffer.
+ * Return value is JPEG_ROW_COMPLETED, JPEG_SCAN_COMPLETED, or JPEG_SUSPENDED.
+ *
+ * NB: output_buf contains a plane for each component in image.
+ * For single pass, this is the same as the components in the scan.
+ */
+
+METHODDEF int
+decompress_onepass (j_decompress_ptr cinfo, JSAMPIMAGE output_buf)
+{
+  my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
+  JDIMENSION MCU_col_num;	/* index of current MCU within row */
+  JDIMENSION last_MCU_col = cinfo->MCUs_per_row - 1;
+  JDIMENSION last_iMCU_row = cinfo->total_iMCU_rows - 1;
+  int blkn, ci, xindex, yindex, yoffset, useful_width;
+  JSAMPARRAY output_ptr;
+  JDIMENSION start_col, output_col;
+  jpeg_component_info *compptr;
+  inverse_DCT_method_ptr inverse_DCT;
+
+  /* Loop to process as much as one whole iMCU row */
+  for (yoffset = coef->MCU_vert_offset; yoffset < coef->MCU_rows_per_iMCU_row;
+       yoffset++) {
+    for (MCU_col_num = coef->MCU_ctr; MCU_col_num <= last_MCU_col;
+	 MCU_col_num++) {
+      /* Try to fetch an MCU.  Entropy decoder expects buffer to be zeroed. */
+      jzero_far((void FAR *) coef->MCU_buffer[0],
+		(size_t) (cinfo->blocks_in_MCU * SIZEOF(JBLOCK)));
+      if (! (*cinfo->entropy->decode_mcu) (cinfo, coef->MCU_buffer)) {
+	/* Suspension forced; update state counters and exit */
+	coef->MCU_vert_offset = yoffset;
+	coef->MCU_ctr = MCU_col_num;
+	return JPEG_SUSPENDED;
+      }
+      /* Determine where data should go in output_buf and do the IDCT thing.
+       * We skip dummy blocks at the right and bottom edges (but blkn gets
+       * incremented past them!).  Note the inner loop relies on having
+       * allocated the MCU_buffer[] blocks sequentially.
+       */
+      blkn = 0;			/* index of current DCT block within MCU */
+      for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+	compptr = cinfo->cur_comp_info[ci];
+	/* Don't bother to IDCT an uninteresting component. */
+	if (! compptr->component_needed) {
+	  blkn += compptr->MCU_blocks;
+	  continue;
+	}
+	inverse_DCT = cinfo->idct->inverse_DCT[compptr->component_index];
+	useful_width = (MCU_col_num < last_MCU_col) ? compptr->MCU_width
+						    : compptr->last_col_width;
+	output_ptr = output_buf[ci] + yoffset * compptr->DCT_scaled_size;
+	start_col = MCU_col_num * compptr->MCU_sample_width;
+	for (yindex = 0; yindex < compptr->MCU_height; yindex++) {
+	  if (cinfo->input_iMCU_row < last_iMCU_row ||
+	      yoffset+yindex < compptr->last_row_height) {
+	    output_col = start_col;
+	    for (xindex = 0; xindex < useful_width; xindex++) {
+	      (*inverse_DCT) (cinfo, compptr,
+			      (JCOEFPTR) coef->MCU_buffer[blkn+xindex],
+			      output_ptr, output_col);
+	      output_col += compptr->DCT_scaled_size;
+	    }
+	  }
+	  blkn += compptr->MCU_width;
+	  output_ptr += compptr->DCT_scaled_size;
+	}
+      }
+    }
+    /* Completed an MCU row, but perhaps not an iMCU row */
+    coef->MCU_ctr = 0;
+  }
+  /* Completed the iMCU row, advance counters for next one */
+  cinfo->output_iMCU_row++;
+  if (++(cinfo->input_iMCU_row) < cinfo->total_iMCU_rows) {
+    start_iMCU_row(cinfo);
+    return JPEG_ROW_COMPLETED;
+  }
+  /* Completed the scan */
+  (*cinfo->inputctl->finish_input_pass) (cinfo);
+  return JPEG_SCAN_COMPLETED;
+}
+
+
+/*
+ * Dummy consume-input routine for single-pass operation.
+ */
+
+METHODDEF int
+dummy_consume_data (j_decompress_ptr cinfo)
+{
+  return JPEG_SUSPENDED;	/* Always indicate nothing was done */
+}
+
+
+#ifdef D_MULTISCAN_FILES_SUPPORTED
+
+/*
+ * Consume input data and store it in the full-image coefficient buffer.
+ * We read as much as one fully interleaved MCU row ("iMCU" row) per call,
+ * ie, v_samp_factor block rows for each component in the scan.
+ * Return value is JPEG_ROW_COMPLETED, JPEG_SCAN_COMPLETED, or JPEG_SUSPENDED.
+ */
+
+METHODDEF int
+consume_data (j_decompress_ptr cinfo)
+{
+  my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
+  JDIMENSION MCU_col_num;	/* index of current MCU within row */
+  int blkn, ci, xindex, yindex, yoffset;
+  JDIMENSION start_col;
+  JBLOCKARRAY buffer[MAX_COMPS_IN_SCAN];
+  JBLOCKROW buffer_ptr;
+  jpeg_component_info *compptr;
+
+  /* Align the virtual buffers for the components used in this scan. */
+  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+    compptr = cinfo->cur_comp_info[ci];
+    buffer[ci] = (*cinfo->mem->access_virt_barray)
+      ((j_common_ptr) cinfo, coef->whole_image[compptr->component_index],
+       cinfo->input_iMCU_row * compptr->v_samp_factor,
+       (JDIMENSION) compptr->v_samp_factor, TRUE);
+    /* Note: entropy decoder expects buffer to be zeroed,
+     * but this is handled automatically by the memory manager
+     * because we requested a pre-zeroed array.
+     */
+  }
+
+  /* Loop to process one whole iMCU row */
+  for (yoffset = coef->MCU_vert_offset; yoffset < coef->MCU_rows_per_iMCU_row;
+       yoffset++) {
+    for (MCU_col_num = coef->MCU_ctr; MCU_col_num < cinfo->MCUs_per_row;
+	 MCU_col_num++) {
+      /* Construct list of pointers to DCT blocks belonging to this MCU */
+      blkn = 0;			/* index of current DCT block within MCU */
+      for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+	compptr = cinfo->cur_comp_info[ci];
+	start_col = MCU_col_num * compptr->MCU_width;
+	for (yindex = 0; yindex < compptr->MCU_height; yindex++) {
+	  buffer_ptr = buffer[ci][yindex+yoffset] + start_col;
+	  for (xindex = 0; xindex < compptr->MCU_width; xindex++) {
+	    coef->MCU_buffer[blkn++] = buffer_ptr++;
+	  }
+	}
+      }
+      /* Try to fetch the MCU. */
+      if (! (*cinfo->entropy->decode_mcu) (cinfo, coef->MCU_buffer)) {
+	/* Suspension forced; update state counters and exit */
+	coef->MCU_vert_offset = yoffset;
+	coef->MCU_ctr = MCU_col_num;
+	return JPEG_SUSPENDED;
+      }
+    }
+    /* Completed an MCU row, but perhaps not an iMCU row */
+    coef->MCU_ctr = 0;
+  }
+  /* Completed the iMCU row, advance counters for next one */
+  if (++(cinfo->input_iMCU_row) < cinfo->total_iMCU_rows) {
+    start_iMCU_row(cinfo);
+    return JPEG_ROW_COMPLETED;
+  }
+  /* Completed the scan */
+  (*cinfo->inputctl->finish_input_pass) (cinfo);
+  return JPEG_SCAN_COMPLETED;
+}
+
+
+/*
+ * Decompress and return some data in the multi-pass case.
+ * Always attempts to emit one fully interleaved MCU row ("iMCU" row).
+ * Return value is JPEG_ROW_COMPLETED, JPEG_SCAN_COMPLETED, or JPEG_SUSPENDED.
+ *
+ * NB: output_buf contains a plane for each component in image.
+ */
+
+METHODDEF int
+decompress_data (j_decompress_ptr cinfo, JSAMPIMAGE output_buf)
+{
+  my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
+  JDIMENSION last_iMCU_row = cinfo->total_iMCU_rows - 1;
+  JDIMENSION block_num;
+  int ci, block_row, block_rows;
+  JBLOCKARRAY buffer;
+  JBLOCKROW buffer_ptr;
+  JSAMPARRAY output_ptr;
+  JDIMENSION output_col;
+  jpeg_component_info *compptr;
+  inverse_DCT_method_ptr inverse_DCT;
+
+  /* Force some input to be done if we are getting ahead of the input. */
+  while (cinfo->input_scan_number < cinfo->output_scan_number ||
+	 (cinfo->input_scan_number == cinfo->output_scan_number &&
+	  cinfo->input_iMCU_row <= cinfo->output_iMCU_row)) {
+    if ((*cinfo->inputctl->consume_input)(cinfo) == JPEG_SUSPENDED)
+      return JPEG_SUSPENDED;
+  }
+
+  /* OK, output from the virtual arrays. */
+  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+       ci++, compptr++) {
+    /* Don't bother to IDCT an uninteresting component. */
+    if (! compptr->component_needed)
+      continue;
+    /* Align the virtual buffer for this component. */
+    buffer = (*cinfo->mem->access_virt_barray)
+      ((j_common_ptr) cinfo, coef->whole_image[ci],
+       cinfo->output_iMCU_row * compptr->v_samp_factor,
+       (JDIMENSION) compptr->v_samp_factor, FALSE);
+    /* Count non-dummy DCT block rows in this iMCU row. */
+    if (cinfo->output_iMCU_row < last_iMCU_row)
+      block_rows = compptr->v_samp_factor;
+    else {
+      /* NB: can't use last_row_height here; it is input-side-dependent! */
+      block_rows = (int) (compptr->height_in_blocks % compptr->v_samp_factor);
+      if (block_rows == 0) block_rows = compptr->v_samp_factor;
+    }
+    inverse_DCT = cinfo->idct->inverse_DCT[ci];
+    output_ptr = output_buf[ci];
+    /* Loop over all DCT blocks to be processed. */
+    for (block_row = 0; block_row < block_rows; block_row++) {
+      buffer_ptr = buffer[block_row];
+      output_col = 0;
+      for (block_num = 0; block_num < compptr->width_in_blocks; block_num++) {
+	(*inverse_DCT) (cinfo, compptr, (JCOEFPTR) buffer_ptr,
+			output_ptr, output_col);
+	buffer_ptr++;
+	output_col += compptr->DCT_scaled_size;
+      }
+      output_ptr += compptr->DCT_scaled_size;
+    }
+  }
+
+  if (++(cinfo->output_iMCU_row) < cinfo->total_iMCU_rows)
+    return JPEG_ROW_COMPLETED;
+  return JPEG_SCAN_COMPLETED;
+}
+
+#endif /* D_MULTISCAN_FILES_SUPPORTED */
+
+
+#ifdef BLOCK_SMOOTHING_SUPPORTED
+
+/*
+ * This code applies interblock smoothing as described by section K.8
+ * of the JPEG standard: the first 5 AC coefficients are estimated from
+ * the DC values of a DCT block and its 8 neighboring blocks.
+ * We apply smoothing only for progressive JPEG decoding, and only if
+ * the coefficients it can estimate are not yet known to full precision.
+ */
+
+/*
+ * Determine whether block smoothing is applicable and safe.
+ * We also latch the current states of the coef_bits[] entries for the
+ * AC coefficients; otherwise, if the input side of the decompressor
+ * advances into a new scan, we might think the coefficients are known
+ * more accurately than they really are.
+ */
+
+LOCAL boolean
+smoothing_ok (j_decompress_ptr cinfo)
+{
+  my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
+  boolean smoothing_useful = FALSE;
+  int ci, coefi;
+  jpeg_component_info *compptr;
+  JQUANT_TBL * qtable;
+  int * coef_bits;
+  int * coef_bits_latch;
+
+  if (! cinfo->progressive_mode || cinfo->coef_bits == NULL)
+    return FALSE;
+
+  /* Allocate latch area if not already done */
+  if (coef->coef_bits_latch == NULL)
+    coef->coef_bits_latch = (int *)
+      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				  cinfo->num_components *
+				  (SAVED_COEFS * SIZEOF(int)));
+  coef_bits_latch = coef->coef_bits_latch;
+
+  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+       ci++, compptr++) {
+    /* All components' quantization values must already be latched. */
+    if ((qtable = compptr->quant_table) == NULL)
+      return FALSE;
+    /* Verify DC & first 5 AC quantizers are nonzero to avoid zero-divide. */
+    for (coefi = 0; coefi <= 5; coefi++) {
+      if (qtable->quantval[coefi] == 0)
+	return FALSE;
+    }
+    /* DC values must be at least partly known for all components. */
+    coef_bits = cinfo->coef_bits[ci];
+    if (coef_bits[0] < 0)
+      return FALSE;
+    /* Block smoothing is helpful if some AC coefficients remain inaccurate. */
+    for (coefi = 1; coefi <= 5; coefi++) {
+      coef_bits_latch[coefi] = coef_bits[coefi];
+      if (coef_bits[coefi] != 0)
+	smoothing_useful = TRUE;
+    }
+    coef_bits_latch += SAVED_COEFS;
+  }
+
+  return smoothing_useful;
+}
+
+
+/*
+ * Variant of decompress_data for use when doing block smoothing.
+ */
+
+METHODDEF int
+decompress_smooth_data (j_decompress_ptr cinfo, JSAMPIMAGE output_buf)
+{
+  my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
+  JDIMENSION last_iMCU_row = cinfo->total_iMCU_rows - 1;
+  JDIMENSION block_num, last_block_column;
+  int ci, block_row, block_rows, access_rows;
+  JBLOCKARRAY buffer;
+  JBLOCKROW buffer_ptr, prev_block_row, next_block_row;
+  JSAMPARRAY output_ptr;
+  JDIMENSION output_col;
+  jpeg_component_info *compptr;
+  inverse_DCT_method_ptr inverse_DCT;
+  boolean first_row, last_row;
+  JBLOCK workspace;
+  int *coef_bits;
+  JQUANT_TBL *quanttbl;
+  INT32 Q00,Q01,Q02,Q10,Q11,Q20, num;
+  int DC1,DC2,DC3,DC4,DC5,DC6,DC7,DC8,DC9;
+  int Al, pred;
+
+  /* Force some input to be done if we are getting ahead of the input. */
+  while (cinfo->input_scan_number <= cinfo->output_scan_number &&
+	 ! cinfo->inputctl->eoi_reached) {
+    if (cinfo->input_scan_number == cinfo->output_scan_number) {
+      /* If input is working on current scan, we ordinarily want it to
+       * have completed the current row.  But if input scan is DC,
+       * we want it to keep one row ahead so that next block row's DC
+       * values are up to date.
+       */
+      JDIMENSION delta = (cinfo->Ss == 0) ? 1 : 0;
+      if (cinfo->input_iMCU_row > cinfo->output_iMCU_row+delta)
+	break;
+    }
+    if ((*cinfo->inputctl->consume_input)(cinfo) == JPEG_SUSPENDED)
+      return JPEG_SUSPENDED;
+  }
+
+  /* OK, output from the virtual arrays. */
+  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+       ci++, compptr++) {
+    /* Don't bother to IDCT an uninteresting component. */
+    if (! compptr->component_needed)
+      continue;
+    /* Count non-dummy DCT block rows in this iMCU row. */
+    if (cinfo->output_iMCU_row < last_iMCU_row) {
+      block_rows = compptr->v_samp_factor;
+      access_rows = block_rows * 2; /* this and next iMCU row */
+      last_row = FALSE;
+    } else {
+      /* NB: can't use last_row_height here; it is input-side-dependent! */
+      block_rows = (int) (compptr->height_in_blocks % compptr->v_samp_factor);
+      if (block_rows == 0) block_rows = compptr->v_samp_factor;
+      access_rows = block_rows; /* this iMCU row only */
+      last_row = TRUE;
+    }
+    /* Align the virtual buffer for this component. */
+    if (cinfo->output_iMCU_row > 0) {
+      access_rows += compptr->v_samp_factor; /* prior iMCU row too */
+      buffer = (*cinfo->mem->access_virt_barray)
+	((j_common_ptr) cinfo, coef->whole_image[ci],
+	 (cinfo->output_iMCU_row - 1) * compptr->v_samp_factor,
+	 (JDIMENSION) access_rows, FALSE);
+      buffer += compptr->v_samp_factor;	/* point to current iMCU row */
+      first_row = FALSE;
+    } else {
+      buffer = (*cinfo->mem->access_virt_barray)
+	((j_common_ptr) cinfo, coef->whole_image[ci],
+	 (JDIMENSION) 0, (JDIMENSION) access_rows, FALSE);
+      first_row = TRUE;
+    }
+    /* Fetch component-dependent info */
+    coef_bits = coef->coef_bits_latch + (ci * SAVED_COEFS);
+    quanttbl = compptr->quant_table;
+    Q00 = quanttbl->quantval[0];
+    Q01 = quanttbl->quantval[1];
+    Q10 = quanttbl->quantval[2];
+    Q20 = quanttbl->quantval[3];
+    Q11 = quanttbl->quantval[4];
+    Q02 = quanttbl->quantval[5];
+    inverse_DCT = cinfo->idct->inverse_DCT[ci];
+    output_ptr = output_buf[ci];
+    /* Loop over all DCT blocks to be processed. */
+    for (block_row = 0; block_row < block_rows; block_row++) {
+      buffer_ptr = buffer[block_row];
+      if (first_row && block_row == 0)
+	prev_block_row = buffer_ptr;
+      else
+	prev_block_row = buffer[block_row-1];
+      if (last_row && block_row == block_rows-1)
+	next_block_row = buffer_ptr;
+      else
+	next_block_row = buffer[block_row+1];
+      /* We fetch the surrounding DC values using a sliding-register approach.
+       * Initialize all nine here so as to do the right thing on narrow pics.
+       */
+      DC1 = DC2 = DC3 = (int) prev_block_row[0][0];
+      DC4 = DC5 = DC6 = (int) buffer_ptr[0][0];
+      DC7 = DC8 = DC9 = (int) next_block_row[0][0];
+      output_col = 0;
+      last_block_column = compptr->width_in_blocks - 1;
+      for (block_num = 0; block_num <= last_block_column; block_num++) {
+	/* Fetch current DCT block into workspace so we can modify it. */
+	jcopy_block_row(buffer_ptr, (JBLOCKROW) workspace, (JDIMENSION) 1);
+	/* Update DC values */
+	if (block_num < last_block_column) {
+	  DC3 = (int) prev_block_row[1][0];
+	  DC6 = (int) buffer_ptr[1][0];
+	  DC9 = (int) next_block_row[1][0];
+	}
+	/* Compute coefficient estimates per K.8.
+	 * An estimate is applied only if coefficient is still zero,
+	 * and is not known to be fully accurate.
+	 */
+	/* AC01 */
+	if ((Al=coef_bits[1]) != 0 && workspace[1] == 0) {
+	  num = 36 * Q00 * (DC4 - DC6);
+	  if (num >= 0) {
+	    pred = (int) (((Q01<<7) + num) / (Q01<<8));
+	    if (Al > 0 && pred >= (1<<Al))
+	      pred = (1<<Al)-1;
+	  } else {
+	    pred = (int) (((Q01<<7) - num) / (Q01<<8));
+	    if (Al > 0 && pred >= (1<<Al))
+	      pred = (1<<Al)-1;
+	    pred = -pred;
+	  }
+	  workspace[1] = (JCOEF) pred;
+	}
+	/* AC10 */
+	if ((Al=coef_bits[2]) != 0 && workspace[8] == 0) {
+	  num = 36 * Q00 * (DC2 - DC8);
+	  if (num >= 0) {
+	    pred = (int) (((Q10<<7) + num) / (Q10<<8));
+	    if (Al > 0 && pred >= (1<<Al))
+	      pred = (1<<Al)-1;
+	  } else {
+	    pred = (int) (((Q10<<7) - num) / (Q10<<8));
+	    if (Al > 0 && pred >= (1<<Al))
+	      pred = (1<<Al)-1;
+	    pred = -pred;
+	  }
+	  workspace[8] = (JCOEF) pred;
+	}
+	/* AC20 */
+	if ((Al=coef_bits[3]) != 0 && workspace[16] == 0) {
+	  num = 9 * Q00 * (DC2 + DC8 - 2*DC5);
+	  if (num >= 0) {
+	    pred = (int) (((Q20<<7) + num) / (Q20<<8));
+	    if (Al > 0 && pred >= (1<<Al))
+	      pred = (1<<Al)-1;
+	  } else {
+	    pred = (int) (((Q20<<7) - num) / (Q20<<8));
+	    if (Al > 0 && pred >= (1<<Al))
+	      pred = (1<<Al)-1;
+	    pred = -pred;
+	  }
+	  workspace[16] = (JCOEF) pred;
+	}
+	/* AC11 */
+	if ((Al=coef_bits[4]) != 0 && workspace[9] == 0) {
+	  num = 5 * Q00 * (DC1 - DC3 - DC7 + DC9);
+	  if (num >= 0) {
+	    pred = (int) (((Q11<<7) + num) / (Q11<<8));
+	    if (Al > 0 && pred >= (1<<Al))
+	      pred = (1<<Al)-1;
+	  } else {
+	    pred = (int) (((Q11<<7) - num) / (Q11<<8));
+	    if (Al > 0 && pred >= (1<<Al))
+	      pred = (1<<Al)-1;
+	    pred = -pred;
+	  }
+	  workspace[9] = (JCOEF) pred;
+	}
+	/* AC02 */
+	if ((Al=coef_bits[5]) != 0 && workspace[2] == 0) {
+	  num = 9 * Q00 * (DC4 + DC6 - 2*DC5);
+	  if (num >= 0) {
+	    pred = (int) (((Q02<<7) + num) / (Q02<<8));
+	    if (Al > 0 && pred >= (1<<Al))
+	      pred = (1<<Al)-1;
+	  } else {
+	    pred = (int) (((Q02<<7) - num) / (Q02<<8));
+	    if (Al > 0 && pred >= (1<<Al))
+	      pred = (1<<Al)-1;
+	    pred = -pred;
+	  }
+	  workspace[2] = (JCOEF) pred;
+	}
+	/* OK, do the IDCT */
+	(*inverse_DCT) (cinfo, compptr, (JCOEFPTR) workspace,
+			output_ptr, output_col);
+	/* Advance for next column */
+	DC1 = DC2; DC2 = DC3;
+	DC4 = DC5; DC5 = DC6;
+	DC7 = DC8; DC8 = DC9;
+	buffer_ptr++, prev_block_row++, next_block_row++;
+	output_col += compptr->DCT_scaled_size;
+      }
+      output_ptr += compptr->DCT_scaled_size;
+    }
+  }
+
+  if (++(cinfo->output_iMCU_row) < cinfo->total_iMCU_rows)
+    return JPEG_ROW_COMPLETED;
+  return JPEG_SCAN_COMPLETED;
+}
+
+#endif /* BLOCK_SMOOTHING_SUPPORTED */
+
+
+/*
+ * Initialize coefficient buffer controller.
+ */
+
+GLOBAL void
+jinit_d_coef_controller (j_decompress_ptr cinfo, boolean need_full_buffer)
+{
+  my_coef_ptr coef;
+
+  coef = (my_coef_ptr)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				SIZEOF(my_coef_controller));
+  cinfo->coef = (struct jpeg_d_coef_controller *) coef;
+  coef->pub.start_input_pass = start_input_pass;
+  coef->pub.start_output_pass = start_output_pass;
+#ifdef BLOCK_SMOOTHING_SUPPORTED
+  coef->coef_bits_latch = NULL;
+#endif
+
+  /* Create the coefficient buffer. */
+  if (need_full_buffer) {
+#ifdef D_MULTISCAN_FILES_SUPPORTED
+    /* Allocate a full-image virtual array for each component, */
+    /* padded to a multiple of samp_factor DCT blocks in each direction. */
+    /* Note we ask for a pre-zeroed array. */
+    int ci, access_rows;
+    jpeg_component_info *compptr;
+
+    for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+	 ci++, compptr++) {
+      access_rows = compptr->v_samp_factor;
+#ifdef BLOCK_SMOOTHING_SUPPORTED
+      /* If block smoothing could be used, need a bigger window */
+      if (cinfo->progressive_mode)
+	access_rows *= 3;
+#endif
+      coef->whole_image[ci] = (*cinfo->mem->request_virt_barray)
+	((j_common_ptr) cinfo, JPOOL_IMAGE, TRUE,
+	 (JDIMENSION) jround_up((long) compptr->width_in_blocks,
+				(long) compptr->h_samp_factor),
+	 (JDIMENSION) jround_up((long) compptr->height_in_blocks,
+				(long) compptr->v_samp_factor),
+	 (JDIMENSION) access_rows);
+    }
+    coef->pub.consume_data = consume_data;
+    coef->pub.decompress_data = decompress_data;
+    coef->pub.coef_arrays = coef->whole_image; /* link to virtual arrays */
+#else
+    ERREXIT(cinfo, JERR_NOT_COMPILED);
+#endif
+  } else {
+    /* We only need a single-MCU buffer. */
+    JBLOCKROW buffer;
+    int i;
+
+    buffer = (JBLOCKROW)
+      (*cinfo->mem->alloc_large) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				  D_MAX_BLOCKS_IN_MCU * SIZEOF(JBLOCK));
+    for (i = 0; i < D_MAX_BLOCKS_IN_MCU; i++) {
+      coef->MCU_buffer[i] = buffer + i;
+    }
+    coef->pub.consume_data = dummy_consume_data;
+    coef->pub.decompress_data = decompress_onepass;
+    coef->pub.coef_arrays = NULL; /* flag for no virtual arrays */
+  }
+}
diff --git a/code/jpeg-6/jdcolor.cpp b/code/jpeg-6/jdcolor.cpp
new file mode 100644
index 0000000..eca1395
--- /dev/null
+++ b/code/jpeg-6/jdcolor.cpp
@@ -0,0 +1,373 @@
+/*
+ * jdcolor.c
+ *
+ * Copyright (C) 1991-1995, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains output colorspace conversion routines.
+ */
+
+
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/* Private subobject */
+
+typedef struct {
+  struct jpeg_color_deconverter pub; /* public fields */
+
+  /* Private state for YCC->RGB conversion */
+  int * Cr_r_tab;		/* => table for Cr to R conversion */
+  int * Cb_b_tab;		/* => table for Cb to B conversion */
+  INT32 * Cr_g_tab;		/* => table for Cr to G conversion */
+  INT32 * Cb_g_tab;		/* => table for Cb to G conversion */
+} my_color_deconverter;
+
+typedef my_color_deconverter * my_cconvert_ptr;
+
+
+/**************** YCbCr -> RGB conversion: most common case **************/
+
+/*
+ * YCbCr is defined per CCIR 601-1, except that Cb and Cr are
+ * normalized to the range 0..MAXJSAMPLE rather than -0.5 .. 0.5.
+ * The conversion equations to be implemented are therefore
+ *	R = Y                + 1.40200 * Cr
+ *	G = Y - 0.34414 * Cb - 0.71414 * Cr
+ *	B = Y + 1.77200 * Cb
+ * where Cb and Cr represent the incoming values less CENTERJSAMPLE.
+ * (These numbers are derived from TIFF 6.0 section 21, dated 3-June-92.)
+ *
+ * To avoid floating-point arithmetic, we represent the fractional constants
+ * as integers scaled up by 2^16 (about 4 digits precision); we have to divide
+ * the products by 2^16, with appropriate rounding, to get the correct answer.
+ * Notice that Y, being an integral input, does not contribute any fraction
+ * so it need not participate in the rounding.
+ *
+ * For even more speed, we avoid doing any multiplications in the inner loop
+ * by precalculating the constants times Cb and Cr for all possible values.
+ * For 8-bit JSAMPLEs this is very reasonable (only 256 entries per table);
+ * for 12-bit samples it is still acceptable.  It's not very reasonable for
+ * 16-bit samples, but if you want lossless storage you shouldn't be changing
+ * colorspace anyway.
+ * The Cr=>R and Cb=>B values can be rounded to integers in advance; the
+ * values for the G calculation are left scaled up, since we must add them
+ * together before rounding.
+ */
+
+#define SCALEBITS	16	/* speediest right-shift on some machines */
+#define ONE_HALF	((INT32) 1 << (SCALEBITS-1))
+#define FIX(x)		((INT32) ((x) * (1L<<SCALEBITS) + 0.5))
+
+
+/*
+ * Initialize tables for YCC->RGB colorspace conversion.
+ */
+
+LOCAL void
+build_ycc_rgb_table (j_decompress_ptr cinfo)
+{
+  my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
+  int i;
+  INT32 x;
+  SHIFT_TEMPS
+
+  cconvert->Cr_r_tab = (int *)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				(MAXJSAMPLE+1) * SIZEOF(int));
+  cconvert->Cb_b_tab = (int *)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				(MAXJSAMPLE+1) * SIZEOF(int));
+  cconvert->Cr_g_tab = (INT32 *)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				(MAXJSAMPLE+1) * SIZEOF(INT32));
+  cconvert->Cb_g_tab = (INT32 *)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				(MAXJSAMPLE+1) * SIZEOF(INT32));
+
+  for (i = 0, x = -CENTERJSAMPLE; i <= MAXJSAMPLE; i++, x++) {
+    /* i is the actual input pixel value, in the range 0..MAXJSAMPLE */
+    /* The Cb or Cr value we are thinking of is x = i - CENTERJSAMPLE */
+    /* Cr=>R value is nearest int to 1.40200 * x */
+    cconvert->Cr_r_tab[i] = (int)
+		    RIGHT_SHIFT(FIX(1.40200) * x + ONE_HALF, SCALEBITS);
+    /* Cb=>B value is nearest int to 1.77200 * x */
+    cconvert->Cb_b_tab[i] = (int)
+		    RIGHT_SHIFT(FIX(1.77200) * x + ONE_HALF, SCALEBITS);
+    /* Cr=>G value is scaled-up -0.71414 * x */
+    cconvert->Cr_g_tab[i] = (- FIX(0.71414)) * x;
+    /* Cb=>G value is scaled-up -0.34414 * x */
+    /* We also add in ONE_HALF so that need not do it in inner loop */
+    cconvert->Cb_g_tab[i] = (- FIX(0.34414)) * x + ONE_HALF;
+  }
+}
+
+
+/*
+ * Convert some rows of samples to the output colorspace.
+ *
+ * Note that we change from noninterleaved, one-plane-per-component format
+ * to interleaved-pixel format.  The output buffer is therefore three times
+ * as wide as the input buffer.
+ * A starting row offset is provided only for the input buffer.  The caller
+ * can easily adjust the passed output_buf value to accommodate any row
+ * offset required on that side.
+ */
+
+METHODDEF void
+ycc_rgb_convert (j_decompress_ptr cinfo,
+		 JSAMPIMAGE input_buf, JDIMENSION input_row,
+		 JSAMPARRAY output_buf, int num_rows)
+{
+  my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
+  register int y, cb, cr;
+  register JSAMPROW outptr;
+  register JSAMPROW inptr0, inptr1, inptr2;
+  register JDIMENSION col;
+  JDIMENSION num_cols = cinfo->output_width;
+  /* copy these pointers into registers if possible */
+  register JSAMPLE * range_limit = cinfo->sample_range_limit;
+  register int * Crrtab = cconvert->Cr_r_tab;
+  register int * Cbbtab = cconvert->Cb_b_tab;
+  register INT32 * Crgtab = cconvert->Cr_g_tab;
+  register INT32 * Cbgtab = cconvert->Cb_g_tab;
+  SHIFT_TEMPS
+
+  while (--num_rows >= 0) {
+    inptr0 = input_buf[0][input_row];
+    inptr1 = input_buf[1][input_row];
+    inptr2 = input_buf[2][input_row];
+    input_row++;
+    outptr = *output_buf++;
+    for (col = 0; col < num_cols; col++) {
+      y  = GETJSAMPLE(inptr0[col]);
+      cb = GETJSAMPLE(inptr1[col]);
+      cr = GETJSAMPLE(inptr2[col]);
+      /* Range-limiting is essential due to noise introduced by DCT losses. */
+      outptr[RGB_RED] =   range_limit[y + Crrtab[cr]];
+      outptr[RGB_GREEN] = range_limit[y +
+			      ((int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],
+						 SCALEBITS))];
+      outptr[RGB_BLUE] =  range_limit[y + Cbbtab[cb]];
+      outptr += RGB_PIXELSIZE;
+    }
+  }
+}
+
+
+/**************** Cases other than YCbCr -> RGB **************/
+
+
+/*
+ * Color conversion for no colorspace change: just copy the data,
+ * converting from separate-planes to interleaved representation.
+ */
+
+METHODDEF void
+null_convert (j_decompress_ptr cinfo,
+	      JSAMPIMAGE input_buf, JDIMENSION input_row,
+	      JSAMPARRAY output_buf, int num_rows)
+{
+  register JSAMPROW inptr, outptr;
+  register JDIMENSION count;
+  register int num_components = cinfo->num_components;
+  JDIMENSION num_cols = cinfo->output_width;
+  int ci;
+
+  while (--num_rows >= 0) {
+    for (ci = 0; ci < num_components; ci++) {
+      inptr = input_buf[ci][input_row];
+      outptr = output_buf[0] + ci;
+      for (count = num_cols; count > 0; count--) {
+	*outptr = *inptr++;	/* needn't bother with GETJSAMPLE() here */
+	outptr += num_components;
+      }
+    }
+    input_row++;
+    output_buf++;
+  }
+}
+
+
+/*
+ * Color conversion for grayscale: just copy the data.
+ * This also works for YCbCr -> grayscale conversion, in which
+ * we just copy the Y (luminance) component and ignore chrominance.
+ */
+
+METHODDEF void
+grayscale_convert (j_decompress_ptr cinfo,
+		   JSAMPIMAGE input_buf, JDIMENSION input_row,
+		   JSAMPARRAY output_buf, int num_rows)
+{
+  jcopy_sample_rows(input_buf[0], (int) input_row, output_buf, 0,
+		    num_rows, cinfo->output_width);
+}
+
+
+/*
+ * Adobe-style YCCK->CMYK conversion.
+ * We convert YCbCr to R=1-C, G=1-M, and B=1-Y using the same
+ * conversion as above, while passing K (black) unchanged.
+ * We assume build_ycc_rgb_table has been called.
+ */
+
+METHODDEF void
+ycck_cmyk_convert (j_decompress_ptr cinfo,
+		   JSAMPIMAGE input_buf, JDIMENSION input_row,
+		   JSAMPARRAY output_buf, int num_rows)
+{
+  my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
+  register int y, cb, cr;
+  register JSAMPROW outptr;
+  register JSAMPROW inptr0, inptr1, inptr2, inptr3;
+  register JDIMENSION col;
+  JDIMENSION num_cols = cinfo->output_width;
+  /* copy these pointers into registers if possible */
+  register JSAMPLE * range_limit = cinfo->sample_range_limit;
+  register int * Crrtab = cconvert->Cr_r_tab;
+  register int * Cbbtab = cconvert->Cb_b_tab;
+  register INT32 * Crgtab = cconvert->Cr_g_tab;
+  register INT32 * Cbgtab = cconvert->Cb_g_tab;
+  SHIFT_TEMPS
+
+  while (--num_rows >= 0) {
+    inptr0 = input_buf[0][input_row];
+    inptr1 = input_buf[1][input_row];
+    inptr2 = input_buf[2][input_row];
+    inptr3 = input_buf[3][input_row];
+    input_row++;
+    outptr = *output_buf++;
+    for (col = 0; col < num_cols; col++) {
+      y  = GETJSAMPLE(inptr0[col]);
+      cb = GETJSAMPLE(inptr1[col]);
+      cr = GETJSAMPLE(inptr2[col]);
+      /* Range-limiting is essential due to noise introduced by DCT losses. */
+      outptr[0] = range_limit[MAXJSAMPLE - (y + Crrtab[cr])];	/* red */
+      outptr[1] = range_limit[MAXJSAMPLE - (y +			/* green */
+			      ((int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],
+						 SCALEBITS)))];
+      outptr[2] = range_limit[MAXJSAMPLE - (y + Cbbtab[cb])];	/* blue */
+      /* K passes through unchanged */
+      outptr[3] = inptr3[col];	/* don't need GETJSAMPLE here */
+      outptr += 4;
+    }
+  }
+}
+
+
+/*
+ * Empty method for start_pass.
+ */
+
+METHODDEF void
+start_pass_dcolor (j_decompress_ptr cinfo)
+{
+  /* no work needed */
+}
+
+
+/*
+ * Module initialization routine for output colorspace conversion.
+ */
+
+GLOBAL void
+jinit_color_deconverter (j_decompress_ptr cinfo)
+{
+  my_cconvert_ptr cconvert;
+  int ci;
+
+  cconvert = (my_cconvert_ptr)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				SIZEOF(my_color_deconverter));
+  cinfo->cconvert = (struct jpeg_color_deconverter *) cconvert;
+  cconvert->pub.start_pass = start_pass_dcolor;
+
+  /* Make sure num_components agrees with jpeg_color_space */
+  switch (cinfo->jpeg_color_space) {
+  case JCS_GRAYSCALE:
+    if (cinfo->num_components != 1)
+      ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
+    break;
+
+  case JCS_RGB:
+  case JCS_YCbCr:
+    if (cinfo->num_components != 3)
+      ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
+    break;
+
+  case JCS_CMYK:
+  case JCS_YCCK:
+    if (cinfo->num_components != 4)
+      ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
+    break;
+
+  default:			/* JCS_UNKNOWN can be anything */
+    if (cinfo->num_components < 1)
+      ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
+    break;
+  }
+
+  /* Set out_color_components and conversion method based on requested space.
+   * Also clear the component_needed flags for any unused components,
+   * so that earlier pipeline stages can avoid useless computation.
+   */
+
+  switch (cinfo->out_color_space) {
+  case JCS_GRAYSCALE:
+    cinfo->out_color_components = 1;
+    if (cinfo->jpeg_color_space == JCS_GRAYSCALE ||
+	cinfo->jpeg_color_space == JCS_YCbCr) {
+      cconvert->pub.color_convert = grayscale_convert;
+      /* For color->grayscale conversion, only the Y (0) component is needed */
+      for (ci = 1; ci < cinfo->num_components; ci++)
+	cinfo->comp_info[ci].component_needed = FALSE;
+    } else
+      ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
+    break;
+
+  case JCS_RGB:
+    cinfo->out_color_components = RGB_PIXELSIZE;
+    if (cinfo->jpeg_color_space == JCS_YCbCr) {
+      cconvert->pub.color_convert = ycc_rgb_convert;
+      build_ycc_rgb_table(cinfo);
+    } else if (cinfo->jpeg_color_space == JCS_RGB && RGB_PIXELSIZE == 3) {
+      cconvert->pub.color_convert = null_convert;
+    } else
+      ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
+    break;
+
+  case JCS_CMYK:
+    cinfo->out_color_components = 4;
+    if (cinfo->jpeg_color_space == JCS_YCCK) {
+      cconvert->pub.color_convert = ycck_cmyk_convert;
+      build_ycc_rgb_table(cinfo);
+    } else if (cinfo->jpeg_color_space == JCS_CMYK) {
+      cconvert->pub.color_convert = null_convert;
+    } else
+      ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
+    break;
+
+  default:
+    /* Permit null conversion to same output space */
+    if (cinfo->out_color_space == cinfo->jpeg_color_space) {
+      cinfo->out_color_components = cinfo->num_components;
+      cconvert->pub.color_convert = null_convert;
+    } else			/* unsupported non-null conversion */
+      ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
+    break;
+  }
+
+  if (cinfo->quantize_colors)
+    cinfo->output_components = 1; /* single colormapped output component */
+  else
+    cinfo->output_components = cinfo->out_color_components;
+}
diff --git a/code/jpeg-6/jdct.h b/code/jpeg-6/jdct.h
new file mode 100644
index 0000000..1d66d4f
--- /dev/null
+++ b/code/jpeg-6/jdct.h
@@ -0,0 +1,176 @@
+/*
+ * jdct.h
+ *
+ * Copyright (C) 1994, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This include file contains common declarations for the forward and
+ * inverse DCT modules.  These declarations are private to the DCT managers
+ * (jcdctmgr.c, jddctmgr.c) and the individual DCT algorithms.
+ * The individual DCT algorithms are kept in separate files to ease 
+ * machine-dependent tuning (e.g., assembly coding).
+ */
+
+
+/*
+ * A forward DCT routine is given a pointer to a work area of type DCTELEM[];
+ * the DCT is to be performed in-place in that buffer.  Type DCTELEM is int
+ * for 8-bit samples, INT32 for 12-bit samples.  (NOTE: Floating-point DCT
+ * implementations use an array of type FAST_FLOAT, instead.)
+ * The DCT inputs are expected to be signed (range +-CENTERJSAMPLE).
+ * The DCT outputs are returned scaled up by a factor of 8; they therefore
+ * have a range of +-8K for 8-bit data, +-128K for 12-bit data.  This
+ * convention improves accuracy in integer implementations and saves some
+ * work in floating-point ones.
+ * Quantization of the output coefficients is done by jcdctmgr.c.
+ */
+
+#if BITS_IN_JSAMPLE == 8
+typedef int DCTELEM;		/* 16 or 32 bits is fine */
+#else
+typedef INT32 DCTELEM;		/* must have 32 bits */
+#endif
+
+typedef JMETHOD(void, forward_DCT_method_ptr, (DCTELEM * data));
+typedef JMETHOD(void, float_DCT_method_ptr, (FAST_FLOAT * data));
+
+
+/*
+ * An inverse DCT routine is given a pointer to the input JBLOCK and a pointer
+ * to an output sample array.  The routine must dequantize the input data as
+ * well as perform the IDCT; for dequantization, it uses the multiplier table
+ * pointed to by compptr->dct_table.  The output data is to be placed into the
+ * sample array starting at a specified column.  (Any row offset needed will
+ * be applied to the array pointer before it is passed to the IDCT code.)
+ * Note that the number of samples emitted by the IDCT routine is
+ * DCT_scaled_size * DCT_scaled_size.
+ */
+
+/* typedef inverse_DCT_method_ptr is declared in jpegint.h */
+
+/*
+ * Each IDCT routine has its own ideas about the best dct_table element type.
+ */
+
+typedef MULTIPLIER ISLOW_MULT_TYPE; /* short or int, whichever is faster */
+#if BITS_IN_JSAMPLE == 8
+typedef MULTIPLIER IFAST_MULT_TYPE; /* 16 bits is OK, use short if faster */
+#define IFAST_SCALE_BITS  2	/* fractional bits in scale factors */
+#else
+typedef INT32 IFAST_MULT_TYPE;	/* need 32 bits for scaled quantizers */
+#define IFAST_SCALE_BITS  13	/* fractional bits in scale factors */
+#endif
+typedef FAST_FLOAT FLOAT_MULT_TYPE; /* preferred floating type */
+
+
+/*
+ * Each IDCT routine is responsible for range-limiting its results and
+ * converting them to unsigned form (0..MAXJSAMPLE).  The raw outputs could
+ * be quite far out of range if the input data is corrupt, so a bulletproof
+ * range-limiting step is required.  We use a mask-and-table-lookup method
+ * to do the combined operations quickly.  See the comments with
+ * prepare_range_limit_table (in jdmaster.c) for more info.
+ */
+
+#define IDCT_range_limit(cinfo)  ((cinfo)->sample_range_limit + CENTERJSAMPLE)
+
+#define RANGE_MASK  (MAXJSAMPLE * 4 + 3) /* 2 bits wider than legal samples */
+
+
+/* Short forms of external names for systems with brain-damaged linkers. */
+
+#ifdef NEED_SHORT_EXTERNAL_NAMES
+#define jpeg_fdct_islow		jFDislow
+#define jpeg_fdct_ifast		jFDifast
+#define jpeg_fdct_float		jFDfloat
+#define jpeg_idct_islow		jRDislow
+#define jpeg_idct_ifast		jRDifast
+#define jpeg_idct_float		jRDfloat
+#define jpeg_idct_4x4		jRD4x4
+#define jpeg_idct_2x2		jRD2x2
+#define jpeg_idct_1x1		jRD1x1
+#endif /* NEED_SHORT_EXTERNAL_NAMES */
+
+/* Extern declarations for the forward and inverse DCT routines. */
+
+EXTERN void jpeg_fdct_islow JPP((DCTELEM * data));
+EXTERN void jpeg_fdct_ifast JPP((DCTELEM * data));
+EXTERN void jpeg_fdct_float JPP((FAST_FLOAT * data));
+
+EXTERN void jpeg_idct_islow
+    JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr,
+	 JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col));
+EXTERN void jpeg_idct_ifast
+    JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr,
+	 JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col));
+EXTERN void jpeg_idct_float
+    JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr,
+	 JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col));
+EXTERN void jpeg_idct_4x4
+    JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr,
+	 JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col));
+EXTERN void jpeg_idct_2x2
+    JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr,
+	 JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col));
+EXTERN void jpeg_idct_1x1
+    JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr,
+	 JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col));
+
+
+/*
+ * Macros for handling fixed-point arithmetic; these are used by many
+ * but not all of the DCT/IDCT modules.
+ *
+ * All values are expected to be of type INT32.
+ * Fractional constants are scaled left by CONST_BITS bits.
+ * CONST_BITS is defined within each module using these macros,
+ * and may differ from one module to the next.
+ */
+
+#define ONE	((INT32) 1)
+#define CONST_SCALE (ONE << CONST_BITS)
+
+/* Convert a positive real constant to an integer scaled by CONST_SCALE.
+ * Caution: some C compilers fail to reduce "FIX(constant)" at compile time,
+ * thus causing a lot of useless floating-point operations at run time.
+ */
+
+#define FIX(x)	((INT32) ((x) * CONST_SCALE + 0.5))
+
+/* Descale and correctly round an INT32 value that's scaled by N bits.
+ * We assume RIGHT_SHIFT rounds towards minus infinity, so adding
+ * the fudge factor is correct for either sign of X.
+ */
+
+#define DESCALE(x,n)  RIGHT_SHIFT((x) + (ONE << ((n)-1)), n)
+
+/* Multiply an INT32 variable by an INT32 constant to yield an INT32 result.
+ * This macro is used only when the two inputs will actually be no more than
+ * 16 bits wide, so that a 16x16->32 bit multiply can be used instead of a
+ * full 32x32 multiply.  This provides a useful speedup on many machines.
+ * Unfortunately there is no way to specify a 16x16->32 multiply portably
+ * in C, but some C compilers will do the right thing if you provide the
+ * correct combination of casts.
+ */
+
+#ifdef SHORTxSHORT_32		/* may work if 'int' is 32 bits */
+#define MULTIPLY16C16(var,const)  (((INT16) (var)) * ((INT16) (const)))
+#endif
+#ifdef SHORTxLCONST_32		/* known to work with Microsoft C 6.0 */
+#define MULTIPLY16C16(var,const)  (((INT16) (var)) * ((INT32) (const)))
+#endif
+
+#ifndef MULTIPLY16C16		/* default definition */
+#define MULTIPLY16C16(var,const)  ((var) * (const))
+#endif
+
+/* Same except both inputs are variables. */
+
+#ifdef SHORTxSHORT_32		/* may work if 'int' is 32 bits */
+#define MULTIPLY16V16(var1,var2)  (((INT16) (var1)) * ((INT16) (var2)))
+#endif
+
+#ifndef MULTIPLY16V16		/* default definition */
+#define MULTIPLY16V16(var1,var2)  ((var1) * (var2))
+#endif
diff --git a/code/jpeg-6/jddctmgr.cpp b/code/jpeg-6/jddctmgr.cpp
new file mode 100644
index 0000000..303c80e
--- /dev/null
+++ b/code/jpeg-6/jddctmgr.cpp
@@ -0,0 +1,276 @@
+/*
+ * jddctmgr.c
+ *
+ * Copyright (C) 1994-1995, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains the inverse-DCT management logic.
+ * This code selects a particular IDCT implementation to be used,
+ * and it performs related housekeeping chores.  No code in this file
+ * is executed per IDCT step, only during output pass setup.
+ *
+ * Note that the IDCT routines are responsible for performing coefficient
+ * dequantization as well as the IDCT proper.  This module sets up the
+ * dequantization multiplier table needed by the IDCT routine.
+ */
+
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jdct.h"		/* Private declarations for DCT subsystem */
+
+
+/*
+ * The decompressor input side (jdinput.c) saves away the appropriate
+ * quantization table for each component at the start of the first scan
+ * involving that component.  (This is necessary in order to correctly
+ * decode files that reuse Q-table slots.)
+ * When we are ready to make an output pass, the saved Q-table is converted
+ * to a multiplier table that will actually be used by the IDCT routine.
+ * The multiplier table contents are IDCT-method-dependent.  To support
+ * application changes in IDCT method between scans, we can remake the
+ * multiplier tables if necessary.
+ * In buffered-image mode, the first output pass may occur before any data
+ * has been seen for some components, and thus before their Q-tables have
+ * been saved away.  To handle this case, multiplier tables are preset
+ * to zeroes; the result of the IDCT will be a neutral gray level.
+ */
+
+
+/* Private subobject for this module */
+
+typedef struct {
+  struct jpeg_inverse_dct pub;	/* public fields */
+
+  /* This array contains the IDCT method code that each multiplier table
+   * is currently set up for, or -1 if it's not yet set up.
+   * The actual multiplier tables are pointed to by dct_table in the
+   * per-component comp_info structures.
+   */
+  int cur_method[MAX_COMPONENTS];
+} my_idct_controller;
+
+typedef my_idct_controller * my_idct_ptr;
+
+
+/* Allocated multiplier tables: big enough for any supported variant */
+
+typedef union {
+  ISLOW_MULT_TYPE islow_array[DCTSIZE2];
+#ifdef DCT_IFAST_SUPPORTED
+  IFAST_MULT_TYPE ifast_array[DCTSIZE2];
+#endif
+#ifdef DCT_FLOAT_SUPPORTED
+  FLOAT_MULT_TYPE float_array[DCTSIZE2];
+#endif
+} multiplier_table;
+
+
+/* The current scaled-IDCT routines require ISLOW-style multiplier tables,
+ * so be sure to compile that code if either ISLOW or SCALING is requested.
+ */
+#ifdef DCT_ISLOW_SUPPORTED
+#define PROVIDE_ISLOW_TABLES
+#else
+#ifdef IDCT_SCALING_SUPPORTED
+#define PROVIDE_ISLOW_TABLES
+#endif
+#endif
+
+
+/*
+ * Prepare for an output pass.
+ * Here we select the proper IDCT routine for each component and build
+ * a matching multiplier table.
+ */
+
+METHODDEF void
+start_pass (j_decompress_ptr cinfo)
+{
+  my_idct_ptr idct = (my_idct_ptr) cinfo->idct;
+  int ci, i;
+  jpeg_component_info *compptr;
+  int method = 0;
+  inverse_DCT_method_ptr method_ptr = NULL;
+  JQUANT_TBL * qtbl;
+
+  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+       ci++, compptr++) {
+    /* Select the proper IDCT routine for this component's scaling */
+    switch (compptr->DCT_scaled_size) {
+#ifdef IDCT_SCALING_SUPPORTED
+    case 1:
+      method_ptr = jpeg_idct_1x1;
+      method = JDCT_ISLOW;	/* jidctred uses islow-style table */
+      break;
+    case 2:
+      method_ptr = jpeg_idct_2x2;
+      method = JDCT_ISLOW;	/* jidctred uses islow-style table */
+      break;
+    case 4:
+      method_ptr = jpeg_idct_4x4;
+      method = JDCT_ISLOW;	/* jidctred uses islow-style table */
+      break;
+#endif
+    case DCTSIZE:
+      switch (cinfo->dct_method) {
+#ifdef DCT_ISLOW_SUPPORTED
+      case JDCT_ISLOW:
+	method_ptr = jpeg_idct_islow;
+	method = JDCT_ISLOW;
+	break;
+#endif
+#ifdef DCT_IFAST_SUPPORTED
+      case JDCT_IFAST:
+	method_ptr = jpeg_idct_ifast;
+	method = JDCT_IFAST;
+	break;
+#endif
+#ifdef DCT_FLOAT_SUPPORTED
+      case JDCT_FLOAT:
+	method_ptr = jpeg_idct_float;
+	method = JDCT_FLOAT;
+	break;
+#endif
+      default:
+	ERREXIT(cinfo, JERR_NOT_COMPILED);
+	break;
+      }
+      break;
+    default:
+      ERREXIT1(cinfo, JERR_BAD_DCTSIZE, compptr->DCT_scaled_size);
+      break;
+    }
+    idct->pub.inverse_DCT[ci] = method_ptr;
+    /* Create multiplier table from quant table.
+     * However, we can skip this if the component is uninteresting
+     * or if we already built the table.  Also, if no quant table
+     * has yet been saved for the component, we leave the
+     * multiplier table all-zero; we'll be reading zeroes from the
+     * coefficient controller's buffer anyway.
+     */
+    if (! compptr->component_needed || idct->cur_method[ci] == method)
+      continue;
+    qtbl = compptr->quant_table;
+    if (qtbl == NULL)		/* happens if no data yet for component */
+      continue;
+    idct->cur_method[ci] = method;
+    switch (method) {
+#ifdef PROVIDE_ISLOW_TABLES
+    case JDCT_ISLOW:
+      {
+	/* For LL&M IDCT method, multipliers are equal to raw quantization
+	 * coefficients, but are stored in natural order as ints.
+	 */
+	ISLOW_MULT_TYPE * ismtbl = (ISLOW_MULT_TYPE *) compptr->dct_table;
+	for (i = 0; i < DCTSIZE2; i++) {
+	  ismtbl[i] = (ISLOW_MULT_TYPE) qtbl->quantval[jpeg_zigzag_order[i]];
+	}
+      }
+      break;
+#endif
+#ifdef DCT_IFAST_SUPPORTED
+    case JDCT_IFAST:
+      {
+	/* For AA&N IDCT method, multipliers are equal to quantization
+	 * coefficients scaled by scalefactor[row]*scalefactor[col], where
+	 *   scalefactor[0] = 1
+	 *   scalefactor[k] = cos(k*PI/16) * sqrt(2)    for k=1..7
+	 * For integer operation, the multiplier table is to be scaled by
+	 * IFAST_SCALE_BITS.  The multipliers are stored in natural order.
+	 */
+	IFAST_MULT_TYPE * ifmtbl = (IFAST_MULT_TYPE *) compptr->dct_table;
+#define CONST_BITS 14
+	static const INT16 aanscales[DCTSIZE2] = {
+	  /* precomputed values scaled up by 14 bits */
+	  16384, 22725, 21407, 19266, 16384, 12873,  8867,  4520,
+	  22725, 31521, 29692, 26722, 22725, 17855, 12299,  6270,
+	  21407, 29692, 27969, 25172, 21407, 16819, 11585,  5906,
+	  19266, 26722, 25172, 22654, 19266, 15137, 10426,  5315,
+	  16384, 22725, 21407, 19266, 16384, 12873,  8867,  4520,
+	  12873, 17855, 16819, 15137, 12873, 10114,  6967,  3552,
+	   8867, 12299, 11585, 10426,  8867,  6967,  4799,  2446,
+	   4520,  6270,  5906,  5315,  4520,  3552,  2446,  1247
+	};
+	SHIFT_TEMPS
+
+	for (i = 0; i < DCTSIZE2; i++) {
+	  ifmtbl[i] = (IFAST_MULT_TYPE)
+	    DESCALE(MULTIPLY16V16((INT32) qtbl->quantval[jpeg_zigzag_order[i]],
+				  (INT32) aanscales[i]),
+		    CONST_BITS-IFAST_SCALE_BITS);
+	}
+      }
+      break;
+#endif
+#ifdef DCT_FLOAT_SUPPORTED
+    case JDCT_FLOAT:
+      {
+	/* For float AA&N IDCT method, multipliers are equal to quantization
+	 * coefficients scaled by scalefactor[row]*scalefactor[col], where
+	 *   scalefactor[0] = 1
+	 *   scalefactor[k] = cos(k*PI/16) * sqrt(2)    for k=1..7
+	 * The multipliers are stored in natural order.
+	 */
+	FLOAT_MULT_TYPE * fmtbl = (FLOAT_MULT_TYPE *) compptr->dct_table;
+	int row, col;
+	static const double aanscalefactor[DCTSIZE] = {
+	  1.0, 1.387039845, 1.306562965, 1.175875602,
+	  1.0, 0.785694958, 0.541196100, 0.275899379
+	};
+
+	i = 0;
+	for (row = 0; row < DCTSIZE; row++) {
+	  for (col = 0; col < DCTSIZE; col++) {
+	    fmtbl[i] = (FLOAT_MULT_TYPE)
+	      ((double) qtbl->quantval[jpeg_zigzag_order[i]] *
+	       aanscalefactor[row] * aanscalefactor[col]);
+	    i++;
+	  }
+	}
+      }
+      break;
+#endif
+    default:
+      ERREXIT(cinfo, JERR_NOT_COMPILED);
+      break;
+    }
+  }
+}
+
+
+/*
+ * Initialize IDCT manager.
+ */
+
+GLOBAL void
+jinit_inverse_dct (j_decompress_ptr cinfo)
+{
+  my_idct_ptr idct;
+  int ci;
+  jpeg_component_info *compptr;
+
+  idct = (my_idct_ptr)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				SIZEOF(my_idct_controller));
+  cinfo->idct = (struct jpeg_inverse_dct *) idct;
+  idct->pub.start_pass = start_pass;
+
+  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+       ci++, compptr++) {
+    /* Allocate and pre-zero a multiplier table for each component */
+    compptr->dct_table =
+      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				  SIZEOF(multiplier_table));
+    MEMZERO(compptr->dct_table, SIZEOF(multiplier_table));
+    /* Mark multiplier table not yet set up for any method */
+    idct->cur_method[ci] = -1;
+  }
+}
diff --git a/code/jpeg-6/jdhuff.cpp b/code/jpeg-6/jdhuff.cpp
new file mode 100644
index 0000000..2a20fe1
--- /dev/null
+++ b/code/jpeg-6/jdhuff.cpp
@@ -0,0 +1,580 @@
+/*
+ * jdhuff.c
+ *
+ * Copyright (C) 1991-1995, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains Huffman entropy decoding routines.
+ *
+ * Much of the complexity here has to do with supporting input suspension.
+ * If the data source module demands suspension, we want to be able to back
+ * up to the start of the current MCU.  To do this, we copy state variables
+ * into local working storage, and update them back to the permanent
+ * storage only upon successful completion of an MCU.
+ */
+
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jdhuff.h"		/* Declarations shared with jdphuff.c */
+
+
+/*
+ * Expanded entropy decoder object for Huffman decoding.
+ *
+ * The savable_state subrecord contains fields that change within an MCU,
+ * but must not be updated permanently until we complete the MCU.
+ */
+
+typedef struct {
+  int last_dc_val[MAX_COMPS_IN_SCAN]; /* last DC coef for each component */
+} savable_state;
+
+/* This macro is to work around compilers with missing or broken
+ * structure assignment.  You'll need to fix this code if you have
+ * such a compiler and you change MAX_COMPS_IN_SCAN.
+ */
+
+#ifndef NO_STRUCT_ASSIGN
+#define ASSIGN_STATE(dest,src)  ((dest) = (src))
+#else
+#if MAX_COMPS_IN_SCAN == 4
+#define ASSIGN_STATE(dest,src)  \
+	((dest).last_dc_val[0] = (src).last_dc_val[0], \
+	 (dest).last_dc_val[1] = (src).last_dc_val[1], \
+	 (dest).last_dc_val[2] = (src).last_dc_val[2], \
+	 (dest).last_dc_val[3] = (src).last_dc_val[3])
+#endif
+#endif
+
+
+typedef struct {
+  struct jpeg_entropy_decoder pub; /* public fields */
+
+  /* These fields are loaded into local variables at start of each MCU.
+   * In case of suspension, we exit WITHOUT updating them.
+   */
+  bitread_perm_state bitstate;	/* Bit buffer at start of MCU */
+  savable_state saved;		/* Other state at start of MCU */
+
+  /* These fields are NOT loaded into local working state. */
+  unsigned int restarts_to_go;	/* MCUs left in this restart interval */
+
+  /* Pointers to derived tables (these workspaces have image lifespan) */
+  d_derived_tbl * dc_derived_tbls[NUM_HUFF_TBLS];
+  d_derived_tbl * ac_derived_tbls[NUM_HUFF_TBLS];
+} huff_entropy_decoder;
+
+typedef huff_entropy_decoder * huff_entropy_ptr;
+
+
+/*
+ * Initialize for a Huffman-compressed scan.
+ */
+
+METHODDEF void
+start_pass_huff_decoder (j_decompress_ptr cinfo)
+{
+  huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
+  int ci, dctbl, actbl;
+  jpeg_component_info * compptr;
+
+  /* Check that the scan parameters Ss, Se, Ah/Al are OK for sequential JPEG.
+   * This ought to be an error condition, but we make it a warning because
+   * there are some baseline files out there with all zeroes in these bytes.
+   */
+  if (cinfo->Ss != 0 || cinfo->Se != DCTSIZE2-1 ||
+      cinfo->Ah != 0 || cinfo->Al != 0)
+    WARNMS(cinfo, JWRN_NOT_SEQUENTIAL);
+
+  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+    compptr = cinfo->cur_comp_info[ci];
+    dctbl = compptr->dc_tbl_no;
+    actbl = compptr->ac_tbl_no;
+    /* Make sure requested tables are present */
+    if (dctbl < 0 || dctbl >= NUM_HUFF_TBLS ||
+	cinfo->dc_huff_tbl_ptrs[dctbl] == NULL)
+      ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, dctbl);
+    if (actbl < 0 || actbl >= NUM_HUFF_TBLS ||
+	cinfo->ac_huff_tbl_ptrs[actbl] == NULL)
+      ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, actbl);
+    /* Compute derived values for Huffman tables */
+    /* We may do this more than once for a table, but it's not expensive */
+    jpeg_make_d_derived_tbl(cinfo, cinfo->dc_huff_tbl_ptrs[dctbl],
+			    & entropy->dc_derived_tbls[dctbl]);
+    jpeg_make_d_derived_tbl(cinfo, cinfo->ac_huff_tbl_ptrs[actbl],
+			    & entropy->ac_derived_tbls[actbl]);
+    /* Initialize DC predictions to 0 */
+    entropy->saved.last_dc_val[ci] = 0;
+  }
+
+  /* Initialize bitread state variables */
+  entropy->bitstate.bits_left = 0;
+  entropy->bitstate.get_buffer = 0; /* unnecessary, but keeps Purify quiet */
+  entropy->bitstate.printed_eod = FALSE;
+
+  /* Initialize restart counter */
+  entropy->restarts_to_go = cinfo->restart_interval;
+}
+
+
+/*
+ * Compute the derived values for a Huffman table.
+ * Note this is also used by jdphuff.c.
+ */
+
+GLOBAL void
+jpeg_make_d_derived_tbl (j_decompress_ptr cinfo, JHUFF_TBL * htbl,
+			 d_derived_tbl ** pdtbl)
+{
+  d_derived_tbl *dtbl;
+  int p, i, l, si;
+  int lookbits, ctr;
+  char huffsize[257];
+  unsigned int huffcode[257];
+  unsigned int code;
+
+  /* Allocate a workspace if we haven't already done so. */
+  if (*pdtbl == NULL)
+    *pdtbl = (d_derived_tbl *)
+      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				  SIZEOF(d_derived_tbl));
+  dtbl = *pdtbl;
+  dtbl->pub = htbl;		/* fill in back link */
+  
+  /* Figure C.1: make table of Huffman code length for each symbol */
+  /* Note that this is in code-length order. */
+
+  p = 0;
+  for (l = 1; l <= 16; l++) {
+    for (i = 1; i <= (int) htbl->bits[l]; i++)
+      huffsize[p++] = (char) l;
+  }
+  huffsize[p] = 0;
+  
+  /* Figure C.2: generate the codes themselves */
+  /* Note that this is in code-length order. */
+  
+  code = 0;
+  si = huffsize[0];
+  p = 0;
+  while (huffsize[p]) {
+    while (((int) huffsize[p]) == si) {
+      huffcode[p++] = code;
+      code++;
+    }
+    code <<= 1;
+    si++;
+  }
+
+  /* Figure F.15: generate decoding tables for bit-sequential decoding */
+
+  p = 0;
+  for (l = 1; l <= 16; l++) {
+    if (htbl->bits[l]) {
+      dtbl->valptr[l] = p; /* huffval[] index of 1st symbol of code length l */
+      dtbl->mincode[l] = huffcode[p]; /* minimum code of length l */
+      p += htbl->bits[l];
+      dtbl->maxcode[l] = huffcode[p-1]; /* maximum code of length l */
+    } else {
+      dtbl->maxcode[l] = -1;	/* -1 if no codes of this length */
+    }
+  }
+  dtbl->maxcode[17] = 0xFFFFFL; /* ensures jpeg_huff_decode terminates */
+
+  /* Compute lookahead tables to speed up decoding.
+   * First we set all the table entries to 0, indicating "too long";
+   * then we iterate through the Huffman codes that are short enough and
+   * fill in all the entries that correspond to bit sequences starting
+   * with that code.
+   */
+
+  MEMZERO(dtbl->look_nbits, SIZEOF(dtbl->look_nbits));
+
+  p = 0;
+  for (l = 1; l <= HUFF_LOOKAHEAD; l++) {
+    for (i = 1; i <= (int) htbl->bits[l]; i++, p++) {
+      /* l = current code's length, p = its index in huffcode[] & huffval[]. */
+      /* Generate left-justified code followed by all possible bit sequences */
+      lookbits = huffcode[p] << (HUFF_LOOKAHEAD-l);
+      for (ctr = 1 << (HUFF_LOOKAHEAD-l); ctr > 0; ctr--) {
+	dtbl->look_nbits[lookbits] = l;
+	dtbl->look_sym[lookbits] = htbl->huffval[p];
+	lookbits++;
+      }
+    }
+  }
+}
+
+
+/*
+ * Out-of-line code for bit fetching (shared with jdphuff.c).
+ * See jdhuff.h for info about usage.
+ * Note: current values of get_buffer and bits_left are passed as parameters,
+ * but are returned in the corresponding fields of the state struct.
+ *
+ * On most machines MIN_GET_BITS should be 25 to allow the full 32-bit width
+ * of get_buffer to be used.  (On machines with wider words, an even larger
+ * buffer could be used.)  However, on some machines 32-bit shifts are
+ * quite slow and take time proportional to the number of places shifted.
+ * (This is true with most PC compilers, for instance.)  In this case it may
+ * be a win to set MIN_GET_BITS to the minimum value of 15.  This reduces the
+ * average shift distance at the cost of more calls to jpeg_fill_bit_buffer.
+ */
+
+#ifdef SLOW_SHIFT_32
+#define MIN_GET_BITS  15	/* minimum allowable value */
+#else
+#define MIN_GET_BITS  (BIT_BUF_SIZE-7)
+#endif
+
+
+GLOBAL boolean
+jpeg_fill_bit_buffer (bitread_working_state * state,
+		      register bit_buf_type get_buffer, register int bits_left,
+		      int nbits)
+/* Load up the bit buffer to a depth of at least nbits */
+{
+  /* Copy heavily used state fields into locals (hopefully registers) */
+  register const JOCTET * next_input_byte = state->next_input_byte;
+  register size_t bytes_in_buffer = state->bytes_in_buffer;
+  register int c;
+
+  /* Attempt to load at least MIN_GET_BITS bits into get_buffer. */
+  /* (It is assumed that no request will be for more than that many bits.) */
+
+  while (bits_left < MIN_GET_BITS) {
+    /* Attempt to read a byte */
+    if (state->unread_marker != 0)
+      goto no_more_data;	/* can't advance past a marker */
+
+    if (bytes_in_buffer == 0) {
+      if (! (*state->cinfo->src->fill_input_buffer) (state->cinfo))
+	return FALSE;
+      next_input_byte = state->cinfo->src->next_input_byte;
+      bytes_in_buffer = state->cinfo->src->bytes_in_buffer;
+    }
+    bytes_in_buffer--;
+    c = GETJOCTET(*next_input_byte++);
+
+    /* If it's 0xFF, check and discard stuffed zero byte */
+    if (c == 0xFF) {
+      do {
+	if (bytes_in_buffer == 0) {
+	  if (! (*state->cinfo->src->fill_input_buffer) (state->cinfo))
+	    return FALSE;
+	  next_input_byte = state->cinfo->src->next_input_byte;
+	  bytes_in_buffer = state->cinfo->src->bytes_in_buffer;
+	}
+	bytes_in_buffer--;
+	c = GETJOCTET(*next_input_byte++);
+      } while (c == 0xFF);
+
+      if (c == 0) {
+	/* Found FF/00, which represents an FF data byte */
+	c = 0xFF;
+      } else {
+	/* Oops, it's actually a marker indicating end of compressed data. */
+	/* Better put it back for use later */
+	state->unread_marker = c;
+
+      no_more_data:
+	/* There should be enough bits still left in the data segment; */
+	/* if so, just break out of the outer while loop. */
+	if (bits_left >= nbits)
+	  break;
+	/* Uh-oh.  Report corrupted data to user and stuff zeroes into
+	 * the data stream, so that we can produce some kind of image.
+	 * Note that this code will be repeated for each byte demanded
+	 * for the rest of the segment.  We use a nonvolatile flag to ensure
+	 * that only one warning message appears.
+	 */
+	if (! *(state->printed_eod_ptr)) {
+	  WARNMS(state->cinfo, JWRN_HIT_MARKER);
+	  *(state->printed_eod_ptr) = TRUE;
+	}
+	c = 0;			/* insert a zero byte into bit buffer */
+      }
+    }
+
+    /* OK, load c into get_buffer */
+    get_buffer = (get_buffer << 8) | c;
+    bits_left += 8;
+  }
+
+  /* Unload the local registers */
+  state->next_input_byte = next_input_byte;
+  state->bytes_in_buffer = bytes_in_buffer;
+  state->get_buffer = get_buffer;
+  state->bits_left = bits_left;
+
+  return TRUE;
+}
+
+
+/*
+ * Out-of-line code for Huffman code decoding.
+ * See jdhuff.h for info about usage.
+ */
+
+GLOBAL int
+jpeg_huff_decode (bitread_working_state * state,
+		  register bit_buf_type get_buffer, register int bits_left,
+		  d_derived_tbl * htbl, int min_bits)
+{
+  register int l = min_bits;
+  register INT32 code;
+
+  /* HUFF_DECODE has determined that the code is at least min_bits */
+  /* bits long, so fetch that many bits in one swoop. */
+
+  CHECK_BIT_BUFFER(*state, l, return -1);
+  code = GET_BITS(l);
+
+  /* Collect the rest of the Huffman code one bit at a time. */
+  /* This is per Figure F.16 in the JPEG spec. */
+
+  while (code > htbl->maxcode[l]) {
+    code <<= 1;
+    CHECK_BIT_BUFFER(*state, 1, return -1);
+    code |= GET_BITS(1);
+    l++;
+  }
+
+  /* Unload the local registers */
+  state->get_buffer = get_buffer;
+  state->bits_left = bits_left;
+
+  /* With garbage input we may reach the sentinel value l = 17. */
+
+  if (l > 16) {
+    WARNMS(state->cinfo, JWRN_HUFF_BAD_CODE);
+    return 0;			/* fake a zero as the safest result */
+  }
+
+  return htbl->pub->huffval[ htbl->valptr[l] +
+			    ((int) (code - htbl->mincode[l])) ];
+}
+
+
+/*
+ * Figure F.12: extend sign bit.
+ * On some machines, a shift and add will be faster than a table lookup.
+ */
+
+#ifdef AVOID_TABLES
+
+#define HUFF_EXTEND(x,s)  ((x) < (1<<((s)-1)) ? (x) + (((-1)<<(s)) + 1) : (x))
+
+#else
+
+#define HUFF_EXTEND(x,s)  ((x) < extend_test[s] ? (x) + extend_offset[s] : (x))
+
+static const int extend_test[16] =   /* entry n is 2**(n-1) */
+  { 0, 0x0001, 0x0002, 0x0004, 0x0008, 0x0010, 0x0020, 0x0040, 0x0080,
+    0x0100, 0x0200, 0x0400, 0x0800, 0x1000, 0x2000, 0x4000 };
+
+static const int extend_offset[16] = /* entry n is (-1 << n) + 1 */
+  { 0, ((-1)<<1) + 1, ((-1)<<2) + 1, ((-1)<<3) + 1, ((-1)<<4) + 1,
+    ((-1)<<5) + 1, ((-1)<<6) + 1, ((-1)<<7) + 1, ((-1)<<8) + 1,
+    ((-1)<<9) + 1, ((-1)<<10) + 1, ((-1)<<11) + 1, ((-1)<<12) + 1,
+    ((-1)<<13) + 1, ((-1)<<14) + 1, ((-1)<<15) + 1 };
+
+#endif /* AVOID_TABLES */
+
+
+/*
+ * Check for a restart marker & resynchronize decoder.
+ * Returns FALSE if must suspend.
+ */
+
+LOCAL boolean
+process_restart (j_decompress_ptr cinfo)
+{
+  huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
+  int ci;
+
+  /* Throw away any unused bits remaining in bit buffer; */
+  /* include any full bytes in next_marker's count of discarded bytes */
+  cinfo->marker->discarded_bytes += entropy->bitstate.bits_left / 8;
+  entropy->bitstate.bits_left = 0;
+
+  /* Advance past the RSTn marker */
+  if (! (*cinfo->marker->read_restart_marker) (cinfo))
+    return FALSE;
+
+  /* Re-initialize DC predictions to 0 */
+  for (ci = 0; ci < cinfo->comps_in_scan; ci++)
+    entropy->saved.last_dc_val[ci] = 0;
+
+  /* Reset restart counter */
+  entropy->restarts_to_go = cinfo->restart_interval;
+
+  /* Next segment can get another out-of-data warning */
+  entropy->bitstate.printed_eod = FALSE;
+
+  return TRUE;
+}
+
+
+/*
+ * Decode and return one MCU's worth of Huffman-compressed coefficients.
+ * The coefficients are reordered from zigzag order into natural array order,
+ * but are not dequantized.
+ *
+ * The i'th block of the MCU is stored into the block pointed to by
+ * MCU_data[i].  WE ASSUME THIS AREA HAS BEEN ZEROED BY THE CALLER.
+ * (Wholesale zeroing is usually a little faster than retail...)
+ *
+ * Returns FALSE if data source requested suspension.  In that case no
+ * changes have been made to permanent state.  (Exception: some output
+ * coefficients may already have been assigned.  This is harmless for
+ * this module, since we'll just re-assign them on the next call.)
+ */
+
+METHODDEF boolean
+decode_mcu (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
+{
+  huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
+  register int s, k, r;
+  int blkn, ci;
+  JBLOCKROW block;
+  BITREAD_STATE_VARS;
+  savable_state state;
+  d_derived_tbl * dctbl;
+  d_derived_tbl * actbl;
+  jpeg_component_info * compptr;
+
+  /* Process restart marker if needed; may have to suspend */
+  if (cinfo->restart_interval) {
+    if (entropy->restarts_to_go == 0)
+      if (! process_restart(cinfo))
+	return FALSE;
+  }
+
+  /* Load up working state */
+  BITREAD_LOAD_STATE(cinfo,entropy->bitstate);
+  ASSIGN_STATE(state, entropy->saved);
+
+  /* Outer loop handles each block in the MCU */
+
+  for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
+    block = MCU_data[blkn];
+    ci = cinfo->MCU_membership[blkn];
+    compptr = cinfo->cur_comp_info[ci];
+    dctbl = entropy->dc_derived_tbls[compptr->dc_tbl_no];
+    actbl = entropy->ac_derived_tbls[compptr->ac_tbl_no];
+
+    /* Decode a single block's worth of coefficients */
+
+    /* Section F.2.2.1: decode the DC coefficient difference */
+    HUFF_DECODE(s, br_state, dctbl, return FALSE, label1);
+    if (s) {
+      CHECK_BIT_BUFFER(br_state, s, return FALSE);
+      r = GET_BITS(s);
+      s = HUFF_EXTEND(r, s);
+    }
+
+    /* Shortcut if component's values are not interesting */
+    if (! compptr->component_needed)
+      goto skip_ACs;
+
+    /* Convert DC difference to actual value, update last_dc_val */
+    s += state.last_dc_val[ci];
+    state.last_dc_val[ci] = s;
+    /* Output the DC coefficient (assumes jpeg_natural_order[0] = 0) */
+    (*block)[0] = (JCOEF) s;
+
+    /* Do we need to decode the AC coefficients for this component? */
+    if (compptr->DCT_scaled_size > 1) {
+
+      /* Section F.2.2.2: decode the AC coefficients */
+      /* Since zeroes are skipped, output area must be cleared beforehand */
+      for (k = 1; k < DCTSIZE2; k++) {
+	HUFF_DECODE(s, br_state, actbl, return FALSE, label2);
+      
+	r = s >> 4;
+	s &= 15;
+      
+	if (s) {
+	  k += r;
+	  CHECK_BIT_BUFFER(br_state, s, return FALSE);
+	  r = GET_BITS(s);
+	  s = HUFF_EXTEND(r, s);
+	  /* Output coefficient in natural (dezigzagged) order.
+	   * Note: the extra entries in jpeg_natural_order[] will save us
+	   * if k >= DCTSIZE2, which could happen if the data is corrupted.
+	   */
+	  (*block)[jpeg_natural_order[k]] = (JCOEF) s;
+	} else {
+	  if (r != 15)
+	    break;
+	  k += 15;
+	}
+      }
+
+    } else {
+skip_ACs:
+
+      /* Section F.2.2.2: decode the AC coefficients */
+      /* In this path we just discard the values */
+      for (k = 1; k < DCTSIZE2; k++) {
+	HUFF_DECODE(s, br_state, actbl, return FALSE, label3);
+      
+	r = s >> 4;
+	s &= 15;
+      
+	if (s) {
+	  k += r;
+	  CHECK_BIT_BUFFER(br_state, s, return FALSE);
+	  DROP_BITS(s);
+	} else {
+	  if (r != 15)
+	    break;
+	  k += 15;
+	}
+      }
+
+    }
+  }
+
+  /* Completed MCU, so update state */
+  BITREAD_SAVE_STATE(cinfo,entropy->bitstate);
+  ASSIGN_STATE(entropy->saved, state);
+
+  /* Account for restart interval (no-op if not using restarts) */
+  entropy->restarts_to_go--;
+
+  return TRUE;
+}
+
+
+/*
+ * Module initialization routine for Huffman entropy decoding.
+ */
+
+GLOBAL void
+jinit_huff_decoder (j_decompress_ptr cinfo)
+{
+  huff_entropy_ptr entropy;
+  int i;
+
+  entropy = (huff_entropy_ptr)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				SIZEOF(huff_entropy_decoder));
+  cinfo->entropy = (struct jpeg_entropy_decoder *) entropy;
+  entropy->pub.start_pass = start_pass_huff_decoder;
+  entropy->pub.decode_mcu = decode_mcu;
+
+  /* Mark tables unallocated */
+  for (i = 0; i < NUM_HUFF_TBLS; i++) {
+    entropy->dc_derived_tbls[i] = entropy->ac_derived_tbls[i] = NULL;
+  }
+}
diff --git a/code/jpeg-6/jdhuff.h b/code/jpeg-6/jdhuff.h
new file mode 100644
index 0000000..65f3054
--- /dev/null
+++ b/code/jpeg-6/jdhuff.h
@@ -0,0 +1,202 @@
+/*
+ * jdhuff.h
+ *
+ * Copyright (C) 1991-1995, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains declarations for Huffman entropy decoding routines
+ * that are shared between the sequential decoder (jdhuff.c) and the
+ * progressive decoder (jdphuff.c).  No other modules need to see these.
+ */
+
+/* Short forms of external names for systems with brain-damaged linkers. */
+
+#ifdef NEED_SHORT_EXTERNAL_NAMES
+#define jpeg_make_d_derived_tbl	jMkDDerived
+#define jpeg_fill_bit_buffer	jFilBitBuf
+#define jpeg_huff_decode	jHufDecode
+#endif /* NEED_SHORT_EXTERNAL_NAMES */
+
+
+/* Derived data constructed for each Huffman table */
+
+#define HUFF_LOOKAHEAD	8	/* # of bits of lookahead */
+
+typedef struct {
+  /* Basic tables: (element [0] of each array is unused) */
+  INT32 mincode[17];		/* smallest code of length k */
+  INT32 maxcode[18];		/* largest code of length k (-1 if none) */
+  /* (maxcode[17] is a sentinel to ensure jpeg_huff_decode terminates) */
+  int valptr[17];		/* huffval[] index of 1st symbol of length k */
+
+  /* Link to public Huffman table (needed only in jpeg_huff_decode) */
+  JHUFF_TBL *pub;
+
+  /* Lookahead tables: indexed by the next HUFF_LOOKAHEAD bits of
+   * the input data stream.  If the next Huffman code is no more
+   * than HUFF_LOOKAHEAD bits long, we can obtain its length and
+   * the corresponding symbol directly from these tables.
+   */
+  int look_nbits[1<<HUFF_LOOKAHEAD]; /* # bits, or 0 if too long */
+  UINT8 look_sym[1<<HUFF_LOOKAHEAD]; /* symbol, or unused */
+} d_derived_tbl;
+
+/* Expand a Huffman table definition into the derived format */
+EXTERN void jpeg_make_d_derived_tbl JPP((j_decompress_ptr cinfo,
+				JHUFF_TBL * htbl, d_derived_tbl ** pdtbl));
+
+
+/*
+ * Fetching the next N bits from the input stream is a time-critical operation
+ * for the Huffman decoders.  We implement it with a combination of inline
+ * macros and out-of-line subroutines.  Note that N (the number of bits
+ * demanded at one time) never exceeds 15 for JPEG use.
+ *
+ * We read source bytes into get_buffer and dole out bits as needed.
+ * If get_buffer already contains enough bits, they are fetched in-line
+ * by the macros CHECK_BIT_BUFFER and GET_BITS.  When there aren't enough
+ * bits, jpeg_fill_bit_buffer is called; it will attempt to fill get_buffer
+ * as full as possible (not just to the number of bits needed; this
+ * prefetching reduces the overhead cost of calling jpeg_fill_bit_buffer).
+ * Note that jpeg_fill_bit_buffer may return FALSE to indicate suspension.
+ * On TRUE return, jpeg_fill_bit_buffer guarantees that get_buffer contains
+ * at least the requested number of bits --- dummy zeroes are inserted if
+ * necessary.
+ */
+
+typedef INT32 bit_buf_type;	/* type of bit-extraction buffer */
+#define BIT_BUF_SIZE  32	/* size of buffer in bits */
+
+/* If long is > 32 bits on your machine, and shifting/masking longs is
+ * reasonably fast, making bit_buf_type be long and setting BIT_BUF_SIZE
+ * appropriately should be a win.  Unfortunately we can't do this with
+ * something like  #define BIT_BUF_SIZE (sizeof(bit_buf_type)*8)
+ * because not all machines measure sizeof in 8-bit bytes.
+ */
+
+typedef struct {		/* Bitreading state saved across MCUs */
+  bit_buf_type get_buffer;	/* current bit-extraction buffer */
+  int bits_left;		/* # of unused bits in it */
+  boolean printed_eod;		/* flag to suppress multiple warning msgs */
+} bitread_perm_state;
+
+typedef struct {		/* Bitreading working state within an MCU */
+  /* current data source state */
+  const JOCTET * next_input_byte; /* => next byte to read from source */
+  size_t bytes_in_buffer;	/* # of bytes remaining in source buffer */
+  int unread_marker;		/* nonzero if we have hit a marker */
+  /* bit input buffer --- note these values are kept in register variables,
+   * not in this struct, inside the inner loops.
+   */
+  bit_buf_type get_buffer;	/* current bit-extraction buffer */
+  int bits_left;		/* # of unused bits in it */
+  /* pointers needed by jpeg_fill_bit_buffer */
+  j_decompress_ptr cinfo;	/* back link to decompress master record */
+  boolean * printed_eod_ptr;	/* => flag in permanent state */
+} bitread_working_state;
+
+/* Macros to declare and load/save bitread local variables. */
+#define BITREAD_STATE_VARS  \
+	register bit_buf_type get_buffer;  \
+	register int bits_left;  \
+	bitread_working_state br_state
+
+#define BITREAD_LOAD_STATE(cinfop,permstate)  \
+	br_state.cinfo = cinfop; \
+	br_state.next_input_byte = cinfop->src->next_input_byte; \
+	br_state.bytes_in_buffer = cinfop->src->bytes_in_buffer; \
+	br_state.unread_marker = cinfop->unread_marker; \
+	get_buffer = permstate.get_buffer; \
+	bits_left = permstate.bits_left; \
+	br_state.printed_eod_ptr = & permstate.printed_eod
+
+#define BITREAD_SAVE_STATE(cinfop,permstate)  \
+	cinfop->src->next_input_byte = br_state.next_input_byte; \
+	cinfop->src->bytes_in_buffer = br_state.bytes_in_buffer; \
+	cinfop->unread_marker = br_state.unread_marker; \
+	permstate.get_buffer = get_buffer; \
+	permstate.bits_left = bits_left
+
+/*
+ * These macros provide the in-line portion of bit fetching.
+ * Use CHECK_BIT_BUFFER to ensure there are N bits in get_buffer
+ * before using GET_BITS, PEEK_BITS, or DROP_BITS.
+ * The variables get_buffer and bits_left are assumed to be locals,
+ * but the state struct might not be (jpeg_huff_decode needs this).
+ *	CHECK_BIT_BUFFER(state,n,action);
+ *		Ensure there are N bits in get_buffer; if suspend, take action.
+ *      val = GET_BITS(n);
+ *		Fetch next N bits.
+ *      val = PEEK_BITS(n);
+ *		Fetch next N bits without removing them from the buffer.
+ *	DROP_BITS(n);
+ *		Discard next N bits.
+ * The value N should be a simple variable, not an expression, because it
+ * is evaluated multiple times.
+ */
+
+#define CHECK_BIT_BUFFER(state,nbits,action) \
+	{ if (bits_left < (nbits)) {  \
+	    if (! jpeg_fill_bit_buffer(&(state),get_buffer,bits_left,nbits))  \
+	      { action; }  \
+	    get_buffer = (state).get_buffer; bits_left = (state).bits_left; } }
+
+#define GET_BITS(nbits) \
+	(((int) (get_buffer >> (bits_left -= (nbits)))) & ((1<<(nbits))-1))
+
+#define PEEK_BITS(nbits) \
+	(((int) (get_buffer >> (bits_left -  (nbits)))) & ((1<<(nbits))-1))
+
+#define DROP_BITS(nbits) \
+	(bits_left -= (nbits))
+
+/* Load up the bit buffer to a depth of at least nbits */
+EXTERN boolean jpeg_fill_bit_buffer JPP((bitread_working_state * state,
+		register bit_buf_type get_buffer, register int bits_left,
+		int nbits));
+
+
+/*
+ * Code for extracting next Huffman-coded symbol from input bit stream.
+ * Again, this is time-critical and we make the main paths be macros.
+ *
+ * We use a lookahead table to process codes of up to HUFF_LOOKAHEAD bits
+ * without looping.  Usually, more than 95% of the Huffman codes will be 8
+ * or fewer bits long.  The few overlength codes are handled with a loop,
+ * which need not be inline code.
+ *
+ * Notes about the HUFF_DECODE macro:
+ * 1. Near the end of the data segment, we may fail to get enough bits
+ *    for a lookahead.  In that case, we do it the hard way.
+ * 2. If the lookahead table contains no entry, the next code must be
+ *    more than HUFF_LOOKAHEAD bits long.
+ * 3. jpeg_huff_decode returns -1 if forced to suspend.
+ */
+
+#define HUFF_DECODE(result,state,htbl,failaction,slowlabel) \
+{ register int nb, look; \
+  if (bits_left < HUFF_LOOKAHEAD) { \
+    if (! jpeg_fill_bit_buffer(&state,get_buffer,bits_left, 0)) {failaction;} \
+    get_buffer = state.get_buffer; bits_left = state.bits_left; \
+    if (bits_left < HUFF_LOOKAHEAD) { \
+      nb = 1; goto slowlabel; \
+    } \
+  } \
+  look = PEEK_BITS(HUFF_LOOKAHEAD); \
+  if ((nb = htbl->look_nbits[look]) != 0) { \
+    DROP_BITS(nb); \
+    result = htbl->look_sym[look]; \
+  } else { \
+    nb = HUFF_LOOKAHEAD+1; \
+slowlabel: \
+    if ((result=jpeg_huff_decode(&state,get_buffer,bits_left,htbl,nb)) < 0) \
+	{ failaction; } \
+    get_buffer = state.get_buffer; bits_left = state.bits_left; \
+  } \
+}
+
+/* Out-of-line case for Huffman code fetching */
+EXTERN int jpeg_huff_decode JPP((bitread_working_state * state,
+		register bit_buf_type get_buffer, register int bits_left,
+		d_derived_tbl * htbl, int min_bits));
diff --git a/code/jpeg-6/jdinput.cpp b/code/jpeg-6/jdinput.cpp
new file mode 100644
index 0000000..db93ccc
--- /dev/null
+++ b/code/jpeg-6/jdinput.cpp
@@ -0,0 +1,386 @@
+/*
+ * jdinput.c
+ *
+ * Copyright (C) 1991-1995, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains input control logic for the JPEG decompressor.
+ * These routines are concerned with controlling the decompressor's input
+ * processing (marker reading and coefficient decoding).  The actual input
+ * reading is done in jdmarker.c, jdhuff.c, and jdphuff.c.
+ */
+
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/* Private state */
+
+typedef struct {
+  struct jpeg_input_controller pub; /* public fields */
+
+  boolean inheaders;		/* TRUE until first SOS is reached */
+} my_input_controller;
+
+typedef my_input_controller * my_inputctl_ptr;
+
+
+/* Forward declarations */
+METHODDEF int consume_markers JPP((j_decompress_ptr cinfo));
+
+
+/*
+ * Routines to calculate various quantities related to the size of the image.
+ */
+
+LOCAL void
+initial_setup (j_decompress_ptr cinfo)
+/* Called once, when first SOS marker is reached */
+{
+  int ci;
+  jpeg_component_info *compptr;
+
+  /* Make sure image isn't bigger than I can handle */
+  if ((long) cinfo->image_height > (long) JPEG_MAX_DIMENSION ||
+      (long) cinfo->image_width > (long) JPEG_MAX_DIMENSION)
+    ERREXIT1(cinfo, JERR_IMAGE_TOO_BIG, (unsigned int) JPEG_MAX_DIMENSION);
+
+  /* For now, precision must match compiled-in value... */
+  if (cinfo->data_precision != BITS_IN_JSAMPLE)
+    ERREXIT1(cinfo, JERR_BAD_PRECISION, cinfo->data_precision);
+
+  /* Check that number of components won't exceed internal array sizes */
+  if (cinfo->num_components > MAX_COMPONENTS)
+    ERREXIT2(cinfo, JERR_COMPONENT_COUNT, cinfo->num_components,
+	     MAX_COMPONENTS);
+
+  /* Compute maximum sampling factors; check factor validity */
+  cinfo->max_h_samp_factor = 1;
+  cinfo->max_v_samp_factor = 1;
+  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+       ci++, compptr++) {
+    if (compptr->h_samp_factor<=0 || compptr->h_samp_factor>MAX_SAMP_FACTOR ||
+	compptr->v_samp_factor<=0 || compptr->v_samp_factor>MAX_SAMP_FACTOR)
+      ERREXIT(cinfo, JERR_BAD_SAMPLING);
+    cinfo->max_h_samp_factor = MAX(cinfo->max_h_samp_factor,
+				   compptr->h_samp_factor);
+    cinfo->max_v_samp_factor = MAX(cinfo->max_v_samp_factor,
+				   compptr->v_samp_factor);
+  }
+
+  /* We initialize DCT_scaled_size and min_DCT_scaled_size to DCTSIZE.
+   * In the full decompressor, this will be overridden by jdmaster.c;
+   * but in the transcoder, jdmaster.c is not used, so we must do it here.
+   */
+  cinfo->min_DCT_scaled_size = DCTSIZE;
+
+  /* Compute dimensions of components */
+  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+       ci++, compptr++) {
+    compptr->DCT_scaled_size = DCTSIZE;
+    /* Size in DCT blocks */
+    compptr->width_in_blocks = (JDIMENSION)
+      jdiv_round_up((long) cinfo->image_width * (long) compptr->h_samp_factor,
+		    (long) (cinfo->max_h_samp_factor * DCTSIZE));
+    compptr->height_in_blocks = (JDIMENSION)
+      jdiv_round_up((long) cinfo->image_height * (long) compptr->v_samp_factor,
+		    (long) (cinfo->max_v_samp_factor * DCTSIZE));
+    /* downsampled_width and downsampled_height will also be overridden by
+     * jdmaster.c if we are doing full decompression.  The transcoder library
+     * doesn't use these values, but the calling application might.
+     */
+    /* Size in samples */
+    compptr->downsampled_width = (JDIMENSION)
+      jdiv_round_up((long) cinfo->image_width * (long) compptr->h_samp_factor,
+		    (long) cinfo->max_h_samp_factor);
+    compptr->downsampled_height = (JDIMENSION)
+      jdiv_round_up((long) cinfo->image_height * (long) compptr->v_samp_factor,
+		    (long) cinfo->max_v_samp_factor);
+    /* Mark component needed, until color conversion says otherwise */
+    compptr->component_needed = TRUE;
+    /* Mark no quantization table yet saved for component */
+    compptr->quant_table = NULL;
+  }
+
+  /* Compute number of fully interleaved MCU rows. */
+  cinfo->total_iMCU_rows = (JDIMENSION)
+    jdiv_round_up((long) cinfo->image_height,
+		  (long) (cinfo->max_v_samp_factor*DCTSIZE));
+
+  /* Decide whether file contains multiple scans */
+  if (cinfo->comps_in_scan < cinfo->num_components || cinfo->progressive_mode)
+    cinfo->inputctl->has_multiple_scans = TRUE;
+  else
+    cinfo->inputctl->has_multiple_scans = FALSE;
+}
+
+
+LOCAL void
+per_scan_setup (j_decompress_ptr cinfo)
+/* Do computations that are needed before processing a JPEG scan */
+/* cinfo->comps_in_scan and cinfo->cur_comp_info[] were set from SOS marker */
+{
+  int ci, mcublks, tmp;
+  jpeg_component_info *compptr;
+  
+  if (cinfo->comps_in_scan == 1) {
+    
+    /* Noninterleaved (single-component) scan */
+    compptr = cinfo->cur_comp_info[0];
+    
+    /* Overall image size in MCUs */
+    cinfo->MCUs_per_row = compptr->width_in_blocks;
+    cinfo->MCU_rows_in_scan = compptr->height_in_blocks;
+    
+    /* For noninterleaved scan, always one block per MCU */
+    compptr->MCU_width = 1;
+    compptr->MCU_height = 1;
+    compptr->MCU_blocks = 1;
+    compptr->MCU_sample_width = compptr->DCT_scaled_size;
+    compptr->last_col_width = 1;
+    /* For noninterleaved scans, it is convenient to define last_row_height
+     * as the number of block rows present in the last iMCU row.
+     */
+    tmp = (int) (compptr->height_in_blocks % compptr->v_samp_factor);
+    if (tmp == 0) tmp = compptr->v_samp_factor;
+    compptr->last_row_height = tmp;
+    
+    /* Prepare array describing MCU composition */
+    cinfo->blocks_in_MCU = 1;
+    cinfo->MCU_membership[0] = 0;
+    
+  } else {
+    
+    /* Interleaved (multi-component) scan */
+    if (cinfo->comps_in_scan <= 0 || cinfo->comps_in_scan > MAX_COMPS_IN_SCAN)
+      ERREXIT2(cinfo, JERR_COMPONENT_COUNT, cinfo->comps_in_scan,
+	       MAX_COMPS_IN_SCAN);
+    
+    /* Overall image size in MCUs */
+    cinfo->MCUs_per_row = (JDIMENSION)
+      jdiv_round_up((long) cinfo->image_width,
+		    (long) (cinfo->max_h_samp_factor*DCTSIZE));
+    cinfo->MCU_rows_in_scan = (JDIMENSION)
+      jdiv_round_up((long) cinfo->image_height,
+		    (long) (cinfo->max_v_samp_factor*DCTSIZE));
+    
+    cinfo->blocks_in_MCU = 0;
+    
+    for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+      compptr = cinfo->cur_comp_info[ci];
+      /* Sampling factors give # of blocks of component in each MCU */
+      compptr->MCU_width = compptr->h_samp_factor;
+      compptr->MCU_height = compptr->v_samp_factor;
+      compptr->MCU_blocks = compptr->MCU_width * compptr->MCU_height;
+      compptr->MCU_sample_width = compptr->MCU_width * compptr->DCT_scaled_size;
+      /* Figure number of non-dummy blocks in last MCU column & row */
+      tmp = (int) (compptr->width_in_blocks % compptr->MCU_width);
+      if (tmp == 0) tmp = compptr->MCU_width;
+      compptr->last_col_width = tmp;
+      tmp = (int) (compptr->height_in_blocks % compptr->MCU_height);
+      if (tmp == 0) tmp = compptr->MCU_height;
+      compptr->last_row_height = tmp;
+      /* Prepare array describing MCU composition */
+      mcublks = compptr->MCU_blocks;
+      if (cinfo->blocks_in_MCU + mcublks > D_MAX_BLOCKS_IN_MCU)
+	ERREXIT(cinfo, JERR_BAD_MCU_SIZE);
+      while (mcublks-- > 0) {
+	cinfo->MCU_membership[cinfo->blocks_in_MCU++] = ci;
+      }
+    }
+    
+  }
+}
+
+
+/*
+ * Save away a copy of the Q-table referenced by each component present
+ * in the current scan, unless already saved during a prior scan.
+ *
+ * In a multiple-scan JPEG file, the encoder could assign different components
+ * the same Q-table slot number, but change table definitions between scans
+ * so that each component uses a different Q-table.  (The IJG encoder is not
+ * currently capable of doing this, but other encoders might.)  Since we want
+ * to be able to dequantize all the components at the end of the file, this
+ * means that we have to save away the table actually used for each component.
+ * We do this by copying the table at the start of the first scan containing
+ * the component.
+ * The JPEG spec prohibits the encoder from changing the contents of a Q-table
+ * slot between scans of a component using that slot.  If the encoder does so
+ * anyway, this decoder will simply use the Q-table values that were current
+ * at the start of the first scan for the component.
+ *
+ * The decompressor output side looks only at the saved quant tables,
+ * not at the current Q-table slots.
+ */
+
+LOCAL void
+latch_quant_tables (j_decompress_ptr cinfo)
+{
+  int ci, qtblno;
+  jpeg_component_info *compptr;
+  JQUANT_TBL * qtbl;
+
+  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+    compptr = cinfo->cur_comp_info[ci];
+    /* No work if we already saved Q-table for this component */
+    if (compptr->quant_table != NULL)
+      continue;
+    /* Make sure specified quantization table is present */
+    qtblno = compptr->quant_tbl_no;
+    if (qtblno < 0 || qtblno >= NUM_QUANT_TBLS ||
+	cinfo->quant_tbl_ptrs[qtblno] == NULL)
+      ERREXIT1(cinfo, JERR_NO_QUANT_TABLE, qtblno);
+    /* OK, save away the quantization table */
+    qtbl = (JQUANT_TBL *)
+      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				  SIZEOF(JQUANT_TBL));
+    MEMCOPY(qtbl, cinfo->quant_tbl_ptrs[qtblno], SIZEOF(JQUANT_TBL));
+    compptr->quant_table = qtbl;
+  }
+}
+
+
+/*
+ * Initialize the input modules to read a scan of compressed data.
+ * The first call to this is done by jdmaster.c after initializing
+ * the entire decompressor (during jpeg_start_decompress).
+ * Subsequent calls come from consume_markers, below.
+ */
+
+METHODDEF void
+start_input_pass (j_decompress_ptr cinfo)
+{
+  per_scan_setup(cinfo);
+  latch_quant_tables(cinfo);
+  (*cinfo->entropy->start_pass) (cinfo);
+  (*cinfo->coef->start_input_pass) (cinfo);
+  cinfo->inputctl->consume_input = cinfo->coef->consume_data;
+}
+
+
+/*
+ * Finish up after inputting a compressed-data scan.
+ * This is called by the coefficient controller after it's read all
+ * the expected data of the scan.
+ */
+
+METHODDEF void
+finish_input_pass (j_decompress_ptr cinfo)
+{
+  cinfo->inputctl->consume_input = consume_markers;
+}
+
+
+/*
+ * Read JPEG markers before, between, or after compressed-data scans.
+ * Change state as necessary when a new scan is reached.
+ * Return value is JPEG_SUSPENDED, JPEG_REACHED_SOS, or JPEG_REACHED_EOI.
+ *
+ * The consume_input method pointer points either here or to the
+ * coefficient controller's consume_data routine, depending on whether
+ * we are reading a compressed data segment or inter-segment markers.
+ */
+
+METHODDEF int
+consume_markers (j_decompress_ptr cinfo)
+{
+  my_inputctl_ptr inputctl = (my_inputctl_ptr) cinfo->inputctl;
+  int val;
+
+  if (inputctl->pub.eoi_reached) /* After hitting EOI, read no further */
+    return JPEG_REACHED_EOI;
+
+  val = (*cinfo->marker->read_markers) (cinfo);
+
+  switch (val) {
+  case JPEG_REACHED_SOS:	/* Found SOS */
+    if (inputctl->inheaders) {	/* 1st SOS */
+      initial_setup(cinfo);
+      inputctl->inheaders = FALSE;
+      /* Note: start_input_pass must be called by jdmaster.c
+       * before any more input can be consumed.  jdapi.c is
+       * responsible for enforcing this sequencing.
+       */
+    } else {			/* 2nd or later SOS marker */
+      if (! inputctl->pub.has_multiple_scans)
+	ERREXIT(cinfo, JERR_EOI_EXPECTED); /* Oops, I wasn't expecting this! */
+      start_input_pass(cinfo);
+    }
+    break;
+  case JPEG_REACHED_EOI:	/* Found EOI */
+    inputctl->pub.eoi_reached = TRUE;
+    if (inputctl->inheaders) {	/* Tables-only datastream, apparently */
+      if (cinfo->marker->saw_SOF)
+	ERREXIT(cinfo, JERR_SOF_NO_SOS);
+    } else {
+      /* Prevent infinite loop in coef ctlr's decompress_data routine
+       * if user set output_scan_number larger than number of scans.
+       */
+      if (cinfo->output_scan_number > cinfo->input_scan_number)
+	cinfo->output_scan_number = cinfo->input_scan_number;
+    }
+    break;
+  case JPEG_SUSPENDED:
+    break;
+  }
+
+  return val;
+}
+
+
+/*
+ * Reset state to begin a fresh datastream.
+ */
+
+METHODDEF void
+reset_input_controller (j_decompress_ptr cinfo)
+{
+  my_inputctl_ptr inputctl = (my_inputctl_ptr) cinfo->inputctl;
+
+  inputctl->pub.consume_input = consume_markers;
+  inputctl->pub.has_multiple_scans = FALSE; /* "unknown" would be better */
+  inputctl->pub.eoi_reached = FALSE;
+  inputctl->inheaders = TRUE;
+  /* Reset other modules */
+  (*cinfo->err->reset_error_mgr) ((j_common_ptr) cinfo);
+  (*cinfo->marker->reset_marker_reader) (cinfo);
+  /* Reset progression state -- would be cleaner if entropy decoder did this */
+  cinfo->coef_bits = NULL;
+}
+
+
+/*
+ * Initialize the input controller module.
+ * This is called only once, when the decompression object is created.
+ */
+
+GLOBAL void
+jinit_input_controller (j_decompress_ptr cinfo)
+{
+  my_inputctl_ptr inputctl;
+
+  /* Create subobject in permanent pool */
+  inputctl = (my_inputctl_ptr)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
+				SIZEOF(my_input_controller));
+  cinfo->inputctl = (struct jpeg_input_controller *) inputctl;
+  /* Initialize method pointers */
+  inputctl->pub.consume_input = consume_markers;
+  inputctl->pub.reset_input_controller = reset_input_controller;
+  inputctl->pub.start_input_pass = start_input_pass;
+  inputctl->pub.finish_input_pass = finish_input_pass;
+  /* Initialize state: can't use reset_input_controller since we don't
+   * want to try to reset other modules yet.
+   */
+  inputctl->pub.has_multiple_scans = FALSE; /* "unknown" would be better */
+  inputctl->pub.eoi_reached = FALSE;
+  inputctl->inheaders = TRUE;
+}
diff --git a/code/jpeg-6/jdmainct.cpp b/code/jpeg-6/jdmainct.cpp
new file mode 100644
index 0000000..a821d58
--- /dev/null
+++ b/code/jpeg-6/jdmainct.cpp
@@ -0,0 +1,525 @@
+/*
+ * jdmainct.c
+ *
+ * Copyright (C) 1994-1995, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains the main buffer controller for decompression.
+ * The main buffer lies between the JPEG decompressor proper and the
+ * post-processor; it holds downsampled data in the JPEG colorspace.
+ *
+ * Note that this code is bypassed in raw-data mode, since the application
+ * supplies the equivalent of the main buffer in that case.
+ */
+
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/*
+ * In the current system design, the main buffer need never be a full-image
+ * buffer; any full-height buffers will be found inside the coefficient or
+ * postprocessing controllers.  Nonetheless, the main controller is not
+ * trivial.  Its responsibility is to provide context rows for upsampling/
+ * rescaling, and doing this in an efficient fashion is a bit tricky.
+ *
+ * Postprocessor input data is counted in "row groups".  A row group
+ * is defined to be (v_samp_factor * DCT_scaled_size / min_DCT_scaled_size)
+ * sample rows of each component.  (We require DCT_scaled_size values to be
+ * chosen such that these numbers are integers.  In practice DCT_scaled_size
+ * values will likely be powers of two, so we actually have the stronger
+ * condition that DCT_scaled_size / min_DCT_scaled_size is an integer.)
+ * Upsampling will typically produce max_v_samp_factor pixel rows from each
+ * row group (times any additional scale factor that the upsampler is
+ * applying).
+ *
+ * The coefficient controller will deliver data to us one iMCU row at a time;
+ * each iMCU row contains v_samp_factor * DCT_scaled_size sample rows, or
+ * exactly min_DCT_scaled_size row groups.  (This amount of data corresponds
+ * to one row of MCUs when the image is fully interleaved.)  Note that the
+ * number of sample rows varies across components, but the number of row
+ * groups does not.  Some garbage sample rows may be included in the last iMCU
+ * row at the bottom of the image.
+ *
+ * Depending on the vertical scaling algorithm used, the upsampler may need
+ * access to the sample row(s) above and below its current input row group.
+ * The upsampler is required to set need_context_rows TRUE at global selection
+ * time if so.  When need_context_rows is FALSE, this controller can simply
+ * obtain one iMCU row at a time from the coefficient controller and dole it
+ * out as row groups to the postprocessor.
+ *
+ * When need_context_rows is TRUE, this controller guarantees that the buffer
+ * passed to postprocessing contains at least one row group's worth of samples
+ * above and below the row group(s) being processed.  Note that the context
+ * rows "above" the first passed row group appear at negative row offsets in
+ * the passed buffer.  At the top and bottom of the image, the required
+ * context rows are manufactured by duplicating the first or last real sample
+ * row; this avoids having special cases in the upsampling inner loops.
+ *
+ * The amount of context is fixed at one row group just because that's a
+ * convenient number for this controller to work with.  The existing
+ * upsamplers really only need one sample row of context.  An upsampler
+ * supporting arbitrary output rescaling might wish for more than one row
+ * group of context when shrinking the image; tough, we don't handle that.
+ * (This is justified by the assumption that downsizing will be handled mostly
+ * by adjusting the DCT_scaled_size values, so that the actual scale factor at
+ * the upsample step needn't be much less than one.)
+ *
+ * To provide the desired context, we have to retain the last two row groups
+ * of one iMCU row while reading in the next iMCU row.  (The last row group
+ * can't be processed until we have another row group for its below-context,
+ * and so we have to save the next-to-last group too for its above-context.)
+ * We could do this most simply by copying data around in our buffer, but
+ * that'd be very slow.  We can avoid copying any data by creating a rather
+ * strange pointer structure.  Here's how it works.  We allocate a workspace
+ * consisting of M+2 row groups (where M = min_DCT_scaled_size is the number
+ * of row groups per iMCU row).  We create two sets of redundant pointers to
+ * the workspace.  Labeling the physical row groups 0 to M+1, the synthesized
+ * pointer lists look like this:
+ *                   M+1                          M-1
+ * master pointer --> 0         master pointer --> 0
+ *                    1                            1
+ *                   ...                          ...
+ *                   M-3                          M-3
+ *                   M-2                           M
+ *                   M-1                          M+1
+ *                    M                           M-2
+ *                   M+1                          M-1
+ *                    0                            0
+ * We read alternate iMCU rows using each master pointer; thus the last two
+ * row groups of the previous iMCU row remain un-overwritten in the workspace.
+ * The pointer lists are set up so that the required context rows appear to
+ * be adjacent to the proper places when we pass the pointer lists to the
+ * upsampler.
+ *
+ * The above pictures describe the normal state of the pointer lists.
+ * At top and bottom of the image, we diddle the pointer lists to duplicate
+ * the first or last sample row as necessary (this is cheaper than copying
+ * sample rows around).
+ *
+ * This scheme breaks down if M < 2, ie, min_DCT_scaled_size is 1.  In that
+ * situation each iMCU row provides only one row group so the buffering logic
+ * must be different (eg, we must read two iMCU rows before we can emit the
+ * first row group).  For now, we simply do not support providing context
+ * rows when min_DCT_scaled_size is 1.  That combination seems unlikely to
+ * be worth providing --- if someone wants a 1/8th-size preview, they probably
+ * want it quick and dirty, so a context-free upsampler is sufficient.
+ */
+
+
+/* Private buffer controller object */
+
+typedef struct {
+  struct jpeg_d_main_controller pub; /* public fields */
+
+  /* Pointer to allocated workspace (M or M+2 row groups). */
+  JSAMPARRAY buffer[MAX_COMPONENTS];
+
+  boolean buffer_full;		/* Have we gotten an iMCU row from decoder? */
+  JDIMENSION rowgroup_ctr;	/* counts row groups output to postprocessor */
+
+  /* Remaining fields are only used in the context case. */
+
+  /* These are the master pointers to the funny-order pointer lists. */
+  JSAMPIMAGE xbuffer[2];	/* pointers to weird pointer lists */
+
+  int whichptr;			/* indicates which pointer set is now in use */
+  int context_state;		/* process_data state machine status */
+  JDIMENSION rowgroups_avail;	/* row groups available to postprocessor */
+  JDIMENSION iMCU_row_ctr;	/* counts iMCU rows to detect image top/bot */
+} my_main_controller;
+
+typedef my_main_controller * my_main_ptr;
+
+/* context_state values: */
+#define CTX_PREPARE_FOR_IMCU	0	/* need to prepare for MCU row */
+#define CTX_PROCESS_IMCU	1	/* feeding iMCU to postprocessor */
+#define CTX_POSTPONED_ROW	2	/* feeding postponed row group */
+
+
+/* Forward declarations */
+METHODDEF void process_data_simple_main
+	JPP((j_decompress_ptr cinfo, JSAMPARRAY output_buf,
+	     JDIMENSION *out_row_ctr, JDIMENSION out_rows_avail));
+METHODDEF void process_data_context_main
+	JPP((j_decompress_ptr cinfo, JSAMPARRAY output_buf,
+	     JDIMENSION *out_row_ctr, JDIMENSION out_rows_avail));
+#ifdef QUANT_2PASS_SUPPORTED
+METHODDEF void process_data_crank_post
+	JPP((j_decompress_ptr cinfo, JSAMPARRAY output_buf,
+	     JDIMENSION *out_row_ctr, JDIMENSION out_rows_avail));
+#endif
+
+
+LOCAL void
+alloc_funny_pointers (j_decompress_ptr cinfo)
+/* Allocate space for the funny pointer lists.
+ * This is done only once, not once per pass.
+ */
+{
+  // bk001204 - no use main
+  my_main_ptr jmain = (my_main_ptr) cinfo->main;
+  int ci, rgroup;
+  int M = cinfo->min_DCT_scaled_size;
+  jpeg_component_info *compptr;
+  JSAMPARRAY xbuf;
+
+  /* Get top-level space for component array pointers.
+   * We alloc both arrays with one call to save a few cycles.
+   */
+  jmain->xbuffer[0] = (JSAMPIMAGE)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				cinfo->num_components * 2 * SIZEOF(JSAMPARRAY));
+  jmain->xbuffer[1] = jmain->xbuffer[0] + cinfo->num_components;
+
+  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+       ci++, compptr++) {
+    rgroup = (compptr->v_samp_factor * compptr->DCT_scaled_size) /
+      cinfo->min_DCT_scaled_size; /* height of a row group of component */
+    /* Get space for pointer lists --- M+4 row groups in each list.
+     * We alloc both pointer lists with one call to save a few cycles.
+     */
+    xbuf = (JSAMPARRAY)
+      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				  2 * (rgroup * (M + 4)) * SIZEOF(JSAMPROW));
+    xbuf += rgroup;		/* want one row group at negative offsets */
+    jmain->xbuffer[0][ci] = xbuf;
+    xbuf += rgroup * (M + 4);
+    jmain->xbuffer[1][ci] = xbuf;
+  }
+}
+
+
+LOCAL void
+make_funny_pointers (j_decompress_ptr cinfo)
+/* Create the funny pointer lists discussed in the comments above.
+ * The actual workspace is already allocated (in main->buffer),
+ * and the space for the pointer lists is allocated too.
+ * This routine just fills in the curiously ordered lists.
+ * This will be repeated at the beginning of each pass.
+ */
+{
+ // bk001204 - no use main
+  my_main_ptr jmain = (my_main_ptr) cinfo->main;
+  int ci, i, rgroup;
+  int M = cinfo->min_DCT_scaled_size;
+  jpeg_component_info *compptr;
+  JSAMPARRAY buf, xbuf0, xbuf1;
+
+  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+       ci++, compptr++) {
+    rgroup = (compptr->v_samp_factor * compptr->DCT_scaled_size) /
+      cinfo->min_DCT_scaled_size; /* height of a row group of component */
+    xbuf0 = jmain->xbuffer[0][ci];
+    xbuf1 = jmain->xbuffer[1][ci];
+    /* First copy the workspace pointers as-is */
+    buf = jmain->buffer[ci];
+    for (i = 0; i < rgroup * (M + 2); i++) {
+      xbuf0[i] = xbuf1[i] = buf[i];
+    }
+    /* In the second list, put the last four row groups in swapped order */
+    for (i = 0; i < rgroup * 2; i++) {
+      xbuf1[rgroup*(M-2) + i] = buf[rgroup*M + i];
+      xbuf1[rgroup*M + i] = buf[rgroup*(M-2) + i];
+    }
+    /* The wraparound pointers at top and bottom will be filled later
+     * (see set_wraparound_pointers, below).  Initially we want the "above"
+     * pointers to duplicate the first actual data line.  This only needs
+     * to happen in xbuffer[0].
+     */
+    for (i = 0; i < rgroup; i++) {
+      xbuf0[i - rgroup] = xbuf0[0];
+    }
+  }
+}
+
+
+LOCAL void
+set_wraparound_pointers (j_decompress_ptr cinfo)
+/* Set up the "wraparound" pointers at top and bottom of the pointer lists.
+ * This changes the pointer list state from top-of-image to the normal state.
+ */
+{
+ // bk001204 - no use main
+  my_main_ptr jmain = (my_main_ptr) cinfo->main;
+  int ci, i, rgroup;
+  int M = cinfo->min_DCT_scaled_size;
+  jpeg_component_info *compptr;
+  JSAMPARRAY xbuf0, xbuf1;
+
+  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+       ci++, compptr++) {
+    rgroup = (compptr->v_samp_factor * compptr->DCT_scaled_size) /
+      cinfo->min_DCT_scaled_size; /* height of a row group of component */
+    xbuf0 = jmain->xbuffer[0][ci];
+    xbuf1 = jmain->xbuffer[1][ci];
+    for (i = 0; i < rgroup; i++) {
+      xbuf0[i - rgroup] = xbuf0[rgroup*(M+1) + i];
+      xbuf1[i - rgroup] = xbuf1[rgroup*(M+1) + i];
+      xbuf0[rgroup*(M+2) + i] = xbuf0[i];
+      xbuf1[rgroup*(M+2) + i] = xbuf1[i];
+    }
+  }
+}
+
+
+LOCAL void
+set_bottom_pointers (j_decompress_ptr cinfo)
+/* Change the pointer lists to duplicate the last sample row at the bottom
+ * of the image.  whichptr indicates which xbuffer holds the final iMCU row.
+ * Also sets rowgroups_avail to indicate number of nondummy row groups in row.
+ */
+{
+ // bk001204 - no use main
+  my_main_ptr jmain = (my_main_ptr) cinfo->main;
+  int ci, i, rgroup, iMCUheight, rows_left;
+  jpeg_component_info *compptr;
+  JSAMPARRAY xbuf;
+
+  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+       ci++, compptr++) {
+    /* Count sample rows in one iMCU row and in one row group */
+    iMCUheight = compptr->v_samp_factor * compptr->DCT_scaled_size;
+    rgroup = iMCUheight / cinfo->min_DCT_scaled_size;
+    /* Count nondummy sample rows remaining for this component */
+    rows_left = (int) (compptr->downsampled_height % (JDIMENSION) iMCUheight);
+    if (rows_left == 0) rows_left = iMCUheight;
+    /* Count nondummy row groups.  Should get same answer for each component,
+     * so we need only do it once.
+     */
+    if (ci == 0) {
+      jmain->rowgroups_avail = (JDIMENSION) ((rows_left-1) / rgroup + 1);
+    }
+    /* Duplicate the last real sample row rgroup*2 times; this pads out the
+     * last partial rowgroup and ensures at least one full rowgroup of context.
+     */
+    xbuf = jmain->xbuffer[jmain->whichptr][ci];
+    for (i = 0; i < rgroup * 2; i++) {
+      xbuf[rows_left + i] = xbuf[rows_left-1];
+    }
+  }
+}
+
+
+/*
+ * Initialize for a processing pass.
+ */
+
+METHODDEF void
+start_pass_main (j_decompress_ptr cinfo, J_BUF_MODE pass_mode)
+{
+  // bk001204 - no use main
+  my_main_ptr jmain = (my_main_ptr) cinfo->main;
+
+  switch (pass_mode) {
+  case JBUF_PASS_THRU:
+    if (cinfo->upsample->need_context_rows) {
+      jmain->pub.process_data = process_data_context_main;
+      make_funny_pointers(cinfo); /* Create the xbuffer[] lists */
+      jmain->whichptr = 0;	/* Read first iMCU row into xbuffer[0] */
+      jmain->context_state = CTX_PREPARE_FOR_IMCU;
+      jmain->iMCU_row_ctr = 0;
+    } else {
+      /* Simple case with no context needed */
+      jmain->pub.process_data = process_data_simple_main;
+    }
+    jmain->buffer_full = FALSE;	/* Mark buffer empty */
+    jmain->rowgroup_ctr = 0;
+    break;
+#ifdef QUANT_2PASS_SUPPORTED
+  case JBUF_CRANK_DEST:
+    /* For last pass of 2-pass quantization, just crank the postprocessor */
+    jmain->pub.process_data = process_data_crank_post;
+    break;
+#endif
+  default:
+    ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+    break;
+  }
+}
+
+
+/*
+ * Process some data.
+ * This handles the simple case where no context is required.
+ */
+
+METHODDEF void
+process_data_simple_main (j_decompress_ptr cinfo,
+			  JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
+			  JDIMENSION out_rows_avail)
+{
+  // bk001204 - no use main
+  my_main_ptr jmain = (my_main_ptr) cinfo->main;
+  JDIMENSION rowgroups_avail;
+
+  /* Read input data if we haven't filled the main buffer yet */
+  if (! jmain->buffer_full) {
+    if (! (*cinfo->coef->decompress_data) (cinfo, jmain->buffer))
+      return;			/* suspension forced, can do nothing more */
+    jmain->buffer_full = TRUE;	/* OK, we have an iMCU row to work with */
+  }
+
+  /* There are always min_DCT_scaled_size row groups in an iMCU row. */
+  rowgroups_avail = (JDIMENSION) cinfo->min_DCT_scaled_size;
+  /* Note: at the bottom of the image, we may pass extra garbage row groups
+   * to the postprocessor.  The postprocessor has to check for bottom
+   * of image anyway (at row resolution), so no point in us doing it too.
+   */
+
+  /* Feed the postprocessor */
+  (*cinfo->post->post_process_data) (cinfo, jmain->buffer,
+				     &jmain->rowgroup_ctr, rowgroups_avail,
+				     output_buf, out_row_ctr, out_rows_avail);
+
+  /* Has postprocessor consumed all the data yet? If so, mark buffer empty */
+  if (jmain->rowgroup_ctr >= rowgroups_avail) {
+    jmain->buffer_full = FALSE;
+    jmain->rowgroup_ctr = 0;
+  }
+}
+
+
+/*
+ * Process some data.
+ * This handles the case where context rows must be provided.
+ */
+
+METHODDEF void
+process_data_context_main (j_decompress_ptr cinfo,
+			   JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
+			   JDIMENSION out_rows_avail)
+{
+  // bk001204 - no use main
+  my_main_ptr jmain = (my_main_ptr) cinfo->main;
+
+  /* Read input data if we haven't filled the main buffer yet */
+  if (! jmain->buffer_full) {
+    if (! (*cinfo->coef->decompress_data) (cinfo,
+					   jmain->xbuffer[jmain->whichptr]))
+      return;			/* suspension forced, can do nothing more */
+    jmain->buffer_full = TRUE;	/* OK, we have an iMCU row to work with */
+    jmain->iMCU_row_ctr++;	/* count rows received */
+  }
+
+  /* Postprocessor typically will not swallow all the input data it is handed
+   * in one call (due to filling the output buffer first).  Must be prepared
+   * to exit and restart.  This switch lets us keep track of how far we got.
+   * Note that each case falls through to the next on successful completion.
+   */
+  switch (jmain->context_state) {
+  case CTX_POSTPONED_ROW:
+    /* Call postprocessor using previously set pointers for postponed row */
+    (*cinfo->post->post_process_data) (cinfo, jmain->xbuffer[jmain->whichptr],
+			&jmain->rowgroup_ctr, jmain->rowgroups_avail,
+			output_buf, out_row_ctr, out_rows_avail);
+    if (jmain->rowgroup_ctr < jmain->rowgroups_avail)
+      return;			/* Need to suspend */
+    jmain->context_state = CTX_PREPARE_FOR_IMCU;
+    if (*out_row_ctr >= out_rows_avail)
+      return;			/* Postprocessor exactly filled output buf */
+    /*FALLTHROUGH*/
+  case CTX_PREPARE_FOR_IMCU:
+    /* Prepare to process first M-1 row groups of this iMCU row */
+    jmain->rowgroup_ctr = 0;
+    jmain->rowgroups_avail = (JDIMENSION) (cinfo->min_DCT_scaled_size - 1);
+    /* Check for bottom of image: if so, tweak pointers to "duplicate"
+     * the last sample row, and adjust rowgroups_avail to ignore padding rows.
+     */
+    if (jmain->iMCU_row_ctr == cinfo->total_iMCU_rows)
+      set_bottom_pointers(cinfo);
+    jmain->context_state = CTX_PROCESS_IMCU;
+    /*FALLTHROUGH*/
+  case CTX_PROCESS_IMCU:
+    /* Call postprocessor using previously set pointers */
+    (*cinfo->post->post_process_data) (cinfo, jmain->xbuffer[jmain->whichptr],
+			&jmain->rowgroup_ctr, jmain->rowgroups_avail,
+			output_buf, out_row_ctr, out_rows_avail);
+    if (jmain->rowgroup_ctr < jmain->rowgroups_avail)
+      return;			/* Need to suspend */
+    /* After the first iMCU, change wraparound pointers to normal state */
+    if (jmain->iMCU_row_ctr == 1)
+      set_wraparound_pointers(cinfo);
+    /* Prepare to load new iMCU row using other xbuffer list */
+    jmain->whichptr ^= 1;	/* 0=>1 or 1=>0 */
+    jmain->buffer_full = FALSE;
+    /* Still need to process last row group of this iMCU row, */
+    /* which is saved at index M+1 of the other xbuffer */
+    jmain->rowgroup_ctr = (JDIMENSION) (cinfo->min_DCT_scaled_size + 1);
+    jmain->rowgroups_avail = (JDIMENSION) (cinfo->min_DCT_scaled_size + 2);
+    jmain->context_state = CTX_POSTPONED_ROW;
+  }
+}
+
+
+/*
+ * Process some data.
+ * Final pass of two-pass quantization: just call the postprocessor.
+ * Source data will be the postprocessor controller's internal buffer.
+ */
+
+#ifdef QUANT_2PASS_SUPPORTED
+
+METHODDEF void
+process_data_crank_post (j_decompress_ptr cinfo,
+			 JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
+			 JDIMENSION out_rows_avail)
+{
+  (*cinfo->post->post_process_data) (cinfo, (JSAMPIMAGE) NULL,
+				     (JDIMENSION *) NULL, (JDIMENSION) 0,
+				     output_buf, out_row_ctr, out_rows_avail);
+}
+
+#endif /* QUANT_2PASS_SUPPORTED */
+
+
+/*
+ * Initialize main buffer controller.
+ */
+
+GLOBAL void
+jinit_d_main_controller (j_decompress_ptr cinfo, boolean need_full_buffer)
+{
+  // bk001204 - no use main
+  my_main_ptr jmain;
+  int ci, rgroup, ngroups;
+  jpeg_component_info *compptr;
+
+  jmain = (my_main_ptr)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				SIZEOF(my_main_controller));
+  cinfo->main = (struct jpeg_d_main_controller *) jmain;
+  jmain->pub.start_pass = start_pass_main;
+
+  if (need_full_buffer)		/* shouldn't happen */
+    ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+
+  /* Allocate the workspace.
+   * ngroups is the number of row groups we need.
+   */
+  if (cinfo->upsample->need_context_rows) {
+    if (cinfo->min_DCT_scaled_size < 2) /* unsupported, see comments above */
+      ERREXIT(cinfo, JERR_NOTIMPL);
+    alloc_funny_pointers(cinfo); /* Alloc space for xbuffer[] lists */
+    ngroups = cinfo->min_DCT_scaled_size + 2;
+  } else {
+    ngroups = cinfo->min_DCT_scaled_size;
+  }
+
+  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+       ci++, compptr++) {
+    rgroup = (compptr->v_samp_factor * compptr->DCT_scaled_size) /
+      cinfo->min_DCT_scaled_size; /* height of a row group of component */
+    jmain->buffer[ci] = (*cinfo->mem->alloc_sarray)
+			((j_common_ptr) cinfo, JPOOL_IMAGE,
+			 compptr->width_in_blocks * compptr->DCT_scaled_size,
+			 (JDIMENSION) (rgroup * ngroups));
+  }
+}
diff --git a/code/jpeg-6/jdmarker.cpp b/code/jpeg-6/jdmarker.cpp
new file mode 100644
index 0000000..fddf7ba
--- /dev/null
+++ b/code/jpeg-6/jdmarker.cpp
@@ -0,0 +1,1058 @@
+/*
+ * jdmarker.c
+ *
+ * Copyright (C) 1991-1995, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains routines to decode JPEG datastream markers.
+ * Most of the complexity arises from our desire to support input
+ * suspension: if not all of the data for a marker is available,
+ * we must exit back to the application.  On resumption, we reprocess
+ * the marker.
+ */
+
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+typedef enum {			/* JPEG marker codes */
+  M_SOF0  = 0xc0,
+  M_SOF1  = 0xc1,
+  M_SOF2  = 0xc2,
+  M_SOF3  = 0xc3,
+  
+  M_SOF5  = 0xc5,
+  M_SOF6  = 0xc6,
+  M_SOF7  = 0xc7,
+  
+  M_JPG   = 0xc8,
+  M_SOF9  = 0xc9,
+  M_SOF10 = 0xca,
+  M_SOF11 = 0xcb,
+  
+  M_SOF13 = 0xcd,
+  M_SOF14 = 0xce,
+  M_SOF15 = 0xcf,
+  
+  M_DHT   = 0xc4,
+  
+  M_DAC   = 0xcc,
+  
+  M_RST0  = 0xd0,
+  M_RST1  = 0xd1,
+  M_RST2  = 0xd2,
+  M_RST3  = 0xd3,
+  M_RST4  = 0xd4,
+  M_RST5  = 0xd5,
+  M_RST6  = 0xd6,
+  M_RST7  = 0xd7,
+  
+  M_SOI   = 0xd8,
+  M_EOI   = 0xd9,
+  M_SOS   = 0xda,
+  M_DQT   = 0xdb,
+  M_DNL   = 0xdc,
+  M_DRI   = 0xdd,
+  M_DHP   = 0xde,
+  M_EXP   = 0xdf,
+  
+  M_APP0  = 0xe0,
+  M_APP1  = 0xe1,
+  M_APP2  = 0xe2,
+  M_APP3  = 0xe3,
+  M_APP4  = 0xe4,
+  M_APP5  = 0xe5,
+  M_APP6  = 0xe6,
+  M_APP7  = 0xe7,
+  M_APP8  = 0xe8,
+  M_APP9  = 0xe9,
+  M_APP10 = 0xea,
+  M_APP11 = 0xeb,
+  M_APP12 = 0xec,
+  M_APP13 = 0xed,
+  M_APP14 = 0xee,
+  M_APP15 = 0xef,
+  
+  M_JPG0  = 0xf0,
+  M_JPG13 = 0xfd,
+  M_COM   = 0xfe,
+  
+  M_TEM   = 0x01,
+  
+  M_ERROR = 0x100
+} JPEG_MARKER;
+
+
+/*
+ * Macros for fetching data from the data source module.
+ *
+ * At all times, cinfo->src->next_input_byte and ->bytes_in_buffer reflect
+ * the current restart point; we update them only when we have reached a
+ * suitable place to restart if a suspension occurs.
+ */
+
+/* Declare and initialize local copies of input pointer/count */
+#define INPUT_VARS(cinfo)  \
+	struct jpeg_source_mgr * datasrc = (cinfo)->src;  \
+	const JOCTET * next_input_byte = datasrc->next_input_byte;  \
+	size_t bytes_in_buffer = datasrc->bytes_in_buffer
+
+/* Unload the local copies --- do this only at a restart boundary */
+#define INPUT_SYNC(cinfo)  \
+	( datasrc->next_input_byte = next_input_byte,  \
+	  datasrc->bytes_in_buffer = bytes_in_buffer )
+
+/* Reload the local copies --- seldom used except in MAKE_BYTE_AVAIL */
+#define INPUT_RELOAD(cinfo)  \
+	( next_input_byte = datasrc->next_input_byte,  \
+	  bytes_in_buffer = datasrc->bytes_in_buffer )
+
+/* Internal macro for INPUT_BYTE and INPUT_2BYTES: make a byte available.
+ * Note we do *not* do INPUT_SYNC before calling fill_input_buffer,
+ * but we must reload the local copies after a successful fill.
+ */
+#define MAKE_BYTE_AVAIL(cinfo,action)  \
+	if (bytes_in_buffer == 0) {  \
+	  if (! (*datasrc->fill_input_buffer) (cinfo))  \
+	    { action; }  \
+	  INPUT_RELOAD(cinfo);  \
+	}  \
+	bytes_in_buffer--
+
+/* Read a byte into variable V.
+ * If must suspend, take the specified action (typically "return FALSE").
+ */
+#define INPUT_BYTE(cinfo,V,action)  \
+	MAKESTMT( MAKE_BYTE_AVAIL(cinfo,action); \
+		  V = GETJOCTET(*next_input_byte++); )
+
+/* As above, but read two bytes interpreted as an unsigned 16-bit integer.
+ * V should be declared unsigned int or perhaps INT32.
+ */
+#define INPUT_2BYTES(cinfo,V,action)  \
+	MAKESTMT( MAKE_BYTE_AVAIL(cinfo,action); \
+		  V = ((unsigned int) GETJOCTET(*next_input_byte++)) << 8; \
+		  MAKE_BYTE_AVAIL(cinfo,action); \
+		  V += GETJOCTET(*next_input_byte++); )
+
+
+/*
+ * Routines to process JPEG markers.
+ *
+ * Entry condition: JPEG marker itself has been read and its code saved
+ *   in cinfo->unread_marker; input restart point is just after the marker.
+ *
+ * Exit: if return TRUE, have read and processed any parameters, and have
+ *   updated the restart point to point after the parameters.
+ *   If return FALSE, was forced to suspend before reaching end of
+ *   marker parameters; restart point has not been moved.  Same routine
+ *   will be called again after application supplies more input data.
+ *
+ * This approach to suspension assumes that all of a marker's parameters can
+ * fit into a single input bufferload.  This should hold for "normal"
+ * markers.  Some COM/APPn markers might have large parameter segments,
+ * but we use skip_input_data to get past those, and thereby put the problem
+ * on the source manager's shoulders.
+ *
+ * Note that we don't bother to avoid duplicate trace messages if a
+ * suspension occurs within marker parameters.  Other side effects
+ * require more care.
+ */
+
+
+LOCAL boolean
+get_soi (j_decompress_ptr cinfo)
+/* Process an SOI marker */
+{
+  int i;
+  
+  TRACEMS(cinfo, 1, JTRC_SOI);
+
+  if (cinfo->marker->saw_SOI)
+    ERREXIT(cinfo, JERR_SOI_DUPLICATE);
+
+  /* Reset all parameters that are defined to be reset by SOI */
+
+  for (i = 0; i < NUM_ARITH_TBLS; i++) {
+    cinfo->arith_dc_L[i] = 0;
+    cinfo->arith_dc_U[i] = 1;
+    cinfo->arith_ac_K[i] = 5;
+  }
+  cinfo->restart_interval = 0;
+
+  /* Set initial assumptions for colorspace etc */
+
+  cinfo->jpeg_color_space = JCS_UNKNOWN;
+  cinfo->CCIR601_sampling = FALSE; /* Assume non-CCIR sampling??? */
+
+  cinfo->saw_JFIF_marker = FALSE;
+  cinfo->density_unit = 0;	/* set default JFIF APP0 values */
+  cinfo->X_density = 1;
+  cinfo->Y_density = 1;
+  cinfo->saw_Adobe_marker = FALSE;
+  cinfo->Adobe_transform = 0;
+
+  cinfo->marker->saw_SOI = TRUE;
+
+  return TRUE;
+}
+
+
+LOCAL boolean
+get_sof (j_decompress_ptr cinfo, boolean is_prog, boolean is_arith)
+/* Process a SOFn marker */
+{
+  INT32 length;
+  int c, ci;
+  jpeg_component_info * compptr;
+  INPUT_VARS(cinfo);
+
+  cinfo->progressive_mode = is_prog;
+  cinfo->arith_code = is_arith;
+
+  INPUT_2BYTES(cinfo, length, return FALSE);
+
+  INPUT_BYTE(cinfo, cinfo->data_precision, return FALSE);
+  INPUT_2BYTES(cinfo, cinfo->image_height, return FALSE);
+  INPUT_2BYTES(cinfo, cinfo->image_width, return FALSE);
+  INPUT_BYTE(cinfo, cinfo->num_components, return FALSE);
+
+  length -= 8;
+
+  TRACEMS4(cinfo, 1, JTRC_SOF, cinfo->unread_marker,
+	   (int) cinfo->image_width, (int) cinfo->image_height,
+	   cinfo->num_components);
+
+  if (cinfo->marker->saw_SOF)
+    ERREXIT(cinfo, JERR_SOF_DUPLICATE);
+
+  /* We don't support files in which the image height is initially specified */
+  /* as 0 and is later redefined by DNL.  As long as we have to check that,  */
+  /* might as well have a general sanity check. */
+  if (cinfo->image_height <= 0 || cinfo->image_width <= 0
+      || cinfo->num_components <= 0)
+    ERREXIT(cinfo, JERR_EMPTY_IMAGE);
+
+  if (length != (cinfo->num_components * 3))
+    ERREXIT(cinfo, JERR_BAD_LENGTH);
+
+  if (cinfo->comp_info == NULL)	/* do only once, even if suspend */
+    cinfo->comp_info = (jpeg_component_info *) (*cinfo->mem->alloc_small)
+			((j_common_ptr) cinfo, JPOOL_IMAGE,
+			 cinfo->num_components * SIZEOF(jpeg_component_info));
+  
+  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+       ci++, compptr++) {
+    compptr->component_index = ci;
+    INPUT_BYTE(cinfo, compptr->component_id, return FALSE);
+    INPUT_BYTE(cinfo, c, return FALSE);
+    compptr->h_samp_factor = (c >> 4) & 15;
+    compptr->v_samp_factor = (c     ) & 15;
+    INPUT_BYTE(cinfo, compptr->quant_tbl_no, return FALSE);
+
+    TRACEMS4(cinfo, 1, JTRC_SOF_COMPONENT,
+	     compptr->component_id, compptr->h_samp_factor,
+	     compptr->v_samp_factor, compptr->quant_tbl_no);
+  }
+
+  cinfo->marker->saw_SOF = TRUE;
+
+  INPUT_SYNC(cinfo);
+  return TRUE;
+}
+
+
+LOCAL boolean
+get_sos (j_decompress_ptr cinfo)
+/* Process a SOS marker */
+{
+  INT32 length;
+  int i, ci, n, c, cc;
+  jpeg_component_info * compptr;
+  INPUT_VARS(cinfo);
+
+  if (! cinfo->marker->saw_SOF)
+    ERREXIT(cinfo, JERR_SOS_NO_SOF);
+
+  INPUT_2BYTES(cinfo, length, return FALSE);
+
+  INPUT_BYTE(cinfo, n, return FALSE); /* Number of components */
+
+  if (length != (n * 2 + 6) || n < 1 || n > MAX_COMPS_IN_SCAN)
+    ERREXIT(cinfo, JERR_BAD_LENGTH);
+
+  TRACEMS1(cinfo, 1, JTRC_SOS, n);
+
+  cinfo->comps_in_scan = n;
+
+  /* Collect the component-spec parameters */
+
+  for (i = 0; i < n; i++) {
+    INPUT_BYTE(cinfo, cc, return FALSE);
+    INPUT_BYTE(cinfo, c, return FALSE);
+    
+    for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+	 ci++, compptr++) {
+      if (cc == compptr->component_id)
+	goto id_found;
+    }
+
+    ERREXIT1(cinfo, JERR_BAD_COMPONENT_ID, cc);
+
+  id_found:
+
+    cinfo->cur_comp_info[i] = compptr;
+    compptr->dc_tbl_no = (c >> 4) & 15;
+    compptr->ac_tbl_no = (c     ) & 15;
+    
+    TRACEMS3(cinfo, 1, JTRC_SOS_COMPONENT, cc,
+	     compptr->dc_tbl_no, compptr->ac_tbl_no);
+  }
+
+  /* Collect the additional scan parameters Ss, Se, Ah/Al. */
+  INPUT_BYTE(cinfo, c, return FALSE);
+  cinfo->Ss = c;
+  INPUT_BYTE(cinfo, c, return FALSE);
+  cinfo->Se = c;
+  INPUT_BYTE(cinfo, c, return FALSE);
+  cinfo->Ah = (c >> 4) & 15;
+  cinfo->Al = (c     ) & 15;
+
+  TRACEMS4(cinfo, 1, JTRC_SOS_PARAMS, cinfo->Ss, cinfo->Se,
+	   cinfo->Ah, cinfo->Al);
+
+  /* Prepare to scan data & restart markers */
+  cinfo->marker->next_restart_num = 0;
+
+  /* Count another SOS marker */
+  cinfo->input_scan_number++;
+
+  INPUT_SYNC(cinfo);
+  return TRUE;
+}
+
+
+METHODDEF boolean
+get_app0 (j_decompress_ptr cinfo)
+/* Process an APP0 marker */
+{
+#define JFIF_LEN 14
+  INT32 length;
+  UINT8 b[JFIF_LEN];
+  int buffp;
+  INPUT_VARS(cinfo);
+
+  INPUT_2BYTES(cinfo, length, return FALSE);
+  length -= 2;
+
+  /* See if a JFIF APP0 marker is present */
+
+  if (length >= JFIF_LEN) {
+    for (buffp = 0; buffp < JFIF_LEN; buffp++)
+      INPUT_BYTE(cinfo, b[buffp], return FALSE);
+    length -= JFIF_LEN;
+
+    if (b[0]==0x4A && b[1]==0x46 && b[2]==0x49 && b[3]==0x46 && b[4]==0) {
+      /* Found JFIF APP0 marker: check version */
+      /* Major version must be 1, anything else signals an incompatible change.
+       * We used to treat this as an error, but now it's a nonfatal warning,
+       * because some bozo at Hijaak couldn't read the spec.
+       * Minor version should be 0..2, but process anyway if newer.
+       */
+      if (b[5] != 1)
+	WARNMS2(cinfo, JWRN_JFIF_MAJOR, b[5], b[6]);
+      else if (b[6] > 2)
+	TRACEMS2(cinfo, 1, JTRC_JFIF_MINOR, b[5], b[6]);
+      /* Save info */
+      cinfo->saw_JFIF_marker = TRUE;
+      cinfo->density_unit = b[7];
+      cinfo->X_density = (b[8] << 8) + b[9];
+      cinfo->Y_density = (b[10] << 8) + b[11];
+      TRACEMS3(cinfo, 1, JTRC_JFIF,
+	       cinfo->X_density, cinfo->Y_density, cinfo->density_unit);
+      if (b[12] | b[13])
+	TRACEMS2(cinfo, 1, JTRC_JFIF_THUMBNAIL, b[12], b[13]);
+      if (length != ((INT32) b[12] * (INT32) b[13] * (INT32) 3))
+	TRACEMS1(cinfo, 1, JTRC_JFIF_BADTHUMBNAILSIZE, (int) length);
+    } else {
+      /* Start of APP0 does not match "JFIF" */
+      TRACEMS1(cinfo, 1, JTRC_APP0, (int) length + JFIF_LEN);
+    }
+  } else {
+    /* Too short to be JFIF marker */
+    TRACEMS1(cinfo, 1, JTRC_APP0, (int) length);
+  }
+
+  INPUT_SYNC(cinfo);
+  if (length > 0)		/* skip any remaining data -- could be lots */
+    (*cinfo->src->skip_input_data) (cinfo, (long) length);
+
+  return TRUE;
+}
+
+
+METHODDEF boolean
+get_app14 (j_decompress_ptr cinfo)
+/* Process an APP14 marker */
+{
+#define ADOBE_LEN 12
+  INT32 length;
+  UINT8 b[ADOBE_LEN];
+  int buffp;
+  unsigned int version, flags0, flags1, transform;
+  INPUT_VARS(cinfo);
+
+  INPUT_2BYTES(cinfo, length, return FALSE);
+  length -= 2;
+
+  /* See if an Adobe APP14 marker is present */
+
+  if (length >= ADOBE_LEN) {
+    for (buffp = 0; buffp < ADOBE_LEN; buffp++)
+      INPUT_BYTE(cinfo, b[buffp], return FALSE);
+    length -= ADOBE_LEN;
+
+    if (b[0]==0x41 && b[1]==0x64 && b[2]==0x6F && b[3]==0x62 && b[4]==0x65) {
+      /* Found Adobe APP14 marker */
+      version = (b[5] << 8) + b[6];
+      flags0 = (b[7] << 8) + b[8];
+      flags1 = (b[9] << 8) + b[10];
+      transform = b[11];
+      TRACEMS4(cinfo, 1, JTRC_ADOBE, version, flags0, flags1, transform);
+      cinfo->saw_Adobe_marker = TRUE;
+      cinfo->Adobe_transform = (UINT8) transform;
+    } else {
+      /* Start of APP14 does not match "Adobe" */
+      TRACEMS1(cinfo, 1, JTRC_APP14, (int) length + ADOBE_LEN);
+    }
+  } else {
+    /* Too short to be Adobe marker */
+    TRACEMS1(cinfo, 1, JTRC_APP14, (int) length);
+  }
+
+  INPUT_SYNC(cinfo);
+  if (length > 0)		/* skip any remaining data -- could be lots */
+    (*cinfo->src->skip_input_data) (cinfo, (long) length);
+
+  return TRUE;
+}
+
+
+LOCAL boolean
+get_dac (j_decompress_ptr cinfo)
+/* Process a DAC marker */
+{
+  INT32 length;
+  int index, val;
+  INPUT_VARS(cinfo);
+
+  INPUT_2BYTES(cinfo, length, return FALSE);
+  length -= 2;
+  
+  while (length > 0) {
+    INPUT_BYTE(cinfo, index, return FALSE);
+    INPUT_BYTE(cinfo, val, return FALSE);
+
+    length -= 2;
+
+    TRACEMS2(cinfo, 1, JTRC_DAC, index, val);
+
+    if (index < 0 || index >= (2*NUM_ARITH_TBLS))
+      ERREXIT1(cinfo, JERR_DAC_INDEX, index);
+
+    if (index >= NUM_ARITH_TBLS) { /* define AC table */
+      cinfo->arith_ac_K[index-NUM_ARITH_TBLS] = (UINT8) val;
+    } else {			/* define DC table */
+      cinfo->arith_dc_L[index] = (UINT8) (val & 0x0F);
+      cinfo->arith_dc_U[index] = (UINT8) (val >> 4);
+      if (cinfo->arith_dc_L[index] > cinfo->arith_dc_U[index])
+	ERREXIT1(cinfo, JERR_DAC_VALUE, val);
+    }
+  }
+
+  INPUT_SYNC(cinfo);
+  return TRUE;
+}
+
+
+LOCAL boolean
+get_dht (j_decompress_ptr cinfo)
+/* Process a DHT marker */
+{
+  INT32 length;
+  UINT8 bits[17];
+  UINT8 huffval[256];
+  int i, index, count;
+  JHUFF_TBL **htblptr;
+  INPUT_VARS(cinfo);
+
+  INPUT_2BYTES(cinfo, length, return FALSE);
+  length -= 2;
+  
+  while (length > 0) {
+    INPUT_BYTE(cinfo, index, return FALSE);
+
+    TRACEMS1(cinfo, 1, JTRC_DHT, index);
+      
+    bits[0] = 0;
+    count = 0;
+    for (i = 1; i <= 16; i++) {
+      INPUT_BYTE(cinfo, bits[i], return FALSE);
+      count += bits[i];
+    }
+
+    length -= 1 + 16;
+
+    TRACEMS8(cinfo, 2, JTRC_HUFFBITS,
+	     bits[1], bits[2], bits[3], bits[4],
+	     bits[5], bits[6], bits[7], bits[8]);
+    TRACEMS8(cinfo, 2, JTRC_HUFFBITS,
+	     bits[9], bits[10], bits[11], bits[12],
+	     bits[13], bits[14], bits[15], bits[16]);
+
+    if (count > 256 || ((INT32) count) > length)
+      ERREXIT(cinfo, JERR_DHT_COUNTS);
+
+    for (i = 0; i < count; i++)
+      INPUT_BYTE(cinfo, huffval[i], return FALSE);
+
+    length -= count;
+
+    if (index & 0x10) {		/* AC table definition */
+      index -= 0x10;
+      htblptr = &cinfo->ac_huff_tbl_ptrs[index];
+    } else {			/* DC table definition */
+      htblptr = &cinfo->dc_huff_tbl_ptrs[index];
+    }
+
+    if (index < 0 || index >= NUM_HUFF_TBLS)
+      ERREXIT1(cinfo, JERR_DHT_INDEX, index);
+
+    if (*htblptr == NULL)
+      *htblptr = jpeg_alloc_huff_table((j_common_ptr) cinfo);
+  
+    MEMCOPY((*htblptr)->bits, bits, SIZEOF((*htblptr)->bits));
+    MEMCOPY((*htblptr)->huffval, huffval, SIZEOF((*htblptr)->huffval));
+  }
+
+  INPUT_SYNC(cinfo);
+  return TRUE;
+}
+
+
+LOCAL boolean
+get_dqt (j_decompress_ptr cinfo)
+/* Process a DQT marker */
+{
+  INT32 length;
+  int n, i, prec;
+  unsigned int tmp;
+  JQUANT_TBL *quant_ptr;
+  INPUT_VARS(cinfo);
+
+  INPUT_2BYTES(cinfo, length, return FALSE);
+  length -= 2;
+
+  while (length > 0) {
+    INPUT_BYTE(cinfo, n, return FALSE);
+    prec = n >> 4;
+    n &= 0x0F;
+
+    TRACEMS2(cinfo, 1, JTRC_DQT, n, prec);
+
+    if (n >= NUM_QUANT_TBLS)
+      ERREXIT1(cinfo, JERR_DQT_INDEX, n);
+      
+    if (cinfo->quant_tbl_ptrs[n] == NULL)
+      cinfo->quant_tbl_ptrs[n] = jpeg_alloc_quant_table((j_common_ptr) cinfo);
+    quant_ptr = cinfo->quant_tbl_ptrs[n];
+
+    for (i = 0; i < DCTSIZE2; i++) {
+      if (prec)
+	INPUT_2BYTES(cinfo, tmp, return FALSE);
+      else
+	INPUT_BYTE(cinfo, tmp, return FALSE);
+      quant_ptr->quantval[i] = (UINT16) tmp;
+    }
+
+    for (i = 0; i < DCTSIZE2; i += 8) {
+      TRACEMS8(cinfo, 2, JTRC_QUANTVALS,
+	       quant_ptr->quantval[i  ], quant_ptr->quantval[i+1],
+	       quant_ptr->quantval[i+2], quant_ptr->quantval[i+3],
+	       quant_ptr->quantval[i+4], quant_ptr->quantval[i+5],
+	       quant_ptr->quantval[i+6], quant_ptr->quantval[i+7]);
+    }
+
+    length -= DCTSIZE2+1;
+    if (prec) length -= DCTSIZE2;
+  }
+
+  INPUT_SYNC(cinfo);
+  return TRUE;
+}
+
+
+LOCAL boolean
+get_dri (j_decompress_ptr cinfo)
+/* Process a DRI marker */
+{
+  INT32 length;
+  unsigned int tmp;
+  INPUT_VARS(cinfo);
+
+  INPUT_2BYTES(cinfo, length, return FALSE);
+  
+  if (length != 4)
+    ERREXIT(cinfo, JERR_BAD_LENGTH);
+
+  INPUT_2BYTES(cinfo, tmp, return FALSE);
+
+  TRACEMS1(cinfo, 1, JTRC_DRI, tmp);
+
+  cinfo->restart_interval = tmp;
+
+  INPUT_SYNC(cinfo);
+  return TRUE;
+}
+
+
+METHODDEF boolean
+skip_variable (j_decompress_ptr cinfo)
+/* Skip over an unknown or uninteresting variable-length marker */
+{
+  INT32 length;
+  INPUT_VARS(cinfo);
+
+  INPUT_2BYTES(cinfo, length, return FALSE);
+  
+  TRACEMS2(cinfo, 1, JTRC_MISC_MARKER, cinfo->unread_marker, (int) length);
+
+  INPUT_SYNC(cinfo);		/* do before skip_input_data */
+  (*cinfo->src->skip_input_data) (cinfo, (long) length - 2L);
+
+  return TRUE;
+}
+
+
+/*
+ * Find the next JPEG marker, save it in cinfo->unread_marker.
+ * Returns FALSE if had to suspend before reaching a marker;
+ * in that case cinfo->unread_marker is unchanged.
+ *
+ * Note that the result might not be a valid marker code,
+ * but it will never be 0 or FF.
+ */
+
+LOCAL boolean
+next_marker (j_decompress_ptr cinfo)
+{
+  int c;
+  INPUT_VARS(cinfo);
+
+  for (;;) {
+    INPUT_BYTE(cinfo, c, return FALSE);
+    /* Skip any non-FF bytes.
+     * This may look a bit inefficient, but it will not occur in a valid file.
+     * We sync after each discarded byte so that a suspending data source
+     * can discard the byte from its buffer.
+     */
+    while (c != 0xFF) {
+      cinfo->marker->discarded_bytes++;
+      INPUT_SYNC(cinfo);
+      INPUT_BYTE(cinfo, c, return FALSE);
+    }
+    /* This loop swallows any duplicate FF bytes.  Extra FFs are legal as
+     * pad bytes, so don't count them in discarded_bytes.  We assume there
+     * will not be so many consecutive FF bytes as to overflow a suspending
+     * data source's input buffer.
+     */
+    do {
+      INPUT_BYTE(cinfo, c, return FALSE);
+    } while (c == 0xFF);
+    if (c != 0)
+      break;			/* found a valid marker, exit loop */
+    /* Reach here if we found a stuffed-zero data sequence (FF/00).
+     * Discard it and loop back to try again.
+     */
+    cinfo->marker->discarded_bytes += 2;
+    INPUT_SYNC(cinfo);
+  }
+
+  if (cinfo->marker->discarded_bytes != 0) {
+    WARNMS2(cinfo, JWRN_EXTRANEOUS_DATA, cinfo->marker->discarded_bytes, c);
+    cinfo->marker->discarded_bytes = 0;
+  }
+
+  cinfo->unread_marker = c;
+
+  INPUT_SYNC(cinfo);
+  return TRUE;
+}
+
+
+LOCAL boolean
+first_marker (j_decompress_ptr cinfo)
+/* Like next_marker, but used to obtain the initial SOI marker. */
+/* For this marker, we do not allow preceding garbage or fill; otherwise,
+ * we might well scan an entire input file before realizing it ain't JPEG.
+ * If an application wants to process non-JFIF files, it must seek to the
+ * SOI before calling the JPEG library.
+ */
+{
+  int c, c2;
+  INPUT_VARS(cinfo);
+
+  INPUT_BYTE(cinfo, c, return FALSE);
+  INPUT_BYTE(cinfo, c2, return FALSE);
+  if (c != 0xFF || c2 != (int) M_SOI)
+    ERREXIT2(cinfo, JERR_NO_SOI, c, c2);
+
+  cinfo->unread_marker = c2;
+
+  INPUT_SYNC(cinfo);
+  return TRUE;
+}
+
+
+/*
+ * Read markers until SOS or EOI.
+ *
+ * Returns same codes as are defined for jpeg_consume_input:
+ * JPEG_SUSPENDED, JPEG_REACHED_SOS, or JPEG_REACHED_EOI.
+ */
+
+METHODDEF int
+read_markers (j_decompress_ptr cinfo)
+{
+  /* Outer loop repeats once for each marker. */
+  for (;;) {
+    /* Collect the marker proper, unless we already did. */
+    /* NB: first_marker() enforces the requirement that SOI appear first. */
+    if (cinfo->unread_marker == 0) {
+      if (! cinfo->marker->saw_SOI) {
+	if (! first_marker(cinfo))
+	  return JPEG_SUSPENDED;
+      } else {
+	if (! next_marker(cinfo))
+	  return JPEG_SUSPENDED;
+      }
+    }
+    /* At this point cinfo->unread_marker contains the marker code and the
+     * input point is just past the marker proper, but before any parameters.
+     * A suspension will cause us to return with this state still true.
+     */
+    switch (cinfo->unread_marker) {
+    case M_SOI:
+      if (! get_soi(cinfo))
+	return JPEG_SUSPENDED;
+      break;
+
+    case M_SOF0:		/* Baseline */
+    case M_SOF1:		/* Extended sequential, Huffman */
+      if (! get_sof(cinfo, FALSE, FALSE))
+	return JPEG_SUSPENDED;
+      break;
+
+    case M_SOF2:		/* Progressive, Huffman */
+      if (! get_sof(cinfo, TRUE, FALSE))
+	return JPEG_SUSPENDED;
+      break;
+
+    case M_SOF9:		/* Extended sequential, arithmetic */
+      if (! get_sof(cinfo, FALSE, TRUE))
+	return JPEG_SUSPENDED;
+      break;
+
+    case M_SOF10:		/* Progressive, arithmetic */
+      if (! get_sof(cinfo, TRUE, TRUE))
+	return JPEG_SUSPENDED;
+      break;
+
+    /* Currently unsupported SOFn types */
+    case M_SOF3:		/* Lossless, Huffman */
+    case M_SOF5:		/* Differential sequential, Huffman */
+    case M_SOF6:		/* Differential progressive, Huffman */
+    case M_SOF7:		/* Differential lossless, Huffman */
+    case M_JPG:			/* Reserved for JPEG extensions */
+    case M_SOF11:		/* Lossless, arithmetic */
+    case M_SOF13:		/* Differential sequential, arithmetic */
+    case M_SOF14:		/* Differential progressive, arithmetic */
+    case M_SOF15:		/* Differential lossless, arithmetic */
+      ERREXIT1(cinfo, JERR_SOF_UNSUPPORTED, cinfo->unread_marker);
+      break;
+
+    case M_SOS:
+      if (! get_sos(cinfo))
+	return JPEG_SUSPENDED;
+      cinfo->unread_marker = 0;	/* processed the marker */
+      return JPEG_REACHED_SOS;
+    
+    case M_EOI:
+      TRACEMS(cinfo, 1, JTRC_EOI);
+      cinfo->unread_marker = 0;	/* processed the marker */
+      return JPEG_REACHED_EOI;
+      
+    case M_DAC:
+      if (! get_dac(cinfo))
+	return JPEG_SUSPENDED;
+      break;
+      
+    case M_DHT:
+      if (! get_dht(cinfo))
+	return JPEG_SUSPENDED;
+      break;
+      
+    case M_DQT:
+      if (! get_dqt(cinfo))
+	return JPEG_SUSPENDED;
+      break;
+      
+    case M_DRI:
+      if (! get_dri(cinfo))
+	return JPEG_SUSPENDED;
+      break;
+      
+    case M_APP0:
+    case M_APP1:
+    case M_APP2:
+    case M_APP3:
+    case M_APP4:
+    case M_APP5:
+    case M_APP6:
+    case M_APP7:
+    case M_APP8:
+    case M_APP9:
+    case M_APP10:
+    case M_APP11:
+    case M_APP12:
+    case M_APP13:
+    case M_APP14:
+    case M_APP15:
+      if (! (*cinfo->marker->process_APPn[cinfo->unread_marker - (int) M_APP0]) (cinfo))
+	return JPEG_SUSPENDED;
+      break;
+      
+    case M_COM:
+      if (! (*cinfo->marker->process_COM) (cinfo))
+	return JPEG_SUSPENDED;
+      break;
+
+    case M_RST0:		/* these are all parameterless */
+    case M_RST1:
+    case M_RST2:
+    case M_RST3:
+    case M_RST4:
+    case M_RST5:
+    case M_RST6:
+    case M_RST7:
+    case M_TEM:
+      TRACEMS1(cinfo, 1, JTRC_PARMLESS_MARKER, cinfo->unread_marker);
+      break;
+
+    case M_DNL:			/* Ignore DNL ... perhaps the wrong thing */
+      if (! skip_variable(cinfo))
+	return JPEG_SUSPENDED;
+      break;
+
+    default:			/* must be DHP, EXP, JPGn, or RESn */
+      /* For now, we treat the reserved markers as fatal errors since they are
+       * likely to be used to signal incompatible JPEG Part 3 extensions.
+       * Once the JPEG 3 version-number marker is well defined, this code
+       * ought to change!
+       */
+      ERREXIT1(cinfo, JERR_UNKNOWN_MARKER, cinfo->unread_marker);
+      break;
+    }
+    /* Successfully processed marker, so reset state variable */
+    cinfo->unread_marker = 0;
+  } /* end loop */
+}
+
+
+/*
+ * Read a restart marker, which is expected to appear next in the datastream;
+ * if the marker is not there, take appropriate recovery action.
+ * Returns FALSE if suspension is required.
+ *
+ * This is called by the entropy decoder after it has read an appropriate
+ * number of MCUs.  cinfo->unread_marker may be nonzero if the entropy decoder
+ * has already read a marker from the data source.  Under normal conditions
+ * cinfo->unread_marker will be reset to 0 before returning; if not reset,
+ * it holds a marker which the decoder will be unable to read past.
+ */
+
+METHODDEF boolean
+read_restart_marker (j_decompress_ptr cinfo)
+{
+  /* Obtain a marker unless we already did. */
+  /* Note that next_marker will complain if it skips any data. */
+  if (cinfo->unread_marker == 0) {
+    if (! next_marker(cinfo))
+      return FALSE;
+  }
+
+  if (cinfo->unread_marker ==
+      ((int) M_RST0 + cinfo->marker->next_restart_num)) {
+    /* Normal case --- swallow the marker and let entropy decoder continue */
+    TRACEMS1(cinfo, 2, JTRC_RST, cinfo->marker->next_restart_num);
+    cinfo->unread_marker = 0;
+  } else {
+    /* Uh-oh, the restart markers have been messed up. */
+    /* Let the data source manager determine how to resync. */
+    if (! (*cinfo->src->resync_to_restart) (cinfo,
+					    cinfo->marker->next_restart_num))
+      return FALSE;
+  }
+
+  /* Update next-restart state */
+  cinfo->marker->next_restart_num = (cinfo->marker->next_restart_num + 1) & 7;
+
+  return TRUE;
+}
+
+
+/*
+ * This is the default resync_to_restart method for data source managers
+ * to use if they don't have any better approach.  Some data source managers
+ * may be able to back up, or may have additional knowledge about the data
+ * which permits a more intelligent recovery strategy; such managers would
+ * presumably supply their own resync method.
+ *
+ * read_restart_marker calls resync_to_restart if it finds a marker other than
+ * the restart marker it was expecting.  (This code is *not* used unless
+ * a nonzero restart interval has been declared.)  cinfo->unread_marker is
+ * the marker code actually found (might be anything, except 0 or FF).
+ * The desired restart marker number (0..7) is passed as a parameter.
+ * This routine is supposed to apply whatever error recovery strategy seems
+ * appropriate in order to position the input stream to the next data segment.
+ * Note that cinfo->unread_marker is treated as a marker appearing before
+ * the current data-source input point; usually it should be reset to zero
+ * before returning.
+ * Returns FALSE if suspension is required.
+ *
+ * This implementation is substantially constrained by wanting to treat the
+ * input as a data stream; this means we can't back up.  Therefore, we have
+ * only the following actions to work with:
+ *   1. Simply discard the marker and let the entropy decoder resume at next
+ *      byte of file.
+ *   2. Read forward until we find another marker, discarding intervening
+ *      data.  (In theory we could look ahead within the current bufferload,
+ *      without having to discard data if we don't find the desired marker.
+ *      This idea is not implemented here, in part because it makes behavior
+ *      dependent on buffer size and chance buffer-boundary positions.)
+ *   3. Leave the marker unread (by failing to zero cinfo->unread_marker).
+ *      This will cause the entropy decoder to process an empty data segment,
+ *      inserting dummy zeroes, and then we will reprocess the marker.
+ *
+ * #2 is appropriate if we think the desired marker lies ahead, while #3 is
+ * appropriate if the found marker is a future restart marker (indicating
+ * that we have missed the desired restart marker, probably because it got
+ * corrupted).
+ * We apply #2 or #3 if the found marker is a restart marker no more than
+ * two counts behind or ahead of the expected one.  We also apply #2 if the
+ * found marker is not a legal JPEG marker code (it's certainly bogus data).
+ * If the found marker is a restart marker more than 2 counts away, we do #1
+ * (too much risk that the marker is erroneous; with luck we will be able to
+ * resync at some future point).
+ * For any valid non-restart JPEG marker, we apply #3.  This keeps us from
+ * overrunning the end of a scan.  An implementation limited to single-scan
+ * files might find it better to apply #2 for markers other than EOI, since
+ * any other marker would have to be bogus data in that case.
+ */
+
+GLOBAL boolean
+jpeg_resync_to_restart (j_decompress_ptr cinfo, int desired)
+{
+  int marker = cinfo->unread_marker;
+  int action = 1;
+  
+  /* Always put up a warning. */
+  WARNMS2(cinfo, JWRN_MUST_RESYNC, marker, desired);
+  
+  /* Outer loop handles repeated decision after scanning forward. */
+  for (;;) {
+    if (marker < (int) M_SOF0)
+      action = 2;		/* invalid marker */
+    else if (marker < (int) M_RST0 || marker > (int) M_RST7)
+      action = 3;		/* valid non-restart marker */
+    else {
+      if (marker == ((int) M_RST0 + ((desired+1) & 7)) ||
+	  marker == ((int) M_RST0 + ((desired+2) & 7)))
+	action = 3;		/* one of the next two expected restarts */
+      else if (marker == ((int) M_RST0 + ((desired-1) & 7)) ||
+	       marker == ((int) M_RST0 + ((desired-2) & 7)))
+	action = 2;		/* a prior restart, so advance */
+      else
+	action = 1;		/* desired restart or too far away */
+    }
+    TRACEMS2(cinfo, 4, JTRC_RECOVERY_ACTION, marker, action);
+    switch (action) {
+    case 1:
+      /* Discard marker and let entropy decoder resume processing. */
+      cinfo->unread_marker = 0;
+      return TRUE;
+    case 2:
+      /* Scan to the next marker, and repeat the decision loop. */
+      if (! next_marker(cinfo))
+	return FALSE;
+      marker = cinfo->unread_marker;
+      break;
+    case 3:
+      /* Return without advancing past this marker. */
+      /* Entropy decoder will be forced to process an empty segment. */
+      return TRUE;
+    }
+  } /* end loop */
+}
+
+
+/*
+ * Reset marker processing state to begin a fresh datastream.
+ */
+
+METHODDEF void
+reset_marker_reader (j_decompress_ptr cinfo)
+{
+  cinfo->comp_info = NULL;		/* until allocated by get_sof */
+  cinfo->input_scan_number = 0;		/* no SOS seen yet */
+  cinfo->unread_marker = 0;		/* no pending marker */
+  cinfo->marker->saw_SOI = FALSE;	/* set internal state too */
+  cinfo->marker->saw_SOF = FALSE;
+  cinfo->marker->discarded_bytes = 0;
+}
+
+
+/*
+ * Initialize the marker reader module.
+ * This is called only once, when the decompression object is created.
+ */
+
+GLOBAL void
+jinit_marker_reader (j_decompress_ptr cinfo)
+{
+  int i;
+
+  /* Create subobject in permanent pool */
+  cinfo->marker = (struct jpeg_marker_reader *)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
+				SIZEOF(struct jpeg_marker_reader));
+  /* Initialize method pointers */
+  cinfo->marker->reset_marker_reader = reset_marker_reader;
+  cinfo->marker->read_markers = read_markers;
+  cinfo->marker->read_restart_marker = read_restart_marker;
+  cinfo->marker->process_COM = skip_variable;
+  for (i = 0; i < 16; i++)
+    cinfo->marker->process_APPn[i] = skip_variable;
+  cinfo->marker->process_APPn[0] = get_app0;
+  cinfo->marker->process_APPn[14] = get_app14;
+  /* Reset marker processing state */
+  reset_marker_reader(cinfo);
+}
diff --git a/code/jpeg-6/jdmaster.cpp b/code/jpeg-6/jdmaster.cpp
new file mode 100644
index 0000000..69d1edd
--- /dev/null
+++ b/code/jpeg-6/jdmaster.cpp
@@ -0,0 +1,562 @@
+/*
+ * jdmaster.c
+ *
+ * Copyright (C) 1991-1995, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains master control logic for the JPEG decompressor.
+ * These routines are concerned with selecting the modules to be executed
+ * and with determining the number of passes and the work to be done in each
+ * pass.
+ */
+
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/* Private state */
+
+typedef struct {
+  struct jpeg_decomp_master pub; /* public fields */
+
+  int pass_number;		/* # of passes completed */
+
+  boolean using_merged_upsample; /* TRUE if using merged upsample/cconvert */
+
+  /* Saved references to initialized quantizer modules,
+   * in case we need to switch modes.
+   */
+  struct jpeg_color_quantizer * quantizer_1pass;
+  struct jpeg_color_quantizer * quantizer_2pass;
+} my_decomp_master;
+
+typedef my_decomp_master * my_master_ptr;
+
+
+/*
+ * Determine whether merged upsample/color conversion should be used.
+ * CRUCIAL: this must match the actual capabilities of jdmerge.c!
+ */
+
+LOCAL boolean
+use_merged_upsample (j_decompress_ptr cinfo)
+{
+#ifdef UPSAMPLE_MERGING_SUPPORTED
+  /* Merging is the equivalent of plain box-filter upsampling */
+  if (cinfo->do_fancy_upsampling || cinfo->CCIR601_sampling)
+    return FALSE;
+  /* jdmerge.c only supports YCC=>RGB color conversion */
+  if (cinfo->jpeg_color_space != JCS_YCbCr || cinfo->num_components != 3 ||
+      cinfo->out_color_space != JCS_RGB ||
+      cinfo->out_color_components != RGB_PIXELSIZE)
+    return FALSE;
+  /* and it only handles 2h1v or 2h2v sampling ratios */
+  if (cinfo->comp_info[0].h_samp_factor != 2 ||
+      cinfo->comp_info[1].h_samp_factor != 1 ||
+      cinfo->comp_info[2].h_samp_factor != 1 ||
+      cinfo->comp_info[0].v_samp_factor >  2 ||
+      cinfo->comp_info[1].v_samp_factor != 1 ||
+      cinfo->comp_info[2].v_samp_factor != 1)
+    return FALSE;
+  /* furthermore, it doesn't work if we've scaled the IDCTs differently */
+  if (cinfo->comp_info[0].DCT_scaled_size != cinfo->min_DCT_scaled_size ||
+      cinfo->comp_info[1].DCT_scaled_size != cinfo->min_DCT_scaled_size ||
+      cinfo->comp_info[2].DCT_scaled_size != cinfo->min_DCT_scaled_size)
+    return FALSE;
+  /* ??? also need to test for upsample-time rescaling, when & if supported */
+  return TRUE;			/* by golly, it'll work... */
+#else
+  return FALSE;
+#endif
+}
+
+
+/*
+ * Compute output image dimensions and related values.
+ * NOTE: this is exported for possible use by application.
+ * Hence it mustn't do anything that can't be done twice.
+ * Also note that it may be called before the master module is initialized!
+ */
+
+GLOBAL void
+jpeg_calc_output_dimensions (j_decompress_ptr cinfo)
+/* Do computations that are needed before master selection phase */
+{
+#if 0	// JDC: commented out to remove warning
+  int ci;
+  jpeg_component_info *compptr;
+#endif
+
+  /* Prevent application from calling me at wrong times */
+  if (cinfo->global_state != DSTATE_READY)
+    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+
+#ifdef IDCT_SCALING_SUPPORTED
+
+  /* Compute actual output image dimensions and DCT scaling choices. */
+  if (cinfo->scale_num * 8 <= cinfo->scale_denom) {
+    /* Provide 1/8 scaling */
+    cinfo->output_width = (JDIMENSION)
+      jdiv_round_up((long) cinfo->image_width, 8L);
+    cinfo->output_height = (JDIMENSION)
+      jdiv_round_up((long) cinfo->image_height, 8L);
+    cinfo->min_DCT_scaled_size = 1;
+  } else if (cinfo->scale_num * 4 <= cinfo->scale_denom) {
+    /* Provide 1/4 scaling */
+    cinfo->output_width = (JDIMENSION)
+      jdiv_round_up((long) cinfo->image_width, 4L);
+    cinfo->output_height = (JDIMENSION)
+      jdiv_round_up((long) cinfo->image_height, 4L);
+    cinfo->min_DCT_scaled_size = 2;
+  } else if (cinfo->scale_num * 2 <= cinfo->scale_denom) {
+    /* Provide 1/2 scaling */
+    cinfo->output_width = (JDIMENSION)
+      jdiv_round_up((long) cinfo->image_width, 2L);
+    cinfo->output_height = (JDIMENSION)
+      jdiv_round_up((long) cinfo->image_height, 2L);
+    cinfo->min_DCT_scaled_size = 4;
+  } else {
+    /* Provide 1/1 scaling */
+    cinfo->output_width = cinfo->image_width;
+    cinfo->output_height = cinfo->image_height;
+    cinfo->min_DCT_scaled_size = DCTSIZE;
+  }
+  /* In selecting the actual DCT scaling for each component, we try to
+   * scale up the chroma components via IDCT scaling rather than upsampling.
+   * This saves time if the upsampler gets to use 1:1 scaling.
+   * Note this code assumes that the supported DCT scalings are powers of 2.
+   */
+  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+       ci++, compptr++) {
+    int ssize = cinfo->min_DCT_scaled_size;
+    while (ssize < DCTSIZE &&
+	   (compptr->h_samp_factor * ssize * 2 <=
+	    cinfo->max_h_samp_factor * cinfo->min_DCT_scaled_size) &&
+	   (compptr->v_samp_factor * ssize * 2 <=
+	    cinfo->max_v_samp_factor * cinfo->min_DCT_scaled_size)) {
+      ssize = ssize * 2;
+    }
+    compptr->DCT_scaled_size = ssize;
+  }
+
+  /* Recompute downsampled dimensions of components;
+   * application needs to know these if using raw downsampled data.
+   */
+  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+       ci++, compptr++) {
+    /* Size in samples, after IDCT scaling */
+    compptr->downsampled_width = (JDIMENSION)
+      jdiv_round_up((long) cinfo->image_width *
+		    (long) (compptr->h_samp_factor * compptr->DCT_scaled_size),
+		    (long) (cinfo->max_h_samp_factor * DCTSIZE));
+    compptr->downsampled_height = (JDIMENSION)
+      jdiv_round_up((long) cinfo->image_height *
+		    (long) (compptr->v_samp_factor * compptr->DCT_scaled_size),
+		    (long) (cinfo->max_v_samp_factor * DCTSIZE));
+  }
+
+#else /* !IDCT_SCALING_SUPPORTED */
+
+  /* Hardwire it to "no scaling" */
+  cinfo->output_width = cinfo->image_width;
+  cinfo->output_height = cinfo->image_height;
+  /* jdinput.c has already initialized DCT_scaled_size to DCTSIZE,
+   * and has computed unscaled downsampled_width and downsampled_height.
+   */
+
+#endif /* IDCT_SCALING_SUPPORTED */
+
+  /* Report number of components in selected colorspace. */
+  /* Probably this should be in the color conversion module... */
+  switch (cinfo->out_color_space) {
+  case JCS_GRAYSCALE:
+    cinfo->out_color_components = 1;
+    break;
+  case JCS_RGB:
+#if RGB_PIXELSIZE != 3
+    cinfo->out_color_components = RGB_PIXELSIZE;
+    break;
+#endif /* else share code with YCbCr */
+  case JCS_YCbCr:
+    cinfo->out_color_components = 3;
+    break;
+  case JCS_CMYK:
+  case JCS_YCCK:
+    cinfo->out_color_components = 4;
+    break;
+  default:			/* else must be same colorspace as in file */
+    cinfo->out_color_components = cinfo->num_components;
+    break;
+  }
+  cinfo->output_components = (cinfo->quantize_colors ? 1 :
+			      cinfo->out_color_components);
+
+  /* See if upsampler will want to emit more than one row at a time */
+  if (use_merged_upsample(cinfo))
+    cinfo->rec_outbuf_height = cinfo->max_v_samp_factor;
+  else
+    cinfo->rec_outbuf_height = 1;
+}
+
+
+/*
+ * Several decompression processes need to range-limit values to the range
+ * 0..MAXJSAMPLE; the input value may fall somewhat outside this range
+ * due to noise introduced by quantization, roundoff error, etc.  These
+ * processes are inner loops and need to be as fast as possible.  On most
+ * machines, particularly CPUs with pipelines or instruction prefetch,
+ * a (subscript-check-less) C table lookup
+ *		x = sample_range_limit[x];
+ * is faster than explicit tests
+ *		if (x < 0)  x = 0;
+ *		else if (x > MAXJSAMPLE)  x = MAXJSAMPLE;
+ * These processes all use a common table prepared by the routine below.
+ *
+ * For most steps we can mathematically guarantee that the initial value
+ * of x is within MAXJSAMPLE+1 of the legal range, so a table running from
+ * -(MAXJSAMPLE+1) to 2*MAXJSAMPLE+1 is sufficient.  But for the initial
+ * limiting step (just after the IDCT), a wildly out-of-range value is 
+ * possible if the input data is corrupt.  To avoid any chance of indexing
+ * off the end of memory and getting a bad-pointer trap, we perform the
+ * post-IDCT limiting thus:
+ *		x = range_limit[x & MASK];
+ * where MASK is 2 bits wider than legal sample data, ie 10 bits for 8-bit
+ * samples.  Under normal circumstances this is more than enough range and
+ * a correct output will be generated; with bogus input data the mask will
+ * cause wraparound, and we will safely generate a bogus-but-in-range output.
+ * For the post-IDCT step, we want to convert the data from signed to unsigned
+ * representation by adding CENTERJSAMPLE at the same time that we limit it.
+ * So the post-IDCT limiting table ends up looking like this:
+ *   CENTERJSAMPLE,CENTERJSAMPLE+1,...,MAXJSAMPLE,
+ *   MAXJSAMPLE (repeat 2*(MAXJSAMPLE+1)-CENTERJSAMPLE times),
+ *   0          (repeat 2*(MAXJSAMPLE+1)-CENTERJSAMPLE times),
+ *   0,1,...,CENTERJSAMPLE-1
+ * Negative inputs select values from the upper half of the table after
+ * masking.
+ *
+ * We can save some space by overlapping the start of the post-IDCT table
+ * with the simpler range limiting table.  The post-IDCT table begins at
+ * sample_range_limit + CENTERJSAMPLE.
+ *
+ * Note that the table is allocated in near data space on PCs; it's small
+ * enough and used often enough to justify this.
+ */
+
+LOCAL void
+prepare_range_limit_table (j_decompress_ptr cinfo)
+/* Allocate and fill in the sample_range_limit table */
+{
+  JSAMPLE * table;
+  int i;
+
+  table = (JSAMPLE *)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+		(5 * (MAXJSAMPLE+1) + CENTERJSAMPLE) * SIZEOF(JSAMPLE));
+  table += (MAXJSAMPLE+1);	/* allow negative subscripts of simple table */
+  cinfo->sample_range_limit = table;
+  /* First segment of "simple" table: limit[x] = 0 for x < 0 */
+  MEMZERO(table - (MAXJSAMPLE+1), (MAXJSAMPLE+1) * SIZEOF(JSAMPLE));
+  /* Main part of "simple" table: limit[x] = x */
+  for (i = 0; i <= MAXJSAMPLE; i++)
+    table[i] = (JSAMPLE) i;
+  table += CENTERJSAMPLE;	/* Point to where post-IDCT table starts */
+  /* End of simple table, rest of first half of post-IDCT table */
+  for (i = CENTERJSAMPLE; i < 2*(MAXJSAMPLE+1); i++)
+    table[i] = MAXJSAMPLE;
+  /* Second half of post-IDCT table */
+  MEMZERO(table + (2 * (MAXJSAMPLE+1)),
+	  (2 * (MAXJSAMPLE+1) - CENTERJSAMPLE) * SIZEOF(JSAMPLE));
+  MEMCOPY(table + (4 * (MAXJSAMPLE+1) - CENTERJSAMPLE),
+	  cinfo->sample_range_limit, CENTERJSAMPLE * SIZEOF(JSAMPLE));
+}
+
+
+/*
+ * Master selection of decompression modules.
+ * This is done once at jpeg_start_decompress time.  We determine
+ * which modules will be used and give them appropriate initialization calls.
+ * We also initialize the decompressor input side to begin consuming data.
+ *
+ * Since jpeg_read_header has finished, we know what is in the SOF
+ * and (first) SOS markers.  We also have all the application parameter
+ * settings.
+ */
+
+LOCAL void
+master_selection (j_decompress_ptr cinfo)
+{
+  my_master_ptr master = (my_master_ptr) cinfo->master;
+  boolean use_c_buffer;
+  long samplesperrow;
+  JDIMENSION jd_samplesperrow;
+
+  /* Initialize dimensions and other stuff */
+  jpeg_calc_output_dimensions(cinfo);
+  prepare_range_limit_table(cinfo);
+
+  /* Width of an output scanline must be representable as JDIMENSION. */
+  samplesperrow = (long) cinfo->output_width * (long) cinfo->out_color_components;
+  jd_samplesperrow = (JDIMENSION) samplesperrow;
+  if ((long) jd_samplesperrow != samplesperrow)
+    ERREXIT(cinfo, JERR_WIDTH_OVERFLOW);
+
+  /* Initialize my private state */
+  master->pass_number = 0;
+  master->using_merged_upsample = use_merged_upsample(cinfo);
+
+  /* Color quantizer selection */
+  master->quantizer_1pass = NULL;
+  master->quantizer_2pass = NULL;
+  /* No mode changes if not using buffered-image mode. */
+  if (! cinfo->quantize_colors || ! cinfo->buffered_image) {
+    cinfo->enable_1pass_quant = FALSE;
+    cinfo->enable_external_quant = FALSE;
+    cinfo->enable_2pass_quant = FALSE;
+  }
+  if (cinfo->quantize_colors) {
+    if (cinfo->raw_data_out)
+      ERREXIT(cinfo, JERR_NOTIMPL);
+    /* 2-pass quantizer only works in 3-component color space. */
+    if (cinfo->out_color_components != 3) {
+      cinfo->enable_1pass_quant = TRUE;
+      cinfo->enable_external_quant = FALSE;
+      cinfo->enable_2pass_quant = FALSE;
+      cinfo->colormap = NULL;
+    } else if (cinfo->colormap != NULL) {
+      cinfo->enable_external_quant = TRUE;
+    } else if (cinfo->two_pass_quantize) {
+      cinfo->enable_2pass_quant = TRUE;
+    } else {
+      cinfo->enable_1pass_quant = TRUE;
+    }
+
+    if (cinfo->enable_1pass_quant) {
+#ifdef QUANT_1PASS_SUPPORTED
+      jinit_1pass_quantizer(cinfo);
+      master->quantizer_1pass = cinfo->cquantize;
+#else
+      ERREXIT(cinfo, JERR_NOT_COMPILED);
+#endif
+    }
+
+    /* We use the 2-pass code to map to external colormaps. */
+    if (cinfo->enable_2pass_quant || cinfo->enable_external_quant) {
+#ifdef QUANT_2PASS_SUPPORTED
+      jinit_2pass_quantizer(cinfo);
+      master->quantizer_2pass = cinfo->cquantize;
+#else
+      ERREXIT(cinfo, JERR_NOT_COMPILED);
+#endif
+    }
+    /* If both quantizers are initialized, the 2-pass one is left active;
+     * this is necessary for starting with quantization to an external map.
+     */
+  }
+
+  /* Post-processing: in particular, color conversion first */
+  if (! cinfo->raw_data_out) {
+    if (master->using_merged_upsample) {
+#ifdef UPSAMPLE_MERGING_SUPPORTED
+      jinit_merged_upsampler(cinfo); /* does color conversion too */
+#else
+      ERREXIT(cinfo, JERR_NOT_COMPILED);
+#endif
+    } else {
+      jinit_color_deconverter(cinfo);
+      jinit_upsampler(cinfo);
+    }
+    jinit_d_post_controller(cinfo, cinfo->enable_2pass_quant);
+  }
+  /* Inverse DCT */
+  jinit_inverse_dct(cinfo);
+  /* Entropy decoding: either Huffman or arithmetic coding. */
+  if (cinfo->arith_code) {
+    ERREXIT(cinfo, JERR_ARITH_NOTIMPL);
+  } else {
+    if (cinfo->progressive_mode) {
+#ifdef D_PROGRESSIVE_SUPPORTED
+      jinit_phuff_decoder(cinfo);
+#else
+      ERREXIT(cinfo, JERR_NOT_COMPILED);
+#endif
+    } else
+      jinit_huff_decoder(cinfo);
+  }
+
+  /* Initialize principal buffer controllers. */
+  use_c_buffer = cinfo->inputctl->has_multiple_scans || cinfo->buffered_image;
+  jinit_d_coef_controller(cinfo, use_c_buffer);
+
+  if (! cinfo->raw_data_out)
+    jinit_d_main_controller(cinfo, FALSE /* never need full buffer here */);
+
+  /* We can now tell the memory manager to allocate virtual arrays. */
+  (*cinfo->mem->realize_virt_arrays) ((j_common_ptr) cinfo);
+
+  /* Initialize input side of decompressor to consume first scan. */
+  (*cinfo->inputctl->start_input_pass) (cinfo);
+
+#ifdef D_MULTISCAN_FILES_SUPPORTED
+  /* If jpeg_start_decompress will read the whole file, initialize
+   * progress monitoring appropriately.  The input step is counted
+   * as one pass.
+   */
+  if (cinfo->progress != NULL && ! cinfo->buffered_image &&
+      cinfo->inputctl->has_multiple_scans) {
+    int nscans;
+    /* Estimate number of scans to set pass_limit. */
+    if (cinfo->progressive_mode) {
+      /* Arbitrarily estimate 2 interleaved DC scans + 3 AC scans/component. */
+      nscans = 2 + 3 * cinfo->num_components;
+    } else {
+      /* For a nonprogressive multiscan file, estimate 1 scan per component. */
+      nscans = cinfo->num_components;
+    }
+    cinfo->progress->pass_counter = 0L;
+    cinfo->progress->pass_limit = (long) cinfo->total_iMCU_rows * nscans;
+    cinfo->progress->completed_passes = 0;
+    cinfo->progress->total_passes = (cinfo->enable_2pass_quant ? 3 : 2);
+    /* Count the input pass as done */
+    master->pass_number++;
+  }
+#endif /* D_MULTISCAN_FILES_SUPPORTED */
+}
+
+
+/*
+ * Per-pass setup.
+ * This is called at the beginning of each output pass.  We determine which
+ * modules will be active during this pass and give them appropriate
+ * start_pass calls.  We also set is_dummy_pass to indicate whether this
+ * is a "real" output pass or a dummy pass for color quantization.
+ * (In the latter case, jdapi.c will crank the pass to completion.)
+ */
+
+METHODDEF void
+prepare_for_output_pass (j_decompress_ptr cinfo)
+{
+  my_master_ptr master = (my_master_ptr) cinfo->master;
+
+  if (master->pub.is_dummy_pass) {
+#ifdef QUANT_2PASS_SUPPORTED
+    /* Final pass of 2-pass quantization */
+    master->pub.is_dummy_pass = FALSE;
+    (*cinfo->cquantize->start_pass) (cinfo, FALSE);
+    (*cinfo->post->start_pass) (cinfo, JBUF_CRANK_DEST);
+    (*cinfo->main->start_pass) (cinfo, JBUF_CRANK_DEST);
+#else
+    ERREXIT(cinfo, JERR_NOT_COMPILED);
+#endif /* QUANT_2PASS_SUPPORTED */
+  } else {
+    if (cinfo->quantize_colors && cinfo->colormap == NULL) {
+      /* Select new quantization method */
+      if (cinfo->two_pass_quantize && cinfo->enable_2pass_quant) {
+	cinfo->cquantize = master->quantizer_2pass;
+	master->pub.is_dummy_pass = TRUE;
+      } else if (cinfo->enable_1pass_quant) {
+	cinfo->cquantize = master->quantizer_1pass;
+      } else {
+	ERREXIT(cinfo, JERR_MODE_CHANGE);
+      }
+    }
+    (*cinfo->idct->start_pass) (cinfo);
+    (*cinfo->coef->start_output_pass) (cinfo);
+    if (! cinfo->raw_data_out) {
+      if (! master->using_merged_upsample)
+	(*cinfo->cconvert->start_pass) (cinfo);
+      (*cinfo->upsample->start_pass) (cinfo);
+      if (cinfo->quantize_colors)
+	(*cinfo->cquantize->start_pass) (cinfo, master->pub.is_dummy_pass);
+      (*cinfo->post->start_pass) (cinfo,
+	    (master->pub.is_dummy_pass ? JBUF_SAVE_AND_PASS : JBUF_PASS_THRU));
+      (*cinfo->main->start_pass) (cinfo, JBUF_PASS_THRU);
+    }
+  }
+
+  /* Set up progress monitor's pass info if present */
+  if (cinfo->progress != NULL) {
+    cinfo->progress->completed_passes = master->pass_number;
+    cinfo->progress->total_passes = master->pass_number +
+				    (master->pub.is_dummy_pass ? 2 : 1);
+    /* In buffered-image mode, we assume one more output pass if EOI not
+     * yet reached, but no more passes if EOI has been reached.
+     */
+    if (cinfo->buffered_image && ! cinfo->inputctl->eoi_reached) {
+      cinfo->progress->total_passes += (cinfo->enable_2pass_quant ? 2 : 1);
+    }
+  }
+}
+
+
+/*
+ * Finish up at end of an output pass.
+ */
+
+METHODDEF void
+finish_output_pass (j_decompress_ptr cinfo)
+{
+  my_master_ptr master = (my_master_ptr) cinfo->master;
+
+  if (cinfo->quantize_colors)
+    (*cinfo->cquantize->finish_pass) (cinfo);
+  master->pass_number++;
+}
+
+
+#ifdef D_MULTISCAN_FILES_SUPPORTED
+
+/*
+ * Switch to a new external colormap between output passes.
+ */
+
+GLOBAL void
+jpeg_new_colormap (j_decompress_ptr cinfo)
+{
+  my_master_ptr master = (my_master_ptr) cinfo->master;
+
+  /* Prevent application from calling me at wrong times */
+  if (cinfo->global_state != DSTATE_BUFIMAGE)
+    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+
+  if (cinfo->quantize_colors && cinfo->enable_external_quant &&
+      cinfo->colormap != NULL) {
+    /* Select 2-pass quantizer for external colormap use */
+    cinfo->cquantize = master->quantizer_2pass;
+    /* Notify quantizer of colormap change */
+    (*cinfo->cquantize->new_color_map) (cinfo);
+    master->pub.is_dummy_pass = FALSE; /* just in case */
+  } else
+    ERREXIT(cinfo, JERR_MODE_CHANGE);
+}
+
+#endif /* D_MULTISCAN_FILES_SUPPORTED */
+
+
+/*
+ * Initialize master decompression control and select active modules.
+ * This is performed at the start of jpeg_start_decompress.
+ */
+
+GLOBAL void
+jinit_master_decompress (j_decompress_ptr cinfo)
+{
+  my_master_ptr master;
+
+  master = (my_master_ptr)
+      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				  SIZEOF(my_decomp_master));
+  cinfo->master = (struct jpeg_decomp_master *) master;
+  master->pub.prepare_for_output_pass = prepare_for_output_pass;
+  master->pub.finish_output_pass = finish_output_pass;
+
+  master->pub.is_dummy_pass = FALSE;
+
+  master_selection(cinfo);
+}
diff --git a/code/jpeg-6/jdpostct.cpp b/code/jpeg-6/jdpostct.cpp
new file mode 100644
index 0000000..fab5534
--- /dev/null
+++ b/code/jpeg-6/jdpostct.cpp
@@ -0,0 +1,296 @@
+/*
+ * jdpostct.c
+ *
+ * Copyright (C) 1994-1995, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains the decompression postprocessing controller.
+ * This controller manages the upsampling, color conversion, and color
+ * quantization/reduction steps; specifically, it controls the buffering
+ * between upsample/color conversion and color quantization/reduction.
+ *
+ * If no color quantization/reduction is required, then this module has no
+ * work to do, and it just hands off to the upsample/color conversion code.
+ * An integrated upsample/convert/quantize process would replace this module
+ * entirely.
+ */
+
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/* Private buffer controller object */
+
+typedef struct {
+  struct jpeg_d_post_controller pub; /* public fields */
+
+  /* Color quantization source buffer: this holds output data from
+   * the upsample/color conversion step to be passed to the quantizer.
+   * For two-pass color quantization, we need a full-image buffer;
+   * for one-pass operation, a strip buffer is sufficient.
+   */
+  jvirt_sarray_ptr whole_image;	/* virtual array, or NULL if one-pass */
+  JSAMPARRAY buffer;		/* strip buffer, or current strip of virtual */
+  JDIMENSION strip_height;	/* buffer size in rows */
+  /* for two-pass mode only: */
+  JDIMENSION starting_row;	/* row # of first row in current strip */
+  JDIMENSION next_row;		/* index of next row to fill/empty in strip */
+} my_post_controller;
+
+typedef my_post_controller * my_post_ptr;
+
+
+/* Forward declarations */
+METHODDEF void post_process_1pass
+	JPP((j_decompress_ptr cinfo,
+	     JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr,
+	     JDIMENSION in_row_groups_avail,
+	     JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
+	     JDIMENSION out_rows_avail));
+#ifdef QUANT_2PASS_SUPPORTED
+METHODDEF void post_process_prepass
+	JPP((j_decompress_ptr cinfo,
+	     JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr,
+	     JDIMENSION in_row_groups_avail,
+	     JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
+	     JDIMENSION out_rows_avail));
+METHODDEF void post_process_2pass
+	JPP((j_decompress_ptr cinfo,
+	     JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr,
+	     JDIMENSION in_row_groups_avail,
+	     JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
+	     JDIMENSION out_rows_avail));
+#endif
+
+
+/*
+ * Initialize for a processing pass.
+ */
+
+METHODDEF void
+start_pass_dpost (j_decompress_ptr cinfo, J_BUF_MODE pass_mode)
+{
+  my_post_ptr post = (my_post_ptr) cinfo->post;
+
+  switch (pass_mode) {
+  case JBUF_PASS_THRU:
+    if (cinfo->quantize_colors) {
+      /* Single-pass processing with color quantization. */
+      post->pub.post_process_data = post_process_1pass;
+      /* We could be doing buffered-image output before starting a 2-pass
+       * color quantization; in that case, jinit_d_post_controller did not
+       * allocate a strip buffer.  Use the virtual-array buffer as workspace.
+       */
+      if (post->buffer == NULL) {
+	post->buffer = (*cinfo->mem->access_virt_sarray)
+	  ((j_common_ptr) cinfo, post->whole_image,
+	   (JDIMENSION) 0, post->strip_height, TRUE);
+      }
+    } else {
+      /* For single-pass processing without color quantization,
+       * I have no work to do; just call the upsampler directly.
+       */
+      post->pub.post_process_data = cinfo->upsample->upsample;
+    }
+    break;
+#ifdef QUANT_2PASS_SUPPORTED
+  case JBUF_SAVE_AND_PASS:
+    /* First pass of 2-pass quantization */
+    if (post->whole_image == NULL)
+      ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+    post->pub.post_process_data = post_process_prepass;
+    break;
+  case JBUF_CRANK_DEST:
+    /* Second pass of 2-pass quantization */
+    if (post->whole_image == NULL)
+      ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+    post->pub.post_process_data = post_process_2pass;
+    break;
+#endif /* QUANT_2PASS_SUPPORTED */
+  default:
+    ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+    break;
+  }
+  post->starting_row = post->next_row = 0;
+}
+
+
+/*
+ * Process some data in the one-pass (strip buffer) case.
+ * This is used for color precision reduction as well as one-pass quantization.
+ */
+
+METHODDEF void
+post_process_1pass (j_decompress_ptr cinfo,
+		    JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr,
+		    JDIMENSION in_row_groups_avail,
+		    JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
+		    JDIMENSION out_rows_avail)
+{
+  my_post_ptr post = (my_post_ptr) cinfo->post;
+  JDIMENSION num_rows, max_rows;
+
+  /* Fill the buffer, but not more than what we can dump out in one go. */
+  /* Note we rely on the upsampler to detect bottom of image. */
+  max_rows = out_rows_avail - *out_row_ctr;
+  if (max_rows > post->strip_height)
+    max_rows = post->strip_height;
+  num_rows = 0;
+  (*cinfo->upsample->upsample) (cinfo,
+		input_buf, in_row_group_ctr, in_row_groups_avail,
+		post->buffer, &num_rows, max_rows);
+  /* Quantize and emit data. */
+  (*cinfo->cquantize->color_quantize) (cinfo,
+		post->buffer, output_buf + *out_row_ctr, (int) num_rows);
+  *out_row_ctr += num_rows;
+}
+
+
+#ifdef QUANT_2PASS_SUPPORTED
+
+/*
+ * Process some data in the first pass of 2-pass quantization.
+ */
+
+METHODDEF void
+post_process_prepass (j_decompress_ptr cinfo,
+		      JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr,
+		      JDIMENSION in_row_groups_avail,
+		      JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
+		      JDIMENSION out_rows_avail)
+{
+  my_post_ptr post = (my_post_ptr) cinfo->post;
+  JDIMENSION old_next_row, num_rows;
+
+  /* Reposition virtual buffer if at start of strip. */
+  if (post->next_row == 0) {
+    post->buffer = (*cinfo->mem->access_virt_sarray)
+	((j_common_ptr) cinfo, post->whole_image,
+	 post->starting_row, post->strip_height, TRUE);
+  }
+
+  /* Upsample some data (up to a strip height's worth). */
+  old_next_row = post->next_row;
+  (*cinfo->upsample->upsample) (cinfo,
+		input_buf, in_row_group_ctr, in_row_groups_avail,
+		post->buffer, &post->next_row, post->strip_height);
+
+  /* Allow quantizer to scan new data.  No data is emitted, */
+  /* but we advance out_row_ctr so outer loop can tell when we're done. */
+  if (post->next_row > old_next_row) {
+    num_rows = post->next_row - old_next_row;
+    (*cinfo->cquantize->color_quantize) (cinfo, post->buffer + old_next_row,
+					 (JSAMPARRAY) NULL, (int) num_rows);
+    *out_row_ctr += num_rows;
+  }
+
+  /* Advance if we filled the strip. */
+  if (post->next_row >= post->strip_height) {
+    post->starting_row += post->strip_height;
+    post->next_row = 0;
+  }
+}
+
+
+/*
+ * Process some data in the second pass of 2-pass quantization.
+ */
+
+METHODDEF void
+post_process_2pass (j_decompress_ptr cinfo,
+		    JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr,
+		    JDIMENSION in_row_groups_avail,
+		    JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
+		    JDIMENSION out_rows_avail)
+{
+  my_post_ptr post = (my_post_ptr) cinfo->post;
+  JDIMENSION num_rows, max_rows;
+
+  /* Reposition virtual buffer if at start of strip. */
+  if (post->next_row == 0) {
+    post->buffer = (*cinfo->mem->access_virt_sarray)
+	((j_common_ptr) cinfo, post->whole_image,
+	 post->starting_row, post->strip_height, FALSE);
+  }
+
+  /* Determine number of rows to emit. */
+  num_rows = post->strip_height - post->next_row; /* available in strip */
+  max_rows = out_rows_avail - *out_row_ctr; /* available in output area */
+  if (num_rows > max_rows)
+    num_rows = max_rows;
+  /* We have to check bottom of image here, can't depend on upsampler. */
+  max_rows = cinfo->output_height - post->starting_row;
+  if (num_rows > max_rows)
+    num_rows = max_rows;
+
+  /* Quantize and emit data. */
+  (*cinfo->cquantize->color_quantize) (cinfo,
+		post->buffer + post->next_row, output_buf + *out_row_ctr,
+		(int) num_rows);
+  *out_row_ctr += num_rows;
+
+  /* Advance if we filled the strip. */
+  post->next_row += num_rows;
+  if (post->next_row >= post->strip_height) {
+    post->starting_row += post->strip_height;
+    post->next_row = 0;
+  }
+}
+
+#endif /* QUANT_2PASS_SUPPORTED */
+
+
+/*
+ * Initialize postprocessing controller.
+ */
+
+GLOBAL void
+jinit_d_post_controller (j_decompress_ptr cinfo, boolean need_full_buffer)
+{
+  my_post_ptr post;
+
+  post = (my_post_ptr)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				SIZEOF(my_post_controller));
+  cinfo->post = (struct jpeg_d_post_controller *) post;
+  post->pub.start_pass = start_pass_dpost;
+  post->whole_image = NULL;	/* flag for no virtual arrays */
+  post->buffer = NULL;		/* flag for no strip buffer */
+
+  /* Create the quantization buffer, if needed */
+  if (cinfo->quantize_colors) {
+    /* The buffer strip height is max_v_samp_factor, which is typically
+     * an efficient number of rows for upsampling to return.
+     * (In the presence of output rescaling, we might want to be smarter?)
+     */
+    post->strip_height = (JDIMENSION) cinfo->max_v_samp_factor;
+    if (need_full_buffer) {
+      /* Two-pass color quantization: need full-image storage. */
+      /* We round up the number of rows to a multiple of the strip height. */
+#ifdef QUANT_2PASS_SUPPORTED
+      post->whole_image = (*cinfo->mem->request_virt_sarray)
+	((j_common_ptr) cinfo, JPOOL_IMAGE, FALSE,
+	 cinfo->output_width * cinfo->out_color_components,
+	 (JDIMENSION) jround_up((long) cinfo->output_height,
+				(long) post->strip_height),
+	 post->strip_height);
+#else
+      ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+#endif /* QUANT_2PASS_SUPPORTED */
+    } else {
+      /* One-pass color quantization: just make a strip buffer. */
+      post->buffer = (*cinfo->mem->alloc_sarray)
+	((j_common_ptr) cinfo, JPOOL_IMAGE,
+	 cinfo->output_width * cinfo->out_color_components,
+	 post->strip_height);
+    }
+  }
+}
diff --git a/code/jpeg-6/jdsample.cpp b/code/jpeg-6/jdsample.cpp
new file mode 100644
index 0000000..9eb2e27
--- /dev/null
+++ b/code/jpeg-6/jdsample.cpp
@@ -0,0 +1,484 @@
+/*
+ * jdsample.c
+ *
+ * Copyright (C) 1991-1994, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains upsampling routines.
+ *
+ * Upsampling input data is counted in "row groups".  A row group
+ * is defined to be (v_samp_factor * DCT_scaled_size / min_DCT_scaled_size)
+ * sample rows of each component.  Upsampling will normally produce
+ * max_v_samp_factor pixel rows from each row group (but this could vary
+ * if the upsampler is applying a scale factor of its own).
+ *
+ * An excellent reference for image resampling is
+ *   Digital Image Warping, George Wolberg, 1990.
+ *   Pub. by IEEE Computer Society Press, Los Alamitos, CA. ISBN 0-8186-8944-7.
+ */
+
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/* Pointer to routine to upsample a single component */
+typedef JMETHOD(void, upsample1_ptr,
+		(j_decompress_ptr cinfo, jpeg_component_info * compptr,
+		 JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr));
+
+/* Private subobject */
+
+typedef struct {
+  struct jpeg_upsampler pub;	/* public fields */
+
+  /* Color conversion buffer.  When using separate upsampling and color
+   * conversion steps, this buffer holds one upsampled row group until it
+   * has been color converted and output.
+   * Note: we do not allocate any storage for component(s) which are full-size,
+   * ie do not need rescaling.  The corresponding entry of color_buf[] is
+   * simply set to point to the input data array, thereby avoiding copying.
+   */
+  JSAMPARRAY color_buf[MAX_COMPONENTS];
+
+  /* Per-component upsampling method pointers */
+  upsample1_ptr methods[MAX_COMPONENTS];
+
+  int next_row_out;		/* counts rows emitted from color_buf */
+  JDIMENSION rows_to_go;	/* counts rows remaining in image */
+
+  /* Height of an input row group for each component. */
+  int rowgroup_height[MAX_COMPONENTS];
+
+  /* These arrays save pixel expansion factors so that int_expand need not
+   * recompute them each time.  They are unused for other upsampling methods.
+   */
+  UINT8 h_expand[MAX_COMPONENTS];
+  UINT8 v_expand[MAX_COMPONENTS];
+} my_upsampler;
+
+typedef my_upsampler * my_upsample_ptr;
+
+
+/*
+ * Initialize for an upsampling pass.
+ */
+
+METHODDEF void
+start_pass_upsample (j_decompress_ptr cinfo)
+{
+  my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample;
+
+  /* Mark the conversion buffer empty */
+  upsample->next_row_out = cinfo->max_v_samp_factor;
+  /* Initialize total-height counter for detecting bottom of image */
+  upsample->rows_to_go = cinfo->output_height;
+}
+
+
+/*
+ * Control routine to do upsampling (and color conversion).
+ *
+ * In this version we upsample each component independently.
+ * We upsample one row group into the conversion buffer, then apply
+ * color conversion a row at a time.
+ */
+
+METHODDEF void
+sep_upsample (j_decompress_ptr cinfo,
+	      JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr,
+	      JDIMENSION in_row_groups_avail,
+	      JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
+	      JDIMENSION out_rows_avail)
+{
+  my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample;
+  int ci;
+  jpeg_component_info * compptr;
+  JDIMENSION num_rows;
+
+  /* Fill the conversion buffer, if it's empty */
+  if (upsample->next_row_out >= cinfo->max_v_samp_factor) {
+    for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+	 ci++, compptr++) {
+      /* Invoke per-component upsample method.  Notice we pass a POINTER
+       * to color_buf[ci], so that fullsize_upsample can change it.
+       */
+      (*upsample->methods[ci]) (cinfo, compptr,
+	input_buf[ci] + (*in_row_group_ctr * upsample->rowgroup_height[ci]),
+	upsample->color_buf + ci);
+    }
+    upsample->next_row_out = 0;
+  }
+
+  /* Color-convert and emit rows */
+
+  /* How many we have in the buffer: */
+  num_rows = (JDIMENSION) (cinfo->max_v_samp_factor - upsample->next_row_out);
+  /* Not more than the distance to the end of the image.  Need this test
+   * in case the image height is not a multiple of max_v_samp_factor:
+   */
+  if (num_rows > upsample->rows_to_go) 
+    num_rows = upsample->rows_to_go;
+  /* And not more than what the client can accept: */
+  out_rows_avail -= *out_row_ctr;
+  if (num_rows > out_rows_avail)
+    num_rows = out_rows_avail;
+
+  (*cinfo->cconvert->color_convert) (cinfo, upsample->color_buf,
+				     (JDIMENSION) upsample->next_row_out,
+				     output_buf + *out_row_ctr,
+				     (int) num_rows);
+
+  /* Adjust counts */
+  *out_row_ctr += num_rows;
+  upsample->rows_to_go -= num_rows;
+  upsample->next_row_out += num_rows;
+  /* When the buffer is emptied, declare this input row group consumed */
+  if (upsample->next_row_out >= cinfo->max_v_samp_factor)
+    (*in_row_group_ctr)++;
+}
+
+
+/*
+ * These are the routines invoked by sep_upsample to upsample pixel values
+ * of a single component.  One row group is processed per call.
+ */
+
+
+/*
+ * For full-size components, we just make color_buf[ci] point at the
+ * input buffer, and thus avoid copying any data.  Note that this is
+ * safe only because sep_upsample doesn't declare the input row group
+ * "consumed" until we are done color converting and emitting it.
+ */
+
+METHODDEF void
+fullsize_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr,
+		   JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr)
+{
+  *output_data_ptr = input_data;
+}
+
+
+/*
+ * This is a no-op version used for "uninteresting" components.
+ * These components will not be referenced by color conversion.
+ */
+
+METHODDEF void
+noop_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr,
+	       JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr)
+{
+  *output_data_ptr = NULL;	/* safety check */
+}
+
+
+/*
+ * This version handles any integral sampling ratios.
+ * This is not used for typical JPEG files, so it need not be fast.
+ * Nor, for that matter, is it particularly accurate: the algorithm is
+ * simple replication of the input pixel onto the corresponding output
+ * pixels.  The hi-falutin sampling literature refers to this as a
+ * "box filter".  A box filter tends to introduce visible artifacts,
+ * so if you are actually going to use 3:1 or 4:1 sampling ratios
+ * you would be well advised to improve this code.
+ */
+
+METHODDEF void
+int_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr,
+	      JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr)
+{
+  my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample;
+  JSAMPARRAY output_data = *output_data_ptr;
+  register JSAMPROW inptr, outptr;
+  register JSAMPLE invalue;
+  register int h;
+  JSAMPROW outend;
+  int h_expand, v_expand;
+  int inrow, outrow;
+
+  h_expand = upsample->h_expand[compptr->component_index];
+  v_expand = upsample->v_expand[compptr->component_index];
+
+  inrow = outrow = 0;
+  while (outrow < cinfo->max_v_samp_factor) {
+    /* Generate one output row with proper horizontal expansion */
+    inptr = input_data[inrow];
+    outptr = output_data[outrow];
+    outend = outptr + cinfo->output_width;
+    while (outptr < outend) {
+      invalue = *inptr++;	/* don't need GETJSAMPLE() here */
+      for (h = h_expand; h > 0; h--) {
+	*outptr++ = invalue;
+      }
+    }
+    /* Generate any additional output rows by duplicating the first one */
+    if (v_expand > 1) {
+      jcopy_sample_rows(output_data, outrow, output_data, outrow+1,
+			v_expand-1, cinfo->output_width);
+    }
+    inrow++;
+    outrow += v_expand;
+  }
+}
+
+
+/*
+ * Fast processing for the common case of 2:1 horizontal and 1:1 vertical.
+ * It's still a box filter.
+ */
+
+METHODDEF void
+h2v1_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr,
+	       JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr)
+{
+  JSAMPARRAY output_data = *output_data_ptr;
+  register JSAMPROW inptr, outptr;
+  register JSAMPLE invalue;
+  JSAMPROW outend;
+  int inrow;
+
+  for (inrow = 0; inrow < cinfo->max_v_samp_factor; inrow++) {
+    inptr = input_data[inrow];
+    outptr = output_data[inrow];
+    outend = outptr + cinfo->output_width;
+    while (outptr < outend) {
+      invalue = *inptr++;	/* don't need GETJSAMPLE() here */
+      *outptr++ = invalue;
+      *outptr++ = invalue;
+    }
+  }
+}
+
+
+/*
+ * Fast processing for the common case of 2:1 horizontal and 2:1 vertical.
+ * It's still a box filter.
+ */
+
+METHODDEF void
+h2v2_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr,
+	       JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr)
+{
+  JSAMPARRAY output_data = *output_data_ptr;
+  register JSAMPROW inptr, outptr;
+  register JSAMPLE invalue;
+  JSAMPROW outend;
+  int inrow, outrow;
+
+  inrow = outrow = 0;
+  while (outrow < cinfo->max_v_samp_factor) {
+    inptr = input_data[inrow];
+    outptr = output_data[outrow];
+    outend = outptr + cinfo->output_width;
+    while (outptr < outend) {
+      invalue = *inptr++;	/* don't need GETJSAMPLE() here */
+      *outptr++ = invalue;
+      *outptr++ = invalue;
+    }
+    jcopy_sample_rows(output_data, outrow, output_data, outrow+1,
+		      1, cinfo->output_width);
+    inrow++;
+    outrow += 2;
+  }
+}
+
+
+/*
+ * Fancy processing for the common case of 2:1 horizontal and 1:1 vertical.
+ *
+ * The upsampling algorithm is linear interpolation between pixel centers,
+ * also known as a "triangle filter".  This is a good compromise between
+ * speed and visual quality.  The centers of the output pixels are 1/4 and 3/4
+ * of the way between input pixel centers.
+ *
+ * A note about the "bias" calculations: when rounding fractional values to
+ * integer, we do not want to always round 0.5 up to the next integer.
+ * If we did that, we'd introduce a noticeable bias towards larger values.
+ * Instead, this code is arranged so that 0.5 will be rounded up or down at
+ * alternate pixel locations (a simple ordered dither pattern).
+ */
+
+METHODDEF void
+h2v1_fancy_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr,
+		     JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr)
+{
+  JSAMPARRAY output_data = *output_data_ptr;
+  register JSAMPROW inptr, outptr;
+  register int invalue;
+  register JDIMENSION colctr;
+  int inrow;
+
+  for (inrow = 0; inrow < cinfo->max_v_samp_factor; inrow++) {
+    inptr = input_data[inrow];
+    outptr = output_data[inrow];
+    /* Special case for first column */
+    invalue = GETJSAMPLE(*inptr++);
+    *outptr++ = (JSAMPLE) invalue;
+    *outptr++ = (JSAMPLE) ((invalue * 3 + GETJSAMPLE(*inptr) + 2) >> 2);
+
+    for (colctr = compptr->downsampled_width - 2; colctr > 0; colctr--) {
+      /* General case: 3/4 * nearer pixel + 1/4 * further pixel */
+      invalue = GETJSAMPLE(*inptr++) * 3;
+      *outptr++ = (JSAMPLE) ((invalue + GETJSAMPLE(inptr[-2]) + 1) >> 2);
+      *outptr++ = (JSAMPLE) ((invalue + GETJSAMPLE(*inptr) + 2) >> 2);
+    }
+
+    /* Special case for last column */
+    invalue = GETJSAMPLE(*inptr);
+    *outptr++ = (JSAMPLE) ((invalue * 3 + GETJSAMPLE(inptr[-1]) + 1) >> 2);
+    *outptr++ = (JSAMPLE) invalue;
+  }
+}
+
+
+/*
+ * Fancy processing for the common case of 2:1 horizontal and 2:1 vertical.
+ * Again a triangle filter; see comments for h2v1 case, above.
+ *
+ * It is OK for us to reference the adjacent input rows because we demanded
+ * context from the main buffer controller (see initialization code).
+ */
+
+METHODDEF void
+h2v2_fancy_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr,
+		     JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr)
+{
+  JSAMPARRAY output_data = *output_data_ptr;
+  register JSAMPROW inptr0, inptr1, outptr;
+#if BITS_IN_JSAMPLE == 8
+  register int thiscolsum, lastcolsum, nextcolsum;
+#else
+  register INT32 thiscolsum, lastcolsum, nextcolsum;
+#endif
+  register JDIMENSION colctr;
+  int inrow, outrow, v;
+
+  inrow = outrow = 0;
+  while (outrow < cinfo->max_v_samp_factor) {
+    for (v = 0; v < 2; v++) {
+      /* inptr0 points to nearest input row, inptr1 points to next nearest */
+      inptr0 = input_data[inrow];
+      if (v == 0)		/* next nearest is row above */
+	inptr1 = input_data[inrow-1];
+      else			/* next nearest is row below */
+	inptr1 = input_data[inrow+1];
+      outptr = output_data[outrow++];
+
+      /* Special case for first column */
+      thiscolsum = GETJSAMPLE(*inptr0++) * 3 + GETJSAMPLE(*inptr1++);
+      nextcolsum = GETJSAMPLE(*inptr0++) * 3 + GETJSAMPLE(*inptr1++);
+      *outptr++ = (JSAMPLE) ((thiscolsum * 4 + 8) >> 4);
+      *outptr++ = (JSAMPLE) ((thiscolsum * 3 + nextcolsum + 7) >> 4);
+      lastcolsum = thiscolsum; thiscolsum = nextcolsum;
+
+      for (colctr = compptr->downsampled_width - 2; colctr > 0; colctr--) {
+	/* General case: 3/4 * nearer pixel + 1/4 * further pixel in each */
+	/* dimension, thus 9/16, 3/16, 3/16, 1/16 overall */
+	nextcolsum = GETJSAMPLE(*inptr0++) * 3 + GETJSAMPLE(*inptr1++);
+	*outptr++ = (JSAMPLE) ((thiscolsum * 3 + lastcolsum + 8) >> 4);
+	*outptr++ = (JSAMPLE) ((thiscolsum * 3 + nextcolsum + 7) >> 4);
+	lastcolsum = thiscolsum; thiscolsum = nextcolsum;
+      }
+
+      /* Special case for last column */
+      *outptr++ = (JSAMPLE) ((thiscolsum * 3 + lastcolsum + 8) >> 4);
+      *outptr++ = (JSAMPLE) ((thiscolsum * 4 + 7) >> 4);
+    }
+    inrow++;
+  }
+}
+
+
+/*
+ * Module initialization routine for upsampling.
+ */
+
+GLOBAL void
+jinit_upsampler (j_decompress_ptr cinfo)
+{
+  my_upsample_ptr upsample;
+  int ci;
+  jpeg_component_info * compptr;
+  boolean need_buffer, do_fancy;
+  int h_in_group, v_in_group, h_out_group, v_out_group;
+
+  upsample = (my_upsample_ptr)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				SIZEOF(my_upsampler));
+  cinfo->upsample = (struct jpeg_upsampler *) upsample;
+  upsample->pub.start_pass = start_pass_upsample;
+  upsample->pub.upsample = sep_upsample;
+  upsample->pub.need_context_rows = FALSE; /* until we find out differently */
+
+  if (cinfo->CCIR601_sampling)	/* this isn't supported */
+    ERREXIT(cinfo, JERR_CCIR601_NOTIMPL);
+
+  /* jdmainct.c doesn't support context rows when min_DCT_scaled_size = 1,
+   * so don't ask for it.
+   */
+  do_fancy = cinfo->do_fancy_upsampling && cinfo->min_DCT_scaled_size > 1;
+
+  /* Verify we can handle the sampling factors, select per-component methods,
+   * and create storage as needed.
+   */
+  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+       ci++, compptr++) {
+    /* Compute size of an "input group" after IDCT scaling.  This many samples
+     * are to be converted to max_h_samp_factor * max_v_samp_factor pixels.
+     */
+    h_in_group = (compptr->h_samp_factor * compptr->DCT_scaled_size) /
+		 cinfo->min_DCT_scaled_size;
+    v_in_group = (compptr->v_samp_factor * compptr->DCT_scaled_size) /
+		 cinfo->min_DCT_scaled_size;
+    h_out_group = cinfo->max_h_samp_factor;
+    v_out_group = cinfo->max_v_samp_factor;
+    upsample->rowgroup_height[ci] = v_in_group; /* save for use later */
+    need_buffer = TRUE;
+    if (! compptr->component_needed) {
+      /* Don't bother to upsample an uninteresting component. */
+      upsample->methods[ci] = noop_upsample;
+      need_buffer = FALSE;
+    } else if (h_in_group == h_out_group && v_in_group == v_out_group) {
+      /* Fullsize components can be processed without any work. */
+      upsample->methods[ci] = fullsize_upsample;
+      need_buffer = FALSE;
+    } else if (h_in_group * 2 == h_out_group &&
+	       v_in_group == v_out_group) {
+      /* Special cases for 2h1v upsampling */
+      if (do_fancy && compptr->downsampled_width > 2)
+	upsample->methods[ci] = h2v1_fancy_upsample;
+      else
+	upsample->methods[ci] = h2v1_upsample;
+    } else if (h_in_group * 2 == h_out_group &&
+	       v_in_group * 2 == v_out_group) {
+      /* Special cases for 2h2v upsampling */
+      if (do_fancy && compptr->downsampled_width > 2) {
+	upsample->methods[ci] = h2v2_fancy_upsample;
+	upsample->pub.need_context_rows = TRUE;
+      } else
+	upsample->methods[ci] = h2v2_upsample;
+    } else if ((h_out_group % h_in_group) == 0 &&
+	       (v_out_group % v_in_group) == 0) {
+      /* Generic integral-factors upsampling method */
+      upsample->methods[ci] = int_upsample;
+      upsample->h_expand[ci] = (UINT8) (h_out_group / h_in_group);
+      upsample->v_expand[ci] = (UINT8) (v_out_group / v_in_group);
+    } else
+      ERREXIT(cinfo, JERR_FRACT_SAMPLE_NOTIMPL);
+    if (need_buffer) {
+      upsample->color_buf[ci] = (*cinfo->mem->alloc_sarray)
+	((j_common_ptr) cinfo, JPOOL_IMAGE,
+	 (JDIMENSION) jround_up((long) cinfo->output_width,
+				(long) cinfo->max_h_samp_factor),
+	 (JDIMENSION) cinfo->max_v_samp_factor);
+    }
+  }
+}
diff --git a/code/jpeg-6/jdtrans.cpp b/code/jpeg-6/jdtrans.cpp
new file mode 100644
index 0000000..c60cba7
--- /dev/null
+++ b/code/jpeg-6/jdtrans.cpp
@@ -0,0 +1,129 @@
+/*
+ * jdtrans.c
+ *
+ * Copyright (C) 1995, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains library routines for transcoding decompression,
+ * that is, reading raw DCT coefficient arrays from an input JPEG file.
+ * The routines in jdapimin.c will also be needed by a transcoder.
+ */
+
+
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/* Forward declarations */
+LOCAL void transdecode_master_selection JPP((j_decompress_ptr cinfo));
+
+
+/*
+ * Read the coefficient arrays from a JPEG file.
+ * jpeg_read_header must be completed before calling this.
+ *
+ * The entire image is read into a set of virtual coefficient-block arrays,
+ * one per component.  The return value is a pointer to the array of
+ * virtual-array descriptors.  These can be manipulated directly via the
+ * JPEG memory manager, or handed off to jpeg_write_coefficients().
+ * To release the memory occupied by the virtual arrays, call
+ * jpeg_finish_decompress() when done with the data.
+ *
+ * Returns NULL if suspended.  This case need be checked only if
+ * a suspending data source is used.
+ */
+
+GLOBAL jvirt_barray_ptr *
+jpeg_read_coefficients (j_decompress_ptr cinfo)
+{
+  if (cinfo->global_state == DSTATE_READY) {
+    /* First call: initialize active modules */
+    transdecode_master_selection(cinfo);
+    cinfo->global_state = DSTATE_RDCOEFS;
+  } else if (cinfo->global_state != DSTATE_RDCOEFS)
+    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+  /* Absorb whole file into the coef buffer */
+  for (;;) {
+    int retcode;
+    /* Call progress monitor hook if present */
+    if (cinfo->progress != NULL)
+      (*cinfo->progress->progress_monitor) ((j_common_ptr) cinfo);
+    /* Absorb some more input */
+    retcode = (*cinfo->inputctl->consume_input) (cinfo);
+    if (retcode == JPEG_SUSPENDED)
+      return NULL;
+    if (retcode == JPEG_REACHED_EOI)
+      break;
+    /* Advance progress counter if appropriate */
+    if (cinfo->progress != NULL &&
+	(retcode == JPEG_ROW_COMPLETED || retcode == JPEG_REACHED_SOS)) {
+      if (++cinfo->progress->pass_counter >= cinfo->progress->pass_limit) {
+	/* startup underestimated number of scans; ratchet up one scan */
+	cinfo->progress->pass_limit += (long) cinfo->total_iMCU_rows;
+      }
+    }
+  }
+  /* Set state so that jpeg_finish_decompress does the right thing */
+  cinfo->global_state = DSTATE_STOPPING;
+  return cinfo->coef->coef_arrays;
+}
+
+
+/*
+ * Master selection of decompression modules for transcoding.
+ * This substitutes for jdmaster.c's initialization of the full decompressor.
+ */
+
+LOCAL void
+transdecode_master_selection (j_decompress_ptr cinfo)
+{
+  /* Entropy decoding: either Huffman or arithmetic coding. */
+  if (cinfo->arith_code) {
+    ERREXIT(cinfo, JERR_ARITH_NOTIMPL);
+  } else {
+    if (cinfo->progressive_mode) {
+#ifdef D_PROGRESSIVE_SUPPORTED
+      jinit_phuff_decoder(cinfo);
+#else
+      ERREXIT(cinfo, JERR_NOT_COMPILED);
+#endif
+    } else
+      jinit_huff_decoder(cinfo);
+  }
+
+  /* Always get a full-image coefficient buffer. */
+  jinit_d_coef_controller(cinfo, TRUE);
+
+  /* We can now tell the memory manager to allocate virtual arrays. */
+  (*cinfo->mem->realize_virt_arrays) ((j_common_ptr) cinfo);
+
+  /* Initialize input side of decompressor to consume first scan. */
+  (*cinfo->inputctl->start_input_pass) (cinfo);
+
+  /* Initialize progress monitoring. */
+  if (cinfo->progress != NULL) {
+    int nscans;
+    /* Estimate number of scans to set pass_limit. */
+    if (cinfo->progressive_mode) {
+      /* Arbitrarily estimate 2 interleaved DC scans + 3 AC scans/component. */
+      nscans = 2 + 3 * cinfo->num_components;
+    } else if (cinfo->inputctl->has_multiple_scans) {
+      /* For a nonprogressive multiscan file, estimate 1 scan per component. */
+      nscans = cinfo->num_components;
+    } else {
+      nscans = 1;
+    }
+    cinfo->progress->pass_counter = 0L;
+    cinfo->progress->pass_limit = (long) cinfo->total_iMCU_rows * nscans;
+    cinfo->progress->completed_passes = 0;
+    cinfo->progress->total_passes = 1;
+  }
+}
diff --git a/code/jpeg-6/jerror.cpp b/code/jpeg-6/jerror.cpp
new file mode 100644
index 0000000..9621d02
--- /dev/null
+++ b/code/jpeg-6/jerror.cpp
@@ -0,0 +1,239 @@
+/*
+ * jerror.c
+ *
+ * Copyright (C) 1991-1994, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains simple error-reporting and trace-message routines.
+ * These are suitable for Unix-like systems and others where writing to
+ * stderr is the right thing to do.  Many applications will want to replace
+ * some or all of these routines.
+ *
+ * These routines are used by both the compression and decompression code.
+ */
+
+
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+
+
+/* this is not a core library module, so it doesn't define JPEG_INTERNALS */
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jversion.h"
+#include "jerror.h"
+
+#include "../renderer/tr_local.h"
+
+#ifndef EXIT_FAILURE		/* define exit() codes if not provided */
+#define EXIT_FAILURE  1
+#endif
+
+
+/*
+ * Create the message string table.
+ * We do this from the master message list in jerror.h by re-reading
+ * jerror.h with a suitable definition for macro JMESSAGE.
+ * The message table is made an external symbol just in case any applications
+ * want to refer to it directly.
+ */
+
+#ifdef NEED_SHORT_EXTERNAL_NAMES
+#define jpeg_std_message_table	jMsgTable
+#endif
+
+#define JMESSAGE(code,string)	string ,
+
+const char * const jpeg_std_message_table[] = {
+#include "jerror.h"
+  NULL
+};
+
+
+/*
+ * Error exit handler: must not return to caller.
+ *
+ * Applications may override this if they want to get control back after
+ * an error.  Typically one would longjmp somewhere instead of exiting.
+ * The setjmp buffer can be made a private field within an expanded error
+ * handler object.  Note that the info needed to generate an error message
+ * is stored in the error object, so you can generate the message now or
+ * later, at your convenience.
+ * You should make sure that the JPEG object is cleaned up (with jpeg_abort
+ * or jpeg_destroy) at some point.
+ */
+
+METHODDEF void
+error_exit (j_common_ptr cinfo)
+{
+  char buffer[JMSG_LENGTH_MAX];
+
+  /* Create the message */
+  (*cinfo->err->format_message) (cinfo, buffer);
+
+  /* Let the memory manager delete any temp files before we die */
+  jpeg_destroy(cinfo);
+
+  Com_Error( ERR_FATAL, "%s\n", buffer );
+}
+
+
+/*
+ * Actual output of an error or trace message.
+ * Applications may override this method to send JPEG messages somewhere
+ * other than stderr.
+ */
+
+METHODDEF void
+output_message (j_common_ptr cinfo)
+{
+  char buffer[JMSG_LENGTH_MAX];
+
+  /* Create the message */
+  (*cinfo->err->format_message) (cinfo, buffer);
+
+  /* Send it to stderr, adding a newline */
+  VID_Printf(PRINT_ALL, "%s\n", buffer);
+}
+
+
+/*
+ * Decide whether to emit a trace or warning message.
+ * msg_level is one of:
+ *   -1: recoverable corrupt-data warning, may want to abort.
+ *    0: important advisory messages (always display to user).
+ *    1: first level of tracing detail.
+ *    2,3,...: successively more detailed tracing messages.
+ * An application might override this method if it wanted to abort on warnings
+ * or change the policy about which messages to display.
+ */
+
+METHODDEF void
+emit_message (j_common_ptr cinfo, int msg_level)
+{
+  struct jpeg_error_mgr * err = cinfo->err;
+
+  if (msg_level < 0) {
+    /* It's a warning message.  Since corrupt files may generate many warnings,
+     * the policy implemented here is to show only the first warning,
+     * unless trace_level >= 3.
+     */
+    if (err->num_warnings == 0 || err->trace_level >= 3)
+      (*err->output_message) (cinfo);
+    /* Always count warnings in num_warnings. */
+    err->num_warnings++;
+  } else {
+    /* It's a trace message.  Show it if trace_level >= msg_level. */
+    if (err->trace_level >= msg_level)
+      (*err->output_message) (cinfo);
+  }
+}
+
+
+/*
+ * Format a message string for the most recent JPEG error or message.
+ * The message is stored into buffer, which should be at least JMSG_LENGTH_MAX
+ * characters.  Note that no '\n' character is added to the string.
+ * Few applications should need to override this method.
+ */
+
+METHODDEF void
+format_message (j_common_ptr cinfo, char * buffer)
+{
+  struct jpeg_error_mgr * err = cinfo->err;
+  int msg_code = err->msg_code;
+  const char * msgtext = NULL;
+  const char * msgptr;
+  char ch;
+  boolean isstring;
+
+  /* Look up message string in proper table */
+  if (msg_code > 0 && msg_code <= err->last_jpeg_message) {
+    msgtext = err->jpeg_message_table[msg_code];
+  } else if (err->addon_message_table != NULL &&
+	     msg_code >= err->first_addon_message &&
+	     msg_code <= err->last_addon_message) {
+    msgtext = err->addon_message_table[msg_code - err->first_addon_message];
+  }
+
+  /* Defend against bogus message number */
+  if (msgtext == NULL) {
+    err->msg_parm.i[0] = msg_code;
+    msgtext = err->jpeg_message_table[0];
+  }
+
+  /* Check for string parameter, as indicated by %s in the message text */
+  isstring = FALSE;
+  msgptr = msgtext;
+  while ((ch = *msgptr++) != '\0') {
+    if (ch == '%') {
+      if (*msgptr == 's') isstring = TRUE;
+      break;
+    }
+  }
+
+  /* Format the message into the passed buffer */
+  if (isstring)
+    sprintf(buffer, msgtext, err->msg_parm.s);
+  else
+    sprintf(buffer, msgtext,
+	    err->msg_parm.i[0], err->msg_parm.i[1],
+	    err->msg_parm.i[2], err->msg_parm.i[3],
+	    err->msg_parm.i[4], err->msg_parm.i[5],
+	    err->msg_parm.i[6], err->msg_parm.i[7]);
+}
+
+
+/*
+ * Reset error state variables at start of a new image.
+ * This is called during compression startup to reset trace/error
+ * processing to default state, without losing any application-specific
+ * method pointers.  An application might possibly want to override
+ * this method if it has additional error processing state.
+ */
+
+METHODDEF void
+reset_error_mgr (j_common_ptr cinfo)
+{
+  cinfo->err->num_warnings = 0;
+  /* trace_level is not reset since it is an application-supplied parameter */
+  cinfo->err->msg_code = 0;	/* may be useful as a flag for "no error" */
+}
+
+
+/*
+ * Fill in the standard error-handling methods in a jpeg_error_mgr object.
+ * Typical call is:
+ *	struct jpeg_compress_struct cinfo;
+ *	struct jpeg_error_mgr err;
+ *
+ *	cinfo.err = jpeg_std_error(&err);
+ * after which the application may override some of the methods.
+ */
+
+GLOBAL struct jpeg_error_mgr *
+jpeg_std_error (struct jpeg_error_mgr * err)
+{
+  err->error_exit = error_exit;
+  err->emit_message = emit_message;
+  err->output_message = output_message;
+  err->format_message = format_message;
+  err->reset_error_mgr = reset_error_mgr;
+
+  err->trace_level = 0;		/* default = no tracing */
+  err->num_warnings = 0;	/* no warnings emitted yet */
+  err->msg_code = 0;		/* may be useful as a flag for "no error" */
+
+  /* Initialize message table pointers */
+  err->jpeg_message_table = jpeg_std_message_table;
+  err->last_jpeg_message = (int) JMSG_LASTMSGCODE - 1;
+
+  err->addon_message_table = NULL;
+  err->first_addon_message = 0;	/* for safety */
+  err->last_addon_message = 0;
+
+  return err;
+}
diff --git a/code/jpeg-6/jerror.h b/code/jpeg-6/jerror.h
new file mode 100644
index 0000000..0ffb8b4
--- /dev/null
+++ b/code/jpeg-6/jerror.h
@@ -0,0 +1,273 @@
+/*
+ * jerror.h
+ *
+ * Copyright (C) 1994-1995, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file defines the error and message codes for the JPEG library.
+ * Edit this file to add new codes, or to translate the message strings to
+ * some other language.
+ * A set of error-reporting macros are defined too.  Some applications using
+ * the JPEG library may wish to include this file to get the error codes
+ * and/or the macros.
+ */
+
+/*
+ * To define the enum list of message codes, include this file without
+ * defining macro JMESSAGE.  To create a message string table, include it
+ * again with a suitable JMESSAGE definition (see jerror.c for an example).
+ */
+#ifndef JMESSAGE
+#ifndef JERROR_H
+/* First time through, define the enum list */
+#define JMAKE_ENUM_LIST
+#else
+/* Repeated inclusions of this file are no-ops unless JMESSAGE is defined */
+#define JMESSAGE(code,string)
+#endif /* JERROR_H */
+#endif /* JMESSAGE */
+
+#ifdef JMAKE_ENUM_LIST
+
+typedef enum {
+
+#define JMESSAGE(code,string)	code ,
+
+#endif /* JMAKE_ENUM_LIST */
+
+JMESSAGE(JMSG_NOMESSAGE, "Bogus message code %d") /* Must be first entry! */
+
+/* For maintenance convenience, list is alphabetical by message code name */
+JMESSAGE(JERR_ARITH_NOTIMPL,
+	 "Sorry, there are legal restrictions on arithmetic coding")
+JMESSAGE(JERR_BAD_ALIGN_TYPE, "ALIGN_TYPE is wrong, please fix")
+JMESSAGE(JERR_BAD_ALLOC_CHUNK, "MAX_ALLOC_CHUNK is wrong, please fix")
+JMESSAGE(JERR_BAD_BUFFER_MODE, "Bogus buffer control mode")
+JMESSAGE(JERR_BAD_COMPONENT_ID, "Invalid component ID %d in SOS")
+JMESSAGE(JERR_BAD_DCTSIZE, "IDCT output block size %d not supported")
+JMESSAGE(JERR_BAD_IN_COLORSPACE, "Bogus input colorspace")
+JMESSAGE(JERR_BAD_J_COLORSPACE, "Bogus JPEG colorspace")
+JMESSAGE(JERR_BAD_LENGTH, "Bogus marker length")
+JMESSAGE(JERR_BAD_MCU_SIZE, "Sampling factors too large for interleaved scan")
+JMESSAGE(JERR_BAD_POOL_ID, "Invalid memory pool code %d")
+JMESSAGE(JERR_BAD_PRECISION, "Unsupported JPEG data precision %d")
+JMESSAGE(JERR_BAD_PROGRESSION,
+	 "Invalid progressive parameters Ss=%d Se=%d Ah=%d Al=%d")
+JMESSAGE(JERR_BAD_PROG_SCRIPT,
+	 "Invalid progressive parameters at scan script entry %d")
+JMESSAGE(JERR_BAD_SAMPLING, "Bogus sampling factors")
+JMESSAGE(JERR_BAD_SCAN_SCRIPT, "Invalid scan script at entry %d")
+JMESSAGE(JERR_BAD_STATE, "Improper call to JPEG library in state %d")
+JMESSAGE(JERR_BAD_VIRTUAL_ACCESS, "Bogus virtual array access")
+JMESSAGE(JERR_BUFFER_SIZE, "Buffer passed to JPEG library is too small")
+JMESSAGE(JERR_CANT_SUSPEND, "Suspension not allowed here")
+JMESSAGE(JERR_CCIR601_NOTIMPL, "CCIR601 sampling not implemented yet")
+JMESSAGE(JERR_COMPONENT_COUNT, "Too many color components: %d, max %d")
+JMESSAGE(JERR_CONVERSION_NOTIMPL, "Unsupported color conversion request")
+JMESSAGE(JERR_DAC_INDEX, "Bogus DAC index %d")
+JMESSAGE(JERR_DAC_VALUE, "Bogus DAC value 0x%x")
+JMESSAGE(JERR_DHT_COUNTS, "Bogus DHT counts")
+JMESSAGE(JERR_DHT_INDEX, "Bogus DHT index %d")
+JMESSAGE(JERR_DQT_INDEX, "Bogus DQT index %d")
+JMESSAGE(JERR_EMPTY_IMAGE, "Empty JPEG image (DNL not supported)")
+JMESSAGE(JERR_EMS_READ, "Read from EMS failed")
+JMESSAGE(JERR_EMS_WRITE, "Write to EMS failed")
+JMESSAGE(JERR_EOI_EXPECTED, "Didn't expect more than one scan")
+JMESSAGE(JERR_FILE_READ, "Input file read error")
+JMESSAGE(JERR_FILE_WRITE, "Output file write error --- out of disk space?")
+JMESSAGE(JERR_FRACT_SAMPLE_NOTIMPL, "Fractional sampling not implemented yet")
+JMESSAGE(JERR_HUFF_CLEN_OVERFLOW, "Huffman code size table overflow")
+JMESSAGE(JERR_HUFF_MISSING_CODE, "Missing Huffman code table entry")
+JMESSAGE(JERR_IMAGE_TOO_BIG, "Maximum supported image dimension is %u pixels")
+JMESSAGE(JERR_INPUT_EMPTY, "Empty input file")
+JMESSAGE(JERR_INPUT_EOF, "Premature end of input file")
+JMESSAGE(JERR_MISMATCHED_QUANT_TABLE,
+	 "Cannot transcode due to multiple use of quantization table %d")
+JMESSAGE(JERR_MISSING_DATA, "Scan script does not transmit all data")
+JMESSAGE(JERR_MODE_CHANGE, "Invalid color quantization mode change")
+JMESSAGE(JERR_NOTIMPL, "Not implemented yet")
+JMESSAGE(JERR_NOT_COMPILED, "Requested feature was omitted at compile time")
+JMESSAGE(JERR_NO_BACKING_STORE, "Backing store not supported")
+JMESSAGE(JERR_NO_HUFF_TABLE, "Huffman table 0x%02x was not defined")
+JMESSAGE(JERR_NO_IMAGE, "JPEG datastream contains no image")
+JMESSAGE(JERR_NO_QUANT_TABLE, "Quantization table 0x%02x was not defined")
+JMESSAGE(JERR_NO_SOI, "Not a JPEG file: starts with 0x%02x 0x%02x")
+JMESSAGE(JERR_OUT_OF_MEMORY, "Insufficient memory (case %d)")
+JMESSAGE(JERR_QUANT_COMPONENTS,
+	 "Cannot quantize more than %d color components")
+JMESSAGE(JERR_QUANT_FEW_COLORS, "Cannot quantize to fewer than %d colors")
+JMESSAGE(JERR_QUANT_MANY_COLORS, "Cannot quantize to more than %d colors")
+JMESSAGE(JERR_SOF_DUPLICATE, "Invalid JPEG file structure: two SOF markers")
+JMESSAGE(JERR_SOF_NO_SOS, "Invalid JPEG file structure: missing SOS marker")
+JMESSAGE(JERR_SOF_UNSUPPORTED, "Unsupported JPEG process: SOF type 0x%02x")
+JMESSAGE(JERR_SOI_DUPLICATE, "Invalid JPEG file structure: two SOI markers")
+JMESSAGE(JERR_SOS_NO_SOF, "Invalid JPEG file structure: SOS before SOF")
+JMESSAGE(JERR_TFILE_CREATE, "Failed to create temporary file %s")
+JMESSAGE(JERR_TFILE_READ, "Read failed on temporary file")
+JMESSAGE(JERR_TFILE_SEEK, "Seek failed on temporary file")
+JMESSAGE(JERR_TFILE_WRITE,
+	 "Write failed on temporary file --- out of disk space?")
+JMESSAGE(JERR_TOO_LITTLE_DATA, "Application transferred too few scanlines")
+JMESSAGE(JERR_UNKNOWN_MARKER, "Unsupported marker type 0x%02x")
+JMESSAGE(JERR_VIRTUAL_BUG, "Virtual array controller messed up")
+JMESSAGE(JERR_WIDTH_OVERFLOW, "Image too wide for this implementation")
+JMESSAGE(JERR_XMS_READ, "Read from XMS failed")
+JMESSAGE(JERR_XMS_WRITE, "Write to XMS failed")
+JMESSAGE(JMSG_COPYRIGHT, JCOPYRIGHT)
+JMESSAGE(JMSG_VERSION, JVERSION)
+JMESSAGE(JTRC_16BIT_TABLES,
+	 "Caution: quantization tables are too coarse for baseline JPEG")
+JMESSAGE(JTRC_ADOBE,
+	 "Adobe APP14 marker: version %d, flags 0x%04x 0x%04x, transform %d")
+JMESSAGE(JTRC_APP0, "Unknown APP0 marker (not JFIF), length %u")
+JMESSAGE(JTRC_APP14, "Unknown APP14 marker (not Adobe), length %u")
+JMESSAGE(JTRC_DAC, "Define Arithmetic Table 0x%02x: 0x%02x")
+JMESSAGE(JTRC_DHT, "Define Huffman Table 0x%02x")
+JMESSAGE(JTRC_DQT, "Define Quantization Table %d  precision %d")
+JMESSAGE(JTRC_DRI, "Define Restart Interval %u")
+JMESSAGE(JTRC_EMS_CLOSE, "Freed EMS handle %u")
+JMESSAGE(JTRC_EMS_OPEN, "Obtained EMS handle %u")
+JMESSAGE(JTRC_EOI, "End Of Image")
+JMESSAGE(JTRC_HUFFBITS, "        %3d %3d %3d %3d %3d %3d %3d %3d")
+JMESSAGE(JTRC_JFIF, "JFIF APP0 marker, density %dx%d  %d")
+JMESSAGE(JTRC_JFIF_BADTHUMBNAILSIZE,
+	 "Warning: thumbnail image size does not match data length %u")
+JMESSAGE(JTRC_JFIF_MINOR, "Unknown JFIF minor revision number %d.%02d")
+JMESSAGE(JTRC_JFIF_THUMBNAIL, "    with %d x %d thumbnail image")
+JMESSAGE(JTRC_MISC_MARKER, "Skipping marker 0x%02x, length %u")
+JMESSAGE(JTRC_PARMLESS_MARKER, "Unexpected marker 0x%02x")
+JMESSAGE(JTRC_QUANTVALS, "        %4u %4u %4u %4u %4u %4u %4u %4u")
+JMESSAGE(JTRC_QUANT_3_NCOLORS, "Quantizing to %d = %d*%d*%d colors")
+JMESSAGE(JTRC_QUANT_NCOLORS, "Quantizing to %d colors")
+JMESSAGE(JTRC_QUANT_SELECTED, "Selected %d colors for quantization")
+JMESSAGE(JTRC_RECOVERY_ACTION, "At marker 0x%02x, recovery action %d")
+JMESSAGE(JTRC_RST, "RST%d")
+JMESSAGE(JTRC_SMOOTH_NOTIMPL,
+	 "Smoothing not supported with nonstandard sampling ratios")
+JMESSAGE(JTRC_SOF, "Start Of Frame 0x%02x: width=%u, height=%u, components=%d")
+JMESSAGE(JTRC_SOF_COMPONENT, "    Component %d: %dhx%dv q=%d")
+JMESSAGE(JTRC_SOI, "Start of Image")
+JMESSAGE(JTRC_SOS, "Start Of Scan: %d components")
+JMESSAGE(JTRC_SOS_COMPONENT, "    Component %d: dc=%d ac=%d")
+JMESSAGE(JTRC_SOS_PARAMS, "  Ss=%d, Se=%d, Ah=%d, Al=%d")
+JMESSAGE(JTRC_TFILE_CLOSE, "Closed temporary file %s")
+JMESSAGE(JTRC_TFILE_OPEN, "Opened temporary file %s")
+JMESSAGE(JTRC_UNKNOWN_IDS,
+	 "Unrecognized component IDs %d %d %d, assuming YCbCr")
+JMESSAGE(JTRC_XMS_CLOSE, "Freed XMS handle %u")
+JMESSAGE(JTRC_XMS_OPEN, "Obtained XMS handle %u")
+JMESSAGE(JWRN_ADOBE_XFORM, "Unknown Adobe color transform code %d")
+JMESSAGE(JWRN_BOGUS_PROGRESSION,
+	 "Inconsistent progression sequence for component %d coefficient %d")
+JMESSAGE(JWRN_EXTRANEOUS_DATA,
+	 "Corrupt JPEG data: %u extraneous bytes before marker 0x%02x")
+JMESSAGE(JWRN_HIT_MARKER, "Corrupt JPEG data: premature end of data segment")
+JMESSAGE(JWRN_HUFF_BAD_CODE, "Corrupt JPEG data: bad Huffman code")
+JMESSAGE(JWRN_JFIF_MAJOR, "Warning: unknown JFIF revision number %d.%02d")
+JMESSAGE(JWRN_JPEG_EOF, "Premature end of JPEG file")
+JMESSAGE(JWRN_MUST_RESYNC,
+	 "Corrupt JPEG data: found marker 0x%02x instead of RST%d")
+JMESSAGE(JWRN_NOT_SEQUENTIAL, "Invalid SOS parameters for sequential JPEG")
+JMESSAGE(JWRN_TOO_MUCH_DATA, "Application transferred too many scanlines")
+
+#ifdef JMAKE_ENUM_LIST
+
+  JMSG_LASTMSGCODE
+} J_MESSAGE_CODE;
+
+#undef JMAKE_ENUM_LIST
+#endif /* JMAKE_ENUM_LIST */
+
+/* Zap JMESSAGE macro so that future re-inclusions do nothing by default */
+#undef JMESSAGE
+
+
+#ifndef JERROR_H
+#define JERROR_H
+
+/* Macros to simplify using the error and trace message stuff */
+/* The first parameter is either type of cinfo pointer */
+
+/* Fatal errors (print message and exit) */
+#define ERREXIT(cinfo,code)  \
+  ((cinfo)->err->msg_code = (code), \
+   (*(cinfo)->err->error_exit) ((j_common_ptr) (cinfo)))
+#define ERREXIT1(cinfo,code,p1)  \
+  ((cinfo)->err->msg_code = (code), \
+   (cinfo)->err->msg_parm.i[0] = (p1), \
+   (*(cinfo)->err->error_exit) ((j_common_ptr) (cinfo)))
+#define ERREXIT2(cinfo,code,p1,p2)  \
+  ((cinfo)->err->msg_code = (code), \
+   (cinfo)->err->msg_parm.i[0] = (p1), \
+   (cinfo)->err->msg_parm.i[1] = (p2), \
+   (*(cinfo)->err->error_exit) ((j_common_ptr) (cinfo)))
+#define ERREXIT3(cinfo,code,p1,p2,p3)  \
+  ((cinfo)->err->msg_code = (code), \
+   (cinfo)->err->msg_parm.i[0] = (p1), \
+   (cinfo)->err->msg_parm.i[1] = (p2), \
+   (cinfo)->err->msg_parm.i[2] = (p3), \
+   (*(cinfo)->err->error_exit) ((j_common_ptr) (cinfo)))
+#define ERREXIT4(cinfo,code,p1,p2,p3,p4)  \
+  ((cinfo)->err->msg_code = (code), \
+   (cinfo)->err->msg_parm.i[0] = (p1), \
+   (cinfo)->err->msg_parm.i[1] = (p2), \
+   (cinfo)->err->msg_parm.i[2] = (p3), \
+   (cinfo)->err->msg_parm.i[3] = (p4), \
+   (*(cinfo)->err->error_exit) ((j_common_ptr) (cinfo)))
+#define ERREXITS(cinfo,code,str)  \
+  ((cinfo)->err->msg_code = (code), \
+   strncpy((cinfo)->err->msg_parm.s, (str), JMSG_STR_PARM_MAX), \
+   (*(cinfo)->err->error_exit) ((j_common_ptr) (cinfo)))
+
+#define MAKESTMT(stuff)		do { stuff } while (0)
+
+/* Nonfatal errors (we can keep going, but the data is probably corrupt) */
+#define WARNMS(cinfo,code)  \
+  ((cinfo)->err->msg_code = (code), \
+   (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), -1))
+#define WARNMS1(cinfo,code,p1)  \
+  ((cinfo)->err->msg_code = (code), \
+   (cinfo)->err->msg_parm.i[0] = (p1), \
+   (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), -1))
+#define WARNMS2(cinfo,code,p1,p2)  \
+  ((cinfo)->err->msg_code = (code), \
+   (cinfo)->err->msg_parm.i[0] = (p1), \
+   (cinfo)->err->msg_parm.i[1] = (p2), \
+   (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), -1))
+
+/* Informational/debugging messages */
+#define TRACEMS(cinfo,lvl,code)  \
+  ((cinfo)->err->msg_code = (code), \
+   (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), (lvl)))
+#define TRACEMS1(cinfo,lvl,code,p1)  \
+  ((cinfo)->err->msg_code = (code), \
+   (cinfo)->err->msg_parm.i[0] = (p1), \
+   (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), (lvl)))
+#define TRACEMS2(cinfo,lvl,code,p1,p2)  \
+  ((cinfo)->err->msg_code = (code), \
+   (cinfo)->err->msg_parm.i[0] = (p1), \
+   (cinfo)->err->msg_parm.i[1] = (p2), \
+   (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), (lvl)))
+#define TRACEMS3(cinfo,lvl,code,p1,p2,p3)  \
+  MAKESTMT(int * _mp = (cinfo)->err->msg_parm.i; \
+	   _mp[0] = (p1); _mp[1] = (p2); _mp[2] = (p3); \
+	   (cinfo)->err->msg_code = (code); \
+	   (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), (lvl)); )
+#define TRACEMS4(cinfo,lvl,code,p1,p2,p3,p4)  \
+  MAKESTMT(int * _mp = (cinfo)->err->msg_parm.i; \
+	   _mp[0] = (p1); _mp[1] = (p2); _mp[2] = (p3); _mp[3] = (p4); \
+	   (cinfo)->err->msg_code = (code); \
+	   (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), (lvl)); )
+#define TRACEMS8(cinfo,lvl,code,p1,p2,p3,p4,p5,p6,p7,p8)  \
+  MAKESTMT(int * _mp = (cinfo)->err->msg_parm.i; \
+	   _mp[0] = (p1); _mp[1] = (p2); _mp[2] = (p3); _mp[3] = (p4); \
+	   _mp[4] = (p5); _mp[5] = (p6); _mp[6] = (p7); _mp[7] = (p8); \
+	   (cinfo)->err->msg_code = (code); \
+	   (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), (lvl)); )
+#define TRACEMSS(cinfo,lvl,code,str)  \
+  ((cinfo)->err->msg_code = (code), \
+   strncpy((cinfo)->err->msg_parm.s, (str), JMSG_STR_PARM_MAX), \
+   (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), (lvl)))
+
+#endif /* JERROR_H */
diff --git a/code/jpeg-6/jfdctflt.cpp b/code/jpeg-6/jfdctflt.cpp
new file mode 100644
index 0000000..091fc8f
--- /dev/null
+++ b/code/jpeg-6/jfdctflt.cpp
@@ -0,0 +1,174 @@
+/*
+ * jfdctflt.c
+ *
+ * Copyright (C) 1994, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains a floating-point implementation of the
+ * forward DCT (Discrete Cosine Transform).
+ *
+ * This implementation should be more accurate than either of the integer
+ * DCT implementations.  However, it may not give the same results on all
+ * machines because of differences in roundoff behavior.  Speed will depend
+ * on the hardware's floating point capacity.
+ *
+ * A 2-D DCT can be done by 1-D DCT on each row followed by 1-D DCT
+ * on each column.  Direct algorithms are also available, but they are
+ * much more complex and seem not to be any faster when reduced to code.
+ *
+ * This implementation is based on Arai, Agui, and Nakajima's algorithm for
+ * scaled DCT.  Their original paper (Trans. IEICE E-71(11):1095) is in
+ * Japanese, but the algorithm is described in the Pennebaker & Mitchell
+ * JPEG textbook (see REFERENCES section in file README).  The following code
+ * is based directly on figure 4-8 in P&M.
+ * While an 8-point DCT cannot be done in less than 11 multiplies, it is
+ * possible to arrange the computation so that many of the multiplies are
+ * simple scalings of the final outputs.  These multiplies can then be
+ * folded into the multiplications or divisions by the JPEG quantization
+ * table entries.  The AA&N method leaves only 5 multiplies and 29 adds
+ * to be done in the DCT itself.
+ * The primary disadvantage of this method is that with a fixed-point
+ * implementation, accuracy is lost due to imprecise representation of the
+ * scaled quantization values.  However, that problem does not arise if
+ * we use floating point arithmetic.
+ */
+
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jdct.h"		/* Private declarations for DCT subsystem */
+
+#ifdef DCT_FLOAT_SUPPORTED
+
+
+/*
+ * This module is specialized to the case DCTSIZE = 8.
+ */
+
+#if DCTSIZE != 8
+  Sorry, this code only copes with 8x8 DCTs. /* deliberate syntax err */
+#endif
+
+
+/*
+ * Perform the forward DCT on one block of samples.
+ */
+
+GLOBAL void
+jpeg_fdct_float (FAST_FLOAT * data)
+{
+  FAST_FLOAT tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
+  FAST_FLOAT tmp10, tmp11, tmp12, tmp13;
+  FAST_FLOAT z1, z2, z3, z4, z5, z11, z13;
+  FAST_FLOAT *dataptr;
+  int ctr;
+
+  /* Pass 1: process rows. */
+
+  dataptr = data;
+  for (ctr = DCTSIZE-1; ctr >= 0; ctr--) {
+    tmp0 = dataptr[0] + dataptr[7];
+    tmp7 = dataptr[0] - dataptr[7];
+    tmp1 = dataptr[1] + dataptr[6];
+    tmp6 = dataptr[1] - dataptr[6];
+    tmp2 = dataptr[2] + dataptr[5];
+    tmp5 = dataptr[2] - dataptr[5];
+    tmp3 = dataptr[3] + dataptr[4];
+    tmp4 = dataptr[3] - dataptr[4];
+    
+    /* Even part */
+    
+    tmp10 = tmp0 + tmp3;	/* phase 2 */
+    tmp13 = tmp0 - tmp3;
+    tmp11 = tmp1 + tmp2;
+    tmp12 = tmp1 - tmp2;
+    
+    dataptr[0] = tmp10 + tmp11; /* phase 3 */
+    dataptr[4] = tmp10 - tmp11;
+    
+    z1 = (tmp12 + tmp13) * ((FAST_FLOAT) 0.707106781); /* c4 */
+    dataptr[2] = tmp13 + z1;	/* phase 5 */
+    dataptr[6] = tmp13 - z1;
+    
+    /* Odd part */
+
+    tmp10 = tmp4 + tmp5;	/* phase 2 */
+    tmp11 = tmp5 + tmp6;
+    tmp12 = tmp6 + tmp7;
+
+    /* The rotator is modified from fig 4-8 to avoid extra negations. */
+    z5 = (tmp10 - tmp12) * ((FAST_FLOAT) 0.382683433); /* c6 */
+    z2 = ((FAST_FLOAT) 0.541196100) * tmp10 + z5; /* c2-c6 */
+    z4 = ((FAST_FLOAT) 1.306562965) * tmp12 + z5; /* c2+c6 */
+    z3 = tmp11 * ((FAST_FLOAT) 0.707106781); /* c4 */
+
+    z11 = tmp7 + z3;		/* phase 5 */
+    z13 = tmp7 - z3;
+
+    dataptr[5] = z13 + z2;	/* phase 6 */
+    dataptr[3] = z13 - z2;
+    dataptr[1] = z11 + z4;
+    dataptr[7] = z11 - z4;
+
+    dataptr += DCTSIZE;		/* advance pointer to next row */
+  }
+
+  /* Pass 2: process columns. */
+
+  dataptr = data;
+  for (ctr = DCTSIZE-1; ctr >= 0; ctr--) {
+    tmp0 = dataptr[DCTSIZE*0] + dataptr[DCTSIZE*7];
+    tmp7 = dataptr[DCTSIZE*0] - dataptr[DCTSIZE*7];
+    tmp1 = dataptr[DCTSIZE*1] + dataptr[DCTSIZE*6];
+    tmp6 = dataptr[DCTSIZE*1] - dataptr[DCTSIZE*6];
+    tmp2 = dataptr[DCTSIZE*2] + dataptr[DCTSIZE*5];
+    tmp5 = dataptr[DCTSIZE*2] - dataptr[DCTSIZE*5];
+    tmp3 = dataptr[DCTSIZE*3] + dataptr[DCTSIZE*4];
+    tmp4 = dataptr[DCTSIZE*3] - dataptr[DCTSIZE*4];
+    
+    /* Even part */
+    
+    tmp10 = tmp0 + tmp3;	/* phase 2 */
+    tmp13 = tmp0 - tmp3;
+    tmp11 = tmp1 + tmp2;
+    tmp12 = tmp1 - tmp2;
+    
+    dataptr[DCTSIZE*0] = tmp10 + tmp11; /* phase 3 */
+    dataptr[DCTSIZE*4] = tmp10 - tmp11;
+    
+    z1 = (tmp12 + tmp13) * ((FAST_FLOAT) 0.707106781); /* c4 */
+    dataptr[DCTSIZE*2] = tmp13 + z1; /* phase 5 */
+    dataptr[DCTSIZE*6] = tmp13 - z1;
+    
+    /* Odd part */
+
+    tmp10 = tmp4 + tmp5;	/* phase 2 */
+    tmp11 = tmp5 + tmp6;
+    tmp12 = tmp6 + tmp7;
+
+    /* The rotator is modified from fig 4-8 to avoid extra negations. */
+    z5 = (tmp10 - tmp12) * ((FAST_FLOAT) 0.382683433); /* c6 */
+    z2 = ((FAST_FLOAT) 0.541196100) * tmp10 + z5; /* c2-c6 */
+    z4 = ((FAST_FLOAT) 1.306562965) * tmp12 + z5; /* c2+c6 */
+    z3 = tmp11 * ((FAST_FLOAT) 0.707106781); /* c4 */
+
+    z11 = tmp7 + z3;		/* phase 5 */
+    z13 = tmp7 - z3;
+
+    dataptr[DCTSIZE*5] = z13 + z2; /* phase 6 */
+    dataptr[DCTSIZE*3] = z13 - z2;
+    dataptr[DCTSIZE*1] = z11 + z4;
+    dataptr[DCTSIZE*7] = z11 - z4;
+
+    dataptr++;			/* advance pointer to next column */
+  }
+}
+
+#endif /* DCT_FLOAT_SUPPORTED */
diff --git a/code/jpeg-6/jidctflt.cpp b/code/jpeg-6/jidctflt.cpp
new file mode 100644
index 0000000..523dc45
--- /dev/null
+++ b/code/jpeg-6/jidctflt.cpp
@@ -0,0 +1,246 @@
+/*
+ * jidctflt.c
+ *
+ * Copyright (C) 1994, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains a floating-point implementation of the
+ * inverse DCT (Discrete Cosine Transform).  In the IJG code, this routine
+ * must also perform dequantization of the input coefficients.
+ *
+ * This implementation should be more accurate than either of the integer
+ * IDCT implementations.  However, it may not give the same results on all
+ * machines because of differences in roundoff behavior.  Speed will depend
+ * on the hardware's floating point capacity.
+ *
+ * A 2-D IDCT can be done by 1-D IDCT on each column followed by 1-D IDCT
+ * on each row (or vice versa, but it's more convenient to emit a row at
+ * a time).  Direct algorithms are also available, but they are much more
+ * complex and seem not to be any faster when reduced to code.
+ *
+ * This implementation is based on Arai, Agui, and Nakajima's algorithm for
+ * scaled DCT.  Their original paper (Trans. IEICE E-71(11):1095) is in
+ * Japanese, but the algorithm is described in the Pennebaker & Mitchell
+ * JPEG textbook (see REFERENCES section in file README).  The following code
+ * is based directly on figure 4-8 in P&M.
+ * While an 8-point DCT cannot be done in less than 11 multiplies, it is
+ * possible to arrange the computation so that many of the multiplies are
+ * simple scalings of the final outputs.  These multiplies can then be
+ * folded into the multiplications or divisions by the JPEG quantization
+ * table entries.  The AA&N method leaves only 5 multiplies and 29 adds
+ * to be done in the DCT itself.
+ * The primary disadvantage of this method is that with a fixed-point
+ * implementation, accuracy is lost due to imprecise representation of the
+ * scaled quantization values.  However, that problem does not arise if
+ * we use floating point arithmetic.
+ */
+
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jdct.h"		/* Private declarations for DCT subsystem */
+
+#ifdef DCT_FLOAT_SUPPORTED
+
+
+/*
+ * This module is specialized to the case DCTSIZE = 8.
+ */
+
+#if DCTSIZE != 8
+  Sorry, this code only copes with 8x8 DCTs. /* deliberate syntax err */
+#endif
+
+
+/* Dequantize a coefficient by multiplying it by the multiplier-table
+ * entry; produce a float result.
+ */
+
+#define DEQUANTIZE(coef,quantval)  (((FAST_FLOAT) (coef)) * (quantval))
+
+
+/*
+ * Perform dequantization and inverse DCT on one block of coefficients.
+ */
+
+GLOBAL void
+jpeg_idct_float (j_decompress_ptr cinfo, jpeg_component_info * compptr,
+		 JCOEFPTR coef_block,
+		 JSAMPARRAY output_buf, JDIMENSION output_col)
+{
+  FAST_FLOAT tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
+  FAST_FLOAT tmp10, tmp11, tmp12, tmp13;
+  FAST_FLOAT z5, z10, z11, z12, z13;
+  JCOEFPTR inptr;
+  FLOAT_MULT_TYPE * quantptr;
+  FAST_FLOAT * wsptr;
+  JSAMPROW outptr;
+  JSAMPLE *range_limit = IDCT_range_limit(cinfo);
+  int ctr;
+  FAST_FLOAT workspace[DCTSIZE2]; /* buffers data between passes */
+  SHIFT_TEMPS
+
+  /* Pass 1: process columns from input, store into work array. */
+
+  inptr = coef_block;
+  quantptr = (FLOAT_MULT_TYPE *) compptr->dct_table;
+  wsptr = workspace;
+  for (ctr = DCTSIZE; ctr > 0; ctr--) {
+    /* Due to quantization, we will usually find that many of the input
+     * coefficients are zero, especially the AC terms.  We can exploit this
+     * by short-circuiting the IDCT calculation for any column in which all
+     * the AC terms are zero.  In that case each output is equal to the
+     * DC coefficient (with scale factor as needed).
+     * With typical images and quantization tables, half or more of the
+     * column DCT calculations can be simplified this way.
+     */
+    
+    if ((inptr[DCTSIZE*1] | inptr[DCTSIZE*2] | inptr[DCTSIZE*3] |
+	 inptr[DCTSIZE*4] | inptr[DCTSIZE*5] | inptr[DCTSIZE*6] |
+	 inptr[DCTSIZE*7]) == 0) {
+      /* AC terms all zero */
+      FAST_FLOAT dcval = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
+      
+      wsptr[DCTSIZE*0] = dcval;
+      wsptr[DCTSIZE*1] = dcval;
+      wsptr[DCTSIZE*2] = dcval;
+      wsptr[DCTSIZE*3] = dcval;
+      wsptr[DCTSIZE*4] = dcval;
+      wsptr[DCTSIZE*5] = dcval;
+      wsptr[DCTSIZE*6] = dcval;
+      wsptr[DCTSIZE*7] = dcval;
+      
+      inptr++;			/* advance pointers to next column */
+      quantptr++;
+      wsptr++;
+      continue;
+    }
+    
+    /* Even part */
+
+    tmp0 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
+    tmp1 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
+    tmp2 = DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]);
+    tmp3 = DEQUANTIZE(inptr[DCTSIZE*6], quantptr[DCTSIZE*6]);
+
+    tmp10 = tmp0 + tmp2;	/* phase 3 */
+    tmp11 = tmp0 - tmp2;
+
+    tmp13 = tmp1 + tmp3;	/* phases 5-3 */
+    tmp12 = (tmp1 - tmp3) * ((FAST_FLOAT) 1.414213562) - tmp13; /* 2*c4 */
+
+    tmp0 = tmp10 + tmp13;	/* phase 2 */
+    tmp3 = tmp10 - tmp13;
+    tmp1 = tmp11 + tmp12;
+    tmp2 = tmp11 - tmp12;
+    
+    /* Odd part */
+
+    tmp4 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
+    tmp5 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]);
+    tmp6 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]);
+    tmp7 = DEQUANTIZE(inptr[DCTSIZE*7], quantptr[DCTSIZE*7]);
+
+    z13 = tmp6 + tmp5;		/* phase 6 */
+    z10 = tmp6 - tmp5;
+    z11 = tmp4 + tmp7;
+    z12 = tmp4 - tmp7;
+
+    tmp7 = z11 + z13;		/* phase 5 */
+    tmp11 = (z11 - z13) * ((FAST_FLOAT) 1.414213562); /* 2*c4 */
+
+    z5 = (z10 + z12) * ((FAST_FLOAT) 1.847759065); /* 2*c2 */
+    tmp10 = ((FAST_FLOAT) 1.082392200) * z12 - z5; /* 2*(c2-c6) */
+    tmp12 = ((FAST_FLOAT) -2.613125930) * z10 + z5; /* -2*(c2+c6) */
+
+    tmp6 = tmp12 - tmp7;	/* phase 2 */
+    tmp5 = tmp11 - tmp6;
+    tmp4 = tmp10 + tmp5;
+
+    wsptr[DCTSIZE*0] = tmp0 + tmp7;
+    wsptr[DCTSIZE*7] = tmp0 - tmp7;
+    wsptr[DCTSIZE*1] = tmp1 + tmp6;
+    wsptr[DCTSIZE*6] = tmp1 - tmp6;
+    wsptr[DCTSIZE*2] = tmp2 + tmp5;
+    wsptr[DCTSIZE*5] = tmp2 - tmp5;
+    wsptr[DCTSIZE*4] = tmp3 + tmp4;
+    wsptr[DCTSIZE*3] = tmp3 - tmp4;
+
+    inptr++;			/* advance pointers to next column */
+    quantptr++;
+    wsptr++;
+  }
+  
+  /* Pass 2: process rows from work array, store into output array. */
+  /* Note that we must descale the results by a factor of 8 == 2**3. */
+
+  wsptr = workspace;
+  for (ctr = 0; ctr < DCTSIZE; ctr++) {
+    outptr = output_buf[ctr] + output_col;
+    /* Rows of zeroes can be exploited in the same way as we did with columns.
+     * However, the column calculation has created many nonzero AC terms, so
+     * the simplification applies less often (typically 5% to 10% of the time).
+     * And testing floats for zero is relatively expensive, so we don't bother.
+     */
+    
+    /* Even part */
+
+    tmp10 = wsptr[0] + wsptr[4];
+    tmp11 = wsptr[0] - wsptr[4];
+
+    tmp13 = wsptr[2] + wsptr[6];
+    tmp12 = (wsptr[2] - wsptr[6]) * ((FAST_FLOAT) 1.414213562) - tmp13;
+
+    tmp0 = tmp10 + tmp13;
+    tmp3 = tmp10 - tmp13;
+    tmp1 = tmp11 + tmp12;
+    tmp2 = tmp11 - tmp12;
+
+    /* Odd part */
+
+    z13 = wsptr[5] + wsptr[3];
+    z10 = wsptr[5] - wsptr[3];
+    z11 = wsptr[1] + wsptr[7];
+    z12 = wsptr[1] - wsptr[7];
+
+    tmp7 = z11 + z13;
+    tmp11 = (z11 - z13) * ((FAST_FLOAT) 1.414213562);
+
+    z5 = (z10 + z12) * ((FAST_FLOAT) 1.847759065); /* 2*c2 */
+    tmp10 = ((FAST_FLOAT) 1.082392200) * z12 - z5; /* 2*(c2-c6) */
+    tmp12 = ((FAST_FLOAT) -2.613125930) * z10 + z5; /* -2*(c2+c6) */
+
+    tmp6 = tmp12 - tmp7;
+    tmp5 = tmp11 - tmp6;
+    tmp4 = tmp10 + tmp5;
+
+    /* Final output stage: scale down by a factor of 8 and range-limit */
+
+    outptr[0] = range_limit[(int) DESCALE((INT32) (tmp0 + tmp7), 3)
+			    & RANGE_MASK];
+    outptr[7] = range_limit[(int) DESCALE((INT32) (tmp0 - tmp7), 3)
+			    & RANGE_MASK];
+    outptr[1] = range_limit[(int) DESCALE((INT32) (tmp1 + tmp6), 3)
+			    & RANGE_MASK];
+    outptr[6] = range_limit[(int) DESCALE((INT32) (tmp1 - tmp6), 3)
+			    & RANGE_MASK];
+    outptr[2] = range_limit[(int) DESCALE((INT32) (tmp2 + tmp5), 3)
+			    & RANGE_MASK];
+    outptr[5] = range_limit[(int) DESCALE((INT32) (tmp2 - tmp5), 3)
+			    & RANGE_MASK];
+    outptr[4] = range_limit[(int) DESCALE((INT32) (tmp3 + tmp4), 3)
+			    & RANGE_MASK];
+    outptr[3] = range_limit[(int) DESCALE((INT32) (tmp3 - tmp4), 3)
+			    & RANGE_MASK];
+    
+    wsptr += DCTSIZE;		/* advance pointer to next row */
+  }
+}
+
+#endif /* DCT_FLOAT_SUPPORTED */
diff --git a/code/jpeg-6/jinclude.h b/code/jpeg-6/jinclude.h
new file mode 100644
index 0000000..99f535d
--- /dev/null
+++ b/code/jpeg-6/jinclude.h
@@ -0,0 +1,116 @@
+/*
+ * jinclude.h
+ *
+ * Copyright (C) 1991-1994, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file exists to provide a single place to fix any problems with
+ * including the wrong system include files.  (Common problems are taken
+ * care of by the standard jconfig symbols, but on really weird systems
+ * you may have to edit this file.)
+ *
+ * NOTE: this file is NOT intended to be included by applications using the
+ * JPEG library.  Most applications need only include jpeglib.h.
+ */
+
+
+#ifdef _WIN32
+
+#pragma warning(disable : 4018)     // signed/unsigned mismatch
+#pragma warning(disable : 4032)
+#pragma warning(disable : 4051)
+#pragma warning(disable : 4057)		// slightly different base types
+#pragma warning(disable : 4100)		// unreferenced formal parameter
+#pragma warning(disable : 4115)
+#pragma warning(disable : 4125)		// decimal digit terminates octal escape sequence
+#pragma warning(disable : 4127)		// conditional expression is constant
+#pragma warning(disable : 4136)
+#pragma warning(disable : 4152)		// nonstandard extension, function/data pointer conversion in expression
+#pragma warning(disable : 4201)
+#pragma warning(disable : 4214)
+#pragma warning(disable : 4244)
+#pragma warning(disable : 4305)		// truncation from const double to float
+#pragma warning(disable : 4310)		// cast truncates constant value
+#pragma warning(disable:  4505) 	// unreferenced local function has been removed
+#pragma warning(disable : 4514)
+#pragma warning(disable : 4702)		// unreachable code
+#pragma warning(disable : 4711)		// selected for automatic inline expansion
+#pragma warning(disable : 4220)		// varargs matches remaining parameters
+#pragma warning(disable : 4761)		// integral size mismatch 
+#endif
+
+/* Include auto-config file to find out which system include files we need. */
+
+#include "../jpeg-6/jconfig.h"		/* auto configuration options */
+#define JCONFIG_INCLUDED	/* so that jpeglib.h doesn't do it again */
+
+/*
+ * We need the NULL macro and size_t typedef.
+ * On an ANSI-conforming system it is sufficient to include <stddef.h>.
+ * Otherwise, we get them from <stdlib.h> or <stdio.h>; we may have to
+ * pull in <sys/types.h> as well.
+ * Note that the core JPEG library does not require <stdio.h>;
+ * only the default error handler and data source/destination modules do.
+ * But we must pull it in because of the references to FILE in jpeglib.h.
+ * You can remove those references if you want to compile without <stdio.h>.
+ */
+
+#ifdef HAVE_STDDEF_H
+#include <stddef.h>
+#endif
+
+#ifdef HAVE_STDLIB_H
+#include <stdlib.h>
+#endif
+
+#ifdef NEED_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+
+#include <stdio.h>
+
+/*
+ * We need memory copying and zeroing functions, plus strncpy().
+ * ANSI and System V implementations declare these in <string.h>.
+ * BSD doesn't have the mem() functions, but it does have bcopy()/bzero().
+ * Some systems may declare memset and memcpy in <memory.h>.
+ *
+ * NOTE: we assume the size parameters to these functions are of type size_t.
+ * Change the casts in these macros if not!
+ */
+
+#ifdef NEED_BSD_STRINGS
+
+#include <strings.h>
+#define MEMZERO(target,size)	bzero((void *)(target), (size_t)(size))
+#define MEMCOPY(dest,src,size)	bcopy((const void *)(src), (void *)(dest), (size_t)(size))
+
+#else /* not BSD, assume ANSI/SysV string lib */
+
+#include <string.h>
+#define MEMZERO(target,size)	memset((void *)(target), 0, (size_t)(size))
+#define MEMCOPY(dest,src,size)	memcpy((void *)(dest), (const void *)(src), (size_t)(size))
+
+#endif
+
+/*
+ * In ANSI C, and indeed any rational implementation, size_t is also the
+ * type returned by sizeof().  However, it seems there are some irrational
+ * implementations out there, in which sizeof() returns an int even though
+ * size_t is defined as long or unsigned long.  To ensure consistent results
+ * we always use this SIZEOF() macro in place of using sizeof() directly.
+ */
+
+#define SIZEOF(object)	((size_t) sizeof(object))
+
+/*
+ * The modules that use fread() and fwrite() always invoke them through
+ * these macros.  On some systems you may need to twiddle the argument casts.
+ * CAUTION: argument order is different from underlying functions!
+ */
+
+#define JFREAD(file,buf,sizeofbuf)  \
+  ((size_t) fread((void *) (buf), (size_t) 1, (size_t) (sizeofbuf), (file)))
+#define JFWRITE(file,buf,sizeofbuf)  \
+  ((size_t) fwrite((const void *) (buf), (size_t) 1, (size_t) (sizeofbuf), (file)))
diff --git a/code/jpeg-6/jmemmgr.cpp b/code/jpeg-6/jmemmgr.cpp
new file mode 100644
index 0000000..048f2c0
--- /dev/null
+++ b/code/jpeg-6/jmemmgr.cpp
@@ -0,0 +1,1120 @@
+/*
+ * jmemmgr.c
+ *
+ * Copyright (C) 1991-1995, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains the JPEG system-independent memory management
+ * routines.  This code is usable across a wide variety of machines; most
+ * of the system dependencies have been isolated in a separate file.
+ * The major functions provided here are:
+ *   * pool-based allocation and freeing of memory;
+ *   * policy decisions about how to divide available memory among the
+ *     virtual arrays;
+ *   * control logic for swapping virtual arrays between main memory and
+ *     backing storage.
+ * The separate system-dependent file provides the actual backing-storage
+ * access code, and it contains the policy decision about how much total
+ * main memory to use.
+ * This file is system-dependent in the sense that some of its functions
+ * are unnecessary in some systems.  For example, if there is enough virtual
+ * memory so that backing storage will never be used, much of the virtual
+ * array control logic could be removed.  (Of course, if you have that much
+ * memory then you shouldn't care about a little bit of unused code...)
+ */
+
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+
+#define JPEG_INTERNALS
+#define AM_MEMORY_MANAGER	/* we define jvirt_Xarray_control structs */
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jmemsys.h"		/* import the system-dependent declarations */
+
+#ifndef NO_GETENV
+#ifndef HAVE_STDLIB_H		/* <stdlib.h> should declare getenv() */
+extern char * getenv JPP((const char * name));
+#endif
+#endif
+
+
+/*
+ * Some important notes:
+ *   The allocation routines provided here must never return NULL.
+ *   They should exit to error_exit if unsuccessful.
+ *
+ *   It's not a good idea to try to merge the sarray and barray routines,
+ *   even though they are textually almost the same, because samples are
+ *   usually stored as bytes while coefficients are shorts or ints.  Thus,
+ *   in machines where byte pointers have a different representation from
+ *   word pointers, the resulting machine code could not be the same.
+ */
+
+
+/*
+ * Many machines require storage alignment: longs must start on 4-byte
+ * boundaries, doubles on 8-byte boundaries, etc.  On such machines, malloc()
+ * always returns pointers that are multiples of the worst-case alignment
+ * requirement, and we had better do so too.
+ * There isn't any really portable way to determine the worst-case alignment
+ * requirement.  This module assumes that the alignment requirement is
+ * multiples of sizeof(ALIGN_TYPE).
+ * By default, we define ALIGN_TYPE as double.  This is necessary on some
+ * workstations (where doubles really do need 8-byte alignment) and will work
+ * fine on nearly everything.  If your machine has lesser alignment needs,
+ * you can save a few bytes by making ALIGN_TYPE smaller.
+ * The only place I know of where this will NOT work is certain Macintosh
+ * 680x0 compilers that define double as a 10-byte IEEE extended float.
+ * Doing 10-byte alignment is counterproductive because longwords won't be
+ * aligned well.  Put "#define ALIGN_TYPE long" in jconfig.h if you have
+ * such a compiler.
+ */
+
+#ifndef ALIGN_TYPE		/* so can override from jconfig.h */
+#define ALIGN_TYPE  double
+#endif
+
+
+/*
+ * We allocate objects from "pools", where each pool is gotten with a single
+ * request to jpeg_get_small() or jpeg_get_large().  There is no per-object
+ * overhead within a pool, except for alignment padding.  Each pool has a
+ * header with a link to the next pool of the same class.
+ * Small and large pool headers are identical except that the latter's
+ * link pointer must be FAR on 80x86 machines.
+ * Notice that the "real" header fields are union'ed with a dummy ALIGN_TYPE
+ * field.  This forces the compiler to make SIZEOF(small_pool_hdr) a multiple
+ * of the alignment requirement of ALIGN_TYPE.
+ */
+
+typedef union small_pool_struct * small_pool_ptr;
+
+typedef union small_pool_struct {
+  struct {
+    small_pool_ptr next;	/* next in list of pools */
+    size_t bytes_used;		/* how many bytes already used within pool */
+    size_t bytes_left;		/* bytes still available in this pool */
+  } hdr;
+  ALIGN_TYPE dummy;		/* included in union to ensure alignment */
+} small_pool_hdr;
+
+typedef union large_pool_struct FAR * large_pool_ptr;
+
+typedef union large_pool_struct {
+  struct {
+    large_pool_ptr next;	/* next in list of pools */
+    size_t bytes_used;		/* how many bytes already used within pool */
+    size_t bytes_left;		/* bytes still available in this pool */
+  } hdr;
+  ALIGN_TYPE dummy;		/* included in union to ensure alignment */
+} large_pool_hdr;
+
+
+/*
+ * Here is the full definition of a memory manager object.
+ */
+
+typedef struct {
+  struct jpeg_memory_mgr pub;	/* public fields */
+
+  /* Each pool identifier (lifetime class) names a linked list of pools. */
+  small_pool_ptr small_list[JPOOL_NUMPOOLS];
+  large_pool_ptr large_list[JPOOL_NUMPOOLS];
+
+  /* Since we only have one lifetime class of virtual arrays, only one
+   * linked list is necessary (for each datatype).  Note that the virtual
+   * array control blocks being linked together are actually stored somewhere
+   * in the small-pool list.
+   */
+  jvirt_sarray_ptr virt_sarray_list;
+  jvirt_barray_ptr virt_barray_list;
+
+  /* This counts total space obtained from jpeg_get_small/large */
+  long total_space_allocated;
+
+  /* alloc_sarray and alloc_barray set this value for use by virtual
+   * array routines.
+   */
+  JDIMENSION last_rowsperchunk;	/* from most recent alloc_sarray/barray */
+} my_memory_mgr;
+
+typedef my_memory_mgr * my_mem_ptr;
+
+
+/*
+ * The control blocks for virtual arrays.
+ * Note that these blocks are allocated in the "small" pool area.
+ * System-dependent info for the associated backing store (if any) is hidden
+ * inside the backing_store_info struct.
+ */
+
+struct jvirt_sarray_control {
+  JSAMPARRAY mem_buffer;	/* => the in-memory buffer */
+  JDIMENSION rows_in_array;	/* total virtual array height */
+  JDIMENSION samplesperrow;	/* width of array (and of memory buffer) */
+  JDIMENSION maxaccess;		/* max rows accessed by access_virt_sarray */
+  JDIMENSION rows_in_mem;	/* height of memory buffer */
+  JDIMENSION rowsperchunk;	/* allocation chunk size in mem_buffer */
+  JDIMENSION cur_start_row;	/* first logical row # in the buffer */
+  JDIMENSION first_undef_row;	/* row # of first uninitialized row */
+  boolean pre_zero;		/* pre-zero mode requested? */
+  boolean dirty;		/* do current buffer contents need written? */
+  boolean b_s_open;		/* is backing-store data valid? */
+  jvirt_sarray_ptr next;	/* link to next virtual sarray control block */
+  backing_store_info b_s_info;	/* System-dependent control info */
+};
+
+struct jvirt_barray_control {
+  JBLOCKARRAY mem_buffer;	/* => the in-memory buffer */
+  JDIMENSION rows_in_array;	/* total virtual array height */
+  JDIMENSION blocksperrow;	/* width of array (and of memory buffer) */
+  JDIMENSION maxaccess;		/* max rows accessed by access_virt_barray */
+  JDIMENSION rows_in_mem;	/* height of memory buffer */
+  JDIMENSION rowsperchunk;	/* allocation chunk size in mem_buffer */
+  JDIMENSION cur_start_row;	/* first logical row # in the buffer */
+  JDIMENSION first_undef_row;	/* row # of first uninitialized row */
+  boolean pre_zero;		/* pre-zero mode requested? */
+  boolean dirty;		/* do current buffer contents need written? */
+  boolean b_s_open;		/* is backing-store data valid? */
+  jvirt_barray_ptr next;	/* link to next virtual barray control block */
+  backing_store_info b_s_info;	/* System-dependent control info */
+};
+
+
+#ifdef MEM_STATS		/* optional extra stuff for statistics */
+
+LOCAL void
+print_mem_stats (j_common_ptr cinfo, int pool_id)
+{
+  my_mem_ptr mem = (my_mem_ptr) cinfo->mem;
+  small_pool_ptr shdr_ptr;
+  large_pool_ptr lhdr_ptr;
+
+  /* Since this is only a debugging stub, we can cheat a little by using
+   * fprintf directly rather than going through the trace message code.
+   * This is helpful because message parm array can't handle longs.
+   */
+  fprintf(stderr, "Freeing pool %d, total space = %ld\n",
+	  pool_id, mem->total_space_allocated);
+
+  for (lhdr_ptr = mem->large_list[pool_id]; lhdr_ptr != NULL;
+       lhdr_ptr = lhdr_ptr->hdr.next) {
+    fprintf(stderr, "  Large chunk used %ld\n",
+	    (long) lhdr_ptr->hdr.bytes_used);
+  }
+
+  for (shdr_ptr = mem->small_list[pool_id]; shdr_ptr != NULL;
+       shdr_ptr = shdr_ptr->hdr.next) {
+    fprintf(stderr, "  Small chunk used %ld free %ld\n",
+	    (long) shdr_ptr->hdr.bytes_used,
+	    (long) shdr_ptr->hdr.bytes_left);
+  }
+}
+
+#endif /* MEM_STATS */
+
+
+LOCAL void
+out_of_memory (j_common_ptr cinfo, int which)
+/* Report an out-of-memory error and stop execution */
+/* If we compiled MEM_STATS support, report alloc requests before dying */
+{
+#ifdef MEM_STATS
+  cinfo->err->trace_level = 2;	/* force self_destruct to report stats */
+#endif
+  ERREXIT1(cinfo, JERR_OUT_OF_MEMORY, which);
+}
+
+
+/*
+ * Allocation of "small" objects.
+ *
+ * For these, we use pooled storage.  When a new pool must be created,
+ * we try to get enough space for the current request plus a "slop" factor,
+ * where the slop will be the amount of leftover space in the new pool.
+ * The speed vs. space tradeoff is largely determined by the slop values.
+ * A different slop value is provided for each pool class (lifetime),
+ * and we also distinguish the first pool of a class from later ones.
+ * NOTE: the values given work fairly well on both 16- and 32-bit-int
+ * machines, but may be too small if longs are 64 bits or more.
+ */
+
+static const size_t first_pool_slop[JPOOL_NUMPOOLS] = 
+{
+	1600,			/* first PERMANENT pool */
+	16000			/* first IMAGE pool */
+};
+
+static const size_t extra_pool_slop[JPOOL_NUMPOOLS] = 
+{
+	0,			/* additional PERMANENT pools */
+	5000			/* additional IMAGE pools */
+};
+
+#define MIN_SLOP  50		/* greater than 0 to avoid futile looping */
+
+
+METHODDEF void *
+alloc_small (j_common_ptr cinfo, int pool_id, size_t sizeofobject)
+/* Allocate a "small" object */
+{
+  my_mem_ptr mem = (my_mem_ptr) cinfo->mem;
+  small_pool_ptr hdr_ptr, prev_hdr_ptr;
+  char * data_ptr;
+  size_t odd_bytes, min_request, slop;
+
+  /* Check for unsatisfiable request (do now to ensure no overflow below) */
+  if (sizeofobject > (size_t) (MAX_ALLOC_CHUNK-SIZEOF(small_pool_hdr)))
+    out_of_memory(cinfo, 1);	/* request exceeds malloc's ability */
+
+  /* Round up the requested size to a multiple of SIZEOF(ALIGN_TYPE) */
+  odd_bytes = sizeofobject % SIZEOF(ALIGN_TYPE);
+  if (odd_bytes > 0)
+    sizeofobject += SIZEOF(ALIGN_TYPE) - odd_bytes;
+
+  /* See if space is available in any existing pool */
+  if (pool_id < 0 || pool_id >= JPOOL_NUMPOOLS)
+    ERREXIT1(cinfo, JERR_BAD_POOL_ID, pool_id);	/* safety check */
+  prev_hdr_ptr = NULL;
+  hdr_ptr = mem->small_list[pool_id];
+  while (hdr_ptr != NULL) {
+    if (hdr_ptr->hdr.bytes_left >= sizeofobject)
+      break;			/* found pool with enough space */
+    prev_hdr_ptr = hdr_ptr;
+    hdr_ptr = hdr_ptr->hdr.next;
+  }
+
+  /* Time to make a new pool? */
+  if (hdr_ptr == NULL) {
+    /* min_request is what we need now, slop is what will be leftover */
+    min_request = sizeofobject + SIZEOF(small_pool_hdr);
+    if (prev_hdr_ptr == NULL)	/* first pool in class? */
+      slop = first_pool_slop[pool_id];
+    else
+      slop = extra_pool_slop[pool_id];
+    /* Don't ask for more than MAX_ALLOC_CHUNK */
+    if (slop > (size_t) (MAX_ALLOC_CHUNK-min_request))
+      slop = (size_t) (MAX_ALLOC_CHUNK-min_request);
+    /* Try to get space, if fail reduce slop and try again */
+    for (;;) {
+      hdr_ptr = (small_pool_ptr) jpeg_get_small(cinfo, min_request + slop);
+      if (hdr_ptr != NULL)
+	break;
+      slop /= 2;
+      if (slop < MIN_SLOP)	/* give up when it gets real small */
+	out_of_memory(cinfo, 2); /* jpeg_get_small failed */
+    }
+    mem->total_space_allocated += min_request + slop;
+    /* Success, initialize the new pool header and add to end of list */
+    hdr_ptr->hdr.next = NULL;
+    hdr_ptr->hdr.bytes_used = 0;
+    hdr_ptr->hdr.bytes_left = sizeofobject + slop;
+    if (prev_hdr_ptr == NULL)	/* first pool in class? */
+      mem->small_list[pool_id] = hdr_ptr;
+    else
+      prev_hdr_ptr->hdr.next = hdr_ptr;
+  }
+
+  /* OK, allocate the object from the current pool */
+  data_ptr = (char *) (hdr_ptr + 1); /* point to first data byte in pool */
+  data_ptr += hdr_ptr->hdr.bytes_used; /* point to place for object */
+  hdr_ptr->hdr.bytes_used += sizeofobject;
+  hdr_ptr->hdr.bytes_left -= sizeofobject;
+
+  return (void *) data_ptr;
+}
+
+
+/*
+ * Allocation of "large" objects.
+ *
+ * The external semantics of these are the same as "small" objects,
+ * except that FAR pointers are used on 80x86.  However the pool
+ * management heuristics are quite different.  We assume that each
+ * request is large enough that it may as well be passed directly to
+ * jpeg_get_large; the pool management just links everything together
+ * so that we can free it all on demand.
+ * Note: the major use of "large" objects is in JSAMPARRAY and JBLOCKARRAY
+ * structures.  The routines that create these structures (see below)
+ * deliberately bunch rows together to ensure a large request size.
+ */
+
+METHODDEF void FAR *
+alloc_large (j_common_ptr cinfo, int pool_id, size_t sizeofobject)
+/* Allocate a "large" object */
+{
+  my_mem_ptr mem = (my_mem_ptr) cinfo->mem;
+  large_pool_ptr hdr_ptr;
+  size_t odd_bytes;
+
+  /* Check for unsatisfiable request (do now to ensure no overflow below) */
+  if (sizeofobject > (size_t) (MAX_ALLOC_CHUNK-SIZEOF(large_pool_hdr)))
+    out_of_memory(cinfo, 3);	/* request exceeds malloc's ability */
+
+  /* Round up the requested size to a multiple of SIZEOF(ALIGN_TYPE) */
+  odd_bytes = sizeofobject % SIZEOF(ALIGN_TYPE);
+  if (odd_bytes > 0)
+    sizeofobject += SIZEOF(ALIGN_TYPE) - odd_bytes;
+
+  /* Always make a new pool */
+  if (pool_id < 0 || pool_id >= JPOOL_NUMPOOLS)
+    ERREXIT1(cinfo, JERR_BAD_POOL_ID, pool_id);	/* safety check */
+
+  hdr_ptr = (large_pool_ptr) jpeg_get_large(cinfo, sizeofobject +
+					    SIZEOF(large_pool_hdr));
+  if (hdr_ptr == NULL)
+    out_of_memory(cinfo, 4);	/* jpeg_get_large failed */
+  mem->total_space_allocated += sizeofobject + SIZEOF(large_pool_hdr);
+
+  /* Success, initialize the new pool header and add to list */
+  hdr_ptr->hdr.next = mem->large_list[pool_id];
+  /* We maintain space counts in each pool header for statistical purposes,
+   * even though they are not needed for allocation.
+   */
+  hdr_ptr->hdr.bytes_used = sizeofobject;
+  hdr_ptr->hdr.bytes_left = 0;
+  mem->large_list[pool_id] = hdr_ptr;
+
+  return (void FAR *) (hdr_ptr + 1); /* point to first data byte in pool */
+}
+
+
+/*
+ * Creation of 2-D sample arrays.
+ * The pointers are in near heap, the samples themselves in FAR heap.
+ *
+ * To minimize allocation overhead and to allow I/O of large contiguous
+ * blocks, we allocate the sample rows in groups of as many rows as possible
+ * without exceeding MAX_ALLOC_CHUNK total bytes per allocation request.
+ * NB: the virtual array control routines, later in this file, know about
+ * this chunking of rows.  The rowsperchunk value is left in the mem manager
+ * object so that it can be saved away if this sarray is the workspace for
+ * a virtual array.
+ */
+
+METHODDEF JSAMPARRAY
+alloc_sarray (j_common_ptr cinfo, int pool_id,
+	      JDIMENSION samplesperrow, JDIMENSION numrows)
+/* Allocate a 2-D sample array */
+{
+  my_mem_ptr mem = (my_mem_ptr) cinfo->mem;
+  JSAMPARRAY result;
+  JSAMPROW workspace;
+  JDIMENSION rowsperchunk, currow, i;
+  long ltemp;
+
+  /* Calculate max # of rows allowed in one allocation chunk */
+  ltemp = (MAX_ALLOC_CHUNK-SIZEOF(large_pool_hdr)) /
+	  ((long) samplesperrow * SIZEOF(JSAMPLE));
+  if (ltemp <= 0)
+    ERREXIT(cinfo, JERR_WIDTH_OVERFLOW);
+  if (ltemp < (long) numrows)
+    rowsperchunk = (JDIMENSION) ltemp;
+  else
+    rowsperchunk = numrows;
+  mem->last_rowsperchunk = rowsperchunk;
+
+  /* Get space for row pointers (small object) */
+  result = (JSAMPARRAY) alloc_small(cinfo, pool_id,
+				    (size_t) (numrows * SIZEOF(JSAMPROW)));
+
+  /* Get the rows themselves (large objects) */
+  currow = 0;
+  while (currow < numrows) {
+    rowsperchunk = MIN(rowsperchunk, numrows - currow);
+    workspace = (JSAMPROW) alloc_large(cinfo, pool_id,
+	(size_t) ((size_t) rowsperchunk * (size_t) samplesperrow
+		  * SIZEOF(JSAMPLE)));
+    for (i = rowsperchunk; i > 0; i--) {
+      result[currow++] = workspace;
+      workspace += samplesperrow;
+    }
+  }
+
+  return result;
+}
+
+
+/*
+ * Creation of 2-D coefficient-block arrays.
+ * This is essentially the same as the code for sample arrays, above.
+ */
+
+METHODDEF JBLOCKARRAY
+alloc_barray (j_common_ptr cinfo, int pool_id,
+	      JDIMENSION blocksperrow, JDIMENSION numrows)
+/* Allocate a 2-D coefficient-block array */
+{
+  my_mem_ptr mem = (my_mem_ptr) cinfo->mem;
+  JBLOCKARRAY result;
+  JBLOCKROW workspace;
+  JDIMENSION rowsperchunk, currow, i;
+  long ltemp;
+
+  /* Calculate max # of rows allowed in one allocation chunk */
+  ltemp = (MAX_ALLOC_CHUNK-SIZEOF(large_pool_hdr)) /
+	  ((long) blocksperrow * SIZEOF(JBLOCK));
+  if (ltemp <= 0)
+    ERREXIT(cinfo, JERR_WIDTH_OVERFLOW);
+  if (ltemp < (long) numrows)
+    rowsperchunk = (JDIMENSION) ltemp;
+  else
+    rowsperchunk = numrows;
+  mem->last_rowsperchunk = rowsperchunk;
+
+  /* Get space for row pointers (small object) */
+  result = (JBLOCKARRAY) alloc_small(cinfo, pool_id,
+				     (size_t) (numrows * SIZEOF(JBLOCKROW)));
+
+  /* Get the rows themselves (large objects) */
+  currow = 0;
+  while (currow < numrows) {
+    rowsperchunk = MIN(rowsperchunk, numrows - currow);
+    workspace = (JBLOCKROW) alloc_large(cinfo, pool_id,
+	(size_t) ((size_t) rowsperchunk * (size_t) blocksperrow
+		  * SIZEOF(JBLOCK)));
+    for (i = rowsperchunk; i > 0; i--) {
+      result[currow++] = workspace;
+      workspace += blocksperrow;
+    }
+  }
+
+  return result;
+}
+
+
+/*
+ * About virtual array management:
+ *
+ * The above "normal" array routines are only used to allocate strip buffers
+ * (as wide as the image, but just a few rows high).  Full-image-sized buffers
+ * are handled as "virtual" arrays.  The array is still accessed a strip at a
+ * time, but the memory manager must save the whole array for repeated
+ * accesses.  The intended implementation is that there is a strip buffer in
+ * memory (as high as is possible given the desired memory limit), plus a
+ * backing file that holds the rest of the array.
+ *
+ * The request_virt_array routines are told the total size of the image and
+ * the maximum number of rows that will be accessed at once.  The in-memory
+ * buffer must be at least as large as the maxaccess value.
+ *
+ * The request routines create control blocks but not the in-memory buffers.
+ * That is postponed until realize_virt_arrays is called.  At that time the
+ * total amount of space needed is known (approximately, anyway), so free
+ * memory can be divided up fairly.
+ *
+ * The access_virt_array routines are responsible for making a specific strip
+ * area accessible (after reading or writing the backing file, if necessary).
+ * Note that the access routines are told whether the caller intends to modify
+ * the accessed strip; during a read-only pass this saves having to rewrite
+ * data to disk.  The access routines are also responsible for pre-zeroing
+ * any newly accessed rows, if pre-zeroing was requested.
+ *
+ * In current usage, the access requests are usually for nonoverlapping
+ * strips; that is, successive access start_row numbers differ by exactly
+ * num_rows = maxaccess.  This means we can get good performance with simple
+ * buffer dump/reload logic, by making the in-memory buffer be a multiple
+ * of the access height; then there will never be accesses across bufferload
+ * boundaries.  The code will still work with overlapping access requests,
+ * but it doesn't handle bufferload overlaps very efficiently.
+ */
+
+
+METHODDEF jvirt_sarray_ptr
+request_virt_sarray (j_common_ptr cinfo, int pool_id, boolean pre_zero,
+		     JDIMENSION samplesperrow, JDIMENSION numrows,
+		     JDIMENSION maxaccess)
+/* Request a virtual 2-D sample array */
+{
+  my_mem_ptr mem = (my_mem_ptr) cinfo->mem;
+  jvirt_sarray_ptr result;
+
+  /* Only IMAGE-lifetime virtual arrays are currently supported */
+  if (pool_id != JPOOL_IMAGE)
+    ERREXIT1(cinfo, JERR_BAD_POOL_ID, pool_id);	/* safety check */
+
+  /* get control block */
+  result = (jvirt_sarray_ptr) alloc_small(cinfo, pool_id,
+					  SIZEOF(struct jvirt_sarray_control));
+
+  result->mem_buffer = NULL;	/* marks array not yet realized */
+  result->rows_in_array = numrows;
+  result->samplesperrow = samplesperrow;
+  result->maxaccess = maxaccess;
+  result->pre_zero = pre_zero;
+  result->b_s_open = FALSE;	/* no associated backing-store object */
+  result->next = mem->virt_sarray_list; /* add to list of virtual arrays */
+  mem->virt_sarray_list = result;
+
+  return result;
+}
+
+
+METHODDEF jvirt_barray_ptr
+request_virt_barray (j_common_ptr cinfo, int pool_id, boolean pre_zero,
+		     JDIMENSION blocksperrow, JDIMENSION numrows,
+		     JDIMENSION maxaccess)
+/* Request a virtual 2-D coefficient-block array */
+{
+  my_mem_ptr mem = (my_mem_ptr) cinfo->mem;
+  jvirt_barray_ptr result;
+
+  /* Only IMAGE-lifetime virtual arrays are currently supported */
+  if (pool_id != JPOOL_IMAGE)
+    ERREXIT1(cinfo, JERR_BAD_POOL_ID, pool_id);	/* safety check */
+
+  /* get control block */
+  result = (jvirt_barray_ptr) alloc_small(cinfo, pool_id,
+					  SIZEOF(struct jvirt_barray_control));
+
+  result->mem_buffer = NULL;	/* marks array not yet realized */
+  result->rows_in_array = numrows;
+  result->blocksperrow = blocksperrow;
+  result->maxaccess = maxaccess;
+  result->pre_zero = pre_zero;
+  result->b_s_open = FALSE;	/* no associated backing-store object */
+  result->next = mem->virt_barray_list; /* add to list of virtual arrays */
+  mem->virt_barray_list = result;
+
+  return result;
+}
+
+
+METHODDEF void
+realize_virt_arrays (j_common_ptr cinfo)
+/* Allocate the in-memory buffers for any unrealized virtual arrays */
+{
+  my_mem_ptr mem = (my_mem_ptr) cinfo->mem;
+  long space_per_minheight, maximum_space, avail_mem;
+  long minheights, max_minheights;
+  jvirt_sarray_ptr sptr;
+  jvirt_barray_ptr bptr;
+
+  /* Compute the minimum space needed (maxaccess rows in each buffer)
+   * and the maximum space needed (full image height in each buffer).
+   * These may be of use to the system-dependent jpeg_mem_available routine.
+   */
+  space_per_minheight = 0;
+  maximum_space = 0;
+  for (sptr = mem->virt_sarray_list; sptr != NULL; sptr = sptr->next) {
+    if (sptr->mem_buffer == NULL) { /* if not realized yet */
+      space_per_minheight += (long) sptr->maxaccess *
+			     (long) sptr->samplesperrow * SIZEOF(JSAMPLE);
+      maximum_space += (long) sptr->rows_in_array *
+		       (long) sptr->samplesperrow * SIZEOF(JSAMPLE);
+    }
+  }
+  for (bptr = mem->virt_barray_list; bptr != NULL; bptr = bptr->next) {
+    if (bptr->mem_buffer == NULL) { /* if not realized yet */
+      space_per_minheight += (long) bptr->maxaccess *
+			     (long) bptr->blocksperrow * SIZEOF(JBLOCK);
+      maximum_space += (long) bptr->rows_in_array *
+		       (long) bptr->blocksperrow * SIZEOF(JBLOCK);
+    }
+  }
+
+  if (space_per_minheight <= 0)
+    return;			/* no unrealized arrays, no work */
+
+  /* Determine amount of memory to actually use; this is system-dependent. */
+  avail_mem = jpeg_mem_available(cinfo, space_per_minheight, maximum_space,
+				 mem->total_space_allocated);
+
+  /* If the maximum space needed is available, make all the buffers full
+   * height; otherwise parcel it out with the same number of minheights
+   * in each buffer.
+   */
+  if (avail_mem >= maximum_space)
+    max_minheights = 1000000000L;
+  else {
+    max_minheights = avail_mem / space_per_minheight;
+    /* If there doesn't seem to be enough space, try to get the minimum
+     * anyway.  This allows a "stub" implementation of jpeg_mem_available().
+     */
+    if (max_minheights <= 0)
+      max_minheights = 1;
+  }
+
+  /* Allocate the in-memory buffers and initialize backing store as needed. */
+
+  for (sptr = mem->virt_sarray_list; sptr != NULL; sptr = sptr->next) {
+    if (sptr->mem_buffer == NULL) { /* if not realized yet */
+      minheights = ((long) sptr->rows_in_array - 1L) / sptr->maxaccess + 1L;
+      if (minheights <= max_minheights) {
+	/* This buffer fits in memory */
+	sptr->rows_in_mem = sptr->rows_in_array;
+      } else {
+	/* It doesn't fit in memory, create backing store. */
+	sptr->rows_in_mem = (JDIMENSION) (max_minheights * sptr->maxaccess);
+	jpeg_open_backing_store(cinfo, & sptr->b_s_info,
+				(long) sptr->rows_in_array *
+				(long) sptr->samplesperrow *
+				(long) SIZEOF(JSAMPLE));
+	sptr->b_s_open = TRUE;
+      }
+      sptr->mem_buffer = alloc_sarray(cinfo, JPOOL_IMAGE,
+				      sptr->samplesperrow, sptr->rows_in_mem);
+      sptr->rowsperchunk = mem->last_rowsperchunk;
+      sptr->cur_start_row = 0;
+      sptr->first_undef_row = 0;
+      sptr->dirty = FALSE;
+    }
+  }
+
+  for (bptr = mem->virt_barray_list; bptr != NULL; bptr = bptr->next) {
+    if (bptr->mem_buffer == NULL) { /* if not realized yet */
+      minheights = ((long) bptr->rows_in_array - 1L) / bptr->maxaccess + 1L;
+      if (minheights <= max_minheights) {
+	/* This buffer fits in memory */
+	bptr->rows_in_mem = bptr->rows_in_array;
+      } else {
+	/* It doesn't fit in memory, create backing store. */
+	bptr->rows_in_mem = (JDIMENSION) (max_minheights * bptr->maxaccess);
+	jpeg_open_backing_store(cinfo, & bptr->b_s_info,
+				(long) bptr->rows_in_array *
+				(long) bptr->blocksperrow *
+				(long) SIZEOF(JBLOCK));
+	bptr->b_s_open = TRUE;
+      }
+      bptr->mem_buffer = alloc_barray(cinfo, JPOOL_IMAGE,
+				      bptr->blocksperrow, bptr->rows_in_mem);
+      bptr->rowsperchunk = mem->last_rowsperchunk;
+      bptr->cur_start_row = 0;
+      bptr->first_undef_row = 0;
+      bptr->dirty = FALSE;
+    }
+  }
+}
+
+
+LOCAL void
+do_sarray_io (j_common_ptr cinfo, jvirt_sarray_ptr ptr, boolean writing)
+/* Do backing store read or write of a virtual sample array */
+{
+  long bytesperrow, file_offset, byte_count, rows, thisrow, i;
+
+  bytesperrow = (long) ptr->samplesperrow * SIZEOF(JSAMPLE);
+  file_offset = ptr->cur_start_row * bytesperrow;
+  /* Loop to read or write each allocation chunk in mem_buffer */
+  for (i = 0; i < (long) ptr->rows_in_mem; i += ptr->rowsperchunk) {
+    /* One chunk, but check for short chunk at end of buffer */
+    rows = MIN((long) ptr->rowsperchunk, (long) ptr->rows_in_mem - i);
+    /* Transfer no more than is currently defined */
+    thisrow = (long) ptr->cur_start_row + i;
+    rows = MIN(rows, (long) ptr->first_undef_row - thisrow);
+    /* Transfer no more than fits in file */
+    rows = MIN(rows, (long) ptr->rows_in_array - thisrow);
+    if (rows <= 0)		/* this chunk might be past end of file! */
+      break;
+    byte_count = rows * bytesperrow;
+    if (writing)
+      (*ptr->b_s_info.write_backing_store) (cinfo, & ptr->b_s_info,
+					    (void FAR *) ptr->mem_buffer[i],
+					    file_offset, byte_count);
+    else
+      (*ptr->b_s_info.read_backing_store) (cinfo, & ptr->b_s_info,
+					   (void FAR *) ptr->mem_buffer[i],
+					   file_offset, byte_count);
+    file_offset += byte_count;
+  }
+}
+
+
+LOCAL void
+do_barray_io (j_common_ptr cinfo, jvirt_barray_ptr ptr, boolean writing)
+/* Do backing store read or write of a virtual coefficient-block array */
+{
+  long bytesperrow, file_offset, byte_count, rows, thisrow, i;
+
+  bytesperrow = (long) ptr->blocksperrow * SIZEOF(JBLOCK);
+  file_offset = ptr->cur_start_row * bytesperrow;
+  /* Loop to read or write each allocation chunk in mem_buffer */
+  for (i = 0; i < (long) ptr->rows_in_mem; i += ptr->rowsperchunk) {
+    /* One chunk, but check for short chunk at end of buffer */
+    rows = MIN((long) ptr->rowsperchunk, (long) ptr->rows_in_mem - i);
+    /* Transfer no more than is currently defined */
+    thisrow = (long) ptr->cur_start_row + i;
+    rows = MIN(rows, (long) ptr->first_undef_row - thisrow);
+    /* Transfer no more than fits in file */
+    rows = MIN(rows, (long) ptr->rows_in_array - thisrow);
+    if (rows <= 0)		/* this chunk might be past end of file! */
+      break;
+    byte_count = rows * bytesperrow;
+    if (writing)
+      (*ptr->b_s_info.write_backing_store) (cinfo, & ptr->b_s_info,
+					    (void FAR *) ptr->mem_buffer[i],
+					    file_offset, byte_count);
+    else
+      (*ptr->b_s_info.read_backing_store) (cinfo, & ptr->b_s_info,
+					   (void FAR *) ptr->mem_buffer[i],
+					   file_offset, byte_count);
+    file_offset += byte_count;
+  }
+}
+
+
+METHODDEF JSAMPARRAY
+access_virt_sarray (j_common_ptr cinfo, jvirt_sarray_ptr ptr,
+		    JDIMENSION start_row, JDIMENSION num_rows,
+		    boolean writable)
+/* Access the part of a virtual sample array starting at start_row */
+/* and extending for num_rows rows.  writable is true if  */
+/* caller intends to modify the accessed area. */
+{
+  JDIMENSION end_row = start_row + num_rows;
+  JDIMENSION undef_row;
+
+  /* debugging check */
+  if (end_row > ptr->rows_in_array || num_rows > ptr->maxaccess ||
+      ptr->mem_buffer == NULL)
+    ERREXIT(cinfo, JERR_BAD_VIRTUAL_ACCESS);
+
+  /* Make the desired part of the virtual array accessible */
+  if (start_row < ptr->cur_start_row ||
+      end_row > ptr->cur_start_row+ptr->rows_in_mem) {
+    if (! ptr->b_s_open)
+      ERREXIT(cinfo, JERR_VIRTUAL_BUG);
+    /* Flush old buffer contents if necessary */
+    if (ptr->dirty) {
+      do_sarray_io(cinfo, ptr, TRUE);
+      ptr->dirty = FALSE;
+    }
+    /* Decide what part of virtual array to access.
+     * Algorithm: if target address > current window, assume forward scan,
+     * load starting at target address.  If target address < current window,
+     * assume backward scan, load so that target area is top of window.
+     * Note that when switching from forward write to forward read, will have
+     * start_row = 0, so the limiting case applies and we load from 0 anyway.
+     */
+    if (start_row > ptr->cur_start_row) {
+      ptr->cur_start_row = start_row;
+    } else {
+      /* use long arithmetic here to avoid overflow & unsigned problems */
+      long ltemp;
+
+      ltemp = (long) end_row - (long) ptr->rows_in_mem;
+      if (ltemp < 0)
+	ltemp = 0;		/* don't fall off front end of file */
+      ptr->cur_start_row = (JDIMENSION) ltemp;
+    }
+    /* Read in the selected part of the array.
+     * During the initial write pass, we will do no actual read
+     * because the selected part is all undefined.
+     */
+    do_sarray_io(cinfo, ptr, FALSE);
+  }
+  /* Ensure the accessed part of the array is defined; prezero if needed.
+   * To improve locality of access, we only prezero the part of the array
+   * that the caller is about to access, not the entire in-memory array.
+   */
+  if (ptr->first_undef_row < end_row) {
+    if (ptr->first_undef_row < start_row) {
+      if (writable)		/* writer skipped over a section of array */
+	ERREXIT(cinfo, JERR_BAD_VIRTUAL_ACCESS);
+      undef_row = start_row;	/* but reader is allowed to read ahead */
+    } else {
+      undef_row = ptr->first_undef_row;
+    }
+    if (writable)
+      ptr->first_undef_row = end_row;
+    if (ptr->pre_zero) {
+      size_t bytesperrow = (size_t) ptr->samplesperrow * SIZEOF(JSAMPLE);
+      undef_row -= ptr->cur_start_row; /* make indexes relative to buffer */
+      end_row -= ptr->cur_start_row;
+      while (undef_row < end_row) {
+	jzero_far((void FAR *) ptr->mem_buffer[undef_row], bytesperrow);
+	undef_row++;
+      }
+    } else {
+      if (! writable)		/* reader looking at undefined data */
+	ERREXIT(cinfo, JERR_BAD_VIRTUAL_ACCESS);
+    }
+  }
+  /* Flag the buffer dirty if caller will write in it */
+  if (writable)
+    ptr->dirty = TRUE;
+  /* Return address of proper part of the buffer */
+  return ptr->mem_buffer + (start_row - ptr->cur_start_row);
+}
+
+
+METHODDEF JBLOCKARRAY
+access_virt_barray (j_common_ptr cinfo, jvirt_barray_ptr ptr,
+		    JDIMENSION start_row, JDIMENSION num_rows,
+		    boolean writable)
+/* Access the part of a virtual block array starting at start_row */
+/* and extending for num_rows rows.  writable is true if  */
+/* caller intends to modify the accessed area. */
+{
+  JDIMENSION end_row = start_row + num_rows;
+  JDIMENSION undef_row;
+
+  /* debugging check */
+  if (end_row > ptr->rows_in_array || num_rows > ptr->maxaccess ||
+      ptr->mem_buffer == NULL)
+    ERREXIT(cinfo, JERR_BAD_VIRTUAL_ACCESS);
+
+  /* Make the desired part of the virtual array accessible */
+  if (start_row < ptr->cur_start_row ||
+      end_row > ptr->cur_start_row+ptr->rows_in_mem) {
+    if (! ptr->b_s_open)
+      ERREXIT(cinfo, JERR_VIRTUAL_BUG);
+    /* Flush old buffer contents if necessary */
+    if (ptr->dirty) {
+      do_barray_io(cinfo, ptr, TRUE);
+      ptr->dirty = FALSE;
+    }
+    /* Decide what part of virtual array to access.
+     * Algorithm: if target address > current window, assume forward scan,
+     * load starting at target address.  If target address < current window,
+     * assume backward scan, load so that target area is top of window.
+     * Note that when switching from forward write to forward read, will have
+     * start_row = 0, so the limiting case applies and we load from 0 anyway.
+     */
+    if (start_row > ptr->cur_start_row) {
+      ptr->cur_start_row = start_row;
+    } else {
+      /* use long arithmetic here to avoid overflow & unsigned problems */
+      long ltemp;
+
+      ltemp = (long) end_row - (long) ptr->rows_in_mem;
+      if (ltemp < 0)
+	ltemp = 0;		/* don't fall off front end of file */
+      ptr->cur_start_row = (JDIMENSION) ltemp;
+    }
+    /* Read in the selected part of the array.
+     * During the initial write pass, we will do no actual read
+     * because the selected part is all undefined.
+     */
+    do_barray_io(cinfo, ptr, FALSE);
+  }
+  /* Ensure the accessed part of the array is defined; prezero if needed.
+   * To improve locality of access, we only prezero the part of the array
+   * that the caller is about to access, not the entire in-memory array.
+   */
+  if (ptr->first_undef_row < end_row) {
+    if (ptr->first_undef_row < start_row) {
+      if (writable)		/* writer skipped over a section of array */
+	ERREXIT(cinfo, JERR_BAD_VIRTUAL_ACCESS);
+      undef_row = start_row;	/* but reader is allowed to read ahead */
+    } else {
+      undef_row = ptr->first_undef_row;
+    }
+    if (writable)
+      ptr->first_undef_row = end_row;
+    if (ptr->pre_zero) {
+      size_t bytesperrow = (size_t) ptr->blocksperrow * SIZEOF(JBLOCK);
+      undef_row -= ptr->cur_start_row; /* make indexes relative to buffer */
+      end_row -= ptr->cur_start_row;
+      while (undef_row < end_row) {
+	jzero_far((void FAR *) ptr->mem_buffer[undef_row], bytesperrow);
+	undef_row++;
+      }
+    } else {
+      if (! writable)		/* reader looking at undefined data */
+	ERREXIT(cinfo, JERR_BAD_VIRTUAL_ACCESS);
+    }
+  }
+  /* Flag the buffer dirty if caller will write in it */
+  if (writable)
+    ptr->dirty = TRUE;
+  /* Return address of proper part of the buffer */
+  return ptr->mem_buffer + (start_row - ptr->cur_start_row);
+}
+
+
+/*
+ * Release all objects belonging to a specified pool.
+ */
+
+METHODDEF void
+free_pool (j_common_ptr cinfo, int pool_id)
+{
+  my_mem_ptr mem = (my_mem_ptr) cinfo->mem;
+  small_pool_ptr shdr_ptr;
+  large_pool_ptr lhdr_ptr;
+  size_t space_freed;
+
+  if (pool_id < 0 || pool_id >= JPOOL_NUMPOOLS)
+    ERREXIT1(cinfo, JERR_BAD_POOL_ID, pool_id);	/* safety check */
+
+#ifdef MEM_STATS
+  if (cinfo->err->trace_level > 1)
+    print_mem_stats(cinfo, pool_id); /* print pool's memory usage statistics */
+#endif
+
+  /* If freeing IMAGE pool, close any virtual arrays first */
+  if (pool_id == JPOOL_IMAGE) {
+    jvirt_sarray_ptr sptr;
+    jvirt_barray_ptr bptr;
+
+    for (sptr = mem->virt_sarray_list; sptr != NULL; sptr = sptr->next) {
+      if (sptr->b_s_open) {	/* there may be no backing store */
+	sptr->b_s_open = FALSE;	/* prevent recursive close if error */
+	(*sptr->b_s_info.close_backing_store) (cinfo, & sptr->b_s_info);
+      }
+    }
+    mem->virt_sarray_list = NULL;
+    for (bptr = mem->virt_barray_list; bptr != NULL; bptr = bptr->next) {
+      if (bptr->b_s_open) {	/* there may be no backing store */
+	bptr->b_s_open = FALSE;	/* prevent recursive close if error */
+	(*bptr->b_s_info.close_backing_store) (cinfo, & bptr->b_s_info);
+      }
+    }
+    mem->virt_barray_list = NULL;
+  }
+
+  /* Release large objects */
+  lhdr_ptr = mem->large_list[pool_id];
+  mem->large_list[pool_id] = NULL;
+
+  while (lhdr_ptr != NULL) {
+    large_pool_ptr next_lhdr_ptr = lhdr_ptr->hdr.next;
+    space_freed = lhdr_ptr->hdr.bytes_used +
+		  lhdr_ptr->hdr.bytes_left +
+		  SIZEOF(large_pool_hdr);
+    jpeg_free_large(cinfo, (void FAR *) lhdr_ptr, space_freed);
+    mem->total_space_allocated -= space_freed;
+    lhdr_ptr = next_lhdr_ptr;
+  }
+
+  /* Release small objects */
+  shdr_ptr = mem->small_list[pool_id];
+  mem->small_list[pool_id] = NULL;
+
+  while (shdr_ptr != NULL) {
+    small_pool_ptr next_shdr_ptr = shdr_ptr->hdr.next;
+    space_freed = shdr_ptr->hdr.bytes_used +
+		  shdr_ptr->hdr.bytes_left +
+		  SIZEOF(small_pool_hdr);
+    jpeg_free_small(cinfo, (void *) shdr_ptr, space_freed);
+    mem->total_space_allocated -= space_freed;
+    shdr_ptr = next_shdr_ptr;
+  }
+}
+
+
+/*
+ * Close up shop entirely.
+ * Note that this cannot be called unless cinfo->mem is non-NULL.
+ */
+
+METHODDEF void
+self_destruct (j_common_ptr cinfo)
+{
+  int pool;
+
+  /* Close all backing store, release all memory.
+   * Releasing pools in reverse order might help avoid fragmentation
+   * with some (brain-damaged) malloc libraries.
+   */
+  for (pool = JPOOL_NUMPOOLS-1; pool >= JPOOL_PERMANENT; pool--) {
+    free_pool(cinfo, pool);
+  }
+
+  /* Release the memory manager control block too. */
+  jpeg_free_small(cinfo, (void *) cinfo->mem, SIZEOF(my_memory_mgr));
+  cinfo->mem = NULL;		/* ensures I will be called only once */
+
+  jpeg_mem_term(cinfo);		/* system-dependent cleanup */
+}
+
+
+/*
+ * Memory manager initialization.
+ * When this is called, only the error manager pointer is valid in cinfo!
+ */
+
+GLOBAL void
+jinit_memory_mgr (j_common_ptr cinfo)
+{
+  my_mem_ptr mem;
+  long max_to_use;
+  int pool;
+  size_t test_mac;
+
+  cinfo->mem = NULL;		/* for safety if init fails */
+
+  /* Check for configuration errors.
+   * SIZEOF(ALIGN_TYPE) should be a power of 2; otherwise, it probably
+   * doesn't reflect any real hardware alignment requirement.
+   * The test is a little tricky: for X>0, X and X-1 have no one-bits
+   * in common if and only if X is a power of 2, ie has only one one-bit.
+   * Some compilers may give an "unreachable code" warning here; ignore it.
+   */
+  if ((SIZEOF(ALIGN_TYPE) & (SIZEOF(ALIGN_TYPE)-1)) != 0)
+    ERREXIT(cinfo, JERR_BAD_ALIGN_TYPE);
+  /* MAX_ALLOC_CHUNK must be representable as type size_t, and must be
+   * a multiple of SIZEOF(ALIGN_TYPE).
+   * Again, an "unreachable code" warning may be ignored here.
+   * But a "constant too large" warning means you need to fix MAX_ALLOC_CHUNK.
+   */
+  test_mac = (size_t) MAX_ALLOC_CHUNK;
+  if ((long) test_mac != MAX_ALLOC_CHUNK ||
+      (MAX_ALLOC_CHUNK % SIZEOF(ALIGN_TYPE)) != 0)
+    ERREXIT(cinfo, JERR_BAD_ALLOC_CHUNK);
+
+  max_to_use = jpeg_mem_init(cinfo); /* system-dependent initialization */
+
+  /* Attempt to allocate memory manager's control block */
+  mem = (my_mem_ptr) jpeg_get_small(cinfo, SIZEOF(my_memory_mgr));
+
+  if (mem == NULL) {
+    jpeg_mem_term(cinfo);	/* system-dependent cleanup */
+    ERREXIT1(cinfo, JERR_OUT_OF_MEMORY, 0);
+  }
+
+  /* OK, fill in the method pointers */
+  mem->pub.alloc_small = alloc_small;
+  mem->pub.alloc_large = alloc_large;
+  mem->pub.alloc_sarray = alloc_sarray;
+  mem->pub.alloc_barray = alloc_barray;
+  mem->pub.request_virt_sarray = request_virt_sarray;
+  mem->pub.request_virt_barray = request_virt_barray;
+  mem->pub.realize_virt_arrays = realize_virt_arrays;
+  mem->pub.access_virt_sarray = access_virt_sarray;
+  mem->pub.access_virt_barray = access_virt_barray;
+  mem->pub.free_pool = free_pool;
+  mem->pub.self_destruct = self_destruct;
+
+  /* Initialize working state */
+  mem->pub.max_memory_to_use = max_to_use;
+
+  for (pool = JPOOL_NUMPOOLS-1; pool >= JPOOL_PERMANENT; pool--) {
+    mem->small_list[pool] = NULL;
+    mem->large_list[pool] = NULL;
+  }
+  mem->virt_sarray_list = NULL;
+  mem->virt_barray_list = NULL;
+
+  mem->total_space_allocated = SIZEOF(my_memory_mgr);
+
+  /* Declare ourselves open for business */
+  cinfo->mem = & mem->pub;
+
+  /* Check for an environment variable JPEGMEM; if found, override the
+   * default max_memory setting from jpeg_mem_init.  Note that the
+   * surrounding application may again override this value.
+   * If your system doesn't support getenv(), define NO_GETENV to disable
+   * this feature.
+   */
+#ifndef NO_GETENV
+  { char * memenv;
+
+    if ((memenv = getenv("JPEGMEM")) != NULL) {
+      char ch = 'x';
+
+      if (sscanf(memenv, "%ld%c", &max_to_use, &ch) > 0) {
+	if (ch == 'm' || ch == 'M')
+	  max_to_use *= 1000L;
+	mem->pub.max_memory_to_use = max_to_use * 1000L;
+      }
+    }
+  }
+#endif
+
+}
diff --git a/code/jpeg-6/jmemnobs.cpp b/code/jpeg-6/jmemnobs.cpp
new file mode 100644
index 0000000..f9595e5
--- /dev/null
+++ b/code/jpeg-6/jmemnobs.cpp
@@ -0,0 +1,111 @@
+/*
+ * jmemnobs.c
+ *
+ * Copyright (C) 1992-1994, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file provides a really simple implementation of the system-
+ * dependent portion of the JPEG memory manager.  This implementation
+ * assumes that no backing-store files are needed: all required space
+ * can be obtained from ri.Malloc().
+ * This is very portable in the sense that it'll compile on almost anything,
+ * but you'd better have lots of main memory (or virtual memory) if you want
+ * to process big images.
+ * Note that the max_memory_to_use option is ignored by this implementation.
+ */
+
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jmemsys.h"		/* import the system-dependent declarations */
+
+#include "../renderer/tr_local.h"
+
+/*
+ * Memory allocation and ri.Freeing are controlled by the regular library
+ * routines ri.Malloc() and ri.Free().
+ */
+
+GLOBAL void *
+jpeg_get_small (j_common_ptr cinfo, size_t sizeofobject)
+{
+  return (void *) Z_Malloc(sizeofobject, TAG_TEMP_JPG, qfalse);
+}
+
+GLOBAL void
+jpeg_free_small (j_common_ptr cinfo, void * object, size_t sizeofobject)
+{
+  Z_Free(object);
+}
+
+
+/*
+ * "Large" objects are treated the same as "small" ones.
+ * NB: although we include FAR keywords in the routine declarations,
+ * this file won't actually work in 80x86 small/medium model; at least,
+ * you probably won't be able to process useful-size images in only 64KB.
+ */
+
+GLOBAL void FAR *
+jpeg_get_large (j_common_ptr cinfo, size_t sizeofobject)
+{
+  return (void FAR *) Z_Malloc(sizeofobject, TAG_TEMP_JPG, qfalse);
+}
+
+GLOBAL void
+jpeg_free_large (j_common_ptr cinfo, void FAR * object, size_t sizeofobject)
+{
+  Z_Free(object);
+}
+
+
+/*
+ * This routine computes the total memory space available for allocation.
+ * Here we always say, "we got all you want bud!"
+ */
+
+GLOBAL long
+jpeg_mem_available (j_common_ptr cinfo, long min_bytes_needed,
+		    long max_bytes_needed, long already_allocated)
+{
+  return max_bytes_needed;
+}
+
+
+/*
+ * Backing store (temporary file) management.
+ * Since jpeg_mem_available always promised the moon,
+ * this should never be called and we can just error out.
+ */
+
+GLOBAL void
+jpeg_open_backing_store (j_common_ptr cinfo, backing_store_ptr info,
+			 long total_bytes_needed)
+{
+  ERREXIT(cinfo, JERR_NO_BACKING_STORE);
+}
+
+
+/*
+ * These routines take care of any system-dependent initialization and
+ * cleanup required.  Here, there isn't any.
+ */
+
+GLOBAL long
+jpeg_mem_init (j_common_ptr cinfo)
+{
+  return 0;			/* just set max_memory_to_use to 0 */
+}
+
+GLOBAL void
+jpeg_mem_term (j_common_ptr cinfo)
+{
+  /* no work */
+}
diff --git a/code/jpeg-6/jmemsys.h b/code/jpeg-6/jmemsys.h
new file mode 100644
index 0000000..0c7d7c1
--- /dev/null
+++ b/code/jpeg-6/jmemsys.h
@@ -0,0 +1,182 @@
+/*
+ * jmemsys.h
+ *
+ * Copyright (C) 1992-1994, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This include file defines the interface between the system-independent
+ * and system-dependent portions of the JPEG memory manager.  No other
+ * modules need include it.  (The system-independent portion is jmemmgr.c;
+ * there are several different versions of the system-dependent portion.)
+ *
+ * This file works as-is for the system-dependent memory managers supplied
+ * in the IJG distribution.  You may need to modify it if you write a
+ * custom memory manager.  If system-dependent changes are needed in
+ * this file, the best method is to #ifdef them based on a configuration
+ * symbol supplied in jconfig.h, as we have done with USE_MSDOS_MEMMGR.
+ */
+
+
+/* Short forms of external names for systems with brain-damaged linkers. */
+
+#ifdef NEED_SHORT_EXTERNAL_NAMES
+#define jpeg_get_small		jGetSmall
+#define jpeg_free_small		jFreeSmall
+#define jpeg_get_large		jGetLarge
+#define jpeg_free_large		jFreeLarge
+#define jpeg_mem_available	jMemAvail
+#define jpeg_open_backing_store	jOpenBackStore
+#define jpeg_mem_init		jMemInit
+#define jpeg_mem_term		jMemTerm
+#endif /* NEED_SHORT_EXTERNAL_NAMES */
+
+
+/*
+ * These two functions are used to allocate and release small chunks of
+ * memory.  (Typically the total amount requested through jpeg_get_small is
+ * no more than 20K or so; this will be requested in chunks of a few K each.)
+ * Behavior should be the same as for the standard library functions malloc
+ * and free; in particular, jpeg_get_small must return NULL on failure.
+ * On most systems, these ARE malloc and free.  jpeg_free_small is passed the
+ * size of the object being freed, just in case it's needed.
+ * On an 80x86 machine using small-data memory model, these manage near heap.
+ */
+
+EXTERN void * jpeg_get_small JPP((j_common_ptr cinfo, size_t sizeofobject));
+EXTERN void jpeg_free_small JPP((j_common_ptr cinfo, void * object,
+				 size_t sizeofobject));
+
+/*
+ * These two functions are used to allocate and release large chunks of
+ * memory (up to the total free space designated by jpeg_mem_available).
+ * The interface is the same as above, except that on an 80x86 machine,
+ * far pointers are used.  On most other machines these are identical to
+ * the jpeg_get/free_small routines; but we keep them separate anyway,
+ * in case a different allocation strategy is desirable for large chunks.
+ */
+
+EXTERN void FAR * jpeg_get_large JPP((j_common_ptr cinfo,size_t sizeofobject));
+EXTERN void jpeg_free_large JPP((j_common_ptr cinfo, void FAR * object,
+				 size_t sizeofobject));
+
+/*
+ * The macro MAX_ALLOC_CHUNK designates the maximum number of bytes that may
+ * be requested in a single call to jpeg_get_large (and jpeg_get_small for that
+ * matter, but that case should never come into play).  This macro is needed
+ * to model the 64Kb-segment-size limit of far addressing on 80x86 machines.
+ * On those machines, we expect that jconfig.h will provide a proper value.
+ * On machines with 32-bit flat address spaces, any large constant may be used.
+ *
+ * NB: jmemmgr.c expects that MAX_ALLOC_CHUNK will be representable as type
+ * size_t and will be a multiple of sizeof(align_type).
+ */
+
+#ifndef MAX_ALLOC_CHUNK		/* may be overridden in jconfig.h */
+#define MAX_ALLOC_CHUNK  1000000000L
+#endif
+
+/*
+ * This routine computes the total space still available for allocation by
+ * jpeg_get_large.  If more space than this is needed, backing store will be
+ * used.  NOTE: any memory already allocated must not be counted.
+ *
+ * There is a minimum space requirement, corresponding to the minimum
+ * feasible buffer sizes; jmemmgr.c will request that much space even if
+ * jpeg_mem_available returns zero.  The maximum space needed, enough to hold
+ * all working storage in memory, is also passed in case it is useful.
+ * Finally, the total space already allocated is passed.  If no better
+ * method is available, cinfo->mem->max_memory_to_use - already_allocated
+ * is often a suitable calculation.
+ *
+ * It is OK for jpeg_mem_available to underestimate the space available
+ * (that'll just lead to more backing-store access than is really necessary).
+ * However, an overestimate will lead to failure.  Hence it's wise to subtract
+ * a slop factor from the true available space.  5% should be enough.
+ *
+ * On machines with lots of virtual memory, any large constant may be returned.
+ * Conversely, zero may be returned to always use the minimum amount of memory.
+ */
+
+EXTERN long jpeg_mem_available JPP((j_common_ptr cinfo,
+				    long min_bytes_needed,
+				    long max_bytes_needed,
+				    long already_allocated));
+
+
+/*
+ * This structure holds whatever state is needed to access a single
+ * backing-store object.  The read/write/close method pointers are called
+ * by jmemmgr.c to manipulate the backing-store object; all other fields
+ * are private to the system-dependent backing store routines.
+ */
+
+#define TEMP_NAME_LENGTH   64	/* max length of a temporary file's name */
+
+#ifdef USE_MSDOS_MEMMGR		/* DOS-specific junk */
+
+typedef unsigned short XMSH;	/* type of extended-memory handles */
+typedef unsigned short EMSH;	/* type of expanded-memory handles */
+
+typedef union {
+  short file_handle;		/* DOS file handle if it's a temp file */
+  XMSH xms_handle;		/* handle if it's a chunk of XMS */
+  EMSH ems_handle;		/* handle if it's a chunk of EMS */
+} handle_union;
+
+#endif /* USE_MSDOS_MEMMGR */
+
+typedef struct backing_store_struct * backing_store_ptr;
+
+typedef struct backing_store_struct {
+  /* Methods for reading/writing/closing this backing-store object */
+  JMETHOD(void, read_backing_store, (j_common_ptr cinfo,
+				     backing_store_ptr info,
+				     void FAR * buffer_address,
+				     long file_offset, long byte_count));
+  JMETHOD(void, write_backing_store, (j_common_ptr cinfo,
+				      backing_store_ptr info,
+				      void FAR * buffer_address,
+				      long file_offset, long byte_count));
+  JMETHOD(void, close_backing_store, (j_common_ptr cinfo,
+				      backing_store_ptr info));
+
+  /* Private fields for system-dependent backing-store management */
+#ifdef USE_MSDOS_MEMMGR
+  /* For the MS-DOS manager (jmemdos.c), we need: */
+  handle_union handle;		/* reference to backing-store storage object */
+  char temp_name[TEMP_NAME_LENGTH]; /* name if it's a file */
+#else
+  /* For a typical implementation with temp files, we need: */
+  FILE * temp_file;		/* stdio reference to temp file */
+  char temp_name[TEMP_NAME_LENGTH]; /* name of temp file */
+#endif
+} backing_store_info;
+
+/*
+ * Initial opening of a backing-store object.  This must fill in the
+ * read/write/close pointers in the object.  The read/write routines
+ * may take an error exit if the specified maximum file size is exceeded.
+ * (If jpeg_mem_available always returns a large value, this routine can
+ * just take an error exit.)
+ */
+
+EXTERN void jpeg_open_backing_store JPP((j_common_ptr cinfo,
+					 backing_store_ptr info,
+					 long total_bytes_needed));
+
+
+/*
+ * These routines take care of any system-dependent initialization and
+ * cleanup required.  jpeg_mem_init will be called before anything is
+ * allocated (and, therefore, nothing in cinfo is of use except the error
+ * manager pointer).  It should return a suitable default value for
+ * max_memory_to_use; this may subsequently be overridden by the surrounding
+ * application.  (Note that max_memory_to_use is only important if
+ * jpeg_mem_available chooses to consult it ... no one else will.)
+ * jpeg_mem_term may assume that all requested memory has been freed and that
+ * all opened backing-store objects have been closed.
+ */
+
+EXTERN long jpeg_mem_init JPP((j_common_ptr cinfo));
+EXTERN void jpeg_mem_term JPP((j_common_ptr cinfo));
diff --git a/code/jpeg-6/jmorecfg.h b/code/jpeg-6/jmorecfg.h
new file mode 100644
index 0000000..08f332a
--- /dev/null
+++ b/code/jpeg-6/jmorecfg.h
@@ -0,0 +1,349 @@
+/*
+ * jmorecfg.h
+ *
+ * Copyright (C) 1991-1995, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains additional configuration options that customize the
+ * JPEG software for special applications or support machine-dependent
+ * optimizations.  Most users will not need to touch this file.
+ */
+
+
+/*
+ * Define BITS_IN_JSAMPLE as either
+ *   8   for 8-bit sample values (the usual setting)
+ *   12  for 12-bit sample values
+ * Only 8 and 12 are legal data precisions for lossy JPEG according to the
+ * JPEG standard, and the IJG code does not support anything else!
+ * We do not support run-time selection of data precision, sorry.
+ */
+
+#define BITS_IN_JSAMPLE  8	/* use 8 or 12 */
+
+
+/*
+ * Maximum number of components (color channels) allowed in JPEG image.
+ * To meet the letter of the JPEG spec, set this to 255.  However, darn
+ * few applications need more than 4 channels (maybe 5 for CMYK + alpha
+ * mask).  We recommend 10 as a reasonable compromise; use 4 if you are
+ * really short on memory.  (Each allowed component costs a hundred or so
+ * bytes of storage, whether actually used in an image or not.)
+ */
+
+#define MAX_COMPONENTS  10	/* maximum number of image components */
+
+
+/*
+ * Basic data types.
+ * You may need to change these if you have a machine with unusual data
+ * type sizes; for example, "char" not 8 bits, "short" not 16 bits,
+ * or "long" not 32 bits.  We don't care whether "int" is 16 or 32 bits,
+ * but it had better be at least 16.
+ */
+
+/* Representation of a single sample (pixel element value).
+ * We frequently allocate large arrays of these, so it's important to keep
+ * them small.  But if you have memory to burn and access to char or short
+ * arrays is very slow on your hardware, you might want to change these.
+ */
+
+#if BITS_IN_JSAMPLE == 8
+/* JSAMPLE should be the smallest type that will hold the values 0..255.
+ * You can use a signed char by having GETJSAMPLE mask it with 0xFF.
+ */
+
+#ifdef HAVE_UNSIGNED_CHAR
+
+typedef unsigned char JSAMPLE;
+#define GETJSAMPLE(value)  ((int) (value))
+
+#else /* not HAVE_UNSIGNED_CHAR */
+
+typedef char JSAMPLE;
+#ifdef CHAR_IS_UNSIGNED
+#define GETJSAMPLE(value)  ((int) (value))
+#else
+#define GETJSAMPLE(value)  ((int) (value) & 0xFF)
+#endif /* CHAR_IS_UNSIGNED */
+
+#endif /* HAVE_UNSIGNED_CHAR */
+
+#define MAXJSAMPLE	255
+#define CENTERJSAMPLE	128
+
+#endif /* BITS_IN_JSAMPLE == 8 */
+
+
+#if BITS_IN_JSAMPLE == 12
+/* JSAMPLE should be the smallest type that will hold the values 0..4095.
+ * On nearly all machines "short" will do nicely.
+ */
+
+typedef short JSAMPLE;
+#define GETJSAMPLE(value)  ((int) (value))
+
+#define MAXJSAMPLE	4095
+#define CENTERJSAMPLE	2048
+
+#endif /* BITS_IN_JSAMPLE == 12 */
+
+
+/* Representation of a DCT frequency coefficient.
+ * This should be a signed value of at least 16 bits; "short" is usually OK.
+ * Again, we allocate large arrays of these, but you can change to int
+ * if you have memory to burn and "short" is really slow.
+ */
+
+typedef short JCOEF;
+
+
+/* Compressed datastreams are represented as arrays of JOCTET.
+ * These must be EXACTLY 8 bits wide, at least once they are written to
+ * external storage.  Note that when using the stdio data source/destination
+ * managers, this is also the data type passed to fread/fwrite.
+ */
+
+#ifdef HAVE_UNSIGNED_CHAR
+
+typedef unsigned char JOCTET;
+#define GETJOCTET(value)  (value)
+
+#else /* not HAVE_UNSIGNED_CHAR */
+
+typedef char JOCTET;
+#ifdef CHAR_IS_UNSIGNED
+#define GETJOCTET(value)  (value)
+#else
+#define GETJOCTET(value)  ((value) & 0xFF)
+#endif /* CHAR_IS_UNSIGNED */
+
+#endif /* HAVE_UNSIGNED_CHAR */
+
+
+/* These typedefs are used for various table entries and so forth.
+ * They must be at least as wide as specified; but making them too big
+ * won't cost a huge amount of memory, so we don't provide special
+ * extraction code like we did for JSAMPLE.  (In other words, these
+ * typedefs live at a different point on the speed/space tradeoff curve.)
+ */
+
+/* UINT8 must hold at least the values 0..255. */
+
+#ifdef HAVE_UNSIGNED_CHAR
+typedef unsigned char UINT8;
+#else /* not HAVE_UNSIGNED_CHAR */
+#ifdef CHAR_IS_UNSIGNED
+typedef char UINT8;
+#else /* not CHAR_IS_UNSIGNED */
+typedef short UINT8;
+#endif /* CHAR_IS_UNSIGNED */
+#endif /* HAVE_UNSIGNED_CHAR */
+
+/* UINT16 must hold at least the values 0..65535. */
+
+#ifdef HAVE_UNSIGNED_SHORT
+typedef unsigned short UINT16;
+#else /* not HAVE_UNSIGNED_SHORT */
+typedef unsigned int UINT16;
+#endif /* HAVE_UNSIGNED_SHORT */
+
+// compile warning for VC6 with CPP being defined
+// typedef long INT32;
+
+/* INT16 must hold at least the values -32768..32767. */
+
+#ifndef XMD_H			/* X11/xmd.h correctly defines INT16 */
+typedef short INT16;
+#endif
+
+/* INT32 must hold at least signed 32-bit values. */
+
+//#ifndef XMD_H			/* X11/xmd.h correctly defines INT32 */
+//typedef long INT32;
+//#endif
+
+/* Datatype used for image dimensions.  The JPEG standard only supports
+ * images up to 64K*64K due to 16-bit fields in SOF markers.  Therefore
+ * "unsigned int" is sufficient on all machines.  However, if you need to
+ * handle larger images and you don't mind deviating from the spec, you
+ * can change this datatype.
+ */
+
+typedef unsigned int JDIMENSION;
+
+#define JPEG_MAX_DIMENSION  65500L  /* a tad under 64K to prevent overflows */
+
+
+/* These defines are used in all function definitions and extern declarations.
+ * You could modify them if you need to change function linkage conventions.
+ * Another application is to make all functions global for use with debuggers
+ * or code profilers that require it.
+ */
+
+#define METHODDEF static	/* a function called through method pointers */
+#define LOCAL	  static	/* a function used only in its module */
+#define GLOBAL			/* a function referenced thru EXTERNs */
+#define EXTERN	  extern	/* a reference to a GLOBAL function */
+
+
+/* Here is the pseudo-keyword for declaring pointers that must be "far"
+ * on 80x86 machines.  Most of the specialized coding for 80x86 is handled
+ * by just saying "FAR *" where such a pointer is needed.  In a few places
+ * explicit coding is needed; see uses of the NEED_FAR_POINTERS symbol.
+ */
+
+#ifdef NEED_FAR_POINTERS
+#undef FAR
+#define FAR  far
+#else
+#undef FAR
+#define FAR
+#endif
+
+
+/*
+ * On a few systems, type boolean and/or its values FALSE, TRUE may appear
+ * in standard header files.  Or you may have conflicts with application-
+ * specific header files that you want to include together with these files.
+ * Defining HAVE_BOOLEAN before including jpeglib.h should make it work.
+ */
+
+//#ifndef HAVE_BOOLEAN
+//typedef int boolean;
+//#endif
+#ifndef FALSE			/* in case these macros already exist */
+#define FALSE	0		/* values of boolean */
+#endif
+#ifndef TRUE
+#define TRUE	1
+#endif
+
+
+/*
+ * The remaining options affect code selection within the JPEG library,
+ * but they don't need to be visible to most applications using the library.
+ * To minimize application namespace pollution, the symbols won't be
+ * defined unless JPEG_INTERNALS or JPEG_INTERNAL_OPTIONS has been defined.
+ */
+
+#ifdef JPEG_INTERNALS
+#define JPEG_INTERNAL_OPTIONS
+#endif
+
+#ifdef JPEG_INTERNAL_OPTIONS
+
+
+/*
+ * These defines indicate whether to include various optional functions.
+ * Undefining some of these symbols will produce a smaller but less capable
+ * library.  Note that you can leave certain source files out of the
+ * compilation/linking process if you've #undef'd the corresponding symbols.
+ * (You may HAVE to do that if your compiler doesn't like null source files.)
+ */
+
+/* Arithmetic coding is unsupported for legal reasons.  Complaints to IBM. */
+
+/* Capability options common to encoder and decoder: */
+
+#undef DCT_ISLOW_SUPPORTED	/* slow but accurate integer algorithm */
+#undef DCT_IFAST_SUPPORTED	/* faster, less accurate integer method */
+#define DCT_FLOAT_SUPPORTED	/* floating-point: accurate, fast on fast HW */
+
+/* Encoder capability options: */
+
+#undef  C_ARITH_CODING_SUPPORTED    /* Arithmetic coding back end? */
+#define C_MULTISCAN_FILES_SUPPORTED /* Multiple-scan JPEG files? */
+#define C_PROGRESSIVE_SUPPORTED	    /* Progressive JPEG? (Requires MULTISCAN)*/
+#define ENTROPY_OPT_SUPPORTED	    /* Optimization of entropy coding parms? */
+/* Note: if you selected 12-bit data precision, it is dangerous to turn off
+ * ENTROPY_OPT_SUPPORTED.  The standard Huffman tables are only good for 8-bit
+ * precision, so jchuff.c normally uses entropy optimization to compute
+ * usable tables for higher precision.  If you don't want to do optimization,
+ * you'll have to supply different default Huffman tables.
+ * The exact same statements apply for progressive JPEG: the default tables
+ * don't work for progressive mode.  (This may get fixed, however.)
+ */
+#define INPUT_SMOOTHING_SUPPORTED   /* Input image smoothing option? */
+
+/* Decoder capability options: */
+
+#undef  D_ARITH_CODING_SUPPORTED    /* Arithmetic coding back end? */
+#undef D_MULTISCAN_FILES_SUPPORTED /* Multiple-scan JPEG files? */
+#undef D_PROGRESSIVE_SUPPORTED	    /* Progressive JPEG? (Requires MULTISCAN)*/
+#undef BLOCK_SMOOTHING_SUPPORTED   /* Block smoothing? (Progressive only) */
+#undef IDCT_SCALING_SUPPORTED	    /* Output rescaling via IDCT? */
+#undef  UPSAMPLE_SCALING_SUPPORTED  /* Output rescaling at upsample stage? */
+#undef UPSAMPLE_MERGING_SUPPORTED  /* Fast path for sloppy upsampling? */
+#undef QUANT_1PASS_SUPPORTED	    /* 1-pass color quantization? */
+#undef QUANT_2PASS_SUPPORTED	    /* 2-pass color quantization? */
+
+/* more capability options later, no doubt */
+
+
+/*
+ * Ordering of RGB data in scanlines passed to or from the application.
+ * If your application wants to deal with data in the order B,G,R, just
+ * change these macros.  You can also deal with formats such as R,G,B,X
+ * (one extra byte per pixel) by changing RGB_PIXELSIZE.  Note that changing
+ * the offsets will also change the order in which colormap data is organized.
+ * RESTRICTIONS:
+ * 1. The sample applications cjpeg,djpeg do NOT support modified RGB formats.
+ * 2. These macros only affect RGB<=>YCbCr color conversion, so they are not
+ *    useful if you are using JPEG color spaces other than YCbCr or grayscale.
+ * 3. The color quantizer modules will not behave desirably if RGB_PIXELSIZE
+ *    is not 3 (they don't understand about dummy color components!).  So you
+ *    can't use color quantization if you change that value.
+ */
+
+#define RGB_RED		0	/* Offset of Red in an RGB scanline element */
+#define RGB_GREEN	1	/* Offset of Green */
+#define RGB_BLUE	2	/* Offset of Blue */
+#define RGB_PIXELSIZE	4	/* JSAMPLEs per RGB scanline element */
+
+
+/* Definitions for speed-related optimizations. */
+
+
+/* If your compiler supports inline functions, define INLINE
+ * as the inline keyword; otherwise define it as empty.
+ */
+
+#ifndef INLINE
+#ifdef __GNUC__			/* for instance, GNU C knows about inline */
+#define INLINE __inline__
+#endif
+#ifndef INLINE
+#define INLINE			/* default is to define it as empty */
+#endif
+#endif
+
+
+/* On some machines (notably 68000 series) "int" is 32 bits, but multiplying
+ * two 16-bit shorts is faster than multiplying two ints.  Define MULTIPLIER
+ * as short on such a machine.  MULTIPLIER must be at least 16 bits wide.
+ */
+
+#ifndef MULTIPLIER
+#define MULTIPLIER  int		/* type for fastest integer multiply */
+#endif
+
+
+/* FAST_FLOAT should be either float or double, whichever is done faster
+ * by your compiler.  (Note that this type is only used in the floating point
+ * DCT routines, so it only matters if you've defined DCT_FLOAT_SUPPORTED.)
+ * Typically, float is faster in ANSI C compilers, while double is faster in
+ * pre-ANSI compilers (because they insist on converting to double anyway).
+ * The code below therefore chooses float if we have ANSI-style prototypes.
+ */
+
+#ifndef FAST_FLOAT
+#ifdef HAVE_PROTOTYPES
+#define FAST_FLOAT  float
+#else
+#define FAST_FLOAT  double
+#endif
+#endif
+
+#endif /* JPEG_INTERNAL_OPTIONS */
diff --git a/code/jpeg-6/jpegint.h b/code/jpeg-6/jpegint.h
new file mode 100644
index 0000000..b3b6a6d
--- /dev/null
+++ b/code/jpeg-6/jpegint.h
@@ -0,0 +1,388 @@
+/*
+ * jpegint.h
+ *
+ * Copyright (C) 1991-1995, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file provides common declarations for the various JPEG modules.
+ * These declarations are considered internal to the JPEG library; most
+ * applications using the library shouldn't need to include this file.
+ */
+
+
+/* Declarations for both compression & decompression */
+
+typedef enum {			/* Operating modes for buffer controllers */
+	JBUF_PASS_THRU,		/* Plain stripwise operation */
+	/* Remaining modes require a full-image buffer to have been created */
+	JBUF_SAVE_SOURCE,	/* Run source subobject only, save output */
+	JBUF_CRANK_DEST,	/* Run dest subobject only, using saved data */
+	JBUF_SAVE_AND_PASS	/* Run both subobjects, save output */
+} J_BUF_MODE;
+
+/* Values of global_state field (jdapi.c has some dependencies on ordering!) */
+#define CSTATE_START	100	/* after create_compress */
+#define CSTATE_SCANNING	101	/* start_compress done, write_scanlines OK */
+#define CSTATE_RAW_OK	102	/* start_compress done, write_raw_data OK */
+#define CSTATE_WRCOEFS	103	/* jpeg_write_coefficients done */
+#define DSTATE_START	200	/* after create_decompress */
+#define DSTATE_INHEADER	201	/* reading header markers, no SOS yet */
+#define DSTATE_READY	202	/* found SOS, ready for start_decompress */
+#define DSTATE_PRELOAD	203	/* reading multiscan file in start_decompress*/
+#define DSTATE_PRESCAN	204	/* performing dummy pass for 2-pass quant */
+#define DSTATE_SCANNING	205	/* start_decompress done, read_scanlines OK */
+#define DSTATE_RAW_OK	206	/* start_decompress done, read_raw_data OK */
+#define DSTATE_BUFIMAGE	207	/* expecting jpeg_start_output */
+#define DSTATE_BUFPOST	208	/* looking for SOS/EOI in jpeg_finish_output */
+#define DSTATE_RDCOEFS	209	/* reading file in jpeg_read_coefficients */
+#define DSTATE_STOPPING	210	/* looking for EOI in jpeg_finish_decompress */
+
+
+/* Declarations for compression modules */
+
+/* Master control module */
+struct jpeg_comp_master {
+  JMETHOD(void, prepare_for_pass, (j_compress_ptr cinfo));
+  JMETHOD(void, pass_startup, (j_compress_ptr cinfo));
+  JMETHOD(void, finish_pass, (j_compress_ptr cinfo));
+
+  /* State variables made visible to other modules */
+  boolean call_pass_startup;	/* True if pass_startup must be called */
+  boolean is_last_pass;		/* True during last pass */
+};
+
+/* Main buffer control (downsampled-data buffer) */
+struct jpeg_c_main_controller {
+  JMETHOD(void, start_pass, (j_compress_ptr cinfo, J_BUF_MODE pass_mode));
+  JMETHOD(void, process_data, (j_compress_ptr cinfo,
+			       JSAMPARRAY input_buf, JDIMENSION *in_row_ctr,
+			       JDIMENSION in_rows_avail));
+};
+
+/* Compression preprocessing (downsampling input buffer control) */
+struct jpeg_c_prep_controller {
+  JMETHOD(void, start_pass, (j_compress_ptr cinfo, J_BUF_MODE pass_mode));
+  JMETHOD(void, pre_process_data, (j_compress_ptr cinfo,
+				   JSAMPARRAY input_buf,
+				   JDIMENSION *in_row_ctr,
+				   JDIMENSION in_rows_avail,
+				   JSAMPIMAGE output_buf,
+				   JDIMENSION *out_row_group_ctr,
+				   JDIMENSION out_row_groups_avail));
+};
+
+/* Coefficient buffer control */
+struct jpeg_c_coef_controller {
+  JMETHOD(void, start_pass, (j_compress_ptr cinfo, J_BUF_MODE pass_mode));
+  JMETHOD(boolean, compress_data, (j_compress_ptr cinfo,
+				   JSAMPIMAGE input_buf));
+};
+
+/* Colorspace conversion */
+struct jpeg_color_converter {
+  JMETHOD(void, start_pass, (j_compress_ptr cinfo));
+  JMETHOD(void, color_convert, (j_compress_ptr cinfo,
+				JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+				JDIMENSION output_row, int num_rows));
+};
+
+/* Downsampling */
+struct jpeg_downsampler {
+  JMETHOD(void, start_pass, (j_compress_ptr cinfo));
+  JMETHOD(void, downsample, (j_compress_ptr cinfo,
+			     JSAMPIMAGE input_buf, JDIMENSION in_row_index,
+			     JSAMPIMAGE output_buf,
+			     JDIMENSION out_row_group_index));
+
+  boolean need_context_rows;	/* TRUE if need rows above & below */
+};
+
+/* Forward DCT (also controls coefficient quantization) */
+struct jpeg_forward_dct {
+  JMETHOD(void, start_pass, (j_compress_ptr cinfo));
+  /* perhaps this should be an array??? */
+  JMETHOD(void, forward_DCT, (j_compress_ptr cinfo,
+			      jpeg_component_info * compptr,
+			      JSAMPARRAY sample_data, JBLOCKROW coef_blocks,
+			      JDIMENSION start_row, JDIMENSION start_col,
+			      JDIMENSION num_blocks));
+};
+
+/* Entropy encoding */
+struct jpeg_entropy_encoder {
+  JMETHOD(void, start_pass, (j_compress_ptr cinfo, boolean gather_statistics));
+  JMETHOD(boolean, encode_mcu, (j_compress_ptr cinfo, JBLOCKROW *MCU_data));
+  JMETHOD(void, finish_pass, (j_compress_ptr cinfo));
+};
+
+/* Marker writing */
+struct jpeg_marker_writer {
+  /* write_any_marker is exported for use by applications */
+  /* Probably only COM and APPn markers should be written */
+  JMETHOD(void, write_any_marker, (j_compress_ptr cinfo, int marker,
+				   const JOCTET *dataptr, unsigned int datalen));
+  JMETHOD(void, write_file_header, (j_compress_ptr cinfo));
+  JMETHOD(void, write_frame_header, (j_compress_ptr cinfo));
+  JMETHOD(void, write_scan_header, (j_compress_ptr cinfo));
+  JMETHOD(void, write_file_trailer, (j_compress_ptr cinfo));
+  JMETHOD(void, write_tables_only, (j_compress_ptr cinfo));
+};
+
+
+/* Declarations for decompression modules */
+
+/* Master control module */
+struct jpeg_decomp_master {
+  JMETHOD(void, prepare_for_output_pass, (j_decompress_ptr cinfo));
+  JMETHOD(void, finish_output_pass, (j_decompress_ptr cinfo));
+
+  /* State variables made visible to other modules */
+  boolean is_dummy_pass;	/* True during 1st pass for 2-pass quant */
+};
+
+/* Input control module */
+struct jpeg_input_controller {
+  JMETHOD(int, consume_input, (j_decompress_ptr cinfo));
+  JMETHOD(void, reset_input_controller, (j_decompress_ptr cinfo));
+  JMETHOD(void, start_input_pass, (j_decompress_ptr cinfo));
+  JMETHOD(void, finish_input_pass, (j_decompress_ptr cinfo));
+
+  /* State variables made visible to other modules */
+  boolean has_multiple_scans;	/* True if file has multiple scans */
+  boolean eoi_reached;		/* True when EOI has been consumed */
+};
+
+/* Main buffer control (downsampled-data buffer) */
+struct jpeg_d_main_controller {
+  JMETHOD(void, start_pass, (j_decompress_ptr cinfo, J_BUF_MODE pass_mode));
+  JMETHOD(void, process_data, (j_decompress_ptr cinfo,
+			       JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
+			       JDIMENSION out_rows_avail));
+};
+
+/* Coefficient buffer control */
+struct jpeg_d_coef_controller {
+  JMETHOD(void, start_input_pass, (j_decompress_ptr cinfo));
+  JMETHOD(int, consume_data, (j_decompress_ptr cinfo));
+  JMETHOD(void, start_output_pass, (j_decompress_ptr cinfo));
+  JMETHOD(int, decompress_data, (j_decompress_ptr cinfo,
+				 JSAMPIMAGE output_buf));
+  /* Pointer to array of coefficient virtual arrays, or NULL if none */
+  jvirt_barray_ptr *coef_arrays;
+};
+
+/* Decompression postprocessing (color quantization buffer control) */
+struct jpeg_d_post_controller {
+  JMETHOD(void, start_pass, (j_decompress_ptr cinfo, J_BUF_MODE pass_mode));
+  JMETHOD(void, post_process_data, (j_decompress_ptr cinfo,
+				    JSAMPIMAGE input_buf,
+				    JDIMENSION *in_row_group_ctr,
+				    JDIMENSION in_row_groups_avail,
+				    JSAMPARRAY output_buf,
+				    JDIMENSION *out_row_ctr,
+				    JDIMENSION out_rows_avail));
+};
+
+/* Marker reading & parsing */
+struct jpeg_marker_reader {
+  JMETHOD(void, reset_marker_reader, (j_decompress_ptr cinfo));
+  /* Read markers until SOS or EOI.
+   * Returns same codes as are defined for jpeg_consume_input:
+   * JPEG_SUSPENDED, JPEG_REACHED_SOS, or JPEG_REACHED_EOI.
+   */
+  JMETHOD(int, read_markers, (j_decompress_ptr cinfo));
+  /* Read a restart marker --- exported for use by entropy decoder only */
+  jpeg_marker_parser_method read_restart_marker;
+  /* Application-overridable marker processing methods */
+  jpeg_marker_parser_method process_COM;
+  jpeg_marker_parser_method process_APPn[16];
+
+  /* State of marker reader --- nominally internal, but applications
+   * supplying COM or APPn handlers might like to know the state.
+   */
+  boolean saw_SOI;		/* found SOI? */
+  boolean saw_SOF;		/* found SOF? */
+  int next_restart_num;		/* next restart number expected (0-7) */
+  unsigned int discarded_bytes;	/* # of bytes skipped looking for a marker */
+};
+
+/* Entropy decoding */
+struct jpeg_entropy_decoder {
+  JMETHOD(void, start_pass, (j_decompress_ptr cinfo));
+  JMETHOD(boolean, decode_mcu, (j_decompress_ptr cinfo,
+				JBLOCKROW *MCU_data));
+};
+
+/* Inverse DCT (also performs dequantization) */
+typedef JMETHOD(void, inverse_DCT_method_ptr,
+		(j_decompress_ptr cinfo, jpeg_component_info * compptr,
+		 JCOEFPTR coef_block,
+		 JSAMPARRAY output_buf, JDIMENSION output_col));
+
+struct jpeg_inverse_dct {
+  JMETHOD(void, start_pass, (j_decompress_ptr cinfo));
+  /* It is useful to allow each component to have a separate IDCT method. */
+  inverse_DCT_method_ptr inverse_DCT[MAX_COMPONENTS];
+};
+
+/* Upsampling (note that upsampler must also call color converter) */
+struct jpeg_upsampler {
+  JMETHOD(void, start_pass, (j_decompress_ptr cinfo));
+  JMETHOD(void, upsample, (j_decompress_ptr cinfo,
+			   JSAMPIMAGE input_buf,
+			   JDIMENSION *in_row_group_ctr,
+			   JDIMENSION in_row_groups_avail,
+			   JSAMPARRAY output_buf,
+			   JDIMENSION *out_row_ctr,
+			   JDIMENSION out_rows_avail));
+
+  boolean need_context_rows;	/* TRUE if need rows above & below */
+};
+
+/* Colorspace conversion */
+struct jpeg_color_deconverter {
+  JMETHOD(void, start_pass, (j_decompress_ptr cinfo));
+  JMETHOD(void, color_convert, (j_decompress_ptr cinfo,
+				JSAMPIMAGE input_buf, JDIMENSION input_row,
+				JSAMPARRAY output_buf, int num_rows));
+};
+
+/* Color quantization or color precision reduction */
+struct jpeg_color_quantizer {
+  JMETHOD(void, start_pass, (j_decompress_ptr cinfo, boolean is_pre_scan));
+  JMETHOD(void, color_quantize, (j_decompress_ptr cinfo,
+				 JSAMPARRAY input_buf, JSAMPARRAY output_buf,
+				 int num_rows));
+  JMETHOD(void, finish_pass, (j_decompress_ptr cinfo));
+  JMETHOD(void, new_color_map, (j_decompress_ptr cinfo));
+};
+
+
+/* Miscellaneous useful macros */
+
+#undef MAX
+#define MAX(a,b)	((a) > (b) ? (a) : (b))
+#undef MIN
+#define MIN(a,b)	((a) < (b) ? (a) : (b))
+
+
+/* We assume that right shift corresponds to signed division by 2 with
+ * rounding towards minus infinity.  This is correct for typical "arithmetic
+ * shift" instructions that shift in copies of the sign bit.  But some
+ * C compilers implement >> with an unsigned shift.  For these machines you
+ * must define RIGHT_SHIFT_IS_UNSIGNED.
+ * RIGHT_SHIFT provides a proper signed right shift of an INT32 quantity.
+ * It is only applied with constant shift counts.  SHIFT_TEMPS must be
+ * included in the variables of any routine using RIGHT_SHIFT.
+ */
+
+#ifdef RIGHT_SHIFT_IS_UNSIGNED
+#define SHIFT_TEMPS	INT32 shift_temp;
+#define RIGHT_SHIFT(x,shft)  \
+	((shift_temp = (x)) < 0 ? \
+	 (shift_temp >> (shft)) | ((~((INT32) 0)) << (32-(shft))) : \
+	 (shift_temp >> (shft)))
+#else
+#define SHIFT_TEMPS
+#define RIGHT_SHIFT(x,shft)	((x) >> (shft))
+#endif
+
+
+/* Short forms of external names for systems with brain-damaged linkers. */
+
+#ifdef NEED_SHORT_EXTERNAL_NAMES
+#define jinit_compress_master	jICompress
+#define jinit_c_master_control	jICMaster
+#define jinit_c_main_controller	jICMainC
+#define jinit_c_prep_controller	jICPrepC
+#define jinit_c_coef_controller	jICCoefC
+#define jinit_color_converter	jICColor
+#define jinit_downsampler	jIDownsampler
+#define jinit_forward_dct	jIFDCT
+#define jinit_huff_encoder	jIHEncoder
+#define jinit_phuff_encoder	jIPHEncoder
+#define jinit_marker_writer	jIMWriter
+#define jinit_master_decompress	jIDMaster
+#define jinit_d_main_controller	jIDMainC
+#define jinit_d_coef_controller	jIDCoefC
+#define jinit_d_post_controller	jIDPostC
+#define jinit_input_controller	jIInCtlr
+#define jinit_marker_reader	jIMReader
+#define jinit_huff_decoder	jIHDecoder
+#define jinit_phuff_decoder	jIPHDecoder
+#define jinit_inverse_dct	jIIDCT
+#define jinit_upsampler		jIUpsampler
+#define jinit_color_deconverter	jIDColor
+#define jinit_1pass_quantizer	jI1Quant
+#define jinit_2pass_quantizer	jI2Quant
+#define jinit_merged_upsampler	jIMUpsampler
+#define jinit_memory_mgr	jIMemMgr
+#define jdiv_round_up		jDivRound
+#define jround_up		jRound
+#define jcopy_sample_rows	jCopySamples
+#define jcopy_block_row		jCopyBlocks
+#define jzero_far		jZeroFar
+#define jpeg_zigzag_order	jZIGTable
+#define jpeg_natural_order	jZAGTable
+#endif /* NEED_SHORT_EXTERNAL_NAMES */
+
+
+/* Compression module initialization routines */
+EXTERN void jinit_compress_master JPP((j_compress_ptr cinfo));
+EXTERN void jinit_c_master_control JPP((j_compress_ptr cinfo,
+					boolean transcode_only));
+EXTERN void jinit_c_main_controller JPP((j_compress_ptr cinfo,
+					 boolean need_full_buffer));
+EXTERN void jinit_c_prep_controller JPP((j_compress_ptr cinfo,
+					 boolean need_full_buffer));
+EXTERN void jinit_c_coef_controller JPP((j_compress_ptr cinfo,
+					 boolean need_full_buffer));
+EXTERN void jinit_color_converter JPP((j_compress_ptr cinfo));
+EXTERN void jinit_downsampler JPP((j_compress_ptr cinfo));
+EXTERN void jinit_forward_dct JPP((j_compress_ptr cinfo));
+EXTERN void jinit_huff_encoder JPP((j_compress_ptr cinfo));
+EXTERN void jinit_phuff_encoder JPP((j_compress_ptr cinfo));
+EXTERN void jinit_marker_writer JPP((j_compress_ptr cinfo));
+/* Decompression module initialization routines */
+EXTERN void jinit_master_decompress JPP((j_decompress_ptr cinfo));
+EXTERN void jinit_d_main_controller JPP((j_decompress_ptr cinfo,
+					 boolean need_full_buffer));
+EXTERN void jinit_d_coef_controller JPP((j_decompress_ptr cinfo,
+					 boolean need_full_buffer));
+EXTERN void jinit_d_post_controller JPP((j_decompress_ptr cinfo,
+					 boolean need_full_buffer));
+EXTERN void jinit_input_controller JPP((j_decompress_ptr cinfo));
+EXTERN void jinit_marker_reader JPP((j_decompress_ptr cinfo));
+EXTERN void jinit_huff_decoder JPP((j_decompress_ptr cinfo));
+EXTERN void jinit_phuff_decoder JPP((j_decompress_ptr cinfo));
+EXTERN void jinit_inverse_dct JPP((j_decompress_ptr cinfo));
+EXTERN void jinit_upsampler JPP((j_decompress_ptr cinfo));
+EXTERN void jinit_color_deconverter JPP((j_decompress_ptr cinfo));
+EXTERN void jinit_1pass_quantizer JPP((j_decompress_ptr cinfo));
+EXTERN void jinit_2pass_quantizer JPP((j_decompress_ptr cinfo));
+EXTERN void jinit_merged_upsampler JPP((j_decompress_ptr cinfo));
+/* Memory manager initialization */
+EXTERN void jinit_memory_mgr JPP((j_common_ptr cinfo));
+
+/* Utility routines in jutils.c */
+EXTERN long jdiv_round_up JPP((long a, long b));
+EXTERN long jround_up JPP((long a, long b));
+EXTERN void jcopy_sample_rows JPP((JSAMPARRAY input_array, int source_row,
+				   JSAMPARRAY output_array, int dest_row,
+				   int num_rows, JDIMENSION num_cols));
+EXTERN void jcopy_block_row JPP((JBLOCKROW input_row, JBLOCKROW output_row,
+				 JDIMENSION num_blocks));
+EXTERN void jzero_far JPP((void FAR * target, size_t bytestozero));
+/* Constant tables in jutils.c */
+extern const int jpeg_zigzag_order[]; /* natural coef order to zigzag order */
+extern const int jpeg_natural_order[]; /* zigzag coef order to natural order */
+
+/* Suppress undefined-structure complaints if necessary. */
+
+#ifdef INCOMPLETE_TYPES_BROKEN
+#ifndef AM_MEMORY_MANAGER	/* only jmemmgr.c defines these */
+struct jvirt_sarray_control { long dummy; };
+struct jvirt_barray_control { long dummy; };
+#endif
+#endif /* INCOMPLETE_TYPES_BROKEN */
diff --git a/code/jpeg-6/jpeglib.h b/code/jpeg-6/jpeglib.h
new file mode 100644
index 0000000..3027b12
--- /dev/null
+++ b/code/jpeg-6/jpeglib.h
@@ -0,0 +1,1065 @@
+/*
+ * jpeglib.h
+ *
+ * Copyright (C) 1991-1995, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file defines the application interface for the JPEG library.
+ * Most applications using the library need only include this file,
+ * and perhaps jerror.h if they want to know the exact error codes.
+ */
+
+#ifndef JPEGLIB_H
+#define JPEGLIB_H
+
+#if !defined(TR_LOCAL_H)
+	#include "../renderer/tr_local.h"
+#endif
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+
+typedef unsigned char boolean;
+/*
+ * First we include the configuration files that record how this
+ * installation of the JPEG library is set up.  jconfig.h can be
+ * generated automatically for many systems.  jmorecfg.h contains
+ * manual configuration options that most people need not worry about.
+ */
+
+#ifndef JCONFIG_INCLUDED	/* in case jinclude.h already did */
+#include "../jpeg-6/jconfig.h"		/* widely used configuration options */
+#endif
+#include "../jpeg-6/jmorecfg.h"		/* seldom changed options */
+
+
+/* Version ID for the JPEG library.
+ * Might be useful for tests like "#if JPEG_LIB_VERSION >= 60".
+ */
+
+#define JPEG_LIB_VERSION  60	/* Version 6 */
+
+
+/* Various constants determining the sizes of things.
+ * All of these are specified by the JPEG standard, so don't change them
+ * if you want to be compatible.
+ */
+
+#define DCTSIZE		    8	/* The basic DCT block is 8x8 samples */
+#define DCTSIZE2	    64	/* DCTSIZE squared; # of elements in a block */
+#define NUM_QUANT_TBLS      4	/* Quantization tables are numbered 0..3 */
+#define NUM_HUFF_TBLS       4	/* Huffman tables are numbered 0..3 */
+#define NUM_ARITH_TBLS      16	/* Arith-coding tables are numbered 0..15 */
+#define MAX_COMPS_IN_SCAN   4	/* JPEG limit on # of components in one scan */
+#define MAX_SAMP_FACTOR     4	/* JPEG limit on sampling factors */
+/* Unfortunately, some bozo at Adobe saw no reason to be bound by the standard;
+ * the PostScript DCT filter can emit files with many more than 10 blocks/MCU.
+ * If you happen to run across such a file, you can up D_MAX_BLOCKS_IN_MCU
+ * to handle it.  We even let you do this from the jconfig.h file.  However,
+ * we strongly discourage changing C_MAX_BLOCKS_IN_MCU; just because Adobe
+ * sometimes emits noncompliant files doesn't mean you should too.
+ */
+#define C_MAX_BLOCKS_IN_MCU   10 /* compressor's limit on blocks per MCU */
+#ifndef D_MAX_BLOCKS_IN_MCU
+#define D_MAX_BLOCKS_IN_MCU   10 /* decompressor's limit on blocks per MCU */
+#endif
+
+
+/* This macro is used to declare a "method", that is, a function pointer.
+ * We want to supply prototype parameters if the compiler can cope.
+ * Note that the arglist parameter must be parenthesized!
+ */
+
+#ifdef HAVE_PROTOTYPES
+#define JMETHOD(type,methodname,arglist)  type (*methodname) arglist
+#else
+#define JMETHOD(type,methodname,arglist)  type (*methodname) ()
+#endif
+
+
+/* Data structures for images (arrays of samples and of DCT coefficients).
+ * On 80x86 machines, the image arrays are too big for near pointers,
+ * but the pointer arrays can fit in near memory.
+ */
+
+typedef JSAMPLE FAR *JSAMPROW;	/* ptr to one image row of pixel samples. */
+typedef JSAMPROW *JSAMPARRAY;	/* ptr to some rows (a 2-D sample array) */
+typedef JSAMPARRAY *JSAMPIMAGE;	/* a 3-D sample array: top index is color */
+
+typedef JCOEF JBLOCK[DCTSIZE2];	/* one block of coefficients */
+typedef JBLOCK FAR *JBLOCKROW;	/* pointer to one row of coefficient blocks */
+typedef JBLOCKROW *JBLOCKARRAY;		/* a 2-D array of coefficient blocks */
+typedef JBLOCKARRAY *JBLOCKIMAGE;	/* a 3-D array of coefficient blocks */
+
+typedef JCOEF FAR *JCOEFPTR;	/* useful in a couple of places */
+
+
+/* Types for JPEG compression parameters and working tables. */
+
+
+/* DCT coefficient quantization tables. */
+
+typedef struct {
+  /* This field directly represents the contents of a JPEG DQT marker.
+   * Note: the values are always given in zigzag order.
+   */
+  UINT16 quantval[DCTSIZE2];	/* quantization step for each coefficient */
+  /* This field is used only during compression.  It's initialized FALSE when
+   * the table is created, and set TRUE when it's been output to the file.
+   * You could suppress output of a table by setting this to TRUE.
+   * (See jpeg_suppress_tables for an example.)
+   */
+  boolean sent_table;		/* TRUE when table has been output */
+} JQUANT_TBL;
+
+
+/* Huffman coding tables. */
+
+typedef struct {
+  /* These two fields directly represent the contents of a JPEG DHT marker */
+  UINT8 bits[17];		/* bits[k] = # of symbols with codes of */
+				/* length k bits; bits[0] is unused */
+  UINT8 huffval[256];		/* The symbols, in order of incr code length */
+  /* This field is used only during compression.  It's initialized FALSE when
+   * the table is created, and set TRUE when it's been output to the file.
+   * You could suppress output of a table by setting this to TRUE.
+   * (See jpeg_suppress_tables for an example.)
+   */
+  boolean sent_table;		/* TRUE when table has been output */
+} JHUFF_TBL;
+
+
+/* Basic info about one component (color channel). */
+
+typedef struct {
+  /* These values are fixed over the whole image. */
+  /* For compression, they must be supplied by parameter setup; */
+  /* for decompression, they are read from the SOF marker. */
+  int component_id;		/* identifier for this component (0..255) */
+  int component_index;		/* its index in SOF or cinfo->comp_info[] */
+  int h_samp_factor;		/* horizontal sampling factor (1..4) */
+  int v_samp_factor;		/* vertical sampling factor (1..4) */
+  int quant_tbl_no;		/* quantization table selector (0..3) */
+  /* These values may vary between scans. */
+  /* For compression, they must be supplied by parameter setup; */
+  /* for decompression, they are read from the SOS marker. */
+  /* The decompressor output side may not use these variables. */
+  int dc_tbl_no;		/* DC entropy table selector (0..3) */
+  int ac_tbl_no;		/* AC entropy table selector (0..3) */
+  
+  /* Remaining fields should be treated as private by applications. */
+  
+  /* These values are computed during compression or decompression startup: */
+  /* Component's size in DCT blocks.
+   * Any dummy blocks added to complete an MCU are not counted; therefore
+   * these values do not depend on whether a scan is interleaved or not.
+   */
+  JDIMENSION width_in_blocks;
+  JDIMENSION height_in_blocks;
+  /* Size of a DCT block in samples.  Always DCTSIZE for compression.
+   * For decompression this is the size of the output from one DCT block,
+   * reflecting any scaling we choose to apply during the IDCT step.
+   * Values of 1,2,4,8 are likely to be supported.  Note that different
+   * components may receive different IDCT scalings.
+   */
+  int DCT_scaled_size;
+  /* The downsampled dimensions are the component's actual, unpadded number
+   * of samples at the main buffer (preprocessing/compression interface), thus
+   * downsampled_width = ceil(image_width * Hi/Hmax)
+   * and similarly for height.  For decompression, IDCT scaling is included, so
+   * downsampled_width = ceil(image_width * Hi/Hmax * DCT_scaled_size/DCTSIZE)
+   */
+  JDIMENSION downsampled_width;	 /* actual width in samples */
+  JDIMENSION downsampled_height; /* actual height in samples */
+  /* This flag is used only for decompression.  In cases where some of the
+   * components will be ignored (eg grayscale output from YCbCr image),
+   * we can skip most computations for the unused components.
+   */
+  boolean component_needed;	/* do we need the value of this component? */
+
+  /* These values are computed before starting a scan of the component. */
+  /* The decompressor output side may not use these variables. */
+  int MCU_width;		/* number of blocks per MCU, horizontally */
+  int MCU_height;		/* number of blocks per MCU, vertically */
+  int MCU_blocks;		/* MCU_width * MCU_height */
+  int MCU_sample_width;		/* MCU width in samples, MCU_width*DCT_scaled_size */
+  int last_col_width;		/* # of non-dummy blocks across in last MCU */
+  int last_row_height;		/* # of non-dummy blocks down in last MCU */
+
+  /* Saved quantization table for component; NULL if none yet saved.
+   * See jdinput.c comments about the need for this information.
+   * This field is not currently used by the compressor.
+   */
+  JQUANT_TBL * quant_table;
+
+  /* Private per-component storage for DCT or IDCT subsystem. */
+  void * dct_table;
+} jpeg_component_info;
+
+
+/* The script for encoding a multiple-scan file is an array of these: */
+
+typedef struct {
+  int comps_in_scan;		/* number of components encoded in this scan */
+  int component_index[MAX_COMPS_IN_SCAN]; /* their SOF/comp_info[] indexes */
+  int Ss, Se;			/* progressive JPEG spectral selection parms */
+  int Ah, Al;			/* progressive JPEG successive approx. parms */
+} jpeg_scan_info;
+
+
+/* Known color spaces. */
+
+typedef enum {
+	JCS_UNKNOWN,		/* error/unspecified */
+	JCS_GRAYSCALE,		/* monochrome */
+	JCS_RGB,		/* red/green/blue */
+	JCS_YCbCr,		/* Y/Cb/Cr (also known as YUV) */
+	JCS_CMYK,		/* C/M/Y/K */
+	JCS_YCCK		/* Y/Cb/Cr/K */
+} J_COLOR_SPACE;
+
+/* DCT/IDCT algorithm options. */
+
+typedef enum {
+	JDCT_ISLOW,		/* slow but accurate integer algorithm */
+	JDCT_IFAST,		/* faster, less accurate integer method */
+	JDCT_FLOAT		/* floating-point: accurate, fast on fast HW */
+} J_DCT_METHOD;
+
+#ifndef JDCT_DEFAULT		/* may be overridden in jconfig.h */
+#define JDCT_DEFAULT  JDCT_ISLOW
+#endif
+#ifndef JDCT_FASTEST		/* may be overridden in jconfig.h */
+#define JDCT_FASTEST  JDCT_IFAST
+#endif
+
+/* Dithering options for decompression. */
+
+typedef enum {
+	JDITHER_NONE,		/* no dithering */
+	JDITHER_ORDERED,	/* simple ordered dither */
+	JDITHER_FS		/* Floyd-Steinberg error diffusion dither */
+} J_DITHER_MODE;
+
+
+/* Common fields between JPEG compression and decompression master structs. */
+
+#define jpeg_common_fields \
+  struct jpeg_error_mgr * err;	/* Error handler module */\
+  struct jpeg_memory_mgr * mem;	/* Memory manager module */\
+  struct jpeg_progress_mgr * progress; /* Progress monitor, or NULL if none */\
+  boolean is_decompressor;	/* so common code can tell which is which */\
+  int global_state		/* for checking call sequence validity */
+
+/* Routines that are to be used by both halves of the library are declared
+ * to receive a pointer to this structure.  There are no actual instances of
+ * jpeg_common_struct, only of jpeg_compress_struct and jpeg_decompress_struct.
+ */
+struct jpeg_common_struct {
+  jpeg_common_fields;		/* Fields common to both master struct types */
+  /* Additional fields follow in an actual jpeg_compress_struct or
+   * jpeg_decompress_struct.  All three structs must agree on these
+   * initial fields!  (This would be a lot cleaner in C++.)
+   */
+};
+
+typedef struct jpeg_common_struct * j_common_ptr;
+typedef struct jpeg_compress_struct * j_compress_ptr;
+typedef struct jpeg_decompress_struct * j_decompress_ptr;
+
+
+/* Master record for a compression instance */
+
+struct jpeg_compress_struct {
+  jpeg_common_fields;		/* Fields shared with jpeg_decompress_struct */
+
+  /* Destination for compressed data */
+  struct jpeg_destination_mgr * dest;
+
+  /* Description of source image --- these fields must be filled in by
+   * outer application before starting compression.  in_color_space must
+   * be correct before you can even call jpeg_set_defaults().
+   */
+
+  JDIMENSION image_width;	/* input image width */
+  JDIMENSION image_height;	/* input image height */
+  int input_components;		/* # of color components in input image */
+  J_COLOR_SPACE in_color_space;	/* colorspace of input image */
+
+  double input_gamma;		/* image gamma of input image */
+
+  /* Compression parameters --- these fields must be set before calling
+   * jpeg_start_compress().  We recommend calling jpeg_set_defaults() to
+   * initialize everything to reasonable defaults, then changing anything
+   * the application specifically wants to change.  That way you won't get
+   * burnt when new parameters are added.  Also note that there are several
+   * helper routines to simplify changing parameters.
+   */
+
+  int data_precision;		/* bits of precision in image data */
+
+  int num_components;		/* # of color components in JPEG image */
+  J_COLOR_SPACE jpeg_color_space; /* colorspace of JPEG image */
+
+  jpeg_component_info * comp_info;
+  /* comp_info[i] describes component that appears i'th in SOF */
+  
+  JQUANT_TBL * quant_tbl_ptrs[NUM_QUANT_TBLS];
+  /* ptrs to coefficient quantization tables, or NULL if not defined */
+  
+  JHUFF_TBL * dc_huff_tbl_ptrs[NUM_HUFF_TBLS];
+  JHUFF_TBL * ac_huff_tbl_ptrs[NUM_HUFF_TBLS];
+  /* ptrs to Huffman coding tables, or NULL if not defined */
+  
+  UINT8 arith_dc_L[NUM_ARITH_TBLS]; /* L values for DC arith-coding tables */
+  UINT8 arith_dc_U[NUM_ARITH_TBLS]; /* U values for DC arith-coding tables */
+  UINT8 arith_ac_K[NUM_ARITH_TBLS]; /* Kx values for AC arith-coding tables */
+
+  int num_scans;		/* # of entries in scan_info array */
+  const jpeg_scan_info * scan_info; /* script for multi-scan file, or NULL */
+  /* The default value of scan_info is NULL, which causes a single-scan
+   * sequential JPEG file to be emitted.  To create a multi-scan file,
+   * set num_scans and scan_info to point to an array of scan definitions.
+   */
+
+  boolean raw_data_in;		/* TRUE=caller supplies downsampled data */
+  boolean arith_code;		/* TRUE=arithmetic coding, FALSE=Huffman */
+  boolean optimize_coding;	/* TRUE=optimize entropy encoding parms */
+  boolean CCIR601_sampling;	/* TRUE=first samples are cosited */
+  int smoothing_factor;		/* 1..100, or 0 for no input smoothing */
+  J_DCT_METHOD dct_method;	/* DCT algorithm selector */
+
+  /* The restart interval can be specified in absolute MCUs by setting
+   * restart_interval, or in MCU rows by setting restart_in_rows
+   * (in which case the correct restart_interval will be figured
+   * for each scan).
+   */
+  unsigned int restart_interval; /* MCUs per restart, or 0 for no restart */
+  int restart_in_rows;		/* if > 0, MCU rows per restart interval */
+
+  /* Parameters controlling emission of special markers. */
+
+  boolean write_JFIF_header;	/* should a JFIF marker be written? */
+  /* These three values are not used by the JPEG code, merely copied */
+  /* into the JFIF APP0 marker.  density_unit can be 0 for unknown, */
+  /* 1 for dots/inch, or 2 for dots/cm.  Note that the pixel aspect */
+  /* ratio is defined by X_density/Y_density even when density_unit=0. */
+  UINT8 density_unit;		/* JFIF code for pixel size units */
+  UINT16 X_density;		/* Horizontal pixel density */
+  UINT16 Y_density;		/* Vertical pixel density */
+  boolean write_Adobe_marker;	/* should an Adobe marker be written? */
+  
+  /* State variable: index of next scanline to be written to
+   * jpeg_write_scanlines().  Application may use this to control its
+   * processing loop, e.g., "while (next_scanline < image_height)".
+   */
+
+  JDIMENSION next_scanline;	/* 0 .. image_height-1  */
+
+  /* Remaining fields are known throughout compressor, but generally
+   * should not be touched by a surrounding application.
+   */
+
+  /*
+   * These fields are computed during compression startup
+   */
+  boolean progressive_mode;	/* TRUE if scan script uses progressive mode */
+  int max_h_samp_factor;	/* largest h_samp_factor */
+  int max_v_samp_factor;	/* largest v_samp_factor */
+
+  JDIMENSION total_iMCU_rows;	/* # of iMCU rows to be input to coef ctlr */
+  /* The coefficient controller receives data in units of MCU rows as defined
+   * for fully interleaved scans (whether the JPEG file is interleaved or not).
+   * There are v_samp_factor * DCTSIZE sample rows of each component in an
+   * "iMCU" (interleaved MCU) row.
+   */
+  
+  /*
+   * These fields are valid during any one scan.
+   * They describe the components and MCUs actually appearing in the scan.
+   */
+  int comps_in_scan;		/* # of JPEG components in this scan */
+  jpeg_component_info * cur_comp_info[MAX_COMPS_IN_SCAN];
+  /* *cur_comp_info[i] describes component that appears i'th in SOS */
+  
+  JDIMENSION MCUs_per_row;	/* # of MCUs across the image */
+  JDIMENSION MCU_rows_in_scan;	/* # of MCU rows in the image */
+  
+  int blocks_in_MCU;		/* # of DCT blocks per MCU */
+  int MCU_membership[C_MAX_BLOCKS_IN_MCU];
+  /* MCU_membership[i] is index in cur_comp_info of component owning */
+  /* i'th block in an MCU */
+
+  int Ss, Se, Ah, Al;		/* progressive JPEG parameters for scan */
+
+  /*
+   * Links to compression subobjects (methods and private variables of modules)
+   */
+  struct jpeg_comp_master * master;
+  struct jpeg_c_main_controller * main;
+  struct jpeg_c_prep_controller * prep;
+  struct jpeg_c_coef_controller * coef;
+  struct jpeg_marker_writer * marker;
+  struct jpeg_color_converter * cconvert;
+  struct jpeg_downsampler * downsample;
+  struct jpeg_forward_dct * fdct;
+  struct jpeg_entropy_encoder * entropy;
+};
+
+
+/* Master record for a decompression instance */
+
+struct jpeg_decompress_struct {
+  jpeg_common_fields;		/* Fields shared with jpeg_compress_struct */
+
+  /* Source of compressed data */
+  struct jpeg_source_mgr * src;
+
+  /* Basic description of image --- filled in by jpeg_read_header(). */
+  /* Application may inspect these values to decide how to process image. */
+
+  JDIMENSION image_width;	/* nominal image width (from SOF marker) */
+  JDIMENSION image_height;	/* nominal image height */
+  int num_components;		/* # of color components in JPEG image */
+  J_COLOR_SPACE jpeg_color_space; /* colorspace of JPEG image */
+
+  /* Decompression processing parameters --- these fields must be set before
+   * calling jpeg_start_decompress().  Note that jpeg_read_header() initializes
+   * them to default values.
+   */
+
+  J_COLOR_SPACE out_color_space; /* colorspace for output */
+
+  unsigned int scale_num, scale_denom; /* fraction by which to scale image */
+
+  double output_gamma;		/* image gamma wanted in output */
+
+  boolean buffered_image;	/* TRUE=multiple output passes */
+  boolean raw_data_out;		/* TRUE=downsampled data wanted */
+
+  J_DCT_METHOD dct_method;	/* IDCT algorithm selector */
+  boolean do_fancy_upsampling;	/* TRUE=apply fancy upsampling */
+  boolean do_block_smoothing;	/* TRUE=apply interblock smoothing */
+
+  boolean quantize_colors;	/* TRUE=colormapped output wanted */
+  /* the following are ignored if not quantize_colors: */
+  J_DITHER_MODE dither_mode;	/* type of color dithering to use */
+  boolean two_pass_quantize;	/* TRUE=use two-pass color quantization */
+  int desired_number_of_colors;	/* max # colors to use in created colormap */
+  /* these are significant only in buffered-image mode: */
+  boolean enable_1pass_quant;	/* enable future use of 1-pass quantizer */
+  boolean enable_external_quant;/* enable future use of external colormap */
+  boolean enable_2pass_quant;	/* enable future use of 2-pass quantizer */
+
+  /* Description of actual output image that will be returned to application.
+   * These fields are computed by jpeg_start_decompress().
+   * You can also use jpeg_calc_output_dimensions() to determine these values
+   * in advance of calling jpeg_start_decompress().
+   */
+
+  JDIMENSION output_width;	/* scaled image width */
+  JDIMENSION output_height;	/* scaled image height */
+  int out_color_components;	/* # of color components in out_color_space */
+  int output_components;	/* # of color components returned */
+  /* output_components is 1 (a colormap index) when quantizing colors;
+   * otherwise it equals out_color_components.
+   */
+  int rec_outbuf_height;	/* min recommended height of scanline buffer */
+  /* If the buffer passed to jpeg_read_scanlines() is less than this many rows
+   * high, space and time will be wasted due to unnecessary data copying.
+   * Usually rec_outbuf_height will be 1 or 2, at most 4.
+   */
+
+  /* When quantizing colors, the output colormap is described by these fields.
+   * The application can supply a colormap by setting colormap non-NULL before
+   * calling jpeg_start_decompress; otherwise a colormap is created during
+   * jpeg_start_decompress or jpeg_start_output.
+   * The map has out_color_components rows and actual_number_of_colors columns.
+   */
+  int actual_number_of_colors;	/* number of entries in use */
+  JSAMPARRAY colormap;		/* The color map as a 2-D pixel array */
+
+  /* State variables: these variables indicate the progress of decompression.
+   * The application may examine these but must not modify them.
+   */
+
+  /* Row index of next scanline to be read from jpeg_read_scanlines().
+   * Application may use this to control its processing loop, e.g.,
+   * "while (output_scanline < output_height)".
+   */
+  JDIMENSION output_scanline;	/* 0 .. output_height-1  */
+
+  /* Current input scan number and number of iMCU rows completed in scan.
+   * These indicate the progress of the decompressor input side.
+   */
+  int input_scan_number;	/* Number of SOS markers seen so far */
+  JDIMENSION input_iMCU_row;	/* Number of iMCU rows completed */
+
+  /* The "output scan number" is the notional scan being displayed by the
+   * output side.  The decompressor will not allow output scan/row number
+   * to get ahead of input scan/row, but it can fall arbitrarily far behind.
+   */
+  int output_scan_number;	/* Nominal scan number being displayed */
+  JDIMENSION output_iMCU_row;	/* Number of iMCU rows read */
+
+  /* Current progression status.  coef_bits[c][i] indicates the precision
+   * with which component c's DCT coefficient i (in zigzag order) is known.
+   * It is -1 when no data has yet been received, otherwise it is the point
+   * transform (shift) value for the most recent scan of the coefficient
+   * (thus, 0 at completion of the progression).
+   * This pointer is NULL when reading a non-progressive file.
+   */
+  int (*coef_bits)[DCTSIZE2];	/* -1 or current Al value for each coef */
+
+  /* Internal JPEG parameters --- the application usually need not look at
+   * these fields.  Note that the decompressor output side may not use
+   * any parameters that can change between scans.
+   */
+
+  /* Quantization and Huffman tables are carried forward across input
+   * datastreams when processing abbreviated JPEG datastreams.
+   */
+
+  JQUANT_TBL * quant_tbl_ptrs[NUM_QUANT_TBLS];
+  /* ptrs to coefficient quantization tables, or NULL if not defined */
+
+  JHUFF_TBL * dc_huff_tbl_ptrs[NUM_HUFF_TBLS];
+  JHUFF_TBL * ac_huff_tbl_ptrs[NUM_HUFF_TBLS];
+  /* ptrs to Huffman coding tables, or NULL if not defined */
+
+  /* These parameters are never carried across datastreams, since they
+   * are given in SOF/SOS markers or defined to be reset by SOI.
+   */
+
+  int data_precision;		/* bits of precision in image data */
+
+  jpeg_component_info * comp_info;
+  /* comp_info[i] describes component that appears i'th in SOF */
+
+  boolean progressive_mode;	/* TRUE if SOFn specifies progressive mode */
+  boolean arith_code;		/* TRUE=arithmetic coding, FALSE=Huffman */
+
+  UINT8 arith_dc_L[NUM_ARITH_TBLS]; /* L values for DC arith-coding tables */
+  UINT8 arith_dc_U[NUM_ARITH_TBLS]; /* U values for DC arith-coding tables */
+  UINT8 arith_ac_K[NUM_ARITH_TBLS]; /* Kx values for AC arith-coding tables */
+
+  unsigned int restart_interval; /* MCUs per restart interval, or 0 for no restart */
+
+  /* These fields record data obtained from optional markers recognized by
+   * the JPEG library.
+   */
+  boolean saw_JFIF_marker;	/* TRUE iff a JFIF APP0 marker was found */
+  /* Data copied from JFIF marker: */
+  UINT8 density_unit;		/* JFIF code for pixel size units */
+  UINT16 X_density;		/* Horizontal pixel density */
+  UINT16 Y_density;		/* Vertical pixel density */
+  boolean saw_Adobe_marker;	/* TRUE iff an Adobe APP14 marker was found */
+  UINT8 Adobe_transform;	/* Color transform code from Adobe marker */
+
+  boolean CCIR601_sampling;	/* TRUE=first samples are cosited */
+
+  /* Remaining fields are known throughout decompressor, but generally
+   * should not be touched by a surrounding application.
+   */
+
+  /*
+   * These fields are computed during decompression startup
+   */
+  int max_h_samp_factor;	/* largest h_samp_factor */
+  int max_v_samp_factor;	/* largest v_samp_factor */
+
+  int min_DCT_scaled_size;	/* smallest DCT_scaled_size of any component */
+
+  JDIMENSION total_iMCU_rows;	/* # of iMCU rows in image */
+  /* The coefficient controller's input and output progress is measured in
+   * units of "iMCU" (interleaved MCU) rows.  These are the same as MCU rows
+   * in fully interleaved JPEG scans, but are used whether the scan is
+   * interleaved or not.  We define an iMCU row as v_samp_factor DCT block
+   * rows of each component.  Therefore, the IDCT output contains
+   * v_samp_factor*DCT_scaled_size sample rows of a component per iMCU row.
+   */
+
+  JSAMPLE * sample_range_limit; /* table for fast range-limiting */
+
+  /*
+   * These fields are valid during any one scan.
+   * They describe the components and MCUs actually appearing in the scan.
+   * Note that the decompressor output side must not use these fields.
+   */
+  int comps_in_scan;		/* # of JPEG components in this scan */
+  jpeg_component_info * cur_comp_info[MAX_COMPS_IN_SCAN];
+  /* *cur_comp_info[i] describes component that appears i'th in SOS */
+
+  JDIMENSION MCUs_per_row;	/* # of MCUs across the image */
+  JDIMENSION MCU_rows_in_scan;	/* # of MCU rows in the image */
+
+  int blocks_in_MCU;		/* # of DCT blocks per MCU */
+  int MCU_membership[D_MAX_BLOCKS_IN_MCU];
+  /* MCU_membership[i] is index in cur_comp_info of component owning */
+  /* i'th block in an MCU */
+
+  int Ss, Se, Ah, Al;		/* progressive JPEG parameters for scan */
+
+  /* This field is shared between entropy decoder and marker parser.
+   * It is either zero or the code of a JPEG marker that has been
+   * read from the data source, but has not yet been processed.
+   */
+  int unread_marker;
+
+  /*
+   * Links to decompression subobjects (methods, private variables of modules)
+   */
+  struct jpeg_decomp_master * master;
+  struct jpeg_d_main_controller * main;
+  struct jpeg_d_coef_controller * coef;
+  struct jpeg_d_post_controller * post;
+  struct jpeg_input_controller * inputctl;
+  struct jpeg_marker_reader * marker;
+  struct jpeg_entropy_decoder * entropy;
+  struct jpeg_inverse_dct * idct;
+  struct jpeg_upsampler * upsample;
+  struct jpeg_color_deconverter * cconvert;
+  struct jpeg_color_quantizer * cquantize;
+};
+
+
+/* "Object" declarations for JPEG modules that may be supplied or called
+ * directly by the surrounding application.
+ * As with all objects in the JPEG library, these structs only define the
+ * publicly visible methods and state variables of a module.  Additional
+ * private fields may exist after the public ones.
+ */
+
+
+/* Error handler object */
+
+struct jpeg_error_mgr {
+  /* Error exit handler: does not return to caller */
+  JMETHOD(void, error_exit, (j_common_ptr cinfo));
+  /* Conditionally emit a trace or warning message */
+  JMETHOD(void, emit_message, (j_common_ptr cinfo, int msg_level));
+  /* Routine that actually outputs a trace or error message */
+  JMETHOD(void, output_message, (j_common_ptr cinfo));
+  /* Format a message string for the most recent JPEG error or message */
+  JMETHOD(void, format_message, (j_common_ptr cinfo, char * buffer));
+#define JMSG_LENGTH_MAX  200	/* recommended size of format_message buffer */
+  /* Reset error state variables at start of a new image */
+  JMETHOD(void, reset_error_mgr, (j_common_ptr cinfo));
+  
+  /* The message ID code and any parameters are saved here.
+   * A message can have one string parameter or up to 8 int parameters.
+   */
+  int msg_code;
+#define JMSG_STR_PARM_MAX  80
+  union {
+    int i[8];
+    char s[JMSG_STR_PARM_MAX];
+  } msg_parm;
+  
+  /* Standard state variables for error facility */
+  
+  int trace_level;		/* max msg_level that will be displayed */
+  
+  /* For recoverable corrupt-data errors, we emit a warning message,
+   * but keep going unless emit_message chooses to abort.  emit_message
+   * should count warnings in num_warnings.  The surrounding application
+   * can check for bad data by seeing if num_warnings is nonzero at the
+   * end of processing.
+   */
+  long num_warnings;		/* number of corrupt-data warnings */
+
+  /* These fields point to the table(s) of error message strings.
+   * An application can change the table pointer to switch to a different
+   * message list (typically, to change the language in which errors are
+   * reported).  Some applications may wish to add additional error codes
+   * that will be handled by the JPEG library error mechanism; the second
+   * table pointer is used for this purpose.
+   *
+   * First table includes all errors generated by JPEG library itself.
+   * Error code 0 is reserved for a "no such error string" message.
+   */
+  const char * const * jpeg_message_table; /* Library errors */
+  int last_jpeg_message;    /* Table contains strings 0..last_jpeg_message */
+  /* Second table can be added by application (see cjpeg/djpeg for example).
+   * It contains strings numbered first_addon_message..last_addon_message.
+   */
+  const char * const * addon_message_table; /* Non-library errors */
+  int first_addon_message;	/* code for first string in addon table */
+  int last_addon_message;	/* code for last string in addon table */
+};
+
+
+/* Progress monitor object */
+
+struct jpeg_progress_mgr {
+  JMETHOD(void, progress_monitor, (j_common_ptr cinfo));
+
+  long pass_counter;		/* work units completed in this pass */
+  long pass_limit;		/* total number of work units in this pass */
+  int completed_passes;		/* passes completed so far */
+  int total_passes;		/* total number of passes expected */
+};
+
+
+/* Data destination object for compression */
+
+struct jpeg_destination_mgr {
+  JOCTET * next_output_byte;	/* => next byte to write in buffer */
+  size_t free_in_buffer;	/* # of byte spaces remaining in buffer */
+
+  JMETHOD(void, init_destination, (j_compress_ptr cinfo));
+  JMETHOD(boolean, empty_output_buffer, (j_compress_ptr cinfo));
+  JMETHOD(void, term_destination, (j_compress_ptr cinfo));
+};
+
+
+/* Data source object for decompression */
+
+struct jpeg_source_mgr {
+  const JOCTET * next_input_byte; /* => next byte to read from buffer */
+  size_t bytes_in_buffer;	/* # of bytes remaining in buffer */
+
+  JMETHOD(void, init_source, (j_decompress_ptr cinfo));
+  JMETHOD(boolean, fill_input_buffer, (j_decompress_ptr cinfo));
+  JMETHOD(void, skip_input_data, (j_decompress_ptr cinfo, long num_bytes));
+  JMETHOD(boolean, resync_to_restart, (j_decompress_ptr cinfo, int desired));
+  JMETHOD(void, term_source, (j_decompress_ptr cinfo));
+};
+
+
+/* Memory manager object.
+ * Allocates "small" objects (a few K total), "large" objects (tens of K),
+ * and "really big" objects (virtual arrays with backing store if needed).
+ * The memory manager does not allow individual objects to be freed; rather,
+ * each created object is assigned to a pool, and whole pools can be freed
+ * at once.  This is faster and more convenient than remembering exactly what
+ * to free, especially where malloc()/free() are not too speedy.
+ * NB: alloc routines never return NULL.  They exit to error_exit if not
+ * successful.
+ */
+
+#define JPOOL_PERMANENT	0	/* lasts until master record is destroyed */
+#define JPOOL_IMAGE	1	/* lasts until done with image/datastream */
+#define JPOOL_NUMPOOLS	2
+
+typedef struct jvirt_sarray_control * jvirt_sarray_ptr;
+typedef struct jvirt_barray_control * jvirt_barray_ptr;
+
+
+struct jpeg_memory_mgr {
+  /* Method pointers */
+  JMETHOD(void *, alloc_small, (j_common_ptr cinfo, int pool_id,
+				size_t sizeofobject));
+  JMETHOD(void FAR *, alloc_large, (j_common_ptr cinfo, int pool_id,
+				     size_t sizeofobject));
+  JMETHOD(JSAMPARRAY, alloc_sarray, (j_common_ptr cinfo, int pool_id,
+				     JDIMENSION samplesperrow,
+				     JDIMENSION numrows));
+  JMETHOD(JBLOCKARRAY, alloc_barray, (j_common_ptr cinfo, int pool_id,
+				      JDIMENSION blocksperrow,
+				      JDIMENSION numrows));
+  JMETHOD(jvirt_sarray_ptr, request_virt_sarray, (j_common_ptr cinfo,
+						  int pool_id,
+						  boolean pre_zero,
+						  JDIMENSION samplesperrow,
+						  JDIMENSION numrows,
+						  JDIMENSION maxaccess));
+  JMETHOD(jvirt_barray_ptr, request_virt_barray, (j_common_ptr cinfo,
+						  int pool_id,
+						  boolean pre_zero,
+						  JDIMENSION blocksperrow,
+						  JDIMENSION numrows,
+						  JDIMENSION maxaccess));
+  JMETHOD(void, realize_virt_arrays, (j_common_ptr cinfo));
+  JMETHOD(JSAMPARRAY, access_virt_sarray, (j_common_ptr cinfo,
+					   jvirt_sarray_ptr ptr,
+					   JDIMENSION start_row,
+					   JDIMENSION num_rows,
+					   boolean writable));
+  JMETHOD(JBLOCKARRAY, access_virt_barray, (j_common_ptr cinfo,
+					    jvirt_barray_ptr ptr,
+					    JDIMENSION start_row,
+					    JDIMENSION num_rows,
+					    boolean writable));
+  JMETHOD(void, free_pool, (j_common_ptr cinfo, int pool_id));
+  JMETHOD(void, self_destruct, (j_common_ptr cinfo));
+
+  /* Limit on memory allocation for this JPEG object.  (Note that this is
+   * merely advisory, not a guaranteed maximum; it only affects the space
+   * used for virtual-array buffers.)  May be changed by outer application
+   * after creating the JPEG object.
+   */
+  long max_memory_to_use;
+};
+
+
+/* Routine signature for application-supplied marker processing methods.
+ * Need not pass marker code since it is stored in cinfo->unread_marker.
+ */
+typedef JMETHOD(boolean, jpeg_marker_parser_method, (j_decompress_ptr cinfo));
+
+
+/* Declarations for routines called by application.
+ * The JPP macro hides prototype parameters from compilers that can't cope.
+ * Note JPP requires double parentheses.
+ */
+
+#ifdef HAVE_PROTOTYPES
+#define JPP(arglist)	arglist
+#else
+#define JPP(arglist)	()
+#endif
+
+
+/* Short forms of external names for systems with brain-damaged linkers.
+ * We shorten external names to be unique in the first six letters, which
+ * is good enough for all known systems.
+ * (If your compiler itself needs names to be unique in less than 15 
+ * characters, you are out of luck.  Get a better compiler.)
+ */
+
+#ifdef NEED_SHORT_EXTERNAL_NAMES
+#define jpeg_std_error		jStdError
+#define jpeg_create_compress	jCreaCompress
+#define jpeg_create_decompress	jCreaDecompress
+#define jpeg_destroy_compress	jDestCompress
+#define jpeg_destroy_decompress	jDestDecompress
+#define jpeg_stdio_dest		jStdDest
+#define jpeg_stdio_src		jStdSrc
+#define jpeg_set_defaults	jSetDefaults
+#define jpeg_set_colorspace	jSetColorspace
+#define jpeg_default_colorspace	jDefColorspace
+#define jpeg_set_quality	jSetQuality
+#define jpeg_set_linear_quality	jSetLQuality
+#define jpeg_add_quant_table	jAddQuantTable
+#define jpeg_quality_scaling	jQualityScaling
+#define jpeg_simple_progression	jSimProgress
+#define jpeg_suppress_tables	jSuppressTables
+#define jpeg_alloc_quant_table	jAlcQTable
+#define jpeg_alloc_huff_table	jAlcHTable
+#define jpeg_start_compress	jStrtCompress
+#define jpeg_write_scanlines	jWrtScanlines
+#define jpeg_finish_compress	jFinCompress
+#define jpeg_write_raw_data	jWrtRawData
+#define jpeg_write_marker	jWrtMarker
+#define jpeg_write_tables	jWrtTables
+#define jpeg_read_header	jReadHeader
+#define jpeg_start_decompress	jStrtDecompress
+#define jpeg_read_scanlines	jReadScanlines
+#define jpeg_finish_decompress	jFinDecompress
+#define jpeg_read_raw_data	jReadRawData
+#define jpeg_has_multiple_scans	jHasMultScn
+#define jpeg_start_output	jStrtOutput
+#define jpeg_finish_output	jFinOutput
+#define jpeg_input_complete	jInComplete
+#define jpeg_new_colormap	jNewCMap
+#define jpeg_consume_input	jConsumeInput
+#define jpeg_calc_output_dimensions	jCalcDimensions
+#define jpeg_set_marker_processor	jSetMarker
+#define jpeg_read_coefficients	jReadCoefs
+#define jpeg_write_coefficients	jWrtCoefs
+#define jpeg_copy_critical_parameters	jCopyCrit
+#define jpeg_abort_compress	jAbrtCompress
+#define jpeg_abort_decompress	jAbrtDecompress
+#define jpeg_abort		jAbort
+#define jpeg_destroy		jDestroy
+#define jpeg_resync_to_restart	jResyncRestart
+#endif /* NEED_SHORT_EXTERNAL_NAMES */
+
+
+/* Default error-management setup */
+EXTERN struct jpeg_error_mgr *jpeg_std_error JPP((struct jpeg_error_mgr *err));
+
+/* Initialization and destruction of JPEG compression objects */
+/* NB: you must set up the error-manager BEFORE calling jpeg_create_xxx */
+EXTERN void jpeg_create_compress JPP((j_compress_ptr cinfo));
+EXTERN void jpeg_create_decompress JPP((j_decompress_ptr cinfo));
+EXTERN void jpeg_destroy_compress JPP((j_compress_ptr cinfo));
+EXTERN void jpeg_destroy_decompress JPP((j_decompress_ptr cinfo));
+
+/* Standard data source and destination managers: stdio streams. */
+/* Caller is responsible for opening the file before and closing after. */
+EXTERN void jpeg_stdio_dest JPP((j_compress_ptr cinfo, FILE * outfile));
+EXTERN void jpeg_stdio_src JPP((j_decompress_ptr cinfo, unsigned char *infile));
+
+/* Default parameter setup for compression */
+EXTERN void jpeg_set_defaults JPP((j_compress_ptr cinfo));
+/* Compression parameter setup aids */
+EXTERN void jpeg_set_colorspace JPP((j_compress_ptr cinfo,
+				     J_COLOR_SPACE colorspace));
+EXTERN void jpeg_default_colorspace JPP((j_compress_ptr cinfo));
+EXTERN void jpeg_set_quality JPP((j_compress_ptr cinfo, int quality,
+				  boolean force_baseline));
+EXTERN void jpeg_set_linear_quality JPP((j_compress_ptr cinfo,
+					 int scale_factor,
+					 boolean force_baseline));
+EXTERN void jpeg_add_quant_table JPP((j_compress_ptr cinfo, int which_tbl,
+				      const unsigned int *basic_table,
+				      int scale_factor,
+				      boolean force_baseline));
+EXTERN int jpeg_quality_scaling JPP((int quality));
+EXTERN void jpeg_simple_progression JPP((j_compress_ptr cinfo));
+EXTERN void jpeg_suppress_tables JPP((j_compress_ptr cinfo,
+				      boolean suppress));
+EXTERN JQUANT_TBL * jpeg_alloc_quant_table JPP((j_common_ptr cinfo));
+EXTERN JHUFF_TBL * jpeg_alloc_huff_table JPP((j_common_ptr cinfo));
+
+/* Main entry points for compression */
+EXTERN void jpeg_start_compress JPP((j_compress_ptr cinfo,
+				     boolean write_all_tables));
+EXTERN JDIMENSION jpeg_write_scanlines JPP((j_compress_ptr cinfo,
+					    JSAMPARRAY scanlines,
+					    JDIMENSION num_lines));
+EXTERN void jpeg_finish_compress JPP((j_compress_ptr cinfo));
+
+/* Replaces jpeg_write_scanlines when writing raw downsampled data. */
+EXTERN JDIMENSION jpeg_write_raw_data JPP((j_compress_ptr cinfo,
+					   JSAMPIMAGE data,
+					   JDIMENSION num_lines));
+
+/* Write a special marker.  See libjpeg.doc concerning safe usage. */
+EXTERN void jpeg_write_marker JPP((j_compress_ptr cinfo, int marker,
+				   const JOCTET *dataptr, unsigned int datalen));
+
+/* Alternate compression function: just write an abbreviated table file */
+EXTERN void jpeg_write_tables JPP((j_compress_ptr cinfo));
+
+/* Decompression startup: read start of JPEG datastream to see what's there */
+EXTERN int jpeg_read_header JPP((j_decompress_ptr cinfo,
+				 boolean require_image));
+/* Return value is one of: */
+#define JPEG_SUSPENDED		0 /* Suspended due to lack of input data */
+#define JPEG_HEADER_OK		1 /* Found valid image datastream */
+#define JPEG_HEADER_TABLES_ONLY	2 /* Found valid table-specs-only datastream */
+/* If you pass require_image = TRUE (normal case), you need not check for
+ * a TABLES_ONLY return code; an abbreviated file will cause an error exit.
+ * JPEG_SUSPENDED is only possible if you use a data source module that can
+ * give a suspension return (the stdio source module doesn't).
+ */
+
+/* Main entry points for decompression */
+EXTERN boolean jpeg_start_decompress JPP((j_decompress_ptr cinfo));
+EXTERN JDIMENSION jpeg_read_scanlines JPP((j_decompress_ptr cinfo,
+					   JSAMPARRAY scanlines,
+					   JDIMENSION max_lines));
+EXTERN boolean jpeg_finish_decompress JPP((j_decompress_ptr cinfo));
+
+/* Replaces jpeg_read_scanlines when reading raw downsampled data. */
+EXTERN JDIMENSION jpeg_read_raw_data JPP((j_decompress_ptr cinfo,
+					  JSAMPIMAGE data,
+					  JDIMENSION max_lines));
+
+/* Additional entry points for buffered-image mode. */
+EXTERN boolean jpeg_has_multiple_scans JPP((j_decompress_ptr cinfo));
+EXTERN boolean jpeg_start_output JPP((j_decompress_ptr cinfo,
+				      int scan_number));
+EXTERN boolean jpeg_finish_output JPP((j_decompress_ptr cinfo));
+EXTERN boolean jpeg_input_complete JPP((j_decompress_ptr cinfo));
+EXTERN void jpeg_new_colormap JPP((j_decompress_ptr cinfo));
+EXTERN int jpeg_consume_input JPP((j_decompress_ptr cinfo));
+/* Return value is one of: */
+/* #define JPEG_SUSPENDED	0    Suspended due to lack of input data */
+#define JPEG_REACHED_SOS	1 /* Reached start of new scan */
+#define JPEG_REACHED_EOI	2 /* Reached end of image */
+#define JPEG_ROW_COMPLETED	3 /* Completed one iMCU row */
+#define JPEG_SCAN_COMPLETED	4 /* Completed last iMCU row of a scan */
+
+/* Precalculate output dimensions for current decompression parameters. */
+EXTERN void jpeg_calc_output_dimensions JPP((j_decompress_ptr cinfo));
+
+/* Install a special processing method for COM or APPn markers. */
+EXTERN void jpeg_set_marker_processor JPP((j_decompress_ptr cinfo,
+					   int marker_code,
+					   jpeg_marker_parser_method routine));
+
+/* Read or write raw DCT coefficients --- useful for lossless transcoding. */
+EXTERN jvirt_barray_ptr * jpeg_read_coefficients JPP((j_decompress_ptr cinfo));
+EXTERN void jpeg_write_coefficients JPP((j_compress_ptr cinfo,
+					 jvirt_barray_ptr * coef_arrays));
+EXTERN void jpeg_copy_critical_parameters JPP((j_decompress_ptr srcinfo,
+					       j_compress_ptr dstinfo));
+
+/* If you choose to abort compression or decompression before completing
+ * jpeg_finish_(de)compress, then you need to clean up to release memory,
+ * temporary files, etc.  You can just call jpeg_destroy_(de)compress
+ * if you're done with the JPEG object, but if you want to clean it up and
+ * reuse it, call this:
+ */
+EXTERN void jpeg_abort_compress JPP((j_compress_ptr cinfo));
+EXTERN void jpeg_abort_decompress JPP((j_decompress_ptr cinfo));
+
+/* Generic versions of jpeg_abort and jpeg_destroy that work on either
+ * flavor of JPEG object.  These may be more convenient in some places.
+ */
+EXTERN void jpeg_abort JPP((j_common_ptr cinfo));
+EXTERN void jpeg_destroy JPP((j_common_ptr cinfo));
+
+/* Default restart-marker-resync procedure for use by data source modules */
+EXTERN boolean jpeg_resync_to_restart JPP((j_decompress_ptr cinfo,
+					   int desired));
+
+
+/* These marker codes are exported since applications and data source modules
+ * are likely to want to use them.
+ */
+
+#define JPEG_RST0	0xD0	/* RST0 marker code */
+#define JPEG_EOI	0xD9	/* EOI marker code */
+#define JPEG_APP0	0xE0	/* APP0 marker code */
+#define JPEG_COM	0xFE	/* COM marker code */
+
+
+/* If we have a brain-damaged compiler that emits warnings (or worse, errors)
+ * for structure definitions that are never filled in, keep it quiet by
+ * supplying dummy definitions for the various substructures.
+ */
+
+#ifdef INCOMPLETE_TYPES_BROKEN
+#ifndef JPEG_INTERNALS		/* will be defined in jpegint.h */
+struct jvirt_sarray_control { long dummy; };
+struct jvirt_barray_control { long dummy; };
+struct jpeg_comp_master { long dummy; };
+struct jpeg_c_main_controller { long dummy; };
+struct jpeg_c_prep_controller { long dummy; };
+struct jpeg_c_coef_controller { long dummy; };
+struct jpeg_marker_writer { long dummy; };
+struct jpeg_color_converter { long dummy; };
+struct jpeg_downsampler { long dummy; };
+struct jpeg_forward_dct { long dummy; };
+struct jpeg_entropy_encoder { long dummy; };
+struct jpeg_decomp_master { long dummy; };
+struct jpeg_d_main_controller { long dummy; };
+struct jpeg_d_coef_controller { long dummy; };
+struct jpeg_d_post_controller { long dummy; };
+struct jpeg_input_controller { long dummy; };
+struct jpeg_marker_reader { long dummy; };
+struct jpeg_entropy_decoder { long dummy; };
+struct jpeg_inverse_dct { long dummy; };
+struct jpeg_upsampler { long dummy; };
+struct jpeg_color_deconverter { long dummy; };
+struct jpeg_color_quantizer { long dummy; };
+#endif /* JPEG_INTERNALS */
+#endif /* INCOMPLETE_TYPES_BROKEN */
+
+
+/*
+ * The JPEG library modules define JPEG_INTERNALS before including this file.
+ * The internal structure declarations are read only when that is true.
+ * Applications using the library should not include jpegint.h, but may wish
+ * to include jerror.h.
+ */
+
+#ifdef JPEG_INTERNALS
+#include "../jpeg-6/jpegint.h"		/* fetch private declarations */
+#include "../jpeg-6/jerror.h"		/* fetch error codes too */
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* JPEGLIB_H */
diff --git a/code/jpeg-6/jutils.cpp b/code/jpeg-6/jutils.cpp
new file mode 100644
index 0000000..9255505
--- /dev/null
+++ b/code/jpeg-6/jutils.cpp
@@ -0,0 +1,179 @@
+/*
+ * jutils.c
+ *
+ * Copyright (C) 1991-1995, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains tables and miscellaneous utility routines needed
+ * for both compression and decompression.
+ * Note we prefix all global names with "j" to minimize conflicts with
+ * a surrounding application.
+ */
+
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/*
+ * jpeg_zigzag_order[i] is the zigzag-order position of the i'th element
+ * of a DCT block read in natural order (left to right, top to bottom).
+ */
+
+const int jpeg_zigzag_order[DCTSIZE2] = {
+   0,  1,  5,  6, 14, 15, 27, 28,
+   2,  4,  7, 13, 16, 26, 29, 42,
+   3,  8, 12, 17, 25, 30, 41, 43,
+   9, 11, 18, 24, 31, 40, 44, 53,
+  10, 19, 23, 32, 39, 45, 52, 54,
+  20, 22, 33, 38, 46, 51, 55, 60,
+  21, 34, 37, 47, 50, 56, 59, 61,
+  35, 36, 48, 49, 57, 58, 62, 63
+};
+
+/*
+ * jpeg_natural_order[i] is the natural-order position of the i'th element
+ * of zigzag order.
+ *
+ * When reading corrupted data, the Huffman decoders could attempt
+ * to reference an entry beyond the end of this array (if the decoded
+ * zero run length reaches past the end of the block).  To prevent
+ * wild stores without adding an inner-loop test, we put some extra
+ * "63"s after the real entries.  This will cause the extra coefficient
+ * to be stored in location 63 of the block, not somewhere random.
+ * The worst case would be a run-length of 15, which means we need 16
+ * fake entries.
+ */
+
+const int jpeg_natural_order[DCTSIZE2+16] = {
+  0,  1,  8, 16,  9,  2,  3, 10,
+ 17, 24, 32, 25, 18, 11,  4,  5,
+ 12, 19, 26, 33, 40, 48, 41, 34,
+ 27, 20, 13,  6,  7, 14, 21, 28,
+ 35, 42, 49, 56, 57, 50, 43, 36,
+ 29, 22, 15, 23, 30, 37, 44, 51,
+ 58, 59, 52, 45, 38, 31, 39, 46,
+ 53, 60, 61, 54, 47, 55, 62, 63,
+ 63, 63, 63, 63, 63, 63, 63, 63, /* extra entries for safety in decoder */
+ 63, 63, 63, 63, 63, 63, 63, 63
+};
+
+
+/*
+ * Arithmetic utilities
+ */
+
+GLOBAL long
+jdiv_round_up (long a, long b)
+/* Compute a/b rounded up to next integer, ie, ceil(a/b) */
+/* Assumes a >= 0, b > 0 */
+{
+  return (a + b - 1L) / b;
+}
+
+
+GLOBAL long
+jround_up (long a, long b)
+/* Compute a rounded up to next multiple of b, ie, ceil(a/b)*b */
+/* Assumes a >= 0, b > 0 */
+{
+  a += b - 1L;
+  return a - (a % b);
+}
+
+
+/* On normal machines we can apply MEMCOPY() and MEMZERO() to sample arrays
+ * and coefficient-block arrays.  This won't work on 80x86 because the arrays
+ * are FAR and we're assuming a small-pointer memory model.  However, some
+ * DOS compilers provide far-pointer versions of memcpy() and memset() even
+ * in the small-model libraries.  These will be used if USE_FMEM is defined.
+ * Otherwise, the routines below do it the hard way.  (The performance cost
+ * is not all that great, because these routines aren't very heavily used.)
+ */
+
+#ifndef NEED_FAR_POINTERS	/* normal case, same as regular macros */
+#define FMEMCOPY(dest,src,size)	MEMCOPY(dest,src,size)
+#define FMEMZERO(target,size)	MEMZERO(target,size)
+#else				/* 80x86 case, define if we can */
+#ifdef USE_FMEM
+#define FMEMCOPY(dest,src,size)	_fmemcpy((void FAR *)(dest), (const void FAR *)(src), (size_t)(size))
+#define FMEMZERO(target,size)	_fmemset((void FAR *)(target), 0, (size_t)(size))
+#endif
+#endif
+
+
+GLOBAL void
+jcopy_sample_rows (JSAMPARRAY input_array, int source_row,
+		   JSAMPARRAY output_array, int dest_row,
+		   int num_rows, JDIMENSION num_cols)
+/* Copy some rows of samples from one place to another.
+ * num_rows rows are copied from input_array[source_row++]
+ * to output_array[dest_row++]; these areas may overlap for duplication.
+ * The source and destination arrays must be at least as wide as num_cols.
+ */
+{
+  register JSAMPROW inptr, outptr;
+#ifdef FMEMCOPY
+  register size_t count = (size_t) (num_cols * SIZEOF(JSAMPLE));
+#else
+  register JDIMENSION count;
+#endif
+  register int row;
+
+  input_array += source_row;
+  output_array += dest_row;
+
+  for (row = num_rows; row > 0; row--) {
+    inptr = *input_array++;
+    outptr = *output_array++;
+#ifdef FMEMCOPY
+    FMEMCOPY(outptr, inptr, count);
+#else
+    for (count = num_cols; count > 0; count--)
+      *outptr++ = *inptr++;	/* needn't bother with GETJSAMPLE() here */
+#endif
+  }
+}
+
+
+GLOBAL void
+jcopy_block_row (JBLOCKROW input_row, JBLOCKROW output_row,
+		 JDIMENSION num_blocks)
+/* Copy a row of coefficient blocks from one place to another. */
+{
+#ifdef FMEMCOPY
+  FMEMCOPY(output_row, input_row, num_blocks * (DCTSIZE2 * SIZEOF(JCOEF)));
+#else
+  register JCOEFPTR inptr, outptr;
+  register long count;
+
+  inptr = (JCOEFPTR) input_row;
+  outptr = (JCOEFPTR) output_row;
+  for (count = (long) num_blocks * DCTSIZE2; count > 0; count--) {
+    *outptr++ = *inptr++;
+  }
+#endif
+}
+
+
+GLOBAL void
+jzero_far (void FAR * target, size_t bytestozero)
+/* Zero out a chunk of FAR memory. */
+/* This might be sample-array data, block-array data, or alloc_large data. */
+{
+#ifdef FMEMZERO
+  FMEMZERO(target, bytestozero);
+#else
+  register char FAR * ptr = (char FAR *) target;
+  register size_t count;
+
+  for (count = bytestozero; count > 0; count--) {
+    *ptr++ = 0;
+  }
+#endif
+}
diff --git a/code/jpeg-6/jversion.h b/code/jpeg-6/jversion.h
new file mode 100644
index 0000000..02083ac
--- /dev/null
+++ b/code/jpeg-6/jversion.h
@@ -0,0 +1,14 @@
+/*
+ * jversion.h
+ *
+ * Copyright (C) 1991-1995, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains software version identification.
+ */
+
+
+#define JVERSION	"6  2-Aug-95"
+
+#define JCOPYRIGHT	"Copyright (C) 1995, Thomas G. Lane"
diff --git a/code/jpeg-6/vssver.scc b/code/jpeg-6/vssver.scc
new file mode 100644
index 0000000..eaad51d
Binary files /dev/null and b/code/jpeg-6/vssver.scc differ
diff --git a/code/mac/MacGamma.c b/code/mac/MacGamma.c
new file mode 100644
index 0000000..e468450
--- /dev/null
+++ b/code/mac/MacGamma.c
@@ -0,0 +1,487 @@
+/*
+	File:		MacGamma.cpp
+
+	Contains:	Functions to enable Mac OS device gamma adjustments using Windows common 3 channel 256 element 8 bit gamma ramps
+
+	Written by:	Geoff Stahl
+
+	Copyright:	Copyright © 1999 Apple Computer, Inc., All Rights Reserved
+
+	Change History (most recent first):
+
+         <4>     5/20/99    GGS     Added handling for gamma tables with different data widths,
+                                    number of entries, and channels.  Forced updates to 3 channels
+                                    (poss. could break on rare card, but very unlikely).  Added
+                                    quick update with BlockMove for 3x256x8 tables. Updated function
+                                    names.
+         <3>     5/20/99    GGS     Cleaned up and commented
+         <2>     5/20/99    GGS     Added system wide get and restore gamma functions to enable
+                                    restoration of original for all devices.  Modified functionality
+                                    to return pointers vice squirreling away the memory.
+         <1>     5/20/99    GGS     Initial Add
+*/
+
+
+
+// system includes ----------------------------------------------------------
+
+#include <Devices.h>
+#include <Files.h>
+#include <MacTypes.h>
+#include <QDOffscreen.h>
+#include <Quickdraw.h>
+#include <video.h>
+
+
+
+// project includes ---------------------------------------------------------
+
+#include "MacGamma.h"
+
+
+
+// functions (external/public) ----------------------------------------------
+
+// GetRawDeviceGamma
+
+// Returns the device gamma table pointer in ppDeviceTable
+
+OSErr GetGammaTable (GDHandle hGD, GammaTblPtr * ppTableGammaOut)
+{
+	VDGammaRecord   DeviceGammaRec;
+	CntrlParam		cParam;
+	OSErr			err;
+	
+	cParam.ioCompletion = NULL;										// set up control params
+	cParam.ioNamePtr = NULL;
+	cParam.ioVRefNum = 0;
+	cParam.ioCRefNum = (**hGD).gdRefNum;
+	cParam.csCode = cscGetGamma;									// Get Gamma commnd to device
+	*(Ptr *)cParam.csParam = (Ptr) &DeviceGammaRec;					// record for gamma
+
+	err = PBStatus( (ParmBlkPtr)&cParam, 0 );						// get gamma
+	
+	*ppTableGammaOut = (GammaTblPtr)(DeviceGammaRec.csGTable);		// pull table out of record
+	
+	return err;	
+}
+
+// --------------------------------------------------------------------------
+
+// CreateEmptyGammaTable
+
+// creates an empty gamma table of a given size, assume no formula data will be used
+
+Ptr CreateEmptyGammaTable (short channels, short entries, short bits)
+{
+	GammaTblPtr		pTableGammaOut = NULL;
+	short			tableSize, dataWidth;
+
+	dataWidth = (bits + 7) / 8;										// number of bytes per entry
+	tableSize = sizeof (GammaTbl) + (channels * entries * dataWidth);
+	pTableGammaOut = (GammaTblPtr) NewPtrClear (tableSize);			// allocate new tabel
+
+	if (pTableGammaOut)												// if we successfully allocated
+	{
+		pTableGammaOut->gVersion = 0;								// set parameters based on input
+		pTableGammaOut->gType = 0;
+		pTableGammaOut->gFormulaSize = 0;
+		pTableGammaOut->gChanCnt = channels;
+		pTableGammaOut->gDataCnt = entries;
+		pTableGammaOut->gDataWidth = bits;
+	}
+	return (Ptr)pTableGammaOut;										// return whatever we allocated
+}
+
+// --------------------------------------------------------------------------
+
+// CopyGammaTable
+
+// given a pointer toa device gamma table properly iterates and copies
+
+Ptr CopyGammaTable (GammaTblPtr pTableGammaIn)
+{
+	GammaTblPtr		pTableGammaOut = NULL;
+	short			tableSize, dataWidth;
+
+	if (pTableGammaIn)												// if there is a table to copy 
+	{
+		dataWidth = (pTableGammaIn->gDataWidth + 7) / 8;			// number of bytes per entry
+		tableSize = sizeof (GammaTbl) + pTableGammaIn->gFormulaSize +
+					(pTableGammaIn->gChanCnt * pTableGammaIn->gDataCnt * dataWidth);
+		pTableGammaOut = (GammaTblPtr) NewPtr (tableSize);			// allocate new table
+		if (pTableGammaOut)											
+			BlockMove( (Ptr)pTableGammaIn, (Ptr)pTableGammaOut, tableSize);	// move everything
+	}
+	return (Ptr)pTableGammaOut;										// return whatever we allocated, could be NULL
+}
+
+// --------------------------------------------------------------------------
+
+// DisposeGammaTable
+
+// disposes gamma table returned from GetGammaTable, GetDeviceGamma, or CopyGammaTable 
+// 5/20/99: (GGS) added
+
+void DisposeGammaTable (Ptr pGamma)
+{
+	if (pGamma)
+		DisposePtr((Ptr) pGamma);									// get rid of it
+}
+
+// --------------------------------------------------------------------------
+
+// GetDeviceGamma
+
+// returns pointer to copy of orginal device gamma table in native format (allocates memory for gamma table, call DisposeDeviceGamma to delete)
+// 5/20/99: (GGS) change spec to return the allocated pointer vice storing internally
+
+Ptr GetDeviceGamma (GDHandle hGD)
+{
+	GammaTblPtr		pTableGammaDevice = NULL;
+	GammaTblPtr		pTableGammaReturn = NULL;	
+	OSErr			err;
+	
+	err = GetGammaTable (hGD, &pTableGammaDevice);					// get a pointer to the devices table
+	if ((err == noErr) && pTableGammaDevice)						// if succesful
+		pTableGammaReturn = (GammaTblPtr) CopyGammaTable (pTableGammaDevice); // copy to global
+
+	return (Ptr) pTableGammaReturn;
+}
+
+// --------------------------------------------------------------------------
+
+// RestoreDeviceGamma
+
+// sets device to saved table
+// 5/20/99: (GGS) now does not delete table, avoids confusion
+
+void RestoreDeviceGamma (GDHandle hGD, Ptr pGammaTable)
+{
+	VDSetEntryRecord setEntriesRec;
+	VDGammaRecord	gameRecRestore;
+	CTabHandle      hCTabDeviceColors;
+	Ptr				csPtr;
+	OSErr			err = noErr;
+	
+	if (pGammaTable)												// if we have a table to restore								
+	{
+		gameRecRestore.csGTable = pGammaTable;						// setup restore record
+		csPtr = (Ptr) &gameRecRestore;
+		err = Control((**hGD).gdRefNum, cscSetGamma, (Ptr) &csPtr);	// restore gamma
+		
+		if ((err == noErr) && ((**(**hGD).gdPMap).pixelSize == 8))	// if successful and on an 8 bit device
+		{
+			hCTabDeviceColors = (**(**hGD).gdPMap).pmTable;			// do SetEntries to force CLUT update
+			setEntriesRec.csTable = (ColorSpec *) &(**hCTabDeviceColors).ctTable;
+			setEntriesRec.csStart = 0;
+			setEntriesRec.csCount = (**hCTabDeviceColors).ctSize;
+			csPtr = (Ptr) &setEntriesRec;
+			
+			err = Control((**hGD).gdRefNum, cscSetEntries, (Ptr) &csPtr); // SetEntries in CLUT
+		}
+	}
+}
+
+// --------------------------------------------------------------------------
+
+// GetSystemGammas
+
+// returns a pointer to a set of all current device gammas in native format (returns NULL on failure, which means reseting gamma will not be possible)
+// 5/20/99: (GGS) added
+
+Ptr GetSystemGammas (void)										
+{
+	precSystemGamma pSysGammaOut;									// return pointer to system device gamma info
+	short devCount = 0;												// number of devices attached
+	Boolean fail = false;
+	GDHandle hGDevice;
+	
+	pSysGammaOut = (precSystemGamma) NewPtr (sizeof (recSystemGamma)); // allocate for structure
+	
+	hGDevice = GetDeviceList ();							// top of device list
+	do																// iterate
+	{
+		devCount++;													// count devices					
+		hGDevice = GetNextDevice (hGDevice);						// next device
+	} while (hGDevice);
+	
+	pSysGammaOut->devGamma = (precDeviceGamma *) NewPtr (sizeof (precDeviceGamma) * devCount); // allocate for array of pointers to device records
+	if (pSysGammaOut)
+	{
+		pSysGammaOut->numDevices = devCount;						// stuff count
+		
+		devCount = 0;												// reset iteration
+		hGDevice = GetDeviceList ();
+		do
+		{
+			pSysGammaOut->devGamma [devCount] = (precDeviceGamma) NewPtr (sizeof (recDeviceGamma));	  // new device record
+			if (pSysGammaOut->devGamma [devCount])					// if we actually allocated memory
+			{
+				pSysGammaOut->devGamma [devCount]->hGD = hGDevice;										  // stuff handle
+				pSysGammaOut->devGamma [devCount]->pDeviceGamma = (GammaTblPtr)GetDeviceGamma (hGDevice); // copy gamma table
+			}
+			else													// otherwise dump record on exit
+			 fail = true;
+			devCount++;												// next device
+			hGDevice = GetNextDevice (hGDevice);						
+		} while (hGDevice);
+	}
+	if (!fail)														// if we did not fail
+		return (Ptr) pSysGammaOut;									// return pointer to structure
+	else
+	{
+		DisposeSystemGammas (&(Ptr)pSysGammaOut);					// otherwise dump the current structures (dispose does error checking)
+		return NULL;												// could not complete
+	}
+}
+
+// --------------------------------------------------------------------------
+
+// RestoreSystemGammas
+
+// restores all system devices to saved gamma setting
+// 5/20/99: (GGS) added
+
+void RestoreSystemGammas (Ptr pSystemGammas)
+{
+	short i;
+	precSystemGamma pSysGammaIn = (precSystemGamma) pSystemGammas;
+	if (pSysGammaIn)
+		for ( i = 0; i < pSysGammaIn->numDevices; i++)			// for all devices
+			RestoreDeviceGamma (pSysGammaIn->devGamma [i]->hGD, (Ptr) pSysGammaIn->devGamma [i]->pDeviceGamma);	// restore gamma
+}
+
+// --------------------------------------------------------------------------
+
+// DisposeSystemGammas
+
+// iterates through and deletes stored gamma settings
+// 5/20/99: (GGS) added
+
+void DisposeSystemGammas (Ptr* ppSystemGammas)
+{
+	precSystemGamma pSysGammaIn;
+	if (ppSystemGammas)
+	{
+		pSysGammaIn = (precSystemGamma) *ppSystemGammas;
+		if (pSysGammaIn)
+		{
+			short i;
+			for (i = 0; i < pSysGammaIn->numDevices; i++)		// for all devices
+				if (pSysGammaIn->devGamma [i])						// if pointer is valid
+				{
+					DisposeGammaTable ((Ptr) pSysGammaIn->devGamma [i]->pDeviceGamma); // dump gamma table
+					DisposePtr ((Ptr) pSysGammaIn->devGamma [i]);						 // dump device info
+				}
+			DisposePtr ((Ptr) pSysGammaIn->devGamma);				// dump device pointer array		
+			DisposePtr ((Ptr) pSysGammaIn);							// dump system structure
+			*ppSystemGammas = NULL;
+		}	
+	}
+}
+
+// --------------------------------------------------------------------------
+
+// GetDeviceGammaRampGD
+
+// retrieves the gamma ramp from a graphics device (pRamp: 3 arrays of 256 elements each)
+
+Boolean GetDeviceGammaRampGD (GDHandle hGD, Ptr pRamp)
+{
+	GammaTblPtr		pTableGammaTemp = NULL;
+	long 			indexChan, indexEntry;
+	OSErr			err;
+	
+	if (pRamp)															// ensure pRamp is allocated
+	{
+		err = GetGammaTable (hGD, &pTableGammaTemp);					// get a pointer to the current gamma
+		if ((err == noErr) && pTableGammaTemp)							// if successful
+		{															
+			// fill ramp
+			unsigned char * pEntry = (unsigned char *)&pTableGammaTemp->gFormulaData + pTableGammaTemp->gFormulaSize; // base of table
+			short bytesPerEntry = (pTableGammaTemp->gDataWidth + 7) / 8; // size, in bytes, of the device table entries
+			short shiftRightValue = pTableGammaTemp->gDataWidth - 8; 	 // number of right shifts device -> ramp
+			short channels = pTableGammaTemp->gChanCnt;	
+			short entries = pTableGammaTemp->gDataCnt;									
+			if (channels == 3)											// RGB format
+			{															// note, this will create runs of entries if dest. is bigger (not linear interpolate)
+				for (indexChan = 0; indexChan < channels; indexChan++)
+					for (indexEntry = 0; indexEntry < 256; indexEntry++)
+						*((unsigned char *)pRamp + (indexChan << 8) + indexEntry) = 
+						  *(pEntry + (indexChan * entries * bytesPerEntry) + indexEntry * ((entries * bytesPerEntry) >> 8)) >> shiftRightValue;
+			}
+			else														// single channel format
+			{
+				for (indexEntry = 0; indexEntry < 256; indexEntry++)	// for all entries set vramp value
+					for (indexChan = 0; indexChan < channels; indexChan++)	// repeat for all channels
+						*((unsigned char *)pRamp + (indexChan << 8) + indexEntry) = 
+						  *(pEntry + ((indexEntry * entries * bytesPerEntry) >> 8)) >> shiftRightValue;
+			}
+			return true;
+		}
+	}
+	return false;
+}
+
+// --------------------------------------------------------------------------
+
+// GetDeviceGammaRampGW
+
+// retrieves the gamma ramp from a graphics device associated with a GWorld pointer (pRamp: 3 arrays of 256 elements each)
+
+Boolean GetDeviceGammaRampGW (GWorldPtr pGW, Ptr pRamp)
+{
+	GDHandle hGD = GetGWorldDevice (pGW);
+	return GetDeviceGammaRampGD (hGD, pRamp);
+}
+
+// --------------------------------------------------------------------------
+
+// GetDeviceGammaRampCGP
+
+// retrieves the gamma ramp from a graphics device associated with a CGraf pointer (pRamp: 3 arrays of 256 elements each)
+
+Boolean GetDeviceGammaRampCGP (CGrafPtr pGraf, Ptr pRamp)
+{
+	CGrafPtr pGrafSave;
+	GDHandle hGDSave;
+	GDHandle hGD;
+	Boolean fResult;
+	
+	GetGWorld (&pGrafSave, &hGDSave);
+	SetGWorld (pGraf, NULL);
+	hGD = GetGDevice ();
+	fResult = GetDeviceGammaRampGD (hGD, pRamp);
+	SetGWorld (pGrafSave, hGDSave);
+	return fResult;
+}
+
+// --------------------------------------------------------------------------
+
+// SetDeviceGammaRampGD
+
+// sets the gamma ramp for a graphics device (pRamp: 3 arrays of 256 elements each (R,G,B))
+
+Boolean SetDeviceGammaRampGD (GDHandle hGD, Ptr pRamp)
+{
+	VDSetEntryRecord setEntriesRec;
+	VDGammaRecord	gameRecRestore;
+	GammaTblPtr		pTableGammaNew;
+	GammaTblPtr		pTableGammaCurrent = NULL;
+	CTabHandle      hCTabDeviceColors;
+	Ptr				csPtr;
+	OSErr			err;
+	short 			dataBits, entries, channels = 3;						// force three channels in the gamma table
+	
+	if (pRamp)																// ensure pRamp is allocated
+	{
+		err= GetGammaTable (hGD, &pTableGammaCurrent);						// get pointer to current table
+		if ((err == noErr) && pTableGammaCurrent)
+		{
+			dataBits = pTableGammaCurrent->gDataWidth;						// table must have same data width
+			entries = pTableGammaCurrent->gDataCnt;							// table must be same size
+			pTableGammaNew = (GammaTblPtr) CreateEmptyGammaTable (channels, entries, dataBits); // our new table
+			if (pTableGammaNew)												// if successful fill table
+			{	
+				unsigned char * pGammaBase = (unsigned char *)&pTableGammaNew->gFormulaData + pTableGammaNew->gFormulaSize; // base of table
+				if (entries == 256 && dataBits == 8)						// simple case: direct mapping
+					BlockMove ((Ptr)pRamp, (Ptr)pGammaBase, channels * entries); // move everything
+				else														// tough case handle entry, channel and data size disparities
+				{
+					short bytesPerEntry = (dataBits + 7) / 8; 				// size, in bytes, of the device table entries
+					short shiftRightValue = 8 - dataBits;					// number of right shifts ramp -> device
+					short indexChan;
+					short indexEntry;
+					short indexByte;
+					
+					shiftRightValue += ((bytesPerEntry - 1) * 8);  			// multibyte entries and the need to map a byte at a time most sig. to least sig.
+					for ( indexChan = 0; indexChan < channels; indexChan++) // for all the channels
+						for ( indexEntry = 0; indexEntry < entries; indexEntry++) // for all the entries
+						{
+							short currentShift = shiftRightValue;			// reset current bit shift
+							long temp = *((unsigned char *)pRamp + (indexChan << 8) + (indexEntry << 8) / entries); // get data from ramp
+							for ( indexByte = 0; indexByte < bytesPerEntry; indexByte++) // for all bytes
+							{
+								if (currentShift < 0)						// shift data correctly for current byte
+									*(pGammaBase++) = temp << -currentShift;
+								else
+									*(pGammaBase++) = temp >> currentShift;
+								currentShift -= 8;							// increment shift to align to next less sig. byte
+							}
+						}
+				}
+				
+				// set gamma
+				gameRecRestore.csGTable = (Ptr) pTableGammaNew;				// setup restore record
+				csPtr = (Ptr) &gameRecRestore;
+				err = Control((**hGD).gdRefNum, cscSetGamma, (Ptr) &csPtr);	// restore gamma
+				
+				if (((**(**hGD).gdPMap).pixelSize == 8) && (err == noErr))	// if successful and on an 8 bit device
+				{
+					hCTabDeviceColors = (**(**hGD).gdPMap).pmTable;			// do SetEntries to force CLUT update
+					setEntriesRec.csTable = (ColorSpec *) &(**hCTabDeviceColors).ctTable;
+					setEntriesRec.csStart = 0;
+					setEntriesRec.csCount = (**hCTabDeviceColors).ctSize;
+					csPtr = (Ptr) &setEntriesRec;
+					err = Control((**hGD).gdRefNum, cscSetEntries, (Ptr) &csPtr);	// SetEntries in CLUT
+				}
+				DisposeGammaTable ((Ptr) pTableGammaNew);					// dump table
+				if (err == noErr)
+					return true;
+			}
+		}
+	}
+	else																	// set NULL gamma -> results in linear map
+	{
+		gameRecRestore.csGTable = (Ptr) NULL;								// setup restore record
+		csPtr = (Ptr) &gameRecRestore;
+		err = Control((**hGD).gdRefNum, cscSetGamma, (Ptr) &csPtr);			// restore gamma
+		
+		if (((**(**hGD).gdPMap).pixelSize == 8) && (err == noErr))			// if successful and on an 8 bit device
+		{
+			hCTabDeviceColors = (**(**hGD).gdPMap).pmTable;					// do SetEntries to force CLUT update
+			setEntriesRec.csTable = (ColorSpec *) &(**hCTabDeviceColors).ctTable;
+			setEntriesRec.csStart = 0;
+			setEntriesRec.csCount = (**hCTabDeviceColors).ctSize;
+			csPtr = (Ptr) &setEntriesRec;
+			err = Control((**hGD).gdRefNum, cscSetEntries, (Ptr) &csPtr);	// SetEntries in CLUT
+		}
+		if (err == noErr)
+			return true;
+	}
+	return false;															// memory allocation or device control failed if we get here
+}
+
+// --------------------------------------------------------------------------
+
+// SetDeviceGammaRampGW
+
+// sets the gamma ramp for a graphics device associated with a GWorld pointer (pRamp: 3 arrays of 256 elements each (R,G,B))
+
+Boolean SetDeviceGammaRampGW (GWorldPtr pGW, Ptr pRamp)
+{
+	GDHandle hGD = GetGWorldDevice (pGW);
+	return SetDeviceGammaRampGD (hGD, pRamp);
+}
+
+// --------------------------------------------------------------------------
+
+// SetDeviceGammaRampCGP
+
+// sets the gamma ramp for a graphics device associated with a CGraf pointer (pRamp: 3 arrays of 256 elements each (R,G,B))
+
+Boolean SetDeviceGammaRampCGP (CGrafPtr pGraf, Ptr pRamp)
+{
+	CGrafPtr pGrafSave;
+	GDHandle hGDSave;
+	GDHandle hGD;
+	Boolean fResult;
+	
+	GetGWorld (&pGrafSave, &hGDSave);
+	SetGWorld (pGraf, NULL);
+	hGD = GetGDevice ();
+	fResult = SetDeviceGammaRampGD (hGD, pRamp);
+	SetGWorld (pGrafSave, hGDSave);
+	return fResult;
+}
\ No newline at end of file
diff --git a/code/mac/MacGamma.cpp b/code/mac/MacGamma.cpp
new file mode 100644
index 0000000..a429950
--- /dev/null
+++ b/code/mac/MacGamma.cpp
@@ -0,0 +1,474 @@
+/*
+	File:		MacGamma.cpp
+
+	Contains:	Functions to enable Mac OS device gamma adjustments using Windows common 3 channel 256 element 8 bit gamma ramps
+
+	Written by:	Geoff Stahl
+
+	Copyright:	Copyright © 1999 Apple Computer, Inc., All Rights Reserved
+
+	Change History (most recent first):
+
+         <4>     5/20/99    GGS     Added handling for gamma tables with different data widths,
+                                    number of entries, and channels.  Forced updates to 3 channels
+                                    (poss. could break on rare card, but very unlikely).  Added
+                                    quick update with BlockMove for 3x256x8 tables. Updated function
+                                    names.
+         <3>     5/20/99    GGS     Cleaned up and commented
+         <2>     5/20/99    GGS     Added system wide get and restore gamma functions to enable
+                                    restoration of original for all devices.  Modified functionality
+                                    to return pointers vice squirreling away the memory.
+         <1>     5/20/99    GGS     Initial Add
+*/
+
+
+
+// system includes ----------------------------------------------------------
+
+#include <Devices.h>
+#include <Files.h>
+#include <MacTypes.h>
+#include <QDOffscreen.h>
+#include <Quickdraw.h>
+#include <video.h>
+
+
+
+// project includes ---------------------------------------------------------
+
+#include "MacGamma.h"
+
+
+
+// functions (external/public) ----------------------------------------------
+
+// GetRawDeviceGamma
+
+// Returns the device gamma table pointer in ppDeviceTable
+
+OSErr GetGammaTable (GDHandle hGD, GammaTblPtr * ppTableGammaOut)
+{
+	VDGammaRecord   DeviceGammaRec;
+	CntrlParam		cParam;
+	OSErr			err;
+	
+	cParam.ioCompletion = NULL;										// set up control params
+	cParam.ioNamePtr = NULL;
+	cParam.ioVRefNum = 0;
+	cParam.ioCRefNum = (**hGD).gdRefNum;
+	cParam.csCode = cscGetGamma;									// Get Gamma commnd to device
+	*(Ptr *)cParam.csParam = (Ptr) &DeviceGammaRec;					// record for gamma
+
+	err = PBStatus( (ParmBlkPtr)&cParam, 0 );						// get gamma
+	
+	*ppTableGammaOut = (GammaTblPtr)(DeviceGammaRec.csGTable);		// pull table out of record
+	
+	return err;	
+}
+
+// --------------------------------------------------------------------------
+
+// CreateEmptyGammaTable
+
+// creates an empty gamma table of a given size, assume no formula data will be used
+
+Ptr CreateEmptyGammaTable (short channels, short entries, short bits)
+{
+	GammaTblPtr		pTableGammaOut = NULL;
+	short			tableSize, dataWidth;
+
+	dataWidth = (bits + 7) / 8;										// number of bytes per entry
+	tableSize = sizeof (GammaTbl) + (channels * entries * dataWidth);
+	pTableGammaOut = (GammaTblPtr) NewPtrClear (tableSize);			// allocate new tabel
+
+	if (pTableGammaOut)												// if we successfully allocated
+	{
+		pTableGammaOut->gVersion = 0;								// set parameters based on input
+		pTableGammaOut->gType = 0;
+		pTableGammaOut->gFormulaSize = 0;
+		pTableGammaOut->gChanCnt = channels;
+		pTableGammaOut->gDataCnt = entries;
+		pTableGammaOut->gDataWidth = bits;
+	}
+	return (Ptr)pTableGammaOut;										// return whatever we allocated
+}
+
+// --------------------------------------------------------------------------
+
+// CopyGammaTable
+
+// given a pointer toa device gamma table properly iterates and copies
+
+Ptr CopyGammaTable (GammaTblPtr pTableGammaIn)
+{
+	GammaTblPtr		pTableGammaOut = NULL;
+	short			tableSize, dataWidth;
+
+	if (pTableGammaIn)												// if there is a table to copy 
+	{
+		dataWidth = (pTableGammaIn->gDataWidth + 7) / 8;			// number of bytes per entry
+		tableSize = sizeof (GammaTbl) + pTableGammaIn->gFormulaSize +
+					(pTableGammaIn->gChanCnt * pTableGammaIn->gDataCnt * dataWidth);
+		pTableGammaOut = (GammaTblPtr) NewPtr (tableSize);			// allocate new table
+		if (pTableGammaOut)											
+			BlockMove( (Ptr)pTableGammaIn, (Ptr)pTableGammaOut, tableSize);	// move everything
+	}
+	return (Ptr)pTableGammaOut;										// return whatever we allocated, could be NULL
+}
+
+// --------------------------------------------------------------------------
+
+// DisposeGammaTable
+
+// disposes gamma table returned from GetGammaTable, GetDeviceGamma, or CopyGammaTable 
+// 5/20/99: (GGS) added
+
+void DisposeGammaTable (Ptr pGamma)
+{
+	if (pGamma)
+		DisposePtr((Ptr) pGamma);									// get rid of it
+}
+
+// --------------------------------------------------------------------------
+
+// GetDeviceGamma
+
+// returns pointer to copy of orginal device gamma table in native format (allocates memory for gamma table, call DisposeDeviceGamma to delete)
+// 5/20/99: (GGS) change spec to return the allocated pointer vice storing internally
+
+Ptr GetDeviceGamma (GDHandle hGD)
+{
+	GammaTblPtr		pTableGammaDevice = NULL;
+	GammaTblPtr		pTableGammaReturn = NULL;	
+	OSErr			err;
+	
+	err = GetGammaTable (hGD, &pTableGammaDevice);					// get a pointer to the devices table
+	if ((err == noErr) && pTableGammaDevice)						// if succesful
+		pTableGammaReturn = (GammaTblPtr) CopyGammaTable (pTableGammaDevice); // copy to global
+
+	return (Ptr) pTableGammaReturn;
+}
+
+// --------------------------------------------------------------------------
+
+// RestoreDeviceGamma
+
+// sets device to saved table
+// 5/20/99: (GGS) now does not delete table, avoids confusion
+
+void RestoreDeviceGamma (GDHandle hGD, Ptr pGammaTable)
+{
+	VDSetEntryRecord setEntriesRec;
+	VDGammaRecord	gameRecRestore;
+	CTabHandle      hCTabDeviceColors;
+	Ptr				csPtr;
+	OSErr			err = noErr;
+	
+	if (pGammaTable)												// if we have a table to restore								
+	{
+		gameRecRestore.csGTable = pGammaTable;						// setup restore record
+		csPtr = (Ptr) &gameRecRestore;
+		err = Control((**hGD).gdRefNum, cscSetGamma, (Ptr) &csPtr);	// restore gamma
+		
+		if ((err == noErr) && ((**(**hGD).gdPMap).pixelSize == 8))	// if successful and on an 8 bit device
+		{
+			hCTabDeviceColors = (**(**hGD).gdPMap).pmTable;			// do SetEntries to force CLUT update
+			setEntriesRec.csTable = (ColorSpec *) &(**hCTabDeviceColors).ctTable;
+			setEntriesRec.csStart = 0;
+			setEntriesRec.csCount = (**hCTabDeviceColors).ctSize;
+			csPtr = (Ptr) &setEntriesRec;
+			
+			err = Control((**hGD).gdRefNum, cscSetEntries, (Ptr) &csPtr); // SetEntries in CLUT
+		}
+	}
+}
+
+// --------------------------------------------------------------------------
+
+// GetSystemGammas
+
+// returns a pointer to a set of all current device gammas in native format (returns NULL on failure, which means reseting gamma will not be possible)
+// 5/20/99: (GGS) added
+
+Ptr GetSystemGammas (void)										
+{
+	precSystemGamma pSysGammaOut;									// return pointer to system device gamma info
+	short devCount = 0;												// number of devices attached
+	Boolean fail = false;
+
+	pSysGammaOut = (precSystemGamma) NewPtr (sizeof (recSystemGamma)); // allocate for structure
+	
+	GDHandle hGDevice = GetDeviceList ();							// top of device list
+	do																// iterate
+	{
+		devCount++;													// count devices					
+		hGDevice = GetNextDevice (hGDevice);						// next device
+	} while (hGDevice);
+	
+	pSysGammaOut->devGamma = (precDeviceGamma *) NewPtr (sizeof (precDeviceGamma) * devCount); // allocate for array of pointers to device records
+	if (pSysGammaOut)
+	{
+		pSysGammaOut->numDevices = devCount;						// stuff count
+		
+		devCount = 0;												// reset iteration
+		hGDevice = GetDeviceList ();
+		do
+		{
+			pSysGammaOut->devGamma [devCount] = (precDeviceGamma) NewPtr (sizeof (recDeviceGamma));	  // new device record
+			if (pSysGammaOut->devGamma [devCount])					// if we actually allocated memory
+			{
+				pSysGammaOut->devGamma [devCount]->hGD = hGDevice;										  // stuff handle
+				pSysGammaOut->devGamma [devCount]->pDeviceGamma = (GammaTblPtr)GetDeviceGamma (hGDevice); // copy gamma table
+			}
+			else													// otherwise dump record on exit
+			 fail = true;
+			devCount++;												// next device
+			hGDevice = GetNextDevice (hGDevice);						
+		} while (hGDevice);
+	}
+	if (!fail)														// if we did not fail
+		return (Ptr) pSysGammaOut;									// return pointer to structure
+	else
+	{
+		DisposeSystemGammas (&(Ptr)pSysGammaOut);					// otherwise dump the current structures (dispose does error checking)
+		return NULL;												// could not complete
+	}
+}
+
+// --------------------------------------------------------------------------
+
+// RestoreSystemGammas
+
+// restores all system devices to saved gamma setting
+// 5/20/99: (GGS) added
+
+void RestoreSystemGammas (Ptr pSystemGammas)
+{
+	precSystemGamma pSysGammaIn = (precSystemGamma) pSystemGammas;
+	if (pSysGammaIn)
+		for (short i = 0; i < pSysGammaIn->numDevices; i++)			// for all devices
+			RestoreDeviceGamma (pSysGammaIn->devGamma [i]->hGD, (Ptr) pSysGammaIn->devGamma [i]->pDeviceGamma);	// restore gamma
+}
+
+// --------------------------------------------------------------------------
+
+// DisposeSystemGammas
+
+// iterates through and deletes stored gamma settings
+// 5/20/99: (GGS) added
+
+void DisposeSystemGammas (Ptr* ppSystemGammas)
+{
+	precSystemGamma pSysGammaIn;
+	if (ppSystemGammas)
+	{
+		pSysGammaIn = (precSystemGamma) *ppSystemGammas;
+		if (pSysGammaIn)
+		{
+			for (short i = 0; i < pSysGammaIn->numDevices; i++)		// for all devices
+				if (pSysGammaIn->devGamma [i])						// if pointer is valid
+				{
+					DisposeGammaTable ((Ptr) pSysGammaIn->devGamma [i]->pDeviceGamma); // dump gamma table
+					DisposePtr ((Ptr) pSysGammaIn->devGamma [i]);						 // dump device info
+				}
+			DisposePtr ((Ptr) pSysGammaIn->devGamma);				// dump device pointer array		
+			DisposePtr ((Ptr) pSysGammaIn);							// dump system structure
+			*ppSystemGammas = NULL;
+		}	
+	}
+}
+
+// --------------------------------------------------------------------------
+
+// GetDeviceGammaRampGD
+
+// retrieves the gamma ramp from a graphics device (pRamp: 3 arrays of 256 elements each)
+
+Boolean GetDeviceGammaRampGD (GDHandle hGD, Ptr pRamp)
+{
+	GammaTblPtr		pTableGammaTemp = NULL;
+	long 			indexChan, indexEntry;
+	OSErr			err;
+	
+	if (pRamp)															// ensure pRamp is allocated
+	{
+		err = GetGammaTable (hGD, &pTableGammaTemp);					// get a pointer to the current gamma
+		if ((err == noErr) && pTableGammaTemp)							// if successful
+		{															
+			// fill ramp
+			unsigned char * pEntry = (unsigned char *)&pTableGammaTemp->gFormulaData + pTableGammaTemp->gFormulaSize; // base of table
+			short bytesPerEntry = (pTableGammaTemp->gDataWidth + 7) / 8; // size, in bytes, of the device table entries
+			short shiftRightValue = pTableGammaTemp->gDataWidth - 8; 	 // number of right shifts device -> ramp
+			short channels = pTableGammaTemp->gChanCnt;	
+			short entries = pTableGammaTemp->gDataCnt;									
+			if (channels == 3)											// RGB format
+			{															// note, this will create runs of entries if dest. is bigger (not linear interpolate)
+				for (indexChan = 0; indexChan < channels; indexChan++)
+					for (indexEntry = 0; indexEntry < 256; indexEntry++)
+						*((unsigned char *)pRamp + (indexChan << 8) + indexEntry) = 
+						  *(pEntry + (indexChan * entries * bytesPerEntry) + indexEntry * ((entries * bytesPerEntry) >> 8)) >> shiftRightValue;
+			}
+			else														// single channel format
+			{
+				for (indexEntry = 0; indexEntry < 256; indexEntry++)	// for all entries set vramp value
+					for (indexChan = 0; indexChan < channels; indexChan++)	// repeat for all channels
+						*((unsigned char *)pRamp + (indexChan << 8) + indexEntry) = 
+						  *(pEntry + ((indexEntry * entries * bytesPerEntry) >> 8)) >> shiftRightValue;
+			}
+			return true;
+		}
+	}
+	return false;
+}
+
+// --------------------------------------------------------------------------
+
+// GetDeviceGammaRampGW
+
+// retrieves the gamma ramp from a graphics device associated with a GWorld pointer (pRamp: 3 arrays of 256 elements each)
+
+Boolean GetDeviceGammaRampGW (GWorldPtr pGW, Ptr pRamp)
+{
+	GDHandle hGD = GetGWorldDevice (pGW);
+	return GetDeviceGammaRampGD (hGD, pRamp);
+}
+
+// --------------------------------------------------------------------------
+
+// GetDeviceGammaRampCGP
+
+// retrieves the gamma ramp from a graphics device associated with a CGraf pointer (pRamp: 3 arrays of 256 elements each)
+
+Boolean GetDeviceGammaRampCGP (CGrafPtr pGraf, Ptr pRamp)
+{
+	CGrafPtr pGrafSave;
+	GDHandle hGDSave;
+	GetGWorld (&pGrafSave, &hGDSave);
+	SetGWorld (pGraf, NULL);
+	GDHandle hGD = GetGDevice ();
+	Boolean fResult = GetDeviceGammaRampGD (hGD, pRamp);
+	SetGWorld (pGrafSave, hGDSave);
+	return fResult;
+}
+
+// --------------------------------------------------------------------------
+
+// SetDeviceGammaRampGD
+
+// sets the gamma ramp for a graphics device (pRamp: 3 arrays of 256 elements each (R,G,B))
+
+Boolean SetDeviceGammaRampGD (GDHandle hGD, Ptr pRamp)
+{
+	VDSetEntryRecord setEntriesRec;
+	VDGammaRecord	gameRecRestore;
+	GammaTblPtr		pTableGammaNew;
+	GammaTblPtr		pTableGammaCurrent = NULL;
+	CTabHandle      hCTabDeviceColors;
+	Ptr				csPtr;
+	OSErr			err;
+	short 			dataBits, entries, channels = 3;						// force three channels in the gamma table
+	
+	if (pRamp)																// ensure pRamp is allocated
+	{
+		err= GetGammaTable (hGD, &pTableGammaCurrent);						// get pointer to current table
+		if ((err == noErr) && pTableGammaCurrent)
+		{
+			dataBits = pTableGammaCurrent->gDataWidth;						// table must have same data width
+			entries = pTableGammaCurrent->gDataCnt;							// table must be same size
+			pTableGammaNew = (GammaTblPtr) CreateEmptyGammaTable (channels, entries, dataBits); // our new table
+			if (pTableGammaNew)												// if successful fill table
+			{	
+				unsigned char * pGammaBase = (unsigned char *)&pTableGammaNew->gFormulaData + pTableGammaNew->gFormulaSize; // base of table
+				if (entries == 256 && dataBits == 8)						// simple case: direct mapping
+					BlockMove ((Ptr)pRamp, (Ptr)pGammaBase, channels * entries); // move everything
+				else														// tough case handle entry, channel and data size disparities
+				{
+					short bytesPerEntry = (dataBits + 7) / 8; 				// size, in bytes, of the device table entries
+					short shiftRightValue = 8 - dataBits;					// number of right shifts ramp -> device
+					shiftRightValue += ((bytesPerEntry - 1) * 8);  			// multibyte entries and the need to map a byte at a time most sig. to least sig.
+					for (short indexChan = 0; indexChan < channels; indexChan++) // for all the channels
+						for (short indexEntry = 0; indexEntry < entries; indexEntry++) // for all the entries
+						{
+							short currentShift = shiftRightValue;			// reset current bit shift
+							long temp = *((unsigned char *)pRamp + (indexChan << 8) + (indexEntry << 8) / entries); // get data from ramp
+							for (short indexByte = 0; indexByte < bytesPerEntry; indexByte++) // for all bytes
+							{
+								if (currentShift < 0)						// shift data correctly for current byte
+									*(pGammaBase++) = temp << -currentShift;
+								else
+									*(pGammaBase++) = temp >> currentShift;
+								currentShift -= 8;							// increment shift to align to next less sig. byte
+							}
+						}
+				}
+				
+				// set gamma
+				gameRecRestore.csGTable = (Ptr) pTableGammaNew;				// setup restore record
+				csPtr = (Ptr) &gameRecRestore;
+				err = Control((**hGD).gdRefNum, cscSetGamma, (Ptr) &csPtr);	// restore gamma
+				
+				if (((**(**hGD).gdPMap).pixelSize == 8) && (err == noErr))	// if successful and on an 8 bit device
+				{
+					hCTabDeviceColors = (**(**hGD).gdPMap).pmTable;			// do SetEntries to force CLUT update
+					setEntriesRec.csTable = (ColorSpec *) &(**hCTabDeviceColors).ctTable;
+					setEntriesRec.csStart = 0;
+					setEntriesRec.csCount = (**hCTabDeviceColors).ctSize;
+					csPtr = (Ptr) &setEntriesRec;
+					err = Control((**hGD).gdRefNum, cscSetEntries, (Ptr) &csPtr);	// SetEntries in CLUT
+				}
+				DisposeGammaTable ((Ptr) pTableGammaNew);					// dump table
+				if (err == noErr)
+					return true;
+			}
+		}
+	}
+	else																	// set NULL gamma -> results in linear map
+	{
+		gameRecRestore.csGTable = (Ptr) NULL;								// setup restore record
+		csPtr = (Ptr) &gameRecRestore;
+		err = Control((**hGD).gdRefNum, cscSetGamma, (Ptr) &csPtr);			// restore gamma
+		
+		if (((**(**hGD).gdPMap).pixelSize == 8) && (err == noErr))			// if successful and on an 8 bit device
+		{
+			hCTabDeviceColors = (**(**hGD).gdPMap).pmTable;					// do SetEntries to force CLUT update
+			setEntriesRec.csTable = (ColorSpec *) &(**hCTabDeviceColors).ctTable;
+			setEntriesRec.csStart = 0;
+			setEntriesRec.csCount = (**hCTabDeviceColors).ctSize;
+			csPtr = (Ptr) &setEntriesRec;
+			err = Control((**hGD).gdRefNum, cscSetEntries, (Ptr) &csPtr);	// SetEntries in CLUT
+		}
+		if (err == noErr)
+			return true;
+	}
+	return false;															// memory allocation or device control failed if we get here
+}
+
+// --------------------------------------------------------------------------
+
+// SetDeviceGammaRampGW
+
+// sets the gamma ramp for a graphics device associated with a GWorld pointer (pRamp: 3 arrays of 256 elements each (R,G,B))
+
+Boolean SetDeviceGammaRampGW (GWorldPtr pGW, Ptr pRamp)
+{
+	GDHandle hGD = GetGWorldDevice (pGW);
+	return SetDeviceGammaRampGD (hGD, pRamp);
+}
+
+// --------------------------------------------------------------------------
+
+// SetDeviceGammaRampCGP
+
+// sets the gamma ramp for a graphics device associated with a CGraf pointer (pRamp: 3 arrays of 256 elements each (R,G,B))
+
+Boolean SetDeviceGammaRampCGP (CGrafPtr pGraf, Ptr pRamp)
+{
+	CGrafPtr pGrafSave;
+	GDHandle hGDSave;
+	GetGWorld (&pGrafSave, &hGDSave);
+	SetGWorld (pGraf, NULL);
+	GDHandle hGD = GetGDevice ();
+	Boolean fResult = SetDeviceGammaRampGD (hGD, pRamp);
+	SetGWorld (pGrafSave, hGDSave);
+	return fResult;
+}
\ No newline at end of file
diff --git a/code/mac/MacGamma.h b/code/mac/MacGamma.h
new file mode 100644
index 0000000..efb145e
--- /dev/null
+++ b/code/mac/MacGamma.h
@@ -0,0 +1,82 @@
+/*
+	File:		MacGamma.h
+
+	Contains:	Functions to enable Mac OS device gamma adjustments using Windows common 3 channel 256 element 8 bit gamma ramps
+
+	Written by:	Geoff Stahl
+
+	Copyright:	Copyright © 1999 Apple Computer, Inc., All Rights Reserved
+
+	Change History (most recent first):
+
+         <4>     5/20/99    GGS     Updated function names.
+         <3>     5/20/99    GGS     Cleaned up and commented
+         <2>     5/20/99    GGS     Added system wide get and restore gamma functions to enable
+                                    restoration of original for all devices.  Modified functionality
+                                    to return pointers vice squirreling away the memory.
+         <1>     5/20/99    GGS     Initial Add
+*/
+
+
+
+// include control --------------------------------------------------
+
+#ifndef MacGamma_h
+#define MacGamma_h
+
+
+
+// includes ---------------------------------------------------------
+
+#include <Quickdraw.h>
+#include <QDOffscreen.h>
+
+
+
+// structures/classes -----------------------------------------------
+	
+typedef struct 											// storage for device handle and gamma table
+{
+	GDHandle hGD;												// handle to device
+	GammaTblPtr pDeviceGamma;									// pointer to device gamma table
+} recDeviceGamma;
+typedef recDeviceGamma * precDeviceGamma;
+
+typedef struct											// storage for system devices and gamma tables
+{
+	short numDevices;											// number of devices
+	precDeviceGamma * devGamma;									// array of pointers to device gamma records
+} recSystemGamma;
+typedef recSystemGamma * precSystemGamma;
+
+
+
+// function declarations --------------------------------------------
+
+// 5/20/99: (GGS) changed functional specification
+OSErr GetGammaTable(GDHandle gd, GammaTblPtr * ppTableGammaOut);		// Returns the device gamma table pointer in ppDeviceTable
+Ptr CreateEmptyGammaTable (short channels, short entries, short bits);	// creates an empty gamma table of a given size, assume no formula data will be used
+Ptr CopyGammaTable (GammaTblPtr pTableGammaIn);							// given a pointer toa device gamma table properly iterates and copies
+void DisposeGammaTable (Ptr pGamma);									// disposes gamma table returned from GetGammaTable, GetDeviceGamma, or CopyGammaTable 
+
+Ptr GetDeviceGamma (GDHandle hGD);								// returns pointer to copy of orginal device gamma table in native format
+void RestoreDeviceGamma (GDHandle hGD, Ptr pGammaTable);				// sets device to saved table
+
+// 5/20/99: (GGS) added system wide gamma get and restore
+Ptr GetSystemGammas (void);										// returns a pointer to a set of all current device gammas in native format
+																	// (returns NULL on failure, which means reseting gamma will not be possible)
+void RestoreSystemGammas (Ptr pSystemGammas);					// restores all system devices to saved gamma setting
+void DisposeSystemGammas (Ptr* ppSystemGammas);					// iterates through and deletes stored gamma settings
+
+Boolean GetDeviceGammaRampGD (GDHandle hGD, Ptr pRamp);			// retrieves the gamma ramp from a graphics device (pRamp: 3 arrays of 256 elements each)
+Boolean GetDeviceGammaRampGW (GWorldPtr pGW, Ptr pRamp);		// retrieves the gamma ramp from a graphics device associated with a GWorld pointer (pRamp: 3 arrays of 256 elements each)
+Boolean GetDeviceGammaRampCGP (CGrafPtr pGraf, Ptr pRamp);		// retrieves the gamma ramp from a graphics device associated with a CGraf pointer (pRamp: 3 arrays of 256 elements each)
+
+
+Boolean SetDeviceGammaRampGD (GDHandle hGD, Ptr pRamp);			// sets the gamma ramp for a graphics device (pRamp: 3 arrays of 256 elements each (R,G,B))
+Boolean SetDeviceGammaRampGW (GWorldPtr pGW, Ptr pRamp);		// sets the gamma ramp for a graphics device associated with a GWorld pointer (pRamp: 3 arrays of 256 elements each (R,G,B))
+Boolean SetDeviceGammaRampCGP (CGrafPtr pGraf, Ptr pRamp);		// sets the gamma ramp for a graphics device associated with a CGraf pointer (pRamp: 3 arrays of 256 elements each (R,G,B))
+
+
+
+#endif // MacGamma_h
\ No newline at end of file
diff --git a/code/mac/MacQuake3 b/code/mac/MacQuake3
new file mode 100644
index 0000000..f6d71f8
Binary files /dev/null and b/code/mac/MacQuake3 differ
diff --git a/code/mac/mac_console.c b/code/mac/mac_console.c
new file mode 100644
index 0000000..839a4ef
--- /dev/null
+++ b/code/mac/mac_console.c
@@ -0,0 +1,119 @@
+#include "../client/client.h"
+#include "mac_local.h"
+#include <DriverServices.h>
+#include <console.h>
+
+#define	CONSOLE_MASK	1023
+static char	consoleChars[CONSOLE_MASK+1];
+static int consoleHead, consoleTail;
+static qboolean consoleDisplayed;
+
+/*
+==================
+Sys_InitConsole
+==================
+*/
+void	Sys_InitConsole( void ) {
+	SIOUXSettings.initializeTB   = 0;
+	SIOUXSettings.standalone   = 0;
+	SIOUXSettings.setupmenus   = 0;
+	SIOUXSettings.autocloseonquit   = 1;
+	SIOUXSettings.asktosaveonclose   = 0;
+	SIOUXSettings.toppixel = 40;
+	SIOUXSettings.leftpixel = 10;
+	
+//	Sys_ShowConsole( 1, qfalse );
+}
+
+/*
+==================
+Sys_ShowConsole
+==================
+*/
+void	Sys_ShowConsole( int level, qboolean quitOnClose ) {
+	
+	if ( level ) {
+		consoleDisplayed = qtrue;
+		printf( "\n" );
+	} else {
+		// FIXME: I don't know how to hide this window...
+		consoleDisplayed = qfalse;
+	}	
+}
+
+
+/*
+================
+Sys_Print
+
+This is called for all console output, even if the game is running
+full screen and the dedicated console window is hidden.
+================
+*/
+void	Sys_Print( const char *text ) {
+	if ( !consoleDisplayed ) {
+		return;
+	}
+	printf( "%s", text );
+}
+
+
+/*
+==================
+Sys_ConsoleEvent
+==================
+*/
+qboolean Sys_ConsoleEvent( EventRecord *event ) {
+	qboolean flag;
+	
+	flag = SIOUXHandleOneEvent(event);
+	
+	// track keyboard events so we can do console input,
+	// because SIOUX doesn't offer a polled read as far
+	// as I can tell...
+	if ( flag && event->what == keyDown ) {
+		int		myCharCode;
+	
+		myCharCode	= BitAnd( event->message, charCodeMask );
+		if ( myCharCode == 8 || myCharCode == 28 ) {
+			if ( consoleHead > consoleTail ) {
+				consoleHead--;
+			}
+		} else if ( myCharCode >= 32 || myCharCode == 13 ) {
+			consoleChars[ consoleHead & CONSOLE_MASK ] = myCharCode;
+			consoleHead++;
+		}
+	}
+		
+	return flag;
+}
+
+
+/*
+================
+Sys_ConsoleInput
+
+Checks for a complete line of text typed in at the console.
+Return NULL if a complete line is not ready.
+================
+*/
+char *Sys_ConsoleInput( void ) {
+	static char	string[1024];
+	int		i;
+
+	if ( consoleTail == consoleHead ) {
+		return NULL;
+	}
+	
+	for ( i = 0 ; i + consoleTail < consoleHead ; i++ ) {
+		string[i] = consoleChars[ ( consoleTail + i ) & CONSOLE_MASK ];
+		if ( string[i] == 13 ) {
+			consoleTail += i + 1;
+			string[i] = 0;
+			return string;
+		}
+	}
+		
+	return NULL;
+}
+
diff --git a/code/mac/mac_event.c b/code/mac/mac_event.c
new file mode 100644
index 0000000..b9ecdf8
--- /dev/null
+++ b/code/mac/mac_event.c
@@ -0,0 +1,357 @@
+#include "../client/client.h"
+#include "mac_local.h"
+
+void DoMenuCommand(long	menuAndItem);
+void DoDrag(WindowPtr	myWindow,Point	mouseloc);
+void DoGoAwayBox(WindowPtr myWindow, Point mouseloc);
+void DoCloseWindow(WindowPtr myWindow);
+void DoKeyDown(EventRecord *event);
+void DoDiskEvent(EventRecord *event);
+void DoOSEvent(EventRecord *event);
+void DoUpdate(WindowPtr myWindow);
+void DoActivate(WindowPtr myWindow, int myModifiers);
+void DoAboutBox(void);
+void DoMenuCommand(long	menuAndItem);
+void DoMouseDown(EventRecord *event);
+void DoMouseUp(EventRecord *event);
+void DoMenuAdjust(void);
+void DoKeyUp(EventRecord *event);
+
+/*
+================
+Sys_MsecForMacEvent
+
+Q3 event records take time in msec,
+so convert the mac event record when
+(60ths) to msec.  The base values
+are updated ever frame, so this
+is guaranteed to not drift.
+=================
+*/
+int	Sys_MsecForMacEvent( void ) {
+	int		tics;
+	
+	tics = sys_lastEventTic - sys_ticBase;
+	
+	return sys_msecBase + tics * 16;
+}
+
+
+
+
+void DoMouseDown(EventRecord *event)
+{	
+	int			myPart;
+	WindowPtr	myWindow;
+	Point		point;
+
+	myPart = FindWindow(event->where, &myWindow);
+	
+	switch(myPart)
+	{
+		case inMenuBar:
+			DrawMenuBar();
+			DoMenuCommand(MenuSelect(event->where));
+		break;
+		case inSysWindow:
+			SystemClick(event, myWindow);
+		break;
+		case inDrag:
+			DoDrag(myWindow, event->where);
+			
+			// update the vid_xpos / vid_ypos cvars
+			point.h = 0;
+			point.v = 0;
+			LocalToGlobal( &point );
+			Cvar_SetValue( "vid_xpos", point.h );
+			Cvar_SetValue( "vid_ypos", point.v );
+			return;
+		break;
+		case inGoAway:
+			DoGoAwayBox(myWindow, event->where);
+		break;
+
+		case inContent:
+			if (myWindow != FrontWindow())
+			{
+				SelectWindow(myWindow);
+			}
+		break;
+	}
+}
+
+void DoMouseUp(EventRecord *event)
+{
+}
+
+void DoDrag(WindowPtr myWindow, Point mouseloc)
+{
+	Rect	dragBounds;
+	
+	dragBounds = (**GetGrayRgn()).rgnBBox;
+	DragWindow(myWindow,mouseloc,&dragBounds);
+
+	aglUpdateContext(aglGetCurrentContext());
+}
+
+
+void DoGoAwayBox(WindowPtr myWindow, Point mouseloc)
+{
+	if(TrackGoAway(myWindow,mouseloc))
+	{ 
+		DoCloseWindow(myWindow); 
+	}
+}
+
+void DoCloseWindow(WindowPtr myWindow)
+{
+}
+
+void DoMenuAdjust(void)
+{
+}
+
+int	vkeyToQuakeKey[256] = {
+/*0x00*/	'a', 's', 'd', 'f', 'h', 'g', 'z', 'x',
+/*0x08*/	'c', 'v', '?', 'b', 'q', 'w', 'e', 'r',
+/*0x10*/	'y', 't', '1', '2', '3', '4', '6', '5',
+/*0x18*/	'=', '9', '7', '-', '8', '0', ']', 'o',
+/*0x20*/	'u', '[', 'i', 'p', K_ENTER, 'l', 'j', '\'',
+/*0x28*/	'k', ';', '\\', ',', '/', 'n', 'm', '.',
+/*0x30*/	K_TAB, K_SPACE, '`', K_BACKSPACE, '?', K_ESCAPE, '?', K_COMMAND,
+/*0x38*/	K_SHIFT, K_CAPSLOCK, K_ALT, K_CTRL, '?', '?', '?', '?',
+/*0x40*/	'?', K_KP_DEL, '?', K_KP_STAR, '?', K_KP_PLUS, '?', K_KP_NUMLOCK,
+/*0x48*/	'?', '?', '?', K_KP_SLASH, K_KP_ENTER, '?', K_KP_MINUS, '?',
+/*0x50*/	'?', K_KP_EQUALS, K_KP_INS, K_KP_END, K_KP_DOWNARROW, K_KP_PGDN, K_KP_LEFTARROW, K_KP_5,
+/*0x58*/	K_KP_RIGHTARROW, K_KP_HOME, '?', K_KP_UPARROW, K_KP_PGUP, '?', '?', '?',
+/*0x60*/	K_F5, K_F6, K_F7, K_F3, K_F8, K_F9, '?', K_F11,
+/*0x68*/	'?', K_F13, '?', K_F14, '?', K_F10, '?', K_F12,
+/*0x70*/	'?', K_F15, K_INS, K_HOME, K_PGUP, K_DEL, K_F4, K_END,	
+/*0x78*/	K_F2, K_PGDN, K_F1, K_LEFTARROW, K_RIGHTARROW, K_DOWNARROW, K_UPARROW, K_POWER
+};
+
+void DoKeyDown(EventRecord *event)
+{ 
+	int		myCharCode;
+	int		myKeyCode;
+	
+	myCharCode	= BitAnd(event->message,charCodeMask);
+	myKeyCode = ( event->message & keyCodeMask ) >> 8;
+
+	Sys_QueEvent( Sys_MsecForMacEvent(), SE_KEY, vkeyToQuakeKey[ myKeyCode ], 1, 0, NULL );
+	Sys_QueEvent( Sys_MsecForMacEvent(), SE_CHAR, myCharCode, 0, 0, NULL );
+}
+
+void DoKeyUp(EventRecord *event)
+{ 
+	int		myCharCode;
+	int		myKeyCode;
+	
+	myCharCode	= BitAnd(event->message,charCodeMask);
+	myKeyCode = ( event->message & keyCodeMask ) >> 8;
+
+	Sys_QueEvent( Sys_MsecForMacEvent(), SE_KEY, vkeyToQuakeKey[ myKeyCode ], 0, 0, NULL );
+}
+
+/*
+==================
+Sys_ModifierEvents
+==================
+*/
+static void Sys_ModifierEvents( int modifiers ) {
+	static int		oldModifiers;
+	int				changed;
+	int				i;
+
+	typedef struct {
+		int		bit;
+		int		keyCode;
+	} modifierKey_t;
+
+	static modifierKey_t	keys[] = {
+		{ 128, K_MOUSE1 },
+		{ 256, K_COMMAND },
+		{ 512, K_SHIFT },
+		{1024, K_CAPSLOCK },
+		{2048, K_ALT },
+		{4096, K_CTRL },
+		{-1, -1 }
+	};
+	
+	changed = modifiers ^ oldModifiers;
+	
+	for ( i = 0 ; keys[i].bit != -1 ; i++ ) {
+		// if we have input sprockets running, ignore mouse events we
+		// get from the debug passthrough driver
+		if ( inputActive && keys[i].keyCode == K_MOUSE1 ) {
+			continue;
+		}
+
+		if ( changed & keys[i].bit ) {
+			Sys_QueEvent( Sys_MsecForMacEvent(), 
+			SE_KEY, keys[i].keyCode, !!( modifiers & keys[i].bit ), 0, NULL );	
+		}
+	}
+	
+	oldModifiers = modifiers;
+}
+
+
+static void DoDiskEvent(EventRecord	*event)
+{
+
+}
+
+static void	DoOSEvent(EventRecord	*event)
+{
+
+}
+
+static void DoUpdate(WindowPtr	myWindow)
+{ 
+	GrafPtr		origPort;
+	
+	GetPort(&origPort);
+	SetPort(myWindow);
+		
+	BeginUpdate(myWindow);	
+	EndUpdate(myWindow);
+	
+	aglUpdateContext(aglGetCurrentContext());
+	
+	SetPort(origPort);
+}
+
+static void DoActivate( WindowPtr myWindow, int myModifiers) {
+
+}
+
+static void DoAboutBox( void ) {
+	DialogPtr	myDialog;
+	short		itemHit;
+
+	myDialog = GetNewDialog(kAboutDialog, nil, (WindowPtr) -1);
+	ModalDialog(nil, &itemHit);
+	DisposeDialog(myDialog);
+}
+
+static void DoMenuCommand( long menuAndItem ) {
+	int			myMenuNum;
+	int			myItemNum;
+	int			myResult;
+	Str255		myDAName;
+	WindowPtr	myWindow;
+	
+	myMenuNum	= HiWord(menuAndItem);
+	myItemNum	= LoWord(menuAndItem);
+	
+	GetPort(&myWindow);
+	
+	switch (myMenuNum)  {
+	case mApple:
+		switch( myItemNum ) {
+		case iAbout: 
+			DoAboutBox();
+			break;
+		default: 
+			GetMenuItemText(GetMenuHandle(mApple), myItemNum, myDAName);
+			myResult = OpenDeskAcc(myDAName);
+			break;
+		}
+		break;
+	case mFile:
+		switch (myItemNum) {
+		case iQuit:
+			Com_Quit_f();
+			break;
+		}
+		break;
+	}
+	
+	HiliteMenu(0);
+}
+
+void TestTime( EventRecord *ev ) {
+	int		msec;
+	int		tics;
+	static int startTics, startMsec;
+	
+	msec = Sys_Milliseconds();
+	tics = ev->when;
+	
+	if ( !startTics || ev->what == mouseDown ) {
+		startTics = tics;
+		startMsec = msec;
+	}
+	
+	msec -= startMsec;
+	tics -= startTics;
+	
+	if ( !tics ) {
+		return;
+	}
+	Com_Printf( "%i msec to tic\n", msec / tics );
+}
+
+/*
+==================
+Sys_SendKeyEvents
+==================
+*/
+void Sys_SendKeyEvents (void) {
+	Boolean		   gotEvent;
+	EventRecord	   event;
+	
+	if ( !glConfig.isFullscreen || sys_waitNextEvent->value ) {
+		// this call involves 68k code and task switching.
+		// do it on the desktop, or if they explicitly ask for
+		// it when fullscreen
+		gotEvent = WaitNextEvent(everyEvent, &event, 0, nil);
+	} else {
+		gotEvent = GetOSEvent( everyEvent, &event );
+	}
+	
+	// generate faked events from modifer changes
+	Sys_ModifierEvents( event.modifiers );
+
+	sys_lastEventTic = event.when;
+
+	if ( !gotEvent ) {
+		return;
+	}
+	if ( Sys_ConsoleEvent(&event) ) {
+		return;
+	}
+	switch(event.what)
+	{
+		case mouseDown:
+			DoMouseDown(&event);
+		break;
+		case mouseUp:
+			DoMouseUp(&event);
+		break;
+		case keyDown:
+			DoKeyDown(&event);
+		break;
+		case keyUp:
+			DoKeyUp(&event);
+		break;
+		case autoKey:
+			DoKeyDown(&event);
+		break;
+		case updateEvt:
+			DoUpdate((WindowPtr) event.message);
+		break;
+		case diskEvt:
+			DoDiskEvent(&event);
+		break;
+		case activateEvt:
+			DoActivate((WindowPtr) event.message, event.modifiers);
+		break;
+		case osEvt:
+			DoOSEvent(&event);
+		break;
+		default:
+		break;
+	}
+}
diff --git a/code/mac/mac_glimp.c b/code/mac/mac_glimp.c
new file mode 100644
index 0000000..2f46cc1
--- /dev/null
+++ b/code/mac/mac_glimp.c
@@ -0,0 +1,829 @@
+
+typedef int sysEventType_t;	// FIXME...
+#include "../renderer/tr_local.h"
+#include "mac_local.h"
+#include <glm.h>
+#include <DrawSprocket.h>
+#include "MacGamma.h"
+
+#define	MAX_DEVICES	32
+
+typedef struct {
+	GDHandle		devices[MAX_DEVICES];
+	int				numDevices;
+	
+	Ptr				systemGammas;
+	
+	GDHandle		device;
+
+	AGLContext      context;
+	AGLDrawable     drawable;
+	AGLPixelFormat  fmt;
+	
+	GLint			textureMemory;
+	GLint			videoMemory;
+	
+	DSpContextReference DSpContext;
+} macGlInfo;
+
+
+cvar_t			*r_device;
+cvar_t			*r_ext_transform_hint;
+glHardwareType_t		sys_hardwareType;
+macGlInfo		sys_gl;
+
+void GLimp_EndFrame( void );
+static void GLimp_Extensions( void );
+
+
+void CToPStr(char *cs, Str255 ps)
+{
+	GLint i, l;
+	
+	l = strlen(cs);
+	if(l > 255) l = 255;
+	ps[0] = l;
+	for(i = 0; i < l; i++) ps[i + 1] = cs[i];
+}
+
+/*
+============
+CheckErrors
+============
+*/
+void CheckErrors( void ) {		
+	GLenum   err;
+
+	err = aglGetError();
+	if( err != AGL_NO_ERROR ) {
+		ri.Error( ERR_FATAL, "aglGetError: %s", 
+			aglErrorString( err ) );
+	}
+}
+
+//=======================================================================
+
+/*
+=====================
+GLimp_ResetDisplay
+=====================
+*/
+void GLimp_ResetDisplay( void ) {
+	if ( !glConfig.isFullscreen ) {
+		return;
+	}
+	glConfig.isFullscreen = qfalse;
+	
+	// put the context into the inactive state
+	DSpContext_SetState( sys_gl.DSpContext, kDSpContextState_Inactive );
+
+	// release the context
+	DSpContext_Release( sys_gl.DSpContext );
+
+	// shutdown draw sprockets
+	DSpShutdown();
+}
+
+/*
+=====================
+GLimp_ChangeDisplay
+=====================
+*/
+void GLimp_ChangeDisplay( int *actualWidth, int *actualHeight ) {
+	OSStatus				theError;
+	DSpContextAttributes 	inAttributes;
+	int						colorBits;
+	
+	// startup DrawSprocket
+	theError = DSpStartup();
+	if( theError ) {
+		ri.Printf( PRINT_ALL, "DSpStartup() failed: %i\n", theError );
+		*actualWidth = 640;
+		*actualHeight = 480;
+		return;
+	}	
+	
+	if ( r_colorbits->integer == 24 || r_colorbits->integer == 32 ) {
+		colorBits = kDSpDepthMask_32;
+	} else {
+		colorBits = kDSpDepthMask_16;
+	}
+	
+	memset( &inAttributes, 0, sizeof( inAttributes ) );
+	inAttributes.frequency					= 0;
+	inAttributes.displayWidth				= glConfig.vidWidth;
+	inAttributes.displayHeight				= glConfig.vidHeight;
+	inAttributes.reserved1					= 0;
+	inAttributes.reserved2					= 0;
+	inAttributes.colorNeeds					= kDSpColorNeeds_Require;
+	inAttributes.colorTable					= NULL;
+	inAttributes.contextOptions				= 0;
+	inAttributes.backBufferDepthMask		= colorBits;
+	inAttributes.displayDepthMask			= colorBits;
+	inAttributes.backBufferBestDepth		= colorBits;
+	inAttributes.displayBestDepth			= colorBits;
+	inAttributes.pageCount					= 1;
+	inAttributes.gameMustConfirmSwitch		= false;
+	inAttributes.reserved3[0]				= 0;
+	inAttributes.reserved3[1]				= 0;
+	inAttributes.reserved3[2]				= 0;
+	inAttributes.reserved3[3]				= 0;
+
+	theError = DSpFindBestContext( &inAttributes, &sys_gl.DSpContext );
+
+	inAttributes.displayWidth				= glConfig.vidWidth;
+	inAttributes.displayHeight				= glConfig.vidHeight;
+	inAttributes.backBufferDepthMask		= colorBits;
+	inAttributes.displayDepthMask			= colorBits;
+	inAttributes.backBufferBestDepth		= colorBits;
+	inAttributes.displayBestDepth			= colorBits;
+	inAttributes.pageCount					= 1;
+
+	theError = DSpContext_Reserve( sys_gl.DSpContext, &inAttributes );
+
+	// find out what res we actually got
+	theError = DSpContext_GetAttributes( sys_gl.DSpContext, &inAttributes );
+	
+	*actualWidth = inAttributes.displayWidth;
+	*actualHeight = inAttributes.displayHeight;
+	
+	// put the context into the active state
+	theError = DSpContext_SetState( sys_gl.DSpContext, kDSpContextState_Active );
+
+	// fade back in
+	theError = DSpContext_FadeGammaIn( NULL, NULL );
+
+	glConfig.isFullscreen = qtrue;
+}
+
+//=======================================================================
+
+
+/*
+===================
+GLimp_AglDescribe_f
+
+===================
+*/
+void GLimp_AglDescribe_f( void ) {
+	long		value;
+	long		r,g,b,a;
+	long		stencil, depth;
+	
+	ri.Printf( PRINT_ALL, "Selected pixel format 0x%x\n", (int)sys_gl.fmt );
+	
+	ri.Printf( PRINT_ALL, "TEXTURE_MEMORY: %i\n", sys_gl.textureMemory );
+	ri.Printf( PRINT_ALL, "VIDEO_MEMORY: %i\n", sys_gl.videoMemory );
+	
+	aglDescribePixelFormat(sys_gl.fmt, AGL_RED_SIZE, &r);
+	aglDescribePixelFormat(sys_gl.fmt, AGL_GREEN_SIZE, &g);
+	aglDescribePixelFormat(sys_gl.fmt, AGL_BLUE_SIZE, &b);
+	aglDescribePixelFormat(sys_gl.fmt, AGL_ALPHA_SIZE, &a);
+	aglDescribePixelFormat(sys_gl.fmt, AGL_STENCIL_SIZE, &stencil);
+	aglDescribePixelFormat(sys_gl.fmt, AGL_DEPTH_SIZE, &depth);
+	ri.Printf( PRINT_ALL, "red:%i green:%i blue:%i alpha:%i depth:%i stencil:%i\n",
+		r, g, b, a, depth, stencil );
+
+	aglDescribePixelFormat(sys_gl.fmt, AGL_BUFFER_SIZE, &value);
+	ri.Printf( PRINT_ALL, "BUFFER_SIZE: %i\n", value );
+
+	aglDescribePixelFormat(sys_gl.fmt, AGL_PIXEL_SIZE, &value);
+	ri.Printf( PRINT_ALL, "PIXEL_SIZE: %i\n", value );
+
+	aglDescribePixelFormat(sys_gl.fmt, AGL_RENDERER_ID, &value);
+	ri.Printf( PRINT_ALL, "RENDERER_ID: %i\n", value );
+
+	// memory functions
+	value = glmGetInteger( GLM_PAGE_SIZE );
+	ri.Printf( PRINT_ALL, "GLM_PAGE_SIZE: %i\n", value );
+	
+	value = glmGetInteger( GLM_NUMBER_PAGES );
+	ri.Printf( PRINT_ALL, "GLM_NUMBER_PAGES: %i\n", value );
+	
+	value = glmGetInteger( GLM_CURRENT_MEMORY );
+	ri.Printf( PRINT_ALL, "GLM_CURRENT_MEMORY: %i\n", value );
+	
+	value = glmGetInteger( GLM_MAXIMUM_MEMORY );
+	ri.Printf( PRINT_ALL, "GLM_MAXIMUM_MEMORY: %i\n", value );
+	
+}
+
+/*
+===================
+GLimp_AglState_f
+
+===================
+*/
+void GLimp_AglState_f( void ) {
+	char	*cmd;
+	int		state, value;
+	
+	if ( ri.Cmd_Argc() != 3 ) {
+		ri.Printf( PRINT_ALL, "Usage: aglstate <parameter> <0/1>\n" );
+		return;
+	}
+
+	cmd = ri.Cmd_Argv( 1 );
+	if ( !Q_stricmp( cmd, "rasterization" ) ) {
+		state = AGL_RASTERIZATION;
+	} else {
+		ri.Printf( PRINT_ALL, "Unknown agl state: %s\n", cmd );
+		return;
+	}
+	
+	cmd = ri.Cmd_Argv( 2 );
+	value = atoi( cmd );
+	
+	if ( value ) {
+		aglEnable( sys_gl.context, state );
+	} else {
+		aglDisable( sys_gl.context, state );
+	}
+}
+
+/*
+===================
+GLimp_Extensions
+
+===================
+*/
+static void GLimp_Extensions( void ) {
+	const char	*extensions;
+
+	// get our config strings
+	Q_strncpyz( glConfig.vendor_string, (const char *)qglGetString (GL_VENDOR), sizeof( glConfig.vendor_string ) );
+	Q_strncpyz( glConfig.renderer_string, (const char *)qglGetString (GL_RENDERER), sizeof( glConfig.renderer_string ) );
+	Q_strncpyz( glConfig.version_string, (const char *)qglGetString (GL_VERSION), sizeof( glConfig.version_string ) );
+	Q_strncpyz( glConfig.extensions_string, (const char *)qglGetString (GL_EXTENSIONS), sizeof( glConfig.extensions_string ) );
+
+	extensions = glConfig.extensions_string;
+
+	// GL_ARB_multitexture
+	qglMultiTexCoord2fARB = NULL;
+	qglActiveTextureARB = NULL;
+	qglClientActiveTextureARB = NULL;
+
+	if ( strstr( extensions, "GL_ARB_multitexture" )  ) {
+		if ( r_ext_multitexture->integer && r_allowExtensions->integer ) {
+			qglMultiTexCoord2fARB = glMultiTexCoord2fARB;
+			qglActiveTextureARB = glActiveTextureARB;
+			qglClientActiveTextureARB = glClientActiveTextureARB;
+
+			ri.Printf( PRINT_ALL, "...using GL_ARB_multitexture\n" );
+		} else {
+			ri.Printf( PRINT_ALL, "...ignoring GL_ARB_multitexture\n" );
+		}
+	} else {
+		ri.Printf( PRINT_ALL, "...GL_ARB_multitexture not found\n" );
+	}
+
+	// GL_EXT_compiled_vertex_array
+	qglLockArraysEXT = NULL;
+	qglUnlockArraysEXT = NULL;
+
+	if ( strstr( extensions, "GL_EXT_compiled_vertex_array" ) ) {
+		if ( r_ext_compiled_vertex_array->integer && r_allowExtensions->integer ) {
+			qglLockArraysEXT = glLockArraysEXT;
+			qglUnlockArraysEXT = glUnlockArraysEXT;
+
+			ri.Printf( PRINT_ALL, "...using GL_EXT_compiled_vertex_array\n" );
+		} else {
+			ri.Printf( PRINT_ALL, "...ignoring GL_EXT_compiled_vertex_array\n" );
+		}
+	} else {
+		ri.Printf( PRINT_ALL, "...GL_EXT_compiled_vertex_array not found\n" );
+	}
+	
+	// GL_EXT_texture_env_add
+	glConfig.textureEnvAddAvailable = qfalse;
+	if ( strstr( glConfig.extensions_string, "EXT_texture_env_add" ) ) {
+		if ( r_ext_texture_env_add->integer ) {
+			glConfig.textureEnvAddAvailable = qtrue;
+			ri.Printf( PRINT_ALL, "...using GL_EXT_texture_env_add\n" );
+		} else {
+			glConfig.textureEnvAddAvailable = qfalse;
+			ri.Printf( PRINT_ALL, "...ignoring GL_EXT_texture_env_add\n" );
+		}
+	} else {
+		ri.Printf( PRINT_ALL, "...GL_EXT_texture_env_add not found\n" );
+	}
+
+	// GL_EXT_texture_filter_anisotropic
+	glConfig.textureFilterAnisotropicAvailable = qfalse;
+	if ( strstr( glConfig.extensions_string, "EXT_texture_filter_anisotropic" ) )
+	{
+		glConfig.textureFilterAnisotropicAvailable = qtrue;
+		ri.Printf( PRINT_ALL, "...GL_EXT_texture_filter_anisotropic available\n" );
+
+		if ( r_ext_texture_filter_anisotropic->integer )
+		{
+			ri.Printf( PRINT_ALL, "...using GL_EXT_texture_filter_anisotropic\n" );
+		}
+		else
+		{
+			ri.Printf( PRINT_ALL, "...ignoring GL_EXT_texture_filter_anisotropic\n" );
+		}
+		ri.Cvar_Set( "r_ext_texture_filter_anisotropic_avail", "1" );
+	}
+	else
+	{
+		ri.Printf( PRINT_ALL, "...GL_EXT_texture_filter_anisotropic not found\n" );
+		ri.Cvar_Set( "r_ext_texture_filter_anisotropic_avail", "0" );
+	}
+
+	// apple transform hint
+	if ( strstr( extensions, "GL_APPLE_transform_hint" ) ) {
+		if ( r_ext_compiled_vertex_array->integer && r_allowExtensions->integer ) {
+			glHint( GL_TRANSFORM_HINT_APPLE, GL_FASTEST );
+			ri.Printf( PRINT_ALL, "...using GL_APPLE_transform_hint\n" );
+		} else {
+			ri.Printf( PRINT_ALL, "...ignoring GL_APPLE_transform_hint\n" );
+		}
+	} else {
+		ri.Printf( PRINT_ALL, "...GL_APPLE_transform_hint not found\n" );
+	}
+}
+
+/*
+============================
+GLimp_SufficientVideoMemory
+============================
+*/
+#if 0
+
+qboolean	GLimp_SufficientVideoMemory( void ) {
+	AGLRendererInfo head_info, info;
+	GLint 		accelerated;
+	AGLDevice 	*device;
+	GLint 		i, ndevs;
+		
+	device = aglDevicesOfPixelFormat( sys_gl.fmt, &ndevs);
+	if (!device || ndevs < 1) {
+		ri.Printf( PRINT_ALL, "aglDevicesOfPixelFormat failed.\n" );
+		return 0;
+	}
+	
+	ri.Printf( PRINT_ALL, "%i rendering devices\n", ndevs );
+	
+	head_info =  aglQueryRendererInfo( device, 1 );
+	info = head_info;
+	if (!info) {
+		ri.Printf( PRINT_ALL, "aglQueryRendererInfo failed.\n" );
+		return 0;
+	}
+	
+	for ( i = 0 ; i < ndevs ; i++ ) {
+		// ignore the software renderer listing
+		aglDescribeRenderer( info, AGL_ACCELERATED, &accelerated );
+		if ( accelerated ) {		
+			aglDescribeRenderer( info, AGL_TEXTURE_MEMORY, &sys_gl.textureMemory );
+			aglDescribeRenderer( info, AGL_VIDEO_MEMORY, &sys_gl.videoMemory );
+		}
+		info = aglNextRendererInfo(info);
+	}
+
+	aglDestroyRendererInfo(head_info);
+#if 0
+	if ( sys_gl.videoMemory < 16000000 ) {
+		glConfig.hardwareType = GLHW_RAGEPRO;		// FIXME when voodoo is available
+	} else {
+		glConfig.isRagePro = GLHW_GENERIC;		// FIXME when voodoo is available
+	}
+#endif
+	ri.Printf( PRINT_ALL, "%i texture memory, %i video memory\n", sys_gl.textureMemory, sys_gl.videoMemory );
+
+	return qtrue;
+}
+
+#endif
+
+/*
+=======================
+CheckDeviceRenderers
+
+========================
+*/
+static void CheckDeviceRenderers( GDHandle device ) {
+	AGLRendererInfo info, head_info;
+	GLint inum;
+	GLint	accelerated;
+	GLint	textureMemory, videoMemory;
+	
+	head_info =  aglQueryRendererInfo(&device, 1);
+	if( !head_info ) {
+		ri.Printf( PRINT_ALL, "aglQueryRendererInfo : Info Error\n");
+		return;
+	}
+	
+	info = head_info;
+	inum = 0;
+	while( info ) {
+		ri.Printf( PRINT_ALL, "  Renderer : %d\n", inum);
+		
+		aglDescribeRenderer( info, AGL_ACCELERATED, &accelerated );
+		
+		if ( accelerated ) {		
+			aglDescribeRenderer( info, AGL_TEXTURE_MEMORY, &textureMemory );
+			aglDescribeRenderer( info, AGL_VIDEO_MEMORY, &videoMemory );
+			ri.Printf( PRINT_ALL, "    AGL_VIDEO_MEMORY: %i\n", textureMemory );
+			ri.Printf( PRINT_ALL, "    AGL_TEXTURE_MEMORY: %i\n", videoMemory );
+			
+			// save the device with the most texture memory
+			if ( sys_gl.textureMemory < textureMemory ) {
+				sys_gl.textureMemory = textureMemory;
+				sys_gl.device = device;
+			}
+		} else {
+			ri.Printf( PRINT_ALL, "    Not accelerated.\n" );
+		}
+
+		info = aglNextRendererInfo(info);
+		inum++;
+	}
+	
+	aglDestroyRendererInfo(head_info);
+}
+
+
+/*
+=======================
+CheckDevices
+
+Make sure there is a device with enough video memory to play
+=======================
+*/
+static void CheckDevices( void ) {
+	GDHandle device;
+	static	qboolean	checkedFullscreen;
+	
+	if ( checkedFullscreen ) {
+		return;
+	}
+	if ( glConfig.isFullscreen ) {
+		checkedFullscreen = qtrue;
+	}
+
+	device = GetDeviceList();
+	sys_gl.numDevices = 0;
+	while( device && sys_gl.numDevices < MAX_DEVICES ) {
+		sys_gl.devices[ sys_gl.numDevices ] = device;
+
+		ri.Printf( PRINT_ALL, "Device : %d\n", sys_gl.numDevices);
+		CheckDeviceRenderers(device);
+		
+		device = GetNextDevice(device);
+		
+		sys_gl.numDevices++;
+	}
+
+	CheckErrors();		
+	
+	if ( sys_gl.textureMemory < 4000000 ) {
+		ri.Error( ERR_FATAL, "You must have at least four megs of video memory to play" );
+	}
+
+	if ( sys_gl.textureMemory < 16000000 ) {
+		sys_hardwareType = GLHW_RAGEPRO;		// this will have to change with voodoo
+	} else {
+		sys_hardwareType = GLHW_GENERIC;
+	}
+}
+
+/*
+=================
+CreateGameWindow
+=================
+*/
+static qboolean CreateGameWindow( void ) {
+	cvar_t		*vid_xpos;
+	cvar_t		*vid_ypos;
+	int			mode;
+	int			x, y;
+	Str255    	pstr;
+
+	
+	vid_xpos = ri.Cvar_Get( "vid_xpos", "30", 0 );
+	vid_ypos = ri.Cvar_Get( "vid_ypos", "30", 0 );
+	
+	// get mode info
+	mode = r_mode->integer;
+    ri.Printf( PRINT_ALL, "...setting mode %d:", mode );
+
+    if ( !R_GetModeInfo( &glConfig.vidWidth, &glConfig.vidHeight, &glConfig.windowAspect, mode ) )  {
+        ri.Printf( PRINT_ALL, " invalid mode\n" );
+        return false;
+    }
+    ri.Printf( PRINT_ALL, " %d %d\n", glConfig.vidWidth, glConfig.vidHeight );
+
+	/* Create window */
+	if ( r_fullscreen->integer ) {
+		int		actualWidth, actualHeight;
+		
+		// change display resolution
+		GLimp_ChangeDisplay( &actualWidth, &actualHeight );
+		
+		x = ( actualWidth - glConfig.vidWidth ) / 2;
+		y = ( actualHeight - glConfig.vidHeight ) / 2;
+		sys_gl.drawable = (AGLDrawable) GetNewCWindow(kFullScreenWindow,nil,(WindowPtr)-1L);
+	} else {
+		x = vid_xpos->integer;
+		y = vid_ypos->integer;
+		sys_gl.drawable = (AGLDrawable) GetNewCWindow(kMainWindow,nil,(WindowPtr)-1L);
+	}
+	if( !sys_gl.drawable ) {
+		return qfalse;
+	}
+	
+	SizeWindow((GrafPort *) sys_gl.drawable, glConfig.vidWidth, glConfig.vidHeight,GL_FALSE);
+	MoveWindow((GrafPort *) sys_gl.drawable,x, y, GL_FALSE);
+	ShowWindow((GrafPort *) sys_gl.drawable);
+	SetPort((GrafPort *) sys_gl.drawable);
+	CToPStr("Quake3: Arena", pstr);
+	SetWTitle((GrafPort *) sys_gl.drawable, pstr);
+	HiliteWindow((GrafPort *) sys_gl.drawable, 1);
+	
+	return qtrue;
+}
+
+
+/*
+===================
+GLimp_SetMode
+
+Returns false if the mode / fullscrenn / options combination failed,
+so another fallback can be tried
+===================
+*/
+qboolean GLimp_SetMode( void ) {
+	GLint     	value;
+	GLint		attrib[64];
+	int			i;
+
+	if ( !CreateGameWindow() ) {
+		ri.Printf( PRINT_ALL, "GLimp_Init: window could not be created" );
+		return qfalse;
+	}
+	
+	// check devices now that the game has set the display mode,
+	// because RAVE devices don't get reported if in an 8 bit desktop
+	CheckDevices();
+	
+	// set up the attribute list
+	i = 0;
+	attrib[i++] = AGL_RGBA;
+	attrib[i++] = AGL_DOUBLEBUFFER;
+	attrib[i++] = AGL_NO_RECOVERY;
+	attrib[i++] = AGL_ACCELERATED;
+
+	if ( r_colorbits->integer >= 16 ) {
+		attrib[i++] = AGL_RED_SIZE;
+		attrib[i++] = 8;
+		attrib[i++] = AGL_GREEN_SIZE;
+		attrib[i++] = 8;
+		attrib[i++] = AGL_BLUE_SIZE;
+		attrib[i++] = 8;
+		attrib[i++] = AGL_ALPHA_SIZE;
+		attrib[i++] = 0;
+	} else {
+		attrib[i++] = AGL_RED_SIZE;
+		attrib[i++] = 5;
+		attrib[i++] = AGL_GREEN_SIZE;
+		attrib[i++] = 5;
+		attrib[i++] = AGL_BLUE_SIZE;
+		attrib[i++] = 5;
+		attrib[i++] = AGL_ALPHA_SIZE;
+		attrib[i++] = 0;
+	}
+	
+	attrib[i++] = AGL_STENCIL_SIZE;
+	if ( r_stencilbits->integer ) {
+		attrib[i++] = r_stencilbits->integer;		
+	} else {
+		attrib[i++] = 0;
+	}
+
+	attrib[i++] = AGL_DEPTH_SIZE;
+	if ( r_depthbits->integer ) {
+		attrib[i++] = r_depthbits->integer;
+	} else {
+		attrib[i++] = 16;
+	}
+	
+	attrib[i++] = 0;
+	
+	/* Choose pixel format */
+	ri.Printf( PRINT_ALL, "aglChoosePixelFormat\n" );
+	if ( r_device->integer < 0 || r_device->integer >= sys_gl.numDevices ) {
+		ri.Cvar_Set( "r_device", "0" );
+	}
+	sys_gl.fmt = aglChoosePixelFormat( &sys_gl.devices[ r_device->integer ], 1, attrib);
+	if(!sys_gl.fmt) {
+		ri.Printf( PRINT_ALL, "GLimp_Init: Pixel format could not be achieved\n");
+		return qfalse;
+	}
+	ri.Printf( PRINT_ALL, "Selected pixel format 0x%x\n", (int)sys_gl.fmt );
+	
+	aglDescribePixelFormat(sys_gl.fmt, AGL_RED_SIZE, &value);
+	glConfig.colorBits = value * 3;
+	aglDescribePixelFormat(sys_gl.fmt, AGL_STENCIL_SIZE, &value);
+	glConfig.stencilBits = value;
+	aglDescribePixelFormat(sys_gl.fmt, AGL_DEPTH_SIZE, &value);
+	glConfig.depthBits = value;
+
+	CheckErrors();
+	
+	/* Create context */
+	sys_gl.context = aglCreateContext(sys_gl.fmt, NULL);
+	if(!sys_gl.context) {
+		ri.Printf( PRINT_ALL, "GLimp_init: Context could not be created\n");
+		return qfalse;
+	}
+	
+	CheckErrors();
+	
+	/* Make context current */
+
+	if(!aglSetDrawable(sys_gl.context, sys_gl.drawable)) {
+		ri.Printf( PRINT_ALL, "GLimp_Init: Could not attach to context\n" );
+		return qfalse;
+	}
+	
+	CheckErrors();
+	
+	if( !aglSetCurrentContext(sys_gl.context) ) {
+		ri.Printf( PRINT_ALL, "GLimp_Init: Could not attach to context");
+		return qfalse;
+	}
+
+	CheckErrors();
+	
+	// check video memory and determine ragePro status
+#if 0
+	if ( !GLimp_SufficientVideoMemory() ) {
+		return qfalse;
+	}
+#endif
+	glConfig.hardwareType = sys_hardwareType;		// FIXME: this isn't really right
+	
+	// draw something to show that GL is alive	
+	qglClearColor( 1, 0.5, 0.2, 0 );
+	qglClear( GL_COLOR_BUFFER_BIT );
+	GLimp_EndFrame();
+
+	CheckErrors();
+
+	// get the extensions	
+	GLimp_Extensions();
+
+	CheckErrors();
+	
+	return qtrue;
+}
+
+
+
+/*
+===================
+GLimp_Init
+
+Don't return unless OpenGL has been properly initialized
+===================
+*/
+void GLimp_Init( void ) {
+	GLint		major, minor;
+	static		qboolean	registered;
+	
+	ri.Printf( PRINT_ALL, "--- GLimp_Init ---\n" );
+
+	aglGetVersion( &major, &minor );
+	ri.Printf( PRINT_ALL, "aglVersion: %i.%i\n", (int)major, (int)minor );
+	
+	r_device = ri.Cvar_Get( "r_device", "0", CVAR_LATCH | CVAR_ARCHIVE );
+	r_ext_transform_hint = ri.Cvar_Get( "r_ext_transform_hint", "1", CVAR_LATCH | CVAR_ARCHIVE );
+	
+	if ( !registered ) {
+		ri.Cmd_AddCommand( "aglDescribe", GLimp_AglDescribe_f );
+		ri.Cmd_AddCommand( "aglState", GLimp_AglState_f );
+	}
+	
+	memset( &glConfig, 0, sizeof( glConfig ) );
+
+
+	r_swapInterval->modified = qtrue;	// force a set next frame
+
+
+	glConfig.deviceSupportsGamma = qtrue;
+	
+	// FIXME: try for a voodoo first
+	sys_gl.systemGammas = GetSystemGammas();
+	
+	if ( GLimp_SetMode() ) {
+		ri.Printf( PRINT_ALL, "------------------\n" );
+		return;
+	}
+	
+	// fall back to the known-good mode
+	ri.Cvar_Set( "r_fullscreen", "1" );
+	ri.Cvar_Set( "r_mode", "3" );
+	ri.Cvar_Set( "r_stereo", "0" );
+	ri.Cvar_Set( "r_depthBits", "16" );
+	ri.Cvar_Set( "r_colorBits", "16" );
+	ri.Cvar_Set( "r_stencilBits", "0" );
+	if ( GLimp_SetMode() ) {
+		ri.Printf( PRINT_ALL, "------------------\n" );
+		return;
+	}
+
+	ri.Error( ERR_FATAL, "Could not initialize OpenGL" );
+}
+
+
+/*
+===============
+GLimp_EndFrame
+
+===============
+*/
+void GLimp_EndFrame( void ) {
+	// check for variable changes
+	if ( r_swapInterval->modified ) {
+		r_swapInterval->modified = qfalse;
+		ri.Printf( PRINT_ALL, "Changing AGL_SWAP_INTERVAL\n" );
+		aglSetInteger( sys_gl.context, AGL_SWAP_INTERVAL, (long *)&r_swapInterval->integer );
+	}
+
+	// make sure the event loop is pumped
+	Sys_SendKeyEvents();
+	
+	aglSwapBuffers( sys_gl.context );
+}
+
+/*
+===============
+GLimp_Shutdown
+
+===============
+*/
+void GLimp_Shutdown( void ) {	
+	if ( sys_gl.systemGammas ) {
+		RestoreSystemGammas( sys_gl.systemGammas );
+		DisposeSystemGammas( &sys_gl.systemGammas );
+		sys_gl.systemGammas = 0;
+	}
+	
+	if ( sys_gl.context ) {
+		aglDestroyContext(sys_gl.context);
+		sys_gl.context = 0;
+	}
+	if ( sys_gl.fmt ) {
+	    aglDestroyPixelFormat(sys_gl.fmt);
+		sys_gl.fmt = 0;
+	}
+	if ( sys_gl.drawable ) {
+		DisposeWindow((GrafPort *) sys_gl.drawable);
+		sys_gl.drawable = 0;
+	}
+	GLimp_ResetDisplay();
+	
+	memset( &glConfig, 0, sizeof( glConfig ) );
+}
+
+
+void		GLimp_LogComment( char *comment ) {
+}
+qboolean	GLimp_SpawnRenderThread( void (*function)( void ) ) {
+}
+void *GLimp_RendererSleep( void ) {
+
+}
+
+void GLimp_FrontEndSleep( void ) {
+
+}
+
+void GLimp_WakeRenderer( void * data ) {
+
+}
+
+
+
+/*
+===============
+GLimp_SetGamma
+
+===============
+*/
+void		GLimp_SetGamma( unsigned char red[256], 
+						    unsigned char green[256],
+							unsigned char blue[256] ) {
+	char	color[3][256];
+	int		i;
+
+	for ( i = 0 ; i < 256 ; i++ ) {
+		color[0][i] = red[i];
+		color[1][i] = green[i];
+		color[2][i] = blue[i];	
+	}
+	SetDeviceGammaRampGD( sys_gl.device, color[0] );
+}
+
diff --git a/code/mac/mac_input.c b/code/mac/mac_input.c
new file mode 100644
index 0000000..b9e3375
--- /dev/null
+++ b/code/mac/mac_input.c
@@ -0,0 +1,212 @@
+
+#include "../client/client.h"
+#include "mac_local.h"
+#include "InputSprocket.h"
+
+qboolean			inputActive;
+qboolean			inputSuspended;
+
+#define	MAX_DEVICES		100
+ISpDeviceReference	devices[MAX_DEVICES];
+ISpElementListReference	elementList;
+
+#define	MAX_ELEMENTS	512
+#define	MAX_MOUSE_DEVICES	2
+UInt32				numDevices;
+UInt32				numElements[MAX_MOUSE_DEVICES];
+ISpElementReference	elements[MAX_MOUSE_DEVICES][MAX_ELEMENTS];
+
+cvar_t				*in_nomouse;
+
+void Input_Init(void);
+void Input_GetState( void );
+
+/*
+=================
+Sys_InitInput
+=================
+*/
+void Sys_InitInput( void ) {
+	NumVersion		ver;
+	ISpElementInfo	info;
+	int				i, j;
+	OSStatus		err;
+	
+	// no input with dedicated servers
+	if ( com_dedicated->integer ) {
+		return;
+	}
+	
+	Com_Printf( "------- Input Initialization -------\n" );
+	in_nomouse = Cvar_Get( "in_nomouse", "0", 0 );
+	if ( in_nomouse->integer != 0 ) {
+		Com_Printf( "in_nomouse is set, skipping.\n" );
+		Com_Printf( "------------------------------------\n" );
+		return;
+	}
+	
+	ver = ISpGetVersion();
+	Com_Printf( "InputSprocket version: 0x%x\n", ver );
+		
+	err = ISpStartup();
+	if ( err ) {
+		Com_Printf( "ISpStartup failed: %i\n", err );
+		Com_Printf( "------------------------------------\n" );
+		return;
+	}
+
+	// disable everything
+	ISpDevices_Extract( MAX_DEVICES, &numDevices, devices );
+	Com_Printf("%i total devices\n", numDevices);
+	if (numDevices > MAX_DEVICES) {
+		numDevices = MAX_DEVICES;
+	}
+	err = ISpDevices_Deactivate(
+			numDevices,
+			devices);
+	
+	// enable mouse
+	err = ISpDevices_ExtractByClass(
+			kISpDeviceClass_Mouse,
+			MAX_DEVICES,
+			&numDevices,
+			devices);
+	Com_Printf("%i mouse devices\n", numDevices);
+	if (numDevices > MAX_MOUSE_DEVICES) {
+		numDevices = MAX_MOUSE_DEVICES;
+	}
+	
+	err = ISpDevices_Activate( numDevices, devices);
+	for ( i = 0 ; i < numDevices ; i++ ) {
+		ISpDevice_GetElementList( devices[i], &elementList );
+	
+//	ISpGetGlobalElementList( &elementList );
+	
+		// go through all the elements and asign them Quake key codes
+		ISpElementList_Extract( elementList, MAX_ELEMENTS, &numElements[i], elements[i] );
+		Com_Printf("%i elements in list\n", numElements[i] );
+		
+		for ( j = 0 ; j	< numElements[i] ; j++ ) {
+			ISpElement_GetInfo( elements[i][j], &info );
+			PStringToCString( (char *)info.theString );
+			Com_Printf( "%i : %s\n", i, info.theString );
+		}
+	}
+	
+	inputActive = true;
+
+	HideCursor();
+
+	Com_Printf( "------------------------------------\n" );
+}
+
+/*
+=================
+Sys_ShutdownInput
+=================
+*/
+void Sys_ShutdownInput( void ) {
+	if ( !inputActive ) {
+		return;
+	}
+	ShowCursor();
+	ISpShutdown();
+	inputActive = qfalse;
+}
+
+void Sys_SuspendInput( void ) {
+	if ( inputSuspended ) {
+		return;
+	}
+	inputSuspended = true;
+	ShowCursor();
+	ISpSuspend();
+}
+
+void Sys_ResumeInput( void ) {
+	if ( !inputSuspended ) {
+		return;
+	}
+	inputSuspended = false;
+	HideCursor();
+	ISpResume();
+}
+
+/*
+=================
+Sys_Input
+=================
+*/
+void Sys_Input( void ) {
+	ISpElementEvent		event;
+	Boolean				wasEvent;
+	UInt32				state, state2;
+	int					xmove, ymove;
+	int					button;
+	static int xtotal, ytotal;
+	int					device;
+	
+	if ( !inputActive ) {
+		return;
+	}
+
+	// during debugging it is sometimes usefull to be able to kill mouse support
+	if ( in_nomouse->integer ) {
+		Com_Printf( "Shutting down input.\n");
+		Sys_ShutdownInput();
+		return;
+	}
+	
+	// always suspend for dedicated 
+	if ( com_dedicated->integer ) {
+		Sys_SuspendInput();
+		return;
+	}
+	
+	// temporarily deactivate if not in the game and
+	if ( cls.keyCatchers || cls.state != CA_ACTIVE ) {
+		if ( !glConfig.isFullscreen ) {
+			Sys_SuspendInput();
+			return;
+		}
+	}
+
+	Sys_ResumeInput();
+
+	// send all button events
+	for ( device = 0 ; device < numDevices ; device++ ) {
+		// mouse buttons
+		
+		for ( button = 2 ; button < numElements[device] ; button++ ) {
+			while ( 1 ) {
+				ISpElement_GetNextEvent( elements[device][button], sizeof( event ), &event, &wasEvent );
+				if ( !wasEvent ) {
+					break;
+				}
+				if ( event.data ) {
+					Sys_QueEvent( 0, SE_KEY, K_MOUSE1 + button - 2, 1, 0, NULL );
+				} else {
+					Sys_QueEvent( 0, SE_KEY, K_MOUSE1 + button - 2, 0, 0, NULL );
+				}
+			}
+		}
+		
+		// mouse movement
+		
+#define	MAC_MOUSE_SCALE		163		// why this constant?
+		// send mouse event
+		ISpElement_GetSimpleState( elements[device][0], &state );
+		xmove = (int)state / MAC_MOUSE_SCALE;
+		
+		ISpElement_GetSimpleState( elements[device][1], &state2 );
+		ymove = (int)state2 / -MAC_MOUSE_SCALE;
+		
+		if ( xmove || ymove ) {
+			xtotal += xmove;
+			ytotal += ymove;
+	//Com_Printf("%i %i = %i %i\n", state, state2, xtotal, ytotal );
+			Sys_QueEvent( 0, SE_MOUSE, xmove, ymove, 0, NULL );
+		}
+	}
+	
+}
diff --git a/code/mac/mac_local.h b/code/mac/mac_local.h
new file mode 100644
index 0000000..da86397
--- /dev/null
+++ b/code/mac/mac_local.h
@@ -0,0 +1,321 @@
+
+/*
+ *	Apple Universal Headers 3.1
+ *
+ *	Uncomment any additional #includes you want to add to your MacHeaders.
+ */
+//#include <MacHeaders.h>
+
+
+//	#include <ADSP.h>
+//	#include <ADSPSecure.h>
+	#include <AEDataModel.h>
+	#include <AEObjects.h>
+	#include <AEPackObject.h>
+	#include <AERegistry.h>
+	#include <AEUserTermTypes.h>
+//	#include <AIFF.h>
+	#include <Aliases.h>
+	#include <Appearance.h>
+	#include <AppleEvents.h>
+	#include <AppleGuide.h>
+	#include <AppleScript.h>
+	#include <AppleTalk.h>
+	#include <ASDebugging.h>
+	#include <ASRegistry.h>
+//	#include <ATA.h>
+//	#include <AVComponents.h>
+	#include <Balloons.h>
+//	#include <CardServices.h>
+//	#include <CMAcceleration.h>
+	#include <CMApplication.h>
+//	#include <CMCalibrator.h>
+//	#include <CMComponent.h>
+//	#include <CMConversions.h>
+	#include <CMICCProfile.h>
+//	#include <CMMComponent.h>
+//	#include <CMPRComponent.h>
+//	#include <CMScriptingPlugin.h>
+	#include <CodeFragments.h>
+//	#include <Collections.h>
+	#include <ColorPicker.h>
+//	#include <ColorPickerComponents.h>
+//	#include <CommResources.h>
+	#include <Components.h>
+	#include <ConditionalMacros.h>
+//	#include <Connections.h>
+//	#include <ConnectionTools.h>
+	#include <Controls.h>
+//	#include <ControlStrip.h>
+//	#include <CRMSerialDevices.h>
+//	#include <CTBUtilities.h>
+//	#include <CursorDevices.h>
+//	#include <DatabaseAccess.h>
+	#include <DateTimeUtils.h>
+//	#include <Desk.h>
+//	#include <DeskBus.h>
+	#include <Devices.h>
+	#include <Dialogs.h>
+//	#include <Dictionary.h>
+//	#include <DigitalSignature.h>
+	#include <DiskInit.h>
+//	#include <Disks.h>
+	#include <Displays.h>
+	#include <Drag.h>
+//	#include <DrawSprocket.h>
+//	#include <DriverSynchronization.h>
+	#include <DriverFamilyMatching.h>
+//	#include <DriverGestalt.h>
+//	#include <DriverServices.h>
+//	#include <DriverSupport.h>
+//	#include <Editions.h>
+//	#include <Endian.h>
+//	#include <ENET.h>
+	#include <EPPC.h>
+	#include <Errors.h>
+	#include <Events.h>
+//	#include <fenv.h>
+	#include <Files.h>
+//	#include <FileTransfers.h>
+//	#include <FileTransferTools.h>
+	#include <FileTypesAndCreators.h>
+	#include <Finder.h>
+	#include <FinderRegistry.h>
+	#include <FixMath.h>
+	#include <Folders.h>
+	#include <Fonts.h>
+//	#include <fp.h>
+//	#include <FragLoad.h>
+//	#include <FSM.h>
+	#include <Gestalt.h>
+//	#include <GXEnvironment.h>
+//	#include <GXErrors.h>
+//	#include <GXFonts.h>
+//	#include <GXGraphics.h>
+//	#include <GXLayout.h>
+//	#include <GXMath.h>
+//	#include <GXMessages.h>
+//	#include <GXPrinterDrivers.h>
+//	#include <GXPrinting.h>
+//	#include <GXTypes.h>
+//	#include <GoggleSprocket.h>
+	#include <HFSVolumes.h>
+//	#include <HyperXCmd.h>
+	#include <Icons.h>
+//	#include <ImageCodec.h>
+	#include <ImageCompression.h>
+//	#include <InputSprocket.h>
+//	#include <Interrupts.h>
+	#include <IntlResources.h>
+//	#include <JManager.h>
+//	#include <Kernel.h>
+//	#include <Language.h>
+	#include <Lists.h>
+//	#include <LocationManager.h>
+//	#include <LocationManager.k.h>
+	#include <LowMem.h>
+//	#include <MachineExceptions.h>
+	#include <MacMemory.h>
+//	#include <MacTCP.h>
+	#include <MacTypes.h>
+	#include <MacWindows.h>
+//	#include <Math64.h>
+//	#include <MediaHandlers.h>
+	#include <Memory.h>						// Start using MacMemory.h
+	#include <Menus.h>
+//	#include <MIDI.h>
+	#include <MixedMode.h>
+	#include <Movies.h>
+//	#include <MoviesFormat.h>
+//	#include <MP.h>
+//	#include <Multiprocessing.h>
+	#include <NameRegistry.h>
+//	#include <NetSprocket.h>
+	#include <Notification.h>
+	#include <NumberFormatting.h>
+//	#include <OCE.h>
+//	#include <OCEAuthDir.h>
+//	#include <OCEErrors.h>
+//	#include <OCEMail.h>
+//	#include <OCEMessaging.h>
+//	#include <OCEStandardDirectory.h>
+//	#include <OCEStandardMail.h>
+//	#include <OCETemplates.h>
+	#include <OSA.h>
+	#include <OSAComp.h>
+	#include <OSAGeneric.h>
+	#include <OSUtils.h>
+//	#include <Packages.h>
+	#include <Palettes.h>
+	#include <Patches.h>
+//	#include <PCCardAdapterPlugin.h>
+//	#include <PCCardEnablerPlugin.h>
+//	#include <PCCardTuples.h>
+//	#include <PCI.h>
+//	#include <PEFBinaryFormat.h>
+//	#include <PCCard.h>
+//	#include <Picker.h>
+//	#include <PictUtil.h>
+//	#include <PictUtils.h>
+	#include <PLStringFuncs.h>
+//	#include <Power.h>
+	#include <PPCToolbox.h>
+	#include <Printing.h>
+	#include <Processes.h>
+//	#include <QD3DAcceleration.h>
+//	#include <QD3DCamera.h>
+//	#include <QD3DController.h>
+//	#include <QD3DCustomElements.h>
+//	#include <QD3DDrawContext.h>
+//	#include <QD3DErrors.h>
+//	#include <QD3DExtension.h>
+//	#include <QD3DGeometry.h>
+//	#include <QD3DGroup.h>
+//	#include <QD3DIO.h>
+//	#include <QD3DLight.h>
+//	#include <QD3DMath.h>
+//	#include <QD3DPick.h>
+//	#include <QD3DRenderer.h>
+//	#include <QD3DSet.h>
+//	#include <QD3DShader.h>
+//	#include <QD3DStorage.h>
+//	#include <QD3DString.h>
+//	#include <QD3DStyle.h>
+//	#include <QD3DTransform.h>
+//	#include <QD3DView.h>
+//	#include <QD3DViewer.h>
+//	#include <QD3DWinViewer.h>
+//	#include <QD3D.h>
+	#include <QDOffscreen.h>
+//	#include <QTML.h>
+//	#include <QTMLCustomElements.h>
+	#include <Quickdraw.h>
+	#include <QuickdrawText.h>
+//	#include <QuickTimeComponents.h>
+//	#include <QuickTimeVR.h>
+//	#include <QuickTimeVRFormat.h>
+//	#include <RAVE.h>
+//	#include <QuickTimeMusic.h>
+	#include <Resources.h>
+//	#include <Retrace.h>
+//	#include <ROMDefs.h>
+//	#include <ScalerTypes.h>
+//	#include <ScalerStreamTypes.h>
+	#include <Scrap.h>
+	#include <Script.h>
+//	#include <SCSI.h>
+	#include <SegLoad.h>
+//	#include <Serial.h>
+//	#include <SFNTTypes.h>
+//	#include <SFNTLayoutTypes.h>
+//	#include <ShutDown.h>
+//	#include <SIOW.h>
+//	#include <Slots.h>
+//	#include <SocketServices.h>
+	#include <Sound.h>
+//	#include <SoundComponents.h>
+//	#include <SoundInput.h>
+//	#include <SoundSprocket.h>
+//	#include <Speech.h>
+//	#include <SpeechRecognition.h>
+//	#include <SpeechSynthesis.h>
+	#include <StandardFile.h>
+	#include <StringCompare.h>
+//	#include <Start.h>
+	#include <Strings.h>				// Start using TextUtils.h
+//	#include <Telephones.h>
+//	#include <Terminals.h>
+//	#include <TerminalTools.h>
+	#include <TextCommon.h>
+	#include <TextEdit.h>
+//	#include <TextEncodingConverter.h>
+//	#include <TextServices.h>
+	#include <TextUtils.h>
+	#include <Threads.h>
+	#include <Timer.h>
+	#include <ToolUtils.h>
+//	#include <Translation.h>
+//	#include <TranslationExtensions.h>
+	#include <Traps.h>
+//	#include <TSMTE.h>
+	#include <Types.h>					// Start using MacTypes.h
+//	#include <Unicode.h>
+//	#include <UnicodeConverter.h>
+	#include <Video.h>
+//	#include <VideoServices.h>
+	#include <Windows.h>				// Start using MacWindows.h
+//	#include <WorldScript.h>
+//	#include <ZoomedVideo.h>
+
+
+
+
+#include <gl.h>
+#include <agl.h>
+#include <console.h>
+#include <SIOUX.h>
+#include <math.h>
+#include <time.h>
+#include <errno.h>
+#include <Profiler.h>
+
+/* Menus: */
+	#define rMenuBar	128
+	/* Apple menu: */
+		#define mApple	128
+		#define	iAbout	1
+	/* File menu: */
+		#define mFile	129
+		#define iQuit	1
+	/* Edit menu: */
+		#define mEdit	130
+		#define	iUndo	1
+		#define iCut	3
+		#define	iCopy	4
+		#define iPaste	5
+		#define iClear	6
+/* Windows: */
+	#define kMainWindow		128
+	#define kFullScreenWindow		129
+/* Dilogs: */
+	#define kAboutDialog	128
+
+
+// mac_main.c
+extern	int		sys_ticBase;
+extern	int		sys_msecBase;
+extern	int		sys_lastEventTic;
+
+extern	cvar_t	*sys_waitNextEvent;
+
+void Sys_QueEvent( int time, sysEventType_t type, int value, int value2, int ptrLength, void *ptr );
+int PStringToCString( char *s );
+int CStringToPString( char *s );
+
+// mac_event.c
+extern	int	vkeyToQuakeKey[256];
+void Sys_SendKeyEvents (void);
+
+// mac_net.c
+void Sys_InitNetworking( void );
+void Sys_ShutdownNetworking( void );
+
+// mac_input.c
+void Sys_InitInput( void );
+void Sys_ShutdownInput( void );
+void Sys_Input( void );
+
+extern	qboolean			inputActive;
+
+// mac_glimp.c
+extern glconfig_t glConfig;
+
+// mac_console.c
+
+void	Sys_InitConsole( void );
+void	Sys_ShowConsole( int level, qboolean quitOnClose );
+void	Sys_Print( const char *text );
+char	*Sys_ConsoleInput( void );
+qboolean Sys_ConsoleEvent( EventRecord *event );
+
+
diff --git a/code/mac/mac_main.c b/code/mac/mac_main.c
new file mode 100644
index 0000000..a195b48
--- /dev/null
+++ b/code/mac/mac_main.c
@@ -0,0 +1,693 @@
+#include "../client/client.h"
+#include "mac_local.h"
+#include <DriverServices.h>
+#include <console.h>
+
+/*
+
+TODO:
+
+about box
+dir with no extension gives strange results
+console input?
+dedicated servers
+icons
+dynamic loading of server game
+clipboard pasting
+
+quit from menu
+
+*/
+
+int		sys_ticBase;
+int		sys_msecBase;
+int		sys_lastEventTic;
+
+cvar_t	*sys_profile;
+cvar_t	*sys_waitNextEvent;
+
+void putenv( char *buffer ) {
+	// the mac doesn't seem to have the concept of environment vars, so nop this
+}
+
+//===========================================================================
+
+void	Sys_UnloadGame (void) {
+}
+void	*Sys_GetGameAPI (void *parms) {
+    void *GetGameAPI (void *import);
+    // we are hard-linked in, so no need to load anything
+    return GetGameAPI (parms);
+}
+
+void	Sys_UnloadUI (void) {
+}
+void	*Sys_GetUIAPI (void) {
+    void *GetUIAPI (void);
+    // we are hard-linked in, so no need to load anything
+    return GetUIAPI ();
+}
+
+void Sys_UnloadBotLib( void ) {
+}
+
+void *Sys_GetBotLibAPI (void *parms) {
+	return NULL;
+}
+
+void *Sys_GetBotAIAPI (void *parms) {
+	return NULL;
+}
+
+void dllEntry( int (*syscallptr)( int arg,... ) );
+int vmMain( int command, ... );
+
+void *Sys_LoadDll( const char *name, int (**entryPoint)(int, ...),
+	int (*systemCalls)(int, ...) ) {
+	
+	dllEntry( systemCalls );
+	
+	*entryPoint = vmMain;
+	
+	return (void *)1;
+}
+
+void Sys_UnloadDll( void *dllHandle ) {
+}
+
+//===========================================================================
+
+char *Sys_GetClipboardData( void ) {	// FIXME
+    return NULL;
+}
+
+int Sys_GetProcessorId( void ) {
+    return CPUID_GENERIC;
+}
+
+void Sys_Mkdir( const char *path ) {
+	char	ospath[MAX_OSPATH];
+	int		err;
+	
+	Com_sprintf( ospath, sizeof(ospath), "%s:", path );
+	
+	err = mkdir( ospath, 0777 );
+}
+
+char *Sys_Cwd( void ) {
+	static char dir[MAX_OSPATH];
+	int			l;
+	
+	getcwd( dir, sizeof( dir ) );
+	dir[MAX_OSPATH-1] = 0;
+	
+	// strip off the last colon
+	l = strlen( dir );
+	if ( l > 0 ) {
+		dir[ l - 1 ] = 0;
+	} 
+	return dir;
+}
+
+char *Sys_DefaultCDPath( void ) {
+	return "";
+}
+
+char *Sys_DefaultBasePath( void ) {
+	return Sys_Cwd();
+}
+
+/*
+ =================================================================================
+
+ FILE FINDING
+ 
+ =================================================================================
+*/
+
+int PStringToCString( char *s ) {
+	int		l;
+	int		i;
+	
+	l = ((unsigned char *)s)[0];
+	for ( i = 0 ; i < l ; i++ ) {
+		s[i] = s[i+1];
+	}
+	s[l] = 0;
+	return l;
+}
+
+
+int CStringToPString( char *s ) {
+	int		l;
+	int		i;
+	
+	l = strlen( s );
+	for ( i = 0 ; i < l ; i++ ) {
+		s[l-i] = s[l-i-1];
+	}
+	s[0] = l;
+	return l;
+}
+
+#define	MAX_FOUND_FILES	0x1000
+
+char **Sys_ListFiles( const char *directory, const char *extension, int *numfiles, qboolean wantsubs ) {
+	int			nfiles;
+	char		**listCopy;
+	char		pdirectory[MAX_OSPATH];
+	char		*list[MAX_FOUND_FILES];
+	int			findhandle;
+	int			directoryFlag;
+	int			i;
+	int			extensionLength;
+	int			VRefNum;
+	int			DrDirId;
+	int			index;
+	FSSpec		fsspec;
+	
+	// get the volume and directory numbers 
+	// there has to be a better way than this...
+	{
+		CInfoPBRec	paramBlock;
+
+		Q_strncpyz( pdirectory, directory, sizeof(pdirectory) );
+		CStringToPString( pdirectory );
+		FSMakeFSSpec( 0, 0, (unsigned char *)pdirectory, &fsspec );
+		
+		VRefNum = fsspec.vRefNum;
+
+		memset( &paramBlock, 0, sizeof( paramBlock ) );
+		paramBlock.hFileInfo.ioNamePtr = (unsigned char *)pdirectory;		
+		PBGetCatInfoSync( &paramBlock );
+
+		DrDirId = paramBlock.hFileInfo.ioDirID;
+	}	
+
+	if ( !extension) {
+		extension = "";
+	}
+	extensionLength = strlen( extension );
+
+	if ( wantsubs || (extension[0] == '/' && extension[1] == 0) ) {
+		directoryFlag = 16;
+	} else {
+		directoryFlag = 0;
+	}
+
+	nfiles = 0;
+	
+	for ( index = 1 ; ; index++ ) {
+		CInfoPBRec	paramBlock;
+		char		fileName[MAX_OSPATH];
+		int			length;
+		OSErr		err;
+		
+		memset( &paramBlock, 0, sizeof( paramBlock ) );
+		paramBlock.hFileInfo.ioNamePtr = (unsigned char *)fileName;
+		paramBlock.hFileInfo.ioVRefNum = VRefNum;
+		paramBlock.hFileInfo.ioFDirIndex = index;
+		paramBlock.hFileInfo.ioDirID = DrDirId;
+		
+		err = PBGetCatInfoSync( &paramBlock );
+		
+		if ( err != noErr ) {
+			break;
+		}
+
+		if ( directoryFlag ^ ( paramBlock.hFileInfo.ioFlAttrib & 16 ) ) {
+			continue;
+		}
+		
+		// convert filename to C string
+		length = PStringToCString( fileName );
+
+		// check the extension		
+		if ( !directoryFlag ) {			
+			if ( length < extensionLength ) {
+				continue;
+			}
+			if ( Q_stricmp( fileName + length - extensionLength, extension ) ) {
+				continue;
+			} 
+		}
+		
+		// add this file
+		if ( nfiles == MAX_FOUND_FILES - 1 ) {
+			break;
+		}
+		list[ nfiles ] = CopyString( fileName );
+		nfiles++;		
+	}	
+
+	list[ nfiles ] = 0;
+
+
+	// return a copy of the list
+	*numfiles = nfiles;
+
+	if ( !nfiles ) {
+		return NULL;
+	}
+
+	listCopy = Z_Malloc( ( nfiles + 1 ) * sizeof( *listCopy ) );
+	for ( i = 0 ; i < nfiles ; i++ ) {
+		listCopy[i] = list[i];
+	}
+	listCopy[i] = NULL;
+
+	return listCopy;
+}
+
+void	Sys_FreeFileList( char **list ) {
+	int		i;
+
+	if ( !list ) {
+		return;
+	}
+
+	for ( i = 0 ; list[i] ; i++ ) {
+		Z_Free( list[i] );
+	}
+
+	Z_Free( list );
+}
+
+
+//===================================================================
+
+
+/*
+================
+Sys_Init
+
+The cvar and file system has been setup, so configurations are loaded
+================
+*/
+void Sys_Init(void) {
+	Sys_InitNetworking();
+	Sys_InitInput();	
+}
+
+/*
+=================
+Sys_Shutdown
+=================
+*/
+void Sys_Shutdown( void ) {
+	Sys_EndProfiling();
+	Sys_ShutdownInput();	
+	Sys_ShutdownNetworking();
+}
+
+
+/*
+=================
+Sys_BeginProfiling
+=================
+*/
+static qboolean sys_profiling;
+void Sys_BeginProfiling( void ) {
+	if ( !sys_profile->integer ) {
+		return;
+	}
+	ProfilerInit(collectDetailed, bestTimeBase, 16384, 64);
+	sys_profiling = qtrue;
+}
+
+/*
+=================
+Sys_EndProfiling
+=================
+*/
+void Sys_EndProfiling( void ) {
+	unsigned char	pstring[1024];
+	
+	if ( !sys_profiling ) {
+		return;
+	}
+	sys_profiling = qfalse;
+	
+	sprintf( (char *)pstring + 1, "%s:profile.txt", Cvar_VariableString( "fs_basepath" ) );
+	pstring[0] = strlen( (char *)pstring + 1 );
+	ProfilerDump( pstring );
+	ProfilerTerm();
+}
+
+//================================================================================
+
+
+/*
+================
+Sys_Milliseconds
+================
+*/
+int Sys_Milliseconds (void) {
+#if 0
+	int		c;
+	
+	c = clock();		// FIXME, make more accurate
+
+	return c*1000/60;
+#else
+	AbsoluteTime	t;
+	Nanoseconds		nano;
+	double			doub;
+
+#define kTwoPower32 (4294967296.0)      /* 2^32 */
+	
+	t = UpTime();
+	nano = AbsoluteToNanoseconds( t );
+	doub = (((double) nano.hi) * kTwoPower32) + nano.lo;
+	
+	return doub * 0.000001;	
+#endif
+}
+
+/*
+================
+Sys_Error
+================
+*/
+void Sys_Error( const char *error, ... ) {
+	va_list		argptr;
+	char		string[1024];
+	char		string2[1024];
+
+	Sys_Shutdown();
+
+	va_start (argptr,error);
+	vsprintf (string2+1,error,argptr);
+	va_end (argptr);
+	string2[0] = strlen( string2 + 1 );
+	
+	strcpy( string+1, "Quake 3 Error:" );
+	string[0] = strlen( string + 1 );
+	
+	// set the dialog box strings
+	ParamText( (unsigned char *)string, (unsigned char *)string2, 
+	(unsigned char *)string2, (unsigned char *)string2 );
+
+	// run a dialog
+	StopAlert( 128, NULL );
+	
+	exit(0);	
+}
+
+
+/*
+================
+Sys_Quit
+================
+*/
+void Sys_Quit( void ) {
+	Sys_Shutdown();
+	exit (0);
+}
+
+
+//===================================================================
+
+void Sys_BeginStreamedFile( fileHandle_t f, int readAhead ) {
+}
+
+void Sys_EndStreamedFile( fileHandle_t f ) {
+}
+
+int Sys_StreamedRead( void *buffer, int size, int count, fileHandle_t f ) {
+   return FS_Read( buffer, size, count, f );
+}
+
+void Sys_StreamSeek( fileHandle_t f, int offset, int origin ) {
+   FS_Seek( f, offset, origin );
+}
+
+//=================================================================================
+
+
+/*
+========================================================================
+
+EVENT LOOP
+
+========================================================================
+*/
+
+qboolean	Sys_GetPacket ( netadr_t *net_from, msg_t *net_message );
+
+#define	MAX_QUED_EVENTS		256
+#define	MASK_QUED_EVENTS	( MAX_QUED_EVENTS - 1 )
+
+sysEvent_t	eventQue[MAX_QUED_EVENTS];
+int			eventHead, eventTail;
+byte		sys_packetReceived[MAX_MSGLEN];
+
+/*
+================
+Sys_QueEvent
+
+A time of 0 will get the current time
+Ptr should either be null, or point to a block of data that can
+be freed by the game later.
+================
+*/
+void Sys_QueEvent( int time, sysEventType_t type, int value, int value2, int ptrLength, void *ptr ) {
+   sysEvent_t	*ev;
+
+   ev = &eventQue[ eventHead & MASK_QUED_EVENTS ];
+	if ( eventHead - eventTail >= MAX_QUED_EVENTS ) {
+		Com_Printf("Sys_QueEvent: overflow\n");
+		// we are discarding an event, but don't leak memory
+		if ( ev->evPtr ) {
+			free( ev->evPtr );
+		}
+		eventTail++;
+	}
+   eventHead++;
+
+   if ( time == 0 ) {
+       time = Sys_Milliseconds();
+   }
+
+   ev->evTime = time;
+   ev->evType = type;
+   ev->evValue = value;
+   ev->evValue2 = value2;
+   ev->evPtrLength = ptrLength;
+   ev->evPtr = ptr;
+}
+
+/*
+=================
+Sys_PumpEvents
+=================
+*/
+void Sys_PumpEvents( void ) {
+	char		*s;
+	msg_t		netmsg;
+	netadr_t	adr;
+
+   // pump the message loop
+	Sys_SendKeyEvents();
+   
+   // check for console commands
+   s = Sys_ConsoleInput();
+   if ( s ) {
+       char	*b;
+       int		len;
+
+       len = strlen( s ) + 1;
+       b = malloc( len );
+	   if ( !b ) {
+		   Com_Error( ERR_FATAL, "malloc failed in Sys_PumpEvents" );
+	   }
+       strcpy( b, s );
+       Sys_QueEvent( 0, SE_CONSOLE, 0, 0, len, b );
+   }
+
+   // check for other input devices
+   Sys_Input();
+
+   // check for network packets
+   MSG_Init( &netmsg, sys_packetReceived, sizeof( sys_packetReceived ) );
+   if ( Sys_GetPacket ( &adr, &netmsg ) ) {
+       netadr_t		*buf;
+       int				len;
+
+       // copy out to a seperate buffer for qeueing
+       len = sizeof( netadr_t ) + netmsg.cursize;
+       buf = malloc( len );
+	   if ( !buf ) {
+		   Com_Error( ERR_FATAL, "malloc failed in Sys_PumpEvents" );
+	   }
+       *buf = adr;
+       memcpy( buf+1, netmsg.data, netmsg.cursize );
+       Sys_QueEvent( 0, SE_PACKET, 0, 0, len, buf );
+   }
+}
+
+/*
+================
+Sys_GetEvent
+
+================
+*/
+sysEvent_t Sys_GetEvent( void ) {
+	sysEvent_t	ev;
+
+	if ( eventHead == eventTail ) {
+		Sys_PumpEvents();
+	}
+	// return if we have data
+	if ( eventHead > eventTail ) {
+	   eventTail++;
+	   return eventQue[ ( eventTail - 1 ) & MASK_QUED_EVENTS ];
+	}
+
+	// create an empty event to return
+	memset( &ev, 0, sizeof( ev ) );
+	ev.evTime = Sys_Milliseconds();
+
+	// track the mac event "when" to milliseconds rate
+	sys_ticBase = sys_lastEventTic;
+	sys_msecBase = ev.evTime;
+	
+	return ev;
+}
+
+
+/*
+=============
+InitMacStuff
+=============
+*/
+void InitMacStuff( void ) {
+	Handle 		menuBar;
+	char		dir[MAX_OSPATH];
+	
+	// init toolbox
+	MaxApplZone();
+	MoreMasters();
+	
+	InitGraf(&qd.thePort);
+	InitFonts();
+	FlushEvents(everyEvent, 0);
+	SetEventMask( -1 );
+	InitWindows();
+	InitMenus();
+	TEInit();
+	InitDialogs(nil);
+	InitCursor();
+
+	// init menu
+	menuBar = GetNewMBar(rMenuBar);
+	if(!menuBar) {
+		Com_Error( ERR_FATAL, "MenuBar not found.");
+	}
+	
+	SetMenuBar(menuBar);
+	DisposeHandle(menuBar);
+	AppendResMenu(GetMenuHandle(mApple),'DRVR');
+	DrawMenuBar();
+
+	Sys_InitConsole();
+
+	SetEventMask( -1 );
+}
+
+//==================================================================================
+
+/*
+=============
+ReadCommandLineParms
+
+Read startup options from a text file or dialog box
+=============
+*/
+char *ReadCommandLineParms( void ) {
+	FILE	*f;
+	int		len;
+	char	*buf;
+	EventRecord	   event;
+	
+	// flush out all the events and see if shift is held down
+	// to bring up the args window
+	while ( WaitNextEvent(everyEvent, &event, 0, nil) ) {
+	}
+	if ( event.modifiers & 512 ) {
+		static char	text[1024];
+		int		argc;
+		char	**argv;
+		int		i;
+		
+		argc = ccommand( &argv );
+		text[0] = 0;
+		// concat all the args into a string
+		// quote each arg seperately, because metrowerks does
+		// its own quote combining from the dialog
+		for ( i = 1 ; i < argc ; i++ ) {
+			if ( argv[i][0] != '+' ) {
+				Q_strcat( text, sizeof(text), "\"" );
+			}
+			Q_strcat( text, sizeof(text), argv[i] );
+			if ( argv[i][0] != '+' ) {
+				Q_strcat( text, sizeof(text), "\"" );
+			}
+			Q_strcat( text, sizeof(text), " " );
+		}		
+		return text;
+	}
+	
+	// otherwise check for a parms file
+	f = fopen( "MacQuake3Parms.txt", "r" );
+	if ( !f ) {
+		return "";
+	}
+	len = FS_filelength( f );
+	buf = malloc( len + 1 );
+	if ( !buf ) {
+		exit( 1 );
+	}
+	buf[len] = 0;
+	fread( buf, len, 1, f );
+	fclose( f );
+
+	return buf;
+}
+
+/*
+=============
+main
+=============
+*/
+void main( void ) {
+	char	*commandLine;
+		
+	InitMacStuff();
+	
+	commandLine = ReadCommandLineParms( );
+	
+    Com_Init ( commandLine );
+
+	sys_profile = Cvar_Get( "sys_profile", "0", 0 );
+	sys_profile->modified = qfalse;
+	
+	sys_waitNextEvent = Cvar_Get( "sys_waitNextEvent", "0", 0 );
+
+    while( 1 ) {
+        // run the frame
+        Com_Frame();
+        
+        if ( sys_profile->modified ) {
+        	sys_profile->modified = qfalse;
+        	if ( sys_profile->integer ) {
+        		Com_Printf( "Beginning profile.\n" );
+				Sys_BeginProfiling() ;
+			} else {
+				Com_Printf( "Ending profile.\n" );
+				Sys_EndProfiling();
+        	}
+        }
+    }
+}
+
diff --git a/code/mac/mac_net.c b/code/mac/mac_net.c
new file mode 100644
index 0000000..798c878
--- /dev/null
+++ b/code/mac/mac_net.c
@@ -0,0 +1,527 @@
+#include "../client/client.h"
+#include "mac_local.h"
+#include <OpenTransport.h>
+#include <OpenTptInternet.h>
+
+static qboolean	gOTInited;
+static EndpointRef endpoint = kOTInvalidEndpointRef;
+static EndpointRef resolverEndpoint = kOTInvalidEndpointRef;
+
+#define	MAX_IPS		16
+static	int		numIP;
+static	InetInterfaceInfo	sys_inetInfo[MAX_IPS];
+
+static	TUDErr	uderr;
+
+void RcvUDErr( void ) {
+	memset( &uderr, 0, sizeof( uderr ) );
+	uderr.addr.maxlen = 0;
+	uderr.opt.maxlen = 0;
+	OTRcvUDErr( endpoint, &uderr );
+}
+
+void HandleOTError( int err, const char *func ) {
+	int		r;
+	static int lastErr;
+
+	if ( err != lastErr ) {
+		Com_Printf( "%s: error %i\n", func, err );
+	}
+	
+	// if we don't call OTLook, things wedge
+	r = OTLook( endpoint );
+	if ( err != lastErr ) {
+		Com_DPrintf( "%s: OTLook %i\n", func, r );
+	}
+
+	switch( r ) {
+	case T_UDERR:
+		RcvUDErr();
+		if ( err != lastErr ) {
+			Com_DPrintf( "%s: OTRcvUDErr %i\n", func, uderr.error );				
+		}
+		break;
+	default:
+//		Com_Printf( "%s: Unknown OTLook error %i\n", func, r );				
+		break;
+	}
+	lastErr = err;	// don't spew tons of messages
+}
+
+/*
+=================
+NotifyProc
+=================
+*/
+pascal void NotifyProc(void* contextPtr, OTEventCode code, 
+									   OTResult result, void* cookie) {
+	switch( code ) {
+	case T_OPENCOMPLETE:
+		endpoint = cookie;
+		break;
+	case T_UDERR:
+		RcvUDErr();
+		break;
+	}
+}
+
+
+/*
+=================
+GetFourByteOption
+=================
+*/
+static OTResult GetFourByteOption(EndpointRef ep,
+                           OTXTILevel level,
+                           OTXTIName  name,
+                           UInt32   *value)
+{
+   OTResult err;
+   TOption  option;
+   TOptMgmt request;
+   TOptMgmt result;
+   
+   /* Set up the option buffer */
+   option.len  = kOTFourByteOptionSize;
+   option.level= level;
+   option.name = name;
+   option.status = 0;
+   option.value[0] = 0;// Ignored because we're getting the value.
+
+   /* Set up the request parameter for OTOptionManagement to point
+    to the option buffer we just filled out */
+
+   request.opt.buf= (UInt8 *) &option;
+   request.opt.len= sizeof(option);
+   request.flags= T_CURRENT;
+
+   /* Set up the reply parameter for OTOptionManagement. */
+   result.opt.buf  = (UInt8 *) &option;
+   result.opt.maxlen = sizeof(option);
+   
+   err = OTOptionManagement(ep, &request, &result);
+
+   if (err == noErr) {
+      switch (option.status) 
+      {
+         case T_SUCCESS:
+         case T_READONLY:
+            *value = option.value[0];
+            break;
+         default:
+            err = option.status;
+            break;
+      }
+   }
+            
+   return (err);
+}
+
+
+/*
+=================
+SetFourByteOption
+=================
+*/
+static OTResult SetFourByteOption(EndpointRef ep,
+                           OTXTILevel level,
+                           OTXTIName  name,
+                           UInt32   value)
+{
+   OTResult err;
+   TOption  option;
+   TOptMgmt request;
+   TOptMgmt result;
+   
+   /* Set up the option buffer to specify the option and value to
+         set. */
+   option.len  = kOTFourByteOptionSize;
+   option.level= level;
+   option.name = name;
+   option.status = 0;
+   option.value[0] = value;
+
+   /* Set up request parameter for OTOptionManagement */
+   request.opt.buf= (UInt8 *) &option;
+   request.opt.len= sizeof(option);
+   request.flags  = T_NEGOTIATE;
+
+   /* Set up reply parameter for OTOptionManagement. */
+   result.opt.buf  = (UInt8 *) &option;
+   result.opt.maxlen  = sizeof(option);
+
+   
+   err = OTOptionManagement(ep, &request, &result);
+
+   if (err == noErr) {
+      if (option.status != T_SUCCESS) 
+         err = option.status;
+   }
+            
+   return (err);
+}
+
+
+/*
+=====================
+NET_GetLocalAddress
+=====================
+*/
+void NET_GetLocalAddress( void ) {
+	OSStatus		err;
+
+	for ( numIP = 0 ; numIP < MAX_IPS ; numIP++ ) {
+		err = OTInetGetInterfaceInfo( &sys_inetInfo[ numIP ], numIP );
+		if ( err ) {
+			break;
+		}
+		Com_Printf( "LocalAddress: %i.%i.%i.%i\n",
+			((byte *)&sys_inetInfo[numIP].fAddress)[0],		
+			((byte *)&sys_inetInfo[numIP].fAddress)[1],		
+			((byte *)&sys_inetInfo[numIP].fAddress)[2],		
+			((byte *)&sys_inetInfo[numIP].fAddress)[3] );		
+
+		Com_Printf( "Netmask: %i.%i.%i.%i\n",
+			((byte *)&sys_inetInfo[numIP].fNetmask)[0],		
+			((byte *)&sys_inetInfo[numIP].fNetmask)[1],		
+			((byte *)&sys_inetInfo[numIP].fNetmask)[2],		
+			((byte *)&sys_inetInfo[numIP].fNetmask)[3] );		
+	}
+}
+
+
+/*
+==================
+Sys_InitNetworking
+
+
+struct InetAddress
+{
+		OTAddressType	fAddressType;	// always AF_INET
+		InetPort		fPort;			// Port number 
+		InetHost		fHost;			// Host address in net byte order
+		UInt8			fUnused[8];		// Traditional unused bytes
+};
+typedef struct InetAddress InetAddress;
+
+==================
+*/
+void Sys_InitNetworking( void ) {
+	OSStatus		err;
+	OTConfiguration *config;
+	TBind			bind, bindOut;
+	InetAddress		in, out;
+	int				i;
+
+	Com_Printf( "----- Sys_InitNetworking -----\n" );
+	// init OpenTransport	
+	Com_Printf( "... InitOpenTransport()\n" );
+	err = InitOpenTransport();
+	if ( err != noErr ) {
+		Com_Printf( "InitOpenTransport() failed\n" );
+		Com_Printf( "------------------------------\n" );
+		return;
+	}
+	
+  	gOTInited = true;
+
+	// get an endpoint
+	Com_Printf( "... OTOpenEndpoint()\n" );
+	config = OTCreateConfiguration( kUDPName );
+
+#if 1
+	endpoint = OTOpenEndpoint( config, 0, nil, &err); 
+#else
+	err = OTAsyncOpenEndpoint( config, 0, 0, NotifyProc, 0 );
+	if ( !endpoint ) {
+		err = 1;
+	}
+#endif
+
+	if ( err != noErr ) {
+		endpoint = 0;
+		Com_Printf( "OTOpenEndpoint() failed\n" );
+		Com_Printf( "------------------------------\n" );
+		return;
+	}
+
+	// set non-blocking	
+	err = OTSetNonBlocking( endpoint );
+ 
+	// scan for a valid port in our range
+	Com_Printf( "... OTBind()\n" );
+	for ( i = 0 ; i < 10 ; i++ ) {
+		in.fAddressType = AF_INET;
+		in.fPort = PORT_SERVER + i;
+		in.fHost = 0;
+
+		bind.addr.maxlen = sizeof( in );
+		bind.addr.len = sizeof( in );
+		bind.addr.buf = (unsigned char *)&in;
+		bind.qlen = 0;
+		
+		bindOut.addr.maxlen = sizeof( out );
+		bindOut.addr.len = sizeof( out );
+		bindOut.addr.buf = (unsigned char *)&out;
+		bindOut.qlen = 0;
+		
+		err = OTBind( endpoint, &bind, &bindOut );
+		if ( err == noErr ) {
+			Com_Printf( "Opened UDP endpoint at port %i\n",
+				out.fPort );
+			break;
+		}
+	}
+
+	if ( err != noErr ) {
+		Com_Printf( "Couldn't bind a local port\n" );
+	}
+
+	// get the local address for LAN client detection
+	NET_GetLocalAddress();
+
+
+	// set to allow broadcasts
+	err = SetFourByteOption( endpoint, INET_IP, IP_BROADCAST, T_YES );
+
+	if ( err != noErr ) {
+		Com_Printf( "IP_BROADCAST failed\n" );
+	}
+	
+	// get an endpoint just for resolving addresses, because
+	// I was having crashing problems doing it on the same endpoint
+	config = OTCreateConfiguration( kUDPName );
+	resolverEndpoint = OTOpenEndpoint( config, 0, nil, &err); 
+	if ( err != noErr ) {
+		resolverEndpoint = 0;
+		Com_Printf( "OTOpenEndpoint() for resolver failed\n" );
+		Com_Printf( "------------------------------\n" );
+		return;
+	}
+
+	in.fAddressType = AF_INET;
+	in.fPort = 0;
+	in.fHost = 0;
+
+	bind.addr.maxlen = sizeof( in );
+	bind.addr.len = sizeof( in );
+	bind.addr.buf = (unsigned char *)&in;
+	bind.qlen = 0;
+	
+	bindOut.addr.maxlen = sizeof( out );
+	bindOut.addr.len = sizeof( out );
+	bindOut.addr.buf = (unsigned char *)&out;
+	bindOut.qlen = 0;
+	
+	err = OTBind( resolverEndpoint, &bind, &bindOut );
+		
+	Com_Printf( "------------------------------\n" );
+}
+
+
+/*
+==================
+Sys_ShutdownNetworking
+==================
+*/
+void Sys_ShutdownNetworking( void ) {
+	Com_Printf( "Sys_ShutdownNetworking();\n" );
+
+	if ( endpoint != kOTInvalidEndpointRef ) {
+		OTUnbind( endpoint );
+		OTCloseProvider( endpoint );
+		endpoint = kOTInvalidEndpointRef;
+	}
+	if ( resolverEndpoint != kOTInvalidEndpointRef ) {
+		OTUnbind( resolverEndpoint );
+		OTCloseProvider( resolverEndpoint );
+		resolverEndpoint = kOTInvalidEndpointRef;
+	}
+	if (gOTInited) {
+		CloseOpenTransport();
+		gOTInited = false;
+	}
+}
+
+/*
+=============
+Sys_StringToAdr
+
+
+Does NOT parse port numbers
+
+
+idnewt
+192.246.40.70
+=============
+*/
+qboolean	Sys_StringToAdr( const char *s, netadr_t *a ) {
+	OSStatus	err;
+	TBind		in, out;
+	InetAddress	inAddr;
+	DNSAddress	dnsAddr;
+
+	if ( !resolverEndpoint ) {
+		return qfalse;
+	}
+
+	memset( &in, 0, sizeof( in ) );
+	in.addr.buf = (UInt8 *) &dnsAddr;
+	in.addr.len = OTInitDNSAddress(&dnsAddr, (char *)s );
+	in.qlen = 0;
+	
+	memset( &out, 0, sizeof( out ) );
+	out.addr.buf = (byte *)&inAddr;
+	out.addr.maxlen = sizeof( inAddr );
+	out.qlen = 0;
+	                           
+	err = OTResolveAddress( resolverEndpoint, &in, &out, 10000 );
+	if ( err ) {
+		HandleOTError( err, "Sys_StringToAdr" );
+		return qfalse;
+	}
+	
+	a->type = NA_IP;
+	*(int *)a->ip = inAddr.fHost;
+
+	return qtrue;
+}
+
+/*
+==================
+Sys_SendPacket
+==================
+*/
+#define	MAX_PACKETLEN	1400
+void Sys_SendPacket( int length, const void *data, netadr_t to ) {
+	TUnitData	d;
+	InetAddress	inAddr;
+	OSStatus	err;
+
+	if ( !endpoint ) {
+		return;
+	}
+
+	if ( length > MAX_PACKETLEN ) {
+		Com_Error( ERR_DROP, "Sys_SendPacket: length > MAX_PACKETLEN" );
+	}
+
+	inAddr.fAddressType = AF_INET;
+	inAddr.fPort = to.port;	
+	if ( to.type == NA_BROADCAST ) {
+		inAddr.fHost = -1;
+	} else {
+		inAddr.fHost = *(int *)&to.ip;
+	}
+	
+	memset( &d, 0, sizeof( d ) );
+	
+	d.addr.len = sizeof( inAddr );
+	d.addr.maxlen = sizeof( inAddr );
+	d.addr.buf = (unsigned char *)&inAddr;
+
+	d.opt.len = 0;
+	d.opt.maxlen = 0;
+	d.opt.buf = NULL;
+		
+	d.udata.len = length;
+	d.udata.maxlen = length;
+	d.udata.buf = (unsigned char *)data;
+	
+	err = OTSndUData( endpoint, &d );
+	if ( err ) {
+		HandleOTError( err, "Sys_SendPacket" );
+	}
+}
+
+/*
+==================
+Sys_GetPacket
+
+Never called by the game logic, just the system event queing
+==================
+*/
+qboolean	Sys_GetPacket ( netadr_t *net_from, msg_t *net_message ) {
+	TUnitData	d;
+	InetAddress	inAddr;
+	OSStatus	err;
+	OTFlags		flags;
+	
+	if ( !endpoint ) {
+		return qfalse;
+	}
+
+	inAddr.fAddressType = AF_INET;
+	inAddr.fPort = 0;
+	inAddr.fHost = 0;
+
+	memset( &d, 0, sizeof( d ) );
+
+	d.addr.len = sizeof( inAddr );
+	d.addr.maxlen = sizeof( inAddr );
+	d.addr.buf = (unsigned char *)&inAddr;
+
+	d.opt.len = 0;
+	d.opt.maxlen = 0;
+	d.opt.buf = 0;
+		
+	d.udata.len = net_message->maxsize;
+	d.udata.maxlen = net_message->maxsize;
+	d.udata.buf = net_message->data;
+	
+	err = OTRcvUData( endpoint, &d, &flags );
+	if ( err ) {
+		if ( err == kOTNoDataErr ) {
+			return false;
+		}
+		HandleOTError( err, "Sys_GetPacket" );
+		return qfalse;
+	}
+
+	net_from->type = NA_IP;
+	net_from->port = inAddr.fPort;
+	*(int *)net_from->ip = inAddr.fHost;
+
+	net_message->cursize = d.udata.len;
+	
+	return qtrue;
+}
+
+
+/*
+==================
+Sys_IsLANAddress
+
+LAN clients will have their rate var ignored
+==================
+*/
+qboolean	Sys_IsLANAddress (netadr_t adr) {
+	int		i;
+	int		ip;
+	
+	if ( adr.type == NA_LOOPBACK ) {
+		return qtrue;
+	}
+
+	if ( adr.type != NA_IP ) {
+		return qfalse;
+	}
+	
+	for ( ip = 0 ; ip < numIP ; ip++ ) {
+		for ( i = 0 ; i < 4 ; i++ ) {
+			if ( ( adr.ip[i] & ((byte *)&sys_inetInfo[ip].fNetmask)[i] )
+			!= ( ((byte *)&sys_inetInfo[ip].fAddress)[i] & ((byte *)&sys_inetInfo[ip].fNetmask)[i] ) ) {
+				break;
+			}
+		}
+		if ( i == 4 ) {
+			return qtrue;	// matches this subnet
+		}
+	}
+	
+	return qfalse;
+}
+
+
+void NET_Sleep( int i ) {
+}
diff --git a/code/mac/mac_snddma.c b/code/mac/mac_snddma.c
new file mode 100644
index 0000000..9643aa3
--- /dev/null
+++ b/code/mac/mac_snddma.c
@@ -0,0 +1,140 @@
+
+// mac_snddma.c
+// all other sound mixing is portable
+
+#include "../client/snd_local.h"
+#include <sound.h>
+
+#define	MAX_MIXED_SAMPLES	0x8000
+#define	SUBMISSION_CHUNK	0x100
+
+static	short			s_mixedSamples[MAX_MIXED_SAMPLES];
+static	int				s_chunkCount;		// number of chunks submitted
+static	SndChannel		*s_sndChan;
+static	ExtSoundHeader	s_sndHeader;
+
+/*
+===============
+S_Callback
+===============
+*/
+void S_Callback( SndChannel *sc, SndCommand *cmd ) {
+	SndCommand		mySndCmd;
+	SndCommand		mySndCmd2;
+	int				offset;
+	
+	offset = ( s_chunkCount * SUBMISSION_CHUNK ) & (MAX_MIXED_SAMPLES-1);
+	
+	// queue up another sound buffer
+	memset( &s_sndHeader, 0, sizeof( s_sndHeader ) );
+	s_sndHeader.samplePtr = (void *)(s_mixedSamples + offset);
+	s_sndHeader.numChannels = 2;
+	s_sndHeader.sampleRate = rate22khz;
+	s_sndHeader.loopStart = 0;
+	s_sndHeader.loopEnd = 0;
+	s_sndHeader.encode = extSH;
+	s_sndHeader.baseFrequency = 1;
+	s_sndHeader.numFrames = SUBMISSION_CHUNK / 2;
+	s_sndHeader.markerChunk = NULL;
+	s_sndHeader.instrumentChunks = NULL;
+	s_sndHeader.AESRecording = NULL;
+	s_sndHeader.sampleSize = 16;
+	
+	mySndCmd.cmd = bufferCmd;
+	mySndCmd.param1 = 0;
+	mySndCmd.param2 = (int)&s_sndHeader;
+	SndDoCommand( sc, &mySndCmd, true );
+	
+	// and another callback
+	mySndCmd2.cmd = callBackCmd;
+	mySndCmd2.param1 = 0;
+	mySndCmd2.param2 = 0;
+	SndDoCommand( sc, &mySndCmd2, true );
+
+	s_chunkCount++;		// this is the next buffer we will submit
+}
+
+/*
+===============
+S_MakeTestPattern
+===============
+*/
+void S_MakeTestPattern( void ) {
+	int		i;
+	float	v;
+	int		sample;
+	
+	for ( i = 0 ; i < dma.samples / 2 ; i ++ ) {
+		v = sin( M_PI * 2 * i / 64 );
+		sample = v * 0x4000;
+		((short *)dma.buffer)[i*2] = sample;	
+		((short *)dma.buffer)[i*2+1] = sample;	
+	}
+}
+
+/*
+===============
+SNDDMA_Init
+===============
+*/
+qboolean SNDDMA_Init(void) {
+	int		err;
+	
+	// create a sound channel
+	s_sndChan = NULL;
+	err = SndNewChannel( &s_sndChan, sampledSynth, initStereo, NewSndCallBackProc(S_Callback) );
+	if ( err ) {
+		return false;
+	}
+	
+	dma.channels = 2;
+	dma.samples = MAX_MIXED_SAMPLES;
+	dma.submission_chunk = SUBMISSION_CHUNK;
+	dma.samplebits = 16;
+	dma.speed = 22050;
+	dma.buffer = (byte *)s_mixedSamples;
+	
+	// que up the first submission-chunk sized buffer
+	s_chunkCount = 0;
+	
+	S_Callback( s_sndChan, NULL );
+	
+	return qtrue;
+}
+
+/*
+===============
+SNDDMA_GetDMAPos
+===============
+*/
+int	SNDDMA_GetDMAPos(void) {
+	return s_chunkCount * SUBMISSION_CHUNK;
+}
+
+/*
+===============
+SNDDMA_Shutdown
+===============
+*/
+void SNDDMA_Shutdown(void) {
+	if ( s_sndChan ) {
+		SndDisposeChannel( s_sndChan, true );
+		s_sndChan = NULL;
+	}
+}
+
+/*
+===============
+SNDDMA_BeginPainting
+===============
+*/
+void SNDDMA_BeginPainting(void) {
+}
+
+/*
+===============
+SNDDMA_Submit
+===============
+*/
+void SNDDMA_Submit(void) {
+}
diff --git a/code/mac/macprefix.h b/code/mac/macprefix.h
new file mode 100644
index 0000000..2836860
--- /dev/null
+++ b/code/mac/macprefix.h
@@ -0,0 +1,3 @@
+//#define __MACOS__		// needed for MrC
+#define	BOTLIB
+
diff --git a/code/mac/q3.rsrc b/code/mac/q3.rsrc
new file mode 100644
index 0000000..e69de29
diff --git a/code/mac/vssver.scc b/code/mac/vssver.scc
new file mode 100644
index 0000000..1081f2f
Binary files /dev/null and b/code/mac/vssver.scc differ
diff --git a/code/mp3code/cdct.c b/code/mp3code/cdct.c
new file mode 100644
index 0000000..556270f
--- /dev/null
+++ b/code/mp3code/cdct.c
@@ -0,0 +1,320 @@
+/*____________________________________________________________________________
+	
+	FreeAmp - The Free MP3 Player
+
+        MP3 Decoder originally Copyright (C) 1995-1997 Xing Technology
+        Corp.  http://www.xingtech.com
+
+	Portions Copyright (C) 1998-1999 EMusic.com
+
+	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., 675 Mass Ave, Cambridge, MA 02139, USA.
+	
+	$Id: cdct.c,v 1.11 1999/10/19 07:13:08 elrod Exp $
+____________________________________________________________________________*/
+
+/****  cdct.c  ***************************************************
+
+mod 5/16/95 first stage in 8 pt dct does not drop last sb mono
+
+
+MPEG audio decoder, dct
+portable C
+
+******************************************************************/
+
+#include "config.h"
+#include <stdlib.h>
+#include <stdio.h>
+#include <float.h>
+#include <math.h>
+
+#pragma warning ( disable : 4711 )	// function 'xxxx' selected for automatic inline expansion
+
+float coef32[31];	/* 32 pt dct coefs */		// !!!!!!!!!!!!!!!!!! (only generated once (always to same value)
+
+/*------------------------------------------------------------*/
+float *dct_coef_addr()
+{
+   return coef32;
+}
+/*------------------------------------------------------------*/
+static void forward_bf(int m, int n, float x[], float f[], float coef[])
+{
+   int i, j, n2;
+   int p, q, p0, k;
+
+   p0 = 0;
+   n2 = n >> 1;
+   for (i = 0; i < m; i++, p0 += n)
+   {
+      k = 0;
+      p = p0;
+      q = p + n - 1;
+      for (j = 0; j < n2; j++, p++, q--, k++)
+      {
+	 f[p] = x[p] + x[q];
+	 f[n2 + p] = coef[k] * (x[p] - x[q]);
+      }
+   }
+}
+/*------------------------------------------------------------*/
+static void back_bf(int m, int n, float x[], float f[])
+{
+   int i, j, n2, n21;
+   int p, q, p0;
+
+   p0 = 0;
+   n2 = n >> 1;
+   n21 = n2 - 1;
+   for (i = 0; i < m; i++, p0 += n)
+   {
+      p = p0;
+      q = p0;
+      for (j = 0; j < n2; j++, p += 2, q++)
+	 f[p] = x[q];
+      p = p0 + 1;
+      for (j = 0; j < n21; j++, p += 2, q++)
+	 f[p] = x[q] + x[q + 1];
+      f[p] = x[q];
+   }
+}
+/*------------------------------------------------------------*/
+
+
+void fdct32(float x[], float c[])
+{
+   float a[32];			/* ping pong buffers */
+   float b[32];
+   int p, q;
+
+   float *src = x;
+
+/* special first stage */
+   for (p = 0, q = 31; p < 16; p++, q--)
+   {
+      a[p] = src[p] + src[q];
+      a[16 + p] = coef32[p] * (src[p] - src[q]);
+   }
+   forward_bf(2, 16, a, b, coef32 + 16);
+   forward_bf(4, 8, b, a, coef32 + 16 + 8);
+   forward_bf(8, 4, a, b, coef32 + 16 + 8 + 4);
+   forward_bf(16, 2, b, a, coef32 + 16 + 8 + 4 + 2);
+   back_bf(8, 4, a, b);
+   back_bf(4, 8, b, a);
+   back_bf(2, 16, a, b);
+   back_bf(1, 32, b, c);
+}
+/*------------------------------------------------------------*/
+void fdct32_dual(float x[], float c[])
+{
+   float a[32];			/* ping pong buffers */
+   float b[32];
+   int p, pp, qq;
+
+/* special first stage for dual chan (interleaved x) */
+   pp = 0;
+   qq = 2 * 31;
+   for (p = 0; p < 16; p++, pp += 2, qq -= 2)
+   {
+      a[p] = x[pp] + x[qq];
+      a[16 + p] = coef32[p] * (x[pp] - x[qq]);
+   }
+   forward_bf(2, 16, a, b, coef32 + 16);
+   forward_bf(4, 8, b, a, coef32 + 16 + 8);
+   forward_bf(8, 4, a, b, coef32 + 16 + 8 + 4);
+   forward_bf(16, 2, b, a, coef32 + 16 + 8 + 4 + 2);
+   back_bf(8, 4, a, b);
+   back_bf(4, 8, b, a);
+   back_bf(2, 16, a, b);
+   back_bf(1, 32, b, c);
+}
+/*---------------convert dual to mono------------------------------*/
+void fdct32_dual_mono(float x[], float c[])
+{
+   float a[32];			/* ping pong buffers */
+   float b[32];
+   float t1, t2;
+   int p, pp, qq;
+
+/* special first stage  */
+   pp = 0;
+   qq = 2 * 31;
+   for (p = 0; p < 16; p++, pp += 2, qq -= 2)
+   {
+      t1 = 0.5F * (x[pp] + x[pp + 1]);
+      t2 = 0.5F * (x[qq] + x[qq + 1]);
+      a[p] = t1 + t2;
+      a[16 + p] = coef32[p] * (t1 - t2);
+   }
+   forward_bf(2, 16, a, b, coef32 + 16);
+   forward_bf(4, 8, b, a, coef32 + 16 + 8);
+   forward_bf(8, 4, a, b, coef32 + 16 + 8 + 4);
+   forward_bf(16, 2, b, a, coef32 + 16 + 8 + 4 + 2);
+   back_bf(8, 4, a, b);
+   back_bf(4, 8, b, a);
+   back_bf(2, 16, a, b);
+   back_bf(1, 32, b, c);
+}
+/*------------------------------------------------------------*/
+/*---------------- 16 pt fdct -------------------------------*/
+void fdct16(float x[], float c[])
+{
+   float a[16];			/* ping pong buffers */
+   float b[16];
+   int p, q;
+
+/* special first stage (drop highest sb) */
+   a[0] = x[0];
+   a[8] = coef32[16] * x[0];
+   for (p = 1, q = 14; p < 8; p++, q--)
+   {
+      a[p] = x[p] + x[q];
+      a[8 + p] = coef32[16 + p] * (x[p] - x[q]);
+   }
+   forward_bf(2, 8, a, b, coef32 + 16 + 8);
+   forward_bf(4, 4, b, a, coef32 + 16 + 8 + 4);
+   forward_bf(8, 2, a, b, coef32 + 16 + 8 + 4 + 2);
+   back_bf(4, 4, b, a);
+   back_bf(2, 8, a, b);
+   back_bf(1, 16, b, c);
+}
+/*------------------------------------------------------------*/
+/*---------------- 16 pt fdct dual chan---------------------*/
+void fdct16_dual(float x[], float c[])
+{
+   float a[16];			/* ping pong buffers */
+   float b[16];
+   int p, pp, qq;
+
+/* special first stage for interleaved input */
+   a[0] = x[0];
+   a[8] = coef32[16] * x[0];
+   pp = 2;
+   qq = 2 * 14;
+   for (p = 1; p < 8; p++, pp += 2, qq -= 2)
+   {
+      a[p] = x[pp] + x[qq];
+      a[8 + p] = coef32[16 + p] * (x[pp] - x[qq]);
+   }
+   forward_bf(2, 8, a, b, coef32 + 16 + 8);
+   forward_bf(4, 4, b, a, coef32 + 16 + 8 + 4);
+   forward_bf(8, 2, a, b, coef32 + 16 + 8 + 4 + 2);
+   back_bf(4, 4, b, a);
+   back_bf(2, 8, a, b);
+   back_bf(1, 16, b, c);
+}
+/*------------------------------------------------------------*/
+/*---------------- 16 pt fdct dual to mono-------------------*/
+void fdct16_dual_mono(float x[], float c[])
+{
+   float a[16];			/* ping pong buffers */
+   float b[16];
+   float t1, t2;
+   int p, pp, qq;
+
+/* special first stage  */
+   a[0] = 0.5F * (x[0] + x[1]);
+   a[8] = coef32[16] * a[0];
+   pp = 2;
+   qq = 2 * 14;
+   for (p = 1; p < 8; p++, pp += 2, qq -= 2)
+   {
+      t1 = 0.5F * (x[pp] + x[pp + 1]);
+      t2 = 0.5F * (x[qq] + x[qq + 1]);
+      a[p] = t1 + t2;
+      a[8 + p] = coef32[16 + p] * (t1 - t2);
+   }
+   forward_bf(2, 8, a, b, coef32 + 16 + 8);
+   forward_bf(4, 4, b, a, coef32 + 16 + 8 + 4);
+   forward_bf(8, 2, a, b, coef32 + 16 + 8 + 4 + 2);
+   back_bf(4, 4, b, a);
+   back_bf(2, 8, a, b);
+   back_bf(1, 16, b, c);
+}
+/*------------------------------------------------------------*/
+/*---------------- 8 pt fdct -------------------------------*/
+void fdct8(float x[], float c[])
+{
+   float a[8];			/* ping pong buffers */
+   float b[8];
+   int p, q;
+
+/* special first stage  */
+
+   b[0] = x[0] + x[7];
+   b[4] = coef32[16 + 8] * (x[0] - x[7]);
+   for (p = 1, q = 6; p < 4; p++, q--)
+   {
+      b[p] = x[p] + x[q];
+      b[4 + p] = coef32[16 + 8 + p] * (x[p] - x[q]);
+   }
+
+   forward_bf(2, 4, b, a, coef32 + 16 + 8 + 4);
+   forward_bf(4, 2, a, b, coef32 + 16 + 8 + 4 + 2);
+   back_bf(2, 4, b, a);
+   back_bf(1, 8, a, c);
+}
+/*------------------------------------------------------------*/
+/*---------------- 8 pt fdct dual chan---------------------*/
+void fdct8_dual(float x[], float c[])
+{
+   float a[8];			/* ping pong buffers */
+   float b[8];
+   int p, pp, qq;
+
+/* special first stage for interleaved input */
+   b[0] = x[0] + x[14];
+   b[4] = coef32[16 + 8] * (x[0] - x[14]);
+   pp = 2;
+   qq = 2 * 6;
+   for (p = 1; p < 4; p++, pp += 2, qq -= 2)
+   {
+      b[p] = x[pp] + x[qq];
+      b[4 + p] = coef32[16 + 8 + p] * (x[pp] - x[qq]);
+   }
+   forward_bf(2, 4, b, a, coef32 + 16 + 8 + 4);
+   forward_bf(4, 2, a, b, coef32 + 16 + 8 + 4 + 2);
+   back_bf(2, 4, b, a);
+   back_bf(1, 8, a, c);
+}
+/*------------------------------------------------------------*/
+/*---------------- 8 pt fdct dual to mono---------------------*/
+void fdct8_dual_mono(float x[], float c[])
+{
+   float a[8];			/* ping pong buffers */
+   float b[8];
+   float t1, t2;
+   int p, pp, qq;
+
+/* special first stage  */
+   t1 = 0.5F * (x[0] + x[1]);
+   t2 = 0.5F * (x[14] + x[15]);
+   b[0] = t1 + t2;
+   b[4] = coef32[16 + 8] * (t1 - t2);
+   pp = 2;
+   qq = 2 * 6;
+   for (p = 1; p < 4; p++, pp += 2, qq -= 2)
+   {
+      t1 = 0.5F * (x[pp] + x[pp + 1]);
+      t2 = 0.5F * (x[qq] + x[qq + 1]);
+      b[p] = t1 + t2;
+      b[4 + p] = coef32[16 + 8 + p] * (t1 - t2);
+   }
+   forward_bf(2, 4, b, a, coef32 + 16 + 8 + 4);
+   forward_bf(4, 2, a, b, coef32 + 16 + 8 + 4 + 2);
+   back_bf(2, 4, b, a);
+   back_bf(1, 8, a, c);
+}
+/*------------------------------------------------------------*/
diff --git a/code/mp3code/config.h b/code/mp3code/config.h
new file mode 100644
index 0000000..a5da233
--- /dev/null
+++ b/code/mp3code/config.h
@@ -0,0 +1,136 @@
+/*____________________________________________________________________________
+	
+	FreeAmp - The Free MP3 Player
+
+	Portions Copyright (C) 1998-1999 EMusic.com
+
+	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., 675 Mass Ave, Cambridge, MA 02139, USA.
+	
+	$Id: config.win32,v 1.16 1999/12/09 08:44:07 elrod Exp $
+____________________________________________________________________________*/
+
+#ifndef CONFIG_H
+#define CONFIG_H
+
+#if !defined(RC_INVOKED)
+
+#include <limits.h>
+
+#define HAVE_IO_H 1
+#define HAVE_ERRNO_H 1
+
+#if HAVE_UNISTD_H
+#define RD_BNRY_FLAGS O_RDONLY
+#elif HAVE_IO_H
+#define RD_BNRY_FLAGS O_RDONLY | O_BINARY
+#endif
+
+/* Endian Issues */
+#ifdef LINUX
+#include <endian.h>
+#endif
+
+#ifdef WIN32
+#define __LITTLE_ENDIAN 1234
+#define __BIG_ENDIAN    4321
+#define __PDP_ENDIAN    3412
+#define __BYTE_ORDER    __LITTLE_ENDIAN
+#define usleep(x) ::Sleep(x/1000)
+#define strcasecmp(a,b) stricmp(a,b)
+#define strncasecmp(a,b,c) strnicmp(a,b,c)
+typedef int socklen_t;
+#endif
+
+#ifndef _MAX_PATH
+#define _MAX_PATH 260
+#endif
+
+/* define our datatypes */
+// real number
+typedef double real;
+
+#if UCHAR_MAX == 0xff
+
+typedef unsigned char	uint8;
+typedef signed char		int8;
+
+#else
+#error This machine has no 8-bit type
+#endif
+
+#if UINT_MAX == 0xffff
+
+typedef unsigned int	uint16;
+typedef int				int16;
+
+#elif USHRT_MAX == 0xffff
+
+typedef unsigned short	uint16;
+typedef short			int16;
+
+#else
+#error This machine has no 16-bit type
+#endif
+
+
+#if UINT_MAX == 0xfffffffful
+
+typedef unsigned int	uint32;
+typedef int				int32;
+
+#elif ULONG_MAX == 0xfffffffful
+
+typedef unsigned long	uint32;
+typedef long			int32;
+
+#elif USHRT_MAX == 0xfffffffful
+
+typedef unsigned short	uint32;
+typedef short			int32;
+
+#else
+#error This machine has no 32-bit type
+#endif
+
+
+// What character marks the end of a directory entry? For DOS and
+// Windows, it is "\"; in UNIX it is "/".
+#if defined(WIN32) || defined(OS2) || defined(__DOS__)
+#define DIR_MARKER '\\'
+#define DIR_MARKER_STR "\\"
+#else
+#define DIR_MARKER '/'
+#define DIR_MARKER_STR "/"
+#endif /* WIN32 */
+
+// What character(s) marks the end of a line in a text file? 
+// For DOS and Windows, it is "\r\n"; in UNIX it is "\r".
+#if defined(WIN32) || defined(OS2) || defined(__DOS__)
+#define LINE_END_MARKER_STR "\r\n"
+#else
+#define LINE_END_MARKER_STR "\n"
+#endif /* WIN32 */
+
+#ifndef NULL
+#ifdef  __cplusplus
+#define NULL    0
+#else
+#define NULL    ((void *)0)
+#endif
+#endif /* NULL */
+
+#endif /* RC_INVOKED */
+
+#endif /* CONFIG_H */
diff --git a/code/mp3code/copyright.h b/code/mp3code/copyright.h
new file mode 100644
index 0000000..5f75427
--- /dev/null
+++ b/code/mp3code/copyright.h
@@ -0,0 +1,19 @@
+//############################################################################
+//##                                                                        ##
+//##  MSS 4.0 Miles Sound Studio                                            ##
+//##                                                                        ##
+//##  V1.00 of 18-Mar-96: Initial version                                   ##
+//##                                                                        ##
+//##  C source compatible with Microsoft C v9.0 or later                    ##
+//##                                                                        ##
+//##   Author: Jeff Roberts                                                 ##
+//##                                                                        ##
+//############################################################################
+//##                                                                        ##
+//##  Copyright (C) RAD Game Tools, Inc.                                    ##
+//##                                                                        ##
+//##  For technical support, contact RAD Game Tools at 425-893-4300.        ##
+//##                                                                        ##
+//############################################################################
+
+#define MSS_COPYRIGHT "Copyright (C) 1991-2000, RAD Game Tools, Inc."
diff --git a/code/mp3code/csbt.c b/code/mp3code/csbt.c
new file mode 100644
index 0000000..a88d338
--- /dev/null
+++ b/code/mp3code/csbt.c
@@ -0,0 +1,355 @@
+/*____________________________________________________________________________
+	
+	FreeAmp - The Free MP3 Player
+
+        MP3 Decoder originally Copyright (C) 1995-1997 Xing Technology
+        Corp.  http://www.xingtech.com
+
+	Portions Copyright (C) 1998 EMusic.com
+
+	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., 675 Mass Ave, Cambridge, MA 02139, USA.
+	
+	$Id: csbt.c,v 1.2 1999/10/19 07:13:08 elrod Exp $
+____________________________________________________________________________*/
+
+/****  csbt.c  ***************************************************
+
+MPEG audio decoder, dct and window
+portable C
+
+1/7/96 mod for Layer III
+  
+******************************************************************/
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <float.h>
+#include <math.h>
+
+void fdct32(float *, float *);
+void fdct32_dual(float *, float *);
+void fdct32_dual_mono(float *, float *);
+void fdct16(float *, float *);
+void fdct16_dual(float *, float *);
+void fdct16_dual_mono(float *, float *);
+void fdct8(float *, float *);
+void fdct8_dual(float *, float *);
+void fdct8_dual_mono(float *, float *);
+
+void window(float *vbuf, int vb_ptr, short *pcm);
+void window_dual(float *vbuf, int vb_ptr, short *pcm);
+void window16(float *vbuf, int vb_ptr, short *pcm);
+void window16_dual(float *vbuf, int vb_ptr, short *pcm);
+void window8(float *vbuf, int vb_ptr, short *pcm);
+void window8_dual(float *vbuf, int vb_ptr, short *pcm);
+
+/*-------------------------------------------------------------------------*/
+/* circular window buffers */
+#include "mp3struct.h"
+////static signed int vb_ptr;	// !!!!!!!!!!!!!
+////static signed int vb2_ptr;	// !!!!!!!!!!!!!
+////static float pMP3Stream->vbuf[512];		// !!!!!!!!!!!!!
+////static float vbuf2[512];	// !!!!!!!!!!!!!
+
+float *dct_coef_addr();
+
+/*======================================================================*/
+static void gencoef()		/* gen coef for N=32 (31 coefs) */
+{
+	static int iOnceOnly = 0;
+   int p, n, i, k;
+   double t, pi;
+   float *coef32;
+
+   if (!iOnceOnly++)
+   {
+	   coef32 = dct_coef_addr();
+
+	   pi = 4.0 * atan(1.0);
+	   n = 16;
+	   k = 0;
+	   for (i = 0; i < 5; i++, n = n / 2)
+	   {
+
+		  for (p = 0; p < n; p++, k++)
+		  {
+		 t = (pi / (4 * n)) * (2 * p + 1);
+		 coef32[k] = (float) (0.50 / cos(t));
+		  }
+	   }
+   }
+}
+/*------------------------------------------------------------*/
+void sbt_init()
+{
+   int i;
+   static int first_pass = 1;
+
+   if (first_pass)
+   {
+      gencoef();
+      first_pass = 0;
+   }
+
+/* clear window pMP3Stream->vbuf */
+   for (i = 0; i < 512; i++)
+   {
+      pMP3Stream->vbuf[i] = 0.0F;
+      pMP3Stream->vbuf2[i] = 0.0F;
+   }
+   pMP3Stream->vb2_ptr = pMP3Stream->vb_ptr = 0;
+
+}
+/*============================================================*/
+/*============================================================*/
+/*============================================================*/
+void sbt_mono(float *sample, short *pcm, int n)
+{
+   int i;
+
+   for (i = 0; i < n; i++)
+   {
+      fdct32(sample, pMP3Stream->vbuf + pMP3Stream->vb_ptr);
+      window(pMP3Stream->vbuf, pMP3Stream->vb_ptr, pcm);
+      sample += 64;
+      pMP3Stream->vb_ptr = (pMP3Stream->vb_ptr - 32) & 511;
+      pcm += 32;
+   }
+
+}
+/*------------------------------------------------------------*/
+void sbt_dual(float *sample, short *pcm, int n)
+{
+   int i;
+
+   for (i = 0; i < n; i++)
+   {
+      fdct32_dual(sample, pMP3Stream->vbuf + pMP3Stream->vb_ptr);
+      fdct32_dual(sample + 1, pMP3Stream->vbuf2 + pMP3Stream->vb_ptr);
+      window_dual(pMP3Stream->vbuf, pMP3Stream->vb_ptr, pcm);
+      window_dual(pMP3Stream->vbuf2, pMP3Stream->vb_ptr, pcm + 1);
+      sample += 64;
+      pMP3Stream->vb_ptr = (pMP3Stream->vb_ptr - 32) & 511;
+      pcm += 64;
+   }
+
+
+}
+/*------------------------------------------------------------*/
+/* convert dual to mono */
+void sbt_dual_mono(float *sample, short *pcm, int n)
+{
+   int i;
+
+   for (i = 0; i < n; i++)
+   {
+      fdct32_dual_mono(sample, pMP3Stream->vbuf + pMP3Stream->vb_ptr);
+      window(pMP3Stream->vbuf, pMP3Stream->vb_ptr, pcm);
+      sample += 64;
+      pMP3Stream->vb_ptr = (pMP3Stream->vb_ptr - 32) & 511;
+      pcm += 32;
+   }
+
+}
+/*------------------------------------------------------------*/
+/* convert dual to left */
+void sbt_dual_left(float *sample, short *pcm, int n)
+{
+   int i;
+
+   for (i = 0; i < n; i++)
+   {
+      fdct32_dual(sample, pMP3Stream->vbuf + pMP3Stream->vb_ptr);
+      window(pMP3Stream->vbuf, pMP3Stream->vb_ptr, pcm);
+      sample += 64;
+      pMP3Stream->vb_ptr = (pMP3Stream->vb_ptr - 32) & 511;
+      pcm += 32;
+   }
+}
+/*------------------------------------------------------------*/
+/* convert dual to right */
+void sbt_dual_right(float *sample, short *pcm, int n)
+{
+   int i;
+
+   sample++;			/* point to right chan */
+   for (i = 0; i < n; i++)
+   {
+      fdct32_dual(sample, pMP3Stream->vbuf + pMP3Stream->vb_ptr);
+      window(pMP3Stream->vbuf, pMP3Stream->vb_ptr, pcm);
+      sample += 64;
+      pMP3Stream->vb_ptr = (pMP3Stream->vb_ptr - 32) & 511;
+      pcm += 32;
+   }
+}
+/*------------------------------------------------------------*/
+/*---------------- 16 pt sbt's  -------------------------------*/
+/*------------------------------------------------------------*/
+void sbt16_mono(float *sample, short *pcm, int n)
+{
+   int i;
+
+   for (i = 0; i < n; i++)
+   {
+      fdct16(sample, pMP3Stream->vbuf + pMP3Stream->vb_ptr);
+      window16(pMP3Stream->vbuf, pMP3Stream->vb_ptr, pcm);
+      sample += 64;
+      pMP3Stream->vb_ptr = (pMP3Stream->vb_ptr - 16) & 255;
+      pcm += 16;
+   }
+
+
+}
+/*------------------------------------------------------------*/
+void sbt16_dual(float *sample, short *pcm, int n)
+{
+   int i;
+
+   for (i = 0; i < n; i++)
+   {
+      fdct16_dual(sample, pMP3Stream->vbuf + pMP3Stream->vb_ptr);
+      fdct16_dual(sample + 1, pMP3Stream->vbuf2 + pMP3Stream->vb_ptr);
+      window16_dual(pMP3Stream->vbuf, pMP3Stream->vb_ptr, pcm);
+      window16_dual(pMP3Stream->vbuf2, pMP3Stream->vb_ptr, pcm + 1);
+      sample += 64;
+      pMP3Stream->vb_ptr = (pMP3Stream->vb_ptr - 16) & 255;
+      pcm += 32;
+   }
+}
+/*------------------------------------------------------------*/
+void sbt16_dual_mono(float *sample, short *pcm, int n)
+{
+   int i;
+
+   for (i = 0; i < n; i++)
+   {
+      fdct16_dual_mono(sample, pMP3Stream->vbuf + pMP3Stream->vb_ptr);
+      window16(pMP3Stream->vbuf, pMP3Stream->vb_ptr, pcm);
+      sample += 64;
+      pMP3Stream->vb_ptr = (pMP3Stream->vb_ptr - 16) & 255;
+      pcm += 16;
+   }
+}
+/*------------------------------------------------------------*/
+void sbt16_dual_left(float *sample, short *pcm, int n)
+{
+   int i;
+
+   for (i = 0; i < n; i++)
+   {
+      fdct16_dual(sample, pMP3Stream->vbuf + pMP3Stream->vb_ptr);
+      window16(pMP3Stream->vbuf, pMP3Stream->vb_ptr, pcm);
+      sample += 64;
+      pMP3Stream->vb_ptr = (pMP3Stream->vb_ptr - 16) & 255;
+      pcm += 16;
+   }
+}
+/*------------------------------------------------------------*/
+void sbt16_dual_right(float *sample, short *pcm, int n)
+{
+   int i;
+
+   sample++;
+   for (i = 0; i < n; i++)
+   {
+      fdct16_dual(sample, pMP3Stream->vbuf + pMP3Stream->vb_ptr);
+      window16(pMP3Stream->vbuf, pMP3Stream->vb_ptr, pcm);
+      sample += 64;
+      pMP3Stream->vb_ptr = (pMP3Stream->vb_ptr - 16) & 255;
+      pcm += 16;
+   }
+}
+/*------------------------------------------------------------*/
+/*---------------- 8 pt sbt's  -------------------------------*/
+/*------------------------------------------------------------*/
+void sbt8_mono(float *sample, short *pcm, int n)
+{
+   int i;
+
+   for (i = 0; i < n; i++)
+   {
+      fdct8(sample, pMP3Stream->vbuf + pMP3Stream->vb_ptr);
+      window8(pMP3Stream->vbuf, pMP3Stream->vb_ptr, pcm);
+      sample += 64;
+      pMP3Stream->vb_ptr = (pMP3Stream->vb_ptr - 8) & 127;
+      pcm += 8;
+   }
+
+}
+/*------------------------------------------------------------*/
+void sbt8_dual(float *sample, short *pcm, int n)
+{
+   int i;
+
+   for (i = 0; i < n; i++)
+   {
+      fdct8_dual(sample, pMP3Stream->vbuf + pMP3Stream->vb_ptr);
+      fdct8_dual(sample + 1, pMP3Stream->vbuf2 + pMP3Stream->vb_ptr);
+      window8_dual(pMP3Stream->vbuf, pMP3Stream->vb_ptr, pcm);
+      window8_dual(pMP3Stream->vbuf2, pMP3Stream->vb_ptr, pcm + 1);
+      sample += 64;
+      pMP3Stream->vb_ptr = (pMP3Stream->vb_ptr - 8) & 127;
+      pcm += 16;
+   }
+}
+/*------------------------------------------------------------*/
+void sbt8_dual_mono(float *sample, short *pcm, int n)
+{
+   int i;
+
+   for (i = 0; i < n; i++)
+   {
+      fdct8_dual_mono(sample, pMP3Stream->vbuf + pMP3Stream->vb_ptr);
+      window8(pMP3Stream->vbuf, pMP3Stream->vb_ptr, pcm);
+      sample += 64;
+      pMP3Stream->vb_ptr = (pMP3Stream->vb_ptr - 8) & 127;
+      pcm += 8;
+   }
+}
+/*------------------------------------------------------------*/
+void sbt8_dual_left(float *sample, short *pcm, int n)
+{
+   int i;
+
+   for (i = 0; i < n; i++)
+   {
+      fdct8_dual(sample, pMP3Stream->vbuf + pMP3Stream->vb_ptr);
+      window8(pMP3Stream->vbuf, pMP3Stream->vb_ptr, pcm);
+      sample += 64;
+      pMP3Stream->vb_ptr = (pMP3Stream->vb_ptr - 8) & 127;
+      pcm += 8;
+   }
+}
+/*------------------------------------------------------------*/
+void sbt8_dual_right(float *sample, short *pcm, int n)
+{
+   int i;
+
+   sample++;
+   for (i = 0; i < n; i++)
+   {
+      fdct8_dual(sample, pMP3Stream->vbuf + pMP3Stream->vb_ptr);
+      window8(pMP3Stream->vbuf, pMP3Stream->vb_ptr, pcm);
+      sample += 64;
+      pMP3Stream->vb_ptr = (pMP3Stream->vb_ptr - 8) & 127;
+      pcm += 8;
+   }
+}
+/*------------------------------------------------------------*/
+/*------------------------------------------------------------*/
+#define COMPILE_ME
+#include "csbtb.c"		/* 8 bit output */
+#include "csbtL3.c"		/* Layer III */
+/*------------------------------------------------------------*/
diff --git a/code/mp3code/csbtb.c b/code/mp3code/csbtb.c
new file mode 100644
index 0000000..48be054
--- /dev/null
+++ b/code/mp3code/csbtb.c
@@ -0,0 +1,279 @@
+#pragma warning(disable:4206)	// nonstandard extension used : translation unit is empty
+#ifdef COMPILE_ME
+/*____________________________________________________________________________
+	
+	FreeAmp - The Free MP3 Player
+
+        MP3 Decoder originally Copyright (C) 1995-1997 Xing Technology
+        Corp.  http://www.xingtech.com
+
+	Portions Copyright (C) 1998 EMusic.com
+
+	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., 675 Mass Ave, Cambridge, MA 02139, USA.
+	
+	$Id: csbtb.c,v 1.2 1999/10/19 07:13:08 elrod Exp $
+____________________________________________________________________________*/
+
+/****  csbtb.c  ***************************************************
+include to csbt.c
+
+MPEG audio decoder, dct and window - byte (8 pcm bit output)
+portable C
+
+******************************************************************/
+/*============================================================*/
+/*============================================================*/
+void windowB(float *vbuf, int vb_ptr, unsigned char *pcm);
+void windowB_dual(float *vbuf, int vb_ptr, unsigned char *pcm);
+void windowB16(float *vbuf, int vb_ptr, unsigned char *pcm);
+void windowB16_dual(float *vbuf, int vb_ptr, unsigned char *pcm);
+void windowB8(float *vbuf, int vb_ptr, unsigned char *pcm);
+void windowB8_dual(float *vbuf, int vb_ptr, unsigned char *pcm);
+
+/*============================================================*/
+void sbtB_mono(float *sample, unsigned char *pcm, int n)
+{
+   int i;
+
+   for (i = 0; i < n; i++)
+   {
+      fdct32(sample, pMP3Stream->vbuf + pMP3Stream->vb_ptr);
+      windowB(pMP3Stream->vbuf, pMP3Stream->vb_ptr, pcm);
+      sample += 64;
+      pMP3Stream->vb_ptr = (pMP3Stream->vb_ptr - 32) & 511;
+      pcm += 32;
+   }
+
+}
+/*------------------------------------------------------------*/
+void sbtB_dual(float *sample, unsigned char *pcm, int n)
+{
+   int i;
+
+   for (i = 0; i < n; i++)
+   {
+      fdct32_dual(sample, pMP3Stream->vbuf + pMP3Stream->vb_ptr);
+      fdct32_dual(sample + 1, pMP3Stream->vbuf2 + pMP3Stream->vb_ptr);
+      windowB_dual(pMP3Stream->vbuf, pMP3Stream->vb_ptr, pcm);
+      windowB_dual(pMP3Stream->vbuf2, pMP3Stream->vb_ptr, pcm + 1);
+      sample += 64;
+      pMP3Stream->vb_ptr = (pMP3Stream->vb_ptr - 32) & 511;
+      pcm += 64;
+   }
+
+
+}
+/*------------------------------------------------------------*/
+/* convert dual to mono */
+void sbtB_dual_mono(float *sample, unsigned char *pcm, int n)
+{
+   int i;
+
+   for (i = 0; i < n; i++)
+   {
+      fdct32_dual_mono(sample, pMP3Stream->vbuf + pMP3Stream->vb_ptr);
+      windowB(pMP3Stream->vbuf, pMP3Stream->vb_ptr, pcm);
+      sample += 64;
+      pMP3Stream->vb_ptr = (pMP3Stream->vb_ptr - 32) & 511;
+      pcm += 32;
+   }
+
+}
+/*------------------------------------------------------------*/
+/* convert dual to left */
+void sbtB_dual_left(float *sample, unsigned char *pcm, int n)
+{
+   int i;
+
+   for (i = 0; i < n; i++)
+   {
+      fdct32_dual(sample, pMP3Stream->vbuf + pMP3Stream->vb_ptr);
+      windowB(pMP3Stream->vbuf, pMP3Stream->vb_ptr, pcm);
+      sample += 64;
+      pMP3Stream->vb_ptr = (pMP3Stream->vb_ptr - 32) & 511;
+      pcm += 32;
+   }
+}
+/*------------------------------------------------------------*/
+/* convert dual to right */
+void sbtB_dual_right(float *sample, unsigned char *pcm, int n)
+{
+   int i;
+
+   sample++;			/* point to right chan */
+   for (i = 0; i < n; i++)
+   {
+      fdct32_dual(sample, pMP3Stream->vbuf + pMP3Stream->vb_ptr);
+      windowB(pMP3Stream->vbuf, pMP3Stream->vb_ptr, pcm);
+      sample += 64;
+      pMP3Stream->vb_ptr = (pMP3Stream->vb_ptr - 32) & 511;
+      pcm += 32;
+   }
+}
+/*------------------------------------------------------------*/
+/*---------------- 16 pt sbt's  -------------------------------*/
+/*------------------------------------------------------------*/
+void sbtB16_mono(float *sample, unsigned char *pcm, int n)
+{
+   int i;
+
+   for (i = 0; i < n; i++)
+   {
+      fdct16(sample, pMP3Stream->vbuf + pMP3Stream->vb_ptr);
+      windowB16(pMP3Stream->vbuf, pMP3Stream->vb_ptr, pcm);
+      sample += 64;
+      pMP3Stream->vb_ptr = (pMP3Stream->vb_ptr - 16) & 255;
+      pcm += 16;
+   }
+
+
+}
+/*------------------------------------------------------------*/
+void sbtB16_dual(float *sample, unsigned char *pcm, int n)
+{
+   int i;
+
+   for (i = 0; i < n; i++)
+   {
+      fdct16_dual(sample, pMP3Stream->vbuf + pMP3Stream->vb_ptr);
+      fdct16_dual(sample + 1, pMP3Stream->vbuf2 + pMP3Stream->vb_ptr);
+      windowB16_dual(pMP3Stream->vbuf, pMP3Stream->vb_ptr, pcm);
+      windowB16_dual(pMP3Stream->vbuf2, pMP3Stream->vb_ptr, pcm + 1);
+      sample += 64;
+      pMP3Stream->vb_ptr = (pMP3Stream->vb_ptr - 16) & 255;
+      pcm += 32;
+   }
+}
+/*------------------------------------------------------------*/
+void sbtB16_dual_mono(float *sample, unsigned char *pcm, int n)
+{
+   int i;
+
+   for (i = 0; i < n; i++)
+   {
+      fdct16_dual_mono(sample, pMP3Stream->vbuf + pMP3Stream->vb_ptr);
+      windowB16(pMP3Stream->vbuf, pMP3Stream->vb_ptr, pcm);
+      sample += 64;
+      pMP3Stream->vb_ptr = (pMP3Stream->vb_ptr - 16) & 255;
+      pcm += 16;
+   }
+}
+/*------------------------------------------------------------*/
+void sbtB16_dual_left(float *sample, unsigned char *pcm, int n)
+{
+   int i;
+
+   for (i = 0; i < n; i++)
+   {
+      fdct16_dual(sample, pMP3Stream->vbuf + pMP3Stream->vb_ptr);
+      windowB16(pMP3Stream->vbuf, pMP3Stream->vb_ptr, pcm);
+      sample += 64;
+      pMP3Stream->vb_ptr = (pMP3Stream->vb_ptr - 16) & 255;
+      pcm += 16;
+   }
+}
+/*------------------------------------------------------------*/
+void sbtB16_dual_right(float *sample, unsigned char *pcm, int n)
+{
+   int i;
+
+   sample++;
+   for (i = 0; i < n; i++)
+   {
+      fdct16_dual(sample, pMP3Stream->vbuf + pMP3Stream->vb_ptr);
+      windowB16(pMP3Stream->vbuf, pMP3Stream->vb_ptr, pcm);
+      sample += 64;
+      pMP3Stream->vb_ptr = (pMP3Stream->vb_ptr - 16) & 255;
+      pcm += 16;
+   }
+}
+/*------------------------------------------------------------*/
+/*---------------- 8 pt sbt's  -------------------------------*/
+/*------------------------------------------------------------*/
+void sbtB8_mono(float *sample, unsigned char *pcm, int n)
+{
+   int i;
+
+   for (i = 0; i < n; i++)
+   {
+      fdct8(sample, pMP3Stream->vbuf + pMP3Stream->vb_ptr);
+      windowB8(pMP3Stream->vbuf, pMP3Stream->vb_ptr, pcm);
+      sample += 64;
+      pMP3Stream->vb_ptr = (pMP3Stream->vb_ptr - 8) & 127;
+      pcm += 8;
+   }
+
+}
+/*------------------------------------------------------------*/
+void sbtB8_dual(float *sample, unsigned char *pcm, int n)
+{
+   int i;
+
+   for (i = 0; i < n; i++)
+   {
+      fdct8_dual(sample, pMP3Stream->vbuf + pMP3Stream->vb_ptr);
+      fdct8_dual(sample + 1, pMP3Stream->vbuf2 + pMP3Stream->vb_ptr);
+      windowB8_dual(pMP3Stream->vbuf, pMP3Stream->vb_ptr, pcm);
+      windowB8_dual(pMP3Stream->vbuf2, pMP3Stream->vb_ptr, pcm + 1);
+      sample += 64;
+      pMP3Stream->vb_ptr = (pMP3Stream->vb_ptr - 8) & 127;
+      pcm += 16;
+   }
+}
+/*------------------------------------------------------------*/
+void sbtB8_dual_mono(float *sample, unsigned char *pcm, int n)
+{
+   int i;
+
+   for (i = 0; i < n; i++)
+   {
+      fdct8_dual_mono(sample, pMP3Stream->vbuf + pMP3Stream->vb_ptr);
+      windowB8(pMP3Stream->vbuf, pMP3Stream->vb_ptr, pcm);
+      sample += 64;
+      pMP3Stream->vb_ptr = (pMP3Stream->vb_ptr - 8) & 127;
+      pcm += 8;
+   }
+}
+/*------------------------------------------------------------*/
+void sbtB8_dual_left(float *sample, unsigned char *pcm, int n)
+{
+   int i;
+
+   for (i = 0; i < n; i++)
+   {
+      fdct8_dual(sample, pMP3Stream->vbuf + pMP3Stream->vb_ptr);
+      windowB8(pMP3Stream->vbuf, pMP3Stream->vb_ptr, pcm);
+      sample += 64;
+      pMP3Stream->vb_ptr = (pMP3Stream->vb_ptr - 8) & 127;
+      pcm += 8;
+   }
+}
+/*------------------------------------------------------------*/
+void sbtB8_dual_right(float *sample, unsigned char *pcm, int n)
+{
+   int i;
+
+   sample++;
+   for (i = 0; i < n; i++)
+   {
+      fdct8_dual(sample, pMP3Stream->vbuf + pMP3Stream->vb_ptr);
+      windowB8(pMP3Stream->vbuf, pMP3Stream->vb_ptr, pcm);
+      sample += 64;
+      pMP3Stream->vb_ptr = (pMP3Stream->vb_ptr - 8) & 127;
+      pcm += 8;
+   }
+}
+/*------------------------------------------------------------*/
+#endif	// #ifdef COMPILE_ME
diff --git a/code/mp3code/csbtl3.c b/code/mp3code/csbtl3.c
new file mode 100644
index 0000000..6e9537d
--- /dev/null
+++ b/code/mp3code/csbtl3.c
@@ -0,0 +1,309 @@
+#pragma warning(disable:4206)	// nonstandard extension used : translation unit is empty
+#ifdef COMPILE_ME
+/*____________________________________________________________________________
+	
+	FreeAmp - The Free MP3 Player
+
+        MP3 Decoder originally Copyright (C) 1995-1997 Xing Technology
+        Corp.  http://www.xingtech.com
+
+	Portions Copyright (C) 1998 EMusic.com
+
+	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., 675 Mass Ave, Cambridge, MA 02139, USA.
+	
+	$Id: csbtL3.c,v 1.2 1999/10/19 07:13:08 elrod Exp $
+____________________________________________________________________________*/
+
+/****  csbtL3.c  ***************************************************
+
+layer III
+
+  include to  csbt.c
+
+******************************************************************/
+/*============================================================*/
+/*============ Layer III =====================================*/
+/*============================================================*/
+void sbt_mono_L3(float *sample, short *pcm, int ch)
+{
+	int i;
+	
+	ch = 0;
+	for (i = 0; i < 18; i++)
+	{
+		fdct32(sample, pMP3Stream->vbuf + pMP3Stream->vb_ptr);
+		window(pMP3Stream->vbuf, pMP3Stream->vb_ptr, pcm);
+		sample += 32;
+		pMP3Stream->vb_ptr = (pMP3Stream->vb_ptr - 32) & 511;
+		pcm += 32;
+	}	
+}
+/*------------------------------------------------------------*/
+void sbt_dual_L3(float *sample, short *pcm, int ch)
+{
+	int i;
+	
+	if (ch == 0)
+	{
+		for (i = 0; i < 18; i++)
+		{
+			fdct32(sample, pMP3Stream->vbuf + pMP3Stream->vb_ptr);
+			window_dual(pMP3Stream->vbuf, pMP3Stream->vb_ptr, pcm);
+			sample += 32;
+			pMP3Stream->vb_ptr = (pMP3Stream->vb_ptr - 32) & 511;
+			pcm += 64;
+		}
+	}
+	else
+	{
+		for (i = 0; i < 18; i++)
+		{
+			fdct32(sample, pMP3Stream->vbuf2 + pMP3Stream->vb2_ptr);
+			window_dual(pMP3Stream->vbuf2, pMP3Stream->vb2_ptr, pcm + 1);
+			sample += 32;
+			pMP3Stream->vb2_ptr = (pMP3Stream->vb2_ptr - 32) & 511;
+			pcm += 64;
+		}
+	}
+}
+/*------------------------------------------------------------*/
+/*------------------------------------------------------------*/
+/*---------------- 16 pt sbt's  -------------------------------*/
+/*------------------------------------------------------------*/
+void sbt16_mono_L3(float *sample, short *pcm, int ch)
+{
+	int i;
+	
+	ch = 0;
+	for (i = 0; i < 18; i++)
+	{
+		fdct16(sample, pMP3Stream->vbuf + pMP3Stream->vb_ptr);
+		window16(pMP3Stream->vbuf, pMP3Stream->vb_ptr, pcm);
+		sample += 32;
+		pMP3Stream->vb_ptr = (pMP3Stream->vb_ptr - 16) & 255;
+		pcm += 16;
+	}
+}
+/*------------------------------------------------------------*/
+void sbt16_dual_L3(float *sample, short *pcm, int ch)
+{
+   int i;
+
+   if (ch == 0)
+   {
+	   for (i = 0; i < 18; i++)
+	   {
+		   fdct16(sample, pMP3Stream->vbuf + pMP3Stream->vb_ptr);
+		   window16_dual(pMP3Stream->vbuf, pMP3Stream->vb_ptr, pcm);
+		   sample += 32;
+		   pMP3Stream->vb_ptr = (pMP3Stream->vb_ptr - 16) & 255;
+		   pcm += 32;
+	   }
+   }
+   else
+   {
+	   for (i = 0; i < 18; i++)
+	   {
+		   fdct16(sample, pMP3Stream->vbuf2 + pMP3Stream->vb2_ptr);
+		   window16_dual(pMP3Stream->vbuf2, pMP3Stream->vb2_ptr, pcm + 1);
+		   sample += 32;
+		   pMP3Stream->vb2_ptr = (pMP3Stream->vb2_ptr - 16) & 255;
+		   pcm += 32;
+	   }
+   }   
+}
+/*------------------------------------------------------------*/
+/*---------------- 8 pt sbt's  -------------------------------*/
+/*------------------------------------------------------------*/
+void sbt8_mono_L3(float *sample, short *pcm, int ch)
+{
+	int i;
+	
+	ch = 0;
+	for (i = 0; i < 18; i++)
+	{
+		fdct8(sample, pMP3Stream->vbuf + pMP3Stream->vb_ptr);
+		window8(pMP3Stream->vbuf, pMP3Stream->vb_ptr, pcm);
+		sample += 32;
+		pMP3Stream->vb_ptr = (pMP3Stream->vb_ptr - 8) & 127;
+		pcm += 8;
+	}
+}
+/*------------------------------------------------------------*/
+void sbt8_dual_L3(float *sample, short *pcm, int ch)
+{
+	int i;
+	
+	if (ch == 0)
+	{
+		for (i = 0; i < 18; i++)
+		{
+			fdct8(sample, pMP3Stream->vbuf + pMP3Stream->vb_ptr);
+			window8_dual(pMP3Stream->vbuf, pMP3Stream->vb_ptr, pcm);
+			sample += 32;
+			pMP3Stream->vb_ptr = (pMP3Stream->vb_ptr - 8) & 127;
+			pcm += 16;
+		}
+	}
+	else
+	{
+		for (i = 0; i < 18; i++)
+		{
+			fdct8(sample, pMP3Stream->vbuf2 + pMP3Stream->vb2_ptr);
+			window8_dual(pMP3Stream->vbuf2, pMP3Stream->vb2_ptr, pcm + 1);
+			sample += 32;
+			pMP3Stream->vb2_ptr = (pMP3Stream->vb2_ptr - 8) & 127;
+			pcm += 16;
+		}
+	}
+}
+/*------------------------------------------------------------*/
+/*------- 8 bit output ---------------------------------------*/
+/*------------------------------------------------------------*/
+void sbtB_mono_L3(float *sample, unsigned char *pcm, int ch)
+{
+	int i;
+	
+	ch = 0;
+	for (i = 0; i < 18; i++)
+	{
+		fdct32(sample, pMP3Stream->vbuf + pMP3Stream->vb_ptr);
+		windowB(pMP3Stream->vbuf, pMP3Stream->vb_ptr, pcm);
+		sample += 32;
+		pMP3Stream->vb_ptr = (pMP3Stream->vb_ptr - 32) & 511;
+		pcm += 32;
+	}
+}
+/*------------------------------------------------------------*/
+void sbtB_dual_L3(float *sample, unsigned char *pcm, int ch)
+{
+	int i;
+	
+	if (ch == 0)
+	{
+		for (i = 0; i < 18; i++)
+		{
+			fdct32(sample, pMP3Stream->vbuf + pMP3Stream->vb_ptr);
+			windowB_dual(pMP3Stream->vbuf, pMP3Stream->vb_ptr, pcm);
+			sample += 32;
+			pMP3Stream->vb_ptr = (pMP3Stream->vb_ptr - 32) & 511;
+			pcm += 64;
+		}
+	}
+	else
+	{
+		for (i = 0; i < 18; i++)
+		{
+			fdct32(sample, pMP3Stream->vbuf2 + pMP3Stream->vb2_ptr);
+			windowB_dual(pMP3Stream->vbuf2, pMP3Stream->vb2_ptr, pcm + 1);
+			sample += 32;
+			pMP3Stream->vb2_ptr = (pMP3Stream->vb2_ptr - 32) & 511;
+			pcm += 64;
+		}
+	}
+}
+/*------------------------------------------------------------*/
+/*------------------------------------------------------------*/
+/*---------------- 16 pt sbtB's  -------------------------------*/
+/*------------------------------------------------------------*/
+void sbtB16_mono_L3(float *sample, unsigned char *pcm, int ch)
+{
+	int i;
+	
+	ch = 0;
+	for (i = 0; i < 18; i++)
+	{
+		fdct16(sample, pMP3Stream->vbuf + pMP3Stream->vb_ptr);
+		windowB16(pMP3Stream->vbuf, pMP3Stream->vb_ptr, pcm);
+		sample += 32;
+		pMP3Stream->vb_ptr = (pMP3Stream->vb_ptr - 16) & 255;
+		pcm += 16;
+	}
+}
+/*------------------------------------------------------------*/
+void sbtB16_dual_L3(float *sample, unsigned char *pcm, int ch)
+{
+	int i;
+	
+	if (ch == 0)
+	{
+		for (i = 0; i < 18; i++)
+		{
+			fdct16(sample, pMP3Stream->vbuf + pMP3Stream->vb_ptr);
+			windowB16_dual(pMP3Stream->vbuf, pMP3Stream->vb_ptr, pcm);
+			sample += 32;
+			pMP3Stream->vb_ptr = (pMP3Stream->vb_ptr - 16) & 255;
+			pcm += 32;
+		}
+	}
+	else
+	{
+		for (i = 0; i < 18; i++)
+		{
+			fdct16(sample, pMP3Stream->vbuf2 + pMP3Stream->vb2_ptr);
+			windowB16_dual(pMP3Stream->vbuf2, pMP3Stream->vb2_ptr, pcm + 1);
+			sample += 32;
+			pMP3Stream->vb2_ptr = (pMP3Stream->vb2_ptr - 16) & 255;
+			pcm += 32;
+		}
+	}
+}
+/*------------------------------------------------------------*/
+/*---------------- 8 pt sbtB's  -------------------------------*/
+/*------------------------------------------------------------*/
+void sbtB8_mono_L3(float *sample, unsigned char *pcm, int ch)
+{
+	int i;
+	
+	ch = 0;
+	for (i = 0; i < 18; i++)
+	{
+		fdct8(sample, pMP3Stream->vbuf + pMP3Stream->vb_ptr);
+		windowB8(pMP3Stream->vbuf, pMP3Stream->vb_ptr, pcm);
+		sample += 32;
+		pMP3Stream->vb_ptr = (pMP3Stream->vb_ptr - 8) & 127;
+		pcm += 8;
+	}
+}
+/*------------------------------------------------------------*/
+void sbtB8_dual_L3(float *sample, unsigned char *pcm, int ch)
+{
+	int i;
+	
+	if (ch == 0)
+	{
+		for (i = 0; i < 18; i++)
+		{
+			fdct8(sample, pMP3Stream->vbuf + pMP3Stream->vb_ptr);
+			windowB8_dual(pMP3Stream->vbuf, pMP3Stream->vb_ptr, pcm);
+			sample += 32;
+			pMP3Stream->vb_ptr = (pMP3Stream->vb_ptr - 8) & 127;
+			pcm += 16;
+		}
+	}
+	else
+	{
+		for (i = 0; i < 18; i++)
+		{
+			fdct8(sample, pMP3Stream->vbuf2 + pMP3Stream->vb2_ptr);
+			windowB8_dual(pMP3Stream->vbuf2, pMP3Stream->vb2_ptr, pcm + 1);
+			sample += 32;
+			pMP3Stream->vb2_ptr = (pMP3Stream->vb2_ptr - 8) & 127;
+			pcm += 16;
+		}
+	}
+}
+/*------------------------------------------------------------*/
+#endif	// #ifdef COMPILE_ME
diff --git a/code/mp3code/cup.c b/code/mp3code/cup.c
new file mode 100644
index 0000000..6277d4b
--- /dev/null
+++ b/code/mp3code/cup.c
@@ -0,0 +1,546 @@
+/*____________________________________________________________________________
+	
+	FreeAmp - The Free MP3 Player
+
+        MP3 Decoder originally Copyright (C) 1995-1997 Xing Technology
+        Corp.  http://www.xingtech.com
+
+	Portions Copyright (C) 1998-1999 EMusic.com
+
+	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., 675 Mass Ave, Cambridge, MA 02139, USA.
+	
+	$Id: cup.c,v 1.3 1999/10/19 07:13:08 elrod Exp $
+____________________________________________________________________________*/
+
+/****  cup.c  ***************************************************
+
+MPEG audio decoder Layer I/II  mpeg1 and mpeg2
+should be portable ANSI C, should be endian independent
+
+
+mod  2/21/95 2/21/95  add bit skip, sb limiting
+
+mods 11/15/95 for Layer I
+
+******************************************************************/
+/******************************************************************
+
+       MPEG audio software decoder portable ANSI c.
+       Decodes all Layer I/II to 16 bit linear pcm.
+       Optional stereo to mono conversion.  Optional
+       output sample rate conversion to half or quarter of
+       native mpeg rate. dec8.c adds oupuut conversion features.
+
+-------------------------------------
+int audio_decode_init(MPEG_HEAD *h, int framebytes_arg,
+         int reduction_code, int transform_code, int convert_code,
+         int freq_limit)
+
+initilize decoder:
+       return 0 = fail, not 0 = success
+
+MPEG_HEAD *h    input, mpeg header info (returned by call to head_info)
+pMP3Stream->framebytes      input, mpeg frame size (returned by call to head_info)
+reduction_code  input, sample rate reduction code
+                    0 = full rate
+                    1 = half rate
+                    2 = quarter rate
+
+transform_code  input, ignored
+convert_code    input, channel conversion
+                  convert_code:  0 = two chan output
+                                 1 = convert two chan to mono
+                                 2 = convert two chan to left chan
+                                 3 = convert two chan to right chan
+freq_limit      input, limits bandwidth of pcm output to specified
+                frequency.  Special use. Set to 24000 for normal use.
+
+
+---------------------------------
+void audio_decode_info( DEC_INFO *info)
+
+information return:
+          Call after audio_decode_init.  See mhead.h for
+          information returned in DEC_INFO structure.
+
+
+---------------------------------
+IN_OUT audio_decode(unsigned char *bs, void *pcmbuf)
+
+decode one mpeg audio frame:
+bs        input, mpeg bitstream, must start with
+          sync word.  Caution: may read up to 3 bytes
+          beyond end of frame.
+pcmbuf    output, pcm samples.
+
+IN_OUT structure returns:
+          Number bytes conceptually removed from mpeg bitstream.
+          Returns 0 if sync loss.
+          Number bytes of pcm output.
+
+*******************************************************************/
+
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <float.h>
+#include <math.h>
+#include "mhead.h"		/* mpeg header structure */
+
+
+#ifdef _MSC_VER
+#pragma warning(disable: 4709)
+#endif
+
+#include "mp3struct.h"
+
+
+/*-------------------------------------------------------
+NOTE:  Decoder may read up to three bytes beyond end of
+frame.  Calling application must ensure that this does
+not cause a memory access violation (protection fault)
+---------------------------------------------------------*/
+
+/*====================================================================*/
+/*----------------*/
+//@@@@ This next one (decinfo) is ok:
+DEC_INFO decinfo;		/* global for Layer III */	// only written into by decode init funcs, then copied to stack struct higher up
+
+/*----------------*/
+static float look_c_value[18];	/* built by init */	// effectively constant
+
+/*----------------*/
+////@@@@static int pMP3Stream->outbytes;		// !!!!!!!!!!!!!!?
+////@@@@static int pMP3Stream->framebytes;		// !!!!!!!!!!!!!!!!
+////@@@@static int pMP3Stream->outvalues;		// !!!!!!!!!!!!?
+////@@@@static int pad;
+static const int look_joint[16] =
+{				/* lookup stereo sb's by mode+ext */
+   64, 64, 64, 64,		/* stereo */
+   2 * 4, 2 * 8, 2 * 12, 2 * 16,	/* joint */
+   64, 64, 64, 64,		/* dual */
+   32, 32, 32, 32,		/* mono */
+};
+
+/*----------------*/
+////@@@@static int max_sb;		// !!!!!!!!! L1, 2 3
+////@@@@static int stereo_sb;
+
+/*----------------*/
+////@@@@static int pMP3Stream->nsb_limit = 6;
+////@@@@static int bit_skip;
+static const int bat_bit_master[] =
+{
+   0, 5, 7, 9, 10, 12, 15, 18, 21, 24, 27, 30, 33, 36, 39, 42, 45, 48};
+
+/*----------------*/
+////@@@@static int nbat[4] = {3, 8, 12, 7};	// !!!!!!!!!!!!! not constant!!!!
+////@@@@static int bat[4][16];	// built as constant, but built according to header type (sigh)
+static int ballo[64];		/* set by unpack_ba */					// scratchpad
+static unsigned int samp_dispatch[66];	/* set by unpack_ba */		// scratchpad?
+static float c_value[64];	/* set by unpack_ba */					// scratchpad
+
+/*----------------*/
+static unsigned int sf_dispatch[66];	/* set by unpack_ba */		// scratchpad?
+static float sf_table[64];		// effectively constant
+////@@@@ static float cs_factor[3][64];
+
+/*----------------*/
+////@@@@FINDME - groan....  (I shoved a *2 in just in case it needed it for stereo. This whole thing is crap now
+float sample[2304*2];		/* global for use by Later 3 */	// !!!!!!!!!!!!!!!!!!!!!! // scratchpad?
+static signed char group3_table[32][3];		// effectively constant
+static signed char group5_table[128][3];	// effectively constant
+static signed short group9_table[1024][3];	// effectively constant
+
+/*----------------*/
+
+////@@@@typedef void (*SBT_FUNCTION) (float *sample, short *pcm, int n);
+void sbt_mono(float *sample, short *pcm, int n);
+void sbt_dual(float *sample, short *pcm, int n);
+////@@@@static SBT_FUNCTION sbt = sbt_mono;
+
+
+typedef IN_OUT(*AUDIO_DECODE_ROUTINE) (unsigned char *bs, signed short *pcm);
+IN_OUT L2audio_decode(unsigned char *bs, signed short *pcm);
+static AUDIO_DECODE_ROUTINE audio_decode_routine = L2audio_decode;
+
+/*======================================================================*/
+/*======================================================================*/
+/* get bits from bitstream in endian independent way */
+////@@@@ FINDME - this stuff doesn't appear to be used by any of our samples (phew)
+static unsigned char *bs_ptr;
+static unsigned long bitbuf;
+static int bits;
+static long bitval;
+
+/*------------- initialize bit getter -------------*/
+static void load_init(unsigned char *buf)
+{
+   bs_ptr = buf;
+   bits = 0;
+   bitbuf = 0;
+}
+/*------------- get n bits from bitstream -------------*/
+static long load(int n)
+{
+   unsigned long x;
+
+   if (bits < n)
+   {				/* refill bit buf if necessary */
+      while (bits <= 24)
+      {
+	 bitbuf = (bitbuf << 8) | *bs_ptr++;
+	 bits += 8;
+      }
+   }
+   bits -= n;
+   x = bitbuf >> bits;
+   bitbuf -= x << bits;
+   return x;
+}
+/*------------- skip over n bits in bitstream -------------*/
+static void skip(int n)
+{
+   int k;
+
+   if (bits < n)
+   {
+      n -= bits;
+      k = n >> 3;
+/*--- bytes = n/8 --*/
+      bs_ptr += k;
+      n -= k << 3;
+      bitbuf = *bs_ptr++;
+      bits = 8;
+   }
+   bits -= n;
+   bitbuf -= (bitbuf >> bits) << bits;
+}
+/*--------------------------------------------------------------*/
+#define mac_load_check(n) if( bits < (n) ) {                           \
+          while( bits <= 24 ) {               \
+             bitbuf = (bitbuf << 8) | *bs_ptr++;  \
+             bits += 8;                       \
+          }                                   \
+   }
+/*--------------------------------------------------------------*/
+#define mac_load(n) ( bits -= n,                    \
+         bitval = bitbuf >> bits,      \
+         bitbuf -= bitval << bits,     \
+         bitval )
+/*======================================================================*/
+static void unpack_ba()
+{
+   int i, j, k;
+   static int nbit[4] =
+   {4, 4, 3, 2};
+   int nstereo;
+
+   pMP3Stream->bit_skip = 0;
+   nstereo = pMP3Stream->stereo_sb;
+   k = 0;
+   for (i = 0; i < 4; i++)
+   {
+      for (j = 0; j < pMP3Stream->nbat[i]; j++, k++)
+      {
+	 mac_load_check(4);
+	 ballo[k] = samp_dispatch[k] = pMP3Stream->bat[i][mac_load(nbit[i])];
+	 if (k >= pMP3Stream->nsb_limit)
+	    pMP3Stream->bit_skip += bat_bit_master[samp_dispatch[k]];
+	 c_value[k] = look_c_value[samp_dispatch[k]];
+	 if (--nstereo < 0)
+	 {
+	    ballo[k + 1] = ballo[k];
+	    samp_dispatch[k] += 18;	/* flag as joint */
+	    samp_dispatch[k + 1] = samp_dispatch[k];	/* flag for sf */
+	    c_value[k + 1] = c_value[k];
+	    k++;
+	    j++;
+	 }
+      }
+   }
+   samp_dispatch[pMP3Stream->nsb_limit] = 37;	/* terminate the dispatcher with skip */
+   samp_dispatch[k] = 36;	/* terminate the dispatcher */
+
+}
+/*-------------------------------------------------------------------------*/
+static void unpack_sfs()	/* unpack scale factor selectors */
+{
+   int i;
+
+   for (i = 0; i < pMP3Stream->max_sb; i++)
+   {
+      mac_load_check(2);
+      if (ballo[i])
+	 sf_dispatch[i] = mac_load(2);
+      else
+	 sf_dispatch[i] = 4;	/* no allo */
+   }
+   sf_dispatch[i] = 5;		/* terminate dispatcher */
+}
+/*-------------------------------------------------------------------------*/
+static void unpack_sf()		/* unpack scale factor */
+{				/* combine dequant and scale factors */
+   int i;
+
+   i = -1;
+ dispatch:switch (sf_dispatch[++i])
+   {
+      case 0:			/* 3 factors 012 */
+	 mac_load_check(18);
+	 pMP3Stream->cs_factor[0][i] = c_value[i] * sf_table[mac_load(6)];
+	 pMP3Stream->cs_factor[1][i] = c_value[i] * sf_table[mac_load(6)];
+	 pMP3Stream->cs_factor[2][i] = c_value[i] * sf_table[mac_load(6)];
+	 goto dispatch;
+      case 1:			/* 2 factors 002 */
+	 mac_load_check(12);
+	 pMP3Stream->cs_factor[1][i] = pMP3Stream->cs_factor[0][i] = c_value[i] * sf_table[mac_load(6)];
+	 pMP3Stream->cs_factor[2][i] = c_value[i] * sf_table[mac_load(6)];
+	 goto dispatch;
+      case 2:			/* 1 factor 000 */
+	 mac_load_check(6);
+	 pMP3Stream->cs_factor[2][i] = pMP3Stream->cs_factor[1][i] = pMP3Stream->cs_factor[0][i] =
+	    c_value[i] * sf_table[mac_load(6)];
+	 goto dispatch;
+      case 3:			/* 2 factors 022 */
+	 mac_load_check(12);
+	 pMP3Stream->cs_factor[0][i] = c_value[i] * sf_table[mac_load(6)];
+	 pMP3Stream->cs_factor[2][i] = pMP3Stream->cs_factor[1][i] = c_value[i] * sf_table[mac_load(6)];
+	 goto dispatch;
+      case 4:			/* no allo */
+/*-- pMP3Stream->cs_factor[2][i] = pMP3Stream->cs_factor[1][i] = pMP3Stream->cs_factor[0][i] = 0.0;  --*/
+	 goto dispatch;
+      case 5:			/* all done */
+	 ;
+   }				/* end switch */
+}
+/*-------------------------------------------------------------------------*/
+#define UNPACK_N(n) s[k]     =  pMP3Stream->cs_factor[i][k]*(load(n)-((1 << (n-1)) -1));   \
+    s[k+64]  =  pMP3Stream->cs_factor[i][k]*(load(n)-((1 << (n-1)) -1));   \
+    s[k+128] =  pMP3Stream->cs_factor[i][k]*(load(n)-((1 << (n-1)) -1));   \
+    goto dispatch;
+#define UNPACK_N2(n) mac_load_check(3*n);                                         \
+    s[k]     =  pMP3Stream->cs_factor[i][k]*(mac_load(n)-((1 << (n-1)) -1));   \
+    s[k+64]  =  pMP3Stream->cs_factor[i][k]*(mac_load(n)-((1 << (n-1)) -1));   \
+    s[k+128] =  pMP3Stream->cs_factor[i][k]*(mac_load(n)-((1 << (n-1)) -1));   \
+    goto dispatch;
+#define UNPACK_N3(n) mac_load_check(2*n);                                         \
+    s[k]     =  pMP3Stream->cs_factor[i][k]*(mac_load(n)-((1 << (n-1)) -1));   \
+    s[k+64]  =  pMP3Stream->cs_factor[i][k]*(mac_load(n)-((1 << (n-1)) -1));   \
+    mac_load_check(n);                                           \
+    s[k+128] =  pMP3Stream->cs_factor[i][k]*(mac_load(n)-((1 << (n-1)) -1));   \
+    goto dispatch;
+#define UNPACKJ_N(n) tmp        =  (load(n)-((1 << (n-1)) -1));                \
+    s[k]       =  pMP3Stream->cs_factor[i][k]*tmp;                       \
+    s[k+1]     =  pMP3Stream->cs_factor[i][k+1]*tmp;                     \
+    tmp        =  (load(n)-((1 << (n-1)) -1));                 \
+    s[k+64]    =  pMP3Stream->cs_factor[i][k]*tmp;                       \
+    s[k+64+1]  =  pMP3Stream->cs_factor[i][k+1]*tmp;                     \
+    tmp        =  (load(n)-((1 << (n-1)) -1));                 \
+    s[k+128]   =  pMP3Stream->cs_factor[i][k]*tmp;                       \
+    s[k+128+1] =  pMP3Stream->cs_factor[i][k+1]*tmp;                     \
+    k++;       /* skip right chan dispatch */                \
+    goto dispatch;
+/*-------------------------------------------------------------------------*/
+static void unpack_samp()	/* unpack samples */
+{
+   int i, j, k;
+   float *s;
+   int n;
+   long tmp;
+
+   s = sample;
+   for (i = 0; i < 3; i++)
+   {				/* 3 groups of scale factors */
+      for (j = 0; j < 4; j++)
+      {
+	 k = -1;
+       dispatch:switch (samp_dispatch[++k])
+	 {
+	    case 0:
+	       s[k + 128] = s[k + 64] = s[k] = 0.0F;
+	       goto dispatch;
+	    case 1:		/* 3 levels grouped 5 bits */
+	       mac_load_check(5);
+	       n = mac_load(5);
+	       s[k] = pMP3Stream->cs_factor[i][k] * group3_table[n][0];
+	       s[k + 64] = pMP3Stream->cs_factor[i][k] * group3_table[n][1];
+	       s[k + 128] = pMP3Stream->cs_factor[i][k] * group3_table[n][2];
+	       goto dispatch;
+	    case 2:		/* 5 levels grouped 7 bits */
+	       mac_load_check(7);
+	       n = mac_load(7);
+	       s[k] = pMP3Stream->cs_factor[i][k] * group5_table[n][0];
+	       s[k + 64] = pMP3Stream->cs_factor[i][k] * group5_table[n][1];
+	       s[k + 128] = pMP3Stream->cs_factor[i][k] * group5_table[n][2];
+	       goto dispatch;
+	    case 3:
+	       UNPACK_N2(3)	/* 7 levels */
+	    case 4:		/* 9 levels grouped 10 bits */
+	       mac_load_check(10);
+	       n = mac_load(10);
+	       s[k] = pMP3Stream->cs_factor[i][k] * group9_table[n][0];
+	       s[k + 64] = pMP3Stream->cs_factor[i][k] * group9_table[n][1];
+	       s[k + 128] = pMP3Stream->cs_factor[i][k] * group9_table[n][2];
+	       goto dispatch;
+	    case 5:
+	       UNPACK_N2(4)	/* 15 levels */
+	    case 6:
+	       UNPACK_N2(5)	/* 31 levels */
+	    case 7:
+	       UNPACK_N2(6)	/* 63 levels */
+	    case 8:
+	       UNPACK_N2(7)	/* 127 levels */
+	    case 9:
+	       UNPACK_N2(8)	/* 255 levels */
+	    case 10:
+	       UNPACK_N3(9)	/* 511 levels */
+	    case 11:
+	       UNPACK_N3(10)	/* 1023 levels */
+	    case 12:
+	       UNPACK_N3(11)	/* 2047 levels */
+	    case 13:
+	       UNPACK_N3(12)	/* 4095 levels */
+	    case 14:
+	       UNPACK_N(13)	/* 8191 levels */
+	    case 15:
+	       UNPACK_N(14)	/* 16383 levels */
+	    case 16:
+	       UNPACK_N(15)	/* 32767 levels */
+	    case 17:
+	       UNPACK_N(16)	/* 65535 levels */
+/* -- joint ---- */
+	    case 18 + 0:
+	       s[k + 128 + 1] = s[k + 128] = s[k + 64 + 1] = s[k + 64] = s[k + 1] = s[k] = 0.0F;
+	       k++;		/* skip right chan dispatch */
+	       goto dispatch;
+	    case 18 + 1:	/* 3 levels grouped 5 bits */
+	       n = load(5);
+	       s[k] = pMP3Stream->cs_factor[i][k] * group3_table[n][0];
+	       s[k + 1] = pMP3Stream->cs_factor[i][k + 1] * group3_table[n][0];
+	       s[k + 64] = pMP3Stream->cs_factor[i][k] * group3_table[n][1];
+	       s[k + 64 + 1] = pMP3Stream->cs_factor[i][k + 1] * group3_table[n][1];
+	       s[k + 128] = pMP3Stream->cs_factor[i][k] * group3_table[n][2];
+	       s[k + 128 + 1] = pMP3Stream->cs_factor[i][k + 1] * group3_table[n][2];
+	       k++;		/* skip right chan dispatch */
+	       goto dispatch;
+	    case 18 + 2:	/* 5 levels grouped 7 bits */
+	       n = load(7);
+	       s[k] = pMP3Stream->cs_factor[i][k] * group5_table[n][0];
+	       s[k + 1] = pMP3Stream->cs_factor[i][k + 1] * group5_table[n][0];
+	       s[k + 64] = pMP3Stream->cs_factor[i][k] * group5_table[n][1];
+	       s[k + 64 + 1] = pMP3Stream->cs_factor[i][k + 1] * group5_table[n][1];
+	       s[k + 128] = pMP3Stream->cs_factor[i][k] * group5_table[n][2];
+	       s[k + 128 + 1] = pMP3Stream->cs_factor[i][k + 1] * group5_table[n][2];
+	       k++;		/* skip right chan dispatch */
+	       goto dispatch;
+	    case 18 + 3:
+	       UNPACKJ_N(3)	/* 7 levels */
+	    case 18 + 4:	/* 9 levels grouped 10 bits */
+	       n = load(10);
+	       s[k] = pMP3Stream->cs_factor[i][k] * group9_table[n][0];
+	       s[k + 1] = pMP3Stream->cs_factor[i][k + 1] * group9_table[n][0];
+	       s[k + 64] = pMP3Stream->cs_factor[i][k] * group9_table[n][1];
+	       s[k + 64 + 1] = pMP3Stream->cs_factor[i][k + 1] * group9_table[n][1];
+	       s[k + 128] = pMP3Stream->cs_factor[i][k] * group9_table[n][2];
+	       s[k + 128 + 1] = pMP3Stream->cs_factor[i][k + 1] * group9_table[n][2];
+	       k++;		/* skip right chan dispatch */
+	       goto dispatch;
+	    case 18 + 5:
+	       UNPACKJ_N(4)	/* 15 levels */
+	    case 18 + 6:
+	       UNPACKJ_N(5)	/* 31 levels */
+	    case 18 + 7:
+	       UNPACKJ_N(6)	/* 63 levels */
+	    case 18 + 8:
+	       UNPACKJ_N(7)	/* 127 levels */
+	    case 18 + 9:
+	       UNPACKJ_N(8)	/* 255 levels */
+	    case 18 + 10:
+	       UNPACKJ_N(9)	/* 511 levels */
+	    case 18 + 11:
+	       UNPACKJ_N(10)	/* 1023 levels */
+	    case 18 + 12:
+	       UNPACKJ_N(11)	/* 2047 levels */
+	    case 18 + 13:
+	       UNPACKJ_N(12)	/* 4095 levels */
+	    case 18 + 14:
+	       UNPACKJ_N(13)	/* 8191 levels */
+	    case 18 + 15:
+	       UNPACKJ_N(14)	/* 16383 levels */
+	    case 18 + 16:
+	       UNPACKJ_N(15)	/* 32767 levels */
+	    case 18 + 17:
+	       UNPACKJ_N(16)	/* 65535 levels */
+/* -- end of dispatch -- */
+	    case 37:
+	       skip(pMP3Stream->bit_skip);
+	    case 36:
+	       s += 3 * 64;
+	 }			/* end switch */
+      }				/* end j loop */
+   }				/* end i loop */
+
+
+}
+/*-------------------------------------------------------------------------*/
+unsigned char *gpNextByteAfterData = NULL;
+IN_OUT audio_decode(unsigned char *bs, signed short *pcm, unsigned char *pNextByteAfterData)
+{
+	gpNextByteAfterData = pNextByteAfterData;	// sigh....
+   return audio_decode_routine(bs, pcm);
+}
+/*-------------------------------------------------------------------------*/
+IN_OUT L2audio_decode(unsigned char *bs, signed short *pcm)
+{
+   int sync, prot;
+   IN_OUT in_out;
+
+   load_init(bs);		/* initialize bit getter */
+/* test sync */
+   in_out.in_bytes = 0;		/* assume fail */
+   in_out.out_bytes = 0;
+   sync = load(12);
+   if (sync != 0xFFF)
+      return in_out;		/* sync fail */
+
+   load(3);			/* skip id and option (checked by init) */
+   prot = load(1);		/* load prot bit */
+   load(6);			/* skip to pad */
+   pMP3Stream->pad = load(1);
+   load(1);			/* skip to mode */
+   pMP3Stream->stereo_sb = look_joint[load(4)];
+   if (prot)
+      load(4);			/* skip to data */
+   else
+      load(20);			/* skip crc */
+
+   unpack_ba();			/* unpack bit allocation */
+   unpack_sfs();		/* unpack scale factor selectors */
+   unpack_sf();			/* unpack scale factor */
+   unpack_samp();		/* unpack samples */
+
+   pMP3Stream->sbt(sample, pcm, 36);
+/*-----------*/
+   in_out.in_bytes = pMP3Stream->framebytes + pMP3Stream->pad;
+   in_out.out_bytes = pMP3Stream->outbytes;
+
+   return in_out;
+}
+/*-------------------------------------------------------------------------*/
+#define COMPILE_ME
+#include "cupini.c"		/* initialization */
+#include "cupL1.c"		/* Layer I */
+/*-------------------------------------------------------------------------*/
diff --git a/code/mp3code/cupini.c b/code/mp3code/cupini.c
new file mode 100644
index 0000000..4a7d4c9
--- /dev/null
+++ b/code/mp3code/cupini.c
@@ -0,0 +1,401 @@
+#pragma warning(disable:4206)	// nonstandard extension used : translation unit is empty
+#ifdef COMPILE_ME
+/*____________________________________________________________________________
+	
+	FreeAmp - The Free MP3 Player
+
+        MP3 Decoder originally Copyright (C) 1995-1997 Xing Technology
+        Corp.  http://www.xingtech.com
+
+	Portions Copyright (C) 1998-1999 EMusic.com
+
+	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., 675 Mass Ave, Cambridge, MA 02139, USA.
+	
+	$Id: cupini.c,v 1.3 1999/10/19 07:13:08 elrod Exp $
+____________________________________________________________________________*/
+
+/*=========================================================
+ initialization for cup.c - include to cup.c
+ mpeg audio decoder portable "c"
+
+mod 8/6/96 add 8 bit output
+
+mod 5/10/95 add quick (low precision) window
+
+mod 5/16/95 sb limit for reduced samprate output
+            changed from 94% to 100% of Nyquist sb
+
+mod 11/15/95 for Layer I
+
+
+=========================================================*/
+/*-- compiler bug, floating constant overflow w/ansi --*/
+#ifdef _MSC_VER
+#pragma warning(disable:4056)
+#endif
+
+
+
+
+static const long steps[18] =
+{
+   0, 3, 5, 7, 9, 15, 31, 63, 127,
+   255, 511, 1023, 2047, 4095, 8191, 16383, 32767, 65535};
+
+
+/* ABCD_INDEX = lookqt[mode][sr_index][br_index]  */
+/* -1 = invalid  */
+static const signed char lookqt[4][3][16] =
+{
+ {{1, -1, -1, -1, 2, -1, 2, 0, 0, 0, 1, 1, 1, 1, 1, -1},	/*  44ks stereo */
+  {0, -1, -1, -1, 2, -1, 2, 0, 0, 0, 0, 0, 0, 0, 0, -1},	/*  48ks */
+  {1, -1, -1, -1, 3, -1, 3, 0, 0, 0, 1, 1, 1, 1, 1, -1}},	/*  32ks */
+ {{1, -1, -1, -1, 2, -1, 2, 0, 0, 0, 1, 1, 1, 1, 1, -1},	/*  44ks joint stereo */
+  {0, -1, -1, -1, 2, -1, 2, 0, 0, 0, 0, 0, 0, 0, 0, -1},	/*  48ks */
+  {1, -1, -1, -1, 3, -1, 3, 0, 0, 0, 1, 1, 1, 1, 1, -1}},	/*  32ks */
+ {{1, -1, -1, -1, 2, -1, 2, 0, 0, 0, 1, 1, 1, 1, 1, -1},	/*  44ks dual chan */
+  {0, -1, -1, -1, 2, -1, 2, 0, 0, 0, 0, 0, 0, 0, 0, -1},	/*  48ks */
+  {1, -1, -1, -1, 3, -1, 3, 0, 0, 0, 1, 1, 1, 1, 1, -1}},	/*  32ks */
+// mono extended beyond legal br index
+//  1,2,2,0,0,0,1,1,1,1,1,1,1,1,1,-1,          /*  44ks single chan */
+//  0,2,2,0,0,0,0,0,0,0,0,0,0,0,0,-1,          /*  48ks */
+//  1,3,3,0,0,0,1,1,1,1,1,1,1,1,1,-1,          /*  32ks */
+// legal mono
+ {{1, 2, 2, 0, 0, 0, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1},	/*  44ks single chan */
+  {0, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, -1, -1, -1, -1, -1},	/*  48ks */
+  {1, 3, 3, 0, 0, 0, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1}},	/*  32ks */
+};
+
+static const long sr_table[8] =
+{22050L, 24000L, 16000L, 1L,
+ 44100L, 48000L, 32000L, 1L};
+
+/* bit allocation table look up */
+/* table per mpeg spec tables 3b2a/b/c/d  /e is mpeg2 */
+/* look_bat[abcd_index][4][16]  */
+static const unsigned char look_bat[5][4][16] =
+{
+/* LOOK_BATA */
+ {{0, 1, 3, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17},
+  {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 17},
+  {0, 1, 2, 3, 4, 5, 6, 17, 0, 0, 0, 0, 0, 0, 0, 0},
+  {0, 1, 2, 17, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
+/* LOOK_BATB */
+ {{0, 1, 3, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17},
+  {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 17},
+  {0, 1, 2, 3, 4, 5, 6, 17, 0, 0, 0, 0, 0, 0, 0, 0},
+  {0, 1, 2, 17, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
+/* LOOK_BATC */
+ {{0, 1, 2, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16},
+  {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+  {0, 1, 2, 4, 5, 6, 7, 8, 0, 0, 0, 0, 0, 0, 0, 0},
+  {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
+/* LOOK_BATD */
+ {{0, 1, 2, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16},
+  {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+  {0, 1, 2, 4, 5, 6, 7, 8, 0, 0, 0, 0, 0, 0, 0, 0},
+  {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
+/* LOOK_BATE */
+ {{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15},
+  {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+  {0, 1, 2, 4, 5, 6, 7, 8, 0, 0, 0, 0, 0, 0, 0, 0},
+  {0, 1, 2, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
+};
+
+/* look_nbat[abcd_index]][4] */
+static const unsigned char look_nbat[5][4] =
+{
+  {3, 8, 12, 4},
+  {3, 8, 12, 7},
+  {2, 0, 6, 0},
+  {2, 0, 10, 0},
+  {4, 0, 7, 19},
+};
+
+
+void sbt_mono(float *sample, short *pcm, int n);
+void sbt_dual(float *sample, short *pcm, int n);
+void sbt_dual_mono(float *sample, short *pcm, int n);
+void sbt_dual_left(float *sample, short *pcm, int n);
+void sbt_dual_right(float *sample, short *pcm, int n);
+void sbt16_mono(float *sample, short *pcm, int n);
+void sbt16_dual(float *sample, short *pcm, int n);
+void sbt16_dual_mono(float *sample, short *pcm, int n);
+void sbt16_dual_left(float *sample, short *pcm, int n);
+void sbt16_dual_right(float *sample, short *pcm, int n);
+void sbt8_mono(float *sample, short *pcm, int n);
+void sbt8_dual(float *sample, short *pcm, int n);
+void sbt8_dual_mono(float *sample, short *pcm, int n);
+void sbt8_dual_left(float *sample, short *pcm, int n);
+void sbt8_dual_right(float *sample, short *pcm, int n);
+
+/*--- 8 bit output ---*/
+void sbtB_mono(float *sample, unsigned char *pcm, int n);
+void sbtB_dual(float *sample, unsigned char *pcm, int n);
+void sbtB_dual_mono(float *sample, unsigned char *pcm, int n);
+void sbtB_dual_left(float *sample, unsigned char *pcm, int n);
+void sbtB_dual_right(float *sample, unsigned char *pcm, int n);
+void sbtB16_mono(float *sample, unsigned char *pcm, int n);
+void sbtB16_dual(float *sample, unsigned char *pcm, int n);
+void sbtB16_dual_mono(float *sample, unsigned char *pcm, int n);
+void sbtB16_dual_left(float *sample, unsigned char *pcm, int n);
+void sbtB16_dual_right(float *sample, unsigned char *pcm, int n);
+void sbtB8_mono(float *sample, unsigned char *pcm, int n);
+void sbtB8_dual(float *sample, unsigned char *pcm, int n);
+void sbtB8_dual_mono(float *sample, unsigned char *pcm, int n);
+void sbtB8_dual_left(float *sample, unsigned char *pcm, int n);
+void sbtB8_dual_right(float *sample, unsigned char *pcm, int n);
+
+
+static const SBT_FUNCTION sbt_table[2][3][5] =
+{
+ {{sbt_mono, sbt_dual, sbt_dual_mono, sbt_dual_left, sbt_dual_right},
+  {sbt16_mono, sbt16_dual, sbt16_dual_mono, sbt16_dual_left, sbt16_dual_right},
+  {sbt8_mono, sbt8_dual, sbt8_dual_mono, sbt8_dual_left, sbt8_dual_right}},
+ {{(SBT_FUNCTION) sbtB_mono,
+   (SBT_FUNCTION) sbtB_dual,
+   (SBT_FUNCTION) sbtB_dual_mono,
+   (SBT_FUNCTION) sbtB_dual_left,
+   (SBT_FUNCTION) sbtB_dual_right},
+  {(SBT_FUNCTION) sbtB16_mono,
+   (SBT_FUNCTION) sbtB16_dual,
+   (SBT_FUNCTION) sbtB16_dual_mono,
+   (SBT_FUNCTION) sbtB16_dual_left,
+   (SBT_FUNCTION) sbtB16_dual_right},
+  {(SBT_FUNCTION) sbtB8_mono,
+   (SBT_FUNCTION) sbtB8_dual,
+   (SBT_FUNCTION) sbtB8_dual_mono,
+   (SBT_FUNCTION) sbtB8_dual_left,
+   (SBT_FUNCTION) sbtB8_dual_right}},
+};
+
+static const int out_chans[5] =
+{1, 2, 1, 1, 1};
+
+
+int audio_decode_initL1(MPEG_HEAD * h, int framebytes_arg,
+		   int reduction_code, int transform_code, int convert_code,
+			int freq_limit);
+void sbt_init();
+
+
+IN_OUT L1audio_decode(unsigned char *bs, signed short *pcm);
+IN_OUT L2audio_decode(unsigned char *bs, signed short *pcm);
+IN_OUT L3audio_decode(unsigned char *bs, unsigned char *pcm);
+static const AUDIO_DECODE_ROUTINE decode_routine_table[4] =
+{
+   L2audio_decode,
+   (AUDIO_DECODE_ROUTINE)L3audio_decode,
+   L2audio_decode,
+   L1audio_decode,};
+
+/*---------------------------------------------------------*/
+static void table_init()
+{
+   int i, j;
+   int code;
+   static int iOnceOnly=0;
+
+   if (!iOnceOnly++)
+   {
+	/*--  c_values (dequant) --*/
+	   for (i = 1; i < 18; i++)
+		  look_c_value[i] = 2.0F / steps[i];
+
+	/*--  scale factor table, scale by 32768 for 16 pcm output  --*/
+	   for (i = 0; i < 64; i++)
+		  sf_table[i] = (float) (32768.0 * 2.0 * pow(2.0, -i / 3.0));   
+
+	/*--  grouped 3 level lookup table 5 bit token --*/
+	   for (i = 0; i < 32; i++)
+	   {
+		  code = i;
+		  for (j = 0; j < 3; j++)
+		  {
+		 group3_table[i][j] = (char) ((code % 3) - 1);
+		 code /= 3;
+		  }
+	   }
+   
+	/*--  grouped 5 level lookup table 7 bit token --*/
+	   for (i = 0; i < 128; i++)
+	   {
+		  code = i;
+		  for (j = 0; j < 3; j++)
+		  {
+		 group5_table[i][j] = (char) ((code % 5) - 2);
+		 code /= 5;
+		  }
+	   }
+
+	/*--  grouped 9 level lookup table 10 bit token --*/
+	   for (i = 0; i < 1024; i++)
+	   {
+		  code = i;
+		  for (j = 0; j < 3; j++)
+		  {
+		 group9_table[i][j] = (short) ((code % 9) - 4);
+		 code /= 9;
+		  }
+	   }
+   }
+}
+/*---------------------------------------------------------*/
+int L1audio_decode_init(MPEG_HEAD * h, int framebytes_arg,
+		   int reduction_code, int transform_code, int convert_code,
+			int freq_limit);
+int L3audio_decode_init(MPEG_HEAD * h, int framebytes_arg,
+		   int reduction_code, int transform_code, int convert_code,
+			int freq_limit);
+
+/*---------------------------------------------------------*/
+/* mpeg_head defined in mhead.h  frame bytes is without pad */
+int audio_decode_init(MPEG_HEAD * h, int framebytes_arg,
+		   int reduction_code, int transform_code, int convert_code,
+		      int freq_limit)
+{
+   int i, j, k;
+   static int first_pass = 1;
+   int abcd_index;
+   long samprate;
+   int limit;
+   int bit_code;
+
+   if (first_pass)
+   {
+      table_init();
+      first_pass = 0;
+   }
+
+/* select decoder routine Layer I,II,III */
+   audio_decode_routine = decode_routine_table[h->option & 3];
+
+
+   if (h->option == 3)		/* layer I */
+      return L1audio_decode_init(h, framebytes_arg,
+		  reduction_code, transform_code, convert_code, freq_limit);
+
+   if (h->option == 1)		/* layer III */
+      return L3audio_decode_init(h, framebytes_arg,
+		  reduction_code, transform_code, convert_code, freq_limit);
+
+
+
+   transform_code = transform_code;	/* not used, asm compatability */
+   bit_code = 0;
+   if (convert_code & 8)
+      bit_code = 1;
+   convert_code = convert_code & 3;	/* higher bits used by dec8 freq cvt */
+   if (reduction_code < 0)
+      reduction_code = 0;
+   if (reduction_code > 2)
+      reduction_code = 2;
+   if (freq_limit < 1000)
+      freq_limit = 1000;
+
+
+   pMP3Stream->framebytes = framebytes_arg;
+/* check if code handles */
+   if (h->option != 2)
+      return 0;			/* layer II only */
+   if (h->sr_index == 3)
+      return 0;			/* reserved */
+
+/* compute abcd index for bit allo table selection */
+   if (h->id)			/* mpeg 1 */
+      abcd_index = lookqt[h->mode][h->sr_index][h->br_index];
+   else
+      abcd_index = 4;		/* mpeg 2 */
+
+   if (abcd_index < 0)
+      return 0;			// fail invalid Layer II bit rate index
+
+   for (i = 0; i < 4; i++)
+      for (j = 0; j < 16; j++)
+		pMP3Stream->bat[i][j] = look_bat[abcd_index][i][j];
+   for (i = 0; i < 4; i++)
+      pMP3Stream->nbat[i] = look_nbat[abcd_index][i];
+   pMP3Stream->max_sb = pMP3Stream->nbat[0] + pMP3Stream->nbat[1] + pMP3Stream->nbat[2] + pMP3Stream->nbat[3];
+/*----- compute pMP3Stream->nsb_limit --------*/
+   samprate = sr_table[4 * h->id + h->sr_index];
+   pMP3Stream->nsb_limit = (freq_limit * 64L + samprate / 2) / samprate;
+/*- caller limit -*/
+/*---- limit = 0.94*(32>>reduction_code);  ----*/
+   limit = (32 >> reduction_code);
+   if (limit > 8)
+      limit--;
+   if (pMP3Stream->nsb_limit > limit)
+      pMP3Stream->nsb_limit = limit;
+   if (pMP3Stream->nsb_limit > pMP3Stream->max_sb)
+      pMP3Stream->nsb_limit = pMP3Stream->max_sb;
+
+   pMP3Stream->outvalues = 1152 >> reduction_code;
+   if (h->mode != 3)
+   {				/* adjust for 2 channel modes */
+      for (i = 0; i < 4; i++)
+		pMP3Stream->nbat[i] *= 2;
+      pMP3Stream->max_sb *= 2;
+      pMP3Stream->nsb_limit *= 2;
+   }
+
+/* set sbt function */
+   k = 1 + convert_code;
+   if (h->mode == 3)
+   {
+      k = 0;
+   }
+   pMP3Stream->sbt = sbt_table[bit_code][reduction_code][k];
+   pMP3Stream->outvalues *= out_chans[k];
+   if (bit_code)
+      pMP3Stream->outbytes = pMP3Stream->outvalues;
+   else
+      pMP3Stream->outbytes = sizeof(short) * pMP3Stream->outvalues;
+
+   decinfo.channels = out_chans[k];
+   decinfo.outvalues = pMP3Stream->outvalues;
+   decinfo.samprate = samprate >> reduction_code;
+   if (bit_code)
+      decinfo.bits = 8;
+   else
+      decinfo.bits = sizeof(short) * 8;
+
+   decinfo.framebytes = pMP3Stream->framebytes;
+   decinfo.type = 0;
+
+
+
+/* clear sample buffer, unused sub bands must be 0 */
+   for (i = 0; i < 2304*2; i++)	// the *2 here was inserted by me just in case, since the array is now *2, because of stereo files unpacking at 4608 bytes per frame (which may or may not be relevant, but in any case I don't think we use the L1 versions of MP3 now anyway
+      sample[i] = 0.0F;
+
+
+/* init sub-band transform */
+   sbt_init();
+
+   return 1;
+}
+/*---------------------------------------------------------*/
+void audio_decode_info(DEC_INFO * info)
+{
+   *info = decinfo;		/* info return, call after init */
+}
+/*---------------------------------------------------------*/
+void decode_table_init()
+{
+/* dummy for asm version compatability */
+}
+/*---------------------------------------------------------*/
+#endif	// #ifdef COMPILE_ME
+
diff --git a/code/mp3code/cupl1.c b/code/mp3code/cupl1.c
new file mode 100644
index 0000000..f3b664d
--- /dev/null
+++ b/code/mp3code/cupl1.c
@@ -0,0 +1,325 @@
+#pragma warning(disable:4206)	// nonstandard extension used : translation unit is empty
+#pragma warning(disable:4711)	// function 'xxxx' selected for automatic inline expansion
+#ifdef COMPILE_ME
+/*____________________________________________________________________________
+	
+	FreeAmp - The Free MP3 Player
+
+        MP3 Decoder originally Copyright (C) 1995-1997 Xing Technology
+        Corp.  http://www.xingtech.com
+
+	Portions Copyright (C) 1998-1999 EMusic.com
+
+	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., 675 Mass Ave, Cambridge, MA 02139, USA.
+	
+	$Id: cupL1.c,v 1.3 1999/10/19 07:13:08 elrod Exp $
+____________________________________________________________________________*/
+
+/****  cupL1.c  ***************************************************
+
+MPEG audio decoder Layer I mpeg1 and mpeg2
+
+include to clup.c
+
+
+******************************************************************/
+/*======================================================================*/
+static const int bat_bit_masterL1[] =
+{
+   0, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16
+};
+////@@@@static float *pMP3Stream->cs_factorL1 = &pMP3Stream->cs_factor[0];	// !!!!!!!!!!!!!!!!
+static float look_c_valueL1[16];	// effectively constant
+////@@@@static int nbatL1 = 32;
+
+/*======================================================================*/
+static void unpack_baL1()
+{
+   int j;
+   int nstereo;
+
+   pMP3Stream->bit_skip = 0;
+   nstereo = pMP3Stream->stereo_sb;
+
+   for (j = 0; j < pMP3Stream->nbatL1; j++)
+   {
+      mac_load_check(4);
+      ballo[j] = samp_dispatch[j] = mac_load(4);
+      if (j >= pMP3Stream->nsb_limit)
+		pMP3Stream->bit_skip += bat_bit_masterL1[samp_dispatch[j]];
+      c_value[j] = look_c_valueL1[samp_dispatch[j]];
+      if (--nstereo < 0)
+      {
+	 ballo[j + 1] = ballo[j];
+	 samp_dispatch[j] += 15;	/* flag as joint */
+	 samp_dispatch[j + 1] = samp_dispatch[j];	/* flag for sf */
+	 c_value[j + 1] = c_value[j];
+	 j++;
+      }
+   }
+/*-- terminate with bit skip and end --*/
+   samp_dispatch[pMP3Stream->nsb_limit] = 31;
+   samp_dispatch[j] = 30;
+}
+/*-------------------------------------------------------------------------*/
+static void unpack_sfL1(void)	/* unpack scale factor */
+{				/* combine dequant and scale factors */
+   int i;
+
+   for (i = 0; i < pMP3Stream->nbatL1; i++)
+   {
+      if (ballo[i])
+      {
+	 mac_load_check(6);
+	 pMP3Stream->cs_factorL1[i] = c_value[i] * sf_table[mac_load(6)];
+      }
+   }
+/*-- done --*/
+}
+/*-------------------------------------------------------------------------*/
+#define UNPACKL1_N(n) s[k]     =  pMP3Stream->cs_factorL1[k]*(load(n)-((1 << (n-1)) -1));  \
+    goto dispatch;
+#define UNPACKL1J_N(n) tmp        =  (load(n)-((1 << (n-1)) -1));                 \
+    s[k]       =  pMP3Stream->cs_factorL1[k]*tmp;                        \
+    s[k+1]     =  pMP3Stream->cs_factorL1[k+1]*tmp;                      \
+    k++;                                                     \
+    goto dispatch;
+/*-------------------------------------------------------------------------*/
+static void unpack_sampL1()	/* unpack samples */
+{
+   int j, k;
+   float *s;
+   long tmp;
+
+   s = sample;
+   for (j = 0; j < 12; j++)
+   {
+      k = -1;
+    dispatch:switch (samp_dispatch[++k])
+      {
+	 case 0:
+	    s[k] = 0.0F;
+	    goto dispatch;
+	 case 1:
+	    UNPACKL1_N(2)	/*  3 levels */
+	 case 2:
+	    UNPACKL1_N(3)	/*  7 levels */
+	 case 3:
+	    UNPACKL1_N(4)	/* 15 levels */
+	 case 4:
+	    UNPACKL1_N(5)	/* 31 levels */
+	 case 5:
+	    UNPACKL1_N(6)	/* 63 levels */
+	 case 6:
+	    UNPACKL1_N(7)	/* 127 levels */
+	 case 7:
+	    UNPACKL1_N(8)	/* 255 levels */
+	 case 8:
+	    UNPACKL1_N(9)	/* 511 levels */
+	 case 9:
+	    UNPACKL1_N(10)	/* 1023 levels */
+	 case 10:
+	    UNPACKL1_N(11)	/* 2047 levels */
+	 case 11:
+	    UNPACKL1_N(12)	/* 4095 levels */
+	 case 12:
+	    UNPACKL1_N(13)	/* 8191 levels */
+	 case 13:
+	    UNPACKL1_N(14)	/* 16383 levels */
+	 case 14:
+	    UNPACKL1_N(15)	/* 32767 levels */
+/* -- joint ---- */
+	 case 15 + 0:
+	    s[k + 1] = s[k] = 0.0F;
+	    k++;		/* skip right chan dispatch */
+	    goto dispatch;
+/* -- joint ---- */
+	 case 15 + 1:
+	    UNPACKL1J_N(2)	/*  3 levels */
+	 case 15 + 2:
+	    UNPACKL1J_N(3)	/*  7 levels */
+	 case 15 + 3:
+	    UNPACKL1J_N(4)	/* 15 levels */
+	 case 15 + 4:
+	    UNPACKL1J_N(5)	/* 31 levels */
+	 case 15 + 5:
+	    UNPACKL1J_N(6)	/* 63 levels */
+	 case 15 + 6:
+	    UNPACKL1J_N(7)	/* 127 levels */
+	 case 15 + 7:
+	    UNPACKL1J_N(8)	/* 255 levels */
+	 case 15 + 8:
+	    UNPACKL1J_N(9)	/* 511 levels */
+	 case 15 + 9:
+	    UNPACKL1J_N(10)	/* 1023 levels */
+	 case 15 + 10:
+	    UNPACKL1J_N(11)	/* 2047 levels */
+	 case 15 + 11:
+	    UNPACKL1J_N(12)	/* 4095 levels */
+	 case 15 + 12:
+	    UNPACKL1J_N(13)	/* 8191 levels */
+	 case 15 + 13:
+	    UNPACKL1J_N(14)	/* 16383 levels */
+	 case 15 + 14:
+	    UNPACKL1J_N(15)	/* 32767 levels */
+
+/* -- end of dispatch -- */
+	 case 31:
+	    skip(pMP3Stream->bit_skip);
+	 case 30:
+	    s += 64;
+      }				/* end switch */
+   }				/* end j loop */
+
+/*-- done --*/
+}
+/*-------------------------------------------------------------------*/
+IN_OUT L1audio_decode(unsigned char *bs, signed short *pcm)
+{
+   int sync, prot;
+   IN_OUT in_out;
+
+   load_init(bs);		/* initialize bit getter */
+/* test sync */
+   in_out.in_bytes = 0;		/* assume fail */
+   in_out.out_bytes = 0;
+   sync = load(12);
+   if (sync != 0xFFF)
+      return in_out;		/* sync fail */
+
+
+   load(3);			/* skip id and option (checked by init) */
+   prot = load(1);		/* load prot bit */
+   load(6);			/* skip to pad */
+   pMP3Stream->pad = (load(1)) << 2;
+   load(1);			/* skip to mode */
+   pMP3Stream->stereo_sb = look_joint[load(4)];
+   if (prot)
+      load(4);			/* skip to data */
+   else
+      load(20);			/* skip crc */
+
+   unpack_baL1();		/* unpack bit allocation */
+   unpack_sfL1();		/* unpack scale factor */
+   unpack_sampL1();		/* unpack samples */
+
+   pMP3Stream->sbt(sample, pcm, 12);
+/*-----------*/
+   in_out.in_bytes = pMP3Stream->framebytes + pMP3Stream->pad;
+   in_out.out_bytes = pMP3Stream->outbytes;
+
+   return in_out;
+}
+/*-------------------------------------------------------------------------*/
+int L1audio_decode_init(MPEG_HEAD * h, int framebytes_arg,
+		   int reduction_code, int transform_code, int convert_code,
+			int freq_limit)
+{
+   int i, k;
+   static int first_pass = 1;
+   long samprate;
+   int limit;
+   long step;
+   int bit_code;
+
+/*--- sf init done by layer II init ---*/
+   if (first_pass)
+   {
+      for (step = 4, i = 1; i < 16; i++, step <<= 1)
+	 look_c_valueL1[i] = (float) (2.0 / (step - 1));
+      first_pass = 0;
+   }
+   pMP3Stream->cs_factorL1 = pMP3Stream->cs_factor[0];
+
+   transform_code = transform_code;	/* not used, asm compatability */
+
+   bit_code = 0;
+   if (convert_code & 8)
+      bit_code = 1;
+   convert_code = convert_code & 3;	/* higher bits used by dec8 freq cvt */
+   if (reduction_code < 0)
+      reduction_code = 0;
+   if (reduction_code > 2)
+      reduction_code = 2;
+   if (freq_limit < 1000)
+      freq_limit = 1000;
+
+
+   pMP3Stream->framebytes = framebytes_arg;
+/* check if code handles */
+   if (h->option != 3)
+      return 0;			/* layer I only */
+
+   pMP3Stream->nbatL1 = 32;
+   pMP3Stream->max_sb = pMP3Stream->nbatL1;
+/*----- compute pMP3Stream->nsb_limit --------*/
+   samprate = sr_table[4 * h->id + h->sr_index];
+   pMP3Stream->nsb_limit = (freq_limit * 64L + samprate / 2) / samprate;
+/*- caller limit -*/
+/*---- limit = 0.94*(32>>reduction_code);  ----*/
+   limit = (32 >> reduction_code);
+   if (limit > 8)
+      limit--;
+   if (pMP3Stream->nsb_limit > limit)
+      pMP3Stream->nsb_limit = limit;
+   if (pMP3Stream->nsb_limit > pMP3Stream->max_sb)
+      pMP3Stream->nsb_limit = pMP3Stream->max_sb;
+
+   pMP3Stream->outvalues = 384 >> reduction_code;
+   if (h->mode != 3)
+   {				/* adjust for 2 channel modes */
+      pMP3Stream->nbatL1 *= 2;
+      pMP3Stream->max_sb *= 2;
+      pMP3Stream->nsb_limit *= 2;
+   }
+
+/* set sbt function */
+   k = 1 + convert_code;
+   if (h->mode == 3)
+   {
+      k = 0;
+   }
+   pMP3Stream->sbt = sbt_table[bit_code][reduction_code][k];
+   pMP3Stream->outvalues *= out_chans[k];
+
+   if (bit_code)
+      pMP3Stream->outbytes = pMP3Stream->outvalues;
+   else
+      pMP3Stream->outbytes = sizeof(short) * pMP3Stream->outvalues;
+
+   decinfo.channels = out_chans[k];
+   decinfo.outvalues = pMP3Stream->outvalues;
+   decinfo.samprate = samprate >> reduction_code;
+   if (bit_code)
+      decinfo.bits = 8;
+   else
+      decinfo.bits = sizeof(short) * 8;
+
+   decinfo.framebytes = pMP3Stream->framebytes;
+   decinfo.type = 0;
+
+
+/* clear sample buffer, unused sub bands must be 0 */
+   for (i = 0; i < 768; i++)
+      sample[i] = 0.0F;
+
+
+/* init sub-band transform */
+   sbt_init();
+
+   return 1;
+}
+/*---------------------------------------------------------*/
+#endif	// #ifdef COMPILE_ME
diff --git a/code/mp3code/cupl3.c b/code/mp3code/cupl3.c
new file mode 100644
index 0000000..e3cba5b
--- /dev/null
+++ b/code/mp3code/cupl3.c
@@ -0,0 +1,1287 @@
+/*____________________________________________________________________________
+	
+	FreeAmp - The Free MP3 Player
+
+        MP3 Decoder originally Copyright (C) 1995-1997 Xing Technology
+        Corp.  http://www.xingtech.com
+
+	Portions Copyright (C) 1998-1999 EMusic.com
+
+	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., 675 Mass Ave, Cambridge, MA 02139, USA.
+	
+	$Id: cupl3.c,v 1.8 1999/10/19 07:13:08 elrod Exp $
+____________________________________________________________________________*/
+
+/****  cupL3.c  ***************************************************
+unpack Layer III
+
+
+mod 8/18/97  bugfix crc problem
+
+mod 10/9/97  add pMP3Stream->band_limit12 for short blocks
+
+mod 10/22/97  zero buf_ptrs in init
+
+mod 5/15/98 mpeg 2.5
+
+mod 8/19/98 decode 22 sf bands
+
+******************************************************************/
+
+/*---------------------------------------
+TO DO: Test mixed blocks (mixed long/short)
+  No mixed blocks in mpeg-1 test stream being used for development
+
+-----------------------------------------*/
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <float.h>
+#include <math.h>
+#include <memory.h>
+#include <string.h>
+#include <assert.h>
+#include "mhead.h"		/* mpeg header structure */
+#include "L3.h"
+#include "jdw.h"
+
+#include "mp3struct.h"
+
+/*====================================================================*/
+static const int mp_sr20_table[2][4] =
+{{441, 480, 320, -999}, {882, 960, 640, -999}};
+static const int mp_br_tableL3[2][16] =
+{{0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160, 0},	/* mpeg 2 */
+ {0, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 0}};
+
+/*====================================================================*/
+
+/*-- global band tables */
+/*-- short portion is 3*x !! --*/
+////@@@@int nBand[2][22];		/* [long/short][cb] */		
+////@@@@int sfBandIndex[2][22];		/* [long/short][cb] */	
+
+/*====================================================================*/
+
+/*----------------*/
+extern DEC_INFO decinfo;	////@@@@ this is ok, only written to during init, then chucked.
+
+/*----------------*/
+////@@@@static int pMP3Stream->mpeg25_flag;		// L3 only
+
+//int iframe;
+
+/*-------*/
+////@@@@static int pMP3Stream->band_limit = (576);		// L3 only
+////@@@@static int pMP3Stream->band_limit21 = (576);	// limit for sf band 21	// L3 only
+////@@@@static int pMP3Stream->band_limit12 = (576);	// limit for sf band 12 short	//L3 only
+
+////@@@@int band_limit_nsb = 32;	/* global for hybrid */	
+////@@@@static int pMP3Stream->nsb_limit = 32;	
+////@@@@static int pMP3Stream->gain_adjust = 0;	/* adjust gain e.g. cvt to mono */	// L3 only
+////@@@@static int id; // L3 only
+////@@@@static int pMP3Stream->ncbl_mixed;		/* number of long cb's in mixed block 8 or 6 */		// L3 only
+////@@@@static int pMP3Stream->sr_index;	// L3 only (99%)
+
+//@@@@
+////@@@@static int pMP3Stream->outvalues;		//
+////@@@@static int pMP3Stream->outbytes;		//
+////@@@@static int pMP3Stream->half_outbytes;	// L3 only
+////@@@@static int pMP3Stream->framebytes;		//
+
+//static int padframebytes;
+////@@@@static int pMP3Stream->crcbytes;		// L3 only
+////@@@@static int pMP3Stream->pad;				//
+//static int stereo_flag;	// only written to
+////@@@@static int pMP3Stream->nchan;			// L3 only
+////@@@@static int pMP3Stream->ms_mode;			// L3 only (99%)
+////@@@@static int pMP3Stream->is_mode;			// L3 only
+////@@@@static unsigned int pMP3Stream->zero_level_pcm = 0;	// L3 only
+
+/* cb_info[igr][ch], compute by dequant, used by joint */
+static CB_INFO cb_info[2][2];	// L3 only	############ I think this is ok, only a scratchpad?
+static IS_SF_INFO is_sf_info;	/* MPEG-2 intensity stereo */	// L3 only	 ############## scratchpad?
+
+/*---------------------------------*/
+//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+/* main data bit buffer */
+/*@@@@
+#define NBUF (8*1024)
+#define BUF_TRIGGER (NBUF-1500)
+static unsigned char buf[NBUF];
+static int buf_ptr0 = 0;	// !!!!!!!!!!!
+static int buf_ptr1 = 0;	// !!!!!!!!!!!
+static int main_pos_bit;
+*/
+/*---------------------------------*/
+static SIDE_INFO side_info;		// ####### scratchpad?
+
+static SCALEFACT sf[2][2];	/* [gr][ch] */	 // ########## scratchpad?
+
+static int nsamp[2][2];		/* must start = 0, for nsamp[igr_prev] */	// ########## scratchpad?
+
+/*- sample union of int/float  sample[ch][gr][576] */
+/* static SAMPLE sample[2][2][576]; */
+// @@@@FINDME
+////@@@@extern SAMPLE sample[2][2][576];						////////////????? suspicious, mainly used in decode loop, but zeroed init code
+static float yout[576];		/* hybrid out, sbt in */	//////////// scratchpad
+
+////@@@@typedef void (*SBT_FUNCTION) (float *sample, short *pcm, int ch);
+void sbt_dual_L3(float *sample, short *pcm, int n);
+////@@@@static SBT_FUNCTION sbt_L3 = sbt_dual_L3;	// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+////@@@@typedef void (*XFORM_FUNCTION) (void *pcm, int igr);
+static void Xform_dual(void *pcm, int igr);
+////@@@@static XFORM_FUNCTION Xform = Xform_dual;	// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+IN_OUT L3audio_decode_MPEG1(unsigned char *bs, unsigned char *pcm);
+IN_OUT L3audio_decode_MPEG2(unsigned char *bs, unsigned char *pcm);
+////@@@@typedef IN_OUT(*DECODE_FUNCTION) (unsigned char *bs, unsigned char *pcm);
+////@@@@static DECODE_FUNCTION decode_function = L3audio_decode_MPEG1;		<------------------ needs streaming, ditto above!!!
+
+
+/*====================================================================*/
+int hybrid(void *xin, void *xprev, float *y,
+	   int btype, int nlong, int ntot, int nprev);
+int hybrid_sum(void *xin, void *xin_left, float *y,
+	       int btype, int nlong, int ntot);
+void sum_f_bands(void *a, void *b, int n);
+void FreqInvert(float *y, int n);
+void antialias(void *x, int n);
+void ms_process(void *x, int n);	/* sum-difference stereo */
+void is_process_MPEG1(void *x,	/* intensity stereo */
+		      SCALEFACT * sf,
+		      CB_INFO cb_info[2],	/* [ch] */
+		      int nsamp, int ms_mode);
+void is_process_MPEG2(void *x,	/* intensity stereo */
+		      SCALEFACT * sf,
+		      CB_INFO cb_info[2],	/* [ch] */
+		      IS_SF_INFO * is_sf_info,
+		      int nsamp, int ms_mode);
+
+void unpack_huff(void *xy, int n, int ntable);
+int unpack_huff_quad(void *vwxy, int n, int nbits, int ntable);
+void dequant(SAMPLE sample[], int *nsamp,
+	     SCALEFACT * sf,
+	     GR * gr,
+	     CB_INFO * cb_info, int ncbl_mixed);
+void unpack_sf_sub_MPEG1(SCALEFACT * scalefac, GR * gr,
+			 int scfsi,	/* bit flag */
+			 int igr);
+void unpack_sf_sub_MPEG2(SCALEFACT sf[],	/* return intensity scale */
+			 GR * grdat,
+			 int is_and_ch, IS_SF_INFO * is_sf_info);
+
+/*====================================================================*/
+/* get bits from bitstream in endian independent way */
+
+BITDAT bitdat;			/* global for inline use by Huff */		// !!!!!!!!!!!!!!!!!!!
+
+/*------------- initialize bit getter -------------*/
+static void bitget_init(unsigned char *buf)
+{
+   bitdat.bs_ptr0 = bitdat.bs_ptr = buf;
+   bitdat.bits = 0;
+   bitdat.bitbuf = 0;
+}
+/*------------- initialize bit getter -------------*/
+static void bitget_init_end(unsigned char *buf_end)
+{
+   bitdat.bs_ptr_end = buf_end;
+}
+/*------------- get n bits from bitstream -------------*/
+int bitget_bits_used()
+{
+   int n;			/* compute bits used from last init call */
+
+   n = ((bitdat.bs_ptr - bitdat.bs_ptr0) << 3) - bitdat.bits;
+   return n;
+}
+/*------------- check for n bits in bitbuf -------------*/
+void bitget_check(int n)
+{
+   if (bitdat.bits < n)
+   {
+      while (bitdat.bits <= 24)
+      {
+	 bitdat.bitbuf = (bitdat.bitbuf << 8) | *bitdat.bs_ptr++;
+	 bitdat.bits += 8;
+      }
+   }
+}
+/*------------- get n bits from bitstream -------------*/
+unsigned int bitget(int n)
+{
+   unsigned int x;
+
+   if (bitdat.bits < n)
+   {				/* refill bit buf if necessary */
+      while (bitdat.bits <= 24)
+      {
+	 bitdat.bitbuf = (bitdat.bitbuf << 8) | *bitdat.bs_ptr++;
+	 bitdat.bits += 8;
+      }
+   }
+   bitdat.bits -= n;
+   x = bitdat.bitbuf >> bitdat.bits;
+   bitdat.bitbuf -= x << bitdat.bits;
+   return x;
+}
+/*------------- get 1 bit from bitstream -------------*/
+unsigned int bitget_1bit()
+{
+   unsigned int x;
+
+   if (bitdat.bits <= 0)
+   {				/* refill bit buf if necessary */
+      while (bitdat.bits <= 24)
+      {
+	 bitdat.bitbuf = (bitdat.bitbuf << 8) | *bitdat.bs_ptr++;
+	 bitdat.bits += 8;
+      }
+   }
+   bitdat.bits--;
+   x = bitdat.bitbuf >> bitdat.bits;
+   bitdat.bitbuf -= x << bitdat.bits;
+   return x;
+}
+/*====================================================================*/
+static void Xform_mono(void *pcm, int igr)
+{
+   int igr_prev, n1, n2;
+
+/*--- hybrid + sbt ---*/
+   n1 = n2 = nsamp[igr][0];	/* total number bands */
+   if (side_info.gr[igr][0].block_type == 2)
+   {				/* long bands */
+      n1 = 0;
+      if (side_info.gr[igr][0].mixed_block_flag)
+	 n1 = pMP3Stream->sfBandIndex[0][pMP3Stream->ncbl_mixed - 1];
+   }
+   if (n1 > pMP3Stream->band_limit)
+      n1 = pMP3Stream->band_limit;
+   if (n2 > pMP3Stream->band_limit)
+      n2 = pMP3Stream->band_limit;
+   igr_prev = igr ^ 1;
+
+   nsamp[igr][0] = hybrid(pMP3Stream->sample[0][igr], pMP3Stream->sample[0][igr_prev],
+	 yout, side_info.gr[igr][0].block_type, n1, n2, nsamp[igr_prev][0]);
+   FreqInvert(yout, nsamp[igr][0]);
+   pMP3Stream->sbt_L3(yout, pcm, 0);
+
+}
+/*--------------------------------------------------------------------*/
+static void Xform_dual_right(void *pcm, int igr)
+{
+   int igr_prev, n1, n2;
+
+/*--- hybrid + sbt ---*/
+   n1 = n2 = nsamp[igr][1];	/* total number bands */
+   if (side_info.gr[igr][1].block_type == 2)
+   {				/* long bands */
+      n1 = 0;
+      if (side_info.gr[igr][1].mixed_block_flag)
+	 n1 = pMP3Stream->sfBandIndex[0][pMP3Stream->ncbl_mixed - 1];
+   }
+   if (n1 > pMP3Stream->band_limit)
+      n1 = pMP3Stream->band_limit;
+   if (n2 > pMP3Stream->band_limit)
+      n2 = pMP3Stream->band_limit;
+   igr_prev = igr ^ 1;
+   nsamp[igr][1] = hybrid(pMP3Stream->sample[1][igr], pMP3Stream->sample[1][igr_prev],
+	 yout, side_info.gr[igr][1].block_type, n1, n2, nsamp[igr_prev][1]);
+   FreqInvert(yout, nsamp[igr][1]);
+   pMP3Stream->sbt_L3(yout, pcm, 0);
+
+}
+/*--------------------------------------------------------------------*/
+static void Xform_dual(void *pcm, int igr)
+{
+   int ch;
+   int igr_prev, n1, n2;
+
+/*--- hybrid + sbt ---*/
+   igr_prev = igr ^ 1;
+   for (ch = 0; ch < pMP3Stream->nchan; ch++)
+   {
+      n1 = n2 = nsamp[igr][ch];	/* total number bands */
+      if (side_info.gr[igr][ch].block_type == 2)
+      {				/* long bands */
+	 n1 = 0;
+	 if (side_info.gr[igr][ch].mixed_block_flag)
+	    n1 = pMP3Stream->sfBandIndex[0][pMP3Stream->ncbl_mixed - 1];
+      }
+      if (n1 > pMP3Stream->band_limit)
+	 n1 = pMP3Stream->band_limit;
+      if (n2 > pMP3Stream->band_limit)
+	 n2 = pMP3Stream->band_limit;
+      nsamp[igr][ch] = hybrid(pMP3Stream->sample[ch][igr], pMP3Stream->sample[ch][igr_prev],
+       yout, side_info.gr[igr][ch].block_type, n1, n2, nsamp[igr_prev][ch]);
+      FreqInvert(yout, nsamp[igr][ch]);
+      pMP3Stream->sbt_L3(yout, pcm, ch);
+   }
+
+}
+/*--------------------------------------------------------------------*/
+static void Xform_dual_mono(void *pcm, int igr)
+{
+   int igr_prev, n1, n2, n3;
+
+/*--- hybrid + sbt ---*/
+   igr_prev = igr ^ 1;
+   if ((side_info.gr[igr][0].block_type == side_info.gr[igr][1].block_type)
+       && (side_info.gr[igr][0].mixed_block_flag == 0)
+       && (side_info.gr[igr][1].mixed_block_flag == 0))
+   {
+
+      n2 = nsamp[igr][0];	/* total number bands max of L R */
+      if (n2 < nsamp[igr][1])
+	 n2 = nsamp[igr][1];
+      if (n2 > pMP3Stream->band_limit)
+	 n2 = pMP3Stream->band_limit;
+      n1 = n2;			/* n1 = number long bands */
+      if (side_info.gr[igr][0].block_type == 2)
+	 n1 = 0;
+      sum_f_bands(pMP3Stream->sample[0][igr], pMP3Stream->sample[1][igr], n2);
+      n3 = nsamp[igr][0] = hybrid(pMP3Stream->sample[0][igr], pMP3Stream->sample[0][igr_prev],
+	 yout, side_info.gr[igr][0].block_type, n1, n2, nsamp[igr_prev][0]);
+   }
+   else
+   {				/* transform and then sum (not tested - never happens in test) */
+/*-- left chan --*/
+      n1 = n2 = nsamp[igr][0];	/* total number bands */
+      if (side_info.gr[igr][0].block_type == 2)
+      {
+	 n1 = 0;		/* long bands */
+	 if (side_info.gr[igr][0].mixed_block_flag)
+	    n1 = pMP3Stream->sfBandIndex[0][pMP3Stream->ncbl_mixed - 1];
+      }
+      n3 = nsamp[igr][0] = hybrid(pMP3Stream->sample[0][igr], pMP3Stream->sample[0][igr_prev],
+	 yout, side_info.gr[igr][0].block_type, n1, n2, nsamp[igr_prev][0]);
+/*-- right chan --*/
+      n1 = n2 = nsamp[igr][1];	/* total number bands */
+      if (side_info.gr[igr][1].block_type == 2)
+      {
+	 n1 = 0;		/* long bands */
+	 if (side_info.gr[igr][1].mixed_block_flag)
+	    n1 = pMP3Stream->sfBandIndex[0][pMP3Stream->ncbl_mixed - 1];
+      }
+      nsamp[igr][1] = hybrid_sum(pMP3Stream->sample[1][igr], pMP3Stream->sample[0][igr],
+			     yout, side_info.gr[igr][1].block_type, n1, n2);
+      if (n3 < nsamp[igr][1])
+	 n1 = nsamp[igr][1];
+   }
+
+/*--------*/
+   FreqInvert(yout, n3);
+   pMP3Stream->sbt_L3(yout, pcm, 0);
+
+}
+/*--------------------------------------------------------------------*/
+/*====================================================================*/
+static int unpack_side_MPEG1()
+{
+   int prot;
+   int br_index;
+   int igr, ch;
+   int side_bytes;
+
+/* decode partial header plus initial side info */
+/* at entry bit getter points at id, sync skipped by caller */
+
+   pMP3Stream->id = bitget(1);		/* id */
+   bitget(2);			/* skip layer */
+   prot = bitget(1);		/* bitget prot bit */
+   br_index = bitget(4);
+   pMP3Stream->sr_index = bitget(2);
+   pMP3Stream->pad = bitget(1);
+   bitget(1);			/* skip to mode */
+   side_info.mode = bitget(2);	/* mode */
+   side_info.mode_ext = bitget(2);	/* mode ext */
+
+   if (side_info.mode != 1)
+      side_info.mode_ext = 0;
+
+/* adjust global gain in ms mode to avoid having to mult by 1/sqrt(2) */
+   pMP3Stream->ms_mode = side_info.mode_ext >> 1;
+   pMP3Stream->is_mode = side_info.mode_ext & 1;
+
+
+   pMP3Stream->crcbytes = 0;
+   if (prot)
+      bitget(4);		/* skip to data */
+   else
+   {
+      bitget(20);		/* skip crc */
+      pMP3Stream->crcbytes = 2;
+   }
+
+   if (br_index > 0)		/* pMP3Stream->framebytes fixed for free format */
+	{
+      pMP3Stream->framebytes =
+	 2880 * mp_br_tableL3[pMP3Stream->id][br_index] / mp_sr20_table[pMP3Stream->id][pMP3Stream->sr_index];
+   }
+
+   side_info.main_data_begin = bitget(9);
+   if (side_info.mode == 3)
+   {
+      side_info.private_bits = bitget(5);
+      pMP3Stream->nchan = 1;
+//      stereo_flag = 0;
+      side_bytes = (4 + 17);
+/*-- with header --*/
+   }
+   else
+   {
+      side_info.private_bits = bitget(3);
+      pMP3Stream->nchan = 2;
+//      stereo_flag = 1;
+      side_bytes = (4 + 32);
+/*-- with header --*/
+   }
+   for (ch = 0; ch < pMP3Stream->nchan; ch++)
+      side_info.scfsi[ch] = bitget(4);
+/* this always 0 (both igr) for short blocks */
+
+   for (igr = 0; igr < 2; igr++)
+   {
+      for (ch = 0; ch < pMP3Stream->nchan; ch++)
+      {
+	 side_info.gr[igr][ch].part2_3_length = bitget(12);
+	 side_info.gr[igr][ch].big_values = bitget(9);
+	 side_info.gr[igr][ch].global_gain = bitget(8) + pMP3Stream->gain_adjust;
+	 if (pMP3Stream->ms_mode)
+	    side_info.gr[igr][ch].global_gain -= 2;
+	 side_info.gr[igr][ch].scalefac_compress = bitget(4);
+	 side_info.gr[igr][ch].window_switching_flag = bitget(1);
+	 if (side_info.gr[igr][ch].window_switching_flag)
+	 {
+	    side_info.gr[igr][ch].block_type = bitget(2);
+	    side_info.gr[igr][ch].mixed_block_flag = bitget(1);
+	    side_info.gr[igr][ch].table_select[0] = bitget(5);
+	    side_info.gr[igr][ch].table_select[1] = bitget(5);
+	    side_info.gr[igr][ch].subblock_gain[0] = bitget(3);
+	    side_info.gr[igr][ch].subblock_gain[1] = bitget(3);
+	    side_info.gr[igr][ch].subblock_gain[2] = bitget(3);
+	  /* region count set in terms of long block cb's/bands */
+	  /* r1 set so r0+r1+1 = 21 (lookup produces 576 bands ) */
+	  /* if(window_switching_flag) always 36 samples in region0 */
+	    side_info.gr[igr][ch].region0_count = (8 - 1);	/* 36 samples */
+	    side_info.gr[igr][ch].region1_count = 20 - (8 - 1);
+	 }
+	 else
+	 {
+	    side_info.gr[igr][ch].mixed_block_flag = 0;
+	    side_info.gr[igr][ch].block_type = 0;
+	    side_info.gr[igr][ch].table_select[0] = bitget(5);
+	    side_info.gr[igr][ch].table_select[1] = bitget(5);
+	    side_info.gr[igr][ch].table_select[2] = bitget(5);
+	    side_info.gr[igr][ch].region0_count = bitget(4);
+	    side_info.gr[igr][ch].region1_count = bitget(3);
+	 }
+	 side_info.gr[igr][ch].preflag = bitget(1);
+	 side_info.gr[igr][ch].scalefac_scale = bitget(1);
+	 side_info.gr[igr][ch].count1table_select = bitget(1);
+      }
+   }
+
+
+
+/* return  bytes in header + side info */
+   return side_bytes;
+}
+/*====================================================================*/
+static int unpack_side_MPEG2(int igr)
+{
+   int prot;
+   int br_index;
+   int ch;
+   int side_bytes;
+
+/* decode partial header plus initial side info */
+/* at entry bit getter points at id, sync skipped by caller */
+
+   pMP3Stream->id = bitget(1);		/* id */
+   bitget(2);			/* skip layer */
+   prot = bitget(1);		/* bitget prot bit */
+   br_index = bitget(4);
+   pMP3Stream->sr_index = bitget(2);
+   pMP3Stream->pad = bitget(1);
+   bitget(1);			/* skip to mode */
+   side_info.mode = bitget(2);	/* mode */
+   side_info.mode_ext = bitget(2);	/* mode ext */
+
+   if (side_info.mode != 1)
+      side_info.mode_ext = 0;
+
+/* adjust global gain in ms mode to avoid having to mult by 1/sqrt(2) */
+   pMP3Stream->ms_mode = side_info.mode_ext >> 1;
+   pMP3Stream->is_mode = side_info.mode_ext & 1;
+
+   pMP3Stream->crcbytes = 0;
+   if (prot)
+      bitget(4);		/* skip to data */
+   else
+   {
+      bitget(20);		/* skip crc */
+      pMP3Stream->crcbytes = 2;
+   }
+
+   if (br_index > 0)
+   {				/* pMP3Stream->framebytes fixed for free format */
+      if (pMP3Stream->mpeg25_flag == 0)
+      {
+	 pMP3Stream->framebytes =
+	    1440 * mp_br_tableL3[pMP3Stream->id][br_index] / mp_sr20_table[pMP3Stream->id][pMP3Stream->sr_index];
+      }
+      else
+      {
+	 pMP3Stream->framebytes =
+	    2880 * mp_br_tableL3[pMP3Stream->id][br_index] / mp_sr20_table[pMP3Stream->id][pMP3Stream->sr_index];
+       //if( pMP3Stream->sr_index == 2 ) return 0;  // fail mpeg25 8khz
+      }
+   }
+   side_info.main_data_begin = bitget(8);
+   if (side_info.mode == 3)
+   {
+      side_info.private_bits = bitget(1);
+      pMP3Stream->nchan = 1;
+//      stereo_flag = 0;
+      side_bytes = (4 + 9);
+/*-- with header --*/
+   }
+   else
+   {
+      side_info.private_bits = bitget(2);
+      pMP3Stream->nchan = 2;
+//      stereo_flag = 1;
+      side_bytes = (4 + 17);
+/*-- with header --*/
+   }
+   side_info.scfsi[1] = side_info.scfsi[0] = 0;
+
+
+   for (ch = 0; ch < pMP3Stream->nchan; ch++)
+   {
+      side_info.gr[igr][ch].part2_3_length = bitget(12);
+      side_info.gr[igr][ch].big_values = bitget(9);
+      side_info.gr[igr][ch].global_gain = bitget(8) + pMP3Stream->gain_adjust;
+      if (pMP3Stream->ms_mode)
+	 side_info.gr[igr][ch].global_gain -= 2;
+      side_info.gr[igr][ch].scalefac_compress = bitget(9);
+      side_info.gr[igr][ch].window_switching_flag = bitget(1);
+      if (side_info.gr[igr][ch].window_switching_flag)
+      {
+	 side_info.gr[igr][ch].block_type = bitget(2);
+	 side_info.gr[igr][ch].mixed_block_flag = bitget(1);
+	 side_info.gr[igr][ch].table_select[0] = bitget(5);
+	 side_info.gr[igr][ch].table_select[1] = bitget(5);
+	 side_info.gr[igr][ch].subblock_gain[0] = bitget(3);
+	 side_info.gr[igr][ch].subblock_gain[1] = bitget(3);
+	 side_info.gr[igr][ch].subblock_gain[2] = bitget(3);
+       /* region count set in terms of long block cb's/bands  */
+       /* r1 set so r0+r1+1 = 21 (lookup produces 576 bands ) */
+       /* bt=1 or 3       54 samples */
+       /* bt=2 mixed=0    36 samples */
+       /* bt=2 mixed=1    54 (8 long sf) samples? or maybe 36 */
+       /* region0 discussion says 54 but this would mix long */
+       /* and short in region0 if scale factors switch */
+       /* at band 36 (6 long scale factors) */
+	 if ((side_info.gr[igr][ch].block_type == 2))
+	 {
+	    side_info.gr[igr][ch].region0_count = (6 - 1);	/* 36 samples */
+	    side_info.gr[igr][ch].region1_count = 20 - (6 - 1);
+	 }
+	 else
+	 {			/* long block type 1 or 3 */
+	    side_info.gr[igr][ch].region0_count = (8 - 1);	/* 54 samples */
+	    side_info.gr[igr][ch].region1_count = 20 - (8 - 1);
+	 }
+      }
+      else
+      {
+	 side_info.gr[igr][ch].mixed_block_flag = 0;
+	 side_info.gr[igr][ch].block_type = 0;
+	 side_info.gr[igr][ch].table_select[0] = bitget(5);
+	 side_info.gr[igr][ch].table_select[1] = bitget(5);
+	 side_info.gr[igr][ch].table_select[2] = bitget(5);
+	 side_info.gr[igr][ch].region0_count = bitget(4);
+	 side_info.gr[igr][ch].region1_count = bitget(3);
+      }
+      side_info.gr[igr][ch].preflag = 0;
+      side_info.gr[igr][ch].scalefac_scale = bitget(1);
+      side_info.gr[igr][ch].count1table_select = bitget(1);
+   }
+
+/* return  bytes in header + side info */
+   return side_bytes;
+}
+/*-----------------------------------------------------------------*/
+static void unpack_main(unsigned char *pcm, int igr)
+{
+   int ch;
+   int bit0;
+   int n1, n2, n3, n4, nn2, nn3;
+   int nn4;
+   int qbits;
+   int m0;
+
+
+   for (ch = 0; ch < pMP3Stream->nchan; ch++)
+   {
+      bitget_init(pMP3Stream->buf + (pMP3Stream->main_pos_bit >> 3));
+      bit0 = (pMP3Stream->main_pos_bit & 7);
+      if (bit0)
+	 bitget(bit0);
+      pMP3Stream->main_pos_bit += side_info.gr[igr][ch].part2_3_length;
+      bitget_init_end(pMP3Stream->buf + ((pMP3Stream->main_pos_bit + 39) >> 3));
+/*-- scale factors --*/
+      if (pMP3Stream->id)
+	 unpack_sf_sub_MPEG1(&sf[igr][ch],
+			  &side_info.gr[igr][ch], side_info.scfsi[ch], igr);
+      else
+	 unpack_sf_sub_MPEG2(&sf[igr][ch],
+			 &side_info.gr[igr][ch], pMP3Stream->is_mode & ch, &is_sf_info);
+/*--- huff data ---*/
+      n1 = pMP3Stream->sfBandIndex[0][side_info.gr[igr][ch].region0_count];
+      n2 = pMP3Stream->sfBandIndex[0][side_info.gr[igr][ch].region0_count
+			  + side_info.gr[igr][ch].region1_count + 1];
+      n3 = side_info.gr[igr][ch].big_values;
+      n3 = n3 + n3;
+
+
+      if (n3 > pMP3Stream->band_limit)
+	 n3 = pMP3Stream->band_limit;
+      if (n2 > n3)
+	 n2 = n3;
+      if (n1 > n3)
+	 n1 = n3;
+      nn3 = n3 - n2;
+      nn2 = n2 - n1;
+      unpack_huff(pMP3Stream->sample[ch][igr], n1, side_info.gr[igr][ch].table_select[0]);
+      unpack_huff(pMP3Stream->sample[ch][igr] + n1, nn2, side_info.gr[igr][ch].table_select[1]);
+      unpack_huff(pMP3Stream->sample[ch][igr] + n2, nn3, side_info.gr[igr][ch].table_select[2]);
+      qbits = side_info.gr[igr][ch].part2_3_length - (bitget_bits_used() - bit0);
+      nn4 = unpack_huff_quad(pMP3Stream->sample[ch][igr] + n3, pMP3Stream->band_limit - n3, qbits,
+			     side_info.gr[igr][ch].count1table_select);
+      n4 = n3 + nn4;
+      nsamp[igr][ch] = n4;
+    //limit n4 or allow deqaunt to sf band 22
+      if (side_info.gr[igr][ch].block_type == 2)
+	 n4 = min(n4, pMP3Stream->band_limit12);
+      else
+	 n4 = min(n4, pMP3Stream->band_limit21);
+      if (n4 < 576)
+	 memset(pMP3Stream->sample[ch][igr] + n4, 0, sizeof(SAMPLE) * (576 - n4));
+      if (bitdat.bs_ptr > bitdat.bs_ptr_end)
+      {				// bad data overrun
+
+	 memset(pMP3Stream->sample[ch][igr], 0, sizeof(SAMPLE) * (576));
+      }
+   }
+
+
+
+/*--- dequant ---*/
+   for (ch = 0; ch < pMP3Stream->nchan; ch++)
+   {
+      dequant(pMP3Stream->sample[ch][igr],
+	      &nsamp[igr][ch],	/* nsamp updated for shorts */
+	      &sf[igr][ch], &side_info.gr[igr][ch],
+	      &cb_info[igr][ch], pMP3Stream->ncbl_mixed);
+   }
+
+/*--- ms stereo processing  ---*/
+   if (pMP3Stream->ms_mode)
+   {
+      if (pMP3Stream->is_mode == 0)
+      {
+	 m0 = nsamp[igr][0];	/* process to longer of left/right */
+	 if (m0 < nsamp[igr][1])
+	    m0 = nsamp[igr][1];
+      }
+      else
+      {				/* process to last cb in right */
+	 m0 = pMP3Stream->sfBandIndex[cb_info[igr][1].cbtype][cb_info[igr][1].cbmax];
+      }
+      ms_process(pMP3Stream->sample[0][igr], m0);
+   }
+
+/*--- is stereo processing  ---*/
+   if (pMP3Stream->is_mode)
+   {
+      if (pMP3Stream->id)
+	 is_process_MPEG1(pMP3Stream->sample[0][igr], &sf[igr][1],
+			  cb_info[igr], nsamp[igr][0], pMP3Stream->ms_mode);
+      else
+	 is_process_MPEG2(pMP3Stream->sample[0][igr], &sf[igr][1],
+			  cb_info[igr], &is_sf_info,
+			  nsamp[igr][0], pMP3Stream->ms_mode);
+   }
+
+/*-- adjust ms and is modes to max of left/right */
+   if (side_info.mode_ext)
+   {
+      if (nsamp[igr][0] < nsamp[igr][1])
+	 nsamp[igr][0] = nsamp[igr][1];
+      else
+	 nsamp[igr][1] = nsamp[igr][0];
+   }
+
+/*--- antialias ---*/
+   for (ch = 0; ch < pMP3Stream->nchan; ch++)
+   {
+      if (cb_info[igr][ch].ncbl == 0)
+	 continue;		/* have no long blocks */
+      if (side_info.gr[igr][ch].mixed_block_flag)
+	 n1 = 1;		/* 1 -> 36 samples */
+      else
+	 n1 = (nsamp[igr][ch] + 7) / 18;
+      if (n1 > 31)
+	 n1 = 31;
+      antialias(pMP3Stream->sample[ch][igr], n1);
+      n1 = 18 * n1 + 8;		/* update number of samples */
+      if (n1 > nsamp[igr][ch])
+	 nsamp[igr][ch] = n1;
+   }
+
+
+
+/*--- hybrid + sbt ---*/
+   pMP3Stream->Xform(pcm, igr);
+
+
+/*-- done --*/
+}
+/*--------------------------------------------------------------------*/
+/*-----------------------------------------------------------------*/
+IN_OUT L3audio_decode(unsigned char *bs, unsigned char *pcm)
+{
+   return pMP3Stream->decode_function(bs, pcm);
+}
+
+/*--------------------------------------------------------------------*/
+extern unsigned char *gpNextByteAfterData;
+IN_OUT L3audio_decode_MPEG1(unsigned char *bs, unsigned char *pcm)
+{
+   int sync;
+   IN_OUT in_out;
+   int side_bytes;
+   int nbytes;
+
+   int padframebytes;	////@@@@
+   
+//   iframe++;
+
+   bitget_init(bs);		/* initialize bit getter */
+/* test sync */
+   in_out.in_bytes = 0;		/* assume fail */
+   in_out.out_bytes = 0;
+   sync = bitget(12);
+
+   if (sync != 0xFFF)
+      return in_out;		/* sync fail */
+/*-----------*/
+
+/*-- unpack side info --*/
+   side_bytes = unpack_side_MPEG1();
+   padframebytes = pMP3Stream->framebytes + pMP3Stream->pad;
+
+   if (bs + padframebytes > gpNextByteAfterData)
+	   return in_out;	// error check if we're about to read off the end of the legal memory (caused by certain MP3 writers' goofy comment formats) -ste.
+   in_out.in_bytes = padframebytes;
+
+/*-- load main data and update buf pointer --*/
+/*------------------------------------------- 
+   if start point < 0, must just cycle decoder 
+   if jumping into middle of stream, 
+w---------------------------------------------*/
+   pMP3Stream->buf_ptr0 = pMP3Stream->buf_ptr1 - side_info.main_data_begin;	/* decode start point */
+   if (pMP3Stream->buf_ptr1 > BUF_TRIGGER)
+   {				/* shift buffer */
+      memmove(pMP3Stream->buf, pMP3Stream->buf + pMP3Stream->buf_ptr0, side_info.main_data_begin);
+      pMP3Stream->buf_ptr0 = 0;
+      pMP3Stream->buf_ptr1 = side_info.main_data_begin;
+   }
+   nbytes = padframebytes - side_bytes - pMP3Stream->crcbytes;
+
+   // RAK: This is no bueno. :-(
+	if (nbytes < 0 || nbytes > NBUF)
+	{
+	    in_out.in_bytes = 0;
+		 return in_out;
+   }
+
+	if (bFastEstimateOnly)
+	{
+		in_out.out_bytes = pMP3Stream->outbytes;
+		return in_out;
+	}
+
+   memmove(pMP3Stream->buf + pMP3Stream->buf_ptr1, bs + side_bytes + pMP3Stream->crcbytes, nbytes);
+   pMP3Stream->buf_ptr1 += nbytes;
+/*-----------------------*/
+
+   if (pMP3Stream->buf_ptr0 >= 0)
+   {
+// dump_frame(buf+buf_ptr0, 64);
+      pMP3Stream->main_pos_bit = pMP3Stream->buf_ptr0 << 3;
+      unpack_main(pcm, 0);
+      unpack_main(pcm + pMP3Stream->half_outbytes, 1);
+      in_out.out_bytes = pMP3Stream->outbytes;
+   }
+   else
+   {
+      memset(pcm, pMP3Stream->zero_level_pcm, pMP3Stream->outbytes);	/* fill out skipped frames */
+      in_out.out_bytes = pMP3Stream->outbytes;
+/* iframe--;  in_out.out_bytes = 0;  // test test */
+   }
+
+   return in_out;
+}
+/*--------------------------------------------------------------------*/
+/*--------------------------------------------------------------------*/
+IN_OUT L3audio_decode_MPEG2(unsigned char *bs, unsigned char *pcm)
+{
+   int sync;
+   IN_OUT in_out;
+   int side_bytes;
+   int nbytes;
+   static int igr = 0;
+
+   int padframebytes;	////@@@@
+
+//   iframe++;
+
+
+   bitget_init(bs);		/* initialize bit getter */
+/* test sync */
+   in_out.in_bytes = 0;		/* assume fail */
+   in_out.out_bytes = 0;
+   sync = bitget(12);
+
+// if( sync != 0xFFF ) return in_out;       /* sync fail */
+
+   pMP3Stream->mpeg25_flag = 0;
+   if (sync != 0xFFF)
+   {
+      pMP3Stream->mpeg25_flag = 1;		/* mpeg 2.5 sync */
+      if (sync != 0xFFE)
+	 return in_out;		/* sync fail */
+   }
+/*-----------*/
+
+
+/*-- unpack side info --*/
+   side_bytes = unpack_side_MPEG2(igr);
+   padframebytes = pMP3Stream->framebytes + pMP3Stream->pad;
+   in_out.in_bytes = padframebytes;
+
+   pMP3Stream->buf_ptr0 = pMP3Stream->buf_ptr1 - side_info.main_data_begin;	/* decode start point */
+   if (pMP3Stream->buf_ptr1 > BUF_TRIGGER)
+   {				/* shift buffer */
+      memmove(pMP3Stream->buf, pMP3Stream->buf + pMP3Stream->buf_ptr0, side_info.main_data_begin);
+      pMP3Stream->buf_ptr0 = 0;
+      pMP3Stream->buf_ptr1 = side_info.main_data_begin;
+   }
+   nbytes = padframebytes - side_bytes - pMP3Stream->crcbytes;
+   // RAK: This is no bueno. :-(
+	if (nbytes < 0 || nbytes > NBUF)
+	{
+	    in_out.in_bytes = 0;
+		 return in_out;
+   }
+
+	if (bFastEstimateOnly)
+	{
+		in_out.out_bytes = pMP3Stream->outbytes;
+		return in_out;
+	}
+
+   memmove(pMP3Stream->buf + pMP3Stream->buf_ptr1, bs + side_bytes + pMP3Stream->crcbytes, nbytes);
+   pMP3Stream->buf_ptr1 += nbytes;
+/*-----------------------*/
+
+   if (pMP3Stream->buf_ptr0 >= 0)
+   {
+      pMP3Stream->main_pos_bit = pMP3Stream->buf_ptr0 << 3;
+      unpack_main(pcm, igr);
+      in_out.out_bytes = pMP3Stream->outbytes;
+   }
+   else
+   {
+      memset(pcm, pMP3Stream->zero_level_pcm, pMP3Stream->outbytes);	/* fill out skipped frames */
+      in_out.out_bytes = pMP3Stream->outbytes;
+// iframe--;  in_out.out_bytes = 0; return in_out;// test test */
+   }
+
+
+
+   igr = igr ^ 1;
+   return in_out;
+}
+/*--------------------------------------------------------------------*/
+/*--------------------------------------------------------------------*/
+/*--------------------------------------------------------------------*/
+static const int sr_table[8] =
+{22050, 24000, 16000, 1,
+ 44100, 48000, 32000, 1};
+
+static const struct
+{
+   int l[23];
+   int s[14];
+}
+sfBandIndexTable[3][3] =
+{
+/* mpeg-2 */
+   {
+      {
+	 {
+	    0, 6, 12, 18, 24, 30, 36, 44, 54, 66, 80, 96, 116, 140, 168, 200, 238, 284, 336, 396, 464, 522, 576
+	 }
+	 ,
+	 {
+	    0, 4, 8, 12, 18, 24, 32, 42, 56, 74, 100, 132, 174, 192
+	 }
+      }
+      ,
+      {
+	 {
+	    0, 6, 12, 18, 24, 30, 36, 44, 54, 66, 80, 96, 114, 136, 162, 194, 232, 278, 332, 394, 464, 540, 576
+	 }
+	 ,
+	 {
+	    0, 4, 8, 12, 18, 26, 36, 48, 62, 80, 104, 136, 180, 192
+	 }
+      }
+      ,
+      {
+	 {
+	    0, 6, 12, 18, 24, 30, 36, 44, 54, 66, 80, 96, 116, 140, 168, 200, 238, 284, 336, 396, 464, 522, 576
+	 }
+	 ,
+	 {
+	    0, 4, 8, 12, 18, 26, 36, 48, 62, 80, 104, 134, 174, 192
+	 }
+      }
+      ,
+   }
+   ,
+/* mpeg-1 */
+   {
+      {
+	 {
+	    0, 4, 8, 12, 16, 20, 24, 30, 36, 44, 52, 62, 74, 90, 110, 134, 162, 196, 238, 288, 342, 418, 576
+	 }
+	 ,
+	 {
+	    0, 4, 8, 12, 16, 22, 30, 40, 52, 66, 84, 106, 136, 192
+	 }
+      }
+      ,
+      {
+	 {
+	    0, 4, 8, 12, 16, 20, 24, 30, 36, 42, 50, 60, 72, 88, 106, 128, 156, 190, 230, 276, 330, 384, 576
+	 }
+	 ,
+	 {
+	    0, 4, 8, 12, 16, 22, 28, 38, 50, 64, 80, 100, 126, 192
+	 }
+      }
+      ,
+      {
+	 {
+	    0, 4, 8, 12, 16, 20, 24, 30, 36, 44, 54, 66, 82, 102, 126, 156, 194, 240, 296, 364, 448, 550, 576
+	 }
+	 ,
+	 {
+	    0, 4, 8, 12, 16, 22, 30, 42, 58, 78, 104, 138, 180, 192
+	 }
+      }
+   }
+   ,
+
+/* mpeg-2.5, 11 & 12 KHz seem ok, 8 ok */
+   {
+      {
+	 {
+	    0, 6, 12, 18, 24, 30, 36, 44, 54, 66, 80, 96, 116, 140, 168, 200, 238, 284, 336, 396, 464, 522, 576
+	 }
+	 ,
+	 {
+	    0, 4, 8, 12, 18, 26, 36, 48, 62, 80, 104, 134, 174, 192
+	 }
+      }
+      ,
+      {
+	 {
+	    0, 6, 12, 18, 24, 30, 36, 44, 54, 66, 80, 96, 116, 140, 168, 200, 238, 284, 336, 396, 464, 522, 576
+	 }
+	 ,
+	 {
+	    0, 4, 8, 12, 18, 26, 36, 48, 62, 80, 104, 134, 174, 192
+	 }
+      }
+      ,
+// this 8khz table, and only 8khz, from mpeg123)
+      {
+	 {
+	    0, 12, 24, 36, 48, 60, 72, 88, 108, 132, 160, 192, 232, 280, 336, 400, 476, 566, 568, 570, 572, 574, 576
+	 }
+	 ,
+	 {
+	    0, 8, 16, 24, 36, 52, 72, 96, 124, 160, 162, 164, 166, 192
+	 }
+      }
+      ,
+   }
+   ,
+};
+
+
+void sbt_mono_L3(float *sample, signed short *pcm, int ch);
+void sbt_dual_L3(float *sample, signed short *pcm, int ch);
+void sbt16_mono_L3(float *sample, signed short *pcm, int ch);
+void sbt16_dual_L3(float *sample, signed short *pcm, int ch);
+void sbt8_mono_L3(float *sample, signed short *pcm, int ch);
+void sbt8_dual_L3(float *sample, signed short *pcm, int ch);
+
+void sbtB_mono_L3(float *sample, unsigned char *pcm, int ch);
+void sbtB_dual_L3(float *sample, unsigned char *pcm, int ch);
+void sbtB16_mono_L3(float *sample, unsigned char *pcm, int ch);
+void sbtB16_dual_L3(float *sample, unsigned char *pcm, int ch);
+void sbtB8_mono_L3(float *sample, unsigned char *pcm, int ch);
+void sbtB8_dual_L3(float *sample, unsigned char *pcm, int ch);
+
+
+
+static const SBT_FUNCTION sbt_table[2][3][2] =
+{
+{{ (SBT_FUNCTION) sbt_mono_L3,
+   (SBT_FUNCTION) sbt_dual_L3 } ,
+ { (SBT_FUNCTION) sbt16_mono_L3,
+   (SBT_FUNCTION) sbt16_dual_L3 } ,
+ { (SBT_FUNCTION) sbt8_mono_L3,
+   (SBT_FUNCTION) sbt8_dual_L3 }} ,
+/*-- 8 bit output -*/
+{{ (SBT_FUNCTION) sbtB_mono_L3,
+   (SBT_FUNCTION) sbtB_dual_L3 },
+ { (SBT_FUNCTION) sbtB16_mono_L3,
+   (SBT_FUNCTION) sbtB16_dual_L3 },
+ { (SBT_FUNCTION) sbtB8_mono_L3,
+   (SBT_FUNCTION) sbtB8_dual_L3 }}
+};
+
+
+void Xform_mono(void *pcm, int igr);
+void Xform_dual(void *pcm, int igr);
+void Xform_dual_mono(void *pcm, int igr);
+void Xform_dual_right(void *pcm, int igr);
+
+static XFORM_FUNCTION xform_table[5] =
+{
+   Xform_mono,
+   Xform_dual,
+   Xform_dual_mono,
+   Xform_mono,			/* left */
+   Xform_dual_right,
+};
+int L3table_init();
+void msis_init();
+void sbt_init();
+typedef int iARRAY22[22];
+iARRAY22 *quant_init_band_addr();
+iARRAY22 *msis_init_band_addr();
+
+/*---------------------------------------------------------*/
+/* mpeg_head defined in mhead.h  frame bytes is without pMP3Stream->pad */
+////@@@@INIT
+int L3audio_decode_init(MPEG_HEAD * h, int framebytes_arg,
+		   int reduction_code, int transform_code, int convert_code,
+			int freq_limit)
+{
+   int i, j, k;
+   // static int first_pass = 1;
+   int samprate;
+   int limit;
+   int bit_code;
+   int out_chans;
+
+   pMP3Stream->buf_ptr0 = 0;
+   pMP3Stream->buf_ptr1 = 0;
+
+/* check if code handles */
+   if (h->option != 1)
+      return 0;			/* layer III only */
+
+   if (h->id)
+      pMP3Stream->ncbl_mixed = 8;		/* mpeg-1 */
+   else
+      pMP3Stream->ncbl_mixed = 6;		/* mpeg-2 */
+
+   pMP3Stream->framebytes = framebytes_arg;
+
+   transform_code = transform_code;	/* not used, asm compatability */
+   bit_code = 0;
+   if (convert_code & 8)
+      bit_code = 1;
+   convert_code = convert_code & 3;	/* higher bits used by dec8 freq cvt */
+   if (reduction_code < 0)
+      reduction_code = 0;
+   if (reduction_code > 2)
+      reduction_code = 2;
+   if (freq_limit < 1000)
+      freq_limit = 1000;
+
+
+   samprate = sr_table[4 * h->id + h->sr_index];
+   if ((h->sync & 1) == 0)
+      samprate = samprate / 2;	// mpeg 2.5 
+/*----- compute pMP3Stream->nsb_limit --------*/
+   pMP3Stream->nsb_limit = (freq_limit * 64L + samprate / 2) / samprate;
+/*- caller limit -*/
+   limit = (32 >> reduction_code);
+   if (limit > 8)
+      limit--;
+   if (pMP3Stream->nsb_limit > limit)
+      pMP3Stream->nsb_limit = limit;
+   limit = 18 * pMP3Stream->nsb_limit;
+
+   k = h->id;
+   if ((h->sync & 1) == 0)
+      k = 2;			// mpeg 2.5 
+
+   if (k == 1)
+   {
+      pMP3Stream->band_limit12 = 3 * sfBandIndexTable[k][h->sr_index].s[13];
+      pMP3Stream->band_limit = pMP3Stream->band_limit21 = sfBandIndexTable[k][h->sr_index].l[22];
+   }
+   else
+   {
+      pMP3Stream->band_limit12 = 3 * sfBandIndexTable[k][h->sr_index].s[12];
+      pMP3Stream->band_limit = pMP3Stream->band_limit21 = sfBandIndexTable[k][h->sr_index].l[21];
+   }
+   pMP3Stream->band_limit += 8;		/* allow for antialias */
+   if (pMP3Stream->band_limit > limit)
+      pMP3Stream->band_limit = limit;
+
+   if (pMP3Stream->band_limit21 > pMP3Stream->band_limit)
+      pMP3Stream->band_limit21 = pMP3Stream->band_limit;
+   if (pMP3Stream->band_limit12 > pMP3Stream->band_limit)
+      pMP3Stream->band_limit12 = pMP3Stream->band_limit;
+
+
+   pMP3Stream->band_limit_nsb = (pMP3Stream->band_limit + 17) / 18;	/* limit nsb's rounded up */
+/*----------------------------------------------*/
+   pMP3Stream->gain_adjust = 0;		/* adjust gain e.g. cvt to mono sum channel */
+   if ((h->mode != 3) && (convert_code == 1))
+      pMP3Stream->gain_adjust = -4;
+
+   pMP3Stream->outvalues = 1152 >> reduction_code;
+   if (h->id == 0)
+      pMP3Stream->outvalues /= 2;
+
+   out_chans = 2;
+   if (h->mode == 3)
+      out_chans = 1;
+   if (convert_code)
+      out_chans = 1;
+
+   pMP3Stream->sbt_L3 = sbt_table[bit_code][reduction_code][out_chans - 1];
+   k = 1 + convert_code;
+   if (h->mode == 3)
+      k = 0;
+   pMP3Stream->Xform = xform_table[k];
+
+
+   pMP3Stream->outvalues *= out_chans;
+
+   if (bit_code)
+      pMP3Stream->outbytes = pMP3Stream->outvalues;
+   else
+      pMP3Stream->outbytes = sizeof(short) * pMP3Stream->outvalues;
+
+   if (bit_code)
+      pMP3Stream->zero_level_pcm = 128;	/* 8 bit output */
+   else
+      pMP3Stream->zero_level_pcm = 0;
+
+
+   decinfo.channels = out_chans;
+   decinfo.outvalues = pMP3Stream->outvalues;
+   decinfo.samprate = samprate >> reduction_code;
+   if (bit_code)
+      decinfo.bits = 8;
+   else
+      decinfo.bits = sizeof(short) * 8;
+
+   decinfo.framebytes = pMP3Stream->framebytes;
+   decinfo.type = 0;
+
+   pMP3Stream->half_outbytes = pMP3Stream->outbytes / 2;
+/*------------------------------------------*/
+
+/*- init band tables --*/
+
+
+   k = h->id;
+   if ((h->sync & 1) == 0)
+      k = 2;			// mpeg 2.5 
+
+   for (i = 0; i < 22; i++)
+      pMP3Stream->sfBandIndex[0][i] = sfBandIndexTable[k][h->sr_index].l[i + 1];
+   for (i = 0; i < 13; i++)
+      pMP3Stream->sfBandIndex[1][i] = 3 * sfBandIndexTable[k][h->sr_index].s[i + 1];
+   for (i = 0; i < 22; i++)
+      pMP3Stream->nBand[0][i] = sfBandIndexTable[k][h->sr_index].l[i + 1] - sfBandIndexTable[k][h->sr_index].l[i];
+   for (i = 0; i < 13; i++)
+      pMP3Stream->nBand[1][i] = sfBandIndexTable[k][h->sr_index].s[i + 1] - sfBandIndexTable[k][h->sr_index].s[i];
+
+
+/* init tables */
+   L3table_init();
+/* init ms and is stereo modes */
+   msis_init();
+
+/*----- init sbt ---*/
+   sbt_init();
+
+
+
+/*--- clear buffers --*/
+   for (i = 0; i < 576; i++)
+      yout[i] = 0.0f;
+   for (j = 0; j < 2; j++)
+   {
+      for (k = 0; k < 2; k++)
+      {
+	 for (i = 0; i < 576; i++)
+	 {
+	    pMP3Stream->sample[j][k][i].x = 0.0f;
+	    pMP3Stream->sample[j][k][i].s = 0;
+	 }
+      }
+   }
+
+   if (h->id == 1)
+      pMP3Stream->decode_function = L3audio_decode_MPEG1;
+   else
+      pMP3Stream->decode_function = L3audio_decode_MPEG2;
+
+   return 1;
+}
+/*---------------------------------------------------------*/
+/*==========================================================*/
diff --git a/code/mp3code/cwin.c b/code/mp3code/cwin.c
new file mode 100644
index 0000000..884abb1
--- /dev/null
+++ b/code/mp3code/cwin.c
@@ -0,0 +1,470 @@
+#pragma warning(disable:4206)	// nonstandard extension used : translation unit is empty
+#ifdef COMPILE_ME
+/*____________________________________________________________________________
+	
+	FreeAmp - The Free MP3 Player
+
+        MP3 Decoder originally Copyright (C) 1995-1997 Xing Technology
+        Corp.  http://www.xingtech.com
+
+	Portions Copyright (C) 1998-1999 EMusic.com
+
+	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., 675 Mass Ave, Cambridge, MA 02139, USA.
+	
+	$Id: cwin.c,v 1.7 1999/10/19 07:13:08 elrod Exp $
+____________________________________________________________________________*/
+
+/****  cwin.c  ***************************************************
+
+include to cwinm.c
+
+MPEG audio decoder, float window routines
+portable C
+
+******************************************************************/
+
+#include "config.h"
+
+/*-------------------------------------------------------------------------*/
+void window(float *vbuf, int vb_ptr, short *pcm)
+{
+   int i, j;
+   int si, bx;
+   const float *coef;
+   float sum;
+   long tmp;
+
+   si = vb_ptr + 16;
+   bx = (si + 32) & 511;
+   coef = wincoef;
+
+/*-- first 16 --*/
+   for (i = 0; i < 16; i++)
+   {
+      sum = 0.0F;
+      for (j = 0; j < 8; j++)
+      {
+	 sum += (*coef++) * vbuf[si];
+	 si = (si + 64) & 511;
+	 sum -= (*coef++) * vbuf[bx];
+	 bx = (bx + 64) & 511;
+      }
+      si++;
+      bx--;
+      tmp = (long) sum;
+      if (tmp > 32767)
+	 tmp = 32767;
+      else if (tmp < -32768)
+	 tmp = -32768;
+      *pcm++ = tmp;
+   }
+/*--  special case --*/
+   sum = 0.0F;
+   for (j = 0; j < 8; j++)
+   {
+      sum += (*coef++) * vbuf[bx];
+      bx = (bx + 64) & 511;
+   }
+   tmp = (long) sum;
+   if (tmp > 32767)
+      tmp = 32767;
+   else if (tmp < -32768)
+      tmp = -32768;
+   *pcm++ = tmp;
+/*-- last 15 --*/
+   coef = wincoef + 255;	/* back pass through coefs */
+   for (i = 0; i < 15; i++)
+   {
+      si--;
+      bx++;
+      sum = 0.0F;
+      for (j = 0; j < 8; j++)
+      {
+	 sum += (*coef--) * vbuf[si];
+	 si = (si + 64) & 511;
+	 sum += (*coef--) * vbuf[bx];
+	 bx = (bx + 64) & 511;
+      }
+      tmp = (long) sum;
+      if (tmp > 32767)
+	 tmp = 32767;
+      else if (tmp < -32768)
+	 tmp = -32768;
+      *pcm++ = tmp;
+   }
+}
+
+
+
+/*------------------------------------------------------------*/
+void window_dual(float *vbuf, int vb_ptr, short *pcm)
+{
+   int i, j;			/* dual window interleaves output */
+   int si, bx;
+   const float *coef;
+   float sum;
+   long tmp;
+
+   si = vb_ptr + 16;
+   bx = (si + 32) & 511;
+   coef = wincoef;
+
+/*-- first 16 --*/
+   for (i = 0; i < 16; i++)
+   {
+      sum = 0.0F;
+      for (j = 0; j < 8; j++)
+      {
+	 sum += (*coef++) * vbuf[si];
+	 si = (si + 64) & 511;
+	 sum -= (*coef++) * vbuf[bx];
+	 bx = (bx + 64) & 511;
+      }
+      si++;
+      bx--;
+      tmp = (long) sum;
+      if (tmp > 32767)
+	 tmp = 32767;
+      else if (tmp < -32768)
+	 tmp = -32768;
+      *pcm = tmp;
+      pcm += 2;
+   }
+/*--  special case --*/
+   sum = 0.0F;
+   for (j = 0; j < 8; j++)
+   {
+      sum += (*coef++) * vbuf[bx];
+      bx = (bx + 64) & 511;
+   }
+   tmp = (long) sum;
+   if (tmp > 32767)
+      tmp = 32767;
+   else if (tmp < -32768)
+      tmp = -32768;
+   *pcm = tmp;
+   pcm += 2;
+/*-- last 15 --*/
+   coef = wincoef + 255;	/* back pass through coefs */
+   for (i = 0; i < 15; i++)
+   {
+      si--;
+      bx++;
+      sum = 0.0F;
+      for (j = 0; j < 8; j++)
+      {
+	 sum += (*coef--) * vbuf[si];
+	 si = (si + 64) & 511;
+	 sum += (*coef--) * vbuf[bx];
+	 bx = (bx + 64) & 511;
+      }
+      tmp = (long) sum;
+      if (tmp > 32767)
+	 tmp = 32767;
+      else if (tmp < -32768)
+	 tmp = -32768;
+      *pcm = tmp;
+      pcm += 2;
+   }
+}
+/*------------------------------------------------------------*/
+/*------------------- 16 pt window ------------------------------*/
+void window16(float *vbuf, int vb_ptr, short *pcm)
+{
+   int i, j;
+   unsigned char si, bx;
+   const float *coef;
+   float sum;
+   long tmp;
+
+   si = vb_ptr + 8;
+   bx = si + 16;
+   coef = wincoef;
+
+/*-- first 8 --*/
+   for (i = 0; i < 8; i++)
+   {
+      sum = 0.0F;
+      for (j = 0; j < 8; j++)
+      {
+	 sum += (*coef++) * vbuf[si];
+	 si += 32;
+	 sum -= (*coef++) * vbuf[bx];
+	 bx += 32;
+      }
+      si++;
+      bx--;
+      coef += 16;
+      tmp = (long) sum;
+      if (tmp > 32767)
+	 tmp = 32767;
+      else if (tmp < -32768)
+	 tmp = -32768;
+      *pcm++ = tmp;
+   }
+/*--  special case --*/
+   sum = 0.0F;
+   for (j = 0; j < 8; j++)
+   {
+      sum += (*coef++) * vbuf[bx];
+      bx += 32;
+   }
+   tmp = (long) sum;
+   if (tmp > 32767)
+      tmp = 32767;
+   else if (tmp < -32768)
+      tmp = -32768;
+   *pcm++ = tmp;
+/*-- last 7 --*/
+   coef = wincoef + 255;	/* back pass through coefs */
+   for (i = 0; i < 7; i++)
+   {
+      coef -= 16;
+      si--;
+      bx++;
+      sum = 0.0F;
+      for (j = 0; j < 8; j++)
+      {
+	 sum += (*coef--) * vbuf[si];
+	 si += 32;
+	 sum += (*coef--) * vbuf[bx];
+	 bx += 32;
+      }
+      tmp = (long) sum;
+      if (tmp > 32767)
+	 tmp = 32767;
+      else if (tmp < -32768)
+	 tmp = -32768;
+      *pcm++ = tmp;
+   }
+}
+/*--------------- 16 pt dual window (interleaved output) -----------------*/
+void window16_dual(float *vbuf, int vb_ptr, short *pcm)
+{
+   int i, j;
+   unsigned char si, bx;
+   const float *coef;
+   float sum;
+   long tmp;
+
+   si = vb_ptr + 8;
+   bx = si + 16;
+   coef = wincoef;
+
+/*-- first 8 --*/
+   for (i = 0; i < 8; i++)
+   {
+      sum = 0.0F;
+      for (j = 0; j < 8; j++)
+      {
+	 sum += (*coef++) * vbuf[si];
+	 si += 32;
+	 sum -= (*coef++) * vbuf[bx];
+	 bx += 32;
+      }
+      si++;
+      bx--;
+      coef += 16;
+      tmp = (long) sum;
+      if (tmp > 32767)
+	 tmp = 32767;
+      else if (tmp < -32768)
+	 tmp = -32768;
+      *pcm = tmp;
+      pcm += 2;
+   }
+/*--  special case --*/
+   sum = 0.0F;
+   for (j = 0; j < 8; j++)
+   {
+      sum += (*coef++) * vbuf[bx];
+      bx += 32;
+   }
+   tmp = (long) sum;
+   if (tmp > 32767)
+      tmp = 32767;
+   else if (tmp < -32768)
+      tmp = -32768;
+   *pcm = tmp;
+   pcm += 2;
+/*-- last 7 --*/
+   coef = wincoef + 255;	/* back pass through coefs */
+   for (i = 0; i < 7; i++)
+   {
+      coef -= 16;
+      si--;
+      bx++;
+      sum = 0.0F;
+      for (j = 0; j < 8; j++)
+      {
+	 sum += (*coef--) * vbuf[si];
+	 si += 32;
+	 sum += (*coef--) * vbuf[bx];
+	 bx += 32;
+      }
+      tmp = (long) sum;
+      if (tmp > 32767)
+	 tmp = 32767;
+      else if (tmp < -32768)
+	 tmp = -32768;
+      *pcm = tmp;
+      pcm += 2;
+   }
+}
+/*------------------- 8 pt window ------------------------------*/
+void window8(float *vbuf, int vb_ptr, short *pcm)
+{
+   int i, j;
+   int si, bx;
+   const float *coef;
+   float sum;
+   long tmp;
+
+   si = vb_ptr + 4;
+   bx = (si + 8) & 127;
+   coef = wincoef;
+
+/*-- first 4 --*/
+   for (i = 0; i < 4; i++)
+   {
+      sum = 0.0F;
+      for (j = 0; j < 8; j++)
+      {
+	 sum += (*coef++) * vbuf[si];
+	 si = (si + 16) & 127;
+	 sum -= (*coef++) * vbuf[bx];
+	 bx = (bx + 16) & 127;
+      }
+      si++;
+      bx--;
+      coef += 48;
+      tmp = (long) sum;
+      if (tmp > 32767)
+	 tmp = 32767;
+      else if (tmp < -32768)
+	 tmp = -32768;
+      *pcm++ = tmp;
+   }
+/*--  special case --*/
+   sum = 0.0F;
+   for (j = 0; j < 8; j++)
+   {
+      sum += (*coef++) * vbuf[bx];
+      bx = (bx + 16) & 127;
+   }
+   tmp = (long) sum;
+   if (tmp > 32767)
+      tmp = 32767;
+   else if (tmp < -32768)
+      tmp = -32768;
+   *pcm++ = tmp;
+/*-- last 3 --*/
+   coef = wincoef + 255;	/* back pass through coefs */
+   for (i = 0; i < 3; i++)
+   {
+      coef -= 48;
+      si--;
+      bx++;
+      sum = 0.0F;
+      for (j = 0; j < 8; j++)
+      {
+	 sum += (*coef--) * vbuf[si];
+	 si = (si + 16) & 127;
+	 sum += (*coef--) * vbuf[bx];
+	 bx = (bx + 16) & 127;
+      }
+      tmp = (long) sum;
+      if (tmp > 32767)
+	 tmp = 32767;
+      else if (tmp < -32768)
+	 tmp = -32768;
+      *pcm++ = tmp;
+   }
+}
+/*--------------- 8 pt dual window (interleaved output) -----------------*/
+void window8_dual(float *vbuf, int vb_ptr, short *pcm)
+{
+   int i, j;
+   int si, bx;
+   const float *coef;
+   float sum;
+   long tmp;
+
+   si = vb_ptr + 4;
+   bx = (si + 8) & 127;
+   coef = wincoef;
+
+/*-- first 4 --*/
+   for (i = 0; i < 4; i++)
+   {
+      sum = 0.0F;
+      for (j = 0; j < 8; j++)
+      {
+	 sum += (*coef++) * vbuf[si];
+	 si = (si + 16) & 127;
+	 sum -= (*coef++) * vbuf[bx];
+	 bx = (bx + 16) & 127;
+      }
+      si++;
+      bx--;
+      coef += 48;
+      tmp = (long) sum;
+      if (tmp > 32767)
+	 tmp = 32767;
+      else if (tmp < -32768)
+	 tmp = -32768;
+      *pcm = tmp;
+      pcm += 2;
+   }
+/*--  special case --*/
+   sum = 0.0F;
+   for (j = 0; j < 8; j++)
+   {
+      sum += (*coef++) * vbuf[bx];
+      bx = (bx + 16) & 127;
+   }
+   tmp = (long) sum;
+   if (tmp > 32767)
+      tmp = 32767;
+   else if (tmp < -32768)
+      tmp = -32768;
+   *pcm = tmp;
+   pcm += 2;
+/*-- last 3 --*/
+   coef = wincoef + 255;	/* back pass through coefs */
+   for (i = 0; i < 3; i++)
+   {
+      coef -= 48;
+      si--;
+      bx++;
+      sum = 0.0F;
+      for (j = 0; j < 8; j++)
+      {
+	 sum += (*coef--) * vbuf[si];
+	 si = (si + 16) & 127;
+	 sum += (*coef--) * vbuf[bx];
+	 bx = (bx + 16) & 127;
+      }
+      tmp = (long) sum;
+      if (tmp > 32767)
+	 tmp = 32767;
+      else if (tmp < -32768)
+	 tmp = -32768;
+      *pcm = tmp;
+      pcm += 2;
+   }
+}
+/*------------------------------------------------------------*/
+#endif	// #ifdef COMPILE_ME
diff --git a/code/mp3code/cwinb.c b/code/mp3code/cwinb.c
new file mode 100644
index 0000000..537a4b7
--- /dev/null
+++ b/code/mp3code/cwinb.c
@@ -0,0 +1,465 @@
+#pragma warning(disable:4206)	// nonstandard extension used : translation unit is empty
+#ifdef COMPILE_ME
+/*____________________________________________________________________________
+	
+	FreeAmp - The Free MP3 Player
+
+        MP3 Decoder originally Copyright (C) 1995-1997 Xing Technology
+        Corp.  http://www.xingtech.com
+
+	Portions Copyright (C) 1998-1999 EMusic.com
+
+	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., 675 Mass Ave, Cambridge, MA 02139, USA.
+	
+	$Id: cwinb.c,v 1.4 1999/10/19 07:13:08 elrod Exp $
+____________________________________________________________________________*/
+
+/****  cwin.c  ***************************************************
+
+include to cwinm.c
+
+MPEG audio decoder, float window routines - 8 bit output
+portable C
+
+******************************************************************/
+/*-------------------------------------------------------------------------*/
+
+void windowB(float *vbuf, int vb_ptr, unsigned char *pcm)
+{
+   int i, j;
+   int si, bx;
+   const float *coef;
+   float sum;
+   long tmp;
+
+   si = vb_ptr + 16;
+   bx = (si + 32) & 511;
+   coef = wincoef;
+
+/*-- first 16 --*/
+   for (i = 0; i < 16; i++)
+   {
+      sum = 0.0F;
+      for (j = 0; j < 8; j++)
+      {
+	 sum += (*coef++) * vbuf[si];
+	 si = (si + 64) & 511;
+	 sum -= (*coef++) * vbuf[bx];
+	 bx = (bx + 64) & 511;
+      }
+      si++;
+      bx--;
+      tmp = (long) sum;
+      if (tmp > 32767)
+	 tmp = 32767;
+      else if (tmp < -32768)
+	 tmp = -32768;
+      *pcm++ = ((unsigned char) (tmp >> 8)) ^ 0x80;
+   }
+/*--  special case --*/
+   sum = 0.0F;
+   for (j = 0; j < 8; j++)
+   {
+      sum += (*coef++) * vbuf[bx];
+      bx = (bx + 64) & 511;
+   }
+   tmp = (long) sum;
+   if (tmp > 32767)
+      tmp = 32767;
+   else if (tmp < -32768)
+      tmp = -32768;
+   *pcm++ = ((unsigned char) (tmp >> 8)) ^ 0x80;
+/*-- last 15 --*/
+   coef = wincoef + 255;	/* back pass through coefs */
+   for (i = 0; i < 15; i++)
+   {
+      si--;
+      bx++;
+      sum = 0.0F;
+      for (j = 0; j < 8; j++)
+      {
+	 sum += (*coef--) * vbuf[si];
+	 si = (si + 64) & 511;
+	 sum += (*coef--) * vbuf[bx];
+	 bx = (bx + 64) & 511;
+      }
+      tmp = (long) sum;
+      if (tmp > 32767)
+	 tmp = 32767;
+      else if (tmp < -32768)
+	 tmp = -32768;
+      *pcm++ = ((unsigned char) (tmp >> 8)) ^ 0x80;
+   }
+}
+/*------------------------------------------------------------*/
+void windowB_dual(float *vbuf, int vb_ptr, unsigned char *pcm)
+{
+   int i, j;			/* dual window interleaves output */
+   int si, bx;
+   const float *coef;
+   float sum;
+   long tmp;
+
+   si = vb_ptr + 16;
+   bx = (si + 32) & 511;
+   coef = wincoef;
+
+/*-- first 16 --*/
+   for (i = 0; i < 16; i++)
+   {
+      sum = 0.0F;
+      for (j = 0; j < 8; j++)
+      {
+	 sum += (*coef++) * vbuf[si];
+	 si = (si + 64) & 511;
+	 sum -= (*coef++) * vbuf[bx];
+	 bx = (bx + 64) & 511;
+      }
+      si++;
+      bx--;
+      tmp = (long) sum;
+      if (tmp > 32767)
+	 tmp = 32767;
+      else if (tmp < -32768)
+	 tmp = -32768;
+      *pcm = ((unsigned char) (tmp >> 8)) ^ 0x80;
+      pcm += 2;
+   }
+/*--  special case --*/
+   sum = 0.0F;
+   for (j = 0; j < 8; j++)
+   {
+      sum += (*coef++) * vbuf[bx];
+      bx = (bx + 64) & 511;
+   }
+   tmp = (long) sum;
+   if (tmp > 32767)
+      tmp = 32767;
+   else if (tmp < -32768)
+      tmp = -32768;
+   *pcm = ((unsigned char) (tmp >> 8)) ^ 0x80;
+   pcm += 2;
+/*-- last 15 --*/
+   coef = wincoef + 255;	/* back pass through coefs */
+   for (i = 0; i < 15; i++)
+   {
+      si--;
+      bx++;
+      sum = 0.0F;
+      for (j = 0; j < 8; j++)
+      {
+	 sum += (*coef--) * vbuf[si];
+	 si = (si + 64) & 511;
+	 sum += (*coef--) * vbuf[bx];
+	 bx = (bx + 64) & 511;
+      }
+      tmp = (long) sum;
+      if (tmp > 32767)
+	 tmp = 32767;
+      else if (tmp < -32768)
+	 tmp = -32768;
+      *pcm = ((unsigned char) (tmp >> 8)) ^ 0x80;
+      pcm += 2;
+   }
+}
+/*------------------------------------------------------------*/
+/*------------------- 16 pt window ------------------------------*/
+void windowB16(float *vbuf, int vb_ptr, unsigned char *pcm)
+{
+   int i, j;
+   unsigned char si, bx;
+   const float *coef;
+   float sum;
+   long tmp;
+
+   si = vb_ptr + 8;
+   bx = si + 16;
+   coef = wincoef;
+
+/*-- first 8 --*/
+   for (i = 0; i < 8; i++)
+   {
+      sum = 0.0F;
+      for (j = 0; j < 8; j++)
+      {
+	 sum += (*coef++) * vbuf[si];
+	 si += 32;
+	 sum -= (*coef++) * vbuf[bx];
+	 bx += 32;
+      }
+      si++;
+      bx--;
+      coef += 16;
+      tmp = (long) sum;
+      if (tmp > 32767)
+	 tmp = 32767;
+      else if (tmp < -32768)
+	 tmp = -32768;
+      *pcm++ = ((unsigned char) (tmp >> 8)) ^ 0x80;
+   }
+/*--  special case --*/
+   sum = 0.0F;
+   for (j = 0; j < 8; j++)
+   {
+      sum += (*coef++) * vbuf[bx];
+      bx += 32;
+   }
+   tmp = (long) sum;
+   if (tmp > 32767)
+      tmp = 32767;
+   else if (tmp < -32768)
+      tmp = -32768;
+   *pcm++ = ((unsigned char) (tmp >> 8)) ^ 0x80;
+/*-- last 7 --*/
+   coef = wincoef + 255;	/* back pass through coefs */
+   for (i = 0; i < 7; i++)
+   {
+      coef -= 16;
+      si--;
+      bx++;
+      sum = 0.0F;
+      for (j = 0; j < 8; j++)
+      {
+	 sum += (*coef--) * vbuf[si];
+	 si += 32;
+	 sum += (*coef--) * vbuf[bx];
+	 bx += 32;
+      }
+      tmp = (long) sum;
+      if (tmp > 32767)
+	 tmp = 32767;
+      else if (tmp < -32768)
+	 tmp = -32768;
+      *pcm++ = ((unsigned char) (tmp >> 8)) ^ 0x80;
+   }
+}
+/*--------------- 16 pt dual window (interleaved output) -----------------*/
+void windowB16_dual(float *vbuf, int vb_ptr, unsigned char *pcm)
+{
+   int i, j;
+   unsigned char si, bx;
+   const float *coef;
+   float sum;
+   long tmp;
+
+   si = vb_ptr + 8;
+   bx = si + 16;
+   coef = wincoef;
+
+/*-- first 8 --*/
+   for (i = 0; i < 8; i++)
+   {
+      sum = 0.0F;
+      for (j = 0; j < 8; j++)
+      {
+	 sum += (*coef++) * vbuf[si];
+	 si += 32;
+	 sum -= (*coef++) * vbuf[bx];
+	 bx += 32;
+      }
+      si++;
+      bx--;
+      coef += 16;
+      tmp = (long) sum;
+      if (tmp > 32767)
+	 tmp = 32767;
+      else if (tmp < -32768)
+	 tmp = -32768;
+      *pcm = ((unsigned char) (tmp >> 8)) ^ 0x80;
+      pcm += 2;
+   }
+/*--  special case --*/
+   sum = 0.0F;
+   for (j = 0; j < 8; j++)
+   {
+      sum += (*coef++) * vbuf[bx];
+      bx += 32;
+   }
+   tmp = (long) sum;
+   if (tmp > 32767)
+      tmp = 32767;
+   else if (tmp < -32768)
+      tmp = -32768;
+   *pcm = ((unsigned char) (tmp >> 8)) ^ 0x80;
+   pcm += 2;
+/*-- last 7 --*/
+   coef = wincoef + 255;	/* back pass through coefs */
+   for (i = 0; i < 7; i++)
+   {
+      coef -= 16;
+      si--;
+      bx++;
+      sum = 0.0F;
+      for (j = 0; j < 8; j++)
+      {
+	 sum += (*coef--) * vbuf[si];
+	 si += 32;
+	 sum += (*coef--) * vbuf[bx];
+	 bx += 32;
+      }
+      tmp = (long) sum;
+      if (tmp > 32767)
+	 tmp = 32767;
+      else if (tmp < -32768)
+	 tmp = -32768;
+      *pcm = ((unsigned char) (tmp >> 8)) ^ 0x80;
+      pcm += 2;
+   }
+}
+/*------------------- 8 pt window ------------------------------*/
+void windowB8(float *vbuf, int vb_ptr, unsigned char *pcm)
+{
+   int i, j;
+   int si, bx;
+   const float *coef;
+   float sum;
+   long tmp;
+
+   si = vb_ptr + 4;
+   bx = (si + 8) & 127;
+   coef = wincoef;
+
+/*-- first 4 --*/
+   for (i = 0; i < 4; i++)
+   {
+      sum = 0.0F;
+      for (j = 0; j < 8; j++)
+      {
+	 sum += (*coef++) * vbuf[si];
+	 si = (si + 16) & 127;
+	 sum -= (*coef++) * vbuf[bx];
+	 bx = (bx + 16) & 127;
+      }
+      si++;
+      bx--;
+      coef += 48;
+      tmp = (long) sum;
+      if (tmp > 32767)
+	 tmp = 32767;
+      else if (tmp < -32768)
+	 tmp = -32768;
+      *pcm++ = ((unsigned char) (tmp >> 8)) ^ 0x80;
+   }
+/*--  special case --*/
+   sum = 0.0F;
+   for (j = 0; j < 8; j++)
+   {
+      sum += (*coef++) * vbuf[bx];
+      bx = (bx + 16) & 127;
+   }
+   tmp = (long) sum;
+   if (tmp > 32767)
+      tmp = 32767;
+   else if (tmp < -32768)
+      tmp = -32768;
+   *pcm++ = ((unsigned char) (tmp >> 8)) ^ 0x80;
+/*-- last 3 --*/
+   coef = wincoef + 255;	/* back pass through coefs */
+   for (i = 0; i < 3; i++)
+   {
+      coef -= 48;
+      si--;
+      bx++;
+      sum = 0.0F;
+      for (j = 0; j < 8; j++)
+      {
+	 sum += (*coef--) * vbuf[si];
+	 si = (si + 16) & 127;
+	 sum += (*coef--) * vbuf[bx];
+	 bx = (bx + 16) & 127;
+      }
+      tmp = (long) sum;
+      if (tmp > 32767)
+	 tmp = 32767;
+      else if (tmp < -32768)
+	 tmp = -32768;
+      *pcm++ = ((unsigned char) (tmp >> 8)) ^ 0x80;
+   }
+}
+/*--------------- 8 pt dual window (interleaved output) -----------------*/
+void windowB8_dual(float *vbuf, int vb_ptr, unsigned char *pcm)
+{
+   int i, j;
+   int si, bx;
+   const float *coef;
+   float sum;
+   long tmp;
+
+   si = vb_ptr + 4;
+   bx = (si + 8) & 127;
+   coef = wincoef;
+
+/*-- first 4 --*/
+   for (i = 0; i < 4; i++)
+   {
+      sum = 0.0F;
+      for (j = 0; j < 8; j++)
+      {
+	 sum += (*coef++) * vbuf[si];
+	 si = (si + 16) & 127;
+	 sum -= (*coef++) * vbuf[bx];
+	 bx = (bx + 16) & 127;
+      }
+      si++;
+      bx--;
+      coef += 48;
+      tmp = (long) sum;
+      if (tmp > 32767)
+	 tmp = 32767;
+      else if (tmp < -32768)
+	 tmp = -32768;
+      *pcm = ((unsigned char) (tmp >> 8)) ^ 0x80;
+      pcm += 2;
+   }
+/*--  special case --*/
+   sum = 0.0F;
+   for (j = 0; j < 8; j++)
+   {
+      sum += (*coef++) * vbuf[bx];
+      bx = (bx + 16) & 127;
+   }
+   tmp = (long) sum;
+   if (tmp > 32767)
+      tmp = 32767;
+   else if (tmp < -32768)
+      tmp = -32768;
+   *pcm = ((unsigned char) (tmp >> 8)) ^ 0x80;
+   pcm += 2;
+/*-- last 3 --*/
+   coef = wincoef + 255;	/* back pass through coefs */
+   for (i = 0; i < 3; i++)
+   {
+      coef -= 48;
+      si--;
+      bx++;
+      sum = 0.0F;
+      for (j = 0; j < 8; j++)
+      {
+	 sum += (*coef--) * vbuf[si];
+	 si = (si + 16) & 127;
+	 sum += (*coef--) * vbuf[bx];
+	 bx = (bx + 16) & 127;
+      }
+      tmp = (long) sum;
+      if (tmp > 32767)
+	 tmp = 32767;
+      else if (tmp < -32768)
+	 tmp = -32768;
+      *pcm = ((unsigned char) (tmp >> 8)) ^ 0x80;
+      pcm += 2;
+   }
+}
+/*------------------------------------------------------------*/
+#endif	// #ifdef COMPILE_ME
diff --git a/code/mp3code/cwinm.c b/code/mp3code/cwinm.c
new file mode 100644
index 0000000..8a18f0d
--- /dev/null
+++ b/code/mp3code/cwinm.c
@@ -0,0 +1,55 @@
+/*____________________________________________________________________________
+	
+	FreeAmp - The Free MP3 Player
+
+        MP3 Decoder originally Copyright (C) 1995-1997 Xing Technology
+        Corp.  http://www.xingtech.com
+
+	Portions Copyright (C) 1998-1999 EMusic.com
+
+	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., 675 Mass Ave, Cambridge, MA 02139, USA.
+	
+	$Id: cwinm.c,v 1.3 1999/10/19 07:13:08 elrod Exp $
+____________________________________________________________________________*/
+
+/****  cwinm.c  ***************************************************
+
+MPEG audio decoder, window master routine
+portable C
+
+
+******************************************************************/
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <float.h>
+#include <math.h>
+
+
+/* disable precision loss warning on type conversion */
+#ifdef _MSC_VER
+#pragma warning(disable:4244 4056)
+#endif
+
+const float wincoef[264] =
+{				/* window coefs */
+#include "tableawd.h"
+};
+
+/*--------------------------------------------------------*/
+#define COMPILE_ME
+#include "cwin.c"
+#include "cwinb.c"
+/*--------------------------------------------------------*/
diff --git a/code/mp3code/htable.h b/code/mp3code/htable.h
new file mode 100644
index 0000000..3131bd5
--- /dev/null
+++ b/code/mp3code/htable.h
@@ -0,0 +1,999 @@
+/*____________________________________________________________________________
+	
+	FreeAmp - The Free MP3 Player
+
+        MP3 Decoder originally Copyright (C) 1995-1997 Xing Technology
+        Corp.  http://www.xingtech.com
+
+	Portions Copyright (C) 1998-1999 EMusic.com
+
+	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.}, {675 Mass Ave}, {Cambridge}, {MA 02139}, {USA.
+	
+	$Id: htable.h,v 1.2 1999/10/19 07:13:08 elrod Exp $
+____________________________________________________________________________*/
+
+/* TABLE  1    4 entries  maxbits  3  linbits  0 */
+static const HUFF_ELEMENT huff_table_1[] =
+{
+  {0xFF000003}, {0x03010102}, {0x03010001}, {0x02000101}, {0x02000101},	/*  4 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},
+};
+
+/* max table bits  3 */
+
+/* TABLE  2    9 entries  maxbits  6  linbits  0 */
+static const HUFF_ELEMENT huff_table_2[] =
+{
+  {0xFF000006}, {0x06020202}, {0x06020001}, {0x05020102}, {0x05020102},	/*  4 */
+  {0x05010202}, {0x05010202}, {0x05000201}, {0x05000201}, {0x03010102},	/*  9 */
+  {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102},	/* 14 */
+  {0x03010102}, {0x03010102}, {0x03010001}, {0x03010001}, {0x03010001},	/* 19 */
+  {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001},	/* 24 */
+  {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101},	/* 29 */
+  {0x03000101}, {0x03000101}, {0x03000101}, {0x01000000}, {0x01000000},	/* 34 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 39 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 44 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 49 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 54 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 59 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, /* 64 */
+};
+
+/* max table bits  6 */
+
+/* TABLE  3    9 entries  maxbits  6  linbits  0 */
+static const HUFF_ELEMENT huff_table_3[] =
+{
+  {0xFF000006}, {0x06020202}, {0x06020001}, {0x05020102}, {0x05020102},	/*  4 */
+  {0x05010202}, {0x05010202}, {0x05000201}, {0x05000201}, {0x03000101},	/*  9 */
+  {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101},	/* 14 */
+  {0x03000101}, {0x03000101}, {0x02010102}, {0x02010102}, {0x02010102},	/* 19 */
+  {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102},	/* 24 */
+  {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102},	/* 29 */
+  {0x02010102}, {0x02010102}, {0x02010102}, {0x02010001}, {0x02010001},	/* 34 */
+  {0x02010001}, {0x02010001}, {0x02010001}, {0x02010001}, {0x02010001},	/* 39 */
+  {0x02010001}, {0x02010001}, {0x02010001}, {0x02010001}, {0x02010001},	/* 44 */
+  {0x02010001}, {0x02010001}, {0x02010001}, {0x02010001}, {0x02000000},	/* 49 */
+  {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000},	/* 54 */
+  {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000},	/* 59 */
+  {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, /* 64 */
+};
+
+/* max table bits  6 */
+/* NO XING TABLE 4 */
+
+/* TABLE  5   16 entries  maxbits  8  linbits  0 */
+static const HUFF_ELEMENT huff_table_5[] =
+{
+  {0xFF000008}, {0x08030302}, {0x08030202}, {0x07020302}, {0x07020302},	/*  4 */
+  {0x06010302}, {0x06010302}, {0x06010302}, {0x06010302}, {0x07030102},	/*  9 */
+  {0x07030102}, {0x07030001}, {0x07030001}, {0x07000301}, {0x07000301},	/* 14 */
+  {0x07020202}, {0x07020202}, {0x06020102}, {0x06020102}, {0x06020102},	/* 19 */
+  {0x06020102}, {0x06010202}, {0x06010202}, {0x06010202}, {0x06010202},	/* 24 */
+  {0x06020001}, {0x06020001}, {0x06020001}, {0x06020001}, {0x06000201},	/* 29 */
+  {0x06000201}, {0x06000201}, {0x06000201}, {0x03010102}, {0x03010102},	/* 34 */
+  {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102},	/* 39 */
+  {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102},	/* 44 */
+  {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102},	/* 49 */
+  {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102},	/* 54 */
+  {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102},	/* 59 */
+  {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102},	/* 64 */
+  {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001},	/* 69 */
+  {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001},	/* 74 */
+  {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001},	/* 79 */
+  {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001},	/* 84 */
+  {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001},	/* 89 */
+  {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001},	/* 94 */
+  {0x03010001}, {0x03010001}, {0x03000101}, {0x03000101}, {0x03000101},	/* 99 */
+  {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101},	/* 104 */
+  {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101},	/* 109 */
+  {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101},	/* 114 */
+  {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101},	/* 119 */
+  {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101},	/* 124 */
+  {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x01000000},	/* 129 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 134 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 139 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 144 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 149 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 154 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 159 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 164 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 169 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 174 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 179 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 184 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 189 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 194 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 199 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 204 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 209 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 214 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 219 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 224 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 229 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 234 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 239 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 244 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 249 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 254 */
+  {0x01000000}, {0x01000000},
+};
+
+/* max table bits  8 */
+
+/* TABLE  6   16 entries  maxbits  7  linbits  0 */
+static const HUFF_ELEMENT huff_table_6[] =
+{
+  {0xFF000007}, {0x07030302}, {0x07030001}, {0x06030202}, {0x06030202},	/*  4 */
+  {0x06020302}, {0x06020302}, {0x06000301}, {0x06000301}, {0x05030102},	/*  9 */
+  {0x05030102}, {0x05030102}, {0x05030102}, {0x05010302}, {0x05010302},	/* 14 */
+  {0x05010302}, {0x05010302}, {0x05020202}, {0x05020202}, {0x05020202},	/* 19 */
+  {0x05020202}, {0x05020001}, {0x05020001}, {0x05020001}, {0x05020001},	/* 24 */
+  {0x04020102}, {0x04020102}, {0x04020102}, {0x04020102}, {0x04020102},	/* 29 */
+  {0x04020102}, {0x04020102}, {0x04020102}, {0x04010202}, {0x04010202},	/* 34 */
+  {0x04010202}, {0x04010202}, {0x04010202}, {0x04010202}, {0x04010202},	/* 39 */
+  {0x04010202}, {0x04000201}, {0x04000201}, {0x04000201}, {0x04000201},	/* 44 */
+  {0x04000201}, {0x04000201}, {0x04000201}, {0x04000201}, {0x03010001},	/* 49 */
+  {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001},	/* 54 */
+  {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001},	/* 59 */
+  {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001},	/* 64 */
+  {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102},	/* 69 */
+  {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102},	/* 74 */
+  {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102},	/* 79 */
+  {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102},	/* 84 */
+  {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102},	/* 89 */
+  {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102},	/* 94 */
+  {0x02010102}, {0x02010102}, {0x03000101}, {0x03000101}, {0x03000101},	/* 99 */
+  {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101},	/* 104 */
+  {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101},	/* 109 */
+  {0x03000101}, {0x03000101}, {0x03000101}, {0x03000000}, {0x03000000},	/* 114 */
+  {0x03000000}, {0x03000000}, {0x03000000}, {0x03000000}, {0x03000000},	/* 119 */
+  {0x03000000}, {0x03000000}, {0x03000000}, {0x03000000}, {0x03000000},	/* 124 */
+  {0x03000000}, {0x03000000}, {0x03000000}, {0x03000000},
+};
+
+/* max table bits  7 */
+
+/* TABLE  7   36 entries  maxbits 10  linbits  0 */
+static const HUFF_ELEMENT huff_table_7[] =
+{
+  {0xFF000006}, {0x00000041}, {0x00000052}, {0x0000005B}, {0x00000060},	/*  4 */
+  {0x00000063}, {0x00000068}, {0x0000006B}, {0x06020102}, {0x05010202},	/*  9 */
+  {0x05010202}, {0x06020001}, {0x06000201}, {0x04010102}, {0x04010102},	/* 14 */
+  {0x04010102}, {0x04010102}, {0x03010001}, {0x03010001}, {0x03010001},	/* 19 */
+  {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001},	/* 24 */
+  {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101},	/* 29 */
+  {0x03000101}, {0x03000101}, {0x03000101}, {0x01000000}, {0x01000000},	/* 34 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 39 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 44 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 49 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 54 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 59 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 64 */
+  {0xFF000004}, {0x04050502}, {0x04050402}, {0x04040502}, {0x04030502},	/* 69 */
+  {0x03050302}, {0x03050302}, {0x03040402}, {0x03040402}, {0x03050202},	/* 74 */
+  {0x03050202}, {0x03020502}, {0x03020502}, {0x02050102}, {0x02050102},	/* 79 */
+  {0x02050102}, {0x02050102}, {0xFF000003}, {0x02010502}, {0x02010502},	/* 84 */
+  {0x03050001}, {0x03040302}, {0x02000501}, {0x02000501}, {0x03030402},	/* 89 */
+  {0x03030302}, {0xFF000002}, {0x02040202}, {0x02020402}, {0x01040102},	/* 94 */
+  {0x01040102}, {0xFF000001}, {0x01010402}, {0x01000401}, {0xFF000002},	/* 99 */
+  {0x02040001}, {0x02030202}, {0x02020302}, {0x02030001}, {0xFF000001},	/* 104 */
+  {0x01030102}, {0x01010302}, {0xFF000001}, {0x01000301}, {0x01020202}, /* 109 */
+};
+
+/* max table bits  6 */
+
+/* TABLE  8   36 entries  maxbits 11  linbits  0 */
+static const HUFF_ELEMENT huff_table_8[] =
+{
+  {0xFF000008}, {0x00000101}, {0x0000010A}, {0x0000010F}, {0x08050102},	/*  4 */
+  {0x08010502}, {0x00000112}, {0x00000115}, {0x08040202}, {0x08020402},	/*  9 */
+  {0x08040102}, {0x07010402}, {0x07010402}, {0x08040001}, {0x08000401},	/* 14 */
+  {0x08030202}, {0x08020302}, {0x08030102}, {0x08010302}, {0x08030001},	/* 19 */
+  {0x08000301}, {0x06020202}, {0x06020202}, {0x06020202}, {0x06020202},	/* 24 */
+  {0x06020001}, {0x06020001}, {0x06020001}, {0x06020001}, {0x06000201},	/* 29 */
+  {0x06000201}, {0x06000201}, {0x06000201}, {0x04020102}, {0x04020102},	/* 34 */
+  {0x04020102}, {0x04020102}, {0x04020102}, {0x04020102}, {0x04020102},	/* 39 */
+  {0x04020102}, {0x04020102}, {0x04020102}, {0x04020102}, {0x04020102},	/* 44 */
+  {0x04020102}, {0x04020102}, {0x04020102}, {0x04020102}, {0x04010202},	/* 49 */
+  {0x04010202}, {0x04010202}, {0x04010202}, {0x04010202}, {0x04010202},	/* 54 */
+  {0x04010202}, {0x04010202}, {0x04010202}, {0x04010202}, {0x04010202},	/* 59 */
+  {0x04010202}, {0x04010202}, {0x04010202}, {0x04010202}, {0x04010202},	/* 64 */
+  {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102},	/* 69 */
+  {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102},	/* 74 */
+  {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102},	/* 79 */
+  {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102},	/* 84 */
+  {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102},	/* 89 */
+  {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102},	/* 94 */
+  {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102},	/* 99 */
+  {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102},	/* 104 */
+  {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102},	/* 109 */
+  {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102},	/* 114 */
+  {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102},	/* 119 */
+  {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102},	/* 124 */
+  {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102}, {0x03010001},	/* 129 */
+  {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001},	/* 134 */
+  {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001},	/* 139 */
+  {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001},	/* 144 */
+  {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001},	/* 149 */
+  {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001},	/* 154 */
+  {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001},	/* 159 */
+  {0x03010001}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101},	/* 164 */
+  {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101},	/* 169 */
+  {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101},	/* 174 */
+  {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101},	/* 179 */
+  {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101},	/* 184 */
+  {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101},	/* 189 */
+  {0x03000101}, {0x03000101}, {0x03000101}, {0x02000000}, {0x02000000},	/* 194 */
+  {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000},	/* 199 */
+  {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000},	/* 204 */
+  {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000},	/* 209 */
+  {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000},	/* 214 */
+  {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000},	/* 219 */
+  {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000},	/* 224 */
+  {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000},	/* 229 */
+  {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000},	/* 234 */
+  {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000},	/* 239 */
+  {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000},	/* 244 */
+  {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000},	/* 249 */
+  {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000},	/* 254 */
+  {0x02000000}, {0x02000000}, {0xFF000003}, {0x03050502}, {0x03040502},	/* 259 */
+  {0x02050402}, {0x02050402}, {0x01030502}, {0x01030502}, {0x01030502},	/* 264 */
+  {0x01030502}, {0xFF000002}, {0x02050302}, {0x02040402}, {0x01050202},	/* 269 */
+  {0x01050202}, {0xFF000001}, {0x01020502}, {0x01050001}, {0xFF000001},	/* 274 */
+  {0x01040302}, {0x01030402}, {0xFF000001}, {0x01000501}, {0x01030302}, /* 279 */
+};
+
+/* max table bits  8 */
+
+/* TABLE  9   36 entries  maxbits  9  linbits  0 */
+static const HUFF_ELEMENT huff_table_9[] =
+{
+  {0xFF000006}, {0x00000041}, {0x0000004A}, {0x0000004F}, {0x00000052},	/*  4 */
+  {0x00000057}, {0x0000005A}, {0x06040102}, {0x06010402}, {0x06030202},	/*  9 */
+  {0x06020302}, {0x05030102}, {0x05030102}, {0x05010302}, {0x05010302},	/* 14 */
+  {0x06030001}, {0x06000301}, {0x05020202}, {0x05020202}, {0x05020001},	/* 19 */
+  {0x05020001}, {0x04020102}, {0x04020102}, {0x04020102}, {0x04020102},	/* 24 */
+  {0x04010202}, {0x04010202}, {0x04010202}, {0x04010202}, {0x04000201},	/* 29 */
+  {0x04000201}, {0x04000201}, {0x04000201}, {0x03010102}, {0x03010102},	/* 34 */
+  {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102},	/* 39 */
+  {0x03010102}, {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001},	/* 44 */
+  {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, {0x03000101},	/* 49 */
+  {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101},	/* 54 */
+  {0x03000101}, {0x03000101}, {0x03000000}, {0x03000000}, {0x03000000},	/* 59 */
+  {0x03000000}, {0x03000000}, {0x03000000}, {0x03000000}, {0x03000000},	/* 64 */
+  {0xFF000003}, {0x03050502}, {0x03050402}, {0x02050302}, {0x02050302},	/* 69 */
+  {0x02030502}, {0x02030502}, {0x03040502}, {0x03050001}, {0xFF000002},	/* 74 */
+  {0x02040402}, {0x02050202}, {0x02020502}, {0x02050102}, {0xFF000001},	/* 79 */
+  {0x01010502}, {0x01040302}, {0xFF000002}, {0x01030402}, {0x01030402},	/* 84 */
+  {0x02000501}, {0x02040001}, {0xFF000001}, {0x01040202}, {0x01020402},	/* 89 */
+  {0xFF000001}, {0x01030302}, {0x01000401},
+};
+
+/* max table bits  6 */
+
+/* TABLE 10   64 entries  maxbits 11  linbits  0 */
+static const HUFF_ELEMENT huff_table_10[] =
+{
+  {0xFF000008}, {0x00000101}, {0x0000010A}, {0x0000010F}, {0x00000118},	/*  4 */
+  {0x0000011B}, {0x00000120}, {0x00000125}, {0x08070102}, {0x08010702},	/*  9 */
+  {0x0000012A}, {0x0000012D}, {0x00000132}, {0x08060102}, {0x08010602},	/* 14 */
+  {0x08000601}, {0x00000137}, {0x0000013A}, {0x0000013D}, {0x08040102},	/* 19 */
+  {0x08010402}, {0x08000401}, {0x08030202}, {0x08020302}, {0x08030001},	/* 24 */
+  {0x07030102}, {0x07030102}, {0x07010302}, {0x07010302}, {0x07000301},	/* 29 */
+  {0x07000301}, {0x07020202}, {0x07020202}, {0x06020102}, {0x06020102},	/* 34 */
+  {0x06020102}, {0x06020102}, {0x06010202}, {0x06010202}, {0x06010202},	/* 39 */
+  {0x06010202}, {0x06020001}, {0x06020001}, {0x06020001}, {0x06020001},	/* 44 */
+  {0x06000201}, {0x06000201}, {0x06000201}, {0x06000201}, {0x04010102},	/* 49 */
+  {0x04010102}, {0x04010102}, {0x04010102}, {0x04010102}, {0x04010102},	/* 54 */
+  {0x04010102}, {0x04010102}, {0x04010102}, {0x04010102}, {0x04010102},	/* 59 */
+  {0x04010102}, {0x04010102}, {0x04010102}, {0x04010102}, {0x04010102},	/* 64 */
+  {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001},	/* 69 */
+  {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001},	/* 74 */
+  {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001},	/* 79 */
+  {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001},	/* 84 */
+  {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001},	/* 89 */
+  {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001},	/* 94 */
+  {0x03010001}, {0x03010001}, {0x03000101}, {0x03000101}, {0x03000101},	/* 99 */
+  {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101},	/* 104 */
+  {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101},	/* 109 */
+  {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101},	/* 114 */
+  {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101},	/* 119 */
+  {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101},	/* 124 */
+  {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x01000000},	/* 129 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 134 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 139 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 144 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 149 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 154 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 159 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 164 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 169 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 174 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 179 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 184 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 189 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 194 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 199 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 204 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 209 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 214 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 219 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 224 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 229 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 234 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 239 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 244 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 249 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 254 */
+  {0x01000000}, {0x01000000}, {0xFF000003}, {0x03070702}, {0x03070602},	/* 259 */
+  {0x03060702}, {0x03070502}, {0x03050702}, {0x03060602}, {0x02070402},	/* 264 */
+  {0x02070402}, {0xFF000002}, {0x02040702}, {0x02060502}, {0x02050602},	/* 269 */
+  {0x02070302}, {0xFF000003}, {0x02030702}, {0x02030702}, {0x02060402},	/* 274 */
+  {0x02060402}, {0x03050502}, {0x03040502}, {0x02030602}, {0x02030602},	/* 279 */
+  {0xFF000001}, {0x01070202}, {0x01020702}, {0xFF000002}, {0x02040602},	/* 284 */
+  {0x02070001}, {0x01000701}, {0x01000701}, {0xFF000002}, {0x01020602},	/* 289 */
+  {0x01020602}, {0x02050402}, {0x02050302}, {0xFF000002}, {0x01060001},	/* 294 */
+  {0x01060001}, {0x02030502}, {0x02040402}, {0xFF000001}, {0x01060302},	/* 299 */
+  {0x01060202}, {0xFF000002}, {0x02050202}, {0x02020502}, {0x01050102},	/* 304 */
+  {0x01050102}, {0xFF000002}, {0x01010502}, {0x01010502}, {0x02040302},	/* 309 */
+  {0x02030402}, {0xFF000001}, {0x01050001}, {0x01000501}, {0xFF000001},	/* 314 */
+  {0x01040202}, {0x01020402}, {0xFF000001}, {0x01030302}, {0x01040001}, /* 319 */
+};
+
+/* max table bits  8 */
+
+/* TABLE 11   64 entries  maxbits 11  linbits  0 */
+static const HUFF_ELEMENT huff_table_11[] =
+{
+  {0xFF000008}, {0x00000101}, {0x00000106}, {0x0000010F}, {0x00000114},	/*  4 */
+  {0x00000117}, {0x08070202}, {0x08020702}, {0x0000011C}, {0x07010702},	/*  9 */
+  {0x07010702}, {0x08070102}, {0x08000701}, {0x08060302}, {0x08030602},	/* 14 */
+  {0x08000601}, {0x0000011F}, {0x00000122}, {0x08050102}, {0x07020602},	/* 19 */
+  {0x07020602}, {0x08060202}, {0x08060001}, {0x07060102}, {0x07060102},	/* 24 */
+  {0x07010602}, {0x07010602}, {0x08010502}, {0x08040302}, {0x08000501},	/* 29 */
+  {0x00000125}, {0x08040202}, {0x08020402}, {0x08040102}, {0x08010402},	/* 34 */
+  {0x08040001}, {0x08000401}, {0x07030202}, {0x07030202}, {0x07020302},	/* 39 */
+  {0x07020302}, {0x06030102}, {0x06030102}, {0x06030102}, {0x06030102},	/* 44 */
+  {0x06010302}, {0x06010302}, {0x06010302}, {0x06010302}, {0x07030001},	/* 49 */
+  {0x07030001}, {0x07000301}, {0x07000301}, {0x06020202}, {0x06020202},	/* 54 */
+  {0x06020202}, {0x06020202}, {0x05010202}, {0x05010202}, {0x05010202},	/* 59 */
+  {0x05010202}, {0x05010202}, {0x05010202}, {0x05010202}, {0x05010202},	/* 64 */
+  {0x04020102}, {0x04020102}, {0x04020102}, {0x04020102}, {0x04020102},	/* 69 */
+  {0x04020102}, {0x04020102}, {0x04020102}, {0x04020102}, {0x04020102},	/* 74 */
+  {0x04020102}, {0x04020102}, {0x04020102}, {0x04020102}, {0x04020102},	/* 79 */
+  {0x04020102}, {0x05020001}, {0x05020001}, {0x05020001}, {0x05020001},	/* 84 */
+  {0x05020001}, {0x05020001}, {0x05020001}, {0x05020001}, {0x05000201},	/* 89 */
+  {0x05000201}, {0x05000201}, {0x05000201}, {0x05000201}, {0x05000201},	/* 94 */
+  {0x05000201}, {0x05000201}, {0x03010102}, {0x03010102}, {0x03010102},	/* 99 */
+  {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102},	/* 104 */
+  {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102},	/* 109 */
+  {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102},	/* 114 */
+  {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102},	/* 119 */
+  {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102},	/* 124 */
+  {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102}, {0x03010001},	/* 129 */
+  {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001},	/* 134 */
+  {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001},	/* 139 */
+  {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001},	/* 144 */
+  {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001},	/* 149 */
+  {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001},	/* 154 */
+  {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001},	/* 159 */
+  {0x03010001}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101},	/* 164 */
+  {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101},	/* 169 */
+  {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101},	/* 174 */
+  {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101},	/* 179 */
+  {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101},	/* 184 */
+  {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101},	/* 189 */
+  {0x03000101}, {0x03000101}, {0x03000101}, {0x02000000}, {0x02000000},	/* 194 */
+  {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000},	/* 199 */
+  {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000},	/* 204 */
+  {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000},	/* 209 */
+  {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000},	/* 214 */
+  {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000},	/* 219 */
+  {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000},	/* 224 */
+  {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000},	/* 229 */
+  {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000},	/* 234 */
+  {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000},	/* 239 */
+  {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000},	/* 244 */
+  {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000},	/* 249 */
+  {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000},	/* 254 */
+  {0x02000000}, {0x02000000}, {0xFF000002}, {0x02070702}, {0x02070602},	/* 259 */
+  {0x02060702}, {0x02050702}, {0xFF000003}, {0x02060602}, {0x02060602},	/* 264 */
+  {0x02070402}, {0x02070402}, {0x02040702}, {0x02040702}, {0x03070502},	/* 269 */
+  {0x03050502}, {0xFF000002}, {0x02060502}, {0x02050602}, {0x01070302},	/* 274 */
+  {0x01070302}, {0xFF000001}, {0x01030702}, {0x01060402}, {0xFF000002},	/* 279 */
+  {0x02050402}, {0x02040502}, {0x02050302}, {0x02030502}, {0xFF000001},	/* 284 */
+  {0x01040602}, {0x01070001}, {0xFF000001}, {0x01040402}, {0x01050202},	/* 289 */
+  {0xFF000001}, {0x01020502}, {0x01050001}, {0xFF000001}, {0x01030402},	/* 294 */
+  {0x01030302},
+};
+
+/* max table bits  8 */
+
+/* TABLE 12   64 entries  maxbits 10  linbits  0 */
+static const HUFF_ELEMENT huff_table_12[] =
+{
+  {0xFF000007}, {0x00000081}, {0x0000008A}, {0x0000008F}, {0x00000092},	/*  4 */
+  {0x00000097}, {0x0000009A}, {0x0000009D}, {0x000000A2}, {0x000000A5},	/*  9 */
+  {0x000000A8}, {0x07060202}, {0x07020602}, {0x07010602}, {0x000000AD},	/* 14 */
+  {0x000000B0}, {0x000000B3}, {0x07050102}, {0x07010502}, {0x07040302},	/* 19 */
+  {0x07030402}, {0x000000B6}, {0x07040202}, {0x07020402}, {0x07040102},	/* 24 */
+  {0x06030302}, {0x06030302}, {0x06010402}, {0x06010402}, {0x06030202},	/* 29 */
+  {0x06030202}, {0x06020302}, {0x06020302}, {0x07000401}, {0x07030001},	/* 34 */
+  {0x06000301}, {0x06000301}, {0x05030102}, {0x05030102}, {0x05030102},	/* 39 */
+  {0x05030102}, {0x05010302}, {0x05010302}, {0x05010302}, {0x05010302},	/* 44 */
+  {0x05020202}, {0x05020202}, {0x05020202}, {0x05020202}, {0x04020102},	/* 49 */
+  {0x04020102}, {0x04020102}, {0x04020102}, {0x04020102}, {0x04020102},	/* 54 */
+  {0x04020102}, {0x04020102}, {0x04010202}, {0x04010202}, {0x04010202},	/* 59 */
+  {0x04010202}, {0x04010202}, {0x04010202}, {0x04010202}, {0x04010202},	/* 64 */
+  {0x05020001}, {0x05020001}, {0x05020001}, {0x05020001}, {0x05000201},	/* 69 */
+  {0x05000201}, {0x05000201}, {0x05000201}, {0x04000000}, {0x04000000},	/* 74 */
+  {0x04000000}, {0x04000000}, {0x04000000}, {0x04000000}, {0x04000000},	/* 79 */
+  {0x04000000}, {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102},	/* 84 */
+  {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102},	/* 89 */
+  {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102},	/* 94 */
+  {0x03010102}, {0x03010102}, {0x03010001}, {0x03010001}, {0x03010001},	/* 99 */
+  {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001},	/* 104 */
+  {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001},	/* 109 */
+  {0x03010001}, {0x03010001}, {0x03010001}, {0x03000101}, {0x03000101},	/* 114 */
+  {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101},	/* 119 */
+  {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101},	/* 124 */
+  {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0xFF000003},	/* 129 */
+  {0x03070702}, {0x03070602}, {0x02060702}, {0x02060702}, {0x02070502},	/* 134 */
+  {0x02070502}, {0x02050702}, {0x02050702}, {0xFF000002}, {0x02060602},	/* 139 */
+  {0x02070402}, {0x02040702}, {0x02050602}, {0xFF000001}, {0x01060502},	/* 144 */
+  {0x01070302}, {0xFF000002}, {0x02030702}, {0x02050502}, {0x01070202},	/* 149 */
+  {0x01070202}, {0xFF000001}, {0x01020702}, {0x01060402}, {0xFF000001},	/* 154 */
+  {0x01040602}, {0x01070102}, {0xFF000002}, {0x01010702}, {0x01010702},	/* 159 */
+  {0x02070001}, {0x02000701}, {0xFF000001}, {0x01060302}, {0x01030602},	/* 164 */
+  {0xFF000001}, {0x01050402}, {0x01040502}, {0xFF000002}, {0x01040402},	/* 169 */
+  {0x01040402}, {0x02060001}, {0x02050001}, {0xFF000001}, {0x01060102},	/* 174 */
+  {0x01000601}, {0xFF000001}, {0x01050302}, {0x01030502}, {0xFF000001},	/* 179 */
+  {0x01050202}, {0x01020502}, {0xFF000001}, {0x01000501}, {0x01040001}, /* 184 */
+};
+
+/* max table bits  7 */
+
+/* TABLE 13  256 entries  maxbits 19  linbits  0 */
+static const HUFF_ELEMENT huff_table_13[] =
+{
+  {0xFF000006}, {0x00000041}, {0x00000082}, {0x000000C3}, {0x000000E4},	/*  4 */
+  {0x00000105}, {0x00000116}, {0x0000011F}, {0x00000130}, {0x00000139},	/*  9 */
+  {0x0000013E}, {0x00000143}, {0x00000146}, {0x06020102}, {0x06010202},	/* 14 */
+  {0x06020001}, {0x06000201}, {0x04010102}, {0x04010102}, {0x04010102},	/* 19 */
+  {0x04010102}, {0x04010001}, {0x04010001}, {0x04010001}, {0x04010001},	/* 24 */
+  {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101},	/* 29 */
+  {0x03000101}, {0x03000101}, {0x03000101}, {0x01000000}, {0x01000000},	/* 34 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 39 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 44 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 49 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 54 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 59 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 64 */
+  {0xFF000006}, {0x00000108}, {0x00000111}, {0x0000011A}, {0x00000123},	/* 69 */
+  {0x0000012C}, {0x00000131}, {0x00000136}, {0x0000013F}, {0x00000144},	/* 74 */
+  {0x00000147}, {0x0000014C}, {0x00000151}, {0x00000156}, {0x0000015B},	/* 79 */
+  {0x060F0102}, {0x06010F02}, {0x06000F01}, {0x00000160}, {0x00000163},	/* 84 */
+  {0x00000166}, {0x06020E02}, {0x00000169}, {0x060E0102}, {0x06010E02},	/* 89 */
+  {0x0000016C}, {0x0000016F}, {0x00000172}, {0x00000175}, {0x00000178},	/* 94 */
+  {0x0000017B}, {0x06060C02}, {0x060D0302}, {0x0000017E}, {0x060D0202},	/* 99 */
+  {0x06020D02}, {0x060D0102}, {0x06070B02}, {0x00000181}, {0x00000184},	/* 104 */
+  {0x06030C02}, {0x00000187}, {0x060B0402}, {0x05010D02}, {0x05010D02},	/* 109 */
+  {0x060D0001}, {0x06000D01}, {0x060A0802}, {0x06080A02}, {0x060C0402},	/* 114 */
+  {0x06040C02}, {0x060B0602}, {0x06060B02}, {0x050C0302}, {0x050C0302},	/* 119 */
+  {0x050C0202}, {0x050C0202}, {0x05020C02}, {0x05020C02}, {0x050B0502},	/* 124 */
+  {0x050B0502}, {0x06050B02}, {0x06090802}, {0x050C0102}, {0x050C0102},	/* 129 */
+  {0xFF000006}, {0x05010C02}, {0x05010C02}, {0x06080902}, {0x060C0001},	/* 134 */
+  {0x05000C01}, {0x05000C01}, {0x06040B02}, {0x060A0602}, {0x06060A02},	/* 139 */
+  {0x06090702}, {0x050B0302}, {0x050B0302}, {0x05030B02}, {0x05030B02},	/* 144 */
+  {0x06080802}, {0x060A0502}, {0x050B0202}, {0x050B0202}, {0x06050A02},	/* 149 */
+  {0x06090602}, {0x05040A02}, {0x05040A02}, {0x06080702}, {0x06070802},	/* 154 */
+  {0x05040902}, {0x05040902}, {0x06070702}, {0x06060702}, {0x04020B02},	/* 159 */
+  {0x04020B02}, {0x04020B02}, {0x04020B02}, {0x040B0102}, {0x040B0102},	/* 164 */
+  {0x040B0102}, {0x040B0102}, {0x04010B02}, {0x04010B02}, {0x04010B02},	/* 169 */
+  {0x04010B02}, {0x050B0001}, {0x050B0001}, {0x05000B01}, {0x05000B01},	/* 174 */
+  {0x05060902}, {0x05060902}, {0x050A0402}, {0x050A0402}, {0x050A0302},	/* 179 */
+  {0x050A0302}, {0x05030A02}, {0x05030A02}, {0x05090502}, {0x05090502},	/* 184 */
+  {0x05050902}, {0x05050902}, {0x040A0202}, {0x040A0202}, {0x040A0202},	/* 189 */
+  {0x040A0202}, {0x04020A02}, {0x04020A02}, {0x04020A02}, {0x04020A02},	/* 194 */
+  {0xFF000005}, {0x040A0102}, {0x040A0102}, {0x04010A02}, {0x04010A02},	/* 199 */
+  {0x050A0001}, {0x05080602}, {0x04000A01}, {0x04000A01}, {0x05060802},	/* 204 */
+  {0x05090402}, {0x04030902}, {0x04030902}, {0x05090302}, {0x05080502},	/* 209 */
+  {0x05050802}, {0x05070602}, {0x04090202}, {0x04090202}, {0x04020902},	/* 214 */
+  {0x04020902}, {0x05070502}, {0x05050702}, {0x04080302}, {0x04080302},	/* 219 */
+  {0x04030802}, {0x04030802}, {0x05060602}, {0x05070402}, {0x05040702},	/* 224 */
+  {0x05060502}, {0x05050602}, {0x05030702}, {0xFF000005}, {0x03090102},	/* 229 */
+  {0x03090102}, {0x03090102}, {0x03090102}, {0x03010902}, {0x03010902},	/* 234 */
+  {0x03010902}, {0x03010902}, {0x04090001}, {0x04090001}, {0x04000901},	/* 239 */
+  {0x04000901}, {0x04080402}, {0x04080402}, {0x04040802}, {0x04040802},	/* 244 */
+  {0x04020702}, {0x04020702}, {0x05060402}, {0x05040602}, {0x03080202},	/* 249 */
+  {0x03080202}, {0x03080202}, {0x03080202}, {0x03020802}, {0x03020802},	/* 254 */
+  {0x03020802}, {0x03020802}, {0x03080102}, {0x03080102}, {0x03080102},	/* 259 */
+  {0x03080102}, {0xFF000004}, {0x04070302}, {0x04070202}, {0x03070102},	/* 264 */
+  {0x03070102}, {0x03010702}, {0x03010702}, {0x04050502}, {0x04070001},	/* 269 */
+  {0x04000701}, {0x04060302}, {0x04030602}, {0x04050402}, {0x04040502},	/* 274 */
+  {0x04060202}, {0x04020602}, {0x04050302}, {0xFF000003}, {0x02010802},	/* 279 */
+  {0x02010802}, {0x03080001}, {0x03000801}, {0x03060102}, {0x03010602},	/* 284 */
+  {0x03060001}, {0x03000601}, {0xFF000004}, {0x04030502}, {0x04040402},	/* 289 */
+  {0x03050202}, {0x03050202}, {0x03020502}, {0x03020502}, {0x03050001},	/* 294 */
+  {0x03050001}, {0x02050102}, {0x02050102}, {0x02050102}, {0x02050102},	/* 299 */
+  {0x02010502}, {0x02010502}, {0x02010502}, {0x02010502}, {0xFF000003},	/* 304 */
+  {0x03040302}, {0x03030402}, {0x03000501}, {0x03040202}, {0x03020402},	/* 309 */
+  {0x03030302}, {0x02040102}, {0x02040102}, {0xFF000002}, {0x01010402},	/* 314 */
+  {0x01010402}, {0x02040001}, {0x02000401}, {0xFF000002}, {0x02030202},	/* 319 */
+  {0x02020302}, {0x01030102}, {0x01030102}, {0xFF000001}, {0x01010302},	/* 324 */
+  {0x01030001}, {0xFF000001}, {0x01000301}, {0x01020202}, {0xFF000003},	/* 329 */
+  {0x00000082}, {0x0000008B}, {0x0000008E}, {0x00000091}, {0x00000094},	/* 334 */
+  {0x00000097}, {0x030C0E02}, {0x030D0D02}, {0xFF000003}, {0x00000093},	/* 339 */
+  {0x030E0B02}, {0x030B0E02}, {0x030F0902}, {0x03090F02}, {0x030A0E02},	/* 344 */
+  {0x030D0B02}, {0x030B0D02}, {0xFF000003}, {0x030F0802}, {0x03080F02},	/* 349 */
+  {0x030C0C02}, {0x0000008D}, {0x030E0802}, {0x00000090}, {0x02070F02},	/* 354 */
+  {0x02070F02}, {0xFF000003}, {0x020A0D02}, {0x020A0D02}, {0x030D0A02},	/* 359 */
+  {0x030C0B02}, {0x030B0C02}, {0x03060F02}, {0x020F0602}, {0x020F0602},	/* 364 */
+  {0xFF000002}, {0x02080E02}, {0x020F0502}, {0x020D0902}, {0x02090D02},	/* 369 */
+  {0xFF000002}, {0x02050F02}, {0x02070E02}, {0x020C0A02}, {0x020B0B02},	/* 374 */
+  {0xFF000003}, {0x020F0402}, {0x020F0402}, {0x02040F02}, {0x02040F02},	/* 379 */
+  {0x030A0C02}, {0x03060E02}, {0x02030F02}, {0x02030F02}, {0xFF000002},	/* 384 */
+  {0x010F0302}, {0x010F0302}, {0x020D0802}, {0x02080D02}, {0xFF000001},	/* 389 */
+  {0x010F0202}, {0x01020F02}, {0xFF000002}, {0x020E0602}, {0x020C0902},	/* 394 */
+  {0x010F0001}, {0x010F0001}, {0xFF000002}, {0x02090C02}, {0x020E0502},	/* 399 */
+  {0x010B0A02}, {0x010B0A02}, {0xFF000002}, {0x020D0702}, {0x02070D02},	/* 404 */
+  {0x010E0402}, {0x010E0402}, {0xFF000002}, {0x02080C02}, {0x02060D02},	/* 409 */
+  {0x010E0302}, {0x010E0302}, {0xFF000002}, {0x01090B02}, {0x01090B02},	/* 414 */
+  {0x020B0902}, {0x020A0A02}, {0xFF000001}, {0x010A0B02}, {0x01050E02},	/* 419 */
+  {0xFF000001}, {0x01040E02}, {0x010C0802}, {0xFF000001}, {0x010D0602},	/* 424 */
+  {0x01030E02}, {0xFF000001}, {0x010E0202}, {0x010E0001}, {0xFF000001},	/* 429 */
+  {0x01000E01}, {0x010D0502}, {0xFF000001}, {0x01050D02}, {0x010C0702},	/* 434 */
+  {0xFF000001}, {0x01070C02}, {0x010D0402}, {0xFF000001}, {0x010B0802},	/* 439 */
+  {0x01080B02}, {0xFF000001}, {0x01040D02}, {0x010A0902}, {0xFF000001},	/* 444 */
+  {0x01090A02}, {0x010C0602}, {0xFF000001}, {0x01030D02}, {0x010B0702},	/* 449 */
+  {0xFF000001}, {0x010C0502}, {0x01050C02}, {0xFF000001}, {0x01090902},	/* 454 */
+  {0x010A0702}, {0xFF000001}, {0x01070A02}, {0x01070902}, {0xFF000003},	/* 459 */
+  {0x00000023}, {0x030D0F02}, {0x020D0E02}, {0x020D0E02}, {0x010F0F02},	/* 464 */
+  {0x010F0F02}, {0x010F0F02}, {0x010F0F02}, {0xFF000001}, {0x010F0E02},	/* 469 */
+  {0x010F0D02}, {0xFF000001}, {0x010E0E02}, {0x010F0C02}, {0xFF000001},	/* 474 */
+  {0x010E0D02}, {0x010F0B02}, {0xFF000001}, {0x010B0F02}, {0x010E0C02},	/* 479 */
+  {0xFF000002}, {0x010C0D02}, {0x010C0D02}, {0x020F0A02}, {0x02090E02},	/* 484 */
+  {0xFF000001}, {0x010A0F02}, {0x010D0C02}, {0xFF000001}, {0x010E0A02},	/* 489 */
+  {0x010E0902}, {0xFF000001}, {0x010F0702}, {0x010E0702}, {0xFF000001},	/* 494 */
+  {0x010E0F02}, {0x010C0F02},
+};
+
+/* max table bits  6 */
+/* NO XING TABLE 14 */
+
+/* TABLE 15  256 entries  maxbits 13  linbits  0 */
+static const HUFF_ELEMENT huff_table_15[] =
+{
+  {0xFF000008}, {0x00000101}, {0x00000122}, {0x00000143}, {0x00000154},	/*  4 */
+  {0x00000165}, {0x00000176}, {0x0000017F}, {0x00000188}, {0x00000199},	/*  9 */
+  {0x000001A2}, {0x000001AB}, {0x000001B4}, {0x000001BD}, {0x000001C2},	/* 14 */
+  {0x000001CB}, {0x000001D4}, {0x000001D9}, {0x000001DE}, {0x000001E3},	/* 19 */
+  {0x000001E8}, {0x000001ED}, {0x000001F2}, {0x000001F7}, {0x000001FC},	/* 24 */
+  {0x00000201}, {0x00000204}, {0x00000207}, {0x0000020A}, {0x0000020F},	/* 29 */
+  {0x00000212}, {0x00000215}, {0x0000021A}, {0x0000021D}, {0x00000220},	/* 34 */
+  {0x08010902}, {0x00000223}, {0x00000226}, {0x00000229}, {0x0000022C},	/* 39 */
+  {0x0000022F}, {0x08080202}, {0x08020802}, {0x08080102}, {0x08010802},	/* 44 */
+  {0x00000232}, {0x00000235}, {0x00000238}, {0x0000023B}, {0x08070202},	/* 49 */
+  {0x08020702}, {0x08040602}, {0x08070102}, {0x08050502}, {0x08010702},	/* 54 */
+  {0x0000023E}, {0x08060302}, {0x08030602}, {0x08050402}, {0x08040502},	/* 59 */
+  {0x08060202}, {0x08020602}, {0x08060102}, {0x00000241}, {0x08050302},	/* 64 */
+  {0x07010602}, {0x07010602}, {0x08030502}, {0x08040402}, {0x07050202},	/* 69 */
+  {0x07050202}, {0x07020502}, {0x07020502}, {0x07050102}, {0x07050102},	/* 74 */
+  {0x07010502}, {0x07010502}, {0x08050001}, {0x08000501}, {0x07040302},	/* 79 */
+  {0x07040302}, {0x07030402}, {0x07030402}, {0x07040202}, {0x07040202},	/* 84 */
+  {0x07020402}, {0x07020402}, {0x07030302}, {0x07030302}, {0x06010402},	/* 89 */
+  {0x06010402}, {0x06010402}, {0x06010402}, {0x07040102}, {0x07040102},	/* 94 */
+  {0x07040001}, {0x07040001}, {0x06030202}, {0x06030202}, {0x06030202},	/* 99 */
+  {0x06030202}, {0x06020302}, {0x06020302}, {0x06020302}, {0x06020302},	/* 104 */
+  {0x07000401}, {0x07000401}, {0x07030001}, {0x07030001}, {0x06030102},	/* 109 */
+  {0x06030102}, {0x06030102}, {0x06030102}, {0x06010302}, {0x06010302},	/* 114 */
+  {0x06010302}, {0x06010302}, {0x06000301}, {0x06000301}, {0x06000301},	/* 119 */
+  {0x06000301}, {0x05020202}, {0x05020202}, {0x05020202}, {0x05020202},	/* 124 */
+  {0x05020202}, {0x05020202}, {0x05020202}, {0x05020202}, {0x05020102},	/* 129 */
+  {0x05020102}, {0x05020102}, {0x05020102}, {0x05020102}, {0x05020102},	/* 134 */
+  {0x05020102}, {0x05020102}, {0x05010202}, {0x05010202}, {0x05010202},	/* 139 */
+  {0x05010202}, {0x05010202}, {0x05010202}, {0x05010202}, {0x05010202},	/* 144 */
+  {0x05020001}, {0x05020001}, {0x05020001}, {0x05020001}, {0x05020001},	/* 149 */
+  {0x05020001}, {0x05020001}, {0x05020001}, {0x05000201}, {0x05000201},	/* 154 */
+  {0x05000201}, {0x05000201}, {0x05000201}, {0x05000201}, {0x05000201},	/* 159 */
+  {0x05000201}, {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102},	/* 164 */
+  {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102},	/* 169 */
+  {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102},	/* 174 */
+  {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102},	/* 179 */
+  {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102},	/* 184 */
+  {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102},	/* 189 */
+  {0x03010102}, {0x03010102}, {0x03010102}, {0x04010001}, {0x04010001},	/* 194 */
+  {0x04010001}, {0x04010001}, {0x04010001}, {0x04010001}, {0x04010001},	/* 199 */
+  {0x04010001}, {0x04010001}, {0x04010001}, {0x04010001}, {0x04010001},	/* 204 */
+  {0x04010001}, {0x04010001}, {0x04010001}, {0x04010001}, {0x04000101},	/* 209 */
+  {0x04000101}, {0x04000101}, {0x04000101}, {0x04000101}, {0x04000101},	/* 214 */
+  {0x04000101}, {0x04000101}, {0x04000101}, {0x04000101}, {0x04000101},	/* 219 */
+  {0x04000101}, {0x04000101}, {0x04000101}, {0x04000101}, {0x04000101},	/* 224 */
+  {0x03000000}, {0x03000000}, {0x03000000}, {0x03000000}, {0x03000000},	/* 229 */
+  {0x03000000}, {0x03000000}, {0x03000000}, {0x03000000}, {0x03000000},	/* 234 */
+  {0x03000000}, {0x03000000}, {0x03000000}, {0x03000000}, {0x03000000},	/* 239 */
+  {0x03000000}, {0x03000000}, {0x03000000}, {0x03000000}, {0x03000000},	/* 244 */
+  {0x03000000}, {0x03000000}, {0x03000000}, {0x03000000}, {0x03000000},	/* 249 */
+  {0x03000000}, {0x03000000}, {0x03000000}, {0x03000000}, {0x03000000},	/* 254 */
+  {0x03000000}, {0x03000000}, {0xFF000005}, {0x050F0F02}, {0x050F0E02},	/* 259 */
+  {0x050E0F02}, {0x050F0D02}, {0x040E0E02}, {0x040E0E02}, {0x050D0F02},	/* 264 */
+  {0x050F0C02}, {0x050C0F02}, {0x050E0D02}, {0x050D0E02}, {0x050F0B02},	/* 269 */
+  {0x040B0F02}, {0x040B0F02}, {0x050E0C02}, {0x050C0E02}, {0x040D0D02},	/* 274 */
+  {0x040D0D02}, {0x040F0A02}, {0x040F0A02}, {0x040A0F02}, {0x040A0F02},	/* 279 */
+  {0x040E0B02}, {0x040E0B02}, {0x040B0E02}, {0x040B0E02}, {0x040D0C02},	/* 284 */
+  {0x040D0C02}, {0x040C0D02}, {0x040C0D02}, {0x040F0902}, {0x040F0902},	/* 289 */
+  {0xFF000005}, {0x04090F02}, {0x04090F02}, {0x040A0E02}, {0x040A0E02},	/* 294 */
+  {0x040D0B02}, {0x040D0B02}, {0x040B0D02}, {0x040B0D02}, {0x040F0802},	/* 299 */
+  {0x040F0802}, {0x04080F02}, {0x04080F02}, {0x040C0C02}, {0x040C0C02},	/* 304 */
+  {0x040E0902}, {0x040E0902}, {0x04090E02}, {0x04090E02}, {0x040F0702},	/* 309 */
+  {0x040F0702}, {0x04070F02}, {0x04070F02}, {0x040D0A02}, {0x040D0A02},	/* 314 */
+  {0x040A0D02}, {0x040A0D02}, {0x040C0B02}, {0x040C0B02}, {0x040F0602},	/* 319 */
+  {0x040F0602}, {0x050E0A02}, {0x050F0001}, {0xFF000004}, {0x030B0C02},	/* 324 */
+  {0x030B0C02}, {0x03060F02}, {0x03060F02}, {0x040E0802}, {0x04080E02},	/* 329 */
+  {0x040F0502}, {0x040D0902}, {0x03050F02}, {0x03050F02}, {0x030E0702},	/* 334 */
+  {0x030E0702}, {0x03070E02}, {0x03070E02}, {0x030C0A02}, {0x030C0A02},	/* 339 */
+  {0xFF000004}, {0x030A0C02}, {0x030A0C02}, {0x030B0B02}, {0x030B0B02},	/* 344 */
+  {0x04090D02}, {0x040D0802}, {0x030F0402}, {0x030F0402}, {0x03040F02},	/* 349 */
+  {0x03040F02}, {0x030F0302}, {0x030F0302}, {0x03030F02}, {0x03030F02},	/* 354 */
+  {0x03080D02}, {0x03080D02}, {0xFF000004}, {0x03060E02}, {0x03060E02},	/* 359 */
+  {0x030F0202}, {0x030F0202}, {0x03020F02}, {0x03020F02}, {0x040E0602},	/* 364 */
+  {0x04000F01}, {0x030F0102}, {0x030F0102}, {0x03010F02}, {0x03010F02},	/* 369 */
+  {0x030C0902}, {0x030C0902}, {0x03090C02}, {0x03090C02}, {0xFF000003},	/* 374 */
+  {0x030E0502}, {0x030B0A02}, {0x030A0B02}, {0x03050E02}, {0x030D0702},	/* 379 */
+  {0x03070D02}, {0x030E0402}, {0x03040E02}, {0xFF000003}, {0x030C0802},	/* 384 */
+  {0x03080C02}, {0x030E0302}, {0x030D0602}, {0x03060D02}, {0x03030E02},	/* 389 */
+  {0x030B0902}, {0x03090B02}, {0xFF000004}, {0x030E0202}, {0x030E0202},	/* 394 */
+  {0x030A0A02}, {0x030A0A02}, {0x03020E02}, {0x03020E02}, {0x030E0102},	/* 399 */
+  {0x030E0102}, {0x03010E02}, {0x03010E02}, {0x040E0001}, {0x04000E01},	/* 404 */
+  {0x030D0502}, {0x030D0502}, {0x03050D02}, {0x03050D02}, {0xFF000003},	/* 409 */
+  {0x030C0702}, {0x03070C02}, {0x030D0402}, {0x030B0802}, {0x02040D02},	/* 414 */
+  {0x02040D02}, {0x03080B02}, {0x030A0902}, {0xFF000003}, {0x03090A02},	/* 419 */
+  {0x030C0602}, {0x03060C02}, {0x030D0302}, {0x02030D02}, {0x02030D02},	/* 424 */
+  {0x02020D02}, {0x02020D02}, {0xFF000003}, {0x030D0202}, {0x030D0001},	/* 429 */
+  {0x020D0102}, {0x020D0102}, {0x020B0702}, {0x020B0702}, {0x02070B02},	/* 434 */
+  {0x02070B02}, {0xFF000003}, {0x02010D02}, {0x02010D02}, {0x030C0502},	/* 439 */
+  {0x03000D01}, {0x02050C02}, {0x02050C02}, {0x020A0802}, {0x020A0802},	/* 444 */
+  {0xFF000002}, {0x02080A02}, {0x020C0402}, {0x02040C02}, {0x020B0602},	/* 449 */
+  {0xFF000003}, {0x02060B02}, {0x02060B02}, {0x03090902}, {0x030C0001},	/* 454 */
+  {0x020C0302}, {0x020C0302}, {0x02030C02}, {0x02030C02}, {0xFF000003},	/* 459 */
+  {0x020A0702}, {0x020A0702}, {0x02070A02}, {0x02070A02}, {0x02060A02},	/* 464 */
+  {0x02060A02}, {0x03000C01}, {0x030B0001}, {0xFF000002}, {0x01020C02},	/* 469 */
+  {0x01020C02}, {0x020C0202}, {0x020B0502}, {0xFF000002}, {0x02050B02},	/* 474 */
+  {0x020C0102}, {0x02090802}, {0x02080902}, {0xFF000002}, {0x02010C02},	/* 479 */
+  {0x020B0402}, {0x02040B02}, {0x020A0602}, {0xFF000002}, {0x020B0302},	/* 484 */
+  {0x02090702}, {0x01030B02}, {0x01030B02}, {0xFF000002}, {0x02070902},	/* 489 */
+  {0x02080802}, {0x020B0202}, {0x020A0502}, {0xFF000002}, {0x01020B02},	/* 494 */
+  {0x01020B02}, {0x02050A02}, {0x020B0102}, {0xFF000002}, {0x01010B02},	/* 499 */
+  {0x01010B02}, {0x02000B01}, {0x02090602}, {0xFF000002}, {0x02060902},	/* 504 */
+  {0x020A0402}, {0x02040A02}, {0x02080702}, {0xFF000002}, {0x02070802},	/* 509 */
+  {0x020A0302}, {0x01030A02}, {0x01030A02}, {0xFF000001}, {0x01090502},	/* 514 */
+  {0x01050902}, {0xFF000001}, {0x010A0202}, {0x01020A02}, {0xFF000001},	/* 519 */
+  {0x010A0102}, {0x01010A02}, {0xFF000002}, {0x020A0001}, {0x02000A01},	/* 524 */
+  {0x01080602}, {0x01080602}, {0xFF000001}, {0x01060802}, {0x01090402},	/* 529 */
+  {0xFF000001}, {0x01040902}, {0x01090302}, {0xFF000002}, {0x01030902},	/* 534 */
+  {0x01030902}, {0x02070702}, {0x02090001}, {0xFF000001}, {0x01080502},	/* 539 */
+  {0x01050802}, {0xFF000001}, {0x01090202}, {0x01070602}, {0xFF000001},	/* 544 */
+  {0x01060702}, {0x01020902}, {0xFF000001}, {0x01090102}, {0x01000901},	/* 549 */
+  {0xFF000001}, {0x01080402}, {0x01040802}, {0xFF000001}, {0x01070502},	/* 554 */
+  {0x01050702}, {0xFF000001}, {0x01080302}, {0x01030802}, {0xFF000001},	/* 559 */
+  {0x01060602}, {0x01070402}, {0xFF000001}, {0x01040702}, {0x01080001},	/* 564 */
+  {0xFF000001}, {0x01000801}, {0x01060502}, {0xFF000001}, {0x01050602},	/* 569 */
+  {0x01070302}, {0xFF000001}, {0x01030702}, {0x01060402}, {0xFF000001},	/* 574 */
+  {0x01070001}, {0x01000701}, {0xFF000001}, {0x01060001}, {0x01000601}, /* 579 */
+};
+
+/* max table bits  8 */
+
+/* TABLE 16  256 entries  maxbits 17  linbits  0 */
+static const HUFF_ELEMENT huff_table_16[] =
+{
+  {0xFF000008}, {0x00000101}, {0x0000010A}, {0x00000113}, {0x080F0F02},	/*  4 */
+  {0x00000118}, {0x0000011D}, {0x00000120}, {0x08020F02}, {0x00000131},	/*  9 */
+  {0x080F0102}, {0x08010F02}, {0x00000134}, {0x00000145}, {0x00000156},	/* 14 */
+  {0x00000167}, {0x00000178}, {0x00000189}, {0x0000019A}, {0x000001A3},	/* 19 */
+  {0x000001AC}, {0x000001B5}, {0x000001BE}, {0x000001C7}, {0x000001D0},	/* 24 */
+  {0x000001D9}, {0x000001DE}, {0x000001E3}, {0x000001E6}, {0x000001EB},	/* 29 */
+  {0x000001F0}, {0x08010502}, {0x000001F3}, {0x000001F6}, {0x000001F9},	/* 34 */
+  {0x000001FC}, {0x08040102}, {0x08010402}, {0x000001FF}, {0x08030202},	/* 39 */
+  {0x08020302}, {0x07030102}, {0x07030102}, {0x07010302}, {0x07010302},	/* 44 */
+  {0x08030001}, {0x08000301}, {0x07020202}, {0x07020202}, {0x06020102},	/* 49 */
+  {0x06020102}, {0x06020102}, {0x06020102}, {0x06010202}, {0x06010202},	/* 54 */
+  {0x06010202}, {0x06010202}, {0x06020001}, {0x06020001}, {0x06020001},	/* 59 */
+  {0x06020001}, {0x06000201}, {0x06000201}, {0x06000201}, {0x06000201},	/* 64 */
+  {0x04010102}, {0x04010102}, {0x04010102}, {0x04010102}, {0x04010102},	/* 69 */
+  {0x04010102}, {0x04010102}, {0x04010102}, {0x04010102}, {0x04010102},	/* 74 */
+  {0x04010102}, {0x04010102}, {0x04010102}, {0x04010102}, {0x04010102},	/* 79 */
+  {0x04010102}, {0x04010001}, {0x04010001}, {0x04010001}, {0x04010001},	/* 84 */
+  {0x04010001}, {0x04010001}, {0x04010001}, {0x04010001}, {0x04010001},	/* 89 */
+  {0x04010001}, {0x04010001}, {0x04010001}, {0x04010001}, {0x04010001},	/* 94 */
+  {0x04010001}, {0x04010001}, {0x03000101}, {0x03000101}, {0x03000101},	/* 99 */
+  {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101},	/* 104 */
+  {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101},	/* 109 */
+  {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101},	/* 114 */
+  {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101},	/* 119 */
+  {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101},	/* 124 */
+  {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x01000000},	/* 129 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 134 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 139 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 144 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 149 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 154 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 159 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 164 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 169 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 174 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 179 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 184 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 189 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 194 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 199 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 204 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 209 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 214 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 219 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 224 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 229 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 234 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 239 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 244 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 249 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 254 */
+  {0x01000000}, {0x01000000}, {0xFF000003}, {0x030F0E02}, {0x030E0F02},	/* 259 */
+  {0x030F0D02}, {0x030D0F02}, {0x030F0C02}, {0x030C0F02}, {0x030F0B02},	/* 264 */
+  {0x030B0F02}, {0xFF000003}, {0x020F0A02}, {0x020F0A02}, {0x030A0F02},	/* 269 */
+  {0x030F0902}, {0x03090F02}, {0x03080F02}, {0x020F0802}, {0x020F0802},	/* 274 */
+  {0xFF000002}, {0x020F0702}, {0x02070F02}, {0x020F0602}, {0x02060F02},	/* 279 */
+  {0xFF000002}, {0x020F0502}, {0x02050F02}, {0x010F0402}, {0x010F0402},	/* 284 */
+  {0xFF000001}, {0x01040F02}, {0x01030F02}, {0xFF000004}, {0x01000F01},	/* 289 */
+  {0x01000F01}, {0x01000F01}, {0x01000F01}, {0x01000F01}, {0x01000F01},	/* 294 */
+  {0x01000F01}, {0x01000F01}, {0x020F0302}, {0x020F0302}, {0x020F0302},	/* 299 */
+  {0x020F0302}, {0x000000E2}, {0x000000F3}, {0x000000FC}, {0x00000105},	/* 304 */
+  {0xFF000001}, {0x010F0202}, {0x010F0001}, {0xFF000004}, {0x000000FA},	/* 309 */
+  {0x000000FF}, {0x00000104}, {0x00000109}, {0x0000010C}, {0x00000111},	/* 314 */
+  {0x00000116}, {0x00000119}, {0x0000011E}, {0x00000123}, {0x00000128},	/* 319 */
+  {0x04030E02}, {0x0000012D}, {0x00000130}, {0x00000133}, {0x00000136},	/* 324 */
+  {0xFF000004}, {0x00000128}, {0x0000012B}, {0x0000012E}, {0x040D0001},	/* 329 */
+  {0x00000131}, {0x00000134}, {0x00000137}, {0x040C0302}, {0x0000013A},	/* 334 */
+  {0x040C0102}, {0x04000C01}, {0x0000013D}, {0x03020E02}, {0x03020E02},	/* 339 */
+  {0x040E0202}, {0x040E0102}, {0xFF000004}, {0x04030D02}, {0x040D0202},	/* 344 */
+  {0x04020D02}, {0x04010D02}, {0x040B0302}, {0x0000012F}, {0x030D0102},	/* 349 */
+  {0x030D0102}, {0x04040C02}, {0x040B0602}, {0x04030C02}, {0x04070A02},	/* 354 */
+  {0x030C0202}, {0x030C0202}, {0x04020C02}, {0x04050B02}, {0xFF000004},	/* 359 */
+  {0x04010C02}, {0x040C0001}, {0x040B0402}, {0x04040B02}, {0x040A0602},	/* 364 */
+  {0x04060A02}, {0x03030B02}, {0x03030B02}, {0x040A0502}, {0x04050A02},	/* 369 */
+  {0x030B0202}, {0x030B0202}, {0x03020B02}, {0x03020B02}, {0x030B0102},	/* 374 */
+  {0x030B0102}, {0xFF000004}, {0x03010B02}, {0x03010B02}, {0x040B0001},	/* 379 */
+  {0x04000B01}, {0x04090602}, {0x04060902}, {0x040A0402}, {0x04040A02},	/* 384 */
+  {0x04080702}, {0x04070802}, {0x03030A02}, {0x03030A02}, {0x040A0302},	/* 389 */
+  {0x04090502}, {0x030A0202}, {0x030A0202}, {0xFF000004}, {0x04050902},	/* 394 */
+  {0x04080602}, {0x03010A02}, {0x03010A02}, {0x04060802}, {0x04070702},	/* 399 */
+  {0x03040902}, {0x03040902}, {0x04090402}, {0x04070502}, {0x03070602},	/* 404 */
+  {0x03070602}, {0x02020A02}, {0x02020A02}, {0x02020A02}, {0x02020A02},	/* 409 */
+  {0xFF000003}, {0x020A0102}, {0x020A0102}, {0x030A0001}, {0x03000A01},	/* 414 */
+  {0x03090302}, {0x03030902}, {0x03080502}, {0x03050802}, {0xFF000003},	/* 419 */
+  {0x02090202}, {0x02090202}, {0x02020902}, {0x02020902}, {0x03060702},	/* 424 */
+  {0x03090001}, {0x02090102}, {0x02090102}, {0xFF000003}, {0x02010902},	/* 429 */
+  {0x02010902}, {0x03000901}, {0x03080402}, {0x03040802}, {0x03050702},	/* 434 */
+  {0x03080302}, {0x03030802}, {0xFF000003}, {0x03060602}, {0x03080202},	/* 439 */
+  {0x02020802}, {0x02020802}, {0x03070402}, {0x03040702}, {0x02080102},	/* 444 */
+  {0x02080102}, {0xFF000003}, {0x02010802}, {0x02010802}, {0x02000801},	/* 449 */
+  {0x02000801}, {0x03080001}, {0x03060502}, {0x02070302}, {0x02070302},	/* 454 */
+  {0xFF000003}, {0x02030702}, {0x02030702}, {0x03050602}, {0x03060402},	/* 459 */
+  {0x02070202}, {0x02070202}, {0x02020702}, {0x02020702}, {0xFF000003},	/* 464 */
+  {0x03040602}, {0x03050502}, {0x02070001}, {0x02070001}, {0x01070102},	/* 469 */
+  {0x01070102}, {0x01070102}, {0x01070102}, {0xFF000002}, {0x01010702},	/* 474 */
+  {0x01010702}, {0x02000701}, {0x02060302}, {0xFF000002}, {0x02030602},	/* 479 */
+  {0x02050402}, {0x02040502}, {0x02060202}, {0xFF000001}, {0x01020602},	/* 484 */
+  {0x01060102}, {0xFF000002}, {0x01010602}, {0x01010602}, {0x02060001},	/* 489 */
+  {0x02000601}, {0xFF000002}, {0x01030502}, {0x01030502}, {0x02050302},	/* 494 */
+  {0x02040402}, {0xFF000001}, {0x01050202}, {0x01020502}, {0xFF000001},	/* 499 */
+  {0x01050102}, {0x01050001}, {0xFF000001}, {0x01040302}, {0x01030402},	/* 504 */
+  {0xFF000001}, {0x01000501}, {0x01040202}, {0xFF000001}, {0x01020402},	/* 509 */
+  {0x01030302}, {0xFF000001}, {0x01040001}, {0x01000401}, {0xFF000004},	/* 514 */
+  {0x040E0C02}, {0x00000086}, {0x030E0D02}, {0x030E0D02}, {0x03090E02},	/* 519 */
+  {0x03090E02}, {0x040A0E02}, {0x04090D02}, {0x020E0E02}, {0x020E0E02},	/* 524 */
+  {0x020E0E02}, {0x020E0E02}, {0x030D0E02}, {0x030D0E02}, {0x030B0E02},	/* 529 */
+  {0x030B0E02}, {0xFF000003}, {0x020E0B02}, {0x020E0B02}, {0x020D0C02},	/* 534 */
+  {0x020D0C02}, {0x030C0D02}, {0x030B0D02}, {0x020E0A02}, {0x020E0A02},	/* 539 */
+  {0xFF000003}, {0x020C0C02}, {0x020C0C02}, {0x030D0A02}, {0x030A0D02},	/* 544 */
+  {0x030E0702}, {0x030C0A02}, {0x020A0C02}, {0x020A0C02}, {0xFF000003},	/* 549 */
+  {0x03090C02}, {0x030D0702}, {0x020E0502}, {0x020E0502}, {0x010D0B02},	/* 554 */
+  {0x010D0B02}, {0x010D0B02}, {0x010D0B02}, {0xFF000002}, {0x010E0902},	/* 559 */
+  {0x010E0902}, {0x020C0B02}, {0x020B0C02}, {0xFF000002}, {0x020E0802},	/* 564 */
+  {0x02080E02}, {0x020D0902}, {0x02070E02}, {0xFF000002}, {0x020B0B02},	/* 569 */
+  {0x020D0802}, {0x02080D02}, {0x020E0602}, {0xFF000001}, {0x01060E02},	/* 574 */
+  {0x010C0902}, {0xFF000002}, {0x020B0A02}, {0x020A0B02}, {0x02050E02},	/* 579 */
+  {0x02070D02}, {0xFF000002}, {0x010E0402}, {0x010E0402}, {0x02040E02},	/* 584 */
+  {0x020C0802}, {0xFF000001}, {0x01080C02}, {0x010E0302}, {0xFF000002},	/* 589 */
+  {0x010D0602}, {0x010D0602}, {0x02060D02}, {0x020B0902}, {0xFF000002},	/* 594 */
+  {0x02090B02}, {0x020A0A02}, {0x01010E02}, {0x01010E02}, {0xFF000002},	/* 599 */
+  {0x01040D02}, {0x01040D02}, {0x02080B02}, {0x02090A02}, {0xFF000002},	/* 604 */
+  {0x010B0702}, {0x010B0702}, {0x02070B02}, {0x02000D01}, {0xFF000001},	/* 609 */
+  {0x010E0001}, {0x01000E01}, {0xFF000001}, {0x010D0502}, {0x01050D02},	/* 614 */
+  {0xFF000001}, {0x010C0702}, {0x01070C02}, {0xFF000001}, {0x010D0402},	/* 619 */
+  {0x010B0802}, {0xFF000001}, {0x010A0902}, {0x010C0602}, {0xFF000001},	/* 624 */
+  {0x01060C02}, {0x010D0302}, {0xFF000001}, {0x010C0502}, {0x01050C02},	/* 629 */
+  {0xFF000001}, {0x010A0802}, {0x01080A02}, {0xFF000001}, {0x01090902},	/* 634 */
+  {0x010C0402}, {0xFF000001}, {0x01060B02}, {0x010A0702}, {0xFF000001},	/* 639 */
+  {0x010B0502}, {0x01090802}, {0xFF000001}, {0x01080902}, {0x01090702},	/* 644 */
+  {0xFF000001}, {0x01070902}, {0x01080802}, {0xFF000001}, {0x010C0E02},	/* 649 */
+  {0x010D0D02},
+};
+
+/* max table bits  8 */
+/* NO XING TABLE 17 */
+/* NO XING TABLE 18 */
+/* NO XING TABLE 19 */
+/* NO XING TABLE 20 */
+/* NO XING TABLE 21 */
+/* NO XING TABLE 22 */
+/* NO XING TABLE 23 */
+
+/* TABLE 24  256 entries  maxbits 12  linbits  0 */
+static const HUFF_ELEMENT huff_table_24[] =
+{
+  {0xFF000009}, {0x080F0E02}, {0x080F0E02}, {0x080E0F02}, {0x080E0F02},	/*  4 */
+  {0x080F0D02}, {0x080F0D02}, {0x080D0F02}, {0x080D0F02}, {0x080F0C02},	/*  9 */
+  {0x080F0C02}, {0x080C0F02}, {0x080C0F02}, {0x080F0B02}, {0x080F0B02},	/* 14 */
+  {0x080B0F02}, {0x080B0F02}, {0x070A0F02}, {0x070A0F02}, {0x070A0F02},	/* 19 */
+  {0x070A0F02}, {0x080F0A02}, {0x080F0A02}, {0x080F0902}, {0x080F0902},	/* 24 */
+  {0x07090F02}, {0x07090F02}, {0x07090F02}, {0x07090F02}, {0x07080F02},	/* 29 */
+  {0x07080F02}, {0x07080F02}, {0x07080F02}, {0x080F0802}, {0x080F0802},	/* 34 */
+  {0x080F0702}, {0x080F0702}, {0x07070F02}, {0x07070F02}, {0x07070F02},	/* 39 */
+  {0x07070F02}, {0x070F0602}, {0x070F0602}, {0x070F0602}, {0x070F0602},	/* 44 */
+  {0x07060F02}, {0x07060F02}, {0x07060F02}, {0x07060F02}, {0x070F0502},	/* 49 */
+  {0x070F0502}, {0x070F0502}, {0x070F0502}, {0x07050F02}, {0x07050F02},	/* 54 */
+  {0x07050F02}, {0x07050F02}, {0x070F0402}, {0x070F0402}, {0x070F0402},	/* 59 */
+  {0x070F0402}, {0x07040F02}, {0x07040F02}, {0x07040F02}, {0x07040F02},	/* 64 */
+  {0x070F0302}, {0x070F0302}, {0x070F0302}, {0x070F0302}, {0x07030F02},	/* 69 */
+  {0x07030F02}, {0x07030F02}, {0x07030F02}, {0x070F0202}, {0x070F0202},	/* 74 */
+  {0x070F0202}, {0x070F0202}, {0x07020F02}, {0x07020F02}, {0x07020F02},	/* 79 */
+  {0x07020F02}, {0x07010F02}, {0x07010F02}, {0x07010F02}, {0x07010F02},	/* 84 */
+  {0x080F0102}, {0x080F0102}, {0x08000F01}, {0x08000F01}, {0x090F0001},	/* 89 */
+  {0x00000201}, {0x00000206}, {0x0000020B}, {0x00000210}, {0x00000215},	/* 94 */
+  {0x0000021A}, {0x0000021F}, {0x040F0F02}, {0x040F0F02}, {0x040F0F02},	/* 99 */
+  {0x040F0F02}, {0x040F0F02}, {0x040F0F02}, {0x040F0F02}, {0x040F0F02},	/* 104 */
+  {0x040F0F02}, {0x040F0F02}, {0x040F0F02}, {0x040F0F02}, {0x040F0F02},	/* 109 */
+  {0x040F0F02}, {0x040F0F02}, {0x040F0F02}, {0x040F0F02}, {0x040F0F02},	/* 114 */
+  {0x040F0F02}, {0x040F0F02}, {0x040F0F02}, {0x040F0F02}, {0x040F0F02},	/* 119 */
+  {0x040F0F02}, {0x040F0F02}, {0x040F0F02}, {0x040F0F02}, {0x040F0F02},	/* 124 */
+  {0x040F0F02}, {0x040F0F02}, {0x040F0F02}, {0x040F0F02}, {0x00000224},	/* 129 */
+  {0x00000229}, {0x00000232}, {0x00000237}, {0x0000023A}, {0x0000023F},	/* 134 */
+  {0x00000242}, {0x00000245}, {0x0000024A}, {0x0000024D}, {0x00000250},	/* 139 */
+  {0x00000253}, {0x00000256}, {0x00000259}, {0x0000025C}, {0x0000025F},	/* 144 */
+  {0x00000262}, {0x00000265}, {0x00000268}, {0x0000026B}, {0x0000026E},	/* 149 */
+  {0x00000271}, {0x00000274}, {0x00000277}, {0x0000027A}, {0x0000027D},	/* 154 */
+  {0x00000280}, {0x00000283}, {0x00000288}, {0x0000028B}, {0x0000028E},	/* 159 */
+  {0x00000291}, {0x00000294}, {0x00000297}, {0x0000029A}, {0x0000029F},	/* 164 */
+  {0x09040B02}, {0x000002A4}, {0x000002A7}, {0x000002AA}, {0x09030B02},	/* 169 */
+  {0x09080802}, {0x000002AF}, {0x09020B02}, {0x000002B2}, {0x000002B5},	/* 174 */
+  {0x09060902}, {0x09040A02}, {0x000002B8}, {0x09070802}, {0x090A0302},	/* 179 */
+  {0x09030A02}, {0x09090502}, {0x09050902}, {0x090A0202}, {0x09020A02},	/* 184 */
+  {0x09010A02}, {0x09080602}, {0x09060802}, {0x09070702}, {0x09090402},	/* 189 */
+  {0x09040902}, {0x09090302}, {0x09030902}, {0x09080502}, {0x09050802},	/* 194 */
+  {0x09090202}, {0x09070602}, {0x09060702}, {0x09020902}, {0x09090102},	/* 199 */
+  {0x09010902}, {0x09080402}, {0x09040802}, {0x09070502}, {0x09050702},	/* 204 */
+  {0x09080302}, {0x09030802}, {0x09060602}, {0x09080202}, {0x09020802},	/* 209 */
+  {0x09080102}, {0x09070402}, {0x09040702}, {0x09010802}, {0x000002BB},	/* 214 */
+  {0x09060502}, {0x09050602}, {0x09070102}, {0x000002BE}, {0x08030702},	/* 219 */
+  {0x08030702}, {0x09070302}, {0x09070202}, {0x08020702}, {0x08020702},	/* 224 */
+  {0x08060402}, {0x08060402}, {0x08040602}, {0x08040602}, {0x08050502},	/* 229 */
+  {0x08050502}, {0x08010702}, {0x08010702}, {0x08060302}, {0x08060302},	/* 234 */
+  {0x08030602}, {0x08030602}, {0x08050402}, {0x08050402}, {0x08040502},	/* 239 */
+  {0x08040502}, {0x08060202}, {0x08060202}, {0x08020602}, {0x08020602},	/* 244 */
+  {0x08060102}, {0x08060102}, {0x08010602}, {0x08010602}, {0x09060001},	/* 249 */
+  {0x09000601}, {0x08050302}, {0x08050302}, {0x08030502}, {0x08030502},	/* 254 */
+  {0x08040402}, {0x08040402}, {0x08050202}, {0x08050202}, {0x08020502},	/* 259 */
+  {0x08020502}, {0x08050102}, {0x08050102}, {0x09050001}, {0x09000501},	/* 264 */
+  {0x07010502}, {0x07010502}, {0x07010502}, {0x07010502}, {0x08040302},	/* 269 */
+  {0x08040302}, {0x08030402}, {0x08030402}, {0x07040202}, {0x07040202},	/* 274 */
+  {0x07040202}, {0x07040202}, {0x07020402}, {0x07020402}, {0x07020402},	/* 279 */
+  {0x07020402}, {0x07030302}, {0x07030302}, {0x07030302}, {0x07030302},	/* 284 */
+  {0x07040102}, {0x07040102}, {0x07040102}, {0x07040102}, {0x07010402},	/* 289 */
+  {0x07010402}, {0x07010402}, {0x07010402}, {0x08040001}, {0x08040001},	/* 294 */
+  {0x08000401}, {0x08000401}, {0x07030202}, {0x07030202}, {0x07030202},	/* 299 */
+  {0x07030202}, {0x07020302}, {0x07020302}, {0x07020302}, {0x07020302},	/* 304 */
+  {0x06030102}, {0x06030102}, {0x06030102}, {0x06030102}, {0x06030102},	/* 309 */
+  {0x06030102}, {0x06030102}, {0x06030102}, {0x06010302}, {0x06010302},	/* 314 */
+  {0x06010302}, {0x06010302}, {0x06010302}, {0x06010302}, {0x06010302},	/* 319 */
+  {0x06010302}, {0x07030001}, {0x07030001}, {0x07030001}, {0x07030001},	/* 324 */
+  {0x07000301}, {0x07000301}, {0x07000301}, {0x07000301}, {0x06020202},	/* 329 */
+  {0x06020202}, {0x06020202}, {0x06020202}, {0x06020202}, {0x06020202},	/* 334 */
+  {0x06020202}, {0x06020202}, {0x05020102}, {0x05020102}, {0x05020102},	/* 339 */
+  {0x05020102}, {0x05020102}, {0x05020102}, {0x05020102}, {0x05020102},	/* 344 */
+  {0x05020102}, {0x05020102}, {0x05020102}, {0x05020102}, {0x05020102},	/* 349 */
+  {0x05020102}, {0x05020102}, {0x05020102}, {0x05010202}, {0x05010202},	/* 354 */
+  {0x05010202}, {0x05010202}, {0x05010202}, {0x05010202}, {0x05010202},	/* 359 */
+  {0x05010202}, {0x05010202}, {0x05010202}, {0x05010202}, {0x05010202},	/* 364 */
+  {0x05010202}, {0x05010202}, {0x05010202}, {0x05010202}, {0x06020001},	/* 369 */
+  {0x06020001}, {0x06020001}, {0x06020001}, {0x06020001}, {0x06020001},	/* 374 */
+  {0x06020001}, {0x06020001}, {0x06000201}, {0x06000201}, {0x06000201},	/* 379 */
+  {0x06000201}, {0x06000201}, {0x06000201}, {0x06000201}, {0x06000201},	/* 384 */
+  {0x04010102}, {0x04010102}, {0x04010102}, {0x04010102}, {0x04010102},	/* 389 */
+  {0x04010102}, {0x04010102}, {0x04010102}, {0x04010102}, {0x04010102},	/* 394 */
+  {0x04010102}, {0x04010102}, {0x04010102}, {0x04010102}, {0x04010102},	/* 399 */
+  {0x04010102}, {0x04010102}, {0x04010102}, {0x04010102}, {0x04010102},	/* 404 */
+  {0x04010102}, {0x04010102}, {0x04010102}, {0x04010102}, {0x04010102},	/* 409 */
+  {0x04010102}, {0x04010102}, {0x04010102}, {0x04010102}, {0x04010102},	/* 414 */
+  {0x04010102}, {0x04010102}, {0x04010001}, {0x04010001}, {0x04010001},	/* 419 */
+  {0x04010001}, {0x04010001}, {0x04010001}, {0x04010001}, {0x04010001},	/* 424 */
+  {0x04010001}, {0x04010001}, {0x04010001}, {0x04010001}, {0x04010001},	/* 429 */
+  {0x04010001}, {0x04010001}, {0x04010001}, {0x04010001}, {0x04010001},	/* 434 */
+  {0x04010001}, {0x04010001}, {0x04010001}, {0x04010001}, {0x04010001},	/* 439 */
+  {0x04010001}, {0x04010001}, {0x04010001}, {0x04010001}, {0x04010001},	/* 444 */
+  {0x04010001}, {0x04010001}, {0x04010001}, {0x04010001}, {0x04000101},	/* 449 */
+  {0x04000101}, {0x04000101}, {0x04000101}, {0x04000101}, {0x04000101},	/* 454 */
+  {0x04000101}, {0x04000101}, {0x04000101}, {0x04000101}, {0x04000101},	/* 459 */
+  {0x04000101}, {0x04000101}, {0x04000101}, {0x04000101}, {0x04000101},	/* 464 */
+  {0x04000101}, {0x04000101}, {0x04000101}, {0x04000101}, {0x04000101},	/* 469 */
+  {0x04000101}, {0x04000101}, {0x04000101}, {0x04000101}, {0x04000101},	/* 474 */
+  {0x04000101}, {0x04000101}, {0x04000101}, {0x04000101}, {0x04000101},	/* 479 */
+  {0x04000101}, {0x04000000}, {0x04000000}, {0x04000000}, {0x04000000},	/* 484 */
+  {0x04000000}, {0x04000000}, {0x04000000}, {0x04000000}, {0x04000000},	/* 489 */
+  {0x04000000}, {0x04000000}, {0x04000000}, {0x04000000}, {0x04000000},	/* 494 */
+  {0x04000000}, {0x04000000}, {0x04000000}, {0x04000000}, {0x04000000},	/* 499 */
+  {0x04000000}, {0x04000000}, {0x04000000}, {0x04000000}, {0x04000000},	/* 504 */
+  {0x04000000}, {0x04000000}, {0x04000000}, {0x04000000}, {0x04000000},	/* 509 */
+  {0x04000000}, {0x04000000}, {0x04000000}, {0xFF000002}, {0x020E0E02},	/* 514 */
+  {0x020E0D02}, {0x020D0E02}, {0x020E0C02}, {0xFF000002}, {0x020C0E02},	/* 519 */
+  {0x020D0D02}, {0x020E0B02}, {0x020B0E02}, {0xFF000002}, {0x020D0C02},	/* 524 */
+  {0x020C0D02}, {0x020E0A02}, {0x020A0E02}, {0xFF000002}, {0x020D0B02},	/* 529 */
+  {0x020B0D02}, {0x020C0C02}, {0x020E0902}, {0xFF000002}, {0x02090E02},	/* 534 */
+  {0x020D0A02}, {0x020A0D02}, {0x020C0B02}, {0xFF000002}, {0x020B0C02},	/* 539 */
+  {0x020E0802}, {0x02080E02}, {0x020D0902}, {0xFF000002}, {0x02090D02},	/* 544 */
+  {0x020E0702}, {0x02070E02}, {0x020C0A02}, {0xFF000002}, {0x020A0C02},	/* 549 */
+  {0x020B0B02}, {0x020D0802}, {0x02080D02}, {0xFF000003}, {0x030E0001},	/* 554 */
+  {0x03000E01}, {0x020D0001}, {0x020D0001}, {0x01060E02}, {0x01060E02},	/* 559 */
+  {0x01060E02}, {0x01060E02}, {0xFF000002}, {0x020E0602}, {0x020C0902},	/* 564 */
+  {0x01090C02}, {0x01090C02}, {0xFF000001}, {0x010E0502}, {0x010A0B02},	/* 569 */
+  {0xFF000002}, {0x01050E02}, {0x01050E02}, {0x020B0A02}, {0x020D0702},	/* 574 */
+  {0xFF000001}, {0x01070D02}, {0x01040E02}, {0xFF000001}, {0x010C0802},	/* 579 */
+  {0x01080C02}, {0xFF000002}, {0x020E0402}, {0x020E0202}, {0x010E0302},	/* 584 */
+  {0x010E0302}, {0xFF000001}, {0x010D0602}, {0x01060D02}, {0xFF000001},	/* 589 */
+  {0x01030E02}, {0x010B0902}, {0xFF000001}, {0x01090B02}, {0x010A0A02},	/* 594 */
+  {0xFF000001}, {0x01020E02}, {0x010E0102}, {0xFF000001}, {0x01010E02},	/* 599 */
+  {0x010D0502}, {0xFF000001}, {0x01050D02}, {0x010C0702}, {0xFF000001},	/* 604 */
+  {0x01070C02}, {0x010D0402}, {0xFF000001}, {0x010B0802}, {0x01080B02},	/* 609 */
+  {0xFF000001}, {0x01040D02}, {0x010A0902}, {0xFF000001}, {0x01090A02},	/* 614 */
+  {0x010C0602}, {0xFF000001}, {0x01060C02}, {0x010D0302}, {0xFF000001},	/* 619 */
+  {0x01030D02}, {0x010D0202}, {0xFF000001}, {0x01020D02}, {0x010D0102},	/* 624 */
+  {0xFF000001}, {0x010B0702}, {0x01070B02}, {0xFF000001}, {0x01010D02},	/* 629 */
+  {0x010C0502}, {0xFF000001}, {0x01050C02}, {0x010A0802}, {0xFF000001},	/* 634 */
+  {0x01080A02}, {0x01090902}, {0xFF000001}, {0x010C0402}, {0x01040C02},	/* 639 */
+  {0xFF000001}, {0x010B0602}, {0x01060B02}, {0xFF000002}, {0x02000D01},	/* 644 */
+  {0x020C0001}, {0x010C0302}, {0x010C0302}, {0xFF000001}, {0x01030C02},	/* 649 */
+  {0x010A0702}, {0xFF000001}, {0x01070A02}, {0x010C0202}, {0xFF000001},	/* 654 */
+  {0x01020C02}, {0x010B0502}, {0xFF000001}, {0x01050B02}, {0x010C0102},	/* 659 */
+  {0xFF000001}, {0x01090802}, {0x01080902}, {0xFF000001}, {0x01010C02},	/* 664 */
+  {0x010B0402}, {0xFF000002}, {0x02000C01}, {0x020B0001}, {0x010B0302},	/* 669 */
+  {0x010B0302}, {0xFF000002}, {0x02000B01}, {0x020A0001}, {0x010A0102},	/* 674 */
+  {0x010A0102}, {0xFF000001}, {0x010A0602}, {0x01060A02}, {0xFF000001},	/* 679 */
+  {0x01090702}, {0x01070902}, {0xFF000002}, {0x02000A01}, {0x02090001},	/* 684 */
+  {0x01000901}, {0x01000901}, {0xFF000001}, {0x010B0202}, {0x010A0502},	/* 689 */
+  {0xFF000001}, {0x01050A02}, {0x010B0102}, {0xFF000001}, {0x01010B02},	/* 694 */
+  {0x01090602}, {0xFF000001}, {0x010A0402}, {0x01080702}, {0xFF000001},	/* 699 */
+  {0x01080001}, {0x01000801}, {0xFF000001}, {0x01070001}, {0x01000701}, /* 704 */
+};
+
+/* max table bits  9 */
+/* NO XING TABLE 25 */
+/* NO XING TABLE 26 */
+/* NO XING TABLE 27 */
+/* NO XING TABLE 28 */
+/* NO XING TABLE 29 */
+/* NO XING TABLE 30 */
+/* NO XING TABLE 31 */
+/* done */
diff --git a/code/mp3code/hwin.c b/code/mp3code/hwin.c
new file mode 100644
index 0000000..26d7dd8
--- /dev/null
+++ b/code/mp3code/hwin.c
@@ -0,0 +1,264 @@
+/*____________________________________________________________________________
+	
+	FreeAmp - The Free MP3 Player
+
+        MP3 Decoder originally Copyright (C) 1995-1997 Xing Technology
+        Corp.  http://www.xingtech.com
+
+	Portions Copyright (C) 1998-1999 EMusic.com
+
+	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., 675 Mass Ave, Cambridge, MA 02139, USA.
+	
+	$Id: hwin.c,v 1.5 1999/10/19 07:13:08 elrod Exp $
+____________________________________________________________________________*/
+
+/****  hwin.c  ***************************************************
+
+Layer III 
+
+hybrid window/filter 
+
+******************************************************************/
+#include <stdlib.h>
+#include <stdio.h>
+#include <float.h>
+#include <math.h>
+
+#include "mp3struct.h"
+////@@@@extern int band_limit_nsb;
+
+typedef float ARRAY36[36];
+
+/*-- windows by block type --*/
+static float win[4][36];	// effectively a constant
+
+
+/*====================================================================*/
+void imdct18(float f[]);	/* 18 point */
+void imdct6_3(float f[]);	/* 6 point */
+
+/*====================================================================*/
+ARRAY36 *hwin_init_addr()
+{
+   return win;
+}
+
+
+/*====================================================================*/
+int hybrid(float xin[], float xprev[], float y[18][32],
+	   int btype, int nlong, int ntot, int nprev)
+{
+   int i, j;
+   float *x, *x0;
+   float xa, xb;
+   int n;
+   int nout;
+
+
+
+   if (btype == 2)
+      btype = 0;
+   x = xin;
+   x0 = xprev;
+
+/*-- do long blocks (if any) --*/
+   n = (nlong + 17) / 18;	/* number of dct's to do */
+   for (i = 0; i < n; i++)
+   {
+      imdct18(x);
+      for (j = 0; j < 9; j++)
+      {
+	 y[j][i] = x0[j] + win[btype][j] * x[9 + j];
+	 y[9 + j][i] = x0[9 + j] + win[btype][9 + j] * x[17 - j];
+      }
+    /* window x for next time x0 */
+      for (j = 0; j < 4; j++)
+      {
+	 xa = x[j];
+	 xb = x[8 - j];
+	 x[j] = win[btype][18 + j] * xb;
+	 x[8 - j] = win[btype][(18 + 8) - j] * xa;
+	 x[9 + j] = win[btype][(18 + 9) + j] * xa;
+	 x[17 - j] = win[btype][(18 + 17) - j] * xb;
+      }
+      xa = x[j];
+      x[j] = win[btype][18 + j] * xa;
+      x[9 + j] = win[btype][(18 + 9) + j] * xa;
+
+      x += 18;
+      x0 += 18;
+   }
+
+/*-- do short blocks (if any) --*/
+   n = (ntot + 17) / 18;	/* number of 6 pt dct's triples to do */
+   for (; i < n; i++)
+   {
+      imdct6_3(x);
+      for (j = 0; j < 3; j++)
+      {
+	 y[j][i] = x0[j];
+	 y[3 + j][i] = x0[3 + j];
+
+	 y[6 + j][i] = x0[6 + j] + win[2][j] * x[3 + j];
+	 y[9 + j][i] = x0[9 + j] + win[2][3 + j] * x[5 - j];
+
+	 y[12 + j][i] = x0[12 + j] + win[2][6 + j] * x[2 - j] + win[2][j] * x[(6 + 3) + j];
+	 y[15 + j][i] = x0[15 + j] + win[2][9 + j] * x[j] + win[2][3 + j] * x[(6 + 5) - j];
+      }
+    /* window x for next time x0 */
+      for (j = 0; j < 3; j++)
+      {
+	 x[j] = win[2][6 + j] * x[(6 + 2) - j] + win[2][j] * x[(12 + 3) + j];
+	 x[3 + j] = win[2][9 + j] * x[6 + j] + win[2][3 + j] * x[(12 + 5) - j];
+      }
+      for (j = 0; j < 3; j++)
+      {
+	 x[6 + j] = win[2][6 + j] * x[(12 + 2) - j];
+	 x[9 + j] = win[2][9 + j] * x[12 + j];
+      }
+      for (j = 0; j < 3; j++)
+      {
+	 x[12 + j] = 0.0f;
+	 x[15 + j] = 0.0f;
+      }
+      x += 18;
+      x0 += 18;
+   }
+
+/*--- overlap prev if prev longer that current --*/
+   n = (nprev + 17) / 18;
+   for (; i < n; i++)
+   {
+      for (j = 0; j < 18; j++)
+	 y[j][i] = x0[j];
+      x0 += 18;
+   }
+   nout = 18 * i;
+
+/*--- clear remaining only to band limit --*/
+   for (; i < pMP3Stream->band_limit_nsb; i++)
+   {
+      for (j = 0; j < 18; j++)
+	 y[j][i] = 0.0f;
+   }
+
+   return nout;
+}
+
+
+/*--------------------------------------------------------------------*/
+/*--------------------------------------------------------------------*/
+/*-- convert to mono, add curr result to y,
+    window and add next time to current left */
+int hybrid_sum(float xin[], float xin_left[], float y[18][32],
+	       int btype, int nlong, int ntot)
+{
+   int i, j;
+   float *x, *x0;
+   float xa, xb;
+   int n;
+   int nout;
+
+
+
+   if (btype == 2)
+      btype = 0;
+   x = xin;
+   x0 = xin_left;
+
+/*-- do long blocks (if any) --*/
+   n = (nlong + 17) / 18;	/* number of dct's to do */
+   for (i = 0; i < n; i++)
+   {
+      imdct18(x);
+      for (j = 0; j < 9; j++)
+      {
+	 y[j][i] += win[btype][j] * x[9 + j];
+	 y[9 + j][i] += win[btype][9 + j] * x[17 - j];
+      }
+    /* window x for next time x0 */
+      for (j = 0; j < 4; j++)
+      {
+	 xa = x[j];
+	 xb = x[8 - j];
+	 x0[j] += win[btype][18 + j] * xb;
+	 x0[8 - j] += win[btype][(18 + 8) - j] * xa;
+	 x0[9 + j] += win[btype][(18 + 9) + j] * xa;
+	 x0[17 - j] += win[btype][(18 + 17) - j] * xb;
+      }
+      xa = x[j];
+      x0[j] += win[btype][18 + j] * xa;
+      x0[9 + j] += win[btype][(18 + 9) + j] * xa;
+
+      x += 18;
+      x0 += 18;
+   }
+
+/*-- do short blocks (if any) --*/
+   n = (ntot + 17) / 18;	/* number of 6 pt dct's triples to do */
+   for (; i < n; i++)
+   {
+      imdct6_3(x);
+      for (j = 0; j < 3; j++)
+      {
+	 y[6 + j][i] += win[2][j] * x[3 + j];
+	 y[9 + j][i] += win[2][3 + j] * x[5 - j];
+
+	 y[12 + j][i] += win[2][6 + j] * x[2 - j] + win[2][j] * x[(6 + 3) + j];
+	 y[15 + j][i] += win[2][9 + j] * x[j] + win[2][3 + j] * x[(6 + 5) - j];
+      }
+    /* window x for next time */
+      for (j = 0; j < 3; j++)
+      {
+	 x0[j] += win[2][6 + j] * x[(6 + 2) - j] + win[2][j] * x[(12 + 3) + j];
+	 x0[3 + j] += win[2][9 + j] * x[6 + j] + win[2][3 + j] * x[(12 + 5) - j];
+      }
+      for (j = 0; j < 3; j++)
+      {
+	 x0[6 + j] += win[2][6 + j] * x[(12 + 2) - j];
+	 x0[9 + j] += win[2][9 + j] * x[12 + j];
+      }
+      x += 18;
+      x0 += 18;
+   }
+
+   nout = 18 * i;
+
+   return nout;
+}
+/*--------------------------------------------------------------------*/
+void sum_f_bands(float a[], float b[], int n)
+{
+   int i;
+
+   for (i = 0; i < n; i++)
+      a[i] += b[i];
+}
+/*--------------------------------------------------------------------*/
+/*--------------------------------------------------------------------*/
+void FreqInvert(float y[18][32], int n)
+{
+   int i, j;
+
+   n = (n + 17) / 18;
+   for (j = 0; j < 18; j += 2)
+   {
+      for (i = 0; i < n; i += 2)
+      {
+	 y[1 + j][1 + i] = -y[1 + j][1 + i];
+      }
+   }
+}
+/*--------------------------------------------------------------------*/
diff --git a/code/mp3code/jdw.h b/code/mp3code/jdw.h
new file mode 100644
index 0000000..c8751f9
--- /dev/null
+++ b/code/mp3code/jdw.h
@@ -0,0 +1,28 @@
+/*____________________________________________________________________________
+	
+	FreeAmp - The Free MP3 Player
+
+	Copyright (C) 1998 EMusic.com
+
+	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., 675 Mass Ave, Cambridge, MA 02139, USA.
+	
+	$Id: jdw.h,v 1.2 1999/10/19 07:13:08 elrod Exp $
+____________________________________________________________________________*/
+
+/* LOL */
+
+#ifndef min
+#define min(a,b) ((a>b)?b:a)
+#endif
diff --git a/code/mp3code/l3.h b/code/mp3code/l3.h
new file mode 100644
index 0000000..f7cfee4
--- /dev/null
+++ b/code/mp3code/l3.h
@@ -0,0 +1,187 @@
+/*____________________________________________________________________________
+	
+	FreeAmp - The Free MP3 Player
+
+        MP3 Decoder originally Copyright (C) 1996-1997 Xing Technology
+        Corp.  http://www.xingtech.com
+
+	Portions Copyright (C) 1998-1999 Emusic.com
+
+	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., 675 Mass Ave, Cambridge, MA 02139, USA.
+	
+	$Id: L3.h,v 1.7 1999/12/10 07:16:42 elrod Exp $
+____________________________________________________________________________*/
+
+/****  L3.h  ***************************************************
+
+  Layer III structures
+
+  *** Layer III is 32 bit only          ***
+  *** Layer III code assumes 32 bit int ***
+
+******************************************************************/
+#ifndef L3_H
+#define L3_H
+
+#include "config.h"
+
+#define GLOBAL_GAIN_SCALE (4*15)
+/* #define GLOBAL_GAIN_SCALE 0 */
+
+
+#ifdef _M_IX86
+#define LITTLE_ENDIAN 1
+#endif
+
+#ifdef _M_ALPHA
+#define LITTLE_ENDIAN 1
+#endif
+
+#ifdef sparc
+#define LITTLE_ENDIAN 0
+#endif
+
+#if defined(__POWERPC__)
+#define LITTLE_ENDIAN 0
+#elif defined(__INTEL__)
+#define LITTLE_ENDIAN 1
+#endif
+
+#ifndef LITTLE_ENDIAN
+#error Layer III LITTLE_ENDIAN must be defined 0 or 1
+#endif
+
+/*-----------------------------------------------------------*/
+/*---- huffman lookup tables ---*/
+/* endian dependent !!! */
+#if LITTLE_ENDIAN
+typedef union
+{
+   int ptr;
+   struct
+   {
+      unsigned char signbits;
+      unsigned char x;
+      unsigned char y;
+      unsigned char purgebits;	// 0 = esc
+
+   }
+   b;
+}
+HUFF_ELEMENT;
+
+#else /* big endian machines */
+typedef union
+{
+   int ptr;			/* int must be 32 bits or more */
+   struct
+   {
+      unsigned char purgebits;	// 0 = esc
+
+      unsigned char y;
+      unsigned char x;
+      unsigned char signbits;
+   }
+   b;
+}
+HUFF_ELEMENT;
+
+#endif
+/*--------------------------------------------------------------*/
+typedef struct
+{
+   unsigned int bitbuf;
+   int bits;
+   unsigned char *bs_ptr;
+   unsigned char *bs_ptr0;
+   unsigned char *bs_ptr_end;	// optional for overrun test
+
+}
+BITDAT;
+
+/*-- side info ---*/
+typedef struct
+{
+   int part2_3_length;
+   int big_values;
+   int global_gain;
+   int scalefac_compress;
+   int window_switching_flag;
+   int block_type;
+   int mixed_block_flag;
+   int table_select[3];
+   int subblock_gain[3];
+   int region0_count;
+   int region1_count;
+   int preflag;
+   int scalefac_scale;
+   int count1table_select;
+}
+GR;
+typedef struct
+{
+   int mode;
+   int mode_ext;
+/*---------------*/
+   int main_data_begin;		/* beginning, not end, my spec wrong */
+   int private_bits;
+/*---------------*/
+   int scfsi[2];		/* 4 bit flags [ch] */
+   GR gr[2][2];			/* [gran][ch] */
+}
+SIDE_INFO;
+
+/*-----------------------------------------------------------*/
+/*-- scale factors ---*/
+// check dimensions - need 21 long, 3*12 short
+// plus extra for implicit sf=0 above highest cb
+typedef struct
+{
+   int l[23];			/* [cb] */
+   int s[3][13];		/* [window][cb] */
+}
+SCALEFACT;
+
+/*-----------------------------------------------------------*/
+typedef struct
+{
+   int cbtype;			/* long=0 short=1 */
+   int cbmax;			/* max crit band */
+//   int lb_type;			/* long block type 0 1 3 */
+   int cbs0;			/* short band start index 0 3 12 (12=no shorts */
+   int ncbl;			/* number long cb's 0 8 21 */
+   int cbmax_s[3];		/* cbmax by individual short blocks */
+}
+CB_INFO;
+
+/*-----------------------------------------------------------*/
+/* scale factor infor for MPEG2 intensity stereo  */
+typedef struct
+{
+   int nr[3];
+   int slen[3];
+   int intensity_scale;
+}
+IS_SF_INFO;
+
+
+#ifndef SAMPLE
+#include "small_header.h"
+#endif
+
+/*-----------------------------------------------------------*/
+
+#endif	// #ifndef L3_H
+
diff --git a/code/mp3code/l3dq.c b/code/mp3code/l3dq.c
new file mode 100644
index 0000000..dda1881
--- /dev/null
+++ b/code/mp3code/l3dq.c
@@ -0,0 +1,262 @@
+/*____________________________________________________________________________
+	
+	FreeAmp - The Free MP3 Player
+
+        MP3 Decoder originally Copyright (C) 1995-1997 Xing Technology
+        Corp.  http://www.xingtech.com
+
+	Portions Copyright (C) 1998-1999 EMusic.com
+
+	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., 675 Mass Ave, Cambridge, MA 02139, USA.
+	
+	$Id: l3dq.c,v 1.6 1999/10/19 07:13:09 elrod Exp $
+____________________________________________________________________________*/
+
+/****  quant.c  ***************************************************
+  Layer III  dequant
+
+  does reordering of short blocks
+
+  mod 8/19/98 decode 22 sf bands
+
+******************************************************************/
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <float.h>
+#include <math.h>
+#include <string.h>
+#include "L3.h"
+
+#include "mp3struct.h"
+
+/*----------
+static struct  {
+int l[23];
+int s[14];} sfBandTable[3] =   
+{{{0,4,8,12,16,20,24,30,36,44,52,62,74,90,110,134,162,196,238,288,342,418,576},
+ {0,4,8,12,16,22,30,40,52,66,84,106,136,192}},
+{{0,4,8,12,16,20,24,30,36,42,50,60,72,88,106,128,156,190,230,276,330,384,576},
+ {0,4,8,12,16,22,28,38,50,64,80,100,126,192}},
+{{0,4,8,12,16,20,24,30,36,44,54,66,82,102,126,156,194,240,296,364,448,550,576},
+ {0,4,8,12,16,22,30,42,58,78,104,138,180,192}}};
+----------*/
+
+/*--------------------------------*/
+static const int pretab[2][22] =
+{
+   {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+   {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 3, 3, 3, 2, 0},
+};
+
+
+////@@@@extern int nBand[2][22];	/* long = nBand[0][i], short = nBand[1][i] */
+
+/* 8 bit plus 2 lookup x = pow(2.0, 0.25*(global_gain-210)) */
+/* two extra slots to do 1/sqrt(2) scaling for ms */
+/* 4 extra slots to do 1/2 scaling for cvt to mono */
+static float look_global[256 + 2 + 4];		// effectively constant
+
+/*-------- scaling lookup
+x = pow(2.0, -0.5*(1+scalefact_scale)*scalefac + preemp)
+look_scale[scalefact_scale][preemp][scalefac]
+-----------------------*/
+static float look_scale[2][4][32];			// effectively constant
+typedef float LS[4][32];
+
+
+/*--- iSample**(4/3) lookup, -32<=i<=31 ---*/
+#define ISMAX 32
+static float look_pow[2 * ISMAX];			// effectively constant
+
+/*-- pow(2.0, -0.25*8.0*subblock_gain) --*/
+static float look_subblock[8];				// effectively constant
+
+/*-- reorder buffer ---*/
+static float re_buf[192][3];				// used by dequant() below, but only during func (as workspace)
+typedef float ARRAY3[3];
+
+
+/*=============================================================*/
+float *quant_init_global_addr()
+{
+   return look_global;
+}
+/*-------------------------------------------------------------*/
+LS *quant_init_scale_addr()
+{
+   return look_scale;
+}
+/*-------------------------------------------------------------*/
+float *quant_init_pow_addr()
+{
+   return look_pow;
+}
+/*-------------------------------------------------------------*/
+float *quant_init_subblock_addr()
+{
+   return look_subblock;
+}
+/*=============================================================*/
+
+#ifdef _MSC_VER
+#pragma warning(disable: 4056)
+#endif
+
+void dequant(SAMPLE Sample[], int *nsamp,
+	     SCALEFACT * sf,
+	     GR * gr,
+	     CB_INFO * cb_info, int ncbl_mixed)
+{
+   int i, j;
+   int cb, n, w;
+   float x0, xs;
+   float xsb[3];
+   double tmp;
+   int ncbl;
+   int cbs0;
+   ARRAY3 *buf;			/* short block reorder */
+   int nbands;
+   int i0;
+   int non_zero;
+   int cbmax[3];
+
+   nbands = *nsamp;
+
+
+   ncbl = 22;			/* long block cb end */
+   cbs0 = 12;			/* short block cb start */
+/* ncbl_mixed = 8 or 6  mpeg1 or 2 */
+   if (gr->block_type == 2)
+   {
+      ncbl = 0;
+      cbs0 = 0;
+      if (gr->mixed_block_flag)
+      {
+	 ncbl = ncbl_mixed;
+	 cbs0 = 3;
+      }
+   }
+/* fill in cb_info -- */
+   /* This doesn't seem used anywhere...
+   cb_info->lb_type = gr->block_type;
+   if (gr->block_type == 2)
+      cb_info->lb_type;
+   */
+   cb_info->cbs0 = cbs0;
+   cb_info->ncbl = ncbl;
+
+   cbmax[2] = cbmax[1] = cbmax[0] = 0;
+/* global gain pre-adjusted by 2 if ms_mode, 0 otherwise */
+   x0 = look_global[(2 + 4) + gr->global_gain];
+   i = 0;
+/*----- long blocks ---*/
+   for (cb = 0; cb < ncbl; cb++)
+   {
+      non_zero = 0;
+      xs = x0 * look_scale[gr->scalefac_scale][pretab[gr->preflag][cb]][sf->l[cb]];
+      n = pMP3Stream->nBand[0][cb];
+      for (j = 0; j < n; j++, i++)
+      {
+	 if (Sample[i].s == 0)
+	    Sample[i].x = 0.0F;
+	 else
+	 {
+	    non_zero = 1;
+	    if ((Sample[i].s >= (-ISMAX)) && (Sample[i].s < ISMAX))
+	       Sample[i].x = xs * look_pow[ISMAX + Sample[i].s];
+	    else
+	    {
+		float tmpConst = (float)(1.0/3.0);
+	       tmp = (double) Sample[i].s;
+	       Sample[i].x = (float) (xs * tmp * pow(fabs(tmp), tmpConst));
+	    }
+	 }
+      }
+      if (non_zero)
+	 cbmax[0] = cb;
+      if (i >= nbands)
+	 break;
+   }
+
+   cb_info->cbmax = cbmax[0];
+   cb_info->cbtype = 0;		// type = long
+
+   if (cbs0 >= 12)
+      return;
+/*---------------------------
+block type = 2  short blocks
+----------------------------*/
+   cbmax[2] = cbmax[1] = cbmax[0] = cbs0;
+   i0 = i;			/* save for reorder */
+   buf = re_buf;
+   for (w = 0; w < 3; w++)
+      xsb[w] = x0 * look_subblock[gr->subblock_gain[w]];
+   for (cb = cbs0; cb < 13; cb++)
+   {
+      n = pMP3Stream->nBand[1][cb];
+      for (w = 0; w < 3; w++)
+      {
+	 non_zero = 0;
+	 xs = xsb[w] * look_scale[gr->scalefac_scale][0][sf->s[w][cb]];
+	 for (j = 0; j < n; j++, i++)
+	 {
+	    if (Sample[i].s == 0)
+	       buf[j][w] = 0.0F;
+	    else
+	    {
+	       non_zero = 1;
+	       if ((Sample[i].s >= (-ISMAX)) && (Sample[i].s < ISMAX))
+		  buf[j][w] = xs * look_pow[ISMAX + Sample[i].s];
+	       else
+	       {
+		  float tmpConst = (float)(1.0/3.0);
+		  tmp = (double) Sample[i].s;
+		  buf[j][w] = (float) (xs * tmp * pow(fabs(tmp), tmpConst));
+	       }
+	    }
+	 }
+	 if (non_zero)
+	    cbmax[w] = cb;
+      }
+      if (i >= nbands)
+	 break;
+      buf += n;
+   }
+
+
+   memmove(&Sample[i0].x, &re_buf[0][0], sizeof(float) * (i - i0));
+
+   *nsamp = i;			/* update nsamp */
+   cb_info->cbmax_s[0] = cbmax[0];
+   cb_info->cbmax_s[1] = cbmax[1];
+   cb_info->cbmax_s[2] = cbmax[2];
+   if (cbmax[1] > cbmax[0])
+      cbmax[0] = cbmax[1];
+   if (cbmax[2] > cbmax[0])
+      cbmax[0] = cbmax[2];
+
+   cb_info->cbmax = cbmax[0];
+   cb_info->cbtype = 1;		/* type = short */
+
+
+   return;
+}
+
+#ifdef _MSC_VER
+#pragma warning(default: 4056)
+#endif
+
+/*-------------------------------------------------------------*/
diff --git a/code/mp3code/l3init.c b/code/mp3code/l3init.c
new file mode 100644
index 0000000..aaf1ad7
--- /dev/null
+++ b/code/mp3code/l3init.c
@@ -0,0 +1,422 @@
+/*____________________________________________________________________________
+	
+	FreeAmp - The Free MP3 Player
+
+        MP3 Decoder originally Copyright (C) 1995-1997 Xing Technology
+        Corp.  http://www.xingtech.com
+
+	Portions Copyright (C) 1998 EMusic.com
+
+	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., 675 Mass Ave, Cambridge, MA 02139, USA.
+	
+	$Id: l3init.c,v 1.2 1999/10/19 07:13:09 elrod Exp $
+____________________________________________________________________________*/
+
+/****  tinit.c  ***************************************************
+  Layer III  init tables
+
+
+******************************************************************/
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <float.h>
+#include <math.h>
+#include "L3.h"
+
+/* get rid of precision loss warnings on conversion */
+#ifdef _MSC_VER
+#pragma warning(disable:4244 4056)
+#endif
+
+
+/*---------- quant ---------------------------------*/
+/* 8 bit lookup x = pow(2.0, 0.25*(global_gain-210)) */
+float *quant_init_global_addr();
+
+
+/* x = pow(2.0, -0.5*(1+scalefact_scale)*scalefac + preemp) */
+typedef float LS[4][32];
+LS *quant_init_scale_addr();
+
+
+float *quant_init_pow_addr();
+float *quant_init_subblock_addr();
+
+typedef int iARRAY22[22];
+iARRAY22 *quant_init_band_addr();
+
+/*---------- antialias ---------------------------------*/
+typedef float PAIR[2];
+PAIR *alias_init_addr();
+
+static const float Ci[8] =
+{
+   -0.6f, -0.535f, -0.33f, -0.185f, -0.095f, -0.041f, -0.0142f, -0.0037f};
+
+
+void hwin_init();		/* hybrid windows -- */
+void imdct_init();
+typedef struct
+{
+   float *w;
+   float *w2;
+   void *coef;
+}
+IMDCT_INIT_BLOCK;
+
+void msis_init();
+void msis_init_MPEG2();
+
+/*=============================================================*/
+int L3table_init()
+{
+   int i;
+   float *x;
+   LS *ls;
+   int scalefact_scale, preemp, scalefac;
+   double tmp;
+   PAIR *csa;
+
+   static int iOnceOnly = 0;
+
+   	if (!iOnceOnly++)
+	{
+/*================ quant ===============================*/
+
+	/* 8 bit plus 2 lookup x = pow(2.0, 0.25*(global_gain-210)) */
+	/* extra 2 for ms scaling by 1/sqrt(2) */
+	/* extra 4 for cvt to mono scaling by 1/2 */
+	   x = quant_init_global_addr();
+	   for (i = 0; i < 256 + 2 + 4; i++)
+		  x[i] = (float) pow(2.0, 0.25 * ((i - (2 + 4)) - 210 + GLOBAL_GAIN_SCALE));
+
+
+
+	/* x = pow(2.0, -0.5*(1+scalefact_scale)*scalefac + preemp) */
+	   ls = quant_init_scale_addr();
+	   for (scalefact_scale = 0; scalefact_scale < 2; scalefact_scale++)
+	   {
+		  for (preemp = 0; preemp < 4; preemp++)
+		  {
+		 for (scalefac = 0; scalefac < 32; scalefac++)
+		 {
+			ls[scalefact_scale][preemp][scalefac] =
+			   (float) pow(2.0, -0.5 * (1 + scalefact_scale) * (scalefac + preemp));
+		 }
+		  }
+	   }
+
+	/*--- iSample**(4/3) lookup, -32<=i<=31 ---*/
+	   x = quant_init_pow_addr();
+	   for (i = 0; i < 64; i++)
+	   {
+		  tmp = i - 32;
+		  x[i] = (float) (tmp * pow(fabs(tmp), (1.0 / 3.0)));
+	   }
+
+
+	/*-- pow(2.0, -0.25*8.0*subblock_gain)  3 bits --*/
+	   x = quant_init_subblock_addr();
+	   for (i = 0; i < 8; i++)
+	   {
+		  x[i] = (float) pow(2.0, 0.25 * -8.0 * i);
+	   }
+
+	/*-------------------------*/
+	// quant_init_sf_band(sr_index);   replaced by code in sup.c
+
+
+/*================ antialias ===============================*/
+	   // onceonly!!!!!!!!!!!!!!!!!!!!!
+	   csa = alias_init_addr();
+	   for (i = 0; i < 8; i++)
+	   {
+		  csa[i][0] = (float) (1.0 / sqrt(1.0 + Ci[i] * Ci[i]));
+		  csa[i][1] = (float) (Ci[i] / sqrt(1.0 + Ci[i] * Ci[i]));
+	   }
+   }
+
+   // these 4 are iOnceOnly-protected inside...
+
+/*================ msis ===============================*/
+   msis_init();
+   msis_init_MPEG2();
+
+/*================ imdct ===============================*/
+   imdct_init();
+
+/*--- hybrid windows ------------*/
+   hwin_init();
+
+   return 0;
+}
+/*====================================================================*/
+typedef float ARRAY36[36];
+ARRAY36 *hwin_init_addr();
+
+/*--------------------------------------------------------------------*/
+void hwin_init()
+{
+   int i, j;
+   double pi;
+   ARRAY36 *win;
+
+   static int iOnceOnly = 0;
+
+   if (!iOnceOnly++)
+   {
+	   win = hwin_init_addr();
+
+	   pi = 4.0 * atan(1.0);
+
+	/* type 0 */
+	   for (i = 0; i < 36; i++)
+		  win[0][i] = (float) sin(pi / 36 * (i + 0.5));
+
+	/* type 1 */
+	   for (i = 0; i < 18; i++)
+		  win[1][i] = (float) sin(pi / 36 * (i + 0.5));
+	   for (i = 18; i < 24; i++)
+		  win[1][i] = 1.0F;
+	   for (i = 24; i < 30; i++)
+		  win[1][i] = (float) sin(pi / 12 * (i + 0.5 - 18));
+	   for (i = 30; i < 36; i++)
+		  win[1][i] = 0.0F;
+
+	/* type 3 */
+	   for (i = 0; i < 6; i++)
+		  win[3][i] = 0.0F;
+	   for (i = 6; i < 12; i++)
+		  win[3][i] = (float) sin(pi / 12 * (i + 0.5 - 6));
+	   for (i = 12; i < 18; i++)
+		  win[3][i] = 1.0F;
+	   for (i = 18; i < 36; i++)
+		  win[3][i] = (float) sin(pi / 36 * (i + 0.5));
+
+	/* type 2 */
+	   for (i = 0; i < 12; i++)
+		  win[2][i] = (float) sin(pi / 12 * (i + 0.5));
+	   for (i = 12; i < 36; i++)
+		  win[2][i] = 0.0F;
+
+	/*--- invert signs by region to match mdct 18pt --> 36pt mapping */
+	   for (j = 0; j < 4; j++)
+	   {
+		  if (j == 2)
+		 continue;
+		  for (i = 9; i < 36; i++)
+		 win[j][i] = -win[j][i];
+	   }
+
+	/*-- invert signs for short blocks --*/
+	   for (i = 3; i < 12; i++)
+		  win[2][i] = -win[2][i];
+   }   
+}
+/*=============================================================*/
+typedef float ARRAY4[4];
+const IMDCT_INIT_BLOCK *imdct_init_addr_18();
+const IMDCT_INIT_BLOCK *imdct_init_addr_6();
+
+/*-------------------------------------------------------------*/
+void imdct_init()
+{
+   int k, p, n;
+   double t, pi;
+   const IMDCT_INIT_BLOCK *addr;
+   float *w, *w2;
+   float *v, *v2, *coef87;
+   ARRAY4 *coef;
+
+   static int iOnceOnly = 0;
+
+   if (!iOnceOnly++)
+   {
+	/*--- 18 point --*/
+	   addr = imdct_init_addr_18();
+	   w = addr->w;
+	   w2 = addr->w2;
+	   coef = addr->coef;
+	/*----*/
+	   n = 18;
+	   pi = 4.0 * atan(1.0);
+	   t = pi / (4 * n);
+	   for (p = 0; p < n; p++)
+		  w[p] = (float) (2.0 * cos(t * (2 * p + 1)));
+	   for (p = 0; p < 9; p++)
+		  w2[p] = (float) 2.0 *cos(2 * t * (2 * p + 1));
+
+	   t = pi / (2 * n);
+	   for (k = 0; k < 9; k++)
+	   {
+		  for (p = 0; p < 4; p++)
+		 coef[k][p] = (float) cos(t * (2 * k) * (2 * p + 1));
+	   }
+
+	/*--- 6 point */
+	   addr = imdct_init_addr_6();
+	   v = addr->w;
+	   v2 = addr->w2;
+	   coef87 = addr->coef;
+	/*----*/
+	   n = 6;
+	   pi = 4.0 * atan(1.0);
+	   t = pi / (4 * n);
+	   for (p = 0; p < n; p++)
+		  v[p] = (float) 2.0 *cos(t * (2 * p + 1));
+
+	   for (p = 0; p < 3; p++)
+		  v2[p] = (float) 2.0 *cos(2 * t * (2 * p + 1));
+
+	   t = pi / (2 * n);
+	   k = 1;
+	   p = 0;
+	   *coef87 = (float) cos(t * (2 * k) * (2 * p + 1));
+	/* adjust scaling to save a few mults */
+	   for (p = 0; p < 6; p++)
+		  v[p] = v[p] / 2.0f;
+	   *coef87 = (float) 2.0 *(*coef87);
+
+   }   
+}
+/*===============================================================*/
+typedef float ARRAY8_2[8][2];
+ARRAY8_2 *msis_init_addr();
+
+/*-------------------------------------------------------------*/
+void msis_init()
+{
+   int i;
+   double s, c;
+   double pi;
+   double t;
+   ARRAY8_2 *lr;
+
+   static int iOnceOnly = 0;
+
+   if (!iOnceOnly++)
+   {
+	   lr = msis_init_addr();
+
+
+	   pi = 4.0 * atan(1.0);
+	   t = pi / 12.0;
+	   for (i = 0; i < 7; i++)
+	   {
+		  s = sin(i * t);
+		  c = cos(i * t);
+		/* ms_mode = 0 */
+		  lr[0][i][0] = (float) (s / (s + c));
+		  lr[0][i][1] = (float) (c / (s + c));
+		/* ms_mode = 1 */
+		  lr[1][i][0] = (float) (sqrt(2.0) * (s / (s + c)));
+		  lr[1][i][1] = (float) (sqrt(2.0) * (c / (s + c)));
+	   }
+	/* sf = 7 */
+	/* ms_mode = 0 */
+	   lr[0][i][0] = 1.0f;
+	   lr[0][i][1] = 0.0f;
+	/* ms_mode = 1, in is bands is routine does ms processing */
+	   lr[1][i][0] = 1.0f;
+	   lr[1][i][1] = 1.0f;
+
+
+	/*-------
+	for(i=0;i<21;i++) nBand[0][i] = 
+				sfBandTable[sr_index].l[i+1] - sfBandTable[sr_index].l[i];
+	for(i=0;i<12;i++) nBand[1][i] = 
+				sfBandTable[sr_index].s[i+1] - sfBandTable[sr_index].s[i];
+	-------------*/
+   }
+}
+/*-------------------------------------------------------------*/
+/*===============================================================*/
+typedef float ARRAY2_64_2[2][64][2];
+ARRAY2_64_2 *msis_init_addr_MPEG2();
+
+/*-------------------------------------------------------------*/
+void msis_init_MPEG2()
+{
+   int k, n;
+   double t;
+   ARRAY2_64_2 *lr2;
+   int intensity_scale, ms_mode, sf, sflen;
+   float ms_factor[2];
+
+   static int iOnceOnly = 0;
+
+   if (!iOnceOnly++)
+   {
+	   ms_factor[0] = 1.0;
+	   ms_factor[1] = (float) sqrt(2.0);
+
+	   lr2 = msis_init_addr_MPEG2();
+
+	/* intensity stereo MPEG2 */
+	/* lr2[intensity_scale][ms_mode][sflen_offset+sf][left/right] */
+
+	   for (intensity_scale = 0; intensity_scale < 2; intensity_scale++)
+	   {
+		  t = pow(2.0, -0.25 * (1 + intensity_scale));
+		  for (ms_mode = 0; ms_mode < 2; ms_mode++)
+		  {
+
+		 n = 1;
+		 k = 0;
+		 for (sflen = 0; sflen < 6; sflen++)
+		 {
+			for (sf = 0; sf < (n - 1); sf++, k++)
+			{
+			   if (sf == 0)
+			   {
+			  lr2[intensity_scale][ms_mode][k][0] = ms_factor[ms_mode] * 1.0f;
+			  lr2[intensity_scale][ms_mode][k][1] = ms_factor[ms_mode] * 1.0f;
+			   }
+			   else if ((sf & 1))
+			   {
+			  lr2[intensity_scale][ms_mode][k][0] =
+				 (float) (ms_factor[ms_mode] * pow(t, (sf + 1) / 2));
+			  lr2[intensity_scale][ms_mode][k][1] = ms_factor[ms_mode] * 1.0f;
+			   }
+			   else
+			   {
+			  lr2[intensity_scale][ms_mode][k][0] = ms_factor[ms_mode] * 1.0f;
+			  lr2[intensity_scale][ms_mode][k][1] =
+				 (float) (ms_factor[ms_mode] * pow(t, sf / 2));
+			   }
+			}
+
+		  /* illegal is_pos used to do ms processing */
+			if (ms_mode == 0)
+			{			/* ms_mode = 0 */
+			   lr2[intensity_scale][ms_mode][k][0] = 1.0f;
+			   lr2[intensity_scale][ms_mode][k][1] = 0.0f;
+			}
+			else
+			{
+			 /* ms_mode = 1, in is bands is routine does ms processing */
+			   lr2[intensity_scale][ms_mode][k][0] = 1.0f;
+			   lr2[intensity_scale][ms_mode][k][1] = 1.0f;
+			}
+			k++;
+			n = n + n;
+		 }
+		  }
+	   }
+   }
+
+}
+/*-------------------------------------------------------------*/
diff --git a/code/mp3code/mdct.c b/code/mp3code/mdct.c
new file mode 100644
index 0000000..10c21cf
--- /dev/null
+++ b/code/mp3code/mdct.c
@@ -0,0 +1,229 @@
+/*____________________________________________________________________________
+	
+	FreeAmp - The Free MP3 Player
+
+        MP3 Decoder originally Copyright (C) 1995-1997 Xing Technology
+        Corp.  http://www.xingtech.com
+
+	Portions Copyright (C) 1998-1999 EMusic.com
+
+	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., 675 Mass Ave, Cambridge, MA 02139, USA.
+	
+	$Id: mdct.c,v 1.4 1999/10/19 07:13:09 elrod Exp $
+____________________________________________________________________________*/
+
+/****  mdct.c  ***************************************************
+
+Layer III 
+
+  cos transform for n=18, n=6
+
+computes  c[k] =  Sum( cos((pi/4*n)*(2*k+1)*(2*p+1))*f[p] )
+                k = 0, ...n-1,  p = 0...n-1
+
+
+inplace ok.
+
+******************************************************************/
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <float.h>
+#include <math.h>
+
+
+/*------ 18 point xform -------*/
+float mdct18w[18];		// effectively constant
+float mdct18w2[9];		//  "  "
+float coef[9][4];		//  "  "
+
+float mdct6_3v[6];		//  "  "
+float mdct6_3v2[3];		//  "  "
+float coef87;			//  "  "
+
+typedef struct
+{
+   float *w;
+   float *w2;
+   void *coef;
+}
+IMDCT_INIT_BLOCK;
+
+static const IMDCT_INIT_BLOCK imdct_info_18 =
+{mdct18w, mdct18w2, coef};
+static const IMDCT_INIT_BLOCK imdct_info_6 =
+{mdct6_3v, mdct6_3v2, &coef87};
+
+
+
+/*====================================================================*/
+const IMDCT_INIT_BLOCK *imdct_init_addr_18()
+{
+   return &imdct_info_18;
+}
+const IMDCT_INIT_BLOCK *imdct_init_addr_6()
+{
+   return &imdct_info_6;
+}
+/*--------------------------------------------------------------------*/
+void imdct18(float f[18])	/* 18 point */
+{
+   int p;
+   float a[9], b[9];
+   float ap, bp, a8p, b8p;
+   float g1, g2;
+
+
+   for (p = 0; p < 4; p++)
+   {
+      g1 = mdct18w[p] * f[p];
+      g2 = mdct18w[17 - p] * f[17 - p];
+      ap = g1 + g2;		// a[p]
+
+      bp = mdct18w2[p] * (g1 - g2);	// b[p]
+
+      g1 = mdct18w[8 - p] * f[8 - p];
+      g2 = mdct18w[9 + p] * f[9 + p];
+      a8p = g1 + g2;		// a[8-p]
+
+      b8p = mdct18w2[8 - p] * (g1 - g2);	// b[8-p]
+
+      a[p] = ap + a8p;
+      a[5 + p] = ap - a8p;
+      b[p] = bp + b8p;
+      b[5 + p] = bp - b8p;
+   }
+   g1 = mdct18w[p] * f[p];
+   g2 = mdct18w[17 - p] * f[17 - p];
+   a[p] = g1 + g2;
+   b[p] = mdct18w2[p] * (g1 - g2);
+
+
+   f[0] = 0.5f * (a[0] + a[1] + a[2] + a[3] + a[4]);
+   f[1] = 0.5f * (b[0] + b[1] + b[2] + b[3] + b[4]);
+
+   f[2] = coef[1][0] * a[5] + coef[1][1] * a[6] + coef[1][2] * a[7]
+      + coef[1][3] * a[8];
+   f[3] = coef[1][0] * b[5] + coef[1][1] * b[6] + coef[1][2] * b[7]
+      + coef[1][3] * b[8] - f[1];
+   f[1] = f[1] - f[0];
+   f[2] = f[2] - f[1];
+
+   f[4] = coef[2][0] * a[0] + coef[2][1] * a[1] + coef[2][2] * a[2]
+      + coef[2][3] * a[3] - a[4];
+   f[5] = coef[2][0] * b[0] + coef[2][1] * b[1] + coef[2][2] * b[2]
+      + coef[2][3] * b[3] - b[4] - f[3];
+   f[3] = f[3] - f[2];
+   f[4] = f[4] - f[3];
+
+   f[6] = coef[3][0] * (a[5] - a[7] - a[8]);
+   f[7] = coef[3][0] * (b[5] - b[7] - b[8]) - f[5];
+   f[5] = f[5] - f[4];
+   f[6] = f[6] - f[5];
+
+   f[8] = coef[4][0] * a[0] + coef[4][1] * a[1] + coef[4][2] * a[2]
+      + coef[4][3] * a[3] + a[4];
+   f[9] = coef[4][0] * b[0] + coef[4][1] * b[1] + coef[4][2] * b[2]
+      + coef[4][3] * b[3] + b[4] - f[7];
+   f[7] = f[7] - f[6];
+   f[8] = f[8] - f[7];
+
+   f[10] = coef[5][0] * a[5] + coef[5][1] * a[6] + coef[5][2] * a[7]
+      + coef[5][3] * a[8];
+   f[11] = coef[5][0] * b[5] + coef[5][1] * b[6] + coef[5][2] * b[7]
+      + coef[5][3] * b[8] - f[9];
+   f[9] = f[9] - f[8];
+   f[10] = f[10] - f[9];
+
+   f[12] = 0.5f * (a[0] + a[2] + a[3]) - a[1] - a[4];
+   f[13] = 0.5f * (b[0] + b[2] + b[3]) - b[1] - b[4] - f[11];
+   f[11] = f[11] - f[10];
+   f[12] = f[12] - f[11];
+
+   f[14] = coef[7][0] * a[5] + coef[7][1] * a[6] + coef[7][2] * a[7]
+      + coef[7][3] * a[8];
+   f[15] = coef[7][0] * b[5] + coef[7][1] * b[6] + coef[7][2] * b[7]
+      + coef[7][3] * b[8] - f[13];
+   f[13] = f[13] - f[12];
+   f[14] = f[14] - f[13];
+
+   f[16] = coef[8][0] * a[0] + coef[8][1] * a[1] + coef[8][2] * a[2]
+      + coef[8][3] * a[3] + a[4];
+   f[17] = coef[8][0] * b[0] + coef[8][1] * b[1] + coef[8][2] * b[2]
+      + coef[8][3] * b[3] + b[4] - f[15];
+   f[15] = f[15] - f[14];
+   f[16] = f[16] - f[15];
+   f[17] = f[17] - f[16];
+
+
+   return;
+}
+/*--------------------------------------------------------------------*/
+/* does 3, 6 pt dct.  changes order from f[i][window] c[window][i] */
+void imdct6_3(float f[])	/* 6 point */
+{
+   int w;
+   float buf[18];
+   float *a, *c;		// b[i] = a[3+i]
+
+   float g1, g2;
+   float a02, b02;
+
+   c = f;
+   a = buf;
+   for (w = 0; w < 3; w++)
+   {
+      g1 = mdct6_3v[0] * f[3 * 0];
+      g2 = mdct6_3v[5] * f[3 * 5];
+      a[0] = g1 + g2;
+      a[3 + 0] = mdct6_3v2[0] * (g1 - g2);
+
+      g1 = mdct6_3v[1] * f[3 * 1];
+      g2 = mdct6_3v[4] * f[3 * 4];
+      a[1] = g1 + g2;
+      a[3 + 1] = mdct6_3v2[1] * (g1 - g2);
+
+      g1 = mdct6_3v[2] * f[3 * 2];
+      g2 = mdct6_3v[3] * f[3 * 3];
+      a[2] = g1 + g2;
+      a[3 + 2] = mdct6_3v2[2] * (g1 - g2);
+
+      a += 6;
+      f++;
+   }
+
+   a = buf;
+   for (w = 0; w < 3; w++)
+   {
+      a02 = (a[0] + a[2]);
+      b02 = (a[3 + 0] + a[3 + 2]);
+      c[0] = a02 + a[1];
+      c[1] = b02 + a[3 + 1];
+      c[2] = coef87 * (a[0] - a[2]);
+      c[3] = coef87 * (a[3 + 0] - a[3 + 2]) - c[1];
+      c[1] = c[1] - c[0];
+      c[2] = c[2] - c[1];
+      c[4] = a02 - a[1] - a[1];
+      c[5] = b02 - a[3 + 1] - a[3 + 1] - c[3];
+      c[3] = c[3] - c[2];
+      c[4] = c[4] - c[3];
+      c[5] = c[5] - c[4];
+      a += 6;
+      c += 6;
+   }
+
+   return;
+}
+/*--------------------------------------------------------------------*/
diff --git a/code/mp3code/mhead.c b/code/mp3code/mhead.c
new file mode 100644
index 0000000..496ff4a
--- /dev/null
+++ b/code/mp3code/mhead.c
@@ -0,0 +1,328 @@
+/*____________________________________________________________________________
+	
+	FreeAmp - The Free MP3 Player
+
+        MP3 Decoder originally Copyright (C) 1995-1997 Xing Technology
+        Corp.  http://www.xingtech.com
+
+	Portions Copyright (C) 1998-1999 EMusic.com
+
+	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., 675 Mass Ave, Cambridge, MA 02139, USA.
+	
+	$Id: mhead.c,v 1.7 1999/10/19 07:13:09 elrod Exp $
+____________________________________________________________________________*/
+
+/*------------ mhead.c ----------------------------------------------
+  mpeg audio
+  extract info from mpeg header
+  portable version (adapted from c:\eco\mhead.c
+
+  add Layer III
+
+  mods 6/18/97 re mux restart, 32 bit ints
+
+  mod 5/7/98 parse mpeg 2.5
+
+---------------------------------------------------------------------*/
+#include <stdlib.h>
+#include <stdio.h>
+#include <float.h>
+#include <math.h>
+#include "mhead.h"		/* mpeg header structure */
+
+static const int mp_br_table[2][16] =
+{{0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160, 0},
+ {0, 32, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 384, 0}};
+static const int mp_sr20_table[2][4] =
+{{441, 480, 320, -999}, {882, 960, 640, -999}};
+
+static const int mp_br_tableL1[2][16] =
+{{0, 32, 48, 56, 64, 80, 96, 112, 128, 144, 160, 176, 192, 224, 256, 0},/* mpeg2 */
+ {0, 32, 64, 96, 128, 160, 192, 224, 256, 288, 320, 352, 384, 416, 448, 0}};
+
+static const int mp_br_tableL3[2][16] =
+{{0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160, 0},      /* mpeg 2 */
+ {0, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 0}};
+
+
+
+static int find_sync(unsigned char *buf, int n);
+static int sync_scan(unsigned char *buf, int n, int i0);
+static int sync_test(unsigned char *buf, int n, int isync, int padbytes);
+
+
+/*--------------------------------------------------------------*/
+int head_info(unsigned char *buf, unsigned int n, MPEG_HEAD * h)
+{
+   int framebytes;
+   int mpeg25_flag;
+  
+   if (n > 10000)
+      n = 10000;		/* limit scan for free format */
+
+
+
+   h->sync = 0;
+   //if ((buf[0] == 0xFF) && ((buf[1] & 0xF0) == 0xF0))
+   if ((buf[0] == 0xFF) && ((buf[0+1] & 0xF0) == 0xF0))
+   {
+      mpeg25_flag = 0;		// mpeg 1 & 2
+
+   }
+   else if ((buf[0] == 0xFF) && ((buf[0+1] & 0xF0) == 0xE0))
+   {
+      mpeg25_flag = 1;		// mpeg 2.5
+
+   }
+   else
+      return 0;			// sync fail
+
+   h->sync = 1;
+   if (mpeg25_flag)
+      h->sync = 2;		//low bit clear signals mpeg25 (as in 0xFFE)
+
+   h->id = (buf[0+1] & 0x08) >> 3;
+   h->option = (buf[0+1] & 0x06) >> 1;
+   h->prot = (buf[0+1] & 0x01);
+
+   h->br_index = (buf[0+2] & 0xf0) >> 4;
+   h->sr_index = (buf[0+2] & 0x0c) >> 2;
+   h->pad = (buf[0+2] & 0x02) >> 1;
+   h->private_bit = (buf[0+2] & 0x01);
+   h->mode = (buf[0+3] & 0xc0) >> 6;
+   h->mode_ext = (buf[0+3] & 0x30) >> 4;
+   h->cr = (buf[0+3] & 0x08) >> 3;
+   h->original = (buf[0+3] & 0x04) >> 2;
+   h->emphasis = (buf[0+3] & 0x03);
+
+
+// if( mpeg25_flag ) {
+ //    if( h->sr_index == 2 ) return 0;   // fail 8khz
+ //}
+
+
+/* compute framebytes for Layer I, II, III */
+   if (h->option < 1)
+      return 0;
+   if (h->option > 3)
+      return 0;
+
+   framebytes = 0;
+
+   if (h->br_index > 0)
+   {
+      if (h->option == 3)
+      {				/* layer I */
+	 framebytes =
+	    240 * mp_br_tableL1[h->id][h->br_index]
+	    / mp_sr20_table[h->id][h->sr_index];
+	 framebytes = 4 * framebytes;
+      }
+      else if (h->option == 2)
+      {				/* layer II */
+	 framebytes =
+	    2880 * mp_br_table[h->id][h->br_index]
+	    / mp_sr20_table[h->id][h->sr_index];
+      }
+      else if (h->option == 1)
+      {				/* layer III */
+	 if (h->id)
+	 {			// mpeg1
+
+	    framebytes =
+	       2880 * mp_br_tableL3[h->id][h->br_index]
+	       / mp_sr20_table[h->id][h->sr_index];
+	 }
+	 else
+	 {			// mpeg2
+
+	    if (mpeg25_flag)
+	    {			// mpeg2.2
+
+	       framebytes =
+		  2880 * mp_br_tableL3[h->id][h->br_index]
+		  / mp_sr20_table[h->id][h->sr_index];
+	    }
+	    else
+	    {
+	       framebytes =
+		  1440 * mp_br_tableL3[h->id][h->br_index]
+		  / mp_sr20_table[h->id][h->sr_index];
+	    }
+	 }
+      }
+   }
+   else
+      framebytes = find_sync(buf, n);	/* free format */
+
+  return framebytes;
+}
+
+int head_info3(unsigned char *buf, unsigned int n, MPEG_HEAD *h, int *br, unsigned int *searchForward) {
+	unsigned int pBuf = 0;
+
+	// jdw insertion...
+   while ((pBuf < n) && !((buf[pBuf] == 0xFF) && 
+          ((buf[pBuf+1] & 0xF0) == 0xF0 || (buf[pBuf+1] & 0xF0) == 0xE0))) 
+   {
+		pBuf++;
+   }
+
+   if (pBuf == n) return 0;
+
+   *searchForward = pBuf;
+   return head_info2(&(buf[pBuf]),n,h,br);
+}
+
+/*--------------------------------------------------------------*/
+int head_info2(unsigned char *buf, unsigned int n, MPEG_HEAD * h, int *br)
+{
+	int framebytes;
+	
+	/*---  return br (in bits/sec) in addition to frame bytes ---*/
+	
+	*br = 0;
+	/*-- assume fail --*/
+	framebytes = head_info(buf, n, h);
+	
+	if (framebytes == 0)
+		return 0; 
+	
+	switch (h->option)
+	{
+		case 1:	/* layer III */
+		{
+			if (h->br_index > 0)
+				*br = 1000 * mp_br_tableL3[h->id][h->br_index];
+			else
+			{
+				if (h->id)		// mpeg1
+					
+					*br = 1000 * framebytes * mp_sr20_table[h->id][h->sr_index] / (144 * 20);
+				else
+				{			// mpeg2
+					
+					if ((h->sync & 1) == 0)	//  flags mpeg25
+						
+						*br = 500 * framebytes * mp_sr20_table[h->id][h->sr_index] / (72 * 20);
+					else
+						*br = 1000 * framebytes * mp_sr20_table[h->id][h->sr_index] / (72 * 20);
+				}
+			}
+		}
+		break;
+
+		case 2:	/* layer II */
+		{
+			if (h->br_index > 0)
+				*br = 1000 * mp_br_table[h->id][h->br_index];
+			else
+				*br = 1000 * framebytes * mp_sr20_table[h->id][h->sr_index]	/ (144 * 20);
+		}
+		break;
+
+		case 3:	/* layer I */
+		{
+			if (h->br_index > 0)
+				*br = 1000 * mp_br_tableL1[h->id][h->br_index];
+			else
+				*br = 1000 * framebytes * mp_sr20_table[h->id][h->sr_index]	/ (48 * 20);
+		}
+		break;
+
+		default:
+
+			return 0;	// fuck knows what this is, but it ain't one of ours...
+	}
+		
+		
+	return framebytes;
+}
+/*--------------------------------------------------------------*/
+static int compare(unsigned char *buf, unsigned char *buf2)
+{
+   if (buf[0] != buf2[0])
+      return 0;
+   if (buf[1] != buf2[1])
+      return 0;
+   return 1;
+}
+/*----------------------------------------------------------*/
+/*-- does not scan for initial sync, initial sync assumed --*/
+static int find_sync(unsigned char *buf, int n)
+{
+   int i0, isync, nmatch, pad;
+   int padbytes, option;
+
+/* mod 4/12/95 i0 change from 72, allows as low as 8kbits for mpeg1 */
+   i0 = 24;
+   padbytes = 1;
+   option = (buf[1] & 0x06) >> 1;
+   if (option == 3)
+   {
+      padbytes = 4;
+      i0 = 24;			/* for shorter layer I frames */
+   }
+
+   pad = (buf[2] & 0x02) >> 1;
+
+   n -= 3;			/*  need 3 bytes of header  */
+
+   while (i0 < 2000)
+   {
+      isync = sync_scan(buf, n, i0);
+      i0 = isync + 1;
+      isync -= pad;
+      if (isync <= 0)
+	 return 0;
+      nmatch = sync_test(buf, n, isync, padbytes);
+      if (nmatch > 0)
+	 return isync;
+   }
+
+   return 0;
+}
+/*------------------------------------------------------*/
+/*---- scan for next sync, assume start is valid -------*/
+/*---- return number bytes to next sync ----------------*/
+static int sync_scan(unsigned char *buf, int n, int i0)
+{
+   int i;
+
+   for (i = i0; i < n; i++)
+      if (compare(buf, buf + i))
+	 return i;
+
+   return 0;
+}
+/*------------------------------------------------------*/
+/*- test consecutative syncs, input isync without pad --*/
+static int sync_test(unsigned char *buf, int n, int isync, int padbytes)
+{
+   int i, nmatch, pad;
+
+   nmatch = 0;
+   for (i = 0;;)
+   {
+      pad = padbytes * ((buf[i + 2] & 0x02) >> 1);
+      i += (pad + isync);
+      if (i > n)
+	 break;
+      if (!compare(buf, buf + i))
+	 return -nmatch;
+      nmatch++;
+   }
+   return nmatch;
+}
diff --git a/code/mp3code/mhead.h b/code/mp3code/mhead.h
new file mode 100644
index 0000000..3a526b1
--- /dev/null
+++ b/code/mp3code/mhead.h
@@ -0,0 +1,102 @@
+#ifndef MHEAD_H
+#define MHEAD_H
+
+
+/*____________________________________________________________________________
+	
+	FreeAmp - The Free MP3 Player
+
+        MP3 Decoder originally Copyright (C) 1995-1997 Xing Technology
+        Corp.  http://www.xingtech.com
+
+	Portions Copyright (C) 1998 EMusic.com
+
+	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., 675 Mass Ave, Cambridge, MA 02139, USA.
+	
+	$Id: mhead.h,v 1.3 1999/10/19 07:13:08 elrod Exp $
+____________________________________________________________________________*/
+
+/* portable copy of eco\mhead.h */
+/* mpeg audio header   */
+typedef struct
+{
+   int sync;			/* 1 if valid sync */
+   int id;
+   int option;
+   int prot;
+   int br_index;
+   int sr_index;
+   int pad;
+   int private_bit;
+   int mode;
+   int mode_ext;
+   int cr;
+   int original;
+   int emphasis;
+}
+MPEG_HEAD;
+
+/* portable mpeg audio decoder, decoder functions */
+
+#ifndef IN_OUT
+#include "small_header.h"
+#endif
+
+typedef struct
+{
+   int channels;
+   int outvalues;
+   long samprate;
+   int bits;
+   int framebytes;
+   int type;
+}
+DEC_INFO;
+
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+   int head_info(unsigned char *buf, unsigned int n, MPEG_HEAD * h);
+   int head_info2(unsigned char *buf,
+	   unsigned int n, MPEG_HEAD * h, int *br);
+	int head_info3(unsigned char *buf, unsigned int n, MPEG_HEAD *h, int*br, unsigned int *searchForward);
+/* head_info returns framebytes > 0 for success */
+/* audio_decode_init returns 1 for success, 0 for fail */
+/* audio_decode returns in_bytes = 0 on sync loss */
+
+   int audio_decode_init(MPEG_HEAD * h, int framebytes_arg,
+		   int reduction_code, int transform_code, int convert_code,
+			 int freq_limit);
+   void audio_decode_info(DEC_INFO * info);
+   IN_OUT audio_decode(unsigned char *bs, short *pcm, unsigned char *pNextByteAfterData);
+
+   int audio_decode8_init(MPEG_HEAD * h, int framebytes_arg,
+		   int reduction_code, int transform_code, int convert_code,
+			  int freq_limit);
+   void audio_decode8_info(DEC_INFO * info);
+   IN_OUT audio_decode8(unsigned char *bs, short *pcmbuf);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#pragma warning(disable:4711)	// function 'xxxx' selected for automatic inline expansion
+
+#endif	// #ifndef MHEAD_H
+
diff --git a/code/mp3code/mp3struct.h b/code/mp3code/mp3struct.h
new file mode 100644
index 0000000..efd3729
--- /dev/null
+++ b/code/mp3code/mp3struct.h
@@ -0,0 +1,141 @@
+// Filename:	mp3struct.h
+//
+// this file is my struct to gather all loose MP3 global vars into one struct so we can do multiple-stream decompression
+//
+
+#ifndef MP3STRUCT_H
+#define MP3STRUCT_H
+
+#pragma warning (disable : 4201 )	// nonstandard extension used : nameless struct/union
+
+#include "small_header.h"	// for SAMPLE and IN_OUT
+
+typedef void (*SBT_FUNCTION) (float *sample, short *pcm, int n);
+typedef void (*XFORM_FUNCTION) (void *pcm, int igr);
+typedef IN_OUT(*DECODE_FUNCTION) (unsigned char *bs, unsigned char *pcm);
+
+typedef struct
+{
+	union
+	{
+		struct
+		{
+			SBT_FUNCTION sbt;	
+
+			float	cs_factor[3][64];	// 768 bytes
+
+			int		nbat[4];
+			int		bat[4][16];
+			int		max_sb;		
+			int		stereo_sb;
+			int		bit_skip;
+
+			float*	cs_factorL1;
+			int		nbatL1;
+
+		};//L1_2;
+
+		struct 
+		{
+			SBT_FUNCTION sbt_L3;
+			XFORM_FUNCTION Xform;
+			DECODE_FUNCTION decode_function;
+
+			SAMPLE	sample[2][2][576];		// if this isn't kept per stream then the decode breaks up
+
+		// the 4k version of these 2 seems to work for everything, but I'm reverting to original 8k for safety jic.
+		//
+		#define NBUF (8*1024)
+		#define BUF_TRIGGER (NBUF-1500)
+//		#define NBUF (4096)	// 2048 works for all except 133+ kbps VBR files, 4096 copes with these
+//		#define BUF_TRIGGER ((NBUF/4)*3)
+
+			unsigned char buf[NBUF];
+			int		buf_ptr0;
+			int		buf_ptr1;
+			int		main_pos_bit;
+
+
+			int		band_limit_nsb;
+			int			nBand[2][22];		/* [long/short][cb] */
+			int			sfBandIndex[2][22];		/* [long/short][cb] */
+			int			half_outbytes;
+			int			crcbytes;
+			int			nchan;
+			int			ms_mode;
+			int			is_mode;
+			unsigned int zero_level_pcm;
+			int			mpeg25_flag;
+			int			band_limit;
+			int			band_limit21;
+			int			band_limit12;
+			int			gain_adjust;
+			int			ncbl_mixed;
+		};//L3;
+	};
+	// from csbt.c...
+	//
+	// if this isn't kept per stream then the decode breaks up
+	signed int	vb_ptr;			// 
+	signed int	vb2_ptr;		// 
+	float		vbuf[512];		//
+	float		vbuf2[512];		// this can be lost if we stick to mono samples
+
+	// L3 only...
+	//
+	int			sr_index;	// L3 only (99%)
+	int			id;
+
+	// any type...
+	//
+	int			outvalues;
+	int			outbytes;
+	int			framebytes;
+	int			pad;
+	int			nsb_limit;	
+
+	// stuff added now that the game uses streaming MP3s...
+	//
+	byte		*pbSourceData;			// a useful dup ptr only, this whole struct will be owned by an sfx_t struct that has the actual data ptr field
+	int			iSourceBytesRemaining;
+	int			iSourceReadIndex;
+	int			iSourceFrameBytes;
+#ifdef _DEBUG
+	int			iSourceFrameCounter;	// not really important
+#endif
+	int			iBytesDecodedTotal;
+	int			iBytesDecodedThisPacket;// not sure how useful this will be, it's only per-frame, so will always be full frame size (eg 2304 or below for mono) except possibly for the last frame?
+
+	int			iRewind_FinalReductionCode;
+	int			iRewind_FinalConvertCode;
+	int			iRewind_SourceBytesRemaining;
+	int			iRewind_SourceReadIndex;
+	byte		bDecodeBuffer[2304*2];	// *2 to allow for stereo now
+	int			iCopyOffset;			// used for painting to DMA-feeder, since 2304 won't match the size it wants
+
+	// some new stuff added for dynamic music, to allow "how many seconds left to play" queries...
+	//
+	// ( m_lengthInSeconds = ((iUnpackedDataLength / iRate) / iChannels) / iWidth; )
+	//
+	// Note that these fields are only valid/initialised if MP3Stream_InitPlayingTimeFields() was called.
+	//	If not, this->iTimeQuery_UnpackedLength will be zero.
+	//
+	int			iTimeQuery_UnpackedLength;	
+	int			iTimeQuery_SampleRate;
+	int			iTimeQuery_Channels;
+	int			iTimeQuery_Width;
+
+} MP3STREAM, *LP_MP3STREAM;
+
+#define MP3STUFF_KNOWN
+
+extern LP_MP3STREAM pMP3Stream;
+extern int bFastEstimateOnly;
+
+#pragma warning (default : 4201 )	// nonstandard extension used : nameless struct/union
+#pragma warning (disable : 4711 )	// function 'xxxx' selected for automatic inline expansion
+
+#endif	// #ifndef MP3STRUCT_H
+
+////////////////// eof /////////////////////
+
diff --git a/code/mp3code/msis.c b/code/mp3code/msis.c
new file mode 100644
index 0000000..6e7ef24
--- /dev/null
+++ b/code/mp3code/msis.c
@@ -0,0 +1,296 @@
+/*____________________________________________________________________________
+	
+	FreeAmp - The Free MP3 Player
+
+        MP3 Decoder originally Copyright (C) 1995-1997 Xing Technology
+        Corp.  http://www.xingtech.com
+
+	Portions Copyright (C) 1998-1999 EMusic.com
+
+	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., 675 Mass Ave, Cambridge, MA 02139, USA.
+	
+	$Id: msis.c,v 1.4 1999/10/19 07:13:09 elrod Exp $
+____________________________________________________________________________*/
+
+/****  msis.c  ***************************************************
+  Layer III  
+ antialias, ms and is stereo precessing
+
+**** is_process assumes never switch 
+      from short to long in is region *****
+     
+is_process does ms or stereo in "forbidded sf regions"
+    //ms_mode = 0 
+    lr[0][i][0] = 1.0f;
+    lr[0][i][1] = 0.0f;
+    // ms_mode = 1, in is bands is routine does ms processing 
+    lr[1][i][0] = 1.0f;
+    lr[1][i][1] = 1.0f;
+
+******************************************************************/
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <float.h>
+#include <math.h>
+#include "L3.h"
+
+#include "mp3struct.h"
+
+typedef float ARRAY2[2];
+typedef float ARRAY8_2[8][2];
+
+float csa[8][2];		/* antialias */		// effectively constant
+
+/* pMP3Stream->nBand[0] = long, pMP3Stream->nBand[1] = short */
+////@@@@extern int pMP3Stream->nBand[2][22];
+////@@@@extern int pMP3Stream->sfBandIndex[2][22];	/* [long/short][cb] */
+
+/* intensity stereo */
+/* if ms mode quant pre-scales all values by 1.0/sqrt(2.0) ms_mode in table
+   compensates   */
+static float lr[2][8][2];	/* [ms_mode 0/1][sf][left/right]  */	// effectively constant
+
+
+/* intensity stereo MPEG2 */
+/* lr2[intensity_scale][ms_mode][sflen_offset+sf][left/right] */
+typedef float ARRAY2_64_2[2][64][2];
+typedef float ARRAY64_2[64][2];
+static float lr2[2][2][64][2];		// effectively constant
+
+
+/*===============================================================*/
+ARRAY2 *alias_init_addr()
+{
+   return csa;
+}
+/*-----------------------------------------------------------*/
+ARRAY8_2 *msis_init_addr()
+{
+/*-------
+pi = 4.0*atan(1.0);
+t = pi/12.0;
+for(i=0;i<7;i++) {
+    s = sin(i*t);
+    c = cos(i*t);
+    // ms_mode = 0 
+    lr[0][i][0] = (float)(s/(s+c));
+    lr[0][i][1] = (float)(c/(s+c));
+    // ms_mode = 1 
+    lr[1][i][0] = (float)(sqrt(2.0)*(s/(s+c)));
+    lr[1][i][1] = (float)(sqrt(2.0)*(c/(s+c)));
+}
+//sf = 7 
+//ms_mode = 0 
+lr[0][i][0] = 1.0f;
+lr[0][i][1] = 0.0f;
+// ms_mode = 1, in is bands is routine does ms processing 
+lr[1][i][0] = 1.0f;
+lr[1][i][1] = 1.0f;
+------------*/
+
+   return lr;
+}
+/*-------------------------------------------------------------*/
+ARRAY2_64_2 *msis_init_addr_MPEG2()
+{
+   return lr2;
+}
+/*===============================================================*/
+void antialias(float x[], int n)
+{
+   int i, k;
+   float a, b;
+
+   for (k = 0; k < n; k++)
+   {
+      for (i = 0; i < 8; i++)
+      {
+	 a = x[17 - i];
+	 b = x[18 + i];
+	 x[17 - i] = a * csa[i][0] - b * csa[i][1];
+	 x[18 + i] = b * csa[i][0] + a * csa[i][1];
+      }
+      x += 18;
+   }
+}
+/*===============================================================*/
+void ms_process(float x[][1152], int n)		/* sum-difference stereo */
+{
+   int i;
+   float xl, xr;
+
+/*-- note: sqrt(2) done scaling by dequant ---*/
+   for (i = 0; i < n; i++)
+   {
+      xl = x[0][i] + x[1][i];
+      xr = x[0][i] - x[1][i];
+      x[0][i] = xl;
+      x[1][i] = xr;
+   }
+   return;
+}
+/*===============================================================*/
+void is_process_MPEG1(float x[][1152],	/* intensity stereo */
+		      SCALEFACT * sf,
+		      CB_INFO cb_info[2],	/* [ch] */
+		      int nsamp, int ms_mode)
+{
+   int i, j, n, cb, w;
+   float fl, fr;
+   int m;
+   int isf;
+   float fls[3], frs[3];
+   int cb0;
+
+
+   cb0 = cb_info[1].cbmax;	/* start at end of right */
+   i = pMP3Stream->sfBandIndex[cb_info[1].cbtype][cb0];
+   cb0++;
+   m = nsamp - i;		/* process to len of left */
+
+   if (cb_info[1].cbtype)
+      goto short_blocks;
+/*------------------------*/
+/* long_blocks: */
+   for (cb = cb0; cb < 21; cb++)
+   {
+      isf = sf->l[cb];
+      n = pMP3Stream->nBand[0][cb];
+      fl = lr[ms_mode][isf][0];
+      fr = lr[ms_mode][isf][1];
+      for (j = 0; j < n; j++, i++)
+      {
+	 if (--m < 0)
+	    goto exit;
+	 x[1][i] = fr * x[0][i];
+	 x[0][i] = fl * x[0][i];
+      }
+   }
+   return;
+/*------------------------*/
+ short_blocks:
+   for (cb = cb0; cb < 12; cb++)
+   {
+      for (w = 0; w < 3; w++)
+      {
+	 isf = sf->s[w][cb];
+	 fls[w] = lr[ms_mode][isf][0];
+	 frs[w] = lr[ms_mode][isf][1];
+      }
+      n = pMP3Stream->nBand[1][cb];
+      for (j = 0; j < n; j++)
+      {
+	 m -= 3;
+	 if (m < 0)
+	    goto exit;
+	 x[1][i] = frs[0] * x[0][i];
+	 x[0][i] = fls[0] * x[0][i];
+	 x[1][1 + i] = frs[1] * x[0][1 + i];
+	 x[0][1 + i] = fls[1] * x[0][1 + i];
+	 x[1][2 + i] = frs[2] * x[0][2 + i];
+	 x[0][2 + i] = fls[2] * x[0][2 + i];
+	 i += 3;
+      }
+   }
+
+ exit:
+   return;
+}
+/*===============================================================*/
+void is_process_MPEG2(float x[][1152],	/* intensity stereo */
+		      SCALEFACT * sf,
+		      CB_INFO cb_info[2],	/* [ch] */
+		      IS_SF_INFO * is_sf_info,
+		      int nsamp, int ms_mode)
+{
+   int i, j, k, n, cb, w;
+   float fl, fr;
+   int m;
+   int isf;
+   int il[21];
+   int tmp;
+   int r;
+   ARRAY2 *lr;
+   int cb0, cb1;
+
+   lr = lr2[is_sf_info->intensity_scale][ms_mode];
+
+   if (cb_info[1].cbtype)
+      goto short_blocks;
+
+/*------------------------*/
+/* long_blocks: */
+   cb0 = cb_info[1].cbmax;	/* start at end of right */
+   i = pMP3Stream->sfBandIndex[0][cb0];
+   m = nsamp - i;		/* process to len of left */
+/* gen sf info */
+   for (k = r = 0; r < 3; r++)
+   {
+      tmp = (1 << is_sf_info->slen[r]) - 1;
+      for (j = 0; j < is_sf_info->nr[r]; j++, k++)
+	 il[k] = tmp;
+   }
+   for (cb = cb0 + 1; cb < 21; cb++)
+   {
+      isf = il[cb] + sf->l[cb];
+      fl = lr[isf][0];
+      fr = lr[isf][1];
+      n = pMP3Stream->nBand[0][cb];
+      for (j = 0; j < n; j++, i++)
+      {
+	 if (--m < 0)
+	    goto exit;
+	 x[1][i] = fr * x[0][i];
+	 x[0][i] = fl * x[0][i];
+      }
+   }
+   return;
+/*------------------------*/
+ short_blocks:
+
+   for (k = r = 0; r < 3; r++)
+   {
+      tmp = (1 << is_sf_info->slen[r]) - 1;
+      for (j = 0; j < is_sf_info->nr[r]; j++, k++)
+	 il[k] = tmp;
+   }
+
+   for (w = 0; w < 3; w++)
+   {
+      cb0 = cb_info[1].cbmax_s[w];	/* start at end of right */
+      i = pMP3Stream->sfBandIndex[1][cb0] + w;
+      cb1 = cb_info[0].cbmax_s[w];	/* process to end of left */
+
+      for (cb = cb0 + 1; cb <= cb1; cb++)
+      {
+	 isf = il[cb] + sf->s[w][cb];
+	 fl = lr[isf][0];
+	 fr = lr[isf][1];
+	 n = pMP3Stream->nBand[1][cb];
+	 for (j = 0; j < n; j++)
+	 {
+	    x[1][i] = fr * x[0][i];
+	    x[0][i] = fl * x[0][i];
+	    i += 3;
+	 }
+      }
+
+   }
+
+ exit:
+   return;
+}
+/*===============================================================*/
diff --git a/code/mp3code/port.h b/code/mp3code/port.h
new file mode 100644
index 0000000..78ad088
--- /dev/null
+++ b/code/mp3code/port.h
@@ -0,0 +1,80 @@
+/*____________________________________________________________________________
+	
+	FreeAmp - The Free MP3 Player
+
+        MP3 Decoder originally Copyright (C) 1995-1997 Xing Technology
+        Corp.  http://www.xingtech.com
+
+	Portions Copyright (C) 1998-1999 EMusic.com
+
+	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., 675 Mass Ave, Cambridge, MA 02139, USA.
+	
+	$Id: port.h,v 1.2 1999/10/19 07:13:08 elrod Exp $
+____________________________________________________________________________*/
+
+#ifndef O_BINARY
+#define O_BINARY 0
+#endif
+
+
+/*--- no kb function unless DOS ---*/
+
+#ifndef KB_OK
+#ifdef __MSDOS__
+#define KB_OK
+#endif
+#ifdef _CONSOLE
+#define KB_OK
+#endif
+#endif
+
+/*-- no pcm conversion to wave required 
+ if short = 16 bits and little endian ---*/
+
+/* mods 1/9/97 LITTLE_SHORT16 detect */
+
+#ifndef LITTLE_SHORT16
+  #ifdef __MSDOS__
+    #undef LITTLE_SHORT16
+    #define LITTLE_SHORT16
+  #endif
+  #ifdef WIN32
+    #undef LITTLE_SHORT16
+    #define LITTLE_SHORT16
+  #endif
+  #ifdef _M_IX86
+    #undef LITTLE_SHORT16
+    #define LITTLE_SHORT16
+  #endif
+#endif
+
+
+// JDW //
+//#ifdef LITTLE_SHORT16
+//#define cvt_to_wave_init(a)
+//#define cvt_to_wave(a, b)  b
+//#else
+//void cvt_to_wave_init(int bits);
+//unsigned int cvt_to_wave(void *a, unsigned int b);
+//
+//#endif
+#ifdef LITTLE_SHORT16
+#define cvt_to_wave_init(a)
+#define cvt_to_wave(a, b) b
+#else
+void cvt_to_wave_init(int);
+unsigned int cvt_to_wave(unsigned char *,unsigned int);
+#endif
+
diff --git a/code/mp3code/small_header.h b/code/mp3code/small_header.h
new file mode 100644
index 0000000..bfbe7cf
--- /dev/null
+++ b/code/mp3code/small_header.h
@@ -0,0 +1,34 @@
+// Filename:-	small_header.h
+//
+// This file is just used so I can isolate a few small structs from various horrible MP3 header files without
+//	externalising code protos etc. This can now be included by both main game sound code (through sfx_t) and MP3 C code.
+//
+
+#ifndef SMALL_HEADER_H
+#define SMALL_HEADER_H
+
+
+typedef union
+{
+   int s;
+   float x;
+}
+SAMPLE;
+
+typedef struct
+{
+   int in_bytes;
+   int out_bytes;
+}
+IN_OUT;
+
+#ifdef WIN32 // Damn linux gcc isn't detecting byte as defined
+#ifndef byte
+typedef unsigned char byte;
+#endif
+#endif
+
+#endif	// #ifndef SMALL_HEADER_H
+
+/////////////// eof ////////////
+
diff --git a/code/mp3code/tableawd.h b/code/mp3code/tableawd.h
new file mode 100644
index 0000000..4f08dd7
--- /dev/null
+++ b/code/mp3code/tableawd.h
@@ -0,0 +1,93 @@
+/*____________________________________________________________________________
+	
+	FreeAmp - The Free MP3 Player
+
+        MP3 Decoder originally Copyright (C) 1995-1997 Xing Technology
+        Corp.  http://www.xingtech.com
+
+	Portions Copyright (C) 1998 EMusic.com
+
+	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., 675 Mass Ave, Cambridge, MA 02139, USA.
+	
+	$Id: tableawd.h,v 1.2 1999/10/19 07:13:08 elrod Exp $
+____________________________________________________________________________*/
+
+/* decoder analysis window gen by dinit.c (asm version table gen) */
+0.000000000f, 0.000442505f, -0.003250122f, 0.007003784f,
+-0.031082151f, 0.078628540f, -0.100311279f, 0.572036743f,
+-1.144989014f, -0.572036743f, -0.100311279f, -0.078628540f,
+-0.031082151f, -0.007003784f, -0.003250122f, -0.000442505f,
+0.000015259f, 0.000473022f, -0.003326416f, 0.007919312f,
+-0.030517576f, 0.084182739f, -0.090927124f, 0.600219727f,
+-1.144287109f, -0.543823242f, -0.108856201f, -0.073059082f,
+-0.031478882f, -0.006118774f, -0.003173828f, -0.000396729f,
+0.000015259f, 0.000534058f, -0.003387451f, 0.008865356f,
+-0.029785154f, 0.089706421f, -0.080688477f, 0.628295898f,
+-1.142211914f, -0.515609741f, -0.116577141f, -0.067520142f,
+-0.031738281f, -0.005294800f, -0.003082275f, -0.000366211f,
+0.000015259f, 0.000579834f, -0.003433228f, 0.009841919f,
+-0.028884888f, 0.095169067f, -0.069595337f, 0.656219482f,
+-1.138763428f, -0.487472534f, -0.123474121f, -0.061996460f,
+-0.031845093f, -0.004486084f, -0.002990723f, -0.000320435f,
+0.000015259f, 0.000625610f, -0.003463745f, 0.010848999f,
+-0.027801514f, 0.100540161f, -0.057617184f, 0.683914185f,
+-1.133926392f, -0.459472656f, -0.129577637f, -0.056533810f,
+-0.031814575f, -0.003723145f, -0.002899170f, -0.000289917f,
+0.000015259f, 0.000686646f, -0.003479004f, 0.011886597f,
+-0.026535034f, 0.105819702f, -0.044784546f, 0.711318970f,
+-1.127746582f, -0.431655884f, -0.134887695f, -0.051132202f,
+-0.031661987f, -0.003005981f, -0.002792358f, -0.000259399f,
+0.000015259f, 0.000747681f, -0.003479004f, 0.012939452f,
+-0.025085449f, 0.110946655f, -0.031082151f, 0.738372803f,
+-1.120223999f, -0.404083252f, -0.139450073f, -0.045837402f,
+-0.031387329f, -0.002334595f, -0.002685547f, -0.000244141f,
+0.000030518f, 0.000808716f, -0.003463745f, 0.014022826f,
+-0.023422241f, 0.115921021f, -0.016510010f, 0.765029907f,
+-1.111373901f, -0.376800537f, -0.143264771f, -0.040634155f,
+-0.031005858f, -0.001693726f, -0.002578735f, -0.000213623f,
+0.000030518f, 0.000885010f, -0.003417969f, 0.015121460f,
+-0.021575928f, 0.120697014f, -0.001068115f, 0.791213989f,
+-1.101211548f, -0.349868774f, -0.146362305f, -0.035552979f,
+-0.030532837f, -0.001098633f, -0.002456665f, -0.000198364f,
+0.000030518f, 0.000961304f, -0.003372192f, 0.016235352f,
+-0.019531250f, 0.125259399f, 0.015228271f, 0.816864014f,
+-1.089782715f, -0.323318481f, -0.148773193f, -0.030609131f,
+-0.029937742f, -0.000549316f, -0.002349854f, -0.000167847f,
+0.000030518f, 0.001037598f, -0.003280640f, 0.017349243f,
+-0.017257690f, 0.129562378f, 0.032379150f, 0.841949463f,
+-1.077117920f, -0.297210693f, -0.150497437f, -0.025817871f,
+-0.029281614f, -0.000030518f, -0.002243042f, -0.000152588f,
+0.000045776f, 0.001113892f, -0.003173828f, 0.018463135f,
+-0.014801024f, 0.133590698f, 0.050354004f, 0.866363525f,
+-1.063217163f, -0.271591187f, -0.151596069f, -0.021179199f,
+-0.028533936f, 0.000442505f, -0.002120972f, -0.000137329f,
+0.000045776f, 0.001205444f, -0.003051758f, 0.019577026f,
+-0.012115479f, 0.137298584f, 0.069168091f, 0.890090942f,
+-1.048156738f, -0.246505737f, -0.152069092f, -0.016708374f,
+-0.027725220f, 0.000869751f, -0.002014160f, -0.000122070f,
+0.000061035f, 0.001296997f, -0.002883911f, 0.020690918f,
+-0.009231566f, 0.140670776f, 0.088775635f, 0.913055420f,
+-1.031936646f, -0.221984863f, -0.151962280f, -0.012420653f,
+-0.026840210f, 0.001266479f, -0.001907349f, -0.000106812f,
+0.000061035f, 0.001388550f, -0.002700806f, 0.021789551f,
+-0.006134033f, 0.143676758f, 0.109161377f, 0.935195923f,
+-1.014617920f, -0.198059082f, -0.151306152f, -0.008316040f,
+-0.025909424f, 0.001617432f, -0.001785278f, -0.000106812f,
+0.000076294f, 0.001480103f, -0.002487183f, 0.022857666f,
+-0.002822876f, 0.146255493f, 0.130310059f, 0.956481934f,
+-0.996246338f, -0.174789429f, -0.150115967f, -0.004394531f,
+-0.024932859f, 0.001937866f, -0.001693726f, -0.000091553f,
+-0.001586914f, -0.023910521f, -0.148422241f, -0.976852417f,
+0.152206421f, 0.000686646f, -0.002227783f, 0.000076294f,
diff --git a/code/mp3code/towave.c b/code/mp3code/towave.c
new file mode 100644
index 0000000..58f6ac1
--- /dev/null
+++ b/code/mp3code/towave.c
@@ -0,0 +1,766 @@
+/*____________________________________________________________________________
+	
+	FreeAmp - The Free MP3 Player
+
+        MP3 Decoder originally Copyright (C) 1995-1997 Xing Technology
+        Corp.  http://www.xingtech.com
+
+	Portions Copyright (C) 1998-1999 EMusic.com
+
+	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., 675 Mass Ave, Cambridge, MA 02139, USA.
+	
+	$Id: towave.c,v 1.3 1999/10/19 07:13:09 elrod Exp $
+____________________________________________________________________________*/
+
+/* ------------------------------------------------------------------------
+
+      NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE
+
+        This file exists for reference only. It is not actually used
+        in the FreeAmp project. There is no need to mess with this 
+        file. There is no need to flatten the beavers, either.
+
+      NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE
+
+/*---- towave.c --------------------------------------------
+  32 bit version only
+
+decode mpeg Layer I/II/III file using portable ANSI C decoder,
+output to pcm wave file.
+
+mod 8/19/98 decode 22 sf bands
+
+mod 5/14/98  allow mpeg25 (dec8 not supported for mpeg25 samp rate)
+
+mod 3/4/98 bs_trigger  bs_bufbytes  made signed, unsigned may 
+            not terminate properly.  Also extra test in bs_fill.
+
+mod 8/6/96 add 8 bit output to standard decoder
+
+ver 1.4 mods 7/18/96 32 bit and add asm option
+
+mods 6/29/95  allow MS wave file for u-law.  bugfix u-law table dec8.c
+
+mods 2/95 add sample rate reduction, freq_limit and conversions.
+          add _decode8 for 8Ks output, 16bit 8bit, u-law output.
+          add additional control parameters to init.
+          add _info function
+
+mod 5/12/95 add quick window cwinq.c
+
+mod 5/19/95 change from stream io to handle io
+
+mod 11/16/95 add Layer I
+
+mod 1/5/95   integer overflow mod iup.c
+
+ver 1.3
+mod 2/5/96   portability mods
+             drop Tom and Gloria pcm file types
+
+ver 2.0
+mod 1/7/97   Layer 3 (float mpeg-1 only)
+    2/6/97   Layer 3 MPEG-2
+
+ver 3.01     Layer III bugfix crc problem 8/18/97
+ver 3.02     Layer III fix wannabe.mp3 problem 10/9/97
+ver 3.03     allow mpeg 2.5  5/14/98
+  
+Decoder functions for _decode8 are defined in dec8.c.  Useage
+is same as regular decoder.
+
+Towave illustrates use of decoder.  Towave converts
+mpeg audio files to 16 bit (short) pcm.  Default pcm file
+format is wave. Other formats can be accommodated by
+adding alternative write_pcm_header and write_pcm_tailer
+functions.  The functions kbhit and getch used in towave.c
+may not port to other systems.
+
+The decoder handles all mpeg1 and mpeg2 Layer I/II  bitstreams.  
+
+For compatability with the asm decoder and future C versions,
+source code users are discouraged from making modifications
+to the decoder proper.  MS Windows applications can use wrapper
+functions in a separate module if decoder functions need to
+be exported.
+
+NOTE additional control parameters.
+
+mod 8/6/96 standard decoder adds 8 bit output
+
+decode8 (8Ks output) convert_code:
+   convert_code = 4*bit_code + chan_code
+       bit_code:   1 = 16 bit linear pcm
+                   2 =  8 bit (unsigned) linear pcm
+                   3 = u-law (8 bits unsigned)
+       chan_code:  0 = convert two chan to mono
+                   1 = convert two chan to mono
+                   2 = convert two chan to left chan
+                   3 = convert two chan to right chan
+
+decode (standard decoder) convert_code:
+             0 = two chan output
+             1 = convert two chan to mono
+             2 = convert two chan to left chan
+             3 = convert two chan to right chan
+     or with 8 = 8 bit output 
+          (other bits ignored)
+
+decode (standard decoder) reduction_code:
+             0 = full sample rate output
+             1 = half rate
+             2 = quarter rate
+
+-----------------------------------------------------------*/
+#include <stdlib.h>
+#include <stdio.h>
+#include <float.h>
+#include <math.h>
+#include <string.h>
+#ifdef WIN32
+#include <io.h>
+#endif
+#include <fcntl.h>		/* file open flags */
+#include <sys/types.h>		/* someone wants for port */
+#include <sys/stat.h>		/* forward slash for portability */
+#include "mhead.h"		/* mpeg header structure, decode protos */
+
+#include "port.h"
+
+// JDW
+#ifdef __linux__
+#include <sys/ioctl.h>
+#include <sys/soundcard.h>
+#include <fcntl.h>
+#include <errno.h>
+#endif
+// JDW
+
+#include "mp3struct.h"
+#include <assert.h>
+
+
+#ifndef byte
+typedef unsigned char byte;
+#endif
+
+
+
+typedef struct id3v1_1 {
+    char id[3];
+    char title[30];		// <file basename>
+    char artist[30];	// "Raven Software"
+    char album[30];		// "#UNCOMP %d"		// needed
+    char year[4];		// "2000"
+    char comment[28];	// "#MAXVOL %g"		// needed
+    char zero;
+    char track;
+    char genre;
+} id3v1_1;	// 128 bytes in size
+
+id3v1_1 *gpTAG;
+#define BYTESREMAINING_ACCOUNT_FOR_REAR_TAG(_pvData, _iBytesRemaining)								\
+																									\
+	/* account for trailing ID3 tag in _iBytesRemaining */											\
+	gpTAG = (id3v1_1*) (((byte *)_pvData + _iBytesRemaining)-sizeof(id3v1_1));	/* sizeof = 128	*/	\
+	if (!strncmp(gpTAG->id, "TAG", 3))																\
+	{																								\
+		_iBytesRemaining -= sizeof(id3v1_1);														\
+	}
+
+
+
+
+
+/********  pcm buffer ********/
+
+#define PCM_BUFBYTES  60000U	// more than enough to cover the largest that one packet will ever expand to
+char PCM_Buffer[PCM_BUFBYTES];	// better off being declared, so we don't do mallocs in this module (MAC reasons)
+
+   typedef struct
+   {
+      int (*decode_init) (MPEG_HEAD * h, int framebytes_arg,
+			  int reduction_code, int transform_code,
+			  int convert_code, int freq_limit);
+      void (*decode_info) (DEC_INFO * info);
+      IN_OUT(*decode) (unsigned char *bs, short *pcm, unsigned char *pNextByteAfterData);
+   }
+   AUDIO;
+   
+#if 0
+   // fuck this...
+   static AUDIO audio_table[2][2] =
+   {
+      {
+	 {audio_decode_init, audio_decode_info, audio_decode},
+	 {audio_decode8_init, audio_decode8_info, audio_decode8},
+      },
+      {
+	 {i_audio_decode_init, i_audio_decode_info, i_audio_decode},
+	 {audio_decode8_init, audio_decode8_info, audio_decode8},
+      }
+   };
+#else
+   static AUDIO audio_table[2][2] =
+   {
+      {
+		{audio_decode_init, audio_decode_info, audio_decode},
+		{audio_decode_init, audio_decode_info, audio_decode},
+      },
+      {
+		{audio_decode_init, audio_decode_info, audio_decode},
+		{audio_decode_init, audio_decode_info, audio_decode},			
+      }
+   };
+#endif
+
+   static const AUDIO audio = {audio_decode_init, audio_decode_info, audio_decode};	//audio_table[0][0];
+
+
+// Do NOT change these, ever!!!!!!!!!!!!!!!!!!
+//
+const int reduction_code	= 0;		// unpack at full sample rate output
+const int convert_code_mono	= 1;		
+const int convert_code_stereo = 0;
+const int freq_limit		= 24000;	// no idea what this is about, but it's always this value so...
+
+// the entire decode mechanism uses this now...
+//
+MP3STREAM _MP3Stream;
+LP_MP3STREAM pMP3Stream = &_MP3Stream;
+int bFastEstimateOnly = 0;	// MUST DEFAULT TO THIS VALUE!!!!!!!!!
+
+
+// char *return is NZ for any errors (no trailing CR!)
+//
+char *C_MP3_IsValid(void *pvData, int iDataLen, int bStereoDesired)
+{
+//	char sTemp[1024];	/////////////////////////////////////////////////
+	unsigned int iRealDataStart;
+	MPEG_HEAD head;
+	DEC_INFO  decinfo;
+
+	int iBitRate;
+	int iFrameBytes;
+
+#ifdef _DEBUG
+//	int iIgnoreThisForNowIJustNeedItToBreakpointOnToReadAValue = sizeof(MP3STREAM);
+//	iBitRate = iIgnoreThisForNowIJustNeedItToBreakpointOnToReadAValue;	// get rid of unused-variable warning
+#endif
+
+	memset(pMP3Stream,0,sizeof(*pMP3Stream));
+
+	iFrameBytes = head_info3( pvData, iDataLen/2, &head, &iBitRate, &iRealDataStart);
+	if (iFrameBytes == 0)
+	{
+		return "MP3ERR: Bad or unsupported file!";
+	}
+
+	// check for files with bad frame unpack sizes (that would crash the game), or stereo files.
+	//
+	// although the decoder can convert stereo to mono (apparently), we want to know about stereo files
+	//	because they're a waste of source space... (all FX are mono, and moved via panning)
+	//
+	if (head.mode != 3 && !bStereoDesired && iDataLen > 98000)	//3 seems to mean mono
+	{// we'll allow it for small files even if stereo
+		if ( iDataLen != 1050024 ) //fixme, make cinematic_1 play as music instead
+		{	
+			return "MP3ERR: Sound file is stereo!";
+		}
+	}		
+	if (audio.decode_init(&head, iFrameBytes, reduction_code, iRealDataStart, bStereoDesired?convert_code_stereo:convert_code_mono, freq_limit))
+	{
+		if (bStereoDesired)
+		{
+			if (pMP3Stream->outbytes > 4608)
+			{
+				return "MP3ERR: Source file has output packet size > 2304 (*2 for stereo) bytes!";
+			}
+		}		
+		else
+		{
+			if (pMP3Stream->outbytes > 2304)
+			{
+				return "MP3ERR: Source file has output packet size > 2304 bytes!";
+			}
+		}		
+
+		audio.decode_info(&decinfo);
+
+		if (decinfo.bits != 16)
+		{
+			return "MP3ERR: Source file is not 16bit!";	// will this ever happen? oh well...
+		}
+
+		if (decinfo.samprate != 44100)
+		{
+			return "MP3ERR: Source file is not sampled @ 44100!";
+		}
+		if (bStereoDesired && decinfo.channels != 2)
+		{
+			return "MP3ERR: Source file is not stereo!";	// sod it, I'm going to count this as an error now
+		}		
+
+	}
+	else
+	{
+		return "MP3ERR: Decoder failed to initialise";
+	}
+
+	// file seems to be valid...
+	//
+	return NULL;
+}
+
+
+
+// char *return is NZ for any errors (no trailing CR!)
+//
+char* C_MP3_GetHeaderData(void *pvData, int iDataLen, int *piRate, int *piWidth, int *piChannels, int bStereoDesired)
+{
+	unsigned int iRealDataStart;
+	MPEG_HEAD head;
+	DEC_INFO  decinfo;
+
+	int iBitRate;
+	int iFrameBytes;
+
+	memset(pMP3Stream,0,sizeof(*pMP3Stream));
+
+	iFrameBytes = head_info3( pvData, iDataLen/2, &head, &iBitRate, &iRealDataStart);
+	if (iFrameBytes == 0)
+	{
+		return "MP3ERR: Bad or unsupported file!";
+	}
+
+	if (audio.decode_init(&head, iFrameBytes, reduction_code, iRealDataStart, bStereoDesired?convert_code_stereo:convert_code_mono, freq_limit))
+	{
+		audio.decode_info(&decinfo);
+
+		*piRate		= decinfo.samprate;	// rate (eg 22050, 44100 etc)
+		*piWidth	= decinfo.bits/8;	// 1 for 8bit, 2 for 16 bit
+		*piChannels	= decinfo.channels;	// 1 for mono, 2 for stereo
+	}
+	else
+	{
+		return "MP3ERR: Decoder failed to initialise";
+	}
+
+	// everything ok...
+	//
+	return NULL;
+}
+
+
+
+
+// this duplicates work done in C_MP3_IsValid(), but it avoids global structs, and means that you can call this anytime
+//	if you just want info for some reason
+//
+// ( size is now workd out just by decompressing each packet header, not the whole stream. MUCH faster :-)
+//
+// char *return is NZ for any errors (no trailing CR!)
+//
+char *C_MP3_GetUnpackedSize(void *pvData, int iSourceBytesRemaining, int *piUnpackedSize, int bStereoDesired )
+{
+	int iReadLimit;
+	unsigned int iRealDataStart;
+	MPEG_HEAD head;
+	int iBitRate;
+
+	char *pPCM_Buffer = PCM_Buffer;
+	char *psReturn = NULL;
+//	int  iSourceReadIndex = 0;
+	int	 iDestWriteIndex = 0;
+
+	int iFrameBytes;
+	int iFrameCounter;
+
+	DEC_INFO decinfo;
+	IN_OUT	 x;
+	
+	memset(pMP3Stream,0,sizeof(*pMP3Stream));
+
+#define iSourceReadIndex iRealDataStart
+
+//	iFrameBytes = head_info2( pvData, 0, &head, &iBitRate);
+	iFrameBytes = head_info3( pvData, iSourceBytesRemaining/2, &head, &iBitRate, &iRealDataStart);
+	
+	BYTESREMAINING_ACCOUNT_FOR_REAR_TAG(pvData, iSourceBytesRemaining)
+	iSourceBytesRemaining -= iRealDataStart;
+
+	iReadLimit = iSourceReadIndex + iSourceBytesRemaining;
+
+	if (iFrameBytes)
+	{
+		//pPCM_Buffer = Z_Malloc(PCM_BUFBYTES);
+
+		//if (pPCM_Buffer)
+		{
+			// init decoder...
+
+			if (audio.decode_init(&head, iFrameBytes, reduction_code, iRealDataStart, bStereoDesired?convert_code_stereo:convert_code_mono, freq_limit))
+			{
+				audio.decode_info(&decinfo);
+
+				// decode...
+				//
+				for (iFrameCounter = 0;;iFrameCounter++)
+				{
+					if ( iSourceBytesRemaining == 0 || iSourceBytesRemaining < iFrameBytes)
+						break;	// end of file
+
+					bFastEstimateOnly = 1;	///////////////////////////////
+
+							x = audio.decode((unsigned char *)pvData + iSourceReadIndex, (short *) ((char *)pPCM_Buffer
+																							//+ iDestWriteIndex		// keep decoding over the same spot since we're only counting bytes in this function
+																							),
+											(unsigned char *)pvData + iReadLimit
+											);	
+
+					bFastEstimateOnly = 0;	///////////////////////////////
+					
+					iSourceReadIndex		+= x.in_bytes;
+					iSourceBytesRemaining	-= x.in_bytes;
+					iDestWriteIndex			+= x.out_bytes;
+
+					if (x.in_bytes <= 0)
+					{
+						//psReturn = "MP3ERR: Bad sync in file";
+						break;
+					}
+				}
+
+				*piUnpackedSize = iDestWriteIndex;	// yeeehaaa!
+			}
+			else
+			{
+				psReturn = "MP3ERR: Decoder failed to initialise";
+			}
+		}
+//		else
+//		{
+//			psReturn = "MP3ERR: Unable to alloc temp decomp buffer";		
+//		}
+	}
+	else
+	{
+		psReturn = "MP3ERR: Bad or Unsupported MP3 file!";
+	}
+
+
+//	if (pPCM_Buffer)
+//	{
+//		Z_Free(pPCM_Buffer);
+//		pPCM_Buffer = NULL;	// I know, I know...
+//	}
+
+	return psReturn;
+
+#undef iSourceReadIndex
+}
+
+
+
+
+char *C_MP3_UnpackRawPCM( void *pvData, int iSourceBytesRemaining, int *piUnpackedSize, void *pbUnpackBuffer, int bStereoDesired)
+{
+	int iReadLimit;
+	unsigned int iRealDataStart;
+	MPEG_HEAD head;
+	int iBitRate;
+	
+	char *psReturn = NULL;
+//	int  iSourceReadIndex = 0;
+	int	 iDestWriteIndex = 0;
+
+	int iFrameBytes;
+	int iFrameCounter;
+
+	DEC_INFO decinfo;
+	IN_OUT	 x;
+
+	memset(pMP3Stream,0,sizeof(*pMP3Stream));
+
+#define iSourceReadIndex iRealDataStart
+
+//	iFrameBytes = head_info2( pvData, 0, &head, &iBitRate);
+	iFrameBytes = head_info3( pvData, iSourceBytesRemaining/2, &head, &iBitRate, &iRealDataStart);
+
+	BYTESREMAINING_ACCOUNT_FOR_REAR_TAG(pvData, iSourceBytesRemaining)
+	iSourceBytesRemaining -= iRealDataStart;
+
+	iReadLimit = iSourceReadIndex + iSourceBytesRemaining;
+
+	if (iFrameBytes)
+	{
+//		if (1)////////////////////////pPCM_Buffer)
+		{
+			// init decoder...
+
+			if (audio.decode_init(&head, iFrameBytes, reduction_code, iRealDataStart, bStereoDesired?convert_code_stereo:convert_code_mono, freq_limit))
+			{
+				audio.decode_info(&decinfo);
+
+//				printf("\n output samprate = %6ld",decinfo.samprate);
+//				printf("\n output channels = %6d", decinfo.channels);
+//				printf("\n output bits     = %6d", decinfo.bits);
+//				printf("\n output type     = %6d", decinfo.type);
+
+//===============
+				
+				// decode...
+				//
+				for (iFrameCounter = 0;;iFrameCounter++)
+				{
+					if ( iSourceBytesRemaining == 0 || iSourceBytesRemaining < iFrameBytes)
+						break;	// end of file
+
+					x = audio.decode((unsigned char *)pvData + iSourceReadIndex, (short *) ((char *)pbUnpackBuffer + iDestWriteIndex),
+									 (unsigned char *)pvData + iReadLimit
+									);
+					
+					iSourceReadIndex		+= x.in_bytes;
+					iSourceBytesRemaining	-= x.in_bytes;
+					iDestWriteIndex			+= x.out_bytes;
+
+					if (x.in_bytes <= 0)
+					{
+						//psReturn = "MP3ERR: Bad sync in file";
+						break;
+					}
+				}
+
+				*piUnpackedSize = iDestWriteIndex;	// yeeehaaa!
+			}
+			else
+			{
+				psReturn = "MP3ERR: Decoder failed to initialise";
+			}
+		}
+	}
+	else
+	{
+		psReturn = "MP3ERR: Bad or Unsupported MP3 file!";
+	}
+
+	return psReturn;
+
+#undef iSourceReadIndex
+}
+
+
+// called once, after we've decided to keep something as MP3. This just sets up the decoder for subsequent stream-calls.
+// 					  
+// (the struct pSFX_MP3Stream is cleared internally, so pass as args anything you want stored in it)
+//
+// char * return is NULL for ok, else error string
+//
+char *C_MP3Stream_DecodeInit( LP_MP3STREAM pSFX_MP3Stream, void *pvSourceData, int iSourceBytesRemaining,
+							  int iGameAudioSampleRate, int iGameAudioSampleBits, int bStereoDesired )
+{
+	char			*psReturn = NULL;
+	MPEG_HEAD		head;			// only relevant within this function during init	
+	DEC_INFO		decinfo;		//   " "
+	int				iBitRate;		// not used after being filled in by head_info3()
+
+	pMP3Stream = pSFX_MP3Stream;
+
+	memset(pMP3Stream,0,sizeof(*pMP3Stream));
+	
+	pMP3Stream->pbSourceData			= (byte *) pvSourceData;
+	pMP3Stream->iSourceBytesRemaining	= iSourceBytesRemaining;
+	pMP3Stream->iSourceFrameBytes		= head_info3( (byte *) pvSourceData, iSourceBytesRemaining/2, &head, &iBitRate, (unsigned int*)&pMP3Stream->iSourceReadIndex );	
+
+	// hack, do NOT do this for stereo, since music files are now streamed and therefore the data isn't actually fully
+	//	loaded at this point, only about 4k or so for the header is actually in memory!!!...
+	//
+	if (!bStereoDesired)
+	{
+		BYTESREMAINING_ACCOUNT_FOR_REAR_TAG(pvSourceData, pMP3Stream->iSourceBytesRemaining);
+		pMP3Stream->iSourceBytesRemaining  -= pMP3Stream->iSourceReadIndex;
+	}
+
+	// backup a couple of fields so we can play this again later...
+	//
+	pMP3Stream->iRewind_SourceReadIndex		= pMP3Stream->iSourceReadIndex;
+	pMP3Stream->iRewind_SourceBytesRemaining= pMP3Stream->iSourceBytesRemaining;
+
+	assert(pMP3Stream->iSourceFrameBytes);
+	if (pMP3Stream->iSourceFrameBytes)
+	{
+		if (audio.decode_init(&head, pMP3Stream->iSourceFrameBytes, reduction_code, pMP3Stream->iSourceReadIndex, bStereoDesired?convert_code_stereo:convert_code_mono, freq_limit))
+		{
+			pMP3Stream->iRewind_FinalReductionCode = reduction_code;	// default = 0 (no reduction), 1=half, 2 = quarter
+
+			pMP3Stream->iRewind_FinalConvertCode   = bStereoDesired?convert_code_stereo:convert_code_mono;
+																		// default = 1 (mono), OR with 8 for 8-bit output
+
+			// only now can we ask what kind of properties this file has, and then adjust to fit what the game wants...
+			//
+			audio.decode_info(&decinfo);
+
+//			printf("\n output samprate = %6ld",decinfo.samprate);
+//			printf("\n output channels = %6d", decinfo.channels);
+//			printf("\n output bits     = %6d", decinfo.bits);
+//			printf("\n output type     = %6d", decinfo.type);
+
+			// decoder offers half or quarter rate adjustement only...
+			//
+			if (iGameAudioSampleRate == decinfo.samprate>>1)
+				pMP3Stream->iRewind_FinalReductionCode = 1;
+			else
+			if (iGameAudioSampleRate == decinfo.samprate>>2)
+				pMP3Stream->iRewind_FinalReductionCode = 2;
+
+			if (iGameAudioSampleBits == decinfo.bits>>1)	// if game wants 8 bit sounds, then setup for that
+				pMP3Stream->iRewind_FinalConvertCode |= 8;
+
+			if (audio.decode_init(&head, pMP3Stream->iSourceFrameBytes, pMP3Stream->iRewind_FinalReductionCode, pMP3Stream->iSourceReadIndex, pMP3Stream->iRewind_FinalConvertCode, freq_limit))
+			{
+				audio.decode_info(&decinfo);
+#ifdef _DEBUG
+				assert( iGameAudioSampleRate == decinfo.samprate );
+				assert( iGameAudioSampleBits == decinfo.bits );
+#endif
+
+				// sod it, no harm in one last check... (should never happen)
+				//
+				if ( iGameAudioSampleRate != decinfo.samprate || iGameAudioSampleBits != decinfo.bits )
+				{
+					psReturn = "MP3ERR: Decoder unable to convert to current game audio settings";
+				}
+			}
+			else
+			{
+				psReturn = "MP3ERR: Decoder failed to initialise for pass 2 sample adjust";
+			}
+		}
+		else
+		{
+			psReturn = "MP3ERR: Decoder failed to initialise";
+		}
+	}
+	else
+	{
+		psReturn = "MP3ERR: Errr.... something's broken with this MP3 file";	// should never happen by this point
+	}
+
+	// restore global stream ptr before returning to normal functions (so the rest of the MP3 code still works)...
+	//
+	pMP3Stream = &_MP3Stream;
+
+	return psReturn;
+}
+
+// return value is decoded bytes for this packet, which is effectively a BOOL, NZ for not finished decoding yet...
+//
+unsigned int C_MP3Stream_Decode( LP_MP3STREAM pSFX_MP3Stream, int bFastForwarding )
+{
+	unsigned int uiDecoded = 0;	// default to "finished"
+	IN_OUT	 x;
+
+	pMP3Stream = pSFX_MP3Stream;
+
+	do
+	{
+		if ( pSFX_MP3Stream->iSourceBytesRemaining == 0 )//|| pSFX_MP3Stream->iSourceBytesRemaining < pSFX_MP3Stream->iSourceFrameBytes)
+		{
+			uiDecoded = 0;	// finished
+			break;
+		}
+
+
+		
+		bFastEstimateOnly = bFastForwarding;	///////////////////////////////
+
+		x = audio.decode(pSFX_MP3Stream->pbSourceData + pSFX_MP3Stream->iSourceReadIndex, (short *) (pSFX_MP3Stream->bDecodeBuffer),
+						 pSFX_MP3Stream->pbSourceData + pSFX_MP3Stream->iRewind_SourceReadIndex + pSFX_MP3Stream->iRewind_SourceBytesRemaining
+						);
+
+		bFastEstimateOnly = 0;	///////////////////////////////
+
+
+
+#ifdef _DEBUG
+		pSFX_MP3Stream->iSourceFrameCounter++;
+#endif
+
+		pSFX_MP3Stream->iSourceReadIndex		+= x.in_bytes;
+		pSFX_MP3Stream->iSourceBytesRemaining	-= x.in_bytes;
+		pSFX_MP3Stream->iBytesDecodedTotal		+= x.out_bytes;
+		pSFX_MP3Stream->iBytesDecodedThisPacket	 = x.out_bytes;
+
+		uiDecoded = x.out_bytes;
+
+		if (x.in_bytes <= 0)
+		{
+			//psReturn = "MP3ERR: Bad sync in file";			
+			uiDecoded= 0;	// finished
+			break;
+		}
+	}
+	#pragma warning (disable : 4127 )	// conditional expression is constant
+	while (0);	// <g>
+	#pragma warning (default : 4127 )	// conditional expression is constant
+	
+	// restore global stream ptr before returning to normal functions (so the rest of the MP3 code still works)...
+	//
+	pMP3Stream = &_MP3Stream;
+
+	return uiDecoded;
+}
+
+
+// ret is char* errstring, else NULL for ok
+//
+char *C_MP3Stream_Rewind( LP_MP3STREAM pSFX_MP3Stream )
+{
+	char*		psReturn = NULL;
+	MPEG_HEAD	head;			// only relevant within this function during init	
+	int			iBitRate;		// ditto
+	int			iNULL;			
+
+	pMP3Stream = pSFX_MP3Stream;
+
+	pMP3Stream->iSourceReadIndex		= pMP3Stream->iRewind_SourceReadIndex;
+	pMP3Stream->iSourceBytesRemaining	= pMP3Stream->iRewind_SourceBytesRemaining;	// already adjusted for tags etc	
+
+	// I'm not sure that this is needed, but where else does decode_init get passed useful data ptrs?...
+	//
+	if (pMP3Stream->iSourceFrameBytes == head_info3( pMP3Stream->pbSourceData, pMP3Stream->iSourceBytesRemaining/2, &head, &iBitRate, (unsigned int*)&iNULL ) )
+	{	
+		if (audio.decode_init(&head, pMP3Stream->iSourceFrameBytes, pMP3Stream->iRewind_FinalReductionCode, pMP3Stream->iSourceReadIndex, pMP3Stream->iRewind_FinalConvertCode, freq_limit))
+		{
+			// we should always get here...
+			//
+		}
+		else
+		{
+			psReturn = "MP3ERR: Failed to re-init decoder for rewind!";
+		}
+	}
+	else
+	{
+		psReturn = "MP3ERR: Frame bytes mismatch during rewind header-read!";
+	}
+
+	// restore global stream ptr before returning to normal functions (so the rest of the MP3 code still works)...
+	//
+	pMP3Stream = &_MP3Stream;
+
+	return psReturn;
+}
+
diff --git a/code/mp3code/uph.c b/code/mp3code/uph.c
new file mode 100644
index 0000000..95f956a
--- /dev/null
+++ b/code/mp3code/uph.c
@@ -0,0 +1,507 @@
+/*____________________________________________________________________________
+	
+	FreeAmp - The Free MP3 Player
+
+        MP3 Decoder originally Copyright (C) 1995-1997 Xing Technology
+        Corp.  http://www.xingtech.com
+
+	Portions Copyright (C) 1998-1999 EMusic.com
+
+	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., 675 Mass Ave, Cambridge, MA 02139, USA.
+	
+	$Id: uph.c,v 1.3 1999/10/19 07:13:09 elrod Exp $
+____________________________________________________________________________*/
+
+/****  uph.c  ***************************************************
+
+Layer 3 audio
+ huffman decode
+
+
+******************************************************************/
+#include <stdlib.h>
+#include <stdio.h>
+#include <float.h>
+#include <math.h>
+
+#include "L3.h"
+
+#pragma warning ( disable : 4711 )	// function 'xxxx' selected for automatic inline expansion
+
+
+#ifdef _MSC_VER
+#pragma warning(disable: 4505)
+#endif
+
+/*===============================================================*/
+
+/* max bits required for any lookup - change if htable changes */
+/* quad required 10 bit w/signs  must have (MAXBITS+2) >= 10   */
+#define MAXBITS 9
+
+static const HUFF_ELEMENT huff_table_0[4] =
+{{0}, {0}, {0}, {64}};			/* dummy must not use */
+
+#include "htable.h"
+
+/*-- 6 bit lookup (purgebits, value) --*/
+static const unsigned char quad_table_a[][2] =
+{
+  {6, 11}, {6, 15}, {6, 13}, {6, 14}, {6, 7}, {6, 5}, {5, 9},
+  {5, 9}, {5, 6}, {5, 6}, {5, 3}, {5, 3}, {5, 10}, {5, 10},
+  {5, 12}, {5, 12}, {4, 2}, {4, 2}, {4, 2}, {4, 2}, {4, 1},
+  {4, 1}, {4, 1}, {4, 1}, {4, 4}, {4, 4}, {4, 4}, {4, 4},
+  {4, 8}, {4, 8}, {4, 8}, {4, 8}, {1, 0}, {1, 0}, {1, 0},
+  {1, 0}, {1, 0}, {1, 0}, {1, 0}, {1, 0}, {1, 0}, {1, 0},
+  {1, 0}, {1, 0}, {1, 0}, {1, 0}, {1, 0}, {1, 0}, {1, 0},
+  {1, 0}, {1, 0}, {1, 0}, {1, 0}, {1, 0}, {1, 0}, {1, 0},
+  {1, 0}, {1, 0}, {1, 0}, {1, 0}, {1, 0}, {1, 0}, {1, 0},
+  {1, 0},
+};
+
+
+typedef struct
+{
+   const HUFF_ELEMENT *table;
+   int linbits;
+   int ncase;
+}
+HUFF_SETUP;
+
+#define no_bits       0
+#define one_shot      1
+#define no_linbits    2
+#define have_linbits  3
+#define quad_a        4
+#define quad_b        5
+
+
+static const HUFF_SETUP table_look[] =
+{
+  {huff_table_0, 0, no_bits},
+  {huff_table_1, 0, one_shot},
+  {huff_table_2, 0, one_shot},
+  {huff_table_3, 0, one_shot},
+  {huff_table_0, 0, no_bits},
+  {huff_table_5, 0, one_shot},
+  {huff_table_6, 0, one_shot},
+  {huff_table_7, 0, no_linbits},
+  {huff_table_8, 0, no_linbits},
+  {huff_table_9, 0, no_linbits},
+  {huff_table_10, 0, no_linbits},
+  {huff_table_11, 0, no_linbits},
+  {huff_table_12, 0, no_linbits},
+  {huff_table_13, 0, no_linbits},
+  {huff_table_0, 0, no_bits},
+  {huff_table_15, 0, no_linbits},
+  {huff_table_16, 1, have_linbits},
+  {huff_table_16, 2, have_linbits},
+  {huff_table_16, 3, have_linbits},
+  {huff_table_16, 4, have_linbits},
+  {huff_table_16, 6, have_linbits},
+  {huff_table_16, 8, have_linbits},
+  {huff_table_16, 10, have_linbits},
+  {huff_table_16, 13, have_linbits},
+  {huff_table_24, 4, have_linbits},
+  {huff_table_24, 5, have_linbits},
+  {huff_table_24, 6, have_linbits},
+  {huff_table_24, 7, have_linbits},
+  {huff_table_24, 8, have_linbits},
+  {huff_table_24, 9, have_linbits},
+  {huff_table_24, 11, have_linbits},
+  {huff_table_24, 13, have_linbits},
+  {huff_table_0, 0, quad_a},
+  {huff_table_0, 0, quad_b},
+};
+
+/*========================================================*/
+extern BITDAT bitdat;
+
+/*------------- get n bits from bitstream -------------*/
+/* unused
+static unsigned int bitget(int n)
+{
+   unsigned int x;
+
+   if (bitdat.bits < n)
+   {			*/	/* refill bit buf if necessary */
+/*      while (bitdat.bits <= 24)
+      {
+	 bitdat.bitbuf = (bitdat.bitbuf << 8) | *bitdat.bs_ptr++;
+	 bitdat.bits += 8;
+      }
+   }
+   bitdat.bits -= n;
+   x = bitdat.bitbuf >> bitdat.bits;
+   bitdat.bitbuf -= x << bitdat.bits;
+   return x;
+}
+*/
+/*----- get n bits  - checks for n+2 avail bits (linbits+sign) -----*/
+static unsigned int bitget_lb(int n)
+{
+   unsigned int x;
+
+   if (bitdat.bits < (n + 2))
+   {				/* refill bit buf if necessary */
+      while (bitdat.bits <= 24)
+      {
+	 bitdat.bitbuf = (bitdat.bitbuf << 8) | *bitdat.bs_ptr++;
+	 bitdat.bits += 8;
+      }
+   }
+   bitdat.bits -= n;
+   x = bitdat.bitbuf >> bitdat.bits;
+   bitdat.bitbuf -= x << bitdat.bits;
+   return x;
+}
+
+
+
+
+/*------------- get n bits but DO NOT remove from bitstream --*/
+static unsigned int bitget2(int n)
+{
+   unsigned int x;
+
+   if (bitdat.bits < (MAXBITS + 2))
+   {				/* refill bit buf if necessary */
+      while (bitdat.bits <= 24)
+      {
+	 bitdat.bitbuf = (bitdat.bitbuf << 8) | *bitdat.bs_ptr++;
+	 bitdat.bits += 8;
+      }
+   }
+   x = bitdat.bitbuf >> (bitdat.bits - n);
+   return x;
+}
+/*------------- remove n bits from bitstream ---------*/
+/* unused
+static void bitget_purge(int n)
+{
+   bitdat.bits -= n;
+   bitdat.bitbuf -= (bitdat.bitbuf >> bitdat.bits) << bitdat.bits;
+}
+*/
+/*------------- get 1 bit from bitstream NO CHECK -------------*/
+/* unused
+static unsigned int bitget_1bit()
+{
+   unsigned int x;
+
+   bitdat.bits--;
+   x = bitdat.bitbuf >> bitdat.bits;
+   bitdat.bitbuf -= x << bitdat.bits;
+   return x;
+}
+*/
+/*========================================================*/
+/*========================================================*/
+#define mac_bitget_check(n) if( bitdat.bits < (n) ) {                   \
+    while( bitdat.bits <= 24 ) {            \
+        bitdat.bitbuf = (bitdat.bitbuf << 8) | *bitdat.bs_ptr++; \
+        bitdat.bits += 8;                   \
+    }                                       \
+}
+/*---------------------------------------------------------*/
+#define mac_bitget2(n)  (bitdat.bitbuf >> (bitdat.bits-n));
+/*---------------------------------------------------------*/
+#define mac_bitget(n) ( bitdat.bits -= n,           \
+         code  = bitdat.bitbuf >> bitdat.bits,     \
+         bitdat.bitbuf -= code << bitdat.bits,     \
+         code )
+/*---------------------------------------------------------*/
+#define mac_bitget_purge(n) bitdat.bits -= n,                    \
+    bitdat.bitbuf -= (bitdat.bitbuf >> bitdat.bits) << bitdat.bits;
+/*---------------------------------------------------------*/
+#define mac_bitget_1bit() ( bitdat.bits--,                           \
+         code  = bitdat.bitbuf >> bitdat.bits,    \
+         bitdat.bitbuf -= code << bitdat.bits,  \
+         code )
+/*========================================================*/
+/*========================================================*/
+void unpack_huff(int xy[][2], int n, int ntable)
+{
+   int i;
+   const HUFF_ELEMENT *t;
+   const HUFF_ELEMENT *t0;
+   int linbits;
+   int bits;
+   int code;
+   int x, y;
+
+   if (n <= 0)
+      return;
+   n = n >> 1;			/* huff in pairs */
+/*-------------*/
+   t0 = table_look[ntable].table;
+   linbits = table_look[ntable].linbits;
+   switch (table_look[ntable].ncase)
+   {
+      default:
+/*------------------------------------------*/
+      case no_bits:
+/*- table 0, no data, x=y=0--*/
+	 for (i = 0; i < n; i++)
+	 {
+	    xy[i][0] = 0;
+	    xy[i][1] = 0;
+	 }
+	 return;
+/*------------------------------------------*/
+      case one_shot:
+/*- single lookup, no escapes -*/
+	 for (i = 0; i < n; i++)
+	 {
+	    mac_bitget_check((MAXBITS + 2));
+	    bits = t0[0].b.signbits;
+	    code = mac_bitget2(bits);
+	    mac_bitget_purge(t0[1 + code].b.purgebits);
+	    x = t0[1 + code].b.x;
+	    y = t0[1 + code].b.y;
+	    if (x)
+	       if (mac_bitget_1bit())
+		  x = -x;
+	    if (y)
+	       if (mac_bitget_1bit())
+		  y = -y;
+	    xy[i][0] = x;
+	    xy[i][1] = y;
+	    if (bitdat.bs_ptr > bitdat.bs_ptr_end)
+	       break;		// bad data protect
+
+	 }
+	 return;
+/*------------------------------------------*/
+      case no_linbits:
+	 for (i = 0; i < n; i++)
+	 {
+	    t = t0;
+	    for (;;)
+	    {
+	       mac_bitget_check((MAXBITS + 2));
+	       bits = t[0].b.signbits;
+	       code = mac_bitget2(bits);
+	       if (t[1 + code].b.purgebits)
+		  break;
+	       t += t[1 + code].ptr;	/* ptr include 1+code */
+	       mac_bitget_purge(bits);
+	    }
+	    mac_bitget_purge(t[1 + code].b.purgebits);
+	    x = t[1 + code].b.x;
+	    y = t[1 + code].b.y;
+	    if (x)
+	       if (mac_bitget_1bit())
+		  x = -x;
+	    if (y)
+	       if (mac_bitget_1bit())
+		  y = -y;
+	    xy[i][0] = x;
+	    xy[i][1] = y;
+	    if (bitdat.bs_ptr > bitdat.bs_ptr_end)
+	       break;		// bad data protect
+
+	 }
+	 return;
+/*------------------------------------------*/
+      case have_linbits:
+	 for (i = 0; i < n; i++)
+	 {
+	    t = t0;
+	    for (;;)
+	    {
+	       bits = t[0].b.signbits;
+	       code = bitget2(bits);
+	       if (t[1 + code].b.purgebits)
+		  break;
+	       t += t[1 + code].ptr;	/* ptr includes 1+code */
+	       mac_bitget_purge(bits);
+	    }
+	    mac_bitget_purge(t[1 + code].b.purgebits);
+	    x = t[1 + code].b.x;
+	    y = t[1 + code].b.y;
+	    if (x == 15)
+	       x += bitget_lb(linbits);
+	    if (x)
+	       if (mac_bitget_1bit())
+		  x = -x;
+	    if (y == 15)
+	       y += bitget_lb(linbits);
+	    if (y)
+	       if (mac_bitget_1bit())
+		  y = -y;
+	    xy[i][0] = x;
+	    xy[i][1] = y;
+	    if (bitdat.bs_ptr > bitdat.bs_ptr_end)
+	       break;		// bad data protect
+
+	 }
+	 return;
+   }
+/*--- end switch ---*/
+
+}
+/*==========================================================*/
+int unpack_huff_quad(int vwxy[][4], int n, int nbits, int ntable)
+{
+   int i;
+   int code;
+   int x, y, v, w;
+   int tmp;
+   int i_non_zero, tmp_nz;
+
+   tmp_nz = 15;
+   i_non_zero = -1;
+
+   n = n >> 2;			/* huff in quads */
+
+   if (ntable)
+      goto case_quad_b;
+
+/* case_quad_a: */
+   for (i = 0; i < n; i++)
+   {
+      if (nbits <= 0)
+	 break;
+      mac_bitget_check(10);
+      code = mac_bitget2(6);
+      nbits -= quad_table_a[code][0];
+      mac_bitget_purge(quad_table_a[code][0]);
+      tmp = quad_table_a[code][1];
+      if (tmp)
+      {
+	 i_non_zero = i;
+	 tmp_nz = tmp;
+      }
+      v = (tmp >> 3) & 1;
+      w = (tmp >> 2) & 1;
+      x = (tmp >> 1) & 1;
+      y = tmp & 1;
+      if (v)
+      {
+	 if (mac_bitget_1bit())
+	    v = -v;
+	 nbits--;
+      }
+      if (w)
+      {
+	 if (mac_bitget_1bit())
+	    w = -w;
+	 nbits--;
+      }
+      if (x)
+      {
+	 if (mac_bitget_1bit())
+	    x = -x;
+	 nbits--;
+      }
+      if (y)
+      {
+	 if (mac_bitget_1bit())
+	    y = -y;
+	 nbits--;
+      }
+      vwxy[i][0] = v;
+      vwxy[i][1] = w;
+      vwxy[i][2] = x;
+      vwxy[i][3] = y;
+      if (bitdat.bs_ptr > bitdat.bs_ptr_end)
+	 break;			// bad data protect
+
+   }
+   if (i && nbits < 0)
+   {
+      i--;
+      vwxy[i][0] = 0;
+      vwxy[i][1] = 0;
+      vwxy[i][2] = 0;
+      vwxy[i][3] = 0;
+   }
+
+   i_non_zero = (i_non_zero + 1) << 2;
+
+   if ((tmp_nz & 3) == 0)
+      i_non_zero -= 2;
+
+   return i_non_zero;
+
+/*--------------------*/
+ case_quad_b:
+   for (i = 0; i < n; i++)
+   {
+      if (nbits < 4)
+	 break;
+      nbits -= 4;
+      mac_bitget_check(8);
+      tmp = mac_bitget(4) ^ 15;	/* one's complement of bitstream */
+      if (tmp)
+      {
+	 i_non_zero = i;
+	 tmp_nz = tmp;
+      }
+      v = (tmp >> 3) & 1;
+      w = (tmp >> 2) & 1;
+      x = (tmp >> 1) & 1;
+      y = tmp & 1;
+      if (v)
+      {
+	 if (mac_bitget_1bit())
+	    v = -v;
+	 nbits--;
+      }
+      if (w)
+      {
+	 if (mac_bitget_1bit())
+	    w = -w;
+	 nbits--;
+      }
+      if (x)
+      {
+	 if (mac_bitget_1bit())
+	    x = -x;
+	 nbits--;
+      }
+      if (y)
+      {
+	 if (mac_bitget_1bit())
+	    y = -y;
+	 nbits--;
+      }
+      vwxy[i][0] = v;
+      vwxy[i][1] = w;
+      vwxy[i][2] = x;
+      vwxy[i][3] = y;
+      if (bitdat.bs_ptr > bitdat.bs_ptr_end)
+	 break;			// bad data protect
+
+   }
+   if (nbits < 0)
+   {
+      i--;
+      vwxy[i][0] = 0;
+      vwxy[i][1] = 0;
+      vwxy[i][2] = 0;
+      vwxy[i][3] = 0;
+   }
+
+   i_non_zero = (i_non_zero + 1) << 2;
+
+   if ((tmp_nz & 3) == 0)
+      i_non_zero -= 2;
+
+   return i_non_zero;		/* return non-zero sample (to nearest pair) */
+
+}
+/*-----------------------------------------------------*/
diff --git a/code/mp3code/upsf.c b/code/mp3code/upsf.c
new file mode 100644
index 0000000..e538229
--- /dev/null
+++ b/code/mp3code/upsf.c
@@ -0,0 +1,404 @@
+/*____________________________________________________________________________
+	
+	FreeAmp - The Free MP3 Player
+
+        MP3 Decoder originally Copyright (C) 1995-1997 Xing Technology
+        Corp.  http://www.xingtech.com
+
+	Portions Copyright (C) 1998-1999 EMusic.com
+
+	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., 675 Mass Ave, Cambridge, MA 02139, USA.
+	
+	$Id: upsf.c,v 1.3 1999/10/19 07:13:09 elrod Exp $
+____________________________________________________________________________*/
+
+/****  upsf.c  ***************************************************
+
+Layer III 
+    unpack scale factors
+
+
+
+******************************************************************/
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <float.h>
+#include <math.h>
+#include "L3.h"
+
+//extern int iframe;
+
+unsigned int bitget(int n);
+
+/*------------------------------------------------------------*/
+static const int slen_table[16][2] =
+{
+  {0, 0}, {0, 1},
+  {0, 2}, {0, 3},
+  {3, 0}, {1, 1},
+  {1, 2}, {1, 3},
+  {2, 1}, {2, 2},
+  {2, 3}, {3, 1},
+  {3, 2}, {3, 3},
+  {4, 2}, {4, 3},
+};
+
+/* nr_table[size+3*is_right][block type 0,1,3  2, 2+mixed][4]  */
+/* for bt=2 nr is count for group of 3 */
+static const int nr_table[6][3][4] =
+{
+ {{6, 5, 5, 5},
+  {3, 3, 3, 3},
+  {6, 3, 3, 3}},
+
+ {{6, 5, 7, 3},
+  {3, 3, 4, 2},
+  {6, 3, 4, 2}},
+
+ {{11, 10, 0, 0},
+  {6, 6, 0, 0},
+  {6, 3, 6, 0}},			/* adjusted *//* 15, 18, 0, 0,   */
+/*-intensity stereo right chan--*/
+ {{7, 7, 7, 0},
+  {4, 4, 4, 0},
+  {6, 5, 4, 0}},
+
+ {{6, 6, 6, 3},
+  {4, 3, 3, 2},
+  {6, 4, 3, 2}},
+
+ {{8, 8, 5, 0},
+  {5, 4, 3, 0},
+  {6, 6, 3, 0}},
+};
+
+/*=============================================================*/
+void unpack_sf_sub_MPEG1(SCALEFACT sf[],
+			 GR * grdat,
+			 int scfsi,	/* bit flag */
+			 int gr)
+{
+   int sfb;
+   int slen0, slen1;
+   int block_type, mixed_block_flag, scalefac_compress;
+
+
+   block_type = grdat->block_type;
+   mixed_block_flag = grdat->mixed_block_flag;
+   scalefac_compress = grdat->scalefac_compress;
+
+   slen0 = slen_table[scalefac_compress][0];
+   slen1 = slen_table[scalefac_compress][1];
+
+
+   if (block_type == 2)
+   {
+      if (mixed_block_flag)
+      {				/* mixed */
+	 for (sfb = 0; sfb < 8; sfb++)
+	    sf[0].l[sfb] = bitget(slen0);
+	 for (sfb = 3; sfb < 6; sfb++)
+	 {
+	    sf[0].s[0][sfb] = bitget(slen0);
+	    sf[0].s[1][sfb] = bitget(slen0);
+	    sf[0].s[2][sfb] = bitget(slen0);
+	 }
+	 for (sfb = 6; sfb < 12; sfb++)
+	 {
+	    sf[0].s[0][sfb] = bitget(slen1);
+	    sf[0].s[1][sfb] = bitget(slen1);
+	    sf[0].s[2][sfb] = bitget(slen1);
+	 }
+	 return;
+      }
+      for (sfb = 0; sfb < 6; sfb++)
+      {
+	 sf[0].s[0][sfb] = bitget(slen0);
+	 sf[0].s[1][sfb] = bitget(slen0);
+	 sf[0].s[2][sfb] = bitget(slen0);
+      }
+      for (; sfb < 12; sfb++)
+      {
+	 sf[0].s[0][sfb] = bitget(slen1);
+	 sf[0].s[1][sfb] = bitget(slen1);
+	 sf[0].s[2][sfb] = bitget(slen1);
+      }
+      return;
+   }
+
+/* long blocks types 0 1 3, first granule */
+   if (gr == 0)
+   {
+      for (sfb = 0; sfb < 11; sfb++)
+	 sf[0].l[sfb] = bitget(slen0);
+      for (; sfb < 21; sfb++)
+	 sf[0].l[sfb] = bitget(slen1);
+      return;
+   }
+
+/* long blocks 0, 1, 3, second granule */
+   sfb = 0;
+   if (scfsi & 8)
+      for (; sfb < 6; sfb++)
+	 sf[0].l[sfb] = sf[-2].l[sfb];
+   else
+      for (; sfb < 6; sfb++)
+	 sf[0].l[sfb] = bitget(slen0);
+   if (scfsi & 4)
+      for (; sfb < 11; sfb++)
+	 sf[0].l[sfb] = sf[-2].l[sfb];
+   else
+      for (; sfb < 11; sfb++)
+	 sf[0].l[sfb] = bitget(slen0);
+   if (scfsi & 2)
+      for (; sfb < 16; sfb++)
+	 sf[0].l[sfb] = sf[-2].l[sfb];
+   else
+      for (; sfb < 16; sfb++)
+	 sf[0].l[sfb] = bitget(slen1);
+   if (scfsi & 1)
+      for (; sfb < 21; sfb++)
+	 sf[0].l[sfb] = sf[-2].l[sfb];
+   else
+      for (; sfb < 21; sfb++)
+	 sf[0].l[sfb] = bitget(slen1);
+
+
+
+   return;
+}
+/*=============================================================*/
+void unpack_sf_sub_MPEG2(SCALEFACT sf[],
+			 GR * grdat,
+			 int is_and_ch, IS_SF_INFO * sf_info)
+{
+   int sfb;
+   int slen1, slen2, slen3, slen4;
+   int nr1, nr2, nr3, nr4;
+   int i, k;
+   int preflag, intensity_scale;
+   int block_type, mixed_block_flag, scalefac_compress;
+
+
+   block_type = grdat->block_type;
+   mixed_block_flag = grdat->mixed_block_flag;
+   scalefac_compress = grdat->scalefac_compress;
+
+   preflag = 0;
+   intensity_scale = 0;		/* to avoid compiler warning */
+   if (is_and_ch == 0)
+   {
+      if (scalefac_compress < 400)
+      {
+	 slen2 = scalefac_compress >> 4;
+	 slen1 = slen2 / 5;
+	 slen2 = slen2 % 5;
+	 slen4 = scalefac_compress & 15;
+	 slen3 = slen4 >> 2;
+	 slen4 = slen4 & 3;
+	 k = 0;
+      }
+      else if (scalefac_compress < 500)
+      {
+	 scalefac_compress -= 400;
+	 slen2 = scalefac_compress >> 2;
+	 slen1 = slen2 / 5;
+	 slen2 = slen2 % 5;
+	 slen3 = scalefac_compress & 3;
+	 slen4 = 0;
+	 k = 1;
+      }
+      else
+      {
+	 scalefac_compress -= 500;
+	 slen1 = scalefac_compress / 3;
+	 slen2 = scalefac_compress % 3;
+	 slen3 = slen4 = 0;
+	 if (mixed_block_flag)
+	 {
+	    slen3 = slen2;	/* adjust for long/short mix logic */
+	    slen2 = slen1;
+	 }
+	 preflag = 1;
+	 k = 2;
+      }
+   }
+   else
+   {				/* intensity stereo ch = 1 (right) */
+      intensity_scale = scalefac_compress & 1;
+      scalefac_compress >>= 1;
+      if (scalefac_compress < 180)
+      {
+	 slen1 = scalefac_compress / 36;
+	 slen2 = scalefac_compress % 36;
+	 slen3 = slen2 % 6;
+	 slen2 = slen2 / 6;
+	 slen4 = 0;
+	 k = 3 + 0;
+      }
+      else if (scalefac_compress < 244)
+      {
+	 scalefac_compress -= 180;
+	 slen3 = scalefac_compress & 3;
+	 scalefac_compress >>= 2;
+	 slen2 = scalefac_compress & 3;
+	 slen1 = scalefac_compress >> 2;
+	 slen4 = 0;
+	 k = 3 + 1;
+      }
+      else
+      {
+	 scalefac_compress -= 244;
+	 slen1 = scalefac_compress / 3;
+	 slen2 = scalefac_compress % 3;
+	 slen3 = slen4 = 0;
+	 k = 3 + 2;
+      }
+   }
+
+   i = 0;
+   if (block_type == 2)
+      i = (mixed_block_flag & 1) + 1;
+   nr1 = nr_table[k][i][0];
+   nr2 = nr_table[k][i][1];
+   nr3 = nr_table[k][i][2];
+   nr4 = nr_table[k][i][3];
+
+
+/* return is scale factor info (for right chan is mode) */
+   if (is_and_ch)
+   {
+      sf_info->nr[0] = nr1;
+      sf_info->nr[1] = nr2;
+      sf_info->nr[2] = nr3;
+      sf_info->slen[0] = slen1;
+      sf_info->slen[1] = slen2;
+      sf_info->slen[2] = slen3;
+      sf_info->intensity_scale = intensity_scale;
+   }
+   grdat->preflag = preflag;	/* return preflag */
+
+/*--------------------------------------*/
+   if (block_type == 2)
+   {
+      if (mixed_block_flag)
+      {				/* mixed */
+	 if (slen1 != 0)	/* long block portion */
+	    for (sfb = 0; sfb < 6; sfb++)
+	       sf[0].l[sfb] = bitget(slen1);
+	 else
+	    for (sfb = 0; sfb < 6; sfb++)
+	       sf[0].l[sfb] = 0;
+	 sfb = 3;		/* start sfb for short */
+      }
+      else
+      {				/* all short, initial short blocks */
+	 sfb = 0;
+	 if (slen1 != 0)
+	    for (i = 0; i < nr1; i++, sfb++)
+	    {
+	       sf[0].s[0][sfb] = bitget(slen1);
+	       sf[0].s[1][sfb] = bitget(slen1);
+	       sf[0].s[2][sfb] = bitget(slen1);
+	    }
+	 else
+	    for (i = 0; i < nr1; i++, sfb++)
+	    {
+	       sf[0].s[0][sfb] = 0;
+	       sf[0].s[1][sfb] = 0;
+	       sf[0].s[2][sfb] = 0;
+	    }
+      }
+/* remaining short blocks */
+      if (slen2 != 0)
+	 for (i = 0; i < nr2; i++, sfb++)
+	 {
+	    sf[0].s[0][sfb] = bitget(slen2);
+	    sf[0].s[1][sfb] = bitget(slen2);
+	    sf[0].s[2][sfb] = bitget(slen2);
+	 }
+      else
+	 for (i = 0; i < nr2; i++, sfb++)
+	 {
+	    sf[0].s[0][sfb] = 0;
+	    sf[0].s[1][sfb] = 0;
+	    sf[0].s[2][sfb] = 0;
+	 }
+      if (slen3 != 0)
+	 for (i = 0; i < nr3; i++, sfb++)
+	 {
+	    sf[0].s[0][sfb] = bitget(slen3);
+	    sf[0].s[1][sfb] = bitget(slen3);
+	    sf[0].s[2][sfb] = bitget(slen3);
+	 }
+      else
+	 for (i = 0; i < nr3; i++, sfb++)
+	 {
+	    sf[0].s[0][sfb] = 0;
+	    sf[0].s[1][sfb] = 0;
+	    sf[0].s[2][sfb] = 0;
+	 }
+      if (slen4 != 0)
+	 for (i = 0; i < nr4; i++, sfb++)
+	 {
+	    sf[0].s[0][sfb] = bitget(slen4);
+	    sf[0].s[1][sfb] = bitget(slen4);
+	    sf[0].s[2][sfb] = bitget(slen4);
+	 }
+      else
+	 for (i = 0; i < nr4; i++, sfb++)
+	 {
+	    sf[0].s[0][sfb] = 0;
+	    sf[0].s[1][sfb] = 0;
+	    sf[0].s[2][sfb] = 0;
+	 }
+      return;
+   }
+
+
+/* long blocks types 0 1 3 */
+   sfb = 0;
+   if (slen1 != 0)
+      for (i = 0; i < nr1; i++, sfb++)
+	 sf[0].l[sfb] = bitget(slen1);
+   else
+      for (i = 0; i < nr1; i++, sfb++)
+	 sf[0].l[sfb] = 0;
+
+   if (slen2 != 0)
+      for (i = 0; i < nr2; i++, sfb++)
+	 sf[0].l[sfb] = bitget(slen2);
+   else
+      for (i = 0; i < nr2; i++, sfb++)
+	 sf[0].l[sfb] = 0;
+
+   if (slen3 != 0)
+      for (i = 0; i < nr3; i++, sfb++)
+	 sf[0].l[sfb] = bitget(slen3);
+   else
+      for (i = 0; i < nr3; i++, sfb++)
+	 sf[0].l[sfb] = 0;
+
+   if (slen4 != 0)
+      for (i = 0; i < nr4; i++, sfb++)
+	 sf[0].l[sfb] = bitget(slen4);
+   else
+      for (i = 0; i < nr4; i++, sfb++)
+	 sf[0].l[sfb] = 0;
+
+
+}
+/*-------------------------------------------------*/
diff --git a/code/mp3code/vssver.scc b/code/mp3code/vssver.scc
new file mode 100644
index 0000000..14eef1c
Binary files /dev/null and b/code/mp3code/vssver.scc differ
diff --git a/code/mp3code/wavep.c b/code/mp3code/wavep.c
new file mode 100644
index 0000000..6ff6af2
--- /dev/null
+++ b/code/mp3code/wavep.c
@@ -0,0 +1,96 @@
+#pragma warning(disable:4206)	// nonstandard extension used : translation unit is empty
+#if 0
+/*____________________________________________________________________________
+	
+	FreeAmp - The Free MP3 Player
+
+        MP3 Decoder originally Copyright (C) 1995-1997 Xing Technology
+        Corp.  http://www.xingtech.com
+
+	Portions Copyright (C) 1998-1999 EMusic.com
+
+	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., 675 Mass Ave, Cambridge, MA 02139, USA.
+	
+	$Id: wavep.c,v 1.3 1999/10/19 07:13:09 elrod Exp $
+____________________________________________________________________________*/
+
+/*---- wavep.c --------------------------------------------
+
+WAVE FILE HEADER ROUTINES
+with conditional pcm conversion to MS wave format
+portable version
+
+-----------------------------------------------------------*/
+#include <stdlib.h>
+#include <stdio.h>
+#include <float.h>
+#include <math.h>
+#ifdef WIN32
+#include <io.h>
+#else
+#include <unistd.h>
+#endif
+#include "port.h"
+
+typedef struct
+{
+   unsigned char riff[4];
+   unsigned char size[4];
+   unsigned char wave[4];
+   unsigned char fmt[4];
+   unsigned char fmtsize[4];
+   unsigned char tag[2];
+   unsigned char nChannels[2];
+   unsigned char nSamplesPerSec[4];
+   unsigned char nAvgBytesPerSec[4];
+   unsigned char nBlockAlign[2];
+   unsigned char nBitsPerSample[2];
+   unsigned char data[4];
+   unsigned char pcm_bytes[4];
+}
+BYTE_WAVE;
+
+static const BYTE_WAVE wave =
+{
+   "RIFF",
+   {(sizeof(BYTE_WAVE) - 8), 0, 0, 0},
+   "WAVE",
+   "fmt ",
+   {16, 0, 0, 0},
+   {1, 0},
+   {1, 0},
+   {34, 86, 0, 0},		/* 86 * 256 + 34 = 22050 */
+   {172, 68, 0, 0},		/* 172 * 256 + 68 = 44100 */
+   {2, 0},
+   {16, 0},
+   "data",
+   {0, 0, 0, 0}
+};
+
+/*----------------------------------------------------------------
+  pcm conversion to wave format
+
+  This conversion code required for big endian machine, or,
+  if sizeof(short) != 16 bits.
+  Conversion routines may be used on any machine, but if
+  not required, the do nothing macros in port.h can be used instead
+  to reduce overhead.
+
+-----------------------------------------------------------------*/
+#ifndef LITTLE_SHORT16
+#include "wcvt.c"
+#endif
+/*-----------------------------------------------*/
+#endif
diff --git a/code/mssccprj.scc b/code/mssccprj.scc
new file mode 100644
index 0000000..1329978
--- /dev/null
+++ b/code/mssccprj.scc
@@ -0,0 +1,9 @@
+SCC = This is a Source Code Control file
+
+[JediAcademy.sln]
+SCC_Aux_Path = "\\ravendata1\vss\central_code"
+SCC_Project_Name = "$/jedi/code", ROBAAAAA
+
+[starwars.vcproj]
+SCC_Aux_Path = "\\ravendata1\vss\central_code"
+SCC_Project_Name = "$/jedi/code", ROBAAAAA
diff --git a/code/null/mac_net.c b/code/null/mac_net.c
new file mode 100644
index 0000000..6232aff
--- /dev/null
+++ b/code/null/mac_net.c
@@ -0,0 +1,44 @@
+
+#include "../game/q_shared.h"
+#include "../qcommon/qcommon.h"
+
+/*
+=============
+NET_StringToAdr
+
+localhost
+idnewt
+idnewt:28000
+192.246.40.70
+192.246.40.70:28000
+=============
+*/
+qboolean	NET_StringToAdr (char *s, netadr_t *a)
+{	
+	if (!strcmp (s, "localhost")) {
+		memset (a, 0, sizeof(*a));
+		a->type = NA_LOOPBACK;
+		return true;
+	}
+
+	return false;
+}
+
+/*
+==================
+Sys_SendPacket
+==================
+*/
+void Sys_SendPacket( int length, void *data, netadr_t to ) {
+}
+
+/*
+==================
+Sys_GetPacket
+
+Never called by the game logic, just the system event queing
+==================
+*/
+qboolean	Sys_GetPacket ( netadr_t *net_from, msg_t *net_message ) {
+	return false;
+}
diff --git a/code/null/null_glimp.c b/code/null/null_glimp.c
new file mode 100644
index 0000000..30b84f7
--- /dev/null
+++ b/code/null/null_glimp.c
@@ -0,0 +1,39 @@
+#include "../renderer/tr_local.h"
+
+
+qboolean ( * qwglSwapIntervalEXT)( int interval );
+void ( * qglMultiTexCoord2fARB )( enum texture, float s, float t );
+void ( * qglActiveTextureARB )( enum texture );
+void ( * qglClientActiveTextureARB )( enum texture );
+
+
+void ( * qglLockArraysEXT)( int, int);
+void ( * qglUnlockArraysEXT) ( void );
+
+
+void		GLimp_EndFrame( void ) {
+}
+
+int 		GLimp_Init( void )
+{
+}
+
+void		GLimp_Shutdown( void ) {
+}
+
+rserr_t		GLimp_SetMode( const char *drivername, int *pWidth, int *pHeight, int mode, qboolean fullscreen ) {
+}
+
+
+void		GLimp_EnableLogging( qboolean enable ) {
+}
+
+void GLimp_LogComment( char *comment ) {
+}
+
+qboolean QGL_Init( const char *dllname ) {
+	return true;
+}
+
+void		QGL_Shutdown( void ) {
+}
diff --git a/code/null/null_main.c b/code/null/null_main.c
new file mode 100644
index 0000000..59a5797
--- /dev/null
+++ b/code/null/null_main.c
@@ -0,0 +1,94 @@
+// sys_null.h -- null system driver to aid porting efforts
+
+#include "../qcommon/qcommon.h"
+#include "errno.h"
+
+int			sys_curtime;
+
+
+//===================================================================
+
+void Sys_BeginStreamedFile( fileHandle_t f, int readAhead ) {
+}
+
+void Sys_EndStreamedFile( fileHandle_t f ) {
+}
+
+int Sys_StreamedRead( void *buffer, int size, int count, fileHandle_t f ) {
+	return FS_Read( buffer, size, count, f );
+}
+
+void Sys_StreamSeek( fileHandle_t f, int offset, int origin ) {
+	FS_Seek( f, offset, origin );
+}
+
+
+//===================================================================
+
+
+void Sys_mkdir (char *path) {
+}
+
+void Sys_Error (char *error, ...) {
+	va_list		argptr;
+
+	printf ("Sys_Error: ");	
+	va_start (argptr,error);
+	vprintf (error,argptr);
+	va_end (argptr);
+	printf ("\n");
+
+	exit (1);
+}
+
+void Sys_Quit (void) {
+	exit (0);
+}
+
+void	Sys_UnloadGame (void) {
+}
+
+void	*Sys_GetGameAPI (void *parms) {
+	return NULL;
+}
+
+char *Sys_GetClipboardData( void ) {
+	return NULL;
+}
+
+int		Sys_Milliseconds (void) {
+	return 0;
+}
+
+void	Sys_Mkdir (char *path) {
+}
+
+char	*Sys_FindFirst (char *path, unsigned musthave, unsigned canthave) {
+	return NULL;
+}
+
+char	*Sys_FindNext (unsigned musthave, unsigned canthave) {
+	return NULL;
+}
+
+void	Sys_FindClose (void) {
+}
+
+void	Sys_Init (void) {
+}
+
+
+void	Sys_EarlyOutput( char *string ) {
+	printf( "%s", string );
+}
+
+
+void main (int argc, char **argv) {
+	Com_Init (argc, argv);
+
+	while (1) {
+		Com_Frame( );
+	}
+}
+
+
diff --git a/code/null/null_net.c b/code/null/null_net.c
new file mode 100644
index 0000000..2973a8d
--- /dev/null
+++ b/code/null/null_net.c
@@ -0,0 +1,43 @@
+
+#include "../qcommon/qcommon.h"
+
+/*
+=============
+NET_StringToAdr
+
+localhost
+idnewt
+idnewt:28000
+192.246.40.70
+192.246.40.70:28000
+=============
+*/
+qboolean	NET_StringToAdr (char *s, netadr_t *a)
+{	
+	if (!strcmp (s, "localhost")) {
+		memset (a, 0, sizeof(*a));
+		a->type = NA_LOOPBACK;
+		return true;
+	}
+
+	return false;
+}
+
+/*
+==================
+Sys_SendPacket
+==================
+*/
+void Sys_SendPacket( int length, void *data, netadr_t to ) {
+}
+
+/*
+==================
+Sys_GetPacket
+
+Never called by the game logic, just the system event queing
+==================
+*/
+qboolean	Sys_GetPacket ( netadr_t *net_from, msg_t *net_message ) {
+	return false;
+}
diff --git a/code/null/null_snddma.c b/code/null/null_snddma.c
new file mode 100644
index 0000000..2e5d3d4
--- /dev/null
+++ b/code/null/null_snddma.c
@@ -0,0 +1,27 @@
+
+// snddma_null.c
+// all other sound mixing is portable
+
+#include "../client/client.h"
+
+qboolean SNDDMA_Init(void)
+{
+	return qfalse;
+}
+
+int	SNDDMA_GetDMAPos(void)
+{
+	return 0;
+}
+
+void SNDDMA_Shutdown(void)
+{
+}
+
+void SNDDMA_BeginPainting (void)
+{
+}
+
+void SNDDMA_Submit(void)
+{
+}
diff --git a/code/null/vssver.scc b/code/null/vssver.scc
new file mode 100644
index 0000000..5d84ae8
Binary files /dev/null and b/code/null/vssver.scc differ
diff --git a/code/png/png.cpp b/code/png/png.cpp
new file mode 100644
index 0000000..66d4a47
--- /dev/null
+++ b/code/png/png.cpp
@@ -0,0 +1,783 @@
+// Generic PNG file loading code
+
+// leave this as first line for PCH reasons...
+//
+#include "../game/q_shared.h"
+#include "../qcommon/qcommon.h"
+
+#include "../zlib32/zip.h"
+#include "png.h"
+//#include "../qcommon/memory.h"
+
+// Error returns
+
+#define PNG_ERROR_OK			0
+#define PNG_ERROR_DECOMP		1
+#define PNG_ERROR_COMP			2
+#define PNG_ERROR_MEMORY		3
+#define PNG_ERROR_NOSIG	   		4
+#define PNG_ERROR_TOO_SMALL	   	5
+#define PNG_ERROR_WNP2	   		6
+#define PNG_ERROR_HNP2	   		7
+#define PNG_ERROR_NOT_TC	   	8
+#define PNG_ERROR_INV_FIL	   	9
+#define PNG_ERROR_FAILED_CRC	10
+#define PNG_ERROR_CREATE_FAIL	11
+#define PNG_ERROR_WRITE			12
+#define PNG_ERROR_NOT_PALETTE	13
+#define PNG_ERROR_NOT8BIT		14
+#define PNG_ERROR_TOO_LARGE		15
+
+static int png_error = PNG_ERROR_OK;
+
+static const byte png_signature[8] = { 0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a };
+static const char png_copyright[] = "Copyright\0Raven Software Inc. 2001";
+static const char *png_errors[] = 
+{
+	"OK.",
+	"Error decompressing image data.",
+	"Error compressing image data.",
+	"Error allocating memory.",
+	"PNG signature not found.",
+	"Image is too small to load.",
+	"Width is not a power of two.",
+	"Height is not a power of two.",
+	"Image is not 24 or 32 bit.",
+	"Invalid filter or compression type.",
+	"Failed CRC check.",
+	"Could not create file.",
+	"Error writing to file.",
+	"Image is not indexed colour.",
+	"Image does not have 8 bits per sample.",
+	"Image is too large",
+};
+
+// Gets the error string for a failed PNG operation
+
+const char *PNG_GetError(void)
+{
+	return(png_errors[png_error]);
+}
+
+// Create a header chunk
+
+void PNG_CreateHeader(png_ihdr_t *header, int width, int height, int bytedepth)
+{
+	header->width = BigLong(width);
+	header->height = BigLong(height);
+	header->bitdepth = 8;
+
+	if(bytedepth == 3)
+	{
+		header->colortype = 2;
+	}
+	if(bytedepth == 4)
+	{
+		header->colortype = 6;
+	}
+	header->compression = 0;
+	header->filter = 0;
+	header->interlace = 0;
+}
+
+// Processes the header chunk and checks to see if all the data is valid
+
+bool PNG_HandleIHDR(const byte *data, png_image_t *image)
+{
+	png_ihdr_t *ihdr = (png_ihdr_t *)data;
+
+	image->width = BigLong(ihdr->width);
+	image->height = BigLong(ihdr->height);
+
+	// Make sure image is a reasonable size
+	if((image->width < 2) || (image->height < 2))
+	{
+		png_error = PNG_ERROR_TOO_SMALL;
+		return(false);
+	}
+	if(image->width > MAX_PNG_WIDTH)
+	{
+		png_error = PNG_ERROR_TOO_LARGE;
+		return(false);
+	}
+	if(ihdr->bitdepth != 8)
+	{
+		png_error = PNG_ERROR_NOT8BIT;
+		return(false);
+	}
+	// Check for non power of two size (but not for data files)
+	if(image->isimage)
+	{
+		if(image->width & (image->width - 1))
+		{
+			png_error = PNG_ERROR_WNP2;
+			return(false);
+		}
+		if(image->height & (image->height - 1))
+		{
+			png_error = PNG_ERROR_HNP2;
+			return(false);
+		}
+	}
+	// Make sure we have a 24 or 32 bit image (for images)
+	if(image->isimage)
+	{
+		if((ihdr->colortype != 2) && (ihdr->colortype != 6))
+		{
+			png_error = PNG_ERROR_NOT_TC;
+			return(false);
+		}
+	}
+	// Make sure we have an 8 bit grayscale image for data files
+	if(!image->isimage)
+	{
+		if(ihdr->colortype && (ihdr->colortype != 3))
+		{
+			png_error = PNG_ERROR_NOT_PALETTE;
+			return(false);
+		}
+	}
+	// Make sure we aren't using any wacky compression or filter algos
+	if(ihdr->compression || ihdr->filter)
+	{
+		png_error = PNG_ERROR_INV_FIL;
+		return(false);
+	}
+	// Extract the data we need
+	if(!ihdr->colortype || (ihdr->colortype == 3))
+	{
+		image->bytedepth = 1;
+	}
+	if(ihdr->colortype == 2)
+	{
+		image->bytedepth = 3;
+	}
+	if(ihdr->colortype == 6)
+	{
+		image->bytedepth = 4;
+	}
+	return(true);
+}
+
+// Filter a row of data
+
+void PNG_Filter(byte *out, byte filter, const byte *in, const byte *lastline, ulong rowbytes, ulong bpp)
+{
+	ulong		i;
+
+	switch(filter)
+	{
+	case PNG_FILTER_VALUE_NONE:
+		memcpy(out, in, rowbytes);
+		break;
+	case PNG_FILTER_VALUE_SUB:
+		for(i = 0; i < bpp; i++)
+		{
+			*out++ = *in++;
+		}
+		for(i = bpp; i < rowbytes; i++)
+		{
+			*out++ = *in - *(in - bpp);
+			in++;
+		}
+		break;
+	case PNG_FILTER_VALUE_UP:
+		for(i = 0; i < rowbytes; i++)
+		{
+			if(lastline)
+			{
+				*out++ = *in++ - *lastline++;
+			}
+			else
+			{
+				*out++ = *in++;
+			}
+		}
+		break;
+	case PNG_FILTER_VALUE_AVG:
+		for(i = 0; i < bpp; i++)
+		{
+			if(lastline)
+			{
+				*out++ = *in++ - (*lastline++ >> 1);
+			}
+			else
+			{
+				*out++ = *in++;
+			}
+		}
+		for(i = bpp; i < rowbytes; i++)
+		{
+			if(lastline)
+			{
+				*out++ = *in - ((*lastline++ + *(in - bpp)) >> 1);
+			}
+			else
+			{
+				*out++ = *in - (*(in - bpp) >> 1);
+			}
+			in++;
+		}
+		break;
+	case PNG_FILTER_VALUE_PAETH:
+		int			a, b, c;
+		int			pa, pb, pc, p;
+
+		for(i = 0; i < bpp; i++)
+		{
+			if(lastline)
+			{
+				*out++ = *in++ - *lastline++;
+			}
+			else
+			{
+				*out++ = *in++;
+			}
+		}
+		for(i = bpp; i < rowbytes; i++)
+		{
+			a = *(in - bpp);
+			c = 0;
+			b = 0;
+			if(lastline)
+			{
+				c = *(lastline - bpp);
+				b = *lastline++;
+			}
+
+			p = b - c;
+			pc = a - c;
+
+			pa = p < 0 ? -p : p;
+			pb = pc < 0 ? -pc : pc;
+			pc = (p + pc) < 0 ? -(p + pc) : p + pc;
+
+			p = (pa <= pb && pa <= pc) ? a : (pb <= pc) ? b : c;
+
+			*out++ = *in++ - p;
+		}
+		break;
+	}
+}
+
+// Unfilters a row of data
+
+void PNG_Unfilter(byte *out, byte filter, const byte *lastline, ulong rowbytes, ulong bpp)
+{
+	ulong	i;
+
+	switch(filter)
+	{
+	case PNG_FILTER_VALUE_NONE:
+		break;
+	case PNG_FILTER_VALUE_SUB:
+		out += bpp;
+		for(i = bpp; i < rowbytes; i++)
+		{
+			*out += *(out - bpp);
+			out++;
+		}
+		break;
+	case PNG_FILTER_VALUE_UP:   
+		for(i = 0; i < rowbytes; i++)
+		{
+			if(lastline)
+			{
+				*out += *lastline++;
+			}
+			out++;
+		}
+		break;
+	case PNG_FILTER_VALUE_AVG:  
+		for(i = 0; i < bpp; i++)
+		{
+			if(lastline)
+			{
+				*out += *lastline++ >> 1;
+			}
+			out++;
+		}
+		for(i = bpp; i < rowbytes; i++)
+		{
+			if(lastline)
+			{
+				*out += (*lastline++ + *(out - bpp)) >> 1;
+			}
+			else
+			{
+				*out += *(out - bpp) >> 1;
+			}
+			out++;
+		}
+		break;
+	case PNG_FILTER_VALUE_PAETH:
+		int			a, b, c;
+		int			pa, pb, pc, p;
+
+		for(i = 0; i < bpp; i++)
+		{
+			if(lastline)
+			{
+				*out += *lastline++;
+			}
+			out++;
+		}
+		for(i = bpp; i < rowbytes; i++)
+		{
+			a = *(out - bpp);
+			c = 0;
+			b = 0;
+			if(lastline)
+			{
+				c = *(lastline - bpp);
+				b = *lastline++;
+			}
+			p = b - c;
+			pc = a - c;
+
+			pa = p < 0 ? -p : p;
+			pb = pc < 0 ? -pc : pc;
+			pc = (p + pc) < 0 ? -(p + pc) : p + pc;
+
+			p = (pa <= pb && pa <= pc) ? a : (pb <= pc) ? b : c;
+
+			*out++ += p;
+		}
+		break;
+	default:
+		break;
+	}
+}
+
+// Pack up the image data line by line
+
+bool PNG_Pack(byte *out, ulong *size, ulong maxsize, byte *data, int width, int height, int bytedepth)
+{
+	z_stream		zdata;
+	ulong			rowbytes;
+	ulong			y;
+	const byte		*lastline, *source;
+	// Storage for filter type and filtered row
+	byte			workline[(MAX_PNG_WIDTH * MAX_PNG_DEPTH) + 1];
+
+	// Number of bytes per row
+	rowbytes = width * bytedepth;
+
+	memset(&zdata, 0, sizeof(z_stream));
+	if(deflateInit(&zdata, Z_FAST_COMPRESSION_HIGH) != Z_OK)
+	{
+		png_error = PNG_ERROR_COMP;
+		return(false);
+	}
+
+	zdata.next_out = out;
+	zdata.avail_out = maxsize;
+
+	lastline = NULL;
+	source = data + ((height - 1) * rowbytes);
+	for(y = 0; y < height; y++)
+	{
+		// Refilter using the most compressable filter algo
+		// Assume paeth to speed things up
+		workline[0] = (byte)PNG_FILTER_VALUE_PAETH;
+		PNG_Filter(workline + 1, (byte)PNG_FILTER_VALUE_PAETH, source, lastline, rowbytes, bytedepth);
+
+		zdata.next_in = workline;
+		zdata.avail_in = rowbytes + 1;
+		if(deflate(&zdata, Z_SYNC_FLUSH) != Z_OK)
+		{
+			deflateEnd(&zdata);
+			png_error = PNG_ERROR_COMP;
+			return(false);
+		}
+		lastline = source;
+		source -= rowbytes;
+	}
+	if(deflate(&zdata, Z_FINISH) != Z_STREAM_END)
+	{
+		png_error = PNG_ERROR_COMP;
+		return(false);
+	}
+	*size = zdata.total_out;
+	deflateEnd(&zdata);
+	return(true);
+}
+
+// Unpack the image data, line by line
+
+bool PNG_Unpack(const byte *data, const ulong datasize, png_image_t *image)
+{
+	ulong		rowbytes, zerror, y;
+	byte		filter;
+	z_stream	zdata;
+	byte		*lastline, *out;
+
+//	MD_PushTag(TAG_ZIP_TEMP);
+
+	memset(&zdata, 0, sizeof(z_stream));
+	if(inflateInit(&zdata, Z_SYNC_FLUSH) != Z_OK)
+	{
+		png_error = PNG_ERROR_DECOMP;
+//		MD_PopTag();
+		return(false);
+	}
+	zdata.next_in = (byte *)data;
+	zdata.avail_in = datasize;
+
+	rowbytes = image->width * image->bytedepth;
+
+	lastline = NULL;
+	out = image->data;
+	for(y = 0; y < image->height; y++)
+	{
+		// Inflate a row of data
+		zdata.next_out = &filter;
+		zdata.avail_out = 1;
+		if(inflate(&zdata) != Z_OK)
+		{
+			inflateEnd(&zdata);
+			png_error = PNG_ERROR_DECOMP;
+//			MD_PopTag();
+			return(false);
+		}
+		zdata.next_out = out;
+		zdata.avail_out = rowbytes;
+		zerror = inflate(&zdata);
+		if((zerror != Z_OK) && (zerror != Z_STREAM_END))
+		{
+			inflateEnd(&zdata);
+			png_error = PNG_ERROR_DECOMP;
+//			MD_PopTag();
+			return(false);
+		}
+
+		// Unfilter a row of data
+		PNG_Unfilter(out, filter, lastline, rowbytes, image->bytedepth);
+
+		lastline = out;
+		out += rowbytes;
+	}
+	inflateEnd(&zdata);
+//	MD_PopTag();
+	return(true);
+}
+
+// Scan through all chunks and process each one
+
+bool PNG_Load(const byte *data, ulong datasize, png_image_t *image)
+{
+	bool			moredata;
+	const byte		*next;
+	byte			*workspace, *work;
+	ulong			length, type, crc, totallength;
+
+	png_error = PNG_ERROR_OK;
+
+	if(memcmp(data, png_signature, sizeof(png_signature)))
+	{
+		png_error = PNG_ERROR_NOSIG;
+		return(false);
+	}
+	data += sizeof(png_signature);
+
+	workspace = (byte *)Z_Malloc(datasize, TAG_TEMP_PNG, qfalse);
+	work = workspace;
+	totallength = 0;
+
+	moredata = true;
+	while(moredata)
+	{
+		length = BigLong(*(ulong *)data);
+		data += sizeof(ulong);
+
+		type = BigLong(*(ulong *)data);
+		const byte *crcbase = data;
+		data += sizeof(ulong);
+
+		// CRC checksum location
+		next = data + length + sizeof(ulong);
+
+		// CRC checksum includes header field
+		crc = crc32(0, crcbase, length + sizeof(ulong));
+		if(crc != (ulong)BigLong(*(ulong *)(next - 4)))
+		{
+			if(image->data)
+			{
+				Z_Free(image->data);
+				image->data = NULL;
+			}
+			Z_Free(workspace);
+			png_error = PNG_ERROR_FAILED_CRC;
+			return(false);		
+		}
+		switch(type)
+		{
+		case PNG_IHDR:
+			if(!PNG_HandleIHDR(data, image))
+			{
+				Z_Free(workspace);
+				return(false);
+			}
+			image->data = (byte *)Z_Malloc(image->width * image->height * image->bytedepth, TAG_TEMP_PNG, qfalse);
+			break;
+		case PNG_IDAT:
+			// Need to copy all the various IDAT chunks into one big one
+			// Everything but 3dsmax has one IDAT chunk
+			memcpy(work, data, length);
+			work += length;
+			totallength += length;
+			break;
+		case PNG_IEND:
+			if(!PNG_Unpack(workspace, totallength, image))
+			{
+				Z_Free(workspace);
+				Z_Free(image->data);
+				image->data = NULL;
+				return(false);
+			}
+			moredata = false;
+			break;
+		default:
+			break;
+		}
+		data = next;
+	}
+	Z_Free(workspace);
+	return(true);
+}
+
+// Outputs a crc'd chunk of PNG data
+
+bool PNG_OutputChunk(fileHandle_t fp, ulong type, byte *data, ulong size)
+{
+	ulong	crc, little, outcount;
+
+	// Output a standard PNG chunk - length, type, data, crc
+	little = BigLong(size);
+	outcount = FS_Write(&little, sizeof(little), fp);
+
+	little = BigLong(type);
+	crc = crc32(0, (byte *)&little, sizeof(little));
+	outcount += FS_Write(&little, sizeof(little), fp);
+
+	if(size)
+	{
+		crc = crc32(crc, data, size);
+		outcount += FS_Write(data, size, fp);
+	}
+
+	little = BigLong(crc);
+	outcount += FS_Write(&little, sizeof(little), fp);
+
+	if(outcount != (size + 12))
+	{
+		png_error = PNG_ERROR_WRITE;
+		return(false);
+	}
+	return(true);
+}
+
+// Saves a PNG format compressed image
+
+bool PNG_Save(const char *name, byte *data, int width, int height, int bytedepth)
+{
+	byte			*work;
+	fileHandle_t	fp;
+	int				maxsize;
+	ulong			size, outcount;
+	png_ihdr_t		png_header;
+
+	png_error = PNG_ERROR_OK;
+
+	// Create the file
+	fp = FS_FOpenFileWrite(name);
+	if(!fp)
+	{
+		png_error = PNG_ERROR_CREATE_FAIL;
+		return(false);
+	}
+	// Write out the PNG signature
+	outcount = FS_Write(png_signature, sizeof(png_signature), fp);
+	if(outcount != sizeof(png_signature))
+	{
+		FS_FCloseFile(fp);
+		png_error = PNG_ERROR_WRITE;
+		return(false);
+	}
+	// Create and output a valid header
+	PNG_CreateHeader(&png_header, width, height, bytedepth);
+	if(!PNG_OutputChunk(fp, PNG_IHDR, (byte *)&png_header, sizeof(png_header)))
+	{
+		FS_FCloseFile(fp);
+		return(false);
+	}
+	// Create and output the copyright info
+ 	if(!PNG_OutputChunk(fp, PNG_tEXt, (byte *)png_copyright, sizeof(png_copyright)))
+	{
+		FS_FCloseFile(fp);
+		return(false);
+	}
+	// Max size of compressed image (source size + 0.1% + 12)
+	maxsize = (width * height * bytedepth) + 4096;
+	work = (byte *)Z_Malloc(maxsize, TAG_TEMP_PNG, qtrue);	// fixme: optimise to qfalse sometime - ok?
+  
+	// Pack up the image data
+	if(!PNG_Pack(work, &size, maxsize, data, width, height, bytedepth))
+	{
+		Z_Free(work);
+		FS_FCloseFile(fp);
+		return(false);
+	}
+	// Write out the compressed image data
+	if(!PNG_OutputChunk(fp, PNG_IDAT, (byte *)work, size))
+	{
+		Z_Free(work);
+		FS_FCloseFile(fp);
+		return(false);
+	}
+	Z_Free(work);
+	// Output terminating chunk
+	if(!PNG_OutputChunk(fp, PNG_IEND, NULL, 0))
+	{
+		FS_FCloseFile(fp);
+		return(false);
+	}
+	FS_FCloseFile(fp);
+	return(true);
+}
+
+/*
+=============
+PNG_ConvertTo32
+=============
+*/
+
+void PNG_ConvertTo32(png_image_t *image)
+{
+	byte	*temp;
+	byte	*old, *old2;
+	ulong	i;
+
+	temp = (byte *)Z_Malloc(image->width * image->height * 4, TAG_TEMP_PNG, qtrue);
+	old = image->data;
+	old2 = old;
+	image->data = temp;
+	image->bytedepth = 4;
+
+	for(i = 0; i < image->width * image->height; i++)
+	{
+		*temp++ = *old++;
+		*temp++ = *old++;
+		*temp++ = *old++;
+		*temp++ = 0xff;
+	}
+	Z_Free(old2);
+}
+
+/*
+=============
+LoadPNG32
+=============
+*/
+bool LoadPNG32 (char *name, byte **pixels, int *width, int *height, int *bytedepth)
+{
+	byte		*buffer;
+	byte		**bufferptr = &buffer;
+	int			nLen;
+	png_image_t	png_image;
+
+	if(!pixels)
+	{
+		bufferptr = NULL;
+	}
+	nLen = FS_ReadFile ( ( char * ) name, (void **)bufferptr);
+	if (nLen == -1) 
+	{
+		if(pixels)
+		{
+			*pixels = NULL;
+		}
+		return(false);
+	}
+	if(!pixels)
+	{
+		return(true);
+	}
+	*pixels = NULL;
+	png_image.isimage = true;
+	if(!PNG_Load(buffer, nLen, &png_image))
+	{
+		Com_Printf ("Error parsing %s: %s\n", name, PNG_GetError());
+		return(false);
+	}
+	if(png_image.bytedepth != 4)
+	{
+		PNG_ConvertTo32(&png_image);
+	}
+	*pixels = png_image.data;
+	if(width)
+	{
+		*width = png_image.width;
+	}
+	if(height)
+	{
+		*height = png_image.height;
+	}
+	if(bytedepth)
+	{
+		*bytedepth = png_image.bytedepth;
+	}
+	FS_FreeFile(buffer);
+	return(true);
+}
+
+/*
+=============
+LoadPNG8
+=============
+*/
+bool LoadPNG8 (char *name, byte **pixels, int *width, int *height)
+{
+	byte		*buffer;
+	byte		**bufferptr = &buffer;
+	int			nLen;
+	png_image_t	png_image;
+
+	if(!pixels)
+	{
+		bufferptr = NULL;
+	}
+	nLen = FS_ReadFile ( ( char * ) name, (void **)bufferptr);
+	if (nLen == -1) 
+	{
+		if(pixels)
+		{
+			*pixels = NULL;
+		}
+		return(false);
+	}
+	if(!pixels)
+	{
+		return(true);
+	}
+	*pixels = NULL;
+	png_image.isimage = false;
+	if(!PNG_Load(buffer, nLen, &png_image))
+	{
+		Com_Printf ("Error parsing %s: %s\n", name, PNG_GetError());
+		return(false);
+	}
+	*pixels = png_image.data;
+	if(width)
+	{
+		*width = png_image.width;
+	}
+	if(height)
+	{
+		*height = png_image.height;
+	}
+	FS_FreeFile(buffer);
+	return(true);
+}
+
+// end
\ No newline at end of file
diff --git a/code/png/png.h b/code/png/png.h
new file mode 100644
index 0000000..7a3580a
--- /dev/null
+++ b/code/png/png.h
@@ -0,0 +1,73 @@
+// Known chunk types
+
+#define PNG_IHDR		'IHDR'
+#define PNG_IDAT		'IDAT' 
+#define PNG_IEND 		'IEND'
+#define PNG_tEXt 		'tEXt'
+
+#define PNG_PLTE 		'PLTE'
+#define PNG_bKGD 		'bKGD'
+#define PNG_cHRM 		'cHRM'
+#define PNG_gAMA 		'gAMA'
+#define PNG_hIST 		'hIST'
+#define PNG_iCCP 		'iCCP'
+#define PNG_iTXt 		'iTXt'
+#define PNG_oFFs 		'oFFs'
+#define PNG_pCAL 		'pCAL'
+#define PNG_sCAL 		'sCAL'
+#define PNG_pHYs 		'pHYs'
+#define PNG_sBIT 		'sBIT'
+#define PNG_sPLT 		'sPLT'
+#define PNG_sRGB 		'sRGB'
+#define PNG_tIME 		'tIME'
+#define PNG_tRNS 		'tRNS'
+#define PNG_zTXt 		'zTXt'
+
+// Filter values 
+
+#define PNG_FILTER_VALUE_NONE	0
+#define PNG_FILTER_VALUE_SUB	1
+#define PNG_FILTER_VALUE_UP		2
+#define PNG_FILTER_VALUE_AVG	3
+#define PNG_FILTER_VALUE_PAETH	4
+#define PNG_FILTER_NUM			5
+
+// Common defines and typedefs
+
+#define MAX_PNG_WIDTH			4096
+#define MAX_PNG_DEPTH			4
+
+typedef unsigned char	byte;
+typedef unsigned short	word;
+typedef unsigned long	ulong;
+
+#pragma pack(push)
+#pragma pack(1)
+
+typedef struct png_ihdr_s
+{
+	ulong			width;
+	ulong			height;
+	byte			bitdepth;			// Bits per sample (not per pixel)
+	byte			colortype;			// bit 0 - palette; bit 1 - RGB; bit 2 - alpha channel
+	byte			compression;		// 0 for zip - error otherwise
+	byte			filter;				// 0 for adaptive with the 5 basic types - error otherwise
+	byte			interlace;			// 0 for no interlace - 1 for Adam7 interlace
+} png_ihdr_t;
+
+#pragma pack(pop)
+
+typedef struct png_image_s
+{
+	byte			*data;
+	ulong			width;
+	ulong			height;
+	ulong			bytedepth;
+	bool			isimage;
+} png_image_t;
+
+bool LoadPNG32 (char *name, byte **pixels, int *width, int *height, int *bytedepth);
+bool LoadPNG8 (char *name, byte **pixels, int *width, int *height);
+bool PNG_Save(const char *name, byte *data, int width, int height, int bytedepth);
+
+// end
\ No newline at end of file
diff --git a/code/png/vssver.scc b/code/png/vssver.scc
new file mode 100644
index 0000000..02b04cc
Binary files /dev/null and b/code/png/vssver.scc differ
diff --git a/code/qcommon/MiniHeap.h b/code/qcommon/MiniHeap.h
new file mode 100644
index 0000000..1ce0315
--- /dev/null
+++ b/code/qcommon/MiniHeap.h
@@ -0,0 +1,67 @@
+#if !defined(MINIHEAP_H_INC)
+#define MINIHEAP_H_INC
+
+
+class CMiniHeap
+{
+	char	*mHeap;
+	char	*mCurrentHeap;
+	int		mSize;
+#if _DEBUG
+	int		mMaxAlloc;
+#endif
+public:
+
+// reset the heap back to the start
+void ResetHeap()
+{
+#if _DEBUG
+	if ((int)mCurrentHeap - (int)mHeap>mMaxAlloc)
+	{
+		mMaxAlloc=(int)mCurrentHeap - (int)mHeap;
+	}
+#endif
+	mCurrentHeap = mHeap;
+}
+
+// initialise the heap
+CMiniHeap(int size)
+{
+	mHeap = (char *)Z_Malloc(size, TAG_GHOUL2, qtrue);
+	mSize = size;
+#if _DEBUG
+	mMaxAlloc=0;
+#endif
+	if (mHeap)
+	{
+		ResetHeap();
+	}
+}
+
+// free up the heap
+~CMiniHeap()
+{
+	if (mHeap)
+	{
+		// the quake heap will be long gone, no need to free it Z_Free(mHeap);
+	}
+}
+
+// give me some space from the heap please
+char *MiniHeapAlloc(int size)
+{
+	if (size < (mSize - ((int)mCurrentHeap - (int)mHeap)))
+	{
+		char *tempAddress =  mCurrentHeap;
+		mCurrentHeap += size;
+		return tempAddress;
+	}
+	return NULL;
+}
+
+};
+
+extern CMiniHeap *G2VertSpaceServer;
+
+
+#endif	//MINIHEAP_H_INC
diff --git a/code/qcommon/chash.h b/code/qcommon/chash.h
new file mode 100644
index 0000000..a531f8c
--- /dev/null
+++ b/code/qcommon/chash.h
@@ -0,0 +1,162 @@
+// Notes
+// Make sure extension is stripped if it needs to be
+
+// Template class must have
+// 1. A GetName() accessor - a null terminated string case insensitive
+// 2. A Destroy() function - normally "delete this"
+// 3. SetNext(T *) and T *GetNext() functions
+
+#define HASH_SIZE	1024
+
+template <class T, int TSize = HASH_SIZE, int (*TCompare)(const char *, const char *) = &strcmp>
+
+class CHash
+{
+private:
+	T		*mHashTable[TSize];
+	T		*mNext;
+	int		mCount;
+	T		*mPrevious;					// Internal work variable
+	long	mHash;						// Internal work variable
+
+	// Creates the hash value and sets the mHash member
+	void CreateHash(const char *key)
+	{
+		int		i = 0;
+		char	letter;
+
+		mHash = 0;
+		letter = *key++;
+		while (letter)
+		{
+			mHash += (long)(letter) * (i + 119);
+
+			i++;
+			letter = *key++;
+		}
+		mHash &= TSize - 1;
+	}
+public:
+	// Constructor
+	CHash(void)
+	{
+		memset(mHashTable, NULL, sizeof(mHashTable));
+		mNext = NULL;
+		mCount = 0;
+		mPrevious = NULL;
+		mHash = 0;
+	}
+	// Destructor
+	~CHash(void)
+	{
+#ifdef _DEBUG
+//		Com_OPrintf("Shutting down %s hash table .....", typeid(T).name());
+#endif
+		clear();
+#ifdef _DEBUG
+//		Com_OPrintf(" done\n");
+#endif
+	}
+	// Returns the total number of entries in the hash table
+	int count(void) const { return(mCount); }
+
+	// Inserts an item into the hash table
+	void insert(T *item)
+	{
+		CreateHash(item->GetName());
+		item->SetNext(mHashTable[mHash]);
+		mHashTable[mHash] = item;
+		mCount++;
+	}
+	// Finds an item in the hash table (sets the mPrevious member)
+	T *find(const char *key)
+	{
+		CreateHash(key);
+		T *item = mHashTable[mHash];
+		mPrevious = NULL;
+		while(item)
+		{
+			mNext = item->GetNext();
+			if(!TCompare(item->GetName(), key))
+			{
+				return(item);
+			}
+			mPrevious = item;
+			item = mNext;
+		}
+		return(NULL);
+	}
+	// Remove item from the hash table referenced by key
+	bool remove(const char *key)
+	{
+		T *item = find(key);
+		if(item)
+		{
+			T *next = item->GetNext();
+			if(mPrevious)
+			{
+				mPrevious->SetNext(next);
+			}
+			else
+			{
+				mHashTable[mHash] = next;
+			}
+			item->Destroy();
+			mCount--;
+			return(true);
+		}
+		return(false);
+	}
+	// Remove item from hash referenced by item
+	bool remove(T *item)
+	{
+		return(remove(item->GetName()));
+	}
+	// Returns the first valid entry
+	T *head(void)
+	{
+		mHash = -1;
+		mNext = NULL;
+		return(next());
+	}
+	// Returns the next entry in the hash table
+	T *next(void)
+	{
+		T *item;
+
+		assert(mHash < TSize);
+
+		if(mNext)
+		{
+			item = mNext;
+			mNext = item->GetNext();
+			return(item);
+		}
+		mHash++;
+
+		for( ; mHash < TSize; mHash++)
+		{
+			item = mHashTable[mHash];
+			if(item)
+			{
+				mNext = item->GetNext();
+				return(item);
+			}
+		}
+		return(NULL);
+	}
+	// Destroy all entries in the hash table
+	void clear(void)
+	{
+		T *item = head();
+		while(item)
+		{
+			remove(item);
+			item = next();
+		}
+	}
+	// Override the [] operator
+	T *operator[](const char *key) { return(find(key)); }
+};
+
+// end
\ No newline at end of file
diff --git a/code/qcommon/cm_draw.cpp b/code/qcommon/cm_draw.cpp
new file mode 100644
index 0000000..29d6bb0
--- /dev/null
+++ b/code/qcommon/cm_draw.cpp
@@ -0,0 +1,1488 @@
+///////////////////////////////////////////////////////////////////////////////
+// CDraw32 Class Implementation
+//
+// Basic drawing routines for 32-bit buffer
+///////////////////////////////////////////////////////////////////////////////
+#include "../server/exe_headers.h"
+
+#include "cm_local.h"
+#include "cm_draw.h"
+
+
+///////////// statics for CDraw32 //////////////////////////////////
+// Used by all drawing routines as the "current" drawing context
+CPixel32* CDraw32::buffer = NULL; 	// pointer to 32-bit deep pixel buffer
+long	CDraw32::buf_width=0;		// width of buffer in pixels
+long	CDraw32::buf_height=0;		// height of buffer in pixels
+long	CDraw32::stride = 0;		// stride in pixels
+long	CDraw32::clip_min_x=0;		// clip bounds
+long	CDraw32::clip_min_y=0;		// clip bounds
+long	CDraw32::clip_max_x=0;		// clip bounds
+long	CDraw32::clip_max_y=0;		// clip bounds
+long*	CDraw32::row_off = NULL;	// Table for quick Y calculations
+
+CDraw32::CDraw32() 
+//USE:	constructor
+{
+}
+
+CDraw32::~CDraw32()
+//USE:	Destructor
+{
+}
+
+int	imgKernel[5][5] = 
+{
+	{-1,-1,-1,-1, 0},
+	{-1,-1,-1, 0, 1},
+	{-1,-1, 0, 1, 1},
+	{-1, 0, 1, 1, 1},
+	{ 0, 1, 1, 1, 1}
+};
+
+const int KWIDTH = 2;
+
+void CDraw32::Emboss(long dstX, long dstY, long width, long height, 
+					 CPixel32* clrImage, long clrX, long clrY, long clrStride)
+{
+	CPixel32 	*dst;
+	CPixel32 	*clr;
+	int			x,y,i,j;
+	int			dstNextLine;
+	int			clrNextLine;
+
+	assert(buffer != NULL);
+
+	BlitClip(dstX, dstY, width, height, clrX, clrY);
+
+	if (width < 1 || height < 1)
+		return;
+
+	dst = &buffer[PIXPOS(dstX,dstY,stride)];
+	clr = &clrImage[PIXPOS(clrX,clrY,clrStride)];
+
+	dstNextLine = (stride - width);
+	clrNextLine = (clrStride - width);
+
+	for (y = 0; y < height; y++)
+	{
+		for (x = 0; x < width; x++)
+		{
+			int accum = 0;
+			for (j = -KWIDTH; j<=KWIDTH; j++)
+				for (i = -KWIDTH; i<=KWIDTH; i++)
+				{
+					int xk = CLAMP(x + i, clrX, clrX+width-1);
+					int yk = CLAMP(y + j, clrY, clrY+height-1);
+					accum += clrImage[PIXPOS(xk,yk,clrStride)].a * imgKernel[j+KWIDTH][i+KWIDTH];
+				}
+			*dst = LIGHT_PIX(*clr, accum);
+			dst->a = 255;
+			++dst;
+			++clr;
+		}
+		dst += dstNextLine;
+		clr += clrNextLine;
+	}
+
+
+}
+
+bool CDraw32::SetBufferSize(long width,long height,long stride_len)
+//USE:	setup for a particular size drawing buffer
+//			(do not re-setup if buffer size has not changed)
+//IN:		width,height	- size of buffer
+//			stride_len		- distance to next line
+//OUT:	true if everything goes OK, otherwise false
+{
+	long		i;
+
+	assert(width!=0);
+	assert(height!=0);
+	assert(stride_len!=0);
+
+	if (buf_width != width || buf_height != height ||
+		  stride_len != stride)
+	{	// need to re-create row_off table
+		buf_width  = width;
+		buf_height = height;
+		stride = stride_len;
+
+		if (row_off)
+  			delete [] row_off;
+
+		// row offsets used for quick pixel address calcs
+		row_off = new long[height];
+
+		assert(row_off != NULL);
+		if (row_off == NULL)
+			return false;
+
+		// table for quick pixel lookups
+		for (i=0; i<height; i++)
+			row_off[i] = i * stride;
+	}
+	// set default clip bounds
+	SetClip(0, 0, width-1, height-1);
+
+	return true;
+}
+
+void CDraw32::ClearLines(CPixel32 color,long start,long end)
+//USE:	clear screen buffer to color provided for lines
+//IN:		color	 				- 32-bit color value
+//			start through end		- line numbers
+//OUT:	none
+{
+	CPixel32 	*dest;
+	int			line,i,next_line;
+
+	assert(buffer!=NULL);
+	assert(start>=0);
+	assert(end<buf_height);
+
+	dest = &buffer[row_off[start]];
+
+	next_line = stride - buf_width;
+	line = end - start + 1;
+
+	while (line-- != 0)
+	{	 // very simple-minded fill loop
+		i = buf_width;
+		while (i--)
+			*dest++ = color;
+		dest += next_line;
+	}
+}
+
+void CDraw32::SetAlphaLines(byte alpha,long start,long end)
+//USE:	set the alpha value only
+//IN:		alpha	 				- 8-bit alpha value
+//			start through end		- line numbers
+//OUT:	none
+{
+	CPixel32 	*dest;
+	int			line,i,next_line;
+
+	assert(buffer!=NULL);
+	assert(start>=0);
+	assert(end<buf_height);
+
+	dest = &buffer[row_off[start]];
+
+	next_line = stride - buf_width;
+	line = end - start + 1;
+
+	while (line-- != 0)
+	{	 // very simple-minded fill loop
+		i = buf_width;
+		while (i--)
+		{
+			dest->a = alpha;
+			++dest;
+		}
+		dest += next_line;
+	}
+}
+
+#define LEFT   1 // code bits
+#define RIGHT  2
+#define TOP    4
+#define BOTTOM 8
+
+static long code(long x,long y)
+//USE:	determines where a point is in relation to a bounding box
+//IN:		x,y		- coordinate pair
+//OUT:	clipping code compaired to global clip context
+{
+	long c;
+
+	c = 0;
+	if (x < CDraw32::clip_min_x) c |= LEFT;
+	if (x > CDraw32::clip_max_x) c |= RIGHT;
+	if (y < CDraw32::clip_min_y) c |= BOTTOM;
+	if (y > CDraw32::clip_max_y) c |= TOP;
+
+	return c;
+}
+
+bool CDraw32::ClipLine(long& x1, long& y1, long& x2, long& y2)
+//USE:	clip a line from (x1,y1) to (x2,y2) to clip bounds
+//IN:		(x1,y1)-(x2,y2) line
+//OUT:	return true if something left to draw, otherwise false
+{
+	long c1,c2,c,x,y,f;
+	x = x1;
+	y = y1;
+
+	c1 = code(x1,y1); // find where first pt. is
+	c2 = code(x2,y2); // find where second pt. is
+
+	if ((c1 & c2) == 0)
+  	{   // the line may be visible
+	  	while (c1 | c2)
+    	{   // where there is 2D clipping to be done
+	    	if (c1 & c2)
+			{
+				return false;  // if both on same side, quit
+			}
+
+			c = c1;
+    		if (c==0)
+			{
+				c = c2; // pick a point
+			}
+
+	    	if (c & TOP)
+		  	{
+      			f = ((clip_max_y-y1) << 15)/(y2-y1);
+		      	x = x1 + (((x2-x1)*f + 16384) >> 15);
+      			y = clip_max_y;
+	      	}
+			else if (c & BOTTOM)
+      		{
+	      		f = ((clip_min_y-y1) << 15)/(y2-y1);
+		  		x = x1 + (((x2-x1)*f + 16384) >> 15);
+      			y = clip_min_y;
+      		}
+	      	else if (c & LEFT)
+       		{
+	     		f = ((clip_min_x-x1) << 15)/(x2-x1);
+    	 		y = y1 + (((y2-y1)*f + 16384) >> 15);
+       			x = clip_min_x;
+       		}
+      		else if (c & RIGHT)
+   			{
+       			f = ((clip_max_x-x1) << 15)/(x2-x1);
+   	   			y = y1 + (((y2-y1)*f + 16384) >> 15);
+       			x = clip_max_x;
+   			}
+	    	if (c==c1)
+		  	{
+				x1=x; y1=y; c1=code(x1,y1);
+			}
+    		else
+	      	{
+				x2=x; y2=y; c2=code(x2,y2);
+			}
+    	} // while still needs clipping
+  	}
+	else
+	{	// line not visible
+  		return false;
+	}
+	return true;
+}
+
+void CDraw32::DrawLineNC(long x1, long y1, long x2, long y2, CPixel32 color)
+//USE:	draw a line from (x1,y1) to (x2,y2) in color (no clip)
+//IN:		(x1,y1)			- starting coordinate
+//			(x2,y2)			- ending coordinate
+//			color			- 32-bit color value
+//OUT:	none
+{
+	long		d, ax, ay, sx, sy, dx, dy;
+	CPixel32*	dest;
+
+	assert(buffer != NULL);
+
+	dx = x2-x1;
+	ax = ABS(dx) << 1;
+	sx = SIGN(dx);
+	dy = y2-y1;
+	ay = ABS(dy) << 1;
+	sy = SIGN(dy);
+
+	if (255 == color.a)
+	{
+		if (dy == 0)
+		{ // horz line
+			if (dx >= 0)
+			{
+				dest = &buffer[row_off[y1] + x1];
+				int i = dx+1;
+				while (i--)
+					*dest++ = color;
+			}
+			else
+			{
+				dest = &buffer[row_off[y1] + x1 + dx];
+				int i = -dx+1;
+				while (i--)
+					*dest++ = color;
+			}
+			return;
+		}
+
+		if (dx == 0)
+		{ // vert line
+			if (dy >= 0)
+			{
+				dest = &buffer[row_off[y1] + x1];
+				dy++;
+			}
+			else
+			{
+				dest = &buffer[row_off[y2] + x1];
+				dy = -dy + 1;
+			}
+
+			while (dy-- != 0)
+			{
+				*dest = color;
+				dest += stride;
+			}
+			return;
+		}
+	}
+
+	// bressenham's algorithm
+	if (ax > ay)
+	{
+		d = ay - (ax >> 1);
+		while(x1 != x2)
+   		{
+			PutPixAlphaNC(x1,y1,color);
+
+	    	if (d >= 0)
+    		{
+		   		y1 += sy;
+    			d  -= ax;
+    		}
+	    	x1 += sx;
+			d  += ay;
+   		}
+	}
+	else
+	{
+		d = ax - (ay >> 1);
+		while(y1 != y2)
+    	{
+			PutPixAlphaNC(x1,y1,color);
+			if (d >= 0)
+    		{
+    			x1 += sx;
+    			d  -= ay;
+    		}
+	    	y1 += sy;
+			d  += ax;
+    	}
+	}
+	PutPixAlphaNC(x1,y1,color);
+}
+
+void CDraw32::DrawLineAveNC(long x1, long y1, long x2, long y2, CPixel32 color)
+//USE:	draw a translucent line from (x1,y1) to (x2,y2) in color (no clip)
+//IN:		(x1,y1)			- starting coordinate
+//			(x2,y2)			- ending coordinate
+//			color 			- 32-bit color value
+//OUT:	none
+{
+	long		d, ax, ay, sx, sy, dx, dy;
+	CPixel32*	dest;
+
+	assert(buffer != NULL);
+
+	dx = x2-x1;
+	ax = ABS(dx) << 1;
+	sx = SIGN(dx);
+	dy = y2-y1;
+	ay = ABS(dy) << 1;
+	sy = SIGN(dy);
+
+	if (dy == 0)
+	{ // horz line
+		if (dx >= 0)
+		{
+			dest = &buffer[row_off[y1] + x1];
+			int i = dx+1;
+			while (i--)
+				*dest++ = AVE_PIX(*dest, color);
+		}
+		else
+		{
+			dest = &buffer[row_off[y1] + x1 + dx];
+			int i = -dx+1;
+			while (i--)
+				*dest++ = AVE_PIX(*dest, color);
+		}
+		return;
+	}
+
+	if (dx == 0)
+	{ // vert line
+		if (dy >= 0)
+		{
+			dest = &buffer[row_off[y1] + x1];
+			dy++;
+		}
+		else
+		{
+			dest = &buffer[row_off[y2] + x1];
+			dy = -dy + 1;
+		}
+
+		while (dy-- != 0)
+		{
+			*dest = AVE_PIX(*dest, color);
+			dest += stride;
+		}
+		return;
+	}
+
+	// bressenham's algorithm
+	if (ax > ay)
+	{
+		d = ay - (ax >> 1);
+		while(x1 != x2)
+   		{
+			PutPixAveNC(x1,y1,color);
+
+	    	if (d >= 0)
+    		{
+		   		y1 += sy;
+    			d  -= ax;
+    		}
+	    	x1 += sx;
+			d  += ay;
+   		}
+	}
+	else
+	{
+		d = ax - (ay >> 1);
+		while(y1 != y2)
+    	{
+			PutPixAveNC(x1,y1,color);
+			if (d >= 0)
+    		{
+    			x1 += sx;
+    			d  -= ay;
+    		}
+	    	y1 += sy;
+			d  += ax;
+    	}
+	}
+	PutPixAveNC(x1,y1,color);
+}
+
+void CDraw32::DrawLineAANC(long x0, long y0, long x1, long y1, CPixel32 color)
+// Wu antialiased line drawer.
+//USE:	Function to draw an antialiased line from (x0,y0) to (x1,y1), using an
+//			antialiasing approach published by Xiaolin Wu in the July 1991 issue of
+//			Computer Graphics (SIGGRAPH proceedings). 
+//
+//IN:		(x0,y0),(x1,y1) = line to draw
+//			color = 32-bit color
+//OUT:	none
+{
+	assert(buffer != NULL);
+
+	// Make sure the line runs top to bottom 
+	if (y0 > y1) 
+	{
+		SWAP(y0,y1);
+		SWAP(x0,x1);
+	}
+
+	long	DeltaX = x1 - x0;
+	long	DeltaY = y1 - y0;
+	long	XDir;
+
+	// Draw the initial pixel, which is always exactly intersected by
+ 	// the line and so needs no Alpha 
+	PutPixAlphaNC(x0, y0, color);
+
+	if (DeltaX >= 0) 
+	{
+ 		XDir = 1;
+	} 
+	else 
+	{
+ 		XDir = -1;
+ 		DeltaX = -DeltaX; // make DeltaX positive 
+	}
+
+	// Special-case horizontal, vertical, and diagonal lines, which
+ 	//	require no Alpha because they go right through the center of
+ 	//	every pixel 
+	if (DeltaY == 0) 
+	{	// Horizontal line 
+ 		while (DeltaX-- != 0) 
+		{
+ 			x0 += XDir;
+			PutPixAlphaNC(x0, y0, color);
+		}
+ 		return;
+	}
+	if (DeltaX == 0) 
+	{	// Vertical line 
+ 		do 
+		{
+ 			y0++;
+			PutPixAlphaNC(x0, y0, color);
+		} 
+		while (--DeltaY != 0);
+ 		return;
+	}
+	if (DeltaX == DeltaY) 
+	{	// Diagonal line 
+ 		do 
+		{
+ 			x0 += XDir;
+ 			y0++;
+			PutPixAlphaNC(x0, y0, color);
+ 		}
+		while (--DeltaY != 0);
+ 		return;
+	}
+
+	// Line is not horizontal, diagonal, or vertical 
+	unsigned short ErrorAcc = 0;  // initialize the line error accumulator to 0 
+
+	// # of bits by which to shift ErrorAcc to get intensity level 
+	const unsigned long	IntensityShift = 16 - 8;
+	
+	// Is this an X-major or Y-major line? 
+	if (DeltaY > DeltaX) 
+	{
+ 		// Y-major line; calculate 16-bit fixed-point fractional part of a
+ 		// pixel that X advances each time Y advances 1 pixel, truncating the
+ 		// result so that we won't overrun the endpoint along the X axis 
+ 		unsigned short	ErrorAdj = unsigned short 
+				(((unsigned long) DeltaX << 16) / (unsigned long) DeltaY);
+
+ 		// Draw all pixels other than the first and last 
+ 		while (--DeltaY) 
+		{
+ 			unsigned short	ErrorAccTemp = ErrorAcc;   // remember currrent accumulated error 
+ 			ErrorAcc += ErrorAdj;      // calculate error for next pixel 
+ 			if (ErrorAcc <= ErrorAccTemp) 
+			{	// The error accumulator turned over, so advance the X coord 
+ 				x0 += XDir;
+			}
+ 			y0++; // Y-major, so always advance Y 
+ 			// The IntensityBits most significant bits of ErrorAcc give us the
+ 			// intensity Alpha for this pixel, and the complement of the
+ 			// Alpha for the paired pixel 
+ 			unsigned long	Alpha = ErrorAcc >> IntensityShift;
+			unsigned long	InvAlpha = 256-Alpha;
+
+			PutPixAlphaNC(x0, y0, 
+				ALPHA_PIX(GetPix(x0, y0), color, Alpha, InvAlpha));
+			PutPixAlphaNC(x0+XDir, y0, 
+				ALPHA_PIX(GetPix(x0+XDir, y0), color, InvAlpha, Alpha));
+ 		}
+ 		// Draw the final pixel, which is always exactly intersected by the line
+ 		// and so needs no Alpha 
+		PutPixAlphaNC(x1, y1, color);
+ 		return;
+	}
+	// It's an X-major line; calculate 16-bit fixed-point fractional part of a
+ 	// pixel that Y advances each time X advances 1 pixel, truncating the
+ 	// result to avoid overrunning the endpoint along the X axis 
+	unsigned short	ErrorAdj = unsigned short 
+		(((unsigned long) DeltaY << 16) / (unsigned long) DeltaX);
+	// Draw all pixels other than the first and last 
+	while (--DeltaX) 
+	{
+ 		unsigned short	ErrorAccTemp = ErrorAcc;   // remember currrent accumulated error 
+ 		ErrorAcc += ErrorAdj;      // calculate error for next pixel 
+ 		if (ErrorAcc <= ErrorAccTemp) 
+		{	// The error accumulator turned over, so advance the Y coord 
+ 			y0++;
+		}
+ 		x0 += XDir; // X-major, so always advance X 
+ 		// The IntensityBits most significant bits of ErrorAcc give us the
+ 		// intensity Alpha for this pixel, and the complement of the
+ 		// Alpha for the paired pixel 
+ 		unsigned long	Alpha = ErrorAcc >> IntensityShift;
+		unsigned long	InvAlpha = 256-Alpha;
+		PutPixAlphaNC(x0, y0, 
+			ALPHA_PIX(GetPix(x0, y0), color, Alpha, InvAlpha));
+		PutPixAlphaNC(x0, y0+1, 
+			ALPHA_PIX(GetPix(x0, y0+1), color, InvAlpha, Alpha));
+	}
+	// Draw the final pixel, which is always exactly intersected by the line
+ 	// and so needs no Alpha 
+	PutPixAlphaNC(x1, y1, color);
+}
+
+void CDraw32::DrawRectNC(long ulx, long uly, long width, long height, CPixel32 color)
+//USE:	draw rectangle in solid color, no clipping
+//IN:		(ulx,uly)			- coordinates of upper-left corner of rect
+//			width, height		- dimensions of rectangle
+//			color				- color value
+//OUT:	none
+{
+
+	assert(buffer != NULL);
+	assert(ulx>=0);
+	assert(uly>=0);
+	assert(ulx+width<buf_width);
+	assert(uly+height<buf_height);
+
+	if (height < 1 || width < 1)
+		return;
+
+	while (height-- != 0)
+	{
+		DrawLineNC(ulx, uly, ulx+width-1, uly, color);
+		uly++;
+	}
+}
+
+void CDraw32::DrawRect(long ulx, long uly, long width, long height, CPixel32 color)
+//USE:	draw rectangle in solid color
+//IN:		(ulx,uly)			- coordinates of upper-left corner of rect
+//			width, height		- dimensions of rectangle
+//			color				- color value
+//OUT:	none
+{
+	assert(buffer != NULL);
+
+	if (height < 1 || width < 1)
+		return;
+
+	while (height-- != 0)
+	{
+		DrawLine(ulx, uly, ulx+width-1, uly, color);
+		uly++;
+	}
+}
+
+void CDraw32::DrawRectAve(long ulx, long uly, long width, long height, CPixel32 color)
+//USE:	draw rectangle in solid color, translucent
+//IN:		(ulx,uly)			- coordinates of upper-left corner of rect
+//			width, height		- dimensions of rectangle
+//			color				- color value
+//OUT:	none
+{
+	assert(buffer != NULL);
+
+	if (height < 1 || width < 1)
+		return;
+
+	while (height-- != 0)
+	{
+		DrawLineAve(ulx, uly, ulx+width-1, uly, color);
+		uly++;
+	}
+}
+
+void CDraw32::DrawBoxNC(long ulx, long uly, long width, long height, CPixel32 color)
+//USE:	Draw an empty box, no clipping
+//IN:		(ulx,uly)		- coordinates of upper-left corner of box
+//			width, height	- dimensions of box
+//			color			- color value
+//OUT:	none
+{
+	assert(buffer != NULL);
+
+	if (height < 1 || width < 1)
+		return;
+
+	DrawLineNC(ulx, uly, ulx+width-1, uly, color);
+	DrawLineNC(ulx, uly+height-1, ulx+width-1, uly+height-1, color);
+	DrawLineNC(ulx, uly, ulx, uly+height-1, color);
+	DrawLineNC(ulx+width-1, uly, ulx+width-1, uly+height-1, color);
+}
+
+void CDraw32::DrawBox(long ulx, long uly, long width, long height, CPixel32 color)
+//USE:	Draw an empty box
+//IN:		(ulx,uly)		- coordinates of upper-left corner of rect
+//			width, height	- dimensions of rectangle
+//			color			- color value
+//OUT:	none
+{
+	assert(buffer != NULL);
+
+	if (height < 1 || width < 1)
+		return;
+
+	DrawLine(ulx, uly, ulx+width-1, uly, color);
+	DrawLine(ulx, uly+height-1, ulx+width-1, uly+height-1, color);
+	DrawLine(ulx, uly, ulx, uly+height-1, color);
+	DrawLine(ulx+width-1, uly, ulx+width-1, uly+height-1, color);
+}
+
+void CDraw32::DrawBoxAve(long ulx, long uly, long width, long height, CPixel32 color)
+//USE: Draw an empty box, translucent
+//IN:		(ulx,uly)		- coordinates of upper-left corner of rect
+//			width, height	- dimensions of rectangle
+//			color			- color value
+//OUT:	none
+{
+	assert(buffer!=NULL);
+
+	if (height < 1 || width < 1)
+		return;
+
+	DrawLineAve(ulx, uly, ulx+width-1, uly, color);
+	DrawLineAve(ulx, uly+height-1, ulx+width-1, uly+height-1, color);
+	DrawLineAve(ulx, uly, ulx, uly+height-1, color);
+	DrawLineAve(ulx+width-1, uly, ulx+width-1, uly+height-1, color);
+}
+
+void CDraw32::DrawCircle(long xc, long yc, long r, CPixel32 edge, CPixel32 fill)
+//USE:	Draw a simple circle in current color with Bresenham's
+//		circle algorithm.
+// See PROCEDURAL ELEMENTS FOR COMPUTER GRAPHICS
+// David F. Rogers Pg. 48.
+//
+//IN:   xc,yc - center
+//      r     - radius
+//      edge  - edge color 
+//      fill  - fill color 
+//
+//OUT: NONE (a circle drawn in the off-screen buffer)
+{
+	long		x,y;
+	long		limit,di,delta;
+	long		last_x,last_y;
+
+	assert(buffer != NULL);
+
+	if (r < 1)
+		return;
+
+	// draw fill
+	if (fill.a != 0)
+	{
+		x = 0; last_x = x;
+		y = r; last_y = y;
+		di = 2*(1-r);
+		limit = 0;
+
+		do
+    	{
+	    	if (y >= limit)
+    		{
+				if (di < 0)
+       			{
+	     			delta = 2*di + 2*y - 1;
+		 			if (delta <= 0)
+       				{ 	// move horizontal
+     					last_x = x;
+     					x++;
+	     				di += (2*x + 1);
+		   			}
+     			else
+       				{ 	// move diagonal
+     					last_x = x;
+     					x++;
+	     				y--;
+		 				di += (2*x - 2*y + 2);
+       				}
+       			}
+    			else
+				{
+        			if (di > 0)
+        			{
+	        			delta = 2*di - 2*x -1;
+		    			if (delta <= 0)
+         				{ 	// move diagonal
+							last_x = x;
+	       					x++;
+    	   					y--;
+         					di += (2*x - 2*y + 2);
+         				}
+	        			else
+		      			{ 	// move vertical
+				  			y--;
+          					di += (1 - 2*y);
+	          			}
+	    			}
+		    		else /* di = 0 */
+        			{  // move diagonal
+			    		last_x = x;
+	    	    		x++;
+		    			y--;
+						di += (2*x - 2*y + 2);
+        			}
+				}
+    		}
+
+	    	if (y != last_y)
+    		{ // circle fill
+		    	DrawLine(xc-last_x,yc+last_y,xc+last_x,yc+last_y,fill);
+				if (last_y > limit)
+				{
+      				DrawLine(xc-last_x,yc-last_y,xc+last_x,yc-last_y,fill);
+				}
+	    		last_y = y;
+    		}
+    	}  while (y >= limit);
+	}
+
+	// draw edge
+	if (edge.a != 0)
+	{
+		x = 0;
+		y = r;
+		limit = 0;
+		di = 2*(1-r);
+
+		do
+   		{
+	    	// circle edge
+			PutPix(xc+x, yc+y, edge);
+    		PutPix(xc-x, yc+y, edge);
+	    	if (y > limit)
+    		{
+		   		PutPix(xc+x, yc-y, edge);
+    			PutPix(xc-x, yc-y, edge);
+    		}
+
+	    	if (y >= limit)
+    		{
+    			if (di < 0)
+     			{
+	     			delta = 2*di + 2*y - 1;
+		 			if (delta <= 0)
+       				{ 	// move horizontal
+     					x++;
+     					di += (2*x + 1);
+	       			}
+		 			else
+       				{ 	// move diagonal
+     					x++;
+	     				y--;
+		       			di += (2*x - 2*y + 2);
+       				}
+       			}
+	    		else
+				{
+		      		if (di > 0)
+       				{
+      					delta = 2*di - 2*x -1;
+		      			if (delta <= 0)
+			 			{ // move diagonal
+       						x++;
+       						y--;
+		       				di += (2*x - 2*y + 2);
+			 			}
+      					else
+	        			{ // move vertical
+			   				y--;
+       						di += (1 - 2*y);
+         				}
+	       			}
+			  		else /* di = 0 */
+	       			{  	// move diagonal
+			  			x++;
+      					y--;
+		      			di += (2*x - 2*y + 2);
+	     			}
+				}
+    		}
+    	}  while (y >= limit);
+	}
+} // DrawCircle
+
+void CDraw32::DrawCircleAve(long xc, long yc, long r, CPixel32 edge, CPixel32 fill)
+//USE:	Draw a simple circle in current color with Bresenham's
+//			circle algorithm.
+//			a circle with fill and edge colors averaged with dest (-1 = no color)
+// See PROCEDURAL ELEMENTS FOR COMPUTER GRAPHICS
+// David F. Rogers Pg. 48.
+//
+//IN:   xc,yc - center
+//      r     - radius
+//      edge  - edge color 
+//      fill  - fill color 
+//
+//OUT:	none (a circle on in the off-screen buffer)
+{
+	long		x,y;
+	long		limit,di,delta;
+	long		last_x,last_y;
+	long		f;
+
+	assert(buffer != NULL);
+
+	if (r < 1)
+		return;
+
+	// draw fill
+	if (fill.a != 0)
+	{
+		x = 0; last_x = x;
+		y = r; last_y = y;
+		di = 2*(1-r);
+		limit = 0;
+
+		do
+    	{
+	    	if (y >= limit)
+    		{
+				if (di < 0)
+       			{
+     				delta = 2*di + 2*y - 1;
+	     			if (delta <= 0)
+		   			{ 	// move horizontal
+     					last_x = x;
+     					x++;
+     					di += (2*x + 1);
+	       			}
+		 			else
+       				{ 	// move diagonal
+	     				last_x = x;
+		 				x++;
+     					y--;
+     					di += (2*x - 2*y + 2);
+       				}
+	       		}
+				else
+				{
+					if (di > 0)
+	        		{
+			    		delta = 2*di - 2*x -1;
+		        		if (delta <= 0)
+			 			{ 	// move diagonal
+		        			last_x = x;
+				   			x++;
+		    	   			y--;
+				 			di += (2*x - 2*y + 2);
+         				}
+		        		else
+			      		{ 	// move vertical
+			          		y--;
+			          		di += (1 - 2*y);
+          				}
+	        		}
+			    	else /* di = 0 */
+	        		{  // move diagonal
+			        	last_x = x;
+		    	    	x++;
+						y--;
+		        		di += (2*x - 2*y + 2);
+					}
+				}
+    		}
+
+	    	if (y != last_y)
+    		{ // circle fill
+				for (f=xc-last_x; f<=xc+last_x; f++)
+					PutPixAve(f, yc+last_y, fill);
+	    		if (last_y > limit)
+				{
+					for (f=xc-last_x; f<=xc+last_x; f++)
+						PutPixAve(f, yc-last_y, fill);
+				}
+	    		last_y = y;
+    		}
+    	}  while (y >= limit);
+	}
+
+	// draw edge
+	if (edge.a != 0)
+	{
+		x = 0;
+		y = r;
+		limit = 0;
+		di = 2*(1-r);
+
+		do
+   		{
+	    	// circle edge
+			PutPixAve(xc+x, yc+y, edge);
+	    	PutPixAve(xc-x, yc+y, edge);
+			if (y > limit)
+    		{
+	   			PutPixAve(xc+x, yc-y, edge);
+	    		PutPixAve(xc-x, yc-y, edge);
+    		}
+			if (y >= limit)
+    		{
+    			if (di < 0)
+     			{
+     				delta = 2*di + 2*y - 1;
+	     			if (delta <= 0)
+	       			{ 	// move horizontal
+		 				x++;
+     					di += (2*x + 1);
+       				}
+     				else
+	       			{ 	// move diagonal
+		 				x++;
+			 			y--;
+	       				di += (2*x - 2*y + 2);
+		   			}
+       			}
+    			else
+				{
+		      		if (di > 0)
+		   			{
+	      				delta = 2*di - 2*x -1;
+			  			if (delta <= 0)
+	         			{ // move diagonal
+			   				x++;
+       						y--;
+		       				di += (2*x - 2*y + 2);
+			 			}
+      					else
+	        			{ // move vertical
+			   				y--;
+       						di += (1 - 2*y);
+	         			}
+		   			}
+		      		else /* di = 0 */
+       				{  	// move diagonal
+		      			x++;
+      					y--;
+		      			di += (2*x - 2*y + 2);
+	     			}
+				}
+    		}
+    	}  while (y >= limit);
+	}
+} // DrawCircleAve
+
+////////////////////////////////////////////////////////////////////////////
+//Concave Polygon Scan Conversion
+////////////////////////////////////////////////////////////////////////////
+
+// concave: scan convert nvert-sided concave non-simple polygon
+// with vertices at (point[i].x, point[i].y) for i in
+// [0..nvert-1] within the window win by
+// calling spanproc for each visible span of pixels.
+//
+// Polygon can be clockwise or counterclockwise.
+//
+// Algorithm does uniform point sampling at pixel centers.
+// Inside-outside test done by even-odd rule: a point is
+// considered inside if an emanating ray intersects the polygon
+// an odd number of times.
+//
+// spanproc should fill in pixels from xl to xr inclusive on scanline y,
+//
+// e.g:
+//	spanproc(short y, short xl, short xr)
+//	{
+//	    short x;
+//	    for (x=xl; x<=xr; x++)
+//			pixel_write(x, y, pixelvalue);
+//	}
+
+typedef struct
+{	   	        // a polygon edge
+             	// these are fixed point long ints for some accuracy & speed
+	long   x;		// x coordinate of edge's intersection with current scanline
+	long   dx;	// change in x with respect to y
+	long   i;		// edge number: edge i goes from pt[i] to
+       				// pt[i+1]
+} POLYEDGE;
+
+#define INT_SHIFT 13
+
+// global for speed
+static long   	 n;				// number of vertices
+static POINT  	*pt;		  	// vertices
+
+static long	    nact;	  		// number of active edges
+static POLYEDGE active[256];	// active edge list:edges crossing scanline y
+static long     ind[256];		// list of vertex indices, sorted by
+	    		                // pt[ind[j]].y
+
+static void del_edge(long i)
+// remove edge i from active list
+{
+	int  j;
+
+	for (j = 0; j < nact && active[j].i != i; j++)
+		;
+
+	// edge not in active list; happens at cliprect->top
+	if (j >= nact)
+	{
+		return;
+	}
+
+	nact--;
+	memcpy(&active[j], &active[j + 1], (nact - j) * sizeof(active[0]));
+}
+
+static void ins_edge(long i, long y)
+// append edge i to end of active list
+{
+	int 		j;
+	long    dx;
+	POINT   *p;
+	POINT   *q;
+
+	j = i < n - 1 ? i + 1 : 0;
+	if (pt[i].y < pt[j].y)
+	{
+		p = &pt[i];
+		q = &pt[j];
+	}
+	else
+	{
+		p = &pt[j];
+		q = &pt[i];
+	}
+
+	// initialize x position at intersection of edge with scanline y
+	if ((q->y - p->y) != 0)
+	{
+		dx =  (((long)q->x - (long)p->x) * (long)(1<<INT_SHIFT));
+		dx /= (((long)q->y - (long)p->y));
+	}
+	else
+	{
+		// horizontal line
+		dx = 0;
+	}
+
+	active[nact].dx = dx;
+	active[nact].x = (dx * (long)(y - p->y)) + ((long)p->x << INT_SHIFT);
+	active[nact].i = i;
+	nact++;
+}
+
+// comparison routines for shellsort
+int compare_ind(long *u, long *v)
+{
+	return (pt[*u].y <= pt[*v].y ? -1 : 1);
+}
+
+int compare_active(POLYEDGE *u, POLYEDGE *v)
+{
+	return (u->x <= v->x ? -1 : 1);
+}
+
+void shell_sort(void *vec, long n, long siz,
+                int (*compare)(void*,void*))
+// USE:  shell sort aka heap sort. Best sort algorithm for almost sorted list.
+{
+	byte *a;
+	byte v[128]; // temp object
+	long 		i,j,h;
+
+	a = (byte *)vec;
+
+	// choose size of "heap"
+	for (h = 1; h <= n/9; h = 3*h+1)
+		;
+
+	// divide and conq.
+	for ( ; h > 0; h /= 3)
+	{
+		for (i = h; i < n; i++)
+   		{
+	    	// v = a[i];
+			memcpy(v,(a+i*siz),siz);
+	    	j = i;
+			// j >= h && a[j-h] > v
+    		while ((j >= h) && compare((void*)(a+(j-h)*siz),(void*)v) > 0)
+    		{
+	    		// a[j] = a[j-h]
+				memcpy((a+j*siz),(a+(j-h)*siz),siz);
+    			j -= h;
+    		}
+	    	// a[j] = v;
+			memcpy((a+j*siz),v,siz);
+   		}
+	}
+}
+
+void CDraw32::DrawPolygon(long nvert, POINT *point, CPixel32 edge, CPixel32 fill)
+//USE:    Scan convert a polygon
+//IN:     nvert:        Number of vertices
+//        point:        Vertices of polygon
+//        edge:         edge color
+//        fill:         fill color
+//OUT:		none
+{
+	long	k,
+	        y0,
+	        y1,
+	        y,
+	        i,
+	        j,
+	        xl,
+	        xr;
+
+	assert(buffer != NULL);
+
+	n = nvert;
+
+	if (n <= 0)
+	{	// nothing to do
+		return;
+	}
+
+	pt = point;
+
+	if (fill.a != 0)
+	{ // draw fill
+
+		// create y-sorted array of indices ind[k] into vertex list
+		for (k = 0; k < n; k++)
+		{
+			ind[k] = k;
+		}
+
+		// sort ind by pt[ind[k]].y
+		shell_sort(ind, n, sizeof(long), (int (*)(void*,void*)) compare_ind);
+
+		nact = 0;					   // start with empty active list
+		k = 0;						   // ind[k] is next vertex to process
+
+		// ymin of polygon
+		y0 = MAX(clip_min_y-1, pt[ind[0]].y);
+
+		// ymax of polygon
+		y1 = MIN(clip_max_y+1, pt[ind[n-1]].y);
+
+		// step through scanlines
+		for (y = y0; y < y1; y++)
+    	{
+			// Check vertices between previous scanline
+			// and current one, if any
+			for (; (k < n) && (pt[ind[k]].y <= y); k++)
+    		{
+				i = ind[k];
+				//  insert or delete edges before and after vertex i
+	    		//  (i-1 to i, and i to i+1)
+				//  from active list if they cross scanline y
+				j = i > 0 ? i - 1 : n - 1;	// vertex previous to i
+				if (pt[j].y < y)
+				{
+					// old edge, remove from active list
+					del_edge(j);
+				}
+				else
+				{
+					if (pt[j].y > y)
+					{
+						// new edge, add to active list
+						ins_edge(j, y);
+					}
+		 		}
+				j = i < n - 1 ? i + 1 : 0;	// vertex next after i
+				if (pt[j].y < y)
+				{
+					// old edge, remove from active list
+					del_edge(i);
+				}
+				else
+				{
+					if (pt[j].y > y)
+					{
+						// new edge, add to active list
+						ins_edge(i, y);
+					}
+				}
+   			}
+
+			// sort active edge list by active[j].x
+			shell_sort(active, nact, sizeof(POLYEDGE), (int (*)(void*,void*))compare_active);
+
+			// draw horizontal segments for scanline y
+			for (j = 0; j < nact; j += 2)
+    		{	// draw horizontal segments
+				// span 'tween j & j+1 is inside, span tween
+				// j+1 & j+2 is outside
+
+				// left end of span
+	    		// convert back from fixed point - round down
+				xl = (long) (active[j].x >> INT_SHIFT);
+  				if (xl < clip_min_x-1)
+				{
+  					xl = clip_min_x-1;
+			 	}
+
+	    		// right end of span
+				// convert back from fixed point - round down
+				xr = (long) (active[j + 1].x >> INT_SHIFT);
+  				if (xr > clip_max_x)
+				{
+  					xr = clip_max_x;
+				}
+
+				if (xl < xr)
+	        	{
+  					// draw pixels in span
+		        	DrawLine(xl+1,y,xr,y,fill);
+	        	}
+
+				// increment edge coords
+				active[j].x += active[j].dx;
+				active[j + 1].x += active[j + 1].dx;
+				}
+  			}
+
+			// sort active edge list by active[j].x
+			shell_sort(active, nact, sizeof(POLYEDGE), (int (*)(void*,void*))compare_active);
+
+			// draw horizontal segments for scanline y
+			for (j = 0; j < nact; j += 2)
+    		{	// draw horizontal segments
+				// span 'tween j & j+1 is inside, span tween
+				// j+1 & j+2 is outside
+
+				// left end of span
+    			// convert back from fixed point - round down
+		    	xl = (long) (active[j].x >> INT_SHIFT);
+		  		if (xl < clip_min_x-1)
+				{
+  					xl = clip_min_x-1;
+				}
+
+		    	// right end of span
+		    	// convert back from fixed point - round up
+				xr = (long) (active[j + 1].x >> INT_SHIFT);
+		  		if (xr > clip_max_x)
+				{
+  					xr = clip_max_x;
+				}
+
+				if (xl < xr)
+				{
+  					// draw pixels in span
+		    		DrawLine(xl+1,y,xr,y,fill);
+    			}
+
+				// increment edge coords
+				active[j].x += active[j].dx;
+				active[j + 1].x += active[j + 1].dx;
+			}
+		}
+
+		if (edge.a != 0)
+		{ // draw edges
+			for (k = 0; k < n-1; k++)
+			{
+    			DrawLineAA(pt[k].x,pt[k].y,pt[k+1].x,pt[k+1].y,edge);
+			}
+
+			DrawLineAA(pt[n-1].x,pt[n-1].y,pt[0].x,pt[0].y,edge);
+		}
+
+	return;
+}
+
+void CDraw32::Blit(long dstX, long dstY, long width, long height, 
+				   CPixel32* srcImage, long srcX, long srcY, long srcStride)
+//USE:	simple blit
+//IN:	dstX, dstY				- upper left corner of where image will land in buffer
+//		width, height			- width and height of image
+//		srcImage				- src image buffer
+//		srcX, srcY				- upper left corner in src image
+//		srcStride				- number of pixels per line in src image
+//OUT:	none
+{
+	CPixel32 	*dst;
+	CPixel32 	*src;
+	int			x,y;
+
+	assert(buffer != NULL);
+
+	BlitClip(dstX, dstY, width, height, srcX, srcY);
+
+	if (width < 1 || height < 1)
+		return;
+
+	dst = &buffer[PIXPOS(dstX,dstY,stride)];
+	src = &srcImage[PIXPOS(srcX,srcY,srcStride)];
+
+	for (y = 0; y < height; y++)
+	{
+		for (x = 0; x < width; x++)
+		{
+//			*dst++ = *src++;
+			byte alpha = src->a;
+			byte dst_alpha = dst->a;
+			*dst = ALPHA_PIX(*src, *dst, alpha, 256-alpha);
+			dst->a = dst_alpha;
+			++dst;
+			++src;
+		}
+		dst += (stride - width);
+		src += (srcStride - width);
+	}
+}
+
+void CDraw32::BlitClip(long& dstX, long& dstY, 
+					   long& width, long& height, 
+					   long& srcX, long& srcY)
+//USE:	simple blit clip
+//IN:	dstX, dstY				- upper left corner of where image will land in buffer
+//		width, height			- width and height of image
+//		srcX, srcY				- upper left corner in src image
+//OUT:	none
+{
+
+	// clip to our buffer size
+	if (dstX < clip_min_x)
+	{
+		int dif = (clip_min_x - dstX);
+		dstX += dif;
+		srcX += dif;
+		width -= dif;
+	}
+
+	if (dstY < clip_min_y)
+	{
+		int dif = (clip_min_y - dstY);
+		dstY += dif;
+		srcY += dif;
+		height -= dif;
+	}
+
+	if (dstX+width-1 > clip_max_x)
+	{
+		width -= (dstX+width-1 - clip_max_x);
+	}
+
+	if (dstY+height-1 > clip_max_y)
+	{
+		height -= (dstY+height-1 - clip_max_y);
+	}
+}
+
+void CDraw32::BlitColor(long dstX, long dstY, long width, long height, 
+					    CPixel32* srcImage, long srcX, long srcY, long srcStride, CPixel32 color)
+//USE:	blit using image alpha as mask
+//IN:	dstX, dstY				- upper left corner of where image will land in buffer
+//		width, height			- width and height of image
+//		srcImage				- src image buffer
+//		srcX, srcY				- upper left corner in src image
+//		srcStride				- number of pixels per line in src image
+//		color					- color to apply to srcImage
+//OUT:	none
+{
+	CPixel32 	*dst;
+	CPixel32 	*src;
+	int			x,y;
+	int			dstNextLine;
+	int			srcNextLine;
+
+	assert(buffer != NULL);
+
+	BlitClip(dstX, dstY, width, height, srcX, srcY);
+
+	if (width < 1 || height < 1)
+		return;
+
+	dst = &buffer[PIXPOS(dstX,dstY,stride)];
+	src = &srcImage[PIXPOS(srcX,srcY,srcStride)];
+
+	dstNextLine = (stride - width);
+	srcNextLine = (srcStride - width);
+
+	for (y = 0; y < height; y++)
+	{
+		for (x = 0; x < width; x++)
+		{
+			byte alpha = src->a;
+			*dst = ALPHA_PIX(color, *dst, alpha, 256-alpha);
+			++dst;
+			++src;
+		}
+		dst += dstNextLine;
+		src += srcNextLine;
+	}
+}
+
diff --git a/code/qcommon/cm_draw.h b/code/qcommon/cm_draw.h
new file mode 100644
index 0000000..1f9bb3a
--- /dev/null
+++ b/code/qcommon/cm_draw.h
@@ -0,0 +1,245 @@
+///////////////////////////////////////////////////////////////////////////////
+// CDraw32 Class Interface
+//
+// Basic drawing routines for 32-bit per pixel buffer
+///////////////////////////////////////////////////////////////////////////////
+
+#if !defined(CM_DRAW_H_INC)
+#define CM_DRAW_H_INC
+
+// calc offset into image array for a pixel at (x,y)
+#define PIXPOS(x,y,stride) (((y)*(stride))+(x))
+
+#ifndef MIN
+// handy macros
+#define MIN(a,b) ((a) < (b) ? (a) : (b))
+#define MAX(a,b) ((a) > (b) ? (a) : (b))
+#define ABS(x) ((x)<0 ? -(x):(x))
+#define SIGN(x)  (((x) < 0) ? -1 : (((x) > 0) ? 1 : 0))
+#endif
+
+#ifndef CLAMP
+#define SWAP(a,b) { a^=b; b^=a; a^=b; }
+#define SQR(a)  ((a)*(a))
+#define CLAMP(v,l,h)    ((v)<(l) ? (l) : (v) > (h) ? (h) : (v))
+#define LERP(t, a, b) (((b)-(a))*(t) + (a))
+
+// round a to nearest integer towards 0
+#define FLOOR(a)        ((a)>0 ? (int)(a) : -(int)(-a))
+
+// round a to nearest integer away from 0
+#define CEILING(a) \
+((a)==(int)(a) ? (a) : (a)>0 ? 1+(int)(a) : -(1+(int)(-a)))
+
+#include <stdlib.h>
+#endif
+
+class CPixel32
+{
+public:
+	byte r;
+	byte g;
+	byte b;
+	byte a;
+
+	CPixel32(byte R = 0, byte G = 0, byte B = 0, byte A = 255) : r(R), g(G), b(B), a(A) {}
+	CPixel32(long l) {r = (l >> 24) & 0xff; g = (l >> 16) & 0xff; b = (l >> 8) & 0xff; a = l & 0xff;};
+
+	~CPixel32()
+	{}
+};
+
+#define PIX32_SIZE sizeof(CPixel32)
+
+// standard image operator macros
+#define IMAGE_SIZE(width,height) ((width)*(height)*(PIX32_SIZE))
+
+
+inline CPixel32 AVE_PIX (CPixel32 x, CPixel32 y) 
+	{ CPixel32 t; t.r = (byte)(((int)x.r + (int)y.r)>>1); 
+				  t.g = (byte)(((int)x.g + (int)y.g)>>1); 
+				  t.b = (byte)(((int)x.b + (int)y.b)>>1); 
+				  t.a = (byte)(((int)x.a + (int)y.a)>>1); return t;}
+
+inline CPixel32 ALPHA_PIX (CPixel32 x, CPixel32 y, long alpha, long inv_alpha) 
+	{ CPixel32 t; t.r = (byte)((x.r*alpha + y.r*inv_alpha)>>8); 
+				  t.g = (byte)((x.g*alpha + y.g*inv_alpha)>>8); 
+				  t.b = (byte)((x.b*alpha + y.b*inv_alpha)>>8); 
+//				  t.a = (byte)((x.a*alpha + y.a*inv_alpha)>>8);  return t;}
+				  t.a = y.a;  return t;}
+
+inline CPixel32 LIGHT_PIX (CPixel32 p, long light) 
+{ CPixel32 t; 
+  t.r = (byte)CLAMP(((p.r * light)>>10) + p.r, 0, 255); 
+  t.g = (byte)CLAMP(((p.g * light)>>10) + p.g, 0, 255); 
+  t.b = (byte)CLAMP(((p.b * light)>>10) + p.b, 0, 255); 
+  t.a = p.a;  return t;}
+
+// Colors are 32-bit RGBA
+
+// draw class
+class CDraw32
+{
+public: // static drawing context - static so we set only ONCE for many draw calls
+	static	CPixel32*	buffer;	   			// pointer to pixel buffer (one active)
+	static	long	buf_width;				// size of buffer
+	static	long	buf_height;				// size of buffer
+	static	long	stride;					// stride of buffer in pixels
+	static	long	clip_min_x;				// clip bounds
+	static	long	clip_min_y;				// clip bounds
+	static	long	clip_max_x;				// clip bounds
+	static	long	clip_max_y;				// clip bounds
+	static	long*	row_off;				// Table for quick Y calculations
+
+private:
+	void BlitClip(long& dstX, long& dstY, 
+		 		  long& width, long& height, 
+				  long& srcX, long& srcY);
+
+protected:
+public:
+	CDraw32();						// constructor
+	~CDraw32();						// destructor
+
+	// set the rect to clip drawing functions to
+	static void	SetClip(long min_x, long min_y,long max_x, long max_y)
+						{clip_min_x = MAX(min_x,0); clip_max_x = MIN(max_x,buf_width-1);
+						 clip_min_y = MAX(min_y,0); clip_max_y = MIN(max_y,buf_height-1);}
+
+	static void GetClip(long& min_x, long& min_y,long& max_x, long& max_y)
+						{min_x = clip_min_x; min_y = clip_min_y;
+						 max_x = clip_max_x; max_y = clip_max_y; }
+
+	// set the buffer to use for drawing off-screen
+	static void	SetBuffer(CPixel32* buf) {buffer = buf;};
+
+	// set the dimensions of the off-screen buffer
+	static bool	SetBufferSize(long width,long height,long stride_len);
+
+	// call this to free the table for quick y calcs before the program ends
+	static void CleanUp(void) 
+		{if (row_off) delete [] row_off; row_off=NULL; buf_width=0; buf_height=0;}
+
+	// set a pixel at (x,y) to color (no clipping)
+	void				PutPixNC(long x, long y, CPixel32 color)
+		{buffer[row_off[y] + x] = color;}
+
+	// set a pixel at (x,y) to color
+	void				PutPix(long x, long y, CPixel32 color)
+		{	// clipping check
+			if (x < clip_min_x || x > clip_max_x ||
+			    y < clip_min_y || y > clip_max_y)
+	  			return;
+			PutPixNC(x,y,color);
+		}
+
+	// get the color of a pixel at (x,y)
+	CPixel32			GetPix(long x, long y)
+		{return buffer[row_off[y] + x];}
+
+	// set a pixel at (x,y) with 50% translucency (no clip)
+	void				PutPixAveNC(long x, long y, CPixel32 color)
+		{	PutPixNC(x,y,AVE_PIX(GetPix(x, y), color)); }
+
+	// set a pixel at (x,y) with 50% translucency
+	void				PutPixAve(long x, long y, CPixel32 color)
+		{	// clipping check
+			if (x < clip_min_x || x > clip_max_x ||
+				y < clip_min_y || y > clip_max_y)
+		  		return;
+			PutPixNC(x,y,AVE_PIX(GetPix(x, y), color));
+		}
+
+	// set a pixel at (x,y) with translucency level (no clip)
+	void				PutPixAlphaNC(long x, long y, CPixel32 color)
+		{	PutPixNC(x,y,ALPHA_PIX(color, GetPix(x, y), color.a, 256-color.a));}
+
+	// set a pixel at (x,y) with translucency level
+	void				PutPixAlpha(long x, long y, CPixel32 color)
+		{	// clipping check
+		if (x < clip_min_x || x > clip_max_x ||
+		    y < clip_min_y || y > clip_max_y)
+  		return;
+		PutPixNC(x,y,ALPHA_PIX(color, GetPix(x, y), color.a, 256-color.a));}
+
+	// clear screen buffer to color from start to end line
+	void				ClearLines(CPixel32 color,long start,long end);
+
+	// clear screen buffer to color provided
+	void				ClearBuffer(CPixel32 color)
+		{ClearLines(color,0,buf_height-1);};
+
+	// fill buffer alpha from start to end line
+	void				SetAlphaLines(byte alpha,long start,long end);
+
+	// clear screen buffer to color provided
+	void				SetAlphaBuffer(byte alpha)
+		{SetAlphaLines(alpha,0,buf_height-1);};
+
+	// clip a line segment to the clip rect
+	bool				ClipLine(long& x1, long& y1, long& x2, long& y2);
+
+	// draw a solid colored line, no clipping
+	void				DrawLineNC(long x1, long y1, long x2, long y2, CPixel32 color);
+	
+	// draw a solid color line
+	void				DrawLine(long x1, long y1, long x2, long y2, CPixel32 color)
+		{	if (ClipLine(x1,y1,x2,y2)) DrawLineNC(x1,y1,x2,y2,color);}
+
+	void				DrawLineAveNC(long x1, long y1, long x2, long y2, CPixel32 color);
+
+	// draw a translucent solid color line
+	void				DrawLineAve(long x1, long y1, long x2, long y2, CPixel32 color)
+		{	if (ClipLine(x1,y1,x2,y2)) DrawLineAveNC(x1,y1,x2,y2,color);}
+
+	// draw an anti-aliased line, no clipping
+	void				DrawLineAANC(long x0, long y0, long x1, long y1, CPixel32 color);
+
+	// draw an anti-aliased line
+	void				DrawLineAA(long x1, long y1, long x2, long y2, CPixel32 color)
+		{	if (ClipLine(x1,y1,x2,y2)) DrawLineAANC(x1,y1,x2,y2,color);}
+
+	// draw a filled rectangle, no clipping
+	void				DrawRectNC(long ulx, long uly, long width, long height,CPixel32 color);
+	
+	// draw a filled rectangle
+	void				DrawRect(long ulx, long uly, long width, long height, CPixel32 color);
+
+	// draw a filled rectangle
+	void				DrawRectAve(long ulx, long uly, long width, long height,CPixel32 color);
+
+	// draw a box (unfilled rectangle) no clip
+	void				DrawBoxNC(long ulx, long uly, long width, long height, CPixel32 color);
+
+	// draw a box (unfilled rectangle)
+	void				DrawBox(long ulx, long uly, long width, long height, CPixel32 color);
+
+	// draw a box (unfilled rectangle)
+	void				DrawBoxAve(long ulx, long uly, long width, long height, CPixel32 color);
+
+	// draw a circle with fill and edge colors 
+	void				DrawCircle(long xc, long yc, long r, CPixel32 edge, CPixel32 fill);
+
+	// draw a circle with fill and edge colors averaged with dest 
+	void				DrawCircleAve(long xc, long yc, long r, CPixel32 edge, CPixel32 fill);
+
+	// draw a polygon (complex) with fill and edge colors 
+	void				DrawPolygon(long nvert, POINT *point, CPixel32 edge, CPixel32 fill);
+
+	// simple blit function
+	void				BlitNC(long dstX, long dstY, long dstWidth, long dstHeight, 
+							   CPixel32* srcImage, long srcX, long srcY, long srcStride);
+
+	void				Blit(long dstX, long dstY, long dstWidth, long dstHeight, 
+							   CPixel32* srcImage, long srcX, long srcY, long srcStride);
+
+	// blit image times color
+	void				BlitColor(long dstX, long dstY, long dstWidth, long dstHeight, 
+								  CPixel32* srcImage, long srcX, long srcY, long srcStride, CPixel32 color);
+
+	void				Emboss(long dstX, long dstY, long width, long height, 
+							    CPixel32* clrImage, long clrX, long clrY, long clrStride);
+};
+
+///////////////////////////////////////////////////////////////////////////////
+#endif
diff --git a/code/qcommon/cm_landscape.h b/code/qcommon/cm_landscape.h
new file mode 100644
index 0000000..872171f
--- /dev/null
+++ b/code/qcommon/cm_landscape.h
@@ -0,0 +1,271 @@
+#if !defined(CM_LANDSCAPE_H_INC)
+#define CM_LANDSCAPE_H_INC
+
+#pragma warning (push, 3)	//go back down to 3 for the stl include
+#include <list>
+#pragma warning (pop)
+
+using namespace std;
+
+// These are the root classes using data shared in both the server and the renderer.
+// This common data is also available to physics
+
+#define HEIGHT_RESOLUTION		256
+
+// Trying to make a guess at the optimal step through the patches
+// This is the average of 1 side and the diagonal presuming a square patch
+#define TERRAIN_STEP_MAGIC		(1.0f / 1.2071f)
+
+#define MIN_TERXELS				2
+#define MAX_TERXELS				8
+// Defined as 1 << (sqrt(MAX_TERXELS) + 1)
+#define MAX_VARIANCE_SIZE		16
+
+// Maximum number of instances to pick from an instance file
+#define MAX_INSTANCE_TYPES		16
+
+// Types of areas
+
+typedef enum
+{
+	AT_NONE,
+	AT_FLAT,
+	AT_BSP,
+	AT_NPC,
+	AT_GROUP,
+	AT_RIVER,
+	AT_OBJECTIVE,
+	AT_PLAYER,
+
+} areaType_t;
+
+class CArea
+{
+private:
+	vec3_t		mPosition;
+	float		mRadius;
+	float		mAngle;
+	float		mAngleDiff;
+	int			mType;
+	int			mVillageID;
+public:
+	CArea(void) {}
+	~CArea(void) {}
+
+	void Init(vec3_t pos, float radius, float angle = 0.0f, int type = AT_NONE, float angleDiff = 0.0f, int villageID = 0) 
+	{ 
+		VectorCopy(pos, mPosition); 
+		mRadius = radius; 
+		mAngle = angle; 
+		mAngleDiff = angleDiff; 
+		mType = type; 
+		mVillageID = villageID;
+	}
+	float GetRadius(void) const { return(mRadius); }
+	float GetAngle(void) const { return(mAngle); }
+	float GetAngleDiff(void) const { return(mAngleDiff); }
+	vec3_t &GetPosition(void) { return(mPosition); }
+	int GetType(void) const { return(mType); }
+	int GetVillageID(void) const { return(mVillageID); }
+};
+
+typedef list<CArea*>					areaList_t;
+typedef list<CArea*>::iterator			areaIter_t;
+
+class CCMHeightDetails
+{
+private:
+	int						mContents;
+	int						mSurfaceFlags;
+public:
+	CCMHeightDetails(void) {}
+	~CCMHeightDetails(void) {}
+
+	// Accessors
+	const int GetSurfaceFlags(void) const { return(mSurfaceFlags); }
+	const int GetContents(void) const { return(mContents); }
+	void SetFlags(const int con, const int sf) { mContents = con; mSurfaceFlags = sf; }
+};
+
+class CCMPatch
+{
+protected:
+	class CCMLandScape		*owner;										// Owning landscape
+	int						mHx, mHy;									// Terxel coords of patch
+	byte					*mHeightMap;				 				// Pointer to height map to use
+	byte					mCornerHeights[4]; 							// Heights at the corners of the patch
+	vec3_t					mWorldCoords;				 				// World coordinate offset of this patch.
+	vec3pair_t 				mBounds;									// mins and maxs of the patch for culling
+	int						mNumBrushes;								// number of brushes to collide with in the patch
+	struct cbrush_s			*mPatchBrushData;							// List of brushes that make up the patch
+	int						mSurfaceFlags;								// surfaceflag of the heightshader
+	int						mContentFlags;								// contents of the heightshader
+public:
+	// Constructors
+	CCMPatch(void) {}
+	~CCMPatch(void);
+
+	// Accessors
+	const vec3_t &GetWorld(void) const { return(mWorldCoords); }
+	const vec3_t &GetMins(void) const { return(mBounds[0]); }
+	const vec3_t &GetMaxs(void) const { return(mBounds[1]); }
+	const vec3pair_t &GetBounds(void) const { return(mBounds); }
+	const int GetHeightMapX(void) const { return(mHx); }
+	const int GetHeightMapY(void) const { return(mHy); }
+	const int GetHeight(int corner) const { return(mCornerHeights[corner]); }
+	const int GetNumBrushes(void) const { return(mNumBrushes); }
+	struct cbrush_s *GetCollisionData(void) const { return(mPatchBrushData); }
+
+	void SetSurfaceFlags(const int in) { mSurfaceFlags = in; }
+	const int GetSurfaceFlags(void) const { return(mSurfaceFlags); }
+	void SetContents(const int in) { mContentFlags = in; }
+	const int GetContents(void) const { return(mContentFlags); }
+
+	// Prototypes
+	void Init(CCMLandScape *ls, int heightX, int heightY, vec3_t world, byte *hMap, byte *patchBrushData);
+	void InitPlane(struct cbrushside_s *side, cplane_t *plane, vec3_t p0, vec3_t p1, vec3_t p2);
+	void CreatePatchPlaneData(void);
+	
+	void*	GetAdjacentBrushX ( int x, int y );
+	void*	GetAdjacentBrushY ( int x, int y );
+};
+
+class CRandomTerrain;
+
+class CCMLandScape
+{
+private:
+	int						mRefCount;									// Number of times this class is referenced
+	thandle_t				mTerrainHandle;
+	byte					*mHeightMap;								// Pointer to byte array of height samples
+	byte					*mFlattenMap;								// Pointer to byte array of flatten samples
+	int						mWidth, mHeight;							// Width and height of heightMap excluding the 1 pixel edge
+	int						mTerxels;									// Number of terxels per patch side
+	vec3_t					mTerxelSize;								// Vector to scale heightMap samples to real world coords
+	vec3pair_t				mBounds;									// Real world bounds of terrain brush
+	vec3_t					mSize;										// Size of terrain brush in real world coords excluding 1 patch edge
+	vec3_t					mPatchSize;									// Size of each patch in the x and y directions only
+	float					mPatchScalarSize;							// Horizontal size of the patch
+	int						mBlockWidth, mBlockHeight;					// Width and height of heightfield on blocks
+	CCMPatch 				*mPatches;
+	byte					*mPatchBrushData;							// Base memory from which the patch brush data is taken
+	bool					mHasPhysics;								// Set to true unless disabled
+	CRandomTerrain			*mRandomTerrain;
+							
+	int						mBaseWaterHeight;							// Base water height in terxels
+	float					mWaterHeight;								// Real world height of the water
+	int						mWaterContents;								// Contents of the water shader
+	int						mWaterSurfaceFlags;							// Surface flags of the water shader
+
+	unsigned long			holdrand;
+	
+	list<CArea *>			mAreas;										// List of flattened areas on this landscape
+	list<CArea *>::iterator	mAreasIt;
+
+	CCMHeightDetails		mHeightDetails[HEIGHT_RESOLUTION];			// Surfaceflags per height
+	vec3_t					*mCoords;									// Temp storage for real world coords
+
+public:
+	CCMLandScape(const char *configstring, bool server);
+	~CCMLandScape(void);
+
+	CCMPatch *GetPatch(int x, int y);
+
+	// Prototypes
+	void PatchCollide(struct traceWork_s *tw, trace_t &trace, const vec3_t start, const vec3_t end, int checkcount);
+	void TerrainPatchIterate(void (*IterateFunc)( CCMPatch *, void * ), void *userdata) const;
+	float GetWorldHeight(vec3_t origin, const vec3pair_t bounds, bool aboveGround) const;
+	float WaterCollide(const vec3_t begin, const vec3_t end, float fraction) const;
+	void UpdatePatches(void);
+	void GetTerxelLocalCoords ( int x, int y, vec3_t coords[8] );
+	void LoadTerrainDef(const char *td);
+	void SetShaders(int height, class CCMShader *shader);
+	void FlattenArea(CArea *area, int height, bool save, bool forceHeight, bool smooth);
+	void CarveLine ( vec3_t start, vec3_t end, int depth, int width );
+	void CarveBezierCurve ( int numCtlPoints, vec3_t* ctlPoints, int steps, int depth, int size );
+	void SaveArea(CArea *area);
+	float FractionBelowLevel(CArea *area, int height);
+	bool AreaCollision(CArea *area, int *areaTypes, int areaTypeCount);
+	CArea *GetFirstArea(void);
+	CArea *GetFirstObjectiveArea(void);
+	CArea *GetPlayerArea(void);
+	CArea *GetNextArea(void);
+	CArea *GetNextObjectiveArea(void);
+
+	// Accessors
+	const int GetRefCount(void) const { return(mRefCount); }
+	void IncreaseRefCount(void) { mRefCount++; }
+	void DecreaseRefCount(void) { mRefCount--; }
+	const vec3pair_t &GetBounds(void) const { return(mBounds); }
+	const vec3_t &GetMins(void) const { return(mBounds[0]); }
+	const vec3_t &GetMaxs(void) const { return(mBounds[1]); }
+	const vec3_t &GetSize(void) const { return(mSize); }
+	const vec3_t &GetTerxelSize(void) const { return(mTerxelSize); }
+	const vec3_t &GetPatchSize(void) const { return(mPatchSize); }
+	const float GetPatchWidth(void) const { return(mPatchSize[0]); }
+	const float GetPatchHeight(void) const { return(mPatchSize[1]); }
+	const float GetPatchScalarSize(void) const { return(mPatchScalarSize); }
+	const int GetTerxels(void) const { return(mTerxels); }
+	const int GetRealWidth(void) const { return(mWidth + 1); }
+	const int GetRealHeight(void) const { return(mHeight + 1); }
+	const int GetRealArea(void) const { return((mWidth + 1) * (mHeight + 1)); }
+	const int GetWidth(void) const { return(mWidth); }
+	const int GetHeight(void) const { return(mHeight); }
+	const int GetArea(void) const { return(mWidth * mHeight); }
+	const int GetBlockWidth(void) const { return(mBlockWidth); }
+	const int GetBlockHeight(void) const { return(mBlockHeight); }
+	const int GetBlockCount(void) const { return(mBlockWidth * mBlockHeight); }
+	byte *GetHeightMap(void) const { return(mHeightMap); }
+	byte *GetFlattenMap(void) const { return(mFlattenMap); }
+	const thandle_t GetTerrainId(void) const { return(mTerrainHandle); }
+	void SetTerrainId(const thandle_t terrainId) { mTerrainHandle = terrainId; }
+	const float CalcWorldHeight(int height) const { return((height * mTerxelSize[2]) + mBounds[0][2]); }
+	const bool GetHasPhysics(void) const { return(mHasPhysics); }
+	const bool GetIsRandom(void) const { return(mRandomTerrain != 0); }
+	const int GetSurfaceFlags(int height) const { return(mHeightDetails[height].GetSurfaceFlags()); }
+	const int GetContentFlags(int height) const { return(mHeightDetails[height].GetContents()); }
+	void CalcRealCoords(void);
+	vec3_t *GetCoords(void) const { return(mCoords); }
+
+	int GetBaseWaterHeight(void) const { return(mBaseWaterHeight); }
+	void SetRealWaterHeight(int height) { mWaterHeight = height * mTerxelSize[2]; }
+	float GetWaterHeight(void) const { return(mWaterHeight); }
+	int GetWaterContents(void) const { return(mWaterContents); }
+	int GetWaterSurfaceFlags(void) const { return(mWaterSurfaceFlags); }
+
+	CRandomTerrain			*GetRandomTerrain(void) { return mRandomTerrain; }
+
+	void			rand_seed(int seed);
+	unsigned long	get_rand_seed(void) { return holdrand; }
+
+	float			flrand(float min, float max);
+	int				irand(int min, int max);
+};
+
+void CM_TerrainPatchIterate(const class CCMLandScape *ls, void (*IterateFunc)( CCMPatch *, void * ), void *userdata);
+class CCMLandScape *CM_InitTerrain(const char *configstring, thandle_t terrainId, bool server);
+float CM_GetWorldHeight(const CCMLandScape *landscape, vec3_t origin, const vec3pair_t bounds, bool aboveGround);
+void CM_FlattenArea(CCMLandScape *landscape, CArea *area, int height, bool save, bool forceHeight, bool smooth);
+void CM_CarveBezierCurve (CCMLandScape *landscape, int numCtls, vec3_t* ctls, int steps, int depth, int size );
+void CM_SaveArea(CCMLandScape *landscape, CArea *area);
+float CM_FractionBelowLevel(CCMLandScape *landscape, CArea *area, int height);
+bool CM_AreaCollision(class CCMLandScape *landscape, class CArea *area, int *areaTypes, int areaTypeCount);
+CArea *CM_GetFirstArea(CCMLandScape *landscape);
+CArea *CM_GetFirstObjectiveArea(CCMLandScape *landscape);
+CArea *CM_GetPlayerArea(class CCMLandScape *common);
+CArea *CM_GetNextArea(CCMLandScape *landscape);
+CArea *CM_GetNextObjectiveArea(CCMLandScape *landscape);
+void CM_CircularIterate(byte *data, int width, int height, int xo, int yo, int insideRadius, int outsideRadius, int *user, void (*callback)(byte *, float, int *));
+
+CRandomTerrain *CreateRandomTerrain(const char *config, CCMLandScape *landscape, byte *heightmap, int width, int height);
+
+void SV_LoadMissionDef(const char *configstring, class CCMLandScape *landscape);
+void CL_CreateRandomTerrain(const char *config, class CCMLandScape *landscape, byte *image, int width, int height);
+void CL_LoadInstanceDef(const char *configstring, class CCMLandScape *landscape);
+void CL_LoadMissionDef(const char *configstring, class CCMLandScape *landscape);
+
+extern cvar_t	*com_terrainPhysics;
+
+#endif
+
+// end
diff --git a/code/qcommon/cm_load.cpp b/code/qcommon/cm_load.cpp
new file mode 100644
index 0000000..e990c66
--- /dev/null
+++ b/code/qcommon/cm_load.cpp
@@ -0,0 +1,1298 @@
+// cmodel.c -- model loading
+
+#include "cm_local.h"
+#include "../RMG/RM_Headers.h"
+
+void CM_LoadShaderText(bool forceReload);
+
+#ifdef BSPC
+void SetPlaneSignbits (cplane_t *out) {
+	int	bits, j;
+
+	// for fast box on planeside test
+	bits = 0;
+	for (j=0 ; j<3 ; j++) {
+		if (out->normal[j] < 0) {
+			bits |= 1<<j;
+		}
+	}
+	out->signbits = bits;
+}
+#endif //BSPC
+
+// to allow boxes to be treated as brush models, we allocate
+// some extra indexes along with those needed by the map
+#define	BOX_BRUSHES		1
+#define	BOX_SIDES		6
+#define	BOX_LEAFS		2
+#define	BOX_PLANES		12
+
+#define	LL(x) x=LittleLong(x)
+
+
+clipMap_t	cmg;
+int			c_pointcontents;
+int			c_traces, c_brush_traces, c_patch_traces;
+
+
+byte		*cmod_base;
+
+#ifndef BSPC
+cvar_t		*cm_noAreas;
+cvar_t		*cm_noCurves;
+cvar_t		*cm_playerCurveClip;
+#endif
+
+cmodel_t	box_model;
+cplane_t	*box_planes;
+cbrush_t	*box_brush;
+
+int			CM_OrOfAllContentsFlagsInMap;
+
+
+void	CM_InitBoxHull (void);
+void	CM_FloodAreaConnections (clipMap_t &cm);
+
+clipMap_t	SubBSP[MAX_SUB_BSP];
+int			NumSubBSP = 0, TotalSubModels = 0;
+
+/*
+===============================================================================
+
+					MAP LOADING
+
+===============================================================================
+*/
+
+/*
+=================
+CMod_LoadShaders
+=================
+*/
+void CMod_LoadShaders( lump_t *l, clipMap_t	&cm ) 
+{
+	dshader_t	*in;
+	int			i, count;
+	CCMShader	*out;
+
+	in = (dshader_t *)(cmod_base + l->fileofs);
+	if (l->filelen % sizeof(*in)) {
+		Com_Error (ERR_DROP, "CMod_LoadShaders: funny lump size");
+	}
+	count = l->filelen / sizeof(*in);
+
+	if (count < 1) {
+		Com_Error (ERR_DROP, "Map with no shaders");
+	}
+	cm.shaders = (CCMShader *)Z_Malloc( (1 + count) * sizeof( *cm.shaders ), TAG_BSP, qtrue );	//+1 for the BOX_SIDES to point at
+	cm.numShaders = count;
+
+	out = cm.shaders;
+	for ( i = 0; i < count; i++, in++, out++ ) 
+	{
+		Q_strncpyz(out->shader, in->shader, MAX_QPATH);
+		out->contentFlags = LittleLong( in->contentFlags );
+		out->surfaceFlags = LittleLong( in->surfaceFlags );
+	}
+}
+
+
+/*
+=================
+CMod_LoadSubmodels
+=================
+*/
+void CMod_LoadSubmodels( lump_t *l, clipMap_t	&cm ) {
+	dmodel_t	*in;
+	cmodel_t	*out;
+	int			i, j, count;
+	int			*indexes;
+
+	in = (dmodel_t *)(cmod_base + l->fileofs);
+	if (l->filelen % sizeof(*in))
+		Com_Error (ERR_DROP, "CMod_LoadSubmodels: funny lump size");
+	count = l->filelen / sizeof(*in);
+
+	if (count < 1) {
+		Com_Error (ERR_DROP, "Map with no models");
+	}
+
+	//FIXME: note that MAX_SUBMODELS - 1 is used for BOX_MODEL_HANDLE, if that slot gets used, that would be bad, no?
+	if ( count > MAX_SUBMODELS ) {
+		Com_Error( ERR_DROP, "MAX_SUBMODELS (%d) exceeded by %d", MAX_SUBMODELS, count-MAX_SUBMODELS );
+	}
+
+	cm.cmodels = (struct cmodel_s *) Z_Malloc( count * sizeof( *cm.cmodels ), TAG_BSP, qtrue );
+	cm.numSubModels = count;
+
+	for ( i=0 ; i<count ; i++, in++, out++)
+	{
+		out = &cm.cmodels[i];
+
+		for (j=0 ; j<3 ; j++)
+		{	// spread the mins / maxs by a pixel
+			out->mins[j] = LittleFloat (in->mins[j]) - 1;
+			out->maxs[j] = LittleFloat (in->maxs[j]) + 1;
+		}
+
+		//rww - I changed this to do the &cm == &cmg check. sof2 does not have to do this,
+		//but I think they have a different tracing system that allows it to catch subbsp
+		//stuff without extra leaf data. The reason we have to do this for subbsp instances
+		//is that they often are compiled in a sort of "prefab" form, so the first model isn't
+		//necessarily the world model.
+		if ( i == 0 && &cm == &cmg ) {
+			continue;	// world model doesn't need other info
+		}
+
+		// make a "leaf" just to hold the model's brushes and surfaces
+		out->leaf.numLeafBrushes = LittleLong( in->numBrushes );
+		indexes = (int *) Z_Malloc( out->leaf.numLeafBrushes * 4, TAG_BSP, qfalse);
+		out->leaf.firstLeafBrush = indexes - cm.leafbrushes;
+		for ( j = 0 ; j < out->leaf.numLeafBrushes ; j++ ) {
+			indexes[j] = LittleLong( in->firstBrush ) + j;
+		}
+
+		out->leaf.numLeafSurfaces = LittleLong( in->numSurfaces );
+		indexes = (int *) Z_Malloc( out->leaf.numLeafSurfaces * 4, TAG_BSP, qfalse);
+		out->leaf.firstLeafSurface = indexes - cm.leafsurfaces;
+		for ( j = 0 ; j < out->leaf.numLeafSurfaces ; j++ ) {
+			indexes[j] = LittleLong( in->firstSurface ) + j;
+		}
+	}
+}
+
+
+/*
+=================
+CMod_LoadNodes
+
+=================
+*/
+void CMod_LoadNodes( lump_t *l, clipMap_t &cm ) {
+	dnode_t		*in;
+	int			child;
+	cNode_t		*out;
+	int			i, j, count;
+	
+	in = (dnode_t *)(cmod_base + l->fileofs);
+	if (l->filelen % sizeof(*in))
+		Com_Error (ERR_DROP, "MOD_LoadBmodel: funny lump size");
+	count = l->filelen / sizeof(*in);
+
+	if (count < 1)
+		Com_Error (ERR_DROP, "Map has no nodes");
+	cm.nodes = (cNode_t *) Z_Malloc( count * sizeof( *cm.nodes ), TAG_BSP, qfalse);
+	cm.numNodes = count;
+
+	out = cm.nodes;
+
+	for (i=0 ; i<count ; i++, out++, in++)
+	{
+		out->plane = cm.planes + LittleLong( in->planeNum );
+		for (j=0 ; j<2 ; j++)
+		{
+			child = LittleLong (in->children[j]);
+			out->children[j] = child;
+		}
+	}
+
+}
+
+/*
+=================
+CM_BoundBrush
+
+=================
+*/
+void CM_BoundBrush( cbrush_t *b ) {
+	b->bounds[0][0] = -b->sides[0].plane->dist;
+	b->bounds[1][0] = b->sides[1].plane->dist;
+
+	b->bounds[0][1] = -b->sides[2].plane->dist;
+	b->bounds[1][1] = b->sides[3].plane->dist;
+
+	b->bounds[0][2] = -b->sides[4].plane->dist;
+	b->bounds[1][2] = b->sides[5].plane->dist;
+}
+
+
+/*
+=================
+CMod_LoadBrushes
+
+=================
+*/
+void CMod_LoadBrushes( lump_t *l, clipMap_t &cm ) {
+	dbrush_t	*in;
+	cbrush_t	*out;
+	int			i, count;
+
+	in = (dbrush_t *)(cmod_base + l->fileofs);
+	if (l->filelen % sizeof(*in)) {
+		Com_Error (ERR_DROP, "MOD_LoadBmodel: funny lump size");
+	}
+	count = l->filelen / sizeof(*in);
+
+	cm.brushes = (cbrush_t *) Z_Malloc( ( BOX_BRUSHES + count ) * sizeof( *cm.brushes ), TAG_BSP, qfalse);
+	cm.numBrushes = count;
+
+	out = cm.brushes;
+
+	for ( i=0 ; i<count ; i++, out++, in++ ) {
+		out->sides = cm.brushsides + LittleLong(in->firstSide);
+		out->numsides = LittleLong(in->numSides);
+
+		out->shaderNum = LittleLong( in->shaderNum );
+		if ( out->shaderNum < 0 || out->shaderNum >= cm.numShaders ) {
+			Com_Error( ERR_DROP, "CMod_LoadBrushes: bad shaderNum: %i", out->shaderNum );
+		}
+		out->contents = cm.shaders[out->shaderNum].contentFlags;
+		CM_OrOfAllContentsFlagsInMap |= out->contents;
+		out->checkcount=0;
+
+		CM_BoundBrush( out );
+	}
+
+}
+
+/*
+=================
+CMod_LoadLeafs
+=================
+*/
+void CMod_LoadLeafs (lump_t *l, clipMap_t &cm)
+{
+	int			i;
+	cLeaf_t		*out;
+	dleaf_t 	*in;
+	int			count;
+	
+	in = (dleaf_t *)(cmod_base + l->fileofs);
+	if (l->filelen % sizeof(*in))
+		Com_Error (ERR_DROP, "MOD_LoadBmodel: funny lump size");
+	count = l->filelen / sizeof(*in);
+
+	if (count < 1)
+		Com_Error (ERR_DROP, "Map with no leafs");
+
+	cm.leafs = (cLeaf_t *) Z_Malloc( ( BOX_LEAFS + count ) * sizeof( *cm.leafs ), TAG_BSP, qfalse);
+	cm.numLeafs = count;
+	out = cm.leafs;	
+
+	for ( i=0 ; i<count ; i++, in++, out++)
+	{
+		out->cluster = LittleLong (in->cluster);
+		out->area = LittleLong (in->area);
+		out->firstLeafBrush = LittleLong (in->firstLeafBrush);
+		out->numLeafBrushes = LittleLong (in->numLeafBrushes);
+		out->firstLeafSurface = LittleLong (in->firstLeafSurface);
+		out->numLeafSurfaces = LittleLong (in->numLeafSurfaces);
+
+		if (out->cluster >= cm.numClusters)
+			cm.numClusters = out->cluster + 1;
+		if (out->area >= cm.numAreas)
+			cm.numAreas = out->area + 1;
+	}
+
+	cm.areas = (cArea_t *) Z_Malloc( cm.numAreas * sizeof( *cm.areas ), TAG_BSP, qtrue );
+	cm.areaPortals = (int *) Z_Malloc( cm.numAreas * cm.numAreas * sizeof( *cm.areaPortals ), TAG_BSP, qtrue );
+}
+
+/*
+=================
+CMod_LoadPlanes
+=================
+*/
+void CMod_LoadPlanes (lump_t *l, clipMap_t &cm)
+{
+	int			i, j;
+	cplane_t	*out;
+	dplane_t 	*in;
+	int			count;
+	int			bits;
+	
+	in = (dplane_t *)(cmod_base + l->fileofs);
+	if (l->filelen % sizeof(*in))
+		Com_Error (ERR_DROP, "MOD_LoadBmodel: funny lump size");
+	count = l->filelen / sizeof(*in);
+
+	if (count < 1)
+		Com_Error (ERR_DROP, "Map with no planes");
+	cm.planes = (struct cplane_s *) Z_Malloc( ( BOX_PLANES + count ) * sizeof( *cm.planes ), TAG_BSP, qfalse);
+	cm.numPlanes = count;
+
+	out = cm.planes;	
+
+	for ( i=0 ; i<count ; i++, in++, out++)
+	{
+		bits = 0;
+		for (j=0 ; j<3 ; j++)
+		{
+			out->normal[j] = LittleFloat (in->normal[j]);
+			if (out->normal[j] < 0)
+				bits |= 1<<j;
+		}
+
+		out->dist = LittleFloat (in->dist);
+		out->type = PlaneTypeForNormal( out->normal );
+		out->signbits = bits;
+	}
+}
+
+/*
+=================
+CMod_LoadLeafBrushes
+=================
+*/
+void CMod_LoadLeafBrushes (lump_t *l, clipMap_t &cm)
+{
+	int			i;
+	int			*out;
+	int		 	*in;
+	int			count;
+	
+	in = (int *)(cmod_base + l->fileofs);
+	if (l->filelen % sizeof(*in))
+		Com_Error (ERR_DROP, "MOD_LoadBmodel: funny lump size");
+	count = l->filelen / sizeof(*in);
+
+	cm.leafbrushes = (int *) Z_Malloc( ( BOX_BRUSHES + count ) * sizeof( *cm.leafbrushes ), TAG_BSP, qfalse);
+	cm.numLeafBrushes = count;
+
+	out = cm.leafbrushes;
+
+	for ( i=0 ; i<count ; i++, in++, out++) {
+		*out = LittleLong (*in);
+	}
+}
+
+/*
+=================
+CMod_LoadLeafSurfaces
+=================
+*/
+void CMod_LoadLeafSurfaces( lump_t *l, clipMap_t &cm )
+{
+	int			i;
+	int			*out;
+	int		 	*in;
+	int			count;
+	
+	in = (int *)(cmod_base + l->fileofs);
+	if (l->filelen % sizeof(*in))
+		Com_Error (ERR_DROP, "MOD_LoadBmodel: funny lump size");
+	count = l->filelen / sizeof(*in);
+
+	cm.leafsurfaces = (int *) Z_Malloc( count * sizeof( *cm.leafsurfaces ), TAG_BSP, qfalse);
+	cm.numLeafSurfaces = count;
+
+	out = cm.leafsurfaces;
+
+	for ( i=0 ; i<count ; i++, in++, out++) {
+		*out = LittleLong (*in);
+	}
+}
+
+/*
+=================
+CMod_LoadBrushSides
+=================
+*/
+void CMod_LoadBrushSides (lump_t *l, clipMap_t &cm)
+{
+	int				i;
+	cbrushside_t	*out;
+	dbrushside_t 	*in;
+	int				count;
+	int				num;
+
+	in = (dbrushside_t *)(cmod_base + l->fileofs);
+	if ( l->filelen % sizeof(*in) ) {
+		Com_Error (ERR_DROP, "MOD_LoadBmodel: funny lump size");
+	}
+	count = l->filelen / sizeof(*in);
+
+	cm.brushsides = (cbrushside_t *) Z_Malloc( ( BOX_SIDES + count ) * sizeof( *cm.brushsides ), TAG_BSP, qfalse);
+	cm.numBrushSides = count;
+
+	out = cm.brushsides;	
+
+	for ( i=0 ; i<count ; i++, in++, out++) {
+		num = LittleLong( in->planeNum );
+		out->plane = &cm.planes[num];
+		out->shaderNum = LittleLong( in->shaderNum );
+		if ( out->shaderNum < 0 || out->shaderNum >= cm.numShaders ) {
+			Com_Error( ERR_DROP, "CMod_LoadBrushSides: bad shaderNum: %i", out->shaderNum );
+		}
+//		out->surfaceFlags = cm.shaders[out->shaderNum].surfaceFlags;
+	}
+}
+
+
+/*
+=================
+CMod_LoadEntityString
+=================
+*/
+void CMod_LoadEntityString( lump_t *l, clipMap_t &cm ) {
+	cm.entityString = (char *) Z_Malloc( l->filelen, TAG_BSP, qfalse);
+	cm.numEntityChars = l->filelen;
+	memcpy (cm.entityString, cmod_base + l->fileofs, l->filelen);
+}
+
+/*
+=================
+CMod_LoadVisibility
+=================
+*/
+#define	VIS_HEADER	8
+void CMod_LoadVisibility( lump_t *l, clipMap_t &cm ) {
+	int		len;
+	byte	*buf;
+
+    len = l->filelen;
+	if ( !len ) {
+		cm.clusterBytes = ( cm.numClusters + 31 ) & ~31;
+		cm.visibility = (unsigned char *) Z_Malloc( cm.clusterBytes, TAG_BSP, qfalse);
+		memset( cm.visibility, 255, cm.clusterBytes );
+		return;
+	}
+	buf = cmod_base + l->fileofs;
+
+	cm.vised = qtrue;
+	cm.visibility = (unsigned char *) Z_Malloc( len, TAG_BSP, qtrue );
+	cm.numClusters = LittleLong( ((int *)buf)[0] );
+	cm.clusterBytes = LittleLong( ((int *)buf)[1] );
+	memcpy (cm.visibility, buf + VIS_HEADER, len - VIS_HEADER );
+}
+
+//==================================================================
+
+
+/*
+=================
+CMod_LoadPatches
+=================
+*/
+#define	MAX_PATCH_VERTS		1024
+void CMod_LoadPatches( lump_t *surfs, lump_t *verts, clipMap_t &cm ) {
+	mapVert_t	*dv, *dv_p;
+	dsurface_t	*in;
+	int			count;
+	int			i, j;
+	int			c;
+	cPatch_t	*patch;
+	vec3_t		points[MAX_PATCH_VERTS];
+	int			width, height;
+	int			shaderNum;
+
+	in = (dsurface_t *)(cmod_base + surfs->fileofs);
+	if (surfs->filelen % sizeof(*in))
+		Com_Error (ERR_DROP, "MOD_LoadBmodel: funny lump size");
+	cm.numSurfaces = count = surfs->filelen / sizeof(*in);
+	cm.surfaces = (cPatch_t **) Z_Malloc( cm.numSurfaces * sizeof( cm.surfaces[0] ), TAG_BSP, qtrue );
+
+	dv = (mapVert_t *)(cmod_base + verts->fileofs);
+	if (verts->filelen % sizeof(*dv))
+		Com_Error (ERR_DROP, "MOD_LoadBmodel: funny lump size");
+
+	// scan through all the surfaces, but only load patches,
+	// not planar faces
+	for ( i = 0 ; i < count ; i++, in++ ) {
+		if ( LittleLong( in->surfaceType ) != MST_PATCH ) {
+			continue;		// ignore other surfaces
+		}
+		// FIXME: check for non-colliding patches
+
+		cm.surfaces[ i ] = patch = (cPatch_t *) Z_Malloc( sizeof( *patch ), TAG_BSP, qtrue );
+
+		// load the full drawverts onto the stack
+		width = LittleLong( in->patchWidth );
+		height = LittleLong( in->patchHeight );
+		c = width * height;
+		if ( c > MAX_PATCH_VERTS ) {
+			Com_Error( ERR_DROP, "ParseMesh: MAX_PATCH_VERTS" );
+		}
+
+		dv_p = dv + LittleLong( in->firstVert );
+		for ( j = 0 ; j < c ; j++, dv_p++ ) {
+			points[j][0] = LittleFloat( dv_p->xyz[0] );
+			points[j][1] = LittleFloat( dv_p->xyz[1] );
+			points[j][2] = LittleFloat( dv_p->xyz[2] );
+		}
+
+		shaderNum = LittleLong( in->shaderNum );
+		patch->contents = cm.shaders[shaderNum].contentFlags;
+		CM_OrOfAllContentsFlagsInMap |= patch->contents;
+
+		patch->surfaceFlags = cm.shaders[shaderNum].surfaceFlags;
+
+		// create the internal facet structure
+		patch->pc = CM_GeneratePatchCollide( width, height, points );
+	}
+}
+
+//==================================================================
+
+#ifdef BSPC
+/*
+==================
+CM_FreeMap
+
+Free any loaded map and all submodels
+==================
+*/
+void CM_FreeMap(void) {
+	memset( &cm, 0, sizeof( cm ) );
+	Hunk_ClearHigh();
+	CM_ClearLevelPatches();
+}
+#endif //BSPC
+
+unsigned CM_LumpChecksum(lump_t *lump) {
+	return LittleLong (Com_BlockChecksum (cmod_base + lump->fileofs, lump->filelen));
+}
+
+unsigned CM_Checksum(dheader_t *header) {
+	unsigned checksums[16];
+	checksums[0] = CM_LumpChecksum(&header->lumps[LUMP_SHADERS]);
+	checksums[1] = CM_LumpChecksum(&header->lumps[LUMP_LEAFS]);
+	checksums[2] = CM_LumpChecksum(&header->lumps[LUMP_LEAFBRUSHES]);
+	checksums[3] = CM_LumpChecksum(&header->lumps[LUMP_LEAFSURFACES]);
+	checksums[4] = CM_LumpChecksum(&header->lumps[LUMP_PLANES]);
+	checksums[5] = CM_LumpChecksum(&header->lumps[LUMP_BRUSHSIDES]);
+	checksums[6] = CM_LumpChecksum(&header->lumps[LUMP_BRUSHES]);
+	checksums[7] = CM_LumpChecksum(&header->lumps[LUMP_MODELS]);
+	checksums[8] = CM_LumpChecksum(&header->lumps[LUMP_NODES]);
+	checksums[9] = CM_LumpChecksum(&header->lumps[LUMP_SURFACES]);
+	checksums[10] = CM_LumpChecksum(&header->lumps[LUMP_DRAWVERTS]);
+
+	return LittleLong(Com_BlockChecksum(checksums, 11 * 4));
+}
+
+/*
+==================
+CM_LoadMap
+
+Loads in the map and all submodels
+==================
+*/
+void *gpvCachedMapDiskImage = NULL;
+char  gsCachedMapDiskImage[MAX_QPATH];
+qboolean gbUsingCachedMapDataRightNow = qfalse;	// if true, signifies that you can't delete this at the moment!! (used during z_malloc()-fail recovery attempt)
+
+// called in response to a "devmapbsp blah" or "devmapall blah" command, do NOT use inside CM_Load unless you pass in qtrue
+//
+// new bool return used to see if anything was freed, used during z_malloc failure re-try
+//
+qboolean CM_DeleteCachedMap(qboolean bGuaranteedOkToDelete)
+{
+	qboolean bActuallyFreedSomething = qfalse;
+
+	if (bGuaranteedOkToDelete || !gbUsingCachedMapDataRightNow)
+	{
+		// dump cached disk image...
+		//
+		if (gpvCachedMapDiskImage)
+		{
+			Z_Free(	gpvCachedMapDiskImage );
+					gpvCachedMapDiskImage = NULL;
+
+			bActuallyFreedSomething = qtrue;
+		}
+		gsCachedMapDiskImage[0] = '\0';
+		
+		// force map loader to ignore cached internal BSP structures for next level CM_LoadMap() call...
+		//
+		cmg.name[0] = '\0';
+	}
+
+	return bActuallyFreedSomething;
+}
+
+static void CM_LoadMap_Actual( const char *name, qboolean clientload, int *checksum, clipMap_t &cm ) {
+	const int		*buf;
+	int				i;
+	dheader_t		header;
+	static unsigned	last_checksum;
+	void			*subBSPData = NULL;
+
+	if ( !name || !name[0] ) {
+		Com_Error( ERR_DROP, "CM_LoadMap: NULL name" );
+	}
+
+#ifndef BSPC
+	cm_noAreas = Cvar_Get ("cm_noAreas", "0", CVAR_CHEAT);
+	cm_noCurves = Cvar_Get ("cm_noCurves", "0", CVAR_CHEAT);
+	cm_playerCurveClip = Cvar_Get ("cm_playerCurveClip", "1", CVAR_ARCHIVE|CVAR_CHEAT );
+#endif
+	Com_DPrintf( "CM_LoadMap( %s, %i )\n", name, clientload );
+
+	if ( !strcmp( cm.name, name ) && clientload ) {
+		*checksum = last_checksum;
+		return;
+	}
+
+	if (&cm == &cmg)
+	{
+		// if there was a cached disk image but the name was empty (ie ERR_DROP happened) or just doesn't match
+		//	the current name, then ditch it...
+		//	
+		if (gpvCachedMapDiskImage && 
+			(gsCachedMapDiskImage[0] == '\0' || strcmp( gsCachedMapDiskImage, name ))
+			)
+		{
+			Z_Free(gpvCachedMapDiskImage);
+				   gpvCachedMapDiskImage = NULL;
+		   gsCachedMapDiskImage[0] = '\0';
+
+		   CM_ClearMap();
+		}
+	}
+
+	// if there's a valid map name, and it's the same as last time (respawn?), and it's the server-load, 
+	//	then keep the data from last time...
+	//
+	if (name[0] && !strcmp( cm.name, name ) && !clientload && &cm == &cmg )
+	{
+		// clear some stuff that needs zeroing...
+		//
+		cm.floodvalid = 0;
+		//NO... don't reset this because the brush checkcounts are cached, 
+		//so when you load up, brush checkcounts equal the cm.checkcount 
+		//and the trace will be skipped (because everything loads and
+		//traces in the same exact order ever time you load the map)
+		cm.checkcount++;// = 0;
+		memset(cm.areas,		0, cm.numAreas * sizeof( *cm.areas ));
+		memset(cm.areaPortals,	0, cm.numAreas * cm.numAreas * sizeof( *cm.areaPortals ));		
+	}
+	else
+	{
+		// ... else load map from scratch...
+		//
+		if (&cm == &cmg)
+		{
+			assert(!clientload);	// logic check. I'm assuming that a client load doesn't get this far?
+
+			// free old stuff
+			memset( &cm, 0, sizeof( cm ) );
+			CM_ClearLevelPatches();
+			Z_TagFree(TAG_BSP);
+
+			if ( !name[0] ) {
+				cm.numLeafs = 1;
+				cm.numClusters = 1;
+				cm.numAreas = 1;
+				cm.cmodels = (struct cmodel_s *) Z_Malloc( sizeof( *cm.cmodels ), TAG_BSP, qtrue );
+				*checksum = 0;
+				return;
+			}		
+		}
+
+		// load the file into a buffer that we either discard as usual at the bottom, or if we've got enough memory
+		//	then keep it long enough to save the renderer re-loading it, then discard it after that.
+		//
+		fileHandle_t h;
+		const int iBSPLen = FS_FOpenFileRead( name, &h, qfalse );
+		if(!h)
+		{
+			Com_Error (ERR_DROP, "Couldn't load %s", name);
+			return;
+		}
+		//rww - only do this when not loading a sub-bsp!
+		if (&cm == &cmg)
+		{
+			if (gpvCachedMapDiskImage && gsCachedMapDiskImage[0])
+			{ //didn't get cleared elsewhere so free it before we allocate the pointer again
+			  //Maps with terrain will allow this to happen because they want everything to be cleared out (going between terrain and no-terrain is messy)
+				Z_Free(gpvCachedMapDiskImage);
+			}
+			gsCachedMapDiskImage[0]	= '\0';		// flag that map isn't valid, until name is filled in
+			gpvCachedMapDiskImage	= Z_Malloc( iBSPLen, TAG_BSP_DISKIMAGE, qfalse);
+			FS_Read(gpvCachedMapDiskImage, iBSPLen, h);
+			FS_FCloseFile( h );
+			
+			buf = (int*) gpvCachedMapDiskImage;	// so the rest of the code works as normal
+		}
+		else
+		{ //otherwise, read straight in..
+			subBSPData = Z_Malloc( iBSPLen, TAG_BSP_DISKIMAGE, qfalse);
+			FS_Read(subBSPData, iBSPLen, h);
+			FS_FCloseFile( h );
+
+			buf = (int*)subBSPData;
+		}
+
+		// carry on as before...
+
+		last_checksum = LittleLong (Com_BlockChecksum (buf, iBSPLen));		
+
+		header = *(dheader_t *)buf;
+		for (i=0 ; i<sizeof(dheader_t)/4 ; i++) {
+			((int *)&header)[i] = LittleLong ( ((int *)&header)[i]);
+		}
+
+		if ( header.version != BSP_VERSION )
+		{
+			Z_Free(	gpvCachedMapDiskImage);
+					gpvCachedMapDiskImage = NULL;
+
+			Com_Error (ERR_DROP, "CM_LoadMap: %s has wrong version number (%i should be %i)"
+			, name, header.version, BSP_VERSION );
+		}
+
+		cmod_base = (byte *)buf;
+
+		// load into heap
+		CMod_LoadShaders( &header.lumps[LUMP_SHADERS], cm );
+		CMod_LoadLeafs (&header.lumps[LUMP_LEAFS], cm);
+		CMod_LoadLeafBrushes (&header.lumps[LUMP_LEAFBRUSHES], cm);
+		CMod_LoadLeafSurfaces (&header.lumps[LUMP_LEAFSURFACES], cm);
+		CMod_LoadPlanes (&header.lumps[LUMP_PLANES], cm);
+		CMod_LoadBrushSides (&header.lumps[LUMP_BRUSHSIDES], cm);
+		CMod_LoadBrushes (&header.lumps[LUMP_BRUSHES], cm);
+		CMod_LoadSubmodels (&header.lumps[LUMP_MODELS], cm);
+		CMod_LoadNodes (&header.lumps[LUMP_NODES], cm);
+		CMod_LoadEntityString (&header.lumps[LUMP_ENTITIES], cm);
+		CMod_LoadVisibility( &header.lumps[LUMP_VISIBILITY], cm );
+		CMod_LoadPatches( &header.lumps[LUMP_SURFACES], &header.lumps[LUMP_DRAWVERTS], cm );
+
+		TotalSubModels += cm.numSubModels;
+
+		// we are NOT freeing the file, because it is cached for the ref
+		//actually we do because the new hunk sys won't allow it
+		// actually we DON'T now <g>, if we've got enough ram to keep it for the renderer's disk-load...
+		//
+		extern qboolean Sys_LowPhysicalMemory();
+		if (Sys_LowPhysicalMemory() //|| com_dedicated->integer	// no need to check for dedicated in single-player codebase
+			)
+		{
+			Z_Free(	gpvCachedMapDiskImage );
+					gpvCachedMapDiskImage = NULL;
+		}
+		else
+		{
+			// ... do nothing, and let the renderer free it after it's finished playing with it...
+			//
+		}
+
+		if (subBSPData)
+		{
+			Z_Free(subBSPData);
+		}
+
+		if (&cm == &cmg)
+		{
+#if !defined(BSPC)
+			CM_LoadShaderText(false);
+//			MAT_Init((bool)(!clientload));
+#endif
+			CM_InitBoxHull ();
+#if !defined(BSPC)
+			CM_SetupShaderProperties();
+#endif
+
+			Q_strncpyz( gsCachedMapDiskImage, name, sizeof(gsCachedMapDiskImage) );	// so the renderer can check it
+		}
+	}
+
+	*checksum = last_checksum;	
+
+	// do this whether or not the map was cached from last load...
+	//
+	CM_FloodAreaConnections (cm);
+
+	// allow this to be cached if it is loaded by the server
+	if ( !clientload ) {
+		Q_strncpyz( cm.name, name, sizeof( cm.name ) );
+	}
+	CM_CleanLeafCache();
+}
+
+// need a wrapper function around this because of multiple returns, need to ensure bool is correct...
+//
+void CM_LoadMap( const char *name, qboolean clientload, int *checksum, qboolean subBSP )
+{
+	if (subBSP)
+	{
+		CM_LoadSubBSP(va("maps/%s.bsp", ((const char *)name) + 1), qfalse);
+		//CM_LoadMap_Actual( name, clientload, checksum, cmg );
+	}
+	else
+	{
+		gbUsingCachedMapDataRightNow = qtrue;	// !!!!!!!!!!!!!!!!!!
+
+			CM_LoadMap_Actual( name, clientload, checksum, cmg );
+
+		gbUsingCachedMapDataRightNow = qfalse;	// !!!!!!!!!!!!!!!!!!
+	}
+	/*
+	gbUsingCachedMapDataRightNow = qtrue;	// !!!!!!!!!!!!!!!!!!
+
+		CM_LoadMap_Actual( name, clientload, checksum, cmg );
+
+	gbUsingCachedMapDataRightNow = qfalse;	// !!!!!!!!!!!!!!!!!!
+	*/
+}
+
+qboolean CM_SameMap(char *server)
+{
+	if (!cmg.name[0] || !server || !server[0])
+	{
+		return qfalse;
+	}
+
+	if (Q_stricmp(cmg.name, va("maps/%s.bsp", server)))
+	{
+		return qfalse;
+	}
+
+	return qtrue;
+}
+
+qboolean CM_HasTerrain(void)
+{
+	if (cmg.landScape)
+	{
+		return qtrue;
+	}
+
+	return qfalse;
+}
+
+/*
+==================
+CM_ClearMap
+==================
+*/
+void CM_ClearMap( void ) 
+{
+	int		i;
+
+	CM_OrOfAllContentsFlagsInMap = CONTENTS_BODY;
+
+#if !defined(BSPC)
+	CM_ShutdownShaderProperties();
+//	MAT_Shutdown();
+#endif
+
+	if (TheRandomMissionManager)
+	{
+		delete TheRandomMissionManager;
+		TheRandomMissionManager = 0;
+	}
+
+	if (cmg.landScape)
+	{
+		delete cmg.landScape;
+		cmg.landScape = 0;
+	}
+
+	memset( &cmg, 0, sizeof( cmg ) );
+	CM_ClearLevelPatches();
+
+	for(i = 0; i < NumSubBSP; i++)
+	{
+		memset(&SubBSP[i], 0, sizeof(SubBSP[0]));
+	}
+	NumSubBSP = 0;
+	TotalSubModels = 0;
+}
+
+int CM_TotalMapContents()
+{
+	return CM_OrOfAllContentsFlagsInMap;
+}
+
+/*
+==================
+CM_ClipHandleToModel
+==================
+*/
+cmodel_t	*CM_ClipHandleToModel( clipHandle_t handle, clipMap_t **clipMap )
+{
+	int		i;
+	int		count;
+
+	if ( handle < 0 ) 
+	{
+		Com_Error( ERR_DROP, "CM_ClipHandleToModel: bad handle %i", handle );
+	}
+	if ( handle < cmg.numSubModels ) 
+	{
+		if (clipMap)
+		{
+			*clipMap = &cmg;
+		}
+		return &cmg.cmodels[handle];
+	}
+	if ( handle == BOX_MODEL_HANDLE ) 
+	{
+		if (clipMap)
+		{
+			*clipMap = &cmg;
+		}
+		return &box_model;
+	}
+
+	count = cmg.numSubModels;
+	for(i = 0; i < NumSubBSP; i++)
+	{
+		if (handle < count + SubBSP[i].numSubModels)
+		{
+			if (clipMap)
+			{
+				*clipMap = &SubBSP[i];
+			}
+			return &SubBSP[i].cmodels[handle - count];
+		}
+		count += SubBSP[i].numSubModels;
+	}
+
+	if ( handle < MAX_SUBMODELS ) 
+	{
+		Com_Error( ERR_DROP, "CM_ClipHandleToModel: bad handle %i < %i < %i", 
+			cmg.numSubModels, handle, MAX_SUBMODELS );
+	}
+	Com_Error( ERR_DROP, "CM_ClipHandleToModel: bad handle %i", handle + MAX_SUBMODELS );
+
+	return NULL;
+}
+/*
+==================
+CM_InlineModel
+==================
+*/
+clipHandle_t	CM_InlineModel( int index ) {
+	if ( index < 0 || index >= TotalSubModels ) {
+		Com_Error (ERR_DROP, "CM_InlineModel: bad number (may need to re-BSP map?)");
+	}
+	return index;
+}
+
+int		CM_NumClusters( void ) {
+	return cmg.numClusters;
+}
+
+int		CM_NumInlineModels( void ) {
+	return cmg.numSubModels;
+}
+
+char	*CM_EntityString( void ) {
+	return cmg.entityString;
+}
+
+char *CM_SubBSPEntityString( int index ) 
+{
+	return SubBSP[index].entityString;
+}
+
+int		CM_LeafCluster( int leafnum ) {
+	if (leafnum < 0 || leafnum >= cmg.numLeafs) {
+		Com_Error (ERR_DROP, "CM_LeafCluster: bad number");
+	}
+	return cmg.leafs[leafnum].cluster;
+}
+
+int		CM_LeafArea( int leafnum ) {
+	if ( leafnum < 0 || leafnum >= cmg.numLeafs ) {
+		Com_Error (ERR_DROP, "CM_LeafArea: bad number");
+	}
+	return cmg.leafs[leafnum].area;
+}
+
+//=======================================================================
+
+
+/*
+===================
+CM_InitBoxHull
+
+Set up the planes and nodes so that the six floats of a bounding box
+can just be stored out and get a proper clipping hull structure.
+===================
+*/
+void CM_InitBoxHull (void)
+{
+	int			i;
+	int			side;
+	cplane_t	*p;
+	cbrushside_t	*s;
+
+	box_planes = &cmg.planes[cmg.numPlanes];
+
+	box_brush = &cmg.brushes[cmg.numBrushes];
+	box_brush->numsides = 6;
+	box_brush->sides = cmg.brushsides + cmg.numBrushSides;
+	box_brush->contents = CONTENTS_BODY;
+
+	box_model.leaf.numLeafBrushes = 1;
+//	box_model.leaf.firstLeafBrush = cmg.numBrushes;
+	box_model.leaf.firstLeafBrush = cmg.numLeafBrushes;
+	cmg.leafbrushes[cmg.numLeafBrushes] = cmg.numBrushes;
+
+	for (i=0 ; i<6 ; i++)
+	{
+		side = i&1;
+
+		// brush sides
+		s = &cmg.brushsides[cmg.numBrushSides+i];
+		s->plane = 	cmg.planes + (cmg.numPlanes+i*2+side);
+		s->shaderNum = cmg.numShaders;	//not storing flags directly anymore, so be sure to point @ a valid shader 
+
+		// planes
+		p = &box_planes[i*2];
+		p->type = i>>1;
+		p->signbits = 0;
+		VectorClear (p->normal);
+		p->normal[i>>1] = 1;
+
+		p = &box_planes[i*2+1];
+		p->type = 3 + (i>>1);
+		p->signbits = 0;
+		VectorClear (p->normal);
+		p->normal[i>>1] = -1;
+
+		SetPlaneSignbits( p );
+	}	
+}
+
+
+
+/*
+===================
+CM_HeadnodeForBox
+
+To keep everything totally uniform, bounding boxes are turned into small
+BSP trees instead of being compared directly.
+===================
+*/
+clipHandle_t CM_TempBoxModel( const vec3_t mins, const vec3_t maxs) {//, const int contents ) {
+	box_planes[0].dist = maxs[0];
+	box_planes[1].dist = -maxs[0];
+	box_planes[2].dist = mins[0];
+	box_planes[3].dist = -mins[0];
+	box_planes[4].dist = maxs[1];
+	box_planes[5].dist = -maxs[1];
+	box_planes[6].dist = mins[1];
+	box_planes[7].dist = -mins[1];
+	box_planes[8].dist = maxs[2];
+	box_planes[9].dist = -maxs[2];
+	box_planes[10].dist = mins[2];
+	box_planes[11].dist = -mins[2];
+
+	VectorCopy( mins, box_brush->bounds[0] );
+	VectorCopy( maxs, box_brush->bounds[1] );
+
+	//FIXME: this is the "correct" way, but not the way JK2 was designed around... fix for further projects
+	//box_brush->contents = contents;
+
+	return BOX_MODEL_HANDLE;
+}
+
+
+/*
+===================
+CM_ModelBounds
+===================
+*/
+void CM_ModelBounds( clipMap_t &cm, clipHandle_t model, vec3_t mins, vec3_t maxs ) 
+{
+	cmodel_t	*cmod;
+
+	cmod = CM_ClipHandleToModel( model );
+	VectorCopy( cmod->mins, mins );
+	VectorCopy( cmod->maxs, maxs );
+}
+
+/*
+===================
+CM_RegisterTerrain
+
+Allows physics to examine the terrain data.
+===================
+*/
+#if !defined(BSPC)
+CCMLandScape *CM_RegisterTerrain(const char *config, bool server)
+{
+	thandle_t		terrainId;
+	CCMLandScape	*ls;
+
+	terrainId = atol(Info_ValueForKey(config, "terrainId"));
+	if(terrainId && cmg.landScape)
+	{
+		// Already spawned so just return
+		ls = cmg.landScape;
+		ls->IncreaseRefCount();
+		return(ls);
+	}
+	// Doesn't exist so create and link in
+	//cmg.numTerrains++;
+	ls = CM_InitTerrain(config, 1, server);
+
+	// Increment for the next instance
+	if (cmg.landScape)
+	{
+		Com_Error(ERR_DROP, "You can't have more than one terrain brush.");
+	}
+	cmg.landScape = ls;
+	return(ls);
+}
+
+/*
+===================
+CM_ShutdownTerrain
+===================
+*/
+
+void CM_ShutdownTerrain( thandle_t terrainId)
+{
+	CCMLandScape	*landscape;
+
+	landscape = cmg.landScape;
+	if (landscape)
+	{
+		landscape->DecreaseRefCount();
+		if(landscape->GetRefCount() <= 0)
+		{
+			delete landscape;
+			cmg.landScape = NULL;
+		}
+	}
+}
+#endif
+
+int CM_LoadSubBSP(const char *name, qboolean clientload)
+{
+	int		i;
+	int		checksum;
+	int		count;
+
+	count = cmg.numSubModels;
+	for(i = 0; i < NumSubBSP; i++)
+	{
+		if (!stricmp(name, SubBSP[i].name))
+		{
+			return count;
+		}
+		count += SubBSP[i].numSubModels;
+	}
+
+	if (NumSubBSP == MAX_SUB_BSP)
+	{
+		Com_Error (ERR_DROP, "CM_LoadSubBSP: too many unique sub BSPs");
+	}
+
+	CM_LoadMap_Actual( name, clientload, &checksum, SubBSP[NumSubBSP] );
+	NumSubBSP++;
+
+	return count;
+}
+
+int CM_FindSubBSP(int modelIndex)
+{
+	int		i;
+	int		count;
+
+	count = cmg.numSubModels;
+	if (modelIndex < count)
+	{	// belongs to the main bsp
+		return -1;
+	}
+
+	for(i = 0; i < NumSubBSP; i++)
+	{
+		count += SubBSP[i].numSubModels;
+		if (modelIndex < count)
+		{
+			return i;
+		}
+	}
+	return -1;
+}
+
+void CM_GetWorldBounds ( vec3_t mins, vec3_t maxs )
+{
+	VectorCopy ( cmg.cmodels[0].mins, mins );
+	VectorCopy ( cmg.cmodels[0].maxs, maxs );
+}
+
+int CM_ModelContents_Actual( clipHandle_t model, clipMap_t *cm ) 
+{
+	cmodel_t	*cmod;
+	int			contents = 0;
+	int			i;
+
+	if (!cm)
+	{
+		cm = &cmg;
+	}
+
+	cmod = CM_ClipHandleToModel( model, &cm );
+
+	//MCG ADDED - return the contents, too
+	if( cmod->leaf.numLeafBrushes )		// check for brush
+	{
+		int brushNum;
+		for ( i = cmod->leaf.firstLeafBrush; i < cmod->leaf.firstLeafBrush+cmod->leaf.numLeafBrushes; i++ )
+		{
+			brushNum = cm->leafbrushes[i];
+			contents |= cm->brushes[brushNum].contents;
+		}
+	}
+	if( cmod->leaf.numLeafSurfaces )	// if not brush, check for patch
+	{	
+		int surfaceNum;
+		for ( i = cmod->leaf.firstLeafSurface; i < cmod->leaf.firstLeafSurface+cmod->leaf.numLeafSurfaces; i++ )
+		{
+			surfaceNum = cm->leafsurfaces[i];
+			if ( cm->surfaces[surfaceNum] != NULL )
+			{//HERNH?  How could we have a null surf within our cmod->leaf.numLeafSurfaces?
+				contents |= cm->surfaces[surfaceNum]->contents;
+			}
+		}
+	}
+	return contents;
+}
+
+int CM_ModelContents(  clipHandle_t model, int subBSPIndex )
+{
+	if (subBSPIndex < 0)
+	{
+		return CM_ModelContents_Actual(model, NULL);
+	}
+
+	return CM_ModelContents_Actual(model, &SubBSP[subBSPIndex]);
+}
+
+//support for save/load games
+/*
+===================
+CM_WritePortalState
+
+Writes the portal state to a savegame file
+===================
+*/
+//
+qboolean SG_Append(unsigned long chid, const void *data, int length);
+int SG_Read(unsigned long chid, void *pvAddress, int iLength, void **ppvAddressPtr = NULL);
+
+void CM_WritePortalState ()
+{	
+	SG_Append('PRTS', (void *)cmg.areaPortals, cmg.numAreas * cmg.numAreas * sizeof( *cmg.areaPortals ));
+}
+
+/*
+===================
+CM_ReadPortalState
+
+Reads the portal state from a savegame file
+and recalculates the area connections
+===================
+*/
+void	CM_ReadPortalState ()
+{
+	SG_Read('PRTS', (void *)cmg.areaPortals, cmg.numAreas * cmg.numAreas * sizeof( *cmg.areaPortals ));
+	CM_FloodAreaConnections (cmg);
+}
+
diff --git a/code/qcommon/cm_load_xbox.cpp b/code/qcommon/cm_load_xbox.cpp
new file mode 100644
index 0000000..70ae607
--- /dev/null
+++ b/code/qcommon/cm_load_xbox.cpp
@@ -0,0 +1,1249 @@
+// cmodel.c -- model loading
+
+#include "cm_local.h"
+#include "cm_patch.h"
+#include "../renderer/tr_local.h"
+#include "../RMG/RM_Headers.h"
+
+#include "sparc.h"
+#include "../zlib/zlib.h"
+
+static SPARC<byte> visData;
+
+void *SparcAllocator(unsigned int size)
+{
+	return Z_Malloc(size, TAG_BSP, false);
+}
+
+void SparcDeallocator(void *ptr)
+{
+	Z_Free(ptr);
+}
+
+extern world_t	s_worldData;
+
+
+void CM_LoadShaderText(bool forceReload);
+
+#ifdef BSPC
+void SetPlaneSignbits (cplane_t *out) {
+	int	bits, j;
+
+	// for fast box on planeside test
+	bits = 0;
+	for (j=0 ; j<3 ; j++) {
+		if (out->normal[j] < 0) {
+			bits |= 1<<j;
+		}
+	}
+	out->signbits = bits;
+}
+#endif //BSPC
+
+// to allow boxes to be treated as brush models, we allocate
+// some extra indexes along with those needed by the map
+#define	BOX_BRUSHES		1
+#define	BOX_SIDES		6
+#define	BOX_LEAFS		2
+#define	BOX_PLANES		12
+
+#define	LL(x) x=LittleLong(x)
+
+clipMap_t	cmg;
+int			c_pointcontents;
+int			c_traces, c_brush_traces, c_patch_traces;
+
+
+byte		*cmod_base;
+
+#ifndef BSPC
+cvar_t		*cm_noAreas;
+cvar_t		*cm_noCurves;
+cvar_t		*cm_playerCurveClip;
+#endif
+
+cmodel_t	box_model;
+cplane_t	*box_planes;
+cbrush_t	*box_brush;
+
+int			CM_OrOfAllContentsFlagsInMap;
+
+
+void	CM_InitBoxHull (void);
+void	CM_FloodAreaConnections (void);
+
+clipMap_t	SubBSP[MAX_SUB_BSP];
+int			NumSubBSP = 0, TotalSubModels = 0;
+
+/*
+===============================================================================
+
+					MAP LOADING
+
+===============================================================================
+*/
+
+/*
+=================
+CMod_LoadShaders
+=================
+*/
+void CMod_LoadShaders( void *data, int len ) {
+	dshader_t	*in;
+	int			i, count;
+	CCMShader	*out;
+
+	in = (dshader_t *)(data);
+	if (len % sizeof(*in)) {
+		Com_Error (ERR_DROP, "CMod_LoadShaders: funny lump size");
+	}
+	count = len / sizeof(*in);
+
+	if (count < 1) {
+		Com_Error (ERR_DROP, "Map with no shaders");
+	}
+	cmg.shaders = (CCMShader *) Z_Malloc( count * sizeof( *cmg.shaders ), TAG_BSP, qfalse);
+	cmg.numShaders = count;
+
+	s_worldData.shaders = (dshader_t *) Z_Malloc ( count*sizeof(dshader_t), TAG_BSP, qfalse );
+	s_worldData.numShaders = count;
+
+	out = cmg.shaders;
+	for ( i = 0; i < count; i++, in++, out++ ) 
+	{
+		Q_strncpyz(out->shader, in->shader, MAX_QPATH);
+		out->contentFlags = in->contentFlags;
+		out->surfaceFlags = in->surfaceFlags;
+
+		Q_strncpyz(s_worldData.shaders[i].shader, in->shader, MAX_QPATH);
+		s_worldData.shaders[i].contentFlags = in->contentFlags;
+		s_worldData.shaders[i].surfaceFlags = in->surfaceFlags;
+	}
+}
+
+
+/*
+=================
+CMod_LoadSubmodels
+=================
+*/
+void CMod_LoadSubmodels( void *data, int len ) {
+	dmodel_t	*in;
+	cmodel_t	*out;
+	int			i, j, count;
+	int			*indexes;
+
+	in = (dmodel_t *)(data);
+	if (len % sizeof(*in))
+		Com_Error (ERR_DROP, "CMod_LoadSubmodels: funny lump size");
+	count = len / sizeof(*in);
+
+	if (count < 1) {
+		Com_Error (ERR_DROP, "Map with no models");
+	}
+
+	if ( count > MAX_SUBMODELS ) {
+		Com_Error( ERR_DROP, "MAX_SUBMODELS (%d) exceeded by %d", MAX_SUBMODELS, count-MAX_SUBMODELS );
+	}
+
+	cmg.cmodels = (struct cmodel_s *) Z_Malloc( count * sizeof( *cmg.cmodels ), TAG_BSP, qtrue );
+	cmg.numSubModels = count;
+
+	for ( i=0 ; i<count ; i++, in++, out++)
+	{
+		out = &cmg.cmodels[i];
+
+		for (j=0 ; j<3 ; j++)
+		{	// spread the mins / maxs by a pixel
+			out->mins[j] = in->mins[j] - 1;
+			out->maxs[j] = in->maxs[j] + 1;
+		}
+
+		if ( i == 0 ) {
+			continue;	// world model doesn't need other info
+		}
+
+		// make a "leaf" just to hold the model's brushes and surfaces
+		out->leaf.numLeafBrushes = in->numBrushes;
+		indexes = (int *) Z_Malloc( out->leaf.numLeafBrushes * 4, TAG_BSP, qfalse);
+		out->leaf.firstLeafBrush = indexes - cmg.leafbrushes;
+		for ( j = 0 ; j < out->leaf.numLeafBrushes ; j++ ) {
+			indexes[j] = in->firstBrush + j;
+		}
+
+		out->leaf.numLeafSurfaces = in->numSurfaces;
+		indexes = (int *) Z_Malloc( out->leaf.numLeafSurfaces * 4, TAG_BSP, qfalse);
+		out->leaf.firstLeafSurface = indexes - cmg.leafsurfaces;
+		for ( j = 0 ; j < out->leaf.numLeafSurfaces ; j++ ) {
+			indexes[j] = in->firstSurface + j;
+		}
+	}
+}
+
+/*
+=================
+CMod_LoadNodes
+
+=================
+*/
+void CMod_LoadNodes( void *data, int len ) {
+	dnode_t		*in;
+	cNode_t		*out;
+	int			i, count;
+	
+	in = (dnode_t *)(data);
+	if (len % sizeof(*in))
+		Com_Error (ERR_DROP, "MOD_LoadBmodel: funny lump size");
+	count = len / sizeof(*in);
+
+	if (count < 1)
+		Com_Error (ERR_DROP, "Map has no nodes");
+	cmg.nodes = (cNode_t *) Z_Malloc( count * sizeof( *cmg.nodes ), TAG_BSP, qfalse);
+	cmg.numNodes = count;
+
+	out = cmg.nodes;
+
+	for (i=0 ; i<count ; i++, out++, in++)
+	{
+		out->children[0] = in->children[0];
+		out->children[1] = in->children[1];
+	}
+}
+
+/*
+=================
+CM_BoundBrush
+
+=================
+*/
+void CM_BoundBrush( cbrush_t *b ) {
+	b->bounds[0][0] = -cmg.planes[b->sides[0].planeNum.GetValue()].dist;
+	b->bounds[1][0] = cmg.planes[b->sides[1].planeNum.GetValue()].dist;
+
+	b->bounds[0][1] = -cmg.planes[b->sides[2].planeNum.GetValue()].dist;
+	b->bounds[1][1] = cmg.planes[b->sides[3].planeNum.GetValue()].dist;
+
+	b->bounds[0][2] = -cmg.planes[b->sides[4].planeNum.GetValue()].dist;
+	b->bounds[1][2] = cmg.planes[b->sides[5].planeNum.GetValue()].dist;
+}
+
+
+/*
+=================
+CMod_LoadBrushes
+
+=================
+*/
+void CMod_LoadBrushes( void *data, int len ) {
+	dbrush_t	*in;
+	cbrush_t	*out;
+	int			i, count;
+
+	in = (dbrush_t *)(data);
+	if (len % sizeof(*in)) {
+		Com_Error (ERR_DROP, "MOD_LoadBmodel: funny lump size");
+	}
+	count = len / sizeof(*in);
+
+	cmg.brushes = (cbrush_t *) Z_Malloc( ( BOX_BRUSHES + count ) * sizeof( *cmg.brushes ), TAG_BSP, qfalse);
+	cmg.numBrushes = count;
+
+	out = cmg.brushes;
+
+	for ( i=0 ; i<count ; i++, out++, in++ ) {
+		out->sides = cmg.brushsides + in->firstSide;
+		out->numsides = in->numSides;
+
+		out->shaderNum = in->shaderNum;
+		if ( out->shaderNum < 0 || out->shaderNum >= cmg.numShaders ) {
+			Com_Error( ERR_DROP, "CMod_LoadBrushes: bad shaderNum: %i", out->shaderNum );
+		}
+		out->contents = cmg.shaders[out->shaderNum].contentFlags;
+		//TEMP HACK: for water that cuts vis but is not solid!!!
+		if ( cmg.shaders[out->shaderNum].surfaceFlags & SURF_SLICK )
+		{
+			out->contents &= ~CONTENTS_SOLID;
+		}
+
+		CM_OrOfAllContentsFlagsInMap |= out->contents;
+
+		CM_BoundBrush( out );
+	}
+
+}
+
+/*
+=================
+CMod_LoadLeafs
+=================
+*/
+void CMod_LoadLeafs (void *data, int len)
+{
+	int			i;
+	cLeaf_t		*out;
+	dleaf_t 	*in;
+	int			count;
+	
+	in = (dleaf_t *)(data);
+	if (len % sizeof(*in))
+		Com_Error (ERR_DROP, "MOD_LoadBmodel: funny lump size");
+	count = len / sizeof(*in);
+
+	if (count < 1)
+		Com_Error (ERR_DROP, "Map with no leafs");
+
+	cmg.leafs = (cLeaf_t *) Z_Malloc( ( BOX_LEAFS + count ) * sizeof( *cmg.leafs ), TAG_BSP, qfalse);
+	cmg.numLeafs = count;
+	out = cmg.leafs;	
+
+	for ( i=0 ; i<count ; i++, in++, out++)
+	{
+		out->cluster = in->cluster;
+		out->area = in->area;
+		out->firstLeafBrush = in->firstLeafBrush;
+		out->numLeafBrushes = in->numLeafBrushes;
+		out->firstLeafSurface = in->firstLeafSurface;
+		out->numLeafSurfaces = in->numLeafSurfaces;
+
+		if (out->cluster >= cmg.numClusters)
+			cmg.numClusters = out->cluster + 1;
+		if (out->area >= cmg.numAreas)
+			cmg.numAreas = out->area + 1;
+	}
+
+	cmg.areas = (cArea_t *) Z_Malloc( cmg.numAreas * sizeof( *cmg.areas ), TAG_BSP, qtrue );
+
+	extern qboolean vidRestartReloadMap;
+	if (!vidRestartReloadMap)
+	{
+		cmg.areaPortals = (int *) Z_Malloc( cmg.numAreas * cmg.numAreas * sizeof( *cmg.areaPortals ), TAG_BSP, qtrue );
+	}
+}
+
+/*
+=================
+CMod_LoadPlanes
+=================
+*/
+void CMod_LoadPlanes (void *data, int len)
+{
+	int			i, j;
+	cplane_t	*out;
+	dplane_t 	*in;
+	int			count;
+	int			bits;
+	
+	in = (dplane_t *)(data);
+	if (len % sizeof(*in))
+		Com_Error (ERR_DROP, "MOD_LoadBmodel: funny lump size");
+	count = len / sizeof(*in);
+
+	if (count < 1)
+		Com_Error (ERR_DROP, "Map with no planes");
+	cmg.planes = (struct cplane_s *) Z_Malloc( ( BOX_PLANES + count ) * sizeof( *cmg.planes ), TAG_BSP, qfalse);
+	cmg.numPlanes = count;
+
+	out = cmg.planes;	
+
+	for ( i=0 ; i<count ; i++, in++, out++)
+	{
+		bits = 0;
+		for (j=0 ; j<3 ; j++)
+		{
+			out->normal[j] = in->normal[j];
+			if (out->normal[j] < 0)
+				bits |= 1<<j;
+		}
+
+		out->dist = in->dist;
+		out->type = PlaneTypeForNormal( out->normal );
+		out->signbits = bits;
+	}
+}
+
+/*
+=================
+CMod_LoadLeafBrushes
+=================
+*/
+void CMod_LoadLeafBrushes (void *data, int len)
+{
+	int			*out;
+	int		 	*in;
+	int			count;
+	
+	in = (int *)(data);
+	if (len % sizeof(*in))
+		Com_Error (ERR_DROP, "MOD_LoadBmodel: funny lump size");
+	count = len / sizeof(*in);
+
+	cmg.leafbrushes = (int *) Z_Malloc( ( BOX_BRUSHES + count ) * sizeof( *cmg.leafbrushes ), TAG_BSP, qfalse);
+	cmg.numLeafBrushes = count;
+
+	out = cmg.leafbrushes;
+
+	memcpy(out, in, len);
+}
+
+/*
+=================
+CMod_LoadBrushSides
+=================
+*/
+void CMod_LoadBrushSides (void *data, int len)
+{
+	int				i;
+	cbrushside_t	*out;
+	dbrushside_t 	*in;
+	int				count;
+
+	in = (dbrushside_t *)(data);
+	if ( len % sizeof(*in) ) {
+		Com_Error (ERR_DROP, "MOD_LoadBmodel: funny lump size");
+	}
+	count = len / sizeof(*in);
+
+	cmg.brushsides = (cbrushside_t *) Z_Malloc( ( BOX_SIDES + count ) * sizeof( *cmg.brushsides ), TAG_BSP, qfalse);
+	cmg.numBrushSides = count;
+
+	out = cmg.brushsides;	
+
+	for ( i=0 ; i<count ; i++, in++, out++) {
+		out->planeNum = in->planeNum;
+		assert(in->planeNum == out->planeNum.GetValue());
+
+		out->shaderNum = in->shaderNum;
+		if ( out->shaderNum < 0 || out->shaderNum >= cmg.numShaders ) {
+			Com_Error( ERR_DROP, "CMod_LoadBrushSides: bad shaderNum: %i", out->shaderNum );
+		}
+	}
+}
+
+
+/*
+=================
+CMod_LoadEntityString
+=================
+*/
+void CMod_LoadEntityString( void *data, int len ) {
+	cmg.entityString = (char *) Z_Malloc( len, TAG_BSP, qfalse);
+	cmg.numEntityChars = len;
+	memcpy (cmg.entityString, data, len);
+}
+
+/*
+=================
+CMod_LoadVisibility
+=================
+*/
+#define	VIS_HEADER	8
+void CMod_LoadVisibility( void *data, int len ) {
+	char	*buf;
+
+	if ( !len ) {
+		cmg.visibility = NULL;
+		return;
+	}
+	buf = (char*)data;
+
+	visData.SetAllocator(SparcAllocator, SparcDeallocator);
+
+	cmg.vised = qtrue;
+	cmg.numClusters = ((int *)buf)[0];
+	cmg.clusterBytes = ((int *)buf)[1];
+	visData.Load(buf + VIS_HEADER, len - VIS_HEADER);
+	cmg.visibility = &visData;
+	RE_SetWorldVisData(&visData);
+}
+
+//==================================================================
+
+
+/*
+=================
+CMod_LoadPatches
+=================
+*/
+#define	MAX_PATCH_VERTS		1024
+
+void CMod_LoadPatches( void *verts, int vertlen, void *surfaces, int surfacelen, int numsurfs ) {
+	mapVert_t	*dv, *dv_p;
+	dpatch_t	*in;
+	int			count;
+	int			i, j;
+	int			c;
+	cPatch_t	*patch;
+	vec3_t		points[MAX_PATCH_VERTS];
+	int			width, height;
+	int			shaderNum;
+
+	count = surfacelen / sizeof(*in);
+
+	cmg.numSurfaces = numsurfs;
+	cmg.surfaces = (cPatch_t **) Z_Malloc( cmg.numSurfaces * sizeof( cmg.surfaces[0] ), TAG_BSP, qtrue );
+
+	dv = (mapVert_t *)(verts);
+	if (vertlen % sizeof(*dv))
+		Com_Error (ERR_DROP, "MOD_LoadBmodel: funny lump size");
+
+	unsigned char* patchScratch = (unsigned char*)Z_Malloc( sizeof( *patch ) * count, TAG_BSP, qtrue);
+	
+	extern void CM_GridAlloc();
+	extern void CM_PatchCollideFromGridTempAlloc();
+	extern void CM_PreparePatchCollide(int num);
+	extern void CM_TempPatchPlanesAlloc();
+	CM_GridAlloc();
+	CM_PatchCollideFromGridTempAlloc();
+	CM_PreparePatchCollide(count);
+	CM_TempPatchPlanesAlloc();
+
+	facetLoad_t *facetbuf = (facetLoad_t*)Z_Malloc(
+		MAX_PATCH_PLANES*sizeof(facetLoad_t), TAG_TEMP_WORKSPACE, qfalse);
+	
+	int *gridbuf = (int*)Z_Malloc(
+		CM_MAX_GRID_SIZE*CM_MAX_GRID_SIZE*2*sizeof(int), TAG_TEMP_WORKSPACE, qfalse);
+
+	for ( i = 0 ; i < count ; i++) {
+		in = (dpatch_t *)surfaces + i;
+
+		cmg.surfaces[ in->code ] = patch = (cPatch_t *) patchScratch;
+		patchScratch += sizeof( *patch );
+
+		// load the full drawverts onto the stack
+		width = in->patchWidth;
+		height = in->patchHeight;
+		c = width * height;
+		if ( c > MAX_PATCH_VERTS ) {
+			Com_Error( ERR_DROP, "ParseMesh: MAX_PATCH_VERTS" );
+		}
+
+		dv_p = dv + (in->verts >> 12);
+		for ( j = 0 ; j < c ; j++, dv_p++ ) {
+			points[j][0] = dv_p->xyz[0];
+			points[j][1] = dv_p->xyz[1];
+			points[j][2] = dv_p->xyz[2];
+		}
+
+		shaderNum = in->shaderNum;
+		patch->contents = cmg.shaders[shaderNum].contentFlags;
+		CM_OrOfAllContentsFlagsInMap |= patch->contents;
+
+		patch->surfaceFlags = cmg.shaders[shaderNum].surfaceFlags;
+
+		// create the internal facet structure
+		patch->pc = CM_GeneratePatchCollide( width, height, points, facetbuf, gridbuf );
+	}
+
+	extern void CM_GridDealloc();
+	extern void CM_PatchCollideFromGridTempDealloc();
+	extern void CM_TempPatchPlanesDealloc();
+	CM_PatchCollideFromGridTempDealloc();
+	CM_GridDealloc();
+	CM_TempPatchPlanesDealloc();
+
+	Z_Free(gridbuf);
+	Z_Free(facetbuf);
+}
+
+//==================================================================
+
+#ifdef BSPC
+/*
+==================
+CM_FreeMap
+
+Free any loaded map and all submodels
+==================
+*/
+void CM_FreeMap(void) {
+	memset( &cmg, 0, sizeof( cmg ) );
+	Hunk_ClearHigh();
+	CM_ClearLevelPatches();
+}
+#endif //BSPC
+
+
+/*
+==================
+CM_LoadMap
+
+Loads in the map and all submodels
+==================
+*/
+void *gpvCachedMapDiskImage = NULL;
+char  gsCachedMapDiskImage[MAX_QPATH];
+qboolean gbUsingCachedMapDataRightNow = qfalse;	// if true, signifies that you can't delete this at the moment!! (used during z_malloc()-fail recovery attempt)
+
+// called in response to a "devmapbsp blah" or "devmapall blah" command, do NOT use inside CM_Load unless you pass in qtrue
+//
+// new bool return used to see if anything was freed, used during z_malloc failure re-try
+//
+qboolean CM_DeleteCachedMap(qboolean bGuaranteedOkToDelete)
+{
+	qboolean bActuallyFreedSomething = qfalse;
+
+	if (bGuaranteedOkToDelete || !gbUsingCachedMapDataRightNow)
+	{
+		// dump cached disk image...
+		//
+		if (gpvCachedMapDiskImage)
+		{
+			Z_Free(	gpvCachedMapDiskImage );
+					gpvCachedMapDiskImage = NULL;
+
+			bActuallyFreedSomething = qtrue;
+		}
+		gsCachedMapDiskImage[0] = '\0';
+		
+		// force map loader to ignore cached internal BSP structures for next level CM_LoadMap() call...
+		//
+		cmg.name[0] = '\0';
+	}
+
+	return bActuallyFreedSomething;
+}
+
+void CM_Free(void) 
+{
+	CM_ClearLevelPatches();
+	visData.Release();
+	Z_TagFree(TAG_BSP);
+}
+
+void R_LoadSurfaces( int count );
+void R_LoadPatches( void *verts, int vertlen, 
+					void *surfaces, int surfacelen );
+void R_LoadTriSurfs( void *indexdata, int indexlen, 
+					void *verts, int vertlen, 
+					void *surfaces, int surfacelen );
+void R_LoadFaces( void *indexdata, int indexlen, 
+					void *verts, int vertlen, 
+					void *surfaces, int surfacelen );
+void R_LoadFlares( void *surfaces, int surfacelen );
+extern void R_LoadShaders( void );
+extern void R_LoadLightmaps( void *data, int len, const char *psMapName );
+extern byte *fileBase;
+static void CM_LoadMap_Actual( const char *name, qboolean clientload, int *checksum ) {
+	const int		*buf = NULL;
+	const int		*surfBuf = NULL;
+	static unsigned	last_checksum;
+	char			lmName[MAX_QPATH];
+	char			stripName[MAX_QPATH];
+	Lump			outputLump;
+
+	if ( !name || !name[0] ) {
+		Com_Error( ERR_DROP, "CM_LoadMap: NULL name" );
+	}
+
+#ifndef BSPC
+	cm_noAreas = Cvar_Get ("cm_noAreas", "0", CVAR_CHEAT);
+	cm_noCurves = Cvar_Get ("cm_noCurves", "0", CVAR_CHEAT);
+	cm_playerCurveClip = Cvar_Get ("cm_playerCurveClip", "1", CVAR_ARCHIVE|CVAR_CHEAT );
+#endif
+	Com_DPrintf( "CM_LoadMap( %s, %i )\n", name, clientload );
+
+	if ( !strcmp( cmg.name, name ) && clientload ) {
+		*checksum = last_checksum;
+		return;
+	}
+
+	// free old stuff
+	extern qboolean vidRestartReloadMap;
+	int* ap;
+	if (vidRestartReloadMap) ap = cmg.areaPortals;
+	memset( &cmg, 0, sizeof( cmg ) );
+	if (vidRestartReloadMap) cmg.areaPortals = ap;
+	
+	if ( !name[0] ) {
+		cmg.numLeafs = 1; 
+		cmg.numClusters = 1;
+		cmg.numAreas = 1;
+		cmg.cmodels = (struct cmodel_s *) Z_Malloc( sizeof( *cmg.cmodels ), TAG_BSP, qtrue );
+		*checksum = 0;
+		return;
+	}
+	
+	last_checksum = crc32(0, (const Bytef *)name, strlen(name));
+	COM_StripExtension(name, stripName);
+
+	// load into heap
+	outputLump.load(stripName, "shaders");
+	CMod_LoadShaders( outputLump.data, outputLump.len );
+	R_LoadShaders();
+	
+	strcpy(lmName, name);
+	outputLump.load(stripName, "lightmaps");
+	R_LoadLightmaps( outputLump.data, outputLump.len, lmName);
+	
+	{
+		fileBase = NULL;
+		outputLump.clear();
+
+		Lump misc;
+		misc.load(stripName, "misc");
+		
+		int num_surfs = *(int*)misc.data;
+		misc.clear();
+		
+		R_LoadSurfaces(num_surfs);
+
+		Lump verts;
+		verts.load(stripName, "verts");
+
+		Lump patches;
+		patches.load(stripName, "patches");
+
+		CMod_LoadPatches(verts.data, verts.len,
+			patches.data, patches.len,
+			num_surfs );
+		R_LoadPatches(verts.data, verts.len, 
+			patches.data, patches.len);
+
+		patches.clear();
+
+		Lump indexes;
+		indexes.load(stripName, "indexes");
+
+		Lump trisurfs;
+		trisurfs.load(stripName, "trisurfs");
+
+		R_LoadTriSurfs(indexes.data, indexes.len,
+			verts.data, verts.len, 
+			trisurfs.data, trisurfs.len);
+
+		trisurfs.clear();
+	
+		Lump faces;
+		faces.load(stripName, "faces");
+
+		R_LoadFaces(indexes.data, indexes.len,
+			verts.data, verts.len, 
+			faces.data, faces.len);
+
+		Lump flares;
+		flares.load(stripName, "flares");
+
+		R_LoadFlares(flares.data, flares.len);
+	}
+	
+	outputLump.load(stripName, "leafs");
+	CMod_LoadLeafs (outputLump.data, outputLump.len);
+
+	outputLump.load(stripName, "leafbrushes");
+	CMod_LoadLeafBrushes (outputLump.data, outputLump.len);
+	
+	cmg.leafsurfaces = NULL;
+	outputLump.load(stripName, "planes");
+	CMod_LoadPlanes (outputLump.data, outputLump.len);
+	
+	outputLump.load(stripName, "brushsides");
+	CMod_LoadBrushSides (outputLump.data, outputLump.len);
+	outputLump.load(stripName, "brushes");
+	CMod_LoadBrushes (outputLump.data, outputLump.len);
+
+	outputLump.load(stripName, "models");
+	CMod_LoadSubmodels (outputLump.data, outputLump.len);
+
+	outputLump.load(stripName, "nodes");
+	CMod_LoadNodes (outputLump.data, outputLump.len);
+
+	outputLump.load(stripName, "entities");
+	CMod_LoadEntityString (outputLump.data, outputLump.len);
+
+	outputLump.load(stripName, "visibility");
+	CMod_LoadVisibility( outputLump.data, outputLump.len);
+
+	TotalSubModels += cmg.numSubModels;
+	
+	CM_InitBoxHull ();
+
+	*checksum = last_checksum;	
+
+	// do this whether or not the map was cached from last load...
+	//
+	CM_FloodAreaConnections ();
+
+	// allow this to be cached if it is loaded by the server
+	if ( !clientload ) {
+		Q_strncpyz( cmg.name, name, sizeof( cmg.name ) );
+	}
+	CM_CleanLeafCache();
+}
+
+// need a wrapper function around this because of multiple returns, need to ensure bool is correct...
+//
+void CM_LoadMap( const char *name, qboolean clientload, int *checksum )
+{
+	CM_LoadMap_Actual( name, clientload, checksum );
+}
+
+qboolean CM_SameMap(char *server)
+{
+	if (!cmg.name[0] || !server || !server[0])
+	{
+		return qfalse;
+	}
+
+	if (Q_stricmp(cmg.name, va("maps/%s.bsp", server)))
+	{
+		return qfalse;
+	}
+
+	return qtrue;
+}
+
+#ifndef _XBOX
+qboolean CM_HasTerrain(void)
+{
+	if (cmg.landScape)
+		return qtrue;
+	return qfalse;
+}
+#endif
+
+/*
+==================
+CM_ClearMap
+==================
+*/
+void CM_ClearMap( void ) 
+{
+	int		i;
+
+	CM_OrOfAllContentsFlagsInMap = CONTENTS_BODY;
+
+#if !defined(BSPC)
+//	CM_ShutdownShaderProperties();
+//	MAT_Shutdown();
+#endif
+
+#ifndef _XBOX
+	if (TheRandomMissionManager)
+	{
+		delete TheRandomMissionManager;
+		TheRandomMissionManager = 0;
+	}
+
+	if (cmg.landScape)
+	{
+		delete cmg.landScape;
+		cmg.landScape = 0;
+	}
+#endif
+
+	memset( &cmg, 0, sizeof( cmg ) );
+	CM_ClearLevelPatches();
+
+	for(i = 0; i < NumSubBSP; i++)
+	{
+		memset(&SubBSP[i], 0, sizeof(SubBSP[0]));
+	}
+	NumSubBSP = 0;
+	TotalSubModels = 0;
+}
+
+int CM_TotalMapContents()
+{
+	return CM_OrOfAllContentsFlagsInMap;
+}
+
+/*
+==================
+CM_ClipHandleToModel
+==================
+*/
+cmodel_t	*CM_ClipHandleToModel( clipHandle_t handle, clipMap_t **clipMap )
+{
+	int		i;
+	int		count;
+
+	if ( handle < 0 ) 
+	{
+		Com_Error( ERR_DROP, "CM_ClipHandleToModel: bad handle %i", handle );
+	}
+	if ( handle < cmg.numSubModels ) 
+	{
+		if (clipMap)
+		{
+			*clipMap = &cmg;
+		}
+		return &cmg.cmodels[handle];
+	}
+	if ( handle == BOX_MODEL_HANDLE ) 
+	{
+		if (clipMap)
+		{
+			*clipMap = &cmg;
+		}
+		return &box_model;
+	}
+
+	count = cmg.numSubModels;
+	for(i = 0; i < NumSubBSP; i++)
+	{
+		if (handle < count + SubBSP[i].numSubModels)
+		{
+			if (clipMap)
+			{
+				*clipMap = &SubBSP[i];
+			}
+			return &SubBSP[i].cmodels[handle - count];
+		}
+		count += SubBSP[i].numSubModels;
+	}
+
+	if ( handle < MAX_SUBMODELS ) 
+	{
+		Com_Error( ERR_DROP, "CM_ClipHandleToModel: bad handle %i < %i < %i", 
+			cmg.numSubModels, handle, MAX_SUBMODELS );
+	}
+	Com_Error( ERR_DROP, "CM_ClipHandleToModel: bad handle %i", handle + MAX_SUBMODELS );
+
+	return NULL;
+}
+/*
+==================
+CM_InlineModel
+==================
+*/
+clipHandle_t	CM_InlineModel( int index ) {
+	if ( index < 0 || index >= TotalSubModels ) {
+		Com_Error (ERR_DROP, "CM_InlineModel: bad number (may need to re-BSP map?)");
+	}
+	return index;
+}
+
+int		CM_NumClusters( void ) {
+	return cmg.numClusters;
+}
+
+int		CM_NumInlineModels( void ) {
+	return cmg.numSubModels;
+}
+
+char	*CM_EntityString( void ) {
+	return cmg.entityString;
+}
+
+char *CM_SubBSPEntityString( int index ) 
+{
+	return SubBSP[index].entityString;
+}
+
+int		CM_LeafCluster( int leafnum ) {
+	if (leafnum < 0 || leafnum >= cmg.numLeafs) {
+		Com_Error (ERR_DROP, "CM_LeafCluster: bad number");
+	}
+	return cmg.leafs[leafnum].cluster;
+}
+
+int		CM_LeafArea( int leafnum ) {
+	if ( leafnum < 0 || leafnum >= cmg.numLeafs ) {
+		Com_Error (ERR_DROP, "CM_LeafArea: bad number");
+	}
+	return cmg.leafs[leafnum].area;
+}
+
+//=======================================================================
+
+
+/*
+===================
+CM_InitBoxHull
+
+Set up the planes and nodes so that the six floats of a bounding box
+can just be stored out and get a proper clipping hull structure.
+===================
+*/
+void CM_InitBoxHull (void)
+{
+	int			i;
+	int			side;
+	cplane_t	*p;
+	cbrushside_t	*s;
+
+	box_planes = &cmg.planes[cmg.numPlanes];
+
+	box_brush = &cmg.brushes[cmg.numBrushes];
+	box_brush->numsides = 6;
+	box_brush->sides = cmg.brushsides + cmg.numBrushSides;
+	box_brush->contents = CONTENTS_BODY;
+
+	box_model.leaf.numLeafBrushes = 1;
+//	box_model.leaf.firstLeafBrush = cmg.numBrushes;
+	box_model.leaf.firstLeafBrush = cmg.numLeafBrushes;
+	cmg.leafbrushes[cmg.numLeafBrushes] = cmg.numBrushes;
+
+	for (i=0 ; i<6 ; i++)
+	{
+		side = i&1;
+
+		// brush sides
+		s = &cmg.brushsides[cmg.numBrushSides+i];
+		s->planeNum = cmg.numPlanes+i*2+side;
+		s->shaderNum = cmg.numShaders;
+
+		// planes
+		p = &box_planes[i*2];
+		p->type = i>>1;
+		p->signbits = 0;
+		VectorClear (p->normal);
+		p->normal[i>>1] = 1;
+
+		p = &box_planes[i*2+1];
+		p->type = 3 + (i>>1);
+		p->signbits = 0;
+		VectorClear (p->normal);
+		p->normal[i>>1] = -1;
+
+		SetPlaneSignbits( p );
+	}	
+}
+
+
+
+/*
+===================
+CM_HeadnodeForBox
+
+To keep everything totally uniform, bounding boxes are turned into small
+BSP trees instead of being compared directly.
+===================
+*/
+clipHandle_t CM_TempBoxModel( const vec3_t mins, const vec3_t maxs) {//, const int contents ) {
+	box_planes[0].dist = maxs[0];
+	box_planes[1].dist = -maxs[0];
+	box_planes[2].dist = mins[0];
+	box_planes[3].dist = -mins[0];
+	box_planes[4].dist = maxs[1];
+	box_planes[5].dist = -maxs[1];
+	box_planes[6].dist = mins[1];
+	box_planes[7].dist = -mins[1];
+	box_planes[8].dist = maxs[2];
+	box_planes[9].dist = -maxs[2];
+	box_planes[10].dist = mins[2];
+	box_planes[11].dist = -mins[2];
+
+	VectorCopy( mins, box_brush->bounds[0] );
+	VectorCopy( maxs, box_brush->bounds[1] );
+
+	//FIXME: this is the "correct" way, but not the way JK2 was designed around... fix for further projects
+	//box_brush->contents = contents;
+
+	return BOX_MODEL_HANDLE;
+}
+
+
+/*
+===================
+CM_ModelBounds
+===================
+*/
+void CM_ModelBounds( clipMap_t &cmg, clipHandle_t model, vec3_t mins, vec3_t maxs ) 
+{
+	cmodel_t	*cmod;
+
+	cmod = CM_ClipHandleToModel( model );
+	VectorCopy( cmod->mins, mins );
+	VectorCopy( cmod->maxs, maxs );
+}
+
+/*
+===================
+CM_RegisterTerrain
+
+Allows physics to examine the terrain data.
+===================
+*/
+#if !defined(BSPC)
+#if 0	// Removing terrain on Xbox
+CCMLandScape *CM_RegisterTerrain(const char *config, bool server)
+{
+	thandle_t		terrainId;
+	CCMLandScape	*ls;
+
+	terrainId = atol(Info_ValueForKey(config, "terrainId"));
+	if(terrainId && cmg.landScape)
+	{
+		// Already spawned so just return
+		ls = cmg.landScape;
+		ls->IncreaseRefCount();
+		return(ls);
+	}
+	// Doesn't exist so create and link in
+	//cmg.numTerrains++;
+	ls = CM_InitTerrain(config, 1, server);
+
+	// Increment for the next instance
+	if (cmg.landScape)
+	{
+		Com_Error(ERR_DROP, "You can't have more than one terrain brush.");
+	}
+	cmg.landScape = ls;
+	return(ls);
+}
+
+/*
+===================
+CM_ShutdownTerrain
+===================
+*/
+
+void CM_ShutdownTerrain( thandle_t terrainId)
+{
+	CCMLandScape	*landscape;
+
+	landscape = cmg.landScape;
+	if (landscape)
+	{
+		landscape->DecreaseRefCount();
+		if(landscape->GetRefCount() <= 0)
+		{
+			delete landscape;
+			cmg.landScape = NULL;
+		}
+	}
+}
+#endif	// No terrain on Xbox
+#endif
+
+int CM_LoadSubBSP(const char *name, qboolean clientload)
+{
+	int		i;
+	int		checksum;
+	int		count;
+
+	count = cmg.numSubModels;
+	for(i = 0; i < NumSubBSP; i++)
+	{
+		if (!stricmp(name, SubBSP[i].name))
+		{
+			return count;
+		}
+		count += SubBSP[i].numSubModels;
+	}
+
+	if (NumSubBSP == MAX_SUB_BSP)
+	{
+		Com_Error (ERR_DROP, "CM_LoadSubBSP: too many unique sub BSPs");
+	}
+
+#ifdef _XBOX
+	assert(0); // MATT! - testing now - fix this later!
+#else
+	CM_LoadMap_Actual( name, clientload, &checksum, SubBSP[NumSubBSP] );
+#endif
+	NumSubBSP++;
+
+	return count;
+}
+
+int CM_FindSubBSP(int modelIndex)
+{
+	int		i;
+	int		count;
+
+	count = cmg.numSubModels;
+	if (modelIndex < count)
+	{	// belongs to the main bsp
+		return -1;
+	}
+
+	for(i = 0; i < NumSubBSP; i++)
+	{
+		count += SubBSP[i].numSubModels;
+		if (modelIndex < count)
+		{
+			return i;
+		}
+	}
+	return -1;
+}
+
+void CM_GetWorldBounds ( vec3_t mins, vec3_t maxs )
+{
+	VectorCopy ( cmg.cmodels[0].mins, mins );
+	VectorCopy ( cmg.cmodels[0].maxs, maxs );
+}
+
+int CM_ModelContents_Actual( clipHandle_t model, clipMap_t *cm ) 
+{
+	cmodel_t	*cmod;
+	int			contents = 0;
+	int			i;
+
+	if (!cm)
+	{
+		cm = &cmg;
+	}
+
+	cmod = CM_ClipHandleToModel( model, &cm );
+
+	//MCG ADDED - return the contents, too
+	if( cmod->leaf.numLeafBrushes )		// check for brush
+	{
+		int brushNum;
+		for ( i = cmod->leaf.firstLeafBrush; i < cmod->leaf.firstLeafBrush+cmod->leaf.numLeafBrushes; i++ )
+		{
+			brushNum = cm->leafbrushes[i];
+			contents |= cm->brushes[brushNum].contents;
+		}
+	}
+	if( cmod->leaf.numLeafSurfaces )	// if not brush, check for patch
+	{	
+		int surfaceNum;
+		for ( i = cmod->leaf.firstLeafSurface; i < cmod->leaf.firstLeafSurface+cmod->leaf.numLeafSurfaces; i++ )
+		{
+			surfaceNum = cm->leafsurfaces[i];
+			if ( cm->surfaces[surfaceNum] != NULL )
+			{//HERNH?  How could we have a null surf within our cmod->leaf.numLeafSurfaces?
+				contents |= cm->surfaces[surfaceNum]->contents;
+			}
+		}
+	}
+	return contents;
+}
+
+int CM_ModelContents(  clipHandle_t model, int subBSPIndex )
+{
+	if (subBSPIndex < 0)
+	{
+		return CM_ModelContents_Actual(model, NULL);
+	}
+
+	return CM_ModelContents_Actual(model, &SubBSP[subBSPIndex]);
+}
+
+//support for save/load games
+/*
+===================
+CM_WritePortalState
+
+Writes the portal state to a savegame file
+===================
+*/
+// having to proto this stuff again here is crap, but wtf?...
+//
+qboolean SG_Append(unsigned long chid, const void *data, int length);
+int SG_Read(unsigned long chid, void *pvAddress, int iLength, void **ppvAddressPtr = NULL);
+
+void CM_WritePortalState ()
+{	
+	SG_Append('PRTS', (void *)cmg.areaPortals, cmg.numAreas * cmg.numAreas * sizeof( *cmg.areaPortals ));
+}
+
+/*
+===================
+CM_ReadPortalState
+
+Reads the portal state from a savegame file
+and recalculates the area connections
+===================
+*/
+void	CM_ReadPortalState ()
+{
+	SG_Read('PRTS', (void *)cmg.areaPortals, cmg.numAreas * cmg.numAreas * sizeof( *cmg.areaPortals ));
+	CM_FloodAreaConnections ();
+
+}
+
diff --git a/code/qcommon/cm_local.h b/code/qcommon/cm_local.h
new file mode 100644
index 0000000..ba759ea
--- /dev/null
+++ b/code/qcommon/cm_local.h
@@ -0,0 +1,321 @@
+#include "../game/q_shared.h"
+#include "qcommon.h"
+#include "cm_polylib.h"
+#include "cm_landscape.h"
+
+#ifdef _XBOX
+#include "sparc.h"
+#endif
+
+#ifndef CM_LOCAL_H
+#define CM_LOCAL_H
+
+#define	BOX_MODEL_HANDLE	(MAX_SUBMODELS-1)
+
+#ifdef _XBOX
+#pragma pack(push, 1)
+typedef struct {
+	short		children[2];		// negative numbers are leafs
+} cNode_t;
+#pragma pack(pop)
+
+#else // _XBOX
+
+typedef struct {
+	cplane_t	*plane;
+	int			children[2];		// negative numbers are leafs
+} cNode_t;
+
+#endif // _XBOX
+
+typedef struct {
+	int			cluster;
+	int			area;
+
+	int			firstLeafBrush;
+	int			numLeafBrushes;
+
+	int			firstLeafSurface;
+	int			numLeafSurfaces;
+} cLeaf_t;
+
+typedef struct cmodel_s {
+	vec3_t		mins, maxs;
+	cLeaf_t		leaf;			// submodels don't reference the main tree
+} cmodel_t;
+
+#ifdef _XBOX
+#pragma pack (push, 1)
+typedef struct cbrushside_s {
+	NotSoShort planeNum;
+	unsigned char	shaderNum;
+} cbrushside_t;
+#pragma pack(pop)
+
+#else // _XBOX
+
+typedef struct cbrushside_s {
+	cplane_t	*plane;
+	int			shaderNum;
+} cbrushside_t;
+
+#endif // _XBOX
+
+typedef struct cbrush_s {
+	int					shaderNum;		// the shader that determined the contents
+	int					contents;
+	vec3_t				bounds[2];
+	cbrushside_t		*sides;
+	unsigned short		numsides;
+	unsigned short		checkcount;		// to avoid repeated testings
+} cbrush_t;
+
+class CCMShader
+{
+public:
+	char				shader[MAX_QPATH];
+	class CCMShader		*mNext;
+	int					surfaceFlags;
+	int					contentFlags;
+
+	const char			*GetName(void) const { return(shader); }
+	class CCMShader		*GetNext(void) const { return(mNext); }
+	void				SetNext(class CCMShader *next) { mNext = next; }
+	void				Destroy(void) { }
+};
+
+typedef struct {
+	int			checkcount;				// to avoid repeated testings
+	int			surfaceFlags;
+	int			contents;
+	struct patchCollide_s	*pc;
+} cPatch_t;
+
+
+typedef struct {
+	int			floodnum;
+	int			floodvalid;
+} cArea_t;
+
+#ifdef _XBOX
+template <class T>
+class SPARC;
+typedef struct {
+	char		name[MAX_QPATH];
+
+	int			numShaders;
+	CCMShader	*shaders;
+
+	int			numBrushSides;
+	cbrushside_t *brushsides;
+
+	int			numPlanes;
+	cplane_t	*planes;
+
+	int			numNodes;
+	cNode_t		*nodes;
+
+	int			numLeafs;
+	cLeaf_t		*leafs;
+
+	int			numLeafBrushes;
+	int			*leafbrushes;
+
+	int			numLeafSurfaces;
+	int			*leafsurfaces;
+
+	int			numSubModels;
+	cmodel_t	*cmodels;
+
+	int			numBrushes;
+	cbrush_t	*brushes;
+
+	int			numClusters;
+	int			clusterBytes;
+	SPARC<byte>	*visibility;
+	qboolean	vised;			// if false, visibility is just a single cluster of ffs
+
+	int			numEntityChars;
+	char		*entityString;
+
+	int			numAreas;
+	cArea_t		*areas;
+	int			*areaPortals;	// [ numAreas*numAreas ] reference counts
+
+	int			numSurfaces;
+	cPatch_t	**surfaces;			// non-patches will be NULL
+
+	int			floodvalid;
+	int			checkcount;					// incremented on each trace
+
+//	CCMLandScape	*landScape;		// Removing terrain from Xbox
+} clipMap_t;
+
+#else // _XBOX
+
+typedef struct {
+	char		name[MAX_QPATH];
+
+	int			numShaders;
+	//dshader_t	*shaders;
+	CCMShader	*shaders;
+
+	int			numBrushSides;
+	cbrushside_t *brushsides;
+
+	int			numPlanes;
+	cplane_t	*planes;
+
+	int			numNodes;
+	cNode_t		*nodes;
+
+	int			numLeafs;
+	cLeaf_t		*leafs;
+
+	int			numLeafBrushes;
+	int			*leafbrushes;
+
+	int			numLeafSurfaces;
+	int			*leafsurfaces;
+
+	int			numSubModels;
+	cmodel_t	*cmodels;
+
+	int			numBrushes;
+	cbrush_t	*brushes;
+
+	int			numClusters;
+	int			clusterBytes;
+	byte		*visibility;
+	qboolean	vised;			// if false, visibility is just a single cluster of ffs
+
+	int			numEntityChars;
+	char		*entityString;
+
+	int			numAreas;
+	cArea_t		*areas;
+	int			*areaPortals;	// [ numAreas*numAreas ] reference counts
+
+	int			numSurfaces;
+	cPatch_t	**surfaces;			// non-patches will be NULL
+
+	int			floodvalid;
+	int			checkcount;					// incremented on each trace
+
+	CCMLandScape	*landScape;
+} clipMap_t;
+
+#endif // _XBOX
+
+
+// keep 1/8 unit away to keep the position valid before network snapping
+// and to avoid various numeric issues
+#define	SURFACE_CLIP_EPSILON	(0.125)
+
+extern	clipMap_t	cmg;
+extern	int			c_pointcontents;
+extern	int			c_traces, c_brush_traces, c_patch_traces;
+extern	cvar_t		*cm_noAreas;
+extern	cvar_t		*cm_noCurves;
+extern	cvar_t		*cm_playerCurveClip;
+
+extern clipMap_t	SubBSP[MAX_SUB_BSP];
+extern int			NumSubBSP;
+
+// cm_test.c
+
+// Used for oriented capsule collision detection
+typedef struct
+{
+	qboolean	use;
+	float		radius;
+	float		halfheight;
+	vec3_t		offset;
+} sphere_t;
+
+typedef struct traceWork_s {
+	vec3_t		start;
+	vec3_t		end;
+	vec3_t		size[2];	// size of the box being swept through the model
+	vec3_t		offsets[8];	// [signbits][x] = either size[0][x] or size[1][x]
+	float		maxOffset;	// longest corner length from origin
+	vec3_t		extents;	// greatest of abs(size[0]) and abs(size[1])
+
+	vec3_t		bounds[2];	// enclosing box of start and end surrounding by size
+	vec3pair_t	localBounds;	// enclosing box of start and end surrounding by size for a segment
+
+	vec3_t		modelOrigin;// origin of the model tracing through
+	int			contents;	// ored contents of the model tracing through
+	qboolean	isPoint;	// optimized case
+	sphere_t	sphere;		// sphere for oriendted capsule collision
+
+	float			baseEnterFrac;	// global enter fraction (before processing subsections of the brush)	
+	float			baseLeaveFrac;	// global leave fraction (before processing subsections of the brush)	
+	float			enterFrac;		// fraction where the ray enters the brush
+	float			leaveFrac;		// fraction where the ray leaves the brush
+	cbrushside_t	*leadside;
+	cplane_t		*clipplane;
+	bool			startout;
+	bool			getout;
+
+	trace_t		trace;		// returned from trace call
+	// make sure nothing goes under here for Ghoul2 collision purposes
+} traceWork_t;
+
+typedef struct leafList_s {
+	int		count;
+	int		maxcount;
+	qboolean	overflowed;
+	int		*list;
+	vec3_t	bounds[2];
+	int		lastLeaf;		// for overflows where each leaf can't be stored individually
+	void	(*storeLeafs)( struct leafList_s *ll, int nodenum );
+} leafList_t;
+
+
+int CM_BoxBrushes( const vec3_t mins, const vec3_t maxs, cbrush_t **boxlist, int listsize );
+
+void CM_StoreLeafs( leafList_t *ll, int nodenum );
+void CM_StoreBrushes( leafList_t *ll, int nodenum );
+
+void CM_BoxLeafnums_r( leafList_t *ll, int nodenum );
+
+cmodel_t	*CM_ClipHandleToModel( clipHandle_t handle, clipMap_t **clipMap = 0 );
+void CM_CleanLeafCache(void);
+
+// cm_load.c
+void CM_ModelBounds( clipMap_t &cm, clipHandle_t model, vec3_t mins, vec3_t maxs );
+
+// cm_patch.c
+
+struct patchCollide_s	*CM_GeneratePatchCollide( int width, int height, vec3_t *points );
+void CM_TraceThroughPatchCollide( traceWork_t *tw, const struct patchCollide_s *pc );
+qboolean CM_PositionTestInPatchCollide( traceWork_t *tw, const struct patchCollide_s *pc );
+void CM_ClearLevelPatches( void );
+
+// cm_shader.cpp
+void CM_SetupShaderProperties( void );
+void CM_ShutdownShaderProperties(void);
+CCMShader *CM_GetShaderInfo( const char *name );
+CCMShader *CM_GetShaderInfo( int shaderNum );
+void		CM_GetModelFormalName ( const char* model, const char* skin, char* name, int size );
+
+//cm_trace.cpp
+void CM_CalcExtents(const vec3_t start, const vec3_t end, const traceWork_t *tw, vec3pair_t bounds);
+void CM_HandlePatchCollision(struct traceWork_s *tw, trace_t &trace, const vec3_t tStart, const vec3_t tEnd, CCMPatch *patch, int checkcount);
+bool CM_GenericBoxCollide(const vec3pair_t abounds, const vec3pair_t bbounds);
+
+
+//RM_Terrain.cpp
+int Round(float value);
+
+//random utils for cm_terrain (and others?)
+#define VectorInc(v)					((v)[0] += 1.0f,(v)[1] += 1.0f,(v)[2] +=1.0f)
+#define VectorDec(v)					((v)[0] -= 1.0f,(v)[1] -= 1.0f,(v)[2] -=1.0f)
+#define VectorInverseScaleVector(a,b,c)	((c)[0]=(a)[0]/(b)[0],(c)[1]=(a)[1]/(b)[1],(c)[2]=(a)[2]/(b)[2])
+#define VectorScaleVectorAdd(c,a,b,o)	((o)[0]=(c)[0]+((a)[0]*(b)[0]),(o)[1]=(c)[1]+((a)[1]*(b)[1]),(o)[2]=(c)[2]+((a)[2]*(b)[2]))
+
+#define minimum(x,y) ((x)<(y)?(x):(y))
+#define maximum(x,y) ((x)>(y)?(x):(y))
+
+#endif
diff --git a/code/qcommon/cm_patch.cpp b/code/qcommon/cm_patch.cpp
new file mode 100644
index 0000000..652d3de
--- /dev/null
+++ b/code/qcommon/cm_patch.cpp
@@ -0,0 +1,2930 @@
+
+#include "cm_local.h"
+#include "cm_patch.h"
+
+//#define	CULL_BBOX
+
+/*
+
+This file does not reference any globals, and has these entry points:
+
+void CM_ClearLevelPatches( void );
+struct patchCollide_s	*CM_GeneratePatchCollide( int width, int height, const vec3_t *points );
+void CM_TraceThroughPatchCollide( traceWork_t *tw, const struct patchCollide_s *pc );
+qboolean CM_PositionTestInPatchCollide( traceWork_t *tw, const struct patchCollide_s *pc );
+void CM_DrawDebugSurface( void (*drawPoly)(int color, int numPoints, flaot *points) );
+
+
+Issues for collision against curved surfaces:
+
+Surface edges need to be handled differently than surface planes
+
+Plane expansion causes raw surfaces to expand past expanded bounding box
+
+Position test of a volume against a surface is tricky.
+
+Position test of a point against a surface is not well defined, because the surface has no volume.
+
+
+Tracing leading edge points instead of volumes?
+Position test by tracing corner to corner? (8*7 traces -- ouch)
+
+coplanar edges
+triangulated patches
+degenerate patches
+
+  endcaps
+  degenerate
+
+WARNING: this may misbehave with meshes that have rows or columns that only
+degenerate a few triangles.  Completely degenerate rows and columns are handled
+properly.
+*/
+
+/*
+#define	MAX_FACETS			1024
+#define	MAX_PATCH_PLANES	2048
+
+typedef struct {
+	float	plane[4];
+	int		signbits;		// signx + (signy<<1) + (signz<<2), used as lookup during collision
+} patchPlane_t;
+
+typedef struct {
+	int			surfacePlane;
+	int			numBorders;		// 3 or four + 6 axial bevels + 4 or 3 * 4 edge bevels
+	int			borderPlanes[4+6+16];
+	int			borderInward[4+6+16];
+	qboolean	borderNoAdjust[4+6+16];
+} facet_t;
+
+typedef struct patchCollide_s {
+	vec3_t	bounds[2];
+	int		numPlanes;			// surface planes plus edge planes
+	patchPlane_t	*planes;
+	int		numFacets;
+	facet_t	*facets;
+} patchCollide_t;
+
+
+#define	MAX_GRID_SIZE	129
+
+typedef struct {
+	int			width;
+	int			height;
+	qboolean	wrapWidth;
+	qboolean	wrapHeight;
+	vec3_t	points[MAX_GRID_SIZE][MAX_GRID_SIZE];	// [width][height]
+} cGrid_t;
+
+#define	SUBDIVIDE_DISTANCE	16	//4	// never more than this units away from curve
+#define	PLANE_TRI_EPSILON	0.1
+#define	WRAP_POINT_EPSILON	0.1
+*/
+
+#define ADDBEVELS
+
+int	c_totalPatchBlocks;
+int	c_totalPatchSurfaces;
+int	c_totalPatchEdges;
+
+static const patchCollide_t	*debugPatchCollide;
+static const facet_t		*debugFacet;
+static qboolean		debugBlock;
+static vec3_t		debugBlockPoints[4];
+
+/*
+=================
+CM_ClearLevelPatches
+=================
+*/
+void CM_ClearLevelPatches( void ) {
+	debugPatchCollide = NULL;
+	debugFacet = NULL;
+}
+
+/*
+=================
+CM_SignbitsForNormal
+=================
+*/
+static int CM_SignbitsForNormal( vec3_t normal ) {
+	int	bits, j;
+
+	bits = 0;
+	for (j=0 ; j<3 ; j++) {
+		if ( normal[j] < 0 ) {
+			bits |= 1<<j;
+		}
+	}
+	return bits;
+}
+
+/*
+=====================
+CM_PlaneFromPoints
+
+Returns false if the triangle is degenrate.
+The normal will point out of the clock for clockwise ordered points
+=====================
+*/
+static qboolean CM_PlaneFromPoints( vec4_t plane, vec3_t a, vec3_t b, vec3_t c ) {
+	vec3_t	d1, d2;
+
+	VectorSubtract( b, a, d1 );
+	VectorSubtract( c, a, d2 );
+	CrossProduct( d2, d1, plane );
+	if ( VectorNormalize( plane ) == 0 ) {
+		return qfalse;
+	}
+
+	plane[3] = DotProduct( a, plane );
+	return qtrue;
+}
+
+
+/*
+================================================================================
+
+GRID SUBDIVISION
+
+================================================================================
+*/
+
+/*
+=================
+CM_NeedsSubdivision
+
+Returns true if the given quadratic curve is not flat enough for our
+collision detection purposes
+=================
+*/
+static qboolean	CM_NeedsSubdivision( vec3_t a, vec3_t b, vec3_t c ) {
+	vec3_t		cmid;
+	vec3_t		lmid;
+	vec3_t		delta;
+	float		dist;
+	int			i;
+
+	// calculate the linear midpoint
+	for ( i = 0 ; i < 3 ; i++ ) {
+		lmid[i] = 0.5*(a[i] + c[i]);
+	}
+
+	// calculate the exact curve midpoint
+	for ( i = 0 ; i < 3 ; i++ ) {
+		cmid[i] = 0.5 * ( 0.5*(a[i] + b[i]) + 0.5*(b[i] + c[i]) );
+	}
+
+	// see if the curve is far enough away from the linear mid
+	VectorSubtract( cmid, lmid, delta );
+	dist = VectorLengthSquared( delta );
+	
+	return dist >= SUBDIVIDE_DISTANCE * SUBDIVIDE_DISTANCE;
+}
+
+/*
+===============
+CM_Subdivide
+
+a, b, and c are control points.
+the subdivided sequence will be: a, out1, out2, out3, c
+===============
+*/
+static void CM_Subdivide( vec3_t a, vec3_t b, vec3_t c, vec3_t out1, vec3_t out2, vec3_t out3 ) {
+	int		i;
+
+	for ( i = 0 ; i < 3 ; i++ ) {
+		out1[i] = 0.5 * (a[i] + b[i]);
+		out3[i] = 0.5 * (b[i] + c[i]);
+		out2[i] = 0.5 * (out1[i] + out3[i]);
+	}
+}
+
+/*
+=================
+CM_TransposeGrid
+
+Swaps the rows and columns in place
+=================
+*/
+static void CM_TransposeGrid( cGrid_t *grid ) {
+	int			i, j, l;
+	vec3_t		temp;
+	qboolean	tempWrap;
+
+	if ( grid->width > grid->height ) {
+		for ( i = 0 ; i < grid->height ; i++ ) {
+			for ( j = i + 1 ; j < grid->width ; j++ ) {
+				if ( j < grid->height ) {
+					// swap the value
+					VectorCopy( grid->points[i][j], temp );
+					VectorCopy( grid->points[j][i], grid->points[i][j] );
+					VectorCopy( temp, grid->points[j][i] );
+				} else {
+					// just copy
+					VectorCopy( grid->points[j][i], grid->points[i][j] );
+				}
+			}
+		}
+	} else {
+		for ( i = 0 ; i < grid->width ; i++ ) {
+			for ( j = i + 1 ; j < grid->height ; j++ ) {
+				if ( j < grid->width ) {
+					// swap the value
+					VectorCopy( grid->points[j][i], temp );
+					VectorCopy( grid->points[i][j], grid->points[j][i] );
+					VectorCopy( temp, grid->points[i][j] );
+				} else {
+					// just copy
+					VectorCopy( grid->points[i][j], grid->points[j][i] );
+				}
+			}
+		}
+	}
+
+	l = grid->width;
+	grid->width = grid->height;
+	grid->height = l;
+
+	tempWrap = grid->wrapWidth;
+	grid->wrapWidth = grid->wrapHeight;
+	grid->wrapHeight = tempWrap;
+}
+
+/*
+===================
+CM_SetGridWrapWidth
+
+If the left and right columns are exactly equal, set grid->wrapWidth qtrue
+===================
+*/
+static void CM_SetGridWrapWidth( cGrid_t *grid ) {
+	int		i, j;
+	float	d;
+
+	for ( i = 0 ; i < grid->height ; i++ ) {
+		for ( j = 0 ; j < 3 ; j++ ) {
+			d = grid->points[0][i][j] - grid->points[grid->width-1][i][j];
+			if ( d < -WRAP_POINT_EPSILON || d > WRAP_POINT_EPSILON ) {
+				break;
+			}
+		}
+		if ( j != 3 ) {
+			break;
+		}
+	}
+	if ( i == grid->height ) {
+		grid->wrapWidth = qtrue;
+	} else {
+		grid->wrapWidth = qfalse;
+	}
+}
+
+
+/*
+=================
+CM_SubdivideGridColumns
+
+Adds columns as necessary to the grid until
+all the aproximating points are within SUBDIVIDE_DISTANCE
+from the true curve
+=================
+*/
+static void CM_SubdivideGridColumns( cGrid_t *grid ) {
+	int		i, j, k;
+
+	for ( i = 0 ; i < grid->width - 2 ;  ) {
+		// grid->points[i][x] is an interpolating control point
+		// grid->points[i+1][x] is an aproximating control point
+		// grid->points[i+2][x] is an interpolating control point
+
+		//
+		// first see if we can collapse the aproximating collumn away
+		//
+		for ( j = 0 ; j < grid->height ; j++ ) {
+			if ( CM_NeedsSubdivision( grid->points[i][j], grid->points[i+1][j], grid->points[i+2][j] ) ) {
+				break;
+			}
+		}
+		if ( j == grid->height ) {
+			// all of the points were close enough to the linear midpoints
+			// that we can collapse the entire column away
+			for ( j = 0 ; j < grid->height ; j++ ) {
+				// remove the column
+				for ( k = i + 2 ; k < grid->width ; k++ ) {
+					VectorCopy( grid->points[k][j], grid->points[k-1][j] );
+				}
+			}
+
+			grid->width--;
+
+			// go to the next curve segment
+			i++;
+			continue;
+		}
+
+		//
+		// we need to subdivide the curve
+		//
+		for ( j = 0 ; j < grid->height ; j++ ) {
+			vec3_t	prev, mid, next;
+
+			// save the control points now
+			VectorCopy( grid->points[i][j], prev );
+			VectorCopy( grid->points[i+1][j], mid );
+			VectorCopy( grid->points[i+2][j], next );
+
+			// make room for two additional columns in the grid
+			// columns i+1 will be replaced, column i+2 will become i+4
+			// i+1, i+2, and i+3 will be generated
+			for ( k = grid->width - 1 ; k > i + 1 ; k-- ) {
+				VectorCopy( grid->points[k][j], grid->points[k+2][j] );
+			}
+
+			// generate the subdivided points
+			CM_Subdivide( prev, mid, next, grid->points[i+1][j], grid->points[i+2][j], grid->points[i+3][j] );
+		}
+
+		grid->width += 2;
+
+		// the new aproximating point at i+1 may need to be removed
+		// or subdivided farther, so don't advance i
+	}
+}
+
+
+#define	POINT_EPSILON	0.1
+/*
+======================
+CM_ComparePoints
+======================
+*/
+static qboolean CM_ComparePoints( float *a, float *b ) {
+	float		d;
+
+	d = a[0] - b[0];
+	if ( d < -POINT_EPSILON || d > POINT_EPSILON ) {
+		return qfalse;
+	}
+	d = a[1] - b[1];
+	if ( d < -POINT_EPSILON || d > POINT_EPSILON ) {
+		return qfalse;
+	}
+	d = a[2] - b[2];
+	if ( d < -POINT_EPSILON || d > POINT_EPSILON ) {
+		return qfalse;
+	}
+	return qtrue;
+}
+
+/*
+=================
+CM_RemoveDegenerateColumns
+
+If there are any identical columns, remove them
+=================
+*/
+static void CM_RemoveDegenerateColumns( cGrid_t *grid ) {
+	int		i, j, k;
+
+	for ( i = 0 ; i < grid->width - 1 ; i++ ) {
+		for ( j = 0 ; j < grid->height ; j++ ) {
+			if ( !CM_ComparePoints( grid->points[i][j], grid->points[i+1][j] ) ) {
+				break;
+			}
+		}
+
+		if ( j != grid->height ) {
+			continue;	// not degenerate
+		}
+
+		for ( j = 0 ; j < grid->height ; j++ ) {
+			// remove the column
+			for ( k = i + 2 ; k < grid->width ; k++ ) {
+				VectorCopy( grid->points[k][j], grid->points[k-1][j] );
+			}
+		}
+		grid->width--;
+
+		// check against the next column
+		i--;
+	}
+}
+
+/*
+================================================================================
+
+PATCH COLLIDE GENERATION
+
+================================================================================
+*/
+
+static	int				numPlanes;
+
+#ifdef _XBOX
+static	patchPlane_t	*planes = NULL;
+void CM_TempPatchPlanesAlloc(void)
+{
+	if(!planes) {
+		planes = (patchPlane_t*)Z_Malloc(MAX_PATCH_PLANES*sizeof(patchPlane_t), 
+				TAG_TEMP_WORKSPACE, qfalse);
+	}
+}
+
+void CM_TempPatchPlanesDealloc(void)
+{
+	if(planes) {
+		Z_Free(planes);
+		planes = NULL;
+	}
+}
+#else
+static	patchPlane_t	planes[MAX_PATCH_PLANES];
+#endif
+
+//static	int				numFacets;
+// static	facet_t			facets[MAX_PATCH_PLANES]; //maybe MAX_FACETS ??
+//static	facet_t			facets[MAX_FACETS];	// Switched to MAX_FACETS = VV_FIXME, allocate these only during use
+static	facet_t			*facets = NULL;
+
+#define	NORMAL_EPSILON	0.0001
+#define	DIST_EPSILON	0.02
+
+int CM_PlaneEqual(patchPlane_t *p, float plane[4], int *flipped) {
+	float invplane[4];
+
+	if (
+	   Q_fabs(p->plane[0] - plane[0]) < NORMAL_EPSILON
+	&& Q_fabs(p->plane[1] - plane[1]) < NORMAL_EPSILON
+	&& Q_fabs(p->plane[2] - plane[2]) < NORMAL_EPSILON
+	&& Q_fabs(p->plane[3] - plane[3]) < DIST_EPSILON )
+	{
+		*flipped = qfalse;
+		return qtrue;
+	}
+
+	VectorNegate(plane, invplane);
+	invplane[3] = -plane[3];
+
+	if (
+	   Q_fabs(p->plane[0] - invplane[0]) < NORMAL_EPSILON
+	&& Q_fabs(p->plane[1] - invplane[1]) < NORMAL_EPSILON
+	&& Q_fabs(p->plane[2] - invplane[2]) < NORMAL_EPSILON
+	&& Q_fabs(p->plane[3] - invplane[3]) < DIST_EPSILON )
+	{
+		*flipped = qtrue;
+		return qtrue;
+	}
+
+	return qfalse;
+}
+
+void CM_SnapVector(vec3_t normal) {
+	int		i;
+
+	for (i=0 ; i<3 ; i++)
+	{
+		if ( Q_fabs(normal[i] - 1) < NORMAL_EPSILON )
+		{
+			VectorClear (normal);
+			normal[i] = 1;
+			break;
+		}
+		if ( Q_fabs(normal[i] - -1) < NORMAL_EPSILON )
+		{
+			VectorClear (normal);
+			normal[i] = -1;
+			break;
+		}
+	}
+}
+
+int CM_FindPlane2(float plane[4], int *flipped) {
+	int i;
+
+	// see if the points are close enough to an existing plane
+	for ( i = 0 ; i < numPlanes ; i++ ) {
+		if (CM_PlaneEqual(&planes[i], plane, flipped)) return i;
+	}
+
+	// add a new plane
+	if ( numPlanes == MAX_PATCH_PLANES ) {
+		Com_Error( ERR_DROP, "MAX_PATCH_PLANES reached (%d)", MAX_PATCH_PLANES );
+	}
+
+	Vector4Copy( plane, planes[numPlanes].plane );
+	planes[numPlanes].signbits = CM_SignbitsForNormal( plane );
+
+	numPlanes++;
+
+	*flipped = qfalse;
+
+	return numPlanes-1;
+}
+
+/*
+==================
+CM_FindPlane
+==================
+*/
+static int CM_FindPlane( float *p1, float *p2, float *p3 ) {
+	float	plane[4];
+	int		i;
+	float	d;
+
+	if ( !CM_PlaneFromPoints( plane, p1, p2, p3 ) ) {
+		return -1;
+	}
+
+	// see if the points are close enough to an existing plane
+	for ( i = 0 ; i < numPlanes ; i++ ) {
+		if ( DotProduct( plane, planes[i].plane ) < 0 ) {
+			continue;	// allow backwards planes?
+		}
+
+		d = DotProduct( p1, planes[i].plane ) - planes[i].plane[3];
+		if ( d < -PLANE_TRI_EPSILON || d > PLANE_TRI_EPSILON ) {
+			continue;
+		}
+
+		d = DotProduct( p2, planes[i].plane ) - planes[i].plane[3];
+		if ( d < -PLANE_TRI_EPSILON || d > PLANE_TRI_EPSILON ) {
+			continue;
+		}
+
+		d = DotProduct( p3, planes[i].plane ) - planes[i].plane[3];
+		if ( d < -PLANE_TRI_EPSILON || d > PLANE_TRI_EPSILON ) {
+			continue;
+		}
+
+		// found it
+		return i;
+	}
+
+	// add a new plane
+	if ( numPlanes == MAX_PATCH_PLANES ) {
+		Com_Error( ERR_DROP, "MAX_PATCH_PLANES" );
+	}
+
+	Vector4Copy( plane, planes[numPlanes].plane );
+	planes[numPlanes].signbits = CM_SignbitsForNormal( plane );
+
+	numPlanes++;
+
+	return numPlanes-1;
+}
+
+
+/*
+==================
+CM_PointOnPlaneSide
+==================
+*/
+static int CM_PointOnPlaneSide( float *p, int planeNum ) {
+	float	*plane;
+	float	d;
+
+	if ( planeNum == -1 ) {
+		return SIDE_ON;
+	}
+	plane = planes[ planeNum ].plane;
+
+	d = DotProduct( p, plane ) - plane[3];
+
+	if ( d > PLANE_TRI_EPSILON ) {
+		return SIDE_FRONT;
+	}
+
+	if ( d < -PLANE_TRI_EPSILON ) {
+		return SIDE_BACK;
+	}
+
+	return SIDE_ON;
+}
+
+
+#ifdef _XBOX
+static int	CM_GridPlane( int* gridPlanes, int i, int j, int tri ) {
+	int		p;
+
+	p = gridPlanes[i*CM_MAX_GRID_SIZE*2+j*2+tri];
+	if ( p != -1 ) {
+		return p;
+	}
+	p = gridPlanes[i*CM_MAX_GRID_SIZE*2+j*2+(!tri)];
+	if ( p != -1 ) {
+		return p;
+	}
+
+	// should never happen
+	Com_Printf( "WARNING: CM_GridPlane unresolvable\n" );
+	return -1;
+}
+
+#else // _XBOX
+
+static int	CM_GridPlane( int gridPlanes[CM_MAX_GRID_SIZE][CM_MAX_GRID_SIZE][2], int i, int j, int tri ) {
+	int		p;
+
+	p = gridPlanes[i][j][tri];
+	if ( p != -1 ) {
+		return p;
+	}
+	p = gridPlanes[i][j][!tri];
+	if ( p != -1 ) {
+		return p;
+	}
+
+	// should never happen
+	Com_Printf( "WARNING: CM_GridPlane unresolvable\n" );
+	return -1;
+}
+
+#endif // _XBOX
+
+/*
+==================
+CM_EdgePlaneNum
+==================
+*/
+#ifdef _XBOX
+static int CM_EdgePlaneNum( cGrid_t *grid, int* gridPlanes/*[PATCH_MAX_GRID_SIZE][PATCH_MAX_GRID_SIZE][2]*/, int i, int j, int k ) {
+	float	*p1, *p2;
+	vec3_t		up;
+	int			p;
+
+	switch ( k ) {
+	case 0:	// top border
+		p1 = grid->points[i][j];
+		p2 = grid->points[i+1][j];
+		p = CM_GridPlane( gridPlanes, i, j, 0 );
+		VectorMA( p1, 4, planes[ p ].plane, up );
+		return CM_FindPlane( p1, p2, up );
+
+	case 2:	// bottom border
+		p1 = grid->points[i][j+1];
+		p2 = grid->points[i+1][j+1];
+		p = CM_GridPlane( gridPlanes, i, j, 1 );
+		VectorMA( p1, 4, planes[ p ].plane, up );
+		return CM_FindPlane( p2, p1, up );
+
+	case 3: // left border
+		p1 = grid->points[i][j];
+		p2 = grid->points[i][j+1];
+		p = CM_GridPlane( gridPlanes, i, j, 1 );
+		VectorMA( p1, 4, planes[ p ].plane, up );
+		return CM_FindPlane( p2, p1, up );
+
+	case 1:	// right border
+		p1 = grid->points[i+1][j];
+		p2 = grid->points[i+1][j+1];
+		p = CM_GridPlane( gridPlanes, i, j, 0 );
+		VectorMA( p1, 4, planes[ p ].plane, up );
+		return CM_FindPlane( p1, p2, up );
+
+	case 4:	// diagonal out of triangle 0
+		p1 = grid->points[i+1][j+1];
+		p2 = grid->points[i][j];
+		p = CM_GridPlane( gridPlanes, i, j, 0 );
+		VectorMA( p1, 4, planes[ p ].plane, up );
+		return CM_FindPlane( p1, p2, up );
+
+	case 5:	// diagonal out of triangle 1
+		p1 = grid->points[i][j];
+		p2 = grid->points[i+1][j+1];
+		p = CM_GridPlane( gridPlanes, i, j, 1 );
+		VectorMA( p1, 4, planes[ p ].plane, up );
+		return CM_FindPlane( p1, p2, up );
+
+	}
+
+	Com_Error( ERR_DROP, "CM_EdgePlaneNum: bad k" );
+	return -1;
+}
+
+#else 
+
+static int CM_EdgePlaneNum( cGrid_t *grid, int gridPlanes[CM_MAX_GRID_SIZE][CM_MAX_GRID_SIZE][2], int i, int j, int k ) {
+	float	*p1, *p2;
+	vec3_t		up;
+	int			p;
+
+	switch ( k ) {
+	case 0:	// top border
+		p1 = grid->points[i][j];
+		p2 = grid->points[i+1][j];
+		p = CM_GridPlane( gridPlanes, i, j, 0 );
+		VectorMA( p1, 4, planes[ p ].plane, up );
+		return CM_FindPlane( p1, p2, up );
+
+	case 2:	// bottom border
+		p1 = grid->points[i][j+1];
+		p2 = grid->points[i+1][j+1];
+		p = CM_GridPlane( gridPlanes, i, j, 1 );
+		VectorMA( p1, 4, planes[ p ].plane, up );
+		return CM_FindPlane( p2, p1, up );
+
+	case 3: // left border
+		p1 = grid->points[i][j];
+		p2 = grid->points[i][j+1];
+		p = CM_GridPlane( gridPlanes, i, j, 1 );
+		VectorMA( p1, 4, planes[ p ].plane, up );
+		return CM_FindPlane( p2, p1, up );
+
+	case 1:	// right border
+		p1 = grid->points[i+1][j];
+		p2 = grid->points[i+1][j+1];
+		p = CM_GridPlane( gridPlanes, i, j, 0 );
+		VectorMA( p1, 4, planes[ p ].plane, up );
+		return CM_FindPlane( p1, p2, up );
+
+	case 4:	// diagonal out of triangle 0
+		p1 = grid->points[i+1][j+1];
+		p2 = grid->points[i][j];
+		p = CM_GridPlane( gridPlanes, i, j, 0 );
+		VectorMA( p1, 4, planes[ p ].plane, up );
+		return CM_FindPlane( p1, p2, up );
+
+	case 5:	// diagonal out of triangle 1
+		p1 = grid->points[i][j];
+		p2 = grid->points[i+1][j+1];
+		p = CM_GridPlane( gridPlanes, i, j, 1 );
+		VectorMA( p1, 4, planes[ p ].plane, up );
+		return CM_FindPlane( p1, p2, up );
+
+	}
+
+	Com_Error( ERR_DROP, "CM_EdgePlaneNum: bad k" );
+	return -1;
+}
+
+#endif
+
+/*
+===================
+CM_SetBorderInward
+===================
+*/
+#ifdef _XBOX
+static void CM_SetBorderInward( facetLoad_t *facet, cGrid_t *grid,
+						  int i, int j, int which ) {
+	int		k, l;
+	float	*points[4];
+	int		numPoints;
+
+	switch ( which ) {
+	case -1:
+		points[0] = grid->points[i][j];
+		points[1] = grid->points[i+1][j];
+		points[2] = grid->points[i+1][j+1];
+		points[3] = grid->points[i][j+1];
+		numPoints = 4;
+		break;
+	case 0:
+		points[0] = grid->points[i][j];
+		points[1] = grid->points[i+1][j];
+		points[2] = grid->points[i+1][j+1];
+		numPoints = 3;
+		break;
+	case 1:
+		points[0] = grid->points[i+1][j+1];
+		points[1] = grid->points[i][j+1];
+		points[2] = grid->points[i][j];
+		numPoints = 3;
+		break;
+	default:
+		Com_Error( ERR_FATAL, "CM_SetBorderInward: bad parameter" );
+		numPoints = 0;
+		break;
+	}
+
+	for ( k = 0 ; k < facet->numBorders ; k++ ) {
+		int		front, back;
+
+		front = 0;
+		back = 0;
+
+		for ( l = 0 ; l < numPoints ; l++ ) {
+			int		side;
+
+			side = CM_PointOnPlaneSide( points[l], facet->borderPlanes[k] );
+			if ( side == SIDE_FRONT ) {
+				front++;
+			} if ( side == SIDE_BACK ) {
+				back++;
+			}
+		}
+
+		if ( front && !back ) {
+			facet->borderInward[k] = qtrue;
+		} else if ( back && !front ) {
+			facet->borderInward[k] = qfalse;
+		} else if ( !front && !back ) {
+			// flat side border
+			facet->borderPlanes[k] = -1;
+		} else {
+			// bisecting side border
+			Com_DPrintf( "WARNING: CM_SetBorderInward: mixed plane sides\n" );
+			facet->borderInward[k] = qfalse;
+			if ( !debugBlock ) {
+				debugBlock = qtrue;
+				VectorCopy( grid->points[i][j], debugBlockPoints[0] );
+				VectorCopy( grid->points[i+1][j], debugBlockPoints[1] );
+				VectorCopy( grid->points[i+1][j+1], debugBlockPoints[2] );
+				VectorCopy( grid->points[i][j+1], debugBlockPoints[3] );
+			}
+		}
+	}
+}
+
+#else // _XBOX
+
+static void CM_SetBorderInward( facet_t *facet, cGrid_t *grid, int gridPlanes[CM_MAX_GRID_SIZE][CM_MAX_GRID_SIZE][2],
+						  int i, int j, int which ) {
+	int		k, l;
+	float	*points[4];
+	int		numPoints;
+
+	switch ( which ) {
+	case -1:
+		points[0] = grid->points[i][j];
+		points[1] = grid->points[i+1][j];
+		points[2] = grid->points[i+1][j+1];
+		points[3] = grid->points[i][j+1];
+		numPoints = 4;
+		break;
+	case 0:
+		points[0] = grid->points[i][j];
+		points[1] = grid->points[i+1][j];
+		points[2] = grid->points[i+1][j+1];
+		numPoints = 3;
+		break;
+	case 1:
+		points[0] = grid->points[i+1][j+1];
+		points[1] = grid->points[i][j+1];
+		points[2] = grid->points[i][j];
+		numPoints = 3;
+		break;
+	default:
+		Com_Error( ERR_FATAL, "CM_SetBorderInward: bad parameter" );
+		numPoints = 0;
+		break;
+	}
+
+	for ( k = 0 ; k < facet->numBorders ; k++ ) {
+		int		front, back;
+
+		front = 0;
+		back = 0;
+
+		for ( l = 0 ; l < numPoints ; l++ ) {
+			int		side;
+
+			side = CM_PointOnPlaneSide( points[l], facet->borderPlanes[k] );
+			if ( side == SIDE_FRONT ) {
+				front++;
+			} if ( side == SIDE_BACK ) {
+				back++;
+			}
+		}
+
+		if ( front && !back ) {
+			facet->borderInward[k] = qtrue;
+		} else if ( back && !front ) {
+			facet->borderInward[k] = qfalse;
+		} else if ( !front && !back ) {
+			// flat side border
+			facet->borderPlanes[k] = -1;
+		} else {
+			// bisecting side border
+			Com_DPrintf( "WARNING: CM_SetBorderInward: mixed plane sides\n" );
+			facet->borderInward[k] = qfalse;
+			if ( !debugBlock ) {
+				debugBlock = qtrue;
+				VectorCopy( grid->points[i][j], debugBlockPoints[0] );
+				VectorCopy( grid->points[i+1][j], debugBlockPoints[1] );
+				VectorCopy( grid->points[i+1][j+1], debugBlockPoints[2] );
+				VectorCopy( grid->points[i][j+1], debugBlockPoints[3] );
+			}
+		}
+	}
+}
+
+#endif
+
+/*
+==================
+CM_ValidateFacet
+
+If the facet isn't bounded by its borders, we screwed up.
+==================
+*/
+#ifdef _XBOX
+static qboolean CM_ValidateFacet( facetLoad_t *facet ) {
+	float		plane[4];
+	int			j;
+	winding_t	*w;
+	vec3_t		bounds[2];
+
+	if ( facet->surfacePlane == -1 ) {
+		return qfalse;
+	}
+
+	Vector4Copy( planes[ facet->surfacePlane ].plane, plane );
+	w = BaseWindingForPlane( plane,  plane[3] );
+	for ( j = 0 ; j < facet->numBorders && w ; j++ ) {
+		if ( facet->borderPlanes[j] == -1 ) {
+			FreeWinding(w);
+			return qfalse;
+		}
+		Vector4Copy( planes[ facet->borderPlanes[j] ].plane, plane );
+		if ( !facet->borderInward[j] ) {
+			VectorSubtract( vec3_origin, plane, plane );
+			plane[3] = -plane[3];
+		}
+		ChopWindingInPlace( &w, plane, plane[3], 0.1f );
+	}
+
+	if ( !w ) {
+		return qfalse;		// winding was completely chopped away
+	}
+
+	// see if the facet is unreasonably large
+	WindingBounds( w, bounds[0], bounds[1] );
+	FreeWinding( w );
+	
+	for ( j = 0 ; j < 3 ; j++ ) {
+		if ( bounds[1][j] - bounds[0][j] > MAX_MAP_BOUNDS ) {
+			return qfalse;		// we must be missing a plane
+		}
+		if ( bounds[0][j] >= MAX_MAP_BOUNDS ) {
+			return qfalse;
+		}
+		if ( bounds[1][j] <= -MAX_MAP_BOUNDS ) {
+			return qfalse;
+		}
+	}
+	return qtrue;		// winding is fine
+}
+
+#else // _XBOX
+
+static qboolean CM_ValidateFacet( facet_t *facet ) {
+	float		plane[4];
+	int			j;
+	winding_t	*w;
+	vec3_t		bounds[2];
+
+	if ( facet->surfacePlane == -1 ) {
+		return qfalse;
+	}
+
+	Vector4Copy( planes[ facet->surfacePlane ].plane, plane );
+	w = BaseWindingForPlane( plane,  plane[3] );
+	for ( j = 0 ; j < facet->numBorders && w ; j++ ) {
+		if ( facet->borderPlanes[j] == -1 ) {
+			FreeWinding(w);
+			return qfalse;
+		}
+		Vector4Copy( planes[ facet->borderPlanes[j] ].plane, plane );
+		if ( !facet->borderInward[j] ) {
+			VectorSubtract( vec3_origin, plane, plane );
+			plane[3] = -plane[3];
+		}
+		ChopWindingInPlace( &w, plane, plane[3], 0.1f );
+	}
+
+	if ( !w ) {
+		return qfalse;		// winding was completely chopped away
+	}
+
+	// see if the facet is unreasonably large
+	WindingBounds( w, bounds[0], bounds[1] );
+	FreeWinding( w );
+	
+	for ( j = 0 ; j < 3 ; j++ ) {
+		if ( bounds[1][j] - bounds[0][j] > MAX_MAP_BOUNDS ) {
+			return qfalse;		// we must be missing a plane
+		}
+		if ( bounds[0][j] >= MAX_MAP_BOUNDS ) {
+			return qfalse;
+		}
+		if ( bounds[1][j] <= -MAX_MAP_BOUNDS ) {
+			return qfalse;
+		}
+	}
+	return qtrue;		// winding is fine
+}
+
+#endif // _XBOX
+
+/*
+==================
+CM_AddFacetBevels
+==================
+*/
+#ifdef _XBOX
+void CM_AddFacetBevels( facetLoad_t *facet ) {
+
+	int i, j, k, l;
+	int axis, dir, order, flipped;
+	float plane[4], d, newplane[4];
+	winding_t *w, *w2;
+	vec3_t mins, maxs, vec, vec2;
+
+#ifndef ADDBEVELS
+	return;
+#endif
+
+	Vector4Copy( planes[ facet->surfacePlane ].plane, plane );
+
+	w = BaseWindingForPlane( plane,  plane[3] );
+	for ( j = 0 ; j < facet->numBorders && w ; j++ ) {
+		if (facet->borderPlanes[j] == facet->surfacePlane) continue;
+		Vector4Copy( planes[ facet->borderPlanes[j] ].plane, plane );
+
+		if ( !facet->borderInward[j] ) {
+			VectorSubtract( vec3_origin, plane, plane );
+			plane[3] = -plane[3];
+		}
+
+		ChopWindingInPlace( &w, plane, plane[3], 0.1f );
+	}
+	if ( !w ) {
+		return;
+	}
+
+	WindingBounds(w, mins, maxs);
+
+	// add the axial planes
+	order = 0;
+	for ( axis = 0 ; axis < 3 ; axis++ )
+	{
+		for ( dir = -1 ; dir <= 1 ; dir += 2, order++ )
+		{
+			VectorClear(plane);
+			plane[axis] = dir;
+			if (dir == 1) {
+				plane[3] = maxs[axis];
+			}
+			else {
+				plane[3] = -mins[axis];
+			}
+			//if it's the surface plane
+			if (CM_PlaneEqual(&planes[facet->surfacePlane], plane, &flipped)) {
+				continue;
+			}
+			// see if the plane is allready present
+			for ( i = 0 ; i < facet->numBorders ; i++ ) {
+				if (CM_PlaneEqual(&planes[facet->borderPlanes[i]], plane, &flipped))
+					break;
+			}
+
+			if ( i == facet->numBorders ) {
+				if (facet->numBorders > 4 + 6 + 16) Com_Printf(S_COLOR_RED"ERROR: too many bevels\n");
+				int num = CM_FindPlane2(plane, &flipped);
+				assert(num > -32768 && num < 32768);
+				facet->borderPlanes[facet->numBorders] = num;
+				facet->borderNoAdjust[facet->numBorders] = 0;
+				facet->borderInward[facet->numBorders] = flipped;
+				facet->numBorders++;
+			}
+		}
+	}
+	//
+	// add the edge bevels
+	//
+	// test the non-axial plane edges
+	for ( j = 0 ; j < w->numpoints ; j++ )
+	{
+		k = (j+1)%w->numpoints;
+		VectorSubtract (w->p[j], w->p[k], vec);
+		//if it's a degenerate edge
+		if (VectorNormalize (vec) < 0.5)
+			continue;
+		CM_SnapVector(vec);
+		for ( k = 0; k < 3 ; k++ )
+			if ( vec[k] == -1 || vec[k] == 1 )
+				break;	// axial
+		if ( k < 3 )
+			continue;	// only test non-axial edges
+
+		// try the six possible slanted axials from this edge
+		for ( axis = 0 ; axis < 3 ; axis++ )
+		{
+			for ( dir = -1 ; dir <= 1 ; dir += 2 )
+			{
+				// construct a plane
+				VectorClear (vec2);
+				vec2[axis] = dir;
+				CrossProduct (vec, vec2, plane);
+				if (VectorNormalize (plane) < 0.5)
+					continue;
+				plane[3] = DotProduct (w->p[j], plane);
+
+				// if all the points of the facet winding are
+				// behind this plane, it is a proper edge bevel
+				for ( l = 0 ; l < w->numpoints ; l++ )
+				{
+					d = DotProduct (w->p[l], plane) - plane[3];
+					if (d > 0.1)
+						break;	// point in front
+				}
+				if ( l < w->numpoints )
+					continue;
+
+				//if it's the surface plane
+				if (CM_PlaneEqual(&planes[facet->surfacePlane], plane, &flipped)) {
+					continue;
+				}
+				// see if the plane is allready present
+				for ( i = 0 ; i < facet->numBorders ; i++ ) {
+					if (CM_PlaneEqual(&planes[facet->borderPlanes[i]], plane, &flipped)) {
+							break;
+					}
+				}
+
+				if ( i == facet->numBorders ) {
+					if (facet->numBorders > 4 + 6 + 16) Com_Printf(S_COLOR_RED"ERROR: too many bevels\n");
+					int num = CM_FindPlane2(plane, &flipped);
+					assert(num > -32768 && num < 32768);
+					facet->borderPlanes[facet->numBorders] = num;
+
+					for ( k = 0 ; k < facet->numBorders ; k++ ) {
+						if (facet->borderPlanes[facet->numBorders] ==
+							facet->borderPlanes[k]) Com_Printf("WARNING: bevel plane already used\n");
+					}
+
+					facet->borderNoAdjust[facet->numBorders] = 0;
+					facet->borderInward[facet->numBorders] = flipped;
+					//
+					w2 = CopyWinding(w);
+					Vector4Copy(planes[facet->borderPlanes[facet->numBorders]].plane, newplane);
+					if (!facet->borderInward[facet->numBorders])
+					{
+						VectorNegate(newplane, newplane);
+						newplane[3] = -newplane[3];
+					} //end if
+					ChopWindingInPlace( &w2, newplane, newplane[3], 0.1f );
+					if (!w2) {
+						Com_DPrintf("WARNING: CM_AddFacetBevels... invalid bevel\n");
+						continue;
+					}
+					else {
+						FreeWinding(w2);
+					}
+					//
+					facet->numBorders++;
+					//already got a bevel
+//					break;
+				}
+			}
+		}
+	}
+	FreeWinding( w );
+
+#ifndef BSPC
+	//add opposite plane
+	assert(facet->surfacePlane > -32768 && facet->surfacePlane < 32768);
+	facet->borderPlanes[facet->numBorders] = facet->surfacePlane;
+	facet->borderNoAdjust[facet->numBorders] = 0;
+	facet->borderInward[facet->numBorders] = qtrue;
+	facet->numBorders++;
+#endif //BSPC
+
+}
+
+#else // _XBOX
+
+void CM_AddFacetBevels( facet_t *facet ) {
+
+	int i, j, k, l;
+	int axis, dir, order, flipped;
+	float plane[4], d, newplane[4];
+	winding_t *w, *w2;
+	vec3_t mins, maxs, vec, vec2;
+
+#ifndef ADDBEVELS
+	return;
+#endif
+
+	Vector4Copy( planes[ facet->surfacePlane ].plane, plane );
+
+	w = BaseWindingForPlane( plane,  plane[3] );
+	for ( j = 0 ; j < facet->numBorders && w ; j++ ) {
+		if (facet->borderPlanes[j] == facet->surfacePlane) continue;
+		Vector4Copy( planes[ facet->borderPlanes[j] ].plane, plane );
+
+		if ( !facet->borderInward[j] ) {
+			VectorSubtract( vec3_origin, plane, plane );
+			plane[3] = -plane[3];
+		}
+
+		ChopWindingInPlace( &w, plane, plane[3], 0.1f );
+	}
+	if ( !w ) {
+		return;
+	}
+
+	WindingBounds(w, mins, maxs);
+
+	// add the axial planes
+	order = 0;
+	for ( axis = 0 ; axis < 3 ; axis++ )
+	{
+		for ( dir = -1 ; dir <= 1 ; dir += 2, order++ )
+		{
+			VectorClear(plane);
+			plane[axis] = dir;
+			if (dir == 1) {
+				plane[3] = maxs[axis];
+			}
+			else {
+				plane[3] = -mins[axis];
+			}
+			//if it's the surface plane
+			if (CM_PlaneEqual(&planes[facet->surfacePlane], plane, &flipped)) {
+				continue;
+			}
+			// see if the plane is allready present
+			for ( i = 0 ; i < facet->numBorders ; i++ ) {
+				if (CM_PlaneEqual(&planes[facet->borderPlanes[i]], plane, &flipped))
+					break;
+			}
+
+			if ( i == facet->numBorders ) {
+				if (facet->numBorders > 4 + 6 + 16) Com_Printf(S_COLOR_RED"ERROR: too many bevels\n");
+				facet->borderPlanes[facet->numBorders] = CM_FindPlane2(plane, &flipped);
+				facet->borderNoAdjust[facet->numBorders] = 0;
+				facet->borderInward[facet->numBorders] = flipped;
+				facet->numBorders++;
+			}
+		}
+	}
+	//
+	// add the edge bevels
+	//
+	// test the non-axial plane edges
+	for ( j = 0 ; j < w->numpoints ; j++ )
+	{
+		k = (j+1)%w->numpoints;
+		VectorSubtract (w->p[j], w->p[k], vec);
+		//if it's a degenerate edge
+		if (VectorNormalize (vec) < 0.5)
+			continue;
+		CM_SnapVector(vec);
+		for ( k = 0; k < 3 ; k++ )
+			if ( vec[k] == -1 || vec[k] == 1 )
+				break;	// axial
+		if ( k < 3 )
+			continue;	// only test non-axial edges
+
+		// try the six possible slanted axials from this edge
+		for ( axis = 0 ; axis < 3 ; axis++ )
+		{
+			for ( dir = -1 ; dir <= 1 ; dir += 2 )
+			{
+				// construct a plane
+				VectorClear (vec2);
+				vec2[axis] = dir;
+				CrossProduct (vec, vec2, plane);
+				if (VectorNormalize (plane) < 0.5)
+					continue;
+				plane[3] = DotProduct (w->p[j], plane);
+
+				// if all the points of the facet winding are
+				// behind this plane, it is a proper edge bevel
+				for ( l = 0 ; l < w->numpoints ; l++ )
+				{
+					d = DotProduct (w->p[l], plane) - plane[3];
+					if (d > 0.1)
+						break;	// point in front
+				}
+				if ( l < w->numpoints )
+					continue;
+
+				//if it's the surface plane
+				if (CM_PlaneEqual(&planes[facet->surfacePlane], plane, &flipped)) {
+					continue;
+				}
+				// see if the plane is allready present
+				for ( i = 0 ; i < facet->numBorders ; i++ ) {
+					if (CM_PlaneEqual(&planes[facet->borderPlanes[i]], plane, &flipped)) {
+							break;
+					}
+				}
+
+				if ( i == facet->numBorders ) {
+					if (facet->numBorders > 4 + 6 + 16) Com_Printf(S_COLOR_RED"ERROR: too many bevels\n");
+					facet->borderPlanes[facet->numBorders] = CM_FindPlane2(plane, &flipped);
+
+					for ( k = 0 ; k < facet->numBorders ; k++ ) {
+						if (facet->borderPlanes[facet->numBorders] ==
+							facet->borderPlanes[k]) Com_Printf("WARNING: bevel plane already used\n");
+					}
+
+					facet->borderNoAdjust[facet->numBorders] = 0;
+					facet->borderInward[facet->numBorders] = flipped;
+					//
+					w2 = CopyWinding(w);
+					Vector4Copy(planes[facet->borderPlanes[facet->numBorders]].plane, newplane);
+					if (!facet->borderInward[facet->numBorders])
+					{
+						VectorNegate(newplane, newplane);
+						newplane[3] = -newplane[3];
+					} //end if
+					ChopWindingInPlace( &w2, newplane, newplane[3], 0.1f );
+					if (!w2) {
+						Com_DPrintf("WARNING: CM_AddFacetBevels... invalid bevel\n");
+						continue;
+					}
+					else {
+						FreeWinding(w2);
+					}
+					//
+					facet->numBorders++;
+					//already got a bevel
+//					break;
+				}
+			}
+		}
+	}
+	FreeWinding( w );
+
+#ifndef BSPC
+	//add opposite plane
+	facet->borderPlanes[facet->numBorders] = facet->surfacePlane;
+	facet->borderNoAdjust[facet->numBorders] = 0;
+	facet->borderInward[facet->numBorders] = qtrue;
+	facet->numBorders++;
+#endif //BSPC
+
+}
+
+#endif // _XBOX
+
+typedef enum {
+	EN_TOP,
+	EN_RIGHT,
+	EN_BOTTOM,
+	EN_LEFT
+} edgeName_t;
+
+#ifdef _XBOX
+facetLoad_t*	cm_facets = 0;
+int*		cm_gridPlanes = 0;
+void CM_PatchCollideFromGridTempAlloc()
+{
+	if (!cm_facets)
+	{
+		cm_facets = (facetLoad_t*)Z_Malloc(MAX_PATCH_PLANES*sizeof(facetLoad_t), TAG_TEMP_WORKSPACE, qfalse);
+	}
+	if (!cm_gridPlanes)
+	{
+		cm_gridPlanes = (int*)Z_Malloc(CM_MAX_GRID_SIZE*CM_MAX_GRID_SIZE*2*sizeof(int), TAG_TEMP_WORKSPACE, qfalse);
+	}
+}
+
+void CM_PatchCollideFromGridTempDealloc()
+{
+	Z_Free(cm_gridPlanes);
+	Z_Free(cm_facets);
+	cm_gridPlanes = 0;
+	cm_facets = 0;
+}
+#endif
+
+/*
+==================
+CM_PatchCollideFromGrid
+==================
+*/
+#ifdef _XBOX
+int min1 = 0, max1 = 0, min2 = 0, max2 = 0;
+static void CM_PatchCollideFromGrid( cGrid_t *grid, patchCollide_t *pf,
+									facetLoad_t *facetbuf, int *gridbuf ) {
+	int				i, j;
+	float			*p1, *p2, *p3;
+	int				*gridPlanes;
+	facetLoad_t			*facet;
+	int				borders[4];
+	int				noAdjust[4];
+	facetLoad_t			*facets;
+	int				numFacets;
+
+	facets = cm_facets;
+	if (facets == 0)
+	{
+		facets = facetbuf;
+	}
+	gridPlanes = cm_gridPlanes;
+	if (gridPlanes == 0)
+	{
+		gridPlanes = gridbuf;
+	}
+	
+	numPlanes = 0;
+	numFacets = 0;
+
+	// find the planes for each triangle of the grid
+	for ( i = 0 ; i < grid->width - 1 ; i++ ) {
+		for ( j = 0 ; j < grid->height - 1 ; j++ ) {
+			p1 = grid->points[i][j];
+			p2 = grid->points[i+1][j];
+			p3 = grid->points[i+1][j+1];
+			gridPlanes[i*CM_MAX_GRID_SIZE*2+j*2+0] = CM_FindPlane( p1, p2, p3 );
+
+			p1 = grid->points[i+1][j+1];
+			p2 = grid->points[i][j+1];
+			p3 = grid->points[i][j];
+			gridPlanes[i*CM_MAX_GRID_SIZE*2+j*2+1] = CM_FindPlane( p1, p2, p3 );
+		}
+	}
+
+	// create the borders for each facet
+	for ( i = 0 ; i < grid->width - 1 ; i++ ) {
+		for ( j = 0 ; j < grid->height - 1 ; j++ ) {
+			 
+			borders[EN_TOP] = -1;
+			if ( j > 0 ) {
+				borders[EN_TOP] = gridPlanes[i*CM_MAX_GRID_SIZE*2+(j-1)*2+1];
+			} else if ( grid->wrapHeight ) {
+				borders[EN_TOP] = gridPlanes[i*CM_MAX_GRID_SIZE*2+(grid->height-2)*2+1];
+			} 
+			noAdjust[EN_TOP] = ( borders[EN_TOP] == gridPlanes[i*CM_MAX_GRID_SIZE*2+j*2+0] );
+			if ( borders[EN_TOP] == -1 || noAdjust[EN_TOP] ) {
+				borders[EN_TOP] = CM_EdgePlaneNum( grid, gridPlanes, i, j, 0 );
+			}
+
+			borders[EN_BOTTOM] = -1;
+			if ( j < grid->height - 2 ) {
+				borders[EN_BOTTOM] = gridPlanes[i*CM_MAX_GRID_SIZE*2+(j+1)*2+0];
+			} else if ( grid->wrapHeight ) {
+				borders[EN_BOTTOM] = gridPlanes[i*CM_MAX_GRID_SIZE*2+0*2+0];
+			}
+			noAdjust[EN_BOTTOM] = ( borders[EN_BOTTOM] == gridPlanes[i*CM_MAX_GRID_SIZE*2+j*2+1] );
+			if ( borders[EN_BOTTOM] == -1 || noAdjust[EN_BOTTOM] ) {
+				borders[EN_BOTTOM] = CM_EdgePlaneNum( grid, gridPlanes, i, j, 2 );
+			}
+
+			borders[EN_LEFT] = -1;
+			if ( i > 0 ) {
+				borders[EN_LEFT] = gridPlanes[(i-1)*CM_MAX_GRID_SIZE*2+j*2+0];
+			} else if ( grid->wrapWidth ) {
+				borders[EN_LEFT] = gridPlanes[(grid->width-2)*CM_MAX_GRID_SIZE*2+j*2+0];
+			}
+			noAdjust[EN_LEFT] = ( borders[EN_LEFT] == gridPlanes[i*CM_MAX_GRID_SIZE*2+j*2+1] );
+			if ( borders[EN_LEFT] == -1 || noAdjust[EN_LEFT] ) {
+				borders[EN_LEFT] = CM_EdgePlaneNum( grid, gridPlanes, i, j, 3 );
+			}
+
+			borders[EN_RIGHT] = -1;
+			if ( i < grid->width - 2 ) {
+				borders[EN_RIGHT] = gridPlanes[(i+1)*CM_MAX_GRID_SIZE*2+j*2+1];
+			} else if ( grid->wrapWidth ) {
+				borders[EN_RIGHT] = gridPlanes[0*CM_MAX_GRID_SIZE*2+j*2+1];
+			}
+			noAdjust[EN_RIGHT] = ( borders[EN_RIGHT] == gridPlanes[i*CM_MAX_GRID_SIZE*2+j*2+0] );
+			if ( borders[EN_RIGHT] == -1 || noAdjust[EN_RIGHT] ) {
+				borders[EN_RIGHT] = CM_EdgePlaneNum( grid, gridPlanes, i, j, 1 );
+			}
+
+			if ( numFacets == MAX_FACETS ) {
+				Com_Error( ERR_DROP, "MAX_FACETS" );
+			}
+			facet = &facets[numFacets];
+			memset( facet, 0, sizeof( *facet ) );
+
+			if ( gridPlanes[i*CM_MAX_GRID_SIZE*2+j*2+0] == gridPlanes[i*CM_MAX_GRID_SIZE*2+j*2+1] ) {
+				if ( gridPlanes[i*CM_MAX_GRID_SIZE*2+j*2+0] == -1 ) {
+					continue;		// degenrate
+				}
+				facet->surfacePlane = gridPlanes[i*CM_MAX_GRID_SIZE*2+j*2+0];
+				facet->numBorders = 4;
+				facet->borderPlanes[0] = borders[EN_TOP];
+				assert(borders[EN_TOP] > -32768 && borders[EN_TOP] < 32768);
+				facet->borderNoAdjust[0] = noAdjust[EN_TOP];
+				assert(noAdjust[EN_TOP] >= 0 && noAdjust[EN_TOP] < 256);
+				facet->borderPlanes[1] = borders[EN_RIGHT];
+				assert(borders[EN_RIGHT] > -32768 && borders[EN_RIGHT] < 32768);
+				facet->borderNoAdjust[1] = noAdjust[EN_RIGHT];
+				assert(noAdjust[EN_RIGHT] >= 0 && noAdjust[EN_RIGHT] < 256);
+				facet->borderPlanes[2] = borders[EN_BOTTOM];
+				assert(borders[EN_BOTTOM] > -32768 && 
+						borders[EN_BOTTOM] < 32768);
+				facet->borderNoAdjust[2] = noAdjust[EN_BOTTOM];
+				assert(noAdjust[EN_BOTTOM] >= 0 && noAdjust[EN_BOTTOM] < 256);
+				facet->borderPlanes[3] = borders[EN_LEFT];
+				assert(borders[EN_LEFT] > -32768 && borders[EN_LEFT] < 32768);
+				facet->borderNoAdjust[3] = noAdjust[EN_LEFT];
+				assert(noAdjust[EN_LEFT] >= 0 && noAdjust[EN_LEFT] < 256);
+				CM_SetBorderInward( facet, grid, i, j, -1 );
+				if ( CM_ValidateFacet( facet ) ) {
+					CM_AddFacetBevels( facet );
+					numFacets++;
+				}
+			} else {
+				// two seperate triangles
+				facet->surfacePlane = gridPlanes[i*CM_MAX_GRID_SIZE*2+j*2+0];
+				facet->numBorders = 3;
+				facet->borderPlanes[0] = borders[EN_TOP];
+				assert(borders[EN_TOP] > -32768 && borders[EN_TOP] < 32768);
+				assert(noAdjust[EN_TOP] >= 0 && noAdjust[EN_TOP] < 256);
+				facet->borderNoAdjust[0] = noAdjust[EN_TOP];
+				facet->borderPlanes[1] = borders[EN_RIGHT];
+				assert(borders[EN_RIGHT] > -32768 && borders[EN_RIGHT] < 32768);
+				facet->borderNoAdjust[1] = noAdjust[EN_RIGHT];
+				assert(noAdjust[EN_RIGHT] >= 0 && noAdjust[EN_RIGHT] < 256);
+				facet->borderPlanes[2] = gridPlanes[i*CM_MAX_GRID_SIZE*2+j*2+1];
+				assert(gridPlanes[i*CM_MAX_GRID_SIZE*2+j*2+1] > -32768 &&
+						gridPlanes[i*CM_MAX_GRID_SIZE*2+j*2+1] < 32768);
+				if ( facet->borderPlanes[2] == -1 ) {
+					facet->borderPlanes[2] = borders[EN_BOTTOM];
+					assert(borders[EN_BOTTOM] > -32768 && 
+							borders[EN_BOTTOM] < 32768);
+					if ( facet->borderPlanes[2] == -1 ) {
+						int num = CM_EdgePlaneNum( grid, gridPlanes, i, j, 4 );
+						assert(num > -32768 && num < 32768);
+						facet->borderPlanes[2] = num;
+					}
+				}
+ 				CM_SetBorderInward( facet, grid, i, j, 0 );
+				if ( CM_ValidateFacet( facet ) ) {
+					CM_AddFacetBevels( facet );
+					numFacets++;
+				}
+
+				if ( numFacets == MAX_FACETS ) {
+					Com_Error( ERR_DROP, "MAX_FACETS" );
+				}
+				facet = &facets[numFacets];
+				memset( facet, 0, sizeof( *facet ) );
+
+				facet->surfacePlane = gridPlanes[i*CM_MAX_GRID_SIZE*2+j*2+1];
+				facet->numBorders = 3;
+				facet->borderPlanes[0] = borders[EN_BOTTOM];
+				assert(borders[EN_BOTTOM] > -32768 && 
+						borders[EN_BOTTOM] < 32768);
+				facet->borderNoAdjust[0] = noAdjust[EN_BOTTOM];
+				assert(noAdjust[EN_BOTTOM] >= 0 && noAdjust[EN_BOTTOM] < 256);
+				facet->borderPlanes[1] = borders[EN_LEFT];
+				assert(borders[EN_LEFT] > -32768 && borders[EN_LEFT] < 32768);
+				facet->borderNoAdjust[1] = noAdjust[EN_LEFT];
+				assert(noAdjust[EN_LEFT] >= 0 && noAdjust[EN_LEFT] < 256);
+				facet->borderPlanes[2] = gridPlanes[i*CM_MAX_GRID_SIZE*2+j*2+0];
+				assert(gridPlanes[i*CM_MAX_GRID_SIZE*2+j*2+0] > -32768 &&
+						gridPlanes[i*CM_MAX_GRID_SIZE*2+j*2+0] < 32768);
+				if ( facet->borderPlanes[2] == -1 ) {
+					facet->borderPlanes[2] = borders[EN_TOP];
+					assert(borders[EN_TOP] > -32768 && 
+							borders[EN_TOP] < 32768);
+					if ( facet->borderPlanes[2] == -1 ) {
+						int num = CM_EdgePlaneNum( grid, gridPlanes, i, j, 5 );
+						assert(num > -32768 && num < 32768);
+						facet->borderPlanes[2] = num;
+					}
+				}
+				CM_SetBorderInward( facet, grid, i, j, 1 );
+				if ( CM_ValidateFacet( facet ) ) {
+					CM_AddFacetBevels( facet );
+					numFacets++;
+				}
+			}
+		}
+	}
+
+	// copy the results out
+	pf->numPlanes = numPlanes;
+	pf->numFacets = numFacets;
+	if (numFacets)
+	{
+		pf->facets = (facet_t *) Z_Malloc( numFacets * sizeof( *pf->facets ), TAG_BSP, qfalse);
+		for(i=0; i<numFacets; i++) {
+			pf->facets[i].data = (char*)Z_Malloc(facets[i].numBorders * 4,
+					TAG_BSP, qfalse);
+			pf->facets[i].surfacePlane = facets[i].surfacePlane;
+			pf->facets[i].numBorders = facets[i].numBorders;
+			short *bp = pf->facets[i].GetBorderPlanes();
+			char *bi = pf->facets[i].GetBorderInward();
+			char *bna = pf->facets[i].GetBorderNoAdjust();
+			for(j=0; j<facets[i].numBorders; j++) {
+				bp[j] = facets[i].borderPlanes[j];
+				bi[j] = facets[i].borderInward[j];
+				bna[j] = facets[i].borderNoAdjust[j];
+			}
+		}
+	}
+	else 
+	{
+		pf->facets = 0;
+	}
+	pf->planes = (patchPlane_t *) Z_Malloc( numPlanes * sizeof( *pf->planes ), TAG_BSP, qfalse);
+	memcpy( pf->planes, planes, numPlanes * sizeof( *pf->planes ) );
+}
+
+#else 
+
+static void CM_PatchCollideFromGrid( cGrid_t *grid, patchCollide_t *pf ) {
+	int				i, j;
+	float			*p1, *p2, *p3;
+	MAC_STATIC int				gridPlanes[CM_MAX_GRID_SIZE][CM_MAX_GRID_SIZE][2];
+	facet_t			*facet;
+	int				borders[4];
+	int				noAdjust[4];
+
+	int numFacets;
+	facets = (facet_t*) Z_Malloc(MAX_FACETS*sizeof(facet_t), TAG_TEMP_WORKSPACE, qfalse, 4);
+
+	numPlanes = 0;
+	numFacets = 0;
+
+	// find the planes for each triangle of the grid
+	for ( i = 0 ; i < grid->width - 1 ; i++ ) {
+		for ( j = 0 ; j < grid->height - 1 ; j++ ) {
+			p1 = grid->points[i][j];
+			p2 = grid->points[i+1][j];
+			p3 = grid->points[i+1][j+1];
+			gridPlanes[i][j][0] = CM_FindPlane( p1, p2, p3 );
+
+			p1 = grid->points[i+1][j+1];
+			p2 = grid->points[i][j+1];
+			p3 = grid->points[i][j];
+			gridPlanes[i][j][1] = CM_FindPlane( p1, p2, p3 );
+		}
+	}
+
+	// create the borders for each facet
+	for ( i = 0 ; i < grid->width - 1 ; i++ ) {
+		for ( j = 0 ; j < grid->height - 1 ; j++ ) {
+			 
+			borders[EN_TOP] = -1;
+			if ( j > 0 ) {
+				borders[EN_TOP] = gridPlanes[i][j-1][1];
+			} else if ( grid->wrapHeight ) {
+				borders[EN_TOP] = gridPlanes[i][grid->height-2][1];
+			} 
+			noAdjust[EN_TOP] = ( borders[EN_TOP] == gridPlanes[i][j][0] );
+			if ( borders[EN_TOP] == -1 || noAdjust[EN_TOP] ) {
+				borders[EN_TOP] = CM_EdgePlaneNum( grid, gridPlanes, i, j, 0 );
+			}
+
+			borders[EN_BOTTOM] = -1;
+			if ( j < grid->height - 2 ) {
+				borders[EN_BOTTOM] = gridPlanes[i][j+1][0];
+			} else if ( grid->wrapHeight ) {
+				borders[EN_BOTTOM] = gridPlanes[i][0][0];
+			}
+			noAdjust[EN_BOTTOM] = ( borders[EN_BOTTOM] == gridPlanes[i][j][1] );
+			if ( borders[EN_BOTTOM] == -1 || noAdjust[EN_BOTTOM] ) {
+				borders[EN_BOTTOM] = CM_EdgePlaneNum( grid, gridPlanes, i, j, 2 );
+			}
+
+			borders[EN_LEFT] = -1;
+			if ( i > 0 ) {
+				borders[EN_LEFT] = gridPlanes[i-1][j][0];
+			} else if ( grid->wrapWidth ) {
+				borders[EN_LEFT] = gridPlanes[grid->width-2][j][0];
+			}
+			noAdjust[EN_LEFT] = ( borders[EN_LEFT] == gridPlanes[i][j][1] );
+			if ( borders[EN_LEFT] == -1 || noAdjust[EN_LEFT] ) {
+				borders[EN_LEFT] = CM_EdgePlaneNum( grid, gridPlanes, i, j, 3 );
+			}
+
+			borders[EN_RIGHT] = -1;
+			if ( i < grid->width - 2 ) {
+				borders[EN_RIGHT] = gridPlanes[i+1][j][1];
+			} else if ( grid->wrapWidth ) {
+				borders[EN_RIGHT] = gridPlanes[0][j][1];
+			}
+			noAdjust[EN_RIGHT] = ( borders[EN_RIGHT] == gridPlanes[i][j][0] );
+			if ( borders[EN_RIGHT] == -1 || noAdjust[EN_RIGHT] ) {
+				borders[EN_RIGHT] = CM_EdgePlaneNum( grid, gridPlanes, i, j, 1 );
+			}
+
+			if ( numFacets == MAX_FACETS ) {
+				Com_Error( ERR_DROP, "MAX_FACETS" );
+			}
+			facet = &facets[numFacets];
+			memset( facet, 0, sizeof( *facet ) );
+
+			if ( gridPlanes[i][j][0] == gridPlanes[i][j][1] ) {
+				if ( gridPlanes[i][j][0] == -1 ) {
+					continue;		// degenrate
+				}
+				facet->surfacePlane = gridPlanes[i][j][0];
+				facet->numBorders = 4;
+				facet->borderPlanes[0] = borders[EN_TOP];
+				facet->borderNoAdjust[0] = noAdjust[EN_TOP];
+				facet->borderPlanes[1] = borders[EN_RIGHT];
+				facet->borderNoAdjust[1] = noAdjust[EN_RIGHT];
+				facet->borderPlanes[2] = borders[EN_BOTTOM];
+				facet->borderNoAdjust[2] = noAdjust[EN_BOTTOM];
+				facet->borderPlanes[3] = borders[EN_LEFT];
+				facet->borderNoAdjust[3] = noAdjust[EN_LEFT];
+				CM_SetBorderInward( facet, grid, gridPlanes, i, j, -1 );
+				if ( CM_ValidateFacet( facet ) ) {
+					CM_AddFacetBevels( facet );
+					numFacets++;
+				}
+			} else {
+				// two seperate triangles
+				facet->surfacePlane = gridPlanes[i][j][0];
+				facet->numBorders = 3;
+				facet->borderPlanes[0] = borders[EN_TOP];
+				facet->borderNoAdjust[0] = noAdjust[EN_TOP];
+				facet->borderPlanes[1] = borders[EN_RIGHT];
+				facet->borderNoAdjust[1] = noAdjust[EN_RIGHT];
+				facet->borderPlanes[2] = gridPlanes[i][j][1];
+				if ( facet->borderPlanes[2] == -1 ) {
+					facet->borderPlanes[2] = borders[EN_BOTTOM];
+					if ( facet->borderPlanes[2] == -1 ) {
+						facet->borderPlanes[2] = CM_EdgePlaneNum( grid, gridPlanes, i, j, 4 );
+					}
+				}
+ 				CM_SetBorderInward( facet, grid, gridPlanes, i, j, 0 );
+				if ( CM_ValidateFacet( facet ) ) {
+					CM_AddFacetBevels( facet );
+					numFacets++;
+				}
+
+				if ( numFacets == MAX_FACETS ) {
+					Com_Error( ERR_DROP, "MAX_FACETS" );
+				}
+				facet = &facets[numFacets];
+				memset( facet, 0, sizeof( *facet ) );
+
+				facet->surfacePlane = gridPlanes[i][j][1];
+				facet->numBorders = 3;
+				facet->borderPlanes[0] = borders[EN_BOTTOM];
+				facet->borderNoAdjust[0] = noAdjust[EN_BOTTOM];
+				facet->borderPlanes[1] = borders[EN_LEFT];
+				facet->borderNoAdjust[1] = noAdjust[EN_LEFT];
+				facet->borderPlanes[2] = gridPlanes[i][j][0];
+				if ( facet->borderPlanes[2] == -1 ) {
+					facet->borderPlanes[2] = borders[EN_TOP];
+					if ( facet->borderPlanes[2] == -1 ) {
+						facet->borderPlanes[2] = CM_EdgePlaneNum( grid, gridPlanes, i, j, 5 );
+					}
+				}
+				CM_SetBorderInward( facet, grid, gridPlanes, i, j, 1 );
+				if ( CM_ValidateFacet( facet ) ) {
+					CM_AddFacetBevels( facet );
+					numFacets++;
+				}
+			}
+		}
+	}
+
+	// copy the results out
+	pf->numPlanes = numPlanes;
+	pf->numFacets = numFacets;
+	if (numFacets)
+	{
+		pf->facets = (facet_t *) Z_Malloc( numFacets * sizeof( *pf->facets ), TAG_BSP, qfalse);
+		memcpy( pf->facets, facets, numFacets * sizeof( *pf->facets ) );
+	}
+	else 
+	{
+		pf->facets = 0;
+	}
+	pf->planes = (patchPlane_t *) Z_Malloc( numPlanes * sizeof( *pf->planes ), TAG_BSP, qfalse);
+	memcpy( pf->planes, planes, numPlanes * sizeof( *pf->planes ) );
+
+	Z_Free(facets);
+}
+
+#endif // _XBOX
+
+static patchCollide_t *pfScratch = 0;
+void CM_PreparePatchCollide(int num)
+{
+	pfScratch = (patchCollide_t *) Z_Malloc( sizeof( *pfScratch ) * num, TAG_BSP, qfalse );
+}
+
+cGrid_t *cm_grid = 0;
+void CM_GridAlloc()
+{
+	if (cm_grid) return;
+	cm_grid = (cGrid_t*)Z_Malloc(sizeof(cGrid_t), TAG_TEMP_WORKSPACE, qfalse);
+}
+
+void CM_GridDealloc()
+{
+	Z_Free(cm_grid);
+	cm_grid = 0;
+}
+
+/*
+===================
+CM_GeneratePatchCollide
+
+Creates an internal structure that will be used to perform
+collision detection with a patch mesh.
+
+Points is packed as concatenated rows.
+===================
+*/
+#ifdef _XBOX
+struct patchCollide_s	*CM_GeneratePatchCollide( int width, int height, vec3_t *points,
+												 facetLoad_t *facetbuf, int *gridbuf ) {
+	patchCollide_t	*pf;
+// --AAA--AAA--
+//	cGrid_t			*grid = new cGrid_t;
+	cGrid_t			*grid = cm_grid;
+// --AAA--AAA--
+	int				i, j;
+
+	memset(grid, 0, sizeof(cGrid_t));
+	if ( width <= 2 || height <= 2 || !points ) {
+		Com_Error( ERR_DROP, "CM_GeneratePatchFacets: bad parameters: (%i, %i, %p)",
+			width, height, points );
+	}
+
+	if ( !(width & 1) || !(height & 1) ) {
+		Com_Error( ERR_DROP, "CM_GeneratePatchFacets: even sizes are invalid for quadratic meshes" );
+	}
+
+	if ( width > CM_MAX_GRID_SIZE || height > CM_MAX_GRID_SIZE ) {
+		Com_Error( ERR_DROP, "CM_GeneratePatchFacets: source is > CM_MAX_GRID_SIZE" );
+	}
+
+	// build a grid
+	grid->width = width;
+	grid->height = height;
+	grid->wrapWidth = qfalse;
+	grid->wrapHeight = qfalse;
+	for ( i = 0 ; i < width ; i++ ) {
+		for ( j = 0 ; j < height ; j++ ) {
+			VectorCopy( points[j*width + i], grid->points[i][j] );
+		}
+	}
+
+	// subdivide the grid
+	CM_SetGridWrapWidth( grid );
+	CM_SubdivideGridColumns( grid );
+	CM_RemoveDegenerateColumns( grid );
+
+	CM_TransposeGrid( grid );
+
+	CM_SetGridWrapWidth( grid );
+	CM_SubdivideGridColumns( grid );
+	CM_RemoveDegenerateColumns( grid );
+
+	// we now have a grid of points exactly on the curve
+	// the aproximate surface defined by these points will be
+	// collided against
+	
+	// --AAA--AAA--
+//	pf = (patchCollide_t *) Z_Malloc( sizeof( *pf ), TAG_BSP, qfalse );
+	pf = pfScratch++;
+	// --AAA--AAA--
+	
+	ClearBounds( pf->bounds[0], pf->bounds[1] );
+	for ( i = 0 ; i < grid->width ; i++ ) {
+		for ( j = 0 ; j < grid->height ; j++ ) {
+			AddPointToBounds( grid->points[i][j], pf->bounds[0], pf->bounds[1] );
+		}
+	}
+
+	c_totalPatchBlocks += ( grid->width - 1 ) * ( grid->height - 1 );
+
+	// generate a bsp tree for the surface
+	CM_PatchCollideFromGrid( grid, pf, facetbuf, gridbuf );
+
+	// expand by one unit for epsilon purposes
+	pf->bounds[0][0] -= 1;
+	pf->bounds[0][1] -= 1;
+	pf->bounds[0][2] -= 1;
+
+	pf->bounds[1][0] += 1;
+	pf->bounds[1][1] += 1;
+	pf->bounds[1][2] += 1;
+
+// --AAA--AAA--
+//	delete grid;
+// --AAA--AAA--
+
+	return pf;
+}
+
+#else
+
+struct patchCollide_s	*CM_GeneratePatchCollide( int width, int height, vec3_t *points ) {
+	patchCollide_t	*pf;
+	MAC_STATIC cGrid_t			grid;
+	int				i, j;
+
+	if ( width <= 2 || height <= 2 || !points ) {
+		Com_Error( ERR_DROP, "CM_GeneratePatchFacets: bad parameters: (%i, %i, %p)",
+			width, height, points );
+	}
+
+	if ( !(width & 1) || !(height & 1) ) {
+		Com_Error( ERR_DROP, "CM_GeneratePatchFacets: even sizes are invalid for quadratic meshes" );
+	}
+
+	if ( width > CM_MAX_GRID_SIZE || height > CM_MAX_GRID_SIZE ) {
+		Com_Error( ERR_DROP, "CM_GeneratePatchFacets: source is > CM_MAX_GRID_SIZE" );
+	}
+
+	// build a grid
+	grid.width = width;
+	grid.height = height;
+	grid.wrapWidth = qfalse;
+	grid.wrapHeight = qfalse;
+	for ( i = 0 ; i < width ; i++ ) {
+		for ( j = 0 ; j < height ; j++ ) {
+			VectorCopy( points[j*width + i], grid.points[i][j] );
+		}
+	}
+
+	// subdivide the grid
+	CM_SetGridWrapWidth( &grid );
+	CM_SubdivideGridColumns( &grid );
+	CM_RemoveDegenerateColumns( &grid );
+
+	CM_TransposeGrid( &grid );
+
+	CM_SetGridWrapWidth( &grid );
+	CM_SubdivideGridColumns( &grid );
+	CM_RemoveDegenerateColumns( &grid );
+
+	// we now have a grid of points exactly on the curve
+	// the aproximate surface defined by these points will be
+	// collided against
+	pf = (patchCollide_t *) Z_Malloc( sizeof( *pf ), TAG_BSP, qfalse );
+	ClearBounds( pf->bounds[0], pf->bounds[1] );
+	for ( i = 0 ; i < grid.width ; i++ ) {
+		for ( j = 0 ; j < grid.height ; j++ ) {
+			AddPointToBounds( grid.points[i][j], pf->bounds[0], pf->bounds[1] );
+		}
+	}
+
+	c_totalPatchBlocks += ( grid.width - 1 ) * ( grid.height - 1 );
+
+	// generate a bsp tree for the surface
+	CM_PatchCollideFromGrid( &grid, pf );
+
+	// expand by one unit for epsilon purposes
+	pf->bounds[0][0] -= 1;
+	pf->bounds[0][1] -= 1;
+	pf->bounds[0][2] -= 1;
+
+	pf->bounds[1][0] += 1;
+	pf->bounds[1][1] += 1;
+	pf->bounds[1][2] += 1;
+
+	return pf;
+}
+
+#endif // _XBOX
+
+/*
+================================================================================
+
+TRACE TESTING
+
+================================================================================
+*/
+
+/*
+====================
+CM_TraceThroughPatchCollide
+
+Modifies tr->tr if any of the facets effect the trace
+====================
+*/
+
+/*
+void CM_TraceThroughPatchCollide( traceWork_t *tw, const struct patchCollide_s *pc )
+{
+	int i, j, n;
+	float d1, d2, offset, planedist, fraction;
+	vec3_t v1, v2, normal, point;
+	patchPlane_t *planes;
+	facet_t	*facet;
+	//
+	facet = pc->facets;
+	for ( i = 0 ; i < pc->numFacets ; i++, facet++ )
+	{
+		planes = &pc->planes[ facet->surfacePlane ];
+		VectorCopy(planes->plane, normal);
+		for (n = 0; n < 3; n++)
+		{
+			if (normal[n] > 0) v1[n] = tw->size[0][n];
+			else v1[n] = tw->size[1][n];
+		} //end for
+		VectorNegate(normal, v2);
+		offset = DotProduct(v1, v2);
+		//offset = 0;
+		//
+		planedist = planes->plane[3] + offset;
+		//
+		d1 = DotProduct( tw->start, normal ) - planedist;
+		d2 = DotProduct( tw->end, normal ) - planedist;
+
+		// if completely in front of face, no intersection with the entire patch
+		if (d1 > 0 && ( d2 >= SURFACE_CLIP_EPSILON || d2 >= d1 )  ) {
+			continue;
+		}
+
+		// if it doesn't cross the plane, the plane isn't relevent
+		if (d1 <= 0 && d2 <= 0 ) {
+			continue;
+		}
+
+		// crosses face
+		if (d1 > d2) {	// enter
+			fraction = (d1-SURFACE_CLIP_EPSILON) / (d1-d2);
+			if ( fraction < 0 ) {
+				fraction = 0;
+			}
+			for (j = 0; j < 3; j++)
+				point[j] = tw->start[j] + (tw->end[j] - tw->start[j]) * fraction;
+		}
+		else {
+			continue;
+		}
+		//
+		for (j = 0; j < facet->numBorders; j++)
+		{
+			planes = &pc->planes[ facet->borderPlanes[j] ];
+			if (!facet->borderInward[j])
+			{
+				VectorNegate(planes->plane, normal);
+				planedist = -planes->plane[3];
+			} //end if
+			else
+			{
+				VectorCopy(planes->plane, normal);
+				planedist = planes->plane[3];
+			} //end else
+			for (n = 0; n < 3; n++)
+			{
+				if (normal[n] > 0) v1[n] = tw->size[0][n];
+				else v1[n] = tw->size[1][n];
+			} //end for
+			VectorNegate(normal, v2);
+			offset = DotProduct(v1, v2);
+			//offset = 0;
+			planedist -= offset;
+			//the hit point should be in front of the (inward facing) border plane
+			if (DotProduct(point, normal) - planedist < -ON_EPSILON) break;
+		} //end for
+		if (j < facet->numBorders) continue;
+		//
+		if (fraction < tw->trace.fraction)
+		{
+			debugPatchCollide = pc;
+			debugFacet = facet;
+
+			tw->trace.fraction = fraction;
+			planes = &pc->planes[ facet->surfacePlane ];
+			VectorCopy( planes->plane, tw->trace.plane.normal );
+			tw->trace.plane.dist = planes->plane[3];
+		} //end if
+	} //end for
+} //end of the function CM_TraceThroughPatchCollide*/
+
+/*
+====================
+CM_TracePointThroughPatchCollide
+
+  special case for point traces because the patch collide "brushes" have no volume
+====================
+*/
+#ifdef _XBOX
+void CM_TracePointThroughPatchCollide( traceWork_t *tw, const struct patchCollide_s *pc ) {
+	qboolean	frontFacing[MAX_PATCH_PLANES];
+	float		intersection[MAX_PATCH_PLANES];
+	float		intersect;
+	const patchPlane_t	*planes;
+	const facet_t	*facet;
+	int			i, j, k;
+	float		offset;
+	float		d1, d2;
+#ifndef BSPC
+	static cvar_t *cv;
+#endif //BSPC
+
+#ifndef BSPC
+	if ( !cm_playerCurveClip->integer && !tw->isPoint ) {
+		return;		// FIXME: until I get player sized clipping working right
+	}
+#endif
+
+	if (!pc->numFacets)
+	{	//not gonna do anything anyhow?
+		return;
+	}
+	// determine the trace's relationship to all planes
+	planes = pc->planes;
+	for ( i = 0 ; i < pc->numPlanes ; i++, planes++ ) {
+		offset = DotProduct( tw->offsets[ planes->signbits ], planes->plane );
+		d1 = DotProduct( tw->start, planes->plane ) - planes->plane[3] + offset;
+		d2 = DotProduct( tw->end, planes->plane ) - planes->plane[3] + offset;
+		if ( d1 <= 0 ) {
+			frontFacing[i] = qfalse;
+		} else {
+			frontFacing[i] = qtrue;
+		}
+		if ( d1 == d2 ) {
+			intersection[i] = WORLD_SIZE;
+		} else {
+			intersection[i] = d1 / ( d1 - d2 );
+			if ( intersection[i] <= 0 ) {
+				intersection[i] = WORLD_SIZE;
+			}
+		}
+	}
+
+
+	// see if any of the surface planes are intersected
+	facet = pc->facets;
+	for ( i = 0 ; i < pc->numFacets ; i++, facet++ ) {
+		if ( !frontFacing[facet->surfacePlane] ) {
+			continue;
+		}
+		intersect = intersection[facet->surfacePlane];
+		if ( intersect < 0 ) {
+			continue;		// surface is behind the starting point
+		}
+		if ( intersect > tw->trace.fraction ) {
+			continue;		// already hit something closer
+		}
+		for ( j = 0 ; j < facet->numBorders ; j++ ) {
+			k = facet->GetBorderPlanes()[j];
+			if ( frontFacing[k] ^ facet->GetBorderInward()[j] ) {
+				if ( intersection[k] > intersect ) {
+					break;
+				}
+			} else {
+				if ( intersection[k] < intersect ) {
+					break;
+				}
+			}
+		}
+		if ( j == facet->numBorders ) {
+			// we hit this facet
+#ifndef BSPC
+			if (!cv) {
+				cv = Cvar_Get( "r_debugSurfaceUpdate", "1", 0 );
+			}
+			if (cv->integer) {
+				debugPatchCollide = pc;
+				debugFacet = facet;
+			}
+#endif //BSPC
+			planes = &pc->planes[facet->surfacePlane];
+
+			// calculate intersection with a slight pushoff
+			offset = DotProduct( tw->offsets[ planes->signbits ], planes->plane );
+			d1 = DotProduct( tw->start, planes->plane ) - planes->plane[3] + offset;
+			d2 = DotProduct( tw->end, planes->plane ) - planes->plane[3] + offset;
+			tw->trace.fraction = ( d1 - SURFACE_CLIP_EPSILON ) / ( d1 - d2 );
+
+			if ( tw->trace.fraction < 0 ) {
+				tw->trace.fraction = 0;
+			}
+
+			VectorCopy( planes->plane,  tw->trace.plane.normal );
+			tw->trace.plane.dist = planes->plane[3];
+		}
+	}
+}
+
+#else // _XBOX
+
+void CM_TracePointThroughPatchCollide( traceWork_t *tw, const struct patchCollide_s *pc ) {
+	qboolean	frontFacing[MAX_PATCH_PLANES];
+	float		intersection[MAX_PATCH_PLANES];
+	float		intersect;
+	const patchPlane_t	*planes;
+	const facet_t	*facet;
+	int			i, j, k;
+	float		offset;
+	float		d1, d2;
+#ifndef BSPC
+	static cvar_t *cv;
+#endif //BSPC
+
+#ifndef BSPC
+	if ( !cm_playerCurveClip->integer && !tw->isPoint ) {
+		return;		// FIXME: until I get player sized clipping working right
+	}
+#endif
+
+	if (!pc->numFacets)
+	{	//not gonna do anything anyhow?
+		return;
+	}
+	// determine the trace's relationship to all planes
+	planes = pc->planes;
+	for ( i = 0 ; i < pc->numPlanes ; i++, planes++ ) {
+		offset = DotProduct( tw->offsets[ planes->signbits ], planes->plane );
+		d1 = DotProduct( tw->start, planes->plane ) - planes->plane[3] + offset;
+		d2 = DotProduct( tw->end, planes->plane ) - planes->plane[3] + offset;
+		if ( d1 <= 0 ) {
+			frontFacing[i] = qfalse;
+		} else {
+			frontFacing[i] = qtrue;
+		}
+		if ( d1 == d2 ) {
+			intersection[i] = WORLD_SIZE;
+		} else {
+			intersection[i] = d1 / ( d1 - d2 );
+			if ( intersection[i] <= 0 ) {
+				intersection[i] = WORLD_SIZE;
+			}
+		}
+	}
+
+
+	// see if any of the surface planes are intersected
+	facet = pc->facets;
+	for ( i = 0 ; i < pc->numFacets ; i++, facet++ ) {
+		if ( !frontFacing[facet->surfacePlane] ) {
+			continue;
+		}
+		intersect = intersection[facet->surfacePlane];
+		if ( intersect < 0 ) {
+			continue;		// surface is behind the starting point
+		}
+		if ( intersect > tw->trace.fraction ) {
+			continue;		// already hit something closer
+		}
+		for ( j = 0 ; j < facet->numBorders ; j++ ) {
+			k = facet->borderPlanes[j];
+			if ( frontFacing[k] ^ facet->borderInward[j] ) {
+				if ( intersection[k] > intersect ) {
+					break;
+				}
+			} else {
+				if ( intersection[k] < intersect ) {
+					break;
+				}
+			}
+		}
+		if ( j == facet->numBorders ) {
+			// we hit this facet
+#ifndef BSPC
+			if (!cv) {
+				cv = Cvar_Get( "r_debugSurfaceUpdate", "1", 0 );
+			}
+			if (cv->integer) {
+				debugPatchCollide = pc;
+				debugFacet = facet;
+			}
+#endif //BSPC
+			planes = &pc->planes[facet->surfacePlane];
+
+			// calculate intersection with a slight pushoff
+			offset = DotProduct( tw->offsets[ planes->signbits ], planes->plane );
+			d1 = DotProduct( tw->start, planes->plane ) - planes->plane[3] + offset;
+			d2 = DotProduct( tw->end, planes->plane ) - planes->plane[3] + offset;
+			tw->trace.fraction = ( d1 - SURFACE_CLIP_EPSILON ) / ( d1 - d2 );
+
+			if ( tw->trace.fraction < 0 ) {
+				tw->trace.fraction = 0;
+			}
+
+			VectorCopy( planes->plane,  tw->trace.plane.normal );
+			tw->trace.plane.dist = planes->plane[3];
+		}
+	}
+}
+
+#endif
+
+/*
+====================
+CM_CheckFacetPlane
+====================
+*/
+int CM_CheckFacetPlane(float *plane, vec3_t start, vec3_t end, float *enterFrac, float *leaveFrac, int *hit) {
+	float d1, d2, f;
+
+	*hit = qfalse;
+
+	d1 = DotProduct( start, plane ) - plane[3];
+	d2 = DotProduct( end, plane ) - plane[3];
+
+	// if completely in front of face, no intersection with the entire facet
+	if (d1 > 0 && ( d2 >= SURFACE_CLIP_EPSILON || d2 >= d1 )  ) {
+		return qfalse;
+	}
+
+	// if it doesn't cross the plane, the plane isn't relevent
+	if (d1 <= 0 && d2 <= 0 ) {
+		return qtrue;
+	}
+
+	// crosses face
+	if (d1 > d2) {	// enter
+		f = (d1-SURFACE_CLIP_EPSILON) / (d1-d2);
+		if ( f < 0 ) {
+			f = 0;
+		}
+		//always favor previous plane hits and thus also the surface plane hit
+		if (f > *enterFrac) {
+			*enterFrac = f;
+			*hit = qtrue;
+		}
+	} else {	// leave
+		f = (d1+SURFACE_CLIP_EPSILON) / (d1-d2);
+		if ( f > 1 ) {
+			f = 1;
+		}
+		if (f < *leaveFrac) {
+			*leaveFrac = f;
+		}
+	}
+	return qtrue;
+}
+
+/*
+====================
+CM_TraceThroughPatchCollide
+====================
+*/
+#ifdef _XBOX
+void CM_TraceThroughPatchCollide( traceWork_t *tw, const struct patchCollide_s *pc )
+{
+	int i, j, hit, hitnum;
+	float offset, enterFrac, leaveFrac, t;
+	patchPlane_t *planes;
+	facet_t	*facet;
+	float plane[4], bestplane[4];
+	vec3_t startp, endp;
+#ifndef BSPC
+	static cvar_t *cv;
+#endif //BSPC
+
+#ifndef CULL_BBOX
+	// I'm not sure if test is strictly correct.  Are all
+	// bboxes axis aligned?  Do I care?  It seems to work
+	// good enough...
+	for ( i = 0 ; i < 3 ; i++ ) {
+		if ( tw->bounds[0][i] > pc->bounds[1][i]
+			|| tw->bounds[1][i] < pc->bounds[0][i] ) {
+			return;
+		}
+	}
+#endif
+
+	if (tw->isPoint) {
+
+		CM_TracePointThroughPatchCollide( tw, pc );
+		return;
+	}
+#ifndef ADDBEVELS
+	CM_TracePointThroughPatchCollide( tw, pc );
+	return;
+#endif
+	//
+	facet = pc->facets;
+	for ( i = 0 ; i < pc->numFacets ; i++, facet++ ) {
+		enterFrac = -1.0;
+		leaveFrac = 1.0;
+		hitnum = -1;
+		//
+		planes = &pc->planes[ facet->surfacePlane ];
+		VectorCopy(planes->plane, plane);
+		plane[3] = planes->plane[3];
+		if ( tw->sphere.use ) {
+			// adjust the plane distance apropriately for radius
+			plane[3] += tw->sphere.radius;
+
+			// find the closest point on the capsule to the plane
+			t = DotProduct( plane, tw->sphere.offset );
+			if ( t > 0.0f )
+			{
+				VectorSubtract( tw->start, tw->sphere.offset, startp );
+				VectorSubtract( tw->end, tw->sphere.offset, endp );
+			}
+			else
+			{
+				VectorAdd( tw->start, tw->sphere.offset, startp );
+				VectorAdd( tw->end, tw->sphere.offset, endp );
+			}
+		}
+		else {
+			offset = DotProduct( tw->offsets[ planes->signbits ], plane);
+			plane[3] -= offset;
+			VectorCopy( tw->start, startp );
+			VectorCopy( tw->end, endp );
+		}
+		if (!CM_CheckFacetPlane(plane, startp, endp, &enterFrac, &leaveFrac, &hit)) {
+			continue;
+		}
+		if (hit) {
+			Vector4Copy(plane, bestplane);
+		}
+		for ( j = 0 ; j < facet->numBorders ; j++ ) {
+			planes = &pc->planes[ facet->GetBorderPlanes()[j] ];
+			if (facet->GetBorderInward()[j]) {
+				VectorNegate(planes->plane, plane);
+				plane[3] = -planes->plane[3];
+			}
+			else {
+				VectorCopy(planes->plane, plane);
+				plane[3] = planes->plane[3];
+			}
+			if ( tw->sphere.use ) {
+				// adjust the plane distance apropriately for radius
+				plane[3] += tw->sphere.radius;
+
+				// find the closest point on the capsule to the plane
+				t = DotProduct( plane, tw->sphere.offset );
+				if ( t > 0.0f )
+				{
+					VectorSubtract( tw->start, tw->sphere.offset, startp );
+					VectorSubtract( tw->end, tw->sphere.offset, endp );
+				}
+				else
+				{
+					VectorAdd( tw->start, tw->sphere.offset, startp );
+					VectorAdd( tw->end, tw->sphere.offset, endp );
+				}
+			}
+			else {
+				// NOTE: this works even though the plane might be flipped because the bbox is centered
+				offset = DotProduct( tw->offsets[ planes->signbits ], plane);
+				plane[3] += Q_fabs(offset);
+				VectorCopy( tw->start, startp );
+				VectorCopy( tw->end, endp );
+			}
+			if (!CM_CheckFacetPlane(plane, startp, endp, &enterFrac, &leaveFrac, &hit)) {
+				break;
+			}
+			if (hit) {
+				hitnum = j;
+				Vector4Copy(plane, bestplane);
+			}
+		}
+		if (j < facet->numBorders) continue;
+		//never clip against the back side
+		if (hitnum == facet->numBorders - 1) continue;
+		if (enterFrac < leaveFrac && enterFrac >= 0) {
+			if (enterFrac < tw->trace.fraction) {
+				if (enterFrac < 0) {
+					enterFrac = 0;
+				}
+#ifndef BSPC
+				if (!cv) {
+					cv = Cvar_Get( "r_debugSurfaceUpdate", "1", 0 );
+				}
+				if (cv && cv->integer) {
+					debugPatchCollide = pc;
+					debugFacet = facet;
+				}
+#endif // BSPC
+
+				tw->trace.fraction = enterFrac;
+				VectorCopy( bestplane, tw->trace.plane.normal );
+				tw->trace.plane.dist = bestplane[3];
+			}
+		}
+	}
+}
+
+#else // _XBOX
+
+void CM_TraceThroughPatchCollide( traceWork_t *tw, const struct patchCollide_s *pc )
+{
+	int i, j, hit, hitnum;
+	float offset, enterFrac, leaveFrac, t;
+	patchPlane_t *planes;
+	facet_t	*facet;
+	float plane[4], bestplane[4];
+	vec3_t startp, endp;
+#ifndef BSPC
+	static cvar_t *cv;
+#endif //BSPC
+
+	if (tw->isPoint) {
+		CM_TracePointThroughPatchCollide( tw, pc );
+		return;
+	}
+#ifndef ADDBEVELS
+	CM_TracePointThroughPatchCollide( tw, pc );
+	return;
+#endif
+	//
+	facet = pc->facets;
+	for ( i = 0 ; i < pc->numFacets ; i++, facet++ ) {
+		enterFrac = -1.0;
+		leaveFrac = 1.0;
+		hitnum = -1;
+		//
+		planes = &pc->planes[ facet->surfacePlane ];
+		VectorCopy(planes->plane, plane);
+		plane[3] = planes->plane[3];
+		if ( tw->sphere.use ) {
+			// adjust the plane distance apropriately for radius
+			plane[3] += tw->sphere.radius;
+
+			// find the closest point on the capsule to the plane
+			t = DotProduct( plane, tw->sphere.offset );
+			if ( t > 0.0f )
+			{
+				VectorSubtract( tw->start, tw->sphere.offset, startp );
+				VectorSubtract( tw->end, tw->sphere.offset, endp );
+			}
+			else
+			{
+				VectorAdd( tw->start, tw->sphere.offset, startp );
+				VectorAdd( tw->end, tw->sphere.offset, endp );
+			}
+		}
+		else {
+			offset = DotProduct( tw->offsets[ planes->signbits ], plane);
+			plane[3] -= offset;
+			VectorCopy( tw->start, startp );
+			VectorCopy( tw->end, endp );
+		}
+		if (!CM_CheckFacetPlane(plane, startp, endp, &enterFrac, &leaveFrac, &hit)) {
+			continue;
+		}
+		if (hit) {
+			Vector4Copy(plane, bestplane);
+		}
+		for ( j = 0 ; j < facet->numBorders ; j++ ) {
+			planes = &pc->planes[ facet->borderPlanes[j] ];
+			if (facet->borderInward[j]) {
+				VectorNegate(planes->plane, plane);
+				plane[3] = -planes->plane[3];
+			}
+			else {
+				VectorCopy(planes->plane, plane);
+				plane[3] = planes->plane[3];
+			}
+			if ( tw->sphere.use ) {
+				// adjust the plane distance apropriately for radius
+				plane[3] += tw->sphere.radius;
+
+				// find the closest point on the capsule to the plane
+				t = DotProduct( plane, tw->sphere.offset );
+				if ( t > 0.0f )
+				{
+					VectorSubtract( tw->start, tw->sphere.offset, startp );
+					VectorSubtract( tw->end, tw->sphere.offset, endp );
+				}
+				else
+				{
+					VectorAdd( tw->start, tw->sphere.offset, startp );
+					VectorAdd( tw->end, tw->sphere.offset, endp );
+				}
+			}
+			else {
+				// NOTE: this works even though the plane might be flipped because the bbox is centered
+				offset = DotProduct( tw->offsets[ planes->signbits ], plane);
+				plane[3] += fabs(offset);
+				VectorCopy( tw->start, startp );
+				VectorCopy( tw->end, endp );
+			}
+			if (!CM_CheckFacetPlane(plane, startp, endp, &enterFrac, &leaveFrac, &hit)) {
+				break;
+			}
+			if (hit) {
+				hitnum = j;
+				Vector4Copy(plane, bestplane);
+			}
+		}
+		if (j < facet->numBorders) continue;
+		//never clip against the back side
+		if (hitnum == facet->numBorders - 1) continue;
+		if (enterFrac < leaveFrac && enterFrac >= 0) {
+			if (enterFrac < tw->trace.fraction) {
+				if (enterFrac < 0) {
+					enterFrac = 0;
+				}
+#ifndef BSPC
+				if (!cv) {
+					cv = Cvar_Get( "r_debugSurfaceUpdate", "1", 0 );
+				}
+				if (cv && cv->integer) {
+					debugPatchCollide = pc;
+					debugFacet = facet;
+				}
+#endif // BSPC
+
+				tw->trace.fraction = enterFrac;
+				VectorCopy( bestplane, tw->trace.plane.normal );
+				tw->trace.plane.dist = bestplane[3];
+			}
+		}
+	}
+}
+#endif // _XBOX
+
+/*
+=======================================================================
+
+POSITION TEST
+
+=======================================================================
+*/
+
+#define	BOX_FRONT	0
+#define	BOX_BACK	1
+#define	BOX_CROSS	2
+
+/*
+====================
+CM_PositionTestInPatchCollide
+
+Modifies tr->tr if any of the facets effect the trace
+====================
+*/
+#ifdef _XBOX
+qboolean CM_PositionTestInPatchCollide( traceWork_t *tw, const struct patchCollide_s *pc ) {
+	int			cross[MAX_PATCH_PLANES];
+	const patchPlane_t	*planes;
+	const facet_t	*facet;
+	int			i, j, k;
+	float		offset;
+	float		d;
+
+//return qfalse;
+
+#ifndef CULL_BBOX
+	for ( i = 0 ; i < 3 ; i++ ) {
+		if ( tw->bounds[0][i] > pc->bounds[1][i]
+			|| tw->bounds[1][i] < pc->bounds[0][i] ) {
+			return qfalse;
+		}
+	}
+#endif
+
+	// determine if the box is in front, behind, or crossing each plane
+	planes = pc->planes;
+	for ( i = 0 ; i < pc->numPlanes ; i++, planes++ ) {
+		d = DotProduct( tw->start, planes->plane ) - planes->plane[3];
+		offset = Q_fabs( DotProduct( tw->offsets[ planes->signbits ], planes->plane ) );
+		if ( d < -offset ) {
+			cross[i] = BOX_FRONT;
+		} else if ( d > offset ) {
+			cross[i] = BOX_BACK;
+		} else {
+			cross[i] = BOX_CROSS;
+		}
+	}
+
+
+	// see if any of the surface planes are intersected
+	facet = pc->facets;
+	for ( i = 0 ; i < pc->numFacets ; i++, facet++ ) {
+		// the facet plane must be in a cross state
+		if ( cross[facet->surfacePlane] != BOX_CROSS ) {
+			continue;
+		}
+		// all of the boundaries must be either cross or back
+		for ( j = 0 ; j < facet->numBorders ; j++ ) {
+			k = facet->GetBorderPlanes()[j];
+			if ( cross[ k ] == BOX_CROSS ) {
+				continue;
+			}
+			if ( cross[k] ^ facet->GetBorderInward()[j] ) {
+				break;
+			}
+		}
+		// if we passed all borders, we are definately in this facet
+		if ( j == facet->numBorders ) {
+			return qtrue;
+		}
+	}
+
+	return qfalse;
+}
+
+#else // _XBOX
+
+qboolean CM_PositionTestInPatchCollide( traceWork_t *tw, const struct patchCollide_s *pc ) {
+	int			cross[MAX_PATCH_PLANES];
+	const patchPlane_t	*planes;
+	const facet_t	*facet;
+	int			i, j, k;
+	float		offset;
+	float		d;
+
+//return qfalse;
+
+#ifndef CULL_BBOX
+	for ( i = 0 ; i < 3 ; i++ ) {
+		if ( tw->bounds[0][i] > pc->bounds[1][i]
+			|| tw->bounds[1][i] < pc->bounds[0][i] ) {
+			return qfalse;
+		}
+	}
+#endif
+
+	// determine if the box is in front, behind, or crossing each plane
+	planes = pc->planes;
+	for ( i = 0 ; i < pc->numPlanes ; i++, planes++ ) {
+		d = DotProduct( tw->start, planes->plane ) - planes->plane[3];
+		offset = fabs( DotProduct( tw->offsets[ planes->signbits ], planes->plane ) );
+		if ( d < -offset ) {
+			cross[i] = BOX_FRONT;
+		} else if ( d > offset ) {
+			cross[i] = BOX_BACK;
+		} else {
+			cross[i] = BOX_CROSS;
+		}
+	}
+
+
+	// see if any of the surface planes are intersected
+	facet = pc->facets;
+	for ( i = 0 ; i < pc->numFacets ; i++, facet++ ) {
+		// the facet plane must be in a cross state
+		if ( cross[facet->surfacePlane] != BOX_CROSS ) {
+			continue;
+		}
+		// all of the boundaries must be either cross or back
+		for ( j = 0 ; j < facet->numBorders ; j++ ) {
+			k = facet->borderPlanes[j];
+			if ( cross[ k ] == BOX_CROSS ) {
+				continue;
+			}
+			if ( cross[k] ^ facet->borderInward[j] ) {
+				break;
+			}
+		}
+		// if we passed all borders, we are definately in this facet
+		if ( j == facet->numBorders ) {
+			return qtrue;
+		}
+	}
+
+	return qfalse;
+}
+
+#endif // _XBOX
+
+
+/*
+=======================================================================
+
+DEBUGGING
+
+=======================================================================
+*/
+
+
+/*
+==================
+CM_DrawDebugSurface
+
+Called from the renderer
+==================
+*/
+#ifndef BSPC
+void BotDrawDebugPolygons(void (*drawPoly)(int color, int numPoints, float *points), int value);
+#endif
+
+void CM_DrawDebugSurface( void (*drawPoly)(int color, int numPoints, float *points) ) {
+#ifndef _XBOX
+	static cvar_t	*cv;
+	const patchCollide_t	*pc;
+	facet_t			*facet;
+	winding_t		*w;
+	int				i, j, k, n;
+	int				curplanenum, planenum, curinward, inward;
+	float			plane[4];
+	vec3_t mins = {-15, -15, -28}, maxs = {15, 15, 28};
+	//vec3_t mins = {0, 0, 0}, maxs = {0, 0, 0};
+	vec3_t v1, v2;
+
+	if ( !debugPatchCollide ) {
+		return;
+	}
+
+#ifndef BSPC
+	if ( !cv ) {
+		cv = Cvar_Get( "cm_debugSize", "2", 0 );
+	}
+#endif
+	pc = debugPatchCollide;
+
+	for ( i = 0, facet = pc->facets ; i < pc->numFacets ; i++, facet++ ) {
+
+		for ( k = 0 ; k < facet->numBorders + 1; k++ ) {
+			//
+			if (k < facet->numBorders) {
+				planenum = facet->borderPlanes[k];
+				inward = facet->borderInward[k];
+			}
+			else {
+				planenum = facet->surfacePlane;
+				inward = qfalse;
+				//continue;
+			}
+
+			Vector4Copy( pc->planes[ planenum ].plane, plane );
+
+			//planenum = facet->surfacePlane;
+			if ( inward ) {
+				VectorSubtract( vec3_origin, plane, plane );
+				plane[3] = -plane[3];
+			}
+
+			plane[3] += cv->value;
+			//*
+			for (n = 0; n < 3; n++)
+			{
+				if (plane[n] > 0) v1[n] = maxs[n];
+				else v1[n] = mins[n];
+			} //end for
+			VectorNegate(plane, v2);
+			plane[3] += fabs(DotProduct(v1, v2));
+			//*/
+
+			w = BaseWindingForPlane( plane,  plane[3] );
+			for ( j = 0 ; j < facet->numBorders + 1 && w; j++ ) {
+				//
+				if (j < facet->numBorders) {
+					curplanenum = facet->borderPlanes[j];
+					curinward = facet->borderInward[j];
+				}
+				else {
+					curplanenum = facet->surfacePlane;
+					curinward = qfalse;
+					//continue;
+				}
+				//
+				if (curplanenum == planenum) continue;
+
+				Vector4Copy( pc->planes[ curplanenum ].plane, plane );
+				if ( !curinward ) {
+					VectorSubtract( vec3_origin, plane, plane );
+					plane[3] = -plane[3];
+				}
+		//			if ( !facet->borderNoAdjust[j] ) {
+					plane[3] -= cv->value;
+		//			}
+				for (n = 0; n < 3; n++)
+				{
+					if (plane[n] > 0) v1[n] = maxs[n];
+					else v1[n] = mins[n];
+				} //end for
+				VectorNegate(plane, v2);
+				plane[3] -= fabs(DotProduct(v1, v2));
+
+				ChopWindingInPlace( &w, plane, plane[3], 0.1f );
+			}
+			if ( w ) {
+				if ( facet == debugFacet ) {
+					drawPoly( 4, w->numpoints, w->p[0] );
+					//Com_Printf("blue facet has %d border planes\n", facet->numBorders);
+				} else {
+					drawPoly( 1, w->numpoints, w->p[0] );
+				}
+				FreeWinding( w );
+			}
+			else
+				Com_Printf("winding chopped away by border planes\n");
+		}
+	}
+
+	// draw the debug block
+	{
+		vec3_t			v[3];
+
+		VectorCopy( debugBlockPoints[0], v[0] );
+		VectorCopy( debugBlockPoints[1], v[1] );
+		VectorCopy( debugBlockPoints[2], v[2] );
+		drawPoly( 2, 3, v[0] );
+
+		VectorCopy( debugBlockPoints[2], v[0] );
+		VectorCopy( debugBlockPoints[3], v[1] );
+		VectorCopy( debugBlockPoints[0], v[2] );
+		drawPoly( 2, 3, v[0] );
+	}
+
+#if 0
+	vec3_t			v[4];
+
+	v[0][0] = pc->bounds[1][0];
+	v[0][1] = pc->bounds[1][1];
+	v[0][2] = pc->bounds[1][2];
+
+	v[1][0] = pc->bounds[1][0];
+	v[1][1] = pc->bounds[0][1];
+	v[1][2] = pc->bounds[1][2];
+
+	v[2][0] = pc->bounds[0][0];
+	v[2][1] = pc->bounds[0][1];
+	v[2][2] = pc->bounds[1][2];
+
+	v[3][0] = pc->bounds[0][0];
+	v[3][1] = pc->bounds[1][1];
+	v[3][2] = pc->bounds[1][2];
+
+	drawPoly( 4, v[0] );
+#endif
+#endif // _XBOX
+}
+
+
diff --git a/code/qcommon/cm_patch.h b/code/qcommon/cm_patch.h
new file mode 100644
index 0000000..3ed08ba
--- /dev/null
+++ b/code/qcommon/cm_patch.h
@@ -0,0 +1,121 @@
+
+//#define	CULL_BBOX
+
+/*
+
+This file does not reference any globals, and has these entry points:
+
+void CM_ClearLevelPatches( void );
+struct patchCollide_s	*CM_GeneratePatchCollide( int width, int height, const vec3_t *points );
+void CM_TraceThroughPatchCollide( traceWork_t *tw, const struct patchCollide_s *pc );
+qboolean CM_PositionTestInPatchCollide( traceWork_t *tw, const struct patchCollide_s *pc );
+void CM_DrawDebugSurface( void (*drawPoly)(int color, int numPoints, flaot *points) );
+
+
+Issues for collision against curved surfaces:
+
+Surface edges need to be handled differently than surface planes
+
+Plane expansion causes raw surfaces to expand past expanded bounding box
+
+Position test of a volume against a surface is tricky.
+
+Position test of a point against a surface is not well defined, because the surface has no volume.
+
+
+Tracing leading edge points instead of volumes?
+Position test by tracing corner to corner? (8*7 traces -- ouch)
+
+coplanar edges
+triangulated patches
+degenerate patches
+
+  endcaps
+  degenerate
+
+WARNING: this may misbehave with meshes that have rows or columns that only
+degenerate a few triangles.  Completely degenerate rows and columns are handled
+properly.
+*/
+
+
+#define	MAX_FACETS			1024
+#define	MAX_PATCH_PLANES	2048
+
+typedef struct {
+	float	plane[4];
+	int		signbits;		// signx + (signy<<1) + (signz<<2), used as lookup during collision
+} patchPlane_t;
+
+#ifdef _XBOX
+//Facets are now two structures - a maximum sized version that's used
+//temporarily during load time, and smaller version that only allocates
+//as much memory as needed.  The load version is copied into the small
+//version after it's been assembled.
+#pragma pack(push, 1)
+typedef struct {
+	int			surfacePlane;
+	int			numBorders;		// 3 or four + 6 axial bevels + 4 or 3 * 4 edge bevels
+	short	borderPlanes[4+6+16];
+	unsigned char	borderInward[4+6+16];
+	unsigned char  borderNoAdjust[4+6+16];
+} facetLoad_t;
+
+typedef struct {
+	int			surfacePlane;
+	int			numBorders;		// 3 or four + 6 axial bevels + 4 or 3 * 4 edge bevels
+	char *data;
+
+	short *GetBorderPlanes(void) { return (short*)data; }
+	char *GetBorderInward(void) { return data + (numBorders * 2); }
+	char *GetBorderNoAdjust(void) 
+			{ return data + (numBorders * 2) + numBorders; }
+
+	const short *GetBorderPlanes(void) const { return (short*)data; }
+	const char *GetBorderInward(void) const { return data + (numBorders * 2); }
+	const char *GetBorderNoAdjust(void) const 
+			{ return data + (numBorders * 2) + numBorders; }
+} facet_t;
+#pragma pack(pop)
+
+#else // _XBOX
+
+typedef struct {
+	int			surfacePlane;
+	int			numBorders;		// 3 or four + 6 axial bevels + 4 or 3 * 4 edge bevels
+	int			borderPlanes[4+6+16];
+	int			borderInward[4+6+16];
+	qboolean	borderNoAdjust[4+6+16];
+} facet_t;
+
+#endif // _XBOX
+
+typedef struct patchCollide_s {
+	vec3_t	bounds[2];
+	int		numPlanes;			// surface planes plus edge planes
+	patchPlane_t	*planes;
+	int		numFacets;
+	facet_t	*facets;
+} patchCollide_t;
+
+
+#define	CM_MAX_GRID_SIZE	129
+
+typedef struct {
+	int			width;
+	int			height;
+	qboolean	wrapWidth;
+	qboolean	wrapHeight;
+	vec3_t	points[CM_MAX_GRID_SIZE][CM_MAX_GRID_SIZE];	// [width][height]
+} cGrid_t;
+
+#define	SUBDIVIDE_DISTANCE	16	//4	// never more than this units away from curve
+#define	PLANE_TRI_EPSILON	0.1
+#define	WRAP_POINT_EPSILON	0.1
+
+#ifdef _XBOX
+struct patchCollide_s	*CM_GeneratePatchCollide( int width, int height, vec3_t *points,
+												 facetLoad_t *facetbuf, int *gridbuf );
+#else
+struct patchCollide_s	*CM_GeneratePatchCollide( int width, int height, vec3_t *points );
+#endif // _XBOX
diff --git a/code/qcommon/cm_polylib.cpp b/code/qcommon/cm_polylib.cpp
new file mode 100644
index 0000000..4c2459d
--- /dev/null
+++ b/code/qcommon/cm_polylib.cpp
@@ -0,0 +1,711 @@
+
+// this is only used for visualization tools in cm_ debug functions
+
+
+#include "cm_local.h"
+
+
+// counters are only bumped when running single threaded,
+// because they are an awefull coherence problem
+int	c_active_windings;
+int	c_peak_windings;
+int	c_winding_allocs;
+int	c_winding_points;
+
+void pw(winding_t *w)
+{
+	int		i;
+	for (i=0 ; i<w->numpoints ; i++)
+		printf ("(%5.1f, %5.1f, %5.1f)\n",w->p[i][0], w->p[i][1],w->p[i][2]);
+}
+
+
+/*
+=============
+AllocWinding
+=============
+*/
+winding_t	*AllocWinding (int points)
+{
+	winding_t	*w;
+	int			s;
+
+	c_winding_allocs++;
+	c_winding_points += points;
+	c_active_windings++;
+	if (c_active_windings > c_peak_windings)
+		c_peak_windings = c_active_windings;
+
+	s = sizeof(vec_t)*3*points + sizeof(int);
+	w = (winding_t *) Z_Malloc (s,TAG_BSP, qtrue);//TAG_WINDING);
+//	memset (w, 0, s);	// qtrue above does this
+	return w;
+}
+
+void FreeWinding (winding_t *w)
+{
+	if (*(unsigned *)w == 0xdeaddead)
+		Com_Error (ERR_FATAL, "FreeWinding: freed a freed winding");
+	*(unsigned *)w = 0xdeaddead;
+
+	c_active_windings--;
+	Z_Free (w);
+}
+
+/*
+============
+RemoveColinearPoints
+============
+*/
+int	c_removed;
+
+void	RemoveColinearPoints (winding_t *w)
+{
+	int		i, j, k;
+	vec3_t	v1, v2;
+	int		nump;
+	vec3_t	p[MAX_POINTS_ON_WINDING];
+
+	nump = 0;
+	for (i=0 ; i<w->numpoints ; i++)
+	{
+		j = (i+1)%w->numpoints;
+		k = (i+w->numpoints-1)%w->numpoints;
+		VectorSubtract (w->p[j], w->p[i], v1);
+		VectorSubtract (w->p[i], w->p[k], v2);
+		VectorNormalize2(v1,v1);
+		VectorNormalize2(v2,v2);
+		if (DotProduct(v1, v2) < 0.999)
+		{
+			VectorCopy (w->p[i], p[nump]);
+			nump++;
+		}
+	}
+
+	if (nump == w->numpoints)
+		return;
+
+	c_removed += w->numpoints - nump;
+	w->numpoints = nump;
+	memcpy (w->p, p, nump*sizeof(p[0]));
+}
+
+/*
+============
+WindingPlane
+============
+*/
+void WindingPlane (winding_t *w, vec3_t normal, vec_t *dist)
+{
+	vec3_t	v1, v2;
+
+	VectorSubtract (w->p[1], w->p[0], v1);
+	VectorSubtract (w->p[2], w->p[0], v2);
+	CrossProduct (v2, v1, normal);
+	VectorNormalize2(normal, normal);
+	*dist = DotProduct (w->p[0], normal);
+
+}
+
+/*
+=============
+WindingArea
+=============
+*/
+vec_t	WindingArea (winding_t *w)
+{
+	int		i;
+	vec3_t	d1, d2, cross;
+	vec_t	total;
+
+	total = 0;
+	for (i=2 ; i<w->numpoints ; i++)
+	{
+		VectorSubtract (w->p[i-1], w->p[0], d1);
+		VectorSubtract (w->p[i], w->p[0], d2);
+		CrossProduct (d1, d2, cross);
+		total += 0.5 * VectorLength ( cross );
+	}
+	return total;
+}
+
+void	WindingBounds (winding_t *w, vec3_t mins, vec3_t maxs)
+{
+	vec_t	v;
+	int		i,j;
+
+	mins[0] = mins[1] = mins[2] =  WORLD_SIZE;	// 99999;	// WORLD_SIZE instead of MAX_WORLD_COORD so that...
+	maxs[0] = maxs[1] = maxs[2] = -WORLD_SIZE;	//-99999;	// ... it's guaranteed to be outide of legal
+
+	for (i=0 ; i<w->numpoints ; i++)
+	{
+		for (j=0 ; j<3 ; j++)
+		{
+			v = w->p[i][j];
+			if (v < mins[j])
+				mins[j] = v;
+			if (v > maxs[j])
+				maxs[j] = v;
+		}
+	}
+}
+
+/*
+=============
+WindingCenter
+=============
+*/
+void	WindingCenter (winding_t *w, vec3_t center)
+{
+	int		i;
+	float	scale;
+
+	VectorCopy (vec3_origin, center);
+	for (i=0 ; i<w->numpoints ; i++)
+		VectorAdd (w->p[i], center, center);
+
+	scale = 1.0/w->numpoints;
+	VectorScale (center, scale, center);
+}
+
+/*
+=================
+BaseWindingForPlane
+=================
+*/
+winding_t *BaseWindingForPlane (vec3_t normal, vec_t dist)
+{
+	int		i, x;
+	vec_t	max, v;
+	vec3_t	org, vright, vup;
+	winding_t	*w;
+	
+// find the major axis
+
+	max = -MAX_MAP_BOUNDS;
+	x = -1;
+	for (i=0 ; i<3; i++)
+	{
+		v = fabs(normal[i]);
+		if (v > max)
+		{
+			x = i;
+			max = v;
+		}
+	}
+	if (x==-1)
+		Com_Error (ERR_DROP, "BaseWindingForPlane: no axis found");
+		
+	VectorCopy (vec3_origin, vup);	
+	switch (x)
+	{
+	case 0:
+	case 1:
+		vup[2] = 1;
+		break;		
+	case 2:
+		vup[0] = 1;
+		break;		
+	}
+
+	v = DotProduct (vup, normal);
+	VectorMA (vup, -v, normal, vup);
+	VectorNormalize2(vup, vup);
+		
+	VectorScale (normal, dist, org);
+	
+	CrossProduct (vup, normal, vright);
+	
+	VectorScale (vup, MAX_MAP_BOUNDS, vup);
+	VectorScale (vright, MAX_MAP_BOUNDS, vright);
+
+// project a really big	axis aligned box onto the plane
+	w = AllocWinding (4);
+	
+	VectorSubtract (org, vright, w->p[0]);
+	VectorAdd (w->p[0], vup, w->p[0]);
+	
+	VectorAdd (org, vright, w->p[1]);
+	VectorAdd (w->p[1], vup, w->p[1]);
+	
+	VectorAdd (org, vright, w->p[2]);
+	VectorSubtract (w->p[2], vup, w->p[2]);
+	
+	VectorSubtract (org, vright, w->p[3]);
+	VectorSubtract (w->p[3], vup, w->p[3]);
+	
+	w->numpoints = 4;
+	
+	return w;	
+}
+
+/*
+==================
+CopyWinding
+==================
+*/
+winding_t	*CopyWinding (winding_t *w)
+{
+	int			size;
+	winding_t	*c;
+
+	c = AllocWinding (w->numpoints);
+	size = (int)((winding_t *)0)->p[w->numpoints];
+	memcpy (c, w, size);
+	return c;
+}
+
+/*
+==================
+ReverseWinding
+==================
+*/
+winding_t	*ReverseWinding (winding_t *w)
+{
+	int			i;
+	winding_t	*c;
+
+	c = AllocWinding (w->numpoints);
+	for (i=0 ; i<w->numpoints ; i++)
+	{
+		VectorCopy (w->p[w->numpoints-1-i], c->p[i]);
+	}
+	c->numpoints = w->numpoints;
+	return c;
+}
+
+
+/*
+=============
+ClipWindingEpsilon
+=============
+*/
+void	ClipWindingEpsilon (winding_t *in, vec3_t normal, vec_t dist, 
+				vec_t epsilon, winding_t **front, winding_t **back)
+{
+	vec_t	dists[MAX_POINTS_ON_WINDING+4];
+	int		sides[MAX_POINTS_ON_WINDING+4];
+	int		counts[3];
+	static	vec_t	dot;		// VC 4.2 optimizer bug if not static
+	int		i, j;
+	vec_t	*p1, *p2;
+	vec3_t	mid;
+	winding_t	*f, *b;
+	int		maxpts;
+	
+	counts[0] = counts[1] = counts[2] = 0;
+
+// determine sides for each point
+	for (i=0 ; i<in->numpoints ; i++)
+	{
+		dot = DotProduct (in->p[i], normal);
+		dot -= dist;
+		dists[i] = dot;
+		if (dot > epsilon)
+			sides[i] = SIDE_FRONT;
+		else if (dot < -epsilon)
+			sides[i] = SIDE_BACK;
+		else
+		{
+			sides[i] = SIDE_ON;
+		}
+		counts[sides[i]]++;
+	}
+	sides[i] = sides[0];
+	dists[i] = dists[0];
+	
+	*front = *back = NULL;
+
+	if (!counts[0])
+	{
+		*back = CopyWinding (in);
+		return;
+	}
+	if (!counts[1])
+	{
+		*front = CopyWinding (in);
+		return;
+	}
+
+	maxpts = in->numpoints+4;	// cant use counts[0]+2 because
+								// of fp grouping errors
+
+	*front = f = AllocWinding (maxpts);
+	*back = b = AllocWinding (maxpts);
+		
+	for (i=0 ; i<in->numpoints ; i++)
+	{
+		p1 = in->p[i];
+		
+		if (sides[i] == SIDE_ON)
+		{
+			VectorCopy (p1, f->p[f->numpoints]);
+			f->numpoints++;
+			VectorCopy (p1, b->p[b->numpoints]);
+			b->numpoints++;
+			continue;
+		}
+	
+		if (sides[i] == SIDE_FRONT)
+		{
+			VectorCopy (p1, f->p[f->numpoints]);
+			f->numpoints++;
+		}
+		if (sides[i] == SIDE_BACK)
+		{
+			VectorCopy (p1, b->p[b->numpoints]);
+			b->numpoints++;
+		}
+
+		if (sides[i+1] == SIDE_ON || sides[i+1] == sides[i])
+			continue;
+			
+	// generate a split point
+		p2 = in->p[(i+1)%in->numpoints];
+		
+		dot = dists[i] / (dists[i]-dists[i+1]);
+		for (j=0 ; j<3 ; j++)
+		{	// avoid round off error when possible
+			if (normal[j] == 1)
+				mid[j] = dist;
+			else if (normal[j] == -1)
+				mid[j] = -dist;
+			else
+				mid[j] = p1[j] + dot*(p2[j]-p1[j]);
+		}
+			
+		VectorCopy (mid, f->p[f->numpoints]);
+		f->numpoints++;
+		VectorCopy (mid, b->p[b->numpoints]);
+		b->numpoints++;
+	}
+	
+	if (f->numpoints > maxpts || b->numpoints > maxpts)
+		Com_Error (ERR_DROP, "ClipWinding: points exceeded estimate");
+	if (f->numpoints > MAX_POINTS_ON_WINDING || b->numpoints > MAX_POINTS_ON_WINDING)
+		Com_Error (ERR_DROP, "ClipWinding: MAX_POINTS_ON_WINDING");
+}
+
+
+/*
+=============
+ChopWindingInPlace
+=============
+*/
+void ChopWindingInPlace (winding_t **inout, vec3_t normal, vec_t dist, vec_t epsilon)
+{
+	winding_t	*in;
+	vec_t	dists[MAX_POINTS_ON_WINDING+4];
+	int		sides[MAX_POINTS_ON_WINDING+4];
+	int		counts[3];
+	static	vec_t	dot;		// VC 4.2 optimizer bug if not static
+	int		i, j;
+	vec_t	*p1, *p2;
+	vec3_t	mid;
+	winding_t	*f;
+	int		maxpts;
+
+	in = *inout;
+	counts[0] = counts[1] = counts[2] = 0;
+
+// determine sides for each point
+	for (i=0 ; i<in->numpoints ; i++)
+	{
+		dot = DotProduct (in->p[i], normal);
+		dot -= dist;
+		dists[i] = dot;
+		if (dot > epsilon)
+			sides[i] = SIDE_FRONT;
+		else if (dot < -epsilon)
+			sides[i] = SIDE_BACK;
+		else
+		{
+			sides[i] = SIDE_ON;
+		}
+		counts[sides[i]]++;
+	}
+	sides[i] = sides[0];
+	dists[i] = dists[0];
+	
+	if (!counts[0])
+	{
+		FreeWinding (in);
+		*inout = NULL;
+		return;
+	}
+	if (!counts[1])
+		return;		// inout stays the same
+
+	maxpts = in->numpoints+4;	// cant use counts[0]+2 because
+								// of fp grouping errors
+
+	f = AllocWinding (maxpts);
+		
+	for (i=0 ; i<in->numpoints ; i++)
+	{
+		p1 = in->p[i];
+		
+		if (sides[i] == SIDE_ON)
+		{
+			VectorCopy (p1, f->p[f->numpoints]);
+			f->numpoints++;
+			continue;
+		}
+	
+		if (sides[i] == SIDE_FRONT)
+		{
+			VectorCopy (p1, f->p[f->numpoints]);
+			f->numpoints++;
+		}
+
+		if (sides[i+1] == SIDE_ON || sides[i+1] == sides[i])
+			continue;
+			
+	// generate a split point
+		p2 = in->p[(i+1)%in->numpoints];
+		
+		dot = dists[i] / (dists[i]-dists[i+1]);
+		for (j=0 ; j<3 ; j++)
+		{	// avoid round off error when possible
+			if (normal[j] == 1)
+				mid[j] = dist;
+			else if (normal[j] == -1)
+				mid[j] = -dist;
+			else
+				mid[j] = p1[j] + dot*(p2[j]-p1[j]);
+		}
+			
+		VectorCopy (mid, f->p[f->numpoints]);
+		f->numpoints++;
+	}
+	
+	if (f->numpoints > maxpts)
+		Com_Error (ERR_DROP, "ClipWinding: points exceeded estimate");
+	if (f->numpoints > MAX_POINTS_ON_WINDING)
+		Com_Error (ERR_DROP, "ClipWinding: MAX_POINTS_ON_WINDING");
+
+	FreeWinding (in);
+	*inout = f;
+}
+
+
+/*
+=================
+ChopWinding
+
+Returns the fragment of in that is on the front side
+of the cliping plane.  The original is freed.
+=================
+*/
+winding_t	*ChopWinding (winding_t *in, vec3_t normal, vec_t dist)
+{
+	winding_t	*f, *b;
+
+	ClipWindingEpsilon (in, normal, dist, ON_EPSILON, &f, &b);
+	FreeWinding (in);
+	if (b)
+		FreeWinding (b);
+	return f;
+}
+
+
+/*
+=================
+CheckWinding
+
+=================
+*/
+void CheckWinding (winding_t *w)
+{
+	int		i, j;
+	vec_t	*p1, *p2;
+	vec_t	d, edgedist;
+	vec3_t	dir, edgenormal, facenormal;
+	vec_t	area;
+	vec_t	facedist;
+
+	if (w->numpoints < 3)
+		Com_Error (ERR_DROP, "CheckWinding: %i points",w->numpoints);
+	
+	area = WindingArea(w);
+	if (area < 1)
+		Com_Error (ERR_DROP, "CheckWinding: %f area", area);
+
+	WindingPlane (w, facenormal, &facedist);
+	
+	for (i=0 ; i<w->numpoints ; i++)
+	{
+		p1 = w->p[i];
+
+		for (j=0 ; j<3 ; j++)
+			if (p1[j] > MAX_MAP_BOUNDS || p1[j] < -MAX_MAP_BOUNDS)
+				Com_Error (ERR_DROP, "CheckFace: BOGUS_RANGE: %f",p1[j]);
+
+		j = i+1 == w->numpoints ? 0 : i+1;
+		
+	// check the point is on the face plane
+		d = DotProduct (p1, facenormal) - facedist;
+		if (d < -ON_EPSILON || d > ON_EPSILON)
+			Com_Error (ERR_DROP, "CheckWinding: point off plane");
+	
+	// check the edge isnt degenerate
+		p2 = w->p[j];
+		VectorSubtract (p2, p1, dir);
+		
+		if (VectorLength (dir) < ON_EPSILON)
+			Com_Error (ERR_DROP, "CheckWinding: degenerate edge");
+			
+		CrossProduct (facenormal, dir, edgenormal);
+		VectorNormalize2 (edgenormal, edgenormal);
+		edgedist = DotProduct (p1, edgenormal);
+		edgedist += ON_EPSILON;
+		
+	// all other points must be on front side
+		for (j=0 ; j<w->numpoints ; j++)
+		{
+			if (j == i)
+				continue;
+			d = DotProduct (w->p[j], edgenormal);
+			if (d > edgedist)
+				Com_Error (ERR_DROP, "CheckWinding: non-convex");
+		}
+	}
+}
+
+
+/*
+============
+WindingOnPlaneSide
+============
+*/
+int		WindingOnPlaneSide (winding_t *w, vec3_t normal, vec_t dist)
+{
+	qboolean	front, back;
+	int			i;
+	vec_t		d;
+
+	front = qfalse;
+	back = qfalse;
+	for (i=0 ; i<w->numpoints ; i++)
+	{
+		d = DotProduct (w->p[i], normal) - dist;
+		if (d < -ON_EPSILON)
+		{
+			if (front)
+				return SIDE_CROSS;
+			back = qtrue;
+			continue;
+		}
+		if (d > ON_EPSILON)
+		{
+			if (back)
+				return SIDE_CROSS;
+			front = qtrue;
+			continue;
+		}
+	}
+
+	if (back)
+		return SIDE_BACK;
+	if (front)
+		return SIDE_FRONT;
+	return SIDE_ON;
+}
+
+
+/*
+=================
+AddWindingToConvexHull
+
+Both w and *hull are on the same plane
+=================
+*/
+#define	MAX_HULL_POINTS		128
+void	AddWindingToConvexHull( winding_t *w, winding_t **hull, vec3_t normal ) {
+	int			i, j, k;
+	float		*p, *copy;
+	vec3_t		dir;
+	float		d;
+	int			numHullPoints, numNew;
+	vec3_t		hullPoints[MAX_HULL_POINTS];
+	vec3_t		newHullPoints[MAX_HULL_POINTS];
+	vec3_t		hullDirs[MAX_HULL_POINTS];
+	qboolean	hullSide[MAX_HULL_POINTS];
+	qboolean	outside;
+
+	if ( !*hull ) {
+		*hull = CopyWinding( w );
+		return;
+	}
+
+	numHullPoints = (*hull)->numpoints;
+	memcpy( hullPoints, (*hull)->p, numHullPoints * sizeof(vec3_t) );
+
+	for ( i = 0 ; i < w->numpoints ; i++ ) {
+		p = w->p[i];
+
+		// calculate hull side vectors
+		for ( j = 0 ; j < numHullPoints ; j++ ) {
+			k = ( j + 1 ) % numHullPoints;
+
+			VectorSubtract( hullPoints[k], hullPoints[j], dir );
+			VectorNormalize2( dir, dir );
+			CrossProduct( normal, dir, hullDirs[j] );
+		}
+
+		outside = qfalse;
+		for ( j = 0 ; j < numHullPoints ; j++ ) {
+			VectorSubtract( p, hullPoints[j], dir );
+			d = DotProduct( dir, hullDirs[j] );
+			if ( d >= ON_EPSILON ) {
+				outside = qtrue;
+			}
+			if ( d >= -ON_EPSILON ) {
+				hullSide[j] = qtrue;
+			} else {
+				hullSide[j] = qfalse;
+			}
+		}
+
+		// if the point is effectively inside, do nothing
+		if ( !outside ) {
+			continue;
+		}
+
+		// find the back side to front side transition
+		for ( j = 0 ; j < numHullPoints ; j++ ) {
+			if ( !hullSide[ j % numHullPoints ] && hullSide[ (j + 1) % numHullPoints ] ) {
+				break;
+			}
+		}
+		if ( j == numHullPoints ) {
+			continue;
+		}
+
+		// insert the point here
+		VectorCopy( p, newHullPoints[0] );
+		numNew = 1;
+
+		// copy over all points that aren't double fronts
+		j = (j+1)%numHullPoints;
+		for ( k = 0 ; k < numHullPoints ; k++ ) {
+			if ( hullSide[ (j+k) % numHullPoints ] && hullSide[ (j+k+1) % numHullPoints ] ) {
+				continue;
+			}
+			copy = hullPoints[ (j+k+1) % numHullPoints ];
+			VectorCopy( copy, newHullPoints[numNew] );
+			numNew++;
+		}
+
+		numHullPoints = numNew;
+		memcpy( hullPoints, newHullPoints, numHullPoints * sizeof(vec3_t) );
+	}
+
+	FreeWinding( *hull );
+	w = AllocWinding( numHullPoints );
+	w->numpoints = numHullPoints;
+	*hull = w;
+	memcpy( w->p, hullPoints, numHullPoints * sizeof(vec3_t) );
+}
+
+
diff --git a/code/qcommon/cm_polylib.h b/code/qcommon/cm_polylib.h
new file mode 100644
index 0000000..b1c6979
--- /dev/null
+++ b/code/qcommon/cm_polylib.h
@@ -0,0 +1,51 @@
+
+// this is only used for visualization tools in cm_ debug functions
+
+#ifndef CM_POLYLIB_H
+#define CM_POLYLIB_H
+
+typedef struct
+{
+	int		numpoints;
+	vec3_t	p[4];		// variable sized
+} winding_t;
+
+#define	MAX_POINTS_ON_WINDING	64
+
+#define	SIDE_FRONT	0
+#define	SIDE_BACK	1
+#define	SIDE_ON		2
+#define	SIDE_CROSS	3
+
+#define	CLIP_EPSILON	0.1
+
+#define MAX_MAP_BOUNDS			65535
+
+// you can define on_epsilon in the makefile as tighter
+#ifndef	ON_EPSILON
+#define	ON_EPSILON	0.1f
+#endif
+
+winding_t	*AllocWinding (int points);
+vec_t	WindingArea (winding_t *w);
+void	WindingCenter (winding_t *w, vec3_t center);
+void	ClipWindingEpsilon (winding_t *in, vec3_t normal, vec_t dist, 
+				vec_t epsilon, winding_t **front, winding_t **back);
+winding_t	*ChopWinding (winding_t *in, vec3_t normal, vec_t dist);
+winding_t	*CopyWinding (winding_t *w);
+winding_t	*ReverseWinding (winding_t *w);
+winding_t	*BaseWindingForPlane (vec3_t normal, vec_t dist);
+void	CheckWinding (winding_t *w);
+void	WindingPlane (winding_t *w, vec3_t normal, vec_t *dist);
+void	RemoveColinearPoints (winding_t *w);
+int		WindingOnPlaneSide (winding_t *w, vec3_t normal, vec_t dist);
+void	FreeWinding (winding_t *w);
+void	WindingBounds (winding_t *w, vec3_t mins, vec3_t maxs);
+
+void	AddWindingToConvexHull( winding_t *w, winding_t **hull, vec3_t normal );
+
+void	ChopWindingInPlace (winding_t **w, vec3_t normal, vec_t dist, vec_t epsilon);
+// frees the original if clipped
+
+void pw(winding_t *w);
+#endif
diff --git a/code/qcommon/cm_public.h b/code/qcommon/cm_public.h
new file mode 100644
index 0000000..1ab6b97
--- /dev/null
+++ b/code/qcommon/cm_public.h
@@ -0,0 +1,72 @@
+#ifndef __CM_PUBLIC_H__
+#define __CM_PUBLIC_H__
+
+#include "qfiles.h"
+
+qboolean CM_DeleteCachedMap(qboolean bGuaranteedOkToDelete);
+#ifdef _XBOX
+void		CM_LoadMap( const char *name, qboolean clientload, int *checksum);
+#else
+void		CM_LoadMap( const char *name, qboolean clientload, int *checksum, qboolean subBSP);
+#endif
+void		CM_ClearMap( void );
+int			CM_TotalMapContents();
+
+clipHandle_t CM_InlineModel( int index );		// 0 = world, 1 + are bmodels
+clipHandle_t CM_TempBoxModel( const vec3_t mins, const vec3_t maxs );//, const int contents );
+
+int		CM_ModelContents( clipHandle_t model, int subBSPIndex );
+
+
+int			CM_NumClusters (void);
+int			CM_NumInlineModels( void );
+char		*CM_EntityString (void);
+char		*CM_SubBSPEntityString (int index);
+int			CM_LoadSubBSP(const char *name, qboolean clientload);
+int			CM_FindSubBSP(int modelIndex);
+
+// returns an ORed contents mask
+int			CM_PointContents( const vec3_t p, clipHandle_t model );
+int			CM_TransformedPointContents( const vec3_t p, clipHandle_t model, const vec3_t origin, const vec3_t angles );
+
+void		CM_BoxTrace ( trace_t *results, const vec3_t start, const vec3_t end,
+						  const vec3_t mins, const vec3_t maxs,
+						  clipHandle_t model, int brushmask);
+void		CM_TransformedBoxTrace( trace_t *results, const vec3_t start, const vec3_t end,
+						  const vec3_t mins, const vec3_t maxs,
+						  clipHandle_t model, int brushmask,
+						  const vec3_t origin, const vec3_t angles);
+
+#ifdef _XBOX
+const byte	*CM_ClusterPVS (int cluster);
+#else
+byte		*CM_ClusterPVS (int cluster);
+#endif
+
+int			CM_PointLeafnum( const vec3_t p );
+
+// only returns non-solid leafs
+// overflow if return listsize and if *lastLeaf != list[listsize-1]
+int			CM_BoxLeafnums( const vec3_t mins, const vec3_t maxs, int *boxList,
+		 					int listsize, int *lastLeaf );
+
+int			CM_LeafCluster (int leafnum);
+int			CM_LeafArea (int leafnum);
+
+void		CM_AdjustAreaPortalState( int area1, int area2, qboolean open );
+qboolean	CM_AreasConnected( int area1, int area2 );
+
+int			CM_WriteAreaBits( byte *buffer, int area );
+
+//for savegames
+void		CM_WritePortalState ();
+void		CM_ReadPortalState ();
+
+// cm_marks.c
+int	CM_MarkFragments( int numPoints, const vec3_t *points, const vec3_t projection,
+				   int maxPoints, vec3_t pointBuffer, int maxFragments, markFragment_t *fragmentBuffer );
+
+// cm_patch.c
+void CM_DrawDebugSurface( void (*drawPoly)(int color, int numPoints, float *points) );
+
+#endif //__CM_PUBLIC_H__
diff --git a/code/qcommon/cm_randomterrain.cpp b/code/qcommon/cm_randomterrain.cpp
new file mode 100644
index 0000000..2e2538a
--- /dev/null
+++ b/code/qcommon/cm_randomterrain.cpp
@@ -0,0 +1,1086 @@
+#include "../server/exe_headers.h"
+
+#include "cm_local.h"
+#include "cm_patch.h"
+#include "cm_landscape.h"
+#include "../game/genericparser2.h"
+#include "cm_randomterrain.h"
+
+
+#define NOISE_SIZE			256
+#define NOISE_MASK			(NOISE_SIZE - 1)
+
+static float					noiseTable[NOISE_SIZE];
+static int						noisePerm[NOISE_SIZE];
+
+static void CM_NoiseInit( CCMLandScape *landscape )
+{
+	int		i;
+
+	for ( i = 0; i < NOISE_SIZE; i++ )
+	{
+		noiseTable[i] = landscape->flrand(-1.0f, 1.0f);
+		noisePerm[i] = (byte)landscape->irand(0, 255);
+	}
+}
+
+#define VAL( a ) noisePerm[ ( a ) & ( NOISE_MASK )]
+#define INDEX( x, y, z, t ) VAL( x + VAL( y + VAL( z + VAL( t ) ) ) )
+
+#define LERP( a, b, w ) ( a * ( 1.0f - w ) + b * w )
+
+static float GetNoiseValue( int x, int y, int z, int t )
+{
+	int index = INDEX( ( int ) x, ( int ) y, ( int ) z, ( int ) t );
+
+	return noiseTable[index];
+}
+
+#if 0
+static float GetNoiseTime( int t )
+{
+	int index = VAL( t );
+
+	return (1 + noiseTable[index]);
+}
+#endif
+
+static float CM_NoiseGet4f( float x, float y, float z, float t )
+{
+	int i;
+	int ix, iy, iz, it;
+	float fx, fy, fz, ft;
+	float front[4];
+	float back[4];
+	float fvalue, bvalue, value[2], finalvalue;
+
+	ix = ( int ) floor( x );
+	fx = x - ix;
+	iy = ( int ) floor( y );
+	fy = y - iy;
+	iz = ( int ) floor( z );
+	fz = z - iz;
+	it = ( int ) floor( t );
+	ft = t - it;
+
+	for ( i = 0; i < 2; i++ )
+	{
+		front[0] = GetNoiseValue( ix, iy, iz, it + i );
+		front[1] = GetNoiseValue( ix+1, iy, iz, it + i );
+		front[2] = GetNoiseValue( ix, iy+1, iz, it + i );
+		front[3] = GetNoiseValue( ix+1, iy+1, iz, it + i );
+
+		back[0] = GetNoiseValue( ix, iy, iz + 1, it + i );
+		back[1] = GetNoiseValue( ix+1, iy, iz + 1, it + i );
+		back[2] = GetNoiseValue( ix, iy+1, iz + 1, it + i );
+		back[3] = GetNoiseValue( ix+1, iy+1, iz + 1, it + i );
+
+		fvalue = LERP( LERP( front[0], front[1], fx ), LERP( front[2], front[3], fx ), fy );
+		bvalue = LERP( LERP( back[0], back[1], fx ), LERP( back[2], back[3], fx ), fy );
+
+		value[i] = LERP( fvalue, bvalue, fz );
+	}
+
+	finalvalue = LERP( value[0], value[1], ft );
+	return finalvalue;
+}
+
+
+
+
+
+
+
+
+/****** lincrv.c ******/
+/* Ken Shoemake, 1994 */
+
+/* Perform a generic vector unary operation. */
+#define V_Op(vdst,gets,vsrc,n) {register int V_i;\
+    for(V_i=(n)-1;V_i>=0;V_i--) (vdst)[V_i] gets ((vsrc)[V_i]);}
+
+static void lerp(float t, float a0, float a1, vec4_t p0, vec4_t p1, int m, vec4_t p)
+{
+    register float t0=(a1-t)/(a1-a0), t1=1-t0;
+    register int i;
+    for (i=m-1; i>=0; i--) p[i] = t0*p0[i] + t1*p1[i];
+}
+
+/* DialASpline(t,a,p,m,n,work,Cn,interp,val) computes a point val at parameter
+    t on a spline with knot values a and control points p. The curve will have
+    Cn continuity, and if interp is TRUE it will interpolate the control points.
+    Possibilities include Langrange interpolants, Bezier curves, Catmull-Rom
+    interpolating splines, and B-spline curves. Points have m coordinates, and
+    n+1 of them are provided. The work array must have room for n+1 points.
+ */
+static int DialASpline(float t, float a[], vec4_t p[], int m, int n, vec4_t work[],
+                    unsigned int Cn, bool interp, vec4_t val)
+{
+    register int i, j, k, h, lo, hi;
+
+    if (Cn>n-1) Cn = n-1;       /* Anything greater gives one polynomial */
+    for (k=0; t> a[k]; k++);    /* Find enclosing knot interval */
+    for (h=k; t==a[k]; k++);    /* May want to use fewer legs */
+    if (k>n) {k = n; if (h>k) h = k;}
+    h = 1+Cn - (k-h); k--;
+    lo = k-Cn; hi = k+1+Cn;
+
+    if (interp) {               /* Lagrange interpolation steps */
+        int drop=0;
+        if (lo<0) {lo = 0; drop += Cn-k;
+                   if (hi-lo<Cn) {drop += Cn-hi; hi = Cn;}}
+        if (hi>n) {hi = n; drop += k+1+Cn-n;
+                   if (hi-lo<Cn) {drop += lo-(n-Cn); lo = n-Cn;}}
+        for (i=lo; i<=hi; i++) V_Op(work[i],=,p[i],m);
+        for (j=1; j<=Cn; j++) {
+            for (i=lo; i<=hi-j; i++) {
+                lerp(t,a[i],a[i+j],work[i],work[i+1],m,work[i]);
+            }
+        }
+        h = 1+Cn-drop;
+    } else {                    /* Prepare for B-spline steps */
+        if (lo<0) {h += lo; lo = 0;}
+        for (i=lo; i<=lo+h; i++) V_Op(work[i],=,p[i],m);
+        if (h<0) h = 0;
+    }
+    for (j=0; j<h; j++) {
+        int tmp = 1+Cn-j;
+        for (i=h-1; i>=j; i--) {
+            lerp(t,a[lo+i],a[lo+i+tmp],work[lo+i],work[lo+i+1],m,work[lo+i+1]);
+        }
+    }
+    V_Op(val,=,work[lo+h],m);
+    return (k);
+}
+
+#define BIG (1.0e12)
+
+static vec_t Vector2Normalize( vec2_t v ) 
+{
+	float	length, ilength;
+
+	length = v[0]*v[0] + v[1]*v[1];
+	length = sqrt (length);
+
+	if ( length ) 
+	{
+		ilength = 1/length;
+		v[0] *= ilength;
+		v[1] *= ilength;
+	}
+		
+	return length;
+}
+
+CPathInfo::CPathInfo(CCMLandScape *landscape, int numPoints, float bx, float by, float ex, float ey, 
+					 float minWidth, float maxWidth, float depth, float deviation, float breadth,
+					 CPathInfo *Connected, unsigned CreationFlags) :
+	mNumPoints(numPoints),
+	mMinWidth(minWidth),
+	mMaxWidth(maxWidth),
+	mDepth(depth),
+	mDeviation(deviation),
+	mBreadth(breadth)
+{
+	int		i, numConnected, index;
+	float	position, goal, deltaGoal;
+//	float	random, delta;
+	bool	horizontal;
+	float	*point;
+	float	currentWidth;
+	float	currentPosition;
+	vec2_t	testPoint, percPoint, diffPoint, normalizedPath;
+	float	distance, length;
+	
+	CreateCircle();
+
+	numConnected = -1;
+	if (Connected)
+	{	// we are connecting to an existing spline
+		numConnected = Connected->GetNumPoints();
+		if (numConnected >= SPLINE_MERGE_SIZE)
+		{	// plenty of points to choose from
+			mNumPoints += SPLINE_MERGE_SIZE;
+		}
+		else
+		{	// the existing spline doesn't have enough points
+			mNumPoints += numConnected;
+		}
+	}
+
+	mPoints = (vec4_t *)malloc(sizeof(vec4_t) * mNumPoints);
+	mWork = (vec4_t *)malloc(sizeof(vec4_t) * (mNumPoints+1));
+	mWeights = (vec_t *)malloc(sizeof(vec_t) * (mNumPoints+1));
+
+	length = sqrt((ex-bx)*(ex-bx) + (ey-by)*(ey-by));
+	if (fabs(ex - bx) >= fabs(ey - by))
+	{	// this appears to be a horizontal path
+		mInc = 1.0 / fabs(ex - bx);
+		horizontal = true;
+		position = by;
+		goal = ey;
+		deltaGoal = (ey-by) / (numPoints-1);
+	}
+	else
+	{	// this appears to be a vertical path
+		mInc = 1.0 / fabs(ey - by);
+		horizontal = false;
+		position = bx;
+		goal = ex;
+		deltaGoal = (ex-bx) / (numPoints-1);
+	}
+	normalizedPath[0] = (ex-bx);
+	normalizedPath[1] = (ey-by);
+	Vector2Normalize(normalizedPath);
+	// approx calculate how much we need to iterate through the spline to hit every point
+	mInc /= 16;
+
+	currentWidth = landscape->flrand(minWidth, maxWidth);
+	currentPosition = 0.0;
+
+	for(i=0;i<mNumPoints;i++)
+	{
+		// weights are evenly distributed
+		mWeights[i] = (float)i / (mNumPoints-1);
+
+		if (i < numConnected && i < SPLINE_MERGE_SIZE)
+		{	// we are connecting to an existing spline, so copy over the first few points
+			if (CreationFlags & PATH_CREATION_CONNECT_FRONT)
+			{	// copy from the front
+				index = i;
+			}
+			else
+			{	// copy from the end
+				index = numConnected-SPLINE_MERGE_SIZE+i;
+			}
+			point = Connected->GetPoint(index);
+			mPoints[i][0] = point[0];
+			mPoints[i][1] = point[1];
+			mPoints[i][3] = point[3];
+		}
+		else
+		{
+			if (horizontal)
+			{	// we appear to be going horizontal, so spread the randomness across the vertical
+				mPoints[i][0] = ((ex - bx) * currentPosition) + bx;
+				mPoints[i][1] = position;
+			}
+			else
+			{	// we appear to be going vertical, so spread the randomness across the horizontal
+				mPoints[i][0] = position;
+				mPoints[i][1] = ((ey - by) * currentPosition) + by;
+			}
+			currentPosition += 1.0 / (numPoints-1);
+
+			// set the width of the spline
+			mPoints[i][3] = currentWidth;
+			currentWidth += landscape->flrand(-0.1f, 0.1f);
+			if (currentWidth < minWidth)
+			{
+				currentWidth = minWidth;
+			}
+			else if (currentWidth > maxWidth)
+			{
+				currentWidth = maxWidth;
+			}
+
+			// see how far we are from the goal
+/*			delta = (goal - position) * currentPosition;
+			// calculate the randomness we are allowed at this place
+			random = landscape->flrand(-mDeviation/1.0, mDeviation/1.0) * (1.0 - currentPosition);
+			position += delta + random;*/
+
+			if (i == mNumPoints-2)
+			{	// -2 because we are calculating for the next point
+				position = goal;
+			}
+			else
+			{
+				if (i == 0)
+				{
+					position += deltaGoal + landscape->flrand(-mDeviation/10.0, mDeviation/10.0);
+				}
+				else
+				{
+					position += deltaGoal + landscape->flrand(-mDeviation*1.5, mDeviation*1.5);
+				}
+			}
+
+
+			if (position > 0.9)
+			{	// too far over, so move back a bit
+				position = 0.9 - landscape->flrand(0.02f, 0.1f);
+			}
+			if (position < 0.1)
+			{	// too near, so move bakc a bit
+				position = 0.1 + landscape->flrand(0.02f, 0.1f);
+			}
+
+			// check our deviation from the straight line to the end
+			if (horizontal)
+			{
+				testPoint[0] = ((ex - bx) * currentPosition) + bx;
+				testPoint[1] = position;
+			}
+			else
+			{
+				testPoint[0] = position;
+				testPoint[1] = ((ey - by) * currentPosition) + by;
+			}
+			// dot product of the normal of the path to the point we are at
+			distance = ((testPoint[0]-bx)*normalizedPath[0]) + ((testPoint[1]-by)*normalizedPath[1]);
+			// find the perpendicular place that is intersected by the point and the path
+			percPoint[0] = (distance * normalizedPath[0]) + bx;
+			percPoint[1] = (distance * normalizedPath[1]) + by;
+			// calculate the difference between the perpendicular point and the test point
+			diffPoint[0] = testPoint[0] - percPoint[0];
+			diffPoint[1] = testPoint[1] - percPoint[1];
+			// calculate the distance
+			distance = sqrt((diffPoint[0]*diffPoint[0]) + (diffPoint[1]*diffPoint[1]));
+			if (distance > mDeviation)
+			{	// we are beyond our allowed deviation, so head back
+				if (horizontal)
+				{
+					position = (ey-by) * currentPosition + by;
+				}
+				else
+				{
+					position = (ex-bx) * currentPosition + bx;
+				}
+				position += landscape->flrand(-mDeviation/2.0, mDeviation/2.0);
+			}
+		}
+	}
+	mWeights[mNumPoints] = (float)BIG;
+}
+
+CPathInfo::~CPathInfo(void)
+{
+	free(mWeights);
+	free(mWork);
+	free(mPoints);
+}
+
+void CPathInfo::CreateCircle(void)
+{
+	int		x, y;
+	float	r, d;
+
+	memset(mCircleStamp, 0, sizeof(mCircleStamp));
+	r = CIRCLE_STAMP_SIZE;
+	for(x=0;x<CIRCLE_STAMP_SIZE;x++)
+	{
+		for(y=0;y<CIRCLE_STAMP_SIZE;y++)
+		{
+			d = sqrt((float)(x*x + y*y));
+			if (d > r)
+			{
+				mCircleStamp[y][x] = 255;
+			}
+			else
+			{
+				mCircleStamp[y][x] = pow(sin((float)(d / r * M_PI / 2)), mBreadth) * 255;
+			}
+		}
+	}
+}
+
+void CPathInfo::Stamp(int x, int y, int size, int depth, unsigned char *Data, int DataWidth, int DataHeight)
+{
+//	int xPos;
+//	float yPos;
+	int		dx, dy, fx, fy;
+	float	offset;
+	byte	value;
+	byte	invDepth;
+
+	offset = (float)(CIRCLE_STAMP_SIZE-1) / size;
+	invDepth = 255-depth;
+
+	for(dx = -size; dx <= size; dx++)
+	{
+		for ( dy = -size; dy <= size; dy ++ )
+		{
+			float d;
+
+			d = dx * dx + dy * dy ;
+			if ( d > size * size )
+			{
+				continue;
+			}
+
+			fx = x + dx;
+			if (fx < 2 || fx > DataWidth-2)
+			{
+				continue;
+			}
+			
+			fy = y + dy;
+			if (fy < 2 || fy > DataHeight-2)
+			{
+				continue;
+			}
+
+			value = pow ( sin ( (float)(d / (size * size) * M_PI / 2)), mBreadth ) * invDepth + depth;
+			if (value < Data[(fy * DataWidth) + fx])
+			{
+				Data[(fy * DataWidth) + fx] = value;
+			}
+		}
+	}
+/*
+
+		fx = x + dx;
+		if (fx < 2 || fx > DataWidth-2)
+		{
+			continue;
+		}
+		xPos = abs((int)(dx*offset));
+		yPos = offset*size + offset;
+		for(dy = -size; dy < 0; dy++)
+		{
+			yPos -= offset;
+			fy = y + dy;
+			if (fy < 2 || fy > DataHeight-2)
+			{
+				continue;
+			}
+
+			value = (invDepth * mCircleStamp[(int)yPos][xPos] / 256) + depth;
+			if (value < Data[(fy * DataWidth) + fx])
+			{
+				Data[(fy * DataWidth) + fx] = value;
+			}
+		}
+
+		yPos = -offset;
+		for(; dy <= size; dy++)
+		{
+			yPos += offset;
+
+			fy = y + dy;
+			if (fy < 2 || fy > DataHeight-2)
+			{
+				continue;
+			}
+
+			value = (invDepth * mCircleStamp[(int)yPos][xPos] / 256) + depth;
+			if (value < Data[(fy * DataWidth) + fx])
+			{
+				Data[(fy * DataWidth) + fx] = value;
+			}
+		}
+	}
+*/
+}
+
+void CPathInfo::GetInfo(float PercentInto, vec4_t Coord, vec4_t Vector)
+{
+	vec4_t	before, after;
+	float	testPercent;
+
+	DialASpline(PercentInto, mWeights, mPoints, sizeof(vec4_t) / sizeof(vec_t), mNumPoints-1, mWork, 2, true, Coord);
+
+	testPercent = PercentInto - 0.01;
+	if (testPercent < 0)
+	{
+		testPercent = 0;
+	}
+	DialASpline(testPercent, mWeights, mPoints, sizeof(vec4_t) / sizeof(vec_t), mNumPoints-1, mWork, 2, true, before);
+
+	testPercent = PercentInto + 0.01;
+	if (testPercent > 1.0)
+	{
+		testPercent = 1.0;
+	}
+	DialASpline(testPercent, mWeights, mPoints, sizeof(vec4_t) / sizeof(vec_t), mNumPoints-1, mWork, 2, true, after);
+
+	Coord[2] = mDepth;
+
+	Vector[0] = after[0] - before[0];
+	Vector[1] = after[1] - before[1];
+}
+
+void CPathInfo::DrawPath(unsigned char *Data, int DataWidth, int DataHeight )
+{
+	float			t;
+	vec4_t			val, vector;//, perp;
+	int				size;
+	float			inc;
+	int				x, y, lastX, lastY;
+	float			depth;
+
+	inc = mInc / DataWidth;
+
+	lastX = lastY = -999;
+
+	for (t=0.0; t<=1.0; t+=inc) 
+	{
+		GetInfo(t, val, vector);
+
+/*		perp[0] = -vector[1];
+		perp[1] = vector[0];
+
+		if (fabs(perp[0]) > fabs(perp[1]))
+		{
+			perp[1] /= fabs(perp[0]);
+			perp[0] /= fabs(perp[0]);
+		}
+		else
+		{
+			perp[0] /= fabs(perp[1]);
+			perp[1] /= fabs(perp[1]);
+		}
+*/
+		x = val[0] * DataWidth;
+		y = val[1] * DataHeight;
+
+		if (x == lastX && y == lastY)
+		{
+			continue;
+		}
+
+		lastX = x;
+		lastY = y;
+
+		size = val[3] * DataWidth;
+
+		depth = mDepth * 255.0f;
+
+		Stamp(x, y, size, (int)depth, Data, DataWidth, DataHeight);
+	}
+}
+
+
+
+
+
+
+
+CRandomTerrain::CRandomTerrain(void)
+{
+	memset(mPaths, 0, sizeof(mPaths));
+}
+
+CRandomTerrain::~CRandomTerrain(void)
+{
+	Shutdown();
+}
+
+void CRandomTerrain::Init(CCMLandScape *landscape, byte *grid, int width, int height)
+{
+	Shutdown();
+	mLandScape = landscape;
+	mWidth = width;
+	mHeight = height;
+	mArea = mWidth * mHeight;
+	mBorder = (width + height) >> 6;
+	mGrid = grid;
+}
+
+void CRandomTerrain::ClearPaths(void)
+{
+	int	i;
+
+	for(i=0;i<MAX_RANDOM_PATHS;i++)
+	{
+		if (mPaths[i])
+		{
+			delete mPaths[i];
+			mPaths[i] = 0;
+		}
+	}
+
+	memset(mPaths, 0, sizeof(mPaths));
+}
+
+void CRandomTerrain::Shutdown(void)
+{
+	ClearPaths ( );
+}
+
+bool CRandomTerrain::CreatePath(int PathID, int ConnectedID, unsigned CreationFlags, int numPoints, 
+					float bx, float by, float ex, float ey, 
+					float minWidth, float maxWidth, float depth, float deviation, float breadth )
+{
+	CPathInfo	*connected = 0;
+
+	if (PathID < 0 || PathID >= MAX_RANDOM_PATHS || mPaths[PathID])
+	{
+		return false;
+	}
+
+	if (ConnectedID >= 0 && ConnectedID < MAX_RANDOM_PATHS)
+	{
+		connected = mPaths[ConnectedID];
+	}
+
+	mPaths[PathID] = new CPathInfo(mLandScape, numPoints, bx, by, ex, ey, 
+		minWidth, maxWidth, depth, deviation, breadth,
+		connected, CreationFlags );
+
+	return true;
+}
+
+bool CRandomTerrain::GetPathInfo(int PathNum, float PercentInto, vec4_t Coord, vec4_t Vector)
+{
+	if (PathNum < 0 || PathNum >= MAX_RANDOM_PATHS || !mPaths[PathNum])
+	{
+		return false;
+	}
+
+	mPaths[PathNum]->GetInfo(PercentInto, Coord, Vector);
+
+	return true;
+}
+
+void CRandomTerrain::ParseGenerate(const char *GenerateFile)
+{
+}
+
+void CRandomTerrain::Smooth ( void )
+{
+	// Scale down to 1/4 size then back up to smooth out the terrain
+	byte	*temp;
+	int		x, y, o;
+
+	temp = mLandScape->GetFlattenMap ( );
+
+	// Copy over anything in the flatten map
+	if (temp) 
+	{
+		for ( o = 0; o < mHeight * mWidth; o++)
+		{
+			if ( temp[o] > 0 )
+			{
+				mGrid[o] = (byte)temp[o] & 0x7F;
+			}
+		}
+	}
+	temp = (byte *)Z_Malloc(mWidth * mHeight, TAG_TEMP_WORKSPACE, qfalse);
+#if 1
+	unsigned	total, count;
+	for(x=1;x<mWidth-1;x++)
+	{
+		for(y=1;y<mHeight-1;y++)
+		{
+			total = 0;
+			count = 2;
+
+			// Left
+			total += mGrid[((y)*mWidth)+(x-1)];
+			count++;
+
+			// Right
+			total += mGrid[((y)*mWidth)+(x+1)];
+			count++;
+
+			// Up
+			total += mGrid[((y-1)*mWidth)+(x)];
+			count++;
+
+			// Down
+			total += mGrid[((y+1)*mWidth)+(x)];
+			count++;
+
+			// Up-Left
+			total += mGrid[((y-1)*mWidth)+(x-1)];
+			count++;
+
+			// Down-Left
+			total += mGrid[((y+1)*mWidth)+(x-1)];
+			count++;
+
+			// Up-Right
+			total += mGrid[((y-1)*mWidth)+(x+1)];
+			count++;
+
+			// Down-Right
+			total += mGrid[((y+1)*mWidth)+(x+1)];
+			count++;
+
+			total += (unsigned)mGrid[((y)*mWidth)+(x)] * 2;
+
+			temp[((y)*mWidth)+(x)] = total / count;
+		}
+	}
+
+	memcpy(mGrid, temp, mWidth * mHeight);
+
+#else
+	float	smoothKernel[FILTER_SIZE][FILTER_SIZE];
+	int		xx, yy, dx, dy;
+	float	total, num;
+
+	R_Resample(mGrid, mWidth, mHeight, temp, mWidth >> 1, mHeight >> 1, 1);
+	R_Resample(temp, mWidth >> 1, mHeight >> 1, mGrid, mWidth, mHeight, 1);
+
+	// now lets filter it.
+	memcpy(temp, mGrid, mWidth * mHeight);
+
+	for (dy = -KERNEL_SIZE; dy <= KERNEL_SIZE; dy++)
+	{
+		for (dx = -KERNEL_SIZE; dx <= KERNEL_SIZE; dx++)
+		{
+			smoothKernel[dy + KERNEL_SIZE][dx + KERNEL_SIZE] =
+				1.0f / (1.0f + fabs(float(dx) * float(dx) * float(dx)) + fabs(float(dy) * float(dy) * float(dy)));
+		}
+	}
+
+	for (y = 0; y < mHeight; y++)
+	{
+		for (x = 0; x < mWidth; x++)
+		{
+			total = 0.0f;
+			num = 0.0f;
+			for (dy = -KERNEL_SIZE; dy <= KERNEL_SIZE; dy++)
+			{
+				for (dx = -KERNEL_SIZE; dx <= KERNEL_SIZE; dx++)
+				{
+					xx = x + dx;
+					if (xx >= 0 && xx < mWidth)
+					{
+						yy = y + dy;
+						if (yy >= 0 && yy < mHeight)
+						{
+							total += smoothKernel[dy + KERNEL_SIZE][dx + KERNEL_SIZE] * (float)temp[yy * mWidth + xx];
+							num += smoothKernel[dy + KERNEL_SIZE][dx + KERNEL_SIZE];
+						}
+					}
+				}
+			}
+			total /= num;
+			mGrid[y * mWidth + x] = (byte)Com_Clamp(0, 255, (int)Round(total));
+		}
+	}
+#endif
+
+	Z_Free(temp);
+
+/* Uncomment to see the symmetry line on the map
+
+	for ( x = 0; x < mWidth; x ++ )
+	{
+		mGrid[x * mWidth + x] = 255;
+	}
+*/
+}
+
+void CRandomTerrain::Generate(int symmetric)
+{
+	int	i,j;
+
+	// Clear out all existing data
+	memset(mGrid, 255, mArea);
+
+	// make landscape a little bumpy
+	float t1 = mLandScape->flrand(0, 2);
+	float t2 = mLandScape->flrand(0, 2);
+	float t3 = mLandScape->flrand(0, 2);
+
+	CM_NoiseInit(mLandScape);
+
+	int x, y;
+	for (y = 0; y < mHeight; y++)
+		for (x = 0; x < mWidth; x++)
+		{
+			i = x + y*mWidth;
+			byte val = (byte)Com_Clamp(0, 255, (int)(220 + (CM_NoiseGet4f( x*0.25, y*0.25, 0, t3 ) * 20)) + (CM_NoiseGet4f( x*0.5, y*0.5, 0, t2 ) * 15));
+			mGrid[i] = val;
+		}
+
+	for ( i = 0; mPaths[i] != 0; i ++ )
+	{
+		mPaths[i]->DrawPath(mGrid, mWidth, mHeight);
+	}
+
+	for (y = 0; y < mHeight; y++)
+		for (x = 0; x < mWidth; x++)
+		{
+			i = x + y*mWidth;
+			byte val = (byte)Com_Clamp(0, 255, (int)(mGrid[i] + (CM_NoiseGet4f( x, y, 0, t1 ) * 5))); 
+			mGrid[i] = val;
+		}
+
+	// if symmetric, do this now
+	if (symmetric)
+	{
+		assert (mWidth == mHeight); // must be square
+
+		for (y = 0; y < mHeight; y++)
+			for (x = 0; x < (mWidth-y); x++)
+			{
+				i = x + y*mWidth;
+				j = (mWidth-1 - x) + (mHeight-1 - y)*mWidth;
+				byte val = mGrid[i] < mGrid[j] ? mGrid[i] : mGrid[j];
+				mGrid[i] = mGrid[j] = val;
+			}
+	}
+}
+
+
+
+
+typedef enum
+{
+	RMG_CP_NONE = -1,
+	RMG_CP_CONSONANT,
+	RMG_CP_COMPLEX_CONSONANT,
+	RMG_CP_VOWEL,
+	RMG_CP_COMPLEX_VOWEL,
+	RMG_CP_ENDING,
+
+	RMG_CP_NUM_PIECES,
+} ECPType;
+
+typedef struct SCharacterPiece
+{
+	char	*mPiece;
+	int		mCommonality;
+} TCharacterPiece;
+
+static TCharacterPiece	Consonants[] = 
+{
+	{	"b", 6 },
+	{	"c", 8 },
+	{	"d", 6 },
+	{	"f", 5 },
+	{	"g", 4 },
+	{	"h", 5 },
+	{	"j", 2 },
+	{	"k", 4 },
+	{	"l", 4 },
+	{	"m", 7 },
+	{	"n", 7 },
+	{	"r", 6 },
+	{	"s", 10 },
+	{	"t", 10 },
+	{	"v", 1 },
+	{	"w", 2 },
+	{	"x", 1 },
+	{	"z", 1 },
+
+	{	0, 0 }
+};
+
+static TCharacterPiece	ComplexConsonants[] = 
+{
+	{	"st", 10 },
+	{	"ck", 10 },
+	{	"ss", 10 },
+	{	"tt", 7 },
+	{	"ll", 8 },
+	{	"nd", 10 },
+	{	"rn", 6 },
+	{	"nc", 6 },
+	{	"mp", 4 },
+	{	"sc", 10 }, 
+	{	"sl", 10 }, 
+	{	"tch", 6 }, 
+	{	"th", 4 }, 
+	{	"rn", 5 }, 
+	{	"cl", 10 }, 
+	{	"sp", 10 }, 
+	{	"st", 10 }, 
+	{	"fl", 4 }, 
+	{	"sh", 7 }, 
+	{	"ng", 4 }, 
+//	{	"" },
+
+	{	0, 0 }
+};
+
+static TCharacterPiece	Vowels[] = 
+{
+	{	"a", 10 },
+	{	"e", 10 },
+	{	"i", 10 },
+	{	"o", 10 },
+	{	"u", 2 },
+//	{	"" },
+
+	{	0, 0 }
+};
+
+static TCharacterPiece	ComplexVowels[] = 
+{
+	{	"ea", 10  },
+	{	"ue", 3 },
+	{	"oi", 10 },
+	{	"ai", 8 },
+	{	"oo", 10 },
+	{	"io", 10 },
+	{	"oe", 10 },
+	{	"au", 3 },
+	{	"ee", 7 },
+	{	"ei", 7 },
+	{	"ou", 7 }, 
+	{	"ia", 4 }, 
+//	{	"" },
+
+	{	0, 0 }
+};
+
+static TCharacterPiece	Endings[] = 
+{
+	{	"ing", 10 },
+	{	"ed", 10 },
+	{	"ute", 10 },
+	{	"ance", 10 },
+	{	"ey", 10 },
+	{	"ation", 10 },
+	{	"ous", 10 },
+	{	"ent", 10 },
+	{	"ate", 10 },
+	{	"ible", 10 },
+	{	"age", 10 },
+	{	"ity", 10 },
+	{	"ist", 10 },
+	{	"ism", 10 },
+	{	"ime", 10 },
+	{	"ic", 10 },
+	{	"ant", 10 },
+	{	"etry", 10 },
+	{	"ious", 10 },
+	{	"ative", 10 },
+	{	"er", 10 },
+	{	"ize", 10 }, 
+	{	"able", 10 }, 
+	{	"itude", 10 }, 
+//	{	"" },
+
+	{	0, 0 }
+};
+
+static void FindPiece(ECPType type, char *&pos)
+{
+	TCharacterPiece		*search, *start;
+	int					count = 0;
+
+	switch(type)
+	{
+		case RMG_CP_CONSONANT:
+		default:
+			start = Consonants;
+			break;
+
+		case RMG_CP_COMPLEX_CONSONANT:
+			start = ComplexConsonants;
+			break;
+
+		case RMG_CP_VOWEL:
+			start = Vowels;
+			break;
+
+		case RMG_CP_COMPLEX_VOWEL:
+			start = ComplexVowels;
+			break;
+
+		case RMG_CP_ENDING:
+			start = Endings;
+			break;
+	}
+
+	search = start;
+	while(search->mPiece)
+	{
+		count += search->mCommonality;
+		search++;
+	}
+
+	count = Q_irand(0, count-1);
+	search = start;
+	while(count > search->mCommonality)
+	{
+		count -= search->mCommonality;
+		search++;
+	}
+
+	strcpy(pos, search->mPiece);
+	pos += strlen(search->mPiece);
+}
+
+unsigned RMG_CreateSeed(char *TextSeed)
+{
+	int			Length;
+	char		Ending[256], *pos;
+	int			ComplexVowelChance, ComplexConsonantChance;
+	ECPType		LookingFor;
+	unsigned	SeedValue = 0, high;
+
+	Length = Q_irand(4, 9);
+
+	if (Q_irand(0, 100) < 20)
+	{ 
+		LookingFor = RMG_CP_VOWEL;
+	}
+	else
+	{
+		LookingFor = RMG_CP_CONSONANT;
+	}
+
+	Ending[0] = 0;
+
+	if (Q_irand(0, 100) < 55)
+	{
+		pos = Ending;
+		FindPiece(RMG_CP_ENDING, pos);
+		Length -= (pos - Ending);
+	}
+
+	pos = TextSeed;
+	*pos = 0;
+
+	ComplexVowelChance = -1;
+	ComplexConsonantChance	= -1;
+
+	while((pos - TextSeed) < Length || LookingFor == RMG_CP_CONSONANT)
+	{
+		if (LookingFor == RMG_CP_VOWEL)
+		{
+			if (Q_irand(0, 100) < ComplexVowelChance)
+			{
+				ComplexVowelChance = -1;
+				LookingFor = RMG_CP_COMPLEX_VOWEL;
+			}
+			else
+			{
+				ComplexVowelChance += 10;
+			}
+
+			FindPiece(LookingFor, pos);
+			LookingFor = RMG_CP_CONSONANT;
+		}
+		else
+		{
+			if (Q_irand(0, 100) < ComplexConsonantChance)
+			{
+				ComplexConsonantChance = -1;
+				LookingFor = RMG_CP_COMPLEX_CONSONANT;
+			}
+			else
+			{
+				ComplexConsonantChance += 45;
+			}
+
+			FindPiece(LookingFor, pos);
+			LookingFor = RMG_CP_VOWEL;
+		}
+	}
+
+	if (Ending[0])
+	{
+		strcpy(pos, Ending);
+	}
+
+	pos = TextSeed;
+	while(*pos)
+	{
+		high = SeedValue >> 28;
+		SeedValue ^= (SeedValue << 4) + ((*pos)-'a');
+		SeedValue ^= high;
+		pos++;
+	}
+
+	return SeedValue;
+}
diff --git a/code/qcommon/cm_randomterrain.h b/code/qcommon/cm_randomterrain.h
new file mode 100644
index 0000000..4f97432
--- /dev/null
+++ b/code/qcommon/cm_randomterrain.h
@@ -0,0 +1,89 @@
+#pragma once
+#if !defined(CM_RANDOMTERRAIN_H_INC)
+#define CM_RANDOMTERRAIN_H_INC
+
+#ifdef DEBUG_LINKING
+	#pragma message("...including cm_randomterrain.h")
+#endif
+
+//class CPathInfo;
+
+#define SPLINE_MERGE_SIZE	3
+#define	CIRCLE_STAMP_SIZE	128
+
+
+class CPathInfo
+{
+private:
+	vec4_t		*mPoints, *mWork;
+	vec_t		*mWeights;
+	int			mNumPoints;
+	float		mMinWidth, mMaxWidth;
+	float		mInc;
+	float		mDepth, mBreadth;
+	float		mDeviation;
+	byte		mCircleStamp[CIRCLE_STAMP_SIZE][CIRCLE_STAMP_SIZE];
+
+	void		CreateCircle(void);
+	void		Stamp(int x, int y, int size, int depth, unsigned char *Data, int DataWidth, int DataHeight);
+
+public:
+	CPathInfo(CCMLandScape *landscape, int numPoints, float bx, float by, float ex, float ey, 
+		float minWidth, float maxWidth, float depth, float deviation, float breadth,
+		CPathInfo *Connected, unsigned CreationFlags);
+	~CPathInfo(void);
+
+	int		GetNumPoints(void) { return mNumPoints; }
+	float	*GetPoint(int index) { return mPoints[index]; }
+	float	GetWidth(int index) { return mPoints[index][3]; }
+
+	void	GetInfo(float PercentInto, vec4_t Coord, vec4_t Vector);
+	void	DrawPath(unsigned char *Data, int DataWidth, int DataHeight );
+};
+
+
+const int			MAX_RANDOM_PATHS	= 30;
+
+// Path Creation Flags
+#define		PATH_CREATION_CONNECT_FRONT		0x00000001
+
+
+
+class CRandomTerrain
+{
+private:
+
+	class CCMLandScape	*mLandScape;
+	int					mWidth;
+	int					mHeight;
+	int					mArea;
+	int					mBorder;
+	byte				*mGrid;
+	CPathInfo			*mPaths[MAX_RANDOM_PATHS];
+
+public:
+	CRandomTerrain(void);
+	~CRandomTerrain(void);
+
+	CCMLandScape		*GetLandScape(void) { return mLandScape; }
+	const vec3pair_t	&GetBounds(void) const { return mLandScape->GetBounds(); }
+	void				rand_seed(int seed) { mLandScape->rand_seed(seed); }
+	int					get_rand_seed(void) { return mLandScape->get_rand_seed();}
+	float				flrand(float min, float max) { return mLandScape->flrand(min, max); }
+	int					irand(int min, int max) { return mLandScape->irand(min, max); }
+
+	void	Init(class CCMLandScape *landscape, byte *data, int width, int height);
+	void	Shutdown(void);
+	bool	CreatePath(int PathID, int ConnectedID, unsigned CreationFlags, int numPoints, 
+						float bx, float by, float ex, float ey, 
+						float minWidth, float maxWidth, float depth, float deviation, float breadth );
+	bool	GetPathInfo(int PathNum, float PercentInto, vec2_t Coord, vec2_t Vector);
+	void	ParseGenerate(const char *GenerateFile);
+	void	Smooth ( void );
+	void	Generate(int symmetric);
+	void	ClearPaths(void);
+};
+
+unsigned RMG_CreateSeed(char *TextSeed);
+
+#endif // CM_RANDOM_H_INC
diff --git a/code/qcommon/cm_shader.cpp b/code/qcommon/cm_shader.cpp
new file mode 100644
index 0000000..7709f90
--- /dev/null
+++ b/code/qcommon/cm_shader.cpp
@@ -0,0 +1,529 @@
+#include "../server/exe_headers.h"
+
+#include "../game/q_shared.h"
+
+#include "cm_local.h"
+#include "memory.h"
+#include "chash.h"
+
+class CCMShaderText
+{
+private:
+	char					mName[MAX_QPATH];
+	class CCMShaderText		*mNext;
+	const char				*mData;
+public:
+	// Constructors
+	CCMShaderText(const char *name, const char *data) { Q_strncpyz(mName, name, MAX_QPATH); mNext = NULL; mData = data; }
+	~CCMShaderText(void) {}
+
+	// Accessors
+	const char *GetName(void) const { return(mName); }
+	class CCMShaderText *GetNext(void) const { return(mNext); }
+	void SetNext(class CCMShaderText *next) { mNext = next; }
+	void Destroy(void) { delete this; }
+
+	const char *GetData(void) const { return(mData); }
+};
+
+char			   		*shaderText = NULL;
+CHash<CCMShaderText>	shaderTextTable;
+CHash<CCMShader>		cmShaderTable;
+
+const char *SkipWhitespace( const char *data, qboolean *hasNewLines );
+
+//rwwFIXMEFIXME: Called at RE_BeginRegistration because Hunk_Clear
+//destroys the memory cmShaderTable is on. This is a temp solution
+//I guess.
+void ShaderTableCleanup()
+{
+	cmShaderTable.clear();
+}
+
+/*
+====================
+CM_CreateShaderTextHash
+=====================
+*/
+void CM_CreateShaderTextHash(void)
+{
+	const char			*p;
+	qboolean			hasNewLines;
+	char				*token;
+	CCMShaderText		*shader;
+
+	p = shaderText;
+	// look for label
+	while (p) 
+	{
+		p = SkipWhitespace(p, &hasNewLines);
+		token = COM_ParseExt( &p, qtrue );
+		if ( !token[0] ) 
+		{
+			break;
+		}
+		shader = new CCMShaderText(token, p);
+		shaderTextTable.insert(shader);
+
+		SkipBracedSection(&p);
+	}
+}
+
+/*
+====================
+CM_LoadShaderFiles
+
+Finds and loads all .shader files, combining them into
+a single large text block that can be scanned for shader names
+=====================
+*/
+#define	MAX_SHADER_FILES	1024
+
+void CM_LoadShaderFiles( void )
+{
+	char	**shaderFiles1;
+	int		numShaders1;
+	char	*buffers[MAX_SHADER_FILES];
+	int		numShaders;
+	int		i;
+	int		sum = 0;
+
+	// scan for shader files
+	shaderFiles1 = FS_ListFiles( "shaders", ".shader", &numShaders1 );
+
+	if ( !shaderFiles1 || !numShaders1 )
+	{
+		Com_Printf( S_COLOR_YELLOW "WARNING: no shader files found\n" );
+		return;
+	}
+
+	numShaders = numShaders1;
+	if ( numShaders > MAX_SHADER_FILES ) 
+	{
+		numShaders = MAX_SHADER_FILES;
+	}
+
+	// load and parse shader files
+	for ( i = 0; i < numShaders1; i++ )
+	{
+		char filename[MAX_QPATH];
+
+		Com_sprintf( filename, sizeof( filename ), "shaders/%s", shaderFiles1[i] );
+		Com_DPrintf( "...loading '%s'\n", filename );
+		FS_ReadFile( filename, (void **)&buffers[i] );
+		if ( !buffers[i] ) 
+		{
+			Com_Error( ERR_DROP, "Couldn't load %s", filename );
+		}
+		sum += COM_Compress( buffers[i] );
+	}
+
+	// build single large buffer
+	shaderText = (char *)Z_Malloc( sum + numShaders * 2, TAG_SHADERTEXT, qtrue);
+
+	// free in reverse order, so the temp files are all dumped
+	for ( i = numShaders - 1; i >= 0 ; i-- ) 
+	{
+		strcat( shaderText, "\n" );
+		strcat( shaderText, buffers[i] );
+		FS_FreeFile( buffers[i] );
+	}
+
+	// free up memory
+	FS_FreeFileList( shaderFiles1 );
+}
+
+/*
+==================
+CM_GetShaderText
+==================
+*/
+
+const char *CM_GetShaderText(const char *key)
+{
+	CCMShaderText	*st;
+
+	st = shaderTextTable[key];
+	if(st)
+	{
+		return(st->GetData());
+	}
+	return(NULL);
+}
+
+/*
+==================
+CM_FreeShaderText
+==================
+*/
+
+void CM_FreeShaderText(void)
+{
+	shaderTextTable.clear();
+	if(shaderText)
+	{
+		Z_Free(shaderText);
+		shaderText = NULL;
+	}
+}
+
+/*
+==================
+CM_LoadShaderText
+
+  Loads in all the .shader files so it can be accessed by the server and the renderer
+  Creates a hash table to quickly access the shader text
+==================
+*/
+
+void CM_LoadShaderText(bool forceReload)
+{
+	if(forceReload)
+	{
+		CM_FreeShaderText();
+	}
+	if(shaderText)
+	{
+		return;
+	}
+	Com_Printf("Loading shader text .....\n");
+	CM_LoadShaderFiles();
+	CM_CreateShaderTextHash();
+
+	Com_Printf("..... %d shader definitions loaded\n", shaderTextTable.count());
+}
+
+/*
+===============
+ParseSurfaceParm
+
+surfaceparm <name>
+===============
+*/
+
+typedef struct 
+{
+	char	*name;
+	int		clearSolid, surfaceFlags, contents;
+} infoParm_t;
+
+infoParm_t	svInfoParms[] =
+{
+	// Game content Flags
+	{"nonsolid", 	~CONTENTS_SOLID,	0, 				0 },						// special hack to clear solid flag
+	{"nonopaque", 	~CONTENTS_OPAQUE,	0, 				0 },						// special hack to clear opaque flag
+	{"lava",		~CONTENTS_SOLID,	0,				CONTENTS_LAVA },			// very damaging
+	{"slime",		~CONTENTS_SOLID,	0,				CONTENTS_SLIME },			// mildly damaging
+	{"water",		~CONTENTS_SOLID,	0,				CONTENTS_WATER },
+	{"fog",			~CONTENTS_SOLID,	0,				CONTENTS_FOG},				// carves surfaces entering
+	{"shotclip",	~CONTENTS_SOLID,	0,				CONTENTS_SHOTCLIP },		/* block shots, but not people */
+	{"playerclip",	~(CONTENTS_SOLID|CONTENTS_OPAQUE),0,CONTENTS_PLAYERCLIP },	   	/* block only the player */ 
+	{"monsterclip",	~(CONTENTS_SOLID|CONTENTS_OPAQUE),0,CONTENTS_MONSTERCLIP },		
+	{"botclip",		~(CONTENTS_SOLID|CONTENTS_OPAQUE),0,CONTENTS_BOTCLIP },		   	/* NPC do not enter */															
+	{"trigger",		~(CONTENTS_SOLID|CONTENTS_OPAQUE),0,CONTENTS_TRIGGER },
+	{"nodrop",		~(CONTENTS_SOLID|CONTENTS_OPAQUE),0,CONTENTS_NODROP },			// don't drop items or leave bodies (death fog, lava, etc)
+	{"terrain",		~(CONTENTS_SOLID|CONTENTS_OPAQUE),0,CONTENTS_TERRAIN },		   	/* use special terrain collsion */										
+	{"ladder",		~(CONTENTS_SOLID|CONTENTS_OPAQUE),0,CONTENTS_LADDER },			// climb up in it like water
+	{"abseil",		~(CONTENTS_SOLID|CONTENTS_OPAQUE),0,CONTENTS_ABSEIL },			// can abseil down this brush
+	{"outside",		~(CONTENTS_SOLID|CONTENTS_OPAQUE),0,CONTENTS_OUTSIDE },			// volume is considered to be in the outside (i.e. not indoors)
+	{"inside",		~(CONTENTS_SOLID|CONTENTS_OPAQUE),0,CONTENTS_INSIDE },			// volume is considered to be inside (i.e. indoors)
+																		
+	{"detail",		-1,					0,				CONTENTS_DETAIL },			// don't include in structural bsp
+	{"trans",		-1,					0,				CONTENTS_TRANSLUCENT },		// surface has an alpha component
+	
+	/* Game surface flags */
+	{"sky",			-1,					SURF_SKY,		0 },					   	/* emit light from an environment map */
+	{"slick",		-1,					SURF_SLICK,		0 },
+
+	{"nodamage",	-1,					SURF_NODAMAGE,	0 },					   	   																	
+	{"noimpact",	-1,					SURF_NOIMPACT,	0 },					   	/* don't make impact explosions or marks */
+	{"nomarks",		-1,					SURF_NOMARKS,	0 },					   	/* don't make impact marks, but still explode */
+	{"nodraw",		-1,					SURF_NODRAW,	0 },					   	/* don't generate a drawsurface (or a lightmap) */
+	{"nosteps",		-1,					SURF_NOSTEPS,	0 },
+	{"nodlight",	-1,					SURF_NODLIGHT,	0 },					   	/* don't ever add dynamic lights */
+	{"metalsteps",	-1,					SURF_METALSTEPS,0 },
+	{"nomiscents",	-1,					SURF_NOMISCENTS,0 },						/* No misc ents on this surface */
+	{"forcefield",	-1,					SURF_FORCEFIELD,0 },
+	{"forcesight",	-1,					SURF_FORCESIGHT,0 },						// only visible with force sight
+};
+
+void SV_ParseSurfaceParm( CCMShader * shader, const char **text ) 
+{
+	char	*token;
+	int		numsvInfoParms = sizeof(svInfoParms) / sizeof(svInfoParms[0]);
+	int		i;
+
+	token = COM_ParseExt( text, qfalse );
+	for ( i = 0 ; i < numsvInfoParms ; i++ ) 
+	{
+		if ( !Q_stricmp( token, svInfoParms[i].name ) ) 
+		{
+			shader->surfaceFlags |= svInfoParms[i].surfaceFlags;
+			shader->contentFlags |= svInfoParms[i].contents;
+			shader->contentFlags &= svInfoParms[i].clearSolid;
+			break;
+		}
+	}
+}
+
+/*
+=================
+ParseMaterial
+=================
+*/
+const char *svMaterialNames[MATERIAL_LAST] =
+{
+	MATERIALS
+};
+
+void SV_ParseMaterial( CCMShader *shader, const char **text ) 
+{
+	char	*token;
+	int		i;
+
+	token = COM_ParseExt( text, qfalse );
+	if ( !token[0] ) 
+	{
+		Com_Printf( S_COLOR_YELLOW "WARNING: missing material in shader '%s'\n", shader->shader );
+		return;
+	}
+	for(i = 0; i < MATERIAL_LAST; i++)
+	{
+		if ( !Q_stricmp( token, svMaterialNames[i] ) ) 
+		{
+			shader->surfaceFlags &= ~MATERIAL_MASK;//safety, clear it first
+			shader->surfaceFlags |= i;
+			break;
+		}
+	}
+}
+
+/*
+===============
+ParseVector
+===============
+*/
+qboolean CM_ParseVector( CCMShader *shader, const char **text, int count, float *v ) 
+{
+	char	*token;
+	int		i;
+
+	// FIXME: spaces are currently required after parens, should change parseext...
+	token = COM_ParseExt( text, qfalse );
+	if ( strcmp( token, "(" ) ) 
+	{
+		Com_Printf( S_COLOR_YELLOW "WARNING: missing parenthesis in shader '%s'\n", shader->shader );
+		return qfalse;
+	}
+
+	for ( i = 0 ; i < count ; i++ ) 
+	{
+		token = COM_ParseExt( text, qfalse );
+		if ( !token[0] ) 
+		{
+			Com_Printf( S_COLOR_YELLOW "WARNING: missing vector element in shader '%s'\n", shader->shader );
+			return qfalse;
+		}
+		v[i] = atof( token );
+	}
+
+	token = COM_ParseExt( text, qfalse );
+	if ( strcmp( token, ")" ) ) 
+	{
+		Com_Printf( S_COLOR_YELLOW "WARNING: missing parenthesis in shader '%s'\n", shader->shader );
+		return qfalse;
+	}
+	return qtrue;
+}
+
+/*
+=================
+CM_ParseShader
+
+The current text pointer is at the explicit text definition of the
+shader.  Parse it into the global shader variable.
+
+This extracts all the info from the shader required for physics and collision
+It is designed to *NOT* load any image files and not require any of the renderer to 
+be initialised.
+=================
+*/
+void CM_ParseShader( CCMShader *shader, const char **text )
+{
+	char	*token;
+
+	token = COM_ParseExt( text, qtrue );
+	if ( token[0] != '{' )
+	{
+		Com_Printf( S_COLOR_YELLOW "WARNING: expecting '{', found '%s' instead in shader '%s'\n", token, shader->shader );
+		return;
+	}
+
+	while ( true )
+	{
+		token = COM_ParseExt( text, qtrue );
+		if ( !token[0] )
+		{
+			Com_Printf( S_COLOR_YELLOW "WARNING: no concluding '}' in shader %s\n", shader->shader );
+			return;
+		}
+
+		// end of shader definition
+		if ( token[0] == '}' )
+		{
+			break;
+		}
+		// stage definition
+		else if ( token[0] == '{' )
+		{
+			SkipBracedSection( text );
+			continue;
+		}
+		// material deprecated as of 11 Jan 01
+		// material undeprecated as of 7 May 01 - q3map_material deprecated
+		else if ( !Q_stricmp( token, "material" ) || !Q_stricmp( token, "q3map_material" ) )
+		{
+			SV_ParseMaterial( shader, text );
+		}
+		// sun parms
+		// q3map_sun deprecated as of 11 Jan 01
+		else if ( !Q_stricmp( token, "sun" ) || !Q_stricmp( token, "q3map_sun" ) ) 
+		{
+//			float	a, b;
+
+			token = COM_ParseExt( text, qfalse );
+//			shader->sunLight[0] = atof( token );
+			token = COM_ParseExt( text, qfalse );
+//			shader->sunLight[1] = atof( token );
+			token = COM_ParseExt( text, qfalse );
+//			shader->sunLight[2] = atof( token );
+			
+//			VectorNormalize( shader->sunLight );
+
+			token = COM_ParseExt( text, qfalse );
+//			a = atof( token );
+//			VectorScale( shader->sunLight, a, shader->sunLight);
+
+			token = COM_ParseExt( text, qfalse );
+//			a = DEG2RAD(atof( token ));
+
+			token = COM_ParseExt( text, qfalse );
+//			b = DEG2RAD(atof( token ));
+
+//			shader->sunDirection[0] = cos( a ) * cos( b );
+//			shader->sunDirection[1] = sin( a ) * cos( b );
+//			shader->sunDirection[2] = sin( b );
+		}
+		else if ( !Q_stricmp( token, "surfaceParm" ) ) 
+		{
+			SV_ParseSurfaceParm( shader, text );
+			continue;
+		}
+		else if ( !Q_stricmp( token, "fogParms" ) ) 
+		{
+			vec3_t				fogColor;
+			if ( !CM_ParseVector( shader, text, 3, fogColor ) ) 
+			{
+				return;
+			}
+
+			token = COM_ParseExt( text, qfalse );
+			if ( !token[0] ) 
+			{
+				Com_Printf( S_COLOR_YELLOW "WARNING: missing parm for 'fogParms' keyword in shader '%s'\n", shader->shader );
+				continue;
+			}
+//			shader->depthForOpaque = atof( token );
+
+			// skip any old gradient directions
+			SkipRestOfLine( (const char **)text );
+			continue;
+		}
+	}
+	return;
+}
+
+/*
+=================
+CM_SetupShaderProperties
+
+  Scans thru the shaders loaded for the map, parses the text of that shader and
+  extracts the interesting info *WITHOUT* loading up any images or requiring
+  the renderer to be active.
+=================
+*/
+
+void CM_SetupShaderProperties(void)
+{
+	int			i;
+	const char	*def;
+	CCMShader	*shader;
+
+	// Add all basic shaders to the cmShaderTable
+	for(i = 0; i < cmg.numShaders; i++)
+	{
+		cmShaderTable.insert(CM_GetShaderInfo(i));
+	}
+	// Go through and parse evaluate shader names to shadernums
+	for(i = 0; i < cmg.numShaders; i++)
+	{
+		shader = CM_GetShaderInfo(i);
+		def = CM_GetShaderText(shader->shader);
+		if(def)
+		{
+			CM_ParseShader(shader, &def);
+		}
+	}
+}
+
+void CM_ShutdownShaderProperties(void)
+{
+	if(cmShaderTable.count())
+	{
+		Com_Printf("Shutting down cmShaderTable .....\n");
+		cmShaderTable.clear();
+	}
+}
+
+CCMShader *CM_GetShaderInfo( const char *name )
+{
+	CCMShader	*out;
+	const char	*def;
+
+	out = cmShaderTable[name];
+	if(out)
+	{
+		return(out);
+	}
+
+	// Create a new CCMShader class
+	//out = (CCMShader *)Hunk_Alloc( sizeof( CCMShader ), h_high );
+	out = (CCMShader *)Hunk_Alloc( sizeof( CCMShader ), qtrue );
+	// Set defaults
+	Q_strncpyz(out->shader, name, MAX_QPATH);
+	out->contentFlags = CONTENTS_SOLID | CONTENTS_OPAQUE;
+
+	// Parse in any text if it exists
+	def = CM_GetShaderText(name);
+	if(def)
+	{
+		CM_ParseShader(out, &def);
+	}
+
+	cmShaderTable.insert(out);
+	return(out);
+}
+
+CCMShader *CM_GetShaderInfo( int shaderNum )
+{
+	CCMShader	*out;
+
+	if((shaderNum < 0) || (shaderNum >= cmg.numShaders))
+	{
+		return(NULL);
+	}
+	out = cmg.shaders + shaderNum;
+	return(out);
+}
+
+// end
diff --git a/code/qcommon/cm_terrain.cpp b/code/qcommon/cm_terrain.cpp
new file mode 100644
index 0000000..f85718e
--- /dev/null
+++ b/code/qcommon/cm_terrain.cpp
@@ -0,0 +1,1714 @@
+#include "../server/exe_headers.h"
+
+#include "cm_local.h"
+#include "cm_patch.h"
+#include "cm_landscape.h"
+#include "../game/genericparser2.h"
+#include "cm_randomterrain.h"
+
+#ifdef _WIN32
+#pragma optimize("p", on)
+#endif
+
+void R_LoadDataImage	( const char *name, byte **pic, int *width, int *height);
+void R_InvertImage		( byte *data, int width, int height, int depth);
+void R_Resample			( byte *source, int swidth, int sheight, byte *dest, int dwidth, int dheight, int components);
+
+//#define _SMOOTH_TERXEL_BRUSH
+
+#ifdef _SMOOTH_TERXEL_BRUSH 
+#define BRUSH_SIDES_PER_TERXEL	8
+#else
+#define BRUSH_SIDES_PER_TERXEL	5
+#endif
+
+void CCMLandScape::SetShaders(int height, CCMShader *shader)
+{
+	int		i;
+
+	for(i = height; shader && (i < HEIGHT_RESOLUTION); i++)
+	{
+		if(!mHeightDetails[i].GetSurfaceFlags())
+		{
+			mHeightDetails[i].SetFlags(shader->contentFlags, shader->surfaceFlags);
+		}
+	}
+}
+
+void CCMLandScape::LoadTerrainDef(const char *td)
+{
+	char				terrainDef[MAX_QPATH];
+	CGenericParser2		parse;
+	CGPGroup			*basegroup, *classes, *items;
+
+	Com_sprintf(terrainDef, MAX_QPATH, "ext_data/RMG/%s.terrain", Info_ValueForKey(td, "terrainDef"));
+	Com_DPrintf("CM_Terrain: Loading and parsing terrainDef %s.....\n", Info_ValueForKey(td, "terrainDef"));
+
+	if(!Com_ParseTextFile(terrainDef, parse))
+	{
+		Com_sprintf(terrainDef, MAX_QPATH, "ext_data/arioche/%s.terrain", Info_ValueForKey(td, "terrainDef"));
+		if(!Com_ParseTextFile(terrainDef, parse))
+		{
+			Com_Printf("Could not open %s\n", terrainDef);
+			return;
+		}
+	}
+	// The whole file....
+	basegroup = parse.GetBaseParseGroup();
+
+	// The root { } struct
+	classes = basegroup->GetSubGroups();
+	while(classes)
+	{
+		items = classes->GetSubGroups();
+		while(items)
+		{
+			if(!stricmp(items->GetName(), "altitudetexture"))
+			{
+				int			height;
+				const char	*shaderName;
+				CCMShader	*shader;
+
+				// Height must exist - the rest are optional
+				height = atol(items->FindPairValue("height", "0"));
+
+				// Shader for this height
+				shaderName = items->FindPairValue("shader", "");
+				if(strlen(shaderName))
+				{
+					shader = CM_GetShaderInfo(shaderName);
+					if(shader)
+					{
+						SetShaders(height, shader); 
+					}
+				}
+			}
+			else if(!stricmp(items->GetName(), "water"))
+			{
+				const char	*shaderName;
+				CCMShader	*shader;
+
+				// Grab the height of the water
+				mBaseWaterHeight = atol(items->FindPairValue("height", "0"));
+				SetRealWaterHeight(mBaseWaterHeight);
+
+				// Grab the material of the water
+				shaderName = items->FindPairValue("shader", "");
+				shader = CM_GetShaderInfo(shaderName);
+				if(shader)
+				{
+					mWaterContents = shader->contentFlags;
+					mWaterSurfaceFlags = shader->surfaceFlags;
+				}
+			}
+			items = (CGPGroup *)items->GetNext();
+		}
+		classes = (CGPGroup *)classes->GetNext();
+	}
+	Com_ParseTextFileDestroy(parse);
+}
+
+CCMPatch::~CCMPatch(void)
+{
+}
+
+CCMLandScape::CCMLandScape(const char *configstring, bool server)
+{
+	int			numPatches, numBrushesPerPatch, size;// seed;
+	char		heightMap[MAX_QPATH];
+//	char		*ptr;
+
+	holdrand = 0x89abcdef;
+
+	// Clear out the height details
+	memset(mHeightDetails, 0, sizeof(CCMHeightDetails) * HEIGHT_RESOLUTION);
+	mBaseWaterHeight = 0;
+	mWaterHeight = 0.0f;
+
+	// When constructed, referenced once
+	mRefCount = 1;
+
+	// Extract the relevant data from the config string
+	Com_sprintf(heightMap, MAX_QPATH, "%s", Info_ValueForKey(configstring, "heightMap"));
+	numPatches = atol(Info_ValueForKey(configstring, "numPatches"));
+	mTerxels = atol(Info_ValueForKey(configstring, "terxels"));
+	mHasPhysics = !!atol(Info_ValueForKey(configstring, "physics"));
+	//seed = strtoul(Info_ValueForKey(configstring, "seed"), &ptr, 10);
+
+	mBounds[0][0] = (float)atof(Info_ValueForKey(configstring, "minx"));
+	mBounds[0][1] = (float)atof(Info_ValueForKey(configstring, "miny"));
+	mBounds[0][2] = (float)atof(Info_ValueForKey(configstring, "minz"));
+	mBounds[1][0] = (float)atof(Info_ValueForKey(configstring, "maxx"));
+	mBounds[1][1] = (float)atof(Info_ValueForKey(configstring, "maxy"));
+	mBounds[1][2] = (float)atof(Info_ValueForKey(configstring, "maxz"));
+
+	// Calculate size of the brush
+	VectorSubtract(mBounds[1], mBounds[0], mSize);
+
+	// Work out the dimensions of the brush in blocks - the object is to make the blocks as square as possible
+	mBlockWidth = Round(sqrtf(numPatches * mSize[0] / mSize[1]));
+	mBlockHeight = Round(sqrtf(numPatches * mSize[1] / mSize[0]));
+
+	// ...which lets us get the size of the heightmap
+	mWidth = mBlockWidth * mTerxels;
+	mHeight = mBlockHeight * mTerxels;
+
+	mHeightMap = (byte *)Z_Malloc(GetRealArea(), TAG_CM_TERRAIN, qfalse);
+	mFlattenMap = 0;	//only needed on random terrains
+
+	if(strlen(heightMap))
+	{
+		byte	*imageData;
+		int		iWidth, iHeight;
+
+		Com_DPrintf("CM_Terrain: Loading heightmap %s.....\n", heightMap);
+		R_LoadDataImage(heightMap, &imageData, &iWidth, &iHeight); 
+
+		mRandomTerrain = 0;
+
+		if(imageData)
+		{
+			if(strstr(heightMap, "random_"))
+			{
+				mFlattenMap = (byte *)Z_Malloc(GetRealArea(), TAG_CM_TERRAIN, qfalse);
+				memset ( mFlattenMap, 0, GetRealArea() );// Zero means unused.
+				mRandomTerrain = CreateRandomTerrain ( configstring, this, mHeightMap, GetRealWidth(), GetRealHeight());
+			}
+			else
+			{
+				// Flip to make the same as GenSurf
+				R_InvertImage(imageData, iWidth, iHeight, 1);
+				R_Resample(imageData, iWidth, iHeight, mHeightMap, GetRealWidth(), GetRealHeight(), 1);
+			}
+			Z_Free(imageData);
+		}
+	}
+	else
+	{
+		Com_Error(ERR_FATAL, "Terrain has no heightmap specified\n");
+	}
+
+	// Work out the dimensions of the terxel - should be almost square
+	mTerxelSize[0] = mSize[0] / mWidth;
+	mTerxelSize[1] = mSize[1] / mHeight;
+	mTerxelSize[2] = mSize[2] / 255.0f;
+
+	// Work out the patchsize
+	mPatchSize[0] = mSize[0] / mBlockWidth;
+	mPatchSize[1] = mSize[1] / mBlockHeight;
+	mPatchSize[2] = 1.0f;
+	mPatchScalarSize = VectorLength(mPatchSize);
+
+	// Loads in the water height and properties
+	// Gets the shader properties for the blended shaders
+	LoadTerrainDef(configstring);
+
+	Com_DPrintf("CM_Terrain: Creating patches.....\n");
+	mPatches = (CCMPatch *)Z_Malloc(sizeof(CCMPatch) * GetBlockCount(), TAG_CM_TERRAIN, qfalse);
+
+	numBrushesPerPatch = mTerxels * mTerxels * 2;
+	size = (numBrushesPerPatch * sizeof(cbrush_t)) + (numBrushesPerPatch * BRUSH_SIDES_PER_TERXEL * 2 * (sizeof(cbrushside_t) + sizeof(cplane_t)));
+	mPatchBrushData = (byte *)Z_Malloc(size * GetBlockCount(), TAG_CM_TERRAIN, qfalse);
+
+	// Initialize all terrain patches
+	UpdatePatches();
+}
+
+// Initialise a plane from 3 coords
+
+void CCMPatch::InitPlane(struct cbrushside_s *side, cplane_t *plane, vec3_t p0, vec3_t p1, vec3_t p2)
+{
+	vec3_t	dx, dy;
+
+	VectorSubtract(p1, p0, dx);
+	VectorSubtract(p2, p0, dy);
+	CrossProduct(dx, dy, plane->normal);
+	VectorNormalize(plane->normal);
+
+	plane->dist = DotProduct(p0, plane->normal);
+	plane->type = PlaneTypeForNormal(plane->normal);
+	SetPlaneSignbits(plane);
+
+#ifdef _XBOX
+	// MATT! - does this work?
+	cmg.planes[side->planeNum.GetValue()] = *plane;
+#else
+	side->plane = plane;
+#endif
+}
+
+// Create the planes required for collision detection
+// 2 brushes per terxel - each brush has 5 sides and 5 planes
+
+void* CCMPatch::GetAdjacentBrushY ( int x, int y )
+{
+	int			yo1 = y % owner->GetTerxels();
+	int			yo2 = (y-1) % owner->GetTerxels();
+	int			xo  = x % owner->GetTerxels();
+	CCMPatch*	patch;
+	
+	// Different patch
+	if ( yo2 > yo1 )
+	{
+		patch = owner->GetPatch ( x / owner->GetTerxels(), (y-1) / owner->GetTerxels() );
+	}
+	else
+	{
+		patch = this;
+	}
+
+	cbrush_t *brush;
+	
+	brush =  patch->mPatchBrushData;
+	brush += ((yo2 * owner->GetTerxels ( ) + xo) * 2);
+	brush ++;
+
+	return brush;
+}
+
+void* CCMPatch::GetAdjacentBrushX ( int x, int y )
+{
+	int			xo1 = x % owner->GetTerxels();
+	int			xo2 = (x-1) % owner->GetTerxels();
+	int			yo  = y % owner->GetTerxels();
+	CCMPatch*	patch;
+	
+	// Different patch
+	if ( xo2 > xo1 )
+	{
+		patch = owner->GetPatch ( (x-1) / owner->GetTerxels(), y / owner->GetTerxels() );
+	}
+	else
+	{
+		patch = this;
+	}
+
+	cbrush_t *brush;
+	
+	brush =  patch->mPatchBrushData;
+	brush += ((yo * owner->GetTerxels ( ) + xo2) * 2);
+
+	if ( ! ((x+y) & 1) )
+	{		
+		brush ++;
+	}
+
+	return brush;
+}
+
+void CCMPatch::CreatePatchPlaneData(void)
+{				
+#ifndef PRE_RELEASE_DEMO
+	int				realWidth;
+	int				x, y, i, j;
+#if	0
+	int				n;
+#endif
+	cbrush_t		*brush;
+	cbrushside_t	*side;
+	cplane_t		*plane;
+	vec3_t			*coords;
+	vec3_t			localCoords[8];
+
+	mNumBrushes = owner->GetTerxels() * owner->GetTerxels() * 2;
+	realWidth = owner->GetRealWidth();
+	coords = owner->GetCoords();
+
+	brush = mPatchBrushData;
+	side = (cbrushside_t *)(mPatchBrushData + mNumBrushes);
+	plane = (cplane_t *)(side + (mNumBrushes * BRUSH_SIDES_PER_TERXEL * 2));
+	for(y = mHy; y < mHy + owner->GetTerxels(); y++)
+	{
+		for(x = mHx; x < mHx + owner->GetTerxels(); x++)
+		{
+			int		offsets[4];
+
+			if ( (x+y)&1 )
+			{
+				offsets[0] = (y * realWidth) + x;				// TL
+				offsets[1] = (y * realWidth) + x + 1;			// TR
+				offsets[2] = ((y + 1) * realWidth) + x;			// BL
+				offsets[3] = ((y + 1) * realWidth) + x + 1;		// BR
+			}
+			else
+			{
+				offsets[2] = (y * realWidth) + x;				// TL
+				offsets[0] = (y * realWidth) + x + 1;			// TR
+				offsets[3] = ((y + 1) * realWidth) + x;			// BL
+				offsets[1] = ((y + 1) * realWidth) + x + 1;		// BR
+			}
+
+			for(i = 0; i < 4; i++)
+			{
+				VectorCopy(coords[offsets[i]], localCoords[i]);
+				VectorCopy(coords[offsets[i]], localCoords[i + 4]);
+				// Set z of base of brush to bottom of landscape brush
+				localCoords[i + 4][2] = owner->GetMins()[2];
+			}
+
+			// Set the bounds of the terxel
+			VectorSet(brush[0].bounds[0], MAX_WORLD_COORD, MAX_WORLD_COORD, MAX_WORLD_COORD);
+			VectorSet(brush[0].bounds[1], MIN_WORLD_COORD, MIN_WORLD_COORD, MIN_WORLD_COORD);
+
+			for(i = 0; i < 8; i++)
+			{
+				for(j = 0; j < 3; j++)
+				{
+					// mins
+					if(localCoords[i][j] < brush[0].bounds[0][j])
+					{
+						brush[0].bounds[0][j] = localCoords[i][j];
+					}
+					// maxs
+					if(localCoords[i][j] > brush[0].bounds[1][j])
+					{
+						brush[0].bounds[1][j] = localCoords[i][j];
+					}
+				}
+			}
+			VectorDec(brush[0].bounds[0]);
+			VectorInc(brush[0].bounds[1]);
+			VectorCopy(brush[0].bounds[0], brush[1].bounds[0]);
+			VectorCopy(brush[0].bounds[1], brush[1].bounds[1]);
+
+			brush[0].contents = mContentFlags;
+			brush[1].contents = mContentFlags;
+
+#ifndef _SMOOTH_TERXEL_BRUSH
+
+			// Set up sides of the brushes
+			brush[0].numsides = 5;
+			brush[0].sides = side;
+			brush[1].numsides = 5;
+			brush[1].sides = side + 5;
+
+			for ( i = 0; i < 8 ; i ++ )
+			{
+				localCoords[i][0] = (int)localCoords[i][0];
+				localCoords[i][1] = (int)localCoords[i][1];
+				localCoords[i][2] = (int)localCoords[i][2];
+			}
+	
+			// Create the planes of the 2 triangles that make up the tops of the brushes
+			InitPlane(side + 0, plane + 0, localCoords[0], localCoords[1], localCoords[2]);
+			InitPlane(side + 5, plane + 5, localCoords[3], localCoords[2], localCoords[1]);
+
+			// Create the bottom face of the brushes
+			InitPlane(side + 1, plane + 1, localCoords[6], localCoords[5], localCoords[4]);
+			InitPlane(side + 6, plane + 6, localCoords[5], localCoords[6], localCoords[7]);
+
+			// Create the 3 vertical faces
+			InitPlane(side + 2, plane + 2, localCoords[0], localCoords[2], localCoords[4]);
+			InitPlane(side + 7, plane + 7, localCoords[3], localCoords[1], localCoords[7]);
+
+			InitPlane(side + 3, plane + 3, localCoords[0], localCoords[4], localCoords[1]);
+			InitPlane(side + 8, plane + 8, localCoords[3], localCoords[7], localCoords[2]);
+
+			InitPlane(side + 4, plane + 4, localCoords[2], localCoords[1], localCoords[6]);
+			InitPlane(side + 9, plane + 9, localCoords[5], localCoords[1], localCoords[6]);
+
+			// Increment to next terxel
+			brush += 2;
+			side += 10;
+			plane += 10;
+
+			
+
+#else
+
+			// Set up sides of the brushes
+			brush[0].numsides = 5;
+			brush[0].sides = side;
+			brush[1].numsides = 5;
+			brush[1].sides = side + 8;
+
+			// Create the planes of the 2 triangles that make up the tops of the brushes
+			InitPlane(side + 0, plane + 0, localCoords[0], localCoords[1], localCoords[2]);
+			InitPlane(side + 8, plane + 8, localCoords[3], localCoords[2], localCoords[1]);
+
+			// Create the bottom face of the brushes
+			InitPlane(side + 1, plane + 1, localCoords[4], localCoords[6], localCoords[5]);
+			InitPlane(side + 9, plane + 9, localCoords[7], localCoords[5], localCoords[6]);
+
+			// Create the 3 vertical faces
+			InitPlane(side + 2, plane + 2, localCoords[0], localCoords[2], localCoords[4]);
+			InitPlane(side + 10, plane + 10, localCoords[3], localCoords[1], localCoords[7]);
+
+			InitPlane(side + 3, plane + 3, localCoords[0], localCoords[4], localCoords[1]);
+			InitPlane(side + 11, plane + 11, localCoords[3], localCoords[7], localCoords[2]);
+
+			InitPlane(side + 4, plane + 4, localCoords[2], localCoords[1], localCoords[6]);
+			InitPlane(side + 12, plane + 12, localCoords[5], localCoords[1], localCoords[6]);
+
+			float V = DotProduct ( (plane + 8)->normal, localCoords[0] ) - (plane + 8)->dist;
+
+			if ( V < 0 )
+			{
+				InitPlane ( brush[0].sides + brush[0].numsides, plane + brush[0].numsides, localCoords[3], localCoords[2], localCoords[1]);
+				brush[0].numsides++;			
+
+				InitPlane ( brush[1].sides + brush[1].numsides, plane + 8 + brush[1].numsides, localCoords[0], localCoords[1], localCoords[2]);
+				brush[1].numsides++;			
+			}
+
+			// Determine if we need to smooth the brush transition from the brush above us
+			if ( y > 0 && y < owner->GetPatchHeight ( ) - 1 )
+			{
+				cbrush_t* abovebrush = (cbrush_t*)GetAdjacentBrushY ( x, y );
+#ifdef _XBOX
+				cplane_t* aboveplane = &cmg.planes[abovebrush->sides->planeNum.GetValue()];
+#else
+				cplane_t* aboveplane = abovebrush->sides->plane;
+#endif
+
+				V = DotProduct ( aboveplane->normal, ((y+x)&1)?(localCoords[2]):(localCoords[1]) ) - aboveplane->dist;
+
+				if ( V < 0 )
+				{
+					memcpy ( brush[0].sides + brush[0].numsides, abovebrush->sides, sizeof(cbrushside_t) );
+					brush[0].numsides++;
+
+					memcpy ( abovebrush->sides + abovebrush->numsides, side + 0, sizeof(cbrushside_t) );
+					abovebrush->numsides++;
+				}
+			}
+			
+			// Determine if we need to smooth the brush transition from the brush to the left of us
+			if ( x > 0 && x < owner->GetPatchWidth ( ) - 1 )
+			{
+				cbrush_t* abovebrush = (cbrush_t*)GetAdjacentBrushX ( x, y );
+#ifdef _XBOX
+				cplane_t* aboveplane = &cmg.planes[abovebrush->sides->planeNum.GetValue()];
+#else
+				cplane_t* aboveplane = abovebrush->sides->plane;
+#endif
+
+				V = DotProduct ( aboveplane->normal, localCoords[1] ) - aboveplane->dist;
+
+				if ( V < 0 )
+				{
+					if ( (x+y)&1 )
+					{
+						memcpy ( brush[0].sides + brush[0].numsides, abovebrush->sides, sizeof(cbrushside_t) );
+						brush[0].numsides++;
+
+						memcpy ( abovebrush->sides + abovebrush->numsides, side + 0, sizeof(cbrushside_t) );
+						abovebrush->numsides++;
+					}
+					else
+					{
+						memcpy ( brush[1].sides + brush[1].numsides, abovebrush->sides, sizeof(cbrushside_t) );
+						brush[1].numsides++;
+
+						memcpy ( abovebrush->sides + abovebrush->numsides, side + 8, sizeof(cbrushside_t) );
+						abovebrush->numsides++;
+					}
+				}
+			}
+
+			// Increment to next terxel
+			brush += 2;
+			side += 16;
+			plane += 16;
+#endif
+		}
+	}
+#endif // PRE_RELEASE_DEMO
+}
+
+void CCMPatch::Init(CCMLandScape *ls, int heightX, int heightY, vec3_t world, byte *hMap, byte *patchBrushData)
+{
+#ifndef PRE_RELEASE_DEMO
+	int		min, max, x, y, height;
+
+	// Set owning landscape
+	owner = ls;
+
+	// Store the base of the top left corner
+	VectorCopy(world, mWorldCoords);
+
+	// Store pointer to first byte of the height data for this patch.
+	mHx = heightX;
+	mHy = heightY;
+	mHeightMap = hMap + ((heightY * owner->GetRealWidth()) + heightX);
+
+	// Calculate the bounds for culling 
+	// Use the dimensions 1 terxel outside the patch to allow for sloping of edge terxels
+	min = 256;
+	max = -1;
+	for(y = heightY - 1; y < heightY + owner->GetTerxels() + 1; y++)
+	{
+		if(y >= 0)
+		{
+			for(x = heightX - 1; x < heightX + owner->GetTerxels() + 1; x++)
+			{
+				if(x >= 0)
+				{
+					height = hMap[(y * owner->GetRealWidth()) + x];
+
+					if(height > max)
+					{
+						max = height;
+					}
+					if(height < min)
+					{
+						min = height;
+					}
+				}
+			}
+		}
+	}
+
+	// Mins
+	mBounds[0][0] = world[0];
+	mBounds[0][1] = world[1];
+	mBounds[0][2] = world[2] + (min * owner->GetTerxelSize()[2]);
+
+	// Maxs
+	mBounds[1][0] = world[0] + (owner->GetPatchSize()[0]);
+	mBounds[1][1] = world[1] + (owner->GetPatchSize()[1]);
+	mBounds[1][2] = world[2] + (max * owner->GetTerxelSize()[2]);
+
+	// Corner heights
+	mCornerHeights[0] = mHeightMap[0];
+	mCornerHeights[1] = mHeightMap[owner->GetTerxels()];
+	mCornerHeights[2] = mHeightMap[owner->GetTerxels() * owner->GetRealWidth()];
+	mCornerHeights[3] = mHeightMap[(owner->GetTerxels() * owner->GetRealWidth()) + owner->GetTerxels()];
+
+	// Set the surfaceFlags using average height (may want a more complex algo here)
+	mSurfaceFlags = owner->GetSurfaceFlags((min + max) >> 1);
+	mContentFlags = owner->GetContentFlags((min + max) >> 1);
+
+	// Set base of brush data from big array
+	mPatchBrushData = (cbrush_t *)patchBrushData; 
+	CreatePatchPlaneData();
+#endif // PRE_RELEASE_DEMO
+}
+
+CCMPatch *CCMLandScape::GetPatch(int x, int y)
+{
+	return(mPatches + ((y * mBlockWidth) + x));
+}
+
+void CCMLandScape::PatchCollide(struct traceWork_s *tw, trace_t &trace, const vec3_t start, const vec3_t end, int checkcount)
+{
+	vec3pair_t	tBounds;
+
+	// Convert to valid bounding box
+	CM_CalcExtents(start, end, tw, tBounds);
+
+//	if (com_newtrace->integer)
+	if (1)
+	{
+		float		slope, offset;
+		float		startPatchLoc, endPatchLoc, startPos, endPos;
+		float		patchDirection = 1;
+		float		checkDirection = 1;
+		int			countPatches, count;
+		CCMPatch	*patch;
+		float		fraction = trace.fraction;
+
+		if (fabs(end[0]-start[0]) >= fabs(fabs(end[1]-start[1])))
+		{	// x travels more than y
+			// calculate line slope and offset
+			if (end[0] - start[0])
+			{
+				slope = (end[1] - start[1]) / (end[0] - start[0]);
+			}
+			else
+			{
+				slope = 0;
+			}
+			offset = start[1] - (start[0] * slope);
+
+			// find the starting 
+			startPatchLoc = floor((start[0] - mBounds[0][0]) / mPatchSize[0]);
+			endPatchLoc = floor((end[0] - mBounds[0][0]) / mPatchSize[0]);
+
+			if (startPatchLoc <= endPatchLoc)
+			{	// moving along slope in a positive direction
+				endPatchLoc++;
+				startPatchLoc--;
+				countPatches = endPatchLoc - startPatchLoc + 1;
+			}
+			else
+			{	// moving along slope in a negative direction
+				endPatchLoc--;
+				startPatchLoc++;
+				patchDirection = -1;
+				countPatches = startPatchLoc - endPatchLoc + 1;
+			}
+			if (slope < 0.0)
+			{
+				checkDirection = -1;
+			}
+			
+			// first calculate the real world location
+			startPos = ((startPatchLoc * mPatchSize[0] + mBounds[0][0]) * slope) + offset;
+			// calculate it back into patch coords
+			startPos = floor((startPos - mBounds[0][1] + tw->size[0][1]) / mPatchSize[1]);
+			do
+			{
+				if (startPatchLoc >= 0 && startPatchLoc < mBlockWidth)
+				{	// valid location
+					// first calculate the real world location
+					endPos = (((startPatchLoc+patchDirection) * mPatchSize[0] + mBounds[0][0]) * slope) + offset;
+					// calculate it back into patch coords
+					endPos = floor((endPos - mBounds[0][1] + tw->size[1][1]) / mPatchSize[1]);
+					
+					if (checkDirection < 0)
+					{
+						startPos++;
+						endPos--;
+					}
+					else
+					{
+						startPos--;
+						endPos++;
+					}
+					count = fabs(endPos - startPos) + 1;
+					while(count)
+					{
+						if (startPos  >= 0 && startPos < mBlockHeight)
+						{	// valid location
+							patch = GetPatch(startPatchLoc, startPos);
+							// Collide with every patch to find the minimum fraction
+							CM_HandlePatchCollision(tw, trace, tBounds[0], tBounds[1], patch, checkcount);
+
+							if (trace.fraction <= 0.0)
+							{
+								return;
+							}
+						}
+						startPos += checkDirection;
+						count--;
+					}
+
+					if (trace.fraction < fraction)
+					{
+						return;
+					}
+				}
+				// move to the next spot
+				// we still stay one behind, to get the opposite edge of the terrain patch
+				startPos = ((startPatchLoc * mPatchSize[0] + mBounds[0][0]) * slope) + offset;
+				startPatchLoc += patchDirection;
+				// first calculate the real world location
+				// calculate it back into patch coords
+				startPos = floor((startPos - mBounds[0][1] + tw->size[0][1]) / mPatchSize[1]);
+
+				countPatches--;
+			}
+			while (countPatches);
+		}
+		else
+		{
+			// calculate line slope and offset
+			slope = (end[0] - start[0]) / (end[1] - start[1]);
+			offset = start[0] - (start[1] * slope);
+
+			// find the starting 
+			startPatchLoc = floor((start[1] - mBounds[0][1]) / mPatchSize[1]);
+			endPatchLoc = floor((end[1] - mBounds[0][1]) / mPatchSize[1]);
+
+			if (startPatchLoc <= endPatchLoc)
+			{	// moving along slope in a positive direction
+				endPatchLoc++;
+				startPatchLoc--;
+				countPatches = endPatchLoc - startPatchLoc + 1;
+			}
+			else
+			{	// moving along slope in a negative direction
+				endPatchLoc--;
+				startPatchLoc++;
+				patchDirection = -1;
+				countPatches = startPatchLoc - endPatchLoc + 1;
+			}
+			if (slope < 0.0)
+			{
+				checkDirection = -1;
+			}
+			
+			// first calculate the real world location
+			startPos = ((startPatchLoc * mPatchSize[1] + mBounds[0][1]) * slope) + offset;
+			// calculate it back into patch coords
+			startPos = floor((startPos - mBounds[0][0] + tw->size[0][0]) / mPatchSize[0]);
+			do
+			{
+				if (startPatchLoc >= 0 && startPatchLoc < mBlockHeight)
+				{	// valid location
+					// first calculate the real world location
+					endPos = (((startPatchLoc+patchDirection) * mPatchSize[1] + mBounds[0][1]) * slope) + offset;
+					// calculate it back into patch coords
+					endPos = floor((endPos - mBounds[0][0] + tw->size[1][0]) / mPatchSize[0]);
+
+					if (checkDirection < 0)
+					{
+						startPos++;
+						endPos--;
+					}
+					else
+					{
+						startPos--;
+						endPos++;
+					}
+					
+					count = fabs(endPos - startPos) + 1;
+					while(count)
+					{
+						if (startPos >= 0 && startPos < mBlockWidth)
+						{	// valid location
+							patch = GetPatch(startPos, startPatchLoc);
+							// Collide with every patch to find the minimum fraction
+							CM_HandlePatchCollision(tw, trace, tBounds[0], tBounds[1], patch, checkcount);
+
+							if (trace.fraction <= 0.0)
+							{
+								return;
+							}
+						}
+						startPos += checkDirection;
+						count--;
+					}
+
+					if (trace.fraction < fraction)
+					{
+						return;
+					}
+				}
+
+				// move to the next spot
+				// we still stay one behind, to get the opposite edge of the terrain patch
+				startPos = ((startPatchLoc * mPatchSize[1] + mBounds[0][1]) * slope) + offset;
+				startPatchLoc += patchDirection;
+				// first calculate the real world location
+				// calculate it back into patch coords
+				startPos = floor((startPos - mBounds[0][0] + tw->size[0][0]) / mPatchSize[0]);
+				countPatches--;
+			}
+			while (countPatches);
+		}
+	}
+	else
+	{
+		int			x, y;
+		vec3_t		tWork;
+		vec3_t		pStart, pEnd;
+		int			minx, maxx, miny, maxy;
+		CCMPatch	*patch;
+
+		// Work out and grab the relevant patches
+		VectorSubtract(tBounds[0], mBounds[0], tWork);
+		VectorInverseScaleVector(tWork, mPatchSize, pStart);
+		VectorSubtract(tBounds[1], mBounds[0], tWork);
+		VectorInverseScaleVector(tWork, mPatchSize, pEnd);
+
+		minx = Com_Clamp(0, mBlockWidth - 1, floorf(pStart[0]));
+		maxx = Com_Clamp(0, mBlockWidth - 1, ceilf(pEnd[0]));
+		miny = Com_Clamp(0, mBlockHeight - 1, floorf(pStart[1]));
+		maxy = Com_Clamp(0, mBlockHeight - 1, ceilf(pEnd[1]));
+
+		// generic box collide with each one
+		for(y = miny; y <= maxy; y++)
+		{
+			for(x = minx; x <= maxx; x++)
+			{
+				patch = GetPatch(x, y);
+				// Collide with every patch to find the minimum fraction
+				CM_HandlePatchCollision(tw, trace, tBounds[0], tBounds[1], patch, checkcount);
+
+				if (trace.fraction <= 0.0)
+				{
+					break;
+				}
+			}
+		}
+	}
+}
+
+float CCMLandScape::WaterCollide(const vec3_t begin, const vec3_t end, float fraction) const
+{
+	// Check for completely above water
+	if((begin[2] > mWaterHeight) && (end[2] > mWaterHeight))
+	{
+		return(fraction);
+	}
+	// Check for completely below water
+	if((begin[2] < mWaterHeight) && (end[2] < mWaterHeight))
+	{
+		return(fraction);
+	}
+	// Check for starting in water and leaving
+	if(begin[2] < mWaterHeight - SURFACE_CLIP_EPSILON)
+	{
+		fraction = ((mWaterHeight - SURFACE_CLIP_EPSILON) - begin[2]) / (end[2] - begin[2]);
+		return(fraction);
+	}
+	// Now the trace must be entering the water
+	if(begin[2] > mWaterHeight + SURFACE_CLIP_EPSILON)
+	{
+		fraction = (begin[2] - (mWaterHeight + SURFACE_CLIP_EPSILON)) / (begin[2] - end[2]);
+	}
+	return(fraction);
+}
+
+void CCMLandScape::GetTerxelLocalCoords ( int x, int y, vec3_t localCoords[8] )
+{
+	int		realWidth;
+	vec3_t* coords;
+	int		offsets[4];
+	int		i;
+
+	coords = GetCoords ( );
+	realWidth = GetRealWidth ( );
+
+	if ( (x+y)&1 )
+	{
+		offsets[0] = (y * realWidth) + x;				// TL
+		offsets[1] = (y * realWidth) + x + 1;			// TR
+		offsets[2] = ((y + 1) * realWidth) + x;			// BL
+		offsets[3] = ((y + 1) * realWidth) + x + 1;		// BR
+	}
+	else
+	{
+		offsets[2] = (y * realWidth) + x;				// TL
+		offsets[0] = (y * realWidth) + x + 1;			// TR
+		offsets[3] = ((y + 1) * realWidth) + x;			// BL
+		offsets[1] = ((y + 1) * realWidth) + x + 1;		// BR
+	}
+
+	for( i = 0; i < 4; i++ )
+	{
+		VectorCopy(coords[offsets[i]], localCoords[i]);
+		VectorCopy(coords[offsets[i]], localCoords[i + 4]);
+		
+		// Set z of base of brush to bottom of landscape brush
+		localCoords[i + 4][2] = GetMins()[2];
+	}
+}
+
+
+void CCMLandScape::UpdatePatches(void)
+{
+	CCMPatch	*patch;
+	int			x, y, ix, iy, numBrushesPerPatch;
+	vec3_t		world;
+	int			size;
+
+/*	for(y=0;y<GetRealHeight();y++)
+	{
+		for(x=0;x<GetRealWidth();x++)
+		{
+			Com_Printf("(%d,%d) = %u\n", x, y, (unsigned)mHeightMap[y*GetRealWidth() + x]);
+		}
+	}
+*/
+	// Calculate real world coordinates from the heightmap
+	CalcRealCoords();
+
+	numBrushesPerPatch = mTerxels * mTerxels * 2;
+	size = (numBrushesPerPatch * sizeof(cbrush_t)) + (numBrushesPerPatch * BRUSH_SIDES_PER_TERXEL * 2 * (sizeof(cbrushside_t) + sizeof(cplane_t)));
+
+	patch = mPatches;
+	for(y = 0, iy = 0; y < mHeight; y += mTerxels, iy++)
+	{
+		for(x = 0, ix = 0; x < mWidth; x += mTerxels, ix++, patch++)
+		{
+			VectorSet(world, mBounds[0][0] + (x * mTerxelSize[0]), mBounds[0][1] + (y * mTerxelSize[1]), mBounds[0][2]);
+			patch->Init(this, x, y, world, mHeightMap, mPatchBrushData + (size * (ix + (iy * mBlockWidth))));
+		}
+	}
+
+/*	
+	for ( y = mTerxels; y < mHeight - mTerxels; y ++ )
+	{
+		for ( x = mTerxels; x < mWidth - mTerxels; x ++ )
+		{
+			int xo     = x % mTerxels;
+			int yo     = y % mTerxels;
+			int xor    = (x + 1) % mTerxels;
+			int yob    = (y + 1) % mTerxels;
+
+			CCMPatch*	patch  = mPatches + (mWidth / mTerxels) * y + (x / mTerxels);
+			CCMPatch*	rpatch = mPatches + (mWidth / mTerxels) * y + ((x+1) / mTerxels);
+			CCMPatch*	bpatch = mPatches + (mWidth / mTerxels) * (y + 1) + (x / mTerxels);
+
+			int		offsets[4];
+			vec3_t	localCoords[8];
+			vec3_t	localCoordsR[8];
+			vec3_t	localCoordsL[8];
+
+			GetTerxelLocalCoords ( x, y, localCoords );
+			GetTerxelLocalCoords ( x + 1, y, localCoordsR );
+			GetTerxelLocalCoords ( x, y + 1, localCoordsB );
+
+			brush = patch->GetCollisionData ( );;
+			side  = (cbrushside_t *)(mPatchBrushData + patch->GetNumBrushes ( ) );
+			plane = (cplane_t *)(side + (mNumBrushes * BRUSH_SIDES_PER_TERXEL * 2));
+			
+
+			float V = DotProduct ( (plane + 8)->normal, localCoords[0] ) + plane->dist;
+
+			if ( V < 0 )
+			{
+				InitPlane ( brush[0].sides + brush[0].numsides, plane + brush[0].numsides, localCoords[3], localCoords[2], localCoords[1]);
+				brush[0].numsides++;			
+
+				InitPlane ( brush[1].sides + brush[1].numsides, plane + 8 + brush[1].numsides, localCoords[0], localCoords[1], localCoords[2]);
+				brush[1].numsides++;			
+			}			
+		}
+	}
+*/
+
+	// Cleanup coord array
+	Z_Free(mCoords);
+}
+
+void CCMLandScape::CalcRealCoords(void)
+{
+	int		x, y;
+
+	mCoords = (vec3_t *)Z_Malloc(sizeof(vec3_t) * GetRealWidth() * GetRealHeight(), TAG_CM_TERRAIN, qfalse);
+
+	// Work out the real world coordinates of each heightmap entry
+	for(y = 0; y < GetRealHeight(); y++)
+	{
+		for(x = 0; x < GetRealWidth(); x++)
+		{
+			ivec3_t		icoords;
+			int			offset;
+
+			offset = (y * GetRealWidth()) + x;
+
+			VectorSet(icoords, x, y, mHeightMap[offset]);
+			VectorScaleVectorAdd(GetMins(), icoords, GetTerxelSize(), mCoords[offset]);
+		}
+	}
+}
+
+void CCMLandScape::TerrainPatchIterate(void (*IterateFunc)( CCMPatch *, void * ), void *userdata) const
+{
+	int			i;
+	CCMPatch	*patch;
+
+	patch = mPatches;
+	for(i = 0; i < GetBlockCount(); i++, patch++)
+	{
+		IterateFunc(patch, userdata);
+	}
+}
+
+#define LERP(t, a, b) (((b)-(a))*(t) + (a))
+
+float CCMLandScape::GetWorldHeight(vec3_t origin, const vec3pair_t bounds, bool aboveGround) const
+{ 
+	vec3_t		work;
+	int			minx, maxx, miny, maxy;
+	int			TL, TR, BL, BR;
+	int			final;
+
+	VectorSubtract(origin, mBounds[0], work);
+	VectorInverseScaleVector(work, mTerxelSize, work);
+
+	// Presume the bases of all misc models are less than 1 terxel square
+	minx = Com_Clamp(0, GetWidth(), (int)floorf(work[0]));
+	maxx = Com_Clamp(0, GetWidth(), (int)ceilf(work[0]));
+	miny = Com_Clamp(0, GetHeight(), (int)floorf(work[1]));
+	maxy = Com_Clamp(0, GetHeight(), (int)ceilf(work[1]));
+
+	TL = mHeightMap[(miny * GetRealWidth()) + minx];
+	TR = mHeightMap[(miny * GetRealWidth()) + maxx];
+	BL = mHeightMap[(maxy * GetRealWidth()) + minx];
+	BR = mHeightMap[(maxy * GetRealWidth()) + maxx];
+
+	if(aboveGround)
+	{
+//		int			max1, max2;
+//		max1 = maximum(TL, TR);
+//		max2 = maximum(BL, BR);
+//		final = maximum(max1, max2);
+		float h1, h2;
+		float tx, ty;
+		tx = (work[0] - minx)/((float)(maxx-minx));
+		ty = (work[1] - miny)/((float)(maxy-miny));
+		h1 = LERP(tx, TL, TR);
+		h2 = LERP(tx, BL, BR);
+		final = LERP(ty, h1, h2);
+	}
+	else
+	{
+		int			min1, min2;
+
+		min1 = minimum(TL, TR);
+		min2 = minimum(BL, BR);
+		final = minimum(min1, min2);
+	}
+	origin[2] = (final * mTerxelSize[2]) + mBounds[0][2]; 
+
+	// compute slope at this spot
+	if (maxx == minx)
+		maxx = Com_Clamp(0, GetWidth(), minx+1);
+	if (maxy == miny)
+		maxy = Com_Clamp(0, GetHeight(), miny+1);
+	BR = mHeightMap[(maxy * GetRealWidth()) + maxx];
+
+	// rise over run
+	return (fabs((float)(BR - TL)) * mTerxelSize[2]) / mTerxelSize[0];
+}
+
+void CM_CircularIterate(byte *data, int width, int height, int xo, int yo, int insideRadius, int outsideRadius, int *user, void (*callback)(byte *, float, int *))
+{
+	int		x, y, offset;
+	byte	*work;
+
+	for(y = -outsideRadius; y < outsideRadius + 1; y++)
+	{
+		if(y + yo >= 0 && y + yo < height)
+		{
+			offset = sqrtf((outsideRadius * outsideRadius) - (y * y));
+			for(x = -offset; x < offset + 1; x++)
+			{
+		 		if(x + xo >= 0 && x + xo < width)
+		 		{
+					float radius = sqrt((float)(x*x+y*y));
+
+					if ( radius >= insideRadius )
+					{
+		 				work = data + (x + xo) + ((y + yo) * width);
+		 				callback( work, (radius - (float)insideRadius) / (float)(outsideRadius - insideRadius), user);
+					}
+		 		}
+			}
+		}
+	}
+}
+
+void CM_ForceHeight( byte *work, float lerp, int *user)
+{
+	*work = (byte)Com_Clamp(0, 255, (int)*user);
+}
+
+
+void CM_GetAverage( byte *work, float lerp, int *user)
+{
+	user[0] += *work;
+	user[1]++;
+}
+
+void CM_Smooth ( byte* work, float lerp, int *user )
+{
+	float smooth = sin ( M_PI/2*3 + (1.0f-lerp) * (M_PI / 2) ) + 1.0f;
+//	float smooth = (1.0f - lerp);
+
+	*work = *work + (int)((float)(*user - *work) * smooth);
+}
+
+void CM_MakeAverage( byte *work, float lerp, int *user)
+{
+	int		height, diff;
+
+	height = (int)*work;
+	diff = *user - height;
+	if(abs(diff) > 3)
+	{
+		diff >>= 2;
+	}
+	height += diff;
+	*work = (byte)Com_Clamp(0, 255, height);
+}
+
+void CCMLandScape::SaveArea(CArea *area)
+{
+	mAreas.push_back(area);
+}
+
+void CCMLandScape::CarveLine ( vec3_t start, vec3_t end, int depth, int width )
+{
+	int	x, x1, x2, deltax;
+	int	y, y1, y2, deltay;
+	int	xinc1, xinc2;
+	int yinc1, yinc2;
+	int	den, num;
+	int count, add;
+	int	i;
+	float	heightStart;
+	float	heightEnd;
+	float	heightStep;
+
+	x1 = (int) start[0];
+	y1 = (int) start[1];
+	x2 = (int) end[0];
+	y2 = (int) end[1];	
+
+	deltax = abs(x2 - x1);
+	deltay = abs(y2 - y1);
+	x = x1;
+	y = y1;
+
+	// The x-values are increasing
+	if (x2 >= x1)
+	{
+		xinc1 = 1;
+		xinc2 = 1;
+	}
+	// The x-values are decreasing
+	else                          
+	{
+		xinc1 = -1;
+		xinc2 = -1;
+	}
+
+	// The y-values are increasing
+	if (y2 >= y1)                 
+	{
+		yinc1 = 1;
+		yinc2 = 1;
+	}
+	// The y-values are decreasing
+	else                          
+	{
+		yinc1 = -1;
+		yinc2 = -1;
+	}
+
+	if (deltax >= deltay)         // There is at least one x-value for every y-value
+	{
+		xinc1 = 0;                  // Don't change the x when numerator >= denominator
+		yinc2 = 0;                  // Don't change the y for every iteration
+		den   = deltax;
+		num   = deltax / 2;
+		add   = deltay;
+		count = deltax;				// There are more x-values than y-values
+	}
+	else                          // There is at least one y-value for every x-value
+	{
+		xinc2 = 0;                  // Don't change the x for every iteration
+		yinc1 = 0;                  // Don't change the y when numerator >= denominator
+		den   = deltay;
+		num   = deltay / 2;
+		add   = deltax;
+		count = deltay;         // There are more y-values than x-values
+	}
+
+	vec3_t pt;
+	vec3_t bounds[2] = {{-1,-1,-1},{1,1,1}};
+	
+	pt[0] = start[0];
+	pt[1] = start[1];
+	GetWorldHeight ( pt, bounds, false );
+	heightStart = pt[2];
+
+	pt[0] = end[0];
+	pt[1] = end[1];
+	GetWorldHeight ( pt, bounds, false );
+	heightEnd = pt[2];
+
+	heightStep = (heightEnd-heightStart) / count;
+
+	for ( i = 0; i <= count; i++ )
+	{
+		// Flatten the current location
+		CArea area;
+
+		pt[0] = x;
+		pt[1] = y;
+		area.Init ( pt, width / 2 + (irand(0, width/2)) );
+	 	FlattenArea ( &area, heightStart + (heightStep * i) - (depth/2 - (irand(0, depth/2))), false, true, true );
+
+		// Increase the numerator by the top of the fraction
+		num += add;					
+  
+		if (num >= den)             
+		{
+			// Calculate the new numerator value
+			num -= den;
+			
+			// Change the x and y as appropriate
+			x += xinc1;
+			y += yinc1;
+		}
+		
+		// Change the x and y as appropriate
+		x += xinc2;                 
+		y += yinc2;                 
+	}
+}
+
+void CCMLandScape::CarveBezierCurve ( int numCtlPoints, vec3_t* ctlPoints, int steps, int depth, int size )
+{
+	int		i;
+	int		choose;
+	int		n;
+	float	u;
+	float	t;
+	float	tt;
+	float	t1;
+	float	step;
+	vec3_t	pt;
+	vec3_t  lastpt;
+	vec3_t	b[10];
+
+	n      = numCtlPoints - 1;
+	choose = 1;
+
+	for ( i = 1; i <= n; i ++ )
+	{
+		if ( i == 1 )
+			choose = n;
+		else
+			choose = choose * (n-i+1) / i;
+
+		(*(ctlPoints+i))[0] *= choose;
+		(*(ctlPoints+i))[1] *= choose;
+	}
+	
+	step = 1.0f / (float)steps;
+	for ( choose = 0, t = step; t < 1; t += step, choose++ )
+	{
+		b[0][0] = (*(ctlPoints+0))[0];
+		b[0][1] = (*(ctlPoints+0))[1];
+
+		for ( u = t, i = 1; i <= n; i ++ )
+		{
+			b[i][0] = (*(ctlPoints+i))[0] * u;
+			b[i][1] = (*(ctlPoints+i))[1] * u;
+
+			u = u * t;
+		}
+
+		pt[0] = b[n][0];
+		pt[1] = b[n][1];
+
+		t1 = 1 - t;
+		tt = t1;
+
+		for ( i = n - 1; i >= 0; i -- )
+		{
+			pt[0] += b[i][0] * tt;
+			pt[1] += b[i][1] * tt;
+
+			tt = tt * t1;
+		}
+
+		if ( choose != 0 )
+		{
+			CarveLine ( lastpt, pt, depth, size );
+		}
+
+		// Save this point for next time around
+		lastpt[0] = pt[0];
+		lastpt[1] = pt[1];
+	}
+}
+
+void CCMLandScape::FlattenArea(CArea *area, int height, bool save, bool forceHeight, bool smooth )
+{
+	vec3_t	temp;
+	ivec3_t	icoords;
+	int		radius;
+	int		height2;
+
+	if(save)
+	{
+		SaveArea(area);
+	//	mAreas.push_back(*area);
+	}
+
+	// Work out coords in the heightmap
+	VectorSubtract(area->GetPosition(), mBounds[0], temp);
+	icoords[0] = temp[0] / (mBounds[1][0] - mBounds[0][0]) * (float)GetRealWidth ( );
+	icoords[1] = temp[1] / (mBounds[1][1] - mBounds[0][1]) * (float)GetRealHeight ( );
+
+//	VectorInverseScaleVector(temp, mTerxelSize, icoords);
+
+	// round up, we'd rather have a little more area flattened than have less then what was requested
+	radius = (int)ceilf( (area->GetRadius() / mTerxelSize[1]) );
+
+	// Work out the average height of the surrounding terrain
+	height2 = height;
+	if(height < 0)
+	{
+		ivec3_t info;
+
+		info[0] = 0;
+		info[1] = 0;
+		CM_CircularIterate(mHeightMap, GetRealWidth(), GetRealHeight(), icoords[0], icoords[1], 0, radius, info, CM_GetAverage);
+		if(info[1])
+		{
+			height = info[0] / info[1];
+		}
+	}
+	else
+	{
+		height = height & 0x7F;
+	}
+
+	if ( smooth )
+	{
+		CM_CircularIterate(mHeightMap, GetRealWidth(), GetRealHeight(), icoords[0], icoords[1], radius, radius * 3, &height, CM_Smooth);
+	}
+
+	if ( forceHeight )
+	{		
+		CM_CircularIterate(mHeightMap, GetRealWidth(), GetRealHeight(), icoords[0], icoords[1], 0, radius + 1, &height, CM_ForceHeight );
+		assert (mFlattenMap);
+		CM_CircularIterate(mFlattenMap, GetRealWidth(), GetRealHeight(), icoords[0], icoords[1], 0, radius + 1, &height2, CM_ForceHeight );
+	}
+	else if ( smooth ) 
+	{
+		CM_CircularIterate(mHeightMap, GetRealWidth(), GetRealHeight(), icoords[0], icoords[1], 0, radius, &height, CM_Smooth);
+	}
+}
+
+void CM_BelowLevel(byte *data, float lerp, int *info)
+{
+	info[1]++;
+	if(*data < info[2])
+	{
+		info[0]++;
+	}
+}
+
+float CCMLandScape::FractionBelowLevel(CArea *area, int height)
+{
+	vec3_t	temp;
+	ivec3_t	icoords, info;
+	int		count;
+	float	level;
+
+	// Work out coords in the heightmap
+	VectorSubtract(area->GetPosition(), mBounds[0], temp);
+	VectorInverseScaleVector(temp, mTerxelSize, icoords);
+
+	// Work out radius of area in heightmap entries
+	count = area->GetRadius() / mTerxelSize[1];
+
+	info[0] = 0;
+	info[1] = 0;
+
+	info[2] = height;
+	if(height < 0)
+	{
+		info[2] = mBaseWaterHeight;
+	}
+	CM_CircularIterate(mHeightMap, GetRealWidth(), GetRealHeight(), icoords[0], icoords[1], 0, count, info, CM_BelowLevel);
+
+	level = 0.0f;
+	if(info[1])
+	{
+		level = (float)info[0] / info[1];
+	}
+
+	return(level);
+}
+
+CArea *CCMLandScape::GetFirstArea(void)
+{
+	if(!mAreas.size())
+	{
+		return(NULL);
+	}
+	mAreasIt = mAreas.begin();
+	return (*mAreasIt);
+}
+
+CArea *CCMLandScape::GetFirstObjectiveArea(void)
+{
+	if(!mAreas.size())
+	{
+		return(NULL);
+	}
+	mAreasIt = mAreas.begin();
+
+	while (mAreasIt != mAreas.end())
+	{
+		// run through the areas to find the player area
+		if((*mAreasIt)->GetType() == AT_OBJECTIVE)
+		{
+			return (*mAreasIt);
+		}
+		mAreasIt++;
+	}
+	return(NULL);
+}
+
+CArea *CCMLandScape::GetPlayerArea(void)
+{ // do me
+	if(!mAreas.size())
+	{
+		return(NULL);
+	}
+	mAreasIt = mAreas.begin();
+
+	while (mAreasIt != mAreas.end())
+	{
+		// run through the areas to find the player area
+		if((*mAreasIt)->GetType() == AT_PLAYER)
+		{
+			return (*mAreasIt);
+		}
+		mAreasIt++;
+	}
+	return(NULL);
+}
+
+CArea *CCMLandScape::GetNextArea(void)
+{
+	mAreasIt++;
+	if(mAreasIt == mAreas.end())
+	{
+		return(NULL);
+	}
+	return (*mAreasIt);
+}
+
+CArea *CCMLandScape::GetNextObjectiveArea(void)
+{
+	mAreasIt++;
+
+	while (mAreasIt != mAreas.end())
+	{
+		// run through the areas to find the player area
+		if((*mAreasIt)->GetType() == AT_OBJECTIVE)
+		{
+			return (*mAreasIt);
+		}
+		mAreasIt++;
+	}
+	return(NULL);
+}
+
+bool CCMLandScape::AreaCollision(CArea *area, int *areaTypes, int areaTypeCount)
+{
+	CArea	*areas;
+	int		i;
+	float	segment;
+	bool	collision;
+
+	areas = GetFirstArea();
+	while(areas)
+	{
+		collision = false;
+
+		if(area->GetVillageID() == areas->GetVillageID())
+		{
+			// Check for being too close angularly
+			if(area->GetAngleDiff() && areas->GetAngleDiff())
+			{
+				segment = areas->GetAngle() - area->GetAngle();
+				if(segment < M_PI)
+				{
+					segment += (float)(2 * M_PI);
+				}						
+				if(segment > M_PI)
+				{
+					segment -= (float)(2 * M_PI);
+				}						
+				if(fabsf(segment) < areas->GetAngleDiff() + area->GetAngleDiff())
+				{
+					collision = true;
+				}
+			}
+		}
+
+		// Check for buildings being too close together
+		if(Distance(areas->GetPosition(), area->GetPosition()) < areas->GetRadius() + area->GetRadius())
+		{
+			collision = true;
+		}
+
+		if(collision)
+		{
+			// If no area type list was specified then all areas are fair game
+			if ( !areaTypes )
+			{
+				return true;
+			}
+
+			for(i = 0; i < areaTypeCount; i++)
+			{
+				if(areas->GetType() == areaTypes[i])
+				{
+					return(true);
+				}
+			}
+		}
+		areas = GetNextArea();
+	}
+	return(false);
+}
+
+void CCMLandScape::rand_seed(int seed)
+{
+	holdrand = seed;
+	Com_Printf("rand_seed = %d\n", holdrand);
+} 
+
+float CCMLandScape::flrand(float min, float max)
+{
+	float	result;
+
+	assert((max - min) < 32768);
+
+	holdrand = (holdrand * 214013L) + 2531011L;
+	result = (float)(holdrand >> 17);						// 0 - 32767 range
+	result = ((result * (max - min)) / 32768.0F) + min;
+//	Com_Printf("flrand: Seed = %d\n", holdrand);
+
+	return(result);
+}
+
+int CCMLandScape::irand(int min, int max)
+{
+	int		result;
+
+	assert((max - min) < 32768);
+
+	max++;
+	holdrand = (holdrand * 214013L) + 2531011L;
+	result = holdrand >> 17;
+	result = ((result * (max - min)) >> 15) + min;
+//	Com_Printf("irand: Seed = %d\n", holdrand);
+
+	return(result);
+}
+
+CCMLandScape::~CCMLandScape(void)
+{
+	if(mHeightMap) 
+	{ 
+		Z_Free(mHeightMap); 
+		mHeightMap = NULL;
+	}
+	if(mFlattenMap)
+	{
+		Z_Free(mFlattenMap);
+		mFlattenMap = NULL;
+	}
+	if(mPatchBrushData)
+	{
+		Z_Free(mPatchBrushData);
+		mPatchBrushData = NULL;
+	}
+	if(mPatches) 
+	{ 
+		Z_Free(mPatches); 
+		mPatches = NULL;
+	}
+	if (mRandomTerrain)
+	{
+		delete mRandomTerrain;
+	}
+
+	for(mAreasIt=mAreas.begin(); mAreasIt != mAreas.end(); mAreasIt++)
+	{
+		delete (*mAreasIt);
+	}
+
+	mAreas.clear();
+}
+
+class CCMLandScape *CM_InitTerrain(const char *configstring, thandle_t terrainId, bool server)
+{
+	CCMLandScape	*ls;
+
+	ls = new CCMLandScape(configstring, server);
+	ls->SetTerrainId(terrainId);
+
+	return(ls);
+}
+
+void CM_TerrainPatchIterate(const class CCMLandScape *landscape, void (*IterateFunc)( CCMPatch *, void * ), void *userdata)
+{
+	landscape->TerrainPatchIterate(IterateFunc, userdata);
+}
+
+float CM_GetWorldHeight(const CCMLandScape *landscape, vec3_t origin, const vec3pair_t bounds, bool aboveGround)
+{
+	return landscape->GetWorldHeight(origin, bounds, aboveGround);
+}
+
+void CM_FlattenArea(CCMLandScape *landscape, CArea *area, int height, bool save, bool forceHeight, bool smooth )
+{
+	landscape->FlattenArea(area, height, save, forceHeight, smooth );
+}
+
+void CM_CarveBezierCurve(CCMLandScape *landscape, int numCtls, vec3_t* ctls, int steps, int depth, int size )
+{
+	landscape->CarveBezierCurve(numCtls, ctls, steps, depth, size );
+}
+
+void CM_SaveArea(CCMLandScape *landscape, CArea *area)
+{
+	landscape->SaveArea(area);
+}
+
+float CM_FractionBelowLevel(CCMLandScape *landscape, CArea *area, int height)
+{
+	return(landscape->FractionBelowLevel(area, height));
+}
+
+bool CM_AreaCollision(class CCMLandScape *landscape, class CArea *area, int *areaTypes, int areaTypeCount)
+{
+	return(landscape->AreaCollision(area, areaTypes, areaTypeCount));
+}
+
+CArea *CM_GetFirstArea(CCMLandScape *landscape)
+{
+	return(landscape->GetFirstArea());
+}
+
+CArea *CM_GetFirstObjectiveArea(CCMLandScape *landscape)
+{
+	return(landscape->GetFirstObjectiveArea());
+}
+
+CArea *CM_GetPlayerArea(CCMLandScape *landscape)
+{
+	return(landscape->GetPlayerArea());
+}
+
+CArea *CM_GetNextArea(CCMLandScape *landscape)
+{
+	return(landscape->GetNextArea());
+}
+
+CArea *CM_GetNextObjectiveArea(CCMLandScape *landscape)
+{
+	return(landscape->GetNextObjectiveArea());
+}
+
+CRandomTerrain *CreateRandomTerrain(const char *config, CCMLandScape *landscape, byte *heightmap, int width, int height)
+{
+	CRandomTerrain	*RandomTerrain = 0;
+
+#ifndef PRE_RELEASE_DEMO
+	char			*ptr;
+	unsigned long	seed;
+
+	seed = strtoul(Info_ValueForKey(config, "seed"), &ptr, 10);
+
+	landscape->rand_seed(seed);
+	
+	RandomTerrain = new CRandomTerrain;
+	RandomTerrain->Init(landscape, heightmap, width, height);
+#endif // #ifndef PRE_RELEASE_DEMO
+
+/*
+	RandomTerrain->CreatePath(0, -1, 0, 9, 0.1, 0.5, 0.5, 0.5, 0.05, 0.08, 0.31, 0.1, 3);
+	RandomTerrain->CreatePath(1, 0, 0, 6, 0.5, 0.5, 0.9, 0.1, 0.08, 0.1, 0.31, 0.1, 0.9);
+	RandomTerrain->CreatePath(2, 0, 0, 6, 0.5, 0.5, 0.9, 0.9, 0.08, 0.1, 0.31, 0.1, 0.9);
+
+	RandomTerrain->Generate();
+*/
+
+	return RandomTerrain;
+}
+
+
+// end
+
+#ifdef _WIN32
+#pragma optimize("p", off)
+#endif
diff --git a/code/qcommon/cm_terrainmap.cpp b/code/qcommon/cm_terrainmap.cpp
new file mode 100644
index 0000000..d7b6b48
--- /dev/null
+++ b/code/qcommon/cm_terrainmap.cpp
@@ -0,0 +1,489 @@
+#include "../server/exe_headers.h"
+
+#include "cm_local.h"
+#include "cm_patch.h"
+#include "cm_landscape.h"
+#include "../game/genericparser2.h"
+//#include "image.h"
+//#include "../qcommon/q_imath.h"
+#include "cm_terrainmap.h"
+#include "cm_draw.h"
+#include "../png/png.h"
+
+static CTerrainMap	*TerrainMap = 0;
+
+void R_CreateAutomapImage( const char *name, const byte *pic, int width, int height, 
+					   qboolean mipmap, qboolean allowPicmip, qboolean allowTC, int glWrapClampMode );
+
+// simple function for getting a proper color for a side
+inline CPixel32 SideColor(int side)
+{
+	CPixel32 col(255,255,255);
+	switch (side)
+	{
+		default:
+			break;
+		case SIDE_BLUE:
+			col = CPixel32(0,0,192);
+			break;
+		case SIDE_RED:
+			col = CPixel32(192,0,0);
+			break;
+	}
+	return col;
+}
+
+CTerrainMap::CTerrainMap(CCMLandScape *landscape) :
+	mLandscape(landscape)
+{
+	ApplyBackground();
+	ApplyHeightmap();
+
+	CDraw32 draw;
+	draw.SetBuffer((CPixel32*) mImage);
+	draw.SetBufferSize(TM_WIDTH,TM_HEIGHT,TM_WIDTH);
+
+	// create version with paths and water shown
+	int x,y;
+	int water;
+	int land;
+
+	for (y=0; y<TM_HEIGHT; y++)
+		for (x=0; x<TM_WIDTH; x++)
+		{
+			CPixel32 cp = ((CPixel32*)mBufImage)[PIXPOS(x,y,TM_WIDTH)];
+			land = CLAMP(((255 - cp.a)*2)/3,0,255);
+			water = CLAMP((landscape->GetBaseWaterHeight() - cp.a)*4, 0, 255);
+			cp.a = 255;
+
+			if (x > TM_BORDER && x < (TM_WIDTH-TM_BORDER) &&
+				y > TM_BORDER && y < (TM_WIDTH-TM_BORDER))
+			{
+				cp = ALPHA_PIX (CPixel32(0,0,0), cp, land, 256-land);
+				if (water > 0)
+					cp = ALPHA_PIX (CPixel32(0,0,255), cp, water, 256-water);
+			}
+
+			draw.PutPix(x, y, cp);
+		}
+
+	// Load icons for symbols on map
+	GLenum	format;
+#ifdef _XBOX
+	int mipcount;
+
+	R_LoadImage("gfx/menus/rmg/start", (byte**)&mSymStart, &mSymStartWidth, &mSymStartHeight, &mipcount, &format);
+	R_LoadImage("gfx/menus/rmg/end", (byte**)&mSymEnd, &mSymEndWidth, &mSymEndHeight, &mipcount, &format);
+	R_LoadImage("gfx/menus/rmg/objective", (byte**)&mSymObjective, &mSymObjectiveWidth, &mSymObjectiveHeight, &mipcount, &format);
+
+	R_LoadImage("gfx/menus/rmg/building", (byte**)&mSymBld, &mSymBldWidth, &mSymBldHeight, &mipcount, &format);
+#else
+	R_LoadImage("gfx/menus/rmg/start", (byte**)&mSymStart, &mSymStartWidth, &mSymStartHeight, &format);
+	R_LoadImage("gfx/menus/rmg/end", (byte**)&mSymEnd, &mSymEndWidth, &mSymEndHeight, &format);
+	R_LoadImage("gfx/menus/rmg/objective", (byte**)&mSymObjective, &mSymObjectiveWidth, &mSymObjectiveHeight, &format);
+
+	R_LoadImage("gfx/menus/rmg/building", (byte**)&mSymBld, &mSymBldWidth, &mSymBldHeight, &format);
+#endif
+}
+
+CTerrainMap::~CTerrainMap()
+{
+	if (mSymStart)
+	{
+		Z_Free(mSymStart);
+		mSymStart = NULL;
+	}
+
+	if (mSymEnd)
+	{
+		Z_Free(mSymEnd);
+		mSymEnd = NULL;
+	}
+
+	if (mSymBld)
+	{
+		Z_Free(mSymBld);
+		mSymBld = NULL;
+	}
+
+	if (mSymObjective)
+	{
+		Z_Free(mSymObjective);
+		mSymObjective = NULL;
+	}
+
+	CDraw32::CleanUp(); 
+}
+
+void CTerrainMap::ApplyBackground(void)
+{
+	int		x, y;
+	byte	*outPos;
+	float	xRel, yRel, xInc, yInc;
+	byte	*backgroundImage;
+	int		backgroundWidth, backgroundHeight, backgroundDepth;
+	int		pos;
+	GLenum	format;
+
+	memset(mImage, 255, sizeof(mBufImage));
+//	R_LoadImage("textures\\kamchatka\\ice", &backgroundImage, &backgroundWidth, &backgroundHeight, &format);0
+	backgroundDepth = 4;
+
+#ifdef _XBOX
+	int mipcount;
+
+	R_LoadImage("gfx\\menus\\rmg\\01_bg", &backgroundImage, &backgroundWidth, &backgroundHeight, &mipcount, &format);
+#else
+	R_LoadImage("gfx\\menus\\rmg\\01_bg", &backgroundImage, &backgroundWidth, &backgroundHeight, &format);
+#endif
+	if (backgroundImage)
+	{
+		outPos = (byte *)mBufImage;
+		xInc = (float)backgroundWidth / (float)TM_WIDTH;
+		yInc = (float)backgroundHeight / (float)TM_HEIGHT;
+
+		yRel = 0.0;
+		for(y=0;y<TM_HEIGHT;y++)
+		{
+			xRel = 0.0;
+			for(x=0;x<TM_WIDTH;x++)
+			{
+				pos = ((((int)yRel)*backgroundWidth) + ((int)xRel)) * 4;
+				*outPos = backgroundImage[pos++];
+				outPos++;
+				*outPos = backgroundImage[pos++];
+				outPos++;
+				*outPos = backgroundImage[pos];
+				outPos+=2;
+				xRel += xInc;
+			}
+			yRel += yInc;
+		}
+		Z_Free(backgroundImage);
+	}
+}
+
+void CTerrainMap::ApplyHeightmap(void)
+{
+	int			x, y;
+	byte		*inPos = mLandscape->GetHeightMap();
+	int			width = mLandscape->GetRealWidth();
+	int			height = mLandscape->GetRealHeight();
+	byte		*outPos;
+	unsigned	tempColor;
+	float		xRel, yRel, xInc, yInc;
+	int			count;
+
+	outPos = (byte *)mBufImage;
+	outPos += (((TM_BORDER * TM_WIDTH) + TM_BORDER) * 4);
+	xInc = (float)width / (float)(TM_REAL_WIDTH);
+	yInc = (float)height / (float)(TM_REAL_HEIGHT);
+	
+	// add in height map as alpha 
+	yRel = 0.0;
+	for(y=0;y<TM_REAL_HEIGHT;y++)
+	{
+		// x is flipped!
+		xRel = width;
+		for(x=0;x<TM_REAL_WIDTH;x++)
+		{
+			count = 1;
+			tempColor = inPos[(((int)yRel)*width) + ((int)xRel)];
+			if (yRel >= 1.0)
+			{
+				tempColor += inPos[(((int)(yRel-0.5))*width) + ((int)xRel)];
+				count++;
+			}
+			if (yRel <= height-2)
+			{
+				tempColor += inPos[(((int)(yRel+0.5))*width) + ((int)xRel)];
+				count++;
+			}
+			if (xRel >= 1.0)
+			{
+				tempColor += inPos[(((int)(yRel))*width) + ((int)(xRel-0.5))];
+				count++;
+			}
+			if (xRel <= width-2)
+			{
+				tempColor += inPos[(((int)(yRel))*width) + ((int)(xRel+0.5))];
+				count++;
+			}
+			tempColor /= count;
+
+			outPos[3] = tempColor;
+			outPos += 4;
+
+			// x is flipped!
+			xRel -= xInc;
+		}
+		outPos += TM_BORDER * 4 * 2;
+
+		yRel += yInc;
+	}
+}
+
+// Convert position in game coords to automap coords
+void CTerrainMap::ConvertPos(int& x, int& y)
+{
+	x = ((x - mLandscape->GetMins()[0]) / mLandscape->GetSize()[0]) * TM_REAL_WIDTH;
+	y = ((y - mLandscape->GetMins()[1]) / mLandscape->GetSize()[1]) * TM_REAL_HEIGHT;
+
+	// x is flipped!
+	x = TM_REAL_WIDTH - x - 1;
+
+	// border
+	x += TM_BORDER;
+	y += TM_BORDER;
+}
+
+void CTerrainMap::AddStart(int x, int y, int side)
+{
+	ConvertPos(x, y);
+
+	CDraw32 draw;
+	draw.BlitColor(x-mSymStartWidth/2, y-mSymStartHeight/2, mSymStartWidth, mSymStartHeight, 
+			  (CPixel32*)mSymStart, 0, 0, mSymStartWidth, SideColor(side));
+}
+
+void CTerrainMap::AddEnd(int x, int y, int side)
+{
+	ConvertPos(x, y);
+
+	CDraw32 draw;
+	draw.BlitColor(x-mSymEndWidth/2, y-mSymEndHeight/2, mSymEndWidth, mSymEndHeight, 
+			  (CPixel32*)mSymEnd, 0, 0, mSymEndWidth, SideColor(side));
+}
+
+void CTerrainMap::AddObjective(int x, int y, int side)
+{
+	ConvertPos(x, y);
+
+	CDraw32 draw;
+	draw.BlitColor(x-mSymObjectiveWidth/2, y-mSymObjectiveHeight/2, mSymObjectiveWidth, mSymObjectiveHeight, 
+			  (CPixel32*)mSymObjective, 0, 0, mSymObjectiveWidth, SideColor(side));
+}
+
+void CTerrainMap::AddBuilding(int x, int y, int side)
+{
+	ConvertPos(x, y);
+
+	CDraw32 draw;
+	draw.BlitColor(x-mSymBldWidth/2, y-mSymBldHeight/2, mSymBldWidth, mSymBldHeight, 
+			  (CPixel32*)mSymBld, 0, 0, mSymBldWidth, SideColor(side));
+}
+
+void CTerrainMap::AddNPC(int x, int y, bool friendly)
+{
+	ConvertPos(x, y);
+
+	CDraw32 draw;
+	if (friendly)
+		draw.DrawCircle(x,y,3, CPixel32(0,192,0), CPixel32(0,0,0,0));
+	else
+		draw.DrawCircle(x,y,3, CPixel32(192,0,0), CPixel32(0,0,0,0));
+}
+
+void CTerrainMap::AddNode(int x, int y)
+{
+	ConvertPos(x, y);
+
+	CDraw32 draw;
+	draw.DrawCircle(x,y,20, CPixel32(255,255,255), CPixel32(0,0,0,0));
+}
+
+void CTerrainMap::AddWallRect(int x, int y, int side)
+{
+	ConvertPos(x, y);
+
+	CDraw32 draw;
+	switch (side)
+	{
+		default:
+			draw.DrawBox(x-1,y-1,3,3,CPixel32(192,192,192,128));
+			break;
+		case SIDE_BLUE:
+			draw.DrawBox(x-1,y-1,3,3,CPixel32(0,0,192,128));
+			break;
+		case SIDE_RED:
+			draw.DrawBox(x-1,y-1,3,3,CPixel32(192,0,0,128));
+			break;
+	}
+}
+
+void CTerrainMap::AddPlayer(vec3_t origin, vec3_t angles)
+{
+	// draw player start on automap
+	CDraw32 draw;
+
+	vec3_t up;
+	vec3_t pt[4] = {{0,0,0},{-5,-5,0},{10,0,0},{-5,5,0}};
+	vec3_t p;
+	int x,y,i;
+	float facing;
+	POINT poly[4];
+
+	facing = angles[1];
+	
+	up[0] = 0;
+	up[1] = 0;
+	up[2] = 1;
+
+	x = (int)origin[0];
+	y = (int)origin[1];
+	ConvertPos(x, y);
+	x++; y++;
+
+	for (i=0; i<4; i++)
+	{
+		RotatePointAroundVector( p, up, pt[i], facing );
+		poly[i].x = (int)(-p[0] + x);
+		poly[i].y = (int)(p[1] + y);
+	}
+
+	// draw arrowhead shadow
+	draw.DrawPolygon(4, poly, CPixel32(0,0,0,128), CPixel32(0,0,0,128));
+
+	// draw arrowhead
+	for (i=0; i<4; i++)
+	{
+		poly[i].x--;
+		poly[i].y--;
+	}
+	draw.DrawPolygon(4, poly, CPixel32(255,255,255), CPixel32(255,255,255));
+}
+
+void CTerrainMap::Upload(vec3_t player_origin, vec3_t player_angles)
+{
+	CDraw32		draw;
+
+	// copy completed map to mBufImage
+	draw.SetBuffer((CPixel32*) mBufImage);
+	draw.SetBufferSize(TM_WIDTH,TM_HEIGHT,TM_WIDTH);
+
+	draw.Blit(0, 0, TM_WIDTH, TM_HEIGHT, 
+			  (CPixel32*)mImage, 0, 0, TM_WIDTH);
+
+	// now draw player's location on map
+	if (player_origin)
+	{
+		AddPlayer(player_origin, player_angles);
+	}
+
+	draw.SetAlphaBuffer(255);
+	
+	R_CreateAutomapImage("*automap", (unsigned char *)draw.buffer, TM_WIDTH, TM_HEIGHT, qfalse, qfalse, qtrue, qfalse);
+
+	draw.SetBuffer((CPixel32*) mImage);
+}
+
+void CTerrainMap::SaveImageToDisk(const char * terrainName, const char * missionName, const char * seed)
+{
+	//ri.COM_SavePNG(va("save/%s_%s_%s.png", terrainName, missionName, seed), 
+	//		(unsigned char *)mImage, TM_WIDTH, TM_HEIGHT, 4);
+	//rww - Use JPG here? This function seems to be only for debugging anyway.
+//	PNG_Save(va("save/%s_%s_%s.png", terrainName, missionName, seed), 
+//			(unsigned char *)mImage, TM_WIDTH, TM_HEIGHT, 4);
+}
+
+void CM_TM_Create(CCMLandScape *landscape)
+{
+	if (TerrainMap)
+	{
+		CM_TM_Free();
+	}
+
+	TerrainMap = new CTerrainMap(landscape);
+}
+
+void CM_TM_Free(void)
+{
+	if (TerrainMap)
+	{
+		delete TerrainMap;
+		TerrainMap = 0;
+	}
+}
+
+void CM_TM_AddStart(int x, int y, int side)
+{
+	if (TerrainMap)
+	{
+		TerrainMap->AddStart(x, y, side);
+	}
+}
+
+void CM_TM_AddEnd(int x, int y, int side)
+{
+	if (TerrainMap)
+	{
+		TerrainMap->AddEnd(x, y, side);
+	}
+}
+
+void CM_TM_AddObjective(int x, int y, int side)
+{
+	if (TerrainMap)
+	{
+		TerrainMap->AddObjective(x, y, side);
+	}
+}
+
+void CM_TM_AddNPC(int x, int y, bool friendly)
+{
+	if (TerrainMap)
+	{
+		TerrainMap->AddNPC(x, y, friendly);
+	}
+}
+
+void CM_TM_AddNode(int x, int y)
+{
+	if (TerrainMap)
+	{
+		TerrainMap->AddNode(x, y);
+	}
+}
+
+void CM_TM_AddBuilding(int x, int y, int side)
+{
+	if (TerrainMap)
+	{
+		TerrainMap->AddBuilding(x, y, side);
+	}
+}
+
+void CM_TM_AddWallRect(int x, int y, int side)
+{
+	if (TerrainMap)
+	{
+		TerrainMap->AddWallRect(x, y, side);
+	}
+}
+
+void CM_TM_Upload(vec3_t player_origin, vec3_t player_angles)
+{
+	if (TerrainMap)
+	{
+		TerrainMap->Upload(player_origin, player_angles);
+	}
+}
+
+void CM_TM_SaveImageToDisk(const char * terrainName, const char * missionName, const char * seed)
+{
+	if (TerrainMap)
+	{	// write out automap
+		TerrainMap->SaveImageToDisk(terrainName, missionName, seed);
+	}
+}
+
+void CM_TM_ConvertPosition(int &x, int &y, int Width, int Height)
+{
+	if (TerrainMap)
+	{
+		TerrainMap->ConvertPos(x, y);
+		x = x * Width / TM_WIDTH;
+		y = y * Height / TM_HEIGHT;
+	}
+}
+
diff --git a/code/qcommon/cm_terrainmap.h b/code/qcommon/cm_terrainmap.h
new file mode 100644
index 0000000..b1ea0b5
--- /dev/null
+++ b/code/qcommon/cm_terrainmap.h
@@ -0,0 +1,77 @@
+#pragma once
+#if !defined(CM_TERRAINMAP_H_INC)
+#define CM_TERRAINMAP_H_INC
+
+#define TM_WIDTH		512
+#define TM_HEIGHT		512
+#define	TM_BORDER		16
+#define TM_REAL_WIDTH	(TM_WIDTH-TM_BORDER-TM_BORDER)
+#define TM_REAL_HEIGHT	(TM_HEIGHT-TM_BORDER-TM_BORDER)
+
+class CTerrainMap
+{
+private:
+	byte			mImage[TM_HEIGHT][TM_WIDTH][4];	// image to output
+	byte			mBufImage[TM_HEIGHT][TM_WIDTH][4];	// src data for image, color and bump
+
+	byte*			mSymBld;
+	int				mSymBldWidth;
+	int				mSymBldHeight;
+
+	byte*			mSymStart;
+	int				mSymStartWidth;
+	int				mSymStartHeight;
+
+	byte*			mSymEnd;
+	int				mSymEndWidth;
+	int				mSymEndHeight;
+
+	byte*			mSymObjective;
+	int				mSymObjectiveWidth;
+	int				mSymObjectiveHeight;
+
+	CCMLandScape	*mLandscape;
+
+	void	ApplyBackground(void);
+	void	ApplyHeightmap(void);
+
+public:
+	CTerrainMap(CCMLandScape *landscape);
+	~CTerrainMap();
+	
+	void	ConvertPos(int& x, int& y);
+	void	AddBuilding(int x, int y, int side);
+	void	AddStart(int x, int y, int side);
+	void	AddEnd(int x, int y, int side);
+	void	AddObjective(int x, int y, int side);
+	void	AddNPC(int x, int y, bool friendly);
+	void	AddWallRect(int x, int y, int side);
+	void	AddNode(int x, int y);
+	void	AddPlayer(vec3_t origin, vec3_t angles);
+
+	void	Upload(vec3_t player_origin, vec3_t player_angles);
+	void	SaveImageToDisk(const char * terrainName, const char * missionName, const char * seed);
+};
+
+enum
+{
+	SIDE_NONE =0,
+	SIDE_BLUE =1,
+	SIDE_RED = 2
+};
+
+void	CM_TM_Create(CCMLandScape *landscape);
+void	CM_TM_Free(void);
+void	CM_TM_AddStart(int x, int y, int side = SIDE_NONE);
+void	CM_TM_AddEnd(int x, int y, int side = SIDE_NONE);
+void	CM_TM_AddObjective(int x, int y, int side = SIDE_NONE);
+void	CM_TM_AddNPC(int x, int y, bool friendly);
+void	CM_TM_AddWallRect(int x, int y, int side = SIDE_NONE);
+void	CM_TM_AddNode(int x, int y);
+void	CM_TM_AddBuilding(int x, int y, int side = SIDE_NONE);
+void	CM_TM_Upload(vec3_t player_origin, vec3_t player_angles);
+void	CM_TM_SaveImageToDisk(const char * terrainName, const char * missionName, const char * seed);
+void	CM_TM_ConvertPosition(int &x, int &y, int Width, int Height);
+
+#endif CM_TERRAINMAP_H_INC
+
diff --git a/code/qcommon/cm_test.cpp b/code/qcommon/cm_test.cpp
new file mode 100644
index 0000000..cf5c75c
--- /dev/null
+++ b/code/qcommon/cm_test.cpp
@@ -0,0 +1,793 @@
+#include "cm_local.h"
+#pragma warning (push, 3)	//go back down to 3 for the stl include
+#pragma warning (pop)
+using namespace std;
+
+#ifdef _XBOX
+#include "../renderer/tr_local.h"
+#endif
+
+class CPoint
+{
+public:
+	float x,y,z;
+	CPoint(float _x,float _y,float _z):
+		x(_x),
+		y(_y),
+		z(_z)
+	{
+	}
+	bool operator== (const CPoint& _P) const {return((x==_P.x)&&(y==_P.y)&&(z==_P.z));}
+};
+/*
+class CPointComparator
+{
+public:
+	bool operator()(const CPoint& _A,const CPoint& _B) const {return((_A.x==_B.x)&&(_A.y==_B.y)&&(_A.z==_B.z));}
+};
+*/
+
+// Fixed memory version of pointToLeaf that doesn't use STL
+// cuts down on memory fragmentation
+struct PointAndLeaf
+{
+	// Default constructor for array construction below
+	PointAndLeaf() : point(0, 0, 0), leaf(0) { }
+
+	CPoint	point;
+	int		leaf;
+};
+
+// I think it is a patholoically bad idea to do a 64 item linear search for a cache,
+// so I reduced this to something more manageable.
+// hopefully getting rid of water checks on maps with no water will leave us less
+// reliant on this cache. -gwg
+
+#define MAX_POINTS_TO_LEAVES	16
+
+static PointAndLeaf	pointToLeaf[MAX_POINTS_TO_LEAVES];
+static int	oldestPointToLeaf = 0, sizePointToLeaf = 0;
+
+//static hlist<pair<CPoint,int> >				pointToLeaf;
+//static hlist<pair<CPoint,int> >				pointToContents;
+
+void CM_CleanLeafCache(void)
+{
+	oldestPointToLeaf = sizePointToLeaf = 0;
+//	pointToLeaf.clear();
+#if 0 // VVFIXME
+	hlist<pair<CPoint,int> >::iterator l;
+	for(l=pointToLeaf.begin();l!=pointToLeaf.end();l++)
+	{
+		pointToLeaf.erase(l);
+	}
+#endif
+/*
+	for(l=pointToContents.begin();l!=pointToContents.end();l++)
+	{
+		pointToContents.erase(l);
+	}
+*/
+}
+
+/*
+==================
+CM_PointLeafnum_r
+
+==================
+*/
+int CM_PointLeafnum_r( const vec3_t p, int num, clipMap_t *local ) {
+	float		d;
+	cNode_t		*node;
+	cplane_t	*plane;
+
+#ifdef _XBOX
+	if(!tr.world) {
+		return 0;
+	}
+#endif
+
+	while (num >= 0)
+	{
+		node = local->nodes + num;
+#ifdef _XBOX
+		plane = cmg.planes + tr.world->nodes[num].planeNum;
+#else
+		plane = node->plane;
+#endif
+		
+		if (plane->type < 3)
+			d = p[plane->type] - plane->dist;
+		else
+			d = DotProduct (plane->normal, p) - plane->dist;
+		if (d < 0)
+			num = node->children[1];
+		else
+			num = node->children[0];
+	}
+
+	c_pointcontents++;		// optimize counter
+
+	return -1 - num;
+}
+
+int CM_PointLeafnum( const vec3_t p ) {
+	if ( !cmg.numNodes ) {	// map not loaded
+		return 0;
+	}
+	return CM_PointLeafnum_r (p, 0, &cmg);
+}
+
+
+/*
+======================================================================
+
+LEAF LISTING
+
+======================================================================
+*/
+
+
+void CM_StoreLeafs( leafList_t *ll, int nodenum ) {
+	int		leafNum;
+
+	leafNum = -1 - nodenum;
+
+	// store the lastLeaf even if the list is overflowed
+	if ( cmg.leafs[ leafNum ].cluster != -1 ) {
+		ll->lastLeaf = leafNum;
+	}
+
+	if ( ll->count >= ll->maxcount) {
+		ll->overflowed = qtrue;
+		return;
+	}
+	ll->list[ ll->count++ ] = leafNum;
+}
+
+void CM_StoreBrushes( leafList_t *ll, int nodenum ) {
+	int			i, k;
+	int			leafnum;
+	int			brushnum;
+	cLeaf_t		*leaf;
+	cbrush_t	*b;
+
+	leafnum = -1 - nodenum;
+
+	leaf = &cmg.leafs[leafnum];
+
+	for ( k = 0 ; k < leaf->numLeafBrushes ; k++ ) {
+		brushnum = cmg.leafbrushes[leaf->firstLeafBrush+k];
+		b = &cmg.brushes[brushnum];
+		if ( b->checkcount == cmg.checkcount ) {
+			continue;	// already checked this brush in another leaf
+		}
+		b->checkcount = cmg.checkcount;
+		for ( i = 0 ; i < 3 ; i++ ) {
+			if ( b->bounds[0][i] >= ll->bounds[1][i] || b->bounds[1][i] <= ll->bounds[0][i] ) {
+				break;
+			}
+		}
+		if ( i != 3 ) {
+			continue;
+		}
+		if ( ll->count >= ll->maxcount) {
+			ll->overflowed = qtrue;
+			return;
+		}
+		((cbrush_t **)ll->list)[ ll->count++ ] = b;
+	}
+#if 0
+	// store patches?
+	for ( k = 0 ; k < leaf->numLeafSurfaces ; k++ ) {
+		patch = cmg.surfaces[ cmg.leafsurfaces[ leaf->firstleafsurface + k ] ];
+		if ( !patch ) {
+			continue;
+		}
+	}
+#endif
+}
+
+/*
+=============
+CM_BoxLeafnums
+
+Fills in a list of all the leafs touched
+=============
+*/
+void CM_BoxLeafnums_r( leafList_t *ll, int nodenum ) {
+	cplane_t	*plane;
+	cNode_t		*node;
+	int			s;
+
+#ifdef _XBOX
+	if(!tr.world) {
+		return;
+	}
+#endif
+
+	while (1) {
+		if (nodenum < 0) {
+			ll->storeLeafs( ll, nodenum );
+			return;
+		}
+	
+		node = &cmg.nodes[nodenum];
+
+#ifdef _XBOX
+		plane = cmg.planes + tr.world->nodes[nodenum].planeNum;
+#else
+		plane = node->plane;
+#endif
+		s = BoxOnPlaneSide( ll->bounds[0], ll->bounds[1], plane );
+		if (s == 1) {
+			nodenum = node->children[0];
+		} else if (s == 2) {
+			nodenum = node->children[1];
+		} else {
+			// go down both
+			CM_BoxLeafnums_r( ll, node->children[0] );
+			nodenum = node->children[1];
+		}
+
+	}
+}
+
+/*
+==================
+CM_BoxLeafnums
+==================
+*/
+int	CM_BoxLeafnums( const vec3_t mins, const vec3_t maxs, int *boxList, int listsize, int *lastLeaf) {
+	leafList_t	ll;
+
+	cmg.checkcount++;
+
+	VectorCopy( mins, ll.bounds[0] );
+	VectorCopy( maxs, ll.bounds[1] );
+	ll.count = 0;
+	ll.maxcount = listsize;
+	ll.list = boxList;
+	ll.storeLeafs = CM_StoreLeafs;
+	ll.lastLeaf = 0;
+	ll.overflowed = qfalse;
+
+	CM_BoxLeafnums_r( &ll, 0 );
+
+	*lastLeaf = ll.lastLeaf;
+	return ll.count;
+}
+
+/*
+==================
+CM_BoxBrushes
+==================
+*/
+int CM_BoxBrushes( const vec3_t mins, const vec3_t maxs, cbrush_t **boxlist, int listsize ) {
+	leafList_t	ll;
+
+	cmg.checkcount++;
+
+	VectorCopy( mins, ll.bounds[0] );
+	VectorCopy( maxs, ll.bounds[1] );
+	ll.count = 0;
+	ll.maxcount = listsize;
+	ll.list = (int *)boxlist;
+	ll.storeLeafs = CM_StoreBrushes;
+	ll.lastLeaf = 0;
+	ll.overflowed = qfalse;
+	
+	CM_BoxLeafnums_r( &ll, 0 );
+
+	return ll.count;
+}
+
+
+//====================================================================
+
+
+/*
+==================
+CM_PointContents
+
+==================
+*/
+
+#if 1
+
+int CM_PointContents( const vec3_t p, clipHandle_t model ) {
+	int			leafnum=0;
+	int			i, k;
+	int			brushnum;
+	cLeaf_t		*leaf;
+	cbrush_t	*b;
+	int			contents;
+	float		d;
+	cmodel_t	*clipm;
+	clipMap_t	*local;
+
+	if (!cmg.numNodes) {	// map not loaded
+		return 0;
+	}
+
+	if ( model ) {
+		clipm = CM_ClipHandleToModel( model, &local );
+		leaf = &clipm->leaf;
+	} 
+	else
+	{
+		local = &cmg;
+		CPoint pt(p[0],p[1],p[2]);
+/*		map<CPoint,int,CPointComparator>::iterator l=pointToLeaf.find(pt);
+		if(l!=pointToLeaf.end())
+		{
+			leafnum=(*l).second;
+		}
+		else
+		{
+			if(pointToLeaf.size()>=64)
+			{
+				pointToLeaf.clear();
+				Com_Printf("Cleared cache\n");
+			}
+			leafnum=CM_PointLeafnum_r(p, 0);
+			pointToLeaf[pt]=leafnum;
+		}*/
+
+		int l = 0;
+		for ( ; l < sizePointToLeaf; ++l)
+		{
+			if (pointToLeaf[l].point == pt)
+			{
+				leafnum = pointToLeaf[l].leaf;
+				break;
+			}
+		}
+
+		if (l == sizePointToLeaf)
+		{ // Didn't find it
+			if (sizePointToLeaf < MAX_POINTS_TO_LEAVES)
+			{ // We're adding a new one, rather than replacing
+				sizePointToLeaf++;
+			}
+			else
+			{ // Put it in the "oldest" slot
+				l = oldestPointToLeaf++;
+				oldestPointToLeaf &= (MAX_POINTS_TO_LEAVES-1);
+			}
+
+			leafnum = CM_PointLeafnum_r(p, 0, local);
+			pointToLeaf[l].leaf = leafnum;
+			pointToLeaf[l].point = pt;
+		}
+
+		/*
+		hlist<pair<CPoint,int> >::iterator l;
+		for(l=pointToLeaf.begin();l!=pointToLeaf.end();l++)
+		{
+			if((*l).first==pt)
+			{
+				leafnum=(*l).second;
+				break;
+			}
+		}
+		if(l==pointToLeaf.end())
+		{
+			if(pointToLeaf.size()>=64)
+			{
+				pointToLeaf.pop_back();
+			}
+			leafnum=CM_PointLeafnum_r(p, 0, local);
+			pointToLeaf.push_front(pair<CPoint,int>(pt,leafnum));
+		}
+		*/
+		leaf = &local->leafs[leafnum];
+	}
+
+	contents = 0;
+	for (k=0 ; k<leaf->numLeafBrushes ; k++) {
+		brushnum = local->leafbrushes[leaf->firstLeafBrush+k];
+		b = &local->brushes[brushnum];
+
+		// see if the point is in the brush
+		for ( i = 0 ; i < b->numsides ; i++ ) {
+#ifdef _XBOX
+			d = DotProduct( p, 
+					cmg.planes[b->sides[i].planeNum.GetValue()].normal );
+#else
+			d = DotProduct( p, b->sides[i].plane->normal );
+#endif
+// FIXME test for Cash
+//			if ( d >= b->sides[i].plane->dist ) {
+#ifdef _XBOX
+			if ( d > cmg.planes[b->sides[i].planeNum.GetValue()].dist ) {
+#else
+			if ( d > b->sides[i].plane->dist ) {
+#endif
+				break;
+			}
+		}
+
+		if ( i == b->numsides ) {
+			contents |= b->contents;
+#ifndef _XBOX	// Removing terrain from Xbox
+			if(cmg.landScape && (contents & CONTENTS_TERRAIN) )
+			{
+				if(p[2] < cmg.landScape->GetWaterHeight())
+				{
+					contents |= cmg.landScape->GetWaterContents();
+				}
+			}
+#endif
+		}
+	}
+
+	return contents;
+}
+
+#else
+
+int CM_PointContents( const vec3_t p, clipHandle_t model ) {
+	int			leafnum=0;
+	int			i, k;
+	int			brushnum;
+	cLeaf_t		*leaf;
+	cbrush_t	*b;
+	int			contents;
+	float		d;
+	cmodel_t	*clipm;
+
+	if (!cmg.numNodes) {	// map not loaded
+		return 0;
+	}
+
+	CPoint pt(p[0],p[1],p[2]);
+	if ( model ) 
+	{
+		clipm = CM_ClipHandleToModel( model );
+		leaf = &clipm->leaf;
+	} 
+	else
+	{
+		hlist<pair<CPoint,int> >::iterator l;
+		for(l=pointToContents.begin();l!=pointToContents.end();l++)
+		{
+			if((*l).first==pt)
+			{
+				// Breakout early.
+				return((*l).second);
+			}
+		}
+
+		leafnum=CM_PointLeafnum_r(p, 0);
+		leaf = &cmg.leafs[leafnum];
+	}
+
+	contents = 0;
+	for (k=0 ; k<leaf->numLeafBrushes ; k++) 
+	{
+		brushnum = cmg.leafbrushes[leaf->firstLeafBrush+k];
+		b = &cmg.brushes[brushnum];
+
+		// see if the point is in the brush
+		for ( i = 0 ; i < b->numsides ; i++ ) 
+		{
+			d = DotProduct( p, b->sides[i].plane->normal );
+			// FIXME test for Cash
+//			if ( d >= b->sides[i].plane->dist ) {
+			if ( d > b->sides[i].plane->dist ) 
+			{
+				break;
+			}
+		}
+
+		if ( i == b->numsides ) 
+		{
+			contents |= b->contents;
+		}
+	}
+
+	// Cache the result for next time.
+	if(!model)
+	{
+		if(pointToContents.size()>=64)
+		{
+			pointToContents.pop_back();
+		}
+		pointToContents.push_front(pair<CPoint,int>(pt,contents));
+	}
+
+	return contents;
+}
+
+#endif
+/*
+==================
+CM_TransformedPointContents
+
+Handles offseting and rotation of the end points for moving and
+rotating entities
+==================
+*/
+int	CM_TransformedPointContents( const vec3_t p, clipHandle_t model, const vec3_t origin, const vec3_t angles) {
+	vec3_t		p_l;
+	vec3_t		temp;
+	vec3_t		forward, right, up;
+
+	// subtract origin offset
+	VectorSubtract (p, origin, p_l);
+
+	// rotate start and end into the models frame of reference
+	if ( model != BOX_MODEL_HANDLE && 
+	(angles[0] || angles[1] || angles[2]) )
+	{
+		AngleVectors (angles, forward, right, up);
+
+		VectorCopy (p_l, temp);
+		p_l[0] = DotProduct (temp, forward);
+		p_l[1] = -DotProduct (temp, right);
+		p_l[2] = DotProduct (temp, up);
+	}
+
+	return CM_PointContents( p_l, model );
+}
+
+
+
+/*
+===============================================================================
+
+PVS
+
+===============================================================================
+*/
+
+#ifdef _XBOX
+extern trGlobals_t tr;
+const byte	*CM_ClusterPVS (int cluster) {
+	if (cluster < 0 || cluster >= cmg.numClusters || !cmg.vised ) {
+		return NULL;
+	}
+
+	return cmg.visibility->Decompress(cluster * cmg.clusterBytes,
+			cmg.numClusters);
+}
+#else
+byte	*CM_ClusterPVS (int cluster) {
+	if (cluster < 0 || cluster >= cmg.numClusters || !cmg.vised ) {
+		return cmg.visibility;
+	}
+
+	return cmg.visibility + cluster * cmg.clusterBytes;
+}
+#endif
+
+
+/*
+===============================================================================
+
+AREAPORTALS
+
+===============================================================================
+*/
+
+#ifdef _XBOX
+void CM_FloodArea_r( int areaNum, int floodnum) {
+	int		i;
+	cArea_t *area;
+	int		*con;
+
+	area = &cmg.areas[ areaNum ];
+
+	if ( area->floodvalid == cmg.floodvalid ) {
+		if (area->floodnum == floodnum)
+			return;
+		Com_Error (ERR_DROP, "FloodArea_r: reflooded");
+	}
+
+	area->floodnum = floodnum;
+	area->floodvalid = cmg.floodvalid;
+	con = cmg.areaPortals + areaNum * cmg.numAreas;
+	for ( i=0 ; i < cmg.numAreas  ; i++ ) {
+		if ( con[i] > 0 ) {
+			CM_FloodArea_r( i, floodnum );
+		}
+	}
+}
+#else  // _XBOX
+
+void CM_FloodArea_r( int areaNum, int floodnum, clipMap_t &cm) {
+	int		i;
+	cArea_t *area;
+	int		*con;
+
+	area = &cmg.areas[ areaNum ];
+
+	if ( area->floodvalid == cmg.floodvalid ) {
+		if (area->floodnum == floodnum)
+			return;
+		Com_Error (ERR_DROP, "FloodArea_r: reflooded");
+	}
+
+	area->floodnum = floodnum;
+	area->floodvalid = cmg.floodvalid;
+	con = cmg.areaPortals + areaNum * cmg.numAreas;
+	for ( i=0 ; i < cmg.numAreas  ; i++ ) {
+		if ( con[i] > 0 ) {
+			CM_FloodArea_r( i, floodnum, cm );
+		}
+	}
+}
+#endif // XBOX
+
+/*
+====================
+CM_FloodAreaConnections
+
+====================
+*/
+#ifdef _XBOX
+void	CM_FloodAreaConnections( void ) {
+	int		i;
+	cArea_t	*area;
+	int		floodnum;
+
+	// all current floods are now invalid
+	cmg.floodvalid++;
+	floodnum = 0;
+
+	for (i = 0 ; i < cmg.numAreas ; i++) {
+		area = &cmg.areas[i];
+		if (area->floodvalid == cmg.floodvalid) {
+			continue;		// already flooded into
+		}
+		floodnum++;
+		CM_FloodArea_r (i, floodnum);
+	}
+
+}
+#else // _XBOX
+void	CM_FloodAreaConnections( clipMap_t &cm ) {
+	int		i;
+	cArea_t	*area;
+	int		floodnum;
+
+	// all current floods are now invalid
+	cmg.floodvalid++;
+	floodnum = 0;
+
+	for (i = 0 ; i < cmg.numAreas ; i++) {
+		area = &cmg.areas[i];
+		if (area->floodvalid == cmg.floodvalid) {
+			continue;		// already flooded into
+		}
+		floodnum++;
+		CM_FloodArea_r (i, floodnum, cm);
+	}
+
+}
+#endif // _XBOX
+
+/*
+====================
+CM_AdjustAreaPortalState
+
+====================
+*/
+void	CM_AdjustAreaPortalState( int area1, int area2, qboolean open ) {
+	if ( area1 < 0 || area2 < 0 ) {
+		return;
+	}
+
+	if ( area1 >= cmg.numAreas || area2 >= cmg.numAreas ) {
+		Com_Error (ERR_DROP, "CM_ChangeAreaPortalState: bad area number");
+	}
+
+	if ( open ) {
+		cmg.areaPortals[ area1 * cmg.numAreas + area2 ]++;
+		cmg.areaPortals[ area2 * cmg.numAreas + area1 ]++;
+	} else {
+		cmg.areaPortals[ area1 * cmg.numAreas + area2 ]--;
+		cmg.areaPortals[ area2 * cmg.numAreas + area1 ]--;
+		if ( cmg.areaPortals[ area2 * cmg.numAreas + area1 ] < 0 ) {
+			Com_Error (ERR_DROP, "CM_AdjustAreaPortalState: negative reference count");
+		}
+	}
+
+#ifdef _XBOX
+	CM_FloodAreaConnections ();
+#else
+	CM_FloodAreaConnections (cmg);
+#endif
+}
+
+/*
+====================
+CM_AreasConnected
+
+====================
+*/
+qboolean	CM_AreasConnected( int area1, int area2 ) {
+#ifndef BSPC
+	if ( cm_noAreas->integer ) {
+		return qtrue;
+	}
+#endif
+
+	if ( area1 < 0 || area2 < 0 ) {
+		return qfalse;
+	}
+
+	if (area1 >= cmg.numAreas || area2 >= cmg.numAreas) {
+		Com_Error (ERR_DROP, "area >= cmg.numAreas");
+	}
+
+	if (cmg.areas[area1].floodnum == cmg.areas[area2].floodnum) {
+		return qtrue;
+	}
+	return qfalse;
+}
+
+
+/*
+=================
+CM_WriteAreaBits
+
+Writes a bit vector of all the areas
+that are in the same flood as the area parameter
+Returns the number of bytes needed to hold all the bits.
+
+The bits are OR'd in, so you can CM_WriteAreaBits from multiple
+viewpoints and get the union of all visible areas.
+
+This is used to cull non-visible entities from snapshots
+=================
+*/
+int CM_WriteAreaBits (byte *buffer, int area)
+{
+	int		i;
+	int		floodnum;
+	int		bytes;
+
+	bytes = (cmg.numAreas+7)>>3;
+
+#ifndef BSPC
+	if (cm_noAreas->integer || area == -1)
+#else
+	if ( area == -1)
+#endif
+	{	// for debugging, send everything
+		memset (buffer, 255, bytes);
+	}
+	else
+	{
+		floodnum = cmg.areas[area].floodnum;
+		for (i=0 ; i<cmg.numAreas ; i++)
+		{
+			if (cmg.areas[i].floodnum == floodnum || area == -1)
+				buffer[i>>3] |= 1<<(i&7);
+		}
+	}
+
+	return bytes;
+}
+
+void CM_SnapPVS(vec3_t origin,byte *buffer)
+{
+	int		clientarea;
+	int		leafnum;
+	int		i;
+	
+	leafnum = CM_PointLeafnum (origin);
+	clientarea = CM_LeafArea (leafnum);
+
+	// calculate the visible areas
+	memset(buffer,0,MAX_MAP_AREA_BYTES);
+	CM_WriteAreaBits(buffer,clientarea);
+	for ( i = 0 ; i < MAX_MAP_AREA_BYTES/4 ; i++ ) {
+		((int *)buffer)[i] = ((int *)buffer)[i] ^ -1;
+	}
+
+}
+
+
diff --git a/code/qcommon/cm_trace.cpp b/code/qcommon/cm_trace.cpp
new file mode 100644
index 0000000..5db2b5f
--- /dev/null
+++ b/code/qcommon/cm_trace.cpp
@@ -0,0 +1,1244 @@
+
+#include "cm_local.h"
+
+#ifdef _XBOX
+#include "../renderer/tr_local.h"
+#endif
+
+/*
+===============================================================================
+
+POSITION TESTING
+
+===============================================================================
+*/
+
+extern cvar_t	*com_terrainPhysics;
+void VectorAdvance( const vec3_t veca, const float scale, const vec3_t vecb, vec3_t vecc);
+
+/*
+================
+CM_TestBoxInBrush
+================
+*/
+void CM_TestBoxInBrush( traceWork_t *tw, cbrush_t *brush ) {
+	int			i;
+	cplane_t	*plane;
+	float		dist;
+	float		d1;
+	cbrushside_t	*side;
+
+	if (!brush->numsides) {
+		return;
+	}
+
+	// special test for axial
+	if ( tw->bounds[0][0] > brush->bounds[1][0]
+		|| tw->bounds[0][1] > brush->bounds[1][1]
+		|| tw->bounds[0][2] > brush->bounds[1][2]
+		|| tw->bounds[1][0] < brush->bounds[0][0]
+		|| tw->bounds[1][1] < brush->bounds[0][1]
+		|| tw->bounds[1][2] < brush->bounds[0][2]
+		) {
+		return;
+	}
+
+	// the first six planes are the axial planes, so we only
+	// need to test the remainder
+	for ( i = 6 ; i < brush->numsides ; i++ ) {
+		side = brush->sides + i;
+#ifdef _XBOX
+		plane = &cmg.planes[side->planeNum.GetValue()];
+#else
+		plane = side->plane;
+#endif
+
+		// adjust the plane distance apropriately for mins/maxs
+		dist = plane->dist - DotProduct( tw->offsets[ plane->signbits ], plane->normal );
+
+		d1 = DotProduct( tw->start, plane->normal ) - dist;
+
+		// if completely in front of face, no intersection
+		if ( d1 > 0 ) {
+			return;
+		}
+	}
+
+	// inside this brush
+	tw->trace.startsolid = tw->trace.allsolid = qtrue;
+	tw->trace.fraction = 0;
+	tw->trace.contents = brush->contents;
+}
+
+/*
+================
+CM_PlaneCollision
+
+  Returns false for a quick getout
+================
+*/
+
+bool CM_PlaneCollision(traceWork_t *tw, cbrushside_t *side)
+{
+	float			dist, f;
+	float			d1, d2;
+#ifdef _XBOX
+	cplane_t		*plane = &cmg.planes[side->planeNum.GetValue()];
+#else
+	cplane_t		*plane = side->plane;
+#endif
+
+	// adjust the plane distance apropriately for mins/maxs
+	dist = plane->dist - DotProduct( tw->offsets[ plane->signbits ], plane->normal );
+
+	d1 = DotProduct( tw->start, plane->normal ) - dist;
+	d2 = DotProduct( tw->end, plane->normal ) - dist;
+
+	if (d2 > 0.0f) 
+	{
+		// endpoint is not in solid
+		tw->getout = true;	
+	}
+	if (d1 > 0.0f) 
+	{
+		// startpoint is not in solid
+		tw->startout = true;
+	}
+
+	// if completely in front of face, no intersection with the entire brush
+	if ((d1 > 0.0f) && ( (d2 >= SURFACE_CLIP_EPSILON) || (d2 >= d1) ) ) 
+	{
+		return(false);
+	}
+
+	// if it doesn't cross the plane, the plane isn't relevent
+	if ((d1 <= 0.0f) && (d2 <= 0.0f)) 
+	{
+		return(true);
+	}
+	// crosses face
+	if (d1 > d2) 
+	{	// enter
+		f = (d1 - SURFACE_CLIP_EPSILON);
+		if ( f < 0.0f ) 
+		{
+			f = 0.0f;
+			if (f > tw->enterFrac) 
+			{
+				tw->enterFrac = f;
+				tw->clipplane = plane;
+				tw->leadside = side;
+			}
+		}
+		else if (f > tw->enterFrac * (d1 - d2) ) 
+		{
+			tw->enterFrac = f / (d1 - d2);
+			tw->clipplane = plane;
+			tw->leadside = side;
+		}
+	}
+	else
+	{	// leave
+		f = (d1 + SURFACE_CLIP_EPSILON);
+		if ( f < (d1 - d2) ) 
+		{
+			f = 1.0f;
+			if (f < tw->leaveFrac) 
+			{
+				tw->leaveFrac = f;
+			}
+		}
+		else if (f > tw->leaveFrac * (d1 - d2) ) 
+		{
+			tw->leaveFrac = f / (d1 - d2);
+		}
+	}
+	return(true);
+}
+
+/*
+================
+CM_TraceThroughBrush
+================
+*/
+void CM_TraceThroughBrush( traceWork_t *tw, trace_t &trace, cbrush_t *brush, bool infoOnly ) 
+{
+	int				i;
+	cbrushside_t	*side;
+
+	tw->enterFrac = -1.0f;
+	tw->leaveFrac = 1.0f;
+	tw->clipplane = NULL;
+
+	if ( !brush->numsides ) 
+	{
+		return;
+	}
+
+	tw->getout = false;
+	tw->startout = false;						   
+	tw->leadside = NULL;
+
+	//
+	// compare the trace against all planes of the brush
+	// find the latest time the trace crosses a plane towards the interior
+	// and the earliest time the trace crosses a plane towards the exterior
+	//
+	for (i = 0; i < brush->numsides; i++) 
+	{
+		side = brush->sides + i;
+
+		if(!CM_PlaneCollision(tw, side))
+		{
+			return;
+		}
+	}
+
+	//
+	// all planes have been checked, and the trace was not
+	// completely outside the brush
+	//
+	if (!tw->startout) 
+	{	
+		if(!infoOnly)
+		{
+			// original point was inside brush
+			trace.startsolid = qtrue;
+			if (!tw->getout) 
+			{
+				trace.allsolid = qtrue;
+				trace.fraction = 0.0f;
+			}
+		}
+		tw->enterFrac = 0.0f;
+		return;
+	}
+	
+	if (tw->enterFrac < tw->leaveFrac) 
+	{
+		if ((tw->enterFrac > -1.0f) && (tw->enterFrac < trace.fraction)) 
+		{
+			if (tw->enterFrac < 0.0f) 
+			{
+				tw->enterFrac = 0.0f;
+			}
+			if(!infoOnly)
+			{
+				trace.fraction = tw->enterFrac;
+				trace.plane = *tw->clipplane;
+				trace.surfaceFlags = cmg.shaders[tw->leadside->shaderNum].surfaceFlags;
+//				tw->trace.sideNum = tw->leadside - cmg.brushsides;
+				trace.contents = brush->contents;
+			}
+		}
+	}
+}
+
+#ifndef BSPC
+#ifndef _XBOX	// Removing terrain from Xbox
+void CM_TraceThroughTerrain( traceWork_t *tw, trace_t &trace, cbrush_t *brush )
+{
+	CCMLandScape		*landscape;
+	vec3_t				tBegin, tEnd, tDistance, tStep;
+	vec3_t				baseStart;
+	vec3_t				baseEnd;
+	int					count;
+	int					i;
+	float				fraction;
+
+	// At this point we know we may be colliding with a terrain brush (and we know we have a valid terrain structure)
+	landscape = cmg.landScape;
+
+	if (!landscape)
+	{
+		assert(landscape);
+		Com_Error(ERR_FATAL,"Brush had surfaceparm terrain, but there is no Terrain entity on this map!");
+	}
+	// Check for absolutely no connection
+	if(!CM_GenericBoxCollide(tw->bounds, landscape->GetBounds()))
+	{
+		return;
+	}
+	// Now we know that at least some part of the trace needs to collide with the terrain
+	// The regular brush collision is handled elsewhere, so advance the ray to an edge in the terrain brush
+	CM_TraceThroughBrush( tw, trace, brush, true );
+	
+	// Remember the base entering and leaving fractions
+	tw->baseEnterFrac = tw->enterFrac;
+	tw->baseLeaveFrac = tw->leaveFrac;
+	// Reset to full spread within the brush
+	tw->enterFrac = -1.0f;
+	tw->leaveFrac = 1.0f;
+
+	// Work out the corners of the AABB when the trace first hits the terrain brush and when it leaves
+	VectorAdvance(tw->start, tw->baseEnterFrac, tw->end, tBegin);
+	VectorAdvance(tw->start, tw->baseLeaveFrac, tw->end, tEnd);
+	VectorSubtract(tEnd, tBegin, tDistance);
+
+	// Calculate number of iterations to process
+	count = ceilf(VectorLength(tDistance) / (landscape->GetPatchScalarSize() * TERRAIN_STEP_MAGIC));
+	count = 1;
+	fraction = trace.fraction;
+	VectorScale(tDistance, 1.0f / count, tStep);
+
+	// Save the base start and end vectors
+	VectorCopy ( tw->start, baseStart );
+	VectorCopy ( tw->end, baseEnd );
+
+	// Use the terrain vectors.  Start both at the beginning since the
+	// step will be added to the end as the first step of the loop
+	VectorCopy ( tBegin, tw->start );
+	VectorCopy ( tBegin, tw->end );
+
+	// Step thru terrain patches moving on about 1 patch at a time
+	for ( i = 0; i < count; i ++ )
+	{
+		// Add the step to the end
+		VectorAdd(tw->end, tStep, tw->end);
+
+		CM_CalcExtents(tBegin, tw->end, tw, tw->localBounds);
+
+		landscape->PatchCollide(tw, trace, tw->start, tw->end, brush->checkcount);
+	
+		// If collision with something closer than water then just stop here
+		if ( trace.fraction < fraction )
+		{
+			// Convert the fraction of this sub tract into the full trace's fraction
+			trace.fraction = i * (1.0f / count) + (1.0f / count) * trace.fraction;
+			break;
+		}
+
+		// Move the end to the start so the next trace starts
+		// where this one left off
+		VectorCopy(tw->end, tw->start);
+	}
+
+	// Put the original start and end back
+	VectorCopy ( baseStart, tw->start );
+	VectorCopy ( baseEnd, tw->end );
+
+	// Convert to global fraction only if something was hit along the way
+	if ( trace.fraction != 1.0 )
+	{
+		trace.fraction = tw->baseEnterFrac + ((tw->baseLeaveFrac - tw->baseEnterFrac) * trace.fraction);
+		trace.contents = brush->contents;
+	}
+
+	// Collide with any water
+	if ( tw->contents & CONTENTS_WATER )
+	{
+		fraction = landscape->WaterCollide(tw->start, tw->end, trace.fraction);
+		if( fraction < trace.fraction )
+		{
+			VectorSet(trace.plane.normal, 0.0f, 0.0f, 1.0f);
+			trace.contents = landscape->GetWaterContents();
+			trace.fraction = fraction;
+			trace.surfaceFlags = landscape->GetWaterSurfaceFlags();
+		}
+	}
+}
+#endif	// _XBOX
+#endif
+
+#ifdef _XBOX
+static int CM_GetSurfaceIndex(int firstLeafSurface)
+{
+	if(!tr.world || 
+			firstLeafSurface > tr.world->nummarksurfaces || 
+			firstLeafSurface < 0) {
+		return cmg.leafsurfaces[ firstLeafSurface ] ;
+	} else {
+		return tr.world->marksurfaces[firstLeafSurface] - tr.world->surfaces;
+	}
+}
+#endif
+
+/*
+================
+CM_TestInLeaf
+================
+*/
+void CM_TestInLeaf( traceWork_t *tw, cLeaf_t *leaf, clipMap_t *local ) {
+	int			k;
+	int			brushnum;
+	cbrush_t	*b;
+	cPatch_t	*patch;
+
+	// test box position against all brushes in the leaf
+	for (k=0 ; k<leaf->numLeafBrushes ; k++) {
+		brushnum = local->leafbrushes[leaf->firstLeafBrush+k];
+		b = &local->brushes[brushnum];
+		if (b->checkcount == local->checkcount) {
+			continue;	// already checked this brush in another leaf
+		}
+		b->checkcount = local->checkcount;
+
+		if ( !(b->contents & tw->contents)) {
+			continue;
+		}
+		
+#ifndef BSPC
+#ifndef _XBOX	// Removing terrain from Xbox
+		if (com_terrainPhysics->integer && cmg.landScape && (b->contents & CONTENTS_TERRAIN) )
+		{
+			// Invalidate the checkcount for terrain as the terrain brush has to be processed
+			// many times.
+			b->checkcount--;
+
+			CM_TraceThroughTerrain( tw, tw->trace, b );
+			// If inside a terrain brush don't bother with regular brush collision
+			continue;
+		}
+#endif
+#endif
+
+		CM_TestBoxInBrush( tw, b );
+		if ( tw->trace.allsolid ) {
+			return;
+		}
+	}
+
+	// test against all patches
+#ifdef BSPC
+	if (1) {
+#else
+	if ( !cm_noCurves->integer ) {
+#endif //BSPC
+		for ( k = 0 ; k < leaf->numLeafSurfaces ; k++ ) {
+#ifdef _XBOX
+			int index = CM_GetSurfaceIndex(leaf->firstLeafSurface + k);
+			patch = cmg.surfaces[ index ];
+#else
+			patch = local->surfaces[ local->leafsurfaces[ leaf->firstLeafSurface + k ] ];
+#endif
+			if ( !patch ) {
+				continue;
+			}
+			if ( patch->checkcount == local->checkcount ) {
+				continue;	// already checked this brush in another leaf
+			}
+			patch->checkcount = local->checkcount;
+
+			if ( !(patch->contents & tw->contents)) {
+				continue;
+			}
+			
+			if ( CM_PositionTestInPatchCollide( tw, patch->pc ) ) {
+				tw->trace.startsolid = tw->trace.allsolid = qtrue;
+				tw->trace.fraction = 0;
+				tw->trace.contents = patch->contents;
+				return;
+			}
+		}
+	}
+}
+
+/*
+==================
+CM_PositionTest
+==================
+*/
+#define	MAX_POSITION_LEAFS	1024
+void CM_PositionTest( traceWork_t *tw ) {
+	int		leafs[MAX_POSITION_LEAFS];
+	int		i;
+	leafList_t	ll;
+
+	// identify the leafs we are touching
+	VectorAdd( tw->start, tw->size[0], ll.bounds[0] );
+	VectorAdd( tw->start, tw->size[1], ll.bounds[1] );
+
+	for (i=0 ; i<3 ; i++) {
+		ll.bounds[0][i] -= 1;
+		ll.bounds[1][i] += 1;
+	}
+
+	ll.count = 0;
+	ll.maxcount = MAX_POSITION_LEAFS;
+	ll.list = leafs;
+	ll.storeLeafs = CM_StoreLeafs;
+	ll.lastLeaf = 0;
+	ll.overflowed = qfalse;
+
+	cmg.checkcount++;
+
+	CM_BoxLeafnums_r( &ll, 0 );
+
+
+	cmg.checkcount++;
+
+	// test the contents of the leafs
+	for (i=0 ; i < ll.count ; i++) {
+		CM_TestInLeaf( tw, &cmg.leafs[leafs[i]], &cmg );
+		if ( tw->trace.allsolid ) {
+			break;
+		}
+	}
+}
+
+/*
+===============================================================================
+
+BOX TRACING
+
+===============================================================================
+*/
+
+
+/*
+================
+CM_TraceThroughPatch
+================
+*/
+
+void CM_TraceThroughPatch( traceWork_t *tw, cPatch_t *patch ) {
+	float		oldFrac;
+
+	c_patch_traces++;
+
+	oldFrac = tw->trace.fraction;
+
+	CM_TraceThroughPatchCollide( tw, patch->pc );
+
+	if ( tw->trace.fraction < oldFrac ) {
+		tw->trace.surfaceFlags = patch->surfaceFlags;
+		tw->trace.contents = patch->contents;
+	}
+}
+
+
+/*
+================
+CM_TraceThroughBrush
+================
+*/
+void CM_TraceThroughBrush( traceWork_t *tw, cbrush_t *brush ) {
+	int			i;
+	cplane_t	*plane, *clipplane;
+	float		dist;
+	float		enterFrac, leaveFrac;
+	float		d1, d2;
+	qboolean	getout, startout;
+	float		f;
+	cbrushside_t	*side, *leadside;
+
+	enterFrac = -1.0;
+	leaveFrac = 1.0;
+	clipplane = NULL;
+
+	if ( !brush->numsides ) {
+		return;
+	}
+
+	// I'm not sure if test is strictly correct.  Are all
+	// bboxes axis aligned?  Do I care?  It seems to work
+	// good enough...
+	if ( tw->bounds[0][0] > brush->bounds[1][0]
+		|| tw->bounds[0][1] > brush->bounds[1][1]
+		|| tw->bounds[0][2] > brush->bounds[1][2]
+		|| tw->bounds[1][0] < brush->bounds[0][0]
+		|| tw->bounds[1][1] < brush->bounds[0][1]
+		|| tw->bounds[1][2] < brush->bounds[0][2]
+		) {
+		return;
+	}
+
+	c_brush_traces++;
+
+	getout = qfalse;
+	startout = qfalse;
+
+	leadside = NULL;
+
+	//
+	// compare the trace against all planes of the brush
+	// find the latest time the trace crosses a plane towards the interior
+	// and the earliest time the trace crosses a plane towards the exterior
+	//
+	for (i=0 ; i<brush->numsides ; i++) {
+		side = brush->sides + i;
+#ifdef _XBOX
+		plane = &cmg.planes[side->planeNum.GetValue()];
+#else
+		plane = side->plane;
+#endif
+
+		// adjust the plane distance apropriately for mins/maxs
+		dist = plane->dist - DotProduct( tw->offsets[ plane->signbits ], plane->normal );
+
+		d1 = DotProduct( tw->start, plane->normal ) - dist;
+		d2 = DotProduct( tw->end, plane->normal ) - dist;
+
+		if (d2 > 0) {
+			getout = qtrue;	// endpoint is not in solid
+		}
+		if (d1 > 0) {
+			startout = qtrue;
+		}
+
+		// if completely in front of face, no intersection with the entire brush
+		if (d1 > 0 && ( d2 >= SURFACE_CLIP_EPSILON || d2 >= d1 )  ) {
+			return;
+		}
+
+		// if it doesn't cross the plane, the plane isn't relevent
+		if (d1 <= 0 && d2 <= 0 ) {
+			continue;
+		}
+
+		// crosses face
+		if (d1 > d2) {	// enter
+			f = (d1-SURFACE_CLIP_EPSILON) / (d1-d2);
+			if ( f < 0 ) {
+				f = 0;
+			}
+			if (f > enterFrac) {
+				enterFrac = f;
+				clipplane = plane;
+				leadside = side;
+			}
+		} else {	// leave
+			f = (d1+SURFACE_CLIP_EPSILON) / (d1-d2);
+			if ( f > 1 ) {
+				f = 1;
+			}
+			if (f < leaveFrac) {
+				leaveFrac = f;
+			}
+		}
+	}
+
+	//
+	// all planes have been checked, and the trace was not
+	// completely outside the brush
+	//
+	if (!startout) {	// original point was inside brush
+		tw->trace.startsolid = qtrue;
+		tw->trace.contents |= brush->contents;	//note, we always want to know the contents of something we're inside of
+		if (!getout) 
+		{	//endpoint was inside brush
+			tw->trace.allsolid = qtrue;
+			tw->trace.fraction = 0;
+		}
+		return;
+	}
+	
+	if (enterFrac < leaveFrac) {
+		if (enterFrac > -1 && enterFrac < tw->trace.fraction) {
+			if (enterFrac < 0) {
+				enterFrac = 0;
+			}
+			tw->trace.fraction = enterFrac;
+			tw->trace.plane = *clipplane;
+			tw->trace.surfaceFlags = cmg.shaders[leadside->shaderNum].surfaceFlags;
+			tw->trace.contents = brush->contents;
+		}
+	}
+}
+
+/*
+================
+CM_PatchCollide
+
+  By the time we get here we know the AABB is within the patch AABB ie there is a chance of collision
+  The collision data is made up of bounds, 2 triangle planes
+  There is an BB check for the terxel check to see if it is worth checking the planes.
+  Collide with both triangles to find the shortest fraction
+================
+*/
+
+void CM_HandlePatchCollision(struct traceWork_s *tw, trace_t &trace, const vec3_t tStart, const vec3_t tEnd, CCMPatch *patch, int checkcount)
+{
+	int				numBrushes, i;
+	cbrush_t		*brush;
+
+	// Get the collision data
+	brush = patch->GetCollisionData();
+	numBrushes = patch->GetNumBrushes();
+
+	for(i = 0; i < numBrushes; i++, brush++)
+	{
+		if(brush->checkcount == checkcount)
+		{
+			return;
+		}
+
+		// Generic collision of terxel bounds to line segment bounds
+		if(!CM_GenericBoxCollide(brush->bounds, tw->localBounds))
+		{
+			continue;
+		}
+
+		brush->checkcount = checkcount;
+
+		//CM_TraceThroughBrush(tw, trace, brush, false );
+		CM_TraceThroughBrush(tw, brush);
+		if (trace.fraction <= 0.0)
+		{
+			break;
+		}
+	}
+}
+
+/*
+================
+CM_GenericBoxCollide
+================
+*/
+
+bool CM_GenericBoxCollide(const vec3pair_t abounds, const vec3pair_t bbounds)
+{
+	int		i;
+
+	// Check for completely no intersection
+	for(i = 0; i < 3; i++)
+	{
+		if(abounds[1][i] < bbounds[0][i])
+		{
+			return(false);
+		}
+		if(abounds[0][i] > bbounds[1][i])
+		{
+			return(false);
+		}
+	}
+	return(true);
+}
+
+/*
+================
+CM_TraceToLeaf
+================
+*/
+void CM_TraceToLeaf( traceWork_t *tw, cLeaf_t *leaf, clipMap_t *local ) {
+	int			k;
+	int			brushnum;
+	cbrush_t	*b;
+	cPatch_t	*patch;
+
+	// trace line against all brushes in the leaf
+	for ( k = 0 ; k < leaf->numLeafBrushes ; k++ ) {
+		brushnum = local->leafbrushes[leaf->firstLeafBrush+k];
+
+		b = &local->brushes[brushnum];
+		if ( b->checkcount == local->checkcount ) {
+			continue;	// already checked this brush in another leaf
+		}
+		b->checkcount = local->checkcount;
+
+		if ( !(b->contents & tw->contents) ) {
+			continue;
+		}
+
+#ifndef BSPC
+#ifndef _XBOX	// Removing terrain from Xbox
+		if ( com_terrainPhysics->integer && cmg.landScape && (b->contents & CONTENTS_TERRAIN) )
+		{
+			// Invalidate the checkcount for terrain as the terrain brush has to be processed
+			// many times.
+			b->checkcount--;
+
+			CM_TraceThroughTerrain( tw, tw->trace, b );
+			// If inside a terrain brush don't bother with regular brush collision
+			continue;
+		}
+#endif
+#endif
+
+		//if (b->contents & CONTENTS_PLAYERCLIP) continue;
+
+		CM_TraceThroughBrush( tw, b );
+		if ( !tw->trace.fraction ) {
+			return;
+		}
+	}
+
+	// trace line against all patches in the leaf
+#ifdef BSPC
+	if (1) {
+#else
+	if ( !cm_noCurves->integer ) {
+#endif
+		for ( k = 0 ; k < leaf->numLeafSurfaces ; k++ ) {
+#ifdef _XBOX
+			int index = CM_GetSurfaceIndex(leaf->firstLeafSurface + k);
+			patch = cmg.surfaces[ index ];
+#else
+			patch = local->surfaces[ local->leafsurfaces[ leaf->firstLeafSurface + k ] ];
+#endif
+			if ( !patch ) {
+				continue;
+			}
+			if ( patch->checkcount == local->checkcount ) {
+				continue;	// already checked this patch in another leaf
+			}
+			patch->checkcount = local->checkcount;
+
+			if ( !(patch->contents & tw->contents) ) {
+				continue;
+			}
+
+			CM_TraceThroughPatch( tw, patch );
+			if ( !tw->trace.fraction ) {
+				return;
+			}
+		}
+	}
+}
+
+//=========================================================================================
+
+/*
+==================
+CM_TraceThroughTree
+
+Traverse all the contacted leafs from the start to the end position.
+If the trace is a point, they will be exactly in order, but for larger
+trace volumes it is possible to hit something in a later leaf with
+a smaller intercept fraction.
+==================
+*/
+void CM_TraceThroughTree( traceWork_t *tw, clipMap_t *local, int num, float p1f, float p2f, vec3_t p1, vec3_t p2) {
+	cNode_t		*node;
+	cplane_t	*plane;
+	float		t1, t2, offset;
+	float		frac, frac2;
+	float		idist;
+	vec3_t		mid;
+	int			side;
+	float		midf;
+
+#ifdef _XBOX
+	if(!tr.world) {
+		return;
+	}
+#endif
+
+	if (tw->trace.fraction <= p1f) {
+		return;		// already hit something nearer
+	}
+
+	// if < 0, we are in a leaf node
+	if (num < 0) {
+		CM_TraceToLeaf( tw, &local->leafs[-1-num], local );
+		return;
+	}
+
+	//
+	// find the point distances to the seperating plane
+	// and the offset for the size of the box
+	//
+	node = local->nodes + num;
+
+#ifdef _XBOX
+	plane = cmg.planes + tr.world->nodes[num].planeNum;
+#else   mnode_s
+	plane = node->plane;
+#endif
+
+#if 0
+	// uncomment this to test against every leaf in the world for debugging
+CM_TraceThroughTree( tw, local, node->children[0], p1f, p2f, p1, p2 );
+CM_TraceThroughTree( tw, local, node->children[1], p1f, p2f, p1, p2 );
+return;
+#endif
+
+	// adjust the plane distance apropriately for mins/maxs
+	if ( plane->type < 3 ) {
+		t1 = p1[plane->type] - plane->dist;
+		t2 = p2[plane->type] - plane->dist;
+		offset = tw->extents[plane->type];
+	} else {
+		t1 = DotProduct (plane->normal, p1) - plane->dist;
+		t2 = DotProduct (plane->normal, p2) - plane->dist;
+		if ( tw->isPoint ) {
+			offset = 0;
+		} else {
+			// an axial brush right behind a slanted bsp plane
+			// will poke through when expanded, so adjust
+			// by sqrt(3)
+			offset = fabs(tw->extents[0]*plane->normal[0]) +
+				fabs(tw->extents[1]*plane->normal[1]) +
+				fabs(tw->extents[2]*plane->normal[2]);
+
+			offset *= 2;
+#if 0
+CM_TraceThroughTree( tw, local, node->children[0], p1f, p2f, p1, p2 );
+CM_TraceThroughTree( tw, local, node->children[1], p1f, p2f, p1, p2 );
+return;
+#endif
+			offset = tw->maxOffset;
+			offset = 2048;
+		}
+	}
+
+	// see which sides we need to consider
+	if ( t1 >= offset + 1 && t2 >= offset + 1 ) {
+		CM_TraceThroughTree( tw, local, node->children[0], p1f, p2f, p1, p2 );
+		return;
+	}
+	if ( t1 < -offset - 1 && t2 < -offset - 1 ) {
+		CM_TraceThroughTree( tw, local, node->children[1], p1f, p2f, p1, p2 );
+		return;
+	}
+
+	// put the crosspoint SURFACE_CLIP_EPSILON pixels on the near side
+	if ( t1 < t2 ) {
+		idist = 1.0/(t1-t2);
+		side = 1;
+		frac2 = (t1 + offset + SURFACE_CLIP_EPSILON)*idist;
+		frac = (t1 - offset + SURFACE_CLIP_EPSILON)*idist;
+	} else if (t1 > t2) {
+		idist = 1.0/(t1-t2);
+		side = 0;
+		frac2 = (t1 - offset - SURFACE_CLIP_EPSILON)*idist;
+		frac = (t1 + offset + SURFACE_CLIP_EPSILON)*idist;
+	} else {
+		side = 0;
+		frac = 1;
+		frac2 = 0;
+	}
+
+	// move up to the node
+	if ( frac < 0 ) {
+		frac = 0;
+	}
+	if ( frac > 1 ) {
+		frac = 1;
+	}
+		
+	midf = p1f + (p2f - p1f)*frac;
+
+	mid[0] = p1[0] + frac*(p2[0] - p1[0]);
+	mid[1] = p1[1] + frac*(p2[1] - p1[1]);
+	mid[2] = p1[2] + frac*(p2[2] - p1[2]);
+
+	CM_TraceThroughTree( tw, local, node->children[side], p1f, midf, p1, mid );
+
+
+	// go past the node
+	if ( frac2 < 0 ) {
+		frac2 = 0;
+	}
+	if ( frac2 > 1 ) {
+		frac2 = 1;
+	}
+		
+	midf = p1f + (p2f - p1f)*frac2;
+
+	mid[0] = p1[0] + frac2*(p2[0] - p1[0]);
+	mid[1] = p1[1] + frac2*(p2[1] - p1[1]);
+	mid[2] = p1[2] + frac2*(p2[2] - p1[2]);
+
+	CM_TraceThroughTree( tw, local, node->children[side^1], midf, p2f, mid, p2 );
+}
+
+void CM_CalcExtents(const vec3_t start, const vec3_t end, const traceWork_t *tw, vec3pair_t bounds)
+{
+	int		i;
+
+	for ( i = 0 ; i < 3 ; i++ )
+	{
+		if ( start[i] < end[i] )
+		{
+			bounds[0][i] = start[i] + tw->size[0][i];
+			bounds[1][i] = end[i] + tw->size[1][i];
+		}
+		else
+		{
+			bounds[0][i] = end[i] + tw->size[0][i];
+			bounds[1][i] = start[i] + tw->size[1][i];
+		}
+	}
+}
+
+//======================================================================
+
+/*
+==================
+CM_BoxTrace
+==================
+*/
+void CM_BoxTrace( trace_t *results, const vec3_t start, const vec3_t end,
+						  const vec3_t mins, const vec3_t maxs,
+						  clipHandle_t model, int brushmask) {
+	int			i;
+	traceWork_t	tw;
+	vec3_t		offset;
+	cmodel_t	*cmod;
+	clipMap_t	*local = 0;
+
+	cmod = CM_ClipHandleToModel( model, &local );
+
+	local->checkcount++;		// for multi-check avoidance
+
+	c_traces++;				// for statistics, may be zeroed
+
+	// fill in a default trace
+	memset( &tw, 0, sizeof(tw) - sizeof(tw.trace.G2CollisionMap));
+	tw.trace.fraction = 1;	// assume it goes the entire distance until shown otherwise
+
+	if (!local->numNodes) {
+		*results = tw.trace;
+		return;	// map not loaded, shouldn't happen
+	}
+
+	// allow NULL to be passed in for 0,0,0
+	if ( !mins ) {
+		mins = vec3_origin;
+	}
+	if ( !maxs ) {
+		maxs = vec3_origin;
+	}
+
+	// set basic parms
+	tw.contents = brushmask;
+
+	// adjust so that mins and maxs are always symetric, which
+	// avoids some complications with plane expanding of rotated
+	// bmodels
+	for ( i = 0 ; i < 3 ; i++ ) {
+		offset[i] = ( mins[i] + maxs[i] ) * 0.5;
+		tw.size[0][i] = mins[i] - offset[i];
+		tw.size[1][i] = maxs[i] - offset[i];
+		tw.start[i] = start[i] + offset[i];
+		tw.end[i] = end[i] + offset[i];
+	}
+
+	tw.maxOffset = tw.size[1][0] + tw.size[1][1] + tw.size[1][2];
+
+	// tw.offsets[signbits] = vector to apropriate corner from origin
+	tw.offsets[0][0] = tw.size[0][0];
+	tw.offsets[0][1] = tw.size[0][1];
+	tw.offsets[0][2] = tw.size[0][2];
+
+	tw.offsets[1][0] = tw.size[1][0];
+	tw.offsets[1][1] = tw.size[0][1];
+	tw.offsets[1][2] = tw.size[0][2];
+
+	tw.offsets[2][0] = tw.size[0][0];
+	tw.offsets[2][1] = tw.size[1][1];
+	tw.offsets[2][2] = tw.size[0][2];
+
+	tw.offsets[3][0] = tw.size[1][0];
+	tw.offsets[3][1] = tw.size[1][1];
+	tw.offsets[3][2] = tw.size[0][2];
+
+	tw.offsets[4][0] = tw.size[0][0];
+	tw.offsets[4][1] = tw.size[0][1];
+	tw.offsets[4][2] = tw.size[1][2];
+
+	tw.offsets[5][0] = tw.size[1][0];
+	tw.offsets[5][1] = tw.size[0][1];
+	tw.offsets[5][2] = tw.size[1][2];
+
+	tw.offsets[6][0] = tw.size[0][0];
+	tw.offsets[6][1] = tw.size[1][1];
+	tw.offsets[6][2] = tw.size[1][2];
+
+	tw.offsets[7][0] = tw.size[1][0];
+	tw.offsets[7][1] = tw.size[1][1];
+	tw.offsets[7][2] = tw.size[1][2];
+
+
+	//
+	// calculate bounds
+	//
+	for ( i = 0 ; i < 3 ; i++ ) {
+		if ( tw.start[i] < tw.end[i] ) {
+			tw.bounds[0][i] = tw.start[i] + tw.size[0][i];
+			tw.bounds[1][i] = tw.end[i] + tw.size[1][i];
+		} else {
+			tw.bounds[0][i] = tw.end[i] + tw.size[0][i];
+			tw.bounds[1][i] = tw.start[i] + tw.size[1][i];
+		}
+	}
+
+	//
+	// check for position test special case
+	//
+	if (start[0] == end[0] && start[1] == end[1] && start[2] == end[2]) {
+		if ( model ) {
+			CM_TestInLeaf( &tw, &cmod->leaf, local );
+		} else {
+			CM_PositionTest( &tw );
+		}
+	} else {
+		//
+		// check for point special case
+		//
+		if ( tw.size[0][0] == 0 && tw.size[0][1] == 0 && tw.size[0][2] == 0 ) {
+			tw.isPoint = qtrue;
+			VectorClear( tw.extents );
+		} else {
+			tw.isPoint = qfalse;
+			tw.extents[0] = tw.size[1][0];
+			tw.extents[1] = tw.size[1][1];
+			tw.extents[2] = tw.size[1][2];
+		}
+
+		//
+		// general sweeping through world
+		//
+		if ( model ) {
+			CM_TraceToLeaf( &tw, &cmod->leaf, local );
+		} else {
+			CM_TraceThroughTree( &tw, local, 0, 0, 1, tw.start, tw.end );
+		}
+	}
+
+	// generate endpos from the original, unmodified start/end
+	if ( tw.trace.fraction == 1 ) {
+		VectorCopy (end, tw.trace.endpos);
+	} else {
+		for ( i=0 ; i<3 ; i++ ) {
+			tw.trace.endpos[i] = start[i] + tw.trace.fraction * (end[i] - start[i]);
+		}
+	}
+
+	*results = tw.trace;
+}
+
+
+/*
+==================
+CM_TransformedBoxTrace
+
+Handles offseting and rotation of the end points for moving and
+rotating entities
+==================
+*/
+void CM_TransformedBoxTrace( trace_t *results, const vec3_t start, const vec3_t end,
+						  const vec3_t mins, const vec3_t maxs,
+						  clipHandle_t model, int brushmask,
+						  const vec3_t origin, const vec3_t angles) {
+	trace_t		trace;
+	vec3_t		start_l, end_l;
+	vec3_t		a;
+	vec3_t		forward, right, up;
+	vec3_t		temp;
+	qboolean	rotated;
+	vec3_t		offset;
+	vec3_t		symetricSize[2];
+	int			i;
+
+	if ( !mins ) {
+		mins = vec3_origin;
+	}
+	if ( !maxs ) {
+		maxs = vec3_origin;
+	}
+
+	// adjust so that mins and maxs are always symetric, which
+	// avoids some complications with plane expanding of rotated
+	// bmodels
+	for ( i = 0 ; i < 3 ; i++ ) {
+		offset[i] = ( mins[i] + maxs[i] ) * 0.5;
+		symetricSize[0][i] = mins[i] - offset[i];
+		symetricSize[1][i] = maxs[i] - offset[i];
+		start_l[i] = start[i] + offset[i];
+		end_l[i] = end[i] + offset[i];
+	}
+
+	// subtract origin offset
+	VectorSubtract( start_l, origin, start_l );
+	VectorSubtract( end_l, origin, end_l );
+
+	// rotate start and end into the models frame of reference
+	if ( model != BOX_MODEL_HANDLE && 
+		(angles[0] || angles[1] || angles[2]) ) {
+		rotated = qtrue;
+	} else {
+		rotated = qfalse;
+	}
+
+	if (rotated) {
+		AngleVectors (angles, forward, right, up);
+
+		VectorCopy (start_l, temp);
+		start_l[0] = DotProduct (temp, forward);
+		start_l[1] = -DotProduct (temp, right);
+		start_l[2] = DotProduct (temp, up);
+
+		VectorCopy (end_l, temp);
+		end_l[0] = DotProduct (temp, forward);
+		end_l[1] = -DotProduct (temp, right);
+		end_l[2] = DotProduct (temp, up);
+	}
+
+	// sweep the box through the model
+	CM_BoxTrace( &trace, start_l, end_l, symetricSize[0], symetricSize[1], model, brushmask);
+
+	if ( rotated && trace.fraction != 1.0 ) {
+		// FIXME: figure out how to do this with existing angles
+		VectorNegate (angles, a);
+		AngleVectors (a, forward, right, up);
+
+		VectorCopy (trace.plane.normal, temp);
+		trace.plane.normal[0] = DotProduct (temp, forward);
+		trace.plane.normal[1] = -DotProduct (temp, right);
+		trace.plane.normal[2] = DotProduct (temp, up);
+	}
+
+	trace.endpos[0] = start[0] + trace.fraction * (end[0] - start[0]);
+	trace.endpos[1] = start[1] + trace.fraction * (end[1] - start[1]);
+	trace.endpos[2] = start[2] + trace.fraction * (end[2] - start[2]);
+
+	*results = trace;
+}
+
+/*
+=================
+CM_CullBox
+
+Returns true if culled out
+=================
+*/
+
+bool CM_CullBox(const cplane_t *frustum, const vec3_t transformed[8])
+{
+	int				i, j;
+	const cplane_t	*frust;
+
+	// check against frustum planes
+	for (i=0, frust=frustum; i<4 ; i++, frust++) 
+	{
+		for (j=0 ; j<8 ; j++) 
+		{
+			if (DotProduct(transformed[j], frust->normal) > frust->dist) 
+			{	// a point is in front
+				break;
+			} 
+		}
+
+		if (j == 8) 
+		{	// all points were behind one of the planes
+			return true;
+		}
+	}
+	return false;
+}
+
+/*
+=================
+CM_CullWorldBox
+
+Returns true if culled out
+=================
+*/
+
+bool CM_CullWorldBox (const cplane_t *frustum, const vec3pair_t bounds) 
+{
+	int			i;
+	vec3_t		transformed[8];
+
+	for (i = 0 ; i < 8 ; i++) 
+	{
+		transformed[i][0] = bounds[i & 1][0];
+		transformed[i][1] = bounds[(i >> 1) & 1][1];
+		transformed[i][2] = bounds[(i >> 2) & 1][2];
+	}
+
+	//rwwFIXMEFIXME: Was not ! before. But that seems the way it should be and it works that way. Why?
+	return(!CM_CullBox(frustum, transformed));
+}
diff --git a/code/qcommon/cmd.cpp b/code/qcommon/cmd.cpp
new file mode 100644
index 0000000..55589b5
--- /dev/null
+++ b/code/qcommon/cmd.cpp
@@ -0,0 +1,708 @@
+// cmd.c -- Quake script command processing module
+
+#include "../game/q_shared.h"
+#include "qcommon.h"
+
+#define	MAX_CMD_BUFFER	8192
+int			cmd_wait;
+msg_t		cmd_text;
+byte		cmd_text_buf[MAX_CMD_BUFFER];
+char		cmd_defer_text_buf[MAX_CMD_BUFFER];
+
+
+//=============================================================================
+
+/*
+============
+Cmd_Wait_f
+
+Causes execution of the remainder of the command buffer to be delayed until
+next frame.  This allows commands like:
+bind g "cmd use rocket ; +attack ; wait ; -attack ; cmd use blaster"
+============
+*/
+void Cmd_Wait_f( void ) {
+	if ( Cmd_Argc() == 2 ) {
+		cmd_wait = atoi( Cmd_Argv( 1 ) );
+	} else {
+		cmd_wait = 1;
+	}
+}
+
+
+/*
+=============================================================================
+
+						COMMAND BUFFER
+
+=============================================================================
+*/
+
+/*
+============
+Cbuf_Init
+============
+*/
+void Cbuf_Init (void)
+{
+	MSG_Init (&cmd_text, cmd_text_buf, sizeof(cmd_text_buf));
+}
+
+/*
+============
+Cbuf_AddText
+
+Adds command text at the end of the buffer, does NOT add a final \n
+============
+*/
+void Cbuf_AddText( const char *text ) {
+	int		l;
+	
+	l = strlen (text);
+
+	if (cmd_text.cursize + l >= cmd_text.maxsize)
+	{
+		Com_Printf ("Cbuf_AddText: overflow\n");
+		return;
+	}
+	MSG_WriteData (&cmd_text, text, strlen (text));
+}
+
+
+/*
+============
+Cbuf_InsertText
+
+Adds command text immediately after the current command
+Adds a \n to the text
+============
+*/
+void Cbuf_InsertText( const char *text ) {
+	int		len;
+	int		i;
+
+	len = strlen( text ) + 1;
+	if ( len + cmd_text.cursize > cmd_text.maxsize ) {
+		Com_Printf( "Cbuf_InsertText overflowed\n" );
+		return;
+	}
+
+	// move the existing command text
+	for ( i = cmd_text.cursize - 1 ; i >= 0 ; i-- ) {
+		cmd_text.data[ i + len ] = cmd_text.data[ i ];
+	}
+
+	// copy the new text in
+	memcpy( cmd_text.data, text, len - 1 );
+
+	// add a \n
+	cmd_text.data[ len - 1 ] = '\n';
+
+	cmd_text.cursize += len;
+}
+
+
+/*
+============
+Cbuf_ExecuteText
+============
+*/
+void Cbuf_ExecuteText (int exec_when, const char *text)
+{
+	switch (exec_when)
+	{
+	case EXEC_NOW:
+		Cmd_ExecuteString (text);
+		break;
+	case EXEC_INSERT:
+		Cbuf_InsertText (text);
+		break;
+	case EXEC_APPEND:
+		Cbuf_AddText (text);
+		break;
+	default:
+		Com_Error (ERR_FATAL, "Cbuf_ExecuteText: bad exec_when");
+	}
+}
+
+/*
+============
+Cbuf_Execute
+============
+*/
+void Cbuf_Execute (void)
+{
+	int		i;
+	char	*text;
+	char	line[MAX_CMD_BUFFER];
+	int		quotes;
+
+	while (cmd_text.cursize)
+	{
+		if ( cmd_wait )	{
+			// skip out while text still remains in buffer, leaving it
+			// for next frame
+			cmd_wait--;
+			break;
+		}
+
+		// find a \n or ; line break
+		text = (char *)cmd_text.data;
+
+		quotes = 0;
+		for (i=0 ; i< cmd_text.cursize ; i++)
+		{
+			if (text[i] == '"')
+				quotes++;
+			if ( !(quotes&1) &&  text[i] == ';')
+				break;	// don't break if inside a quoted string
+			if (text[i] == '\n' || text[i] == '\r' )
+				break;
+		}
+			
+				
+		memcpy (line, text, i);
+		line[i] = 0;
+		
+// delete the text from the command buffer and move remaining commands down
+// this is necessary because commands (exec) can insert data at the
+// beginning of the text buffer
+
+		if (i == cmd_text.cursize)
+			cmd_text.cursize = 0;
+		else
+		{
+			i++;
+			cmd_text.cursize -= i;
+			memmove (text, text+i, cmd_text.cursize);
+		}
+
+// execute the command line
+		Cmd_ExecuteString (line);		
+	}
+}
+
+
+/*
+==============================================================================
+
+						SCRIPT COMMANDS
+
+==============================================================================
+*/
+
+
+/*
+===============
+Cmd_Exec_f
+===============
+*/
+void Cmd_Exec_f( void ) {
+	char	*f;
+	int		len;
+	char	filename[MAX_QPATH];
+
+	if (Cmd_Argc () != 2) {
+		Com_Printf ("exec <filename> : execute a script file\n");
+		return;
+	}
+
+	Q_strncpyz( filename, Cmd_Argv(1), sizeof( filename ) );
+	COM_DefaultExtension( filename, sizeof( filename ), ".cfg" ); 
+	len = FS_ReadFile( filename, (void **)&f);
+	if (!f) {
+		Com_Printf ("couldn't exec %s\n",Cmd_Argv(1));
+		return;
+	}
+	Com_Printf ("execing %s\n",Cmd_Argv(1));
+	
+	Cbuf_InsertText (f);
+
+	FS_FreeFile (f);
+}
+
+
+/*
+===============
+Cmd_Vstr_f
+
+Inserts the current value of a variable as command text
+===============
+*/
+void Cmd_Vstr_f( void ) {
+	char	*v;
+
+	if (Cmd_Argc () != 2) {
+		Com_Printf ("vstr <variablename> : execute a variable command\n");
+		return;
+	}
+
+	v = Cvar_VariableString( Cmd_Argv( 1 ) );
+	Cbuf_InsertText( va("%s\n", v ) );
+}
+
+
+/*
+===============
+Cmd_Echo_f
+
+Just prints the rest of the line to the console
+===============
+*/
+void Cmd_Echo_f (void)
+{
+	int		i;
+	
+	for (i=1 ; i<Cmd_Argc() ; i++)
+		Com_Printf ("%s ",Cmd_Argv(i));
+	Com_Printf ("\n");
+}
+
+
+/*
+=============================================================================
+
+					COMMAND EXECUTION
+
+=============================================================================
+*/
+
+#define CMD_MAX_NUM 256
+#define CMD_MAX_NAME 32
+typedef struct cmd_function_s
+{
+	char					name[CMD_MAX_NAME];
+	xcommand_t				function;
+} cmd_function_t;
+
+
+static	int			cmd_argc;
+static	char		*cmd_argv[MAX_STRING_TOKENS];		// points into cmd_tokenized
+static	char		cmd_tokenized[MAX_STRING_CHARS+MAX_STRING_TOKENS];	// will have 0 bytes inserted
+
+static	cmd_function_t	cmd_functions[CMD_MAX_NUM] = {0};		// possible commands to execute
+
+/*
+============
+Cmd_Argc
+============
+*/
+int		Cmd_Argc( void ) {
+	return cmd_argc;
+}
+
+/*
+============
+Cmd_Argv
+============
+*/
+char	*Cmd_Argv( int arg ) {
+	if ( (unsigned)arg >= cmd_argc ) {
+		return "";
+	}
+	return cmd_argv[arg];	
+}
+
+/*
+============
+Cmd_ArgvBuffer
+
+The interpreted versions use this because
+they can't have pointers returned to them
+============
+*/
+void	Cmd_ArgvBuffer( int arg, char *buffer, int bufferLength ) {
+	Q_strncpyz( buffer, Cmd_Argv( arg ), bufferLength );
+}
+
+
+/*
+============
+Cmd_Args
+
+Returns a single string containing argv(1) to argv(argc()-1)
+============
+*/
+char	*Cmd_Args( void ) {
+	static	char		cmd_args[MAX_STRING_CHARS];
+	int		i;
+
+	cmd_args[0] = 0;
+	for ( i = 1 ; i < cmd_argc ; i++ ) {
+		strcat( cmd_args, cmd_argv[i] );
+		if ( i != cmd_argc ) {
+			strcat( cmd_args, " " );
+		}
+	}
+
+	return cmd_args;
+}
+
+
+/*
+============
+Cmd_ArgsBuffer
+
+The interpreted versions use this because
+they can't have pointers returned to them
+============
+*/
+void	Cmd_ArgsBuffer( char *buffer, int bufferLength ) {
+	Q_strncpyz( buffer, Cmd_Args(), bufferLength );
+}
+
+
+/*
+============
+Cmd_TokenizeString
+
+Parses the given string into command line tokens.
+The text is copied to a seperate buffer and 0 characters
+are inserted in the apropriate place, The argv array
+will point into this temporary buffer.
+============
+*/
+void Cmd_TokenizeString( const char *text_in ) {
+	const unsigned char	*text;
+	char	*textOut;
+
+	// clear previous args
+	cmd_argc = 0;
+
+	if ( !text_in ) {
+		return;
+	}
+
+	text = (const unsigned char	*)text_in;
+	textOut = cmd_tokenized;
+
+	while ( 1 ) {
+		if ( cmd_argc == MAX_STRING_TOKENS ) {
+			return;			// this is usually something malicious
+		}
+
+		while ( 1 ) {
+			// skip whitespace
+			while ( *text && *text <= ' ' ) {
+				text++;
+			}
+			if ( !*text ) {
+				return;			// all tokens parsed
+			}
+
+			// skip // comments
+			if ( text[0] == '/' && text[1] == '/' ) {
+				return;			// all tokens parsed
+			}
+
+			// skip /* */ comments
+			if ( text[0] == '/' && text[1] =='*' ) {
+				while ( *text && ( text[0] != '*' || text[1] != '/' ) ) {
+					text++;
+				}
+				if ( !*text ) {
+					return;		// all tokens parsed
+				}
+				text += 2;
+			} else {
+				break;			// we are ready to parse a token
+			}
+		}
+
+		// handle quoted strings
+		if ( *text == '"' ) {
+			cmd_argv[cmd_argc] = textOut;
+			cmd_argc++;
+			text++;
+			while ( *text && *text != '"' ) {
+				*textOut++ = *text++;
+			}
+			*textOut++ = 0;
+			if ( !*text ) {
+				return;		// all tokens parsed
+			}
+			text++;
+			continue;
+		}
+
+		// regular token
+		cmd_argv[cmd_argc] = textOut;
+		cmd_argc++;
+
+		// skip until whitespace, quote, or command
+		while ( *text > ' ' ) {
+			if ( text[0] == '"' ) {
+				break;
+			}
+
+			if ( text[0] == '/' && text[1] == '/' ) {
+				break;
+			}
+
+			// skip /* */ comments
+			if ( text[0] == '/' && text[1] =='*' ) {
+				break;
+			}
+
+			*textOut++ = *text++;
+		}
+
+		*textOut++ = 0;
+
+		if ( !*text ) {
+			return;		// all tokens parsed
+		}
+	}
+	
+}
+
+
+/*
+============
+Cmd_AddCommand
+============
+*/
+void	Cmd_AddCommand( const char *cmd_name, xcommand_t function ) {
+	cmd_function_t	*cmd;
+	cmd_function_t	*add = NULL;
+	int c;
+	
+	// fail if the command already exists
+	for ( c = 0; c < CMD_MAX_NUM; ++c )
+	{
+		cmd = cmd_functions + c;
+		if ( !strcmp( cmd_name, cmd->name ) ) {
+			// allow completion-only commands to be silently doubled
+			if ( function != NULL ) {
+				Com_Printf ("Cmd_AddCommand: %s already defined\n", cmd_name);
+			}
+			return;
+		}
+
+		if ( add == NULL && cmd->name[0] == '\0')
+		{
+			add = cmd;
+		}
+	}
+
+	if ( add == NULL )
+	{
+		Com_Printf ("Cmd_AddCommand: Too many commands registered\n", cmd_name);
+		return;
+	}
+
+	Q_strncpyz(add->name, cmd_name, CMD_MAX_NAME, qtrue);
+	add->function = function;
+}
+
+/*
+============
+Cmd_RemoveCommand
+============
+*/
+void	Cmd_RemoveCommand( const char *cmd_name ) {
+	cmd_function_t	*cmd;
+
+	for ( int c = 0; c < CMD_MAX_NUM; ++c )
+	{
+		cmd = cmd_functions + c;
+		if ( !strcmp( cmd_name, cmd->name ) ) {
+			cmd->name[0] = '\0';
+			return;
+		}
+	}
+}
+
+char *Cmd_CompleteCommandNext (char *partial, char *last)
+{
+	cmd_function_t	*cmd, *base;
+	int				len, c;
+	
+	len = strlen(partial);
+	
+	if (!len)
+		return NULL;
+
+	// start past last match
+	base = NULL;
+	if(last)
+	{
+		for (c = 0; c < CMD_MAX_NUM; ++c)
+		{
+			cmd = cmd_functions + c;
+			if(!strcmp(last, cmd->name))
+			{
+				base = cmd + 1;
+				break;
+			}
+		}
+		if(base == NULL)
+		{	//not found, either error or at end of list
+			return NULL;
+		}
+	}
+	else
+	{
+		base = cmd_functions;
+	}
+
+
+	for (c = base - cmd_functions; c < CMD_MAX_NUM; ++c)
+	{
+		cmd = cmd_functions + c;
+		if (!strcmp (partial,cmd->name))
+			return cmd->name;
+	}
+
+// check for partial match
+	for (c = base - cmd_functions; c < CMD_MAX_NUM; ++c)
+	{
+		cmd = cmd_functions + c;
+		if (!strncmp (partial,cmd->name, len))
+			return cmd->name;
+	}
+
+	return NULL;
+}
+
+
+/*
+============
+Cmd_CompleteCommand
+============
+*/
+char *Cmd_CompleteCommand( const char *partial ) {
+	cmd_function_t	*cmd;
+	int				len;
+	
+	len = strlen(partial);
+	
+	if (!len)
+		return NULL;
+		
+	// check for exact match
+	for (int c = 0; c < CMD_MAX_NUM; ++c)
+	{
+		cmd = cmd_functions + c;
+		if (!Q_stricmp( partial, cmd->name))
+			return cmd->name;
+	}
+
+	// check for partial match
+	for (int c = 0; c < CMD_MAX_NUM; ++c)
+	{
+		cmd = cmd_functions + c;
+		if (!Q_stricmpn (partial,cmd->name, len))
+			return cmd->name;
+	}
+
+	return NULL;
+}
+
+
+/*
+============
+Cmd_ExecuteString
+
+A complete command line has been parsed, so try to execute it
+============
+*/
+void	Cmd_ExecuteString( const char *text ) {	
+
+	// execute the command line
+	Cmd_TokenizeString( text );		
+	if ( !Cmd_Argc() ) {
+		return;		// no tokens
+	}
+
+	// check registered command functions	
+	for ( int c = 0; c < CMD_MAX_NUM; ++c )
+	{
+		if ( !Q_stricmp( cmd_argv[0],cmd_functions[c].name ) ) {
+			// rearrange the links so that the command will be
+			// near the head of the list next time it is used
+			cmd_function_t temp = cmd_functions[c];
+			cmd_functions[c] = cmd_functions[0];
+			cmd_functions[0] = temp;
+
+			// perform the action
+			if ( !temp.function ) {
+				// let the cgame or game handle it
+				break;
+			} else {
+				temp.function ();
+			}
+			return;
+		}
+	}
+	
+	// check cvars
+	if ( Cvar_Command() ) {
+		return;
+	}
+
+	// check client game commands
+	if ( com_cl_running && com_cl_running->integer && CL_GameCommand() ) {
+		return;
+	}
+
+	// check server game commands
+	if ( com_sv_running && com_sv_running->integer && SV_GameCommand() ) {
+		return;
+	}
+
+	// check ui commands
+	if ( com_cl_running && com_cl_running->integer && UI_GameCommand() ) {
+		return;
+	}
+
+	// send it as a server command if we are connected
+	// this will usually result in a chat message
+	CL_ForwardCommandToServer ();
+}
+
+/*
+============
+Cmd_List_f
+============
+*/
+void Cmd_List_f (void)
+{
+	cmd_function_t	*cmd;
+	int				i;
+	char			*match;
+
+	if ( Cmd_Argc() > 1 ) {
+		match = Cmd_Argv( 1 );
+	} else {
+		match = NULL;
+	}
+
+	i = 0;
+	for ( int c = 0; c < CMD_MAX_NUM; ++c )
+	{
+		cmd = cmd_functions + c;
+		if (match && !Com_Filter(match, cmd->name, qfalse)) continue;
+		Com_Printf ("%s\n", cmd->name);
+		i++;
+	}
+	Com_Printf ("%i commands\n", i);
+}
+
+/*
+============
+Cmd_Init
+============
+*/
+void Cmd_Init (void)
+{
+//
+// register our commands
+//
+	Cmd_AddCommand ("cmdlist",Cmd_List_f);
+	Cmd_AddCommand ("exec",Cmd_Exec_f);
+	Cmd_AddCommand ("vstr",Cmd_Vstr_f);
+	Cmd_AddCommand ("echo",Cmd_Echo_f);
+	Cmd_AddCommand ("wait", Cmd_Wait_f);
+}
+
diff --git a/code/qcommon/common.cpp b/code/qcommon/common.cpp
new file mode 100644
index 0000000..402de50
--- /dev/null
+++ b/code/qcommon/common.cpp
@@ -0,0 +1,1580 @@
+// common.c -- misc functions used in client and server
+
+#include "../game/q_shared.h"
+#include "qcommon.h"
+#include "../qcommon/sstring.h"	// to get Gil's string class, because MS's doesn't compile properly in here
+#include "stv_version.h"
+
+#ifdef _XBOX
+#include "../win32/win_file.h"
+#include "../ui/ui_splash.h"
+#endif
+
+#ifndef FINAL_BUILD
+#include "platform.h"
+#endif
+
+#define	MAXPRINTMSG	4096
+
+#define MAX_NUM_ARGVS	50
+
+int		com_argc;
+char	*com_argv[MAX_NUM_ARGVS+1];
+
+#ifndef _XBOX
+static fileHandle_t	logfile;
+static fileHandle_t	speedslog;
+static fileHandle_t	camerafile;
+fileHandle_t	com_journalFile;
+fileHandle_t	com_journalDataFile;		// config files are written here
+#endif
+
+cvar_t	*com_viewlog;
+cvar_t	*com_speeds;
+cvar_t	*com_developer;
+cvar_t	*com_timescale;
+cvar_t	*com_fixedtime;
+cvar_t	*com_maxfps;
+cvar_t	*com_sv_running;
+cvar_t	*com_cl_running;
+cvar_t	*com_logfile;		// 1 = buffer log, 2 = flush after each print
+cvar_t	*com_showtrace;
+cvar_t	*com_terrainPhysics;
+cvar_t	*com_version;
+cvar_t	*com_buildScript;	// for automated data building scripts
+cvar_t	*cl_paused;
+cvar_t	*sv_paused;
+cvar_t	*com_skippingcin;
+cvar_t	*com_speedslog;		// 1 = buffer log, 2 = flush after each print
+
+#ifdef G2_PERFORMANCE_ANALYSIS
+cvar_t	*com_G2Report;
+#endif
+
+
+// com_speeds times
+int		time_game;
+int		time_frontend;		// renderer frontend time
+int		time_backend;		// renderer backend time
+
+int		timeInTrace;
+int		timeInPVSCheck;
+int		numTraces;
+
+int			com_frameTime;
+int			com_frameMsec;
+int			com_frameNumber = 0;
+
+qboolean	com_errorEntered;
+qboolean	com_fullyInitialized = qfalse;
+
+char	com_errorMessage[MAXPRINTMSG];
+
+void Com_WriteConfig_f( void );
+//JLF
+//void G_DemoFrame();
+
+//============================================================================
+
+#ifndef _XBOX
+static char	*rd_buffer;
+static int	rd_buffersize;
+static void	(*rd_flush)( char *buffer );
+
+void Com_BeginRedirect (char *buffer, int buffersize, void (*flush)( char *) )
+{
+	if (!buffer || !buffersize || !flush)
+		return;
+	rd_buffer = buffer;
+	rd_buffersize = buffersize;
+	rd_flush = flush;
+
+	*rd_buffer = 0;
+}
+
+void Com_EndRedirect (void)
+{
+	if ( rd_flush ) {
+		rd_flush(rd_buffer);
+	}
+
+	rd_buffer = NULL;
+	rd_buffersize = 0;
+	rd_flush = NULL;
+}
+#ifndef FINAL_BUILD
+#define OUTPUT_TO_BUILD_WINDOW
+#endif
+#endif	//not xbox
+
+/*
+=============
+Com_Printf
+
+Both client and server can use this, and it will output
+to the apropriate place.
+
+A raw string should NEVER be passed as fmt, because of "%f" type crashers.
+=============
+*/
+void QDECL Com_Printf( const char *fmt, ... ) {
+	va_list		argptr;
+	char		msg[MAXPRINTMSG];
+
+	va_start (argptr,fmt);
+	vsprintf (msg,fmt,argptr);
+	va_end (argptr);
+
+#ifndef _XBOX
+	if ( rd_buffer ) {
+		if ((strlen (msg) + strlen(rd_buffer)) > (rd_buffersize - 1)) {
+			rd_flush(rd_buffer);
+			*rd_buffer = 0;
+		}
+		strcat (rd_buffer, msg);
+		return;
+	}
+#endif
+
+	CL_ConsolePrint( msg );
+
+	// echo to dedicated console and early console
+	Sys_Print( msg );
+
+#ifdef OUTPUT_TO_BUILD_WINDOW
+	OutputDebugString(msg);
+#endif
+
+#ifndef _XBOX
+	// logfile
+	if ( com_logfile && com_logfile->integer ) {
+		if ( !logfile ) {
+			logfile = FS_FOpenFileWrite( "qconsole.log" );
+			if ( com_logfile->integer > 1 ) {
+				// force it to not buffer so we get valid
+				// data even if we are crashing
+				FS_ForceFlush(logfile);
+			}
+		}
+		if ( logfile ) {
+			FS_Write(msg, strlen(msg), logfile);
+		}
+	}
+#endif
+}
+
+
+/*
+================
+Com_DPrintf
+
+A Com_Printf that only shows up if the "developer" cvar is set
+================
+*/
+void QDECL Com_DPrintf( const char *fmt, ...) {
+	va_list		argptr;
+	char		msg[MAXPRINTMSG];
+		
+	if ( !com_developer || !com_developer->integer ) {
+		return;			// don't confuse non-developers with techie stuff...
+	}
+
+	va_start (argptr,fmt);
+	vsprintf (msg,fmt,argptr);
+	va_end (argptr);
+	
+	Com_Printf ("%s", msg);
+}
+
+void Com_WriteCam ( const char *text )
+{
+#ifndef _XBOX
+	static	char	mapname[MAX_QPATH];
+	// camerafile
+	if ( !camerafile ) 
+	{
+		extern	cvar_t	*sv_mapname;
+
+		//NOTE: always saves in working dir if using one...
+		sprintf( mapname, "maps/%s_cam.map", sv_mapname->string );
+		camerafile = FS_FOpenFileWrite( mapname );
+	}
+
+	if ( camerafile ) 
+	{
+		FS_Printf( camerafile, "%s", text );
+	}
+
+	Com_Printf( "%s\n", mapname );
+#endif
+}
+
+void Com_FlushCamFile()
+{
+#ifndef _XBOX
+	if (!camerafile)
+	{
+		// nothing to flush, right?
+		Com_Printf("No cam file available\n");
+		return;
+	}
+	FS_ForceFlush(camerafile);
+	FS_FCloseFile (camerafile);
+	camerafile = 0;
+
+	static	char	flushedMapname[MAX_QPATH];
+	extern	cvar_t	*sv_mapname;
+	sprintf( flushedMapname, "maps/%s_cam.map", sv_mapname->string );
+	Com_Printf("flushed all cams to %s\n", flushedMapname);
+#endif
+}
+
+/*
+=============
+Com_Error
+
+Both client and server can use this, and it will
+do the apropriate things.
+=============
+*/
+
+void SG_WipeSavegame(const char *name);	// pretty sucky, but that's how SoF did it...<g>
+void SG_Shutdown();
+//void SCR_UnprecacheScreenshot();
+
+void QDECL Com_Error( int code, const char *fmt, ... ) {
+	va_list		argptr;
+
+#if defined(_WIN32) && defined(_DEBUG)
+	if ( code != ERR_DISCONNECT && code != ERR_NEED_CD ) {
+//		if (com_noErrorInterrupt && !com_noErrorInterrupt->integer) 
+		{
+			__asm {
+				int 0x03
+			}
+		}
+	}
+#endif
+
+	// when we are running automated scripts, make sure we
+	// know if anything failed
+	if ( com_buildScript && com_buildScript->integer ) {
+		code = ERR_FATAL;
+	}
+
+	if ( com_errorEntered ) {
+		Sys_Error( "recursive error after: %s", com_errorMessage );
+	}
+	
+	com_errorEntered = qtrue;
+
+	//reset some game stuff here
+//	SCR_UnprecacheScreenshot();
+
+	va_start (argptr,fmt);
+	vsprintf (com_errorMessage,fmt,argptr);
+	va_end (argptr);	
+
+	if ( code != ERR_DISCONNECT ) {
+		Cvar_Get("com_errorMessage", "", CVAR_ROM);	//give com_errorMessage a default so it won't come back to life after a resetDefaults
+		Cvar_Set("com_errorMessage", com_errorMessage);
+	}
+
+	SG_Shutdown();				// close any file pointers
+	if ( code == ERR_DISCONNECT ) {
+		SV_Shutdown("Disconnect");
+		CL_Disconnect();
+		CL_FlushMemory();
+		CL_StartHunkUsers();
+		com_errorEntered = qfalse;
+		throw ("DISCONNECTED\n");
+	} else if ( code == ERR_DROP ) {
+		// If loading/saving caused the crash/error - delete the temp file
+		SG_WipeSavegame("current");	// delete file
+
+		SV_Shutdown (va("Server crashed: %s\n",  com_errorMessage));
+		CL_Disconnect();
+		CL_FlushMemory();
+		CL_StartHunkUsers();
+		Com_Printf (S_COLOR_RED"********************\n"S_COLOR_MAGENTA"ERROR: %s\n"S_COLOR_RED"********************\n", com_errorMessage);
+		com_errorEntered = qfalse;
+		throw ("DROPPED\n");
+	} else if ( code == ERR_NEED_CD ) {
+		SV_Shutdown( "Server didn't have CD\n" );
+		if ( com_cl_running && com_cl_running->integer ) {
+			CL_Disconnect();
+			CL_FlushMemory();
+			CL_StartHunkUsers();
+			com_errorEntered = qfalse;
+		} else {
+			Com_Printf("Server didn't have CD\n" );
+		}
+		throw ("NEED CD\n");
+	} else {
+		CL_Shutdown ();
+		SV_Shutdown (va(S_COLOR_RED"Server fatal crashed: %s\n", com_errorMessage));
+	}
+
+	Com_Shutdown ();
+
+	Sys_Error ("%s", com_errorMessage);
+}
+
+
+/*
+=============
+Com_Quit_f
+
+Both client and server can use this, and it will
+do the apropriate things.
+=============
+*/
+void Com_Quit_f( void ) {
+	// don't try to shutdown if we are in a recursive error
+	if ( !com_errorEntered ) {
+		SV_Shutdown ("Server quit\n");
+		CL_Shutdown ();
+		Com_Shutdown ();
+	}
+	Sys_Quit ();
+}
+
+
+
+/*
+============================================================================
+
+COMMAND LINE FUNCTIONS
+
++ characters seperate the commandLine string into multiple console
+command lines.
+
+All of these are valid:
+
+quake3 +set test blah +map test
+quake3 set test blah+map test
+quake3 set test blah + map test
+
+============================================================================
+*/
+
+#define	MAX_CONSOLE_LINES	32
+int		com_numConsoleLines;
+char	*com_consoleLines[MAX_CONSOLE_LINES];
+
+/*
+==================
+Com_ParseCommandLine
+
+Break it up into multiple console lines
+==================
+*/
+void Com_ParseCommandLine( char *commandLine ) {
+	com_consoleLines[0] = commandLine;
+	com_numConsoleLines = 1;
+
+	while ( *commandLine ) {
+		// look for a + seperating character
+		// if commandLine came from a file, we might have real line seperators
+		if ( *commandLine == '+' || *commandLine == '\n' ) {
+			if ( com_numConsoleLines == MAX_CONSOLE_LINES ) {
+				return;
+			}
+			com_consoleLines[com_numConsoleLines] = commandLine + 1;
+			com_numConsoleLines++;
+			*commandLine = 0;
+		}
+		commandLine++;
+	}
+}
+
+
+/*
+===================
+Com_SafeMode
+
+Check for "safe" on the command line, which will
+skip loading of jaconfig.cfg
+===================
+*/
+qboolean Com_SafeMode( void ) {
+	int		i;
+
+	for ( i = 0 ; i < com_numConsoleLines ; i++ ) {
+		Cmd_TokenizeString( com_consoleLines[i] );
+		if ( !Q_stricmp( Cmd_Argv(0), "safe" )
+			|| !Q_stricmp( Cmd_Argv(0), "cvar_restart" ) ) {
+			com_consoleLines[i][0] = 0;
+			return qtrue;
+		}
+	}
+	return qfalse;
+}
+
+
+/*
+===============
+Com_StartupVariable
+
+Searches for command line parameters that are set commands.
+If match is not NULL, only that cvar will be looked for.
+That is necessary because cddir and basedir need to be set
+before the filesystem is started, but all other sets should
+be after execing the config and default.
+===============
+*/
+void Com_StartupVariable( const char *match ) {
+	int		i;
+	char	*s;
+	cvar_t	*cv;
+
+	for (i=0 ; i < com_numConsoleLines ; i++) {
+		Cmd_TokenizeString( com_consoleLines[i] );
+		if ( strcmp( Cmd_Argv(0), "set" ) ) {
+			continue;
+		}
+
+		s = Cmd_Argv(1);
+		if ( !match || !stricmp( s, match ) ) {
+			Cvar_Set( s, Cmd_Argv(2) );
+			cv = Cvar_Get( s, "", 0 );
+			cv->flags |= CVAR_USER_CREATED;
+//			com_consoleLines[i] = 0;
+		}
+	}
+}
+
+
+/*
+=================
+Com_AddStartupCommands
+
+Adds command line parameters as script statements
+Commands are seperated by + signs
+
+Returns qtrue if any late commands were added, which
+will keep the demoloop from immediately starting
+=================
+*/
+qboolean Com_AddStartupCommands( void ) {
+	int		i;
+	qboolean	added;
+
+	added = qfalse;
+	// quote every token, so args with semicolons can work
+	for (i=0 ; i < com_numConsoleLines ; i++) {
+		if ( !com_consoleLines[i] || !com_consoleLines[i][0] ) {
+			continue;
+		}
+
+		// set commands won't override menu startup
+		if ( Q_stricmpn( com_consoleLines[i], "set", 3 ) ) {
+			added = qtrue;
+		}
+		Cbuf_AddText( com_consoleLines[i] );
+		Cbuf_AddText( "\n" );
+	}
+
+	return added;
+}
+
+
+//============================================================================
+
+
+void Info_Print( const char *s ) {
+	char	key[512];
+	char	value[512];
+	char	*o;
+	int		l;
+
+	if (*s == '\\')
+		s++;
+	while (*s)
+	{
+		o = key;
+		while (*s && *s != '\\')
+			*o++ = *s++;
+
+		l = o - key;
+		if (l < 20)
+		{
+			memset (o, ' ', 20-l);
+			key[20] = 0;
+		}
+		else
+			*o = 0;
+		Com_Printf ("%s", key);
+
+		if (!*s)
+		{
+			Com_Printf ("MISSING VALUE\n");
+			return;
+		}
+
+		o = value;
+		s++;
+		while (*s && *s != '\\')
+			*o++ = *s++;
+		*o = 0;
+
+		if (*s)
+			s++;
+		Com_Printf ("%s\n", value);
+	}
+}
+
+/*
+============
+Com_StringContains
+============
+*/
+char *Com_StringContains(char *str1, char *str2, int casesensitive) {
+	int len, i, j;
+
+	len = strlen(str1) - strlen(str2);
+	for (i = 0; i <= len; i++, str1++) {
+		for (j = 0; str2[j]; j++) {
+			if (casesensitive) {
+				if (str1[j] != str2[j]) {
+					break;
+				}
+			}
+			else {
+				if (toupper(str1[j]) != toupper(str2[j])) {
+					break;
+				}
+			}
+		}
+		if (!str2[j]) {
+			return str1;
+		}
+	}
+	return NULL;
+}
+
+/*
+============
+Com_Filter
+============
+*/
+int Com_Filter(char *filter, char *name, int casesensitive) {
+	char buf[MAX_TOKEN_CHARS];
+	char *ptr;
+	int i;
+
+	while(*filter) {
+		if (*filter == '*') {
+			filter++;
+			for (i = 0; *filter; i++) {
+				if (*filter == '*' || *filter == '?') {
+					break;
+				}
+				buf[i] = *filter;
+				filter++;
+			}
+			buf[i] = '\0';
+			if (strlen(buf)) {
+				ptr = Com_StringContains(name, buf, casesensitive);
+				if (!ptr) {
+					return qfalse;
+				}
+				name = ptr + strlen(buf);
+			}
+		}
+		else if (*filter == '?') {
+			filter++;
+			name++;
+		}
+		else {
+			if (casesensitive) {
+				if (*filter != *name) {
+					return qfalse;
+				}
+			}
+			else {
+				if (toupper(*filter) != toupper(*name)) {
+					return qfalse;
+				}
+			}
+			filter++;
+			name++;
+		}
+	}
+	return qtrue;
+}
+
+
+
+/*
+=================
+Com_InitHunkMemory
+=================
+*/
+void Com_InitHunkMemory( void )
+{
+	Hunk_Clear();
+
+//	Cmd_AddCommand( "meminfo", Z_Details_f );
+}
+
+// I'm leaving this in just in case we ever need to remember where's a good place to hook something like this in.
+//
+void Com_ShutdownHunkMemory(void)
+{
+}
+
+
+/*
+===================
+Hunk_SetMark
+
+The server calls this after the level and game VM have been loaded
+===================
+*/
+void Hunk_SetMark( void ) 
+{
+}
+
+
+
+/*
+=================
+Hunk_ClearToMark
+
+The client calls this before starting a vid_restart or snd_restart
+=================
+*/
+void Hunk_ClearToMark( void ) 
+{
+	Z_TagFree(TAG_HUNKALLOC);	
+	Z_TagFree(TAG_HUNKMISCMODELS);
+}
+
+
+
+/*
+=================
+Hunk_Clear
+
+The server calls this before shutting down or loading a new map
+=================
+*/
+void Hunk_Clear( void ) 
+{
+	Z_TagFree(TAG_HUNKALLOC);
+	Z_TagFree(TAG_HUNKMISCMODELS);
+
+	extern void CIN_CloseAllVideos();
+				CIN_CloseAllVideos();
+
+	extern void R_ClearStuffToStopGhoul2CrashingThings(void);
+				R_ClearStuffToStopGhoul2CrashingThings();
+}
+
+
+
+
+
+
+/*
+===================================================================
+
+EVENTS AND JOURNALING
+
+In addition to these events, .cfg files are also copied to the
+journaled file
+===================================================================
+*/
+
+#define	MAX_PUSHED_EVENTS	64
+int			com_pushedEventsHead, com_pushedEventsTail;
+sysEvent_t	com_pushedEvents[MAX_PUSHED_EVENTS];
+
+/*
+=================
+Com_GetRealEvent
+=================
+*/
+sysEvent_t	Com_GetRealEvent( void ) {
+	sysEvent_t	ev;
+
+	// get an event from the system
+		ev = Sys_GetEvent();
+
+	return ev;
+}
+
+/*
+=================
+Com_PushEvent
+=================
+*/
+void Com_PushEvent( sysEvent_t *event ) {
+	sysEvent_t		*ev;
+	static int		printedWarning;
+
+	ev = &com_pushedEvents[ com_pushedEventsHead & (MAX_PUSHED_EVENTS-1) ];
+
+	if ( com_pushedEventsHead - com_pushedEventsTail >= MAX_PUSHED_EVENTS ) {
+
+		// don't print the warning constantly, or it can give time for more...
+		if ( !printedWarning ) {
+			printedWarning = qtrue;
+			Com_Printf( "WARNING: Com_PushEvent overflow\n" );
+		}
+
+		if ( ev->evPtr ) {
+			Z_Free( ev->evPtr );
+		}
+		com_pushedEventsTail++;
+	} else {
+		printedWarning = qfalse;
+	}
+
+	*ev = *event;
+	com_pushedEventsHead++;
+}
+
+/*
+=================
+Com_GetEvent
+=================
+*/
+sysEvent_t	Com_GetEvent( void ) {
+	if ( com_pushedEventsHead > com_pushedEventsTail ) {
+		com_pushedEventsTail++;
+		return com_pushedEvents[ (com_pushedEventsTail-1) & (MAX_PUSHED_EVENTS-1) ];
+	}
+	return Com_GetRealEvent();
+}
+
+/*
+=================
+Com_RunAndTimeServerPacket
+=================
+*/
+void Com_RunAndTimeServerPacket( netadr_t *evFrom, msg_t *buf ) {
+	int		t1, t2, msec;
+
+	t1 = 0;
+
+	if ( com_speeds->integer ) {
+		t1 = Sys_Milliseconds ();
+	}
+
+	SV_PacketEvent( *evFrom, buf );
+
+	if ( com_speeds->integer ) {
+		t2 = Sys_Milliseconds ();
+		msec = t2 - t1;
+		if ( com_speeds->integer == 3 ) {
+			Com_Printf( "SV_PacketEvent time: %i\n", msec );
+		}
+	}
+}
+
+/*
+=================
+Com_EventLoop
+
+Returns last event time
+=================
+*/
+int Com_EventLoop( void ) {
+	sysEvent_t	ev;
+	netadr_t	evFrom;
+	byte		bufData[MAX_MSGLEN];
+	msg_t		buf;
+
+	MSG_Init( &buf, bufData, sizeof( bufData ) );
+
+	while ( 1 ) {
+		ev = Com_GetEvent();
+
+		// if no more events are available
+		if ( ev.evType == SE_NONE ) {
+			// manually send packet events for the loopback channel
+			while ( NET_GetLoopPacket( NS_CLIENT, &evFrom, &buf ) ) {
+				CL_PacketEvent( evFrom, &buf );
+			}
+
+			while ( NET_GetLoopPacket( NS_SERVER, &evFrom, &buf ) ) {
+				// if the server just shut down, flush the events
+				if ( com_sv_running->integer ) {
+					Com_RunAndTimeServerPacket( &evFrom, &buf );
+				}
+			}
+
+			return ev.evTime;
+		}
+
+
+		switch ( ev.evType ) {
+		default:
+			Com_Error( ERR_FATAL, "Com_EventLoop: bad event type %i", ev.evTime );
+			break;
+        case SE_NONE:
+            break;
+		case SE_KEY:
+			CL_KeyEvent( ev.evValue, ev.evValue2, ev.evTime );
+			break;
+		case SE_CHAR:
+			CL_CharEvent( ev.evValue );
+			break;
+		case SE_MOUSE:
+			CL_MouseEvent( ev.evValue, ev.evValue2, ev.evTime );
+			break;
+		case SE_JOYSTICK_AXIS:
+			CL_JoystickEvent( ev.evValue, ev.evValue2, ev.evTime );
+			break;
+		case SE_CONSOLE:
+			Cbuf_AddText( (char *)ev.evPtr );
+			Cbuf_AddText( "\n" );
+			break;
+		case SE_PACKET:
+			evFrom = *(netadr_t *)ev.evPtr;
+			buf.cursize = ev.evPtrLength - sizeof( evFrom );
+
+			// we must copy the contents of the message out, because
+			// the event buffers are only large enough to hold the
+			// exact payload, but channel messages need to be large
+			// enough to hold fragment reassembly
+			if ( (unsigned)buf.cursize > buf.maxsize ) {
+				Com_Printf("Com_EventLoop: oversize packet\n");
+				continue;
+			}
+			memcpy( buf.data, (byte *)((netadr_t *)ev.evPtr + 1), buf.cursize );
+			if ( com_sv_running->integer ) {
+				Com_RunAndTimeServerPacket( &evFrom, &buf );
+			} else {
+				CL_PacketEvent( evFrom, &buf );
+			}
+			break;
+		}
+
+		// free any block data
+		if ( ev.evPtr ) {
+			Z_Free( ev.evPtr );
+		}
+	}
+}
+
+/*
+================
+Com_Milliseconds
+
+Can be used for profiling, but will be journaled accurately
+================
+*/
+int Com_Milliseconds (void) {
+	sysEvent_t	ev;
+
+	// get events and push them until we get a null event with the current time
+	do {
+
+		ev = Com_GetRealEvent();
+		if ( ev.evType != SE_NONE ) {
+			Com_PushEvent( &ev );
+		}
+	} while ( ev.evType != SE_NONE );
+	
+	return ev.evTime;
+}
+
+//============================================================================
+
+/*
+=============
+Com_Error_f
+
+Just throw a fatal error to
+test error shutdown procedures
+=============
+*/
+static void Com_Error_f (void) {
+	if ( Cmd_Argc() > 1 ) {
+		Com_Error( ERR_DROP, "Testing drop error" );
+	} else {
+		Com_Error( ERR_FATAL, "Testing fatal error" );
+	}
+}
+
+
+/*
+=============
+Com_Freeze_f
+
+Just freeze in place for a given number of seconds to test
+error recovery
+=============
+*/
+static void Com_Freeze_f (void) {
+	float	s;
+	int		start, now;
+
+	if ( Cmd_Argc() != 2 ) {
+		Com_Printf( "freeze <seconds>\n" );
+		return;
+	}
+	s = atof( Cmd_Argv(1) );
+
+	start = Com_Milliseconds();
+
+	while ( 1 ) {
+		now = Com_Milliseconds();
+		if ( ( now - start ) * 0.001 > s ) {
+			break;
+		}
+	}
+}
+
+/*
+=================
+Com_Crash_f
+
+A way to force a bus error for development reasons
+=================
+*/
+static void Com_Crash_f( void ) {
+	* ( int * ) 0 = 0x12345678;
+}
+
+/*
+=================
+Com_Init
+=================
+*/
+extern void Com_InitZoneMemory();
+extern void R_InitWorldEffects();
+void Com_Init( char *commandLine ) {
+	char	*s;
+
+	Com_Printf( "%s %s %s\n", Q3_VERSION, CPUSTRING, __DATE__ );
+
+	try {
+		// prepare enough of the subsystems to handle
+		// cvar and command buffer management
+		Com_ParseCommandLine( commandLine );
+
+		Swap_Init ();
+		Cbuf_Init ();
+
+		Com_InitZoneMemory();
+
+#ifdef _XBOX
+		WF_Init();
+		// set up ri
+		extern void CL_InitRef( void );
+		CL_InitRef();
+
+		// register renderer cvars
+		extern void R_Register(void);
+		R_Register();
+
+		// start the gl render layer
+		extern void GLimp_Init(void);
+		GLimp_Init();
+
+		// put up the license screen
+		SP_DoLicense();
+#endif
+
+		Cmd_Init ();
+		Cvar_Init ();
+
+		// get the commandline cvars set
+		Com_StartupVariable( NULL );
+
+		// done early so bind command exists
+		CL_InitKeyCommands();
+
+#ifdef _XBOX
+		extern void Sys_FilecodeScan_f();
+		Sys_InitFileCodes();
+		Cmd_AddCommand("filecodes", Sys_FilecodeScan_f);
+
+		extern void Sys_StreamInit();
+		Sys_StreamInit();
+#endif
+
+		FS_InitFilesystem ();	//uses z_malloc
+		R_InitWorldEffects();   // this doesn't do much but I want to be sure certain variables are intialized.
+		
+		Cbuf_AddText ("exec default.cfg\n");
+
+		// skip the jaconfig.cfg if "safe" is on the command line
+		if ( !Com_SafeMode() ) {
+			Cbuf_AddText ("exec jaconfig.cfg\n");
+		}
+
+		Cbuf_AddText ("exec autoexec.cfg\n");
+		
+		Cbuf_Execute ();
+
+		// override anything from the config files with command line args
+		Com_StartupVariable( NULL );
+		
+		// allocate the stack based hunk allocator
+		Com_InitHunkMemory();
+
+		// if any archived cvars are modified after this, we will trigger a writing
+		// of the config file
+		cvar_modifiedFlags &= ~CVAR_ARCHIVE;
+		
+		//
+		// init commands and vars
+		//
+		Cmd_AddCommand ("quit", Com_Quit_f);
+		Cmd_AddCommand ("writeconfig", Com_WriteConfig_f );
+		
+		com_maxfps = Cvar_Get ("com_maxfps", "85", CVAR_ARCHIVE);
+		
+		com_developer = Cvar_Get ("developer", "0", CVAR_TEMP );
+		com_logfile = Cvar_Get ("logfile", "0", CVAR_TEMP );
+		com_speedslog = Cvar_Get ("speedslog", "0", CVAR_TEMP );
+		
+		com_timescale = Cvar_Get ("timescale", "1", CVAR_CHEAT );
+		com_fixedtime = Cvar_Get ("fixedtime", "0", CVAR_CHEAT);
+		com_showtrace = Cvar_Get ("com_showtrace", "0", CVAR_CHEAT);
+		com_terrainPhysics = Cvar_Get ("com_terrainPhysics", "1", CVAR_CHEAT);
+		com_viewlog = Cvar_Get( "viewlog", "0", CVAR_TEMP );
+		com_speeds = Cvar_Get ("com_speeds", "0", 0);
+		
+#ifdef G2_PERFORMANCE_ANALYSIS
+		com_G2Report = Cvar_Get("com_G2Report", "0", 0);
+#endif
+
+		cl_paused	   = Cvar_Get ("cl_paused", "0", CVAR_ROM);
+		sv_paused	   = Cvar_Get ("sv_paused", "0", CVAR_ROM);
+		com_sv_running = Cvar_Get ("sv_running", "0", CVAR_ROM);
+		com_cl_running = Cvar_Get ("cl_running", "0", CVAR_ROM);
+		com_skippingcin = Cvar_Get ("skippingCinematic", "0", CVAR_ROM);
+		com_buildScript = Cvar_Get( "com_buildScript", "0", 0 );
+		
+		if ( com_developer && com_developer->integer ) {
+			Cmd_AddCommand ("error", Com_Error_f);
+			Cmd_AddCommand ("crash", Com_Crash_f );
+			Cmd_AddCommand ("freeze", Com_Freeze_f);
+		}
+		
+		s = va("%s %s %s", Q3_VERSION, CPUSTRING, __DATE__ );
+		com_version = Cvar_Get ("version", s, CVAR_ROM | CVAR_SERVERINFO );
+
+		SE_Init();	// Initialize StringEd
+	
+		Sys_Init();	// this also detects CPU type, so I can now do this CPU check below...
+
+		Netchan_Init( Com_Milliseconds() & 0xffff );	// pick a port value that should be nice and random
+//	VM_Init();
+		SV_Init();
+		
+		CL_Init();
+
+#ifdef _XBOX
+		// Experiment. Sound memory never gets freed, move it earlier. This
+		// will also let us play movies sooner, if we need to.
+		extern void CL_StartSound(void);
+		CL_StartSound();
+#endif
+
+		Sys_ShowConsole( com_viewlog->integer, qfalse );
+		
+		// set com_frameTime so that if a map is started on the
+		// command line it will still be able to count on com_frameTime
+		// being random enough for a serverid
+		com_frameTime = Com_Milliseconds();
+
+		// add + commands from command line
+#ifndef _XBOX
+		if ( !Com_AddStartupCommands() ) {
+#ifdef NDEBUG
+			// if the user didn't give any commands, run default action
+//			if ( !com_dedicated->integer ) 
+			{
+				Cbuf_AddText ("cinematic openinglogos\n");
+//				if( !com_introPlayed->integer ) {
+//					Cvar_Set( com_introPlayed->name, "1" );
+//					Cvar_Set( "nextmap", "cinematic intro" );
+//				}
+			}
+#endif	
+		}
+#endif
+		com_fullyInitialized = qtrue;
+		Com_Printf ("--- Common Initialization Complete ---\n");
+
+//HACKERY FOR THE DEUTSCH		
+		//if ( (Cvar_VariableIntegerValue("ui_iscensored") == 1) 	//if this was on before, set it again so it gets its flags
+		//	)
+		//{
+		//	Cvar_Get( "ui_iscensored",   "1", CVAR_ARCHIVE|CVAR_ROM|CVAR_INIT|CVAR_CHEAT|CVAR_NORESTART);
+		//	Cvar_Set( "ui_iscensored",   "1");	//just in case it was archived
+		//	// NOTE : I also create this in UI_Init()
+		//	Cvar_Get( "g_dismemberment", "0", CVAR_ARCHIVE|CVAR_ROM|CVAR_INIT|CVAR_CHEAT);
+		//	Cvar_Set( "g_dismemberment", "0");	//just in case it was archived
+		//}
+	}
+
+	catch (const char* reason) {
+		Sys_Error ("Error during initialization %s", reason);
+	}
+
+#ifdef _XBOX
+	//Load these early to keep them at the beginning of memory.  Perhaps
+	//here is too early though.  After the license screen would be better.
+	extern void SE_CheckForLanguageUpdates(void);
+	SE_CheckForLanguageUpdates();
+#endif
+
+}
+
+//==================================================================
+
+void Com_WriteConfigToFile( const char *filename ) {
+#ifndef _XBOX
+	fileHandle_t	f;
+
+	f = FS_FOpenFileWrite( filename );
+	if ( !f ) {
+		Com_Printf ("Couldn't write %s.\n", filename );
+		return;
+	}
+
+	FS_Printf (f, "// generated by Star Wars Jedi Academy, do not modify\n");
+	Key_WriteBindings (f);
+	Cvar_WriteVariables (f);
+	FS_FCloseFile( f );
+#endif
+}
+
+
+/*
+===============
+Com_WriteConfiguration
+
+Writes key bindings and archived cvars to config file if modified
+===============
+*/
+void Com_WriteConfiguration( void ) {
+	// if we are quiting without fully initializing, make sure
+	// we don't write out anything
+	if ( !com_fullyInitialized ) {
+		return;
+	}
+
+	if ( !(cvar_modifiedFlags & CVAR_ARCHIVE ) ) {
+		return;
+	}
+	cvar_modifiedFlags &= ~CVAR_ARCHIVE;
+
+	Com_WriteConfigToFile( "jaconfig.cfg" );
+}
+
+
+/*
+===============
+Com_WriteConfig_f
+
+Write the config file to a specific name
+===============
+*/
+void Com_WriteConfig_f( void ) {
+	char	filename[MAX_QPATH];
+
+	if ( Cmd_Argc() != 2 ) {
+		Com_Printf( "Usage: writeconfig <filename>\n" );
+		return;
+	}
+
+	Q_strncpyz( filename, Cmd_Argv(1), sizeof( filename ) );
+	COM_DefaultExtension( filename, sizeof( filename ), ".cfg" );
+	Com_Printf( "Writing %s.\n", filename );
+	Com_WriteConfigToFile( filename );
+}
+
+/*
+================
+Com_ModifyMsec
+================
+*/
+
+
+int Com_ModifyMsec( int msec, float &fraction ) 
+{
+	int		clampTime;
+
+	fraction=0.0f;
+
+	//
+	// modify time for debugging values
+	//
+	if ( com_fixedtime->integer ) 
+	{
+		msec = com_fixedtime->integer;
+	} 
+	else if ( com_timescale->value ) 
+	{
+		fraction=(float)msec;
+		fraction*=com_timescale->value;
+		msec=(int)floor(fraction);
+		fraction-=(float)msec;
+	}
+	
+	// don't let it scale below 1 msec
+	if ( msec < 1 ) 
+	{
+		msec = 1;
+		fraction=0.0f;
+	}
+
+	if ( com_skippingcin->integer ) {
+		// we're skipping ahead so let it go a bit faster
+		clampTime = 500;
+	} else {
+		// for local single player gaming
+		// we may want to clamp the time to prevent players from
+		// flying off edges when something hitches.
+		clampTime = 200;
+	}
+
+	if ( msec > clampTime ) {
+		msec = clampTime;
+		fraction=0.0f;
+	}
+
+	return msec;
+}
+
+/*
+=================
+Com_Frame
+=================
+*/
+static vec3_t corg;
+static vec3_t cangles;
+static bool bComma;
+void Com_SetOrgAngles(vec3_t org,vec3_t angles)
+{
+	VectorCopy(org,corg);
+	VectorCopy(angles,cangles);
+}
+
+#ifdef G2_PERFORMANCE_ANALYSIS
+void G2Time_ResetTimers(void);
+void G2Time_ReportTimers(void);
+#endif
+
+#pragma warning (disable: 4701)	//local may have been used without init (timing info vars)
+void Com_Frame( void ) {
+try 
+{
+	int		timeBeforeFirstEvents, timeBeforeServer, timeBeforeEvents, timeBeforeClient, timeAfter;
+	int		msec, minMsec;
+	static int	lastTime;
+
+	// write config file if anything changed
+#ifndef _XBOX
+	Com_WriteConfiguration(); 
+
+	// if "viewlog" has been modified, show or hide the log console
+	if ( com_viewlog->modified ) {
+		Sys_ShowConsole( com_viewlog->integer, qfalse );
+		com_viewlog->modified = qfalse;
+	}
+#endif
+
+	//
+	// main event loop
+	//
+	if ( com_speeds->integer ) {
+		timeBeforeFirstEvents = Sys_Milliseconds ();
+	}
+
+	// we may want to spin here if things are going too fast
+	if ( com_maxfps->integer > 0 ) {
+		minMsec = 1000 / com_maxfps->integer;
+	} else {
+		minMsec = 1;
+	}
+	do {
+		com_frameTime = Com_EventLoop();
+		if ( lastTime > com_frameTime ) {
+			lastTime = com_frameTime;		// possible on first frame
+		}
+		msec = com_frameTime - lastTime;
+	} while ( msec < minMsec );
+	Cbuf_Execute ();
+
+	lastTime = com_frameTime;
+
+	// mess with msec if needed
+	com_frameMsec = msec;
+	float fractionMsec=0.0f;
+	msec = Com_ModifyMsec( msec, fractionMsec);
+	
+	//
+	// server side
+	//
+	if ( com_speeds->integer ) {
+		timeBeforeServer = Sys_Milliseconds ();
+	}
+
+	SV_Frame (msec, fractionMsec);
+
+
+	//
+	// client system
+	//
+#ifdef _XBOX
+//	extern void G_DemoFrame();
+
+//	G_DemoFrame();
+	extern bool TestDemoTimer();
+	extern void PlayDemo();
+	if ( TestDemoTimer())
+	{
+		PlayDemo();
+	}
+
+
+#endif
+//	if ( !com_dedicated->integer ) 
+	{
+		//
+		// run event loop a second time to get server to client packets
+		// without a frame of latency
+		//
+		if ( com_speeds->integer ) {
+			timeBeforeEvents = Sys_Milliseconds ();
+		}
+		Com_EventLoop();
+		Cbuf_Execute ();
+
+
+		//
+		// client side
+		//
+		if ( com_speeds->integer ) {
+			timeBeforeClient = Sys_Milliseconds ();
+		}
+
+		CL_Frame (msec, fractionMsec);
+
+		if ( com_speeds->integer ) {
+			timeAfter = Sys_Milliseconds ();
+		}
+	}
+
+
+	//
+	// report timing information
+	//
+	if ( com_speeds->integer ) {
+		int			all, sv, ev, cl;
+
+		all = timeAfter - timeBeforeServer;
+		sv = timeBeforeEvents - timeBeforeServer;
+		ev = timeBeforeServer - timeBeforeFirstEvents + timeBeforeClient - timeBeforeEvents;
+		cl = timeAfter - timeBeforeClient;
+		sv -= time_game;
+		cl -= time_frontend + time_backend;
+
+		Com_Printf("fr:%i all:%3i sv:%3i ev:%3i cl:%3i gm:%3i tr:%3i pvs:%3i rf:%3i bk:%3i\n", 
+					com_frameNumber, all, sv, ev, cl, time_game, timeInTrace, timeInPVSCheck, time_frontend, time_backend);
+
+#ifndef _XBOX
+		// speedslog
+		if ( com_speedslog && com_speedslog->integer )
+		{
+			if(!speedslog)
+			{
+				speedslog = FS_FOpenFileWrite("speeds.log");
+				FS_Write("data={\n", strlen("data={\n"), speedslog);
+				bComma=false;
+				if ( com_speedslog->integer > 1 ) 
+				{
+					// force it to not buffer so we get valid
+					// data even if we are crashing
+					FS_ForceFlush(logfile);
+				}
+			}
+			if (speedslog)
+			{
+				char		msg[MAXPRINTMSG];
+
+				if(bComma)
+				{
+					FS_Write(",\n", strlen(",\n"), speedslog);
+					bComma=false;
+				}
+				FS_Write("{", strlen("{"), speedslog);
+				Com_sprintf(msg,sizeof(msg),
+							"%8.4f,%8.4f,%8.4f,%8.4f,%8.4f,%8.4f,",corg[0],corg[1],corg[2],cangles[0],cangles[1],cangles[2]);
+				FS_Write(msg, strlen(msg), speedslog);
+				Com_sprintf(msg,sizeof(msg),
+					"%i,%3i,%3i,%3i,%3i,%3i,%3i,%3i,%3i,%3i}", 
+					com_frameNumber, all, sv, ev, cl, time_game, timeInTrace, timeInPVSCheck, time_frontend, time_backend);
+				FS_Write(msg, strlen(msg), speedslog);
+				bComma=true;
+			}
+		}
+#endif
+
+		timeInTrace = timeInPVSCheck = 0;
+	}
+
+	//
+	// trace optimization tracking
+	//
+	if ( com_showtrace->integer ) {
+		extern	int c_traces, c_brush_traces, c_patch_traces;
+		extern	int	c_pointcontents;
+
+		/*
+		Com_Printf( "%4i non-sv_traces, %4i sv_traces, %4i ms, ave %4.2f ms\n", c_traces - numTraces, numTraces, timeInTrace, (float)timeInTrace/(float)numTraces );
+		timeInTrace = numTraces = 0;
+		c_traces = 0;
+		*/
+		
+		Com_Printf ("%4i traces  (%ib %ip) %4i points\n", c_traces,
+			c_brush_traces, c_patch_traces, c_pointcontents);
+		c_traces = 0;
+		c_brush_traces = 0;
+		c_patch_traces = 0;
+		c_pointcontents = 0;
+	}
+
+	com_frameNumber++;
+}//try
+	catch (const char* reason) {
+		Com_Printf (reason);
+		return;			// an ERR_DROP was thrown
+	}
+
+#ifdef G2_PERFORMANCE_ANALYSIS
+	if (com_G2Report && com_G2Report->integer)
+	{
+		G2Time_ReportTimers();
+	}
+
+	G2Time_ResetTimers();
+#endif
+}
+
+#pragma warning (default: 4701)	//local may have been used without init
+
+/*
+=================
+Com_Shutdown
+=================
+*/
+extern void CM_FreeShaderText(void);
+void Com_Shutdown (void) {
+	CM_ClearMap();
+
+#ifndef _XBOX
+	CM_FreeShaderText();
+
+	if (logfile) {
+		FS_FCloseFile (logfile);
+		logfile = 0;
+	}
+
+	if (speedslog) {
+		FS_Write("\n};", strlen("\n};"), speedslog);
+		FS_FCloseFile (speedslog);
+		speedslog = 0;
+	}
+
+	if (camerafile) {
+		FS_FCloseFile (camerafile);
+		camerafile = 0;
+	}
+
+	if ( com_journalFile ) {
+		FS_FCloseFile( com_journalFile );
+		com_journalFile = 0;
+	}
+#endif
+
+#ifdef _XBOX
+	extern void Sys_StreamShutdown();
+	Sys_StreamShutdown();
+	Sys_ShutdownFileCodes();
+#endif
+
+	SE_ShutDown();//close the string packages
+
+	extern void Netchan_Shutdown();
+	Netchan_Shutdown();
+}
+
+/*
+============
+ParseTextFile
+============
+*/
+
+bool Com_ParseTextFile(const char *file, class CGenericParser2 &parser, bool cleanFirst)
+{
+	fileHandle_t	f;
+	int				length = 0;
+	char			*buf = 0, *bufParse = 0;
+
+	length = FS_FOpenFileByMode( file, &f, FS_READ );
+	if (!f || !length)		
+	{
+		return false;
+	}
+
+	buf = new char [length + 1];
+	FS_Read( buf, length, f );
+	buf[length] = 0;
+
+	bufParse = buf;
+	parser.Parse(&bufParse, cleanFirst);
+	delete buf;
+
+	FS_FCloseFile( f );
+
+	return true;
+}
+
+void Com_ParseTextFileDestroy(class CGenericParser2 &parser)
+{
+	parser.Clean();
+}
+
+CGenericParser2 *Com_ParseTextFile(const char *file, bool cleanFirst, bool writeable)
+{
+	fileHandle_t	f;
+	int				length = 0;
+	char			*buf = 0, *bufParse = 0;
+	CGenericParser2 *parse;
+
+	length = FS_FOpenFileByMode( file, &f, FS_READ );
+	if (!f || !length)		
+	{
+		return 0;
+	}
+
+	buf = new char [length + 1];
+	FS_Read( buf, length, f );
+	FS_FCloseFile( f );
+	buf[length] = 0;
+
+	bufParse = buf;
+
+	parse = new CGenericParser2;
+	if (!parse->Parse(&bufParse, cleanFirst, writeable))
+	{
+		delete parse;
+		parse = 0;
+	}
+
+	delete buf;
+
+	return parse;
+}
+
diff --git a/code/qcommon/cvar.cpp b/code/qcommon/cvar.cpp
new file mode 100644
index 0000000..49505d0
--- /dev/null
+++ b/code/qcommon/cvar.cpp
@@ -0,0 +1,951 @@
+// cvar.c -- dynamic variable tracking
+
+#include "../game/q_shared.h"
+#include "qcommon.h"
+
+cvar_t		*cvar_vars;
+cvar_t		*cvar_cheats;
+int			cvar_modifiedFlags;
+
+#define	MAX_CVARS	1024
+cvar_t		cvar_indexes[MAX_CVARS];
+int			cvar_numIndexes;
+
+
+cvar_t *Cvar_Set2( const char *var_name, const char *value, qboolean force);
+
+static char *lastMemPool = NULL;
+static int memPoolSize;
+
+
+//If the string came from the memory pool, don't really free it.  The entire
+//memory pool will be wiped during the next level load.
+static void Cvar_FreeString(char *string)
+{
+	if(!lastMemPool || string < lastMemPool ||
+			string >= lastMemPool + memPoolSize) { 
+		Z_Free(string);
+	}
+}
+
+/*
+============
+Cvar_ValidateString
+============
+*/
+static qboolean Cvar_ValidateString( const char *s ) {
+	if ( !s ) {
+		return qfalse;
+	}
+	if ( strchr( s, '\\' ) ) {
+		return qfalse;
+	}
+	if ( strchr( s, '\"' ) ) {
+		return qfalse;
+	}
+	if ( strchr( s, ';' ) ) {
+		return qfalse;
+	}
+	return qtrue;
+}
+
+/*
+============
+Cvar_FindVar
+============
+*/
+static cvar_t *Cvar_FindVar( const char *var_name ) {
+	cvar_t	*var;
+	
+	for (var=cvar_vars ; var ; var=var->next) {
+		if (!Q_stricmp(var_name, var->name)) {
+			return var;
+		}
+	}
+
+	return NULL;
+}
+
+/*
+============
+Cvar_VariableValue
+============
+*/
+float Cvar_VariableValue( const char *var_name ) {
+	cvar_t	*var;
+	
+	var = Cvar_FindVar (var_name);
+	if (!var)
+		return 0;
+	return var->value;
+}
+
+
+/*
+============
+Cvar_VariableIntegerValue
+============
+*/
+int Cvar_VariableIntegerValue( const char *var_name ) {
+	cvar_t	*var;
+	
+	var = Cvar_FindVar (var_name);
+	if (!var)
+		return 0;
+	return var->integer;
+}
+
+
+/*
+============
+Cvar_VariableString
+============
+*/
+char *Cvar_VariableString( const char *var_name ) {
+	cvar_t *var;
+	
+	var = Cvar_FindVar (var_name);
+	if (!var)
+		return "";
+	return var->string;
+}
+
+
+/*
+============
+Cvar_VariableStringBuffer
+============
+*/
+void Cvar_VariableStringBuffer( const char *var_name, char *buffer, int bufsize ) {
+	cvar_t *var;
+	
+	var = Cvar_FindVar (var_name);
+	if (!var) {
+		*buffer = 0;
+	}
+	else {
+		Q_strncpyz( buffer, var->string, bufsize );
+	}
+}
+
+
+/*
+============
+Cvar_CompleteVariable
+============
+*/
+char *Cvar_CompleteVariable( const char *partial ) {
+	cvar_t		*cvar;
+	int			len;
+	
+	len = strlen(partial);
+	
+	if ( !len ) {
+		return NULL;
+	}
+		
+	// check partial match
+	for ( cvar=cvar_vars ; cvar ; cvar=cvar->next ) {
+		if ( !Q_stricmpn (partial,cvar->name, len) ) {
+			if ( (cvar->flags & CVAR_CHEAT) && !cvar_cheats->integer ) {
+				continue;
+			}
+			else {
+				return cvar->name;
+			}
+		}
+	}
+
+	return NULL;
+}
+
+/*
+============
+Cvar_CompleteVariableNext - get the next cvar in alphabetical order.
+
+============
+*/
+char *Cvar_CompleteVariableNext (char *partial, char *last)
+{
+	cvar_t		*cvar, *base;
+	int			len;
+	
+	len = strlen(partial);
+	
+	if (!len)
+		return NULL;
+		
+	// this check needed since cvars may be resetting from cmd searches
+	base = NULL;
+	if(last)
+	{
+		for (cvar=cvar_vars; cvar; cvar = cvar->next)
+		{
+			if(!Q_stricmp(last, cvar->name))
+			{
+				base = cvar->next;
+				break;
+			}
+		}
+		if(base == NULL)
+		{	//not found, either error or at end of list
+			return NULL;
+		}
+	}
+	else
+	{
+		base = cvar_vars;
+	}
+
+	// check partial match
+	for (cvar=base ; cvar ; cvar=cvar->next)
+	{
+		if (!Q_stricmpn (partial,cvar->name, len)) {
+			if ( (cvar->flags & CVAR_CHEAT) && !cvar_cheats->integer ) {
+				continue;
+			}
+			else {
+				return cvar->name;
+			}
+		}
+	}
+
+	return NULL;
+}
+
+/*
+============
+Cvar_Get
+
+If the variable already exists, the value will not be set unless CVAR_ROM
+The flags will be or'ed in if the variable exists.
+============
+*/
+cvar_t *Cvar_Get( const char *var_name, const char *var_value, int flags ) {
+	cvar_t	*var;
+
+    if ( !var_name || ! var_value ) {
+		Com_Error( ERR_FATAL, "Cvar_Get: NULL parameter" );
+    }
+
+	if ( !Cvar_ValidateString( var_name ) ) {
+		Com_Printf("invalid cvar name string: %s\n", var_name );
+		var_name = "BADNAME";
+	}
+
+#if 0		// FIXME: values with backslash happen
+	if ( !Cvar_ValidateString( var_value ) ) {
+		Com_Printf("invalid cvar value string: %s\n", var_value );
+		var_value = "BADVALUE";
+	}
+#endif
+
+	var = Cvar_FindVar (var_name);
+	if ( var ) {
+		// if the C code is now specifying a variable that the user already
+		// set a value for, take the new value as the reset value
+		if ( ( var->flags & CVAR_USER_CREATED ) && !( flags & CVAR_USER_CREATED )
+			&& var_value[0] ) {
+			var->flags &= ~CVAR_USER_CREATED;
+			Cvar_FreeString( var->resetString );
+			var->resetString = CopyString( var_value );
+
+			// ZOID--needs to be set so that cvars the game sets as 
+			// SERVERINFO get sent to clients
+			cvar_modifiedFlags |= flags;
+		}
+
+		var->flags |= flags;
+		// only allow one non-empty reset string without a warning
+		if ( !var->resetString[0] ) {
+			// we don't have a reset string yet
+			Cvar_FreeString( var->resetString );
+			var->resetString = CopyString( var_value );
+		} else if ( var_value[0] && strcmp( var->resetString, var_value ) ) {
+			Com_Printf( "Warning: cvar \"%s\" given initial values: \"%s\" and \"%s\"\n",
+				var_name, var->resetString, var_value );
+		}
+		// if we have a latched string, take that value now
+		if ( var->latchedString ) {
+			char *s;
+
+			s = var->latchedString;
+			var->latchedString = NULL;	// otherwise cvar_set2 would free it
+			Cvar_Set2( var_name, s, qtrue );
+			Cvar_FreeString( s );
+		}
+
+// use a CVAR_SET for rom sets, get won't override
+#if 0
+		// CVAR_ROM always overrides
+		if ( flags & CVAR_ROM ) {
+			Cvar_Set2( var_name, var_value, qtrue );
+		}
+#endif
+		return var;
+	}
+
+	//
+	// allocate a new cvar
+	//
+	if ( cvar_numIndexes == MAX_CVARS ) {
+		Com_Error( ERR_FATAL, "MAX_CVARS" );
+	}
+	var = &cvar_indexes[cvar_numIndexes];
+	cvar_numIndexes++;
+	var->name = CopyString (var_name);
+	var->string = CopyString (var_value);
+	var->modified = qtrue;
+	var->modificationCount = 1;
+	var->value = atof (var->string);
+	var->integer = atoi(var->string);
+	var->resetString = CopyString( var_value );
+
+	// link the variable in
+	var->next = cvar_vars;
+	cvar_vars = var;
+
+	var->flags = flags;
+
+	return var;
+}
+
+/*
+============
+Cvar_Set2
+============
+*/
+cvar_t *Cvar_Set2( const char *var_name, const char *value, qboolean force ) {
+	cvar_t	*var;
+
+	Com_DPrintf( "Cvar_Set2: %s %s\n", var_name, value );
+
+	if ( !Cvar_ValidateString( var_name ) ) {
+		Com_Printf("invalid cvar name string: %s\n", var_name );
+		var_name = "BADNAME";
+	}
+
+#if 0	// FIXME
+	if ( value && !Cvar_ValidateString( value ) ) {
+		Com_Printf("invalid cvar value string: %s\n", value );
+		var_value = "BADVALUE";
+	}
+#endif
+
+	var = Cvar_FindVar (var_name);
+	if (!var) {
+		if ( !value ) {
+			return NULL;
+		}
+		// create it
+		if ( !force ) {
+			return Cvar_Get( var_name, value, CVAR_USER_CREATED );
+		} else {
+			return Cvar_Get (var_name, value, 0);
+		}
+	}
+
+	if (!value ) {
+		value = var->resetString;
+	}
+
+	// note what types of cvars have been modified (userinfo, archive, serverinfo, systeminfo)
+	cvar_modifiedFlags |= var->flags;
+
+	if (!force)
+	{
+		if (var->flags & CVAR_ROM)
+		{
+			Com_Printf ("%s is read only.\n", var_name);
+			return var;
+		}
+
+		if (var->flags & CVAR_INIT)
+		{
+			Com_Printf ("%s is write protected.\n", var_name);
+			return var;
+		}
+
+		if (var->flags & CVAR_LATCH)
+		{
+			if (var->latchedString)
+			{
+				if (strcmp(value, var->latchedString) == 0)
+					return var;
+				Cvar_FreeString (var->latchedString);
+			}
+			else
+			{
+				if (strcmp(value, var->string) == 0)
+					return var;
+			}
+
+			Com_Printf ("%s will be changed upon restarting.\n", var_name);
+			var->latchedString = CopyString(value);
+			var->modified = qtrue;
+			var->modificationCount++;
+			return var;
+		}
+
+		if ( (var->flags & CVAR_CHEAT) && !cvar_cheats->integer )
+		{
+			Com_Printf ("%s is cheat protected.\n", var_name);
+			return var;
+		}
+
+	}
+	else
+	{
+		if (var->latchedString)
+		{
+			Cvar_FreeString (var->latchedString);
+			var->latchedString = NULL;
+		}
+	}
+
+	if (!strcmp(value, var->string))
+		return var;		// not changed
+
+	var->modified = qtrue;
+	var->modificationCount++;
+	
+	Cvar_FreeString (var->string);	// free the old value string
+	
+	var->string = CopyString(value);
+	var->value = atof (var->string);
+	var->integer = atoi (var->string);
+
+	return var;
+}
+
+/*
+============
+Cvar_Set
+============
+*/
+void Cvar_Set( const char *var_name, const char *value) {
+	Cvar_Set2 (var_name, value, qtrue);
+}
+
+
+/*
+============
+Cvar_SetValue
+============
+*/
+void Cvar_SetValue( const char *var_name, float value) {
+	char	val[32];
+
+	if ( value == (int)value ) {
+		Com_sprintf (val, sizeof(val), "%i",(int)value);
+	} else {
+		Com_sprintf (val, sizeof(val), "%f",value);
+	}
+	Cvar_Set (var_name, val);
+}
+
+
+/*
+============
+Cvar_Reset
+============
+*/
+void Cvar_Reset( const char *var_name ) {
+	Cvar_Set2( var_name, NULL, qfalse );
+}
+
+
+/*
+============
+Cvar_SetCheatState
+
+Any testing variables will be reset to the safe values
+============
+*/
+void Cvar_SetCheatState( void ) {
+	cvar_t	*var;
+
+	// set all default vars to the safe value
+	for ( var = cvar_vars ; var ; var = var->next ) {
+		if ( var->flags & CVAR_CHEAT) {
+			Cvar_Set( var->name, var->resetString );
+		}
+	}
+}
+
+/*
+============
+Cvar_Command
+
+Handles variable inspection and changing from the console
+============
+*/
+qboolean Cvar_Command( void ) {
+	cvar_t			*v;
+
+	// check variables
+	v = Cvar_FindVar (Cmd_Argv(0));
+	if (!v) {
+		return qfalse;
+	}
+
+	// perform a variable print or set
+	if ( Cmd_Argc() == 1 ) {
+		Com_Printf ("\"%s\" is:\"%s" S_COLOR_WHITE "\" default:\"%s" S_COLOR_WHITE "\"\n", v->name, v->string, v->resetString );
+		if ( v->latchedString ) {
+			Com_Printf( "latched: \"%s\"\n", v->latchedString );
+		}
+		return qtrue;
+	}
+
+//JFM toggle test
+	char *value;
+	value = Cmd_Argv(1);
+	if (value[0] =='!')	//toggle
+	{
+		char buff[5];
+		sprintf(buff,"%i",!v->value);
+		Cvar_Set2 (v->name, buff, qfalse);// toggle the value
+	}
+	else
+		Cvar_Set2 (v->name, value, qfalse);// set the value if forcing isn't required
+	
+	return qtrue;
+}
+
+
+/*
+============
+Cvar_Toggle_f
+
+Toggles a cvar for easy single key binding
+============
+*/
+void Cvar_Toggle_f( void ) {
+	int		v;
+
+	if ( Cmd_Argc() != 2 ) {
+		Com_Printf ("usage: toggle <variable>\n");
+		return;
+	}
+
+	v = Cvar_VariableIntegerValue( Cmd_Argv( 1 ) );
+	v = !v;
+
+	Cvar_Set2 (Cmd_Argv(1), va("%i", v), qfalse);
+}
+
+/*
+============
+Cvar_Set_f
+
+Allows setting and defining of arbitrary cvars from console, even if they
+weren't declared in C code.
+============
+*/
+void Cvar_Set_f( void ) {
+	int		i, c, l, len;
+	char	combined[MAX_STRING_TOKENS];
+
+	c = Cmd_Argc();
+	if ( c < 3 ) {
+		Com_Printf ("usage: set <variable> <value>\n");
+		return;
+	}
+
+	combined[0] = 0;
+	l = 0;
+	for ( i = 2 ; i < c ; i++ ) {
+		len = strlen ( Cmd_Argv( i ) + 1 );
+		if ( l + len >= MAX_STRING_TOKENS - 2 ) {
+			break;
+		}
+		strcat( combined, Cmd_Argv( i ) );
+		if ( i != c-1 ) {
+			strcat( combined, " " );
+		}
+		l += len;
+	}
+	Cvar_Set2 (Cmd_Argv(1), combined, qfalse);
+}
+
+/*
+============
+Cvar_SetU_f
+
+As Cvar_Set, but also flags it as userinfo
+============
+*/
+void Cvar_SetU_f( void ) {
+	cvar_t	*v;
+
+	if ( Cmd_Argc() != 3 ) {
+		Com_Printf ("usage: setu <variable> <value>\n");
+		return;
+	}
+	Cvar_Set_f();
+	v = Cvar_FindVar( Cmd_Argv( 1 ) );
+	if ( !v ) {
+		return;
+	}
+	v->flags |= CVAR_USERINFO;
+}
+
+/*
+============
+Cvar_SetS_f
+
+As Cvar_Set, but also flags it as userinfo
+============
+*/
+void Cvar_SetS_f( void ) {
+	cvar_t	*v;
+
+	if ( Cmd_Argc() != 3 ) {
+		Com_Printf ("usage: sets <variable> <value>\n");
+		return;
+	}
+	Cvar_Set_f();
+	v = Cvar_FindVar( Cmd_Argv( 1 ) );
+	if ( !v ) {
+		return;
+	}
+	v->flags |= CVAR_SERVERINFO;
+}
+
+/*
+============
+Cvar_SetA_f
+
+As Cvar_Set, but also flags it as archived
+============
+*/
+void Cvar_SetA_f( void ) {
+	cvar_t	*v;
+
+	if ( Cmd_Argc() != 3 ) {
+		Com_Printf ("usage: seta <variable> <value>\n");
+		return;
+	}
+	Cvar_Set_f();
+	v = Cvar_FindVar( Cmd_Argv( 1 ) );
+	if ( !v ) {
+		return;
+	}
+	v->flags |= CVAR_ARCHIVE;
+}
+
+/*
+============
+Cvar_Reset_f
+============
+*/
+void Cvar_Reset_f( void ) {
+	if ( Cmd_Argc() != 2 ) {
+		Com_Printf ("usage: reset <variable>\n");
+		return;
+	}
+	Cvar_Reset( Cmd_Argv( 1 ) );
+}
+
+/*
+============
+Cvar_WriteVariables
+
+Appends lines containing "set variable value" for all variables
+with the archive flag set to qtrue.
+============
+*/
+void Cvar_WriteVariables( fileHandle_t f ) {
+#ifndef _XBOX
+	cvar_t	*var;
+	char	buffer[1024];
+
+	for (var = cvar_vars ; var ; var = var->next) {
+		if (var->flags & CVAR_ARCHIVE ) {
+			// write the latched value, even if it hasn't taken effect yet
+			if ( var->latchedString ) {
+				Com_sprintf (buffer, sizeof(buffer), "seta %s \"%s\"\n", var->name, var->latchedString);
+			} else {
+				Com_sprintf (buffer, sizeof(buffer), "seta %s \"%s\"\n", var->name, var->string);
+			}
+			FS_Printf (f, "%s", buffer);
+		}
+	}
+#endif
+}
+
+/*
+============
+Cvar_List_f
+
+============
+*/
+void Cvar_List_f( void ) {
+	cvar_t	*var;
+	int		i;
+	char	*match;
+
+	if ( Cmd_Argc() > 1 ) {
+		match = Cmd_Argv( 1 );
+	} else {
+		match = NULL;
+	}
+
+	i = 0;
+	for (var = cvar_vars ; var ; var = var->next, i++)
+	{
+		if (match && !Com_Filter(match, var->name, qfalse)) continue;
+
+		if (var->flags & CVAR_SERVERINFO) {
+			Com_Printf("S");
+		} else {
+			Com_Printf(" ");
+		}
+		if (var->flags & CVAR_USERINFO) {
+			Com_Printf("U");
+		} else {
+			Com_Printf(" ");
+		}
+		if (var->flags & CVAR_ROM) {
+			Com_Printf("R");
+		} else {
+			Com_Printf(" ");
+		}
+		if (var->flags & CVAR_INIT) {
+			Com_Printf("I");
+		} else {
+			Com_Printf(" ");
+		}
+		if (var->flags & CVAR_ARCHIVE) {
+			Com_Printf("A");
+		} else {
+			Com_Printf(" ");
+		}
+		if (var->flags & CVAR_LATCH) {
+			Com_Printf("L");
+		} else {
+			Com_Printf(" ");
+		}
+		if (var->flags & CVAR_CHEAT) {
+			if (!cvar_cheats->integer)
+			{
+				i--;
+				continue;
+			}
+			Com_Printf("C");
+		} else {
+			Com_Printf(" ");
+		}
+
+		Com_Printf (" %s \"%s\"\n", var->name, var->string);
+	}
+
+	Com_Printf ("\n%i total cvars\n", i);
+}
+
+/*
+============
+Cvar_Restart_f
+
+Resets all cvars to their hardcoded values
+============
+*/
+void Cvar_Restart_f( void ) {
+	cvar_t	*var;
+	cvar_t	**prev;
+
+	prev = &cvar_vars;
+	while ( 1 ) {
+		var = *prev;
+		if ( !var ) {
+			break;
+		}
+
+		// don't mess with rom values, or some inter-module
+		// communication will get broken (com_cl_running, etc)
+		if ( var->flags & ( CVAR_ROM | CVAR_INIT | CVAR_NORESTART ) ) {
+			prev = &var->next;
+			continue;
+		}
+
+		// throw out any variables the user created
+		if ( var->flags & CVAR_USER_CREATED ) {
+			*prev = var->next;
+			if ( var->name ) {
+				Cvar_FreeString( var->name );
+			}
+			if ( var->string ) {
+				Cvar_FreeString( var->string );
+			}
+			if ( var->latchedString ) {
+				Cvar_FreeString( var->latchedString );
+			}
+			if ( var->resetString ) {
+				Cvar_FreeString( var->resetString );
+			}
+			// clear the var completely, since we
+			// can't remove the index from the list
+			memset( var, 0, sizeof( var ) );
+			continue;
+		}
+		Cvar_Set( var->name, var->resetString );
+		prev = &var->next;
+	}
+}
+
+
+
+/*
+=====================
+Cvar_InfoString
+=====================
+*/
+char	*Cvar_InfoString( int bit ) {
+	static char	info[MAX_INFO_STRING];
+	cvar_t	*var;
+
+	info[0] = 0;
+
+	for (var = cvar_vars ; var ; var = var->next) {
+		if (var->flags & bit) {
+			Info_SetValueForKey (info, var->name, var->string);
+		}
+	}
+	return info;
+}
+
+/*
+=====================
+Cvar_InfoStringBuffer
+=====================
+*/
+void Cvar_InfoStringBuffer( int bit, char* buff, int buffsize ) {
+	Q_strncpyz(buff,Cvar_InfoString(bit),buffsize);
+}
+
+/*
+=====================
+Cvar_Register
+
+basically a slightly modified Cvar_Get for the interpreted modules
+=====================
+*/
+void	Cvar_Register( vmCvar_t *vmCvar, const char *varName, const char *defaultValue, int flags ) {
+	cvar_t	*cv;
+
+	cv = Cvar_Get( varName, defaultValue, flags );
+	if ( !vmCvar ) {
+		return;
+	}
+	vmCvar->handle = cv - cvar_indexes;
+	vmCvar->modificationCount = -1;
+	Cvar_Update( vmCvar );
+}
+
+
+/*
+=====================
+Cvar_Register
+
+updates an interpreted modules' version of a cvar
+=====================
+*/
+void	Cvar_Update( vmCvar_t *vmCvar ) {
+	cvar_t	*cv;
+
+	if ( (unsigned)vmCvar->handle >= cvar_numIndexes ) {
+		Com_Error( ERR_DROP, "Cvar_Update: handle out of range" );
+	}
+
+	cv = cvar_indexes + vmCvar->handle;
+
+	if ( cv->modificationCount == vmCvar->modificationCount ) {
+		return;
+	}
+	if ( !cv->string ) {
+		return;		// variable might have been cleared by a cvar_restart
+	}
+	vmCvar->modificationCount = cv->modificationCount;
+	Q_strncpyz( vmCvar->string, cv->string, sizeof( vmCvar->string ) );
+	vmCvar->value = cv->value;
+	vmCvar->integer = cv->integer;
+}
+
+
+/*
+============
+Cvar_Init
+
+Reads in all archived cvars
+============
+*/
+void Cvar_Init (void) {
+	cvar_cheats = Cvar_Get("helpUsObi", "0", CVAR_SYSTEMINFO );
+
+	Cmd_AddCommand ("toggle", Cvar_Toggle_f);
+	Cmd_AddCommand ("set", Cvar_Set_f);
+	Cmd_AddCommand ("sets", Cvar_SetS_f);
+	Cmd_AddCommand ("setu", Cvar_SetU_f);
+	Cmd_AddCommand ("seta", Cvar_SetA_f);
+	Cmd_AddCommand ("reset", Cvar_Reset_f);
+	Cmd_AddCommand ("cvarlist", Cvar_List_f);
+	Cmd_AddCommand ("cvar_restart", Cvar_Restart_f);
+}
+
+
+static void Cvar_Realloc(char **string, char *memPool, int &memPoolUsed)
+{
+	if(string && *string)
+	{
+		char *temp = memPool + memPoolUsed;
+		strcpy(temp, *string);
+		memPoolUsed += strlen(*string) + 1;
+		Cvar_FreeString(*string);
+		*string = temp;
+	}
+}
+
+
+//Turns many small allocation blocks into one big one.
+void Cvar_Defrag(void)
+{
+	cvar_t	*var;
+	int totalMem = 0;
+	int nextMemPoolSize;
+	
+	for (var = cvar_vars; var; var = var->next)
+	{
+		if (var->name) {
+			totalMem += strlen(var->name) + 1;
+		}
+		if (var->string) {
+			totalMem += strlen(var->string) + 1;
+		}
+		if (var->resetString) {
+			totalMem += strlen(var->resetString) + 1;
+		}
+		if (var->latchedString) {
+			totalMem += strlen(var->latchedString) + 1;
+		}
+	}
+
+	char *mem = (char*)Z_Malloc(totalMem, TAG_SMALL, qfalse);
+	nextMemPoolSize = totalMem;
+	totalMem = 0;
+
+	for (var = cvar_vars; var; var = var->next)
+	{
+		Cvar_Realloc(&var->name, mem, totalMem);
+		Cvar_Realloc(&var->string, mem, totalMem);
+		Cvar_Realloc(&var->resetString, mem, totalMem);
+		Cvar_Realloc(&var->latchedString, mem, totalMem);
+	}
+
+	if(lastMemPool) {
+		Z_Free(lastMemPool);
+	}
+	lastMemPool = mem;
+	memPoolSize = nextMemPoolSize;
+}
+
diff --git a/code/qcommon/files.h b/code/qcommon/files.h
new file mode 100644
index 0000000..0eb3a56
--- /dev/null
+++ b/code/qcommon/files.h
@@ -0,0 +1,118 @@
+#ifndef __FILES_H
+#define __FILES_H
+
+
+
+/*
+   Structures local to the files_* modules.
+*/
+
+
+
+#ifdef _XBOX
+#include "../goblib/goblib.h"
+
+typedef int wfhandle_t;
+#else
+#include "../zlib32/zip.h"
+#include "unzip.h"
+#endif
+
+
+#define MAX_ZPATH			256
+#define	BASEGAME			"base"
+
+
+
+typedef struct fileInPack_s {
+	char					*name;		// name of the file
+	unsigned long			pos;		// file info position in zip
+	struct	fileInPack_s*	next;		// next file in the hash
+} fileInPack_t;
+
+typedef struct {
+	char			pakFilename[MAX_OSPATH];	// c:\quake3\base\asset0.pk3
+#ifndef _XBOX
+	unzFile			handle;
+#endif
+	int				checksum;
+	int				numfiles;
+	int				hashSize;					// hash table size (power of 2)
+	fileInPack_t*	*hashTable;					// hash table
+	fileInPack_t*	buildBuffer;				// buffer with the filenames etc.
+} pack_t;
+
+typedef struct {
+	char		path[MAX_OSPATH];		// c:\stvoy
+	char		gamedir[MAX_OSPATH];	// base
+} directory_t;
+
+typedef struct searchpath_s {
+	struct searchpath_s *next;
+
+	pack_t		*pack;		// only one of pack / dir will be non NULL
+	directory_t	*dir;
+} searchpath_t;
+
+
+#define	MAX_FILE_HANDLES	16
+
+typedef union qfile_gus {
+	FILE*		o;
+#ifndef _XBOX
+	unzFile		z;
+#endif
+} qfile_gut;
+
+typedef struct qfile_us {
+	qfile_gut	file;
+	qboolean	unique;
+} qfile_ut;
+
+typedef struct {
+	qfile_ut	handleFiles;
+	qboolean	handleSync;
+	int			baseOffset;
+	int			fileSize;
+	int			zipFilePos;
+	qboolean	zipFile;
+	char		name[MAX_QPATH];
+
+#ifdef _XBOX
+	GOBHandle	ghandle;
+	qboolean	gob;
+	qboolean	used;
+	wfhandle_t  whandle;
+#endif
+} fileHandleData_t;
+
+
+extern fileHandleData_t	fsh[MAX_FILE_HANDLES];
+
+extern searchpath_t	*fs_searchpaths;
+extern char			fs_gamedir[MAX_OSPATH];	// this will be a single file name with no separators
+extern cvar_t		*fs_debug;
+extern cvar_t		*fs_basepath;
+extern cvar_t		*fs_cdpath;
+extern cvar_t		*fs_copyfiles;
+extern cvar_t		*fs_gamedirvar;
+extern cvar_t		*fs_restrict;
+extern int			fs_readCount;			// total bytes read
+extern int			fs_loadCount;			// total files read
+extern int			fs_packFiles;			// total number of files in packs
+
+
+void			FS_Startup( const char *gameName );
+void			FS_CreatePath(char *OSPath);
+char			*FS_BuildOSPath( const char *base, const char *game, const char *qpath );
+char			*FS_BuildOSPath( const char *qpath );
+fileHandle_t	FS_HandleForFile(void);
+qboolean		FS_FilenameCompare( const char *s1, const char *s2 );
+int				FS_SV_FOpenFileRead( const char *filename, fileHandle_t *fp );
+void			FS_Shutdown( void );
+void			FS_SetRestrictions(void);
+void			FS_CheckInit(void);
+void			FS_ReplaceSeparators( char *path );
+
+
+#endif
diff --git a/code/qcommon/files_common.cpp b/code/qcommon/files_common.cpp
new file mode 100644
index 0000000..32b8268
--- /dev/null
+++ b/code/qcommon/files_common.cpp
@@ -0,0 +1,588 @@
+
+/*****************************************************************************
+ * name:		files.c
+ *
+ * desc:		handle based filesystem for Quake III Arena 
+ *
+ *
+ *****************************************************************************/
+
+
+#include "../game/q_shared.h"
+#include "qcommon.h"
+#include "files.h"
+
+/*
+=============================================================================
+
+QUAKE3 FILESYSTEM
+
+All of Quake's data access is through a hierarchical file system, but the contents of 
+the file system can be transparently merged from several sources.
+
+A "qpath" is a reference to game file data.  MAX_QPATH is 64 characters, which must include
+a terminating zero. "..", "\\", and ":" are explicitly illegal in qpaths to prevent any
+references outside the quake directory system.
+
+The "base path" is the path to the directory holding all the game directories and usually
+the executable.  It defaults to ".", but can be overridden with a "+set fs_basepath c:\quake3"
+command line to allow code debugging in a different directory.  Basepath cannot
+be modified at all after startup.  Any files that are created (demos, screenshots,
+etc) will be created relative to the base path, so base path should usually be writable.
+
+The "cd path" is the path to an alternate hierarchy that will be searched if a file
+is not located in the base path.  A user can do a partial install that copies some
+data to a base path created on their hard drive and leave the rest on the cd.  Files
+are never writen to the cd path.  It defaults to a value set by the installer, like
+"e:\quake3", but it can be overridden with "+set ds_cdpath g:\quake3".
+
+If a user runs the game directly from a CD, the base path would be on the CD.  This
+should still function correctly, but all file writes will fail (harmlessly).
+
+
+The "base game" is the directory under the paths where data comes from by default, and
+can be either "base" or "demo".
+
+The "current game" may be the same as the base game, or it may be the name of another
+directory under the paths that should be searched for files before looking in the base game.
+This is the basis for addons.
+
+Clients automatically set the game directory after receiving a gamestate from a server,
+so only servers need to worry about +set fs_game.
+
+No other directories outside of the base game and current game will ever be referenced by
+filesystem functions.
+
+To save disk space and speed loading, directory trees can be collapsed into zip files.
+The files use a ".pk3" extension to prevent users from unzipping them accidentally, but
+otherwise the are simply normal uncompressed zip files.  A game directory can have multiple
+zip files of the form "asset0.pk3", "pak1.pk3", etc.  Zip files are searched in decending order
+from the highest number to the lowest, and will always take precedence over the filesystem.
+This allows a pk3 distributed as a patch to override all existing data.
+
+Because we will have updated executables freely available online, there is no point to
+trying to restrict demo / oem versions of the game with code changes.  Demo / oem versions
+should be exactly the same executables as release versions, but with different data that
+automatically restricts where game media can come from to prevent add-ons from working.
+
+After the paths are initialized, quake will look for the product.txt file.  If not
+found and verified, the game will run in restricted mode.  In restricted mode, only 
+files contained in demo/asset0.pk3 will be available for loading, and only if the zip header is
+verified to not have been modified.  A single exception is made for jaconfig.cfg.  Files
+can still be written out in restricted mode, so screenshots and demos are allowed.
+Restricted mode can be tested by setting "+set fs_restrict 1" on the command line, even
+if there is a valid product.txt under the basepath or cdpath.
+
+If not running in restricted mode, and a file is not found in any local filesystem,
+an attempt will be made to download it and save it under the base path.
+
+If the "fs_copyfiles" cvar is set to 1, then every time a file is sourced from the cd
+path, it will be copied over to the base path.  This is a development aid to help build
+test releases and to copy working sets over slow network links.
+(If set to 2, copying will only take place if the two filetimes are NOT EQUAL)
+
+
+The qpath "sound/newstuff/test.wav" would be searched for in the following places:
+
+base path + current game's zip files
+base path + current game's directory
+cd path + current game's zip files
+cd path + current game's directory
+base path + base game's zip files
+base path + base game's directory
+cd path + base game's zip files
+cd path + base game's directory
+server download, to be written to base path + current game's directory
+
+
+The filesystem can be safely shutdown and reinitialized with different
+basedir / cddir / game combinations, but all other subsystems that rely on it
+(sound, video) must also be forced to restart.
+
+Because the same files are loaded by both the clip model (CM_) and renderer (TR_)
+subsystems, a simple single-file caching scheme is used.  The CM_ subsystems will
+load the file with a request to cache.  Only one file will be kept cached at a time,
+so any models that are going to be referenced by both subsystems should alternate
+between the CM_ load function and the ref load function.
+
+
+
+
+TODO: A qpath that starts with a leading slash will always refer to the base game, even if another
+game is currently active.  This allows character models, skins, and sounds to be downloaded
+to a common directory no matter which game is active.
+
+
+How to prevent downloading zip files?
+Pass pk3 file names in systeminfo, and download before FS_Restart()?
+
+
+
+Aborting a download disconnects the client from the server.
+
+How to mark files as downloadable?  Commercial add-ons won't be downloadable.
+
+Non-commercial downloads will want to download the entire zip file.
+the game would have to be reset to actually read the zip in
+
+Auto-update information
+
+Path separators
+
+Casing
+
+  separate server gamedir and client gamedir, so if the user starts
+  a local game after having connected to a network game, it won't stick
+  with the network game.
+
+  allow menu options for game selection?
+
+Read / write config to floppy option.
+
+Different version coexistance?
+
+When building a pak file, make sure a jaconfig.cfg isn't present in it,
+or configs will never get loaded from disk!
+
+  todo:
+
+  downloading (outside fs?)
+  game directory passing and restarting
+
+=============================================================================
+
+*/
+
+// if this is defined, the executable positively won't work with any paks other
+// than the demo pak, even if productid is present.  This is only used for our
+// last demo release to prevent the mac and linux users from using the demo
+// executable with the production windows pak before the mac/linux products
+// hit the shelves a little later
+//#define	PRE_RELEASE_DEMO
+
+
+char		fs_gamedir[MAX_OSPATH];	// this will be a single file name with no separators
+cvar_t		*fs_debug;
+cvar_t		*fs_basepath;
+cvar_t		*fs_cdpath;
+cvar_t		*fs_copyfiles;
+cvar_t		*fs_gamedirvar;
+cvar_t		*fs_restrict;
+searchpath_t	*fs_searchpaths;
+int			fs_readCount;			// total bytes read
+int			fs_loadCount;			// total files read
+int			fs_packFiles;			// total number of files in packs
+
+qboolean initialized = qfalse;
+
+
+
+
+
+fileHandleData_t	fsh[MAX_FILE_HANDLES];
+
+void FS_CheckInit(void)
+{
+	if (!initialized)
+	{
+		Com_Error( ERR_FATAL, "Filesystem call made without initialization\n" );
+	}
+}
+
+
+/*
+==============
+FS_Initialized
+==============
+*/
+
+qboolean FS_Initialized() {
+	return (qboolean)(fs_searchpaths != NULL);
+}
+
+
+
+fileHandle_t	FS_HandleForFile(void) {
+	int		i;
+
+	for ( i = 1 ; i < MAX_FILE_HANDLES ; i++ ) {
+#ifdef _XBOX
+		if ( !fsh[i].used ) {
+#else
+		if ( fsh[i].handleFiles.file.o == NULL ) {
+#endif
+			return i;
+		}
+	}
+
+	Com_Printf( "FS_HandleForFile: all handles taken:\n" );
+	for ( i = 1 ; i < MAX_FILE_HANDLES ; i++ ) {
+		Com_Printf( "%d. %s\n", i, fsh[i].name);
+	}
+	Com_Error( ERR_DROP, "FS_HandleForFile: none free" );
+	return 0;
+}
+
+
+/*
+====================
+FS_ReplaceSeparators
+
+Fix things up differently for win/unix/mac
+====================
+*/
+void FS_ReplaceSeparators( char *path ) {
+	char	*s;
+
+	for ( s = path ; *s ; s++ ) {
+		if ( *s == '/' || *s == '\\' ) {
+			*s = PATH_SEP;
+		}
+	}
+}
+
+/*
+===================
+FS_BuildOSPath
+
+Qpath may have either forward or backwards slashes
+===================
+*/
+
+char *FS_BuildOSPath( const char *qpath )
+{
+	char	temp[MAX_OSPATH];
+	static char ospath[2][MAX_OSPATH];
+	static int toggle;
+	
+	toggle ^= 1;		// flip-flop to allow two returns without clash
+
+	Com_sprintf( temp, sizeof(temp), "/%s/%s", fs_gamedirvar->string, qpath );
+
+	FS_ReplaceSeparators( temp );	
+	Com_sprintf( ospath[toggle], sizeof( ospath[0] ), "%s%s", 
+		fs_basepath->string, temp );
+	
+	return ospath[toggle];
+}
+
+#ifndef _XBOX
+char *FS_BuildOSPath( const char *base, const char *game, const char *qpath ) {
+	char	temp[MAX_OSPATH];
+	static char ospath[4][MAX_OSPATH];
+	static int toggle;
+	
+	toggle = (++toggle)&3;	// allows four returns without clash (increased from 2 during fs_copyfiles 2 enhancement)
+
+	Com_sprintf( temp, sizeof(temp), "/%s/%s", game, qpath );
+	FS_ReplaceSeparators( temp );	
+	Com_sprintf( ospath[toggle], sizeof( ospath[0] ), "%s%s", base, temp );
+	
+	return ospath[toggle];
+}
+#endif
+
+
+/*
+============
+FS_CreatePath
+
+Creates any directories needed to store the given filename
+============
+*/
+void	FS_CreatePath (char *OSPath) {
+	char	*ofs;
+	
+	// make absolutely sure that it can't back up the path
+	// FIXME: is c: allowed???
+	if ( strstr( OSPath, ".." ) || strstr( OSPath, "::" ) ) {
+		Com_Printf( "WARNING: refusing to create relative path \"%s\"\n", OSPath );
+		return;
+	}
+
+	strlwr(OSPath);
+
+	for (ofs = OSPath+1 ; *ofs ; ofs++) {
+		if (*ofs == PATH_SEP) {	
+			// create the directory
+			*ofs = 0;
+			Sys_Mkdir (OSPath);
+			*ofs = PATH_SEP;
+		}
+	}
+}
+
+
+
+/*
+===========
+FS_SV_FOpenFileRead
+
+===========
+*/
+int FS_SV_FOpenFileRead( const char *filename, fileHandle_t *fp ) {
+  char *ospath;
+	fileHandle_t	f;
+
+	if ( !fs_searchpaths ) {
+		Com_Error( ERR_FATAL, "Filesystem call made without initialization\n" );
+	}
+
+	f = FS_HandleForFile();
+	fsh[f].zipFile = qfalse;
+
+	Q_strncpyz( fsh[f].name, filename, sizeof( fsh[f].name ) );
+
+	// don't let sound stutter
+	S_ClearSoundBuffer();
+
+#ifdef _XBOX
+	ospath = FS_BuildOSPath( filename );
+#else
+	ospath = FS_BuildOSPath( fs_basepath->string, filename, "" );
+#endif
+	// remove trailing slash
+  ospath[strlen(ospath)-1] = '\0';
+
+	if ( fs_debug->integer ) {
+		Com_Printf( "FS_SV_FOpenFileRead: %s\n", ospath );
+	}
+
+	fsh[f].handleFiles.file.o = fopen( ospath, "rb" );
+	fsh[f].handleSync = qfalse;
+	if (!fsh[f].handleFiles.file.o) {
+		f = 0;
+	}
+  
+  *fp = f;
+  if (f) {
+    return FS_filelength(f);
+  }
+  return 0;
+}
+
+
+
+
+/*
+===========
+FS_FOpenFileAppend
+
+===========
+*/
+fileHandle_t FS_FOpenFileAppend( const char *filename ) {
+	char			*ospath;
+	fileHandle_t	f;
+
+	if ( !fs_searchpaths ) {
+		Com_Error( ERR_FATAL, "Filesystem call made without initialization\n" );
+	}
+
+	f = FS_HandleForFile();
+	fsh[f].zipFile = qfalse;
+
+	Q_strncpyz( fsh[f].name, filename, sizeof( fsh[f].name ) );
+
+	// don't let sound stutter
+	S_ClearSoundBuffer();
+
+#ifdef _XBOX
+	ospath = FS_BuildOSPath( filename );
+#else
+	ospath = FS_BuildOSPath( fs_basepath->string, fs_gamedir, filename );
+#endif
+
+	if ( fs_debug->integer ) {
+		Com_Printf( "FS_FOpenFileAppend: %s\n", ospath );
+	}
+
+	FS_CreatePath( ospath );
+	fsh[f].handleFiles.file.o = fopen( ospath, "ab" );
+	fsh[f].handleSync = qfalse;
+	if (!fsh[f].handleFiles.file.o) {
+		f = 0;
+	}
+	return f;
+}
+
+
+/*
+===========
+FS_FilenameCompare
+
+Ignore case and seprator char distinctions
+===========
+*/
+qboolean FS_FilenameCompare( const char *s1, const char *s2 ) {
+	int		c1, c2;
+	
+	do {
+		c1 = *s1++;
+		c2 = *s2++;
+
+		if ( Q_islower(c1) ) {
+			c1 -= ('a' - 'A');
+		}
+		if ( Q_islower(c2) ) {
+			c2 -= ('a' - 'A');
+		}
+
+		if ( c1 == '\\' || c1 == ':' ) {
+			c1 = '/';
+		}
+		if ( c2 == '\\' || c2 == ':' ) {
+			c2 = '/';
+		}
+		
+		if (c1 != c2) {
+			return -1;		// strings not equal
+		}
+	} while (c1);
+	
+	return 0;		// strings are equal
+}
+
+					
+#define	MAXPRINTMSG	4096
+void QDECL FS_Printf( fileHandle_t h, const char *fmt, ... ) {
+	va_list		argptr;
+	char		msg[MAXPRINTMSG];
+
+	va_start (argptr,fmt);
+	vsprintf (msg,fmt,argptr);
+	va_end (argptr);
+
+	FS_Write(msg, strlen(msg), h);
+}
+
+
+
+
+/*
+============
+FS_WriteFile
+
+Filename are relative to the quake search path
+============
+*/
+void FS_WriteFile( const char *qpath, const void *buffer, int size ) {
+	fileHandle_t f;
+
+	if ( !fs_searchpaths ) {
+		Com_Error( ERR_FATAL, "Filesystem call made without initialization\n" );
+	}
+
+	if ( !qpath || !buffer ) {
+		Com_Error( ERR_FATAL, "FS_WriteFile: NULL parameter" );
+	}
+
+	f = FS_FOpenFileWrite( qpath );
+	if ( !f ) {
+		Com_Printf( "Failed to open %s\n", qpath );
+		return;
+	}
+
+	FS_Write( buffer, size, f );
+
+	FS_FCloseFile( f );
+}
+
+
+
+
+
+
+
+
+/*
+================
+FS_Shutdown
+
+Frees all resources and closes all files
+================
+*/
+void FS_Shutdown( void ) {
+	searchpath_t	*p, *next;
+	int	i;
+
+	for(i = 0; i < MAX_FILE_HANDLES; i++) {
+		if (fsh[i].fileSize) {
+			FS_FCloseFile(i);
+		}
+	}
+
+	// free everything
+	for ( p = fs_searchpaths ; p ; p = next ) {
+		next = p->next;
+
+		if ( p->pack ) {
+#ifndef _XBOX
+			unzClose(p->pack->handle);
+#endif
+			Z_Free( p->pack->buildBuffer );
+			Z_Free( p->pack );
+		}
+		if ( p->dir ) {
+			Z_Free( p->dir );
+		}
+		Z_Free( p );
+	}
+
+	// any FS_ calls will now be an error until reinitialized
+	fs_searchpaths = NULL;
+
+	Cmd_RemoveCommand( "path" );
+	Cmd_RemoveCommand( "dir" );
+	Cmd_RemoveCommand( "touchFile" );
+
+	initialized = qfalse;
+}
+
+
+
+/*
+================
+FS_InitFilesystem
+
+Called only at inital startup, not when the filesystem
+is resetting due to a game change
+================
+*/
+void FS_InitFilesystem( void ) {
+	// allow command line parms to override our defaults
+	// we don't have to specially handle this, because normal command
+	// line variable sets happen before the filesystem
+	// has been initialized
+	//
+	// UPDATE: BTO (VV)
+	// we have to specially handle this, because normal command
+	// line variable sets don't happen until after the filesystem
+	// has already been initialized
+	Com_StartupVariable( "fs_cdpath" );
+	Com_StartupVariable( "fs_basepath" );
+	Com_StartupVariable( "fs_game" );
+	Com_StartupVariable( "fs_copyfiles" );
+	Com_StartupVariable( "fs_restrict" );
+
+	// try to start up normally
+	FS_Startup( BASEGAME );
+	initialized = qtrue;
+
+	// see if we are going to allow add-ons
+	FS_SetRestrictions();
+
+	// if we can't find default.cfg, assume that the paths are
+	// busted and error out now, rather than getting an unreadable
+	// graphics screen when the font fails to load
+	if ( FS_ReadFile( "default.cfg", NULL ) <= 0 ) {
+		Com_Error( ERR_FATAL, "Couldn't load default.cfg" );
+	}
+}
+
+
+
+
+void	FS_Flush( fileHandle_t f ) {
+	fflush(fsh[f].handleFiles.file.o);
+}
+
diff --git a/code/qcommon/files_console.cpp b/code/qcommon/files_console.cpp
new file mode 100644
index 0000000..d93300e
--- /dev/null
+++ b/code/qcommon/files_console.cpp
@@ -0,0 +1,1033 @@
+
+#include "../game/q_shared.h"
+#include "qcommon.h"
+#include "files.h"
+#include "../win32/win_file.h"
+#include "../zlib/zlib.h"
+
+
+
+static	cvar_t		*fs_openorder;
+
+
+// Zlib Tech Ref says decompression should use about 44kb.  I'll
+// go with 64kb as a safety factor...
+#define ZI_STACKSIZE (64*1024)
+
+static char* zi_stackTop = NULL;
+static char* zi_stackBase = NULL;
+
+
+
+//GOB stuff
+//===========================================================================
+
+struct gi_handleTable
+{
+	wfhandle_t file;
+	bool used;
+};
+
+static gi_handleTable *gi_handles = NULL;
+static int gi_cacheHandle = 0;
+
+static GOBFSHandle gi_open(GOBChar* name, GOBAccessType type)
+{
+	if (type != GOBACCESS_READ) return (GOBFSHandle)0xFFFFFFFF;
+
+	int f;
+	for (f = 0; f < MAX_FILE_HANDLES; ++f)
+	{
+		if (!gi_handles[f].used) break;
+	}
+
+	if (f == MAX_FILE_HANDLES) return (GOBFSHandle)0xFFFFFFFF;
+	
+	gi_handles[f].file = WF_Open(name, true, strstr(name, "assets.gob") ? true : false);
+	if (gi_handles[f].file < 0) return (GOBFSHandle)0xFFFFFFFF;
+	gi_handles[f].used = true;
+
+	return (GOBFSHandle)f;
+}
+
+static GOBBool gi_close(GOBFSHandle* handle)
+{
+	WF_Close(gi_handles[(int)*handle].file);
+	gi_handles[(int)*handle].used = false;
+	return GOB_TRUE;
+}
+
+static GOBInt32 gi_read(GOBFSHandle handle, GOBVoid* buffer, GOBInt32 size)
+{
+	return WF_Read(buffer, size, gi_handles[(int)handle].file);
+}
+
+static GOBInt32 gi_seek(GOBFSHandle handle, GOBInt32 offset, GOBSeekType type)
+{
+	int _type;
+	switch (type) {
+	case GOBSEEK_START: _type = SEEK_SET; break;
+	case GOBSEEK_CURRENT: _type = SEEK_CUR; break;
+	case GOBSEEK_END: _type = SEEK_END; break;
+	default: assert(0); _type = SEEK_SET; break;
+	}
+
+	return WF_Seek(offset, _type, gi_handles[(int)handle].file);
+}
+
+static GOBVoid* gi_alloc(GOBUInt32 size)
+{
+	return Z_Malloc(size, TAG_FILESYS, qfalse, 32);
+}
+
+static GOBVoid gi_free(GOBVoid* ptr)
+{
+	Z_Free(ptr);
+}
+
+static GOBBool cache_open(GOBUInt32 size)
+{
+	for (gi_cacheHandle = 0; gi_cacheHandle < MAX_FILE_HANDLES; ++gi_cacheHandle)
+	{
+		if (!gi_handles[gi_cacheHandle].used) break;
+	}
+
+	if (gi_cacheHandle == MAX_FILE_HANDLES) return GOB_FALSE;
+	
+	gi_handles[gi_cacheHandle].file = WF_Open("z:\\jedi.swap", false, true);
+	if (gi_handles[gi_cacheHandle].file < 0) return GOB_FALSE;
+
+	if (!WF_Resize(size, gi_handles[gi_cacheHandle].file))
+	{
+		WF_Close(gi_handles[gi_cacheHandle].file);
+		return GOB_FALSE;
+	}
+
+	gi_handles[gi_cacheHandle].used = true;
+
+	return GOB_TRUE;
+}
+
+static GOBBool cache_close(GOBVoid)
+{
+	WF_Close(gi_handles[gi_cacheHandle].file);
+	gi_handles[gi_cacheHandle].used = false;
+	return GOB_TRUE;
+}
+
+static GOBInt32 cache_read(GOBVoid* buffer, GOBInt32 size)
+{
+	return WF_Read(buffer, size, gi_handles[gi_cacheHandle].file);
+}
+
+static GOBInt32 cache_write(GOBVoid* buffer, GOBInt32 size)
+{
+	return WF_Write(buffer, size, gi_handles[gi_cacheHandle].file);
+}
+
+static GOBInt32 cache_seek(GOBInt32 offset)
+{
+	return WF_Seek(offset, SEEK_SET, gi_handles[gi_cacheHandle].file);
+}
+
+static voidpf zi_alloc(voidpf opaque, uInt items, uInt size)
+{
+	voidpf ret = zi_stackTop;
+	
+	zi_stackTop += items * size;
+	assert(zi_stackTop < zi_stackBase + ZI_STACKSIZE);
+
+	return ret;
+}
+
+static void zi_free(voidpf opaque, voidpf address)
+{
+}
+
+static GOBInt32 gi_decompress_zlib(GOBVoid* source, GOBUInt32 sourceLen, 
+	GOBVoid* dest, GOBUInt32* destLen)
+{
+	// Copied and modified version of zlib's uncompress()...
+
+	z_stream stream;
+	int err;
+
+	stream.next_in = (Bytef*)source;
+	stream.avail_in = (uInt)sourceLen;
+
+	stream.next_out = (Bytef*)dest;
+	stream.avail_out = (uInt)*destLen;
+	if ((uLong)stream.avail_out != *destLen) return Z_BUF_ERROR;
+
+	stream.zalloc = zi_alloc;
+	stream.zfree = zi_free;
+	zi_stackTop = zi_stackBase;
+
+	err = inflateInit(&stream);
+	if (err != Z_OK) return err;
+
+	err = inflate(&stream, Z_FINISH);
+	if (err != Z_STREAM_END) {
+		inflateEnd(&stream);
+		return err == Z_OK ? Z_BUF_ERROR : err;
+	}
+	*destLen = stream.total_out;
+
+	err = inflateEnd(&stream);
+	return err;
+}
+
+GOBInt32 gi_decompress_null(GOBVoid* source, GOBUInt32 sourceLen, 
+	GOBVoid* dest, GOBUInt32* destLen)
+{
+	if (sourceLen > *destLen) return -1;
+	*destLen = sourceLen;
+
+	memcpy(dest, source, sourceLen);
+	return 0;
+}
+
+#ifdef GOB_PROFILE
+static GOBVoid gi_profileread(GOBUInt32 code)
+{
+	code = LittleLong(code);
+	Sys_Log("gob-prof.dat", &code, sizeof(code), true);
+}
+#endif
+
+//===========================================================================
+
+
+
+
+static void FS_CheckUsed(fileHandle_t f)
+{
+	if (!fsh[f].used)
+	{
+		Com_Error( ERR_FATAL, "Filesystem call attempting to use invalid handle\n" );
+	}
+}
+
+
+int FS_filelength( fileHandle_t f )
+{
+	FS_CheckInit();
+	FS_CheckUsed(f);
+	
+	if (fsh[f].gob)
+	{
+		GOBUInt32 cur, end, crap;
+		GOBSeek(fsh[f].ghandle, 0, GOBSEEK_CURRENT, &cur);
+		GOBSeek(fsh[f].ghandle, 0, GOBSEEK_END, &end);
+		GOBSeek(fsh[f].ghandle, cur, GOBSEEK_START, &crap);
+		
+		return end;
+	}
+	else
+	{
+		int pos = WF_Tell(fsh[f].whandle);
+		WF_Seek(0, SEEK_END, fsh[f].whandle);
+		int end = WF_Tell(fsh[f].whandle);
+		WF_Seek(pos, SEEK_SET, fsh[f].whandle);
+
+		return end;
+	}
+}
+
+
+void FS_FCloseFile( fileHandle_t f )
+{
+	FS_CheckInit();
+	FS_CheckUsed(f);
+
+	if (fsh[f].gob)
+		GOBClose(fsh[f].ghandle);
+	else
+		WF_Close(fsh[f].whandle);
+
+	fsh[f].used = qfalse;
+}
+
+
+fileHandle_t FS_FOpenFileWrite( const char *filename )
+{
+	FS_CheckInit();
+	
+	fileHandle_t f = FS_HandleForFile();
+
+	char* osname = FS_BuildOSPath( filename );
+	fsh[f].whandle = WF_Open(osname, false, false);
+	if (fsh[f].whandle >= 0)
+	{
+		fsh[f].used = qtrue;
+		fsh[f].gob = qfalse;
+		return f;
+	}
+
+	return 0;
+}
+
+
+/*
+===========
+FS_FOpenFileRead
+
+Finds the file in the search path.
+Returns filesize and an open FILE pointer.
+Used for streaming data out of either a
+separate file or a ZIP file.
+===========
+*/
+
+static int FS_FOpenFileReadOS( const char *filename, fileHandle_t f )
+{
+	if (Sys_GetFileCode(filename) != -1)
+	{
+		char* osname = FS_BuildOSPath( filename );
+		fsh[f].whandle = WF_Open(osname, true, false);
+		if (fsh[f].whandle >= 0)
+		{
+			fsh[f].used = qtrue;
+			fsh[f].gob = qfalse;
+			return FS_filelength(f);
+		}
+	}
+	return -1;
+}
+
+
+/*
+===================
+FS_BuildGOBPath
+
+Qpath may have either forward or backwards slashes
+===================
+*/
+static char *FS_BuildGOBPath(const char *qpath )
+{
+	static char path[2][MAX_OSPATH];
+	static int toggle;
+	
+	toggle ^= 1;		// flip-flop to allow two returns without clash
+
+	if (qpath[0] == '\\' || qpath[0] == '/')
+	{
+		Com_sprintf( path[toggle], sizeof( path[0] ), ".%s", qpath );
+	}
+	else
+	{
+		Com_sprintf( path[toggle], sizeof( path[0] ), ".\\%s", qpath );
+	}
+
+//	FS_ReplaceSeparators( path[toggle], '\\' );
+	FS_ReplaceSeparators( path[toggle] );
+	
+	return path[toggle];
+}
+
+
+static int FS_FOpenFileReadGOB( const char *filename, fileHandle_t f )
+{
+	char* gobname = FS_BuildGOBPath( filename );
+	if (GOBOpen(gobname, &fsh[f].ghandle) == GOBERR_OK)
+	{
+		fsh[f].used = qtrue;
+		fsh[f].gob = qtrue;
+		return FS_filelength(f);
+	}
+	return -1;
+}
+
+
+/*
+===========
+FS_FOpenFileRead
+
+Finds the file in the search path.
+Returns filesize and an open FILE pointer.
+Used for streaming data out of either a
+separate file or a ZIP file.
+===========
+*/
+int FS_FOpenFileRead( const char *filename, fileHandle_t *file, qboolean uniqueFILE )
+{
+	FS_CheckInit();
+	
+	if ( file == NULL ) {
+		Com_Error( ERR_FATAL, "FS_FOpenFileRead: NULL 'file' parameter passed\n" );
+	}
+
+	if ( !filename ) {
+		Com_Error( ERR_FATAL, "FS_FOpenFileRead: NULL 'filename' parameter passed\n" );
+	}
+
+	*file = FS_HandleForFile();
+
+	int len;
+	
+	if (fs_openorder->integer == 0)
+	{
+		// Release mode -- read from GOB first
+		len = FS_FOpenFileReadGOB(filename, *file);
+		if (len < 0) len = FS_FOpenFileReadOS(filename, *file);
+	}
+	else
+	{
+		// Debug mode -- external files override GOB
+		len = FS_FOpenFileReadOS(filename, *file);
+		if (len < 0) len = FS_FOpenFileReadGOB(filename, *file);
+	}
+
+	if (len >= 0) return len;
+
+	Com_DPrintf ("Can't find %s\n", filename);
+	
+	*file = 0;
+	return -1;
+}
+
+
+/*
+=================
+FS_Read
+
+Properly handles partial reads
+=================
+*/
+int FS_Read( void *buffer, int len, fileHandle_t f )
+{
+	FS_CheckInit();
+	FS_CheckUsed(f);
+
+	if ( !f )
+	{
+		return 0;
+	}
+	
+	if ( f <= 0  || f >= MAX_FILE_HANDLES )
+	{
+		Com_Error( ERR_FATAL, "FS_Read: Invalid handle %d\n", f );
+	}
+
+	if (fsh[f].gob)
+	{
+		GOBUInt32 size = GOBRead(buffer, len, fsh[f].ghandle);
+		if (size == GOB_INVALID_SIZE)
+		{
+#if defined(FINAL_BUILD)
+			/*
+			extern void ERR_DiscFail(bool);
+			ERR_DiscFail(false);
+			*/
+#else
+			Com_Error( ERR_FATAL, "Failed to read from GOB" );
+#endif
+		}
+		return size;
+	}
+	else
+	{
+		return WF_Read(buffer, len, fsh[f].whandle);
+	}
+}
+
+/*
+	MP has FS_Read2 which is supposed to do some extra logic.
+	We don't care, and just call FS_Read()
+*/
+int FS_Read2( void *buffer, int len, fileHandle_t f )
+{
+	return FS_Read(buffer, len, f);
+}
+
+/*
+=================
+FS_Write
+=================
+*/
+int FS_Write( const void *buffer, int len, fileHandle_t f )
+{
+	FS_CheckInit();
+	FS_CheckUsed(f);
+
+	if ( !f )
+	{
+		return 0;
+	}
+	
+	if ( f <= 0  || f >= MAX_FILE_HANDLES )
+	{
+		Com_Error( ERR_FATAL, "FS_Read: Invalid handle %d\n", f );
+	}
+
+	if (fsh[f].gob)
+	{
+		Com_Error( ERR_FATAL, "FS_Write: Cannot write to GOB files %d\n", f );
+	}
+	else
+	{
+		return WF_Write(buffer, len, fsh[f].whandle);
+	}
+
+	return 0;
+}
+
+
+/*
+=================
+FS_Seek
+
+=================
+*/
+int FS_Seek( fileHandle_t f, long offset, int origin )
+{
+	FS_CheckInit();
+	FS_CheckUsed(f);
+
+	if (fsh[f].gob)
+	{
+		int _origin;
+		switch( origin ) {
+		case FS_SEEK_CUR: _origin = GOBSEEK_CURRENT; break;
+		case FS_SEEK_END: _origin = GOBSEEK_END; break;
+		case FS_SEEK_SET: _origin = GOBSEEK_START; break;
+		default:
+			_origin = GOBSEEK_CURRENT;
+			Com_Error( ERR_FATAL, "Bad origin in FS_Seek\n" );
+			break;
+		}
+
+		GOBUInt32 pos;
+		GOBSeek(fsh[f].ghandle, offset, _origin, &pos);
+		return pos;
+	}
+	else
+	{
+		int _origin;
+		switch( origin ) {
+		case FS_SEEK_CUR: _origin = SEEK_CUR; break;
+		case FS_SEEK_END: _origin = SEEK_END; break;
+		case FS_SEEK_SET: _origin = SEEK_SET; break;
+		default:
+			_origin = SEEK_CUR;
+			Com_Error( ERR_FATAL, "Bad origin in FS_Seek\n" );
+			break;
+		}
+
+		return WF_Seek(offset, _origin, fsh[f].whandle);
+	}
+}
+
+
+/*
+=================
+FS_Access
+=================
+*/
+qboolean FS_Access( const char *filename )
+{
+	GOBBool status;
+	
+	FS_CheckInit();
+
+	char* gobname = FS_BuildGOBPath( filename );
+	if (GOBAccess(gobname, &status) != GOBERR_OK || status != GOB_TRUE)
+	{
+		return Sys_GetFileCode( filename ) != -1;
+	}
+
+	return qtrue;
+}
+
+
+/*
+======================================================================================
+
+CONVENIENCE FUNCTIONS FOR ENTIRE FILES
+
+======================================================================================
+*/
+
+#ifdef _JK2MP
+int	FS_FileIsInPAK(const char *filename, int *pChecksum)
+#else
+int	FS_FileIsInPAK(const char *filename)
+#endif
+{
+	FS_CheckInit();
+
+	if ( !filename ) {
+		Com_Error( ERR_FATAL, "FS_FOpenFileRead: NULL 'filename' parameter passed\n" );
+	}
+
+	GOBBool exists;
+	GOBAccess(const_cast<GOBChar*>(filename), &exists);
+
+#ifdef _JK2MP
+	*pChecksum = 0;
+#endif
+
+	return exists ? 1 : -1;
+}
+
+/*
+============
+FS_ReadFile
+
+Filename are relative to the quake search path
+a null buffer will just return the file length without loading
+============
+*/
+int FS_ReadFile( const char *qpath, void **buffer )
+{
+	FS_CheckInit();
+	
+	if ( !qpath || !qpath[0] ) {
+		Com_Error( ERR_FATAL, "FS_ReadFile with empty name\n" );
+	}
+
+	// stop sounds from repeating
+	S_ClearSoundBuffer();
+
+	fileHandle_t h;
+	int len = FS_FOpenFileRead( qpath, &h, qfalse );
+	if ( h == 0 )
+	{
+		if ( buffer ) *buffer = NULL;
+		return -1;
+	}
+	
+	if ( !buffer )
+	{
+		FS_FCloseFile(h);
+		return len;
+	}
+
+	// assume temporary....
+	byte* buf = (byte*)Z_Malloc( len+1, TAG_TEMP_WORKSPACE, qfalse, 32);
+	buf[len]='\0';
+
+//	Z_Label(buf, qpath);
+
+	FS_Read(buf, len, h);
+
+	// guarantee that it will have a trailing 0 for string operations
+	buf[len] = 0;
+	FS_FCloseFile( h );
+
+	*buffer = buf;
+	return len;
+}
+
+
+/*
+=============
+FS_FreeFile
+=============
+*/
+void FS_FreeFile( void *buffer )
+{
+	FS_CheckInit();
+
+	if ( !buffer ) {
+		Com_Error( ERR_FATAL, "FS_FreeFile( NULL )" );
+	}
+
+	Z_Free( buffer );
+}
+
+
+int	FS_FOpenFileByMode( const char *qpath, fileHandle_t *f, fsMode_t mode )
+{
+	FS_CheckInit();
+
+	if (mode != FS_READ)
+	{
+		Com_Error( ERR_FATAL, "FSH_FOpenFile: bad mode" );
+		return -1;
+	}
+	
+	return FS_FOpenFileRead( qpath, f, qtrue );
+}
+
+
+int	FS_FTell( fileHandle_t f )
+{
+	FS_CheckInit();
+	FS_CheckUsed(f);
+
+	if (fsh[f].gob)
+	{
+		GOBUInt32 pos;
+		GOBSeek(fsh[f].ghandle, 0, GOBSEEK_CURRENT, &pos);
+		return pos;
+	}
+	else
+	{
+		return WF_Tell(fsh[f].whandle);
+	}
+}
+
+/*
+================
+FS_Startup
+================
+*/
+void FS_Startup( const char *gameName )
+{
+	Com_Printf( "----- FS_Startup -----\n" );
+
+	fs_openorder = Cvar_Get( "fs_openorder", "0", 0 );
+	fs_debug = Cvar_Get( "fs_debug", "0", 0 );
+	fs_copyfiles = Cvar_Get( "fs_copyfiles", "0", CVAR_INIT );
+	fs_cdpath = Cvar_Get ("fs_cdpath", Sys_DefaultCDPath(), CVAR_INIT );	
+	fs_basepath = Cvar_Get ("fs_basepath", Sys_DefaultBasePath(), CVAR_INIT );
+	fs_gamedirvar = Cvar_Get ("fs_game", "base", CVAR_INIT|CVAR_SERVERINFO );
+	fs_restrict = Cvar_Get ("fs_restrict", "", CVAR_INIT );
+
+	gi_handles = new gi_handleTable[MAX_FILE_HANDLES];
+	for (int f = 0; f < MAX_FILE_HANDLES; ++f)
+	{
+		fsh[f].used = false;
+		gi_handles[f].used = false;
+	}
+
+	zi_stackBase = (char*)Z_Malloc(ZI_STACKSIZE, TAG_FILESYS, qfalse);
+
+	GOBMemoryFuncSet mem;
+	mem.alloc = gi_alloc;
+	mem.free = gi_free;
+	
+	GOBFileSysFuncSet file;
+	file.close = gi_close;
+	file.open = gi_open;
+	file.read = gi_read;
+	file.seek = gi_seek;
+	file.write = NULL;
+	
+	GOBCacheFileFuncSet cache;
+	cache.close = cache_close;
+	cache.open = cache_open;
+	cache.read = cache_read;
+	cache.seek = cache_seek;
+	cache.write = cache_write;
+
+	GOBCodecFuncSet codec = {
+		2, // codecs
+		{
+			{ // Codec 0 - zlib
+				'z', GOB_INFINITE_RATIO, // tag, ratio (ratio is meaningless for decomp)
+				NULL,
+				gi_decompress_zlib,
+			},
+			{ // Codec 1 - null
+				'0', GOB_INFINITE_RATIO, // tag, ratio (ratio is meaningless for decomp)
+				NULL,
+				gi_decompress_null,
+			},
+		}
+	};
+
+	if (
+#ifdef _XBOX
+		GOBInit(&mem, &file, &codec, &cache)
+#else
+		GOBInit(&mem, &file, &codec, NULL)
+#endif
+		!= GOBERR_OK)
+	{
+		Com_Error( ERR_FATAL, "Could not initialize GOB" );
+	}
+
+	char* archive = FS_BuildOSPath( "assets" );
+	if (GOBArchiveOpen(archive, GOBACCESS_READ, GOB_FALSE, GOB_TRUE) != GOBERR_OK)
+	{
+#if defined(FINAL_BUILD)
+		/*
+		extern void ERR_DiscFail(bool);
+		ERR_DiscFail(false);
+		*/
+#else
+		//Com_Error( ERR_FATAL, "Could not initialize GOB" );
+		Cvar_Set("fs_openorder", "1");
+#endif
+	}
+	
+	GOBSetCacheSize(1);
+	GOBSetReadBufferSize(32 * 1024);
+
+#ifdef GOB_PROFILE
+	GOBProfileFuncSet profile = {
+		gi_profileread
+	};
+	GOBSetProfileFuncs(&profile);
+	GOBStartProfile();
+#endif
+
+	Com_Printf( "----------------------\n" );
+}
+
+/*
+============================
+
+DIRECTORY SCANNING FUCNTIONS
+
+============================
+*/
+
+#define	MAX_FOUND_FILES	0x1000
+
+/*
+==================
+FS_AddFileToList
+==================
+*/
+static int FS_AddFileToList( char *name, char *list[MAX_FOUND_FILES], int nfiles ) {
+	int		i;
+
+	if ( nfiles == MAX_FOUND_FILES - 1 ) {
+		return nfiles;
+	}
+	for ( i = 0 ; i < nfiles ; i++ ) {
+		if ( !stricmp( name, list[i] ) ) {
+			return nfiles;		// allready in list
+		}
+	}
+//	list[nfiles] = CopyString( name );
+	list[nfiles] = (char *) Z_Malloc( strlen(name) + 1, TAG_LISTFILES, qfalse );
+	strcpy(list[nfiles], name);
+	nfiles++;
+
+	return nfiles;
+}
+
+/*
+===============
+FS_ListFiles
+
+Returns a uniqued list of files that match the given criteria
+from all search paths
+===============
+*/
+char **FS_ListFiles( const char *path, const char *extension, int *numfiles )
+{
+	char			*netpath;
+	int				numSysFiles;
+	char			**sysFiles;
+	char			*name;
+	int				nfiles = 0;
+	char			**listCopy;
+	char			*list[MAX_FOUND_FILES];
+	int				i;
+
+	FS_CheckInit();
+
+	if ( !path ) {
+		*numfiles = 0;
+		return NULL;
+	}
+
+	// We don't do any fancy searchpath magic here, it's all in the meta-file
+	// that Sys_ListFiles will return
+	netpath = FS_BuildOSPath( path );
+#ifdef _JK2MP
+	sysFiles = Sys_ListFiles( netpath, extension, NULL, &numSysFiles, qfalse );
+#else
+	sysFiles = Sys_ListFiles( netpath, extension, &numSysFiles, qfalse );
+#endif
+	for ( i = 0 ; i < numSysFiles ; i++ ) {
+		// unique the match
+		name = sysFiles[i];
+		nfiles = FS_AddFileToList( name, list, nfiles );
+	}
+	Sys_FreeFileList( sysFiles );
+
+	// return a copy of the list
+	*numfiles = nfiles;
+
+	if ( !nfiles ) {
+		return NULL;
+	}
+
+	listCopy = (char**)Z_Malloc( ( nfiles + 1 ) * sizeof( *listCopy ), TAG_LISTFILES, qfalse);
+	for ( i = 0 ; i < nfiles ; i++ ) {
+		listCopy[i] = list[i];
+	}
+	listCopy[i] = NULL;
+
+	return listCopy;
+}
+
+
+/*
+=================
+FS_FreeFileList
+=================
+*/
+void FS_FreeFileList( char **filelist )
+{
+	int		i;
+
+	FS_CheckInit();
+
+	if ( !filelist ) {
+		return;
+	}
+
+	for ( i = 0 ; filelist[i] ; i++ ) {
+		Z_Free( filelist[i] );
+	}
+
+	Z_Free( filelist );
+}
+
+/*
+===============
+FS_AddFileToListBuf
+===============
+*/
+static int FS_AddFileToListBuf( char *name, char *listbuf, int bufsize, int nfiles )
+{
+	char	*p;
+
+	if ( nfiles == MAX_FOUND_FILES - 1 ) {
+		return nfiles;
+	}
+
+	if (name[0] == '/' || name[0] == '\\') {
+		name++;
+	}
+
+	p = listbuf;
+	while ( *p ) {
+		if ( !stricmp( name, p ) ) {
+			return nfiles;		// already in list
+		}
+		p += strlen( p ) + 1;
+	}
+
+	if ( ( p + strlen( name ) + 2 - listbuf ) > bufsize ) {
+		return nfiles;		// list is full
+	}
+
+	strcpy( p, name );
+	p += strlen( p ) + 1;
+	*p = 0;
+
+	return nfiles + 1;
+}
+
+/*
+================
+FS_GetFileList
+
+Returns a uniqued list of files that match the given criteria
+from all search paths
+================
+*/
+int	FS_GetFileList(  const char *path, const char *extension, char *listbuf, int bufsize )
+{
+	int				nfiles = 0;
+	int				i;
+	char			*netpath;
+	int				numSysFiles;
+	char			**sysFiles;
+	char			*name;
+
+	FS_CheckInit();
+
+	if ( !path ) {
+		return 0;
+	}
+	if ( !extension ) {
+		extension = "";
+	}
+
+	// Prime the file list buffer
+	listbuf[0] = '\0';
+	netpath = FS_BuildOSPath( path );
+#ifdef _JK2MP
+	sysFiles = Sys_ListFiles( netpath, extension, NULL, &numSysFiles, qfalse );
+#else
+	sysFiles = Sys_ListFiles( netpath, extension, &numSysFiles, qfalse );
+#endif
+	for ( i = 0 ; i < numSysFiles ; i++ ) {
+		// unique the match
+		name = sysFiles[i];
+		nfiles = FS_AddFileToListBuf( name, listbuf, bufsize, nfiles );
+	}
+	Sys_FreeFileList( sysFiles );
+
+	return nfiles;
+}
+
+/*
+=================
+ Filesytem STUBS
+=================
+*/
+
+qboolean FS_ConditionalRestart(int checksumFeed)
+{
+	return qfalse;
+}
+
+void FS_ClearPakReferences(int flags)
+{
+	return;
+}
+
+const char *FS_LoadedPakNames(void)
+{
+	return "";
+}
+
+const char *FS_ReferencedPakNames(void)
+{
+	return "";
+}
+
+void FS_SetRestrictions(void)
+{
+	return;
+}
+
+#ifdef _JK2MP
+void FS_Restart(int checksumFeed)
+#else
+void FS_Restart(void)
+#endif
+{
+	return;
+}
+
+qboolean FS_FileExists(const char *file)
+{
+	assert(!"FS_FileExists not implemented on Xbox");
+	return qfalse;
+}
+
+void FS_UpdateGamedir(void)
+{
+	return;
+}
+
+void FS_PureServerSetReferencedPaks(const char *pakSums, const char *pakNames)
+{
+	return;
+}
+
+void FS_PureServerSetLoadedPaks(const char *pakSums, const char *pakNames)
+{
+	return;
+}
+
+const char *FS_ReferencedPakChecksums(void)
+{
+	return "";
+}
+
+const char *FS_LoadedPakChecksums(void)
+{
+	return "";
+}
diff --git a/code/qcommon/files_pc.cpp b/code/qcommon/files_pc.cpp
new file mode 100644
index 0000000..4deaa35
--- /dev/null
+++ b/code/qcommon/files_pc.cpp
@@ -0,0 +1,1741 @@
+
+#include "../game/q_shared.h"
+#include "qcommon.h"
+#include "files.h"
+
+
+#define	MAX_SEARCH_PATHS	2048
+#define MAX_FILEHASH_SIZE	1024
+
+
+#define	DEMOGAME			"demo"
+
+// every time a new demo pk3 file is built, this checksum must be updated.
+// the easiest way to get it is to just run the game and see what it spits out
+#define	DEMO_PAK_CHECKSUM	1431467275
+#define	DEMO_PAK_MAXFILES	5174u
+
+
+//static int		fs_numServerPaks;
+//static int		fs_serverPaks[MAX_SEARCH_PATHS];
+
+// productId: This file is copyright 2003 Raven Software, and may not be duplicated except during a licensed installation of the full commercial version of Star Wars: Jedi Academy
+static const byte fs_scrambledProductId[] = {
+42, 143, 149, 190,  10, 197, 225, 133, 243,  63, 189, 182, 226,  56, 143,  17, 215,  37, 197, 218,  50, 103,  24, 235, 246, 191, 183, 149, 160, 170,
+230,  52, 176, 231,  15, 194, 236, 247, 159, 168, 132, 154,  24, 133,  67,  85,  36,  97,  99,  86, 117, 189, 212, 156, 236, 153,  68,  10, 196, 241,
+39, 219, 156,  88,  93, 198, 200, 232, 142,  67,  45, 209,  53, 186, 228, 241, 162, 127, 213,  83,   7, 121,  11,  93, 123, 243, 148, 240, 229,  42,
+42,   6, 215, 239, 112, 120, 240, 244, 104,  12,  38,  47, 201, 253, 223, 208, 154,  69, 141, 157,  32, 117, 166, 146, 236,  59,  15, 223,  52,  89,
+133,  64, 201,  56, 119,  25, 211, 152, 159,  11,  92,  59, 207,  81, 123,   0, 121, 241, 116,  42,  36, 251,  51, 149,  79, 165,  12, 106, 187, 225,
+203,  99, 102,  69,  97,  81,  27, 107,  81, 178,  63,  35, 185,  64, 115 
+};
+
+
+/*
+================
+return a hash value for the filename
+================
+*/
+long FS_HashFileName( const char *fname, int hashSize ) {
+	int		i;
+	long	hash;
+	char	letter;
+
+	hash = 0;
+	i = 0;
+	while (fname[i] != '\0') {
+		letter = tolower(fname[i]);
+		if (letter =='.') break;				// don't include extension
+		if (letter =='\\') letter = '/';		// damn path names
+		if (letter == PATH_SEP) letter = '/';		// damn path names	//mac and unix are different
+		hash+=(long)(letter)*(i+119);
+		i++;
+	}
+	hash = (hash ^ (hash >> 10) ^ (hash >> 20));
+	hash &= (hashSize-1);
+	return hash;
+}
+
+
+static FILE	*FS_FileForHandle( fileHandle_t f ) {
+	if ( f < 0 || f > MAX_FILE_HANDLES ) {
+		Com_Error( ERR_DROP, "FS_FileForHandle: out of reange" );
+	}
+	if (fsh[f].zipFile == (int)qtrue) {
+		Com_Error( ERR_DROP, "FS_FileForHandle: can't get FILE on zip file" );
+	}
+	if ( ! fsh[f].handleFiles.file.o ) {
+		Com_Error( ERR_DROP, "FS_FileForHandle: NULL" );
+	}
+	
+	return fsh[f].handleFiles.file.o;
+}
+
+void	FS_ForceFlush( fileHandle_t f ) {
+	FILE *file;
+
+	file = FS_FileForHandle(f);
+	setvbuf( file, NULL, _IONBF, 0 );
+}
+
+
+/*
+================
+FS_filelength
+
+If this is called on a non-unique FILE (from a pak file),
+it will return the size of the pak file, not the expected
+size of the file.
+================
+*/
+int FS_filelength( fileHandle_t f ) {
+	int		pos;
+	int		end;
+	FILE*	h;
+
+	h = FS_FileForHandle(f);
+	pos = ftell (h);
+	fseek (h, 0, SEEK_END);
+	end = ftell (h);
+	fseek (h, pos, SEEK_SET);
+
+	return end;
+}
+
+/*
+=================
+FS_CopyFile
+
+Copy a fully specified file from one place to another
+=================
+*/
+// added extra param so behind-the-scenes copying in savegames doesn't clutter up the screen -slc
+qboolean FS_CopyFile( char *fromOSPath, char *toOSPath, qboolean qbSilent = qfalse );
+qboolean FS_CopyFile( char *fromOSPath, char *toOSPath, qboolean qbSilent ) {
+	FILE	*f;
+	int		len;
+	byte	*buf;
+
+	if (!qbSilent)
+	{
+		Com_Printf( "copy %s to %s\n", fromOSPath, toOSPath );
+	}
+	f = fopen( fromOSPath, "rb" );
+	if ( !f ) {
+		return qfalse;
+	}
+	fseek (f, 0, SEEK_END);
+	len = ftell (f);
+	fseek (f, 0, SEEK_SET);
+	
+	buf = (unsigned char *) Z_Malloc( len, TAG_FILESYS, qfalse);
+	if (fread( buf, 1, len, f ) != (size_t) len)
+	{
+		Z_Free( buf );
+		fclose(f);
+		if (qbSilent){
+			return qfalse;
+		}
+		Com_Error( ERR_FATAL, "Short read in FS_Copyfiles()\n" );
+	}
+	fclose( f );
+
+	FS_CreatePath( toOSPath );
+	f = fopen( toOSPath, "wb" );
+	if ( !f ) {
+		Z_Free( buf );
+		return qfalse;
+	}
+	if (fwrite( buf, 1, len, f ) != (size_t)len)
+	{
+		Z_Free( buf );
+		fclose(f);
+		if (qbSilent){
+			return qfalse;
+		}
+		Com_Error( ERR_FATAL, "Short write in FS_Copyfiles()\n" );
+	}
+	fclose( f );
+	Z_Free( buf );
+
+	return qtrue;
+}
+
+/*
+==============
+FS_FCloseFile
+
+If the FILE pointer is an open pak file, leave it open.
+
+For some reason, other dll's can't just call fclose()
+on files returned by FS_FOpenFile...
+==============
+*/
+void FS_FCloseFile( fileHandle_t f ) {
+	if ( !fs_searchpaths ) {
+		Com_Error( ERR_FATAL, "Filesystem call made without initialization\n" );
+	}
+
+	if (fsh[f].zipFile == qtrue) {
+		unzCloseCurrentFile( fsh[f].handleFiles.file.z );
+		if ( fsh[f].handleFiles.unique ) {
+			unzClose( fsh[f].handleFiles.file.z );
+		}
+		memset( &fsh[f], 0, sizeof( fsh[f] ) );
+		return;
+	}
+
+	// we didn't find it as a pak, so close it as a unique file
+	fclose (fsh[f].handleFiles.file.o);
+	memset( &fsh[f], 0, sizeof( fsh[f] ) );
+}
+
+
+
+
+// The following functions with "UserGen" in them were added for savegame handling, 
+//	since outside functions aren't supposed to know about full paths/dirs
+
+// "filename" is local to the current gamedir (eg "saves/blah.sav")
+//
+void FS_DeleteUserGenFile( const char *filename )
+{
+	char		*ospath;
+
+	if ( !fs_searchpaths ) 
+	{
+		Com_Error( ERR_FATAL, "Filesystem call made without initialization\n" );
+	}
+
+	ospath = FS_BuildOSPath( fs_basepath->string, fs_gamedir, filename );
+
+	if ( fs_debug->integer ) 
+	{
+		Com_Printf( "FS_DeleteUserGenFile: %s\n", ospath );
+	}
+
+	remove ( ospath );
+}
+
+// filenames are local (eg "saves/blah.sav")
+//
+// return: qtrue = OK
+//
+qboolean FS_MoveUserGenFile( const char *filename_src, const char *filename_dst )
+{
+	char		*ospath_src,
+				*ospath_dst;
+
+	if ( !fs_searchpaths ) 
+	{
+		Com_Error( ERR_FATAL, "Filesystem call made without initialization\n" );
+	}
+
+	ospath_src = FS_BuildOSPath( fs_basepath->string, fs_gamedir, filename_src );
+	ospath_dst = FS_BuildOSPath( fs_basepath->string, fs_gamedir, filename_dst );
+
+	if ( fs_debug->integer ) 
+	{
+		Com_Printf( "FS_MoveUserGenFile: %s to %s\n", ospath_src, ospath_dst );
+	}
+
+/*	int iSlashes1=0;
+	int iSlashes2=0;
+	char *p;
+	for (p = strchr(filename_src,'/'); p; iSlashes1++)
+	{
+		p = strchr(p+1,'/');
+	}
+	for (p = strchr(filename_dst,'/'); p; iSlashes2++)
+	{
+		p = strchr(p+1,'/');
+	}
+
+	if (iSlashes1 != iSlashes2)
+	{
+		int ret = FS_CopyFile( ospath_src, ospath_dst, qtrue );
+		remove(ospath_src);
+		return ret;
+	}
+	else
+*/
+	{
+	remove(ospath_dst);
+	return (0 == rename (ospath_src, ospath_dst ));
+	}
+}
+
+/*
+===========
+FS_FOpenFileWrite
+
+===========
+*/
+fileHandle_t FS_FOpenFileWrite( const char *filename ) {
+	char			*ospath;
+	fileHandle_t	f;
+
+	if ( !fs_searchpaths ) {
+		Com_Error( ERR_FATAL, "Filesystem call made without initialization\n" );
+	}
+
+	f = FS_HandleForFile();
+	fsh[f].zipFile = qfalse;
+
+	ospath = FS_BuildOSPath( fs_basepath->string, fs_gamedir, filename );
+
+	if ( fs_debug->integer ) {
+		Com_Printf( "FS_FOpenFileWrite: %s\n", ospath );
+	}
+
+	//Com_DPrintf( "writing to: %s\n", ospath );
+	FS_CreatePath( ospath );
+	fsh[f].handleFiles.file.o = fopen( ospath, "wb" );
+
+	Q_strncpyz( fsh[f].name, filename, sizeof( fsh[f].name ) );
+
+	fsh[f].handleSync = qfalse;
+	if (!fsh[f].handleFiles.file.o) {
+		f = 0;
+	}
+	return f;
+}
+
+static bool FS_FileCacheable(const char* const filename) 
+{
+	extern	cvar_t	*com_buildScript;
+	if (com_buildScript && com_buildScript->integer)
+	{ 
+		return true;
+	}
+	return( strchr(filename, '/') != 0 );
+}
+
+/*
+===========
+FS_FOpenFileRead
+
+Finds the file in the search path.
+Returns filesize and an open FILE pointer.
+Used for streaming data out of either a
+separate file or a ZIP file.
+===========
+*/
+int FS_FOpenFileRead( const char *filename, fileHandle_t *file, qboolean uniqueFILE ) {
+	searchpath_t	*search;
+	char			*netpath;
+	pack_t			*pak;
+	fileInPack_t	*pakFile;
+	directory_t		*dir;
+	long			hash=0;
+	unz_s			*zfi;
+	ZIP_FILE		*temp;
+//	int				i;
+
+	if ( !fs_searchpaths ) {
+		Com_Error( ERR_FATAL, "Filesystem call made without initialization\n" );
+	}
+
+	if ( file == NULL ) {
+		Com_Error( ERR_FATAL, "FS_FOpenFileRead: NULL 'file' parameter passed\n" );
+	}
+
+	if ( !filename ) {
+		Com_Error( ERR_FATAL, "FS_FOpenFileRead: NULL 'filename' parameter passed\n" );
+	}
+
+	// qpaths are not supposed to have a leading slash
+	if ( filename[0] == '/' || filename[0] == '\\' ) {
+		filename++;
+	}
+
+	// make absolutely sure that it can't back up the path.
+	// The searchpaths do guarantee that something will always
+	// be prepended, so we don't need to worry about "c:" or "//limbo" 
+	if ( strstr( filename, ".." ) || strstr( filename, "::" ) ) {
+		*file = 0;
+		return -1;
+	}
+
+	//
+	// search through the path, one element at a time
+	//
+
+	*file = FS_HandleForFile();
+	fsh[*file].handleFiles.unique = uniqueFILE;
+
+	// this new bool is in for an optimisation, if you (eg) opened a BSP file under fs_copyfiles==2,
+	//	then it triggered a copy operation to update your local HD version, then this will re-open the
+	//	file handle on your local version, not the net build. This uses a bit more CPU to re-do the loop
+	//	logic, but should read faster than accessing the net version a second time.
+	//
+	qboolean bFasterToReOpenUsingNewLocalFile = qfalse;
+
+	do
+	{
+		bFasterToReOpenUsingNewLocalFile = qfalse;
+
+		for ( search = fs_searchpaths ; search ; search = search->next ) {
+			//
+			if ( search->pack ) {
+				hash = FS_HashFileName(filename, search->pack->hashSize);
+			}
+			// is the element a pak file?
+			if ( search->pack && search->pack->hashTable[hash] ) {
+				// disregard if it doesn't match one of the allowed pure pak files
+	/*			if ( !FS_PakIsPure(search->pack) ) {
+					continue;
+				}
+	*/
+				// look through all the pak file elements
+				pak = search->pack;
+				pakFile = pak->hashTable[hash];
+				do {
+					// case and separator insensitive comparisons
+					if ( !FS_FilenameCompare( pakFile->name, filename ) ) {
+						// found it!
+						if ( uniqueFILE ) {
+							// open a new file on the pakfile
+							fsh[*file].handleFiles.file.z = unzReOpen (pak->pakFilename, pak->handle);
+							if (fsh[*file].handleFiles.file.z == NULL) {
+								Com_Error (ERR_FATAL, "Couldn't reopen %s", pak->pakFilename);
+							}
+						} else {
+							fsh[*file].handleFiles.file.z = pak->handle;
+						}
+						Q_strncpyz( fsh[*file].name, filename, sizeof( fsh[*file].name ) );
+						fsh[*file].zipFile = qtrue;
+						zfi = (unz_s *)fsh[*file].handleFiles.file.z;
+						// in case the file was new
+						temp = zfi->file;
+						// set the file position in the zip file (also sets the current file info)
+						unzSetCurrentFileInfoPosition(pak->handle, pakFile->pos);
+						// copy the file info into the unzip structure
+						memcpy( zfi, pak->handle, sizeof(unz_s));
+						// we copy this back into the structure
+						zfi->file = temp;
+						// open the file in the zip
+						unzOpenCurrentFile( fsh[*file].handleFiles.file.z );
+						fsh[*file].zipFilePos = pakFile->pos;
+
+						if ( fs_debug->integer ) {
+							Com_Printf( "FS_FOpenFileRead: %s (found in '%s')\n", 
+								filename, pak->pakFilename );
+						}
+						return zfi->cur_file_info.uncompressed_size;
+					}
+					pakFile = pakFile->next;
+				} while(pakFile != NULL);
+			} else if ( search->dir ) {
+				// check a file in the directory tree
+
+				// if we are running restricted, the only files we
+				// will allow to come from the directory are .cfg files
+				if ( fs_restrict->integer /*|| fs_numServerPaks*/ ) {
+					int		l;
+
+					l = strlen( filename );
+
+					if ( stricmp( filename + l - 4, ".cfg" )		// for config files
+						&& stricmp( filename + l - 4, ".sav" )  // for save games
+						&& stricmp( filename + l - 4, ".dat" ) ) {	// for journal files
+						continue;
+					}
+				}
+
+				dir = search->dir;
+				
+				netpath = FS_BuildOSPath( dir->path, dir->gamedir, filename );
+
+				fsh[*file].handleFiles.file.o = fopen (netpath, "rb");
+				if ( !fsh[*file].handleFiles.file.o ) {
+					continue;
+				}
+
+				// if running with fs_copyfiles 2, and search path == local, then we need to fail to open
+				//	if the time/date stamp != the network version (so it'll loop round again and use the network path,
+				//	which comes later in the search order)
+				//
+				if ( fs_copyfiles->integer == 2 && fs_cdpath->string[0] && !Q_stricmp( dir->path, fs_basepath->string ) 
+					&& FS_FileCacheable(filename) )
+				{
+					if ( Sys_FileOutOfDate( netpath, FS_BuildOSPath( fs_cdpath->string, dir->gamedir, filename ) ))
+					{
+						fclose(fsh[*file].handleFiles.file.o);
+						fsh[*file].handleFiles.file.o = 0;
+						continue;	//carry on to find the cdpath version.
+					}
+				}
+				
+				Q_strncpyz( fsh[*file].name, filename, sizeof( fsh[*file].name ) );
+				fsh[*file].zipFile = qfalse;
+				if ( fs_debug->integer ) {
+					Com_Printf( "FS_FOpenFileRead: %s (found in '%s/%s')\n", filename,
+						dir->path, dir->gamedir );
+				}
+
+				// if we are getting it from the cdpath, optionally copy it
+				//  to the basepath
+				if ( fs_copyfiles->integer && !stricmp( dir->path, fs_cdpath->string ) ) {
+					char	*copypath;
+
+					copypath = FS_BuildOSPath( fs_basepath->string, dir->gamedir, filename );
+
+					switch ( fs_copyfiles->integer )
+					{
+						default:
+						case 1:
+						{
+							FS_CopyFile( netpath, copypath );
+						}
+						break;
+
+						case 2:
+						{
+					
+							if (FS_FileCacheable(filename) )
+							{
+								// maybe change this to Com_DPrintf?   On the other hand...
+								//
+								Com_Printf( S_COLOR_CYAN"fs_copyfiles(2), Copying: %s to %s\n", netpath, copypath );
+								
+								FS_CreatePath( copypath );
+
+								if (Sys_CopyFile( netpath, copypath, qtrue ))
+								{
+									// clear this handle and setup for re-opening of the new local copy...
+									//
+									bFasterToReOpenUsingNewLocalFile = qtrue;
+									fclose(fsh[*file].handleFiles.file.o);
+									fsh[*file].handleFiles.file.o = NULL;
+								}
+							}
+						}
+						break;
+					}
+				}
+
+				if (bFasterToReOpenUsingNewLocalFile)
+				{
+					break;	// and re-read the local copy, not the net version
+				}
+
+				return FS_filelength (*file);
+			}
+		}
+	}
+	while ( bFasterToReOpenUsingNewLocalFile );
+	
+	Com_DPrintf ("Can't find %s\n", filename);
+	
+	*file = 0;
+	return -1;
+}
+
+
+
+/*
+=================
+FS_Read
+
+Properly handles partial reads
+=================
+*/
+int FS_Read( void *buffer, int len, fileHandle_t f ) {
+	int		block, remaining;
+	int		read;
+	byte	*buf;
+	int		tries;
+
+	if ( !fs_searchpaths ) {
+		Com_Error( ERR_FATAL, "Filesystem call made without initialization\n" );
+	}
+
+	if ( !f ) {
+		return 0;
+	}
+	if ( f <= 0  || f >= MAX_FILE_HANDLES )
+	{
+		Com_Error( ERR_FATAL, "FS_Read: Invalid handle %d\n", f );
+	}
+
+	buf = (byte *)buffer;
+	fs_readCount += len;
+
+	if (fsh[f].zipFile == qfalse) {
+		remaining = len;
+		tries = 0;
+		while (remaining) {
+			block = remaining;
+			read = fread (buf, 1, block, fsh[f].handleFiles.file.o);
+			if (read == 0) {
+				// we might have been trying to read from a CD, which
+				// sometimes returns a 0 read on windows
+				if (!tries) {
+					tries = 1;
+				} else {
+					return len-remaining;	//Com_Error (ERR_FATAL, "FS_Read: 0 bytes read");
+				}
+			}
+
+			if (read == -1) {
+				Com_Error (ERR_FATAL, "FS_Read: -1 bytes read");
+			}
+
+			remaining -= read;
+			buf += read;
+		}
+		return len;
+	} else {
+		return unzReadCurrentFile(fsh[f].handleFiles.file.z, buffer, len);
+	}
+}
+
+
+/*
+=================
+FS_Write
+
+Properly handles partial writes
+=================
+*/
+int FS_Write( const void *buffer, int len, fileHandle_t h ) {
+	int		block, remaining;
+	int		written;
+	byte	*buf;
+	int		tries;
+	FILE	*f;
+
+	if ( !fs_searchpaths ) {
+		Com_Error( ERR_FATAL, "Filesystem call made without initialization\n" );
+	}
+
+	if ( !h ) {
+		return 0;
+	}
+
+	f = FS_FileForHandle(h);
+	buf = (byte *)buffer;
+
+	remaining = len;
+	tries = 0;
+	while (remaining) {
+		block = remaining;
+		written = fwrite (buf, 1, block, f);
+		if (written == 0) {
+			if (!tries) {
+				tries = 1;
+			} else {
+				Com_Printf( "FS_Write: 0 bytes written\n" );
+				return 0;
+			}
+		}
+
+		if (written == -1) {
+			Com_Printf( "FS_Write: -1 bytes written\n" );
+			return 0;
+		}
+
+		remaining -= written;
+		buf += written;
+	}
+	if ( fsh[h].handleSync ) {
+		fflush( f );
+	}
+	return len;
+}
+
+
+/*
+=================
+FS_Seek
+
+=================
+*/
+int FS_Seek( fileHandle_t f, long offset, int origin ) {
+	int		_origin;
+
+	if ( !fs_searchpaths ) {
+		Com_Error( ERR_FATAL, "Filesystem call made without initialization\n" );
+		return -1;
+	}
+
+	if (fsh[f].zipFile == qtrue) {
+		char	foo[65536];
+		if (offset == 0 && origin == FS_SEEK_SET) {
+			// set the file position in the zip file (also sets the current file info)
+			unzSetCurrentFileInfoPosition(fsh[f].handleFiles.file.z, fsh[f].zipFilePos);
+			return unzOpenCurrentFile(fsh[f].handleFiles.file.z);
+		} else if (offset<65536) {
+			// set the file position in the zip file (also sets the current file info)
+			unzSetCurrentFileInfoPosition(fsh[f].handleFiles.file.z, fsh[f].zipFilePos);
+			unzOpenCurrentFile(fsh[f].handleFiles.file.z);
+			return FS_Read(foo, offset, f);
+		} else {
+			Com_Error( ERR_FATAL, "ZIP FILE FSEEK NOT YET IMPLEMENTED for big offsets(%s)\n", fsh[f].name);
+			return -1;
+		}
+	} else {
+		FILE *file;
+		file = FS_FileForHandle(f);
+		switch( origin ) {
+		case FS_SEEK_CUR:
+			_origin = SEEK_CUR;
+			break;
+		case FS_SEEK_END:
+			_origin = SEEK_END;
+			break;
+		case FS_SEEK_SET:
+			_origin = SEEK_SET;
+			break;
+		default:
+			_origin = SEEK_CUR;
+			Com_Error( ERR_FATAL, "Bad origin in FS_Seek\n" );
+			break;
+		}
+
+		return fseek( file, offset, _origin );
+	}
+}
+
+
+/*
+======================================================================================
+
+CONVENIENCE FUNCTIONS FOR ENTIRE FILES
+
+======================================================================================
+*/
+
+int	FS_FileIsInPAK(const char *filename ) {
+	searchpath_t	*search;
+	pack_t			*pak;
+	fileInPack_t	*pakFile;
+	long			hash = 0;
+
+	if ( !fs_searchpaths ) {
+		Com_Error( ERR_FATAL, "Filesystem call made without initialization\n" );
+	}
+
+	if ( !filename ) {
+		Com_Error( ERR_FATAL, "FS_FOpenFileRead: NULL 'filename' parameter passed\n" );
+	}
+
+	// qpaths are not supposed to have a leading slash
+	if ( filename[0] == '/' || filename[0] == '\\' ) {
+		filename++;
+	}
+
+	// make absolutely sure that it can't back up the path.
+	// The searchpaths do guarantee that something will always
+	// be prepended, so we don't need to worry about "c:" or "//limbo" 
+	if ( strstr( filename, ".." ) || strstr( filename, "::" ) ) {
+		return -1;
+	}
+
+	//
+	// search through the path, one element at a time
+	//
+
+	for ( search = fs_searchpaths ; search ; search = search->next ) {
+		//
+		if (search->pack) {
+			hash = FS_HashFileName(filename, search->pack->hashSize);
+		}
+		// is the element a pak file?
+		if ( search->pack && search->pack->hashTable[hash] ) {
+			// disregard if it doesn't match one of the allowed pure pak files
+/*			if ( !FS_PakIsPure(search->pack) ) {
+				continue;
+			}
+*/
+			// look through all the pak file elements
+			pak = search->pack;
+			pakFile = pak->hashTable[hash];
+			do {
+				// case and separator insensitive comparisons
+				if ( !FS_FilenameCompare( pakFile->name, filename ) ) {
+					return 1;
+				}
+				pakFile = pakFile->next;
+			} while(pakFile != NULL);
+		}
+	}
+	return -1;
+}
+
+/*
+============
+FS_ReadFile
+
+Filename are relative to the quake search path
+a null buffer will just return the file length without loading
+============
+*/
+#include "..\client\client.h"
+int FS_ReadFile( const char *qpath, void **buffer ) {
+	fileHandle_t	h;
+	byte*			buf;
+	int				len;
+
+	if ( !fs_searchpaths ) {
+		Com_Error( ERR_FATAL, "Filesystem call made without initialization\n" );
+	}
+
+	if ( !qpath || !qpath[0] ) {
+		Com_Error( ERR_FATAL, "FS_ReadFile with empty name\n" );
+	}
+
+	// stop sounds from repeating
+	S_ClearSoundBuffer();
+
+	// look for it in the filesystem or pack files
+	len = FS_FOpenFileRead( qpath, &h, qfalse );
+	if ( h == 0 ) {
+		if ( buffer ) {
+			*buffer = NULL;
+		}
+		return -1;
+	}
+	
+	if ( !buffer ) {
+		FS_FCloseFile( h);
+		return len;
+	}
+
+	fs_loadCount++;
+
+	buf = (byte*)Z_Malloc( len+1, TAG_FILESYS, qfalse);
+	*buffer = buf;	
+
+	Z_Label(buf, qpath);
+
+	// PRECACE CHECKER!
+#ifndef FINAL_BUILD
+	if (com_sv_running && com_sv_running->integer && cls.state >= CA_ACTIVE) {	//com_cl_running
+		if (strncmp(qpath,"menu/",5) ) {
+			Com_Printf( S_COLOR_MAGENTA"FS_ReadFile: %s NOT PRECACHED!\n", qpath );
+		}
+	}
+#endif
+
+	FS_Read (buf, len, h);
+
+	// guarantee that it will have a trailing 0 for string operations
+	buf[len] = 0;
+	FS_FCloseFile( h );
+	return len;
+}
+
+
+/*
+=============
+FS_FreeFile
+=============
+*/
+void FS_FreeFile( void *buffer ) {
+	
+	if ( !fs_searchpaths ) {
+		Com_Error( ERR_FATAL, "Filesystem call made without initialization\n" );
+	}
+	if ( !buffer ) {
+		Com_Error( ERR_FATAL, "FS_FreeFile( NULL )" );
+	}
+
+	Z_Free( buffer );
+}
+
+
+
+/*
+==========================================================================
+
+ZIP FILE LOADING
+
+==========================================================================
+*/
+
+/*
+=================
+FS_LoadZipFile
+
+Creates a new pak_t in the search chain for the contents
+of a zip file.
+=================
+*/
+static pack_t *FS_LoadZipFile( char *zipfile )
+{
+	fileInPack_t	*buildBuffer;
+	pack_t			*pack;
+	unzFile			uf;
+	int				err;
+	unz_global_info gi;
+	char			filename_inzip[MAX_ZPATH];
+	unz_file_info	file_info;
+	int				i, len;
+	long			hash;
+	int				fs_numHeaderLongs;
+	int				*fs_headerLongs;
+	char			*namePtr;
+
+	fs_numHeaderLongs = 0;
+
+	uf = unzOpen(zipfile);
+	err = unzGetGlobalInfo (uf,&gi);
+
+	if (err != UNZ_OK)
+		return NULL;
+
+	fs_packFiles += gi.number_entry;
+
+	len = 0;	//find the length of all filenames
+	unzGoToFirstFile(uf);
+	for (i = 0; i < gi.number_entry; i++)
+	{
+		err = unzGetCurrentFileInfo(uf, &file_info, filename_inzip, sizeof(filename_inzip), NULL, 0, NULL, 0);
+		if (err != UNZ_OK) {
+			break;
+		}
+		if ( file_info.size_filename > MAX_QPATH)
+		{
+			Com_Error(ERR_FATAL, "ERROR: filename length > MAX_QPATH ( strlen(%s) = %d) \n", filename_inzip, file_info.size_filename );
+		}
+		len += strlen(filename_inzip) + 1;
+		unzGoToNextFile(uf);
+	}
+
+	buildBuffer = (fileInPack_t *)Z_Malloc( gi.number_entry * sizeof( fileInPack_t ) + len , TAG_FILESYS, qtrue );
+	namePtr = ((char *) buildBuffer) + gi.number_entry * sizeof( fileInPack_t );
+	fs_headerLongs = (int*)Z_Malloc( gi.number_entry * sizeof(int), TAG_FILESYS, qtrue );
+
+	// get the hash table size from the number of files in the zip
+	// because lots of custom pk3 files have less than 32 or 64 files
+	for (i = 1; i <= MAX_FILEHASH_SIZE; i <<= 1) {
+		if (i > gi.number_entry) {
+			break;
+		}
+	}
+
+	pack = (pack_t*)Z_Malloc( sizeof( pack_t ) + i * sizeof(fileInPack_t *), TAG_FILESYS, qtrue );
+	memset (pack, 0, sizeof( pack_t ) + i * sizeof(fileInPack_t *));
+	pack->hashSize = i;
+	pack->hashTable = (fileInPack_t **) (((char *) pack) + sizeof( pack_t ));
+
+	Q_strncpyz( pack->pakFilename, zipfile, sizeof( pack->pakFilename ) );
+
+	pack->handle = uf;
+	pack->numfiles = gi.number_entry;
+	unzGoToFirstFile(uf);
+
+	for (i = 0; i < gi.number_entry; i++)
+	{
+		err = unzGetCurrentFileInfo(uf, &file_info, filename_inzip, sizeof(filename_inzip), NULL, 0, NULL, 0);
+		if (err != UNZ_OK) {
+			break;
+		}
+		if (file_info.uncompressed_size > 0) {
+			fs_headerLongs[fs_numHeaderLongs++] = LittleLong(file_info.crc);
+		}
+		Q_strlwr( filename_inzip );
+		hash = FS_HashFileName(filename_inzip, pack->hashSize);
+		buildBuffer[i].name = namePtr;
+		strcpy( buildBuffer[i].name, filename_inzip );
+		namePtr += strlen(filename_inzip) + 1;
+		// store the file position in the zip
+		unzGetCurrentFileInfoPosition(uf, &buildBuffer[i].pos);
+		//
+		buildBuffer[i].next = pack->hashTable[hash];
+		pack->hashTable[hash] = &buildBuffer[i];
+		unzGoToNextFile(uf);
+	}
+
+	pack->checksum = Com_BlockChecksum( fs_headerLongs, 4 * fs_numHeaderLongs );
+	pack->checksum = LittleLong( pack->checksum );
+
+	Z_Free(fs_headerLongs);
+
+	pack->buildBuffer = buildBuffer;
+	return pack;
+}
+
+/*
+=================================================================================
+
+DIRECTORY SCANNING FUNCTIONS
+
+=================================================================================
+*/
+
+#define	MAX_FOUND_FILES	0x1000
+
+static int FS_ReturnPath( const char *zname, char *zpath, int *depth ) {
+	int len, at, newdep;
+
+	newdep = 0;
+	zpath[0] = 0;
+	len = 0;
+	at = 0;
+
+	while(zname[at] != 0)
+	{
+		if (zname[at]=='/' || zname[at]=='\\') {
+			len = at;
+			newdep++;
+		}
+		at++;
+	}
+	strcpy(zpath, zname);
+	zpath[len] = 0;
+	*depth = newdep;
+
+	return len;
+}
+
+/*
+==================
+FS_AddFileToList
+==================
+*/
+static int FS_AddFileToList( char *name, char *list[MAX_FOUND_FILES], int nfiles ) {
+	int		i;
+
+	if ( nfiles == MAX_FOUND_FILES - 1 ) {
+		return nfiles;
+	}
+	for ( i = 0 ; i < nfiles ; i++ ) {
+		if ( !stricmp( name, list[i] ) ) {
+			return nfiles;		// allready in list
+		}
+	}
+	list[nfiles] = CopyString( name );
+	nfiles++;
+
+	return nfiles;
+}
+
+/*
+===============
+FS_ListFiles
+
+Returns a uniqued list of files that match the given criteria
+from all search paths
+===============
+*/
+char **FS_ListFiles( const char *path, const char *extension, int *numfiles ) {
+	int				nfiles;
+	char			**listCopy;
+	char			*list[MAX_FOUND_FILES];
+	searchpath_t	*search;
+	int				i;
+	int				pathLength;
+	int				extensionLength;
+	int				length, pathDepth;
+	pack_t			*pak;
+	fileInPack_t	*buildBuffer;
+	char			zpath[MAX_QPATH];
+
+	if ( !fs_searchpaths ) {
+		Com_Error( ERR_FATAL, "Filesystem call made without initialization\n" );
+	}
+
+	if ( !path ) {
+		*numfiles = 0;
+		return NULL;
+	}
+	if ( !extension ) {
+		extension = "";
+	}
+
+	pathLength = strlen( path );
+	extensionLength = strlen( extension );
+	nfiles = 0;
+	FS_ReturnPath(path, zpath, &pathDepth);
+
+	//
+	// search through the path, one element at a time, adding to list
+	//
+	for (search = fs_searchpaths ; search ; search = search->next) {
+		// is the element a pak file?
+		if (search->pack) {
+			// look through all the pak file elements
+			pak = search->pack;
+			buildBuffer = pak->buildBuffer;
+			for (i=0 ; i<pak->numfiles ; i++) {
+				char	*name;
+				int		zpathLen, depth;
+
+				// check for directory match
+				name = buildBuffer[i].name;
+				zpathLen = FS_ReturnPath(name, zpath, &depth);
+
+				if ( (depth-pathDepth)>2 || pathLength > zpathLen || Q_stricmpn( name, path, pathLength ) ) {
+					continue;
+				}
+
+				// check for extension match
+				length = strlen( name );
+				if ( length < extensionLength ) {
+					continue;
+				}
+
+				if ( stricmp( name + length - extensionLength, extension ) ) {
+					continue;
+				}
+
+				// unique the match
+				nfiles = FS_AddFileToList( name + pathLength + 1, list, nfiles );
+			}
+		} else if (search->dir) { // scan for files in the filesystem
+			char	*netpath;
+			int		numSysFiles;
+			char	**sysFiles;
+			char	*name;
+
+			netpath = FS_BuildOSPath( search->dir->path, search->dir->gamedir, path );
+			sysFiles = Sys_ListFiles( netpath, extension, &numSysFiles, qfalse );
+			for ( i = 0 ; i < numSysFiles ; i++ ) {
+				// unique the match
+				name = sysFiles[i];
+				nfiles = FS_AddFileToList( name, list, nfiles );
+			}
+			Sys_FreeFileList( sysFiles );
+		}		
+	}
+
+	// return a copy of the list
+	*numfiles = nfiles;
+
+	if ( !nfiles ) {
+		return NULL;
+	}
+
+	listCopy = (char**)Z_Malloc( ( nfiles + 1 ) * sizeof( *listCopy ), TAG_FILESYS, qfalse);
+	for ( i = 0 ; i < nfiles ; i++ ) {
+		listCopy[i] = list[i];
+	}
+	listCopy[i] = NULL;
+
+	return listCopy;
+}
+
+
+/*
+=================
+FS_FreeFileList
+=================
+*/
+void FS_FreeFileList( char **filelist ) {
+	int		i;
+
+	if ( !fs_searchpaths ) {
+		Com_Error( ERR_FATAL, "Filesystem call made without initialization\n" );
+	}
+
+	if ( !filelist ) {
+		return;
+	}
+
+	for ( i = 0 ; filelist[i] ; i++ ) {
+		Z_Free( filelist[i] );
+	}
+
+	Z_Free( filelist );
+}
+
+/*
+===============
+FS_AddFileToListBuf
+===============
+*/
+static int FS_AddFileToListBuf( char *name, char *listbuf, int bufsize, int nfiles ) {
+	char	*p;
+
+	if ( nfiles == MAX_FOUND_FILES - 1 ) {
+		return nfiles;
+	}
+
+	if (name[0] == '/' || name[0] == '\\') {
+		name++;
+	}
+
+	p = listbuf;
+	while ( *p ) {
+		if ( !stricmp( name, p ) ) {
+			return nfiles;		// already in list
+		}
+		p += strlen( p ) + 1;
+	}
+
+	if ( ( p + strlen( name ) + 2 - listbuf ) > bufsize ) {
+		return nfiles;		// list is full
+	}
+
+	strcpy( p, name );
+	p += strlen( p ) + 1;
+	*p = 0;
+
+	return nfiles + 1;
+}
+
+/*
+================
+FS_GetFileList
+
+Returns a uniqued list of files that match the given criteria
+from all search paths
+================
+*/
+int	FS_GetModList( char *listbuf, int bufsize );
+int	FS_GetFileList(  const char *path, const char *extension, char *listbuf, int bufsize ) {
+	int		nfiles;
+	searchpath_t	*search;
+	int				i;
+	int				pathLength;
+	int				extensionLength;
+	int				length, pathDepth;
+	pack_t			*pak;
+	fileInPack_t	*buildBuffer;
+	char			zpath[MAX_QPATH];
+
+	if (Q_stricmp(path, "$modlist") == 0)
+	{
+		return FS_GetModList(listbuf, bufsize);
+	}
+
+	if ( !fs_searchpaths ) {
+		Com_Error( ERR_FATAL, "Filesystem call made without initialization\n" );
+	}
+
+	if ( !path ) {
+		return 0;
+	}
+	if ( !extension ) {
+		extension = "";
+	}
+
+	pathLength = strlen( path );
+	extensionLength = strlen( extension );
+	nfiles = 0;
+	*listbuf = 0;
+	FS_ReturnPath(path, zpath, &pathDepth);
+	//
+	// search through the path, one element at a time, adding to list
+	//
+	for (search = fs_searchpaths ; search ; search = search->next) {
+		// is the element a pak file?
+		if (search->pack) {
+			// look through all the pak file elements
+			pak = search->pack;
+			buildBuffer = pak->buildBuffer;
+			for (i=0 ; i<pak->numfiles ; i++) {
+				char	*name;
+				int		zpathLen, depth;
+
+				// check for directory match
+				name = buildBuffer[i].name;
+				zpathLen = FS_ReturnPath(name, zpath, &depth);
+
+				if ( (depth-pathDepth)>2 || pathLength > zpathLen || Q_stricmpn( name, path, pathLength ) ) {
+					continue;
+				}
+
+				// check for extension match
+				length = strlen( name );
+				if ( length < extensionLength || (length == (extensionLength + pathLength))) {
+					continue;
+				}
+
+				if ( stricmp( name + length - extensionLength, extension ) ) {
+					continue;
+				}
+
+				// unique the match
+				nfiles = FS_AddFileToListBuf( name + pathLength, listbuf, bufsize, nfiles );
+			}
+		} else  if (search->dir) { // scan for files in the filesystem
+			char	*netpath;
+			int		numSysFiles;
+			char	**sysFiles;
+			char	*name;
+
+			netpath = FS_BuildOSPath( search->dir->path, search->dir->gamedir, path );
+			sysFiles = Sys_ListFiles( netpath, extension, &numSysFiles, qfalse );
+			for ( i = 0 ; i < numSysFiles ; i++ ) {
+				// unique the match
+				name = sysFiles[i];
+				nfiles = FS_AddFileToListBuf( name, listbuf, bufsize, nfiles );
+			}
+			Sys_FreeFileList( sysFiles );
+		}		
+	}
+
+	return nfiles;
+}
+
+/*
+================
+FS_GetModList
+
+Returns a list of mod directory names
+A mod directory is a peer to base with a pk3 in it
+
+================
+*/
+int	FS_GetModList( char *listbuf, int bufsize ) {
+	int		nMods, i, nTotal, nLen, nPaks, nPotential, nDescLen;
+  char **pFiles = NULL;
+  char **pPaks = NULL;
+  char *name, *path;
+  char descPath[MAX_OSPATH];
+  fileHandle_t descHandle;
+
+  *listbuf = 0;
+  nMods = nPotential = nTotal = 0;
+
+	pFiles = Sys_ListFiles( fs_basepath->string, ".*", &nPotential, qtrue );
+	for ( i = 0 ; i < nPotential ; i++ ) {
+    name = pFiles[i];
+    if (Q_stricmp(name, BASEGAME) && Q_stricmpn(name, ".", 1)) {
+      // ignore base
+			path = FS_BuildOSPath( fs_basepath->string, name, "" );
+      nPaks = 0;
+      pPaks = Sys_ListFiles(path, ".pk3", &nPaks, qfalse); 
+      if (nPaks > 0) {
+        nLen = strlen(name) + 1;
+        // nLen is the length of the mod path
+        // we need to see if there is a description available
+        descPath[0] = '\0';
+        strcpy(descPath, name);
+        strcat(descPath, "/description.txt");
+        nDescLen = FS_SV_FOpenFileRead( descPath, &descHandle);
+        if ( nDescLen > 0 && descHandle) {
+      		FILE *file;
+      		file = FS_FileForHandle(descHandle);
+			memset( descPath, 0, sizeof( descPath ) );
+          nDescLen = fread(descPath, 1, 48, file);
+          if (nDescLen >= 0) {
+            descPath[nDescLen] = '\0';
+          }
+          FS_FCloseFile(descHandle);
+        } else {
+          strcpy(descPath, name);
+        }
+        nDescLen = strlen(descPath) + 1;
+
+        if (nTotal + nLen + 1 + nDescLen + 1 < bufsize) {
+          strcpy(listbuf, name);
+          listbuf += nLen;
+          strcpy(listbuf, descPath);
+          listbuf += nDescLen;
+          nTotal += nLen + nDescLen;
+          nMods++;
+        }
+        else {
+          break;
+        }
+      }
+	  	Sys_FreeFileList( pPaks );
+    }
+  }
+ 	Sys_FreeFileList( pFiles );
+
+  return nMods;
+}
+
+//============================================================================
+
+/*
+================
+FS_Dir_f
+================
+*/
+void FS_Dir_f( void ) {
+	char	*path;
+	char	*extension;
+	char	**dirnames;
+	int		ndirs;
+	int		i;
+
+	if ( Cmd_Argc() < 2 || Cmd_Argc() > 3 ) {
+		Com_Printf( "usage: dir <directory> [extension]\n" );
+		return;
+	}
+
+	if ( Cmd_Argc() == 2 ) {
+		path = Cmd_Argv( 1 );
+		extension = "";
+	} else {
+		path = Cmd_Argv( 1 );
+		extension = Cmd_Argv( 2 );
+	}
+
+	Com_Printf( "Directory of %s %s\n", path, extension );
+	Com_Printf( "---------------\n" );
+
+	dirnames = FS_ListFiles( path, extension, &ndirs );
+
+	for ( i = 0; i < ndirs; i++ ) {
+		Com_Printf( "%s\n", dirnames[i] );
+	}
+	FS_FreeFileList( dirnames );
+}
+
+/*
+============
+FS_Path_f
+
+============
+*/
+void FS_Path_f( void ) {
+	searchpath_t	*s;
+	int				i;
+
+	Com_Printf ("Current search path:\n");
+	for (s=fs_searchpaths ; s ; s=s->next) {
+		if (s->pack) {
+			Com_Printf ("%s (%i files)\n", s->pack->pakFilename, s->pack->numfiles);
+/*			if ( fs_numServerPaks ) {
+				for ( i = 0 ; i < fs_numServerPaks ; i++ ) {
+					if ( s->pack->checksum == fs_serverPaks[i] ) {
+						break;		// on the aproved list
+					}
+				}
+				if ( i == fs_numServerPaks ) {
+					Com_Printf( "    not on the pure list\n" );
+				} else {
+					Com_Printf( "    on the pure list\n" );
+				}
+			}
+*/
+		} else 	{
+			Com_Printf ("%s/%s\n", s->dir->path, s->dir->gamedir );
+		}
+	}
+
+
+	Com_Printf( "\n" );
+	for ( i = 1 ; i < MAX_FILE_HANDLES ; i++ ) {
+		if ( fsh[i].handleFiles.file.o ) {
+			Com_Printf( "handle %i: %s\n", i, fsh[i].name );
+		}
+	}
+}
+
+/*
+============
+FS_TouchFile_f
+
+The only purpose of this function is to allow game script files to copy
+arbitrary files during an "fs_copyfiles 1" run.
+============
+*/
+void FS_TouchFile_f( void ) {
+	fileHandle_t	f;
+	int count = Cmd_Argc();
+
+	if ( (count == 2) || (count == 3) ) {
+		FS_FOpenFileRead( Cmd_Argv( 1 ), &f, qfalse );
+		if ( f ) {
+			FS_FCloseFile( f );
+		}
+		if ( count == 3 ) {
+			FS_FOpenFileRead( Cmd_Argv( 2 ), &f, qfalse );
+			if ( f ) {
+				FS_FCloseFile( f );
+			}
+		}
+	}
+	else {
+		Com_Printf( "Usage: touchFile <file> [file2] -- You gave %d args!\n", Cmd_Argc() );
+	}
+}
+
+//===========================================================================
+
+
+
+static int QDECL paksort( const void *a, const void *b ) {
+	char	*aa, *bb;
+
+	aa = *(char **)a;
+	bb = *(char **)b;
+
+	return stricmp( aa, bb );
+}
+
+
+/*
+================
+FS_AddGameDirectory
+
+Sets fs_gamedir, adds the directory to the head of the path,
+then loads the zip headers
+================
+*/
+#define	MAX_PAKFILES	1024
+static void FS_AddGameDirectory( const char *path, const char *dir ) {
+	int				i;
+	searchpath_t	*search;
+	pack_t			*pak;
+	char			*pakfile;
+	int				numfiles;
+	char			**pakfiles;
+	char			*sorted[MAX_PAKFILES];
+
+	Q_strncpyz( fs_gamedir, dir, sizeof( fs_gamedir ) );
+
+	//
+	// add the directory to the search path
+	//
+	search = (searchpath_t *)Z_Malloc (sizeof(searchpath_t), TAG_FILESYS, qtrue );
+	search->dir = (directory_t*)Z_Malloc( sizeof( *search->dir ), TAG_FILESYS, qtrue );
+	search->pack = 0;
+	Q_strncpyz( search->dir->path, path, sizeof( search->dir->path ) );
+	Q_strncpyz( search->dir->gamedir, dir, sizeof( search->dir->gamedir ) );
+	search->next = fs_searchpaths;
+	fs_searchpaths = search;
+
+	Z_Label(search, path);
+	Z_Label(search->dir, dir);
+
+	// find all pak files in this directory
+	pakfile = FS_BuildOSPath( path, dir, "" );
+	pakfile[ strlen(pakfile) - 1 ] = 0;	// strip the trailing slash
+
+#ifdef PRE_RELEASE_DEMO
+	pakfile = FS_BuildOSPath( path, dir, "asset0.pksp" );
+	if ( ( pak = FS_LoadZipFile( pakfile ) ) == 0 )
+		return;
+	if ( (pak->numfiles^ 0x84268436u) != (DEMO_PAK_MAXFILES^ 0x84268436u))	//don't let them use the full version, even if renamed!
+		return;
+	search = (searchpath_t*)Z_Malloc(sizeof(searchpath_t), TAG_FILESYS, qtrue );
+	search->pack = pak;
+	search->dir = 0;
+	search->next = fs_searchpaths;
+	fs_searchpaths = search;		
+#else
+	pakfiles = Sys_ListFiles( pakfile, ".pk3", &numfiles, qfalse );
+
+	// sort them so that later alphabetic matches override
+	// earlier ones.  This makes pak1.pk3 override asset0.pk3
+	if ( numfiles > MAX_PAKFILES ) {
+		numfiles = MAX_PAKFILES;
+	}
+	for ( i = 0 ; i < numfiles ; i++ ) {
+		sorted[i] = pakfiles[i];
+	}
+
+	qsort( sorted, numfiles, 4, paksort );
+
+	for ( i = 0 ; i < numfiles ; i++ ) {
+		pakfile = FS_BuildOSPath( path, dir, sorted[i] );
+		if ( ( pak = FS_LoadZipFile( pakfile ) ) == 0 )
+			continue;
+		search = (searchpath_t*)Z_Malloc(sizeof(searchpath_t), TAG_FILESYS, qtrue );
+		search->pack = pak;
+		search->dir = 0;
+		search->next = fs_searchpaths;
+		fs_searchpaths = search;		
+	}
+
+	// done
+	Sys_FreeFileList( pakfiles );
+#endif
+}
+
+
+
+/*
+================
+FS_Startup
+================
+*/
+void FS_Startup( const char *gameName ) {
+	Com_Printf( "----- FS_Startup -----\n" );
+
+	fs_debug = Cvar_Get( "fs_debug", "0", 0 );
+	fs_copyfiles = Cvar_Get( "fs_copyfiles", "0", CVAR_INIT );
+	fs_cdpath = Cvar_Get ("fs_cdpath", Sys_DefaultCDPath(), CVAR_INIT );
+	fs_basepath = Cvar_Get ("fs_basepath", Sys_DefaultBasePath(), CVAR_INIT );
+
+	fs_gamedirvar = Cvar_Get ("fs_game", "", CVAR_INIT|CVAR_SERVERINFO );
+	fs_restrict = Cvar_Get ("fs_restrict", "", CVAR_INIT );
+	Cvar_Get( "com_demo", "", CVAR_INIT );
+
+	// set up cdpath
+	if (fs_cdpath->string[0]) {
+		FS_AddGameDirectory ( fs_cdpath->string, gameName );
+	}
+
+	// set up basepath
+	FS_AddGameDirectory ( fs_basepath->string, gameName );
+
+	// check for game override
+	if ( fs_gamedirvar->string[0] && 
+		!Q_stricmp( gameName, BASEGAME ) &&
+		Q_stricmp( fs_gamedirvar->string, gameName ) ) {
+		if ( fs_cdpath->string[0] ) {
+			FS_AddGameDirectory( fs_cdpath->string, fs_gamedirvar->string );
+		}
+		FS_AddGameDirectory( fs_basepath->string, fs_gamedirvar->string );
+	}
+
+	// add our commands
+	Cmd_AddCommand ("path", FS_Path_f);
+	Cmd_AddCommand ("dir", FS_Dir_f );
+	Cmd_AddCommand ("touchFile", FS_TouchFile_f );
+
+	// print the current search paths
+	FS_Path_f();
+
+	Com_Printf( "----------------------\n" );
+	Com_Printf( "%d files in pk3 files\n", fs_packFiles );
+}
+
+
+/*
+===================
+FS_SetRestrictions
+
+Looks for product keys and restricts media add on ability
+if the full version is not found
+===================
+*/
+void FS_SetRestrictions( void ) {
+	searchpath_t	*path;
+
+#ifndef PRE_RELEASE_DEMO
+	byte	*productId;
+
+	// if fs_restrict is set, don't even look for the id file,
+	// which allows the demo release to be tested even if
+	// the full game is present
+	if ( !fs_restrict->integer ) {
+		// look for the full game id
+		FS_ReadFile( "productid.txt", (void **)&productId );
+		if ( productId ) {
+			// check against the hardcoded string
+			unsigned int		seed, i;
+
+			seed = 102270;
+			for ( i = 0 ; i < sizeof( fs_scrambledProductId ) ; i++ ) {
+#if 0
+				fs_scrambledProductId[i]  = productId[i] ^ (seed&255);
+				Com_Printf("%3i, ", fs_scrambledProductId[i]);
+#endif
+				if ( ( fs_scrambledProductId[i] ^ (seed&255) ) != productId[i] ) {
+					break;
+				}
+				seed = (69069 * seed + 1);
+			}
+
+			FS_FreeFile( productId );
+
+			if ( i == sizeof( fs_scrambledProductId ) ) {
+				return;	// no restrictions
+			}
+			Com_Error( ERR_FATAL, "Invalid product identification" );
+		}
+	}
+#endif
+	Cvar_Set( "fs_restrict", "1" );
+	Cvar_Set( "com_demo", "1" );
+
+	Com_Printf( "\nRunning in restricted demo mode.\n\n" );
+
+	// restart the filesystem with just the demo directory
+	FS_Shutdown();
+	FS_Startup( DEMOGAME );
+
+	// make sure that the pak file has the header checksum we expect
+	for ( path = fs_searchpaths ; path ; path = path->next ) {
+		if ( path->pack ) {
+			// a tiny attempt to keep the checksum from being scannable from the exe
+			if ( (path->pack->checksum ^ 0x84268436u) != (DEMO_PAK_CHECKSUM ^ 0x84268436u) ) {
+				Com_Error( ERR_FATAL, "Corrupted pk3: %u", path->pack->checksum );
+			}
+		}
+	}
+}
+
+
+/*
+================
+FS_Restart
+================
+*/
+
+void FS_Restart( void ) {
+	// free anything we currently have loaded
+	FS_Shutdown();
+
+	// try to start up normally
+	FS_Startup( BASEGAME );
+
+	// see if we are going to allow add-ons
+	FS_SetRestrictions();
+
+	// if we can't find default.cfg, assume that the paths are
+	// busted and error out now, rather than getting an unreadable
+	// graphics screen when the font fails to load
+	if ( FS_ReadFile( "default.cfg", NULL ) <= 0 ) {
+		Com_Error( ERR_FATAL, "Couldn't load default.cfg" );
+	}
+}
+
+/*
+========================================================================================
+
+Handle based file calls for virtual machines
+
+========================================================================================
+*/
+
+int		FS_FOpenFileByMode( const char *qpath, fileHandle_t *f, fsMode_t mode ) {
+	int		r;
+	qboolean	sync;
+
+	sync = qfalse;
+
+	switch( mode ) {
+	case FS_READ:
+		r = FS_FOpenFileRead( qpath, f, qtrue );
+		break;
+	case FS_WRITE:
+		*f = FS_FOpenFileWrite( qpath );
+		r = 0;
+		break;
+	case FS_APPEND_SYNC:
+		sync = qtrue;
+	case FS_APPEND:
+		*f = FS_FOpenFileAppend( qpath );
+		r = 0;
+		break;
+	default:
+		Com_Error( ERR_FATAL, "FSH_FOpenFile: bad mode" );
+		return -1;
+	}
+
+	if ( *f ) {
+		if (fsh[*f].zipFile == (int)qtrue) {
+			fsh[*f].baseOffset = unztell(fsh[*f].handleFiles.file.z);
+		} else {
+			fsh[*f].baseOffset = ftell(fsh[*f].handleFiles.file.o);
+		}
+		fsh[*f].fileSize = r;
+	}
+	fsh[*f].handleSync = sync;
+
+	return r;
+}
+
+int		FS_FTell( fileHandle_t f ) {
+	int pos;
+	if (fsh[f].zipFile == (int)qtrue) {
+		pos = unztell(fsh[f].handleFiles.file.z);
+	} else {
+		pos = ftell(fsh[f].handleFiles.file.o);
+	}
+	return pos;
+}
+
+
diff --git a/code/qcommon/fixedmap.h b/code/qcommon/fixedmap.h
new file mode 100644
index 0000000..8642d08
--- /dev/null
+++ b/code/qcommon/fixedmap.h
@@ -0,0 +1,149 @@
+#ifndef __FIXEDMAP_H
+#define __FIXEDMAP_H
+
+
+/*
+   An STL map-like container.  Quickly thrown together to replace STL maps
+   in specific instances.  Many gotchas.  Use with caution.
+*/
+
+
+#include <stdlib.h>
+
+
+template < class T, class U >
+class VVFixedMap
+{
+private:
+	struct Data {
+		T data;
+		U key;
+	};
+
+	Data *items;
+	unsigned int numItems;
+	unsigned int maxItems;
+
+	VVFixedMap(void) {}
+
+public:
+	VVFixedMap(unsigned int maxItems)
+	{
+		items = new Data[maxItems];
+		numItems = 0;
+		this->maxItems = maxItems;
+	}
+
+
+	~VVFixedMap(void)
+	{
+		items -= ( maxItems - numItems );
+		delete [] items;
+		numItems = 0;
+	}
+
+
+	bool Insert(const T &newItem, const U &key)
+	{
+		Data *storage = NULL;
+
+		//Check for fullness.
+		if(numItems >= maxItems) {
+			assert( 0 );
+			return false;
+		}
+
+		//Check for reuse.
+		if(!FindUnsorted(key, storage)) {
+		   storage = items + numItems;
+		   numItems++;
+		}	   
+
+		storage->data = newItem;
+		storage->key = key;
+
+		return true;
+	}
+
+
+	void Sort(void) 
+	{
+		qsort(items, numItems, sizeof(Data), 
+				VVFixedMap< T, U >::FixedMapSorter);
+	}
+
+
+	//Binary search, items must have been sorted!
+	T *Find(const U &key)
+	{
+		int i;
+		int high;
+		int low;
+
+		for(low = -1, high = numItems; high - low > 1; ) {
+			i = (high + low) / 2;
+			if(key < items[i].key) {
+				high = i;
+			} else if(key > items[i].key) {
+				low = i;
+			} else {
+				return &items[i].data;
+			}
+		}
+
+		if(items[i+1].key == key) {
+			return &items[i+1].data;
+		} else if(items[i-1].key == key) {
+			return &items[i-1].data;
+		}
+
+		return NULL;
+	}
+
+
+	//Slower, but don't need to call sort first.
+	T *FindUnsorted(const U &key, Data *&storage)
+	{
+		int i;
+
+		for(i=0; i<numItems; i++) {
+			if(items[i].key == key) {
+				storage = items + i;
+				return &items[i].data;
+			}
+		}
+
+		return NULL;
+	}
+
+	// returns the top item's data
+	// and removes the item from the map
+	T *Pop(void)
+	{
+		T* top = NULL;
+
+		if(numItems)
+		{
+			top	= &items[0].data;
+			items++;
+			numItems--;
+		}
+
+		return top;
+	}
+
+
+	static int FixedMapSorter(const void *a, const void *b)
+	{
+		if(((Data*)a)->key > ((Data*)b)->key) {
+			return 1;
+		} else if(((Data*)a)->key == ((Data*)b)->key) {
+			return 0;
+		} else {
+			return -1;
+		}
+	}
+};
+
+
+#endif
diff --git a/code/qcommon/hstring.cpp b/code/qcommon/hstring.cpp
new file mode 100644
index 0000000..70badb5
--- /dev/null
+++ b/code/qcommon/hstring.cpp
@@ -0,0 +1,525 @@
+#include "cm_local.h"
+#include "hstring.h"
+
+#if defined (_DEBUG) && defined (_WIN32)
+#define WIN32_LEAN_AND_MEAN 1
+//#include <windows.h>	// for Sleep for Z_Malloc recovery attempy
+#include "platform.h"
+#endif
+
+// mapPoolBlockCount is defined differently in the executable (sv_main.cpp) and the game dll (g_main.cpp) cuz
+//we likely don't need as many blocks in the executable as we do in the game
+extern int		mapPoolBlockCount;
+
+// Used to fool optimizer during compilation of mem touch routines.
+int HaHaOptimizer2=0;
+
+#ifndef _XBOX
+CMapPoolLow &GetMapPool()
+{
+	// this may need to be ifdefed to be different for different modules
+	static CMapPoolLow thePool;
+	return thePool;
+}
+#endif
+
+#define MAPBLOCK_SIZE_NODES	(1024)
+#define MAPNODE_FREE		(0xa1)
+#define MAPNODE_INUSE		(0x94)
+
+struct SMapNode
+{
+	unsigned char mData[MAP_NODE_SIZE-2];
+	unsigned char mMapBlockNum;
+	unsigned char mTag;
+};
+
+class CMapBlock
+{
+	int			mId;
+	char		mRaw[(MAPBLOCK_SIZE_NODES+1)*MAP_NODE_SIZE];
+	SMapNode	*mNodes;
+	int			mLastNode;
+
+public:
+	CMapBlock(int id,vector <void *> &freeList) :
+		mLastNode(0)
+	{
+		// Alloc node storage for MAPBLOCK_SIZE_NODES worth of nodes.
+		mNodes=(SMapNode *)((((unsigned long)mRaw)+MAP_NODE_SIZE)&~(unsigned long)0x1f);
+		// Set all nodes to initially be free.
+		int i;
+		for(i=0;i<MAPBLOCK_SIZE_NODES;i++)
+		{
+			mNodes[i].mMapBlockNum=id;
+			mNodes[i].mTag=MAPNODE_FREE;
+			freeList.push_back((void *)&mNodes[i]);
+		}
+	}
+
+	bool bOwnsNode(void *node)
+	{
+		return((((SMapNode *)node)>=&mNodes[0])&&(((SMapNode *)node)<&mNodes[MAPBLOCK_SIZE_NODES]));
+	}
+};
+
+#ifndef _XBOX
+CMapPoolLow::CMapPoolLow()
+{
+	mLastBlockNum=-1;	
+}
+
+CMapPoolLow::~CMapPoolLow()
+{
+#if _DEBUG
+	char mess[1000];
+#if _GAME
+	if(mFreeList.size()<mMapBlocks.size()*MAPBLOCK_SIZE_NODES)
+	{
+		sprintf(mess,"[MEM][GAME]  !!!! Map Pool Leaked %d nodes\n",(MAPBLOCK_SIZE_NODES*mMapBlocks.size())-mFreeList.size());
+		OutputDebugString(mess);
+	}
+	sprintf(mess, "[MEM][GAME]  Map Pool max. mem used = %d\n",mMapBlocks.size()*MAPBLOCK_SIZE_NODES*MAP_NODE_SIZE);
+	OutputDebugString(mess);
+#elif _CGAME
+	if (mFreeList.size()<mMapBlocks.size()*MAPBLOCK_SIZE_NODES)
+	{
+		sprintf(mess, "[MEM][CGAME]  !!!! Map Pool Leaked %d nodes\n",(MAPBLOCK_SIZE_NODES*mMapBlocks.size())-mFreeList.size());
+		OutputDebugString(mess);
+	}
+	sprintf(mess, "[MEM][CGAME] Map Pool max. mem used = %d\n",mMapBlocks.size()*MAPBLOCK_SIZE_NODES*MAP_NODE_SIZE);
+	OutputDebugString(mess);
+#else
+	if (mFreeList.size()<mMapBlocks.size()*MAPBLOCK_SIZE_NODES)
+	{
+		sprintf(mess, "[MEM][EXE]  !!!! Map Pool Leaked %d nodes\n",(MAPBLOCK_SIZE_NODES*mMapBlocks.size())-mFreeList.size());
+		OutputDebugString(mess);
+	}
+	sprintf(mess, "[MEM][EXE] Map Pool max. mem used = %d\n",mMapBlocks.size()*MAPBLOCK_SIZE_NODES*MAP_NODE_SIZE);
+	OutputDebugString(mess);
+#endif
+#endif
+
+	int i;
+	for (i=0;i<mMapBlocks.size();i++)
+	{
+		delete mMapBlocks[i];
+	}
+}
+
+void *CMapPoolLow::Alloc()
+{
+	// Try to request a node. First we look in the free-list, but if that
+	// happens to be empty, we allocate more storage in the current CMapBlock.
+	void *node=0;
+	if(mFreeList.size())
+	{
+		// Retrieve the node to be recycled.
+		node=(void *)mFreeList[mFreeList.size()-1];
+		mFreeList.pop_back();
+	}
+	else
+	{
+		// None free, so alloc another block.
+		CMapBlock *block=new CMapBlock(mLastBlockNum+1,mFreeList);
+		assert(block);
+		mMapBlocks.push_back(block);
+		mLastBlockNum++;
+		node=(void *)mFreeList[mFreeList.size()-1];
+		mFreeList.pop_back();
+	}
+
+	// Validate we aren't somehow grabbing something that is already in use
+	// and also that the end marker is intact.
+	assert(((SMapNode *)node)->mTag==MAPNODE_FREE);
+	assert((((SMapNode *)node)->mMapBlockNum)>=0);
+	assert((((SMapNode *)node)->mMapBlockNum)<256);
+	assert((((SMapNode *)node)->mMapBlockNum)<=mLastBlockNum);
+	assert(mMapBlocks[((SMapNode *)node)->mMapBlockNum]->bOwnsNode(node));
+
+	// Ok, mark the node as in use.
+	((SMapNode *)node)->mTag=MAPNODE_INUSE;
+
+	return(node);
+}
+
+void CMapPoolLow::Free(void *p)
+{
+	// Validate that someone isn't trying to double free this node and also
+	// that the end marker is intact. 
+	assert(((SMapNode *)p)->mTag==MAPNODE_INUSE);
+	assert((((SMapNode *)p)->mMapBlockNum)>=0);
+	assert((((SMapNode *)p)->mMapBlockNum)<256);
+	assert((((SMapNode *)p)->mMapBlockNum)<=mLastBlockNum);
+	assert(mMapBlocks[((SMapNode *)p)->mMapBlockNum]->bOwnsNode(p));
+
+	// Ok, mark the the node as free.
+	((SMapNode *)p)->mTag=MAPNODE_FREE;
+
+	// Add a new freelist entry to point at this node.
+	mFreeList.push_back(p);
+}
+
+void CMapPoolLow::TouchMem()
+{
+	int				i,j;
+	unsigned char	*memory;
+	int				totSize=0;
+	for(i=0;i<mMapBlocks.size();i++)
+	{
+		memory=(unsigned char *)mMapBlocks[i];
+		totSize+=sizeof(CMapBlock);
+		for(j=0;j<sizeof(CMapBlock);j+=256)
+		{
+			HaHaOptimizer2+=memory[j];
+		}
+	}
+#ifdef _DEBUG
+	Com_Printf("MapPool: Bytes touched %i\n",totSize);
+#endif
+}
+#endif // _XBOX
+
+////////////
+// hString stuff
+////////////
+#define MAX_HASH (65536*2)
+
+// Max number of strings we can ever deal with.
+#define MAX_HSTRINGS 100000
+
+// Size of a string storage block in bytes.
+#define	BLOCK_SIZE	65536
+
+
+int HashFunction(const char *key)
+{
+	long	hash=0;
+	int		i=0;
+	unsigned char	letter;
+
+	letter = (unsigned char)*key++;
+	while (letter)
+	{
+		hash += (long)(letter) * (i + 119);
+		i++;
+		letter = (unsigned char)*key++;
+	}
+	hash &= MAX_HASH - 1;
+	return (int)hash;
+}
+
+
+class CHashHelper
+{
+	int mHashes[MAX_HASH];
+	int mFindPtr;
+	int mFindPtrStart;
+public:
+	CHashHelper() 
+	{
+		int i;
+		for (i=0;i<MAX_HASH;i++)
+		{
+			mHashes[i]=0;
+		}
+	}
+	void Add(int hash,int value)
+	{
+		assert(hash>=0&&hash<MAX_HASH);
+		assert(value); // 0 is the empty marker
+		int i=hash;
+		while (mHashes[i])
+		{
+			assert(mHashes[i]!=value); //please don't insert things twice
+			i=(i+1)&(MAX_HASH-1);
+			assert(i!=hash); //hash table is full?
+		}
+		mHashes[i]=value;
+	}
+	int FindFirst(int hash)
+	{
+		mFindPtr=hash;
+		mFindPtrStart=hash;
+		return FindNext();
+	}
+	int FindNext()
+	{
+		assert(mFindPtr>=0&&mFindPtr<MAX_HASH);
+		int val=mHashes[mFindPtr];
+		mFindPtr=(mFindPtr+1)&(MAX_HASH-1);
+		assert(mFindPtr!=mFindPtrStart); //hash table full?
+		return val;
+	}
+	void TouchMem()
+	{
+		int	i;
+		for(i=0;i<sizeof(mHashes);i+=256)
+		{
+			HaHaOptimizer2+=((unsigned char	*)mHashes)[i];
+		}
+#ifdef _DEBUG
+		Com_Printf("Hash helper: Bytes touched %i\n",sizeof(mHashes));
+#endif
+	}
+};
+
+CHashHelper &HashHelper()
+{
+	static CHashHelper It;
+	return It;
+}
+
+static char	*gCharPtrs[MAX_HSTRINGS];
+
+class CHSBlock
+{
+	int		mBytesUsed;
+	char	mRaw[BLOCK_SIZE];
+
+public:
+	CHSBlock(void) :
+		mBytesUsed(0)
+	{
+		// So we can do a comparison of blocks for debug purposes.
+		memset(mRaw,0,BLOCK_SIZE);
+	};
+
+	char *Alloc(int sizeBytes)
+	{
+		// Remember to include 0 termintor in size.
+		sizeBytes++;
+
+		// Is it WAAAY to big? If so we complain loudly.
+		assert(sizeBytes<=BLOCK_SIZE);
+
+		// If we don't have space in the current block, return failure.
+		if(sizeBytes>(BLOCK_SIZE-mBytesUsed))
+		{
+			return(0);
+		}
+		
+		// Return the pointer to the start of allocated space.
+		char *ret=&mRaw[mBytesUsed];
+		mBytesUsed+=sizeBytes;
+		return ret;
+	}
+
+	bool operator== (const CHSBlock &block) const
+	{
+		if(!memcmp(mRaw,block.mRaw,BLOCK_SIZE))
+		{
+			return(true);
+		}
+		return(false);
+	}
+};
+
+class CPool
+{
+	vector<CHSBlock *>	mBlockVec;
+
+public:
+	int					mNextStringId;
+	int					mLastBlockNum;
+
+	CPool(void) :
+		mNextStringId(1),
+		mLastBlockNum(-1)
+	{
+		memset(gCharPtrs,0,MAX_HSTRINGS*4);
+	}
+
+	~CPool(void)
+	{
+		int i;
+		for (i=0;i<mBlockVec.size();i++)
+		{
+			delete mBlockVec[i];
+		}
+	}
+
+	char *Alloc(int sizeBytes,int &id)
+	{
+		// Can't alloc more than MAX_HSTRINGS.
+		assert(mNextStringId<MAX_HSTRINGS);
+		char *raw=0;
+		if (mLastBlockNum>=0)
+		{
+			// Get the pointer to the start of allocated space in the current block.
+			raw=mBlockVec[mLastBlockNum]->Alloc(sizeBytes);
+		}
+		if(!raw)
+		{
+			// Ok, make a new empty block and append it.
+			CHSBlock *block=new(CHSBlock);
+			mBlockVec.push_back(block);
+			mLastBlockNum++;
+			raw=mBlockVec[mLastBlockNum]->Alloc(sizeBytes);
+		}
+		// Should never really happen!!
+		assert(raw);
+
+		id=mNextStringId;
+		gCharPtrs[mNextStringId]=raw;
+		mNextStringId++;
+
+		return(raw);
+	}
+
+	bool operator== (const CPool &pool) const
+	{
+		int i;
+		for(i=0;i<mBlockVec.size();i++)
+		{
+			if(!(*mBlockVec[i]==*pool.mBlockVec[i]))
+			{
+				return(false);
+			}
+		}
+		return(true);
+	}
+
+	void TouchMem()
+	{
+		int				i,j;
+		unsigned char	*memory;
+		int				totSize=0;
+		for(i=0;i<mBlockVec.size();i++)
+		{
+			memory=(unsigned char *)mBlockVec[i];
+			totSize+=sizeof(CHSBlock);
+			for(j=0;j<sizeof(CHSBlock);j+=256)
+			{
+				HaHaOptimizer2+=memory[j];
+			}
+		}
+#ifdef _DEBUG
+		Com_Printf("String Pool: Bytes touched %i\n",totSize);
+#endif
+	}
+};
+
+#ifdef _DEBUG
+CPool &TheDebugPool(void);
+CPool &ThePool(void);
+
+class CPoolChecker
+{
+public:
+	CPoolChecker()
+	{
+		TheDebugPool();
+		ThePool();
+	}
+	~CPoolChecker()
+	{
+#if 0
+		int i;
+		for (i=1;i<ThePool().mNextStringId;i++)
+		{
+			OutputDebugString(gCharPtrs[i]);
+			OutputDebugString("\n");
+		}
+#endif
+#if _DEBUG
+		char mess[1000];
+#if _GAME
+		sprintf(mess,"[MEM][GAME]  String Pool %d unique strings, %dK\n",ThePool().mNextStringId,(ThePool().mLastBlockNum+1)*BLOCK_SIZE/1024);
+#elif _CGAME
+		sprintf(mess,"[MEM][CGAME]  String Pool %d unique strings, %dK\n",ThePool().mNextStringId,(ThePool().mLastBlockNum+1)*BLOCK_SIZE/1024);
+#else
+		sprintf(mess,"[MEM][EXE]  String Pool %d unique strings, %dK\n",ThePool().mNextStringId,(ThePool().mLastBlockNum+1)*BLOCK_SIZE/1024);
+#endif
+		OutputDebugString(mess);
+#endif
+		// if this fails it means the string storage is CORRUPTED, let someone know
+		assert(TheDebugPool()==ThePool());
+	}
+};
+
+static CPoolChecker TheCPoolChecker;
+
+CPool &TheDebugPool(void)
+{
+	static CPool theDebugPool;
+	return(theDebugPool);
+}
+
+
+#endif
+
+CPool &ThePool(void)
+{
+	static CPool thePool;
+	return(thePool);
+}
+
+void TouchStringPool(void)
+{
+	ThePool().TouchMem();
+	HashHelper().TouchMem();
+}
+
+//
+// Now the rest of the hString class.
+//
+#ifdef _XBOX
+namespace exeNamespace
+{
+#endif
+
+void hstring::Init(const char *str)
+{
+	if(!str)
+	{
+		mId=0;
+		return;
+	}
+	int hash=HashFunction(str);
+	int id=HashHelper().FindFirst(hash);
+	while (id)
+	{
+		assert(id>0&&id<ThePool().mNextStringId);
+		if (!strcmp(str,gCharPtrs[id]))
+		{
+			mId=id;
+			return;
+		}
+		id=HashHelper().FindNext();
+	}
+	char *raw=ThePool().Alloc(strlen(str),mId);
+	strcpy(raw,str);
+	HashHelper().Add(hash,mId);
+#ifdef _DEBUG
+	int test;
+	raw=TheDebugPool().Alloc(strlen(str),test);
+	assert(test==mId);
+	strcpy(raw,str);
+#endif
+
+}
+
+const char *hstring::c_str(void) const
+{
+	if(!mId)
+	{
+		return("");
+	}
+	assert(mId>0&&mId<ThePool().mNextStringId);
+	return(gCharPtrs[mId]);
+}
+
+string hstring::str(void) const
+{
+	if(!mId)
+	{
+		return(string());
+	}
+	assert(mId>0&&mId<ThePool().mNextStringId);
+	return string(gCharPtrs[mId]);
+}
+
+#ifdef _XBOX
+} // exeNamespace
+#endif
diff --git a/code/qcommon/hstring.h b/code/qcommon/hstring.h
new file mode 100644
index 0000000..84ea68c
--- /dev/null
+++ b/code/qcommon/hstring.h
@@ -0,0 +1,219 @@
+#if !defined hString_H
+#define hString_H
+
+#pragma warning (push, 3)	//go back down to 3 for the stl include
+#include <string>
+#include <set>
+#include <list>
+#include <map>
+#pragma warning (pop)
+
+using namespace std;
+
+class hstring
+{
+	int	mId;
+	
+	void Init(const char *str);
+
+public:
+	hstring()
+	{
+		mId=0;
+	}
+	hstring(const char *str)
+	{
+		Init(str);
+	}
+	hstring(const string &str)
+	{
+		Init(str.c_str());
+	}
+	hstring(const hstring &str) 
+	{
+		mId=str.mId;
+	}
+
+	operator string () const
+	{
+		return str();
+	}
+
+	const char *c_str(void) const;
+	string str(void) const;
+	
+	hstring& operator= (const char *str)
+	{
+		Init(str);
+		return *this;
+	}
+	hstring& operator= (const string &str)
+	{
+		Init(str.c_str());
+		return *this;
+	}
+	hstring& operator= (const hstring &str)
+	{
+		mId=str.mId;
+		return *this;
+	}
+
+	bool operator== (const hstring &str) const
+	{
+		return((mId==str.mId)?true:false);
+	}
+
+	int compare(const hstring &str) const
+	{
+		return strcmp(c_str(),str.c_str());
+	}
+
+	bool operator< (const hstring &str) const
+	{
+		return((mId<str.mId)?true:false);
+	}
+	int length() const
+	{
+		return strlen(c_str());
+	}
+};
+
+
+void TouchStringPool(void);
+
+////////////
+// MapPool
+////////////
+#define MAP_NODE_SIZE (32)
+
+class CMapBlock;
+class CMapPoolLow
+{
+	vector <CMapBlock *>	mMapBlocks;
+	vector <void *>			mFreeList;
+	int						mLastBlockNum;
+
+public:
+	CMapPoolLow();
+	~CMapPoolLow();
+	void *Alloc();
+	void Free(void *p);
+	void TouchMem();
+};
+
+CMapPoolLow &GetMapPool();
+
+template<class T>
+class CMapPool
+{
+	CMapPoolLow &mPool;
+public:
+	CMapPool() : mPool(GetMapPool())
+	{
+
+	}
+	template <class U>
+	CMapPool(const U&) : mPool(GetMapPool())
+	{
+	}
+	~CMapPool()
+	{
+	}
+
+	typedef T        value_type;
+	typedef T*       pointer;
+	typedef const T* const_pointer;
+	typedef T&       reference;
+	typedef const T& const_reference;
+	typedef size_t    size_type;
+	typedef ptrdiff_t difference_type;
+	
+	template <class U>
+	struct rebind 
+	{
+	   typedef CMapPool<U> other;
+	};
+	
+	// return address of values
+	pointer address (reference value) const 
+	{
+	   return &value;
+	}
+	const_pointer address (const_reference value) const 
+	{
+	   return &value;
+	}
+		
+	// return maximum number of elements that can be allocated
+	size_type max_size () const
+	{
+//	   return mMaxSize;
+	   return 0xfffffff;	//uh, take a guess
+	}
+	
+	// allocate but don't initialize num elements of type T
+	pointer allocate (size_type num, const void* = 0) 
+	{
+		assert(sizeof(T)<=(MAP_NODE_SIZE-2)); // to big for this pool
+		assert(num==1); //allocator not design for this
+		return (T*)mPool.Alloc();
+	}
+	void *_Charalloc(size_type size)
+	{
+		assert(size<=(MAP_NODE_SIZE-2)); // to big for this pool
+		return mPool.Alloc();
+	}
+	
+	// initialize elements of allocated storage p with value value
+	void construct (pointer p, const T& value) 
+	{
+	   // initialize memory with placement new
+	   new((void*)p)T(value);
+	}
+	
+	// destroy elements of initialized storage p
+	void destroy (pointer p) 
+	{
+	   // destroy objects by calling their destructor
+	   p->~T();
+	}
+	
+	// deallocate storage p of deleted elements
+	template<class U>
+	void deallocate (U *p, size_type num) 
+	{
+		assert(num==1); //allocator not design for this
+		mPool.Free(p);
+	}
+};
+
+template <class T1,class T2>
+bool operator== (const CMapPool<T1>&,
+                const CMapPool<T2>&)
+{
+   return false;
+}
+template <class T1,class T2>
+bool operator!= (const CMapPool<T1>&,
+                const CMapPool<T2>&)
+{
+   return true;
+}
+
+
+template <class K,class V,class Compare = less<K> >
+class hmap : public map<K,V,Compare,CMapPool<V> >{};
+
+template <class K,class V,class Compare = less<K> >
+class hmultimap : public multimap<K,V,Compare,CMapPool<V> >{};
+
+template <class K,class Compare = less<K> >
+class hset : public set<K,Compare,CMapPool<K> >{};
+
+template <class K,class Compare = less<K> >
+class hmultiset : public multiset<K,Compare,CMapPool<K> >{};
+
+template <class K>
+class hlist : public list<K,CMapPool<K> >{};
+
+#endif // hString_H
\ No newline at end of file
diff --git a/code/qcommon/md4.cpp b/code/qcommon/md4.cpp
new file mode 100644
index 0000000..982a284
--- /dev/null
+++ b/code/qcommon/md4.cpp
@@ -0,0 +1,274 @@
+/* GLOBAL.H - RSAREF types and constants */
+
+#include <string.h>
+
+/* POINTER defines a generic pointer type */
+typedef unsigned char *POINTER;
+
+/* UINT2 defines a two byte word */
+typedef unsigned short int UINT2;
+
+/* UINT4 defines a four byte word */
+typedef unsigned long int UINT4;
+
+  
+/* MD4.H - header file for MD4C.C */
+
+/* Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. 
+
+All rights reserved.
+  
+License to copy and use this software is granted provided that it is identified as the “RSA Data Security, Inc. MD4 Message-Digest Algorithm” in all material mentioning or referencing this software or this function.
+License is also granted to make and use derivative works provided that such works are identified as “derived from the RSA Data Security, Inc. MD4 Message-Digest Algorithm” in all material mentioning or referencing the derived work.
+RSA Data Security, Inc. makes no representations concerning either the merchantability of this software or the suitability of this software for any particular purpose. It is provided “as is” without express or implied warranty of any kind.
+  
+These notices must be retained in any copies of any part of this documentation and/or software. */
+
+/* MD4 context. */
+typedef struct {
+	UINT4 state[4];				/* state (ABCD) */
+	UINT4 count[2];				/* number of bits, modulo 2^64 (lsb first) */
+	unsigned char buffer[64]; 			/* input buffer */
+} MD4_CTX;
+
+void MD4Init (MD4_CTX *);
+void MD4Update (MD4_CTX *, const unsigned char *, unsigned int);
+void MD4Final (unsigned char [16], MD4_CTX *);
+  
+
+  
+/* MD4C.C - RSA Data Security, Inc., MD4 message-digest algorithm */
+/* Copyright (C) 1990-2, RSA Data Security, Inc. All rights reserved.
+  
+License to copy and use this software is granted provided that it is identified as the
+RSA Data Security, Inc. MD4 Message-Digest Algorithm
+ in all material mentioning or referencing this software or this function.
+License is also granted to make and use derivative works provided that such works are identified as 
+derived from the RSA Data Security, Inc. MD4 Message-Digest Algorithm
+in all material mentioning or referencing the derived work.
+RSA Data Security, Inc. makes no representations concerning either the merchantability of this software or the suitability of this software for any particular purpose. It is provided
+as is without express or implied warranty of any kind.
+  
+These notices must be retained in any copies of any part of this documentation and/or software. */
+
+/* Constants for MD4Transform routine.  */
+#define S11 3
+#define S12 7
+#define S13 11
+#define S14 19
+#define S21 3
+#define S22 5
+#define S23 9
+#define S24 13
+#define S31 3
+#define S32 9
+#define S33 11
+#define S34 15
+
+static void MD4Transform (UINT4 [4], const unsigned char [64]);
+static void Encode (unsigned char *, UINT4 *, unsigned int);
+static void Decode (UINT4 *, const unsigned char *, unsigned int);
+
+static unsigned char PADDING[64] = {
+0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
+};
+
+/* F, G and H are basic MD4 functions. */
+#define F(x, y, z) (((x) & (y)) | ((~x) & (z)))
+#define G(x, y, z) (((x) & (y)) | ((x) & (z)) | ((y) & (z)))
+#define H(x, y, z) ((x) ^ (y) ^ (z))
+
+/* ROTATE_LEFT rotates x left n bits. */
+#define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32-(n))))
+
+/* FF, GG and HH are transformations for rounds 1, 2 and 3 */
+/* Rotation is separate from addition to prevent recomputation */
+#define FF(a, b, c, d, x, s) {(a) += F ((b), (c), (d)) + (x); (a) = ROTATE_LEFT ((a), (s));}
+
+#define GG(a, b, c, d, x, s) {(a) += G ((b), (c), (d)) + (x) + (UINT4)0x5a827999; (a) = ROTATE_LEFT ((a), (s));}
+
+#define HH(a, b, c, d, x, s) {(a) += H ((b), (c), (d)) + (x) + (UINT4)0x6ed9eba1; (a) = ROTATE_LEFT ((a), (s));}
+
+
+/* MD4 initialization. Begins an MD4 operation, writing a new context. */
+void MD4Init (MD4_CTX *context)
+{
+	context->count[0] = context->count[1] = 0;
+
+/* Load magic initialization constants.*/
+context->state[0] = 0x67452301;
+context->state[1] = 0xefcdab89;
+context->state[2] = 0x98badcfe;
+context->state[3] = 0x10325476;
+}
+
+/* MD4 block update operation. Continues an MD4 message-digest operation, processing another message block, and updating the context. */
+void MD4Update (MD4_CTX *context, const unsigned char *input, unsigned int inputLen)
+{
+	unsigned int i, index, partLen;
+
+	/* Compute number of bytes mod 64 */
+	index = (unsigned int)((context->count[0] >> 3) & 0x3F);
+
+	/* Update number of bits */
+	if ((context->count[0] += ((UINT4)inputLen << 3))< ((UINT4)inputLen << 3))
+		context->count[1]++;
+
+	context->count[1] += ((UINT4)inputLen >> 29);
+
+	partLen = 64 - index;
+
+	/* Transform as many times as possible.*/
+	if (inputLen >= partLen)
+	{
+ 		memcpy((POINTER)&context->buffer[index], (POINTER)input, partLen);
+ 		MD4Transform (context->state, context->buffer);
+
+ 		for (i = partLen; i + 63 < inputLen; i += 64)
+ 			MD4Transform (context->state, &input[i]);
+
+ 		index = 0;
+	}
+	else
+ 		i = 0;
+
+	/* Buffer remaining input */
+	memcpy ((POINTER)&context->buffer[index], (POINTER)&input[i], inputLen-i);
+}
+
+
+/* MD4 finalization. Ends an MD4 message-digest operation, writing the the message digest and zeroizing the context. */
+void MD4Final (unsigned char digest[16], MD4_CTX *context)
+{
+	unsigned char bits[8];
+	unsigned int index, padLen;
+
+	/* Save number of bits */
+	Encode (bits, context->count, 8);
+
+	/* Pad out to 56 mod 64.*/
+	index = (unsigned int)((context->count[0] >> 3) & 0x3f);
+	padLen = (index < 56) ? (56 - index) : (120 - index);
+	MD4Update (context, PADDING, padLen);
+
+	/* Append length (before padding) */
+	MD4Update (context, bits, 8);
+	
+	/* Store state in digest */
+	Encode (digest, context->state, 16);
+
+	/* Zeroize sensitive information.*/
+	memset ((POINTER)context, 0, sizeof (*context));
+}
+
+
+/* MD4 basic transformation. Transforms state based on block. */
+static void MD4Transform (UINT4 state[4], const unsigned char block[64])
+{
+	UINT4 a = state[0], b = state[1], c = state[2], d = state[3], x[16];
+
+	Decode (x, block, 64);
+
+/* Round 1 */
+FF (a, b, c, d, x[ 0], S11); 				/* 1 */
+FF (d, a, b, c, x[ 1], S12); 				/* 2 */
+FF (c, d, a, b, x[ 2], S13); 				/* 3 */
+FF (b, c, d, a, x[ 3], S14); 				/* 4 */
+FF (a, b, c, d, x[ 4], S11); 				/* 5 */
+FF (d, a, b, c, x[ 5], S12); 				/* 6 */
+FF (c, d, a, b, x[ 6], S13); 				/* 7 */
+FF (b, c, d, a, x[ 7], S14); 				/* 8 */
+FF (a, b, c, d, x[ 8], S11); 				/* 9 */
+FF (d, a, b, c, x[ 9], S12); 				/* 10 */
+FF (c, d, a, b, x[10], S13); 			/* 11 */
+FF (b, c, d, a, x[11], S14); 			/* 12 */
+FF (a, b, c, d, x[12], S11); 			/* 13 */
+FF (d, a, b, c, x[13], S12); 			/* 14 */
+FF (c, d, a, b, x[14], S13); 			/* 15 */
+FF (b, c, d, a, x[15], S14); 			/* 16 */
+
+/* Round 2 */
+GG (a, b, c, d, x[ 0], S21); 			/* 17 */
+GG (d, a, b, c, x[ 4], S22); 			/* 18 */
+GG (c, d, a, b, x[ 8], S23); 			/* 19 */
+GG (b, c, d, a, x[12], S24); 			/* 20 */
+GG (a, b, c, d, x[ 1], S21); 			/* 21 */
+GG (d, a, b, c, x[ 5], S22); 			/* 22 */
+GG (c, d, a, b, x[ 9], S23); 			/* 23 */
+GG (b, c, d, a, x[13], S24); 			/* 24 */
+GG (a, b, c, d, x[ 2], S21); 			/* 25 */
+GG (d, a, b, c, x[ 6], S22); 			/* 26 */
+GG (c, d, a, b, x[10], S23); 			/* 27 */
+GG (b, c, d, a, x[14], S24); 			/* 28 */
+GG (a, b, c, d, x[ 3], S21); 			/* 29 */
+GG (d, a, b, c, x[ 7], S22); 			/* 30 */
+GG (c, d, a, b, x[11], S23); 			/* 31 */
+GG (b, c, d, a, x[15], S24); 			/* 32 */
+
+/* Round 3 */
+HH (a, b, c, d, x[ 0], S31);				/* 33 */
+HH (d, a, b, c, x[ 8], S32); 			/* 34 */
+HH (c, d, a, b, x[ 4], S33); 			/* 35 */
+HH (b, c, d, a, x[12], S34); 			/* 36 */
+HH (a, b, c, d, x[ 2], S31); 			/* 37 */
+HH (d, a, b, c, x[10], S32); 			/* 38 */
+HH (c, d, a, b, x[ 6], S33); 			/* 39 */
+HH (b, c, d, a, x[14], S34); 			/* 40 */
+HH (a, b, c, d, x[ 1], S31); 			/* 41 */
+HH (d, a, b, c, x[ 9], S32); 			/* 42 */
+HH (c, d, a, b, x[ 5], S33); 			/* 43 */
+HH (b, c, d, a, x[13], S34); 			/* 44 */
+HH (a, b, c, d, x[ 3], S31); 			/* 45 */
+HH (d, a, b, c, x[11], S32); 			/* 46 */
+HH (c, d, a, b, x[ 7], S33); 			/* 47 */
+HH (b, c, d, a, x[15], S34);			/* 48 */
+
+state[0] += a;
+state[1] += b;
+state[2] += c;
+state[3] += d;
+
+	/* Zeroize sensitive information.*/
+	memset ((POINTER)x, 0, sizeof (x));
+}
+
+
+/* Encodes input (UINT4) into output (unsigned char). Assumes len is a multiple of 4. */
+static void Encode (unsigned char *output, UINT4 *input, unsigned int len)
+{
+	unsigned int i, j;
+
+	for (i = 0, j = 0; j < len; i++, j += 4) {
+ 		output[j] = (unsigned char)(input[i] & 0xff);
+ 		output[j+1] = (unsigned char)((input[i] >> 8) & 0xff);
+ 		output[j+2] = (unsigned char)((input[i] >> 16) & 0xff);
+ 		output[j+3] = (unsigned char)((input[i] >> 24) & 0xff);
+	}
+}
+
+
+/* Decodes input (unsigned char) into output (UINT4). Assumes len is a multiple of 4. */
+static void Decode (UINT4 *output, const unsigned char *input, unsigned int len)
+{
+unsigned int i, j;
+
+for (i = 0, j = 0; j < len; i++, j += 4)
+ 	output[i] = ((UINT4)input[j]) | (((UINT4)input[j+1]) << 8) | (((UINT4)input[j+2]) << 16) | (((UINT4)input[j+3]) << 24);
+}
+
+//===================================================================
+
+unsigned Com_BlockChecksum (void const *buffer, int length)
+{
+	int			digest[4];
+	unsigned	val;
+	MD4_CTX		ctx;
+
+	MD4Init (&ctx);
+	MD4Update (&ctx, (unsigned char *)buffer, length);
+	MD4Final ( (unsigned char *)digest, &ctx);
+	
+	val = digest[0] ^ digest[1] ^ digest[2] ^ digest[3];
+
+	return val;
+}
diff --git a/code/qcommon/msg.cpp b/code/qcommon/msg.cpp
new file mode 100644
index 0000000..15ea66f
--- /dev/null
+++ b/code/qcommon/msg.cpp
@@ -0,0 +1,1248 @@
+
+#include "../game/q_shared.h"
+#include "qcommon.h"
+#include "../server/server.h"
+
+
+
+/*
+==============================================================================
+
+			MESSAGE IO FUNCTIONS
+
+Handles byte ordering and avoids alignment errors
+==============================================================================
+*/
+
+
+void MSG_Init( msg_t *buf, byte *data, int length ) {
+	memset (buf, 0, sizeof(*buf));
+	buf->data = data;
+	buf->maxsize = length;
+}
+
+void MSG_Clear( msg_t *buf ) {
+	buf->cursize = 0;
+	buf->overflowed = qfalse;
+	buf->bit = 0;
+}
+
+
+void MSG_BeginReading( msg_t *msg ) {
+	msg->readcount = 0;
+	msg->bit = 0;
+}
+
+
+void MSG_ReadByteAlign( msg_t *buf ) {
+	// round up to the next byte
+	if ( buf->bit ) {
+		buf->bit = 0;
+		buf->readcount++;
+	}
+}
+
+void *MSG_GetSpace( msg_t *buf, int length ) {
+	void	*data;
+
+	// round up to the next byte
+	if ( buf->bit ) {
+		buf->bit = 0;
+		buf->cursize++;
+	}
+
+	if ( buf->cursize + length > buf->maxsize )	{
+		if ( !buf->allowoverflow ) {
+			Com_Error (ERR_FATAL, "MSG_GetSpace: overflow without allowoverflow set");
+		}
+		if ( length > buf->maxsize ) {
+			Com_Error (ERR_FATAL, "MSG_GetSpace: %i is > full buffer size", length);
+		}
+		Com_Printf ("MSG_GetSpace: overflow\n");
+		MSG_Clear (buf); 
+		buf->overflowed = qtrue;
+	}
+
+	data = buf->data + buf->cursize;
+	buf->cursize += length;
+	
+	return data;
+}
+
+void MSG_WriteData( msg_t *buf, const void *data, int length ) {
+	memcpy (MSG_GetSpace(buf,length),data,length);		
+}
+
+
+/*
+=============================================================================
+
+bit functions
+  
+=============================================================================
+*/
+
+int	overflows;
+
+// negative bit values include signs
+void MSG_WriteBits( msg_t *msg, int value, int bits ) {
+	int		put;
+	int		fraction;
+
+	// this isn't an exact overflow check, but close enough
+	if ( msg->maxsize - msg->cursize < 4 ) {
+		msg->overflowed = qtrue;
+#ifndef FINAL_BUILD
+		Com_Printf (S_COLOR_RED"MSG_WriteBits: buffer Full writing %d in %d bits\n", value, bits);
+#endif
+		return;
+	}
+
+	if ( bits == 0 || bits < -31 || bits > 32 ) {
+		Com_Error( ERR_DROP, "MSG_WriteBits: bad bits %i", bits );
+	}
+
+	// check for overflows
+	if ( bits != 32 ) {
+		if ( bits > 0 ) {
+			if ( value > ( ( 1 << bits ) - 1 ) || value < 0 ) {
+				overflows++;
+#ifndef FINAL_BUILD
+#ifdef _DEBUG
+				Com_Printf (S_COLOR_RED"MSG_WriteBits: overflow writing %d in %d bits\n", value, bits);
+#endif
+#endif
+			}
+		} else {
+			int	r;
+
+			r = 1 << (bits-1);
+
+			if ( value >  r - 1 || value < -r ) {
+				overflows++;
+#ifndef FINAL_BUILD
+#ifdef _DEBUG
+				Com_Printf (S_COLOR_RED"MSG_WriteBits: overflow writing %d in %d bits\n", value, bits);
+#endif
+#endif
+			}
+		}
+	}
+	if ( bits < 0 ) {
+		bits = -bits;
+	}
+
+	while ( bits ) {
+		if ( msg->bit == 0 ) {
+			msg->data[msg->cursize] = 0;
+			msg->cursize++;
+		}
+		put = 8 - msg->bit;
+		if ( put > bits ) {
+			put = bits;
+		}
+		fraction = value & ( ( 1 << put ) - 1 );
+		msg->data[msg->cursize - 1] |= fraction << msg->bit;
+		bits -= put;
+		value >>= put;
+		msg->bit = ( msg->bit + put ) & 7;
+	}
+}
+
+int MSG_ReadBits( msg_t *msg, int bits ) {
+	int		value;
+	int		valueBits;
+	int		get;
+	int		fraction;
+	qboolean	sgn;
+
+	value = 0;
+	valueBits = 0;
+
+	if ( bits < 0 ) {
+		bits = -bits;
+		sgn = qtrue;
+	} else {
+		sgn = qfalse;
+	}
+
+	while ( valueBits < bits ) {
+		if ( msg->bit == 0 ) {
+			msg->readcount++;
+			assert (msg->readcount <= msg->cursize);
+		}
+		get = 8 - msg->bit;
+		if ( get > (bits - valueBits) ) {
+			get = (bits - valueBits);
+		}
+		fraction = msg->data[msg->readcount - 1];
+		fraction >>= msg->bit;
+		fraction &= ( 1 << get ) - 1;
+		value |= fraction << valueBits;
+
+		valueBits += get;
+		msg->bit = ( msg->bit + get ) & 7;
+	}
+
+	if ( sgn ) {
+		if ( value & ( 1 << ( bits - 1 ) ) ) {
+			value |= -1 ^ ( ( 1 << bits ) - 1 );
+		}
+	}
+
+	return value;
+}
+
+
+
+//================================================================================
+
+//
+// writing functions
+//
+
+void MSG_WriteByte( msg_t *sb, int c ) {
+#ifdef PARANOID
+	if (c < 0 || c > 255)
+		Com_Error (ERR_FATAL, "MSG_WriteByte: range error");
+#endif
+
+	MSG_WriteBits( sb, c, 8 );
+}
+
+void MSG_WriteShort( msg_t *sb, int c ) {
+#ifdef PARANOID
+	if (c < ((short)0x8000) || c > (short)0x7fff)
+		Com_Error (ERR_FATAL, "MSG_WriteShort: range error");
+#endif
+
+	MSG_WriteBits( sb, c, 16 );
+}
+
+static void MSG_WriteSShort( msg_t *sb, int c ) {
+	MSG_WriteBits( sb, c, -16 );
+}
+
+void MSG_WriteLong( msg_t *sb, int c ) {
+	MSG_WriteBits( sb, c, 32 );
+}
+
+void MSG_WriteString( msg_t *sb, const char *s ) {
+	if ( !s ) {
+		MSG_WriteData (sb, "", 1);
+	} else {
+		int		l, i;
+		char	string[MAX_STRING_CHARS];
+
+		l = strlen( s );
+		if ( l >= MAX_STRING_CHARS ) {
+			Com_Printf( "MSG_WriteString: MAX_STRING_CHARS" );
+			MSG_WriteData (sb, "", 1);
+			return;
+		}
+		Q_strncpyz( string, s, sizeof( string ) );
+
+		// get rid of 0xff chars, because old clients don't like them
+		for ( i = 0 ; i < l ; i++ ) {
+			if ( ((byte *)string)[i] > 127 ) {
+				string[i] = '.';
+			}
+		}
+
+		MSG_WriteData (sb, string, l+1);
+	}
+}
+
+
+
+//============================================================
+
+//
+// reading functions
+//
+
+// returns -1 if no more characters are available
+int MSG_ReadByte( msg_t *msg ) {
+	int	c;
+	
+	if ( msg->readcount+1 > msg->cursize ) {
+		c = -1;
+	} else {
+		c = (unsigned char)MSG_ReadBits( msg, 8 );
+	}
+	
+	return c;
+}
+
+int MSG_ReadShort( msg_t *msg ) {
+	int	c;
+	
+	if ( msg->readcount+2 > msg->cursize ) {
+		c = -1;
+	} else {
+		c = MSG_ReadBits( msg, 16 );
+	}
+
+	return c;
+}
+
+static int MSG_ReadSShort( msg_t *msg ) {
+	int	c;
+	
+	if ( msg->readcount+2 > msg->cursize ) {
+		c = -1;
+	} else {
+		c = MSG_ReadBits( msg, -16 );
+	}
+
+	return c;
+}
+
+int MSG_ReadLong( msg_t *msg ) {
+	int	c;
+	
+	if ( msg->readcount+4 > msg->cursize ) {
+		c = -1;
+	} else {
+		c = MSG_ReadBits( msg, 32 );
+	}
+	
+	return c;
+}
+
+char *MSG_ReadString( msg_t *msg ) {
+	static char	string[MAX_STRING_CHARS];
+	int		l,c;
+	
+	MSG_ReadByteAlign( msg );
+	l = 0;
+	do {
+		c = MSG_ReadByte(msg);		// use ReadByte so -1 is out of bounds
+		if ( c == -1 || c == 0 ) {
+			break;
+		}
+		// translate all fmt spec to avoid crash bugs
+		if ( c == '%' ) {
+			c = '.';
+		}
+
+		string[l] = c;
+		l++;
+	} while (l < sizeof(string)-1);
+	
+	string[l] = 0;
+	
+	return string;
+}
+
+char *MSG_ReadStringLine( msg_t *msg ) {
+	static char	string[MAX_STRING_CHARS];
+	int		l,c;
+
+	MSG_ReadByteAlign( msg );
+	l = 0;
+	do {
+		c = MSG_ReadByte(msg);		// use ReadByte so -1 is out of bounds
+		if (c == -1 || c == 0 || c == '\n') {
+			break;
+		}
+		// translate all fmt spec to avoid crash bugs
+		if ( c == '%' ) {
+			c = '.';
+		}
+		string[l] = c;
+		l++;
+	} while (l < sizeof(string)-1);
+	
+	string[l] = 0;
+	
+	return string;
+}
+
+
+void MSG_ReadData( msg_t *msg, void *data, int len ) {
+	int		i;
+
+	MSG_ReadByteAlign( msg );
+	for (i=0 ; i<len ; i++) {
+		((byte *)data)[i] = MSG_ReadByte (msg);
+	}
+}
+
+
+/*
+=============================================================================
+
+delta functions
+  
+=============================================================================
+*/
+
+extern cvar_t *cl_shownet;
+
+#define	LOG(x) if( cl_shownet->integer == 4 ) { Com_Printf("%s ", x ); };
+
+void MSG_WriteDelta( msg_t *msg, int oldV, int newV, int bits ) {
+	if ( oldV == newV ) {
+		MSG_WriteBits( msg, 0, 1 );
+		return;
+	}
+	MSG_WriteBits( msg, 1, 1 );
+	MSG_WriteBits( msg, newV, bits );
+}
+
+int	MSG_ReadDelta( msg_t *msg, int oldV, int bits ) {
+	if ( MSG_ReadBits( msg, 1 ) ) {
+		return MSG_ReadBits( msg, bits );
+	}
+	return oldV;
+}
+
+void MSG_WriteDeltaFloat( msg_t *msg, float oldV, float newV ) {
+	if ( oldV == newV ) {
+		MSG_WriteBits( msg, 0, 1 );
+		return;
+	}
+	MSG_WriteBits( msg, 1, 1 );
+	MSG_WriteBits( msg, *(int *)&newV, 32 );
+}
+
+float MSG_ReadDeltaFloat( msg_t *msg, float oldV ) {
+	if ( MSG_ReadBits( msg, 1 ) ) {
+		float	newV;
+
+		*(int *)&newV = MSG_ReadBits( msg, 32 );
+		return newV;
+	}
+	return oldV;
+}
+
+
+/*
+============================================================================
+
+usercmd_t communication
+
+============================================================================
+*/
+
+// ms is allways sent, the others are optional
+#define	CM_ANGLE1 	(1<<0)
+#define	CM_ANGLE2 	(1<<1)
+#define	CM_ANGLE3 	(1<<2)
+#define	CM_FORWARD	(1<<3)
+#define	CM_SIDE		(1<<4)
+#define	CM_UP		(1<<5)
+#define	CM_BUTTONS	(1<<6)
+#define CM_WEAPON	(1<<7)
+
+/*
+=====================
+MSG_WriteDeltaUsercmd
+=====================
+*/
+void MSG_WriteDeltaUsercmd( msg_t *msg, usercmd_t *from, usercmd_t *to ) {
+	MSG_WriteDelta( msg, from->serverTime, to->serverTime, 32 );
+	MSG_WriteDelta( msg, from->angles[0], to->angles[0], 16 );
+	MSG_WriteDelta( msg, from->angles[1], to->angles[1], 16 );
+	MSG_WriteDelta( msg, from->angles[2], to->angles[2], 16 );
+	MSG_WriteDelta( msg, from->forwardmove, to->forwardmove, -8 );
+	MSG_WriteDelta( msg, from->rightmove, to->rightmove, -8 );
+	MSG_WriteDelta( msg, from->upmove, to->upmove, -8 );
+	MSG_WriteDelta( msg, from->buttons, to->buttons, 16 );//FIXME:  We're only really using 9 bits...can this be changed to that?
+	MSG_WriteDelta( msg, from->weapon, to->weapon, 8 );
+	MSG_WriteDelta( msg, from->generic_cmd, to->generic_cmd, 8 );
+}
+
+
+/*
+=====================
+MSG_ReadDeltaUsercmd
+=====================
+*/
+void MSG_ReadDeltaUsercmd( msg_t *msg, usercmd_t *from, usercmd_t *to ) {
+	to->serverTime = MSG_ReadDelta( msg, from->serverTime, 32);
+	to->angles[0] = MSG_ReadDelta( msg, from->angles[0], 16);
+	to->angles[1] = MSG_ReadDelta( msg, from->angles[1], 16);
+	to->angles[2] = MSG_ReadDelta( msg, from->angles[2], 16);
+	to->forwardmove = MSG_ReadDelta( msg, from->forwardmove, -8);
+	to->rightmove = MSG_ReadDelta( msg, from->rightmove, -8);
+	to->upmove = MSG_ReadDelta( msg, from->upmove, -8);
+	to->buttons = MSG_ReadDelta( msg, from->buttons, 16);//FIXME:  We're only really using 9 bits...can this be changed to that?
+	to->weapon = MSG_ReadDelta( msg, from->weapon, 8);
+	to->generic_cmd = MSG_ReadDelta( msg, from->generic_cmd, 8);
+}
+
+/*
+=============================================================================
+
+entityState_t communication
+  
+=============================================================================
+*/
+
+typedef struct {
+	char	*name;
+	int		offset;
+	int		bits;		// 0 = float
+} netField_t;
+
+// using the stringizing operator to save typing...
+#define	NETF(x) #x,(int)&((entityState_t*)0)->x
+
+#if 0	// Removed by BTO (VV)
+const netField_t	entityStateFields[] = 
+{
+{ NETF(eType), 8 },
+{ NETF(eFlags), 32 },
+
+{ NETF(pos.trType), 8 },
+{ NETF(pos.trTime), 32 },
+{ NETF(pos.trDuration), 32 },
+{ NETF(pos.trBase[0]), 0 },
+{ NETF(pos.trBase[1]), 0 },
+{ NETF(pos.trBase[2]), 0 },
+{ NETF(pos.trDelta[0]), 0 },
+{ NETF(pos.trDelta[1]), 0 },
+{ NETF(pos.trDelta[2]), 0 },
+
+{ NETF(apos.trType), 8 },
+{ NETF(apos.trTime), 32 },
+{ NETF(apos.trDuration), 32 },
+{ NETF(apos.trBase[0]), 0 },
+{ NETF(apos.trBase[1]), 0 },
+{ NETF(apos.trBase[2]), 0 },
+{ NETF(apos.trDelta[0]), 0 },
+{ NETF(apos.trDelta[1]), 0 },
+{ NETF(apos.trDelta[2]), 0 },
+
+{ NETF(time), 32 },
+{ NETF(time2), 32 },
+
+{ NETF(origin[0]), 0 },
+{ NETF(origin[1]), 0 },
+{ NETF(origin[2]), 0 },
+
+{ NETF(origin2[0]), 0 },
+{ NETF(origin2[1]), 0 },
+{ NETF(origin2[2]), 0 },
+
+{ NETF(angles[0]), 0 },
+{ NETF(angles[1]), 0 },
+{ NETF(angles[2]), 0 },
+
+{ NETF(angles2[0]), 0 },
+{ NETF(angles2[1]), 0 },
+{ NETF(angles2[2]), 0 },
+
+{ NETF(otherEntityNum), GENTITYNUM_BITS },
+//{ NETF(otherEntityNum2), GENTITYNUM_BITS },
+{ NETF(groundEntityNum), GENTITYNUM_BITS },
+
+{ NETF(constantLight), 32 },
+{ NETF(loopSound), 16 },
+{ NETF(modelindex), 9 },	//0 to 511
+{ NETF(modelindex2), 8 },
+{ NETF(modelindex3), 8 },
+{ NETF(clientNum), 32 },
+{ NETF(frame), 16 },
+
+{ NETF(solid), 24 },
+
+{ NETF(event), 10 },
+{ NETF(eventParm), 16 },
+
+{ NETF(powerups), 16 },
+{ NETF(weapon), 8 },
+{ NETF(legsAnim), 16 },
+{ NETF(legsAnimTimer), 8 },
+{ NETF(torsoAnim), 16 },
+{ NETF(torsoAnimTimer), 8 },
+{ NETF(scale), 8 },
+
+{ NETF(saberInFlight), 4 },
+{ NETF(saberActive), 4 },
+{ NETF(vehicleArmor), 32 },
+{ NETF(vehicleAngles[0]), 0 },
+{ NETF(vehicleAngles[1]), 0 },
+{ NETF(vehicleAngles[2]), 0 },
+{ NETF(m_iVehicleNum), 32 },
+
+/*
+Ghoul2 Insert Start
+*/
+{ NETF(modelScale[0]), 0 },
+{ NETF(modelScale[1]), 0 },
+{ NETF(modelScale[2]), 0 },
+{ NETF(radius), 16 },
+{ NETF(boltInfo), 32 },
+//{ NETF(ghoul2), 32 },
+
+{ NETF(isPortalEnt), 1 },
+
+};
+#endif
+
+
+// if (int)f == f and (int)f + ( 1<<(FLOAT_INT_BITS-1) ) < ( 1 << FLOAT_INT_BITS )
+// the float will be sent with FLOAT_INT_BITS, otherwise all 32 bits will be sent
+#define	FLOAT_INT_BITS	13
+#define	FLOAT_INT_BIAS	(1<<(FLOAT_INT_BITS-1))
+
+void MSG_WriteField (msg_t *msg, const int *toF, const netField_t *field)
+{
+	int			trunc;
+	float		fullFloat;
+
+	if ( field->bits == -1)
+	{	// a -1 in the bits field means it's a float that's always between -1 and 1
+		int temp = *(float *)toF * 32767;
+ 		MSG_WriteBits( msg, temp, -16 );
+	}
+	else
+ 	if ( field->bits == 0 ) {
+ 		// float
+ 		fullFloat = *(float *)toF;
+ 		trunc = (int)fullFloat;
+
+		if (fullFloat == 0.0f) {
+			MSG_WriteBits( msg, 0, 1 );	//it's a zero
+		} else {
+			MSG_WriteBits( msg, 1, 1 );	//not a zero
+			if ( trunc == fullFloat && trunc + FLOAT_INT_BIAS >= 0 && 
+				trunc + FLOAT_INT_BIAS < ( 1 << FLOAT_INT_BITS ) ) {
+				// send as small integer
+				MSG_WriteBits( msg, 0, 1 );
+				MSG_WriteBits( msg, trunc + FLOAT_INT_BIAS, FLOAT_INT_BITS );
+			} else {
+				// send as full floating point value
+				MSG_WriteBits( msg, 1, 1 );
+				MSG_WriteBits( msg, *toF, 32 );
+			}
+		}
+ 	} else {
+		if (*toF == 0) {
+			MSG_WriteBits( msg, 0, 1 );	//it's a zero
+		} else {
+			MSG_WriteBits( msg, 1, 1 );	//not a zero
+			// integer
+			MSG_WriteBits( msg, *toF, field->bits );
+		}
+ 	}
+}
+
+void MSG_ReadField (msg_t *msg, int *toF, const netField_t *field, int print)
+{
+	int			trunc;
+
+	if ( field->bits == -1)
+	{	// a -1 in the bits field means it's a float that's always between -1 and 1
+		int temp = MSG_ReadBits( msg, -16);
+		*(float *)toF = (float)temp / 32767;
+	}
+	else
+  	if ( field->bits == 0 ) {
+  		// float
+		if ( MSG_ReadBits( msg, 1 ) == 0 ) {
+				*(float *)toF = 0.0f; 
+		} else {
+			if ( MSG_ReadBits( msg, 1 ) == 0 ) {
+				// integral float
+				trunc = MSG_ReadBits( msg, FLOAT_INT_BITS );
+				// bias to allow equal parts positive and negative
+				trunc -= FLOAT_INT_BIAS;
+				*(float *)toF = trunc; 
+				if ( print ) {
+					Com_Printf( "%s:%i ", field->name, trunc );
+				}
+			} else {
+				// full floating point value
+				*toF = MSG_ReadBits( msg, 32 );
+				if ( print ) {
+					Com_Printf( "%s:%f ", field->name, *(float *)toF );
+				}
+			}
+		}
+	} else {
+		if ( MSG_ReadBits( msg, 1 ) == 0 ) {
+			*toF = 0;
+		} else {
+			// integer
+			*toF = MSG_ReadBits( msg, field->bits );
+			if ( print ) {
+				Com_Printf( "%s:%i ", field->name, *toF );
+			}
+		}
+	}
+}
+
+
+/*
+==================
+MSG_WriteDeltaEntity
+
+
+GENTITYNUM_BITS 1 : remove this entity
+GENTITYNUM_BITS 0 1 SMALL_VECTOR_BITS <data>
+GENTITYNUM_BITS 0 0 LARGE_VECTOR_BITS >data>
+
+Writes part of a packetentities message, including the entity number.
+Can delta from either a baseline or a previous packet_entity
+If to is NULL, a remove entity update will be sent
+If force is not set, then nothing at all will be generated if the entity is
+identical, under the assumption that the in-order delta code will catch it.
+==================
+*/
+#if 0 // Removed by BTO (VV)
+void MSG_WriteDeltaEntity( msg_t *msg, struct entityState_s *from, struct entityState_s *to, 
+						   qboolean force ) {
+	int			c;
+	int			i;
+	const netField_t	*field;
+	int			*fromF, *toF;
+	int			blah;
+	bool		stuffChanged = false;
+	const int numFields = sizeof(entityStateFields)/sizeof(entityStateFields[0]);
+	byte		changeVector[(numFields/8) + 1];
+
+
+	// all fields should be 32 bits to avoid any compiler packing issues
+	// the "number" field is not part of the field list
+	// if this assert fails, someone added a field to the entityState_t
+	// struct without updating the message fields
+	blah = sizeof( *from );
+	assert( numFields + 1 == blah/4); 
+
+	c = msg->cursize;
+
+	// a NULL to is a delta remove message
+	if ( to == NULL ) {
+		if ( from == NULL ) {
+			return;
+		}
+		MSG_WriteBits( msg, from->number, GENTITYNUM_BITS );
+		MSG_WriteBits( msg, 1, 1 );
+		return;
+	}
+
+	if ( to->number < 0 || to->number >= MAX_GENTITIES ) {
+		Com_Error (ERR_FATAL, "MSG_WriteDeltaEntity: Bad entity number: %i", to->number );
+	}
+
+	memset(changeVector, 0, sizeof(changeVector));
+
+	// build the change vector as bytes so it is endien independent
+	for ( i = 0, field = entityStateFields ; i < numFields ; i++, field++ ) {
+		fromF = (int *)( (byte *)from + field->offset );
+		toF = (int *)( (byte *)to + field->offset );
+		if ( *fromF != *toF ) {
+			changeVector[ i>>3 ] |= 1 << ( i & 7 );
+			stuffChanged = true;
+		}
+	}
+	
+	if ( stuffChanged ) 
+	{
+		MSG_WriteBits( msg, to->number, GENTITYNUM_BITS );
+		MSG_WriteBits( msg, 0, 1 );			// not removed
+		MSG_WriteBits( msg, 1, 1 );			// we have a delta
+
+		// we need to write the entire delta
+		for ( i = 0 ; i + 8 <= numFields ; i += 8 ) {
+			MSG_WriteByte( msg, changeVector[i>>3] );
+		}
+		if ( numFields & 7 ) {
+			MSG_WriteBits( msg, changeVector[i>>3], numFields & 7 );
+		}
+
+		for ( i = 0, field = entityStateFields ; i < numFields ; i++, field++ ) {
+			fromF = (int *)( (byte *)from + field->offset );
+			toF = (int *)( (byte *)to + field->offset );
+
+			if ( *fromF == *toF ) {
+				continue;
+			}
+
+			MSG_WriteField(msg, toF, field);
+		}
+	}
+	else
+	{
+		// nothing at all changed
+		// write two bits for no change
+		MSG_WriteBits( msg, to->number, GENTITYNUM_BITS );
+		MSG_WriteBits( msg, 0, 1 );		// not removed
+		MSG_WriteBits( msg, 0, 1 );		// no delta
+	}
+
+	c = msg->cursize - c;
+}
+#endif
+
+
+extern serverStatic_t svs;
+void MSG_WriteEntity( msg_t *msg, struct entityState_s *to, int removeNum)
+{
+
+	if ( to == NULL ) {
+		MSG_WriteBits(msg, removeNum, GENTITYNUM_BITS);
+		MSG_WriteBits(msg, 1, 1); //removed
+		return;
+	} else {
+		MSG_WriteBits(msg, to->number, GENTITYNUM_BITS);
+		MSG_WriteBits(msg, 0, 1); //not removed
+	}
+	assert(( to - svs.snapshotEntities ) >= 0 && ( to - svs.snapshotEntities ) < 512);
+	MSG_WriteLong(msg, to - svs.snapshotEntities);
+}
+
+void MSG_ReadEntity( msg_t *msg, entityState_t *to)
+{
+	// check for a remove
+	if ( MSG_ReadBits( msg, 1 ) == 1 ) {
+		memset( to, 0, sizeof( *to ) );	
+		to->number = MAX_GENTITIES - 1;
+		return;
+	}
+
+	//No remove, read data
+	int index;
+	index = MSG_ReadLong(msg);
+	assert(index >= 0 && index < svs.numSnapshotEntities);
+	*to = svs.snapshotEntities[index];
+}
+
+/*
+==================
+MSG_ReadDeltaEntity
+
+The entity number has already been read from the message, which
+is how the from state is identified.
+
+If the delta removes the entity, entityState_t->number will be set to MAX_GENTITIES-1
+
+Can go from either a baseline or a previous packet_entity
+==================
+*/
+extern	cvar_t	*cl_shownet;
+
+#if 0 // Removed by BTO (VV)
+void MSG_ReadDeltaEntity( msg_t *msg, entityState_t *from, entityState_t *to, int number) 
+{
+	int			i;
+	const netField_t	*field;
+	int			*fromF, *toF;
+	int			print = 0;
+	int			startBit, endBit;
+	const int numFields = sizeof(entityStateFields)/sizeof(entityStateFields[0]);
+	byte		expandedVector[(numFields/8) + 1];
+
+	if ( number < 0 || number >= MAX_GENTITIES) {
+		Com_Error( ERR_DROP, "Bad delta entity number: %i", number );
+	}
+
+	if ( msg->bit == 0 ) {
+		startBit = msg->readcount * 8 - GENTITYNUM_BITS;
+	} else {
+		startBit = ( msg->readcount - 1 ) * 8 + msg->bit - GENTITYNUM_BITS;
+	}
+
+	// check for a remove
+	if ( MSG_ReadBits( msg, 1 ) == 1 ) {
+		memset( to, 0, sizeof( *to ) );	
+		to->number = MAX_GENTITIES - 1;
+		if ( cl_shownet->integer >= 2 || cl_shownet->integer == -1 ) {
+			Com_Printf( "%3i: #%-3i remove\n", msg->readcount, number );
+		}
+		return;
+	}
+
+	// check for no delta
+	if ( MSG_ReadBits( msg, 1 ) != 0 )
+	{  
+		const int numFields = sizeof(entityStateFields)/sizeof(entityStateFields[0]);
+
+		// shownet 2/3 will interleave with other printed info, -1 will
+		// just print the delta records`
+		if ( cl_shownet->integer >= 2 || cl_shownet->integer == -1 ) {
+			print = 1;
+			Com_Printf( "%3i: #%-3i ", msg->readcount, to->number );
+		} else {
+			print = 0;
+		}
+
+		// we need to write the entire delta
+		for ( i = 0 ; i + 8 <= numFields ; i += 8 ) {
+			expandedVector[i>>3] = MSG_ReadByte( msg );
+		}
+		if ( numFields & 7 ) {
+			expandedVector[i>>3] = MSG_ReadBits( msg, numFields & 7 );
+		}
+
+		to->number = number;
+
+		for ( i = 0, field = entityStateFields ; i < numFields ; i++, field++ ) {
+			fromF = (int *)( (byte *)from + field->offset );
+			toF = (int *)( (byte *)to + field->offset );
+
+			if ( ! ( expandedVector[ i >> 3 ] & ( 1 << ( i & 7 ) ) ) ) {
+				// no change
+				*toF = *fromF;
+			} else {
+				MSG_ReadField(msg, toF, field, print);
+			}
+		}
+	}
+	else
+	{
+		memcpy(to, from,sizeof(entityState_t));
+		to->number = number;
+ 	}
+	if ( print ) {
+		if ( msg->bit == 0 ) {
+			endBit = msg->readcount * 8 - GENTITYNUM_BITS;
+		} else {
+			endBit = ( msg->readcount - 1 ) * 8 + msg->bit - GENTITYNUM_BITS;
+		}
+		Com_Printf( " (%i bits)\n", endBit - startBit  );
+	}
+}
+#endif
+
+/*
+Ghoul2 Insert End
+*/
+
+/*
+============================================================================
+
+plyer_state_t communication
+
+============================================================================
+*/
+
+// using the stringizing operator to save typing...
+#define	PSF(x) #x,(int)&((playerState_t*)0)->x
+
+static const netField_t	playerStateFields[] = 
+{
+{ PSF(commandTime), 32 },
+{ PSF(pm_type), 8 },
+{ PSF(bobCycle), 8 },
+{ PSF(pm_flags), 32 },
+{ PSF(pm_time), -16 },
+{ PSF(origin[0]), 0 },
+{ PSF(origin[1]), 0 },
+{ PSF(origin[2]), 0 },
+{ PSF(velocity[0]), 0 },
+{ PSF(velocity[1]), 0 },
+{ PSF(velocity[2]), 0 },
+{ PSF(weaponTime), -16 },
+{ PSF(weaponChargeTime), 32 }, //? really need 32 bits??
+{ PSF(gravity), 16 },
+{ PSF(leanofs), -8 },
+{ PSF(friction), 16 },
+{ PSF(speed), 16 },
+{ PSF(delta_angles[0]), 16 },
+{ PSF(delta_angles[1]), 16 },
+{ PSF(delta_angles[2]), 16 },
+{ PSF(groundEntityNum), GENTITYNUM_BITS },
+//{ PSF(animationTimer), 16 },
+{ PSF(legsAnim), 16 },
+{ PSF(torsoAnim), 16 },
+{ PSF(movementDir), 4 },
+{ PSF(eFlags), 32 },
+{ PSF(eventSequence), 16 },
+{ PSF(events[0]), 8 },
+{ PSF(events[1]), 8 },
+{ PSF(eventParms[0]), -9 },
+{ PSF(eventParms[1]), -9 },
+{ PSF(externalEvent), 8 },
+{ PSF(externalEventParm), 8 },
+{ PSF(clientNum), 32 },
+{ PSF(weapon), 5 },
+{ PSF(weaponstate),	  4 },
+{ PSF(batteryCharge),	16 },
+{ PSF(viewangles[0]), 0 },
+{ PSF(viewangles[1]), 0 },
+{ PSF(viewangles[2]), 0 },
+{ PSF(viewheight), -8 },
+{ PSF(damageEvent), 8 },
+{ PSF(damageYaw), 8 },
+{ PSF(damagePitch), -8 },
+{ PSF(damageCount), 8 },
+//{ PSF(saberColor), 8 },
+//{ PSF(saberActive), 8 },
+//{ PSF(saberLength), 32 },
+//{ PSF(saberLengthMax), 32 },
+{ PSF(forcePowersActive), 32},
+{ PSF(saberInFlight), 8 },
+
+/*{ PSF(vehicleIndex), 32 },			// WOAH, what do we do with this stuff???
+{ PSF(vehicleArmor), 32 },
+{ PSF(vehicleAngles[0]), 0 },
+{ PSF(vehicleAngles[1]), 0 },
+{ PSF(vehicleAngles[2]), 0 },*/
+
+{ PSF(viewEntity), 32 },
+{ PSF(serverViewOrg[0]), 0 },
+{ PSF(serverViewOrg[1]), 0 },
+{ PSF(serverViewOrg[2]), 0 },
+};
+
+/*
+=============
+MSG_WriteDeltaPlayerstate
+
+=============
+*/
+void MSG_WriteDeltaPlayerstate( msg_t *msg, struct playerState_s *from, struct playerState_s *to ) {
+	int				i;
+	playerState_t	dummy;
+	int				statsbits;
+	int				persistantbits;
+	int				ammobits;
+	int				powerupbits;
+	int				numFields;
+	int				c;
+	const netField_t	*field;
+	int				*fromF, *toF;
+
+	if (!from) {
+		from = &dummy;
+		memset (&dummy, 0, sizeof(dummy));
+	}
+
+	c = msg->cursize;
+
+	numFields = sizeof( playerStateFields ) / sizeof( playerStateFields[0] );
+	for ( i = 0, field = playerStateFields ; i < numFields ; i++, field++ ) {
+		fromF = (int *)( (byte *)from + field->offset );
+		toF = (int *)( (byte *)to + field->offset );
+
+		if ( *fromF == *toF ) {
+			MSG_WriteBits( msg, 0, 1 );	// no change
+			continue;
+		}
+
+		MSG_WriteBits( msg, 1, 1 );	// changed
+		MSG_WriteField (msg, toF, field);
+	}
+	c = msg->cursize - c;
+
+
+	//
+	// send the arrays
+	//
+	statsbits = 0;
+	for (i=0 ; i<MAX_STATS ; i++) {
+		if (to->stats[i] != from->stats[i]) {
+			statsbits |= 1<<i;
+		}
+	}
+	if ( statsbits ) {
+		MSG_WriteBits( msg, 1, 1 );	// changed
+		MSG_WriteShort( msg, statsbits );
+		for (i=0 ; i<MAX_STATS ; i++)
+			if (statsbits & (1<<i) )
+				MSG_WriteBits(msg, to->stats[i], 32);
+	} else {
+		MSG_WriteBits( msg, 0, 1 );	// no change
+	}
+
+
+	persistantbits = 0;
+	for (i=0 ; i<MAX_PERSISTANT ; i++) {
+		if (to->persistant[i] != from->persistant[i]) {
+			persistantbits |= 1<<i;
+		}
+	}
+	if ( persistantbits ) {
+		MSG_WriteBits( msg, 1, 1 );	// changed
+		MSG_WriteShort( msg, persistantbits );
+		for (i=0 ; i<MAX_PERSISTANT ; i++)
+			if (persistantbits & (1<<i) )
+				MSG_WriteSShort (msg, to->persistant[i]);
+	} else {
+		MSG_WriteBits( msg, 0, 1 );	// no change
+	}
+
+
+	ammobits = 0;
+	for (i=0 ; i<MAX_AMMO ; i++) {
+		if (to->ammo[i] != from->ammo[i]) {
+			ammobits |= 1<<i;
+		}
+	}
+	if ( ammobits ) {
+		MSG_WriteBits( msg, 1, 1 );	// changed
+		MSG_WriteShort( msg, ammobits );
+		for (i=0 ; i<MAX_AMMO ; i++)
+			if (ammobits & (1<<i) )
+				MSG_WriteSShort (msg, to->ammo[i]);
+	} else {
+		MSG_WriteBits( msg, 0, 1 );	// no change
+	}
+
+	powerupbits = 0;
+	for (i=0 ; i<MAX_POWERUPS ; i++) {
+		if (to->powerups[i] != from->powerups[i]) {
+			powerupbits |= 1<<i;
+		}
+	}
+	if ( powerupbits ) {
+		MSG_WriteBits( msg, 1, 1 );	// changed
+		MSG_WriteShort( msg, powerupbits );
+		for (i=0 ; i<MAX_POWERUPS ; i++)
+			if (powerupbits & (1<<i) )
+				MSG_WriteLong( msg, to->powerups[i] );
+	} else {
+		MSG_WriteBits( msg, 0, 1 );	// no change
+	}
+
+
+	statsbits = 0;
+	for (i=0 ; i<MAX_INVENTORY ; i++) 
+	{
+		if (to->inventory[i] != from->inventory[i]) 
+		{
+			statsbits |= 1<<i;
+		}
+	}
+	if ( statsbits ) 
+	{
+		MSG_WriteBits( msg, 1, 1 );	// changed
+		MSG_WriteShort( msg, statsbits );
+		for (i=0 ; i<MAX_INVENTORY ; i++)
+		{
+			if (statsbits & (1<<i) )
+			{
+				MSG_WriteShort (msg, to->inventory[i]);
+			}
+		}
+	} 
+	else 
+	{
+		MSG_WriteBits( msg, 0, 1 );	// no change
+	}
+}
+
+
+/*
+===================
+MSG_ReadDeltaPlayerstate
+===================
+*/
+void MSG_ReadDeltaPlayerstate (msg_t *msg, playerState_t *from, playerState_t *to ) {
+	int			i;
+	int			bits;
+	const netField_t	*field;
+	int			numFields;
+	int			startBit, endBit;
+	int			print;
+	int			*fromF, *toF;
+	playerState_t	dummy;
+
+	if ( !from ) {
+		from = &dummy;
+		memset( &dummy, 0, sizeof( dummy ) );
+	}
+	*to = *from;
+
+	if ( msg->bit == 0 ) {
+		startBit = msg->readcount * 8 - GENTITYNUM_BITS;
+	} else {
+		startBit = ( msg->readcount - 1 ) * 8 + msg->bit - GENTITYNUM_BITS;
+	}
+
+	// shownet 2/3 will interleave with other printed info, -2 will
+	// just print the delta records
+	if ( cl_shownet->integer >= 2 || cl_shownet->integer == -2 ) {
+		print = 1;
+		Com_Printf( "%3i: playerstate ", msg->readcount );
+	} else {
+		print = 0;
+	}
+
+	numFields = sizeof( playerStateFields ) / sizeof( playerStateFields[0] );
+	for ( i = 0, field = playerStateFields ; i < numFields ; i++, field++ ) {
+		fromF = (int *)( (byte *)from + field->offset );
+		toF = (int *)( (byte *)to + field->offset );
+
+		if ( ! MSG_ReadBits( msg, 1 ) ) {
+			// no change
+			*toF = *fromF;
+		} else {
+			MSG_ReadField( msg, toF, field, print);
+		}
+	}
+
+	// read the arrays
+
+	// parse stats
+	if ( MSG_ReadBits( msg, 1 ) ) {
+		LOG("PS_STATS");
+		bits = MSG_ReadShort (msg);
+		for (i=0 ; i<MAX_STATS ; i++) {
+			if (bits & (1<<i) ) {
+				to->stats[i] = MSG_ReadBits(msg,32);
+			}
+		}
+	}
+
+	// parse persistant stats
+	if ( MSG_ReadBits( msg, 1 ) ) {
+		LOG("PS_PERSISTANT");
+		bits = MSG_ReadShort (msg);
+		for (i=0 ; i<MAX_PERSISTANT ; i++) {
+			if (bits & (1<<i) ) {
+				to->persistant[i] = MSG_ReadSShort(msg);
+			}
+		}
+	}
+
+	// parse ammo
+	if ( MSG_ReadBits( msg, 1 ) ) {
+		LOG("PS_AMMO");
+		bits = MSG_ReadShort (msg);
+		for (i=0 ; i<MAX_AMMO ; i++) {
+			if (bits & (1<<i) ) {
+				to->ammo[i] = MSG_ReadSShort(msg);
+			}
+		}
+	}
+
+	// parse powerups
+	if ( MSG_ReadBits( msg, 1 ) ) {
+		LOG("PS_POWERUPS");
+		bits = MSG_ReadShort (msg);
+		for (i=0 ; i<MAX_POWERUPS ; i++) {
+			if (bits & (1<<i) ) {
+				to->powerups[i] = MSG_ReadLong(msg);
+			}
+		}
+	}
+
+	// parse inventory
+	if ( MSG_ReadBits( msg, 1 ) ) {
+		LOG("PS_INVENTORY");
+		bits = MSG_ReadShort (msg);
+		for (i=0 ; i<MAX_INVENTORY ; i++) {
+			if (bits & (1<<i) ) {
+				to->inventory[i] = MSG_ReadShort(msg);
+			}
+		}
+	}
+
+	if ( print ) {
+		if ( msg->bit == 0 ) {
+			endBit = msg->readcount * 8 - GENTITYNUM_BITS;
+		} else {
+			endBit = ( msg->readcount - 1 ) * 8 + msg->bit - GENTITYNUM_BITS;
+		}
+		Com_Printf( " (%i bits)\n", endBit - startBit  );
+	}
+}
+
+
+//===========================================================================
diff --git a/code/qcommon/net_chan.cpp b/code/qcommon/net_chan.cpp
new file mode 100644
index 0000000..a2ea2cf
--- /dev/null
+++ b/code/qcommon/net_chan.cpp
@@ -0,0 +1,566 @@
+
+#include "../game/q_shared.h"
+#include "qcommon.h"
+
+/*
+
+packet header
+-------------
+4	outgoing sequence.  high bit will be set if this is a fragmented message
+4	acknowledge sequence
+[2	qport (only for client to server)]
+[2	fragment start byte]
+[2	fragment length. if < FRAGMENT_SIZE, this is the last fragment]
+
+if the sequence number is -1, the packet should be handled as an out-of-band
+message instead of as part of a netcon.
+
+All fragments will have the same sequence numbers.
+
+The qport field is a workaround for bad address translating routers that
+sometimes remap the client's source port on a packet during gameplay.
+
+If the base part of the net address matches and the qport matches, then the
+channel matches even if the IP port differs.  The IP port should be updated
+to the new value before sending out any replies.
+
+*/
+
+
+#define	MAX_PACKETLEN			(MAX_MSGLEN)	//(1400)		// max size of a network packet
+#define MAX_LOOPDATA            16 * 1024
+
+#if (MAX_PACKETLEN > MAX_MSGLEN)
+#error MAX_PACKETLEN must be <= MAX_MSGLEN
+#endif
+#if (MAX_LOOPDATA > MAX_MSGLEN)
+#error MAX_LOOPDATA must be <= MAX_MSGLEN
+#endif
+
+#define	FRAGMENT_SIZE			(MAX_PACKETLEN - 100)
+#define	PACKET_HEADER			10			// two ints and a short
+
+#define	FRAGMENT_BIT	(1<<31)
+
+cvar_t		*showpackets;
+cvar_t		*showdrop;
+cvar_t		*qport;
+
+static char *netsrcString[2] = {
+	"client",
+	"server"
+};
+
+typedef struct {
+	char loopData[MAX_LOOPDATA];
+	int			get, send;
+} loopback_t;
+
+static loopback_t	*loopbacks = NULL;
+
+
+/*
+===============
+Netchan_Init
+
+===============
+*/
+void Netchan_Init( int port ) {
+	if (!loopbacks)
+	{
+		loopbacks = (loopback_t*) Z_Malloc(sizeof(loopback_t) * 2, TAG_NEWDEL, qtrue);
+	}
+	
+	port &= 0xffff;
+	showpackets = Cvar_Get ("showpackets", "0", CVAR_TEMP );
+	showdrop = Cvar_Get ("showdrop", "0", CVAR_TEMP );
+	qport = Cvar_Get ("qport", va("%i", port), CVAR_INIT );
+}
+
+void Netchan_Shutdown()
+{
+	if (loopbacks)
+	{
+		Z_Free(loopbacks);
+		loopbacks = 0;
+	}
+}
+
+/*
+==============
+Netchan_Setup
+
+called to open a channel to a remote system
+==============
+*/
+void Netchan_Setup( netsrc_t sock, netchan_t *chan, netadr_t adr, int qport ) {
+	memset (chan, 0, sizeof(*chan));
+	
+	chan->sock = sock;
+	chan->remoteAddress = adr;
+	chan->qport = qport;
+	chan->incomingSequence = 0;
+	chan->outgoingSequence = 1;
+}
+
+/*
+===============
+Netchan_Transmit
+
+Sends a message to a connection, fragmenting if necessary
+A 0 length will still generate a packet.
+================
+*/
+void Netchan_Transmit( netchan_t *chan, int length, const byte *data ) {
+	msg_t		send;
+	byte		send_buf[MAX_PACKETLEN];
+	int			fragmentStart, fragmentLength;
+
+	fragmentStart = 0;		// stop warning message
+	fragmentLength = 0;
+
+	// fragment large reliable messages
+	if ( length >= FRAGMENT_SIZE ) {
+		fragmentStart = 0;
+		do {
+			// write the packet header
+			MSG_Init (&send, send_buf, sizeof(send_buf));
+
+			MSG_WriteLong( &send, chan->outgoingSequence | FRAGMENT_BIT );
+			MSG_WriteLong( &send, chan->incomingSequence );
+
+			// send the qport if we are a client
+			if ( chan->sock == NS_CLIENT ) {
+				MSG_WriteShort( &send, qport->integer );
+			}
+
+			// copy the reliable message to the packet first
+			fragmentLength = FRAGMENT_SIZE;
+			if ( fragmentStart  + fragmentLength > length ) {
+				fragmentLength = length - fragmentStart;
+			}
+
+			MSG_WriteShort( &send, fragmentStart );
+			MSG_WriteShort( &send, fragmentLength );
+			MSG_WriteData( &send, data + fragmentStart, fragmentLength );
+
+			// send the datagram
+			NET_SendPacket( chan->sock, send.cursize, send.data, chan->remoteAddress );
+
+			if ( showpackets->integer ) {
+				Com_Printf ("%s send %4i : s=%i ack=%i fragment=%i,%i\n"
+					, netsrcString[ chan->sock ]
+					, send.cursize
+					, chan->outgoingSequence - 1
+					, chan->incomingSequence
+					, fragmentStart, fragmentLength);
+			}
+
+			fragmentStart += fragmentLength;
+			// this exit condition is a little tricky, because a packet
+			// that is exactly the fragment length still needs to send
+			// a second packet of zero length so that the other side
+			// can tell there aren't more to follow
+		} while ( fragmentStart != length || fragmentLength == FRAGMENT_SIZE );
+
+		chan->outgoingSequence++;
+		return;
+	}
+
+	// write the packet header
+	MSG_Init (&send, send_buf, sizeof(send_buf));
+
+	MSG_WriteLong( &send, chan->outgoingSequence );
+	MSG_WriteLong( &send, chan->incomingSequence );
+	chan->outgoingSequence++;
+
+	// send the qport if we are a client
+	if ( chan->sock == NS_CLIENT ) {
+		MSG_WriteShort( &send, qport->integer );
+	}
+
+	MSG_WriteData( &send, data, length );
+
+	// send the datagram
+	NET_SendPacket( chan->sock, send.cursize, send.data, chan->remoteAddress );
+
+	if ( showpackets->integer ) {
+		Com_Printf( "%s send %4i : s=%i ack=%i\n"
+			, netsrcString[ chan->sock ]
+			, send.cursize
+			, chan->outgoingSequence - 1
+			, chan->incomingSequence );
+	}
+}
+
+/*
+=================
+Netchan_Process
+
+Returns qfalse if the message should not be processed due to being
+out of order or a fragment.
+
+Msg must be large enough to hold MAX_MSGLEN, because if this is the
+final fragment of a multi-part message, the entire thing will be
+copied out.
+=================
+*/
+qboolean Netchan_Process( netchan_t *chan, msg_t *msg ) {
+	int			sequence, sequence_ack;
+	int			qport;
+	int			fragmentStart, fragmentLength;
+	qboolean	fragmented;
+
+	// get sequence numbers		
+	MSG_BeginReading( msg );
+	sequence = MSG_ReadLong( msg );
+	sequence_ack = MSG_ReadLong( msg );
+
+	// check for fragment information
+	if ( sequence & FRAGMENT_BIT ) {
+		sequence &= ~FRAGMENT_BIT;
+		fragmented = qtrue;
+	} else {
+		fragmented = qfalse;
+	}
+
+	// read the qport if we are a server
+	if ( chan->sock == NS_SERVER ) {
+		qport = MSG_ReadShort( msg );
+	}
+
+	// read the fragment information
+	if ( fragmented ) {
+		fragmentStart = MSG_ReadShort( msg );
+		fragmentLength = MSG_ReadShort( msg );
+	} else {
+		fragmentStart = 0;		// stop warning message
+		fragmentLength = 0;
+	}
+
+	if ( showpackets->integer ) {
+		if ( fragmented ) {
+			Com_Printf( "%s recv %4i : s=%i ack=%i fragment=%i,%i\n"
+				, netsrcString[ chan->sock ]
+				, msg->cursize
+				, sequence
+				, sequence_ack
+				, fragmentStart, fragmentLength );
+		} else {
+			Com_Printf( "%s recv %4i : s=%i ack=%i\n"
+				, netsrcString[ chan->sock ]
+				, msg->cursize
+				, sequence
+				, sequence_ack );
+		}
+	}
+
+	//
+	// discard out of order or duplicated packets
+	//
+	if ( sequence <= chan->incomingSequence ) {
+		if ( showdrop->integer || showpackets->integer ) {
+			Com_Printf( "%s:Out of order packet %i at %i\n"
+				, NET_AdrToString( chan->remoteAddress )
+				,  sequence
+				, chan->incomingSequence );
+		}
+		return qfalse;
+	}
+
+	//
+	// dropped packets don't keep the message from being used
+	//
+	chan->dropped = sequence - (chan->incomingSequence+1);
+	if ( chan->dropped > 0 ) {
+		if ( showdrop->integer || showpackets->integer ) {
+			Com_Printf( "%s:Dropped %i packets at %i\n"
+			, NET_AdrToString( chan->remoteAddress )
+			, chan->dropped
+			, sequence );
+		}
+	}
+	
+
+	//
+	// if this is the final framgent of a reliable message,
+	// bump incoming_reliable_sequence 
+	//
+	if ( fragmented ) {
+		// make sure we 
+		if ( sequence != chan->fragmentSequence ) {
+			chan->fragmentSequence = sequence;
+			chan->fragmentLength = 0;
+		}
+
+		// if we missed a fragment, dump the message
+		if ( fragmentStart != chan->fragmentLength ) {
+			if ( showdrop->integer || showpackets->integer ) {
+				Com_Printf( "%s:Dropped a message fragment\n"
+				, NET_AdrToString( chan->remoteAddress )
+				, sequence);
+			}
+			// we can still keep the part that we have so far,
+			// so we don't need to clear chan->fragmentLength
+			return qfalse;
+		}
+
+		// copy the fragment to the fragment buffer
+		if ( fragmentLength < 0 || msg->readcount + fragmentLength > msg->cursize ||
+			chan->fragmentLength + fragmentLength > sizeof( chan->fragmentBuffer ) ) {
+			if ( showdrop->integer || showpackets->integer ) {
+				Com_Printf ("%s:illegal fragment length\n"
+				, NET_AdrToString (chan->remoteAddress ) );
+			}
+			return qfalse;
+		}
+
+		memcpy( chan->fragmentBuffer + chan->fragmentLength, 
+			msg->data + msg->readcount, fragmentLength );
+
+		chan->fragmentLength += fragmentLength;
+
+		// if this wasn't the last fragment, don't process anything
+		if ( fragmentLength == FRAGMENT_SIZE ) {
+			return qfalse;
+		}
+
+		if ( chan->fragmentLength > msg->maxsize ) {
+			Com_Printf( "%s:fragmentLength %i > msg->maxsize\n"
+				, NET_AdrToString (chan->remoteAddress ),
+				chan->fragmentLength );
+			return qfalse;
+		}
+
+		// copy the full message over the partial fragment
+
+		// make sure the sequence number is still there
+		*(int *)msg->data = LittleLong( sequence );
+
+		memcpy( msg->data + 4, chan->fragmentBuffer, chan->fragmentLength );
+		msg->cursize = chan->fragmentLength + 4;
+		chan->fragmentLength = 0;
+		msg->readcount = 4;	// past the sequence number
+
+		return qtrue;
+	}
+
+	//
+	// the message can now be read from the current message pointer
+	//
+	chan->incomingSequence = sequence;
+	chan->incomingAcknowledged = sequence_ack;
+
+	return qtrue;
+}
+
+
+//==============================================================================
+
+/*
+===================
+NET_CompareBaseAdr
+
+Compares without the port
+===================
+*/
+qboolean	NET_CompareBaseAdr (netadr_t a, netadr_t b)
+{
+	if (a.type != b.type)
+		return qfalse;
+
+	if (a.type == NA_LOOPBACK)
+		return qtrue;
+
+	Com_Printf ("NET_CompareBaseAdr: bad address type\n");
+	return qfalse;
+}
+
+const char	*NET_AdrToString (netadr_t a)
+{
+	static	char	s[64];
+
+	if (a.type == NA_LOOPBACK) {
+		Com_sprintf (s, sizeof(s), "loopback");
+	}
+
+	return s;
+}
+
+
+qboolean	NET_CompareAdr (netadr_t a, netadr_t b)
+{
+	if (a.type != b.type)
+		return qfalse;
+
+	if (a.type == NA_LOOPBACK)
+		return qtrue;
+
+	Com_Printf ("NET_CompareAdr: bad address type\n");
+	return qfalse;
+}
+
+
+qboolean	NET_IsLocalAddress( netadr_t adr ) {
+	return adr.type == NA_LOOPBACK;
+}
+
+
+
+/*
+=============================================================================
+
+LOOPBACK BUFFERS FOR LOCAL PLAYER
+
+=============================================================================
+*/
+
+qboolean	NET_GetLoopPacket (netsrc_t sock, netadr_t *net_from, msg_t *net_message)
+{
+	int		i;
+	loopback_t	*loop;
+
+	loop = &loopbacks[sock];
+
+	//If read and write positions are the same, nothing left to read.
+	if (loop->get == loop->send)
+		return qfalse;
+
+	//Get read position.  Wrap if too close to end.
+	i = loop->get;
+	if(i > MAX_LOOPDATA - 4) {
+		i = 0;
+	}
+
+	//Get length of packet.
+	int length = *(int*)(loop->loopData + i);
+	i += 4;
+
+	//See if entire packet is at end of buffer or part is at the beginning.
+	if(i + length <= MAX_LOOPDATA) {
+		//Everything fits, full copy.
+		memcpy (net_message->data, loop->loopData + i, length);
+		net_message->cursize = length;
+		i += length;
+		loop->get = i;
+	} else {
+		//Doesn't all fit, partial copy
+		const int copyToEnd = MAX_LOOPDATA - i;
+		memcpy (net_message->data, loop->loopData + i, copyToEnd);
+		memcpy ((char*)net_message->data + copyToEnd, 
+				loop->loopData, length - copyToEnd);
+		net_message->cursize = length;
+		loop->get = length - copyToEnd;
+	}
+
+	memset (net_from, 0, sizeof(*net_from));
+	net_from->type = NA_LOOPBACK;
+
+	return qtrue;
+}
+
+
+void NET_SendLoopPacket (netsrc_t sock, int length, const void *data, netadr_t to)
+{
+	int		i;
+	loopback_t	*loop;
+
+	loop = &loopbacks[sock^1];
+
+	//Make sure there is enough free space in the buffer.
+	int freeSpace;
+	if(loop->send >= loop->get) {
+		freeSpace = MAX_LOOPDATA - (loop->send - loop->get);
+	} else {
+		freeSpace = loop->get - loop->send;
+	}
+
+	assert(freeSpace > length);
+
+	//Get write position.  Wrap around if too close to end.
+	i = loop->send;
+	if(i > MAX_LOOPDATA - 4) {
+		i = 0;
+	}
+
+	//Write length of packet.
+	*(int*)(loop->loopData + i) = length;
+	i += 4;
+
+	//See if the whole packet will fit on the end of the buffer or if we
+	//need to write part of it back at the beginning.
+	if(i + length <= MAX_LOOPDATA) {
+		//Everything fits, full copy.
+		memcpy (loop->loopData + i, data, length);
+		i += length;
+		loop->send = i;
+	} else {
+		//Doesn't all fit, partial copy
+		int copyToEnd = MAX_LOOPDATA - i;
+		memcpy(loop->loopData + i, data, copyToEnd);
+		memcpy(loop->loopData, (char*)data + copyToEnd, length - copyToEnd); 
+		loop->send = length - copyToEnd;
+	}
+}
+
+//=============================================================================
+
+
+void NET_SendPacket( netsrc_t sock, int length, const void *data, netadr_t to ) {
+
+	// sequenced packets are shown in netchan, so just show oob
+	if ( showpackets->integer && *(int *)data == -1 )	{
+		Com_Printf ("send packet %4i\n", length);
+	}
+
+	if ( to.type == NA_LOOPBACK ) {
+		NET_SendLoopPacket (sock, length, data, to);
+		return;
+	}
+}
+
+/*
+===============
+NET_OutOfBandPrint
+
+Sends a text message in an out-of-band datagram
+================
+*/
+void QDECL NET_OutOfBandPrint( netsrc_t sock, netadr_t adr, const char *format, ... ) {
+	va_list		argptr;
+	char		string[MAX_MSGLEN];
+
+	// set the header
+	string[0] = (char) 0xff;
+	string[1] = (char) 0xff;
+	string[2] = (char) 0xff;
+	string[3] = (char) 0xff;
+
+	va_start( argptr, format );
+	vsprintf( string+4, format, argptr );
+	va_end( argptr );
+
+	// send the datagram
+	NET_SendPacket( sock, strlen( string ), string, adr );
+}
+
+
+
+/*
+=============
+NET_StringToAdr
+
+Traps "localhost" for loopback, passes everything else to system
+=============
+*/
+qboolean	NET_StringToAdr( const char *s, netadr_t *a ) {
+	if (!strcmp (s, "localhost")) {
+		memset (a, 0, sizeof(*a));
+		a->type = NA_LOOPBACK;
+		return qtrue;
+	}
+
+	a->type = NA_BAD;
+	return qfalse;
+}
+
diff --git a/code/qcommon/platform.h b/code/qcommon/platform.h
new file mode 100644
index 0000000..32057ff
--- /dev/null
+++ b/code/qcommon/platform.h
@@ -0,0 +1,17 @@
+// Simple header file to dispatch to the relevant platform API headers
+#ifndef _PLATFORM_H
+#define _PLATFORM_H
+
+#if defined(_XBOX)
+#include <xtl.h>
+#endif
+
+#ifdef _WIN32
+#define WIN32_LEAN_AND_MEAN 1
+#endif
+
+#if defined(_WINDOWS)
+#include <windows.h>
+#endif
+
+#endif
diff --git a/code/qcommon/qcommon.h b/code/qcommon/qcommon.h
new file mode 100644
index 0000000..ec27b67
--- /dev/null
+++ b/code/qcommon/qcommon.h
@@ -0,0 +1,850 @@
+// qcommon.h -- definitions common between client and server, but not game.or ref modules
+#ifndef __QCOMMON_H__
+#define __QCOMMON_H__
+
+#include "stringed_ingame.h"
+#include "../qcommon/cm_public.h"
+
+
+// some zone mem debugging stuff
+#ifndef FINAL_BUILD
+	#ifdef _DEBUG
+	//
+	// both of these should be REM'd unless you specifically need them...
+	//
+	//#define DEBUG_ZONE_ALLOCS			// adds __FILE__ and __LINE__ info to zone blocks, to see who's leaking
+	//#define DETAILED_ZONE_DEBUG_CODE	// this slows things down a LOT, and is only for tracking nasty double-freeing Z_Malloc bugs
+	#endif
+#endif
+
+
+//============================================================================
+
+//
+// msg.c
+//
+typedef struct {
+	qboolean	allowoverflow;	// if false, do a Com_Error
+	qboolean	overflowed;		// set to true if the buffer size failed (with allowoverflow set)
+	byte	*data;
+	int		maxsize;
+	int		cursize;
+	int		readcount;
+	int		bit;				// for bitwise reads and writes
+} msg_t;
+
+void MSG_Init (msg_t *buf, byte *data, int length);
+void MSG_Clear (msg_t *buf);
+void *MSG_GetSpace (msg_t *buf, int length);
+void MSG_WriteData (msg_t *buf, const void *data, int length);
+
+
+struct usercmd_s;
+struct entityState_s;
+struct playerState_s;
+
+void MSG_WriteBits( msg_t *msg, int value, int bits );
+
+void MSG_WriteByte (msg_t *sb, int c);
+void MSG_WriteShort (msg_t *sb, int c);
+void MSG_WriteLong (msg_t *sb, int c);
+void MSG_WriteString (msg_t *sb, const char *s);
+
+void	MSG_BeginReading (msg_t *sb);
+
+int		MSG_ReadBits( msg_t *msg, int bits );
+
+int		MSG_ReadByte (msg_t *sb);
+int		MSG_ReadShort (msg_t *sb);
+int		MSG_ReadLong (msg_t *sb);
+char	*MSG_ReadString (msg_t *sb);
+char	*MSG_ReadStringLine (msg_t *sb);
+void	MSG_ReadData (msg_t *sb, void *buffer, int size);
+
+
+void MSG_WriteDeltaUsercmd( msg_t *msg, struct usercmd_s *from, struct usercmd_s *to );
+void MSG_ReadDeltaUsercmd( msg_t *msg, struct usercmd_s *from, struct usercmd_s *to );
+
+void MSG_WriteDeltaEntity( msg_t *msg, struct entityState_s *from, struct entityState_s *to
+						   , qboolean force );
+void MSG_ReadDeltaEntity( msg_t *msg, entityState_t *from, entityState_t *to, 
+						 int number );
+void MSG_ReadEntity( msg_t *msg, entityState_t *to);
+void MSG_WriteEntity( msg_t *msg, entityState_t *to, int removeNum);
+
+void MSG_WriteDeltaPlayerstate( msg_t *msg, struct playerState_s *from, struct playerState_s *to );
+void MSG_ReadDeltaPlayerstate( msg_t *msg, struct playerState_s *from, struct playerState_s *to );
+
+
+//============================================================================
+
+#ifdef _M_IX86
+//
+// optimised stuff for Intel, since most of our data is in that format anyway...
+//
+extern	short	BigShort (short l);
+extern	int		BigLong (int l);
+extern	float	BigFloat (float l);
+#define LittleShort(l) l
+#define LittleLong(l) l
+#define LittleFloat(l) l
+//
+#else
+//
+// standard smart-swap code...
+//
+extern	short	BigShort (short l);
+extern	short	LittleShort (short l);
+extern	int		BigLong (int l);
+extern	int		LittleLong (int l);
+extern	float	BigFloat (float l);
+extern	float	LittleFloat (float l);
+//
+#endif
+
+
+/*
+==============================================================
+
+NET
+
+==============================================================
+*/
+
+#ifdef _XBOX
+#define PACKET_BACKUP	2
+#else
+#define	PACKET_BACKUP	16	// number of old messages that must be kept on client and
+#endif						// server for delta comrpession and ping estimation
+#define	PACKET_MASK		(PACKET_BACKUP-1)
+
+#define	MAX_PACKET_USERCMDS		32		// max number of usercmd_t in a packet
+
+#define	PORT_ANY			-1
+
+#define	MAX_RELIABLE_COMMANDS	64			// max string commands buffered for restransmit
+
+typedef enum {
+	NA_BAD,					// an address lookup failed
+	NA_LOOPBACK,
+} netadrtype_t;
+
+typedef enum {
+	NS_CLIENT,
+	NS_SERVER
+} netsrc_t;
+
+typedef struct {
+	netadrtype_t	type;
+
+	unsigned short	port;
+} netadr_t;
+
+void		NET_SendPacket (netsrc_t sock, int length, const void *data, netadr_t to);
+void		NET_OutOfBandPrint( netsrc_t net_socket, netadr_t adr, const char *format, ...);
+
+qboolean	NET_CompareAdr (netadr_t a, netadr_t b);
+qboolean	NET_CompareBaseAdr (netadr_t a, netadr_t b);
+qboolean	NET_IsLocalAddress (netadr_t adr);
+qboolean	NET_IsLANAddress (netadr_t adr);
+const char	*NET_AdrToString (netadr_t a);
+qboolean	NET_StringToAdr ( const char *s, netadr_t *a);
+qboolean	NET_GetLoopPacket (netsrc_t sock, netadr_t *net_from, msg_t *net_message);
+
+
+#define	MAX_MSGLEN				(1*17408)		// max length of a message, which may
+//#define	MAX_MSGLEN				(3*16384)		// max length of a message, which may
+											// be fragmented into multiple packets
+
+
+/*
+Netchan handles packet fragmentation and out of order / duplicate suppression
+*/
+
+typedef struct {
+	netsrc_t	sock;
+
+	int			dropped;			// between last packet and previous
+
+	netadr_t	remoteAddress;
+	int			qport;				// qport value to write when transmitting
+
+	// sequencing variables
+	int			incomingSequence;
+	int			incomingAcknowledged;
+
+	int			outgoingSequence;
+
+	// incoming fragment assembly buffer
+	int			fragmentSequence;
+	int			fragmentLength;	
+	byte		fragmentBuffer[MAX_MSGLEN];
+} netchan_t;
+
+void Netchan_Init( int qport );
+void Netchan_Setup( netsrc_t sock, netchan_t *chan, netadr_t adr, int qport );
+
+void Netchan_Transmit( netchan_t *chan, int length, const byte *data );
+qboolean Netchan_Process( netchan_t *chan, msg_t *msg );
+
+
+/*
+==============================================================
+
+PROTOCOL
+
+==============================================================
+*/
+
+#define	PROTOCOL_VERSION	40
+
+#define	PORT_SERVER			27960
+
+// the svc_strings[] array in cl_parse.c should mirror this
+//
+// server to client
+//
+enum svc_ops_e {
+	svc_bad,
+	svc_nop,
+	svc_gamestate,
+	svc_configstring,			// [short] [string] only in gamestate messages
+	svc_baseline,				// only in gamestate messages
+	svc_serverCommand,			// [string] to be executed by client game module
+	svc_download,				// [short] size [size bytes]
+	svc_snapshot
+};
+
+
+//
+// client to server
+//
+enum clc_ops_e {
+	clc_bad,
+	clc_nop, 		
+	clc_move,				// [[usercmd_t]
+	clc_clientCommand		// [string] message
+};
+
+
+/*
+==============================================================
+
+CMD
+
+Command text buffering and command execution
+
+==============================================================
+*/
+
+/*
+
+Any number of commands can be added in a frame, from several different sources.
+Most commands come from either keybindings or console line input, but entire text
+files can be execed.
+
+*/
+
+void Cbuf_Init (void);
+// allocates an initial text buffer that will grow as needed
+
+void Cbuf_AddText( const char *text );
+// Adds command text at the end of the buffer, does NOT add a final \n
+
+void Cbuf_ExecuteText( int exec_when, const char *text );
+// this can be used in place of either Cbuf_AddText or Cbuf_InsertText
+
+void Cbuf_Execute (void);
+// Pulls off \n terminated lines of text from the command buffer and sends
+// them through Cmd_ExecuteString.  Stops when the buffer is empty.
+// Normally called once per frame, but may be explicitly invoked.
+// Do not call inside a command function, or current args will be destroyed.
+
+//===========================================================================
+
+/*
+
+Command execution takes a null terminated string, breaks it into tokens,
+then searches for a command or variable that matches the first token.
+
+*/
+
+typedef void (*xcommand_t) (void);
+
+void	Cmd_Init (void);
+
+void	Cmd_AddCommand( const char *cmd_name, xcommand_t function );
+// called by the init functions of other parts of the program to
+// register commands and functions to call for them.
+// The cmd_name is referenced later, so it should not be in temp memory
+// if function is NULL, the command will be forwarded to the server
+// as a clc_clientCommand instead of executed locally
+
+void	Cmd_RemoveCommand( const char *cmd_name );
+
+char 	*Cmd_CompleteCommand( const char *partial );
+// attempts to match a partial command for automatic command line completion
+// returns NULL if nothing fits
+
+int		Cmd_Argc (void);
+char	*Cmd_Argv (int arg);
+void	Cmd_ArgvBuffer( int arg, char *buffer, int bufferLength );
+char	*Cmd_Args (void);
+void	Cmd_ArgsBuffer( char *buffer, int bufferLength );
+// The functions that execute commands get their parameters with these
+// functions. Cmd_Argv () will return an empty string, not a NULL
+// if arg > argc, so string operations are allways safe.
+
+void	Cmd_TokenizeString( const char *text );
+// Takes a null terminated string.  Does not need to be /n terminated.
+// breaks the string up into arg tokens.
+
+void	Cmd_ExecuteString( const char *text );
+// Parses a single line of text into arguments and tries to execute it
+// as if it was typed at the console
+
+
+/*
+==============================================================
+
+CVAR
+
+==============================================================
+*/
+
+/*
+
+cvar_t variables are used to hold scalar or string variables that can be changed
+or displayed at the console or prog code as well as accessed directly
+in C code.
+
+The user can access cvars from the console in three ways:
+r_draworder			prints the current value
+r_draworder 0		sets the current value to 0
+set r_draworder 0	as above, but creates the cvar if not present
+
+Cvars are restricted from having the same names as commands to keep this
+interface from being ambiguous.
+
+The are also occasionally used to communicated information between different
+modules of the program.
+
+*/
+
+cvar_t *Cvar_Get( const char *var_name, const char *value, int flags );
+// creates the variable if it doesn't exist, or returns the existing one
+// if it exists, the value will not be changed, but flags will be ORed in
+// that allows variables to be unarchived without needing bitflags
+// if value is "", the value will not override a previously set value.
+
+void	Cvar_Register( vmCvar_t *vmCvar, const char *varName, const char *defaultValue, int flags );
+// basically a slightly modified Cvar_Get for the interpreted modules
+
+void	Cvar_Update( vmCvar_t *vmCvar );
+// updates an interpreted modules' version of a cvar
+
+void 	Cvar_Set( const char *var_name, const char *value );
+// will create the variable with no flags if it doesn't exist
+
+void	Cvar_SetValue( const char *var_name, float value );
+// expands value to a string and calls Cvar_Set
+
+float	Cvar_VariableValue( const char *var_name );
+int		Cvar_VariableIntegerValue( const char *var_name );
+// returns 0 if not defined or non numeric
+
+char	*Cvar_VariableString( const char *var_name );
+void	Cvar_VariableStringBuffer( const char *var_name, char *buffer, int bufsize );
+// returns an empty string if not defined
+
+char 	*Cvar_CompleteVariable( const char *partial );
+// attempts to match a partial variable name for command line completion
+// returns NULL if nothing fits
+
+void 	Cvar_Reset( const char *var_name );
+
+void	Cvar_SetCheatState( void );
+// reset all testing vars to a safe value
+
+qboolean Cvar_Command( void );
+// called by Cmd_ExecuteString when Cmd_Argv(0) doesn't match a known
+// command.  Returns true if the command was a variable reference that
+// was handled. (print or change)
+
+void 	Cvar_WriteVariables( fileHandle_t f );
+// writes lines containing "set variable value" for all variables
+// with the archive flag set to true.
+
+void	Cvar_Init( void );
+
+char	*Cvar_InfoString( int bit );
+// returns an info string containing all the cvars that have the given bit set
+// in their flags ( CVAR_USERINFO, CVAR_SERVERINFO, CVAR_SYSTEMINFO, etc )
+void	Cvar_InfoStringBuffer( int bit, char *buff, int buffsize );
+
+void	Cvar_Restart_f( void );
+
+extern	int			cvar_modifiedFlags;
+// whenever a cvar is modifed, its flags will be OR'd into this, so
+// a single check can determine if any CVAR_USERINFO, CVAR_SERVERINFO,
+// etc, variables have been modified since the last check.  The bit
+// can then be cleared to allow another change detection.
+
+/*
+==============================================================
+
+FILESYSTEM
+
+No stdio calls should be used by any part of the game, because
+we need to deal with all sorts of directory and seperator char
+issues.
+==============================================================
+*/
+
+qboolean FS_Initialized();
+
+void	FS_InitFilesystem (void);
+
+char	**FS_ListFiles( const char *directory, const char *extension, int *numfiles );
+// directory should not have either a leading or trailing /
+// if extension is "/", only subdirectories will be returned
+// the returned files will not include any directories or /
+
+void	FS_FreeFileList( char **filelist );
+
+int	FS_GetFileList(  const char *path, const char *extension, char *listbuf, int bufsize );
+
+fileHandle_t FS_FOpenFileWrite( const char *qpath );
+// will properly create any needed paths and deal with seperater character issues
+
+fileHandle_t FS_FOpenFileAppend( const char *filename );	// this was present already, but no public proto
+
+qboolean FS_GetExtendedInfo_FOpenFileRead(const char *filename, char **ppsFilename, int *piOffset);
+//return value is success of opening file, then ppsFilename and piOffset are valid
+
+int		FS_FOpenFileRead( const char *qpath, fileHandle_t *file, qboolean uniqueFILE );
+// if uniqueFILE is true, then a new FILE will be fopened even if the file
+// is found in an already open pak file.  If uniqueFILE is false, you must call
+// FS_FCloseFile instead of fclose, otherwise the pak FILE would be improperly closed
+// It is generally safe to always set uniqueFILE to true, because the majority of
+// file IO goes through FS_ReadFile, which Does The Right Thing already.
+
+int	FS_FileIsInPAK(const char *filename );
+// returns 1 if a file is in the PAK file, otherwise -1
+
+int	FS_Write( const void *buffer, int len, fileHandle_t f );
+
+int	FS_Read( void *buffer, int len, fileHandle_t f );
+// properly handles partial reads and reads from other dlls
+
+void	FS_FCloseFile( fileHandle_t f );
+// note: you can't just fclose from another DLL, due to MS libc issues
+
+int		FS_ReadFile( const char *qpath, void **buffer );
+// returns the length of the file
+// a null buffer will just return the file length without loading
+// as a quick check for existance. -1 length == not present
+// A 0 byte will always be appended at the end, so string ops are safe.
+// the buffer should be considered read-only, because it may be cached
+// for other uses.
+
+void	FS_ForceFlush( fileHandle_t f );
+// forces flush on files we're writing to.
+
+void	FS_FreeFile( void *buffer );
+// frees the memory returned by FS_ReadFile
+
+void	FS_WriteFile( const char *qpath, const void *buffer, int size );
+// writes a complete file, creating any subdirectories needed
+
+int		FS_filelength( fileHandle_t f );
+// doesn't work for files that are opened from a pack file
+
+int		FS_FTell( fileHandle_t f );
+// where are we?
+
+void	FS_Flush( fileHandle_t f );
+
+void 	QDECL FS_Printf( fileHandle_t f, const char *fmt, ... );
+// like fprintf
+
+int		FS_FOpenFileByMode( const char *qpath, fileHandle_t *f, fsMode_t mode );
+// opens a file for reading, writing, or appending depending on the value of mode
+
+int		FS_Seek( fileHandle_t f, long offset, int origin );
+// seek on a file (doesn't work for zip files!!!!!!!!)
+
+
+// These 2 are generally only used by the save games, filenames are local (eg "saves/blah.sav")
+//
+void		FS_DeleteUserGenFile( const char *filename );
+qboolean	FS_MoveUserGenFile  ( const char *filename_src, const char *filename_dst );
+
+/*
+==============================================================
+
+MISC
+
+==============================================================
+*/
+
+//==========================================================
+//
+// NOTE NOTE NOTE!!!!!!!!!!!!!
+//
+// Any CPUID_XXXX defined as higher than CPUID_INTEL_MMX *must* have MMX support (eg like CPUID_AMD_3DNOW (0x30) has),
+//	this allows convenient MMX capability checking. If you for some reason want to support some new processor that does
+//	*NOT* have MMX (yeah, right), then define it as a lower number. -slc
+//
+// ( These values are returned by Sys_GetProcessorId )
+//
+#define CPUID_GENERIC			0			// any unrecognized processor
+
+#define CPUID_AXP				0x10
+
+#define CPUID_INTEL_UNSUPPORTED	0x20			// Intel 386/486
+#define CPUID_INTEL_PENTIUM		0x21			// Intel Pentium or PPro
+#define CPUID_INTEL_MMX			0x22			// Intel Pentium/MMX or P2/MMX
+#define CPUID_INTEL_KATMAI		0x23			// Intel Katmai
+#define CPUID_INTEL_WILLIAMETTE	0x24			// Intel Williamette
+
+#define CPUID_AMD_3DNOW			0x30			// AMD K6 3DNOW!
+//
+//==========================================================
+
+#define RoundUp(N, M) ((N) + ((unsigned int)(M)) - (((unsigned int)(N)) % ((unsigned int)(M))))
+#define RoundDown(N, M) ((N) - (((unsigned int)(N)) % ((unsigned int)(M))))
+
+char		*CopyString( const char *in );
+void		Info_Print( const char *s );
+
+void		Com_BeginRedirect (char *buffer, int buffersize, void (*flush)(char *));
+void		Com_EndRedirect( void );
+void 		QDECL Com_Printf( const char *fmt, ... );
+void 		QDECL Com_DPrintf( const char *fmt, ... );
+void 		QDECL Com_Error( int code, const char *fmt, ... );
+void 		Com_Quit_f( void );
+int			Com_EventLoop( void );
+int			Com_Milliseconds( void );	// will be journaled properly
+unsigned	Com_BlockChecksum( const void *buffer, int length );
+int			Com_Filter(char *filter, char *name, int casesensitive);
+
+void		Com_StartupVariable( const char *match );
+// checks for and removes command line "+set var arg" constructs
+// if match is NULL, all set commands will be executed, otherwise
+// only a set with the exact name.  Only used during startup.
+
+
+extern	cvar_t	*com_developer;
+extern	cvar_t	*com_speeds;
+extern	cvar_t	*com_timescale;
+extern	cvar_t	*com_sv_running;
+extern	cvar_t	*com_cl_running;
+extern	cvar_t	*com_viewlog;			// 0 = hidden, 1 = visible, 2 = minimized
+extern	cvar_t	*com_version;
+
+// both client and server must agree to pause
+extern	cvar_t	*cl_paused;
+extern	cvar_t	*sv_paused;
+
+// com_speeds times
+extern	int		time_game;
+extern	int		time_frontend;
+extern	int		time_backend;		// renderer backend time
+
+extern	int		timeInTrace;
+extern	int		timeInPVSCheck;
+extern	int		numTraces;
+
+extern	int		com_frameTime;
+extern	int		com_frameMsec;
+
+extern	qboolean	com_errorEntered;
+
+
+#ifndef _XBOX
+extern	fileHandle_t	com_journalFile;
+extern	fileHandle_t	com_journalDataFile;
+#endif
+
+/*
+
+--- low memory ----
+server vm
+server clipmap
+---mark---
+renderer initialization (shaders, etc)
+UI vm
+cgame vm
+renderer map
+renderer models
+
+---free---
+
+temp file loading
+--- high memory ---
+
+*/
+int  Z_Validate( void );			// also used to insure all of these are paged in
+int   Z_MemSize	( memtag_t eTag );
+void  Z_TagFree	( memtag_t eTag );
+int   Z_Free	( void *ptr );	//returns bytes freed
+int	  Z_Size	( void *pvAddress);
+void  Z_MorphMallocTag( void *pvAddress, memtag_t eDesiredTag );
+qboolean Z_IsFromZone(void *pvAddress, memtag_t eTag);	//returns size if true
+
+#ifdef DEBUG_ZONE_ALLOCS
+
+	void *_D_Z_Malloc ( int iSize, memtag_t eTag, qboolean bZeroit, const char *psFile, int iLine );
+	void *_D_S_Malloc ( int iSize, const char *psFile, int iLine );	
+	void  _D_Z_Label  ( const void *pvAddress, const char *pslabel );
+
+	#define Z_Malloc(_iSize, _eTag, _bZeroit)	_D_Z_Malloc (_iSize, _eTag, _bZeroit, __FILE__, __LINE__)
+	#define S_Malloc(_iSize)					_D_S_Malloc	(_iSize, __FILE__, __LINE__)	// NOT 0 filled memory only for small allocations	
+	
+	#define Z_Label(_ptr, _label)				_D_Z_Label	(_ptr, _label)
+
+#else
+
+	void *Z_Malloc  ( int iSize, memtag_t eTag, qboolean bZeroit, int iAlign = 4);	// return memory NOT zero-filled by default
+	void *S_Malloc	( int iSize );									// NOT 0 filled memory only for small allocations
+
+	#define Z_Label(_ptr, _label)	/* */
+
+#endif
+
+
+void Hunk_Clear( void );
+void Hunk_ClearToMark( void );
+void Hunk_SetMark( void );
+// note the opposite default for 'bZeroIt' in Hunk_Alloc to Z_Malloc, since Hunk_Alloc always used to memset(0)...
+//
+inline void *Hunk_Alloc( int size, qboolean bZeroIt = qtrue) 
+{
+	return Z_Malloc(size, TAG_HUNKALLOC, bZeroIt);
+}
+
+
+void Com_TouchMemory( void );
+
+// commandLine should not include the executable name (argv[0])
+void Com_SetOrgAngles(vec3_t org,vec3_t angles);
+void Com_Init( char *commandLine );
+void Com_Frame( void );
+void Com_Shutdown( void );
+void Com_ShutdownZoneMemory(void);
+void Com_ShutdownHunkMemory(void);
+
+bool Com_ParseTextFile(const char *file, class CGenericParser2 &parser, bool cleanFirst = true);
+CGenericParser2 *Com_ParseTextFile(const char *file, bool cleanFirst, bool writeable);
+void Com_ParseTextFileDestroy(class CGenericParser2 &parser);
+
+/*
+==============================================================
+
+CLIENT / SERVER SYSTEMS
+
+==============================================================
+*/
+
+//
+// client interface
+//
+void CL_InitKeyCommands( void );
+// the keyboard binding interface must be setup before execing
+// config files, but the rest of client startup will happen later
+
+void CL_Init( void );
+void CL_Disconnect( void );
+void CL_Shutdown( void );
+void CL_Frame( int msec,float fractionMsec );
+qboolean CL_GameCommand( void );
+void CL_KeyEvent (int key, qboolean down, unsigned time);
+
+void CL_CharEvent( int key );
+// char events are for field typing, not game control
+
+void CL_MouseEvent( int dx, int dy, int time );
+
+void CL_JoystickEvent( int axis, int value, int time );
+
+void CL_PacketEvent( netadr_t from, msg_t *msg );
+
+void CL_ConsolePrint( char *text );
+
+void CL_MapLoading( void );
+// do a screen update before starting to load a map
+// when the server is going to load a new map, the entire hunk
+// will be cleared, so the client must shutdown cgame, ui, and
+// the renderer
+
+void	CL_ForwardCommandToServer( void );
+// adds the current command line as a clc_clientCommand to the client message.
+// things like godmode, noclip, etc, are commands directed to the server,
+// so when they are typed in at the console, they will need to be forwarded.
+
+void CL_FlushMemory( void );
+// dump all memory on an error
+
+void CL_StartHunkUsers( void );
+
+void Key_WriteBindings( fileHandle_t f );
+// for writing the config files
+
+void S_ClearSoundBuffer( void );
+// call before filesystem access
+
+void SCR_DebugGraph (float value, int color);	// FIXME: move logging to common?
+
+
+//
+// server interface
+//
+void SV_Init( void );
+void SV_Shutdown( char *finalmsg );
+void SV_Frame( int msec,float fractionMsec);
+void SV_PacketEvent( netadr_t from, msg_t *msg );
+qboolean SV_GameCommand( void );
+
+
+//
+// UI interface
+//
+qboolean UI_GameCommand( void );
+
+
+/*
+==============================================================
+
+NON-PORTABLE SYSTEM SERVICES
+
+==============================================================
+*/
+
+typedef enum {
+	AXIS_SIDE,
+	AXIS_FORWARD,
+	AXIS_UP,
+	AXIS_ROLL,
+	AXIS_YAW,
+	AXIS_PITCH,
+	MAX_JOYSTICK_AXIS
+} joystickAxis_t;
+
+typedef enum {
+	SE_NONE,	// evTime is still valid
+	SE_KEY,		// evValue is a key code, evValue2 is the down flag
+	SE_CHAR,	// evValue is an ascii char
+	SE_MOUSE,	// evValue and evValue2 are reletive signed x / y moves
+	SE_JOYSTICK_AXIS,	// evValue is an axis number and evValue2 is the current state (-127 to 127)
+	SE_CONSOLE,	// evPtr is a char*
+	SE_PACKET	// evPtr is a netadr_t followed by data bytes to evPtrLength
+} sysEventType_t;
+
+typedef struct {
+	int				evTime;
+	sysEventType_t	evType;
+	int				evValue, evValue2;
+	int				evPtrLength;	// bytes of data pointed to by evPtr, for journaling
+	void			*evPtr;			// this must be manually freed if not NULL
+} sysEvent_t;
+
+sysEvent_t	Sys_GetEvent( void );
+
+void	Sys_Init (void);
+
+char	*Sys_GetCurrentUser( void );
+
+void	QDECL Sys_Error( const char *error, ...);
+void	Sys_Quit (void);
+char	*Sys_GetClipboardData( void );	// note that this isn't journaled...
+
+void	Sys_Print( const char *msg );
+#ifdef _XBOX
+void	Sys_Log( const char *file, const char *msg );
+void	Sys_Log( const char *file, const void *buffer, int size, bool flush );
+#endif
+
+// Sys_Milliseconds should only be used for profiling purposes,
+// any game related timing information should come from event timestamps
+int		Sys_Milliseconds (void);
+
+
+// the system console is shown when a dedicated server is running
+void	Sys_DisplaySystemConsole( qboolean show );
+
+int		Sys_GetProcessorId( void );
+
+void	Sys_BeginStreamedFile( fileHandle_t f, int readahead );
+void	Sys_EndStreamedFile( fileHandle_t f );
+int		Sys_StreamedRead( void *buffer, int size, int count, fileHandle_t f );
+void	Sys_StreamSeek( fileHandle_t f, int offset, int origin );
+
+void	Sys_ShowConsole( int level, qboolean quitOnClose );
+void	Sys_SetErrorText( const char *text );
+
+qboolean	Sys_CheckCD( void );
+
+void	Sys_Mkdir( const char *path );
+char	*Sys_Cwd( void );
+char	*Sys_DefaultCDPath(void);
+char	*Sys_DefaultBasePath(void);
+
+char **Sys_ListFiles( const char *directory, const char *extension, int *numfiles, qboolean wantsubs );
+void	Sys_FreeFileList( char **filelist );
+
+void	Sys_BeginProfiling( void );
+void	Sys_EndProfiling( void );
+
+qboolean Sys_LowPhysicalMemory();
+qboolean Sys_FileOutOfDate( LPCSTR psFinalFileName /* dest */, LPCSTR psDataFileName /* src */ );
+qboolean Sys_CopyFile(LPCSTR lpExistingFileName, LPCSTR lpNewFileName, qboolean bOverwrite);
+
+
+//byte*	SCR_GetScreenshot(qboolean *qValid);
+//void	SCR_SetScreenshot(const byte *pbData, int w, int h);
+//byte*	SCR_TempRawImage_ReadFromFile(const char *psLocalFilename, int *piWidth, int *piHeight, byte *pbReSampleBuffer, qboolean qbVertFlip);
+//void	SCR_TempRawImage_CleanUp();
+
+inline int Round(float value)
+{
+	return((int)floorf(value + 0.5f));
+}
+
+
+#ifdef _XBOX
+//////////////////////////////
+//
+// Map Lump Loader
+//
+struct Lump
+{
+	void* data;
+	int len;
+	
+	Lump() : data(NULL), len(0) {}
+	~Lump() { clear(); }
+
+	void load(const char* map, const char* lump)
+	{
+		clear();
+
+		char path[MAX_QPATH];
+		Com_sprintf(path, MAX_QPATH, "%s/%s.mle", map, lump);
+
+		len = FS_ReadFile(path, &data);
+		if (len < 0) len = 0;
+	}
+
+	void clear(void)
+	{
+		if (data)
+		{
+			FS_FreeFile(data);
+			data = NULL;
+		}
+	}
+};
+#endif _XBOX
+
+#endif //__QCOMMON_H__
\ No newline at end of file
diff --git a/code/qcommon/qfiles.h b/code/qcommon/qfiles.h
new file mode 100644
index 0000000..9b8bde5
--- /dev/null
+++ b/code/qcommon/qfiles.h
@@ -0,0 +1,633 @@
+#ifndef __QFILES_H__
+#define __QFILES_H__
+
+//
+// qfiles.h: quake file formats
+// This file must be identical in the quake and utils directories
+//
+
+// surface geometry should not exceed these limits
+#define	SHADER_MAX_VERTEXES	1000
+#define	SHADER_MAX_INDEXES	(6*SHADER_MAX_VERTEXES)
+
+
+// the maximum size of game reletive pathnames
+#define	MAX_QPATH		64
+
+/*
+========================================================================
+
+QVM files
+
+========================================================================
+*/
+
+#define	VM_MAGIC	0x12721444
+typedef struct {
+	int		vmMagic;
+
+	int		instructionCount;
+
+	int		codeOffset;
+	int		codeLength;
+
+	int		dataOffset;
+	int		dataLength;
+	int		litLength;			// ( dataLength - litLength ) should be byteswapped on load
+	int		bssLength;			// zero filled memory appended to datalength
+} vmHeader_t;
+
+/*
+========================================================================
+
+PCX files are used for 8 bit images
+
+========================================================================
+*/
+
+typedef struct {
+    char	manufacturer;
+    char	version;
+    char	encoding;
+    char	bits_per_pixel;
+    unsigned short	xmin,ymin,xmax,ymax;
+    unsigned short	hres,vres;
+    unsigned char	palette[48];
+    char	reserved;
+    char	color_planes;
+    unsigned short	bytes_per_line;
+    unsigned short	palette_type;
+    char	filler[58];
+    unsigned char	data;			// unbounded
+} pcx_t;
+
+
+/*
+========================================================================
+
+TGA files are used for 24/32 bit images
+
+========================================================================
+*/
+
+typedef struct _TargaHeader {
+	unsigned char 	id_length, colormap_type, image_type;
+	unsigned short	colormap_index, colormap_length;
+	unsigned char	colormap_size;
+	unsigned short	x_origin, y_origin, width, height;
+	unsigned char	pixel_size, attributes;
+} TargaHeader;
+
+
+
+/*
+========================================================================
+
+.MD3 triangle model file format
+
+========================================================================
+*/
+
+#define MD3_IDENT			(('3'<<24)+('P'<<16)+('D'<<8)+'I')
+#define MD3_VERSION			15
+
+// limits
+#define MD3_MAX_LODS		3
+#define	MD3_MAX_TRIANGLES	8192	// per surface
+#define MD3_MAX_VERTS		4096	// per surface
+#define MD3_MAX_SHADERS		256		// per surface
+#define MD3_MAX_FRAMES		1024	// per model
+#define	MD3_MAX_SURFACES	32 + 32	// per model
+#define MD3_MAX_TAGS		16		// per frame
+
+// vertex scales
+#define	MD3_XYZ_SCALE		(1.0/64)
+
+typedef struct md3Frame_s {
+	vec3_t		bounds[2];
+	vec3_t		localOrigin;
+	float		radius;
+	char		name[16];
+} md3Frame_t;
+
+typedef struct md3Tag_s {
+	char		name[MAX_QPATH];	// tag name
+	vec3_t		origin;
+	vec3_t		axis[3];
+} md3Tag_t;
+
+/*
+** md3Surface_t
+**
+** CHUNK			SIZE
+** header			sizeof( md3Surface_t )
+** shaders			sizeof( md3Shader_t ) * numShaders
+** triangles[0]		sizeof( md3Triangle_t ) * numTriangles
+** st				sizeof( md3St_t ) * numVerts
+** XyzNormals		sizeof( md3XyzNormal_t ) * numVerts * numFrames
+*/
+typedef struct {
+	int		ident;				// 
+
+	char	name[MAX_QPATH];	// polyset name
+
+	int		flags;
+	int		numFrames;			// all surfaces in a model should have the same
+
+	int		numShaders;			// all surfaces in a model should have the same
+	int		numVerts;
+
+	int		numTriangles;
+	int		ofsTriangles;
+
+	int		ofsShaders;			// offset from start of md3Surface_t
+	int		ofsSt;				// texture coords are common for all frames
+	int		ofsXyzNormals;		// numVerts * numFrames
+
+	int		ofsEnd;				// next surface follows
+} md3Surface_t;
+
+typedef struct {
+	char			name[MAX_QPATH];
+	int				shaderIndex;	// for in-game use
+} md3Shader_t;
+
+typedef struct {
+	int			indexes[3];
+} md3Triangle_t;
+
+typedef struct {
+	float		st[2];
+} md3St_t;
+
+typedef struct {
+	short		xyz[3];
+	short		normal;
+} md3XyzNormal_t;
+
+typedef struct {
+	int			ident;
+	int			version;
+
+	char		name[MAX_QPATH];	// model name
+
+	int			flags;
+
+	int			numFrames;
+	int			numTags;			
+	int			numSurfaces;
+
+	int			numSkins;
+
+	int			ofsFrames;			// offset for first frame
+	int			ofsTags;			// numFrames * numTags
+	int			ofsSurfaces;		// first surface, others follow
+
+	int			ofsEnd;				// end of file
+} md3Header_t;
+
+
+/*
+==============================================================================
+
+  .BSP file format
+
+==============================================================================
+*/
+
+
+#define BSP_IDENT	(('P'<<24)+('S'<<16)+('B'<<8)+'R')
+		// little-endian "IBSP"
+
+#define BSP_VERSION			1
+
+
+// there shouldn't be any problem with increasing these values at the
+// expense of more memory allocation in the utilities
+#define	MAX_MAP_MODELS		0x400
+#define	MAX_MAP_BRUSHES		0x8000
+#define	MAX_MAP_ENTITIES	0x800
+#define	MAX_MAP_ENTSTRING	0x40000
+#define	MAX_MAP_SHADERS		0x400
+
+#define	MAX_MAP_AREAS		0x100	// MAX_MAP_AREA_BYTES in q_shared must match!
+#define	MAX_MAP_FOGS		0x100
+#define	MAX_MAP_PLANES		0x20000
+#define	MAX_MAP_NODES		0x20000
+#define	MAX_MAP_BRUSHSIDES	0x20000
+#define	MAX_MAP_LEAFS		0x20000
+#define	MAX_MAP_LEAFFACES	0x20000
+#define	MAX_MAP_LEAFBRUSHES 0x40000
+#define	MAX_MAP_PORTALS		0x20000
+#define	MAX_MAP_LIGHTING	0x800000
+#define	MAX_MAP_LIGHTGRID	65535
+#define	MAX_MAP_LIGHTGRID_ARRAY	0x100000
+
+#define	MAX_MAP_VISIBILITY	0x400000
+
+#define	MAX_MAP_DRAW_SURFS	0x20000
+#define	MAX_MAP_DRAW_VERTS	0x80000
+#define	MAX_MAP_DRAW_INDEXES	0x80000
+
+
+// key / value pair sizes in the entities lump
+#define	MAX_KEY				32
+#define	MAX_VALUE			1024
+
+// the editor uses these predefined yaw angles to orient entities up or down
+#define	ANGLE_UP			-1
+#define	ANGLE_DOWN			-2
+
+#define	LIGHTMAP_WIDTH		128
+#define	LIGHTMAP_HEIGHT		128
+
+//=============================================================================
+
+#ifdef _XBOX
+
+#pragma pack(push, 1)
+
+typedef struct {
+	float			mins[3], maxs[3];
+	int				firstSurface;
+	unsigned short	numSurfaces;
+	int				firstBrush;
+	unsigned short	numBrushes;
+} dmodel_t;
+
+typedef struct {
+	char		shader[MAX_QPATH];
+	int			surfaceFlags;
+	int			contentFlags;
+} dshader_t;
+
+// planes x^1 is allways the opposite of plane x
+
+typedef struct {
+	float		normal[3];
+	float		dist;
+} dplane_t;
+
+typedef struct {
+	int				planeNum;
+	short			children[2];	// negative numbers are -(leafs+1), not nodes
+	short			mins[3];		// for frustom culling
+	short			maxs[3];
+} dnode_t;
+
+typedef struct {
+	short			cluster;			// -1 = opaque cluster (do I still store these?)
+	signed char		area;
+
+	short			mins[3];			// for frustum culling
+	short			maxs[3];
+
+	unsigned short	firstLeafSurface;
+	unsigned short	numLeafSurfaces;
+
+	unsigned short	firstLeafBrush;
+	unsigned short	numLeafBrushes;
+} dleaf_t;
+
+typedef struct {
+	int				planeNum;		// positive plane side faces out of the leaf
+	byte			shaderNum;
+} dbrushside_t;
+
+typedef struct {
+	int				firstSide;
+	byte			numSides;
+	unsigned short	shaderNum;		// the shader that determines the contents flags
+} dbrush_t;
+
+typedef struct {
+	char		shader[MAX_QPATH];
+	int			brushNum;
+	int			visibleSide;	// the brush side that ray tests need to clip against (-1 == none)
+} dfog_t;
+
+// Light Style Constants
+#define	MAXLIGHTMAPS	4
+#define LS_NORMAL		0x00
+#define LS_UNUSED		0xfe
+#define	LS_NONE			0xff
+#define MAX_LIGHT_STYLES		64
+
+typedef struct {
+	float			lightmap[MAXLIGHTMAPS][2];
+	float			st[2];
+	short			xyz[3];
+	short			normal[3];
+	byte			color[MAXLIGHTMAPS][4];
+} mapVert_t;
+
+#define DRAWVERT_LIGHTMAP_SCALE 32768.0f
+// Change texture coordinates for TriSurfs to be even more fine grain.
+// See below for note about keeping MIN_ST and MAX_ST up to date with
+// ST_SCALE. These are in 4.12. Okay, how about 5.11?
+//#define DRAWVERT_ST_SCALE 4096.0f
+#define DRAWVERT_ST_SCALE 2048.0f
+
+// We use a slightly different format for the fixed point texture
+// coords in Grid/Mesh drawverts: 10.6 rather than 12.4
+// To be sure that this is ok, keep the max and min values equal to
+// the largest and smallest whole numbers that can be stored using the
+// format. (ie: Don't change GRID_DRAWVERT_ST_SCALE without changing
+// the other two!) (And don't forget that we're using a bit for sign.)
+#define GRID_DRAWVERT_ST_SCALE 64.0f
+
+// This master switch controls whether we use compressed (4-bit per channel)
+// vertex colors in draw and surface verts. It saves memory, but I'm switching
+// it off, because we end up with that nasty green/purple streaking effect.
+// If we ever figure out how to do it better... (1555? 565?)
+//#define COMPRESS_VERTEX_COLORS
+
+typedef struct {
+	short		xyz[3];
+	short		dvst[2];
+	short		dvlightmap[MAXLIGHTMAPS][2];
+	short		normal[3];
+#ifdef _XBOX
+	vec3_t		tangent;
+#endif
+#ifdef COMPRESS_VERTEX_COLORS
+	byte		dvcolor[MAXLIGHTMAPS][1];
+#else
+	byte		dvcolor[MAXLIGHTMAPS][4];
+#endif
+} drawVert_t;
+
+typedef struct {
+	byte	flags;
+	byte	latLong[2];
+} dgrid_t;
+
+typedef struct {
+	int			code;
+	byte		shaderNum;
+	signed char	fogNum;
+
+	unsigned int	verts;				// high 20 bits are first vert, low 12 are num verts
+	unsigned int	indexes;			// high 20 bits are first index, low 12 are num indices
+
+	byte		lightmapStyles[MAXLIGHTMAPS];
+	byte		lightmapNum[MAXLIGHTMAPS];
+
+	short		lightmapVecs[3];
+} dface_t;
+
+typedef struct {
+	int			code;
+	byte		shaderNum;
+	signed char	fogNum;
+
+	unsigned int	verts;				// high 20 bits are first vert, low 12 are num verts
+
+	byte		lightmapStyles[MAXLIGHTMAPS];
+	byte		lightmapNum[MAXLIGHTMAPS];
+
+	short		lightmapVecs[2][3];		// for patches, [0] and [1] are lodbounds
+
+	byte		patchWidth;
+	byte		patchHeight;
+} dpatch_t;
+
+typedef struct {
+	int			code;
+	byte		shaderNum;
+	signed char	fogNum;
+
+	unsigned int	verts;				// high 20 bits are first vert, low 12 are num verts
+	unsigned int	indexes;			// high 20 bits are first index, low 12 are num indices
+
+	byte		lightmapStyles[MAXLIGHTMAPS];
+} dtrisurf_t;
+
+typedef struct {
+	int				code;
+	byte			shaderNum;
+	signed char     fogNum;
+
+	short			origin[3];
+	short			normal[3];
+	byte			color[3];
+} dflare_t;
+
+#pragma pack(pop)
+
+#else // _XBOX
+
+typedef struct {
+	int		fileofs, filelen;
+} lump_t;
+
+#define	LUMP_ENTITIES		0
+#define	LUMP_SHADERS		1
+#define	LUMP_PLANES			2
+#define	LUMP_NODES			3
+#define	LUMP_LEAFS			4
+#define	LUMP_LEAFSURFACES	5
+#define	LUMP_LEAFBRUSHES	6
+#define	LUMP_MODELS			7
+#define	LUMP_BRUSHES		8
+#define	LUMP_BRUSHSIDES		9
+#define	LUMP_DRAWVERTS		10
+#define	LUMP_DRAWINDEXES	11
+#define	LUMP_FOGS			12
+#define	LUMP_SURFACES		13
+#define	LUMP_LIGHTMAPS		14
+#define	LUMP_LIGHTGRID		15
+#define	LUMP_VISIBILITY		16
+#define LUMP_LIGHTARRAY		17
+#define	HEADER_LUMPS		18
+
+typedef struct {
+	int			ident;
+	int			version;
+
+	lump_t		lumps[HEADER_LUMPS];
+} dheader_t;
+
+typedef struct {
+	float		mins[3], maxs[3];
+	int			firstSurface, numSurfaces;
+	int			firstBrush, numBrushes;
+} dmodel_t;
+
+typedef struct dshader_s {
+	char		shader[MAX_QPATH];
+	int			surfaceFlags;
+	int			contentFlags;
+} dshader_t;
+
+// planes x^1 is allways the opposite of plane x
+
+typedef struct {
+	float		normal[3];
+	float		dist;
+} dplane_t;
+
+typedef struct {
+	int			planeNum;
+	int			children[2];	// negative numbers are -(leafs+1), not nodes
+	int			mins[3];		// for frustom culling
+	int			maxs[3];
+} dnode_t;
+
+typedef struct {
+	int			cluster;			// -1 = opaque cluster (do I still store these?)
+	int			area;
+
+	int			mins[3];			// for frustum culling
+	int			maxs[3];
+
+	int			firstLeafSurface;
+	int			numLeafSurfaces;
+
+	int			firstLeafBrush;
+	int			numLeafBrushes;
+} dleaf_t;
+
+typedef struct {
+	int			planeNum;			// positive plane side faces out of the leaf
+	int			shaderNum;
+	int			drawSurfNum;
+} dbrushside_t;
+
+typedef struct {
+	int			firstSide;
+	int			numSides;
+	int			shaderNum;		// the shader that determines the contents flags
+} dbrush_t;
+
+typedef struct {
+	char		shader[MAX_QPATH];
+	int			brushNum;
+	int			visibleSide;	// the brush side that ray tests need to clip against (-1 == none)
+} dfog_t;
+
+// Light Style Constants
+#define	MAXLIGHTMAPS	4
+#define LS_NORMAL		0x00
+#define LS_UNUSED		0xfe
+#define	LS_NONE			0xff
+#define MAX_LIGHT_STYLES		64
+
+typedef struct {
+	vec3_t		xyz;
+	float		st[2];
+	float		lightmap[MAXLIGHTMAPS][2];
+	vec3_t		normal;
+	byte		color[MAXLIGHTMAPS][4];
+} mapVert_t;
+
+typedef struct {
+	vec3_t		xyz;
+	float		st[2];
+	float		lightmap[MAXLIGHTMAPS][2];
+	vec3_t		normal;
+	byte		color[MAXLIGHTMAPS][4];
+} drawVert_t;
+
+typedef struct
+{
+	byte		ambientLight[MAXLIGHTMAPS][3];
+	byte		directLight[MAXLIGHTMAPS][3];
+	byte		styles[MAXLIGHTMAPS];
+	byte		latLong[2];
+}  dgrid_t;
+
+typedef enum {
+	MST_BAD,
+	MST_PLANAR,
+	MST_PATCH,
+	MST_TRIANGLE_SOUP,
+	MST_FLARE
+} mapSurfaceType_t;
+
+typedef struct {
+	int			shaderNum;
+	int			fogNum;
+	int			surfaceType;
+
+	int			firstVert;
+	int			numVerts;
+
+	int			firstIndex;
+	int			numIndexes;
+
+	byte		lightmapStyles[MAXLIGHTMAPS], vertexStyles[MAXLIGHTMAPS];
+	int			lightmapNum[MAXLIGHTMAPS];
+	int			lightmapX[MAXLIGHTMAPS], lightmapY[MAXLIGHTMAPS];
+	int			lightmapWidth, lightmapHeight;
+
+	vec3_t		lightmapOrigin;
+	vec3_t		lightmapVecs[3];	// for patches, [0] and [1] are lodbounds
+
+	int			patchWidth;
+	int			patchHeight;
+} dsurface_t;
+
+#endif _XBOX
+
+typedef enum //# hunkAllocType_e
+{
+	HA_MISC,	
+	HA_MAP,
+	HA_SHADERS,
+	HA_LIGHTING,
+	HA_FOG,
+	HA_PATCHES,
+	HA_VIS,
+	HA_SUBMODELS,
+	HA_MODELS,
+	MAX_HA_TYPES
+} hunkAllocType_t;
+
+
+
+/////////////////////////////////////////////////////////////
+//
+// Defines and structures required for fonts
+
+#define GLYPH_COUNT			256
+
+// Must match define in stmparse.h
+#define STYLE_DROPSHADOW	0x80000000
+#define STYLE_BLINK			0x40000000
+#define	SET_MASK			0x00ffffff
+
+typedef struct 
+{
+	short		width;					// number of pixels wide
+	short		height;					// number of scan lines
+	short		horizAdvance;			// number of pixels to advance to the next char
+	short		horizOffset;			// x offset into space to render glyph
+	int			baseline;				// y offset 
+	float		s;						// x start tex coord
+	float		t;						// y start tex coord
+	float		s2;						// x end tex coord
+	float		t2;						// y end tex coord
+} glyphInfo_t;
+
+
+// this file corresponds 1:1 with the "*.fontdat" files, so don't change it unless you're going to
+//	recompile the fontgen util and regenerate all the fonts!
+//
+typedef struct dfontdat_s
+{
+	glyphInfo_t		mGlyphs[GLYPH_COUNT];
+
+	short			mPointSize;
+	short			mHeight;				// max height of font
+	short			mAscender;
+	short			mDescender;
+
+	short			mKoreanHack;			// unused field, written out by John's fontgen program but we have to leave it there for disk structs <sigh>
+} dfontdat_t;
+
+/////////////////// fonts end ////////////////////////////////////
+
+
+
+#endif
diff --git a/code/qcommon/sparc.h b/code/qcommon/sparc.h
new file mode 100644
index 0000000..19ebeb6
--- /dev/null
+++ b/code/qcommon/sparc.h
@@ -0,0 +1,725 @@
+
+/*
+ * UNPUBLISHED -- Rights  reserved  under  the  copyright  laws  of the 
+ * United States.  Use  of a copyright notice is precautionary only and 
+ * does not imply publication or disclosure.                            
+ *                                                                      
+ * THIS DOCUMENTATION CONTAINS CONFIDENTIAL AND PROPRIETARY INFORMATION 
+ * OF    VICARIOUS   VISIONS,  INC.    ANY  DUPLICATION,  MODIFICATION, 
+ * DISTRIBUTION, OR DISCLOSURE IS STRICTLY PROHIBITED WITHOUT THE PRIOR 
+ * EXPRESS WRITTEN PERMISSION OF VICARIOUS VISIONS, INC.
+ */
+
+/*
+
+AUTHOR: Dave Calvin
+CREATED: 2002-05-07
+
+SParse ARray Compressor.  Given an array, this class reduces the memory
+needed to store the array by eliminating the most-frequently used element.
+The remaining elements are increased in size by one integer.
+
+If the compressed data would be larger than the original data, the
+original data is stored as is.
+
+Compression is O(2N) where N is the number of elements to compress.
+
+Decompression is O(log M + N) where M is the number of elements after
+compression (CompressedLength()) and N is the number of elements to decompress.
+Decompression is O(1) when the same or smaller amount of data is requested as
+the last decompression.
+
+The pointer returned by Decompress() is valid until the class is destroyed
+or a new call is made to Compress() or Decompress().
+
+Elements must define operator==, operator!=, and sizeof.
+
+*/
+
+#ifndef __SPARC_H
+#define __SPARC_H
+
+#ifdef _GAMECUBE
+#define SPARC_BIG_ENDIAN
+#endif
+
+//Bigger than a short, smaller than an int.
+#pragma pack(push, 1)
+struct NotSoShort
+{
+	unsigned char bytes[3];
+
+	NotSoShort(void) {}
+
+	NotSoShort(unsigned int source) {
+#ifdef SPARC_BIG_ENDIAN
+		bytes[2] = source & 0xFF;
+		bytes[1] = (source >> 8) & 0xFF;
+		bytes[0] = (source >> 16) & 0xFF;
+#else
+		bytes[0] = source & 0xFF;
+		bytes[1] = (source >> 8) & 0xFF;
+		bytes[2] = (source >> 16) & 0xFF;
+#endif
+	}
+
+	inline unsigned int GetValue(void) {
+#ifdef SPARC_BIG_ENDIAN
+		return (bytes[0] << 16) | (bytes[1] << 8) | bytes[2];
+#else
+		return (bytes[2] << 16) | (bytes[1] << 8) | bytes[0];
+#endif
+	}
+
+	inline bool operator==(unsigned int cmp) {
+#ifdef SPARC_BIG_ENDIAN
+		return cmp == ((*(unsigned int*)bytes) >> 8);
+#else
+		return cmp == ((*(unsigned int*)bytes) & 0x00FFFFFF);
+#endif
+	}
+
+	bool operator<(unsigned int cmp) {
+		unsigned int tmp = *(unsigned int*)bytes;
+#ifdef SPARC_BIG_ENDIAN
+		tmp >>= 8;
+#else
+		tmp &= 0x00FFFFFF;
+#endif
+		return tmp < cmp;
+	}
+
+	bool operator<=(unsigned int cmp) {
+		unsigned int tmp = *(unsigned int*)bytes;
+#ifdef SPARC_BIG_ENDIAN
+		tmp >>= 8;
+#else
+		tmp &= 0x00FFFFFF;
+#endif
+		return tmp <= cmp;
+	}
+
+	bool operator>(unsigned int cmp) {
+		unsigned int tmp = *(unsigned int*)bytes;
+#ifdef SPARC_BIG_ENDIAN
+		tmp >>= 8;
+#else
+		tmp &= 0x00FFFFFF;
+#endif
+		return tmp > cmp;
+	}
+};
+
+//Compressed data is made up of these elements.
+template <class T, class U>
+struct SPARCElement
+{
+	T data;
+	U offset;
+};
+#pragma pack(pop)
+
+
+inline unsigned int SPARC_SWAP32(unsigned int x, bool doSwap) {
+	if (doSwap) {
+		return ((unsigned int)( ( (x & 0xff000000) >> 24)
+			+ ( (x & 0x00ff0000) >> 8 )
+			+ ( (x & 0x0000ff00) << 8 )
+			+ ( (x & 0x000000ff) << 24 ) ));
+	}
+	return x;
+}
+
+inline NotSoShort SPARC_SWAP24(NotSoShort x, bool doSwap) {
+	if (doSwap) {
+		x.bytes[0] ^= x.bytes[2];
+		x.bytes[2] ^= x.bytes[0];
+		x.bytes[0] ^= x.bytes[2];
+	}
+	return x;
+}
+
+inline unsigned short SPARC_SWAP16(unsigned short x, bool doSwap) {
+	if (doSwap) {
+		return ((unsigned short)( ( (x & 0xff00) >> 8)
+			+ ( (x & 0x00ff) << 8 ) ));
+	}
+	return x;
+}
+
+
+//The core of the SPARC system.  T is the data type to be compressed.
+//U is the data type needed to store offsets information in the compressed
+//data.  Smaller U makes for better compression but bigger data requires
+//larger U.
+template <class T, class U>
+class SPARCCore
+{
+private:
+	//Using compression or just storing clear data?
+	bool compressionUsed;
+
+	//Compressed data and its length.
+	SPARCElement<T, U> *compressedData;
+	unsigned int compressedLength;
+
+	//Decompression cache.
+	T *decompressedData;
+	unsigned int decompressedOffset;
+	unsigned int decompressedLength;
+
+	//Element which was removed to compress.
+	T removedElement;
+	
+	//Length of original data before compression.
+	unsigned int originalLength;
+
+	//Memory allocators.
+	void* (*Allocator)(unsigned int size);
+	void (*Deallocator)(void *ptr);
+
+	//Destroy all allocated memory.
+	void Cleanup(void) {
+		if(compressedData) {
+			if(Deallocator) {
+				Deallocator(compressedData);
+			} else {
+				delete [] compressedData;
+			}
+			compressedData = NULL;
+		}
+
+		if(decompressedData) {
+			if(Deallocator) {
+				Deallocator(decompressedData);
+			} else {
+				delete [] decompressedData;
+			}
+			decompressedData = NULL;
+		}
+	}
+
+	void Init(void) {
+		compressionUsed = false;
+		compressedData = NULL;
+		originalLength = 0;
+		compressedLength = 0;
+		decompressedData = NULL;
+		decompressedOffset = 0;
+		decompressedLength = 0;
+	}
+
+
+	//Binary search for the compressed element most closely matching 'offset'.
+	SPARCElement<T, U> *FindDecompStart(unsigned int offset)
+	{
+		unsigned int startPoint = compressedLength / 2;
+		unsigned int divisor = 4;
+		unsigned int leap;
+		while(1) {
+			if(compressedData[startPoint].offset <= offset &&
+					compressedData[startPoint+1].offset > offset) {
+				if(compressedData[startPoint].offset == offset) {
+					return &compressedData[startPoint];
+				} else {
+					return &compressedData[startPoint+1];
+				}
+			}
+
+			leap = compressedLength / divisor;
+			if(leap < 1) {
+				leap = 1;
+			} else {
+				divisor *= 2;
+			}
+			if(compressedData[startPoint].offset > offset) {
+				startPoint -= leap;
+			} else {
+				startPoint += leap;
+			}
+		}
+	}
+
+public:
+	SPARCCore(void) {
+		Init();
+		Allocator = NULL;
+		Deallocator = NULL;
+	}
+
+	~SPARCCore(void) {
+		Cleanup();
+	}
+
+	void SetAllocator(void* (*alloc)(unsigned int size),
+			void (*dealloc)(void *ptr)) {
+		Allocator = alloc;
+		Deallocator = dealloc;
+	}
+
+	//Just store the array without compression.
+	unsigned int Store(const T *array, unsigned int length) {
+		//Destroy old data.
+		Cleanup();
+		Init();
+
+		//Allocate memory and copy array.
+		if(Allocator) {
+			decompressedData = (T*)Allocator(length * sizeof(T));
+		} else {
+			decompressedData = new T[length];
+		}
+		compressedLength = length;
+		memcpy(decompressedData, array, sizeof(T) * length);
+
+		//Set length.
+		originalLength = length;
+
+		return CompressedSize();
+	}
+
+	//Load compressed data directly.
+	unsigned int Load(const char *array, unsigned int length) {
+		//Destroy old data.
+		Cleanup();
+		Init();
+
+		//Restore some attributes.
+		compressionUsed = (bool)*array++;
+
+		assert(sizeof(T) == 1); //For now only support characters.
+		removedElement = *(T*)array;
+		array += sizeof(T);
+
+		originalLength = *(unsigned int*)array;
+		array += sizeof(unsigned int);
+
+		compressedLength = *(unsigned int*)array;
+		array += sizeof(unsigned int);
+
+		//Allocate memory and copy array.
+		if (compressionUsed) {
+			if(Allocator) {
+				compressedData = (SPARCElement<T, U>*)
+					Allocator(compressedLength * sizeof(SPARCElement<T, U>));
+			} else {
+				compressedData = new SPARCElement<T, U>[compressedLength];
+			}
+			memcpy(compressedData, array, 
+				compressedLength * sizeof(SPARCElement<T, U>));
+		}
+		else {
+			if(Allocator) {
+				decompressedData = (T*)Allocator(
+					compressedLength * sizeof(T));
+			} else {
+				decompressedData = new T[compressedLength];
+			}
+			memcpy(decompressedData, array, compressedLength * sizeof(T));
+		}
+
+		return CompressedSize();
+	}
+
+	//Save state for later restoration.
+	unsigned int Save(char *array, unsigned int length, bool doSwap) {
+		//Figure out how much space is needed.
+		unsigned int size = sizeof(char) + sizeof(T) + 
+			sizeof(unsigned int) + sizeof(unsigned int);
+
+		if (compressionUsed) {
+			size += compressedLength * sizeof(SPARCElement<T, U>);
+		}
+		else {
+			size += compressedLength * sizeof(T);
+		}
+		
+		assert(length >= size);
+		
+		//Save some attributes.
+		*array++ = (char)compressionUsed;
+
+		assert(sizeof(T) == 1); //For now only support characters.
+		*(T*)array = removedElement;
+		array += sizeof(T);
+
+		*(unsigned int*)array = SPARC_SWAP32(originalLength, doSwap);
+		array += sizeof(unsigned int);
+
+		*(unsigned int*)array = SPARC_SWAP32(compressedLength, doSwap);
+		array += sizeof(unsigned int);
+
+		//Store compressed data (or uncompressed data if none exists)
+		if (compressionUsed) {
+			for (unsigned int i = 0; i < compressedLength; ++i) {
+				//Copy the data element.  For now only support characters.
+				((SPARCElement<T, U> *)array)[i].data = compressedData[i].data;
+				
+				//Copy the offset to the next unique element.
+				if (sizeof(U) == 1) {
+					((SPARCElement<T, U> *)array)[i].offset = 
+						compressedData[i].offset;
+				}
+				else if (sizeof(U) == 2) {
+					((SPARCElement<T, unsigned short> *)array)[i].offset = 
+						SPARC_SWAP16(*(unsigned short*)&compressedData[i].offset, 
+						doSwap);
+				}
+				else if (sizeof(U) == 3) {
+					((SPARCElement<T, NotSoShort> *)array)[i].offset = 
+						SPARC_SWAP24(*(NotSoShort*)&compressedData[i].offset, 
+						doSwap);
+				}
+				else if (sizeof(U) == 4) {
+					((SPARCElement<T, unsigned int> *)array)[i].offset = 
+						SPARC_SWAP32(*(unsigned int*)&compressedData[i].offset, 
+						doSwap);
+				}
+			}
+		}
+		else {
+			memcpy(array, decompressedData, compressedLength * sizeof(T));
+		}
+
+		return size;
+	}
+
+	//Compresses this array, returns the compressed size.  Compresses
+	//by eliminating the given element.
+	unsigned int Compress(const T *array, unsigned int length, T removal) {
+
+		unsigned int i;
+		unsigned int numRemove = 0;
+		SPARCElement<T, U> *compress;
+
+		//Destroy old data.
+		Cleanup();
+		Init();
+
+		//Count number of elements to remove.  Can't remove first or
+		//last element (prevents boundary conditions).
+		for(i=1; i<length-1; i++) {
+			if(array[i] == removal) {
+				numRemove++;
+			}
+		}
+
+		compressedLength = length - numRemove;
+		originalLength = length;
+
+		//If we're going to allocate more memory than was originally used,
+		//just store the data.
+		if(sizeof(SPARCElement<T, U>) * compressedLength >= 
+				sizeof(T) * length) {
+			Store(array, length);
+			return CompressedSize();
+		}
+
+		//Allocate memory for compressed elements.
+		if(Allocator) {
+			compressedData = (SPARCElement<T, U>*)
+				Allocator(compressedLength * sizeof(SPARCElement<T, U>));
+		} else {
+			compressedData = new SPARCElement<T, U>[compressedLength];
+		}
+		compressionUsed = true;
+
+		//Fill compressed array.  First and last elements go in no matter
+		//what.
+		compressedData[0].data = array[0];
+		compressedData[0].offset = 0;
+		compress = &compressedData[1];
+		for(i=1; i<length-1; i++) {
+			if(array[i] != removal) {
+				compress->data = array[i];
+				compress->offset = i;
+				compress++;
+			}
+		}
+		compress->data = array[i];
+		compress->offset = i;
+
+		//Store removal value for decompression purposes.
+		removedElement = removal;
+
+		//Store original length for bounds checking.
+		originalLength = length;
+
+		//Return the compressed size.
+		return CompressedSize();
+	}
+
+
+	//Get the compressed data size in bytes, or 0 if nothing stored.
+	unsigned int CompressedSize(void) {
+		return compressedLength * sizeof(SPARCElement<T, U>);
+	}
+
+	//Get the decompressed data starting at offset and ending at
+	//offset + length.  Returns NULL on error.
+	const T *Decompress(unsigned int offset, unsigned int length) {
+
+		SPARCElement<T, U> *decomp = NULL;
+		unsigned int i;
+
+		//If data isn't compressed, just return a pointers.
+		if(!compressionUsed) {
+			return decompressedData + offset;
+		}
+		
+		//If last decompression falls within offset and length, just return
+		//a pointer.
+		if(decompressedData && decompressedOffset <= offset &&
+				decompressedOffset + decompressedLength >= offset + length) {
+			return decompressedData + offset - decompressedOffset;
+		}
+
+
+
+		//Allocate new space for decompression if length has changed.
+		if(length != decompressedLength) {
+			//Destroy old data first.
+			if(decompressedData) {
+				if(Deallocator) {
+					Deallocator(decompressedData);
+				} else {
+					delete [] decompressedData;
+				}
+			}
+
+			if(Allocator) {
+				decompressedData = (T*)Allocator(length * sizeof(T));
+			} else {
+				decompressedData = new T[length];
+			}
+		}
+		decompressedOffset = offset;
+		decompressedLength = length;
+
+		//Find position to start decompressing from.
+		decomp = FindDecompStart(offset);
+
+		if(!decomp) { //should never happen
+			assert(0);
+			return NULL;
+		}
+
+		//Decompress the data.
+		for(i=0; i < length; i++) {
+			if(decomp->offset == i + offset) {
+				decompressedData[i] = decomp->data;
+				decomp++;
+			} else {
+				decompressedData[i] = removedElement;
+			}
+		}
+
+		return decompressedData;
+	}
+};
+
+
+//The user-interface to SPARC.  Automatically selects the best core based
+//on data size.
+template <class T>
+class SPARC
+{
+private:
+	void *core;
+	unsigned char offsetBytes;
+
+	//Memory allocators.
+	void* (*Allocator)(unsigned int size);
+	void (*Deallocator)(void *ptr);
+
+public:
+	SPARC(void) {
+		core = NULL;
+		offsetBytes = 0;
+		Allocator = NULL;
+		Deallocator = NULL;
+	}
+
+	~SPARC(void) {
+		Release();
+	};
+
+	void SetAllocator(void* (*alloc)(unsigned int size),
+			void (*dealloc)(void *ptr)) {
+		Allocator = alloc;
+		Deallocator = dealloc;
+	}
+
+	//Select a core, cast it to the right type and return the size.
+	unsigned int CompressedSize(void) {
+		if(!core) {
+			return 0;
+		}
+
+		switch(offsetBytes) {
+		case 1:
+			return ((SPARCCore<T, unsigned char>*)core)->CompressedSize();
+		case 2:
+			return ((SPARCCore<T, unsigned short>*)core)->CompressedSize();
+		case 3:
+			return ((SPARCCore<T, NotSoShort>*)core)->CompressedSize();
+		case 4:
+			return ((SPARCCore<T, unsigned int>*)core)->CompressedSize();
+		}
+
+		return 0;
+	}
+
+	//Always use the same core type since we won't be compressing.
+	unsigned int Store(const T *array, unsigned int length)
+	{
+		Release();
+		offsetBytes = 1;
+		core = new SPARCCore<T, unsigned char>;
+		((SPARCCore<T, unsigned char>*)core)->
+			SetAllocator(Allocator, Deallocator);
+		return ((SPARCCore<T, unsigned char>*)core)-> Store(array, length);
+	}
+
+	//Load compressed data directly.
+	unsigned int Load(const char *array, unsigned int length) {
+		Release();
+
+		offsetBytes = *array++;
+
+		switch (offsetBytes) {
+		case 1:
+			core = new SPARCCore<T, unsigned char>;
+			((SPARCCore<T, unsigned char>*)core)->
+				SetAllocator(Allocator, Deallocator);
+			return ((SPARCCore<T, unsigned char>*)core)->
+				Load(array, length-1);
+		case 2:
+			core = new SPARCCore<T, unsigned short>;
+			((SPARCCore<T, unsigned short>*)core)->
+				SetAllocator(Allocator, Deallocator);
+			return ((SPARCCore<T, unsigned short>*)core)->
+				Load(array, length-1);
+		case 3:
+			core = new SPARCCore<T, NotSoShort>;
+			((SPARCCore<T, NotSoShort>*)core)->
+				SetAllocator(Allocator, Deallocator);
+			return ((SPARCCore<T, NotSoShort>*)core)->
+				Load(array, length-1);
+		case 4:
+			core = new SPARCCore<T, unsigned int>;
+			((SPARCCore<T, unsigned int>*)core)->
+				SetAllocator(Allocator, Deallocator);
+			return ((SPARCCore<T, unsigned int>*)core)->
+				Load(array, length-1);
+		default:
+			assert(false);
+			return 0;
+		}
+	}
+
+	//Save compressed data into array.
+	unsigned int Save(char *array, unsigned int length, bool doSwap) {
+		*array++ = offsetBytes;
+
+		switch (offsetBytes) {
+		case 1:
+			return ((SPARCCore<T, unsigned char>*)core)->
+				Save(array, length-1, doSwap);
+		case 2:
+			return ((SPARCCore<T, unsigned short>*)core)->
+				Save(array, length-1, doSwap);
+		case 3:
+			return ((SPARCCore<T, NotSoShort>*)core)->
+				Save(array, length-1, doSwap);
+		case 4:
+			return ((SPARCCore<T, unsigned int>*)core)->
+				Save(array, length-1, doSwap);
+		default:
+			assert(false);
+			return 0;
+		}
+	}
+
+	//Create the smallest core possible for the given data.
+	unsigned int Compress(const T *array, unsigned int length, T removal) {
+		Release();
+
+		if(length < 256) {
+			offsetBytes = 1;
+			core = new SPARCCore<T, unsigned char>;
+			((SPARCCore<T, unsigned char>*)core)->
+				SetAllocator(Allocator, Deallocator);
+			return ((SPARCCore<T, unsigned char>*)core)->
+				Compress(array, length, removal);
+		} else if(length < 65536) {
+			offsetBytes = 2;
+			core = new SPARCCore<T, unsigned short>;
+			((SPARCCore<T, unsigned short>*)core)->
+				SetAllocator(Allocator, Deallocator);
+			return ((SPARCCore<T, unsigned short>*)core)->
+				Compress(array, length, removal);
+		} else if(length < 16777216) {
+			offsetBytes = 3;
+			core = new SPARCCore<T, NotSoShort>;
+			((SPARCCore<T, NotSoShort>*)core)->
+				SetAllocator(Allocator, Deallocator);
+			return ((SPARCCore<T, NotSoShort>*)core)->
+				Compress(array, length, removal);
+		} else {
+			offsetBytes = 4;
+			core = new SPARCCore<T, unsigned int>;
+			((SPARCCore<T, unsigned int>*)core)->
+				SetAllocator(Allocator, Deallocator);
+			return ((SPARCCore<T, unsigned int>*)core)->
+				Compress(array, length, removal);
+		}
+	}
+
+	//Cast to the correct core type and decompress.
+	const T *Decompress(unsigned int offset, unsigned int length) {
+		if(!core) {
+			return NULL;
+		}
+
+		switch(offsetBytes) {
+		case 1:
+			return ((SPARCCore<T, unsigned char>*)core)->
+				Decompress(offset, length);
+		case 2:
+			return ((SPARCCore<T, unsigned short>*)core)->
+				Decompress(offset, length);
+		case 3:
+			return ((SPARCCore<T, NotSoShort>*)core)->
+				Decompress(offset, length);
+		case 4:
+			return ((SPARCCore<T, unsigned int>*)core)->
+				Decompress(offset, length);
+		}
+
+		return NULL;
+	}
+
+	//Destroy all compressed data and the current decompressed buffer.
+	void Release(void) {
+		if(core) {
+			switch(offsetBytes) {
+			case 1:
+				delete (SPARCCore<T, unsigned char>*)core;
+				break;
+			case 2:
+				delete (SPARCCore<T, unsigned short>*)core;
+				break;
+			case 3:
+				delete (SPARCCore<T, NotSoShort>*)core;
+				break;
+			case 4:
+				delete (SPARCCore<T, unsigned int>*)core;
+				break;
+			}
+			core = NULL;
+		}
+	}
+};
+
+#endif
diff --git a/code/qcommon/sstring.h b/code/qcommon/sstring.h
new file mode 100644
index 0000000..13d4196
--- /dev/null
+++ b/code/qcommon/sstring.h
@@ -0,0 +1,120 @@
+// Filename:-	sstring.h
+//
+// Gil's string template, used to replace Microsoft's <string> vrsion which doesn't compile under certain stl map<>
+//	conditions...
+
+
+#ifndef SSTRING_H
+#define SSTRING_H
+
+
+template<int MaxSize>
+class sstring
+{
+	struct SStorage
+	{
+		char data[MaxSize];
+	};
+	SStorage mStorage;
+public:
+/* don't figure we need this
+	template<int oMaxSize>
+	sstring(const sstring<oMaxSize> &o)
+	{
+		assert(strlen(o.mStorage.data)<MaxSize);
+		strcpy(mStorage.data,o.mStorage.data);
+	}
+*/	
+	sstring(const sstring<MaxSize> &o)
+	{
+		//strcpy(mStorage.data,o.mStorage.data);
+		Q_strncpyz(mStorage.data,o.mStorage.data,sizeof(mStorage.data),qtrue);
+	}
+	sstring(const char *s)
+	{
+		//assert(strlen(s)<MaxSize);
+		//strcpy(mStorage.data,s);
+		Q_strncpyz(mStorage.data,s,sizeof(mStorage.data),qtrue);
+	}
+	sstring()
+	{
+		mStorage.data[0]=0;
+	}
+/* don't figure we need this
+	template<int oMaxSize>
+	sstring<oMaxSize> & operator =(const sstring<oMaxSize> &o)
+	{
+		assert(strlen(o.mStorage.data)<MaxSize);
+		strcpy(mStorage.data,o.mStorage.data);
+		return *this;
+	}
+*/	
+	sstring<MaxSize> & operator=(const sstring<MaxSize> &o)
+	{
+		//strcpy(mStorage.data,o.mStorage.data);
+		Q_strncpyz(mStorage.data,o.mStorage.data,sizeof(mStorage.data),qtrue);
+		return *this;
+	}
+	sstring<MaxSize> & operator=(const char *s)
+	{
+		assert(strlen(s)<MaxSize);
+		//strcpy(mStorage.data,s);
+		Q_strncpyz(mStorage.data,s,sizeof(mStorage.data),qtrue);
+		return *this;
+	}
+	char *c_str()
+	{
+		return mStorage.data;
+	}	
+	const char *c_str() const
+	{
+		return mStorage.data;
+	}	
+	int capacity() const
+	{
+		return MaxSize;	// not sure if this should be MaxSize-1? depends if talking bytes or strlen space I guess
+	}
+	int length() const
+	{
+		return strlen(mStorage.data);
+	}
+	bool operator==(const sstring<MaxSize> &o) const
+	{
+		if (!strcmpi(mStorage.data,o.mStorage.data))
+		{
+			return true;
+		}
+		return false;
+	}
+	bool operator!=(const sstring<MaxSize> &o) const
+	{
+		if (strcmpi(mStorage.data,o.mStorage.data)!=0)
+		{
+			return true;
+		}
+		return false;
+	}
+	bool operator<(const sstring<MaxSize> &o) const
+	{
+		if (strcmpi(mStorage.data,o.mStorage.data)<0)
+		{
+			return true;
+		}
+		return false;
+	}
+	bool operator>(const sstring<MaxSize> &o) const
+	{
+		if (strcmpi(mStorage.data,o.mStorage.data)>0)
+		{
+			return true;
+		}
+		return false;
+	}
+};
+
+typedef sstring<MAX_QPATH> sstring_t;
+
+#endif	// #ifndef SSTRING_H
+
+/////////////////// eof ////////////////////
+
diff --git a/code/qcommon/stringed_ingame.cpp b/code/qcommon/stringed_ingame.cpp
new file mode 100644
index 0000000..5e77588
--- /dev/null
+++ b/code/qcommon/stringed_ingame.cpp
@@ -0,0 +1,1264 @@
+// Filename:-	stringed_ingame.cpp
+//
+// This file is designed to be pasted into each game project that uses the StringEd package's files.
+//  You can alter the way it does things by (eg) replacing STL with RATL, BUT LEAVE THE OVERALL
+//	FUNCTIONALITY THE SAME, or if I ever make any funadamental changes to the way the package works
+//	then you're going to be SOOL (shit out of luck ;-)...
+//
+
+//////////////////////////////////////////////////
+//
+// stuff common to all qcommon files...
+#include "../server/server.h"
+#include "../game/q_shared.h"
+#include "qcommon.h"
+//
+//////////////////////////////////////////////////
+
+
+#pragma warning ( disable : 4511 )			// copy constructor could not be generated
+#pragma warning ( disable : 4512 )			// assignment operator could not be generated
+#pragma warning ( disable : 4663 )			// C++ language change: blah blah template crap blah blah
+#include "stringed_ingame.h"
+#include "stringed_interface.h"
+
+///////////////////////////////////////////////
+//
+// some STL stuff...
+#pragma warning ( disable : 4786 )			// disable the usual stupid and pointless STL warning
+#include <list>
+#include <map>
+#include <set>
+#include <string>
+#include <vector>
+using namespace std;
+
+typedef vector<string>	vStrings_t;
+typedef vector<int>		vInts_t;
+//
+///////////////////////////////////////////////
+
+cvar_t	*se_language = NULL;
+cvar_t	*se_debug = NULL;
+cvar_t  *sp_leet = NULL;	// kept as 'sp_' for JK2 compat.
+
+#define __DEBUGOUT(_string)	OutputDebugString(_string)
+#define __ASSERT(_blah)		assert(_blah)
+
+typedef struct SE_Entry_s
+{
+	string		m_strString;
+	string		m_strDebug;	// english and/or "#same", used for debugging only. Also prefixed by "SE:" to show which strings go through StringEd (ie aren't hardwired)
+	int			m_iFlags;
+
+	SE_Entry_s()
+	{
+		m_iFlags = 0;
+	}
+
+} SE_Entry_t;
+
+
+typedef map <string, SE_Entry_t> mapStringEntries_t;
+
+class CStringEdPackage
+{
+private:
+
+	SE_BOOL				m_bEndMarkerFound_ParseOnly;
+	string				m_strCurrentEntryRef_ParseOnly;
+	string				m_strCurrentEntryEnglish_ParseOnly;
+	string				m_strCurrentFileRef_ParseOnly;
+	string				m_strLoadingLanguage_ParseOnly;	// eg "german"
+	SE_BOOL				m_bLoadingEnglish_ParseOnly;
+
+public:
+
+	CStringEdPackage()
+	{
+		Clear( SE_FALSE );
+	}
+
+	~CStringEdPackage()
+	{
+		Clear( SE_FALSE );
+	}
+
+	mapStringEntries_t	m_StringEntries;	// needs to be in public space now
+	SE_BOOL				m_bLoadDebug;		// ""
+	//
+	// flag stuff...
+	//
+	vector <string>		m_vstrFlagNames;
+	map	<string,int>	m_mapFlagMasks;
+
+	void	Clear( SE_BOOL bChangingLanguages );
+	void	SetupNewFileParse( LPCSTR psFileName, SE_BOOL bLoadDebug );
+	SE_BOOL	ReadLine( LPCSTR &psParsePos, char *psDest );
+	LPCSTR	ParseLine( LPCSTR psLine );
+	int		GetFlagMask( LPCSTR psFlagName );
+	LPCSTR	ExtractLanguageFromPath( LPCSTR psFileName );
+	SE_BOOL	EndMarkerFoundDuringParse( void )
+	{
+		return m_bEndMarkerFound_ParseOnly;
+	}
+
+private:
+
+	void	AddEntry( LPCSTR psLocalReference );
+	int		GetNumStrings(void);
+	void	SetString( LPCSTR psLocalReference, LPCSTR psNewString, SE_BOOL bEnglishDebug );
+	SE_BOOL	SetReference( int iIndex, LPCSTR psNewString );
+	void	AddFlagReference( LPCSTR psLocalReference, LPCSTR psFlagName );
+	LPCSTR	GetCurrentFileName(void);
+	LPCSTR	GetCurrentReference_ParseOnly( void );
+	SE_BOOL	CheckLineForKeyword( LPCSTR psKeyword, LPCSTR &psLine);
+	LPCSTR	InsideQuotes( LPCSTR psLine );
+	LPCSTR	ConvertCRLiterals_Read( LPCSTR psString );
+	void	REMKill( char *psBuffer );
+	char	*Filename_PathOnly( LPCSTR psFilename );
+	char	*Filename_WithoutPath(LPCSTR psFilename);
+	char	*Filename_WithoutExt(LPCSTR psFilename);
+};
+
+CStringEdPackage TheStringPackage;
+
+
+void CStringEdPackage::Clear( SE_BOOL bChangingLanguages )
+{
+	m_StringEntries.clear();
+
+	if ( !bChangingLanguages )
+	{
+		// if we're changing languages, then I'm going to leave these alone. This is to do with any (potentially) cached
+		//	flag bitmasks on the game side. It shouldn't matter since all files are written out at once using the build
+		//	command in StringEd. But if ever someone changed a file by hand, or added one, or whatever, and it had a 
+		//	different set of flags declared, or the strings were in a different order, then the flags might also change
+		//	the order I see them in, and hence their indexes and masks. This should never happen unless people mess with
+		//	the .STR files by hand and delete some, but this way makes sure it'll all work just in case...
+		//
+		// ie. flags stay defined once they're defined, and only the destructor (at app-end) kills them.
+		//
+		m_vstrFlagNames.clear();
+		m_mapFlagMasks.clear();
+	}
+
+	m_bEndMarkerFound_ParseOnly = SE_FALSE;
+	m_strCurrentEntryRef_ParseOnly = "";
+	m_strCurrentEntryEnglish_ParseOnly = "";
+	//
+	// the other vars are cleared in SetupNewFileParse(), and are ok to not do here.
+	//
+}
+
+
+
+// loses anything after the path (if any), (eg) "dir/name.bmp" becomes "dir"
+// (copes with either slash-scheme for names)
+//
+// (normally I'd call another function for this, but this is supposed to be engine-independant,
+//	 so a certain amount of re-invention of the wheel is to be expected...)
+//
+char *CStringEdPackage::Filename_PathOnly(LPCSTR psFilename)
+{
+	static char sString[ iSE_MAX_FILENAME_LENGTH ];
+
+	strcpy(sString,psFilename);	
+		
+	char *p1= strrchr(sString,'\\');
+	char *p2= strrchr(sString,'/');
+	char *p = (p1>p2)?p1:p2;
+	if (p)
+		*p=0;
+
+	return sString;
+}
+
+
+// returns (eg) "dir/name" for "dir/name.bmp"
+// (copes with either slash-scheme for names)
+//
+// (normally I'd call another function for this, but this is supposed to be engine-independant,
+//	 so a certain amount of re-invention of the wheel is to be expected...)
+//
+char *CStringEdPackage::Filename_WithoutExt(LPCSTR psFilename)
+{
+	static char sString[ iSE_MAX_FILENAME_LENGTH ];
+
+	strcpy(sString,psFilename);
+
+	char *p = strrchr(sString,'.');		
+	char *p2= strrchr(sString,'\\');
+	char *p3= strrchr(sString,'/');
+
+	// special check, make sure the first suffix we found from the end wasn't just a directory suffix (eg on a path'd filename with no extension anyway)
+	//
+	if (p && 
+		(p2==0 || (p2 && p>p2)) &&
+		(p3==0 || (p3 && p>p3))
+		)
+		*p=0;	
+
+	return sString;
+}
+
+// returns actual filename only, no path
+// (copes with either slash-scheme for names)
+//
+// (normally I'd call another function for this, but this is supposed to be engine-independant,
+//	 so a certain amount of re-invention of the wheel is to be expected...)
+//
+char *CStringEdPackage::Filename_WithoutPath(LPCSTR psFilename)
+{
+	static char sString[ iSE_MAX_FILENAME_LENGTH ];
+
+	LPCSTR psCopyPos = psFilename;
+	
+	while (*psFilename)
+	{
+		if (*psFilename == '/' || *psFilename == '\\')
+			psCopyPos = psFilename+1;
+		psFilename++;
+	}
+
+	strcpy(sString,psCopyPos);
+
+	return sString;
+}
+
+
+LPCSTR CStringEdPackage::ExtractLanguageFromPath( LPCSTR psFileName )
+{
+	return Filename_WithoutPath( Filename_PathOnly( psFileName ) );
+}
+
+
+void CStringEdPackage::SetupNewFileParse( LPCSTR psFileName, SE_BOOL bLoadDebug )
+{
+	char sString[ iSE_MAX_FILENAME_LENGTH ];
+
+	strcpy(sString, Filename_WithoutPath( Filename_WithoutExt( psFileName ) ));
+	Q_strupr(sString);
+
+	m_strCurrentFileRef_ParseOnly = sString;	// eg "OBJECTIVES"
+	m_strLoadingLanguage_ParseOnly = ExtractLanguageFromPath( psFileName );
+	m_bLoadingEnglish_ParseOnly = (!stricmp( m_strLoadingLanguage_ParseOnly.c_str(), "english" )) ? SE_TRUE : SE_FALSE;
+	m_bLoadDebug = bLoadDebug;
+}
+
+
+// returns SE_TRUE if supplied keyword found at line start (and advances supplied ptr past any whitespace to next arg (or line end if none),
+//
+//	else returns SE_FALSE...
+//
+SE_BOOL CStringEdPackage::CheckLineForKeyword( LPCSTR psKeyword, LPCSTR &psLine)
+{
+	if (!Q_stricmpn(psKeyword, psLine, strlen(psKeyword)) )
+	{
+		psLine += strlen(psKeyword);
+
+		// skip whitespace to arrive at next item...
+		//
+		while ( *psLine == '\t' || *psLine == ' ' )
+		{
+			psLine++;
+		}
+		return SE_TRUE;
+	}
+
+	return SE_FALSE;
+}
+
+// change "\n" to '\n' (i.e. 2-byte char-string to 1-byte ctrl-code)...
+//  (or "\r\n" in editor)
+//
+LPCSTR CStringEdPackage::ConvertCRLiterals_Read( LPCSTR psString )
+{
+	static string str;
+	str = psString;
+	int iLoc;
+	while ( (iLoc = str.find("\\n")) != -1 )
+	{
+		str[iLoc  ] = '\n';
+		str.erase( iLoc+1,1 );
+	}
+
+	return str.c_str();
+}
+
+
+// kill off any "//" onwards part in the line, but NOT if it's inside a quoted string...
+//
+void CStringEdPackage::REMKill( char *psBuffer )
+{
+	char *psScanPos = psBuffer;
+	char *p;
+	int iDoubleQuotesSoFar = 0;
+
+	// scan forwards in case there are more than one (and the first is inside quotes)...
+	//
+	while ( (p=strstr(psScanPos,"//")) != NULL)
+	{
+		// count the number of double quotes before this point, if odd number, then we're inside quotes...
+		//
+		int iDoubleQuoteCount = iDoubleQuotesSoFar;
+
+		for (int i=0; i<p-psScanPos; i++)
+		{
+			if (psScanPos[i] == '"')
+			{
+				iDoubleQuoteCount++;
+			}
+		}
+		if (!(iDoubleQuoteCount&1))
+		{
+			// not inside quotes, so kill line here...
+			//			
+			*p='\0';
+			//
+			// and remove any trailing whitespace...
+			//
+			if (psScanPos[0])	// any strlen? (else access violation with -1 below)
+			{
+				int iWhiteSpaceScanPos = strlen(psScanPos)-1;
+				while (iWhiteSpaceScanPos>=0 && isspace(psScanPos[iWhiteSpaceScanPos]))
+				{
+					psScanPos[iWhiteSpaceScanPos--] = '\0';
+				}
+			}
+
+			return;
+		}
+		else
+		{
+			// inside quotes (blast), oh well, skip past and keep scanning...
+			//
+			psScanPos = p+1;
+			iDoubleQuotesSoFar = iDoubleQuoteCount;
+		}
+	}
+}
+
+// returns true while new lines available to be read...
+//
+SE_BOOL CStringEdPackage::ReadLine( LPCSTR &psParsePos, char *psDest )
+{
+	if (psParsePos[0])
+	{	
+		LPCSTR psLineEnd = strchr(psParsePos, '\n');
+		if (psLineEnd)
+		{
+			int iCharsToCopy = (psLineEnd - psParsePos);
+			strncpy(psDest, psParsePos, iCharsToCopy);
+					psDest[iCharsToCopy] = '\0';
+			psParsePos += iCharsToCopy;
+			while (*psParsePos && strchr("\r\n",*psParsePos))
+			{
+				psParsePos++;	// skip over CR or CR/LF pairs
+			}
+		}
+		else
+		{
+			// last line...
+			//
+			strcpy(psDest, psParsePos);
+			psParsePos += strlen(psParsePos);
+		}
+
+		// clean up the line...
+		//
+		if (psDest[0])
+		{
+			int iWhiteSpaceScanPos = strlen(psDest)-1;
+			while (iWhiteSpaceScanPos>=0 && isspace(psDest[iWhiteSpaceScanPos]))
+			{
+				psDest[iWhiteSpaceScanPos--] = '\0';
+			}
+
+			REMKill( psDest );
+		}
+		return SE_TRUE;
+	}
+
+	return SE_FALSE;
+}
+
+// remove any outside quotes from this supplied line, plus any leading or trailing whitespace...
+//
+LPCSTR CStringEdPackage::InsideQuotes( LPCSTR psLine )
+{
+	// I *could* replace this string object with a declared array, but wasn't sure how big to leave it, and it'd have to
+	//	be static as well, hence permanent. (problem on consoles?)
+	//
+	static	string	str;
+					str = "";	// do NOT join to above line
+
+	// skip any leading whitespace...
+	//
+	while (*psLine == ' ' || *psLine == '\t')
+	{
+		psLine++;
+	}
+
+	// skip any leading quote...
+	//
+	if (*psLine == '"')
+	{
+		psLine++;
+	}
+
+	// assign it...
+	//
+	str = psLine;
+
+	if (psLine[0])
+	{
+		// lose any trailing whitespace...
+		//
+		while (	str.c_str()[ strlen(str.c_str()) -1 ] == ' ' ||
+				str.c_str()[ strlen(str.c_str()) -1 ] == '\t'
+				)
+		{
+			str.erase( strlen(str.c_str()) -1, 1);
+		}
+
+		// lose any trailing quote...
+		//
+		if (str.c_str()[ strlen(str.c_str()) -1 ] == '"')
+		{
+			str.erase( strlen(str.c_str()) -1, 1);
+		}
+	}
+
+	// and return it...
+	//
+	return str.c_str();
+}
+
+
+// returns flag bitmask (eg 00000010b), else 0 for not found
+//
+int CStringEdPackage::GetFlagMask( LPCSTR psFlagName )
+{
+	map <string, int>::iterator itFlag = m_mapFlagMasks.find( psFlagName );
+	if ( itFlag != m_mapFlagMasks.end() )
+	{
+		int &iMask = (*itFlag).second;
+		return iMask;
+	}
+
+	return 0;
+}
+
+
+void CStringEdPackage::AddFlagReference( LPCSTR psLocalReference, LPCSTR psFlagName )
+{
+	// add the flag to the list of known ones...
+	//
+	int iMask = GetFlagMask( psFlagName );
+	if (iMask == 0)
+	{
+		m_vstrFlagNames.push_back( psFlagName );
+		iMask = 1 << (m_vstrFlagNames.size()-1);
+		m_mapFlagMasks[ psFlagName ] = iMask;
+	}
+	//
+	// then add the reference to this flag to the currently-parsed reference...
+	//
+	mapStringEntries_t::iterator itEntry = m_StringEntries.find( va("%s_%s",m_strCurrentFileRef_ParseOnly.c_str(), psLocalReference) );
+	if (itEntry != m_StringEntries.end())
+	{
+		SE_Entry_t &Entry = (*itEntry).second;
+		Entry.m_iFlags |= iMask;
+	}
+}
+
+// this copes with both foreigners using hi-char values (eg the french using 0x92 instead of 0x27
+//  for a "'" char), as well as the fact that our buggy fontgen program writes out zeroed glyph info for
+//	some fonts anyway (though not all, just as a gotcha).
+//
+// New bit, instead of static buffer (since XBox guys are desperately short of mem) I return a malloc'd buffer now,
+//	so remember to free it!
+//
+static char *CopeWithDumbStringData( LPCSTR psSentence, LPCSTR psThisLanguage )
+{
+	const int iBufferSize = strlen(psSentence)*3;	// *3 to allow for expansion of anything even stupid string consisting entirely of elipsis chars
+	char *psNewString = (char *) Z_Malloc(iBufferSize, TAG_TEMP_WORKSPACE, qfalse);	
+	Q_strncpyz(psNewString, psSentence, iBufferSize);
+
+	// this is annoying, I have to just guess at which languages to do it for (ie NOT ASIAN/MBCS!!!) since the 
+	//	string system was deliberately (and correctly) designed to not know or care whether it was doing SBCS 
+	//	or MBCS languages, because it was never envisioned that I'd have to clean up other people's mess.
+	//
+	// Ok, bollocks to it, this will have to do. Any other languages that come later and have bugs in their text can
+	//	get fixed by them typing it in properly in the first place...
+	//
+	if (!stricmp(psThisLanguage,"ENGLISH") ||
+		!stricmp(psThisLanguage,"FRENCH") ||
+		!stricmp(psThisLanguage,"GERMAN") ||
+		!stricmp(psThisLanguage,"ITALIAN") ||
+		!stricmp(psThisLanguage,"SPANISH") ||
+		!stricmp(psThisLanguage,"POLISH") ||
+		!stricmp(psThisLanguage,"RUSSIAN")
+		)
+	{
+		char *p;
+
+	//	strXLS_Speech.Replace(va("%c",0x92),va("%c",0x27));	// "'"
+		while ((p=strchr(psNewString,0x92))!=NULL)  // "rich" (and illegal) apostrophe
+		{
+			*p = 0x27;
+		}
+
+	//	strXLS_Speech.Replace(va("%c",0x93),"\"");			// smart quotes -> '"'
+		while ((p=strchr(psNewString,0x93))!=NULL)
+		{
+			*p = '"';
+		}
+
+	//	strXLS_Speech.Replace(va("%c",0x94),"\"");			// smart quotes -> '"'
+		while ((p=strchr(psNewString,0x94))!=NULL)
+		{
+			*p = '"';
+		}
+
+	//	strXLS_Speech.Replace(va("%c",0x0B),".");			// full stop
+		while ((p=strchr(psNewString,0x0B))!=NULL)
+		{
+			*p = '.';
+		}
+
+	//	strXLS_Speech.Replace(va("%c",0x85),"...");			// "..."-char ->  3-char "..."
+		while ((p=strchr(psNewString,0x85))!=NULL)  // "rich" (and illegal) apostrophe
+		{			
+			memmove(p+2,p,strlen(p));
+			*p++ = '.';
+			*p++ = '.';
+			*p   = '.';
+		}
+
+	//	strXLS_Speech.Replace(va("%c",0x91),va("%c",0x27));	// "'"
+		while ((p=strchr(psNewString,0x91))!=NULL)
+		{
+			*p = 0x27;
+		}
+
+	//	strXLS_Speech.Replace(va("%c",0x96),va("%c",0x2D));	// "-"
+		while ((p=strchr(psNewString,0x96))!=NULL)
+		{
+			*p = 0x2D;
+		}
+
+	//	strXLS_Speech.Replace(va("%c",0x97),va("%c",0x2D));	// "-"
+		while ((p=strchr(psNewString,0x97))!=NULL)
+		{
+			*p = 0x2D;
+		}
+
+		// bug fix for picky grammatical errors, replace "?." with "? "
+		//
+		while ((p=strstr(psNewString,"?."))!=NULL)
+		{
+			p[1] = ' ';
+		}
+
+		// StripEd and our print code don't support tabs...
+		//
+		while ((p=strchr(psNewString,0x09))!=NULL)
+		{
+			*p = ' ';
+		}
+	}
+
+	return psNewString;
+}
+
+// return is either NULL for good else error message to display...
+//
+LPCSTR CStringEdPackage::ParseLine( LPCSTR psLine )
+{
+	LPCSTR psErrorMessage = NULL;
+
+	if (psLine)
+	{
+		if (CheckLineForKeyword( sSE_KEYWORD_VERSION, psLine ))
+		{
+			// VERSION 	"1"
+			//
+			LPCSTR psVersionNumber = InsideQuotes( psLine );
+			int		iVersionNumber = atoi( psVersionNumber );
+			
+			if (iVersionNumber != iSE_VERSION)
+			{
+				psErrorMessage = va("Unexpected version number %d, expecting %d!\n", iVersionNumber, iSE_VERSION);
+			}
+		}
+		else
+		if (	CheckLineForKeyword(sSE_KEYWORD_CONFIG, psLine)
+			||	CheckLineForKeyword(sSE_KEYWORD_FILENOTES, psLine)
+			||	CheckLineForKeyword(sSE_KEYWORD_NOTES, psLine)
+			)
+		{
+			// not used ingame, but need to absorb the token
+		}
+		else
+		if (CheckLineForKeyword(sSE_KEYWORD_REFERENCE, psLine))
+		{
+			// REFERENCE	GUARD_GOOD_TO_SEE_YOU
+			//
+			LPCSTR psLocalReference = InsideQuotes( psLine );
+			AddEntry( psLocalReference );
+		}
+		else
+		if (CheckLineForKeyword(sSE_KEYWORD_FLAGS, psLine))
+		{
+			// FLAGS 	FLAG_CAPTION FLAG_TYPEMATIC
+			//
+			LPCSTR psReference = GetCurrentReference_ParseOnly();
+			if (psReference[0])
+			{
+				static const char sSeperators[] = " \t";
+				char sFlags[1024]={0};	// 1024 chars should be enough to store 8 flag names
+				strncpy(sFlags, psLine, sizeof(sFlags)-1);
+				char *psToken = strtok( sFlags, sSeperators );
+				while( psToken != NULL )
+				{
+					// psToken = flag name (in caps)
+					//
+					Q_strupr(psToken);	// jic
+					AddFlagReference( psReference, psToken );
+
+					// read next flag for this string...
+					//
+					psToken = strtok( NULL, sSeperators );
+				}
+			}
+			else
+			{
+				psErrorMessage = "Error parsing file: Unexpected \"" sSE_KEYWORD_FLAGS "\"\n";
+			}
+		}
+		else
+		if (CheckLineForKeyword(sSE_KEYWORD_ENDMARKER, psLine))
+		{
+			// ENDMARKER
+			//
+			m_bEndMarkerFound_ParseOnly = SE_TRUE;	// the only major error checking I bother to do (for file truncation)
+		}
+		else
+		if (!Q_stricmpn(sSE_KEYWORD_LANG, psLine, strlen(sSE_KEYWORD_LANG)))
+		{
+			// LANG_ENGLISH 	"GUARD:  Good to see you, sir.  Taylor is waiting for you in the clean tent.  We need to get you suited up.  "
+			//
+			LPCSTR psReference = GetCurrentReference_ParseOnly();
+			if ( psReference[0] )
+			{
+				psLine += strlen(sSE_KEYWORD_LANG);
+
+				// what language is this?...
+				//
+				LPCSTR psWordEnd = psLine;
+				while (*psWordEnd && *psWordEnd != ' ' && *psWordEnd != '\t')
+				{
+					psWordEnd++;
+				}
+				char sThisLanguage[1024]={0};
+				int iCharsToCopy = psWordEnd - psLine;
+				if (iCharsToCopy > sizeof(sThisLanguage)-1)
+				{
+					iCharsToCopy = sizeof(sThisLanguage)-1;
+				}
+				strncpy(sThisLanguage, psLine, iCharsToCopy);	// already declared as {0} so no need to zero-cap dest buffer
+
+				psLine += strlen(sThisLanguage);
+				LPCSTR _psSentence = ConvertCRLiterals_Read( InsideQuotes( psLine ) );
+
+				// Dammit, I hate having to do crap like this just because other people mess up and put
+				//	stupid data in their text, so I have to cope with it. 
+				//
+				// note hackery with _psSentence and psSentence because of const-ness. bleurgh. Just don't ask.
+				//
+				char *psSentence = CopeWithDumbStringData( _psSentence, sThisLanguage );
+
+				if ( m_bLoadingEnglish_ParseOnly )
+				{
+					// if loading just "english", then go ahead and store it...
+					//
+					SetString( psReference, psSentence, SE_FALSE );
+				}
+				else
+				{
+					// if loading a foreign language...
+					//
+					SE_BOOL bSentenceIsEnglish = (!stricmp(sThisLanguage,"english")) ? SE_TRUE: SE_FALSE;	// see whether this is the english master or not
+
+					// this check can be omitted, I'm just being extra careful here...
+					//
+					if ( !bSentenceIsEnglish )
+					{
+						// basically this is just checking that an .STE file override is the same language as the .STR...
+						//
+						if (stricmp( m_strLoadingLanguage_ParseOnly.c_str(), sThisLanguage ))
+						{
+							psErrorMessage = va("Language \"%s\" found when expecting \"%s\"!\n", sThisLanguage, m_strLoadingLanguage_ParseOnly.c_str());
+						}
+					}
+
+					if (!psErrorMessage)
+					{
+						SetString( psReference, psSentence, bSentenceIsEnglish );
+					}
+				}
+
+				Z_Free( psSentence );
+			}
+			else
+			{
+				psErrorMessage = "Error parsing file: Unexpected \"" sSE_KEYWORD_LANG "\"\n";
+			}
+		}
+		else
+		{
+			psErrorMessage = va("Unknown keyword at linestart: \"%s\"\n", psLine);
+		}
+	}
+
+	return psErrorMessage;
+}
+	
+// returns reference of string being parsed, else "" for none.
+//
+LPCSTR CStringEdPackage::GetCurrentReference_ParseOnly( void )
+{
+	return m_strCurrentEntryRef_ParseOnly.c_str();
+}
+	
+// add new string entry (during parse)
+//
+void CStringEdPackage::AddEntry( LPCSTR psLocalReference )
+{
+	// the reason I don't just assign it anyway is because the optional .STE override files don't contain flags, 
+	//	and therefore would wipe out the parsed flags of the .STR file...
+	//
+	mapStringEntries_t::iterator itEntry = m_StringEntries.find( va("%s_%s",m_strCurrentFileRef_ParseOnly.c_str(), psLocalReference) );
+	if (itEntry == m_StringEntries.end())
+	{
+		SE_Entry_t SE_Entry;
+		m_StringEntries[ va("%s_%s", m_strCurrentFileRef_ParseOnly.c_str(), psLocalReference) ] = SE_Entry;
+	}
+	m_strCurrentEntryRef_ParseOnly = psLocalReference;
+}
+
+LPCSTR Leetify( LPCSTR psString )
+{
+	static string str;
+	str = psString;
+	if (sp_leet->integer == 42)	// very specific test, so you won't hit it accidentally
+	{
+		static const
+		char cReplace[]={	'o','0','l','1','e','3','a','4','s','5','t','7','i','!','h','#',
+							'O','0','L','1','E','3','A','4','S','5','T','7','I','!','H','#'	// laziness because of strchr()
+						};
+
+		char *p;
+		for (int i=0; i<sizeof(cReplace); i+=2)
+		{
+			while ((p=strchr(str.c_str(),cReplace[i]))!=NULL)
+				*p = cReplace[i+1];
+		}
+	}
+
+	return str.c_str();
+}
+
+
+void CStringEdPackage::SetString( LPCSTR psLocalReference, LPCSTR psNewString, SE_BOOL bEnglishDebug )
+{
+	mapStringEntries_t::iterator itEntry = m_StringEntries.find( va("%s_%s",m_strCurrentFileRef_ParseOnly.c_str(), psLocalReference) );
+	if (itEntry != m_StringEntries.end())
+	{
+		SE_Entry_t &Entry = (*itEntry).second;
+	
+		if ( bEnglishDebug || m_bLoadingEnglish_ParseOnly)
+		{	
+			// then this is the leading english text of a foreign sentence pair (so it's the debug-key text),
+			//	or it's the only text when it's english being loaded...
+			//
+			Entry.m_strString = Leetify( psNewString );
+			if ( m_bLoadDebug )
+			{
+				Entry.m_strDebug = sSE_DEBUGSTR_PREFIX;
+				Entry.m_strDebug+= /* m_bLoadingEnglish_ParseOnly ? "" : */ psNewString;
+				Entry.m_strDebug+= sSE_DEBUGSTR_SUFFIX;
+			}
+			m_strCurrentEntryEnglish_ParseOnly = psNewString;	// for possible "#same" resolving in foreign later
+		}
+		else
+		{				
+			// then this is foreign text (so check for "#same" resolving)...
+			//
+			if (!stricmp(psNewString, sSE_EXPORT_SAME))
+			{
+				Entry.m_strString = m_strCurrentEntryEnglish_ParseOnly;	// foreign "#same" is now english
+				if (m_bLoadDebug)
+				{
+					Entry.m_strDebug = sSE_DEBUGSTR_PREFIX;
+					Entry.m_strDebug+= sSE_EXPORT_SAME;				// english (debug) is now "#same"
+					Entry.m_strDebug+= sSE_DEBUGSTR_SUFFIX;
+				}
+			}
+			else
+			{
+				Entry.m_strString	= psNewString;							// foreign is just foreign
+			}
+		}
+	}
+	else
+	{
+		__ASSERT(0);	// should never happen
+	}
+}
+
+
+
+// filename is local here, eg:	"strings/german/obj.str"
+//
+// return is either NULL for good else error message to display...
+//
+static LPCSTR SE_Load_Actual( LPCSTR psFileName, SE_BOOL bLoadDebug, SE_BOOL bSpeculativeLoad )
+{
+	LPCSTR psErrorMessage = NULL;
+	
+	unsigned char *psLoadedData = SE_LoadFileData( psFileName );
+	if ( psLoadedData )
+	{
+		// now parse the data...
+		//
+		char *psParsePos = (char *) psLoadedData;
+
+		TheStringPackage.SetupNewFileParse( psFileName, bLoadDebug );
+
+		char sLineBuffer[16384];	// should be enough for one line of text (some of them can be BIG though)
+		while ( !psErrorMessage && TheStringPackage.ReadLine((LPCSTR &) psParsePos, sLineBuffer ) )
+		{
+			if (strlen(sLineBuffer))
+			{
+//				__DEBUGOUT( sLineBuffer );
+//				__DEBUGOUT( "\n" );
+
+				psErrorMessage = TheStringPackage.ParseLine( sLineBuffer );
+			}
+		}
+
+		SE_FreeFileDataAfterLoad( psLoadedData);
+		
+		if (!psErrorMessage && !TheStringPackage.EndMarkerFoundDuringParse())
+		{
+			psErrorMessage = va("Truncated file, failed to find \"%s\" at file end!", sSE_KEYWORD_ENDMARKER);
+		}
+	}
+	else
+	{
+		if ( bSpeculativeLoad )
+		{
+			// then it's ok to not find the file, so do nothing...
+		}
+		else
+		{
+			psErrorMessage = va("Unable to load \"%s\"!", psFileName);
+		}
+	}
+
+	return psErrorMessage;
+}
+
+static LPCSTR SE_GetFoundFile( string &strResult )
+{
+	static char sTemp[1024/*MAX_PATH*/];
+
+	if (!strlen(strResult.c_str()))
+		return NULL;
+	
+	strncpy(sTemp,strResult.c_str(),sizeof(sTemp)-1);
+	sTemp[sizeof(sTemp)-1]='\0';
+
+	char *psSemiColon = strchr(sTemp,';');
+	if (  psSemiColon)
+	{
+		 *psSemiColon = '\0';
+
+		 strResult.erase(0,(psSemiColon-sTemp)+1);
+	}
+	else
+	{
+		// no semicolon found, probably last entry? (though i think even those have them on, oh well)
+		//
+		strResult.erase();
+	}
+
+//	strlwr(sTemp);	// just for consistancy and set<> -> set<> erasure checking etc
+
+	return sTemp;
+}
+
+//////////// API entry points from rest of game.... //////////////////////////////
+
+// filename is local here, eg:	"strings/german/obj.str"
+//
+// return is either NULL for good else error message to display...
+//
+LPCSTR SE_Load( LPCSTR psFileName, SE_BOOL bLoadDebug = SE_TRUE, SE_BOOL bFailIsCritical = SE_TRUE  )
+{
+	////////////////////////////////////////////////////
+	//
+	// ingame here tends to pass in names without paths, but I expect them when doing a language load, so...
+	//
+	char sTemp[1000]={0};
+	if (!strchr(psFileName,'/'))
+	{
+		strcpy(sTemp,sSE_STRINGS_DIR);
+		strcat(sTemp,"/");
+		if (se_language)
+		{
+			strcat(sTemp,se_language->string);
+			strcat(sTemp,"/");
+		}
+	}
+	strcat(sTemp,psFileName);
+	COM_DefaultExtension( sTemp, sizeof(sTemp), sSE_INGAME_FILE_EXTENSION);
+	psFileName = &sTemp[0];
+	//
+	////////////////////////////////////////////////////
+
+
+	LPCSTR psErrorMessage = SE_Load_Actual( psFileName, bLoadDebug, SE_FALSE );
+
+	// check for any corresponding / overriding .STE files and load them afterwards...
+	//
+	if ( !psErrorMessage )
+	{
+		char sFileName[ iSE_MAX_FILENAME_LENGTH ];
+		strncpy( sFileName, psFileName, sizeof(sFileName)-1 );
+				 sFileName[ sizeof(sFileName)-1 ] = '\0';
+		char *p = strrchr( sFileName, '.' );
+		if (p && strlen(p) == strlen(sSE_EXPORT_FILE_EXTENSION))
+		{
+			strcpy( p, sSE_EXPORT_FILE_EXTENSION );
+		
+			psErrorMessage = SE_Load_Actual( sFileName, bLoadDebug, SE_TRUE );
+		}
+	}
+
+	if (psErrorMessage)
+	{
+		if (bFailIsCritical)
+		{
+	//		TheStringPackage.Clear(TRUE);	// Will we want to do this?  Any errors that arise should be fixed immediately
+			Com_Error( ERR_DROP, "SE_Load(): Couldn't load \"%s\"!\n\nError: \"%s\"\n", psFileName, psErrorMessage );
+		}
+		else
+		{
+			Com_DPrintf(S_COLOR_YELLOW "SE_Load(): Couldn't load \"%s\"!\n", psFileName );
+		}
+	}
+
+	return psErrorMessage;
+}
+
+
+// convenience-function for the main GetString call...
+//
+LPCSTR SE_GetString( LPCSTR psPackageReference, LPCSTR psStringReference)
+{
+	char sReference[256];	// will always be enough, I've never seen one more than about 30 chars long
+
+	sprintf(sReference,"%s_%s", psPackageReference, psStringReference);
+
+	return SE_GetString( Q_strupr(sReference) );
+}
+
+
+LPCSTR SE_GetString( LPCSTR psPackageAndStringReference )
+{
+	char sReference[256];	// will always be enough, I've never seen one more than about 30 chars long
+	assert(strlen(psPackageAndStringReference) < sizeof(sReference) );
+	Q_strncpyz(sReference, psPackageAndStringReference, sizeof(sReference) );
+	Q_strupr(sReference);
+
+	mapStringEntries_t::iterator itEntry = TheStringPackage.m_StringEntries.find( sReference );
+	if (itEntry != TheStringPackage.m_StringEntries.end())
+	{
+		SE_Entry_t &Entry = (*itEntry).second;
+
+		if ( se_debug->integer && TheStringPackage.m_bLoadDebug )
+		{
+			return Entry.m_strDebug.c_str();
+		}
+		else
+		{
+			return Entry.m_strString.c_str();
+		}
+	}
+
+	// should never get here, but fall back anyway... (except we DO use this to see if there's a debug-friendly key bind, which may not exist)
+	//
+//	__ASSERT(0);
+	return "";	// you may want to replace this with something based on _DEBUG or not?
+}
+
+
+// convenience-function for the main GetFlags call...
+//
+int	SE_GetFlags ( LPCSTR psPackageReference, LPCSTR psStringReference )
+{
+	char sReference[256];	// will always be enough, I've never seen one more than about 30 chars long
+
+	sprintf(sReference,"%s_%s", psPackageReference, psStringReference);
+
+	return SE_GetFlags( sReference );
+}
+
+int	SE_GetFlags ( LPCSTR psPackageAndStringReference )
+{
+	mapStringEntries_t::iterator itEntry = TheStringPackage.m_StringEntries.find( psPackageAndStringReference );
+	if (itEntry != TheStringPackage.m_StringEntries.end())
+	{
+		SE_Entry_t &Entry = (*itEntry).second;
+
+		return Entry.m_iFlags;
+	}
+
+	// should never get here, but fall back anyway...
+	//
+	__ASSERT(0);
+
+	return 0;
+}
+
+
+int SE_GetNumFlags( void )
+{
+	return TheStringPackage.m_vstrFlagNames.size();
+}
+
+LPCSTR SE_GetFlagName( int iFlagIndex )
+{
+	if ( iFlagIndex < TheStringPackage.m_vstrFlagNames.size())
+	{
+		return TheStringPackage.m_vstrFlagNames[ iFlagIndex ].c_str();
+	}
+
+	__ASSERT(0);
+	return "";
+}
+
+// returns flag bitmask (eg 00000010b), else 0 for not found
+//
+int SE_GetFlagMask( LPCSTR psFlagName )
+{
+	return TheStringPackage.GetFlagMask( psFlagName );
+}
+
+// I could cache the result of this since it won't change during app lifetime unless someone does a build-publish
+//	while you're still ingame. Cacheing would make sense since it can take a while to scan, but I'll leave it and
+//	let whoever calls it cache the results instead. I'll make it known that it's a slow process to call this, but 
+//	whenever anyone calls someone else's code they should assign it to an int anyway, since you've no idea what's
+//	going on. Basically, don't  use this in a FOR loop as the end-condition. Duh.
+//
+// Groan, except for Bob. I mentioned that this was slow and only call it once, but he's calling it from 
+//	every level-load...  Ok, cacheing it is...
+//
+vector <string> gvLanguagesAvailable;
+int SE_GetNumLanguages(void)
+{
+	if ( gvLanguagesAvailable.empty() )
+	{
+		string strResults;
+		/*int iFilesFound = */SE_BuildFileList( 
+												#ifdef _STRINGED
+													va("C:\\Source\\Tools\\StringEd\\test_data\\%s",sSE_STRINGS_DIR)
+												#else
+													sSE_STRINGS_DIR
+												#endif
+												, strResults 
+											);
+
+		set<string> strUniqueStrings;	// laziness <g>
+		LPCSTR p;
+		while ((p=SE_GetFoundFile (strResults)) != NULL)
+		{
+			LPCSTR psLanguage = TheStringPackage.ExtractLanguageFromPath( p );
+
+	//		__DEBUGOUT( p );
+	//		__DEBUGOUT( "\n" );
+	//		__DEBUGOUT( psLanguage );
+	//		__DEBUGOUT( "\n" );
+
+			if (!strUniqueStrings.count( psLanguage ))
+			{
+				strUniqueStrings.insert( psLanguage );
+
+				// if english is available, it should always be first... ( I suppose )
+				//
+				if (!stricmp(psLanguage,"english"))
+				{
+					gvLanguagesAvailable.insert( gvLanguagesAvailable.begin(), psLanguage );
+				}
+				else
+				{
+					gvLanguagesAvailable.push_back( psLanguage );
+				}
+			}
+		}
+	}
+
+	return gvLanguagesAvailable.size();
+}
+
+// SE_GetNumLanguages() must have been called before this...
+//
+LPCSTR SE_GetLanguageName( int iLangIndex )
+{
+	if ( iLangIndex < gvLanguagesAvailable.size() )
+	{
+		return gvLanguagesAvailable[ iLangIndex ].c_str();
+	}
+
+	__ASSERT(0);
+	return "";
+}
+
+// SE_GetNumLanguages() must have been called before this...
+//
+LPCSTR SE_GetLanguageDir( int iLangIndex )
+{
+	if ( iLangIndex < gvLanguagesAvailable.size() )
+	{
+		return va("%s/%s", sSE_STRINGS_DIR, gvLanguagesAvailable[ iLangIndex ].c_str() );
+	}
+
+	__ASSERT(0);
+	return "";
+}
+
+void SE_NewLanguage(void)
+{
+	TheStringPackage.Clear( SE_TRUE );
+}
+
+
+
+// these two functions aren't needed other than to make Quake-type games happy and/or stop memory managers
+//	complaining about leaks if they report them before the global StringEd package object calls it's own dtor.
+//
+// but here they are for completeness's sake I guess...
+//
+void SE_Init(void)
+{
+#ifdef _XBOX	// VVFIXME?
+//	extern void Z_SetNewDeleteTemporary(bool);
+//	Z_SetNewDeleteTemporary(true);
+#endif
+
+	TheStringPackage.Clear( SE_FALSE );
+
+#ifdef _DEBUG
+//	int iNumLanguages = SE_GetNumLanguages();
+#endif
+
+	se_language = Cvar_Get("se_language", "english", CVAR_ARCHIVE | CVAR_NORESTART);
+	se_debug = Cvar_Get("se_debug", "0", 0);
+	sp_leet = Cvar_Get("sp_leet", "0", CVAR_ROM );
+
+	// if doing a buildscript, load all languages...
+	//
+	extern cvar_t *com_buildScript;
+	if (com_buildScript->integer == 2)
+	{
+		int iLanguages = SE_GetNumLanguages();
+		for (int iLang = 0; iLang < iLanguages; iLang++)
+		{
+            LPCSTR psLanguage = SE_GetLanguageName( iLang );	// eg "german"			
+			Com_Printf( "com_buildScript(2): Loading language \"%s\"...\n", psLanguage );
+			SE_LoadLanguage( psLanguage );
+		}
+	}
+
+	LPCSTR psErrorMessage = SE_LoadLanguage( se_language->string );
+	if (psErrorMessage)
+	{
+		Com_Error( ERR_DROP, "SE_Init() Unable to load language: \"%s\"!\nError: \"%s\"\n", se_language->string,psErrorMessage );
+	}
+
+#ifdef _XBOX
+//	Z_SetNewDeleteTemporary(false);
+#endif
+}
+
+void SE_ShutDown(void)
+{
+	TheStringPackage.Clear( SE_FALSE );
+}
+
+
+// returns error message else NULL for ok.
+//
+// Any errors that result from this should probably be treated as game-fatal, since an asset file is fuxored.
+//
+LPCSTR SE_LoadLanguage( LPCSTR psLanguage, SE_BOOL bLoadDebug /* = SE_TRUE */ )
+{
+	LPCSTR psErrorMessage = NULL;
+
+	if (psLanguage && psLanguage[0])
+	{
+		SE_NewLanguage();
+
+		string strResults;
+		/*int iFilesFound = */SE_BuildFileList( 
+												#ifdef _STRINGED
+													va("C:\\Source\\Tools\\StringEd\\test_data\\%s",sSE_STRINGS_DIR)
+												#else
+													sSE_STRINGS_DIR
+												#endif
+												, strResults 
+											);
+
+		LPCSTR p;
+		while ( (p=SE_GetFoundFile (strResults)) != NULL && !psErrorMessage )
+		{
+			LPCSTR psThisLang = TheStringPackage.ExtractLanguageFromPath( p );
+
+			if ( !stricmp( psLanguage, psThisLang ) )
+			{
+				psErrorMessage = SE_Load( p, bLoadDebug );
+			}
+		}
+	}
+	else
+	{
+		__ASSERT( 0 && "SE_LoadLanguage(): Bad language name!" );
+	}
+
+	return psErrorMessage;
+}
+
+
+// called in Com_Frame, so don't take up any time! (can also be called during dedicated)
+//
+// instead of re-loading just the files we've already loaded I'm going to load the whole language (simpler)
+//
+void SE_CheckForLanguageUpdates(void)
+{
+	if (se_language && se_language->modified)
+	{
+		LPCSTR psErrorMessage = SE_LoadLanguage( se_language->string, SE_TRUE );
+		if ( psErrorMessage )
+		{
+			Com_Error( ERR_DROP, psErrorMessage );
+		}
+		se_language->modified = SE_FALSE;
+	}
+}
+
+
+///////////////////////// eof //////////////////////////
diff --git a/code/qcommon/stringed_ingame.h b/code/qcommon/stringed_ingame.h
new file mode 100644
index 0000000..107951c
--- /dev/null
+++ b/code/qcommon/stringed_ingame.h
@@ -0,0 +1,110 @@
+// Filename:-	stringed_ingame.h
+//
+
+#ifndef STRINGED_INGAME_H
+#define	STRINGED_INGAME_H
+
+
+// alter these to suit your own game...
+//
+#define SE_BOOL					qboolean
+#define SE_TRUE					qtrue
+#define SE_FALSE				qfalse
+#define	iSE_MAX_FILENAME_LENGTH	MAX_QPATH
+#define sSE_STRINGS_DIR			"strings"
+#define sSE_DEBUGSTR_PREFIX		"["		// any string you want prefixing onto the debug versions of strings (to spot hardwired english etc)
+#define sSE_DEBUGSTR_SUFFIX		"]"		// ""
+
+extern cvar_t	*se_language;
+
+// some needed text-equates, do not alter these under any circumstances !!!! (unless you're me. Which you're not)
+//
+#define iSE_VERSION					1
+#define sSE_KEYWORD_VERSION			"VERSION"
+#define sSE_KEYWORD_CONFIG			"CONFIG"
+#define sSE_KEYWORD_FILENOTES		"FILENOTES"
+#define sSE_KEYWORD_REFERENCE		"REFERENCE"
+#define sSE_KEYWORD_FLAGS 			"FLAGS"
+#define sSE_KEYWORD_NOTES			"NOTES"
+#define sSE_KEYWORD_LANG			"LANG_"
+#define sSE_KEYWORD_ENDMARKER		"ENDMARKER"
+#define sSE_FILE_EXTENSION			".st"	// editor-only NEVER used ingame, but I wanted all extensions together
+#define sSE_EXPORT_FILE_EXTENSION	".ste"
+#define sSE_INGAME_FILE_EXTENSION	".str"
+#define sSE_EXPORT_SAME				"#same"
+
+
+
+// available API calls...
+//
+typedef const char *LPCSTR;
+
+void	SE_Init				( void );
+void	SE_ShutDown			( void );
+void	SE_CheckForLanguageUpdates(void);
+int		SE_GetNumLanguages	( void );
+LPCSTR	SE_GetLanguageName	( int iLangIndex );	// eg "german"
+LPCSTR	SE_GetLanguageDir	( int iLangIndex );	// eg "strings/german"
+LPCSTR	SE_LoadLanguage		( LPCSTR psLanguage, SE_BOOL bLoadDebug = SE_TRUE );
+void	SE_NewLanguage		( void );
+//
+// for convenience, two ways of getting at the same data...
+//
+LPCSTR	SE_GetString		( LPCSTR psPackageReference, LPCSTR psStringReference);
+LPCSTR	SE_GetString		( LPCSTR psPackageAndStringReference);
+//
+// ditto...
+//
+int		SE_GetFlags			( LPCSTR psPackageReference, LPCSTR psStringReference );
+int		SE_GetFlags			( LPCSTR psPackageAndStringReference );
+//
+// general flag functions... (SEP_GetFlagMask() return should be used with SEP_GetFlags() return)
+//
+int		SE_GetNumFlags		( void );
+LPCSTR	SE_GetFlagName		( int iFlagIndex );
+int		SE_GetFlagMask		( LPCSTR psFlagName );
+
+
+// note that so far the only place in the game that needs to know these is the font system so it can know how to
+//	interpret char codes, for this reason I'm only exposing these simple bool queries...
+//
+inline SE_BOOL Language_IsRussian(void)
+{
+	return (se_language && !Q_stricmp(se_language->string, "russian")) ? SE_TRUE : SE_FALSE;	
+}
+
+inline SE_BOOL Language_IsPolish(void)
+{
+	return (se_language && !Q_stricmp(se_language->string, "polish")) ? SE_TRUE : SE_FALSE;	
+}
+
+inline SE_BOOL Language_IsKorean(void)
+{
+	return (se_language && !Q_stricmp(se_language->string, "korean")) ? SE_TRUE : SE_FALSE;
+}
+
+inline SE_BOOL Language_IsTaiwanese(void)
+{
+	return (se_language && !Q_stricmp(se_language->string, "taiwanese")) ? SE_TRUE : SE_FALSE;
+}
+
+inline SE_BOOL Language_IsJapanese(void)
+{
+	return (se_language && !Q_stricmp(se_language->string, "japanese")) ? SE_TRUE : SE_FALSE;
+}
+
+inline SE_BOOL Language_IsChinese(void)
+{
+	return (se_language && !Q_stricmp(se_language->string, "chinese")) ? SE_TRUE : SE_FALSE;
+}
+
+inline SE_BOOL Language_IsThai(void)
+{
+	return (se_language && !Q_stricmp(se_language->string, "thai")) ? SE_TRUE : SE_FALSE;
+}
+
+
+#endif	// #ifndef STRINGED_INGAME_H
+
+/////////////////// eof ////////////////
+
diff --git a/code/qcommon/stringed_interface.cpp b/code/qcommon/stringed_interface.cpp
new file mode 100644
index 0000000..b23b9fa
--- /dev/null
+++ b/code/qcommon/stringed_interface.cpp
@@ -0,0 +1,215 @@
+// Filename:-	stringed_interface.cpp
+//
+// This file contains functions that StringEd wants to call to do things like load/save, they can be modified
+//	for use ingame, but must remain functionally the same...
+//
+//  Please try and put modifications for whichever games this is used for inside #defines, so I can copy the same file
+//		into each project.
+//
+
+
+//////////////////////////////////////////////////
+//
+// stuff common to all qcommon files...
+#include "../server/server.h"
+#include "../game/q_shared.h"
+#include "qcommon.h"
+//
+//////////////////////////////////////////////////
+
+
+#pragma warning ( disable : 4511 )			// copy constructor could not be generated
+#pragma warning ( disable : 4512 )			// assignment operator could not be generated
+#pragma warning ( disable : 4663 )			// C++ language change: blah blah template crap blah blah
+#include "stringed_interface.h"
+#include "stringed_ingame.h"
+
+#include <string>
+using namespace std;
+
+#ifdef _STRINGED
+#include <stdlib.h>
+#include <memory.h>
+#include "generic.h"
+#endif
+
+
+// this just gets the binary of the file into memory, so I can parse it. Called by main SGE loader
+//
+//  returns either char * of loaded file, else NULL for failed-to-open...
+//
+unsigned char *SE_LoadFileData( const char *psFileName, int *piLoadedLength /* = 0 */)
+{
+	unsigned char *psReturn = NULL;
+	if ( piLoadedLength )
+	{
+		*piLoadedLength = 0;
+	}
+
+#ifdef _STRINGED
+	if (psFileName[1] == ':')
+	{
+		// full-path filename...
+		//
+		FILE *fh = fopen( psFileName, "rb" );
+		if (fh)
+		{
+			long lLength = filesize(fh);
+
+			if (lLength > 0)
+			{
+				psReturn = (unsigned char *) malloc( lLength + 1);
+				if (psReturn)
+				{
+					int iBytesRead = fread( psReturn, 1, lLength, fh );
+					if (iBytesRead != lLength)
+					{
+						// error reading file!!!...
+						//
+						free(psReturn);
+							 psReturn = NULL;
+					}
+					else
+					{
+						psReturn[ lLength ] = '\0';
+						if ( piLoadedLength )
+						{
+							*piLoadedLength = iBytesRead;
+						}
+					}
+					fclose(fh);
+				}
+			}
+		}
+	}
+	else
+#endif
+	{
+		// local filename, so prepend the base dir etc according to game and load it however (from PAK?)
+		//		
+		unsigned char *pvLoadedData;		
+		int iLen = FS_ReadFile( psFileName, (void **)&pvLoadedData );
+
+		if (iLen>0)
+		{
+			psReturn = pvLoadedData;
+			if ( piLoadedLength )
+			{
+				*piLoadedLength = iLen;
+			}
+		}
+	}
+
+	return psReturn;
+}
+
+
+// called by main SGE code after loaded data has been parsedinto internal structures...
+//
+void SE_FreeFileDataAfterLoad( unsigned char *psLoadedFile )
+{
+#ifdef _STRINGED
+	if ( psLoadedFile )
+	{
+		free( psLoadedFile );
+	}
+#else
+	if ( psLoadedFile )
+	{
+		FS_FreeFile( psLoadedFile );
+	}	
+#endif
+}
+
+
+
+
+
+#ifndef _STRINGED
+// quake-style method of doing things since their file-list code doesn't have a 'recursive' flag...
+//
+int giFilesFound;
+static void SE_R_ListFiles( const char *psExtension, const char *psDir, string &strResults )
+{
+//	Com_Printf(va("Scanning Dir: %s\n",psDir));
+
+	char	**sysFiles, **dirFiles;
+	int		numSysFiles, i, numdirs;
+
+	dirFiles = FS_ListFiles( psDir, "/", &numdirs);
+	for (i=0;i<numdirs;i++)
+	{
+		if (dirFiles[i][0] && dirFiles[i][0] != '.')	// skip blanks, plus ".", ".." etc
+		{
+			char	sDirName[MAX_QPATH];
+			sprintf(sDirName, "%s/%s", psDir, dirFiles[i]);
+			//
+			// for some reason the quake filesystem in this game now returns an extra slash on the end,
+			//	didn't used to. Sigh...
+			//
+			if (sDirName[strlen(sDirName)-1] == '/')
+			{
+				sDirName[strlen(sDirName)-1] = '\0';
+			}
+			SE_R_ListFiles( psExtension, sDirName, strResults );
+		}
+	}
+
+	sysFiles = FS_ListFiles( psDir, psExtension, &numSysFiles );
+	for(i=0; i<numSysFiles; i++)
+	{
+		char	sFilename[MAX_QPATH];
+		sprintf(sFilename,"%s/%s", psDir, sysFiles[i]);		
+			
+//		Com_Printf("%sFound file: %s",!i?"\n":"",sFilename);
+
+		strResults += sFilename;
+		strResults += ';';
+		giFilesFound++;
+
+		// read it in...
+		//
+/*		byte *pbData = NULL;
+		int iSize = FS_ReadFile( sFilename, (void **)&pbData);
+
+		if (pbData)
+		{
+
+			FS_FreeFile( pbData );
+		}
+*/
+	}
+	FS_FreeFileList( sysFiles );
+	FS_FreeFileList( dirFiles );
+}
+#endif
+
+
+// replace this with a call to whatever your own code equivalent is.
+//
+// expected result is a ';'-delineated string (including last one) containing file-list search results
+//
+int SE_BuildFileList( const char *psStartDir, string &strResults )
+{
+#ifndef _STRINGED
+	giFilesFound = 0;
+	strResults = "";
+
+	SE_R_ListFiles( sSE_INGAME_FILE_EXTENSION, psStartDir, strResults );
+
+	return giFilesFound;
+#else
+	// .ST files...
+	//
+	int iFilesFound = BuildFileList(	va("%s\\*%s",psStartDir, sSE_INGAME_FILE_EXTENSION),	// LPCSTR psPathAndFilter, 
+										true					// bool bRecurseSubDirs
+										);
+
+	extern string strResult;
+	strResults = strResult;
+	return iFilesFound;
+#endif
+}
+
+/////////////////////// eof ///////////////////////
+
diff --git a/code/qcommon/stringed_interface.h b/code/qcommon/stringed_interface.h
new file mode 100644
index 0000000..a708c24
--- /dev/null
+++ b/code/qcommon/stringed_interface.h
@@ -0,0 +1,21 @@
+// Filename:-	stringed_interface.h
+//
+// These are the functions that get replaced by game-specific ones (or StringEd code) so SGE can access files etc
+//
+
+#ifndef STRINGED_INTERFACE_H
+#define STRINGED_INTERFACE_H
+
+#pragma warning ( disable : 4786 )			// disable the usual stupid and pointless STL warning
+#include <string>
+using namespace std;
+
+unsigned char *	SE_LoadFileData			( const char *psFileName, int *piLoadedLength = 0);
+void			SE_FreeFileDataAfterLoad( unsigned char *psLoadedFile );
+int				SE_BuildFileList		( const char *psStartDir, string &strResults );
+
+#endif	// #ifndef STRINGED_INTERFACE_H
+
+
+////////////////// eof ///////////////////
+
diff --git a/code/qcommon/stv_version.h b/code/qcommon/stv_version.h
new file mode 100644
index 0000000..b0d5cbb
--- /dev/null
+++ b/code/qcommon/stv_version.h
@@ -0,0 +1,13 @@
+// Current version of the single player game
+#include "../win32/autoversion.h"
+
+#ifdef _DEBUG
+	#define	Q3_VERSION		"(debug)JA: v"VERSION_STRING_DOTTED
+#elif defined FINAL_BUILD
+	#define	Q3_VERSION		"JA: v"VERSION_STRING_DOTTED
+#else
+	#define	Q3_VERSION		"(internal)JA: v"VERSION_STRING_DOTTED
+#endif
+// end
+
+
diff --git a/code/qcommon/tags.h b/code/qcommon/tags.h
new file mode 100644
index 0000000..9097b77
--- /dev/null
+++ b/code/qcommon/tags.h
@@ -0,0 +1,54 @@
+// Filename:-	tags.h
+
+// do NOT include-protect this file, or add any fields or labels, because it's included within enums and tables
+//
+// these macro args get "TAG_" prepended on them for enum purposes, and appear as literal strings for "meminfo" command
+
+	TAGDEF(ALL),
+	TAGDEF(HUNKALLOC),					// mem that was formerly from the hunk AFTER the SetMark (ie discarded during vid_reset)
+	TAGDEF(HUNKMISCMODELS),			// sub-hunk alloc to track misc models
+	TAGDEF(FILESYS),					// general filesystem usage
+	TAGDEF(EVENT),
+	TAGDEF(CLIPBOARD),					
+	TAGDEF(LISTFILES),					// for "*.blah" lists
+	TAGDEF(AMBIENTSET),
+	TAGDEF(G_ALLOC),					// used by G_Alloc()
+	TAGDEF(CLIENTS),					// Memory used for client info
+	TAGDEF(STATIC),						// special usage for 1-byte allocations from 0..9 to avoid CopyString() slowdowns during cvar value copies
+	TAGDEF(SMALL),						// used by S_Malloc, but probably more of a hint now. Will be dumped later
+	TAGDEF(MODEL),						// general model usage), includes header-struct-only stuff like 'model_t'
+	TAGDEF(MODEL_MD3),					// specific model types' disk images
+	TAGDEF(MODEL_GLM),					//	   "
+	TAGDEF(MODEL_GLA),					//	   "
+	TAGDEF(ICARUS),						// Memory used internally by the Icarus scripting system
+	TAGDEF(IMAGE_T),					// an image_t struct (no longer on the hunk because of cached texture stuff)
+	TAGDEF(TEMP_WORKSPACE),				// anything like file loading or image workspace that's only temporary
+	TAGDEF(TEMP_TGA),					// image workspace that's only temporary
+	TAGDEF(TEMP_JPG),					// image workspace that's only temporary
+	TAGDEF(TEMP_PNG),					// image workspace that's only temporary
+	TAGDEF(SND_MP3STREAMHDR),			// specific MP3 struct for decoding (about 18..22K each?), not the actual MP3 binary
+	TAGDEF(SND_DYNAMICMUSIC),			// in-mem MP3 files
+	TAGDEF(SND_RAWDATA),				// raw sound data, either MP3 or WAV
+	TAGDEF(GHOUL2),						// Ghoul2 stuff
+	TAGDEF(BSP),						// guess.
+	TAGDEF(BSP_DISKIMAGE),				// temp during loading, to save both server and renderer fread()ing the same file. Only used if not low physical memory (currently 96MB)
+	TAGDEF(GP2),						// generic parser 2
+	TAGDEF(SPECIAL_MEM_TEST),			// special usage in one function only!!!!!!
+	TAGDEF(ANIMATION_CFG),				// may as well keep this seperate / readable
+
+	TAGDEF(SAVEGAME),					// used for allocating chunks during savegame file read
+	TAGDEF(SHADERTEXT),					// used by cm_shader stuff
+	TAGDEF(CM_TERRAIN),					// terrain
+	TAGDEF(R_TERRAIN),					// renderer side of terrain
+	TAGDEF(INFLATE),				// Temp memory used by zlib32
+	TAGDEF(DEFLATE),				// Temp memory used by zlib32
+	TAGDEF(POINTCACHE),					// weather effects
+	TAGDEF(NEWDEL),
+#ifdef _XBOX
+	TAGDEF(UI_ALLOC),
+	TAGDEF(BINK),
+#endif
+	TAGDEF(COUNT)
+	
+//////////////// eof //////////////
+
diff --git a/code/qcommon/timing.h b/code/qcommon/timing.h
new file mode 100644
index 0000000..c8ca8f7
--- /dev/null
+++ b/code/qcommon/timing.h
@@ -0,0 +1,62 @@
+
+class timing_c
+{
+private:
+	__int64	start;
+	__int64	end;
+
+	int		reset;
+public:
+	timing_c(void)
+	{
+	}
+	void Start()
+	{
+		const __int64 *s = &start;
+
+		__asm
+		{
+			push eax
+			push ebx
+			push edx
+
+			rdtsc
+			mov ebx, s
+			mov	[ebx], eax
+			mov [ebx + 4], edx
+
+			pop edx
+			pop ebx
+			pop eax
+		}
+	}
+	int End()
+	{
+		const __int64 *e = &end;
+		__int64	time;
+
+		__asm
+		{
+			push eax
+			push ebx
+			push edx
+
+			rdtsc
+			mov ebx, e
+			mov	[ebx], eax
+			mov [ebx + 4], edx
+
+			pop edx
+			pop ebx
+			pop eax
+		}
+		time = end - start;
+		if (time < 0)
+		{
+			time = 0;
+		}
+		return((int)time);
+	}
+};
+
+// end
\ No newline at end of file
diff --git a/code/qcommon/tri_coll_test.cpp b/code/qcommon/tri_coll_test.cpp
new file mode 100644
index 0000000..158678a
--- /dev/null
+++ b/code/qcommon/tri_coll_test.cpp
@@ -0,0 +1,506 @@
+/* Triangle/triangle intersection test routine,
+ * by Tomas Moller, 1997.
+ * See article "A Fast Triangle-Triangle Intersection Test",
+ * Journal of Graphics Tools, 2(2), 1997
+ *
+ * int tri_tri_intersect(float V0[3],float V1[3],float V2[3],
+ *                         float U0[3],float U1[3],float U2[3])
+ *
+ * parameters: vertices of triangle 1: V0,V1,V2
+ *             vertices of triangle 2: U0,U1,U2
+ * result    : returns 1 if the triangles intersect, otherwise 0
+ *
+ */
+
+// leave this at the top for PCH reasons...
+#include "common_headers.h"
+
+
+
+
+#include <math.h>
+#include "../game/q_shared.h"
+#include "../game/g_local.h"
+
+/* if USE_EPSILON_TEST is true then we do a check: 
+         if |dv|<EPSILON then dv=0.0;
+   else no check is done (which is less robust)
+*/
+#define USE_EPSILON_TEST 1
+#define EPSILON 0.000001
+
+
+/* some macros */
+#define CROSS(dest,v1,v2)                      \
+              dest[0]=v1[1]*v2[2]-v1[2]*v2[1]; \
+              dest[1]=v1[2]*v2[0]-v1[0]*v2[2]; \
+              dest[2]=v1[0]*v2[1]-v1[1]*v2[0];
+
+#define DOT(v1,v2) (v1[0]*v2[0]+v1[1]*v2[1]+v1[2]*v2[2])
+
+#define SUB(dest,v1,v2)          \
+            dest[0]=v1[0]-v2[0]; \
+            dest[1]=v1[1]-v2[1]; \
+            dest[2]=v1[2]-v2[2]; 
+
+/* sort so that a<=b */
+#define SORT(a,b)       \
+             if(a>b)    \
+             {          \
+               float c; \
+               c=a;     \
+               a=b;     \
+               b=c;     \
+             }
+
+#define ISECT(VV0,VV1,VV2,D0,D1,D2,isect0,isect1) \
+              isect0=VV0+(VV1-VV0)*D0/(D0-D1);    \
+              isect1=VV0+(VV2-VV0)*D0/(D0-D2);
+
+
+#define COMPUTE_INTERVALS(VV0,VV1,VV2,D0,D1,D2,D0D1,D0D2,isect0,isect1) \
+  if(D0D1>0.0f)                                         \
+  {                                                     \
+    /* here we know that D0D2<=0.0 */                   \
+    /* that is D0, D1 are on the same side, D2 on the other or on the plane */ \
+    ISECT(VV2,VV0,VV1,D2,D0,D1,isect0,isect1);          \
+  }                                                     \
+  else if(D0D2>0.0f)                                    \
+  {                                                     \
+    /* here we know that d0d1<=0.0 */                   \
+    ISECT(VV1,VV0,VV2,D1,D0,D2,isect0,isect1);          \
+  }                                                     \
+  else if(D1*D2>0.0f || D0!=0.0f)                       \
+  {                                                     \
+    /* here we know that d0d1<=0.0 or that D0!=0.0 */   \
+    ISECT(VV0,VV1,VV2,D0,D1,D2,isect0,isect1);          \
+  }                                                     \
+  else if(D1!=0.0f)                                     \
+  {                                                     \
+    ISECT(VV1,VV0,VV2,D1,D0,D2,isect0,isect1);          \
+  }                                                     \
+  else if(D2!=0.0f)                                     \
+  {                                                     \
+    ISECT(VV2,VV0,VV1,D2,D0,D1,isect0,isect1);          \
+  }                                                     \
+  else                                                  \
+  {                                                     \
+    /* triangles are coplanar */                        \
+    return coplanar_tri_tri(N1,V0,V1,V2,U0,U1,U2);      \
+  }
+
+
+
+/* this edge to edge test is based on Franlin Antonio's gem:
+   "Faster Line Segment Intersection", in Graphics Gems III,
+   pp. 199-202 */ 
+#define EDGE_EDGE_TEST(V0,U0,U1)                      \
+  Bx=U0[i0]-U1[i0];                                   \
+  By=U0[i1]-U1[i1];                                   \
+  Cx=V0[i0]-U0[i0];                                   \
+  Cy=V0[i1]-U0[i1];                                   \
+  f=Ay*Bx-Ax*By;                                      \
+  d=By*Cx-Bx*Cy;                                      \
+  if((f>0 && d>=0 && d<=f) || (f<0 && d<=0 && d>=f))  \
+  {                                                   \
+    e=Ax*Cy-Ay*Cx;                                    \
+    if(f>0)                                           \
+    {                                                 \
+      if(e>=0 && e<=f) return 1;                      \
+    }                                                 \
+    else                                              \
+    {                                                 \
+      if(e<=0 && e>=f) return 1;                      \
+    }                                                 \
+  }                                
+
+#define EDGE_AGAINST_TRI_EDGES(V0,V1,U0,U1,U2) \
+{                                              \
+  float Ax,Ay,Bx,By,Cx,Cy,e,d,f;               \
+  Ax=V1[i0]-V0[i0];                            \
+  Ay=V1[i1]-V0[i1];                            \
+  /* test edge U0,U1 against V0,V1 */          \
+  EDGE_EDGE_TEST(V0,U0,U1);                    \
+  /* test edge U1,U2 against V0,V1 */          \
+  EDGE_EDGE_TEST(V0,U1,U2);                    \
+  /* test edge U2,U1 against V0,V1 */          \
+  EDGE_EDGE_TEST(V0,U2,U0);                    \
+}
+
+#define POINT_IN_TRI(V0,U0,U1,U2)           \
+{                                           \
+  float a,b,c,d0,d1,d2;                     \
+  /* is T1 completly inside T2? */          \
+  /* check if V0 is inside tri(U0,U1,U2) */ \
+  a=U1[i1]-U0[i1];                          \
+  b=-(U1[i0]-U0[i0]);                       \
+  c=-a*U0[i0]-b*U0[i1];                     \
+  d0=a*V0[i0]+b*V0[i1]+c;                   \
+                                            \
+  a=U2[i1]-U1[i1];                          \
+  b=-(U2[i0]-U1[i0]);                       \
+  c=-a*U1[i0]-b*U1[i1];                     \
+  d1=a*V0[i0]+b*V0[i1]+c;                   \
+                                            \
+  a=U0[i1]-U2[i1];                          \
+  b=-(U0[i0]-U2[i0]);                       \
+  c=-a*U2[i0]-b*U2[i1];                     \
+  d2=a*V0[i0]+b*V0[i1]+c;                   \
+  if(d0*d1>0.0)                             \
+  {                                         \
+    if(d0*d2>0.0) return 1;                 \
+  }                                         \
+}
+
+qboolean coplanar_tri_tri(vec3_t N,vec3_t V0,vec3_t V1,vec3_t V2,
+                     vec3_t U0,vec3_t U1,vec3_t U2)
+{
+   vec3_t A;
+   short i0,i1;
+   /* first project onto an axis-aligned plane, that maximizes the area */
+   /* of the triangles, compute indices: i0,i1. */
+   A[0]=fabs(N[0]);
+   A[1]=fabs(N[1]);
+   A[2]=fabs(N[2]);
+   if(A[0]>A[1])
+   {
+      if(A[0]>A[2])  
+      {
+          i0=1;      /* A[0] is greatest */
+          i1=2;
+      }
+      else
+      {
+          i0=0;      /* A[2] is greatest */
+          i1=1;
+      }
+   }
+   else   /* A[0]<=A[1] */
+   {
+      if(A[2]>A[1])
+      {
+          i0=0;      /* A[2] is greatest */
+          i1=1;                                           
+      }
+      else
+      {
+          i0=0;      /* A[1] is greatest */
+          i1=2;
+      }
+    }               
+                
+    /* test all edges of triangle 1 against the edges of triangle 2 */
+    EDGE_AGAINST_TRI_EDGES(V0,V1,U0,U1,U2);
+    EDGE_AGAINST_TRI_EDGES(V1,V2,U0,U1,U2);
+    EDGE_AGAINST_TRI_EDGES(V2,V0,U0,U1,U2);
+                
+    /* finally, test if tri1 is totally contained in tri2 or vice versa */
+    POINT_IN_TRI(V0,U0,U1,U2);
+    POINT_IN_TRI(U0,V0,V1,V2);
+
+    return qfalse;
+}
+
+qboolean tri_tri_intersect(vec3_t V0,vec3_t V1,vec3_t V2,
+                      vec3_t U0,vec3_t U1,vec3_t U2)
+{
+  vec3_t E1,E2;
+  vec3_t N1,N2;
+  float	d1,d2;
+  float du0,du1,du2,dv0,dv1,dv2;
+  vec3_t D;
+  float isect1[2], isect2[2];
+  float du0du1,du0du2,dv0dv1,dv0dv2;
+  short index;
+  float vp0,vp1,vp2;
+  float up0,up1,up2;
+  float b,c,max;
+
+  /* compute plane equation of triangle(V0,V1,V2) */
+  SUB(E1,V1,V0);
+  SUB(E2,V2,V0);
+  CROSS(N1,E1,E2);
+  d1=-DOT(N1,V0);
+  /* plane equation 1: N1.X+d1=0 */
+
+  /* put U0,U1,U2 into plane equation 1 to compute signed distances to the plane*/
+  du0=DOT(N1,U0)+d1;
+  du1=DOT(N1,U1)+d1;
+  du2=DOT(N1,U2)+d1;
+
+  /* coplanarity robustness check */
+#if USE_EPSILON_TEST
+  if(fabs(du0)<EPSILON) du0=0.0;
+  if(fabs(du1)<EPSILON) du1=0.0;
+  if(fabs(du2)<EPSILON) du2=0.0;
+#endif
+  du0du1=du0*du1;
+  du0du2=du0*du2;
+
+  if(du0du1>0.0f && du0du2>0.0f) /* same sign on all of them + not equal 0 ? */
+    return 0;                    /* no intersection occurs */
+
+  /* compute plane of triangle (U0,U1,U2) */
+  SUB(E1,U1,U0);
+  SUB(E2,U2,U0);
+  CROSS(N2,E1,E2);
+  d2=-DOT(N2,U0);
+  /* plane equation 2: N2.X+d2=0 */
+
+  /* put V0,V1,V2 into plane equation 2 */
+  dv0=DOT(N2,V0)+d2;
+  dv1=DOT(N2,V1)+d2;
+  dv2=DOT(N2,V2)+d2;
+
+#if USE_EPSILON_TEST
+  if(fabs(dv0)<EPSILON) dv0=0.0;
+  if(fabs(dv1)<EPSILON) dv1=0.0;
+  if(fabs(dv2)<EPSILON) dv2=0.0;
+#endif
+
+  dv0dv1=dv0*dv1;
+  dv0dv2=dv0*dv2;
+        
+  if(dv0dv1>0.0f && dv0dv2>0.0f) /* same sign on all of them + not equal 0 ? */
+    return 0;                    /* no intersection occurs */
+
+  /* compute direction of intersection line */
+  CROSS(D,N1,N2);
+
+  /* compute and index to the largest component of D */
+  max=fabs(D[0]);
+  index=0;
+  b=fabs(D[1]);
+  c=fabs(D[2]);
+  if(b>max) max=b,index=1;
+  if(c>max) max=c,index=2;
+
+        /* this is the simplified projection onto L*/
+        vp0=V0[index];
+        vp1=V1[index];
+        vp2=V2[index];
+
+        up0=U0[index];
+        up1=U1[index];
+        up2=U2[index];
+
+  /* compute interval for triangle 1 */
+  COMPUTE_INTERVALS(vp0,vp1,vp2,dv0,dv1,dv2,dv0dv1,dv0dv2,isect1[0],isect1[1]);
+
+  /* compute interval for triangle 2 */
+  COMPUTE_INTERVALS(up0,up1,up2,du0,du1,du2,du0du1,du0du2,isect2[0],isect2[1]);
+
+  SORT(isect1[0],isect1[1]);
+  SORT(isect2[0],isect2[1]);
+
+  if(isect1[1]<isect2[0] || isect2[1]<isect1[0]) return qtrue;
+  return qfalse;
+}
+
+
+float LineSegmentDistance( vec3_t a, vec3_t b, vec3_t c, vec3_t d )
+{
+	vec3_t	v1, v2, v3, cross;
+	//FIXME: what if parallel or intersect?
+	//FIXME: this doesn't take into account the endpoints...
+
+	//get the two lines
+	VectorSubtract( b, a, v1 );
+	VectorSubtract( c, d, v2 );
+
+	//get their normalized cross product
+	CrossProduct( v1, v2, cross );
+	/*
+	float crossLength = VectorLength( cross );
+	if ( crossLength == 0 )
+	{//intersect!  Or... parallel?
+		return 0;
+	}
+	VectorScale( cross, 1/crossLength, cross );
+	*/
+	VectorNormalize( cross );
+
+	//now get a vector from v1 to v2
+	VectorSubtract( d, a, v3 );
+
+	//distance is dot product of that new vector and the normalized cross product
+	float dist = fabs( DotProduct( v3, cross ) );
+
+	return dist;
+}
+
+extern qboolean G_FindClosestPointOnLineSegment( const vec3_t start, const vec3_t end, const vec3_t from, vec3_t result );
+float ShortestLineSegBewteen2LineSegs( vec3_t start1, vec3_t end1, vec3_t start2, vec3_t end2, vec3_t close_pnt1, vec3_t close_pnt2 )
+{
+	float	current_dist, new_dist;
+	vec3_t	new_pnt;
+	//start1, end1 : the first segment
+	//start2, end2 : the second segment
+
+	//output, one point on each segment, the closest two points on the segments.
+
+	//compute some temporaries:
+	//vec start_dif = start2 - start1
+	vec3_t	start_dif;
+	VectorSubtract( start2, start1, start_dif );
+	//vec v1 = end1 - start1
+	vec3_t	v1;
+	VectorSubtract( end1, start1, v1 );
+	//vec v2 = end2 - start2
+	vec3_t	v2;
+	VectorSubtract( end2, start2, v2 );
+	//
+	float v1v1 = DotProduct( v1, v1 );
+	float v2v2 = DotProduct( v2, v2 );
+	float v1v2 = DotProduct( v1, v2 );
+
+	//the main computation
+
+	float denom = (v1v2 * v1v2) - (v1v1 * v2v2);
+
+	//if denom is small, then skip all this and jump to the section marked below
+	if ( fabs(denom) > 0.001f )
+	{
+		float s = -( (v2v2*DotProduct( v1, start_dif )) - (v1v2*DotProduct( v2, start_dif )) ) / denom;
+		float t = ( (v1v1*DotProduct( v2, start_dif )) - (v1v2*DotProduct( v1, start_dif )) ) / denom;
+		qboolean done = qtrue;
+
+		if ( s < 0 )
+		{
+			done = qfalse;
+			s = 0;// and see note below
+		}
+
+		if ( s > 1 ) 
+		{
+			done = qfalse;
+			s = 1;// and see note below
+		}
+
+		if ( t < 0 ) 
+		{
+			done = qfalse;
+			t = 0;// and see note below
+		}
+
+		if ( t > 1 ) 
+		{
+			done = qfalse;
+			t = 1;// and see note below
+		}
+
+		//vec close_pnt1 = start1 + s * v1
+		VectorMA( start1, s, v1, close_pnt1 );
+		//vec close_pnt2 = start2 + t * v2
+		VectorMA( start2, t, v2, close_pnt2 );
+
+		current_dist = Distance( close_pnt1, close_pnt2 );
+		//now, if none of those if's fired, you are done. 
+		if ( done )
+		{
+			return current_dist;
+		}
+		//If they did fire, then we need to do some additional tests.
+
+		//What we are gonna do is see if we can find a shorter distance than the above
+		//involving the endpoints.
+	}
+	else
+	{
+		//******start here for paralell lines with current_dist = infinity****
+		current_dist = Q3_INFINITE;
+	}
+
+	//test 2 close_pnts first
+	/*
+	G_FindClosestPointOnLineSegment( start1, end1, close_pnt2, new_pnt );
+	new_dist = Distance( close_pnt2, new_pnt );
+	if ( new_dist < current_dist )
+	{//then update close_pnt1 close_pnt2 and current_dist
+		VectorCopy( new_pnt, close_pnt1 );
+		VectorCopy( close_pnt2, close_pnt2 );
+		current_dist = new_dist;
+	}
+
+	G_FindClosestPointOnLineSegment( start2, end2, close_pnt1, new_pnt );
+	new_dist = Distance( close_pnt1, new_pnt );
+	if ( new_dist < current_dist )
+	{//then update close_pnt1 close_pnt2 and current_dist
+		VectorCopy( close_pnt1, close_pnt1 );
+		VectorCopy( new_pnt, close_pnt2 );
+		current_dist = new_dist;
+	}
+	*/
+	//test all the endpoints
+	new_dist = Distance( start1, start2 );
+	if ( new_dist < current_dist )
+	{//then update close_pnt1 close_pnt2 and current_dist
+		VectorCopy( start1, close_pnt1 );
+		VectorCopy( start2, close_pnt2 );
+		current_dist = new_dist;
+	}
+
+	new_dist = Distance( start1, end2 );
+	if ( new_dist < current_dist )
+	{//then update close_pnt1 close_pnt2 and current_dist
+		VectorCopy( start1, close_pnt1 );
+		VectorCopy( end2, close_pnt2 );
+		current_dist = new_dist;
+	}
+
+	new_dist = Distance( end1, start2 );
+	if ( new_dist < current_dist )
+	{//then update close_pnt1 close_pnt2 and current_dist
+		VectorCopy( end1, close_pnt1 );
+		VectorCopy( start2, close_pnt2 );
+		current_dist = new_dist;
+	}
+
+	new_dist = Distance( end1, end2 );
+	if ( new_dist < current_dist )
+	{//then update close_pnt1 close_pnt2 and current_dist
+		VectorCopy( end1, close_pnt1 );
+		VectorCopy( end2, close_pnt2 );
+		current_dist = new_dist;
+	}
+
+	//Then we have 4 more point / segment tests
+
+	G_FindClosestPointOnLineSegment( start2, end2, start1, new_pnt );
+	new_dist = Distance( start1, new_pnt );
+	if ( new_dist < current_dist )
+	{//then update close_pnt1 close_pnt2 and current_dist
+		VectorCopy( start1, close_pnt1 );
+		VectorCopy( new_pnt, close_pnt2 );
+		current_dist = new_dist;
+	}
+
+	G_FindClosestPointOnLineSegment( start2, end2, end1, new_pnt );
+	new_dist = Distance( end1, new_pnt );
+	if ( new_dist < current_dist )
+	{//then update close_pnt1 close_pnt2 and current_dist
+		VectorCopy( end1, close_pnt1 );
+		VectorCopy( new_pnt, close_pnt2 );
+		current_dist = new_dist;
+	}
+
+	G_FindClosestPointOnLineSegment( start1, end1, start2, new_pnt );
+	new_dist = Distance( start2, new_pnt );
+	if ( new_dist < current_dist )
+	{//then update close_pnt1 close_pnt2 and current_dist
+		VectorCopy( new_pnt, close_pnt1 );
+		VectorCopy( start2, close_pnt2 );
+		current_dist = new_dist;
+	}
+
+	G_FindClosestPointOnLineSegment( start1, end1, end2, new_pnt );
+	new_dist = Distance( end2, new_pnt );
+	if ( new_dist < current_dist )
+	{//then update close_pnt1 close_pnt2 and current_dist
+		VectorCopy( new_pnt, close_pnt1 );
+		VectorCopy( end2, close_pnt2 );
+		current_dist = new_dist;
+	}
+
+	return current_dist;
+}
\ No newline at end of file
diff --git a/code/qcommon/unzip.cpp b/code/qcommon/unzip.cpp
new file mode 100644
index 0000000..9fc6300
--- /dev/null
+++ b/code/qcommon/unzip.cpp
@@ -0,0 +1,1348 @@
+/*****************************************************************************
+ * name:		unzip.c
+ *
+ * desc:		IO on .zip files using portions of zlib 
+ *
+ * $Archive: /StarTrek/Code-Single/qcommon/unzip.cpp $
+ * $Author: Jmonroe $ 
+ * $Revision: 5 $
+ * $Modtime: 4/10/01 6:47p $
+ * $Date: 4/10/01 7:28p $
+ *
+ *****************************************************************************/
+
+#include "../client/client.h"
+
+#define ZIP_fopen	fopen
+#define ZIP_fclose	fclose
+#define ZIP_fseek	fseek
+#define ZIP_fread	fread
+#define ZIP_ftell	ftell
+
+#include "../zlib32/zip.h"
+#include "unzip.h"
+
+/* unzip.h -- IO for uncompress .zip files using zlib 
+   Version 0.15 beta, Mar 19th, 1998,
+
+   Copyright (C) 1998 Gilles Vollant
+
+   This unzip package allow extract file from .ZIP file, compatible with PKZip 2.04g
+     WinZip, InfoZip tools and compatible.
+   Encryption and multi volume ZipFile (span) are not supported.
+   Old compressions used by old PKZip 1.x are not supported
+
+   THIS IS AN ALPHA VERSION. AT THIS STAGE OF DEVELOPPEMENT, SOMES API OR STRUCTURE
+   CAN CHANGE IN FUTURE VERSION !!
+   I WAIT FEEDBACK at mail info@winimage.com
+   Visit also http://www.winimage.com/zLibDll/unzip.htm for evolution
+
+   Condition of use and distribution are the same than zlib :
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+
+
+*/
+
+                        /* Type declarations */
+
+#ifndef OF /* function prototypes */
+#define OF(args)  args
+#endif
+
+typedef unsigned char  Byte;  /* 8 bits */
+typedef unsigned int   uInt;  /* 16 bits or more */
+typedef unsigned long  uLong; /* 32 bits or more */
+typedef Byte    *voidp;
+
+#ifndef SEEK_SET
+#  define SEEK_SET        0       /* Seek from beginning of file.  */
+#  define SEEK_CUR        1       /* Seek from current position.  */
+#  define SEEK_END        2       /* Set file pointer to EOF plus "offset" */
+#endif
+
+typedef voidp gzFile;
+
+gzFile gzopen  OF((const char *path, const char *mode));
+/*
+     Opens a gzip (.gz) file for reading or writing. The mode parameter
+   is as in fopen ("rb" or "wb") but can also include a compression level
+   ("wb9") or a strategy: 'f' for filtered data as in "wb6f", 'h' for
+   Huffman only compression as in "wb1h". (See the description
+   of deflateInit2 for more information about the strategy parameter.)
+
+     gzopen can be used to read a file which is not in gzip format; in this
+   case gzread will directly read from the file without decompression.
+
+     gzopen returns NULL if the file could not be opened or if there was
+   insufficient memory to allocate the (de)compression state; errno
+   can be checked to distinguish the two cases (if errno is zero, the
+   zlib error is Z_MEM_ERROR).  */
+
+gzFile gzdopen  OF((int fd, const char *mode));
+/*
+     gzdopen() associates a gzFile with the file descriptor fd.  File
+   descriptors are obtained from calls like open, dup, creat, pipe or
+   fileno (in the file has been previously opened with fopen).
+   The mode parameter is as in gzopen.
+     The next call of gzclose on the returned gzFile will also close the
+   file descriptor fd, just like fclose(fdopen(fd), mode) closes the file
+   descriptor fd. If you want to keep fd open, use gzdopen(dup(fd), mode).
+     gzdopen returns NULL if there was insufficient memory to allocate
+   the (de)compression state.
+*/
+
+int gzsetparams OF((gzFile file, int level, int strategy));
+/*
+     Dynamically update the compression level or strategy. See the description
+   of deflateInit2 for the meaning of these parameters.
+     gzsetparams returns Z_OK if success, or Z_STREAM_ERROR if the file was not
+   opened for writing.
+*/
+
+int    gzread  OF((gzFile file, voidp buf, unsigned len));
+/*
+     Reads the given number of uncompressed bytes from the compressed file.
+   If the input file was not in gzip format, gzread copies the given number
+   of bytes into the buffer.
+     gzread returns the number of uncompressed bytes actually read (0 for
+   end of file, -1 for error). */
+
+int    gzwrite OF((gzFile file, 
+				   const voidp buf, unsigned len));
+/*
+     Writes the given number of uncompressed bytes into the compressed file.
+   gzwrite returns the number of uncompressed bytes actually written
+   (0 in case of error).
+*/
+
+int    QDECL gzprintf OF((gzFile file, const char *format, ...));
+/*
+     Converts, formats, and writes the args to the compressed file under
+   control of the format string, as in fprintf. gzprintf returns the number of
+   uncompressed bytes actually written (0 in case of error).
+*/
+
+int gzputs OF((gzFile file, const char *s));
+/*
+      Writes the given null-terminated string to the compressed file, excluding
+   the terminating null character.
+      gzputs returns the number of characters written, or -1 in case of error.
+*/
+
+char * gzgets OF((gzFile file, char *buf, int len));
+/*
+      Reads bytes from the compressed file until len-1 characters are read, or
+   a newline character is read and transferred to buf, or an end-of-file
+   condition is encountered.  The string is then terminated with a null
+   character.
+      gzgets returns buf, or Z_NULL in case of error.
+*/
+
+int    gzputc OF((gzFile file, int c));
+/*
+      Writes c, converted to an unsigned char, into the compressed file.
+   gzputc returns the value that was written, or -1 in case of error.
+*/
+
+int    gzgetc OF((gzFile file));
+/*
+      Reads one byte from the compressed file. gzgetc returns this byte
+   or -1 in case of end of file or error.
+*/
+
+int    gzflush OF((gzFile file, int flush));
+/*
+     Flushes all pending output into the compressed file. The parameter
+   flush is as in the deflate() function. The return value is the zlib
+   error number (see function gzerror below). gzflush returns Z_OK if
+   the flush parameter is Z_FINISH and all output could be flushed.
+     gzflush should be called only when strictly necessary because it can
+   degrade compression.
+*/
+
+long gzseek OF((gzFile file,
+				      long offset, int whence));
+/* 
+      Sets the starting position for the next gzread or gzwrite on the
+   given compressed file. The offset represents a number of bytes in the
+   uncompressed data stream. The whence parameter is defined as in lseek(2);
+   the value SEEK_END is not supported.
+     If the file is opened for reading, this function is emulated but can be
+   extremely slow. If the file is opened for writing, only forward seeks are
+   supported; gzseek then compresses a sequence of zeroes up to the new
+   starting position.
+
+      gzseek returns the resulting offset location as measured in bytes from
+   the beginning of the uncompressed stream, or -1 in case of error, in
+   particular if the file is opened for writing and the new starting position
+   would be before the current position.
+*/
+
+int    gzrewind OF((gzFile file));
+/*
+     Rewinds the given file. This function is supported only for reading.
+
+   gzrewind(file) is equivalent to (int)gzseek(file, 0L, SEEK_SET)
+*/
+
+long    gztell OF((gzFile file));
+/*
+     Returns the starting position for the next gzread or gzwrite on the
+   given compressed file. This position represents a number of bytes in the
+   uncompressed data stream.
+
+   gztell(file) is equivalent to gzseek(file, 0L, SEEK_CUR)
+*/
+
+int gzeof OF((gzFile file));
+/*
+     Returns 1 when EOF has previously been detected reading the given
+   input stream, otherwise zero.
+*/
+
+int    gzclose OF((gzFile file));
+/*
+     Flushes all pending output if necessary, closes the compressed file
+   and deallocates all the (de)compression state. The return value is the zlib
+   error number (see function gzerror below).
+*/
+
+const char * gzerror OF((gzFile file, int *errnum));
+/*
+     Returns the error message for the last error which occurred on the
+   given compressed file. errnum is set to zlib error number. If an
+   error occurred in the file system and not in the compression library,
+   errnum is set to Z_ERRNO and the application may consult errno
+   to get the exact error code.
+*/
+
+#if !defined(unix) && !defined(CASESENSITIVITYDEFAULT_YES) && \
+                      !defined(CASESENSITIVITYDEFAULT_NO)
+#define CASESENSITIVITYDEFAULT_NO
+#endif
+
+
+#ifndef UNZ_BUFSIZE
+#define UNZ_BUFSIZE (65536)
+#endif
+
+#ifndef UNZ_MAXFILENAMEINZIP
+#define UNZ_MAXFILENAMEINZIP (256)
+#endif
+
+#ifndef ALLOC
+# define ALLOC(size) (UNZ_Malloc (size)) //Quake hookups
+#endif
+#ifndef TRYFREE
+# define TRYFREE(p) {if (p) Z_Free(p);}//Quake hookups
+#endif
+
+#define SIZECENTRALDIRITEM (0x2e)
+#define SIZEZIPLOCALHEADER (0x1e)
+
+static void *UNZ_Malloc( int size ) {
+	void	*buf;
+	
+	buf = Z_Malloc( size, TAG_FILESYS, qfalse);
+	return buf;
+}
+
+
+/* ===========================================================================
+   Reads a long in LSB order from the given gz_stream. Sets 
+*/
+static int unzlocal_getShort (ZIP_FILE* fin, uLong *pX)
+{
+	short	v;
+
+	ZIP_fread( &v, sizeof(v), 1, fin );
+
+	*pX = LittleShort( v);
+	return UNZ_OK;
+}
+
+static int unzlocal_getLong (ZIP_FILE *fin, uLong *pX)
+{
+	int		v;
+
+	ZIP_fread( &v, sizeof(v), 1, fin );
+
+	*pX = LittleLong( v);
+	return UNZ_OK;
+}
+
+
+/* My own strcmpi / strcasecmp */
+static int strcmpcasenosensitive_internal (const char* fileName1,const char* fileName2)
+{
+	for (;;)
+	{
+		char c1=*(fileName1++);
+		char c2=*(fileName2++);
+		if ((c1>='a') && (c1<='z'))
+			c1 -= 0x20;
+		if ((c2>='a') && (c2<='z'))
+			c2 -= 0x20;
+		if (c1=='\0')
+			return ((c2=='\0') ? 0 : -1);
+		if (c2=='\0')
+			return 1;
+		if (c1<c2)
+			return -1;
+		if (c1>c2)
+			return 1;
+	}
+}
+
+
+#ifdef  CASESENSITIVITYDEFAULT_NO
+#define CASESENSITIVITYDEFAULTVALUE 2
+#else
+#define CASESENSITIVITYDEFAULTVALUE 1
+#endif
+
+#ifndef STRCMPCASENOSENTIVEFUNCTION
+#define STRCMPCASENOSENTIVEFUNCTION strcmpcasenosensitive_internal
+#endif
+
+/* 
+   Compare two filename (fileName1,fileName2).
+   If iCaseSenisivity = 1, comparision is case sensitivity (like strcmp)
+   If iCaseSenisivity = 2, comparision is not case sensitivity (like strcmpi
+                                                                or strcasecmp)
+   If iCaseSenisivity = 0, case sensitivity is defaut of your operating system
+        (like 1 on Unix, 2 on Windows)
+
+*/
+extern int unzStringFileNameCompare (const char* fileName1,const char* fileName2,int iCaseSensitivity)
+{
+	if (iCaseSensitivity==0)
+		iCaseSensitivity=CASESENSITIVITYDEFAULTVALUE;
+
+	if (iCaseSensitivity==1)
+		return strcmp(fileName1,fileName2);
+
+	return STRCMPCASENOSENTIVEFUNCTION(fileName1,fileName2);
+} 
+
+#define BUFREADCOMMENT (0x400)
+
+/*
+  Locate the Central directory of a zipfile (at the end, just before
+    the global comment)
+*/
+static uLong unzlocal_SearchCentralDir(ZIP_FILE *fin)
+{
+	unsigned char* buf;
+	uLong uSizeFile;
+	uLong uBackRead;
+	uLong uMaxBack=0xffff; /* maximum size of global comment */
+	uLong uPosFound=0;
+	
+	if (ZIP_fseek(fin,0,SEEK_END) != 0)
+		return 0;
+
+
+	uSizeFile = ZIP_ftell( fin );
+	
+	if (uMaxBack>uSizeFile)
+		uMaxBack = uSizeFile;
+
+	buf = (unsigned char*)ALLOC(BUFREADCOMMENT+4);
+
+	uBackRead = 4;
+	while (uBackRead<uMaxBack)
+	{
+		uLong uReadSize,uReadPos ;
+		int i;
+		if (uBackRead+BUFREADCOMMENT>uMaxBack) 
+			uBackRead = uMaxBack;
+		else
+			uBackRead+=BUFREADCOMMENT;
+		uReadPos = uSizeFile-uBackRead ;
+		
+		uReadSize = ((BUFREADCOMMENT+4) < (uSizeFile-uReadPos)) ? 
+                     (BUFREADCOMMENT+4) : (uSizeFile-uReadPos);
+		if (ZIP_fseek(fin,uReadPos,SEEK_SET)!=0)
+			break;
+
+		if (ZIP_fread(buf,(uInt)uReadSize,1,fin)!=1)
+			break;
+
+                for (i=(int)uReadSize-3; (i--)>0;)
+			if (((*(buf+i))==0x50) && ((*(buf+i+1))==0x4b) && 
+				((*(buf+i+2))==0x05) && ((*(buf+i+3))==0x06))
+			{
+				uPosFound = uReadPos+i;
+				break;
+			}
+
+		if (uPosFound!=0)
+			break;
+	}
+	TRYFREE(buf);
+	return uPosFound;
+}
+
+extern unzFile unzReOpen (const char* path, unzFile file)
+{
+	unz_s *s;
+	ZIP_FILE * fin;
+
+    fin=ZIP_fopen(path,"rb");
+	if (fin==NULL)
+		return NULL;
+
+	s=(unz_s*)ALLOC(sizeof(unz_s));
+	memcpy(s, (unz_s*)file, sizeof(unz_s));
+
+	s->file = fin;
+	return (unzFile)s;	
+}
+
+/*
+  Open a Zip file. path contain the full pathname (by example,
+     on a Windows NT computer "c:\\test\\zlib109.zip" or on an Unix computer
+	 "zlib/zlib109.zip".
+	 If the zipfile cannot be opened (file don't exist or in not valid), the
+	   return value is NULL.
+     Else, the return value is a unzFile Handle, usable with other function
+	   of this unzip package.
+*/
+extern unzFile unzOpen (const char* path)
+{
+	unz_s us;
+	unz_s *s;
+	uLong central_pos,uL;
+	ZIP_FILE * fin ;
+
+	uLong number_disk;          /* number of the current dist, used for 
+								   spaning ZIP, unsupported, always 0*/
+	uLong number_disk_with_CD;  /* number the the disk with central dir, used
+								   for spaning ZIP, unsupported, always 0*/
+	uLong number_entry_CD;      /* total number of entries in
+	                               the central dir 
+	                               (same than number_entry on nospan) */
+
+	int err=UNZ_OK;
+
+    fin=ZIP_fopen(path,"rb");
+	if (fin==NULL)
+		return NULL;
+
+	central_pos = unzlocal_SearchCentralDir(fin);
+	if (central_pos==0)
+		err=UNZ_ERRNO;
+
+	if (ZIP_fseek(fin,central_pos,SEEK_SET)!=0)
+		err=UNZ_ERRNO;
+
+	/* the signature, already checked */
+	if (unzlocal_getLong(fin,&uL)!=UNZ_OK)
+		err=UNZ_ERRNO;
+
+	/* number of this disk */
+	if (unzlocal_getShort(fin,&number_disk)!=UNZ_OK)
+		err=UNZ_ERRNO;
+
+	/* number of the disk with the start of the central directory */
+	if (unzlocal_getShort(fin,&number_disk_with_CD)!=UNZ_OK)
+		err=UNZ_ERRNO;
+
+	/* total number of entries in the central dir on this disk */
+	if (unzlocal_getShort(fin,&us.gi.number_entry)!=UNZ_OK)
+		err=UNZ_ERRNO;
+
+	/* total number of entries in the central dir */
+	if (unzlocal_getShort(fin,&number_entry_CD)!=UNZ_OK)
+		err=UNZ_ERRNO;
+
+	if ((number_entry_CD!=us.gi.number_entry) ||
+		(number_disk_with_CD!=0) ||
+		(number_disk!=0))
+		err=UNZ_BADZIPFILE;
+
+	/* size of the central directory */
+	if (unzlocal_getLong(fin,&us.size_central_dir)!=UNZ_OK)
+		err=UNZ_ERRNO;
+
+	/* offset of start of central directory with respect to the 
+	      starting disk number */
+	if (unzlocal_getLong(fin,&us.offset_central_dir)!=UNZ_OK)
+		err=UNZ_ERRNO;
+
+	/* zipfile comment length */
+	if (unzlocal_getShort(fin,&us.gi.size_comment)!=UNZ_OK)
+		err=UNZ_ERRNO;
+
+	if ((central_pos<us.offset_central_dir+us.size_central_dir) && 
+		(err==UNZ_OK))
+		err=UNZ_BADZIPFILE;
+
+	if (err!=UNZ_OK)
+	{
+		ZIP_fclose(fin);
+		return NULL;
+	}
+
+	us.file=fin;
+	us.byte_before_the_zipfile = central_pos -
+		                    (us.offset_central_dir+us.size_central_dir);
+	us.central_pos = central_pos;
+    us.pfile_in_zip_read = NULL;
+	
+
+	s=(unz_s*)ALLOC(sizeof(unz_s));
+	*s=us;
+//	unzGoToFirstFile((unzFile)s);	
+	return (unzFile)s;	
+}
+
+
+/*
+  Close a ZipFile opened with unzipOpen.
+  If there is files inside the .Zip opened with unzipOpenCurrentFile (see later),
+    these files MUST be closed with unzipCloseCurrentFile before call unzipClose.
+  return UNZ_OK if there is no problem. */
+extern int unzClose (unzFile file)
+{
+	unz_s* s;
+	if (file==NULL)
+		return UNZ_PARAMERROR;
+	s=(unz_s*)file;
+
+    if (s->pfile_in_zip_read!=NULL)
+        unzCloseCurrentFile(file);
+
+	ZIP_fclose(s->file);
+	TRYFREE(s);
+	return UNZ_OK;
+}
+
+
+/*
+  Write info about the ZipFile in the *pglobal_info structure.
+  No preparation of the structure is needed
+  return UNZ_OK if there is no problem. */
+extern int unzGetGlobalInfo (unzFile file,unz_global_info *pglobal_info)
+{
+	unz_s* s;
+	if (file==NULL)
+		return UNZ_PARAMERROR;
+	s=(unz_s*)file;
+	*pglobal_info=s->gi;
+	return UNZ_OK;
+}
+
+
+/*
+   Translate date/time from Dos format to tm_unz (readable more easilty)
+*/
+static void unzlocal_DosDateToTmuDate (uLong ulDosDate, tm_unz* ptm)
+{
+    uLong uDate;
+    uDate = (uLong)(ulDosDate>>16);
+    ptm->tm_mday = (uInt)(uDate&0x1f) ;
+    ptm->tm_mon =  (uInt)((((uDate)&0x1E0)/0x20)-1) ;
+    ptm->tm_year = (uInt)(((uDate&0x0FE00)/0x0200)+1980) ;
+
+    ptm->tm_hour = (uInt) ((ulDosDate &0xF800)/0x800);
+    ptm->tm_min =  (uInt) ((ulDosDate&0x7E0)/0x20) ;
+    ptm->tm_sec =  (uInt) (2*(ulDosDate&0x1f)) ;
+}
+
+/*
+  Get Info about the current file in the zipfile, with internal only info
+*/
+static int unzlocal_GetCurrentFileInfoInternal (unzFile file,
+                                                  unz_file_info *pfile_info,
+                                                  unz_file_info_internal 
+                                                  *pfile_info_internal,
+                                                  char *szFileName,
+												  uLong fileNameBufferSize,
+                                                  void *extraField,
+												  uLong extraFieldBufferSize,
+                                                  char *szComment,
+												  uLong commentBufferSize)
+{
+	unz_s* s;
+	unz_file_info file_info;
+	unz_file_info_internal file_info_internal;
+	int err=UNZ_OK;
+	uLong uMagic;
+	long lSeek=0;
+
+	if (file==NULL)
+		return UNZ_PARAMERROR;
+	s=(unz_s*)file;
+	if (ZIP_fseek(s->file,s->pos_in_central_dir+s->byte_before_the_zipfile,SEEK_SET)!=0)
+		err=UNZ_ERRNO;
+
+
+	/* we check the magic */
+	if (err==UNZ_OK)
+		if (unzlocal_getLong(s->file,&uMagic) != UNZ_OK)
+			err=UNZ_ERRNO;
+		else if (uMagic!=0x02014b50)
+			err=UNZ_BADZIPFILE;
+
+	if (unzlocal_getShort(s->file,&file_info.version) != UNZ_OK)
+		err=UNZ_ERRNO;
+
+	if (unzlocal_getShort(s->file,&file_info.version_needed) != UNZ_OK)
+		err=UNZ_ERRNO;
+
+	if (unzlocal_getShort(s->file,&file_info.flag) != UNZ_OK)
+		err=UNZ_ERRNO;
+
+	if (unzlocal_getShort(s->file,&file_info.compression_method) != UNZ_OK)
+		err=UNZ_ERRNO;
+
+	if (unzlocal_getLong(s->file,&file_info.dosDate) != UNZ_OK)
+		err=UNZ_ERRNO;
+
+    unzlocal_DosDateToTmuDate(file_info.dosDate,&file_info.tmu_date);
+
+	if (unzlocal_getLong(s->file,&file_info.crc) != UNZ_OK)
+		err=UNZ_ERRNO;
+
+	if (unzlocal_getLong(s->file,&file_info.compressed_size) != UNZ_OK)
+		err=UNZ_ERRNO;
+
+	if (unzlocal_getLong(s->file,&file_info.uncompressed_size) != UNZ_OK)
+		err=UNZ_ERRNO;
+
+	if (unzlocal_getShort(s->file,&file_info.size_filename) != UNZ_OK)
+		err=UNZ_ERRNO;
+
+	if (unzlocal_getShort(s->file,&file_info.size_file_extra) != UNZ_OK)
+		err=UNZ_ERRNO;
+
+	if (unzlocal_getShort(s->file,&file_info.size_file_comment) != UNZ_OK)
+		err=UNZ_ERRNO;
+
+	if (unzlocal_getShort(s->file,&file_info.disk_num_start) != UNZ_OK)
+		err=UNZ_ERRNO;
+
+	if (unzlocal_getShort(s->file,&file_info.internal_fa) != UNZ_OK)
+		err=UNZ_ERRNO;
+
+	if (unzlocal_getLong(s->file,&file_info.external_fa) != UNZ_OK)
+		err=UNZ_ERRNO;
+
+	if (unzlocal_getLong(s->file,&file_info_internal.offset_curfile) != UNZ_OK)
+		err=UNZ_ERRNO;
+
+	lSeek+=file_info.size_filename;
+	if ((err==UNZ_OK) && (szFileName!=NULL))
+	{
+		uLong uSizeRead ;
+		if (file_info.size_filename<fileNameBufferSize)
+		{
+			*(szFileName+file_info.size_filename)='\0';
+			uSizeRead = file_info.size_filename;
+		}
+		else
+			uSizeRead = fileNameBufferSize;
+
+		if ((file_info.size_filename>0) && (fileNameBufferSize>0))
+			if (ZIP_fread(szFileName,(uInt)uSizeRead,1,s->file)!=1)
+				err=UNZ_ERRNO;
+		lSeek -= uSizeRead;
+	}
+
+	
+	if ((err==UNZ_OK) && (extraField!=NULL))
+	{
+		uLong uSizeRead ;
+		if (file_info.size_file_extra<extraFieldBufferSize)
+			uSizeRead = file_info.size_file_extra;
+		else
+			uSizeRead = extraFieldBufferSize;
+
+		if (lSeek!=0)
+			if (ZIP_fseek(s->file,lSeek,SEEK_CUR)==0)
+				lSeek=0;
+			else
+				err=UNZ_ERRNO;
+		if ((file_info.size_file_extra>0) && (extraFieldBufferSize>0))
+			if (ZIP_fread(extraField,(uInt)uSizeRead,1,s->file)!=1)
+				err=UNZ_ERRNO;
+		lSeek += file_info.size_file_extra - uSizeRead;
+	}
+	else
+		lSeek+=file_info.size_file_extra; 
+
+	
+	if ((err==UNZ_OK) && (szComment!=NULL))
+	{
+		uLong uSizeRead ;
+		if (file_info.size_file_comment<commentBufferSize)
+		{
+			*(szComment+file_info.size_file_comment)='\0';
+			uSizeRead = file_info.size_file_comment;
+		}
+		else
+			uSizeRead = commentBufferSize;
+
+		if (lSeek!=0)
+			if (ZIP_fseek(s->file,lSeek,SEEK_CUR)==0)
+				lSeek=0;
+			else
+				err=UNZ_ERRNO;
+		if ((file_info.size_file_comment>0) && (commentBufferSize>0))
+			if (ZIP_fread(szComment,(uInt)uSizeRead,1,s->file)!=1)
+				err=UNZ_ERRNO;
+		lSeek+=file_info.size_file_comment - uSizeRead;
+	}
+	else
+		lSeek+=file_info.size_file_comment;
+
+	if ((err==UNZ_OK) && (pfile_info!=NULL))
+		*pfile_info=file_info;
+
+	if ((err==UNZ_OK) && (pfile_info_internal!=NULL))
+		*pfile_info_internal=file_info_internal;
+
+	return err;
+}
+
+
+
+/*
+  Write info about the ZipFile in the *pglobal_info structure.
+  No preparation of the structure is needed
+  return UNZ_OK if there is no problem.
+*/
+extern int unzGetCurrentFileInfo (	unzFile file, unz_file_info *pfile_info,
+									char *szFileName, uLong fileNameBufferSize,
+									void *extraField, uLong extraFieldBufferSize,
+									char *szComment, uLong commentBufferSize)
+{
+	return unzlocal_GetCurrentFileInfoInternal(file,pfile_info,NULL,
+												szFileName,fileNameBufferSize,
+												extraField,extraFieldBufferSize,
+												szComment,commentBufferSize);
+}
+
+/*
+  Set the current file of the zipfile to the first file.
+  return UNZ_OK if there is no problem
+*/
+extern int unzGoToFirstFile (unzFile file)
+{
+	int err=UNZ_OK;
+	unz_s* s;
+	if (file==NULL)
+		return UNZ_PARAMERROR;
+	s=(unz_s*)file;
+	s->pos_in_central_dir=s->offset_central_dir;
+	s->num_file=0;
+	err=unzlocal_GetCurrentFileInfoInternal(file,&s->cur_file_info,
+											 &s->cur_file_info_internal,
+											 NULL,0,NULL,0,NULL,0);
+	s->current_file_ok = (err == UNZ_OK);
+	return err;
+}
+
+
+/*
+  Set the current file of the zipfile to the next file.
+  return UNZ_OK if there is no problem
+  return UNZ_END_OF_LIST_OF_FILE if the actual file was the latest.
+*/
+extern int unzGoToNextFile (unzFile file)
+{
+	unz_s* s;	
+	int err;
+
+	if (file==NULL)
+		return UNZ_PARAMERROR;
+	s=(unz_s*)file;
+	if (!s->current_file_ok)
+		return UNZ_END_OF_LIST_OF_FILE;
+	if (s->num_file+1==s->gi.number_entry)
+		return UNZ_END_OF_LIST_OF_FILE;
+
+	s->pos_in_central_dir += SIZECENTRALDIRITEM + s->cur_file_info.size_filename +
+			s->cur_file_info.size_file_extra + s->cur_file_info.size_file_comment ;
+	s->num_file++;
+	err = unzlocal_GetCurrentFileInfoInternal(file,&s->cur_file_info,
+											   &s->cur_file_info_internal,
+											   NULL,0,NULL,0,NULL,0);
+	s->current_file_ok = (err == UNZ_OK);
+	return err;
+}
+
+
+/*
+  Get the position of the info of the current file in the zip.
+  return UNZ_OK if there is no problem
+*/
+extern int unzGetCurrentFileInfoPosition (unzFile file, unsigned long *pos )
+{
+	unz_s* s;	
+
+	if (file==NULL)
+		return UNZ_PARAMERROR;
+	s=(unz_s*)file;
+
+	*pos = s->pos_in_central_dir;
+	return UNZ_OK;
+}
+
+/*
+  Set the position of the info of the current file in the zip.
+  return UNZ_OK if there is no problem
+*/
+extern int unzSetCurrentFileInfoPosition (unzFile file, unsigned long pos )
+{
+	unz_s* s;	
+	int err;
+
+	if (file==NULL)
+		return UNZ_PARAMERROR;
+	s=(unz_s*)file;
+
+	s->pos_in_central_dir = pos;
+	err = unzlocal_GetCurrentFileInfoInternal(file,&s->cur_file_info,
+											   &s->cur_file_info_internal,
+											   NULL,0,NULL,0,NULL,0);
+	s->current_file_ok = (err == UNZ_OK);
+	return UNZ_OK;
+}
+
+/*
+  Try locate the file szFileName in the zipfile.
+  For the iCaseSensitivity signification, see unzipStringFileNameCompare
+
+  return value :
+  UNZ_OK if the file is found. It becomes the current file.
+  UNZ_END_OF_LIST_OF_FILE if the file is not found
+*/
+extern int unzLocateFile (unzFile file, const char *szFileName, int iCaseSensitivity)
+{
+	unz_s* s;	
+	int err;
+
+	
+	uLong num_fileSaved;
+	uLong pos_in_central_dirSaved;
+
+
+	if (file==NULL)
+		return UNZ_PARAMERROR;
+
+    if (strlen(szFileName)>=UNZ_MAXFILENAMEINZIP)
+        return UNZ_PARAMERROR;
+
+	s=(unz_s*)file;
+	if (!s->current_file_ok)
+		return UNZ_END_OF_LIST_OF_FILE;
+
+	num_fileSaved = s->num_file;
+	pos_in_central_dirSaved = s->pos_in_central_dir;
+
+	err = unzGoToFirstFile(file);
+
+	while (err == UNZ_OK)
+	{
+		char szCurrentFileName[UNZ_MAXFILENAMEINZIP+1];
+		unzGetCurrentFileInfo(file,NULL,
+								szCurrentFileName,sizeof(szCurrentFileName)-1,
+								NULL,0,NULL,0);
+		if (unzStringFileNameCompare(szCurrentFileName,
+										szFileName,iCaseSensitivity)==0)
+			return UNZ_OK;
+		err = unzGoToNextFile(file);
+	}
+
+	s->num_file = num_fileSaved ;
+	s->pos_in_central_dir = pos_in_central_dirSaved ;
+	return err;
+}
+
+
+/*
+  Read the static header of the current zipfile
+  Check the coherency of the static header and info in the end of central
+        directory about this file
+  store in *piSizeVar the size of extra info in static header
+        (filename and size of extra field data)
+*/
+static int unzlocal_CheckCurrentFileCoherencyHeader (unz_s* s, uInt* piSizeVar,
+													uLong *poffset_local_extrafield,
+													uInt *psize_local_extrafield)
+{
+	uLong uMagic,uData,uFlags;
+	uLong size_filename;
+	uLong size_extra_field;
+	int err=UNZ_OK;
+
+	*piSizeVar = 0;
+	*poffset_local_extrafield = 0;
+	*psize_local_extrafield = 0;
+
+	if (ZIP_fseek(s->file,s->cur_file_info_internal.offset_curfile +
+								s->byte_before_the_zipfile,SEEK_SET)!=0)
+		return UNZ_ERRNO;
+
+
+	if (err==UNZ_OK)
+		if (unzlocal_getLong(s->file,&uMagic) != UNZ_OK)
+			err=UNZ_ERRNO;
+		else if (uMagic!=0x04034b50)
+			err=UNZ_BADZIPFILE;
+
+	if (unzlocal_getShort(s->file,&uData) != UNZ_OK)
+		err=UNZ_ERRNO;
+/*
+	else if ((err==UNZ_OK) && (uData!=s->cur_file_info.wVersion))
+		err=UNZ_BADZIPFILE;
+*/
+	if (unzlocal_getShort(s->file,&uFlags) != UNZ_OK)
+		err=UNZ_ERRNO;
+
+	if (unzlocal_getShort(s->file,&uData) != UNZ_OK)
+		err=UNZ_ERRNO;
+	else if ((err==UNZ_OK) && (uData!=s->cur_file_info.compression_method))
+		err=UNZ_BADZIPFILE;
+
+    if ((err==UNZ_OK) && (s->cur_file_info.compression_method!=0) &&
+                         (s->cur_file_info.compression_method!=ZF_DEFLATED))
+        err=UNZ_BADZIPFILE;
+
+	if (unzlocal_getLong(s->file,&uData) != UNZ_OK) /* date/time */
+		err=UNZ_ERRNO;
+
+	if (unzlocal_getLong(s->file,&uData) != UNZ_OK) /* crc */
+		err=UNZ_ERRNO;
+	else if ((err==UNZ_OK) && (uData!=s->cur_file_info.crc) &&
+		                      ((uFlags & 8)==0))
+		err=UNZ_BADZIPFILE;
+
+	if (unzlocal_getLong(s->file,&uData) != UNZ_OK) /* size compr */
+		err=UNZ_ERRNO;
+	else if ((err==UNZ_OK) && (uData!=s->cur_file_info.compressed_size) &&
+							  ((uFlags & 8)==0))
+		err=UNZ_BADZIPFILE;
+
+	if (unzlocal_getLong(s->file,&uData) != UNZ_OK) /* size uncompr */
+		err=UNZ_ERRNO;
+	else if ((err==UNZ_OK) && (uData!=s->cur_file_info.uncompressed_size) && 
+							  ((uFlags & 8)==0))
+		err=UNZ_BADZIPFILE;
+
+
+	if (unzlocal_getShort(s->file,&size_filename) != UNZ_OK)
+		err=UNZ_ERRNO;
+	else if ((err==UNZ_OK) && (size_filename!=s->cur_file_info.size_filename))
+		err=UNZ_BADZIPFILE;
+
+	*piSizeVar += (uInt)size_filename;
+
+	if (unzlocal_getShort(s->file,&size_extra_field) != UNZ_OK)
+		err=UNZ_ERRNO;
+	*poffset_local_extrafield= s->cur_file_info_internal.offset_curfile +
+									SIZEZIPLOCALHEADER + size_filename;
+	*psize_local_extrafield = (uInt)size_extra_field;
+
+	*piSizeVar += (uInt)size_extra_field;
+
+	return err;
+}
+												
+/*
+  Open for reading data the current file in the zipfile.
+  If there is no error and the file is opened, the return value is UNZ_OK.
+*/
+extern int unzOpenCurrentFile (unzFile file)
+{
+	int err=UNZ_OK;
+	int Store;
+	uInt iSizeVar;
+	unz_s* s;
+	file_in_zip_read_info_s* pfile_in_zip_read_info;
+	uLong offset_local_extrafield;  /* offset of the static extra field */
+	uInt  size_local_extrafield;    /* size of the static extra field */
+
+	if (file==NULL)
+		return UNZ_PARAMERROR;
+	s=(unz_s*)file;
+	if (!s->current_file_ok)
+		return UNZ_PARAMERROR;
+
+    if (s->pfile_in_zip_read != NULL)
+        unzCloseCurrentFile(file);
+
+	if (unzlocal_CheckCurrentFileCoherencyHeader(s,&iSizeVar,
+				&offset_local_extrafield,&size_local_extrafield)!=UNZ_OK)
+		return UNZ_BADZIPFILE;
+
+	pfile_in_zip_read_info = (file_in_zip_read_info_s*) ALLOC(sizeof(file_in_zip_read_info_s));
+
+	pfile_in_zip_read_info->read_buffer=(char*)ALLOC(UNZ_BUFSIZE);
+	pfile_in_zip_read_info->offset_local_extrafield = offset_local_extrafield;
+	pfile_in_zip_read_info->size_local_extrafield = size_local_extrafield;
+	pfile_in_zip_read_info->pos_local_extrafield=0;
+
+	pfile_in_zip_read_info->stream_initialised=0;
+	
+	if ((s->cur_file_info.compression_method!=0) &&
+        (s->cur_file_info.compression_method!=ZF_DEFLATED))
+		err=UNZ_BADZIPFILE;
+	Store = s->cur_file_info.compression_method==0;
+
+	pfile_in_zip_read_info->crc32_wait=s->cur_file_info.crc;
+	pfile_in_zip_read_info->crc32=0;
+	pfile_in_zip_read_info->compression_method =
+            s->cur_file_info.compression_method;
+	pfile_in_zip_read_info->file=s->file;
+	pfile_in_zip_read_info->byte_before_the_zipfile=s->byte_before_the_zipfile;
+
+    pfile_in_zip_read_info->stream.total_out = 0;
+
+	if (!Store)
+	{
+	  err=inflateInit(&pfile_in_zip_read_info->stream, Z_SYNC_FLUSH, 1);
+	  if (err == Z_OK)
+	    pfile_in_zip_read_info->stream_initialised=1;
+        /* windowBits is passed < 0 to tell that there is no zlib header.
+         * Note that in this case inflate *requires* an extra "dummy" byte
+         * after the compressed stream in order to complete decompression and
+         * return Z_STREAM_END. 
+         * In unzip, i don't wait absolutely Z_STREAM_END because I known the 
+         * size of both compressed and uncompressed data
+         */
+	}
+	pfile_in_zip_read_info->rest_read_compressed = 
+            s->cur_file_info.compressed_size ;
+	pfile_in_zip_read_info->rest_read_uncompressed = 
+            s->cur_file_info.uncompressed_size ;
+
+	
+	pfile_in_zip_read_info->pos_in_zipfile = 
+            s->cur_file_info_internal.offset_curfile + SIZEZIPLOCALHEADER + 
+			  iSizeVar;
+	
+	pfile_in_zip_read_info->stream.avail_in = (uInt)0;
+
+
+	s->pfile_in_zip_read = pfile_in_zip_read_info;
+    return UNZ_OK;
+}
+
+
+/*
+  Read bytes from the current file.
+  buf contain buffer where data must be copied
+  len the size of buf.
+
+  return the number of byte copied if somes bytes are copied
+  return 0 if the end of file was reached
+  return <0 with error code if there is an error
+    (UNZ_ERRNO for IO error, or zLib error for uncompress error)
+*/
+extern int unzReadCurrentFile  (unzFile file, void *buf, unsigned len)
+{
+	int err=UNZ_OK;
+	uInt iRead = 0;
+	unz_s* s;
+	file_in_zip_read_info_s* pfile_in_zip_read_info;
+	if (file==NULL)
+		return UNZ_PARAMERROR;
+	s=(unz_s*)file;
+    pfile_in_zip_read_info=s->pfile_in_zip_read;
+
+	if (pfile_in_zip_read_info==NULL)
+		return UNZ_PARAMERROR;
+
+
+	if ((pfile_in_zip_read_info->read_buffer == NULL))
+		return UNZ_END_OF_LIST_OF_FILE;
+	if (len==0)
+		return 0;
+
+	pfile_in_zip_read_info->stream.next_out = (Byte*)buf;
+
+	pfile_in_zip_read_info->stream.avail_out = (uInt)len;
+	
+	if (len>pfile_in_zip_read_info->rest_read_uncompressed)
+		pfile_in_zip_read_info->stream.avail_out = 
+		  (uInt)pfile_in_zip_read_info->rest_read_uncompressed;
+
+	while (pfile_in_zip_read_info->stream.avail_out>0)
+	{
+		if ((pfile_in_zip_read_info->stream.avail_in==0) &&
+            (pfile_in_zip_read_info->rest_read_compressed>0))
+		{
+			uInt uReadThis = UNZ_BUFSIZE;
+			if (pfile_in_zip_read_info->rest_read_compressed<uReadThis)
+				uReadThis = (uInt)pfile_in_zip_read_info->rest_read_compressed;
+			if (uReadThis == 0)
+				return UNZ_EOF;
+			if (s->cur_file_info.compressed_size == pfile_in_zip_read_info->rest_read_compressed)
+				if (ZIP_fseek(pfile_in_zip_read_info->file,
+						  pfile_in_zip_read_info->pos_in_zipfile + 
+							 pfile_in_zip_read_info->byte_before_the_zipfile,SEEK_SET)!=0)
+					return UNZ_ERRNO;
+			if (ZIP_fread(pfile_in_zip_read_info->read_buffer,uReadThis,1,
+                         pfile_in_zip_read_info->file)!=1)
+				return UNZ_ERRNO;
+			pfile_in_zip_read_info->pos_in_zipfile += uReadThis;
+
+			pfile_in_zip_read_info->rest_read_compressed-=uReadThis;
+			
+			pfile_in_zip_read_info->stream.next_in = 
+                (Byte*)pfile_in_zip_read_info->read_buffer;
+			pfile_in_zip_read_info->stream.avail_in = (uInt)uReadThis;
+		}
+
+		if (pfile_in_zip_read_info->compression_method==0)
+		{
+			uInt uDoCopy,i ;
+			if (pfile_in_zip_read_info->stream.avail_out < 
+                            pfile_in_zip_read_info->stream.avail_in)
+				uDoCopy = pfile_in_zip_read_info->stream.avail_out ;
+			else
+				uDoCopy = pfile_in_zip_read_info->stream.avail_in ;
+				
+			for (i=0;i<uDoCopy;i++)
+				*(pfile_in_zip_read_info->stream.next_out+i) =
+                        *(pfile_in_zip_read_info->stream.next_in+i);
+					
+			pfile_in_zip_read_info->crc32 = crc32(pfile_in_zip_read_info->crc32,
+								pfile_in_zip_read_info->stream.next_out,
+								uDoCopy);
+			pfile_in_zip_read_info->rest_read_uncompressed-=uDoCopy;
+			pfile_in_zip_read_info->stream.avail_in -= uDoCopy;
+			pfile_in_zip_read_info->stream.avail_out -= uDoCopy;
+			pfile_in_zip_read_info->stream.next_out += uDoCopy;
+			pfile_in_zip_read_info->stream.next_in += uDoCopy;
+            pfile_in_zip_read_info->stream.total_out += uDoCopy;
+			iRead += uDoCopy;
+		}
+		else
+		{
+			uLong uTotalOutBefore,uTotalOutAfter;
+			const Byte *bufBefore;
+			uLong uOutThis;
+
+			uTotalOutBefore = pfile_in_zip_read_info->stream.total_out;
+			bufBefore = pfile_in_zip_read_info->stream.next_out;
+
+			/*
+			if ((pfile_in_zip_read_info->rest_read_uncompressed ==
+			         pfile_in_zip_read_info->stream.avail_out) &&
+				(pfile_in_zip_read_info->rest_read_compressed == 0))
+				flush = Z_FINISH;
+			*/
+			err=inflate(&pfile_in_zip_read_info->stream);
+
+			uTotalOutAfter = pfile_in_zip_read_info->stream.total_out;
+			uOutThis = uTotalOutAfter-uTotalOutBefore;
+			
+			pfile_in_zip_read_info->crc32 = 
+                crc32(pfile_in_zip_read_info->crc32,bufBefore,
+                        (uInt)(uOutThis));
+
+			pfile_in_zip_read_info->rest_read_uncompressed -=
+                uOutThis;
+
+			iRead += (uInt)(uTotalOutAfter - uTotalOutBefore);
+            
+			if (err==Z_STREAM_END)
+				return (iRead==0) ? UNZ_EOF : iRead;
+			if (err!=Z_OK) 
+				break;
+		}
+	}
+
+	if (err==Z_OK)
+		return iRead;
+	return err;
+}
+
+
+/*
+  Give the current position in uncompressed data
+*/
+extern long unztell (unzFile file)
+{
+	unz_s* s;
+	file_in_zip_read_info_s* pfile_in_zip_read_info;
+	if (file==NULL)
+		return UNZ_PARAMERROR;
+	s=(unz_s*)file;
+    pfile_in_zip_read_info=s->pfile_in_zip_read;
+
+	if (pfile_in_zip_read_info==NULL)
+		return UNZ_PARAMERROR;
+
+	return (long)pfile_in_zip_read_info->stream.total_out;
+}
+
+
+/*
+  return 1 if the end of file was reached, 0 elsewhere 
+*/
+extern int unzeof (unzFile file)
+{
+	unz_s* s;
+	file_in_zip_read_info_s* pfile_in_zip_read_info;
+	if (file==NULL)
+		return UNZ_PARAMERROR;
+	s=(unz_s*)file;
+    pfile_in_zip_read_info=s->pfile_in_zip_read;
+
+	if (pfile_in_zip_read_info==NULL)
+		return UNZ_PARAMERROR;
+	
+	if (pfile_in_zip_read_info->rest_read_uncompressed == 0)
+		return 1;
+	else
+		return 0;
+}
+
+
+
+/*
+  Read extra field from the current file (opened by unzOpenCurrentFile)
+  This is the static-header version of the extra field (sometimes, there is
+    more info in the static-header version than in the central-header)
+
+  if buf==NULL, it return the size of the static extra field that can be read
+
+  if buf!=NULL, len is the size of the buffer, the extra header is copied in
+	buf.
+  the return value is the number of bytes copied in buf, or (if <0) 
+	the error code
+*/
+extern int unzGetLocalExtrafield (unzFile file,void *buf,unsigned len)
+{
+	unz_s* s;
+	file_in_zip_read_info_s* pfile_in_zip_read_info;
+	uInt read_now;
+	uLong size_to_read;
+
+	if (file==NULL)
+		return UNZ_PARAMERROR;
+	s=(unz_s*)file;
+    pfile_in_zip_read_info=s->pfile_in_zip_read;
+
+	if (pfile_in_zip_read_info==NULL)
+		return UNZ_PARAMERROR;
+
+	size_to_read = (pfile_in_zip_read_info->size_local_extrafield - 
+				pfile_in_zip_read_info->pos_local_extrafield);
+
+	if (buf==NULL)
+		return (int)size_to_read;
+	
+	if (len>size_to_read)
+		read_now = (uInt)size_to_read;
+	else
+		read_now = (uInt)len ;
+
+	if (read_now==0)
+		return 0;
+	
+	if (ZIP_fseek(pfile_in_zip_read_info->file,
+              pfile_in_zip_read_info->offset_local_extrafield + 
+			  pfile_in_zip_read_info->pos_local_extrafield,SEEK_SET)!=0)
+		return UNZ_ERRNO;
+
+	if (ZIP_fread(buf,(uInt)size_to_read,1,pfile_in_zip_read_info->file)!=1)
+		return UNZ_ERRNO;
+
+	return (int)read_now;
+}
+
+/*
+  Close the file in zip opened with unzipOpenCurrentFile
+  Return UNZ_CRCERROR if all the file was read but the CRC is not good
+*/
+extern int unzCloseCurrentFile (unzFile file)
+{
+	int err=UNZ_OK;
+
+	unz_s* s;
+	file_in_zip_read_info_s* pfile_in_zip_read_info;
+	if (file==NULL)
+		return UNZ_PARAMERROR;
+	s=(unz_s*)file;
+    pfile_in_zip_read_info=s->pfile_in_zip_read;
+
+	if (pfile_in_zip_read_info==NULL)
+		return UNZ_PARAMERROR;
+
+
+	if (pfile_in_zip_read_info->rest_read_uncompressed == 0)
+	{
+		if (pfile_in_zip_read_info->crc32 != pfile_in_zip_read_info->crc32_wait)
+			err=UNZ_CRCERROR;
+	}
+
+
+	TRYFREE(pfile_in_zip_read_info->read_buffer);
+	pfile_in_zip_read_info->read_buffer = NULL;
+	if (pfile_in_zip_read_info->stream_initialised)
+		inflateEnd(&pfile_in_zip_read_info->stream);
+
+	pfile_in_zip_read_info->stream_initialised = 0;
+	TRYFREE(pfile_in_zip_read_info);
+
+    s->pfile_in_zip_read=NULL;
+
+	return err;
+}
+
+
+/*
+  Get the global comment string of the ZipFile, in the szComment buffer.
+  uSizeBuf is the size of the szComment buffer.
+  return the number of byte copied or an error code <0
+*/
+extern int unzGetGlobalComment (unzFile file, char *szComment, uLong uSizeBuf)
+{
+	unz_s* s;
+	uLong uReadThis ;
+	if (file==NULL)
+		return UNZ_PARAMERROR;
+	s=(unz_s*)file;
+
+	uReadThis = uSizeBuf;
+	if (uReadThis>s->gi.size_comment)
+		uReadThis = s->gi.size_comment;
+
+	if (ZIP_fseek(s->file,s->central_pos+22,SEEK_SET)!=0)
+		return UNZ_ERRNO;
+
+	if (uReadThis>0)
+    {
+      *szComment='\0';
+	  if (ZIP_fread(szComment,(uInt)uReadThis,1,s->file)!=1)
+		return UNZ_ERRNO;
+    }
+
+	if ((szComment != NULL) && (uSizeBuf > s->gi.size_comment))
+		*(szComment+s->gi.size_comment)='\0';
+	return (int)uReadThis;
+}
+
+// end
diff --git a/code/qcommon/unzip.h b/code/qcommon/unzip.h
new file mode 100644
index 0000000..0e46bbe
--- /dev/null
+++ b/code/qcommon/unzip.h
@@ -0,0 +1,286 @@
+
+#if defined(STRICTUNZIP) || defined(STRICTZIPUNZIP)
+/* like the STRICT of WIN32, we define a pointer that cannot be converted
+    from (void*) without cast */
+typedef struct TagunzFile__ { int unused; } unzFile__; 
+typedef unzFile__ *unzFile;
+#else
+typedef void* unzFile;
+#endif
+
+#define ZIP_FILE	FILE
+
+/* tm_unz contain date/time info */
+typedef struct tm_unz_s 
+{
+	unsigned int tm_sec;            /* seconds after the minute - [0,59] */
+	unsigned int tm_min;            /* minutes after the hour - [0,59] */
+	unsigned int tm_hour;           /* hours since midnight - [0,23] */
+	unsigned int tm_mday;           /* day of the month - [1,31] */
+	unsigned int tm_mon;            /* months since January - [0,11] */
+	unsigned int tm_year;           /* years - [1980..2044] */
+} tm_unz;
+
+/* unz_global_info structure contain global data about the ZIPfile
+   These data comes from the end of central dir */
+typedef struct unz_global_info_s
+{
+	unsigned long number_entry;         /* total number of entries in the central dir on this disk */
+	unsigned long size_comment;         /* size of the global comment of the zipfile */
+} unz_global_info;
+
+
+/* unz_file_info contain information about a file in the zipfile */
+typedef struct unz_file_info_s
+{
+    unsigned long version;              /* version made by                 2 unsigned chars */
+    unsigned long version_needed;       /* version needed to extract       2 unsigned chars */
+    unsigned long flag;                 /* general purpose bit flag        2 unsigned chars */
+    unsigned long compression_method;   /* compression method              2 unsigned chars */
+    unsigned long dosDate;              /* last mod file date in Dos fmt   4 unsigned chars */
+    unsigned long crc;                  /* crc-32                          4 unsigned chars */
+    unsigned long compressed_size;      /* compressed size                 4 unsigned chars */ 
+    unsigned long uncompressed_size;    /* uncompressed size               4 unsigned chars */ 
+    unsigned long size_filename;        /* filename length                 2 unsigned chars */
+    unsigned long size_file_extra;      /* extra field length              2 unsigned chars */
+    unsigned long size_file_comment;    /* file comment length             2 unsigned chars */
+
+    unsigned long disk_num_start;       /* disk number start               2 unsigned chars */
+    unsigned long internal_fa;          /* internal file attributes        2 unsigned chars */
+    unsigned long external_fa;          /* external file attributes        4 unsigned chars */
+
+    tm_unz tmu_date;
+} unz_file_info;
+
+/* unz_file_info_interntal contain internal info about a file in zipfile*/
+typedef struct unz_file_info_internal_s
+{
+    unsigned long offset_curfile;/* relative offset of static header 4 unsigned chars */
+} unz_file_info_internal;
+
+/* file_in_zip_read_info_s contain internal information about a file in zipfile,
+    when reading and decompress it */
+typedef struct
+{
+	char  *read_buffer;         /* internal buffer for compressed data */
+	z_stream stream;            /* zLib stream structure for inflate */
+
+	unsigned long pos_in_zipfile;       /* position in unsigned char on the zipfile, for fseek*/
+	unsigned long stream_initialised;   /* flag set if stream structure is initialised*/
+
+	unsigned long offset_local_extrafield;/* offset of the static extra field */
+	unsigned int  size_local_extrafield;/* size of the static extra field */
+	unsigned long pos_local_extrafield;   /* position in the static extra field in read*/
+
+	unsigned long crc32;                /* crc32 of all data uncompressed */
+	unsigned long crc32_wait;           /* crc32 we must obtain after decompress all */
+	unsigned long rest_read_compressed; /* number of unsigned char to be decompressed */
+	unsigned long rest_read_uncompressed;/*number of unsigned char to be obtained after decomp*/
+	ZIP_FILE *file;                 /* io structore of the zipfile */
+	unsigned long compression_method;   /* compression method (0==store) */
+	unsigned long byte_before_the_zipfile;/* unsigned char before the zipfile, (>0 for sfx)*/
+} file_in_zip_read_info_s;
+
+
+/* unz_s contain internal information about the zipfile
+*/
+typedef struct
+{
+	ZIP_FILE* file;                 /* io structore of the zipfile */
+	unz_global_info gi;       /* public global information */
+	unsigned long byte_before_the_zipfile;/* unsigned char before the zipfile, (>0 for sfx)*/
+	unsigned long num_file;             /* number of the current file in the zipfile*/
+	unsigned long pos_in_central_dir;   /* pos of the current file in the central dir*/
+	unsigned long current_file_ok;      /* flag about the usability of the current file*/
+	unsigned long central_pos;          /* position of the beginning of the central dir*/
+
+	unsigned long size_central_dir;     /* size of the central directory  */
+	unsigned long offset_central_dir;   /* offset of start of central directory with
+								   respect to the starting disk number */
+
+	unz_file_info cur_file_info; /* public info about the current file in zip*/
+	unz_file_info_internal cur_file_info_internal; /* private info about it*/
+    file_in_zip_read_info_s* pfile_in_zip_read; /* structure about the current
+	                                    file if we are decompressing it */
+} unz_s;
+
+#define UNZ_OK                                  (0)
+#define UNZ_END_OF_LIST_OF_FILE (-100)
+#define UNZ_ERRNO               (Z_DATA_ERROR)
+#define UNZ_EOF                 (0)
+#define UNZ_PARAMERROR                  (-102)
+#define UNZ_BADZIPFILE                  (-103)
+#define UNZ_INTERNALERROR               (-104)
+#define UNZ_CRCERROR                    (-105)
+
+#define UNZ_CASESENSITIVE		1
+#define UNZ_NOTCASESENSITIVE	2
+#define UNZ_OSDEFAULTCASE		0
+
+extern int unzStringFileNameCompare (const char* fileName1, const char* fileName2, int iCaseSensitivity);
+
+/*
+   Compare two filename (fileName1,fileName2).
+   If iCaseSenisivity = 1, comparision is case sensitivity (like strcmp)
+   If iCaseSenisivity = 2, comparision is not case sensitivity (like strcmpi
+								or strcasecmp)
+   If iCaseSenisivity = 0, case sensitivity is defaut of your operating system
+	(like 1 on Unix, 2 on Windows)
+*/
+
+extern unzFile unzOpen (const char *path);
+extern unzFile unzReOpen (const char* path, unzFile file);
+
+/*
+  Open a Zip file. path contain the full pathname (by example,
+     on a Windows NT computer "c:\\zlib\\zlib111.zip" or on an Unix computer
+	 "zlib/zlib111.zip".
+	 If the zipfile cannot be opened (file don't exist or in not valid), the
+	   return value is NULL.
+     Else, the return value is a unzFile Handle, usable with other function
+	   of this unzip package.
+*/
+
+extern int unzClose (unzFile file);
+
+/*
+  Close a ZipFile opened with unzipOpen.
+  If there is files inside the .Zip opened with unzOpenCurrentFile (see later),
+    these files MUST be closed with unzipCloseCurrentFile before call unzipClose.
+  return UNZ_OK if there is no problem. */
+
+extern int unzGetGlobalInfo (unzFile file, unz_global_info *pglobal_info);
+
+/*
+  Write info about the ZipFile in the *pglobal_info structure.
+  No preparation of the structure is needed
+  return UNZ_OK if there is no problem. */
+
+
+extern int unzGetGlobalComment (unzFile file, char *szComment, unsigned long uSizeBuf);
+
+/*
+  Get the global comment string of the ZipFile, in the szComment buffer.
+  uSizeBuf is the size of the szComment buffer.
+  return the number of unsigned char copied or an error code <0
+*/
+
+
+/***************************************************************************/
+/* Unzip package allow you browse the directory of the zipfile */
+
+extern int unzGoToFirstFile (unzFile file);
+
+/*
+  Set the current file of the zipfile to the first file.
+  return UNZ_OK if there is no problem
+*/
+
+extern int unzGoToNextFile (unzFile file);
+
+/*
+  Set the current file of the zipfile to the next file.
+  return UNZ_OK if there is no problem
+  return UNZ_END_OF_LIST_OF_FILE if the actual file was the latest.
+*/
+
+extern int unzGetCurrentFileInfoPosition (unzFile file, unsigned long *pos );
+
+/*
+  Get the position of the info of the current file in the zip.
+  return UNZ_OK if there is no problem
+*/
+
+extern int unzSetCurrentFileInfoPosition (unzFile file, unsigned long pos );
+
+/*
+  Set the position of the info of the current file in the zip.
+  return UNZ_OK if there is no problem
+*/
+
+extern int unzLocateFile (unzFile file, const char *szFileName, int iCaseSensitivity);
+
+/*
+  Try locate the file szFileName in the zipfile.
+  For the iCaseSensitivity signification, see unzStringFileNameCompare
+
+  return value :
+  UNZ_OK if the file is found. It becomes the current file.
+  UNZ_END_OF_LIST_OF_FILE if the file is not found
+*/
+
+
+extern int unzGetCurrentFileInfo (unzFile file, unz_file_info *pfile_info, char *szFileName, unsigned long fileNameBufferSize, void *extraField, unsigned long extraFieldBufferSize, char *szComment, unsigned long commentBufferSize);
+
+/*
+  Get Info about the current file
+  if pfile_info!=NULL, the *pfile_info structure will contain somes info about
+	    the current file
+  if szFileName!=NULL, the filemane string will be copied in szFileName
+			(fileNameBufferSize is the size of the buffer)
+  if extraField!=NULL, the extra field information will be copied in extraField
+			(extraFieldBufferSize is the size of the buffer).
+			This is the Central-header version of the extra field
+  if szComment!=NULL, the comment string of the file will be copied in szComment
+			(commentBufferSize is the size of the buffer)
+*/
+
+/***************************************************************************/
+/* for reading the content of the current zipfile, you can open it, read data
+   from it, and close it (you can close it before reading all the file)
+   */
+
+extern int unzOpenCurrentFile (unzFile file);
+
+/*
+  Open for reading data the current file in the zipfile.
+  If there is no error, the return value is UNZ_OK.
+*/
+
+extern int unzCloseCurrentFile (unzFile file);
+
+/*
+  Close the file in zip opened with unzOpenCurrentFile
+  Return UNZ_CRCERROR if all the file was read but the CRC is not good
+*/
+
+												
+extern int unzReadCurrentFile (unzFile file, void* buf, unsigned len);
+
+/*
+  Read unsigned chars from the current file (opened by unzOpenCurrentFile)
+  buf contain buffer where data must be copied
+  len the size of buf.
+
+  return the number of unsigned char copied if somes unsigned chars are copied
+  return 0 if the end of file was reached
+  return <0 with error code if there is an error
+    (UNZ_ERRNO for IO error, or zLib error for uncompress error)
+*/
+
+extern long unztell(unzFile file);
+
+/*
+  Give the current position in uncompressed data
+*/
+
+extern int unzeof (unzFile file);
+
+/*
+  return 1 if the end of file was reached, 0 elsewhere 
+*/
+
+extern int unzGetLocalExtrafield (unzFile file, void* buf, unsigned len);
+
+/*
+  Read extra field from the current file (opened by unzOpenCurrentFile)
+  This is the local-header version of the extra field (sometimes, there is
+    more info in the local-header version than in the central-header)
+
+  if buf==NULL, it return the size of the local extra field
+
+  if buf!=NULL, len is the size of the buffer, the extra header is copied in
+	buf.
+  the return value is the number of unsigned chars copied in buf, or (if <0) 
+	the error code
+*/
diff --git a/code/qcommon/vssver.scc b/code/qcommon/vssver.scc
new file mode 100644
index 0000000..8567cec
Binary files /dev/null and b/code/qcommon/vssver.scc differ
diff --git a/code/qcommon/z_memman_console.cpp b/code/qcommon/z_memman_console.cpp
new file mode 100644
index 0000000..ac16c48
--- /dev/null
+++ b/code/qcommon/z_memman_console.cpp
@@ -0,0 +1,1843 @@
+
+/*
+ * UNPUBLISHED -- Rights  reserved  under  the  copyright  laws  of the 
+ * United States.  Use  of a copyright notice is precautionary only and 
+ * does not imply publication or disclosure.                            
+ *                                                                      
+ * THIS DOCUMENTATION CONTAINS CONFIDENTIAL AND PROPRIETARY INFORMATION 
+ * OF    VICARIOUS   VISIONS,  INC.    ANY  DUPLICATION,  MODIFICATION, 
+ * DISTRIBUTION, OR DISCLOSURE IS STRICTLY PROHIBITED WITHOUT THE PRIOR 
+ * EXPRESS WRITTEN PERMISSION OF VICARIOUS VISIONS, INC.
+ */
+
+/*
+ *	ZONE MEMORY MANAGER
+ *
+ *	Goals:
+ *		1. Minimize overhead
+ *		2. Minimize fragmentation
+ *
+ *	Constraints:
+ *		1. Maximum allocated block size is 32MB
+ *		2. Maximum 64 different memory tags supported
+ *		3. Maximum 256 byte alignment
+ *
+ *	All memory required by the manager is allocated at startup in
+ *	the form of one large pool.
+ *
+ *	Allocated blocks require a 4 byte header to store size, tag, and
+ *	alignment information.  Blocks that need to support the Z_TagFree()
+ *	feature require an additional 8 byte link list structure.
+ *
+ *	Free blocks require a 16 bytes of tracking information.  If possible
+ *	this information is stored directly in the block (which is in the
+ *	pool.)  If the free block is not large enough, its information is
+ *	stored in an overflow buffer.
+ *
+ *	In an effort to reduce fragmentation, blocks allocated for a short
+ *	period of time at the end of the pool.  All other blocks are allocated
+ *	at the start.  Allocation is first fit.
+ *
+ */
+
+#include "../game/q_shared.h"
+#include "qcommon.h"
+#include "../renderer/qgl_console.h"
+
+#ifdef _GAMECUBE
+#include <dolphin/os.h>
+#endif
+
+#ifdef _WINDOWS
+#include <windows.h>
+#endif
+
+#ifdef _XBOX
+#include <Xtl.h>
+#endif
+
+// Used to mark the start and end of blocks in debug mode
+#define ZONE_MAGIC 0xfe
+
+// Size of the free block overflow buffer
+#define ZONE_FREE_OVERFLOW 4096
+
+// Indicates whether or not special (slow) debug code should be enabled
+#define ZONE_DEBUG 0
+
+// Allocate all available memory minus this amount
+#ifdef _GAMECUBE
+#define ZONE_HEAP_FREE_DEBUG (64*1024*4)
+#define ZONE_HEAP_FREE_RELEASE (0)
+
+#ifdef _DEBUG
+#	define ZONE_HEAP_FREE ZONE_HEAP_FREE_DEBUG
+#else
+#	define ZONE_HEAP_FREE ZONE_HEAP_FREE_RELEASE
+#endif
+#else
+//Game needs about 8 MB for framebuffers audio, bink, etc., plus 17 MB (?)
+//for textures. Leave lots more physical memory around when not in 64 MB
+//map, so the profiler and other things work.
+#ifdef FINAL_BUILD
+#	define ZONE_HEAP_FREE (1024*1024*8 + 17*1024*1024)
+#else
+#	define ZONE_HEAP_FREE (1024*1024*16 + 16*1024*1024 + 16*1024*1024)
+#endif
+#endif
+
+// Should we emulate the smaller memory footprint of actual release systems?
+#define ZONE_EMULATE_SPACE 0
+
+// All standard header data is crammed into 4 bytes
+typedef unsigned int ZoneHeader;
+
+// Debug markers to check for overflow/underflow
+typedef unsigned int ZoneDebugHeader;
+typedef unsigned char ZoneDebugFooter;
+
+// Extended header information for memory freed with TagFree()
+struct ZoneLinkHeader
+{
+	ZoneLinkHeader* m_Next;
+	ZoneLinkHeader* m_Prev;
+};
+
+static ZoneLinkHeader* s_LinkBase;
+
+// Free memory block tracking information
+struct ZoneFreeBlock
+{
+	unsigned int m_Address;
+	unsigned int m_Size;
+	ZoneFreeBlock* m_Next;
+	ZoneFreeBlock* m_Prev;
+};
+
+// Buffer to hold free memory information that we can't
+// fit directly in the pool
+static ZoneFreeBlock s_FreeOverflow[ZONE_FREE_OVERFLOW];
+static int s_LastOverflowIndex;
+
+static ZoneFreeBlock s_FreeStart;
+static ZoneFreeBlock s_FreeEnd;
+
+// Various stats collected at runtime
+struct ZoneStats
+{
+	int	m_CountAlloc;
+	int m_SizeAlloc;
+	int m_OverheadAlloc;
+	int	m_PeakAlloc;
+	int	m_CountFree;
+	int m_SizeFree;
+	int	m_SizesPerTag[TAG_COUNT];
+	int	m_CountsPerTag[TAG_COUNT];	
+};
+
+static ZoneStats s_Stats;
+
+// Special empty block for zero size allocations
+struct ZoneEmptyBlock
+{
+	ZoneHeader header;
+#ifdef _DEBUG
+	ZoneDebugHeader start;
+	ZoneDebugFooter end;
+#endif
+};
+
+#ifdef _DEBUG
+static ZoneEmptyBlock s_EmptyBlock = {TAG_STATIC << 25, ZONE_MAGIC, ZONE_MAGIC};
+#else
+static ZoneEmptyBlock s_EmptyBlock = {TAG_STATIC << 25};
+#endif
+
+// Free block jump table for fast memory deallocation
+#define Z_JUMP_TABLE_SIZE 64
+static ZoneFreeBlock* s_FreeJumpTable[Z_JUMP_TABLE_SIZE];
+static unsigned int s_FreeJumpResolution;
+
+static void* s_PoolBase;
+static bool s_Initialized = false;
+static bool s_IsNewDeleteTemp = false;
+
+#ifndef _GAMECUBE
+static HANDLE s_Mutex = INVALID_HANDLE_VALUE;
+#endif
+
+static void Z_Stats_f(void);
+void Z_Details_f(void);
+void Z_DumpMemMap_f(void);
+
+
+#ifdef _XBOX
+void ShowOSMemory(void)
+{
+	MEMORYSTATUS stat;
+	GlobalMemoryStatus(&stat);
+	Com_Printf("     total mem: %d, free mem: %d\n", stat.dwTotalPhys / 1024,
+			stat.dwAvailPhys / 1024);
+	FILE *out = fopen("d:\\osmem.txt", "a");
+	if(out) {
+		fprintf(out, "total mem: %d, free mem: %d\n", stat.dwTotalPhys / 1024,
+				stat.dwAvailPhys / 1024);
+		fclose(out);
+	}
+}
+#endif
+
+
+int Z_MemFree(void)
+{
+	return s_Stats.m_SizeFree;
+}
+
+
+void Com_InitZoneMemory(void)
+{
+//	assert(!s_Initialized);
+	// Zone now initializes on first use, can't reliably assume anything here
+	if (s_Initialized)
+		return;
+
+	Com_Printf("Initialising zone memory .....\n");
+
+	// Clear some globals
+	memset(&s_Stats, 0, sizeof(s_Stats));
+	memset(s_FreeOverflow, 0, sizeof(s_FreeOverflow));
+	s_LastOverflowIndex = 0;
+	s_LinkBase = NULL;
+	s_IsNewDeleteTemp = false;
+
+	// Alloc the pool
+#if defined(_XBOX)
+	MEMORYSTATUS status;
+	GlobalMemoryStatus(&status);
+
+	// BTO : VVFIXME - Extra little note to see how much memory
+	// is being used by globals/statics
+	Com_Printf("*** PhysRAM: %d used, %d free\n",
+				status.dwTotalPhys-status.dwAvailPhys,
+				status.dwAvailPhys);
+	SIZE_T size;
+#	if ZONE_EMULATE_SPACE
+#ifdef _DEBUG
+	//Emulated space is always about 6 megs off from release build.  Try
+	//to compensate.  This number may need tweaking in the future.
+	SIZE_T exe = 6500 * 1024;
+#else
+	SIZE_T exe = 0; //Exe size is already reflected in GlobalMemoryStatus().
+#endif
+	size = 0x4000000 - (exe + ZONE_HEAP_FREE);
+#	else
+	size = status.dwAvailPhys - ZONE_HEAP_FREE;
+#	endif
+	s_PoolBase = GlobalAlloc(0, size);
+#elif defined(_WINDOWS)
+	SIZE_T size = 50*1024*1024;
+	s_PoolBase = GlobalAlloc(0, size);
+#endif
+
+	// Setup the initial free block
+	ZoneFreeBlock* base = (ZoneFreeBlock*)s_PoolBase;
+	base->m_Address = (unsigned int)s_PoolBase;
+	base->m_Size = size;
+	base->m_Next = &s_FreeEnd;
+	base->m_Prev = &s_FreeStart;
+
+	// Init the free block jump table
+	memset(s_FreeJumpTable, 0, Z_JUMP_TABLE_SIZE * sizeof(ZoneFreeBlock*));
+	s_FreeJumpResolution = (size / Z_JUMP_TABLE_SIZE) + 1;
+	s_FreeJumpTable[0] = base;
+
+	// Setup free block dummies
+	s_FreeStart.m_Address = 0;
+	s_FreeStart.m_Size = 0;
+	s_FreeStart.m_Next = base;
+	s_FreeStart.m_Prev = NULL;
+
+	s_FreeEnd.m_Address = 0xFFFFFFFF;
+	s_FreeEnd.m_Size = 0;
+	s_FreeEnd.m_Next = NULL;
+	s_FreeEnd.m_Prev = base;
+
+	s_Stats.m_CountFree = 1;
+	s_Stats.m_SizeFree = size;
+
+	s_Initialized = true;
+
+	// Add some commands
+	Cmd_AddCommand("zone_stats",	Z_Stats_f);
+	Cmd_AddCommand("zone_details",	Z_Details_f);
+	Cmd_AddCommand("zone_memmap",	Z_DumpMemMap_f);
+
+#ifndef _GAMECUBE
+	s_Mutex = CreateMutex(NULL, FALSE, NULL);
+#endif
+}
+
+void Com_ShutdownZoneMemory(void)
+{
+	assert(s_Initialized);
+
+	// Remove commands
+	Cmd_RemoveCommand("zone_stats");
+	Cmd_RemoveCommand("zone_details");
+	Cmd_RemoveCommand("zone_memmap");
+
+	if (s_Stats.m_CountAlloc)
+	{
+		// Free all memory
+//		CM_ReleaseVisData();
+		Z_TagFree(TAG_ALL);
+	}
+	
+	// Clear some globals
+	memset(&s_Stats, 0, sizeof(s_Stats));
+	memset(s_FreeOverflow, 0, sizeof(s_FreeOverflow));
+	s_LastOverflowIndex = 0;
+	s_LinkBase = NULL;
+
+	// Free the pool
+#ifndef _GAMECUBE
+	GlobalFree(s_PoolBase);
+	CloseHandle(s_Mutex);
+#endif
+
+	s_PoolBase = NULL;
+	s_Initialized = false;
+}
+
+
+// Determine if a tag should only be allocated for a very
+// short period of time.
+static bool Z_IsTagTemp(memtag_t eTag)
+{
+	return 
+		eTag == TAG_TEMP_WORKSPACE || 
+#ifndef _JK2MP
+		eTag == TAG_TEMP_SAVEGAME_WORKSPACE ||
+		eTag == TAG_STRING ||
+#endif
+//		eTag == TAG_TEMP_SND_RAWDATA ||
+		eTag == TAG_SND_RAWDATA ||
+		eTag == TAG_ICARUS ||
+		eTag == TAG_LISTFILES ||
+#ifdef _JK2MP
+		eTag == TAG_TEXTPOOL;
+#else
+		eTag == TAG_GP2;
+#endif
+//		eTag == TAG_BINK;
+}
+
+// Determine if a tag needs TagFree() support.
+static bool Z_IsTagLinked(memtag_t eTag)
+{
+	return
+//		eTag == TAG_BOTGAME ||
+		eTag == TAG_BSP ||
+		eTag == TAG_HUNKALLOC ||
+#ifndef _JK2MP
+		eTag == TAG_HUNKMISCMODELS ||
+		eTag == TAG_G_ALLOC ||
+#endif
+#ifdef _JK2MP
+		eTag == TAG_CG_UI_ALLOC ||
+		eTag == TAG_BG_ALLOC ||
+#endif
+		eTag == TAG_UI_ALLOC;
+}
+
+static int Z_CalcAlignmentPad(int iAlign, unsigned int iAddress, unsigned int iOffset, 
+	unsigned int iSize, unsigned int iHeaderSize, unsigned int iFooterSize)
+{
+	int align_size;
+
+	if (iAlign == 0) return 0;
+	
+	if (iOffset == 0)
+	{
+		// Align data at low end of block
+		align_size = iAlign - 
+			((iAddress + iHeaderSize) % iAlign);
+	}
+	else
+	{
+		// Align data at high end of block
+		unsigned int block_start = iAddress + iOffset - 
+			iSize + iHeaderSize;
+		align_size = block_start % iAlign;
+	}
+	
+	if (align_size == iAlign)
+	{
+		return 0;
+	}
+
+	return align_size;
+}
+
+static ZoneFreeBlock* Z_GetOverflowBlock(void)
+{
+	for (int i = s_LastOverflowIndex; i < ZONE_FREE_OVERFLOW; ++i)
+	{
+		if (s_FreeOverflow[i].m_Address == 0)
+		{
+			s_LastOverflowIndex = i;
+			return &s_FreeOverflow[i];
+		}
+	}
+
+	for (int j = 0; j < s_LastOverflowIndex; ++j)
+	{
+		if (s_FreeOverflow[j].m_Address == 0)
+		{
+			s_LastOverflowIndex = j;
+			return &s_FreeOverflow[j];
+		}
+	}
+
+	return NULL;
+}
+
+static inline bool Z_IsFreeBlockLargeEnough(ZoneFreeBlock* pBlock, int iSize, 
+	int iHeaderSize, int iFooterSize, int iAlign, bool bLow, int& iAlignPad)
+{
+	// Is the block large enough?
+	if (pBlock->m_Size >= iSize)
+	{
+		if (iAlign > 0)
+		{
+			// If we need some aligment, we need to check size
+			// against that as well.
+			iAlignPad = Z_CalcAlignmentPad(iAlign,
+				pBlock->m_Address, !bLow ? pBlock->m_Size : 0,
+				iSize, iHeaderSize, iFooterSize);
+
+			if (pBlock->m_Size < iAlignPad + iSize)
+			{
+				return false;
+			}
+		}
+		return true;
+	}
+	return false;
+}
+
+static ZoneFreeBlock* Z_FindFirstFree(int iSize, int iHeaderSize, 
+	int iFooterSize, int iAlign, int& iAlignPad)
+{
+	for (ZoneFreeBlock* block = s_FreeStart.m_Next; block; block = block->m_Next)
+	{
+		if (Z_IsFreeBlockLargeEnough(block, iSize, iHeaderSize, iFooterSize,
+			iAlign, true, iAlignPad))
+		{
+			return block;
+		}
+	}
+	return NULL;
+}
+
+static ZoneFreeBlock* Z_FindLastFree(int iSize, int iHeaderSize, 
+	int iFooterSize, int iAlign, int& iAlignPad)
+{
+	for (ZoneFreeBlock* block = s_FreeEnd.m_Prev; block; block = block->m_Prev)
+	{
+		if (Z_IsFreeBlockLargeEnough(block, iSize, iHeaderSize, iFooterSize,
+			iAlign, false, iAlignPad))
+		{
+			return block;
+		}
+	}
+	return NULL;
+}
+
+static bool Z_ValidateFree(void)
+{
+#if ZONE_DEBUG
+	// Make sure no free blocks are overlapping
+	for (ZoneFreeBlock* a = &s_FreeStart; a; a = a->m_Next)
+	{
+		if (a->m_Address == 0 && a->m_Size != 0)
+		{
+			return false;
+		}
+
+		for (ZoneFreeBlock* b = &s_FreeStart; b; b = b->m_Next)
+		{
+			if (a != b && 
+				a->m_Address >= b->m_Address && 
+				a->m_Address < b->m_Address + b->m_Size)
+			{
+				return false;
+			}
+		}
+	}
+#endif
+
+	return true;
+}
+
+static bool Z_ValidateLinks(void)
+{
+#if ZONE_DEBUG
+	// Make sure links are sane
+	for (ZoneLinkHeader* a = s_LinkBase; a; a = a->m_Next)
+	{
+		if ((a->m_Next && a != a->m_Next->m_Prev) ||
+			(a->m_Prev && a != a->m_Prev->m_Next))
+		{
+			return false;
+		}
+	}
+#endif
+
+	return true;
+}
+
+static int Z_GetJumpTableIndex(unsigned int iAddress)
+{
+	int index = (iAddress - (unsigned int)s_PoolBase) / s_FreeJumpResolution;
+	if (index < 0) return 0;
+	if (index >= Z_JUMP_TABLE_SIZE) return Z_JUMP_TABLE_SIZE - 1;
+	return index;
+}
+
+static ZoneFreeBlock* Z_GetFreeBlockBefore(unsigned int iAddress)
+{
+	// Find this block's position in the jump table
+	int index = Z_GetJumpTableIndex(iAddress) - 1;
+
+	// Find a valid jump table entry
+	while (index >= 0 && !s_FreeJumpTable[index]) --index;
+
+	if (index < 0) return &s_FreeStart;
+	return s_FreeJumpTable[index];
+}
+
+static void Z_RemoveFromJumpTable(ZoneFreeBlock* pBlock)
+{
+	// Is this block in the jump table?
+	int index = Z_GetJumpTableIndex(pBlock->m_Address);
+	if (s_FreeJumpTable[index] == pBlock)
+	{
+		// See if the next block will fit in our slot
+		if (pBlock->m_Next != &s_FreeEnd)
+		{
+			int nindex = Z_GetJumpTableIndex(pBlock->m_Next->m_Address);
+			if (nindex == index)
+			{
+				s_FreeJumpTable[index] = pBlock->m_Next;
+				return;
+			}
+		}
+
+		// See if the previous block will fit in our slot
+		if (pBlock->m_Prev != &s_FreeStart)
+		{
+			int pindex = Z_GetJumpTableIndex(pBlock->m_Prev->m_Address);
+			if (pindex == index)
+			{
+				s_FreeJumpTable[index] = pBlock->m_Prev;
+				return;
+			}
+		}
+
+		// No other free blocks fit here, give up
+		s_FreeJumpTable[index] = NULL;
+	}
+}
+
+static void Z_LinkFreeBlock(ZoneFreeBlock* pBlock)
+{
+	ZoneFreeBlock* cur = Z_GetFreeBlockBefore(pBlock->m_Address);
+	for (; cur; cur = cur->m_Next)
+	{
+		// Find the correct position, ordered by address
+		if (cur->m_Address > pBlock->m_Address)
+		{
+			// Link up the block
+			pBlock->m_Next = cur;
+			pBlock->m_Prev = cur->m_Prev;
+			cur->m_Prev->m_Next = pBlock;
+			cur->m_Prev = pBlock;
+
+			// Update the jump table if necessary
+			int index = Z_GetJumpTableIndex(pBlock->m_Address);
+			if (!s_FreeJumpTable[index])
+			{
+				s_FreeJumpTable[index] = pBlock;
+			}
+
+			s_Stats.m_CountFree++;
+			s_Stats.m_SizeFree += pBlock->m_Size;
+			
+			assert(Z_ValidateFree());
+			break;
+		}
+	}	
+}
+
+static void* Z_SplitFree(ZoneFreeBlock* pBlock, int iSize, bool bLow)
+{
+	assert(pBlock->m_Size >= iSize);
+	
+	Z_RemoveFromJumpTable(pBlock);
+
+	// Delink the free block
+	ZoneFreeBlock fblock = *pBlock;
+	pBlock->m_Prev->m_Next = pBlock->m_Next;
+	pBlock->m_Next->m_Prev = pBlock->m_Prev;
+	pBlock->m_Address = 0;
+
+	s_Stats.m_CountFree--;
+	s_Stats.m_SizeFree -= pBlock->m_Size;
+	assert(Z_ValidateFree());
+
+	if (fblock.m_Size > iSize)
+	{
+		// Split the block into an allocated and free portion
+		int remainder = fblock.m_Size - iSize;
+
+		if (remainder < sizeof(ZoneFreeBlock))
+		{
+			// Free portion is not large to hold free info --
+			// we're going to have to use the overflow buffer.
+			ZoneFreeBlock* nblock = Z_GetOverflowBlock();
+
+			if (nblock == NULL)
+			{
+				Z_Details_f();
+				Com_Error(ERR_FATAL, "Zone free overflow buffer overflowed!");
+			}
+
+			// Split the block
+			void* ret;
+			if (bLow)
+			{
+				ret = (void*)fblock.m_Address;
+				nblock->m_Address = fblock.m_Address + iSize;
+			}
+			else
+			{
+				ret = (void*)(fblock.m_Address + remainder);
+				nblock->m_Address = fblock.m_Address;
+			}
+	
+			nblock->m_Size = remainder;
+			Z_LinkFreeBlock(nblock);
+
+			return ret;
+		}
+		else
+		{
+			// Free portion is large enough -- split it
+			void* ret;
+			ZoneFreeBlock* nblock;
+			if (bLow)
+			{
+				ret = (void*)fblock.m_Address;
+				nblock = (ZoneFreeBlock*)(fblock.m_Address + iSize);
+			}
+			else
+			{
+				ret = (void*)(fblock.m_Address + remainder);
+				nblock = (ZoneFreeBlock*)fblock.m_Address;
+			}
+
+			nblock->m_Address = (unsigned int)nblock;
+			nblock->m_Size = remainder;
+			
+			Z_LinkFreeBlock(nblock);
+
+			return ret;
+		}
+	}
+	else
+	{
+		// No need to split, just return block.
+		return (void*)fblock.m_Address;
+	}
+}
+
+static void Z_SetupAlignmentPad(void* pBlock, int iAlignPad, bool bLow)
+{
+	// Clear alignment bytes
+	memset(pBlock, 0, iAlignPad);
+	
+	// If we have more than 1 alignment byte, the first align byte
+	// tells us how many additional bytes we have.
+	if (iAlignPad > 1)
+	{
+		assert(iAlignPad < 256);
+		unsigned char* ptr;
+		if (bLow)
+		{
+			ptr = (unsigned char*)pBlock + (iAlignPad - 1);
+		}
+		else
+		{
+			ptr = (unsigned char*)pBlock;
+		}
+		*ptr = iAlignPad - 1;
+	}
+}
+
+void Z_MallocFail(const char* pMessage, int iSize, memtag_t eTag)
+{
+	// Report the error
+//	Com_Printf("Z_Malloc(): %s : %d bytes and tag %d !!!!\n", pMessage, iSize, eTag);
+	Com_Printf("Z_Malloc(): %s : %d bytes and tag %d !!!!\n", pMessage, iSize, eTag);
+	Z_Details_f();
+	Z_DumpMemMap_f();
+//	Com_Printf("(Repeat): Z_Malloc(): %s : %d bytes and tag %d !!!!\n", pMessage, iSize, eTag);
+	Com_Printf("(Repeat): Z_Malloc(): %s : %d bytes and tag %d !!!!\n", pMessage, iSize, eTag);
+
+	// Clear the screen blue to indicate out of memory
+	for (;;)
+	{
+		qglBeginFrame();
+		qglClearColor(0, 0, 1, 1);
+		qglClear(GL_COLOR_BUFFER_BIT);
+		qglEndFrame();
+	}
+}
+
+void *Z_Malloc(int iSize, memtag_t eTag, qboolean bZeroit, int iAlign)
+{
+//	assert(s_Initialized);
+	// Zone now initializes on first use. (During static constructors)
+	if (!s_Initialized)
+		Com_InitZoneMemory();
+	
+	if (iSize == 0)
+	{
+#ifdef _DEBUG
+		return (void*)(&s_EmptyBlock.start + 1);
+#else
+		return (void*)(&s_EmptyBlock.header + 1);
+#endif
+	}
+
+	if (iSize < 0)
+	{
+		Z_MallocFail("Negative size", iSize, eTag);
+		return NULL;
+	}
+
+#ifndef _GAMECUBE
+	WaitForSingleObject(s_Mutex, INFINITE);
+#endif
+	
+	// Make new/delete memory temporary if requested
+	if (eTag == TAG_NEWDEL && s_IsNewDeleteTemp)
+	{
+		eTag = TAG_TEMP_WORKSPACE;
+	}
+
+	// Determine how much space we need with headers and footers
+	int header_size = sizeof(ZoneHeader);
+	int footer_size = 0;
+	if (Z_IsTagLinked(eTag))
+	{
+		header_size += sizeof(ZoneLinkHeader);
+	}
+#ifdef _DEBUG
+	header_size += sizeof(ZoneDebugHeader);
+	footer_size += sizeof(ZoneDebugFooter);
+#endif
+	int real_size = iSize + header_size + footer_size;
+	int align_pad = 0;
+
+	// Get a bit of free memory.  Temporary memory is allocated
+	// from the end.  More permanent allocations are done at the
+	// begining of the pool.
+	ZoneFreeBlock* fblock;
+	if (Z_IsTagTemp(eTag))
+	{
+		fblock = Z_FindLastFree(real_size, header_size, footer_size, 
+			iAlign, align_pad);
+	}
+	else
+	{
+		fblock = Z_FindFirstFree(real_size, header_size, footer_size, 
+			iAlign, align_pad);
+	}
+
+	// Did we actually find some memory?
+	if (!fblock)
+	{
+#ifndef _GAMECUBE
+		ReleaseMutex(s_Mutex);
+#endif
+//		if(eTag == TAG_TEMP_SND_RAWDATA) {
+		if(eTag == TAG_SND_RAWDATA) {
+			return NULL;
+		}
+
+		Z_MallocFail("Out of memory", iSize, eTag);
+		return NULL;
+	}
+
+	// Add any alignment bytes
+	real_size += align_pad;
+
+	// Split the free block and get a pointer to the start
+	// allocated space.
+	void* ablock;
+	if (Z_IsTagTemp(eTag))
+	{
+		ablock = Z_SplitFree(fblock, real_size, false);
+		
+		// Append align pad to end of block
+		Z_SetupAlignmentPad(
+			(void*)((char*)ablock + real_size - align_pad), 
+			align_pad, false);
+	}
+	else
+	{
+		ablock = Z_SplitFree(fblock, real_size, true);
+
+		// Insert align pad at block start
+		Z_SetupAlignmentPad(ablock, align_pad, true);
+		ablock = (void*)((char*)ablock + align_pad);
+	}
+
+	if (!ablock)
+	{
+		Z_MallocFail("Failed to split", iSize, eTag);
+	}
+
+	// Add linking header if necessary
+	if (Z_IsTagLinked(eTag))
+	{
+		ZoneLinkHeader* linked = (ZoneLinkHeader*)ablock;
+		linked->m_Next = s_LinkBase;
+		linked->m_Prev = NULL;
+		if (s_LinkBase)
+		{
+			s_LinkBase->m_Prev = linked;
+		}
+		s_LinkBase = linked;
+
+		assert(Z_ValidateLinks());
+
+		// Next...
+		ablock = (void*)((char*)ablock + sizeof(ZoneLinkHeader));
+	}
+
+	// Setup the header:
+	//		31		- alignment flag
+	//		25-30	- tag
+	//		0-24	- size without headers/footers
+	assert(iSize >= 0 && iSize < (1 << 25));
+	assert(eTag >= 0 && eTag < 64);
+	ZoneHeader* header = (ZoneHeader*)ablock;
+	*header = 
+		(((unsigned int)eTag) << 25) |
+		((unsigned int)iSize);
+
+	if (align_pad)
+	{
+		*header |= (1 << 31);
+	}
+
+	// Next...
+	ablock = (void*)((char*)ablock + sizeof(ZoneHeader));
+
+#ifdef _DEBUG
+	{
+		// Setup the debug markers
+		ZoneDebugHeader* debug_header = (ZoneDebugHeader*)ablock;
+
+		ZoneDebugFooter* debug_footer = (ZoneDebugFooter*)((char*)debug_header + 
+			(sizeof(ZoneDebugHeader) + iSize));
+
+		*debug_header = ZONE_MAGIC;
+		*debug_footer = ZONE_MAGIC;
+
+		// Next...
+		ablock = (void*)((char*)ablock + sizeof(ZoneDebugHeader));
+	}
+#endif
+
+	// Update the stats
+	s_Stats.m_SizeAlloc += iSize;
+	s_Stats.m_OverheadAlloc += header_size + footer_size + align_pad;
+	s_Stats.m_SizesPerTag[eTag] += iSize;
+	s_Stats.m_CountAlloc++;
+	s_Stats.m_CountsPerTag[eTag]++;
+
+	if (s_Stats.m_SizeAlloc + s_Stats.m_OverheadAlloc > s_Stats.m_PeakAlloc)
+	{
+		s_Stats.m_PeakAlloc = s_Stats.m_SizeAlloc + s_Stats.m_OverheadAlloc;
+	}
+
+	// Return a pointer to data memory
+	if (bZeroit)
+	{
+		memset(ablock, 0, iSize);
+	}
+
+	assert(iAlign == 0 || (unsigned int)ablock % iAlign == 0);
+
+	/*
+	   This is useful for figuring out who's allocating a certain block of
+	   memory.  Please don't remove it.
+	if(eTag == TAG_NEWDEL && (unsigned int)ablock >= 0x806c0000 && 
+			(unsigned int)ablock <= 0x806c1000 && iSize == 24) {
+		int suck = 0;
+	}
+	if(eTag == TAG_SMALL && (iSize == 7 || iSize == 96)) {
+		int suck = 0;
+	}
+	if(eTag == TAG_CLIENTS) {
+		int suck = 0;
+	}
+	
+	if ((unsigned)ablock >= 0x1eb0000 && (unsigned)ablock <= 0x1ec0000 && iSize == 48)
+	{
+		int suck = 0;
+	}
+	*/
+
+#ifndef _GAMECUBE
+	ReleaseMutex(s_Mutex);
+#endif
+
+	return ablock;
+}
+
+static memtag_t Z_GetTag(const ZoneHeader* header)
+{
+	return (*header & 0x7E000000) >> 25;
+}
+
+static unsigned int Z_GetSize(const ZoneHeader* header)
+{
+	return *header & 0x1FFFFFF;
+}
+
+static int Z_GetAlign(const ZoneHeader* header)
+{
+	if (*header & (1 << 31))
+	{
+		unsigned char* ptr = (unsigned char*)header;
+		memtag_t tag = Z_GetTag(header);
+
+		// point to the first alignment block
+		if (Z_IsTagTemp(tag))
+		{
+			ptr += sizeof(ZoneHeader) + Z_GetSize(header);
+#ifdef _DEBUG
+			ptr += sizeof(ZoneDebugHeader) + sizeof(ZoneDebugFooter);
+#endif
+		}
+		else
+		{
+			if (Z_IsTagLinked(tag))
+			{
+				// skip the link header
+				ptr -= sizeof(ZoneLinkHeader);
+			}
+			ptr -= 1;
+		}
+
+		return *ptr + 1;
+	}
+	return 0;
+}
+
+int Z_Size(void *pvAddress)
+{
+	assert(s_Initialized);
+
+#ifdef _DEBUG
+	ZoneDebugHeader* debug = (ZoneDebugHeader*)pvAddress - 1;
+
+	if (*debug != ZONE_MAGIC)
+	{
+		Com_Error(ERR_FATAL, "Z_Size(): Not a valid zone header!");
+		return 0;	// won't get here
+	}
+
+	pvAddress = (void*)debug;
+#endif
+
+	ZoneHeader* header = (ZoneHeader*)pvAddress - 1;
+
+	if (Z_GetTag(header) == TAG_STATIC)
+	{
+		return 0;	// kind of
+	}
+	
+	return Z_GetSize(header);
+}
+
+static void Z_Coalasce(ZoneFreeBlock* pBlock)
+{
+	unsigned int size = 0;
+	
+	// Find later free blocks adjacent to us
+	ZoneFreeBlock* end;
+	for (end = pBlock->m_Next; 
+	end->m_Next; 
+	end = end->m_Next)
+	{
+		if (end->m_Address !=
+			end->m_Prev->m_Address + end->m_Prev->m_Size)
+		{
+			break;
+		}
+
+		size += end->m_Size;
+
+		Z_RemoveFromJumpTable(end);
+
+		end->m_Address = 0; // invalidate block
+		s_Stats.m_CountFree--;
+	}
+
+	// Find previous free blocks adjacent to us
+	ZoneFreeBlock* start;
+	for (start = pBlock; 
+	start->m_Prev; 
+	start = start->m_Prev)
+	{
+		if (start->m_Prev->m_Address + start->m_Prev->m_Size !=
+			start->m_Address)
+		{
+			break;
+		}
+
+		size += start->m_Size;
+
+		Z_RemoveFromJumpTable(start);
+
+		start->m_Address = 0; // invalidate block
+		s_Stats.m_CountFree--;
+	}
+
+	// Do we need to coalesce some blocks?
+	if (start->m_Next != end)
+	{
+		start->m_Next = end;
+		end->m_Prev = start;
+		start->m_Size += size;
+	}
+}
+
+// Return type of Z_Free differs in SP/MP. Macro hack to wrap it up
+#ifdef _JK2MP
+	void Z_Free(void *pvAddress)
+	#define Z_FREE_RETURN(x) return
+#else
+int Z_Free(void *pvAddress)
+	#define Z_FREE_RETURN(x) return (x)
+#endif
+{
+#ifdef _WINDOWS
+	if (!s_Initialized) return;
+#endif
+
+	assert(s_Initialized);
+
+#ifdef _DEBUG
+	// check the header magic
+	ZoneDebugHeader* debug_header = (ZoneDebugHeader*)pvAddress - 1;
+
+	if (*debug_header != ZONE_MAGIC)
+	{
+		Com_Error(ERR_FATAL, "Z_Free(): Corrupt zone header!");
+		Z_FREE_RETURN( 0 );
+	}
+
+	ZoneHeader* header = (ZoneHeader*)debug_header - 1;
+
+	// check the footer magic
+	ZoneDebugFooter* debug_footer = (ZoneDebugFooter*)((char*)pvAddress + 
+		Z_GetSize(header));
+
+	if (*debug_footer != ZONE_MAGIC)
+	{
+		Com_Error(ERR_FATAL, "Z_Free(): Corrupt zone footer!");
+		Z_FREE_RETURN( 0 );
+	}
+#else
+	ZoneHeader* header = (ZoneHeader*)pvAddress - 1;
+#endif
+
+	memtag_t tag = Z_GetTag(header);
+
+	if (tag != TAG_STATIC)
+	{
+#ifndef _GAMECUBE
+		WaitForSingleObject(s_Mutex, INFINITE);
+#endif
+
+		// Determine size of header and footer
+		int header_size = sizeof(ZoneHeader);
+		int align_size = Z_GetAlign(header);
+		int footer_size = 0;
+		int data_size = Z_GetSize(header);
+		if (Z_IsTagLinked(tag))
+		{
+			header_size += sizeof(ZoneLinkHeader);
+		}
+		if (Z_IsTagTemp(tag))
+		{
+			footer_size += align_size;
+		}
+		else
+		{
+			header_size += align_size;
+		}
+#ifdef _DEBUG
+		header_size += sizeof(ZoneDebugHeader);
+		footer_size += sizeof(ZoneDebugFooter);
+#endif
+		int real_size = data_size + header_size + footer_size;
+		
+		// Update the stats
+		s_Stats.m_SizeAlloc -= data_size;
+		s_Stats.m_OverheadAlloc -= header_size + footer_size;
+		s_Stats.m_SizesPerTag[tag] -= data_size;
+		s_Stats.m_CountAlloc--;
+		s_Stats.m_CountsPerTag[tag]--;
+	
+		// Delink block
+		if (Z_IsTagLinked(tag))
+		{
+			ZoneLinkHeader* linked = (ZoneLinkHeader*)header - 1;
+			
+			if (linked == s_LinkBase)
+			{
+				s_LinkBase = linked->m_Next;
+				if (s_LinkBase)
+				{
+					s_LinkBase->m_Prev = NULL;
+				}
+			}
+			else
+			{
+				if (linked->m_Next)
+				{
+					linked->m_Next->m_Prev = linked->m_Prev;
+				}
+				linked->m_Prev->m_Next = linked->m_Next;
+			}
+
+			assert(Z_ValidateLinks());
+		}
+
+		// Clear the block header for safety
+		*header = 0;
+
+		// Add block to free list
+		ZoneFreeBlock* nblock = NULL;
+		if (real_size < sizeof(ZoneFreeBlock))
+		{
+			// Not enough space in block to put free information --
+			// use overflow buffer.
+			nblock = Z_GetOverflowBlock();
+
+			if (nblock == NULL)
+			{
+				Z_Details_f();
+				Com_Error(ERR_FATAL, "Zone free overflow buffer overflowed!");
+			}
+		}
+		else
+		{
+			// Place free information in block
+			nblock = (ZoneFreeBlock*)((char*)pvAddress - header_size);
+		}
+
+		nblock->m_Address = (unsigned int)pvAddress - header_size;
+		nblock->m_Size = real_size;
+		Z_LinkFreeBlock(nblock);
+
+		// Coalesce any adjacent free blocks
+		Z_Coalasce(nblock);
+#ifndef _GAMECUBE
+		ReleaseMutex(s_Mutex);
+#endif
+	}
+
+	Z_FREE_RETURN( 0 );
+}
+
+
+int Z_MemSize(memtag_t eTag)
+{
+	return s_Stats.m_SizesPerTag[eTag];
+}
+
+#if ZONE_DEBUG
+void Z_FindLeak(void)
+{
+	assert(s_Initialized);
+
+	static int cycle_count = 0;
+	const memtag_t tag = TAG_NEWDEL;
+
+	struct PointerInfo
+	{
+		void* data;
+		int counter;
+		bool mark;
+	};
+	
+	const int max_pointers = 32768;
+	static PointerInfo pointers[max_pointers];
+	static int num_pointers = 0;
+
+	// Clear pointer existance
+	for (int i = 0; i < num_pointers; ++i)
+	{
+		pointers[i].mark = false;
+	}
+	
+	// Add all known pointers
+	int start_num = num_pointers;
+	for (ZoneLinkHeader* link = s_LinkBase; link;)
+	{
+		ZoneHeader* header = (ZoneHeader*)(link + 1);
+		link = link->m_Next;
+		
+		if (Z_GetTag(header) == tag)
+		{
+			// See if the pointer already is in the array
+			bool found = false;
+			for (int k = start_num; k < num_pointers; ++k)
+			{
+				if (pointers[k].data == header)
+				{
+					++pointers[k].counter;
+					pointers[k].mark = true;
+					found = true;
+					break;
+				}
+			}
+
+			// If the pointer is not in the array, add it
+			if (!found)
+			{
+				assert(num_pointers < max_pointers);
+				pointers[num_pointers].data = header;
+				pointers[num_pointers].counter = 0;
+				pointers[num_pointers].mark = true;
+				++num_pointers;
+			}
+		}
+	}
+
+	// Remove pointers that are no longer used
+	for (int j = 0; j < num_pointers; ++j)
+	{
+		if (pointers[j].mark)
+		{
+			if (pointers[j].counter != cycle_count && 
+				pointers[j].counter != cycle_count - 1 && 
+				pointers[j].counter != 0)
+			{
+				Com_Printf("Memory leak: %p\n", pointers[j].data);
+			}
+		}
+		else
+		{
+			int k;
+			for (k = j; k < num_pointers; ++k)
+			{
+				if (pointers[k].mark) break;
+			}
+
+			if (k == num_pointers) break;
+
+			memmove(pointers + j, pointers + k, (num_pointers - k) * sizeof(PointerInfo));
+			num_pointers -= k - j;
+		}
+	}
+
+	++cycle_count;
+}
+#endif
+
+void Z_TagPointers(memtag_t eTag)
+{
+	assert(s_Initialized);
+
+#ifndef _GAMECUBE
+	WaitForSingleObject(s_Mutex, INFINITE);
+#endif
+
+	Sys_Log( "pointers.txt", va("Pointers for tag %d:\n", eTag) );
+
+	for (ZoneLinkHeader* link = s_LinkBase; link;)
+	{
+		ZoneHeader* header = (ZoneHeader*)(link + 1);
+		link = link->m_Next;
+
+		if (eTag == TAG_ALL || Z_GetTag(header) == eTag)
+		{
+#ifdef _DEBUG
+			Sys_Log( "pointers.txt",
+					va("%x - %d\n", ((void*)((char*)header + 
+							sizeof(ZoneHeader) + sizeof(ZoneDebugHeader))),
+					Z_Size(((void*)((char*)header + 
+							sizeof(ZoneHeader) + sizeof(ZoneDebugHeader))))));
+#else
+			Sys_Log( "pointers.txt",
+					va("%x - %d\n", (void*)(header + 1),
+					Z_Size((void*)(header + 1))));
+#endif
+		}
+	}
+
+#ifndef _GAMECUBE
+	ReleaseMutex(s_Mutex);
+#endif
+}
+
+void Z_TagFree(memtag_t eTag)
+{
+	assert(s_Initialized);
+
+	for (ZoneLinkHeader* link = s_LinkBase; link;)
+	{
+		ZoneHeader* header = (ZoneHeader*)(link + 1);
+		link = link->m_Next;
+
+		if (eTag == TAG_ALL || Z_GetTag(header) == eTag)
+		{
+#ifdef _DEBUG
+			Z_Free((void*)((char*)header + sizeof(ZoneHeader) + 
+				sizeof(ZoneDebugHeader)));
+#else
+			Z_Free((void*)(header + 1));
+#endif
+		}
+	}
+}
+
+void Z_SetNewDeleteTemporary(bool bTemp)
+{
+	// Catch nested uses that break when unwinding the stack
+	assert(bTemp != s_IsNewDeleteTemp);
+	s_IsNewDeleteTemp = bTemp;
+}
+
+void *S_Malloc( int iSize ) 
+{
+	return Z_Malloc(iSize, TAG_SMALL, qfalse, 0);
+}
+
+int Z_GetLevelMemory(void)
+{
+#ifdef _JK2MP
+	return s_Stats.m_SizesPerTag[TAG_BSP];
+#else
+	return s_Stats.m_SizesPerTag[TAG_HUNKALLOC] +
+		s_Stats.m_SizesPerTag[TAG_HUNKMISCMODELS] +
+		s_Stats.m_SizesPerTag[TAG_BSP];
+#endif
+}
+
+#ifdef _JK2MP
+int Z_GetHunkMemory(void)
+{
+	return s_Stats.m_SizesPerTag[TAG_HUNKALLOC] +
+		s_Stats.m_SizesPerTag[TAG_TEMP_HUNKALLOC];
+}
+#endif
+
+int Z_GetTerrainMemory(void)
+{
+	return s_Stats.m_SizesPerTag[TAG_CM_TERRAIN] +
+		s_Stats.m_SizesPerTag[TAG_CM_TERRAIN_TEMP] +
+#ifdef _JK2MP
+		s_Stats.m_SizesPerTag[TAG_TERRAIN] +
+#endif
+		s_Stats.m_SizesPerTag[TAG_R_TERRAIN];
+}
+
+int Z_GetMiscMemory(void)
+{
+	return s_Stats.m_SizeAlloc -
+		(Z_GetLevelMemory() +
+#ifdef _JK2MP
+		Z_GetHunkMemory() +
+#endif
+		Z_GetTerrainMemory() +
+		s_Stats.m_SizesPerTag[TAG_MODEL_GLM] +
+		s_Stats.m_SizesPerTag[TAG_MODEL_GLA] +
+		s_Stats.m_SizesPerTag[TAG_MODEL_MD3] +
+		s_Stats.m_SizesPerTag[TAG_BINK] +
+		s_Stats.m_SizesPerTag[TAG_SND_RAWDATA]);
+}
+
+#ifdef _GAMECUBE
+static int texMemSize = 0;
+#else
+extern int texMemSize;
+#endif
+void Z_CompactStats(void)
+{
+	assert(s_Initialized);
+
+	//This report is conservative.  Divides by 1000 instead of 1024 and
+	//then rounds up.
+	static int	printHeader = 1;
+	if (printHeader)
+	{
+		Sys_Log("memory-map.txt", "**Z_CompactStats Start**\n\n");
+		Sys_Log("memory-map.txt", "Map:\tOV:\tLVL:\tGLM:\tGLA:\tMD3:\tTER:\tSND:\tTEX:\tFMV:\tMSC:\tFrZN:\tFrPH:\n");
+		printHeader = 0;
+	}
+
+	MEMORYSTATUS stat;
+	GlobalMemoryStatus(&stat);
+
+	Sys_Log("memory-map.txt", va("%s\t%d\t%d\t%d\t%d\t%d\t%d\t%d\t%d\t%d\t%d\t%d\t%d\n",
+			Cvar_VariableString( "mapname" ),
+			(s_Stats.m_OverheadAlloc / 1000) + 1,
+			(Z_GetLevelMemory() / 1000) + 1,
+			(s_Stats.m_SizesPerTag[TAG_MODEL_GLM] / 1000) + 1,
+			(s_Stats.m_SizesPerTag[TAG_MODEL_GLA] / 1000) + 1,
+			(s_Stats.m_SizesPerTag[TAG_MODEL_MD3] / 1000) + 1,
+			(Z_GetTerrainMemory() / 1000) + 1,
+			(s_Stats.m_SizesPerTag[TAG_SND_RAWDATA] / 1000) + 1,
+			(texMemSize / 1000) + 1,
+			(s_Stats.m_SizesPerTag[TAG_BINK] / 1000) + 1,
+			(Z_GetMiscMemory() / 1000) + 1,
+			s_Stats.m_SizeFree,
+			stat.dwAvailPhys));
+
+#ifdef _JK2MP
+	Sys_Log("memory-map.txt", va("HUNK: %d, THUNK: %d\n",
+			(s_Stats.m_SizesPerTag[TAG_HUNKALLOC] / 1000) + 1,
+			(s_Stats.m_SizesPerTag[TAG_TEMP_HUNKALLOC] / 1000) + 1));
+#endif
+
+	//Sys_Log("memory-map.txt", va("Free Zone: %d\n", s_Stats.m_SizeFree));
+
+}
+
+
+static void Z_Stats_f(void)
+{
+	assert(s_Initialized);
+	// Display some memory usage summary information...
+
+	Com_Printf("\nThe zone is using %d bytes (%.2fMB) in %d memory blocks\n", 
+		s_Stats.m_SizeAlloc,
+		(float)s_Stats.m_SizeAlloc / 1024.0f / 1024.0f, 
+		s_Stats.m_CountAlloc);
+
+	Com_Printf("Free memory is %d bytes (%.2fMB) in %d memory blocks\n", 
+		s_Stats.m_SizeFree,
+		(float)s_Stats.m_SizeFree / 1024.0f / 1024.0f, 
+		s_Stats.m_CountFree);
+
+	Com_Printf("The zone peaked at %d bytes (%.2fMB)\n", 
+		s_Stats.m_PeakAlloc,
+		(float)s_Stats.m_PeakAlloc / 1024.0f / 1024.0f);
+
+	Com_Printf("The zone overhead is %d bytes (%.2fMB)\n", 
+		s_Stats.m_OverheadAlloc,
+		(float)s_Stats.m_OverheadAlloc / 1024.0f / 1024.0f);
+}
+
+void Z_Details_f(void)
+{
+	assert(s_Initialized);
+	// Display some tag specific information...
+
+	Com_Printf("---------------------------------------------------------------------------\n");
+	Com_Printf("%20s %9s\n","Zone Tag","Bytes");
+	Com_Printf("%20s %9s\n","--------","-----");
+	for (int i=0; i<TAG_COUNT; i++)
+	{
+		int iThisCount = s_Stats.m_CountsPerTag[i];
+		int iThisSize = s_Stats.m_SizesPerTag[i];
+
+		if (iThisCount)
+		{
+			float	fSize		= (float)(iThisSize) / 1024.0f / 1024.0f;
+			int		iSize		= fSize;
+			int		iRemainder 	= 100.0f * (fSize - floor(fSize));
+			Com_Printf("%d %9d (%2d.%02dMB) in %6d blocks (%9d average)\n", 
+				i, iThisSize, iSize, iRemainder, iThisCount, iThisSize / iThisCount);
+		}
+	}
+	Com_Printf("---------------------------------------------------------------------------\n");
+
+	Z_Stats_f();
+}
+
+void Z_DumpMemMap_f(void)
+{
+#	define WRITECHAR(C) \
+		Sys_Log("memmap.txt", C, 1, false);	\
+		cur += 1024;	\
+		if ((++counter) % 81 == 0) Sys_Log("memmap.txt", "\n", 1, false);
+	
+	unsigned int cur = (unsigned int)s_PoolBase;
+	unsigned int counter = 0;
+	for (ZoneFreeBlock* fblock = &s_FreeStart; fblock != &s_FreeEnd; fblock = fblock->m_Next)
+	{
+		while (fblock->m_Address > cur + 1024)
+		{
+			WRITECHAR("*");
+		}
+
+		if (fblock->m_Address > cur && fblock->m_Address < cur + 1024)
+		{
+			WRITECHAR("+");
+		}
+
+		while (fblock->m_Address + fblock->m_Size > cur + 1024)
+		{
+			WRITECHAR("-");
+		}
+
+		if (fblock->m_Address + fblock->m_Size > cur && 
+			fblock->m_Address + fblock->m_Size < cur + 1024)
+		{
+			WRITECHAR("+");
+		}
+	}
+
+	Sys_Log("memmap.txt", "\n");
+}
+
+void Z_DisplayLevelMemory(int size, int surf, int block)
+{
+	Z_DumpMemMap_f();
+
+	//Yes, it should be divided by 1024, but I'm going for a safety margin
+	//by rounding down.
+	//Com_Printf("level memory used: %d KB\n", size / 1000);
+	//Z_CompactStats(size, surf, block);
+	Z_CompactStats();
+}
+
+void Z_DisplayLevelMemory(void)
+{
+#ifdef _GAMECUBE
+	extern void R_SurfMramUsed(int &surface, int &block);
+	int surface, block;
+	R_SurfMramUsed(surface, block);
+	Z_DisplayLevelMemory(Z_GetLevelMemory(), surface, block);
+#else
+	Z_DisplayLevelMemory(Z_GetLevelMemory(), 0, 0);
+#endif
+}
+
+
+/*
+========================
+CopyString
+
+ NOTE:	never write over the memory CopyString returns because
+		memory from a memstatic_t might be returned
+========================
+*/
+char *CopyString( const char *in )
+{
+	struct ZoneSingleChar
+	{
+		ZoneHeader header;
+#ifdef _DEBUG
+		ZoneDebugHeader start;
+#endif
+		char data[2];
+#ifdef _DEBUG
+		ZoneDebugFooter end;
+#endif
+	};
+
+#ifdef _DEBUG
+	static ZoneSingleChar empty = {(TAG_STATIC << 25) | 2, ZONE_MAGIC, "\0", ZONE_MAGIC};
+	static ZoneSingleChar numbers[10] =
+	{
+		{(TAG_STATIC << 25) | 2, ZONE_MAGIC, "0", ZONE_MAGIC},
+		{(TAG_STATIC << 25) | 2, ZONE_MAGIC, "1", ZONE_MAGIC},
+		{(TAG_STATIC << 25) | 2, ZONE_MAGIC, "2", ZONE_MAGIC},
+		{(TAG_STATIC << 25) | 2, ZONE_MAGIC, "3", ZONE_MAGIC},
+		{(TAG_STATIC << 25) | 2, ZONE_MAGIC, "4", ZONE_MAGIC},
+		{(TAG_STATIC << 25) | 2, ZONE_MAGIC, "5", ZONE_MAGIC},
+		{(TAG_STATIC << 25) | 2, ZONE_MAGIC, "6", ZONE_MAGIC},
+		{(TAG_STATIC << 25) | 2, ZONE_MAGIC, "7", ZONE_MAGIC},
+		{(TAG_STATIC << 25) | 2, ZONE_MAGIC, "8", ZONE_MAGIC},
+		{(TAG_STATIC << 25) | 2, ZONE_MAGIC, "9", ZONE_MAGIC},
+	};
+#else
+	static ZoneSingleChar empty = {(TAG_STATIC << 25) | 2, "\0"};
+	static ZoneSingleChar numbers[10] =
+	{
+		{(TAG_STATIC << 25) | 2, "0"},
+		{(TAG_STATIC << 25) | 2, "1"},
+		{(TAG_STATIC << 25) | 2, "2"},
+		{(TAG_STATIC << 25) | 2, "3"},
+		{(TAG_STATIC << 25) | 2, "4"},
+		{(TAG_STATIC << 25) | 2, "5"},
+		{(TAG_STATIC << 25) | 2, "6"},
+		{(TAG_STATIC << 25) | 2, "7"},
+		{(TAG_STATIC << 25) | 2, "8"},
+		{(TAG_STATIC << 25) | 2, "9"},
+	};
+#endif
+
+	char	*out;
+
+	if (!in[0])
+	{
+		return empty.data;
+	}
+	else if (!in[1])
+	{
+		if (in[0] >= '0' && in[0] <= '9')
+		{
+			return numbers[in[0]-'0'].data;
+		}
+	}
+
+	out = (char *) S_Malloc (strlen(in)+1);
+	strcpy (out, in);
+
+//	Z_Label(out,in);
+
+	return out;
+}
+
+void Com_TouchMemory(void)
+{
+	// Stub function. Do nothing.
+	return;
+}
+
+qboolean Z_IsFromZone(void *pvAddress, memtag_t eTag)
+{
+	assert(s_Initialized);
+
+#ifdef _DEBUG
+	ZoneDebugHeader* debug = (ZoneDebugHeader*)pvAddress - 1;
+
+	if (*debug != ZONE_MAGIC)
+	{
+		return qfalse;
+	}
+
+	pvAddress = (void*)debug;
+#endif
+
+	ZoneHeader* header = (ZoneHeader*)pvAddress - 1;
+
+	if (Z_GetTag(header) != eTag)
+	{
+		return qfalse;
+	}
+	
+	return Z_GetSize(header);
+}
+
+
+/*
+   Hunk emulation
+
+   The emulation is pretty bad right now, we just use two tags:
+   TAG_HUNKALLOC and TAG_TEMP_HUNKALLOC, to represent the permanent and
+   temporary sides of the hunk respectively. We should make the
+   Hunk allocations tagged so we can do this better.
+*/
+#ifdef _JK2MP
+
+void Hunk_Clear(void)
+{
+	Z_TagFree(TAG_TEMP_HUNKALLOC);
+	Z_TagFree(TAG_HUNKALLOC);
+/*
+	Z_TagFree(TAG_HUNKALLOC);
+	Z_TagFree(TAG_BSP_HUNK);
+	Z_TagFree(TAG_BOT_HUNK);
+	Z_TagFree(TAG_RENDERER_HUNK);
+	Z_TagFree(TAG_SKELETON);
+	Z_TagFree(TAG_MODEL_OTHER);
+	Z_TagFree(TAG_MODEL_CHAR);
+	VM_Clear();
+*/
+}
+
+
+//void *Hunk_Alloc( int size, ha_pref preference, memtag_t eTag ) 
+void *Hunk_Alloc(int size, ha_pref preference)
+{
+	return Z_Malloc(size, TAG_HUNKALLOC, qtrue);
+/*
+	assert(eTag == TAG_HUNKALLOC ||
+			eTag == TAG_BSP_HUNK ||
+			eTag == TAG_BOT_HUNK ||
+			eTag == TAG_RENDERER_HUNK ||
+			eTag == TAG_SKELETON ||
+			eTag == TAG_MODEL_OTHER ||
+			eTag == TAG_MODEL_CHAR);
+	return Z_Malloc(size, eTag, qtrue);
+*/
+}
+
+
+void *Hunk_AllocateTempMemory(int size)
+{
+	return Z_Malloc(size, TAG_TEMP_HUNKALLOC, qtrue);
+/*
+	return Z_Malloc(size, TAG_TEMP_HUNK, qtrue);
+*/
+}
+
+
+void Hunk_FreeTempMemory(void *buf)
+{
+	Z_Free(buf);
+}
+
+
+void Hunk_ClearTempMemory(void)
+{
+	Z_TagFree(TAG_TEMP_HUNKALLOC);
+//	Z_TagFree(TAG_TEMP_HUNK);
+}
+
+
+void Com_InitHunkMemory(void)
+{
+}
+
+
+int Hunk_MemoryRemaining(void)
+{
+	return 0;
+}
+
+
+void Hunk_ClearToMark(void)
+{
+}
+
+
+qboolean Hunk_CheckMark(void)
+{
+	return qfalse;
+}
+
+
+void Hunk_SetMark(void)
+{
+}
+#endif // _JK2MP
+
+/*
+	XTL Replacement functions
+	XMemAlloc
+	XMemFree
+	XMemSize
+
+	Replacing these lets us intercept ALL memory allocation done by the XTL, and lets the
+	Zone take pretty much all available memory at startup
+*/
+/* This still doesn't work. Numrous allocations still use internal functions, so there's
+   little benefit right now.
+
+XBOXAPI
+LPVOID
+WINAPI
+XMemAlloc(SIZE_T dwSize, DWORD dwAllocAttributes)
+{
+	PXALLOC_ATTRIBUTES pAllocAttributes = (PXALLOC_ATTRIBUTES)&dwAllocAttributes;
+	LPVOID ptr = NULL;
+
+	if (pAllocAttributes->dwMemoryType == XALLOC_MEMTYPE_HEAP)
+	{ // Heap allocation
+		ptr = HeapAlloc(GetProcessHeap(),
+						pAllocAttributes->dwZeroInitialize ? HEAP_ZERO_MEMORY : 0,
+						dwSize);
+		if (pAllocAttributes->dwHeapTracksAttributes)
+			XSetAttributesOnHeapAlloc(ptr, dwAllocAttributes);
+	}
+	else
+	{ // Physical allocation
+		// Map requested alignment to real alignment
+		ULONG_PTR ulAlign = 0;
+		DWORD dwProtect = 0;
+
+		switch(pAllocAttributes->dwAlignment)
+		{
+			case XALLOC_PHYSICAL_ALIGNMENT_8K:
+				ulAlign = 8*1024;
+				break;
+
+			case XALLOC_PHYSICAL_ALIGNMENT_16K:
+				ulAlign = 16*1024;
+				break;
+
+			case XALLOC_PHYSICAL_ALIGNMENT_32K:
+				ulAlign = 32*1024;
+				break;
+
+			default:
+				ulAlign = 4*1024;
+				break;
+		}
+
+		if (pAllocAttributes->dwMemoryProtect & XALLOC_MEMPROTECT_READONLY)
+			dwProtect = PAGE_READONLY;
+		else
+			dwProtect = PAGE_READWRITE;
+
+		if (pAllocAttributes->dwMemoryProtect & XALLOC_MEMPROTECT_NOCACHE)
+			dwProtect |= PAGE_NOCACHE;
+		if (pAllocAttributes->dwMemoryProtect & XALLOC_MEMPROTECT_WRITECOMBINE)
+			dwProtect |= PAGE_WRITECOMBINE;
+
+		ptr = XPhysicalAlloc(dwSize, MAXULONG_PTR, ulAlign, dwProtect);
+	}
+
+	return ptr;
+}
+
+XBOXAPI
+VOID
+WINAPI
+XMemFree(PVOID pAddress, DWORD dwAllocAttributes)
+{
+	PXALLOC_ATTRIBUTES pAllocAttributes = (PXALLOC_ATTRIBUTES)&dwAllocAttributes;
+
+	if (pAllocAttributes->dwMemoryType == XALLOC_MEMTYPE_HEAP)
+	{ // Heap pointer
+		HeapFree(GetProcessHeap(), 0, pAddress);
+	}
+	else
+	{ // Physical pointer
+		XPhysicalFree(pAddress);
+	}
+}
+
+XBOXAPI
+SIZE_T
+WINAPI
+XMemSize(PVOID pAddress, DWORD dwAllocAttributes)
+{
+	PXALLOC_ATTRIBUTES pAllocAttributes = (PXALLOC_ATTRIBUTES)&dwAllocAttributes;
+
+	if (pAllocAttributes->dwMemoryType == XALLOC_MEMTYPE_HEAP)
+	{ // Heap pointer
+		return HeapSize(GetProcessHeap(), 0, pAddress);
+	}
+	else
+	{ // Physical pointer
+		return XPhysicalSize(pAddress);
+	}
+}
+*/
diff --git a/code/qcommon/z_memman_pc.cpp b/code/qcommon/z_memman_pc.cpp
new file mode 100644
index 0000000..2c36f8e
--- /dev/null
+++ b/code/qcommon/z_memman_pc.cpp
@@ -0,0 +1,958 @@
+// Created 2/3/03 by Brian Osman - split Zone code from common.cpp
+
+#include "../game/q_shared.h"
+#include "qcommon.h"
+#include "../qcommon/sstring.h"
+
+#include "platform.h"
+
+#ifdef DEBUG_ZONE_ALLOCS
+int giZoneSnaphotNum=0;
+#define DEBUG_ZONE_ALLOC_OPTIONAL_LABEL_SIZE 256
+typedef sstring<DEBUG_ZONE_ALLOC_OPTIONAL_LABEL_SIZE> sDebugString_t;
+#endif
+
+static void Z_Details_f(void);
+
+// define a string table of all mem tags...
+//
+#ifdef TAGDEF	// itu?
+#undef TAGDEF
+#endif
+#define TAGDEF(blah) #blah
+static const char *psTagStrings[TAG_COUNT+1]=	// +1 because TAG_COUNT will itself become a string here. Oh well.
+{
+	#include "../qcommon/tags.h"
+};
+
+// This handles zone memory allocation.
+// It is a wrapper around malloc with a tag id and a magic number at the start
+
+#define ZONE_MAGIC			0x21436587
+
+// if you change ANYTHING in this structure, be sure to update the tables below using DEF_STATIC...
+//
+typedef struct zoneHeader_s
+{
+		int					iMagic;
+		memtag_t			eTag;
+		int					iSize;
+struct	zoneHeader_s		*pNext;
+struct	zoneHeader_s		*pPrev;
+
+#ifdef DEBUG_ZONE_ALLOCS
+		char				sSrcFileBaseName[MAX_QPATH];
+		int					iSrcFileLineNum;
+		char				sOptionalLabel[DEBUG_ZONE_ALLOC_OPTIONAL_LABEL_SIZE];
+		int					iSnapshotNumber;
+#endif
+
+} zoneHeader_t;
+
+typedef struct 
+{
+	int iMagic;
+
+} zoneTail_t;
+
+static inline zoneTail_t *ZoneTailFromHeader(zoneHeader_t *pHeader)
+{
+	return (zoneTail_t*) ( (char*)pHeader + sizeof(*pHeader) + pHeader->iSize );
+}
+
+#ifdef DETAILED_ZONE_DEBUG_CODE
+map <void*,int> mapAllocatedZones;
+#endif
+
+
+typedef struct zoneStats_s
+{
+	int		iCount;
+	int		iCurrent;
+	int		iPeak;
+
+	// I'm keeping these updated on the fly, since it's quicker for cache-pool
+	//	purposes rather than recalculating each time...
+	//
+	int		iSizesPerTag [TAG_COUNT];	
+	int		iCountsPerTag[TAG_COUNT];	
+
+} zoneStats_t;
+
+typedef struct zone_s
+{
+	zoneStats_t				Stats;
+	zoneHeader_t			Header;
+} zone_t;
+
+cvar_t	*com_validateZone;
+
+zone_t	TheZone = {0};
+
+
+
+
+// Scans through the linked list of mallocs and makes sure no data has been overwritten
+
+int Z_Validate(void)
+{	
+	int ret=0;
+	if(!com_validateZone || !com_validateZone->integer)
+	{
+		return ret;
+	}
+
+	zoneHeader_t *pMemory = TheZone.Header.pNext;
+	while (pMemory)
+	{
+		#ifdef DETAILED_ZONE_DEBUG_CODE
+		// this won't happen here, but wtf?
+		int& iAllocCount = mapAllocatedZones[pMemory];
+		if (iAllocCount <= 0)
+		{
+			Com_Error(ERR_FATAL, "Z_Validate(): Bad block allocation count!");
+			return ret;
+		}		   
+		#endif
+
+		if(pMemory->iMagic != ZONE_MAGIC)
+		{
+			Com_Error(ERR_FATAL, "Z_Validate(): Corrupt zone header!");
+			return ret;
+		}
+
+		// this block of code is intended to make sure all of the data is paged in
+		if (pMemory->eTag != TAG_IMAGE_T 
+			&& pMemory->eTag != TAG_MODEL_MD3 
+			&& pMemory->eTag != TAG_MODEL_GLM 
+			&& pMemory->eTag != TAG_MODEL_GLA )	//don't bother with disk caches as they've already been hit or will be thrown out next 
+		{
+			unsigned char *memstart = (unsigned char *)pMemory;
+			int totalSize = pMemory->iSize;
+			while (totalSize > 4096)
+			{
+				memstart += 4096;
+				ret += (int)(*memstart); // this fools the optimizer
+				totalSize -= 4096;
+			}
+		}
+
+
+		if (ZoneTailFromHeader(pMemory)->iMagic != ZONE_MAGIC)
+		{
+			Com_Error(ERR_FATAL, "Z_Validate(): Corrupt zone tail!");
+			return ret;
+		}
+		
+		pMemory = pMemory->pNext;
+	}
+	return ret;
+}
+				
+
+
+// static mem blocks to reduce a lot of small zone overhead
+//
+#pragma pack(push)
+#pragma pack(1)
+typedef struct
+{
+	zoneHeader_t	Header;	
+//	byte mem[0];
+	zoneTail_t		Tail;
+} StaticZeroMem_t;
+
+typedef struct
+{
+	zoneHeader_t	Header;	
+	byte mem[2];
+	zoneTail_t		Tail;
+} StaticMem_t;
+#pragma pack(pop)
+
+const static StaticZeroMem_t gZeroMalloc  =
+	{ {ZONE_MAGIC, TAG_STATIC,0,NULL,NULL},{ZONE_MAGIC}};
+
+#ifdef DEBUG_ZONE_ALLOCS
+#define DEF_STATIC(_char) {ZONE_MAGIC, TAG_STATIC,2,NULL,NULL, "<static>",0,"",0},_char,'\0',{ZONE_MAGIC}
+#else
+#define DEF_STATIC(_char) {ZONE_MAGIC, TAG_STATIC,2,NULL,NULL			        },_char,'\0',{ZONE_MAGIC}	
+#endif
+
+const static StaticMem_t gEmptyString =
+	{ DEF_STATIC('\0') };
+
+const static StaticMem_t gNumberString[] = {
+	{ DEF_STATIC('0') },
+	{ DEF_STATIC('1') },
+	{ DEF_STATIC('2') },
+	{ DEF_STATIC('3') },
+	{ DEF_STATIC('4') },
+	{ DEF_STATIC('5') },
+	{ DEF_STATIC('6') },
+	{ DEF_STATIC('7') },
+	{ DEF_STATIC('8') },
+	{ DEF_STATIC('9') },
+};
+
+qboolean gbMemFreeupOccured = qfalse;
+
+#ifdef DEBUG_ZONE_ALLOCS
+void *_D_Z_Malloc ( int iSize, memtag_t eTag, qboolean bZeroit, const char *psFile, int iLine)
+#else
+void *Z_Malloc(int iSize, memtag_t eTag, qboolean bZeroit, int unusedAlign)
+#endif
+{	
+	gbMemFreeupOccured = qfalse;
+
+	if (iSize == 0)
+	{
+		zoneHeader_t *pMemory = (zoneHeader_t *) &gZeroMalloc;
+		return &pMemory[1];
+	}
+
+	// Add in tracking info and round to a longword...  (ignore longword aligning now we're not using contiguous blocks)
+	//
+//	int iRealSize = (iSize + sizeof(zoneHeader_t) + sizeof(zoneTail_t) + 3) & 0xfffffffc;
+	int iRealSize = (iSize + sizeof(zoneHeader_t) + sizeof(zoneTail_t));
+
+	// Allocate a chunk...
+	//
+	zoneHeader_t *pMemory = NULL;
+	while (pMemory == NULL)
+	{
+		#ifdef _WIN32
+		if (gbMemFreeupOccured)
+		{
+			Sleep(1000);	// sleep for a second, so Windows has a chance to shuffle mem to de-swiss-cheese it
+		}
+		#endif
+
+		if (bZeroit) {
+			pMemory = (zoneHeader_t *) calloc ( iRealSize, 1 );
+		} else {
+			pMemory = (zoneHeader_t *) malloc ( iRealSize );
+		}
+		if (!pMemory)
+		{
+			// new bit, if we fail to malloc memory, try dumping some of the cached stuff that's non-vital and try again...
+			//
+
+			// ditch the BSP cache...
+			//
+			if (CM_DeleteCachedMap(qfalse))
+			{
+				gbMemFreeupOccured = qtrue;
+				continue;		// we've just ditched a whole load of memory, so try again with the malloc
+			}
+
+
+			// ditch any sounds not used on this level...
+			//
+			extern qboolean SND_RegisterAudio_LevelLoadEnd(qboolean bDeleteEverythingNotUsedThisLevel);
+			if (SND_RegisterAudio_LevelLoadEnd(qtrue))
+			{
+				gbMemFreeupOccured = qtrue;
+				continue;		// we've dropped at least one sound, so try again with the malloc
+			}
+
+
+			// ditch any image_t's (and associated GL texture mem) not used on this level...
+			//
+			extern qboolean RE_RegisterImages_LevelLoadEnd(void);
+			if (RE_RegisterImages_LevelLoadEnd())
+			{
+				gbMemFreeupOccured = qtrue;
+				continue;		// we've dropped at least one image, so try again with the malloc
+			}
+
+
+			// ditch the model-binaries cache...  (must be getting desperate here!)
+			//
+			extern qboolean RE_RegisterModels_LevelLoadEnd(qboolean bDeleteEverythingNotUsedThisLevel);
+			if (RE_RegisterModels_LevelLoadEnd(qtrue))
+			{
+				gbMemFreeupOccured = qtrue;
+				continue;
+			}
+
+			// as a last panic measure, dump all the audio memory, but not if we're in the audio loader 
+			//	(which is annoying, but I'm not sure how to ensure we're not dumping any memory needed by the sound
+			//	currently being loaded if that was the case)...
+			//
+			// note that this keeps querying until it's freed up as many bytes as the requested size, but freeing
+			//	several small blocks might not mean that one larger one is satisfiable after freeup, however that'll
+			//	just make it go round again and try for freeing up another bunch of blocks until the total is satisfied 
+			//	again (though this will have freed twice the requested amount in that case), so it'll either work 
+			//	eventually or not free up enough and drop through to the final ERR_DROP. No worries...
+			//
+			extern qboolean gbInsideLoadSound;			
+			extern int SND_FreeOldestSound(void);	// I had to add a void-arg version of this because of link issues, sigh
+			if (!gbInsideLoadSound)
+			{
+				int iBytesFreed = SND_FreeOldestSound();
+				if (iBytesFreed)
+				{						
+					int iTheseBytesFreed = 0;
+					while ( (iTheseBytesFreed = SND_FreeOldestSound()) != 0)
+					{
+						iBytesFreed += iTheseBytesFreed;
+						if (iBytesFreed >= iRealSize)
+							break;	// early opt-out since we've managed to recover enough (mem-contiguity issues aside)
+					}
+					gbMemFreeupOccured = qtrue;
+					continue;
+				}
+			}
+
+			// sigh, dunno what else to try, I guess we'll have to give up and report this as an out-of-mem error...
+			//
+			// findlabel:  "recovermem"
+
+			Com_Printf(S_COLOR_RED"Z_Malloc(): Failed to alloc %d bytes (TAG_%s) !!!!!\n", iSize, psTagStrings[eTag]);
+			Z_Details_f();
+			Com_Error(ERR_FATAL,"(Repeat): Z_Malloc(): Failed to alloc %d bytes (TAG_%s) !!!!!\n", iSize, psTagStrings[eTag]);
+			return NULL;
+		}
+	}
+
+
+#ifdef DEBUG_ZONE_ALLOCS
+	extern char *Filename_WithoutPath(const char *psFilename);
+
+	Q_strncpyz(pMemory->sSrcFileBaseName, Filename_WithoutPath(psFile), sizeof(pMemory->sSrcFileBaseName));
+	pMemory->iSrcFileLineNum	= iLine;	
+	pMemory->sOptionalLabel[0]	= '\0';
+	pMemory->iSnapshotNumber	= giZoneSnaphotNum;
+#endif
+
+	// Link in
+	pMemory->iMagic	= ZONE_MAGIC;
+	pMemory->eTag	= eTag;
+	pMemory->iSize	= iSize;	
+	pMemory->pNext  = TheZone.Header.pNext;
+	TheZone.Header.pNext = pMemory;
+	if (pMemory->pNext)
+	{
+		pMemory->pNext->pPrev = pMemory;
+	}
+	pMemory->pPrev = &TheZone.Header;
+	//
+	// add tail...
+	//
+	ZoneTailFromHeader(pMemory)->iMagic = ZONE_MAGIC;
+
+	// Update stats...
+	//
+	TheZone.Stats.iCurrent += iSize;
+	TheZone.Stats.iCount++;
+	TheZone.Stats.iSizesPerTag	[eTag] += iSize;
+	TheZone.Stats.iCountsPerTag	[eTag]++;	
+
+	if (TheZone.Stats.iCurrent > TheZone.Stats.iPeak)
+	{
+		TheZone.Stats.iPeak	= TheZone.Stats.iCurrent;
+	}
+
+#ifdef DETAILED_ZONE_DEBUG_CODE
+	mapAllocatedZones[pMemory]++;
+#endif
+	
+	Z_Validate();	// check for corruption
+
+	void *pvReturnMem = &pMemory[1];
+	return pvReturnMem;
+}
+
+// used during model cacheing to save an extra malloc, lets us morph the disk-load buffer then
+//	just not fs_freefile() it afterwards.
+//
+void Z_MorphMallocTag( void *pvAddress, memtag_t eDesiredTag )
+{
+	zoneHeader_t *pMemory = ((zoneHeader_t *)pvAddress) - 1;
+
+	if (pMemory->iMagic != ZONE_MAGIC)
+	{
+		Com_Error(ERR_FATAL, "Z_MorphMallocTag(): Not a valid zone header!");
+		return;	// won't get here
+	}
+
+	// DEC existing tag stats...
+	//
+//	TheZone.Stats.iCurrent	- unchanged
+//	TheZone.Stats.iCount	- unchanged
+	TheZone.Stats.iSizesPerTag	[pMemory->eTag] -= pMemory->iSize;
+	TheZone.Stats.iCountsPerTag	[pMemory->eTag]--;
+
+	// morph...
+	//
+	pMemory->eTag = eDesiredTag;
+
+	// INC new tag stats...
+	//
+//	TheZone.Stats.iCurrent	- unchanged
+//	TheZone.Stats.iCount	- unchanged
+	TheZone.Stats.iSizesPerTag	[pMemory->eTag] += pMemory->iSize;
+	TheZone.Stats.iCountsPerTag	[pMemory->eTag]++;
+}
+
+
+static int Zone_FreeBlock(zoneHeader_t *pMemory)
+{
+	const int iSize = pMemory->iSize;
+	if (pMemory->eTag != TAG_STATIC)	// belt and braces, should never hit this though
+	{
+		// Update stats...
+		//
+		TheZone.Stats.iCount--;
+		TheZone.Stats.iCurrent -= pMemory->iSize;
+		TheZone.Stats.iSizesPerTag	[pMemory->eTag] -= pMemory->iSize;
+		TheZone.Stats.iCountsPerTag	[pMemory->eTag]--;
+
+		// Sanity checks...
+		//
+		assert(pMemory->pPrev->pNext == pMemory);
+		assert(!pMemory->pNext || (pMemory->pNext->pPrev == pMemory));
+
+		// Unlink and free...
+		//
+		pMemory->pPrev->pNext = pMemory->pNext;
+		if(pMemory->pNext)
+		{
+			pMemory->pNext->pPrev = pMemory->pPrev;
+		}
+		
+		//debugging double frees
+		pMemory->iMagic = 'FREE';
+		free (pMemory);
+
+		
+		#ifdef DETAILED_ZONE_DEBUG_CODE
+		// this has already been checked for in execution order, but wtf?
+		int& iAllocCount = mapAllocatedZones[pMemory];
+		if (iAllocCount == 0)
+		{
+			Com_Error(ERR_FATAL, "Zone_FreeBlock(): Double-freeing block!");
+			return -1;
+		}
+		iAllocCount--;	
+		#endif
+	}
+	return iSize;
+}
+
+// stats-query function to to see if it's our malloc
+// returns block size if so
+qboolean Z_IsFromZone(void *pvAddress, memtag_t eTag)
+{
+	zoneHeader_t *pMemory = ((zoneHeader_t *)pvAddress) - 1;
+#if 1	//debugging double free
+	if (pMemory->iMagic == 'FREE')
+	{
+		Com_Printf("Z_IsFromZone(%x): Ptr has been freed already!(%9s)\n",pvAddress,pvAddress);
+		return qfalse;
+	}
+#endif
+	if (pMemory->iMagic != ZONE_MAGIC)
+	{
+		return qfalse;
+	}
+
+	//looks like it is from our zone, let's double check the tag
+
+	if (pMemory->eTag != eTag)
+	{
+		return qfalse;
+	}
+
+	return pMemory->iSize;
+}
+
+// stats-query function to ask how big a malloc is...
+//
+int Z_Size(void *pvAddress)
+{
+	zoneHeader_t *pMemory = ((zoneHeader_t *)pvAddress) - 1;
+
+	if (pMemory->eTag == TAG_STATIC)
+	{
+		return 0;	// kind of
+	}
+
+	if (pMemory->iMagic != ZONE_MAGIC)
+	{
+		Com_Error(ERR_FATAL, "Z_Size(): Not a valid zone header!");
+		return 0;	// won't get here
+	}
+
+	return pMemory->iSize;
+}
+
+
+#ifdef DEBUG_ZONE_ALLOCS
+void _D_Z_Label(const void *pvAddress, const char *psLabel)
+{
+	zoneHeader_t *pMemory = ((zoneHeader_t *)pvAddress) - 1;
+
+	if (pMemory->eTag == TAG_STATIC)
+	{
+		return;
+	}
+
+	if (pMemory->iMagic != ZONE_MAGIC)
+	{
+		Com_Error(ERR_FATAL, "_D_Z_Label(): Not a valid zone header!");
+	}
+
+	Q_strncpyz(	pMemory->sOptionalLabel, psLabel, sizeof(pMemory->sOptionalLabel));
+				pMemory->sOptionalLabel[ sizeof(pMemory->sOptionalLabel)-1 ] = '\0';
+}
+#endif
+
+
+
+// Frees a block of memory...
+//
+int Z_Free(void *pvAddress)
+{
+	if (!TheZone.Stats.iCount)
+	{
+		//Com_Error(ERR_FATAL, "Z_Free(): Zone has been cleard already!");
+		Com_Printf("Z_Free(%x): Zone has been cleard already!\n",pvAddress);
+		return -1;
+	}
+
+	zoneHeader_t *pMemory = ((zoneHeader_t *)pvAddress) - 1;
+
+#if 1	//debugging double free
+	if (pMemory->iMagic == 'FREE')
+	{
+		Com_Error(ERR_FATAL, "Z_Free(%s): Block already-freed, or not allocated through Z_Malloc!",pvAddress);
+		return -1;
+	}
+#endif
+
+	if (pMemory->eTag == TAG_STATIC)
+	{
+		return 0;
+	}
+
+	#ifdef DETAILED_ZONE_DEBUG_CODE
+	//
+	// check this error *before* barfing on bad magics...
+	//
+	int& iAllocCount = mapAllocatedZones[pMemory];
+	if (iAllocCount <= 0)
+	{			
+		Com_Error(ERR_FATAL, "Z_Free(): Block already-freed, or not allocated through Z_Malloc!");
+		return -1;
+	}		   
+	#endif
+
+	if (pMemory->iMagic != ZONE_MAGIC)
+	{
+		Com_Error(ERR_FATAL, "Z_Free(): Corrupt zone header!");
+		return -1;
+	}
+	if (ZoneTailFromHeader(pMemory)->iMagic != ZONE_MAGIC)
+	{
+		Com_Error(ERR_FATAL, "Z_Free(): Corrupt zone tail!");
+		return -1;
+	}
+
+	return Zone_FreeBlock(pMemory);
+}
+
+
+int Z_MemSize(memtag_t eTag)
+{
+	return TheZone.Stats.iSizesPerTag[eTag];
+}
+
+// Frees all blocks with the specified tag...
+//
+void Z_TagFree(memtag_t eTag)
+{
+//#ifdef _DEBUG
+//	int iZoneBlocks = TheZone.Stats.iCount;
+//#endif
+
+	zoneHeader_t *pMemory = TheZone.Header.pNext;
+	while (pMemory)
+	{
+		zoneHeader_t *pNext = pMemory->pNext;
+		if ( (eTag == TAG_ALL) || (pMemory->eTag == eTag))
+		{
+			Zone_FreeBlock(pMemory);
+		}
+		pMemory = pNext;
+	}
+
+// these stupid pragmas don't work here???!?!?!
+//
+//#ifdef _DEBUG
+//#pragma warning( disable : 4189)
+//	int iBlocksFreed = iZoneBlocks - TheZone.Stats.iCount;
+//#pragma warning( default : 4189)
+//#endif
+}
+
+
+#ifdef DEBUG_ZONE_ALLOCS
+void *_D_S_Malloc ( int iSize, const char *psFile, int iLine)
+{
+	return _D_Z_Malloc( iSize, TAG_SMALL, qfalse, psFile, iLine );
+}
+#else
+void *S_Malloc( int iSize ) 
+{
+	return Z_Malloc( iSize, TAG_SMALL, qfalse);
+}
+#endif
+
+
+#ifdef _DEBUG
+static void Z_MemRecoverTest_f(void)
+{
+	// needs to be in _DEBUG only, not good for final game! 
+	//
+	if ( Cmd_Argc() != 2 ) {
+		Com_Printf( "Usage: zone_memrecovertest max2alloc\n" );
+		return;
+	}
+
+	int iMaxAlloc = 1024*1024*atoi( Cmd_Argv(1) );
+	int iTotalMalloc = 0;
+	while (1)
+	{
+		const int iThisMalloc = 5* (1024 * 1024);
+		Z_Malloc(iThisMalloc, TAG_SPECIAL_MEM_TEST, qfalse);	// and lose, just to consume memory
+		iTotalMalloc += iThisMalloc;
+
+		if (gbMemFreeupOccured || (iTotalMalloc >= iMaxAlloc) )
+			break;
+	}
+
+	Z_TagFree(TAG_SPECIAL_MEM_TEST);
+}
+#endif
+
+// Gives a summary of the zone memory usage
+
+static void Z_Stats_f(void)
+{
+	Com_Printf("\nThe zone is using %d bytes (%.2fMB) in %d memory blocks\n", 
+								  TheZone.Stats.iCurrent, 
+									        (float)TheZone.Stats.iCurrent / 1024.0f / 1024.0f, 
+													  TheZone.Stats.iCount
+				);
+
+	Com_Printf("The zone peaked at %d bytes (%.2fMB)\n", 
+									TheZone.Stats.iPeak, 
+									         (float)TheZone.Stats.iPeak / 1024.0f / 1024.0f
+				);
+}
+
+// Gives a detailed breakdown of the memory blocks in the zone
+//
+static void Z_Details_f(void)
+{
+
+	Com_Printf("---------------------------------------------------------------------------\n");
+	Com_Printf("%20s %9s\n","Zone Tag","Bytes");
+	Com_Printf("%20s %9s\n","--------","-----");
+	for (int i=0; i<TAG_COUNT; i++)
+	{
+		int iThisCount = TheZone.Stats.iCountsPerTag[i];
+		int iThisSize  = TheZone.Stats.iSizesPerTag	[i];
+
+		if (iThisCount)
+		{
+			// can you believe that using %2.2f as a format specifier doesn't bloody work? 
+			//	It ignores the left-hand specifier. Sigh, now I've got to do shit like this...
+			//
+			float	fSize		= (float)(iThisSize) / 1024.0f / 1024.0f;
+			int		iSize		= fSize;
+			int		iRemainder 	= 100.0f * (fSize - floor(fSize));
+			Com_Printf("%20s %9d (%2d.%02dMB) in %6d blocks (%9d Bytes/block)\n", 
+					    psTagStrings[i], 
+							  iThisSize, 
+								iSize,iRemainder,
+								           iThisCount, iThisSize / iThisCount
+					   );
+		}
+	}
+	Com_Printf("---------------------------------------------------------------------------\n");
+
+	Z_Stats_f();
+}
+
+#ifdef DEBUG_ZONE_ALLOCS
+#pragma warning (disable:4503)	// decorated name length xceeded, name was truncated
+typedef map <sDebugString_t,int> LabelRefCount_t;	// yet another place where Gil's tring class works and MS's doesn't
+typedef map <sDebugString_t,LabelRefCount_t>	TagBlockLabels_t;
+										TagBlockLabels_t AllTagBlockLabels;
+#pragma warning (disable:4503)	// decorated name length xceeded, name was truncated
+static void Z_Snapshot_f(void)
+{	
+	AllTagBlockLabels.clear();
+
+	zoneHeader_t *pMemory = TheZone.Header.pNext;
+	while (pMemory)
+	{
+		AllTagBlockLabels[psTagStrings[pMemory->eTag]][pMemory->sOptionalLabel]++;
+		pMemory = pMemory->pNext;		
+	}
+
+	giZoneSnaphotNum++;
+	Com_Printf("Ok.    ( Current snapshot num is now %d )\n",giZoneSnaphotNum);
+}
+
+static void Z_TagDebug_f(void)
+{
+	TagBlockLabels_t AllTagBlockLabels_Local;
+	qboolean bSnapShotTestActive = qfalse;
+
+	memtag_t eTag = TAG_ALL;
+
+	const char *psTAGName = Cmd_Argv(1);
+	if (psTAGName[0])
+	{
+		// check optional arg...
+		//
+		if (!Q_stricmp(psTAGName,"#snap"))
+		{
+			bSnapShotTestActive = qtrue;
+
+			AllTagBlockLabels_Local = AllTagBlockLabels;	// horrible great STL copy
+
+			psTAGName = Cmd_Argv(2);			
+		}
+
+		if (psTAGName[0])
+		{
+			// skip over "tag_" if user supplied it...
+			//
+			if (!Q_stricmpn(psTAGName,"TAG_",4))
+			{
+				psTAGName += 4;
+			}
+
+			// see if the user specified a valid tag...
+			//
+			for (int i=0; i<TAG_COUNT; i++)
+			{
+				if (!Q_stricmp(psTAGName,psTagStrings[i]))
+				{
+					eTag = (memtag_t) i;
+					break;
+				}
+			}
+		}
+	}
+	else
+	{
+		Com_Printf("Usage: 'zone_tagdebug [#snap] <tag>', e.g. TAG_GHOUL2, TAG_ALL (careful!)\n");
+		return;
+	}
+
+	Com_Printf("Dumping debug data for tag \"%s\"...%s\n\n",psTagStrings[eTag], bSnapShotTestActive?"( since snapshot only )":"");
+
+	Com_Printf("%8s"," ");	// to compensate for code further down:   Com_Printf("(%5d) ",iBlocksListed);
+	if (eTag == TAG_ALL)
+	{
+		Com_Printf("%20s ","Zone Tag");
+	}
+	Com_Printf("%9s\n","Bytes");
+	Com_Printf("%8s"," ");
+	if (eTag == TAG_ALL)
+	{
+		Com_Printf("%20s ","--------");
+	}
+	Com_Printf("%9s\n","-----");
+
+
+	if (bSnapShotTestActive)
+	{
+		// dec ref counts in last snapshot for all current blocks (which will make new stuff go negative)
+		//
+		zoneHeader_t *pMemory = TheZone.Header.pNext;
+		while (pMemory)
+		{
+			if (pMemory->eTag == eTag || eTag == TAG_ALL)
+			{
+				AllTagBlockLabels_Local[psTagStrings[pMemory->eTag]][pMemory->sOptionalLabel]--;
+			}
+			pMemory = pMemory->pNext;		
+		}
+	}
+
+	// now dump them out...
+	//
+	int iBlocksListed = 0;
+	int iTotalSize = 0;
+	zoneHeader_t *pMemory = TheZone.Header.pNext;
+	while (pMemory)
+	{
+		if (	(pMemory->eTag == eTag	|| eTag == TAG_ALL)
+			&&  (!bSnapShotTestActive	|| (pMemory->iSnapshotNumber == giZoneSnaphotNum && AllTagBlockLabels_Local[psTagStrings[pMemory->eTag]][pMemory->sOptionalLabel] <0) )
+			)
+		{
+			float	fSize		= (float)(pMemory->iSize) / 1024.0f / 1024.0f;
+			int		iSize		= fSize;
+			int		iRemainder 	= 100.0f * (fSize - floor(fSize));
+
+			Com_Printf("(%5d) ",iBlocksListed);
+
+			if (eTag == TAG_ALL)
+			{
+				Com_Printf("%20s",psTagStrings[pMemory->eTag]);
+			}
+
+			Com_Printf(" %9d (%2d.%02dMB) File: \"%s\", Line: %d\n",
+						  pMemory->iSize,
+ 							  iSize,iRemainder,
+												pMemory->sSrcFileBaseName,
+															pMemory->iSrcFileLineNum
+					   );
+			if (pMemory->sOptionalLabel[0])
+			{
+				Com_Printf("( Label: \"%s\" )\n",pMemory->sOptionalLabel);
+			}
+			iBlocksListed++;
+			iTotalSize += pMemory->iSize;
+			
+			if (bSnapShotTestActive)
+			{
+				// bump ref count so we only 1 warning per new string, not for every one sharing that label...
+				//
+				AllTagBlockLabels_Local[psTagStrings[pMemory->eTag]][pMemory->sOptionalLabel]++;
+			}
+		}
+		pMemory = pMemory->pNext;		
+	}
+
+	Com_Printf("( %d blocks listed, %d bytes (%.2fMB) total )\n",iBlocksListed, iTotalSize, (float)iTotalSize / 1024.0f / 1024.0f);
+}
+#endif
+
+// Shuts down the zone memory system and frees up all memory
+void Com_ShutdownZoneMemory(void)
+{
+	Cmd_RemoveCommand("zone_stats");
+	Cmd_RemoveCommand("zone_details");
+
+#ifdef _DEBUG
+	Cmd_RemoveCommand("zone_memrecovertest");
+#endif
+
+#ifdef DEBUG_ZONE_ALLOCS
+	Cmd_RemoveCommand("zone_tagdebug");
+	Cmd_RemoveCommand("zone_snapshot");
+#endif
+
+	if(TheZone.Stats.iCount)
+	{
+		//Com_Printf("Automatically freeing %d blocks making up %d bytes\n", TheZone.Stats.iCount, TheZone.Stats.iCurrent);
+		Z_TagFree(TAG_ALL);
+
+		assert(!TheZone.Stats.iCount);
+		assert(!TheZone.Stats.iCurrent);
+	}
+}
+
+// Initialises the zone memory system
+
+void Com_InitZoneMemory( void ) 
+{
+	Com_Printf("Initialising zone memory .....\n");
+
+	memset(&TheZone, 0, sizeof(TheZone)); 
+	TheZone.Header.iMagic = ZONE_MAGIC;
+
+	com_validateZone = Cvar_Get("com_validateZone", "0", 0);
+
+	Cmd_AddCommand("zone_stats",	Z_Stats_f);
+	Cmd_AddCommand("zone_details",	Z_Details_f);
+
+#ifdef _DEBUG
+	Cmd_AddCommand("zone_memrecovertest", Z_MemRecoverTest_f);
+#endif
+
+
+#ifdef DEBUG_ZONE_ALLOCS
+	Cmd_AddCommand("zone_tagdebug",	Z_TagDebug_f);
+	Cmd_AddCommand("zone_snapshot",	Z_Snapshot_f);
+#endif
+}
+
+
+
+
+/*
+========================
+CopyString
+
+ NOTE:	never write over the memory CopyString returns because
+		memory from a memstatic_t might be returned
+========================
+*/
+char *CopyString( const char *in ) {
+	char	*out;
+
+	if (!in[0]) {
+		return ((char *)&gEmptyString) + sizeof(zoneHeader_t);
+	}
+	else if (!in[1]) {
+		if (in[0] >= '0' && in[0] <= '9') {
+			return ((char *)&gNumberString[in[0]-'0']) + sizeof(zoneHeader_t);
+		}
+	}
+
+	out = (char *) S_Malloc (strlen(in)+1);
+	strcpy (out, in);
+
+	Z_Label(out,in);
+
+	return out;
+}
+
+
+/*
+===============
+Com_TouchMemory
+
+Touch all known used data to make sure it is paged in
+===============
+*/
+void Com_TouchMemory( void ) {
+	int		start, end;
+	int		i, j;
+	int		sum;	
+	int		totalTouched;
+
+	Z_Validate();
+
+	start = Sys_Milliseconds();
+
+	sum = 0;
+	totalTouched=0;
+
+	zoneHeader_t *pMemory = TheZone.Header.pNext;
+	while (pMemory)
+	{
+		byte *pMem = (byte *) &pMemory[1];
+		j = pMemory->iSize >> 2;
+		for (i=0; i<j; i+=64){
+			sum += ((int*)pMem)[i];
+		}
+		totalTouched+=pMemory->iSize;
+		pMemory = pMemory->pNext;
+	}
+
+	end = Sys_Milliseconds();
+
+	//Com_Printf( "Com_TouchMemory: %i bytes, %i msec\n", totalTouched, end - start );
+}
+
+
diff --git a/code/renderer/amd3d.h b/code/renderer/amd3d.h
new file mode 100644
index 0000000..45fece2
--- /dev/null
+++ b/code/renderer/amd3d.h
@@ -0,0 +1,471 @@
+/******************************************************************
+; *
+; * Copyright (c) 1996-1998 ADVANCED MICRO DEVICES, INC.
+; * All Rights reserved.
+; *
+; * This software is unpublished and contains the trade secrets
+; * and confidential proprietary information of AMD.  Unless
+; * otherwise provided in the Software Agreement associated
+; * herewith, it is licensed in confidence "AS IS" and
+; * is not to be reproduced in whole or part by any means except
+; * for backup.  Use, duplication, or disclosure by the Government
+; * is subject to the restrictions in paragraph(b)(3)(B)of the
+; * Rights in Technical Data and Computer Software clause in
+; * DFAR 52.227-7013(a)(Oct 1988).  Software owned by Advanced
+; * Micro Devices Inc., One AMD Place, P.O. Box 3453, Sunnyvale,
+; * CA 94088-3453.
+; *
+; ******************************************************************
+ *
+ * AMD3D.H
+ *
+ * MACRO FORMAT
+ * ============
+ * This file contains inline assembly macros that
+ * generate AMD-3D instructions in binary format.
+ * Therefore, C or C++ programmer can use AMD-3D instructions
+ * without any penalty in their C or C++ source code.
+ *
+ * The macro's name and format conventions are as follow:
+ *
+ *
+ *      1. First argument of macro is a destination and
+ *         second argument is a source operand.
+ *              ex) _asm PFCMPEQ (m3, m4)
+ *                                        |    |
+ *                               dst  src
+ *
+ *      2. The destination operand can be m0 to m7 only.
+ *     The source operand can be any one of the register
+ *     m0 to m7 or _eax, _ecx, _edx, _ebx, _esi, or _edi
+ *     that contains effective address.
+ *      ex) _asm PFRCP    (M7, M6)
+ *              ex) _asm PFRCPIT2 (m0, m4)
+ *              ex) _asm PFMUL    (m3, _edi)
+ *
+ *  3. The prefetch(w) takes one src operand _eax, ecx, _edx,
+ *     _ebx, _esi, or _edi that contains effective address.
+ *      ex) _asm PREFETCH (_edi)
+ *
+ * EXAMPLE
+ * =======
+ * Following program doesn't do anything but it shows you
+ * how to use inline assembly AMD-3D instructions in C.
+ * Note that this will only work in flat memory model which
+ * segment registers cs, ds, ss and es point to the same
+ * linear address space total less than 4GB.
+ *
+ * Used Microsoft VC++ 5.0
+ *
+ * #include <stdio.h>
+ * #include "amd3d.h"
+ *
+ * void main ()
+ * {
+ *      float x = (float)1.25;
+ *      float y = (float)1.25;
+ *      float z, zz;
+ *
+ *      _asm {
+ *              movd mm1, x
+ *              movd mm2, y
+ *              pfmul (m1, m2)
+ *              movd z, mm1
+ *               femms
+ *      }
+ *
+ *      printf ("value of z = %f\n", z);
+ *
+ *      //
+ *      // Demonstration of using the memory instead of
+ *      // multimedia register
+ *      //
+ *      _asm {
+ *              movd mm3, x
+ *              lea esi, y   // load effective address of y
+ *              pfmul (m3, _esi)
+ *              movd zz, mm3
+ *              femms
+ *      }
+ *
+ *      printf ("value of zz = %f\n", zz);
+ *  }
+ ******************************************************************/
+
+#define M0   0xc0
+#define M1   0xc1
+#define M2   0xc2
+#define M3   0xc3
+#define M4   0xc4
+#define M5   0xc5
+#define M6   0xc6
+#define M7   0xc7
+
+#define m0   0xc0
+#define m1   0xc1
+#define m2   0xc2
+#define m3   0xc3
+#define m4   0xc4
+#define m5   0xc5
+#define m6   0xc6
+#define m7   0xc7
+#define _EAX 0x00
+#define _ECX 0x01
+#define _EDX 0x02
+#define _EBX 0x03
+#define _ESI 0x06
+#define _EDI 0x07
+#define _eax 0x00
+#define _ecx 0x01
+#define _edx 0x02
+#define _ebx 0x03
+#define _esi 0x06
+#define _edi 0x07
+
+#define PF2ID(dst, src) \
+{\
+   _asm _emit 0x0f                              \
+   _asm _emit 0x0f                              \
+   _asm _emit ((dst & 0x3f) << 3) | src   \
+   _asm _emit 0x1d \
+}
+
+#define PFACC(dst, src) \
+{\
+   _asm _emit 0x0f                              \
+   _asm _emit 0x0f                              \
+   _asm _emit ((dst & 0x3f) << 3) | src \
+   _asm _emit 0xae \
+}
+
+#define PFADD(dst, src) \
+{\
+   _asm _emit 0x0f                              \
+   _asm _emit 0x0f                              \
+   _asm _emit ((dst & 0x3f) << 3) | src \
+   _asm _emit 0x9e \
+}
+
+#define PFCMPEQ(dst, src)       \
+{\
+   _asm _emit 0x0f                              \
+   _asm _emit 0x0f                              \
+   _asm _emit ((dst & 0x3f) << 3) | src \
+   _asm _emit 0xb0 \
+}
+
+#define PFCMPGE(dst, src)       \
+{\
+   _asm _emit 0x0f                              \
+   _asm _emit 0x0f                              \
+   _asm _emit ((dst & 0x3f) << 3) | src \
+   _asm _emit 0x90 \
+}
+
+#define PFCMPGT(dst, src)       \
+{\
+   _asm _emit 0x0f                              \
+   _asm _emit 0x0f                              \
+   _asm _emit ((dst & 0x3f) << 3) | src \
+   _asm _emit 0xa0 \
+}
+
+#define PFMAX(dst, src) \
+{\
+   _asm _emit 0x0f                              \
+   _asm _emit 0x0f                              \
+   _asm _emit ((dst & 0x3f) << 3) | src \
+   _asm _emit 0xa4 \
+}
+
+#define PFMIN(dst, src) \
+{\
+   _asm _emit 0x0f                              \
+   _asm _emit 0x0f                              \
+   _asm _emit ((dst & 0x3f) << 3) | src \
+   _asm _emit 0x94 \
+}
+
+#define PFMUL(dst, src) \
+{\
+   _asm _emit 0x0f                              \
+   _asm _emit 0x0f                              \
+   _asm _emit ((dst & 0x3f) << 3) | src \
+   _asm _emit 0xb4 \
+}
+
+#define PFRCP(dst, src) \
+{\
+   _asm _emit 0x0f                              \
+   _asm _emit 0x0f                              \
+   _asm _emit ((dst & 0x3f) << 3) | src \
+   _asm _emit 0x96 \
+}
+
+#define PFRCPIT1(dst, src)      \
+{\
+   _asm _emit 0x0f                              \
+   _asm _emit 0x0f                              \
+   _asm _emit ((dst & 0x3f) << 3) | src \
+   _asm _emit 0xa6 \
+}
+
+#define PFRCPIT2(dst, src)      \
+{\
+   _asm _emit 0x0f                              \
+   _asm _emit 0x0f                              \
+   _asm _emit ((dst & 0x3f) << 3) | src \
+   _asm _emit 0xb6 \
+}
+
+#define PFRSQRT(dst, src)       \
+{\
+   _asm _emit 0x0f                              \
+   _asm _emit 0x0f                              \
+   _asm _emit ((dst & 0x3f) << 3) | src \
+   _asm _emit 0x97 \
+}
+
+#define PFRSQIT1(dst, src)      \
+{\
+   _asm _emit 0x0f                              \
+   _asm _emit 0x0f                              \
+   _asm _emit ((dst & 0x3f) << 3) | src \
+   _asm _emit 0xa7 \
+}
+
+#define PFSUB(dst, src) \
+{\
+   _asm _emit 0x0f                              \
+   _asm _emit 0x0f                              \
+   _asm _emit ((dst & 0x3f) << 3) | src \
+   _asm _emit 0x9a \
+}
+
+#define PFSUBR(dst, src)        \
+{\
+   _asm _emit 0x0f                              \
+   _asm _emit 0x0f                              \
+   _asm _emit ((dst & 0x3f) << 3) | src \
+   _asm _emit 0xaa \
+}
+
+#define PI2FD(dst, src) \
+{\
+   _asm _emit 0x0f                              \
+   _asm _emit 0x0f                              \
+   _asm _emit ((dst & 0x3f) << 3) | src \
+   _asm _emit 0x0d \
+}
+
+#define FEMMS \
+{\
+        _asm _emit 0x0f \
+        _asm _emit 0x0e \
+}
+
+#define PAVGUSB(dst, src)       \
+{\
+   _asm _emit 0x0f                              \
+   _asm _emit 0x0f                              \
+   _asm _emit ((dst & 0x3f) << 3) | src \
+   _asm _emit 0xbf \
+}
+
+#define PMULHRW(dst, src)       \
+{\
+   _asm _emit 0x0f                              \
+   _asm _emit 0x0f                              \
+   _asm _emit ((dst & 0x3f) << 3) | src \
+   _asm _emit 0xb7 \
+}
+
+#define PREFETCH(src)   \
+{\
+   _asm _emit 0x0f                              \
+   _asm _emit 0x0d                              \
+   _asm _emit 0x00 | src        \
+}
+
+#define PREFETCHW(src)  \
+{\
+   _asm _emit 0x0f                              \
+   _asm _emit 0x0d                              \
+   _asm _emit 0x08 | src        \
+}
+
+//
+// Exactly same as above except macro names are all
+// lower case latter.
+//
+#define pf2id(dst, src) \
+{\
+   _asm _emit 0x0f                              \
+   _asm _emit 0x0f                              \
+   _asm _emit ((dst & 0x3f) << 3) | src \
+   _asm _emit 0x1d \
+}
+
+#define pfacc(dst, src) \
+{\
+   _asm _emit 0x0f                              \
+   _asm _emit 0x0f                              \
+   _asm _emit ((dst & 0x3f) << 3) | src \
+   _asm _emit 0xae \
+}
+
+#define pfadd(dst, src) \
+{\
+   _asm _emit 0x0f                              \
+   _asm _emit 0x0f                              \
+   _asm _emit ((dst & 0x3f) << 3) | src \
+   _asm _emit 0x9e \
+}
+
+#define pfcmpeq(dst, src)       \
+{\
+   _asm _emit 0x0f                              \
+   _asm _emit 0x0f                              \
+   _asm _emit ((dst & 0x3f) << 3) | src \
+   _asm _emit 0xb0 \
+}
+
+#define pfcmpge(dst, src)       \
+{\
+   _asm _emit 0x0f                              \
+   _asm _emit 0x0f                              \
+   _asm _emit ((dst & 0x3f) << 3) | src \
+   _asm _emit 0x90 \
+}
+
+#define pfcmpgt(dst, src)       \
+{\
+   _asm _emit 0x0f                              \
+   _asm _emit 0x0f                              \
+   _asm _emit ((dst & 0x3f) << 3) | src \
+   _asm _emit 0xa0 \
+}
+
+#define pfmax(dst, src) \
+{\
+   _asm _emit 0x0f                              \
+   _asm _emit 0x0f                              \
+   _asm _emit ((dst & 0x3f) << 3) | src \
+   _asm _emit 0xa4 \
+}
+
+#define pfmin(dst, src) \
+{\
+   _asm _emit 0x0f                              \
+   _asm _emit 0x0f                              \
+   _asm _emit ((dst & 0x3f) << 3) | src \
+   _asm _emit 0x94 \
+}
+
+#define pfmul(dst, src) \
+{\
+   _asm _emit 0x0f                              \
+   _asm _emit 0x0f                              \
+   _asm _emit ((dst & 0x3f) << 3) | src \
+   _asm _emit 0xb4 \
+}
+
+#define pfrcp(dst, src) \
+{\
+   _asm _emit 0x0f                              \
+   _asm _emit 0x0f                              \
+   _asm _emit ((dst & 0x3f) << 3) | src \
+   _asm _emit 0x96 \
+}
+
+#define pfrcpit1(dst, src)      \
+{\
+   _asm _emit 0x0f                              \
+   _asm _emit 0x0f                              \
+   _asm _emit ((dst & 0x3f) << 3) | src \
+   _asm _emit 0xa6 \
+}
+
+#define pfrcpit2(dst, src)      \
+{\
+   _asm _emit 0x0f                              \
+   _asm _emit 0x0f                              \
+   _asm _emit ((dst & 0x3f) << 3) | src \
+   _asm _emit 0xb6 \
+}
+
+#define pfrsqrt(dst, src)       \
+{\
+   _asm _emit 0x0f                              \
+   _asm _emit 0x0f                              \
+   _asm _emit ((dst & 0x3f) << 3) | src \
+   _asm _emit 0x97 \
+}
+
+#define pfrsqit1(dst, src)      \
+{\
+   _asm _emit 0x0f                              \
+   _asm _emit 0x0f                              \
+   _asm _emit ((dst & 0x3f) << 3) | src \
+   _asm _emit 0xa7 \
+}
+
+#define pfsub(dst, src) \
+{\
+   _asm _emit 0x0f                              \
+   _asm _emit 0x0f                              \
+   _asm _emit ((dst & 0x3f) << 3) | src \
+   _asm _emit 0x9a \
+}
+
+#define pfsubr(dst, src)        \
+{\
+   _asm _emit 0x0f                              \
+   _asm _emit 0x0f                              \
+   _asm _emit ((dst & 0x3f) << 3) | src \
+   _asm _emit 0xaa \
+}
+
+#define pi2fd(dst, src) \
+{\
+   _asm _emit 0x0f                              \
+   _asm _emit 0x0f                              \
+   _asm _emit ((dst & 0x3f) << 3) | src \
+   _asm _emit 0x0d \
+}
+
+#define femms \
+{\
+        _asm _emit 0x0f \
+        _asm _emit 0x0e \
+}
+
+#define pavgusb(dst, src)       \
+{\
+   _asm _emit 0x0f                              \
+   _asm _emit 0x0f                              \
+   _asm _emit ((dst & 0x3f) << 3) | src \
+   _asm _emit 0xbf \
+}
+
+#define pmulhrw(dst, src)       \
+{\
+   _asm _emit 0x0f                              \
+   _asm _emit 0x0f                              \
+   _asm _emit ((dst & 0x3f) << 3) | src \
+   _asm _emit 0xb7 \
+}
+
+#define prefetch(src)   \
+{\
+   _asm _emit 0x0f                              \
+   _asm _emit 0x0d                              \
+   _asm _emit 0x00 | src        \
+}
+
+#define prefetchw(src)  \
+{\
+   _asm _emit 0x0f                              \
+   _asm _emit 0x0d                              \
+   _asm _emit 0x08 | src        \
+}
diff --git a/code/renderer/glext.h b/code/renderer/glext.h
new file mode 100644
index 0000000..22d1f95
--- /dev/null
+++ b/code/renderer/glext.h
@@ -0,0 +1,2920 @@
+#ifndef __glext_h_
+#define __glext_h_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+** License Applicability. Except to the extent portions of this file are
+** made subject to an alternative license as permitted in the SGI Free
+** Software License B, Version 1.1 (the "License"), the contents of this
+** file are subject only to the provisions of the License. You may not use
+** this file except in compliance with the License. You may obtain a copy
+** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+** 
+** http://oss.sgi.com/projects/FreeB
+** 
+** Note that, as provided in the License, the Software is distributed on an
+** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+** 
+** Original Code. The Original Code is: OpenGL Sample Implementation,
+** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+** Copyright in any portions created by third parties is as indicated
+** elsewhere herein. All Rights Reserved.
+** 
+** Additional Notice Provisions: This software was created using the
+** OpenGL(R) version 1.2.1 Sample Implementation published by SGI, but has
+** not been independently verified as being compliant with the OpenGL(R)
+** version 1.2.1 Specification.
+*/
+
+#if defined(_WIN32) && !defined(APIENTRY) && !defined(__CYGWIN__)
+#define WIN32_LEAN_AND_MEAN 1
+#include <windows.h>
+#endif
+
+#ifndef APIENTRY
+#define APIENTRY
+#endif
+
+/*************************************************************/
+
+/* Header file version number, required by OpenGL ABI for Linux */
+#define GL_GLEXT_VERSION 6
+
+#ifndef GL_VERSION_1_2
+#define GL_CONSTANT_COLOR                 0x8001
+#define GL_ONE_MINUS_CONSTANT_COLOR       0x8002
+#define GL_CONSTANT_ALPHA                 0x8003
+#define GL_ONE_MINUS_CONSTANT_ALPHA       0x8004
+#define GL_BLEND_COLOR                    0x8005
+#define GL_FUNC_ADD                       0x8006
+#define GL_MIN                            0x8007
+#define GL_MAX                            0x8008
+#define GL_BLEND_EQUATION                 0x8009
+#define GL_FUNC_SUBTRACT                  0x800A
+#define GL_FUNC_REVERSE_SUBTRACT          0x800B
+#define GL_CONVOLUTION_1D                 0x8010
+#define GL_CONVOLUTION_2D                 0x8011
+#define GL_SEPARABLE_2D                   0x8012
+#define GL_CONVOLUTION_BORDER_MODE        0x8013
+#define GL_CONVOLUTION_FILTER_SCALE       0x8014
+#define GL_CONVOLUTION_FILTER_BIAS        0x8015
+#define GL_REDUCE                         0x8016
+#define GL_CONVOLUTION_FORMAT             0x8017
+#define GL_CONVOLUTION_WIDTH              0x8018
+#define GL_CONVOLUTION_HEIGHT             0x8019
+#define GL_MAX_CONVOLUTION_WIDTH          0x801A
+#define GL_MAX_CONVOLUTION_HEIGHT         0x801B
+#define GL_POST_CONVOLUTION_RED_SCALE     0x801C
+#define GL_POST_CONVOLUTION_GREEN_SCALE   0x801D
+#define GL_POST_CONVOLUTION_BLUE_SCALE    0x801E
+#define GL_POST_CONVOLUTION_ALPHA_SCALE   0x801F
+#define GL_POST_CONVOLUTION_RED_BIAS      0x8020
+#define GL_POST_CONVOLUTION_GREEN_BIAS    0x8021
+#define GL_POST_CONVOLUTION_BLUE_BIAS     0x8022
+#define GL_POST_CONVOLUTION_ALPHA_BIAS    0x8023
+#define GL_HISTOGRAM                      0x8024
+#define GL_PROXY_HISTOGRAM                0x8025
+#define GL_HISTOGRAM_WIDTH                0x8026
+#define GL_HISTOGRAM_FORMAT               0x8027
+#define GL_HISTOGRAM_RED_SIZE             0x8028
+#define GL_HISTOGRAM_GREEN_SIZE           0x8029
+#define GL_HISTOGRAM_BLUE_SIZE            0x802A
+#define GL_HISTOGRAM_ALPHA_SIZE           0x802B
+#define GL_HISTOGRAM_LUMINANCE_SIZE       0x802C
+#define GL_HISTOGRAM_SINK                 0x802D
+#define GL_MINMAX                         0x802E
+#define GL_MINMAX_FORMAT                  0x802F
+#define GL_MINMAX_SINK                    0x8030
+#define GL_TABLE_TOO_LARGE                0x8031
+#define GL_UNSIGNED_BYTE_3_3_2            0x8032
+#define GL_UNSIGNED_SHORT_4_4_4_4         0x8033
+#define GL_UNSIGNED_SHORT_5_5_5_1         0x8034
+#define GL_UNSIGNED_INT_8_8_8_8           0x8035
+#define GL_UNSIGNED_INT_10_10_10_2        0x8036
+#define GL_RESCALE_NORMAL                 0x803A
+#define GL_UNSIGNED_BYTE_2_3_3_REV        0x8362
+#define GL_UNSIGNED_SHORT_5_6_5           0x8363
+#define GL_UNSIGNED_SHORT_5_6_5_REV       0x8364
+#define GL_UNSIGNED_SHORT_4_4_4_4_REV     0x8365
+#define GL_UNSIGNED_SHORT_1_5_5_5_REV     0x8366
+#define GL_UNSIGNED_INT_8_8_8_8_REV       0x8367
+#define GL_UNSIGNED_INT_2_10_10_10_REV    0x8368
+#define GL_COLOR_MATRIX                   0x80B1
+#define GL_COLOR_MATRIX_STACK_DEPTH       0x80B2
+#define GL_MAX_COLOR_MATRIX_STACK_DEPTH   0x80B3
+#define GL_POST_COLOR_MATRIX_RED_SCALE    0x80B4
+#define GL_POST_COLOR_MATRIX_GREEN_SCALE  0x80B5
+#define GL_POST_COLOR_MATRIX_BLUE_SCALE   0x80B6
+#define GL_POST_COLOR_MATRIX_ALPHA_SCALE  0x80B7
+#define GL_POST_COLOR_MATRIX_RED_BIAS     0x80B8
+#define GL_POST_COLOR_MATRIX_GREEN_BIAS   0x80B9
+#define GL_POST_COLOR_MATRIX_BLUE_BIAS    0x80BA
+#define GL_COLOR_TABLE                    0x80D0
+#define GL_POST_CONVOLUTION_COLOR_TABLE   0x80D1
+#define GL_POST_COLOR_MATRIX_COLOR_TABLE  0x80D2
+#define GL_PROXY_COLOR_TABLE              0x80D3
+#define GL_PROXY_POST_CONVOLUTION_COLOR_TABLE 0x80D4
+#define GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE 0x80D5
+#define GL_COLOR_TABLE_SCALE              0x80D6
+#define GL_COLOR_TABLE_BIAS               0x80D7
+#define GL_COLOR_TABLE_FORMAT             0x80D8
+#define GL_COLOR_TABLE_WIDTH              0x80D9
+#define GL_COLOR_TABLE_RED_SIZE           0x80DA
+#define GL_COLOR_TABLE_GREEN_SIZE         0x80DB
+#define GL_COLOR_TABLE_BLUE_SIZE          0x80DC
+#define GL_COLOR_TABLE_ALPHA_SIZE         0x80DD
+#define GL_COLOR_TABLE_LUMINANCE_SIZE     0x80DE
+#define GL_COLOR_TABLE_INTENSITY_SIZE     0x80DF
+#define GL_CLAMP_TO_EDGE                  0x812F
+#define GL_TEXTURE_MIN_LOD                0x813A
+#define GL_TEXTURE_MAX_LOD                0x813B
+#define GL_TEXTURE_BASE_LEVEL             0x813C
+#define GL_TEXTURE_MAX_LEVEL              0x813D
+#endif
+
+#ifndef GL_ARB_multitexture
+#define GL_TEXTURE0_ARB                   0x84C0
+#define GL_TEXTURE1_ARB                   0x84C1
+#define GL_TEXTURE2_ARB                   0x84C2
+#define GL_TEXTURE3_ARB                   0x84C3
+#define GL_TEXTURE4_ARB                   0x84C4
+#define GL_TEXTURE5_ARB                   0x84C5
+#define GL_TEXTURE6_ARB                   0x84C6
+#define GL_TEXTURE7_ARB                   0x84C7
+#define GL_TEXTURE8_ARB                   0x84C8
+#define GL_TEXTURE9_ARB                   0x84C9
+#define GL_TEXTURE10_ARB                  0x84CA
+#define GL_TEXTURE11_ARB                  0x84CB
+#define GL_TEXTURE12_ARB                  0x84CC
+#define GL_TEXTURE13_ARB                  0x84CD
+#define GL_TEXTURE14_ARB                  0x84CE
+#define GL_TEXTURE15_ARB                  0x84CF
+#define GL_TEXTURE16_ARB                  0x84D0
+#define GL_TEXTURE17_ARB                  0x84D1
+#define GL_TEXTURE18_ARB                  0x84D2
+#define GL_TEXTURE19_ARB                  0x84D3
+#define GL_TEXTURE20_ARB                  0x84D4
+#define GL_TEXTURE21_ARB                  0x84D5
+#define GL_TEXTURE22_ARB                  0x84D6
+#define GL_TEXTURE23_ARB                  0x84D7
+#define GL_TEXTURE24_ARB                  0x84D8
+#define GL_TEXTURE25_ARB                  0x84D9
+#define GL_TEXTURE26_ARB                  0x84DA
+#define GL_TEXTURE27_ARB                  0x84DB
+#define GL_TEXTURE28_ARB                  0x84DC
+#define GL_TEXTURE29_ARB                  0x84DD
+#define GL_TEXTURE30_ARB                  0x84DE
+#define GL_TEXTURE31_ARB                  0x84DF
+#define GL_ACTIVE_TEXTURE_ARB             0x84E0
+#define GL_CLIENT_ACTIVE_TEXTURE_ARB      0x84E1
+#define GL_MAX_TEXTURE_UNITS_ARB          0x84E2
+#endif
+
+#ifndef GL_ARB_transpose_matrix
+#define GL_TRANSPOSE_MODELVIEW_MATRIX_ARB 0x84E3
+#define GL_TRANSPOSE_PROJECTION_MATRIX_ARB 0x84E4
+#define GL_TRANSPOSE_TEXTURE_MATRIX_ARB   0x84E5
+#define GL_TRANSPOSE_COLOR_MATRIX_ARB     0x84E6
+#endif
+
+#ifndef GL_ARB_multisample
+#define GL_MULTISAMPLE_ARB                0x809D
+#define GL_SAMPLE_ALPHA_TO_COVERAGE_ARB   0x809E
+#define GL_SAMPLE_ALPHA_TO_ONE_ARB        0x809F
+#define GL_SAMPLE_COVERAGE_ARB            0x80A0
+#define GL_SAMPLE_BUFFERS_ARB             0x80A8
+#define GL_SAMPLES_ARB                    0x80A9
+#define GL_SAMPLE_COVERAGE_VALUE_ARB      0x80AA
+#define GL_SAMPLE_COVERAGE_INVERT_ARB     0x80AB
+#define GL_MULTISAMPLE_BIT_ARB            0x20000000
+#endif
+
+#ifndef GL_ARB_texture_cube_map
+#define GL_NORMAL_MAP_ARB                 0x8511
+#define GL_REFLECTION_MAP_ARB             0x8512
+#define GL_TEXTURE_CUBE_MAP_ARB           0x8513
+#define GL_TEXTURE_BINDING_CUBE_MAP_ARB   0x8514
+#define GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB 0x8515
+#define GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB 0x8516
+#define GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB 0x8517
+#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB 0x8518
+#define GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB 0x8519
+#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB 0x851A
+#define GL_PROXY_TEXTURE_CUBE_MAP_ARB     0x851B
+#define GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB  0x851C
+#endif
+
+#ifndef GL_ARB_texture_compression
+#define GL_COMPRESSED_ALPHA_ARB           0x84E9
+#define GL_COMPRESSED_LUMINANCE_ARB       0x84EA
+#define GL_COMPRESSED_LUMINANCE_ALPHA_ARB 0x84EB
+#define GL_COMPRESSED_INTENSITY_ARB       0x84EC
+#define GL_COMPRESSED_RGB_ARB             0x84ED
+#define GL_COMPRESSED_RGBA_ARB            0x84EE
+#define GL_TEXTURE_COMPRESSION_HINT_ARB   0x84EF
+#define GL_TEXTURE_IMAGE_SIZE_ARB         0x86A0
+#define GL_TEXTURE_COMPRESSED_ARB         0x86A1
+#define GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB 0x86A2
+#define GL_COMPRESSED_TEXTURE_FORMATS_ARB 0x86A3
+#endif
+
+#ifndef GL_EXT_abgr
+#define GL_ABGR_EXT                       0x8000
+#endif
+
+#ifndef GL_EXT_blend_color
+#define GL_CONSTANT_COLOR_EXT             0x8001
+#define GL_ONE_MINUS_CONSTANT_COLOR_EXT   0x8002
+#define GL_CONSTANT_ALPHA_EXT             0x8003
+#define GL_ONE_MINUS_CONSTANT_ALPHA_EXT   0x8004
+#define GL_BLEND_COLOR_EXT                0x8005
+#endif
+
+#ifndef GL_EXT_polygon_offset
+#define GL_POLYGON_OFFSET_EXT             0x8037
+#define GL_POLYGON_OFFSET_FACTOR_EXT      0x8038
+#define GL_POLYGON_OFFSET_BIAS_EXT        0x8039
+#endif
+
+#ifndef GL_EXT_texture
+#define GL_ALPHA4_EXT                     0x803B
+#define GL_ALPHA8_EXT                     0x803C
+#define GL_ALPHA12_EXT                    0x803D
+#define GL_ALPHA16_EXT                    0x803E
+#define GL_LUMINANCE4_EXT                 0x803F
+#define GL_LUMINANCE8_EXT                 0x8040
+#define GL_LUMINANCE12_EXT                0x8041
+#define GL_LUMINANCE16_EXT                0x8042
+#define GL_LUMINANCE4_ALPHA4_EXT          0x8043
+#define GL_LUMINANCE6_ALPHA2_EXT          0x8044
+#define GL_LUMINANCE8_ALPHA8_EXT          0x8045
+#define GL_LUMINANCE12_ALPHA4_EXT         0x8046
+#define GL_LUMINANCE12_ALPHA12_EXT        0x8047
+#define GL_LUMINANCE16_ALPHA16_EXT        0x8048
+#define GL_INTENSITY_EXT                  0x8049
+#define GL_INTENSITY4_EXT                 0x804A
+#define GL_INTENSITY8_EXT                 0x804B
+#define GL_INTENSITY12_EXT                0x804C
+#define GL_INTENSITY16_EXT                0x804D
+#define GL_RGB2_EXT                       0x804E
+#define GL_RGB4_EXT                       0x804F
+#define GL_RGB5_EXT                       0x8050
+#define GL_RGB8_EXT                       0x8051
+#define GL_RGB10_EXT                      0x8052
+#define GL_RGB12_EXT                      0x8053
+#define GL_RGB16_EXT                      0x8054
+#define GL_RGBA2_EXT                      0x8055
+#define GL_RGBA4_EXT                      0x8056
+#define GL_RGB5_A1_EXT                    0x8057
+#define GL_RGBA8_EXT                      0x8058
+#define GL_RGB10_A2_EXT                   0x8059
+#define GL_RGBA12_EXT                     0x805A
+#define GL_RGBA16_EXT                     0x805B
+#define GL_TEXTURE_RED_SIZE_EXT           0x805C
+#define GL_TEXTURE_GREEN_SIZE_EXT         0x805D
+#define GL_TEXTURE_BLUE_SIZE_EXT          0x805E
+#define GL_TEXTURE_ALPHA_SIZE_EXT         0x805F
+#define GL_TEXTURE_LUMINANCE_SIZE_EXT     0x8060
+#define GL_TEXTURE_INTENSITY_SIZE_EXT     0x8061
+#define GL_REPLACE_EXT                    0x8062
+#define GL_PROXY_TEXTURE_1D_EXT           0x8063
+#define GL_PROXY_TEXTURE_2D_EXT           0x8064
+#define GL_TEXTURE_TOO_LARGE_EXT          0x8065
+#endif
+
+#ifndef GL_EXT_texture3D
+#define GL_PACK_SKIP_IMAGES               0x806B
+#define GL_PACK_SKIP_IMAGES_EXT           0x806B
+#define GL_PACK_IMAGE_HEIGHT              0x806C
+#define GL_PACK_IMAGE_HEIGHT_EXT          0x806C
+#define GL_UNPACK_SKIP_IMAGES             0x806D
+#define GL_UNPACK_SKIP_IMAGES_EXT         0x806D
+#define GL_UNPACK_IMAGE_HEIGHT            0x806E
+#define GL_UNPACK_IMAGE_HEIGHT_EXT        0x806E
+#define GL_TEXTURE_3D                     0x806F
+#define GL_TEXTURE_3D_EXT                 0x806F
+#define GL_PROXY_TEXTURE_3D               0x8070
+#define GL_PROXY_TEXTURE_3D_EXT           0x8070
+#define GL_TEXTURE_DEPTH                  0x8071
+#define GL_TEXTURE_DEPTH_EXT              0x8071
+#define GL_TEXTURE_WRAP_R                 0x8072
+#define GL_TEXTURE_WRAP_R_EXT             0x8072
+#define GL_MAX_3D_TEXTURE_SIZE            0x8073
+#define GL_MAX_3D_TEXTURE_SIZE_EXT        0x8073
+#endif
+
+#ifndef GL_SGIS_texture_filter4
+#define GL_FILTER4_SGIS                   0x8146
+#define GL_TEXTURE_FILTER4_SIZE_SGIS      0x8147
+#endif
+
+#ifndef GL_EXT_subtexture
+#endif
+
+#ifndef GL_EXT_copy_texture
+#endif
+
+#ifndef GL_EXT_histogram
+#define GL_HISTOGRAM_EXT                  0x8024
+#define GL_PROXY_HISTOGRAM_EXT            0x8025
+#define GL_HISTOGRAM_WIDTH_EXT            0x8026
+#define GL_HISTOGRAM_FORMAT_EXT           0x8027
+#define GL_HISTOGRAM_RED_SIZE_EXT         0x8028
+#define GL_HISTOGRAM_GREEN_SIZE_EXT       0x8029
+#define GL_HISTOGRAM_BLUE_SIZE_EXT        0x802A
+#define GL_HISTOGRAM_ALPHA_SIZE_EXT       0x802B
+#define GL_HISTOGRAM_LUMINANCE_SIZE_EXT   0x802C
+#define GL_HISTOGRAM_SINK_EXT             0x802D
+#define GL_MINMAX_EXT                     0x802E
+#define GL_MINMAX_FORMAT_EXT              0x802F
+#define GL_MINMAX_SINK_EXT                0x8030
+#define GL_TABLE_TOO_LARGE_EXT            0x8031
+#endif
+
+#ifndef GL_EXT_convolution
+#define GL_CONVOLUTION_1D_EXT             0x8010
+#define GL_CONVOLUTION_2D_EXT             0x8011
+#define GL_SEPARABLE_2D_EXT               0x8012
+#define GL_CONVOLUTION_BORDER_MODE_EXT    0x8013
+#define GL_CONVOLUTION_FILTER_SCALE_EXT   0x8014
+#define GL_CONVOLUTION_FILTER_BIAS_EXT    0x8015
+#define GL_REDUCE_EXT                     0x8016
+#define GL_CONVOLUTION_FORMAT_EXT         0x8017
+#define GL_CONVOLUTION_WIDTH_EXT          0x8018
+#define GL_CONVOLUTION_HEIGHT_EXT         0x8019
+#define GL_MAX_CONVOLUTION_WIDTH_EXT      0x801A
+#define GL_MAX_CONVOLUTION_HEIGHT_EXT     0x801B
+#define GL_POST_CONVOLUTION_RED_SCALE_EXT 0x801C
+#define GL_POST_CONVOLUTION_GREEN_SCALE_EXT 0x801D
+#define GL_POST_CONVOLUTION_BLUE_SCALE_EXT 0x801E
+#define GL_POST_CONVOLUTION_ALPHA_SCALE_EXT 0x801F
+#define GL_POST_CONVOLUTION_RED_BIAS_EXT  0x8020
+#define GL_POST_CONVOLUTION_GREEN_BIAS_EXT 0x8021
+#define GL_POST_CONVOLUTION_BLUE_BIAS_EXT 0x8022
+#define GL_POST_CONVOLUTION_ALPHA_BIAS_EXT 0x8023
+#endif
+
+#ifndef GL_SGI_color_matrix
+#define GL_COLOR_MATRIX_SGI               0x80B1
+#define GL_COLOR_MATRIX_STACK_DEPTH_SGI   0x80B2
+#define GL_MAX_COLOR_MATRIX_STACK_DEPTH_SGI 0x80B3
+#define GL_POST_COLOR_MATRIX_RED_SCALE_SGI 0x80B4
+#define GL_POST_COLOR_MATRIX_GREEN_SCALE_SGI 0x80B5
+#define GL_POST_COLOR_MATRIX_BLUE_SCALE_SGI 0x80B6
+#define GL_POST_COLOR_MATRIX_ALPHA_SCALE_SGI 0x80B7
+#define GL_POST_COLOR_MATRIX_RED_BIAS_SGI 0x80B8
+#define GL_POST_COLOR_MATRIX_GREEN_BIAS_SGI 0x80B9
+#define GL_POST_COLOR_MATRIX_BLUE_BIAS_SGI 0x80BA
+#define GL_POST_COLOR_MATRIX_ALPHA_BIAS_SGI 0x80BB
+#endif
+
+#ifndef GL_SGI_color_table
+#define GL_COLOR_TABLE_SGI                0x80D0
+#define GL_POST_CONVOLUTION_COLOR_TABLE_SGI 0x80D1
+#define GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI 0x80D2
+#define GL_PROXY_COLOR_TABLE_SGI          0x80D3
+#define GL_PROXY_POST_CONVOLUTION_COLOR_TABLE_SGI 0x80D4
+#define GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE_SGI 0x80D5
+#define GL_COLOR_TABLE_SCALE_SGI          0x80D6
+#define GL_COLOR_TABLE_BIAS_SGI           0x80D7
+#define GL_COLOR_TABLE_FORMAT_SGI         0x80D8
+#define GL_COLOR_TABLE_WIDTH_SGI          0x80D9
+#define GL_COLOR_TABLE_RED_SIZE_SGI       0x80DA
+#define GL_COLOR_TABLE_GREEN_SIZE_SGI     0x80DB
+#define GL_COLOR_TABLE_BLUE_SIZE_SGI      0x80DC
+#define GL_COLOR_TABLE_ALPHA_SIZE_SGI     0x80DD
+#define GL_COLOR_TABLE_LUMINANCE_SIZE_SGI 0x80DE
+#define GL_COLOR_TABLE_INTENSITY_SIZE_SGI 0x80DF
+#endif
+
+#ifndef GL_SGIS_pixel_texture
+#define GL_PIXEL_TEXTURE_SGIS             0x8353
+#define GL_PIXEL_FRAGMENT_RGB_SOURCE_SGIS 0x8354
+#define GL_PIXEL_FRAGMENT_ALPHA_SOURCE_SGIS 0x8355
+#define GL_PIXEL_GROUP_COLOR_SGIS         0x8356
+#endif
+
+#ifndef GL_SGIX_pixel_texture
+#define GL_PIXEL_TEX_GEN_SGIX             0x8139
+#define GL_PIXEL_TEX_GEN_MODE_SGIX        0x832B
+#endif
+
+#ifndef GL_SGIS_texture4D
+#define GL_PACK_SKIP_VOLUMES_SGIS         0x8130
+#define GL_PACK_IMAGE_DEPTH_SGIS          0x8131
+#define GL_UNPACK_SKIP_VOLUMES_SGIS       0x8132
+#define GL_UNPACK_IMAGE_DEPTH_SGIS        0x8133
+#define GL_TEXTURE_4D_SGIS                0x8134
+#define GL_PROXY_TEXTURE_4D_SGIS          0x8135
+#define GL_TEXTURE_4DSIZE_SGIS            0x8136
+#define GL_TEXTURE_WRAP_Q_SGIS            0x8137
+#define GL_MAX_4D_TEXTURE_SIZE_SGIS       0x8138
+#define GL_TEXTURE_4D_BINDING_SGIS        0x814F
+#endif
+
+#ifndef GL_SGI_texture_color_table
+#define GL_TEXTURE_COLOR_TABLE_SGI        0x80BC
+#define GL_PROXY_TEXTURE_COLOR_TABLE_SGI  0x80BD
+#endif
+
+#ifndef GL_EXT_cmyka
+#define GL_CMYK_EXT                       0x800C
+#define GL_CMYKA_EXT                      0x800D
+#define GL_PACK_CMYK_HINT_EXT             0x800E
+#define GL_UNPACK_CMYK_HINT_EXT           0x800F
+#endif
+
+#ifndef GL_EXT_texture_object
+#define GL_TEXTURE_PRIORITY_EXT           0x8066
+#define GL_TEXTURE_RESIDENT_EXT           0x8067
+#define GL_TEXTURE_1D_BINDING_EXT         0x8068
+#define GL_TEXTURE_2D_BINDING_EXT         0x8069
+#define GL_TEXTURE_3D_BINDING_EXT         0x806A
+#endif
+
+#ifndef GL_SGIS_detail_texture
+#define GL_DETAIL_TEXTURE_2D_SGIS         0x8095
+#define GL_DETAIL_TEXTURE_2D_BINDING_SGIS 0x8096
+#define GL_LINEAR_DETAIL_SGIS             0x8097
+#define GL_LINEAR_DETAIL_ALPHA_SGIS       0x8098
+#define GL_LINEAR_DETAIL_COLOR_SGIS       0x8099
+#define GL_DETAIL_TEXTURE_LEVEL_SGIS      0x809A
+#define GL_DETAIL_TEXTURE_MODE_SGIS       0x809B
+#define GL_DETAIL_TEXTURE_FUNC_POINTS_SGIS 0x809C
+#endif
+
+#ifndef GL_SGIS_sharpen_texture
+#define GL_LINEAR_SHARPEN_SGIS            0x80AD
+#define GL_LINEAR_SHARPEN_ALPHA_SGIS      0x80AE
+#define GL_LINEAR_SHARPEN_COLOR_SGIS      0x80AF
+#define GL_SHARPEN_TEXTURE_FUNC_POINTS_SGIS 0x80B0
+#endif
+
+#ifndef GL_EXT_packed_pixels
+#define GL_UNSIGNED_BYTE_3_3_2_EXT        0x8032
+#define GL_UNSIGNED_SHORT_4_4_4_4_EXT     0x8033
+#define GL_UNSIGNED_SHORT_5_5_5_1_EXT     0x8034
+#define GL_UNSIGNED_INT_8_8_8_8_EXT       0x8035
+#define GL_UNSIGNED_INT_10_10_10_2_EXT    0x8036
+#endif
+
+#ifndef GL_SGIS_texture_lod
+#define GL_TEXTURE_MIN_LOD_SGIS           0x813A
+#define GL_TEXTURE_MAX_LOD_SGIS           0x813B
+#define GL_TEXTURE_BASE_LEVEL_SGIS        0x813C
+#define GL_TEXTURE_MAX_LEVEL_SGIS         0x813D
+#endif
+
+#ifndef GL_SGIS_multisample
+#define GL_MULTISAMPLE_SGIS               0x809D
+#define GL_SAMPLE_ALPHA_TO_MASK_SGIS      0x809E
+#define GL_SAMPLE_ALPHA_TO_ONE_SGIS       0x809F
+#define GL_SAMPLE_MASK_SGIS               0x80A0
+#define GL_1PASS_SGIS                     0x80A1
+#define GL_2PASS_0_SGIS                   0x80A2
+#define GL_2PASS_1_SGIS                   0x80A3
+#define GL_4PASS_0_SGIS                   0x80A4
+#define GL_4PASS_1_SGIS                   0x80A5
+#define GL_4PASS_2_SGIS                   0x80A6
+#define GL_4PASS_3_SGIS                   0x80A7
+#define GL_SAMPLE_BUFFERS_SGIS            0x80A8
+#define GL_SAMPLES_SGIS                   0x80A9
+#define GL_SAMPLE_MASK_VALUE_SGIS         0x80AA
+#define GL_SAMPLE_MASK_INVERT_SGIS        0x80AB
+#define GL_SAMPLE_PATTERN_SGIS            0x80AC
+#endif
+
+#ifndef GL_EXT_rescale_normal
+#define GL_RESCALE_NORMAL_EXT             0x803A
+#endif
+
+#ifndef GL_EXT_vertex_array
+#define GL_VERTEX_ARRAY_EXT               0x8074
+#define GL_NORMAL_ARRAY_EXT               0x8075
+#define GL_COLOR_ARRAY_EXT                0x8076
+#define GL_INDEX_ARRAY_EXT                0x8077
+#define GL_TEXTURE_COORD_ARRAY_EXT        0x8078
+#define GL_EDGE_FLAG_ARRAY_EXT            0x8079
+#define GL_VERTEX_ARRAY_SIZE_EXT          0x807A
+#define GL_VERTEX_ARRAY_TYPE_EXT          0x807B
+#define GL_VERTEX_ARRAY_STRIDE_EXT        0x807C
+#define GL_VERTEX_ARRAY_COUNT_EXT         0x807D
+#define GL_NORMAL_ARRAY_TYPE_EXT          0x807E
+#define GL_NORMAL_ARRAY_STRIDE_EXT        0x807F
+#define GL_NORMAL_ARRAY_COUNT_EXT         0x8080
+#define GL_COLOR_ARRAY_SIZE_EXT           0x8081
+#define GL_COLOR_ARRAY_TYPE_EXT           0x8082
+#define GL_COLOR_ARRAY_STRIDE_EXT         0x8083
+#define GL_COLOR_ARRAY_COUNT_EXT          0x8084
+#define GL_INDEX_ARRAY_TYPE_EXT           0x8085
+#define GL_INDEX_ARRAY_STRIDE_EXT         0x8086
+#define GL_INDEX_ARRAY_COUNT_EXT          0x8087
+#define GL_TEXTURE_COORD_ARRAY_SIZE_EXT   0x8088
+#define GL_TEXTURE_COORD_ARRAY_TYPE_EXT   0x8089
+#define GL_TEXTURE_COORD_ARRAY_STRIDE_EXT 0x808A
+#define GL_TEXTURE_COORD_ARRAY_COUNT_EXT  0x808B
+#define GL_EDGE_FLAG_ARRAY_STRIDE_EXT     0x808C
+#define GL_EDGE_FLAG_ARRAY_COUNT_EXT      0x808D
+#define GL_VERTEX_ARRAY_POINTER_EXT       0x808E
+#define GL_NORMAL_ARRAY_POINTER_EXT       0x808F
+#define GL_COLOR_ARRAY_POINTER_EXT        0x8090
+#define GL_INDEX_ARRAY_POINTER_EXT        0x8091
+#define GL_TEXTURE_COORD_ARRAY_POINTER_EXT 0x8092
+#define GL_EDGE_FLAG_ARRAY_POINTER_EXT    0x8093
+#endif
+
+#ifndef GL_EXT_misc_attribute
+#endif
+
+#ifndef GL_SGIS_generate_mipmap
+#define GL_GENERATE_MIPMAP_SGIS           0x8191
+#define GL_GENERATE_MIPMAP_HINT_SGIS      0x8192
+#endif
+
+#ifndef GL_SGIX_clipmap
+#define GL_LINEAR_CLIPMAP_LINEAR_SGIX     0x8170
+#define GL_TEXTURE_CLIPMAP_CENTER_SGIX    0x8171
+#define GL_TEXTURE_CLIPMAP_FRAME_SGIX     0x8172
+#define GL_TEXTURE_CLIPMAP_OFFSET_SGIX    0x8173
+#define GL_TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX 0x8174
+#define GL_TEXTURE_CLIPMAP_LOD_OFFSET_SGIX 0x8175
+#define GL_TEXTURE_CLIPMAP_DEPTH_SGIX     0x8176
+#define GL_MAX_CLIPMAP_DEPTH_SGIX         0x8177
+#define GL_MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX 0x8178
+#define GL_NEAREST_CLIPMAP_NEAREST_SGIX   0x844D
+#define GL_NEAREST_CLIPMAP_LINEAR_SGIX    0x844E
+#define GL_LINEAR_CLIPMAP_NEAREST_SGIX    0x844F
+#endif
+
+#ifndef GL_SGIX_shadow
+#define GL_TEXTURE_COMPARE_SGIX           0x819A
+#define GL_TEXTURE_COMPARE_OPERATOR_SGIX  0x819B
+#define GL_TEXTURE_LEQUAL_R_SGIX          0x819C
+#define GL_TEXTURE_GEQUAL_R_SGIX          0x819D
+#endif
+
+#ifndef GL_SGIS_texture_edge_clamp
+#define GL_CLAMP_TO_EDGE_SGIS             0x812F
+#endif
+
+#ifndef GL_SGIS_texture_border_clamp
+#define GL_CLAMP_TO_BORDER_SGIS           0x812D
+#endif
+
+#ifndef GL_EXT_blend_minmax
+#define GL_FUNC_ADD_EXT                   0x8006
+#define GL_MIN_EXT                        0x8007
+#define GL_MAX_EXT                        0x8008
+#define GL_BLEND_EQUATION_EXT             0x8009
+#endif
+
+#ifndef GL_EXT_blend_subtract
+#define GL_FUNC_SUBTRACT_EXT              0x800A
+#define GL_FUNC_REVERSE_SUBTRACT_EXT      0x800B
+#endif
+
+#ifndef GL_EXT_blend_logic_op
+#endif
+
+#ifndef GL_SGIX_interlace
+#define GL_INTERLACE_SGIX                 0x8094
+#endif
+
+#ifndef GL_SGIX_pixel_tiles
+#define GL_PIXEL_TILE_BEST_ALIGNMENT_SGIX 0x813E
+#define GL_PIXEL_TILE_CACHE_INCREMENT_SGIX 0x813F
+#define GL_PIXEL_TILE_WIDTH_SGIX          0x8140
+#define GL_PIXEL_TILE_HEIGHT_SGIX         0x8141
+#define GL_PIXEL_TILE_GRID_WIDTH_SGIX     0x8142
+#define GL_PIXEL_TILE_GRID_HEIGHT_SGIX    0x8143
+#define GL_PIXEL_TILE_GRID_DEPTH_SGIX     0x8144
+#define GL_PIXEL_TILE_CACHE_SIZE_SGIX     0x8145
+#endif
+
+#ifndef GL_SGIS_texture_select
+#define GL_DUAL_ALPHA4_SGIS               0x8110
+#define GL_DUAL_ALPHA8_SGIS               0x8111
+#define GL_DUAL_ALPHA12_SGIS              0x8112
+#define GL_DUAL_ALPHA16_SGIS              0x8113
+#define GL_DUAL_LUMINANCE4_SGIS           0x8114
+#define GL_DUAL_LUMINANCE8_SGIS           0x8115
+#define GL_DUAL_LUMINANCE12_SGIS          0x8116
+#define GL_DUAL_LUMINANCE16_SGIS          0x8117
+#define GL_DUAL_INTENSITY4_SGIS           0x8118
+#define GL_DUAL_INTENSITY8_SGIS           0x8119
+#define GL_DUAL_INTENSITY12_SGIS          0x811A
+#define GL_DUAL_INTENSITY16_SGIS          0x811B
+#define GL_DUAL_LUMINANCE_ALPHA4_SGIS     0x811C
+#define GL_DUAL_LUMINANCE_ALPHA8_SGIS     0x811D
+#define GL_QUAD_ALPHA4_SGIS               0x811E
+#define GL_QUAD_ALPHA8_SGIS               0x811F
+#define GL_QUAD_LUMINANCE4_SGIS           0x8120
+#define GL_QUAD_LUMINANCE8_SGIS           0x8121
+#define GL_QUAD_INTENSITY4_SGIS           0x8122
+#define GL_QUAD_INTENSITY8_SGIS           0x8123
+#define GL_DUAL_TEXTURE_SELECT_SGIS       0x8124
+#define GL_QUAD_TEXTURE_SELECT_SGIS       0x8125
+#endif
+
+#ifndef GL_SGIX_sprite
+#define GL_SPRITE_SGIX                    0x8148
+#define GL_SPRITE_MODE_SGIX               0x8149
+#define GL_SPRITE_AXIS_SGIX               0x814A
+#define GL_SPRITE_TRANSLATION_SGIX        0x814B
+#define GL_SPRITE_AXIAL_SGIX              0x814C
+#define GL_SPRITE_OBJECT_ALIGNED_SGIX     0x814D
+#define GL_SPRITE_EYE_ALIGNED_SGIX        0x814E
+#endif
+
+#ifndef GL_SGIX_texture_multi_buffer
+#define GL_TEXTURE_MULTI_BUFFER_HINT_SGIX 0x812E
+#endif
+
+#ifndef GL_SGIS_point_parameters
+#define GL_POINT_SIZE_MIN_EXT             0x8126
+#define GL_POINT_SIZE_MIN_SGIS            0x8126
+#define GL_POINT_SIZE_MAX_EXT             0x8127
+#define GL_POINT_SIZE_MAX_SGIS            0x8127
+#define GL_POINT_FADE_THRESHOLD_SIZE_EXT  0x8128
+#define GL_POINT_FADE_THRESHOLD_SIZE_SGIS 0x8128
+#define GL_DISTANCE_ATTENUATION_EXT       0x8129
+#define GL_DISTANCE_ATTENUATION_SGIS      0x8129
+#endif
+
+#ifndef GL_SGIX_instruments
+#define GL_INSTRUMENT_BUFFER_POINTER_SGIX 0x8180
+#define GL_INSTRUMENT_MEASUREMENTS_SGIX   0x8181
+#endif
+
+#ifndef GL_SGIX_texture_scale_bias
+#define GL_POST_TEXTURE_FILTER_BIAS_SGIX  0x8179
+#define GL_POST_TEXTURE_FILTER_SCALE_SGIX 0x817A
+#define GL_POST_TEXTURE_FILTER_BIAS_RANGE_SGIX 0x817B
+#define GL_POST_TEXTURE_FILTER_SCALE_RANGE_SGIX 0x817C
+#endif
+
+#ifndef GL_SGIX_framezoom
+#define GL_FRAMEZOOM_SGIX                 0x818B
+#define GL_FRAMEZOOM_FACTOR_SGIX          0x818C
+#define GL_MAX_FRAMEZOOM_FACTOR_SGIX      0x818D
+#endif
+
+#ifndef GL_SGIX_tag_sample_buffer
+#endif
+
+#ifndef GL_SGIX_reference_plane
+#define GL_REFERENCE_PLANE_SGIX           0x817D
+#define GL_REFERENCE_PLANE_EQUATION_SGIX  0x817E
+#endif
+
+#ifndef GL_SGIX_flush_raster
+#endif
+
+#ifndef GL_SGIX_depth_texture
+#define GL_DEPTH_COMPONENT16_SGIX         0x81A5
+#define GL_DEPTH_COMPONENT24_SGIX         0x81A6
+#define GL_DEPTH_COMPONENT32_SGIX         0x81A7
+#endif
+
+#ifndef GL_SGIS_fog_function
+#define GL_FOG_FUNC_SGIS                  0x812A
+#define GL_FOG_FUNC_POINTS_SGIS           0x812B
+#define GL_MAX_FOG_FUNC_POINTS_SGIS       0x812C
+#endif
+
+#ifndef GL_SGIX_fog_offset
+#define GL_FOG_OFFSET_SGIX                0x8198
+#define GL_FOG_OFFSET_VALUE_SGIX          0x8199
+#endif
+
+#ifndef GL_HP_image_transform
+#define GL_IMAGE_SCALE_X_HP               0x8155
+#define GL_IMAGE_SCALE_Y_HP               0x8156
+#define GL_IMAGE_TRANSLATE_X_HP           0x8157
+#define GL_IMAGE_TRANSLATE_Y_HP           0x8158
+#define GL_IMAGE_ROTATE_ANGLE_HP          0x8159
+#define GL_IMAGE_ROTATE_ORIGIN_X_HP       0x815A
+#define GL_IMAGE_ROTATE_ORIGIN_Y_HP       0x815B
+#define GL_IMAGE_MAG_FILTER_HP            0x815C
+#define GL_IMAGE_MIN_FILTER_HP            0x815D
+#define GL_IMAGE_CUBIC_WEIGHT_HP          0x815E
+#define GL_CUBIC_HP                       0x815F
+#define GL_AVERAGE_HP                     0x8160
+#define GL_IMAGE_TRANSFORM_2D_HP          0x8161
+#define GL_POST_IMAGE_TRANSFORM_COLOR_TABLE_HP 0x8162
+#define GL_PROXY_POST_IMAGE_TRANSFORM_COLOR_TABLE_HP 0x8163
+#endif
+
+#ifndef GL_HP_convolution_border_modes
+#define GL_IGNORE_BORDER_HP               0x8150
+#define GL_CONSTANT_BORDER_HP             0x8151
+#define GL_REPLICATE_BORDER_HP            0x8153
+#define GL_CONVOLUTION_BORDER_COLOR_HP    0x8154
+#endif
+
+#ifndef GL_INGR_palette_buffer
+#endif
+
+#ifndef GL_SGIX_texture_add_env
+#define GL_TEXTURE_ENV_BIAS_SGIX          0x80BE
+#endif
+
+#ifndef GL_EXT_color_subtable
+#endif
+
+#ifndef GL_PGI_vertex_hints
+#define GL_VERTEX_DATA_HINT_PGI           0x1A22A
+#define GL_VERTEX_CONSISTENT_HINT_PGI     0x1A22B
+#define GL_MATERIAL_SIDE_HINT_PGI         0x1A22C
+#define GL_MAX_VERTEX_HINT_PGI            0x1A22D
+#define GL_COLOR3_BIT_PGI                 0x00010000
+#define GL_COLOR4_BIT_PGI                 0x00020000
+#define GL_EDGEFLAG_BIT_PGI               0x00040000
+#define GL_INDEX_BIT_PGI                  0x00080000
+#define GL_MAT_AMBIENT_BIT_PGI            0x00100000
+#define GL_MAT_AMBIENT_AND_DIFFUSE_BIT_PGI 0x00200000
+#define GL_MAT_DIFFUSE_BIT_PGI            0x00400000
+#define GL_MAT_EMISSION_BIT_PGI           0x00800000
+#define GL_MAT_COLOR_INDEXES_BIT_PGI      0x01000000
+#define GL_MAT_SHININESS_BIT_PGI          0x02000000
+#define GL_MAT_SPECULAR_BIT_PGI           0x04000000
+#define GL_NORMAL_BIT_PGI                 0x08000000
+#define GL_TEXCOORD1_BIT_PGI              0x10000000
+#define GL_TEXCOORD2_BIT_PGI              0x20000000
+#define GL_TEXCOORD3_BIT_PGI              0x40000000
+#define GL_TEXCOORD4_BIT_PGI              0x80000000
+#define GL_VERTEX23_BIT_PGI               0x00000004
+#define GL_VERTEX4_BIT_PGI                0x00000008
+#endif
+
+#ifndef GL_PGI_misc_hints
+#define GL_PREFER_DOUBLEBUFFER_HINT_PGI   0x1A1F8
+#define GL_CONSERVE_MEMORY_HINT_PGI       0x1A1FD
+#define GL_RECLAIM_MEMORY_HINT_PGI        0x1A1FE
+#define GL_NATIVE_GRAPHICS_HANDLE_PGI     0x1A202
+#define GL_NATIVE_GRAPHICS_BEGIN_HINT_PGI 0x1A203
+#define GL_NATIVE_GRAPHICS_END_HINT_PGI   0x1A204
+#define GL_ALWAYS_FAST_HINT_PGI           0x1A20C
+#define GL_ALWAYS_SOFT_HINT_PGI           0x1A20D
+#define GL_ALLOW_DRAW_OBJ_HINT_PGI        0x1A20E
+#define GL_ALLOW_DRAW_WIN_HINT_PGI        0x1A20F
+#define GL_ALLOW_DRAW_FRG_HINT_PGI        0x1A210
+#define GL_ALLOW_DRAW_MEM_HINT_PGI        0x1A211
+#define GL_STRICT_DEPTHFUNC_HINT_PGI      0x1A216
+#define GL_STRICT_LIGHTING_HINT_PGI       0x1A217
+#define GL_STRICT_SCISSOR_HINT_PGI        0x1A218
+#define GL_FULL_STIPPLE_HINT_PGI          0x1A219
+#define GL_CLIP_NEAR_HINT_PGI             0x1A220
+#define GL_CLIP_FAR_HINT_PGI              0x1A221
+#define GL_WIDE_LINE_HINT_PGI             0x1A222
+#define GL_BACK_NORMALS_HINT_PGI          0x1A223
+#endif
+
+#ifndef GL_EXT_paletted_texture
+#define GL_COLOR_INDEX1_EXT               0x80E2
+#define GL_COLOR_INDEX2_EXT               0x80E3
+#define GL_COLOR_INDEX4_EXT               0x80E4
+#define GL_COLOR_INDEX8_EXT               0x80E5
+#define GL_COLOR_INDEX12_EXT              0x80E6
+#define GL_COLOR_INDEX16_EXT              0x80E7
+#define GL_TEXTURE_INDEX_SIZE_EXT         0x80ED
+#endif
+
+#ifndef GL_EXT_clip_volume_hint
+#define GL_CLIP_VOLUME_CLIPPING_HINT_EXT  0x80F0
+#endif
+
+#ifndef GL_SGIX_list_priority
+#define GL_LIST_PRIORITY_SGIX             0x8182
+#endif
+
+#ifndef GL_SGIX_ir_instrument1
+#define GL_IR_INSTRUMENT1_SGIX            0x817F
+#endif
+
+#ifndef GL_SGIX_calligraphic_fragment
+#define GL_CALLIGRAPHIC_FRAGMENT_SGIX     0x8183
+#endif
+
+#ifndef GL_SGIX_texture_lod_bias
+#define GL_TEXTURE_LOD_BIAS_S_SGIX        0x818E
+#define GL_TEXTURE_LOD_BIAS_T_SGIX        0x818F
+#define GL_TEXTURE_LOD_BIAS_R_SGIX        0x8190
+#endif
+
+#ifndef GL_SGIX_shadow_ambient
+#define GL_SHADOW_AMBIENT_SGIX            0x80BF
+#endif
+
+#ifndef GL_EXT_index_texture
+#endif
+
+#ifndef GL_EXT_index_material
+#define GL_INDEX_MATERIAL_EXT             0x81B8
+#define GL_INDEX_MATERIAL_PARAMETER_EXT   0x81B9
+#define GL_INDEX_MATERIAL_FACE_EXT        0x81BA
+#endif
+
+#ifndef GL_EXT_index_func
+#define GL_INDEX_TEST_EXT                 0x81B5
+#define GL_INDEX_TEST_FUNC_EXT            0x81B6
+#define GL_INDEX_TEST_REF_EXT             0x81B7
+#endif
+
+#ifndef GL_EXT_index_array_formats
+#define GL_IUI_V2F_EXT                    0x81AD
+#define GL_IUI_V3F_EXT                    0x81AE
+#define GL_IUI_N3F_V2F_EXT                0x81AF
+#define GL_IUI_N3F_V3F_EXT                0x81B0
+#define GL_T2F_IUI_V2F_EXT                0x81B1
+#define GL_T2F_IUI_V3F_EXT                0x81B2
+#define GL_T2F_IUI_N3F_V2F_EXT            0x81B3
+#define GL_T2F_IUI_N3F_V3F_EXT            0x81B4
+#endif
+
+#ifndef GL_EXT_compiled_vertex_array
+#define GL_ARRAY_ELEMENT_LOCK_FIRST_EXT   0x81A8
+#define GL_ARRAY_ELEMENT_LOCK_COUNT_EXT   0x81A9
+#endif
+
+#ifndef GL_EXT_cull_vertex
+#define GL_CULL_VERTEX_EXT                0x81AA
+#define GL_CULL_VERTEX_EYE_POSITION_EXT   0x81AB
+#define GL_CULL_VERTEX_OBJECT_POSITION_EXT 0x81AC
+#endif
+
+#ifndef GL_SGIX_ycrcb
+#define GL_YCRCB_422_SGIX                 0x81BB
+#define GL_YCRCB_444_SGIX                 0x81BC
+#endif
+
+#ifndef GL_SGIX_fragment_lighting
+#define GL_FRAGMENT_LIGHTING_SGIX         0x8400
+#define GL_FRAGMENT_COLOR_MATERIAL_SGIX   0x8401
+#define GL_FRAGMENT_COLOR_MATERIAL_FACE_SGIX 0x8402
+#define GL_FRAGMENT_COLOR_MATERIAL_PARAMETER_SGIX 0x8403
+#define GL_MAX_FRAGMENT_LIGHTS_SGIX       0x8404
+#define GL_MAX_ACTIVE_LIGHTS_SGIX         0x8405
+#define GL_CURRENT_RASTER_NORMAL_SGIX     0x8406
+#define GL_LIGHT_ENV_MODE_SGIX            0x8407
+#define GL_FRAGMENT_LIGHT_MODEL_LOCAL_VIEWER_SGIX 0x8408
+#define GL_FRAGMENT_LIGHT_MODEL_TWO_SIDE_SGIX 0x8409
+#define GL_FRAGMENT_LIGHT_MODEL_AMBIENT_SGIX 0x840A
+#define GL_FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION_SGIX 0x840B
+#define GL_FRAGMENT_LIGHT0_SGIX           0x840C
+#define GL_FRAGMENT_LIGHT1_SGIX           0x840D
+#define GL_FRAGMENT_LIGHT2_SGIX           0x840E
+#define GL_FRAGMENT_LIGHT3_SGIX           0x840F
+#define GL_FRAGMENT_LIGHT4_SGIX           0x8410
+#define GL_FRAGMENT_LIGHT5_SGIX           0x8411
+#define GL_FRAGMENT_LIGHT6_SGIX           0x8412
+#define GL_FRAGMENT_LIGHT7_SGIX           0x8413
+#endif
+
+#ifndef GL_IBM_rasterpos_clip
+#define GL_RASTER_POSITION_UNCLIPPED_IBM  0x19262
+#endif
+
+#ifndef GL_HP_texture_lighting
+#define GL_TEXTURE_LIGHTING_MODE_HP       0x8167
+#define GL_TEXTURE_POST_SPECULAR_HP       0x8168
+#define GL_TEXTURE_PRE_SPECULAR_HP        0x8169
+#endif
+
+#ifndef GL_EXT_draw_range_elements
+#define GL_MAX_ELEMENTS_VERTICES_EXT      0x80E8
+#define GL_MAX_ELEMENTS_INDICES_EXT       0x80E9
+#endif
+
+#ifndef GL_WIN_phong_shading
+#define GL_PHONG_WIN                      0x80EA
+#define GL_PHONG_HINT_WIN                 0x80EB
+#endif
+
+#ifndef GL_WIN_specular_fog
+#define GL_FOG_SPECULAR_TEXTURE_WIN       0x80EC
+#endif
+
+#ifndef GL_EXT_light_texture
+#define GL_FRAGMENT_MATERIAL_EXT          0x8349
+#define GL_FRAGMENT_NORMAL_EXT            0x834A
+#define GL_FRAGMENT_COLOR_EXT             0x834C
+#define GL_ATTENUATION_EXT                0x834D
+#define GL_SHADOW_ATTENUATION_EXT         0x834E
+#define GL_TEXTURE_APPLICATION_MODE_EXT   0x834F
+#define GL_TEXTURE_LIGHT_EXT              0x8350
+#define GL_TEXTURE_MATERIAL_FACE_EXT      0x8351
+#define GL_TEXTURE_MATERIAL_PARAMETER_EXT 0x8352
+/* reuse GL_FRAGMENT_DEPTH_EXT */
+#endif
+
+#ifndef GL_SGIX_blend_alpha_minmax
+#define GL_ALPHA_MIN_SGIX                 0x8320
+#define GL_ALPHA_MAX_SGIX                 0x8321
+#endif
+
+#ifndef GL_EXT_bgra
+#define GL_BGR_EXT                        0x80E0
+#define GL_BGRA_EXT                       0x80E1
+#endif
+
+#ifndef GL_INTEL_texture_scissor
+#endif
+
+#ifndef GL_INTEL_parallel_arrays
+#define GL_PARALLEL_ARRAYS_INTEL          0x83F4
+#define GL_VERTEX_ARRAY_PARALLEL_POINTERS_INTEL 0x83F5
+#define GL_NORMAL_ARRAY_PARALLEL_POINTERS_INTEL 0x83F6
+#define GL_COLOR_ARRAY_PARALLEL_POINTERS_INTEL 0x83F7
+#define GL_TEXTURE_COORD_ARRAY_PARALLEL_POINTERS_INTEL 0x83F8
+#endif
+
+#ifndef GL_HP_occlusion_test
+#define GL_OCCLUSION_TEST_HP              0x8165
+#define GL_OCCLUSION_TEST_RESULT_HP       0x8166
+#endif
+
+#ifndef GL_EXT_pixel_transform
+#define GL_PIXEL_TRANSFORM_2D_EXT         0x8330
+#define GL_PIXEL_MAG_FILTER_EXT           0x8331
+#define GL_PIXEL_MIN_FILTER_EXT           0x8332
+#define GL_PIXEL_CUBIC_WEIGHT_EXT         0x8333
+#define GL_CUBIC_EXT                      0x8334
+#define GL_AVERAGE_EXT                    0x8335
+#define GL_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT 0x8336
+#define GL_MAX_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT 0x8337
+#define GL_PIXEL_TRANSFORM_2D_MATRIX_EXT  0x8338
+#endif
+
+#ifndef GL_EXT_pixel_transform_color_table
+#endif
+
+#ifndef GL_EXT_shared_texture_palette
+#define GL_SHARED_TEXTURE_PALETTE_EXT     0x81FB
+#endif
+
+#ifndef GL_EXT_separate_specular_color
+#define GL_LIGHT_MODEL_COLOR_CONTROL_EXT  0x81F8
+#define GL_SINGLE_COLOR_EXT               0x81F9
+#define GL_SEPARATE_SPECULAR_COLOR_EXT    0x81FA
+#endif
+
+#ifndef GL_EXT_secondary_color
+#define GL_COLOR_SUM_EXT                  0x8458
+#define GL_CURRENT_SECONDARY_COLOR_EXT    0x8459
+#define GL_SECONDARY_COLOR_ARRAY_SIZE_EXT 0x845A
+#define GL_SECONDARY_COLOR_ARRAY_TYPE_EXT 0x845B
+#define GL_SECONDARY_COLOR_ARRAY_STRIDE_EXT 0x845C
+#define GL_SECONDARY_COLOR_ARRAY_POINTER_EXT 0x845D
+#define GL_SECONDARY_COLOR_ARRAY_EXT      0x845E
+#endif
+
+#ifndef GL_EXT_texture_perturb_normal
+#define GL_PERTURB_EXT                    0x85AE
+#define GL_TEXTURE_NORMAL_EXT             0x85AF
+#endif
+
+#ifndef GL_EXT_multi_draw_arrays
+#endif
+
+#ifndef GL_EXT_fog_coord
+#define GL_FOG_COORDINATE_SOURCE_EXT      0x8450
+#define GL_FOG_COORDINATE_EXT             0x8451
+#define GL_FRAGMENT_DEPTH_EXT             0x8452
+#define GL_CURRENT_FOG_COORDINATE_EXT     0x8453
+#define GL_FOG_COORDINATE_ARRAY_TYPE_EXT  0x8454
+#define GL_FOG_COORDINATE_ARRAY_STRIDE_EXT 0x8455
+#define GL_FOG_COORDINATE_ARRAY_POINTER_EXT 0x8456
+#define GL_FOG_COORDINATE_ARRAY_EXT       0x8457
+#endif
+
+#ifndef GL_REND_screen_coordinates
+#define GL_SCREEN_COORDINATES_REND        0x8490
+#define GL_INVERTED_SCREEN_W_REND         0x8491
+#endif
+
+#ifndef GL_EXT_coordinate_frame
+#define GL_TANGENT_ARRAY_EXT              0x8439
+#define GL_BINORMAL_ARRAY_EXT             0x843A
+#define GL_CURRENT_TANGENT_EXT            0x843B
+#define GL_CURRENT_BINORMAL_EXT           0x843C
+#define GL_TANGENT_ARRAY_TYPE_EXT         0x843E
+#define GL_TANGENT_ARRAY_STRIDE_EXT       0x843F
+#define GL_BINORMAL_ARRAY_TYPE_EXT        0x8440
+#define GL_BINORMAL_ARRAY_STRIDE_EXT      0x8441
+#define GL_TANGENT_ARRAY_POINTER_EXT      0x8442
+#define GL_BINORMAL_ARRAY_POINTER_EXT     0x8443
+#define GL_MAP1_TANGENT_EXT               0x8444
+#define GL_MAP2_TANGENT_EXT               0x8445
+#define GL_MAP1_BINORMAL_EXT              0x8446
+#define GL_MAP2_BINORMAL_EXT              0x8447
+#endif
+
+#ifndef GL_EXT_texture_env_combine
+#define GL_COMBINE_EXT                    0x8570
+#define GL_COMBINE_RGB_EXT                0x8571
+#define GL_COMBINE_ALPHA_EXT              0x8572
+#define GL_RGB_SCALE_EXT                  0x8573
+#define GL_ADD_SIGNED_EXT                 0x8574
+#define GL_INTERPOLATE_EXT                0x8575
+#define GL_CONSTANT_EXT                   0x8576
+#define GL_PRIMARY_COLOR_EXT              0x8577
+#define GL_PREVIOUS_EXT                   0x8578
+#define GL_SOURCE0_RGB_EXT                0x8580
+#define GL_SOURCE1_RGB_EXT                0x8581
+#define GL_SOURCE2_RGB_EXT                0x8582
+#define GL_SOURCE3_RGB_EXT                0x8583
+#define GL_SOURCE4_RGB_EXT                0x8584
+#define GL_SOURCE5_RGB_EXT                0x8585
+#define GL_SOURCE6_RGB_EXT                0x8586
+#define GL_SOURCE7_RGB_EXT                0x8587
+#define GL_SOURCE0_ALPHA_EXT              0x8588
+#define GL_SOURCE1_ALPHA_EXT              0x8589
+#define GL_SOURCE2_ALPHA_EXT              0x858A
+#define GL_SOURCE3_ALPHA_EXT              0x858B
+#define GL_SOURCE4_ALPHA_EXT              0x858C
+#define GL_SOURCE5_ALPHA_EXT              0x858D
+#define GL_SOURCE6_ALPHA_EXT              0x858E
+#define GL_SOURCE7_ALPHA_EXT              0x858F
+#define GL_OPERAND0_RGB_EXT               0x8590
+#define GL_OPERAND1_RGB_EXT               0x8591
+#define GL_OPERAND2_RGB_EXT               0x8592
+#define GL_OPERAND3_RGB_EXT               0x8593
+#define GL_OPERAND4_RGB_EXT               0x8594
+#define GL_OPERAND5_RGB_EXT               0x8595
+#define GL_OPERAND6_RGB_EXT               0x8596
+#define GL_OPERAND7_RGB_EXT               0x8597
+#define GL_OPERAND0_ALPHA_EXT             0x8598
+#define GL_OPERAND1_ALPHA_EXT             0x8599
+#define GL_OPERAND2_ALPHA_EXT             0x859A
+#define GL_OPERAND3_ALPHA_EXT             0x859B
+#define GL_OPERAND4_ALPHA_EXT             0x859C
+#define GL_OPERAND5_ALPHA_EXT             0x859D
+#define GL_OPERAND6_ALPHA_EXT             0x859E
+#define GL_OPERAND7_ALPHA_EXT             0x859F
+#endif
+
+#ifndef GL_APPLE_specular_vector
+#define GL_LIGHT_MODEL_SPECULAR_VECTOR_APPLE 0x85B0
+#endif
+
+#ifndef GL_APPLE_transform_hint
+#define GL_TRANSFORM_HINT_APPLE           0x85B1
+#endif
+
+#ifndef GL_SGIX_fog_scale
+#define GL_FOG_SCALE_SGIX                 0x81FC
+#define GL_FOG_SCALE_VALUE_SGIX           0x81FD
+#endif
+
+#ifndef GL_SUNX_constant_data
+#define GL_UNPACK_CONSTANT_DATA_SUNX      0x81D5
+#define GL_TEXTURE_CONSTANT_DATA_SUNX     0x81D6
+#endif
+
+#ifndef GL_SUN_global_alpha
+#define GL_GLOBAL_ALPHA_SUN               0x81D9
+#define GL_GLOBAL_ALPHA_FACTOR_SUN        0x81DA
+#endif
+
+#ifndef GL_SUN_triangle_list
+#define GL_RESTART_SUN                    0x01
+#define GL_REPLACE_MIDDLE_SUN             0x02
+#define GL_REPLACE_OLDEST_SUN             0x03
+#define GL_TRIANGLE_LIST_SUN              0x81D7
+#define GL_REPLACEMENT_CODE_SUN           0x81D8
+#define GL_REPLACEMENT_CODE_ARRAY_SUN     0x85C0
+#define GL_REPLACEMENT_CODE_ARRAY_TYPE_SUN 0x85C1
+#define GL_REPLACEMENT_CODE_ARRAY_STRIDE_SUN 0x85C2
+#define GL_REPLACEMENT_CODE_ARRAY_POINTER_SUN 0x85C3
+#define GL_R1UI_V3F_SUN                   0x85C4
+#define GL_R1UI_C4UB_V3F_SUN              0x85C5
+#define GL_R1UI_C3F_V3F_SUN               0x85C6
+#define GL_R1UI_N3F_V3F_SUN               0x85C7
+#define GL_R1UI_C4F_N3F_V3F_SUN           0x85C8
+#define GL_R1UI_T2F_V3F_SUN               0x85C9
+#define GL_R1UI_T2F_N3F_V3F_SUN           0x85CA
+#define GL_R1UI_T2F_C4F_N3F_V3F_SUN       0x85CB
+#endif
+
+#ifndef GL_SUN_vertex
+#endif
+
+#ifndef GL_EXT_blend_func_separate
+#define GL_BLEND_DST_RGB_EXT              0x80C8
+#define GL_BLEND_SRC_RGB_EXT              0x80C9
+#define GL_BLEND_DST_ALPHA_EXT            0x80CA
+#define GL_BLEND_SRC_ALPHA_EXT            0x80CB
+#endif
+
+#ifndef GL_INGR_color_clamp
+#define GL_RED_MIN_CLAMP_INGR             0x8560
+#define GL_GREEN_MIN_CLAMP_INGR           0x8561
+#define GL_BLUE_MIN_CLAMP_INGR            0x8562
+#define GL_ALPHA_MIN_CLAMP_INGR           0x8563
+#define GL_RED_MAX_CLAMP_INGR             0x8564
+#define GL_GREEN_MAX_CLAMP_INGR           0x8565
+#define GL_BLUE_MAX_CLAMP_INGR            0x8566
+#define GL_ALPHA_MAX_CLAMP_INGR           0x8567
+#endif
+
+#ifndef GL_INGR_interlace_read
+#define GL_INTERLACE_READ_INGR            0x8568
+#endif
+
+#ifndef GL_EXT_stencil_wrap
+#define GL_INCR_WRAP_EXT                  0x8507
+#define GL_DECR_WRAP_EXT                  0x8508
+#endif
+
+#ifndef GL_EXT_422_pixels
+#define GL_422_EXT                        0x80CC
+#define GL_422_REV_EXT                    0x80CD
+#define GL_422_AVERAGE_EXT                0x80CE
+#define GL_422_REV_AVERAGE_EXT            0x80CF
+#endif
+
+#ifndef GL_NV_texgen_reflection
+#define GL_NORMAL_MAP_NV                  0x8511
+#define GL_REFLECTION_MAP_NV              0x8512
+#endif
+
+#ifndef GL_EXT_texture_cube_map
+#define GL_NORMAL_MAP_EXT                 0x8511
+#define GL_REFLECTION_MAP_EXT             0x8512
+#define GL_TEXTURE_CUBE_MAP_EXT           0x8513
+#define GL_TEXTURE_BINDING_CUBE_MAP_EXT   0x8514
+#define GL_TEXTURE_CUBE_MAP_POSITIVE_X_EXT 0x8515
+#define GL_TEXTURE_CUBE_MAP_NEGATIVE_X_EXT 0x8516
+#define GL_TEXTURE_CUBE_MAP_POSITIVE_Y_EXT 0x8517
+#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_EXT 0x8518
+#define GL_TEXTURE_CUBE_MAP_POSITIVE_Z_EXT 0x8519
+#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_EXT 0x851A
+#define GL_PROXY_TEXTURE_CUBE_MAP_EXT     0x851B
+#define GL_MAX_CUBE_MAP_TEXTURE_SIZE_EXT  0x851C
+#endif
+
+#ifndef GL_SUN_convolution_border_modes
+#define GL_WRAP_BORDER_SUN                0x81D4
+#endif
+
+#ifndef GL_EXT_texture_env_add
+#endif
+
+#ifndef GL_EXT_texture_lod_bias
+#define GL_MAX_TEXTURE_LOD_BIAS_EXT       0x84FD
+#define GL_TEXTURE_FILTER_CONTROL_EXT     0x8500
+#define GL_TEXTURE_LOD_BIAS_EXT           0x8501
+#endif
+
+#ifndef GL_EXT_texture_filter_anisotropic
+#define GL_TEXTURE_MAX_ANISOTROPY_EXT     0x84FE
+#define GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT 0x84FF
+#endif
+
+#ifndef GL_EXT_vertex_weighting
+#define GL_MODELVIEW0_STACK_DEPTH_EXT     GL_MODELVIEW_STACK_DEPTH
+#define GL_MODELVIEW1_STACK_DEPTH_EXT     0x8502
+#define GL_MODELVIEW0_MATRIX_EXT          GL_MODELVIEW_MATRIX
+#define GL_MODELVIEW_MATRIX1_EXT          0x8506
+#define GL_VERTEX_WEIGHTING_EXT           0x8509
+#define GL_MODELVIEW0_EXT                 GL_MODELVIEW
+#define GL_MODELVIEW1_EXT                 0x850A
+#define GL_CURRENT_VERTEX_WEIGHT_EXT      0x850B
+#define GL_VERTEX_WEIGHT_ARRAY_EXT        0x850C
+#define GL_VERTEX_WEIGHT_ARRAY_SIZE_EXT   0x850D
+#define GL_VERTEX_WEIGHT_ARRAY_TYPE_EXT   0x850E
+#define GL_VERTEX_WEIGHT_ARRAY_STRIDE_EXT 0x850F
+#define GL_VERTEX_WEIGHT_ARRAY_POINTER_EXT 0x8510
+#endif
+
+#ifndef GL_NV_light_max_exponent
+#define GL_MAX_SHININESS_NV               0x8504
+#define GL_MAX_SPOT_EXPONENT_NV           0x8505
+#endif
+
+#ifndef GL_NV_vertex_array_range
+#define GL_VERTEX_ARRAY_RANGE_NV          0x851D
+#define GL_VERTEX_ARRAY_RANGE_LENGTH_NV   0x851E
+#define GL_VERTEX_ARRAY_RANGE_VALID_NV    0x851F
+#define GL_MAX_VERTEX_ARRAY_RANGE_ELEMENT_NV 0x8520
+#define GL_VERTEX_ARRAY_RANGE_POINTER_NV  0x8521
+#endif
+
+#ifndef GL_NV_register_combiners
+#define GL_REGISTER_COMBINERS_NV          0x8522
+#define GL_VARIABLE_A_NV                  0x8523
+#define GL_VARIABLE_B_NV                  0x8524
+#define GL_VARIABLE_C_NV                  0x8525
+#define GL_VARIABLE_D_NV                  0x8526
+#define GL_VARIABLE_E_NV                  0x8527
+#define GL_VARIABLE_F_NV                  0x8528
+#define GL_VARIABLE_G_NV                  0x8529
+#define GL_CONSTANT_COLOR0_NV             0x852A
+#define GL_CONSTANT_COLOR1_NV             0x852B
+#define GL_PRIMARY_COLOR_NV               0x852C
+#define GL_SECONDARY_COLOR_NV             0x852D
+#define GL_SPARE0_NV                      0x852E
+#define GL_SPARE1_NV                      0x852F
+#define GL_DISCARD_NV                     0x8530
+#define GL_E_TIMES_F_NV                   0x8531
+#define GL_SPARE0_PLUS_SECONDARY_COLOR_NV 0x8532
+#define GL_UNSIGNED_IDENTITY_NV           0x8536
+#define GL_UNSIGNED_INVERT_NV             0x8537
+#define GL_EXPAND_NORMAL_NV               0x8538
+#define GL_EXPAND_NEGATE_NV               0x8539
+#define GL_HALF_BIAS_NORMAL_NV            0x853A
+#define GL_HALF_BIAS_NEGATE_NV            0x853B
+#define GL_SIGNED_IDENTITY_NV             0x853C
+#define GL_SIGNED_NEGATE_NV               0x853D
+#define GL_SCALE_BY_TWO_NV                0x853E
+#define GL_SCALE_BY_FOUR_NV               0x853F
+#define GL_SCALE_BY_ONE_HALF_NV           0x8540
+#define GL_BIAS_BY_NEGATIVE_ONE_HALF_NV   0x8541
+#define GL_COMBINER_INPUT_NV              0x8542
+#define GL_COMBINER_MAPPING_NV            0x8543
+#define GL_COMBINER_COMPONENT_USAGE_NV    0x8544
+#define GL_COMBINER_AB_DOT_PRODUCT_NV     0x8545
+#define GL_COMBINER_CD_DOT_PRODUCT_NV     0x8546
+#define GL_COMBINER_MUX_SUM_NV            0x8547
+#define GL_COMBINER_SCALE_NV              0x8548
+#define GL_COMBINER_BIAS_NV               0x8549
+#define GL_COMBINER_AB_OUTPUT_NV          0x854A
+#define GL_COMBINER_CD_OUTPUT_NV          0x854B
+#define GL_COMBINER_SUM_OUTPUT_NV         0x854C
+#define GL_MAX_GENERAL_COMBINERS_NV       0x854D
+#define GL_NUM_GENERAL_COMBINERS_NV       0x854E
+#define GL_COLOR_SUM_CLAMP_NV             0x854F
+#define GL_COMBINER0_NV                   0x8550
+#define GL_COMBINER1_NV                   0x8551
+#define GL_COMBINER2_NV                   0x8552
+#define GL_COMBINER3_NV                   0x8553
+#define GL_COMBINER4_NV                   0x8554
+#define GL_COMBINER5_NV                   0x8555
+#define GL_COMBINER6_NV                   0x8556
+#define GL_COMBINER7_NV                   0x8557
+/* reuse GL_TEXTURE0_ARB */
+/* reuse GL_TEXTURE1_ARB */
+/* reuse GL_ZERO */
+/* reuse GL_NONE */
+/* reuse GL_FOG */
+#endif
+
+#ifndef GL_NV_fog_distance
+#define GL_FOG_DISTANCE_MODE_NV           0x855A
+#define GL_EYE_RADIAL_NV                  0x855B
+#define GL_EYE_PLANE_ABSOLUTE_NV          0x855C
+/* reuse GL_EYE_PLANE */
+#endif
+
+#ifndef GL_NV_texgen_emboss
+#define GL_EMBOSS_LIGHT_NV                0x855D
+#define GL_EMBOSS_CONSTANT_NV             0x855E
+#define GL_EMBOSS_MAP_NV                  0x855F
+#endif
+
+#ifndef GL_NV_blend_square
+#endif
+
+#ifndef GL_NV_texture_env_combine4
+#define GL_COMBINE4_NV                    0x8503
+#define GL_SOURCE3_RGB_NV                 0x8583
+#define GL_SOURCE3_ALPHA_NV               0x858B
+#define GL_OPERAND3_RGB_NV                0x8593
+#define GL_OPERAND3_ALPHA_NV              0x859B
+#endif
+
+#ifndef GL_MESA_resize_buffers
+#endif
+
+#ifndef GL_MESA_window_pos
+#endif
+
+#ifndef GL_EXT_texture_compression_s3tc
+#define GL_COMPRESSED_RGB_S3TC_DXT1_EXT   0x83F0
+#define GL_COMPRESSED_RGBA_S3TC_DXT1_EXT  0x83F1
+#define GL_COMPRESSED_RGBA_S3TC_DXT3_EXT  0x83F2
+#define GL_COMPRESSED_RGBA_S3TC_DXT5_EXT  0x83F3
+#endif
+
+#ifndef GL_IBM_cull_vertex
+#define GL_CULL_VERTEX_IBM                103050
+#endif
+
+#ifndef GL_IBM_multimode_draw_arrays
+#endif
+
+#ifndef GL_IBM_vertex_array_lists
+#define GL_VERTEX_ARRAY_LIST_IBM          103070
+#define GL_NORMAL_ARRAY_LIST_IBM          103071
+#define GL_COLOR_ARRAY_LIST_IBM           103072
+#define GL_INDEX_ARRAY_LIST_IBM           103073
+#define GL_TEXTURE_COORD_ARRAY_LIST_IBM   103074
+#define GL_EDGE_FLAG_ARRAY_LIST_IBM       103075
+#define GL_FOG_COORDINATE_ARRAY_LIST_IBM  103076
+#define GL_SECONDARY_COLOR_ARRAY_LIST_IBM 103077
+#define GL_VERTEX_ARRAY_LIST_STRIDE_IBM   103080
+#define GL_NORMAL_ARRAY_LIST_STRIDE_IBM   103081
+#define GL_COLOR_ARRAY_LIST_STRIDE_IBM    103082
+#define GL_INDEX_ARRAY_LIST_STRIDE_IBM    103083
+#define GL_TEXTURE_COORD_ARRAY_LIST_STRIDE_IBM 103084
+#define GL_EDGE_FLAG_ARRAY_LIST_STRIDE_IBM 103085
+#define GL_FOG_COORDINATE_ARRAY_LIST_STRIDE_IBM 103086
+#define GL_SECONDARY_COLOR_ARRAY_LIST_STRIDE_IBM 103087
+#endif
+
+#ifndef GL_SGIX_subsample
+#define GL_PACK_SUBSAMPLE_RATE_SGIX       0x85A0
+#define GL_UNPACK_SUBSAMPLE_RATE_SGIX     0x85A1
+#define GL_PIXEL_SUBSAMPLE_4444_SGIX      0x85A2
+#define GL_PIXEL_SUBSAMPLE_2424_SGIX      0x85A3
+#define GL_PIXEL_SUBSAMPLE_4242_SGIX      0x85A4
+#endif
+
+#ifndef GL_SGIX_ycrcb_subsample
+#endif
+
+#ifndef GL_SGIX_ycrcba
+#define GL_YCRCB_SGIX                     0x8318
+#define GL_YCRCBA_SGIX                    0x8319
+#endif
+
+#ifndef GL_SGI_depth_pass_instrument
+#define GL_DEPTH_PASS_INSTRUMENT_SGIX     0x8310
+#define GL_DEPTH_PASS_INSTRUMENT_COUNTERS_SGIX 0x8311
+#define GL_DEPTH_PASS_INSTRUMENT_MAX_SGIX 0x8312
+#endif
+
+#ifndef GL_3DFX_texture_compression_FXT1
+#define GL_COMPRESSED_RGB_FXT1_3DFX       0x86B0
+#define GL_COMPRESSED_RGBA_FXT1_3DFX      0x86B1
+#endif
+
+#ifndef GL_3DFX_multisample
+#define GL_MULTISAMPLE_3DFX               0x86B2
+#define GL_SAMPLE_BUFFERS_3DFX            0x86B3
+#define GL_SAMPLES_3DFX                   0x86B4
+#define GL_MULTISAMPLE_BIT_3DFX           0x20000000
+#endif
+
+#ifndef GL_3DFX_tbuffer
+#endif
+
+#ifndef GL_EXT_multisample
+#define GL_MULTISAMPLE_EXT                0x809D
+#define GL_SAMPLE_ALPHA_TO_MASK_EXT       0x809E
+#define GL_SAMPLE_ALPHA_TO_ONE_EXT        0x809F
+#define GL_SAMPLE_MASK_EXT                0x80A0
+#define GL_1PASS_EXT                      0x80A1
+#define GL_2PASS_0_EXT                    0x80A2
+#define GL_2PASS_1_EXT                    0x80A3
+#define GL_4PASS_0_EXT                    0x80A4
+#define GL_4PASS_1_EXT                    0x80A5
+#define GL_4PASS_2_EXT                    0x80A6
+#define GL_4PASS_3_EXT                    0x80A7
+#define GL_SAMPLE_BUFFERS_EXT             0x80A8
+#define GL_SAMPLES_EXT                    0x80A9
+#define GL_SAMPLE_MASK_VALUE_EXT          0x80AA
+#define GL_SAMPLE_MASK_INVERT_EXT         0x80AB
+#define GL_SAMPLE_PATTERN_EXT             0x80AC
+#endif
+
+#ifndef GL_SGIX_vertex_preclip
+#define GL_VERTEX_PRECLIP_SGIX            0x83EE
+#define GL_VERTEX_PRECLIP_HINT_SGIX       0x83EF
+#endif
+
+#ifndef GL_SGIX_convolution_accuracy
+#define GL_CONVOLUTION_HINT_SGIX          0x8316
+#endif
+
+#ifndef GL_SGIX_resample
+#define GL_PACK_RESAMPLE_SGIX             0x842C
+#define GL_UNPACK_RESAMPLE_SGIX           0x842D
+#define GL_RESAMPLE_REPLICATE_SGIX        0x842E
+#define GL_RESAMPLE_ZERO_FILL_SGIX        0x842F
+#define GL_RESAMPLE_DECIMATE_SGIX         0x8430
+#endif
+
+#ifndef GL_SGIS_point_line_texgen
+#define GL_EYE_DISTANCE_TO_POINT_SGIS     0x81F0
+#define GL_OBJECT_DISTANCE_TO_POINT_SGIS  0x81F1
+#define GL_EYE_DISTANCE_TO_LINE_SGIS      0x81F2
+#define GL_OBJECT_DISTANCE_TO_LINE_SGIS   0x81F3
+#define GL_EYE_POINT_SGIS                 0x81F4
+#define GL_OBJECT_POINT_SGIS              0x81F5
+#define GL_EYE_LINE_SGIS                  0x81F6
+#define GL_OBJECT_LINE_SGIS               0x81F7
+#endif
+
+#ifndef GL_SGIS_texture_color_mask
+#define GL_TEXTURE_COLOR_WRITEMASK_SGIS   0x81EF
+#endif
+
+/* NV_point_sprite */
+#define GL_POINT_SPRITE_NV                0x8861
+#define GL_COORD_REPLACE_NV               0x8862
+#define GL_POINT_SPRITE_R_MODE_NV         0x8863
+#define GL_NV_point_sprite                1
+
+/*************************************************************/
+
+#ifndef GL_VERSION_1_2
+#define GL_VERSION_1_2 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glBlendColor (GLclampf, GLclampf, GLclampf, GLclampf);
+extern void APIENTRY glBlendEquation (GLenum);
+extern void APIENTRY glDrawRangeElements (GLenum, GLuint, GLuint, GLsizei, GLenum, const GLvoid *);
+extern void APIENTRY glColorTable (GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *);
+extern void APIENTRY glColorTableParameterfv (GLenum, GLenum, const GLfloat *);
+extern void APIENTRY glColorTableParameteriv (GLenum, GLenum, const GLint *);
+extern void APIENTRY glCopyColorTable (GLenum, GLenum, GLint, GLint, GLsizei);
+extern void APIENTRY glGetColorTable (GLenum, GLenum, GLenum, GLvoid *);
+extern void APIENTRY glGetColorTableParameterfv (GLenum, GLenum, GLfloat *);
+extern void APIENTRY glGetColorTableParameteriv (GLenum, GLenum, GLint *);
+extern void APIENTRY glColorSubTable (GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *);
+extern void APIENTRY glCopyColorSubTable (GLenum, GLsizei, GLint, GLint, GLsizei);
+extern void APIENTRY glConvolutionFilter1D (GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *);
+extern void APIENTRY glConvolutionFilter2D (GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *);
+extern void APIENTRY glConvolutionParameterf (GLenum, GLenum, GLfloat);
+extern void APIENTRY glConvolutionParameterfv (GLenum, GLenum, const GLfloat *);
+extern void APIENTRY glConvolutionParameteri (GLenum, GLenum, GLint);
+extern void APIENTRY glConvolutionParameteriv (GLenum, GLenum, const GLint *);
+extern void APIENTRY glCopyConvolutionFilter1D (GLenum, GLenum, GLint, GLint, GLsizei);
+extern void APIENTRY glCopyConvolutionFilter2D (GLenum, GLenum, GLint, GLint, GLsizei, GLsizei);
+extern void APIENTRY glGetConvolutionFilter (GLenum, GLenum, GLenum, GLvoid *);
+extern void APIENTRY glGetConvolutionParameterfv (GLenum, GLenum, GLfloat *);
+extern void APIENTRY glGetConvolutionParameteriv (GLenum, GLenum, GLint *);
+extern void APIENTRY glGetSeparableFilter (GLenum, GLenum, GLenum, GLvoid *, GLvoid *, GLvoid *);
+extern void APIENTRY glSeparableFilter2D (GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *, const GLvoid *);
+extern void APIENTRY glGetHistogram (GLenum, GLboolean, GLenum, GLenum, GLvoid *);
+extern void APIENTRY glGetHistogramParameterfv (GLenum, GLenum, GLfloat *);
+extern void APIENTRY glGetHistogramParameteriv (GLenum, GLenum, GLint *);
+extern void APIENTRY glGetMinmax (GLenum, GLboolean, GLenum, GLenum, GLvoid *);
+extern void APIENTRY glGetMinmaxParameterfv (GLenum, GLenum, GLfloat *);
+extern void APIENTRY glGetMinmaxParameteriv (GLenum, GLenum, GLint *);
+extern void APIENTRY glHistogram (GLenum, GLsizei, GLenum, GLboolean);
+extern void APIENTRY glMinmax (GLenum, GLenum, GLboolean);
+extern void APIENTRY glResetHistogram (GLenum);
+extern void APIENTRY glResetMinmax (GLenum);
+extern void APIENTRY glTexImage3D (GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *);
+extern void APIENTRY glTexSubImage3D (GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *);
+extern void APIENTRY glCopyTexSubImage3D (GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLBLENDCOLORPROC) (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
+typedef void (APIENTRY * PFNGLBLENDEQUATIONPROC) (GLenum mode);
+typedef void (APIENTRY * PFNGLDRAWRANGEELEMENTSPROC) (GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices);
+typedef void (APIENTRY * PFNGLCOLORTABLEPROC) (GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table);
+typedef void (APIENTRY * PFNGLCOLORTABLEPARAMETERFVPROC) (GLenum target, GLenum pname, const GLfloat *params);
+typedef void (APIENTRY * PFNGLCOLORTABLEPARAMETERIVPROC) (GLenum target, GLenum pname, const GLint *params);
+typedef void (APIENTRY * PFNGLCOPYCOLORTABLEPROC) (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width);
+typedef void (APIENTRY * PFNGLGETCOLORTABLEPROC) (GLenum target, GLenum format, GLenum type, GLvoid *table);
+typedef void (APIENTRY * PFNGLGETCOLORTABLEPARAMETERFVPROC) (GLenum target, GLenum pname, GLfloat *params);
+typedef void (APIENTRY * PFNGLGETCOLORTABLEPARAMETERIVPROC) (GLenum target, GLenum pname, GLint *params);
+typedef void (APIENTRY * PFNGLCOLORSUBTABLEPROC) (GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data);
+typedef void (APIENTRY * PFNGLCOPYCOLORSUBTABLEPROC) (GLenum target, GLsizei start, GLint x, GLint y, GLsizei width);
+typedef void (APIENTRY * PFNGLCONVOLUTIONFILTER1DPROC) (GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *image);
+typedef void (APIENTRY * PFNGLCONVOLUTIONFILTER2DPROC) (GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image);
+typedef void (APIENTRY * PFNGLCONVOLUTIONPARAMETERFPROC) (GLenum target, GLenum pname, GLfloat params);
+typedef void (APIENTRY * PFNGLCONVOLUTIONPARAMETERFVPROC) (GLenum target, GLenum pname, const GLfloat *params);
+typedef void (APIENTRY * PFNGLCONVOLUTIONPARAMETERIPROC) (GLenum target, GLenum pname, GLint params);
+typedef void (APIENTRY * PFNGLCONVOLUTIONPARAMETERIVPROC) (GLenum target, GLenum pname, const GLint *params);
+typedef void (APIENTRY * PFNGLCOPYCONVOLUTIONFILTER1DPROC) (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width);
+typedef void (APIENTRY * PFNGLCOPYCONVOLUTIONFILTER2DPROC) (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height);
+typedef void (APIENTRY * PFNGLGETCONVOLUTIONFILTERPROC) (GLenum target, GLenum format, GLenum type, GLvoid *image);
+typedef void (APIENTRY * PFNGLGETCONVOLUTIONPARAMETERFVPROC) (GLenum target, GLenum pname, GLfloat *params);
+typedef void (APIENTRY * PFNGLGETCONVOLUTIONPARAMETERIVPROC) (GLenum target, GLenum pname, GLint *params);
+typedef void (APIENTRY * PFNGLGETSEPARABLEFILTERPROC) (GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span);
+typedef void (APIENTRY * PFNGLSEPARABLEFILTER2DPROC) (GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column);
+typedef void (APIENTRY * PFNGLGETHISTOGRAMPROC) (GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values);
+typedef void (APIENTRY * PFNGLGETHISTOGRAMPARAMETERFVPROC) (GLenum target, GLenum pname, GLfloat *params);
+typedef void (APIENTRY * PFNGLGETHISTOGRAMPARAMETERIVPROC) (GLenum target, GLenum pname, GLint *params);
+typedef void (APIENTRY * PFNGLGETMINMAXPROC) (GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values);
+typedef void (APIENTRY * PFNGLGETMINMAXPARAMETERFVPROC) (GLenum target, GLenum pname, GLfloat *params);
+typedef void (APIENTRY * PFNGLGETMINMAXPARAMETERIVPROC) (GLenum target, GLenum pname, GLint *params);
+typedef void (APIENTRY * PFNGLHISTOGRAMPROC) (GLenum target, GLsizei width, GLenum internalformat, GLboolean sink);
+typedef void (APIENTRY * PFNGLMINMAXPROC) (GLenum target, GLenum internalformat, GLboolean sink);
+typedef void (APIENTRY * PFNGLRESETHISTOGRAMPROC) (GLenum target);
+typedef void (APIENTRY * PFNGLRESETMINMAXPROC) (GLenum target);
+typedef void (APIENTRY * PFNGLTEXIMAGE3DPROC) (GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
+typedef void (APIENTRY * PFNGLTEXSUBIMAGE3DPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels);
+typedef void (APIENTRY * PFNGLCOPYTEXSUBIMAGE3DPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height);
+#endif
+
+#ifndef GL_ARB_multitexture
+#define GL_ARB_multitexture 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glActiveTextureARB (GLenum);
+extern void APIENTRY glClientActiveTextureARB (GLenum);
+extern void APIENTRY glMultiTexCoord1dARB (GLenum, GLdouble);
+extern void APIENTRY glMultiTexCoord1dvARB (GLenum, const GLdouble *);
+extern void APIENTRY glMultiTexCoord1fARB (GLenum, GLfloat);
+extern void APIENTRY glMultiTexCoord1fvARB (GLenum, const GLfloat *);
+extern void APIENTRY glMultiTexCoord1iARB (GLenum, GLint);
+extern void APIENTRY glMultiTexCoord1ivARB (GLenum, const GLint *);
+extern void APIENTRY glMultiTexCoord1sARB (GLenum, GLshort);
+extern void APIENTRY glMultiTexCoord1svARB (GLenum, const GLshort *);
+extern void APIENTRY glMultiTexCoord2dARB (GLenum, GLdouble, GLdouble);
+extern void APIENTRY glMultiTexCoord2dvARB (GLenum, const GLdouble *);
+extern void APIENTRY glMultiTexCoord2fARB (GLenum, GLfloat, GLfloat);
+extern void APIENTRY glMultiTexCoord2fvARB (GLenum, const GLfloat *);
+extern void APIENTRY glMultiTexCoord2iARB (GLenum, GLint, GLint);
+extern void APIENTRY glMultiTexCoord2ivARB (GLenum, const GLint *);
+extern void APIENTRY glMultiTexCoord2sARB (GLenum, GLshort, GLshort);
+extern void APIENTRY glMultiTexCoord2svARB (GLenum, const GLshort *);
+extern void APIENTRY glMultiTexCoord3dARB (GLenum, GLdouble, GLdouble, GLdouble);
+extern void APIENTRY glMultiTexCoord3dvARB (GLenum, const GLdouble *);
+extern void APIENTRY glMultiTexCoord3fARB (GLenum, GLfloat, GLfloat, GLfloat);
+extern void APIENTRY glMultiTexCoord3fvARB (GLenum, const GLfloat *);
+extern void APIENTRY glMultiTexCoord3iARB (GLenum, GLint, GLint, GLint);
+extern void APIENTRY glMultiTexCoord3ivARB (GLenum, const GLint *);
+extern void APIENTRY glMultiTexCoord3sARB (GLenum, GLshort, GLshort, GLshort);
+extern void APIENTRY glMultiTexCoord3svARB (GLenum, const GLshort *);
+extern void APIENTRY glMultiTexCoord4dARB (GLenum, GLdouble, GLdouble, GLdouble, GLdouble);
+extern void APIENTRY glMultiTexCoord4dvARB (GLenum, const GLdouble *);
+extern void APIENTRY glMultiTexCoord4fARB (GLenum, GLfloat, GLfloat, GLfloat, GLfloat);
+extern void APIENTRY glMultiTexCoord4fvARB (GLenum, const GLfloat *);
+extern void APIENTRY glMultiTexCoord4iARB (GLenum, GLint, GLint, GLint, GLint);
+extern void APIENTRY glMultiTexCoord4ivARB (GLenum, const GLint *);
+extern void APIENTRY glMultiTexCoord4sARB (GLenum, GLshort, GLshort, GLshort, GLshort);
+extern void APIENTRY glMultiTexCoord4svARB (GLenum, const GLshort *);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLACTIVETEXTUREARBPROC) (GLenum texture);
+typedef void (APIENTRY * PFNGLCLIENTACTIVETEXTUREARBPROC) (GLenum texture);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD1DARBPROC) (GLenum target, GLdouble s);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD1DVARBPROC) (GLenum target, const GLdouble *v);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD1FARBPROC) (GLenum target, GLfloat s);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD1FVARBPROC) (GLenum target, const GLfloat *v);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD1IARBPROC) (GLenum target, GLint s);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD1IVARBPROC) (GLenum target, const GLint *v);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD1SARBPROC) (GLenum target, GLshort s);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD1SVARBPROC) (GLenum target, const GLshort *v);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD2DARBPROC) (GLenum target, GLdouble s, GLdouble t);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD2DVARBPROC) (GLenum target, const GLdouble *v);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD2FARBPROC) (GLenum target, GLfloat s, GLfloat t);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD2FVARBPROC) (GLenum target, const GLfloat *v);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD2IARBPROC) (GLenum target, GLint s, GLint t);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD2IVARBPROC) (GLenum target, const GLint *v);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD2SARBPROC) (GLenum target, GLshort s, GLshort t);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD2SVARBPROC) (GLenum target, const GLshort *v);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD3DARBPROC) (GLenum target, GLdouble s, GLdouble t, GLdouble r);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD3DVARBPROC) (GLenum target, const GLdouble *v);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD3FARBPROC) (GLenum target, GLfloat s, GLfloat t, GLfloat r);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD3FVARBPROC) (GLenum target, const GLfloat *v);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD3IARBPROC) (GLenum target, GLint s, GLint t, GLint r);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD3IVARBPROC) (GLenum target, const GLint *v);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD3SARBPROC) (GLenum target, GLshort s, GLshort t, GLshort r);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD3SVARBPROC) (GLenum target, const GLshort *v);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD4DARBPROC) (GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD4DVARBPROC) (GLenum target, const GLdouble *v);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD4FARBPROC) (GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD4FVARBPROC) (GLenum target, const GLfloat *v);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD4IARBPROC) (GLenum target, GLint s, GLint t, GLint r, GLint q);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD4IVARBPROC) (GLenum target, const GLint *v);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD4SARBPROC) (GLenum target, GLshort s, GLshort t, GLshort r, GLshort q);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD4SVARBPROC) (GLenum target, const GLshort *v);
+#endif
+
+#ifndef GL_ARB_transpose_matrix
+#define GL_ARB_transpose_matrix 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glLoadTransposeMatrixfARB (const GLfloat *);
+extern void APIENTRY glLoadTransposeMatrixdARB (const GLdouble *);
+extern void APIENTRY glMultTransposeMatrixfARB (const GLfloat *);
+extern void APIENTRY glMultTransposeMatrixdARB (const GLdouble *);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLLOADTRANSPOSEMATRIXFARBPROC) (const GLfloat *m);
+typedef void (APIENTRY * PFNGLLOADTRANSPOSEMATRIXDARBPROC) (const GLdouble *m);
+typedef void (APIENTRY * PFNGLMULTTRANSPOSEMATRIXFARBPROC) (const GLfloat *m);
+typedef void (APIENTRY * PFNGLMULTTRANSPOSEMATRIXDARBPROC) (const GLdouble *m);
+#endif
+
+#ifndef GL_ARB_multisample
+#define GL_ARB_multisample 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glSampleCoverageARB (GLclampf, GLboolean);
+extern void APIENTRY glSamplePassARB (GLenum);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLSAMPLECOVERAGEARBPROC) (GLclampf value, GLboolean invert);
+typedef void (APIENTRY * PFNGLSAMPLEPASSARBPROC) (GLenum pass);
+#endif
+
+#ifndef GL_ARB_texture_env_add
+#define GL_ARB_texture_env_add 1
+#endif
+
+#ifndef GL_ARB_texture_cube_map
+#define GL_ARB_texture_cube_map 1
+#endif
+
+#ifndef GL_ARB_texture_compression
+#define GL_ARB_texture_compression 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glCompressedTexImage3DARB (GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLsizei, const GLvoid *);
+extern void APIENTRY glCompressedTexImage2DARB (GLenum, GLint, GLenum, GLsizei, GLsizei, GLint, GLsizei, const GLvoid *);
+extern void APIENTRY glCompressedTexImage1DARB (GLenum, GLint, GLenum, GLsizei, GLint, GLsizei, const GLvoid *);
+extern void APIENTRY glCompressedTexSubImage3DARB (GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLsizei, const GLvoid *);
+extern void APIENTRY glCompressedTexSubImage2DARB (GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLsizei, const GLvoid *);
+extern void APIENTRY glCompressedTexSubImage1DARB (GLenum, GLint, GLint, GLsizei, GLenum, GLsizei, const GLvoid *);
+extern void APIENTRY glGetCompressedTexImageARB (GLenum, GLint, void *);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLCOMPRESSEDTEXIMAGE3DARBPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data);
+typedef void (APIENTRY * PFNGLCOMPRESSEDTEXIMAGE2DARBPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data);
+typedef void (APIENTRY * PFNGLCOMPRESSEDTEXIMAGE1DARBPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data);
+typedef void (APIENTRY * PFNGLCOMPRESSEDTEXSUBIMAGE3DARBPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data);
+typedef void (APIENTRY * PFNGLCOMPRESSEDTEXSUBIMAGE2DARBPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data);
+typedef void (APIENTRY * PFNGLCOMPRESSEDTEXSUBIMAGE1DARBPROC) (GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data);
+typedef void (APIENTRY * PFNGLGETCOMPRESSEDTEXIMAGEARBPROC) (GLenum target, GLint level, void *img);
+#endif
+
+#ifndef GL_EXT_abgr
+#define GL_EXT_abgr 1
+#endif
+
+#ifndef GL_EXT_blend_color
+#define GL_EXT_blend_color 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glBlendColorEXT (GLclampf, GLclampf, GLclampf, GLclampf);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLBLENDCOLOREXTPROC) (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
+#endif
+
+#ifndef GL_EXT_polygon_offset
+#define GL_EXT_polygon_offset 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glPolygonOffsetEXT (GLfloat, GLfloat);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLPOLYGONOFFSETEXTPROC) (GLfloat factor, GLfloat bias);
+#endif
+
+#ifndef GL_EXT_texture
+#define GL_EXT_texture 1
+#endif
+
+#ifndef GL_EXT_texture3D
+#define GL_EXT_texture3D 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glTexImage3DEXT (GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *);
+extern void APIENTRY glTexSubImage3DEXT (GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLTEXIMAGE3DEXTPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
+typedef void (APIENTRY * PFNGLTEXSUBIMAGE3DEXTPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels);
+#endif
+
+#ifndef GL_SGIS_texture_filter4
+#define GL_SGIS_texture_filter4 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glGetTexFilterFuncSGIS (GLenum, GLenum, GLfloat *);
+extern void APIENTRY glTexFilterFuncSGIS (GLenum, GLenum, GLsizei, const GLfloat *);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLGETTEXFILTERFUNCSGISPROC) (GLenum target, GLenum filter, GLfloat *weights);
+typedef void (APIENTRY * PFNGLTEXFILTERFUNCSGISPROC) (GLenum target, GLenum filter, GLsizei n, const GLfloat *weights);
+#endif
+
+#ifndef GL_EXT_subtexture
+#define GL_EXT_subtexture 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glTexSubImage1DEXT (GLenum, GLint, GLint, GLsizei, GLenum, GLenum, const GLvoid *);
+extern void APIENTRY glTexSubImage2DEXT (GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLTEXSUBIMAGE1DEXTPROC) (GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels);
+typedef void (APIENTRY * PFNGLTEXSUBIMAGE2DEXTPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
+#endif
+
+#ifndef GL_EXT_copy_texture
+#define GL_EXT_copy_texture 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glCopyTexImage1DEXT (GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLint);
+extern void APIENTRY glCopyTexImage2DEXT (GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLsizei, GLint);
+extern void APIENTRY glCopyTexSubImage1DEXT (GLenum, GLint, GLint, GLint, GLint, GLsizei);
+extern void APIENTRY glCopyTexSubImage2DEXT (GLenum, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei);
+extern void APIENTRY glCopyTexSubImage3DEXT (GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLCOPYTEXIMAGE1DEXTPROC) (GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border);
+typedef void (APIENTRY * PFNGLCOPYTEXIMAGE2DEXTPROC) (GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
+typedef void (APIENTRY * PFNGLCOPYTEXSUBIMAGE1DEXTPROC) (GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);
+typedef void (APIENTRY * PFNGLCOPYTEXSUBIMAGE2DEXTPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
+typedef void (APIENTRY * PFNGLCOPYTEXSUBIMAGE3DEXTPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height);
+#endif
+
+#ifndef GL_EXT_histogram
+#define GL_EXT_histogram 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glGetHistogramEXT (GLenum, GLboolean, GLenum, GLenum, GLvoid *);
+extern void APIENTRY glGetHistogramParameterfvEXT (GLenum, GLenum, GLfloat *);
+extern void APIENTRY glGetHistogramParameterivEXT (GLenum, GLenum, GLint *);
+extern void APIENTRY glGetMinmaxEXT (GLenum, GLboolean, GLenum, GLenum, GLvoid *);
+extern void APIENTRY glGetMinmaxParameterfvEXT (GLenum, GLenum, GLfloat *);
+extern void APIENTRY glGetMinmaxParameterivEXT (GLenum, GLenum, GLint *);
+extern void APIENTRY glHistogramEXT (GLenum, GLsizei, GLenum, GLboolean);
+extern void APIENTRY glMinmaxEXT (GLenum, GLenum, GLboolean);
+extern void APIENTRY glResetHistogramEXT (GLenum);
+extern void APIENTRY glResetMinmaxEXT (GLenum);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLGETHISTOGRAMEXTPROC) (GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values);
+typedef void (APIENTRY * PFNGLGETHISTOGRAMPARAMETERFVEXTPROC) (GLenum target, GLenum pname, GLfloat *params);
+typedef void (APIENTRY * PFNGLGETHISTOGRAMPARAMETERIVEXTPROC) (GLenum target, GLenum pname, GLint *params);
+typedef void (APIENTRY * PFNGLGETMINMAXEXTPROC) (GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values);
+typedef void (APIENTRY * PFNGLGETMINMAXPARAMETERFVEXTPROC) (GLenum target, GLenum pname, GLfloat *params);
+typedef void (APIENTRY * PFNGLGETMINMAXPARAMETERIVEXTPROC) (GLenum target, GLenum pname, GLint *params);
+typedef void (APIENTRY * PFNGLHISTOGRAMEXTPROC) (GLenum target, GLsizei width, GLenum internalformat, GLboolean sink);
+typedef void (APIENTRY * PFNGLMINMAXEXTPROC) (GLenum target, GLenum internalformat, GLboolean sink);
+typedef void (APIENTRY * PFNGLRESETHISTOGRAMEXTPROC) (GLenum target);
+typedef void (APIENTRY * PFNGLRESETMINMAXEXTPROC) (GLenum target);
+#endif
+
+#ifndef GL_EXT_convolution
+#define GL_EXT_convolution 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glConvolutionFilter1DEXT (GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *);
+extern void APIENTRY glConvolutionFilter2DEXT (GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *);
+extern void APIENTRY glConvolutionParameterfEXT (GLenum, GLenum, GLfloat);
+extern void APIENTRY glConvolutionParameterfvEXT (GLenum, GLenum, const GLfloat *);
+extern void APIENTRY glConvolutionParameteriEXT (GLenum, GLenum, GLint);
+extern void APIENTRY glConvolutionParameterivEXT (GLenum, GLenum, const GLint *);
+extern void APIENTRY glCopyConvolutionFilter1DEXT (GLenum, GLenum, GLint, GLint, GLsizei);
+extern void APIENTRY glCopyConvolutionFilter2DEXT (GLenum, GLenum, GLint, GLint, GLsizei, GLsizei);
+extern void APIENTRY glGetConvolutionFilterEXT (GLenum, GLenum, GLenum, GLvoid *);
+extern void APIENTRY glGetConvolutionParameterfvEXT (GLenum, GLenum, GLfloat *);
+extern void APIENTRY glGetConvolutionParameterivEXT (GLenum, GLenum, GLint *);
+extern void APIENTRY glGetSeparableFilterEXT (GLenum, GLenum, GLenum, GLvoid *, GLvoid *, GLvoid *);
+extern void APIENTRY glSeparableFilter2DEXT (GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *, const GLvoid *);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLCONVOLUTIONFILTER1DEXTPROC) (GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *image);
+typedef void (APIENTRY * PFNGLCONVOLUTIONFILTER2DEXTPROC) (GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image);
+typedef void (APIENTRY * PFNGLCONVOLUTIONPARAMETERFEXTPROC) (GLenum target, GLenum pname, GLfloat params);
+typedef void (APIENTRY * PFNGLCONVOLUTIONPARAMETERFVEXTPROC) (GLenum target, GLenum pname, const GLfloat *params);
+typedef void (APIENTRY * PFNGLCONVOLUTIONPARAMETERIEXTPROC) (GLenum target, GLenum pname, GLint params);
+typedef void (APIENTRY * PFNGLCONVOLUTIONPARAMETERIVEXTPROC) (GLenum target, GLenum pname, const GLint *params);
+typedef void (APIENTRY * PFNGLCOPYCONVOLUTIONFILTER1DEXTPROC) (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width);
+typedef void (APIENTRY * PFNGLCOPYCONVOLUTIONFILTER2DEXTPROC) (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height);
+typedef void (APIENTRY * PFNGLGETCONVOLUTIONFILTEREXTPROC) (GLenum target, GLenum format, GLenum type, GLvoid *image);
+typedef void (APIENTRY * PFNGLGETCONVOLUTIONPARAMETERFVEXTPROC) (GLenum target, GLenum pname, GLfloat *params);
+typedef void (APIENTRY * PFNGLGETCONVOLUTIONPARAMETERIVEXTPROC) (GLenum target, GLenum pname, GLint *params);
+typedef void (APIENTRY * PFNGLGETSEPARABLEFILTEREXTPROC) (GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span);
+typedef void (APIENTRY * PFNGLSEPARABLEFILTER2DEXTPROC) (GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column);
+#endif
+
+#ifndef GL_EXT_color_matrix
+#define GL_EXT_color_matrix 1
+#endif
+
+#ifndef GL_SGI_color_table
+#define GL_SGI_color_table 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glColorTableSGI (GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *);
+extern void APIENTRY glColorTableParameterfvSGI (GLenum, GLenum, const GLfloat *);
+extern void APIENTRY glColorTableParameterivSGI (GLenum, GLenum, const GLint *);
+extern void APIENTRY glCopyColorTableSGI (GLenum, GLenum, GLint, GLint, GLsizei);
+extern void APIENTRY glGetColorTableSGI (GLenum, GLenum, GLenum, GLvoid *);
+extern void APIENTRY glGetColorTableParameterfvSGI (GLenum, GLenum, GLfloat *);
+extern void APIENTRY glGetColorTableParameterivSGI (GLenum, GLenum, GLint *);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLCOLORTABLESGIPROC) (GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table);
+typedef void (APIENTRY * PFNGLCOLORTABLEPARAMETERFVSGIPROC) (GLenum target, GLenum pname, const GLfloat *params);
+typedef void (APIENTRY * PFNGLCOLORTABLEPARAMETERIVSGIPROC) (GLenum target, GLenum pname, const GLint *params);
+typedef void (APIENTRY * PFNGLCOPYCOLORTABLESGIPROC) (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width);
+typedef void (APIENTRY * PFNGLGETCOLORTABLESGIPROC) (GLenum target, GLenum format, GLenum type, GLvoid *table);
+typedef void (APIENTRY * PFNGLGETCOLORTABLEPARAMETERFVSGIPROC) (GLenum target, GLenum pname, GLfloat *params);
+typedef void (APIENTRY * PFNGLGETCOLORTABLEPARAMETERIVSGIPROC) (GLenum target, GLenum pname, GLint *params);
+#endif
+
+#ifndef GL_SGIX_pixel_texture
+#define GL_SGIX_pixel_texture 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glPixelTexGenSGIX (GLenum);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLPIXELTEXGENSGIXPROC) (GLenum mode);
+#endif
+
+#ifndef GL_SGIS_pixel_texture
+#define GL_SGIS_pixel_texture 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glPixelTexGenParameteriSGIS (GLenum, GLint);
+extern void APIENTRY glPixelTexGenParameterivSGIS (GLenum, const GLint *);
+extern void APIENTRY glPixelTexGenParameterfSGIS (GLenum, GLfloat);
+extern void APIENTRY glPixelTexGenParameterfvSGIS (GLenum, const GLfloat *);
+extern void APIENTRY glGetPixelTexGenParameterivSGIS (GLenum, GLint *);
+extern void APIENTRY glGetPixelTexGenParameterfvSGIS (GLenum, GLfloat *);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLPIXELTEXGENPARAMETERISGISPROC) (GLenum pname, GLint param);
+typedef void (APIENTRY * PFNGLPIXELTEXGENPARAMETERIVSGISPROC) (GLenum pname, const GLint *params);
+typedef void (APIENTRY * PFNGLPIXELTEXGENPARAMETERFSGISPROC) (GLenum pname, GLfloat param);
+typedef void (APIENTRY * PFNGLPIXELTEXGENPARAMETERFVSGISPROC) (GLenum pname, const GLfloat *params);
+typedef void (APIENTRY * PFNGLGETPIXELTEXGENPARAMETERIVSGISPROC) (GLenum pname, GLint *params);
+typedef void (APIENTRY * PFNGLGETPIXELTEXGENPARAMETERFVSGISPROC) (GLenum pname, GLfloat *params);
+#endif
+
+#ifndef GL_SGIS_texture4D
+#define GL_SGIS_texture4D 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glTexImage4DSGIS (GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *);
+extern void APIENTRY glTexSubImage4DSGIS (GLenum, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLTEXIMAGE4DSGISPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLsizei size4d, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
+typedef void (APIENTRY * PFNGLTEXSUBIMAGE4DSGISPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint woffset, GLsizei width, GLsizei height, GLsizei depth, GLsizei size4d, GLenum format, GLenum type, const GLvoid *pixels);
+#endif
+
+#ifndef GL_SGI_texture_color_table
+#define GL_SGI_texture_color_table 1
+#endif
+
+#ifndef GL_EXT_cmyka
+#define GL_EXT_cmyka 1
+#endif
+
+#ifndef GL_EXT_texture_object
+#define GL_EXT_texture_object 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern GLboolean APIENTRY glAreTexturesResidentEXT (GLsizei, const GLuint *, GLboolean *);
+extern void APIENTRY glBindTextureEXT (GLenum, GLuint);
+extern void APIENTRY glDeleteTexturesEXT (GLsizei, const GLuint *);
+extern void APIENTRY glGenTexturesEXT (GLsizei, GLuint *);
+extern GLboolean APIENTRY glIsTextureEXT (GLuint);
+extern void APIENTRY glPrioritizeTexturesEXT (GLsizei, const GLuint *, const GLclampf *);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef GLboolean (APIENTRY * PFNGLARETEXTURESRESIDENTEXTPROC) (GLsizei n, const GLuint *textures, GLboolean *residences);
+typedef void (APIENTRY * PFNGLBINDTEXTUREEXTPROC) (GLenum target, GLuint texture);
+typedef void (APIENTRY * PFNGLDELETETEXTURESEXTPROC) (GLsizei n, const GLuint *textures);
+typedef void (APIENTRY * PFNGLGENTEXTURESEXTPROC) (GLsizei n, GLuint *textures);
+typedef GLboolean (APIENTRY * PFNGLISTEXTUREEXTPROC) (GLuint texture);
+typedef void (APIENTRY * PFNGLPRIORITIZETEXTURESEXTPROC) (GLsizei n, const GLuint *textures, const GLclampf *priorities);
+#endif
+
+#ifndef GL_SGIS_detail_texture
+#define GL_SGIS_detail_texture 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glDetailTexFuncSGIS (GLenum, GLsizei, const GLfloat *);
+extern void APIENTRY glGetDetailTexFuncSGIS (GLenum, GLfloat *);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLDETAILTEXFUNCSGISPROC) (GLenum target, GLsizei n, const GLfloat *points);
+typedef void (APIENTRY * PFNGLGETDETAILTEXFUNCSGISPROC) (GLenum target, GLfloat *points);
+#endif
+
+#ifndef GL_SGIS_sharpen_texture
+#define GL_SGIS_sharpen_texture 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glSharpenTexFuncSGIS (GLenum, GLsizei, const GLfloat *);
+extern void APIENTRY glGetSharpenTexFuncSGIS (GLenum, GLfloat *);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLSHARPENTEXFUNCSGISPROC) (GLenum target, GLsizei n, const GLfloat *points);
+typedef void (APIENTRY * PFNGLGETSHARPENTEXFUNCSGISPROC) (GLenum target, GLfloat *points);
+#endif
+
+#ifndef GL_EXT_packed_pixels
+#define GL_EXT_packed_pixels 1
+#endif
+
+#ifndef GL_SGIS_texture_lod
+#define GL_SGIS_texture_lod 1
+#endif
+
+#ifndef GL_SGIS_multisample
+#define GL_SGIS_multisample 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glSampleMaskSGIS (GLclampf, GLboolean);
+extern void APIENTRY glSamplePatternSGIS (GLenum);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLSAMPLEMASKSGISPROC) (GLclampf value, GLboolean invert);
+typedef void (APIENTRY * PFNGLSAMPLEPATTERNSGISPROC) (GLenum pattern);
+#endif
+
+#ifndef GL_EXT_rescale_normal
+#define GL_EXT_rescale_normal 1
+#endif
+
+#ifndef GL_EXT_vertex_array
+#define GL_EXT_vertex_array 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glArrayElementEXT (GLint);
+extern void APIENTRY glColorPointerEXT (GLint, GLenum, GLsizei, GLsizei, const GLvoid *);
+extern void APIENTRY glDrawArraysEXT (GLenum, GLint, GLsizei);
+extern void APIENTRY glEdgeFlagPointerEXT (GLsizei, GLsizei, const GLboolean *);
+extern void APIENTRY glGetPointervEXT (GLenum, GLvoid* *);
+extern void APIENTRY glIndexPointerEXT (GLenum, GLsizei, GLsizei, const GLvoid *);
+extern void APIENTRY glNormalPointerEXT (GLenum, GLsizei, GLsizei, const GLvoid *);
+extern void APIENTRY glTexCoordPointerEXT (GLint, GLenum, GLsizei, GLsizei, const GLvoid *);
+extern void APIENTRY glVertexPointerEXT (GLint, GLenum, GLsizei, GLsizei, const GLvoid *);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLARRAYELEMENTEXTPROC) (GLint i);
+typedef void (APIENTRY * PFNGLCOLORPOINTEREXTPROC) (GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer);
+typedef void (APIENTRY * PFNGLDRAWARRAYSEXTPROC) (GLenum mode, GLint first, GLsizei count);
+typedef void (APIENTRY * PFNGLEDGEFLAGPOINTEREXTPROC) (GLsizei stride, GLsizei count, const GLboolean *pointer);
+typedef void (APIENTRY * PFNGLGETPOINTERVEXTPROC) (GLenum pname, GLvoid* *params);
+typedef void (APIENTRY * PFNGLINDEXPOINTEREXTPROC) (GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer);
+typedef void (APIENTRY * PFNGLNORMALPOINTEREXTPROC) (GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer);
+typedef void (APIENTRY * PFNGLTEXCOORDPOINTEREXTPROC) (GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer);
+typedef void (APIENTRY * PFNGLVERTEXPOINTEREXTPROC) (GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer);
+#endif
+
+#ifndef GL_EXT_misc_attribute
+#define GL_EXT_misc_attribute 1
+#endif
+
+#ifndef GL_SGIS_generate_mipmap
+#define GL_SGIS_generate_mipmap 1
+#endif
+
+#ifndef GL_SGIX_clipmap
+#define GL_SGIX_clipmap 1
+#endif
+
+#ifndef GL_SGIX_shadow
+#define GL_SGIX_shadow 1
+#endif
+
+#ifndef GL_SGIS_texture_edge_clamp
+#define GL_SGIS_texture_edge_clamp 1
+#endif
+
+#ifndef GL_SGIS_texture_border_clamp
+#define GL_SGIS_texture_border_clamp 1
+#endif
+
+#ifndef GL_EXT_blend_minmax
+#define GL_EXT_blend_minmax 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glBlendEquationEXT (GLenum);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLBLENDEQUATIONEXTPROC) (GLenum mode);
+#endif
+
+#ifndef GL_EXT_blend_subtract
+#define GL_EXT_blend_subtract 1
+#endif
+
+#ifndef GL_EXT_blend_logic_op
+#define GL_EXT_blend_logic_op 1
+#endif
+
+#ifndef GL_SGIX_interlace
+#define GL_SGIX_interlace 1
+#endif
+
+#ifndef GL_SGIX_pixel_tiles
+#define GL_SGIX_pixel_tiles 1
+#endif
+
+#ifndef GL_SGIX_texture_select
+#define GL_SGIX_texture_select 1
+#endif
+
+#ifndef GL_SGIX_sprite
+#define GL_SGIX_sprite 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glSpriteParameterfSGIX (GLenum, GLfloat);
+extern void APIENTRY glSpriteParameterfvSGIX (GLenum, const GLfloat *);
+extern void APIENTRY glSpriteParameteriSGIX (GLenum, GLint);
+extern void APIENTRY glSpriteParameterivSGIX (GLenum, const GLint *);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLSPRITEPARAMETERFSGIXPROC) (GLenum pname, GLfloat param);
+typedef void (APIENTRY * PFNGLSPRITEPARAMETERFVSGIXPROC) (GLenum pname, const GLfloat *params);
+typedef void (APIENTRY * PFNGLSPRITEPARAMETERISGIXPROC) (GLenum pname, GLint param);
+typedef void (APIENTRY * PFNGLSPRITEPARAMETERIVSGIXPROC) (GLenum pname, const GLint *params);
+#endif
+
+#ifndef GL_SGIX_texture_multi_buffer
+#define GL_SGIX_texture_multi_buffer 1
+#endif
+
+#ifndef GL_EXT_point_parameters
+#define GL_EXT_point_parameters 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glPointParameterfEXT (GLenum, GLfloat);
+extern void APIENTRY glPointParameterfvEXT (GLenum, const GLfloat *);
+extern void APIENTRY glPointParameterfSGIS (GLenum, GLfloat);
+extern void APIENTRY glPointParameterfvSGIS (GLenum, const GLfloat *);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLPOINTPARAMETERFEXTPROC) (GLenum pname, GLfloat param);
+typedef void (APIENTRY * PFNGLPOINTPARAMETERFVEXTPROC) (GLenum pname, const GLfloat *params);
+typedef void (APIENTRY * PFNGLPOINTPARAMETERFSGISPROC) (GLenum pname, GLfloat param);
+typedef void (APIENTRY * PFNGLPOINTPARAMETERFVSGISPROC) (GLenum pname, const GLfloat *params);
+#endif
+
+#ifndef GL_SGIX_instruments
+#define GL_SGIX_instruments 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern GLint APIENTRY glGetInstrumentsSGIX (void);
+extern void APIENTRY glInstrumentsBufferSGIX (GLsizei, GLint *);
+extern GLint APIENTRY glPollInstrumentsSGIX (GLint *);
+extern void APIENTRY glReadInstrumentsSGIX (GLint);
+extern void APIENTRY glStartInstrumentsSGIX (void);
+extern void APIENTRY glStopInstrumentsSGIX (GLint);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef GLint (APIENTRY * PFNGLGETINSTRUMENTSSGIXPROC) (void);
+typedef void (APIENTRY * PFNGLINSTRUMENTSBUFFERSGIXPROC) (GLsizei size, GLint *buffer);
+typedef GLint (APIENTRY * PFNGLPOLLINSTRUMENTSSGIXPROC) (GLint *marker_p);
+typedef void (APIENTRY * PFNGLREADINSTRUMENTSSGIXPROC) (GLint marker);
+typedef void (APIENTRY * PFNGLSTARTINSTRUMENTSSGIXPROC) (void);
+typedef void (APIENTRY * PFNGLSTOPINSTRUMENTSSGIXPROC) (GLint marker);
+#endif
+
+#ifndef GL_SGIX_texture_scale_bias
+#define GL_SGIX_texture_scale_bias 1
+#endif
+
+#ifndef GL_SGIX_framezoom
+#define GL_SGIX_framezoom 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glFrameZoomSGIX (GLint);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLFRAMEZOOMSGIXPROC) (GLint factor);
+#endif
+
+#ifndef GL_SGIX_tag_sample_buffer
+#define GL_SGIX_tag_sample_buffer 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glTagSampleBufferSGIX (void);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLTAGSAMPLEBUFFERSGIXPROC) (void);
+#endif
+
+#ifndef GL_SGIX_reference_plane
+#define GL_SGIX_reference_plane 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glReferencePlaneSGIX (const GLdouble *);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLREFERENCEPLANESGIXPROC) (const GLdouble *equation);
+#endif
+
+#ifndef GL_SGIX_flush_raster
+#define GL_SGIX_flush_raster 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glFlushRasterSGIX (void);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLFLUSHRASTERSGIXPROC) (void);
+#endif
+
+#ifndef GL_SGIX_depth_texture
+#define GL_SGIX_depth_texture 1
+#endif
+
+#ifndef GL_SGIS_fog_function
+#define GL_SGIS_fog_function 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glFogFuncSGIS (GLsizei, const GLfloat *);
+extern void APIENTRY glGetFogFuncSGIS (const GLfloat *);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLFOGFUNCSGISPROC) (GLsizei n, const GLfloat *points);
+typedef void (APIENTRY * PFNGLGETFOGFUNCSGISPROC) (const GLfloat *points);
+#endif
+
+#ifndef GL_SGIX_fog_offset
+#define GL_SGIX_fog_offset 1
+#endif
+
+#ifndef GL_HP_image_transform
+#define GL_HP_image_transform 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glImageTransformParameteriHP (GLenum, GLenum, GLint);
+extern void APIENTRY glImageTransformParameterfHP (GLenum, GLenum, GLfloat);
+extern void APIENTRY glImageTransformParameterivHP (GLenum, GLenum, const GLint *);
+extern void APIENTRY glImageTransformParameterfvHP (GLenum, GLenum, const GLfloat *);
+extern void APIENTRY glGetImageTransformParameterivHP (GLenum, GLenum, GLint *);
+extern void APIENTRY glGetImageTransformParameterfvHP (GLenum, GLenum, GLfloat *);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLIMAGETRANSFORMPARAMETERIHPPROC) (GLenum target, GLenum pname, GLint param);
+typedef void (APIENTRY * PFNGLIMAGETRANSFORMPARAMETERFHPPROC) (GLenum target, GLenum pname, GLfloat param);
+typedef void (APIENTRY * PFNGLIMAGETRANSFORMPARAMETERIVHPPROC) (GLenum target, GLenum pname, const GLint *params);
+typedef void (APIENTRY * PFNGLIMAGETRANSFORMPARAMETERFVHPPROC) (GLenum target, GLenum pname, const GLfloat *params);
+typedef void (APIENTRY * PFNGLGETIMAGETRANSFORMPARAMETERIVHPPROC) (GLenum target, GLenum pname, GLint *params);
+typedef void (APIENTRY * PFNGLGETIMAGETRANSFORMPARAMETERFVHPPROC) (GLenum target, GLenum pname, GLfloat *params);
+#endif
+
+#ifndef GL_HP_convolution_border_modes
+#define GL_HP_convolution_border_modes 1
+#endif
+
+#ifndef GL_SGIX_texture_add_env
+#define GL_SGIX_texture_add_env 1
+#endif
+
+#ifndef GL_EXT_color_subtable
+#define GL_EXT_color_subtable 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glColorSubTableEXT (GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *);
+extern void APIENTRY glCopyColorSubTableEXT (GLenum, GLsizei, GLint, GLint, GLsizei);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLCOLORSUBTABLEEXTPROC) (GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data);
+typedef void (APIENTRY * PFNGLCOPYCOLORSUBTABLEEXTPROC) (GLenum target, GLsizei start, GLint x, GLint y, GLsizei width);
+#endif
+
+#ifndef GL_PGI_vertex_hints
+#define GL_PGI_vertex_hints 1
+#endif
+
+#ifndef GL_PGI_misc_hints
+#define GL_PGI_misc_hints 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glHintPGI (GLenum, GLint);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLHINTPGIPROC) (GLenum target, GLint mode);
+#endif
+
+#ifndef GL_EXT_paletted_texture
+#define GL_EXT_paletted_texture 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glColorTableEXT (GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *);
+extern void APIENTRY glGetColorTableEXT (GLenum, GLenum, GLenum, GLvoid *);
+extern void APIENTRY glGetColorTableParameterivEXT (GLenum, GLenum, GLint *);
+extern void APIENTRY glGetColorTableParameterfvEXT (GLenum, GLenum, GLfloat *);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLCOLORTABLEEXTPROC) (GLenum target, GLenum internalFormat, GLsizei width, GLenum format, GLenum type, const GLvoid *table);
+typedef void (APIENTRY * PFNGLGETCOLORTABLEEXTPROC) (GLenum target, GLenum format, GLenum type, GLvoid *data);
+typedef void (APIENTRY * PFNGLGETCOLORTABLEPARAMETERIVEXTPROC) (GLenum target, GLenum pname, GLint *params);
+typedef void (APIENTRY * PFNGLGETCOLORTABLEPARAMETERFVEXTPROC) (GLenum target, GLenum pname, GLfloat *params);
+#endif
+
+#ifndef GL_EXT_clip_volume_hint
+#define GL_EXT_clip_volume_hint 1
+#endif
+
+#ifndef GL_SGIX_list_priority
+#define GL_SGIX_list_priority 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glGetListParameterfvSGIX (GLuint, GLenum, GLfloat *);
+extern void APIENTRY glGetListParameterivSGIX (GLuint, GLenum, GLint *);
+extern void APIENTRY glListParameterfSGIX (GLuint, GLenum, GLfloat);
+extern void APIENTRY glListParameterfvSGIX (GLuint, GLenum, const GLfloat *);
+extern void APIENTRY glListParameteriSGIX (GLuint, GLenum, GLint);
+extern void APIENTRY glListParameterivSGIX (GLuint, GLenum, const GLint *);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLGETLISTPARAMETERFVSGIXPROC) (GLuint list, GLenum pname, GLfloat *params);
+typedef void (APIENTRY * PFNGLGETLISTPARAMETERIVSGIXPROC) (GLuint list, GLenum pname, GLint *params);
+typedef void (APIENTRY * PFNGLLISTPARAMETERFSGIXPROC) (GLuint list, GLenum pname, GLfloat param);
+typedef void (APIENTRY * PFNGLLISTPARAMETERFVSGIXPROC) (GLuint list, GLenum pname, const GLfloat *params);
+typedef void (APIENTRY * PFNGLLISTPARAMETERISGIXPROC) (GLuint list, GLenum pname, GLint param);
+typedef void (APIENTRY * PFNGLLISTPARAMETERIVSGIXPROC) (GLuint list, GLenum pname, const GLint *params);
+#endif
+
+#ifndef GL_SGIX_ir_instrument1
+#define GL_SGIX_ir_instrument1 1
+#endif
+
+#ifndef GL_SGIX_calligraphic_fragment
+#define GL_SGIX_calligraphic_fragment 1
+#endif
+
+#ifndef GL_SGIX_texture_lod_bias
+#define GL_SGIX_texture_lod_bias 1
+#endif
+
+#ifndef GL_SGIX_shadow_ambient
+#define GL_SGIX_shadow_ambient 1
+#endif
+
+#ifndef GL_EXT_index_texture
+#define GL_EXT_index_texture 1
+#endif
+
+#ifndef GL_EXT_index_material
+#define GL_EXT_index_material 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glIndexMaterialEXT (GLenum, GLenum);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLINDEXMATERIALEXTPROC) (GLenum face, GLenum mode);
+#endif
+
+#ifndef GL_EXT_index_func
+#define GL_EXT_index_func 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glIndexFuncEXT (GLenum, GLclampf);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLINDEXFUNCEXTPROC) (GLenum func, GLclampf ref);
+#endif
+
+#ifndef GL_EXT_index_array_formats
+#define GL_EXT_index_array_formats 1
+#endif
+
+#ifndef GL_EXT_compiled_vertex_array
+#define GL_EXT_compiled_vertex_array 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glLockArraysEXT (GLint, GLsizei);
+extern void APIENTRY glUnlockArraysEXT (void);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLLOCKARRAYSEXTPROC) (GLint first, GLsizei count);
+typedef void (APIENTRY * PFNGLUNLOCKARRAYSEXTPROC) (void);
+#endif
+
+#ifndef GL_EXT_cull_vertex
+#define GL_EXT_cull_vertex 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glCullParameterdvEXT (GLenum, GLdouble *);
+extern void APIENTRY glCullParameterfvEXT (GLenum, GLfloat *);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLCULLPARAMETERDVEXTPROC) (GLenum pname, GLdouble *params);
+typedef void (APIENTRY * PFNGLCULLPARAMETERFVEXTPROC) (GLenum pname, GLfloat *params);
+#endif
+
+#ifndef GL_SGIX_ycrcb
+#define GL_SGIX_ycrcb 1
+#endif
+
+#ifndef GL_SGIX_fragment_lighting
+#define GL_SGIX_fragment_lighting 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glFragmentColorMaterialSGIX (GLenum, GLenum);
+extern void APIENTRY glFragmentLightfSGIX (GLenum, GLenum, GLfloat);
+extern void APIENTRY glFragmentLightfvSGIX (GLenum, GLenum, const GLfloat *);
+extern void APIENTRY glFragmentLightiSGIX (GLenum, GLenum, GLint);
+extern void APIENTRY glFragmentLightivSGIX (GLenum, GLenum, const GLint *);
+extern void APIENTRY glFragmentLightModelfSGIX (GLenum, GLfloat);
+extern void APIENTRY glFragmentLightModelfvSGIX (GLenum, const GLfloat *);
+extern void APIENTRY glFragmentLightModeliSGIX (GLenum, GLint);
+extern void APIENTRY glFragmentLightModelivSGIX (GLenum, const GLint *);
+extern void APIENTRY glFragmentMaterialfSGIX (GLenum, GLenum, GLfloat);
+extern void APIENTRY glFragmentMaterialfvSGIX (GLenum, GLenum, const GLfloat *);
+extern void APIENTRY glFragmentMaterialiSGIX (GLenum, GLenum, GLint);
+extern void APIENTRY glFragmentMaterialivSGIX (GLenum, GLenum, const GLint *);
+extern void APIENTRY glGetFragmentLightfvSGIX (GLenum, GLenum, GLfloat *);
+extern void APIENTRY glGetFragmentLightivSGIX (GLenum, GLenum, GLint *);
+extern void APIENTRY glGetFragmentMaterialfvSGIX (GLenum, GLenum, GLfloat *);
+extern void APIENTRY glGetFragmentMaterialivSGIX (GLenum, GLenum, GLint *);
+extern void APIENTRY glLightEnviSGIX (GLenum, GLint);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLFRAGMENTCOLORMATERIALSGIXPROC) (GLenum face, GLenum mode);
+typedef void (APIENTRY * PFNGLFRAGMENTLIGHTFSGIXPROC) (GLenum light, GLenum pname, GLfloat param);
+typedef void (APIENTRY * PFNGLFRAGMENTLIGHTFVSGIXPROC) (GLenum light, GLenum pname, const GLfloat *params);
+typedef void (APIENTRY * PFNGLFRAGMENTLIGHTISGIXPROC) (GLenum light, GLenum pname, GLint param);
+typedef void (APIENTRY * PFNGLFRAGMENTLIGHTIVSGIXPROC) (GLenum light, GLenum pname, const GLint *params);
+typedef void (APIENTRY * PFNGLFRAGMENTLIGHTMODELFSGIXPROC) (GLenum pname, GLfloat param);
+typedef void (APIENTRY * PFNGLFRAGMENTLIGHTMODELFVSGIXPROC) (GLenum pname, const GLfloat *params);
+typedef void (APIENTRY * PFNGLFRAGMENTLIGHTMODELISGIXPROC) (GLenum pname, GLint param);
+typedef void (APIENTRY * PFNGLFRAGMENTLIGHTMODELIVSGIXPROC) (GLenum pname, const GLint *params);
+typedef void (APIENTRY * PFNGLFRAGMENTMATERIALFSGIXPROC) (GLenum face, GLenum pname, GLfloat param);
+typedef void (APIENTRY * PFNGLFRAGMENTMATERIALFVSGIXPROC) (GLenum face, GLenum pname, const GLfloat *params);
+typedef void (APIENTRY * PFNGLFRAGMENTMATERIALISGIXPROC) (GLenum face, GLenum pname, GLint param);
+typedef void (APIENTRY * PFNGLFRAGMENTMATERIALIVSGIXPROC) (GLenum face, GLenum pname, const GLint *params);
+typedef void (APIENTRY * PFNGLGETFRAGMENTLIGHTFVSGIXPROC) (GLenum light, GLenum pname, GLfloat *params);
+typedef void (APIENTRY * PFNGLGETFRAGMENTLIGHTIVSGIXPROC) (GLenum light, GLenum pname, GLint *params);
+typedef void (APIENTRY * PFNGLGETFRAGMENTMATERIALFVSGIXPROC) (GLenum face, GLenum pname, GLfloat *params);
+typedef void (APIENTRY * PFNGLGETFRAGMENTMATERIALIVSGIXPROC) (GLenum face, GLenum pname, GLint *params);
+typedef void (APIENTRY * PFNGLLIGHTENVISGIXPROC) (GLenum pname, GLint param);
+#endif
+
+#ifndef GL_IBM_rasterpos_clip
+#define GL_IBM_rasterpos_clip 1
+#endif
+
+#ifndef GL_HP_texture_lighting
+#define GL_HP_texture_lighting 1
+#endif
+
+#ifndef GL_EXT_draw_range_elements
+#define GL_EXT_draw_range_elements 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glDrawRangeElementsEXT (GLenum, GLuint, GLuint, GLsizei, GLenum, const GLvoid *);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLDRAWRANGEELEMENTSEXTPROC) (GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices);
+#endif
+
+#ifndef GL_WIN_phong_shading
+#define GL_WIN_phong_shading 1
+#endif
+
+#ifndef GL_WIN_specular_fog
+#define GL_WIN_specular_fog 1
+#endif
+
+#ifndef GL_EXT_light_texture
+#define GL_EXT_light_texture 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glApplyTextureEXT (GLenum);
+extern void APIENTRY glTextureLightEXT (GLenum);
+extern void APIENTRY glTextureMaterialEXT (GLenum, GLenum);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLAPPLYTEXTUREEXTPROC) (GLenum mode);
+typedef void (APIENTRY * PFNGLTEXTURELIGHTEXTPROC) (GLenum pname);
+typedef void (APIENTRY * PFNGLTEXTUREMATERIALEXTPROC) (GLenum face, GLenum mode);
+#endif
+
+#ifndef GL_SGIX_blend_alpha_minmax
+#define GL_SGIX_blend_alpha_minmax 1
+#endif
+
+#ifndef GL_EXT_bgra
+#define GL_EXT_bgra 1
+#endif
+
+#ifndef GL_INTEL_parallel_arrays
+#define GL_INTEL_parallel_arrays 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glVertexPointervINTEL (GLint, GLenum, const GLvoid* *);
+extern void APIENTRY glNormalPointervINTEL (GLenum, const GLvoid* *);
+extern void APIENTRY glColorPointervINTEL (GLint, GLenum, const GLvoid* *);
+extern void APIENTRY glTexCoordPointervINTEL (GLint, GLenum, const GLvoid* *);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLVERTEXPOINTERVINTELPROC) (GLint size, GLenum type, const GLvoid* *pointer);
+typedef void (APIENTRY * PFNGLNORMALPOINTERVINTELPROC) (GLenum type, const GLvoid* *pointer);
+typedef void (APIENTRY * PFNGLCOLORPOINTERVINTELPROC) (GLint size, GLenum type, const GLvoid* *pointer);
+typedef void (APIENTRY * PFNGLTEXCOORDPOINTERVINTELPROC) (GLint size, GLenum type, const GLvoid* *pointer);
+#endif
+
+#ifndef GL_HP_occlusion_test
+#define GL_HP_occlusion_test 1
+#endif
+
+#ifndef GL_EXT_pixel_transform
+#define GL_EXT_pixel_transform 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glPixelTransformParameteriEXT (GLenum, GLenum, GLint);
+extern void APIENTRY glPixelTransformParameterfEXT (GLenum, GLenum, GLfloat);
+extern void APIENTRY glPixelTransformParameterivEXT (GLenum, GLenum, const GLint *);
+extern void APIENTRY glPixelTransformParameterfvEXT (GLenum, GLenum, const GLfloat *);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLPIXELTRANSFORMPARAMETERIEXTPROC) (GLenum target, GLenum pname, GLint param);
+typedef void (APIENTRY * PFNGLPIXELTRANSFORMPARAMETERFEXTPROC) (GLenum target, GLenum pname, GLfloat param);
+typedef void (APIENTRY * PFNGLPIXELTRANSFORMPARAMETERIVEXTPROC) (GLenum target, GLenum pname, const GLint *params);
+typedef void (APIENTRY * PFNGLPIXELTRANSFORMPARAMETERFVEXTPROC) (GLenum target, GLenum pname, const GLfloat *params);
+#endif
+
+#ifndef GL_EXT_pixel_transform_color_table
+#define GL_EXT_pixel_transform_color_table 1
+#endif
+
+#ifndef GL_EXT_shared_texture_palette
+#define GL_EXT_shared_texture_palette 1
+#endif
+
+#ifndef GL_EXT_separate_specular_color
+#define GL_EXT_separate_specular_color 1
+#endif
+
+#ifndef GL_EXT_secondary_color
+#define GL_EXT_secondary_color 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glSecondaryColor3bEXT (GLbyte, GLbyte, GLbyte);
+extern void APIENTRY glSecondaryColor3bvEXT (const GLbyte *);
+extern void APIENTRY glSecondaryColor3dEXT (GLdouble, GLdouble, GLdouble);
+extern void APIENTRY glSecondaryColor3dvEXT (const GLdouble *);
+extern void APIENTRY glSecondaryColor3fEXT (GLfloat, GLfloat, GLfloat);
+extern void APIENTRY glSecondaryColor3fvEXT (const GLfloat *);
+extern void APIENTRY glSecondaryColor3iEXT (GLint, GLint, GLint);
+extern void APIENTRY glSecondaryColor3ivEXT (const GLint *);
+extern void APIENTRY glSecondaryColor3sEXT (GLshort, GLshort, GLshort);
+extern void APIENTRY glSecondaryColor3svEXT (const GLshort *);
+extern void APIENTRY glSecondaryColor3ubEXT (GLubyte, GLubyte, GLubyte);
+extern void APIENTRY glSecondaryColor3ubvEXT (const GLubyte *);
+extern void APIENTRY glSecondaryColor3uiEXT (GLuint, GLuint, GLuint);
+extern void APIENTRY glSecondaryColor3uivEXT (const GLuint *);
+extern void APIENTRY glSecondaryColor3usEXT (GLushort, GLushort, GLushort);
+extern void APIENTRY glSecondaryColor3usvEXT (const GLushort *);
+extern void APIENTRY glSecondaryColorPointerEXT (GLint, GLenum, GLsizei, GLvoid *);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLSECONDARYCOLOR3BEXTPROC) (GLbyte red, GLbyte green, GLbyte blue);
+typedef void (APIENTRY * PFNGLSECONDARYCOLOR3BVEXTPROC) (const GLbyte *v);
+typedef void (APIENTRY * PFNGLSECONDARYCOLOR3DEXTPROC) (GLdouble red, GLdouble green, GLdouble blue);
+typedef void (APIENTRY * PFNGLSECONDARYCOLOR3DVEXTPROC) (const GLdouble *v);
+typedef void (APIENTRY * PFNGLSECONDARYCOLOR3FEXTPROC) (GLfloat red, GLfloat green, GLfloat blue);
+typedef void (APIENTRY * PFNGLSECONDARYCOLOR3FVEXTPROC) (const GLfloat *v);
+typedef void (APIENTRY * PFNGLSECONDARYCOLOR3IEXTPROC) (GLint red, GLint green, GLint blue);
+typedef void (APIENTRY * PFNGLSECONDARYCOLOR3IVEXTPROC) (const GLint *v);
+typedef void (APIENTRY * PFNGLSECONDARYCOLOR3SEXTPROC) (GLshort red, GLshort green, GLshort blue);
+typedef void (APIENTRY * PFNGLSECONDARYCOLOR3SVEXTPROC) (const GLshort *v);
+typedef void (APIENTRY * PFNGLSECONDARYCOLOR3UBEXTPROC) (GLubyte red, GLubyte green, GLubyte blue);
+typedef void (APIENTRY * PFNGLSECONDARYCOLOR3UBVEXTPROC) (const GLubyte *v);
+typedef void (APIENTRY * PFNGLSECONDARYCOLOR3UIEXTPROC) (GLuint red, GLuint green, GLuint blue);
+typedef void (APIENTRY * PFNGLSECONDARYCOLOR3UIVEXTPROC) (const GLuint *v);
+typedef void (APIENTRY * PFNGLSECONDARYCOLOR3USEXTPROC) (GLushort red, GLushort green, GLushort blue);
+typedef void (APIENTRY * PFNGLSECONDARYCOLOR3USVEXTPROC) (const GLushort *v);
+typedef void (APIENTRY * PFNGLSECONDARYCOLORPOINTEREXTPROC) (GLint size, GLenum type, GLsizei stride, GLvoid *pointer);
+#endif
+
+#ifndef GL_EXT_texture_perturb_normal
+#define GL_EXT_texture_perturb_normal 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glTextureNormalEXT (GLenum);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLTEXTURENORMALEXTPROC) (GLenum mode);
+#endif
+
+#ifndef GL_EXT_multi_draw_arrays
+#define GL_EXT_multi_draw_arrays 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glMultiDrawArraysEXT (GLenum, GLint *, GLsizei *, GLsizei);
+extern void APIENTRY glMultiDrawElementsEXT (GLenum, const GLsizei *, GLenum, const GLvoid* *, GLsizei);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLMULTIDRAWARRAYSEXTPROC) (GLenum mode, GLint *first, GLsizei *count, GLsizei primcount);
+typedef void (APIENTRY * PFNGLMULTIDRAWELEMENTSEXTPROC) (GLenum mode, const GLsizei *count, GLenum type, const GLvoid* *indices, GLsizei primcount);
+#endif
+
+#ifndef GL_EXT_fog_coord
+#define GL_EXT_fog_coord 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glFogCoordfEXT (GLfloat);
+extern void APIENTRY glFogCoordfvEXT (const GLfloat *);
+extern void APIENTRY glFogCoorddEXT (GLdouble);
+extern void APIENTRY glFogCoorddvEXT (const GLdouble *);
+extern void APIENTRY glFogCoordPointerEXT (GLenum, GLsizei, const GLvoid *);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLFOGCOORDFEXTPROC) (GLfloat coord);
+typedef void (APIENTRY * PFNGLFOGCOORDFVEXTPROC) (const GLfloat *coord);
+typedef void (APIENTRY * PFNGLFOGCOORDDEXTPROC) (GLdouble coord);
+typedef void (APIENTRY * PFNGLFOGCOORDDVEXTPROC) (const GLdouble *coord);
+typedef void (APIENTRY * PFNGLFOGCOORDPOINTEREXTPROC) (GLenum type, GLsizei stride, const GLvoid *pointer);
+#endif
+
+#ifndef GL_REND_screen_coordinates
+#define GL_REND_screen_coordinates 1
+#endif
+
+#ifndef GL_EXT_coordinate_frame
+#define GL_EXT_coordinate_frame 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glTangent3bEXT (GLbyte, GLbyte, GLbyte);
+extern void APIENTRY glTangent3bvEXT (const GLbyte *);
+extern void APIENTRY glTangent3dEXT (GLdouble, GLdouble, GLdouble);
+extern void APIENTRY glTangent3dvEXT (const GLdouble *);
+extern void APIENTRY glTangent3fEXT (GLfloat, GLfloat, GLfloat);
+extern void APIENTRY glTangent3fvEXT (const GLfloat *);
+extern void APIENTRY glTangent3iEXT (GLint, GLint, GLint);
+extern void APIENTRY glTangent3ivEXT (const GLint *);
+extern void APIENTRY glTangent3sEXT (GLshort, GLshort, GLshort);
+extern void APIENTRY glTangent3svEXT (const GLshort *);
+extern void APIENTRY glBinormal3bEXT (GLbyte, GLbyte, GLbyte);
+extern void APIENTRY glBinormal3bvEXT (const GLbyte *);
+extern void APIENTRY glBinormal3dEXT (GLdouble, GLdouble, GLdouble);
+extern void APIENTRY glBinormal3dvEXT (const GLdouble *);
+extern void APIENTRY glBinormal3fEXT (GLfloat, GLfloat, GLfloat);
+extern void APIENTRY glBinormal3fvEXT (const GLfloat *);
+extern void APIENTRY glBinormal3iEXT (GLint, GLint, GLint);
+extern void APIENTRY glBinormal3ivEXT (const GLint *);
+extern void APIENTRY glBinormal3sEXT (GLshort, GLshort, GLshort);
+extern void APIENTRY glBinormal3svEXT (const GLshort *);
+extern void APIENTRY glTangentPointerEXT (GLenum, GLsizei, const GLvoid *);
+extern void APIENTRY glBinormalPointerEXT (GLenum, GLsizei, const GLvoid *);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLTANGENT3BEXTPROC) (GLbyte tx, GLbyte ty, GLbyte tz);
+typedef void (APIENTRY * PFNGLTANGENT3BVEXTPROC) (const GLbyte *v);
+typedef void (APIENTRY * PFNGLTANGENT3DEXTPROC) (GLdouble tx, GLdouble ty, GLdouble tz);
+typedef void (APIENTRY * PFNGLTANGENT3DVEXTPROC) (const GLdouble *v);
+typedef void (APIENTRY * PFNGLTANGENT3FEXTPROC) (GLfloat tx, GLfloat ty, GLfloat tz);
+typedef void (APIENTRY * PFNGLTANGENT3FVEXTPROC) (const GLfloat *v);
+typedef void (APIENTRY * PFNGLTANGENT3IEXTPROC) (GLint tx, GLint ty, GLint tz);
+typedef void (APIENTRY * PFNGLTANGENT3IVEXTPROC) (const GLint *v);
+typedef void (APIENTRY * PFNGLTANGENT3SEXTPROC) (GLshort tx, GLshort ty, GLshort tz);
+typedef void (APIENTRY * PFNGLTANGENT3SVEXTPROC) (const GLshort *v);
+typedef void (APIENTRY * PFNGLBINORMAL3BEXTPROC) (GLbyte bx, GLbyte by, GLbyte bz);
+typedef void (APIENTRY * PFNGLBINORMAL3BVEXTPROC) (const GLbyte *v);
+typedef void (APIENTRY * PFNGLBINORMAL3DEXTPROC) (GLdouble bx, GLdouble by, GLdouble bz);
+typedef void (APIENTRY * PFNGLBINORMAL3DVEXTPROC) (const GLdouble *v);
+typedef void (APIENTRY * PFNGLBINORMAL3FEXTPROC) (GLfloat bx, GLfloat by, GLfloat bz);
+typedef void (APIENTRY * PFNGLBINORMAL3FVEXTPROC) (const GLfloat *v);
+typedef void (APIENTRY * PFNGLBINORMAL3IEXTPROC) (GLint bx, GLint by, GLint bz);
+typedef void (APIENTRY * PFNGLBINORMAL3IVEXTPROC) (const GLint *v);
+typedef void (APIENTRY * PFNGLBINORMAL3SEXTPROC) (GLshort bx, GLshort by, GLshort bz);
+typedef void (APIENTRY * PFNGLBINORMAL3SVEXTPROC) (const GLshort *v);
+typedef void (APIENTRY * PFNGLTANGENTPOINTEREXTPROC) (GLenum type, GLsizei stride, const GLvoid *pointer);
+typedef void (APIENTRY * PFNGLBINORMALPOINTEREXTPROC) (GLenum type, GLsizei stride, const GLvoid *pointer);
+#endif
+
+#ifndef GL_EXT_texture_env_combine
+#define GL_EXT_texture_env_combine 1
+#endif
+
+#ifndef GL_APPLE_specular_vector
+#define GL_APPLE_specular_vector 1
+#endif
+
+#ifndef GL_APPLE_transform_hint
+#define GL_APPLE_transform_hint 1
+#endif
+
+#ifndef GL_SGIX_fog_scale
+#define GL_SGIX_fog_scale 1
+#endif
+
+#ifndef GL_SUNX_constant_data
+#define GL_SUNX_constant_data 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glFinishTextureSUNX (void);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLFINISHTEXTURESUNXPROC) (void);
+#endif
+
+#ifndef GL_SUN_global_alpha
+#define GL_SUN_global_alpha 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glGlobalAlphaFactorbSUN (GLbyte);
+extern void APIENTRY glGlobalAlphaFactorsSUN (GLshort);
+extern void APIENTRY glGlobalAlphaFactoriSUN (GLint);
+extern void APIENTRY glGlobalAlphaFactorfSUN (GLfloat);
+extern void APIENTRY glGlobalAlphaFactordSUN (GLdouble);
+extern void APIENTRY glGlobalAlphaFactorubSUN (GLubyte);
+extern void APIENTRY glGlobalAlphaFactorusSUN (GLushort);
+extern void APIENTRY glGlobalAlphaFactoruiSUN (GLuint);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLGLOBALALPHAFACTORBSUNPROC) (GLbyte factor);
+typedef void (APIENTRY * PFNGLGLOBALALPHAFACTORSSUNPROC) (GLshort factor);
+typedef void (APIENTRY * PFNGLGLOBALALPHAFACTORISUNPROC) (GLint factor);
+typedef void (APIENTRY * PFNGLGLOBALALPHAFACTORFSUNPROC) (GLfloat factor);
+typedef void (APIENTRY * PFNGLGLOBALALPHAFACTORDSUNPROC) (GLdouble factor);
+typedef void (APIENTRY * PFNGLGLOBALALPHAFACTORUBSUNPROC) (GLubyte factor);
+typedef void (APIENTRY * PFNGLGLOBALALPHAFACTORUSSUNPROC) (GLushort factor);
+typedef void (APIENTRY * PFNGLGLOBALALPHAFACTORUISUNPROC) (GLuint factor);
+#endif
+
+#ifndef GL_SUN_triangle_list
+#define GL_SUN_triangle_list 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glReplacementCodeuiSUN (GLuint);
+extern void APIENTRY glReplacementCodeusSUN (GLushort);
+extern void APIENTRY glReplacementCodeubSUN (GLubyte);
+extern void APIENTRY glReplacementCodeuivSUN (const GLuint *);
+extern void APIENTRY glReplacementCodeusvSUN (const GLushort *);
+extern void APIENTRY glReplacementCodeubvSUN (const GLubyte *);
+extern void APIENTRY glReplacementCodePointerSUN (GLenum, GLsizei, const GLvoid* *);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLREPLACEMENTCODEUISUNPROC) (GLuint code);
+typedef void (APIENTRY * PFNGLREPLACEMENTCODEUSSUNPROC) (GLushort code);
+typedef void (APIENTRY * PFNGLREPLACEMENTCODEUBSUNPROC) (GLubyte code);
+typedef void (APIENTRY * PFNGLREPLACEMENTCODEUIVSUNPROC) (const GLuint *code);
+typedef void (APIENTRY * PFNGLREPLACEMENTCODEUSVSUNPROC) (const GLushort *code);
+typedef void (APIENTRY * PFNGLREPLACEMENTCODEUBVSUNPROC) (const GLubyte *code);
+typedef void (APIENTRY * PFNGLREPLACEMENTCODEPOINTERSUNPROC) (GLenum type, GLsizei stride, const GLvoid* *pointer);
+#endif
+
+#ifndef GL_SUN_vertex
+#define GL_SUN_vertex 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glColor4ubVertex2fSUN (GLubyte, GLubyte, GLubyte, GLubyte, GLfloat, GLfloat);
+extern void APIENTRY glColor4ubVertex2fvSUN (const GLubyte *, const GLfloat *);
+extern void APIENTRY glColor4ubVertex3fSUN (GLubyte, GLubyte, GLubyte, GLubyte, GLfloat, GLfloat, GLfloat);
+extern void APIENTRY glColor4ubVertex3fvSUN (const GLubyte *, const GLfloat *);
+extern void APIENTRY glColor3fVertex3fSUN (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
+extern void APIENTRY glColor3fVertex3fvSUN (const GLfloat *, const GLfloat *);
+extern void APIENTRY glNormal3fVertex3fSUN (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
+extern void APIENTRY glNormal3fVertex3fvSUN (const GLfloat *, const GLfloat *);
+extern void APIENTRY glColor4fNormal3fVertex3fSUN (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
+extern void APIENTRY glColor4fNormal3fVertex3fvSUN (const GLfloat *, const GLfloat *, const GLfloat *);
+extern void APIENTRY glTexCoord2fVertex3fSUN (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
+extern void APIENTRY glTexCoord2fVertex3fvSUN (const GLfloat *, const GLfloat *);
+extern void APIENTRY glTexCoord4fVertex4fSUN (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
+extern void APIENTRY glTexCoord4fVertex4fvSUN (const GLfloat *, const GLfloat *);
+extern void APIENTRY glTexCoord2fColor4ubVertex3fSUN (GLfloat, GLfloat, GLubyte, GLubyte, GLubyte, GLubyte, GLfloat, GLfloat, GLfloat);
+extern void APIENTRY glTexCoord2fColor4ubVertex3fvSUN (const GLfloat *, const GLubyte *, const GLfloat *);
+extern void APIENTRY glTexCoord2fColor3fVertex3fSUN (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
+extern void APIENTRY glTexCoord2fColor3fVertex3fvSUN (const GLfloat *, const GLfloat *, const GLfloat *);
+extern void APIENTRY glTexCoord2fNormal3fVertex3fSUN (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
+extern void APIENTRY glTexCoord2fNormal3fVertex3fvSUN (const GLfloat *, const GLfloat *, const GLfloat *);
+extern void APIENTRY glTexCoord2fColor4fNormal3fVertex3fSUN (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
+extern void APIENTRY glTexCoord2fColor4fNormal3fVertex3fvSUN (const GLfloat *, const GLfloat *, const GLfloat *, const GLfloat *);
+extern void APIENTRY glTexCoord4fColor4fNormal3fVertex4fSUN (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
+extern void APIENTRY glTexCoord4fColor4fNormal3fVertex4fvSUN (const GLfloat *, const GLfloat *, const GLfloat *, const GLfloat *);
+extern void APIENTRY glReplacementCodeuiVertex3fSUN (GLenum, GLfloat, GLfloat, GLfloat);
+extern void APIENTRY glReplacementCodeuiVertex3fvSUN (const GLenum *, const GLfloat *);
+extern void APIENTRY glReplacementCodeuiColor4ubVertex3fSUN (GLenum, GLubyte, GLubyte, GLubyte, GLubyte, GLfloat, GLfloat, GLfloat);
+extern void APIENTRY glReplacementCodeuiColor4ubVertex3fvSUN (const GLenum *, const GLubyte *, const GLfloat *);
+extern void APIENTRY glReplacementCodeuiColor3fVertex3fSUN (GLenum, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
+extern void APIENTRY glReplacementCodeuiColor3fVertex3fvSUN (const GLenum *, const GLfloat *, const GLfloat *);
+extern void APIENTRY glReplacementCodeuiNormal3fVertex3fSUN (GLenum, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
+extern void APIENTRY glReplacementCodeuiNormal3fVertex3fvSUN (const GLenum *, const GLfloat *, const GLfloat *);
+extern void APIENTRY glReplacementCodeuiColor4fNormal3fVertex3fSUN (GLenum, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
+extern void APIENTRY glReplacementCodeuiColor4fNormal3fVertex3fvSUN (const GLenum *, const GLfloat *, const GLfloat *, const GLfloat *);
+extern void APIENTRY glReplacementCodeuiTexCoord2fVertex3fSUN (GLenum, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
+extern void APIENTRY glReplacementCodeuiTexCoord2fVertex3fvSUN (const GLenum *, const GLfloat *, const GLfloat *);
+extern void APIENTRY glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN (GLenum, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
+extern void APIENTRY glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN (const GLenum *, const GLfloat *, const GLfloat *, const GLfloat *);
+extern void APIENTRY glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN (GLenum, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
+extern void APIENTRY glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN (const GLenum *, const GLfloat *, const GLfloat *, const GLfloat *, const GLfloat *);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLCOLOR4UBVERTEX2FSUNPROC) (GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y);
+typedef void (APIENTRY * PFNGLCOLOR4UBVERTEX2FVSUNPROC) (const GLubyte *c, const GLfloat *v);
+typedef void (APIENTRY * PFNGLCOLOR4UBVERTEX3FSUNPROC) (GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y, GLfloat z);
+typedef void (APIENTRY * PFNGLCOLOR4UBVERTEX3FVSUNPROC) (const GLubyte *c, const GLfloat *v);
+typedef void (APIENTRY * PFNGLCOLOR3FVERTEX3FSUNPROC) (GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat z);
+typedef void (APIENTRY * PFNGLCOLOR3FVERTEX3FVSUNPROC) (const GLfloat *c, const GLfloat *v);
+typedef void (APIENTRY * PFNGLNORMAL3FVERTEX3FSUNPROC) (GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z);
+typedef void (APIENTRY * PFNGLNORMAL3FVERTEX3FVSUNPROC) (const GLfloat *n, const GLfloat *v);
+typedef void (APIENTRY * PFNGLCOLOR4FNORMAL3FVERTEX3FSUNPROC) (GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z);
+typedef void (APIENTRY * PFNGLCOLOR4FNORMAL3FVERTEX3FVSUNPROC) (const GLfloat *c, const GLfloat *n, const GLfloat *v);
+typedef void (APIENTRY * PFNGLTEXCOORD2FVERTEX3FSUNPROC) (GLfloat s, GLfloat t, GLfloat x, GLfloat y, GLfloat z);
+typedef void (APIENTRY * PFNGLTEXCOORD2FVERTEX3FVSUNPROC) (const GLfloat *tc, const GLfloat *v);
+typedef void (APIENTRY * PFNGLTEXCOORD4FVERTEX4FSUNPROC) (GLfloat s, GLfloat t, GLfloat p, GLfloat q, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+typedef void (APIENTRY * PFNGLTEXCOORD4FVERTEX4FVSUNPROC) (const GLfloat *tc, const GLfloat *v);
+typedef void (APIENTRY * PFNGLTEXCOORD2FCOLOR4UBVERTEX3FSUNPROC) (GLfloat s, GLfloat t, GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y, GLfloat z);
+typedef void (APIENTRY * PFNGLTEXCOORD2FCOLOR4UBVERTEX3FVSUNPROC) (const GLfloat *tc, const GLubyte *c, const GLfloat *v);
+typedef void (APIENTRY * PFNGLTEXCOORD2FCOLOR3FVERTEX3FSUNPROC) (GLfloat s, GLfloat t, GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat z);
+typedef void (APIENTRY * PFNGLTEXCOORD2FCOLOR3FVERTEX3FVSUNPROC) (const GLfloat *tc, const GLfloat *c, const GLfloat *v);
+typedef void (APIENTRY * PFNGLTEXCOORD2FNORMAL3FVERTEX3FSUNPROC) (GLfloat s, GLfloat t, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z);
+typedef void (APIENTRY * PFNGLTEXCOORD2FNORMAL3FVERTEX3FVSUNPROC) (const GLfloat *tc, const GLfloat *n, const GLfloat *v);
+typedef void (APIENTRY * PFNGLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC) (GLfloat s, GLfloat t, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z);
+typedef void (APIENTRY * PFNGLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC) (const GLfloat *tc, const GLfloat *c, const GLfloat *n, const GLfloat *v);
+typedef void (APIENTRY * PFNGLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FSUNPROC) (GLfloat s, GLfloat t, GLfloat p, GLfloat q, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+typedef void (APIENTRY * PFNGLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FVSUNPROC) (const GLfloat *tc, const GLfloat *c, const GLfloat *n, const GLfloat *v);
+typedef void (APIENTRY * PFNGLREPLACEMENTCODEUIVERTEX3FSUNPROC) (GLenum rc, GLfloat x, GLfloat y, GLfloat z);
+typedef void (APIENTRY * PFNGLREPLACEMENTCODEUIVERTEX3FVSUNPROC) (const GLenum *rc, const GLfloat *v);
+typedef void (APIENTRY * PFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FSUNPROC) (GLenum rc, GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y, GLfloat z);
+typedef void (APIENTRY * PFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FVSUNPROC) (const GLenum *rc, const GLubyte *c, const GLfloat *v);
+typedef void (APIENTRY * PFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FSUNPROC) (GLenum rc, GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat z);
+typedef void (APIENTRY * PFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FVSUNPROC) (const GLenum *rc, const GLfloat *c, const GLfloat *v);
+typedef void (APIENTRY * PFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FSUNPROC) (GLenum rc, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z);
+typedef void (APIENTRY * PFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FVSUNPROC) (const GLenum *rc, const GLfloat *n, const GLfloat *v);
+typedef void (APIENTRY * PFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FSUNPROC) (GLenum rc, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z);
+typedef void (APIENTRY * PFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FVSUNPROC) (const GLenum *rc, const GLfloat *c, const GLfloat *n, const GLfloat *v);
+typedef void (APIENTRY * PFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FSUNPROC) (GLenum rc, GLfloat s, GLfloat t, GLfloat x, GLfloat y, GLfloat z);
+typedef void (APIENTRY * PFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FVSUNPROC) (const GLenum *rc, const GLfloat *tc, const GLfloat *v);
+typedef void (APIENTRY * PFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FSUNPROC) (GLenum rc, GLfloat s, GLfloat t, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z);
+typedef void (APIENTRY * PFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FVSUNPROC) (const GLenum *rc, const GLfloat *tc, const GLfloat *n, const GLfloat *v);
+typedef void (APIENTRY * PFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC) (GLenum rc, GLfloat s, GLfloat t, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z);
+typedef void (APIENTRY * PFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC) (const GLenum *rc, const GLfloat *tc, const GLfloat *c, const GLfloat *n, const GLfloat *v);
+#endif
+
+#ifndef GL_EXT_blend_func_separate
+#define GL_EXT_blend_func_separate 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glBlendFuncSeparateEXT (GLenum, GLenum, GLenum, GLenum);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLBLENDFUNCSEPARATEEXTPROC) (GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);
+#endif
+
+#ifndef GL_INGR_color_clamp
+#define GL_INGR_color_clamp 1
+#endif
+
+#ifndef GL_INGR_interlace_read
+#define GL_INGR_interlace_read 1
+#endif
+
+#ifndef GL_EXT_stencil_wrap
+#define GL_EXT_stencil_wrap 1
+#endif
+
+#ifndef GL_EXT_422_pixels
+#define GL_EXT_422_pixels 1
+#endif
+
+#ifndef GL_NV_texgen_reflection
+#define GL_NV_texgen_reflection 1
+#endif
+
+#ifndef GL_SUN_convolution_border_modes
+#define GL_SUN_convolution_border_modes 1
+#endif
+
+#ifndef GL_EXT_texture_env_add
+#define GL_EXT_texture_env_add 1
+#endif
+
+#ifndef GL_EXT_texture_lod_bias
+#define GL_EXT_texture_lod_bias 1
+#endif
+
+#ifndef GL_EXT_texture_filter_anisotropic
+#define GL_EXT_texture_filter_anisotropic 1
+#endif
+
+#ifndef GL_EXT_vertex_weighting
+#define GL_EXT_vertex_weighting 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glVertexWeightfEXT (GLfloat);
+extern void APIENTRY glVertexWeightfvEXT (const GLfloat *);
+extern void APIENTRY glVertexWeightPointerEXT (GLsizei, GLenum, GLsizei, const GLvoid *);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLVERTEXWEIGHTFEXTPROC) (GLfloat weight);
+typedef void (APIENTRY * PFNGLVERTEXWEIGHTFVEXTPROC) (const GLfloat *weight);
+typedef void (APIENTRY * PFNGLVERTEXWEIGHTPOINTEREXTPROC) (GLsizei size, GLenum type, GLsizei stride, const GLvoid *pointer);
+#endif
+
+#ifndef GL_NV_light_max_exponent
+#define GL_NV_light_max_exponent 1
+#endif
+
+#ifndef GL_NV_vertex_array_range
+#define GL_NV_vertex_array_range 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glFlushVertexArrayRangeNV (void);
+extern void APIENTRY glVertexArrayRangeNV (GLsizei, const GLvoid *);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLFLUSHVERTEXARRAYRANGENVPROC) (void);
+typedef void (APIENTRY * PFNGLVERTEXARRAYRANGENVPROC) (GLsizei size, const GLvoid *pointer);
+#endif
+
+#ifndef GL_NV_register_combiners
+#define GL_NV_register_combiners 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glCombinerParameterfvNV (GLenum, const GLfloat *);
+extern void APIENTRY glCombinerParameterfNV (GLenum, GLfloat);
+extern void APIENTRY glCombinerParameterivNV (GLenum, const GLint *);
+extern void APIENTRY glCombinerParameteriNV (GLenum, GLint);
+extern void APIENTRY glCombinerInputNV (GLenum, GLenum, GLenum, GLenum, GLenum, GLenum);
+extern void APIENTRY glCombinerOutputNV (GLenum, GLenum, GLenum, GLenum, GLenum, GLenum, GLenum, GLboolean, GLboolean, GLboolean);
+extern void APIENTRY glFinalCombinerInputNV (GLenum, GLenum, GLenum, GLenum);
+extern void APIENTRY glGetCombinerInputParameterfvNV (GLenum, GLenum, GLenum, GLenum, GLfloat *);
+extern void APIENTRY glGetCombinerInputParameterivNV (GLenum, GLenum, GLenum, GLenum, GLint *);
+extern void APIENTRY glGetCombinerOutputParameterfvNV (GLenum, GLenum, GLenum, GLfloat *);
+extern void APIENTRY glGetCombinerOutputParameterivNV (GLenum, GLenum, GLenum, GLint *);
+extern void APIENTRY glGetFinalCombinerInputParameterfvNV (GLenum, GLenum, GLfloat *);
+extern void APIENTRY glGetFinalCombinerInputParameterivNV (GLenum, GLenum, GLint *);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLCOMBINERPARAMETERFVNVPROC) (GLenum pname, const GLfloat *params);
+typedef void (APIENTRY * PFNGLCOMBINERPARAMETERFNVPROC) (GLenum pname, GLfloat param);
+typedef void (APIENTRY * PFNGLCOMBINERPARAMETERIVNVPROC) (GLenum pname, const GLint *params);
+typedef void (APIENTRY * PFNGLCOMBINERPARAMETERINVPROC) (GLenum pname, GLint param);
+typedef void (APIENTRY * PFNGLCOMBINERINPUTNVPROC) (GLenum stage, GLenum portion, GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage);
+typedef void (APIENTRY * PFNGLCOMBINEROUTPUTNVPROC) (GLenum stage, GLenum portion, GLenum abOutput, GLenum cdOutput, GLenum sumOutput, GLenum scale, GLenum bias, GLboolean abDotProduct, GLboolean cdDotProduct, GLboolean muxSum);
+typedef void (APIENTRY * PFNGLFINALCOMBINERINPUTNVPROC) (GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage);
+typedef void (APIENTRY * PFNGLGETCOMBINERINPUTPARAMETERFVNVPROC) (GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLfloat *params);
+typedef void (APIENTRY * PFNGLGETCOMBINERINPUTPARAMETERIVNVPROC) (GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLint *params);
+typedef void (APIENTRY * PFNGLGETCOMBINEROUTPUTPARAMETERFVNVPROC) (GLenum stage, GLenum portion, GLenum pname, GLfloat *params);
+typedef void (APIENTRY * PFNGLGETCOMBINEROUTPUTPARAMETERIVNVPROC) (GLenum stage, GLenum portion, GLenum pname, GLint *params);
+typedef void (APIENTRY * PFNGLGETFINALCOMBINERINPUTPARAMETERFVNVPROC) (GLenum variable, GLenum pname, GLfloat *params);
+typedef void (APIENTRY * PFNGLGETFINALCOMBINERINPUTPARAMETERIVNVPROC) (GLenum variable, GLenum pname, GLint *params);
+#endif
+
+#ifndef GL_NV_fog_distance
+#define GL_NV_fog_distance 1
+#endif
+
+#ifndef GL_NV_texgen_emboss
+#define GL_NV_texgen_emboss 1
+#endif
+
+#ifndef GL_NV_blend_square
+#define GL_NV_blend_square 1
+#endif
+
+#ifndef GL_NV_texture_env_combine4
+#define GL_NV_texture_env_combine4 1
+#endif
+
+#ifndef GL_MESA_resize_buffers
+#define GL_MESA_resize_buffers 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glResizeBuffersMESA (void);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLRESIZEBUFFERSMESAPROC) (void);
+#endif
+
+#ifndef GL_MESA_window_pos
+#define GL_MESA_window_pos 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glWindowPos2dMESA (GLdouble, GLdouble);
+extern void APIENTRY glWindowPos2dvMESA (const GLdouble *);
+extern void APIENTRY glWindowPos2fMESA (GLfloat, GLfloat);
+extern void APIENTRY glWindowPos2fvMESA (const GLfloat *);
+extern void APIENTRY glWindowPos2iMESA (GLint, GLint);
+extern void APIENTRY glWindowPos2ivMESA (const GLint *);
+extern void APIENTRY glWindowPos2sMESA (GLshort, GLshort);
+extern void APIENTRY glWindowPos2svMESA (const GLshort *);
+extern void APIENTRY glWindowPos3dMESA (GLdouble, GLdouble, GLdouble);
+extern void APIENTRY glWindowPos3dvMESA (const GLdouble *);
+extern void APIENTRY glWindowPos3fMESA (GLfloat, GLfloat, GLfloat);
+extern void APIENTRY glWindowPos3fvMESA (const GLfloat *);
+extern void APIENTRY glWindowPos3iMESA (GLint, GLint, GLint);
+extern void APIENTRY glWindowPos3ivMESA (const GLint *);
+extern void APIENTRY glWindowPos3sMESA (GLshort, GLshort, GLshort);
+extern void APIENTRY glWindowPos3svMESA (const GLshort *);
+extern void APIENTRY glWindowPos4dMESA (GLdouble, GLdouble, GLdouble, GLdouble);
+extern void APIENTRY glWindowPos4dvMESA (const GLdouble *);
+extern void APIENTRY glWindowPos4fMESA (GLfloat, GLfloat, GLfloat, GLfloat);
+extern void APIENTRY glWindowPos4fvMESA (const GLfloat *);
+extern void APIENTRY glWindowPos4iMESA (GLint, GLint, GLint, GLint);
+extern void APIENTRY glWindowPos4ivMESA (const GLint *);
+extern void APIENTRY glWindowPos4sMESA (GLshort, GLshort, GLshort, GLshort);
+extern void APIENTRY glWindowPos4svMESA (const GLshort *);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLWINDOWPOS2DMESAPROC) (GLdouble x, GLdouble y);
+typedef void (APIENTRY * PFNGLWINDOWPOS2DVMESAPROC) (const GLdouble *v);
+typedef void (APIENTRY * PFNGLWINDOWPOS2FMESAPROC) (GLfloat x, GLfloat y);
+typedef void (APIENTRY * PFNGLWINDOWPOS2FVMESAPROC) (const GLfloat *v);
+typedef void (APIENTRY * PFNGLWINDOWPOS2IMESAPROC) (GLint x, GLint y);
+typedef void (APIENTRY * PFNGLWINDOWPOS2IVMESAPROC) (const GLint *v);
+typedef void (APIENTRY * PFNGLWINDOWPOS2SMESAPROC) (GLshort x, GLshort y);
+typedef void (APIENTRY * PFNGLWINDOWPOS2SVMESAPROC) (const GLshort *v);
+typedef void (APIENTRY * PFNGLWINDOWPOS3DMESAPROC) (GLdouble x, GLdouble y, GLdouble z);
+typedef void (APIENTRY * PFNGLWINDOWPOS3DVMESAPROC) (const GLdouble *v);
+typedef void (APIENTRY * PFNGLWINDOWPOS3FMESAPROC) (GLfloat x, GLfloat y, GLfloat z);
+typedef void (APIENTRY * PFNGLWINDOWPOS3FVMESAPROC) (const GLfloat *v);
+typedef void (APIENTRY * PFNGLWINDOWPOS3IMESAPROC) (GLint x, GLint y, GLint z);
+typedef void (APIENTRY * PFNGLWINDOWPOS3IVMESAPROC) (const GLint *v);
+typedef void (APIENTRY * PFNGLWINDOWPOS3SMESAPROC) (GLshort x, GLshort y, GLshort z);
+typedef void (APIENTRY * PFNGLWINDOWPOS3SVMESAPROC) (const GLshort *v);
+typedef void (APIENTRY * PFNGLWINDOWPOS4DMESAPROC) (GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+typedef void (APIENTRY * PFNGLWINDOWPOS4DVMESAPROC) (const GLdouble *v);
+typedef void (APIENTRY * PFNGLWINDOWPOS4FMESAPROC) (GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+typedef void (APIENTRY * PFNGLWINDOWPOS4FVMESAPROC) (const GLfloat *v);
+typedef void (APIENTRY * PFNGLWINDOWPOS4IMESAPROC) (GLint x, GLint y, GLint z, GLint w);
+typedef void (APIENTRY * PFNGLWINDOWPOS4IVMESAPROC) (const GLint *v);
+typedef void (APIENTRY * PFNGLWINDOWPOS4SMESAPROC) (GLshort x, GLshort y, GLshort z, GLshort w);
+typedef void (APIENTRY * PFNGLWINDOWPOS4SVMESAPROC) (const GLshort *v);
+#endif
+
+#ifndef GL_IBM_cull_vertex
+#define GL_IBM_cull_vertex 1
+#endif
+
+#ifndef GL_IBM_multimode_draw_arrays
+#define GL_IBM_multimode_draw_arrays 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glMultiModeDrawArraysIBM (GLenum, const GLint *, const GLsizei *, GLsizei, GLint);
+extern void APIENTRY glMultiModeDrawElementsIBM (const GLenum *, const GLsizei *, GLenum, const GLvoid* *, GLsizei, GLint);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLMULTIMODEDRAWARRAYSIBMPROC) (GLenum mode, const GLint *first, const GLsizei *count, GLsizei primcount, GLint modestride);
+typedef void (APIENTRY * PFNGLMULTIMODEDRAWELEMENTSIBMPROC) (const GLenum *mode, const GLsizei *count, GLenum type, const GLvoid* *indices, GLsizei primcount, GLint modestride);
+#endif
+
+#ifndef GL_IBM_vertex_array_lists
+#define GL_IBM_vertex_array_lists 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glColorPointerListIBM (GLint, GLenum, GLint, const GLvoid* *, GLint);
+extern void APIENTRY glSecondaryColorPointerListIBM (GLint, GLenum, GLint, const GLvoid* *, GLint);
+extern void APIENTRY glEdgeFlagPointerListIBM (GLint, const GLboolean* *, GLint);
+extern void APIENTRY glFogCoordPointerListIBM (GLenum, GLint, const GLvoid* *, GLint);
+extern void APIENTRY glIndexPointerListIBM (GLenum, GLint, const GLvoid* *, GLint);
+extern void APIENTRY glNormalPointerListIBM (GLenum, GLint, const GLvoid* *, GLint);
+extern void APIENTRY glTexCoordPointerListIBM (GLint, GLenum, GLint, const GLvoid* *, GLint);
+extern void APIENTRY glVertexPointerListIBM (GLint, GLenum, GLint, const GLvoid* *, GLint);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLCOLORPOINTERLISTIBMPROC) (GLint size, GLenum type, GLint stride, const GLvoid* *pointer, GLint ptrstride);
+typedef void (APIENTRY * PFNGLSECONDARYCOLORPOINTERLISTIBMPROC) (GLint size, GLenum type, GLint stride, const GLvoid* *pointer, GLint ptrstride);
+typedef void (APIENTRY * PFNGLEDGEFLAGPOINTERLISTIBMPROC) (GLint stride, const GLboolean* *pointer, GLint ptrstride);
+typedef void (APIENTRY * PFNGLFOGCOORDPOINTERLISTIBMPROC) (GLenum type, GLint stride, const GLvoid* *pointer, GLint ptrstride);
+typedef void (APIENTRY * PFNGLINDEXPOINTERLISTIBMPROC) (GLenum type, GLint stride, const GLvoid* *pointer, GLint ptrstride);
+typedef void (APIENTRY * PFNGLNORMALPOINTERLISTIBMPROC) (GLenum type, GLint stride, const GLvoid* *pointer, GLint ptrstride);
+typedef void (APIENTRY * PFNGLTEXCOORDPOINTERLISTIBMPROC) (GLint size, GLenum type, GLint stride, const GLvoid* *pointer, GLint ptrstride);
+typedef void (APIENTRY * PFNGLVERTEXPOINTERLISTIBMPROC) (GLint size, GLenum type, GLint stride, const GLvoid* *pointer, GLint ptrstride);
+#endif
+
+#ifndef GL_SGIX_subsample
+#define GL_SGIX_subsample 1
+#endif
+
+#ifndef GL_SGIX_ycrcba
+#define GL_SGIX_ycrcba 1
+#endif
+
+#ifndef GL_SGIX_ycrcb_subsample
+#define GL_SGIX_ycrcb_subsample 1
+#endif
+
+#ifndef GL_SGIX_depth_pass_instrument
+#define GL_SGIX_depth_pass_instrument 1
+#endif
+
+#ifndef GL_3DFX_texture_compression_FXT1
+#define GL_3DFX_texture_compression_FXT1 1
+#endif
+
+#ifndef GL_3DFX_multisample
+#define GL_3DFX_multisample 1
+#endif
+
+#ifndef GL_3DFX_tbuffer
+#define GL_3DFX_tbuffer 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glTbufferMask3DFX (GLuint);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLTBUFFERMASK3DFXPROC) (GLuint mask);
+#endif
+
+#ifndef GL_EXT_multisample
+#define GL_EXT_multisample 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glSampleMaskEXT (GLclampf, GLboolean);
+extern void APIENTRY glSamplePatternEXT (GLenum);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLSAMPLEMASKEXTPROC) (GLclampf value, GLboolean invert);
+typedef void (APIENTRY * PFNGLSAMPLEPATTERNEXTPROC) (GLenum pattern);
+#endif
+
+#ifndef GL_SGI_vertex_preclip
+#define GL_SGI_vertex_preclip 1
+#endif
+
+#ifndef GL_SGIX_convolution_accuracy
+#define GL_SGIX_convolution_accuracy 1
+#endif
+
+#ifndef GL_SGIX_resample
+#define GL_SGIX_resample 1
+#endif
+
+#ifndef GL_SGIS_point_line_texgen
+#define GL_SGIS_point_line_texgen 1
+#endif
+
+#ifndef GL_SGIS_texture_color_mask
+#define GL_SGIS_texture_color_mask 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glTextureColorMaskSGIS (GLboolean, GLboolean, GLboolean, GLboolean);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLTEXTURECOLORMASKSGISPROC) (GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
diff --git a/code/renderer/glext_console.h b/code/renderer/glext_console.h
new file mode 100644
index 0000000..0220e94
--- /dev/null
+++ b/code/renderer/glext_console.h
@@ -0,0 +1,2521 @@
+#ifndef __glext_h_
+#define __glext_h_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+** License Applicability. Except to the extent portions of this file are
+** made subject to an alternative license as permitted in the SGI Free
+** Software License B, Version 1.1 (the "License"), the contents of this
+** file are subject only to the provisions of the License. You may not use
+** this file except in compliance with the License. You may obtain a copy
+** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+** 
+** http://oss.sgi.com/projects/FreeB
+** 
+** Note that, as provided in the License, the Software is distributed on an
+** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+** 
+** Original Code. The Original Code is: OpenGL Sample Implementation,
+** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+** Copyright in any portions created by third parties is as indicated
+** elsewhere herein. All Rights Reserved.
+** 
+** Additional Notice Provisions: This software was created using the
+** OpenGL(R) version 1.2.1 Sample Implementation published by SGI, but has
+** not been independently verified as being compliant with the OpenGL(R)
+** version 1.2.1 Specification.
+*/
+
+/*************************************************************/
+
+/* Header file version number, required by OpenGL ABI for Linux */
+#define GL_GLEXT_VERSION 6
+
+#ifndef GL_VERSION_1_2
+#define GL_CONSTANT_COLOR                 0x8001
+#define GL_ONE_MINUS_CONSTANT_COLOR       0x8002
+#define GL_CONSTANT_ALPHA                 0x8003
+#define GL_ONE_MINUS_CONSTANT_ALPHA       0x8004
+#define GL_BLEND_COLOR                    0x8005
+#define GL_FUNC_ADD                       0x8006
+#define GL_MIN                            0x8007
+#define GL_MAX                            0x8008
+#define GL_BLEND_EQUATION                 0x8009
+#define GL_FUNC_SUBTRACT                  0x800A
+#define GL_FUNC_REVERSE_SUBTRACT          0x800B
+#define GL_CONVOLUTION_1D                 0x8010
+#define GL_CONVOLUTION_2D                 0x8011
+#define GL_SEPARABLE_2D                   0x8012
+#define GL_CONVOLUTION_BORDER_MODE        0x8013
+#define GL_CONVOLUTION_FILTER_SCALE       0x8014
+#define GL_CONVOLUTION_FILTER_BIAS        0x8015
+#define GL_REDUCE                         0x8016
+#define GL_CONVOLUTION_FORMAT             0x8017
+#define GL_CONVOLUTION_WIDTH              0x8018
+#define GL_CONVOLUTION_HEIGHT             0x8019
+#define GL_MAX_CONVOLUTION_WIDTH          0x801A
+#define GL_MAX_CONVOLUTION_HEIGHT         0x801B
+#define GL_POST_CONVOLUTION_RED_SCALE     0x801C
+#define GL_POST_CONVOLUTION_GREEN_SCALE   0x801D
+#define GL_POST_CONVOLUTION_BLUE_SCALE    0x801E
+#define GL_POST_CONVOLUTION_ALPHA_SCALE   0x801F
+#define GL_POST_CONVOLUTION_RED_BIAS      0x8020
+#define GL_POST_CONVOLUTION_GREEN_BIAS    0x8021
+#define GL_POST_CONVOLUTION_BLUE_BIAS     0x8022
+#define GL_POST_CONVOLUTION_ALPHA_BIAS    0x8023
+#define GL_HISTOGRAM                      0x8024
+#define GL_PROXY_HISTOGRAM                0x8025
+#define GL_HISTOGRAM_WIDTH                0x8026
+#define GL_HISTOGRAM_FORMAT               0x8027
+#define GL_HISTOGRAM_RED_SIZE             0x8028
+#define GL_HISTOGRAM_GREEN_SIZE           0x8029
+#define GL_HISTOGRAM_BLUE_SIZE            0x802A
+#define GL_HISTOGRAM_ALPHA_SIZE           0x802B
+#define GL_HISTOGRAM_LUMINANCE_SIZE       0x802C
+#define GL_HISTOGRAM_SINK                 0x802D
+#define GL_MINMAX                         0x802E
+#define GL_MINMAX_FORMAT                  0x802F
+#define GL_MINMAX_SINK                    0x8030
+#define GL_TABLE_TOO_LARGE                0x8031
+#define GL_UNSIGNED_BYTE_3_3_2            0x8032
+#define GL_UNSIGNED_SHORT_4_4_4_4         0x8033
+#define GL_UNSIGNED_SHORT_5_5_5_1         0x8034
+#define GL_UNSIGNED_INT_8_8_8_8           0x8035
+#define GL_UNSIGNED_INT_10_10_10_2        0x8036
+#define GL_RESCALE_NORMAL                 0x803A
+#define GL_UNSIGNED_BYTE_2_3_3_REV        0x8362
+#define GL_UNSIGNED_SHORT_5_6_5           0x8363
+#define GL_UNSIGNED_SHORT_5_6_5_REV       0x8364
+#define GL_UNSIGNED_SHORT_4_4_4_4_REV     0x8365
+#define GL_UNSIGNED_SHORT_1_5_5_5_REV     0x8366
+#define GL_UNSIGNED_INT_8_8_8_8_REV       0x8367
+#define GL_UNSIGNED_INT_2_10_10_10_REV    0x8368
+#define GL_COLOR_MATRIX                   0x80B1
+#define GL_COLOR_MATRIX_STACK_DEPTH       0x80B2
+#define GL_MAX_COLOR_MATRIX_STACK_DEPTH   0x80B3
+#define GL_POST_COLOR_MATRIX_RED_SCALE    0x80B4
+#define GL_POST_COLOR_MATRIX_GREEN_SCALE  0x80B5
+#define GL_POST_COLOR_MATRIX_BLUE_SCALE   0x80B6
+#define GL_POST_COLOR_MATRIX_ALPHA_SCALE  0x80B7
+#define GL_POST_COLOR_MATRIX_RED_BIAS     0x80B8
+#define GL_POST_COLOR_MATRIX_GREEN_BIAS   0x80B9
+#define GL_POST_COLOR_MATRIX_BLUE_BIAS    0x80BA
+#define GL_COLOR_TABLE                    0x80D0
+#define GL_POST_CONVOLUTION_COLOR_TABLE   0x80D1
+#define GL_POST_COLOR_MATRIX_COLOR_TABLE  0x80D2
+#define GL_PROXY_COLOR_TABLE              0x80D3
+#define GL_PROXY_POST_CONVOLUTION_COLOR_TABLE 0x80D4
+#define GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE 0x80D5
+#define GL_COLOR_TABLE_SCALE              0x80D6
+#define GL_COLOR_TABLE_BIAS               0x80D7
+#define GL_COLOR_TABLE_FORMAT             0x80D8
+#define GL_COLOR_TABLE_WIDTH              0x80D9
+#define GL_COLOR_TABLE_RED_SIZE           0x80DA
+#define GL_COLOR_TABLE_GREEN_SIZE         0x80DB
+#define GL_COLOR_TABLE_BLUE_SIZE          0x80DC
+#define GL_COLOR_TABLE_ALPHA_SIZE         0x80DD
+#define GL_COLOR_TABLE_LUMINANCE_SIZE     0x80DE
+#define GL_COLOR_TABLE_INTENSITY_SIZE     0x80DF
+#define GL_CLAMP_TO_EDGE                  0x812F
+#define GL_TEXTURE_MIN_LOD                0x813A
+#define GL_TEXTURE_MAX_LOD                0x813B
+#define GL_TEXTURE_BASE_LEVEL             0x813C
+#define GL_TEXTURE_MAX_LEVEL              0x813D
+#define GL_VSYNC                          0x813F
+#endif
+
+#ifndef GL_ARB_multitexture
+#define GL_TEXTURE0_ARB                   0x84C0
+#define GL_TEXTURE1_ARB                   0x84C1
+#define GL_TEXTURE2_ARB                   0x84C2
+#define GL_TEXTURE3_ARB                   0x84C3
+#define GL_TEXTURE4_ARB                   0x84C4
+#define GL_TEXTURE5_ARB                   0x84C5
+#define GL_TEXTURE6_ARB                   0x84C6
+#define GL_TEXTURE7_ARB                   0x84C7
+#define GL_TEXTURE8_ARB                   0x84C8
+#define GL_TEXTURE9_ARB                   0x84C9
+#define GL_TEXTURE10_ARB                  0x84CA
+#define GL_TEXTURE11_ARB                  0x84CB
+#define GL_TEXTURE12_ARB                  0x84CC
+#define GL_TEXTURE13_ARB                  0x84CD
+#define GL_TEXTURE14_ARB                  0x84CE
+#define GL_TEXTURE15_ARB                  0x84CF
+#define GL_TEXTURE16_ARB                  0x84D0
+#define GL_TEXTURE17_ARB                  0x84D1
+#define GL_TEXTURE18_ARB                  0x84D2
+#define GL_TEXTURE19_ARB                  0x84D3
+#define GL_TEXTURE20_ARB                  0x84D4
+#define GL_TEXTURE21_ARB                  0x84D5
+#define GL_TEXTURE22_ARB                  0x84D6
+#define GL_TEXTURE23_ARB                  0x84D7
+#define GL_TEXTURE24_ARB                  0x84D8
+#define GL_TEXTURE25_ARB                  0x84D9
+#define GL_TEXTURE26_ARB                  0x84DA
+#define GL_TEXTURE27_ARB                  0x84DB
+#define GL_TEXTURE28_ARB                  0x84DC
+#define GL_TEXTURE29_ARB                  0x84DD
+#define GL_TEXTURE30_ARB                  0x84DE
+#define GL_TEXTURE31_ARB                  0x84DF
+#define GL_ACTIVE_TEXTURE_ARB             0x84E0
+#define GL_CLIENT_ACTIVE_TEXTURE_ARB      0x84E1
+#define GL_MAX_TEXTURE_UNITS_ARB          0x84E2
+#endif
+
+#ifndef GL_ARB_transpose_matrix
+#define GL_TRANSPOSE_MODELVIEW_MATRIX_ARB 0x84E3
+#define GL_TRANSPOSE_PROJECTION_MATRIX_ARB 0x84E4
+#define GL_TRANSPOSE_TEXTURE_MATRIX_ARB   0x84E5
+#define GL_TRANSPOSE_COLOR_MATRIX_ARB     0x84E6
+#endif
+
+#ifndef GL_ARB_multisample
+#define GL_MULTISAMPLE_ARB                0x809D
+#define GL_SAMPLE_ALPHA_TO_COVERAGE_ARB   0x809E
+#define GL_SAMPLE_ALPHA_TO_ONE_ARB        0x809F
+#define GL_SAMPLE_COVERAGE_ARB            0x80A0
+#define GL_SAMPLE_BUFFERS_ARB             0x80A8
+#define GL_SAMPLES_ARB                    0x80A9
+#define GL_SAMPLE_COVERAGE_VALUE_ARB      0x80AA
+#define GL_SAMPLE_COVERAGE_INVERT_ARB     0x80AB
+#define GL_MULTISAMPLE_BIT_ARB            0x20000000
+#endif
+
+#ifndef GL_ARB_texture_cube_map
+#define GL_NORMAL_MAP_ARB                 0x8511
+#define GL_REFLECTION_MAP_ARB             0x8512
+#define GL_TEXTURE_CUBE_MAP_ARB           0x8513
+#define GL_TEXTURE_BINDING_CUBE_MAP_ARB   0x8514
+#define GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB 0x8515
+#define GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB 0x8516
+#define GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB 0x8517
+#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB 0x8518
+#define GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB 0x8519
+#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB 0x851A
+#define GL_PROXY_TEXTURE_CUBE_MAP_ARB     0x851B
+#define GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB  0x851C
+#endif
+
+#ifndef GL_ARB_texture_compression
+#define GL_COMPRESSED_ALPHA_ARB           0x84E9
+#define GL_COMPRESSED_LUMINANCE_ARB       0x84EA
+#define GL_COMPRESSED_LUMINANCE_ALPHA_ARB 0x84EB
+#define GL_COMPRESSED_INTENSITY_ARB       0x84EC
+#define GL_COMPRESSED_RGB_ARB             0x84ED
+#define GL_COMPRESSED_RGBA_ARB            0x84EE
+#define GL_TEXTURE_COMPRESSION_HINT_ARB   0x84EF
+#define GL_TEXTURE_IMAGE_SIZE_ARB         0x86A0
+#define GL_TEXTURE_COMPRESSED_ARB         0x86A1
+#define GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB 0x86A2
+#define GL_COMPRESSED_TEXTURE_FORMATS_ARB 0x86A3
+#endif
+
+#ifndef GL_EXT_abgr
+#define GL_ABGR_EXT                       0x8000
+#endif
+
+#ifndef GL_EXT_blend_color
+#define GL_CONSTANT_COLOR_EXT             0x8001
+#define GL_ONE_MINUS_CONSTANT_COLOR_EXT   0x8002
+#define GL_CONSTANT_ALPHA_EXT             0x8003
+#define GL_ONE_MINUS_CONSTANT_ALPHA_EXT   0x8004
+#define GL_BLEND_COLOR_EXT                0x8005
+#endif
+
+#ifndef GL_EXT_polygon_offset
+#define GL_POLYGON_OFFSET_EXT             0x8037
+#define GL_POLYGON_OFFSET_FACTOR_EXT      0x8038
+#define GL_POLYGON_OFFSET_BIAS_EXT        0x8039
+#endif
+
+#ifndef GL_EXT_texture
+#define GL_ALPHA4_EXT                     0x803B
+#define GL_ALPHA8_EXT                     0x803C
+#define GL_ALPHA12_EXT                    0x803D
+#define GL_ALPHA16_EXT                    0x803E
+#define GL_LUMINANCE4_EXT                 0x803F
+#define GL_LUMINANCE8_EXT                 0x8040
+#define GL_LUMINANCE12_EXT                0x8041
+#define GL_LUMINANCE16_EXT                0x8042
+#define GL_LUMINANCE4_ALPHA4_EXT          0x8043
+#define GL_LUMINANCE6_ALPHA2_EXT          0x8044
+#define GL_LUMINANCE8_ALPHA8_EXT          0x8045
+#define GL_LUMINANCE12_ALPHA4_EXT         0x8046
+#define GL_LUMINANCE12_ALPHA12_EXT        0x8047
+#define GL_LUMINANCE16_ALPHA16_EXT        0x8048
+#define GL_INTENSITY_EXT                  0x8049
+#define GL_INTENSITY4_EXT                 0x804A
+#define GL_INTENSITY8_EXT                 0x804B
+#define GL_INTENSITY12_EXT                0x804C
+#define GL_INTENSITY16_EXT                0x804D
+#define GL_RGB2_EXT                       0x804E
+#define GL_RGB4_EXT                       0x804F
+#define GL_RGB5_EXT                       0x8050
+#define GL_RGB8_EXT                       0x8051
+#define GL_RGB10_EXT                      0x8052
+#define GL_RGB12_EXT                      0x8053
+#define GL_RGB16_EXT                      0x8054
+#define GL_RGBA2_EXT                      0x8055
+#define GL_RGBA4_EXT                      0x8056
+#define GL_RGB5_A1_EXT                    0x8057
+#define GL_RGBA8_EXT                      0x8058
+#define GL_RGB10_A2_EXT                   0x8059
+#define GL_RGBA12_EXT                     0x805A
+#define GL_RGBA16_EXT                     0x805B
+#define GL_TEXTURE_RED_SIZE_EXT           0x805C
+#define GL_TEXTURE_GREEN_SIZE_EXT         0x805D
+#define GL_TEXTURE_BLUE_SIZE_EXT          0x805E
+#define GL_TEXTURE_ALPHA_SIZE_EXT         0x805F
+#define GL_TEXTURE_LUMINANCE_SIZE_EXT     0x8060
+#define GL_TEXTURE_INTENSITY_SIZE_EXT     0x8061
+#define GL_REPLACE_EXT                    0x8062
+#define GL_PROXY_TEXTURE_1D_EXT           0x8063
+#define GL_PROXY_TEXTURE_2D_EXT           0x8064
+#define GL_TEXTURE_TOO_LARGE_EXT          0x8065
+#define GL_TPL4_EXT                       0x9991
+#define GL_TPL8_EXT                       0x9992
+#define GL_TPL16_EXT                      0x9993
+#define GL_TPL32_EXT                      0x9994
+#define GL_DDS1_EXT                       0x9995
+#define GL_DDS5_EXT                       0x9996
+#define GL_DDS_RGB16_EXT                  0x9997
+#define GL_DDS_RGBA32_EXT                 0x9998
+#define GL_RGB_SWIZZLE_EXT                0x9999
+#endif
+
+#ifndef GL_EXT_texture3D
+#define GL_PACK_SKIP_IMAGES               0x806B
+#define GL_PACK_SKIP_IMAGES_EXT           0x806B
+#define GL_PACK_IMAGE_HEIGHT              0x806C
+#define GL_PACK_IMAGE_HEIGHT_EXT          0x806C
+#define GL_UNPACK_SKIP_IMAGES             0x806D
+#define GL_UNPACK_SKIP_IMAGES_EXT         0x806D
+#define GL_UNPACK_IMAGE_HEIGHT            0x806E
+#define GL_UNPACK_IMAGE_HEIGHT_EXT        0x806E
+#define GL_TEXTURE_3D                     0x806F
+#define GL_TEXTURE_3D_EXT                 0x806F
+#define GL_PROXY_TEXTURE_3D               0x8070
+#define GL_PROXY_TEXTURE_3D_EXT           0x8070
+#define GL_TEXTURE_DEPTH                  0x8071
+#define GL_TEXTURE_DEPTH_EXT              0x8071
+#define GL_TEXTURE_WRAP_R                 0x8072
+#define GL_TEXTURE_WRAP_R_EXT             0x8072
+#define GL_MAX_3D_TEXTURE_SIZE            0x8073
+#define GL_MAX_3D_TEXTURE_SIZE_EXT        0x8073
+#endif
+
+#ifndef GL_SGIS_texture_filter4
+#define GL_FILTER4_SGIS                   0x8146
+#define GL_TEXTURE_FILTER4_SIZE_SGIS      0x8147
+#endif
+
+#ifndef GL_EXT_subtexture
+#endif
+
+#ifndef GL_EXT_copy_texture
+#endif
+
+#ifndef GL_EXT_histogram
+#define GL_HISTOGRAM_EXT                  0x8024
+#define GL_PROXY_HISTOGRAM_EXT            0x8025
+#define GL_HISTOGRAM_WIDTH_EXT            0x8026
+#define GL_HISTOGRAM_FORMAT_EXT           0x8027
+#define GL_HISTOGRAM_RED_SIZE_EXT         0x8028
+#define GL_HISTOGRAM_GREEN_SIZE_EXT       0x8029
+#define GL_HISTOGRAM_BLUE_SIZE_EXT        0x802A
+#define GL_HISTOGRAM_ALPHA_SIZE_EXT       0x802B
+#define GL_HISTOGRAM_LUMINANCE_SIZE_EXT   0x802C
+#define GL_HISTOGRAM_SINK_EXT             0x802D
+#define GL_MINMAX_EXT                     0x802E
+#define GL_MINMAX_FORMAT_EXT              0x802F
+#define GL_MINMAX_SINK_EXT                0x8030
+#define GL_TABLE_TOO_LARGE_EXT            0x8031
+#endif
+
+#ifndef GL_EXT_convolution
+#define GL_CONVOLUTION_1D_EXT             0x8010
+#define GL_CONVOLUTION_2D_EXT             0x8011
+#define GL_SEPARABLE_2D_EXT               0x8012
+#define GL_CONVOLUTION_BORDER_MODE_EXT    0x8013
+#define GL_CONVOLUTION_FILTER_SCALE_EXT   0x8014
+#define GL_CONVOLUTION_FILTER_BIAS_EXT    0x8015
+#define GL_REDUCE_EXT                     0x8016
+#define GL_CONVOLUTION_FORMAT_EXT         0x8017
+#define GL_CONVOLUTION_WIDTH_EXT          0x8018
+#define GL_CONVOLUTION_HEIGHT_EXT         0x8019
+#define GL_MAX_CONVOLUTION_WIDTH_EXT      0x801A
+#define GL_MAX_CONVOLUTION_HEIGHT_EXT     0x801B
+#define GL_POST_CONVOLUTION_RED_SCALE_EXT 0x801C
+#define GL_POST_CONVOLUTION_GREEN_SCALE_EXT 0x801D
+#define GL_POST_CONVOLUTION_BLUE_SCALE_EXT 0x801E
+#define GL_POST_CONVOLUTION_ALPHA_SCALE_EXT 0x801F
+#define GL_POST_CONVOLUTION_RED_BIAS_EXT  0x8020
+#define GL_POST_CONVOLUTION_GREEN_BIAS_EXT 0x8021
+#define GL_POST_CONVOLUTION_BLUE_BIAS_EXT 0x8022
+#define GL_POST_CONVOLUTION_ALPHA_BIAS_EXT 0x8023
+#endif
+
+#ifndef GL_SGI_color_matrix
+#define GL_COLOR_MATRIX_SGI               0x80B1
+#define GL_COLOR_MATRIX_STACK_DEPTH_SGI   0x80B2
+#define GL_MAX_COLOR_MATRIX_STACK_DEPTH_SGI 0x80B3
+#define GL_POST_COLOR_MATRIX_RED_SCALE_SGI 0x80B4
+#define GL_POST_COLOR_MATRIX_GREEN_SCALE_SGI 0x80B5
+#define GL_POST_COLOR_MATRIX_BLUE_SCALE_SGI 0x80B6
+#define GL_POST_COLOR_MATRIX_ALPHA_SCALE_SGI 0x80B7
+#define GL_POST_COLOR_MATRIX_RED_BIAS_SGI 0x80B8
+#define GL_POST_COLOR_MATRIX_GREEN_BIAS_SGI 0x80B9
+#define GL_POST_COLOR_MATRIX_BLUE_BIAS_SGI 0x80BA
+#define GL_POST_COLOR_MATRIX_ALPHA_BIAS_SGI 0x80BB
+#endif
+
+#ifndef GL_SGI_color_table
+#define GL_COLOR_TABLE_SGI                0x80D0
+#define GL_POST_CONVOLUTION_COLOR_TABLE_SGI 0x80D1
+#define GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI 0x80D2
+#define GL_PROXY_COLOR_TABLE_SGI          0x80D3
+#define GL_PROXY_POST_CONVOLUTION_COLOR_TABLE_SGI 0x80D4
+#define GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE_SGI 0x80D5
+#define GL_COLOR_TABLE_SCALE_SGI          0x80D6
+#define GL_COLOR_TABLE_BIAS_SGI           0x80D7
+#define GL_COLOR_TABLE_FORMAT_SGI         0x80D8
+#define GL_COLOR_TABLE_WIDTH_SGI          0x80D9
+#define GL_COLOR_TABLE_RED_SIZE_SGI       0x80DA
+#define GL_COLOR_TABLE_GREEN_SIZE_SGI     0x80DB
+#define GL_COLOR_TABLE_BLUE_SIZE_SGI      0x80DC
+#define GL_COLOR_TABLE_ALPHA_SIZE_SGI     0x80DD
+#define GL_COLOR_TABLE_LUMINANCE_SIZE_SGI 0x80DE
+#define GL_COLOR_TABLE_INTENSITY_SIZE_SGI 0x80DF
+#endif
+
+#ifndef GL_SGIS_pixel_texture
+#define GL_PIXEL_TEXTURE_SGIS             0x8353
+#define GL_PIXEL_FRAGMENT_RGB_SOURCE_SGIS 0x8354
+#define GL_PIXEL_FRAGMENT_ALPHA_SOURCE_SGIS 0x8355
+#define GL_PIXEL_GROUP_COLOR_SGIS         0x8356
+#endif
+
+#ifndef GL_SGIX_pixel_texture
+#define GL_PIXEL_TEX_GEN_SGIX             0x8139
+#define GL_PIXEL_TEX_GEN_MODE_SGIX        0x832B
+#endif
+
+#ifndef GL_SGIS_texture4D
+#define GL_PACK_SKIP_VOLUMES_SGIS         0x8130
+#define GL_PACK_IMAGE_DEPTH_SGIS          0x8131
+#define GL_UNPACK_SKIP_VOLUMES_SGIS       0x8132
+#define GL_UNPACK_IMAGE_DEPTH_SGIS        0x8133
+#define GL_TEXTURE_4D_SGIS                0x8134
+#define GL_PROXY_TEXTURE_4D_SGIS          0x8135
+#define GL_TEXTURE_4DSIZE_SGIS            0x8136
+#define GL_TEXTURE_WRAP_Q_SGIS            0x8137
+#define GL_MAX_4D_TEXTURE_SIZE_SGIS       0x8138
+#define GL_TEXTURE_4D_BINDING_SGIS        0x814F
+#endif
+
+#ifndef GL_SGI_texture_color_table
+#define GL_TEXTURE_COLOR_TABLE_SGI        0x80BC
+#define GL_PROXY_TEXTURE_COLOR_TABLE_SGI  0x80BD
+#endif
+
+#ifndef GL_EXT_cmyka
+#define GL_CMYK_EXT                       0x800C
+#define GL_CMYKA_EXT                      0x800D
+#define GL_PACK_CMYK_HINT_EXT             0x800E
+#define GL_UNPACK_CMYK_HINT_EXT           0x800F
+#endif
+
+#ifndef GL_EXT_texture_object
+#define GL_TEXTURE_PRIORITY_EXT           0x8066
+#define GL_TEXTURE_RESIDENT_EXT           0x8067
+#define GL_TEXTURE_1D_BINDING_EXT         0x8068
+#define GL_TEXTURE_2D_BINDING_EXT         0x8069
+#define GL_TEXTURE_3D_BINDING_EXT         0x806A
+#endif
+
+#ifndef GL_SGIS_detail_texture
+#define GL_DETAIL_TEXTURE_2D_SGIS         0x8095
+#define GL_DETAIL_TEXTURE_2D_BINDING_SGIS 0x8096
+#define GL_LINEAR_DETAIL_SGIS             0x8097
+#define GL_LINEAR_DETAIL_ALPHA_SGIS       0x8098
+#define GL_LINEAR_DETAIL_COLOR_SGIS       0x8099
+#define GL_DETAIL_TEXTURE_LEVEL_SGIS      0x809A
+#define GL_DETAIL_TEXTURE_MODE_SGIS       0x809B
+#define GL_DETAIL_TEXTURE_FUNC_POINTS_SGIS 0x809C
+#endif
+
+#ifndef GL_SGIS_sharpen_texture
+#define GL_LINEAR_SHARPEN_SGIS            0x80AD
+#define GL_LINEAR_SHARPEN_ALPHA_SGIS      0x80AE
+#define GL_LINEAR_SHARPEN_COLOR_SGIS      0x80AF
+#define GL_SHARPEN_TEXTURE_FUNC_POINTS_SGIS 0x80B0
+#endif
+
+#ifndef GL_EXT_packed_pixels
+#define GL_UNSIGNED_BYTE_3_3_2_EXT        0x8032
+#define GL_UNSIGNED_SHORT_4_4_4_4_EXT     0x8033
+#define GL_UNSIGNED_SHORT_5_5_5_1_EXT     0x8034
+#define GL_UNSIGNED_INT_8_8_8_8_EXT       0x8035
+#define GL_UNSIGNED_INT_10_10_10_2_EXT    0x8036
+#endif
+
+#ifndef GL_SGIS_texture_lod
+#define GL_TEXTURE_MIN_LOD_SGIS           0x813A
+#define GL_TEXTURE_MAX_LOD_SGIS           0x813B
+#define GL_TEXTURE_BASE_LEVEL_SGIS        0x813C
+#define GL_TEXTURE_MAX_LEVEL_SGIS         0x813D
+#endif
+
+#ifndef GL_SGIS_multisample
+#define GL_MULTISAMPLE_SGIS               0x809D
+#define GL_SAMPLE_ALPHA_TO_MASK_SGIS      0x809E
+#define GL_SAMPLE_ALPHA_TO_ONE_SGIS       0x809F
+#define GL_SAMPLE_MASK_SGIS               0x80A0
+#define GL_1PASS_SGIS                     0x80A1
+#define GL_2PASS_0_SGIS                   0x80A2
+#define GL_2PASS_1_SGIS                   0x80A3
+#define GL_4PASS_0_SGIS                   0x80A4
+#define GL_4PASS_1_SGIS                   0x80A5
+#define GL_4PASS_2_SGIS                   0x80A6
+#define GL_4PASS_3_SGIS                   0x80A7
+#define GL_SAMPLE_BUFFERS_SGIS            0x80A8
+#define GL_SAMPLES_SGIS                   0x80A9
+#define GL_SAMPLE_MASK_VALUE_SGIS         0x80AA
+#define GL_SAMPLE_MASK_INVERT_SGIS        0x80AB
+#define GL_SAMPLE_PATTERN_SGIS            0x80AC
+#endif
+
+#ifndef GL_EXT_rescale_normal
+#define GL_RESCALE_NORMAL_EXT             0x803A
+#endif
+
+#ifndef GL_EXT_vertex_array
+#define GL_VERTEX_ARRAY_EXT               0x8074
+#define GL_NORMAL_ARRAY_EXT               0x8075
+#define GL_COLOR_ARRAY_EXT                0x8076
+#define GL_INDEX_ARRAY_EXT                0x8077
+#define GL_TEXTURE_COORD_ARRAY_EXT        0x8078
+#define GL_EDGE_FLAG_ARRAY_EXT            0x8079
+#define GL_VERTEX_ARRAY_SIZE_EXT          0x807A
+#define GL_VERTEX_ARRAY_TYPE_EXT          0x807B
+#define GL_VERTEX_ARRAY_STRIDE_EXT        0x807C
+#define GL_VERTEX_ARRAY_COUNT_EXT         0x807D
+#define GL_NORMAL_ARRAY_TYPE_EXT          0x807E
+#define GL_NORMAL_ARRAY_STRIDE_EXT        0x807F
+#define GL_NORMAL_ARRAY_COUNT_EXT         0x8080
+#define GL_COLOR_ARRAY_SIZE_EXT           0x8081
+#define GL_COLOR_ARRAY_TYPE_EXT           0x8082
+#define GL_COLOR_ARRAY_STRIDE_EXT         0x8083
+#define GL_COLOR_ARRAY_COUNT_EXT          0x8084
+#define GL_INDEX_ARRAY_TYPE_EXT           0x8085
+#define GL_INDEX_ARRAY_STRIDE_EXT         0x8086
+#define GL_INDEX_ARRAY_COUNT_EXT          0x8087
+#define GL_TEXTURE_COORD_ARRAY_SIZE_EXT   0x8088
+#define GL_TEXTURE_COORD_ARRAY_TYPE_EXT   0x8089
+#define GL_TEXTURE_COORD_ARRAY_STRIDE_EXT 0x808A
+#define GL_TEXTURE_COORD_ARRAY_COUNT_EXT  0x808B
+#define GL_EDGE_FLAG_ARRAY_STRIDE_EXT     0x808C
+#define GL_EDGE_FLAG_ARRAY_COUNT_EXT      0x808D
+#define GL_VERTEX_ARRAY_POINTER_EXT       0x808E
+#define GL_NORMAL_ARRAY_POINTER_EXT       0x808F
+#define GL_COLOR_ARRAY_POINTER_EXT        0x8090
+#define GL_INDEX_ARRAY_POINTER_EXT        0x8091
+#define GL_TEXTURE_COORD_ARRAY_POINTER_EXT 0x8092
+#define GL_EDGE_FLAG_ARRAY_POINTER_EXT    0x8093
+#endif
+
+#ifndef GL_EXT_misc_attribute
+#endif
+
+#ifndef GL_SGIS_generate_mipmap
+#define GL_GENERATE_MIPMAP_SGIS           0x8191
+#define GL_GENERATE_MIPMAP_HINT_SGIS      0x8192
+#endif
+
+#ifndef GL_SGIX_clipmap
+#define GL_LINEAR_CLIPMAP_LINEAR_SGIX     0x8170
+#define GL_TEXTURE_CLIPMAP_CENTER_SGIX    0x8171
+#define GL_TEXTURE_CLIPMAP_FRAME_SGIX     0x8172
+#define GL_TEXTURE_CLIPMAP_OFFSET_SGIX    0x8173
+#define GL_TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX 0x8174
+#define GL_TEXTURE_CLIPMAP_LOD_OFFSET_SGIX 0x8175
+#define GL_TEXTURE_CLIPMAP_DEPTH_SGIX     0x8176
+#define GL_MAX_CLIPMAP_DEPTH_SGIX         0x8177
+#define GL_MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX 0x8178
+#define GL_NEAREST_CLIPMAP_NEAREST_SGIX   0x844D
+#define GL_NEAREST_CLIPMAP_LINEAR_SGIX    0x844E
+#define GL_LINEAR_CLIPMAP_NEAREST_SGIX    0x844F
+#endif
+
+#ifndef GL_SGIX_shadow
+#define GL_TEXTURE_COMPARE_SGIX           0x819A
+#define GL_TEXTURE_COMPARE_OPERATOR_SGIX  0x819B
+#define GL_TEXTURE_LEQUAL_R_SGIX          0x819C
+#define GL_TEXTURE_GEQUAL_R_SGIX          0x819D
+#endif
+
+#ifndef GL_SGIS_texture_edge_clamp
+#define GL_CLAMP_TO_EDGE_SGIS             0x812F
+#endif
+
+#ifndef GL_SGIS_texture_border_clamp
+#define GL_CLAMP_TO_BORDER_SGIS           0x812D
+#endif
+
+#ifndef GL_EXT_blend_minmax
+#define GL_FUNC_ADD_EXT                   0x8006
+#define GL_MIN_EXT                        0x8007
+#define GL_MAX_EXT                        0x8008
+#define GL_BLEND_EQUATION_EXT             0x8009
+#endif
+
+#ifndef GL_EXT_blend_subtract
+#define GL_FUNC_SUBTRACT_EXT              0x800A
+#define GL_FUNC_REVERSE_SUBTRACT_EXT      0x800B
+#endif
+
+#ifndef GL_EXT_blend_logic_op
+#endif
+
+#ifndef GL_SGIX_interlace
+#define GL_INTERLACE_SGIX                 0x8094
+#endif
+
+#ifndef GL_SGIX_pixel_tiles
+#define GL_PIXEL_TILE_BEST_ALIGNMENT_SGIX 0x813E
+#define GL_PIXEL_TILE_CACHE_INCREMENT_SGIX 0x813F
+#define GL_PIXEL_TILE_WIDTH_SGIX          0x8140
+#define GL_PIXEL_TILE_HEIGHT_SGIX         0x8141
+#define GL_PIXEL_TILE_GRID_WIDTH_SGIX     0x8142
+#define GL_PIXEL_TILE_GRID_HEIGHT_SGIX    0x8143
+#define GL_PIXEL_TILE_GRID_DEPTH_SGIX     0x8144
+#define GL_PIXEL_TILE_CACHE_SIZE_SGIX     0x8145
+#endif
+
+#ifndef GL_SGIS_texture_select
+#define GL_DUAL_ALPHA4_SGIS               0x8110
+#define GL_DUAL_ALPHA8_SGIS               0x8111
+#define GL_DUAL_ALPHA12_SGIS              0x8112
+#define GL_DUAL_ALPHA16_SGIS              0x8113
+#define GL_DUAL_LUMINANCE4_SGIS           0x8114
+#define GL_DUAL_LUMINANCE8_SGIS           0x8115
+#define GL_DUAL_LUMINANCE12_SGIS          0x8116
+#define GL_DUAL_LUMINANCE16_SGIS          0x8117
+#define GL_DUAL_INTENSITY4_SGIS           0x8118
+#define GL_DUAL_INTENSITY8_SGIS           0x8119
+#define GL_DUAL_INTENSITY12_SGIS          0x811A
+#define GL_DUAL_INTENSITY16_SGIS          0x811B
+#define GL_DUAL_LUMINANCE_ALPHA4_SGIS     0x811C
+#define GL_DUAL_LUMINANCE_ALPHA8_SGIS     0x811D
+#define GL_QUAD_ALPHA4_SGIS               0x811E
+#define GL_QUAD_ALPHA8_SGIS               0x811F
+#define GL_QUAD_LUMINANCE4_SGIS           0x8120
+#define GL_QUAD_LUMINANCE8_SGIS           0x8121
+#define GL_QUAD_INTENSITY4_SGIS           0x8122
+#define GL_QUAD_INTENSITY8_SGIS           0x8123
+#define GL_DUAL_TEXTURE_SELECT_SGIS       0x8124
+#define GL_QUAD_TEXTURE_SELECT_SGIS       0x8125
+#endif
+
+#ifndef GL_SGIX_sprite
+#define GL_SPRITE_SGIX                    0x8148
+#define GL_SPRITE_MODE_SGIX               0x8149
+#define GL_SPRITE_AXIS_SGIX               0x814A
+#define GL_SPRITE_TRANSLATION_SGIX        0x814B
+#define GL_SPRITE_AXIAL_SGIX              0x814C
+#define GL_SPRITE_OBJECT_ALIGNED_SGIX     0x814D
+#define GL_SPRITE_EYE_ALIGNED_SGIX        0x814E
+#endif
+
+#ifndef GL_SGIX_texture_multi_buffer
+#define GL_TEXTURE_MULTI_BUFFER_HINT_SGIX 0x812E
+#endif
+
+#ifndef GL_SGIS_point_parameters
+#define GL_POINT_SIZE_MIN_EXT             0x8126
+#define GL_POINT_SIZE_MIN_SGIS            0x8126
+#define GL_POINT_SIZE_MAX_EXT             0x8127
+#define GL_POINT_SIZE_MAX_SGIS            0x8127
+#define GL_POINT_FADE_THRESHOLD_SIZE_EXT  0x8128
+#define GL_POINT_FADE_THRESHOLD_SIZE_SGIS 0x8128
+#define GL_DISTANCE_ATTENUATION_EXT       0x8129
+#define GL_DISTANCE_ATTENUATION_SGIS      0x8129
+#endif
+
+#ifndef GL_SGIX_instruments
+#define GL_INSTRUMENT_BUFFER_POINTER_SGIX 0x8180
+#define GL_INSTRUMENT_MEASUREMENTS_SGIX   0x8181
+#endif
+
+#ifndef GL_SGIX_texture_scale_bias
+#define GL_POST_TEXTURE_FILTER_BIAS_SGIX  0x8179
+#define GL_POST_TEXTURE_FILTER_SCALE_SGIX 0x817A
+#define GL_POST_TEXTURE_FILTER_BIAS_RANGE_SGIX 0x817B
+#define GL_POST_TEXTURE_FILTER_SCALE_RANGE_SGIX 0x817C
+#endif
+
+#ifndef GL_SGIX_framezoom
+#define GL_FRAMEZOOM_SGIX                 0x818B
+#define GL_FRAMEZOOM_FACTOR_SGIX          0x818C
+#define GL_MAX_FRAMEZOOM_FACTOR_SGIX      0x818D
+#endif
+
+#ifndef GL_SGIX_tag_sample_buffer
+#endif
+
+#ifndef GL_SGIX_reference_plane
+#define GL_REFERENCE_PLANE_SGIX           0x817D
+#define GL_REFERENCE_PLANE_EQUATION_SGIX  0x817E
+#endif
+
+#ifndef GL_SGIX_flush_raster
+#endif
+
+#ifndef GL_SGIX_depth_texture
+#define GL_DEPTH_COMPONENT16_SGIX         0x81A5
+#define GL_DEPTH_COMPONENT24_SGIX         0x81A6
+#define GL_DEPTH_COMPONENT32_SGIX         0x81A7
+#endif
+
+#ifndef GL_SGIS_fog_function
+#define GL_FOG_FUNC_SGIS                  0x812A
+#define GL_FOG_FUNC_POINTS_SGIS           0x812B
+#define GL_MAX_FOG_FUNC_POINTS_SGIS       0x812C
+#endif
+
+#ifndef GL_SGIX_fog_offset
+#define GL_FOG_OFFSET_SGIX                0x8198
+#define GL_FOG_OFFSET_VALUE_SGIX          0x8199
+#endif
+
+#ifndef GL_HP_image_transform
+#define GL_IMAGE_SCALE_X_HP               0x8155
+#define GL_IMAGE_SCALE_Y_HP               0x8156
+#define GL_IMAGE_TRANSLATE_X_HP           0x8157
+#define GL_IMAGE_TRANSLATE_Y_HP           0x8158
+#define GL_IMAGE_ROTATE_ANGLE_HP          0x8159
+#define GL_IMAGE_ROTATE_ORIGIN_X_HP       0x815A
+#define GL_IMAGE_ROTATE_ORIGIN_Y_HP       0x815B
+#define GL_IMAGE_MAG_FILTER_HP            0x815C
+#define GL_IMAGE_MIN_FILTER_HP            0x815D
+#define GL_IMAGE_CUBIC_WEIGHT_HP          0x815E
+#define GL_CUBIC_HP                       0x815F
+#define GL_AVERAGE_HP                     0x8160
+#define GL_IMAGE_TRANSFORM_2D_HP          0x8161
+#define GL_POST_IMAGE_TRANSFORM_COLOR_TABLE_HP 0x8162
+#define GL_PROXY_POST_IMAGE_TRANSFORM_COLOR_TABLE_HP 0x8163
+#endif
+
+#ifndef GL_HP_convolution_border_modes
+#define GL_IGNORE_BORDER_HP               0x8150
+#define GL_CONSTANT_BORDER_HP             0x8151
+#define GL_REPLICATE_BORDER_HP            0x8153
+#define GL_CONVOLUTION_BORDER_COLOR_HP    0x8154
+#endif
+
+#ifndef GL_INGR_palette_buffer
+#endif
+
+#ifndef GL_SGIX_texture_add_env
+#define GL_TEXTURE_ENV_BIAS_SGIX          0x80BE
+#endif
+
+#ifndef GL_EXT_color_subtable
+#endif
+
+#ifndef GL_PGI_vertex_hints
+#define GL_VERTEX_DATA_HINT_PGI           0x1A22A
+#define GL_VERTEX_CONSISTENT_HINT_PGI     0x1A22B
+#define GL_MATERIAL_SIDE_HINT_PGI         0x1A22C
+#define GL_MAX_VERTEX_HINT_PGI            0x1A22D
+#define GL_COLOR3_BIT_PGI                 0x00010000
+#define GL_COLOR4_BIT_PGI                 0x00020000
+#define GL_EDGEFLAG_BIT_PGI               0x00040000
+#define GL_INDEX_BIT_PGI                  0x00080000
+#define GL_MAT_AMBIENT_BIT_PGI            0x00100000
+#define GL_MAT_AMBIENT_AND_DIFFUSE_BIT_PGI 0x00200000
+#define GL_MAT_DIFFUSE_BIT_PGI            0x00400000
+#define GL_MAT_EMISSION_BIT_PGI           0x00800000
+#define GL_MAT_COLOR_INDEXES_BIT_PGI      0x01000000
+#define GL_MAT_SHININESS_BIT_PGI          0x02000000
+#define GL_MAT_SPECULAR_BIT_PGI           0x04000000
+#define GL_NORMAL_BIT_PGI                 0x08000000
+#define GL_TEXCOORD1_BIT_PGI              0x10000000
+#define GL_TEXCOORD2_BIT_PGI              0x20000000
+#define GL_TEXCOORD3_BIT_PGI              0x40000000
+#define GL_TEXCOORD4_BIT_PGI              0x80000000
+#define GL_VERTEX23_BIT_PGI               0x00000004
+#define GL_VERTEX4_BIT_PGI                0x00000008
+#endif
+
+#ifndef GL_PGI_misc_hints
+#define GL_PREFER_DOUBLEBUFFER_HINT_PGI   0x1A1F8
+#define GL_CONSERVE_MEMORY_HINT_PGI       0x1A1FD
+#define GL_RECLAIM_MEMORY_HINT_PGI        0x1A1FE
+#define GL_NATIVE_GRAPHICS_HANDLE_PGI     0x1A202
+#define GL_NATIVE_GRAPHICS_BEGIN_HINT_PGI 0x1A203
+#define GL_NATIVE_GRAPHICS_END_HINT_PGI   0x1A204
+#define GL_ALWAYS_FAST_HINT_PGI           0x1A20C
+#define GL_ALWAYS_SOFT_HINT_PGI           0x1A20D
+#define GL_ALLOW_DRAW_OBJ_HINT_PGI        0x1A20E
+#define GL_ALLOW_DRAW_WIN_HINT_PGI        0x1A20F
+#define GL_ALLOW_DRAW_FRG_HINT_PGI        0x1A210
+#define GL_ALLOW_DRAW_MEM_HINT_PGI        0x1A211
+#define GL_STRICT_DEPTHFUNC_HINT_PGI      0x1A216
+#define GL_STRICT_LIGHTING_HINT_PGI       0x1A217
+#define GL_STRICT_SCISSOR_HINT_PGI        0x1A218
+#define GL_FULL_STIPPLE_HINT_PGI          0x1A219
+#define GL_CLIP_NEAR_HINT_PGI             0x1A220
+#define GL_CLIP_FAR_HINT_PGI              0x1A221
+#define GL_WIDE_LINE_HINT_PGI             0x1A222
+#define GL_BACK_NORMALS_HINT_PGI          0x1A223
+#endif
+
+#ifndef GL_EXT_paletted_texture
+#define GL_COLOR_INDEX1_EXT               0x80E2
+#define GL_COLOR_INDEX2_EXT               0x80E3
+#define GL_COLOR_INDEX4_EXT               0x80E4
+#define GL_COLOR_INDEX8_EXT               0x80E5
+#define GL_COLOR_INDEX12_EXT              0x80E6
+#define GL_COLOR_INDEX16_EXT              0x80E7
+#define GL_TEXTURE_INDEX_SIZE_EXT         0x80ED
+#endif
+
+#ifndef GL_EXT_clip_volume_hint
+#define GL_CLIP_VOLUME_CLIPPING_HINT_EXT  0x80F0
+#endif
+
+#ifndef GL_SGIX_list_priority
+#define GL_LIST_PRIORITY_SGIX             0x8182
+#endif
+
+#ifndef GL_SGIX_ir_instrument1
+#define GL_IR_INSTRUMENT1_SGIX            0x817F
+#endif
+
+#ifndef GL_SGIX_calligraphic_fragment
+#define GL_CALLIGRAPHIC_FRAGMENT_SGIX     0x8183
+#endif
+
+#ifndef GL_SGIX_texture_lod_bias
+#define GL_TEXTURE_LOD_BIAS_S_SGIX        0x818E
+#define GL_TEXTURE_LOD_BIAS_T_SGIX        0x818F
+#define GL_TEXTURE_LOD_BIAS_R_SGIX        0x8190
+#endif
+
+#ifndef GL_SGIX_shadow_ambient
+#define GL_SHADOW_AMBIENT_SGIX            0x80BF
+#endif
+
+#ifndef GL_EXT_index_texture
+#endif
+
+#ifndef GL_EXT_index_material
+#define GL_INDEX_MATERIAL_EXT             0x81B8
+#define GL_INDEX_MATERIAL_PARAMETER_EXT   0x81B9
+#define GL_INDEX_MATERIAL_FACE_EXT        0x81BA
+#endif
+
+#ifndef GL_EXT_index_func
+#define GL_INDEX_TEST_EXT                 0x81B5
+#define GL_INDEX_TEST_FUNC_EXT            0x81B6
+#define GL_INDEX_TEST_REF_EXT             0x81B7
+#endif
+
+#ifndef GL_EXT_index_array_formats
+#define GL_IUI_V2F_EXT                    0x81AD
+#define GL_IUI_V3F_EXT                    0x81AE
+#define GL_IUI_N3F_V2F_EXT                0x81AF
+#define GL_IUI_N3F_V3F_EXT                0x81B0
+#define GL_T2F_IUI_V2F_EXT                0x81B1
+#define GL_T2F_IUI_V3F_EXT                0x81B2
+#define GL_T2F_IUI_N3F_V2F_EXT            0x81B3
+#define GL_T2F_IUI_N3F_V3F_EXT            0x81B4
+#endif
+
+#ifndef GL_EXT_compiled_vertex_array
+#define GL_ARRAY_ELEMENT_LOCK_FIRST_EXT   0x81A8
+#define GL_ARRAY_ELEMENT_LOCK_COUNT_EXT   0x81A9
+#endif
+
+#ifndef GL_EXT_cull_vertex
+#define GL_CULL_VERTEX_EXT                0x81AA
+#define GL_CULL_VERTEX_EYE_POSITION_EXT   0x81AB
+#define GL_CULL_VERTEX_OBJECT_POSITION_EXT 0x81AC
+#endif
+
+#ifndef GL_SGIX_ycrcb
+#define GL_YCRCB_422_SGIX                 0x81BB
+#define GL_YCRCB_444_SGIX                 0x81BC
+#endif
+
+#ifndef GL_SGIX_fragment_lighting
+#define GL_FRAGMENT_LIGHTING_SGIX         0x8400
+#define GL_FRAGMENT_COLOR_MATERIAL_SGIX   0x8401
+#define GL_FRAGMENT_COLOR_MATERIAL_FACE_SGIX 0x8402
+#define GL_FRAGMENT_COLOR_MATERIAL_PARAMETER_SGIX 0x8403
+#define GL_MAX_FRAGMENT_LIGHTS_SGIX       0x8404
+#define GL_MAX_ACTIVE_LIGHTS_SGIX         0x8405
+#define GL_CURRENT_RASTER_NORMAL_SGIX     0x8406
+#define GL_LIGHT_ENV_MODE_SGIX            0x8407
+#define GL_FRAGMENT_LIGHT_MODEL_LOCAL_VIEWER_SGIX 0x8408
+#define GL_FRAGMENT_LIGHT_MODEL_TWO_SIDE_SGIX 0x8409
+#define GL_FRAGMENT_LIGHT_MODEL_AMBIENT_SGIX 0x840A
+#define GL_FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION_SGIX 0x840B
+#define GL_FRAGMENT_LIGHT0_SGIX           0x840C
+#define GL_FRAGMENT_LIGHT1_SGIX           0x840D
+#define GL_FRAGMENT_LIGHT2_SGIX           0x840E
+#define GL_FRAGMENT_LIGHT3_SGIX           0x840F
+#define GL_FRAGMENT_LIGHT4_SGIX           0x8410
+#define GL_FRAGMENT_LIGHT5_SGIX           0x8411
+#define GL_FRAGMENT_LIGHT6_SGIX           0x8412
+#define GL_FRAGMENT_LIGHT7_SGIX           0x8413
+#endif
+
+#ifndef GL_IBM_rasterpos_clip
+#define GL_RASTER_POSITION_UNCLIPPED_IBM  0x19262
+#endif
+
+#ifndef GL_HP_texture_lighting
+#define GL_TEXTURE_LIGHTING_MODE_HP       0x8167
+#define GL_TEXTURE_POST_SPECULAR_HP       0x8168
+#define GL_TEXTURE_PRE_SPECULAR_HP        0x8169
+#endif
+
+#ifndef GL_EXT_draw_range_elements
+#define GL_MAX_ELEMENTS_VERTICES_EXT      0x80E8
+#define GL_MAX_ELEMENTS_INDICES_EXT       0x80E9
+#endif
+
+#ifndef GL_WIN_phong_shading
+#define GL_PHONG_WIN                      0x80EA
+#define GL_PHONG_HINT_WIN                 0x80EB
+#endif
+
+#ifndef GL_WIN_specular_fog
+#define GL_FOG_SPECULAR_TEXTURE_WIN       0x80EC
+#endif
+
+#ifndef GL_EXT_light_texture
+#define GL_FRAGMENT_MATERIAL_EXT          0x8349
+#define GL_FRAGMENT_NORMAL_EXT            0x834A
+#define GL_FRAGMENT_COLOR_EXT             0x834C
+#define GL_ATTENUATION_EXT                0x834D
+#define GL_SHADOW_ATTENUATION_EXT         0x834E
+#define GL_TEXTURE_APPLICATION_MODE_EXT   0x834F
+#define GL_TEXTURE_LIGHT_EXT              0x8350
+#define GL_TEXTURE_MATERIAL_FACE_EXT      0x8351
+#define GL_TEXTURE_MATERIAL_PARAMETER_EXT 0x8352
+/* reuse GL_FRAGMENT_DEPTH_EXT */
+#endif
+
+#ifndef GL_SGIX_blend_alpha_minmax
+#define GL_ALPHA_MIN_SGIX                 0x8320
+#define GL_ALPHA_MAX_SGIX                 0x8321
+#endif
+
+#ifndef GL_EXT_bgra
+#define GL_BGR_EXT                        0x80E0
+#define GL_BGRA_EXT                       0x80E1
+#endif
+
+#ifndef GL_INTEL_texture_scissor
+#endif
+
+#ifndef GL_INTEL_parallel_arrays
+#define GL_PARALLEL_ARRAYS_INTEL          0x83F4
+#define GL_VERTEX_ARRAY_PARALLEL_POINTERS_INTEL 0x83F5
+#define GL_NORMAL_ARRAY_PARALLEL_POINTERS_INTEL 0x83F6
+#define GL_COLOR_ARRAY_PARALLEL_POINTERS_INTEL 0x83F7
+#define GL_TEXTURE_COORD_ARRAY_PARALLEL_POINTERS_INTEL 0x83F8
+#endif
+
+#ifndef GL_HP_occlusion_test
+#define GL_OCCLUSION_TEST_HP              0x8165
+#define GL_OCCLUSION_TEST_RESULT_HP       0x8166
+#endif
+
+#ifndef GL_EXT_pixel_transform
+#define GL_PIXEL_TRANSFORM_2D_EXT         0x8330
+#define GL_PIXEL_MAG_FILTER_EXT           0x8331
+#define GL_PIXEL_MIN_FILTER_EXT           0x8332
+#define GL_PIXEL_CUBIC_WEIGHT_EXT         0x8333
+#define GL_CUBIC_EXT                      0x8334
+#define GL_AVERAGE_EXT                    0x8335
+#define GL_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT 0x8336
+#define GL_MAX_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT 0x8337
+#define GL_PIXEL_TRANSFORM_2D_MATRIX_EXT  0x8338
+#endif
+
+#ifndef GL_EXT_pixel_transform_color_table
+#endif
+
+#ifndef GL_EXT_shared_texture_palette
+#define GL_SHARED_TEXTURE_PALETTE_EXT     0x81FB
+#endif
+
+#ifndef GL_EXT_separate_specular_color
+#define GL_LIGHT_MODEL_COLOR_CONTROL_EXT  0x81F8
+#define GL_SINGLE_COLOR_EXT               0x81F9
+#define GL_SEPARATE_SPECULAR_COLOR_EXT    0x81FA
+#endif
+
+#ifndef GL_EXT_secondary_color
+#define GL_COLOR_SUM_EXT                  0x8458
+#define GL_CURRENT_SECONDARY_COLOR_EXT    0x8459
+#define GL_SECONDARY_COLOR_ARRAY_SIZE_EXT 0x845A
+#define GL_SECONDARY_COLOR_ARRAY_TYPE_EXT 0x845B
+#define GL_SECONDARY_COLOR_ARRAY_STRIDE_EXT 0x845C
+#define GL_SECONDARY_COLOR_ARRAY_POINTER_EXT 0x845D
+#define GL_SECONDARY_COLOR_ARRAY_EXT      0x845E
+#endif
+
+#ifndef GL_EXT_texture_perturb_normal
+#define GL_PERTURB_EXT                    0x85AE
+#define GL_TEXTURE_NORMAL_EXT             0x85AF
+#endif
+
+#ifndef GL_EXT_multi_draw_arrays
+#endif
+
+#ifndef GL_EXT_fog_coord
+#define GL_FOG_COORDINATE_SOURCE_EXT      0x8450
+#define GL_FOG_COORDINATE_EXT             0x8451
+#define GL_FRAGMENT_DEPTH_EXT             0x8452
+#define GL_CURRENT_FOG_COORDINATE_EXT     0x8453
+#define GL_FOG_COORDINATE_ARRAY_TYPE_EXT  0x8454
+#define GL_FOG_COORDINATE_ARRAY_STRIDE_EXT 0x8455
+#define GL_FOG_COORDINATE_ARRAY_POINTER_EXT 0x8456
+#define GL_FOG_COORDINATE_ARRAY_EXT       0x8457
+#endif
+
+#ifndef GL_REND_screen_coordinates
+#define GL_SCREEN_COORDINATES_REND        0x8490
+#define GL_INVERTED_SCREEN_W_REND         0x8491
+#endif
+
+#ifndef GL_EXT_coordinate_frame
+#define GL_TANGENT_ARRAY_EXT              0x8439
+#define GL_BINORMAL_ARRAY_EXT             0x843A
+#define GL_CURRENT_TANGENT_EXT            0x843B
+#define GL_CURRENT_BINORMAL_EXT           0x843C
+#define GL_TANGENT_ARRAY_TYPE_EXT         0x843E
+#define GL_TANGENT_ARRAY_STRIDE_EXT       0x843F
+#define GL_BINORMAL_ARRAY_TYPE_EXT        0x8440
+#define GL_BINORMAL_ARRAY_STRIDE_EXT      0x8441
+#define GL_TANGENT_ARRAY_POINTER_EXT      0x8442
+#define GL_BINORMAL_ARRAY_POINTER_EXT     0x8443
+#define GL_MAP1_TANGENT_EXT               0x8444
+#define GL_MAP2_TANGENT_EXT               0x8445
+#define GL_MAP1_BINORMAL_EXT              0x8446
+#define GL_MAP2_BINORMAL_EXT              0x8447
+#endif
+
+#ifndef GL_EXT_texture_env_combine
+#define GL_COMBINE_EXT                    0x8570
+#define GL_COMBINE_RGB_EXT                0x8571
+#define GL_COMBINE_ALPHA_EXT              0x8572
+#define GL_RGB_SCALE_EXT                  0x8573
+#define GL_ADD_SIGNED_EXT                 0x8574
+#define GL_INTERPOLATE_EXT                0x8575
+#define GL_CONSTANT_EXT                   0x8576
+#define GL_PRIMARY_COLOR_EXT              0x8577
+#define GL_PREVIOUS_EXT                   0x8578
+#define GL_SOURCE0_RGB_EXT                0x8580
+#define GL_SOURCE1_RGB_EXT                0x8581
+#define GL_SOURCE2_RGB_EXT                0x8582
+#define GL_SOURCE3_RGB_EXT                0x8583
+#define GL_SOURCE4_RGB_EXT                0x8584
+#define GL_SOURCE5_RGB_EXT                0x8585
+#define GL_SOURCE6_RGB_EXT                0x8586
+#define GL_SOURCE7_RGB_EXT                0x8587
+#define GL_SOURCE0_ALPHA_EXT              0x8588
+#define GL_SOURCE1_ALPHA_EXT              0x8589
+#define GL_SOURCE2_ALPHA_EXT              0x858A
+#define GL_SOURCE3_ALPHA_EXT              0x858B
+#define GL_SOURCE4_ALPHA_EXT              0x858C
+#define GL_SOURCE5_ALPHA_EXT              0x858D
+#define GL_SOURCE6_ALPHA_EXT              0x858E
+#define GL_SOURCE7_ALPHA_EXT              0x858F
+#define GL_OPERAND0_RGB_EXT               0x8590
+#define GL_OPERAND1_RGB_EXT               0x8591
+#define GL_OPERAND2_RGB_EXT               0x8592
+#define GL_OPERAND3_RGB_EXT               0x8593
+#define GL_OPERAND4_RGB_EXT               0x8594
+#define GL_OPERAND5_RGB_EXT               0x8595
+#define GL_OPERAND6_RGB_EXT               0x8596
+#define GL_OPERAND7_RGB_EXT               0x8597
+#define GL_OPERAND0_ALPHA_EXT             0x8598
+#define GL_OPERAND1_ALPHA_EXT             0x8599
+#define GL_OPERAND2_ALPHA_EXT             0x859A
+#define GL_OPERAND3_ALPHA_EXT             0x859B
+#define GL_OPERAND4_ALPHA_EXT             0x859C
+#define GL_OPERAND5_ALPHA_EXT             0x859D
+#define GL_OPERAND6_ALPHA_EXT             0x859E
+#define GL_OPERAND7_ALPHA_EXT             0x859F
+#endif
+
+#ifndef GL_APPLE_specular_vector
+#define GL_LIGHT_MODEL_SPECULAR_VECTOR_APPLE 0x85B0
+#endif
+
+#ifndef GL_APPLE_transform_hint
+#define GL_TRANSFORM_HINT_APPLE           0x85B1
+#endif
+
+#ifndef GL_SGIX_fog_scale
+#define GL_FOG_SCALE_SGIX                 0x81FC
+#define GL_FOG_SCALE_VALUE_SGIX           0x81FD
+#endif
+
+#ifndef GL_SUNX_constant_data
+#define GL_UNPACK_CONSTANT_DATA_SUNX      0x81D5
+#define GL_TEXTURE_CONSTANT_DATA_SUNX     0x81D6
+#endif
+
+#ifndef GL_SUN_global_alpha
+#define GL_GLOBAL_ALPHA_SUN               0x81D9
+#define GL_GLOBAL_ALPHA_FACTOR_SUN        0x81DA
+#endif
+
+#ifndef GL_SUN_triangle_list
+#define GL_RESTART_SUN                    0x01
+#define GL_REPLACE_MIDDLE_SUN             0x02
+#define GL_REPLACE_OLDEST_SUN             0x03
+#define GL_TRIANGLE_LIST_SUN              0x81D7
+#define GL_REPLACEMENT_CODE_SUN           0x81D8
+#define GL_REPLACEMENT_CODE_ARRAY_SUN     0x85C0
+#define GL_REPLACEMENT_CODE_ARRAY_TYPE_SUN 0x85C1
+#define GL_REPLACEMENT_CODE_ARRAY_STRIDE_SUN 0x85C2
+#define GL_REPLACEMENT_CODE_ARRAY_POINTER_SUN 0x85C3
+#define GL_R1UI_V3F_SUN                   0x85C4
+#define GL_R1UI_C4UB_V3F_SUN              0x85C5
+#define GL_R1UI_C3F_V3F_SUN               0x85C6
+#define GL_R1UI_N3F_V3F_SUN               0x85C7
+#define GL_R1UI_C4F_N3F_V3F_SUN           0x85C8
+#define GL_R1UI_T2F_V3F_SUN               0x85C9
+#define GL_R1UI_T2F_N3F_V3F_SUN           0x85CA
+#define GL_R1UI_T2F_C4F_N3F_V3F_SUN       0x85CB
+#endif
+
+#ifndef GL_SUN_vertex
+#endif
+
+#ifndef GL_EXT_blend_func_separate
+#define GL_BLEND_DST_RGB_EXT              0x80C8
+#define GL_BLEND_SRC_RGB_EXT              0x80C9
+#define GL_BLEND_DST_ALPHA_EXT            0x80CA
+#define GL_BLEND_SRC_ALPHA_EXT            0x80CB
+#endif
+
+#ifndef GL_INGR_color_clamp
+#define GL_RED_MIN_CLAMP_INGR             0x8560
+#define GL_GREEN_MIN_CLAMP_INGR           0x8561
+#define GL_BLUE_MIN_CLAMP_INGR            0x8562
+#define GL_ALPHA_MIN_CLAMP_INGR           0x8563
+#define GL_RED_MAX_CLAMP_INGR             0x8564
+#define GL_GREEN_MAX_CLAMP_INGR           0x8565
+#define GL_BLUE_MAX_CLAMP_INGR            0x8566
+#define GL_ALPHA_MAX_CLAMP_INGR           0x8567
+#endif
+
+#ifndef GL_INGR_interlace_read
+#define GL_INTERLACE_READ_INGR            0x8568
+#endif
+
+#ifndef GL_EXT_stencil_wrap
+#define GL_INCR_WRAP_EXT                  0x8507
+#define GL_DECR_WRAP_EXT                  0x8508
+#endif
+
+#ifndef GL_EXT_422_pixels
+#define GL_422_EXT                        0x80CC
+#define GL_422_REV_EXT                    0x80CD
+#define GL_422_AVERAGE_EXT                0x80CE
+#define GL_422_REV_AVERAGE_EXT            0x80CF
+#endif
+
+#ifndef GL_NV_texgen_reflection
+#define GL_NORMAL_MAP_NV                  0x8511
+#define GL_REFLECTION_MAP_NV              0x8512
+#endif
+
+#ifndef GL_EXT_texture_cube_map
+#define GL_NORMAL_MAP_EXT                 0x8511
+#define GL_REFLECTION_MAP_EXT             0x8512
+#define GL_TEXTURE_CUBE_MAP_EXT           0x8513
+#define GL_TEXTURE_BINDING_CUBE_MAP_EXT   0x8514
+#define GL_TEXTURE_CUBE_MAP_POSITIVE_X_EXT 0x8515
+#define GL_TEXTURE_CUBE_MAP_NEGATIVE_X_EXT 0x8516
+#define GL_TEXTURE_CUBE_MAP_POSITIVE_Y_EXT 0x8517
+#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_EXT 0x8518
+#define GL_TEXTURE_CUBE_MAP_POSITIVE_Z_EXT 0x8519
+#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_EXT 0x851A
+#define GL_PROXY_TEXTURE_CUBE_MAP_EXT     0x851B
+#define GL_MAX_CUBE_MAP_TEXTURE_SIZE_EXT  0x851C
+#endif
+
+#ifndef GL_SUN_convolution_border_modes
+#define GL_WRAP_BORDER_SUN                0x81D4
+#endif
+
+#ifndef GL_EXT_texture_env_add
+#endif
+
+#ifndef GL_EXT_texture_lod_bias
+#define GL_MAX_TEXTURE_LOD_BIAS_EXT       0x84FD
+#define GL_TEXTURE_FILTER_CONTROL_EXT     0x8500
+#define GL_TEXTURE_LOD_BIAS_EXT           0x8501
+#endif
+
+#ifndef GL_EXT_texture_filter_anisotropic
+#define GL_TEXTURE_MAX_ANISOTROPY_EXT     0x84FE
+#define GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT 0x84FF
+#endif
+
+#ifndef GL_EXT_vertex_weighting
+#define GL_MODELVIEW0_STACK_DEPTH_EXT     GL_MODELVIEW_STACK_DEPTH
+#define GL_MODELVIEW1_STACK_DEPTH_EXT     0x8502
+#define GL_MODELVIEW0_MATRIX_EXT          GL_MODELVIEW_MATRIX
+#define GL_MODELVIEW_MATRIX1_EXT          0x8506
+#define GL_VERTEX_WEIGHTING_EXT           0x8509
+#define GL_MODELVIEW0_EXT                 GL_MODELVIEW
+#define GL_MODELVIEW1_EXT                 0x850A
+#define GL_CURRENT_VERTEX_WEIGHT_EXT      0x850B
+#define GL_VERTEX_WEIGHT_ARRAY_EXT        0x850C
+#define GL_VERTEX_WEIGHT_ARRAY_SIZE_EXT   0x850D
+#define GL_VERTEX_WEIGHT_ARRAY_TYPE_EXT   0x850E
+#define GL_VERTEX_WEIGHT_ARRAY_STRIDE_EXT 0x850F
+#define GL_VERTEX_WEIGHT_ARRAY_POINTER_EXT 0x8510
+#endif
+
+#ifndef GL_NV_light_max_exponent
+#define GL_MAX_SHININESS_NV               0x8504
+#define GL_MAX_SPOT_EXPONENT_NV           0x8505
+#endif
+
+#ifndef GL_NV_vertex_array_range
+#define GL_VERTEX_ARRAY_RANGE_NV          0x851D
+#define GL_VERTEX_ARRAY_RANGE_LENGTH_NV   0x851E
+#define GL_VERTEX_ARRAY_RANGE_VALID_NV    0x851F
+#define GL_MAX_VERTEX_ARRAY_RANGE_ELEMENT_NV 0x8520
+#define GL_VERTEX_ARRAY_RANGE_POINTER_NV  0x8521
+#endif
+
+#ifndef GL_NV_register_combiners
+#define GL_REGISTER_COMBINERS_NV          0x8522
+#define GL_VARIABLE_A_NV                  0x8523
+#define GL_VARIABLE_B_NV                  0x8524
+#define GL_VARIABLE_C_NV                  0x8525
+#define GL_VARIABLE_D_NV                  0x8526
+#define GL_VARIABLE_E_NV                  0x8527
+#define GL_VARIABLE_F_NV                  0x8528
+#define GL_VARIABLE_G_NV                  0x8529
+#define GL_CONSTANT_COLOR0_NV             0x852A
+#define GL_CONSTANT_COLOR1_NV             0x852B
+#define GL_PRIMARY_COLOR_NV               0x852C
+#define GL_SECONDARY_COLOR_NV             0x852D
+#define GL_SPARE0_NV                      0x852E
+#define GL_SPARE1_NV                      0x852F
+#define GL_DISCARD_NV                     0x8530
+#define GL_E_TIMES_F_NV                   0x8531
+#define GL_SPARE0_PLUS_SECONDARY_COLOR_NV 0x8532
+#define GL_UNSIGNED_IDENTITY_NV           0x8536
+#define GL_UNSIGNED_INVERT_NV             0x8537
+#define GL_EXPAND_NORMAL_NV               0x8538
+#define GL_EXPAND_NEGATE_NV               0x8539
+#define GL_HALF_BIAS_NORMAL_NV            0x853A
+#define GL_HALF_BIAS_NEGATE_NV            0x853B
+#define GL_SIGNED_IDENTITY_NV             0x853C
+#define GL_SIGNED_NEGATE_NV               0x853D
+#define GL_SCALE_BY_TWO_NV                0x853E
+#define GL_SCALE_BY_FOUR_NV               0x853F
+#define GL_SCALE_BY_ONE_HALF_NV           0x8540
+#define GL_BIAS_BY_NEGATIVE_ONE_HALF_NV   0x8541
+#define GL_COMBINER_INPUT_NV              0x8542
+#define GL_COMBINER_MAPPING_NV            0x8543
+#define GL_COMBINER_COMPONENT_USAGE_NV    0x8544
+#define GL_COMBINER_AB_DOT_PRODUCT_NV     0x8545
+#define GL_COMBINER_CD_DOT_PRODUCT_NV     0x8546
+#define GL_COMBINER_MUX_SUM_NV            0x8547
+#define GL_COMBINER_SCALE_NV              0x8548
+#define GL_COMBINER_BIAS_NV               0x8549
+#define GL_COMBINER_AB_OUTPUT_NV          0x854A
+#define GL_COMBINER_CD_OUTPUT_NV          0x854B
+#define GL_COMBINER_SUM_OUTPUT_NV         0x854C
+#define GL_MAX_GENERAL_COMBINERS_NV       0x854D
+#define GL_NUM_GENERAL_COMBINERS_NV       0x854E
+#define GL_COLOR_SUM_CLAMP_NV             0x854F
+#define GL_COMBINER0_NV                   0x8550
+#define GL_COMBINER1_NV                   0x8551
+#define GL_COMBINER2_NV                   0x8552
+#define GL_COMBINER3_NV                   0x8553
+#define GL_COMBINER4_NV                   0x8554
+#define GL_COMBINER5_NV                   0x8555
+#define GL_COMBINER6_NV                   0x8556
+#define GL_COMBINER7_NV                   0x8557
+/* reuse GL_TEXTURE0_ARB */
+/* reuse GL_TEXTURE1_ARB */
+/* reuse GL_ZERO */
+/* reuse GL_NONE */
+/* reuse GL_FOG */
+#endif
+
+#ifndef GL_NV_fog_distance
+#define GL_FOG_DISTANCE_MODE_NV           0x855A
+#define GL_EYE_RADIAL_NV                  0x855B
+#define GL_EYE_PLANE_ABSOLUTE_NV          0x855C
+/* reuse GL_EYE_PLANE */
+#endif
+
+#ifndef GL_NV_texgen_emboss
+#define GL_EMBOSS_LIGHT_NV                0x855D
+#define GL_EMBOSS_CONSTANT_NV             0x855E
+#define GL_EMBOSS_MAP_NV                  0x855F
+#endif
+
+#ifndef GL_NV_blend_square
+#endif
+
+#ifndef GL_NV_texture_env_combine4
+#define GL_COMBINE4_NV                    0x8503
+#define GL_SOURCE3_RGB_NV                 0x8583
+#define GL_SOURCE3_ALPHA_NV               0x858B
+#define GL_OPERAND3_RGB_NV                0x8593
+#define GL_OPERAND3_ALPHA_NV              0x859B
+#endif
+
+#ifndef GL_MESA_resize_buffers
+#endif
+
+#ifndef GL_MESA_window_pos
+#endif
+
+#ifndef GL_EXT_texture_compression_s3tc
+#define GL_COMPRESSED_RGB_S3TC_DXT1_EXT   0x83F0
+#define GL_COMPRESSED_RGBA_S3TC_DXT1_EXT  0x83F1
+#define GL_COMPRESSED_RGBA_S3TC_DXT3_EXT  0x83F2
+#define GL_COMPRESSED_RGBA_S3TC_DXT5_EXT  0x83F3
+#endif
+
+#ifndef GL_IBM_cull_vertex
+#define GL_CULL_VERTEX_IBM                103050
+#endif
+
+#ifndef GL_IBM_multimode_draw_arrays
+#endif
+
+#ifndef GL_IBM_vertex_array_lists
+#define GL_VERTEX_ARRAY_LIST_IBM          103070
+#define GL_NORMAL_ARRAY_LIST_IBM          103071
+#define GL_COLOR_ARRAY_LIST_IBM           103072
+#define GL_INDEX_ARRAY_LIST_IBM           103073
+#define GL_TEXTURE_COORD_ARRAY_LIST_IBM   103074
+#define GL_EDGE_FLAG_ARRAY_LIST_IBM       103075
+#define GL_FOG_COORDINATE_ARRAY_LIST_IBM  103076
+#define GL_SECONDARY_COLOR_ARRAY_LIST_IBM 103077
+#define GL_VERTEX_ARRAY_LIST_STRIDE_IBM   103080
+#define GL_NORMAL_ARRAY_LIST_STRIDE_IBM   103081
+#define GL_COLOR_ARRAY_LIST_STRIDE_IBM    103082
+#define GL_INDEX_ARRAY_LIST_STRIDE_IBM    103083
+#define GL_TEXTURE_COORD_ARRAY_LIST_STRIDE_IBM 103084
+#define GL_EDGE_FLAG_ARRAY_LIST_STRIDE_IBM 103085
+#define GL_FOG_COORDINATE_ARRAY_LIST_STRIDE_IBM 103086
+#define GL_SECONDARY_COLOR_ARRAY_LIST_STRIDE_IBM 103087
+#endif
+
+#ifndef GL_SGIX_subsample
+#define GL_PACK_SUBSAMPLE_RATE_SGIX       0x85A0
+#define GL_UNPACK_SUBSAMPLE_RATE_SGIX     0x85A1
+#define GL_PIXEL_SUBSAMPLE_4444_SGIX      0x85A2
+#define GL_PIXEL_SUBSAMPLE_2424_SGIX      0x85A3
+#define GL_PIXEL_SUBSAMPLE_4242_SGIX      0x85A4
+#endif
+
+#ifndef GL_SGIX_ycrcb_subsample
+#endif
+
+#ifndef GL_SGIX_ycrcba
+#define GL_YCRCB_SGIX                     0x8318
+#define GL_YCRCBA_SGIX                    0x8319
+#endif
+
+#ifndef GL_SGI_depth_pass_instrument
+#define GL_DEPTH_PASS_INSTRUMENT_SGIX     0x8310
+#define GL_DEPTH_PASS_INSTRUMENT_COUNTERS_SGIX 0x8311
+#define GL_DEPTH_PASS_INSTRUMENT_MAX_SGIX 0x8312
+#endif
+
+#ifndef GL_3DFX_texture_compression_FXT1
+#define GL_COMPRESSED_RGB_FXT1_3DFX       0x86B0
+#define GL_COMPRESSED_RGBA_FXT1_3DFX      0x86B1
+#endif
+
+#ifndef GL_3DFX_multisample
+#define GL_MULTISAMPLE_3DFX               0x86B2
+#define GL_SAMPLE_BUFFERS_3DFX            0x86B3
+#define GL_SAMPLES_3DFX                   0x86B4
+#define GL_MULTISAMPLE_BIT_3DFX           0x20000000
+#endif
+
+#ifndef GL_3DFX_tbuffer
+#endif
+
+#ifndef GL_EXT_multisample
+#define GL_MULTISAMPLE_EXT                0x809D
+#define GL_SAMPLE_ALPHA_TO_MASK_EXT       0x809E
+#define GL_SAMPLE_ALPHA_TO_ONE_EXT        0x809F
+#define GL_SAMPLE_MASK_EXT                0x80A0
+#define GL_1PASS_EXT                      0x80A1
+#define GL_2PASS_0_EXT                    0x80A2
+#define GL_2PASS_1_EXT                    0x80A3
+#define GL_4PASS_0_EXT                    0x80A4
+#define GL_4PASS_1_EXT                    0x80A5
+#define GL_4PASS_2_EXT                    0x80A6
+#define GL_4PASS_3_EXT                    0x80A7
+#define GL_SAMPLE_BUFFERS_EXT             0x80A8
+#define GL_SAMPLES_EXT                    0x80A9
+#define GL_SAMPLE_MASK_VALUE_EXT          0x80AA
+#define GL_SAMPLE_MASK_INVERT_EXT         0x80AB
+#define GL_SAMPLE_PATTERN_EXT             0x80AC
+#endif
+
+#ifndef GL_SGIX_vertex_preclip
+#define GL_VERTEX_PRECLIP_SGIX            0x83EE
+#define GL_VERTEX_PRECLIP_HINT_SGIX       0x83EF
+#endif
+
+#ifndef GL_SGIX_convolution_accuracy
+#define GL_CONVOLUTION_HINT_SGIX          0x8316
+#endif
+
+#ifndef GL_SGIX_resample
+#define GL_PACK_RESAMPLE_SGIX             0x842C
+#define GL_UNPACK_RESAMPLE_SGIX           0x842D
+#define GL_RESAMPLE_REPLICATE_SGIX        0x842E
+#define GL_RESAMPLE_ZERO_FILL_SGIX        0x842F
+#define GL_RESAMPLE_DECIMATE_SGIX         0x8430
+#endif
+
+#ifndef GL_SGIS_point_line_texgen
+#define GL_EYE_DISTANCE_TO_POINT_SGIS     0x81F0
+#define GL_OBJECT_DISTANCE_TO_POINT_SGIS  0x81F1
+#define GL_EYE_DISTANCE_TO_LINE_SGIS      0x81F2
+#define GL_OBJECT_DISTANCE_TO_LINE_SGIS   0x81F3
+#define GL_EYE_POINT_SGIS                 0x81F4
+#define GL_OBJECT_POINT_SGIS              0x81F5
+#define GL_EYE_LINE_SGIS                  0x81F6
+#define GL_OBJECT_LINE_SGIS               0x81F7
+#endif
+
+#ifndef GL_SGIS_texture_color_mask
+#define GL_TEXTURE_COLOR_WRITEMASK_SGIS   0x81EF
+#endif
+
+
+/*************************************************************/
+
+#ifndef GL_VERSION_1_2
+#define GL_VERSION_1_2 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glBlendColor (GLclampf, GLclampf, GLclampf, GLclampf);
+extern void glBlendEquation (GLenum);
+extern void glDrawRangeElements (GLenum, GLuint, GLuint, GLsizei, GLenum, const GLvoid *);
+extern void glColorTable (GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *);
+extern void glColorTableParameterfv (GLenum, GLenum, const GLfloat *);
+extern void glColorTableParameteriv (GLenum, GLenum, const GLint *);
+extern void glCopyColorTable (GLenum, GLenum, GLint, GLint, GLsizei);
+extern void glGetColorTable (GLenum, GLenum, GLenum, GLvoid *);
+extern void glGetColorTableParameterfv (GLenum, GLenum, GLfloat *);
+extern void glGetColorTableParameteriv (GLenum, GLenum, GLint *);
+extern void glColorSubTable (GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *);
+extern void glCopyColorSubTable (GLenum, GLsizei, GLint, GLint, GLsizei);
+extern void glConvolutionFilter1D (GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *);
+extern void glConvolutionFilter2D (GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *);
+extern void glConvolutionParameterf (GLenum, GLenum, GLfloat);
+extern void glConvolutionParameterfv (GLenum, GLenum, const GLfloat *);
+extern void glConvolutionParameteri (GLenum, GLenum, GLint);
+extern void glConvolutionParameteriv (GLenum, GLenum, const GLint *);
+extern void glCopyConvolutionFilter1D (GLenum, GLenum, GLint, GLint, GLsizei);
+extern void glCopyConvolutionFilter2D (GLenum, GLenum, GLint, GLint, GLsizei, GLsizei);
+extern void glGetConvolutionFilter (GLenum, GLenum, GLenum, GLvoid *);
+extern void glGetConvolutionParameterfv (GLenum, GLenum, GLfloat *);
+extern void glGetConvolutionParameteriv (GLenum, GLenum, GLint *);
+extern void glGetSeparableFilter (GLenum, GLenum, GLenum, GLvoid *, GLvoid *, GLvoid *);
+extern void glSeparableFilter2D (GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *, const GLvoid *);
+extern void glGetHistogram (GLenum, GLboolean, GLenum, GLenum, GLvoid *);
+extern void glGetHistogramParameterfv (GLenum, GLenum, GLfloat *);
+extern void glGetHistogramParameteriv (GLenum, GLenum, GLint *);
+extern void glGetMinmax (GLenum, GLboolean, GLenum, GLenum, GLvoid *);
+extern void glGetMinmaxParameterfv (GLenum, GLenum, GLfloat *);
+extern void glGetMinmaxParameteriv (GLenum, GLenum, GLint *);
+extern void glHistogram (GLenum, GLsizei, GLenum, GLboolean);
+extern void glMinmax (GLenum, GLenum, GLboolean);
+extern void glResetHistogram (GLenum);
+extern void glResetMinmax (GLenum);
+extern void glTexImage3D (GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *);
+extern void glTexSubImage3D (GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *);
+extern void glCopyTexSubImage3D (GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_ARB_multitexture
+#define GL_ARB_multitexture 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glActiveTextureARB (GLenum);
+extern void glClientActiveTextureARB (GLenum);
+extern void glMultiTexCoord1dARB (GLenum, GLdouble);
+extern void glMultiTexCoord1dvARB (GLenum, const GLdouble *);
+extern void glMultiTexCoord1fARB (GLenum, GLfloat);
+extern void glMultiTexCoord1fvARB (GLenum, const GLfloat *);
+extern void glMultiTexCoord1iARB (GLenum, GLint);
+extern void glMultiTexCoord1ivARB (GLenum, const GLint *);
+extern void glMultiTexCoord1sARB (GLenum, GLshort);
+extern void glMultiTexCoord1svARB (GLenum, const GLshort *);
+extern void glMultiTexCoord2dARB (GLenum, GLdouble, GLdouble);
+extern void glMultiTexCoord2dvARB (GLenum, const GLdouble *);
+extern void glMultiTexCoord2fARB (GLenum, GLfloat, GLfloat);
+extern void glMultiTexCoord2fvARB (GLenum, const GLfloat *);
+extern void glMultiTexCoord2iARB (GLenum, GLint, GLint);
+extern void glMultiTexCoord2ivARB (GLenum, const GLint *);
+extern void glMultiTexCoord2sARB (GLenum, GLshort, GLshort);
+extern void glMultiTexCoord2svARB (GLenum, const GLshort *);
+extern void glMultiTexCoord3dARB (GLenum, GLdouble, GLdouble, GLdouble);
+extern void glMultiTexCoord3dvARB (GLenum, const GLdouble *);
+extern void glMultiTexCoord3fARB (GLenum, GLfloat, GLfloat, GLfloat);
+extern void glMultiTexCoord3fvARB (GLenum, const GLfloat *);
+extern void glMultiTexCoord3iARB (GLenum, GLint, GLint, GLint);
+extern void glMultiTexCoord3ivARB (GLenum, const GLint *);
+extern void glMultiTexCoord3sARB (GLenum, GLshort, GLshort, GLshort);
+extern void glMultiTexCoord3svARB (GLenum, const GLshort *);
+extern void glMultiTexCoord4dARB (GLenum, GLdouble, GLdouble, GLdouble, GLdouble);
+extern void glMultiTexCoord4dvARB (GLenum, const GLdouble *);
+extern void glMultiTexCoord4fARB (GLenum, GLfloat, GLfloat, GLfloat, GLfloat);
+extern void glMultiTexCoord4fvARB (GLenum, const GLfloat *);
+extern void glMultiTexCoord4iARB (GLenum, GLint, GLint, GLint, GLint);
+extern void glMultiTexCoord4ivARB (GLenum, const GLint *);
+extern void glMultiTexCoord4sARB (GLenum, GLshort, GLshort, GLshort, GLshort);
+extern void glMultiTexCoord4svARB (GLenum, const GLshort *);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_ARB_transpose_matrix
+#define GL_ARB_transpose_matrix 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glLoadTransposeMatrixfARB (const GLfloat *);
+extern void glLoadTransposeMatrixdARB (const GLdouble *);
+extern void glMultTransposeMatrixfARB (const GLfloat *);
+extern void glMultTransposeMatrixdARB (const GLdouble *);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_ARB_multisample
+#define GL_ARB_multisample 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glSampleCoverageARB (GLclampf, GLboolean);
+extern void glSamplePassARB (GLenum);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_ARB_texture_env_add
+#define GL_ARB_texture_env_add 1
+#endif
+
+#ifndef GL_ARB_texture_cube_map
+#define GL_ARB_texture_cube_map 1
+#endif
+
+#ifndef GL_ARB_texture_compression
+#define GL_ARB_texture_compression 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glCompressedTexImage3DARB (GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLsizei, const GLvoid *);
+extern void glCompressedTexImage2DARB (GLenum, GLint, GLenum, GLsizei, GLsizei, GLint, GLsizei, const GLvoid *);
+extern void glCompressedTexImage1DARB (GLenum, GLint, GLenum, GLsizei, GLint, GLsizei, const GLvoid *);
+extern void glCompressedTexSubImage3DARB (GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLsizei, const GLvoid *);
+extern void glCompressedTexSubImage2DARB (GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLsizei, const GLvoid *);
+extern void glCompressedTexSubImage1DARB (GLenum, GLint, GLint, GLsizei, GLenum, GLsizei, const GLvoid *);
+extern void glGetCompressedTexImageARB (GLenum, GLint, void *);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_EXT_abgr
+#define GL_EXT_abgr 1
+#endif
+
+#ifndef GL_EXT_blend_color
+#define GL_EXT_blend_color 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glBlendColorEXT (GLclampf, GLclampf, GLclampf, GLclampf);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_EXT_polygon_offset
+#define GL_EXT_polygon_offset 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glPolygonOffsetEXT (GLfloat, GLfloat);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_EXT_texture
+#define GL_EXT_texture 1
+#endif
+
+#ifndef GL_EXT_texture3D
+#define GL_EXT_texture3D 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glTexImage3DEXT (GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *);
+extern void glTexSubImage3DEXT (GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_SGIS_texture_filter4
+#define GL_SGIS_texture_filter4 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glGetTexFilterFuncSGIS (GLenum, GLenum, GLfloat *);
+extern void glTexFilterFuncSGIS (GLenum, GLenum, GLsizei, const GLfloat *);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_EXT_subtexture
+#define GL_EXT_subtexture 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glTexSubImage1DEXT (GLenum, GLint, GLint, GLsizei, GLenum, GLenum, const GLvoid *);
+extern void glTexSubImage2DEXT (GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_EXT_copy_texture
+#define GL_EXT_copy_texture 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glCopyTexImage1DEXT (GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLint);
+extern void glCopyTexImage2DEXT (GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLsizei, GLint);
+extern void glCopyTexSubImage1DEXT (GLenum, GLint, GLint, GLint, GLint, GLsizei);
+extern void glCopyTexSubImage2DEXT (GLenum, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei);
+extern void glCopyTexSubImage3DEXT (GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_EXT_histogram
+#define GL_EXT_histogram 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glGetHistogramEXT (GLenum, GLboolean, GLenum, GLenum, GLvoid *);
+extern void glGetHistogramParameterfvEXT (GLenum, GLenum, GLfloat *);
+extern void glGetHistogramParameterivEXT (GLenum, GLenum, GLint *);
+extern void glGetMinmaxEXT (GLenum, GLboolean, GLenum, GLenum, GLvoid *);
+extern void glGetMinmaxParameterfvEXT (GLenum, GLenum, GLfloat *);
+extern void glGetMinmaxParameterivEXT (GLenum, GLenum, GLint *);
+extern void glHistogramEXT (GLenum, GLsizei, GLenum, GLboolean);
+extern void glMinmaxEXT (GLenum, GLenum, GLboolean);
+extern void glResetHistogramEXT (GLenum);
+extern void glResetMinmaxEXT (GLenum);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_EXT_convolution
+#define GL_EXT_convolution 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glConvolutionFilter1DEXT (GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *);
+extern void glConvolutionFilter2DEXT (GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *);
+extern void glConvolutionParameterfEXT (GLenum, GLenum, GLfloat);
+extern void glConvolutionParameterfvEXT (GLenum, GLenum, const GLfloat *);
+extern void glConvolutionParameteriEXT (GLenum, GLenum, GLint);
+extern void glConvolutionParameterivEXT (GLenum, GLenum, const GLint *);
+extern void glCopyConvolutionFilter1DEXT (GLenum, GLenum, GLint, GLint, GLsizei);
+extern void glCopyConvolutionFilter2DEXT (GLenum, GLenum, GLint, GLint, GLsizei, GLsizei);
+extern void glGetConvolutionFilterEXT (GLenum, GLenum, GLenum, GLvoid *);
+extern void glGetConvolutionParameterfvEXT (GLenum, GLenum, GLfloat *);
+extern void glGetConvolutionParameterivEXT (GLenum, GLenum, GLint *);
+extern void glGetSeparableFilterEXT (GLenum, GLenum, GLenum, GLvoid *, GLvoid *, GLvoid *);
+extern void glSeparableFilter2DEXT (GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *, const GLvoid *);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_EXT_color_matrix
+#define GL_EXT_color_matrix 1
+#endif
+
+#ifndef GL_SGI_color_table
+#define GL_SGI_color_table 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glColorTableSGI (GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *);
+extern void glColorTableParameterfvSGI (GLenum, GLenum, const GLfloat *);
+extern void glColorTableParameterivSGI (GLenum, GLenum, const GLint *);
+extern void glCopyColorTableSGI (GLenum, GLenum, GLint, GLint, GLsizei);
+extern void glGetColorTableSGI (GLenum, GLenum, GLenum, GLvoid *);
+extern void glGetColorTableParameterfvSGI (GLenum, GLenum, GLfloat *);
+extern void glGetColorTableParameterivSGI (GLenum, GLenum, GLint *);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_SGIX_pixel_texture
+#define GL_SGIX_pixel_texture 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glPixelTexGenSGIX (GLenum);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_SGIS_pixel_texture
+#define GL_SGIS_pixel_texture 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glPixelTexGenParameteriSGIS (GLenum, GLint);
+extern void glPixelTexGenParameterivSGIS (GLenum, const GLint *);
+extern void glPixelTexGenParameterfSGIS (GLenum, GLfloat);
+extern void glPixelTexGenParameterfvSGIS (GLenum, const GLfloat *);
+extern void glGetPixelTexGenParameterivSGIS (GLenum, GLint *);
+extern void glGetPixelTexGenParameterfvSGIS (GLenum, GLfloat *);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_SGIS_texture4D
+#define GL_SGIS_texture4D 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glTexImage4DSGIS (GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *);
+extern void glTexSubImage4DSGIS (GLenum, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_SGI_texture_color_table
+#define GL_SGI_texture_color_table 1
+#endif
+
+#ifndef GL_EXT_cmyka
+#define GL_EXT_cmyka 1
+#endif
+
+#ifndef GL_EXT_texture_object
+#define GL_EXT_texture_object 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern GLboolean glAreTexturesResidentEXT (GLsizei, const GLuint *, GLboolean *);
+extern void glBindTextureEXT (GLenum, GLuint);
+extern void glDeleteTexturesEXT (GLsizei, const GLuint *);
+extern void glGenTexturesEXT (GLsizei, GLuint *);
+extern GLboolean glIsTextureEXT (GLuint);
+extern void glPrioritizeTexturesEXT (GLsizei, const GLuint *, const GLclampf *);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_SGIS_detail_texture
+#define GL_SGIS_detail_texture 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glDetailTexFuncSGIS (GLenum, GLsizei, const GLfloat *);
+extern void glGetDetailTexFuncSGIS (GLenum, GLfloat *);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_SGIS_sharpen_texture
+#define GL_SGIS_sharpen_texture 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glSharpenTexFuncSGIS (GLenum, GLsizei, const GLfloat *);
+extern void glGetSharpenTexFuncSGIS (GLenum, GLfloat *);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_EXT_packed_pixels
+#define GL_EXT_packed_pixels 1
+#endif
+
+#ifndef GL_SGIS_texture_lod
+#define GL_SGIS_texture_lod 1
+#endif
+
+#ifndef GL_SGIS_multisample
+#define GL_SGIS_multisample 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glSampleMaskSGIS (GLclampf, GLboolean);
+extern void glSamplePatternSGIS (GLenum);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_EXT_rescale_normal
+#define GL_EXT_rescale_normal 1
+#endif
+
+#ifndef GL_EXT_vertex_array
+#define GL_EXT_vertex_array 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glArrayElementEXT (GLint);
+extern void glColorPointerEXT (GLint, GLenum, GLsizei, GLsizei, const GLvoid *);
+extern void glDrawArraysEXT (GLenum, GLint, GLsizei);
+extern void glEdgeFlagPointerEXT (GLsizei, GLsizei, const GLboolean *);
+extern void glGetPointervEXT (GLenum, GLvoid* *);
+extern void glIndexPointerEXT (GLenum, GLsizei, GLsizei, const GLvoid *);
+extern void glNormalPointerEXT (GLenum, GLsizei, GLsizei, const GLvoid *);
+extern void glTexCoordPointerEXT (GLint, GLenum, GLsizei, GLsizei, const GLvoid *);
+extern void glVertexPointerEXT (GLint, GLenum, GLsizei, GLsizei, const GLvoid *);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_EXT_misc_attribute
+#define GL_EXT_misc_attribute 1
+#endif
+
+#ifndef GL_SGIS_generate_mipmap
+#define GL_SGIS_generate_mipmap 1
+#endif
+
+#ifndef GL_SGIX_clipmap
+#define GL_SGIX_clipmap 1
+#endif
+
+#ifndef GL_SGIX_shadow
+#define GL_SGIX_shadow 1
+#endif
+
+#ifndef GL_SGIS_texture_edge_clamp
+#define GL_SGIS_texture_edge_clamp 1
+#endif
+
+#ifndef GL_SGIS_texture_border_clamp
+#define GL_SGIS_texture_border_clamp 1
+#endif
+
+#ifndef GL_EXT_blend_minmax
+#define GL_EXT_blend_minmax 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glBlendEquationEXT (GLenum);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_EXT_blend_subtract
+#define GL_EXT_blend_subtract 1
+#endif
+
+#ifndef GL_EXT_blend_logic_op
+#define GL_EXT_blend_logic_op 1
+#endif
+
+#ifndef GL_SGIX_interlace
+#define GL_SGIX_interlace 1
+#endif
+
+#ifndef GL_SGIX_pixel_tiles
+#define GL_SGIX_pixel_tiles 1
+#endif
+
+#ifndef GL_SGIX_texture_select
+#define GL_SGIX_texture_select 1
+#endif
+
+#ifndef GL_SGIX_sprite
+#define GL_SGIX_sprite 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glSpriteParameterfSGIX (GLenum, GLfloat);
+extern void glSpriteParameterfvSGIX (GLenum, const GLfloat *);
+extern void glSpriteParameteriSGIX (GLenum, GLint);
+extern void glSpriteParameterivSGIX (GLenum, const GLint *);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_SGIX_texture_multi_buffer
+#define GL_SGIX_texture_multi_buffer 1
+#endif
+
+#ifndef GL_EXT_point_parameters
+#define GL_EXT_point_parameters 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glPointParameterfEXT (GLenum, GLfloat);
+extern void glPointParameterfvEXT (GLenum, const GLfloat *);
+extern void glPointParameterfSGIS (GLenum, GLfloat);
+extern void glPointParameterfvSGIS (GLenum, const GLfloat *);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_SGIX_instruments
+#define GL_SGIX_instruments 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern GLint glGetInstrumentsSGIX (void);
+extern void glInstrumentsBufferSGIX (GLsizei, GLint *);
+extern GLint glPollInstrumentsSGIX (GLint *);
+extern void glReadInstrumentsSGIX (GLint);
+extern void glStartInstrumentsSGIX (void);
+extern void glStopInstrumentsSGIX (GLint);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_SGIX_texture_scale_bias
+#define GL_SGIX_texture_scale_bias 1
+#endif
+
+#ifndef GL_SGIX_framezoom
+#define GL_SGIX_framezoom 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glFrameZoomSGIX (GLint);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_SGIX_tag_sample_buffer
+#define GL_SGIX_tag_sample_buffer 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glTagSampleBufferSGIX (void);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_SGIX_reference_plane
+#define GL_SGIX_reference_plane 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glReferencePlaneSGIX (const GLdouble *);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_SGIX_flush_raster
+#define GL_SGIX_flush_raster 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glFlushRasterSGIX (void);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_SGIX_depth_texture
+#define GL_SGIX_depth_texture 1
+#endif
+
+#ifndef GL_SGIS_fog_function
+#define GL_SGIS_fog_function 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glFogFuncSGIS (GLsizei, const GLfloat *);
+extern void glGetFogFuncSGIS (const GLfloat *);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_SGIX_fog_offset
+#define GL_SGIX_fog_offset 1
+#endif
+
+#ifndef GL_HP_image_transform
+#define GL_HP_image_transform 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glImageTransformParameteriHP (GLenum, GLenum, GLint);
+extern void glImageTransformParameterfHP (GLenum, GLenum, GLfloat);
+extern void glImageTransformParameterivHP (GLenum, GLenum, const GLint *);
+extern void glImageTransformParameterfvHP (GLenum, GLenum, const GLfloat *);
+extern void glGetImageTransformParameterivHP (GLenum, GLenum, GLint *);
+extern void glGetImageTransformParameterfvHP (GLenum, GLenum, GLfloat *);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_HP_convolution_border_modes
+#define GL_HP_convolution_border_modes 1
+#endif
+
+#ifndef GL_SGIX_texture_add_env
+#define GL_SGIX_texture_add_env 1
+#endif
+
+#ifndef GL_EXT_color_subtable
+#define GL_EXT_color_subtable 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glColorSubTableEXT (GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *);
+extern void glCopyColorSubTableEXT (GLenum, GLsizei, GLint, GLint, GLsizei);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_PGI_vertex_hints
+#define GL_PGI_vertex_hints 1
+#endif
+
+#ifndef GL_PGI_misc_hints
+#define GL_PGI_misc_hints 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glHintPGI (GLenum, GLint);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_EXT_paletted_texture
+#define GL_EXT_paletted_texture 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glColorTableEXT (GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *);
+extern void glGetColorTableEXT (GLenum, GLenum, GLenum, GLvoid *);
+extern void glGetColorTableParameterivEXT (GLenum, GLenum, GLint *);
+extern void glGetColorTableParameterfvEXT (GLenum, GLenum, GLfloat *);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_EXT_clip_volume_hint
+#define GL_EXT_clip_volume_hint 1
+#endif
+
+#ifndef GL_SGIX_list_priority
+#define GL_SGIX_list_priority 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glGetListParameterfvSGIX (GLuint, GLenum, GLfloat *);
+extern void glGetListParameterivSGIX (GLuint, GLenum, GLint *);
+extern void glListParameterfSGIX (GLuint, GLenum, GLfloat);
+extern void glListParameterfvSGIX (GLuint, GLenum, const GLfloat *);
+extern void glListParameteriSGIX (GLuint, GLenum, GLint);
+extern void glListParameterivSGIX (GLuint, GLenum, const GLint *);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_SGIX_ir_instrument1
+#define GL_SGIX_ir_instrument1 1
+#endif
+
+#ifndef GL_SGIX_calligraphic_fragment
+#define GL_SGIX_calligraphic_fragment 1
+#endif
+
+#ifndef GL_SGIX_texture_lod_bias
+#define GL_SGIX_texture_lod_bias 1
+#endif
+
+#ifndef GL_SGIX_shadow_ambient
+#define GL_SGIX_shadow_ambient 1
+#endif
+
+#ifndef GL_EXT_index_texture
+#define GL_EXT_index_texture 1
+#endif
+
+#ifndef GL_EXT_index_material
+#define GL_EXT_index_material 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glIndexMaterialEXT (GLenum, GLenum);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_EXT_index_func
+#define GL_EXT_index_func 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glIndexFuncEXT (GLenum, GLclampf);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_EXT_index_array_formats
+#define GL_EXT_index_array_formats 1
+#endif
+
+#ifndef GL_EXT_compiled_vertex_array
+#define GL_EXT_compiled_vertex_array 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glLockArraysEXT (GLint, GLsizei);
+extern void glUnlockArraysEXT (void);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_EXT_cull_vertex
+#define GL_EXT_cull_vertex 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glCullParameterdvEXT (GLenum, GLdouble *);
+extern void glCullParameterfvEXT (GLenum, GLfloat *);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_SGIX_ycrcb
+#define GL_SGIX_ycrcb 1
+#endif
+
+#ifndef GL_SGIX_fragment_lighting
+#define GL_SGIX_fragment_lighting 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glFragmentColorMaterialSGIX (GLenum, GLenum);
+extern void glFragmentLightfSGIX (GLenum, GLenum, GLfloat);
+extern void glFragmentLightfvSGIX (GLenum, GLenum, const GLfloat *);
+extern void glFragmentLightiSGIX (GLenum, GLenum, GLint);
+extern void glFragmentLightivSGIX (GLenum, GLenum, const GLint *);
+extern void glFragmentLightModelfSGIX (GLenum, GLfloat);
+extern void glFragmentLightModelfvSGIX (GLenum, const GLfloat *);
+extern void glFragmentLightModeliSGIX (GLenum, GLint);
+extern void glFragmentLightModelivSGIX (GLenum, const GLint *);
+extern void glFragmentMaterialfSGIX (GLenum, GLenum, GLfloat);
+extern void glFragmentMaterialfvSGIX (GLenum, GLenum, const GLfloat *);
+extern void glFragmentMaterialiSGIX (GLenum, GLenum, GLint);
+extern void glFragmentMaterialivSGIX (GLenum, GLenum, const GLint *);
+extern void glGetFragmentLightfvSGIX (GLenum, GLenum, GLfloat *);
+extern void glGetFragmentLightivSGIX (GLenum, GLenum, GLint *);
+extern void glGetFragmentMaterialfvSGIX (GLenum, GLenum, GLfloat *);
+extern void glGetFragmentMaterialivSGIX (GLenum, GLenum, GLint *);
+extern void glLightEnviSGIX (GLenum, GLint);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_IBM_rasterpos_clip
+#define GL_IBM_rasterpos_clip 1
+#endif
+
+#ifndef GL_HP_texture_lighting
+#define GL_HP_texture_lighting 1
+#endif
+
+#ifndef GL_EXT_draw_range_elements
+#define GL_EXT_draw_range_elements 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glDrawRangeElementsEXT (GLenum, GLuint, GLuint, GLsizei, GLenum, const GLvoid *);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_WIN_phong_shading
+#define GL_WIN_phong_shading 1
+#endif
+
+#ifndef GL_WIN_specular_fog
+#define GL_WIN_specular_fog 1
+#endif
+
+#ifndef GL_EXT_light_texture
+#define GL_EXT_light_texture 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glApplyTextureEXT (GLenum);
+extern void glTextureLightEXT (GLenum);
+extern void glTextureMaterialEXT (GLenum, GLenum);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_SGIX_blend_alpha_minmax
+#define GL_SGIX_blend_alpha_minmax 1
+#endif
+
+#ifndef GL_EXT_bgra
+#define GL_EXT_bgra 1
+#endif
+
+#ifndef GL_INTEL_parallel_arrays
+#define GL_INTEL_parallel_arrays 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glVertexPointervINTEL (GLint, GLenum, const GLvoid* *);
+extern void glNormalPointervINTEL (GLenum, const GLvoid* *);
+extern void glColorPointervINTEL (GLint, GLenum, const GLvoid* *);
+extern void glTexCoordPointervINTEL (GLint, GLenum, const GLvoid* *);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_HP_occlusion_test
+#define GL_HP_occlusion_test 1
+#endif
+
+#ifndef GL_EXT_pixel_transform
+#define GL_EXT_pixel_transform 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glPixelTransformParameteriEXT (GLenum, GLenum, GLint);
+extern void glPixelTransformParameterfEXT (GLenum, GLenum, GLfloat);
+extern void glPixelTransformParameterivEXT (GLenum, GLenum, const GLint *);
+extern void glPixelTransformParameterfvEXT (GLenum, GLenum, const GLfloat *);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_EXT_pixel_transform_color_table
+#define GL_EXT_pixel_transform_color_table 1
+#endif
+
+#ifndef GL_EXT_shared_texture_palette
+#define GL_EXT_shared_texture_palette 1
+#endif
+
+#ifndef GL_EXT_separate_specular_color
+#define GL_EXT_separate_specular_color 1
+#endif
+
+#ifndef GL_EXT_secondary_color
+#define GL_EXT_secondary_color 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glSecondaryColor3bEXT (GLbyte, GLbyte, GLbyte);
+extern void glSecondaryColor3bvEXT (const GLbyte *);
+extern void glSecondaryColor3dEXT (GLdouble, GLdouble, GLdouble);
+extern void glSecondaryColor3dvEXT (const GLdouble *);
+extern void glSecondaryColor3fEXT (GLfloat, GLfloat, GLfloat);
+extern void glSecondaryColor3fvEXT (const GLfloat *);
+extern void glSecondaryColor3iEXT (GLint, GLint, GLint);
+extern void glSecondaryColor3ivEXT (const GLint *);
+extern void glSecondaryColor3sEXT (GLshort, GLshort, GLshort);
+extern void glSecondaryColor3svEXT (const GLshort *);
+extern void glSecondaryColor3ubEXT (GLubyte, GLubyte, GLubyte);
+extern void glSecondaryColor3ubvEXT (const GLubyte *);
+extern void glSecondaryColor3uiEXT (GLuint, GLuint, GLuint);
+extern void glSecondaryColor3uivEXT (const GLuint *);
+extern void glSecondaryColor3usEXT (GLushort, GLushort, GLushort);
+extern void glSecondaryColor3usvEXT (const GLushort *);
+extern void glSecondaryColorPointerEXT (GLint, GLenum, GLsizei, GLvoid *);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_EXT_texture_perturb_normal
+#define GL_EXT_texture_perturb_normal 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glTextureNormalEXT (GLenum);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_EXT_multi_draw_arrays
+#define GL_EXT_multi_draw_arrays 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glMultiDrawArraysEXT (GLenum, GLint *, GLsizei *, GLsizei);
+extern void glMultiDrawElementsEXT (GLenum, const GLsizei *, GLenum, const GLvoid* *, GLsizei);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_EXT_fog_coord
+#define GL_EXT_fog_coord 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glFogCoordfEXT (GLfloat);
+extern void glFogCoordfvEXT (const GLfloat *);
+extern void glFogCoorddEXT (GLdouble);
+extern void glFogCoorddvEXT (const GLdouble *);
+extern void glFogCoordPointerEXT (GLenum, GLsizei, const GLvoid *);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_REND_screen_coordinates
+#define GL_REND_screen_coordinates 1
+#endif
+
+#ifndef GL_EXT_coordinate_frame
+#define GL_EXT_coordinate_frame 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glTangent3bEXT (GLbyte, GLbyte, GLbyte);
+extern void glTangent3bvEXT (const GLbyte *);
+extern void glTangent3dEXT (GLdouble, GLdouble, GLdouble);
+extern void glTangent3dvEXT (const GLdouble *);
+extern void glTangent3fEXT (GLfloat, GLfloat, GLfloat);
+extern void glTangent3fvEXT (const GLfloat *);
+extern void glTangent3iEXT (GLint, GLint, GLint);
+extern void glTangent3ivEXT (const GLint *);
+extern void glTangent3sEXT (GLshort, GLshort, GLshort);
+extern void glTangent3svEXT (const GLshort *);
+extern void glBinormal3bEXT (GLbyte, GLbyte, GLbyte);
+extern void glBinormal3bvEXT (const GLbyte *);
+extern void glBinormal3dEXT (GLdouble, GLdouble, GLdouble);
+extern void glBinormal3dvEXT (const GLdouble *);
+extern void glBinormal3fEXT (GLfloat, GLfloat, GLfloat);
+extern void glBinormal3fvEXT (const GLfloat *);
+extern void glBinormal3iEXT (GLint, GLint, GLint);
+extern void glBinormal3ivEXT (const GLint *);
+extern void glBinormal3sEXT (GLshort, GLshort, GLshort);
+extern void glBinormal3svEXT (const GLshort *);
+extern void glTangentPointerEXT (GLenum, GLsizei, const GLvoid *);
+extern void glBinormalPointerEXT (GLenum, GLsizei, const GLvoid *);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_EXT_texture_env_combine
+#define GL_EXT_texture_env_combine 1
+#endif
+
+#ifndef GL_APPLE_specular_vector
+#define GL_APPLE_specular_vector 1
+#endif
+
+#ifndef GL_APPLE_transform_hint
+#define GL_APPLE_transform_hint 1
+#endif
+
+#ifndef GL_SGIX_fog_scale
+#define GL_SGIX_fog_scale 1
+#endif
+
+#ifndef GL_SUNX_constant_data
+#define GL_SUNX_constant_data 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glFinishTextureSUNX (void);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_SUN_global_alpha
+#define GL_SUN_global_alpha 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glGlobalAlphaFactorbSUN (GLbyte);
+extern void glGlobalAlphaFactorsSUN (GLshort);
+extern void glGlobalAlphaFactoriSUN (GLint);
+extern void glGlobalAlphaFactorfSUN (GLfloat);
+extern void glGlobalAlphaFactordSUN (GLdouble);
+extern void glGlobalAlphaFactorubSUN (GLubyte);
+extern void glGlobalAlphaFactorusSUN (GLushort);
+extern void glGlobalAlphaFactoruiSUN (GLuint);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_SUN_triangle_list
+#define GL_SUN_triangle_list 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glReplacementCodeuiSUN (GLuint);
+extern void glReplacementCodeusSUN (GLushort);
+extern void glReplacementCodeubSUN (GLubyte);
+extern void glReplacementCodeuivSUN (const GLuint *);
+extern void glReplacementCodeusvSUN (const GLushort *);
+extern void glReplacementCodeubvSUN (const GLubyte *);
+extern void glReplacementCodePointerSUN (GLenum, GLsizei, const GLvoid* *);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_SUN_vertex
+#define GL_SUN_vertex 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glColor4ubVertex2fSUN (GLubyte, GLubyte, GLubyte, GLubyte, GLfloat, GLfloat);
+extern void glColor4ubVertex2fvSUN (const GLubyte *, const GLfloat *);
+extern void glColor4ubVertex3fSUN (GLubyte, GLubyte, GLubyte, GLubyte, GLfloat, GLfloat, GLfloat);
+extern void glColor4ubVertex3fvSUN (const GLubyte *, const GLfloat *);
+extern void glColor3fVertex3fSUN (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
+extern void glColor3fVertex3fvSUN (const GLfloat *, const GLfloat *);
+extern void glNormal3fVertex3fSUN (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
+extern void glNormal3fVertex3fvSUN (const GLfloat *, const GLfloat *);
+extern void glColor4fNormal3fVertex3fSUN (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
+extern void glColor4fNormal3fVertex3fvSUN (const GLfloat *, const GLfloat *, const GLfloat *);
+extern void glTexCoord2fVertex3fSUN (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
+extern void glTexCoord2fVertex3fvSUN (const GLfloat *, const GLfloat *);
+extern void glTexCoord4fVertex4fSUN (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
+extern void glTexCoord4fVertex4fvSUN (const GLfloat *, const GLfloat *);
+extern void glTexCoord2fColor4ubVertex3fSUN (GLfloat, GLfloat, GLubyte, GLubyte, GLubyte, GLubyte, GLfloat, GLfloat, GLfloat);
+extern void glTexCoord2fColor4ubVertex3fvSUN (const GLfloat *, const GLubyte *, const GLfloat *);
+extern void glTexCoord2fColor3fVertex3fSUN (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
+extern void glTexCoord2fColor3fVertex3fvSUN (const GLfloat *, const GLfloat *, const GLfloat *);
+extern void glTexCoord2fNormal3fVertex3fSUN (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
+extern void glTexCoord2fNormal3fVertex3fvSUN (const GLfloat *, const GLfloat *, const GLfloat *);
+extern void glTexCoord2fColor4fNormal3fVertex3fSUN (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
+extern void glTexCoord2fColor4fNormal3fVertex3fvSUN (const GLfloat *, const GLfloat *, const GLfloat *, const GLfloat *);
+extern void glTexCoord4fColor4fNormal3fVertex4fSUN (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
+extern void glTexCoord4fColor4fNormal3fVertex4fvSUN (const GLfloat *, const GLfloat *, const GLfloat *, const GLfloat *);
+extern void glReplacementCodeuiVertex3fSUN (GLenum, GLfloat, GLfloat, GLfloat);
+extern void glReplacementCodeuiVertex3fvSUN (const GLenum *, const GLfloat *);
+extern void glReplacementCodeuiColor4ubVertex3fSUN (GLenum, GLubyte, GLubyte, GLubyte, GLubyte, GLfloat, GLfloat, GLfloat);
+extern void glReplacementCodeuiColor4ubVertex3fvSUN (const GLenum *, const GLubyte *, const GLfloat *);
+extern void glReplacementCodeuiColor3fVertex3fSUN (GLenum, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
+extern void glReplacementCodeuiColor3fVertex3fvSUN (const GLenum *, const GLfloat *, const GLfloat *);
+extern void glReplacementCodeuiNormal3fVertex3fSUN (GLenum, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
+extern void glReplacementCodeuiNormal3fVertex3fvSUN (const GLenum *, const GLfloat *, const GLfloat *);
+extern void glReplacementCodeuiColor4fNormal3fVertex3fSUN (GLenum, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
+extern void glReplacementCodeuiColor4fNormal3fVertex3fvSUN (const GLenum *, const GLfloat *, const GLfloat *, const GLfloat *);
+extern void glReplacementCodeuiTexCoord2fVertex3fSUN (GLenum, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
+extern void glReplacementCodeuiTexCoord2fVertex3fvSUN (const GLenum *, const GLfloat *, const GLfloat *);
+extern void glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN (GLenum, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
+extern void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN (const GLenum *, const GLfloat *, const GLfloat *, const GLfloat *);
+extern void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN (GLenum, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
+extern void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN (const GLenum *, const GLfloat *, const GLfloat *, const GLfloat *, const GLfloat *);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_EXT_blend_func_separate
+#define GL_EXT_blend_func_separate 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glBlendFuncSeparateEXT (GLenum, GLenum, GLenum, GLenum);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_INGR_color_clamp
+#define GL_INGR_color_clamp 1
+#endif
+
+#ifndef GL_INGR_interlace_read
+#define GL_INGR_interlace_read 1
+#endif
+
+#ifndef GL_EXT_stencil_wrap
+#define GL_EXT_stencil_wrap 1
+#endif
+
+#ifndef GL_EXT_422_pixels
+#define GL_EXT_422_pixels 1
+#endif
+
+#ifndef GL_NV_texgen_reflection
+#define GL_NV_texgen_reflection 1
+#endif
+
+#ifndef GL_SUN_convolution_border_modes
+#define GL_SUN_convolution_border_modes 1
+#endif
+
+#ifndef GL_EXT_texture_env_add
+#define GL_EXT_texture_env_add 1
+#endif
+
+#ifndef GL_EXT_texture_lod_bias
+#define GL_EXT_texture_lod_bias 1
+#endif
+
+#ifndef GL_EXT_texture_filter_anisotropic
+#define GL_EXT_texture_filter_anisotropic 1
+#endif
+
+#ifndef GL_EXT_vertex_weighting
+#define GL_EXT_vertex_weighting 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glVertexWeightfEXT (GLfloat);
+extern void glVertexWeightfvEXT (const GLfloat *);
+extern void glVertexWeightPointerEXT (GLsizei, GLenum, GLsizei, const GLvoid *);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_NV_light_max_exponent
+#define GL_NV_light_max_exponent 1
+#endif
+
+#ifndef GL_NV_vertex_array_range
+#define GL_NV_vertex_array_range 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glFlushVertexArrayRangeNV (void);
+extern void glVertexArrayRangeNV (GLsizei, const GLvoid *);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_NV_register_combiners
+#define GL_NV_register_combiners 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glCombinerParameterfvNV (GLenum, const GLfloat *);
+extern void glCombinerParameterfNV (GLenum, GLfloat);
+extern void glCombinerParameterivNV (GLenum, const GLint *);
+extern void glCombinerParameteriNV (GLenum, GLint);
+extern void glCombinerInputNV (GLenum, GLenum, GLenum, GLenum, GLenum, GLenum);
+extern void glCombinerOutputNV (GLenum, GLenum, GLenum, GLenum, GLenum, GLenum, GLenum, GLboolean, GLboolean, GLboolean);
+extern void glFinalCombinerInputNV (GLenum, GLenum, GLenum, GLenum);
+extern void glGetCombinerInputParameterfvNV (GLenum, GLenum, GLenum, GLenum, GLfloat *);
+extern void glGetCombinerInputParameterivNV (GLenum, GLenum, GLenum, GLenum, GLint *);
+extern void glGetCombinerOutputParameterfvNV (GLenum, GLenum, GLenum, GLfloat *);
+extern void glGetCombinerOutputParameterivNV (GLenum, GLenum, GLenum, GLint *);
+extern void glGetFinalCombinerInputParameterfvNV (GLenum, GLenum, GLfloat *);
+extern void glGetFinalCombinerInputParameterivNV (GLenum, GLenum, GLint *);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_NV_fog_distance
+#define GL_NV_fog_distance 1
+#endif
+
+#ifndef GL_NV_texgen_emboss
+#define GL_NV_texgen_emboss 1
+#endif
+
+#ifndef GL_NV_blend_square
+#define GL_NV_blend_square 1
+#endif
+
+#ifndef GL_NV_texture_env_combine4
+#define GL_NV_texture_env_combine4 1
+#endif
+
+#ifndef GL_MESA_resize_buffers
+#define GL_MESA_resize_buffers 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glResizeBuffersMESA (void);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_MESA_window_pos
+#define GL_MESA_window_pos 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glWindowPos2dMESA (GLdouble, GLdouble);
+extern void glWindowPos2dvMESA (const GLdouble *);
+extern void glWindowPos2fMESA (GLfloat, GLfloat);
+extern void glWindowPos2fvMESA (const GLfloat *);
+extern void glWindowPos2iMESA (GLint, GLint);
+extern void glWindowPos2ivMESA (const GLint *);
+extern void glWindowPos2sMESA (GLshort, GLshort);
+extern void glWindowPos2svMESA (const GLshort *);
+extern void glWindowPos3dMESA (GLdouble, GLdouble, GLdouble);
+extern void glWindowPos3dvMESA (const GLdouble *);
+extern void glWindowPos3fMESA (GLfloat, GLfloat, GLfloat);
+extern void glWindowPos3fvMESA (const GLfloat *);
+extern void glWindowPos3iMESA (GLint, GLint, GLint);
+extern void glWindowPos3ivMESA (const GLint *);
+extern void glWindowPos3sMESA (GLshort, GLshort, GLshort);
+extern void glWindowPos3svMESA (const GLshort *);
+extern void glWindowPos4dMESA (GLdouble, GLdouble, GLdouble, GLdouble);
+extern void glWindowPos4dvMESA (const GLdouble *);
+extern void glWindowPos4fMESA (GLfloat, GLfloat, GLfloat, GLfloat);
+extern void glWindowPos4fvMESA (const GLfloat *);
+extern void glWindowPos4iMESA (GLint, GLint, GLint, GLint);
+extern void glWindowPos4ivMESA (const GLint *);
+extern void glWindowPos4sMESA (GLshort, GLshort, GLshort, GLshort);
+extern void glWindowPos4svMESA (const GLshort *);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_IBM_cull_vertex
+#define GL_IBM_cull_vertex 1
+#endif
+
+#ifndef GL_IBM_multimode_draw_arrays
+#define GL_IBM_multimode_draw_arrays 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glMultiModeDrawArraysIBM (GLenum, const GLint *, const GLsizei *, GLsizei, GLint);
+extern void glMultiModeDrawElementsIBM (const GLenum *, const GLsizei *, GLenum, const GLvoid* *, GLsizei, GLint);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_IBM_vertex_array_lists
+#define GL_IBM_vertex_array_lists 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glColorPointerListIBM (GLint, GLenum, GLint, const GLvoid* *, GLint);
+extern void glSecondaryColorPointerListIBM (GLint, GLenum, GLint, const GLvoid* *, GLint);
+extern void glEdgeFlagPointerListIBM (GLint, const GLboolean* *, GLint);
+extern void glFogCoordPointerListIBM (GLenum, GLint, const GLvoid* *, GLint);
+extern void glIndexPointerListIBM (GLenum, GLint, const GLvoid* *, GLint);
+extern void glNormalPointerListIBM (GLenum, GLint, const GLvoid* *, GLint);
+extern void glTexCoordPointerListIBM (GLint, GLenum, GLint, const GLvoid* *, GLint);
+extern void glVertexPointerListIBM (GLint, GLenum, GLint, const GLvoid* *, GLint);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_SGIX_subsample
+#define GL_SGIX_subsample 1
+#endif
+
+#ifndef GL_SGIX_ycrcba
+#define GL_SGIX_ycrcba 1
+#endif
+
+#ifndef GL_SGIX_ycrcb_subsample
+#define GL_SGIX_ycrcb_subsample 1
+#endif
+
+#ifndef GL_SGIX_depth_pass_instrument
+#define GL_SGIX_depth_pass_instrument 1
+#endif
+
+#ifndef GL_3DFX_texture_compression_FXT1
+#define GL_3DFX_texture_compression_FXT1 1
+#endif
+
+#ifndef GL_3DFX_multisample
+#define GL_3DFX_multisample 1
+#endif
+
+#ifndef GL_3DFX_tbuffer
+#define GL_3DFX_tbuffer 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glTbufferMask3DFX (GLuint);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_EXT_multisample
+#define GL_EXT_multisample 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glSampleMaskEXT (GLclampf, GLboolean);
+extern void glSamplePatternEXT (GLenum);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_SGI_vertex_preclip
+#define GL_SGI_vertex_preclip 1
+#endif
+
+#ifndef GL_SGIX_convolution_accuracy
+#define GL_SGIX_convolution_accuracy 1
+#endif
+
+#ifndef GL_SGIX_resample
+#define GL_SGIX_resample 1
+#endif
+
+#ifndef GL_SGIS_point_line_texgen
+#define GL_SGIS_point_line_texgen 1
+#endif
+
+#ifndef GL_SGIS_texture_color_mask
+#define GL_SGIS_texture_color_mask 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glTextureColorMaskSGIS (GLboolean, GLboolean, GLboolean, GLboolean);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
diff --git a/code/renderer/matcomp.c b/code/renderer/matcomp.c
new file mode 100644
index 0000000..6ac4260
--- /dev/null
+++ b/code/renderer/matcomp.c
@@ -0,0 +1,361 @@
+#include "MatComp.h"
+#include <assert.h>
+#include <math.h>
+#include <stdio.h>
+#include <memory.h>	// for memcpy
+
+#define MC_MASK_X ((1<<(MC_BITS_X))-1)
+#define MC_MASK_Y ((1<<(MC_BITS_Y))-1)
+#define MC_MASK_Z ((1<<(MC_BITS_Z))-1)
+#define MC_MASK_VECT ((1<<(MC_BITS_VECT))-1)
+
+#define MC_SCALE_VECT (1.0f/(float)((1<<(MC_BITS_VECT-1))-2))
+
+#define MC_POS_X (0)
+#define MC_SHIFT_X (0)
+
+#define MC_POS_Y ((((MC_BITS_X))/8))
+#define MC_SHIFT_Y ((((MC_BITS_X)%8)))
+
+#define MC_POS_Z ((((MC_BITS_X+MC_BITS_Y))/8))
+#define MC_SHIFT_Z ((((MC_BITS_X+MC_BITS_Y)%8)))
+
+#define MC_POS_V11 ((((MC_BITS_X+MC_BITS_Y+MC_BITS_Z))/8))
+#define MC_SHIFT_V11 ((((MC_BITS_X+MC_BITS_Y+MC_BITS_Z)%8)))
+
+#define MC_POS_V12 ((((MC_BITS_X+MC_BITS_Y+MC_BITS_Z+MC_BITS_VECT))/8))
+#define MC_SHIFT_V12 ((((MC_BITS_X+MC_BITS_Y+MC_BITS_Z+MC_BITS_VECT)%8)))
+
+#define MC_POS_V13 ((((MC_BITS_X+MC_BITS_Y+MC_BITS_Z+MC_BITS_VECT*2))/8))
+#define MC_SHIFT_V13 ((((MC_BITS_X+MC_BITS_Y+MC_BITS_Z+MC_BITS_VECT*2)%8)))
+
+#define MC_POS_V21 ((((MC_BITS_X+MC_BITS_Y+MC_BITS_Z+MC_BITS_VECT*3))/8))
+#define MC_SHIFT_V21 ((((MC_BITS_X+MC_BITS_Y+MC_BITS_Z+MC_BITS_VECT*3)%8)))
+
+#define MC_POS_V22 ((((MC_BITS_X+MC_BITS_Y+MC_BITS_Z+MC_BITS_VECT*4))/8))
+#define MC_SHIFT_V22 ((((MC_BITS_X+MC_BITS_Y+MC_BITS_Z+MC_BITS_VECT*4)%8)))
+
+#define MC_POS_V23 ((((MC_BITS_X+MC_BITS_Y+MC_BITS_Z+MC_BITS_VECT*5))/8))
+#define MC_SHIFT_V23 ((((MC_BITS_X+MC_BITS_Y+MC_BITS_Z+MC_BITS_VECT*5)%8)))
+
+#define MC_POS_V31 ((((MC_BITS_X+MC_BITS_Y+MC_BITS_Z+MC_BITS_VECT*6))/8))
+#define MC_SHIFT_V31 ((((MC_BITS_X+MC_BITS_Y+MC_BITS_Z+MC_BITS_VECT*6)%8)))
+
+#define MC_POS_V32 ((((MC_BITS_X+MC_BITS_Y+MC_BITS_Z+MC_BITS_VECT*7))/8))
+#define MC_SHIFT_V32 ((((MC_BITS_X+MC_BITS_Y+MC_BITS_Z+MC_BITS_VECT*7)%8)))
+
+#define MC_POS_V33 ((((MC_BITS_X+MC_BITS_Y+MC_BITS_Z+MC_BITS_VECT*8))/8))
+#define MC_SHIFT_V33 ((((MC_BITS_X+MC_BITS_Y+MC_BITS_Z+MC_BITS_VECT*8)%8)))
+
+void MC_Compress(const float mat[3][4],unsigned char * _comp)
+{
+	char comp[MC_COMP_BYTES*2];
+
+	int i,val;
+	for (i=0;i<MC_COMP_BYTES;i++)
+		comp[i]=0;
+
+	val=(int)(mat[0][3]/MC_SCALE_X);
+	val+=1<<(MC_BITS_X-1);
+	if (val>=(1<<MC_BITS_X))
+		val=(1<<MC_BITS_X)-1;
+	if (val<0)
+		val=0;
+	*(unsigned int *)(comp+MC_POS_X)|=((unsigned int)(val))<<MC_SHIFT_X;
+
+	val=(int)(mat[1][3]/MC_SCALE_Y);
+	val+=1<<(MC_BITS_Y-1);
+	if (val>=(1<<MC_BITS_Y))
+		val=(1<<MC_BITS_Y)-1;
+	if (val<0)
+		val=0;
+	*(unsigned int *)(comp+MC_POS_Y)|=((unsigned int)(val))<<MC_SHIFT_Y;
+
+	val=(int)(mat[2][3]/MC_SCALE_Z);
+	val+=1<<(MC_BITS_Z-1);
+	if (val>=(1<<MC_BITS_Z))
+		val=(1<<MC_BITS_Z)-1;
+	if (val<0)
+		val=0;
+	*(unsigned int *)(comp+MC_POS_Z)|=((unsigned int)(val))<<MC_SHIFT_Z;
+
+
+	val=(int)(mat[0][0]/MC_SCALE_VECT);
+	val+=1<<(MC_BITS_VECT-1);
+	if (val>=(1<<MC_BITS_VECT))
+		val=(1<<MC_BITS_VECT)-1;
+	if (val<0)
+		val=0;
+	*(unsigned int *)(comp+MC_POS_V11)|=((unsigned int)(val))<<MC_SHIFT_V11;
+
+	val=(int)(mat[0][1]/MC_SCALE_VECT);
+	val+=1<<(MC_BITS_VECT-1);
+	if (val>=(1<<MC_BITS_VECT))
+		val=(1<<MC_BITS_VECT)-1;
+	if (val<0)
+		val=0;
+	*(unsigned int *)(comp+MC_POS_V12)|=((unsigned int)(val))<<MC_SHIFT_V12;
+
+	val=(int)(mat[0][2]/MC_SCALE_VECT);
+	val+=1<<(MC_BITS_VECT-1);
+	if (val>=(1<<MC_BITS_VECT))
+		val=(1<<MC_BITS_VECT)-1;
+	if (val<0)
+		val=0;
+	*(unsigned int *)(comp+MC_POS_V13)|=((unsigned int)(val))<<MC_SHIFT_V13;
+
+
+	val=(int)(mat[1][0]/MC_SCALE_VECT);
+	val+=1<<(MC_BITS_VECT-1);
+	if (val>=(1<<MC_BITS_VECT))
+		val=(1<<MC_BITS_VECT)-1;
+	if (val<0)
+		val=0;
+	*(unsigned int *)(comp+MC_POS_V21)|=((unsigned int)(val))<<MC_SHIFT_V21;
+
+	val=(int)(mat[1][1]/MC_SCALE_VECT);
+	val+=1<<(MC_BITS_VECT-1);
+	if (val>=(1<<MC_BITS_VECT))
+		val=(1<<MC_BITS_VECT)-1;
+	if (val<0)
+		val=0;
+	*(unsigned int *)(comp+MC_POS_V22)|=((unsigned int)(val))<<MC_SHIFT_V22;
+
+	val=(int)(mat[1][2]/MC_SCALE_VECT);
+	val+=1<<(MC_BITS_VECT-1);
+	if (val>=(1<<MC_BITS_VECT))
+		val=(1<<MC_BITS_VECT)-1;
+	if (val<0)
+		val=0;
+	*(unsigned int *)(comp+MC_POS_V23)|=((unsigned int)(val))<<MC_SHIFT_V23;
+
+	val=(int)(mat[2][0]/MC_SCALE_VECT);
+	val+=1<<(MC_BITS_VECT-1);
+	if (val>=(1<<MC_BITS_VECT))
+		val=(1<<MC_BITS_VECT)-1;
+	if (val<0)
+		val=0;
+	*(unsigned int *)(comp+MC_POS_V31)|=((unsigned int)(val))<<MC_SHIFT_V31;
+
+	val=(int)(mat[2][1]/MC_SCALE_VECT);
+	val+=1<<(MC_BITS_VECT-1);
+	if (val>=(1<<MC_BITS_VECT))
+		val=(1<<MC_BITS_VECT)-1;
+	if (val<0)
+		val=0;
+	*(unsigned int *)(comp+MC_POS_V32)|=((unsigned int)(val))<<MC_SHIFT_V32;
+
+	val=(int)(mat[2][2]/MC_SCALE_VECT);
+	val+=1<<(MC_BITS_VECT-1);
+	if (val>=(1<<MC_BITS_VECT))
+		val=(1<<MC_BITS_VECT)-1;
+	if (val<0)
+		val=0;
+	*(unsigned int *)(comp+MC_POS_V33)|=((unsigned int)(val))<<MC_SHIFT_V33;
+
+	// I added this because the line above actually ORs data into an int at the 22 byte (from 0), and therefore technically
+	//	is writing beyond the 24th byte of the output array. This *should** be harmless if the OR'd-in value doesn't change 
+	//	those bytes, but BoundsChecker says that it's accessing undefined memory (which it does, sometimes). This is probably
+	//	bad, so... 
+	memcpy(_comp,comp,MC_COMP_BYTES);
+}
+
+void MC_UnCompress(float mat[3][4],const unsigned char * comp)
+{
+	int val;
+
+	val=(int)((unsigned short *)(comp))[0];
+	val-=1<<(MC_BITS_X-1);
+	mat[0][3]=((float)(val))*MC_SCALE_X;
+
+	val=(int)((unsigned short *)(comp))[1];
+	val-=1<<(MC_BITS_Y-1);
+	mat[1][3]=((float)(val))*MC_SCALE_Y;
+
+	val=(int)((unsigned short *)(comp))[2];
+	val-=1<<(MC_BITS_Z-1);
+	mat[2][3]=((float)(val))*MC_SCALE_Z;
+
+	val=(int)((unsigned short *)(comp))[3];
+	val-=1<<(MC_BITS_VECT-1);
+	mat[0][0]=((float)(val))*MC_SCALE_VECT;
+
+	val=(int)((unsigned short *)(comp))[4];
+	val-=1<<(MC_BITS_VECT-1);
+	mat[0][1]=((float)(val))*MC_SCALE_VECT;
+
+	val=(int)((unsigned short *)(comp))[5];
+	val-=1<<(MC_BITS_VECT-1);
+	mat[0][2]=((float)(val))*MC_SCALE_VECT;
+
+
+	val=(int)((unsigned short *)(comp))[6];
+	val-=1<<(MC_BITS_VECT-1);
+	mat[1][0]=((float)(val))*MC_SCALE_VECT;
+
+	val=(int)((unsigned short *)(comp))[7];
+	val-=1<<(MC_BITS_VECT-1);
+	mat[1][1]=((float)(val))*MC_SCALE_VECT;
+
+	val=(int)((unsigned short *)(comp))[8];
+	val-=1<<(MC_BITS_VECT-1);
+	mat[1][2]=((float)(val))*MC_SCALE_VECT;
+
+
+	val=(int)((unsigned short *)(comp))[9];
+	val-=1<<(MC_BITS_VECT-1);
+	mat[2][0]=((float)(val))*MC_SCALE_VECT;
+
+	val=(int)((unsigned short *)(comp))[10];
+	val-=1<<(MC_BITS_VECT-1);
+	mat[2][1]=((float)(val))*MC_SCALE_VECT;
+
+	val=(int)((unsigned short *)(comp))[11];
+	val-=1<<(MC_BITS_VECT-1);
+	mat[2][2]=((float)(val))*MC_SCALE_VECT;
+
+}
+
+/* ROTATION/TRANSLATION COMPRESSION DEBUG CODE (RTCDC)
+unsigned short comp_rot_maskx = 0xfff0;
+unsigned short comp_rot_masky = 0xfff0;
+unsigned short comp_rot_maskz = 0xfff0;
+unsigned short comp_rot_maskw = 0xfff0;
+
+unsigned short comp_tra_maskf1 = 0xfff0;
+unsigned short comp_tra_maskf2 = 0xfff0;
+unsigned short comp_tra_maskf3 = 0xfff0;
+
+int use_comp_rot_mask = 0;
+int use_comp_tra_mask = 0;
+unsigned short cw;
+unsigned short cx;
+unsigned short cy;
+unsigned short cz;
+unsigned short f1;
+unsigned short f2;
+unsigned short f3;
+*/
+
+void MC_UnCompressQuat(float mat[3][4],const unsigned char * comp)
+{
+	float w,x,y,z,f;
+    float fTx;
+    float fTy;
+    float fTz;
+    float fTwx;
+    float fTwy;
+    float fTwz;
+    float fTxx;
+    float fTxy;
+    float fTxz;
+    float fTyy;
+    float fTyz;
+    float fTzz;
+	
+	const unsigned short *pwIn = (unsigned short *) comp;
+	
+
+	/* RTCDC
+	if(use_comp_rot_mask)
+	{
+		cw = *pwIn++;
+		cx = *pwIn++;
+		cy = *pwIn++;
+		cz = *pwIn++;
+
+		cw &= comp_rot_maskw;
+		cx &= comp_rot_maskx;
+		cy &= comp_rot_masky;
+		cz &= comp_rot_maskz;
+	}
+	else
+	{
+		cw = *pwIn++;
+		cx = *pwIn++;
+		cy = *pwIn++;
+		cz = *pwIn++;
+	}
+
+	if(use_comp_tra_mask)
+	{
+		f1 = *pwIn++;
+		f2 = *pwIn++;
+		f3 = *pwIn++;
+
+		f1 &= comp_tra_maskf1;
+		f2 &= comp_tra_maskf2;
+		f3 &= comp_tra_maskf3;
+	}
+	else
+	{
+		f1 = *pwIn++;
+		f2 = *pwIn++;
+		f3 = *pwIn++;
+	}
+	*/
+
+	w = *pwIn++;
+	// RTCDC w = cw;
+	w/=16383.0f;
+	w-=2.0f;
+	x = *pwIn++;
+	// RTCDC x = cx;
+	x/=16383.0f;
+	x-=2.0f;
+	y = *pwIn++;
+	// RTCDC y = cy;
+	y/=16383.0f;
+	y-=2.0f;
+	z = *pwIn++;
+	// RTCDC z = cz;
+	z/=16383.0f;
+	z-=2.0f;
+
+    fTx  = 2.0f*x;
+    fTy  = 2.0f*y;
+    fTz  = 2.0f*z;
+    fTwx = fTx*w;
+    fTwy = fTy*w;
+    fTwz = fTz*w;
+    fTxx = fTx*x;
+    fTxy = fTy*x;
+    fTxz = fTz*x;
+    fTyy = fTy*y;
+    fTyz = fTz*y;
+    fTzz = fTz*z;
+
+	// rot...
+	//
+    mat[0][0] = 1.0f-(fTyy+fTzz);
+    mat[0][1] = fTxy-fTwz;
+    mat[0][2] = fTxz+fTwy;
+    mat[1][0] = fTxy+fTwz;
+    mat[1][1] = 1.0f-(fTxx+fTzz);
+    mat[1][2] = fTyz-fTwx;
+    mat[2][0] = fTxz-fTwy;
+    mat[2][1] = fTyz+fTwx;
+    mat[2][2] = 1.0f-(fTxx+fTyy);
+
+	// xlat...
+	//
+	f = *pwIn++;
+	// RTCDC f = f1;
+	f/=64;
+	f-=512;
+	mat[0][3] = f;
+
+	f = *pwIn++;
+	// RTCDC f = f2;
+	f/=64;
+	f-=512;
+	mat[1][3] = f;
+
+	f = *pwIn++;
+	// RTCDC f = f3;
+	f/=64;
+	f-=512;
+	mat[2][3] = f;
+}
+
+
diff --git a/code/renderer/matcomp.h b/code/renderer/matcomp.h
new file mode 100644
index 0000000..9255e1f
--- /dev/null
+++ b/code/renderer/matcomp.h
@@ -0,0 +1,31 @@
+#ifndef __MATCOMP__
+#define __MATCOMP__
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#define MC_BITS_X (16)
+#define MC_BITS_Y (16)
+#define MC_BITS_Z (16)
+#define MC_BITS_VECT (16)
+
+#define MC_SCALE_X (1.0f/64)
+#define MC_SCALE_Y (1.0f/64)
+#define MC_SCALE_Z (1.0f/64)
+
+
+// currently 24 (.875)
+#define MC_COMP_BYTES (((MC_BITS_X+MC_BITS_Y+MC_BITS_Z+MC_BITS_VECT*9)+7)/8)
+
+void MC_Compress(const float mat[3][4],unsigned char * comp);
+void MC_UnCompress(float mat[3][4],const unsigned char * comp);
+void MC_UnCompressQuat(float mat[3][4],const unsigned char * comp);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
\ No newline at end of file
diff --git a/code/renderer/mdx_format.h b/code/renderer/mdx_format.h
new file mode 100644
index 0000000..e9f8e06
--- /dev/null
+++ b/code/renderer/mdx_format.h
@@ -0,0 +1,434 @@
+// Filename:-	mdx_format.h
+//
+// DO NOT UPDATE THIS FILE IN ANY WAY WHATSOEVER WITHOUT TELLING ME (-Ste),
+//	BECAUSE THE MASTER COPY IS IN A DIFFERENT SOURCESAFE DATABASE AND WILL 
+//	JUST GET PASTED OVER THIS ONE WHENEVER I CHANGE IT.
+//
+//
+//
+// MDX file format (typically uses file extension GLX for mesh, and GLA for anim/skeleton file)
+//
+// Notes:
+//	
+//	- All offset fields are relative to the address of the structure they occur in
+//	- So far, the only external symbol needed is MAX_QPATH, plus the typedefs for vec3_t, vec2_t etc
+
+#ifndef MDX_FORMAT_H
+#define MDX_FORMAT_H
+
+
+#define MDXM_IDENT			(('M'<<24)+('G'<<16)+('L'<<8)+'2')
+#define MDXA_IDENT			(('A'<<24)+('G'<<16)+('L'<<8)+'2')
+
+#define MAX_TAGNAME_BYTES	32	// matches MDR, can be changed if nec.
+
+//
+// normal version numbers...
+//
+#define MDXM_VERSION 6
+#define MDXA_VERSION 6
+
+// (Note that since there is now a "<modelname>_info.txt" file written out by carcass any changes made in here that
+//		introduce new data should also be reflected in the info-output)
+
+// 32 bit-flags for ghoul2 bone properties...  (all undefined fields will be blank)
+//
+#define G2BONEFLAG_ALWAYSXFORM	0x00000001
+
+// same thing but for surfaces...  (Carcass will only generate 1st 2 flags, others are ingame
+//
+#define G2SURFACEFLAG_ISBOLT		0x00000001
+#define G2SURFACEFLAG_OFF			0x00000002	// saves strcmp()ing for "_off" in surface names
+#define G2SURFACEFLAG_SPARE0		0x00000004	// future-expansion fields, saves invalidating models if we add more
+#define G2SURFACEFLAG_SPARE1		0x00000008	//   
+#define G2SURFACEFLAG_SPARE2		0x00000010	// 
+#define G2SURFACEFLAG_SPARE3		0x00000020	// 
+#define G2SURFACEFLAG_SPARE4		0x00000040	// 
+#define G2SURFACEFLAG_SPARE5		0x00000080	// 
+//
+#define G2SURFACEFLAG_NODESCENDANTS 0x00000100	// ingame-stuff, never generated by Carcass....
+#define G2SURFACEFLAG_GENERATED		0x00000200	//
+
+
+
+// triangle side-ordering stuff for tags...
+//
+#define iG2_TRISIDE_MIDDLE				1
+#define iG2_TRISIDE_LONGEST				0
+#define iG2_TRISIDE_SHORTEST			2
+
+#define fG2_BONEWEIGHT_RECIPROCAL_MULT	((float)(1.0f/1023.0f))
+#define iG2_BITS_PER_BONEREF			5
+#define iMAX_G2_BONEREFS_PER_SURFACE	(1<<iG2_BITS_PER_BONEREF)	// (32)
+#define iMAX_G2_BONEWEIGHTS_PER_VERT	4	// can't just be blindly increased, affects cache size etc
+
+#define iG2_BONEWEIGHT_TOPBITS_SHIFT	((iG2_BITS_PER_BONEREF * iMAX_G2_BONEWEIGHTS_PER_VERT) - 8)	// 8 bits because of 8 in the BoneWeight[] array entry
+#define iG2_BONEWEIGHT_TOPBITS_AND		0x300	// 2 bits, giving 10 total, or 10 bits, for 1023/1024 above
+
+
+#define sDEFAULT_GLA_NAME "*default"	// used when making special simple ghoul2 models, usually from MD3 files
+
+
+////////////////////////////////////
+//
+// these structs are defined here purely because of structure dependancy order...
+//
+/*
+#ifdef __cplusplus
+struct mdxmWeight_t
+#else
+typedef struct 
+#endif
+{
+	int			boneIndex;		// these are indexes into the surface boneReferences, not the global bone index
+	float		boneWeight;		// not the global per-frame bone list
+
+	// I'm defining this '<' operator so this struct can be used with an STL <set>...
+	// (note that I've defined it using '>' internally, so it sorts with higher weights being "less", for distance weight-culling
+	//
+	#ifdef __cplusplus
+	bool operator < (const mdxmWeight_t& _X) const {return (boneWeight>_X.boneWeight);}
+	#endif
+} 
+#ifndef __cplusplus
+mdxmWeight_t
+#endif
+;
+*/
+/*
+#ifdef __cplusplus
+struct mdxaCompBone_t
+#else
+typedef struct
+#endif
+{
+	unsigned char Comp[24];		// MC_COMP_BYTES is in MatComp.h, but don't want to couple	
+
+	// I'm defining this '<' operator so this struct can be used as an STL <map> key...
+	//
+	#ifdef __cplusplus
+	bool operator < (const mdxaCompBone_t& _X) const {return (memcmp(Comp,_X.Comp,sizeof(Comp))<0);}
+	#endif
+}
+#ifndef __cplusplus
+mdxaCompBone_t
+#endif
+;
+*/
+#ifdef __cplusplus
+struct mdxaCompQuatBone_t
+#else
+typedef struct
+#endif
+{
+	unsigned char Comp[14];
+
+	// I'm defining this '<' operator so this struct can be used as an STL <map> key...
+	//
+	#ifdef __cplusplus
+	bool operator < (const mdxaCompQuatBone_t& _X) const {return (memcmp(Comp,_X.Comp,sizeof(Comp))<0);}
+	#endif
+}
+#ifndef __cplusplus
+mdxaCompQuatBone_t
+#endif
+;
+
+
+#ifndef MDXABONEDEF
+typedef struct {
+	float matrix[3][4];			
+} mdxaBone_t;
+#endif
+
+////////////////////////////////////
+
+
+
+
+
+
+// mdxHeader_t  - this contains the header for the file, with sanity checking and version checking, plus number of lod's to be expected
+//
+typedef struct {
+	// 
+	// ( first 3 fields are same format as MD3/MDR so we can apply easy model-format-type checks )
+	//
+	int			ident;				// "IDP3" = MD3, "RDM5" = MDR, "2LGM"(GL2 Mesh) = MDX   (cruddy char order I know, but I'm following what was there in other versions)
+	int			version;			// 1,2,3 etc as per format revision
+	char		name[MAX_QPATH];	// model name (eg "models/players/marine.glm")	// note: extension supplied
+	char		animName[MAX_QPATH];// name of animation file this mesh requires	// note: extension missing
+	int			animIndex;			// filled in by game (carcass defaults it to 0)
+
+	int			numBones;			// (for ingame version-checks only, ensure we don't ref more bones than skel file has)
+
+	int			numLODs;
+	int			ofsLODs;
+
+	int			numSurfaces;		// now that surfaces are drawn hierarchically, we have same # per LOD
+	int			ofsSurfHierarchy;
+
+	int			ofsEnd;				// EOF, which of course gives overall file size
+} mdxmHeader_t;
+
+
+// for each surface (doesn't actually need a struct for this, just makes source clearer)
+// {
+		typedef struct
+		{
+			int offsets[1];		// variable sized (mdxmHeader_t->numSurfaces), each offset points to a mdxmSurfHierarchy_t below
+		} mdxmHierarchyOffsets_t;
+// }
+
+// for each surface...	(mdxmHeader_t->numSurfaces)
+// {
+		// mdxmSurfHierarchy_t - contains hierarchical info for surfaces...
+
+		typedef struct {
+			char		name[MAX_QPATH];
+			unsigned int flags;
+			char		shader[MAX_QPATH];
+			int			shaderIndex;		// for in-game use (carcass defaults to 0)
+			int			parentIndex;		// this points to the index in the file of the parent surface. -1 if null/root
+			int			numChildren;		// number of surfaces which are children of this one
+			int			childIndexes[1];	// [mdxmSurfHierarch_t->numChildren] (variable sized)
+		} mdxmSurfHierarchy_t;	// struct size = (int)( &((mdxmSurfHierarch_t *)0)->childIndexes[ mdxmSurfHierarch_t->numChildren ] );
+// }
+
+
+// for each LOD...  (mdxmHeader_t->numLODs)
+// {
+		// mdxLOD_t - this contains the header for this LOD. Contains num of surfaces, offset to surfaces and offset to next LOD. Surfaces are shader sorted, so each surface = 1 shader
+
+		typedef struct {
+			// (used to contain numSurface/ofsSurfaces fields, but these are same per LOD level now)
+			//
+			int			ofsEnd;				// offset to next LOD
+		} mdxmLOD_t;
+
+
+		typedef struct {	// added in GLM version 3 for ingame use at Jake's request
+			int offsets[1];		// variable sized (mdxmHeader_t->numSurfaces), each offset points to surfaces below
+		} mdxmLODSurfOffset_t;
+
+
+		// for each surface... (mdxmHeader_t->numSurfaces)
+		// {
+				// mdxSurface_t - reuse of header format containing surface name, number of bones, offset to poly data and number of polys, offset to vertex information, and number of verts. NOTE offsets are relative to this header.
+
+				typedef struct {
+					int			ident;				// this one field at least should be kept, since the game-engine may switch-case (but currently=0 in carcass)
+
+					int			thisSurfaceIndex;	// 0...mdxmHeader_t->numSurfaces-1 (because of how ingame renderer works)
+
+					int			ofsHeader;			// this will be a negative number, pointing back to main header
+
+					int			numVerts;
+					int			ofsVerts;
+
+					int			numTriangles;
+					int			ofsTriangles;
+
+					// Bone references are a set of ints representing all the bones
+					// present in any vertex weights for this surface.  This is
+					// needed because a model may have surfaces that need to be
+					// drawn at different sort times, and we don't want to have
+					// to re-interpolate all the bones for each surface.
+					//
+					int			numBoneReferences;
+					int			ofsBoneReferences;
+
+					int			ofsEnd;				// next surface follows
+
+				} mdxmSurface_t;
+
+
+				// for each triangle...	(mdxmSurface_t->numTriangles)
+				// {
+						// mdxTriangle_t - contains indexes into verts. One struct entry per poly.
+
+						typedef struct {
+							int			indexes[3];
+						} mdxmTriangle_t;
+				// }
+				
+
+				// for each vert... (mdxmSurface_t->numVerts)
+				// {
+						// mdxVertex_t - this is an array with number of verts from the surface definition as its bounds. It contains normal info, texture coors and number of weightings for this bone
+						// (this is now kept at 32 bytes for cache-aligning)
+						typedef struct {
+#ifdef _XBOX
+							//short			normal[3];
+							unsigned int	normal;
+							short			vertCoords[3];
+							unsigned int	tangent;
+#else
+							vec3_t			normal;
+							vec3_t			vertCoords;
+#endif
+
+							// packed int...
+							unsigned int	uiNmWeightsAndBoneIndexes;	// 32 bits.  format: 
+																		// 31 & 30:  0..3 (= 1..4) weight count
+																		// 29 & 28 (spare)
+																		//	2 bit pairs at 20,22,24,26 are 2-bit overflows from 4 BonWeights below (20=[0], 22=[1]) etc)
+																		//  5-bits each (iG2_BITS_PER_BONEREF) for boneweights
+							// effectively a packed int, each bone weight converted from 0..1 float to 0..255 int...
+							//  promote each entry to float and multiply by fG2_BONEWEIGHT_RECIPROCAL_MULT to convert.
+							byte			BoneWeightings[iMAX_G2_BONEWEIGHTS_PER_VERT];	// 4
+
+						} mdxmVertex_t;
+
+				// } vert
+
+#ifdef __cplusplus
+
+// these are convenience functions that I can invoked in code. Do NOT change them (because this is a shared file), 
+//	but if you want to copy the logic out and use your own versions then fine...
+//
+static inline int G2_GetVertWeights( const mdxmVertex_t *pVert )
+{
+	int iNumWeights = (pVert->uiNmWeightsAndBoneIndexes >> 30)+1;	// 1..4 count 
+
+	return iNumWeights;
+}
+
+static inline int G2_GetVertBoneIndex( const mdxmVertex_t *pVert, const int iWeightNum)
+{ 
+	int iBoneIndex = (pVert->uiNmWeightsAndBoneIndexes>>(iG2_BITS_PER_BONEREF*iWeightNum))&((1<<iG2_BITS_PER_BONEREF)-1);
+
+	return iBoneIndex;
+}
+
+static inline float G2_GetVertBoneWeight( const mdxmVertex_t *pVert, const int iWeightNum, float &fTotalWeight, int iNumWeights )
+{
+	float fBoneWeight;
+
+	if (iWeightNum == iNumWeights-1)
+	{
+		fBoneWeight = 1.0f-fTotalWeight;
+	}
+	else
+	{
+		int iTemp = pVert->BoneWeightings[iWeightNum];
+			iTemp|= (pVert->uiNmWeightsAndBoneIndexes >> (iG2_BONEWEIGHT_TOPBITS_SHIFT+(iWeightNum*2)) ) & iG2_BONEWEIGHT_TOPBITS_AND;
+
+		fBoneWeight = fG2_BONEWEIGHT_RECIPROCAL_MULT * iTemp;
+		fTotalWeight += fBoneWeight;
+	}
+
+	return fBoneWeight;
+}
+#endif															 
+				// for each vert... (mdxmSurface_t->numVerts)  (seperated from mdxmVertex_t struct for cache reasons)
+				// {
+						// mdxVertex_t - this is an array with number of verts from the surface definition as its bounds. It contains normal info, texture coors and number of weightings for this bone
+
+						typedef struct {
+#ifdef _XBOX
+							short			texCoords[2];
+#else
+							vec2_t			texCoords;
+#endif
+						} mdxmVertexTexCoord_t;
+
+				// } vert
+
+
+		// } surface
+// } LOD
+
+
+
+//----------------------------------------------------------------------------
+// seperate file here for animation data...
+//
+
+
+// mdxaHeader_t  - this contains the header for the file, with sanity checking and version checking, plus number of lod's to be expected
+//
+typedef struct {
+	// 
+	// ( first 3 fields are same format as MD3/MDR so we can apply easy model-format-type checks )
+	//
+	int			ident;				// 	"IDP3" = MD3, "RDM5" = MDR, "2LGA"(GL2 Anim) = MDXA
+	int			version;			// 1,2,3 etc as per format revision
+	//
+	char		name[MAX_QPATH];	// GLA name (eg "skeletons/marine")	// note: extension missing
+	float		fScale;				// will be zero if build before this field was defined, else scale it was built with
+
+	// frames and bones are shared by all levels of detail
+	//
+	int			numFrames;
+	int			ofsFrames;			// points at mdxaFrame_t array
+	int			numBones;			// (no offset to these since they're inside the frames array)
+	int			ofsCompBonePool;	// offset to global compressed-bone pool that all frames use
+	int			ofsSkel;			// offset to mdxaSkel_t info
+	
+	int			ofsEnd;				// EOF, which of course gives overall file size
+
+} mdxaHeader_t;
+
+
+// for each bone... (doesn't actually need a struct for this, just makes source clearer)
+// {
+		typedef struct
+		{
+			int offsets[1];		// variable sized (mdxaHeader_t->numBones), each offset points to an mdxaSkel_t below
+		} mdxaSkelOffsets_t;
+// }
+
+
+
+// for each bone...	 (mdxaHeader_t->numBones)       
+// {
+		// mdxaSkel_t - contains hierarchical info only...
+
+		typedef struct {
+			char		name[MAX_QPATH];	// name of bone
+			unsigned int flags;
+			int			parent;				// index of bone that is parent to this one, -1 = NULL/root
+			mdxaBone_t	BasePoseMat;		// base pose
+			mdxaBone_t	BasePoseMatInv;		// inverse, to save run-time calc
+			int			numChildren;		// number of children bones
+			int			children[1];		// [mdxaSkel_t->numChildren] (variable sized)
+		} mdxaSkel_t;	// struct size = (int)( &((mdxaSkel_t *)0)->children[ mdxaSkel_t->numChildren ] );
+// }
+
+
+	// (offset @ mdxaHeader_t->ofsFrames)
+	//
+	//  array of 3 byte indices here (hey, 25% saving over 4-byte really adds up)...
+	//
+	//
+	// access as follows to get the index for a given <iFrameNum, iBoneNum>
+	//
+	// (iFrameNum * mdxaHeader_t->numBones * 3) + (iBoneNum * 3)
+	//
+	//  then read the int at that location and AND it with 0x00FFFFFF. I use the struct below simply for easy searches
+	typedef struct
+	{
+		int iIndex;	// this struct for pointing purposes, need to and with 0x00FFFFFF to be meaningful
+	} mdxaIndex_t;
+	//
+	// (note that there's then an alignement-pad here to get the next struct back onto 32-bit alignement)
+	//
+	// this index then points into the following...
+
+
+// Compressed-bone pool that all frames use  (mdxaHeader_t->ofsCompBonePool)  (defined at end because size unknown until end)
+// for each bone in pool (unknown number, no actual total stored at the moment)... 
+// {
+		// mdxaCompBone_t  (defined at file top because of struct dependancy)
+// }
+
+//---------------------------------------------------------------------------
+
+
+#endif	// #ifndef MDX_FORMAT_H
+
+//////////////////////// eof ///////////////////////
+
+
+
diff --git a/code/renderer/qgl.h b/code/renderer/qgl.h
new file mode 100644
index 0000000..50dacfe
--- /dev/null
+++ b/code/renderer/qgl.h
@@ -0,0 +1,734 @@
+/*
+** QGL.H
+*/
+
+#ifndef __QGL_H__
+#define __QGL_H__
+
+#if defined( __LINT__ )
+
+#include <GL/gl.h>
+
+#elif defined( _WIN32 )
+
+#pragma warning (disable: 4201)
+#pragma warning (disable: 4214)
+#pragma warning (disable: 4514)
+#pragma warning (disable: 4032)
+#pragma warning (disable: 4201)
+#pragma warning (disable: 4214)
+#include <windows.h>
+#include <gl/gl.h>
+
+#elif defined( __APPLE__ ) && defined( __MACH__ )
+  
+#include <MesaGL/gl.h>
+
+#elif defined( __linux__ )
+
+#include <GL/gl.h>
+#include <GL/glx.h>
+#include <GL/fxmesa.h>
+
+#else
+
+#include <gl.h>
+
+#endif
+
+#ifndef APIENTRY
+#define APIENTRY
+#endif
+#ifndef WINAPI
+#define WINAPI
+#endif
+
+
+//===========================================================================
+
+/*
+** multitexture extension definitions
+*/
+#define GL_ACTIVE_TEXTURE_ARB               0x84E0
+#define GL_CLIENT_ACTIVE_TEXTURE_ARB        0x84E1
+#define GL_MAX_ACTIVE_TEXTURES_ARB          0x84E2
+
+#define GL_TEXTURE0_ARB                     0x84C0
+#define GL_TEXTURE1_ARB                     0x84C1
+#define GL_TEXTURE2_ARB                     0x84C2
+#define GL_TEXTURE3_ARB                     0x84C3
+
+#define GL_TEXTURE_RECTANGLE_EXT						0x84F5
+
+typedef void (APIENTRY * PFNGLMULTITEXCOORD1DARBPROC) (GLenum target, GLdouble s);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD1DVARBPROC) (GLenum target, const GLdouble *v);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD1FARBPROC) (GLenum target, GLfloat s);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD1FVARBPROC) (GLenum target, const GLfloat *v);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD1IARBPROC) (GLenum target, GLint s);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD1IVARBPROC) (GLenum target, const GLint *v);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD1SARBPROC) (GLenum target, GLshort s);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD1SVARBPROC) (GLenum target, const GLshort *v);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD2DARBPROC) (GLenum target, GLdouble s, GLdouble t);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD2DVARBPROC) (GLenum target, const GLdouble *v);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD2FARBPROC) (GLenum target, GLfloat s, GLfloat t);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD2FVARBPROC) (GLenum target, const GLfloat *v);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD2IARBPROC) (GLenum target, GLint s, GLint t);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD2IVARBPROC) (GLenum target, const GLint *v);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD2SARBPROC) (GLenum target, GLshort s, GLshort t);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD2SVARBPROC) (GLenum target, const GLshort *v);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD3DARBPROC) (GLenum target, GLdouble s, GLdouble t, GLdouble r);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD3DVARBPROC) (GLenum target, const GLdouble *v);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD3FARBPROC) (GLenum target, GLfloat s, GLfloat t, GLfloat r);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD3FVARBPROC) (GLenum target, const GLfloat *v);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD3IARBPROC) (GLenum target, GLint s, GLint t, GLint r);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD3IVARBPROC) (GLenum target, const GLint *v);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD3SARBPROC) (GLenum target, GLshort s, GLshort t, GLshort r);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD3SVARBPROC) (GLenum target, const GLshort *v);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD4DARBPROC) (GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD4DVARBPROC) (GLenum target, const GLdouble *v);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD4FARBPROC) (GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD4FVARBPROC) (GLenum target, const GLfloat *v);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD4IARBPROC) (GLenum target, GLint s, GLint t, GLint r, GLint q);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD4IVARBPROC) (GLenum target, const GLint *v);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD4SARBPROC) (GLenum target, GLshort s, GLshort t, GLshort r, GLshort q);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD4SVARBPROC) (GLenum target, const GLshort *v);
+typedef void (APIENTRY * PFNGLACTIVETEXTUREARBPROC) (GLenum target);
+typedef void (APIENTRY * PFNGLCLIENTACTIVETEXTUREARBPROC) (GLenum target);
+
+
+// Steps to adding a new extension:
+//	- Add the typedef and function pointer externs here.
+//	- Define the function pointer in tr_init.cpp and possibly add a cvar to track your ext status.
+//	- Load the extension in win_glimp.cpp.
+
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// Register Combiner extension definitions. - AReis
+/***********************************************************************************************************/
+// NOTE: These are obviously not all the regcom flags. I'm only including the ones I use (to reduce code clutter), so
+// if you need any of the other flags, just add them.
+#define GL_REGISTER_COMBINERS_NV			0x8522
+#define GL_COMBINER0_NV						0x8550
+#define GL_COMBINER1_NV						0x8551
+#define GL_COMBINER2_NV						0x8552
+#define GL_COMBINER3_NV						0x8553
+#define GL_COMBINER4_NV						0x8554
+#define GL_COMBINER5_NV						0x8555
+#define GL_COMBINER6_NV						0x8556
+#define GL_COMBINER7_NV						0x8557
+#define GL_NUM_GENERAL_COMBINERS_NV			0x854E
+#define GL_VARIABLE_A_NV					0x8523
+#define GL_VARIABLE_B_NV					0x8524
+#define GL_VARIABLE_C_NV					0x8525
+#define GL_VARIABLE_D_NV					0x8526
+#define GL_VARIABLE_E_NV					0x8527
+#define GL_VARIABLE_F_NV					0x8528
+#define GL_VARIABLE_G_NV					0x8529
+#define GL_DISCARD_NV						0x8530
+#define GL_CONSTANT_COLOR0_NV				0x852A
+#define GL_CONSTANT_COLOR1_NV				0x852B
+#define GL_SPARE0_NV						0x852E
+#define GL_SPARE1_NV						0x852F
+#define GL_UNSIGNED_IDENTITY_NV				0x8536
+#define GL_UNSIGNED_INVERT_NV				0x8537
+
+typedef void (APIENTRY *PFNGLCOMBINERPARAMETERFVNV) (GLenum pname,const GLfloat *params);
+typedef void (APIENTRY *PFNGLCOMBINERPARAMETERIVNV) (GLenum pname,const GLint *params);
+typedef void (APIENTRY *PFNGLCOMBINERPARAMETERFNV) (GLenum pname,GLfloat param);
+typedef void (APIENTRY *PFNGLCOMBINERPARAMETERINV) (GLenum pname,GLint param);
+typedef void (APIENTRY *PFNGLCOMBINERINPUTNV) (GLenum stage,GLenum portion,GLenum variable,GLenum input,GLenum mapping,
+											   GLenum componentUsage);
+typedef void (APIENTRY *PFNGLCOMBINEROUTPUTNV) (GLenum stage,GLenum portion,GLenum abOutput,GLenum cdOutput,GLenum sumOutput,
+												GLenum scale, GLenum bias,GLboolean abDotProduct,GLboolean cdDotProduct,
+												GLboolean muxSum);
+typedef void (APIENTRY *PFNGLFINALCOMBINERINPUTNV) (GLenum variable,GLenum input,GLenum mapping,GLenum componentUsage);
+
+typedef void (APIENTRY *PFNGLGETCOMBINERINPUTPARAMETERFVNV) (GLenum stage,GLenum portion,GLenum variable,GLenum pname,GLfloat *params);
+typedef void (APIENTRY *PFNGLGETCOMBINERINPUTPARAMETERIVNV) (GLenum stage,GLenum portion,GLenum variable,GLenum pname,GLint *params);
+typedef void (APIENTRY *PFNGLGETCOMBINEROUTPUTPARAMETERFVNV) (GLenum stage,GLenum portion,GLenum pname,GLfloat *params);
+typedef void (APIENTRY *PFNGLGETCOMBINEROUTPUTPARAMETERIVNV) (GLenum stage,GLenum portion,GLenum pname,GLint *params);
+typedef void (APIENTRY *PFNGLGETFINALCOMBINERINPUTPARAMETERFVNV) (GLenum variable,GLenum pname,GLfloat *params);
+typedef void (APIENTRY *PFNGLGETFINALCOMBINERINPUTPARAMETERIVNV) (GLenum variable,GLenum pname,GLfloat *params);
+/***********************************************************************************************************/
+
+// Declare Register Combiners function pointers.
+extern PFNGLCOMBINERPARAMETERFVNV				qglCombinerParameterfvNV;
+extern PFNGLCOMBINERPARAMETERIVNV				qglCombinerParameterivNV;
+extern PFNGLCOMBINERPARAMETERFNV				qglCombinerParameterfNV;
+extern PFNGLCOMBINERPARAMETERINV				qglCombinerParameteriNV;
+extern PFNGLCOMBINERINPUTNV						qglCombinerInputNV;
+extern PFNGLCOMBINEROUTPUTNV					qglCombinerOutputNV;
+extern PFNGLFINALCOMBINERINPUTNV				qglFinalCombinerInputNV;
+extern PFNGLGETCOMBINERINPUTPARAMETERFVNV		qglGetCombinerInputParameterfvNV;
+extern PFNGLGETCOMBINERINPUTPARAMETERIVNV		qglGetCombinerInputParameterivNV;
+extern PFNGLGETCOMBINEROUTPUTPARAMETERFVNV		qglGetCombinerOutputParameterfvNV;
+extern PFNGLGETCOMBINEROUTPUTPARAMETERIVNV		qglGetCombinerOutputParameterivNV;
+extern PFNGLGETFINALCOMBINERINPUTPARAMETERFVNV	qglGetFinalCombinerInputParameterfvNV;
+extern PFNGLGETFINALCOMBINERINPUTPARAMETERIVNV	qglGetFinalCombinerInputParameterivNV;
+
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// Pixel Format extension definitions. - AReis
+/***********************************************************************************************************/
+#define WGL_COLOR_BITS_ARB             0x2014
+#define WGL_ALPHA_BITS_ARB             0x201B
+#define WGL_DEPTH_BITS_ARB             0x2022
+#define WGL_STENCIL_BITS_ARB           0x2023
+
+typedef BOOL (WINAPI * PFNWGLGETPIXELFORMATATTRIBIVARBPROC) (HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, const int *piAttributes, int *piValues);
+typedef BOOL (WINAPI * PFNWGLGETPIXELFORMATATTRIBFVARBPROC) (HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, const int *piAttributes, FLOAT *pfValues);
+typedef BOOL (WINAPI * PFNWGLCHOOSEPIXELFORMATARBPROC) (HDC hdc, const int *piAttribIList, const FLOAT *pfAttribFList, UINT nMaxFormats, int *piFormats, UINT *nNumFormats);
+/***********************************************************************************************************/
+
+// Declare Pixel Format function pointers.
+extern PFNWGLGETPIXELFORMATATTRIBIVARBPROC		qwglGetPixelFormatAttribivARB;
+extern PFNWGLGETPIXELFORMATATTRIBFVARBPROC		qwglGetPixelFormatAttribfvARB;
+extern PFNWGLCHOOSEPIXELFORMATARBPROC			qwglChoosePixelFormatARB;
+
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// Pixel Buffer extension definitions. - AReis
+/***********************************************************************************************************/
+DECLARE_HANDLE(HPBUFFERARB);
+
+#define WGL_SUPPORT_OPENGL_ARB         0x2010
+#define WGL_DOUBLE_BUFFER_ARB          0x2011
+#define WGL_DRAW_TO_PBUFFER_ARB        0x202D
+#define WGL_PBUFFER_WIDTH_ARB          0x2034
+#define WGL_PBUFFER_HEIGHT_ARB         0x2035
+#define WGL_RED_BITS_ARB               0x2015
+#define WGL_GREEN_BITS_ARB             0x2017
+#define WGL_BLUE_BITS_ARB              0x2019
+
+typedef HPBUFFERARB (WINAPI * PFNWGLCREATEPBUFFERARBPROC) (HDC hDC, int iPixelFormat, int iWidth, int iHeight, const int *piAttribList);
+typedef HDC (WINAPI * PFNWGLGETPBUFFERDCARBPROC) (HPBUFFERARB hPbuffer);
+typedef int (WINAPI * PFNWGLRELEASEPBUFFERDCARBPROC) (HPBUFFERARB hPbuffer, HDC hDC);
+typedef BOOL (WINAPI * PFNWGLDESTROYPBUFFERARBPROC) (HPBUFFERARB hPbuffer);
+typedef BOOL (WINAPI * PFNWGLQUERYPBUFFERARBPROC) (HPBUFFERARB hPbuffer, int iAttribute, int *piValue);
+/***********************************************************************************************************/
+
+// Declare Pixel Buffer function pointers.
+extern PFNWGLCREATEPBUFFERARBPROC				qwglCreatePbufferARB;
+extern PFNWGLGETPBUFFERDCARBPROC				qwglGetPbufferDCARB;
+extern PFNWGLRELEASEPBUFFERDCARBPROC			qwglReleasePbufferDCARB;
+extern PFNWGLDESTROYPBUFFERARBPROC				qwglDestroyPbufferARB;
+extern PFNWGLQUERYPBUFFERARBPROC				qwglQueryPbufferARB;
+
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// Render-Texture extension definitions. - AReis
+/***********************************************************************************************************/
+#define WGL_BIND_TO_TEXTURE_RGBA_ARB       0x2071
+#define WGL_TEXTURE_FORMAT_ARB             0x2072
+#define WGL_TEXTURE_TARGET_ARB             0x2073
+#define WGL_TEXTURE_RGB_ARB                0x2075
+#define WGL_TEXTURE_RGBA_ARB               0x2076
+#define WGL_TEXTURE_2D_ARB                 0x207A
+#define WGL_FRONT_LEFT_ARB                 0x2083
+
+typedef BOOL (WINAPI * PFNWGLBINDTEXIMAGEARBPROC) (HPBUFFERARB hPbuffer, int iBuffer);
+typedef BOOL (WINAPI * PFNWGLRELEASETEXIMAGEARBPROC) (HPBUFFERARB hPbuffer, int iBuffer);
+typedef BOOL (WINAPI * PFNWGLSETPBUFFERATTRIBARBPROC) (HPBUFFERARB hPbuffer, const int * piAttribList);
+/***********************************************************************************************************/
+
+// Declare Render-Texture function pointers.
+extern PFNWGLBINDTEXIMAGEARBPROC			qwglBindTexImageARB;
+extern PFNWGLRELEASETEXIMAGEARBPROC			qwglReleaseTexImageARB;
+extern PFNWGLSETPBUFFERATTRIBARBPROC		qwglSetPbufferAttribARB;
+
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// Vertex and Fragment Program extension definitions. - AReis
+/***********************************************************************************************************/
+#ifndef GL_ARB_fragment_program
+#define GL_FRAGMENT_PROGRAM_ARB           0x8804
+#define GL_PROGRAM_ALU_INSTRUCTIONS_ARB   0x8805
+#define GL_PROGRAM_TEX_INSTRUCTIONS_ARB   0x8806
+#define GL_PROGRAM_TEX_INDIRECTIONS_ARB   0x8807
+#define GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB 0x8808
+#define GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB 0x8809
+#define GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB 0x880A
+#define GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB 0x880B
+#define GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB 0x880C
+#define GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB 0x880D
+#define GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB 0x880E
+#define GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB 0x880F
+#define GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB 0x8810
+#define GL_MAX_TEXTURE_COORDS_ARB         0x8871
+#define GL_MAX_TEXTURE_IMAGE_UNITS_ARB    0x8872
+#endif
+
+// NOTE: These are obviously not all the vertex program flags (have you seen how many there actually are!). I'm
+// only including the ones I use (to reduce code clutter), so if you need any of the other flags, just add them.
+#define GL_VERTEX_PROGRAM_ARB                       0x8620
+#define GL_PROGRAM_FORMAT_ASCII_ARB                 0x8875
+
+typedef void (APIENTRY * PFNGLPROGRAMSTRINGARBPROC) (GLenum target, GLenum format, GLsizei len, const GLvoid *string); 
+typedef void (APIENTRY * PFNGLBINDPROGRAMARBPROC) (GLenum target, GLuint program);
+typedef void (APIENTRY * PFNGLDELETEPROGRAMSARBPROC) (GLsizei n, const GLuint *programs);
+typedef void (APIENTRY * PFNGLGENPROGRAMSARBPROC) (GLsizei n, GLuint *programs);
+typedef void (APIENTRY * PFNGLPROGRAMENVPARAMETER4DARBPROC) (GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+typedef void (APIENTRY * PFNGLPROGRAMENVPARAMETER4DVARBPROC) (GLenum target, GLuint index, const GLdouble *params);
+typedef void (APIENTRY * PFNGLPROGRAMENVPARAMETER4FARBPROC) (GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+typedef void (APIENTRY * PFNGLPROGRAMENVPARAMETER4FVARBPROC) (GLenum target, GLuint index, const GLfloat *params);
+typedef void (APIENTRY * PFNGLPROGRAMLOCALPARAMETER4DARBPROC) (GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+typedef void (APIENTRY * PFNGLPROGRAMLOCALPARAMETER4DVARBPROC) (GLenum target, GLuint index, const GLdouble *params);
+typedef void (APIENTRY * PFNGLPROGRAMLOCALPARAMETER4FARBPROC) (GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+typedef void (APIENTRY * PFNGLPROGRAMLOCALPARAMETER4FVARBPROC) (GLenum target, GLuint index, const GLfloat *params);
+typedef void (APIENTRY * PFNGLGETPROGRAMENVPARAMETERDVARBPROC) (GLenum target, GLuint index, GLdouble *params);
+typedef void (APIENTRY * PFNGLGETPROGRAMENVPARAMETERFVARBPROC) (GLenum target, GLuint index, GLfloat *params);
+typedef void (APIENTRY * PFNGLGETPROGRAMLOCALPARAMETERDVARBPROC) (GLenum target, GLuint index, GLdouble *params);
+typedef void (APIENTRY * PFNGLGETPROGRAMLOCALPARAMETERFVARBPROC) (GLenum target, GLuint index, GLfloat *params);
+typedef void (APIENTRY * PFNGLGETPROGRAMIVARBPROC) (GLenum target, GLenum pname, GLint *params);
+typedef void (APIENTRY * PFNGLGETPROGRAMSTRINGARBPROC) (GLenum target, GLenum pname, GLvoid *string);
+typedef GLboolean (APIENTRY * PFNGLISPROGRAMARBPROC) (GLuint program);
+/***********************************************************************************************************/
+
+// Declare Vertex and Fragment Program function pointers.
+extern PFNGLPROGRAMSTRINGARBPROC qglProgramStringARB;
+extern PFNGLBINDPROGRAMARBPROC qglBindProgramARB;
+extern PFNGLDELETEPROGRAMSARBPROC qglDeleteProgramsARB;
+extern PFNGLGENPROGRAMSARBPROC qglGenProgramsARB;
+extern PFNGLPROGRAMENVPARAMETER4DARBPROC qglProgramEnvParameter4dARB;
+extern PFNGLPROGRAMENVPARAMETER4DVARBPROC qglProgramEnvParameter4dvARB;
+extern PFNGLPROGRAMENVPARAMETER4FARBPROC qglProgramEnvParameter4fARB;
+extern PFNGLPROGRAMENVPARAMETER4FVARBPROC qglProgramEnvParameter4fvARB;
+extern PFNGLPROGRAMLOCALPARAMETER4DARBPROC qglProgramLocalParameter4dARB;
+extern PFNGLPROGRAMLOCALPARAMETER4DVARBPROC qglProgramLocalParameter4dvARB;
+extern PFNGLPROGRAMLOCALPARAMETER4FARBPROC qglProgramLocalParameter4fARB;
+extern PFNGLPROGRAMLOCALPARAMETER4FVARBPROC qglProgramLocalParameter4fvARB;
+extern PFNGLGETPROGRAMENVPARAMETERDVARBPROC qglGetProgramEnvParameterdvARB;
+extern PFNGLGETPROGRAMENVPARAMETERFVARBPROC qglGetProgramEnvParameterfvARB;
+extern PFNGLGETPROGRAMLOCALPARAMETERDVARBPROC qglGetProgramLocalParameterdvARB;
+extern PFNGLGETPROGRAMLOCALPARAMETERFVARBPROC qglGetProgramLocalParameterfvARB;
+extern PFNGLGETPROGRAMIVARBPROC qglGetProgramivARB;
+extern PFNGLGETPROGRAMSTRINGARBPROC qglGetProgramStringARB;
+extern PFNGLISPROGRAMARBPROC qglIsProgramARB;
+
+
+/*
+** extension constants
+*/
+
+
+// S3TC compression constants
+#define GL_RGB_S3TC							0x83A0
+#define GL_RGB4_S3TC						0x83A1
+
+
+// extensions will be function pointers on all platforms
+
+extern	void ( APIENTRY * qglMultiTexCoord2fARB )( GLenum texture, GLfloat s, GLfloat t );
+extern	void ( APIENTRY * qglActiveTextureARB )( GLenum texture );
+extern	void ( APIENTRY * qglClientActiveTextureARB )( GLenum texture );
+
+extern	void ( APIENTRY * qglLockArraysEXT) (GLint, GLint);
+extern	void ( APIENTRY * qglUnlockArraysEXT) (void);
+
+extern	void ( APIENTRY * qglPointParameterfEXT)( GLenum, GLfloat);
+extern	void ( APIENTRY * qglPointParameterfvEXT)( GLenum, GLfloat *);
+
+// Added 10/23/02 by Aurelio Reis.
+extern	void ( APIENTRY * qglPointParameteriNV)( GLenum, GLint);
+extern	void ( APIENTRY * qglPointParameterivNV)( GLenum, const GLint *);
+
+//===========================================================================
+
+// non-windows systems will just redefine qgl* to gl*
+#if !defined( _WIN32 ) && !defined( __linux__ )
+
+#include "qgl_linked.h"
+
+#else
+
+// windows systems use a function pointer for each call so we can load minidrivers
+
+extern  void ( APIENTRY * qglAccum )(GLenum op, GLfloat value);
+extern  void ( APIENTRY * qglAlphaFunc )(GLenum func, GLclampf ref);
+extern  GLboolean ( APIENTRY * qglAreTexturesResident )(GLsizei n, const GLuint *textures, GLboolean *residences);
+extern  void ( APIENTRY * qglArrayElement )(GLint i);
+extern  void ( APIENTRY * qglBegin )(GLenum mode);
+extern  void ( APIENTRY * qglBindTexture )(GLenum target, GLuint texture);
+extern  void ( APIENTRY * qglBitmap )(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap);
+extern  void ( APIENTRY * qglBlendFunc )(GLenum sfactor, GLenum dfactor);
+extern  void ( APIENTRY * qglCallList )(GLuint list);
+extern  void ( APIENTRY * qglCallLists )(GLsizei n, GLenum type, const GLvoid *lists);
+extern  void ( APIENTRY * qglClear )(GLbitfield mask);
+extern  void ( APIENTRY * qglClearAccum )(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
+extern  void ( APIENTRY * qglClearColor )(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
+extern  void ( APIENTRY * qglClearDepth )(GLclampd depth);
+extern  void ( APIENTRY * qglClearIndex )(GLfloat c);
+extern  void ( APIENTRY * qglClearStencil )(GLint s);
+extern  void ( APIENTRY * qglClipPlane )(GLenum plane, const GLdouble *equation);
+extern  void ( APIENTRY * qglColor3b )(GLbyte red, GLbyte green, GLbyte blue);
+extern  void ( APIENTRY * qglColor3bv )(const GLbyte *v);
+extern  void ( APIENTRY * qglColor3d )(GLdouble red, GLdouble green, GLdouble blue);
+extern  void ( APIENTRY * qglColor3dv )(const GLdouble *v);
+extern  void ( APIENTRY * qglColor3f )(GLfloat red, GLfloat green, GLfloat blue);
+extern  void ( APIENTRY * qglColor3fv )(const GLfloat *v);
+extern  void ( APIENTRY * qglColor3i )(GLint red, GLint green, GLint blue);
+extern  void ( APIENTRY * qglColor3iv )(const GLint *v);
+extern  void ( APIENTRY * qglColor3s )(GLshort red, GLshort green, GLshort blue);
+extern  void ( APIENTRY * qglColor3sv )(const GLshort *v);
+extern  void ( APIENTRY * qglColor3ub )(GLubyte red, GLubyte green, GLubyte blue);
+extern  void ( APIENTRY * qglColor3ubv )(const GLubyte *v);
+extern  void ( APIENTRY * qglColor3ui )(GLuint red, GLuint green, GLuint blue);
+extern  void ( APIENTRY * qglColor3uiv )(const GLuint *v);
+extern  void ( APIENTRY * qglColor3us )(GLushort red, GLushort green, GLushort blue);
+extern  void ( APIENTRY * qglColor3usv )(const GLushort *v);
+extern  void ( APIENTRY * qglColor4b )(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha);
+extern  void ( APIENTRY * qglColor4bv )(const GLbyte *v);
+extern  void ( APIENTRY * qglColor4d )(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha);
+extern  void ( APIENTRY * qglColor4dv )(const GLdouble *v);
+extern  void ( APIENTRY * qglColor4f )(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
+extern  void ( APIENTRY * qglColor4fv )(const GLfloat *v);
+extern  void ( APIENTRY * qglColor4i )(GLint red, GLint green, GLint blue, GLint alpha);
+extern  void ( APIENTRY * qglColor4iv )(const GLint *v);
+extern  void ( APIENTRY * qglColor4s )(GLshort red, GLshort green, GLshort blue, GLshort alpha);
+extern  void ( APIENTRY * qglColor4sv )(const GLshort *v);
+extern  void ( APIENTRY * qglColor4ub )(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha);
+extern  void ( APIENTRY * qglColor4ubv )(const GLubyte *v);
+extern  void ( APIENTRY * qglColor4ui )(GLuint red, GLuint green, GLuint blue, GLuint alpha);
+extern  void ( APIENTRY * qglColor4uiv )(const GLuint *v);
+extern  void ( APIENTRY * qglColor4us )(GLushort red, GLushort green, GLushort blue, GLushort alpha);
+extern  void ( APIENTRY * qglColor4usv )(const GLushort *v);
+extern  void ( APIENTRY * qglColorMask )(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
+extern  void ( APIENTRY * qglColorMaterial )(GLenum face, GLenum mode);
+extern  void ( APIENTRY * qglColorPointer )(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
+extern  void ( APIENTRY * qglCopyPixels )(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type);
+extern  void ( APIENTRY * qglCopyTexImage1D )(GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border);
+extern  void ( APIENTRY * qglCopyTexImage2D )(GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
+extern  void ( APIENTRY * qglCopyTexSubImage1D )(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);
+extern  void ( APIENTRY * qglCopyTexSubImage2D )(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
+extern  void ( APIENTRY * qglCullFace )(GLenum mode);
+extern  void ( APIENTRY * qglDeleteLists )(GLuint list, GLsizei range);
+extern  void ( APIENTRY * qglDeleteTextures )(GLsizei n, const GLuint *textures);
+extern  void ( APIENTRY * qglDepthFunc )(GLenum func);
+extern  void ( APIENTRY * qglDepthMask )(GLboolean flag);
+extern  void ( APIENTRY * qglDepthRange )(GLclampd zNear, GLclampd zFar);
+extern  void ( APIENTRY * qglDisable )(GLenum cap);
+extern  void ( APIENTRY * qglDisableClientState )(GLenum array);
+extern  void ( APIENTRY * qglDrawArrays )(GLenum mode, GLint first, GLsizei count);
+extern  void ( APIENTRY * qglDrawBuffer )(GLenum mode);
+extern  void ( APIENTRY * qglDrawElements )(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices);
+extern  void ( APIENTRY * qglDrawPixels )(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
+extern  void ( APIENTRY * qglEdgeFlag )(GLboolean flag);
+extern  void ( APIENTRY * qglEdgeFlagPointer )(GLsizei stride, const GLvoid *pointer);
+extern  void ( APIENTRY * qglEdgeFlagv )(const GLboolean *flag);
+extern  void ( APIENTRY * qglEnable )(GLenum cap);
+extern  void ( APIENTRY * qglEnableClientState )(GLenum array);
+extern  void ( APIENTRY * qglEnd )(void);
+extern  void ( APIENTRY * qglEndList )(void);
+extern  void ( APIENTRY * qglEvalCoord1d )(GLdouble u);
+extern  void ( APIENTRY * qglEvalCoord1dv )(const GLdouble *u);
+extern  void ( APIENTRY * qglEvalCoord1f )(GLfloat u);
+extern  void ( APIENTRY * qglEvalCoord1fv )(const GLfloat *u);
+extern  void ( APIENTRY * qglEvalCoord2d )(GLdouble u, GLdouble v);
+extern  void ( APIENTRY * qglEvalCoord2dv )(const GLdouble *u);
+extern  void ( APIENTRY * qglEvalCoord2f )(GLfloat u, GLfloat v);
+extern  void ( APIENTRY * qglEvalCoord2fv )(const GLfloat *u);
+extern  void ( APIENTRY * qglEvalMesh1 )(GLenum mode, GLint i1, GLint i2);
+extern  void ( APIENTRY * qglEvalMesh2 )(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2);
+extern  void ( APIENTRY * qglEvalPoint1 )(GLint i);
+extern  void ( APIENTRY * qglEvalPoint2 )(GLint i, GLint j);
+extern  void ( APIENTRY * qglFeedbackBuffer )(GLsizei size, GLenum type, GLfloat *buffer);
+extern  void ( APIENTRY * qglFinish )(void);
+extern  void ( APIENTRY * qglFlush )(void);
+extern  void ( APIENTRY * qglFogf )(GLenum pname, GLfloat param);
+extern  void ( APIENTRY * qglFogfv )(GLenum pname, const GLfloat *params);
+extern  void ( APIENTRY * qglFogi )(GLenum pname, GLint param);
+extern  void ( APIENTRY * qglFogiv )(GLenum pname, const GLint *params);
+extern  void ( APIENTRY * qglFrontFace )(GLenum mode);
+extern  void ( APIENTRY * qglFrustum )(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
+extern  GLuint ( APIENTRY * qglGenLists )(GLsizei range);
+extern  void ( APIENTRY * qglGenTextures )(GLsizei n, GLuint *textures);
+extern  void ( APIENTRY * qglGetBooleanv )(GLenum pname, GLboolean *params);
+extern  void ( APIENTRY * qglGetClipPlane )(GLenum plane, GLdouble *equation);
+extern  void ( APIENTRY * qglGetDoublev )(GLenum pname, GLdouble *params);
+extern  GLenum ( APIENTRY * qglGetError )(void);
+extern  void ( APIENTRY * qglGetFloatv )(GLenum pname, GLfloat *params);
+extern  void ( APIENTRY * qglGetIntegerv )(GLenum pname, GLint *params);
+extern  void ( APIENTRY * qglGetLightfv )(GLenum light, GLenum pname, GLfloat *params);
+extern  void ( APIENTRY * qglGetLightiv )(GLenum light, GLenum pname, GLint *params);
+extern  void ( APIENTRY * qglGetMapdv )(GLenum target, GLenum query, GLdouble *v);
+extern  void ( APIENTRY * qglGetMapfv )(GLenum target, GLenum query, GLfloat *v);
+extern  void ( APIENTRY * qglGetMapiv )(GLenum target, GLenum query, GLint *v);
+extern  void ( APIENTRY * qglGetMaterialfv )(GLenum face, GLenum pname, GLfloat *params);
+extern  void ( APIENTRY * qglGetMaterialiv )(GLenum face, GLenum pname, GLint *params);
+extern  void ( APIENTRY * qglGetPixelMapfv )(GLenum map, GLfloat *values);
+extern  void ( APIENTRY * qglGetPixelMapuiv )(GLenum map, GLuint *values);
+extern  void ( APIENTRY * qglGetPixelMapusv )(GLenum map, GLushort *values);
+extern  void ( APIENTRY * qglGetPointerv )(GLenum pname, GLvoid* *params);
+extern  void ( APIENTRY * qglGetPolygonStipple )(GLubyte *mask);
+extern  const GLubyte * ( APIENTRY * qglGetString )(GLenum name);
+extern  void ( APIENTRY * qglGetTexEnvfv )(GLenum target, GLenum pname, GLfloat *params);
+extern  void ( APIENTRY * qglGetTexEnviv )(GLenum target, GLenum pname, GLint *params);
+extern  void ( APIENTRY * qglGetTexGendv )(GLenum coord, GLenum pname, GLdouble *params);
+extern  void ( APIENTRY * qglGetTexGenfv )(GLenum coord, GLenum pname, GLfloat *params);
+extern  void ( APIENTRY * qglGetTexGeniv )(GLenum coord, GLenum pname, GLint *params);
+extern  void ( APIENTRY * qglGetTexImage )(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels);
+extern  void ( APIENTRY * qglGetTexLevelParameterfv )(GLenum target, GLint level, GLenum pname, GLfloat *params);
+extern  void ( APIENTRY * qglGetTexLevelParameteriv )(GLenum target, GLint level, GLenum pname, GLint *params);
+extern  void ( APIENTRY * qglGetTexParameterfv )(GLenum target, GLenum pname, GLfloat *params);
+extern  void ( APIENTRY * qglGetTexParameteriv )(GLenum target, GLenum pname, GLint *params);
+extern  void ( APIENTRY * qglHint )(GLenum target, GLenum mode);
+extern  void ( APIENTRY * qglIndexMask )(GLuint mask);
+extern  void ( APIENTRY * qglIndexPointer )(GLenum type, GLsizei stride, const GLvoid *pointer);
+extern  void ( APIENTRY * qglIndexd )(GLdouble c);
+extern  void ( APIENTRY * qglIndexdv )(const GLdouble *c);
+extern  void ( APIENTRY * qglIndexf )(GLfloat c);
+extern  void ( APIENTRY * qglIndexfv )(const GLfloat *c);
+extern  void ( APIENTRY * qglIndexi )(GLint c);
+extern  void ( APIENTRY * qglIndexiv )(const GLint *c);
+extern  void ( APIENTRY * qglIndexs )(GLshort c);
+extern  void ( APIENTRY * qglIndexsv )(const GLshort *c);
+extern  void ( APIENTRY * qglIndexub )(GLubyte c);
+extern  void ( APIENTRY * qglIndexubv )(const GLubyte *c);
+extern  void ( APIENTRY * qglInitNames )(void);
+extern  void ( APIENTRY * qglInterleavedArrays )(GLenum format, GLsizei stride, const GLvoid *pointer);
+extern  GLboolean ( APIENTRY * qglIsEnabled )(GLenum cap);
+extern  GLboolean ( APIENTRY * qglIsList )(GLuint l);
+extern  GLboolean ( APIENTRY * qglIsTexture )(GLuint texture);
+extern  void ( APIENTRY * qglLightModelf )(GLenum pname, GLfloat param);
+extern  void ( APIENTRY * qglLightModelfv )(GLenum pname, const GLfloat *params);
+extern  void ( APIENTRY * qglLightModeli )(GLenum pname, GLint param);
+extern  void ( APIENTRY * qglLightModeliv )(GLenum pname, const GLint *params);
+extern  void ( APIENTRY * qglLightf )(GLenum light, GLenum pname, GLfloat param);
+extern  void ( APIENTRY * qglLightfv )(GLenum light, GLenum pname, const GLfloat *params);
+extern  void ( APIENTRY * qglLighti )(GLenum light, GLenum pname, GLint param);
+extern  void ( APIENTRY * qglLightiv )(GLenum light, GLenum pname, const GLint *params);
+extern  void ( APIENTRY * qglLineStipple )(GLint factor, GLushort pattern);
+extern  void ( APIENTRY * qglLineWidth )(GLfloat width);
+extern  void ( APIENTRY * qglListBase )(GLuint base);
+extern  void ( APIENTRY * qglLoadIdentity )(void);
+extern  void ( APIENTRY * qglLoadMatrixd )(const GLdouble *m);
+extern  void ( APIENTRY * qglLoadMatrixf )(const GLfloat *m);
+extern  void ( APIENTRY * qglLoadName )(GLuint name);
+extern  void ( APIENTRY * qglLogicOp )(GLenum opcode);
+extern  void ( APIENTRY * qglMap1d )(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points);
+extern  void ( APIENTRY * qglMap1f )(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points);
+extern  void ( APIENTRY * qglMap2d )(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points);
+extern  void ( APIENTRY * qglMap2f )(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points);
+extern  void ( APIENTRY * qglMapGrid1d )(GLint un, GLdouble u1, GLdouble u2);
+extern  void ( APIENTRY * qglMapGrid1f )(GLint un, GLfloat u1, GLfloat u2);
+extern  void ( APIENTRY * qglMapGrid2d )(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2);
+extern  void ( APIENTRY * qglMapGrid2f )(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2);
+extern  void ( APIENTRY * qglMaterialf )(GLenum face, GLenum pname, GLfloat param);
+extern  void ( APIENTRY * qglMaterialfv )(GLenum face, GLenum pname, const GLfloat *params);
+extern  void ( APIENTRY * qglMateriali )(GLenum face, GLenum pname, GLint param);
+extern  void ( APIENTRY * qglMaterialiv )(GLenum face, GLenum pname, const GLint *params);
+extern  void ( APIENTRY * qglMatrixMode )(GLenum mode);
+extern  void ( APIENTRY * qglMultMatrixd )(const GLdouble *m);
+extern  void ( APIENTRY * qglMultMatrixf )(const GLfloat *m);
+extern  void ( APIENTRY * qglNewList )(GLuint list, GLenum mode);
+extern  void ( APIENTRY * qglNormal3b )(GLbyte nx, GLbyte ny, GLbyte nz);
+extern  void ( APIENTRY * qglNormal3bv )(const GLbyte *v);
+extern  void ( APIENTRY * qglNormal3d )(GLdouble nx, GLdouble ny, GLdouble nz);
+extern  void ( APIENTRY * qglNormal3dv )(const GLdouble *v);
+extern  void ( APIENTRY * qglNormal3f )(GLfloat nx, GLfloat ny, GLfloat nz);
+extern  void ( APIENTRY * qglNormal3fv )(const GLfloat *v);
+extern  void ( APIENTRY * qglNormal3i )(GLint nx, GLint ny, GLint nz);
+extern  void ( APIENTRY * qglNormal3iv )(const GLint *v);
+extern  void ( APIENTRY * qglNormal3s )(GLshort nx, GLshort ny, GLshort nz);
+extern  void ( APIENTRY * qglNormal3sv )(const GLshort *v);
+extern  void ( APIENTRY * qglNormalPointer )(GLenum type, GLsizei stride, const GLvoid *pointer);
+extern  void ( APIENTRY * qglOrtho )(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
+extern  void ( APIENTRY * qglPassThrough )(GLfloat token);
+extern  void ( APIENTRY * qglPixelMapfv )(GLenum map, GLsizei mapsize, const GLfloat *values);
+extern  void ( APIENTRY * qglPixelMapuiv )(GLenum map, GLsizei mapsize, const GLuint *values);
+extern  void ( APIENTRY * qglPixelMapusv )(GLenum map, GLsizei mapsize, const GLushort *values);
+extern  void ( APIENTRY * qglPixelStoref )(GLenum pname, GLfloat param);
+extern  void ( APIENTRY * qglPixelStorei )(GLenum pname, GLint param);
+extern  void ( APIENTRY * qglPixelTransferf )(GLenum pname, GLfloat param);
+extern  void ( APIENTRY * qglPixelTransferi )(GLenum pname, GLint param);
+extern  void ( APIENTRY * qglPixelZoom )(GLfloat xfactor, GLfloat yfactor);
+extern  void ( APIENTRY * qglPointSize )(GLfloat size);
+extern  void ( APIENTRY * qglPolygonMode )(GLenum face, GLenum mode);
+extern  void ( APIENTRY * qglPolygonOffset )(GLfloat factor, GLfloat units);
+extern  void ( APIENTRY * qglPolygonStipple )(const GLubyte *mask);
+extern  void ( APIENTRY * qglPopAttrib )(void);
+extern  void ( APIENTRY * qglPopClientAttrib )(void);
+extern  void ( APIENTRY * qglPopMatrix )(void);
+extern  void ( APIENTRY * qglPopName )(void);
+extern  void ( APIENTRY * qglPrioritizeTextures )(GLsizei n, const GLuint *textures, const GLclampf *priorities);
+extern  void ( APIENTRY * qglPushAttrib )(GLbitfield mask);
+extern  void ( APIENTRY * qglPushClientAttrib )(GLbitfield mask);
+extern  void ( APIENTRY * qglPushMatrix )(void);
+extern  void ( APIENTRY * qglPushName )(GLuint name);
+extern  void ( APIENTRY * qglRasterPos2d )(GLdouble x, GLdouble y);
+extern  void ( APIENTRY * qglRasterPos2dv )(const GLdouble *v);
+extern  void ( APIENTRY * qglRasterPos2f )(GLfloat x, GLfloat y);
+extern  void ( APIENTRY * qglRasterPos2fv )(const GLfloat *v);
+extern  void ( APIENTRY * qglRasterPos2i )(GLint x, GLint y);
+extern  void ( APIENTRY * qglRasterPos2iv )(const GLint *v);
+extern  void ( APIENTRY * qglRasterPos2s )(GLshort x, GLshort y);
+extern  void ( APIENTRY * qglRasterPos2sv )(const GLshort *v);
+extern  void ( APIENTRY * qglRasterPos3d )(GLdouble x, GLdouble y, GLdouble z);
+extern  void ( APIENTRY * qglRasterPos3dv )(const GLdouble *v);
+extern  void ( APIENTRY * qglRasterPos3f )(GLfloat x, GLfloat y, GLfloat z);
+extern  void ( APIENTRY * qglRasterPos3fv )(const GLfloat *v);
+extern  void ( APIENTRY * qglRasterPos3i )(GLint x, GLint y, GLint z);
+extern  void ( APIENTRY * qglRasterPos3iv )(const GLint *v);
+extern  void ( APIENTRY * qglRasterPos3s )(GLshort x, GLshort y, GLshort z);
+extern  void ( APIENTRY * qglRasterPos3sv )(const GLshort *v);
+extern  void ( APIENTRY * qglRasterPos4d )(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+extern  void ( APIENTRY * qglRasterPos4dv )(const GLdouble *v);
+extern  void ( APIENTRY * qglRasterPos4f )(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+extern  void ( APIENTRY * qglRasterPos4fv )(const GLfloat *v);
+extern  void ( APIENTRY * qglRasterPos4i )(GLint x, GLint y, GLint z, GLint w);
+extern  void ( APIENTRY * qglRasterPos4iv )(const GLint *v);
+extern  void ( APIENTRY * qglRasterPos4s )(GLshort x, GLshort y, GLshort z, GLshort w);
+extern  void ( APIENTRY * qglRasterPos4sv )(const GLshort *v);
+extern  void ( APIENTRY * qglReadBuffer )(GLenum mode);
+extern  void ( APIENTRY * qglReadPixels )(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels);
+extern  void ( APIENTRY * qglRectd )(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2);
+extern  void ( APIENTRY * qglRectdv )(const GLdouble *v1, const GLdouble *v2);
+extern  void ( APIENTRY * qglRectf )(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2);
+extern  void ( APIENTRY * qglRectfv )(const GLfloat *v1, const GLfloat *v2);
+extern  void ( APIENTRY * qglRecti )(GLint x1, GLint y1, GLint x2, GLint y2);
+extern  void ( APIENTRY * qglRectiv )(const GLint *v1, const GLint *v2);
+extern  void ( APIENTRY * qglRects )(GLshort x1, GLshort y1, GLshort x2, GLshort y2);
+extern  void ( APIENTRY * qglRectsv )(const GLshort *v1, const GLshort *v2);
+extern  GLint ( APIENTRY * qglRenderMode )(GLenum mode);
+extern  void ( APIENTRY * qglRotated )(GLdouble angle, GLdouble x, GLdouble y, GLdouble z);
+extern  void ( APIENTRY * qglRotatef )(GLfloat angle, GLfloat x, GLfloat y, GLfloat z);
+extern  void ( APIENTRY * qglScaled )(GLdouble x, GLdouble y, GLdouble z);
+extern  void ( APIENTRY * qglScalef )(GLfloat x, GLfloat y, GLfloat z);
+extern  void ( APIENTRY * qglScissor )(GLint x, GLint y, GLsizei width, GLsizei height);
+extern  void ( APIENTRY * qglSelectBuffer )(GLsizei size, GLuint *buffer);
+extern  void ( APIENTRY * qglShadeModel )(GLenum mode);
+extern  void ( APIENTRY * qglStencilFunc )(GLenum func, GLint ref, GLuint mask);
+extern  void ( APIENTRY * qglStencilMask )(GLuint mask);
+extern  void ( APIENTRY * qglStencilOp )(GLenum fail, GLenum zfail, GLenum zpass);
+extern  void ( APIENTRY * qglTexCoord1d )(GLdouble s);
+extern  void ( APIENTRY * qglTexCoord1dv )(const GLdouble *v);
+extern  void ( APIENTRY * qglTexCoord1f )(GLfloat s);
+extern  void ( APIENTRY * qglTexCoord1fv )(const GLfloat *v);
+extern  void ( APIENTRY * qglTexCoord1i )(GLint s);
+extern  void ( APIENTRY * qglTexCoord1iv )(const GLint *v);
+extern  void ( APIENTRY * qglTexCoord1s )(GLshort s);
+extern  void ( APIENTRY * qglTexCoord1sv )(const GLshort *v);
+extern  void ( APIENTRY * qglTexCoord2d )(GLdouble s, GLdouble t);
+extern  void ( APIENTRY * qglTexCoord2dv )(const GLdouble *v);
+extern  void ( APIENTRY * qglTexCoord2f )(GLfloat s, GLfloat t);
+extern  void ( APIENTRY * qglTexCoord2fv )(const GLfloat *v);
+extern  void ( APIENTRY * qglTexCoord2i )(GLint s, GLint t);
+extern  void ( APIENTRY * qglTexCoord2iv )(const GLint *v);
+extern  void ( APIENTRY * qglTexCoord2s )(GLshort s, GLshort t);
+extern  void ( APIENTRY * qglTexCoord2sv )(const GLshort *v);
+extern  void ( APIENTRY * qglTexCoord3d )(GLdouble s, GLdouble t, GLdouble r);
+extern  void ( APIENTRY * qglTexCoord3dv )(const GLdouble *v);
+extern  void ( APIENTRY * qglTexCoord3f )(GLfloat s, GLfloat t, GLfloat r);
+extern  void ( APIENTRY * qglTexCoord3fv )(const GLfloat *v);
+extern  void ( APIENTRY * qglTexCoord3i )(GLint s, GLint t, GLint r);
+extern  void ( APIENTRY * qglTexCoord3iv )(const GLint *v);
+extern  void ( APIENTRY * qglTexCoord3s )(GLshort s, GLshort t, GLshort r);
+extern  void ( APIENTRY * qglTexCoord3sv )(const GLshort *v);
+extern  void ( APIENTRY * qglTexCoord4d )(GLdouble s, GLdouble t, GLdouble r, GLdouble q);
+extern  void ( APIENTRY * qglTexCoord4dv )(const GLdouble *v);
+extern  void ( APIENTRY * qglTexCoord4f )(GLfloat s, GLfloat t, GLfloat r, GLfloat q);
+extern  void ( APIENTRY * qglTexCoord4fv )(const GLfloat *v);
+extern  void ( APIENTRY * qglTexCoord4i )(GLint s, GLint t, GLint r, GLint q);
+extern  void ( APIENTRY * qglTexCoord4iv )(const GLint *v);
+extern  void ( APIENTRY * qglTexCoord4s )(GLshort s, GLshort t, GLshort r, GLshort q);
+extern  void ( APIENTRY * qglTexCoord4sv )(const GLshort *v);
+extern  void ( APIENTRY * qglTexCoordPointer )(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
+extern  void ( APIENTRY * qglTexEnvf )(GLenum target, GLenum pname, GLfloat param);
+extern  void ( APIENTRY * qglTexEnvfv )(GLenum target, GLenum pname, const GLfloat *params);
+extern  void ( APIENTRY * qglTexEnvi )(GLenum target, GLenum pname, GLint param);
+extern  void ( APIENTRY * qglTexEnviv )(GLenum target, GLenum pname, const GLint *params);
+extern  void ( APIENTRY * qglTexGend )(GLenum coord, GLenum pname, GLdouble param);
+extern  void ( APIENTRY * qglTexGendv )(GLenum coord, GLenum pname, const GLdouble *params);
+extern  void ( APIENTRY * qglTexGenf )(GLenum coord, GLenum pname, GLfloat param);
+extern  void ( APIENTRY * qglTexGenfv )(GLenum coord, GLenum pname, const GLfloat *params);
+extern  void ( APIENTRY * qglTexGeni )(GLenum coord, GLenum pname, GLint param);
+extern  void ( APIENTRY * qglTexGeniv )(GLenum coord, GLenum pname, const GLint *params);
+extern  void ( APIENTRY * qglTexImage1D )(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
+extern  void ( APIENTRY * qglTexImage2D )(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
+extern  void ( APIENTRY * qglTexParameterf )(GLenum target, GLenum pname, GLfloat param);
+extern  void ( APIENTRY * qglTexParameterfv )(GLenum target, GLenum pname, const GLfloat *params);
+extern  void ( APIENTRY * qglTexParameteri )(GLenum target, GLenum pname, GLint param);
+extern  void ( APIENTRY * qglTexParameteriv )(GLenum target, GLenum pname, const GLint *params);
+extern  void ( APIENTRY * qglTexSubImage1D )(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels);
+extern  void ( APIENTRY * qglTexSubImage2D )(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
+extern  void ( APIENTRY * qglTranslated )(GLdouble x, GLdouble y, GLdouble z);
+extern  void ( APIENTRY * qglTranslatef )(GLfloat x, GLfloat y, GLfloat z);
+extern  void ( APIENTRY * qglVertex2d )(GLdouble x, GLdouble y);
+extern  void ( APIENTRY * qglVertex2dv )(const GLdouble *v);
+extern  void ( APIENTRY * qglVertex2f )(GLfloat x, GLfloat y);
+extern  void ( APIENTRY * qglVertex2fv )(const GLfloat *v);
+extern  void ( APIENTRY * qglVertex2i )(GLint x, GLint y);
+extern  void ( APIENTRY * qglVertex2iv )(const GLint *v);
+extern  void ( APIENTRY * qglVertex2s )(GLshort x, GLshort y);
+extern  void ( APIENTRY * qglVertex2sv )(const GLshort *v);
+extern  void ( APIENTRY * qglVertex3d )(GLdouble x, GLdouble y, GLdouble z);
+extern  void ( APIENTRY * qglVertex3dv )(const GLdouble *v);
+extern  void ( APIENTRY * qglVertex3f )(GLfloat x, GLfloat y, GLfloat z);
+extern  void ( APIENTRY * qglVertex3fv )(const GLfloat *v);
+extern  void ( APIENTRY * qglVertex3i )(GLint x, GLint y, GLint z);
+extern  void ( APIENTRY * qglVertex3iv )(const GLint *v);
+extern  void ( APIENTRY * qglVertex3s )(GLshort x, GLshort y, GLshort z);
+extern  void ( APIENTRY * qglVertex3sv )(const GLshort *v);
+extern  void ( APIENTRY * qglVertex4d )(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+extern  void ( APIENTRY * qglVertex4dv )(const GLdouble *v);
+extern  void ( APIENTRY * qglVertex4f )(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+extern  void ( APIENTRY * qglVertex4fv )(const GLfloat *v);
+extern  void ( APIENTRY * qglVertex4i )(GLint x, GLint y, GLint z, GLint w);
+extern  void ( APIENTRY * qglVertex4iv )(const GLint *v);
+extern  void ( APIENTRY * qglVertex4s )(GLshort x, GLshort y, GLshort z, GLshort w);
+extern  void ( APIENTRY * qglVertex4sv )(const GLshort *v);
+extern  void ( APIENTRY * qglVertexPointer )(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
+extern  void ( APIENTRY * qglViewport )(GLint x, GLint y, GLsizei width, GLsizei height);
+
+#if defined( _WIN32 )
+
+extern BOOL  ( WINAPI * qwglCopyContext)(HGLRC, HGLRC, UINT);
+extern HGLRC ( WINAPI * qwglCreateContext)(HDC);
+extern HGLRC ( WINAPI * qwglCreateLayerContext)(HDC, int);
+extern BOOL  ( WINAPI * qwglDeleteContext)(HGLRC);
+extern HGLRC ( WINAPI * qwglGetCurrentContext)(VOID);
+extern HDC   ( WINAPI * qwglGetCurrentDC)(VOID);
+extern PROC  ( WINAPI * qwglGetProcAddress)(LPCSTR);
+extern BOOL  ( WINAPI * qwglMakeCurrent)(HDC, HGLRC);
+extern BOOL  ( WINAPI * qwglShareLists)(HGLRC, HGLRC);
+extern BOOL  ( WINAPI * qwglUseFontBitmaps)(HDC, DWORD, DWORD, DWORD);
+
+extern BOOL  ( WINAPI * qwglUseFontOutlines)(HDC, DWORD, DWORD, DWORD, FLOAT,
+                                           FLOAT, int, LPGLYPHMETRICSFLOAT);
+
+extern BOOL ( WINAPI * qwglDescribeLayerPlane)(HDC, int, int, UINT,
+                                            LPLAYERPLANEDESCRIPTOR);
+extern int  ( WINAPI * qwglSetLayerPaletteEntries)(HDC, int, int, int,
+                                                CONST COLORREF *);
+extern int  ( WINAPI * qwglGetLayerPaletteEntries)(HDC, int, int, int,
+                                                COLORREF *);
+extern BOOL ( WINAPI * qwglRealizeLayerPalette)(HDC, int, BOOL);
+extern BOOL ( WINAPI * qwglSwapLayerBuffers)(HDC, UINT);
+
+extern BOOL ( WINAPI * qwglSwapIntervalEXT)( int interval );
+
+#endif	// _WIN32
+
+#if defined( __linux__ )
+
+//FX Mesa Functions
+extern fxMesaContext (*qfxMesaCreateContext)(GLuint win, GrScreenResolution_t, GrScreenRefresh_t, const GLint attribList[]);
+extern fxMesaContext (*qfxMesaCreateBestContext)(GLuint win, GLint width, GLint height, const GLint attribList[]);
+extern void (*qfxMesaDestroyContext)(fxMesaContext ctx);
+extern void (*qfxMesaMakeCurrent)(fxMesaContext ctx);
+extern fxMesaContext (*qfxMesaGetCurrentContext)(void);
+extern void (*qfxMesaSwapBuffers)(void);
+
+//GLX Functions
+extern XVisualInfo * (*qglXChooseVisual)( Display *dpy, int screen, int *attribList );
+extern GLXContext (*qglXCreateContext)( Display *dpy, XVisualInfo *vis, GLXContext shareList, Bool direct );
+extern void (*qglXDestroyContext)( Display *dpy, GLXContext ctx );
+extern Bool (*qglXMakeCurrent)( Display *dpy, GLXDrawable drawable, GLXContext ctx);
+extern void (*qglXCopyContext)( Display *dpy, GLXContext src, GLXContext dst, GLuint mask );
+extern void (*qglXSwapBuffers)( Display *dpy, GLXDrawable drawable );
+
+#endif // __linux__
+
+#endif	// _WIN32 && __linux__
+
+#endif
diff --git a/code/renderer/qgl_console.h b/code/renderer/qgl_console.h
new file mode 100644
index 0000000..543cf58
--- /dev/null
+++ b/code/renderer/qgl_console.h
@@ -0,0 +1,1207 @@
+/*
+** QGL.H
+*/
+
+#ifndef __QGL_H__
+#define __QGL_H__
+
+#ifdef _WINDOWS
+#include <windows.h>
+#include <gl/gl.h>
+#endif
+
+#ifdef _XBOX
+
+#include <Xtl.h>
+#endif
+
+#ifdef _GAMECUBE
+#include <dolphin/gx.h>
+#include <dolphin/mtx.h>
+#endif
+
+typedef unsigned int GLenum;
+typedef unsigned char GLboolean;
+typedef unsigned int GLbitfield;
+typedef signed char GLbyte;
+typedef short GLshort;
+typedef int GLint;
+typedef int GLsizei;
+typedef unsigned char GLubyte;
+typedef unsigned short GLushort;
+typedef unsigned int GLuint;
+typedef float GLfloat;
+typedef float GLclampf;
+typedef double GLdouble;
+typedef double GLclampd;
+typedef void GLvoid;
+
+#undef APIENTRY
+#define APIENTRY
+
+#define GL_ACCUM                          0x0100
+#define GL_LOAD                           0x0101
+#define GL_RETURN                         0x0102
+#define GL_MULT                           0x0103
+#define GL_ADD                            0x0104
+
+/* AlphaFunction */
+#define GL_NEVER                          0x0200
+#define GL_LESS                           0x0201
+#define GL_EQUAL                          0x0202
+#define GL_LEQUAL                         0x0203
+#define GL_GREATER                        0x0204
+#define GL_NOTEQUAL                       0x0205
+#define GL_GEQUAL                         0x0206
+#define GL_ALWAYS                         0x0207
+
+/* AttribMask */
+#define GL_CURRENT_BIT                    0x00000001
+#define GL_POINT_BIT                      0x00000002
+#define GL_LINE_BIT                       0x00000004
+#define GL_POLYGON_BIT                    0x00000008
+#define GL_POLYGON_STIPPLE_BIT            0x00000010
+#define GL_PIXEL_MODE_BIT                 0x00000020
+#define GL_LIGHTING_BIT                   0x00000040
+#define GL_FOG_BIT                        0x00000080
+#define GL_DEPTH_BUFFER_BIT               0x00000100
+#define GL_ACCUM_BUFFER_BIT               0x00000200
+#define GL_STENCIL_BUFFER_BIT             0x00000400
+#define GL_VIEWPORT_BIT                   0x00000800
+#define GL_TRANSFORM_BIT                  0x00001000
+#define GL_ENABLE_BIT                     0x00002000
+#define GL_COLOR_BUFFER_BIT               0x00004000
+#define GL_HINT_BIT                       0x00008000
+#define GL_EVAL_BIT                       0x00010000
+#define GL_LIST_BIT                       0x00020000
+#define GL_TEXTURE_BIT                    0x00040000
+#define GL_SCISSOR_BIT                    0x00080000
+#define GL_ALL_ATTRIB_BITS                0x000fffff
+
+/* BeginMode */
+#define GL_POINTS                         0x0000
+#define GL_LINES                          0x0001
+#define GL_LINE_LOOP                      0x0002
+#define GL_LINE_STRIP                     0x0003
+#define GL_TRIANGLES                      0x0004
+#define GL_TRIANGLE_STRIP                 0x0005
+#define GL_TRIANGLE_FAN                   0x0006
+#define GL_QUADS                          0x0007
+#define GL_QUAD_STRIP                     0x0008
+#define GL_POLYGON                        0x0009
+
+/* BlendingFactorDest */
+#define GL_ZERO                           0
+#define GL_ONE                            1
+#define GL_SRC_COLOR                      0x0300
+#define GL_ONE_MINUS_SRC_COLOR            0x0301
+#define GL_SRC_ALPHA                      0x0302
+#define GL_ONE_MINUS_SRC_ALPHA            0x0303
+#define GL_DST_ALPHA                      0x0304
+#define GL_ONE_MINUS_DST_ALPHA            0x0305
+
+/* BlendingFactorSrc */
+/*      GL_ZERO */
+/*      GL_ONE */
+#define GL_DST_COLOR                      0x0306
+#define GL_ONE_MINUS_DST_COLOR            0x0307
+#define GL_SRC_ALPHA_SATURATE             0x0308
+
+/* Boolean */
+#define GL_TRUE                           1
+#define GL_FALSE                          0
+
+/* ClipPlaneName */
+#define GL_CLIP_PLANE0                    0x3000
+#define GL_CLIP_PLANE1                    0x3001
+#define GL_CLIP_PLANE2                    0x3002
+#define GL_CLIP_PLANE3                    0x3003
+#define GL_CLIP_PLANE4                    0x3004
+#define GL_CLIP_PLANE5                    0x3005
+
+/* DataType */
+#define GL_BYTE                           0x1400
+#define GL_UNSIGNED_BYTE                  0x1401
+#define GL_SHORT                          0x1402
+#define GL_UNSIGNED_SHORT                 0x1403
+#define GL_INT                            0x1404
+#define GL_UNSIGNED_INT                   0x1405
+#define GL_FLOAT                          0x1406
+#define GL_2_BYTES                        0x1407
+#define GL_3_BYTES                        0x1408
+#define GL_4_BYTES                        0x1409
+#define GL_DOUBLE                         0x140A
+
+/* DrawBufferMode */
+#define GL_NONE                           0
+#define GL_FRONT_LEFT                     0x0400
+#define GL_FRONT_RIGHT                    0x0401
+#define GL_BACK_LEFT                      0x0402
+#define GL_BACK_RIGHT                     0x0403
+#define GL_FRONT                          0x0404
+#define GL_BACK                           0x0405
+#define GL_LEFT                           0x0406
+#define GL_RIGHT                          0x0407
+#define GL_FRONT_AND_BACK                 0x0408
+#define GL_AUX0                           0x0409
+#define GL_AUX1                           0x040A
+#define GL_AUX2                           0x040B
+#define GL_AUX3                           0x040C
+
+/* ErrorCode */
+#define GL_NO_ERROR                       0
+#define GL_INVALID_ENUM                   0x0500
+#define GL_INVALID_VALUE                  0x0501
+#define GL_INVALID_OPERATION              0x0502
+#define GL_STACK_OVERFLOW                 0x0503
+#define GL_STACK_UNDERFLOW                0x0504
+#define GL_OUT_OF_MEMORY                  0x0505
+
+/* FeedBackMode */
+#define GL_2D                             0x0600
+#define GL_3D                             0x0601
+#define GL_3D_COLOR                       0x0602
+#define GL_3D_COLOR_TEXTURE               0x0603
+#define GL_4D_COLOR_TEXTURE               0x0604
+
+/* FeedBackToken */
+#define GL_PASS_THROUGH_TOKEN             0x0700
+#define GL_POINT_TOKEN                    0x0701
+#define GL_LINE_TOKEN                     0x0702
+#define GL_POLYGON_TOKEN                  0x0703
+#define GL_BITMAP_TOKEN                   0x0704
+#define GL_DRAW_PIXEL_TOKEN               0x0705
+#define GL_COPY_PIXEL_TOKEN               0x0706
+#define GL_LINE_RESET_TOKEN               0x0707
+
+/* FogMode */
+/*      GL_LINEAR */
+#define GL_EXP                            0x0800
+#define GL_EXP2                           0x0801
+
+/* FrontFaceDirection */
+#define GL_CW                             0x0900
+#define GL_CCW                            0x0901
+
+/* GetMapTarget */
+#define GL_COEFF                          0x0A00
+#define GL_ORDER                          0x0A01
+#define GL_DOMAIN                         0x0A02
+
+/* GetTarget */
+#define GL_CURRENT_COLOR                  0x0B00
+#define GL_CURRENT_INDEX                  0x0B01
+#define GL_CURRENT_NORMAL                 0x0B02
+#define GL_CURRENT_TEXTURE_COORDS         0x0B03
+#define GL_CURRENT_RASTER_COLOR           0x0B04
+#define GL_CURRENT_RASTER_INDEX           0x0B05
+#define GL_CURRENT_RASTER_TEXTURE_COORDS  0x0B06
+#define GL_CURRENT_RASTER_POSITION        0x0B07
+#define GL_CURRENT_RASTER_POSITION_VALID  0x0B08
+#define GL_CURRENT_RASTER_DISTANCE        0x0B09
+#define GL_POINT_SMOOTH                   0x0B10
+#define GL_POINT_SIZE                     0x0B11
+#define GL_POINT_SIZE_RANGE               0x0B12
+#define GL_POINT_SIZE_GRANULARITY         0x0B13
+#define GL_LINE_SMOOTH                    0x0B20
+#define GL_LINE_WIDTH                     0x0B21
+#define GL_LINE_WIDTH_RANGE               0x0B22
+#define GL_LINE_WIDTH_GRANULARITY         0x0B23
+#define GL_LINE_STIPPLE                   0x0B24
+#define GL_LINE_STIPPLE_PATTERN           0x0B25
+#define GL_LINE_STIPPLE_REPEAT            0x0B26
+#define GL_LIST_MODE                      0x0B30
+#define GL_MAX_LIST_NESTING               0x0B31
+#define GL_LIST_BASE                      0x0B32
+#define GL_LIST_INDEX                     0x0B33
+#define GL_POLYGON_MODE                   0x0B40
+#define GL_POLYGON_SMOOTH                 0x0B41
+#define GL_POLYGON_STIPPLE                0x0B42
+#define GL_EDGE_FLAG                      0x0B43
+#define GL_CULL_FACE                      0x0B44
+#define GL_CULL_FACE_MODE                 0x0B45
+#define GL_FRONT_FACE                     0x0B46
+#define GL_LIGHTING                       0x0B50
+#define GL_LIGHT_MODEL_LOCAL_VIEWER       0x0B51
+#define GL_LIGHT_MODEL_TWO_SIDE           0x0B52
+#define GL_LIGHT_MODEL_AMBIENT            0x0B53
+#define GL_SHADE_MODEL                    0x0B54
+#define GL_COLOR_MATERIAL_FACE            0x0B55
+#define GL_COLOR_MATERIAL_PARAMETER       0x0B56
+#define GL_COLOR_MATERIAL                 0x0B57
+#define GL_FOG                            0x0B60
+#define GL_FOG_INDEX                      0x0B61
+#define GL_FOG_DENSITY                    0x0B62
+#define GL_FOG_START                      0x0B63
+#define GL_FOG_END                        0x0B64
+#define GL_FOG_MODE                       0x0B65
+#define GL_FOG_COLOR                      0x0B66
+#define GL_DEPTH_RANGE                    0x0B70
+#define GL_DEPTH_TEST                     0x0B71
+#define GL_DEPTH_WRITEMASK                0x0B72
+#define GL_DEPTH_CLEAR_VALUE              0x0B73
+#define GL_DEPTH_FUNC                     0x0B74
+#define GL_ACCUM_CLEAR_VALUE              0x0B80
+#define GL_STENCIL_TEST                   0x0B90
+#define GL_STENCIL_CLEAR_VALUE            0x0B91
+#define GL_STENCIL_FUNC                   0x0B92
+#define GL_STENCIL_VALUE_MASK             0x0B93
+#define GL_STENCIL_FAIL                   0x0B94
+#define GL_STENCIL_PASS_DEPTH_FAIL        0x0B95
+#define GL_STENCIL_PASS_DEPTH_PASS        0x0B96
+#define GL_STENCIL_REF                    0x0B97
+#define GL_STENCIL_WRITEMASK              0x0B98
+#define GL_MATRIX_MODE                    0x0BA0
+#define GL_NORMALIZE                      0x0BA1
+#define GL_VIEWPORT                       0x0BA2
+#define GL_MODELVIEW_STACK_DEPTH          0x0BA3
+#define GL_PROJECTION_STACK_DEPTH         0x0BA4
+#define GL_TEXTURE_STACK_DEPTH            0x0BA5
+#define GL_MODELVIEW_MATRIX               0x0BA6
+#define GL_PROJECTION_MATRIX              0x0BA7
+#define GL_TEXTURE_MATRIX                 0x0BA8
+#define GL_ATTRIB_STACK_DEPTH             0x0BB0
+#define GL_CLIENT_ATTRIB_STACK_DEPTH      0x0BB1
+#define GL_ALPHA_TEST                     0x0BC0
+#define GL_ALPHA_TEST_FUNC                0x0BC1
+#define GL_ALPHA_TEST_REF                 0x0BC2
+#define GL_DITHER                         0x0BD0
+#define GL_BLEND_DST                      0x0BE0
+#define GL_BLEND_SRC                      0x0BE1
+#define GL_BLEND                          0x0BE2
+#define GL_LOGIC_OP_MODE                  0x0BF0
+#define GL_INDEX_LOGIC_OP                 0x0BF1
+#define GL_COLOR_LOGIC_OP                 0x0BF2
+#define GL_AUX_BUFFERS                    0x0C00
+#define GL_DRAW_BUFFER                    0x0C01
+#define GL_READ_BUFFER                    0x0C02
+#define GL_SCISSOR_BOX                    0x0C10
+#define GL_SCISSOR_TEST                   0x0C11
+#define GL_INDEX_CLEAR_VALUE              0x0C20
+#define GL_INDEX_WRITEMASK                0x0C21
+#define GL_COLOR_CLEAR_VALUE              0x0C22
+#define GL_COLOR_WRITEMASK                0x0C23
+#define GL_INDEX_MODE                     0x0C30
+#define GL_RGBA_MODE                      0x0C31
+#define GL_DOUBLEBUFFER                   0x0C32
+#define GL_STEREO                         0x0C33
+#define GL_RENDER_MODE                    0x0C40
+#define GL_PERSPECTIVE_CORRECTION_HINT    0x0C50
+#define GL_POINT_SMOOTH_HINT              0x0C51
+#define GL_LINE_SMOOTH_HINT               0x0C52
+#define GL_POLYGON_SMOOTH_HINT            0x0C53
+#define GL_FOG_HINT                       0x0C54
+#define GL_TEXTURE_GEN_S                  0x0C60
+#define GL_TEXTURE_GEN_T                  0x0C61
+#define GL_TEXTURE_GEN_R                  0x0C62
+#define GL_TEXTURE_GEN_Q                  0x0C63
+#define GL_PIXEL_MAP_I_TO_I               0x0C70
+#define GL_PIXEL_MAP_S_TO_S               0x0C71
+#define GL_PIXEL_MAP_I_TO_R               0x0C72
+#define GL_PIXEL_MAP_I_TO_G               0x0C73
+#define GL_PIXEL_MAP_I_TO_B               0x0C74
+#define GL_PIXEL_MAP_I_TO_A               0x0C75
+#define GL_PIXEL_MAP_R_TO_R               0x0C76
+#define GL_PIXEL_MAP_G_TO_G               0x0C77
+#define GL_PIXEL_MAP_B_TO_B               0x0C78
+#define GL_PIXEL_MAP_A_TO_A               0x0C79
+#define GL_PIXEL_MAP_I_TO_I_SIZE          0x0CB0
+#define GL_PIXEL_MAP_S_TO_S_SIZE          0x0CB1
+#define GL_PIXEL_MAP_I_TO_R_SIZE          0x0CB2
+#define GL_PIXEL_MAP_I_TO_G_SIZE          0x0CB3
+#define GL_PIXEL_MAP_I_TO_B_SIZE          0x0CB4
+#define GL_PIXEL_MAP_I_TO_A_SIZE          0x0CB5
+#define GL_PIXEL_MAP_R_TO_R_SIZE          0x0CB6
+#define GL_PIXEL_MAP_G_TO_G_SIZE          0x0CB7
+#define GL_PIXEL_MAP_B_TO_B_SIZE          0x0CB8
+#define GL_PIXEL_MAP_A_TO_A_SIZE          0x0CB9
+#define GL_UNPACK_SWAP_BYTES              0x0CF0
+#define GL_UNPACK_LSB_FIRST               0x0CF1
+#define GL_UNPACK_ROW_LENGTH              0x0CF2
+#define GL_UNPACK_SKIP_ROWS               0x0CF3
+#define GL_UNPACK_SKIP_PIXELS             0x0CF4
+#define GL_UNPACK_ALIGNMENT               0x0CF5
+#define GL_PACK_SWAP_BYTES                0x0D00
+#define GL_PACK_LSB_FIRST                 0x0D01
+#define GL_PACK_ROW_LENGTH                0x0D02
+#define GL_PACK_SKIP_ROWS                 0x0D03
+#define GL_PACK_SKIP_PIXELS               0x0D04
+#define GL_PACK_ALIGNMENT                 0x0D05
+#define GL_MAP_COLOR                      0x0D10
+#define GL_MAP_STENCIL                    0x0D11
+#define GL_INDEX_SHIFT                    0x0D12
+#define GL_INDEX_OFFSET                   0x0D13
+#define GL_RED_SCALE                      0x0D14
+#define GL_RED_BIAS                       0x0D15
+#define GL_ZOOM_X                         0x0D16
+#define GL_ZOOM_Y                         0x0D17
+#define GL_GREEN_SCALE                    0x0D18
+#define GL_GREEN_BIAS                     0x0D19
+#define GL_BLUE_SCALE                     0x0D1A
+#define GL_BLUE_BIAS                      0x0D1B
+#define GL_ALPHA_SCALE                    0x0D1C
+#define GL_ALPHA_BIAS                     0x0D1D
+#define GL_DEPTH_SCALE                    0x0D1E
+#define GL_DEPTH_BIAS                     0x0D1F
+#define GL_MAX_EVAL_ORDER                 0x0D30
+#define GL_MAX_LIGHTS                     0x0D31
+#define GL_MAX_CLIP_PLANES                0x0D32
+#define GL_MAX_TEXTURE_SIZE               0x0D33
+#define GL_MAX_PIXEL_MAP_TABLE            0x0D34
+#define GL_MAX_ATTRIB_STACK_DEPTH         0x0D35
+#define GL_MAX_MODELVIEW_STACK_DEPTH      0x0D36
+#define GL_MAX_NAME_STACK_DEPTH           0x0D37
+#define GL_MAX_PROJECTION_STACK_DEPTH     0x0D38
+#define GL_MAX_TEXTURE_STACK_DEPTH        0x0D39
+#define GL_MAX_VIEWPORT_DIMS              0x0D3A
+#define GL_MAX_CLIENT_ATTRIB_STACK_DEPTH  0x0D3B
+#define GL_SUBPIXEL_BITS                  0x0D50
+#define GL_INDEX_BITS                     0x0D51
+#define GL_RED_BITS                       0x0D52
+#define GL_GREEN_BITS                     0x0D53
+#define GL_BLUE_BITS                      0x0D54
+#define GL_ALPHA_BITS                     0x0D55
+#define GL_DEPTH_BITS                     0x0D56
+#define GL_STENCIL_BITS                   0x0D57
+#define GL_ACCUM_RED_BITS                 0x0D58
+#define GL_ACCUM_GREEN_BITS               0x0D59
+#define GL_ACCUM_BLUE_BITS                0x0D5A
+#define GL_ACCUM_ALPHA_BITS               0x0D5B
+#define GL_NAME_STACK_DEPTH               0x0D70
+#define GL_AUTO_NORMAL                    0x0D80
+#define GL_MAP1_COLOR_4                   0x0D90
+#define GL_MAP1_INDEX                     0x0D91
+#define GL_MAP1_NORMAL                    0x0D92
+#define GL_MAP1_TEXTURE_COORD_1           0x0D93
+#define GL_MAP1_TEXTURE_COORD_2           0x0D94
+#define GL_MAP1_TEXTURE_COORD_3           0x0D95
+#define GL_MAP1_TEXTURE_COORD_4           0x0D96
+#define GL_MAP1_VERTEX_3                  0x0D97
+#define GL_MAP1_VERTEX_4                  0x0D98
+#define GL_MAP2_COLOR_4                   0x0DB0
+#define GL_MAP2_INDEX                     0x0DB1
+#define GL_MAP2_NORMAL                    0x0DB2
+#define GL_MAP2_TEXTURE_COORD_1           0x0DB3
+#define GL_MAP2_TEXTURE_COORD_2           0x0DB4
+#define GL_MAP2_TEXTURE_COORD_3           0x0DB5
+#define GL_MAP2_TEXTURE_COORD_4           0x0DB6
+#define GL_MAP2_VERTEX_3                  0x0DB7
+#define GL_MAP2_VERTEX_4                  0x0DB8
+#define GL_MAP1_GRID_DOMAIN               0x0DD0
+#define GL_MAP1_GRID_SEGMENTS             0x0DD1
+#define GL_MAP2_GRID_DOMAIN               0x0DD2
+#define GL_MAP2_GRID_SEGMENTS             0x0DD3
+#define GL_TEXTURE_1D                     0x0DE0
+#define GL_TEXTURE_2D                     0x0DE1
+#define GL_FEEDBACK_BUFFER_POINTER        0x0DF0
+#define GL_FEEDBACK_BUFFER_SIZE           0x0DF1
+#define GL_FEEDBACK_BUFFER_TYPE           0x0DF2
+#define GL_SELECTION_BUFFER_POINTER       0x0DF3
+#define GL_SELECTION_BUFFER_SIZE          0x0DF4
+
+/* GetTextureParameter */
+#define GL_TEXTURE_WIDTH                  0x1000
+#define GL_TEXTURE_HEIGHT                 0x1001
+#define GL_TEXTURE_INTERNAL_FORMAT        0x1003
+#define GL_TEXTURE_BORDER_COLOR           0x1004
+#define GL_TEXTURE_BORDER                 0x1005
+
+/* HintMode */
+#define GL_DONT_CARE                      0x1100
+#define GL_FASTEST                        0x1101
+#define GL_NICEST                         0x1102
+
+/* LightName */
+#define GL_LIGHT0                         0x4000
+#define GL_LIGHT1                         0x4001
+#define GL_LIGHT2                         0x4002
+#define GL_LIGHT3                         0x4003
+#define GL_LIGHT4                         0x4004
+#define GL_LIGHT5                         0x4005
+#define GL_LIGHT6                         0x4006
+#define GL_LIGHT7                         0x4007
+
+/* LightParameter */
+#define GL_AMBIENT                        0x1200
+#define GL_DIFFUSE                        0x1201
+#define GL_SPECULAR                       0x1202
+#define GL_POSITION                       0x1203
+#define GL_SPOT_DIRECTION                 0x1204
+#define GL_SPOT_EXPONENT                  0x1205
+#define GL_SPOT_CUTOFF                    0x1206
+#define GL_CONSTANT_ATTENUATION           0x1207
+#define GL_LINEAR_ATTENUATION             0x1208
+#define GL_QUADRATIC_ATTENUATION          0x1209
+
+/* ListMode */
+#define GL_COMPILE                        0x1300
+#define GL_COMPILE_AND_EXECUTE            0x1301
+
+/* LogicOp */
+#define GL_CLEAR                          0x1500
+#define GL_AND                            0x1501
+#define GL_AND_REVERSE                    0x1502
+#define GL_COPY                           0x1503
+#define GL_AND_INVERTED                   0x1504
+#define GL_NOOP                           0x1505
+#define GL_XOR                            0x1506
+#define GL_OR                             0x1507
+#define GL_NOR                            0x1508
+#define GL_EQUIV                          0x1509
+#define GL_INVERT                         0x150A
+#define GL_OR_REVERSE                     0x150B
+#define GL_COPY_INVERTED                  0x150C
+#define GL_OR_INVERTED                    0x150D
+#define GL_NAND                           0x150E
+#define GL_SET                            0x150F
+
+/* MaterialParameter */
+#define GL_EMISSION                       0x1600
+#define GL_SHININESS                      0x1601
+#define GL_AMBIENT_AND_DIFFUSE            0x1602
+#define GL_COLOR_INDEXES                  0x1603
+
+/* MatrixMode */
+#define GL_MODELVIEW                      0x1700
+#define GL_PROJECTION                     0x1701
+#define GL_TEXTURE0						  0x1702
+#define GL_TEXTURE1                       0x1703
+#define GL_TEXTURE2                       0x1704
+#define GL_TEXTURE3                       0x1705
+
+/* PixelCopyType */
+#define GL_COLOR                          0x1800
+#define GL_DEPTH                          0x1801
+#define GL_STENCIL                        0x1802
+
+/* PixelFormat */
+#define GL_COLOR_INDEX                    0x1900
+#define GL_STENCIL_INDEX                  0x1901
+#define GL_DEPTH_COMPONENT                0x1902
+#define GL_RED                            0x1903
+#define GL_GREEN                          0x1904
+#define GL_BLUE                           0x1905
+#define GL_ALPHA                          0x1906
+#define GL_RGB                            0x1907
+#define GL_RGBA                           0x1908
+#define GL_LUMINANCE                      0x1909
+#define GL_LUMINANCE_ALPHA                0x190A
+
+/* PixelType */
+#define GL_BITMAP                         0x1A00
+
+/* PolygonMode */
+#define GL_POINT                          0x1B00
+#define GL_LINE                           0x1B01
+#define GL_FILL                           0x1B02
+
+/* RenderingMode */
+#define GL_RENDER                         0x1C00
+#define GL_FEEDBACK                       0x1C01
+#define GL_SELECT                         0x1C02
+
+/* ShadingModel */
+#define GL_FLAT                           0x1D00
+#define GL_SMOOTH                         0x1D01
+
+/* StencilOp */
+/*      GL_ZERO */
+#define GL_KEEP                           0x1E00
+#define GL_REPLACE                        0x1E01
+#define GL_INCR                           0x1E02
+#define GL_DECR                           0x1E03
+/*      GL_INVERT */
+
+/* StringName */
+#define GL_VENDOR                         0x1F00
+#define GL_RENDERER                       0x1F01
+#define GL_VERSION                        0x1F02
+#define GL_EXTENSIONS                     0x1F03
+
+/* TextureCoordName */
+#define GL_S                              0x2000
+#define GL_T                              0x2001
+#define GL_R                              0x2002
+#define GL_Q                              0x2003
+
+/* TextureEnvMode */
+#define GL_MODULATE                       0x2100
+#define GL_DECAL                          0x2101
+
+/* TextureEnvParameter */
+#define GL_TEXTURE_ENV_MODE               0x2200
+#define GL_TEXTURE_ENV_COLOR              0x2201
+
+/* TextureEnvTarget */
+#define GL_TEXTURE_ENV                    0x2300
+
+/* TextureGenMode */
+#define GL_EYE_LINEAR                     0x2400
+#define GL_OBJECT_LINEAR                  0x2401
+#define GL_SPHERE_MAP                     0x2402
+
+/* TextureGenParameter */
+#define GL_TEXTURE_GEN_MODE               0x2500
+#define GL_OBJECT_PLANE                   0x2501
+#define GL_EYE_PLANE                      0x2502
+
+/* TextureMagFilter */
+#define GL_NEAREST                        0x2600
+#define GL_LINEAR                         0x2601
+
+/* TextureMinFilter */
+#define GL_NEAREST_MIPMAP_NEAREST         0x2700
+#define GL_LINEAR_MIPMAP_NEAREST          0x2701
+#define GL_NEAREST_MIPMAP_LINEAR          0x2702
+#define GL_LINEAR_MIPMAP_LINEAR           0x2703
+
+/* TextureParameterName */
+#define GL_TEXTURE_MAG_FILTER             0x2800
+#define GL_TEXTURE_MIN_FILTER             0x2801
+#define GL_TEXTURE_WRAP_S                 0x2802
+#define GL_TEXTURE_WRAP_T                 0x2803
+
+// PORT: Anisotropy stuff
+#define GL_TEXTURE_MAX_ANISOTROPY_EXT     0x84FE
+#define GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT 0x84FF
+
+//PORT - TPL stuff
+#define GL_TPL4_EXT                       0x9991
+#define GL_TPL8_EXT                       0x9992
+#define GL_TPL16_EXT                      0x9993
+#define GL_TPL32_EXT                      0x9994
+
+// PORT: DDS Stuff
+#define GL_DDS_RGBA_EXT                   0x9998
+#define GL_RGB_SWIZZLE_EXT				  0x9999
+
+/* TextureWrapMode */
+#define GL_CLAMP                          0x2900
+#define GL_REPEAT                         0x2901
+
+/* ClientAttribMask */
+#define GL_CLIENT_PIXEL_STORE_BIT         0x00000001
+#define GL_CLIENT_VERTEX_ARRAY_BIT        0x00000002
+#define GL_CLIENT_ALL_ATTRIB_BITS         0xffffffff
+
+/* polygon_offset */
+#define GL_POLYGON_OFFSET_FACTOR          0x8038
+#define GL_POLYGON_OFFSET_UNITS           0x2A00
+#define GL_POLYGON_OFFSET_POINT           0x2A01
+#define GL_POLYGON_OFFSET_LINE            0x2A02
+#define GL_POLYGON_OFFSET_FILL            0x8037
+
+/* texture */
+#define GL_ALPHA4                         0x803B
+#define GL_ALPHA8                         0x803C
+#define GL_ALPHA12                        0x803D
+#define GL_ALPHA16                        0x803E
+#define GL_LUMINANCE4                     0x803F
+#define GL_LUMINANCE8                     0x8040
+#define GL_LUMINANCE12                    0x8041
+#define GL_LUMINANCE16                    0x8042
+#define GL_LUMINANCE4_ALPHA4              0x8043
+#define GL_LUMINANCE6_ALPHA2              0x8044
+#define GL_LUMINANCE8_ALPHA8              0x8045
+#define GL_LUMINANCE12_ALPHA4             0x8046
+#define GL_LUMINANCE12_ALPHA12            0x8047
+#define GL_LUMINANCE16_ALPHA16            0x8048
+#define GL_INTENSITY                      0x8049
+#define GL_INTENSITY4                     0x804A
+#define GL_INTENSITY8                     0x804B
+#define GL_INTENSITY12                    0x804C
+#define GL_INTENSITY16                    0x804D
+#define GL_R3_G3_B2                       0x2A10
+#define GL_RGB4                           0x804F
+#define GL_RGB5                           0x8050
+#define GL_RGB8                           0x8051
+#define GL_RGB10                          0x8052
+#define GL_RGB12                          0x8053
+#define GL_RGB16                          0x8054
+#define GL_RGBA2                          0x8055
+#define GL_RGBA4                          0x8056
+#define GL_RGB5_A1                        0x8057
+#define GL_RGBA8                          0x8058
+#define GL_RGB10_A2                       0x8059
+#define GL_RGBA12                         0x805A
+#define GL_RGBA16                         0x805B
+#define GL_TEXTURE_RED_SIZE               0x805C
+#define GL_TEXTURE_GREEN_SIZE             0x805D
+#define GL_TEXTURE_BLUE_SIZE              0x805E
+#define GL_TEXTURE_ALPHA_SIZE             0x805F
+#define GL_TEXTURE_LUMINANCE_SIZE         0x8060
+#define GL_TEXTURE_INTENSITY_SIZE         0x8061
+#define GL_PROXY_TEXTURE_1D               0x8063
+#define GL_PROXY_TEXTURE_2D               0x8064
+
+/* texture_object */
+#define GL_TEXTURE_PRIORITY               0x8066
+#define GL_TEXTURE_RESIDENT               0x8067
+#define GL_TEXTURE_BINDING_1D             0x8068
+#define GL_TEXTURE_BINDING_2D             0x8069
+
+/* vertex_array */
+#define GL_VERTEX_ARRAY                   0x8074
+#define GL_NORMAL_ARRAY                   0x8075
+#define GL_COLOR_ARRAY                    0x8076
+#define GL_INDEX_ARRAY                    0x8077
+#define GL_TEXTURE_COORD_ARRAY            0x8078
+#define GL_EDGE_FLAG_ARRAY                0x8079
+#define GL_VERTEX_ARRAY_SIZE              0x807A
+#define GL_VERTEX_ARRAY_TYPE              0x807B
+#define GL_VERTEX_ARRAY_STRIDE            0x807C
+#define GL_NORMAL_ARRAY_TYPE              0x807E
+#define GL_NORMAL_ARRAY_STRIDE            0x807F
+#define GL_COLOR_ARRAY_SIZE               0x8081
+#define GL_COLOR_ARRAY_TYPE               0x8082
+#define GL_COLOR_ARRAY_STRIDE             0x8083
+#define GL_INDEX_ARRAY_TYPE               0x8085
+#define GL_INDEX_ARRAY_STRIDE             0x8086
+#define GL_TEXTURE_COORD_ARRAY_SIZE       0x8088
+#define GL_TEXTURE_COORD_ARRAY_TYPE       0x8089
+#define GL_TEXTURE_COORD_ARRAY_STRIDE     0x808A
+#define GL_EDGE_FLAG_ARRAY_STRIDE         0x808C
+#define GL_VERTEX_ARRAY_POINTER           0x808E
+#define GL_NORMAL_ARRAY_POINTER           0x808F
+#define GL_COLOR_ARRAY_POINTER            0x8090
+#define GL_INDEX_ARRAY_POINTER            0x8091
+#define GL_TEXTURE_COORD_ARRAY_POINTER    0x8092
+#define GL_EDGE_FLAG_ARRAY_POINTER        0x8093
+#define GL_V2F                            0x2A20
+#define GL_V3F                            0x2A21
+#define GL_C4UB_V2F                       0x2A22
+#define GL_C4UB_V3F                       0x2A23
+#define GL_C3F_V3F                        0x2A24
+#define GL_N3F_V3F                        0x2A25
+#define GL_C4F_N3F_V3F                    0x2A26
+#define GL_T2F_V3F                        0x2A27
+#define GL_T4F_V4F                        0x2A28
+#define GL_T2F_C4UB_V3F                   0x2A29
+#define GL_T2F_C3F_V3F                    0x2A2A
+#define GL_T2F_N3F_V3F                    0x2A2B
+#define GL_T2F_C4F_N3F_V3F                0x2A2C
+#define GL_T4F_C4F_N3F_V4F                0x2A2D
+
+/* Extensions */
+#define GL_EXT_vertex_array               1
+#define GL_EXT_bgra                       1
+#define GL_EXT_paletted_texture           1
+
+/* EXT_vertex_array */
+#define GL_VERTEX_ARRAY_EXT               0x8074
+#define GL_NORMAL_ARRAY_EXT               0x8075
+#define GL_COLOR_ARRAY_EXT                0x8076
+#define GL_INDEX_ARRAY_EXT                0x8077
+#define GL_TEXTURE_COORD_ARRAY_EXT        0x8078
+#define GL_EDGE_FLAG_ARRAY_EXT            0x8079
+#define GL_VERTEX_ARRAY_SIZE_EXT          0x807A
+#define GL_VERTEX_ARRAY_TYPE_EXT          0x807B
+#define GL_VERTEX_ARRAY_STRIDE_EXT        0x807C
+#define GL_VERTEX_ARRAY_COUNT_EXT         0x807D
+#define GL_NORMAL_ARRAY_TYPE_EXT          0x807E
+#define GL_NORMAL_ARRAY_STRIDE_EXT        0x807F
+#define GL_NORMAL_ARRAY_COUNT_EXT         0x8080
+#define GL_COLOR_ARRAY_SIZE_EXT           0x8081
+#define GL_COLOR_ARRAY_TYPE_EXT           0x8082
+#define GL_COLOR_ARRAY_STRIDE_EXT         0x8083
+#define GL_COLOR_ARRAY_COUNT_EXT          0x8084
+#define GL_INDEX_ARRAY_TYPE_EXT           0x8085
+#define GL_INDEX_ARRAY_STRIDE_EXT         0x8086
+#define GL_INDEX_ARRAY_COUNT_EXT          0x8087
+#define GL_TEXTURE_COORD_ARRAY_SIZE_EXT   0x8088
+#define GL_TEXTURE_COORD_ARRAY_TYPE_EXT   0x8089
+#define GL_TEXTURE_COORD_ARRAY_STRIDE_EXT 0x808A
+#define GL_TEXTURE_COORD_ARRAY_COUNT_EXT  0x808B
+#define GL_EDGE_FLAG_ARRAY_STRIDE_EXT     0x808C
+#define GL_EDGE_FLAG_ARRAY_COUNT_EXT      0x808D
+#define GL_VERTEX_ARRAY_POINTER_EXT       0x808E
+#define GL_NORMAL_ARRAY_POINTER_EXT       0x808F
+#define GL_COLOR_ARRAY_POINTER_EXT        0x8090
+#define GL_INDEX_ARRAY_POINTER_EXT        0x8091
+#define GL_TEXTURE_COORD_ARRAY_POINTER_EXT 0x8092
+#define GL_EDGE_FLAG_ARRAY_POINTER_EXT    0x8093
+#define GL_DOUBLE_EXT                     GL_DOUBLE
+
+/* EXT_bgra */
+#define GL_BGR_EXT                        0x80E0
+#define GL_BGRA_EXT                       0x80E1
+
+/* EXT_paletted_texture */
+
+/* These must match the GL_COLOR_TABLE_*_SGI enumerants */
+#define GL_COLOR_TABLE_FORMAT_EXT         0x80D8
+#define GL_COLOR_TABLE_WIDTH_EXT          0x80D9
+#define GL_COLOR_TABLE_RED_SIZE_EXT       0x80DA
+#define GL_COLOR_TABLE_GREEN_SIZE_EXT     0x80DB
+#define GL_COLOR_TABLE_BLUE_SIZE_EXT      0x80DC
+#define GL_COLOR_TABLE_ALPHA_SIZE_EXT     0x80DD
+#define GL_COLOR_TABLE_LUMINANCE_SIZE_EXT 0x80DE
+#define GL_COLOR_TABLE_INTENSITY_SIZE_EXT 0x80DF
+
+#define GL_COLOR_INDEX1_EXT               0x80E2
+#define GL_COLOR_INDEX2_EXT               0x80E3
+#define GL_COLOR_INDEX4_EXT               0x80E4
+#define GL_COLOR_INDEX8_EXT               0x80E5
+#define GL_COLOR_INDEX12_EXT              0x80E6
+#define GL_COLOR_INDEX16_EXT              0x80E7
+
+// VVFIXME New Constants from Jedi
+#define GL_VSYNC                          0x813F
+#define GL_DDS_RGB16_EXT                  0x9997
+#define GL_DDS_RGBA32_EXT                 0x9998
+#define GL_RGB_SWIZZLE_EXT                0x9999
+
+//	VVFIXME - New constants for linear format textures.
+// These numbers are just made up. This is awful.
+#define GL_LIN_RGBA8	0x8E01
+#define GL_LIN_RGBA		0x8E02
+#define GL_LIN_RGB8		0x8E03
+#define GL_LIN_RGB		0x8E04
+
+
+//===========================================================================
+
+/*
+** multitexture extension definitions
+*/
+#define GL_ACTIVE_TEXTURE_ARB               0x84E0
+#define GL_CLIENT_ACTIVE_TEXTURE_ARB        0x84E1
+#define GL_MAX_ACTIVE_TEXTURES_ARB          0x84E2
+
+#define GL_TEXTURE0_ARB                     0x84C0
+#define GL_TEXTURE1_ARB                     0x84C1
+#define GL_TEXTURE2_ARB                     0x84C2
+#define GL_TEXTURE3_ARB                     0x84C3
+
+typedef void ( * PFNGLMULTITEXCOORD1DARBPROC) (GLenum target, GLdouble s);
+typedef void ( * PFNGLMULTITEXCOORD1DVARBPROC) (GLenum target, const GLdouble *v);
+typedef void ( * PFNGLMULTITEXCOORD1FARBPROC) (GLenum target, GLfloat s);
+typedef void ( * PFNGLMULTITEXCOORD1FVARBPROC) (GLenum target, const GLfloat *v);
+typedef void ( * PFNGLMULTITEXCOORD1IARBPROC) (GLenum target, GLint s);
+typedef void ( * PFNGLMULTITEXCOORD1IVARBPROC) (GLenum target, const GLint *v);
+typedef void ( * PFNGLMULTITEXCOORD1SARBPROC) (GLenum target, GLshort s);
+typedef void ( * PFNGLMULTITEXCOORD1SVARBPROC) (GLenum target, const GLshort *v);
+typedef void ( * PFNGLMULTITEXCOORD2DARBPROC) (GLenum target, GLdouble s, GLdouble t);
+typedef void ( * PFNGLMULTITEXCOORD2DVARBPROC) (GLenum target, const GLdouble *v);
+typedef void ( * PFNGLMULTITEXCOORD2FARBPROC) (GLenum target, GLfloat s, GLfloat t);
+typedef void ( * PFNGLMULTITEXCOORD2FVARBPROC) (GLenum target, const GLfloat *v);
+typedef void ( * PFNGLMULTITEXCOORD2IARBPROC) (GLenum target, GLint s, GLint t);
+typedef void ( * PFNGLMULTITEXCOORD2IVARBPROC) (GLenum target, const GLint *v);
+typedef void ( * PFNGLMULTITEXCOORD2SARBPROC) (GLenum target, GLshort s, GLshort t);
+typedef void ( * PFNGLMULTITEXCOORD2SVARBPROC) (GLenum target, const GLshort *v);
+typedef void ( * PFNGLMULTITEXCOORD3DARBPROC) (GLenum target, GLdouble s, GLdouble t, GLdouble r);
+typedef void ( * PFNGLMULTITEXCOORD3DVARBPROC) (GLenum target, const GLdouble *v);
+typedef void ( * PFNGLMULTITEXCOORD3FARBPROC) (GLenum target, GLfloat s, GLfloat t, GLfloat r);
+typedef void ( * PFNGLMULTITEXCOORD3FVARBPROC) (GLenum target, const GLfloat *v);
+typedef void ( * PFNGLMULTITEXCOORD3IARBPROC) (GLenum target, GLint s, GLint t, GLint r);
+typedef void ( * PFNGLMULTITEXCOORD3IVARBPROC) (GLenum target, const GLint *v);
+typedef void ( * PFNGLMULTITEXCOORD3SARBPROC) (GLenum target, GLshort s, GLshort t, GLshort r);
+typedef void ( * PFNGLMULTITEXCOORD3SVARBPROC) (GLenum target, const GLshort *v);
+typedef void ( * PFNGLMULTITEXCOORD4DARBPROC) (GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q);
+typedef void ( * PFNGLMULTITEXCOORD4DVARBPROC) (GLenum target, const GLdouble *v);
+typedef void ( * PFNGLMULTITEXCOORD4FARBPROC) (GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q);
+typedef void ( * PFNGLMULTITEXCOORD4FVARBPROC) (GLenum target, const GLfloat *v);
+typedef void ( * PFNGLMULTITEXCOORD4IARBPROC) (GLenum target, GLint s, GLint t, GLint r, GLint q);
+typedef void ( * PFNGLMULTITEXCOORD4IVARBPROC) (GLenum target, const GLint *v);
+typedef void ( * PFNGLMULTITEXCOORD4SARBPROC) (GLenum target, GLshort s, GLshort t, GLshort r, GLshort q);
+typedef void ( * PFNGLMULTITEXCOORD4SVARBPROC) (GLenum target, const GLshort *v);
+typedef void ( * PFNGLACTIVETEXTUREARBPROC) (GLenum target);
+typedef void ( * PFNGLCLIENTACTIVETEXTUREARBPROC) (GLenum target);
+
+/*
+** extension constants
+*/
+extern	void ( * qglMultiTexCoord2fARB )( GLenum texture, GLfloat s, GLfloat t );
+extern	void ( * qglActiveTextureARB )( GLenum texture );
+extern	void ( * qglClientActiveTextureARB )( GLenum texture );
+
+extern	void ( * qglLockArraysEXT) (GLint, GLint);
+extern	void ( * qglUnlockArraysEXT) (void);
+
+//----(SA)	from Raven
+extern	void ( * qglPointParameterfEXT)( GLenum, GLfloat);
+extern	void ( * qglPointParameterfvEXT)( GLenum, GLfloat *);
+//----(SA)	end
+
+
+
+// S3TC compression constants
+#define GL_RGB_S3TC							0x83A0
+#define GL_RGB4_S3TC						0x83A1
+// More, grabbed from wolf code PORT
+#define	GL_COMPRESSED_RGB_S3TC_DXT1_EXT                   0x83F0
+#define	GL_COMPRESSED_RGBA_S3TC_DXT1_EXT                  0x83F1
+#define	GL_COMPRESSED_RGBA_S3TC_DXT3_EXT                  0x83F2
+#define	GL_COMPRESSED_RGBA_S3TC_DXT5_EXT                  0x83F3
+
+// And more, also from old wolf code:
+// GR - update enumerants
+#define GL_PN_TRIANGLES_ATI							0x87F0
+#define GL_MAX_PN_TRIANGLES_TESSELATION_LEVEL_ATI	0x87F1
+#define GL_PN_TRIANGLES_POINT_MODE_ATI				0x87F2
+#define GL_PN_TRIANGLES_NORMAL_MODE_ATI				0x87F3
+#define GL_PN_TRIANGLES_TESSELATION_LEVEL_ATI		0x87F4
+#define GL_PN_TRIANGLES_POINT_MODE_LINEAR_ATI		0x87F5
+#define GL_PN_TRIANGLES_POINT_MODE_CUBIC_ATI		0x87F6
+#define GL_PN_TRIANGLES_NORMAL_MODE_LINEAR_ATI		0x87F7
+#define GL_PN_TRIANGLES_NORMAL_MODE_QUADRATIC_ATI	0x87F8
+
+extern	void ( * qglPNTrianglesiATI)(GLenum pname, GLint param);
+extern	void ( * qglPNTrianglesfATI)(GLenum pname, GLfloat param);
+
+#define GL_FOG_DISTANCE_MODE_NV           0x855A
+#define GL_EYE_RADIAL_NV                  0x855B
+#define GL_EYE_PLANE_ABSOLUTE_NV          0x855C
+
+//===========================================================================
+
+
+extern  void ( * qglAccum )(GLenum op, GLfloat value);
+extern  void ( * qglAlphaFunc )(GLenum func, GLclampf ref);
+extern  GLboolean ( * qglAreTexturesResident )(GLsizei n, const GLuint *textures, GLboolean *residences);
+extern  void ( * qglArrayElement )(GLint i);
+extern  void ( * qglBegin )(GLenum mode);
+extern  void ( * qglBeginEXT )(GLenum mode, GLint verts, GLint colors, GLint normals, GLint tex0, GLint tex1);//, GLint tex2, GLint tex3);
+extern  GLboolean ( * qglBeginFrame )(void);
+extern  void ( * qglBeginShadow )(void);
+extern  void ( * qglBindTexture )(GLenum target, GLuint texture);
+extern  void ( * qglBitmap )(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap);
+extern  void ( * qglBlendFunc )(GLenum sfactor, GLenum dfactor);
+extern  void ( * qglCallList )(GLuint list);
+extern  void ( * qglCallLists )(GLsizei n, GLenum type, const GLvoid *lists);
+extern  void ( * qglClear )(GLbitfield mask);
+extern  void ( * qglClearAccum )(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
+extern  void ( * qglClearColor )(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
+extern  void ( * qglClearDepth )(GLclampd depth);
+extern  void ( * qglClearIndex )(GLfloat c);
+extern  void ( * qglClearStencil )(GLint s);
+extern  void ( * qglClipPlane )(GLenum plane, const GLdouble *equation);
+extern  void ( * qglColor3b )(GLbyte red, GLbyte green, GLbyte blue);
+extern  void ( * qglColor3bv )(const GLbyte *v);
+extern  void ( * qglColor3d )(GLdouble red, GLdouble green, GLdouble blue);
+extern  void ( * qglColor3dv )(const GLdouble *v);
+extern  void ( * qglColor3f )(GLfloat red, GLfloat green, GLfloat blue);
+extern  void ( * qglColor3fv )(const GLfloat *v);
+extern  void ( * qglColor3i )(GLint red, GLint green, GLint blue);
+extern  void ( * qglColor3iv )(const GLint *v);
+extern  void ( * qglColor3s )(GLshort red, GLshort green, GLshort blue);
+extern  void ( * qglColor3sv )(const GLshort *v);
+extern  void ( * qglColor3ub )(GLubyte red, GLubyte green, GLubyte blue);
+extern  void ( * qglColor3ubv )(const GLubyte *v);
+extern  void ( * qglColor3ui )(GLuint red, GLuint green, GLuint blue);
+extern  void ( * qglColor3uiv )(const GLuint *v);
+extern  void ( * qglColor3us )(GLushort red, GLushort green, GLushort blue);
+extern  void ( * qglColor3usv )(const GLushort *v);
+extern  void ( * qglColor4b )(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha);
+extern  void ( * qglColor4bv )(const GLbyte *v);
+extern  void ( * qglColor4d )(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha);
+extern  void ( * qglColor4dv )(const GLdouble *v);
+extern  void ( * qglColor4f )(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
+extern  void ( * qglColor4fv )(const GLfloat *v);
+extern  void ( * qglColor4i )(GLint red, GLint green, GLint blue, GLint alpha);
+extern  void ( * qglColor4iv )(const GLint *v);
+extern  void ( * qglColor4s )(GLshort red, GLshort green, GLshort blue, GLshort alpha);
+extern  void ( * qglColor4sv )(const GLshort *v);
+extern  void ( * qglColor4ub )(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha);
+extern  void ( * qglColor4ubv )(const GLubyte *v);
+extern  void ( * qglColor4ui )(GLuint red, GLuint green, GLuint blue, GLuint alpha);
+extern  void ( * qglColor4uiv )(const GLuint *v);
+extern  void ( * qglColor4us )(GLushort red, GLushort green, GLushort blue, GLushort alpha);
+extern  void ( * qglColor4usv )(const GLushort *v);
+extern  void ( * qglColorMask )(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
+extern  void ( * qglColorMaterial )(GLenum face, GLenum mode);
+extern  void ( * qglColorPointer )(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
+extern  void ( * qglCopyPixels )(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type);
+extern  void ( * qglCopyTexImage1D )(GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border);
+extern  void ( * qglCopyTexImage2D )(GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
+extern  void ( * qglCopyTexSubImage1D )(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);
+extern  void ( * qglCopyTexSubImage2D )(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
+extern  void ( * qglCullFace )(GLenum mode);
+extern  void ( * qglDeleteLists )(GLuint list, GLsizei range);
+extern  void ( * qglDeleteTextures )(GLsizei n, const GLuint *textures);
+extern  void ( * qglDepthFunc )(GLenum func);
+extern  void ( * qglDepthMask )(GLboolean flag);
+extern  void ( * qglDepthRange )(GLclampd zNear, GLclampd zFar);
+extern  void ( * qglDisable )(GLenum cap);
+extern  void ( * qglDisableClientState )(GLenum array);
+extern  void ( * qglDrawArrays )(GLenum mode, GLint first, GLsizei count);
+extern  void ( * qglDrawBuffer )(GLenum mode);
+extern  void ( * qglDrawElements )(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices);
+extern  void ( * qglDrawPixels )(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
+extern  void ( * qglEdgeFlag )(GLboolean flag);
+extern  void ( * qglEdgeFlagPointer )(GLsizei stride, const GLvoid *pointer);
+extern  void ( * qglEdgeFlagv )(const GLboolean *flag);
+extern  void ( * qglEnable )(GLenum cap);
+extern  void ( * qglEnableClientState )(GLenum array);
+extern  void ( * qglEnd )(void);
+extern  void ( * qglEndFrame )(void);
+extern  void ( * qglEndShadow )(void);
+extern  void ( * qglEndList )(void);
+extern  void ( * qglEvalCoord1d )(GLdouble u);
+extern  void ( * qglEvalCoord1dv )(const GLdouble *u);
+extern  void ( * qglEvalCoord1f )(GLfloat u);
+extern  void ( * qglEvalCoord1fv )(const GLfloat *u);
+extern  void ( * qglEvalCoord2d )(GLdouble u, GLdouble v);
+extern  void ( * qglEvalCoord2dv )(const GLdouble *u);
+extern  void ( * qglEvalCoord2f )(GLfloat u, GLfloat v);
+extern  void ( * qglEvalCoord2fv )(const GLfloat *u);
+extern  void ( * qglEvalMesh1 )(GLenum mode, GLint i1, GLint i2);
+extern  void ( * qglEvalMesh2 )(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2);
+extern  void ( * qglEvalPoint1 )(GLint i);
+extern  void ( * qglEvalPoint2 )(GLint i, GLint j);
+extern  void ( * qglFeedbackBuffer )(GLsizei size, GLenum type, GLfloat *buffer);
+extern  void ( * qglFinish )(void);
+extern  void ( * qglFlush )(void);
+extern  void ( * qglFlushShadow )(void);
+extern  void ( * qglFogf )(GLenum pname, GLfloat param);
+extern  void ( * qglFogfv )(GLenum pname, const GLfloat *params);
+extern  void ( * qglFogi )(GLenum pname, GLint param);
+extern  void ( * qglFogiv )(GLenum pname, const GLint *params);
+extern  void ( * qglFrontFace )(GLenum mode);
+extern  void ( * qglFrustum )(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
+extern  GLuint ( * qglGenLists )(GLsizei range);
+extern  void ( * qglGenTextures )(GLsizei n, GLuint *textures);
+extern  void ( * qglGetBooleanv )(GLenum pname, GLboolean *params);
+extern  void ( * qglGetClipPlane )(GLenum plane, GLdouble *equation);
+extern  void ( * qglGetDoublev )(GLenum pname, GLdouble *params);
+extern  GLenum ( * qglGetError )(void);
+extern  void ( * qglGetFloatv )(GLenum pname, GLfloat *params);
+extern  void ( * qglGetIntegerv )(GLenum pname, GLint *params);
+extern  void ( * qglGetLightfv )(GLenum light, GLenum pname, GLfloat *params);
+extern  void ( * qglGetLightiv )(GLenum light, GLenum pname, GLint *params);
+extern  void ( * qglGetMapdv )(GLenum target, GLenum query, GLdouble *v);
+extern  void ( * qglGetMapfv )(GLenum target, GLenum query, GLfloat *v);
+extern  void ( * qglGetMapiv )(GLenum target, GLenum query, GLint *v);
+extern  void ( * qglGetMaterialfv )(GLenum face, GLenum pname, GLfloat *params);
+extern  void ( * qglGetMaterialiv )(GLenum face, GLenum pname, GLint *params);
+extern  void ( * qglGetPixelMapfv )(GLenum map, GLfloat *values);
+extern  void ( * qglGetPixelMapuiv )(GLenum map, GLuint *values);
+extern  void ( * qglGetPixelMapusv )(GLenum map, GLushort *values);
+extern  void ( * qglGetPointerv )(GLenum pname, GLvoid* *params);
+extern  void ( * qglGetPolygonStipple )(GLubyte *mask);
+extern  const GLubyte * ( * qglGetString )(GLenum name);
+extern  void ( * qglGetTexEnvfv )(GLenum target, GLenum pname, GLfloat *params);
+extern  void ( * qglGetTexEnviv )(GLenum target, GLenum pname, GLint *params);
+extern  void ( * qglGetTexGendv )(GLenum coord, GLenum pname, GLdouble *params);
+extern  void ( * qglGetTexGenfv )(GLenum coord, GLenum pname, GLfloat *params);
+extern  void ( * qglGetTexGeniv )(GLenum coord, GLenum pname, GLint *params);
+extern  void ( * qglGetTexImage )(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels);
+extern  void ( * qglGetTexLevelParameterfv )(GLenum target, GLint level, GLenum pname, GLfloat *params);
+extern  void ( * qglGetTexLevelParameteriv )(GLenum target, GLint level, GLenum pname, GLint *params);
+extern  void ( * qglGetTexParameterfv )(GLenum target, GLenum pname, GLfloat *params);
+extern  void ( * qglGetTexParameteriv )(GLenum target, GLenum pname, GLint *params);
+extern  void ( * qglHint )(GLenum target, GLenum mode);
+extern  void ( * qglIndexedTriToStrip )(GLsizei count, const GLushort *indices);
+extern  void ( * qglIndexMask )(GLuint mask);
+extern  void ( * qglIndexPointer )(GLenum type, GLsizei stride, const GLvoid *pointer);
+extern  void ( * qglIndexd )(GLdouble c);
+extern  void ( * qglIndexdv )(const GLdouble *c);
+extern  void ( * qglIndexf )(GLfloat c);
+extern  void ( * qglIndexfv )(const GLfloat *c);
+extern  void ( * qglIndexi )(GLint c);
+extern  void ( * qglIndexiv )(const GLint *c);
+extern  void ( * qglIndexs )(GLshort c);
+extern  void ( * qglIndexsv )(const GLshort *c);
+extern  void ( * qglIndexub )(GLubyte c);
+extern  void ( * qglIndexubv )(const GLubyte *c);
+extern  void ( * qglInitNames )(void);
+extern  void ( * qglInterleavedArrays )(GLenum format, GLsizei stride, const GLvoid *pointer);
+extern  GLboolean ( * qglIsEnabled )(GLenum cap);
+extern  GLboolean ( * qglIsList )(GLuint listArg);
+extern  GLboolean ( * qglIsTexture )(GLuint texture);
+extern  void ( * qglLightModelf )(GLenum pname, GLfloat param);
+extern  void ( * qglLightModelfv )(GLenum pname, const GLfloat *params);
+extern  void ( * qglLightModeli )(GLenum pname, GLint param);
+extern  void ( * qglLightModeliv )(GLenum pname, const GLint *params);
+extern  void ( * qglLightf )(GLenum light, GLenum pname, GLfloat param);
+extern  void ( * qglLightfv )(GLenum light, GLenum pname, const GLfloat *params);
+extern  void ( * qglLighti )(GLenum light, GLenum pname, GLint param);
+extern  void ( * qglLightiv )(GLenum light, GLenum pname, const GLint *params);
+extern  void ( * qglLineStipple )(GLint factor, GLushort pattern);
+extern  void ( * qglLineWidth )(GLfloat width);
+extern  void ( * qglListBase )(GLuint base);
+extern  void ( * qglLoadIdentity )(void);
+extern  void ( * qglLoadMatrixd )(const GLdouble *m);
+extern  void ( * qglLoadMatrixf )(const GLfloat *m);
+extern  void ( * qglLoadName )(GLuint name);
+extern  void ( * qglLogicOp )(GLenum opcode);
+extern  void ( * qglMap1d )(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points);
+extern  void ( * qglMap1f )(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points);
+extern  void ( * qglMap2d )(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points);
+extern  void ( * qglMap2f )(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points);
+extern  void ( * qglMapGrid1d )(GLint un, GLdouble u1, GLdouble u2);
+extern  void ( * qglMapGrid1f )(GLint un, GLfloat u1, GLfloat u2);
+extern  void ( * qglMapGrid2d )(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2);
+extern  void ( * qglMapGrid2f )(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2);
+extern  void ( * qglMaterialf )(GLenum face, GLenum pname, GLfloat param);
+extern  void ( * qglMaterialfv )(GLenum face, GLenum pname, const GLfloat *params);
+extern  void ( * qglMateriali )(GLenum face, GLenum pname, GLint param);
+extern  void ( * qglMaterialiv )(GLenum face, GLenum pname, const GLint *params);
+extern  void ( * qglMatrixMode )(GLenum mode);
+extern  void ( * qglMultMatrixd )(const GLdouble *m);
+extern  void ( * qglMultMatrixf )(const GLfloat *m);
+extern  void ( * qglNewList )(GLuint list, GLenum mode);
+extern  void ( * qglNormal3b )(GLbyte nx, GLbyte ny, GLbyte nz);
+extern  void ( * qglNormal3bv )(const GLbyte *v);
+extern  void ( * qglNormal3d )(GLdouble nx, GLdouble ny, GLdouble nz);
+extern  void ( * qglNormal3dv )(const GLdouble *v);
+extern  void ( * qglNormal3f )(GLfloat nx, GLfloat ny, GLfloat nz);
+extern  void ( * qglNormal3fv )(const GLfloat *v);
+extern  void ( * qglNormal3i )(GLint nx, GLint ny, GLint nz);
+extern  void ( * qglNormal3iv )(const GLint *v);
+extern  void ( * qglNormal3s )(GLshort nx, GLshort ny, GLshort nz);
+extern  void ( * qglNormal3sv )(const GLshort *v);
+extern  void ( * qglNormalPointer )(GLenum type, GLsizei stride, const GLvoid *pointer);
+extern  void ( * qglOrtho )(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
+extern  void ( * qglPassThrough )(GLfloat token);
+extern  void ( * qglPixelMapfv )(GLenum map, GLsizei mapsize, const GLfloat *values);
+extern  void ( * qglPixelMapuiv )(GLenum map, GLsizei mapsize, const GLuint *values);
+extern  void ( * qglPixelMapusv )(GLenum map, GLsizei mapsize, const GLushort *values);
+extern  void ( * qglPixelStoref )(GLenum pname, GLfloat param);
+extern  void ( * qglPixelStorei )(GLenum pname, GLint param);
+extern  void ( * qglPixelTransferf )(GLenum pname, GLfloat param);
+extern  void ( * qglPixelTransferi )(GLenum pname, GLint param);
+extern  void ( * qglPixelZoom )(GLfloat xfactor, GLfloat yfactor);
+extern  void ( * qglPointSize )(GLfloat size);
+extern  void ( * qglPolygonMode )(GLenum face, GLenum mode);
+extern  void ( * qglPolygonOffset )(GLfloat factor, GLfloat units);
+extern  void ( * qglPolygonStipple )(const GLubyte *mask);
+extern  void ( * qglPopAttrib )(void);
+extern  void ( * qglPopClientAttrib )(void);
+extern  void ( * qglPopMatrix )(void);
+extern  void ( * qglPopName )(void);
+extern  void ( * qglPrioritizeTextures )(GLsizei n, const GLuint *textures, const GLclampf *priorities);
+extern  void ( * qglPushAttrib )(GLbitfield mask);
+extern  void ( * qglPushClientAttrib )(GLbitfield mask);
+extern  void ( * qglPushMatrix )(void);
+extern  void ( * qglPushName )(GLuint name);
+extern  void ( * qglRasterPos2d )(GLdouble x, GLdouble y);
+extern  void ( * qglRasterPos2dv )(const GLdouble *v);
+extern  void ( * qglRasterPos2f )(GLfloat x, GLfloat y);
+extern  void ( * qglRasterPos2fv )(const GLfloat *v);
+extern  void ( * qglRasterPos2i )(GLint x, GLint y);
+extern  void ( * qglRasterPos2iv )(const GLint *v);
+extern  void ( * qglRasterPos2s )(GLshort x, GLshort y);
+extern  void ( * qglRasterPos2sv )(const GLshort *v);
+extern  void ( * qglRasterPos3d )(GLdouble x, GLdouble y, GLdouble z);
+extern  void ( * qglRasterPos3dv )(const GLdouble *v);
+extern  void ( * qglRasterPos3f )(GLfloat x, GLfloat y, GLfloat z);
+extern  void ( * qglRasterPos3fv )(const GLfloat *v);
+extern  void ( * qglRasterPos3i )(GLint x, GLint y, GLint z);
+extern  void ( * qglRasterPos3iv )(const GLint *v);
+extern  void ( * qglRasterPos3s )(GLshort x, GLshort y, GLshort z);
+extern  void ( * qglRasterPos3sv )(const GLshort *v);
+extern  void ( * qglRasterPos4d )(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+extern  void ( * qglRasterPos4dv )(const GLdouble *v);
+extern  void ( * qglRasterPos4f )(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+extern  void ( * qglRasterPos4fv )(const GLfloat *v);
+extern  void ( * qglRasterPos4i )(GLint x, GLint y, GLint z, GLint w);
+extern  void ( * qglRasterPos4iv )(const GLint *v);
+extern  void ( * qglRasterPos4s )(GLshort x, GLshort y, GLshort z, GLshort w);
+extern  void ( * qglRasterPos4sv )(const GLshort *v);
+extern  void ( * qglReadBuffer )(GLenum mode);
+//extern  void ( * qglReadPixels )(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei twidth, GLsizei theight, GLvoid *pixels);
+extern  void ( * qglReadPixels )(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels);
+extern	void ( * qglCopyBackBufferToTexEXT ) (float width, float height, float u1, float v1, float u2, float v2);
+extern	void ( * qglCopyBackBufferToTex ) (void);
+extern  void ( * qglRectd )(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2);
+extern  void ( * qglRectdv )(const GLdouble *v1, const GLdouble *v2);
+extern  void ( * qglRectf )(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2);
+extern  void ( * qglRectfv )(const GLfloat *v1, const GLfloat *v2);
+extern  void ( * qglRecti )(GLint x1, GLint y1, GLint x2, GLint y2);
+extern  void ( * qglRectiv )(const GLint *v1, const GLint *v2);
+extern  void ( * qglRects )(GLshort x1, GLshort y1, GLshort x2, GLshort y2);
+extern  void ( * qglRectsv )(const GLshort *v1, const GLshort *v2);
+extern  GLint ( * qglRenderMode )(GLenum mode);
+extern  void ( * qglRotated )(GLdouble angle, GLdouble x, GLdouble y, GLdouble z);
+extern  void ( * qglRotatef )(GLfloat angle, GLfloat x, GLfloat y, GLfloat z);
+extern  void ( * qglScaled )(GLdouble x, GLdouble y, GLdouble z);
+extern  void ( * qglScalef )(GLfloat x, GLfloat y, GLfloat z);
+extern  void ( * qglScissor )(GLint x, GLint y, GLsizei width, GLsizei height);
+extern  void ( * qglSelectBuffer )(GLsizei size, GLuint *buffer);
+extern  void ( * qglShadeModel )(GLenum mode);
+extern  void ( * qglStencilFunc )(GLenum func, GLint ref, GLuint mask);
+extern  void ( * qglStencilMask )(GLuint mask);
+extern  void ( * qglStencilOp )(GLenum fail, GLenum zfail, GLenum zpass);
+extern  void ( * qglTexCoord1d )(GLdouble s);
+extern  void ( * qglTexCoord1dv )(const GLdouble *v);
+extern  void ( * qglTexCoord1f )(GLfloat s);
+extern  void ( * qglTexCoord1fv )(const GLfloat *v);
+extern  void ( * qglTexCoord1i )(GLint s);
+extern  void ( * qglTexCoord1iv )(const GLint *v);
+extern  void ( * qglTexCoord1s )(GLshort s);
+extern  void ( * qglTexCoord1sv )(const GLshort *v);
+extern  void ( * qglTexCoord2d )(GLdouble s, GLdouble t);
+extern  void ( * qglTexCoord2dv )(const GLdouble *v);
+extern  void ( * qglTexCoord2f )(GLfloat s, GLfloat t);
+extern  void ( * qglTexCoord2fv )(const GLfloat *v);
+extern  void ( * qglTexCoord2i )(GLint s, GLint t);
+extern  void ( * qglTexCoord2iv )(const GLint *v);
+extern  void ( * qglTexCoord2s )(GLshort s, GLshort t);
+extern  void ( * qglTexCoord2sv )(const GLshort *v);
+extern  void ( * qglTexCoord3d )(GLdouble s, GLdouble t, GLdouble r);
+extern  void ( * qglTexCoord3dv )(const GLdouble *v);
+extern  void ( * qglTexCoord3f )(GLfloat s, GLfloat t, GLfloat r);
+extern  void ( * qglTexCoord3fv )(const GLfloat *v);
+extern  void ( * qglTexCoord3i )(GLint s, GLint t, GLint r);
+extern  void ( * qglTexCoord3iv )(const GLint *v);
+extern  void ( * qglTexCoord3s )(GLshort s, GLshort t, GLshort r);
+extern  void ( * qglTexCoord3sv )(const GLshort *v);
+extern  void ( * qglTexCoord4d )(GLdouble s, GLdouble t, GLdouble r, GLdouble q);
+extern  void ( * qglTexCoord4dv )(const GLdouble *v);
+extern  void ( * qglTexCoord4f )(GLfloat s, GLfloat t, GLfloat r, GLfloat q);
+extern  void ( * qglTexCoord4fv )(const GLfloat *v);
+extern  void ( * qglTexCoord4i )(GLint s, GLint t, GLint r, GLint q);
+extern  void ( * qglTexCoord4iv )(const GLint *v);
+extern  void ( * qglTexCoord4s )(GLshort s, GLshort t, GLshort r, GLshort q);
+extern  void ( * qglTexCoord4sv )(const GLshort *v);
+extern  void ( * qglTexCoordPointer )(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
+extern  void ( * qglTexEnvf )(GLenum target, GLenum pname, GLfloat param);
+extern  void ( * qglTexEnvfv )(GLenum target, GLenum pname, const GLfloat *params);
+extern  void ( * qglTexEnvi )(GLenum target, GLenum pname, GLint param);
+extern  void ( * qglTexEnviv )(GLenum target, GLenum pname, const GLint *params);
+extern  void ( * qglTexGend )(GLenum coord, GLenum pname, GLdouble param);
+extern  void ( * qglTexGendv )(GLenum coord, GLenum pname, const GLdouble *params);
+extern  void ( * qglTexGenf )(GLenum coord, GLenum pname, GLfloat param);
+extern  void ( * qglTexGenfv )(GLenum coord, GLenum pname, const GLfloat *params);
+extern  void ( * qglTexGeni )(GLenum coord, GLenum pname, GLint param);
+extern  void ( * qglTexGeniv )(GLenum coord, GLenum pname, const GLint *params);
+extern  void ( * qglTexImage1D )(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
+extern  void ( * qglTexImage2D )(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
+extern  void ( * qglTexImage2DEXT )(GLenum target, GLint level, GLint numlevels, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
+extern  void ( * qglTexParameterf )(GLenum target, GLenum pname, GLfloat param);
+extern  void ( * qglTexParameterfv )(GLenum target, GLenum pname, const GLfloat *params);
+extern  void ( * qglTexParameteri )(GLenum target, GLenum pname, GLint param);
+extern  void ( * qglTexParameteriv )(GLenum target, GLenum pname, const GLint *params);
+extern  void ( * qglTexSubImage1D )(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels);
+extern  void ( * qglTexSubImage2D )(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
+extern  void ( * qglTranslated )(GLdouble x, GLdouble y, GLdouble z);
+extern  void ( * qglTranslatef )(GLfloat x, GLfloat y, GLfloat z);
+extern  void ( * qglVertex2d )(GLdouble x, GLdouble y);
+extern  void ( * qglVertex2dv )(const GLdouble *v);
+extern  void ( * qglVertex2f )(GLfloat x, GLfloat y);
+extern  void ( * qglVertex2fv )(const GLfloat *v);
+extern  void ( * qglVertex2i )(GLint x, GLint y);
+extern  void ( * qglVertex2iv )(const GLint *v);
+extern  void ( * qglVertex2s )(GLshort x, GLshort y);
+extern  void ( * qglVertex2sv )(const GLshort *v);
+extern  void ( * qglVertex3d )(GLdouble x, GLdouble y, GLdouble z);
+extern  void ( * qglVertex3dv )(const GLdouble *v);
+extern  void ( * qglVertex3f )(GLfloat x, GLfloat y, GLfloat z);
+extern  void ( * qglVertex3fv )(const GLfloat *v);
+extern  void ( * qglVertex3i )(GLint x, GLint y, GLint z);
+extern  void ( * qglVertex3iv )(const GLint *v);
+extern  void ( * qglVertex3s )(GLshort x, GLshort y, GLshort z);
+extern  void ( * qglVertex3sv )(const GLshort *v);
+extern  void ( * qglVertex4d )(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+extern  void ( * qglVertex4dv )(const GLdouble *v);
+extern  void ( * qglVertex4f )(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+extern  void ( * qglVertex4fv )(const GLfloat *v);
+extern  void ( * qglVertex4i )(GLint x, GLint y, GLint z, GLint w);
+extern  void ( * qglVertex4iv )(const GLint *v);
+extern  void ( * qglVertex4s )(GLshort x, GLshort y, GLshort z, GLshort w);
+extern  void ( * qglVertex4sv )(const GLshort *v);
+extern  void ( * qglVertexPointer )(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
+extern  void ( * qglViewport )(GLint x, GLint y, GLsizei width, GLsizei height);
+
+#endif
diff --git a/code/renderer/qgl_linked.h b/code/renderer/qgl_linked.h
new file mode 100644
index 0000000..cf48a7c
--- /dev/null
+++ b/code/renderer/qgl_linked.h
@@ -0,0 +1,336 @@
+
+#define qglAccum glAccum
+#define qglAlphaFunc glAlphaFunc
+#define qglAreTexturesResident glAreTexturesResident
+#define qglArrayElement glArrayElement
+#define qglBegin glBegin
+#define qglBindTexture glBindTexture
+#define qglBitmap glBitmap
+#define qglBlendFunc glBlendFunc
+#define qglCallList glCallList
+#define qglCallLists glCallLists
+#define qglClear glClear
+#define qglClearAccum glClearAccum
+#define qglClearColor glClearColor
+#define qglClearDepth glClearDepth
+#define qglClearIndex glClearIndex
+#define qglClearStencil glClearStencil
+#define qglClipPlane glClipPlane
+#define qglColor3b glColor3b
+#define qglColor3bv glColor3bv
+#define qglColor3d glColor3d
+#define qglColor3dv glColor3dv
+#define qglColor3f glColor3f
+#define qglColor3fv glColor3fv
+#define qglColor3i glColor3i
+#define qglColor3iv glColor3iv
+#define qglColor3s glColor3s
+#define qglColor3sv glColor3sv
+#define qglColor3ub glColor3ub
+#define qglColor3ubv glColor3ubv
+#define qglColor3ui glColor3ui
+#define qglColor3uiv glColor3uiv
+#define qglColor3us glColor3us
+#define qglColor3usv glColor3usv
+#define qglColor4b glColor4b
+#define qglColor4bv glColor4bv
+#define qglColor4d glColor4d
+#define qglColor4dv glColor4dv
+#define qglColor4f glColor4f
+#define qglColor4fv glColor4fv
+#define qglColor4i glColor4i
+#define qglColor4iv glColor4iv
+#define qglColor4s glColor4s
+#define qglColor4sv glColor4sv
+#define qglColor4ub glColor4ub
+#define qglColor4ubv glColor4ubv
+#define qglColor4ui glColor4ui
+#define qglColor4uiv glColor4uiv
+#define qglColor4us glColor4us
+#define qglColor4usv glColor4usv
+#define qglColorMask glColorMask
+#define qglColorMaterial glColorMaterial
+#define qglColorPointer glColorPointer
+#define qglCopyPixels glCopyPixels
+#define qglCopyTexImage1D glCopyTexImage1D
+#define qglCopyTexImage2D glCopyTexImage2D
+#define qglCopyTexSubImage1D glCopyTexSubImage1D
+#define qglCopyTexSubImage2D glCopyTexSubImage2D
+#define qglCullFace glCullFace
+#define qglDeleteLists glDeleteLists
+#define qglDeleteTextures glDeleteTextures
+#define qglDepthFunc glDepthFunc
+#define qglDepthMask glDepthMask
+#define qglDepthRange glDepthRange
+#define qglDisable glDisable
+#define qglDisableClientState glDisableClientState
+#define qglDrawArrays glDrawArrays
+#define qglDrawBuffer glDrawBuffer
+#define qglDrawElements glDrawElements
+#define qglDrawPixels glDrawPixels
+#define qglEdgeFlag glEdgeFlag
+#define qglEdgeFlagPointer glEdgeFlagPointer
+#define qglEdgeFlagv glEdgeFlagv
+#define qglEnable glEnable
+#define qglEnableClientState glEnableClientState
+#define qglEnd glEnd
+#define qglEndList glEndList
+#define qglEvalCoord1d glEvalCoord1d
+#define qglEvalCoord1dv glEvalCoord1dv
+#define qglEvalCoord1f glEvalCoord1f
+#define qglEvalCoord1fv glEvalCoord1fv
+#define qglEvalCoord2d glEvalCoord2d
+#define qglEvalCoord2dv glEvalCoord2dv
+#define qglEvalCoord2f glEvalCoord2f
+#define qglEvalCoord2fv glEvalCoord2fv
+#define qglEvalMesh1 glEvalMesh1
+#define qglEvalMesh2 glEvalMesh2
+#define qglEvalPoint1 glEvalPoint1
+#define qglEvalPoint2 glEvalPoint2
+#define qglFeedbackBuffer glFeedbackBuffer
+#define qglFinish glFinish
+#define qglFlush glFlush
+#define qglFogf glFogf
+#define qglFogfv glFogfv
+#define qglFogi glFogi
+#define qglFogiv glFogiv
+#define qglFrontFace glFrontFace
+#define qglFrustum glFrustum
+#define qglGenLists glGenLists
+#define qglGenTextures glGenTextures
+#define qglGetBooleanv glGetBooleanv
+#define qglGetClipPlane glGetClipPlane
+#define qglGetDoublev glGetDoublev
+#define qglGetError glGetError
+#define qglGetFloatv glGetFloatv
+#define qglGetIntegerv glGetIntegerv
+#define qglGetLightfv glGetLightfv
+#define qglGetLightiv glGetLightiv
+#define qglGetMapdv glGetMapdv
+#define qglGetMapfv glGetMapfv
+#define qglGetMapiv glGetMapiv
+#define qglGetMaterialfv glGetMaterialfv
+#define qglGetMaterialiv glGetMaterialiv
+#define qglGetPixelMapfv glGetPixelMapfv
+#define qglGetPixelMapuiv glGetPixelMapuiv
+#define qglGetPixelMapusv glGetPixelMapusv
+#define qglGetPointerv glGetPointerv
+#define qglGetPolygonStipple glGetPolygonStipple
+#define qglGetString glGetString
+#define qglGetTexGendv glGetTexGendv
+#define qglGetTexGenfv glGetTexGenfv
+#define qglGetTexGeniv glGetTexGeniv
+#define qglGetTexImage glGetTexImage
+#define qglGetTexLevelParameterfv glGetTexLevelParameterfv
+#define qglGetTexLevelParameteriv glGetTexLevelParameteriv
+#define qglGetTexParameterfv glGetTexParameterfv
+#define qglGetTexParameteriv glGetTexParameteriv
+#define qglHint glHint
+#define qglIndexMask glIndexMask
+#define qglIndexPointer glIndexPointer
+#define qglIndexd glIndexd
+#define qglIndexdv glIndexdv
+#define qglIndexf glIndexf
+#define qglIndexfv glIndexfv
+#define qglIndexi glIndexi
+#define qglIndexiv glIndexiv
+#define qglIndexs glIndexs
+#define qglIndexsv glIndexsv
+#define qglIndexub glIndexub
+#define qglIndexubv glIndexubv
+#define qglInitNames glInitNames
+#define qglInterleavedArrays glInterleavedArrays
+#define qglIsEnabled glIsEnabled
+#define qglIsList glIsList
+#define qglIsTexture glIsTexture
+#define qglLightModelf glLightModelf
+#define qglLightModelfv glLightModelfv
+#define qglLightModeli glLightModeli
+#define qglLightModeliv glLightModeliv
+#define qglLightf glLightf
+#define qglLightfv glLightfv
+#define qglLighti glLighti
+#define qglLightiv glLightiv
+#define qglLineStipple glLineStipple
+#define qglLineWidth glLineWidth
+#define qglListBase glListBase
+#define qglLoadIdentity glLoadIdentity
+#define qglLoadMatrixd glLoadMatrixd
+#define qglLoadMatrixf glLoadMatrixf
+#define qglLoadName glLoadName
+#define qglLogicOp glLogicOp
+#define qglMap1d glMap1d
+#define qglMap1f glMap1f
+#define qglMap2d glMap2d
+#define qglMap2f glMap2f
+#define qglMapGrid1d glMapGrid1d
+#define qglMapGrid1f glMapGrid1f
+#define qglMapGrid2d glMapGrid2d
+#define qglMapGrid2f glMapGrid2f
+#define qglMaterialf glMaterialf
+#define qglMaterialfv glMaterialfv
+#define qglMateriali glMateriali
+#define qglMaterialiv glMaterialiv
+#define qglMatrixMode glMatrixMode
+#define qglMultMatrixd glMultMatrixd
+#define qglMultMatrixf glMultMatrixf
+#define qglNewList glNewList
+#define qglNormal3b glNormal3b
+#define qglNormal3bv glNormal3bv
+#define qglNormal3d glNormal3d
+#define qglNormal3dv glNormal3dv
+#define qglNormal3f glNormal3f
+#define qglNormal3fv glNormal3fv
+#define qglNormal3i glNormal3i
+#define qglNormal3iv glNormal3iv
+#define qglNormal3s glNormal3s
+#define qglNormal3sv glNormal3sv
+#define qglNormalPointer glNormalPointer
+#define qglOrtho glOrtho
+#define qglPassThrough glPassThrough
+#define qglPixelMapfv glPixelMapfv
+#define qglPixelMapuiv glPixelMapuiv
+#define qglPixelMapusv glPixelMapusv
+#define qglPixelStoref glPixelStoref
+#define qglPixelStorei glPixelStorei
+#define qglPixelTransferf glPixelTransferf
+#define qglPixelTransferi glPixelTransferi
+#define qglPixelZoom glPixelZoom
+#define qglPointSize glPointSize
+#define qglPolygonMode glPolygonMode
+#define qglPolygonOffset glPolygonOffset
+#define qglPolygonStipple glPolygonStipple
+#define qglPopAttrib glPopAttrib
+#define qglPopClientAttrib glPopClientAttrib
+#define qglPopMatrix glPopMatrix
+#define qglPopName glPopName
+#define qglPrioritizeTextures glPrioritizeTextures
+#define qglPushAttrib glPushAttrib
+#define qglPushClientAttrib glPushClientAttrib
+#define qglPushMatrix glPushMatrix
+#define qglPushName glPushName
+#define qglRasterPos2d glRasterPos2d
+#define qglRasterPos2dv glRasterPos2dv
+#define qglRasterPos2f glRasterPos2f
+#define qglRasterPos2fv glRasterPos2fv
+#define qglRasterPos2i glRasterPos2i
+#define qglRasterPos2iv glRasterPos2iv
+#define qglRasterPos2s glRasterPos2s
+#define qglRasterPos2sv glRasterPos2sv
+#define qglRasterPos3d glRasterPos3d
+#define qglRasterPos3dv glRasterPos3dv
+#define qglRasterPos3f glRasterPos3f
+#define qglRasterPos3fv glRasterPos3fv
+#define qglRasterPos3i glRasterPos3i
+#define qglRasterPos3iv glRasterPos3iv
+#define qglRasterPos3s glRasterPos3s
+#define qglRasterPos3sv glRasterPos3sv
+#define qglRasterPos4d glRasterPos4d
+#define qglRasterPos4dv glRasterPos4dv
+#define qglRasterPos4f glRasterPos4f
+#define qglRasterPos4fv glRasterPos4fv
+#define qglRasterPos4i glRasterPos4i
+#define qglRasterPos4iv glRasterPos4iv
+#define qglRasterPos4s glRasterPos4s
+#define qglRasterPos4sv glRasterPos4sv
+#define qglReadBuffer glReadBuffer
+#define qglReadPixels glReadPixels
+#define qglRectd glRectd
+#define qglRectdv glRectdv
+#define qglRectf glRectf
+#define qglRectfv glRectfv
+#define qglRecti glRecti
+#define qglRectiv glRectiv
+#define qglRects glRects
+#define qglRectsv glRectsv
+#define qglRenderMode glRenderMode
+#define qglRotated glRotated
+#define qglRotatef glRotatef
+#define qglScaled glScaled
+#define qglScalef glScalef
+#define qglScissor glScissor
+#define qglSelectBuffer glSelectBuffer
+#define qglShadeModel glShadeModel
+#define qglStencilFunc glStencilFunc
+#define qglStencilMask glStencilMask
+#define qglStencilOp glStencilOp
+#define qglTexCoord1d glTexCoord1d
+#define qglTexCoord1dv glTexCoord1dv
+#define qglTexCoord1f glTexCoord1f
+#define qglTexCoord1fv glTexCoord1fv
+#define qglTexCoord1i glTexCoord1i
+#define qglTexCoord1iv glTexCoord1iv
+#define qglTexCoord1s glTexCoord1s
+#define qglTexCoord1sv glTexCoord1sv
+#define qglTexCoord2d glTexCoord2d
+#define qglTexCoord2dv glTexCoord2dv
+#define qglTexCoord2f glTexCoord2f
+#define qglTexCoord2fv glTexCoord2fv
+#define qglTexCoord2i glTexCoord2i
+#define qglTexCoord2iv glTexCoord2iv
+#define qglTexCoord2s glTexCoord2s
+#define qglTexCoord2sv glTexCoord2sv
+#define qglTexCoord3d glTexCoord3d
+#define qglTexCoord3dv glTexCoord3dv
+#define qglTexCoord3f glTexCoord3f
+#define qglTexCoord3fv glTexCoord3fv
+#define qglTexCoord3i glTexCoord3i
+#define qglTexCoord3iv glTexCoord3iv
+#define qglTexCoord3s glTexCoord3s
+#define qglTexCoord3sv glTexCoord3sv
+#define qglTexCoord4d glTexCoord4d
+#define qglTexCoord4dv glTexCoord4dv
+#define qglTexCoord4f glTexCoord4f
+#define qglTexCoord4fv glTexCoord4fv
+#define qglTexCoord4i glTexCoord4i
+#define qglTexCoord4iv glTexCoord4iv
+#define qglTexCoord4s glTexCoord4s
+#define qglTexCoord4sv glTexCoord4sv
+#define qglTexCoordPointer glTexCoordPointer
+#define	qglTexEnvf glTexEnvf
+#define	qglTexEnvfv glTexEnvfv
+#define	qglTexEnvi glTexEnvi
+#define	qglTexEnviv glTexEnviv
+#define qglTexGend glTexGend
+#define qglTexGendv glTexGendv
+#define qglTexGenf glTexGenf
+#define qglTexGenfv glTexGenfv
+#define qglTexGeni glTexGeni
+#define qglTexGeniv glTexGeniv
+#define qglTexImage1D glTexImage1D
+#define qglTexImage2D glTexImage2D
+#define qglTexParameterf glTexParameterf
+#define qglTexParameterfv glTexParameterfv
+#define qglTexParameteri glTexParameteri
+#define qglTexParameteriv glTexParameteriv
+#define qglTexSubImage1D glTexSubImage1D
+#define qglTexSubImage2D glTexSubImage2D
+#define qglTranslated glTranslated
+#define qglTranslatef glTranslatef
+#define qglVertex2d glVertex2d
+#define qglVertex2dv glVertex2dv
+#define qglVertex2f glVertex2f
+#define qglVertex2fv glVertex2fv
+#define qglVertex2i glVertex2i
+#define qglVertex2iv glVertex2iv
+#define qglVertex2s glVertex2s
+#define qglVertex2sv glVertex2sv
+#define qglVertex3d glVertex3d
+#define qglVertex3dv glVertex3dv
+#define qglVertex3f glVertex3f
+#define qglVertex3fv glVertex3fv
+#define qglVertex3i glVertex3i
+#define qglVertex3iv glVertex3iv
+#define qglVertex3s glVertex3s
+#define qglVertex3sv glVertex3sv
+#define qglVertex4d glVertex4d
+#define qglVertex4dv glVertex4dv
+#define qglVertex4f glVertex4f
+#define qglVertex4fv glVertex4fv
+#define qglVertex4i glVertex4i
+#define qglVertex4iv glVertex4iv
+#define qglVertex4s glVertex4s
+#define qglVertex4sv glVertex4sv
+#define qglVertexPointer glVertexPointer
+#define qglViewport glViewport
+
diff --git a/code/renderer/ref_trin.def b/code/renderer/ref_trin.def
new file mode 100644
index 0000000..2fefbd3
--- /dev/null
+++ b/code/renderer/ref_trin.def
@@ -0,0 +1,2 @@
+EXPORTS
+	GetRefAPI
diff --git a/code/renderer/tr_WorldEffects.cpp b/code/renderer/tr_WorldEffects.cpp
new file mode 100644
index 0000000..b693a6c
--- /dev/null
+++ b/code/renderer/tr_WorldEffects.cpp
@@ -0,0 +1,2283 @@
+////////////////////////////////////////////////////////////////////////////////////////
+// RAVEN SOFTWARE - STAR WARS: JK II
+//  (c) 2002 Activision
+//
+// World Effects
+//
+//
+////////////////////////////////////////////////////////////////////////////////////////
+#include "../server/exe_headers.h"
+#pragma warning( disable : 4512 )
+
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Externs & Fwd Decl.
+////////////////////////////////////////////////////////////////////////////////////////
+extern qboolean		ParseVector( const char **text, int count, float *v );
+extern void			SetViewportAndScissor( void );
+
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Includes
+////////////////////////////////////////////////////////////////////////////////////////
+#include "tr_local.h"
+#include "tr_WorldEffects.h"
+#include "../Ravl/CVec.h"
+#include "../Ratl/vector_vs.h"
+#include "../Ratl/bits_vs.h"
+
+#ifdef _XBOX
+#include "../win32/glw_win_dx8.h"
+#endif
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Defines
+////////////////////////////////////////////////////////////////////////////////////////
+#define GLS_ALPHA				(GLS_SRCBLEND_SRC_ALPHA | GLS_DSTBLEND_ONE_MINUS_SRC_ALPHA)
+#define	MAX_WIND_ZONES			12
+#define MAX_WEATHER_ZONES		50	// so we can more zones that are smaller
+#define	MAX_PUFF_SYSTEMS		2
+#define	MAX_PARTICLE_CLOUDS		5
+
+#ifdef _XBOX
+#define POINTCACHE_CELL_SIZE	32.0f		
+
+// Note to Vv:
+// you guys may want to look into lowering that number.  I've optimized the storage
+// space by breaking it up into small boxes (weather zones) around the areas we care about
+// in order to speed up load time and reduce memory.  A very high number here will mean
+// that weather related effects like rain, fog, snow, etc will bleed through to where
+// they shouldn't...
+
+#else
+#define POINTCACHE_CELL_SIZE	32.0f
+#endif
+
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Globals
+////////////////////////////////////////////////////////////////////////////////////////
+float		mMillisecondsElapsed = 0;
+float		mSecondsElapsed = 0;
+bool		mFrozen = false;
+
+CVec3		mGlobalWindVelocity;
+CVec3		mGlobalWindDirection;
+float		mGlobalWindSpeed;
+int			mParticlesRendered;
+
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Handy Functions
+////////////////////////////////////////////////////////////////////////////////////////
+inline void		VectorMA( vec3_t vecAdd, const float scale, const vec3_t vecScale)
+{
+	vecAdd[0] += (scale * vecScale[0]);
+	vecAdd[1] += (scale * vecScale[1]);
+	vecAdd[2] += (scale * vecScale[2]);
+}
+
+inline void VectorFloor(vec3_t in)
+{
+	in[0] = floorf(in[0]);
+	in[1] = floorf(in[1]);
+	in[2] = floorf(in[2]);
+}
+
+inline void VectorCeil(vec3_t in)
+{
+	in[0] = ceilf(in[0]);
+	in[1] = ceilf(in[1]);
+	in[2] = ceilf(in[2]);
+}
+
+inline float	FloatRand(void) 
+{ 
+	return ((float)rand() / (float)RAND_MAX);
+}
+
+inline float	fast_flrand(float min, float max)
+{
+	//return min + (max - min) * flrand;
+	return Q_flrand(min, max); //fixme?
+}
+
+inline	void	SnapFloatToGrid(float& f, int GridSize)
+{
+	f = (int)(f);
+
+	bool	fNeg		= (f<0);
+	if (fNeg)
+	{
+		f *= -1;		// Temporarly make it positive
+	}
+
+	int		Offset		= ((int)(f) % (int)(GridSize));
+	int		OffsetAbs	= abs(Offset);
+	if (OffsetAbs>(GridSize/2))
+	{
+		Offset = (GridSize - OffsetAbs) * -1;
+	}
+
+	f -= Offset;
+
+	if (fNeg)
+	{
+		f *= -1;		// Put It Back To Negative
+	}
+
+	f = (int)(f);
+
+	assert(((int)(f)%(int)(GridSize)) == 0);
+}
+
+inline	void	SnapVectorToGrid(CVec3& Vec, int GridSize)
+{
+	SnapFloatToGrid(Vec[0], GridSize);
+	SnapFloatToGrid(Vec[1], GridSize);
+	SnapFloatToGrid(Vec[2], GridSize);
+}
+
+
+
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Range Structures
+////////////////////////////////////////////////////////////////////////////////////////
+struct	SVecRange
+{
+	CVec3	mMins;
+	CVec3	mMaxs;
+
+	inline void	Clear()
+	{
+		mMins.Clear();
+		mMaxs.Clear();
+	}
+
+	inline void Pick(CVec3& V)
+	{
+		V[0] = Q_flrand(mMins[0], mMaxs[0]); 
+		V[1] = Q_flrand(mMins[1], mMaxs[1]); 
+		V[2] = Q_flrand(mMins[2], mMaxs[2]); 
+	}
+	inline void Wrap(CVec3& V)
+	{
+		if (V[0]<=mMins[0])
+		{
+			if ((mMins[0]-V[0])>500)
+			{
+				Pick(V);
+				return;
+			}
+			V[0] = mMaxs[0] - 10.0f;
+		}
+		if (V[0]>=mMaxs[0])
+		{
+			if ((V[0]-mMaxs[0])>500)
+			{
+				Pick(V);
+				return;
+			}
+			V[0] = mMins[0] + 10.0f;
+		}
+
+		if (V[1]<=mMins[1])
+		{
+			if ((mMins[1]-V[1])>500)
+			{
+				Pick(V);
+				return;
+			}
+			V[1] = mMaxs[1] - 10.0f;
+		}
+		if (V[1]>=mMaxs[1])
+		{
+			if ((V[1]-mMaxs[1])>500)
+			{
+				Pick(V);
+				return;
+			}
+			V[1] = mMins[1] + 10.0f;
+		}
+
+		if (V[2]<=mMins[2])
+		{
+			if ((mMins[2]-V[2])>500)
+			{
+				Pick(V);
+				return;
+			}
+			V[2] = mMaxs[2] - 10.0f;
+		}
+		if (V[2]>=mMaxs[2])
+		{
+			if ((V[2]-mMaxs[2])>500)
+			{
+				Pick(V);
+				return;
+			}
+			V[2] = mMins[2] + 10.0f;
+		}
+	}
+
+	inline bool In(const CVec3& V)
+	{
+		return (V>mMins && V<mMaxs);
+	}
+};
+
+struct	SFloatRange
+{
+	float	mMin;
+	float	mMax;
+
+	inline void	Clear()
+	{
+		mMin = 0;
+		mMin = 0;
+	}
+	inline void Pick(float& V)
+	{
+		V = Q_flrand(mMin, mMax);
+	}
+	inline bool In(const float& V)
+	{
+		return (V>mMin && V<mMax);
+	}
+};
+
+struct	SIntRange
+{
+	int	mMin;
+	int	mMax;
+
+	inline void	Clear()
+	{
+		mMin = 0;
+		mMin = 0;
+	}
+	inline void Pick(int& V)
+	{
+		V = Q_irand(mMin, mMax);
+	}
+	inline bool In(const int& V)
+	{
+		return (V>mMin && V<mMax);
+	}
+};
+
+
+
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// The Particle Class
+////////////////////////////////////////////////////////////////////////////////////////
+class	WFXParticle
+{
+public:
+	enum
+	{
+		FLAG_RENDER = 0,
+
+		FLAG_FADEIN,
+		FLAG_FADEOUT,
+		FLAG_RESPAWN,
+
+		FLAG_MAX
+	};
+	typedef		ratl::bits_vs<FLAG_MAX>		TFlags;
+
+	float	mAlpha;
+	TFlags	mFlags;
+	CVec3	mPosition;
+	CVec3	mVelocity;
+	float	mMass;			// A higher number will more greatly resist force and result in greater gravity
+};
+
+
+
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// The Wind
+////////////////////////////////////////////////////////////////////////////////////////
+class	CWindZone
+{
+public:
+	bool		mGlobal;
+	SVecRange	mRBounds;
+	SVecRange	mRVelocity;
+	SIntRange	mRDuration;
+	SIntRange	mRDeadTime;
+	float		mMaxDeltaVelocityPerUpdate;
+	float		mChanceOfDeadTime;
+
+	CVec3		mCurrentVelocity;
+	CVec3		mTargetVelocity;
+	int			mTargetVelocityTimeRemaining;
+
+
+public:
+	////////////////////////////////////////////////////////////////////////////////////
+	// Initialize - Will setup default values for all data
+	////////////////////////////////////////////////////////////////////////////////////
+	void		Initialize()
+	{
+		mRBounds.Clear();
+		mGlobal						= true;
+
+		mRVelocity.mMins			= -1500.0f;
+		mRVelocity.mMins[2]			= -10.0f;
+		mRVelocity.mMaxs			= 1500.0f;
+		mRVelocity.mMaxs[2]			= 10.0f;
+
+		mMaxDeltaVelocityPerUpdate	= 10.0f;
+
+		mRDuration.mMin				= 1000;
+		mRDuration.mMax				= 2000;
+
+		mChanceOfDeadTime			= 0.3f;
+		mRDeadTime.mMin				= 1000;
+		mRDeadTime.mMax				= 3000;
+
+		mCurrentVelocity.Clear();
+		mTargetVelocity.Clear();
+		mTargetVelocityTimeRemaining = 0;
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Update - Changes wind when current target velocity expires
+	////////////////////////////////////////////////////////////////////////////////////
+	void		Update()
+	{
+		if (mTargetVelocityTimeRemaining==0)
+		{
+			if (FloatRand()<mChanceOfDeadTime)
+			{
+				mRDeadTime.Pick(mTargetVelocityTimeRemaining);
+				mTargetVelocity.Clear();
+			}
+			else
+			{
+				mRDuration.Pick(mTargetVelocityTimeRemaining);
+				mRVelocity.Pick(mTargetVelocity);
+			}
+		}
+		else if (mTargetVelocityTimeRemaining!=-1)
+		{
+			mTargetVelocityTimeRemaining--;
+
+			CVec3	DeltaVelocity(mTargetVelocity - mCurrentVelocity);
+			float	DeltaVelocityLen = VectorNormalize(DeltaVelocity.v);
+			if (DeltaVelocityLen > mMaxDeltaVelocityPerUpdate)
+			{
+				DeltaVelocityLen = mMaxDeltaVelocityPerUpdate;
+			}
+			DeltaVelocity *= (DeltaVelocityLen);
+			mCurrentVelocity += DeltaVelocity;
+		}
+	}
+};
+ratl::vector_vs<CWindZone, MAX_WIND_ZONES>		mWindZones;
+ratl::vector_vs<CWindZone*, MAX_WIND_ZONES>		mLocalWindZones;
+
+bool R_GetWindVector(vec3_t windVector, vec3_t atpoint)
+{
+	VectorCopy(mGlobalWindDirection.v, windVector);
+	if (atpoint && mLocalWindZones.size())
+	{
+		for (int curLocalWindZone=0; curLocalWindZone<mLocalWindZones.size(); curLocalWindZone++)
+		{
+			if (mLocalWindZones[curLocalWindZone]->mRBounds.In(atpoint))
+			{
+				VectorAdd(windVector, mLocalWindZones[curLocalWindZone]->mCurrentVelocity.v, windVector);
+			}
+		}
+		VectorNormalize(windVector);
+	}
+	return true;
+}
+
+bool R_GetWindSpeed(float &windSpeed, vec3_t atpoint)
+{
+	windSpeed = mGlobalWindSpeed;
+	if (atpoint && mLocalWindZones.size())
+	{
+		for (int curLocalWindZone=0; curLocalWindZone<mLocalWindZones.size(); curLocalWindZone++)
+		{
+			if (mLocalWindZones[curLocalWindZone]->mRBounds.In(atpoint))
+			{
+				windSpeed += VectorLength(mLocalWindZones[curLocalWindZone]->mCurrentVelocity.v);
+			}
+		}
+	}
+	return true;
+}
+
+bool R_GetWindGusting(vec3_t atpoint)
+{
+	float windSpeed;
+	R_GetWindSpeed(windSpeed, atpoint);
+	return (windSpeed>1000.0f);
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Outside Point Cache
+////////////////////////////////////////////////////////////////////////////////////////
+class COutside
+{
+#define COUTSIDE_STRUCT_VERSION 1	// you MUST increase this any time you change any binary (fields) inside this class, or cahced files will fuck up
+public:
+	////////////////////////////////////////////////////////////////////////////////////
+	//Global Public Outside Variables
+	////////////////////////////////////////////////////////////////////////////////////
+
+	bool			mOutsideShake;
+	float			mOutsidePain;
+
+	CVec3			mFogColor;
+	int				mFogColorInt;
+	bool			mFogColorTempActive;
+
+private:
+	////////////////////////////////////////////////////////////////////////////////////
+	// The Outside Cache
+	////////////////////////////////////////////////////////////////////////////////////
+	bool			mCacheInit;			// Has It Been Cached?
+
+	struct SWeatherZone
+	{
+		static bool	mMarkedOutside;		
+		ulong*		mPointCache;			// malloc block ptr
+		
+		int			miPointCacheByteSize;	// size of block
+		SVecRange	mExtents;
+		SVecRange	mSize;
+		int			mWidth;
+		int			mHeight;
+		int			mDepth;
+
+		void WriteToDisk( fileHandle_t f )
+		{			
+			FS_Write(&mMarkedOutside,sizeof(mMarkedOutside),f);
+			FS_Write( mPointCache, miPointCacheByteSize, f );
+		}
+
+		void ReadFromDisk( fileHandle_t f )
+		{			
+			FS_Read(&mMarkedOutside,sizeof(mMarkedOutside),f);
+			FS_Read( mPointCache, miPointCacheByteSize, f);
+		}
+
+		////////////////////////////////////////////////////////////////////////////////////
+		// Convert To Cell
+		////////////////////////////////////////////////////////////////////////////////////
+		inline	void	ConvertToCell(const CVec3& pos, int& x, int& y, int& z, int& bit)
+		{
+			x = (int)((pos[0] / POINTCACHE_CELL_SIZE) - mSize.mMins[0]);
+			y = (int)((pos[1] / POINTCACHE_CELL_SIZE) - mSize.mMins[1]);
+			z = (int)((pos[2] / POINTCACHE_CELL_SIZE) - mSize.mMins[2]);
+
+			bit = (z & 31);
+			z >>= 5;
+		}
+
+		////////////////////////////////////////////////////////////////////////////////////
+		// CellOutside - Test to see if a given cell is outside
+		////////////////////////////////////////////////////////////////////////////////////
+		inline	bool	CellOutside(int x, int y, int z, int bit)
+		{
+			if ((x < 0 || x >= mWidth) || (y < 0 || y >= mHeight) || (z < 0 || z >= mDepth) || (bit < 0 || bit >= 32))
+			{
+				return !(mMarkedOutside);
+			}
+			return (mMarkedOutside==(!!(mPointCache[((z * mWidth * mHeight) + (y * mWidth) + x)]&(1 << bit))));
+		}
+	};
+	ratl::vector_vs<SWeatherZone, MAX_WEATHER_ZONES>	mWeatherZones;
+
+
+private:
+	////////////////////////////////////////////////////////////////////////////////////
+	// Iteration Variables
+	////////////////////////////////////////////////////////////////////////////////////
+	int				mWCells;
+	int				mHCells;
+
+	int				mXCell;
+	int				mYCell;
+	int				mZBit;
+
+	int				mXMax;
+	int				mYMax;
+	int				mZMax;
+
+
+private:
+
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Contents Outside
+	////////////////////////////////////////////////////////////////////////////////////
+	inline	bool	ContentsOutside(int contents)
+	{
+		if (contents&CONTENTS_WATER || contents&CONTENTS_SOLID)
+		{
+			return false;
+		}
+		if (mCacheInit)
+		{
+			if (SWeatherZone::mMarkedOutside)
+			{
+				return (!!(contents&CONTENTS_OUTSIDE));
+			}
+			return (!(contents&CONTENTS_INSIDE));
+		}
+		return !!(contents&CONTENTS_OUTSIDE);
+	}
+
+
+
+
+public:
+	////////////////////////////////////////////////////////////////////////////////////
+	// Constructor - Will setup default values for all data
+	////////////////////////////////////////////////////////////////////////////////////
+	void Reset()
+	{
+		mOutsideShake = false;
+		mOutsidePain = 0.0;
+		mCacheInit = false;
+		SWeatherZone::mMarkedOutside = false;
+		
+		mFogColor.Clear();
+		mFogColorInt = 0;
+		mFogColorTempActive = false;
+
+		for (int wz=0; wz<mWeatherZones.size(); wz++)
+		{
+			Z_Free(mWeatherZones[wz].mPointCache);
+			mWeatherZones[wz].mPointCache = 0;
+			mWeatherZones[wz].miPointCacheByteSize = 0;	// not really necessary because of .clear() below, but keeps things together in case stuff changes
+		}
+		mWeatherZones.clear();
+	}
+
+	COutside()
+	{
+		Reset();
+	}
+	~COutside()
+	{
+		Reset();
+	}
+
+	bool			Initialized()
+	{
+		return mCacheInit;
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// AddWeatherZone - Will add a zone of mins and maxes
+	////////////////////////////////////////////////////////////////////////////////////
+	void			AddWeatherZone(vec3_t mins, vec3_t maxs)
+	{
+		if (mCacheInit)
+		{
+			return;
+		}
+		if (!mWeatherZones.full())
+		{
+			SWeatherZone&	Wz = mWeatherZones.push_back();
+			Wz.mExtents.mMins = mins;
+			Wz.mExtents.mMaxs = maxs;
+
+			SnapVectorToGrid(Wz.mExtents.mMins, POINTCACHE_CELL_SIZE); 
+			SnapVectorToGrid(Wz.mExtents.mMaxs, POINTCACHE_CELL_SIZE); 
+
+			Wz.mSize.mMins = Wz.mExtents.mMins;
+			Wz.mSize.mMaxs = Wz.mExtents.mMaxs;
+
+			Wz.mSize.mMins /= POINTCACHE_CELL_SIZE;
+			Wz.mSize.mMaxs /= POINTCACHE_CELL_SIZE;
+			Wz.mWidth		=  (int)(Wz.mSize.mMaxs[0] - Wz.mSize.mMins[0]);
+			Wz.mHeight		=  (int)(Wz.mSize.mMaxs[1] - Wz.mSize.mMins[1]);
+			Wz.mDepth		= ((int)(Wz.mSize.mMaxs[2] - Wz.mSize.mMins[2]) + 31) >> 5;
+			
+			Wz.miPointCacheByteSize = (Wz.mWidth * Wz.mHeight * Wz.mDepth) * sizeof(ulong);
+			Wz.mPointCache  = (ulong *)Z_Malloc( Wz.miPointCacheByteSize, TAG_POINTCACHE, qtrue );
+		}
+		else
+		{
+			assert("MaxWeatherZones Hit!"==0);
+		}
+	}
+
+	const char *GenCachedWeatherFilename(void)
+	{
+		return va("maps/%s.weather", sv_mapname->string);
+	}
+
+	// weather file format...
+	//
+	struct WeatherFileHeader_t
+	{
+		int m_iVersion;
+		int m_iChecksum;
+
+		WeatherFileHeader_t()
+		{
+			m_iVersion			= COUTSIDE_STRUCT_VERSION;
+			m_iChecksum			= sv_mapChecksum->integer;
+		}
+	};
+	
+	fileHandle_t WriteCachedWeatherFile( void )
+	{
+		fileHandle_t f = FS_FOpenFileWrite( GenCachedWeatherFilename() );
+		if (f)
+		{
+			WeatherFileHeader_t WeatherFileHeader;
+
+            FS_Write(&WeatherFileHeader, sizeof(WeatherFileHeader), f);
+			return f;
+		}
+		else
+		{
+			VID_Printf( PRINT_WARNING, "(Unable to open weather file \"%s\" for writing!)\n",GenCachedWeatherFilename());
+		}
+
+		return 0;
+	}
+
+	// returns 0 for not-found or invalid file, else open handle to continue read from (which you then close yourself)...
+	//
+	fileHandle_t ReadCachedWeatherFile( void )
+	{
+		fileHandle_t f = 0;
+		FS_FOpenFileRead( GenCachedWeatherFilename(), &f, qfalse );
+		if ( f )
+		{
+			// ok, it exists, but is it valid for this map?...
+			//
+			WeatherFileHeader_t WeatherFileHeaderForCompare;
+			WeatherFileHeader_t WeatherFileHeaderFromDisk;
+
+			FS_Read(&WeatherFileHeaderFromDisk, sizeof(WeatherFileHeaderFromDisk), f);
+
+			if (!memcmp(&WeatherFileHeaderForCompare, &WeatherFileHeaderFromDisk, sizeof(WeatherFileHeaderFromDisk)))
+			{
+				// go for it...
+				//
+				return f;
+			}
+
+            VID_Printf( PRINT_WARNING, "( Cached weather file \"%s\" out of date, regenerating... )\n",GenCachedWeatherFilename());
+			FS_FCloseFile( f );
+		}
+		else
+		{
+			VID_Printf( PRINT_WARNING, "( No cached weather file found, generating... )\n");
+		}
+
+		return 0;
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Cache - Will Scan the World, Creating The Cache
+	////////////////////////////////////////////////////////////////////////////////////
+	void			Cache()
+	{
+		if (!tr.world || mCacheInit)
+		{
+			return;
+		}
+
+		// all this piece of code does really is fill in the bool "SWeatherZone::mMarkedOutside", plus the mPointCache[] for each zone,
+		//	so we can diskload those. Maybe.		
+		fileHandle_t f = ReadCachedWeatherFile();
+		if ( f )
+		{
+			for (int iZone=0; iZone<mWeatherZones.size(); iZone++)
+			{
+				SWeatherZone wz = mWeatherZones[iZone];
+				wz.ReadFromDisk( f );
+			}
+
+			mCacheInit = true;
+		}
+		else
+		{
+			CVec3		CurPos;
+			CVec3		Size;
+			CVec3		Mins;
+			int			x, y, z, q, zbase;
+			bool		curPosOutside;
+			ulong		contents;
+			ulong		bit;
+
+
+			// Record The Extents Of The World Incase No Other Weather Zones Exist
+			//---------------------------------------------------------------------
+			if (!mWeatherZones.size())
+			{
+				Com_Printf("WARNING: No Weather Zones Encountered");
+				AddWeatherZone(tr.world->bmodels[0].bounds[0], tr.world->bmodels[0].bounds[1]);
+			}
+
+			f = WriteCachedWeatherFile();
+
+			// Iterate Over All Weather Zones
+			//--------------------------------			
+			for (int zone=0; zone<mWeatherZones.size(); zone++)
+			{
+				SWeatherZone	wz = mWeatherZones[zone];
+
+				// Make Sure Point Contents Checks Occur At The CENTER Of The Cell
+				//-----------------------------------------------------------------
+				Mins = wz.mExtents.mMins;
+				for (x=0; x<3; x++)
+				{
+					Mins[x] += (POINTCACHE_CELL_SIZE/2);
+				}
+
+
+				// Start Scanning
+				//----------------
+				for(z = 0; z < wz.mDepth; z++)
+				{
+					for(q = 0; q < 32; q++)
+					{
+						bit = (1 << q);
+						zbase = (z << 5);
+
+						for(x = 0; x < wz.mWidth; x++)
+						{
+							for(y = 0; y < wz.mHeight; y++)
+							{
+								CurPos[0] = x			* POINTCACHE_CELL_SIZE;
+								CurPos[1] = y			* POINTCACHE_CELL_SIZE;
+								CurPos[2] = (zbase + q)	* POINTCACHE_CELL_SIZE;
+								CurPos	  += Mins;
+
+								contents = CM_PointContents(CurPos.v, 0);
+								if (contents&CONTENTS_INSIDE || contents&CONTENTS_OUTSIDE)
+								{
+									curPosOutside = ((contents&CONTENTS_OUTSIDE)!=0);
+									if (!mCacheInit)
+									{
+										mCacheInit = true;
+										SWeatherZone::mMarkedOutside = curPosOutside;
+									}
+									else if (SWeatherZone::mMarkedOutside!=curPosOutside)
+									{
+										assert(0);
+										Com_Error (ERR_DROP, "Weather Effect: Both Indoor and Outdoor brushs encountered in map.\n" );
+										return;
+									}
+
+									// Mark The Point
+									//----------------
+									wz.mPointCache[((z * wz.mWidth * wz.mHeight) + (y * wz.mWidth) + x)] |= bit;
+								}
+							}// for (y)
+						}// for (x)
+					}// for (q)
+				}// for (z)
+
+				if (f)
+				{
+					mWeatherZones[ zone ].WriteToDisk( f );
+				}
+			}
+		}
+
+		if (f)
+		{
+			FS_FCloseFile(f);
+			f=0;	// not really necessary, but wtf.
+		}
+
+		// If no indoor or outdoor brushes were found
+		//--------------------------------------------
+		if (!mCacheInit)
+		{
+			mCacheInit = true;
+			SWeatherZone::mMarkedOutside = false;		// Assume All Is Outside, Except Solid
+		}
+	}
+
+public:
+	////////////////////////////////////////////////////////////////////////////////////
+	// PointOutside - Test to see if a given point is outside
+	////////////////////////////////////////////////////////////////////////////////////
+	inline	bool	PointOutside(const CVec3& pos)
+	{
+		if (!mCacheInit)
+		{
+			return ContentsOutside(CM_PointContents(pos.v, 0));
+		}
+		for (int zone=0; zone<mWeatherZones.size(); zone++)
+		{
+			SWeatherZone	wz = mWeatherZones[zone];
+			if (wz.mExtents.In(pos))
+			{
+				int		bit, x, y, z;
+				wz.ConvertToCell(pos, x, y, z, bit);
+				return wz.CellOutside(x, y, z, bit);
+			}
+		}
+		return !(SWeatherZone::mMarkedOutside);
+
+	}
+
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// PointOutside - Test to see if a given bounded plane is outside
+	////////////////////////////////////////////////////////////////////////////////////
+	inline	bool	PointOutside(const CVec3& pos, float width, float height)
+	{
+		for (int zone=0; zone<mWeatherZones.size(); zone++)
+		{
+			SWeatherZone	wz = mWeatherZones[zone];
+			if (wz.mExtents.In(pos))
+			{
+				int		bit, x, y, z;
+				wz.ConvertToCell(pos, x, y, z, bit);
+				if (width<POINTCACHE_CELL_SIZE || height<POINTCACHE_CELL_SIZE)
+				{
+ 					return (wz.CellOutside(x, y, z, bit));
+				}
+
+				mWCells = ((int)width  / POINTCACHE_CELL_SIZE);
+				mHCells = ((int)height / POINTCACHE_CELL_SIZE);
+
+				mXMax = x + mWCells;
+				mYMax = y + mWCells;
+				mZMax = bit + mHCells;
+
+				for (mXCell=x-mWCells; mXCell<=mXMax; mXCell++)
+				{
+					for (mYCell=y-mWCells; mYCell<=mYMax; mYCell++)
+					{
+						for (mZBit=bit-mHCells; mZBit<=mZMax; mZBit++)
+						{
+							if (!wz.CellOutside(mXCell, mYCell, z, mZBit))
+							{
+								return false;
+							}
+						}
+					}
+				}
+				return true;
+			}
+		}
+		return !(SWeatherZone::mMarkedOutside);
+	}
+};
+COutside			mOutside;
+bool				COutside::SWeatherZone::mMarkedOutside = false;
+
+
+void R_AddWeatherZone(vec3_t mins, vec3_t maxs)
+{
+	mOutside.AddWeatherZone(mins, maxs);
+}
+
+bool R_IsOutside(vec3_t pos)
+{
+	return mOutside.PointOutside(pos);
+}
+
+bool R_IsShaking(vec3_t pos)
+{
+	return (mOutside.mOutsideShake && mOutside.PointOutside(pos));
+}
+
+float R_IsOutsideCausingPain(vec3_t pos)
+{
+	return (mOutside.mOutsidePain && mOutside.PointOutside(pos));
+}
+
+bool R_SetTempGlobalFogColor(vec3_t color)
+{
+	if (tr.world && tr.world->globalFog != -1)
+	{
+		// If Non Zero, Try To Set The Color
+		//-----------------------------------
+		if (color[0] || color[1] || color[2])
+		{
+			// Remember The Normal Fog Color
+			//-------------------------------
+			if (!mOutside.mFogColorTempActive)
+			{
+				mOutside.mFogColor				= tr.world->fogs[tr.world->globalFog].parms.color;
+				mOutside.mFogColorInt			= tr.world->fogs[tr.world->globalFog].colorInt;
+				mOutside.mFogColorTempActive	= true;
+			}
+
+			// Set The New One
+			//-----------------
+			tr.world->fogs[tr.world->globalFog].parms.color[0] = color[0];
+			tr.world->fogs[tr.world->globalFog].parms.color[1] = color[1];
+			tr.world->fogs[tr.world->globalFog].parms.color[2] = color[2];
+			tr.world->fogs[tr.world->globalFog].colorInt = ColorBytes4 ( 
+												color[0] * tr.identityLight, 
+												color[1] * tr.identityLight, 
+												color[2] * tr.identityLight, 
+												1.0 );
+		}
+
+		// If Unable TO Parse The Command Color Vector, Restore The Previous Fog Color
+		//-----------------------------------------------------------------------------
+		else if (mOutside.mFogColorTempActive)
+		{
+			mOutside.mFogColorTempActive = false;
+
+			tr.world->fogs[tr.world->globalFog].parms.color[0] = mOutside.mFogColor[0];
+			tr.world->fogs[tr.world->globalFog].parms.color[1] = mOutside.mFogColor[1];
+			tr.world->fogs[tr.world->globalFog].parms.color[2] = mOutside.mFogColor[2];
+			tr.world->fogs[tr.world->globalFog].colorInt	   = mOutside.mFogColorInt;
+		}
+	}
+	return true;
+}
+
+
+#ifdef _XBOX	// Xbox point sprite code
+static void pointBegin(GLint verts, float size)
+{
+	assert(!glw_state->inDrawBlock);
+
+	// start the draw block
+	glw_state->inDrawBlock = true;
+	glw_state->primitiveMode = D3DPT_POINTLIST;
+
+	// update DX with any pending state changes
+	glw_state->drawStride = 4;
+	DWORD mask = D3DFVF_XYZ | D3DFVF_DIFFUSE;
+	glw_state->device->SetVertexShader(mask);
+	glw_state->shaderMask = mask;
+
+	if(glw_state->matricesDirty[glwstate_t::MatrixMode_Model])
+	{
+		glw_state->device->SetTransform(D3DTS_VIEW, 
+			glw_state->matrixStack[glwstate_t::MatrixMode_Model]->GetTop());
+
+		glw_state->matricesDirty[glwstate_t::MatrixMode_Model] = false;
+	}
+
+	// Update the texture and states
+	// NOTE: Point sprites ALWAYS go on texture stage 3
+	glwstate_t::texturexlat_t::iterator it = glw_state->textureXlat.find(glw_state->currentTexture[0]);
+	glw_state->device->SetTexture( 3, it->second.mipmap );
+	glw_state->device->SetTextureStageState(3, D3DTSS_COLOROP,   glw_state->textureEnv[0]);
+	glw_state->device->SetTextureStageState(3, D3DTSS_COLORARG1, D3DTA_TEXTURE);
+	glw_state->device->SetTextureStageState(3, D3DTSS_COLORARG2, D3DTA_CURRENT);
+	glw_state->device->SetTextureStageState(3, D3DTSS_ALPHAOP,   glw_state->textureEnv[0]);
+	glw_state->device->SetTextureStageState(3, D3DTSS_ALPHAARG1, D3DTA_TEXTURE);
+	glw_state->device->SetTextureStageState(3, D3DTSS_ALPHAARG2, D3DTA_CURRENT);
+	glw_state->device->SetTextureStageState(3, D3DTSS_MAXANISOTROPY, it->second.anisotropy);
+	glw_state->device->SetTextureStageState(3, D3DTSS_MINFILTER, it->second.minFilter);
+	glw_state->device->SetTextureStageState(3, D3DTSS_MIPFILTER, it->second.mipFilter);
+	glw_state->device->SetTextureStageState(3, D3DTSS_MAGFILTER, it->second.magFilter);
+	glw_state->device->SetTextureStageState(3, D3DTSS_ADDRESSU,  it->second.wrapU);
+	glw_state->device->SetTextureStageState(3, D3DTSS_ADDRESSV,  it->second.wrapV);
+
+	glw_state->device->SetTexture( 0, NULL );
+	glw_state->device->SetTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_DISABLE );
+
+	float attena = 1.0f, attenb = 0.0f, attenc = 0.01f;
+	glw_state->device->SetRenderState( D3DRS_POINTSPRITEENABLE, TRUE );
+	glw_state->device->SetRenderState( D3DRS_POINTSCALEENABLE,  TRUE );
+	glw_state->device->SetRenderState( D3DRS_POINTSIZE,         *((DWORD*)&size) );
+	glw_state->device->SetRenderState( D3DRS_POINTSIZE_MIN,     *((DWORD*)&attenb));
+	glw_state->device->SetRenderState( D3DRS_POINTSCALE_A,      *((DWORD*)&attena) );
+	glw_state->device->SetRenderState( D3DRS_POINTSCALE_B,      *((DWORD*)&attenb) );
+	glw_state->device->SetRenderState( D3DRS_POINTSCALE_C,      *((DWORD*)&attenc) );
+
+	// set vertex counters
+	glw_state->numVertices = 0;
+	glw_state->totalVertices = verts;
+	int max = glw_state->totalVertices;
+	if (max > 2040 / glw_state->drawStride)
+	{
+		max = 2040 / glw_state->drawStride;
+	}
+	glw_state->maxVertices = max;	
+
+	// open a draw packet
+	int num_packets;
+	if(verts == 0) {
+		num_packets = 1;
+	} else {
+		num_packets = (verts / glw_state->maxVertices) + (!!(verts % glw_state->maxVertices));
+	}
+	int cmd_size = num_packets * 3;
+	int vert_size = glw_state->drawStride * verts;
+
+	glw_state->device->BeginPush(vert_size + cmd_size + 2, 
+		&glw_state->drawArray);
+
+	glw_state->drawArray[0] = D3DPUSH_ENCODE(D3DPUSH_SET_BEGIN_END, 1);
+	glw_state->drawArray[1] = glw_state->primitiveMode;
+	glw_state->drawArray[2] = D3DPUSH_ENCODE(
+		D3DPUSH_NOINCREMENT_FLAG|D3DPUSH_INLINE_ARRAY, 
+		glw_state->drawStride * glw_state->maxVertices);
+	glw_state->drawArray += 3;
+}
+
+
+static void pointEnd()
+{
+	glw_state->device->SetRenderState( D3DRS_POINTSPRITEENABLE, FALSE );
+	glw_state->device->SetRenderState( D3DRS_POINTSCALEENABLE, FALSE );
+	glw_state->device->SetTexture( 3, NULL );
+	glw_state->device->SetTextureStageState( 3, D3DTSS_COLOROP, D3DTOP_DISABLE );
+}
+#endif // _XBOX
+
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Particle Cloud
+////////////////////////////////////////////////////////////////////////////////////////
+class	CParticleCloud
+{
+private:
+	////////////////////////////////////////////////////////////////////////////////////
+	// DYNAMIC MEMORY
+	////////////////////////////////////////////////////////////////////////////////////
+	image_t*	mImage;
+	WFXParticle*	mParticles;
+
+private:
+	////////////////////////////////////////////////////////////////////////////////////
+	// RUN TIME VARIANTS
+	////////////////////////////////////////////////////////////////////////////////////
+	float		mSpawnSpeed;
+	CVec3		mSpawnPlaneNorm;
+	CVec3		mSpawnPlaneRight;
+	CVec3		mSpawnPlaneUp;
+	SVecRange	mRange;
+
+	CVec3		mCameraPosition;
+	CVec3		mCameraForward;
+	CVec3		mCameraLeft;
+	CVec3		mCameraDown;
+	CVec3		mCameraLeftPlusUp;
+	CVec3		mCameraLeftMinusUp;
+
+
+	int			mParticleCountRender;
+	int			mGLModeEnum;
+
+	bool		mPopulated;
+
+
+public:
+	////////////////////////////////////////////////////////////////////////////////////
+	// CONSTANTS
+	////////////////////////////////////////////////////////////////////////////////////
+	bool		mOrientWithVelocity;
+	float		mSpawnPlaneSize;
+	float		mSpawnPlaneDistance;
+	SVecRange	mSpawnRange;
+
+	float		mGravity;			// How much gravity affects the velocity of a particle
+	CVec4		mColor;				// RGBA color
+	int			mVertexCount;		// 3 for triangle, 4 for quad, other numbers not supported
+
+	float		mWidth;
+	float		mHeight;
+
+	int			mBlendMode;			// 0 = ALPHA, 1 = SRC->SRC
+	int			mFilterMode;		// 0 = LINEAR, 1 = NEAREST
+
+	float		mFade;				// How much to fade in and out 1.0 = instant, 0.01 = very slow
+
+	SFloatRange	mRotation;
+	float		mRotationDelta;
+	float		mRotationDeltaTarget;
+	float		mRotationCurrent;
+	SIntRange	mRotationChangeTimer;
+	int			mRotationChangeNext;
+
+	SFloatRange	mMass;				// Determines how slowness to accelerate, higher number = slower
+	float		mFrictionInverse;	// How much air friction does this particle have 1.0=none, 0.0=nomove
+	
+	int			mParticleCount;
+
+	bool		mWaterParticles;
+
+
+
+
+public:
+	////////////////////////////////////////////////////////////////////////////////////
+	// Initialize - Create Image, Particles, And Setup All Values
+	////////////////////////////////////////////////////////////////////////////////////
+	void	Initialize(int count, const char* texturePath, int VertexCount=4)
+	{
+		Reset();
+		assert(mParticleCount==0 && mParticles==0);
+		assert(mImage==0);
+
+		// Create The Image
+		//------------------
+		mImage = R_FindImageFile(texturePath, false, false, false, GL_CLAMP);
+		if (!mImage)
+		{
+			Com_Error(ERR_DROP, "CParticleCloud: Could not texture %s", texturePath);
+		}
+
+		GL_Bind(mImage);
+
+
+
+		// Create The Particles
+		//----------------------
+		mParticleCount	= count;
+		mParticles		= new WFXParticle[mParticleCount];
+
+
+
+		WFXParticle*	part=0;
+		for (int particleNum=0; particleNum<mParticleCount; particleNum++)
+		{
+			part = &(mParticles[particleNum]);
+			part->mPosition.Clear();
+			part->mVelocity.Clear();
+			part->mAlpha	= 0.0f;
+			mMass.Pick(part->mMass);
+		}
+
+		mVertexCount = VertexCount;
+#ifdef _XBOX	// Check for point sprite use
+		if(mVertexCount == 1)
+			mGLModeEnum = GL_POINTS;
+		else
+#endif
+		mGLModeEnum = (mVertexCount==3)?(GL_TRIANGLES):(GL_QUADS);
+	}
+
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Reset - Initializes all data to default values
+	////////////////////////////////////////////////////////////////////////////////////
+	void		Reset()
+	{
+		if (mImage)
+		{
+			// TODO: Free Image?
+		}
+		mImage				= 0;
+		if (mParticleCount)
+		{
+			delete [] mParticles;
+		}
+		mParticleCount		= 0;
+		mParticles			= 0;
+
+		mPopulated			= 0;
+
+
+
+		// These Are The Default Startup Values For Constant Data
+		//========================================================
+		mOrientWithVelocity = false;
+		mWaterParticles		= false;
+
+		mSpawnPlaneDistance	= 500;
+		mSpawnPlaneSize		= 500;
+		mSpawnRange.mMins	= -(mSpawnPlaneDistance*1.25f);
+		mSpawnRange.mMaxs	=  (mSpawnPlaneDistance*1.25f);
+
+		mGravity			= 300.0f;	// Units Per Second
+
+		mColor				= 1.0f;
+
+		mVertexCount		= 4;
+		mWidth				= 1.0f;
+		mHeight				= 1.0f;
+
+		mBlendMode			= 0;
+		mFilterMode			= 0;
+
+		mFade				= 10.0f;
+
+		mRotation.Clear();
+		mRotationDelta		= 0.0f;
+		mRotationDeltaTarget= 0.0f;
+		mRotationCurrent	= 0.0f;
+		mRotationChangeNext	= -1;
+		mRotation.mMin		= -0.7f;
+		mRotation.mMax		=  0.7f;
+		mRotationChangeTimer.mMin = 500;
+		mRotationChangeTimer.mMin = 2000;
+
+		mMass.mMin			= 5.0f;
+		mMass.mMax			= 10.0f;
+
+		mFrictionInverse	= 0.7f;		// No Friction?
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Constructor - Will setup default values for all data
+	////////////////////////////////////////////////////////////////////////////////////
+	CParticleCloud()
+	{
+		mImage = 0;
+		mParticleCount = 0;
+		Reset();
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Initialize - Will setup default values for all data
+	////////////////////////////////////////////////////////////////////////////////////
+	~CParticleCloud()
+	{
+		Reset();
+	}
+
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// UseSpawnPlane - Check To See If We Should Spawn On A Plane, Or Just Wrap The Box
+	////////////////////////////////////////////////////////////////////////////////////
+	inline bool	UseSpawnPlane()
+	{
+		return (mGravity!=0.0f);
+	}
+
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Update - Applies All Physics Forces To All Contained Particles
+	////////////////////////////////////////////////////////////////////////////////////
+	void		Update()
+	{
+		WFXParticle*	part=0;
+		CVec3		partForce;
+		CVec3		partMoved;
+		CVec3		partToCamera;
+		bool		partRendering;
+		bool		partOutside;
+		bool		partInRange;
+		bool		partInView;
+		int			particleNum;
+		float		particleFade = (mFade * mSecondsElapsed);
+		int			numLocalWindZones = mLocalWindZones.size();
+		int			curLocalWindZone;
+
+
+		// Compute Camera
+		//----------------
+		{
+			mCameraPosition	= backEnd.viewParms.or.origin;
+			mCameraForward	= backEnd.viewParms.or.axis[0];
+			mCameraLeft		= backEnd.viewParms.or.axis[1];
+			mCameraDown		= backEnd.viewParms.or.axis[2];
+
+			if (mRotationChangeNext!=-1)
+			{
+				if (mRotationChangeNext==0)
+				{
+					mRotation.Pick(mRotationDeltaTarget);
+					mRotationChangeTimer.Pick(mRotationChangeNext);
+					if (mRotationChangeNext<=0)
+					{
+						mRotationChangeNext = 1;
+					}
+				}
+				mRotationChangeNext--;
+
+				float	RotationDeltaDifference = (mRotationDeltaTarget - mRotationDelta);
+				if (fabsf(RotationDeltaDifference)>0.01)
+				{
+					mRotationDelta += RotationDeltaDifference;		// Blend To New Delta
+				}
+                mRotationCurrent += (mRotationDelta * mSecondsElapsed);
+				float s = sinf(mRotationCurrent);
+				float c = cosf(mRotationCurrent);
+
+				CVec3	TempCamLeft(mCameraLeft);
+
+				mCameraLeft *= (c * mWidth);
+				mCameraLeft.ScaleAdd(mCameraDown, (s * mWidth * -1.0f));
+
+				mCameraDown *= (c * mHeight);
+				mCameraDown.ScaleAdd(TempCamLeft, (s * mHeight));
+			}
+			else
+			{
+				mCameraLeft		*= mWidth;
+ 				mCameraDown		*= mHeight;
+			}
+		}
+
+
+		// Compute Global Force
+		//----------------------
+		CVec3		force;
+		{
+			force.Clear();
+
+			// Apply Gravity
+			//---------------
+			force[2] = -1.0f * mGravity;
+
+			// Apply Wind Velocity
+			//---------------------
+			force    += mGlobalWindVelocity;
+		}
+
+
+		// Update Range
+		//--------------
+		{
+			mRange.mMins = mCameraPosition + mSpawnRange.mMins;
+			mRange.mMaxs = mCameraPosition + mSpawnRange.mMaxs;
+
+			// If Using A Spawn Plane, Increase The Range Box A Bit To Account For Rotation On The Spawn Plane
+			//-------------------------------------------------------------------------------------------------
+			if (UseSpawnPlane())
+			{
+				for (int dim=0; dim<3; dim++)
+				{
+					if (force[dim]>0.01)
+					{
+						mRange.mMins[dim] -= (mSpawnPlaneDistance/2.0f);
+					}
+					else if (force[dim]<-0.01)
+					{
+						mRange.mMaxs[dim] += (mSpawnPlaneDistance/2.0f);
+					}
+				}
+				mSpawnPlaneNorm	= force;
+				mSpawnSpeed		= VectorNormalize(mSpawnPlaneNorm.v);
+				MakeNormalVectors(mSpawnPlaneNorm.v, mSpawnPlaneRight.v, mSpawnPlaneUp.v);
+			}
+
+			// Optimization For Quad Position Calculation
+			//--------------------------------------------
+			if (mVertexCount==4)
+			{
+		 		mCameraLeftPlusUp  = (mCameraLeft - mCameraDown);
+				mCameraLeftMinusUp = (mCameraLeft + mCameraDown);
+			}
+			else
+			{
+				mCameraLeftPlusUp  = (mCameraDown + mCameraLeft);		// should really be called mCamera Left + Down
+			}
+		}
+
+		// Stop All Additional Processing
+		//--------------------------------
+		if (mFrozen)
+		{
+			return;
+		}
+
+
+
+		// Now Update All Particles
+		//--------------------------
+		mParticleCountRender = 0;
+		for (particleNum=0; particleNum<mParticleCount; particleNum++)
+		{
+			part			= &(mParticles[particleNum]);
+
+			if (!mPopulated)
+			{
+				mRange.Pick(part->mPosition);		// First Time Spawn Location
+			}
+
+			// Grab The Force And Apply Non Global Wind
+			//------------------------------------------
+			partForce = force;
+
+			if (numLocalWindZones)
+			{
+				for (curLocalWindZone=0; curLocalWindZone<numLocalWindZones; curLocalWindZone++)
+				{
+					if (mLocalWindZones[curLocalWindZone]->mRBounds.In(part->mPosition))
+					{
+						partForce += mLocalWindZones[curLocalWindZone]->mCurrentVelocity;
+					}
+				}
+			}
+
+			partForce /= part->mMass;
+
+
+			// Apply The Force
+			//-----------------
+			part->mVelocity		+= partForce;
+			part->mVelocity		*= mFrictionInverse;
+
+			part->mPosition.ScaleAdd(part->mVelocity, mSecondsElapsed);
+
+			partToCamera	= (part->mPosition - mCameraPosition);
+			partRendering	= part->mFlags.get_bit(WFXParticle::FLAG_RENDER);
+			partOutside		= mOutside.PointOutside(part->mPosition, mWidth, mHeight);
+			partInRange		= mRange.In(part->mPosition);
+			partInView		= (partOutside && partInRange && (partToCamera.Dot(mCameraForward)>0.0f));
+
+			// Process Respawn
+			//-----------------
+			if (!partInRange && !partRendering)
+			{
+				part->mVelocity.Clear();
+
+				// Reselect A Position On The Spawn Plane
+				//----------------------------------------
+				if (UseSpawnPlane())
+				{
+					part->mPosition		= mCameraPosition;
+					part->mPosition		-= (mSpawnPlaneNorm* mSpawnPlaneDistance); 
+					part->mPosition		+= (mSpawnPlaneRight*Q_flrand(-mSpawnPlaneSize, mSpawnPlaneSize)); 
+					part->mPosition		+= (mSpawnPlaneUp*   Q_flrand(-mSpawnPlaneSize, mSpawnPlaneSize)); 
+				}
+
+				// Otherwise, Just Wrap Around To The Other End Of The Range
+				//-----------------------------------------------------------
+				else
+				{
+					mRange.Wrap(part->mPosition);
+				}
+				partInRange = true;
+			}
+
+			// Process Fade
+			//--------------
+			{
+				// Start A Fade Out
+				//------------------
+				if		(partRendering && !partInView)
+				{
+					part->mFlags.clear_bit(WFXParticle::FLAG_FADEIN);
+					part->mFlags.set_bit(WFXParticle::FLAG_FADEOUT);
+				}
+
+				// Switch From Fade Out To Fade In
+				//---------------------------------
+				else if (partRendering && partInView && part->mFlags.get_bit(WFXParticle::FLAG_FADEOUT))
+				{
+					part->mFlags.set_bit(WFXParticle::FLAG_FADEIN);
+					part->mFlags.clear_bit(WFXParticle::FLAG_FADEOUT);
+				}			
+
+				// Start A Fade In
+				//-----------------
+				else if (!partRendering && partInView)
+				{
+					partRendering = true;
+					part->mAlpha = 0.0f;
+					part->mFlags.set_bit(WFXParticle::FLAG_RENDER);
+					part->mFlags.set_bit(WFXParticle::FLAG_FADEIN);
+					part->mFlags.clear_bit(WFXParticle::FLAG_FADEOUT);
+				}
+
+				// Update Fade
+				//-------------
+				if (partRendering)
+				{
+
+					// Update Fade Out
+					//-----------------
+					if (part->mFlags.get_bit(WFXParticle::FLAG_FADEOUT))
+					{
+						part->mAlpha -= particleFade;
+						if (part->mAlpha<=0.0f)
+						{
+							part->mAlpha = 0.0f;
+							part->mFlags.clear_bit(WFXParticle::FLAG_FADEOUT);
+							part->mFlags.clear_bit(WFXParticle::FLAG_FADEIN);
+							part->mFlags.clear_bit(WFXParticle::FLAG_RENDER);
+							partRendering = false;
+						}
+					}
+
+					// Update Fade In
+					//----------------
+					else if (part->mFlags.get_bit(WFXParticle::FLAG_FADEIN))
+					{
+						part->mAlpha += particleFade;
+						if (part->mAlpha>=mColor[3])
+						{
+							part->mFlags.clear_bit(WFXParticle::FLAG_FADEIN);
+							part->mAlpha = mColor[3];
+						}
+					}
+				}
+			}
+
+			// Keep Track Of The Number Of Particles To Render
+			//-------------------------------------------------
+			if (part->mFlags.get_bit(WFXParticle::FLAG_RENDER))
+			{
+				mParticleCountRender ++;
+			}
+		}
+		mPopulated = true;
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Render - 
+	////////////////////////////////////////////////////////////////////////////////////
+	void		Render()
+	{
+		WFXParticle*	part=0;
+		int			particleNum;
+		CVec3		partDirection;
+
+
+		// Set The GL State And Image Binding
+		//------------------------------------
+		GL_State((mBlendMode==0)?(GLS_ALPHA):(GLS_SRCBLEND_ONE | GLS_DSTBLEND_ONE));
+		GL_Bind(mImage);
+
+
+		// Enable And Disable Things
+		//---------------------------
+#ifdef _XBOX	// Simpler pointsprite setup on Xbox
+		if (mGLModeEnum==GL_POINTS)
+		{
+			pointBegin(mParticleCountRender, mWidth);
+		}
+#else
+		if (mGLModeEnum==GL_POINTS && qglPointParameteriNV)
+		{
+			qglEnable(GL_POINT_SPRITE_NV);
+
+			qglPointSize(mWidth);
+			qglPointParameterfEXT( GL_POINT_SIZE_MIN_EXT, 4.0f );
+			qglPointParameterfEXT( GL_POINT_SIZE_MAX_EXT, 2047.0f );
+
+			qglTexEnvi(GL_POINT_SPRITE_NV, GL_COORD_REPLACE_NV, GL_TRUE);
+		}
+#endif
+		else
+		{
+			qglEnable(GL_TEXTURE_2D);
+			qglDisable(GL_CULL_FACE);
+
+			qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, (mFilterMode==0)?(GL_LINEAR):(GL_NEAREST));
+			qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, (mFilterMode==0)?(GL_LINEAR):(GL_NEAREST));
+
+
+			// Setup Matrix Mode And Translation
+			//-----------------------------------
+			qglMatrixMode(GL_MODELVIEW);
+			qglPushMatrix();
+
+#ifdef _XBOX
+			qglBeginEXT(mGLModeEnum, mParticleCountRender*mVertexCount, mParticleCountRender, 0, mParticleCountRender*mVertexCount, 0);
+#endif
+		}
+
+		// Begin
+		//-------
+#ifndef _XBOX
+		qglBegin(mGLModeEnum);
+#endif
+		for (particleNum=0; particleNum<mParticleCount; particleNum++)
+		{
+			part = &(mParticles[particleNum]);
+			if (!part->mFlags.get_bit(WFXParticle::FLAG_RENDER))
+			{
+				continue;
+			}
+
+			// If Oriented With Velocity, We Want To Calculate Vertx Offsets Differently For Each Particle
+			//---------------------------------------------------------------------------------------------
+			if (mOrientWithVelocity)
+			{
+				partDirection = part->mVelocity;
+				VectorNormalize(partDirection.v);
+				mCameraDown = partDirection;
+				mCameraDown *= (mHeight * -1);
+				if (mVertexCount==4)
+				{
+		 			mCameraLeftPlusUp  = (mCameraLeft - mCameraDown);
+					mCameraLeftMinusUp = (mCameraLeft + mCameraDown);
+				}
+				else
+				{
+					mCameraLeftPlusUp  = (mCameraDown + mCameraLeft);
+				}
+			}
+
+			// Blend Mode Zero -> Apply Alpha Just To Alpha Channel
+			//------------------------------------------------------
+			if (mBlendMode==0)
+			{
+				qglColor4f(mColor[0], mColor[1], mColor[2], part->mAlpha);
+			}
+
+			// Otherwise Apply Alpha To All Channels
+			//---------------------------------------
+			else
+			{
+				qglColor4f(mColor[0]*part->mAlpha, mColor[1]*part->mAlpha, mColor[2]*part->mAlpha, mColor[3]*part->mAlpha);
+			}
+
+			// Render A Point
+			//----------------
+			if (mGLModeEnum==GL_POINTS)
+			{
+				qglVertex3fv(part->mPosition.v);
+			}
+
+			// Render A Triangle
+			//-------------------
+			else if (mVertexCount==3)
+			{
+ 				qglTexCoord2f(1.0, 0.0);
+				qglVertex3f(part->mPosition[0],
+							part->mPosition[1],
+							part->mPosition[2]);
+
+				qglTexCoord2f(0.0, 1.0);
+				qglVertex3f(part->mPosition[0] + mCameraLeft[0],
+							part->mPosition[1] + mCameraLeft[1],
+							part->mPosition[2] + mCameraLeft[2]);
+				
+				qglTexCoord2f(0.0, 0.0);
+				qglVertex3f(part->mPosition[0] + mCameraLeftPlusUp[0],
+							part->mPosition[1] + mCameraLeftPlusUp[1],
+							part->mPosition[2] + mCameraLeftPlusUp[2]);
+			}
+
+			// Render A Quad
+			//---------------
+			else
+			{
+				// Left bottom.
+				qglTexCoord2f( 0.0, 0.0 );
+				qglVertex3f(part->mPosition[0] - mCameraLeftMinusUp[0],
+							part->mPosition[1] - mCameraLeftMinusUp[1],
+							part->mPosition[2] - mCameraLeftMinusUp[2] );
+
+				// Right bottom.
+				qglTexCoord2f( 1.0, 0.0 );
+				qglVertex3f(part->mPosition[0] - mCameraLeftPlusUp[0],
+							part->mPosition[1] - mCameraLeftPlusUp[1],
+							part->mPosition[2] - mCameraLeftPlusUp[2] );
+
+				// Right top.
+				qglTexCoord2f( 1.0, 1.0 );
+				qglVertex3f(part->mPosition[0] + mCameraLeftMinusUp[0],
+							part->mPosition[1] + mCameraLeftMinusUp[1],
+							part->mPosition[2] + mCameraLeftMinusUp[2] );
+
+				// Left top.
+				qglTexCoord2f( 0.0, 1.0 );
+				qglVertex3f(part->mPosition[0] + mCameraLeftPlusUp[0],
+							part->mPosition[1] + mCameraLeftPlusUp[1], 
+							part->mPosition[2] + mCameraLeftPlusUp[2] );
+			}
+		}
+		qglEnd();
+
+		if (mGLModeEnum==GL_POINTS)
+		{
+#ifdef _XBOX
+			pointEnd();
+#else
+			qglDisable(GL_POINT_SPRITE_NV);
+			qglTexEnvi(GL_POINT_SPRITE_NV, GL_COORD_REPLACE_NV, GL_FALSE);
+#endif
+		}
+		else
+		{
+			qglEnable(GL_CULL_FACE);
+			qglPopMatrix();
+		}
+
+		mParticlesRendered += mParticleCountRender;
+	}
+};
+ratl::vector_vs<CParticleCloud, MAX_PARTICLE_CLOUDS>	mParticleClouds;
+
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Init World Effects - Will Iterate Over All Particle Clouds, Clear Them Out, And Erase
+////////////////////////////////////////////////////////////////////////////////////////
+void R_InitWorldEffects(void)
+{
+	for (int i=0; i<mParticleClouds.size(); i++)
+	{
+		mParticleClouds[i].Reset();
+	}
+	mParticleClouds.clear();
+	mWindZones.clear();
+	mLocalWindZones.clear();
+	mOutside.Reset();
+	mGlobalWindSpeed = 0.0f;
+	mGlobalWindDirection[0]=1.0f;
+	mGlobalWindDirection[1]=0.0f;
+	mGlobalWindDirection[2]=0.0f;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Init World Effects - Will Iterate Over All Particle Clouds, Clear Them Out, And Erase
+////////////////////////////////////////////////////////////////////////////////////////
+void R_ShutdownWorldEffects(void)
+{
+	R_InitWorldEffects();
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// RB_RenderWorldEffects - If any particle clouds exist, this will update and render them
+////////////////////////////////////////////////////////////////////////////////////////
+void RB_RenderWorldEffects(void)
+{
+	if (!tr.world || 
+		(tr.refdef.rdflags & RDF_NOWORLDMODEL) || 
+		(backEnd.refdef.rdflags & RDF_SKYBOXPORTAL) || 
+		!mParticleClouds.size() ||
+		CL_IsRunningInGameCinematic()) 
+	{	//  no world rendering or no world or no particle clouds
+		return;
+	}
+
+	SetViewportAndScissor();
+	qglMatrixMode(GL_MODELVIEW);
+	qglLoadMatrixf(backEnd.viewParms.world.modelMatrix);
+
+
+	// Calculate Elapsed Time For Scale Purposes
+	//-------------------------------------------
+	mMillisecondsElapsed = backEnd.refdef.frametime;
+	if (mMillisecondsElapsed<1)
+	{
+		mMillisecondsElapsed = 1.0f;
+	}
+	if (mMillisecondsElapsed>1000.0f)
+	{
+		mMillisecondsElapsed = 1000.0f;
+	}
+	mSecondsElapsed = (mMillisecondsElapsed / 1000.0f);
+
+
+	// Make Sure We Are Always Outside Cached
+	//----------------------------------------
+	if (!mOutside.Initialized())
+	{
+		mOutside.Cache();
+	}
+	else
+	{
+		// Update All Wind Zones
+		//-----------------------
+		if (!mFrozen)
+		{
+			mGlobalWindVelocity.Clear();
+			for (int wz=0; wz<mWindZones.size(); wz++)
+			{
+				mWindZones[wz].Update();
+				if (mWindZones[wz].mGlobal)
+				{
+					mGlobalWindVelocity += mWindZones[wz].mCurrentVelocity;
+				}
+			}
+			mGlobalWindDirection	= mGlobalWindVelocity;
+			mGlobalWindSpeed		= VectorNormalize(mGlobalWindDirection.v);
+		}
+
+		// Update All Particle Clouds
+		//----------------------------
+		mParticlesRendered = 0;
+		for (int i=0; i<mParticleClouds.size(); i++)
+		{
+			mParticleClouds[i].Update();
+			mParticleClouds[i].Render();
+		}
+		if (false)
+		{
+			Com_Printf( "Weather: %d Particles Rendered\n", mParticlesRendered);
+		}
+	}
+}
+
+
+void R_WorldEffect_f(void)
+{
+	if (Cvar_VariableIntegerValue("helpUsObi"))
+	{
+		char	temp[2048];
+		Cmd_ArgsBuffer(temp, sizeof(temp));
+		R_WorldEffectCommand(temp);
+	}
+}
+
+void R_WorldEffectCommand(const char *command)
+{
+	if ( !command )
+	{
+		return;
+	}
+
+	const char	*token;//, *origCommand;
+
+	token = COM_ParseExt(&command, qfalse);
+
+	if ( !token )
+	{
+		return;
+	}
+
+
+	// Clear - Removes All Particle Clouds And Wind Zones
+	//----------------------------------------------------
+	if (strcmpi(token, "clear") == 0)
+	{
+		for (int p=0; p<mParticleClouds.size(); p++)
+		{
+			mParticleClouds[p].Reset();
+		}
+		mParticleClouds.clear();
+		mWindZones.clear();
+		mLocalWindZones.clear();
+	}
+
+	// Freeze / UnFreeze - Stops All Particle Motion Updates
+	//--------------------------------------------------------
+	else if (strcmpi(token, "freeze") == 0)
+	{
+		mFrozen = !mFrozen;
+	}
+
+	// Add a zone
+	//---------------
+	else if (strcmpi(token, "zone") == 0)
+	{
+		vec3_t	mins;
+		vec3_t	maxs;
+		if (ParseVector(&command, 3, mins) && ParseVector(&command, 3, maxs))
+		{
+			mOutside.AddWeatherZone(mins, maxs);
+		}
+	}
+
+	// Basic Wind
+	//------------
+	else if (strcmpi(token, "wind") == 0)
+	{
+		if (mWindZones.full())
+		{
+			return;
+		}
+		CWindZone& nWind = mWindZones.push_back();
+		nWind.Initialize();
+	}
+
+	// Constant Wind
+	//---------------
+	else if (strcmpi(token, "constantwind") == 0)
+	{
+		if (mWindZones.full())
+		{
+			return;
+		}
+		CWindZone& nWind = mWindZones.push_back();
+		nWind.Initialize();
+		if (!ParseVector(&command, 3, nWind.mCurrentVelocity.v))
+		{
+			nWind.mCurrentVelocity.Clear();
+			nWind.mCurrentVelocity[1] = 800.0f;
+		}
+		nWind.mTargetVelocityTimeRemaining = -1;
+	}
+
+	// Gusting Wind
+	//--------------
+	else if (strcmpi(token, "gustingwind") == 0)
+	{
+		if (mWindZones.full())
+		{
+			return;
+		}
+		CWindZone& nWind = mWindZones.push_back();
+		nWind.Initialize();
+		nWind.mRVelocity.mMins				= -3000.0f;
+		nWind.mRVelocity.mMins[2]			= -100.0f;
+		nWind.mRVelocity.mMaxs				=  3000.0f;
+		nWind.mRVelocity.mMaxs[2]			=  100.0f;
+
+		nWind.mMaxDeltaVelocityPerUpdate	=  10.0f;
+
+		nWind.mRDuration.mMin				=  1000;
+		nWind.mRDuration.mMax				=  3000;
+
+		nWind.mChanceOfDeadTime				=  0.5f;
+		nWind.mRDeadTime.mMin				=  2000;
+		nWind.mRDeadTime.mMax				=  4000;
+	}
+
+	// Local Wind Zone
+	//-----------------
+	else if (strcmpi(token, "windzone") == 0)
+	{
+		if (mWindZones.full())
+		{
+			return;
+		}
+		CWindZone& nWind = mWindZones.push_back();
+		nWind.Initialize();
+
+		nWind.mGlobal = false;
+
+		// Read Mins
+		if (!ParseVector(&command, 3, nWind.mRBounds.mMins.v))
+		{
+			assert("Wind Zone: Unable To Parse Mins Vector!"==0);
+			mWindZones.pop_back();
+			return;
+		}
+
+		// Read Maxs
+		if (!ParseVector(&command, 3, nWind.mRBounds.mMaxs.v))
+		{
+			assert("Wind Zone: Unable To Parse Maxs Vector!"==0);
+			mWindZones.pop_back();
+			return;
+		}
+
+		// Read Velocity
+		if (!ParseVector(&command, 3, nWind.mCurrentVelocity.v))
+		{
+			nWind.mCurrentVelocity.Clear();
+			nWind.mCurrentVelocity[1] = 800.0f;
+		}
+		nWind.mTargetVelocityTimeRemaining = -1;
+
+		mLocalWindZones.push_back(&nWind);
+	}
+
+
+	// Create A Rain Storm
+	//---------------------
+	else if (strcmpi(token, "lightrain") == 0)
+	{
+		if (mParticleClouds.full())
+		{
+			return;
+		}
+		CParticleCloud& nCloud = mParticleClouds.push_back();
+		nCloud.Initialize(500, "gfx/world/rain.jpg", 3);
+		nCloud.mHeight		= 80.0f;
+		nCloud.mWidth		= 1.2f;
+		nCloud.mGravity		= 2000.0f;
+		nCloud.mFilterMode	= 1;
+		nCloud.mBlendMode	= 1;
+		nCloud.mFade		= 100.0f;
+		nCloud.mColor		= 0.5f;
+		nCloud.mOrientWithVelocity = true;
+		nCloud.mWaterParticles = true;
+	}
+
+	// Create A Rain Storm
+	//---------------------
+	else if (strcmpi(token, "rain") == 0)
+	{
+		if (mParticleClouds.full())
+		{
+			return;
+		}
+		CParticleCloud& nCloud = mParticleClouds.push_back();
+		nCloud.Initialize(1000, "gfx/world/rain.jpg", 3);
+		nCloud.mHeight		= 80.0f;
+		nCloud.mWidth		= 1.2f;
+		nCloud.mGravity		= 2000.0f;
+		nCloud.mFilterMode	= 1;
+		nCloud.mBlendMode	= 1;
+		nCloud.mFade		= 100.0f;
+		nCloud.mColor		= 0.5f;
+		nCloud.mOrientWithVelocity = true;
+		nCloud.mWaterParticles = true;
+	}
+
+	// Create A Rain Storm
+	//---------------------
+	else if (strcmpi(token, "acidrain") == 0)
+	{
+		if (mParticleClouds.full())
+		{
+			return;
+		}
+		CParticleCloud& nCloud = mParticleClouds.push_back();
+		nCloud.Initialize(1000, "gfx/world/rain.jpg", 3);
+		nCloud.mHeight		= 80.0f;
+		nCloud.mWidth		= 2.0f;
+		nCloud.mGravity		= 2000.0f;
+		nCloud.mFilterMode	= 1;
+		nCloud.mBlendMode	= 1;
+		nCloud.mFade		= 100.0f;
+		
+		nCloud.mColor[0]	= 0.34f;
+		nCloud.mColor[1]	= 0.70f;
+		nCloud.mColor[2]	= 0.34f;
+		nCloud.mColor[3]	= 0.70f;
+
+		nCloud.mOrientWithVelocity = true;
+		nCloud.mWaterParticles = true;
+
+		mOutside.mOutsidePain = 0.1f;
+	}
+
+	// Create A Rain Storm
+	//---------------------
+	else if (strcmpi(token, "heavyrain") == 0)
+	{
+		if (mParticleClouds.full())
+		{
+			return;
+		}
+		CParticleCloud& nCloud = mParticleClouds.push_back();
+		nCloud.Initialize(1000, "gfx/world/rain.jpg", 3);
+		nCloud.mHeight		= 80.0f;
+		nCloud.mWidth		= 1.2f;
+		nCloud.mGravity		= 2800.0f;
+		nCloud.mFilterMode	= 1;
+		nCloud.mBlendMode	= 1;
+		nCloud.mFade		= 15.0f;
+		nCloud.mColor		= 0.5f;
+		nCloud.mOrientWithVelocity = true;
+		nCloud.mWaterParticles = true;
+	}
+
+	// Create A Snow Storm
+	//---------------------
+	else if (strcmpi(token, "snow") == 0)
+	{
+		if (mParticleClouds.full())
+		{
+			return;
+		}
+		CParticleCloud& nCloud = mParticleClouds.push_back();
+#ifdef _XBOX
+		nCloud.Initialize(1000, "gfx/effects/snowflake1.bmp", 1);
+#else
+		nCloud.Initialize(1000, "gfx/effects/snowflake1.bmp");
+#endif
+		nCloud.mBlendMode			= 1;
+		nCloud.mRotationChangeNext	= 0;
+		nCloud.mColor		= 0.75f;
+		nCloud.mWaterParticles = true;
+#ifdef _XBOX
+		nCloud.mWidth = 0.05f;
+#endif
+	}
+
+	// Create A Some stuff
+	//---------------------
+	else if (strcmpi(token, "spacedust") == 0)
+	{
+		int count;
+		if (mParticleClouds.full())
+		{
+			return;
+		}
+		token = COM_ParseExt(&command, qfalse);
+		count = atoi(token);
+
+		CParticleCloud& nCloud = mParticleClouds.push_back();
+		nCloud.Initialize(count, "gfx/effects/snowpuff1.tga");
+		nCloud.mHeight		= 1.2f;
+		nCloud.mWidth		= 1.2f;
+		nCloud.mGravity		= 0.0f;
+		nCloud.mBlendMode			= 1;
+		nCloud.mRotationChangeNext	= 0;
+		nCloud.mColor		= 0.75f;
+		nCloud.mWaterParticles = true;
+		nCloud.mMass.mMax	= 30.0f;
+		nCloud.mMass.mMin	= 10.0f;
+		nCloud.mSpawnRange.mMins[0]	= -1500.0f;
+		nCloud.mSpawnRange.mMins[1]	= -1500.0f;
+		nCloud.mSpawnRange.mMins[2]	= -1500.0f;
+		nCloud.mSpawnRange.mMaxs[0]	= 1500.0f;
+		nCloud.mSpawnRange.mMaxs[1]	= 1500.0f;
+		nCloud.mSpawnRange.mMaxs[2]	= 1500.0f;
+	}
+
+	// Create A Sand Storm
+	//---------------------
+	else if (strcmpi(token, "sand") == 0)
+	{
+		if (mParticleClouds.full())
+		{
+			return;
+		}
+		CParticleCloud& nCloud = mParticleClouds.push_back();
+		nCloud.Initialize(400, "gfx/effects/alpha_smoke2b.tga");
+
+		nCloud.mGravity		= 0;
+ 		nCloud.mWidth		= 70;
+		nCloud.mHeight		= 70;
+		nCloud.mColor[0]	= 0.9f;
+		nCloud.mColor[1]	= 0.6f;
+		nCloud.mColor[2]	= 0.0f;
+		nCloud.mColor[3]	= 0.5f;
+		nCloud.mFade		= 5.0f;
+		nCloud.mMass.mMax	= 30.0f;
+		nCloud.mMass.mMin	= 10.0f;
+		nCloud.mSpawnRange.mMins[2]	= -150;
+		nCloud.mSpawnRange.mMaxs[2]	= 150;
+
+		nCloud.mRotationChangeNext	= 0;
+	}
+
+	// Create Blowing Clouds Of Fog
+	//------------------------------
+	else if (strcmpi(token, "fog") == 0)
+	{
+		if (mParticleClouds.full())
+		{
+			return;
+		}
+		CParticleCloud& nCloud = mParticleClouds.push_back();
+		nCloud.Initialize(60, "gfx/effects/alpha_smoke2b.tga");
+		nCloud.mBlendMode	= 1;
+		nCloud.mGravity		= 0;
+ 		nCloud.mWidth		= 70;
+		nCloud.mHeight		= 70;
+		nCloud.mColor		= 0.2f;
+		nCloud.mFade		= 5.0f;
+		nCloud.mMass.mMax	= 30.0f;
+		nCloud.mMass.mMin	= 10.0f;
+		nCloud.mSpawnRange.mMins[2]	= -150;
+		nCloud.mSpawnRange.mMaxs[2]	= 150;
+
+		nCloud.mRotationChangeNext	= 0;
+	}
+
+	// Create Heavy Rain Particle Cloud
+	//-----------------------------------
+	else if (strcmpi(token, "heavyrainfog") == 0)
+	{
+		if (mParticleClouds.full())
+		{
+			return;
+		}
+		CParticleCloud& nCloud = mParticleClouds.push_back();
+ 		nCloud.Initialize(70, "gfx/effects/alpha_smoke2b.tga");
+		nCloud.mBlendMode	= 1;
+		nCloud.mGravity		= 0;
+ 		nCloud.mWidth		= 100;
+		nCloud.mHeight		= 100;
+		nCloud.mColor		= 0.3f;
+		nCloud.mFade		= 1.0f;
+		nCloud.mMass.mMax	= 10.0f;
+		nCloud.mMass.mMin	= 5.0f;
+
+		nCloud.mSpawnRange.mMins	= -(nCloud.mSpawnPlaneDistance*1.25f);
+		nCloud.mSpawnRange.mMaxs	=  (nCloud.mSpawnPlaneDistance*1.25f);
+		nCloud.mSpawnRange.mMins[2]	= -150;
+		nCloud.mSpawnRange.mMaxs[2]	=  150;
+
+		nCloud.mRotationChangeNext	= 0;
+	}
+
+	// Create Blowing Clouds Of Fog
+	//------------------------------
+	else if (strcmpi(token, "light_fog") == 0)
+	{
+		if (mParticleClouds.full())
+		{
+			return;
+		}
+		CParticleCloud& nCloud = mParticleClouds.push_back();
+		nCloud.Initialize(40, "gfx/effects/alpha_smoke2b.tga");
+		nCloud.mBlendMode	= 1;
+		nCloud.mGravity		= 0;
+ 		nCloud.mWidth		= 100;
+		nCloud.mHeight		= 100;
+		nCloud.mColor[0]	= 0.19f;
+		nCloud.mColor[1]	= 0.6f;
+		nCloud.mColor[2]	= 0.7f;
+		nCloud.mColor[3]	= 0.12f;
+		nCloud.mFade		= 0.10f;
+		nCloud.mMass.mMax	= 30.0f;
+		nCloud.mMass.mMin	= 10.0f;
+		nCloud.mSpawnRange.mMins[2]	= -150;
+		nCloud.mSpawnRange.mMaxs[2]	= 150;
+
+		nCloud.mRotationChangeNext	= 0;
+	}
+	else if (strcmpi(token, "outsideshake") == 0)
+	{
+		mOutside.mOutsideShake = !mOutside.mOutsideShake;
+	}
+	else if (strcmpi(token, "outsidepain") == 0)
+	{
+		mOutside.mOutsidePain = !mOutside.mOutsidePain;
+	}
+	else
+	{
+		Com_Printf( "Weather Effect: Please enter a valid command.\n" );
+		Com_Printf( "	clear\n" );
+		Com_Printf( "	freeze\n" );
+		Com_Printf( "	zone (mins) (maxs)\n" );
+		Com_Printf( "	wind\n" );
+		Com_Printf( "	constantwind (velocity)\n" );
+		Com_Printf( "	gustingwind\n" );
+		Com_Printf( "	windzone (mins) (maxs) (velocity)\n" );
+		Com_Printf( "	lightrain\n" );
+		Com_Printf( "	rain\n" );
+		Com_Printf( "	acidrain\n" );
+		Com_Printf( "	heavyrain\n" );
+		Com_Printf( "	snow\n" );
+		Com_Printf( "	spacedust\n" );
+		Com_Printf( "	sand\n" );
+		Com_Printf( "	fog\n" );
+		Com_Printf( "	heavyrainfog\n" );
+		Com_Printf( "	light_fog\n" );
+		Com_Printf( "	outsideshake\n" );
+		Com_Printf( "	outsidepain\n" );
+	}
+}
+
+
+
+
+float R_GetChanceOfSaberFizz()
+{
+ 	float	chance = 0.0f;
+	int		numWater = 0;
+	for (int i=0; i<mParticleClouds.size(); i++)
+	{
+		if (mParticleClouds[i].mWaterParticles)
+		{
+			chance += (mParticleClouds[i].mGravity/20000.0f);
+			numWater ++;
+		}
+	}
+	if (numWater)
+	{
+		return (chance / numWater);
+	}
+	return 0.0f;
+}
+
+bool R_IsRaining()
+{
+	return !mParticleClouds.empty();
+}
+
+bool R_IsPuffing()
+{
+	return false;
+}
+
+
+
+
diff --git a/code/renderer/tr_WorldEffects.h b/code/renderer/tr_WorldEffects.h
new file mode 100644
index 0000000..3175685
--- /dev/null
+++ b/code/renderer/tr_WorldEffects.h
@@ -0,0 +1,43 @@
+////////////////////////////////////////////////////////////////////////////////////////
+// RAVEN SOFTWARE - STAR WARS: JK II
+//  (c) 2002 Activision
+//
+// World Effects
+//
+////////////////////////////////////////////////////////////////////////////////////////
+#pragma once
+#if !defined __TR_WORLDEFFECTS_H
+#define __TR_WORLDEFFECTS_H
+
+#include "../game/q_shared.h"		// For Vec3_t
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Supported Commands
+////////////////////////////////////////////////////////////////////////////////////////
+void R_AddWeatherZone(vec3_t mins, vec3_t maxs);
+
+void R_InitWorldEffects(void);
+void R_ShutdownWorldEffects(void);
+void RB_RenderWorldEffects(void);
+
+void R_WorldEffectCommand(const char *command);
+void R_WorldEffect_f(void);
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Exported Functionality
+////////////////////////////////////////////////////////////////////////////////////////
+bool R_GetWindVector(vec3_t windVector, vec3_t atpoint);
+bool R_GetWindSpeed(float &windSpeed, vec3_t atpoint);
+bool R_GetWindGusting(vec3_t atpoint);
+bool R_IsOutside(vec3_t pos);
+float R_IsOutsideCausingPain(vec3_t pos);
+float R_GetChanceOfSaberFizz();
+bool R_IsShaking(vec3_t pos);
+bool R_SetTempGlobalFogColor(vec3_t color);
+
+bool R_IsRaining();
+bool R_IsPuffing();
+
+
+#endif // __TR_WORLDEFFECTS_H
diff --git a/code/renderer/tr_animation.cpp b/code/renderer/tr_animation.cpp
new file mode 100644
index 0000000..d722645
--- /dev/null
+++ b/code/renderer/tr_animation.cpp
@@ -0,0 +1,478 @@
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+
+#include "tr_local.h"
+#include "MatComp.h"
+
+#ifdef VV_LIGHTING
+#include "tr_lightmanager.h"
+#endif
+
+extern int R_ComputeLOD( trRefEntity_t *ent );
+
+/*
+
+All bones should be an identity orientation to display the mesh exactly
+as it is specified.
+
+For all other frames, the bones represent the transformation from the 
+orientation of the bone in the base frame to the orientation in this
+frame.
+
+*/
+
+
+/*
+=============
+R_ACullModel
+=============
+*/
+static int R_ACullModel( md4Header_t *header, trRefEntity_t *ent ) {
+	vec3_t		bounds[2];
+	md4Frame_t	*oldFrame, *newFrame;
+	int			i;
+	int			frameSize;
+	// compute frame pointers
+
+	if (header->ofsFrames<0) // Compressed
+	{
+		frameSize = (int)( &((md4CompFrame_t *)0)->bones[ tr.currentModel->md4->numBones ] );		
+		newFrame = (md4Frame_t *)((byte *)header - header->ofsFrames + ent->e.frame * frameSize );
+		oldFrame = (md4Frame_t *)((byte *)header - header->ofsFrames + ent->e.oldframe * frameSize );
+		// HACK! These frames actually are md4CompFrames, but the first fields are the same, 
+		// so this will work for this routine.
+	}
+	else
+	{
+		frameSize = (int)( &((md4Frame_t *)0)->bones[ tr.currentModel->md4->numBones ] );		
+		newFrame = (md4Frame_t *)((byte *)header + header->ofsFrames + ent->e.frame * frameSize );
+		oldFrame = (md4Frame_t *)((byte *)header + header->ofsFrames + ent->e.oldframe * frameSize );
+	}
+
+	// cull bounding sphere ONLY if this is not an upscaled entity
+	if ( !ent->e.nonNormalizedAxes )
+	{
+		if ( ent->e.frame == ent->e.oldframe )
+		{
+			switch ( R_CullLocalPointAndRadius( newFrame->localOrigin, newFrame->radius ) )
+			{
+			case CULL_OUT:
+				tr.pc.c_sphere_cull_md3_out++;
+				return CULL_OUT;
+
+			case CULL_IN:
+				tr.pc.c_sphere_cull_md3_in++;
+				return CULL_IN;
+
+			case CULL_CLIP:
+				tr.pc.c_sphere_cull_md3_clip++;
+				break;
+			}
+		}
+		else
+		{
+			int sphereCull, sphereCullB;
+
+			sphereCull  = R_CullLocalPointAndRadius( newFrame->localOrigin, newFrame->radius );
+			if ( newFrame == oldFrame ) {
+				sphereCullB = sphereCull;
+			} else {
+				sphereCullB = R_CullLocalPointAndRadius( oldFrame->localOrigin, oldFrame->radius );
+			}
+
+			if ( sphereCull == sphereCullB )
+			{
+				if ( sphereCull == CULL_OUT )
+				{
+					tr.pc.c_sphere_cull_md3_out++;
+					return CULL_OUT;
+				}
+				else if ( sphereCull == CULL_IN )
+				{
+					tr.pc.c_sphere_cull_md3_in++;
+					return CULL_IN;
+				}
+				else
+				{
+					tr.pc.c_sphere_cull_md3_clip++;
+				}
+			}
+		}
+	}
+	
+	// calculate a bounding box in the current coordinate system
+	for (i = 0 ; i < 3 ; i++) {
+		bounds[0][i] = oldFrame->bounds[0][i] < newFrame->bounds[0][i] ? oldFrame->bounds[0][i] : newFrame->bounds[0][i];
+		bounds[1][i] = oldFrame->bounds[1][i] > newFrame->bounds[1][i] ? oldFrame->bounds[1][i] : newFrame->bounds[1][i];
+	}
+
+	switch ( R_CullLocalBox( bounds ) )
+	{
+	case CULL_IN:
+		tr.pc.c_box_cull_md3_in++;
+		return CULL_IN;
+	case CULL_CLIP:
+		tr.pc.c_box_cull_md3_clip++;
+		return CULL_CLIP;
+	case CULL_OUT:
+	default:
+		tr.pc.c_box_cull_md3_out++;
+		return CULL_OUT;
+	}
+}
+
+
+/*
+=================
+R_AComputeFogNum
+
+=================
+*/
+static int R_AComputeFogNum( md4Header_t *header, trRefEntity_t *ent ) {
+	int				i;
+	fog_t			*fog;
+	md4Frame_t		*frame;
+	vec3_t			localOrigin;
+	int				frameSize;
+
+	if ( tr.refdef.rdflags & RDF_NOWORLDMODEL ) {
+		return 0;
+	}
+
+
+	if (header->ofsFrames<0) // Compressed
+	{
+		frameSize = (int)( &((md4CompFrame_t *)0)->bones[ header->numBones ] );		
+		frame = (md4Frame_t *)((byte *)header - header->ofsFrames + ent->e.frame * frameSize );
+		// HACK! These frames actually are md4CompFrames, but the first fields are the same, 
+		// so this will work for this routine.
+	}
+	else
+	{
+		frameSize = (int)( &((md4Frame_t *)0)->bones[ header->numBones ] );		
+		frame = (md4Frame_t *)((byte *)header + header->ofsFrames + ent->e.frame * frameSize );
+	}
+
+	VectorAdd( ent->e.origin, frame->localOrigin, localOrigin );
+	int partialFog = 0;
+	for ( i = 1 ; i < tr.world->numfogs ; i++ ) {
+		fog = &tr.world->fogs[i];
+		if ( localOrigin[0] - frame->radius >= fog->bounds[0][0] 
+			&& localOrigin[0] + frame->radius <= fog->bounds[1][0] 
+			&& localOrigin[1] - frame->radius >= fog->bounds[0][1]
+			&& localOrigin[1] + frame->radius <= fog->bounds[1][1] 
+			&& localOrigin[2] - frame->radius >= fog->bounds[0][2]
+			&& localOrigin[2] + frame->radius <= fog->bounds[1][2] ) 
+		{//totally inside it
+			return i;
+			break;
+		}
+		if ( ( localOrigin[0] - frame->radius >= fog->bounds[0][0] && localOrigin[1] - frame->radius >= fog->bounds[0][1] && localOrigin[2] - frame->radius >= fog->bounds[0][2] &&
+			localOrigin[0] - frame->radius <= fog->bounds[1][0] && localOrigin[1] - frame->radius <= fog->bounds[1][1] && localOrigin[2] - frame->radius <= fog->bounds[1][2] ) || 
+			( localOrigin[0] + frame->radius >= fog->bounds[0][0] && localOrigin[1] + frame->radius >= fog->bounds[0][1] && localOrigin[2] + frame->radius >= fog->bounds[0][2] &&
+			localOrigin[0] + frame->radius <= fog->bounds[1][0] && localOrigin[1] + frame->radius <= fog->bounds[1][1] && localOrigin[2] + frame->radius <= fog->bounds[1][2] ) ) 
+		{//partially inside it
+			if ( tr.refdef.fogIndex == i || R_FogParmsMatch( tr.refdef.fogIndex, i ) )
+			{//take new one only if it's the same one that the viewpoint is in
+				return i;
+				break;
+			}
+			else if ( !partialFog )
+			{//first partialFog
+				partialFog = i;
+			}
+		}
+	}
+	//if all else fails, return the first partialFog
+	return partialFog;
+}
+
+/*
+==============
+R_AddAnimSurfaces
+==============
+*/
+void R_AddAnimSurfaces( trRefEntity_t *ent ) {
+	md4Header_t		*header;
+	md4Surface_t	*surface;
+	md4LOD_t		*lod;
+	shader_t		*shader = 0;
+	shader_t		*cust_shader = 0;
+	int				fogNum = 0;
+	qboolean		personalModel;
+	int				cull;
+	int				i, whichLod;
+
+	// don't add third_person objects if not in a portal
+	personalModel = (ent->e.renderfx & RF_THIRD_PERSON) && !tr.viewParms.isPortal;
+
+	if ( ent->e.renderfx & RF_CAP_FRAMES) {
+		if (ent->e.frame > tr.currentModel->md4->numFrames-1)
+			ent->e.frame = tr.currentModel->md4->numFrames-1;
+		if (ent->e.oldframe > tr.currentModel->md4->numFrames-1)
+			ent->e.oldframe = tr.currentModel->md4->numFrames-1;
+	}
+	else if ( ent->e.renderfx & RF_WRAP_FRAMES ) {
+		ent->e.frame %= tr.currentModel->md4->numFrames;
+		ent->e.oldframe %= tr.currentModel->md4->numFrames;
+	}
+
+	//
+	// Validate the frames so there is no chance of a crash.
+	// This will write directly into the entity structure, so
+	// when the surfaces are rendered, they don't need to be
+	// range checked again.
+	//
+	if ( (ent->e.frame >= tr.currentModel->md4->numFrames) 
+		|| (ent->e.frame < 0)
+		|| (ent->e.oldframe >= tr.currentModel->md4->numFrames)
+		|| (ent->e.oldframe < 0) ) 
+	{
+#ifdef _DEBUG
+			VID_Printf (PRINT_ALL, "R_AddAnimSurfaces: no such frame %d to %d for '%s'\n",
+#else
+			VID_Printf (PRINT_DEVELOPER, "R_AddAnimSurfaces: no such frame %d to %d for '%s'\n",				
+#endif
+			ent->e.oldframe, ent->e.frame,
+			tr.currentModel->name );
+			ent->e.frame = 0;
+			ent->e.oldframe = 0;
+	}
+
+	header = tr.currentModel->md4;
+
+	//
+	// cull the entire model if merged bounding box of both frames
+	// is outside the view frustum.
+	//
+	cull = R_ACullModel ( header, ent );
+	if ( cull == CULL_OUT ) {
+		return;
+	}
+
+	//
+	// compute LOD
+	//
+	lod = (md4LOD_t *)( (byte *)header + header->ofsLODs );
+	whichLod = R_ComputeLOD( ent );
+	for ( i = 0; i < whichLod; i++)
+	{
+		lod = (md4LOD_t*)( (byte *)lod + lod->ofsEnd );
+	}
+
+	//
+	// set up lighting now that we know we aren't culled
+	//
+	if ( !personalModel || r_shadows->integer > 1 ) {
+#ifdef VV_LIGHTING
+		VVLightMan.R_SetupEntityLighting( &tr.refdef, ent );
+#else
+		R_SetupEntityLighting( &tr.refdef, ent );
+#endif
+	}
+
+	//
+	// see if we are in a fog volume
+	//
+	fogNum = R_AComputeFogNum( header, ent );
+
+
+	//
+	// draw all surfaces
+	//
+	cust_shader = R_GetShaderByHandle( ent->e.customShader );
+
+
+	surface = (md4Surface_t *)( (byte *)lod + lod->ofsSurfaces );
+	for ( i = 0 ; i < lod->numSurfaces ; i++ ) {
+		if ( ent->e.customShader ) {
+			shader = cust_shader;
+		} else if ( ent->e.customSkin > 0 && ent->e.customSkin < tr.numSkins ) {
+			skin_t *skin;
+			int		j;
+			
+			skin = R_GetSkinByHandle( ent->e.customSkin );
+			
+			// match the surface name to something in the skin file
+			shader = tr.defaultShader;
+			for ( j = 0 ; j < skin->numSurfaces ; j++ ) {
+				// the names have both been lowercased
+				if ( !strcmp( skin->surfaces[j]->name, surface->name ) ) {
+					shader = skin->surfaces[j]->shader;
+					break;
+				}
+			}
+		} else {
+			shader = R_GetShaderByHandle( surface->shaderIndex );
+		}
+		// we will add shadows even if the main object isn't visible in the view
+
+		// stencil shadows can't do personal models unless I polyhedron clip
+		if ( !personalModel
+			&& r_shadows->integer == 2 
+#ifndef VV_LIGHTING
+			&& fogNum == 0
+#endif
+			&& (ent->e.renderfx & RF_SHADOW_PLANE )
+			&& !(ent->e.renderfx & ( RF_NOSHADOW | RF_DEPTHHACK ) ) 
+			&& shader->sort == SS_OPAQUE ) {
+			R_AddDrawSurf( (surfaceType_t *)surface, tr.shadowShader, 0, qfalse );
+		}
+
+		// projection shadows work fine with personal models
+		if ( r_shadows->integer == 3
+			&& fogNum == 0
+			&& (ent->e.renderfx & RF_SHADOW_PLANE )
+			&& shader->sort == SS_OPAQUE ) {
+			R_AddDrawSurf( (surfaceType_t *)surface, tr.projectionShadowShader, 0, qfalse );
+		}
+
+		// don't add third_person objects if not viewing through a portal
+		if ( !personalModel ) {
+			R_AddDrawSurf( (surfaceType_t *)surface, shader, fogNum, qfalse );
+		}
+
+		surface = (md4Surface_t *)( (byte *)surface + surface->ofsEnd );
+	}
+}
+
+
+/*
+==============
+RB_SurfaceAnim
+==============
+*/
+void RB_SurfaceAnim( md4Surface_t *surface ) {
+	int				i, j, k;
+	float			frontlerp, backlerp;
+	int				*triangles;
+	int				indexes;
+	int				baseIndex, baseVertex;
+	int				numVerts;
+	md4Vertex_t		*v;
+	md4Bone_t		bones[MD4_MAX_BONES];
+	md4Bone_t		tbone[2];
+	md4Bone_t		*bonePtr, *bone;
+	md4Header_t		*header;
+	md4Frame_t		*frame=0;
+	md4Frame_t		*oldFrame=0;
+	md4CompFrame_t	*cframe=0;
+	md4CompFrame_t	*coldFrame=0;
+	int				frameSize;
+	qboolean		compressed;
+
+
+	if (  backEnd.currentEntity->e.oldframe == backEnd.currentEntity->e.frame ) {
+		backlerp = 0;
+		frontlerp = 1;
+	} else  {
+		backlerp = backEnd.currentEntity->e.backlerp;
+		frontlerp = 1.0 - backlerp;
+	}
+	header = (md4Header_t *)((byte *)surface + surface->ofsHeader);
+
+	if (header->ofsFrames<0) // Compressed
+	{
+		compressed = qtrue;
+		frameSize = (int)( &((md4CompFrame_t *)0)->bones[ header->numBones ] );		
+		cframe = (md4CompFrame_t *)((byte *)header - header->ofsFrames + backEnd.currentEntity->e.frame * frameSize );
+		coldFrame = (md4CompFrame_t *)((byte *)header - header->ofsFrames + backEnd.currentEntity->e.oldframe * frameSize );
+	}
+	else
+	{
+		compressed = qfalse;
+		frameSize = (int)( &((md4Frame_t *)0)->bones[ header->numBones ] );
+		frame = (md4Frame_t *)((byte *)header + header->ofsFrames + 
+			backEnd.currentEntity->e.frame * frameSize );
+		oldFrame = (md4Frame_t *)((byte *)header + header->ofsFrames + 
+			backEnd.currentEntity->e.oldframe * frameSize );
+	}
+
+
+
+	RB_CheckOverflow( surface->numVerts, surface->numTriangles );
+
+	triangles = (int *) ((byte *)surface + surface->ofsTriangles);
+	indexes = surface->numTriangles * 3;
+	baseIndex = tess.numIndexes;
+	baseVertex = tess.numVertexes;
+	for (j = 0 ; j < indexes ; j++) {
+		tess.indexes[baseIndex + j] = baseVertex + triangles[j];
+	}
+	tess.numIndexes += indexes;
+
+	//
+	// lerp all the needed bones
+	//
+	if ( !backlerp && !compressed)
+		// no lerping needed
+		bonePtr = frame->bones;
+	else 
+	{
+		bonePtr = bones;
+		if (compressed)
+		{
+			for ( i = 0 ; i < header->numBones ; i++ ) 
+			{
+				if ( !backlerp )
+					MC_UnCompress(bonePtr[i].matrix,cframe->bones[i].Comp);
+				else
+				{
+					MC_UnCompress(tbone[0].matrix,cframe->bones[i].Comp);
+					MC_UnCompress(tbone[1].matrix,coldFrame->bones[i].Comp);
+					for ( j = 0 ; j < 12 ; j++ ) 
+						((float *)&bonePtr[i])[j] = frontlerp * ((float *)&tbone[0])[j]
+							+ backlerp * ((float *)&tbone[1])[j];
+				}
+			}
+		}
+		else
+		{
+			for ( i = 0 ; i < header->numBones*12 ; i++ ) 
+				((float *)bonePtr)[i] = frontlerp * ((float *)frame->bones)[i]
+					+ backlerp * ((float *)oldFrame->bones)[i];
+		}
+	}
+
+	//
+	// deform the vertexes by the lerped bones
+	//
+	numVerts = surface->numVerts;
+	v = (md4Vertex_t *) ((byte *)surface + surface->ofsVerts);
+	for ( j = 0; j < numVerts; j++ ) {
+		vec3_t	tempVert, tempNormal;
+		md4Weight_t	*w;
+
+		VectorClear( tempVert );
+		VectorClear( tempNormal );
+		w = v->weights;
+		for ( k = 0 ; k < v->numWeights ; k++, w++ ) {
+			bone = bonePtr + w->boneIndex;
+
+			tempVert[0] += w->boneWeight * ( DotProduct( bone->matrix[0], w->offset ) + bone->matrix[0][3] );
+			tempVert[1] += w->boneWeight * ( DotProduct( bone->matrix[1], w->offset ) + bone->matrix[1][3] );
+			tempVert[2] += w->boneWeight * ( DotProduct( bone->matrix[2], w->offset ) + bone->matrix[2][3] );
+
+			tempNormal[0] += w->boneWeight * DotProduct( bone->matrix[0], v->normal );
+			tempNormal[1] += w->boneWeight * DotProduct( bone->matrix[1], v->normal );
+			tempNormal[2] += w->boneWeight * DotProduct( bone->matrix[2], v->normal );
+		}
+
+		tess.xyz[baseVertex + j][0] = tempVert[0];
+		tess.xyz[baseVertex + j][1] = tempVert[1];
+		tess.xyz[baseVertex + j][2] = tempVert[2];
+
+		tess.normal[baseVertex + j][0] = tempNormal[0];
+		tess.normal[baseVertex + j][1] = tempNormal[1];
+		tess.normal[baseVertex + j][2] = tempNormal[2];
+
+		tess.texCoords[baseVertex + j][0][0] = v->texCoords[0];
+		tess.texCoords[baseVertex + j][0][1] = v->texCoords[1];
+
+		v = (md4Vertex_t *)&v->weights[v->numWeights];
+	}
+
+	tess.numVertexes += surface->numVerts;
+}
\ No newline at end of file
diff --git a/code/renderer/tr_arioche.cpp b/code/renderer/tr_arioche.cpp
new file mode 100644
index 0000000..038ae94
--- /dev/null
+++ b/code/renderer/tr_arioche.cpp
@@ -0,0 +1,149 @@
+#include "../server/exe_headers.h"
+
+#include "tr_local.h"
+#include "tr_worldeffects.h"
+
+// Patches up the loaded map to handle the parameters passed from the UI
+
+// Remap sky to contents of the cvar ar_sky
+// Grab sunlight properties from the indirected sky
+
+//void R_RemapShader(const char *shaderName, const char *newShaderName, const char *timeOffset);
+void R_ColorShiftLightingBytes( byte in[4], byte out[4] );
+
+void NormalToLatLong( const vec3_t normal, byte bytes[2] )
+{
+	// check for singularities
+	if (!normal[0] && !normal[1])
+	{
+		if ( normal[2] > 0.0f )
+		{
+			bytes[0] = 0;
+			bytes[1] = 0;		// lat = 0, long = 0
+		}
+		else
+		{
+			bytes[0] = 128;
+			bytes[1] = 0;		// lat = 0, long = 128
+		}
+	}
+	else
+	{
+		int	a, b;
+
+		a = (int)(RAD2DEG( (vec_t)atan2( normal[1], normal[0] ) ) * (255.0f / 360.0f ));
+		a &= 0xff;
+
+		b = (int)(RAD2DEG( (vec_t)acos( normal[2] ) ) * ( 255.0f / 360.0f ));
+		b &= 0xff;
+
+		bytes[0] = b;	// longitude
+		bytes[1] = a;	// lattitude
+	}
+}
+
+void R_RMGInit(void)
+{
+	char			newSky[MAX_QPATH];
+	char			newFog[MAX_QPATH];
+	shader_t		*sky;
+	shader_t		*fog;
+	fog_t			*gfog;
+	mgrid_t			*grid;
+	char			temp[MAX_QPATH];
+	int				i;
+	unsigned short	*pos;
+
+	Cvar_VariableStringBuffer("RMG_sky", newSky, MAX_QPATH);
+	// Get sunlight - this should set up all the sunlight data
+	sky = R_FindShader( newSky, lightmapsNone, stylesDefault, qfalse );
+
+	// Remap sky
+//	R_RemapShader("textures/tools/_sky", newSky, NULL);
+
+	// Fill in the lightgrid with sunlight
+	if(tr.world->lightGridData)
+	{
+#ifdef _XBOX
+		byte *memory = (byte *)tr.world->lightGridData;
+
+		byte *array;
+		array = memory;
+		memory += 3;
+
+		array[0] = (byte)Com_Clamp(0, 255, tr.sunAmbient[0] * 255.0f);
+		array[1] = (byte)Com_Clamp(0, 255, tr.sunAmbient[1] * 255.0f);
+		array[2] = (byte)Com_Clamp(0, 255, tr.sunAmbient[2] * 255.0f);
+		
+		array[3] = (byte)Com_Clamp(0, 255, tr.sunLight[0]);
+		array[4] = (byte)Com_Clamp(0, 255, tr.sunLight[1]);
+		array[5] = (byte)Com_Clamp(0, 255, tr.sunLight[2]);
+		
+		NormalToLatLong(tr.sunDirection, grid->latLong);
+#else // _XBOX
+		grid = tr.world->lightGridData;
+		grid->ambientLight[0][0] = (byte)Com_Clamp(0, 255, tr.sunAmbient[0] * 255.0f);
+		grid->ambientLight[0][1] = (byte)Com_Clamp(0, 255, tr.sunAmbient[1] * 255.0f);
+		grid->ambientLight[0][2] = (byte)Com_Clamp(0, 255, tr.sunAmbient[2] * 255.0f);
+		R_ColorShiftLightingBytes(grid->ambientLight[0], grid->ambientLight[0]);
+
+		grid->directLight[0][0] = (byte)Com_Clamp(0, 255, tr.sunLight[0]);
+		grid->directLight[0][1] = (byte)Com_Clamp(0, 255, tr.sunLight[1]);
+		grid->directLight[0][2] = (byte)Com_Clamp(0, 255, tr.sunLight[2]);
+		R_ColorShiftLightingBytes(grid->directLight[0], grid->directLight[0]);
+
+		NormalToLatLong(tr.sunDirection, grid->latLong);
+#endif // _XBOX
+
+		pos = tr.world->lightGridArray;
+		for(i=0;i<tr.world->numGridArrayElements;i++)
+		{
+			*pos = 0;
+			pos++;
+		}
+	}
+
+	// Override the global fog with the defined one
+	if(tr.world->globalFog != -1)
+	{
+		Cvar_VariableStringBuffer("RMG_fog", newFog, MAX_QPATH);
+		fog = R_FindShader( newFog, lightmapsNone, stylesDefault, qfalse);
+		if (fog != tr.defaultShader)
+		{
+			gfog = tr.world->fogs + tr.world->globalFog;
+			gfog->parms = *fog->fogParms;
+			if (gfog->parms.depthForOpaque)
+			{
+				gfog->tcScale = 1.0f / ( gfog->parms.depthForOpaque * 8.0f );
+				tr.distanceCull = gfog->parms.depthForOpaque;
+				Cvar_Set("RMG_distancecull", va("%f", tr.distanceCull));
+			}
+			else
+			{
+				gfog->tcScale = 1.0f;
+			}
+			gfog->colorInt = ColorBytes4 ( gfog->parms.color[0], 
+										  gfog->parms.color[1], 
+										  gfog->parms.color[2], 1.0f );
+		}
+	}
+
+	Cvar_VariableStringBuffer("RMG_weather", temp, MAX_QPATH);
+
+	// Set up any weather effects
+	switch(atol(temp))
+	{
+	case 0:
+		break;
+	case 1:
+		R_WorldEffectCommand("rain init 1000");
+		R_WorldEffectCommand("rain outside");
+		break;
+	case 2:
+		R_WorldEffectCommand("snow init 1000 outside");
+		R_WorldEffectCommand("snow outside");
+		break;
+	}
+}
+
+// end
diff --git a/code/renderer/tr_backend.cpp b/code/renderer/tr_backend.cpp
new file mode 100644
index 0000000..d26dd28
--- /dev/null
+++ b/code/renderer/tr_backend.cpp
@@ -0,0 +1,1963 @@
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+
+#include "tr_local.h"
+
+#ifdef VV_LIGHTING
+#include "tr_lightmanager.h"
+#endif
+
+#ifdef _XBOX
+#include "../win32/win_highdynamicrange.h"
+#endif
+
+backEndData_t	*backEndData;
+backEndState_t	backEnd;
+
+bool tr_stencilled = false;
+extern qboolean tr_distortionPrePost; //tr_shadows.cpp
+extern qboolean tr_distortionNegate; //tr_shadows.cpp
+extern void RB_CaptureScreenImage(void); //tr_shadows.cpp
+extern void RB_DistortionFill(void); //tr_shadows.cpp
+static void RB_DrawGlowOverlay();
+static void RB_BlurGlowTexture();
+
+// Whether we are currently rendering only glowing objects or not.
+bool g_bRenderGlowingObjects = false;
+
+// Whether the current hardware supports dynamic glows/flares.
+bool g_bDynamicGlowSupported = false;
+
+static const float s_flipMatrix[16] = {
+	// convert from our coordinate system (looking down X)
+	// to OpenGL's coordinate system (looking down -Z)
+#if defined (_XBOX)
+	0, 0, 1, 0,
+	-1, 0, 0, 0,
+	0, 1, 0, 0,
+	0, 0, 0, 1
+#else
+	0, 0, -1, 0,
+	-1, 0, 0, 0,
+	0, 1, 0, 0,
+	0, 0, 0, 1
+#endif
+};
+
+
+/*
+** GL_Bind
+*/
+void GL_Bind( image_t *image ) {
+	int texnum;
+
+	if ( !image ) {
+		VID_Printf( PRINT_WARNING, "GL_Bind: NULL image\n" );
+		texnum = tr.defaultImage->texnum;
+	} else {
+		texnum = image->texnum;
+	}
+
+#ifndef _XBOX
+	if ( r_nobind->integer && tr.dlightImage ) {		// performance evaluation option
+		texnum = tr.dlightImage->texnum;
+	}
+#endif
+
+	if ( glState.currenttextures[glState.currenttmu] != texnum ) {
+#ifndef _XBOX
+		image->frameUsed = tr.frameCount;
+#endif
+		glState.currenttextures[glState.currenttmu] = texnum;
+		qglBindTexture (GL_TEXTURE_2D, texnum);
+	}
+}
+
+/*
+** GL_SelectTexture
+*/
+void GL_SelectTexture( int unit )
+{
+	if ( glState.currenttmu == unit )
+	{
+		return;
+	}
+
+	if ( unit == 0 )
+	{
+		qglActiveTextureARB( GL_TEXTURE0_ARB );
+		GLimp_LogComment( "glActiveTextureARB( GL_TEXTURE0_ARB )\n" );
+		qglClientActiveTextureARB( GL_TEXTURE0_ARB );
+		GLimp_LogComment( "glClientActiveTextureARB( GL_TEXTURE0_ARB )\n" );
+	}
+	else if ( unit == 1 )
+	{
+		qglActiveTextureARB( GL_TEXTURE1_ARB );
+		GLimp_LogComment( "glActiveTextureARB( GL_TEXTURE1_ARB )\n" );
+		qglClientActiveTextureARB( GL_TEXTURE1_ARB );
+		GLimp_LogComment( "glClientActiveTextureARB( GL_TEXTURE1_ARB )\n" );
+	}
+	else if ( unit == 2 )
+	{
+		qglActiveTextureARB( GL_TEXTURE2_ARB );
+		GLimp_LogComment( "glActiveTextureARB( GL_TEXTURE2_ARB )\n" );
+		qglClientActiveTextureARB( GL_TEXTURE2_ARB );
+		GLimp_LogComment( "glClientActiveTextureARB( GL_TEXTURE2_ARB )\n" );
+	}
+	else if ( unit == 3 )
+	{
+		qglActiveTextureARB( GL_TEXTURE3_ARB );
+		GLimp_LogComment( "glActiveTextureARB( GL_TEXTURE3_ARB )\n" );
+		qglClientActiveTextureARB( GL_TEXTURE3_ARB );
+		GLimp_LogComment( "glClientActiveTextureARB( GL_TEXTURE3_ARB )\n" );
+	}
+	else {
+		Com_Error( ERR_DROP, "GL_SelectTexture: unit = %i", unit );
+	}
+
+	glState.currenttmu = unit;
+}
+
+
+/*
+** GL_Cull
+*/
+void GL_Cull( int cullType ) {
+	if ( glState.faceCulling == cullType ) {
+		return;
+	}
+	glState.faceCulling = cullType;
+	if (backEnd.projection2D){	//don't care, we're in 2d when it's always disabled
+		return;	
+	}
+
+	if ( cullType == CT_TWO_SIDED ) 
+	{
+		qglDisable( GL_CULL_FACE );
+	} 
+	else 
+	{
+		qglEnable( GL_CULL_FACE );
+
+		if ( cullType == CT_BACK_SIDED )
+		{
+			if ( backEnd.viewParms.isMirror )
+			{
+				qglCullFace( GL_FRONT );
+			}
+			else
+			{
+				qglCullFace( GL_BACK );
+			}
+		}
+		else
+		{
+			if ( backEnd.viewParms.isMirror )
+			{
+				qglCullFace( GL_BACK );
+			}
+			else
+			{
+				qglCullFace( GL_FRONT );
+			}
+		}
+	}
+}
+
+/*
+** GL_TexEnv
+*/
+void GL_TexEnv( int env )
+{
+	if ( env == glState.texEnv[glState.currenttmu] )
+	{
+		return;
+	}
+
+	glState.texEnv[glState.currenttmu] = env;
+
+
+	switch ( env )
+	{
+	case GL_MODULATE:
+		qglTexEnvf( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE );
+		break;
+	case GL_REPLACE:
+		qglTexEnvf( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE );
+		break;
+	case GL_DECAL:
+		qglTexEnvf( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL );
+		break;
+	case GL_ADD:
+		qglTexEnvf( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_ADD );
+		break;
+#ifdef _XBOX
+	case GL_NONE:
+		qglTexEnvf( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_NONE );
+		break;
+#endif
+	default:
+		Com_Error( ERR_DROP, "GL_TexEnv: invalid env '%d' passed\n", env );
+		break;
+	}
+}
+
+/*
+** GL_State
+**
+** This routine is responsible for setting the most commonly changed state
+** in Q3.
+*/
+void GL_State( unsigned long stateBits )
+{
+	unsigned long diff = stateBits ^ glState.glStateBits;
+
+	if ( !diff )
+	{
+		return;
+	}
+
+	//
+	// check depthFunc bits
+	//
+	if ( diff & GLS_DEPTHFUNC_EQUAL )
+	{
+		if ( stateBits & GLS_DEPTHFUNC_EQUAL )
+		{
+			qglDepthFunc( GL_EQUAL );
+		}
+		else
+		{
+			qglDepthFunc( GL_LEQUAL );
+		}
+	}
+
+	//
+	// check blend bits
+	//
+	if ( diff & ( GLS_SRCBLEND_BITS | GLS_DSTBLEND_BITS ) )
+	{
+		GLenum srcFactor, dstFactor;
+
+		if ( stateBits & ( GLS_SRCBLEND_BITS | GLS_DSTBLEND_BITS ) )
+		{
+			switch ( stateBits & GLS_SRCBLEND_BITS )
+			{
+			case GLS_SRCBLEND_ZERO:
+				srcFactor = GL_ZERO;
+				break;
+			case GLS_SRCBLEND_ONE:
+				srcFactor = GL_ONE;
+				break;
+			case GLS_SRCBLEND_DST_COLOR:
+				srcFactor = GL_DST_COLOR;
+				break;
+			case GLS_SRCBLEND_ONE_MINUS_DST_COLOR:
+				srcFactor = GL_ONE_MINUS_DST_COLOR;
+				break;
+			case GLS_SRCBLEND_SRC_ALPHA:
+				srcFactor = GL_SRC_ALPHA;
+				break;
+			case GLS_SRCBLEND_ONE_MINUS_SRC_ALPHA:
+				srcFactor = GL_ONE_MINUS_SRC_ALPHA;
+				break;
+			case GLS_SRCBLEND_DST_ALPHA:
+				srcFactor = GL_DST_ALPHA;
+				break;
+			case GLS_SRCBLEND_ONE_MINUS_DST_ALPHA:
+				srcFactor = GL_ONE_MINUS_DST_ALPHA;
+				break;
+			case GLS_SRCBLEND_ALPHA_SATURATE:
+				srcFactor = GL_SRC_ALPHA_SATURATE;
+				break;
+			default:
+				srcFactor = GL_ONE;		// to get warning to shut up
+				Com_Error( ERR_DROP, "GL_State: invalid src blend state bits\n" );
+				break;
+			}
+
+			switch ( stateBits & GLS_DSTBLEND_BITS )
+			{
+			case GLS_DSTBLEND_ZERO:
+				dstFactor = GL_ZERO;
+				break;
+			case GLS_DSTBLEND_ONE:
+				dstFactor = GL_ONE;
+				break;
+			case GLS_DSTBLEND_SRC_COLOR:
+				dstFactor = GL_SRC_COLOR;
+				break;
+			case GLS_DSTBLEND_ONE_MINUS_SRC_COLOR:
+				dstFactor = GL_ONE_MINUS_SRC_COLOR;
+				break;
+			case GLS_DSTBLEND_SRC_ALPHA:
+				dstFactor = GL_SRC_ALPHA;
+				break;
+			case GLS_DSTBLEND_ONE_MINUS_SRC_ALPHA:
+				dstFactor = GL_ONE_MINUS_SRC_ALPHA;
+				break;
+			case GLS_DSTBLEND_DST_ALPHA:
+				dstFactor = GL_DST_ALPHA;
+				break;
+			case GLS_DSTBLEND_ONE_MINUS_DST_ALPHA:
+				dstFactor = GL_ONE_MINUS_DST_ALPHA;
+				break;
+			default:
+				dstFactor = GL_ONE;		// to get warning to shut up
+				Com_Error( ERR_DROP, "GL_State: invalid dst blend state bits\n" );
+				break;
+			}
+
+			qglEnable( GL_BLEND );
+			qglBlendFunc( srcFactor, dstFactor );
+		}
+		else
+		{
+			qglDisable( GL_BLEND );
+		}
+	}
+
+	//
+	// check depthmask
+	//
+	if ( diff & GLS_DEPTHMASK_TRUE )
+	{
+		if ( stateBits & GLS_DEPTHMASK_TRUE )
+		{
+			qglDepthMask( GL_TRUE );
+		}
+		else
+		{
+			qglDepthMask( GL_FALSE );
+		}
+	}
+
+	//
+	// fill/line mode
+	//
+	if ( diff & GLS_POLYMODE_LINE )
+	{
+		if ( stateBits & GLS_POLYMODE_LINE )
+		{
+			qglPolygonMode( GL_FRONT_AND_BACK, GL_LINE );
+		}
+		else
+		{
+			qglPolygonMode( GL_FRONT_AND_BACK, GL_FILL );
+		}
+	}
+
+	//
+	// depthtest
+	//
+	if ( diff & GLS_DEPTHTEST_DISABLE )
+	{
+		if ( stateBits & GLS_DEPTHTEST_DISABLE )
+		{
+			qglDisable( GL_DEPTH_TEST );
+		}
+		else
+		{
+			qglEnable( GL_DEPTH_TEST );
+		}
+	}
+
+	//
+	// alpha test
+	//
+	if ( diff & GLS_ATEST_BITS )
+	{
+		switch ( stateBits & GLS_ATEST_BITS )
+		{
+		case 0:
+			qglDisable( GL_ALPHA_TEST );
+			break;
+		case GLS_ATEST_GT_0:
+			qglEnable( GL_ALPHA_TEST );
+			qglAlphaFunc( GL_GREATER, 0.0f );
+			break;
+		case GLS_ATEST_LT_80:
+			qglEnable( GL_ALPHA_TEST );
+			qglAlphaFunc( GL_LESS, 0.5f );
+			break;
+		case GLS_ATEST_GE_80:
+			qglEnable( GL_ALPHA_TEST );
+			qglAlphaFunc( GL_GEQUAL, 0.5f );
+			break;
+		case GLS_ATEST_GE_C0:
+			qglEnable( GL_ALPHA_TEST );
+			qglAlphaFunc( GL_GEQUAL, 0.75f );
+			break;
+		default:
+			assert( 0 );
+			break;
+		}
+	}
+
+	glState.glStateBits = stateBits;
+}
+
+
+
+/*
+================
+RB_Hyperspace
+
+A player has predicted a teleport, but hasn't arrived yet
+================
+*/
+static void RB_Hyperspace( void ) {
+	float		c;
+
+	if ( !backEnd.isHyperspace ) {
+		// do initialization shit
+	}
+
+	c = ( backEnd.refdef.time & 255 ) / 255.0f;
+	qglClearColor( c, c, c, 1 );
+	qglClear( GL_COLOR_BUFFER_BIT );
+
+	backEnd.isHyperspace = qtrue;
+}
+
+
+void SetViewportAndScissor( void ) {
+	qglMatrixMode(GL_PROJECTION);
+	qglLoadMatrixf( backEnd.viewParms.projectionMatrix );
+	qglMatrixMode(GL_MODELVIEW);
+
+	// set the window clipping
+	qglViewport( backEnd.viewParms.viewportX, backEnd.viewParms.viewportY, 
+		backEnd.viewParms.viewportWidth, backEnd.viewParms.viewportHeight );
+	qglScissor( backEnd.viewParms.viewportX, backEnd.viewParms.viewportY, 
+		backEnd.viewParms.viewportWidth, backEnd.viewParms.viewportHeight );
+}
+
+/*
+=================
+RB_BeginDrawingView
+
+Any mirrored or portaled views have already been drawn, so prepare
+to actually render the visible surfaces for this view
+=================
+*/
+static void RB_BeginDrawingView (void) {
+	int clearBits = GL_DEPTH_BUFFER_BIT;
+
+	// sync with gl if needed
+	if ( r_finish->integer == 1 && !glState.finishCalled ) {
+		qglFinish ();
+		glState.finishCalled = qtrue;
+	}
+	if ( r_finish->integer == 0 ) {
+		glState.finishCalled = qtrue;
+	}
+
+	// we will need to change the projection matrix before drawing
+	// 2D images again
+	backEnd.projection2D = qfalse;
+
+	//
+	// set the modelview matrix for the viewer
+	//
+	SetViewportAndScissor();
+
+	// ensures that depth writes are enabled for the depth clear
+	GL_State( GLS_DEFAULT );
+
+	// clear relevant buffers
+	if ( r_measureOverdraw->integer || r_shadows->integer == 2 || tr_stencilled )
+	{
+		clearBits |= GL_STENCIL_BUFFER_BIT;
+		tr_stencilled = false;
+	}
+
+	if (skyboxportal)
+	{
+		if ( backEnd.refdef.rdflags & RDF_SKYBOXPORTAL )
+		{	// portal scene, clear whatever is necessary
+			if (r_fastsky->integer || (backEnd.refdef.rdflags & RDF_NOWORLDMODEL) )
+			{	// fastsky: clear color
+				// try clearing first with the portal sky fog color, then the world fog color, then finally a default
+				clearBits |= GL_COLOR_BUFFER_BIT;
+				if (tr.world && tr.world->globalFog != -1)
+				{
+					const fog_t		*fog = &tr.world->fogs[tr.world->globalFog];
+					qglClearColor(fog->parms.color[0],  fog->parms.color[1], fog->parms.color[2], 1.0f );
+				}
+				else
+				{
+					qglClearColor ( 0.3f, 0.3f, 0.3f, 1.0 );
+				}
+			}			
+		}
+	}
+	else
+	{
+		if ( r_fastsky->integer && !( backEnd.refdef.rdflags & RDF_NOWORLDMODEL ) && !g_bRenderGlowingObjects )
+		{
+			if (tr.world && tr.world->globalFog != -1)
+			{
+				const fog_t		*fog = &tr.world->fogs[tr.world->globalFog];
+				qglClearColor(fog->parms.color[0],  fog->parms.color[1], fog->parms.color[2], 1.0f );
+			}
+			else
+			{
+				qglClearColor( 0.3f, 0.3f, 0.3f, 1 );	// FIXME: get color of sky
+			}
+			clearBits |= GL_COLOR_BUFFER_BIT;	// FIXME: only if sky shaders have been used
+		}
+	}
+
+	if ( !( backEnd.refdef.rdflags & RDF_NOWORLDMODEL ) && ( r_DynamicGlow->integer && !g_bRenderGlowingObjects ) )
+	{
+		if (tr.world && tr.world->globalFog != -1)
+		{ //this is because of a bug in multiple scenes I think, it needs to clear for the second scene but it doesn't normally.
+			const fog_t		*fog = &tr.world->fogs[tr.world->globalFog];
+
+			qglClearColor(fog->parms.color[0],  fog->parms.color[1], fog->parms.color[2], 1.0f );
+			clearBits |= GL_COLOR_BUFFER_BIT;
+		}
+	}
+	// If this pass is to just render the glowing objects, don't clear the depth buffer since
+	// we're sharing it with the main scene (since the main scene has already been rendered). -AReis
+	if ( g_bRenderGlowingObjects )
+	{
+		clearBits &= ~GL_DEPTH_BUFFER_BIT;
+	}
+
+	if (clearBits)
+	{
+		qglClear( clearBits );
+	}
+
+	if ( ( backEnd.refdef.rdflags & RDF_HYPERSPACE ) )
+	{
+		RB_Hyperspace();
+		return;
+	}
+	else
+	{
+		backEnd.isHyperspace = qfalse;
+	}
+
+	glState.faceCulling = -1;		// force face culling to set next time
+
+	// we will only draw a sun if there was sky rendered in this view
+	backEnd.skyRenderedThisView = qfalse;
+
+	// clip to the plane of the portal
+	if ( backEnd.viewParms.isPortal ) {
+		float	plane[4];
+		double	plane2[4];
+
+		plane[0] = backEnd.viewParms.portalPlane.normal[0];
+		plane[1] = backEnd.viewParms.portalPlane.normal[1];
+		plane[2] = backEnd.viewParms.portalPlane.normal[2];
+		plane[3] = backEnd.viewParms.portalPlane.dist;
+
+		plane2[0] = DotProduct (backEnd.viewParms.or.axis[0], plane);
+		plane2[1] = DotProduct (backEnd.viewParms.or.axis[1], plane);
+		plane2[2] = DotProduct (backEnd.viewParms.or.axis[2], plane);
+		plane2[3] = DotProduct (plane, backEnd.viewParms.or.origin) - plane[3];
+
+		qglLoadMatrixf( s_flipMatrix );
+		qglClipPlane (GL_CLIP_PLANE0, plane2);
+		qglEnable (GL_CLIP_PLANE0);
+	} else {
+		qglDisable (GL_CLIP_PLANE0);
+	}
+}
+
+#define	MAC_EVENT_PUMP_MSEC		5
+
+//used by RF_DISTORTION
+static inline bool R_WorldCoordToScreenCoordFloat(vec3_t worldCoord, float *x, float *y)
+{
+	int	xcenter, ycenter;
+	vec3_t	local, transformed;
+	vec3_t	vfwd;
+	vec3_t	vright;
+	vec3_t	vup;
+	float xzi;
+	float yzi;
+
+	xcenter = glConfig.vidWidth / 2;
+	ycenter = glConfig.vidHeight / 2;
+
+	//AngleVectors (tr.refdef.viewangles, vfwd, vright, vup);
+	VectorCopy(tr.refdef.viewaxis[0], vfwd);
+	VectorCopy(tr.refdef.viewaxis[1], vright);
+	VectorCopy(tr.refdef.viewaxis[2], vup);
+
+	VectorSubtract (worldCoord, tr.refdef.vieworg, local);
+
+	transformed[0] = DotProduct(local,vright);
+	transformed[1] = DotProduct(local,vup);
+	transformed[2] = DotProduct(local,vfwd);		
+
+	// Make sure Z is not negative.
+	if(transformed[2] < 0.01)
+	{
+		return false;
+	}
+
+	xzi = xcenter / transformed[2] * (90.0/tr.refdef.fov_x);
+	yzi = ycenter / transformed[2] * (90.0/tr.refdef.fov_y);
+
+	*x = xcenter + xzi * transformed[0];
+	*y = ycenter - yzi * transformed[1];
+
+	return true;
+}
+
+//used by RF_DISTORTION
+static inline bool R_WorldCoordToScreenCoord( vec3_t worldCoord, int *x, int *y )
+{
+	float	xF, yF;
+	bool retVal = R_WorldCoordToScreenCoordFloat( worldCoord, &xF, &yF );
+	*x = (int)xF;
+	*y = (int)yF;
+	return retVal;
+}
+
+/*
+==================
+RB_RenderDrawSurfList
+==================
+*/
+//number of possible surfs we can postrender.
+//note that postrenders lack much of the optimization that the standard sort-render crap does,
+//so it's slower.
+#define MAX_POST_RENDERS	128
+
+typedef struct
+{
+	int			fogNum;
+	int			entNum;
+	int			dlighted;
+	int			depthRange;
+	drawSurf_t	*drawSurf;
+	shader_t	*shader;
+} postRender_t;
+
+static postRender_t g_postRenders[MAX_POST_RENDERS];
+static int g_numPostRenders = 0;
+
+void RB_RenderDrawSurfList( drawSurf_t *drawSurfs, int numDrawSurfs ) {
+	shader_t		*shader, *oldShader;
+	int				fogNum, oldFogNum;
+	int				entityNum, oldEntityNum;
+	int				dlighted, oldDlighted;
+	int				depthRange, oldDepthRange;
+	int				i;
+	drawSurf_t		*drawSurf;
+	unsigned int	oldSort;
+	float			originalTime;
+	trRefEntity_t	*curEnt;
+	postRender_t	*pRender;
+	bool			didShadowPass = false;
+#ifdef __MACOS__
+	int				macEventTime;
+
+	Sys_PumpEvents();		// crutch up the mac's limited buffer queue size
+
+	// we don't want to pump the event loop too often and waste time, so
+	// we are going to check every shader change
+	macEventTime = Sys_Milliseconds() + MAC_EVENT_PUMP_MSEC;
+#endif
+
+	if (g_bRenderGlowingObjects)
+	{ //only shadow on initial passes
+		didShadowPass = true;
+	}
+
+	// save original time for entity shader offsets
+	originalTime = backEnd.refdef.floatTime;
+
+	// clear the z buffer, set the modelview, etc
+	RB_BeginDrawingView ();
+
+	// draw everything
+	oldEntityNum = -1;
+	backEnd.currentEntity = &tr.worldEntity;
+	oldShader = NULL;
+	oldFogNum = -1;
+	oldDepthRange = qfalse;
+	oldDlighted = qfalse;
+	oldSort = (unsigned int) -1;
+	depthRange = qfalse;
+
+	backEnd.pc.c_surfaces += numDrawSurfs;
+
+	for (i = 0, drawSurf = drawSurfs ; i < numDrawSurfs ; i++, drawSurf++) {
+		if ( drawSurf->sort == oldSort ) {
+			// fast path, same as previous sort
+			rb_surfaceTable[ *drawSurf->surface ]( drawSurf->surface );
+			continue;
+		}
+		R_DecomposeSort( drawSurf->sort, &entityNum, &shader, &fogNum, &dlighted );
+
+#ifndef _XBOX	// GLOWXXX
+		// If we're rendering glowing objects, but this shader has no stages with glow, skip it!
+		if ( g_bRenderGlowingObjects && !shader->hasGlow )
+		{
+			shader = oldShader;
+			entityNum = oldEntityNum;
+			fogNum = oldFogNum;
+			dlighted = oldDlighted;
+			continue;
+		}
+#endif
+		oldSort = drawSurf->sort;
+
+		//
+		// change the tess parameters if needed
+		// a "entityMergable" shader is a shader that can have surfaces from seperate
+		// entities merged into a single batch, like smoke and blood puff sprites
+		if (entityNum != TR_WORLDENT &&
+			g_numPostRenders < MAX_POST_RENDERS)
+		{
+			if ( (backEnd.refdef.entities[entityNum].e.renderfx & RF_DISTORTION)/* ||
+				(backEnd.refdef.entities[entityNum].e.renderfx & RF_FORCE_ENT_ALPHA)*/)
+				//not sure if we need this alpha fix for sp or not, leaving it out for now -rww
+			{ //must render last
+				curEnt = &backEnd.refdef.entities[entityNum];
+				pRender = &g_postRenders[g_numPostRenders];
+
+				g_numPostRenders++;
+
+				depthRange = 0;
+				//figure this stuff out now and store it
+				if ( curEnt->e.renderfx & RF_NODEPTH )
+				{
+					depthRange = 2;
+				}
+				else if ( curEnt->e.renderfx & RF_DEPTHHACK )
+				{
+					depthRange = 1;
+				}
+				pRender->depthRange = depthRange;
+
+				//It is not necessary to update the old* values because
+				//we are not updating now with the current values.
+				depthRange = oldDepthRange;
+
+				//store off the ent num
+				pRender->entNum = entityNum;
+
+				//remember the other values necessary for rendering this surf
+				pRender->drawSurf = drawSurf;
+				pRender->dlighted = dlighted;
+				pRender->fogNum = fogNum;
+				pRender->shader = shader;
+
+				//assure the info is back to the last set state
+				shader = oldShader;
+				entityNum = oldEntityNum;
+				fogNum = oldFogNum;
+				dlighted = oldDlighted;
+
+				oldSort = (unsigned int)-1; //invalidate this thing, cause we may want to postrender more surfs of the same sort
+
+				//continue without bothering to begin a draw surf
+				continue;
+			}
+		}
+
+		if (shader != oldShader || fogNum != oldFogNum || dlighted != oldDlighted 
+			|| ( entityNum != oldEntityNum && !shader->entityMergable ) )
+		{
+			if (oldShader != NULL) {
+#ifdef __MACOS__	// crutch up the mac's limited buffer queue size
+				int		t;
+
+				t = Sys_Milliseconds();
+				if ( t > macEventTime ) {
+					macEventTime = t + MAC_EVENT_PUMP_MSEC;
+					Sys_PumpEvents();
+				}
+#endif
+				RB_EndSurface();
+
+				if (!didShadowPass && shader && shader->sort > SS_BANNER)
+				{
+					RB_ShadowFinish();
+					didShadowPass = true;
+				}
+			}
+			RB_BeginSurface( shader, fogNum );
+			oldShader = shader;
+			oldFogNum = fogNum;
+			oldDlighted = dlighted;
+		}
+
+		//
+		// change the modelview matrix if needed
+		//
+		if ( entityNum != oldEntityNum ) {
+			depthRange = qfalse;
+
+			if ( entityNum != TR_WORLDENT ) {
+				backEnd.currentEntity = &backEnd.refdef.entities[entityNum];
+				backEnd.refdef.floatTime = originalTime - backEnd.currentEntity->e.shaderTime;
+
+				// set up the transformation matrix
+				R_RotateForEntity( backEnd.currentEntity, &backEnd.viewParms, &backEnd.ori );
+
+				// set up the dynamic lighting if needed
+				if ( backEnd.currentEntity->needDlights ) {
+#ifdef VV_LIGHTING
+					VVLightMan.R_TransformDlights( &backEnd.ori );
+#else
+					R_TransformDlights( backEnd.refdef.num_dlights, backEnd.refdef.dlights, &backEnd.ori );
+#endif
+				}
+
+				if ( backEnd.currentEntity->e.renderfx & RF_NODEPTH ) {
+					// No depth at all, very rare but some things for seeing through walls
+					depthRange = 2;
+				}
+				else if ( backEnd.currentEntity->e.renderfx & RF_DEPTHHACK ) {
+					// hack the depth range to prevent view model from poking into walls
+					depthRange = qtrue;
+				}
+			} else {
+				backEnd.currentEntity = &tr.worldEntity;
+				backEnd.refdef.floatTime = originalTime;
+				backEnd.ori = backEnd.viewParms.world;
+#ifdef VV_LIGHTING
+				VVLightMan.R_TransformDlights( &backEnd.ori );
+#else
+				R_TransformDlights( backEnd.refdef.num_dlights, backEnd.refdef.dlights, &backEnd.ori );
+#endif
+			}
+
+			qglLoadMatrixf( backEnd.ori.modelMatrix );
+
+			//
+			// change depthrange if needed
+			//
+			if ( oldDepthRange != depthRange ) {
+				switch ( depthRange ) {
+					default:
+					case 0:
+						qglDepthRange (0, 1);	
+						break;
+
+					case 1:
+						qglDepthRange (0, .3);	
+						break;
+
+					case 2:
+						qglDepthRange (0, 0);
+						break;
+				}
+
+				oldDepthRange = depthRange;
+			}
+
+			oldEntityNum = entityNum;
+		}
+
+		// add the triangles for this surface
+		rb_surfaceTable[ *drawSurf->surface ]( drawSurf->surface );
+	}
+
+	// draw the contents of the last shader batch
+	if (oldShader != NULL) {
+		RB_EndSurface();
+	}
+
+	if (tr_stencilled && tr_distortionPrePost)
+	{ //ok, cap it now
+		RB_CaptureScreenImage();
+		RB_DistortionFill();
+	}
+
+	//render distortion surfs (or anything else that needs to be post-rendered)
+	if (g_numPostRenders > 0)
+	{
+		int lastPostEnt = -1;
+
+		while (g_numPostRenders > 0)
+		{
+			g_numPostRenders--;
+			pRender = &g_postRenders[g_numPostRenders];
+
+			RB_BeginSurface( pRender->shader, pRender->fogNum );
+
+			backEnd.currentEntity = &backEnd.refdef.entities[pRender->entNum];
+
+			backEnd.refdef.floatTime = originalTime - backEnd.currentEntity->e.shaderTime;
+
+			// set up the transformation matrix
+			R_RotateForEntity( backEnd.currentEntity, &backEnd.viewParms, &backEnd.ori );
+
+			// set up the dynamic lighting if needed
+			if ( backEnd.currentEntity->needDlights )
+			{
+#ifdef VV_LIGHTING
+				VVLightMan.R_TransformDlights( &backEnd.ori );
+#else
+				R_TransformDlights( backEnd.refdef.num_dlights, backEnd.refdef.dlights, &backEnd.ori );
+#endif
+			}
+
+			qglLoadMatrixf( backEnd.ori.modelMatrix );
+
+			depthRange = pRender->depthRange;
+			switch ( depthRange )
+			{
+				default:
+				case 0:
+					qglDepthRange (0, 1);	
+					break;
+
+				case 1:
+					qglDepthRange (0, .3);	
+					break;
+
+				case 2:
+					qglDepthRange (0, 0);
+					break;
+			}
+
+			if ((backEnd.currentEntity->e.renderfx & RF_DISTORTION) &&
+				lastPostEnt != pRender->entNum)
+			{ //do the capture now, we only need to do it once per ent
+				int x, y;
+				int rad = backEnd.currentEntity->e.radius;
+				//We are going to just bind this, and then the CopyTexImage is going to
+				//stomp over this texture num in texture memory.
+				GL_Bind( tr.screenImage );
+
+				if (R_WorldCoordToScreenCoord( backEnd.currentEntity->e.origin, &x, &y ))
+				{
+					int cX, cY;
+					cX = glConfig.vidWidth-x-(rad/2);
+					cY = glConfig.vidHeight-y-(rad/2);
+
+					if (cX+rad > glConfig.vidWidth)
+					{ //would it go off screen?
+						cX = glConfig.vidWidth-rad;
+					}
+					else if (cX < 0)
+					{ //cap it off at 0
+						cX = 0;
+					}
+
+					if (cY+rad > glConfig.vidHeight)
+					{ //would it go off screen?
+						cY = glConfig.vidHeight-rad;
+					}
+					else if (cY < 0)
+					{ //cap it off at 0
+						cY = 0;
+					}
+
+					//now copy a portion of the screen to this texture
+#ifdef _XBOX
+					qglCopyBackBufferToTexEXT(rad, rad, cX, (480 - cY), (cX + rad), (480 - (cY + rad)));
+#else
+					qglCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA16, cX, cY, rad, rad, 0);
+#endif
+
+					lastPostEnt = pRender->entNum;
+				}
+			}
+
+			rb_surfaceTable[ *pRender->drawSurf->surface ]( pRender->drawSurf->surface );
+			RB_EndSurface();
+		}
+	}
+
+	// go back to the world modelview matrix
+	qglLoadMatrixf( backEnd.viewParms.world.modelMatrix );
+	if ( depthRange ) {
+		qglDepthRange (0, 1);
+	}
+
+#if 0
+	RB_DrawSun();
+#endif
+	if (tr_stencilled && !tr_distortionPrePost)
+	{ //draw in the stencil buffer's cutout
+		RB_DistortionFill();
+	}
+	if (!didShadowPass)
+	{
+		// darken down any stencil shadows
+		RB_ShadowFinish();
+		didShadowPass = true;
+	}
+
+#ifdef _XBOX
+	if (r_hdreffect->integer)
+		HDREffect.Render();
+#endif
+
+	// add light flares on lights that aren't obscured
+//	RB_RenderFlares();
+
+#ifdef __MACOS__
+	Sys_PumpEvents();		// crutch up the mac's limited buffer queue size
+#endif
+}
+
+
+/*
+============================================================================
+
+RENDER BACK END THREAD FUNCTIONS
+
+============================================================================
+*/
+
+/*
+================
+RB_SetGL2D
+
+================
+*/
+void	RB_SetGL2D (void) {
+	backEnd.projection2D = qtrue;
+
+	// set 2D virtual screen size
+	qglViewport( 0, 0, glConfig.vidWidth, glConfig.vidHeight );
+	qglScissor( 0, 0, glConfig.vidWidth, glConfig.vidHeight );
+	qglMatrixMode(GL_PROJECTION);
+    qglLoadIdentity ();
+#ifdef _XBOX
+	qglOrtho (0, 640, 0, 480, 0, 1);
+#else
+	qglOrtho (0, 640, 480, 0, 0, 1);
+#endif
+	qglMatrixMode(GL_MODELVIEW);
+    qglLoadIdentity ();
+
+	GL_State( GLS_DEPTHTEST_DISABLE |
+			  GLS_SRCBLEND_SRC_ALPHA |
+			  GLS_DSTBLEND_ONE_MINUS_SRC_ALPHA );
+
+	qglDisable( GL_CULL_FACE );
+	qglDisable( GL_CLIP_PLANE0 );
+
+	// set time for 2D shaders
+	backEnd.refdef.time = Sys_Milliseconds();
+	backEnd.refdef.floatTime = backEnd.refdef.time * 0.001;
+}
+
+
+/*
+=============
+RB_SetColor
+
+=============
+*/
+const void	*RB_SetColor( const void *data ) {
+	const setColorCommand_t	*cmd;
+
+	cmd = (const setColorCommand_t *)data;
+
+	backEnd.color2D[0] = cmd->color[0] * 255;
+	backEnd.color2D[1] = cmd->color[1] * 255;
+	backEnd.color2D[2] = cmd->color[2] * 255;
+	backEnd.color2D[3] = cmd->color[3] * 255;
+
+	return (const void *)(cmd + 1);
+}
+
+/*
+=============
+RB_StretchPic
+=============
+*/
+const void *RB_StretchPic ( const void *data ) {
+	const stretchPicCommand_t	*cmd;
+	shader_t *shader;
+	int		numVerts, numIndexes;
+
+	cmd = (const stretchPicCommand_t *)data;
+
+	shader = cmd->shader;
+	if ( shader != tess.shader ) {
+		if ( tess.numIndexes ) {
+			RB_EndSurface();	//this might change culling and other states
+		}
+		backEnd.currentEntity = &backEnd.entity2D;
+		RB_BeginSurface( shader, 0 );
+	}
+
+	if ( !backEnd.projection2D ) {
+		RB_SetGL2D();	//set culling and other states
+	}
+
+	RB_CHECKOVERFLOW( 4, 6 );
+	numVerts = tess.numVertexes;
+	numIndexes = tess.numIndexes;
+
+	tess.numVertexes += 4;
+	tess.numIndexes += 6;
+
+	tess.indexes[ numIndexes ] = numVerts + 3;
+	tess.indexes[ numIndexes + 1 ] = numVerts + 0;
+	tess.indexes[ numIndexes + 2 ] = numVerts + 2;
+	tess.indexes[ numIndexes + 3 ] = numVerts + 2;
+	tess.indexes[ numIndexes + 4 ] = numVerts + 0;
+	tess.indexes[ numIndexes + 5 ] = numVerts + 1;
+
+	*(int *)tess.vertexColors[ numVerts ] =
+		*(int *)tess.vertexColors[ numVerts + 1 ] =
+		*(int *)tess.vertexColors[ numVerts + 2 ] =
+		*(int *)tess.vertexColors[ numVerts + 3 ] = *(int *)backEnd.color2D;
+
+	tess.xyz[ numVerts ][0] = cmd->x;
+	tess.xyz[ numVerts ][1] = cmd->y;
+	tess.xyz[ numVerts ][2] = 0;
+
+	tess.texCoords[ numVerts ][0][0] = cmd->s1;
+	tess.texCoords[ numVerts ][0][1] = cmd->t1;
+
+	tess.xyz[ numVerts + 1 ][0] = cmd->x + cmd->w;
+	tess.xyz[ numVerts + 1 ][1] = cmd->y;
+	tess.xyz[ numVerts + 1 ][2] = 0;
+
+	tess.texCoords[ numVerts + 1 ][0][0] = cmd->s2;
+	tess.texCoords[ numVerts + 1 ][0][1] = cmd->t1;
+
+	tess.xyz[ numVerts + 2 ][0] = cmd->x + cmd->w;
+	tess.xyz[ numVerts + 2 ][1] = cmd->y + cmd->h;
+	tess.xyz[ numVerts + 2 ][2] = 0;
+
+	tess.texCoords[ numVerts + 2 ][0][0] = cmd->s2;
+	tess.texCoords[ numVerts + 2 ][0][1] = cmd->t2;
+
+	tess.xyz[ numVerts + 3 ][0] = cmd->x;
+	tess.xyz[ numVerts + 3 ][1] = cmd->y + cmd->h;
+	tess.xyz[ numVerts + 3 ][2] = 0;
+
+	tess.texCoords[ numVerts + 3 ][0][0] = cmd->s1;
+	tess.texCoords[ numVerts + 3 ][0][1] = cmd->t2;
+
+	return (const void *)(cmd + 1);
+}
+
+
+/*
+=============
+RB_DrawRotatePic
+=============
+*/
+const void *RB_RotatePic ( const void *data ) 
+{
+	const rotatePicCommand_t	*cmd;
+	image_t *image;
+	shader_t *shader;
+
+	cmd = (const rotatePicCommand_t *)data;
+
+	shader = cmd->shader;
+	image = &shader->stages[0].bundle[0].image[0];
+
+	if ( image ) {
+		if ( !backEnd.projection2D ) {
+			RB_SetGL2D();
+		}
+
+		qglColor4ubv( backEnd.color2D );
+		qglPushMatrix();
+
+		qglTranslatef(cmd->x+cmd->w,cmd->y,0);
+		qglRotatef(cmd->a, 0.0, 0.0, 1.0);
+		
+		GL_Bind( image );
+#ifdef _XBOX
+		qglBeginEXT (GL_QUADS, 4, 0, 0, 4, 0);
+#else
+		qglBegin (GL_QUADS);
+#endif
+		qglTexCoord2f( cmd->s1, cmd->t1);
+		qglVertex2f( -cmd->w, 0 );
+		qglTexCoord2f( cmd->s2, cmd->t1 );
+		qglVertex2f( 0, 0 );
+		qglTexCoord2f( cmd->s2, cmd->t2 );
+		qglVertex2f( 0, cmd->h );
+		qglTexCoord2f( cmd->s1, cmd->t2 );
+		qglVertex2f( -cmd->w, cmd->h );
+		qglEnd();
+		
+		qglPopMatrix();
+	}
+
+	return (const void *)(cmd + 1);
+}
+
+/*
+=============
+RB_DrawRotatePic2
+=============
+*/
+const void *RB_RotatePic2 ( const void *data ) 
+{
+	const rotatePicCommand_t	*cmd;
+	image_t *image;
+	shader_t *shader;
+
+	cmd = (const rotatePicCommand_t *)data;
+
+	shader = cmd->shader;
+
+	if ( shader->numUnfoggedPasses )
+	{
+		image = &shader->stages[0].bundle[0].image[0];
+
+		if ( image ) 
+		{
+			if ( !backEnd.projection2D ) 
+			{
+				RB_SetGL2D();
+			}
+
+			// Get our current blend mode, etc.
+			GL_State( shader->stages[0].stateBits );
+
+			qglColor4ubv( backEnd.color2D );
+			qglPushMatrix();
+
+			// rotation point is going to be around the center of the passed in coordinates
+			qglTranslatef( cmd->x, cmd->y, 0 );
+			qglRotatef( cmd->a, 0.0, 0.0, 1.0 );
+			
+			GL_Bind( image );
+#ifdef _XBOX
+			qglBeginEXT( GL_QUADS, 4, 0, 0, 4, 0);
+#else
+			qglBegin( GL_QUADS );
+#endif
+				qglTexCoord2f( cmd->s1, cmd->t1);
+				qglVertex2f( -cmd->w * 0.5f, -cmd->h * 0.5f );
+
+				qglTexCoord2f( cmd->s2, cmd->t1 );
+				qglVertex2f( cmd->w * 0.5f, -cmd->h * 0.5f );
+
+				qglTexCoord2f( cmd->s2, cmd->t2 );
+				qglVertex2f( cmd->w * 0.5f, cmd->h * 0.5f );
+
+				qglTexCoord2f( cmd->s1, cmd->t2 );
+				qglVertex2f( -cmd->w * 0.5f, cmd->h * 0.5f );
+			qglEnd();
+			
+			qglPopMatrix();
+
+			// Hmmm, this is not too cool
+			GL_State( GLS_DEPTHTEST_DISABLE |
+				  GLS_SRCBLEND_SRC_ALPHA |
+				  GLS_DSTBLEND_ONE_MINUS_SRC_ALPHA );
+		}
+	}
+
+	return (const void *)(cmd + 1);
+}
+
+/*
+=============
+RB_LAGoggles
+=============
+*/
+const void *RB_LAGoggles( const void *data )
+{
+	return data;
+}
+
+/*
+=============
+RB_ScissorPic
+=============
+*/
+const void *RB_Scissor ( const void *data ) 
+{
+	const scissorCommand_t	*cmd;
+
+	cmd = (const scissorCommand_t *)data;
+
+	if ( !backEnd.projection2D ) 
+	{
+		RB_SetGL2D();
+	}
+
+	if (cmd->x >= 0)
+	{
+		qglScissor( cmd->x,(glConfig.vidHeight - cmd->y - cmd->h),cmd->w,cmd->h);
+	}
+	else
+	{
+		qglScissor( 0, 0, glConfig.vidWidth, glConfig.vidHeight);
+	}		
+
+	return (const void *)(cmd + 1);
+}
+
+/*
+=============
+RB_DrawSurfs
+
+=============
+*/
+const void	*RB_DrawSurfs( const void *data ) {
+	const drawSurfsCommand_t	*cmd;
+
+	// finish any 2D drawing if needed
+	if ( tess.numIndexes ) {
+		RB_EndSurface();
+	}
+
+	cmd = (const drawSurfsCommand_t *)data;
+
+	backEnd.refdef = cmd->refdef;
+	backEnd.viewParms = cmd->viewParms;
+
+	RB_RenderDrawSurfList( cmd->drawSurfs, cmd->numDrawSurfs );
+
+	// Dynamic Glow/Flares:
+	/*
+		The basic idea is to render the glowing parts of the scene to an offscreen buffer, then take
+		that buffer and blur it. After it is sufficiently blurred, re-apply that image back to
+		the normal screen using a additive blending. To blur the scene I use a vertex program to supply
+		four texture coordinate offsets that allow 'peeking' into adjacent pixels. In the register
+		combiner (pixel shader), I combine the adjacent pixels using a weighting factor. - Aurelio
+	*/
+
+	// Render dynamic glowing/flaring objects.
+#ifndef _XBOX	// GLOWXXX
+	if ( !(backEnd.refdef.rdflags & RDF_NOWORLDMODEL) && g_bDynamicGlowSupported && r_DynamicGlow->integer )
+	{
+		// Copy the normal scene to texture.
+		qglDisable( GL_TEXTURE_2D );
+		qglEnable( GL_TEXTURE_RECTANGLE_EXT ); 
+		qglBindTexture( GL_TEXTURE_RECTANGLE_EXT, tr.sceneImage ); 
+		qglCopyTexSubImage2D( GL_TEXTURE_RECTANGLE_EXT, 0, 0, 0, backEnd.viewParms.viewportX, backEnd.viewParms.viewportY, backEnd.viewParms.viewportWidth, backEnd.viewParms.viewportHeight); 
+		qglDisable( GL_TEXTURE_RECTANGLE_EXT );
+		qglEnable( GL_TEXTURE_2D );    
+
+		// Just clear colors, but leave the depth buffer intact so we can 'share' it.
+		qglClearColor( 0.0f, 0.0f, 0.0f, 0.0f );
+		qglClear( GL_COLOR_BUFFER_BIT ); 
+
+		// Render the glowing objects.
+		g_bRenderGlowingObjects = true;
+		RB_RenderDrawSurfList( cmd->drawSurfs, cmd->numDrawSurfs );  
+		g_bRenderGlowingObjects = false;
+		qglFinish();
+
+		// Copy the glow scene to texture.
+		qglDisable( GL_TEXTURE_2D );
+		qglEnable( GL_TEXTURE_RECTANGLE_EXT ); 
+		qglBindTexture( GL_TEXTURE_RECTANGLE_EXT, tr.screenGlow ); 
+		qglCopyTexSubImage2D( GL_TEXTURE_RECTANGLE_EXT, 0, 0, 0,  backEnd.viewParms.viewportX, backEnd.viewParms.viewportY, backEnd.viewParms.viewportWidth, backEnd.viewParms.viewportHeight ); 
+		qglDisable( GL_TEXTURE_RECTANGLE_EXT );
+		qglEnable( GL_TEXTURE_2D );
+		
+		// Resize the viewport to the blur texture size.
+		const int oldViewWidth = backEnd.viewParms.viewportWidth;
+		const int oldViewHeight = backEnd.viewParms.viewportHeight;
+		backEnd.viewParms.viewportWidth = r_DynamicGlowWidth->integer;
+		backEnd.viewParms.viewportHeight = r_DynamicGlowHeight->integer;
+		SetViewportAndScissor();
+
+		// Blur the scene.
+		RB_BlurGlowTexture();
+
+		// Copy the finished glow scene back to texture.
+		qglDisable( GL_TEXTURE_2D );
+		qglEnable( GL_TEXTURE_RECTANGLE_EXT );
+		qglBindTexture( GL_TEXTURE_RECTANGLE_EXT, tr.blurImage );
+		qglCopyTexSubImage2D( GL_TEXTURE_RECTANGLE_EXT, 0, 0, 0, 0, 0, backEnd.viewParms.viewportWidth, backEnd.viewParms.viewportHeight ); 
+		qglDisable( GL_TEXTURE_RECTANGLE_EXT );
+		qglEnable( GL_TEXTURE_2D );
+		
+		// Set the viewport back to normal.
+		backEnd.viewParms.viewportWidth = oldViewWidth;
+		backEnd.viewParms.viewportHeight = oldViewHeight;
+		SetViewportAndScissor();
+		qglClear( GL_COLOR_BUFFER_BIT ); 
+
+		// Draw the glow additively over the screen.
+		RB_DrawGlowOverlay(); 
+	}
+#endif	// _XBOX
+
+	return (const void *)(cmd + 1);
+}
+
+
+/*
+=============
+RB_DrawBuffer
+
+=============
+*/
+const void	*RB_DrawBuffer( const void *data ) {
+	const drawBufferCommand_t	*cmd;
+
+	cmd = (const drawBufferCommand_t *)data;
+
+	qglDrawBuffer( cmd->buffer );
+
+		// clear screen for debugging
+	if (!( backEnd.refdef.rdflags & RDF_NOWORLDMODEL ) && tr.world && tr.refdef.rdflags & RDF_doLAGoggles)
+	{
+		const fog_t		*fog = &tr.world->fogs[tr.world->numfogs];
+
+		qglClearColor(fog->parms.color[0],  fog->parms.color[1], fog->parms.color[2], 1.0f );
+		qglClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+	}
+	else if (!( backEnd.refdef.rdflags & RDF_NOWORLDMODEL ) && tr.world && tr.world->globalFog != -1 && tr.sceneCount)//don't clear during menus, wait for real scene
+	{
+		const fog_t		*fog = &tr.world->fogs[tr.world->globalFog];
+
+		qglClearColor(fog->parms.color[0],  fog->parms.color[1], fog->parms.color[2], 1.0f );
+		qglClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
+	}
+	else if ( r_clear->integer ) 
+	{	// clear screen for debugging
+		int i = r_clear->integer;
+		if (i == 42) {
+			i = Q_irand(0,8);
+		}
+		switch (i)
+		{
+		default:
+			qglClearColor( 1, 0, 0.5, 1 );
+			break;
+		case 1:
+			qglClearColor( 1.0, 0.0, 0.0, 1.0); //red
+			break;
+		case 2:
+			qglClearColor( 0.0, 1.0, 0.0, 1.0); //green
+			break;
+		case 3:
+			qglClearColor( 1.0, 1.0, 0.0, 1.0); //yellow
+			break;
+		case 4:
+			qglClearColor( 0.0, 0.0, 1.0, 1.0); //blue
+			break;
+		case 5:
+			qglClearColor( 0.0, 1.0, 1.0, 1.0); //cyan
+			break;
+		case 6:
+			qglClearColor( 1.0, 0.0, 1.0, 1.0); //magenta
+			break;
+		case 7:
+			qglClearColor( 1.0, 1.0, 1.0, 1.0); //white
+			break;
+		case 8:
+			qglClearColor( 0.0, 0.0, 0.0, 1.0); //black
+			break;
+		}		
+		qglClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
+	}
+
+	return (const void *)(cmd + 1);
+}
+
+/*
+===============
+RB_ShowImages
+
+Draw all the images to the screen, on top of whatever
+was there.  This is used to test for texture thrashing.
+
+Also called by RE_EndRegistration
+===============
+*/
+void RB_ShowImages( void ) {	
+	image_t	*image;
+	float	x, y, w, h;
+	int		start, end;
+
+	if ( !backEnd.projection2D ) {
+		RB_SetGL2D();
+	}
+
+	qglFinish();
+
+	start = Sys_Milliseconds();
+
+	int i=0;
+//	int iNumImages = 
+	   				 R_Images_StartIteration();
+	while ( (image = R_Images_GetNextIteration()) != NULL)
+	{
+		w = glConfig.vidWidth / 20;
+		h = glConfig.vidHeight / 15;
+		x = i % 20 * w;
+		y = i / 20 * h;
+
+		// show in proportional size in mode 2
+		if ( r_showImages->integer == 2 ) {
+			w *= image->width / 512.0;
+			h *= image->height / 512.0;
+		}
+
+		GL_Bind( image );
+#ifdef _XBOX
+		qglBeginEXT (GL_QUADS, 4, 0, 0, 4, 0);
+#else
+		qglBegin (GL_QUADS);
+#endif
+		qglTexCoord2f( 0, 0 );
+		qglVertex2f( x, y );
+		qglTexCoord2f( 1, 0 );
+		qglVertex2f( x + w, y );
+		qglTexCoord2f( 1, 1 );
+		qglVertex2f( x + w, y + h );
+		qglTexCoord2f( 0, 1 );
+		qglVertex2f( x, y + h );
+		qglEnd();
+		i++;
+	}
+
+	qglFinish();
+
+	end = Sys_Milliseconds();
+	//VID_Printf( PRINT_ALL, "%i msec to draw all images\n", end - start );
+}
+
+
+/*
+=============
+RB_SwapBuffers
+
+=============
+*/
+extern void RB_RenderWorldEffects( void );
+const void	*RB_SwapBuffers( const void *data ) {
+	const swapBuffersCommand_t	*cmd;
+
+	// finish any 2D drawing if needed
+	if ( tess.numIndexes ) {
+		RB_EndSurface();
+	}
+
+	// texture swapping test
+	if ( r_showImages->integer ) {
+		RB_ShowImages();
+	}
+
+	cmd = (const swapBuffersCommand_t *)data;
+
+	// we measure overdraw by reading back the stencil buffer and
+	// counting up the number of increments that have happened
+#ifndef _XBOX
+	if ( r_measureOverdraw->integer ) {
+		int i;
+		long sum = 0;
+		unsigned char *stencilReadback;
+
+		stencilReadback = (unsigned char *) Z_Malloc( glConfig.vidWidth * glConfig.vidHeight, TAG_TEMP_WORKSPACE, qfalse );
+		qglReadPixels( 0, 0, glConfig.vidWidth, glConfig.vidHeight, GL_STENCIL_INDEX, GL_UNSIGNED_BYTE, stencilReadback );
+
+		for ( i = 0; i < glConfig.vidWidth * glConfig.vidHeight; i++ ) {
+			sum += stencilReadback[i];
+		}
+
+		backEnd.pc.c_overDraw += sum;
+		Z_Free( stencilReadback );
+	}
+#endif
+
+    if ( !glState.finishCalled ) {
+        qglFinish();
+	}
+
+    GLimp_LogComment( "***************** RB_SwapBuffers *****************\n\n\n" );
+
+	GLimp_EndFrame();
+
+	backEnd.projection2D = qfalse;
+
+	return (const void *)(cmd + 1);
+}
+
+const void	*RB_WorldEffects( const void *data ) 
+{
+	const setModeCommand_t	*cmd;
+
+	cmd = (const setModeCommand_t *)data;
+
+	// Always flush the tess buffer
+	if ( tess.shader && tess.numIndexes ) 
+	{
+		RB_EndSurface();
+	}
+	RB_RenderWorldEffects();
+
+	if(tess.shader)
+	{
+		RB_BeginSurface( tess.shader, tess.fogNum );
+	}
+
+	return (const void *)(cmd + 1);
+}
+
+/*
+====================
+RB_ExecuteRenderCommands
+
+This function will be called syncronously if running without
+smp extensions, or asyncronously by another thread.
+====================
+*/
+void RB_ExecuteRenderCommands( const void *data ) {
+	int		t1, t2;
+
+	t1 = Sys_Milliseconds ();
+
+	while ( 1 ) {
+		switch ( *(const int *)data ) {
+		case RC_SET_COLOR:
+			data = RB_SetColor( data );
+			break;
+		case RC_STRETCH_PIC:
+			data = RB_StretchPic( data );
+			break;
+		case RC_ROTATE_PIC:
+			data = RB_RotatePic( data );
+			break;
+		case RC_ROTATE_PIC2:
+			data = RB_RotatePic2( data );
+			break;
+		case RC_SCISSOR:
+			data = RB_Scissor( data );
+			break;
+		case RC_DRAW_SURFS:
+			data = RB_DrawSurfs( data );
+			break;
+		case RC_DRAW_BUFFER:
+			data = RB_DrawBuffer( data );
+			break;
+		case RC_SWAP_BUFFERS:
+			data = RB_SwapBuffers( data );
+			break;
+		case RC_WORLD_EFFECTS:
+			data = RB_WorldEffects( data );
+			break;
+		case RC_END_OF_LIST:
+		default:
+			// stop rendering on this thread
+			t2 = Sys_Milliseconds ();
+			backEnd.pc.msec = t2 - t1;
+			return;
+		}
+	}
+
+}
+
+#ifndef _XBOX	// GLOWXXX
+// What Pixel Shader type is currently active (regcoms or fragment programs).
+GLuint g_uiCurrentPixelShaderType = 0x0;
+
+// Begin using a Pixel Shader.
+void BeginPixelShader( GLuint uiType, GLuint uiID )
+{
+	switch ( uiType )
+	{
+		// Using Register Combiners, so call the Display List that stores it.
+		case GL_REGISTER_COMBINERS_NV:
+		{
+			// Just in case...
+			if ( !qglCombinerParameterfvNV)
+				return;
+
+			// Call the list with the regcom in it.
+			qglEnable( GL_REGISTER_COMBINERS_NV );
+			qglCallList( uiID );
+
+			g_uiCurrentPixelShaderType = GL_REGISTER_COMBINERS_NV;
+		}
+		return;
+
+		// Using Fragment Programs, so call the program.
+		case GL_FRAGMENT_PROGRAM_ARB:
+		{
+			// Just in case...
+			if ( !qglGenProgramsARB )
+				return;
+
+			qglEnable( GL_FRAGMENT_PROGRAM_ARB );
+			qglBindProgramARB( GL_FRAGMENT_PROGRAM_ARB, uiID );
+
+			g_uiCurrentPixelShaderType = GL_FRAGMENT_PROGRAM_ARB;
+		}
+		return;
+	}
+}
+
+// Stop using a Pixel Shader and return states to normal.
+void EndPixelShader()
+{
+	if ( g_uiCurrentPixelShaderType == 0x0 )
+		return;
+
+	qglDisable( g_uiCurrentPixelShaderType );
+}
+
+// Hack variable for deciding which kind of texture rectangle thing to do (for some
+// reason it acts different on radeon! It's against the spec!).
+extern bool g_bTextureRectangleHack;
+
+static inline void RB_BlurGlowTexture()
+{
+	qglDisable (GL_CLIP_PLANE0);
+	GL_Cull( CT_TWO_SIDED );
+
+	// Go into orthographic 2d mode.
+	qglMatrixMode(GL_PROJECTION);
+	qglPushMatrix();
+	qglLoadIdentity();
+	qglOrtho(0, backEnd.viewParms.viewportWidth, backEnd.viewParms.viewportHeight, 0, -1, 1);
+	qglMatrixMode(GL_MODELVIEW);
+	qglPushMatrix();
+	qglLoadIdentity();
+
+	GL_State(GLS_DEPTHTEST_DISABLE);
+
+	/////////////////////////////////////////////////////////
+	// Setup vertex and pixel programs.
+	/////////////////////////////////////////////////////////
+
+	// NOTE: The 0.25 is because we're blending 4 textures (so = 1.0) and we want a relatively normalized pixel
+	// intensity distribution, but this won't happen anyways if intensity is higher than 1.0.
+	float fBlurDistribution = r_DynamicGlowIntensity->value * 0.25f;
+	float fBlurWeight[4] = { fBlurDistribution, fBlurDistribution, fBlurDistribution, 1.0f };
+
+	// Enable and set the Vertex Program.
+	qglEnable( GL_VERTEX_PROGRAM_ARB );
+	qglBindProgramARB( GL_VERTEX_PROGRAM_ARB, tr.glowVShader );
+
+	// Apply Pixel Shaders.
+	if ( qglCombinerParameterfvNV )
+	{
+		BeginPixelShader( GL_REGISTER_COMBINERS_NV, tr.glowPShader );
+
+		// Pass the blur weight to the regcom.
+		qglCombinerParameterfvNV( GL_CONSTANT_COLOR0_NV, (float*)&fBlurWeight );
+	}
+	else if ( qglProgramEnvParameter4fARB )
+	{
+		BeginPixelShader( GL_FRAGMENT_PROGRAM_ARB, tr.glowPShader );
+
+		// Pass the blur weight to the Fragment Program.
+		qglProgramEnvParameter4fARB( GL_FRAGMENT_PROGRAM_ARB, 0, fBlurWeight[0], fBlurWeight[1], fBlurWeight[2], fBlurWeight[3] );
+	}
+
+	/////////////////////////////////////////////////////////
+	// Set the blur texture to the 4 texture stages.
+	/////////////////////////////////////////////////////////
+
+	// How much to offset each texel by.
+	float fTexelWidthOffset = 0.1f, fTexelHeightOffset = 0.1f;
+
+	GLuint uiTex = tr.screenGlow;  
+
+	qglActiveTextureARB( GL_TEXTURE3_ARB );  
+	qglEnable( GL_TEXTURE_RECTANGLE_EXT ); 
+	qglBindTexture( GL_TEXTURE_RECTANGLE_EXT, uiTex );
+	
+	qglActiveTextureARB( GL_TEXTURE2_ARB ); 
+	qglEnable( GL_TEXTURE_RECTANGLE_EXT );
+	qglBindTexture( GL_TEXTURE_RECTANGLE_EXT, uiTex );
+
+	qglActiveTextureARB( GL_TEXTURE1_ARB );
+	qglEnable( GL_TEXTURE_RECTANGLE_EXT );
+	qglBindTexture( GL_TEXTURE_RECTANGLE_EXT, uiTex );
+
+	qglActiveTextureARB(GL_TEXTURE0_ARB );
+	qglDisable( GL_TEXTURE_2D );  
+	qglEnable( GL_TEXTURE_RECTANGLE_EXT );
+	qglBindTexture( GL_TEXTURE_RECTANGLE_EXT, uiTex ); 
+	
+	/////////////////////////////////////////////////////////
+	// Draw the blur passes (each pass blurs it more, increasing the blur radius ).
+	/////////////////////////////////////////////////////////
+	
+	//int iTexWidth = backEnd.viewParms.viewportWidth, iTexHeight = backEnd.viewParms.viewportHeight;
+	int iTexWidth = glConfig.vidWidth, iTexHeight = glConfig.vidHeight; 
+	
+	for ( int iNumBlurPasses = 0; iNumBlurPasses < r_DynamicGlowPasses->integer; iNumBlurPasses++ )       
+	{
+		// Load the Texel Offsets into the Vertex Program.
+		qglProgramEnvParameter4fARB( GL_VERTEX_PROGRAM_ARB, 0, -fTexelWidthOffset, -fTexelWidthOffset, 0.0f, 0.0f );
+		qglProgramEnvParameter4fARB( GL_VERTEX_PROGRAM_ARB, 1, -fTexelWidthOffset, fTexelWidthOffset, 0.0f, 0.0f );
+		qglProgramEnvParameter4fARB( GL_VERTEX_PROGRAM_ARB, 2, fTexelWidthOffset, -fTexelWidthOffset, 0.0f, 0.0f );
+		qglProgramEnvParameter4fARB( GL_VERTEX_PROGRAM_ARB, 3, fTexelWidthOffset, fTexelWidthOffset, 0.0f, 0.0f );
+
+		// After first pass put the tex coords to the viewport size.
+		if ( iNumBlurPasses == 1 )
+		{
+			if ( !g_bTextureRectangleHack ) 
+			{
+				iTexWidth = backEnd.viewParms.viewportWidth;
+				iTexHeight = backEnd.viewParms.viewportHeight;
+			}
+
+			uiTex = tr.blurImage;
+			qglActiveTextureARB( GL_TEXTURE3_ARB );  
+			qglDisable( GL_TEXTURE_2D );
+			qglEnable( GL_TEXTURE_RECTANGLE_EXT ); 
+			qglBindTexture( GL_TEXTURE_RECTANGLE_EXT, uiTex );
+			qglActiveTextureARB( GL_TEXTURE2_ARB ); 
+			qglDisable( GL_TEXTURE_2D );
+			qglEnable( GL_TEXTURE_RECTANGLE_EXT );
+			qglBindTexture( GL_TEXTURE_RECTANGLE_EXT, uiTex );			
+			qglActiveTextureARB( GL_TEXTURE1_ARB );
+			qglDisable( GL_TEXTURE_2D );
+			qglEnable( GL_TEXTURE_RECTANGLE_EXT );
+			qglBindTexture( GL_TEXTURE_RECTANGLE_EXT, uiTex );
+			qglActiveTextureARB(GL_TEXTURE0_ARB );
+			qglDisable( GL_TEXTURE_2D );
+			qglEnable( GL_TEXTURE_RECTANGLE_EXT );
+			qglBindTexture( GL_TEXTURE_RECTANGLE_EXT, uiTex ); 
+
+			// Copy the current image over.
+			qglBindTexture( GL_TEXTURE_RECTANGLE_EXT, uiTex );     
+			qglCopyTexSubImage2D( GL_TEXTURE_RECTANGLE_EXT, 0, 0, 0, 0, 0, backEnd.viewParms.viewportWidth, backEnd.viewParms.viewportHeight );
+		}
+
+		// Draw the fullscreen quad.
+		qglBegin( GL_QUADS ); 
+			qglMultiTexCoord2fARB( GL_TEXTURE0_ARB, 0, iTexHeight );  
+			qglVertex2f( 0, 0 );
+
+			qglMultiTexCoord2fARB( GL_TEXTURE0_ARB, 0, 0 );
+			qglVertex2f( 0, backEnd.viewParms.viewportHeight );
+
+			qglMultiTexCoord2fARB( GL_TEXTURE0_ARB, iTexWidth, 0 ); 
+			qglVertex2f( backEnd.viewParms.viewportWidth, backEnd.viewParms.viewportHeight );
+
+			qglMultiTexCoord2fARB( GL_TEXTURE0_ARB, iTexWidth, iTexHeight );
+			qglVertex2f( backEnd.viewParms.viewportWidth, 0 ); 
+		qglEnd();
+
+		qglBindTexture( GL_TEXTURE_RECTANGLE_EXT, tr.blurImage );       
+		qglCopyTexSubImage2D( GL_TEXTURE_RECTANGLE_EXT, 0, 0, 0, 0, 0, backEnd.viewParms.viewportWidth, backEnd.viewParms.viewportHeight );    
+
+		// Increase the texel offsets.
+		// NOTE: This is possibly the most important input to the effect. Even by using an exponential function I've been able to
+		// make it look better (at a much higher cost of course). This is cheap though and still looks pretty great. In the future 
+		// I might want to use an actual gaussian equation to correctly calculate the pixel coefficients and attenuates, texel
+		// offsets, gaussian amplitude and radius...
+		fTexelWidthOffset += r_DynamicGlowDelta->value;
+		fTexelHeightOffset += r_DynamicGlowDelta->value;
+	}
+
+	// Disable multi-texturing.
+	qglActiveTextureARB( GL_TEXTURE3_ARB );   
+	qglDisable( GL_TEXTURE_RECTANGLE_EXT );
+
+	qglActiveTextureARB( GL_TEXTURE2_ARB );
+	qglDisable( GL_TEXTURE_RECTANGLE_EXT );
+
+	qglActiveTextureARB( GL_TEXTURE1_ARB );
+	qglDisable( GL_TEXTURE_RECTANGLE_EXT );
+
+	qglActiveTextureARB(GL_TEXTURE0_ARB );
+	qglDisable( GL_TEXTURE_RECTANGLE_EXT );
+	qglEnable( GL_TEXTURE_2D );
+
+	qglDisable( GL_VERTEX_PROGRAM_ARB );
+	EndPixelShader();
+	
+	qglMatrixMode(GL_PROJECTION);
+	qglPopMatrix();
+	qglMatrixMode(GL_MODELVIEW);
+	qglPopMatrix();
+
+	qglDisable( GL_BLEND );
+	glState.currenttmu = 0;	//this matches the last one we activated
+}
+
+// Draw the glow blur over the screen additively.
+static inline void RB_DrawGlowOverlay()
+{
+	qglDisable (GL_CLIP_PLANE0);
+	GL_Cull( CT_TWO_SIDED );
+
+	// Go into orthographic 2d mode.
+	qglMatrixMode(GL_PROJECTION);
+	qglPushMatrix();
+	qglLoadIdentity();
+	qglOrtho(0, glConfig.vidWidth, glConfig.vidHeight, 0, -1, 1);
+	qglMatrixMode(GL_MODELVIEW);
+	qglPushMatrix();
+	qglLoadIdentity();
+
+	GL_State(GLS_DEPTHTEST_DISABLE);
+
+	qglDisable( GL_TEXTURE_2D );
+	qglEnable( GL_TEXTURE_RECTANGLE_EXT );
+
+	// For debug purposes.
+	if ( r_DynamicGlow->integer != 2 )
+	{
+		// Render the normal scene texture.
+		qglBindTexture( GL_TEXTURE_RECTANGLE_EXT, tr.sceneImage ); 
+		qglBegin(GL_QUADS);    
+			qglColor4f( 1.0f, 1.0f, 1.0f, 1.0f );
+			qglTexCoord2f( 0, glConfig.vidHeight ); 
+			qglVertex2f( 0, 0 );
+
+			qglTexCoord2f( 0, 0 );
+			qglVertex2f( 0, glConfig.vidHeight );
+
+			qglTexCoord2f( glConfig.vidWidth, 0 );
+			qglVertex2f( glConfig.vidWidth, glConfig.vidHeight );
+
+			qglTexCoord2f( glConfig.vidWidth, glConfig.vidHeight );
+			qglVertex2f( glConfig.vidWidth, 0 );
+		qglEnd();
+	}
+
+	// One and Inverse Src Color give a very soft addition, while one one is a bit stronger. With one one we can
+	// use additive blending through multitexture though.
+	if ( r_DynamicGlowSoft->integer )
+	{
+		qglBlendFunc( GL_ONE, GL_ONE_MINUS_SRC_COLOR );
+	}
+	else
+	{
+		qglBlendFunc( GL_ONE, GL_ONE );
+	}
+	qglEnable( GL_BLEND );  
+
+	// Now additively render the glow texture.
+	qglBindTexture( GL_TEXTURE_RECTANGLE_EXT, tr.blurImage );     
+	qglBegin(GL_QUADS);    
+		qglColor4f( 1.0f, 1.0f, 1.0f, 1.0f );  
+		qglTexCoord2f( 0, r_DynamicGlowHeight->integer ); 
+		qglVertex2f( 0, 0 );
+
+		qglTexCoord2f( 0, 0 );
+		qglVertex2f( 0, glConfig.vidHeight );
+
+		qglTexCoord2f( r_DynamicGlowWidth->integer, 0 );
+		qglVertex2f( glConfig.vidWidth, glConfig.vidHeight );
+
+		qglTexCoord2f( r_DynamicGlowWidth->integer, r_DynamicGlowHeight->integer );
+		qglVertex2f( glConfig.vidWidth, 0 );
+	qglEnd();
+
+	qglDisable( GL_TEXTURE_RECTANGLE_EXT );
+	qglEnable( GL_TEXTURE_2D );
+	qglBlendFunc( GL_SRC_COLOR, GL_ONE_MINUS_SRC_COLOR );
+	qglDisable( GL_BLEND );
+
+	qglMatrixMode(GL_PROJECTION);
+	qglPopMatrix();
+	qglMatrixMode(GL_MODELVIEW);
+	qglPopMatrix();
+}
+#endif
diff --git a/code/renderer/tr_bsp.cpp b/code/renderer/tr_bsp.cpp
new file mode 100644
index 0000000..9d5fe55
--- /dev/null
+++ b/code/renderer/tr_bsp.cpp
@@ -0,0 +1,1458 @@
+// tr_map.c
+
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+
+#include "tr_local.h"
+
+/*
+
+Loads and prepares a map file for scene rendering.
+
+A single entry point:
+
+void RE_LoadWorldMap( const char *name );
+
+*/
+
+static	world_t		s_worldData;
+static	byte		*fileBase;
+
+int			c_subdivisions;
+int			c_gridVerts;
+
+void R_RMGInit(void);
+//===============================================================================
+
+static void HSVtoRGB( float h, float s, float v, float rgb[3] )
+{
+	int i;
+	float f;
+	float p, q, t;
+
+	h *= 5;
+
+	i = floor( h );
+	f = h - i;
+
+	p = v * ( 1 - s );
+	q = v * ( 1 - s * f );
+	t = v * ( 1 - s * ( 1 - f ) );
+
+	switch ( i )
+	{
+	case 0:
+		rgb[0] = v;
+		rgb[1] = t;
+		rgb[2] = p;
+		break;
+	case 1:
+		rgb[0] = q;
+		rgb[1] = v;
+		rgb[2] = p;
+		break;
+	case 2:
+		rgb[0] = p;
+		rgb[1] = v;
+		rgb[2] = t;
+		break;
+	case 3:
+		rgb[0] = p;
+		rgb[1] = q;
+		rgb[2] = v;
+		break;
+	case 4:
+		rgb[0] = t;
+		rgb[1] = p;
+		rgb[2] = v;
+		break;
+	case 5:
+		rgb[0] = v;
+		rgb[1] = p;
+		rgb[2] = q;
+		break;
+	}
+}
+
+/*
+===============
+R_ColorShiftLightingBytes
+
+===============
+*/
+void R_ColorShiftLightingBytes( byte in[4], byte out[4] ) {
+	int		shift=0, r, g, b;
+
+	// should NOT do it if overbrightBits is 0
+	if (tr.overbrightBits)
+		shift = 1 - tr.overbrightBits;
+
+	if (!shift)
+	{
+		out[0] = in[0];
+		out[1] = in[1];
+		out[2] = in[2];
+		out[3] = in[3];
+		return;
+	}
+
+	// shift the data based on overbright range
+	r = in[0] << shift;
+	g = in[1] << shift;
+	b = in[2] << shift;
+	
+	// normalize by color instead of saturating to white
+	if ( ( r | g | b ) > 255 ) {
+		int		max;
+
+		max = r > g ? r : g;
+		max = max > b ? max : b;
+		r = r * 255 / max;
+		g = g * 255 / max;
+		b = b * 255 / max;
+	}
+
+	out[0] = r;
+	out[1] = g;
+	out[2] = b;
+	out[3] = in[3];
+}
+
+/*
+===============
+R_ColorShiftLightingBytes
+
+===============
+*/
+static	void R_ColorShiftLightingBytes( byte in[3]) 
+{
+	int		shift=0, r, g, b;
+
+	// should NOT do it if overbrightBits is 0
+	if (tr.overbrightBits)
+		shift = 1 - tr.overbrightBits;
+
+	if (!shift) {
+		return;	//no need if not overbright
+	}
+	// shift the data based on overbright range
+	r = in[0] << shift;
+	g = in[1] << shift;
+	b = in[2] << shift;
+	
+	// normalize by color instead of saturating to white
+	if ( ( r | g | b ) > 255 ) {
+		int		max;
+
+		max = r > g ? r : g;
+		max = max > b ? max : b;
+		r = r * 255 / max;
+		g = g * 255 / max;
+		b = b * 255 / max;
+	}
+
+	in[0] = r;
+	in[1] = g;
+	in[2] = b;
+}
+
+
+/*
+===============
+R_LoadLightmaps
+
+===============
+*/
+#define	LIGHTMAP_SIZE	128
+static	void R_LoadLightmaps( lump_t *l, const char *psMapName, world_t &worldData ) 
+{
+	byte				*buf, *buf_p;
+	int					len;
+	MAC_STATIC byte		image[LIGHTMAP_SIZE*LIGHTMAP_SIZE*4];
+	int					i, j;
+	float				maxIntensity = 0;
+	double				sumIntensity = 0;
+	int					count;
+
+	if (&worldData == &s_worldData)
+	{
+		tr.numLightmaps = 0;
+	}
+
+    len = l->filelen;
+	if ( !len ) {
+		return;
+	}
+	buf = fileBase + l->fileofs;
+
+	// we are about to upload textures
+	//R_SyncRenderThread();
+
+	// create all the lightmaps
+	worldData.startLightMapIndex = tr.numLightmaps;
+	count = len / (LIGHTMAP_SIZE * LIGHTMAP_SIZE * 3);
+	tr.numLightmaps += count;
+
+	// if we are in r_vertexLight mode, we don't need the lightmaps at all
+	if ( r_vertexLight->integer ) {
+		return;
+	}
+
+	char sMapName[MAX_QPATH];
+	COM_StripExtension(psMapName,sMapName);	// will already by MAX_QPATH legal, so no length check
+
+	for ( i = 0 ; i < count ; i++ ) {
+		// expand the 24 bit on-disk to 32 bit
+		buf_p = buf + i * LIGHTMAP_SIZE*LIGHTMAP_SIZE * 3;
+
+		if ( r_lightmap->integer == 2 )
+		{	// color code by intensity as development tool	(FIXME: check range)
+			for ( j = 0; j < LIGHTMAP_SIZE * LIGHTMAP_SIZE; j++ )
+			{
+				float r = buf_p[j*3+0];
+				float g = buf_p[j*3+1];
+				float b = buf_p[j*3+2];
+				float intensity;
+				float out[3];
+
+				intensity = 0.33f * r + 0.685f * g + 0.063f * b;
+
+				if ( intensity > 255 )
+					intensity = 1.0f;
+				else
+					intensity /= 255.0f;
+
+				if ( intensity > maxIntensity )
+					maxIntensity = intensity;
+
+				HSVtoRGB( intensity, 1.00, 0.50, out );
+
+				image[j*4+0] = out[0] * 255;
+				image[j*4+1] = out[1] * 255;
+				image[j*4+2] = out[2] * 255;
+				image[j*4+3] = 255;
+
+				sumIntensity += intensity;
+			}
+		} else {
+			for ( j = 0 ; j < LIGHTMAP_SIZE * LIGHTMAP_SIZE; j++ ) {
+				R_ColorShiftLightingBytes( &buf_p[j*3], &image[j*4] );
+				image[j*4+3] = 255;
+			}
+		}
+		tr.lightmaps[worldData.startLightMapIndex+i] = R_CreateImage( va("$%s/lightmap%d",sMapName,worldData.startLightMapIndex+i), image, 
+			LIGHTMAP_SIZE, LIGHTMAP_SIZE, GL_RGBA, qfalse, qfalse, r_ext_compressed_lightmaps->integer, GL_CLAMP );
+	}
+
+	if ( r_lightmap->integer == 2 )	{
+		VID_Printf( PRINT_ALL, "Brightest lightmap value: %d\n", ( int ) ( maxIntensity * 255 ) );
+	}
+}
+
+
+
+/*
+=================
+RE_SetWorldVisData
+
+This is called by the clipmodel subsystem so we can share the 1.8 megs of
+space in big maps...
+=================
+*/
+void		RE_SetWorldVisData( const byte *vis ) {
+	tr.externalVisData = vis;
+}
+
+
+/*
+=================
+R_LoadVisibility
+=================
+*/
+static	void R_LoadVisibility( lump_t *l, world_t &worldData ) {
+	int		len;
+	byte	*buf;
+
+	len = ( worldData.numClusters + 63 ) & ~63;
+	worldData.novis = ( unsigned char *) Hunk_Alloc( len, qfalse );
+	memset( worldData.novis, 0xff, len );
+
+    len = l->filelen;
+	if ( !len ) {
+		return;
+	}
+	buf = fileBase + l->fileofs;
+
+	worldData.numClusters = LittleLong( ((int *)buf)[0] );
+	worldData.clusterBytes = LittleLong( ((int *)buf)[1] );
+
+	// CM_Load should have given us the vis data to share, so
+	// we don't need to allocate another copy
+	if ( tr.externalVisData ) {
+		worldData.vis = tr.externalVisData;
+	} else {
+		byte	*dest;
+
+		dest = (byte *) Hunk_Alloc( len - 8, qfalse );
+		memcpy( dest, buf + 8, len - 8 );
+		worldData.vis = dest;
+	}
+}
+
+//===============================================================================
+
+qhandle_t R_GetShaderByNum(int shaderNum, world_t &worldData)
+{
+	qhandle_t	shader;
+
+	if ( (shaderNum < 0) || (shaderNum >= worldData.numShaders) ) 
+	{
+		Com_Printf( "Warning: Bad index for R_GetShaderByNum - %i", shaderNum );
+		return(0);
+	}
+	shader = RE_RegisterShader(worldData.shaders[ shaderNum ].shader);
+	return(shader);
+}
+
+/*
+===============
+ShaderForShaderNum
+===============
+*/
+static shader_t *ShaderForShaderNum( int shaderNum, const int *lightmapNum, const byte *lightmapStyles, const byte *vertexStyles, world_t &worldData ) {
+	shader_t	*shader;
+	dshader_t	*dsh;
+	const byte	*styles;
+
+	styles = lightmapStyles;
+
+	shaderNum = LittleLong( shaderNum );
+	if ( shaderNum < 0 || shaderNum >= worldData.numShaders ) {
+		Com_Error( ERR_DROP, "ShaderForShaderNum: bad num %i", shaderNum );
+	}
+	dsh = &worldData.shaders[ shaderNum ];
+
+	if (lightmapNum[0] == LIGHTMAP_BY_VERTEX)
+	{
+		styles = vertexStyles;
+	}
+
+	if ( r_vertexLight->integer ) 
+	{
+		lightmapNum = lightmapsVertex;
+		styles = vertexStyles;
+	}
+
+/*	if ( r_fullbright->integer ) 
+	{
+		lightmapNum = lightmapsFullBright;
+		styles = vertexStyles;
+	}
+*/
+	shader = R_FindShader( dsh->shader, lightmapNum, styles, qtrue );
+
+	// if the shader had errors, just use default shader
+	if ( shader->defaultShader ) {
+		return tr.defaultShader;
+	}
+
+	return shader;
+}
+
+/*
+===============
+ParseFace
+===============
+*/
+static void ParseFace( dsurface_t *ds, mapVert_t *verts, msurface_t *surf, int *indexes, byte *&pFaceDataBuffer, world_t &worldData, int index )
+{
+	int			i, j, k;
+	srfSurfaceFace_t	*cv;
+	int			numPoints, numIndexes;
+	int			lightmapNum[MAXLIGHTMAPS];
+	int			sfaceSize, ofsIndexes;
+
+	for(i=0;i<MAXLIGHTMAPS;i++)
+	{
+		lightmapNum[i] = LittleLong( ds->lightmapNum[i] );
+		if (lightmapNum[i] >= 0)
+		{
+			lightmapNum[i] += worldData.startLightMapIndex;
+		}
+	}
+
+	// get fog volume
+	surf->fogIndex = LittleLong( ds->fogNum ) + 1;
+	if (index && !surf->fogIndex && tr.world && tr.world->globalFog != -1)
+	{
+		surf->fogIndex = worldData.globalFog;
+	}
+
+	// get shader value
+	surf->shader = ShaderForShaderNum( ds->shaderNum, lightmapNum, ds->lightmapStyles, ds->vertexStyles, worldData );
+	if ( r_singleShader->integer && !surf->shader->sky ) {
+		surf->shader = tr.defaultShader;
+	}
+
+	numPoints = LittleLong( ds->numVerts );
+	numIndexes = LittleLong( ds->numIndexes );
+
+	// create the srfSurfaceFace_t
+	sfaceSize = ( int ) &((srfSurfaceFace_t *)0)->points[numPoints];
+	ofsIndexes = sfaceSize;
+	sfaceSize += sizeof( int ) * numIndexes;
+
+	cv = (srfSurfaceFace_t *) pFaceDataBuffer;//Hunk_Alloc( sfaceSize );
+	pFaceDataBuffer += sfaceSize;	// :-)
+
+	cv->surfaceType = SF_FACE;
+	cv->numPoints = numPoints;
+	cv->numIndices = numIndexes;
+	cv->ofsIndices = ofsIndexes;
+
+	verts += LittleLong( ds->firstVert );
+	for ( i = 0 ; i < numPoints ; i++ ) {
+		for ( j = 0 ; j < 3 ; j++ ) {
+			cv->points[i][j] = LittleFloat( verts[i].xyz[j] );
+		}
+		for ( j = 0 ; j < 2 ; j++ ) {
+			cv->points[i][3+j] = LittleFloat( verts[i].st[j] );
+			for(k=0;k<MAXLIGHTMAPS;k++)
+			{
+				cv->points[i][VERTEX_LM+j+(k*2)] = LittleFloat( verts[i].lightmap[k][j] );
+			}
+		}
+		for(k=0;k<MAXLIGHTMAPS;k++)
+		{
+			R_ColorShiftLightingBytes( verts[i].color[k], (byte *)&cv->points[i][VERTEX_COLOR+k] );
+		}
+	}
+
+	indexes += LittleLong( ds->firstIndex );
+	for ( i = 0 ; i < numIndexes ; i++ ) {
+		((int *)((byte *)cv + cv->ofsIndices ))[i] = LittleLong( indexes[ i ] );
+	}
+
+	// take the plane information from the lightmap vector
+	for ( i = 0 ; i < 3 ; i++ ) {
+		cv->plane.normal[i] = LittleFloat( ds->lightmapVecs[2][i] );
+	}
+	cv->plane.dist = DotProduct( cv->points[0], cv->plane.normal );
+	SetPlaneSignbits( &cv->plane );
+	cv->plane.type = PlaneTypeForNormal( cv->plane.normal );
+
+	surf->data = (surfaceType_t *)cv;
+}
+
+
+/*
+===============
+ParseMesh
+===============
+*/
+static void ParseMesh ( dsurface_t *ds, mapVert_t *verts, msurface_t *surf, world_t &worldData, int index) {
+	srfGridMesh_t	*grid;
+	int				i, j, k;
+	int				width, height, numPoints;
+	MAC_STATIC drawVert_t points[MAX_PATCH_SIZE*MAX_PATCH_SIZE];
+	int				lightmapNum[MAXLIGHTMAPS];
+	vec3_t			bounds[2];
+	vec3_t			tmpVec;
+	static surfaceType_t	skipData = SF_SKIP;
+
+	for(i=0;i<MAXLIGHTMAPS;i++)
+	{
+		lightmapNum[i] = LittleLong( ds->lightmapNum[i] );
+		if (lightmapNum[i] >= 0)
+		{
+			lightmapNum[i] += worldData.startLightMapIndex;
+		}
+	}
+
+	// get fog volume
+	surf->fogIndex = LittleLong( ds->fogNum ) + 1;
+	if (index && !surf->fogIndex && tr.world && tr.world->globalFog != -1)
+	{
+		surf->fogIndex = worldData.globalFog;
+	}
+
+	// get shader value
+	surf->shader = ShaderForShaderNum( ds->shaderNum, lightmapNum, ds->lightmapStyles, ds->vertexStyles, worldData );
+	if ( r_singleShader->integer && !surf->shader->sky ) {
+		surf->shader = tr.defaultShader;
+	}
+
+	// we may have a nodraw surface, because they might still need to
+	// be around for movement clipping
+	if ( worldData.shaders[ LittleLong( ds->shaderNum ) ].surfaceFlags & SURF_NODRAW ) {
+		surf->data = &skipData;
+		return;
+	}
+
+	width = LittleLong( ds->patchWidth );
+	height = LittleLong( ds->patchHeight );
+
+	verts += LittleLong( ds->firstVert );
+	numPoints = width * height;
+	for ( i = 0 ; i < numPoints ; i++ ) {
+		for ( j = 0 ; j < 3 ; j++ ) {
+			points[i].xyz[j] = LittleFloat( verts[i].xyz[j] );
+			points[i].normal[j] = LittleFloat( verts[i].normal[j] );
+		}
+		for ( j = 0 ; j < 2 ; j++ ) {
+			points[i].st[j] = LittleFloat( verts[i].st[j] );
+			for(k=0;k<MAXLIGHTMAPS;k++)
+			{
+				points[i].lightmap[k][j] = LittleFloat( verts[i].lightmap[k][j] );
+			}
+		}
+		for(k=0;k<MAXLIGHTMAPS;k++)
+		{
+			R_ColorShiftLightingBytes( verts[i].color[k], points[i].color[k] );
+		}
+	}
+
+	// pre-tesseleate
+	grid = R_SubdividePatchToGrid( width, height, points );
+	surf->data = (surfaceType_t *)grid;
+
+	// copy the level of detail origin, which is the center
+	// of the group of all curves that must subdivide the same
+	// to avoid cracking
+	for ( i = 0 ; i < 3 ; i++ ) {
+		bounds[0][i] = LittleFloat( ds->lightmapVecs[0][i] );
+		bounds[1][i] = LittleFloat( ds->lightmapVecs[1][i] );
+	}
+	VectorAdd( bounds[0], bounds[1], bounds[1] );
+	VectorScale( bounds[1], 0.5f, grid->lodOrigin );
+	VectorSubtract( bounds[0], grid->lodOrigin, tmpVec );
+	grid->lodRadius = VectorLength( tmpVec );
+}
+
+/*
+===============
+ParseTriSurf
+===============
+*/
+static void ParseTriSurf( dsurface_t *ds, mapVert_t *verts, msurface_t *surf, int *indexes, world_t &worldData, int index ) {
+	srfTriangles_t	*tri;
+	int				i, j, k;
+	int				numVerts, numIndexes;
+
+	// get fog volume
+	surf->fogIndex = LittleLong( ds->fogNum ) + 1;
+	if (index && !surf->fogIndex && tr.world && tr.world->globalFog != -1)
+	{
+		surf->fogIndex = worldData.globalFog;
+	}
+
+	// get shader
+	surf->shader = ShaderForShaderNum( ds->shaderNum, lightmapsVertex, ds->lightmapStyles, ds->vertexStyles, worldData );
+	if ( r_singleShader->integer && !surf->shader->sky ) {
+		surf->shader = tr.defaultShader;
+	}
+
+	numVerts = LittleLong( ds->numVerts );
+	numIndexes = LittleLong( ds->numIndexes );
+
+	if ( numVerts >= SHADER_MAX_VERTEXES ) {
+		Com_Error(ERR_DROP, "ParseTriSurf: verts > MAX (%d > %d) on misc_model %s", numVerts, SHADER_MAX_VERTEXES, surf->shader->name );
+	}
+	if ( numIndexes >= SHADER_MAX_INDEXES ) {
+		Com_Error(ERR_DROP, "ParseTriSurf: indices > MAX (%d > %d) on misc_model %s", numIndexes, SHADER_MAX_INDEXES, surf->shader->name );
+	}
+
+	tri = (srfTriangles_t *) Z_Malloc( sizeof( *tri ) + numVerts * sizeof( tri->verts[0] ) + numIndexes * sizeof( tri->indexes[0] ), TAG_HUNKMISCMODELS, qfalse );
+	tri->dlightBits = 0; //JIC
+	tri->surfaceType = SF_TRIANGLES;
+	tri->numVerts = numVerts;
+	tri->numIndexes = numIndexes;
+	tri->verts = (drawVert_t *)(tri + 1);
+	tri->indexes = (int *)(tri->verts + tri->numVerts );
+
+	surf->data = (surfaceType_t *)tri;
+
+	// copy vertexes
+	verts += LittleLong( ds->firstVert );
+	ClearBounds( tri->bounds[0], tri->bounds[1] );
+	for ( i = 0 ; i < numVerts ; i++ ) {
+		for ( j = 0 ; j < 3 ; j++ ) {
+			tri->verts[i].xyz[j] = LittleFloat( verts[i].xyz[j] );
+			tri->verts[i].normal[j] = LittleFloat( verts[i].normal[j] );
+		}
+		AddPointToBounds( tri->verts[i].xyz, tri->bounds[0], tri->bounds[1] );
+		for ( j = 0 ; j < 2 ; j++ ) {
+			tri->verts[i].st[j] = LittleFloat( verts[i].st[j] );
+			for(k=0;k<MAXLIGHTMAPS;k++)
+			{
+				tri->verts[i].lightmap[k][j] = LittleFloat( verts[i].lightmap[k][j] );
+			}
+		}
+		for(k=0;k<MAXLIGHTMAPS;k++)
+		{
+			R_ColorShiftLightingBytes( verts[i].color[k], tri->verts[i].color[k] );
+		}
+	}
+
+	// copy indexes
+	indexes += LittleLong( ds->firstIndex );
+	for ( i = 0 ; i < numIndexes ; i++ ) {
+		tri->indexes[i] = LittleLong( indexes[i] );
+		if ( tri->indexes[i] < 0 || tri->indexes[i] >= numVerts ) {
+			Com_Error( ERR_DROP, "Bad index in triangle surface" );
+		}
+	}
+}
+
+/*
+===============
+ParseFlare
+===============
+*/
+static void ParseFlare( dsurface_t *ds, mapVert_t *verts, msurface_t *surf, int *indexes, world_t &worldData, int index ) {
+	srfFlare_t		*flare;
+	int				i;
+	int		lightmaps[MAXLIGHTMAPS] = { LIGHTMAP_BY_VERTEX };
+
+	// get fog volume
+	surf->fogIndex = LittleLong( ds->fogNum ) + 1;
+	if (index && !surf->fogIndex && tr.world->globalFog != -1)
+	{
+		surf->fogIndex = worldData.globalFog;
+	}
+
+	// get shader
+	surf->shader = ShaderForShaderNum( ds->shaderNum, lightmaps, ds->lightmapStyles, ds->vertexStyles, worldData );
+	if ( r_singleShader->integer && !surf->shader->sky ) {
+		surf->shader = tr.defaultShader;
+	}
+
+	flare = (srfFlare_t *) Hunk_Alloc( sizeof( *flare ), qtrue );
+	flare->surfaceType = SF_FLARE;
+
+	surf->data = (surfaceType_t *)flare;
+
+	for ( i = 0 ; i < 3 ; i++ ) {
+		flare->origin[i] = LittleFloat( ds->lightmapOrigin[i] );
+		flare->color[i] = LittleFloat( ds->lightmapVecs[0][i] );
+		flare->normal[i] = LittleFloat( ds->lightmapVecs[2][i] );
+	}
+}
+
+/*
+===============
+R_LoadSurfaces
+===============
+*/
+static	void R_LoadSurfaces( lump_t *surfs, lump_t *verts, lump_t *indexLump, world_t &worldData, int index ) {
+	dsurface_t	*in;
+	msurface_t	*out;
+	mapVert_t	*dv;
+	int			*indexes;
+	int			count;
+	int			numFaces, numMeshes, numTriSurfs, numFlares;
+	int			i;
+
+	numFaces = 0;
+	numMeshes = 0;
+	numTriSurfs = 0;
+	numFlares = 0;
+
+	in = (dsurface_t *)(fileBase + surfs->fileofs);
+	if (surfs->filelen % sizeof(*in))
+		Com_Error (ERR_DROP, "LoadMap: funny lump size in %s",tr.worldDir);
+	count = surfs->filelen / sizeof(*in);
+
+	dv = (mapVert_t *)(fileBase + verts->fileofs);
+	if (verts->filelen % sizeof(*dv))
+		Com_Error (ERR_DROP, "LoadMap: funny lump size in %s",tr.worldDir);
+
+	indexes = (int *)(fileBase + indexLump->fileofs);
+	if ( indexLump->filelen % sizeof(*indexes))
+		Com_Error (ERR_DROP, "LoadMap: funny lump size in %s",tr.worldDir);
+
+	out = (struct msurface_s *) Hunk_Alloc ( count * sizeof(*out), qtrue );	
+
+	worldData.surfaces = out;
+	worldData.numsurfaces = count;
+
+	// new bit, the face code on our biggest map requires over 15,000 mallocs, which was no problem on the hunk,
+	//	bit hits the zone pretty bad (even the tagFree takes about 9 seconds for that many memblocks), 
+	//	so special-case pre-alloc enough space for this data (the patches etc can stay as they are)...
+	//
+	int iFaceDataSizeRequired = 0;
+	for ( i = 0 ; i < count ; i++, in++) 
+	{
+		switch ( LittleLong( in->surfaceType ) ) 
+		{
+			case MST_PLANAR:
+				
+				int sfaceSize = ( int ) &((srfSurfaceFace_t *)0)->points[LittleLong(in->numVerts)];	
+					sfaceSize += sizeof( int ) * LittleLong(in->numIndexes);
+
+				iFaceDataSizeRequired += sfaceSize;
+				break;
+		}
+	}
+	in -= count;	// back it up, ready for loop-proper
+
+	// since this ptr is to hunk data, I can pass it in and have it advanced without worrying about losing
+	//	the original alloc ptr...
+	//
+	byte *pFaceDataBuffer	= (byte *)Hunk_Alloc( iFaceDataSizeRequired, qtrue );	
+
+	// now do regular loop...
+	//
+	for ( i = 0 ; i < count ; i++, in++, out++ ) {
+		switch ( LittleLong( in->surfaceType ) ) {
+		case MST_PATCH:
+			ParseMesh ( in, dv, out, worldData, index );
+			numMeshes++;
+			break;
+		case MST_TRIANGLE_SOUP:
+			ParseTriSurf( in, dv, out, indexes, worldData, index );
+			numTriSurfs++;
+			break;
+		case MST_PLANAR:
+			ParseFace( in, dv, out, indexes, pFaceDataBuffer, worldData, index );
+			numFaces++;
+			break;
+		case MST_FLARE:
+			ParseFlare( in, dv, out, indexes, worldData, index );
+			numFlares++;
+			break;
+		default:
+			Com_Error( ERR_DROP, "Bad surfaceType" );
+		}
+	}
+	
+	VID_Printf( PRINT_ALL, "...loaded %d faces, %i meshes, %i trisurfs, %i flares\n", 
+		numFaces, numMeshes, numTriSurfs, numFlares );
+}
+
+
+
+/*
+=================
+R_LoadSubmodels
+=================
+*/
+static	void R_LoadSubmodels( lump_t *l, world_t &worldData, int index  ) {
+	dmodel_t	*in;
+	bmodel_t	*out;
+	int			i, j, count;
+
+	in = (dmodel_t *)(fileBase + l->fileofs);
+	if (l->filelen % sizeof(*in))
+		Com_Error (ERR_DROP, "LoadMap: funny lump size in %s",tr.worldDir);
+	count = l->filelen / sizeof(*in);
+
+	worldData.bmodels = out = (bmodel_t *) Hunk_Alloc( count * sizeof(*out), qtrue );
+
+	for ( i=0 ; i<count ; i++, in++, out++ ) {
+		model_t *model;
+
+		model = R_AllocModel();
+
+		assert( model != NULL );			// this should never happen
+
+		model->type = MOD_BRUSH;
+		model->bmodel = out;
+		if (index)
+		{
+			Com_sprintf( model->name, sizeof( model->name ), "*%d-%d", index, i );
+			model->bspInstance = true;
+		}
+		else
+		{
+			Com_sprintf( model->name, sizeof( model->name ), "*%d", i);
+		}
+
+		for (j=0 ; j<3 ; j++) {
+			out->bounds[0][j] = LittleFloat (in->mins[j]);
+			out->bounds[1][j] = LittleFloat (in->maxs[j]);
+		}
+/*
+Ghoul2 Insert Start
+*/
+
+		RE_InsertModelIntoHash(model->name, model);
+/*
+Ghoul2 Insert End
+*/
+
+		out->firstSurface = worldData.surfaces + LittleLong( in->firstSurface );
+		out->numSurfaces = LittleLong( in->numSurfaces );
+	}
+}
+
+
+
+//==================================================================
+
+/*
+=================
+R_SetParent
+=================
+*/
+static	void R_SetParent (mnode_t *node, mnode_t *parent)
+{
+	node->parent = parent;
+	if (node->contents != -1)
+		return;
+	R_SetParent (node->children[0], node);
+	R_SetParent (node->children[1], node);
+}
+
+/*
+=================
+R_LoadNodesAndLeafs
+=================
+*/
+static	void R_LoadNodesAndLeafs (lump_t *nodeLump, lump_t *leafLump, world_t &worldData) {
+	int			i, j, p;
+	dnode_t		*in;
+	dleaf_t		*inLeaf;
+	mnode_t 	*out;
+	int			numNodes, numLeafs;
+
+	in = (dnode_t *)(fileBase + nodeLump->fileofs);
+	if (nodeLump->filelen % sizeof(dnode_t) ||
+		leafLump->filelen % sizeof(dleaf_t) ) {
+		Com_Error (ERR_DROP, "LoadMap: funny lump size in %s",tr.worldDir);
+	}
+	numNodes = nodeLump->filelen / sizeof(dnode_t);
+	numLeafs = leafLump->filelen / sizeof(dleaf_t);
+
+	out = (struct mnode_s *) Hunk_Alloc ( (numNodes + numLeafs) * sizeof(*out), qtrue );	
+
+	worldData.nodes = out;
+	worldData.numnodes = numNodes + numLeafs;
+	worldData.numDecisionNodes = numNodes;
+
+	// load nodes
+	for ( i=0 ; i<numNodes; i++, in++, out++)
+	{
+		for (j=0 ; j<3 ; j++)
+		{
+			out->mins[j] = LittleLong (in->mins[j]);
+			out->maxs[j] = LittleLong (in->maxs[j]);
+		}
+	
+		p = LittleLong(in->planeNum);
+		out->plane = worldData.planes + p;
+
+		out->contents = CONTENTS_NODE;	// differentiate from leafs
+
+		for (j=0 ; j<2 ; j++)
+		{
+			p = LittleLong (in->children[j]);
+			if (p >= 0)
+				out->children[j] = worldData.nodes + p;
+			else
+				out->children[j] = worldData.nodes + numNodes + (-1 - p);
+		}
+	}
+	
+	// load leafs
+	inLeaf = (dleaf_t *)(fileBase + leafLump->fileofs);
+	for ( i=0 ; i<numLeafs ; i++, inLeaf++, out++)
+	{
+		for (j=0 ; j<3 ; j++)
+		{
+			out->mins[j] = LittleLong (inLeaf->mins[j]);
+			out->maxs[j] = LittleLong (inLeaf->maxs[j]);
+		}
+
+		out->cluster = LittleLong(inLeaf->cluster);
+		out->area = LittleLong(inLeaf->area);
+
+		if ( out->cluster >= worldData.numClusters ) {
+			worldData.numClusters = out->cluster + 1;
+		}
+
+		out->firstmarksurface = worldData.marksurfaces +
+			LittleLong(inLeaf->firstLeafSurface);
+		out->nummarksurfaces = LittleLong(inLeaf->numLeafSurfaces);
+	}	
+
+	// chain decendants
+	R_SetParent (worldData.nodes, NULL);
+}
+
+//=============================================================================
+
+/*
+=================
+R_LoadShaders
+=================
+*/
+static	void R_LoadShaders( lump_t *l, world_t &worldData ) {	
+	int		i, count;
+	dshader_t	*in, *out;
+	
+	in = (dshader_t *)(fileBase + l->fileofs);
+	if (l->filelen % sizeof(*in))
+		Com_Error (ERR_DROP, "LoadMap: funny lump size in %s",tr.worldDir);
+	count = l->filelen / sizeof(*in);
+	out = (dshader_t *) Hunk_Alloc ( count*sizeof(*out), qfalse );
+
+	worldData.shaders = out;
+	worldData.numShaders = count;
+
+	memcpy( out, in, count*sizeof(*out) );
+
+	for ( i=0 ; i<count ; i++ ) {
+		out[i].surfaceFlags = LittleLong( out[i].surfaceFlags );
+		out[i].contentFlags = LittleLong( out[i].contentFlags );
+	}
+}
+
+
+/*
+=================
+R_LoadMarksurfaces
+=================
+*/
+static	void R_LoadMarksurfaces (lump_t *l, world_t &worldData)
+{	
+	int		i, j, count;
+	int		*in;
+	msurface_t **out;
+	
+	in = (int *)(fileBase + l->fileofs);
+	if (l->filelen % sizeof(*in))
+		Com_Error (ERR_DROP, "LoadMap: funny lump size in %s",tr.worldDir);
+	count = l->filelen / sizeof(*in);
+	out = (struct msurface_s **) Hunk_Alloc ( count*sizeof(*out), qtrue );	
+
+	worldData.marksurfaces = out;
+	worldData.nummarksurfaces = count;
+
+	for ( i=0 ; i<count ; i++)
+	{
+		j = LittleLong(in[i]);
+		out[i] = worldData.surfaces + j;
+	}
+}
+
+
+/*
+=================
+R_LoadPlanes
+=================
+*/
+static	void R_LoadPlanes( lump_t *l, world_t &worldData ) {
+	int			i, j;
+	cplane_t	*out;
+	dplane_t 	*in;
+	int			count;
+	int			bits;
+	
+	in = (dplane_t *)(fileBase + l->fileofs);
+	if (l->filelen % sizeof(*in))
+		Com_Error (ERR_DROP, "LoadMap: funny lump size in %s",tr.worldDir);
+	count = l->filelen / sizeof(*in);
+	out = (struct cplane_s *) Hunk_Alloc ( count*2*sizeof(*out), qtrue );	
+	
+	worldData.planes = out;
+	worldData.numplanes = count;
+
+	for ( i=0 ; i<count ; i++, in++, out++) {
+		bits = 0;
+		for (j=0 ; j<3 ; j++) {
+			out->normal[j] = LittleFloat (in->normal[j]);
+			if (out->normal[j] < 0) {
+				bits |= 1<<j;
+			}
+		}
+
+		out->dist = LittleFloat (in->dist);
+		out->type = PlaneTypeForNormal( out->normal );
+		out->signbits = bits;
+	}
+}
+
+/*
+=================
+R_LoadFogs
+
+=================
+*/
+static	void R_LoadFogs( lump_t *l, lump_t *brushesLump, lump_t *sidesLump, world_t &worldData, int index ) {
+	int			i;
+	fog_t		*out;
+	dfog_t		*fogs;
+	dbrush_t 	*brushes, *brush;
+	dbrushside_t	*sides;
+	int			count, brushesCount, sidesCount;
+	int			sideNum;
+	int			planeNum;
+	shader_t	*shader;
+	float		d;
+	int			firstSide=0;
+	int			lightmaps[MAXLIGHTMAPS] = { LIGHTMAP_NONE } ;
+
+	fogs = (dfog_t *)(fileBase + l->fileofs);
+	if (l->filelen % sizeof(*fogs)) {
+		Com_Error (ERR_DROP, "LoadMap: funny lump size in %s",tr.worldDir);
+	}
+	count = l->filelen / sizeof(*fogs);
+
+	// create fog strucutres for them
+	worldData.numfogs = count + 1;
+	worldData.fogs = (fog_t *)Hunk_Alloc ( (worldData.numfogs+1)*sizeof(*out), qtrue);
+	worldData.globalFog = -1;
+	out = worldData.fogs + 1;
+
+	// Copy the global fog from the main world into the bsp instance
+	if(index)
+	{
+		if(tr.world && (tr.world->globalFog != -1))
+		{
+			// Use the nightvision fog slot
+			worldData.fogs[worldData.numfogs] = tr.world->fogs[tr.world->globalFog];
+			worldData.globalFog = worldData.numfogs;
+			worldData.numfogs++;
+		}
+	}
+
+	if ( !count ) {
+		return;
+	}
+
+	brushes = (dbrush_t *)(fileBase + brushesLump->fileofs);
+	if (brushesLump->filelen % sizeof(*brushes)) {
+		Com_Error (ERR_DROP, "LoadMap: funny lump size in %s",tr.worldDir);
+	}
+	brushesCount = brushesLump->filelen / sizeof(*brushes);
+
+	sides = (dbrushside_t *)(fileBase + sidesLump->fileofs);
+	if (sidesLump->filelen % sizeof(*sides)) {
+		Com_Error (ERR_DROP, "LoadMap: funny lump size in %s",tr.worldDir);
+	}
+	sidesCount = sidesLump->filelen / sizeof(*sides);
+
+	for ( i=0 ; i<count ; i++, fogs++) {
+		out->originalBrushNumber = LittleLong( fogs->brushNum );
+		if (out->originalBrushNumber == -1)
+		{
+			if(index)
+			{
+				Com_Error (ERR_DROP, "LoadMap: global fog not allowed in bsp instances - %s", tr.worldDir);
+			}
+			VectorSet(out->bounds[0], MIN_WORLD_COORD, MIN_WORLD_COORD, MIN_WORLD_COORD);
+			VectorSet(out->bounds[1], MAX_WORLD_COORD, MAX_WORLD_COORD, MAX_WORLD_COORD);
+			worldData.globalFog = i + 1;
+		}
+		else
+		{
+			if ( (unsigned)out->originalBrushNumber >= brushesCount ) {
+				Com_Error( ERR_DROP, "fog brushNumber out of range" );
+			}
+			brush = brushes + out->originalBrushNumber;
+
+			firstSide = LittleLong( brush->firstSide );
+
+				if ( (unsigned)firstSide > sidesCount - 6 ) {
+				Com_Error( ERR_DROP, "fog brush sideNumber out of range" );
+			}
+
+			// brushes are always sorted with the axial sides first
+			sideNum = firstSide + 0;
+			planeNum = LittleLong( sides[ sideNum ].planeNum );
+			out->bounds[0][0] = -worldData.planes[ planeNum ].dist;
+
+			sideNum = firstSide + 1;
+			planeNum = LittleLong( sides[ sideNum ].planeNum );
+			out->bounds[1][0] = worldData.planes[ planeNum ].dist;
+
+			sideNum = firstSide + 2;
+			planeNum = LittleLong( sides[ sideNum ].planeNum );
+			out->bounds[0][1] = -worldData.planes[ planeNum ].dist;
+
+			sideNum = firstSide + 3;
+			planeNum = LittleLong( sides[ sideNum ].planeNum );
+			out->bounds[1][1] = worldData.planes[ planeNum ].dist;
+
+			sideNum = firstSide + 4;
+			planeNum = LittleLong( sides[ sideNum ].planeNum );
+			out->bounds[0][2] = -worldData.planes[ planeNum ].dist;
+
+			sideNum = firstSide + 5;
+			planeNum = LittleLong( sides[ sideNum ].planeNum );
+			out->bounds[1][2] = worldData.planes[ planeNum ].dist;
+		}
+
+		// get information from the shader for fog parameters
+		shader = R_FindShader( fogs->shader, lightmaps, stylesDefault, qtrue );
+
+		assert(shader->fogParms);
+		if (!shader->fogParms)
+		{//bad shader!!
+			out->parms.color[0] = 1.0f;
+			out->parms.color[1] = 0.0f;
+			out->parms.color[2] = 0.0f;
+			out->parms.color[3] = 0.0f;
+			out->parms.depthForOpaque = 250.0f;
+		}
+		else
+		{
+		out->parms = *shader->fogParms;
+		}
+		out->colorInt = ColorBytes4 ( out->parms.color[0], 
+			out->parms.color[1], 
+			out->parms.color[2], 1.0 );
+
+		d = out->parms.depthForOpaque < 1 ? 1 : out->parms.depthForOpaque;
+		out->tcScale = 1.0f / ( d * 8 );
+
+		// set the gradient vector
+		sideNum = LittleLong( fogs->visibleSide );
+
+		if ( sideNum == -1 ) {
+			out->hasSurface = qfalse;
+		} else {
+			out->hasSurface = qtrue;
+			planeNum = LittleLong( sides[ firstSide + sideNum ].planeNum );
+			VectorSubtract( vec3_origin, worldData.planes[ planeNum ].normal, out->surface );
+			out->surface[3] = -worldData.planes[ planeNum ].dist;
+		}
+
+		out++;
+	}
+
+	if (!index)
+	{
+		// Initialise the last fog so we can use it with the LA Goggles
+		// NOTE: We are might appear to be off the end of the array, but we allocated an extra memory slot above but [purposely] didn't 
+		//	increment the total world numFogs to match our array size
+		VectorSet(out->bounds[0], MIN_WORLD_COORD, MIN_WORLD_COORD, MIN_WORLD_COORD);
+		VectorSet(out->bounds[1], MAX_WORLD_COORD, MAX_WORLD_COORD, MAX_WORLD_COORD);
+		out->originalBrushNumber = -1;
+		out->parms.color[0] = 0.0f;
+		out->parms.color[1] = 0.0f;
+		out->parms.color[2] = 0.0f;
+		out->parms.color[3] = 0.0f;
+		out->parms.depthForOpaque = 0.0f;
+		out->colorInt = 0x00000000;
+		out->tcScale = 0.0f;
+		out->hasSurface = false;
+	}
+}
+
+
+/*
+================
+R_LoadLightGrid
+
+================
+*/
+void R_LoadLightGrid( lump_t *l, world_t &worldData ) {
+	int		i, j;
+	vec3_t	maxs;
+	world_t	*w;
+	float	*wMins, *wMaxs;
+
+	w = &worldData;
+
+	w->lightGridInverseSize[0] = 1.0 / w->lightGridSize[0];
+	w->lightGridInverseSize[1] = 1.0 / w->lightGridSize[1];
+	w->lightGridInverseSize[2] = 1.0 / w->lightGridSize[2];
+
+	wMins = w->bmodels[0].bounds[0];
+	wMaxs = w->bmodels[0].bounds[1];
+
+	for ( i = 0 ; i < 3 ; i++ ) {
+		w->lightGridOrigin[i] = w->lightGridSize[i] * ceil( wMins[i] / w->lightGridSize[i] );
+		maxs[i] = w->lightGridSize[i] * floor( wMaxs[i] / w->lightGridSize[i] );
+		w->lightGridBounds[i] = (maxs[i] - w->lightGridOrigin[i])/w->lightGridSize[i] + 1;
+	}
+
+	int numGridDataElements = l->filelen / sizeof(*w->lightGridData);
+	
+	w->lightGridData = (mgrid_t *)Hunk_Alloc( l->filelen, qfalse );
+	memcpy( w->lightGridData, (void *)(fileBase + l->fileofs), l->filelen );
+
+	// deal with overbright bits
+	for ( i = 0 ; i < numGridDataElements ; i++ ) {
+		for(j=0;j<MAXLIGHTMAPS;j++)
+		{
+			R_ColorShiftLightingBytes(w->lightGridData[i].ambientLight[j]);
+			R_ColorShiftLightingBytes(w->lightGridData[i].directLight[j]);
+		}
+	}
+}
+
+/*
+================
+R_LoadLightGridArray
+
+================
+*/
+void R_LoadLightGridArray( lump_t *l, world_t &worldData ) {
+	world_t	*w;
+
+	w = &worldData;
+
+	w->numGridArrayElements = w->lightGridBounds[0] * w->lightGridBounds[1] * w->lightGridBounds[2];
+
+	if ( l->filelen != (int)(w->numGridArrayElements * sizeof(*w->lightGridArray)) ) {
+		if (l->filelen>0)//don't warn if not even lit
+			VID_Printf( PRINT_WARNING, "WARNING: light grid array mismatch\n" );
+		w->lightGridData = NULL;
+		return;
+	}
+
+	w->lightGridArray = (unsigned short *)Hunk_Alloc( l->filelen, qfalse );
+	memcpy( w->lightGridArray, (void *)(fileBase + l->fileofs), l->filelen );
+}
+
+
+/*
+================
+R_LoadEntities
+================
+*/
+void R_LoadEntities( lump_t *l, world_t &worldData ) {
+	const char *p, *token;
+	char keyname[MAX_TOKEN_CHARS];
+	char value[MAX_TOKEN_CHARS];
+	world_t	*w;
+	float ambient = 1;
+
+	w = &worldData;
+	w->lightGridSize[0] = 64;
+	w->lightGridSize[1] = 64;
+	w->lightGridSize[2] = 128;
+
+	VectorSet(tr.sunAmbient, 1, 1, 1);
+	tr.distanceCull = 12000;//DEFAULT_DISTANCE_CULL;
+
+	p = (char *)(fileBase + l->fileofs);
+
+	token = COM_ParseExt( &p, qtrue );
+	if (!*token || *token != '{') {
+		return;
+	}
+
+	// only parse the world spawn
+	while ( 1 ) {	
+		// parse key
+		token = COM_ParseExt( &p, qtrue );
+
+		if ( !*token || *token == '}' ) {
+			break;
+		}
+		Q_strncpyz(keyname, token, sizeof(keyname));
+
+		// parse value
+		token = COM_ParseExt( &p, qtrue );
+
+		if ( !*token || *token == '}' ) {
+			break;
+		}
+		Q_strncpyz(value, token, sizeof(value));
+
+		// check for remapping of shaders for vertex lighting
+/*		s = "vertexremapshader";
+		if (!Q_strncmp(keyname, s, strlen(s)) ) {
+			s = strchr(value, ';');
+			if (!s) {
+				VID_Printf( S_COLOR_YELLOW "WARNING: no semi colon in vertexshaderremap '%s'\n", value );
+				break;
+			}
+			*s++ = 0;
+			if (r_vertexLight->integer) {
+				R_RemapShader(value, s, "0");
+			}
+			continue;
+		}
+		// check for remapping of shaders
+		s = "remapshader";
+		if (!Q_strncmp(keyname, s, strlen(s)) ) {
+			s = strchr(value, ';');
+			if (!s) {
+				VID_Printf( S_COLOR_YELLOW "WARNING: no semi colon in shaderremap '%s'\n", value );
+				break;
+			}
+			*s++ = 0;
+			R_RemapShader(value, s, "0");
+			continue;
+		}
+*/		if (!Q_stricmp(keyname, "distanceCull")) {
+			sscanf(value, "%f", &tr.distanceCull );
+			continue;
+		}
+		//check for linear fog -rww
+		if (!Q_stricmp(keyname, "linFogStart")) {
+			sscanf(value, "%f", &tr.rangedFog );
+			tr.rangedFog = -tr.rangedFog;
+			continue;
+		}
+		// check for a different grid size
+		if (!Q_stricmp(keyname, "gridsize")) {
+			sscanf(value, "%f %f %f", &w->lightGridSize[0], &w->lightGridSize[1], &w->lightGridSize[2] );
+			continue;
+		}
+	// find the optional world ambient for arioche
+		if (!Q_stricmp(keyname, "_color")) {
+			sscanf(value, "%f %f %f", &tr.sunAmbient[0], &tr.sunAmbient[1], &tr.sunAmbient[2] );
+			continue;
+		}
+		if (!Q_stricmp(keyname, "ambient")) {
+			sscanf(value, "%f", &ambient);
+			continue;
+		}
+	}
+	//both default to 1 so no harm if not present.
+	VectorScale( tr.sunAmbient, ambient, tr.sunAmbient);
+}
+
+
+/*
+=================
+RE_LoadWorldMap
+
+Called directly from cgame
+=================
+*/
+void RE_LoadWorldMap_Actual( const char *name, world_t &worldData, int index ) {
+	int			i;
+	dheader_t	*header;
+	byte		*buffer = NULL;
+	qboolean	loadedSubBSP = qfalse;
+
+	if ( tr.worldMapLoaded && !index ) {
+		Com_Error( ERR_DROP, "ERROR: attempted to redundantly load world map\n" );
+	}
+
+	// set default sun direction to be used if it isn't
+	// overridden by a shader
+	if (!index)
+	{
+		skyboxportal = 0;
+
+		tr.sunDirection[0] = 0.45f;
+		tr.sunDirection[1] = 0.3f;
+		tr.sunDirection[2] = 0.9f;
+
+		VectorNormalize( tr.sunDirection );
+
+		tr.worldMapLoaded = qtrue;
+
+		// clear tr.world so if the level fails to load, the next
+		// try will not look at the partially loaded version
+		tr.world = NULL;
+	}
+
+	// check for cached disk file from the server first...
+	//
+	extern void *gpvCachedMapDiskImage;
+	extern char  gsCachedMapDiskImage[];
+	if (gpvCachedMapDiskImage)
+	{
+		if (!strcmp(name, gsCachedMapDiskImage))
+		{
+			// we should always get here, if inside the first IF...
+			//
+			buffer = (byte *)gpvCachedMapDiskImage;
+		}
+		else
+		{
+			// this should never happen (ie renderer loading a different map than the server), but just in case...
+			//
+	//		assert(0);
+	//		Z_Free(gpvCachedMapDiskImage);
+	//			   gpvCachedMapDiskImage = NULL;
+			//rww - this is a valid possibility now because of sub-bsp loading.\
+			//it's alright, just keep the current cache
+			loadedSubBSP = qtrue;
+		}
+	}
+	
+	if (buffer == NULL)
+	{
+		// still needs loading...
+		//
+		FS_ReadFile( name, (void **)&buffer );
+		if ( !buffer ) {
+			Com_Error (ERR_DROP, "RE_LoadWorldMap: %s not found", name);
+		}
+	}
+
+	memset( &worldData, 0, sizeof( worldData ) );
+	
+	Q_strncpyz( tr.worldDir, name, sizeof( tr.worldDir ) );
+	COM_StripExtension( tr.worldDir, tr.worldDir );
+
+	c_gridVerts = 0;
+
+	header = (dheader_t *)buffer;
+	fileBase = (byte *)header;
+
+	header->version = LittleLong (header->version);
+	
+	if ( header->version != BSP_VERSION ) 
+	{
+		Com_Error (ERR_DROP, "RE_LoadWorldMap: %s has wrong version number (%i should be %i)", name, header->version, BSP_VERSION);
+	}
+
+	// swap all the lumps
+	for (i=0 ; i<sizeof(dheader_t)/4 ; i++) {
+		((int *)header)[i] = LittleLong ( ((int *)header)[i]);
+	}
+
+	// load into heap
+	R_LoadShaders( &header->lumps[LUMP_SHADERS], worldData );
+	R_LoadLightmaps( &header->lumps[LUMP_LIGHTMAPS], name, worldData );
+	R_LoadPlanes (&header->lumps[LUMP_PLANES], worldData);
+	R_LoadFogs( &header->lumps[LUMP_FOGS], &header->lumps[LUMP_BRUSHES], &header->lumps[LUMP_BRUSHSIDES], worldData, index );
+	R_LoadSurfaces( &header->lumps[LUMP_SURFACES], &header->lumps[LUMP_DRAWVERTS], &header->lumps[LUMP_DRAWINDEXES], worldData, index );
+	R_LoadMarksurfaces (&header->lumps[LUMP_LEAFSURFACES], worldData);
+	R_LoadNodesAndLeafs (&header->lumps[LUMP_NODES], &header->lumps[LUMP_LEAFS], worldData);
+	R_LoadSubmodels (&header->lumps[LUMP_MODELS], worldData, index);
+	R_LoadVisibility( &header->lumps[LUMP_VISIBILITY], worldData );
+
+	if (!index)
+	{
+		R_LoadEntities( &header->lumps[LUMP_ENTITIES], worldData );
+		R_LoadLightGrid( &header->lumps[LUMP_LIGHTGRID], worldData );
+		R_LoadLightGridArray( &header->lumps[LUMP_LIGHTARRAY], worldData );
+
+		// only set tr.world now that we know the entire level has loaded properly
+		tr.world = &worldData;
+	}
+
+
+	if (gpvCachedMapDiskImage && !loadedSubBSP)
+	{
+		// For the moment, I'm going to keep this disk image around in case we need it to respawn.
+		//  No problem for memory, since it'll only be a NZ ptr if we're not low on physical memory
+		//	( ie we've got > 96MB).
+		//
+		//  So don't do this...
+		//
+		//		Z_Free( gpvCachedMapDiskImage );
+		//				gpvCachedMapDiskImage = NULL;
+	}
+	else
+	{
+		FS_FreeFile( buffer );
+	}
+}
+
+
+// new wrapper used for convenience to tell z_malloc()-fail recovery code whether it's safe to dump the cached-bsp or not.
+//
+extern qboolean gbUsingCachedMapDataRightNow;
+void RE_LoadWorldMap( const char *name )
+{
+	gbUsingCachedMapDataRightNow = qtrue;	// !!!!!!!!!!!!
+
+		RE_LoadWorldMap_Actual( name, s_worldData, 0 );
+
+	gbUsingCachedMapDataRightNow = qfalse;	// !!!!!!!!!!!!
+}
diff --git a/code/renderer/tr_bsp_xbox.cpp b/code/renderer/tr_bsp_xbox.cpp
new file mode 100644
index 0000000..2736b9b
--- /dev/null
+++ b/code/renderer/tr_bsp_xbox.cpp
@@ -0,0 +1,1666 @@
+// tr_map.c
+
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+#include "tr_local.h"
+
+#include "../qcommon/cm_local.h"
+
+/*
+
+Loads and prepares a map file for scene rendering.
+
+A single entry point:
+
+void RE_LoadWorldMap( const char *name );
+
+*/
+
+world_t		s_worldData;
+byte		*fileBase;
+int			c_subdivisions;
+int			c_gridVerts;
+
+void R_RMGInit(void);
+//===============================================================================
+
+// We use a special hack to prevent slight differences in channels
+// from exploding into big differences, as it causes lighting problems
+// later on. This is the maximum channel separation for which we
+// enable the hack.
+#define MAX_GREYSCALE_CHANNEL_DIFF 15
+
+static void R_ColorShiftLightingBytes16( const byte in[4], byte out[2] ) {
+	// What's the largest separation between the red, green, and blue
+	// channels?
+	int chanDiff = max(in[0],max(in[1],in[2])) -
+		min(in[0],min(in[1],in[2]));
+	if (chanDiff <= MAX_GREYSCALE_CHANNEL_DIFF)
+	{
+		// Ensure that all color channels compress to the same value
+		byte channelAvg = (in[0] + in[1] + in[2] + 1) / 3;
+		out[0] = channelAvg & 0xF0;
+		out[0] |= (channelAvg & 0xF0) >> 4;
+		out[1] = channelAvg & 0xF0;
+		out[1] |= (in[3] & 0xF0) >> 4;
+
+		if (channelAvg % 16 >= 8)
+		{
+			out[0] |= 0x10;
+			out[0] |= 0x01;
+			out[1] |= 0x10;
+		}
+		if (in[4] % 16 >= 8)
+		{
+			out[1] |= 0x01;
+		}
+		return;
+	}
+
+	// Normal case for vertex colors that are not "near" greyscale
+	out[0] = in[0] & 0xF0;
+	out[0] |= (in[1] & 0xF0) >> 4;
+	out[1] = in[2] & 0xF0;
+	out[1] |= (in[3] & 0xF0) >> 4;
+	
+	if(in[0] % 16 >= 8) {
+		out[0] |= 0x10;
+	}
+	if(in[1] % 16 >= 8) {
+		out[0] |= 0x1;
+	}
+	if(in[2] % 16 >= 8) {
+		out[1] |= 0x10;
+	}
+	if(in[3] % 16 >= 8) {
+		out[1] |= 0x1;
+	}
+}
+
+
+static void HSVtoRGB( float h, float s, float v, float rgb[3] )
+{
+	int i;
+	float f;
+	float p, q, t;
+
+	h *= 5;
+
+	i = floor( h );
+	f = h - i;
+
+	p = v * ( 1 - s );
+	q = v * ( 1 - s * f );
+	t = v * ( 1 - s * ( 1 - f ) );
+
+	switch ( i )
+	{
+	case 0:
+		rgb[0] = v;
+		rgb[1] = t;
+		rgb[2] = p;
+		break;
+	case 1:
+		rgb[0] = q;
+		rgb[1] = v;
+		rgb[2] = p;
+		break;
+	case 2:
+		rgb[0] = p;
+		rgb[1] = v;
+		rgb[2] = t;
+		break;
+	case 3:
+		rgb[0] = p;
+		rgb[1] = q;
+		rgb[2] = v;
+		break;
+	case 4:
+		rgb[0] = t;
+		rgb[1] = p;
+		rgb[2] = v;
+		break;
+	case 5:
+		rgb[0] = v;
+		rgb[1] = p;
+		rgb[2] = q;
+		break;
+	}
+}
+
+/*
+===============
+R_ColorShiftLightingBytes
+
+===============
+*/
+void R_ColorShiftLightingBytes( byte in[4], byte out[4] ) {
+	int		shift=0, r, g, b;
+
+	// should NOT do it if overbrightBits is 0
+	if (tr.overbrightBits)
+		shift = 1 - tr.overbrightBits;
+
+	if (!shift)
+	{
+		out[0] = in[0];
+		out[1] = in[1];
+		out[2] = in[2];
+		out[3] = in[3];
+		return;
+	}
+
+	// shift the data based on overbright range
+	r = in[0] << shift;
+	g = in[1] << shift;
+	b = in[2] << shift;
+	
+	// normalize by color instead of saturating to white
+	if ( ( r | g | b ) > 255 ) {
+		int		max;
+
+		max = r > g ? r : g;
+		max = max > b ? max : b;
+		r = r * 255 / max;
+		g = g * 255 / max;
+		b = b * 255 / max;
+	}
+
+	out[0] = r;
+	out[1] = g;
+	out[2] = b;
+	out[3] = in[3];
+}
+
+/*
+===============
+R_ColorShiftLightingBytes
+
+===============
+*/
+static	void R_ColorShiftLightingBytes( byte in[3]) 
+{
+	int		shift=0, r, g, b;
+
+	// should NOT do it if overbrightBits is 0
+	if (tr.overbrightBits)
+		shift = 1 - tr.overbrightBits;
+
+	if (!shift) {
+		return;	//no need if not overbright
+	}
+	// shift the data based on overbright range
+	r = in[0] << shift;
+	g = in[1] << shift;
+	b = in[2] << shift;
+	
+	// normalize by color instead of saturating to white
+	if ( ( r | g | b ) > 255 ) {
+		int		max;
+
+		max = r > g ? r : g;
+		max = max > b ? max : b;
+		r = r * 255 / max;
+		g = g * 255 / max;
+		b = b * 255 / max;
+	}
+
+	in[0] = r;
+	in[1] = g;
+	in[2] = b;
+}
+
+
+/*
+===============
+R_LoadLightmaps
+
+===============
+*/
+#define	LIGHTMAP_SIZE	128
+void R_LoadLightmaps( void *data, int len, const char *psMapName ) {
+	byte		*buf, *buf_p;
+	int			i;
+
+	if ( !len ) {
+		return;
+	}
+	buf = (byte *)data + sizeof(int);
+
+	// we are about to upload textures
+	R_SyncRenderThread();
+
+	// create all the lightmaps
+	int size = *(int*)data;
+	tr.numLightmaps = len / size;
+
+	byte* image = (byte*)Z_Malloc(size, TAG_TEMP_WORKSPACE, qfalse, 32);
+
+	char sMapName[MAX_QPATH];
+	COM_StripExtension(psMapName,sMapName);	// will already by MAX_QPATH legal, so no length check
+
+	for ( i = 0 ; i < tr.numLightmaps ; i++ ) {
+		buf_p = buf + i * size;
+		memcpy(image, buf_p, size);
+
+		char lmapName[MAX_QPATH + 32];
+		Com_sprintf(lmapName, MAX_QPATH + 32, "*%s/lightmap%d",sMapName,i);
+		tr.lightmaps[i] = R_CreateImage( lmapName, image, 
+			LIGHTMAP_SIZE, LIGHTMAP_SIZE,
+			GL_DDS_RGB16_EXT,
+			qfalse, 0, GL_CLAMP);
+	}
+
+	Z_Free(image);
+}
+
+
+/*
+=================
+RE_SetWorldVisData
+
+This is called by the clipmodel subsystem so we can share the 1.8 megs of
+space in big maps...
+=================
+*/
+void RE_SetWorldVisData( SPARC<byte> *vis ) {
+	tr.externalVisData = vis;
+}
+
+
+/*
+=================
+R_LoadVisibility
+=================
+*/
+static	void R_LoadVisibility( void ) {
+	int		len;
+
+	len = ( s_worldData.numClusters + 63 ) & ~63;
+	s_worldData.novis = ( unsigned char *) Hunk_Alloc( len, qfalse );
+	memset( s_worldData.novis, 0xff, len );
+
+	s_worldData.numClusters = cmg.numClusters;
+	s_worldData.clusterBytes = cmg.clusterBytes;
+
+	// CM_Load should have given us the vis data to share, so
+	// we don't need to allocate another copy
+	//if ( tr.externalVisData ) {
+		s_worldData.vis = tr.externalVisData;
+	/*} else {
+		assert(0);
+	}*/
+}
+
+//===============================================================================
+
+qhandle_t R_GetShaderByNum(int shaderNum, world_t &worldData)
+{
+	qhandle_t	shader;
+
+	if ( (shaderNum < 0) || (shaderNum >= worldData.numShaders) ) 
+	{
+		Com_Printf( "Warning: Bad index for R_GetShaderByNum - %i", shaderNum );
+		return(0);
+	}
+	shader = RE_RegisterShader(worldData.shaders[ shaderNum ].shader);
+	return(shader);
+}
+
+/*
+===============
+ShaderForShaderNum
+===============
+*/
+static shader_t *ShaderForShaderNum( int shaderNum, const int *lightmapNum, const byte *lightmapStyles ) {
+	shader_t	*shader;
+	dshader_t	*dsh;
+
+	shaderNum = shaderNum;
+	if ( shaderNum < 0 || shaderNum >= s_worldData.numShaders ) {
+		Com_Error( ERR_DROP, "ShaderForShaderNum: bad num %i", shaderNum );
+	}
+	dsh = &s_worldData.shaders[ shaderNum ];
+
+	shader = R_FindShader( dsh->shader, lightmapNum, lightmapStyles, qtrue );
+
+	// if the shader had errors, just use default shader
+	if ( shader->defaultShader ) {
+		return tr.defaultShader;
+	}
+
+	return shader;
+}
+
+bool NeedVertexColors(shader_t *shader)
+{
+	int i;
+	shaderStage_t *stage;
+
+	for(i=0; i<shader->numUnfoggedPasses; i++) {
+		stage = &shader->stages[i];
+		switch(stage->rgbGen) {
+		case CGEN_EXACT_VERTEX:
+		case CGEN_VERTEX:
+		case CGEN_ONE_MINUS_VERTEX:
+			return true;
+		}
+		switch(stage->alphaGen) {
+		case AGEN_VERTEX:
+		case AGEN_ONE_MINUS_VERTEX:
+			return true;
+		}
+	}
+
+	return false;
+}
+
+int NumLightMaps(shader_t *shader)
+{
+	int count = 0;
+	int i;
+
+	for(i=0; i<MAXLIGHTMAPS; i++) {
+		if(shader->lightmapIndex[i] >= 0) {
+			count++;
+		} else {
+			return count;
+		}
+	}
+
+	return count;
+}
+
+int SurfaceFaceSize(int numVerts, int numLightMaps, bool needVertexColors,
+		int numIndexes)
+{
+	int sfaceSize = ( int ) &((srfSurfaceFace_t *)0)->srfPoints + 
+		4 /*sizeof srfPoints*/ + 
+		(numVerts * sizeof(unsigned short) *
+			(VERTEX_LM + numLightMaps * 2 + 
+#ifdef COMPRESS_VERTEX_COLORS
+			(int)needVertexColors * 4));	
+#else
+			(int)needVertexColors * 8));	
+#endif
+
+	// Add in tangent size
+	sfaceSize += sizeof(vec3_t) * numVerts;
+
+	//Indices stored in 8 bits now.
+	sfaceSize += numIndexes;
+
+	return sfaceSize;
+}
+
+
+void BuildDrawVertTangents( drawVert_t *verts, int *indexes, int numIndexes, int numVertexes ) 
+{
+	int i = 0;
+
+	for(i = 0; i < numVertexes; i++)
+	{
+		verts[i].tangent[0] = 0.0f;
+		verts[i].tangent[1] = 0.0f;
+		verts[i].tangent[2] = 0.0f;
+	}
+
+	for(i = 0; i < numIndexes; i += 3)
+	{
+		vec3_t vec1, vec2, du, dv, cp;
+		float st0[2], st1[2], st2[2];
+
+		Q_CastShort2FloatScale(&st0[0], &verts[indexes[i]].dvst[0], 1.f / DRAWVERT_ST_SCALE);
+		Q_CastShort2FloatScale(&st0[1], &verts[indexes[i]].dvst[1], 1.f / DRAWVERT_ST_SCALE);
+
+		Q_CastShort2FloatScale(&st1[0], &verts[indexes[i+1]].dvst[0], 1.f / DRAWVERT_ST_SCALE);
+		Q_CastShort2FloatScale(&st1[1], &verts[indexes[i+1]].dvst[1], 1.f / DRAWVERT_ST_SCALE);
+
+		Q_CastShort2FloatScale(&st2[0], &verts[indexes[i+2]].dvst[0], 1.f / DRAWVERT_ST_SCALE);
+		Q_CastShort2FloatScale(&st2[1], &verts[indexes[i+2]].dvst[1], 1.f / DRAWVERT_ST_SCALE);
+
+		vec1[0] = verts[indexes[i+1]].xyz[0] - verts[indexes[i]].xyz[0];
+		vec1[1] = st1[0] - st0[0];
+		vec1[2] = st1[1] - st0[1];
+
+		vec2[0] = verts[indexes[i+2]].xyz[0] - verts[indexes[i]].xyz[0];
+		vec2[1] = st2[0] - st0[0];
+		vec2[2] = st2[1] - st0[1];
+
+		CrossProduct(vec1, vec2, cp);
+
+		if(cp[0] == 0.0f)
+			cp[0] = 0.001f;
+
+		du[0] = -cp[1] / cp[0];
+		dv[0] = -cp[2] / cp[0];
+
+		vec1[0] = verts[indexes[i+1]].xyz[1] - verts[indexes[i]].xyz[1];
+
+		vec2[0] = verts[indexes[i+2]].xyz[1] - verts[indexes[i]].xyz[1];
+	
+		CrossProduct(vec1, vec2, cp);
+
+		if(cp[0] == 0.0f)
+			cp[0] = 0.001f;
+
+		du[1] = -cp[1] / cp[0];
+		dv[1] = -cp[2] / cp[0];
+
+		vec1[0] = verts[indexes[i+1]].xyz[2] - verts[indexes[i]].xyz[2];
+
+		vec2[0] = verts[indexes[i+2]].xyz[2] - verts[indexes[i]].xyz[2];
+
+		CrossProduct(vec1, vec2, cp);
+
+		if(cp[0] == 0.0f)
+			cp[0] = 0.001f;
+
+		du[2] = -cp[1] / cp[0];
+		dv[2] = -cp[2] / cp[0];
+
+		verts[indexes[i]].tangent[0] += du[0];
+		verts[indexes[i]].tangent[1] += du[1];
+		verts[indexes[i]].tangent[2] += du[2];
+
+		verts[indexes[i+1]].tangent[0] += du[0];
+		verts[indexes[i+1]].tangent[1] += du[1];
+		verts[indexes[i+1]].tangent[2] += du[2];
+
+		verts[indexes[i+2]].tangent[0] += du[0];
+		verts[indexes[i+2]].tangent[1] += du[1];
+		verts[indexes[i+2]].tangent[2] += du[2];
+	}
+
+	for(i = 0; i < numVertexes; i++)
+	{
+		VectorNormalizeFast(verts[i].tangent);
+	}
+}
+
+
+void BuildMapVertTangents( mapVert_t *verts, vec3_t *tangents, short *indexes, int numIndexes, int numVertexes ) 
+{
+	int i = 0;
+
+	for(i = 0; i < numVertexes; i++)
+	{
+		tangents[i][0] = 0.0f;
+		tangents[i][1] = 0.0f;
+		tangents[i][2] = 0.0f;
+	}
+
+	for(i = 0; i < numIndexes; i += 3)
+	{
+		vec3_t vec1, vec2, du, dv, cp;
+		
+		vec1[0] = verts[indexes[i+1]].xyz[0] - verts[indexes[i]].xyz[0];
+		vec1[1] = (verts[indexes[i+1]].st[0] * POINTS_ST_SCALE) - 
+				   (verts[indexes[i]].st[0] * POINTS_ST_SCALE);
+		vec1[2] = (verts[indexes[i+1]].st[1] * POINTS_ST_SCALE) - 
+				   (verts[indexes[i]].st[1] * POINTS_ST_SCALE);
+
+		vec2[0] = verts[indexes[i+2]].xyz[0] - verts[indexes[i]].xyz[0];
+		vec2[1] = (verts[indexes[i+2]].st[0] * POINTS_ST_SCALE) - 
+				   (verts[indexes[i]].st[0] * POINTS_ST_SCALE);
+		vec2[2] = (verts[indexes[i+2]].st[1]* POINTS_ST_SCALE) - 
+				   (verts[indexes[i]].st[1] * POINTS_ST_SCALE);
+
+		CrossProduct(vec1, vec2, cp);
+
+		if(cp[0] == 0.0f)
+			cp[0] = 0.001f;
+
+		du[0] = -cp[1] / cp[0];
+		dv[0] = -cp[2] / cp[0];
+
+		vec1[0] = verts[indexes[i+1]].xyz[1] - verts[indexes[i]].xyz[1];
+
+		vec2[0] = verts[indexes[i+2]].xyz[1] - verts[indexes[i]].xyz[1];
+
+		CrossProduct(vec1, vec2, cp);
+
+		if(cp[0] == 0.0f)
+			cp[0] = 0.001f;
+
+		du[1] = -cp[1] / cp[0];
+		dv[1] = -cp[2] / cp[0];
+
+		vec1[0] = verts[indexes[i+1]].xyz[2] - verts[indexes[i]].xyz[2];
+
+		vec2[0] = verts[indexes[i+2]].xyz[2] - verts[indexes[i]].xyz[2];
+
+		CrossProduct(vec1, vec2, cp);
+
+		if(cp[0] == 0.0f)
+			cp[0] = 0.001f;
+
+		du[2] = -cp[1] / cp[0];
+		dv[2] = -cp[2] / cp[0];
+
+		tangents[indexes[i]][0] += du[0];
+		tangents[indexes[i]][1] += du[1];
+		tangents[indexes[i]][2] += du[2];
+
+		tangents[indexes[i+1]][0] += du[0];
+		tangents[indexes[i+1]][1] += du[1];
+		tangents[indexes[i+1]][2] += du[2];
+
+		tangents[indexes[i+2]][0] += du[0];
+		tangents[indexes[i+2]][1] += du[1];
+		tangents[indexes[i+2]][2] += du[2];
+	}
+
+	for(i = 0; i < numVertexes; i++)
+	{
+		VectorNormalizeFast(tangents[i]);
+	}
+}
+
+/*
+===============
+ParseFace
+===============
+*/
+static void ParseFace( dface_t *ds, mapVert_t *verts, msurface_t *surf, short *indexes, byte *&pFaceDataBuffer) 
+{
+	int			i, j, k;
+	srfSurfaceFace_t	*cv;
+	int			numPoints, numIndexes;
+	int			lightmapNum[MAXLIGHTMAPS];
+	int			sfaceSize, ofsIndexes;
+	vec3_t		tangents[1000];
+
+	for(i=0;i<MAXLIGHTMAPS;i++)
+	{
+		lightmapNum[i] = (int)ds->lightmapNum[i] - 4;
+	}
+
+	// get fog volume
+	surf->fogIndex = ds->fogNum + 1;
+
+	// get shader value
+	surf->shader = ShaderForShaderNum( ds->shaderNum, lightmapNum, ds->lightmapStyles );
+	if ( r_singleShader->integer && !surf->shader->sky ) {
+		surf->shader = tr.defaultShader;
+	}
+
+	bool needVertexColors = NeedVertexColors(surf->shader); 
+	int numLightMaps = NumLightMaps(surf->shader);
+	assert(numLightMaps <= 0x7F);
+
+	numPoints = ds->verts & 0xFFF;
+	if (numPoints > MAX_FACE_POINTS) {
+		VID_Printf( PRINT_DEVELOPER, "MAX_FACE_POINTS exceeded: %i\n", numPoints);
+	}
+
+	numIndexes = ds->indexes & 0xFFF;
+
+	// create the srfSurfaceFace_t
+	sfaceSize = SurfaceFaceSize(numPoints,
+			numLightMaps, needVertexColors, numIndexes);
+	ofsIndexes = sfaceSize - numIndexes;
+
+	cv = (srfSurfaceFace_t *) pFaceDataBuffer;//Hunk_Alloc( sfaceSize );
+	pFaceDataBuffer += sfaceSize;	// :-)
+
+	cv->surfaceType = SF_FACE;
+	cv->numPoints = numPoints;
+	cv->numIndices = numIndexes;
+	cv->ofsIndices = ofsIndexes;
+	cv->srfPoints = (unsigned short *)(((byte*)cv) + ( int ) &((srfSurfaceFace_t *)0)->srfPoints + 4);
+	if(needVertexColors) {
+		cv->flags = 1 << 7;
+	} else {
+		cv->flags = 0;
+	}
+	cv->flags |= (numLightMaps & 0x7F);
+
+	//Make sure we don't overflow storage.
+	assert(numPoints < 256);
+	assert(numIndexes < 65536);
+	assert(ofsIndexes < 65536);
+
+	int nextSurfPoint = NEXT_SURFPOINT(cv->flags);
+	verts += ds->verts >> 12;
+
+	indexes += ds->indexes >> 12;
+
+	BuildMapVertTangents(verts, tangents, indexes, numIndexes, numPoints);
+
+	for ( i = 0 ; i < numPoints ; i++ ) {
+		for ( j = 0 ; j < 3 ; j++ ) {
+			*(cv->srfPoints + i * nextSurfPoint + j) = verts[i].xyz[j];
+		}
+		
+		for ( j = 0; j < 3 ; j++ ) {
+			assert(tangents[i][j] >= -1 && tangents[i][j] <= 1);
+			*(cv->srfPoints + i * nextSurfPoint + 3 + j) = (short)(tangents[i][j] * 32767.0f);
+		}
+		for ( j = 0 ; j < 2 ; j++ ) {
+			*(cv->srfPoints + i * nextSurfPoint + 6 + j) = 
+				(short)(verts[i].st[j] * POINTS_ST_SCALE);
+
+			for(k=0;k<numLightMaps;k++)
+			{
+				*(cv->srfPoints + i * nextSurfPoint + VERTEX_LM+j+(k*2)) = 
+					verts[i].lightmap[k][j];
+			}
+		}
+		if(needVertexColors) {
+			for(k=0;k<MAXLIGHTMAPS;k++)
+			{
+#ifdef COMPRESS_VERTEX_COLORS
+				R_ColorShiftLightingBytes16(
+					verts[i].color[k],
+					(byte*)(cv->srfPoints + i * nextSurfPoint + 
+					VERTEX_COLOR(cv->flags) + k));
+#else
+				R_ColorShiftLightingBytes(
+					verts[i].color[k],
+					(byte*)(cv->srfPoints + i * nextSurfPoint + 
+					VERTEX_COLOR(cv->flags) + 2*k));
+#endif
+			}
+		}
+	}
+
+//	indexes += ds->indexes >> 12;
+	unsigned char *indexStorage = ((unsigned char*)cv) + cv->ofsIndices;
+	for ( i = 0 ; i < numIndexes ; i++ ) {
+		indexStorage[i] = indexes[ i ];
+	}
+
+	// take the plane information from the lightmap vector
+	for ( i = 0 ; i < 3 ; i++ ) {
+		cv->plane.normal[i] = (float)ds->lightmapVecs[i] / 32767.f;
+	}
+	vec3_t fVec;
+	fVec[0] = (float)((short)cv->srfPoints[0]);
+	fVec[1] = (float)((short)cv->srfPoints[1]);
+	fVec[2] = (float)((short)cv->srfPoints[2]);
+	cv->plane.dist = DotProduct( fVec, cv->plane.normal );
+	SetPlaneSignbits( &cv->plane );
+	cv->plane.type = PlaneTypeForNormal( cv->plane.normal );
+
+	surf->data = (surfaceType_t *)cv;
+}
+
+
+/*
+===============
+ParseMesh
+===============
+*/
+static void ParseMesh ( dpatch_t *ds, mapVert_t *verts, msurface_t *surf,
+					   drawVert_t* points, drawVert_t* ctrl, float* errorTable ) {
+	srfGridMesh_t	*grid;
+	int				i, j, k;
+	int				width, height, numPoints;
+	int				lightmapNum[MAXLIGHTMAPS];
+	vec3_t			bounds[2];
+	vec3_t			tmpVec;
+	static surfaceType_t	skipData = SF_SKIP;
+
+	for(i=0;i<MAXLIGHTMAPS;i++)
+	{
+		lightmapNum[i] = (int)ds->lightmapNum[i] - 4;
+	}
+
+	// get fog volume
+	surf->fogIndex = ds->fogNum + 1;
+
+	// get shader value
+	surf->shader = ShaderForShaderNum( ds->shaderNum, lightmapNum, ds->lightmapStyles );
+	if ( r_singleShader->integer && !surf->shader->sky ) {
+		surf->shader = tr.defaultShader;
+	}
+
+	// we may have a nodraw surface, because they might still need to
+	// be around for movement clipping
+	if ( s_worldData.shaders[ ds->shaderNum ].surfaceFlags & SURF_NODRAW ) {
+		surf->data = &skipData;
+		return;
+	}
+
+	width = ds->patchWidth;
+	height = ds->patchHeight;
+
+	verts += ds->verts >> 12;
+	numPoints = width * height;
+	for ( i = 0 ; i < numPoints ; i++ ) {
+		for ( j = 0 ; j < 3 ; j++ ) {
+			points[i].xyz[j] = (float)verts[i].xyz[j];
+			points[i].normal[j] = (float)verts[i].normal[j] / 32767.f;
+		}
+		for ( j = 0 ; j < 2 ; j++ ) {
+			// Sanity check that alternate fixed point representation
+			// is good enough
+			assert( verts[i].st[j] * GRID_DRAWVERT_ST_SCALE < 32767 &&
+					verts[i].st[j] * GRID_DRAWVERT_ST_SCALE >= -32768 );
+			points[i].dvst[j] = verts[i].st[j] * GRID_DRAWVERT_ST_SCALE;
+			for(k=0;k<MAXLIGHTMAPS;k++)
+			{
+				points[i].dvlightmap[k][j] = 
+					((float)verts[i].lightmap[k][j] / POINTS_LIGHT_SCALE) *
+					DRAWVERT_LIGHTMAP_SCALE;
+			}
+		}
+		for(k=0;k<MAXLIGHTMAPS;k++)
+		{
+#ifdef COMPRESS_VERTEX_COLORS
+			R_ColorShiftLightingBytes16(verts[i].color[k], 
+				points[i].dvcolor[k]);
+#else
+			R_ColorShiftLightingBytes(verts[i].color[k],
+				points[i].dvcolor[k]);
+#endif
+		}
+	}
+
+	// pre-tesseleate
+	grid = R_SubdividePatchToGrid( width, height, points, ctrl, errorTable );
+	surf->data = (surfaceType_t *)grid;
+
+	// copy the level of detail origin, which is the center
+	// of the group of all curves that must subdivide the same
+	// to avoid cracking
+	for ( i = 0 ; i < 3 ; i++ ) {
+		bounds[0][i] = ds->lightmapVecs[0][i];
+		bounds[1][i] = ds->lightmapVecs[1][i];
+	}
+	VectorAdd( bounds[0], bounds[1], bounds[1] );
+	VectorScale( bounds[1], 0.5f, grid->lodOrigin );
+	VectorSubtract( bounds[0], grid->lodOrigin, tmpVec );
+	grid->lodRadius = VectorLength( tmpVec );
+}
+
+/*
+===============
+ParseTriSurf
+===============
+*/
+static void ParseTriSurf( dtrisurf_t *ds, mapVert_t *verts, msurface_t *surf, short *indexes ) {
+	srfTriangles_t	*tri;
+	int				i, j, k;
+	int				numVerts, numIndexes;
+
+	// get fog volume
+	surf->fogIndex = ds->fogNum + 1;
+
+	// get shader
+	surf->shader = ShaderForShaderNum( ds->shaderNum, lightmapsVertex, ds->lightmapStyles );
+	if ( r_singleShader->integer && !surf->shader->sky ) {
+		surf->shader = tr.defaultShader;
+	}
+
+	numVerts = ds->verts & 0xFFF;
+	numIndexes = ds->indexes & 0xFFF;
+
+	tri = (srfTriangles_t *) Hunk_Alloc( sizeof( *tri ) + numVerts * sizeof( tri->verts[0] ) 
+		+ numIndexes * sizeof( tri->indexes[0] ), qtrue );
+	tri->surfaceType = SF_TRIANGLES;
+	tri->numVerts = numVerts;
+	tri->numIndexes = numIndexes;
+	tri->verts = (drawVert_t *)(tri + 1);
+	tri->indexes = (int *)(tri->verts + tri->numVerts );
+
+	surf->data = (surfaceType_t *)tri;
+
+	// copy vertexes
+	verts += ds->verts >> 12;
+	ClearBounds( tri->bounds[0], tri->bounds[1] );
+	for ( i = 0 ; i < numVerts ; i++ ) {
+		for ( j = 0 ; j < 3 ; j++ ) {
+			tri->verts[i].xyz[j] = verts[i].xyz[j];
+			tri->verts[i].normal[j] = verts[i].normal[j];
+		}
+		AddPointToBounds( tri->verts[i].xyz, tri->bounds[0], tri->bounds[1] );
+		for ( j = 0 ; j < 2 ; j++ ) {
+			// Sanity check that alternate fixed point representation
+			// is good enough
+			// MATT! - double check this!
+//			assert( verts[i].st[j] * DRAWVERT_ST_SCALE <= 32767 &&
+//					verts[i].st[j] * DRAWVERT_ST_SCALE >= -32768 );
+			tri->verts[i].dvst[j] = verts[i].st[j] * DRAWVERT_ST_SCALE;
+			for(k=0;k<MAXLIGHTMAPS;k++)
+			{
+				tri->verts[i].dvlightmap[k][j] = 
+					((float)verts[i].lightmap[k][j] / POINTS_LIGHT_SCALE) *
+					DRAWVERT_LIGHTMAP_SCALE;
+			}
+		}
+		for(k=0;k<MAXLIGHTMAPS;k++)
+		{
+#ifdef COMPRESS_VERTEX_COLORS
+			R_ColorShiftLightingBytes16(verts[i].color[k], 
+				tri->verts[i].dvcolor[k]);
+#else
+			R_ColorShiftLightingBytes(verts[i].color[k],
+				tri->verts[i].dvcolor[k]);
+#endif
+		}
+	}
+
+	// copy indexes
+	indexes += ds->indexes >> 12;
+	for ( i = 0 ; i < numIndexes ; i++ ) {
+		tri->indexes[i] = indexes[i];
+		if ( tri->indexes[i] < 0 || tri->indexes[i] >= numVerts ) {
+			Com_Error( ERR_DROP, "Bad index in triangle surface" );
+		}
+	}
+
+	// Build the tangent vectors
+	BuildDrawVertTangents(tri->verts, tri->indexes, numIndexes, numVerts);
+}
+
+
+/*
+===============
+ParseFlare
+===============
+*/
+static void ParseFlare( dflare_t *df, msurface_t *surf )
+{
+	srfFlare_t		*flare;
+	int i;
+
+	surf->fogIndex = df->fogNum + 1;
+
+	// get shader
+	surf->shader = ShaderForShaderNum( df->shaderNum, lightmapsVertex, stylesDefault );
+
+	flare = (srfFlare_t *) Hunk_Alloc( sizeof( *flare ), qtrue );
+	flare->surfaceType = SF_FLARE;
+
+	for ( i = 0 ; i < 3 ; i++ ) {
+		flare->origin[i] = df->origin[i];
+		flare->color[i] = df->color[i];
+		flare->normal[i] = df->normal[i];
+	}
+
+	surf->data = (surfaceType_t *)flare;
+}
+
+
+void R_LoadFlares( void *surfaces, int surfacelen ) {
+	int count, i;
+	dflare_t	*in = NULL;
+	msurface_t  *out;
+
+	count = surfacelen / sizeof(*in);
+
+	for ( i = 0 ; i < count ; i++ ) {
+		in = (dflare_t *)surfaces + i;
+		out = s_worldData.surfaces + in->code;
+		ParseFlare( in, out );
+	}
+}
+
+
+/*
+===============
+R_LoadSurfaces
+===============
+*/
+void R_LoadSurfaces( int count ) {
+	s_worldData.surfaces = (struct msurface_s *) 
+		Hunk_Alloc ( count * sizeof(msurface_s), qtrue );
+	s_worldData.numsurfaces = count;
+}
+
+
+/*
+===============
+R_LoadPatches
+===============
+*/
+void R_LoadPatches( void *verts, int vertlen, 
+					void *surfaces, int surfacelen ) {
+	dpatch_t	*in = NULL;
+	msurface_t	*out;
+	mapVert_t	*dv;
+	int			count;
+	int			i;
+
+	if (surfacelen == 0) {
+		return;
+	}
+
+	count = surfacelen / sizeof(*in);
+
+	dv = (mapVert_t *)(verts);
+	if (vertlen % sizeof(*dv))
+		Com_Error (ERR_DROP, "LoadMap: funny lump size in %s",s_worldData.name);
+
+	drawVert_t* points = (drawVert_t*)Z_Malloc(
+		MAX_PATCH_SIZE*MAX_PATCH_SIZE*sizeof(drawVert_t), 
+		TAG_TEMP_WORKSPACE, qfalse);
+	
+	drawVert_t*	ctrl = (drawVert_t*)Z_Malloc(
+		MAX_GRID_SIZE*MAX_GRID_SIZE*sizeof(drawVert_t), 
+		TAG_TEMP_WORKSPACE, qfalse);
+	
+	float* errorTable = (float*)Z_Malloc(
+		2*MAX_GRID_SIZE*sizeof(float), 
+		TAG_TEMP_WORKSPACE, qfalse);
+
+	for ( i = 0 ; i < count ; i++ ) {
+		in = (dpatch_t *)surfaces + i;
+		out = s_worldData.surfaces + in->code;
+		ParseMesh ( in, dv, out, points, ctrl, errorTable );
+	}
+
+	Z_Free(errorTable);
+	Z_Free(ctrl);
+	Z_Free(points);
+
+	VID_Printf( PRINT_ALL, "...loaded %i meshes\n", count );
+}
+
+
+					/*
+===============
+R_LoadTriSurfs
+===============
+*/
+void R_LoadTriSurfs( void *indexdata, int indexlen, 
+					void *verts, int vertlen, 
+					void *surfaces, int surfacelen ) {
+	dtrisurf_t	*in = NULL;
+	msurface_t	*out;
+	mapVert_t	*dv;
+	short		*indexes;
+	int			count;
+	int			i;
+
+	if (surfacelen == 0) {
+		return;
+	}
+	
+	count = surfacelen / sizeof(*in);
+
+	dv = (mapVert_t *)(verts);
+	if (vertlen % sizeof(*dv))
+		Com_Error (ERR_DROP, "LoadMap: funny lump size in %s",s_worldData.name);
+
+	indexes = (short *)(indexdata);
+	if ( indexlen % sizeof(*indexes))
+		Com_Error (ERR_DROP, "LoadMap: funny lump size in %s",s_worldData.name);
+
+	for ( i = 0 ; i < count ; i++ ) {
+		in = (dtrisurf_t *)surfaces + i;
+		out = s_worldData.surfaces + in->code;
+		ParseTriSurf( in, dv, out, indexes );
+	}
+
+	VID_Printf( PRINT_ALL, "...loaded %i trisurfs\n", count );
+}
+
+
+/*
+===============
+R_LoadFaces
+===============
+*/
+void R_LoadFaces( void *indexdata, int indexlen, 
+					void *verts, int vertlen, 
+					void *surfaces, int surfacelen ) {
+	dface_t		*in = NULL;
+	msurface_t	*out;
+	mapVert_t	*dv;
+	short		*indexes;
+	int			count;
+	int			i;
+
+	if (surfacelen == 0) {
+		return;
+	}
+	
+	count = surfacelen / sizeof(*in);
+
+	dv = (mapVert_t *)(verts);
+	if (vertlen % sizeof(*dv))
+		Com_Error (ERR_DROP, "LoadMap: funny lump size in %s",s_worldData.name);
+
+	indexes = (short *)(indexdata);
+	if ( indexlen % sizeof(*indexes))
+		Com_Error (ERR_DROP, "LoadMap: funny lump size in %s",s_worldData.name);
+
+	// new bit, the face code on our biggest map requires over 15,000 mallocs, which was no problem on the hunk,
+	//	bit hits the zone pretty bad (even the tagFree takes about 9 seconds for that many memblocks), 
+	//	so special-case pre-alloc enough space for this data (the patches etc can stay as they are)...
+	//
+	int nTimes = count / 100;
+	int nToGo = nTimes;
+	int iFaceDataSizeRequired = 0;
+	for ( i = 0 ; i < count ; i++) 
+	{ 
+		in = (dface_t *)surfaces + i;
+
+		int lightmapNum[MAXLIGHTMAPS];
+		for(int j=0; j<4; j++) {
+			lightmapNum[j] = (int)in->lightmapNum[j] - 4;
+		}
+		shader_t *shader = ShaderForShaderNum( in->shaderNum, lightmapNum, in->lightmapStyles );
+		bool needVertexColors = NeedVertexColors(shader); 
+		int numLightMaps = NumLightMaps(shader);
+		
+		int sfaceSize = SurfaceFaceSize(in->verts & 0xFFF,
+			numLightMaps, needVertexColors,
+			in->indexes & 0xFFF);
+		
+		iFaceDataSizeRequired += sfaceSize;
+		assert(sfaceSize < 100 * 1024);
+		if (--nToGo <= 0)
+		{
+			nToGo = nTimes;
+		}
+	}
+	in -= count;	// back it up, ready for loop-proper
+
+	// since this ptr is to hunk data, I can pass it in and have it advanced without worrying about losing
+	//	the original alloc ptr...
+	//
+	byte *orgFaceData;
+	byte *pFaceDataBuffer	= (byte *)Hunk_Alloc( iFaceDataSizeRequired, qtrue );
+	orgFaceData = pFaceDataBuffer;
+
+	// now do regular loop...
+	//
+	for ( i = 0 ; i < count ; i++ ) {
+		in = (dface_t *)surfaces + i;
+		out = s_worldData.surfaces + in->code;
+		ParseFace( in, dv, out, indexes, pFaceDataBuffer );
+		if (--nToGo <= 0)
+		{
+			nToGo = nTimes;
+		}
+	}
+
+	VID_Printf( PRINT_ALL, "...loaded %d faces\n", count );
+}
+
+
+/*
+=================
+R_LoadSubmodels
+=================
+*/
+static	void R_LoadSubmodels( void *data, int len ) {
+	dmodel_t	*in;
+	bmodel_t	*out;
+	int			i, j, count;
+
+	in = (dmodel_t *)(data);
+	if (len % sizeof(*in))
+		Com_Error (ERR_DROP, "LoadMap: funny lump size in %s",s_worldData.name);
+	count = len / sizeof(*in);
+
+	s_worldData.bmodels = out = (bmodel_t *) Hunk_Alloc( count * sizeof(*out), qtrue );
+
+	for ( i=0 ; i<count ; i++, in++, out++ ) {
+		model_t *model;
+
+		model = R_AllocModel();
+
+		assert( model != NULL );			// this should never happen
+
+		model->type = MOD_BRUSH;
+		model->bmodel = out;
+		Com_sprintf( model->name, sizeof( model->name ), "*%d", i );
+
+		for (j=0 ; j<3 ; j++) {
+			out->bounds[0][j] = in->mins[j];
+			out->bounds[1][j] = in->maxs[j];
+		}
+
+		RE_InsertModelIntoHash(model->name, model);
+
+		out->firstSurface = s_worldData.surfaces + in->firstSurface;
+		out->numSurfaces = in->numSurfaces;
+	}
+}
+
+//==================================================================
+
+/*
+=================
+R_SetParent
+=================
+*/
+static	void R_SetParent (mnode_t *node, mnode_t *parent)
+{
+	node->parent = parent;
+	if (node->contents != -1)
+		return;
+	R_SetParent (node->children[0], node);
+	R_SetParent (node->children[1], node);
+}
+
+/*
+=================
+R_LoadNodesAndLeafs
+=================
+*/
+static void R_LoadNodesAndLeafs (void *nodes, int nodelen, void *leafs, int leaflen) {
+	int			i, j, p;
+	dnode_t		*in;
+	dleaf_t		*inLeaf;
+	mnode_t 	*outNode;
+	mleaf_s 	*outLeaf;
+	int			numNodes, numLeafs;
+
+	in = (dnode_t *)(nodes);
+	if (nodelen % sizeof(dnode_t) ||
+		leaflen % sizeof(dleaf_t) ) {
+		Com_Error (ERR_DROP, "LoadMap: funny lump size in %s",s_worldData.name);
+	}
+	numNodes = nodelen / sizeof(dnode_t);
+	numLeafs = leaflen / sizeof(dleaf_t);
+
+	outNode = (struct mnode_s *) Hunk_Alloc ( (numNodes) * sizeof(*outNode), qtrue );	
+	outLeaf = (struct mleaf_s *) Hunk_Alloc ( (numLeafs) * sizeof(*outLeaf), qtrue );	
+
+	s_worldData.nodes = outNode;
+	s_worldData.leafs = outLeaf;
+	s_worldData.numnodes = numNodes;
+	s_worldData.numleafs = numLeafs;
+
+	// load nodes
+	for ( i=0 ; i<numNodes; i++, in++, outNode++)
+	{
+		for (j=0 ; j<3 ; j++)
+		{
+			outNode->mins[j] = in->mins[j];
+			outNode->maxs[j] = in->maxs[j];
+		}
+	
+		outNode->planeNum = in->planeNum;
+		outNode->contents = CONTENTS_NODE;	// differentiate from leafs
+
+		for (j=0 ; j<2 ; j++)
+		{
+			p = in->children[j];
+			if (p >= 0) {
+				if(p < numNodes) {
+					outNode->children[j] = s_worldData.nodes + p;
+				} else {
+					outNode->children[j] = (mnode_s*)
+						(s_worldData.leafs + (p - numNodes));
+				}
+			} else {
+				if(numNodes + (-1 - p) < numNodes) {
+					outNode->children[j] = s_worldData.nodes + numNodes + (-1 - p);
+				} else {
+					outNode->children[j] = (mnode_s*)
+						(s_worldData.leafs + (-1 - p));
+				}
+			}
+		}
+	}
+	
+	// load leafs
+	inLeaf = (dleaf_t *)(leafs);
+	for ( i=0 ; i<numLeafs ; i++, inLeaf++, outLeaf++)
+	{
+		for (j=0 ; j<3 ; j++)
+		{
+			outLeaf->mins[j] = inLeaf->mins[j];
+			outLeaf->maxs[j] = inLeaf->maxs[j];
+		}
+
+		outLeaf->cluster = inLeaf->cluster;
+		outLeaf->area = inLeaf->area;
+
+		if ( outLeaf->cluster >= s_worldData.numClusters ) {
+			s_worldData.numClusters = outLeaf->cluster + 1;
+		}
+
+		outLeaf->firstMarkSurfNum = inLeaf->firstLeafSurface;
+		outLeaf->nummarksurfaces = inLeaf->numLeafSurfaces;
+	}	
+
+	// chain decendants
+	R_SetParent (s_worldData.nodes, NULL);
+}
+
+//=============================================================================
+
+/*
+=================
+R_LoadShaders
+=================
+*/
+void R_LoadShaders( void ) {	
+	/*s_worldData.shaders = cm.shaders;
+	s_worldData.numShaders = cm.numShaders;*/
+}
+
+/*
+=================
+R_LoadMarksurfaces
+=================
+*/
+static	void R_LoadMarksurfaces (void *data, int len)
+{	
+	int		i, count;
+	int		*in;
+	msurface_t **out;
+	
+	in = (int *)(data);
+	if (len % sizeof(*in))
+		Com_Error (ERR_DROP, "LoadMap: funny lump size in %s",s_worldData.name);
+	count = len / sizeof(*in);
+	out = (struct msurface_s **) Hunk_Alloc ( count*sizeof(*out), qtrue );	
+
+	s_worldData.marksurfaces = out;
+	s_worldData.nummarksurfaces = count;
+
+	for ( i=0 ; i<count ; i++)
+	{
+		if(in[i] > s_worldData.numsurfaces)
+			assert(0);
+
+		out[i] = s_worldData.surfaces + in[i];
+
+		if (out[i]->shader && out[i]->shader->sort == SS_PORTAL)
+		{
+			s_worldData.portalPresent = qtrue;
+		}
+	}
+}
+
+/*
+=================
+R_LoadPlanes
+=================
+*/
+static	void R_LoadPlanes( void ) {
+	//New method - share with server.
+	s_worldData.planes = cmg.planes;
+	s_worldData.numplanes = cmg.numPlanes;
+}
+
+/*
+=================
+R_LoadFogs
+
+=================
+*/
+static void R_LoadFogs( void *fogdata, int foglen,
+					   void *brushdata, int brushlen,
+					   void *sidedata, int sidelen ) {
+	int			i;
+	fog_t		*out;
+	dfog_t		*fogs;
+	dbrush_t 	*brushes, *brush;
+	dbrushside_t	*sides;
+	int			count, brushesCount, sidesCount;
+	int			sideNum;
+	int			planeNum;
+	shader_t	*shader;
+	float		d;
+	int			firstSide=0;
+	int			lightmaps[MAXLIGHTMAPS] = { LIGHTMAP_NONE } ;
+
+	fogs = (dfog_t *)(fogdata);
+	if (foglen % sizeof(*fogs)) {
+		Com_Error (ERR_DROP, "LoadMap: funny lump size in %s",s_worldData.name);
+	}
+	count = foglen / sizeof(*fogs);
+
+	// create fog structres for them
+	// NOTE: we allocate memory for an extra one so that the LA goggles can turn on their own fog
+	s_worldData.numfogs = count + 1;
+	s_worldData.fogs = (fog_t *)Hunk_Alloc (( s_worldData.numfogs + 1)*sizeof(*out), qtrue );
+	s_worldData.globalFog = -1;
+	out = s_worldData.fogs + 1;
+
+	if ( !count ) {
+		return;
+	}
+
+	brushes = (dbrush_t *)(brushdata);
+	if (brushlen % sizeof(*brushes)) {
+		Com_Error (ERR_DROP, "LoadMap: funny lump size in %s",s_worldData.name);
+	}
+	brushesCount = brushlen / sizeof(*brushes);
+
+	sides = (dbrushside_t *)(sidedata);
+	if (sidelen % sizeof(*sides)) {
+		Com_Error (ERR_DROP, "LoadMap: funny lump size in %s",s_worldData.name);
+	}
+	sidesCount = sidelen / sizeof(*sides);
+
+	for ( i=0 ; i<count ; i++, fogs++) {
+		out->originalBrushNumber = fogs->brushNum;
+		if (out->originalBrushNumber == -1)
+		{
+			out->bounds[0][0] = out->bounds[0][1] = out->bounds[0][2] = MIN_WORLD_COORD;
+			out->bounds[1][0] = out->bounds[1][1] = out->bounds[1][2] = MAX_WORLD_COORD;
+			s_worldData.globalFog = i+1;
+		}
+		else
+		{
+			if ( (unsigned)out->originalBrushNumber >= brushesCount ) {
+				Com_Error( ERR_DROP, "fog brushNumber out of range" );
+			}
+			brush = brushes + out->originalBrushNumber;
+			
+			firstSide = brush->firstSide;
+			
+			if ( (unsigned)firstSide > sidesCount - 6 ) {
+				Com_Error( ERR_DROP, "fog brush sideNumber out of range" );
+			}
+			
+			// brushes are always sorted with the axial sides first
+			sideNum = firstSide + 0;
+			planeNum = sides[ sideNum ].planeNum;
+			out->bounds[0][0] = -s_worldData.planes[ planeNum ].dist;
+			
+			sideNum = firstSide + 1;
+			planeNum = sides[ sideNum ].planeNum;
+			out->bounds[1][0] = s_worldData.planes[ planeNum ].dist;
+			
+			sideNum = firstSide + 2;
+			planeNum = sides[ sideNum ].planeNum;
+			out->bounds[0][1] = -s_worldData.planes[ planeNum ].dist;
+			
+			sideNum = firstSide + 3;
+			planeNum = sides[ sideNum ].planeNum;
+			out->bounds[1][1] = s_worldData.planes[ planeNum ].dist;
+			
+			sideNum = firstSide + 4;
+			planeNum = sides[ sideNum ].planeNum;
+			out->bounds[0][2] = -s_worldData.planes[ planeNum ].dist;
+			
+			sideNum = firstSide + 5;
+			planeNum = sides[ sideNum ].planeNum;
+			out->bounds[1][2] = s_worldData.planes[ planeNum ].dist;
+		}
+		
+		// get information from the shader for fog parameters
+		shader = R_FindShader( fogs->shader, lightmaps, stylesDefault, qtrue );
+		
+		out->parms = *shader->fogParms;
+		out->colorInt = ColorBytes4 ( shader->fogParms->color[0] * tr.identityLight, 
+			shader->fogParms->color[1] * tr.identityLight, 
+			shader->fogParms->color[2] * tr.identityLight, 1.0 );
+		
+		d = shader->fogParms->depthForOpaque < 1 ? 1 : shader->fogParms->depthForOpaque;
+		out->tcScale = 1.0 / ( d * 8 );
+		
+		// set the gradient vector
+		sideNum = fogs->visibleSide;
+		
+		if ( sideNum == -1 ) {
+			out->hasSurface = qfalse;
+		} else {
+			out->hasSurface = qtrue;
+			planeNum = sides[ firstSide + sideNum ].planeNum;
+			VectorSubtract( vec3_origin, s_worldData.planes[ planeNum ].normal, out->surface );
+			out->surface[3] = -s_worldData.planes[ planeNum ].dist;
+		}
+		
+		out++;
+	}
+
+	// Initialise the last fog so we can use it with the LA Goggles
+	// NOTE: We are might appear to be off the end of the array, but we allocated an extra memory slot above but [purposely] didn't 
+	//	increment the total world numFogs to match our array size
+	VectorSet(out->bounds[0], MIN_WORLD_COORD, MIN_WORLD_COORD, MIN_WORLD_COORD);
+	VectorSet(out->bounds[1], MAX_WORLD_COORD, MAX_WORLD_COORD, MAX_WORLD_COORD);
+	out->originalBrushNumber = -1;
+	out->parms.color[0] = 0.0f;
+	out->parms.color[1] = 0.0f;
+	out->parms.color[2] = 0.0f;
+	out->parms.color[3] = 0.0f;
+	out->parms.depthForOpaque = 0.0f;
+	out->colorInt = 0x00000000;
+	out->tcScale = 0.0f;
+	out->hasSurface = false;
+}
+
+/*
+================
+R_LoadLightGrid
+
+================
+*/
+void R_LoadLightGrid( void *data, int len ) {
+	vec3_t	maxs;
+	world_t	*w;
+	int		i;
+	float	*wMins, *wMaxs;
+
+	w = &s_worldData;
+
+	w->lightGridInverseSize[0] = 1.0 / w->lightGridSize[0];
+	w->lightGridInverseSize[1] = 1.0 / w->lightGridSize[1];
+	w->lightGridInverseSize[2] = 1.0 / w->lightGridSize[2];
+
+	wMins = w->bmodels[0].bounds[0];
+	wMaxs = w->bmodels[0].bounds[1];
+
+	for ( i = 0 ; i < 3 ; i++ ) {
+		w->lightGridOrigin[i] = w->lightGridSize[i] * ceil( wMins[i] / w->lightGridSize[i] );
+		maxs[i] = w->lightGridSize[i] * floor( wMaxs[i] / w->lightGridSize[i] );
+		w->lightGridBounds[i] = (maxs[i] - w->lightGridOrigin[i])/w->lightGridSize[i] + 1;
+	}
+
+	w->lightGridData = (mgrid_t *)Hunk_Alloc( len, qfalse );
+	memcpy( w->lightGridData, data, len );
+}
+
+/*
+================
+R_LoadLightGridArray
+
+================
+*/
+void R_LoadLightGridArray( void *data, int len ) {
+	world_t	*w;
+
+	w = &s_worldData;
+
+	w->numGridArrayElements = w->lightGridBounds[0] * w->lightGridBounds[1] * w->lightGridBounds[2];
+
+	if ( len != w->numGridArrayElements * sizeof(*w->lightGridArray) ) {
+		if (len>0)//don't warn if not even lit
+			VID_Printf( PRINT_WARNING, "WARNING: light grid array mismatch\n" );
+		w->lightGridData = NULL;
+		return;
+	}
+
+	w->lightGridArray = (unsigned short *)Hunk_Alloc( len, qfalse );
+	memcpy( w->lightGridArray, data, len );
+}
+
+/*
+================
+R_LoadEntities
+================
+*/
+void R_LoadEntities( void *data, int len ) {
+	const char *p, *token;
+	char keyname[MAX_TOKEN_CHARS];
+	char value[MAX_TOKEN_CHARS];
+	world_t	*w;
+	float ambient = 1;
+
+	w = &s_worldData;
+	w->lightGridSize[0] = 64;
+	w->lightGridSize[1] = 64;
+	w->lightGridSize[2] = 128;
+
+	VectorSet(tr.sunAmbient, 1, 1, 1);
+	tr.distanceCull = 12000;//DEFAULT_DISTANCE_CULL;
+
+	p = (char *)(data);
+
+	token = COM_ParseExt( &p, qtrue );
+	if (!*token || *token != '{') {
+		return;
+	}
+
+	// only parse the world spawn
+	while ( 1 ) {	
+		// parse key
+		token = COM_ParseExt( &p, qtrue );
+
+		if ( !*token || *token == '}' ) {
+			break;
+		}
+		Q_strncpyz(keyname, token, sizeof(keyname));
+
+		// parse value
+		token = COM_ParseExt( &p, qtrue );
+
+		if ( !*token || *token == '}' ) {
+			break;
+		}
+		Q_strncpyz(value, token, sizeof(value));
+
+		if (!Q_stricmp(keyname, "distanceCull")) {
+			sscanf(value, "%f", &tr.distanceCull );
+			continue;
+		}
+		//check for linear fog -rww
+		if (!Q_stricmp(keyname, "linFogStart")) {
+			sscanf(value, "%f", &tr.rangedFog );
+			tr.rangedFog = -tr.rangedFog;
+			continue;
+		}
+		// check for a different grid size
+		if (!Q_stricmp(keyname, "gridsize")) {
+			sscanf(value, "%f %f %f", &w->lightGridSize[0], &w->lightGridSize[1], &w->lightGridSize[2] );
+			continue;
+		}
+	// find the optional world ambient for arioche
+		if (!Q_stricmp(keyname, "_color")) {
+			sscanf(value, "%f %f %f", &tr.sunAmbient[0], &tr.sunAmbient[1], &tr.sunAmbient[2] );
+			continue;
+		}
+		if (!Q_stricmp(keyname, "ambient")) {
+			sscanf(value, "%f", &ambient);
+			continue;
+		}
+	}
+	//both default to 1 so no harm if not present.
+	VectorScale( tr.sunAmbient, ambient, tr.sunAmbient);
+}
+
+
+/*
+=================
+RE_LoadWorldMap
+
+Called directly from cgame
+=================
+*/
+void RE_LoadWorldMap_Actual( const char *name, world_t &worldData, int index ) {
+	char		stripName[MAX_QPATH];
+	Lump outputLumps[3];
+
+	// This is no longer correct. The new code supports sub-models, apparently BSPs in
+	// several chunks. If any map tries to use them, the following COM_Error will go
+	// off. We haven't hit it yet, but if (when) we do, check out tr_bsp.cpp for changes.
+	if ( tr.worldMapLoaded ) {
+		Com_Error( ERR_DROP, "ERROR: attempted to redundantly load world map\n" );
+	}
+
+	// set default sun direction to be used if it isn't
+	// overridden by a shader
+	skyboxportal = 0;
+
+	tr.sunDirection[0] = 0.45f;
+	tr.sunDirection[1] = 0.3f;
+	tr.sunDirection[2] = 0.9f;
+
+	VectorNormalize( tr.sunDirection );
+
+	Cvar_SetValue( "r_sundir_x", tr.sunDirection[0] );
+	Cvar_SetValue( "r_sundir_y", tr.sunDirection[1] );
+	Cvar_SetValue( "r_sundir_z", tr.sunDirection[2] );
+
+	tr.worldMapLoaded = qtrue;
+
+	// clear tr.world so if the level fails to load, the next
+	// try will not look at the partially loaded version
+	tr.world = NULL;
+
+	//Preserve data which was already set in cm_load
+	msurface_t *surfacePtr = s_worldData.surfaces;
+	int numSurfaces = s_worldData.numsurfaces;
+	memset( &s_worldData, 0, sizeof( s_worldData ) );
+	s_worldData.surfaces = surfacePtr;
+	s_worldData.numsurfaces = numSurfaces;
+	//s_worldData.shaders = cm.shaders;
+	s_worldData.numShaders = cmg.numShaders;
+
+	Q_strncpyz( s_worldData.name, name, sizeof( s_worldData.name ) );
+
+	Q_strncpyz( s_worldData.baseName, COM_SkipPath( s_worldData.name ), sizeof( s_worldData.name ) );
+	COM_StripExtension( s_worldData.baseName, s_worldData.baseName );
+
+	COM_StripExtension(name, stripName);
+	
+	c_gridVerts = 0;
+
+	// load into heap
+	R_LoadPlanes ();
+
+	outputLumps[0].load(stripName, "fogs");
+	outputLumps[1].load(stripName, "brushes");
+	outputLumps[2].load(stripName, "brushsides");
+	R_LoadFogs( outputLumps[0].data, outputLumps[0].len,
+		outputLumps[1].data, outputLumps[1].len,
+		outputLumps[2].data, outputLumps[2].len );
+	outputLumps[2].clear();
+	outputLumps[1].clear();
+
+	outputLumps[0].load(stripName, "leafsurfaces");
+	R_LoadMarksurfaces (outputLumps[0].data, outputLumps[0].len);
+
+	outputLumps[0].load(stripName, "nodes");
+	outputLumps[1].load(stripName, "leafs");
+	R_LoadNodesAndLeafs (outputLumps[0].data, outputLumps[0].len,
+		outputLumps[1].data, outputLumps[1].len);
+	outputLumps[1].clear();
+	
+	outputLumps[0].load(stripName, "models");
+	R_LoadSubmodels (outputLumps[0].data, outputLumps[0].len);
+
+	R_LoadVisibility();
+
+	outputLumps[0].load(stripName, "entities");
+	R_LoadEntities( outputLumps[0].data, outputLumps[0].len );
+	outputLumps[0].load(stripName, "lightgrid");
+	R_LoadLightGrid( outputLumps[0].data, outputLumps[0].len );
+	outputLumps[0].load(stripName, "lightarray");
+	R_LoadLightGridArray( outputLumps[0].data, outputLumps[0].len );
+
+	// only set tr.world now that we know the entire level has loaded properly
+	tr.world = &s_worldData;
+
+	// Load the light parms for this level
+	R_LoadLevelLightParms();
+	R_GetLightParmsForLevel();
+}
+
+
+// new wrapper used for convenience to tell z_malloc()-fail recovery code whether it's safe to dump the cached-bsp or not.
+//
+extern qboolean gbUsingCachedMapDataRightNow;
+void RE_LoadWorldMap( const char *name )
+{
+	gbUsingCachedMapDataRightNow = qtrue;	// !!!!!!!!!!!!
+
+		RE_LoadWorldMap_Actual( name, s_worldData, 0 );
+
+	gbUsingCachedMapDataRightNow = qfalse;	// !!!!!!!!!!!!
+}
diff --git a/code/renderer/tr_cmds.cpp b/code/renderer/tr_cmds.cpp
new file mode 100644
index 0000000..d2465c4
--- /dev/null
+++ b/code/renderer/tr_cmds.cpp
@@ -0,0 +1,512 @@
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+
+#include "tr_local.h"
+
+
+/*
+=====================
+R_PerformanceCounters
+=====================
+*/
+void R_PerformanceCounters( void ) {
+#ifndef _XBOX
+	if ( !r_speeds->integer ) {
+		// clear the counters even if we aren't printing
+		memset( &tr.pc, 0, sizeof( tr.pc ) );
+		memset( &backEnd.pc, 0, sizeof( backEnd.pc ) );
+		return;
+	}
+
+	if (r_speeds->integer == 1) {
+		const float texSize = R_SumOfUsedImages( qfalse )/(8*1048576.0f)*(r_texturebits->integer?r_texturebits->integer:glConfig.colorBits);
+		VID_Printf (PRINT_ALL, "%i/%i shdrs/srfs %i leafs %i vrts %i/%i tris %.2fMB tex %.2f dc\n",
+			backEnd.pc.c_shaders, backEnd.pc.c_surfaces, tr.pc.c_leafs, backEnd.pc.c_vertexes, 
+			backEnd.pc.c_indexes/3, backEnd.pc.c_totalIndexes/3, 
+			texSize, backEnd.pc.c_overDraw / (float)(glConfig.vidWidth * glConfig.vidHeight) ); 
+	} else if (r_speeds->integer == 2) {
+		VID_Printf (PRINT_ALL, "(patch) %i sin %i sclip  %i sout %i bin %i bclip %i bout\n",
+			tr.pc.c_sphere_cull_patch_in, tr.pc.c_sphere_cull_patch_clip, tr.pc.c_sphere_cull_patch_out, 
+			tr.pc.c_box_cull_patch_in, tr.pc.c_box_cull_patch_clip, tr.pc.c_box_cull_patch_out );
+		VID_Printf (PRINT_ALL, "(md3) %i sin %i sclip  %i sout %i bin %i bclip %i bout\n",
+			tr.pc.c_sphere_cull_md3_in, tr.pc.c_sphere_cull_md3_clip, tr.pc.c_sphere_cull_md3_out, 
+			tr.pc.c_box_cull_md3_in, tr.pc.c_box_cull_md3_clip, tr.pc.c_box_cull_md3_out );
+	} else if (r_speeds->integer == 3) {
+		VID_Printf (PRINT_ALL, "viewcluster: %i\n", tr.viewCluster );
+	} else if (r_speeds->integer == 4) {
+		if ( backEnd.pc.c_dlightVertexes ) {
+			VID_Printf (PRINT_ALL, "dlight srf:%i  culled:%i  verts:%i  tris:%i\n", 
+				tr.pc.c_dlightSurfaces, tr.pc.c_dlightSurfacesCulled,
+				backEnd.pc.c_dlightVertexes, backEnd.pc.c_dlightIndexes / 3 );
+		}
+	} 
+	else if (r_speeds->integer == 5 )
+	{
+		VID_Printf( PRINT_ALL, "zFar: %.0f\n", tr.viewParms.zFar );
+	}
+	else if (r_speeds->integer == 6 )
+	{
+		VID_Printf( PRINT_ALL, "flare adds:%i tests:%i renders:%i\n", 
+			backEnd.pc.c_flareAdds, backEnd.pc.c_flareTests, backEnd.pc.c_flareRenders );
+	}
+	else if (r_speeds->integer == 7) {
+		const float texSize = R_SumOfUsedImages(qtrue) / (1048576.0f);
+		const float backBuff= glConfig.vidWidth * glConfig.vidHeight * glConfig.colorBits / (8.0f * 1024*1024);
+		const float depthBuff= glConfig.vidWidth * glConfig.vidHeight * glConfig.depthBits / (8.0f * 1024*1024);
+		const float stencilBuff= glConfig.vidWidth * glConfig.vidHeight * glConfig.stencilBits / (8.0f * 1024*1024);
+		VID_Printf (PRINT_ALL, "Tex MB %.2f + buffers %.2f MB = Total %.2fMB\n",
+			texSize, backBuff*2+depthBuff+stencilBuff, texSize+backBuff*2+depthBuff+stencilBuff); 
+	}
+#endif
+
+	memset( &tr.pc, 0, sizeof( tr.pc ) );
+	memset( &backEnd.pc, 0, sizeof( backEnd.pc ) );
+}
+
+
+/*
+====================
+R_InitCommandBuffers
+====================
+*/
+void R_InitCommandBuffers( void ) {
+}
+
+/*
+====================
+R_ShutdownCommandBuffers
+====================
+*/
+void R_ShutdownCommandBuffers( void ) {
+}
+
+/*
+====================
+R_IssueRenderCommands
+====================
+*/
+int	c_blockedOnRender;
+int	c_blockedOnMain;
+
+void R_IssueRenderCommands( qboolean runPerformanceCounters ) {
+	renderCommandList_t	*cmdList;
+
+	cmdList = &backEndData->commands;
+
+	// add an end-of-list command
+	*(int *)(cmdList->cmds + cmdList->used) = RC_END_OF_LIST;
+
+	// clear it out, in case this is a sync and not a buffer flip
+	cmdList->used = 0;
+
+	// at this point, the back end thread is idle, so it is ok
+	// to look at it's performance counters
+	if ( runPerformanceCounters ) {
+		R_PerformanceCounters();
+	}
+
+	// actually start the commands going
+	if ( !r_skipBackEnd->integer ) {
+		// let it start on the new batch
+		RB_ExecuteRenderCommands( cmdList->cmds );
+	}
+}
+
+
+/*
+====================
+R_SyncRenderThread
+
+Issue any pending commands and wait for them to complete.
+After exiting, the render thread will have completed its work
+and will remain idle and the main thread is free to issue
+OpenGL calls until R_IssueRenderCommands is called.
+====================
+*/
+void R_SyncRenderThread( void ) {
+#ifndef _XBOX
+	if ( !tr.registered ) {
+		return;
+	}
+	R_IssueRenderCommands( qfalse );
+#endif
+}
+
+/*
+============
+R_GetCommandBuffer
+
+make sure there is enough command space, waiting on the
+render thread if needed.
+============
+*/
+void *R_GetCommandBuffer( int bytes ) {
+	renderCommandList_t	*cmdList;
+
+	cmdList = &backEndData->commands;
+
+	// always leave room for the end of list command
+	if ( cmdList->used + bytes + 4 > MAX_RENDER_COMMANDS ) {
+#if defined(_DEBUG) && defined(_XBOX)
+		Com_Printf(S_COLOR_RED"Command buffer overflow!  Tell Brian.\n");
+#endif
+		if ( bytes > MAX_RENDER_COMMANDS - 4 ) {
+			Com_Error( ERR_FATAL, "R_GetCommandBuffer: bad size %i", bytes );
+		}
+		// if we run out of room, just start dropping commands
+		return NULL;
+	}
+
+	cmdList->used += bytes;
+
+	return cmdList->cmds + cmdList->used - bytes;
+}
+
+
+/*
+=============
+R_AddDrawSurfCmd
+
+=============
+*/
+void	R_AddDrawSurfCmd( drawSurf_t *drawSurfs, int numDrawSurfs ) {
+	drawSurfsCommand_t	*cmd;
+
+	cmd = (drawSurfsCommand_t *) R_GetCommandBuffer( sizeof( *cmd ) );
+	if ( !cmd ) {
+		return;
+	}
+	cmd->commandId = RC_DRAW_SURFS;
+
+	cmd->drawSurfs = drawSurfs;
+	cmd->numDrawSurfs = numDrawSurfs;
+
+	cmd->refdef = tr.refdef;
+	cmd->viewParms = tr.viewParms;
+}
+
+
+/*
+=============
+RE_SetColor
+
+Passing NULL will set the color to white
+=============
+*/
+void	RE_SetColor( const float *rgba ) {
+	setColorCommand_t	*cmd;
+
+	cmd = (setColorCommand_t *) R_GetCommandBuffer( sizeof( *cmd ) );
+	if ( !cmd ) {
+		return;
+	}
+	cmd->commandId = RC_SET_COLOR;
+	if ( rgba ) {
+		cmd->color[0] = rgba[0];
+		cmd->color[1] = rgba[1];
+		cmd->color[2] = rgba[2];
+		cmd->color[3] = rgba[3];
+		return;
+	}
+
+	cmd->color[0] = 1;
+	cmd->color[1] = 1;
+	cmd->color[2] = 1;
+	cmd->color[3] = 1;
+}
+
+
+/*
+=============
+RE_StretchPic
+=============
+*/
+void RE_StretchPic ( float x, float y, float w, float h, 
+					  float s1, float t1, float s2, float t2, qhandle_t hShader ) {
+	stretchPicCommand_t	*cmd;
+
+	cmd = (stretchPicCommand_t *) R_GetCommandBuffer( sizeof( *cmd ) );
+	if ( !cmd ) {
+		return;
+	}
+	cmd->commandId = RC_STRETCH_PIC;
+	cmd->shader = R_GetShaderByHandle( hShader );
+	cmd->x = x;
+	cmd->y = y;
+	cmd->w = w;
+	cmd->h = h;
+	cmd->s1 = s1;
+	cmd->t1 = t1;
+	cmd->s2 = s2;
+	cmd->t2 = t2;
+}
+
+/*
+=============
+RE_RotatePic
+=============
+*/
+void RE_RotatePic ( float x, float y, float w, float h, 
+					  float s1, float t1, float s2, float t2,float a, qhandle_t hShader ) {
+	rotatePicCommand_t	*cmd;
+
+	cmd = (rotatePicCommand_t *) R_GetCommandBuffer( sizeof( *cmd ) );
+	if ( !cmd ) {
+		return;
+	}
+	cmd->commandId = RC_ROTATE_PIC;
+	cmd->shader = R_GetShaderByHandle( hShader );
+	cmd->x = x;
+	cmd->y = y;
+	cmd->w = w;
+	cmd->h = h;
+	cmd->s1 = s1;
+	cmd->t1 = t1;
+	cmd->s2 = s2;
+	cmd->t2 = t2;
+	cmd->a = a;
+}
+
+/*
+=============
+RE_RotatePic2
+=============
+*/
+void RE_RotatePic2 ( float x, float y, float w, float h, 
+					  float s1, float t1, float s2, float t2,float a, qhandle_t hShader ) {
+	rotatePicCommand_t	*cmd;
+
+	cmd = (rotatePicCommand_t *) R_GetCommandBuffer( sizeof( *cmd ) );
+	if ( !cmd ) {
+		return;
+	}
+	cmd->commandId = RC_ROTATE_PIC2;
+	cmd->shader = R_GetShaderByHandle( hShader );
+	cmd->x = x;
+	cmd->y = y;
+	cmd->w = w;
+	cmd->h = h;
+	cmd->s1 = s1;
+	cmd->t1 = t1;
+	cmd->s2 = s2;
+	cmd->t2 = t2;
+	cmd->a = a;
+}
+
+void RE_LAGoggles( void )
+{
+	tr.refdef.rdflags |= (RDF_doLAGoggles|RDF_doFullbright);
+
+	fog_t		*fog = &tr.world->fogs[tr.world->numfogs];
+
+	fog->parms.color[0] = 0.75f;
+	fog->parms.color[1] = 0.42f + random() * 0.025f;
+	fog->parms.color[2] = 0.07f;
+	fog->parms.color[3] = 1.0f;
+	fog->parms.depthForOpaque = 10000;
+	fog->colorInt = ColorBytes4(fog->parms.color[0], fog->parms.color[1], fog->parms.color[2], fog->parms.color[3]);
+	fog->tcScale = 2.0f / ( fog->parms.depthForOpaque * (1.0f + cos( tr.refdef.floatTime) * 0.1f));
+}
+
+void RE_RenderWorldEffects(void)
+{
+	setModeCommand_t	*cmd;
+
+	cmd = (setModeCommand_t *)R_GetCommandBuffer( sizeof( *cmd ) );
+	if ( !cmd ) {
+		return;
+	}
+	cmd->commandId = RC_WORLD_EFFECTS;
+}
+
+/*   
+=============
+RE_Scissor
+=============
+*/
+void RE_Scissor ( float x, float y, float w, float h) 
+{
+	scissorCommand_t	*cmd;
+
+	cmd = (scissorCommand_t *) R_GetCommandBuffer( sizeof( *cmd ) );
+	if ( !cmd ) {
+		return;
+	}
+	cmd->commandId = RC_SCISSOR;
+	cmd->x = x;
+	cmd->y = y;
+	cmd->w = w;
+	cmd->h = h;
+}
+
+/*
+====================
+RE_BeginFrame
+
+If running in stereo, RE_BeginFrame will be called twice
+for each RE_EndFrame
+====================
+*/
+void RE_BeginFrame( stereoFrame_t stereoFrame ) {
+	drawBufferCommand_t	*cmd;
+
+	if ( !tr.registered ) {
+		return;
+	}
+	glState.finishCalled = qfalse;
+
+	tr.frameCount++;
+	tr.frameSceneNum = 0;
+
+	//
+	// do overdraw measurement
+	//
+#ifndef _XBOX
+	if ( r_measureOverdraw->integer )
+	{
+		if ( glConfig.stencilBits < 4 )
+		{
+			VID_Printf( PRINT_ALL, "Warning: not enough stencil bits to measure overdraw: %d\n", glConfig.stencilBits );
+			Cvar_Set( "r_measureOverdraw", "0" );
+			r_measureOverdraw->modified = qfalse;
+		}
+		else if ( r_shadows->integer == 2 )
+		{
+			VID_Printf( PRINT_ALL, "Warning: stencil shadows and overdraw measurement are mutually exclusive\n" );
+			Cvar_Set( "r_measureOverdraw", "0" );
+			r_measureOverdraw->modified = qfalse;
+		}
+		else
+		{
+			R_SyncRenderThread();
+			qglEnable( GL_STENCIL_TEST );
+			qglStencilMask( ~0U );
+			qglClearStencil( 0U );
+			qglStencilFunc( GL_ALWAYS, 0U, ~0U );
+			qglStencilOp( GL_KEEP, GL_INCR, GL_INCR );
+		}
+		r_measureOverdraw->modified = qfalse;
+	}
+	else
+	{
+		// this is only reached if it was on and is now off
+		if ( r_measureOverdraw->modified ) {
+			R_SyncRenderThread();
+			qglDisable( GL_STENCIL_TEST );
+			r_measureOverdraw->modified = qfalse;
+		}
+	}
+#endif
+
+	//
+	// texturemode stuff
+	//
+	if ( r_textureMode->modified || r_ext_texture_filter_anisotropic->modified) {
+		R_SyncRenderThread();
+		GL_TextureMode( r_textureMode->string );
+		r_textureMode->modified = qfalse;
+		r_ext_texture_filter_anisotropic->modified = qfalse;
+	}
+
+	//
+	// gamma stuff
+	//
+	if ( r_gamma->modified ) {
+		r_gamma->modified = qfalse;
+
+		R_SyncRenderThread();
+		R_SetColorMappings();
+	}
+
+    // check for errors
+    if ( !r_ignoreGLErrors->integer ) {
+        int	err;
+
+		R_SyncRenderThread();
+        if ( ( err = qglGetError() ) != GL_NO_ERROR ) {
+            Com_Error( ERR_FATAL, "RE_BeginFrame() - glGetError() failed (0x%x)!\n", err );
+        }
+    }
+
+	//
+	// draw buffer stuff
+	//
+	cmd = (drawBufferCommand_t *) R_GetCommandBuffer( sizeof( *cmd ) );
+	if ( !cmd ) {
+		return;
+	}
+	cmd->commandId = RC_DRAW_BUFFER;
+
+	if ( glConfig.stereoEnabled ) {
+		if ( stereoFrame == STEREO_LEFT ) {
+			cmd->buffer = (int)GL_BACK_LEFT;
+		} else if ( stereoFrame == STEREO_RIGHT ) {
+			cmd->buffer = (int)GL_BACK_RIGHT;
+		} else {
+			Com_Error( ERR_FATAL, "RE_BeginFrame: Stereo is enabled, but stereoFrame was %i", stereoFrame );
+		}
+	} else {
+		if ( stereoFrame != STEREO_CENTER ) {
+			Com_Error( ERR_FATAL, "RE_BeginFrame: Stereo is disabled, but stereoFrame was %i", stereoFrame );
+		}
+//		if ( !Q_stricmp( r_drawBuffer->string, "GL_FRONT" ) ) {
+//			cmd->buffer = (int)GL_FRONT;
+//		} else 
+		{
+			cmd->buffer = (int)GL_BACK;
+		}
+	}
+}
+
+
+/*
+=============
+RE_EndFrame
+
+Returns the number of msec spent in the back end
+=============
+*/
+void RE_EndFrame( int *frontEndMsec, int *backEndMsec ) {
+	swapBuffersCommand_t	*cmd;
+
+	if ( !tr.registered ) {
+		return;
+	}
+	cmd = (swapBuffersCommand_t *) R_GetCommandBuffer( sizeof( *cmd ) );
+	if ( !cmd ) {
+		return;
+	}
+	cmd->commandId = RC_SWAP_BUFFERS;
+
+#ifdef _XBOX
+	if (!qglBeginFrame()) return;
+#endif
+
+	R_IssueRenderCommands( qtrue );
+
+#ifdef _XBOX
+	RE_ProcessDissolve(); // render the disolve now
+	qglEndFrame();
+#endif
+
+	// use the other buffers next frame, because another CPU
+	// may still be rendering into the current ones
+	R_ToggleSmpFrame();
+
+	if ( frontEndMsec ) {
+		*frontEndMsec = tr.frontEndMsec;
+	}
+	tr.frontEndMsec = 0;
+	if ( backEndMsec ) {
+		*backEndMsec = backEnd.pc.msec;
+	}
+	backEnd.pc.msec = 0;
+	
+	for(int i=0;i<MAX_LIGHT_STYLES;i++)
+	{
+		styleUpdated[i] = false;
+	}
+}
+
diff --git a/code/renderer/tr_curve.cpp b/code/renderer/tr_curve.cpp
new file mode 100644
index 0000000..4781073
--- /dev/null
+++ b/code/renderer/tr_curve.cpp
@@ -0,0 +1,903 @@
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+
+
+#include "tr_local.h"
+
+/*
+
+This file does all of the processing necessary to turn a raw grid of points
+read from the map file into a srfGridMesh_t ready for rendering.
+
+The level of detail solution is direction independent, based only on subdivided
+distance from the true curve.
+
+Only a single entry point:
+
+srfGridMesh_t *R_SubdividePatchToGrid( int width, int height,
+								drawVert_t points[MAX_PATCH_SIZE*MAX_PATCH_SIZE] ) {
+
+*/
+
+
+/*
+============
+LerpDrawVert
+============
+*/
+#ifdef _XBOX
+static void LerpDrawVert( drawVert_t *a, drawVert_t *b, drawVert_t *out ) {
+	int	k;
+	out->xyz[0] = 0.5 * (a->xyz[0] + b->xyz[0]);
+	out->xyz[1] = 0.5 * (a->xyz[1] + b->xyz[1]);
+	out->xyz[2] = 0.5 * (a->xyz[2] + b->xyz[2]);
+
+	out->dvst[0] = (short)(0.5 * (float)(a->dvst[0] + b->dvst[0]));
+	out->dvst[1] = (short)(0.5 * (float)(a->dvst[1] + b->dvst[1]));
+
+	out->normal[0] = 0.5 * (a->normal[0] + b->normal[0]);
+	out->normal[1] = 0.5 * (a->normal[1] + b->normal[1]);
+	out->normal[2] = 0.5 * (a->normal[2] + b->normal[2]);
+
+	for(k=0;k<MAXLIGHTMAPS;k++)
+	{
+		out->dvlightmap[k][0] = (short)(0.5 * (float)(a->dvlightmap[k][0] + b->dvlightmap[k][0]));
+		out->dvlightmap[k][1] = (short)(0.5 * (float)(a->dvlightmap[k][1] + b->dvlightmap[k][1]));
+
+#ifdef COMPRESS_VERTEX_COLORS
+		// Need to do averaging per every four bits
+		for (int j = 0; j < 2; ++j)
+		{
+			byte ah, al, bh, bl;
+			ah = a->dvcolor[k][j] >> 4;
+			al = a->dvcolor[k][j] & 0x0F;
+			bh = b->dvcolor[k][j] >> 4;
+			bl = b->dvcolor[k][j] & 0x0F;
+			out->dvcolor[k][j] = (((ah+bh) / 2) << 4) | ((al+bl) / 2);
+		}
+#else
+		out->dvcolor[k][0] = (a->dvcolor[k][0] + b->dvcolor[k][0]) / 2;
+		out->dvcolor[k][1] = (a->dvcolor[k][1] + b->dvcolor[k][1]) / 2;
+		out->dvcolor[k][2] = (a->dvcolor[k][2] + b->dvcolor[k][2]) / 2;
+		out->dvcolor[k][3] = (a->dvcolor[k][3] + b->dvcolor[k][3]) / 2;
+#endif
+	}
+}
+
+#else // _XBOX
+
+static void LerpDrawVert( drawVert_t *a, drawVert_t *b, drawVert_t *out ) {
+	int	k;
+	out->xyz[0] = 0.5 * (a->xyz[0] + b->xyz[0]);
+	out->xyz[1] = 0.5 * (a->xyz[1] + b->xyz[1]);
+	out->xyz[2] = 0.5 * (a->xyz[2] + b->xyz[2]);
+
+	out->st[0] = 0.5 * (a->st[0] + b->st[0]);
+	out->st[1] = 0.5 * (a->st[1] + b->st[1]);
+
+	out->normal[0] = 0.5 * (a->normal[0] + b->normal[0]);
+	out->normal[1] = 0.5 * (a->normal[1] + b->normal[1]);
+	out->normal[2] = 0.5 * (a->normal[2] + b->normal[2]);
+
+	for(k=0;k<MAXLIGHTMAPS;k++)
+	{
+		out->lightmap[k][0] = 0.5 * (a->lightmap[k][0] + b->lightmap[k][0]);
+		out->lightmap[k][1] = 0.5 * (a->lightmap[k][1] + b->lightmap[k][1]);
+
+		out->color[k][0] = (a->color[k][0] + b->color[k][0]) >> 1;
+		out->color[k][1] = (a->color[k][1] + b->color[k][1]) >> 1;
+		out->color[k][2] = (a->color[k][2] + b->color[k][2]) >> 1;
+		out->color[k][3] = (a->color[k][3] + b->color[k][3]) >> 1;
+	}
+}
+#endif // _XBOX
+
+/*
+============
+Transpose
+============
+*/
+#ifdef _XBOX
+static void Transpose( int width, int height, drawVert_t* ctrl/*[MAX_GRID_SIZE][MAX_GRID_SIZE]*/ ) {
+	int		i, j;
+	drawVert_t	temp;
+
+	if ( width > height ) {
+		for ( i = 0 ; i < height ; i++ ) {
+			for ( j = i + 1 ; j < width ; j++ ) {
+				if ( j < height ) {
+					// swap the value
+					temp = ctrl[j*MAX_GRID_SIZE+i];
+					ctrl[j*MAX_GRID_SIZE+i] = ctrl[i*MAX_GRID_SIZE+j];
+					ctrl[i*MAX_GRID_SIZE+j] = temp;
+				} else {
+					// just copy
+					ctrl[j*MAX_GRID_SIZE+i] = ctrl[i*MAX_GRID_SIZE+j];
+				}
+			}
+		}
+	} else {
+		for ( i = 0 ; i < width ; i++ ) {
+			for ( j = i + 1 ; j < height ; j++ ) {
+				if ( j < width ) {
+					// swap the value
+					temp = ctrl[i*MAX_GRID_SIZE+j];
+					ctrl[i*MAX_GRID_SIZE+j] = ctrl[j*MAX_GRID_SIZE+i];
+					ctrl[j*MAX_GRID_SIZE+i] = temp;
+				} else {
+					// just copy
+					ctrl[i*MAX_GRID_SIZE+j] = ctrl[j*MAX_GRID_SIZE+i];
+				}
+			}
+		}
+	}
+
+}
+
+#else // _XBOX
+static void Transpose( int width, int height, drawVert_t ctrl[MAX_GRID_SIZE][MAX_GRID_SIZE] ) {
+	int		i, j;
+	drawVert_t	temp;
+
+	if ( width > height ) {
+		for ( i = 0 ; i < height ; i++ ) {
+			for ( j = i + 1 ; j < width ; j++ ) {
+				if ( j < height ) {
+					// swap the value
+					temp = ctrl[j][i];
+					ctrl[j][i] = ctrl[i][j];
+					ctrl[i][j] = temp;
+				} else {
+					// just copy
+					ctrl[j][i] = ctrl[i][j];
+				}
+			}
+		}
+	} else {
+		for ( i = 0 ; i < width ; i++ ) {
+			for ( j = i + 1 ; j < height ; j++ ) {
+				if ( j < width ) {
+					// swap the value
+					temp = ctrl[i][j];
+					ctrl[i][j] = ctrl[j][i];
+					ctrl[j][i] = temp;
+				} else {
+					// just copy
+					ctrl[i][j] = ctrl[j][i];
+				}
+			}
+		}
+	}
+
+}
+#endif
+
+/*
+=================
+MakeMeshNormals
+
+Handles all the complicated wrapping and degenerate cases
+=================
+*/
+#ifdef _XBOX
+static void MakeMeshNormals( int width, int height, drawVert_t* ctrl/*[MAX_GRID_SIZE][MAX_GRID_SIZE]*/ ) {
+	int		i, j, k, dist;
+	vec3_t	normal;
+	vec3_t	sum;
+	int		count;
+	vec3_t	base;
+	vec3_t	delta;
+	int		x, y;
+	drawVert_t	*dv;
+	vec3_t		around[8], temp;
+	qboolean	good[8];
+	qboolean	wrapWidth, wrapHeight;
+	float		len;
+	static	int	neighbors[8][2] = {
+		{0,1}, {1,1}, {1,0}, {1,-1}, {0,-1}, {-1,-1}, {-1,0}, {-1,1}
+	};
+
+	wrapWidth = qfalse;
+	for ( i = 0 ; i < height ; i++ ) {
+		VectorSubtract( ctrl[i*MAX_GRID_SIZE+0].xyz, ctrl[i*MAX_GRID_SIZE+width-1].xyz, delta );
+		len = VectorLengthSquared( delta );
+		if ( len > 1.0 ) {
+			break;
+		}
+	}
+	if ( i == height ) {
+		wrapWidth = qtrue;
+	}
+
+	wrapHeight = qfalse;
+	for ( i = 0 ; i < width ; i++ ) {
+		VectorSubtract( ctrl[0*MAX_GRID_SIZE+i].xyz, ctrl[(height-1)*MAX_GRID_SIZE+i].xyz, delta );
+		len = VectorLengthSquared( delta );
+		if ( len > 1.0 ) {
+			break;
+		}
+	}
+	if ( i == width) {
+		wrapHeight = qtrue;
+	}
+
+
+	for ( i = 0 ; i < width ; i++ ) {
+		for ( j = 0 ; j < height ; j++ ) {
+			count = 0;
+			dv = &ctrl[j*MAX_GRID_SIZE+i];
+			VectorCopy( dv->xyz, base );
+			for ( k = 0 ; k < 8 ; k++ ) {
+				VectorClear( around[k] );
+				good[k] = qfalse;
+
+				for ( dist = 1 ; dist <= 3 ; dist++ ) {
+					x = i + neighbors[k][0] * dist;
+					y = j + neighbors[k][1] * dist;
+					if ( wrapWidth ) {
+						if ( x < 0 ) {
+							x = width - 1 + x;
+						} else if ( x >= width ) {
+							x = 1 + x - width;
+						}
+					}
+					if ( wrapHeight ) {
+						if ( y < 0 ) {
+							y = height - 1 + y;
+						} else if ( y >= height ) {
+							y = 1 + y - height;
+						}
+					}
+
+					if ( x < 0 || x >= width || y < 0 || y >= height ) {
+						break;					// edge of patch
+					}
+					VectorSubtract( ctrl[y*MAX_GRID_SIZE+x].xyz, base, temp );
+					if ( VectorNormalize2( temp, temp ) == 0 ) {
+						continue;				// degenerate edge, get more dist
+					} else {
+						good[k] = qtrue;
+						VectorCopy( temp, around[k] );
+						break;					// good edge
+					}
+				}
+			}
+
+			VectorClear( sum );
+			for ( k = 0 ; k < 8 ; k++ ) {
+				if ( !good[k] || !good[(k+1)&7] ) {
+					continue;	// didn't get two points
+				}
+				CrossProduct( around[(k+1)&7], around[k], normal );
+				if ( VectorNormalize2( normal, normal ) == 0 ) {
+					continue;
+				}
+				VectorAdd( normal, sum, sum );
+				count++;
+			}
+			if ( count == 0 ) {
+//printf("bad normal\n");
+				count = 1;
+			}
+			VectorNormalize2( sum, dv->normal );
+		}
+	}
+}
+
+#else // _XBOX
+
+static void MakeMeshNormals( int width, int height, drawVert_t ctrl[MAX_GRID_SIZE][MAX_GRID_SIZE] ) {
+	int		i, j, k, dist;
+	vec3_t	normal;
+	vec3_t	sum;
+	int		count;
+	vec3_t	base;
+	vec3_t	delta;
+	int		x, y;
+	drawVert_t	*dv;
+	vec3_t		around[8], temp;
+	qboolean	good[8];
+	qboolean	wrapWidth, wrapHeight;
+	float		len;
+static	int	neighbors[8][2] = {
+	{0,1}, {1,1}, {1,0}, {1,-1}, {0,-1}, {-1,-1}, {-1,0}, {-1,1}
+	};
+
+	wrapWidth = qfalse;
+	for ( i = 0 ; i < height ; i++ ) {
+		VectorSubtract( ctrl[i][0].xyz, ctrl[i][width-1].xyz, delta );
+		len = VectorLength( delta );
+		if ( len > 1.0 ) {
+			break;
+		}
+	}
+	if ( i == height ) {
+		wrapWidth = qtrue;
+	}
+
+	wrapHeight = qfalse;
+	for ( i = 0 ; i < width ; i++ ) {
+		VectorSubtract( ctrl[0][i].xyz, ctrl[height-1][i].xyz, delta );
+		len = VectorLength( delta );
+		if ( len > 1.0 ) {
+			break;
+		}
+	}
+	if ( i == width) {
+		wrapHeight = qtrue;
+	}
+
+
+	for ( i = 0 ; i < width ; i++ ) {
+		for ( j = 0 ; j < height ; j++ ) {
+			count = 0;
+			dv = &ctrl[j][i];
+			VectorCopy( dv->xyz, base );
+			for ( k = 0 ; k < 8 ; k++ ) {
+				VectorClear( around[k] );
+				good[k] = qfalse;
+
+				for ( dist = 1 ; dist <= 3 ; dist++ ) {
+					x = i + neighbors[k][0] * dist;
+					y = j + neighbors[k][1] * dist;
+					if ( wrapWidth ) {
+						if ( x < 0 ) {
+							x = width - 1 + x;
+						} else if ( x >= width ) {
+							x = 1 + x - width;
+						}
+					}
+					if ( wrapHeight ) {
+						if ( y < 0 ) {
+							y = height - 1 + y;
+						} else if ( y >= height ) {
+							y = 1 + y - height;
+						}
+					}
+
+					if ( x < 0 || x >= width || y < 0 || y >= height ) {
+						break;					// edge of patch
+					}
+					VectorSubtract( ctrl[y][x].xyz, base, temp );
+					if ( VectorNormalize2( temp, temp ) == 0 ) {
+						continue;				// degenerate edge, get more dist
+					} else {
+						good[k] = qtrue;
+						VectorCopy( temp, around[k] );
+						break;					// good edge
+					}
+				}
+			}
+
+			VectorClear( sum );
+			for ( k = 0 ; k < 8 ; k++ ) {
+				if ( !good[k] || !good[(k+1)&7] ) {
+					continue;	// didn't get two points
+				}
+				CrossProduct( around[(k+1)&7], around[k], normal );
+				if ( VectorNormalize2( normal, normal ) == 0 ) {
+					continue;
+				}
+				VectorAdd( normal, sum, sum );
+				count++;
+			}
+			if ( count == 0 ) {
+//printf("bad normal\n");
+				count = 1;
+			}
+			VectorNormalize2( sum, dv->normal );
+		}
+	}
+}
+#endif
+
+
+/*
+============
+InvertCtrl
+============
+*/
+#ifdef _XBOX
+static void InvertCtrl( int width, int height, drawVert_t* ctrl/*[MAX_GRID_SIZE][MAX_GRID_SIZE]*/ ) {
+	int		i, j;
+	drawVert_t	temp;
+
+	for ( i = 0 ; i < height ; i++ ) {
+		for ( j = 0 ; j < width/2 ; j++ ) {
+			temp = ctrl[i*MAX_GRID_SIZE+j];
+			ctrl[i*MAX_GRID_SIZE+j] = ctrl[i*MAX_GRID_SIZE+width-1-j];
+			ctrl[i*MAX_GRID_SIZE+width-1-j] = temp;
+		}
+	}
+}
+
+#else // _XBOX
+static void InvertCtrl( int width, int height, drawVert_t ctrl[MAX_GRID_SIZE][MAX_GRID_SIZE] ) {
+	int		i, j;
+	drawVert_t	temp;
+
+	for ( i = 0 ; i < height ; i++ ) {
+		for ( j = 0 ; j < width/2 ; j++ ) {
+			temp = ctrl[i][j];
+			ctrl[i][j] = ctrl[i][width-1-j];
+			ctrl[i][width-1-j] = temp;
+		}
+	}
+}
+#endif // _XBOX
+
+/*
+=================
+InvertErrorTable
+=================
+*/
+#ifdef _XBOX
+static void InvertErrorTable( float* errorTable/*[2][MAX_GRID_SIZE]*/, int width, int height ) {
+	int		i;
+	float	copy[2][MAX_GRID_SIZE];
+
+	memcpy( copy, errorTable, sizeof( copy ) );
+
+	for ( i = 0 ; i < width ; i++ ) {
+		errorTable[1*MAX_GRID_SIZE+i] = copy[0][i];	//[width-1-i];
+	}
+
+	for ( i = 0 ; i < height ; i++ ) {
+		errorTable[0*MAX_GRID_SIZE+i] = copy[1][height-1-i];
+	}
+
+}
+#else // _XBOX
+static void InvertErrorTable( float errorTable[2][MAX_GRID_SIZE], int width, int height ) {
+	int		i;
+	float	copy[2][MAX_GRID_SIZE];
+
+	memcpy( copy, errorTable, sizeof( copy ) );
+
+	for ( i = 0 ; i < width ; i++ ) {
+		errorTable[1][i] = copy[0][i];	//[width-1-i];
+	}
+
+	for ( i = 0 ; i < height ; i++ ) {
+		errorTable[0][i] = copy[1][height-1-i];
+	}
+
+}
+#endif // _XBOX
+
+/*
+==================
+PutPointsOnCurve
+==================
+*/
+#ifdef _XBOX
+static void PutPointsOnCurve( drawVert_t* ctrl/*[MAX_GRID_SIZE][MAX_GRID_SIZE]*/, 
+							 int width, int height ) {
+	int			i, j;
+	drawVert_t	prev, next;
+
+	for ( i = 0 ; i < width ; i++ ) {
+		for ( j = 1 ; j < height ; j += 2 ) {
+			LerpDrawVert( &ctrl[j*MAX_GRID_SIZE+i], &ctrl[(j+1)*MAX_GRID_SIZE+i], &prev );
+			LerpDrawVert( &ctrl[j*MAX_GRID_SIZE+i], &ctrl[(j-1)*MAX_GRID_SIZE+i], &next );
+			LerpDrawVert( &prev, &next, &ctrl[j*MAX_GRID_SIZE+i] );
+		}
+	}
+
+
+	for ( j = 0 ; j < height ; j++ ) {
+		for ( i = 1 ; i < width ; i += 2 ) {
+			LerpDrawVert( &ctrl[j*MAX_GRID_SIZE+i], &ctrl[j*MAX_GRID_SIZE+i+1], &prev );
+			LerpDrawVert( &ctrl[j*MAX_GRID_SIZE+i], &ctrl[j*MAX_GRID_SIZE+i-1], &next );
+			LerpDrawVert( &prev, &next, &ctrl[j*MAX_GRID_SIZE+i] );
+		}
+	}
+}
+
+#else // _XBOX
+static void PutPointsOnCurve( drawVert_t	ctrl[MAX_GRID_SIZE][MAX_GRID_SIZE], 
+							 int width, int height ) {
+	int			i, j;
+	drawVert_t	prev, next;
+
+	for ( i = 0 ; i < width ; i++ ) {
+		for ( j = 1 ; j < height ; j += 2 ) {
+			LerpDrawVert( &ctrl[j][i], &ctrl[j+1][i], &prev );
+			LerpDrawVert( &ctrl[j][i], &ctrl[j-1][i], &next );
+			LerpDrawVert( &prev, &next, &ctrl[j][i] );
+		}
+	}
+
+
+	for ( j = 0 ; j < height ; j++ ) {
+		for ( i = 1 ; i < width ; i += 2 ) {
+			LerpDrawVert( &ctrl[j][i], &ctrl[j][i+1], &prev );
+			LerpDrawVert( &ctrl[j][i], &ctrl[j][i-1], &next );
+			LerpDrawVert( &prev, &next, &ctrl[j][i] );
+		}
+	}
+}
+#endif // _XBOX
+
+/*
+=================
+R_SubdividePatchToGrid
+
+=================
+*/
+#ifdef _XBOX
+srfGridMesh_t *R_SubdividePatchToGrid( int width, int height, drawVert_t* points,
+									   drawVert_t*	ctrl, float* errorTable ) {
+	int			i, j, k, l;
+	drawVert_t	prev, next, mid;
+	float		len, maxLen;
+	int			dir;
+	int			t;
+	srfGridMesh_t	*grid;
+	drawVert_t	*vert;
+	vec3_t		tmpVec;
+
+	for ( i = 0 ; i < width ; i++ ) {
+		for ( j = 0 ; j < height ; j++ ) {
+			ctrl[j*MAX_GRID_SIZE+i] = points[j*width+i];
+		}
+	}
+
+	for ( dir = 0 ; dir < 2 ; dir++ ) {
+
+		for ( j = 0 ; j < MAX_GRID_SIZE ; j++ ) {
+			errorTable[dir*MAX_GRID_SIZE+j] = 0;
+		}
+
+		// horizontal subdivisions
+		for ( j = 0 ; j + 2 < width ; j += 2 ) {
+			// check subdivided midpoints against control points
+			maxLen = 0;
+			for ( i = 0 ; i < height ; i++ ) {
+				vec3_t		midxyz;
+				vec3_t		dir;
+				vec3_t		projected;
+				float		d;
+
+				// calculate the point on the curve
+				for ( l = 0 ; l < 3 ; l++ ) {
+					midxyz[l] = (ctrl[i*MAX_GRID_SIZE+j].xyz[l] 
+							+ ctrl[i*MAX_GRID_SIZE+j+1].xyz[l] * 2
+							+ ctrl[i*MAX_GRID_SIZE+j+2].xyz[l] ) * 0.25;
+				}
+
+				// see how far off the line it is
+				// using dist-from-line will not account for internal
+				// texture warping, but it gives a lot less polygons than
+				// dist-from-midpoint
+				VectorSubtract( midxyz, ctrl[i*MAX_GRID_SIZE+j].xyz, midxyz );
+				VectorSubtract( ctrl[i*MAX_GRID_SIZE+j+2].xyz, ctrl[i*MAX_GRID_SIZE+j].xyz, dir );
+				VectorNormalize( dir );
+
+				d = DotProduct( midxyz, dir );
+				VectorScale( dir, d, projected );
+				VectorSubtract( midxyz, projected, midxyz);
+				len = VectorLengthSquared( midxyz );
+
+				if ( len > maxLen ) {
+					maxLen = len;
+				}
+			}
+			maxLen = sqrt(maxLen);
+
+			// if all the points are on the lines, remove the entire columns
+			if ( maxLen < 0.1 ) {
+				errorTable[dir*MAX_GRID_SIZE+j+1] = 999;
+				continue;
+			}
+
+			// see if we want to insert subdivided columns
+			if ( width + 2 > MAX_GRID_SIZE ) {
+				errorTable[dir*MAX_GRID_SIZE+j+1] = 1.0/maxLen;
+				continue;	// can't subdivide any more
+			}
+
+			if ( maxLen <= r_subdivisions->value ) {
+				errorTable[dir*MAX_GRID_SIZE+j+1] = 1.0/maxLen;
+				continue;	// didn't need subdivision
+			}
+
+			errorTable[dir*MAX_GRID_SIZE+j+2] = 1.0/maxLen;
+
+			// insert two columns and replace the peak
+			width += 2;
+			for ( i = 0 ; i < height ; i++ ) {
+				LerpDrawVert( &ctrl[i*MAX_GRID_SIZE+j], &ctrl[i*MAX_GRID_SIZE+j+1], &prev );
+				LerpDrawVert( &ctrl[i*MAX_GRID_SIZE+j+1], &ctrl[i*MAX_GRID_SIZE+j+2], &next );
+				LerpDrawVert( &prev, &next, &mid );
+
+				for ( k = width - 1 ; k > j + 3 ; k-- ) {
+					ctrl[i*MAX_GRID_SIZE+k] = ctrl[i*MAX_GRID_SIZE+k-2];
+				}
+				ctrl[i*MAX_GRID_SIZE+j + 1] = prev;
+				ctrl[i*MAX_GRID_SIZE+j + 2] = mid;
+				ctrl[i*MAX_GRID_SIZE+j + 3] = next;
+			}
+
+			// back up and recheck this set again, it may need more subdivision
+			j -= 2;
+
+		}
+
+		Transpose( width, height, ctrl );
+		t = width;
+		width = height;
+		height = t;
+	}
+
+
+	// put all the aproximating points on the curve
+	PutPointsOnCurve( ctrl, width, height );
+
+	// cull out any rows or columns that are colinear
+	for ( i = 1 ; i < width-1 ; i++ ) {
+		if ( errorTable[0*MAX_GRID_SIZE+i] != 999 ) {
+			continue;
+		}
+		for ( j = i+1 ; j < width ; j++ ) {
+			for ( k = 0 ; k < height ; k++ ) {
+				ctrl[k*MAX_GRID_SIZE+j-1] = ctrl[k*MAX_GRID_SIZE+j];
+			}
+			errorTable[0*MAX_GRID_SIZE+j-1] = errorTable[0*MAX_GRID_SIZE+j];
+		}
+		width--;
+	}
+
+	for ( i = 1 ; i < height-1 ; i++ ) {
+		if ( errorTable[1*MAX_GRID_SIZE+i] != 999 ) {
+			continue;
+		}
+		for ( j = i+1 ; j < height ; j++ ) {
+			for ( k = 0 ; k < width ; k++ ) {
+				ctrl[(j-1)*MAX_GRID_SIZE+k] = ctrl[j*MAX_GRID_SIZE+k];
+			}
+			errorTable[1*MAX_GRID_SIZE+j-1] = errorTable[1*MAX_GRID_SIZE+j];
+		}
+		height--;
+	}
+
+#if 1
+	// flip for longest tristrips as an optimization
+	// the results should be visually identical with or
+	// without this step
+	if ( height > width ) {
+		Transpose( width, height, ctrl );
+		InvertErrorTable( errorTable, width, height );
+		t = width;
+		width = height;
+		height = t;
+		InvertCtrl( width, height, ctrl );
+	}
+#endif
+
+	// calculate normals
+	MakeMeshNormals( width, height, ctrl );
+
+	// copy the results out to a grid
+	grid = (struct srfGridMesh_s *) Hunk_Alloc( (width * height - 1) * sizeof( drawVert_t ) + sizeof( *grid ) + width * 4 + height * 4, qtrue );
+
+	grid->widthLodError = (float*)(((char*)grid) + (width * height - 1) *
+		sizeof(drawVert_t) + sizeof(*grid));
+	memcpy( grid->widthLodError, &errorTable[0*MAX_GRID_SIZE], width * 4 );
+
+	grid->heightLodError = (float*)(((char*)grid->widthLodError) + width * 4);
+	memcpy( grid->heightLodError, &errorTable[1*MAX_GRID_SIZE], height * 4 );
+
+	grid->width = width;
+	grid->height = height;
+	grid->surfaceType = SF_GRID;
+	ClearBounds( grid->meshBounds[0], grid->meshBounds[1] );
+	for ( i = 0 ; i < width ; i++ ) {
+		for ( j = 0 ; j < height ; j++ ) {
+			vert = &grid->verts[j*width+i];
+			*vert = ctrl[j*MAX_GRID_SIZE+i];
+			AddPointToBounds( vert->xyz, grid->meshBounds[0], grid->meshBounds[1] );
+		}
+	}
+
+	// compute local origin and bounds
+	VectorAdd( grid->meshBounds[0], grid->meshBounds[1], grid->localOrigin );
+	VectorScale( grid->localOrigin, 0.5f, grid->localOrigin );
+	VectorSubtract( grid->meshBounds[0], grid->localOrigin, tmpVec );
+	grid->meshRadius = VectorLength( tmpVec );
+
+	VectorCopy( grid->localOrigin, grid->lodOrigin );
+	grid->lodRadius = grid->meshRadius;
+
+	return grid;
+}
+
+#else // _XBOX
+
+srfGridMesh_t *R_SubdividePatchToGrid( int width, int height,
+								drawVert_t points[MAX_PATCH_SIZE*MAX_PATCH_SIZE] ) {
+	int			i, j, k, l;
+	drawVert_t	prev, next, mid;
+	float		len, maxLen;
+	int			dir;
+	int			t;
+	MAC_STATIC drawVert_t	ctrl[MAX_GRID_SIZE][MAX_GRID_SIZE];
+	float		errorTable[2][MAX_GRID_SIZE];
+	srfGridMesh_t	*grid;
+	drawVert_t	*vert;
+	vec3_t		tmpVec;
+
+	for ( i = 0 ; i < width ; i++ ) {
+		for ( j = 0 ; j < height ; j++ ) {
+			ctrl[j][i] = points[j*width+i];
+		}
+	}
+
+	for ( dir = 0 ; dir < 2 ; dir++ ) {
+
+		for ( j = 0 ; j < MAX_GRID_SIZE ; j++ ) {
+			errorTable[dir][j] = 0;
+		}
+
+		// horizontal subdivisions
+		for ( j = 0 ; j + 2 < width ; j += 2 ) {
+			// check subdivided midpoints against control points
+			maxLen = 0;
+			for ( i = 0 ; i < height ; i++ ) {
+				vec3_t		midxyz;
+				vec3_t		dir;
+				vec3_t		projected;
+				float		d;
+
+				// calculate the point on the curve
+				for ( l = 0 ; l < 3 ; l++ ) {
+					midxyz[l] = (ctrl[i][j].xyz[l] + ctrl[i][j+1].xyz[l] * 2
+							+ ctrl[i][j+2].xyz[l] ) * 0.25;
+				}
+
+				// see how far off the line it is
+				// using dist-from-line will not account for internal
+				// texture warping, but it gives a lot less polygons than
+				// dist-from-midpoint
+				VectorSubtract( midxyz, ctrl[i][j].xyz, midxyz );
+				VectorSubtract( ctrl[i][j+2].xyz, ctrl[i][j].xyz, dir );
+				VectorNormalize( dir );
+
+				d = DotProduct( midxyz, dir );
+				VectorScale( dir, d, projected );
+				VectorSubtract( midxyz, projected, midxyz);
+				len = VectorLength( midxyz );
+
+				if ( len > maxLen ) {
+					maxLen = len;
+				}
+			}
+
+			// if all the points are on the lines, remove the entire columns
+			if ( maxLen < 0.1 ) {
+				errorTable[dir][j+1] = 999;
+				continue;
+			}
+
+			// see if we want to insert subdivided columns
+			if ( width + 2 > MAX_GRID_SIZE ) {
+				errorTable[dir][j+1] = 1.0/maxLen;
+				continue;	// can't subdivide any more
+			}
+
+			if ( maxLen <= r_subdivisions->value ) {
+				errorTable[dir][j+1] = 1.0/maxLen;
+				continue;	// didn't need subdivision
+			}
+
+			errorTable[dir][j+2] = 1.0/maxLen;
+
+			// insert two columns and replace the peak
+			width += 2;
+			for ( i = 0 ; i < height ; i++ ) {
+				LerpDrawVert( &ctrl[i][j], &ctrl[i][j+1], &prev );
+				LerpDrawVert( &ctrl[i][j+1], &ctrl[i][j+2], &next );
+				LerpDrawVert( &prev, &next, &mid );
+
+				for ( k = width - 1 ; k > j + 3 ; k-- ) {
+					ctrl[i][k] = ctrl[i][k-2];
+				}
+				ctrl[i][j + 1] = prev;
+				ctrl[i][j + 2] = mid;
+				ctrl[i][j + 3] = next;
+			}
+
+			// back up and recheck this set again, it may need more subdivision
+			j -= 2;
+
+		}
+
+		Transpose( width, height, ctrl );
+		t = width;
+		width = height;
+		height = t;
+	}
+
+
+	// put all the aproximating points on the curve
+	PutPointsOnCurve( ctrl, width, height );
+
+	// cull out any rows or columns that are colinear
+	for ( i = 1 ; i < width-1 ; i++ ) {
+		if ( errorTable[0][i] != 999 ) {
+			continue;
+		}
+		for ( j = i+1 ; j < width ; j++ ) {
+			for ( k = 0 ; k < height ; k++ ) {
+				ctrl[k][j-1] = ctrl[k][j];
+			}
+			errorTable[0][j-1] = errorTable[0][j];
+		}
+		width--;
+	}
+
+	for ( i = 1 ; i < height-1 ; i++ ) {
+		if ( errorTable[1][i] != 999 ) {
+			continue;
+		}
+		for ( j = i+1 ; j < height ; j++ ) {
+			for ( k = 0 ; k < width ; k++ ) {
+				ctrl[j-1][k] = ctrl[j][k];
+			}
+			errorTable[1][j-1] = errorTable[1][j];
+		}
+		height--;
+	}
+
+#if 1
+	// flip for longest tristrips as an optimization
+	// the results should be visually identical with or
+	// without this step
+	if ( height > width ) {
+		Transpose( width, height, ctrl );
+		InvertErrorTable( errorTable, width, height );
+		t = width;
+		width = height;
+		height = t;
+		InvertCtrl( width, height, ctrl );
+	}
+#endif
+
+	// calculate normals
+	MakeMeshNormals( width, height, ctrl );
+
+	// copy the results out to a grid
+	grid = (struct srfGridMesh_s *) Hunk_Alloc( (width * height - 1) * sizeof( drawVert_t ) + sizeof( *grid ), qtrue );
+
+	grid->widthLodError = (float *) Hunk_Alloc( width * 4, qfalse );
+	memcpy( grid->widthLodError, errorTable[0], width * 4 );
+
+	grid->heightLodError = (float *) Hunk_Alloc( height * 4, qfalse );
+	memcpy( grid->heightLodError, errorTable[1], height * 4 );
+
+	grid->width = width;
+	grid->height = height;
+	grid->surfaceType = SF_GRID;
+	ClearBounds( grid->meshBounds[0], grid->meshBounds[1] );
+	for ( i = 0 ; i < width ; i++ ) {
+		for ( j = 0 ; j < height ; j++ ) {
+			vert = &grid->verts[j*width+i];
+			*vert = ctrl[j][i];
+			AddPointToBounds( vert->xyz, grid->meshBounds[0], grid->meshBounds[1] );
+		}
+	}
+
+	// compute local origin and bounds
+	VectorAdd( grid->meshBounds[0], grid->meshBounds[1], grid->localOrigin );
+	VectorScale( grid->localOrigin, 0.5f, grid->localOrigin );
+	VectorSubtract( grid->meshBounds[0], grid->localOrigin, tmpVec );
+	grid->meshRadius = VectorLength( tmpVec );
+
+	VectorCopy( grid->localOrigin, grid->lodOrigin );
+	grid->lodRadius = grid->meshRadius;
+
+	return grid;
+}
+#endif // _XBOX
diff --git a/code/renderer/tr_draw.cpp b/code/renderer/tr_draw.cpp
new file mode 100644
index 0000000..ea574a2
--- /dev/null
+++ b/code/renderer/tr_draw.cpp
@@ -0,0 +1,1124 @@
+// tr_draw.c
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+
+#include "tr_local.h"
+
+
+
+/*
+=============
+RE_StretchRaw
+
+Stretches a raw 32 bit power of 2 bitmap image over the given screen rectangle.
+Used for cinematics.
+=============
+*/
+
+// param 'bDirty' should be true 99% of the time
+void RE_StretchRaw (int x, int y, int w, int h, int cols, int rows, const byte *data, int iClient, qboolean bDirty ) 
+{
+	R_SyncRenderThread();
+
+//===========
+	// Q3Final added this:
+	// we definately want to sync every frame for the cinematics
+	//qglFinish();
+
+#ifdef TIMEBIND
+	int start, end;
+	start = end = 0;	// only to stop compiler whining, don't need to be initialised
+#endif
+	// make sure rows and cols are powers of 2
+	if ( (cols&(cols-1)) || (rows&(rows-1)) )
+	{
+		Com_Error (ERR_DROP, "Draw_StretchRaw: size not a power of 2: %i by %i", cols, rows);
+	}
+
+	GL_Bind( tr.scratchImage[iClient] );
+
+	// if the scratchImage isn't in the format we want, specify it as a new texture...
+	//
+	if ( cols != tr.scratchImage[iClient]->width || rows != tr.scratchImage[iClient]->height ) 
+	{
+		tr.scratchImage[iClient]->width = cols;
+		tr.scratchImage[iClient]->height = rows;
+#ifdef TIMEBIND
+		if ( r_ignore->integer ) 
+		{
+			start = Sys_Milliseconds();
+		}
+#endif
+
+		qglTexImage2D( GL_TEXTURE_2D, 0, GL_RGB8, cols, rows, 0, GL_RGBA, GL_UNSIGNED_BYTE, data );
+		
+		qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
+		qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
+		qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP );
+		qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP );
+
+#ifdef TIMEBIND
+		if ( r_ignore->integer ) 
+		{
+			end = Sys_Milliseconds();
+			VID_Printf( PRINT_ALL, "qglTexImage2D %i, %i: %i msec\n", cols, rows, end - start );
+		}
+#endif
+	} 
+	else 
+	{	
+		if (bDirty)	// FIXME: some TA addition or other, not sure why, yet. Should probably be true 99% of the time?
+		{
+			// otherwise, just subimage upload it so that drivers can tell we are going to be changing
+			// it and don't try and do a texture compression
+
+	#ifdef TIMEBIND
+			if ( r_ignore->integer ) 
+			{
+				start = Sys_Milliseconds();
+			}
+	#endif
+
+			qglTexSubImage2D( GL_TEXTURE_2D, 0, 0, 0, cols, rows, GL_RGBA, GL_UNSIGNED_BYTE, data );				
+
+	#ifdef TIMEBIND
+			if ( r_ignore->integer ) 
+			{
+				end = Sys_Milliseconds();
+				VID_Printf( PRINT_ALL, "qglTexSubImage2D %i, %i: %i msec\n", cols, rows, end - start );
+			}
+	#endif
+		}
+	}
+
+
+	extern void	RB_SetGL2D (void);
+	if (!backEnd.projection2D)
+	{
+		RB_SetGL2D();	
+	}
+	qglColor3f( tr.identityLight, tr.identityLight, tr.identityLight );
+
+#ifdef _XBOX
+	qglBeginEXT (GL_TRIANGLE_STRIP, 4, 0, 0, 4, 0);//, 0, 0);
+	qglTexCoord2f ( 0.5 / cols,  0.5 / rows );
+	qglVertex2f (x, y);
+	qglTexCoord2f ( ( cols - 0.5 ) / cols ,  0.5 / rows );
+	qglVertex2f (x+w, y);
+	qglTexCoord2f ( 0.5 / cols, ( rows - 0.5 ) / rows );
+	qglVertex2f (x, y+h);
+	qglTexCoord2f ( ( cols - 0.5 ) / cols, ( rows - 0.5 ) / rows );
+	qglVertex2f (x+w, y+h);
+	qglEnd ();
+#else
+	qglBegin (GL_QUADS);
+	qglTexCoord2f ( 0.5 / cols,  0.5 / rows );
+	qglVertex2f (x, y);
+	qglTexCoord2f ( ( cols - 0.5 ) / cols ,  0.5 / rows );
+	qglVertex2f (x+w, y);
+	qglTexCoord2f ( ( cols - 0.5 ) / cols, ( rows - 0.5 ) / rows );
+	qglVertex2f (x+w, y+h);
+	qglTexCoord2f ( 0.5 / cols, ( rows - 0.5 ) / rows );
+	qglVertex2f (x, y+h);
+	qglEnd ();
+#endif
+}
+
+
+
+void RE_UploadCinematic (int cols, int rows, const byte *data, int client, qboolean dirty) {
+
+	GL_Bind( tr.scratchImage[client] );
+
+	// if the scratchImage isn't in the format we want, specify it as a new texture
+	if ( cols != tr.scratchImage[client]->width || rows != tr.scratchImage[client]->height ) {
+		tr.scratchImage[client]->width = cols;
+		tr.scratchImage[client]->height = rows;
+#ifdef _XBOX
+		qglTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA8, cols, rows, 0, GL_LIN_RGBA, GL_UNSIGNED_BYTE, data );
+#else
+		qglTexImage2D( GL_TEXTURE_2D, 0, GL_RGB8, cols, rows, 0, GL_RGBA, GL_UNSIGNED_BYTE, data );
+#endif
+
+		qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
+		qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
+		qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP );
+		qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP );
+	} else {
+		if (dirty) {
+			// otherwise, just subimage upload it so that drivers can tell we are going to be changing
+			// it and don't try and do a texture compression
+			qglTexSubImage2D( GL_TEXTURE_2D, 0, 0, 0, cols, rows, GL_RGBA, GL_UNSIGNED_BYTE, data );
+		}
+	}
+}
+
+
+
+#if 0
+void RE_GetScreenShot(byte *data, int w, int h)
+{
+	byte		*buffer;
+	int			offset;
+	int			x, y;
+	int			xc, yc;
+	int			xstep, ystep;
+	int			count = 0;
+
+	buffer = (byte *)R_Malloc(glConfig.vidWidth * glConfig.vidHeight * 3);
+	if(!buffer)
+	{
+		return;
+	}
+	qglReadPixels (0, 0, glConfig.vidWidth, glConfig.vidHeight, GL_RGB, GL_UNSIGNED_BYTE, buffer ); 
+	
+	xstep = (glConfig.vidWidth << 16) / w;
+	ystep = (glConfig.vidHeight << 16) / h;
+	yc = 0;
+	for(y = 0; y < h; y++, yc += ystep)
+	{
+		xc = 0;
+		for(x = 0; x < w; x++, xc += xstep)
+		{
+			offset = ((glConfig.vidWidth * (yc >> 16)) + (xc >> 16)) * 3;
+			*data++ = buffer[offset++];
+			*data++ = buffer[offset++];
+			*data++ = buffer[offset++];
+			*data++ = 0xff;
+			count++;
+		}
+	}
+	assert(count == w * h);
+	R_Free(buffer);
+}
+
+#else
+
+void RE_GetScreenShot(byte *buffer, int w, int h)
+{
+#ifndef _XBOX
+	byte		*source;
+	byte		*src, *dst;
+	int			x, y;
+	int			r, g, b;
+	float		xScale, yScale;
+	int			xx, yy;
+
+    qglFinish();	// try and fix broken Radeon cards (7500 & 8500) that don't read screen pixels properly
+
+	source = (byte *)Z_Malloc(glConfig.vidWidth * glConfig.vidHeight * 3, TAG_TEMP_WORKSPACE, qfalse);
+	if(!source)
+	{
+		return;
+	}
+	qglReadPixels (0, 0, glConfig.vidWidth, glConfig.vidHeight, GL_RGB, GL_UNSIGNED_BYTE, source ); 
+	
+	assert (w == h);
+	int count = 0;
+	// resample from source
+	xScale = glConfig.vidWidth / (4.0 * w);
+	yScale = glConfig.vidHeight / (3.0 * w);
+	for ( y = 0 ; y < w ; y++ ) {
+		for ( x = 0 ; x < w ; x++ ) {
+			r = g = b = 0;
+			for ( yy = 0 ; yy < 3 ; yy++ ) {
+				for ( xx = 0 ; xx < 4 ; xx++ ) {
+					src = source + 3 * ( glConfig.vidWidth * (int)( (y*3+yy)*yScale ) + (int)( (x*4+xx)*xScale ) );
+					r += src[0];
+					g += src[1];
+					b += src[2];
+				}
+			}
+			dst = buffer + 4 * ( y * w + x );
+			dst[0] = r / 12;
+			dst[1] = g / 12;
+			dst[2] = b / 12;
+			count++;
+		}
+	}
+
+	assert(count == w * h);
+	Z_Free(source);
+#endif
+}
+
+#endif
+
+
+
+
+// this is just a chunk of code from RE_TempRawImage_ReadFromFile() below, subroutinised so I can call it
+//	from the screen dissolve code as well...
+//
+static byte *RE_ReSample(byte *pbLoadedPic,			int iLoadedWidth,	int iLoadedHeight,
+						 byte *pbReSampleBuffer,	int *piWidth,		int *piHeight
+						)
+{
+	byte *pbReturn = NULL;
+
+	// if not resampling, just return some values and return...
+	//
+	if ( pbReSampleBuffer == NULL || (iLoadedWidth == *piWidth && iLoadedHeight == *piHeight) )
+	{
+		// if not resampling, we're done, just return the loaded size...
+		//
+		*piWidth = iLoadedWidth;
+		*piHeight= iLoadedHeight;
+		pbReturn = pbLoadedPic;
+	}
+	else
+	{
+		// resample from pbLoadedPic to pbReSampledBuffer...
+		//
+		float	fXStep = (float)iLoadedWidth / (float)*piWidth;
+		float	fYStep = (float)iLoadedHeight/ (float)*piHeight;
+		int		iTotPixelsPerDownSample = (int)ceil(fXStep) * (int)ceil(fYStep);
+
+		int 	r,g,b;
+
+		byte	*pbDst = pbReSampleBuffer;
+
+		for ( int y=0; y<*piHeight; y++ )
+		{
+			for ( int x=0; x<*piWidth; x++ )
+			{
+				r=g=b=0;
+
+				for ( float yy = (float)y*fYStep; yy < (float)(y+1)*fYStep ; yy+=1 )
+				{
+					for ( float xx = (float)x*fXStep; xx < (float)(x+1)*fXStep ; xx+=1 )
+					{
+						byte *pbSrc = pbLoadedPic + 4 * ( ((int)yy * iLoadedWidth) + (int)xx );
+
+						assert(pbSrc < pbLoadedPic + (iLoadedWidth * iLoadedHeight * 4) );
+
+						r += pbSrc[0];
+						g += pbSrc[1];
+						b += pbSrc[2];
+					}
+				}
+				
+				assert(pbDst < pbReSampleBuffer + (*piWidth * *piHeight * 4));
+
+				pbDst[0] = r / iTotPixelsPerDownSample;
+				pbDst[1] = g / iTotPixelsPerDownSample;
+				pbDst[2] = b / iTotPixelsPerDownSample;
+				pbDst[3] = 255;
+				pbDst += 4;
+			}
+		}
+
+		// set return value...
+		//
+		pbReturn = pbReSampleBuffer;
+	}
+
+	return pbReturn;
+}
+
+
+// this is so the server (or anyone else) can get access to raw pixels if they really need to, 
+//	currently it's only used by the server so that savegames can embed a graphic in the auto-save files
+//	(which can't do a screenshot since they're saved out before the level is drawn).
+//
+// by default, the pic will be returned as the original dims, but if pbReSampleBuffer != NULL then it's assumed to
+//	be a big enough buffer to hold the resampled image, which also means that the width and height params are read as 
+//	inputs (as well as still being inherently outputs) and the pic is scaled to that size, and to that buffer.
+//
+// the return value is either NULL, or a pointer to the pixels to use (which may be either the pbReSampleBuffer param,
+//	or the local ptr below).
+//
+// In either case, you MUST call the free-up function afterwards ( RE_TempRawImage_CleanUp() ) to get rid of any temp
+//	memory after you've finished with the pic.
+//
+// Note: ALWAYS use the return value if != NULL, even if you passed in a declared resample buffer. This is because the
+//	resample will get skipped if the values you want are the same size as the pic that it loaded, so it'll return a 
+//	different buffer.
+//
+// the vertflip param is used for those functions that expect things in OpenGL's upside-down pixel-read format (sigh)
+//
+// (not brilliantly fast, but it's only used for weird stuff anyway)
+//
+byte* pbLoadedPic = NULL;
+
+#ifndef _XBOX
+byte* RE_TempRawImage_ReadFromFile(const char *psLocalFilename, int *piWidth, int *piHeight, byte *pbReSampleBuffer, qboolean qbVertFlip)
+{
+	RE_TempRawImage_CleanUp();	// jic
+
+	byte *pbReturn = NULL;
+
+	if (psLocalFilename && piWidth && piHeight)
+	{
+		int	 iLoadedWidth, iLoadedHeight;
+
+		GLenum format;	// VVFIXME
+		R_LoadImage( psLocalFilename, &pbLoadedPic, &iLoadedWidth, &iLoadedHeight, &format);
+		if ( pbLoadedPic )
+		{
+			pbReturn = RE_ReSample(	pbLoadedPic,		iLoadedWidth,	iLoadedHeight,
+									pbReSampleBuffer,	piWidth,		piHeight);
+		}
+	}
+
+	if (pbReturn && qbVertFlip)
+	{			
+		unsigned long *pSrcLine = (unsigned long *) pbReturn;
+		unsigned long *pDstLine = (unsigned long *) pbReturn + (*piHeight * *piWidth );	// *4 done by compiler (longs)		
+					   pDstLine-= *piWidth;	// point at start of last line, not first after buffer
+
+		for (int iLineCount=0; iLineCount<*piHeight/2; iLineCount++)
+		{
+			for (int x=0; x<*piWidth; x++)
+			{
+				unsigned long l = pSrcLine[x];
+				pSrcLine[x] = pDstLine[x];
+				pDstLine[x] = l;
+			}
+			pSrcLine += *piWidth;
+			pDstLine -= *piWidth;
+		}
+	}
+
+	return pbReturn;
+}
+#endif // _XBOX
+
+void RE_TempRawImage_CleanUp(void)
+{
+	if ( pbLoadedPic )
+	{
+		Z_Free( pbLoadedPic );
+		pbLoadedPic = NULL;
+	}
+}
+
+
+
+typedef enum
+{
+	eDISSOLVE_RT_TO_LT = 0,
+	eDISSOLVE_LT_TO_RT,
+	eDISSOLVE_TP_TO_BT,
+	eDISSOLVE_BT_TO_TP,
+	eDISSOLVE_CIRCULAR_OUT,	// new image comes out from centre
+	//
+	eDISSOLVE_RAND_LIMIT,	// label only, not valid to select	
+	//
+	// any others...
+	//
+	eDISSOLVE_CIRCULAR_IN,	// new image comes in from edges
+	//
+	eDISSOLVE_NUMBEROF
+
+} Dissolve_e;
+
+typedef struct
+{
+	int			iWidth;
+	int			iHeight;
+	int			iUploadWidth;
+	int			iUploadHeight;
+	int			iScratchPadNumber;
+	image_t		*pImage;	// old image screen
+	image_t		*pDissolve;	// fuzzy thing
+	image_t		*pBlack;	// small black image for clearing
+	int			iStartTime;	// 0 = not processing
+	Dissolve_e	eDissolveType;	
+	qboolean	bTouchNeeded;
+
+} Dissolve_t;
+
+static int PowerOf2(int iArg)
+{
+	if ( (iArg & (iArg-1)) != 0)
+	{
+		int iShift=0;
+		while (iArg)
+		{
+			iArg>>=1;
+			iShift++;
+		}
+
+		iArg = 1<<iShift;
+	}
+
+	return iArg;
+}
+
+Dissolve_t Dissolve={0};
+#define fDISSOLVE_SECONDS 0.75f
+
+// leave the UV stuff in for now as comments in case I ever need to do some sneaky stuff, but for now...
+//
+static void RE_Blit(float fX0, float fY0, float fX1, float fY1, float fX2, float fY2, float fX3, float fY3,
+					//float fU0, float fV0, float fU1, float fV1, float fU2, float fV2, float fU3, float fV3,
+					image_t *pImage, int iGLState
+					)
+{		
+	//
+	// some junk they had at the top of other StretchRaw code...
+	//
+	R_SyncRenderThread();
+//#ifndef _XBOX
+//	qglFinish();
+//#endif // _XBOX
+
+	GL_Bind( pImage );
+	GL_State(iGLState);
+	GL_Cull( CT_TWO_SIDED ) ;
+
+	qglColor3f( 1.0f, 1.0f, 1.0f );
+
+#ifdef _XBOX
+	qglBeginEXT(GL_QUADS,4,0,0,4,0);
+#else
+	qglBegin (GL_QUADS);
+#endif // _XBOX
+	{
+		// TL...
+		//
+//		qglTexCoord2f( fU0 / (float)pImage->width,  fV0 / (float)pImage->height );
+		qglTexCoord2f( 0,0 );
+		qglVertex2f( fX0, fY0 );
+
+		// TR...
+		//
+//		qglTexCoord2f( fU1 / (float)pImage->width,  fV1 / (float)pImage->height );
+		qglTexCoord2f( 1,0 );
+		qglVertex2f( fX1, fY1 );
+
+		// BR...
+		//
+//		qglTexCoord2f( fU2 / (float)pImage->width,  fV2 / (float)pImage->height );
+		qglTexCoord2f( 1,1 );
+		qglVertex2f( fX2, fY2);
+
+		// BL...
+		//
+//		qglTexCoord2f( fU3 / (float)pImage->width,  fV3 / (float)pImage->height );
+		qglTexCoord2f( 0,1 );
+		qglVertex2f( fX3, fY3);
+	}
+	qglEnd ();
+}
+
+static void RE_KillDissolve(void)
+{
+	Dissolve.iStartTime = 0;
+
+	if (Dissolve.pImage)
+	{
+		R_Images_DeleteImage(	Dissolve.pImage );
+								Dissolve.pImage = NULL;
+	}
+}
+// Draw the dissolve pic to the screen, over the top of what's already been rendered.
+//
+// return = qtrue while still processing, for those interested...
+//
+#define iSAFETY_SPRITE_OVERLAP 2	// #pixels to overlap blit region by, in case some drivers leave onscreen seams
+qboolean RE_ProcessDissolve(void)
+{
+	if (Dissolve.iStartTime)
+	{
+		if (Dissolve.bTouchNeeded)
+		{
+			// Stuff to avoid music stutter...
+			//
+			//	The problem is, that if I call RE_InitDissolve() then call RestartMusic, then by the time the music
+			//	has loaded in if it took longer than one second the dissolve would think that it had finished,
+			//	even if it had never actually drawn up. However, if I called RE_InitDissolve() AFTER the music had
+			//	restarted, then the music would stutter on slow video cards or CPUs while I did the binding/resampling.
+			//
+			// This way, I restart the millisecond counter the first time we actually get as far as rendering, which
+			//	should let things work properly...
+			//
+			Dissolve.bTouchNeeded = qfalse;
+			Dissolve.iStartTime = Sys_Milliseconds();
+		}
+		
+		int iDissolvePercentage = ((Sys_Milliseconds() - Dissolve.iStartTime)*100) / (1000.0f * fDISSOLVE_SECONDS);
+
+//		VID_Printf(PRINT_ALL,"iDissolvePercentage %d\n",iDissolvePercentage);
+
+		if (iDissolvePercentage <= 100)
+		{
+			extern void	RB_SetGL2D (void);
+			RB_SetGL2D();			
+
+//			GLdouble glD;
+//			qglGetDoublev(GL_DEPTH_CLEAR_VALUE,&glD);
+//			qglClearColor(0,0,0,1);
+			qglClearDepth(1.0f);
+			qglClear( GL_DEPTH_BUFFER_BIT );
+			
+
+			float fXScaleFactor = (float)SCREEN_WIDTH / (float)Dissolve.iWidth;
+			float fYScaleFactor = (float)SCREEN_HEIGHT/ (float)Dissolve.iHeight;
+			float x0,y0, x1,y1,	x2,y2, x3,y3;	
+
+			switch (Dissolve.eDissolveType)
+			{
+				case eDISSOLVE_RT_TO_LT:
+				{
+					float fXboundary = (float) Dissolve.iWidth - (((float)(Dissolve.iWidth+Dissolve.pDissolve->width)*(float)iDissolvePercentage)/100.0f);
+
+					// blit the fuzzy-dissolve sprite...
+					//
+					x0 = fXScaleFactor * fXboundary;
+					y0 = 0.0f;
+					x1 = fXScaleFactor * (fXboundary + Dissolve.pDissolve->width);
+					y1 = 0.0f;
+					x2 = x1;
+					y2 = fYScaleFactor * Dissolve.iHeight;
+					x3 = x0;
+					y3 = y2;
+
+					RE_Blit(x0,y0,x1,y1,x2,y2,x3,y3, Dissolve.pDissolve, GLS_DEPTHMASK_TRUE | GLS_SRCBLEND_ZERO | GLS_DSTBLEND_ONE | GLS_ATEST_LT_80);
+
+					// blit a blank thing over the area the old screen is to be displayed on to enable screen-writing...
+					// (to the left of fXboundary)
+					//
+					x0 = 0.0f;
+					y0 = 0.0f;
+					x1 = fXScaleFactor * (fXboundary + iSAFETY_SPRITE_OVERLAP);
+					y1 = 0.0f;
+					x2 = x1;
+					y2 = fYScaleFactor * Dissolve.iHeight;
+					x3 = x0;
+					y3 = y2;
+					RE_Blit(x0,y0,x1,y1,x2,y2,x3,y3, Dissolve.pBlack, GLS_DEPTHMASK_TRUE | GLS_SRCBLEND_ZERO | GLS_DSTBLEND_ONE);
+				}
+				break;
+
+				case eDISSOLVE_LT_TO_RT:
+				{
+					float fXboundary = (((float)(Dissolve.iWidth+(2*Dissolve.pDissolve->width))*(float)iDissolvePercentage)/100.0f) - Dissolve.pDissolve->width;
+
+					// blit the fuzzy-dissolve sprite...
+					//
+					x0 = fXScaleFactor * (fXboundary + Dissolve.pDissolve->width);						
+					y0 = 0.0f;
+					x1 = fXScaleFactor * fXboundary;
+					y1 = 0.0f;
+					x2 = x1;
+					y2 = fYScaleFactor * Dissolve.iHeight;
+					x3 = x0;
+					y3 = y2;
+
+					RE_Blit(x0,y0,x1,y1,x2,y2,x3,y3, Dissolve.pDissolve, GLS_DEPTHMASK_TRUE | GLS_SRCBLEND_ZERO | GLS_DSTBLEND_ONE | GLS_ATEST_LT_80);
+
+					// blit a blank thing over the area the old screen is to be displayed on to enable screen-writing...
+					// (to the right of fXboundary)
+					//
+					x0 = fXScaleFactor * (( fXboundary + Dissolve.pDissolve->width) - iSAFETY_SPRITE_OVERLAP);
+					y0 = 0.0f;
+					x1 = fXScaleFactor * Dissolve.iWidth;
+					y0 = 0.0f;
+					x2 = x1;
+					y2 = fYScaleFactor * Dissolve.iHeight;
+					x3 = x0;
+					y3 = y2;
+					RE_Blit(x0,y0,x1,y1,x2,y2,x3,y3, Dissolve.pBlack, GLS_DEPTHMASK_TRUE | GLS_SRCBLEND_ZERO | GLS_DSTBLEND_ONE);
+				}
+				break;
+
+				case eDISSOLVE_TP_TO_BT:
+				{
+					float fYboundary = (((float)(Dissolve.iHeight+(2*Dissolve.pDissolve->width))*(float)iDissolvePercentage)/100.0f) - Dissolve.pDissolve->width;
+
+					// blit the fuzzy-dissolve sprite...
+					//
+					x0 = 0.0f;
+					y0 = fYScaleFactor * (fYboundary + Dissolve.pDissolve->width);
+					x1 = x0;
+					y1 = fYScaleFactor * fYboundary;
+					x2 = fXScaleFactor * Dissolve.iWidth;
+					y2 = y1;
+					x3 = x2;
+					y3 = y0;
+
+					RE_Blit(x0,y0,x1,y1,x2,y2,x3,y3, Dissolve.pDissolve, GLS_DEPTHMASK_TRUE | GLS_SRCBLEND_ZERO | GLS_DSTBLEND_ONE | GLS_ATEST_LT_80);
+
+					// blit a blank thing over the area the old screen is to be displayed on to enable screen-writing...
+					// (underneath fYboundary)
+					//
+					x0 = 0.0f;
+					y0 = fYScaleFactor * ( (fYboundary + Dissolve.pDissolve->width) - iSAFETY_SPRITE_OVERLAP);					
+					x1 = fXScaleFactor * Dissolve.iWidth;
+					y1 = y0;
+					x2 = x1;
+					y2 = fYScaleFactor * Dissolve.iHeight;
+					x3 = x0;
+					y3 = y2;
+					RE_Blit(x0,y0,x1,y1,x2,y2,x3,y3, Dissolve.pBlack, GLS_DEPTHMASK_TRUE | GLS_SRCBLEND_ZERO | GLS_DSTBLEND_ONE);
+				}
+				break;
+
+				case eDISSOLVE_BT_TO_TP:
+				{
+					float fYboundary = Dissolve.iHeight - (((float)(Dissolve.iHeight+Dissolve.pDissolve->width)*(float)iDissolvePercentage)/100.0f);
+
+					// blit the fuzzy-dissolve sprite...
+					//
+					x0 = 0.0f;
+					y0 = fYScaleFactor * fYboundary; 						
+					x1 = x0;
+					y1 = fYScaleFactor * (fYboundary + Dissolve.pDissolve->width);					
+					x2 = fXScaleFactor * Dissolve.iWidth;
+					y2 = y1;
+					x3 = x2;
+					y3 = y0;
+
+					RE_Blit(x0,y0,x1,y1,x2,y2,x3,y3, Dissolve.pDissolve, GLS_DEPTHMASK_TRUE | GLS_SRCBLEND_ZERO | GLS_DSTBLEND_ONE | GLS_ATEST_LT_80);
+
+					// blit a blank thing over the area the old screen is to be displayed on to enable screen-writing...
+					// (above fYboundary)
+					//
+					x0 = 0.0f;
+					y0 = 0.0f;
+					x1 = fXScaleFactor * Dissolve.iWidth;
+					y1 = y0;
+					x2 = x1;
+					y2 = fYScaleFactor * (fYboundary + iSAFETY_SPRITE_OVERLAP);					
+					x3 = x0;
+					y3 = y2;
+					RE_Blit(x0,y0,x1,y1,x2,y2,x3,y3, Dissolve.pBlack, GLS_DEPTHMASK_TRUE | GLS_SRCBLEND_ZERO | GLS_DSTBLEND_ONE);
+				}
+				break;
+
+				case eDISSOLVE_CIRCULAR_IN:
+				{
+					float fDiagZoom = ( ((float)Dissolve.iWidth*0.8) * (100-iDissolvePercentage))/100.0f;
+
+					//
+					// blit circular graphic...
+					//
+					x0 = fXScaleFactor * ((Dissolve.iWidth/2) - fDiagZoom);
+					y0 = fYScaleFactor * ((Dissolve.iHeight/2)- fDiagZoom);
+					x1 = fXScaleFactor * ((Dissolve.iWidth/2) + fDiagZoom);
+					y1 = y0;
+					x2 = x1;
+					y2 = fYScaleFactor * ((Dissolve.iHeight/2)+ fDiagZoom);
+					x3 = x0;
+					y3 = y2;
+
+					RE_Blit(x0,y0,x1,y1,x2,y2,x3,y3, Dissolve.pDissolve, GLS_DEPTHMASK_TRUE | GLS_SRCBLEND_ZERO | GLS_DSTBLEND_ONE | GLS_ATEST_LT_80);
+				}
+				break;
+
+				case eDISSOLVE_CIRCULAR_OUT:
+				{
+					float fDiagZoom = ( ((float)Dissolve.iWidth*0.8) * iDissolvePercentage)/100.0f;
+
+					//
+					// blit circular graphic...
+					//
+					x0 = fXScaleFactor * ((Dissolve.iWidth/2) - fDiagZoom);
+					y0 = fYScaleFactor * ((Dissolve.iHeight/2)- fDiagZoom);
+					x1 = fXScaleFactor * ((Dissolve.iWidth/2) + fDiagZoom);
+					y1 = y0;
+					x2 = x1;
+					y2 = fYScaleFactor * ((Dissolve.iHeight/2)+ fDiagZoom);
+					x3 = x0;
+					y3 = y2;
+
+					RE_Blit(x0,y0,x1,y1,x2,y2,x3,y3, Dissolve.pDissolve, GLS_DEPTHMASK_TRUE | GLS_SRCBLEND_ZERO | GLS_DSTBLEND_ONE | GLS_ATEST_LT_80);
+					// now blit the 4 black squares around it to mask off the rest of the screen...
+					//
+					// LHS, top to bottom...
+					//
+					RE_Blit(0,0,								// x0,y0
+							x0+iSAFETY_SPRITE_OVERLAP,0,		// x1,y1
+							x0+iSAFETY_SPRITE_OVERLAP,(fYScaleFactor * Dissolve.iHeight),// x2,y2
+							0,(fYScaleFactor * Dissolve.iHeight),	// x3,y3, 
+							Dissolve.pBlack, GLS_DEPTHMASK_TRUE | GLS_SRCBLEND_ZERO | GLS_DSTBLEND_ONE
+							);
+
+					// RHS top to bottom...
+					//
+					RE_Blit(x1-iSAFETY_SPRITE_OVERLAP,0,		// x0,y0
+							(fXScaleFactor * Dissolve.iWidth),0,	// x1,y1
+							(fXScaleFactor * Dissolve.iWidth),(fYScaleFactor * Dissolve.iHeight),// x2,y2
+							x1-iSAFETY_SPRITE_OVERLAP,(fYScaleFactor * Dissolve.iHeight),	// x3,y3, 
+							Dissolve.pBlack, GLS_DEPTHMASK_TRUE | GLS_SRCBLEND_ZERO | GLS_DSTBLEND_ONE
+							);
+
+					// top...
+					//
+					RE_Blit(x0-iSAFETY_SPRITE_OVERLAP,0,		// x0,y0
+							x1+iSAFETY_SPRITE_OVERLAP,0,		// x1,y1
+							x1+iSAFETY_SPRITE_OVERLAP,y0 + iSAFETY_SPRITE_OVERLAP,	// x2,y2
+							x0-iSAFETY_SPRITE_OVERLAP,y0 + iSAFETY_SPRITE_OVERLAP,	// x3,y3
+							Dissolve.pBlack, GLS_DEPTHMASK_TRUE | GLS_SRCBLEND_ZERO | GLS_DSTBLEND_ONE
+							);
+
+					// bottom...
+					//
+					RE_Blit(x0-iSAFETY_SPRITE_OVERLAP,y3-iSAFETY_SPRITE_OVERLAP,	// x0,y0
+							x1+iSAFETY_SPRITE_OVERLAP,y2-iSAFETY_SPRITE_OVERLAP,		// x1,y1
+							x1+iSAFETY_SPRITE_OVERLAP,(fYScaleFactor * Dissolve.iHeight),	// x2,y2
+							x0-iSAFETY_SPRITE_OVERLAP,(fYScaleFactor * Dissolve.iHeight),	// x3,y3
+							Dissolve.pBlack, GLS_DEPTHMASK_TRUE | GLS_SRCBLEND_ZERO | GLS_DSTBLEND_ONE
+							);
+				}
+				break;
+
+				default:
+				{
+					assert(0);
+					iDissolvePercentage = 101;	// force a dissolve-kill
+					break;
+				}
+			}
+
+			// re-check in case we hit the default case above...
+			//
+			if (iDissolvePercentage <= 100)
+			{
+				// still dissolving, so now (finally), blit old image over top...
+				//
+				x0 = 0.0f;
+				y0 = 0.0f;
+#ifdef _XBOX
+				x1 = 640;
+#else
+				x1 = fXScaleFactor * Dissolve.pImage->width;
+#endif
+				y1 = y0;
+				x2 = x1;
+#ifdef _XBOX
+				y2 = 480;
+#else
+				y2 = fYScaleFactor * Dissolve.pImage->height;
+#endif
+				x3 = x0;
+				y3 = y2;
+
+				RE_Blit(x0,y0,x1,y1,x2,y2,x3,y3, Dissolve.pImage,GLS_DEPTHFUNC_EQUAL);
+			}
+		}
+
+		if (iDissolvePercentage > 100)
+		{
+			RE_KillDissolve();
+		}
+	}
+
+	return qfalse;
+}
+
+#ifdef _XBOX
+
+/**********
+RE_GetCompressedBackbuffer
+Creates a 256x256 DXT1 texture that contains the backbuffer
+**********/
+static void RE_GetCompressedBackbuffer()
+{
+	byte*	data = (byte*)Z_Malloc(32768,TAG_TEMP_WORKSPACE,qtrue);
+
+	Dissolve.pImage = R_CreateImage(	"*DissolveImage",		// const char *name
+										data,					// const byte *pic
+										256,					// int width
+										256,					// int height
+										GL_COMPRESSED_RGB_S3TC_DXT1_EXT,
+										qfalse,					// qboolean mipmap
+										qfalse,					// qboolean allowPicmip
+										GL_CLAMP				// int glWrapClampMode
+										);
+	Z_Free(data);
+
+	GL_Bind(Dissolve.pImage);
+
+	qglCopyBackBufferToTexEXT(256.0f, 256.0f, 0.0f, 0.0f, 640.0f, 480.0f);
+}
+#endif
+
+// return = qtrue(success) else fail, for those interested...
+//
+qboolean RE_InitDissolve(qboolean bForceCircularExtroWipe)
+{
+	R_SyncRenderThread();
+
+//	VID_Printf( PRINT_ALL, "RE_InitDissolve()\n");
+	qboolean bReturn = qfalse;
+
+	if (//Dissolve.iStartTime == 0	// no point in interruping an existing one
+		//&&
+		tr.registered == qtrue		// ... stops it crashing during first cinematic before the menus... :-)
+		)
+	{
+		RE_KillDissolve();	// kill any that are already running
+
+#ifdef _XBOX	// Things are much simpler on Xbox, and use far less RAM
+
+		if (1)
+		{ // Silly if(1) to match up with control flow below, as the #ifdef ends inside the block
+			RE_GetCompressedBackbuffer();
+			Dissolve.iWidth			= glConfig.vidWidth;
+			Dissolve.iHeight		= glConfig.vidHeight;
+
+#else	// _XBOX
+
+		int iPow2VidWidth	= PowerOf2( glConfig.vidWidth );
+		int iPow2VidHeight	= PowerOf2( glConfig.vidHeight);
+
+		int iBufferBytes	= iPow2VidWidth * iPow2VidHeight * 4;
+		byte *pBuffer = (byte *) Z_Malloc( iBufferBytes, TAG_TEMP_WORKSPACE, qfalse);
+		if (pBuffer)
+		{
+			// read current screen image...  (GL_RGBA should work even on 3DFX in that the RGB parts will be valid at least)
+			//
+			qglReadPixels (0, 0, glConfig.vidWidth, glConfig.vidHeight, GL_RGBA, GL_UNSIGNED_BYTE, pBuffer );
+			//
+			// now expand the pic over the top of itself so that it has a stride value of {PowerOf2(glConfig.vidWidth)}
+			//	(for GL power-of-2 rules)
+			//
+			byte *pbSrc = &pBuffer[	glConfig.vidWidth	* glConfig.vidHeight * 4];
+			byte *pbDst = &pBuffer[ iPow2VidWidth		* glConfig.vidHeight * 4];
+			//
+			// ( clear to end, since we've got pbDst nicely setup here)
+			//
+			int iClearBytes = &pBuffer[iBufferBytes] - pbDst; 
+			memset(pbDst, 0, iClearBytes);
+			//
+			// work out copy/stride vals...
+			//
+				iClearBytes = ( iPow2VidWidth - glConfig.vidWidth ) * 4;
+			int iCopyBytes	= glConfig.vidWidth * 4;
+			//
+			// do it...
+			//
+			for (int y = 0; y < glConfig.vidHeight; y++)
+			{
+				pbDst -= iClearBytes;
+				memset(pbDst,0,iClearBytes);
+				pbDst -= iCopyBytes;
+				pbSrc -= iCopyBytes;
+				memmove(pbDst, pbSrc, iCopyBytes);
+			}
+			//
+			// ok, now we've got the screen image in the top left of the power-of-2 texture square,
+			//	but of course the damn thing's upside down (thanks, GL), so invert it, but only within
+			//	the picture pixels, NOT the upload texture as a whole...
+			//
+			byte *pbSwapLineBuffer = (byte *)Z_Malloc( iCopyBytes, TAG_TEMP_WORKSPACE, qfalse);
+			pbSrc = &pBuffer[0];
+			pbDst = &pBuffer[(glConfig.vidHeight-1) * iPow2VidWidth * 4];
+			for (y = 0; y < glConfig.vidHeight/2; y++)
+			{
+				memcpy(pbSwapLineBuffer, pbDst, iCopyBytes);
+				memcpy(pbDst, pbSrc, iCopyBytes);
+				memcpy(pbSrc, pbSwapLineBuffer, iCopyBytes);				
+				pbDst -= iPow2VidWidth*4;
+				pbSrc += iPow2VidWidth*4;
+			}
+			Z_Free(pbSwapLineBuffer);
+
+			//
+			// Now, in case of busted drivers, 3DFX cards, etc etc we stomp the alphas to 255...
+			//
+			byte *pPix = pBuffer;
+			for (int i=0; i<iBufferBytes/4; i++, pPix += 4)
+			{
+				pPix[3] = 255;
+			}
+
+			// work out what res we're capable of storing/xfading this "screen sprite"...
+			//
+			Dissolve.iWidth			= glConfig.vidWidth;
+			Dissolve.iHeight		= glConfig.vidHeight;
+			Dissolve.iUploadWidth	= iPow2VidWidth;
+			Dissolve.iUploadHeight	= iPow2VidHeight;
+			int	iTexSize			= glConfig.maxTextureSize;
+
+			if ( glConfig.maxTextureSize < 256 )	// jic the driver sucks
+			{
+				iTexSize = 256;
+			}
+
+			if (Dissolve.iUploadWidth > iTexSize) {
+				Dissolve.iUploadWidth = iTexSize;
+			}
+
+			if (Dissolve.iUploadHeight > iTexSize) {
+				Dissolve.iUploadHeight = iTexSize;
+			}
+
+			// alloc resample buffer...  (note slight optimisation to avoid spurious alloc)
+			//
+			byte *pbReSampleBuffer =	(	iPow2VidWidth == Dissolve.iUploadWidth && 
+											iPow2VidHeight == Dissolve.iUploadHeight 
+										)?
+										NULL :
+										(byte*) Z_Malloc( iPow2VidWidth * iPow2VidHeight * 4, TAG_TEMP_WORKSPACE, qfalse);
+
+			// re-sample screen...
+			//
+			byte *pbScreenSprite = RE_ReSample(	pBuffer,				// byte *pbLoadedPic
+												iPow2VidWidth,			// int iLoadedWidth
+												iPow2VidHeight,			// int iLoadedHeight
+												//
+												pbReSampleBuffer,		// byte *pbReSampleBuffer
+												&Dissolve.iUploadWidth,	// int *piWidth
+												&Dissolve.iUploadHeight	// int *piHeight
+												);
+
+			Dissolve.pImage = R_CreateImage("*DissolveImage",		// const char *name
+											pbScreenSprite,			// const byte *pic
+											Dissolve.iUploadWidth,	// int width
+											Dissolve.iUploadHeight,	// int height
+											GL_RGBA,
+											qfalse,					// qboolean mipmap
+											qfalse,					// qboolean allowPicmip
+											qfalse,					// qboolean allowTC
+											GL_CLAMP				// int glWrapClampMode
+											);
+
+#endif	// _XBOX
+
+			static byte bBlack[8*8*4]={0};
+			for (int j=0; j<8*8*4; j+=4)	// itu?
+				bBlack[j+3]=255;		// 
+
+			Dissolve.pBlack = R_CreateImage( "*DissolveBlack",	// const char *name
+											bBlack,				// const byte *pic
+											8,					// int width
+											8,					// int height
+											GL_RGBA,
+											qfalse,				// qboolean mipmap
+											qfalse,				// qboolean allowPicmip
+#ifndef _XBOX
+											qfalse,				// qboolean allowTC
+#endif // _XBOX
+											GL_CLAMP			// int glWrapClampMode
+											);
+
+#ifndef _XBOX
+			if (pbReSampleBuffer)
+			{
+				Z_Free(pbReSampleBuffer);
+			}
+			Z_Free(pBuffer);
+#endif
+
+			// pick dissolve type...
+			//
+#if 0
+			// cycles through every dissolve type, for testing...
+			//
+			static Dissolve_e eDissolve = (Dissolve_e) 0;
+			Dissolve.eDissolveType =	eDissolve;
+										eDissolve = (Dissolve_e) (eDissolve+1);
+									if (eDissolve == eDISSOLVE_RAND_LIMIT)
+										eDissolve = (Dissolve_e) (eDissolve+1);
+									if (eDissolve >= eDISSOLVE_NUMBEROF)
+										eDissolve = (Dissolve_e) 0;
+#else
+			// final (& random) version...
+			//
+			Dissolve.eDissolveType = (Dissolve_e) Q_irand( 0, eDISSOLVE_RAND_LIMIT-1);
+#endif
+
+			if (bForceCircularExtroWipe)
+			{
+				Dissolve.eDissolveType = eDISSOLVE_CIRCULAR_IN;
+			}
+
+			// ... and load appropriate graphics...
+			//
+
+			// special tweak, although this code is normally called just before client spawns into world (and
+			//	is therefore pretty much immune to precache issues) I also need to make sure that the inverse
+			//	iris graphic is loaded so for the special case of doing a circular wipe at the end of the last
+			//	level doesn't stall on loading the image. So I'll load it here anyway - to prime the image - 
+			//	then allow the random wiper to overwrite the ptr if needed. This way the end of level call
+			//	will be instant.  Downside: every level has one extra 256x256 texture.
+#ifndef _XBOX	// Trying to decipher these comments - looks like no problem taking this out. I want the RAM.
+			{
+					Dissolve.pDissolve = R_FindImageFile(	"gfx/2d/iris_mono_rev",		// const char *name
+															qfalse,						// qboolean mipmap
+															qfalse,						// qboolean allowPicmip
+															qfalse,						// qboolean allowTC
+															GL_CLAMP					// int glWrapClampMode 
+														);
+			}
+#endif
+
+			extern cvar_t *com_buildScript;
+			if (com_buildScript->integer)
+			{
+				// register any/all of the possible CASE statements below...
+				//
+				Dissolve.pDissolve = R_FindImageFile(	"gfx/2d/iris_mono",			// const char *name
+														qfalse,						// qboolean mipmap
+														qfalse,						// qboolean allowPicmip
+														qfalse,						// qboolean allowTC
+														GL_CLAMP					// int glWrapClampMode 
+													);
+				Dissolve.pDissolve = R_FindImageFile(	"textures/common/dissolve",	// const char *name
+														qfalse,						// qboolean mipmap
+														qfalse,						// qboolean allowPicmip
+														qfalse,						// qboolean allowTC
+														GL_REPEAT					// int glWrapClampMode 
+													);
+			}
+
+			switch (Dissolve.eDissolveType)
+			{
+				case eDISSOLVE_CIRCULAR_IN:
+				{
+					Dissolve.pDissolve = R_FindImageFile(	"gfx/2d/iris_mono_rev",		// const char *name
+															qfalse,						// qboolean mipmap
+															qfalse,						// qboolean allowPicmip
+															qfalse,						// qboolean allowTC
+															GL_CLAMP					// int glWrapClampMode 
+														);
+				}
+				break;
+
+				case eDISSOLVE_CIRCULAR_OUT:
+				{
+					Dissolve.pDissolve = R_FindImageFile(	"gfx/2d/iris_mono",			// const char *name
+															qfalse,						// qboolean mipmap
+															qfalse,						// qboolean allowPicmip
+															qfalse,						// qboolean allowTC
+															GL_CLAMP					// int glWrapClampMode 
+														);
+				}
+				break;
+
+				default:
+				{
+					Dissolve.pDissolve = R_FindImageFile(	"textures/common/dissolve",	// const char *name
+															qfalse,						// qboolean mipmap
+															qfalse,						// qboolean allowPicmip
+															qfalse,						// qboolean allowTC
+															GL_REPEAT					// int glWrapClampMode 
+														);
+				}
+				break;
+			}
+
+			// all good?...
+			//
+			if (Dissolve.pDissolve)	// test if image was found, if not, don't do dissolves
+			{
+				Dissolve.iStartTime = Sys_Milliseconds();	// gets overwritten first time, but MUST be set to NZ
+				Dissolve.bTouchNeeded = qtrue;
+				bReturn = qtrue;
+			}
+			else
+			{
+				RE_KillDissolve();
+			}
+		}
+	}
+
+	return bReturn;
+}
+
diff --git a/code/renderer/tr_flares.cpp b/code/renderer/tr_flares.cpp
new file mode 100644
index 0000000..a8e9140
--- /dev/null
+++ b/code/renderer/tr_flares.cpp
@@ -0,0 +1,427 @@
+// tr_flares.c
+
+#include "tr_local.h"
+
+/*
+=============================================================================
+
+LIGHT FLARES
+
+A light flare is an effect that takes place inside the eye when bright light
+sources are visible.  The size of the flare reletive to the screen is nearly
+constant, irrespective of distance, but the intensity should be proportional to the
+projected area of the light source.
+
+A surface that has been flagged as having a light flare will calculate the depth
+buffer value that it's midpoint should have when the surface is added.
+
+After all opaque surfaces have been rendered, the depth buffer is read back for
+each flare in view.  If the point has not been obscured by a closer surface, the
+flare should be drawn.
+
+Surfaces that have a repeated texture should never be flagged as flaring, because
+there will only be a single flare added at the midpoint of the polygon.
+
+To prevent abrupt popping, the intensity of the flare is interpolated up and
+down as it changes visibility.  This involves scene to scene state, unlike almost
+all other aspects of the renderer, and is complicated by the fact that a single
+frame may have multiple scenes.
+
+RB_RenderFlares() will be called once per view (twice in a mirrored scene, potentially
+up to five or more times in a frame with 3D status bar icons).
+
+=============================================================================
+*/
+
+
+// flare states maintain visibility over multiple frames for fading
+// layers: view, mirror, menu
+typedef struct flare_s {
+	struct		flare_s	*next;		// for active chain
+
+	int			addedFrame;
+
+	qboolean	inPortal;				// true if in a portal view of the scene
+	int			frameSceneNum;
+	void		*surface;
+	int			fogNum;
+
+	int			fadeTime;
+
+	qboolean	visible;			// state of last test
+	float		drawIntensity;		// may be non 0 even if !visible due to fading
+	float		lightScale;
+	int			windowX, windowY;
+	float		eyeZ;
+
+	vec3_t		color;
+} flare_t;
+
+#define		MAX_FLARES		128
+
+flare_t		r_flareStructs[MAX_FLARES];
+flare_t		*r_activeFlares, *r_inactiveFlares;
+
+/*
+==================
+R_ClearFlares
+==================
+*/
+void R_ClearFlares( void ) {
+	int		i;
+
+	memset( r_flareStructs, 0, sizeof( r_flareStructs ) );
+	r_activeFlares = NULL;
+	r_inactiveFlares = NULL;
+
+	for ( i = 0 ; i < MAX_FLARES ; i++ ) {
+		r_flareStructs[i].next = r_inactiveFlares;
+		r_inactiveFlares = &r_flareStructs[i];
+	}
+}
+
+
+/*
+==================
+RB_AddFlare
+
+This is called at surface tesselation time
+==================
+*/
+void RB_AddFlare( void *surface, int fogNum, vec3_t point, vec3_t color, vec3_t normal, float lightScale) {
+	int				i;
+	flare_t			*f, *oldest;
+	vec3_t			local;
+	float			d;
+	vec4_t			eye, clip, normalized, window;
+
+	backEnd.pc.c_flareAdds++;
+
+	// if the point is off the screen, don't bother adding it
+	// calculate screen coordinates and depth
+	R_TransformModelToClip( point, backEnd.or.modelMatrix, 
+		backEnd.viewParms.projectionMatrix, eye, clip );
+
+	// check to see if the point is completely off screen
+	for ( i = 0 ; i < 3 ; i++ ) {
+		if ( clip[i] >= clip[3] || clip[i] <= -clip[3] ) {
+			return;
+		}
+	}
+
+	R_TransformClipToWindow( clip, &backEnd.viewParms, normalized, window );
+
+	if ( window[0] < 0 || window[0] >= backEnd.viewParms.viewportWidth
+		|| window[1] < 0 || window[1] >= backEnd.viewParms.viewportHeight ) {
+		return;	// shouldn't happen, since we check the clip[] above, except for FP rounding
+	}
+
+	// see if a flare with a matching surface, scene, and view exists
+	oldest = r_flareStructs;
+	for ( f = r_activeFlares ; f ; f = f->next ) {
+		if ( f->surface == surface && f->frameSceneNum == backEnd.viewParms.frameSceneNum
+			&& f->inPortal == backEnd.viewParms.isPortal ) {
+			break;
+		}
+	}
+
+	// allocate a new one
+	if (!f ) {
+		if ( !r_inactiveFlares ) {
+			// the list is completely full
+			return;
+		}
+		f = r_inactiveFlares;
+		r_inactiveFlares = r_inactiveFlares->next;
+		f->next = r_activeFlares;
+		r_activeFlares = f;
+
+		f->surface = surface;
+		f->frameSceneNum = backEnd.viewParms.frameSceneNum;
+		f->inPortal = backEnd.viewParms.isPortal;
+		f->addedFrame = -1;
+	}
+
+	if ( f->addedFrame != backEnd.viewParms.frameCount - 1 ) {
+		f->visible = qfalse;
+		f->fadeTime = backEnd.refdef.time - 2000;
+	}
+
+	f->addedFrame = backEnd.viewParms.frameCount;
+	f->fogNum = fogNum;
+	f->lightScale = lightScale;
+
+	VectorCopy( color, f->color );
+
+	// fade the intensity of the flare down as the
+	// light surface turns away from the viewer
+	if ( normal ) {
+		VectorSubtract( backEnd.viewParms.or.origin, point, local );
+		VectorNormalizeFast( local );
+		d = DotProduct( local, normal );
+		VectorScale( f->color, d, f->color ); 
+	}
+
+	// save info needed to test
+	f->windowX = backEnd.viewParms.viewportX + window[0];
+	f->windowY = backEnd.viewParms.viewportY + window[1];
+
+	f->eyeZ = eye[2];
+}
+
+/*
+==================
+RB_AddDlightFlares
+==================
+*/
+void RB_AddDlightFlares( void ) {
+	dlight_t		*l;
+	int				i, j, k;
+	fog_t			*fog;
+
+	if ( !r_flares->integer ) {
+		return;
+	}
+
+	l = backEnd.refdef.dlights;
+	fog = tr.world->fogs;
+	for (i=0 ; i<backEnd.refdef.num_dlights ; i++, l++) {
+
+		// find which fog volume the light is in 
+		for ( j = 1 ; j < tr.world->numfogs ; j++ ) {
+			fog = &tr.world->fogs[j];
+			for ( k = 0 ; k < 3 ; k++ ) {
+				if ( l->origin[k] < fog->bounds[0][k] || l->origin[k] > fog->bounds[1][k] ) {
+					break;
+				}
+			}
+			if ( k == 3 ) {
+				break;
+			}
+		}
+		if ( j == tr.world->numfogs ) {
+			j = 0;
+		}
+
+		RB_AddFlare( (void *)l, j, l->origin, l->color, NULL, 1.0f );
+	}
+}
+
+/*
+===============================================================================
+
+FLARE BACK END
+
+===============================================================================
+*/
+
+/*
+==================
+RB_TestFlare
+==================
+*/
+void RB_TestFlare( flare_t *f ) {
+	float			depth;
+	qboolean		visible;
+	float			fade;
+	float			screenZ;
+
+	backEnd.pc.c_flareTests++;
+
+	// doing a readpixels is as good as doing a glFinish(), so
+	// don't bother with another sync
+	glState.finishCalled = qfalse;
+
+	// read back the z buffer contents
+	qglReadPixels( f->windowX, f->windowY, 1, 1, GL_DEPTH_COMPONENT, GL_FLOAT, &depth );
+
+	screenZ = backEnd.viewParms.projectionMatrix[14] / 
+		( ( 2*depth - 1 ) * backEnd.viewParms.projectionMatrix[11] - backEnd.viewParms.projectionMatrix[10] );
+
+	visible = ( -f->eyeZ - -screenZ ) < 24;
+
+	if ( visible ) {
+		if ( !f->visible ) {
+			f->visible = qtrue;
+			f->fadeTime = backEnd.refdef.time - 1;
+		}
+		fade = ( ( backEnd.refdef.time - f->fadeTime ) /1000.0f ) * r_flareFade->value;
+	} else {
+		if ( f->visible ) {
+			f->visible = qfalse;
+			f->fadeTime = backEnd.refdef.time - 1;
+		}
+		fade = 1.0 - ( ( backEnd.refdef.time - f->fadeTime ) / 1000.0f ) * r_flareFade->value;
+	}
+
+	if ( fade < 0 ) {
+		fade = 0;
+	}
+	if ( fade > 1 ) {
+		fade = 1;
+	}
+
+	f->drawIntensity = fade;
+}
+
+
+/*
+==================
+RB_RenderFlare
+==================
+*/
+void RB_RenderFlare( flare_t *f ) {
+	float			size;
+	vec3_t			color;
+	int				iColor[3];
+
+	backEnd.pc.c_flareRenders++;
+
+	VectorScale( f->color, f->drawIntensity*tr.identityLight, color );
+	iColor[0] = color[0] * 255;
+	iColor[1] = color[1] * 255;
+	iColor[2] = color[2] * 255;
+
+	size = f->lightScale * backEnd.viewParms.viewportWidth * ( r_flareSize->value/640.0 + 8 / -f->eyeZ );
+
+	RB_BeginSurface( tr.flareShader, f->fogNum );
+
+	// FIXME: use quadstamp?
+	tess.xyz[tess.numVertexes][0] = f->windowX - size;
+	tess.xyz[tess.numVertexes][1] = f->windowY - size;
+	tess.texCoords[tess.numVertexes][0][0] = 0;
+	tess.texCoords[tess.numVertexes][0][1] = 0;
+	tess.vertexColors[tess.numVertexes][0] = iColor[0];
+	tess.vertexColors[tess.numVertexes][1] = iColor[1];
+	tess.vertexColors[tess.numVertexes][2] = iColor[2];
+	tess.vertexColors[tess.numVertexes][3] = 255;
+	tess.numVertexes++;
+
+	tess.xyz[tess.numVertexes][0] = f->windowX - size;
+	tess.xyz[tess.numVertexes][1] = f->windowY + size;
+	tess.texCoords[tess.numVertexes][0][0] = 0;
+	tess.texCoords[tess.numVertexes][0][1] = 1;
+	tess.vertexColors[tess.numVertexes][0] = iColor[0];
+	tess.vertexColors[tess.numVertexes][1] = iColor[1];
+	tess.vertexColors[tess.numVertexes][2] = iColor[2];
+	tess.vertexColors[tess.numVertexes][3] = 255;
+	tess.numVertexes++;
+
+	tess.xyz[tess.numVertexes][0] = f->windowX + size;
+	tess.xyz[tess.numVertexes][1] = f->windowY + size;
+	tess.texCoords[tess.numVertexes][0][0] = 1;
+	tess.texCoords[tess.numVertexes][0][1] = 1;
+	tess.vertexColors[tess.numVertexes][0] = iColor[0];
+	tess.vertexColors[tess.numVertexes][1] = iColor[1];
+	tess.vertexColors[tess.numVertexes][2] = iColor[2];
+	tess.vertexColors[tess.numVertexes][3] = 255;
+	tess.numVertexes++;
+
+	tess.xyz[tess.numVertexes][0] = f->windowX + size;
+	tess.xyz[tess.numVertexes][1] = f->windowY - size;
+	tess.texCoords[tess.numVertexes][0][0] = 1;
+	tess.texCoords[tess.numVertexes][0][1] = 0;
+	tess.vertexColors[tess.numVertexes][0] = iColor[0];
+	tess.vertexColors[tess.numVertexes][1] = iColor[1];
+	tess.vertexColors[tess.numVertexes][2] = iColor[2];
+	tess.vertexColors[tess.numVertexes][3] = 255;
+	tess.numVertexes++;
+
+	tess.indexes[tess.numIndexes++] = 0;
+	tess.indexes[tess.numIndexes++] = 1;
+	tess.indexes[tess.numIndexes++] = 2;
+	tess.indexes[tess.numIndexes++] = 0;
+	tess.indexes[tess.numIndexes++] = 2;
+	tess.indexes[tess.numIndexes++] = 3;
+
+	RB_EndSurface();
+}
+
+/*
+==================
+RB_RenderFlares
+
+Because flares are simulating an occular effect, they should be drawn after
+everything (all views) in the entire frame has been drawn.
+
+Because of the way portals use the depth buffer to mark off areas, the
+needed information would be lost after each view, so we are forced to draw
+flares after each view.
+
+The resulting artifact is that flares in mirrors or portals don't dim properly
+when occluded by something in the main view, and portal flares that should
+extend past the portal edge will be overwritten.
+==================
+*/
+void RB_RenderFlares (void) {
+	flare_t		*f;
+	flare_t		**prev;
+	qboolean	draw;
+
+	if ( !r_flares->integer ) {
+		return;
+	}
+
+//	RB_AddDlightFlares();
+
+	// perform z buffer readback on each flare in this view
+	draw = qfalse;
+	prev = &r_activeFlares;
+	while ( ( f = *prev ) != NULL ) {
+		// throw out any flares that weren't added last frame
+		if ( f->addedFrame < backEnd.viewParms.frameCount - 1 ) {
+			*prev = f->next;
+			f->next = r_inactiveFlares;
+			r_inactiveFlares = f;
+			continue;
+		}
+
+		// don't draw any here that aren't from this scene / portal
+		f->drawIntensity = 0;
+		if ( f->frameSceneNum == backEnd.viewParms.frameSceneNum
+			&& f->inPortal == backEnd.viewParms.isPortal ) {
+			RB_TestFlare( f );
+			if ( f->drawIntensity ) {
+				draw = qtrue;
+			} else {
+				// this flare has completely faded out, so remove it from the chain
+				*prev = f->next;
+				f->next = r_inactiveFlares;
+				r_inactiveFlares = f;
+				continue;
+			}
+		}
+
+		prev = &f->next;
+	}
+
+	if ( !draw ) {
+		return;		// none visible
+	}
+
+	if ( backEnd.viewParms.isPortal ) {
+		qglDisable (GL_CLIP_PLANE0);
+	}
+
+	qglPushMatrix();
+    qglLoadIdentity();
+	qglMatrixMode( GL_PROJECTION );
+	qglPushMatrix();
+    qglLoadIdentity();
+	qglOrtho( backEnd.viewParms.viewportX, backEnd.viewParms.viewportX + backEnd.viewParms.viewportWidth,
+			  backEnd.viewParms.viewportY, backEnd.viewParms.viewportY + backEnd.viewParms.viewportHeight,
+			  -99999, 99999 );
+
+	for ( f = r_activeFlares ; f ; f = f->next ) {
+		if ( f->frameSceneNum == backEnd.viewParms.frameSceneNum
+			&& f->inPortal == backEnd.viewParms.isPortal
+			&& f->drawIntensity ) {
+			RB_RenderFlare( f );
+		}
+	}
+
+	qglPopMatrix();
+	qglMatrixMode( GL_MODELVIEW );
+	qglPopMatrix();
+}
+
diff --git a/code/renderer/tr_font.cpp b/code/renderer/tr_font.cpp
new file mode 100644
index 0000000..72f2952
--- /dev/null
+++ b/code/renderer/tr_font.cpp
@@ -0,0 +1,1714 @@
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+#include "../qcommon/sstring.h"	// stl string class won't compile in here (MS shite), so use Gil's.
+#include "tr_local.h"
+#include "tr_font.h"
+
+#include "../qcommon/stringed_ingame.h"
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////
+//
+// This file is shared in the single and multiplayer codebases, so be CAREFUL WHAT YOU ADD/CHANGE!!!!!
+//
+/////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+typedef enum
+{
+	eWestern,	// ( I only care about asian languages in here at the moment )
+	eRussian,	//  .. but now I need to care about this, since it uses a different TP
+	ePolish,	// ditto
+	eKorean,
+	eTaiwanese,	// 15x15 glyphs tucked against BR of 16x16 space
+	eJapanese,	// 15x15 glyphs tucked against TL of 16x16 space
+	eChinese,	// 15x15 glyphs tucked against TL of 16x16 space
+	eThai,		// 16x16 cells with glyphs against left edge, special file (tha_widths.dat) for variable widths
+} Language_e;
+
+// this is to cut down on all the stupid string compares I've been doing, and convert asian stuff to switch-case
+//
+Language_e GetLanguageEnum()
+{
+	static int			iSE_Language_ModificationCount = -1234;	// any old silly value that won't match the cvar mod count
+	static Language_e	eLanguage = eWestern;
+
+	// only re-strcmp() when language string has changed from what we knew it as...
+	//
+	if (iSE_Language_ModificationCount != se_language->modificationCount )
+	{
+		iSE_Language_ModificationCount  = se_language->modificationCount;
+
+				if ( Language_IsRussian()	)	eLanguage = eRussian;
+		else	if ( Language_IsPolish()	)	eLanguage = ePolish;
+		else	if ( Language_IsKorean()	)	eLanguage = eKorean;
+		else	if ( Language_IsTaiwanese()	)	eLanguage = eTaiwanese;
+		else	if ( Language_IsJapanese()	)	eLanguage = eJapanese;
+		else	if ( Language_IsChinese()	)	eLanguage = eChinese;
+		else	if ( Language_IsThai()		)	eLanguage = eThai;
+		else	eLanguage = eWestern;
+	}
+
+	return eLanguage;
+}
+
+struct SBCSOverrideLanguages_t
+{
+	LPCSTR		m_psName;
+	Language_e	m_eLanguage;
+};
+
+// so I can do some stuff with for-next loops when I add polish etc...
+//
+SBCSOverrideLanguages_t g_SBCSOverrideLanguages[]=
+{
+	{"russian",	eRussian},
+	{"polish",	ePolish},
+	{NULL,		eWestern}
+};
+
+
+
+//================================================
+//
+
+#define sFILENAME_THAI_WIDTHS	"fonts/tha_widths.dat"
+#define sFILENAME_THAI_CODES	"fonts/tha_codes.dat"
+
+struct ThaiCodes_t
+{
+	map <int, int>	m_mapValidCodes;
+	vector<int>		m_viGlyphWidths;	
+	string			m_strInitFailureReason;	// so we don't have to keep retrying to work this out
+
+	void Clear( void )
+	{
+		m_mapValidCodes.clear();
+		m_viGlyphWidths.clear();		
+		m_strInitFailureReason = "";	// if blank, never failed, else says don't bother re-trying
+	}
+
+	ThaiCodes_t()
+	{
+		Clear();
+	}
+
+	// convert a supplied 1,2 or 3-byte multiplied-up integer into a valid 0..n index, else -1...
+	//
+	int GetValidIndex( int iCode )
+	{
+		map <int,int>::iterator it = m_mapValidCodes.find( iCode );
+		if (it != m_mapValidCodes.end())
+		{
+            return (*it).second;
+		}
+
+		return -1;
+	}
+
+	int GetWidth( int iGlyphIndex )
+	{
+		if (iGlyphIndex < m_viGlyphWidths.size())
+		{
+			return m_viGlyphWidths[ iGlyphIndex ];
+		}
+
+		assert(0);
+		return 0;
+	}
+
+	// return is error message to display, or NULL for success
+	const char *Init(void)
+	{
+		if (m_mapValidCodes.empty() && m_viGlyphWidths.empty())
+		{
+			if (m_strInitFailureReason.empty())	// never tried and failed already?
+			{
+				int *piData = NULL;	// note <int>, not <byte>, for []-access
+				//
+				// read the valid-codes table in...
+				//
+				int iBytesRead = FS_ReadFile( sFILENAME_THAI_CODES, (void **) &piData );
+				if (iBytesRead > 0 && !(iBytesRead&3))	// valid length and multiple of 4 bytes long
+				{
+					int iTableEntries = iBytesRead / sizeof(int);
+					
+					for (int i=0; i < iTableEntries; i++)
+					{
+						m_mapValidCodes[ piData[i] ] = i;	// convert MBCS code to sequential index...
+					}
+					FS_FreeFile( piData );	// dispose of original
+
+					// now read in the widths... (I'll keep these in a simple STL vector, so they'all disappear when the <map> entries do...
+					//		
+					iBytesRead = FS_ReadFile( sFILENAME_THAI_WIDTHS, (void **) &piData );
+					if (iBytesRead > 0 && !(iBytesRead&3) && iBytesRead>>2/*sizeof(int)*/ == iTableEntries)
+					{
+						for (int i=0; i<iTableEntries; i++)
+						{
+							m_viGlyphWidths.push_back( piData[i] );
+						}
+						FS_FreeFile( piData );	// dispose of original
+					}
+					else
+					{
+						m_strInitFailureReason = va("Error with file \"%s\", size = %d!\n", sFILENAME_THAI_WIDTHS, iBytesRead);
+					}
+				}
+				else
+				{
+					m_strInitFailureReason = va("Error with file \"%s\", size = %d!\n", sFILENAME_THAI_CODES, iBytesRead);
+				}
+			}
+		}
+
+		return m_strInitFailureReason.c_str();
+	}
+};
+
+
+#define GLYPH_MAX_KOREAN_SHADERS	3
+#define GLYPH_MAX_TAIWANESE_SHADERS 4
+#define GLYPH_MAX_JAPANESE_SHADERS	3
+#define GLYPH_MAX_CHINESE_SHADERS	3
+#define GLYPH_MAX_THAI_SHADERS		3
+#define GLYPH_MAX_ASIAN_SHADERS		4	// this MUST equal the larger of the above defines
+
+class CFontInfo
+{
+private:
+	// From the fontdat file
+	glyphInfo_t		mGlyphs[GLYPH_COUNT];
+
+//	int				mAsianHack;				// unused junk from John's fontdat file format.
+	// end of fontdat data
+
+	int				mShader;   				// handle to the shader with the glyph
+	
+	int				m_hAsianShaders[GLYPH_MAX_ASIAN_SHADERS];	// shaders for Korean glyphs where applicable		
+	glyphInfo_t		m_AsianGlyph;			// special glyph containing asian->western scaling info for all glyphs
+	int				m_iAsianGlyphsAcross;	// needed to dynamically calculate S,T coords
+	int				m_iAsianPagesLoaded;
+	bool			m_bAsianLastPageHalfHeight;
+	int				m_iLanguageModificationCount;	// doesn't matter what this is, so long as it's comparable as being changed
+
+	ThaiCodes_t		*m_pThaiData;
+
+public:
+	char			m_sFontName[MAX_QPATH];	// eg "fonts/lcd"	// needed for korean font-hint if we need >1 hangul set
+	int				mPointSize;
+	int				mHeight;
+	int				mAscender;
+	int				mDescender;
+
+	bool			mbRoundCalcs;	// trying to make this !@#$%^ thing work with scaling
+	int				m_iThisFont;	// handle to itself
+	int				m_iAltSBCSFont;	// -1 == NULL // alternative single-byte font for languages like russian/polish etc that need to override high characters ?
+	int				m_iOriginalFontWhenSBCSOverriden;
+	float			m_fAltSBCSFontScaleFactor;	// -1, else amount to adjust returned values by to make them fit the master western font they're substituting for
+	bool			m_bIsFakeAlienLanguage;	// ... if true, don't process as MBCS or override as SBCS etc
+
+	CFontInfo(const char *fontName);
+//	CFontInfo(int fill) { memset(this, fill, sizeof(*this)); }	// wtf?
+	~CFontInfo(void) {}	
+
+	const int GetPointSize(void) const { return(mPointSize); }
+	const int GetHeight(void) const { return(mHeight); }
+	const int GetAscender(void) const { return(mAscender); }
+	const int GetDescender(void) const { return(mDescender); }
+
+	const glyphInfo_t *GetLetter(const unsigned int uiLetter, int *piShader = NULL);
+	const int GetCollapsedAsianCode(ulong uiLetter) const;
+
+	const int GetLetterWidth(const unsigned int uiLetter);
+	const int GetLetterHorizAdvance(const unsigned int uiLetter);
+	const int GetShader(void) const { return(mShader); }
+
+	void FlagNoAsianGlyphs(void) { m_hAsianShaders[0] = 0; m_iLanguageModificationCount = -1; }	// used during constructor
+	bool AsianGlyphsAvailable(void) const { return !!(m_hAsianShaders[0]); }
+
+	void UpdateAsianIfNeeded( bool bForceReEval = false);	
+};
+
+//================================================
+
+
+
+
+// round float to one decimal place...
+//
+float RoundTenth( float fValue )
+{
+	return ( floorf( (fValue*10.0f) + 0.5f) ) / 10.0f;
+}
+
+
+int							g_iCurrentFontIndex;	// entry 0 is reserved index for missing/invalid, else ++ with each new font registered
+vector<CFontInfo *>			g_vFontArray;
+typedef map<sstring_t, int>	FontIndexMap_t;
+							FontIndexMap_t g_mapFontIndexes;
+int g_iNonScaledCharRange;	// this is used with auto-scaling of asian fonts, anything below this number is preserved in scale, anything above is scaled down by 0.75f
+
+//paletteRGBA_c				lastcolour;
+
+// =============================== some korean stuff =======================================
+
+#define KSC5601_HANGUL_HIBYTE_START		0xB0	// range is...
+#define KSC5601_HANGUL_HIBYTE_STOP		0xC8	// ... inclusive
+#define KSC5601_HANGUL_LOBYTE_LOBOUND	0xA0	// range is...
+#define KSC5601_HANGUL_LOBYTE_HIBOUND	0xFF	// ...bounding (ie only valid in between these points, but NULLs in charsets for these codes)
+#define KSC5601_HANGUL_CODES_PER_ROW	96		// 2 more than the number of glyphs
+
+extern qboolean Language_IsKorean( void );
+
+static inline bool Korean_ValidKSC5601Hangul( byte _iHi, byte _iLo )
+{
+	return (_iHi >=KSC5601_HANGUL_HIBYTE_START		&&
+			_iHi <=KSC5601_HANGUL_HIBYTE_STOP		&&
+			_iLo > KSC5601_HANGUL_LOBYTE_LOBOUND	&&
+			_iLo < KSC5601_HANGUL_LOBYTE_HIBOUND
+			);
+}
+
+static inline bool Korean_ValidKSC5601Hangul( unsigned int uiCode )
+{
+	return Korean_ValidKSC5601Hangul( uiCode >> 8, uiCode & 0xFF );
+}
+
+
+// takes a KSC5601 double-byte hangul code and collapses down to a 0..n glyph index...
+// Assumes rows are 96 wide (glyph slots), not 94 wide (actual glyphs), so I can ignore boundary markers
+//
+// (invalid hangul codes will return 0)
+//
+static int Korean_CollapseKSC5601HangulCode(unsigned int uiCode)
+{
+	if (Korean_ValidKSC5601Hangul( uiCode ))
+	{
+		uiCode -= (KSC5601_HANGUL_HIBYTE_START * 256) + KSC5601_HANGUL_LOBYTE_LOBOUND;	// sneaky maths on both bytes, reduce to 0x0000 onwards
+		uiCode  = ((uiCode >> 8) * KSC5601_HANGUL_CODES_PER_ROW) + (uiCode & 0xFF);
+		return uiCode;
+	}
+	return 0;
+}
+
+static int Korean_InitFields(int &iGlyphTPs, LPCSTR &psLang)
+{
+	psLang		= "kor";
+	iGlyphTPs	= GLYPH_MAX_KOREAN_SHADERS;
+	g_iNonScaledCharRange = 255;
+	return 32;	// m_iAsianGlyphsAcross
+}
+
+// ======================== some taiwanese stuff ==============================
+
+// (all ranges inclusive for Big5)...
+//
+#define BIG5_HIBYTE_START0		0xA1	// (misc chars + level 1 hanzi)
+#define BIG5_HIBYTE_STOP0		0xC6	// 
+#define BIG5_HIBYTE_START1		0xC9	// (level 2 hanzi)
+#define BIG5_HIBYTE_STOP1		0xF9	// 
+#define BIG5_LOBYTE_LOBOUND0	0x40	// 
+#define BIG5_LOBYTE_HIBOUND0	0x7E	// 
+#define BIG5_LOBYTE_LOBOUND1	0xA1	// 
+#define BIG5_LOBYTE_HIBOUND1	0xFE	// 
+#define BIG5_CODES_PER_ROW		160		// 3 more than the number of glyphs
+
+extern qboolean Language_IsTaiwanese( void );
+
+static bool Taiwanese_ValidBig5Code( unsigned int uiCode )
+{
+	const byte _iHi = (uiCode >> 8)&0xFF;
+	if (	(_iHi >= BIG5_HIBYTE_START0 && _iHi <= BIG5_HIBYTE_STOP0)
+		||	(_iHi >= BIG5_HIBYTE_START1 && _iHi <= BIG5_HIBYTE_STOP1)
+		)
+	{
+		const byte _iLo = uiCode & 0xFF;
+
+		if ( (_iLo >= BIG5_LOBYTE_LOBOUND0 && _iLo <= BIG5_LOBYTE_HIBOUND0) ||
+			 (_iLo >= BIG5_LOBYTE_LOBOUND1 && _iLo <= BIG5_LOBYTE_HIBOUND1)
+			)
+		{
+			return true;
+		}
+	}
+
+	return false;
+}
+
+
+// only call this when Taiwanese_ValidBig5Code() has already returned true...
+//
+static bool Taiwanese_IsTrailingPunctuation( unsigned int uiCode )
+{
+	// so far I'm just counting the first 21 chars, those seem to be all the basic punctuation...
+	//
+	if (	uiCode >= ((BIG5_HIBYTE_START0<<8)|BIG5_LOBYTE_LOBOUND0) && 
+			uiCode <  ((BIG5_HIBYTE_START0<<8)|BIG5_LOBYTE_LOBOUND0+20)
+		)
+	{
+		return true;
+	}
+
+	return false;
+}
+
+
+// takes a BIG5 double-byte code (including level 2 hanzi) and collapses down to a 0..n glyph index...
+// Assumes rows are 160 wide (glyph slots), not 157 wide (actual glyphs), so I can ignore boundary markers
+//
+// (invalid big5 codes will return 0)
+//
+static int Taiwanese_CollapseBig5Code( unsigned int uiCode )
+{
+	if (Taiwanese_ValidBig5Code( uiCode ))
+	{			
+		uiCode -= (BIG5_HIBYTE_START0 * 256) + BIG5_LOBYTE_LOBOUND0;	// sneaky maths on both bytes, reduce to 0x0000 onwards
+		if ( (uiCode & 0xFF) >= (BIG5_LOBYTE_LOBOUND1-1)-BIG5_LOBYTE_LOBOUND0)
+		{
+			uiCode -= ((BIG5_LOBYTE_LOBOUND1-1) - (BIG5_LOBYTE_HIBOUND0+1)) -1;
+		}
+		uiCode = ((uiCode >> 8) * BIG5_CODES_PER_ROW) + (uiCode & 0xFF);
+		return uiCode;
+	}
+	return 0;
+}
+
+static int Taiwanese_InitFields(int &iGlyphTPs, LPCSTR &psLang)
+{
+	psLang		= "tai";
+	iGlyphTPs	= GLYPH_MAX_TAIWANESE_SHADERS;
+	g_iNonScaledCharRange = 255;
+	return 64;	// m_iAsianGlyphsAcross
+}
+
+// ======================== some Japanese stuff ==============================
+
+
+// ( all ranges inclusive for Shift-JIS )
+//
+#define SHIFTJIS_HIBYTE_START0	0x81
+#define SHIFTJIS_HIBYTE_STOP0	0x9F
+#define SHIFTJIS_HIBYTE_START1	0xE0
+#define SHIFTJIS_HIBYTE_STOP1	0xEF
+//
+#define SHIFTJIS_LOBYTE_START0	0x40
+#define SHIFTJIS_LOBYTE_STOP0	0x7E
+#define SHIFTJIS_LOBYTE_START1	0x80
+#define SHIFTJIS_LOBYTE_STOP1	0xFC
+#define SHIFTJIS_CODES_PER_ROW	(((SHIFTJIS_LOBYTE_STOP0-SHIFTJIS_LOBYTE_START0)+1)+((SHIFTJIS_LOBYTE_STOP1-SHIFTJIS_LOBYTE_START1)+1))
+
+
+extern qboolean Language_IsJapanese( void );
+
+static bool Japanese_ValidShiftJISCode( byte _iHi, byte _iLo )
+{
+	if (	(_iHi >= SHIFTJIS_HIBYTE_START0 && _iHi <= SHIFTJIS_HIBYTE_STOP0)
+		||	(_iHi >= SHIFTJIS_HIBYTE_START1 && _iHi <= SHIFTJIS_HIBYTE_STOP1)
+		)
+	{
+		if ( (_iLo >= SHIFTJIS_LOBYTE_START0 && _iLo <= SHIFTJIS_LOBYTE_STOP0) ||
+			 (_iLo >= SHIFTJIS_LOBYTE_START1 && _iLo <= SHIFTJIS_LOBYTE_STOP1)
+			)
+		{
+			return true;
+		}
+	}
+	
+	return false;
+}
+
+static inline bool Japanese_ValidShiftJISCode( unsigned int uiCode )
+{
+	return Japanese_ValidShiftJISCode( uiCode >> 8, uiCode & 0xFF );
+}
+
+
+// only call this when Japanese_ValidShiftJISCode() has already returned true...
+//
+static bool Japanese_IsTrailingPunctuation( unsigned int uiCode )
+{
+	// so far I'm just counting the first 18 chars, those seem to be all the basic punctuation...
+	//
+	if (	uiCode >= ((SHIFTJIS_HIBYTE_START0<<8)|SHIFTJIS_LOBYTE_START0) && 
+			uiCode <  ((SHIFTJIS_HIBYTE_START0<<8)|SHIFTJIS_LOBYTE_START0+18)
+		)
+	{
+		return true;
+	}
+
+	return false;
+}
+
+
+// takes a ShiftJIS double-byte code and collapse down to a 0..n glyph index...
+//
+// (invalid codes will return 0)
+//
+static int Japanese_CollapseShiftJISCode( unsigned int uiCode )
+{
+	if (Japanese_ValidShiftJISCode( uiCode ))
+	{	
+		uiCode -= ((SHIFTJIS_HIBYTE_START0<<8)|SHIFTJIS_LOBYTE_START0);	// sneaky maths on both bytes, reduce to 0x0000 onwards
+		
+		if ( (uiCode & 0xFF) >= (SHIFTJIS_LOBYTE_START1)-SHIFTJIS_LOBYTE_START0)
+		{
+			uiCode -= ((SHIFTJIS_LOBYTE_START1)-SHIFTJIS_LOBYTE_STOP0)-1;
+		}
+
+		if ( ((uiCode>>8)&0xFF) >= (SHIFTJIS_HIBYTE_START1)-SHIFTJIS_HIBYTE_START0)
+		{
+			uiCode -= (((SHIFTJIS_HIBYTE_START1)-SHIFTJIS_HIBYTE_STOP0)-1) << 8;
+		}
+
+		uiCode = ((uiCode >> 8) * SHIFTJIS_CODES_PER_ROW) + (uiCode & 0xFF);
+
+		return uiCode;
+	}
+	return 0;
+}
+
+
+static int Japanese_InitFields(int &iGlyphTPs, LPCSTR &psLang)
+{
+	psLang		= "jap";
+	iGlyphTPs	= GLYPH_MAX_JAPANESE_SHADERS;
+	g_iNonScaledCharRange = 255;
+	return 64;	// m_iAsianGlyphsAcross
+}
+
+// ======================== some Chinese stuff ==============================
+
+#define GB_HIBYTE_START		0xA1	// range is...       
+#define GB_HIBYTE_STOP		0xF7	// ... inclusive     
+#define GB_LOBYTE_LOBOUND	0xA0	// range is...                                                                                
+#define GB_LOBYTE_HIBOUND	0xFF	// ...bounding (ie only valid in between these points, but NULLs in charsets for these codes) 
+#define GB_CODES_PER_ROW	95		// 1 more than the number of glyphs
+
+extern qboolean Language_IsChinese( void );
+
+static inline bool Chinese_ValidGBCode( byte _iHi, byte _iLo )
+{
+	return (_iHi >=GB_HIBYTE_START		&&
+			_iHi <=GB_HIBYTE_STOP		&&
+			_iLo > GB_LOBYTE_LOBOUND	&&
+			_iLo < GB_LOBYTE_HIBOUND
+			);
+}
+
+static inline bool Chinese_ValidGBCode( unsigned int uiCode)
+{
+	return Chinese_ValidGBCode( uiCode >> 8, uiCode & 0xFF );
+}
+
+
+// only call this when Chinese_ValidGBCode() has already returned true...
+//
+static bool Chinese_IsTrailingPunctuation( unsigned int uiCode )
+{
+	// so far I'm just counting the first 13 chars, those seem to be all the basic punctuation...
+	//
+	if (	uiCode >  ((GB_HIBYTE_START<<8)|GB_LOBYTE_LOBOUND) && 
+			uiCode <  ((GB_HIBYTE_START<<8)|GB_LOBYTE_LOBOUND+14)
+		)
+	{
+		return true;
+	}
+
+	return false;
+}
+
+
+// takes a GB double-byte code and collapses down to a 0..n glyph index...
+// Assumes rows are 96 wide (glyph slots), not 94 wide (actual glyphs), so I can ignore boundary markers
+//
+// (invalid GB codes will return 0)
+//
+static int Chinese_CollapseGBCode( unsigned int uiCode )
+{
+	if (Chinese_ValidGBCode( uiCode ))
+	{			
+		uiCode -= (GB_HIBYTE_START * 256) + GB_LOBYTE_LOBOUND;	// sneaky maths on both bytes, reduce to 0x0000 onwards
+		uiCode  = ((uiCode >> 8) * GB_CODES_PER_ROW) + (uiCode & 0xFF);		
+		return uiCode;
+	}
+
+	return 0;
+}
+
+static int Chinese_InitFields(int &iGlyphTPs, LPCSTR &psLang)
+{
+	psLang		= "chi";
+	iGlyphTPs	= GLYPH_MAX_CHINESE_SHADERS;
+	g_iNonScaledCharRange = 255;
+	return 64;	// m_iAsianGlyphsAcross
+}
+
+// ======================== some Thai stuff ==============================
+
+//TIS 620-2533
+
+#define TIS_GLYPHS_START	160
+#define TIS_SARA_AM			0xD3		// special case letter, both a new letter and a trailing accent for the prev one
+ThaiCodes_t g_ThaiCodes;	// the one and only instance of this object
+
+extern qboolean Language_IsThai( void );
+
+/*
+static int Thai_IsAccentChar( unsigned int uiCode )
+{
+	switch (uiCode)
+	{
+		case 209:		
+		case 212:	case 213:	case 214:	case 215:	case 216:	case 217:	case 218:
+		case 231:	case 232:	case 233:	case 234:	case 235:	case 236:	case 237:	case 238:
+		return true;
+	}
+	
+	return false;
+}
+*/
+
+// returns a valid Thai code (or 0), based on taking 1,2 or 3 bytes from the supplied byte stream
+//	Fills in <iThaiBytes> with 1,2 or 3
+static int Thai_ValidTISCode( const byte *psString, int &iThaiBytes )
+{	
+	// try a 1-byte code first...
+	//
+	if (psString[0] >= 160)	// so western letters drop through and use normal font
+	{
+		// this code is heavily little-endian, so someone else will need to port for Mac etc... (not my problem ;-)
+		//		
+		union CodeToTry_t
+		{
+            char sChars[4];
+			unsigned int uiCode;
+		};
+		
+		CodeToTry_t CodeToTry;
+		CodeToTry.uiCode = 0;	// important that we clear all 4 bytes in sChars here
+
+		// thai codes can be up to 3 bytes long, so see how high we can get...
+		//
+		for (int i=0; i<3; i++)
+		{			
+			CodeToTry.sChars[i] = psString[i];
+
+            int iIndex = g_ThaiCodes.GetValidIndex( CodeToTry.uiCode );
+			if (iIndex == -1)
+			{
+				// failed, so return previous-longest code...
+				//
+				CodeToTry.sChars[i] = 0;
+				break;
+			}
+		}
+		iThaiBytes = i;
+		assert(i);	// if 'i' was 0, then this may be an error, trying to get a thai accent as standalone char?
+		return CodeToTry.uiCode;
+	}
+
+	return 0;
+}
+
+// special case, thai can only break on certain letters, and since the rules are complicated then
+//	we tell the translators to put an underscore ('_') between each word even though in Thai they're
+//	all jammed together at final output onscreen...
+//
+static inline bool Thai_IsTrailingPunctuation( unsigned int uiCode )
+{
+	return uiCode == '_';
+}
+
+// takes a TIS 1,2 or 3 byte code and collapse down to a 0..n glyph index...
+//
+// (invalid codes will return 0)
+//
+static int Thai_CollapseTISCode( unsigned int uiCode )
+{
+	if (uiCode >= TIS_GLYPHS_START)	// so western letters drop through as invalid
+	{
+		int iCollapsedIndex = g_ThaiCodes.GetValidIndex( uiCode );
+		if (iCollapsedIndex != -1)
+		{
+			return iCollapsedIndex;
+		}        
+	}
+
+	return 0;
+}
+
+static int Thai_InitFields(int &iGlyphTPs, LPCSTR &psLang)
+{
+	psLang		= "tha";
+	iGlyphTPs	= GLYPH_MAX_THAI_SHADERS;
+	g_iNonScaledCharRange = INT_MAX;	// in other words, don't scale any thai chars down
+	return 32;	// m_iAsianGlyphsAcross
+}
+
+
+// ============================================================================
+
+// takes char *, returns integer char at that point, and advances char * on by enough bytes to move
+//	past the letter (either western 1 byte or Asian multi-byte)...
+//
+// looks messy, but the actual execution route is quite short, so it's fast...
+//
+// Note that I have to have this 3-param form instead of advancing a passed-in "const char **psText" because of VM-crap where you can only change ptr-contents, not ptrs themselves. Bleurgh. Ditto the qtrue:qfalse crap instead of just returning stuff straight through.
+//
+unsigned int AnyLanguage_ReadCharFromString( const char *psText, int *piAdvanceCount, qboolean *pbIsTrailingPunctuation /* = NULL */)
+{	
+	const byte *psString = (const byte *) psText;	// avoid sign-promote bug
+	unsigned int uiLetter;
+
+	switch ( GetLanguageEnum() )
+	{
+		case eKorean:
+		{
+			if ( Korean_ValidKSC5601Hangul( psString[0], psString[1] ))
+			{
+				uiLetter = (psString[0] * 256) + psString[1];
+				*piAdvanceCount = 2;
+
+				// not going to bother testing for korean punctuation here, since korean already 
+				//	uses spaces, and I don't have the punctuation glyphs defined, only the basic 2350 hanguls
+				//
+				if ( pbIsTrailingPunctuation)
+				{
+					*pbIsTrailingPunctuation = qfalse;
+				}
+
+				return uiLetter;
+			}
+		}
+		break;
+
+		case eTaiwanese:
+		{
+			if ( Taiwanese_ValidBig5Code( (psString[0] * 256) + psString[1] ))
+			{
+				uiLetter = (psString[0] * 256) + psString[1];
+				*piAdvanceCount = 2;
+
+				// need to ask if this is a trailing (ie like a comma or full-stop) punctuation?...
+				//
+				if ( pbIsTrailingPunctuation)
+				{
+					*pbIsTrailingPunctuation = Taiwanese_IsTrailingPunctuation( uiLetter ) ? qtrue : qfalse;
+				}
+	
+				return uiLetter;
+			}
+		}
+		break;
+
+		case eJapanese:
+		{
+			if ( Japanese_ValidShiftJISCode( psString[0], psString[1] ))
+			{
+				uiLetter = (psString[0] * 256) + psString[1];
+				*piAdvanceCount = 2;
+	
+				// need to ask if this is a trailing (ie like a comma or full-stop) punctuation?...
+				//
+				if ( pbIsTrailingPunctuation)
+				{
+					*pbIsTrailingPunctuation = Japanese_IsTrailingPunctuation( uiLetter ) ? qtrue : qfalse;
+				}
+
+				return uiLetter;
+			}
+		}
+		break;
+
+		case eChinese:
+		{
+			if ( Chinese_ValidGBCode( (psString[0] * 256) + psString[1] ))
+			{
+				uiLetter = (psString[0] * 256) + psString[1];
+				*piAdvanceCount = 2;
+
+				// need to ask if this is a trailing (ie like a comma or full-stop) punctuation?...
+				//
+				if ( pbIsTrailingPunctuation)
+				{
+					*pbIsTrailingPunctuation = Chinese_IsTrailingPunctuation( uiLetter ) ? qtrue : qfalse;
+				}
+
+				return uiLetter;
+			}
+		}
+		break;
+
+		case eThai:
+		{
+			int iThaiBytes;
+			uiLetter = Thai_ValidTISCode( psString, iThaiBytes );
+			if ( uiLetter )
+			{
+				*piAdvanceCount = iThaiBytes;
+
+				if ( pbIsTrailingPunctuation )
+				{
+					*pbIsTrailingPunctuation = Thai_IsTrailingPunctuation( uiLetter ) ? qtrue : qfalse;
+				}
+
+				return uiLetter;
+			}
+		}
+		break;
+	}
+
+	// ... must not have been an MBCS code...
+	//
+	uiLetter = psString[0];
+	*piAdvanceCount = 1;
+
+	if (pbIsTrailingPunctuation)
+	{
+		*pbIsTrailingPunctuation = (uiLetter == '!' || 
+									uiLetter == '?' || 
+									uiLetter == ',' || 
+									uiLetter == '.' || 
+									uiLetter == ';' || 
+									uiLetter == ':'
+									) ? qtrue : qfalse;
+	}
+
+	return uiLetter;
+}
+
+
+// needed for subtitle printing since original code no longer worked once camera bar height was changed to 480/10
+//	rather than refdef height / 10. I now need to bodge the coords to come out right.
+//
+qboolean Language_IsAsian(void)
+{
+	switch ( GetLanguageEnum() )
+	{
+		case eKorean:
+		case eTaiwanese:
+		case eJapanese:
+		case eChinese:
+		case eThai:	// this is asian, but the query is normally used for scaling
+			return qtrue;
+	}
+
+	return qfalse;
+}
+
+qboolean Language_UsesSpaces(void)
+{
+	// ( korean uses spaces )
+	switch ( GetLanguageEnum() )
+	{
+		case eTaiwanese:	
+		case eJapanese:		
+		case eChinese:		
+		case eThai:			
+			return qfalse;
+	}
+
+	return qtrue;
+}
+
+// ======================================================================
+// name is (eg) "ergo" or "lcd", no extension.
+//
+//  If path present, it's a special language hack for SBCS override languages, eg: "lcd/russian", which means
+//	  just treat the file as "russian", but with the "lcd" part ensuring we don't find a different registered russian font
+//
+CFontInfo::CFontInfo(const char *_fontName)
+{
+	int			len, i;
+	void		*buff;
+	dfontdat_t	*fontdat;
+
+	// remove any special hack name insertions...
+	//
+	char fontName[MAX_QPATH];
+	sprintf(fontName,"fonts/%s.fontdat",COM_SkipPath(const_cast<char*>(_fontName)));	// COM_SkipPath should take a const char *, but it's just possible people use it as a char * I guess, so I have to hack around like this <groan>
+	
+	// clear some general things...
+	//
+	m_pThaiData = NULL;
+	m_iAltSBCSFont = -1;
+	m_iThisFont = -1;
+	m_iOriginalFontWhenSBCSOverriden = -1;
+	m_fAltSBCSFontScaleFactor = -1;
+	m_bIsFakeAlienLanguage = !strcmp(_fontName,"aurabesh");	// dont try and make SBCS or asian overrides for this
+
+	len = FS_ReadFile(fontName, NULL);
+	if (len == sizeof(dfontdat_t))
+	{
+		FS_ReadFile(fontName, &buff);
+		fontdat = (dfontdat_t *)buff;
+
+		for(i = 0; i < GLYPH_COUNT; i++)
+		{
+			mGlyphs[i] = fontdat->mGlyphs[i];
+		}
+		mPointSize = fontdat->mPointSize;
+		mHeight = fontdat->mHeight;
+		mAscender = fontdat->mAscender;
+		mDescender = fontdat->mDescender;
+//		mAsianHack = fontdat->mKoreanHack;	// ignore this crap, it's some junk in the fontdat file that no-one uses
+		mbRoundCalcs = !!strstr(fontName,"ergo");
+
+		// cope with bad fontdat headers...
+		//
+		if (mHeight == 0)
+		{
+			mHeight = mPointSize;
+            mAscender = mPointSize - Round( ((float)mPointSize/10.0f)+2 );	// have to completely guess at the baseline... sigh.
+            mDescender = mHeight - mAscender;
+		}
+
+		FS_FreeFile(buff);
+	}
+	else
+	{
+		mHeight = 0;
+		mShader = 0;
+	}
+
+	Q_strncpyz(m_sFontName, fontName, sizeof(m_sFontName));
+	COM_StripExtension( m_sFontName, m_sFontName );	// so we get better error printing if failed to load shader (ie lose ".fontdat")
+	mShader = RE_RegisterShaderNoMip(m_sFontName);
+
+	FlagNoAsianGlyphs();
+	UpdateAsianIfNeeded(true);
+
+	// finished...
+	g_vFontArray.resize(g_iCurrentFontIndex + 1);
+	g_vFontArray[g_iCurrentFontIndex++] = this;
+
+
+	extern cvar_t *com_buildScript;
+	if (com_buildScript->integer == 2)
+	{
+		Com_Printf( "com_buildScript(2): Registering foreign fonts...\n" );
+		static qboolean bDone = qfalse;	// Do this once only (for speed)...
+		if (!bDone)
+		{
+			bDone = qtrue;
+
+			char sTemp[MAX_QPATH];
+			int iGlyphTPs = 0;
+			const char *psLang = NULL;
+
+			// SBCS override languages...
+			//
+			fileHandle_t f;	
+			for (int i=0; g_SBCSOverrideLanguages[i].m_psName ;i++)
+			{
+				char sTemp[MAX_QPATH];
+
+				sprintf(sTemp,"fonts/%s.tga", g_SBCSOverrideLanguages[i].m_psName );
+				FS_FOpenFileRead( sTemp, &f, qfalse );
+				if (f) FS_FCloseFile( f );
+
+				sprintf(sTemp,"fonts/%s.fontdat", g_SBCSOverrideLanguages[i].m_psName );
+				FS_FOpenFileRead( sTemp, &f, qfalse );
+				if (f) FS_FCloseFile( f );
+			}
+
+			// asian MBCS override languages...
+			//
+			for (int iLang=0; iLang<5; iLang++)
+			{
+				switch (iLang)
+				{
+					case 0:	m_iAsianGlyphsAcross = Korean_InitFields	(iGlyphTPs, psLang);	break;
+					case 1: m_iAsianGlyphsAcross = Taiwanese_InitFields	(iGlyphTPs, psLang);	break;
+					case 2: m_iAsianGlyphsAcross = Japanese_InitFields	(iGlyphTPs, psLang);	break;
+					case 3: m_iAsianGlyphsAcross = Chinese_InitFields	(iGlyphTPs, psLang);	break;
+					case 4: m_iAsianGlyphsAcross = Thai_InitFields		(iGlyphTPs, psLang);	
+					{
+						// additional files needed for Thai language...
+						//						
+						FS_FOpenFileRead( sFILENAME_THAI_WIDTHS , &f, qfalse );
+						if (f) {
+							FS_FCloseFile( f );
+						}
+
+						FS_FOpenFileRead( sFILENAME_THAI_CODES, &f, qfalse );
+						if (f) {
+							FS_FCloseFile( f );
+						}					
+					}
+                    break;
+				}
+
+				for (int i=0; i<iGlyphTPs; i++)
+				{
+					Com_sprintf(sTemp,sizeof(sTemp), "fonts/%s_%d_1024_%d.tga", psLang, 1024/m_iAsianGlyphsAcross, i);
+
+					// RE_RegisterShaderNoMip( sTemp );	// don't actually need to load it, so...					
+					FS_FOpenFileRead( sTemp, &f, qfalse );
+					if (f) {
+						FS_FCloseFile( f );
+					}
+				}
+			}
+		}
+	}
+}
+
+void CFontInfo::UpdateAsianIfNeeded( bool bForceReEval /* = false */ )
+{
+	// if asian language, then provide an alternative glyph set and fill in relevant fields...
+	//
+	if (mHeight && !m_bIsFakeAlienLanguage)	// western charset exists in first place, and isn't alien rubbish?
+	{
+		Language_e eLanguage = GetLanguageEnum();
+
+		if (eLanguage == eKorean || eLanguage == eTaiwanese || eLanguage == eJapanese || eLanguage == eChinese || eLanguage == eThai)
+		{
+			int iCappedHeight = mHeight < 16 ? 16: mHeight;	// arbitrary limit on small char sizes because Asian chars don't squash well
+
+			if (m_iLanguageModificationCount != se_language->modificationCount || !AsianGlyphsAvailable() || bForceReEval)
+			{
+				m_iLanguageModificationCount  = se_language->modificationCount;
+
+				int iGlyphTPs = 0;
+				const char *psLang = NULL;
+
+				switch ( eLanguage )
+				{
+					case eKorean:		m_iAsianGlyphsAcross = Korean_InitFields(iGlyphTPs, psLang);	break;
+					case eTaiwanese:	m_iAsianGlyphsAcross = Taiwanese_InitFields(iGlyphTPs, psLang);	break;
+					case eJapanese:		m_iAsianGlyphsAcross = Japanese_InitFields(iGlyphTPs, psLang);	break;
+					case eChinese:		m_iAsianGlyphsAcross = Chinese_InitFields(iGlyphTPs, psLang);	break;
+					case eThai:
+					{
+						m_iAsianGlyphsAcross = Thai_InitFields(iGlyphTPs, psLang);
+
+						if (!m_pThaiData)
+						{
+							LPCSTR psFailureReason = g_ThaiCodes.Init();
+							if (!psFailureReason[0])
+							{
+								m_pThaiData = &g_ThaiCodes;
+							}
+							else
+							{
+								// failed to load a needed file, reset to English...
+								//
+								Cvar_Set("se_language", "english");
+								Com_Error( ERR_DROP, psFailureReason );
+							}
+						}
+					}
+					break;
+				}
+
+				// textures need loading...
+				//
+				if (m_sFontName[0])
+				{
+					// Use this sometime if we need to do logic to load alternate-height glyphs to better fit other fonts.
+					// (but for now, we just use the one glyph set)
+					//
+				}
+				
+				for (int i = 0; i < iGlyphTPs; i++)
+				{
+					// (Note!!  assumption for S,T calculations: all Asian glyph textures pages are square except for last one)
+					//
+					char sTemp[MAX_QPATH];
+					Com_sprintf(sTemp,sizeof(sTemp), "fonts/%s_%d_1024_%d", psLang, 1024/m_iAsianGlyphsAcross, i);
+					//
+					// returning 0 here will automatically inhibit Asian glyph calculations at runtime...
+					//
+					m_hAsianShaders[i] = RE_RegisterShaderNoMip( sTemp );
+				}
+			
+				// for now I'm hardwiring these, but if we ever have more than one glyph set per language then they'll be changed...
+				//
+				m_iAsianPagesLoaded = iGlyphTPs;	// not necessarily true, but will be safe, and show up obvious if something missing
+				m_bAsianLastPageHalfHeight = true;
+
+				bForceReEval = true;
+			}
+
+			if (bForceReEval)
+			{			
+				// now init the Asian member glyph fields to make them come out the same size as the western ones
+				//	that they serve as an alternative for...
+				//
+				m_AsianGlyph.width			= iCappedHeight;	// square Asian chars same size as height of western set
+				m_AsianGlyph.height			= iCappedHeight;	// ""
+				switch (eLanguage)
+				{
+					default:		m_AsianGlyph.horizAdvance	= iCappedHeight;	break;
+					case eKorean:	m_AsianGlyph.horizAdvance	= iCappedHeight - 1;break;	// korean has a small amount of space at the edge of the glyph
+
+					case eTaiwanese:
+					case eJapanese:
+					case eChinese:	m_AsianGlyph.horizAdvance	= iCappedHeight + 3;	// need to force some spacing for these
+//					case eThai:	// this is done dynamically elsewhere, since Thai glyphs are variable width
+				}
+				m_AsianGlyph.horizOffset	= 0;				// ""
+				m_AsianGlyph.baseline		= mAscender + ((iCappedHeight - mHeight) >> 1);
+			}
+		}
+		else
+		{
+			// not using Asian...
+			//
+			FlagNoAsianGlyphs();
+		}
+	}
+	else
+	{			
+		// no western glyphs available, so don't attempt to match asian...
+		//
+		FlagNoAsianGlyphs();
+	}
+}
+
+static CFontInfo *GetFont_Actual(int index)
+{
+	index &= SET_MASK;
+	if((index >= 1) && (index < g_iCurrentFontIndex))
+	{
+		CFontInfo *pFont = g_vFontArray[index];
+
+		if (pFont)
+		{
+			pFont->UpdateAsianIfNeeded();
+		}
+
+		return pFont;
+	}
+	return(NULL);
+}
+
+
+// needed to add *piShader param because of multiple TPs, 
+//	if not passed in, then I also skip S,T calculations for re-usable static asian glyphinfo struct...
+//
+const glyphInfo_t *CFontInfo::GetLetter(const unsigned int uiLetter, int *piShader /* = NULL */)
+{ 	
+	if ( AsianGlyphsAvailable() )
+	{
+		int iCollapsedAsianCode = GetCollapsedAsianCode( uiLetter );
+		if (iCollapsedAsianCode)
+		{
+			if (piShader)
+			{
+				// (Note!!  assumption for S,T calculations: all asian glyph textures pages are square except for last one
+				//			which may or may not be half height) - but not for Thai
+				//				
+				int iTexturePageIndex = iCollapsedAsianCode / (m_iAsianGlyphsAcross * m_iAsianGlyphsAcross);
+
+				if (iTexturePageIndex > m_iAsianPagesLoaded)
+				{
+					assert(0);				// should never happen
+					iTexturePageIndex = 0;
+				}
+
+				int iOriginalCollapsedAsianCode = iCollapsedAsianCode;	// need to back this up (if Thai) for later
+				iCollapsedAsianCode -= iTexturePageIndex *  (m_iAsianGlyphsAcross * m_iAsianGlyphsAcross);
+
+				const int iColumn	= iCollapsedAsianCode % m_iAsianGlyphsAcross;
+				const int iRow		= iCollapsedAsianCode / m_iAsianGlyphsAcross;				
+				const bool bHalfT	= (iTexturePageIndex == (m_iAsianPagesLoaded - 1) && m_bAsianLastPageHalfHeight);
+				const int iAsianGlyphsDown = (bHalfT) ? m_iAsianGlyphsAcross / 2 : m_iAsianGlyphsAcross;
+
+				switch ( GetLanguageEnum() )
+				{
+					case eKorean:
+					default:					
+					{
+						m_AsianGlyph.s  = (float)( iColumn    ) / (float)m_iAsianGlyphsAcross;
+						m_AsianGlyph.t  = (float)( iRow       ) / (float)  iAsianGlyphsDown;
+						m_AsianGlyph.s2 = (float)( iColumn + 1) / (float)m_iAsianGlyphsAcross;				
+						m_AsianGlyph.t2 = (float)( iRow + 1   ) / (float)  iAsianGlyphsDown;
+					}
+					break;
+
+					case eTaiwanese:
+					{
+						m_AsianGlyph.s  = (float)(((1024 / m_iAsianGlyphsAcross) * ( iColumn    ))+1) / 1024.0f;
+						m_AsianGlyph.t  = (float)(((1024 / iAsianGlyphsDown    ) * ( iRow       ))+1) / 1024.0f;
+						m_AsianGlyph.s2 = (float)(((1024 / m_iAsianGlyphsAcross) * ( iColumn+1  ))  ) / 1024.0f;
+						m_AsianGlyph.t2 = (float)(((1024 / iAsianGlyphsDown    ) * ( iRow+1     ))  ) / 1024.0f;
+					}
+					break;
+
+					case eJapanese:
+					case eChinese:
+					{
+						m_AsianGlyph.s  = (float)(((1024 / m_iAsianGlyphsAcross) * ( iColumn    ))  ) / 1024.0f;
+						m_AsianGlyph.t  = (float)(((1024 / iAsianGlyphsDown    ) * ( iRow       ))  ) / 1024.0f;
+						m_AsianGlyph.s2 = (float)(((1024 / m_iAsianGlyphsAcross) * ( iColumn+1  ))-1) / 1024.0f;
+						m_AsianGlyph.t2 = (float)(((1024 / iAsianGlyphsDown    ) * ( iRow+1     ))-1) / 1024.0f;
+					}
+					break;
+
+					case eThai:
+					{
+						int iGlyphXpos = (1024 / m_iAsianGlyphsAcross) * ( iColumn );
+						int iGlyphWidth = g_ThaiCodes.GetWidth( iOriginalCollapsedAsianCode );
+
+						// very thai-specific language-code...
+						//
+						if (uiLetter == TIS_SARA_AM)
+						{
+							iGlyphXpos += 9;	// these are pixel coords on the source TP, so don't affect scaled output
+							iGlyphWidth= 20;	//
+						}
+						m_AsianGlyph.s  = (float)(iGlyphXpos) / 1024.0f;
+						m_AsianGlyph.t  = (float)(((1024 / iAsianGlyphsDown    ) * ( iRow       ))  ) / 1024.0f;						
+						// technically this .s2 line should be modified to blit only the correct width, but since
+						//	all Thai glyphs are up against the left edge of their cells and have blank to the cell
+						//	boundary then it's better to keep these calculations simpler...
+						
+						m_AsianGlyph.s2 = (float)(iGlyphXpos+iGlyphWidth) / 1024.0f;
+						m_AsianGlyph.t2 = (float)(((1024 / iAsianGlyphsDown    ) * ( iRow+1     ))-1) / 1024.0f;
+
+						// special addition for Thai, need to bodge up the width and advance fields...
+						//
+                        m_AsianGlyph.width = iGlyphWidth;
+						m_AsianGlyph.horizAdvance = iGlyphWidth + 1;
+					}
+					break;
+				}
+				*piShader = m_hAsianShaders[ iTexturePageIndex ];
+			}
+			return &m_AsianGlyph;
+		}
+	}
+
+	if (piShader)
+	{
+		*piShader = GetShader();
+	}
+
+	const glyphInfo_t *pGlyph = &mGlyphs[ uiLetter & 0xff ];
+	//
+	// SBCS language substitution?...
+	//
+	if ( m_fAltSBCSFontScaleFactor != -1 )
+	{
+		// sod it, use the asian glyph, that's fine...
+		//
+		memcpy(&m_AsianGlyph,pGlyph,sizeof(m_AsianGlyph));	// *before* changin pGlyph!
+
+//		CFontInfo *pOriginalFont = GetFont_Actual( this->m_iOriginalFontWhenSBCSOverriden );
+//		pGlyph = &pOriginalFont->mGlyphs[ uiLetter & 0xff ];		
+
+		#define ASSIGN_WITH_ROUNDING(_dst,_src) _dst = mbRoundCalcs ? Round( m_fAltSBCSFontScaleFactor * _src ) : m_fAltSBCSFontScaleFactor * (float)_src;
+
+		ASSIGN_WITH_ROUNDING( m_AsianGlyph.baseline,	pGlyph->baseline );
+		ASSIGN_WITH_ROUNDING( m_AsianGlyph.height,		pGlyph->height );
+		ASSIGN_WITH_ROUNDING( m_AsianGlyph.horizAdvance,pGlyph->horizAdvance );
+//		m_AsianGlyph.horizOffset	= /*Round*/( m_fAltSBCSFontScaleFactor * pGlyph->horizOffset );
+		ASSIGN_WITH_ROUNDING( m_AsianGlyph.width,		pGlyph->width );
+
+		pGlyph = &m_AsianGlyph;
+	}
+
+	return pGlyph;
+}
+
+const int CFontInfo::GetCollapsedAsianCode(ulong uiLetter) const
+{
+	int iCollapsedAsianCode = 0;
+
+	if (AsianGlyphsAvailable())
+	{
+		switch ( GetLanguageEnum() )
+		{
+			case eKorean:		iCollapsedAsianCode = Korean_CollapseKSC5601HangulCode( uiLetter );	break;
+			case eTaiwanese:	iCollapsedAsianCode = Taiwanese_CollapseBig5Code( uiLetter );		break;
+			case eJapanese:		iCollapsedAsianCode = Japanese_CollapseShiftJISCode( uiLetter );	break;
+			case eChinese:		iCollapsedAsianCode = Chinese_CollapseGBCode( uiLetter );			break;
+			case eThai:			iCollapsedAsianCode = Thai_CollapseTISCode( uiLetter );				break;
+			default:			assert(0);	/* unhandled asian language */							break;
+		}
+	}
+
+	return iCollapsedAsianCode;
+}
+
+const int CFontInfo::GetLetterWidth(unsigned int uiLetter)
+{
+	const glyphInfo_t *pGlyph = GetLetter( uiLetter );
+	return pGlyph->width ? pGlyph->width : mGlyphs['.'].width;
+}
+
+const int CFontInfo::GetLetterHorizAdvance(unsigned int uiLetter)
+{	
+	const glyphInfo_t *pGlyph = GetLetter( uiLetter );
+	return pGlyph->horizAdvance ? pGlyph->horizAdvance : mGlyphs['.'].horizAdvance;
+}
+
+// ensure any GetFont calls that need SBCS overriding (such as when playing in Russian) have the appropriate stuff done...
+//
+static CFontInfo *GetFont_SBCSOverride(CFontInfo *pFont, Language_e eLanguageSBCS, LPCSTR psLanguageNameSBCS )
+{
+	if ( !pFont->m_bIsFakeAlienLanguage )
+	{
+		if ( GetLanguageEnum() == eLanguageSBCS )
+		{
+			if ( pFont->m_iAltSBCSFont == -1 ) 	// no reg attempted yet?
+			{
+				// need to register this alternative SBCS font...
+				//
+				int iAltFontIndex = RE_RegisterFont( va("%s/%s",COM_SkipPath(pFont->m_sFontName),psLanguageNameSBCS) );	// ensure unique name (eg: "lcd/russian")
+				CFontInfo *pAltFont = GetFont_Actual( iAltFontIndex );
+				if ( pAltFont )
+				{
+					// work out the scaling factor for this font's glyphs...( round it to 1 decimal place to cut down on silly scale factors like 0.53125 )
+					//
+					pAltFont->m_fAltSBCSFontScaleFactor = RoundTenth((float)pFont->GetPointSize() / (float)pAltFont->GetPointSize());
+					//
+					// then override with the main properties of the original font...
+					//
+					pAltFont->mPointSize = pFont->GetPointSize();//(float) pAltFont->GetPointSize() * pAltFont->m_fAltSBCSFontScaleFactor;
+					pAltFont->mHeight	 = pFont->GetHeight();//(float) pAltFont->GetHeight()	* pAltFont->m_fAltSBCSFontScaleFactor;
+					pAltFont->mAscender	 = pFont->GetAscender();//(float) pAltFont->GetAscender()	* pAltFont->m_fAltSBCSFontScaleFactor;
+					pAltFont->mDescender = pFont->GetDescender();//(float) pAltFont->GetDescender()	* pAltFont->m_fAltSBCSFontScaleFactor;
+
+//					pAltFont->mPointSize = (float) pAltFont->GetPointSize() * pAltFont->m_fAltSBCSFontScaleFactor;
+//					pAltFont->mHeight	 = (float) pAltFont->GetHeight()	* pAltFont->m_fAltSBCSFontScaleFactor;
+//					pAltFont->mAscender	 = (float) pAltFont->GetAscender()	* pAltFont->m_fAltSBCSFontScaleFactor;
+//					pAltFont->mDescender = (float) pAltFont->GetDescender()	* pAltFont->m_fAltSBCSFontScaleFactor;
+
+					pAltFont->mbRoundCalcs = true;
+					pAltFont->m_iOriginalFontWhenSBCSOverriden = pFont->m_iThisFont;
+				}
+				pFont->m_iAltSBCSFont = iAltFontIndex;
+			}
+
+			if ( pFont->m_iAltSBCSFont > 0)
+			{
+				return GetFont_Actual( pFont->m_iAltSBCSFont );
+			}
+		}
+	}
+
+	return NULL;
+}
+
+
+
+CFontInfo *GetFont(int index)
+{
+	CFontInfo *pFont = GetFont_Actual( index );
+
+	if (pFont)
+	{
+		// any SBCS overrides? (this has to be pretty quick, and is (sort of))...
+		//
+		for (int i=0; g_SBCSOverrideLanguages[i].m_psName; i++)
+		{
+			CFontInfo *pAltFont = GetFont_SBCSOverride( pFont, g_SBCSOverrideLanguages[i].m_eLanguage, g_SBCSOverrideLanguages[i].m_psName );
+			if (pAltFont) 
+			{
+				return pAltFont;
+			}
+		}
+	}
+
+	return pFont;
+}
+
+
+int RE_Font_StrLenPixels(const char *psText, const int iFontHandle, const float fScale)
+{			
+	int			iMaxWidth = 0;
+	int			iThisWidth= 0;
+	CFontInfo	*curfont;
+
+	curfont = GetFont(iFontHandle);
+	if(!curfont)
+	{
+		return(0);
+	}
+
+	float fScaleA = fScale;
+	if (Language_IsAsian() && fScale > 0.7f )
+	{
+		fScaleA = fScale * 0.75f;
+	}
+
+	while(*psText)
+	{
+		int iAdvanceCount;
+		unsigned int uiLetter = AnyLanguage_ReadCharFromString( psText, &iAdvanceCount, NULL );
+		psText += iAdvanceCount;
+
+		if (uiLetter == '^' )
+		{
+			if (*psText >= '0' &&
+				*psText <= '9')
+			{
+				uiLetter = AnyLanguage_ReadCharFromString( psText, &iAdvanceCount, NULL );
+				psText += iAdvanceCount;
+				continue;
+			}
+		}
+
+		if (uiLetter == 0x0A)
+		{
+			iThisWidth = 0;
+		}
+		else
+		{
+			int iPixelAdvance = curfont->GetLetterHorizAdvance( uiLetter );
+	
+			float fValue = iPixelAdvance * ((uiLetter > g_iNonScaledCharRange) ? fScaleA : fScale);
+			iThisWidth += curfont->mbRoundCalcs ? Round( fValue ) : fValue;
+			if (iThisWidth > iMaxWidth)
+			{
+				iMaxWidth = iThisWidth;
+			}
+		}
+	}
+
+	return iMaxWidth;
+}
+
+// not really a font function, but keeps naming consistant...
+//
+int RE_Font_StrLenChars(const char *psText)
+{			
+	// logic for this function's letter counting must be kept same in this function and RE_Font_DrawString()
+	//
+	int iCharCount = 0;
+
+	while ( *psText )
+	{
+		// in other words, colour codes and CR/LF don't count as chars, all else does...
+		//
+		int iAdvanceCount;
+		unsigned int uiLetter = AnyLanguage_ReadCharFromString( psText, &iAdvanceCount, NULL );
+		psText += iAdvanceCount;
+
+		switch (uiLetter)
+		{
+			case '^':
+				if (*psText >= '0' &&
+					*psText <= '9')
+				{
+					psText++;
+				}
+				else
+				{
+					iCharCount++;
+				}
+				break;	// colour code (note next-char skip)
+			case 10:								break;	// linefeed
+			case 13:								break;	// return 
+			case '_':	iCharCount += (GetLanguageEnum() == eThai && (((unsigned char *)psText)[0] >= TIS_GLYPHS_START))?0:1; break;	// special word-break hack
+			default:	iCharCount++;				break;
+		}
+	}
+	
+	return iCharCount;
+}
+
+int RE_Font_HeightPixels(const int iFontHandle, const float fScale)
+{			
+	CFontInfo	*curfont;
+
+	curfont = GetFont(iFontHandle);
+	if(curfont)
+	{
+		float fValue = curfont->GetPointSize() * fScale;
+		return curfont->mbRoundCalcs ? Round(fValue) : fValue;
+	}
+	return(0);
+}
+
+// iMaxPixelWidth is -1 for "all of string", else pixel display count...
+//
+void RE_Font_DrawString(int ox, int oy, const char *psText, const float *rgba, const int iFontHandle, int iMaxPixelWidth, const float fScale)
+{
+	static qboolean gbInShadow = qfalse;	// MUST default to this
+	int					x, y, colour, offset;
+	const glyphInfo_t	*pLetter;
+	qhandle_t			hShader;
+
+	assert (psText);
+
+	if(iFontHandle & STYLE_BLINK)
+	{
+		if((Sys_Milliseconds() >> 7) & 1)
+		{
+			return;
+		}
+	}
+
+//	// test code only
+//	if (GetLanguageEnum() == eTaiwanese)
+//	{
+//		psText = "Wp:¶}·F§a ¿p·G´µ¡A§Æ±æ§A¹³¥L­Ì»¡ªº¤@¼Ë¦æ¡C";
+//	}
+//	else 
+//	if (GetLanguageEnum() == eChinese)
+//	{
+//		//psText = "Ó¶±øÕ½³¡II  Ô¼º²?ĪÁÖ˹  ÈÎÎñʧ°Ü  ÄãÒªÌ×Óû­ÃæÉ趨µÄ±ä¸üÂ𣿠 Ô¤Éè,S3 ѹËõ,DXT1 ѹËõ,DXT5 ѹËõ,16 Bit,32 Bit";
+//		psText = "Ó¶±øÕ½³¡II";
+//	}
+//	else 
+//	if (GetLanguageEnum() == eThai)
+//	{
+//		//psText = "Áҵðҹ¼ÅÔµÀѳ±ìÍصÊÒË¡ÃÃÁÃËÑÊÊÓËÃѺÍÑ¡¢ÃÐä·Â·Õèãªé¡Ñº¤ÍÁ¾ÔÇàµÍÃì";
+//		psText = "Áҵðҹ¼ÅÔµ";
+//		psText = "ÃËÑÊÊÓËÃѺ";
+//		psText = "ÃËÑÊÊÓËÃѺ   ÍÒ_¡Ô¹_¤ÍÃì·_1415";
+//	}
+//	else
+//	if (GetLanguageEnum() == eKorean)
+//	{
+//		psText = "Wp:¼îŸÀÓÀÌ´Ù ¸Ö¸°. ±×µéÀÌ ¸»ÇÑ´ë·Î ³×°¡ ÀßÇÒÁö ±â´ëÇÏ°Ú´Ù.";
+//	}
+//	else
+//	if (GetLanguageEnum() == eJapanese)
+//	{
+//		static char sBlah[200];
+//		sprintf(sBlah,va("%c%c%c%c%c%c%c%c",0x82,0xA9,0x82,0xC8,0x8A,0xBF,0x8E,0x9A));
+//		psText = &sBlah[0];
+//	}
+//	else
+//	if (GetLanguageEnum() == eRussian)
+//	{
+////		//psText = "Íà âåðøèíå õîëìà ñòîèò ñòàðûé äîì ñ ïðèâèäåíèÿìè è áàøíÿ ñ âîëøåáíûìè ÷àñàìè."
+//		psText = "Íà âåðøèíå õîëìà ñòîèò";
+//	}
+//	else
+//	if (GetLanguageEnum() == ePolish)
+//	{
+//		psText = "za³o¿ony w 1364 roku, jest najstarsz¹ polsk¹ uczelni¹ i nale¿y...";
+//		psText = "za³o¿ony nale¿y";
+//	}
+
+
+	CFontInfo *curfont = GetFont(iFontHandle);
+	if(!curfont || !psText)
+	{
+		return;
+	}
+
+	float fScaleA = fScale;
+	int iAsianYAdjust = 0;
+	if (Language_IsAsian() && fScale > 0.7f)
+	{
+		fScaleA = fScale * 0.75f;
+		iAsianYAdjust = /*Round*/((((float)curfont->GetPointSize() * fScale) - ((float)curfont->GetPointSize() * fScaleA))/2);
+	}
+
+	// Draw a dropshadow if required
+	if(iFontHandle & STYLE_DROPSHADOW)
+	{
+		offset = Round(curfont->GetPointSize() * fScale * 0.075f);
+
+		static const vec4_t v4DKGREY2 = {0.15f, 0.15f, 0.15f, 1};
+
+		gbInShadow = qtrue;
+		RE_Font_DrawString(ox + offset, oy + offset, psText, v4DKGREY2, iFontHandle & SET_MASK, iMaxPixelWidth, fScale);
+		gbInShadow = qfalse;
+	}
+		
+	RE_SetColor( rgba );
+
+	x = ox;
+	oy += Round((curfont->GetHeight() - (curfont->GetDescender() >> 1)) * fScale);
+
+	qboolean bNextTextWouldOverflow = qfalse;
+	while (*psText && !bNextTextWouldOverflow)
+	{
+		int iAdvanceCount;
+		unsigned int uiLetter = AnyLanguage_ReadCharFromString( psText, &iAdvanceCount, NULL );
+		psText += iAdvanceCount;
+
+		switch( uiLetter )
+		{
+		case 10:						//linefeed
+			x = ox;
+			oy += Round(curfont->GetPointSize() * fScale);
+			if (Language_IsAsian())
+			{
+				oy += 4;	// this only comes into effect when playing in asian for "A long time ago in a galaxy" etc, all other text is line-broken in feeder functions
+			}
+			break;
+		case 13:						// Return
+			break;
+		case 32:						// Space
+			pLetter = curfont->GetLetter(' ');			
+			x += Round(pLetter->horizAdvance * fScale);
+			bNextTextWouldOverflow = ( iMaxPixelWidth != -1 && ((x-ox)>iMaxPixelWidth) ) ? qtrue : qfalse;	// yeuch
+			break;
+		case '_':	// has a special word-break usage if in Thai (and followed by a thai char), and should not be displayed, else treat as normal
+			if (GetLanguageEnum()== eThai && ((unsigned char *)psText)[0] >= TIS_GLYPHS_START)
+			{
+				break;
+			}
+			// else drop through and display as normal...
+		case '^':
+			if (uiLetter != '_')	// necessary because of fallthrough above
+			{
+				if (*psText >= '0' &&
+					*psText <= '9')
+				{
+					colour = ColorIndex(*psText++);
+					if (!gbInShadow)
+					{
+						RE_SetColor( g_color_table[colour] );
+					}
+					break;
+				}
+			}
+			//purposely falls thrugh
+		default:
+			pLetter = curfont->GetLetter( uiLetter, &hShader );			// Description of pLetter
+			if(!pLetter->width)
+			{
+				pLetter = curfont->GetLetter('.');
+			}
+
+			float fThisScale = uiLetter > g_iNonScaledCharRange ? fScaleA : fScale;
+
+			// sigh, super-language-specific hack...
+			//
+			if (uiLetter == TIS_SARA_AM && GetLanguageEnum() == eThai)
+			{
+				x -= Round(7 * fThisScale);
+			}
+
+			int iAdvancePixels = Round(pLetter->horizAdvance * fThisScale);
+			bNextTextWouldOverflow = ( iMaxPixelWidth != -1 && (((x+iAdvancePixels)-ox)>iMaxPixelWidth) ) ? qtrue : qfalse;	// yeuch
+			if (!bNextTextWouldOverflow)
+			{
+				// this 'mbRoundCalcs' stuff is crap, but the only way to make the font code work. Sigh...
+				//				
+				y = oy - (curfont->mbRoundCalcs ? Round(pLetter->baseline * fThisScale) : pLetter->baseline * fThisScale);
+				if (curfont->m_fAltSBCSFontScaleFactor != -1)
+				{
+					y+=3;	// I'm sick and tired of going round in circles trying to do this legally, so bollocks to it
+				}
+
+				RE_StretchPic ( x + Round(pLetter->horizOffset * fScale), // float x
+								(uiLetter > g_iNonScaledCharRange) ? y - iAsianYAdjust : y,	// float y
+								curfont->mbRoundCalcs ? Round(pLetter->width * fThisScale) : pLetter->width * fThisScale,	// float w
+								curfont->mbRoundCalcs ? Round(pLetter->height * fThisScale) : pLetter->height * fThisScale, // float h
+								pLetter->s,						// float s1
+								pLetter->t,						// float t1
+								pLetter->s2,					// float s2
+								pLetter->t2,					// float t2
+								//lastcolour.c, 
+								hShader							// qhandle_t hShader
+								);
+
+				x += iAdvancePixels;
+			}
+			break;
+		}		
+	}
+	//let it remember the old color //RE_SetColor(NULL);;
+}
+
+int RE_RegisterFont(const char *psName) 
+{
+	FontIndexMap_t::iterator it = g_mapFontIndexes.find(psName);
+	if (it != g_mapFontIndexes.end() )
+	{
+		int iFontIndex = (*it).second;
+		return iFontIndex;
+	}
+
+	// not registered, so...
+	//
+	{
+		CFontInfo *pFont = new CFontInfo(psName);
+		if (pFont->GetPointSize() > 0)
+		{
+			int iFontIndex = g_iCurrentFontIndex - 1;
+			g_mapFontIndexes[psName] = iFontIndex;
+			pFont->m_iThisFont = iFontIndex;
+			return iFontIndex;
+		}
+		else
+		{
+			g_mapFontIndexes[psName] = 0;	// missing/invalid
+		}
+	}
+
+	return 0;
+}
+
+void R_InitFonts(void)
+{
+	g_iCurrentFontIndex = 1;			// entry 0 is reserved for "missing/invalid"
+	g_iNonScaledCharRange = INT_MAX;	// default all chars to have no special scaling (other than user supplied)
+}
+
+void R_ShutdownFonts(void)
+{
+	for(int i = 1; i < g_iCurrentFontIndex; i++)	// entry 0 is reserved for "missing/invalid"
+	{
+		delete g_vFontArray[i];
+	}
+	g_mapFontIndexes.clear();
+	g_vFontArray.clear();
+	g_iCurrentFontIndex = 1;	// entry 0 is reserved for "missing/invalid"
+
+	g_ThaiCodes.Clear();
+}
+
+// this is only really for debugging while tinkering with fonts, but harmless to leave in...
+//
+void R_ReloadFonts_f(void)
+{
+	// first, grab all the currently-registered fonts IN THE ORDER THEY WERE REGISTERED...
+	//
+	vector <sstring_t> vstrFonts;
+
+	for (int iFontToFind = 1; iFontToFind < g_iCurrentFontIndex; iFontToFind++)
+	{		
+		for (FontIndexMap_t::iterator it = g_mapFontIndexes.begin(); it != g_mapFontIndexes.end(); ++it)
+		{
+			if (iFontToFind == (*it).second)
+			{
+				vstrFonts.push_back( (*it).first );
+				break;
+			}
+		}
+		if ( it == g_mapFontIndexes.end() )
+		{
+			break;	// couldn't find this font
+		}
+	}
+	if ( iFontToFind == g_iCurrentFontIndex ) // found all of them?
+	{
+		// now restart the font system...
+		//
+		R_ShutdownFonts();
+		R_InitFonts();
+		//
+		// and re-register our fonts in the same order as before (note that some menu items etc cache the string lengths so really a vid_restart is better, but this is just for my testing)
+		//
+		for (int iFont = 0; iFont < vstrFonts.size(); iFont++)
+		{
+#ifdef _DEBUG
+			int iNewFontHandle = RE_RegisterFont( vstrFonts[iFont].c_str() );
+			assert( iNewFontHandle == iFont+1 );
+#else
+			RE_RegisterFont( vstrFonts[iFont].c_str() );
+#endif
+		}
+		Com_Printf( "Done.\n" );
+	}
+	else
+	{
+		Com_Printf( "Problem encountered finding current fonts, ignoring.\n" );	// poo. Oh well, forget it.
+	}
+}
+
+
+// end
diff --git a/code/renderer/tr_font.h b/code/renderer/tr_font.h
new file mode 100644
index 0000000..f46e611
--- /dev/null
+++ b/code/renderer/tr_font.h
@@ -0,0 +1,34 @@
+// Filename:-	tr_font.h
+//
+// font support 
+
+// This file is shared in the single and multiplayer codebases, so be CAREFUL WHAT YOU ADD/CHANGE!!!!!
+
+#ifndef TR_FONT_H
+#define TR_FONT_H
+
+
+void R_ShutdownFonts(void);
+void R_InitFonts(void);
+int RE_RegisterFont(const char *psName);
+int RE_Font_StrLenPixels(const char *psText, const int iFontHandle, const float fScale = 1.0f);
+int RE_Font_StrLenChars(const char *psText);
+int RE_Font_HeightPixels(const int iFontHandle, const float fScale = 1.0f);
+void RE_Font_DrawString(int ox, int oy, const char *psText, const float *rgba, const int iFontHandle, int iMaxPixelWidth, const float fScale = 1.0f);
+
+// Dammit, I can't use this more elegant form because of !@#@!$%% VM code... (can't alter passed in ptrs, only contents of)
+//
+//unsigned int AnyLanguage_ReadCharFromString( const char **ppsText, qboolean *pbIsTrailingPunctuation = NULL);
+//
+// so instead we have to use this messier method...
+//
+unsigned int AnyLanguage_ReadCharFromString( const char *psText, int *piAdvanceCount, qboolean *pbIsTrailingPunctuation = NULL);
+
+qboolean Language_IsAsian(void);
+qboolean Language_UsesSpaces(void);
+
+
+#endif	// #ifndef TR_FONT_H
+
+// end
+
diff --git a/code/renderer/tr_ghoul2.cpp b/code/renderer/tr_ghoul2.cpp
new file mode 100644
index 0000000..5e77015
--- /dev/null
+++ b/code/renderer/tr_ghoul2.cpp
@@ -0,0 +1,4374 @@
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+
+ 
+#include "../client/client.h"	//FIXME!! EVIL - just include the definitions needed 
+#include "../client/vmachine.h"
+
+#ifdef _XBOX
+#include "../qcommon/miniheap.h"
+#endif
+						  
+#if !defined(TR_LOCAL_H)
+	#include "tr_local.h"
+#endif
+
+#include "MatComp.h"
+#if !defined(_QCOMMON_H_)
+	#include "../qcommon/qcommon.h"
+#endif
+#if !defined(G2_H_INC)
+	#include "../ghoul2/G2.h"
+#endif
+
+#ifdef _G2_GORE
+#include "../ghoul2/ghoul2_gore.h"
+#endif
+
+#ifdef VV_LIGHTING
+#include "tr_lightmanager.h"
+#endif
+
+#define	LL(x) x=LittleLong(x)
+
+#ifdef G2_PERFORMANCE_ANALYSIS
+#include "../qcommon/timing.h"
+timing_c G2PerformanceTimer_RB_SurfaceGhoul;
+
+int G2PerformanceCounter_G2_TransformGhoulBones = 0;
+
+int G2Time_RB_SurfaceGhoul = 0;
+
+void G2Time_ResetTimers(void)
+{
+	G2Time_RB_SurfaceGhoul = 0;
+	G2PerformanceCounter_G2_TransformGhoulBones = 0;
+}
+
+void G2Time_ReportTimers(void)
+{
+	Com_Printf("\n---------------------------------\nRB_SurfaceGhoul: %i\nTransformGhoulBones calls: %i\n---------------------------------\n\n",
+		G2Time_RB_SurfaceGhoul,
+		G2PerformanceCounter_G2_TransformGhoulBones
+	);
+}
+#endif
+
+//rww - RAGDOLL_BEGIN
+#include <FLOAT.H>
+//rww - RAGDOLL_END
+
+extern	cvar_t	*r_Ghoul2UnSqash;
+extern	cvar_t	*r_Ghoul2AnimSmooth;
+extern	cvar_t	*r_Ghoul2NoLerp;
+extern	cvar_t	*r_Ghoul2NoBlend;
+extern	cvar_t	*r_Ghoul2UnSqashAfterSmooth;
+
+bool HackadelicOnClient=false; // means this is a render traversal
+
+// I hate doing this, but this is the simplest way to get this into the routines it needs to be
+mdxaBone_t		worldMatrix;
+mdxaBone_t		worldMatrixInv;
+#ifdef _G2_GORE
+qhandle_t		goreShader=-1;
+#endif
+
+const static mdxaBone_t		identityMatrix = 
+{ 
+	0.0f, -1.0f, 0.0f, 0.0f,
+	1.0f, 0.0f, 0.0f, 0.0f,
+	0.0f, 0.0f, 1.0f, 0.0f
+};
+
+class CTransformBone
+{
+public:
+#ifdef _XBOX
+	float			renderMatrix[16];
+#endif
+	//rww - RAGDOLL_BEGIN
+	int				touchRender;
+	//rww - RAGDOLL_END
+	mdxaBone_t		boneMatrix; //final matrix
+	int				parent; // only set once
+	int				touch; // for minimal recalculation
+#ifdef _XBOX
+	// This shouldn't be done like this. use declspec(aligned)?!
+	int				pad[1]; // must be 16-byte aligned!
+#endif
+	CTransformBone()
+	{
+		touch=0;
+	//rww - RAGDOLL_BEGIN
+		touchRender = 0;
+	//rww - RAGDOLL_END
+	}
+
+};
+
+struct SBoneCalc
+{
+	int				newFrame;
+	int				currentFrame;
+	float			backlerp;
+	float			blendFrame;
+	int				blendOldFrame;
+	bool			blendMode;
+	float			blendLerp;
+};
+
+class CBoneCache;
+void G2_TransformBone(int index,CBoneCache &CB);
+
+class CBoneCache
+{
+	void SetRenderMatrix(CTransformBone *bone)
+	{
+#ifdef _XBOX
+		float *src = bone->boneMatrix.matrix[0];
+		float *dst = bone->renderMatrix;
+		
+		dst[0] = src[0];
+		dst[1] = src[4];
+		dst[2] = src[8];
+		dst[3] = 0;
+		
+		dst[4] = src[1];
+		dst[5] = src[5];
+		dst[6] = src[9];
+		dst[7] = 0;
+		
+		dst[8] = src[2];
+		dst[9] = src[6];
+		dst[10] = src[10];
+		dst[11] = 0;
+		
+		dst[12] = src[3];
+		dst[13] = src[7];
+		dst[14] = src[11];
+		dst[15] = 1;
+#endif
+	}
+
+	void EvalLow(int index)
+	{
+		assert(index>=0&&index<mNumBones);
+		if (mFinalBones[index].touch!=mCurrentTouch)
+		{
+			// need to evaluate the bone
+			assert((mFinalBones[index].parent>=0&&mFinalBones[index].parent<mNumBones)||(index==0&&mFinalBones[index].parent==-1));
+			if (mFinalBones[index].parent>=0)
+			{
+				EvalLow(mFinalBones[index].parent); // make sure parent is evaluated
+				SBoneCalc &par=mBones[mFinalBones[index].parent];
+				mBones[index].newFrame=par.newFrame;
+				mBones[index].currentFrame=par.currentFrame;
+				mBones[index].backlerp=par.backlerp;
+				mBones[index].blendFrame=par.blendFrame;
+				mBones[index].blendOldFrame=par.blendOldFrame;
+				mBones[index].blendMode=par.blendMode;
+				mBones[index].blendLerp=par.blendLerp;
+			}
+			G2_TransformBone(index,*this);
+			SetRenderMatrix(mFinalBones + index);
+			mFinalBones[index].touch=mCurrentTouch;
+		}
+	}
+//rww - RAGDOLL_BEGIN
+	void SmoothLow(int index)
+	{
+		if (mSmoothBones[index].touch==mLastTouch)
+		{
+			int i;
+			float *oldM=&mSmoothBones[index].boneMatrix.matrix[0][0];
+			float *newM=&mFinalBones[index].boneMatrix.matrix[0][0];
+			for (i=0;i<12;i++,oldM++,newM++)
+			{
+				*oldM=mSmoothFactor*(*oldM-*newM)+*newM;
+			}
+		}
+		else
+		{
+			memcpy(&mSmoothBones[index].boneMatrix,&mFinalBones[index].boneMatrix,sizeof(mdxaBone_t));
+		}
+		mdxaSkelOffsets_t *offsets = (mdxaSkelOffsets_t *)((byte *)header + sizeof(mdxaHeader_t));
+		mdxaSkel_t *skel = (mdxaSkel_t *)((byte *)header + sizeof(mdxaHeader_t) + offsets->offsets[index]);
+		mdxaBone_t tempMatrix;
+		Multiply_3x4Matrix(&tempMatrix,&mSmoothBones[index].boneMatrix, &skel->BasePoseMat);
+		float maxl;
+		maxl=VectorLength(&skel->BasePoseMat.matrix[0][0]);
+		VectorNormalize(&tempMatrix.matrix[0][0]);
+		VectorNormalize(&tempMatrix.matrix[1][0]);
+		VectorNormalize(&tempMatrix.matrix[2][0]);
+
+		VectorScale(&tempMatrix.matrix[0][0],maxl,&tempMatrix.matrix[0][0]);
+		VectorScale(&tempMatrix.matrix[1][0],maxl,&tempMatrix.matrix[1][0]);
+		VectorScale(&tempMatrix.matrix[2][0],maxl,&tempMatrix.matrix[2][0]);
+		Multiply_3x4Matrix(&mSmoothBones[index].boneMatrix,&tempMatrix,&skel->BasePoseMatInv);
+		// Added by BTO (VV) - I hope this is right.
+		SetRenderMatrix(mSmoothBones + index);
+		mSmoothBones[index].touch=mCurrentTouch;
+#ifdef _DEBUG
+		for ( int i = 0; i < 3; i++ )
+		{
+			for ( int j = 0; j < 4; j++ )
+			{
+				assert( !_isnan(mSmoothBones[index].boneMatrix.matrix[i][j]));
+			}
+		}
+#endif// _DEBUG
+	}
+//rww - RAGDOLL_END
+public:
+	int					frameSize; 
+	const mdxaHeader_t	*header; 
+	const model_t		*mod; 
+
+	// these are split for better cpu cache behavior
+	SBoneCalc *mBones;
+	CTransformBone *mFinalBones;
+
+	CTransformBone *mSmoothBones; // for render smoothing
+	mdxaSkel_t **mSkels;
+
+	int				mNumBones;
+
+	boneInfo_v		*rootBoneList;
+	mdxaBone_t		rootMatrix;
+	int				incomingTime;
+
+	int				mCurrentTouch;
+	//rww - RAGDOLL_BEGIN
+	int				mCurrentTouchRender;
+	int				mLastTouch; 
+	int				mLastLastTouch;
+	//rww - RAGDOLL_END
+
+	// for render smoothing
+	bool			mSmoothingActive;
+	bool			mUnsquash;
+	float			mSmoothFactor;
+//	int				mWraithID; // this is just used for debug prints, can use it for any int of interest in JK2
+
+	CBoneCache(const model_t *amod,const mdxaHeader_t *aheader) :
+		mod(amod),
+		header(aheader)
+	{
+		assert(amod);
+		assert(aheader);
+		mSmoothingActive=false;
+		mUnsquash=false;
+		mSmoothFactor=0.0f;
+
+		mNumBones = header->numBones;
+		mBones = new SBoneCalc[mNumBones];
+		mFinalBones = (CTransformBone*)Z_Malloc(sizeof(CTransformBone) * mNumBones, TAG_GHOUL2, qtrue, 16);
+		mSmoothBones = (CTransformBone*)Z_Malloc(sizeof(CTransformBone) * mNumBones, TAG_GHOUL2, qtrue, 16);
+		mSkels = new mdxaSkel_t*[mNumBones];
+		mdxaSkelOffsets_t *offsets;
+		mdxaSkel_t		*skel;
+		offsets = (mdxaSkelOffsets_t *)((byte *)header + sizeof(mdxaHeader_t));
+
+		int i;
+		for (i=0;i<mNumBones;i++)
+		{
+			skel = (mdxaSkel_t *)((byte *)header + sizeof(mdxaHeader_t) + offsets->offsets[i]);
+			mSkels[i]=skel;
+			mFinalBones[i].parent=skel->parent;
+		}
+		mCurrentTouch=3;
+//rww - RAGDOLL_BEGIN
+		mLastTouch=2;
+		mLastLastTouch=1;
+//rww - RAGDOLL_END
+	}
+	~CBoneCache ()
+	{
+		delete [] mBones;
+		// Alignment
+		Z_Free(mFinalBones);
+		Z_Free(mSmoothBones);
+		delete [] mSkels;
+	}
+
+	SBoneCalc &Root()
+	{
+		assert(mNumBones);
+		return mBones[0];
+	}
+	const mdxaBone_t &EvalUnsmooth(int index)
+	{
+		EvalLow(index);
+		if (mSmoothingActive&&mSmoothBones[index].touch)
+		{
+			return mSmoothBones[index].boneMatrix;
+		}
+		return mFinalBones[index].boneMatrix;
+	}
+	const mdxaBone_t &Eval(int index)
+	{
+		/*
+		bool wasEval=EvalLow(index);
+		if (mSmoothingActive)
+		{
+			if (mSmoothBones[index].touch!=incomingTime||wasEval)
+			{
+				float dif=float(incomingTime)-float(mSmoothBones[index].touch);
+				if (mSmoothBones[index].touch&&dif<300.0f)
+				{
+
+					if (dif<16.0f)  // 60 fps
+					{
+						dif=16.0f;
+					}
+					if (dif>100.0f) // 10 fps
+					{
+						dif=100.0f;
+					}
+					float f=1.0f-pow(1.0f-mSmoothFactor,16.0f/dif);
+
+					int i;
+					float *oldM=&mSmoothBones[index].boneMatrix.matrix[0][0];
+					float *newM=&mFinalBones[index].boneMatrix.matrix[0][0];
+					for (i=0;i<12;i++,oldM++,newM++)
+					{
+						*oldM=f*(*oldM-*newM)+*newM;
+					}
+					if (mUnsquash)
+					{
+						mdxaBone_t tempMatrix;
+						Multiply_3x4Matrix(&tempMatrix,&mSmoothBones[index].boneMatrix, &mSkels[index]->BasePoseMat);
+						float maxl;
+						maxl=VectorLength(&mSkels[index]->BasePoseMat.matrix[0][0]);
+						VectorNormalizeFast(&tempMatrix.matrix[0][0]);
+						VectorNormalizeFast(&tempMatrix.matrix[1][0]);
+						VectorNormalizeFast(&tempMatrix.matrix[2][0]);
+
+						VectorScale(&tempMatrix.matrix[0][0],maxl,&tempMatrix.matrix[0][0]);
+						VectorScale(&tempMatrix.matrix[1][0],maxl,&tempMatrix.matrix[1][0]);
+						VectorScale(&tempMatrix.matrix[2][0],maxl,&tempMatrix.matrix[2][0]);
+						Multiply_3x4Matrix(&mSmoothBones[index].boneMatrix,&tempMatrix,&mSkels[index]->BasePoseMatInv);
+					}
+				}
+				else
+				{
+					memcpy(&mSmoothBones[index].boneMatrix,&mFinalBones[index].boneMatrix,sizeof(mdxaBone_t));
+				}
+				SetRenderMatrix(mSmoothBones + index);
+				mSmoothBones[index].touch=incomingTime;
+			}
+			return mSmoothBones[index].boneMatrix;
+		}
+		return mFinalBones[index].boneMatrix;
+		*/
+		//all above is not necessary, smoothing is taken care of when we want to use smoothlow (only when evalrender)
+		assert(index>=0&&index<mNumBones);
+		if (mFinalBones[index].touch!=mCurrentTouch)
+		{
+			EvalLow(index);
+		}
+		return mFinalBones[index].boneMatrix;
+	}
+	//rww - RAGDOLL_BEGIN
+	const inline mdxaBone_t &EvalRender(int index)
+	{
+		assert(index>=0&&index<mNumBones);
+		if (mFinalBones[index].touch!=mCurrentTouch)
+		{
+			mFinalBones[index].touchRender=mCurrentTouchRender;
+			EvalLow(index);
+		}
+		if (mSmoothingActive)
+		{
+			if (mSmoothBones[index].touch!=mCurrentTouch)
+			{
+				SmoothLow(index);
+			}
+			return mSmoothBones[index].boneMatrix;
+		}
+		return mFinalBones[index].boneMatrix;
+	}
+	//rww - RAGDOLL_END
+	//rww - RAGDOLL_BEGIN
+	bool WasRendered(int index)
+	{
+		assert(index>=0&&index<mNumBones);
+		return mFinalBones[index].touchRender==mCurrentTouchRender;
+	}
+	int GetParent(int index)
+	{
+		if (index==0)
+		{
+			return -1;
+		}
+		assert(index>=0&&index<mNumBones);
+		return mFinalBones[index].parent;
+	}
+	//rww - RAGDOLL_END
+
+	// Added by BTO (VV) - This is probably broken
+	// Need to add in smoothing step?
+	CTransformBone *EvalFull(int index)
+	{
+//		Eval(index);
+		EvalRender(index);
+		if (mSmoothingActive)
+		{
+			return mSmoothBones + index;
+		}
+		return mFinalBones + index;
+	}
+};
+
+static inline float G2_GetVertBoneWeightNotSlow( const mdxmVertex_t *pVert, const int iWeightNum)
+{
+	float fBoneWeight;
+
+	int iTemp = pVert->BoneWeightings[iWeightNum];
+
+	iTemp|= (pVert->uiNmWeightsAndBoneIndexes >> (iG2_BONEWEIGHT_TOPBITS_SHIFT+(iWeightNum*2)) ) & iG2_BONEWEIGHT_TOPBITS_AND;
+
+	fBoneWeight = fG2_BONEWEIGHT_RECIPROCAL_MULT * iTemp;
+
+	return fBoneWeight;
+}
+
+#ifdef _XBOX
+
+static inline void VertTransform(float *out_vert, const float *mat, const float *in_vert)
+{
+	__asm
+	{
+		push      ESI
+		push      EDI
+		push      EAX
+		
+		mov       ESI,    in_vert
+		mov       EDI,    out_vert
+		mov       EAX,    mat
+		
+		movaps    XMM4,   [EAX + 0]		// Load matrix columns
+		movaps    XMM5,   [EAX + 16]
+		movaps    XMM6,   [EAX + 32]
+		movaps    XMM7,   [EAX + 48]
+
+		movss     XMM0,   [ESI + 0]		// Compute x * column 0
+		shufps    XMM0,   XMM0, 0x0
+		mulps     XMM0,   XMM4
+		
+		movss     XMM1,   [ESI + 4]		// Compute y * column 1
+		shufps    XMM1,   XMM1, 0x0
+		mulps     XMM1,   XMM5
+
+		movss     XMM2,   [ESI + 8]		// Compute z * column 2
+		shufps    XMM2,   XMM2, 0x0
+		mulps     XMM2,   XMM6
+
+		addps     XMM0,   XMM1			// Add dot products
+		addps     XMM0,   XMM2
+		addps     XMM0,   XMM7			// Add translation
+
+		movaps    [EDI],  XMM0			// Store result
+		
+		pop       EAX
+		pop       EDI
+		pop       ESI
+	}
+}
+
+static inline void VertTransformSR(float *out_vert, const float *mat, const float *in_vert)
+{
+	__asm
+	{
+		push      ESI
+		push      EDI
+		push      EAX
+		
+		mov       ESI,    in_vert
+		mov       EDI,    out_vert
+		mov       EAX,    mat
+		
+		movaps    XMM4,   [EAX + 0]		// Load matrix columns
+		movaps    XMM5,   [EAX + 16]
+		movaps    XMM6,   [EAX + 32]
+
+		movss     XMM0,   [ESI + 0]		// Compute x * column 0
+		shufps    XMM0,   XMM0, 0x0
+		mulps     XMM0,   XMM4
+		
+		movss     XMM1,   [ESI + 4]		// Compute y * column 1
+		shufps    XMM1,   XMM1, 0x0
+		mulps     XMM1,   XMM5
+
+		movss     XMM2,   [ESI + 8]		// Compute z * column 2
+		shufps    XMM2,   XMM2, 0x0
+		mulps     XMM2,   XMM6
+
+		addps     XMM0,   XMM1			// Add dot products
+		addps     XMM0,   XMM2
+
+		movaps    [EDI],  XMM0			// Store result
+		
+		pop       EAX
+		pop       EDI
+		pop       ESI
+	}
+}
+
+static inline void VertTransformWeighted(float *out_vert, const float *mat, const float *in_vert, const float *weight)
+{
+	__asm
+	{
+		push      ESI
+		push      EDI
+		push      EAX
+		push      EDX
+		
+		mov       ESI,    in_vert
+		mov       EDI,    out_vert
+		mov       EAX,    mat
+		mov       EDX,    weight
+		
+		movaps    XMM4,   [EAX + 0]		// Load matrix columns
+		movaps    XMM5,   [EAX + 16]
+		movaps    XMM6,   [EAX + 32]
+		movaps    XMM7,   [EAX + 48]
+
+		movss     XMM0,   [ESI + 0]		// Compute x * column 0
+		shufps    XMM0,   XMM0, 0x0
+		mulps     XMM0,   XMM4
+		
+		movss     XMM1,   [ESI + 4]		// Compute y * column 1
+		shufps    XMM1,   XMM1, 0x0
+		mulps     XMM1,   XMM5
+
+		movss     XMM2,   [ESI + 8]		// Compute z * column 2
+		shufps    XMM2,   XMM2, 0x0
+		mulps     XMM2,   XMM6
+
+		addps     XMM0,   XMM1			// Add dot products
+		addps     XMM0,   XMM2
+		addps     XMM0,   XMM7			// Add translation
+
+		movss     XMM4,   [EDX]			// Weight the resulting vector
+		shufps    XMM4,   XMM4, 0x0
+		mulps     XMM0,   XMM4
+
+		movaps    XMM5,   [EDI]			// Add the weighted vector to the current
+		addps     XMM0,   XMM5
+
+		movaps    [EDI],  XMM0			// Store result
+		
+		pop       EDX
+		pop       EAX
+		pop       EDI
+		pop       ESI
+	}
+}
+
+static inline void VertTransformSRWeighted(float *out_vert, const float *mat, const float *in_vert, const float *weight)
+{
+	__asm
+	{
+		push      ESI
+		push      EDI
+		push      EAX
+		push      EDX
+		
+		mov       ESI,    in_vert
+		mov       EDI,    out_vert
+		mov       EAX,    mat
+		mov       EDX,    weight
+		
+		movaps    XMM4,   [EAX + 0]		// Load matrix columns
+		movaps    XMM5,   [EAX + 16]
+		movaps    XMM6,   [EAX + 32]
+
+		movss     XMM0,   [ESI + 0]		// Compute x * column 0
+		shufps    XMM0,   XMM0, 0x0
+		mulps     XMM0,   XMM4
+		
+		movss     XMM1,   [ESI + 4]		// Compute y * column 1
+		shufps    XMM1,   XMM1, 0x0
+		mulps     XMM1,   XMM5
+
+		movss     XMM2,   [ESI + 8]		// Compute z * column 2
+		shufps    XMM2,   XMM2, 0x0
+		mulps     XMM2,   XMM6
+
+		addps     XMM0,   XMM1			// Add dot products
+		addps     XMM0,   XMM2
+
+		movss     XMM7,   [EDX]			// Weight the resulting vector
+		shufps    XMM7,   XMM7, 0x0
+		mulps     XMM0,   XMM7
+
+		movaps    XMM4,   [EDI]			// Add the weighted vector to the current
+		addps     XMM0,   XMM4
+
+		movaps    [EDI],  XMM0			// Store result
+		
+		pop       EDX
+		pop       EAX
+		pop       EDI
+		pop       ESI
+	}
+}
+
+static void TransformRenderSurface(const mdxmSurface_t *surf, CBoneCache *bones, shaderCommands_t *out)
+{
+	const int *boneRefs = (int*) ((byte*)surf + surf->ofsBoneReferences);
+	int numVerts = surf->numVerts;
+	const mdxmVertex_t *vert = (mdxmVertex_t *) ((byte *)surf + surf->ofsVerts);
+	const mdxmVertexTexCoord_t *texCoord = (mdxmVertexTexCoord_t *) &vert[numVerts];
+
+	int	boneIndex = -1;
+	const float *bone = NULL;
+
+	int baseVert = out->numVertexes;
+
+	while(numVerts--)
+	{
+		__declspec (align(16)) vec4_t vec;
+		__declspec (align(16)) vec4_t nrm;
+
+#ifdef _XBOX
+		__declspec (align(16)) vec4_t tan;
+
+		Q_CastShort2FloatScale(&vec[0], &vert->vertCoords[0], 1.f / GLM_COMP_SIZE);
+		Q_CastShort2FloatScale(&vec[1], &vert->vertCoords[1], 1.f / GLM_COMP_SIZE);
+		Q_CastShort2FloatScale(&vec[2], &vert->vertCoords[2], 1.f / GLM_COMP_SIZE);
+
+		if(tess.shader->needsNormal || tess.dlightBits)
+		{
+			nrm[0] = (((vert->normal & 0x00FF0000) >> 16) - 128.f) / 127.0f;
+			nrm[1] = (((vert->normal & 0x0000FF00) >> 8) - 128.f) / 127.0f;
+			nrm[2] = (((vert->normal & 0x000000FF) >> 0) - 128.f) / 127.0f;
+		}
+		
+		if(tess.shader->needsTangent || tess.dlightBits)
+		{
+			tan[0] = (((vert->tangent & 0x00FF0000) >> 16) - 128.f) / 127.0f;
+			tan[1] = (((vert->tangent & 0x0000FF00) >> 8) - 128.f) / 127.0f;
+			tan[2] = (((vert->tangent & 0x000000FF) >> 0) - 128.f) / 127.0f;
+
+			out->setTangents = true;
+		}
+#else
+		VectorCopy(vert->vertCoords, vec);
+		VectorCopy(vert->normal, nrm);
+#endif
+
+		const int numWeights = G2_GetVertWeights( vert );
+
+		if (numWeights == 1)
+		{
+			// Slightly faster single weight path
+			int index = G2_GetVertBoneIndex( vert, 0 );
+
+			if ( index != boneIndex )
+			{
+				CTransformBone *tbone = bones->EvalFull(boneRefs[index]);
+				bone = tbone->renderMatrix;
+				boneIndex = index;
+			}
+
+			VertTransform(out->xyz[baseVert], bone, vec);
+#ifdef _XBOX	
+			if(tess.shader->needsNormal || tess.dlightBits)
+                VertTransformSR(out->normal[baseVert], bone, nrm);
+
+			if(tess.shader->needsTangent || tess.dlightBits)
+                VertTransformSR(out->tangent[baseVert], bone, tan);
+#else
+			VertTransformSR(out->normal[baseVert], bone, nrm);
+#endif
+		}
+		else
+		{
+			// Multi-weight blending path
+			VectorClear( out->xyz[baseVert] );
+			
+			// Special case for first weight, as it's the only one we use for the normals
+			boneIndex = G2_GetVertBoneIndex( vert, 0 );
+			CTransformBone *tbone = bones->EvalFull(boneRefs[boneIndex]);
+			bone = tbone->renderMatrix;
+
+			__declspec (align(16)) float weight = G2_GetVertBoneWeightNotSlow( vert, 0 );
+
+			VertTransformWeighted(out->xyz[baseVert], bone, vec, &weight);
+#ifdef _XBOX
+			if(tess.shader->needsNormal || tess.dlightBits)
+                VertTransformSR(out->normal[baseVert], bone, nrm);
+
+			if(tess.shader->needsTangent || tess.dlightBits)
+                VertTransformSR(out->tangent[baseVert], bone, tan);
+#else
+			VertTransformSR(out->normal[baseVert], bone, nrm);
+#endif
+
+			for (int k = 1; k < numWeights; ++k)
+			{
+				boneIndex = G2_GetVertBoneIndex( vert, k );
+				
+				tbone = bones->EvalFull(boneRefs[boneIndex]);
+				bone = tbone->renderMatrix;
+
+				weight = G2_GetVertBoneWeightNotSlow( vert, k );
+
+				VertTransformWeighted(out->xyz[baseVert], bone, vec, &weight);
+			}
+		}
+
+#ifdef _XBOX
+		Q_CastShort2FloatScale(&out->texCoords[baseVert][0][0], &texCoord->texCoords[0], 1.f / GLM_COMP_SIZE);
+		Q_CastShort2FloatScale(&out->texCoords[baseVert][0][1], &texCoord->texCoords[1], 1.f / GLM_COMP_SIZE);
+#else
+		out->texCoords[baseVert][0][0] = texCoord->texCoords[0];
+		out->texCoords[baseVert][0][1] = texCoord->texCoords[1];
+#endif
+
+		++vert;
+		++texCoord;
+		++baseVert;
+	}
+
+	// VVFIXME - BTO - commented this out, as it's still being done in SurfaceGhoul now.
+	// Really, I ought to move the Gore surfacing in here.
+//	out->numVertexes += surf->numVerts;
+}
+
+static void TransformCollideSurface(const mdxmSurface_t *surf, CBoneCache *bones, vec3_t scale, float *out)
+{
+	const int *boneRefs = (int*) ((byte*)surf + surf->ofsBoneReferences);
+	int numVerts = surf->numVerts;
+	const mdxmVertex_t *vert = (mdxmVertex_t *) ((byte *)surf + surf->ofsVerts);
+	const mdxmVertexTexCoord_t *texCoord = (mdxmVertexTexCoord_t *) &vert[numVerts];
+
+	int	boneIndex = -1;
+	const float *bone = NULL;
+
+#ifdef _XBOX
+	vec3_t scl;
+	scl[0] = scale[0] * 1.f / GLM_COMP_SIZE;
+	scl[1] = scale[1] * 1.f / GLM_COMP_SIZE;
+	scl[2] = scale[2] * 1.f / GLM_COMP_SIZE;
+#endif
+
+	while(numVerts--)
+	{
+		__declspec (align(16)) vec4_t vec;
+
+#ifdef _XBOX
+		Q_CastShort2FloatScale(&vec[0], &vert->vertCoords[0], scl[0]);
+		Q_CastShort2FloatScale(&vec[1], &vert->vertCoords[1], scl[1]);
+		Q_CastShort2FloatScale(&vec[2], &vert->vertCoords[2], scl[2]);
+#else
+		VectorCopy(vert->vertCoords, vec);
+#endif
+
+		const int numWeights = G2_GetVertWeights( vert );
+
+		if (numWeights == 1)
+		{
+			// Slightly faster single weight path
+			int index = G2_GetVertBoneIndex( vert, 0 );
+
+			if ( index != boneIndex )
+			{
+				CTransformBone *tbone = bones->EvalFull(boneRefs[index]);
+				bone = tbone->renderMatrix;
+				boneIndex = index;
+			}
+
+			__declspec (align(16)) vec4_t temp;
+			
+			VertTransform(temp, bone, vec);
+			
+			out[0] = temp[0];
+			out[1] = temp[1];
+			out[2] = temp[2];
+		}
+		else
+		{
+			// Multi-weight blending path
+			float totalWeight = 0.0f;
+			
+			__declspec (align(16)) vec4_t temp;
+			temp[0] = 0;
+			temp[1] = 0;
+			temp[2] = 0;
+
+			for (int k = 0; k < numWeights; ++k) 
+			{
+				boneIndex = G2_GetVertBoneIndex( vert, k );
+				
+				CTransformBone *tbone = bones->EvalFull(boneRefs[boneIndex]);
+				bone = tbone->renderMatrix;
+
+				__declspec (align(16)) float weight = 
+					G2_GetVertBoneWeight( vert, k, totalWeight, numWeights );
+
+				VertTransformWeighted(temp, bone, vec, &weight);
+			}
+
+			out[0] = temp[0];
+			out[1] = temp[1];
+			out[2] = temp[2];
+		}
+
+#ifdef _XBOX
+		Q_CastShort2FloatScale(out + 3, &texCoord->texCoords[0], 1.f / GLM_COMP_SIZE);
+		Q_CastShort2FloatScale(out + 4, &texCoord->texCoords[1], 1.f / GLM_COMP_SIZE);
+#else
+		out[3] = texCoord->texCoords[0];
+		out[4] = texCoord->texCoords[1];
+#endif
+
+		++vert;
+		++texCoord;
+		out += 5;
+	}
+}
+
+void R_TransformEachSurface( const mdxmSurface_t *surface, vec3_t scale, CMiniHeap *G2VertSpace, int *TransformedVertsArray,CBoneCache *boneCache) 
+{
+	float			*TransformedVerts;
+
+	// alloc some space for the transformed verts to get put in
+	TransformedVerts = (float *)G2VertSpace->MiniHeapAlloc(surface->numVerts * 5 * 4);
+	TransformedVertsArray[surface->thisSurfaceIndex] = (int)TransformedVerts;
+	if (!TransformedVerts)
+	{
+		assert(0);
+		Com_Error(ERR_DROP, "Ran out of transform space for Ghoul2 Models. Adjust MiniHeapSize in SV_SpawnServer.\n");
+	}
+
+	TransformCollideSurface(surface, boneCache, scale, TransformedVerts);
+}
+
+#endif
+
+//rww - RAGDOLL_BEGIN
+const mdxaHeader_t *G2_GetModA(CGhoul2Info &ghoul2)
+{
+	if (!ghoul2.mBoneCache)
+	{
+		return 0;
+	}
+
+	CBoneCache &boneCache=*ghoul2.mBoneCache;
+	return boneCache.header;
+}
+
+int G2_GetBoneDependents(CGhoul2Info &ghoul2,int boneNum,int *tempDependents,int maxDep)
+{
+	// fixme, these should be precomputed
+	if (!ghoul2.mBoneCache||!maxDep)
+	{
+		return 0;
+	}
+
+	CBoneCache &boneCache=*ghoul2.mBoneCache;
+	mdxaSkel_t		*skel;
+	mdxaSkelOffsets_t *offsets;
+	offsets = (mdxaSkelOffsets_t *)((byte *)boneCache.header + sizeof(mdxaHeader_t));
+	skel = (mdxaSkel_t *)((byte *)boneCache.header + sizeof(mdxaHeader_t) + offsets->offsets[boneNum]);
+	int i;
+	int ret=0;
+	for (i=0;i<skel->numChildren;i++)
+	{
+		if (!maxDep)
+		{
+			return i; // number added
+		}
+		*tempDependents=skel->children[i];
+		assert(*tempDependents>0&&*tempDependents<boneCache.header->numBones);
+		maxDep--;
+		tempDependents++;
+		ret++;
+	}
+	for (i=0;i<skel->numChildren;i++)
+	{
+		int num=G2_GetBoneDependents(ghoul2,skel->children[i],tempDependents,maxDep);
+		tempDependents+=num;
+		ret+=num;
+		maxDep-=num;
+		assert(maxDep>=0);
+		if (!maxDep)
+		{
+			break;
+		}
+	}
+	return ret;
+}
+
+bool G2_WasBoneRendered(CGhoul2Info &ghoul2,int boneNum)
+{
+	if (!ghoul2.mBoneCache)
+	{
+		return false;
+	}
+	CBoneCache &boneCache=*ghoul2.mBoneCache;
+
+	return boneCache.WasRendered(boneNum);
+}
+
+void G2_GetBoneBasepose(CGhoul2Info &ghoul2,int boneNum,mdxaBone_t *&retBasepose,mdxaBone_t *&retBaseposeInv)
+{
+	if (!ghoul2.mBoneCache)
+	{
+		// yikes
+		retBasepose=const_cast<mdxaBone_t *>(&identityMatrix);
+		retBaseposeInv=const_cast<mdxaBone_t *>(&identityMatrix);
+		return;
+	}
+	assert(ghoul2.mBoneCache);
+	CBoneCache &boneCache=*ghoul2.mBoneCache;
+	assert(boneCache.mod);
+	assert(boneNum>=0&&boneNum<boneCache.header->numBones);
+
+	mdxaSkel_t		*skel;
+	mdxaSkelOffsets_t *offsets;
+	offsets = (mdxaSkelOffsets_t *)((byte *)boneCache.header + sizeof(mdxaHeader_t));
+	skel = (mdxaSkel_t *)((byte *)boneCache.header + sizeof(mdxaHeader_t) + offsets->offsets[boneNum]);
+	retBasepose=&skel->BasePoseMat;
+	retBaseposeInv=&skel->BasePoseMatInv;
+}
+
+char *G2_GetBoneNameFromSkel(CGhoul2Info &ghoul2, int boneNum)
+{
+	if (!ghoul2.mBoneCache)
+	{
+		return NULL;
+	}
+	CBoneCache &boneCache=*ghoul2.mBoneCache;
+	assert(boneCache.mod);
+	assert(boneNum>=0&&boneNum<boneCache.header->numBones);
+
+	mdxaSkel_t		*skel;
+	mdxaSkelOffsets_t *offsets;
+	offsets = (mdxaSkelOffsets_t *)((byte *)boneCache.header + sizeof(mdxaHeader_t));
+	skel = (mdxaSkel_t *)((byte *)boneCache.header + sizeof(mdxaHeader_t) + offsets->offsets[boneNum]);
+
+	return skel->name;
+}
+
+void G2_RagGetBoneBasePoseMatrixLow(CGhoul2Info &ghoul2, int boneNum, mdxaBone_t &boneMatrix, mdxaBone_t &retMatrix, vec3_t scale)
+{
+	assert(ghoul2.mBoneCache);
+	CBoneCache &boneCache=*ghoul2.mBoneCache;
+	assert(boneCache.mod);
+	assert(boneNum>=0&&boneNum<boneCache.header->numBones);
+
+	mdxaSkel_t		*skel;
+	mdxaSkelOffsets_t *offsets;
+	offsets = (mdxaSkelOffsets_t *)((byte *)boneCache.header + sizeof(mdxaHeader_t));
+	skel = (mdxaSkel_t *)((byte *)boneCache.header + sizeof(mdxaHeader_t) + offsets->offsets[boneNum]);
+	Multiply_3x4Matrix(&retMatrix, &boneMatrix, &skel->BasePoseMat);
+
+	if (scale[0])
+	{
+		retMatrix.matrix[0][3] *= scale[0];
+	}
+	if (scale[1])
+	{
+		retMatrix.matrix[1][3] *= scale[1];
+	}
+	if (scale[2])
+	{
+		retMatrix.matrix[2][3] *= scale[2];
+	}
+
+	VectorNormalize((float*)&retMatrix.matrix[0]);
+	VectorNormalize((float*)&retMatrix.matrix[1]);
+	VectorNormalize((float*)&retMatrix.matrix[2]);
+}
+
+void G2_GetBoneMatrixLow(CGhoul2Info &ghoul2,int boneNum,const vec3_t scale,mdxaBone_t &retMatrix,mdxaBone_t *&retBasepose,mdxaBone_t *&retBaseposeInv)
+{
+	if (!ghoul2.mBoneCache)
+	{
+		retMatrix=identityMatrix;
+		// yikes
+		retBasepose=const_cast<mdxaBone_t *>(&identityMatrix);
+		retBaseposeInv=const_cast<mdxaBone_t *>(&identityMatrix);
+		return;
+	}
+	mdxaBone_t bolt;
+	assert(ghoul2.mBoneCache);
+	CBoneCache &boneCache=*ghoul2.mBoneCache;
+	assert(boneCache.mod);
+	assert(boneNum>=0&&boneNum<boneCache.header->numBones);
+
+	mdxaSkel_t		*skel;
+	mdxaSkelOffsets_t *offsets;
+	offsets = (mdxaSkelOffsets_t *)((byte *)boneCache.header + sizeof(mdxaHeader_t));
+	skel = (mdxaSkel_t *)((byte *)boneCache.header + sizeof(mdxaHeader_t) + offsets->offsets[boneNum]);
+	Multiply_3x4Matrix(&bolt, &boneCache.Eval(boneNum), &skel->BasePoseMat); // DEST FIRST ARG
+	retBasepose=&skel->BasePoseMat;
+	retBaseposeInv=&skel->BasePoseMatInv;
+
+	if (scale[0])
+	{
+		bolt.matrix[0][3] *= scale[0];
+	}
+	if (scale[1])
+	{
+		bolt.matrix[1][3] *= scale[1];
+	}
+	if (scale[2])
+	{
+		bolt.matrix[2][3] *= scale[2];
+	}
+	VectorNormalize((float*)&bolt.matrix[0]);
+	VectorNormalize((float*)&bolt.matrix[1]);
+	VectorNormalize((float*)&bolt.matrix[2]);
+
+	Multiply_3x4Matrix(&retMatrix,&worldMatrix, &bolt);												
+	
+#ifdef _DEBUG
+	for ( int i = 0; i < 3; i++ )
+	{
+		for ( int j = 0; j < 4; j++ )
+		{
+			assert( !_isnan(retMatrix.matrix[i][j]));
+		}
+	}
+#endif// _DEBUG
+}
+
+int G2_GetParentBoneMatrixLow(CGhoul2Info &ghoul2,int boneNum,const vec3_t scale,mdxaBone_t &retMatrix,mdxaBone_t *&retBasepose,mdxaBone_t *&retBaseposeInv)
+{
+	int parent=-1;
+	if (ghoul2.mBoneCache)
+	{
+		CBoneCache &boneCache=*ghoul2.mBoneCache;
+		assert(boneCache.mod);
+		assert(boneNum>=0&&boneNum<boneCache.header->numBones);
+		parent=boneCache.GetParent(boneNum);
+		if (parent<0||parent>=boneCache.header->numBones)
+		{
+			parent=-1;
+			retMatrix=identityMatrix;
+			// yikes
+			retBasepose=const_cast<mdxaBone_t *>(&identityMatrix);
+			retBaseposeInv=const_cast<mdxaBone_t *>(&identityMatrix);
+		}
+		else
+		{
+			G2_GetBoneMatrixLow(ghoul2,parent,scale,retMatrix,retBasepose,retBaseposeInv);
+		}
+	}
+	return parent;
+}
+//rww - RAGDOLL_END
+
+void RemoveBoneCache(CBoneCache *boneCache)
+{
+	delete boneCache;
+}
+
+const mdxaBone_t &EvalBoneCache(int index,CBoneCache *boneCache)
+{
+	assert(boneCache);
+	return boneCache->Eval(index);
+}
+
+
+class CRenderSurface
+{
+public:
+	int				surfaceNum;
+	surfaceInfo_v	&rootSList;
+	const shader_t		*cust_shader;
+	int				fogNum;
+	qboolean		personalModel;
+	CBoneCache		*boneCache;
+	int				renderfx;
+	const skin_t	*skin;
+	const model_t	*currentModel;
+	int				lod;
+	boltInfo_v		&boltList;
+#ifdef _G2_GORE
+	shader_t		*gore_shader;
+	CGoreSet		*gore_set;
+#endif
+
+	CRenderSurface(
+		int				initsurfaceNum,
+		surfaceInfo_v	&initrootSList,
+		const shader_t		*initcust_shader,
+		int				initfogNum,
+		qboolean		initpersonalModel,
+		CBoneCache		*initboneCache,
+		int				initrenderfx,
+		const skin_t			*initskin,
+		const model_t			*initcurrentModel,
+		int				initlod,
+#ifdef _G2_GORE
+		boltInfo_v		&initboltList,
+		shader_t		*initgore_shader,
+		CGoreSet		*initgore_set):
+#else
+		boltInfo_v		&initboltList):
+#endif
+	surfaceNum(initsurfaceNum),
+	rootSList(initrootSList),
+	cust_shader(initcust_shader),
+	fogNum(initfogNum),
+	personalModel(initpersonalModel),
+	boneCache(initboneCache),
+	renderfx(initrenderfx),
+	skin(initskin),
+	currentModel(initcurrentModel),
+	lod(initlod),
+#ifdef _G2_GORE
+	boltList(initboltList),
+	gore_shader(initgore_shader),
+	gore_set(initgore_set)
+#else
+	boltList(initboltList)
+#endif
+	{}
+};
+
+#define MAX_RENDER_SURFACES (2048)
+static CRenderableSurface RSStorage[MAX_RENDER_SURFACES];
+static unsigned int NextRS=0;
+
+CRenderableSurface *AllocRS()
+{
+	CRenderableSurface *ret=&RSStorage[NextRS];
+	ret->Init();
+	NextRS++;
+	NextRS%=MAX_RENDER_SURFACES;
+	return ret;
+}
+
+/*
+
+All bones should be an identity orientation to display the mesh exactly
+as it is specified.
+
+For all other frames, the bones represent the transformation from the 
+orientation of the bone in the base frame to the orientation in this
+frame.
+
+*/
+
+
+/*
+=============
+R_ACullModel
+=============
+*/
+static int R_GCullModel( trRefEntity_t *ent ) {
+
+	// scale the radius if need be
+	float largestScale = ent->e.modelScale[0];
+
+	if (ent->e.modelScale[1] > largestScale)
+	{
+		largestScale = ent->e.modelScale[1];
+	}
+	if (ent->e.modelScale[2] > largestScale)
+	{
+		largestScale = ent->e.modelScale[2];
+	}
+	if (!largestScale)
+	{
+		largestScale = 1;
+	}
+
+	// cull bounding sphere 
+  	switch ( R_CullLocalPointAndRadius( vec3_origin,  ent->e.radius * largestScale) )
+  	{
+  	case CULL_OUT:
+  		tr.pc.c_sphere_cull_md3_out++;
+  		return CULL_OUT;
+
+	case CULL_IN:
+		tr.pc.c_sphere_cull_md3_in++;
+		return CULL_IN;
+
+	case CULL_CLIP:
+		tr.pc.c_sphere_cull_md3_clip++;
+		return CULL_IN;
+ 	}
+	return CULL_IN;
+}
+
+
+/*
+=================
+R_AComputeFogNum
+
+=================
+*/
+static int R_GComputeFogNum( trRefEntity_t *ent ) {
+
+	int				i;
+	fog_t			*fog;
+
+	if ( tr.refdef.rdflags & RDF_NOWORLDMODEL ) {
+		return 0;
+	}
+
+	if ( tr.refdef.rdflags & RDF_doLAGoggles )
+	{
+		return tr.world->numfogs;
+	}
+
+	int partialFog = 0;
+	for ( i = 1 ; i < tr.world->numfogs ; i++ ) {
+		fog = &tr.world->fogs[i];
+		if ( ent->e.origin[0] - ent->e.radius >= fog->bounds[0][0] 
+			&& ent->e.origin[0] + ent->e.radius <= fog->bounds[1][0] 
+			&& ent->e.origin[1] - ent->e.radius >= fog->bounds[0][1]
+			&& ent->e.origin[1] + ent->e.radius <= fog->bounds[1][1] 
+			&& ent->e.origin[2] - ent->e.radius >= fog->bounds[0][2]
+			&& ent->e.origin[2] + ent->e.radius <= fog->bounds[1][2] ) 
+		{//totally inside it
+			return i;
+			break;
+		}
+		if ( ( ent->e.origin[0] - ent->e.radius >= fog->bounds[0][0] && ent->e.origin[1] - ent->e.radius >= fog->bounds[0][1] && ent->e.origin[2] - ent->e.radius >= fog->bounds[0][2] &&
+			ent->e.origin[0] - ent->e.radius <= fog->bounds[1][0] && ent->e.origin[1] - ent->e.radius <= fog->bounds[1][1] && ent->e.origin[2] - ent->e.radius <= fog->bounds[1][2] ) ||
+			( ent->e.origin[0] + ent->e.radius >= fog->bounds[0][0] && ent->e.origin[1] + ent->e.radius >= fog->bounds[0][1] && ent->e.origin[2] + ent->e.radius >= fog->bounds[0][2] &&
+			ent->e.origin[0] + ent->e.radius <= fog->bounds[1][0] && ent->e.origin[1] + ent->e.radius <= fog->bounds[1][1] && ent->e.origin[2] + ent->e.radius <= fog->bounds[1][2] ) )
+		{//partially inside it
+			if ( tr.refdef.fogIndex == i || R_FogParmsMatch( tr.refdef.fogIndex, i ) )
+			{//take new one only if it's the same one that the viewpoint is in
+				return i;
+				break;
+			}
+			else if ( !partialFog )
+			{//first partialFog
+				partialFog = i;
+			}
+		}
+	}
+	//if nothing else, use the first partial fog you found
+	return partialFog;
+}
+
+// work out lod for this entity.
+static int G2_ComputeLOD( trRefEntity_t *ent, const model_t *currentModel, int lodBias ) 
+{
+	float flod, lodscale;
+	float projectedRadius;
+	int lod;
+
+	if ( currentModel->numLods < 2 )
+	{	// model has only 1 LOD level, skip computations and bias
+		return(0);
+	}
+
+	if (r_lodbias->integer > lodBias) 
+	{
+		lodBias = r_lodbias->integer;
+	}
+	
+	//**early out, it's going to be max lod
+	if (lodBias >= currentModel->numLods )
+	{
+		return currentModel->numLods - 1;
+	}
+
+
+	// scale the radius if need be
+	float largestScale = ent->e.modelScale[0];
+
+	if (ent->e.modelScale[1] > largestScale)
+	{
+		largestScale = ent->e.modelScale[1];
+	}
+	if (ent->e.modelScale[2] > largestScale)
+	{
+		largestScale = ent->e.modelScale[2];
+	}
+	if (!largestScale)
+	{
+		largestScale = 1;
+	}
+
+	if ( ( projectedRadius = ProjectRadius( 0.75*largestScale*ent->e.radius, ent->e.origin ) ) != 0 )	//we reduce the radius to make the LOD match other model types which use the actual bound box size
+ 	{
+ 		lodscale = r_lodscale->value;
+ 		if (lodscale > 20) lodscale = 20;	 
+ 		flod = 1.0f - projectedRadius * lodscale;
+ 	}
+ 	else
+ 	{
+ 		// object intersects near view plane, e.g. view weapon
+ 		flod = 0;
+ 	}
+
+ 	flod *= currentModel->numLods;
+ 	lod = myftol( flod );
+
+ 	if ( lod < 0 )
+ 	{
+ 		lod = 0;
+ 	}
+ 	else if ( lod >= currentModel->numLods )
+ 	{
+ 		lod = currentModel->numLods - 1;
+ 	}
+
+
+	lod += lodBias;
+	
+	if ( lod >= currentModel->numLods )
+		lod = currentModel->numLods - 1;
+	if ( lod < 0 )
+		lod = 0;
+
+	return lod;
+}
+
+
+void Multiply_3x4Matrix(mdxaBone_t *out,const  mdxaBone_t *in2,const mdxaBone_t *in) 
+{
+	// first row of out                                                                                      
+	out->matrix[0][0] = (in2->matrix[0][0] * in->matrix[0][0]) + (in2->matrix[0][1] * in->matrix[1][0]) + (in2->matrix[0][2] * in->matrix[2][0]);
+	out->matrix[0][1] = (in2->matrix[0][0] * in->matrix[0][1]) + (in2->matrix[0][1] * in->matrix[1][1]) + (in2->matrix[0][2] * in->matrix[2][1]);
+	out->matrix[0][2] = (in2->matrix[0][0] * in->matrix[0][2]) + (in2->matrix[0][1] * in->matrix[1][2]) + (in2->matrix[0][2] * in->matrix[2][2]);
+	out->matrix[0][3] = (in2->matrix[0][0] * in->matrix[0][3]) + (in2->matrix[0][1] * in->matrix[1][3]) + (in2->matrix[0][2] * in->matrix[2][3]) + in2->matrix[0][3];
+	// second row of outf out                                                                                     
+	out->matrix[1][0] = (in2->matrix[1][0] * in->matrix[0][0]) + (in2->matrix[1][1] * in->matrix[1][0]) + (in2->matrix[1][2] * in->matrix[2][0]);
+	out->matrix[1][1] = (in2->matrix[1][0] * in->matrix[0][1]) + (in2->matrix[1][1] * in->matrix[1][1]) + (in2->matrix[1][2] * in->matrix[2][1]);
+	out->matrix[1][2] = (in2->matrix[1][0] * in->matrix[0][2]) + (in2->matrix[1][1] * in->matrix[1][2]) + (in2->matrix[1][2] * in->matrix[2][2]);
+	out->matrix[1][3] = (in2->matrix[1][0] * in->matrix[0][3]) + (in2->matrix[1][1] * in->matrix[1][3]) + (in2->matrix[1][2] * in->matrix[2][3]) + in2->matrix[1][3];
+	// third row of out  out                                                                                      
+	out->matrix[2][0] = (in2->matrix[2][0] * in->matrix[0][0]) + (in2->matrix[2][1] * in->matrix[1][0]) + (in2->matrix[2][2] * in->matrix[2][0]);
+	out->matrix[2][1] = (in2->matrix[2][0] * in->matrix[0][1]) + (in2->matrix[2][1] * in->matrix[1][1]) + (in2->matrix[2][2] * in->matrix[2][1]);
+	out->matrix[2][2] = (in2->matrix[2][0] * in->matrix[0][2]) + (in2->matrix[2][1] * in->matrix[1][2]) + (in2->matrix[2][2] * in->matrix[2][2]);
+	out->matrix[2][3] = (in2->matrix[2][0] * in->matrix[0][3]) + (in2->matrix[2][1] * in->matrix[1][3]) + (in2->matrix[2][2] * in->matrix[2][3]) + in2->matrix[2][3]; 
+}
+
+static int G2_GetBonePoolIndex(	const mdxaHeader_t *pMDXAHeader, int iFrame, int iBone)
+{
+	assert(iFrame>=0&&iFrame<pMDXAHeader->numFrames);
+	assert(iBone>=0&&iBone<pMDXAHeader->numBones);
+	const int iOffsetToIndex = (iFrame * pMDXAHeader->numBones * 3) + (iBone * 3);
+
+	mdxaIndex_t *pIndex = (mdxaIndex_t *) ((byte*) pMDXAHeader + pMDXAHeader->ofsFrames + iOffsetToIndex);
+
+	return pIndex->iIndex & 0x00FFFFFF;	// this will cause problems for big-endian machines... ;-)
+}
+
+
+/*static inline*/ void UnCompressBone(float mat[3][4], int iBoneIndex, const mdxaHeader_t *pMDXAHeader, int iFrame)
+{
+	mdxaCompQuatBone_t *pCompBonePool = (mdxaCompQuatBone_t *) ((byte *)pMDXAHeader + pMDXAHeader->ofsCompBonePool);
+	MC_UnCompressQuat(mat, pCompBonePool[ G2_GetBonePoolIndex( pMDXAHeader, iFrame, iBoneIndex ) ].Comp);
+}
+
+
+
+#define DEBUG_G2_TIMING (0)
+#define DEBUG_G2_TIMING_RENDER_ONLY (1)
+
+void G2_TimingModel(boneInfo_t &bone,int currentTime,int numFramesInFile,int &currentFrame,int &newFrame,float &lerp)
+{
+	assert(bone.startFrame>=0);
+	assert(bone.startFrame<=numFramesInFile);
+	assert(bone.endFrame>=0);
+	assert(bone.endFrame<=numFramesInFile);
+
+	// yes - add in animation speed to current frame
+	float	animSpeed = bone.animSpeed;
+	float	time;
+	if (bone.pauseTime)
+	{
+		time = (bone.pauseTime - bone.startTime) / 50.0f;
+	}
+	else
+	{			
+		time = (currentTime - bone.startTime) / 50.0f;
+	}
+	if (time<0.0f)
+	{
+		time=0.0f;
+	}
+	float	newFrame_g = bone.startFrame + (time * animSpeed);
+
+	int		animSize = bone.endFrame - bone.startFrame;
+	float	endFrame = (float)bone.endFrame;
+	// we are supposed to be animating right?
+	if (animSize)
+	{
+		// did we run off the end?
+		if (((animSpeed > 0.0f) && (newFrame_g > endFrame - 1)) || 
+			((animSpeed < 0.0f) && (newFrame_g < endFrame+1)))
+		{
+			// yep - decide what to do
+			if (bone.flags & BONE_ANIM_OVERRIDE_LOOP)
+			{
+				// get our new animation frame back within the bounds of the animation set
+				if (animSpeed < 0.0f)
+				{
+					// we don't use this case, or so I am told
+					// if we do, let me know, I need to insure the mod works
+
+					// should we be creating a virtual frame?
+					if ((newFrame_g < endFrame+1) && (newFrame_g >= endFrame))
+					{
+						// now figure out what we are lerping between
+						// delta is the fraction between this frame and the next, since the new anim is always at a .0f;
+						lerp = float(endFrame+1)-newFrame_g;
+						// frames are easy to calculate
+						currentFrame = endFrame;
+						assert(currentFrame>=0&&currentFrame<numFramesInFile);
+						newFrame = bone.startFrame;
+						assert(newFrame>=0&&newFrame<numFramesInFile);
+					}
+					else
+					{
+						if (newFrame_g <= endFrame+1)
+						{
+							newFrame_g=endFrame+fmod(newFrame_g-endFrame,animSize)-animSize;
+						}
+						// now figure out what we are lerping between
+						// delta is the fraction between this frame and the next, since the new anim is always at a .0f;
+						lerp = (ceil(newFrame_g)-newFrame_g);
+						// frames are easy to calculate
+						currentFrame = ceil(newFrame_g);
+						assert(currentFrame>=0&&currentFrame<numFramesInFile);
+						// should we be creating a virtual frame?
+						if (currentFrame <= endFrame+1 )
+						{
+							newFrame = bone.startFrame;
+							assert(newFrame>=0&&newFrame<numFramesInFile);
+						}
+						else
+						{
+							newFrame = currentFrame - 1;
+							assert(newFrame>=0&&newFrame<numFramesInFile);
+						}
+					}
+				}
+				else
+				{
+					// should we be creating a virtual frame?
+					if ((newFrame_g > endFrame - 1) && (newFrame_g < endFrame))
+					{
+						// now figure out what we are lerping between
+						// delta is the fraction between this frame and the next, since the new anim is always at a .0f;
+						lerp = (newFrame_g - (int)newFrame_g);
+						// frames are easy to calculate
+						currentFrame = (int)newFrame_g;
+						assert(currentFrame>=0&&currentFrame<numFramesInFile);
+						newFrame = bone.startFrame;
+						assert(newFrame>=0&&newFrame<numFramesInFile);
+					}
+					else
+					{
+						if (newFrame_g >= endFrame)
+						{
+							newFrame_g=endFrame+fmod(newFrame_g-endFrame,animSize)-animSize;
+						}
+						// now figure out what we are lerping between
+						// delta is the fraction between this frame and the next, since the new anim is always at a .0f;
+						lerp = (newFrame_g - (int)newFrame_g);
+						// frames are easy to calculate
+						currentFrame = (int)newFrame_g;
+						assert(currentFrame>=0&&currentFrame<numFramesInFile);
+						// should we be creating a virtual frame?
+						if (newFrame_g >= endFrame - 1)
+						{
+							newFrame = bone.startFrame;
+							assert(newFrame>=0&&newFrame<numFramesInFile);
+						}
+						else
+						{
+							newFrame = currentFrame + 1;
+							assert(newFrame>=0&&newFrame<numFramesInFile);
+						}
+					}
+				}
+				// sanity check
+				assert ((newFrame < endFrame) && (newFrame >= bone.startFrame) || (animSize < 10)); 
+			}
+			else
+			{
+				if (((bone.flags & (BONE_ANIM_OVERRIDE_FREEZE)) == (BONE_ANIM_OVERRIDE_FREEZE)))
+				{
+					// if we are supposed to reset the default anim, then do so
+					if (animSpeed > 0.0f)
+					{
+						currentFrame = bone.endFrame - 1;
+						assert(currentFrame>=0&&currentFrame<numFramesInFile);
+					}
+					else
+					{
+						currentFrame = bone.endFrame+1;
+						assert(currentFrame>=0&&currentFrame<numFramesInFile);
+					}
+
+					newFrame = currentFrame;
+					assert(newFrame>=0&&newFrame<numFramesInFile);
+					lerp = 0;
+				}
+				else
+				{
+					bone.flags &= ~(BONE_ANIM_TOTAL);
+				}
+
+			}
+		}
+		else
+		{
+			if (animSpeed> 0.0)
+			{
+				// frames are easy to calculate
+				currentFrame = (int)newFrame_g;
+
+				// figure out the difference between the two frames	- we have to decide what frame and what percentage of that
+				// frame we want to display
+				lerp = (newFrame_g - currentFrame);
+
+				assert(currentFrame>=0&&currentFrame<numFramesInFile);
+
+				newFrame = currentFrame + 1;
+				// are we now on the end frame?
+				assert((int)endFrame<=numFramesInFile);
+				if (newFrame >= (int)endFrame)
+				{
+					// we only want to lerp with the first frame of the anim if we are looping 
+					if (bone.flags & BONE_ANIM_OVERRIDE_LOOP)
+					{
+					  	newFrame = bone.startFrame;
+						assert(newFrame>=0&&newFrame<numFramesInFile);
+					}
+					// if we intend to end this anim or freeze after this, then just keep on the last frame
+					else
+					{
+						newFrame = bone.endFrame-1;
+						assert(newFrame>=0&&newFrame<numFramesInFile);
+					}
+				}
+				assert(newFrame>=0&&newFrame<numFramesInFile);
+			}
+			else
+			{
+				lerp = (ceil(newFrame_g)-newFrame_g);
+				// frames are easy to calculate
+				currentFrame = ceil(newFrame_g);
+				if (currentFrame>bone.startFrame)
+				{
+					currentFrame=bone.startFrame;
+					newFrame = currentFrame;
+					lerp=0.0f;
+				}
+				else
+				{
+					newFrame=currentFrame-1;
+					// are we now on the end frame?
+					if (newFrame < endFrame+1)
+					{
+						// we only want to lerp with the first frame of the anim if we are looping 
+						if (bone.flags & BONE_ANIM_OVERRIDE_LOOP)
+						{
+					  		newFrame = bone.startFrame;
+							assert(newFrame>=0&&newFrame<numFramesInFile);
+						}
+						// if we intend to end this anim or freeze after this, then just keep on the last frame
+						else
+						{
+							newFrame = bone.endFrame+1;
+							assert(newFrame>=0&&newFrame<numFramesInFile);
+						}
+					}
+				}
+				assert(currentFrame>=0&&currentFrame<numFramesInFile);
+				assert(newFrame>=0&&newFrame<numFramesInFile);
+			}
+		}
+	}
+	else
+	{
+		if (animSpeed<0.0)
+		{
+			currentFrame = bone.endFrame+1;
+		}
+		else
+		{
+			currentFrame = bone.endFrame-1;
+		}
+		if (currentFrame<0)
+		{
+			currentFrame=0;
+		}
+		assert(currentFrame>=0&&currentFrame<numFramesInFile);
+		newFrame = currentFrame;
+		assert(newFrame>=0&&newFrame<numFramesInFile);
+		lerp = 0;
+
+	}
+	/*
+	assert(currentFrame>=0&&currentFrame<numFramesInFile);
+	assert(newFrame>=0&&newFrame<numFramesInFile);
+	assert(lerp>=0.0f&&lerp<=1.0f);
+	*/
+}
+
+//basically construct a seperate skeleton with full hierarchy to store a matrix
+//off which will give us the desired settling position given the frame in the skeleton
+//that should be used -rww
+int G2_Add_Bone (const model_t *mod, boneInfo_v &blist, const char *boneName);
+int G2_Find_Bone(CGhoul2Info *ghlInfo, boneInfo_v &blist, const char *boneName);
+void G2_RagGetAnimMatrix(CGhoul2Info &ghoul2, const int boneNum, mdxaBone_t &matrix, const int frame)
+{
+	mdxaBone_t animMatrix;
+	mdxaSkel_t *skel;
+	mdxaSkel_t *pskel;
+	mdxaSkelOffsets_t *offsets;
+	int parent;
+	int bListIndex;
+	int parentBlistIndex;
+#ifdef _RAG_PRINT_TEST
+	bool actuallySet = false;
+#endif
+
+	assert(ghoul2.mBoneCache);
+	assert(ghoul2.animModel);
+
+	offsets = (mdxaSkelOffsets_t *)((byte *)ghoul2.mBoneCache->header + sizeof(mdxaHeader_t));
+	skel = (mdxaSkel_t *)((byte *)ghoul2.mBoneCache->header + sizeof(mdxaHeader_t) + offsets->offsets[boneNum]);
+
+	//find/add the bone in the list
+	if (!skel->name || !skel->name[0])
+	{
+		bListIndex = -1;
+	}
+	else
+	{
+		bListIndex = G2_Find_Bone(&ghoul2, ghoul2.mBlist, skel->name);
+		if (bListIndex == -1)
+		{
+#ifdef _RAG_PRINT_TEST
+			Com_Printf("Attempting to add %s\n", skel->name);
+#endif
+			bListIndex = G2_Add_Bone(ghoul2.animModel, ghoul2.mBlist, skel->name);
+		}
+	}
+
+	assert(bListIndex != -1);
+
+	boneInfo_t &bone = ghoul2.mBlist[bListIndex];
+
+	if (bone.hasAnimFrameMatrix == frame)
+	{ //already calculated so just grab it
+		matrix = bone.animFrameMatrix;
+		return;
+	}
+
+	//get the base matrix for the specified frame
+	UnCompressBone(animMatrix.matrix, boneNum, ghoul2.mBoneCache->header, frame);
+
+	parent = skel->parent;
+	if (boneNum > 0 && parent > -1)
+	{
+		//recursively call to assure all parent matrices are set up
+		G2_RagGetAnimMatrix(ghoul2, parent, matrix, frame);
+
+		//assign the new skel ptr for our parent
+		pskel = (mdxaSkel_t *)((byte *)ghoul2.mBoneCache->header + sizeof(mdxaHeader_t) + offsets->offsets[parent]);
+
+		//taking bone matrix for the skeleton frame and parent's animFrameMatrix into account, determine our final animFrameMatrix
+		if (!pskel->name || !pskel->name[0])
+		{
+			parentBlistIndex = -1;
+		}
+		else
+		{
+			parentBlistIndex = G2_Find_Bone(&ghoul2, ghoul2.mBlist, pskel->name);
+			if (parentBlistIndex == -1)
+			{
+				parentBlistIndex = G2_Add_Bone(ghoul2.animModel, ghoul2.mBlist, pskel->name);
+			}
+		}
+
+		assert(parentBlistIndex != -1);
+
+		boneInfo_t &pbone = ghoul2.mBlist[parentBlistIndex];
+
+		assert(pbone.hasAnimFrameMatrix == frame); //this should have been calc'd in the recursive call
+
+		Multiply_3x4Matrix(&bone.animFrameMatrix, &pbone.animFrameMatrix, &animMatrix);
+
+#ifdef _RAG_PRINT_TEST
+		if (parentBlistIndex != -1 && bListIndex != -1)
+		{
+			actuallySet = true;
+		}
+		else
+		{
+			Com_Printf("BAD LIST INDEX: %s, %s [%i]\n", skel->name, pskel->name, parent);
+		}
+#endif
+	}
+	else
+	{ //root
+		Multiply_3x4Matrix(&bone.animFrameMatrix, &ghoul2.mBoneCache->rootMatrix, &animMatrix);
+#ifdef _RAG_PRINT_TEST
+		if (bListIndex != -1)
+		{
+			actuallySet = true;
+		}
+		else
+		{
+			Com_Printf("BAD LIST INDEX: %s\n", skel->name);
+		}
+#endif
+		//bone.animFrameMatrix = ghoul2.mBoneCache->mFinalBones[boneNum].boneMatrix;
+		//Maybe use this for the root, so that the orientation is in sync with the current
+		//root matrix? However this would require constant recalculation of this base
+		//skeleton which I currently do not want.
+	}
+
+	//never need to figure it out again
+	bone.hasAnimFrameMatrix = frame;
+
+#ifdef _RAG_PRINT_TEST
+	if (!actuallySet)
+	{
+		Com_Printf("SET FAILURE\n");
+	}
+#endif
+
+	matrix = bone.animFrameMatrix;
+}
+
+// transform each individual bone's information - making sure to use any override information provided, both for angles and for animations, as
+// well as multiplying each bone's matrix by it's parents matrix 
+void G2_TransformBone (int child,CBoneCache &BC)
+{
+	SBoneCalc &TB=BC.mBones[child];
+	mdxaBone_t		tbone[6];
+// 	mdxaFrame_t		*aFrame=0;
+//	mdxaFrame_t		*bFrame=0;
+//	mdxaFrame_t		*aoldFrame=0;
+//	mdxaFrame_t		*boldFrame=0;
+	mdxaSkel_t		*skel;
+	mdxaSkelOffsets_t *offsets;
+	boneInfo_v		&boneList = *BC.rootBoneList;
+	int				j, boneListIndex;
+	int				angleOverride = 0;
+
+#if DEBUG_G2_TIMING
+	bool printTiming=false;
+#endif
+	// should this bone be overridden by a bone in the bone list?
+	boneListIndex = G2_Find_Bone_In_List(boneList, child);
+	if (boneListIndex != -1)
+	{
+		// we found a bone in the list - we need to override something here.
+		
+		// do we override the rotational angles?
+		if ((boneList[boneListIndex].flags) & (BONE_ANGLES_TOTAL))
+		{
+			angleOverride = (boneList[boneListIndex].flags) & (BONE_ANGLES_TOTAL);
+		}
+
+		// set blending stuff if we need to
+		if (boneList[boneListIndex].flags & BONE_ANIM_BLEND)
+		{
+			float blendTime = BC.incomingTime - boneList[boneListIndex].blendStart;
+			// only set up the blend anim if we actually have some blend time left on this bone anim - otherwise we might corrupt some blend higher up the hiearchy
+			if (blendTime>=0.0f&&blendTime < boneList[boneListIndex].blendTime)
+			{
+				TB.blendFrame	 = boneList[boneListIndex].blendFrame;
+				TB.blendOldFrame = boneList[boneListIndex].blendLerpFrame;
+				TB.blendLerp = (blendTime / boneList[boneListIndex].blendTime);
+				TB.blendMode = true;
+			}
+			else
+			{
+				TB.blendMode = false;
+			}
+		}
+		else if (r_Ghoul2NoBlend->integer||((boneList[boneListIndex].flags) & (BONE_ANIM_OVERRIDE_LOOP | BONE_ANIM_OVERRIDE)))
+		// turn off blending if we are just doing a straing animation override
+		{
+			TB.blendMode = false;
+		}
+
+		// should this animation be overridden by an animation in the bone list?
+		if ((boneList[boneListIndex].flags) & (BONE_ANIM_OVERRIDE_LOOP | BONE_ANIM_OVERRIDE))
+		{
+			G2_TimingModel(boneList[boneListIndex],BC.incomingTime,BC.header->numFrames,TB.currentFrame,TB.newFrame,TB.backlerp);
+		}
+#if DEBUG_G2_TIMING
+		printTiming=true;
+#endif
+		if ((r_Ghoul2NoLerp->integer)||((boneList[boneListIndex].flags) & (BONE_ANIM_NO_LERP)))
+		{
+			TB.backlerp = 0.0f;
+		}
+	}
+	// figure out where the location of the bone animation data is
+	assert(TB.newFrame>=0&&TB.newFrame<BC.header->numFrames);
+	if (!(TB.newFrame>=0&&TB.newFrame<BC.header->numFrames))
+	{
+		TB.newFrame=0;
+	}
+//	aFrame = (mdxaFrame_t *)((byte *)BC.header + BC.header->ofsFrames + TB.newFrame * BC.frameSize );
+	assert(TB.currentFrame>=0&&TB.currentFrame<BC.header->numFrames);
+	if (!(TB.currentFrame>=0&&TB.currentFrame<BC.header->numFrames))
+	{
+		TB.currentFrame=0;
+	}
+//	aoldFrame = (mdxaFrame_t *)((byte *)BC.header + BC.header->ofsFrames + TB.currentFrame * BC.frameSize );
+
+	// figure out where the location of the blended animation data is
+	assert(!(TB.blendFrame < 0.0 || TB.blendFrame >= (BC.header->numFrames+1)));
+	if (TB.blendFrame < 0.0 || TB.blendFrame >= (BC.header->numFrames+1) )
+	{
+		TB.blendFrame=0.0;
+	}
+//	bFrame = (mdxaFrame_t *)((byte *)BC.header + BC.header->ofsFrames + (int)TB.blendFrame * BC.frameSize );
+	assert(TB.blendOldFrame>=0&&TB.blendOldFrame<BC.header->numFrames);
+	if (!(TB.blendOldFrame>=0&&TB.blendOldFrame<BC.header->numFrames))
+	{
+		TB.blendOldFrame=0;
+	}
+#if DEBUG_G2_TIMING
+
+#if DEBUG_G2_TIMING_RENDER_ONLY
+	if (!HackadelicOnClient)
+	{
+		printTiming=false;
+	}
+#endif
+	if (printTiming)
+	{
+		char mess[1000];
+		if (TB.blendMode)
+		{
+			sprintf(mess,"b %2d %5d   %4d %4d %4d %4d  %f %f\n",boneListIndex,BC.incomingTime,(int)TB.newFrame,(int)TB.currentFrame,(int)TB.blendFrame,(int)TB.blendOldFrame,TB.backlerp,TB.blendLerp);
+		}
+		else
+		{
+			sprintf(mess,"a %2d %5d   %4d %4d            %f\n",boneListIndex,BC.incomingTime,TB.newFrame,TB.currentFrame,TB.backlerp);
+		}
+		OutputDebugString(mess);
+		const boneInfo_t &bone=boneList[boneListIndex];
+		if (bone.flags&BONE_ANIM_BLEND)
+		{
+			sprintf(mess,"                                                                    bfb[%2d] %5d  %5d  (%5d-%5d) %4.2f %4x   bt(%5d-%5d) %7.2f %5d\n",
+				boneListIndex,
+				BC.incomingTime,
+				bone.startTime,
+				bone.startFrame,
+				bone.endFrame,
+				bone.animSpeed,
+				bone.flags,
+				bone.blendStart,
+				bone.blendStart+bone.blendTime,
+				bone.blendFrame,
+				bone.blendLerpFrame
+				);
+		}
+		else
+		{
+			sprintf(mess,"                                                                    bfa[%2d] %5d  %5d  (%5d-%5d) %4.2f %4x\n",
+				boneListIndex,
+				BC.incomingTime,
+				bone.startTime,
+				bone.startFrame,
+				bone.endFrame,
+				bone.animSpeed,
+				bone.flags
+				);
+		}
+//		OutputDebugString(mess);
+	}
+#endif
+//	boldFrame = (mdxaFrame_t *)((byte *)BC.header + BC.header->ofsFrames + TB.blendOldFrame * BC.frameSize );
+
+//	mdxaCompBone_t	*compBonePointer = (mdxaCompBone_t *)((byte *)BC.header + BC.header->ofsCompBonePool);
+
+	assert(child>=0&&child<BC.header->numBones);
+//	assert(bFrame->boneIndexes[child]>=0);
+//	assert(boldFrame->boneIndexes[child]>=0);
+//	assert(aFrame->boneIndexes[child]>=0);
+//	assert(aoldFrame->boneIndexes[child]>=0);
+
+	// decide where the transformed bone is going
+
+	// are we blending with another frame of anim?
+	if (TB.blendMode)
+	{
+		float backlerp = TB.blendFrame - (int)TB.blendFrame;
+		float frontlerp = 1.0 - backlerp;
+		
+// 		MC_UnCompress(tbone[3].matrix,compBonePointer[bFrame->boneIndexes[child]].Comp);
+// 		MC_UnCompress(tbone[4].matrix,compBonePointer[boldFrame->boneIndexes[child]].Comp);
+		UnCompressBone(tbone[3].matrix, child, BC.header, TB.blendFrame);
+		UnCompressBone(tbone[4].matrix, child, BC.header, TB.blendOldFrame);
+
+		for ( j = 0 ; j < 12 ; j++ ) 
+		{
+  			((float *)&tbone[5])[j] = (backlerp * ((float *)&tbone[3])[j])
+				+ (frontlerp * ((float *)&tbone[4])[j]);
+		}
+	}
+	
+  	//
+  	// lerp this bone - use the temp space on the ref entity to put the bone transforms into
+  	//
+  	if (!TB.backlerp)
+  	{
+// 		MC_UnCompress(tbone[2].matrix,compBonePointer[aoldFrame->boneIndexes[child]].Comp);
+		UnCompressBone(tbone[2].matrix, child, BC.header, TB.currentFrame);
+
+		// blend in the other frame if we need to
+		if (TB.blendMode)
+		{
+			float blendFrontlerp = 1.0 - TB.blendLerp;
+	  		for ( j = 0 ; j < 12 ; j++ ) 
+			{
+  				((float *)&tbone[2])[j] = (TB.blendLerp * ((float *)&tbone[2])[j])
+					+ (blendFrontlerp * ((float *)&tbone[5])[j]);
+			}
+		}
+
+  		if (!child)
+		{
+			// now multiply by the root matrix, so we can offset this model should we need to
+			Multiply_3x4Matrix(&BC.mFinalBones[child].boneMatrix, &BC.rootMatrix, &tbone[2]);
+ 		}
+  	}
+	else
+  	{
+		float frontlerp = 1.0 - TB.backlerp;
+// 		MC_UnCompress(tbone[0].matrix,compBonePointer[aFrame->boneIndexes[child]].Comp);
+//		MC_UnCompress(tbone[1].matrix,compBonePointer[aoldFrame->boneIndexes[child]].Comp);
+		UnCompressBone(tbone[0].matrix, child, BC.header, TB.newFrame);
+		UnCompressBone(tbone[1].matrix, child, BC.header, TB.currentFrame);		
+
+		for ( j = 0 ; j < 12 ; j++ ) 
+		{
+  			((float *)&tbone[2])[j] = (TB.backlerp * ((float *)&tbone[0])[j])
+				+ (frontlerp * ((float *)&tbone[1])[j]);
+		}
+
+		// blend in the other frame if we need to
+		if (TB.blendMode)
+		{
+			float blendFrontlerp = 1.0 - TB.blendLerp;
+	  		for ( j = 0 ; j < 12 ; j++ ) 
+			{
+  				((float *)&tbone[2])[j] = (TB.blendLerp * ((float *)&tbone[2])[j])
+					+ (blendFrontlerp * ((float *)&tbone[5])[j]);
+			}
+		}
+
+  		if (!child)
+  		{
+			// now multiply by the root matrix, so we can offset this model should we need to
+			Multiply_3x4Matrix(&BC.mFinalBones[child].boneMatrix, &BC.rootMatrix, &tbone[2]);
+  		}
+	}
+	// figure out where the bone hirearchy info is
+	offsets = (mdxaSkelOffsets_t *)((byte *)BC.header + sizeof(mdxaHeader_t));
+	skel = (mdxaSkel_t *)((byte *)BC.header + sizeof(mdxaHeader_t) + offsets->offsets[child]);
+
+	int parent=BC.mFinalBones[child].parent;
+	assert((parent==-1&&child==0)||(parent>=0&&parent<BC.mNumBones));
+	if (angleOverride & BONE_ANGLES_REPLACE)
+	{
+		bool isRag=!!(angleOverride & BONE_ANGLES_RAGDOLL);
+		if (!isRag)
+		{ //do the same for ik.. I suppose.
+			isRag = !!(angleOverride & BONE_ANGLES_IK);
+		}
+
+		mdxaBone_t &bone = BC.mFinalBones[child].boneMatrix;
+		boneInfo_t &boneOverride = boneList[boneListIndex];
+
+		if (isRag)
+		{
+			mdxaBone_t temp, firstPass;
+			// give us the matrix the animation thinks we should have, so we can get the correct X&Y coors
+			Multiply_3x4Matrix(&firstPass, &BC.mFinalBones[parent].boneMatrix, &tbone[2]);
+			// this is crazy, we are gonna drive the animation to ID while we are doing post mults to compensate.
+			Multiply_3x4Matrix(&temp,&firstPass, &skel->BasePoseMat);
+			float	matrixScale = VectorLength((float*)&temp);
+			static mdxaBone_t		toMatrix = 
+			{ 
+				1.0f, 0.0f, 0.0f, 0.0f,
+				0.0f, 1.0f, 0.0f, 0.0f,
+				0.0f, 0.0f, 1.0f, 0.0f
+			};
+			toMatrix.matrix[0][0]=matrixScale;
+			toMatrix.matrix[1][1]=matrixScale;
+			toMatrix.matrix[2][2]=matrixScale;
+			toMatrix.matrix[0][3]=temp.matrix[0][3];
+			toMatrix.matrix[1][3]=temp.matrix[1][3];
+			toMatrix.matrix[2][3]=temp.matrix[2][3];
+
+ 			Multiply_3x4Matrix(&temp, &toMatrix,&skel->BasePoseMatInv); //dest first arg
+
+			float blendTime = BC.incomingTime - boneList[boneListIndex].boneBlendStart;
+			float blendLerp = (blendTime / boneList[boneListIndex].boneBlendTime);
+			if (blendLerp>0.0f)
+			{
+				// has started
+				if (blendLerp>1.0f)
+				{
+					// done
+//					Multiply_3x4Matrix(&bone, &BC.mFinalBones[parent].boneMatrix,&temp);
+					memcpy (&bone,&temp, sizeof(mdxaBone_t));
+				}
+				else
+				{
+//					mdxaBone_t lerp;
+					// now do the blend into the destination
+					float blendFrontlerp = 1.0 - blendLerp;
+	  				for ( j = 0 ; j < 12 ; j++ ) 
+					{
+  						((float *)&bone)[j] = (blendLerp * ((float *)&temp)[j])
+							+ (blendFrontlerp * ((float *)&tbone[2])[j]);
+					}
+//					Multiply_3x4Matrix(&bone, &BC.mFinalBones[parent].boneMatrix,&lerp);
+				}
+			}
+		}
+		else
+		{
+			mdxaBone_t temp, firstPass;
+
+			// give us the matrix the animation thinks we should have, so we can get the correct X&Y coors
+			Multiply_3x4Matrix(&firstPass, &BC.mFinalBones[parent].boneMatrix, &tbone[2]);
+
+			// are we attempting to blend with the base animation? and still within blend time?
+			if (boneOverride.boneBlendTime && (((boneOverride.boneBlendTime + boneOverride.boneBlendStart) < BC.incomingTime)))
+			{
+				// ok, we are supposed to be blending. Work out lerp
+				float blendTime = BC.incomingTime - boneList[boneListIndex].boneBlendStart;
+				float blendLerp = (blendTime / boneList[boneListIndex].boneBlendTime);
+
+				if (blendLerp <= 1)
+				{
+					if (blendLerp < 0)
+					{
+						assert(0);
+					}
+
+					// now work out the matrix we want to get *to* - firstPass is where we are coming *from*
+					Multiply_3x4Matrix(&temp, &firstPass, &skel->BasePoseMat);
+
+					float	matrixScale = VectorLength((float*)&temp);
+
+					mdxaBone_t	newMatrixTemp;
+					
+					if (HackadelicOnClient)
+					{
+						for (int i=0; i<3;i++)
+						{
+							for(int x=0;x<3; x++)
+							{
+								newMatrixTemp.matrix[i][x] = boneOverride.newMatrix.matrix[i][x]*matrixScale;
+							}
+						}
+
+						newMatrixTemp.matrix[0][3] = temp.matrix[0][3];
+						newMatrixTemp.matrix[1][3] = temp.matrix[1][3]; 
+						newMatrixTemp.matrix[2][3] = temp.matrix[2][3];
+					}
+					else
+					{
+						for (int i=0; i<3;i++)
+						{
+							for(int x=0;x<3; x++)
+							{
+								newMatrixTemp.matrix[i][x] = boneOverride.matrix.matrix[i][x]*matrixScale;
+							}
+						}
+
+						newMatrixTemp.matrix[0][3] = temp.matrix[0][3];
+						newMatrixTemp.matrix[1][3] = temp.matrix[1][3]; 
+						newMatrixTemp.matrix[2][3] = temp.matrix[2][3];
+					}
+				
+ 					Multiply_3x4Matrix(&temp, &newMatrixTemp,&skel->BasePoseMatInv);
+
+					// now do the blend into the destination
+					float blendFrontlerp = 1.0 - blendLerp;
+	  				for ( j = 0 ; j < 12 ; j++ ) 
+					{
+  						((float *)&bone)[j] = (blendLerp * ((float *)&temp)[j])
+							+ (blendFrontlerp * ((float *)&firstPass)[j]);
+					}
+				}
+				else
+				{
+					bone = firstPass;
+				}
+			}
+			// no, so just override it directly
+			else
+			{
+
+				Multiply_3x4Matrix(&temp,&firstPass, &skel->BasePoseMat);
+				float	matrixScale = VectorLength((float*)&temp);
+
+				mdxaBone_t	newMatrixTemp;
+				
+				if (HackadelicOnClient)
+				{
+					for (int i=0; i<3;i++)
+					{
+						for(int x=0;x<3; x++)
+						{
+							newMatrixTemp.matrix[i][x] = boneOverride.newMatrix.matrix[i][x]*matrixScale;
+						}
+					}
+					
+					newMatrixTemp.matrix[0][3] = temp.matrix[0][3];
+					newMatrixTemp.matrix[1][3] = temp.matrix[1][3]; 
+					newMatrixTemp.matrix[2][3] = temp.matrix[2][3];
+				}
+				else
+				{
+					for (int i=0; i<3;i++)
+					{
+						for(int x=0;x<3; x++)
+						{
+							newMatrixTemp.matrix[i][x] = boneOverride.matrix.matrix[i][x]*matrixScale;
+						}
+					}
+					
+					newMatrixTemp.matrix[0][3] = temp.matrix[0][3];
+					newMatrixTemp.matrix[1][3] = temp.matrix[1][3]; 
+					newMatrixTemp.matrix[2][3] = temp.matrix[2][3];
+				}
+			
+ 				Multiply_3x4Matrix(&bone, &newMatrixTemp,&skel->BasePoseMatInv);
+			}
+		}
+	}
+	else if (angleOverride & BONE_ANGLES_PREMULT)
+	{
+		if ((angleOverride&BONE_ANGLES_RAGDOLL) || (angleOverride&BONE_ANGLES_IK))
+		{
+			mdxaBone_t	tmp;
+			if (!child)
+			{
+				if (HackadelicOnClient)
+				{
+					Multiply_3x4Matrix(&tmp, &BC.rootMatrix, &boneList[boneListIndex].newMatrix);
+				}
+				else
+				{
+					Multiply_3x4Matrix(&tmp, &BC.rootMatrix, &boneList[boneListIndex].matrix);
+				}
+			}
+			else
+			{
+				if (HackadelicOnClient)
+				{
+					Multiply_3x4Matrix(&tmp, &BC.mFinalBones[parent].boneMatrix, &boneList[boneListIndex].newMatrix);
+				}
+				else
+				{
+					Multiply_3x4Matrix(&tmp, &BC.mFinalBones[parent].boneMatrix, &boneList[boneListIndex].matrix);
+				}
+			}
+			Multiply_3x4Matrix(&BC.mFinalBones[child].boneMatrix,&tmp, &tbone[2]);
+		}
+		else
+		{
+			if (!child)
+			{
+				// use the in coming root matrix as our basis
+				if (HackadelicOnClient)
+				{
+					Multiply_3x4Matrix(&BC.mFinalBones[child].boneMatrix, &BC.rootMatrix, &boneList[boneListIndex].newMatrix);
+				}
+				else
+				{
+					Multiply_3x4Matrix(&BC.mFinalBones[child].boneMatrix, &BC.rootMatrix, &boneList[boneListIndex].matrix);
+				}
+ 			}
+			else
+			{
+				// convert from 3x4 matrix to a 4x4 matrix
+				if (HackadelicOnClient)
+				{
+					Multiply_3x4Matrix(&BC.mFinalBones[child].boneMatrix, &BC.mFinalBones[parent].boneMatrix, &boneList[boneListIndex].newMatrix);
+				}
+				else
+				{
+					Multiply_3x4Matrix(&BC.mFinalBones[child].boneMatrix, &BC.mFinalBones[parent].boneMatrix, &boneList[boneListIndex].matrix);
+				}
+			}
+		}
+	}
+	else
+	// now transform the matrix by it's parent, asumming we have a parent, and we aren't overriding the angles absolutely
+	if (child)
+	{
+		Multiply_3x4Matrix(&BC.mFinalBones[child].boneMatrix, &BC.mFinalBones[parent].boneMatrix, &tbone[2]);
+	}
+
+	// now multiply our resulting bone by an override matrix should we need to
+	if (angleOverride & BONE_ANGLES_POSTMULT)
+	{
+		mdxaBone_t	tempMatrix;
+		memcpy (&tempMatrix,&BC.mFinalBones[child].boneMatrix, sizeof(mdxaBone_t));
+		if (HackadelicOnClient)
+		{
+		  	Multiply_3x4Matrix(&BC.mFinalBones[child].boneMatrix, &tempMatrix, &boneList[boneListIndex].newMatrix);
+		}
+		else
+		{
+		  	Multiply_3x4Matrix(&BC.mFinalBones[child].boneMatrix, &tempMatrix, &boneList[boneListIndex].matrix);
+		}
+	}
+	if (r_Ghoul2UnSqash->integer)
+	{
+		mdxaBone_t tempMatrix;
+		Multiply_3x4Matrix(&tempMatrix,&BC.mFinalBones[child].boneMatrix, &skel->BasePoseMat);
+		float maxl;
+		maxl=VectorLength(&skel->BasePoseMat.matrix[0][0]);
+		VectorNormalize(&tempMatrix.matrix[0][0]);
+		VectorNormalize(&tempMatrix.matrix[1][0]);
+		VectorNormalize(&tempMatrix.matrix[2][0]);
+
+		VectorScale(&tempMatrix.matrix[0][0],maxl,&tempMatrix.matrix[0][0]);
+		VectorScale(&tempMatrix.matrix[1][0],maxl,&tempMatrix.matrix[1][0]);
+		VectorScale(&tempMatrix.matrix[2][0],maxl,&tempMatrix.matrix[2][0]);
+		Multiply_3x4Matrix(&BC.mFinalBones[child].boneMatrix,&tempMatrix,&skel->BasePoseMatInv);
+	}
+
+}
+
+
+#define		GHOUL2_RAG_STARTED						0x0010
+
+// start the recursive hirearchial bone transform and lerp process for this model
+void G2_TransformGhoulBones(boneInfo_v &rootBoneList,mdxaBone_t &rootMatrix, CGhoul2Info &ghoul2, int time,bool smooth=true)
+{
+#ifdef G2_PERFORMANCE_ANALYSIS
+	G2PerformanceCounter_G2_TransformGhoulBones++;
+#endif
+	assert(ghoul2.aHeader);
+	assert(ghoul2.currentModel);
+	assert(ghoul2.currentModel->mdxm);
+	if (!ghoul2.aHeader->numBones)
+	{
+		assert(0); // this would be strange
+		return;
+	}
+	if (!ghoul2.mBoneCache)
+	{
+		ghoul2.mBoneCache=new CBoneCache(ghoul2.currentModel,ghoul2.aHeader);
+	}
+	ghoul2.mBoneCache->mod=ghoul2.currentModel;
+	ghoul2.mBoneCache->header=ghoul2.aHeader; 
+	assert((int)ghoul2.mBoneCache->mNumBones==ghoul2.aHeader->numBones);
+
+	ghoul2.mBoneCache->mSmoothingActive=false;
+	ghoul2.mBoneCache->mUnsquash=false;
+
+	// master smoothing control
+	float val=r_Ghoul2AnimSmooth->value;
+	if (smooth&&val>0.0f&&val<1.0f)
+	{
+		ghoul2.mBoneCache->mLastTouch=ghoul2.mBoneCache->mLastLastTouch;
+
+		if(ghoul2.mFlags & GHOUL2_RAG_STARTED)
+		{
+			int k;
+			for (k=0;k<rootBoneList.size();k++)
+			{
+				boneInfo_t &bone=rootBoneList[k];
+				if (bone.flags&BONE_ANGLES_RAGDOLL)
+				{
+					if (bone.firstCollisionTime &&
+						bone.firstCollisionTime>time-250 &&
+						bone.firstCollisionTime<time)
+					{
+						val=0.9f;//(val+0.8f)/2.0f;
+					}
+					else if (bone.airTime > time)
+					{
+						val = 0.2f;
+					}
+					else
+					{
+						val = 0.8f;
+					}
+					break;
+				}
+			}
+		}
+
+		ghoul2.mBoneCache->mSmoothFactor=val;
+		ghoul2.mBoneCache->mSmoothingActive=true;
+		if (r_Ghoul2UnSqashAfterSmooth->integer)
+		{
+			ghoul2.mBoneCache->mUnsquash=true;
+		}
+	}
+	else
+	{
+		ghoul2.mBoneCache->mSmoothFactor=1.0f;
+	}
+	ghoul2.mBoneCache->mCurrentTouch++;
+
+//rww - RAGDOLL_BEGIN
+	if (HackadelicOnClient)
+	{
+		ghoul2.mBoneCache->mLastLastTouch=ghoul2.mBoneCache->mCurrentTouch;
+		ghoul2.mBoneCache->mCurrentTouchRender=ghoul2.mBoneCache->mCurrentTouch;
+	}
+	else
+	{
+		ghoul2.mBoneCache->mCurrentTouchRender=0;
+	}
+//rww - RAGDOLL_END
+
+//	ghoul2.mBoneCache->mWraithID=0;
+	ghoul2.mBoneCache->frameSize = 0;// can be deleted in new G2 format	//(int)( &((mdxaFrame_t *)0)->boneIndexes[ ghoul2.aHeader->numBones ] );   
+
+	ghoul2.mBoneCache->rootBoneList=&rootBoneList;
+	ghoul2.mBoneCache->rootMatrix=rootMatrix;
+	ghoul2.mBoneCache->incomingTime=time;
+
+	SBoneCalc &TB=ghoul2.mBoneCache->Root();
+	TB.newFrame=0;
+	TB.currentFrame=0;
+	TB.backlerp=0.0f;
+	TB.blendFrame=0;
+	TB.blendOldFrame=0;
+	TB.blendMode=false;
+	TB.blendLerp=0;
+
+}
+
+
+#define MDX_TAG_ORIGIN 2
+
+//======================================================================
+//
+// Surface Manipulation code 
+
+
+// We've come across a surface that's designated as a bolt surface, process it and put it in the appropriate bolt place
+void G2_ProcessSurfaceBolt2(CBoneCache &boneCache, const mdxmSurface_t *surface, int boltNum, boltInfo_v &boltList, const surfaceInfo_t *surfInfo, const model_t *mod,mdxaBone_t &retMatrix)
+{
+ 	mdxmVertex_t 	*v, *vert0, *vert1, *vert2;
+ 	vec3_t			axes[3], sides[3];
+ 	float			pTri[3][3], d;
+ 	int				j, k;
+
+	// now there are two types of tag surface - model ones and procedural generated types - lets decide which one we have here.
+	if (surfInfo && surfInfo->offFlags == G2SURFACEFLAG_GENERATED)
+	{
+		int surfNumber = surfInfo->genPolySurfaceIndex & 0x0ffff;
+		int	polyNumber = (surfInfo->genPolySurfaceIndex >> 16) & 0x0ffff;
+
+		// find original surface our original poly was in.
+		mdxmSurface_t	*originalSurf = (mdxmSurface_t *)G2_FindSurface(mod, surfNumber, surfInfo->genLod);
+		mdxmTriangle_t	*originalTriangleIndexes = (mdxmTriangle_t *)((byte*)originalSurf + originalSurf->ofsTriangles);
+
+		// get the original polys indexes 
+		int index0 = originalTriangleIndexes[polyNumber].indexes[0];
+		int index1 = originalTriangleIndexes[polyNumber].indexes[1];
+		int index2 = originalTriangleIndexes[polyNumber].indexes[2];
+
+		// decide where the original verts are
+ 		vert0 = (mdxmVertex_t *) ((byte *)originalSurf + originalSurf->ofsVerts);
+		vert0+=index0;
+
+		vert1 = (mdxmVertex_t *) ((byte *)originalSurf + originalSurf->ofsVerts);
+		vert1+=index1;
+
+		vert2 = (mdxmVertex_t *) ((byte *)originalSurf + originalSurf->ofsVerts);
+		vert2+=index2;
+
+		// clear out the triangle verts to be
+ 	   	VectorClear( pTri[0] );
+ 	   	VectorClear( pTri[1] );
+ 	   	VectorClear( pTri[2] );
+		int *piBoneReferences = (int*) ((byte*)originalSurf + originalSurf->ofsBoneReferences);
+
+//		mdxmWeight_t	*w;
+		
+		// now go and transform just the points we need from the surface that was hit originally
+//		w = vert0->weights;
+		float fTotalWeight = 0.0f;
+		int iNumWeights = G2_GetVertWeights( vert0 );
+ 		for ( k = 0 ; k < iNumWeights ; k++ ) 
+ 		{
+			int		iBoneIndex	= G2_GetVertBoneIndex( vert0, k );
+			float	fBoneWeight	= G2_GetVertBoneWeight( vert0, k, fTotalWeight, iNumWeights );
+
+			const mdxaBone_t &bone=boneCache.Eval(piBoneReferences[iBoneIndex]);
+
+#ifdef _XBOX
+			vec3_t vec;
+			Q_CastShort2FloatScale(&vec[0], &vert0->vertCoords[0], 1.f / (float)GLM_COMP_SIZE);
+			Q_CastShort2FloatScale(&vec[1], &vert0->vertCoords[1], 1.f / (float)GLM_COMP_SIZE);
+			Q_CastShort2FloatScale(&vec[2], &vert0->vertCoords[2], 1.f / (float)GLM_COMP_SIZE);
+
+			pTri[0][0] += fBoneWeight * ( DotProduct( bone.matrix[0], vec ) + bone.matrix[0][3] );
+			pTri[0][1] += fBoneWeight * ( DotProduct( bone.matrix[1], vec ) + bone.matrix[1][3] );
+			pTri[0][2] += fBoneWeight * ( DotProduct( bone.matrix[2], vec ) + bone.matrix[2][3] );
+#else
+			pTri[0][0] += fBoneWeight * ( DotProduct( bone.matrix[0], vert0->vertCoords ) + bone.matrix[0][3] );
+ 			pTri[0][1] += fBoneWeight * ( DotProduct( bone.matrix[1], vert0->vertCoords ) + bone.matrix[1][3] );
+ 			pTri[0][2] += fBoneWeight * ( DotProduct( bone.matrix[2], vert0->vertCoords ) + bone.matrix[2][3] );
+#endif
+		}
+
+//		w = vert1->weights;
+		fTotalWeight = 0.0f;
+		iNumWeights = G2_GetVertWeights( vert1 );
+ 		for ( k = 0 ; k < iNumWeights ; k++) 
+ 		{
+			int		iBoneIndex	= G2_GetVertBoneIndex( vert1, k );
+			float	fBoneWeight	= G2_GetVertBoneWeight( vert1, k, fTotalWeight, iNumWeights );
+
+			const mdxaBone_t &bone=boneCache.Eval(piBoneReferences[iBoneIndex]);
+
+#ifdef _XBOX
+			vec3_t vec;
+			Q_CastShort2FloatScale(&vec[0], &vert1->vertCoords[0], 1.f / (float)GLM_COMP_SIZE);
+			Q_CastShort2FloatScale(&vec[1], &vert1->vertCoords[1], 1.f / (float)GLM_COMP_SIZE);
+			Q_CastShort2FloatScale(&vec[2], &vert1->vertCoords[2], 1.f / (float)GLM_COMP_SIZE);
+
+			pTri[1][0] += fBoneWeight * ( DotProduct( bone.matrix[0], vec ) + bone.matrix[0][3] );
+			pTri[1][1] += fBoneWeight * ( DotProduct( bone.matrix[1], vec ) + bone.matrix[1][3] );
+			pTri[1][2] += fBoneWeight * ( DotProduct( bone.matrix[2], vec ) + bone.matrix[2][3] );
+#else
+            pTri[1][0] += fBoneWeight * ( DotProduct( bone.matrix[0], vert1->vertCoords ) + bone.matrix[0][3] );
+ 			pTri[1][1] += fBoneWeight * ( DotProduct( bone.matrix[1], vert1->vertCoords ) + bone.matrix[1][3] );
+ 			pTri[1][2] += fBoneWeight * ( DotProduct( bone.matrix[2], vert1->vertCoords ) + bone.matrix[2][3] );
+#endif
+		}
+
+//		w = vert2->weights;
+		fTotalWeight = 0.0f;
+		iNumWeights = G2_GetVertWeights( vert2 );
+ 		for ( k = 0 ; k < iNumWeights ; k++) 
+ 		{
+			int		iBoneIndex	= G2_GetVertBoneIndex( vert2, k );
+			float	fBoneWeight	= G2_GetVertBoneWeight( vert2, k, fTotalWeight, iNumWeights );
+
+			const mdxaBone_t &bone=boneCache.Eval(piBoneReferences[iBoneIndex]);
+
+#ifdef _XBOX
+			vec3_t vec;
+			Q_CastShort2FloatScale(&vec[0], &vert2->vertCoords[0], 1.f / (float)GLM_COMP_SIZE);
+			Q_CastShort2FloatScale(&vec[1], &vert2->vertCoords[1], 1.f / (float)GLM_COMP_SIZE);
+			Q_CastShort2FloatScale(&vec[2], &vert2->vertCoords[2], 1.f / (float)GLM_COMP_SIZE);
+
+			pTri[2][0] += fBoneWeight * ( DotProduct( bone.matrix[0], vec ) + bone.matrix[0][3] );
+			pTri[2][1] += fBoneWeight * ( DotProduct( bone.matrix[1], vec ) + bone.matrix[1][3] );
+			pTri[2][2] += fBoneWeight * ( DotProduct( bone.matrix[2], vec ) + bone.matrix[2][3] );
+#else
+            pTri[2][0] += fBoneWeight * ( DotProduct( bone.matrix[0], vert2->vertCoords ) + bone.matrix[0][3] );
+ 			pTri[2][1] += fBoneWeight * ( DotProduct( bone.matrix[1], vert2->vertCoords ) + bone.matrix[1][3] );
+ 			pTri[2][2] += fBoneWeight * ( DotProduct( bone.matrix[2], vert2->vertCoords ) + bone.matrix[2][3] );
+#endif
+		}
+ 			
+   		vec3_t normal;
+		vec3_t up;
+		vec3_t right;
+		vec3_t vec0, vec1;
+		// work out baryCentricK
+		float baryCentricK = 1.0 - (surfInfo->genBarycentricI + surfInfo->genBarycentricJ);
+
+		// now we have the model transformed into model space, now generate an origin.
+		retMatrix.matrix[0][3] = (pTri[0][0] * surfInfo->genBarycentricI) + (pTri[1][0] * surfInfo->genBarycentricJ) + (pTri[2][0] * baryCentricK);
+		retMatrix.matrix[1][3] = (pTri[0][1] * surfInfo->genBarycentricI) + (pTri[1][1] * surfInfo->genBarycentricJ) + (pTri[2][1] * baryCentricK);
+		retMatrix.matrix[2][3] = (pTri[0][2] * surfInfo->genBarycentricI) + (pTri[1][2] * surfInfo->genBarycentricJ) + (pTri[2][2] * baryCentricK);
+
+		// generate a normal to this new triangle
+		VectorSubtract(pTri[0], pTri[1], vec0);
+		VectorSubtract(pTri[2], pTri[1], vec1);
+
+		CrossProduct(vec0, vec1, normal);
+		VectorNormalize(normal);
+
+		// forward vector
+		retMatrix.matrix[0][0] = normal[0];
+		retMatrix.matrix[1][0] = normal[1];
+		retMatrix.matrix[2][0] = normal[2];
+
+		// up will be towards point 0 of the original triangle.
+		// so lets work it out. Vector is hit point - point 0
+		up[0] = retMatrix.matrix[0][3] - pTri[0][0];
+		up[1] = retMatrix.matrix[1][3] - pTri[0][1];
+		up[2] = retMatrix.matrix[2][3] - pTri[0][2];
+
+		// normalise it
+		VectorNormalize(up);
+
+		// that's the up vector
+		retMatrix.matrix[0][1] = up[0];
+		retMatrix.matrix[1][1] = up[1];
+		retMatrix.matrix[2][1] = up[2];
+
+		// right is always straight
+
+		CrossProduct( normal, up, right );
+		// that's the up vector
+		retMatrix.matrix[0][2] = right[0];
+		retMatrix.matrix[1][2] = right[1];
+		retMatrix.matrix[2][2] = right[2];
+
+
+	}
+	// no, we are looking at a normal model tag
+	else
+	{
+	 	// whip through and actually transform each vertex
+ 		v = (mdxmVertex_t *) ((byte *)surface + surface->ofsVerts);
+		int *piBoneReferences = (int*) ((byte*)surface + surface->ofsBoneReferences);
+ 		for ( j = 0; j < 3; j++ ) 
+ 		{
+// 			mdxmWeight_t	*w;
+
+ 			VectorClear( pTri[j] );
+ //			w = v->weights;
+
+			const int iNumWeights = G2_GetVertWeights( v );
+
+			float fTotalWeight = 0.0f;
+ 			for ( k = 0 ; k < iNumWeights ; k++) 
+ 			{
+				int		iBoneIndex	= G2_GetVertBoneIndex( v, k );
+				float	fBoneWeight	= G2_GetVertBoneWeight( v, k, fTotalWeight, iNumWeights );
+
+				const mdxaBone_t &bone=boneCache.Eval(piBoneReferences[iBoneIndex]);
+
+#ifdef _XBOX
+				vec3_t vec;
+				Q_CastShort2FloatScale(&vec[0], &v->vertCoords[0], 1.f / (float)GLM_COMP_SIZE);
+				Q_CastShort2FloatScale(&vec[1], &v->vertCoords[1], 1.f / (float)GLM_COMP_SIZE);
+				Q_CastShort2FloatScale(&vec[2], &v->vertCoords[2], 1.f / (float)GLM_COMP_SIZE);
+
+				pTri[j][0] += fBoneWeight * ( DotProduct( bone.matrix[0], vec ) + bone.matrix[0][3] );
+				pTri[j][1] += fBoneWeight * ( DotProduct( bone.matrix[1], vec ) + bone.matrix[1][3] );
+				pTri[j][2] += fBoneWeight * ( DotProduct( bone.matrix[2], vec ) + bone.matrix[2][3] );
+#else
+                pTri[j][0] += fBoneWeight * ( DotProduct( bone.matrix[0], v->vertCoords ) + bone.matrix[0][3] );
+ 				pTri[j][1] += fBoneWeight * ( DotProduct( bone.matrix[1], v->vertCoords ) + bone.matrix[1][3] );
+ 				pTri[j][2] += fBoneWeight * ( DotProduct( bone.matrix[2], v->vertCoords ) + bone.matrix[2][3] );
+#endif
+ 			}
+ 			
+ 			v++;// = (mdxmVertex_t *)&v->weights[/*v->numWeights*/surface->maxVertBoneWeights];
+ 		}
+
+ 		// clear out used arrays
+ 		memset( axes, 0, sizeof( axes ) );
+ 		memset( sides, 0, sizeof( sides ) );
+
+ 		// work out actual sides of the tag triangle
+ 		for ( j = 0; j < 3; j++ )
+ 		{
+ 			sides[j][0] = pTri[(j+1)%3][0] - pTri[j][0];
+ 			sides[j][1] = pTri[(j+1)%3][1] - pTri[j][1];
+ 			sides[j][2] = pTri[(j+1)%3][2] - pTri[j][2];
+ 		}
+
+ 		// do math trig to work out what the matrix will be from this triangle's translated position
+ 		VectorNormalize2( sides[iG2_TRISIDE_LONGEST], axes[0] );
+ 		VectorNormalize2( sides[iG2_TRISIDE_SHORTEST], axes[1] );
+
+ 		// project shortest side so that it is exactly 90 degrees to the longer side
+ 		d = DotProduct( axes[0], axes[1] );
+ 		VectorMA( axes[0], -d, axes[1], axes[0] );
+ 		VectorNormalize2( axes[0], axes[0] );
+
+ 		CrossProduct( sides[iG2_TRISIDE_LONGEST], sides[iG2_TRISIDE_SHORTEST], axes[2] );
+ 		VectorNormalize2( axes[2], axes[2] );
+
+ 		// set up location in world space of the origin point in out going matrix
+ 		retMatrix.matrix[0][3] = pTri[MDX_TAG_ORIGIN][0];
+ 		retMatrix.matrix[1][3] = pTri[MDX_TAG_ORIGIN][1];
+ 		retMatrix.matrix[2][3] = pTri[MDX_TAG_ORIGIN][2];
+
+ 		// copy axis to matrix - do some magic to orient minus Y to positive X and so on so bolt on stuff is oriented correctly
+		retMatrix.matrix[0][0] = axes[1][0];
+		retMatrix.matrix[0][1] = axes[0][0];
+		retMatrix.matrix[0][2] = -axes[2][0];
+
+		retMatrix.matrix[1][0] = axes[1][1];
+		retMatrix.matrix[1][1] = axes[0][1];
+		retMatrix.matrix[1][2] = -axes[2][1];
+
+		retMatrix.matrix[2][0] = axes[1][2];
+		retMatrix.matrix[2][1] = axes[0][2];
+		retMatrix.matrix[2][2] = -axes[2][2];
+	}
+
+}
+
+
+void G2_GetBoltMatrixLow(CGhoul2Info &ghoul2,int boltNum,const vec3_t scale,mdxaBone_t &retMatrix)
+{
+	if (!ghoul2.mBoneCache)
+	{
+		retMatrix=identityMatrix;
+		return;
+	}
+	assert(ghoul2.mBoneCache);
+	CBoneCache &boneCache=*ghoul2.mBoneCache;
+	assert(boneCache.mod);
+	boltInfo_v &boltList=ghoul2.mBltlist;
+	assert(boltNum>=0&&boltNum<boltList.size());
+	if (boltList[boltNum].boneNumber>=0)
+	{
+		mdxaSkel_t		*skel;
+		mdxaSkelOffsets_t *offsets;
+		offsets = (mdxaSkelOffsets_t *)((byte *)boneCache.header + sizeof(mdxaHeader_t));
+		skel = (mdxaSkel_t *)((byte *)boneCache.header + sizeof(mdxaHeader_t) + offsets->offsets[boltList[boltNum].boneNumber]);
+		Multiply_3x4Matrix(&retMatrix, &boneCache.EvalUnsmooth(boltList[boltNum].boneNumber), &skel->BasePoseMat);
+	}
+	else if (boltList[boltNum].surfaceNumber>=0)
+	{
+		const surfaceInfo_t *surfInfo=0;
+		{
+			int i;
+			for (i=0;i<ghoul2.mSlist.size();i++)
+			{
+				surfaceInfo_t &t=ghoul2.mSlist[i];
+				if (t.surface==boltList[boltNum].surfaceNumber)
+				{
+					surfInfo=&t;
+				}
+			}
+		}
+		mdxmSurface_t *surface = 0;
+		if (!surfInfo)
+		{
+			surface = (mdxmSurface_t *)G2_FindSurface(boneCache.mod,boltList[boltNum].surfaceNumber, 0);
+		}
+		if (!surface&&surfInfo&&surfInfo->surface<10000)
+		{
+			surface = (mdxmSurface_t *)G2_FindSurface(boneCache.mod,surfInfo->surface, 0);
+		}
+		G2_ProcessSurfaceBolt2(boneCache,surface,boltNum,boltList,surfInfo,(model_t *)boneCache.mod,retMatrix);
+	}
+	else
+	{
+		 // we have a bolt without a bone or surface, not a huge problem but we ought to at least clear the bolt matrix
+		retMatrix=identityMatrix;
+	}
+}
+
+
+
+void G2API_SetSurfaceOnOffFromSkin (CGhoul2Info *ghlInfo, qhandle_t renderSkin)
+{
+	int j;
+	const skin_t	*skin = R_GetSkinByHandle( renderSkin );	
+	//FIXME:  using skin handles means we have to increase the numsurfs in a skin, but reading directly would cause file hits, we need another way to cache or just deal with the larger skin_t
+
+	if (skin)
+	{
+		ghlInfo->mSlist.clear();	//remove any overrides we had before.
+		ghlInfo->mMeshFrameNum = 0;
+		for ( j = 0 ; j < skin->numSurfaces ; j++ )
+		{
+			int	flags;
+			int surfaceNum = G2_IsSurfaceLegal(ghlInfo->currentModel, skin->surfaces[j]->name, &flags);
+			// the names have both been lowercased
+			if ( !(flags&G2SURFACEFLAG_OFF) && !strcmp( skin->surfaces[j]->shader->name , "*off") ) 
+			{
+				G2_SetSurfaceOnOff(ghlInfo, skin->surfaces[j]->name, G2SURFACEFLAG_OFF);
+			}
+			else 
+			{
+				//if ( strcmp( &skin->surfaces[j]->name[strlen(skin->surfaces[j]->name)-4],"_off") )
+				if ( (surfaceNum != -1) && (!(flags&G2SURFACEFLAG_OFF)) )	//only turn on if it's not an "_off" surface
+				{
+					//G2_SetSurfaceOnOff(ghlInfo, skin->surfaces[j]->name, 0);
+				}
+			}
+		}
+	}
+}
+
+// set up each surface ready for rendering in the back end
+void RenderSurfaces(CRenderSurface &RS)
+{
+	int			i;
+	const shader_t	*shader = 0;
+	int			offFlags = 0;
+#ifdef _G2_GORE
+	bool		drawGore = true;
+#endif
+	
+
+	assert(RS.currentModel);
+	assert(RS.currentModel->mdxm);
+	// back track and get the surfinfo struct for this surface
+	mdxmSurface_t			*surface = (mdxmSurface_t *)G2_FindSurface(RS.currentModel, RS.surfaceNum, RS.lod);
+	mdxmHierarchyOffsets_t	*surfIndexes = (mdxmHierarchyOffsets_t *)((byte *)RS.currentModel->mdxm + sizeof(mdxmHeader_t));
+	mdxmSurfHierarchy_t		*surfInfo = (mdxmSurfHierarchy_t *)((byte *)surfIndexes + surfIndexes->offsets[surface->thisSurfaceIndex]);
+	
+	// see if we have an override surface in the surface list
+	const surfaceInfo_t	*surfOverride = G2_FindOverrideSurface(RS.surfaceNum, RS.rootSList);
+
+	// really, we should use the default flags for this surface unless it's been overriden
+	offFlags = surfInfo->flags;
+
+	// set the off flags if we have some
+	if (surfOverride)
+	{
+		offFlags = surfOverride->offFlags;
+	}
+
+	// if this surface is not off, add it to the shader render list
+	if (!offFlags)
+	{	
+ 		if ( RS.cust_shader ) 
+		{
+			shader = RS.cust_shader;
+		} 
+		else if ( RS.skin ) 
+		{
+			int		j;
+			
+			// match the surface name to something in the skin file
+			shader = R_GetShaderByHandle( surfInfo->shaderIndex );	//tr.defaultShader;
+			for ( j = 0 ; j < RS.skin->numSurfaces ; j++ )
+			{
+				// the names have both been lowercased
+				if ( !strcmp( RS.skin->surfaces[j]->name, surfInfo->name ) ) 
+				{
+					shader = RS.skin->surfaces[j]->shader;
+					break;
+				}
+			}
+		} 
+		else 
+		{
+			shader = R_GetShaderByHandle( surfInfo->shaderIndex );
+		}
+
+		// we will add shadows even if the main object isn't visible in the view
+		// stencil shadows can't do personal models unless I polyhedron clip
+		//using z-fail now so can do personal models -rww
+		if ( /*!RS.personalModel
+			&& */r_shadows->integer == 2 
+#ifndef VV_LIGHTING
+//			&& RS.fogNum == 0
+#endif
+			&& (RS.renderfx & RF_SHADOW_PLANE )
+			&& !(RS.renderfx & ( RF_NOSHADOW | RF_DEPTHHACK ) ) 
+			&& shader->sort == SS_OPAQUE ) 
+		{		// set the surface info to point at the where the transformed bone list is going to be for when the surface gets rendered out
+			CRenderableSurface *newSurf = AllocRS();
+#ifdef _XBOX
+			// On Xbox, we always use the lowest LOD
+			mdxmSurface_t *lowsurface = (mdxmSurface_t *)G2_FindSurface(RS.currentModel, RS.surfaceNum, RS.currentModel->numLods-1);
+			newSurf->surfaceData = lowsurface;
+#else
+			if (surface->numVerts >= SHADER_MAX_VERTEXES/2)
+			{ //we need numVerts*2 xyz slots free in tess to do shadow, if this surf is going to exceed that then let's try the lowest lod -rww
+				mdxmSurface_t *lowsurface = (mdxmSurface_t *)G2_FindSurface(RS.currentModel, RS.surfaceNum, RS.currentModel->numLods-1);
+				newSurf->surfaceData = lowsurface;
+			}
+			else
+			{
+				newSurf->surfaceData = surface;
+			}
+#endif
+			newSurf->boneCache = RS.boneCache;
+			R_AddDrawSurf( (surfaceType_t *)newSurf, tr.shadowShader, 0, qfalse );
+		}
+
+		// projection shadows work fine with personal models
+		if ( r_shadows->integer == 3
+//			&& RS.fogNum == 0
+			&& (RS.renderfx & RF_SHADOW_PLANE )
+			&& !(RS.renderfx & ( RF_NOSHADOW ) ) 
+			&& shader->sort == SS_OPAQUE ) 
+		{		// set the surface info to point at the where the transformed bone list is going to be for when the surface gets rendered out
+			CRenderableSurface *newSurf = AllocRS();
+			newSurf->surfaceData = surface;
+			newSurf->boneCache = RS.boneCache;
+			R_AddDrawSurf( (surfaceType_t *)newSurf, tr.projectionShadowShader, 0, qfalse );
+		}
+
+		// don't add third_person objects if not viewing through a portal
+		if ( !RS.personalModel ) 
+		{		// set the surface info to point at the where the transformed bone list is going to be for when the surface gets rendered out
+			CRenderableSurface *newSurf = AllocRS();
+			newSurf->surfaceData = surface;
+			newSurf->boneCache = RS.boneCache;
+			R_AddDrawSurf( (surfaceType_t *)newSurf, shader, RS.fogNum, qfalse );
+
+#ifdef _G2_GORE
+			if (RS.gore_set && drawGore)
+			{
+				int curTime = G2API_GetTime(tr.refdef.time);
+				pair<multimap<int,SGoreSurface>::iterator,multimap<int,SGoreSurface>::iterator> range=
+					RS.gore_set->mGoreRecords.equal_range(RS.surfaceNum);
+				multimap<int,SGoreSurface>::iterator k,kcur;
+				CRenderableSurface *last=newSurf;
+				for (k=range.first;k!=range.second;)
+				{
+					kcur=k;
+					k++;
+					GoreTextureCoordinates *tex=FindGoreRecord((*kcur).second.mGoreTag);
+					if (!tex ||											 // it is gone, lets get rid of it
+						(*kcur).second.mDeleteTime && curTime>=(*kcur).second.mDeleteTime) // out of time
+					{
+						if (tex)
+						{
+							(*tex).~GoreTextureCoordinates();
+							//I don't know what's going on here, it should call the destructor for
+							//this when it erases the record but sometimes it doesn't. -rww
+						}
+
+						RS.gore_set->mGoreRecords.erase(kcur);
+					}
+					else if (tex->tex[RS.lod])
+					{
+						CRenderableSurface *newSurf2 = AllocRS();
+						*newSurf2=*newSurf;
+						newSurf2->goreChain=0;
+						newSurf2->alternateTex=tex->tex[RS.lod];
+						newSurf2->scale=1.0f;
+						newSurf2->fade=1.0f;
+						newSurf2->impactTime=1.0f;	// done with
+						int magicFactor42=500; // ms, impact time
+						if (curTime>(*kcur).second.mGoreGrowStartTime && curTime<(*kcur).second.mGoreGrowStartTime+magicFactor42)
+						{
+							newSurf2->impactTime=float(curTime-(*kcur).second.mGoreGrowStartTime)/float(magicFactor42);  // linear
+						}
+						if (curTime<(*kcur).second.mGoreGrowEndTime)
+						{
+							newSurf2->scale=1.0f/((curTime-(*kcur).second.mGoreGrowStartTime)*(*kcur).second.mGoreGrowFactor + (*kcur).second.mGoreGrowOffset);
+							if (newSurf2->scale<1.0f)
+							{
+								newSurf2->scale=1.0f;
+							}
+						}
+						shader_t *gshader;
+						if ((*kcur).second.shader)
+						{
+ 							gshader=R_GetShaderByHandle((*kcur).second.shader);
+						}
+						else
+						{
+							gshader=R_GetShaderByHandle(goreShader);
+						}
+
+						// Set fade on surf.
+						//Only if we have a fade time set, and let us fade on rgb if we want -rww
+						if ((*kcur).second.mDeleteTime && (*kcur).second.mFadeTime)
+						{
+							if ((*kcur).second.mDeleteTime - curTime < (*kcur).second.mFadeTime)
+							{
+								newSurf2->fade=(float)((*kcur).second.mDeleteTime - curTime)/(*kcur).second.mFadeTime;
+								if ((*kcur).second.mFadeRGB)
+								{ //RGB fades are scaled from 2.0f to 3.0f (simply to differentiate)
+									newSurf2->fade += 2.0f;
+
+									if (newSurf2->fade < 2.01f)
+									{
+										newSurf2->fade = 2.01f;
+									}
+								}
+							}
+						}
+
+						last->goreChain=newSurf2;
+						last=newSurf2;
+						R_AddDrawSurf( (surfaceType_t *)newSurf2,gshader, RS.fogNum, qfalse );
+					}
+				}
+			}
+#endif
+		}
+	}
+	
+	// if we are turning off all descendants, then stop this recursion now
+	if (offFlags & G2SURFACEFLAG_NODESCENDANTS)
+	{
+		return;
+	}
+
+	// now recursively call for the children
+	for (i=0; i< surfInfo->numChildren; i++)
+	{
+		RS.surfaceNum = surfInfo->childIndexes[i];
+		RenderSurfaces(RS);
+	}
+}
+
+
+// sort all the ghoul models in this list so if they go in reference order. This will ensure the bolt on's are attached to the right place
+// on the previous model, since it ensures the model being attached to is built and rendered first.
+
+// NOTE!! This assumes at least one model will NOT have a parent. If it does - we are screwed
+static void G2_Sort_Models(CGhoul2Info_v &ghoul2, int * const modelList, int * const modelCount)
+{
+	int		startPoint, endPoint;
+	int		i, boltTo, j;
+
+	*modelCount = 0;
+
+	// first walk all the possible ghoul2 models, and stuff the out array with those with no parents
+	for (i=0; i<ghoul2.size();i++)
+	{
+		// have a ghoul model here?
+		if (ghoul2[i].mModelindex == -1||!ghoul2[i].mValid)
+		{
+			continue;
+		}
+		// are we attached to anything?
+		if (ghoul2[i].mModelBoltLink == -1)
+		{
+			// no, insert us first
+			modelList[(*modelCount)++] = i;
+	 	}
+	}
+
+	startPoint = 0;
+	endPoint = *modelCount;
+
+	// now, using that list of parentless models, walk the descendant tree for each of them, inserting the descendents in the list
+	while (startPoint != endPoint)
+	{
+		for (i=0; i<ghoul2.size(); i++)
+		{
+			// have a ghoul model here?
+			if (ghoul2[i].mModelindex == -1||!ghoul2[i].mValid)
+			{
+				continue;
+			}
+
+			// what does this model think it's attached to?
+			if (ghoul2[i].mModelBoltLink != -1)
+			{
+				boltTo = (ghoul2[i].mModelBoltLink >> MODEL_SHIFT) & MODEL_AND;
+				// is it any of the models we just added to the list?
+				for (j=startPoint; j<endPoint; j++)
+				{
+					// is this my parent model?
+					if (boltTo == modelList[j])
+					{
+						// yes, insert into list and exit now
+						modelList[(*modelCount)++] = i;
+						break;
+					}
+				}
+			}
+		}
+		// update start and end points
+		startPoint = endPoint;
+		endPoint = *modelCount;
+	}
+}
+
+
+
+static void RootMatrix(CGhoul2Info_v &ghoul2,int time,const vec3_t scale,mdxaBone_t &retMatrix)
+{
+	int i;
+	for (i=0; i<ghoul2.size(); i++)
+	{
+		if (ghoul2[i].mModelindex != -1&&ghoul2[i].mValid)
+		{
+			if (ghoul2[i].mFlags & GHOUL2_NEWORIGIN)
+			{
+				mdxaBone_t bolt;
+				mdxaBone_t		tempMatrix;
+
+				G2_ConstructGhoulSkeleton(ghoul2,time,false,scale); 
+				G2_GetBoltMatrixLow(ghoul2[i],ghoul2[i].mNewOrigin,scale,bolt);
+				tempMatrix.matrix[0][0]=1.0f;
+				tempMatrix.matrix[0][1]=0.0f;
+				tempMatrix.matrix[0][2]=0.0f;
+				tempMatrix.matrix[0][3]=-bolt.matrix[0][3];
+				tempMatrix.matrix[1][0]=0.0f;
+				tempMatrix.matrix[1][1]=1.0f;
+				tempMatrix.matrix[1][2]=0.0f;
+				tempMatrix.matrix[1][3]=-bolt.matrix[1][3];
+				tempMatrix.matrix[2][0]=0.0f;
+				tempMatrix.matrix[2][1]=0.0f;
+				tempMatrix.matrix[2][2]=1.0f;
+				tempMatrix.matrix[2][3]=-bolt.matrix[2][3];
+//				Inverse_Matrix(&bolt, &tempMatrix);
+				Multiply_3x4Matrix(&retMatrix, &tempMatrix, (mdxaBone_t*)&identityMatrix);
+				return;
+			}
+		}
+	}
+	retMatrix=identityMatrix;
+}
+
+extern cvar_t	*r_shadowRange;
+static inline bool bInShadowRange(vec3_t location)
+{
+	const float c = DotProduct( tr.viewParms.or.axis[0], tr.viewParms.or.origin );
+	const float dist = DotProduct( tr.viewParms.or.axis[0], location ) - c;
+
+//	return (dist < tr.distanceCull/1.5f);
+	return (dist < r_shadowRange->value);
+}
+
+/*
+==============
+R_AddGHOULSurfaces
+==============
+*/
+void R_AddGhoulSurfaces( trRefEntity_t *ent ) {
+	shader_t		*cust_shader = 0;
+#ifdef _G2_GORE
+	shader_t		*gore_shader = 0;
+#endif
+	int				fogNum = 0;
+	bool			personalModel;
+	int				cull;
+	int				i, whichLod, j;
+	skin_t			*skin;
+	int				modelCount;
+	mdxaBone_t		rootMatrix;
+	
+	// if we don't want ghoul2 models, then return
+	if (r_noGhoul2->integer)
+	{
+		return;
+	}
+
+	assert (ent->e.ghoul2);	//entity is foo if it has a glm model handle but no ghoul2 pointer!
+	CGhoul2Info_v	&ghoul2 = *ent->e.ghoul2;
+
+	if (!G2_SetupModelPointers(ghoul2))
+	{
+		return;
+	}
+
+	int currentTime=G2API_GetTime(tr.refdef.time);
+
+
+	// cull the entire model if merged bounding box of both frames
+	// is outside the view frustum.
+	cull = R_GCullModel (ent );
+	if ( cull == CULL_OUT ) 
+	{
+		return;
+	}
+	HackadelicOnClient=true;
+	// are any of these models setting a new origin?
+	RootMatrix(ghoul2,currentTime, ent->e.modelScale,rootMatrix);
+
+   	// don't add third_person objects if not in a portal
+	personalModel = (ent->e.renderfx & RF_THIRD_PERSON) && !tr.viewParms.isPortal;
+
+	int modelList[32];
+	assert(ghoul2.size()<=31);
+	modelList[31]=548;
+
+	// set up lighting now that we know we aren't culled
+#ifdef VV_LIGHTING
+	if ( !personalModel ) {
+		VVLightMan.R_SetupEntityLighting( &tr.refdef, ent );
+#else
+	if ( !personalModel || r_shadows->integer > 1 ) {
+		R_SetupEntityLighting( &tr.refdef, ent );
+#endif
+	}
+
+	// see if we are in a fog volume
+	fogNum = R_GComputeFogNum( ent );
+
+	// sort the ghoul 2 models so bolt ons get bolted to the right model
+	G2_Sort_Models(ghoul2, modelList, &modelCount);
+	assert(modelList[31]==548);
+
+#ifdef _G2_GORE
+	if (goreShader == -1)
+	{
+		goreShader=RE_RegisterShader("gfx/damage/burnmark1");
+	}
+#endif
+
+	// construct a world matrix for this entity
+	G2_GenerateWorldMatrix(ent->e.angles, ent->e.origin);
+
+	// walk each possible model for this entity and try rendering it out
+	for (j=0; j<modelCount; j++)
+	{
+		i = modelList[j];
+		if (ghoul2[i].mValid&&!(ghoul2[i].mFlags & GHOUL2_NOMODEL)&&!(ghoul2[i].mFlags & GHOUL2_NORENDER))
+		{
+			//
+			// figure out whether we should be using a custom shader for this model
+			//
+			skin = NULL;
+			if (ent->e.customShader)
+			{
+				cust_shader = R_GetShaderByHandle(ent->e.customShader );
+			}
+			else
+			{
+				cust_shader = NULL;
+				// figure out the custom skin thing
+				if (ent->e.customSkin)
+				{
+					skin = R_GetSkinByHandle(ent->e.customSkin );
+				}
+				else if ( ghoul2[i].mSkin > 0 && ghoul2[i].mSkin < tr.numSkins ) 
+				{
+					skin = R_GetSkinByHandle( ghoul2[i].mSkin );
+				}
+			}
+
+			if (j&&ghoul2[i].mModelBoltLink != -1)
+			{
+				int	boltMod = (ghoul2[i].mModelBoltLink >> MODEL_SHIFT) & MODEL_AND;
+				int	boltNum = (ghoul2[i].mModelBoltLink >> BOLT_SHIFT) & BOLT_AND;
+				mdxaBone_t bolt;
+				G2_GetBoltMatrixLow(ghoul2[boltMod],boltNum,ent->e.modelScale,bolt);
+				G2_TransformGhoulBones(ghoul2[i].mBlist,bolt, ghoul2[i],currentTime);
+			}
+			else
+			{
+				G2_TransformGhoulBones(ghoul2[i].mBlist, rootMatrix, ghoul2[i],currentTime);
+			}
+			if ( ent->e.renderfx & RF_G2MINLOD )
+			{
+				whichLod = G2_ComputeLOD( ent, ghoul2[i].currentModel, 10 );
+			} else
+			{
+				whichLod = G2_ComputeLOD( ent, ghoul2[i].currentModel, ghoul2[i].mLodBias );
+			}
+			G2_FindOverrideSurface(-1,ghoul2[i].mSlist); //reset the quick surface override lookup;
+#ifdef _G2_GORE
+			CGoreSet *gore=0;
+			if (ghoul2[i].mGoreSetTag)
+			{
+				gore=FindGoreSet(ghoul2[i].mGoreSetTag);
+				if (!gore) // my gore is gone, so remove it
+				{
+					ghoul2[i].mGoreSetTag=0;
+				}
+			}
+
+			CRenderSurface RS(ghoul2[i].mSurfaceRoot, ghoul2[i].mSlist, cust_shader, fogNum, personalModel, ghoul2[i].mBoneCache, ent->e.renderfx, skin,ghoul2[i].currentModel, whichLod, ghoul2[i].mBltlist, gore_shader, gore);
+#else
+			CRenderSurface RS(ghoul2[i].mSurfaceRoot, ghoul2[i].mSlist, cust_shader, fogNum, personalModel, ghoul2[i].mBoneCache, ent->e.renderfx, skin,ghoul2[i].currentModel, whichLod, ghoul2[i].mBltlist);
+#endif
+			if (!personalModel && (RS.renderfx & RF_SHADOW_PLANE) && !bInShadowRange(ent->e.origin))
+			{
+				RS.renderfx |= RF_NOSHADOW;
+			}
+			RenderSurfaces(RS);
+		}
+	}
+	HackadelicOnClient=false;
+}	
+
+bool G2_NeedsRecalc(CGhoul2Info *ghlInfo,int frameNum)
+{
+	G2_SetupModelPointers(ghlInfo);
+	// not sure if I still need this test, probably
+	if (ghlInfo->mSkelFrameNum!=frameNum||
+		!ghlInfo->mBoneCache||
+		ghlInfo->mBoneCache->mod!=ghlInfo->currentModel)
+	{
+		ghlInfo->mSkelFrameNum=frameNum;
+		return true;
+	}
+	return false;
+}
+
+/*
+==============
+G2_ConstructGhoulSkeleton - builds a complete skeleton for all ghoul models in a CGhoul2Info_v class	- using LOD 0
+==============
+*/
+void G2_ConstructGhoulSkeleton( CGhoul2Info_v &ghoul2,const int frameNum,bool checkForNewOrigin,const vec3_t scale)
+{
+	int				i, j;
+	int				modelCount;
+	mdxaBone_t		rootMatrix;
+
+	int modelList[32];
+	assert(ghoul2.size()<=31);
+	modelList[31]=548;
+
+	if (checkForNewOrigin)
+	{
+		RootMatrix(ghoul2,frameNum,scale,rootMatrix);
+	}
+	else
+	{
+		rootMatrix = identityMatrix;
+	}
+
+	G2_Sort_Models(ghoul2, modelList, &modelCount);
+	assert(modelList[31]==548);
+
+	for (j=0; j<modelCount; j++)
+	{
+		// get the sorted model to play with
+		i = modelList[j];
+
+		if (ghoul2[i].mValid)
+		{
+			if (j&&ghoul2[i].mModelBoltLink != -1)
+			{
+				int	boltMod = (ghoul2[i].mModelBoltLink >> MODEL_SHIFT) & MODEL_AND;
+				int	boltNum = (ghoul2[i].mModelBoltLink >> BOLT_SHIFT) & BOLT_AND;
+
+				mdxaBone_t bolt;
+				G2_GetBoltMatrixLow(ghoul2[boltMod],boltNum,scale,bolt);
+				G2_TransformGhoulBones(ghoul2[i].mBlist,bolt,ghoul2[i],frameNum,checkForNewOrigin);
+			}
+			else
+			{
+				G2_TransformGhoulBones(ghoul2[i].mBlist,rootMatrix,ghoul2[i],frameNum,checkForNewOrigin);
+			}
+		}
+	}
+}	
+
+/*
+==============
+RB_SurfaceGhoul
+==============
+*/
+void RB_SurfaceGhoul( CRenderableSurface *surf ) 
+{
+#ifdef G2_PERFORMANCE_ANALYSIS
+	G2PerformanceTimer_RB_SurfaceGhoul.Start();
+#endif
+
+	int				j, k;
+	int				baseIndex, baseVertex;
+	int				numVerts;
+	mdxmVertex_t 	*v;
+	int				*triangles;
+	int				indexes;
+	glIndex_t		*tessIndexes;
+	mdxmVertexTexCoord_t *pTexCoords;
+	int				*piBoneReferences;
+
+#ifdef _G2_GORE
+	if (surf->alternateTex)
+	{
+
+		// a gore surface ready to go.
+
+		/*
+			sizeof(int)+ // num verts
+			sizeof(int)+ // num tris
+			sizeof(int)*newNumVerts+ // which verts to copy from original surface
+			sizeof(float)*4*newNumVerts+ // storgage for deformed verts
+			sizeof(float)*4*newNumVerts+ // storgage for deformed normal
+			sizeof(float)*2*newNumVerts+ // texture coordinates
+			sizeof(int)*newNumTris*3;  // new indecies
+		*/
+
+		int *data=(int *)surf->alternateTex;
+		numVerts=*data++;
+		indexes=(*data++);
+		// first up, sanity check our numbers
+		RB_CheckOverflow(numVerts,indexes);
+		indexes*=3;
+
+		data+=numVerts;
+
+		baseIndex = tess.numIndexes;
+		baseVertex = tess.numVertexes;
+
+		memcpy(&tess.xyz[baseVertex][0],data,sizeof(float)*4*numVerts);
+		data+=4*numVerts;
+		memcpy(&tess.normal[baseVertex][0],data,sizeof(float)*4*numVerts);
+		data+=4*numVerts;
+		assert(numVerts>0);
+
+		//float *texCoords = tess.texCoords[0][baseVertex];
+		float *texCoords = tess.texCoords[baseVertex][0];
+		int hack = baseVertex;
+		//rww - since the array is arranged as such we cannot increment
+		//the relative memory position to get where we want. Maybe this
+		//is why sof2 has the texCoords array reversed. In any case, I
+		//am currently too lazy to get around it.
+		//Or can you += array[.][x]+2?
+		if (surf->scale>1.0f)
+		{
+			for ( j = 0; j < numVerts; j++) 
+			{
+				texCoords[0]=((*(float *)data)-0.5f)*surf->scale+0.5f;
+				data++;
+				texCoords[1]=((*(float *)data)-0.5f)*surf->scale+0.5f;
+				data++;
+				//texCoords+=2;// Size of gore (s,t).
+				hack++;
+				texCoords = tess.texCoords[hack][0];
+			}
+		}
+		else
+		{
+			for (j=0;j<numVerts;j++)
+			{
+				texCoords[0]=*(float *)(data++);
+				texCoords[1]=*(float *)(data++);
+//				texCoords+=2;// Size of gore (s,t).
+				hack++;
+				texCoords = tess.texCoords[hack][0];
+			}
+		}
+
+		//now check for fade overrides -rww
+		if (surf->fade)
+		{
+			static int lFade;
+			static int j;
+
+			if (surf->fade<1.0)
+			{
+				tess.fading = true;
+				lFade = myftol(254.4f*surf->fade);
+
+				for (j=0;j<numVerts;j++)
+				{
+					tess.svars.colors[j+baseVertex][3] = lFade;
+				}
+			}
+			else if (surf->fade > 2.0f && surf->fade < 3.0f)
+			{ //hack to fade out on RGB if desired (don't want to add more to CRenderableSurface) -rww
+				tess.fading = true;
+				lFade = myftol(254.4f*(surf->fade-2.0f));
+
+				for (j=0;j<numVerts;j++)
+				{
+					if (lFade < tess.svars.colors[j+baseVertex][0])
+					{ //don't set it unless the fade is less than the current r value (to avoid brightening suddenly before we start fading)
+						tess.svars.colors[j+baseVertex][0] = tess.svars.colors[j+baseVertex][1] = tess.svars.colors[j+baseVertex][2] = lFade;
+					}
+
+					//Set the alpha as well I suppose, no matter what
+					tess.svars.colors[j+baseVertex][3] = lFade;
+				}
+			}
+		}
+		
+		glIndex_t *indexPtr = &tess.indexes[baseIndex];
+		triangles = data;
+		for (j = indexes ; j ; j--) 
+		{
+			*indexPtr++ = baseVertex + (*triangles++);
+		}
+		tess.numIndexes += indexes;
+		tess.numVertexes += numVerts; 
+		return;
+	}
+#endif
+
+	// grab the pointer to the surface info within the loaded mesh file
+	mdxmSurface_t	*surface = surf->surfaceData;
+
+	CBoneCache *bones = surf->boneCache;
+
+
+#ifdef VV_LIGHTING
+	// Set any dynamic lighting needed
+	if(backEnd.currentEntity->dlightBits)
+		tess.dlightBits = backEnd.currentEntity->dlightBits;
+#endif
+
+	// first up, sanity check our numbers
+	RB_CheckOverflow( surface->numVerts, surface->numTriangles );
+
+	//
+	// deform the vertexes by the lerped bones
+	//
+   
+	// first up, sanity check our numbers
+	baseVertex = tess.numVertexes;
+	triangles = (int *) ((byte *)surface + surface->ofsTriangles);
+	baseIndex = tess.numIndexes;
+#if 0
+	indexes = surface->numTriangles * 3;
+	for (j = 0 ; j < indexes ; j++) {
+		tess.indexes[baseIndex + j] = baseVertex + triangles[j];
+	}
+	tess.numIndexes += indexes;
+#else
+	indexes = surface->numTriangles; //*3;	//unrolled 3 times, don't multiply
+	tessIndexes = &tess.indexes[baseIndex];
+	for (j = 0 ; j < indexes ; j++) {
+		*tessIndexes++ = baseVertex + *triangles++;
+		*tessIndexes++ = baseVertex + *triangles++;
+		*tessIndexes++ = baseVertex + *triangles++;
+	}
+	tess.numIndexes += indexes*3;
+#endif
+
+	numVerts = surface->numVerts;
+
+#ifdef _XBOX
+	TransformRenderSurface(surface, surf->boneCache, &tess);
+
+
+#else
+	piBoneReferences = (int*) ((byte*)surface + surface->ofsBoneReferences);
+	baseVertex = tess.numVertexes;
+	v = (mdxmVertex_t *) ((byte *)surface + surface->ofsVerts);
+	pTexCoords = (mdxmVertexTexCoord_t *) &v[numVerts];
+
+//	if (r_ghoul2fastnormals&&r_ghoul2fastnormals->integer==0)
+#if 0
+	if (0)
+	{
+		for ( j = 0; j < numVerts; j++, baseVertex++,v++ ) 
+		{
+			const int iNumWeights = G2_GetVertWeights( v );
+
+			float fTotalWeight = 0.0f;
+
+			k=0;
+			int		iBoneIndex = G2_GetVertBoneIndex( v, k );
+			float	fBoneWeight = G2_GetVertBoneWeight( v, k, fTotalWeight, iNumWeights );
+			const mdxaBone_t *bone = &bones->EvalRender(piBoneReferences[iBoneIndex]);
+
+			tess.xyz[baseVertex][0] = fBoneWeight * ( DotProduct( bone->matrix[0], v->vertCoords ) + bone->matrix[0][3] );
+			tess.xyz[baseVertex][1] = fBoneWeight * ( DotProduct( bone->matrix[1], v->vertCoords ) + bone->matrix[1][3] );
+			tess.xyz[baseVertex][2] = fBoneWeight * ( DotProduct( bone->matrix[2], v->vertCoords ) + bone->matrix[2][3] );
+
+			tess.normal[baseVertex][0] = fBoneWeight * DotProduct( bone->matrix[0], v->normal );
+			tess.normal[baseVertex][1] = fBoneWeight * DotProduct( bone->matrix[1], v->normal );
+			tess.normal[baseVertex][2] = fBoneWeight * DotProduct( bone->matrix[2], v->normal );
+
+			for ( k++ ; k < iNumWeights ; k++) 
+			{
+				iBoneIndex	= G2_GetVertBoneIndex( v, k );
+				fBoneWeight	= G2_GetVertBoneWeight( v, k, fTotalWeight, iNumWeights );
+
+				bone = &bones->EvalRender(piBoneReferences[iBoneIndex]);
+
+				tess.xyz[baseVertex][0] += fBoneWeight * ( DotProduct( bone->matrix[0], v->vertCoords ) + bone->matrix[0][3] );
+				tess.xyz[baseVertex][1] += fBoneWeight * ( DotProduct( bone->matrix[1], v->vertCoords ) + bone->matrix[1][3] );
+				tess.xyz[baseVertex][2] += fBoneWeight * ( DotProduct( bone->matrix[2], v->vertCoords ) + bone->matrix[2][3] );
+
+				tess.normal[baseVertex][0] += fBoneWeight * DotProduct( bone->matrix[0], v->normal );
+				tess.normal[baseVertex][1] += fBoneWeight * DotProduct( bone->matrix[1], v->normal );
+				tess.normal[baseVertex][2] += fBoneWeight * DotProduct( bone->matrix[2], v->normal );
+			}
+
+			tess.texCoords[baseVertex][0][0] = pTexCoords[j].texCoords[0];
+			tess.texCoords[baseVertex][0][1] = pTexCoords[j].texCoords[1];
+		}
+	}
+	else
+	{
+#endif
+		float fTotalWeight;
+		float fBoneWeight;
+		float t1;
+		float t2;
+		const mdxaBone_t *bone;
+		const mdxaBone_t *bone2;
+		for ( j = 0; j < numVerts; j++, baseVertex++,v++ ) 
+		{
+
+			bone = &bones->EvalRender(piBoneReferences[G2_GetVertBoneIndex( v, 0 )]);
+			int iNumWeights = G2_GetVertWeights( v );
+			tess.normal[baseVertex][0] = DotProduct( bone->matrix[0], v->normal );
+			tess.normal[baseVertex][1] = DotProduct( bone->matrix[1], v->normal );
+			tess.normal[baseVertex][2] = DotProduct( bone->matrix[2], v->normal );
+
+			if (iNumWeights==1)
+			{
+				tess.xyz[baseVertex][0] = ( DotProduct( bone->matrix[0], v->vertCoords ) + bone->matrix[0][3] );
+				tess.xyz[baseVertex][1] = ( DotProduct( bone->matrix[1], v->vertCoords ) + bone->matrix[1][3] );
+				tess.xyz[baseVertex][2] = ( DotProduct( bone->matrix[2], v->vertCoords ) + bone->matrix[2][3] );
+			}
+			else
+			{
+				fBoneWeight = G2_GetVertBoneWeightNotSlow( v, 0);
+				if (iNumWeights==2)
+				{
+					bone2 = &bones->EvalRender(piBoneReferences[G2_GetVertBoneIndex( v, 1 )]);
+					/*
+					useless transposition
+					tess.xyz[baseVertex][0] =
+					v[0]*(w*(bone->matrix[0][0]-bone2->matrix[0][0])+bone2->matrix[0][0])+
+					v[1]*(w*(bone->matrix[0][1]-bone2->matrix[0][1])+bone2->matrix[0][1])+
+					v[2]*(w*(bone->matrix[0][2]-bone2->matrix[0][2])+bone2->matrix[0][2])+
+					w*(bone->matrix[0][3]-bone2->matrix[0][3]) + bone2->matrix[0][3];
+					*/
+					t1 = ( DotProduct( bone->matrix[0], v->vertCoords ) + bone->matrix[0][3] );
+					t2 = ( DotProduct( bone2->matrix[0], v->vertCoords ) + bone2->matrix[0][3] );
+					tess.xyz[baseVertex][0] = fBoneWeight * (t1-t2) + t2;
+					t1 = ( DotProduct( bone->matrix[1], v->vertCoords ) + bone->matrix[1][3] );
+					t2 = ( DotProduct( bone2->matrix[1], v->vertCoords ) + bone2->matrix[1][3] );
+					tess.xyz[baseVertex][1] = fBoneWeight * (t1-t2) + t2;
+					t1 = ( DotProduct( bone->matrix[2], v->vertCoords ) + bone->matrix[2][3] );
+					t2 = ( DotProduct( bone2->matrix[2], v->vertCoords ) + bone2->matrix[2][3] );
+					tess.xyz[baseVertex][2] = fBoneWeight * (t1-t2) + t2;
+				}
+				else
+				{
+
+					tess.xyz[baseVertex][0] = fBoneWeight * ( DotProduct( bone->matrix[0], v->vertCoords ) + bone->matrix[0][3] );
+					tess.xyz[baseVertex][1] = fBoneWeight * ( DotProduct( bone->matrix[1], v->vertCoords ) + bone->matrix[1][3] );
+					tess.xyz[baseVertex][2] = fBoneWeight * ( DotProduct( bone->matrix[2], v->vertCoords ) + bone->matrix[2][3] );
+
+					fTotalWeight=fBoneWeight;
+					for (k=1; k < iNumWeights-1 ; k++) 
+					{
+						bone = &bones->EvalRender(piBoneReferences[G2_GetVertBoneIndex( v, k )]);
+						fBoneWeight = G2_GetVertBoneWeightNotSlow( v, k);
+						fTotalWeight += fBoneWeight;
+
+						tess.xyz[baseVertex][0] += fBoneWeight * ( DotProduct( bone->matrix[0], v->vertCoords ) + bone->matrix[0][3] );
+						tess.xyz[baseVertex][1] += fBoneWeight * ( DotProduct( bone->matrix[1], v->vertCoords ) + bone->matrix[1][3] );
+						tess.xyz[baseVertex][2] += fBoneWeight * ( DotProduct( bone->matrix[2], v->vertCoords ) + bone->matrix[2][3] );
+					}
+					bone = &bones->EvalRender(piBoneReferences[G2_GetVertBoneIndex( v, k )]);
+					fBoneWeight	= 1.0f-fTotalWeight;
+
+					tess.xyz[baseVertex][0] += fBoneWeight * ( DotProduct( bone->matrix[0], v->vertCoords ) + bone->matrix[0][3] );
+					tess.xyz[baseVertex][1] += fBoneWeight * ( DotProduct( bone->matrix[1], v->vertCoords ) + bone->matrix[1][3] );
+					tess.xyz[baseVertex][2] += fBoneWeight * ( DotProduct( bone->matrix[2], v->vertCoords ) + bone->matrix[2][3] );
+				}
+			}
+
+			tess.texCoords[baseVertex][0][0] = pTexCoords[j].texCoords[0];
+			tess.texCoords[baseVertex][0][1] = pTexCoords[j].texCoords[1];
+		}
+#if 0
+	}
+#endif
+#endif // _XBOX
+
+#ifdef _G2_GORE
+	while (surf->goreChain)
+	{
+		surf=(CRenderableSurface *)surf->goreChain;
+		if (surf->alternateTex)
+		{
+			// get a gore surface ready to go.
+
+			/*						  
+				sizeof(int)+ // num verts
+				sizeof(int)+ // num tris
+				sizeof(int)*newNumVerts+ // which verts to copy from original surface
+				sizeof(float)*4*newNumVerts+ // storgage for deformed verts
+				sizeof(float)*4*newNumVerts+ // storgage for deformed normal
+				sizeof(float)*2*newNumVerts+ // texture coordinates
+				sizeof(int)*newNumTris*3;  // new indecies
+			*/
+
+			int *data=(int *)surf->alternateTex;
+			int gnumVerts=*data++;
+			data++;
+
+			float *fdata=(float *)data;
+			fdata+=gnumVerts;
+			for (j=0;j<gnumVerts;j++)
+			{
+				assert(data[j]>=0&&data[j]<numVerts);
+				memcpy(fdata,&tess.xyz[tess.numVertexes+data[j]][0],sizeof(float)*3);
+				fdata+=4;
+			}
+			for (j=0;j<gnumVerts;j++)
+			{
+				assert(data[j]>=0&&data[j]<numVerts);
+				memcpy(fdata,&tess.normal[tess.numVertexes+data[j]][0],sizeof(float)*3);
+				fdata+=4;
+			}
+		}
+		else
+		{
+			assert(0); 
+		}
+
+	}
+
+	// NOTE: This is required because a ghoul model might need to be rendered twice a frame (don't cringe,
+	// it's not THAT bad), so we only delete it when doing the glow pass. Warning though, this assumes that
+	// the glow is rendered _second_!!! If that changes, change this!
+	extern bool g_bRenderGlowingObjects;
+	extern bool g_bDynamicGlowSupported;
+#endif
+	tess.numVertexes += surface->numVerts;
+
+#ifdef G2_PERFORMANCE_ANALYSIS
+	G2Time_RB_SurfaceGhoul += G2PerformanceTimer_RB_SurfaceGhoul.End();
+#endif
+}
+ 
+/*
+=================
+R_LoadMDXM - load a Ghoul 2 Mesh file
+=================
+*/
+/*
+
+Some information used in the creation of the JK2 - JKA bone remap table
+
+These are the old bones:
+Complete list of all 72 bones:
+
+*/
+
+int OldToNewRemapTable[72] = {
+0,// Bone 0:   "model_root":           Parent: ""  (index -1)
+1,// Bone 1:   "pelvis":               Parent: "model_root"  (index 0)
+2,// Bone 2:   "Motion":               Parent: "pelvis"  (index 1)
+3,// Bone 3:   "lfemurYZ":             Parent: "pelvis"  (index 1)
+4,// Bone 4:   "lfemurX":              Parent: "pelvis"  (index 1)
+5,// Bone 5:   "ltibia":               Parent: "pelvis"  (index 1)
+6,// Bone 6:   "ltalus":               Parent: "pelvis"  (index 1)
+6,// Bone 7:   "ltarsal":              Parent: "pelvis"  (index 1)
+7,// Bone 8:   "rfemurYZ":             Parent: "pelvis"  (index 1)
+8,// Bone 9:   "rfemurX":	            Parent: "pelvis"  (index 1)
+9,// Bone10:   "rtibia":	            Parent: "pelvis"  (index 1)
+10,// Bone11:   "rtalus":	            Parent: "pelvis"  (index 1)
+10,// Bone12:   "rtarsal":              Parent: "pelvis"  (index 1)
+11,// Bone13:   "lower_lumbar":         Parent: "pelvis"  (index 1)
+12,// Bone14:   "upper_lumbar":	        Parent: "lower_lumbar"  (index 13)
+13,// Bone15:   "thoracic":	            Parent: "upper_lumbar"  (index 14)
+14,// Bone16:   "cervical":	            Parent: "thoracic"  (index 15)
+15,// Bone17:   "cranium":              Parent: "cervical"  (index 16)
+16,// Bone18:   "ceyebrow":	            Parent: "face_always_"  (index 71)
+17,// Bone19:   "jaw":                  Parent: "face_always_"  (index 71)
+18,// Bone20:   "lblip2":	            Parent: "face_always_"  (index 71)
+19,// Bone21:   "leye":		            Parent: "face_always_"  (index 71)
+20,// Bone22:   "rblip2":	            Parent: "face_always_"  (index 71)
+21,// Bone23:   "ltlip2":               Parent: "face_always_"  (index 71)
+22,// Bone24:   "rtlip2":	            Parent: "face_always_"  (index 71)
+23,// Bone25:   "reye":		            Parent: "face_always_"  (index 71)
+24,// Bone26:   "rclavical":            Parent: "thoracic"  (index 15)
+25,// Bone27:   "rhumerus":             Parent: "thoracic"  (index 15)
+26,// Bone28:   "rhumerusX":            Parent: "thoracic"  (index 15)
+27,// Bone29:   "rradius":              Parent: "thoracic"  (index 15)
+28,// Bone30:   "rradiusX":             Parent: "thoracic"  (index 15)
+29,// Bone31:   "rhand":                Parent: "thoracic"  (index 15)
+29,// Bone32:   "mc7":                  Parent: "thoracic"  (index 15)
+34,// Bone33:   "r_d5_j1":              Parent: "thoracic"  (index 15)
+35,// Bone34:   "r_d5_j2":              Parent: "thoracic"  (index 15)
+35,// Bone35:   "r_d5_j3":              Parent: "thoracic"  (index 15)
+30,// Bone36:   "r_d1_j1":              Parent: "thoracic"  (index 15)
+31,// Bone37:   "r_d1_j2":              Parent: "thoracic"  (index 15)
+31,// Bone38:   "r_d1_j3":              Parent: "thoracic"  (index 15)
+32,// Bone39:   "r_d2_j1":              Parent: "thoracic"  (index 15)
+33,// Bone40:   "r_d2_j2":              Parent: "thoracic"  (index 15)
+33,// Bone41:   "r_d2_j3":              Parent: "thoracic"  (index 15)
+32,// Bone42:   "r_d3_j1":			    Parent: "thoracic"  (index 15)
+33,// Bone43:   "r_d3_j2":		        Parent: "thoracic"  (index 15)
+33,// Bone44:   "r_d3_j3":              Parent: "thoracic"  (index 15)
+34,// Bone45:   "r_d4_j1":              Parent: "thoracic"  (index 15)
+35,// Bone46:   "r_d4_j2":	            Parent: "thoracic"  (index 15)
+35,// Bone47:   "r_d4_j3":		        Parent: "thoracic"  (index 15)
+36,// Bone48:   "rhang_tag_bone":	    Parent: "thoracic"  (index 15)
+37,// Bone49:   "lclavical":            Parent: "thoracic"  (index 15)
+38,// Bone50:   "lhumerus":	            Parent: "thoracic"  (index 15)
+39,// Bone51:   "lhumerusX":	        Parent: "thoracic"  (index 15)
+40,// Bone52:   "lradius":	            Parent: "thoracic"  (index 15)
+41,// Bone53:   "lradiusX":	            Parent: "thoracic"  (index 15)
+42,// Bone54:   "lhand":	            Parent: "thoracic"  (index 15)
+42,// Bone55:   "mc5":		            Parent: "thoracic"  (index 15)
+43,// Bone56:   "l_d5_j1":	            Parent: "thoracic"  (index 15)
+44,// Bone57:   "l_d5_j2":	            Parent: "thoracic"  (index 15)
+44,// Bone58:   "l_d5_j3":	            Parent: "thoracic"  (index 15)
+43,// Bone59:   "l_d4_j1":	            Parent: "thoracic"  (index 15)
+44,// Bone60:   "l_d4_j2":	            Parent: "thoracic"  (index 15)
+44,// Bone61:   "l_d4_j3":	            Parent: "thoracic"  (index 15)
+45,// Bone62:   "l_d3_j1":	            Parent: "thoracic"  (index 15)
+46,// Bone63:   "l_d3_j2":	            Parent: "thoracic"  (index 15)
+46,// Bone64:   "l_d3_j3":	            Parent: "thoracic"  (index 15)
+45,// Bone65:   "l_d2_j1":	            Parent: "thoracic"  (index 15)
+46,// Bone66:   "l_d2_j2":	            Parent: "thoracic"  (index 15)
+46,// Bone67:   "l_d2_j3":	            Parent: "thoracic"  (index 15)
+47,// Bone68:   "l_d1_j1":				Parent: "thoracic"  (index 15)
+48,// Bone69:   "l_d1_j2":	            Parent: "thoracic"  (index 15)
+48,// Bone70:   "l_d1_j3":				Parent: "thoracic"  (index 15)
+52// Bone71:   "face_always_":			Parent: "cranium"  (index 17)
+};
+
+
+/*
+
+Bone   0:   "model_root":
+            Parent: ""  (index -1)
+            #Kids:  1
+            Child 0: (index 1), name "pelvis"
+
+Bone   1:   "pelvis":
+            Parent: "model_root"  (index 0)
+            #Kids:  4
+            Child 0: (index 2), name "Motion"
+            Child 1: (index 3), name "lfemurYZ"
+            Child 2: (index 7), name "rfemurYZ"
+            Child 3: (index 11), name "lower_lumbar"
+
+Bone   2:   "Motion":
+            Parent: "pelvis"  (index 1)
+            #Kids:  0
+
+Bone   3:   "lfemurYZ":
+            Parent: "pelvis"  (index 1)
+            #Kids:  3
+            Child 0: (index 4), name "lfemurX"
+            Child 1: (index 5), name "ltibia"
+            Child 2: (index 49), name "ltail"
+
+Bone   4:   "lfemurX":
+            Parent: "lfemurYZ"  (index 3)
+            #Kids:  0
+
+Bone   5:   "ltibia":
+            Parent: "lfemurYZ"  (index 3)
+            #Kids:  1
+            Child 0: (index 6), name "ltalus"
+
+Bone   6:   "ltalus":
+            Parent: "ltibia"  (index 5)
+            #Kids:  0
+
+Bone   7:   "rfemurYZ":
+            Parent: "pelvis"  (index 1)
+            #Kids:  3
+            Child 0: (index 8), name "rfemurX"
+            Child 1: (index 9), name "rtibia"
+            Child 2: (index 50), name "rtail"
+
+Bone   8:   "rfemurX":
+            Parent: "rfemurYZ"  (index 7)
+            #Kids:  0
+
+Bone   9:   "rtibia":
+            Parent: "rfemurYZ"  (index 7)
+            #Kids:  1
+            Child 0: (index 10), name "rtalus"
+
+Bone  10:   "rtalus":
+            Parent: "rtibia"  (index 9)
+            #Kids:  0
+
+Bone  11:   "lower_lumbar":
+            Parent: "pelvis"  (index 1)
+            #Kids:  1
+            Child 0: (index 12), name "upper_lumbar"
+
+Bone  12:   "upper_lumbar":
+            Parent: "lower_lumbar"  (index 11)
+            #Kids:  1
+            Child 0: (index 13), name "thoracic"
+
+Bone  13:   "thoracic":
+            Parent: "upper_lumbar"  (index 12)
+            #Kids:  5
+            Child 0: (index 14), name "cervical"
+            Child 1: (index 24), name "rclavical"
+            Child 2: (index 25), name "rhumerus"
+            Child 3: (index 37), name "lclavical"
+            Child 4: (index 38), name "lhumerus"
+
+Bone  14:   "cervical":
+            Parent: "thoracic"  (index 13)
+            #Kids:  1
+            Child 0: (index 15), name "cranium"
+
+Bone  15:   "cranium":
+            Parent: "cervical"  (index 14)
+            #Kids:  1
+            Child 0: (index 52), name "face_always_"
+
+Bone  16:   "ceyebrow":
+            Parent: "face_always_"  (index 52)
+            #Kids:  0
+
+Bone  17:   "jaw":
+            Parent: "face_always_"  (index 52)
+            #Kids:  0
+
+Bone  18:   "lblip2":
+            Parent: "face_always_"  (index 52)
+            #Kids:  0
+
+Bone  19:   "leye":
+            Parent: "face_always_"  (index 52)
+            #Kids:  0
+
+Bone  20:   "rblip2":
+            Parent: "face_always_"  (index 52)
+            #Kids:  0
+
+Bone  21:   "ltlip2":
+            Parent: "face_always_"  (index 52)
+            #Kids:  0
+
+Bone  22:   "rtlip2":
+            Parent: "face_always_"  (index 52)
+            #Kids:  0
+
+Bone  23:   "reye":
+            Parent: "face_always_"  (index 52)
+            #Kids:  0
+
+Bone  24:   "rclavical":
+            Parent: "thoracic"  (index 13)
+            #Kids:  0
+
+Bone  25:   "rhumerus":
+            Parent: "thoracic"  (index 13)
+            #Kids:  2
+            Child 0: (index 26), name "rhumerusX"
+            Child 1: (index 27), name "rradius"
+
+Bone  26:   "rhumerusX":
+            Parent: "rhumerus"  (index 25)
+            #Kids:  0
+
+Bone  27:   "rradius":
+            Parent: "rhumerus"  (index 25)
+            #Kids:  9
+            Child 0: (index 28), name "rradiusX"
+            Child 1: (index 29), name "rhand"
+            Child 2: (index 30), name "r_d1_j1"
+            Child 3: (index 31), name "r_d1_j2"
+            Child 4: (index 32), name "r_d2_j1"
+            Child 5: (index 33), name "r_d2_j2"
+            Child 6: (index 34), name "r_d4_j1"
+            Child 7: (index 35), name "r_d4_j2"
+            Child 8: (index 36), name "rhang_tag_bone"
+
+Bone  28:   "rradiusX":
+            Parent: "rradius"  (index 27)
+            #Kids:  0
+
+Bone  29:   "rhand":
+            Parent: "rradius"  (index 27)
+            #Kids:  0
+
+Bone  30:   "r_d1_j1":
+            Parent: "rradius"  (index 27)
+            #Kids:  0
+
+Bone  31:   "r_d1_j2":
+            Parent: "rradius"  (index 27)
+            #Kids:  0
+
+Bone  32:   "r_d2_j1":
+            Parent: "rradius"  (index 27)
+            #Kids:  0
+
+Bone  33:   "r_d2_j2":
+            Parent: "rradius"  (index 27)
+            #Kids:  0
+
+Bone  34:   "r_d4_j1":
+            Parent: "rradius"  (index 27)
+            #Kids:  0
+
+Bone  35:   "r_d4_j2":
+            Parent: "rradius"  (index 27)
+            #Kids:  0
+
+Bone  36:   "rhang_tag_bone":
+            Parent: "rradius"  (index 27)
+            #Kids:  0
+
+Bone  37:   "lclavical":
+            Parent: "thoracic"  (index 13)
+            #Kids:  0
+
+Bone  38:   "lhumerus":
+            Parent: "thoracic"  (index 13)
+            #Kids:  2
+            Child 0: (index 39), name "lhumerusX"
+            Child 1: (index 40), name "lradius"
+
+Bone  39:   "lhumerusX":
+            Parent: "lhumerus"  (index 38)
+            #Kids:  0
+
+Bone  40:   "lradius":
+            Parent: "lhumerus"  (index 38)
+            #Kids:  9
+            Child 0: (index 41), name "lradiusX"
+            Child 1: (index 42), name "lhand"
+            Child 2: (index 43), name "l_d4_j1"
+            Child 3: (index 44), name "l_d4_j2"
+            Child 4: (index 45), name "l_d2_j1"
+            Child 5: (index 46), name "l_d2_j2"
+            Child 6: (index 47), name "l_d1_j1"
+            Child 7: (index 48), name "l_d1_j2"
+            Child 8: (index 51), name "lhang_tag_bone"
+
+Bone  41:   "lradiusX":
+            Parent: "lradius"  (index 40)
+            #Kids:  0
+
+Bone  42:   "lhand":
+            Parent: "lradius"  (index 40)
+            #Kids:  0
+
+Bone  43:   "l_d4_j1":
+            Parent: "lradius"  (index 40)
+            #Kids:  0
+
+Bone  44:   "l_d4_j2":
+            Parent: "lradius"  (index 40)
+            #Kids:  0
+
+Bone  45:   "l_d2_j1":
+            Parent: "lradius"  (index 40)
+            #Kids:  0
+
+Bone  46:   "l_d2_j2":
+            Parent: "lradius"  (index 40)
+            #Kids:  0
+
+Bone  47:   "l_d1_j1":
+            Parent: "lradius"  (index 40)
+            #Kids:  0
+
+Bone  48:   "l_d1_j2":
+            Parent: "lradius"  (index 40)
+            #Kids:  0
+
+Bone  49:   "ltail":
+            Parent: "lfemurYZ"  (index 3)
+            #Kids:  0
+
+Bone  50:   "rtail":
+            Parent: "rfemurYZ"  (index 7)
+            #Kids:  0
+
+Bone  51:   "lhang_tag_bone":
+            Parent: "lradius"  (index 40)
+            #Kids:  0
+
+Bone  52:   "face_always_":
+            Parent: "cranium"  (index 15)
+            #Kids:  8
+            Child 0: (index 16), name "ceyebrow"
+            Child 1: (index 17), name "jaw"
+            Child 2: (index 18), name "lblip2"
+            Child 3: (index 19), name "leye"
+            Child 4: (index 20), name "rblip2"
+            Child 5: (index 21), name "ltlip2"
+            Child 6: (index 22), name "rtlip2"
+            Child 7: (index 23), name "reye"
+
+
+
+*/
+
+qboolean R_LoadMDXM( model_t *mod, void *buffer, const char *mod_name, qboolean &bAlreadyCached ) {
+	int					i, l, j;
+	mdxmHeader_t		*pinmodel, *mdxm;
+	mdxmLOD_t			*lod;
+	mdxmSurface_t		*surf;
+	int					version;
+	int					size;
+	shader_t			*sh;
+	mdxmSurfHierarchy_t	*surfInfo;
+
+#ifndef _M_IX86
+	int					k;
+	int					frameSize;
+//	mdxmTag_t			*tag;
+	mdxmTriangle_t		*tri;
+	mdxmVertex_t		*v;
+ 	mdxmFrame_t			*cframe;
+	int					*boneRef;
+#endif
+
+	pinmodel= (mdxmHeader_t *)buffer;
+	//
+	// read some fields from the binary, but only LittleLong() them when we know this wasn't an already-cached model...
+	//	
+	version = (pinmodel->version);
+	size	= (pinmodel->ofsEnd);
+
+	if (!bAlreadyCached)
+	{
+		version = LittleLong(version);
+		size	= LittleLong(size);
+	}
+
+	if (version != MDXM_VERSION) {
+#ifdef _DEBUG
+		Com_Error( ERR_DROP,       "R_LoadMDXM: %s has wrong version (%i should be %i)\n", mod_name, version, MDXM_VERSION);
+#else
+		VID_Printf( PRINT_WARNING, "R_LoadMDXM: %s has wrong version (%i should be %i)\n", mod_name, version, MDXM_VERSION);
+#endif
+		return qfalse;
+	}
+
+	mod->type	   = MOD_MDXM;
+	mod->dataSize += size;	
+	
+	qboolean bAlreadyFound = qfalse;
+	mdxm = mod->mdxm = (mdxmHeader_t*) //Hunk_Alloc( size );
+										RE_RegisterModels_Malloc(size, buffer, mod_name, &bAlreadyFound, TAG_MODEL_GLM);
+
+	assert(bAlreadyCached == bAlreadyFound);
+
+	if (!bAlreadyFound)
+	{
+		// horrible new hackery, if !bAlreadyFound then we've just done a tag-morph, so we need to set the 
+		//	bool reference passed into this function to true, to tell the caller NOT to do an FS_Freefile since
+		//	we've hijacked that memory block...
+		//
+		// Aaaargh. Kill me now...
+		//
+		bAlreadyCached = qtrue;
+		assert( mdxm == buffer );
+//		memcpy( mdxm, buffer, size );	// and don't do this now, since it's the same thing
+
+		LL(mdxm->ident);
+		LL(mdxm->version);
+		LL(mdxm->numLODs);
+		LL(mdxm->ofsLODs);
+		LL(mdxm->numSurfaces);
+		LL(mdxm->ofsSurfHierarchy);
+		LL(mdxm->ofsEnd);
+	}
+		
+	// first up, go load in the animation file we need that has the skeletal animation info for this model
+	mdxm->animIndex = RE_RegisterModel(va ("%s.gla",mdxm->animName));
+	if (!strcmp(mdxm->animName,"models/players/_humanoid/_humanoid"))
+	{	//if we're loading the humanoid, look for a cinematic gla for this map
+		const char*mapname = sv_mapname->string;
+		if (strcmp(mapname,"nomap") )
+		{
+			if (strrchr(mapname,'/') )	//maps in subfolders use the root name, ( presuming only one level deep!)
+			{
+				mapname = strrchr(mapname,'/')+1;
+			}
+			RE_RegisterModel(va ("models/players/_humanoid_%s/_humanoid_%s.gla",mapname,mapname));
+		}
+	}
+	
+	bool isAnOldModelFile = false;
+	if (mdxm->numBones == 72 && strstr(mdxm->animName,"_humanoid") )
+	{
+		isAnOldModelFile = true;
+	}
+
+	if (!mdxm->animIndex) 
+	{
+		VID_Printf( PRINT_WARNING, "R_LoadMDXM: missing animation file %s for mesh %s\n", mdxm->animName, mdxm->name);
+		return qfalse;
+	}
+	else
+	{
+		assert (tr.models[mdxm->animIndex]->mdxa->numBones == mdxm->numBones);
+		if (tr.models[mdxm->animIndex]->mdxa->numBones != mdxm->numBones)
+		{
+			if ( isAnOldModelFile )
+			{
+				VID_Printf( PRINT_WARNING, "R_LoadMDXM: converting jk2 model %s\n", mod_name);
+			}
+			else
+			{
+#ifdef _DEBUG
+				Com_Error( ERR_DROP,       "R_LoadMDXM: %s has different bones than anim (%i != %i)\n", mod_name, mdxm->numBones, tr.models[mdxm->animIndex]->mdxa->numBones);
+#else
+				VID_Printf( PRINT_WARNING, "R_LoadMDXM: %s has different bones than anim (%i != %i)\n", mod_name, mdxm->numBones, tr.models[mdxm->animIndex]->mdxa->numBones);
+#endif
+			}
+			if ( !isAnOldModelFile )
+			{//hmm, load up the old JK2 ones anyway?
+				return qfalse;
+			}
+		}
+	}
+
+	mod->numLods = mdxm->numLODs -1 ;	//copy this up to the model for ease of use - it wil get inced after this.
+
+	if (bAlreadyFound)
+	{
+		return qtrue;	// All done. Stop, go no further, do not LittleLong(), do not pass Go...
+	}
+
+	surfInfo = (mdxmSurfHierarchy_t *)( (byte *)mdxm + mdxm->ofsSurfHierarchy);
+ 	for ( i = 0 ; i < mdxm->numSurfaces ; i++) 
+	{
+		LL(surfInfo->numChildren);
+		LL(surfInfo->parentIndex);
+
+		strlwr(surfInfo->name);	//just in case
+		if ( !strcmp( &surfInfo->name[strlen(surfInfo->name)-4],"_off") )
+		{
+			surfInfo->name[strlen(surfInfo->name)-4]=0;	//remove "_off" from name
+		}
+
+		if ( surfInfo->shader[0] == '[' )
+		{
+			surfInfo->shader[0] = 0;	//kill the stupid [nomaterial] since carcass doesn't
+		}
+
+		// do all the children indexs
+		for (j=0; j<surfInfo->numChildren; j++)
+		{
+			LL(surfInfo->childIndexes[j]);
+		}
+
+		// get the shader name
+		sh = R_FindShader( surfInfo->shader, lightmapsNone, stylesDefault, qtrue );
+		// insert it in the surface list
+		
+		if ( !sh->defaultShader ) 
+		{
+			surfInfo->shaderIndex = sh->index;
+		}
+
+		if (surfInfo->shaderIndex)
+		{
+			RE_RegisterModels_StoreShaderRequest(mod_name, &surfInfo->shader[0], &surfInfo->shaderIndex);		
+		}
+
+		// find the next surface
+		surfInfo = (mdxmSurfHierarchy_t *)( (byte *)surfInfo + (int)( &((mdxmSurfHierarchy_t *)0)->childIndexes[ surfInfo->numChildren ] ));
+  	}
+	
+	// swap all the LOD's	(we need to do the middle part of this even for intel, because of shader reg and err-check)
+	lod = (mdxmLOD_t *) ( (byte *)mdxm + mdxm->ofsLODs );
+	for ( l = 0 ; l < mdxm->numLODs ; l++)
+	{
+		int	triCount = 0;
+
+		LL(lod->ofsEnd);
+		// swap all the surfaces
+		surf = (mdxmSurface_t *) ( (byte *)lod + sizeof (mdxmLOD_t) + (mdxm->numSurfaces * sizeof(mdxmLODSurfOffset_t)) );
+		for ( i = 0 ; i < mdxm->numSurfaces ; i++) 
+		{
+			LL(surf->numTriangles);
+			LL(surf->ofsTriangles);
+			LL(surf->numVerts);
+			LL(surf->ofsVerts);
+			LL(surf->ofsEnd);
+			LL(surf->ofsHeader);
+			LL(surf->numBoneReferences);
+			LL(surf->ofsBoneReferences);
+//			LL(surf->maxVertBoneWeights);
+
+			triCount += surf->numTriangles;
+										
+			if ( surf->numVerts > SHADER_MAX_VERTEXES ) {
+				Com_Error (ERR_DROP, "R_LoadMDXM: %s has more than %i verts on a surface (%i)",
+					mod_name, SHADER_MAX_VERTEXES, surf->numVerts );
+			}
+			if ( surf->numTriangles*3 > SHADER_MAX_INDEXES ) {
+				Com_Error (ERR_DROP, "R_LoadMDXM: %s has more than %i triangles on a surface (%i)",
+					mod_name, SHADER_MAX_INDEXES / 3, surf->numTriangles );
+			}
+		
+			// change to surface identifier
+			surf->ident = SF_MDX;
+
+			// register the shaders
+#ifndef _M_IX86
+//
+// optimisation, we don't bother doing this for standard intel case since our data's already in that format...
+//
+			// FIXME - is this correct? 
+			// do all the bone reference data
+			boneRef = (int *) ( (byte *)surf + surf->ofsBoneReferences );
+			for ( j = 0 ; j < surf->numBoneReferences ; j++ ) 
+			{
+					LL(boneRef[j]);
+			}
+
+			
+			// swap all the triangles
+			tri = (mdxmTriangle_t *) ( (byte *)surf + surf->ofsTriangles );
+			for ( j = 0 ; j < surf->numTriangles ; j++, tri++ ) 
+			{
+				LL(tri->indexes[0]);
+				LL(tri->indexes[1]);
+				LL(tri->indexes[2]);
+			}
+
+			// swap all the vertexes
+			v = (mdxmVertex_t *) ( (byte *)surf + surf->ofsVerts );
+			for ( j = 0 ; j < surf->numVerts ; j++ ) 
+			{
+				v->normal[0] = LittleFloat( v->normal[0] );
+				v->normal[1] = LittleFloat( v->normal[1] );
+				v->normal[2] = LittleFloat( v->normal[2] );
+
+				v->texCoords[0] = LittleFloat( v->texCoords[0] );
+				v->texCoords[1] = LittleFloat( v->texCoords[1] );
+
+				v->numWeights = LittleLong( v->numWeights );
+  			    v->offset[0] = LittleFloat( v->offset[0] );
+				v->offset[1] = LittleFloat( v->offset[1] );
+				v->offset[2] = LittleFloat( v->offset[2] );
+
+				for ( k = 0 ; k < /*v->numWeights*/surf->maxVertBoneWeights ; k++ ) 
+				{
+					v->weights[k].boneIndex = LittleLong( v->weights[k].boneIndex );
+					v->weights[k].boneWeight = LittleFloat( v->weights[k].boneWeight );
+				}
+				v = (mdxmVertex_t *)&v->weights[/*v->numWeights*/surf->maxVertBoneWeights];
+			}
+#endif
+
+			if (isAnOldModelFile)
+			{
+				int *boneRef = (int *) ( (byte *)surf + surf->ofsBoneReferences );
+				for ( j = 0 ; j < surf->numBoneReferences ; j++ ) 
+				{
+					assert(boneRef[j] >= 0 && boneRef[j] < 72);
+					if (boneRef[j] >= 0 && boneRef[j] < 72)
+					{
+						boneRef[j]=OldToNewRemapTable[boneRef[j]];
+					}
+					else
+					{
+						boneRef[j]=0;
+					}
+				}
+			}
+			// find the next surface
+			surf = (mdxmSurface_t *)( (byte *)surf + surf->ofsEnd );
+		}
+		// find the next LOD
+		lod = (mdxmLOD_t *)( (byte *)lod + lod->ofsEnd );
+	}
+
+	return qtrue;
+}
+
+/*
+=================
+R_LoadMDXA - load a Ghoul 2 animation file
+=================
+*/
+qboolean R_LoadMDXA( model_t *mod, void *buffer, const char *mod_name, qboolean &bAlreadyCached ) {
+
+	mdxaHeader_t		*pinmodel, *mdxa;
+	int					version;
+	int					size;
+
+#ifndef _M_IX86
+	int					j, k, i;
+	int					frameSize;
+	mdxaFrame_t			*cframe;
+	mdxaSkel_t			*boneInfo;
+#endif
+
+ 	pinmodel = (mdxaHeader_t *)buffer;
+	//
+	// read some fields from the binary, but only LittleLong() them when we know this wasn't an already-cached model...
+	//	
+	version = (pinmodel->version);
+	size	= (pinmodel->ofsEnd);
+
+	if (!bAlreadyCached)
+	{
+		version = LittleLong(version);
+		size	= LittleLong(size);
+	}
+	
+	if (version != MDXA_VERSION) {
+		VID_Printf( PRINT_WARNING, "R_LoadMDXA: %s has wrong version (%i should be %i)\n",
+				 mod_name, version, MDXA_VERSION);
+		return qfalse;
+	}
+
+	mod->type		= MOD_MDXA;
+	mod->dataSize  += size;
+
+	qboolean bAlreadyFound = qfalse;
+	mdxa = mod->mdxa = (mdxaHeader_t*) //Hunk_Alloc( size );
+										RE_RegisterModels_Malloc(size, buffer, mod_name, &bAlreadyFound, TAG_MODEL_GLA);
+
+	assert(bAlreadyCached == bAlreadyFound);
+
+	if (!bAlreadyFound)
+	{
+		// horrible new hackery, if !bAlreadyFound then we've just done a tag-morph, so we need to set the 
+		//	bool reference passed into this function to true, to tell the caller NOT to do an FS_Freefile since
+		//	we've hijacked that memory block...
+		//
+		// Aaaargh. Kill me now...
+		//
+		bAlreadyCached = qtrue;
+		assert( mdxa == buffer );
+//		memcpy( mdxa, buffer, size );	// and don't do this now, since it's the same thing
+
+		LL(mdxa->ident);
+		LL(mdxa->version);
+		LL(mdxa->numFrames);
+		LL(mdxa->numBones);
+		LL(mdxa->ofsFrames);
+		LL(mdxa->ofsEnd);
+	}
+
+ 	if ( mdxa->numFrames < 1 ) {
+		VID_Printf( PRINT_WARNING, "R_LoadMDXA: %s has no frames\n", mod_name );
+		return qfalse;
+	}
+
+	if (bAlreadyFound)
+	{
+		return qtrue;	// All done, stop here, do not LittleLong() etc. Do not pass go...
+	}
+
+#ifndef _M_IX86
+
+	//
+	// optimisation, we don't bother doing this for standard intel case since our data's already in that format...
+	//
+
+	// swap all the skeletal info
+	boneInfo = (mdxaSkel_t *)( (byte *)mdxa + mdxa->ofsSkel);
+	for ( i = 0 ; i < mdxa->numBones ; i++) 
+	{
+		LL(boneInfo->numChildren);
+		LL(boneInfo->parent);
+		for (k=0; k<boneInfo->numChildren; k++)
+		{
+			LL(boneInfo->children[k]);
+		}
+
+		// get next bone
+		boneInfo += (int)( &((mdxaSkel_t *)0)->children[ boneInfo->numChildren ] );
+	}
+
+
+	// swap all the frames
+	frameSize = (int)( &((mdxaFrame_t *)0)->bones[ mdxa->numBones ] );
+	for ( i = 0 ; i < mdxa->numFrames ; i++) 
+	{
+		cframe = (mdxaFrame_t *) ( (byte *)mdxa + mdxa->ofsFrames + i * frameSize );
+   		cframe->radius = LittleFloat( cframe->radius );
+		for ( j = 0 ; j < 3 ; j++ ) 
+		{
+			cframe->bounds[0][j] = LittleFloat( cframe->bounds[0][j] );
+			cframe->bounds[1][j] = LittleFloat( cframe->bounds[1][j] );
+    		cframe->localOrigin[j] = LittleFloat( cframe->localOrigin[j] );
+		}
+		for ( j = 0 ; j < mdxa->numBones * sizeof( mdxaBone_t ) / 2 ; j++ ) 
+		{
+			((short *)cframe->bones)[j] = LittleShort( ((short *)cframe->bones)[j] );
+		}
+	}
+#endif
+	return qtrue;
+}
+
diff --git a/code/renderer/tr_image.cpp b/code/renderer/tr_image.cpp
new file mode 100644
index 0000000..7a48fa9
--- /dev/null
+++ b/code/renderer/tr_image.cpp
@@ -0,0 +1,3373 @@
+// tr_image.c
+
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+
+
+#include "tr_local.h"
+#ifndef _XBOX
+#include "tr_jpeg_interface.h"
+#else
+#include "../qcommon/sstring.h"
+#include "../zlib/zlib.h"
+#endif
+#include "../png/png.h"
+#include "../qcommon/sstring.h"
+
+
+static byte			 s_intensitytable[256];
+static unsigned char s_gammatable[256];
+
+int		gl_filter_min = GL_LINEAR_MIPMAP_NEAREST;
+int		gl_filter_max = GL_LINEAR;
+
+#define FILE_HASH_SIZE		1024	// actually, the shader code needs this (from another module, great).
+//static	image_t*		hashTable[FILE_HASH_SIZE];
+
+/*
+** R_GammaCorrect
+*/
+void R_GammaCorrect( byte *buffer, int bufSize ) {
+	int i;
+
+	for ( i = 0; i < bufSize; i++ ) {
+		buffer[i] = s_gammatable[buffer[i]];
+	}
+}
+
+typedef struct {
+	char *name;
+	int	minimize, maximize;
+} textureMode_t;
+
+textureMode_t modes[] = {
+	{"GL_NEAREST", GL_NEAREST, GL_NEAREST},
+	{"GL_LINEAR", GL_LINEAR, GL_LINEAR},
+	{"GL_NEAREST_MIPMAP_NEAREST", GL_NEAREST_MIPMAP_NEAREST, GL_NEAREST},
+	{"GL_LINEAR_MIPMAP_NEAREST", GL_LINEAR_MIPMAP_NEAREST, GL_LINEAR},
+	{"GL_NEAREST_MIPMAP_LINEAR", GL_NEAREST_MIPMAP_LINEAR, GL_NEAREST},
+	{"GL_LINEAR_MIPMAP_LINEAR", GL_LINEAR_MIPMAP_LINEAR, GL_LINEAR}
+};
+
+/*
+================
+return a hash value for the filename
+================
+*/
+long generateHashValue( const char *fname ) {
+	int		i;
+	long	hash;
+	char	letter;
+
+	hash = 0;
+	i = 0;
+	while (fname[i] != '\0') {
+		letter = tolower(fname[i]);
+		if (letter =='.') break;				// don't include extension
+		if (letter =='\\') letter = '/';		// damn path names
+		hash+=(long)(letter)*(i+119);
+		i++;
+	}
+	hash &= (FILE_HASH_SIZE-1);
+	return hash;
+}
+
+// makeup a nice clean, consistant name to query for and file under, for map<> usage...
+//
+char *GenerateImageMappingName( const char *name )
+{
+	static char sName[MAX_QPATH];
+	int		i=0;
+	char	letter;
+	
+	while (name[i] != '\0' && i<MAX_QPATH-1) 
+	{
+		letter = tolower(name[i]);
+		if (letter =='.') break;				// don't include extension
+		if (letter =='\\') letter = '/';		// damn path names
+		sName[i++] = letter;
+	}
+	sName[i]=0;
+	
+	return &sName[0];
+}
+
+/*
+===============
+GL_TextureMode
+===============
+*/
+void GL_TextureMode( const char *string ) {
+	int		i;
+	image_t	*glt;
+
+	for ( i=0 ; i< 6 ; i++ ) {
+		if ( !Q_stricmp( modes[i].name, string ) ) {
+			break;
+		}
+	}
+
+	if ( i == 6 ) {
+		VID_Printf (PRINT_ALL, "bad filter name\n");
+		for ( i=0 ; i< 6 ; i++ ) {
+			VID_Printf( PRINT_ALL, "%s\n",modes[i].name);
+			}
+		return;
+	}
+
+	gl_filter_min = modes[i].minimize;
+	gl_filter_max = modes[i].maximize;
+
+	// If the level they requested is less than possible, set the max possible...
+	if ( r_ext_texture_filter_anisotropic->value > glConfig.maxTextureFilterAnisotropy )
+	{
+		Cvar_Set( "r_ext_texture_filter_anisotropic", va("%f",glConfig.maxTextureFilterAnisotropy) );
+	}
+
+	// change all the existing mipmap texture objects
+//	int iNumImages = 
+	   				 R_Images_StartIteration();
+	while ( (glt   = R_Images_GetNextIteration()) != NULL)
+	{
+#ifdef _XBOX
+		if ( glt->mipcount ) {
+#else
+		if ( glt->mipmap ) {
+#endif
+			GL_Bind (glt);
+			qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, gl_filter_min);
+			qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, gl_filter_max);
+
+			if(glConfig.maxTextureFilterAnisotropy>0) {
+				if(r_ext_texture_filter_anisotropic->integer>1) {
+					qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, r_ext_texture_filter_anisotropic->value);
+				} else {
+					qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, 1.0f);
+				}
+			}
+		}
+	}
+}
+
+static float R_BytesPerTex (int format)
+{
+	switch ( format ) {
+	case 1:
+		//"I    " 
+		return 1;
+		break;
+	case 2:
+		//"IA   " 
+		return 2;
+		break;
+	case 3:
+		//"RGB  " 
+		return glConfig.colorBits/8.0f;
+		break;
+	case 4:
+		//"RGBA " 
+		return glConfig.colorBits/8.0f;
+		break;
+		
+	case GL_RGBA4:
+		//"RGBA4" 
+		return 2;
+		break;
+	case GL_RGB5:
+		//"RGB5 " 
+		return 2;
+		break;
+		
+	case GL_RGBA8:
+		//"RGBA8" 
+		return 4;
+		break;
+	case GL_RGB8:
+		//"RGB8" 
+		return 4;
+		break;
+		
+	case GL_RGB4_S3TC:
+		//"S3TC " 
+		return 0.33333f;
+		break;
+	case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
+		//"DXT1 " 
+		return 0.33333f;
+		break;
+	case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
+		//"DXT5 " 
+		return 1;
+		break;
+#ifdef _XBOX
+	case GL_DDS1_EXT:
+		//"DDS1 "
+		return 0.5f;
+		break;
+	case GL_DDS5_EXT:
+		//"DDS5 "
+		return 1;
+		break;
+	case GL_DDS_RGB16_EXT:
+		//"DDS16"
+		return 2;
+		break;
+	case GL_DDS_RGBA32_EXT:
+		//"DDS32"
+		return 4;
+		break;
+#endif
+	default:
+		//"???? " 
+		return 4;
+	}
+}
+
+/*
+===============
+R_SumOfUsedImages
+===============
+*/
+#ifndef _XBOX
+float R_SumOfUsedImages( qboolean bUseFormat ) 
+{
+	int	total = 0;
+	image_t *pImage;
+
+	   				  R_Images_StartIteration();
+	while ( (pImage = R_Images_GetNextIteration()) != NULL)
+	{
+		if ( pImage->frameUsed == tr.frameCount- 1 ) {//it has already been advanced for the next frame, so...
+			if (bUseFormat)
+			{
+				float  bytePerTex = R_BytesPerTex (pImage->internalFormat);
+				total += bytePerTex * (pImage->width * pImage->height);
+			}
+			else
+			{
+				total += pImage->width * pImage->height;
+			}
+		}
+	}
+
+	return total;
+}
+#endif
+
+/*
+===============
+R_ImageList_f
+===============
+*/
+void R_ImageList_f( void ) {
+	int		i=0;
+	image_t	*image;
+	int		texels = 0;
+//	int		totalFileSizeK = 0;
+	float	texBytes = 0.0f;
+	const char *yesno[] = {"no ", "yes"};
+
+	VID_Printf (PRINT_ALL, "\n      -w-- -h-- -fsK- -mm- -if- wrap --name-------\n");
+
+	int iNumImages = R_Images_StartIteration();
+	while ( (image = R_Images_GetNextIteration()) != NULL)
+	{
+		texels   += image->width*image->height;
+		texBytes += image->width*image->height * R_BytesPerTex (image->internalFormat);
+//		totalFileSizeK += (image->imgfileSize+1023)/1024;
+#ifdef _XBOX
+		VID_Printf (PRINT_ALL,  "%4i: %4i %4i  %s ",
+			i, image->width, image->height, yesno[image->mipcount] );
+#else
+		//VID_Printf (PRINT_ALL,  "%4i: %4i %4i %5i  %s ",
+		//	i, image->width, image->height,(image->fileSize+1023)/1024, yesno[image->mipmap] );
+		VID_Printf (PRINT_ALL,  "%4i: %4i %4i  %s ",
+			i, image->width, image->height,yesno[image->mipmap] );
+#endif
+		switch ( image->internalFormat ) {
+		case 1:
+			VID_Printf( PRINT_ALL, "I    " );
+			break;
+		case 2:
+			VID_Printf( PRINT_ALL, "IA   " );
+			break;
+		case 3:
+			VID_Printf( PRINT_ALL, "RGB  " );
+			break;
+		case 4:
+			VID_Printf( PRINT_ALL, "RGBA " );
+			break;
+		case GL_RGBA8:
+			VID_Printf( PRINT_ALL, "RGBA8" );
+			break;
+		case GL_RGB8:
+			VID_Printf( PRINT_ALL, "RGB8 " );
+			break;
+		case GL_RGB4_S3TC:
+			VID_Printf( PRINT_ALL, "S3TC " );
+			break;
+		case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
+			VID_Printf( PRINT_ALL, "DXT1 " );
+			break;
+		case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
+			VID_Printf( PRINT_ALL, "DXT5 " );
+			break;
+		case GL_RGBA4:
+			VID_Printf( PRINT_ALL, "RGBA4" );
+			break;
+		case GL_RGB5:
+			VID_Printf( PRINT_ALL, "RGB5 " );
+			break;
+#ifdef _XBOX
+		case GL_DDS1_EXT:
+			VID_Printf( PRINT_ALL, "DDS1 " );
+			break;
+		case GL_DDS5_EXT:
+			VID_Printf( PRINT_ALL, "DDS5 " );
+			break;
+		case GL_DDS_RGB16_EXT:
+			VID_Printf( PRINT_ALL, "DDS16" );
+			break;
+		case GL_DDS_RGBA32_EXT:
+			VID_Printf( PRINT_ALL, "DDS32" );
+			break;
+#endif
+		default:
+			VID_Printf( PRINT_ALL, "???? " );
+		}
+
+		switch ( image->wrapClampMode ) {
+		case GL_REPEAT:
+			VID_Printf( PRINT_ALL, "rept " );
+			break;
+		case GL_CLAMP:
+			VID_Printf( PRINT_ALL, "clmp " );
+			break;
+		case GL_CLAMP_TO_EDGE:
+			VID_Printf( PRINT_ALL, "clpE " );
+			break;
+		default:
+			VID_Printf( PRINT_ALL, "%4i ", image->wrapClampMode );
+			break;
+		}
+		
+#ifndef _XBOX
+		VID_Printf( PRINT_ALL, "%s\n", image->imgName );
+#endif
+		i++;
+	}
+	VID_Printf (PRINT_ALL, " ---------\n");
+	VID_Printf (PRINT_ALL, "      -w-- -h-- -mm- -if- wrap --name-------\n");
+	VID_Printf (PRINT_ALL, " %i total texels (not including mipmaps)\n", texels );
+//	VID_Printf (PRINT_ALL, " %iMB total filesize\n", (totalFileSizeK+1023)/1024 );
+	VID_Printf (PRINT_ALL, " %.2fMB total texture mem (not including mipmaps)\n", texBytes/1048576.0f );
+	VID_Printf (PRINT_ALL, " %i total images\n\n", iNumImages );
+}
+
+//=======================================================================
+
+
+/*
+================
+R_LightScaleTexture
+
+Scale up the pixel values in a texture to increase the
+lighting range
+================
+*/
+static void R_LightScaleTexture (unsigned *in, int inwidth, int inheight, qboolean only_gamma )
+{
+	if ( only_gamma )
+	{
+		if ( !glConfig.deviceSupportsGamma )
+		{
+			int		i, c;
+			byte	*p;
+
+			p = (byte *)in;
+
+			c = inwidth*inheight;
+			for (i=0 ; i<c ; i++, p+=4)
+			{
+				p[0] = s_gammatable[p[0]];
+				p[1] = s_gammatable[p[1]];
+				p[2] = s_gammatable[p[2]];
+			}
+		}
+	}
+	else
+	{
+		int		i, c;
+		byte	*p;
+
+		p = (byte *)in;
+
+		c = inwidth*inheight;
+
+		if ( glConfig.deviceSupportsGamma )
+		{
+			for (i=0 ; i<c ; i++, p+=4)
+			{
+				p[0] = s_intensitytable[p[0]];
+				p[1] = s_intensitytable[p[1]];
+				p[2] = s_intensitytable[p[2]];
+			}
+		}
+		else
+		{
+			for (i=0 ; i<c ; i++, p+=4)
+			{
+				p[0] = s_gammatable[s_intensitytable[p[0]]];
+				p[1] = s_gammatable[s_intensitytable[p[1]]];
+				p[2] = s_gammatable[s_intensitytable[p[2]]];
+			}
+		}
+	}
+}
+
+
+/*
+================
+R_MipMap2
+
+Uses temp mem, but then copies back to input, quartering the size of the texture
+Proper linear filter
+================
+*/
+static void R_MipMap2( unsigned *in, int inWidth, int inHeight ) {
+	int			i, j, k;
+	byte		*outpix;
+	int			inWidthMask, inHeightMask;
+	int			total;
+	int			outWidth, outHeight;
+	unsigned	*temp;
+
+	outWidth = inWidth >> 1;
+	outHeight = inHeight >> 1;
+	temp = (unsigned int *) Z_Malloc( outWidth * outHeight * 4, TAG_TEMP_WORKSPACE, qfalse );
+
+	inWidthMask = inWidth - 1;
+	inHeightMask = inHeight - 1;
+
+	for ( i = 0 ; i < outHeight ; i++ ) {
+		for ( j = 0 ; j < outWidth ; j++ ) {
+			outpix = (byte *) ( temp + i * outWidth + j );
+			for ( k = 0 ; k < 4 ; k++ ) {
+				total = 
+					1 * ((byte *)&in[ ((i*2-1)&inHeightMask)*inWidth + ((j*2-1)&inWidthMask) ])[k] +
+					2 * ((byte *)&in[ ((i*2-1)&inHeightMask)*inWidth + ((j*2)&inWidthMask) ])[k] +
+					2 * ((byte *)&in[ ((i*2-1)&inHeightMask)*inWidth + ((j*2+1)&inWidthMask) ])[k] +
+					1 * ((byte *)&in[ ((i*2-1)&inHeightMask)*inWidth + ((j*2+2)&inWidthMask) ])[k] +
+
+					2 * ((byte *)&in[ ((i*2)&inHeightMask)*inWidth + ((j*2-1)&inWidthMask) ])[k] +
+					4 * ((byte *)&in[ ((i*2)&inHeightMask)*inWidth + ((j*2)&inWidthMask) ])[k] +
+					4 * ((byte *)&in[ ((i*2)&inHeightMask)*inWidth + ((j*2+1)&inWidthMask) ])[k] +
+					2 * ((byte *)&in[ ((i*2)&inHeightMask)*inWidth + ((j*2+2)&inWidthMask) ])[k] +
+
+					2 * ((byte *)&in[ ((i*2+1)&inHeightMask)*inWidth + ((j*2-1)&inWidthMask) ])[k] +
+					4 * ((byte *)&in[ ((i*2+1)&inHeightMask)*inWidth + ((j*2)&inWidthMask) ])[k] +
+					4 * ((byte *)&in[ ((i*2+1)&inHeightMask)*inWidth + ((j*2+1)&inWidthMask) ])[k] +
+					2 * ((byte *)&in[ ((i*2+1)&inHeightMask)*inWidth + ((j*2+2)&inWidthMask) ])[k] +
+
+					1 * ((byte *)&in[ ((i*2+2)&inHeightMask)*inWidth + ((j*2-1)&inWidthMask) ])[k] +
+					2 * ((byte *)&in[ ((i*2+2)&inHeightMask)*inWidth + ((j*2)&inWidthMask) ])[k] +
+					2 * ((byte *)&in[ ((i*2+2)&inHeightMask)*inWidth + ((j*2+1)&inWidthMask) ])[k] +
+					1 * ((byte *)&in[ ((i*2+2)&inHeightMask)*inWidth + ((j*2+2)&inWidthMask) ])[k];
+				outpix[k] = total / 36;
+			}
+		}
+	}
+
+	memcpy( in, temp, outWidth * outHeight * 4 );
+	Z_Free( temp );
+}
+
+/*
+================
+R_MipMap
+
+Operates in place, quartering the size of the texture
+================
+*/
+static void R_MipMap (byte *in, int width, int height) {
+	int		i, j;
+	byte	*out;
+	int		row;
+
+	if ( width == 1 && height == 1 ) {
+		return;
+	}
+
+	if ( !r_simpleMipMaps->integer ) {
+		R_MipMap2( (unsigned *)in, width, height );
+		return;
+	}
+
+	row = width * 4;
+	out = in;
+	width >>= 1;
+	height >>= 1;
+
+	if ( width == 0 || height == 0 ) {
+		width += height;	// get largest
+		for (i=0 ; i<width ; i++, out+=4, in+=8 ) {
+			out[0] = ( in[0] + in[4] )>>1;
+			out[1] = ( in[1] + in[5] )>>1;
+			out[2] = ( in[2] + in[6] )>>1;
+			out[3] = ( in[3] + in[7] )>>1;
+		}
+		return;
+	}
+
+	for (i=0 ; i<height ; i++, in+=row) {
+		for (j=0 ; j<width ; j++, out+=4, in+=8) {
+			out[0] = (in[0] + in[4] + in[row+0] + in[row+4])>>2;
+			out[1] = (in[1] + in[5] + in[row+1] + in[row+5])>>2;
+			out[2] = (in[2] + in[6] + in[row+2] + in[row+6])>>2;
+			out[3] = (in[3] + in[7] + in[row+3] + in[row+7])>>2;
+		}
+	}
+}
+
+
+/*
+==================
+R_BlendOverTexture
+
+Apply a color blend over a set of pixels
+==================
+*/
+static void R_BlendOverTexture( byte *data, int pixelCount, byte blend[4] ) {
+	int		i;
+	int		inverseAlpha;
+	int		premult[3];
+
+	inverseAlpha = 255 - blend[3];
+	premult[0] = blend[0] * blend[3];
+	premult[1] = blend[1] * blend[3];
+	premult[2] = blend[2] * blend[3];
+
+	for ( i = 0 ; i < pixelCount ; i++, data+=4 ) {
+		data[0] = ( data[0] * inverseAlpha + premult[0] ) >> 9;
+		data[1] = ( data[1] * inverseAlpha + premult[1] ) >> 9;
+		data[2] = ( data[2] * inverseAlpha + premult[2] ) >> 9;
+	}
+}
+
+byte	mipBlendColors[16][4] = {
+	{0,0,0,0},
+	{255,0,0,128},
+	{0,255,0,128},
+	{0,0,255,128},
+	{255,0,0,128},
+	{0,255,0,128},
+	{0,0,255,128},
+	{255,0,0,128},
+	{0,255,0,128},
+	{0,0,255,128},
+	{255,0,0,128},
+	{0,255,0,128},
+	{0,0,255,128},
+	{255,0,0,128},
+	{0,255,0,128},
+	{0,0,255,128},
+};
+
+
+/*
+===============
+Upload32
+
+===============
+*/
+#ifdef _XBOX
+static void Upload32( unsigned *data, 
+						  int img_width, int img_height, 
+						  GLenum format,
+						  int mipcount, 
+						  qboolean picmip, 
+						  qboolean isLightmap, 
+						  int *pformat )
+{
+	if (format == GL_RGBA)
+	{
+		int			samples;
+		int			i, c;
+		byte		*scan;
+		int			width = img_width;
+		int			height = img_height; 
+		
+		//
+		// perform optional picmip operation
+		//
+		if ( picmip ) {
+			for(i = 0; i < r_picmip->integer; i++) {
+				R_MipMap( (byte *)data, width, height );
+				width >>= 1;
+				height >>= 1;
+				if (width < 1) {
+					width = 1;
+				}
+				if (height < 1) {
+					height = 1;
+				}
+			}
+		}
+		
+		//
+		// clamp to the current upper OpenGL limit
+		// scale both axis down equally so we don't have to
+		// deal with a half mip resampling
+		//
+		while ( width > glConfig.maxTextureSize	|| height > glConfig.maxTextureSize ) {
+			R_MipMap( (byte *)data, width, height );
+			width >>= 1;
+			height >>= 1;
+		}
+		
+		//
+		// scan the texture for each channel's max values
+		// and verify if the alpha channel is being used or not
+		//
+		c = width*height;
+		scan = ((byte *)data);
+		samples = 3;
+		for ( i = 0; i < c; i++ )
+		{
+			if ( scan[i*4 + 3] != 255 ) 
+			{
+				samples = 4;
+				break;
+			}
+		}
+		
+		// select proper internal format
+		if ( samples == 3 )
+		{
+			if ( isLightmap && r_texturebitslm->integer > 0 )
+			{
+				// Allow different bit depth when we are a lightmap
+				if ( r_texturebitslm->integer == 16 )
+				{
+					*pformat = GL_RGB5;
+				}
+				else if ( r_texturebitslm->integer == 32 )
+				{
+					*pformat = GL_RGB8;
+				}
+			}
+			else if ( r_texturebits->integer == 16 )
+			{
+				*pformat = GL_RGB5;
+			}
+			else if ( r_texturebits->integer == 32 )
+			{
+				*pformat = GL_RGB8;
+			}
+			else
+			{
+				*pformat = 3;
+			}
+		}
+		else if ( samples == 4 )
+		{
+			if ( r_texturebits->integer == 16 )
+			{
+				*pformat = GL_RGBA4;
+			}
+			else if ( r_texturebits->integer == 32 )
+			{
+				*pformat = GL_RGBA8;
+			}
+			else
+			{
+				*pformat = 4;
+			}
+		}
+		
+		// copy or resample data as appropriate for first MIP level
+		if (!mipcount)
+		{
+			qglTexImage2D (GL_TEXTURE_2D, 0, *pformat, width, height, 0, 
+				GL_RGBA, GL_UNSIGNED_BYTE, data);
+		}
+		else
+		{
+			if (mipcount)
+			{
+				int	miplevel = 0;
+				int total = 1;
+				int n = width;
+				if (height > n) n = height;
+				while (n > 1)
+				{
+					n >>= 1;
+					++total;
+				}
+				
+				qglTexImage2DEXT (GL_TEXTURE_2D, 0, total, *pformat, width, height, 
+					0, GL_RGBA, GL_UNSIGNED_BYTE, data );
+			}
+		}
+	}
+	else
+	{
+		*pformat = format;
+
+		qglTexImage2DEXT (GL_TEXTURE_2D, 0, mipcount,
+			format, img_width, img_height, 0, format, 
+			GL_UNSIGNED_BYTE, data);
+	}
+
+	if (mipcount)
+	{
+		qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, gl_filter_min);
+		qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, gl_filter_max);
+		if(glConfig.textureFilterAnisotropicAvailable)
+		{
+			qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, 2.0f);
+		}
+	}
+	else
+	{
+		qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
+		qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
+	}
+
+	GL_CheckErrors();
+}
+
+#else // _XBOX
+
+static void Upload32( unsigned *data, 
+						  GLenum format,
+						  qboolean mipmap, 
+						  qboolean picmip, 
+						  qboolean isLightmap, 
+						  qboolean allowTC, 
+						  int *pformat, 
+						  USHORT *pUploadWidth, USHORT *pUploadHeight )
+{
+	if (format == GL_RGBA)
+	{
+	    int			samples;
+	    int			i, c;
+	    byte		*scan;
+	    float		rMax = 0, gMax = 0, bMax = 0;
+	    int			width = *pUploadWidth;
+	    int			height = *pUploadHeight; 
+    
+	    //
+	    // perform optional picmip operation
+	    //
+	    if ( picmip ) {
+		    for(i = 0; i < r_picmip->integer; i++) {
+			    R_MipMap( (byte *)data, width, height );
+			    width >>= 1;
+			    height >>= 1;
+			    if (width < 1) {
+				    width = 1;
+			    }
+			    if (height < 1) {
+				    height = 1;
+			    }
+		    }
+	    }
+    
+	    //
+	    // clamp to the current upper OpenGL limit
+	    // scale both axis down equally so we don't have to
+	    // deal with a half mip resampling
+	    //
+	    while ( width > glConfig.maxTextureSize	|| height > glConfig.maxTextureSize ) {
+		    R_MipMap( (byte *)data, width, height );
+		    width >>= 1;
+		    height >>= 1;
+	    }
+    
+	    //
+	    // scan the texture for each channel's max values
+	    // and verify if the alpha channel is being used or not
+	    //
+	    c = width*height;
+	    scan = ((byte *)data);
+	    samples = 3;
+	    for ( i = 0; i < c; i++ )
+	    {
+		    if ( scan[i*4+0] > rMax )
+		    {
+			    rMax = scan[i*4+0];
+		    }
+		    if ( scan[i*4+1] > gMax )
+		    {
+			    gMax = scan[i*4+1];
+		    }
+		    if ( scan[i*4+2] > bMax )
+		    {
+			    bMax = scan[i*4+2];
+		    }
+		    if ( scan[i*4 + 3] != 255 ) 
+		    {
+			    samples = 4;
+			    break;
+		    }
+	    }
+
+	    // select proper internal format
+	    if ( samples == 3 )
+	    {
+		    if ( glConfig.textureCompression == TC_S3TC && allowTC )
+		    {
+			    *pformat = GL_RGB4_S3TC;
+		    }
+		    else if ( glConfig.textureCompression == TC_S3TC_DXT && allowTC )
+		    {	// Compress purely color - no alpha
+			    if ( r_texturebits->integer == 16 ) {
+				    *pformat = GL_COMPRESSED_RGB_S3TC_DXT1_EXT;	//this format cuts to 16 bit
+			    }
+			    else {//if we aren't using 16 bit then, use 32 bit compression
+				    *pformat = GL_COMPRESSED_RGBA_S3TC_DXT5_EXT;
+			    }
+		    }
+		    else if ( isLightmap && r_texturebitslm->integer > 0 )
+		    {
+			    // Allow different bit depth when we are a lightmap
+			    if ( r_texturebitslm->integer == 16 )
+			    {
+				    *pformat = GL_RGB5;
+			    }
+			    else if ( r_texturebitslm->integer == 32 )
+			    {
+				    *pformat = GL_RGB8;
+			    }
+		    }
+		    else if ( r_texturebits->integer == 16 )
+		    {
+			    *pformat = GL_RGB5;
+		    }
+		    else if ( r_texturebits->integer == 32 )
+		    {
+			    *pformat = GL_RGB8;
+		    }
+		    else
+		    {
+			    *pformat = 3;
+		    }
+	    }
+	    else if ( samples == 4 )
+	    {
+		    if ( glConfig.textureCompression == TC_S3TC_DXT && allowTC)
+		    {	// Compress both alpha and color
+			    *pformat = GL_COMPRESSED_RGBA_S3TC_DXT5_EXT;
+		    }
+		    else if ( r_texturebits->integer == 16 )
+		    {
+			    *pformat = GL_RGBA4;
+		    }
+		    else if ( r_texturebits->integer == 32 )
+		    {
+			    *pformat = GL_RGBA8;
+		    }
+		    else
+		    {
+			    *pformat = 4;
+		    }
+	    }
+
+		*pUploadWidth = width;
+		*pUploadHeight = height;
+
+	    // copy or resample data as appropriate for first MIP level
+	    if (!mipmap)
+	    {
+		    qglTexImage2D (GL_TEXTURE_2D, 0, *pformat, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, data);
+		    goto done;
+	    }
+
+		R_LightScaleTexture (data, width, height, !mipmap );
+    
+	    qglTexImage2D (GL_TEXTURE_2D, 0, *pformat, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, data );
+    
+	    if (mipmap)
+	    {
+		    int		miplevel;
+    
+		    miplevel = 0;
+		    while (width > 1 || height > 1)
+		    {
+			    R_MipMap( (byte *)data, width, height );
+			    width >>= 1;
+			    height >>= 1;
+			    if (width < 1)
+				    width = 1;
+			    if (height < 1)
+				    height = 1;
+			    miplevel++;
+    
+			    if ( r_colorMipLevels->integer ) 
+			    {
+				    R_BlendOverTexture( (byte *)data, width * height, mipBlendColors[miplevel] );
+			    }
+    
+			    qglTexImage2D (GL_TEXTURE_2D, miplevel, *pformat, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, data );
+		    }
+	    }
+	}
+	else
+	{
+
+	}
+
+done:
+
+	if (mipmap)
+	{
+		qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, gl_filter_min);
+		qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, gl_filter_max);
+		if( r_ext_texture_filter_anisotropic->integer > 1 && glConfig.maxTextureFilterAnisotropy > 0 )
+		{			
+			qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, r_ext_texture_filter_anisotropic->value );
+		}
+	}
+	else
+	{
+		qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
+		qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
+	}
+
+	GL_CheckErrors();
+}
+#endif // _XBOX
+
+#ifdef _XBOX
+typedef tmap (int, image_t *)	AllocatedImages_t;
+								AllocatedImages_t* AllocatedImages = NULL;
+								AllocatedImages_t::iterator itAllocatedImages;
+#else
+class CStringComparator
+{
+public:
+	bool operator()(const char *s1, const char *s2) const { return(stricmp(s1, s2) < 0); } 
+};
+
+typedef map <LPCSTR, image_t *, CStringComparator>	AllocatedImages_t;
+													AllocatedImages_t AllocatedImages;
+													AllocatedImages_t::iterator itAllocatedImages;
+#endif // _XBOX
+int giTextureBindNum = 1024;	// will be set to this anyway at runtime, but wtf?
+
+
+// return = number of images in the list, for those interested
+//
+#ifdef _XBOX
+int R_Images_StartIteration(void)
+{
+	if(!AllocatedImages)
+		return 0;
+
+	itAllocatedImages = AllocatedImages->begin();
+	return AllocatedImages->size();
+}
+
+image_t *R_Images_GetNextIteration(void)
+{
+	if(!AllocatedImages)
+		return NULL;
+
+	if (itAllocatedImages == AllocatedImages->end())
+		return NULL;
+
+	image_t *pImage = (*itAllocatedImages).second;
+	++itAllocatedImages;
+	return pImage;
+}
+#else
+int R_Images_StartIteration(void)
+{
+	itAllocatedImages = AllocatedImages.begin();
+	return AllocatedImages.size();
+}
+
+image_t *R_Images_GetNextIteration(void)
+{
+	if (itAllocatedImages == AllocatedImages.end())
+		return NULL;
+
+	image_t *pImage = (*itAllocatedImages).second;
+	++itAllocatedImages;
+	return pImage;
+}
+#endif
+
+// clean up anything to do with an image_t struct, but caller will have to clear the internal to an image_t struct ready for either struct free() or overwrite...
+//
+static void R_Images_DeleteImageContents( image_t *pImage )
+{
+	assert(pImage);	// should never be called with NULL
+	if (pImage)
+	{
+		qglDeleteTextures( 1, &pImage->texnum );
+		Z_Free(pImage);
+	}
+}
+
+static void GL_ResetBinds(void)
+{
+	memset( glState.currenttextures, 0, sizeof( glState.currenttextures ) );
+	if ( qglBindTexture ) 
+	{
+		if ( qglActiveTextureARB ) 
+		{
+			GL_SelectTexture( 1 );
+			qglBindTexture( GL_TEXTURE_2D, 0 );
+			GL_SelectTexture( 0 );
+			qglBindTexture( GL_TEXTURE_2D, 0 );
+		} 
+		else 
+		{
+			qglBindTexture( GL_TEXTURE_2D, 0 );
+		}
+	}
+}
+
+// special function used in conjunction with "devmapbsp"...
+//
+#ifdef _XBOX
+void R_Images_DeleteLightMaps(void)
+{
+	qboolean bEraseOccured = qfalse;
+	for (AllocatedImages_t::iterator itImage = AllocatedImages->begin(); itImage != AllocatedImages->end(); bEraseOccured?itImage:++itImage)
+	{			
+		bEraseOccured = qfalse;
+
+		image_t *pImage = (*itImage).second;
+		
+		if (pImage->isLightmap)
+		{
+			R_Images_DeleteImageContents(pImage);
+
+			AllocatedImages->erase(itImage++);
+			bEraseOccured = qtrue;
+		}
+	}
+
+	GL_ResetBinds();
+}
+
+#else // _XBOX
+
+void R_Images_DeleteLightMaps(void)
+{
+	qboolean bEraseOccured = qfalse;
+
+	for (AllocatedImages_t::iterator itImage = AllocatedImages.begin(); itImage != AllocatedImages.end(); bEraseOccured?itImage:++itImage)
+	{			
+		bEraseOccured = qfalse;
+
+		image_t *pImage = (*itImage).second;
+		
+		if (pImage->imgName[0] == '$' /*&& strstr(pImage->imgName,"lightmap")*/)	// loose check, but should be ok
+		{
+			R_Images_DeleteImageContents(pImage);
+			itImage = AllocatedImages.erase(itImage);
+
+			bEraseOccured = qtrue;
+		}
+	}
+
+	GL_ResetBinds();
+}
+#endif // _XBOX
+
+// special function currently only called by Dissolve code...
+//
+#ifdef _XBOX
+void R_Images_DeleteImage(image_t *pImage)
+{		
+	// Even though we supply the image handle, we need to get the corresponding iterator entry...
+	//
+	AllocatedImages_t::iterator itImage = AllocatedImages->find(pImage->imgCode);
+	if (itImage != AllocatedImages->end())
+	{		
+		R_Images_DeleteImageContents(pImage);
+		AllocatedImages->erase(itImage);
+	}
+	else
+	{
+		assert(0);
+	}
+}
+#else // _XBOX
+
+void R_Images_DeleteImage(image_t *pImage)
+{		
+	// Even though we supply the image handle, we need to get the corresponding iterator entry...
+	//
+	AllocatedImages_t::iterator itImage = AllocatedImages.find(pImage->imgName);
+	if (itImage != AllocatedImages.end())
+	{		
+		R_Images_DeleteImageContents(pImage);
+		AllocatedImages.erase(itImage);
+	}
+	else
+	{
+		assert(0);
+	}
+}
+#endif // _XBOX
+
+// called only at app startup, vid_restart, app-exit
+//
+void R_Images_Clear(void)
+{		
+	image_t *pImage;
+	//	int iNumImages = 
+	   				  R_Images_StartIteration();
+	while ( (pImage = R_Images_GetNextIteration()) != NULL)
+	{
+		R_Images_DeleteImageContents(pImage);
+	}
+
+#ifdef _XBOX
+	AllocatedImages->clear();
+#else
+	AllocatedImages.clear();
+#endif
+
+	giTextureBindNum = 1024;
+}
+
+
+void RE_RegisterImages_Info_f( void )
+{
+#ifndef _XBOX
+	image_t *pImage	= NULL;
+	int iImage		= 0;
+	int iTexels		= 0;
+
+	int iNumImages	= R_Images_StartIteration();
+	while ( (pImage	= R_Images_GetNextIteration()) != NULL)
+	{
+		VID_Printf( PRINT_ALL, "%d: (%4dx%4dy) \"%s\"",iImage, pImage->width, pImage->height, pImage->imgName);
+		VID_Printf( PRINT_ALL, ", levused %d",pImage->iLastLevelUsedOn);
+		VID_Printf( PRINT_ALL, "\n");
+
+		iTexels += pImage->width * pImage->height;
+		iImage++;
+	}
+	VID_Printf( PRINT_ALL, "%d Images. %d (%.2fMB) texels total, (not including mipmaps)\n",iNumImages, iTexels, (float)iTexels / 1024.0f / 1024.0f);
+	VID_Printf( PRINT_DEVELOPER, "RE_RegisterMedia_GetLevel(): %d",RE_RegisterMedia_GetLevel());
+#endif // _XBOX
+}
+
+
+// implement this if you need to, do a find for the caller. I don't need it though, so far.
+//
+//void		RE_RegisterImages_LevelLoadBegin(const char *psMapName);
+
+
+// currently, this just goes through all the images and dumps any not referenced on this level...
+//
+#ifdef _XBOX
+qboolean RE_RegisterImages_LevelLoadEnd(void)
+{
+	qboolean bEraseOccured = qfalse;
+	for (AllocatedImages_t::iterator itImage = AllocatedImages->begin(); itImage != AllocatedImages->end(); bEraseOccured?itImage:++itImage)
+	{			
+		bEraseOccured = qfalse;
+
+		image_t *pImage = (*itImage).second;
+
+		// don't un-register system shaders (*fog, *dlight, *white, *default), but DO de-register lightmaps ("$<mapname>/lightmap%d")
+		if (!pImage->isSystem)
+		{
+			// image used on this level?
+			//
+			if ( pImage->iLastLevelUsedOn != RE_RegisterMedia_GetLevel() )
+			{	// nope, so dump it...
+				//VID_Printf( PRINT_DEVELOPER, "Dumping image \"%s\"\n",pImage->imgName);
+				R_Images_DeleteImageContents(pImage);
+				itImage = AllocatedImages->erase(itImage);
+				bEraseOccured = qtrue;
+			}
+		}
+	}
+
+	GL_ResetBinds();
+
+	return bEraseOccured;
+}
+
+#else // _XBOX
+qboolean RE_RegisterImages_LevelLoadEnd(void)
+{
+	//VID_Printf( PRINT_DEVELOPER, "RE_RegisterImages_LevelLoadEnd():\n");
+
+	qboolean bEraseOccured = qfalse;
+	for (AllocatedImages_t::iterator itImage = AllocatedImages.begin(); itImage != AllocatedImages.end(); bEraseOccured?itImage:++itImage)
+	{			
+		bEraseOccured = qfalse;
+
+		image_t *pImage = (*itImage).second;
+
+		// don't un-register system shaders (*fog, *dlight, *white, *default), but DO de-register lightmaps ("$<mapname>/lightmap%d")
+		if (pImage->imgName[0] != '*')
+		{
+			// image used on this level?
+			//
+			if ( pImage->iLastLevelUsedOn != RE_RegisterMedia_GetLevel() )
+			{	// nope, so dump it...
+				//VID_Printf( PRINT_DEVELOPER, "Dumping image \"%s\"\n",pImage->imgName);
+				R_Images_DeleteImageContents(pImage);
+				itImage = AllocatedImages.erase(itImage);
+				bEraseOccured = qtrue;
+			}
+		}
+	}
+
+	//VID_Printf( PRINT_DEVELOPER, "RE_RegisterImages_LevelLoadEnd(): Ok\n");	
+
+	GL_ResetBinds();
+
+	return bEraseOccured;
+}
+#endif // _XBOX
+
+
+
+// returns image_t struct if we already have this, else NULL. No disk-open performed 
+//	(important for creating default images).
+//
+// This is called by both R_FindImageFile and anything that creates default images...
+//
+#ifdef _XBOX
+static image_t *R_FindImageFile_NoLoad(const char *name, int mipcount, qboolean allowPicmip, int glWrapClampMode )
+{	
+	if (!name) {
+		return NULL;
+	}
+
+	char *pName = GenerateImageMappingName(name);
+
+	//
+	// see if the image is already loaded
+	//
+	int code = crc32(0, (const Bytef *)pName, strlen(pName));
+	AllocatedImages_t::iterator itAllocatedImage = AllocatedImages->find(code);
+	if (itAllocatedImage != AllocatedImages->end())
+	{	
+		image_t *pImage = (*itAllocatedImage).second;
+
+		// the white image can be used with any set of parms, but other mismatches are errors...
+		//
+		if ( strcmp( pName, "*white" ) ) {
+			if ( !!pImage->mipcount != !!mipcount ) {
+				VID_Printf( PRINT_WARNING, "WARNING: reused image %s with mixed mipmap parm\n", pName );
+			}
+			if ( pImage->allowPicmip != !!allowPicmip ) {
+				VID_Printf( PRINT_WARNING, "WARNING: reused image %s with mixed allowPicmip parm\n", pName );
+			}
+		}
+
+		pImage->iLastLevelUsedOn = RE_RegisterMedia_GetLevel();
+			  
+		return pImage;
+	}
+
+	return NULL;
+}
+
+#else // _XBOX
+
+static image_t *R_FindImageFile_NoLoad(const char *name, qboolean mipmap, qboolean allowPicmip, qboolean allowTC, int glWrapClampMode )
+{	
+	if (!name) {
+		return NULL;
+	}
+
+	char *pName = GenerateImageMappingName(name);
+
+	//
+	// see if the image is already loaded
+	//
+	AllocatedImages_t::iterator itAllocatedImage = AllocatedImages.find(pName);
+	if (itAllocatedImage != AllocatedImages.end())
+	{	
+		image_t *pImage = (*itAllocatedImage).second;
+
+		// the white image can be used with any set of parms, but other mismatches are errors...
+		//
+		if ( strcmp( pName, "*white" ) ) {
+			if ( pImage->mipmap != !!mipmap ) {
+				VID_Printf( PRINT_WARNING, "WARNING: reused image %s with mixed mipmap parm\n", pName );
+			}
+			if ( pImage->allowPicmip != !!allowPicmip ) {
+				VID_Printf( PRINT_WARNING, "WARNING: reused image %s with mixed allowPicmip parm\n", pName );
+			}
+			if ( pImage->wrapClampMode != glWrapClampMode ) {
+				VID_Printf( PRINT_WARNING, "WARNING: reused image %s with mixed glWrapClampMode parm\n", pName );
+			}
+		}
+			  
+		pImage->iLastLevelUsedOn = RE_RegisterMedia_GetLevel();
+
+		return pImage;
+	}
+
+	return NULL;
+}
+#endif // _XBOX
+
+
+
+
+/*
+================
+R_CreateImage
+
+This is the only way any image_t are created
+================
+*/
+#ifdef _XBOX
+image_t *R_CreateImage( const char *name, const byte *pic, int width, int height, 
+					   GLenum format, int mipcount, qboolean allowPicmip, 
+					   int glWrapClampMode )
+{
+	image_t		*image;
+	qboolean	isLightmap = qfalse;
+
+	if (strlen(name) >= MAX_QPATH ) {
+		Com_Error (ERR_DROP, "R_CreateImage: \"%s\" is too long\n", name);
+	}
+
+	if(glConfig.clampToEdgeAvailable && glWrapClampMode == GL_CLAMP) {
+		glWrapClampMode = GL_CLAMP_TO_EDGE;
+	}
+
+	if (name[0] == '$')
+	{
+		isLightmap = qtrue;
+	}
+
+	if ( (width&(width-1)) || (height&(height-1)) )
+	{
+		Com_Error( ERR_FATAL, "R_CreateImage: %s dimensions (%i x %i) not power of 2!\n",name,width,height);
+	}
+
+	image = R_FindImageFile_NoLoad(name, mipcount, allowPicmip, glWrapClampMode );
+	if (image) {
+		return image;
+	}
+
+	image = (image_t*) Z_Malloc( sizeof( image_t ), TAG_IMAGE_T, qtrue );
+
+//	image->imgfileSize=0;
+	
+	qglGenTextures(1, (GLuint*)&image->texnum);
+
+	image->iLastLevelUsedOn = RE_RegisterMedia_GetLevel();
+
+	image->mipcount = mipcount;
+	image->allowPicmip = allowPicmip;
+
+	image->imgCode = crc32(0, (const Bytef *)name, strlen(name));
+
+	image->width = width;
+	image->height = height;
+
+	image->isSystem = (name[0] == '*');
+	image->isLightmap = isLightmap;
+
+	GL_SelectTexture( 0 );
+
+	GL_Bind(image);
+
+	Upload32( (unsigned *)pic,	image->width, image->height, 
+								format,
+								image->mipcount,
+								allowPicmip, 
+								isLightmap, 
+								&image->internalFormat );
+
+	qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, glWrapClampMode );
+	qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, glWrapClampMode );
+
+	qglBindTexture( GL_TEXTURE_2D, 0 );	//jfm: i don't know why this is here, but it breaks lightmaps when there's only 1
+	glState.currenttextures[glState.currenttmu] = 0;	//mark it not bound
+
+	const char* psNewName = GenerateImageMappingName(name);
+	image->imgCode = crc32(0, (const Bytef *)psNewName, strlen(psNewName));
+
+	(*AllocatedImages)[ image->imgCode ] = image;
+
+	return image;
+}
+
+#else // _XBOX
+
+image_t *R_CreateImage( const char *name, const byte *pic, int width, int height, 
+					   GLenum format, qboolean mipmap, qboolean allowPicmip, qboolean allowTC, int glWrapClampMode,int fileSize)
+{
+	image_t		*image;
+	qboolean	isLightmap = qfalse;
+
+	if (strlen(name) >= MAX_QPATH ) {
+		Com_Error (ERR_DROP, "R_CreateImage: \"%s\" is too long\n", name);
+	}
+
+	if(glConfig.clampToEdgeAvailable && glWrapClampMode == GL_CLAMP) {
+		glWrapClampMode = GL_CLAMP_TO_EDGE;
+	}
+
+	if (name[0] == '$')
+	{
+		isLightmap = qtrue;
+	}
+
+	if ( (width&(width-1)) || (height&(height-1)) )
+	{
+		Com_Error( ERR_FATAL, "R_CreateImage: %s dimensions (%i x %i) not power of 2!\n",name,width,height);
+	}
+
+	image = R_FindImageFile_NoLoad(name, mipmap, allowPicmip, allowTC, glWrapClampMode );
+	if (image) {
+		return image;
+	}
+
+	image = (image_t*) Z_Malloc( sizeof( image_t ), TAG_IMAGE_T, qtrue );
+
+	//image->imgfileSize=fileSize;	
+	
+	image->texnum = 1024 + giTextureBindNum++;	// ++ is of course staggeringly important...
+
+	// record which map it was used on...
+	//
+	image->iLastLevelUsedOn = RE_RegisterMedia_GetLevel();
+
+	image->mipmap = !!mipmap;
+	image->allowPicmip = !!allowPicmip;
+
+	Q_strncpyz(image->imgName, name, sizeof(image->imgName));
+
+	image->width = width;
+	image->height = height;
+	image->wrapClampMode = glWrapClampMode;
+
+	if ( qglActiveTextureARB ) {
+		GL_SelectTexture( 0 );
+	}
+
+	GL_Bind(image);
+
+	Upload32( (unsigned *)pic,	format,
+								image->mipmap,
+								allowPicmip, 
+								isLightmap, 
+								allowTC,
+								&image->internalFormat,
+								&image->width,
+								&image->height );
+
+	qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, glWrapClampMode );
+	qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, glWrapClampMode );
+
+	qglBindTexture( GL_TEXTURE_2D, 0 );	//jfm: i don't know why this is here, but it breaks lightmaps when there's only 1
+	glState.currenttextures[glState.currenttmu] = 0;	//mark it not bound
+
+	LPCSTR psNewName = GenerateImageMappingName(name);
+	Q_strncpyz(image->imgName, psNewName, sizeof(image->imgName));
+	AllocatedImages[ image->imgName ] = image;
+
+	return image;
+}
+#endif // _XBOX
+
+void R_CreateAutomapImage( const char *name, const byte *pic, int width, int height, 
+					   qboolean mipmap, qboolean allowPicmip, qboolean allowTC, int glWrapClampMode ) 
+{
+#ifdef _XBOX
+	R_CreateImage(name, pic, width, height, GL_RGBA, mipmap, allowPicmip, glWrapClampMode);
+#else
+	R_CreateImage(name, pic, width, height, GL_RGBA, mipmap, allowPicmip, allowTC, glWrapClampMode);
+#endif
+}
+
+/*
+=========================================================
+
+TARGA LOADING
+
+=========================================================
+*/
+
+/*
+Ghoul2 Insert Start
+*/
+
+bool LoadTGAPalletteImage ( const char *name, byte **pic, int *width, int *height)
+{
+	int		columns, rows, numPixels;
+	byte	*buf_p;
+	byte	*buffer;
+	TargaHeader	targa_header;
+	byte	*dataStart;
+
+	*pic = NULL;
+
+	//
+	// load the file
+	//
+	FS_ReadFile ( ( char * ) name, (void **)&buffer);
+	if (!buffer) {
+		return false;
+	}
+
+	buf_p = buffer;
+
+	targa_header.id_length = *buf_p++;
+	targa_header.colormap_type = *buf_p++;
+	targa_header.image_type = *buf_p++;
+	
+	targa_header.colormap_index = LittleShort ( *(short *)buf_p );
+	buf_p += 2;
+	targa_header.colormap_length = LittleShort ( *(short *)buf_p );
+	buf_p += 2;
+	targa_header.colormap_size = *buf_p++;
+	targa_header.x_origin = LittleShort ( *(short *)buf_p );
+	buf_p += 2;
+	targa_header.y_origin = LittleShort ( *(short *)buf_p );
+	buf_p += 2;
+	targa_header.width = LittleShort ( *(short *)buf_p );
+	buf_p += 2;
+	targa_header.height = LittleShort ( *(short *)buf_p );
+	buf_p += 2;
+	targa_header.pixel_size = *buf_p++;
+	targa_header.attributes = *buf_p++;
+
+	if (targa_header.image_type!=1 )
+	{
+		Com_Error (ERR_DROP, "LoadTGAPalletteImage: Only type 1 (uncompressed pallettised) TGA images supported\n");
+	}
+
+	if ( targa_header.colormap_type == 0 )
+	{
+		Com_Error( ERR_DROP, "LoadTGAPalletteImage: colormaps ONLY supported\n" );
+	}
+
+	columns = targa_header.width;
+	rows = targa_header.height;
+	numPixels = columns * rows;
+
+	if (width)
+		*width = columns;
+	if (height)
+		*height = rows;
+
+	*pic = (unsigned char *) Z_Malloc (numPixels, TAG_TEMP_TGA, qfalse);
+	if (targa_header.id_length != 0)
+	{
+		buf_p += targa_header.id_length;  // skip TARGA image comment
+	}
+	dataStart = buf_p + (targa_header.colormap_length * (targa_header.colormap_size / 4));
+	memcpy(*pic, dataStart, numPixels);
+	FS_FreeFile (buffer);
+
+	return true;
+}
+
+/*
+Ghoul2 Insert End
+*/
+
+
+// My TGA loader...
+//
+//---------------------------------------------------
+#pragma pack(push,1)
+typedef struct
+{
+	byte	byIDFieldLength;	// must be 0
+	byte	byColourmapType;	// 0 = truecolour, 1 = paletted, else bad
+	byte	byImageType;		// 1 = colour mapped (palette), uncompressed, 2 = truecolour, uncompressed, else bad
+	word	w1stColourMapEntry;	// must be 0
+	word	wColourMapLength;	// 256 for 8-bit palettes, else 0 for true-colour
+	byte	byColourMapEntrySize; // 24 for 8-bit palettes, else 0 for true-colour
+	word	wImageXOrigin;		// ignored
+	word	wImageYOrigin;		// ignored
+	word	wImageWidth;		// in pixels
+	word	wImageHeight;		// in pixels
+	byte	byImagePlanes;		// bits per pixel	(8 for paletted, else 24 for true-colour)
+	byte	byScanLineOrder;	// Image descriptor bytes
+								// bits 0-3 = # attr bits (alpha chan)
+								// bits 4-5 = pixel order/dir
+								// bits 6-7 scan line interleave (00b=none,01b=2way interleave,10b=4way)
+} TGAHeader_t;
+#pragma pack(pop)
+
+
+// *pic == pic, else NULL for failed.
+//
+//  returns false if found but had a format error, else true for either OK or not-found (there's a reason for this)
+//
+
+int LoadTGA ( const char *name, byte **pic, int *width, int *height)
+{
+	char sErrorString[1024];
+	bool bFormatErrors = false;
+
+	// these don't need to be declared or initialised until later, but the compiler whines that 'goto' skips them.
+	//
+	byte *pRGBA = NULL;	
+	byte *pOut	= NULL;
+	byte *pIn	= NULL;
+
+
+	*pic = NULL;
+
+#define TGA_FORMAT_ERROR(blah) {sprintf(sErrorString,blah); bFormatErrors = true; goto TGADone;}
+//#define TGA_FORMAT_ERROR(blah) Com_Error( ERR_DROP, blah );
+
+	//
+	// load the file
+	//
+	byte *pTempLoadedBuffer = 0;
+	const int filelen = FS_ReadFile ( ( char * ) name, (void **)&pTempLoadedBuffer);
+	if (!pTempLoadedBuffer) {
+		return 0;
+	}
+
+	TGAHeader_t *pHeader = (TGAHeader_t *) pTempLoadedBuffer;
+
+	if (pHeader->byColourmapType!=0)
+	{	
+		TGA_FORMAT_ERROR("LoadTGA: colourmaps not supported\n" );		
+	}
+
+	if (pHeader->byImageType != 2 && pHeader->byImageType != 3 && pHeader->byImageType != 10)
+	{
+		TGA_FORMAT_ERROR("LoadTGA: Only type 2 (RGB), 3 (gray), and 10 (RLE-RGB) images supported\n");		
+	}
+		
+	if (pHeader->w1stColourMapEntry != 0)
+	{
+		TGA_FORMAT_ERROR("LoadTGA: colourmaps not supported\n" );		
+	}
+
+	if (pHeader->wColourMapLength !=0 && pHeader->wColourMapLength != 256)
+	{
+		TGA_FORMAT_ERROR("LoadTGA: ColourMapLength must be either 0 or 256\n" );
+	}
+
+	if (pHeader->byColourMapEntrySize != 0 && pHeader->byColourMapEntrySize != 24)
+	{
+		TGA_FORMAT_ERROR("LoadTGA: ColourMapEntrySize must be either 0 or 24\n" );
+	}
+
+	if ( ( pHeader->byImagePlanes != 24 && pHeader->byImagePlanes != 32) && (pHeader->byImagePlanes != 8 && pHeader->byImageType != 3))
+	{
+		TGA_FORMAT_ERROR("LoadTGA: Only type 2 (RGB), 3 (gray), and 10 (RGB) TGA images supported\n");
+	}
+
+	if ((pHeader->byScanLineOrder&0x30)!=0x00 &&
+		(pHeader->byScanLineOrder&0x30)!=0x10 &&
+		(pHeader->byScanLineOrder&0x30)!=0x20 &&
+		(pHeader->byScanLineOrder&0x30)!=0x30
+		)
+	{
+		TGA_FORMAT_ERROR("LoadTGA: ScanLineOrder must be either 0x00,0x10,0x20, or 0x30\n");		
+	}
+
+
+
+	// these last checks are so i can use ID's RLE-code. I don't dare fiddle with it or it'll probably break...
+	//
+	if ( pHeader->byImageType == 10)
+	{
+		if ((pHeader->byScanLineOrder & 0x30) != 0x00)
+		{
+			TGA_FORMAT_ERROR("LoadTGA: RLE-RGB Images (type 10) must be in bottom-to-top format\n");
+		}
+		if (pHeader->byImagePlanes != 24 && pHeader->byImagePlanes != 32)	// probably won't happen, but avoids compressed greyscales?
+		{
+			TGA_FORMAT_ERROR("LoadTGA: RLE-RGB Images (type 10) must be 24 or 32 bit\n");
+		}
+	}
+
+	// now read the actual bitmap in...
+	//
+	// Image descriptor bytes
+	// bits 0-3 = # attr bits (alpha chan)
+	// bits 4-5 = pixel order/dir
+	// bits 6-7 scan line interleave (00b=none,01b=2way interleave,10b=4way)
+	//
+	int iYStart,iXStart,iYStep,iXStep;
+
+	switch(pHeader->byScanLineOrder & 0x30)		
+	{
+		default:	// default case stops the compiler complaining about using uninitialised vars
+		case 0x00:					//	left to right, bottom to top
+
+			iXStart = 0;
+			iXStep  = 1;
+
+			iYStart = pHeader->wImageHeight-1;
+			iYStep  = -1;
+
+			break;
+
+		case 0x10:					//  right to left, bottom to top
+
+			iXStart = pHeader->wImageWidth-1;
+			iXStep  = -1;
+
+			iYStart = pHeader->wImageHeight-1;
+			iYStep	= -1;
+
+			break;
+
+		case 0x20:					//  left to right, top to bottom
+
+			iXStart = 0;
+			iXStep  = 1;
+
+			iYStart = 0;
+			iYStep  = 1;
+
+			break;
+
+		case 0x30:					//  right to left, top to bottom
+
+			iXStart = pHeader->wImageWidth-1;
+			iXStep  = -1;
+
+			iYStart = 0;
+			iYStep  = 1;
+
+			break;
+	}
+
+	// feed back the results...
+	//
+	if (width)
+		*width = pHeader->wImageWidth;
+	if (height)
+		*height = pHeader->wImageHeight;
+
+	pRGBA	= (byte *) Z_Malloc (pHeader->wImageWidth * pHeader->wImageHeight * 4, TAG_TEMP_TGA, qfalse);
+	*pic	= pRGBA;
+	pOut	= pRGBA;
+	pIn		= pTempLoadedBuffer + sizeof(*pHeader);
+
+	// I don't know if this ID-thing here is right, since comments that I've seen are at the end of the file, 
+	//	with a zero in this field. However, may as well...
+	//
+	if (pHeader->byIDFieldLength != 0)
+		pIn += pHeader->byIDFieldLength;	// skip TARGA image comment
+
+	byte red,green,blue,alpha;
+
+	if ( pHeader->byImageType == 2 || pHeader->byImageType == 3 )	// RGB or greyscale
+	{
+		for (int y=iYStart, iYCount=0; iYCount<pHeader->wImageHeight; y+=iYStep, iYCount++)
+		{
+			pOut = pRGBA + y * pHeader->wImageWidth *4;			
+			for (int x=iXStart, iXCount=0; iXCount<pHeader->wImageWidth; x+=iXStep, iXCount++)
+			{
+				switch (pHeader->byImagePlanes)
+				{
+					case 8:
+						blue	= *pIn++;
+						green	= blue;
+						red		= blue;
+						*pOut++ = red;
+						*pOut++ = green;
+						*pOut++ = blue;
+						*pOut++ = 255;
+						break;
+
+					case 24:
+						blue	= *pIn++;
+						green	= *pIn++;
+						red		= *pIn++;
+						*pOut++ = red;
+						*pOut++ = green;
+						*pOut++ = blue;
+						*pOut++ = 255;
+						break;
+
+					case 32:
+						blue	= *pIn++;
+						green	= *pIn++;
+						red		= *pIn++;
+						alpha	= *pIn++;
+						*pOut++ = red;
+						*pOut++ = green;
+						*pOut++ = blue;
+						*pOut++ = alpha;
+						break;
+					
+					default:
+						assert(0);	// if we ever hit this, someone deleted a header check higher up
+						TGA_FORMAT_ERROR("LoadTGA: Image can only have 8, 24 or 32 planes for RGB/greyscale\n");						
+						break;
+				}
+			}		
+		}
+	}
+	else 
+	if (pHeader->byImageType == 10)   // RLE-RGB
+	{
+		// I've no idea if this stuff works, I normally reject RLE targas, but this is from ID's code
+		//	so maybe I should try and support it...
+		//
+		byte packetHeader, packetSize, j;
+
+		for (int y = pHeader->wImageHeight-1; y >= 0; y--)
+		{
+			pOut = pRGBA + y * pHeader->wImageWidth *4;
+			for (int x=0; x<pHeader->wImageWidth;)
+			{
+				packetHeader = *pIn++;
+				packetSize   = 1 + (packetHeader & 0x7f);
+				if (packetHeader & 0x80)         // run-length packet
+				{
+					switch (pHeader->byImagePlanes) 
+					{
+						case 24:
+
+							blue	= *pIn++;
+							green	= *pIn++;
+							red		= *pIn++;
+							alpha	= 255;
+							break;
+
+						case 32:
+							
+							blue	= *pIn++;
+							green	= *pIn++;
+							red		= *pIn++;
+							alpha	= *pIn++;
+							break;
+
+						default:
+							assert(0);	// if we ever hit this, someone deleted a header check higher up
+							TGA_FORMAT_ERROR("LoadTGA: RLE-RGB can only have 24 or 32 planes\n");
+							break;
+					}
+	
+					for (j=0; j<packetSize; j++) 
+					{
+						*pOut++	= red;
+						*pOut++	= green;
+						*pOut++	= blue;
+						*pOut++	= alpha;
+						x++;
+						if (x == pHeader->wImageWidth)  // run spans across rows
+						{
+							x = 0;
+							if (y > 0)
+								y--;
+							else
+								goto breakOut;
+							pOut = pRGBA + y * pHeader->wImageWidth * 4;
+						}
+					}
+				}
+				else 
+				{	// non run-length packet
+
+					for (j=0; j<packetSize; j++) 
+					{
+						switch (pHeader->byImagePlanes) 
+						{
+							case 24:
+
+								blue	= *pIn++;
+								green	= *pIn++;
+								red		= *pIn++;
+								*pOut++ = red;
+								*pOut++ = green;
+								*pOut++ = blue;
+								*pOut++ = 255;
+								break;
+
+							case 32:
+								blue	= *pIn++;
+								green	= *pIn++;
+								red		= *pIn++;
+								alpha	= *pIn++;
+								*pOut++ = red;
+								*pOut++ = green;
+								*pOut++ = blue;
+								*pOut++ = alpha;
+								break;
+
+							default:
+								assert(0);	// if we ever hit this, someone deleted a header check higher up
+								TGA_FORMAT_ERROR("LoadTGA: RLE-RGB can only have 24 or 32 planes\n");
+								break;
+						}
+						x++;
+						if (x == pHeader->wImageWidth)  // pixel packet run spans across rows
+						{
+							x = 0;
+							if (y > 0)
+								y--;
+							else
+								goto breakOut;
+							pOut = pRGBA + y * pHeader->wImageWidth * 4;
+						}
+					}
+				}
+			}
+			breakOut:;
+		}
+	}
+
+TGADone:
+
+	FS_FreeFile (pTempLoadedBuffer);
+
+	if (bFormatErrors)
+	{
+		Com_Error( ERR_DROP, "%s( File: \"%s\" )\n",sErrorString,name);
+	}
+	return filelen;
+}
+
+/*
+=========================================================
+
+DDS LOADING
+
+=========================================================
+*/
+
+#ifdef _XBOX
+
+void LoadDDS ( const char *name, byte **pic, int *width, int *height, int *mipcount, GLenum *format )
+{
+	fileHandle_t h;
+	int len = FS_FOpenFileRead( name, &h, qfalse );
+	if ( h == 0 )
+	{
+		return;
+	}
+	
+	*pic = (byte*)Z_Malloc( len, TAG_TEMP_WORKSPACE, qfalse , 32);
+	FS_Read( *pic, len, h );
+	FS_FCloseFile( h );
+
+	DWORD dds = MAKEFOURCC('D', 'D', 'S', ' ');
+	if (*(DWORD*)(*pic) != dds)
+	{
+		FS_FreeFile (*pic);
+		*pic = NULL;
+		return;
+	}
+	
+	DDS_HEADER *desc = (DDS_HEADER *)(*pic + sizeof(DWORD));
+	DWORD dxt1 = MAKEFOURCC('D', 'X', 'T', '1');
+	DWORD dxt5 = MAKEFOURCC('D', 'X', 'T', '5');
+	
+	if (desc->ddspf.dwFourCC == dxt1)
+	{
+		*format = GL_DDS1_EXT;
+	}
+	else if (desc->ddspf.dwFourCC == dxt5)
+	{
+		*format = GL_DDS5_EXT;
+	}
+	else if (desc->ddspf.dwRGBBitCount == 16)
+	{
+		*format = GL_DDS_RGB16_EXT;
+	}
+	else if (desc->ddspf.dwRGBBitCount == 32)
+	{
+		*format = GL_DDS_RGBA32_EXT;
+	}
+	else
+	{
+		FS_FreeFile (*pic);
+		*pic = NULL;
+		return;
+	}
+
+	*width = desc->dwWidth;
+	*height = desc->dwHeight;
+	*mipcount = desc->dwMipMapCount;
+}
+
+#endif
+
+//===================================================================
+
+/*
+=================
+R_LoadImage
+
+Loads any of the supported image types into a cannonical
+32 bit format.
+=================
+*/
+#ifdef _XBOX
+void R_LoadImage( const char *shortname, byte **pic, int *width, int *height, int *mipcount, GLenum *format ) {
+#else
+int R_LoadImage( const char *shortname, byte **pic, int *width, int *height, GLenum *format ) {
+#endif
+	int		bytedepth;
+	char	name[MAX_QPATH];
+
+	*pic = NULL;
+	*width = 0;
+	*height = 0;
+
+	//handle external LMs
+	if (shortname[0] == '$') {
+		Q_strncpyz( name, shortname+1, sizeof( name ) );
+	} else {
+		Q_strncpyz( name, shortname, sizeof( name ) );
+	}
+#ifdef _XBOX
+	*format = GL_RGBA;
+	*mipcount = 1;
+
+	COM_StripExtension(name,name);
+	COM_DefaultExtension(name, sizeof(name), ".tga");
+	LoadTGA( name, pic, width, height );
+
+	if (*pic)
+	{
+		int j = (*width) * (*height) * 4;
+		byte *buf = *pic;
+		byte swap;
+		for (int i = 0 ; i < j ; i+=4 ) {
+			swap = buf[i];
+			buf[i] = buf[i+2];
+			buf[i+2] = swap;
+		}
+		return;
+	}
+
+	/*	// Removing PNG support	2003/05/19
+	COM_StripExtension(name,name);
+	COM_DefaultExtension(name, sizeof(name), ".png");	
+	
+	//No .tga existed, try .png
+	LoadPNG32( name, pic, width, height, &bytedepth );
+	if (*pic)
+	{
+		return;
+	}
+	*/
+
+	// No .png either, fall back to .dds
+	COM_StripExtension(name,name);
+	COM_DefaultExtension(name, sizeof(name), ".dds");
+	LoadDDS( name, pic, width, height, mipcount, format );
+	return;
+
+#else
+	*format = GL_RGBA;
+	COM_StripExtension(name,name);
+	COM_DefaultExtension(name, sizeof(name), ".jpg");
+
+	int fileSize;
+	//First try .jpg
+	fileSize=LoadJPG( name, pic, width, height );
+	if (*pic)
+	{
+		return fileSize;
+	}
+
+	COM_StripExtension(name,name);
+	COM_DefaultExtension(name, sizeof(name), ".png");	
+	
+	//No .jpg existed, try .png
+	fileSize=LoadPNG32( name, pic, width, height, &bytedepth );
+	if (*pic)
+	{
+		return fileSize;
+	}
+
+	COM_StripExtension(name,name);
+	COM_DefaultExtension(name, sizeof(name), ".tga");
+
+	//No .jpg existed and no .png existed, try .tga as a last resort.
+	fileSize=LoadTGA( name, pic, width, height );
+	return fileSize;
+#endif
+}
+
+
+#ifndef _XBOX	// Only used for terrain
+void R_LoadDataImage( const char *name, byte **pic, int *width, int *height)
+{
+	int		len;
+	char	work[MAX_QPATH];
+
+	*pic = NULL;
+	*width = 0;
+	*height = 0;
+
+	len = strlen(name);
+	if(len >= MAX_QPATH)
+	{
+		return;
+	}
+	if (len < 5)
+	{
+		return;
+	}
+//	MD_PushTag(TAG_DATA_IMAGE_LOAD);
+
+	strcpy(work, name);
+
+	COM_DefaultExtension( work, sizeof( work ), ".png" );
+	LoadPNG8( work, pic, width, height );
+	
+#ifndef _XBOX
+	if (!pic || !*pic)
+	{ //png load failed, try jpeg
+		strcpy(work, name);
+		COM_DefaultExtension( work, sizeof( work ), ".jpg" );
+		LoadJPG( work, pic, width, height );
+	}
+#endif
+
+	if (!pic || !*pic)
+	{ //both png and jpeg failed, try targa
+		strcpy(work, name);
+		COM_DefaultExtension( work, sizeof( work ), ".tga" );
+		LoadTGA( work, pic, width, height );
+	}
+
+	if(*pic)
+	{
+//		MD_PopTag();
+		return;
+	}
+	// Dataimage loading failed
+	Com_Printf("Couldn't read %s -- dataimage load failed\n", name);
+//	MD_PopTag();
+}
+#endif
+
+void R_InvertImage(byte *data, int width, int height, int depth)
+{
+	byte	*newData;
+	byte	*oldData;
+	byte	*saveData;
+	int		y, stride;
+
+	stride = width * depth;
+
+	oldData = data + ((height - 1) * stride);
+	newData = (byte *)Z_Malloc(height * stride, TAG_TEMP_WORKSPACE, qfalse );
+	saveData = newData;
+
+	for(y = 0; y < height; y++)
+	{
+		memcpy(newData, oldData, stride);
+		newData += stride;
+		oldData -= stride;
+	}
+	memcpy(data, saveData, height * stride);
+	Z_Free(saveData);
+}
+
+// Lanczos3 image resampling. Better than bicubic, based on sin(x)/x algorithm
+
+#define	LANCZOS3	(3.0f)
+#define M_PI_OVER_3	(M_PI / 3.0f)
+
+typedef struct
+{
+	int		pixel;
+	float	weight;
+} contrib_t;
+
+typedef struct
+{
+	int			n;		// number of contributors
+	contrib_t	*p;		// pointer to list of contributions
+} contrib_list_t;
+
+// sin(x)/x * sin(x/3)/(x/3)
+
+float Lanczos3(float t)
+{
+	if(!t)
+	{
+		return(1.0f);
+	}
+	t = (float)fabs(t);
+	if(t < 3.0f)
+	{
+		return(sinf(t * M_PI) * sinf(t * M_PI_OVER_3) / (t * M_PI * t * M_PI_OVER_3));
+	}
+	return(0.0f);
+}
+
+void R_Resample(byte *source, int swidth, int sheight, byte *dest, int dwidth, int dheight, int components)
+{
+	int				i, j, k, l, count, left, right, num;
+	int				pixel;
+	byte			*raster;
+	float			center, weight, scale, width, height;
+	contrib_list_t	*contributors;
+	const memtag_t	usedTag = TAG_TEMP_WORKSPACE;
+
+	byte *work = (byte *)Z_Malloc(dwidth * sheight * components, usedTag, qfalse);
+
+	// Pre calculate filter contributions for rows
+	contributors = (contrib_list_t *)Z_Malloc(sizeof(contrib_list_t) * dwidth, usedTag, qfalse);
+
+	float xscale = (float)dwidth / (float)swidth;
+
+	if(xscale < 1.0f)
+	{
+		width = ceilf(LANCZOS3 / xscale);
+		scale = xscale;
+	}
+	else
+	{
+		width = LANCZOS3;
+		scale = 1.0f;
+	}
+	num = ((int)width * 2) + 1;
+
+	for(i = 0; i < dwidth; i++)
+	{
+		contributors[i].n = 0;
+		contributors[i].p = (contrib_t *)Z_Malloc(num * sizeof(contrib_t), usedTag, qfalse);
+
+		center = (float)i / xscale;
+		left = (int)ceilf(center - width);
+		right = (int)floorf(center + width);
+
+		for(j = left; j <= right; j++)
+		{
+			weight = Lanczos3((center - (float)j) * scale) * scale;
+			if(j < 0)
+			{
+				pixel = -j;
+			}
+			else if(j >= swidth)
+			{
+				pixel = (swidth - j) + swidth - 1;
+			}
+			else
+			{
+				pixel = j;
+			}
+			count = contributors[i].n++;
+			contributors[i].p[count].pixel = pixel;
+			contributors[i].p[count].weight = weight;
+		}
+	}
+	// Apply filters to zoom horizontally from source to work
+	for(k = 0; k < sheight; k++)
+	{
+		raster = source + (k * swidth * components);
+		for(i = 0; i < dwidth; i++)
+		{
+			for(l = 0; l < components; l++)
+			{
+				weight = 0.0f;
+				for(j = 0; j < contributors[i].n; j++)
+				{
+					weight += raster[(contributors[i].p[j].pixel * components) + l] * contributors[i].p[j].weight;
+				}
+				pixel = (byte)Com_Clamp(0.0f, 255.0f, weight);
+				work[(k * dwidth * components) + (i * components) + l] = pixel;
+			}
+		}
+	}
+	// Clean up
+	for(i = 0; i < dwidth; i++)
+	{
+		Z_Free(contributors[i].p);
+	}
+	Z_Free(contributors);
+
+	// Columns
+	contributors = (contrib_list_t *)Z_Malloc(sizeof(contrib_list_t) * dheight, usedTag, qfalse);
+
+	float yscale = (float)dheight / (float)sheight;
+	if(yscale < 1.0f)
+	{
+		height = ceilf(LANCZOS3 / yscale);
+		scale = yscale;
+	}
+	else
+	{
+		height = LANCZOS3;
+		scale = 1.0f;
+	}
+	num = ((int)height * 2) + 1;
+
+	for(i = 0; i < dheight; i++)
+	{
+		contributors[i].n = 0;
+		contributors[i].p = (contrib_t *)Z_Malloc(num * sizeof(contrib_t), usedTag, qfalse);
+
+		center = (float)i / yscale;
+		left = (int)ceilf(center - height);
+		right = (int)floorf(center + height);
+
+		for(j = left; j <= right; j++)
+		{
+			weight = Lanczos3((center - (float)j) * scale) * scale;
+			if(j < 0)
+			{
+				pixel = -j;
+			}
+			else if(j >= sheight)
+			{
+				pixel = (sheight - j) + sheight - 1;
+			}
+			else
+			{
+				pixel = j;
+			}
+			count = contributors[i].n++;
+			contributors[i].p[count].pixel = pixel;
+			contributors[i].p[count].weight = weight;
+		}
+	}
+	// Apply filter to columns
+	for(k = 0; k < dwidth; k++)
+	{
+		for(l = 0; l < components; l++)
+		{
+			for(i = 0; i < dheight; i++)
+			{
+				weight = 0.0f;
+				for(j = 0; j < contributors[i].n; j++)
+				{
+					weight += work[(contributors[i].p[j].pixel * dwidth * components) + (k * components) + l] * contributors[i].p[j].weight;
+				}
+				pixel = (byte)Com_Clamp(0.0f, 255.0f, weight);
+				dest[(i * dwidth * components) + (k * components) + l] = pixel;
+			}
+		}
+	}
+	// Clean up
+	for(i = 0; i < dheight; i++)
+	{
+		Z_Free(contributors[i].p);
+	}
+	Z_Free(contributors);
+	Z_Free(work);
+
+//	MD_PopTag();
+}
+
+/*
+===============
+R_FindImageFile
+
+Finds or loads the given image.
+Returns NULL if it fails, not a default image.
+==============
+*/
+#ifdef _XBOX
+image_t	*R_FindImageFile( const char *name, qboolean mipmap, qboolean allowPicmip, qboolean allowTC, int glWrapClampMode ) {
+	image_t	*image;
+	int		width, height;
+	int		mipcount;
+	byte	*pic;
+	GLenum	format;
+   
+	if (!name) {
+		return NULL;
+	}
+
+	// need to do this here as well as in R_CreateImage, or R_FindImageFile_NoLoad() may complain about
+	//	different clamp parms used...
+	//
+	if(glConfig.clampToEdgeAvailable && glWrapClampMode == GL_CLAMP) {
+		glWrapClampMode = GL_CLAMP_TO_EDGE;
+	}
+
+	image = R_FindImageFile_NoLoad(name, mipmap, allowPicmip, glWrapClampMode );
+	if (image) {
+		return image;
+	}
+
+	//
+	// load the pic from disk
+	//
+	R_LoadImage( name, &pic, &width, &height, &mipcount, &format );
+	if ( !pic ) {
+        return NULL;            
+	}
+
+	image = R_CreateImage( ( char * ) name, pic, width, height, format, mipcount, allowPicmip, glWrapClampMode );
+	Z_Free( pic );
+	return image;
+}
+
+#else // _XBOX
+
+image_t	*R_FindImageFile( const char *name, qboolean mipmap, qboolean allowPicmip, qboolean allowTC, int glWrapClampMode ) {
+	image_t	*image;
+	int		width, height;
+	byte	*pic;
+	GLenum	format;
+//	long	hash;
+   
+	if (!name) {
+		return NULL;
+	}
+
+	// need to do this here as well as in R_CreateImage, or R_FindImageFile_NoLoad() may complain about
+	//	different clamp parms used...
+	//
+	if(glConfig.clampToEdgeAvailable && glWrapClampMode == GL_CLAMP) {
+		glWrapClampMode = GL_CLAMP_TO_EDGE;
+	}
+
+	image = R_FindImageFile_NoLoad(name, mipmap, allowPicmip, allowTC, glWrapClampMode );
+	if (image) {
+		return image;
+	}
+
+	//
+	// load the pic from disk
+	//
+	int fileSize=R_LoadImage( name, &pic, &width, &height, &format );
+	if ( !pic ) {
+        return NULL;            
+	}
+
+	image = R_CreateImage( ( char * ) name, pic, width, height, format, mipmap, allowPicmip, allowTC, glWrapClampMode,fileSize );
+	Z_Free( pic );
+	return image;
+}
+
+#endif // _XBOX
+
+
+// EF dlight image creation code
+/*
+================
+R_CreateDlightImage
+================
+*/
+/*
+#define	DLIGHT_SIZE	16
+static void R_CreateDlightImage( void ) {
+	int		x,y;
+	byte	data[DLIGHT_SIZE][DLIGHT_SIZE][4];
+	int		b;
+
+	// make a centered inverse-square falloff blob for dynamic lighting
+	for (x=0 ; x<DLIGHT_SIZE ; x++) {
+		for (y=0 ; y<DLIGHT_SIZE ; y++) {
+			float	d;
+
+			d = ( DLIGHT_SIZE/2 - 0.5 - x ) * ( DLIGHT_SIZE/2 - 0.5 - x ) +
+				( DLIGHT_SIZE/2 - 0.5 - y ) * ( DLIGHT_SIZE/2 - 0.5 - y );
+			b = 4000 / d;
+			if (b > 255) {
+				b = 255;
+			} else if ( b < 75 ) {
+				b = 0;
+			}
+			data[y][x][0] = 
+			data[y][x][1] = 
+			data[y][x][2] = 255;
+			data[y][x][3] = b/8;			
+		}
+	}
+	tr.dlightImage = R_CreateImage("*dlight", (byte *)data, DLIGHT_SIZE, DLIGHT_SIZE, qfalse, qfalse, GL_CLAMP );
+}
+*/
+// Holomatch dlight image creation code
+/*
+================
+R_CreateDlightImage
+================
+*/
+#define	DLIGHT_SIZE	64
+static void R_CreateDlightImage( void ) 
+{
+#ifndef _XBOX
+	int		width, height;
+	byte	*pic;
+	GLenum	format;
+
+	R_LoadImage("gfx/2d/dlight", &pic, &width, &height, &format);
+	if (pic)
+	{                                    
+		tr.dlightImage = R_CreateImage("*dlight", pic, width, height, GL_RGBA, qfalse, qfalse, qfalse, GL_CLAMP );
+		Z_Free(pic);
+	}
+	else
+	{	// if we dont get a successful load
+		int		x,y;
+		byte	data[DLIGHT_SIZE][DLIGHT_SIZE][4];
+		int		b;
+
+		// make a centered inverse-square falloff blob for dynamic lighting
+		for (x=0 ; x<DLIGHT_SIZE ; x++) {
+			for (y=0 ; y<DLIGHT_SIZE ; y++) {
+				float	d;
+
+				d = ( DLIGHT_SIZE/2 - 0.5f - x ) * ( DLIGHT_SIZE/2 - 0.5f - x ) +
+					( DLIGHT_SIZE/2 - 0.5f - y ) * ( DLIGHT_SIZE/2 - 0.5f - y );
+				b = 4000 / d;
+				if (b > 255) {
+					b = 255;
+				} else if ( b < 75 ) {
+					b = 0;
+				}
+				data[y][x][0] = 
+					data[y][x][1] = 
+					data[y][x][2] = b;
+				data[y][x][3] = 255;			
+			}
+		}
+		tr.dlightImage = R_CreateImage("*dlight", (byte *)data, DLIGHT_SIZE, DLIGHT_SIZE, GL_RGBA, qfalse, qfalse, qfalse, GL_CLAMP );
+	}
+#endif
+}
+
+/*
+=================
+R_InitFogTable
+=================
+*/
+void R_InitFogTable( void ) {
+	int		i;
+	float	d;
+	float	exp;
+	
+	exp = 0.5;
+
+	for ( i = 0 ; i < FOG_TABLE_SIZE ; i++ ) {
+		d = pow ( (float)i/(FOG_TABLE_SIZE-1), exp );
+
+		tr.fogTable[i] = d;
+	}
+}
+
+/*
+================
+R_FogFactor
+
+Returns a 0.0 to 1.0 fog density value
+This is called for each texel of the fog texture on startup
+and for each vertex of transparent shaders in fog dynamically
+================
+*/
+float	R_FogFactor( float s, float t ) {
+	float	d;
+
+	s -= 1.0/512;
+	if ( s < 0 ) {
+		return 0;
+	}
+	if ( t < 1.0/32 ) {
+		return 0;
+	}
+	if ( t < 31.0/32 ) {
+		s *= (t - 1.0/32) / (30.0/32);
+	}
+
+	// we need to leave a lot of clamp range
+	s *= 8;
+
+	if ( s > 1.0 ) {
+		s = 1.0;
+	}
+
+	d = tr.fogTable[ (int)(s * (FOG_TABLE_SIZE-1)) ];
+
+	return d;
+}
+
+/*
+================
+R_CreateFogImage
+================
+*/
+#define	FOG_S	256
+#define	FOG_T	32
+static void R_CreateFogImage( void ) {
+	int		x,y;
+	byte	*data;
+	float	g;
+	float	d;
+	float	borderColor[4];
+
+	data = (byte*) Z_Malloc( FOG_S * FOG_T * 4, TAG_TEMP_WORKSPACE, qfalse );
+
+	g = 2.0;
+
+	// S is distance, T is depth
+	for (x=0 ; x<FOG_S ; x++) {
+		for (y=0 ; y<FOG_T ; y++) {
+			d = R_FogFactor( ( x + 0.5 ) / FOG_S, ( y + 0.5 ) / FOG_T );
+
+			data[(y*FOG_S+x)*4+0] = 
+			data[(y*FOG_S+x)*4+1] = 
+			data[(y*FOG_S+x)*4+2] = 255;
+			data[(y*FOG_S+x)*4+3] = 255*d;
+		}
+	}
+	// standard openGL clamping doesn't really do what we want -- it includes
+	// the border color at the edges.  OpenGL 1.2 has clamp-to-edge, which does
+	// what we want.
+#ifdef _XBOX
+	tr.fogImage = R_CreateImage("*fog", (byte *)data, FOG_S, FOG_T, GL_RGBA, qfalse, qfalse, GL_CLAMP);
+#else 
+	tr.fogImage = R_CreateImage("*fog", (byte *)data, FOG_S, FOG_T, GL_RGBA, qfalse, qfalse, qfalse, GL_CLAMP);
+#endif
+	Z_Free( data );
+
+	borderColor[0] = 1.0;
+	borderColor[1] = 1.0;
+	borderColor[2] = 1.0;
+	borderColor[3] = 1;
+
+	qglTexParameterfv( GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, borderColor );
+}
+
+/*
+==================
+R_CreateDefaultImage
+==================
+*/
+#define	DEFAULT_SIZE	16
+static void R_CreateDefaultImage( void ) {
+	int		x;
+	byte	data[DEFAULT_SIZE][DEFAULT_SIZE][4];
+
+	// the default image will be a box, to allow you to see the mapping coordinates
+	memset( data, 32, sizeof( data ) );
+	for ( x = 0 ; x < DEFAULT_SIZE ; x++ ) {
+		data[0][x][0] =
+		data[0][x][1] =
+		data[0][x][2] =
+		data[0][x][3] = 255;
+
+		data[x][0][0] =
+		data[x][0][1] =
+		data[x][0][2] =
+		data[x][0][3] = 255;
+
+		data[DEFAULT_SIZE-1][x][0] =
+		data[DEFAULT_SIZE-1][x][1] =
+		data[DEFAULT_SIZE-1][x][2] =
+		data[DEFAULT_SIZE-1][x][3] = 255;
+
+		data[x][DEFAULT_SIZE-1][0] =
+		data[x][DEFAULT_SIZE-1][1] =
+		data[x][DEFAULT_SIZE-1][2] =
+		data[x][DEFAULT_SIZE-1][3] = 255;
+	}
+#ifdef _XBOX
+	tr.defaultImage = R_CreateImage("*default", (byte *)data, DEFAULT_SIZE, DEFAULT_SIZE, GL_RGBA, qtrue, qfalse, GL_REPEAT);
+#else
+	tr.defaultImage = R_CreateImage("*default", (byte *)data, DEFAULT_SIZE, DEFAULT_SIZE, GL_RGBA, qtrue, qfalse, qtrue, GL_REPEAT);
+#endif
+}
+
+/*
+==================
+R_CreateBuiltinImages
+==================
+*/
+void R_UpdateSaveGameImage(const char *filename);
+
+void R_CreateBuiltinImages( void ) {
+	int		x,y;
+	byte	data[DEFAULT_SIZE][DEFAULT_SIZE][4];
+
+	R_CreateDefaultImage();
+
+	// we use a solid white image instead of disabling texturing
+	memset( data, 255, sizeof( data ) );
+#ifdef _XBOX
+	tr.whiteImage = R_CreateImage("*white", (byte *)data, 8, 8, GL_RGBA, qfalse, qfalse, GL_REPEAT);
+
+	tr.screenImage = R_CreateImage("*screen", (byte *)data, 8, 8, GL_RGBA, 1, qfalse, GL_REPEAT );
+
+	tr.saveGameImage = R_CreateImage("*savegame", (byte *)data, 8, 8, GL_RGBA, 1, qfalse, GL_REPEAT );
+	
+	// load the last saveimage
+	R_UpdateSaveGameImage("u:\\saveimage.xbx");
+#else
+	tr.whiteImage = R_CreateImage("*white", (byte *)data, 8, 8, GL_RGBA, qfalse, qfalse, qtrue, GL_REPEAT);
+
+	tr.screenImage = R_CreateImage("*screen", (byte *)data, 8, 8, GL_RGBA, qfalse, qfalse, qfalse, GL_REPEAT );
+#endif
+
+
+#ifndef _XBOX	// GLOWXXX
+	// Create the scene glow image. - AReis
+	tr.screenGlow = 1024 + giTextureBindNum++;
+	qglDisable( GL_TEXTURE_2D );
+	qglEnable( GL_TEXTURE_RECTANGLE_EXT );
+	qglBindTexture( GL_TEXTURE_RECTANGLE_EXT, tr.screenGlow );
+	qglTexImage2D( GL_TEXTURE_RECTANGLE_EXT, 0, GL_RGBA16, glConfig.vidWidth, glConfig.vidHeight, 0, GL_RGB, GL_FLOAT, 0 );
+	qglTexParameteri( GL_TEXTURE_RECTANGLE_EXT, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
+	qglTexParameteri( GL_TEXTURE_RECTANGLE_EXT, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
+	qglTexParameteri( GL_TEXTURE_RECTANGLE_EXT, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE );
+	qglTexParameteri( GL_TEXTURE_RECTANGLE_EXT, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE );
+
+	// Create the scene image. - AReis
+	tr.sceneImage = 1024 + giTextureBindNum++;
+	qglBindTexture( GL_TEXTURE_RECTANGLE_EXT, tr.sceneImage );
+	qglTexImage2D( GL_TEXTURE_RECTANGLE_EXT, 0, GL_RGBA16, glConfig.vidWidth, glConfig.vidHeight, 0, GL_RGB, GL_FLOAT, 0 );
+	qglTexParameteri( GL_TEXTURE_RECTANGLE_EXT, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
+	qglTexParameteri( GL_TEXTURE_RECTANGLE_EXT, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
+	qglTexParameteri( GL_TEXTURE_RECTANGLE_EXT, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE );
+	qglTexParameteri( GL_TEXTURE_RECTANGLE_EXT, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE );
+
+	// Create the minimized scene blur image.
+	if ( r_DynamicGlowWidth->integer > glConfig.vidWidth  )
+	{
+		r_DynamicGlowWidth->integer = glConfig.vidWidth;
+	}
+	if ( r_DynamicGlowHeight->integer > glConfig.vidHeight  )
+	{
+		r_DynamicGlowHeight->integer = glConfig.vidHeight;
+	}
+	tr.blurImage = 1024 + giTextureBindNum++;
+	qglBindTexture( GL_TEXTURE_RECTANGLE_EXT, tr.blurImage );
+	qglTexImage2D( GL_TEXTURE_RECTANGLE_EXT, 0, GL_RGBA16, r_DynamicGlowWidth->integer, r_DynamicGlowHeight->integer, 0, GL_RGB, GL_FLOAT, 0 );
+	qglTexParameteri( GL_TEXTURE_RECTANGLE_EXT, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
+	qglTexParameteri( GL_TEXTURE_RECTANGLE_EXT, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
+	qglTexParameteri( GL_TEXTURE_RECTANGLE_EXT, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE );
+	qglTexParameteri( GL_TEXTURE_RECTANGLE_EXT, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE );
+	qglDisable( GL_TEXTURE_RECTANGLE_EXT );
+	qglEnable( GL_TEXTURE_2D );
+
+
+	// with overbright bits active, we need an image which is some fraction of full color,
+	// for default lightmaps, etc
+	for (x=0 ; x<DEFAULT_SIZE ; x++) {
+		for (y=0 ; y<DEFAULT_SIZE ; y++) {
+			data[y][x][0] = 
+			data[y][x][1] = 
+			data[y][x][2] = tr.identityLightByte;
+			data[y][x][3] = 255;			
+		}
+	}
+#endif	// _XBOX
+
+#ifdef _XBOX
+	tr.identityLightImage = R_CreateImage("*identityLight", (byte *)data, 8, 8, GL_RGBA, qfalse, qfalse, GL_REPEAT);
+#else
+	tr.identityLightImage = R_CreateImage("*identityLight", (byte *)data, 8, 8, GL_RGBA, qfalse, qfalse, qtrue, GL_REPEAT);
+#endif
+
+	// scratchimage is usually used for cinematic drawing
+	for(x=0;x<NUM_SCRATCH_IMAGES;x++) {
+		// scratchimage is usually used for cinematic drawing
+#ifdef _XBOX
+		tr.scratchImage[x] = R_CreateImage(va("*scratch%d",x), (byte *)data, DEFAULT_SIZE, DEFAULT_SIZE, GL_RGBA, qfalse, qfalse, GL_CLAMP);
+#else
+		tr.scratchImage[x] = R_CreateImage(va("*scratch%d",x), (byte *)data, DEFAULT_SIZE, DEFAULT_SIZE, GL_RGBA, qfalse, qfalse, qfalse, GL_CLAMP);
+#endif
+	}
+
+	R_CreateDlightImage();
+	R_CreateFogImage();
+}
+
+
+/*
+===============
+R_SetColorMappings
+===============
+*/
+void R_SetColorMappings( void ) {
+	int		i, j;
+	float	g;
+	int		inf;
+	int		shift;
+
+	// setup the overbright lighting
+	tr.overbrightBits = r_overBrightBits->integer;
+	if ( !glConfig.deviceSupportsGamma ) {
+		tr.overbrightBits = 0;		// need hardware gamma for overbright
+	}
+
+	// never overbright in windowed mode
+	if ( !glConfig.isFullscreen )
+	{
+		tr.overbrightBits = 0;
+	}
+
+	if ( tr.overbrightBits > 1 ) {
+		tr.overbrightBits = 1;
+	}
+	if ( tr.overbrightBits < 0 ) {
+		tr.overbrightBits = 0;
+	}
+
+	tr.identityLight = 1.0 / ( 1 << tr.overbrightBits );
+	tr.identityLightByte = 255 * tr.identityLight;
+
+
+	if ( r_intensity->value < 1.0f ) {
+		Cvar_Set( "r_intensity", "1.0" );
+	}
+
+	if ( r_gamma->value < 0.5f ) {
+		Cvar_Set( "r_gamma", "0.5" );
+	} else if ( r_gamma->value > 3.0f ) {
+		Cvar_Set( "r_gamma", "3.0" );
+	}
+
+	g = r_gamma->value;
+
+	shift = tr.overbrightBits;
+
+	for ( i = 0; i < 256; i++ ) {
+		if ( g == 1 ) {
+			inf = i;
+		} else {
+			inf = 255 * pow ( i/255.0f, 1.0f / g ) + 0.5f;
+		}
+		inf <<= shift;
+		if (inf < 0) {
+			inf = 0;
+		}
+		if (inf > 255) {
+			inf = 255;
+		}
+		s_gammatable[i] = inf;
+	}
+
+	for (i=0 ; i<256 ; i++) {
+		j = i * r_intensity->value;
+		if (j > 255) {
+			j = 255;
+		}
+		s_intensitytable[i] = j;
+	}
+
+#ifndef _XBOX
+	if ( glConfig.deviceSupportsGamma )
+	{
+		GLimp_SetGamma( s_gammatable, s_gammatable, s_gammatable );
+	}
+#endif
+}
+
+/*
+===============
+R_InitImages
+===============
+*/
+void	R_InitImages( void ) {
+	//memset(hashTable, 0, sizeof(hashTable));	// DO NOT DO THIS NOW (because of image cacheing)	-ste.
+#ifdef _XBOX
+	if (!AllocatedImages)
+	{
+		AllocatedImages = new AllocatedImages_t;
+	}
+#endif
+
+	// build brightness translation tables
+	R_SetColorMappings();
+
+	// create default texture and white texture
+	R_CreateBuiltinImages();
+}
+
+/*
+===============
+R_DeleteTextures
+===============
+*/
+// (only gets called during vid_restart now (and app exit), not during map load)
+//
+void R_DeleteTextures( void ) {
+
+	R_Images_Clear();	
+	GL_ResetBinds();
+}
+
+/*
+============================================================================
+
+SKINS
+
+============================================================================
+*/
+
+/*
+==================
+CommaParse
+
+This is unfortunate, but the skin files aren't
+compatable with our normal parsing rules.
+==================
+*/
+static char *CommaParse( char **data_p ) {
+	int c = 0, len;
+	char *data;
+	static	char	com_token[MAX_TOKEN_CHARS];
+
+	data = *data_p;
+	len = 0;
+	com_token[0] = 0;
+
+	// make sure incoming data is valid
+	if ( !data ) {
+		*data_p = NULL;
+		return com_token;
+	}
+
+	while ( 1 ) {
+		// skip whitespace
+		while( (c = *data) <= ' ') {
+			if( !c ) {
+				break;
+			}
+			data++;
+		}
+
+
+		c = *data;
+
+		// skip double slash comments
+		if ( c == '/' && data[1] == '/' )
+		{
+			while (*data && *data != '\n')
+				data++;
+		}
+		// skip /* */ comments
+		else if ( c=='/' && data[1] == '*' ) 
+		{
+			while ( *data && ( *data != '*' || data[1] != '/' ) ) 
+			{
+				data++;
+			}
+			if ( *data ) 
+			{
+				data += 2;
+			}
+		}
+		else
+		{
+			break;
+		}
+	}
+
+	if ( c == 0 ) {
+		return "";
+	}
+
+	// handle quoted strings
+	if (c == '\"')
+	{
+		data++;
+		while (1)
+		{
+			c = *data++;
+			if (c=='\"' || !c)
+			{
+				com_token[len] = 0;
+				*data_p = ( char * ) data;
+				return com_token;
+			}
+			if (len < MAX_TOKEN_CHARS)
+			{
+				com_token[len] = c;
+				len++;
+			}
+		}
+	}
+
+	// parse a regular word
+	do
+	{
+		if (len < MAX_TOKEN_CHARS)
+		{
+			com_token[len] = c;
+			len++;
+		}
+		data++;
+		c = *data;
+	} while (c>32 && c != ',' );
+
+	if (len == MAX_TOKEN_CHARS)
+	{
+//		Com_Printf ("Token exceeded %i chars, discarded.\n", MAX_TOKEN_CHARS);
+		len = 0;
+	}
+	com_token[len] = 0;
+
+	*data_p = ( char * ) data;
+	return com_token;
+}
+
+/*
+class CStringComparator
+{
+public:
+	bool operator()(const char *s1, const char *s2) const { return(stricmp(s1, s2) < 0); } 
+};
+*/
+typedef map<sstring_t,char * /*, CStringComparator*/ >	AnimationCFGs_t;
+													AnimationCFGs_t AnimationCFGs;
+
+// I added this function for development purposes (and it's VM-safe) so we don't have problems
+//	with our use of cached models but uncached animation.cfg files (so frame sequences are out of sync
+//	if someone rebuild the model while you're ingame and you change levels)...
+//
+// Usage:  call with psDest == NULL for a size enquire (for malloc), 
+//				then with NZ ptr for it to copy to your supplied buffer...
+//
+int RE_GetAnimationCFG(const char *psCFGFilename, char *psDest, int iDestSize)
+{
+	char *psText = NULL;
+
+	AnimationCFGs_t::iterator it = AnimationCFGs.find(psCFGFilename);
+	if (it != AnimationCFGs.end())
+	{
+		psText = (*it).second;
+	}
+	else
+	{
+		// not found, so load it...
+		//
+		fileHandle_t f;
+		int iLen = FS_FOpenFileRead( psCFGFilename, &f, FS_READ );
+		if (iLen <= 0)
+		{
+			return 0;
+		}
+
+		psText = (char *) Z_Malloc( iLen+1, TAG_ANIMATION_CFG, qfalse );
+
+		FS_Read( psText, iLen, f );
+		psText[iLen] = '\0';
+		FS_FCloseFile( f );
+
+		AnimationCFGs[psCFGFilename] = psText;
+	}
+
+	if (psText)	// sanity, but should always be NZ
+	{
+		if (psDest)
+		{
+			Q_strncpyz(psDest,psText,iDestSize);
+		}
+
+		return strlen(psText);
+	}
+
+	return 0;
+}
+
+// only called from devmapbsp, devmapall, or ...
+//
+void RE_AnimationCFGs_DeleteAll(void)
+{
+	for (AnimationCFGs_t::iterator it = AnimationCFGs.begin(); it != AnimationCFGs.end(); ++it)
+	{
+		char *psText = (*it).second;
+		Z_Free(psText);
+	}
+
+	AnimationCFGs.clear();
+}
+
+/*
+===============
+RE_SplitSkins
+input = skinname, possibly being a macro for three skins
+return= true if three part skins found
+output= qualified names to three skins if return is true, undefined if false
+===============
+*/
+bool RE_SplitSkins(const char *INname, char *skinhead, char *skintorso, char *skinlower)
+{	//INname= "models/players/jedi_tf/|head01_skin1|torso01|lower01";
+	if (strchr(INname, '|'))
+	{
+		char name[MAX_QPATH];
+		strcpy(name, INname);
+		char *p = strchr(name, '|');
+		*p=0;
+		p++;
+		//fill in the base path
+		strcpy (skinhead, name);
+		strcpy (skintorso, name);
+		strcpy (skinlower, name);
+
+		//now get the the individual files
+		
+		//advance to second
+		char *p2 = strchr(p, '|'); 
+		assert(p2);
+		*p2=0;
+		p2++;
+		strcat (skinhead, p);
+		strcat (skinhead, ".skin");
+
+
+		//advance to third
+		p = strchr(p2, '|');
+		assert(p);
+		if (!p)
+		{
+			return false;
+		}
+		*p=0;
+		p++;
+		strcat (skintorso,p2);
+		strcat (skintorso, ".skin");
+
+		strcat (skinlower,p);
+		strcat (skinlower, ".skin");
+		
+		return true;
+	}
+	return false;
+}
+
+
+qhandle_t RE_RegisterIndividualSkin( const char *name , qhandle_t hSkin);
+/*
+===============
+RE_RegisterSkin
+
+===============
+*/
+qhandle_t RE_RegisterSkin( const char *name) {
+	qhandle_t	hSkin;
+	skin_t		*skin;
+
+//	if (!cls.cgameStarted && !cls.uiStarted)		
+//	{
+		//rww - added uiStarted exception because we want ghoul2 models in the menus.
+		// gwg well we need our skins to set surfaces on and off, so we gotta get em
+		//return 1;	// cope with Ghoul2's calling-the-renderer-before-its-even-started hackery, must be any NZ amount here to trigger configstring setting
+//	}
+
+	if (!tr.numSkins)
+	{
+		R_InitSkins(); //make sure we have numSkins set to at least one.
+	}
+
+	if ( !name || !name[0] ) {
+		Com_Printf( "Empty name passed to RE_RegisterSkin\n" );
+		return 0;
+	}
+
+	if ( strlen( name ) >= MAX_QPATH ) {
+		Com_Printf( "Skin name exceeds MAX_QPATH\n" );
+		return 0;
+	}
+
+	// see if the skin is already loaded
+	for ( hSkin = 1; hSkin < tr.numSkins ; hSkin++ ) {
+		skin = tr.skins[hSkin];
+		if ( !Q_stricmp( skin->name, name ) ) {
+			if( skin->numSurfaces == 0 ) {
+				return 0;		// default skin
+			}
+			return(hSkin);
+		}
+	}
+
+	if ( tr.numSkins == MAX_SKINS )	{
+		VID_Printf( PRINT_WARNING, "WARNING: RE_RegisterSkin( '%s' ) MAX_SKINS hit\n", name );
+		return 0;
+	}
+	// allocate a new skin
+	tr.numSkins++;
+	skin = (skin_t*) Hunk_Alloc( sizeof( skin_t ), qtrue );
+	tr.skins[hSkin] = skin;
+	Q_strncpyz( skin->name, name, sizeof( skin->name ) );	//always make one so it won't search for it again
+
+	// If not a .skin file, load as a single shader	- then return
+	if ( strcmp( name + strlen( name ) - 5, ".skin" ) ) {
+/*		skin->numSurfaces = 1;
+		skin->surfaces[0] = (skinSurface_t *) Hunk_Alloc( sizeof(skin->surfaces[0]), qtrue );
+		skin->surfaces[0]->shader = R_FindShader( name, lightmapsNone, stylesDefault, qtrue );
+		return hSkin;
+*/
+	}
+
+	char skinhead[MAX_QPATH]={0};
+	char skintorso[MAX_QPATH]={0};
+	char skinlower[MAX_QPATH]={0};
+	if ( RE_SplitSkins(name, (char*)&skinhead, (char*)&skintorso, (char*)&skinlower ) )
+	{//three part
+		hSkin = RE_RegisterIndividualSkin(skinhead, hSkin);
+		if (hSkin)
+		{
+			hSkin = RE_RegisterIndividualSkin(skintorso, hSkin);
+			if (hSkin)
+			{
+				hSkin = RE_RegisterIndividualSkin(skinlower, hSkin);
+			}
+		}
+	}
+	else
+	{//single skin
+		hSkin = RE_RegisterIndividualSkin(name, hSkin);
+	}
+	return(hSkin);
+}
+
+// given a name, go get the skin we want and return
+qhandle_t RE_RegisterIndividualSkin( const char *name , qhandle_t hSkin) 
+{
+	skin_t		*skin;
+	skinSurface_t	*surf;
+	char		*text, *text_p;
+	char		*token;
+	char		surfName[MAX_QPATH];
+
+	// load and parse the skin file
+    FS_ReadFile( name, (void **)&text );
+	if ( !text ) {
+		VID_Printf( PRINT_ERROR, "WARNING: RE_RegisterSkin( '%s' ) failed to load!\n", name );
+		return 0;
+	}
+
+	assert (tr.skins[hSkin]);	//should already be setup, but might be an 3part append
+
+	skin = tr.skins[hSkin];
+
+	text_p = text;
+	while ( text_p && *text_p ) {
+		// get surface name
+		token = CommaParse( &text_p );
+		Q_strncpyz( surfName, token, sizeof( surfName ) );
+
+		if ( !token[0] ) {
+			break;
+		}
+		// lowercase the surface name so skin compares are faster
+		Q_strlwr( surfName );
+
+		if ( *text_p == ',' ) {
+			text_p++;
+		}
+
+		if ( !strncmp( token, "tag_", 4 ) ) {	//these aren't in there, but just in case you load an id style one...
+			continue;
+		}
+		
+		// parse the shader name
+		token = CommaParse( &text_p );
+
+		if ( !strcmp( &surfName[strlen(surfName)-4], "_off") )
+		{
+			if ( !strcmp( token ,"*off" ) )
+			{
+				continue;	//don't need these double offs
+			}
+			surfName[strlen(surfName)-4] = 0;	//remove the "_off"
+		}
+		if (sizeof( skin->surfaces) / sizeof( skin->surfaces[0] ) <= skin->numSurfaces)
+		{
+			assert( sizeof( skin->surfaces) / sizeof( skin->surfaces[0] ) > skin->numSurfaces );
+			VID_Printf( PRINT_ERROR, "WARNING: RE_RegisterSkin( '%s' ) more than %d surfaces!\n", name, sizeof( skin->surfaces) / sizeof( skin->surfaces[0] ) );
+			break;
+		}
+		surf = skin->surfaces[ skin->numSurfaces ] = (skinSurface_t *) Hunk_Alloc( sizeof( *skin->surfaces[0] ), qtrue );
+		Q_strncpyz( surf->name, surfName, sizeof( surf->name ) );
+		surf->shader = R_FindShader( token, lightmapsNone, stylesDefault, qtrue );
+		skin->numSurfaces++;
+	}
+
+	FS_FreeFile( text );
+
+
+	// never let a skin have 0 shaders
+	if ( skin->numSurfaces == 0 ) {
+		return 0;		// use default skin
+	}
+
+	return hSkin;
+}
+
+
+/*
+===============
+R_InitSkins
+===============
+*/
+void	R_InitSkins( void ) {
+	skin_t		*skin;
+
+	tr.numSkins = 1;
+
+	// make the default skin have all default shaders
+	skin = tr.skins[0] = (skin_t*) Hunk_Alloc( sizeof( skin_t ), qtrue );
+	Q_strncpyz( skin->name, "<default skin>", sizeof( skin->name )  );
+	skin->numSurfaces = 1;
+	skin->surfaces[0] = (skinSurface_t *) Hunk_Alloc( sizeof( *skin->surfaces[0] ), qtrue );
+	skin->surfaces[0]->shader = tr.defaultShader;
+}
+
+/*
+===============
+R_GetSkinByHandle
+===============
+*/
+skin_t	*R_GetSkinByHandle( qhandle_t hSkin ) {
+	if ( hSkin < 1 || hSkin >= tr.numSkins ) {
+		return tr.skins[0];
+	}
+	return tr.skins[ hSkin ];
+}
+
+/*
+===============
+R_SkinList_f
+===============
+*/
+void	R_SkinList_f (void) {
+	int			i, j;
+	skin_t		*skin;
+
+	VID_Printf (PRINT_ALL, "------------------\n");
+
+	for ( i = 0 ; i < tr.numSkins ; i++ ) {
+		skin = tr.skins[i];
+		VID_Printf( PRINT_ALL, "%3i:%s\n", i, skin->name );
+		for ( j = 0 ; j < skin->numSurfaces ; j++ ) {
+			VID_Printf( PRINT_ALL, "       %s = %s\n", 
+				skin->surfaces[j]->name, skin->surfaces[j]->shader->name );
+		}
+	}
+	VID_Printf (PRINT_ALL, "------------------\n");
+}
+
+#ifdef _XBOX
+
+extern BOOL LoadCompressedScreenshot(const char* filename);
+
+/*
+===============
+R_UpdateSaveGameImage
+filename	- .xbx format file with a screenshot
+===============
+*/
+void R_UpdateSaveGameImage(const char* filename)
+{
+	// bind the savegame image
+	GL_Bind(tr.saveGameImage);
+
+	// replace the texture with the one from the file
+	LoadCompressedScreenshot(filename);
+}
+
+#endif // _XBOX
+
diff --git a/code/renderer/tr_init.cpp b/code/renderer/tr_init.cpp
new file mode 100644
index 0000000..36edf4a
--- /dev/null
+++ b/code/renderer/tr_init.cpp
@@ -0,0 +1,1626 @@
+// tr_init.c -- functions that are not called every frame
+
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+
+
+#include "tr_local.h"
+#include "tr_stl.h"
+#include "tr_jpeg_interface.h"
+#include "tr_font.h"
+#include "tr_WorldEffects.h"
+
+glconfig_t	glConfig;
+glstate_t	glState;
+
+static void GfxInfo_f( void );
+
+void R_TerrainInit(void);
+void R_TerrainShutdown(void);
+
+cvar_t	*r_verbose;
+cvar_t	*r_ignore;
+
+cvar_t	*r_displayRefresh;
+
+cvar_t	*r_detailTextures;
+
+cvar_t	*r_znear;
+
+cvar_t	*r_skipBackEnd;
+
+cvar_t	*r_ignorehwgamma;
+cvar_t	*r_measureOverdraw;
+
+cvar_t	*r_fastsky;
+cvar_t	*r_drawSun;
+cvar_t	*r_dynamiclight;
+cvar_t	*r_dlightBacks;
+
+cvar_t	*r_lodbias;
+cvar_t	*r_lodscale;
+
+cvar_t	*r_norefresh;
+cvar_t	*r_drawentities;
+cvar_t	*r_drawworld;
+cvar_t	*r_drawfog;
+cvar_t	*r_speeds;
+cvar_t	*r_fullbright;
+cvar_t	*r_novis;
+cvar_t	*r_nocull;
+cvar_t	*r_facePlaneCull;
+cvar_t	*r_showcluster;
+cvar_t	*r_nocurves;
+
+cvar_t	*r_dlightStyle;
+cvar_t	*r_surfaceSprites;
+cvar_t	*r_surfaceWeather;
+
+cvar_t	*r_windSpeed;
+cvar_t	*r_windAngle;
+cvar_t	*r_windGust;
+cvar_t	*r_windDampFactor;
+cvar_t	*r_windPointForce;
+cvar_t	*r_windPointX;
+cvar_t	*r_windPointY;
+
+cvar_t	*r_allowExtensions;
+
+cvar_t	*r_ext_compressed_textures;
+cvar_t	*r_ext_compressed_lightmaps;
+cvar_t	*r_ext_preferred_tc_method;
+cvar_t	*r_ext_gamma_control;
+cvar_t	*r_ext_multitexture;
+cvar_t	*r_ext_compiled_vertex_array;
+cvar_t	*r_ext_texture_env_add;
+cvar_t	*r_ext_texture_filter_anisotropic;
+
+cvar_t	*r_DynamicGlow;
+cvar_t	*r_DynamicGlowPasses;
+cvar_t	*r_DynamicGlowDelta;
+cvar_t	*r_DynamicGlowIntensity;
+cvar_t	*r_DynamicGlowSoft;
+cvar_t	*r_DynamicGlowWidth;
+cvar_t	*r_DynamicGlowHeight;
+
+// Point sprite support.
+cvar_t	*r_ext_point_parameters;
+cvar_t	*r_ext_nv_point_sprite;
+
+cvar_t	*r_ignoreGLErrors;
+cvar_t	*r_logFile;
+
+cvar_t	*r_stencilbits;
+cvar_t	*r_depthbits;
+cvar_t	*r_colorbits;
+cvar_t	*r_stereo;
+cvar_t	*r_primitives;
+cvar_t	*r_texturebits;
+cvar_t	*r_texturebitslm;
+
+cvar_t	*r_lightmap;
+cvar_t	*r_vertexLight;
+cvar_t	*r_shadows;
+cvar_t	*r_shadowRange;
+cvar_t	*r_flares;
+cvar_t	*r_mode;
+cvar_t	*r_nobind;
+cvar_t	*r_singleShader;
+cvar_t	*r_colorMipLevels;
+cvar_t	*r_picmip;
+cvar_t	*r_showtris;
+cvar_t	*r_showtriscolor;
+cvar_t	*r_showsky;
+cvar_t	*r_shownormals;
+cvar_t	*r_finish;
+cvar_t	*r_clear;
+cvar_t	*r_swapInterval;
+cvar_t	*r_textureMode;
+cvar_t	*r_offsetFactor;
+cvar_t	*r_offsetUnits;
+cvar_t	*r_gamma;
+cvar_t	*r_intensity;
+cvar_t	*r_lockpvs;
+cvar_t	*r_noportals;
+cvar_t	*r_portalOnly;
+
+cvar_t	*r_subdivisions;
+cvar_t	*r_lodCurveError;
+
+cvar_t	*r_fullscreen;
+
+cvar_t	*r_customwidth;
+cvar_t	*r_customheight;
+
+cvar_t	*r_overBrightBits;
+
+cvar_t	*r_debugSurface;
+cvar_t	*r_simpleMipMaps;
+
+cvar_t	*r_showImages;
+
+cvar_t	*r_ambientScale;
+cvar_t	*r_directedScale;
+cvar_t	*r_debugLight;
+cvar_t	*r_debugSort;
+cvar_t	*r_debugStyle;
+
+cvar_t	*r_modelpoolmegs;
+
+#ifdef _XBOX
+cvar_t	*r_hdreffect;
+cvar_t  *r_sundir_x;
+cvar_t  *r_sundir_y;
+cvar_t  *r_sundir_z;
+cvar_t  *r_hdrbloom;
+cvar_t	*r_hdrcutoff;
+#endif
+
+/*
+Ghoul2 Insert Start
+*/
+
+cvar_t	*r_noGhoul2;
+cvar_t	*r_Ghoul2AnimSmooth;
+cvar_t	*r_Ghoul2UnSqash;
+cvar_t	*r_Ghoul2TimeBase=0;
+cvar_t	*r_Ghoul2NoLerp;
+cvar_t	*r_Ghoul2NoBlend;
+cvar_t	*r_Ghoul2BlendMultiplier=0;
+cvar_t	*r_Ghoul2UnSqashAfterSmooth;
+
+cvar_t	*broadsword=0;
+cvar_t	*broadsword_kickbones=0;
+cvar_t	*broadsword_kickorigin=0;
+cvar_t	*broadsword_playflop=0;
+cvar_t	*broadsword_dontstopanim=0;
+cvar_t	*broadsword_waitforshot=0;
+cvar_t	*broadsword_smallbbox=0;
+cvar_t	*broadsword_extra1=0;
+cvar_t	*broadsword_extra2=0;
+
+cvar_t	*broadsword_effcorr=0;
+cvar_t	*broadsword_ragtobase=0;
+cvar_t	*broadsword_dircap=0;
+
+/*
+Ghoul2 Insert End
+*/
+
+
+void ( APIENTRY * qglMultiTexCoord2fARB )( GLenum texture, GLfloat s, GLfloat t );
+void ( APIENTRY * qglActiveTextureARB )( GLenum texture );
+void ( APIENTRY * qglClientActiveTextureARB )( GLenum texture );
+
+void ( APIENTRY * qglLockArraysEXT)( GLint, GLint);
+void ( APIENTRY * qglUnlockArraysEXT) ( void );
+
+void ( APIENTRY * qglPointParameterfEXT)( GLenum, GLfloat);
+void ( APIENTRY * qglPointParameterfvEXT)( GLenum, GLfloat *);
+
+// Added 10/23/02 by Aurelio Reis.
+void ( APIENTRY * qglPointParameteriNV)( GLenum, GLint);
+void ( APIENTRY * qglPointParameterivNV)( GLenum, const GLint *);
+
+#ifndef _XBOX	// GLOWXXX
+// Declare Register Combiners function pointers.
+PFNGLCOMBINERPARAMETERFVNV				qglCombinerParameterfvNV = NULL;
+PFNGLCOMBINERPARAMETERIVNV				qglCombinerParameterivNV = NULL;
+PFNGLCOMBINERPARAMETERFNV				qglCombinerParameterfNV = NULL;
+PFNGLCOMBINERPARAMETERINV				qglCombinerParameteriNV = NULL;
+PFNGLCOMBINERINPUTNV					qglCombinerInputNV = NULL;
+PFNGLCOMBINEROUTPUTNV					qglCombinerOutputNV = NULL;
+PFNGLFINALCOMBINERINPUTNV				qglFinalCombinerInputNV = NULL;
+PFNGLGETCOMBINERINPUTPARAMETERFVNV		qglGetCombinerInputParameterfvNV = NULL;
+PFNGLGETCOMBINERINPUTPARAMETERIVNV		qglGetCombinerInputParameterivNV = NULL;
+PFNGLGETCOMBINEROUTPUTPARAMETERFVNV		qglGetCombinerOutputParameterfvNV = NULL;
+PFNGLGETCOMBINEROUTPUTPARAMETERIVNV		qglGetCombinerOutputParameterivNV = NULL;
+PFNGLGETFINALCOMBINERINPUTPARAMETERFVNV	qglGetFinalCombinerInputParameterfvNV = NULL;
+PFNGLGETFINALCOMBINERINPUTPARAMETERIVNV	qglGetFinalCombinerInputParameterivNV = NULL;
+
+// Declare Pixel Format function pointers.
+PFNWGLGETPIXELFORMATATTRIBIVARBPROC		qwglGetPixelFormatAttribivARB = NULL;
+PFNWGLGETPIXELFORMATATTRIBFVARBPROC		qwglGetPixelFormatAttribfvARB = NULL;
+PFNWGLCHOOSEPIXELFORMATARBPROC			qwglChoosePixelFormatARB = NULL;
+
+// Declare Pixel Buffer function pointers.
+PFNWGLCREATEPBUFFERARBPROC				qwglCreatePbufferARB = NULL;
+PFNWGLGETPBUFFERDCARBPROC				qwglGetPbufferDCARB = NULL;
+PFNWGLRELEASEPBUFFERDCARBPROC			qwglReleasePbufferDCARB = NULL;
+PFNWGLDESTROYPBUFFERARBPROC				qwglDestroyPbufferARB = NULL;
+PFNWGLQUERYPBUFFERARBPROC				qwglQueryPbufferARB = NULL;
+
+// Declare Render-Texture function pointers.
+PFNWGLBINDTEXIMAGEARBPROC				qwglBindTexImageARB = NULL;
+PFNWGLRELEASETEXIMAGEARBPROC			qwglReleaseTexImageARB = NULL;
+PFNWGLSETPBUFFERATTRIBARBPROC			qwglSetPbufferAttribARB = NULL;
+
+// Declare Vertex and Fragment Program function pointers.
+PFNGLPROGRAMSTRINGARBPROC qglProgramStringARB = NULL;
+PFNGLBINDPROGRAMARBPROC qglBindProgramARB = NULL;
+PFNGLDELETEPROGRAMSARBPROC qglDeleteProgramsARB = NULL;
+PFNGLGENPROGRAMSARBPROC qglGenProgramsARB = NULL;
+PFNGLPROGRAMENVPARAMETER4DARBPROC qglProgramEnvParameter4dARB = NULL;
+PFNGLPROGRAMENVPARAMETER4DVARBPROC qglProgramEnvParameter4dvARB = NULL;
+PFNGLPROGRAMENVPARAMETER4FARBPROC qglProgramEnvParameter4fARB = NULL;
+PFNGLPROGRAMENVPARAMETER4FVARBPROC qglProgramEnvParameter4fvARB = NULL;
+PFNGLPROGRAMLOCALPARAMETER4DARBPROC qglProgramLocalParameter4dARB = NULL;
+PFNGLPROGRAMLOCALPARAMETER4DVARBPROC qglProgramLocalParameter4dvARB = NULL;
+PFNGLPROGRAMLOCALPARAMETER4FARBPROC qglProgramLocalParameter4fARB = NULL;
+PFNGLPROGRAMLOCALPARAMETER4FVARBPROC qglProgramLocalParameter4fvARB = NULL;
+PFNGLGETPROGRAMENVPARAMETERDVARBPROC qglGetProgramEnvParameterdvARB = NULL;
+PFNGLGETPROGRAMENVPARAMETERFVARBPROC qglGetProgramEnvParameterfvARB = NULL;
+PFNGLGETPROGRAMLOCALPARAMETERDVARBPROC qglGetProgramLocalParameterdvARB = NULL;
+PFNGLGETPROGRAMLOCALPARAMETERFVARBPROC qglGetProgramLocalParameterfvARB = NULL;
+PFNGLGETPROGRAMIVARBPROC qglGetProgramivARB = NULL;
+PFNGLGETPROGRAMSTRINGARBPROC qglGetProgramStringARB = NULL;
+PFNGLISPROGRAMARBPROC qglIsProgramARB = NULL;
+#endif
+
+void RE_SetLightStyle(int style, int color);
+
+static void AssertCvarRange( cvar_t *cv, float minVal, float maxVal, qboolean shouldBeIntegral,  qboolean shouldBeMult2)
+{
+	if ( shouldBeIntegral )
+	{
+		if ( ( int ) cv->value != cv->integer )
+		{
+			VID_Printf( PRINT_WARNING, "WARNING: cvar '%s' must be integral (%f)\n", cv->name, cv->value );
+			Cvar_Set( cv->name, va( "%d", cv->integer ) );
+		}
+	}
+
+	if ( cv->value < minVal )
+	{
+		VID_Printf( PRINT_WARNING, "WARNING: cvar '%s' out of range (%f < %f)\n", cv->name, cv->value, minVal );
+		Cvar_Set( cv->name, va( "%f", minVal ) );
+	}
+	else if ( cv->value > maxVal )
+	{
+		VID_Printf( PRINT_WARNING, "WARNING: cvar '%s' out of range (%f > %f)\n", cv->name, cv->value, maxVal );
+		Cvar_Set( cv->name, va( "%f", maxVal ) );
+	}
+
+	if (shouldBeMult2)
+	{
+		if ( (cv->integer&(cv->integer-1)) )
+		{
+			int newvalue;
+			for (newvalue = 1 ; newvalue < cv->integer ; newvalue<<=1)
+				;
+			VID_Printf( PRINT_WARNING, "WARNING: cvar '%s' must be multiple of 2(%f)\n", cv->name, cv->value );
+			Cvar_Set( cv->name, va( "%d", newvalue ) );
+		}
+	}
+}
+
+void R_Splash()
+{
+#ifndef _XBOX
+	image_t *pImage;
+/*
+	const char* s = Cvar_VariableString("se_language");
+	if (stricmp(s,"english"))
+	{
+		pImage = R_FindImageFile( "menu/splash_eur", qfalse, qfalse, qfalse, GL_CLAMP);
+	}
+	else
+	{
+		pImage = R_FindImageFile( "menu/splash", qfalse, qfalse, qfalse, GL_CLAMP);
+	}
+*/
+	pImage = R_FindImageFile( "menu/splash", qfalse, qfalse, qfalse, GL_CLAMP);
+
+	extern void	RB_SetGL2D (void);
+	RB_SetGL2D();	
+	if (pImage )
+	{//invalid paths?
+		GL_Bind( pImage );
+	}
+	GL_State(GLS_SRCBLEND_ONE | GLS_DSTBLEND_ZERO);
+
+	const int width = 640;
+	const int height = 480;
+	const float x1 = 320 - width / 2;
+	const float x2 = 320 + width / 2;
+	const float y1 = 240 - height / 2;
+	const float y2 = 240 + height / 2;
+
+
+	qglBegin (GL_TRIANGLE_STRIP);
+		qglTexCoord2f( 0,  0 );
+		qglVertex2f(x1, y1);
+		qglTexCoord2f( 1 ,  0 );
+		qglVertex2f(x2, y1);
+		qglTexCoord2f( 0, 1 );
+		qglVertex2f(x1, y2);
+		qglTexCoord2f( 1, 1 );
+		qglVertex2f(x2, y2);
+	qglEnd();
+
+	GLimp_EndFrame();
+#endif
+}
+
+/*
+** InitOpenGL
+**
+** This function is responsible for initializing a valid OpenGL subsystem.  This
+** is done by calling GLimp_Init (which gives us a working OGL subsystem) then
+** setting variables, checking GL constants, and reporting the gfx system config
+** to the user.
+*/
+static void InitOpenGL( void )
+{
+	//
+	// initialize OS specific portions of the renderer
+	//
+	// GLimp_Init directly or indirectly references the following cvars:
+	//		- r_fullscreen
+	//		- r_mode
+	//		- r_(color|depth|stencil)bits
+	//		- r_ignorehwgamma
+	//		- r_gamma
+	//
+
+	if ( glConfig.vidWidth == 0 )
+	{		
+		GLimp_Init();
+		// print info the first time only
+		// set default state
+		GL_SetDefaultState();
+		R_Splash();	//get something on screen asap
+		GfxInfo_f();
+	}
+	else
+	{
+		// set default state
+		GL_SetDefaultState();
+	}
+}
+
+/*
+==================
+GL_CheckErrors
+==================
+*/
+void GL_CheckErrors( void ) {
+    int		err;
+    char	s[64];
+
+    err = qglGetError();
+    if ( err == GL_NO_ERROR ) {
+        return;
+    }
+    if ( r_ignoreGLErrors->integer ) {
+        return;
+    }
+    switch( err ) {
+        case GL_INVALID_ENUM:
+            strcpy( s, "GL_INVALID_ENUM" );
+            break;
+        case GL_INVALID_VALUE:
+            strcpy( s, "GL_INVALID_VALUE" );
+            break;
+        case GL_INVALID_OPERATION:
+            strcpy( s, "GL_INVALID_OPERATION" );
+            break;
+        case GL_STACK_OVERFLOW:
+            strcpy( s, "GL_STACK_OVERFLOW" );
+            break;
+        case GL_STACK_UNDERFLOW:
+            strcpy( s, "GL_STACK_UNDERFLOW" );
+            break;
+        case GL_OUT_OF_MEMORY:
+            strcpy( s, "GL_OUT_OF_MEMORY" );
+            break;
+        default:
+            Com_sprintf( s, sizeof(s), "%i", err);
+            break;
+    }
+
+    Com_Error( ERR_FATAL, "GL_CheckErrors: %s", s );
+}
+
+#ifndef _XBOX
+
+/*
+** R_GetModeInfo
+*/
+typedef struct vidmode_s
+{
+    const char *description;
+    int         width, height;
+} vidmode_t;
+
+const vidmode_t r_vidModes[] =
+{
+    { "Mode  0: 320x240",		320,	240 },
+    { "Mode  1: 400x300",		400,	300 },
+    { "Mode  2: 512x384",		512,	384 },
+    { "Mode  3: 640x480",		640,	480 },
+    { "Mode  4: 800x600",		800,	600 },
+    { "Mode  5: 960x720",		960,	720 },
+    { "Mode  6: 1024x768",		1024,	768 },
+    { "Mode  7: 1152x864",		1152,	864 },
+    { "Mode  8: 1280x1024",		1280,	1024 },
+    { "Mode  9: 1600x1200",		1600,	1200 },
+    { "Mode 10: 2048x1536",		2048,	1536 },
+    { "Mode 11: 856x480 (wide)", 856,	 480 },
+    { "Mode 12: 2400x600(surround)",2400,600 }
+};
+static const int	s_numVidModes = ( sizeof( r_vidModes ) / sizeof( r_vidModes[0] ) );
+
+qboolean R_GetModeInfo( int *width, int *height, int mode ) {
+	const vidmode_t	*vm;
+
+    if ( mode < -1 ) {
+        return qfalse;
+	}
+	if ( mode >= s_numVidModes ) {
+		return qfalse;
+	}
+
+	if ( mode == -1 ) {
+		*width = r_customwidth->integer;
+		*height = r_customheight->integer;
+		return qtrue;
+	}
+
+	vm = &r_vidModes[mode];
+
+    *width  = vm->width;
+    *height = vm->height;
+
+    return qtrue;
+}
+
+/*
+** R_ModeList_f
+*/
+static void R_ModeList_f( void )
+{
+	int i;
+
+	VID_Printf( PRINT_ALL, "\n" );
+	for ( i = 0; i < s_numVidModes; i++ )
+	{
+		VID_Printf( PRINT_ALL, "%s\n", r_vidModes[i].description );
+	}
+	VID_Printf( PRINT_ALL, "\n" );
+}
+
+#endif	// _XBOX
+
+/* 
+============================================================================== 
+ 
+						SCREEN SHOTS 
+ 
+============================================================================== 
+*/ 
+
+/* 
+================== 
+R_TakeScreenshot
+================== 
+*/  
+// "filename" param is something like "screenshots/shot0000.tga"
+//	note that if the last extension is ".jpg", then it'll save a JPG, else TGA
+//
+void R_TakeScreenshot( int x, int y, int width, int height, char *fileName ) {
+#ifndef _XBOX
+	byte		*buffer;
+	int			i, c, temp;
+
+	qboolean bSaveAsJPG = !strnicmp(&fileName[strlen(fileName)-4],".jpg",4);
+
+	if (bSaveAsJPG)
+	{
+		// JPG saver expects to be fed RGBA data, though it presumably ignores 'A'...
+		//
+		buffer = (unsigned char *) Z_Malloc(glConfig.vidWidth*glConfig.vidHeight*4, TAG_TEMP_WORKSPACE, qfalse);
+		qglReadPixels( x, y, width, height, GL_RGBA, GL_UNSIGNED_BYTE, buffer ); 
+
+		// gamma correct
+		if ( tr.overbrightBits>0 && glConfig.deviceSupportsGamma ) {
+			R_GammaCorrect( buffer, glConfig.vidWidth * glConfig.vidHeight * 4 );
+		}
+
+		SaveJPG(fileName, 95, width, height, buffer);
+	}
+	else
+	{
+		// TGA...
+		//
+		buffer = (unsigned char *) Z_Malloc(glConfig.vidWidth*glConfig.vidHeight*3 + 18, TAG_TEMP_WORKSPACE, qfalse);
+		memset (buffer, 0, 18);
+		buffer[2] = 2;		// uncompressed type
+		buffer[12] = width & 255;
+		buffer[13] = width >> 8;
+		buffer[14] = height & 255;
+		buffer[15] = height >> 8;
+		buffer[16] = 24;	// pixel size
+
+		qglReadPixels( x, y, width, height, GL_RGB, GL_UNSIGNED_BYTE, buffer+18 ); 
+
+		// swap rgb to bgr
+		c = 18 + width * height * 3;
+		for (i=18 ; i<c ; i+=3) {
+			temp = buffer[i];
+			buffer[i] = buffer[i+2];
+			buffer[i+2] = temp;
+		}
+
+		// gamma correct
+		if ( tr.overbrightBits>0 && glConfig.deviceSupportsGamma ) {
+			R_GammaCorrect( buffer + 18, glConfig.vidWidth * glConfig.vidHeight * 3 );
+		}
+		FS_WriteFile( fileName, buffer, c );
+	}
+	
+	Z_Free( buffer );
+#endif
+}
+
+/* 
+================== 
+R_ScreenshotFilename
+================== 
+*/  
+void R_ScreenshotFilename( int lastNumber, char *fileName, const char *psExt ) {
+	int		a,b,c,d;
+
+	if ( lastNumber < 0 || lastNumber > 9999 ) {
+		Com_sprintf( fileName, MAX_OSPATH, "screenshots/shot9999%s",psExt );
+		return;
+	}
+
+	a = lastNumber / 1000;
+	lastNumber -= a*1000;
+	b = lastNumber / 100;
+	lastNumber -= b*100;
+	c = lastNumber / 10;
+	lastNumber -= c*10;
+	d = lastNumber;
+
+	Com_sprintf( fileName, MAX_OSPATH, "screenshots/shot%i%i%i%i%s"
+		, a, b, c, d, psExt );
+}
+
+/*
+====================
+R_LevelShot
+
+levelshots are specialized 256*256 thumbnails for
+the menu system, sampled down from full screen distorted images
+====================
+*/
+#define LEVELSHOTSIZE 256
+void R_LevelShot( void ) {
+#ifndef _XBOX
+	char		checkname[MAX_OSPATH];
+	byte		*buffer;
+	byte		*source;
+	byte		*src, *dst;
+	int			x, y;
+	int			r, g, b;
+	float		xScale, yScale;
+	int			xx, yy;
+
+	sprintf( checkname, "levelshots/%s.tga", tr.worldDir + strlen("maps/") );
+
+	source = (byte*) Z_Malloc( glConfig.vidWidth * glConfig.vidHeight * 3, TAG_TEMP_WORKSPACE, qfalse );
+
+	buffer = (byte*) Z_Malloc( LEVELSHOTSIZE * LEVELSHOTSIZE*3 + 18, TAG_TEMP_WORKSPACE, qfalse );
+	memset (buffer, 0, 18);
+	buffer[2] = 2;		// uncompressed type
+	buffer[12] = LEVELSHOTSIZE & 255;
+	buffer[13] = LEVELSHOTSIZE >> 8;
+	buffer[14] = LEVELSHOTSIZE & 255;
+	buffer[15] = LEVELSHOTSIZE >> 8;
+	buffer[16] = 24;	// pixel size
+
+	qglReadPixels( 0, 0, glConfig.vidWidth, glConfig.vidHeight, GL_RGB, GL_UNSIGNED_BYTE, source ); 
+
+	// resample from source
+	xScale = glConfig.vidWidth / (4.0*LEVELSHOTSIZE);
+	yScale = glConfig.vidHeight / (3.0*LEVELSHOTSIZE);
+	for ( y = 0 ; y < LEVELSHOTSIZE ; y++ ) {
+		for ( x = 0 ; x < LEVELSHOTSIZE ; x++ ) {
+			r = g = b = 0;
+			for ( yy = 0 ; yy < 3 ; yy++ ) {
+				for ( xx = 0 ; xx < 4 ; xx++ ) {
+					src = source + 3 * ( glConfig.vidWidth * (int)( (y*3+yy)*yScale ) + (int)( (x*4+xx)*xScale ) );
+					r += src[0];
+					g += src[1];
+					b += src[2];
+				}
+			}
+			dst = buffer + 18 + 3 * ( y * LEVELSHOTSIZE + x );
+			dst[0] = b / 12;
+			dst[1] = g / 12;
+			dst[2] = r / 12;
+		}
+	}
+
+	// gamma correct
+	if ( glConfig.deviceSupportsGamma ) {
+		R_GammaCorrect( buffer + 18, LEVELSHOTSIZE * LEVELSHOTSIZE * 3 );
+	}
+
+	FS_WriteFile( checkname, buffer, LEVELSHOTSIZE * LEVELSHOTSIZE*3 + 18 );
+
+	Z_Free( buffer );
+	Z_Free( source );
+
+	VID_Printf( PRINT_ALL, "Wrote %s\n", checkname );
+#endif
+}
+
+/* 
+================== 
+R_ScreenShot_f
+
+screenshot
+screenshot [silent]
+screenshot [levelshot]
+screenshot [filename]
+
+Doesn't print the pacifier message if there is a second arg
+================== 
+*/  
+void R_ScreenShot_f (void) {
+#ifndef _XBOX
+	char		checkname[MAX_OSPATH];
+	int			len;
+	static	int	lastNumber = -1;
+	qboolean	silent;
+
+	if ( !strcmp( Cmd_Argv(1), "levelshot" ) ) {
+		R_LevelShot();
+		return;
+	}
+	if ( !strcmp( Cmd_Argv(1), "silent" ) ) {
+		silent = qtrue;
+	} else {
+		silent = qfalse;
+	}
+
+	if ( Cmd_Argc() == 2 && !silent ) {
+		// explicit filename
+		Com_sprintf( checkname, MAX_OSPATH, "screenshots/%s.jpg", Cmd_Argv( 1 ) );
+	} else {
+		// scan for a free filename
+
+		// if we have saved a previous screenshot, don't scan
+		// again, because recording demo avis can involve
+		// thousands of shots
+		if ( lastNumber == -1 ) {
+			// scan for a free number
+			for ( lastNumber = 0 ; lastNumber <= 9999 ; lastNumber++ ) {
+				R_ScreenshotFilename( lastNumber, checkname, ".jpg" );
+
+				len = FS_ReadFile( checkname, NULL );
+				if ( len <= 0 ) {
+					break;	// file doesn't exist
+				}
+			}
+		} else {
+			R_ScreenshotFilename( lastNumber, checkname, ".jpg" );
+		}
+
+		if ( lastNumber == 10000 ) {
+			VID_Printf (PRINT_ALL, "ScreenShot: Couldn't create a file\n"); 
+			return;
+ 		}
+
+		lastNumber++;
+	}
+
+
+	R_TakeScreenshot( 0, 0, glConfig.vidWidth, glConfig.vidHeight, checkname );
+
+	if ( !silent ) {
+		VID_Printf (PRINT_ALL, "Wrote %s\n", checkname);
+	}
+#endif
+} 
+
+
+
+/* 
+================== 
+R_ScreenShotTGA_f
+
+screenshot
+screenshot [silent]
+screenshot [levelshot]
+screenshot [filename]
+
+Doesn't print the pacifier message if there is a second arg
+================== 
+*/  
+void R_ScreenShotTGA_f (void) {
+#ifndef _XBOX
+	char		checkname[MAX_OSPATH];
+	int			len;
+	static	int	lastNumber = -1;
+	qboolean	silent;
+
+	if ( !strcmp( Cmd_Argv(1), "levelshot" ) ) {
+		R_LevelShot();
+		return;
+	}
+	if ( !strcmp( Cmd_Argv(1), "silent" ) ) {
+		silent = qtrue;
+	} else {
+		silent = qfalse;
+	}
+
+	if ( Cmd_Argc() == 2 && !silent ) {
+		// explicit filename
+		Com_sprintf( checkname, MAX_OSPATH, "screenshots/%s.tga", Cmd_Argv( 1 ) );
+	} else {
+		// scan for a free filename
+
+		// if we have saved a previous screenshot, don't scan
+		// again, because recording demo avis can involve
+		// thousands of shots
+		if ( lastNumber == -1 ) {
+			// scan for a free number
+			for ( lastNumber = 0 ; lastNumber <= 9999 ; lastNumber++ ) {
+				R_ScreenshotFilename( lastNumber, checkname, ".tga" );
+
+				len = FS_ReadFile( checkname, NULL );
+				if ( len <= 0 ) {
+					break;	// file doesn't exist
+				}
+			}
+		} else {
+			R_ScreenshotFilename( lastNumber, checkname, ".tga" );
+		}
+
+		if ( lastNumber == 10000 ) {
+			VID_Printf (PRINT_ALL, "ScreenShot: Couldn't create a file\n"); 
+			return;
+ 		}
+
+		lastNumber++;
+	}
+
+
+	R_TakeScreenshot( 0, 0, glConfig.vidWidth, glConfig.vidHeight, checkname );
+
+	if ( !silent ) {
+		VID_Printf (PRINT_ALL, "Wrote %s\n", checkname);
+	}
+#endif
+} 
+
+
+
+//============================================================================
+
+/*
+** GL_SetDefaultState
+*/
+void GL_SetDefaultState( void )
+{
+	qglClearDepth( 1.0f );
+
+	qglCullFace(GL_FRONT);
+
+	qglColor4f (1,1,1,1);
+
+	// initialize downstream texture unit if we're running
+	// in a multitexture environment
+	if ( qglActiveTextureARB ) {
+		GL_SelectTexture( 1 );
+		GL_TextureMode( r_textureMode->string );
+		GL_TexEnv( GL_MODULATE );
+		qglDisable( GL_TEXTURE_2D );
+		GL_SelectTexture( 0 );
+	}
+
+	qglEnable(GL_TEXTURE_2D);
+	GL_TextureMode( r_textureMode->string );
+	GL_TexEnv( GL_MODULATE );
+
+	qglShadeModel( GL_SMOOTH );
+	qglDepthFunc( GL_LEQUAL );
+
+	// the vertex array is always enabled, but the color and texture
+	// arrays are enabled and disabled around the compiled vertex array call
+	qglEnableClientState (GL_VERTEX_ARRAY);
+
+	//
+	// make sure our GL state vector is set correctly
+	//
+	glState.glStateBits = GLS_DEPTHTEST_DISABLE | GLS_DEPTHMASK_TRUE;
+
+	qglPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
+	qglDepthMask( GL_TRUE );
+	qglDisable( GL_DEPTH_TEST );
+	qglEnable( GL_SCISSOR_TEST );
+	qglDisable( GL_CULL_FACE );
+	qglDisable( GL_BLEND );
+	qglDisable( GL_ALPHA_TEST );
+	qglBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
+#ifdef _XBOX
+	qglDisable( GL_LIGHTING );
+#endif
+}
+
+
+/*
+================
+GfxInfo_f
+================
+*/
+void GfxInfo_f( void ) 
+{
+	cvar_t *sys_cpustring = Cvar_Get( "sys_cpustring", "", CVAR_ROM );
+	const char *enablestrings[] =
+	{
+		"disabled",
+		"enabled"
+	};
+	const char *fsstrings[] =
+	{
+		"windowed",
+		"fullscreen"
+	};
+
+	const char *tc_table[] = 
+	{
+		"None",
+		"GL_S3_s3tc",
+		"GL_EXT_texture_compression_s3tc",
+	};
+
+	VID_Printf( PRINT_ALL, "\nGL_VENDOR: %s\n", glConfig.vendor_string );
+	VID_Printf( PRINT_ALL, "GL_RENDERER: %s\n", glConfig.renderer_string );
+	VID_Printf( PRINT_ALL, "GL_VERSION: %s\n", glConfig.version_string );
+	VID_Printf( PRINT_ALL, "GL_EXTENSIONS: %s\n", glConfig.extensions_string );
+	VID_Printf( PRINT_ALL, "GL_MAX_TEXTURE_SIZE: %d\n", glConfig.maxTextureSize );
+	VID_Printf( PRINT_ALL, "GL_MAX_ACTIVE_TEXTURES_ARB: %d\n", glConfig.maxActiveTextures );
+	VID_Printf( PRINT_ALL, "\nPIXELFORMAT: color(%d-bits) Z(%d-bit) stencil(%d-bits)\n", glConfig.colorBits, glConfig.depthBits, glConfig.stencilBits );
+	VID_Printf( PRINT_ALL, "MODE: %d, %d x %d %s hz:", r_mode->integer, glConfig.vidWidth, glConfig.vidHeight, fsstrings[r_fullscreen->integer == 1] );
+	if ( glConfig.displayFrequency )
+	{
+		VID_Printf( PRINT_ALL, "%d\n", glConfig.displayFrequency );
+	}
+	else
+	{
+		VID_Printf( PRINT_ALL, "N/A\n" );
+	}
+	if ( glConfig.deviceSupportsGamma )
+	{
+		VID_Printf( PRINT_ALL, "GAMMA: hardware w/ %d overbright bits\n", tr.overbrightBits );
+	}
+	else
+	{
+		VID_Printf( PRINT_ALL, "GAMMA: software w/ %d overbright bits\n", tr.overbrightBits );
+	}
+	VID_Printf( PRINT_ALL, "CPU: %s\n", sys_cpustring->string );
+
+	// rendering primitives
+	{
+		int		primitives;
+
+		// default is to use triangles if compiled vertex arrays are present
+		VID_Printf( PRINT_ALL, "rendering primitives: " );
+		primitives = r_primitives->integer;
+		if ( primitives == 0 ) {
+			if ( qglLockArraysEXT ) {
+				primitives = 2;
+			} else {
+				primitives = 1;
+			}
+		}
+		if ( primitives == -1 ) {
+			VID_Printf( PRINT_ALL, "none\n" );
+		} else if ( primitives == 2 ) {
+			VID_Printf( PRINT_ALL, "single glDrawElements\n" );
+		} else if ( primitives == 1 ) {
+			VID_Printf( PRINT_ALL, "multiple glArrayElement\n" );
+		} else if ( primitives == 3 ) {
+			VID_Printf( PRINT_ALL, "multiple glColor4ubv + glTexCoord2fv + glVertex3fv\n" );
+		}
+	}
+
+	VID_Printf( PRINT_ALL, "texturemode: %s\n", r_textureMode->string );
+	VID_Printf( PRINT_ALL, "picmip: %d\n", r_picmip->integer );
+	VID_Printf( PRINT_ALL, "texture bits: %d\n", r_texturebits->integer );
+	VID_Printf( PRINT_ALL, "lightmap texture bits: %d\n", r_texturebitslm->integer );
+	VID_Printf( PRINT_ALL, "multitexture: %s\n", enablestrings[qglActiveTextureARB != 0] );
+	VID_Printf( PRINT_ALL, "compiled vertex arrays: %s\n", enablestrings[qglLockArraysEXT != 0 ] );
+	VID_Printf( PRINT_ALL, "texenv add: %s\n", enablestrings[glConfig.textureEnvAddAvailable != 0] );
+	VID_Printf( PRINT_ALL, "compressed textures: %s\n", enablestrings[glConfig.textureCompression != TC_NONE] );
+	VID_Printf( PRINT_ALL, "compressed lightmaps: %s\n", enablestrings[(r_ext_compressed_lightmaps->integer != 0 && glConfig.textureCompression != TC_NONE)] );
+	VID_Printf( PRINT_ALL, "texture compression method: %s\n", tc_table[glConfig.textureCompression] );
+	Com_Printf ("anisotropic filtering: %s  ", enablestrings[(r_ext_texture_filter_anisotropic->integer != 0) && glConfig.maxTextureFilterAnisotropy] );
+		Com_Printf ("(%f of %f)\n", r_ext_texture_filter_anisotropic->value, glConfig.maxTextureFilterAnisotropy );
+	Com_Printf ("Dynamic Glow: %s\n", enablestrings[r_DynamicGlow->integer] );
+
+	if ( r_finish->integer ) {
+		VID_Printf( PRINT_ALL, "Forcing glFinish\n" );
+	}
+	if ( r_displayRefresh ->integer ) {
+		VID_Printf( PRINT_ALL, "Display refresh set to %d\n", r_displayRefresh->integer );
+	}
+	if (tr.world)
+	{
+		VID_Printf( PRINT_ALL, "Light Grid size set to (%.2f %.2f %.2f)\n", tr.world->lightGridSize[0], tr.world->lightGridSize[1], tr.world->lightGridSize[2] );
+	}
+}
+
+
+/************************************************************************************************
+ * R_FogDistance_f                                                                              *
+ *    Console command to change the global fog opacity distance.  If you specify nothing on the *
+ *    command line, it will display the current fog opacity distance.  Specifying a float       *
+ *    representing the world units away the fog should be completely opaque will change the     *
+ *    value.                                                                                    *
+ *                                                                                              *
+ * Input                                                                                        *
+ *    none                                                                                      *
+ *                                                                                              *
+ * Output / Return                                                                              *
+ *    none                                                                                      *
+ *                                                                                              *
+ ************************************************************************************************/
+void R_FogDistance_f(void)
+{
+	float	distance;
+
+	if (!tr.world)
+	{
+		VID_Printf(PRINT_ALL, "R_FogDistance_f: World is not initialized\n");
+		return;
+	}
+
+	if (tr.world->globalFog == -1)
+	{
+		VID_Printf(PRINT_ALL, "R_FogDistance_f: World does not have a global fog\n");
+		return;
+	}
+
+	if (Cmd_Argc() <= 1)
+	{
+//		should not ever be 0.0
+//		if (tr.world->fogs[tr.world->globalFog].tcScale == 0.0)
+//		{
+//			distance = 0.0;
+//		}
+//		else
+		{
+			distance = 1.0 / (8.0 * tr.world->fogs[tr.world->globalFog].tcScale);
+		}
+
+		VID_Printf(PRINT_ALL, "R_FogDistance_f: Current Distance: %.0f\n", distance);
+		return;
+	}
+
+	if (Cmd_Argc() != 2)
+	{
+		VID_Printf(PRINT_ALL, "R_FogDistance_f: Invalid number of arguments to set distance\n");
+		return;
+	}
+
+	distance = atof(Cmd_Argv(1));
+	if (distance < 1.0) 
+	{
+		distance = 1.0;
+	}
+	tr.world->fogs[tr.world->globalFog].parms.depthForOpaque = distance;
+	tr.world->fogs[tr.world->globalFog].tcScale = 1.0 / ( distance * 8 );
+}
+
+/************************************************************************************************
+ * R_FogColor_f                                                                                 *
+ *    Console command to change the global fog color.  Specifying nothing on the command will   *
+ *    display the current global fog color.  Specifying a float R G B values between 0.0 and    *
+ *    1.0 will change the fog color.                                                            *
+ *                                                                                              *
+ * Input                                                                                        *
+ *    none                                                                                      *
+ *                                                                                              *
+ * Output / Return                                                                              *
+ *    none                                                                                      *
+ *                                                                                              *
+ ************************************************************************************************/
+void R_FogColor_f(void)
+{
+	if (!tr.world)
+	{
+		VID_Printf(PRINT_ALL, "R_FogColor_f: World is not initialized\n");
+		return;
+	}
+
+	if (tr.world->globalFog == -1)
+	{
+		VID_Printf(PRINT_ALL, "R_FogColor_f: World does not have a global fog\n");
+		return;
+	}
+
+	if (Cmd_Argc() <= 1)
+	{
+		unsigned	i = tr.world->fogs[tr.world->globalFog].colorInt;
+
+		VID_Printf(PRINT_ALL, "R_FogColor_f: Current Color: %0f %0f %0f\n",
+			( (byte *)&i )[0] / 255.0,
+			( (byte *)&i )[1] / 255.0,
+			( (byte *)&i )[2] / 255.0);
+		return;
+	}
+
+	if (Cmd_Argc() != 4)
+	{
+		VID_Printf(PRINT_ALL, "R_FogColor_f: Invalid number of arguments to set color\n");
+		return;
+	}
+
+	tr.world->fogs[tr.world->globalFog].parms.color[0] = atof(Cmd_Argv(1));
+	tr.world->fogs[tr.world->globalFog].parms.color[1] = atof(Cmd_Argv(2));
+	tr.world->fogs[tr.world->globalFog].parms.color[2] = atof(Cmd_Argv(3));
+	tr.world->fogs[tr.world->globalFog].colorInt = ColorBytes4 ( atof(Cmd_Argv(1)) * tr.identityLight, 
+			                          atof(Cmd_Argv(2)) * tr.identityLight, 
+			                          atof(Cmd_Argv(3)) * tr.identityLight, 1.0 );
+}
+
+/*
+===============
+R_Register
+===============
+*/
+void R_Register( void ) 
+{
+	//
+	// latched and archived variables
+	//
+	r_allowExtensions = Cvar_Get( "r_allowExtensions", "1", CVAR_ARCHIVE | CVAR_LATCH );
+	r_ext_compressed_textures = Cvar_Get( "r_ext_compress_textures", "1", CVAR_ARCHIVE | CVAR_LATCH );
+	r_ext_compressed_lightmaps = Cvar_Get( "r_ext_compress_lightmaps", "0", CVAR_ARCHIVE | CVAR_LATCH );
+	r_ext_preferred_tc_method = Cvar_Get( "r_ext_preferred_tc_method", "0", CVAR_ARCHIVE | CVAR_LATCH );
+	r_ext_gamma_control = Cvar_Get( "r_ext_gamma_control", "1", CVAR_ARCHIVE | CVAR_LATCH );
+	r_ext_multitexture = Cvar_Get( "r_ext_multitexture", "1", CVAR_ARCHIVE | CVAR_LATCH );
+	r_ext_compiled_vertex_array = Cvar_Get( "r_ext_compiled_vertex_array", "1", CVAR_ARCHIVE | CVAR_LATCH);
+	r_ext_texture_env_add = Cvar_Get( "r_ext_texture_env_add", "1", CVAR_ARCHIVE | CVAR_LATCH);
+	r_ext_texture_filter_anisotropic = Cvar_Get( "r_ext_texture_filter_anisotropic", "16", CVAR_ARCHIVE );
+ 
+	r_DynamicGlow = Cvar_Get( "r_DynamicGlow", "1", CVAR_ARCHIVE );
+	r_DynamicGlowPasses = Cvar_Get( "r_DynamicGlowPasses", "5", CVAR_CHEAT );
+	r_DynamicGlowDelta  = Cvar_Get( "r_DynamicGlowDelta", "0.8f", CVAR_CHEAT );
+	r_DynamicGlowIntensity = Cvar_Get( "r_DynamicGlowIntensity", "1.13f", CVAR_CHEAT );
+	r_DynamicGlowSoft = Cvar_Get( "r_DynamicGlowSoft", "1", CVAR_CHEAT );
+	r_DynamicGlowWidth = Cvar_Get( "r_DynamicGlowWidth", "320", CVAR_CHEAT | CVAR_LATCH );
+	r_DynamicGlowHeight = Cvar_Get( "r_DynamicGlowHeight", "240", CVAR_CHEAT | CVAR_LATCH );
+
+	// Register point sprite stuff here.
+	r_ext_point_parameters = Cvar_Get( "r_ext_point_parameters", "1", CVAR_ARCHIVE );
+	r_ext_nv_point_sprite = Cvar_Get( "r_ext_nv_point_sprite", "1", CVAR_ARCHIVE );
+
+	r_picmip = Cvar_Get ("r_picmip", "1", CVAR_ARCHIVE | CVAR_LATCH );
+	r_colorMipLevels = Cvar_Get ("r_colorMipLevels", "0", CVAR_LATCH );
+	AssertCvarRange( r_picmip, 0, 16, qtrue, qfalse );
+	r_detailTextures = Cvar_Get( "r_detailtextures", "1", CVAR_ARCHIVE | CVAR_LATCH );
+	r_texturebits = Cvar_Get( "r_texturebits", "0", CVAR_ARCHIVE | CVAR_LATCH );
+	r_texturebitslm = Cvar_Get( "r_texturebitslm", "0", CVAR_ARCHIVE | CVAR_LATCH );
+	r_colorbits = Cvar_Get( "r_colorbits", "0", CVAR_ARCHIVE | CVAR_LATCH );
+	r_stereo = Cvar_Get( "r_stereo", "0", CVAR_ARCHIVE | CVAR_LATCH );
+#ifdef __linux__
+	r_stencilbits = Cvar_Get( "r_stencilbits", "0", CVAR_ARCHIVE | CVAR_LATCH );
+#else
+	r_stencilbits = Cvar_Get( "r_stencilbits", "8", CVAR_ARCHIVE | CVAR_LATCH );
+#endif
+	r_depthbits = Cvar_Get( "r_depthbits", "0", CVAR_ARCHIVE | CVAR_LATCH );
+	r_overBrightBits = Cvar_Get ("r_overBrightBits", "0", CVAR_ARCHIVE | CVAR_LATCH );
+	r_ignorehwgamma = Cvar_Get( "r_ignorehwgamma", "0", CVAR_ARCHIVE | CVAR_LATCH);
+	r_mode = Cvar_Get( "r_mode", "4", CVAR_ARCHIVE | CVAR_LATCH );
+	r_fullscreen = Cvar_Get( "r_fullscreen", "1", CVAR_ARCHIVE | CVAR_LATCH );
+	r_customwidth = Cvar_Get( "r_customwidth", "1600", CVAR_ARCHIVE | CVAR_LATCH );
+	r_customheight = Cvar_Get( "r_customheight", "1024", CVAR_ARCHIVE | CVAR_LATCH );
+	r_simpleMipMaps = Cvar_Get( "r_simpleMipMaps", "1", CVAR_ARCHIVE | CVAR_LATCH );
+	r_vertexLight = Cvar_Get( "r_vertexLight", "0", CVAR_ARCHIVE | CVAR_LATCH );
+	r_subdivisions = Cvar_Get ("r_subdivisions", "4", CVAR_ARCHIVE | CVAR_LATCH);
+	r_intensity = Cvar_Get ("r_intensity", "1", CVAR_LATCH|CVAR_ARCHIVE );
+	
+	//
+	// temporary latched variables that can only change over a restart
+	//
+	r_displayRefresh = Cvar_Get( "r_displayRefresh", "0", CVAR_LATCH );
+	AssertCvarRange( r_displayRefresh, 0, 200, qtrue, qfalse );
+	r_fullbright = Cvar_Get ("r_fullbright", "0", CVAR_CHEAT );
+	r_singleShader = Cvar_Get ("r_singleShader", "0", CVAR_CHEAT | CVAR_LATCH );
+
+	//
+	// archived variables that can change at any time
+	//
+	r_lodCurveError = Cvar_Get( "r_lodCurveError", "250", CVAR_ARCHIVE );
+	r_lodbias = Cvar_Get( "r_lodbias", "0", CVAR_ARCHIVE );
+	r_flares = Cvar_Get ("r_flares", "1", CVAR_ARCHIVE );
+	r_lodscale = Cvar_Get( "r_lodscale", "10", CVAR_ARCHIVE );
+
+#ifdef _XBOX
+	r_znear = Cvar_Get( "r_znear", "2", CVAR_CHEAT );	//lose a lot of precision in the distance
+#else
+	r_znear = Cvar_Get( "r_znear", "4", CVAR_CHEAT );	//if set any lower, you lose a lot of precision in the distance
+#endif
+	AssertCvarRange( r_znear, 0.001f, 200, qfalse, qfalse );
+	r_ignoreGLErrors = Cvar_Get( "r_ignoreGLErrors", "1", CVAR_ARCHIVE );
+	r_fastsky = Cvar_Get( "r_fastsky", "0", CVAR_ARCHIVE );
+	r_drawSun = Cvar_Get( "r_drawSun", "0", CVAR_ARCHIVE );
+	r_dynamiclight = Cvar_Get( "r_dynamiclight", "1", CVAR_ARCHIVE );
+	r_dlightBacks = Cvar_Get( "r_dlightBacks", "0", CVAR_ARCHIVE );
+	r_finish = Cvar_Get ("r_finish", "0", CVAR_ARCHIVE);
+	r_textureMode = Cvar_Get( "r_textureMode", "GL_LINEAR_MIPMAP_NEAREST", CVAR_ARCHIVE );
+	r_swapInterval = Cvar_Get( "r_swapInterval", "0", CVAR_ARCHIVE );
+#ifdef __MACOS__
+	r_gamma = Cvar_Get( "r_gamma", "1.2", CVAR_ARCHIVE );
+#else
+	r_gamma = Cvar_Get( "r_gamma", "1", CVAR_ARCHIVE );
+#endif
+	r_facePlaneCull = Cvar_Get ("r_facePlaneCull", "1", CVAR_ARCHIVE );
+
+	r_dlightStyle = Cvar_Get ("r_dlightStyle", "1", CVAR_TEMP);
+	r_surfaceSprites = Cvar_Get ("r_surfaceSprites", "1", CVAR_TEMP);
+	r_surfaceWeather = Cvar_Get ("r_surfaceWeather", "0", CVAR_TEMP);
+
+	r_windSpeed = Cvar_Get ("r_windSpeed", "0", 0);
+	r_windAngle = Cvar_Get ("r_windAngle", "0", 0);
+	r_windGust = Cvar_Get ("r_windGust", "0", 0);
+	r_windDampFactor = Cvar_Get ("r_windDampFactor", "0.1", 0);
+	r_windPointForce = Cvar_Get ("r_windPointForce", "0", 0);
+	r_windPointX = Cvar_Get ("r_windPointX", "0", 0);
+	r_windPointY = Cvar_Get ("r_windPointY", "0", 0);
+
+	r_primitives = Cvar_Get( "r_primitives", "0", CVAR_ARCHIVE );
+
+	r_ambientScale = Cvar_Get( "r_ambientScale", "0.5", CVAR_CHEAT );
+	r_directedScale = Cvar_Get( "r_directedScale", "1", CVAR_CHEAT );
+
+	//
+	// temporary variables that can change at any time
+	//
+	r_showImages = Cvar_Get( "r_showImages", "0", CVAR_CHEAT );
+
+	r_debugLight = Cvar_Get( "r_debuglight", "0", CVAR_TEMP );
+	r_debugStyle = Cvar_Get( "r_debugStyle", "-1", CVAR_CHEAT );
+	r_debugSort = Cvar_Get( "r_debugSort", "0", CVAR_CHEAT );
+
+	r_nocurves = Cvar_Get ("r_nocurves", "0", CVAR_CHEAT );
+	r_drawworld = Cvar_Get ("r_drawworld", "1", CVAR_CHEAT );
+	r_drawfog = Cvar_Get ("r_drawfog", "2", CVAR_CHEAT );
+	r_lightmap = Cvar_Get ("r_lightmap", "0", CVAR_CHEAT );
+	r_portalOnly = Cvar_Get ("r_portalOnly", "0", CVAR_CHEAT );
+
+	r_skipBackEnd = Cvar_Get ("r_skipBackEnd", "0", CVAR_CHEAT);
+
+	r_measureOverdraw = Cvar_Get( "r_measureOverdraw", "0", CVAR_CHEAT );
+	r_norefresh = Cvar_Get ("r_norefresh", "0", CVAR_CHEAT);
+	r_drawentities = Cvar_Get ("r_drawentities", "1", CVAR_CHEAT );
+	r_ignore = Cvar_Get( "r_ignore", "1", CVAR_TEMP );
+	r_nocull = Cvar_Get ("r_nocull", "0", CVAR_CHEAT);
+	r_novis = Cvar_Get ("r_novis", "0", CVAR_CHEAT);
+	r_showcluster = Cvar_Get ("r_showcluster", "0", CVAR_CHEAT);
+	r_speeds = Cvar_Get ("r_speeds", "0", CVAR_CHEAT);
+	r_verbose = Cvar_Get( "r_verbose", "0", CVAR_CHEAT );
+	r_logFile = Cvar_Get( "r_logFile", "0", CVAR_CHEAT );
+	r_debugSurface = Cvar_Get ("r_debugSurface", "0", CVAR_CHEAT);
+	r_nobind = Cvar_Get ("r_nobind", "0", CVAR_CHEAT);
+	r_showtris = Cvar_Get ("r_showtris", "0", CVAR_CHEAT);
+	r_showtriscolor = Cvar_Get ("r_showtriscolor", "0", CVAR_ARCHIVE);
+	r_showsky = Cvar_Get ("r_showsky", "0", CVAR_CHEAT);
+	r_shownormals = Cvar_Get ("r_shownormals", "0", CVAR_CHEAT);
+	r_clear = Cvar_Get ("r_clear", "0", CVAR_CHEAT);
+	r_offsetFactor = Cvar_Get( "r_offsetfactor", "-1", CVAR_CHEAT );
+	r_offsetUnits = Cvar_Get( "r_offsetunits", "-2", CVAR_CHEAT );
+	r_lockpvs = Cvar_Get ("r_lockpvs", "0", CVAR_CHEAT);
+	r_noportals = Cvar_Get ("r_noportals", "0", CVAR_CHEAT);
+	r_shadows = Cvar_Get( "cg_shadows", "1", 0 );
+	r_shadowRange = Cvar_Get( "r_shadowRange", "1000", CVAR_ARCHIVE );
+
+#ifdef _XBOX
+	r_hdreffect = Cvar_Get( "r_hdreffect", "0", 0 );
+	r_sundir_x = Cvar_Get( "r_sundir_x", "0.45", 0 );
+	r_sundir_y = Cvar_Get( "r_sundir_y", "0.3", 0 );
+	r_sundir_z = Cvar_Get( "r_sundir_z", "0.9", 0 );
+	r_hdrbloom = Cvar_Get( "r_hdrbloom", "1.0", 0 );
+	r_hdrcutoff = Cvar_Get( "r_hdrcutoff", "0.5", 0 );
+#endif
+/*
+Ghoul2 Insert Start
+*/
+	r_noGhoul2 = Cvar_Get( "r_noghoul2", "0", CVAR_CHEAT);
+	r_Ghoul2AnimSmooth = Cvar_Get( "r_ghoul2animsmooth", "0.25", 0);
+	r_Ghoul2UnSqash = Cvar_Get( "r_ghoul2unsquash", "1", 0);
+	r_Ghoul2TimeBase = Cvar_Get( "r_ghoul2timebase", "2", 0);
+	r_Ghoul2NoLerp = Cvar_Get( "r_ghoul2nolerp", "0", 0);
+	r_Ghoul2NoBlend = Cvar_Get( "r_ghoul2noblend", "0", 0);
+	r_Ghoul2BlendMultiplier = Cvar_Get( "r_ghoul2blendmultiplier", "1", 0);
+	r_Ghoul2UnSqashAfterSmooth = Cvar_Get( "r_ghoul2unsquashaftersmooth", "1", 0);
+
+	broadsword = Cvar_Get( "broadsword", "1", 0);
+	broadsword_kickbones = Cvar_Get( "broadsword_kickbones", "1", 0);
+	broadsword_kickorigin = Cvar_Get( "broadsword_kickorigin", "1", 0);
+	broadsword_dontstopanim = Cvar_Get( "broadsword_dontstopanim", "0", 0);
+	broadsword_waitforshot = Cvar_Get( "broadsword_waitforshot", "0", 0);
+	broadsword_playflop = Cvar_Get( "broadsword_playflop", "1", 0);
+	broadsword_smallbbox = Cvar_Get( "broadsword_smallbbox", "0", 0);
+	broadsword_extra1 = Cvar_Get( "broadsword_extra1", "0", 0);
+	broadsword_extra2 = Cvar_Get( "broadsword_extra2", "0", 0);
+	broadsword_effcorr = Cvar_Get( "broadsword_effcorr", "1", 0);
+	broadsword_ragtobase = Cvar_Get( "broadsword_ragtobase", "2", 0);
+	broadsword_dircap = Cvar_Get( "broadsword_dircap", "64", 0);
+
+/*
+Ghoul2 Insert End
+*/
+extern qboolean Sys_LowPhysicalMemory();
+	r_modelpoolmegs = Cvar_Get("r_modelpoolmegs", "20", CVAR_ARCHIVE);
+	if (Sys_LowPhysicalMemory() )
+	{
+		Cvar_Set("r_modelpoolmegs", "0");
+	}
+
+	// make sure all the commands added here are also
+	// removed in R_Shutdown
+	Cmd_AddCommand( "imagelist", R_ImageList_f );
+	Cmd_AddCommand( "shaderlist", R_ShaderList_f );
+	Cmd_AddCommand( "skinlist", R_SkinList_f );
+	Cmd_AddCommand( "modellist", R_Modellist_f );
+#ifndef _XBOX
+	Cmd_AddCommand( "modelist", R_ModeList_f );
+#endif
+	Cmd_AddCommand( "screenshot", R_ScreenShot_f );
+	Cmd_AddCommand( "screenshot_tga", R_ScreenShotTGA_f );
+	Cmd_AddCommand( "gfxinfo", GfxInfo_f );
+	Cmd_AddCommand( "r_fogDistance", R_FogDistance_f);
+	Cmd_AddCommand( "r_fogColor", R_FogColor_f);
+	Cmd_AddCommand( "modelcacheinfo", RE_RegisterModels_Info_f);
+	Cmd_AddCommand( "imagecacheinfo", RE_RegisterImages_Info_f);
+extern void R_WorldEffect_f(void);	//TR_WORLDEFFECTS.CPP
+	Cmd_AddCommand( "r_we", R_WorldEffect_f );
+extern void R_ReloadFonts_f(void);
+	Cmd_AddCommand( "r_reloadfonts", R_ReloadFonts_f );
+	// make sure all the commands added above are also
+	// removed in R_Shutdown
+}
+
+// need to do this hackery so ghoul2 doesn't crash the game because of ITS hackery...
+//
+void R_ClearStuffToStopGhoul2CrashingThings(void)
+{
+	memset( &tr, 0, sizeof( tr ) );
+}
+
+/*
+===============
+R_Init
+===============
+*/
+extern void R_InitWorldEffects();
+void R_Init( void ) {	
+	int	err;
+	int i;
+
+	//VID_Printf( PRINT_ALL, "----- R_Init -----\n" );
+#ifdef _XBOX
+	extern qboolean vidRestartReloadMap;
+	if (!vidRestartReloadMap)
+	{
+		Hunk_Clear();
+		
+		extern void CM_Free(void);
+		CM_Free();
+		
+		void CM_CleanLeafCache(void);
+		CM_CleanLeafCache();
+	}
+#endif
+
+	ShaderEntryPtrs_Clear();
+
+#ifdef _XBOX
+	//Save visibility info as it has already been set.
+	SPARC<byte> *vis = tr.externalVisData;
+#endif
+
+	// clear all our internal state
+	memset( &tr, 0, sizeof( tr ) );
+	memset( &backEnd, 0, sizeof( backEnd ) );
+	memset( &tess, 0, sizeof( tess ) );
+
+#ifdef _XBOX
+	//Restore visibility info.
+	tr.externalVisData = vis;
+#endif
+
+	Swap_Init();
+
+#ifndef FINAL_BUILD
+	if ( (int)tess.xyz & 15 ) {
+		Com_Printf( "WARNING: tess.xyz not 16 byte aligned (%x)\n",(int)tess.xyz & 15 );
+	}
+#endif
+
+	//
+	// init function tables
+	//
+	for ( i = 0; i < FUNCTABLE_SIZE; i++ )
+	{
+		tr.sinTable[i]		= sin( DEG2RAD( i * 360.0f / ( ( float ) ( FUNCTABLE_SIZE - 1 ) ) ) );
+		tr.squareTable[i]	= ( i < FUNCTABLE_SIZE/2 ) ? 1.0f : -1.0f;
+		tr.sawToothTable[i] = (float)i / FUNCTABLE_SIZE;
+		tr.inverseSawToothTable[i] = 1.0 - tr.sawToothTable[i];
+
+		if ( i < FUNCTABLE_SIZE / 2 )
+		{
+			if ( i < FUNCTABLE_SIZE / 4 )
+			{
+				tr.triangleTable[i] = ( float ) i / ( FUNCTABLE_SIZE / 4 );
+			}
+			else
+			{
+				tr.triangleTable[i] = 1.0f - tr.triangleTable[i-FUNCTABLE_SIZE / 4];
+			}
+		}
+		else
+		{
+			tr.triangleTable[i] = -tr.triangleTable[i-FUNCTABLE_SIZE/2];
+		}
+	}
+
+	R_InitFogTable();
+
+	R_NoiseInit();
+
+	R_Register();
+
+	backEndData = (backEndData_t *) Hunk_Alloc( sizeof( backEndData_t ), qtrue );
+	R_ToggleSmpFrame();	//r_smp
+
+	const color4ub_t	color = {0xff, 0xff, 0xff, 0xff};
+	for(i=0;i<MAX_LIGHT_STYLES;i++)
+	{
+		RE_SetLightStyle(i, *(int*)color);
+	}
+
+	InitOpenGL();
+
+	R_InitImages();
+	R_InitShaders();
+	R_InitSkins();
+#ifndef _XBOX
+	R_TerrainInit();
+#endif
+	R_ModelInit();
+//	R_InitWorldEffects();
+	R_InitFonts();
+
+	err = qglGetError();
+	if ( err != GL_NO_ERROR )
+		VID_Printf (PRINT_ALL, "glGetError() = 0x%x\n", err);
+
+	//VID_Printf( PRINT_ALL, "----- finished R_Init -----\n" );
+}
+
+/*
+===============
+RE_Shutdown
+===============
+*/
+extern void R_ShutdownWorldEffects(void);
+void RE_Shutdown( qboolean destroyWindow ) {	
+	//VID_Printf( PRINT_ALL, "RE_Shutdown( %i )\n", destroyWindow );
+
+	Cmd_RemoveCommand ("imagelist");
+	Cmd_RemoveCommand ("shaderlist");
+	Cmd_RemoveCommand ("skinlist");
+	Cmd_RemoveCommand ("modellist");
+	Cmd_RemoveCommand ("modelist" );
+	Cmd_RemoveCommand ("screenshot");
+	Cmd_RemoveCommand ("screenshot_tga");	
+	Cmd_RemoveCommand ("gfxinfo");
+	Cmd_RemoveCommand ("r_fogDistance");
+	Cmd_RemoveCommand ("r_fogColor");
+	Cmd_RemoveCommand ("modelcacheinfo");
+	Cmd_RemoveCommand ("imagecacheinfo");
+	Cmd_RemoveCommand ("r_we");
+	Cmd_RemoveCommand ("r_reloadfonts");
+
+	R_ShutdownWorldEffects();
+#ifndef _XBOX
+	R_TerrainShutdown();
+#endif
+	R_ShutdownFonts();
+
+	if ( tr.registered ) {
+#ifndef _XBOX	// GLOWXXX
+		if ( r_DynamicGlow && r_DynamicGlow->integer )
+		{
+			// Release the Glow Vertex Shader.
+			if ( tr.glowVShader )
+			{
+				qglDeleteProgramsARB( 1, &tr.glowVShader );
+			}
+
+			// Release Pixel Shader.
+			if ( tr.glowPShader )
+			{
+				if ( qglCombinerParameteriNV  )
+				{
+					// Release the Glow Regcom call list.
+					qglDeleteLists( tr.glowPShader, 1 );
+				}
+				else if ( qglGenProgramsARB )
+				{
+					// Release the Glow Fragment Shader.
+					qglDeleteProgramsARB( 1, &tr.glowPShader );
+				}
+			}
+
+			// Release the scene glow texture.
+			qglDeleteTextures( 1, &tr.screenGlow );
+
+			// Release the scene texture.
+			qglDeleteTextures( 1, &tr.sceneImage );
+
+			// Release the blur texture.
+			qglDeleteTextures( 1, &tr.blurImage );
+		}
+#endif
+//		R_SyncRenderThread();
+		R_ShutdownCommandBuffers();
+//#ifndef _XBOX
+		if (destroyWindow)
+//#endif
+		{
+			R_DeleteTextures();	// only do this for vid_restart now, not during things like map load
+		}
+	}
+
+	// shut down platform specific OpenGL stuff
+	if ( destroyWindow ) {
+		GLimp_Shutdown();
+	}
+	tr.registered = qfalse;
+}
+
+/*
+=============
+RE_EndRegistration
+
+Touch all images to make sure they are resident
+=============
+*/
+extern qboolean Sys_LowPhysicalMemory();
+void	RE_EndRegistration( void ) {
+	R_SyncRenderThread();
+	if (!Sys_LowPhysicalMemory()) {
+#ifndef _XBOX
+//		RB_ShowImages();
+#endif
+	}
+}
+
+
+void RE_GetLightStyle(int style, color4ub_t color)
+{
+	if (style >= MAX_LIGHT_STYLES)
+	{
+	    Com_Error( ERR_FATAL, "RE_GetLightStyle: %d is out of range", (int)style );
+		return;
+	}
+
+	*(int *)color = *(int *)styleColors[style];
+}
+
+void RE_SetLightStyle(int style, int color)
+{
+	if (style >= MAX_LIGHT_STYLES)
+	{
+	    Com_Error( ERR_FATAL, "RE_SetLightStyle: %d is out of range", (int)style );
+		return;
+	}
+
+	if (*(int*)styleColors[style] != color)
+	{
+		*(int *)styleColors[style] = color;
+		styleUpdated[style] = true;
+	}
+}
+
+
+/*
+@@@@@@@@@@@@@@@@@@@@@
+GetRefAPI
+
+@@@@@@@@@@@@@@@@@@@@@
+*/
+extern void R_WorldEffectCommand(const char *command);
+refexport_t *GetRefAPI ( int apiVersion ) {
+	static refexport_t	re;
+
+	memset( &re, 0, sizeof( re ) );
+
+	if ( apiVersion != REF_API_VERSION ) {
+		VID_Printf(PRINT_ALL, "Mismatched REF_API_VERSION: expected %i, got %i\n", 
+			REF_API_VERSION, apiVersion );
+		return NULL;
+	}
+
+	// the RE_ functions are Renderer Entry points
+
+	re.Shutdown = RE_Shutdown;
+
+	re.BeginRegistration = RE_BeginRegistration;
+	re.RegisterModel = RE_RegisterModel;
+	re.RegisterSkin = RE_RegisterSkin;
+	re.GetAnimationCFG = RE_GetAnimationCFG;
+	re.RegisterShader = RE_RegisterShader;
+	re.RegisterShaderNoMip = RE_RegisterShaderNoMip;
+	re.LoadWorld = RE_LoadWorldMap;
+	re.SetWorldVisData = RE_SetWorldVisData;
+	re.EndRegistration = RE_EndRegistration;
+
+	re.RegisterMedia_LevelLoadBegin = RE_RegisterMedia_LevelLoadBegin;
+	re.RegisterMedia_LevelLoadEnd   = RE_RegisterMedia_LevelLoadEnd;
+
+	re.BeginFrame = RE_BeginFrame;
+	re.EndFrame = RE_EndFrame;
+
+	re.ProcessDissolve = RE_ProcessDissolve;
+	re.InitDissolve = RE_InitDissolve;
+
+	re.MarkFragments = R_MarkFragments;
+	re.LerpTag = R_LerpTag;
+	re.ModelBounds = R_ModelBounds;
+
+	re.ClearScene = RE_ClearScene;
+	re.AddRefEntityToScene = RE_AddRefEntityToScene;
+	re.GetLighting = RE_GetLighting;
+	re.AddPolyToScene = RE_AddPolyToScene;
+	re.AddLightToScene = RE_AddLightToScene;
+	re.RenderScene = RE_RenderScene;
+
+	re.SetColor = RE_SetColor;
+	re.DrawStretchPic = RE_StretchPic;
+	re.DrawStretchRaw = RE_StretchRaw;
+	re.UploadCinematic = RE_UploadCinematic;
+
+	re.DrawRotatePic = RE_RotatePic;
+	re.DrawRotatePic2 = RE_RotatePic2;
+	re.LAGoggles = RE_LAGoggles;
+	re.Scissor = RE_Scissor;
+
+	re.GetScreenShot = RE_GetScreenShot;
+#ifndef _XBOX
+	re.TempRawImage_ReadFromFile = RE_TempRawImage_ReadFromFile;
+#endif
+	re.TempRawImage_CleanUp = RE_TempRawImage_CleanUp;
+
+	re.GetLightStyle = RE_GetLightStyle;
+	re.SetLightStyle = RE_SetLightStyle;
+	re.WorldEffectCommand = R_WorldEffectCommand;
+
+	re.GetBModelVerts = RE_GetBModelVerts;
+
+	re.RegisterFont = RE_RegisterFont;
+#ifndef _XBOX
+	re.Font_StrLenPixels = RE_Font_StrLenPixels;
+	re.Font_HeightPixels = RE_Font_HeightPixels;	
+	re.Font_DrawString = RE_Font_DrawString;
+#endif
+	re.Font_StrLenChars = RE_Font_StrLenChars;
+	re.Language_IsAsian = Language_IsAsian;
+	re.Language_UsesSpaces = Language_UsesSpaces;
+	re.AnyLanguage_ReadCharFromString = AnyLanguage_ReadCharFromString;
+
+	return &re;
+}
+
diff --git a/code/renderer/tr_jpeg_interface.cpp b/code/renderer/tr_jpeg_interface.cpp
new file mode 100644
index 0000000..55efb88
--- /dev/null
+++ b/code/renderer/tr_jpeg_interface.cpp
@@ -0,0 +1,541 @@
+// Filename:-	tr_jpeg_interace.cpp
+//
+
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+
+
+#include "tr_local.h"
+#include "tr_jpeg_interface.h"
+
+/*
+ * Include file for users of JPEG library.
+ * You will need to have included system headers that define at least
+ * the typedefs FILE and size_t before you can include jpeglib.h.
+ * (stdio.h is sufficient on ANSI-conforming systems.)
+ * You may also wish to include "jerror.h".
+ */
+
+#define JPEG_INTERNALS
+#include "../jpeg-6/jpeglib.h"
+
+// JPG decompression now subroutinised so I can call it from the savegame stuff...
+//
+// (note, the param "byte* pJPGData" should be a malloc of 4K more than the JPG data because the decompressor will read 
+//	up to 4K beyond what's actually presented during decompression).
+//	
+// This will Z_Malloc the output data buffer that gets fed back into "pic", so Z_Free it yourself later.
+//
+void Decompress_JPG( const char *filename, byte *pJPGData, unsigned char **pic, int *width, int *height ) 
+{
+	/* This struct contains the JPEG decompression parameters and pointers to
+	* working space (which is allocated as needed by the JPEG library).
+	*/
+	struct jpeg_decompress_struct cinfo;
+	/* We use our private extension JPEG error handler.
+	* Note that this struct must live as long as the main JPEG parameter
+	* struct, to avoid dangling-pointer problems.
+	*/
+	/* This struct represents a JPEG error handler.  It is declared separately
+	* because applications often want to supply a specialized error handler
+	* (see the second half of this file for an example).  But here we just
+	* take the easy way out and use the standard error handler, which will
+	* print a message on stderr and call exit() if compression fails.
+	* Note that this struct must live as long as the main JPEG parameter
+	* struct, to avoid dangling-pointer problems.
+	*/
+	struct jpeg_error_mgr jerr;
+	/* More stuff */
+	JSAMPARRAY buffer;		/* Output row buffer */
+	int row_stride;		/* physical row width in output buffer */
+	unsigned char *out;	
+	byte  *bbuf;
+	
+	/* Step 1: allocate and initialize JPEG decompression object */
+	
+	/* We have to set up the error handler first, in case the initialization
+	   * step fails.  (Unlikely, but it could happen if you are out of memory.)
+	   * This routine fills in the contents of struct jerr, and returns jerr's
+	   * address which we place into the link field in cinfo.
+	   */
+	cinfo.err = jpeg_std_error(&jerr);
+	
+	/* Now we can initialize the JPEG decompression object. */
+	jpeg_create_decompress(&cinfo);
+	
+	/* Step 2: specify data source (eg, a file) */
+	
+	jpeg_stdio_src(&cinfo, pJPGData);
+	
+	/* Step 3: read file parameters with jpeg_read_header() */
+	
+	(void) jpeg_read_header(&cinfo, TRUE);
+	/* We can ignore the return value from jpeg_read_header since
+	   *   (a) suspension is not possible with the stdio data source, and
+	   *   (b) we passed TRUE to reject a tables-only JPEG file as an error.
+	   * See libjpeg.doc for more info.
+	   */
+	
+	/* Step 4: set parameters for decompression */
+	
+	/* In this example, we don't need to change any of the defaults set by
+	   * jpeg_read_header(), so we do nothing here.
+	   */
+	
+	/* Step 5: Start decompressor */
+	
+	(void) jpeg_start_decompress(&cinfo);
+	/* We can ignore the return value since suspension is not possible
+	   * with the stdio data source.
+	   */
+	
+	   /* We may need to do some setup of our own at this point before reading
+	   * the data.  After jpeg_start_decompress() we have the correct scaled
+	   * output image dimensions available, as well as the output colormap
+	   * if we asked for color quantization.
+	   * In this example, we need to make an output work buffer of the right size.
+	   */ 
+	/* JSAMPLEs per row in output buffer */
+	row_stride = cinfo.output_width * cinfo.output_components;
+	
+	if (cinfo.output_components!=4 && cinfo.output_components!=1 ) {
+		VID_Printf(PRINT_WARNING, "JPG %s is unsupported color depth (%d)\n", filename, cinfo.output_components);
+	}
+	out = (byte *)Z_Malloc(cinfo.output_width*cinfo.output_height*4, TAG_TEMP_JPG, qfalse );
+	
+	*pic = out;
+	*width = cinfo.output_width;
+	*height = cinfo.output_height;
+	
+	/* Step 6: while (scan lines remain to be read) */
+	/*           jpeg_read_scanlines(...); */
+	
+	/* Here we use the library's state variable cinfo.output_scanline as the
+	   * loop counter, so that we don't have to keep track ourselves.
+	   */
+	while (cinfo.output_scanline < cinfo.output_height) {
+	/* jpeg_read_scanlines expects an array of pointers to scanlines.
+	* Here the array is only one element long, but you could ask for
+	* more than one scanline at a time if that's more convenient.
+		*/
+		bbuf = ((out+(row_stride*cinfo.output_scanline)));
+		buffer = &bbuf;
+		(void) jpeg_read_scanlines(&cinfo, buffer, 1);
+	}
+	
+	// if we've just loaded a greyscale, then adjust it from 8-bit to 32bit by stretch-copying it over itself...
+	//  (this also does the alpha stuff as well)
+	//
+	if (cinfo.output_components == 1)
+	{
+		byte *pbDest = (*pic + (cinfo.output_width * cinfo.output_height * 4))-1;
+		byte *pbSrc  = (*pic + (cinfo.output_width * cinfo.output_height    ))-1;
+		int  iPixels = cinfo.output_width * cinfo.output_height;
+		
+		for (int i=0; i<iPixels; i++)
+		{
+			byte b = *pbSrc--;
+			*pbDest-- = 255;
+			*pbDest-- = b;
+			*pbDest-- = b;
+			*pbDest-- = b;
+		}
+	}
+	else	  
+	{// clear all the alphas to 255
+		int	i, j;
+		byte	*buf;
+		
+		buf = *pic;
+		
+		j = cinfo.output_width * cinfo.output_height * 4;
+		for ( i = 3 ; i < j ; i+=4 ) {
+			buf[i] = 255;
+		}
+	}
+	
+	/* Step 7: Finish decompression */
+	
+	(void) jpeg_finish_decompress(&cinfo);
+	/* We can ignore the return value since suspension is not possible
+	   * with the stdio data source.
+	   */
+	
+	/* Step 8: Release JPEG decompression object */
+	
+	/* This is an important step since it will release a good deal of memory. */
+	jpeg_destroy_decompress(&cinfo);
+	
+	/* After finish_decompress, we can close the input file.
+	* Here we postpone it until after no more JPEG errors are possible,
+	* so as to simplify the setjmp error logic above.  (Actually, I don't
+	* think that jpeg_destroy can do an error exit, but why assume anything...)
+	*/
+	
+	/* At this point you may want to check to see whether any corrupt-data
+	* warnings occurred (test whether jerr.pub.num_warnings is nonzero).
+	*/
+	
+	/* And we're done! */
+}
+
+int LoadJPG( const char *filename, unsigned char **pic, int *width, int *height ) 
+{	
+	*pic = NULL;	
+	
+	fileHandle_t	h;
+	const int len = FS_FOpenFileRead( filename, &h, qfalse );
+	if(!h)
+	{
+		return 0;
+	}
+	//JPEG system reads 4K past input buffer so we tack on an additional 4k.
+	byte *pJPGData = (byte *)Z_Malloc(len + 4096, TAG_TEMP_JPG, qfalse);
+	FS_Read(pJPGData, len, h);
+	FS_FCloseFile( h );
+
+	Decompress_JPG( filename, pJPGData, pic, width, height );
+
+	Z_Free (pJPGData);
+	return len;
+}
+
+
+/* Expanded data destination object for stdio output */
+
+typedef struct {
+  struct jpeg_destination_mgr pub; /* public fields */
+
+  byte* outfile;		/* target stream */
+  int	size;
+} my_destination_mgr;
+
+typedef my_destination_mgr * my_dest_ptr;
+
+
+/*
+ * Initialize destination --- called by jpeg_start_compress
+ * before any data is actually written.
+ */
+
+void init_destination (j_compress_ptr cinfo)
+{
+  my_dest_ptr dest = (my_dest_ptr) cinfo->dest;
+
+  dest->pub.next_output_byte = dest->outfile;
+  dest->pub.free_in_buffer = dest->size;
+}
+
+
+/*
+ * Empty the output buffer --- called whenever buffer fills up.
+ *
+ * In typical applications, this should write the entire output buffer
+ * (ignoring the current state of next_output_byte & free_in_buffer),
+ * reset the pointer & count to the start of the buffer, and return TRUE
+ * indicating that the buffer has been dumped.
+ *
+ * In applications that need to be able to suspend compression due to output
+ * overrun, a FALSE return indicates that the buffer cannot be emptied now.
+ * In this situation, the compressor will return to its caller (possibly with
+ * an indication that it has not accepted all the supplied scanlines).  The
+ * application should resume compression after it has made more room in the
+ * output buffer.  Note that there are substantial restrictions on the use of
+ * suspension --- see the documentation.
+ *
+ * When suspending, the compressor will back up to a convenient restart point
+ * (typically the start of the current MCU). next_output_byte & free_in_buffer
+ * indicate where the restart point will be if the current call returns FALSE.
+ * Data beyond this point will be regenerated after resumption, so do not
+ * write it out when emptying the buffer externally.
+ */
+
+boolean empty_output_buffer (j_compress_ptr cinfo)
+{
+  return TRUE;
+}
+
+
+/*
+ * Compression initialization.
+ * Before calling this, all parameters and a data destination must be set up.
+ *
+ * We require a write_all_tables parameter as a failsafe check when writing
+ * multiple datastreams from the same compression object.  Since prior runs
+ * will have left all the tables marked sent_table=TRUE, a subsequent run
+ * would emit an abbreviated stream (no tables) by default.  This may be what
+ * is wanted, but for safety's sake it should not be the default behavior:
+ * programmers should have to make a deliberate choice to emit abbreviated
+ * images.  Therefore the documentation and examples should encourage people
+ * to pass write_all_tables=TRUE; then it will take active thought to do the
+ * wrong thing.
+ */
+
+GLOBAL void
+jpeg_start_compress (j_compress_ptr cinfo, boolean write_all_tables)
+{
+  if (cinfo->global_state != CSTATE_START)
+    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+
+  if (write_all_tables)
+    jpeg_suppress_tables(cinfo, FALSE);	/* mark all tables to be written */
+
+  /* (Re)initialize error mgr and destination modules */
+  (*cinfo->err->reset_error_mgr) ((j_common_ptr) cinfo);
+  (*cinfo->dest->init_destination) (cinfo);
+  /* Perform master selection of active modules */
+  jinit_compress_master(cinfo);
+  /* Set up for the first pass */
+  (*cinfo->master->prepare_for_pass) (cinfo);
+  /* Ready for application to drive first pass through jpeg_write_scanlines
+   * or jpeg_write_raw_data.
+   */
+  cinfo->next_scanline = 0;
+  cinfo->global_state = (cinfo->raw_data_in ? CSTATE_RAW_OK : CSTATE_SCANNING);
+}
+
+
+/*
+ * Write some scanlines of data to the JPEG compressor.
+ *
+ * The return value will be the number of lines actually written.
+ * This should be less than the supplied num_lines only in case that
+ * the data destination module has requested suspension of the compressor,
+ * or if more than image_height scanlines are passed in.
+ *
+ * Note: we warn about excess calls to jpeg_write_scanlines() since
+ * this likely signals an application programmer error.  However,
+ * excess scanlines passed in the last valid call are *silently* ignored,
+ * so that the application need not adjust num_lines for end-of-image
+ * when using a multiple-scanline buffer.
+ */
+
+GLOBAL JDIMENSION
+jpeg_write_scanlines (j_compress_ptr cinfo, JSAMPARRAY scanlines,
+		      JDIMENSION num_lines)
+{
+  JDIMENSION row_ctr, rows_left;
+
+  if (cinfo->global_state != CSTATE_SCANNING)
+    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+  if (cinfo->next_scanline >= cinfo->image_height)
+    WARNMS(cinfo, JWRN_TOO_MUCH_DATA);
+
+  /* Call progress monitor hook if present */
+  if (cinfo->progress != NULL) {
+    cinfo->progress->pass_counter = (long) cinfo->next_scanline;
+    cinfo->progress->pass_limit = (long) cinfo->image_height;
+    (*cinfo->progress->progress_monitor) ((j_common_ptr) cinfo);
+  }
+
+  /* Give master control module another chance if this is first call to
+   * jpeg_write_scanlines.  This lets output of the frame/scan headers be
+   * delayed so that application can write COM, etc, markers between
+   * jpeg_start_compress and jpeg_write_scanlines.
+   */
+  if (cinfo->master->call_pass_startup)
+    (*cinfo->master->pass_startup) (cinfo);
+
+  /* Ignore any extra scanlines at bottom of image. */
+  rows_left = cinfo->image_height - cinfo->next_scanline;
+  if (num_lines > rows_left)
+    num_lines = rows_left;
+
+  row_ctr = 0;
+  (*cinfo->main->process_data) (cinfo, scanlines, &row_ctr, num_lines);
+  cinfo->next_scanline += row_ctr;
+  return row_ctr;
+}
+
+/*
+ * Terminate destination --- called by jpeg_finish_compress
+ * after all data has been written.  Usually needs to flush buffer.
+ *
+ * NB: *not* called by jpeg_abort or jpeg_destroy; surrounding
+ * application must deal with any cleanup that should happen even
+ * for error exit.
+ */
+
+static int hackSize;
+
+void term_destination (j_compress_ptr cinfo)
+{
+  my_dest_ptr dest = (my_dest_ptr) cinfo->dest;
+  size_t datacount = dest->size - dest->pub.free_in_buffer;
+  hackSize = datacount;
+}
+
+
+/*
+ * Prepare for output to a stdio stream.
+ * The caller must have already opened the stream, and is responsible
+ * for closing it after finishing compression.
+ */
+
+void jpegDest (j_compress_ptr cinfo, byte* outfile, int size)
+{
+  my_dest_ptr dest;
+
+  /* The destination object is made permanent so that multiple JPEG images
+   * can be written to the same file without re-executing jpeg_stdio_dest.
+   * This makes it dangerous to use this manager and a different destination
+   * manager serially with the same JPEG object, because their private object
+   * sizes may be different.  Caveat programmer.
+   */
+  if (cinfo->dest == NULL) {	/* first time for this JPEG object? */
+    cinfo->dest = (struct jpeg_destination_mgr *)
+      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
+				  sizeof(my_destination_mgr));
+  }
+
+  dest = (my_dest_ptr) cinfo->dest;
+  dest->pub.init_destination = init_destination;
+  dest->pub.empty_output_buffer = empty_output_buffer;
+  dest->pub.term_destination = term_destination;
+  dest->outfile = outfile;
+  dest->size = size;
+}
+
+// returns a Z_Malloc'd piece of mem that you should free up yourself
+//
+byte *Compress_JPG(int *pOutputSize, int quality, int image_width, int image_height, byte *image_buffer, qboolean bInvertDuringCompression)
+{
+  /* This struct contains the JPEG compression parameters and pointers to
+   * working space (which is allocated as needed by the JPEG library).
+   * It is possible to have several such structures, representing multiple
+   * compression/decompression processes, in existence at once.  We refer
+   * to any one struct (and its associated working data) as a "JPEG object".
+   */
+  struct jpeg_compress_struct cinfo;
+  /* This struct represents a JPEG error handler.  It is declared separately
+   * because applications often want to supply a specialized error handler
+   * (see the second half of this file for an example).  But here we just
+   * take the easy way out and use the standard error handler, which will
+   * print a message on stderr and call exit() if compression fails.
+   * Note that this struct must live as long as the main JPEG parameter
+   * struct, to avoid dangling-pointer problems.
+   */
+  struct jpeg_error_mgr jerr;
+  /* More stuff */
+  JSAMPROW row_pointer[1];	/* pointer to JSAMPLE row[s] */
+  int row_stride;		/* physical row width in image buffer */  
+
+  /* Step 1: allocate and initialize JPEG compression object */
+
+  /* We have to set up the error handler first, in case the initialization
+   * step fails.  (Unlikely, but it could happen if you are out of memory.)
+   * This routine fills in the contents of struct jerr, and returns jerr's
+   * address which we place into the link field in cinfo.
+   */
+  cinfo.err = jpeg_std_error(&jerr);
+  /* Now we can initialize the JPEG compression object. */
+  jpeg_create_compress(&cinfo);
+
+  /* Step 2: specify data destination (eg, a file) */
+  /* Note: steps 2 and 3 can be done in either order. */
+
+  /* Here we use the library-supplied code to send compressed data to a
+   * stdio stream.  You can also write your own code to do something else.
+   * VERY IMPORTANT: use "b" option to fopen() if you are on a machine that
+   * requires it in order to write binary files.
+   */
+	byte *out =	//  (unsigned char *)ri.Hunk_AllocateTempMemory(image_width*image_height*4);
+					(unsigned char *)Z_Malloc(image_width*image_height*4, TAG_TEMP_JPG, qfalse);  	
+
+  jpegDest(&cinfo, out, image_width*image_height*4);
+
+  /* Step 3: set parameters for compression */
+
+  /* First we supply a description of the input image.
+   * Four fields of the cinfo struct must be filled in:
+   */
+  cinfo.image_width = image_width; 	/* image width and height, in pixels */
+  cinfo.image_height = image_height;
+  cinfo.input_components = 4;		/* # of color components per pixel */
+  cinfo.in_color_space = JCS_RGB; 	/* colorspace of input image */
+  /* Now use the library's routine to set default compression parameters.
+   * (You must set at least cinfo.in_color_space before calling this,
+   * since the defaults depend on the source color space.)
+   */
+  jpeg_set_defaults(&cinfo);
+  /* Now you can set any non-default parameters you wish to.
+   * Here we just illustrate the use of quality (quantization table) scaling:
+   */
+  jpeg_set_quality(&cinfo, quality, TRUE /* limit to baseline-JPEG values */);
+
+  /* Step 4: Start compressor */
+
+  /* TRUE ensures that we will write a complete interchange-JPEG file.
+   * Pass TRUE unless you are very sure of what you're doing.
+   */
+  jpeg_start_compress(&cinfo, TRUE);
+
+  /* Step 5: while (scan lines remain to be written) */
+  /*           jpeg_write_scanlines(...); */
+
+  /* Here we use the library's state variable cinfo.next_scanline as the
+   * loop counter, so that we don't have to keep track ourselves.
+   * To keep things simple, we pass one scanline per call; you can pass
+   * more if you wish, though.
+   */
+  row_stride = image_width * 4;	/* JSAMPLEs per row in image_buffer */
+
+  while (cinfo.next_scanline < cinfo.image_height) {
+    /* jpeg_write_scanlines expects an array of pointers to scanlines.
+     * Here the array is only one element long, but you could pass
+     * more than one scanline at a time if that's more convenient.
+     */
+	 if (bInvertDuringCompression)
+	 { 
+		row_pointer[0] = & image_buffer[((cinfo.image_height-1)*row_stride)-cinfo.next_scanline * row_stride];
+	 }
+	 else
+	 {
+		row_pointer[0] = & image_buffer[									cinfo.next_scanline * row_stride];		 
+	 }
+
+     jpeg_write_scanlines(&cinfo, row_pointer, 1);
+  }
+
+  /* Step 6: Finish compression */
+
+  jpeg_finish_compress(&cinfo);
+  
+  /* Step 7: release JPEG compression object */
+
+  /* This is an important step since it will release a good deal of memory. */
+  jpeg_destroy_compress(&cinfo);
+
+  /* And we're done! */
+
+  *pOutputSize = hackSize;
+  return out;
+}
+
+void SaveJPG(const char * filename, int quality, int image_width, int image_height, unsigned char *image_buffer) 
+{
+	int iOutputSize = 0;
+
+	byte *pbOut = Compress_JPG(&iOutputSize, quality, image_width, image_height, image_buffer, qtrue);
+
+	FS_WriteFile( filename, pbOut, iOutputSize );
+
+	Z_Free(pbOut);
+}
+
+
+
+void JPG_ErrorThrow(LPCSTR message)
+{
+	Com_Error( ERR_FATAL, "JPG: %s\n", message );
+}
+
+void JPG_MessageOut(LPCSTR message)
+{
+	VID_Printf(PRINT_ALL, "%s\n", message);
+}
+
+//////////////// eof ////////////
+
diff --git a/code/renderer/tr_jpeg_interface.h b/code/renderer/tr_jpeg_interface.h
new file mode 100644
index 0000000..e5733c7
--- /dev/null
+++ b/code/renderer/tr_jpeg_interface.h
@@ -0,0 +1,40 @@
+// Filename:-	tr_jpeg_interface.h
+//
+#pragma warning (disable: 4100)	//unreferenced formal parameter
+#pragma warning (disable: 4127)	//conditional expression is constant
+#pragma warning (disable: 4244)	//int to unsigned short
+
+#ifndef TR_JPEG_INTERFACE_H
+#define TR_JPEG_INTERFACE_H
+
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+
+#ifndef LPCSTR 
+typedef const char * LPCSTR;
+#endif
+
+int LoadJPG( const char *filename, unsigned char **pic, int *width, int *height );
+void SaveJPG( const char *filename, int quality, int image_width, int image_height, unsigned char *image_buffer);
+
+void JPG_ErrorThrow(LPCSTR message);
+void JPG_MessageOut(LPCSTR message);
+#define ERROR_STRING_NO_RETURN(message) JPG_ErrorThrow(message)
+#define MESSAGE_STRING(message)			JPG_MessageOut(message)
+
+
+#ifdef __cplusplus
+};
+#endif
+
+
+
+#endif	// #ifndef TR_JPEG_INTERFACE_H
+
+
+////////////////// eof //////////////////
+
diff --git a/code/renderer/tr_landscape.h b/code/renderer/tr_landscape.h
new file mode 100644
index 0000000..b413740
--- /dev/null
+++ b/code/renderer/tr_landscape.h
@@ -0,0 +1,193 @@
+#ifndef _INC_LANDSCAPE_H
+#define _INC_LANDSCAPE_H
+
+// Number of TriTreeNodes available
+#define POOL_SIZE				(50000)
+
+#define TEXTURE_ALPHA_TL		0x000000ff
+#define TEXTURE_ALPHA_TR		0x0000ff00
+#define TEXTURE_ALPHA_BL		0x00ff0000
+#define TEXTURE_ALPHA_BR		0x000000ff
+
+#define INDEX_TL				0
+#define INDEX_TR				1
+#define INDEX_BL				2
+#define INDEX_BR				3
+
+#define VARIANCE_MIN			0.0f
+#define VARIANCE_MAX			2000.0f
+#define SPLIT_VARIANCE_SIZE		20
+#define SPLIT_VARIANCE_STEP		(VARIANCE_MAX / SPLIT_VARIANCE_SIZE)
+
+#define VectorAverage(a,b,c)			(((c)[0]=((a)[0]+(b)[0])*0.5f),((c)[1]=((a)[1]+(b)[1])*0.5f),((c)[2]=((a)[2]+(b)[2])*0.5f))
+
+class CTerVert
+{
+public:
+	vec3_t		coords;					// real world coords of terxel
+	vec3_t		normal;					// required to calculate lighting and used in physics
+	color4ub_t	tint;					// tint at this terxel
+	float		tex[2];					// texture coordinates at this terxel
+	int			height;					// Copy of heightmap data
+	int			tessIndex;				// Index of the vert in the tess array
+	int			tessRegistration;		// ...... for the tess with this registration
+
+	CTerVert( void ) { memset(this, 0, sizeof(*this)); }
+	~CTerVert( void ) { }
+};
+
+class CTRHeightDetails
+{
+private:
+	qhandle_t	mShader;
+public:
+	CTRHeightDetails( void ) { }
+	~CTRHeightDetails( void ) { }
+
+	const qhandle_t GetShader( void ) const { return(mShader); }
+	void SetShader(const qhandle_t shader) { mShader = shader; }
+};
+
+//
+// Information of each patch (tessellated area) of a CTRLandScape
+//
+class CTRPatch
+{
+private:
+	class CCMLandScape	*owner;
+	class CTRLandScape	*localowner;
+
+	CCMPatch			*common;
+	vec3_t				mCenter;									// Real world center of the patch
+//	vec3_t				mNormal[2];
+//	float				mDistance[2];
+
+	CTerVert			*mRenderMap;								// Modulation value and texture coords per vertex
+	shader_t			*mTLShader;		 							// Dynamically created blended shader for the top left triangle
+	shader_t			*mBRShader;		 							// Dynamically created blended shader for the bottom right triangle
+
+	bool				misVisible;									// Is this patch visible in the current frame?
+
+public:
+	CTRPatch(void) { }
+	~CTRPatch(void) { }
+
+	// Accessors
+	const vec3_t &GetWorld(void) const { return(common->GetWorld()); }
+	const vec3_t &GetMins(void) const { return(common->GetMins()); }
+	const vec3_t &GetMaxs(void) const { return(common->GetMaxs()); }
+	const vec3pair_t &GetBounds(void) const { return(common->GetBounds()); }
+	shader_t			*GetTLShader(void) { return mTLShader; }
+	shader_t			*GetBRShader(void) { return mBRShader; }
+
+	void SetCommon(CCMPatch *in) { common = in; }
+	const CCMPatch *GetCommon(void) const { return(common); }
+	bool isVisible(void) { return(misVisible); }
+	void SetTLShader(qhandle_t in) { mTLShader = R_GetShaderByHandle(in); }
+	void SetBRShader(qhandle_t in) { mBRShader = R_GetShaderByHandle(in); }
+	void SetOwner(CCMLandScape *in) { owner = in; } 
+	void SetLocalOwner(CTRLandScape *in) { localowner = in; } 
+	void Clear(void) { memset(this, 0, sizeof(*this));  }
+	void SetCenter(void) { VectorAverage(common->GetMins(), common->GetMaxs(), mCenter); }
+	void CalcNormal(void);
+
+	// Prototypes
+	void SetVisibility(bool visCheck);
+	void RenderCorner(ivec5_t corner);
+	void Render(int Part);
+	void RecurseRender(int depth, ivec5_t left, ivec5_t right, ivec5_t apex);
+	void SetRenderMap(const int x, const int y);
+	int RenderWaterVert(int x, int y);
+	void RenderWater(void);
+	const bool HasWater(void) const;
+};
+
+
+#define	PI_TOP		1
+#define PI_BOTTOM	2
+#define PI_BOTH		3
+
+typedef struct SPatchInfo
+{
+	CTRPatch	*mPatch;
+	shader_t	*mShader;
+	int			mPart;
+} TPatchInfo;
+
+//
+// The master class used to define an area of terrain
+//
+
+class CTRLandScape
+{
+private:
+	const CCMLandScape	*common;
+	CTRPatch			*mTRPatches;							// Local patch info
+	TPatchInfo			*mSortedPatches;
+
+	int					mPatchMinx, mPatchMaxx;
+	int					mPatchMiny, mPatchMaxy;
+	int					mMaxNode;								// terxels * terxels = exit condition for splitting
+	int					mSortedCount;
+
+	float				mPatchSize;
+
+	shader_t			*mShader;  								// shader the terrain got its contents from
+						
+	CTerVert			*mRenderMap;							// modulation value and texture coords per vertex
+	float				mTextureScale;							// Scale of texture mapped to terrain
+						
+	float				mScalarSize;
+						
+	shader_t			*mWaterShader;							// Water shader
+	qhandle_t			mFlatShader;							// Flat ground shader	
+
+	CTRHeightDetails	mHeightDetails[HEIGHT_RESOLUTION];		// Array of info specific to height
+#if	_DEBUG
+	int					mCycleCount;
+#endif
+public:
+	CTRLandScape(const char *configstring);
+	~CTRLandScape(void);
+
+	// Accessors
+	const int GetBlockWidth(void) const { return(common->GetBlockWidth()); }
+	const int GetBlockHeight(void) const { return(common->GetBlockHeight()); }
+	const vec3_t &GetMins(void) const { return(common->GetMins()); }
+	const vec3_t &GetMaxs(void) const { return(common->GetMaxs()); }
+	const vec3_t &GetTerxelSize(void) const { return(common->GetTerxelSize()); }
+	const vec3_t &GetPatchSize(void) const { return(common->GetPatchSize()); }
+	const int GetWidth(void) const { return(common->GetWidth()); }
+	const int GetHeight(void) const { return(common->GetHeight()); }
+	const int GetRealWidth(void) const { return(common->GetRealWidth()); }
+	const int GetRealHeight(void) const { return(common->GetRealHeight()); }
+
+	void SetCommon(const CCMLandScape *landscape) { common = landscape; }
+	const CCMLandScape *GetCommon( void ) const { return(common); }
+	const thandle_t GetCommonId( void ) const { return(common->GetTerrainId()); }
+	shader_t	*GetShader(void) const { return(mShader); }
+	CTerVert *GetRenderMap(const int x, const int y) const { return(mRenderMap + x + (y * common->GetRealWidth())); }
+	CTRPatch *GetPatch(const int x, const int y) const { return(mTRPatches + (common->GetBlockWidth() * y) + x); }
+	const CTRHeightDetails *GetHeightDetail(int height) const { return(mHeightDetails + height); }
+	const float GetScalarSize(void) const { return(mScalarSize); }
+	const int GetMaxNode(void) const { return(mMaxNode); }
+
+	// Prototypes
+	void CalculateRegion(void);
+	void Reset(bool visCheck = true);
+	void Render(void);
+	void CalculateRealCoords(void);
+	void CalculateNormals(void);
+	void CalculateTextureCoords(void);
+	void CalculateLighting(void);
+	void CalculateShaders(void);
+	qhandle_t GetBlendedShader(qhandle_t a, qhandle_t b, qhandle_t c, bool surfaceSprites);
+	void LoadTerrainDef(const char *td);
+	void CopyHeightMap(void);
+	void SetShaders(const int height, const qhandle_t shader);
+};
+
+void R_CalcTerrainVisBounds(CTRLandScape *landscape);
+void R_AddTerrainSurfaces(void);
+
+#endif //INC_LANDSCAPE_H
diff --git a/code/renderer/tr_light.cpp b/code/renderer/tr_light.cpp
new file mode 100644
index 0000000..5506c38
--- /dev/null
+++ b/code/renderer/tr_light.cpp
@@ -0,0 +1,572 @@
+// tr_light.c
+
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+
+#include "tr_local.h"
+
+#define	DLIGHT_AT_RADIUS		16
+// at the edge of a dlight's influence, this amount of light will be added
+
+#define	DLIGHT_MINIMUM_RADIUS	16		
+// never calculate a range less than this to prevent huge light numbers
+
+
+/*
+===============
+R_TransformDlights
+
+Transforms the origins of an array of dlights.
+Used by both the front end (for DlightBmodel) and
+the back end (before doing the lighting calculation)
+===============
+*/
+void R_TransformDlights( int count, dlight_t *dl, orientationr_t *or) {
+	int		i;
+	vec3_t	temp;
+
+	for ( i = 0 ; i < count ; i++, dl++ ) {
+		VectorSubtract( dl->origin, or->origin, temp );
+		dl->transformed[0] = DotProduct( temp, or->axis[0] );
+		dl->transformed[1] = DotProduct( temp, or->axis[1] );
+		dl->transformed[2] = DotProduct( temp, or->axis[2] );
+	}
+}
+
+/*
+=============
+R_DlightBmodel
+
+Determine which dynamic lights may effect this bmodel
+=============
+*/
+#ifndef VV_LIGHTING
+void R_DlightBmodel( bmodel_t *bmodel, qboolean NoLight ) {
+	int			i, j;
+	dlight_t	*dl;
+	int			mask;
+	msurface_t	*surf;
+
+	// transform all the lights
+	R_TransformDlights( tr.refdef.num_dlights, tr.refdef.dlights, &tr.or );
+
+	mask = 0;
+	if (!NoLight)
+	{
+		for ( i=0 ; i<tr.refdef.num_dlights ; i++ ) {
+			dl = &tr.refdef.dlights[i];
+
+			// see if the point is close enough to the bounds to matter
+			for ( j = 0 ; j < 3 ; j++ ) {
+				if ( dl->transformed[j] - bmodel->bounds[1][j] > dl->radius ) {
+					break;
+				}
+				if ( bmodel->bounds[0][j] - dl->transformed[j] > dl->radius ) {
+					break;
+				}
+			}
+			if ( j < 3 ) {
+				continue;
+			}
+
+			// we need to check this light
+			mask |= 1 << i;
+		}
+	}
+
+	tr.currentEntity->needDlights = (mask != 0);
+	tr.currentEntity->dlightBits = mask;
+
+
+	// set the dlight bits in all the surfaces
+	for ( i = 0 ; i < bmodel->numSurfaces ; i++ ) {
+		surf = bmodel->firstSurface + i;
+
+		if ( *surf->data == SF_FACE ) {
+			((srfSurfaceFace_t *)surf->data)->dlightBits = mask;
+		} else if ( *surf->data == SF_GRID ) {
+			((srfGridMesh_t *)surf->data)->dlightBits = mask;
+		} else if ( *surf->data == SF_TRIANGLES ) {
+			((srfTriangles_t *)surf->data)->dlightBits = mask;
+		}
+	}
+}
+#endif // VV_LIGHTING
+
+
+/*
+=============================================================================
+
+LIGHT SAMPLING
+
+=============================================================================
+*/
+
+extern	cvar_t	*r_ambientScale;
+extern	cvar_t	*r_directedScale;
+extern	cvar_t	*r_debugLight;
+
+/*
+=================
+R_SetupEntityLightingGrid
+
+=================
+*/
+#ifdef VV_LIGHTING
+void R_SetupEntityLightingGrid( trRefEntity_t *ent ) {
+#else
+static void R_SetupEntityLightingGrid( trRefEntity_t *ent ) {
+#endif
+	vec3_t			lightOrigin;
+	int				pos[3];
+	int				i, j;
+	float			frac[3];
+	int				gridStep[3];
+	vec3_t			direction;
+	float			totalFactor;
+	unsigned short	*startGridPos;
+#ifdef _XBOX
+	byte zeroArray[3];
+	byte style;
+
+	zeroArray[0] = zeroArray[1] = zeroArray[2] = 0;
+#endif
+
+	
+	if (r_fullbright->integer || (tr.refdef.rdflags & RDF_doLAGoggles) )
+	{
+		ent->ambientLight[0] = ent->ambientLight[1] = ent->ambientLight[2] = 255.0;
+		ent->directedLight[0] = ent->directedLight[1] = ent->directedLight[2] = 255.0;
+		VectorCopy( tr.sunDirection, ent->lightDir );
+		return;
+	}
+
+	if ( ent->e.renderfx & RF_LIGHTING_ORIGIN ) {
+		// seperate lightOrigins are needed so an object that is
+		// sinking into the ground can still be lit, and so
+		// multi-part models can be lit identically
+		VectorCopy( ent->e.lightingOrigin, lightOrigin );
+	} else {
+		VectorCopy( ent->e.origin, lightOrigin );
+	}
+#define ACCURATE_LIGHTGRID_SAMPLING 1
+#if ACCURATE_LIGHTGRID_SAMPLING
+	vec3_t	startLightOrigin;
+	VectorCopy( lightOrigin, startLightOrigin );
+#endif
+
+	VectorSubtract( lightOrigin, tr.world->lightGridOrigin, lightOrigin );
+	for ( i = 0 ; i < 3 ; i++ ) {
+		float	v;
+
+		v = lightOrigin[i]*tr.world->lightGridInverseSize[i];
+		pos[i] = floor( v );
+		frac[i] = v - pos[i];
+		if ( pos[i] < 0 ) {
+			pos[i] = 0;
+		} else if ( pos[i] >= tr.world->lightGridBounds[i] - 1 ) {
+			pos[i] = tr.world->lightGridBounds[i] - 1;
+		}
+	}
+
+	VectorClear( ent->ambientLight );
+	VectorClear( ent->directedLight );
+	VectorClear( direction );
+
+	// trilerp the light value
+	gridStep[0] = 1;
+	gridStep[1] = tr.world->lightGridBounds[0];
+	gridStep[2] = tr.world->lightGridBounds[0] * tr.world->lightGridBounds[1];
+	startGridPos = tr.world->lightGridArray	+ pos[0] * gridStep[0] 
+					+ pos[1] * gridStep[1] 	+ pos[2] * gridStep[2];
+#if ACCURATE_LIGHTGRID_SAMPLING
+	vec3_t	startGridOrg;
+	VectorCopy( tr.world->lightGridOrigin, startGridOrg );
+	startGridOrg[0] += pos[0] * tr.world->lightGridSize[0];
+	startGridOrg[1] += pos[1] * tr.world->lightGridSize[1];
+	startGridOrg[2] += pos[2] * tr.world->lightGridSize[2];
+#endif
+	totalFactor = 0;
+	for ( i = 0 ; i < 8 ; i++ ) {
+		float			factor;
+		mgrid_t			*data;
+		unsigned short	*gridPos;
+		int				lat, lng;
+		vec3_t			normal;
+#if ACCURATE_LIGHTGRID_SAMPLING
+		vec3_t			gridOrg;
+		VectorCopy( startGridOrg, gridOrg );
+#endif
+
+		factor = 1.0;
+		gridPos = startGridPos;
+		for ( j = 0 ; j < 3 ; j++ ) {
+			if ( i & (1<<j) ) {
+				factor *= frac[j];
+				gridPos += gridStep[j];
+#if ACCURATE_LIGHTGRID_SAMPLING
+				gridOrg[j] += tr.world->lightGridSize[j];
+#endif
+			} else {
+				factor *= (1.0 - frac[j]);
+			}
+		}
+
+		if (gridPos >= tr.world->lightGridArray + tr.world->numGridArrayElements)
+		{//we've gone off the array somehow
+			continue;
+		}
+		data = tr.world->lightGridData + *gridPos;
+
+#ifdef _XBOX
+		const byte *memory = (const byte *)tr.world->lightGridData + data->data;
+
+		style = data->flags & (1 << 4) ? memory[0] : LS_NONE;
+		if ( style == LS_NONE ) 
+		{
+			continue;	// ignore samples in walls
+		}
+
+		totalFactor += factor;
+
+		const byte *array;
+
+		for(j=0;j<MAXLIGHTMAPS;j++)
+		{
+			if(data->flags & (1 << (j + 4))) {
+				style = *memory;
+				memory++;
+			} else {
+				style = LS_NONE;
+			}
+
+			if (style != LS_NONE)
+			{
+				if(data->flags & (1 << j)) {
+					array = memory;
+					memory += 3;
+				} else {
+					array = zeroArray;
+				}
+
+				ent->ambientLight[0] += factor * array[0] * styleColors[style][0] / 255.0f;
+				ent->ambientLight[1] += factor * array[1] * styleColors[style][1] / 255.0f;
+				ent->ambientLight[2] += factor * array[2] * styleColors[style][2] / 255.0f;
+
+				if(array != zeroArray) {
+					array = memory;
+					memory += 3;
+				} 
+
+				ent->directedLight[0] += factor * array[0] * styleColors[style][0] / 255.0f;
+				ent->directedLight[1] += factor * array[1] * styleColors[style][1] / 255.0f;
+				ent->directedLight[2] += factor * array[2] * styleColors[style][2] / 255.0f;
+			}
+			else
+			{
+				break;
+			}
+		}
+
+#else // _XBOX
+
+		if ( data->styles[0] == LS_NONE ) 
+		{
+			continue;	// ignore samples in walls
+		}
+
+#if 0
+		if ( !SV_inPVS( startLightOrigin, gridOrg ) )
+		{
+			continue;
+		}
+#endif
+
+		totalFactor += factor;
+
+		for(j=0;j<MAXLIGHTMAPS;j++)
+		{
+			if (data->styles[j] != LS_NONE)
+			{
+				const byte	style= data->styles[j];
+
+				ent->ambientLight[0] += factor * data->ambientLight[j][0] * styleColors[style][0] / 255.0f;
+				ent->ambientLight[1] += factor * data->ambientLight[j][1] * styleColors[style][1] / 255.0f;
+				ent->ambientLight[2] += factor * data->ambientLight[j][2] * styleColors[style][2] / 255.0f;
+
+				ent->directedLight[0] += factor * data->directLight[j][0] * styleColors[style][0] / 255.0f;
+				ent->directedLight[1] += factor * data->directLight[j][1] * styleColors[style][1] / 255.0f;
+				ent->directedLight[2] += factor * data->directLight[j][2] * styleColors[style][2] / 255.0f;
+			}
+			else
+			{
+				break;
+			}
+		}
+
+#endif // _XBOX
+
+		lat = data->latLong[1];
+		lng = data->latLong[0];
+		lat *= (FUNCTABLE_SIZE/256);
+		lng *= (FUNCTABLE_SIZE/256);
+
+		// decode X as cos( lat ) * sin( long )
+		// decode Y as sin( lat ) * sin( long )
+		// decode Z as cos( long )
+
+		normal[0] = tr.sinTable[(lat+(FUNCTABLE_SIZE/4))&FUNCTABLE_MASK] * tr.sinTable[lng];
+		normal[1] = tr.sinTable[lat] * tr.sinTable[lng];
+		normal[2] = tr.sinTable[(lng+(FUNCTABLE_SIZE/4))&FUNCTABLE_MASK];
+
+		VectorMA( direction, factor, normal, direction );
+
+#if ACCURATE_LIGHTGRID_SAMPLING
+#ifndef _XBOX
+		if ( r_debugLight->integer && ent->e.hModel == -1 )
+		{
+			//draw 	
+			refEntity_t refEnt;
+			refEnt.hModel = 0;
+			refEnt.ghoul2 = NULL;
+			refEnt.renderfx = 0;
+			VectorCopy( gridOrg, refEnt.origin );
+			vectoangles( normal, refEnt.angles );
+			AnglesToAxis( refEnt.angles, refEnt.axis );
+			refEnt.reType = RT_MODEL;
+			RE_AddRefEntityToScene( &refEnt );
+
+			refEnt.renderfx = RF_DEPTHHACK;
+			refEnt.reType = RT_SPRITE;
+			refEnt.customShader = RE_RegisterShader( "gfx/misc/debugAmbient" );
+			refEnt.shaderRGBA[0] = data->ambientLight[0][0];
+			refEnt.shaderRGBA[1] = data->ambientLight[0][1];
+			refEnt.shaderRGBA[2] = data->ambientLight[0][2];
+			refEnt.shaderRGBA[3] = 255;
+			refEnt.radius = factor*50+2.0f; // maybe always give it a minimum size?
+			refEnt.rotation = 0;			// don't let the sprite wobble around
+			RE_AddRefEntityToScene( &refEnt );
+
+			refEnt.reType = RT_LINE;
+			refEnt.customShader = RE_RegisterShader( "gfx/misc/debugArrow" );
+			refEnt.shaderRGBA[0] = data->directLight[0][0];
+			refEnt.shaderRGBA[1] = data->directLight[0][1];
+			refEnt.shaderRGBA[2] = data->directLight[0][2];
+			refEnt.shaderRGBA[3] = 255;
+			VectorCopy( refEnt.origin, refEnt.oldorigin );
+			VectorMA( gridOrg, (factor*-255) - 2.0f, normal, refEnt.origin ); // maybe always give it a minimum length
+			refEnt.radius = 1.5f;
+			RE_AddRefEntityToScene( &refEnt );
+		}
+#endif // _XBOX
+#endif
+	}
+
+	if ( totalFactor > 0 && totalFactor < 0.99 ) 
+	{
+		totalFactor = 1.0 / totalFactor;
+		VectorScale( ent->ambientLight, totalFactor, ent->ambientLight );
+		VectorScale( ent->directedLight, totalFactor, ent->directedLight );
+	}
+
+	VectorScale( ent->ambientLight, r_ambientScale->value, ent->ambientLight );
+	VectorScale( ent->directedLight, r_directedScale->value, ent->directedLight );
+
+	VectorNormalize2( direction, ent->lightDir );
+}
+
+
+/*
+===============
+LogLight
+===============
+*/
+static void LogLight( trRefEntity_t *ent ) {
+	int	max1, max2;
+
+	/*
+	if ( !(ent->e.renderfx & RF_FIRST_PERSON ) ) {
+		return;
+	}
+	*/
+
+	max1 = VectorLength( ent->ambientLight );
+	/*
+	max1 = ent->ambientLight[0];
+	if ( ent->ambientLight[1] > max1 ) {
+		max1 = ent->ambientLight[1];
+	} else if ( ent->ambientLight[2] > max1 ) {
+		max1 = ent->ambientLight[2];
+	}
+	*/
+
+	max2 = VectorLength( ent->directedLight );
+	/*
+	max2 = ent->directedLight[0];
+	if ( ent->directedLight[1] > max2 ) {
+		max2 = ent->directedLight[1];
+	} else if ( ent->directedLight[2] > max2 ) {
+		max2 = ent->directedLight[2];
+	}
+	*/
+
+	VID_Printf( PRINT_ALL, "amb:%i  dir:%i  direction: (%4.2f, %4.2f, %4.2f)\n", max1, max2, ent->lightDir[0], ent->lightDir[1], ent->lightDir[2] );
+}
+
+/*
+=================
+R_SetupEntityLighting
+
+Calculates all the lighting values that will be used
+by the Calc_* functions
+=================
+*/
+void R_SetupEntityLighting( const trRefdef_t *refdef, trRefEntity_t *ent ) {
+#ifndef VV_LIGHTING
+	int				i;
+	dlight_t		*dl;
+	float			power;
+	vec3_t			dir;
+	float			d;
+	vec3_t			lightDir;
+	vec3_t			lightOrigin;
+
+	// lighting calculations 
+	if ( ent->lightingCalculated ) {
+		return;
+	}
+	ent->lightingCalculated = qtrue;
+
+	//
+	// trace a sample point down to find ambient light
+	//
+	if ( ent->e.renderfx & RF_LIGHTING_ORIGIN ) {
+		// seperate lightOrigins are needed so an object that is
+		// sinking into the ground can still be lit, and so
+		// multi-part models can be lit identically
+		VectorCopy( ent->e.lightingOrigin, lightOrigin );
+	} else {
+		VectorCopy( ent->e.origin, lightOrigin );
+	}
+
+	// if NOWORLDMODEL, only use dynamic lights (menu system, etc)
+	if ( !(refdef->rdflags & RDF_NOWORLDMODEL ) 
+		&& tr.world->lightGridData ) {
+		R_SetupEntityLightingGrid( ent );
+	} else {
+		ent->ambientLight[0] = ent->ambientLight[1] = 
+			ent->ambientLight[2] = tr.identityLight * 150;
+		ent->directedLight[0] = ent->directedLight[1] = 
+			ent->directedLight[2] = tr.identityLight * 150;
+		VectorCopy( tr.sunDirection, ent->lightDir );
+	}
+
+	// bonus items and view weapons have a fixed minimum add
+	if (  ent->e.renderfx & RF_MORELIGHT  ) {
+		ent->ambientLight[0] += tr.identityLight * 96;
+		ent->ambientLight[1] += tr.identityLight * 96;
+		ent->ambientLight[2] += tr.identityLight * 96;
+	}
+	else {
+		// give everything a minimum light add
+		ent->ambientLight[0] += tr.identityLight * 32;
+		ent->ambientLight[1] += tr.identityLight * 32;
+		ent->ambientLight[2] += tr.identityLight * 32;
+	}
+
+	//
+	// modify the light by dynamic lights
+	//
+	d = VectorLength( ent->directedLight );
+	VectorScale( ent->lightDir, d, lightDir );
+
+	for ( i = 0 ; i < refdef->num_dlights ; i++ ) {
+		dl = &refdef->dlights[i];
+		VectorSubtract( dl->origin, lightOrigin, dir );
+		d = VectorNormalize( dir );
+
+		power = DLIGHT_AT_RADIUS * ( dl->radius * dl->radius );
+		if ( d < DLIGHT_MINIMUM_RADIUS ) {
+			d = DLIGHT_MINIMUM_RADIUS;
+		}
+		d = power / ( d * d );
+
+		VectorMA( ent->directedLight, d, dl->color, ent->directedLight );
+		VectorMA( lightDir, d, dir, lightDir );
+	}
+
+	// clamp ambient
+	for ( i = 0 ; i < 3 ; i++ ) {
+		if ( ent->ambientLight[i] > tr.identityLightByte ) {
+			ent->ambientLight[i] = tr.identityLightByte;
+		}
+	}
+
+	if ( r_debugLight->integer ) {
+		LogLight( ent );
+	}
+
+	// save out the byte packet version
+	((byte *)&ent->ambientLightInt)[0] = myftol( ent->ambientLight[0] );
+	((byte *)&ent->ambientLightInt)[1] = myftol( ent->ambientLight[1] );
+	((byte *)&ent->ambientLightInt)[2] = myftol( ent->ambientLight[2] );
+	((byte *)&ent->ambientLightInt)[3] = 0xff;
+	
+	// transform the direction to local space
+	VectorNormalize( lightDir );
+	ent->lightDir[0] = DotProduct( lightDir, ent->e.axis[0] );
+	ent->lightDir[1] = DotProduct( lightDir, ent->e.axis[1] );
+	ent->lightDir[2] = DotProduct( lightDir, ent->e.axis[2] );
+
+#endif // VV_LIGHTING
+}
+
+//pass in origin
+qboolean RE_GetLighting( const vec3_t origin, vec3_t ambientLight, vec3_t directedLight, vec3_t lightDir) {
+	trRefEntity_t tr_ent;
+
+	if ( !tr.world || !tr.world->lightGridData) {
+		ambientLight[0] = ambientLight[1] = ambientLight[2] = 255.0;
+		directedLight[0] = directedLight[1] = directedLight[2] = 255.0;
+		VectorCopy( tr.sunDirection, lightDir );
+		return qfalse;
+	}
+	memset (&tr_ent, 0, sizeof(tr_ent) );
+
+	if ( ambientLight[0] == 666 )
+	{//HAX0R
+		tr_ent.e.hModel = -1;
+	}
+
+	VectorCopy (origin, tr_ent.e.origin);
+	R_SetupEntityLightingGrid( &tr_ent );
+	VectorCopy ( tr_ent.ambientLight,	ambientLight);
+	VectorCopy ( tr_ent.directedLight,	directedLight);
+	VectorCopy ( tr_ent.lightDir,		lightDir);
+	return qtrue;
+}
+
+/*
+=================
+R_LightForPoint
+=================
+*/
+int R_LightForPoint( vec3_t point, vec3_t ambientLight, vec3_t directedLight, vec3_t lightDir )
+{
+	trRefEntity_t ent;
+	
+	// bk010103 - this segfaults with -nolight maps
+	if ( tr.world->lightGridData == NULL )
+	  return qfalse;
+
+	memset(&ent, 0, sizeof(ent));
+	VectorCopy( point, ent.e.origin );
+	R_SetupEntityLightingGrid( &ent );
+	VectorCopy(ent.ambientLight, ambientLight);
+	VectorCopy(ent.directedLight, directedLight);
+	VectorCopy(ent.lightDir, lightDir);
+
+	return qtrue;
+}
diff --git a/code/renderer/tr_local.h b/code/renderer/tr_local.h
new file mode 100644
index 0000000..032b767
--- /dev/null
+++ b/code/renderer/tr_local.h
@@ -0,0 +1,2170 @@
+#ifndef TR_LOCAL_H
+#define TR_LOCAL_H
+
+
+#include "../game/q_shared.h"
+#include "../qcommon/qfiles.h"
+#include "tr_public.h"
+#include "mdx_format.h"
+#if defined(_XBOX)
+#include "qgl_console.h"
+#include "glext_console.h"
+#else
+#include "qgl.h"
+#include "glext.h"
+#endif
+
+#ifdef _XBOX
+#define GL_INDEX_TYPE		GL_UNSIGNED_SHORT
+typedef unsigned short glIndex_t;
+#else
+#define GL_INDEX_TYPE		GL_UNSIGNED_INT
+typedef unsigned int glIndex_t;
+#endif
+
+// fast float to int conversion
+#if id386 && !(defined __linux__ && defined __i386__)
+long myftol( float f );
+#else
+#define	myftol(x) ((int)(x))
+#endif
+
+
+// 14 bits
+// see QSORT_SHADERNUM_SHIFT
+#ifdef _XBOX
+#define	MAX_SHADERS				4096
+#else
+#define	MAX_SHADERS				8192
+#endif
+// can't be increased without changing bit packing for drawsurfs
+
+
+typedef struct dlight_s {
+	vec3_t	origin;
+	vec3_t	color;				// range from 0.0 to 1.0, should be color normalized
+	float	radius;
+
+	vec3_t	transformed;		// origin in local coordinate system
+} dlight_t;
+
+
+// a trRefEntity_t has all the information passed in by
+// the client game, as well as some locally derived info
+typedef struct {
+	refEntity_t	e;
+
+	float		axisLength;		// compensate for non-normalized axis
+
+	qboolean	needDlights;	// true for bmodels that touch a dlight
+	qboolean	lightingCalculated;
+	vec3_t		lightDir;		// normalized direction towards light
+	vec3_t		ambientLight;	// color normalized to 0-255
+	int			ambientLightInt;	// 32 bit rgba packed
+	vec3_t		directedLight;
+	int			dlightBits;
+} trRefEntity_t;
+
+
+// trRefdef_t holds everything that comes in refdef_t,
+// as well as the locally generated scene information
+typedef struct {
+	int			x, y, width, height;
+	float		fov_x, fov_y;
+	vec3_t		vieworg;
+	vec3_t		viewaxis[3];		// transformation matrix
+
+	int			time;				// time in milliseconds for shader effects and other time dependent rendering issues
+	int			frametime;
+	int			rdflags;			// RDF_NOWORLDMODEL, etc
+
+	// 1 bits will prevent the associated area from rendering at all
+	byte		areamask[MAX_MAP_AREA_BYTES];
+	qboolean	areamaskModified;	// qtrue if areamask changed since last scene
+
+	float		floatTime;			// tr.refdef.time / 1000.0
+	
+	// text messages for deform text shaders
+//	char		text[MAX_RENDER_STRINGS][MAX_RENDER_STRING_LENGTH];
+
+	int			num_entities;
+	trRefEntity_t	*entities;
+
+#ifndef VV_LIGHTING
+	int			num_dlights;
+	struct dlight_s	*dlights;
+#endif
+
+	int			numPolys;
+	struct srfPoly_s	*polys;
+
+	int			numDrawSurfs;
+	struct drawSurf_s	*drawSurfs;
+
+	int			fogIndex;	//what fog brush the vieworg is in
+
+} trRefdef_t;
+
+typedef struct {
+	vec3_t		origin;			// in world coordinates
+	vec3_t		axis[3];		// orientation in world
+	vec3_t		viewOrigin;		// viewParms->or.origin in local coordinates
+	float		modelMatrix[16];
+} orientationr_t;
+
+typedef struct image_s {
+#ifdef _XBOX
+	int			imgCode;
+#else
+	char		imgName[MAX_QPATH];		// game path, including extension
+	int			frameUsed;			// for texture usage in frame statistics
+#endif
+	USHORT		width, height;				// source image
+//	int			imgfileSize;
+
+	GLuint		texnum;					// gl texture binding
+	int			internalFormat;
+	int			wrapClampMode;		// GL_CLAMP or GL_REPEAT
+
+#ifdef _XBOX
+	bool		isLightmap;
+	bool		isSystem;
+	short		mipcount;
+#else
+	bool		mipmap;
+#endif
+
+	bool		allowPicmip;
+	short		iLastLevelUsedOn;
+} image_t;
+
+
+//===============================================================================
+
+typedef enum {
+	SS_BAD,
+	SS_PORTAL,			// mirrors, portals, viewscreens
+	SS_ENVIRONMENT,		// sky box
+	SS_OPAQUE,			// opaque
+
+	SS_DECAL,			// scorch marks, etc.
+	SS_SEE_THROUGH,		// ladders, grates, grills that may have small blended edges
+						// in addition to alpha test
+	SS_BANNER,
+
+	SS_INSIDE,			// inside body parts (i.e. heart)
+	SS_MID_INSIDE,
+	SS_MIDDLE,
+	SS_MID_OUTSIDE,
+	SS_OUTSIDE,			// outside body parts (i.e. ribs)
+	
+	SS_FOG,
+	
+	SS_UNDERWATER,		// for items that should be drawn in front of the water plane
+
+	SS_BLEND0,			// regular transparency and filters
+	SS_BLEND1,			// generally only used for additive type effects
+	SS_BLEND2,
+	SS_BLEND3,
+
+	SS_BLEND6,
+	SS_STENCIL_SHADOW,
+	SS_ALMOST_NEAREST,	// gun smoke puffs
+
+	SS_NEAREST			// blood blobs
+} shaderSort_t;
+
+
+#define MAX_SHADER_STAGES 8
+
+typedef enum {
+	GF_NONE,
+
+	GF_SIN,
+	GF_SQUARE,
+	GF_TRIANGLE,
+	GF_SAWTOOTH, 
+	GF_INVERSE_SAWTOOTH, 
+
+	GF_NOISE,
+	GF_RAND,
+
+} genFunc_t;
+
+
+typedef enum {
+	DEFORM_NONE,
+	DEFORM_WAVE,
+	DEFORM_NORMALS,
+	DEFORM_BULGE,
+	DEFORM_MOVE,
+	DEFORM_PROJECTION_SHADOW,
+	DEFORM_AUTOSPRITE,
+	DEFORM_AUTOSPRITE2,
+	DEFORM_TEXT0,
+	DEFORM_TEXT1,
+	DEFORM_TEXT2,
+	DEFORM_TEXT3,
+	DEFORM_TEXT4,
+	DEFORM_TEXT5,
+	DEFORM_TEXT6,
+	DEFORM_TEXT7
+} deform_t;
+
+typedef enum {
+	AGEN_IDENTITY,
+	AGEN_SKIP,
+	AGEN_ENTITY,
+	AGEN_ONE_MINUS_ENTITY,
+	AGEN_VERTEX,
+	AGEN_ONE_MINUS_VERTEX,
+	AGEN_LIGHTING_SPECULAR,
+	AGEN_WAVEFORM,
+	AGEN_PORTAL,
+	AGEN_BLEND,
+	AGEN_CONST,
+	AGEN_DOT,
+	AGEN_ONE_MINUS_DOT
+} alphaGen_t;
+
+typedef enum {
+	CGEN_BAD,
+	CGEN_IDENTITY_LIGHTING,	// tr.identityLight
+	CGEN_IDENTITY,			// always (1,1,1,1)
+	CGEN_SKIP,
+	CGEN_ENTITY,			// grabbed from entity's modulate field
+	CGEN_ONE_MINUS_ENTITY,	// grabbed from 1 - entity.modulate
+	CGEN_EXACT_VERTEX,		// tess.vertexColors
+	CGEN_VERTEX,			// tess.vertexColors * tr.identityLight
+	CGEN_ONE_MINUS_VERTEX,
+	CGEN_WAVEFORM,			// programmatically generated
+	CGEN_LIGHTING_DIFFUSE,
+	CGEN_LIGHTING_DIFFUSE_ENTITY, //diffuse lighting * entity
+	CGEN_FOG,				// standard fog
+	CGEN_CONST,				// fixed color
+	CGEN_LIGHTMAPSTYLE,
+} colorGen_t;
+
+typedef enum {
+	TCGEN_BAD,
+	TCGEN_IDENTITY,			// clear to 0,0
+	TCGEN_LIGHTMAP,
+	TCGEN_LIGHTMAP1,
+	TCGEN_LIGHTMAP2,
+	TCGEN_LIGHTMAP3,
+	TCGEN_TEXTURE,
+	TCGEN_ENVIRONMENT_MAPPED,
+	TCGEN_FOG,
+	TCGEN_VECTOR			// S and T from world coordinates
+} texCoordGen_t;
+
+typedef enum {
+	ACFF_NONE,
+	ACFF_MODULATE_RGB,
+	ACFF_MODULATE_RGBA,
+	ACFF_MODULATE_ALPHA
+} acff_t;
+
+typedef enum {
+	GLFOGOVERRIDE_NONE = 0,
+	GLFOGOVERRIDE_BLACK,
+	GLFOGOVERRIDE_WHITE,
+
+	GLFOGOVERRIDE_MAX
+} EGLFogOverride;
+
+typedef struct {
+	genFunc_t	func;
+
+	float base;
+	float amplitude;
+	float phase;
+	float frequency;
+} waveForm_t;
+
+#define TR_MAX_TEXMODS 4
+
+typedef enum {
+	TMOD_NONE,
+	TMOD_TRANSFORM,
+	TMOD_TURBULENT,
+	TMOD_SCROLL,
+	TMOD_SCALE,
+	TMOD_STRETCH,
+	TMOD_ROTATE,
+	TMOD_ENTITY_TRANSLATE
+} texMod_t;
+
+#define	MAX_SHADER_DEFORMS	3
+typedef struct {
+	deform_t	deformation;			// vertex coordinate modification type
+
+	vec3_t		moveVector;
+	waveForm_t	deformationWave;
+	float		deformationSpread;
+
+	float		bulgeWidth;
+	float		bulgeHeight;
+	float		bulgeSpeed;
+} deformStage_t;
+
+
+typedef struct {
+	texMod_t		type;
+
+	// used for TMOD_TURBULENT and TMOD_STRETCH
+	waveForm_t		wave;
+
+	// used for TMOD_TRANSFORM
+	float			matrix[2][2];		// s' = s * m[0][0] + t * m[1][0] + trans[0]
+	float			translate[2];		// t' = s * m[0][1] + t * m[0][1] + trans[1]
+
+	// used for TMOD_SCALE
+//	float			scale[2];			// s *= scale[0]
+	                                    // t *= scale[1]
+
+	// used for TMOD_SCROLL
+//	float			scroll[2];			// s' = s + scroll[0] * time
+										// t' = t + scroll[1] * time
+
+	// used for TMOD_ROTATE
+	// + = clockwise
+	// - = counterclockwise
+	//float			rotateSpeed;
+
+} texModInfo_t;
+
+
+#define SURFSPRITE_NONE			0
+#define SURFSPRITE_VERTICAL		1
+#define SURFSPRITE_ORIENTED		2
+#define SURFSPRITE_EFFECT		3
+#define SURFSPRITE_WEATHERFX	4
+#define SURFSPRITE_FLATTENED	5
+
+#define SURFSPRITE_FACING_NORMAL	0
+#define SURFSPRITE_FACING_UP		1
+#define SURFSPRITE_FACING_DOWN		2
+#define SURFSPRITE_FACING_ANY		3
+
+typedef struct surfaceSprite_s
+{
+	int				surfaceSpriteType;
+	float			width, height, density, wind, windIdle, fadeDist, fadeMax, fadeScale;
+	float			fxAlphaStart, fxAlphaEnd, fxDuration, vertSkew;
+	vec2_t			variance, fxGrow;
+	int				facing;		// Hangdown on vertical sprites, faceup on others.
+} surfaceSprite_t;
+
+typedef struct {
+	image_t			*image;
+
+	texCoordGen_t	tcGen;
+	vec3_t			*tcGenVectors;
+
+	texModInfo_t	*texMods;
+	short			numTexMods;
+	short			numImageAnimations;
+	float			imageAnimationSpeed;
+
+	bool			isLightmap;
+	bool			oneShotAnimMap;
+	bool			vertexLightmap;
+	bool			isVideoMap;
+
+	int				videoMapHandle;
+} textureBundle_t;
+
+#define NUM_TEXTURE_BUNDLES 2
+
+typedef struct {
+	bool			active;
+	bool			isDetail;
+#ifdef _XBOX
+	byte			isEnvironment;
+#endif
+#ifdef VV_LIGHTING
+	byte			isSpecular;
+	byte			isBumpMap;
+#endif 
+	byte			index;						// index of stage
+	byte			lightmapStyle;
+	
+	textureBundle_t	bundle[NUM_TEXTURE_BUNDLES];
+
+	waveForm_t		rgbWave;
+	colorGen_t		rgbGen;
+
+	waveForm_t		alphaWave;
+	alphaGen_t		alphaGen;
+
+	byte			constantColor[4];			// for CGEN_CONST and AGEN_CONST
+
+	unsigned int	stateBits;					// GLS_xxxx mask
+
+	acff_t			adjustColorsForFog;
+
+	EGLFogOverride	mGLFogColorOverride;
+
+	surfaceSprite_t	*ss;
+
+	// Whether this object emits a glow or not.
+	bool			glow;
+} shaderStage_t;
+
+struct shaderCommands_s;
+
+#define LIGHTMAP_2D			-4		// shader is for 2D rendering
+#define LIGHTMAP_BY_VERTEX	-3		// pre-lit triangle models
+#define LIGHTMAP_WHITEIMAGE	-2
+#define	LIGHTMAP_NONE		-1
+
+typedef enum {
+	CT_FRONT_SIDED,
+	CT_BACK_SIDED,
+	CT_TWO_SIDED
+} cullType_t;
+
+typedef enum {
+	FP_NONE,		// surface is translucent and will just be adjusted properly
+	FP_EQUAL,		// surface is opaque but possibly alpha tested
+	FP_LE			// surface is trnaslucent, but still needs a fog pass (fog surface)
+} fogPass_t;
+
+typedef struct {
+	float		cloudHeight;
+//	image_t		*outerbox[6], *innerbox[6];
+	image_t		*outerbox[6];
+} skyParms_t;
+
+typedef struct {
+	vec3_t	color;
+	float	depthForOpaque;
+} fogParms_t;
+
+
+typedef struct shader_s {
+	char		name[MAX_QPATH];		// game path, including extension
+	int			lightmapIndex[MAXLIGHTMAPS];	// for a shader to match, both name and lightmapIndex must match
+	byte		styles[MAXLIGHTMAPS];
+
+	int			index;					// this shader == tr.shaders[index]
+	int			sortedIndex;			// this shader == tr.sortedShaders[sortedIndex]
+
+	float		sort;					// lower numbered shaders draw before higher numbered
+
+	int			surfaceFlags;			// if explicitlyDefined, this will have SURF_* flags
+	int			contentFlags;
+
+	bool		defaultShader;			// we want to return index 0 if the shader failed to
+										// load for some reason, but R_FindShader should
+										// still keep a name allocated for it, so if
+										// something calls RE_RegisterShader again with
+										// the same name, we don't try looking for it again
+	bool		explicitlyDefined;		// found in a .shader file
+	bool		entityMergable;			// merge across entites optimizable (smoke, blood)
+
+	bool		isBumpMap;
+
+#ifdef _XBOX
+	bool		needsNormal;
+	bool		needsTangent;
+#endif
+
+	skyParms_t	*sky;
+	fogParms_t	*fogParms;
+
+	float		portalRange;			// distance to fog out at
+
+	int			multitextureEnv;		// 0, GL_MODULATE, GL_ADD (FIXME: put in stage)
+
+	cullType_t	cullType;				// CT_FRONT_SIDED, CT_BACK_SIDED, or CT_TWO_SIDED
+	bool		polygonOffset;			// set for decals and other items that must be offset 
+	bool		noMipMaps;				// for console fonts, 2D elements, etc.
+	bool		noPicMip;				// for images that must always be full resolution
+	bool		noTC;					// for images that don't want to be texture compressed (namely skies)
+
+	fogPass_t	fogPass;				// draw a blended pass, possibly with depth test equals
+
+	deformStage_t	*deforms[MAX_SHADER_DEFORMS];
+	short		numDeforms;
+
+	short		numUnfoggedPasses;
+	shaderStage_t	*stages;		
+
+	float			timeOffset;                                 // current time offset for this shader
+
+#ifndef _XBOX	// GLOWXXX
+	// True if this shader has a stage with glow in it (just an optimization).
+	bool hasGlow;
+#endif
+
+//	struct shader_s		*remappedShader;                  // current shader this one is remapped too
+	struct	shader_s	*next;
+} shader_t;
+
+
+/*
+Ghoul2 Insert Start
+*/
+ // bogus little registration system for hit and location based damage files in hunk memory
+/*
+typedef struct
+{
+	byte	*loc;
+	int		width;
+	int		height;
+	char	name[MAX_QPATH];
+} hitMatReg_t;
+
+#define MAX_HITMAT_ENTRIES 1000
+
+extern hitMatReg_t		hitMatReg[MAX_HITMAT_ENTRIES];
+*/
+/*
+Ghoul2 Insert End
+*/
+
+//=================================================================================
+
+// skins allow models to be retextured without modifying the model file
+typedef struct {
+	char		name[MAX_QPATH];
+	shader_t	*shader;
+} skinSurface_t;
+
+typedef struct skin_s {
+	char		name[MAX_QPATH];		// game path, including extension
+	int			numSurfaces;
+	skinSurface_t	*surfaces[128];
+} skin_t;
+
+
+typedef struct {
+	int			originalBrushNumber;
+	vec3_t		bounds[2];
+
+	unsigned	colorInt;				// in packed byte format
+	float		tcScale;				// texture coordinate vector scales
+	fogParms_t	parms;
+
+	// for clipping distance in fog when outside
+	qboolean	hasSurface;
+	float		surface[4];
+} fog_t;
+
+typedef struct {
+	orientationr_t	or;
+	orientationr_t	world;
+	vec3_t		pvsOrigin;			// may be different than or.origin for portals
+	qboolean	isPortal;			// true if this view is through a portal
+	qboolean	isMirror;			// the portal is a mirror, invert the face culling
+	int			frameSceneNum;		// copied from tr.frameSceneNum
+	int			frameCount;			// copied from tr.frameCount
+	cplane_t	portalPlane;		// clip anything behind this if mirroring
+	int			viewportX, viewportY, viewportWidth, viewportHeight;
+	float		fovX, fovY;
+	float		projectionMatrix[16];
+	cplane_t	frustum[5];
+	vec3_t		visBounds[2];
+	float		zFar;
+} viewParms_t;
+
+
+/*
+==============================================================================
+
+SURFACES
+
+==============================================================================
+*/
+
+// any changes in surfaceType must be mirrored in rb_surfaceTable[]
+typedef enum {
+	SF_BAD, 
+	SF_SKIP,				// ignore
+	SF_FACE,
+	SF_GRID,
+	SF_TRIANGLES,
+	SF_POLY,
+	SF_TERRAIN,
+	SF_MD3,
+/*
+Ghoul2 Insert Start
+*/
+	SF_MDX,
+/*
+Ghoul2 Insert End
+*/
+
+	SF_FLARE,
+	SF_ENTITY,				// beams, rails, lightning, etc that can be determined by entity
+	SF_DISPLAY_LIST,
+
+	SF_NUM_SURFACE_TYPES,
+	SF_MAX = 0xffffffff			// ensures that sizeof( surfaceType_t ) == sizeof( int )
+} surfaceType_t;
+
+typedef struct drawSurf_s {
+	unsigned			sort;			// bit combination for fast compares
+	surfaceType_t		*surface;		// any of surface*_t
+} drawSurf_t;
+
+#define	MAX_FACE_POINTS		64
+
+#define	MAX_PATCH_SIZE		32			// max dimensions of a patch mesh in map file
+#define	MAX_GRID_SIZE		65			// max dimensions of a grid mesh in memory
+
+// when cgame directly specifies a polygon, it becomes a srfPoly_t
+// as soon as it is called
+typedef struct srfPoly_s {
+	surfaceType_t	surfaceType;
+	qhandle_t		hShader;
+	int				fogIndex;
+	int				numVerts;
+	polyVert_t		*verts;
+} srfPoly_t;
+
+typedef struct srfDisplayList_s {
+	surfaceType_t	surfaceType;
+	int				listNum;
+} srfDisplayList_t;
+
+#ifdef _XBOX
+typedef struct srfFlare_s {
+	surfaceType_t	surfaceType;
+	unsigned short	origin[3];
+	unsigned short	normal[3];
+	byte			color[3];
+} srfFlare_t;
+
+#else // _XBOX
+
+typedef struct srfFlare_s {
+	surfaceType_t	surfaceType;
+	vec3_t			origin;
+	vec3_t			normal;
+	vec3_t			color;
+} srfFlare_t;
+
+#endif
+
+typedef struct srfGridMesh_s {
+	surfaceType_t	surfaceType;
+
+	// dynamic lighting information
+	int				dlightBits;
+
+	// culling information
+	vec3_t			meshBounds[2];
+	vec3_t			localOrigin;
+	float			meshRadius;
+
+	// lod information, which may be different
+	// than the culling information to allow for
+	// groups of curves that LOD as a unit
+	vec3_t			lodOrigin;
+	float			lodRadius;
+
+	// vertexes
+	int				width, height;
+	float			*widthLodError;
+	float			*heightLodError;
+	drawVert_t		verts[1];		// variable sized
+} srfGridMesh_t;
+
+
+
+#ifdef _XBOX
+// Added tangent size in here
+#define	VERTEXSIZE			(9+(MAXLIGHTMAPS*3))
+#define VERTEX_LM			8  
+#define	VERTEX_COLOR(flags)		(VERTEX_LM + (((flags) & 0x7F) * 2))
+#else
+#define	VERTEXSIZE			(6+(MAXLIGHTMAPS*3))
+#define VERTEX_LM			5
+#define	VERTEX_COLOR		(5+(MAXLIGHTMAPS*2))
+#endif
+
+
+#define	VERTEX_FINAL_COLOR	(5+(MAXLIGHTMAPS*3))
+
+
+
+#ifdef _XBOX
+
+#ifdef COMPRESS_VERTEX_COLORS
+#define NEXT_SURFPOINT(flags) (VERTEX_LM + (((flags) & 0x7F) * 2) + ((((flags) & 0x80) >> 7) * 4));
+#else
+#define NEXT_SURFPOINT(flags) (VERTEX_LM + (((flags) & 0x7F) * 2) + ((((flags) & 0x80) >> 7) * 8));
+#endif
+
+#define POINTS_ST_SCALE 128.0f
+#define POINTS_LIGHT_SCALE 65536.0f
+#define GLM_COMP_SIZE 64.0f
+
+#pragma pack (push, 1)
+typedef struct {
+	surfaceType_t	surfaceType;
+	cplane_t	plane;
+
+	// dynamic lighting information
+	int			dlightBits;
+
+	// triangle definitions (no normals at points)
+	unsigned char	numPoints;
+	unsigned short	numIndices;
+	unsigned short	ofsIndices;
+	unsigned char   flags; //highest bit - true if face uses vertex colors,
+							//low 7 bits - number of light maps
+	unsigned short	*srfPoints;			// variable sized
+										// there is a variable length list of indices here also
+} srfSurfaceFace_t;
+#pragma pack (pop)
+
+#else // _XBOX
+
+typedef struct {
+	surfaceType_t	surfaceType;
+	cplane_t	plane;
+
+	// dynamic lighting information
+	int			dlightBits;
+
+	// triangle definitions (no normals at points)
+	int			numPoints;
+	int			numIndices;
+	int			ofsIndices;
+	float		points[1][VERTEXSIZE];	// variable sized
+										// there is a variable length list of indices here also
+} srfSurfaceFace_t;
+#endif // _XBOX
+
+
+// misc_models in maps are turned into direct geometry by q3map
+typedef struct {
+	surfaceType_t	surfaceType;
+
+	// dynamic lighting information
+	int				dlightBits;
+
+	// culling information (FIXME: use this!)
+	vec3_t			bounds[2];
+//	vec3_t			localOrigin;
+//	float			radius;
+
+	// triangle definitions
+	int				numIndexes;
+	int				*indexes;
+
+	int				numVerts;
+	drawVert_t		*verts;
+} srfTriangles_t;
+
+
+extern	void (*rb_surfaceTable[SF_NUM_SURFACE_TYPES])(void *);
+
+/*
+==============================================================================
+
+BRUSH MODELS
+
+==============================================================================
+*/
+
+
+//
+// in memory representation
+//
+
+#define	SIDE_FRONT	0
+#define	SIDE_BACK	1
+#define	SIDE_ON		2
+
+typedef struct msurface_s {
+	int					viewCount;		// if == tr.viewCount, already added
+	struct shader_s		*shader;
+	int					fogIndex;
+
+	surfaceType_t		*data;			// any of srf*_t
+} msurface_t;
+
+
+
+#define	CONTENTS_NODE		-1
+
+#ifdef _XBOX
+#define	CONTENTS_NODE		-1
+#pragma pack (push, 1)
+typedef struct mnode_s {
+	// common with leaf and node
+	signed char	contents;		// -1 for nodes, to differentiate from leafs
+	int 		visframe;		// node needs to be traversed if current
+	short		mins[3], maxs[3];		// for bounding box culling
+	struct mnode_s *parent;
+
+	// node specific
+	unsigned int planeNum;
+	struct mnode_s	*children[2];	
+
+} mnode_t;
+
+struct mleaf_s {
+	// common with leaf and node
+	signed char	contents;		// -1 for nodes, to differentiate from leafs
+	int 		visframe;		// node needs to be traversed if current
+	short		mins[3], maxs[3];		// for bounding box culling
+	struct mnode_s *parent;
+
+	// leaf specific
+	short			cluster;
+	signed char		area;
+
+	unsigned short firstMarkSurfNum;
+	short		nummarksurfaces;
+};
+#pragma pack (pop)
+
+#else // _XBOX
+
+typedef struct mnode_s {
+	// common with leaf and node
+	int			contents;		// -1 for nodes, to differentiate from leafs
+	int			visframe;		// node needs to be traversed if current
+	vec3_t		mins, maxs;		// for bounding box culling
+	struct mnode_s	*parent;
+
+	// node specific
+	cplane_t	*plane;
+	struct mnode_s	*children[2];	
+
+	// leaf specific
+	int			cluster;
+	int			area;
+
+	msurface_t	**firstmarksurface;
+	int			nummarksurfaces;
+} mnode_t;
+
+#endif // _XBOX
+
+typedef struct {
+	vec3_t		bounds[2];		// for culling
+	msurface_t	*firstSurface;
+	int			numSurfaces;
+} bmodel_t;
+
+#ifdef _XBOX
+#pragma pack(push, 1)
+typedef struct {
+	byte flags;
+	byte latLong[2];
+	int data;
+
+	/*
+	   flags has the following bits:
+	   0 - ambientLight[0] and directLight[0] are not all zeros
+	   1 - ambientLight[1] and directLight[1] are not all zeros
+	   2 - ambientLight[2] and directLight[2] are not all zeros
+	   3 - ambientLight[3] and directLight[3] are not all zeros
+	   4 - styles[0] is not LS_NONE
+	   5 - styles[1] is not LS_NONE
+	   6 - styles[2] is not LS_NONE
+	   7 - styles[3] is not LS_NONE
+
+	   data points to memory which stores ambientLight, directLight and
+	   styles when they are not 0 or LS_NONE.
+	*/
+} mgrid_t;
+#pragma pack(pop)
+
+#else // _XBOX
+
+typedef struct {
+	byte		ambientLight[MAXLIGHTMAPS][3];
+	byte		directLight[MAXLIGHTMAPS][3];
+	byte		styles[MAXLIGHTMAPS];
+	byte		latLong[2];
+} mgrid_t;
+
+#endif // _XBOX
+
+#ifdef _XBOX
+template <class T>
+class SPARC;
+#endif
+typedef struct {
+#ifdef _XBOX
+	char		name[MAX_QPATH];		// ie: maps/tim_dm2.bsp
+	char		baseName[MAX_QPATH];	// ie: tim_dm2
+#endif
+
+	int			numShaders;
+	dshader_t	*shaders;
+
+	bmodel_t	*bmodels;
+
+	int			numplanes;
+	cplane_t	*planes;
+
+	int			numnodes;		// includes leafs
+	int			numDecisionNodes;
+	mnode_t		*nodes;
+#ifdef _XBOX
+	int			numleafs;
+	mleaf_s		*leafs;
+#endif
+
+	int			numsurfaces;
+	msurface_t	*surfaces;
+
+	int			nummarksurfaces;
+	msurface_t	**marksurfaces;
+
+	int			numfogs;
+	fog_t		*fogs;
+	int			globalFog;
+
+	int			startLightMapIndex;
+
+	vec3_t		lightGridOrigin;
+	vec3_t		lightGridSize;
+	vec3_t		lightGridInverseSize;
+	int			lightGridBounds[3];
+	mgrid_t			*lightGridData;
+	unsigned short	*lightGridArray;
+	int			numGridArrayElements;
+
+	int			numClusters;
+	int			clusterBytes;
+
+#ifdef _XBOX
+	SPARC<byte>	*vis;
+#else
+	const byte	*vis;			// may be passed in by CM_LoadMap to save space
+#endif
+
+	byte		*novis;			// clusterBytes of 0xff
+#ifdef _XBOX
+	qboolean	portalPresent;
+#endif
+} world_t;
+
+//======================================================================
+
+typedef enum {
+	MOD_BAD,
+	MOD_BRUSH,
+	MOD_MESH,
+/*
+Ghoul2 Insert Start
+*/
+   	MOD_MDXM,
+	MOD_MDXA
+/*
+Ghoul2 Insert End
+*/
+
+} modtype_t;
+
+typedef struct model_s {
+	char		name[MAX_QPATH];
+	modtype_t	type;
+	int			index;				// model = tr.models[model->mod_index]
+	
+	int			dataSize;			// just for listing purposes
+	bmodel_t	*bmodel;			// only if type == MOD_BRUSH
+	md3Header_t	*md3[MD3_MAX_LODS];	// only if type == MOD_MESH
+/*
+Ghoul2 Insert Start
+*/
+	mdxmHeader_t *mdxm;				// only if type == MOD_GL2M which is a GHOUL II Mesh file NOT a GHOUL II animation file
+	mdxaHeader_t *mdxa;				// only if type == MOD_GL2A which is a GHOUL II Animation file
+/*
+Ghoul2 Insert End
+*/
+	unsigned char	numLods;
+	bool			bspInstance;			// model is a bsp instance
+} model_t;
+
+
+#define	MAX_MOD_KNOWN	1024
+
+void		R_ModelInit (void);
+model_t		*R_GetModelByHandle( qhandle_t hModel );
+void		R_LerpTag( orientation_t *tag, qhandle_t handle, int startFrame, int endFrame, 
+					 float frac, const char *tagName );
+void		R_ModelBounds( qhandle_t handle, vec3_t mins, vec3_t maxs );
+
+void		R_Modellist_f (void);
+
+//====================================================
+#define	MAX_DRAWIMAGES			2048
+#define	MAX_LIGHTMAPS			256
+#define	MAX_SKINS				512	//1024
+
+
+#ifdef _XBOX
+#define	MAX_DRAWSURFS			0x4000
+#else
+#define	MAX_DRAWSURFS			0x10000
+#endif
+#define	DRAWSURF_MASK			(MAX_DRAWSURFS-1)
+
+/*
+
+the drawsurf sort data is packed into a single 32 bit value so it can be
+compared quickly during the qsorting process
+
+the bits are allocated as follows:
+
+22 - 31	: sorted shader index
+12 - 21	: entity index
+3 - 7	: fog index
+2		: used to be clipped flag
+0 - 1	: dlightmap index
+#define	QSORT_SHADERNUM_SHIFT	22
+#define	QSORT_ENTITYNUM_SHIFT	12
+#define	QSORT_FOGNUM_SHIFT		3
+
+	TTimo - 1.32
+31	:  used for alpha fading models (drawn last)
+18-30 : sorted shader index
+7-17  : entity index
+2-6   : fog index
+0-1   : dlightmap index
+*/
+
+#define	QSORT_SHADERNUM_SHIFT	18
+#define	QSORT_ENTITYNUM_SHIFT	7
+#define	QSORT_FOGNUM_SHIFT		2
+
+extern	int			gl_filter_min, gl_filter_max;
+
+/*
+** performanceCounters_t
+*/
+typedef struct {
+	int		c_sphere_cull_patch_in, c_sphere_cull_patch_clip, c_sphere_cull_patch_out;
+	int		c_box_cull_patch_in, c_box_cull_patch_clip, c_box_cull_patch_out;
+	int		c_sphere_cull_md3_in, c_sphere_cull_md3_clip, c_sphere_cull_md3_out;
+	int		c_box_cull_md3_in, c_box_cull_md3_clip, c_box_cull_md3_out;
+
+	int		c_leafs;
+	int		c_dlightSurfaces;
+	int		c_dlightSurfacesCulled;
+} frontEndCounters_t;
+
+#define	FOG_TABLE_SIZE		256
+#define FUNCTABLE_SIZE		1024
+#define FUNCTABLE_SIZE2		10
+#define FUNCTABLE_MASK		(FUNCTABLE_SIZE-1)
+
+
+// the renderer front end should never modify glstate_t
+typedef struct {
+	int			currenttextures[2];
+	int			currenttmu;
+	qboolean	finishCalled;
+	int			texEnv[2];
+	int			faceCulling;
+	unsigned long	glStateBits;
+} glstate_t;
+
+
+typedef struct {
+	int		c_surfaces, c_shaders, c_vertexes, c_indexes, c_totalIndexes;
+	float	c_overDraw;
+	
+	int		c_dlightVertexes;
+	int		c_dlightIndexes;
+
+	int		c_flareAdds;
+	int		c_flareTests;
+	int		c_flareRenders;
+
+	int		msec;			// total msec for backend run
+} backEndCounters_t;
+
+// all state modified by the back end is seperated
+// from the front end state
+typedef struct {
+	trRefdef_t	refdef;
+	viewParms_t	viewParms;
+	orientationr_t	ori;
+	backEndCounters_t	pc;
+	qboolean	isHyperspace;
+	trRefEntity_t	*currentEntity;
+	qboolean	skyRenderedThisView;	// flag for drawing sun
+
+	qboolean	projection2D;	// if qtrue, drawstretchpic doesn't need to change modes
+	byte		color2D[4];
+	qboolean	vertexes2D;		// shader needs to be finished
+	trRefEntity_t	entity2D;	// currentEntity will point at this when doing 2D rendering
+} backEndState_t;
+
+typedef struct srfTerrain_s
+{
+	surfaceType_t			surfaceType;
+	class CTRLandScape		*landscape;
+} srfTerrain_t;
+
+/*
+** trGlobals_t 
+**
+** Most renderer globals are defined here.
+** backend functions should never modify any of these fields,
+** but may read fields that aren't dynamically modified
+** by the frontend.
+*/
+#ifdef _XBOX
+#define NUM_SCRATCH_IMAGES 2
+#else
+#define NUM_SCRATCH_IMAGES 16
+#endif
+
+typedef struct {
+	qboolean				registered;		// cleared at shutdown, set at beginRegistration
+
+	int						visCount;		// incremented every time a new vis cluster is entered
+	int						frameCount;		// incremented every frame
+	int						sceneCount;		// incremented every scene
+	int						viewCount;		// incremented every view (twice a scene if portaled)
+											// and every R_MarkFragments call
+
+	int						frameSceneNum;	// zeroed at RE_BeginFrame
+
+	qboolean				worldMapLoaded;
+	world_t					*world;
+	char					worldDir[MAX_QPATH];		// ie: maps/tim_dm2
+
+#ifdef _XBOX
+	SPARC<byte>				*externalVisData;	// from RE_SetWorldVisData, shared with CM_Load
+#else
+	const byte				*externalVisData;	// from RE_SetWorldVisData, shared with CM_Load
+#endif
+
+	image_t					*defaultImage;	
+	image_t					*scratchImage[NUM_SCRATCH_IMAGES];
+	image_t					*fogImage;
+#ifndef _XBOX
+	image_t					*dlightImage;	// inverse-quare highlight for projective adding
+#endif
+	image_t					*whiteImage;			// full of 0xff
+	image_t					*identityLightImage;	// full of tr.identityLightByte
+
+	image_t					*screenImage; //reserve us a gl texnum to use with RF_DISTORTION
+
+#ifdef _XBOX
+	image_t					*saveGameImage;
+#endif //_XBOX
+	
+#ifndef _XBOX	// GLOWXXX
+	// Handle to the Glow Effect Vertex Shader. - AReis
+	GLuint					glowVShader;
+
+	// Handle to the Glow Effect Pixel Shader. - AReis
+	GLuint					glowPShader;
+
+	// Image the glowing objects are rendered to. - AReis
+	GLuint					screenGlow;
+
+	// A rectangular texture representing the normally rendered scene.
+	GLuint					sceneImage;
+
+	// Image used to downsample and blur scene to.	- AReis
+	GLuint					blurImage;
+#endif
+
+	shader_t				*defaultShader;
+	shader_t				*shadowShader;
+	shader_t				*distortionShader;
+	shader_t				*projectionShadowShader;
+
+	shader_t				*sunShader;
+
+	int						numLightmaps;
+	image_t					*lightmaps[MAX_LIGHTMAPS];
+
+	trRefEntity_t			*currentEntity;
+	trRefEntity_t			worldEntity;		// point currentEntity at this when rendering world
+	int						currentEntityNum;
+	unsigned				shiftedEntityNum;	// currentEntityNum << QSORT_ENTITYNUM_SHIFT (possible with high bit set for RF_ALPHA_FADE)
+	model_t					*currentModel;
+
+	viewParms_t				viewParms;
+
+	float					identityLight;		// 1.0 / ( 1 << overbrightBits )
+	int						identityLightByte;	// identityLight * 255
+	int						overbrightBits;		// r_overbrightBits->integer, but set to 0 if no hw gamma
+
+	orientationr_t			or;					// for current entity
+
+	trRefdef_t				refdef;
+
+	int						viewCluster;
+
+	vec3_t					sunLight;			// from the sky shader for this level
+	vec3_t					sunDirection;
+	vec3_t					sunAmbient;			// from the sky shader	(only used for John's terrain system)
+
+
+	frontEndCounters_t		pc;
+	int						frontEndMsec;		// not in pc due to clearing issue
+
+	//
+	// put large tables at the end, so most elements will be
+	// within the +/32K indexed range on risc processors
+	//
+	model_t					*models[MAX_MOD_KNOWN];
+	int						numModels;
+
+	world_t					bspModels[MAX_SUB_BSP];
+	int						numBSPModels;
+
+	// shader indexes from other modules will be looked up in tr.shaders[]
+	// shader indexes from drawsurfs will be looked up in sortedShaders[]
+	// lower indexed sortedShaders must be rendered first (opaque surfaces before translucent)
+	int						numShaders;
+	shader_t				*shaders[MAX_SHADERS];
+	shader_t				*sortedShaders[MAX_SHADERS];
+	int						iNumDeniedShaders;	// used for error-messages only
+
+	int						numSkins;
+	skin_t					*skins[MAX_SKINS];
+
+	float					sinTable[FUNCTABLE_SIZE];
+
+	float					squareTable[FUNCTABLE_SIZE];
+	float					triangleTable[FUNCTABLE_SIZE];
+	float					sawToothTable[FUNCTABLE_SIZE];
+	float					inverseSawToothTable[FUNCTABLE_SIZE];
+	float					fogTable[FOG_TABLE_SIZE];
+
+	float					rangedFog;
+
+	float					distanceCull;
+	srfTerrain_t			landScape;
+} trGlobals_t;
+
+int		 R_Images_StartIteration(void);
+image_t *R_Images_GetNextIteration(void);
+void	 R_Images_Clear(void);
+void	 R_Images_DeleteLightMaps(void);
+void	 R_Images_DeleteImage(image_t *pImage);
+
+
+extern backEndState_t	backEnd;
+extern trGlobals_t	tr;
+extern glconfig_t	glConfig;		// outside of TR since it shouldn't be cleared during ref re-init
+extern glstate_t	glState;		// outside of TR since it shouldn't be cleared during ref re-init
+
+
+//
+// cvars
+//
+extern cvar_t	*r_ignore;				// used for debugging anything
+extern cvar_t	*r_verbose;				// used for verbose debug spew
+
+extern cvar_t	*r_znear;				// near Z clip plane
+
+extern cvar_t	*r_stencilbits;			// number of desired stencil bits
+extern cvar_t	*r_depthbits;			// number of desired depth bits
+extern cvar_t	*r_colorbits;			// number of desired color bits, only relevant for fullscreen
+extern cvar_t	*r_stereo;				// desired pixelformat stereo flag
+extern cvar_t	*r_texturebits;			// number of desired texture bits
+										// 0 = use framebuffer depth
+										// 16 = use 16-bit textures
+										// 32 = use 32-bit textures
+										// all else = error
+extern cvar_t	*r_texturebitslm;		// number of desired lightmap texture bits
+
+extern cvar_t	*r_measureOverdraw;		// enables stencil buffer overdraw measurement
+
+extern cvar_t	*r_lodbias;				// push/pull LOD transitions
+extern cvar_t	*r_lodscale;
+
+extern cvar_t	*r_primitives;			// "0" = based on compiled vertex array existance
+										// "1" = glDrawElemet tristrips
+										// "2" = glDrawElements triangles
+										// "-1" = no drawing
+
+extern cvar_t	*r_fastsky;				// controls whether sky should be cleared or drawn
+extern cvar_t	*r_drawSun;				// controls drawing of sun quad
+extern cvar_t	*r_dynamiclight;		// dynamic lights enabled/disabled
+extern cvar_t	*r_dlightBacks;			// dlight non-facing surfaces for continuity
+
+extern	cvar_t	*r_norefresh;			// bypasses the ref rendering
+extern	cvar_t	*r_drawentities;		// disable/enable entity rendering
+extern	cvar_t	*r_drawworld;			// disable/enable world rendering
+extern	cvar_t	*r_drawfog;				// disable/enable fog rendering
+extern	cvar_t	*r_speeds;				// various levels of information display
+extern  cvar_t	*r_detailTextures;		// enables/disables detail texturing stages
+
+extern	cvar_t	*r_novis;				// disable/enable usage of PVS
+extern	cvar_t	*r_nocull;
+extern	cvar_t	*r_facePlaneCull;		// enables culling of planar surfaces with back side test
+extern	cvar_t	*r_nocurves;
+extern	cvar_t	*r_showcluster;
+
+extern cvar_t	*r_dlightStyle;
+extern cvar_t	*r_surfaceSprites;
+extern cvar_t	*r_surfaceWeather;
+
+extern cvar_t	*r_windSpeed;
+extern cvar_t	*r_windAngle;
+extern cvar_t	*r_windGust;
+extern cvar_t	*r_windDampFactor;
+extern cvar_t	*r_windPointForce;
+extern cvar_t	*r_windPointX;
+extern cvar_t	*r_windPointY;
+
+extern cvar_t	*r_mode;				// video mode
+extern cvar_t	*r_fullscreen;
+extern cvar_t	*r_gamma;
+extern cvar_t	*r_displayRefresh;		// optional display refresh option
+extern cvar_t	*r_ignorehwgamma;		// overrides hardware gamma capabilities
+
+extern cvar_t	*r_allowExtensions;				// global enable/disable of OpenGL extensions
+extern cvar_t	*r_ext_compressed_textures;		// these control use of specific extensions
+extern cvar_t	*r_ext_compressed_lightmaps;	// turns on compression of lightmaps, off by default
+extern cvar_t	*r_ext_preferred_tc_method;
+extern cvar_t	*r_ext_gamma_control;
+extern cvar_t	*r_ext_texenv_op;
+extern cvar_t	*r_ext_multitexture;
+extern cvar_t	*r_ext_compiled_vertex_array;
+extern cvar_t	*r_ext_texture_env_add;
+extern cvar_t	*r_ext_texture_filter_anisotropic;
+
+extern cvar_t	*r_DynamicGlow;
+extern cvar_t	*r_DynamicGlowPasses;
+extern cvar_t	*r_DynamicGlowDelta;
+extern cvar_t	*r_DynamicGlowIntensity;
+extern cvar_t	*r_DynamicGlowSoft;
+extern cvar_t	*r_DynamicGlowWidth;
+extern cvar_t	*r_DynamicGlowHeight;
+
+extern	cvar_t	*r_nobind;						// turns off binding to appropriate textures
+extern	cvar_t	*r_singleShader;				// make most world faces use default shader
+extern	cvar_t	*r_colorMipLevels;				// development aid to see texture mip usage
+extern	cvar_t	*r_picmip;						// controls picmip values
+extern	cvar_t	*r_finish;
+extern	cvar_t	*r_swapInterval;
+extern	cvar_t	*r_textureMode;
+extern	cvar_t	*r_offsetFactor;
+extern	cvar_t	*r_offsetUnits;
+
+extern	cvar_t	*r_fullbright;					// avoid lightmap pass
+extern	cvar_t	*r_lightmap;					// render lightmaps only
+extern	cvar_t	*r_vertexLight;					// vertex lighting mode for better performance
+
+extern	cvar_t	*r_logFile;						// number of frames to emit GL logs
+extern	cvar_t	*r_showtris;					// enables wireframe rendering of the world
+extern	cvar_t	*r_showtriscolor;				// changes wireframe color
+extern	cvar_t	*r_showsky;						// forces sky in front of all surfaces
+extern	cvar_t	*r_shownormals;					// draws wireframe normals
+extern	cvar_t	*r_clear;						// force screen clear every frame
+
+extern	cvar_t	*r_shadows;						// controls shadows: 0 = none, 1 = blur, 2 = stencil, 3 = black planar projection
+extern	cvar_t	*r_flares;						// light flares
+
+extern	cvar_t	*r_intensity;
+
+extern	cvar_t	*r_lockpvs;
+extern	cvar_t	*r_noportals;
+extern	cvar_t	*r_portalOnly;
+
+extern	cvar_t	*r_subdivisions;
+extern	cvar_t	*r_lodCurveError;
+extern	cvar_t	*r_skipBackEnd;
+
+extern	cvar_t	*r_ignoreGLErrors;
+
+extern	cvar_t	*r_overBrightBits;
+
+extern	cvar_t	*r_debugSurface;
+extern	cvar_t	*r_simpleMipMaps;
+
+extern	cvar_t	*r_showImages;
+extern	cvar_t	*r_debugSort;
+extern	cvar_t	*r_debugStyle;
+
+#ifdef _XBOX
+extern	cvar_t	*r_hdreffect;
+extern  cvar_t  *r_sundir_x;
+extern  cvar_t  *r_sundir_y;
+extern  cvar_t  *r_sundir_z;
+extern  cvar_t  *r_hdrbloom;
+extern	cvar_t	*r_hdrcutoff;
+#endif
+
+/*
+Ghoul2 Insert Start
+*/
+extern	cvar_t	*r_noGhoul2;
+/*
+Ghoul2 Insert End
+*/
+//====================================================================
+
+// Point sprite stuff.
+extern cvar_t	*r_ext_point_parameters;
+extern cvar_t	*r_ext_nv_point_sprite;
+
+
+float R_NoiseGet4f( float x, float y, float z, float t );
+void  R_NoiseInit( void );
+
+void R_SwapBuffers( int );
+
+void R_RenderView( viewParms_t *parms );
+
+void R_AddMD3Surfaces( trRefEntity_t *e );
+void R_AddNullModelSurfaces( trRefEntity_t *e );
+void R_AddBeamSurfaces( trRefEntity_t *e );
+void R_AddRailSurfaces( trRefEntity_t *e, qboolean isUnderwater );
+void R_AddLightningBoltSurfaces( trRefEntity_t *e );
+
+void R_AddPolygonSurfaces( void );
+
+void R_DecomposeSort( unsigned sort, int *entityNum, shader_t **shader, 
+					 int *fogNum, int *dlightMap );
+
+void R_AddDrawSurf( const surfaceType_t *surface, const shader_t *shader, int fogIndex, int dlightMap );
+
+
+#define	CULL_IN		0		// completely unclipped
+#define	CULL_CLIP	1		// clipped by one or more planes
+#define	CULL_OUT	2		// completely outside the clipping planes
+void R_LocalNormalToWorld (const vec3_t local, vec3_t world);
+void R_LocalPointToWorld (const vec3_t local, vec3_t world);
+void R_WorldNormalToEntity (const vec3_t localVec, vec3_t world); 
+//void R_WorldPointToEntity (const vec3_t localVec, vec3_t world);
+int R_CullLocalBox (const vec3_t bounds[2]);
+int R_CullPointAndRadius( const vec3_t pt, float radius );
+int R_CullLocalPointAndRadius( const vec3_t pt, float radius );
+
+void R_RotateForEntity( const trRefEntity_t *ent, const viewParms_t *viewParms, orientationr_t *or );
+
+#ifdef VV_LIGHTING
+void R_SetupEntityLightingGrid( trRefEntity_t *ent );
+void R_AddWorldSurface( msurface_t *surf, int dlightBits, qboolean noViewCount = qfalse );
+#endif
+
+/*
+** GL wrapper/helper functions
+*/
+void	GL_Bind( image_t *image );
+void	GL_SetDefaultState (void);
+void	GL_SelectTexture( int unit );
+void	GL_TextureMode( const char *string );
+void	GL_CheckErrors( void );
+void	GL_State( unsigned long stateVector );
+void	GL_TexEnv( int env );
+void	GL_Cull( int cullType );
+
+#define GLS_SRCBLEND_ZERO						0x00000001
+#define GLS_SRCBLEND_ONE						0x00000002
+#define GLS_SRCBLEND_DST_COLOR					0x00000003
+#define GLS_SRCBLEND_ONE_MINUS_DST_COLOR		0x00000004
+#define GLS_SRCBLEND_SRC_ALPHA					0x00000005
+#define GLS_SRCBLEND_ONE_MINUS_SRC_ALPHA		0x00000006
+#define GLS_SRCBLEND_DST_ALPHA					0x00000007
+#define GLS_SRCBLEND_ONE_MINUS_DST_ALPHA		0x00000008
+#define GLS_SRCBLEND_ALPHA_SATURATE				0x00000009
+#define		GLS_SRCBLEND_BITS					0x0000000f
+
+#define GLS_DSTBLEND_ZERO						0x00000010
+#define GLS_DSTBLEND_ONE						0x00000020
+#define GLS_DSTBLEND_SRC_COLOR					0x00000030
+#define GLS_DSTBLEND_ONE_MINUS_SRC_COLOR		0x00000040
+#define GLS_DSTBLEND_SRC_ALPHA					0x00000050
+#define GLS_DSTBLEND_ONE_MINUS_SRC_ALPHA		0x00000060
+#define GLS_DSTBLEND_DST_ALPHA					0x00000070
+#define GLS_DSTBLEND_ONE_MINUS_DST_ALPHA		0x00000080
+#define		GLS_DSTBLEND_BITS					0x000000f0
+
+#define GLS_DEPTHMASK_TRUE						0x00000100
+
+#define GLS_POLYMODE_LINE						0x00001000
+
+#define GLS_DEPTHTEST_DISABLE					0x00010000
+#define GLS_DEPTHFUNC_EQUAL						0x00020000
+
+#define GLS_ATEST_GT_0							0x10000000
+#define GLS_ATEST_LT_80							0x20000000
+#define GLS_ATEST_GE_80							0x40000000
+#define GLS_ATEST_GE_C0							0x80000000
+#define	GLS_ATEST_BITS							0xF0000000
+
+#define GLS_DEFAULT			GLS_DEPTHMASK_TRUE
+#define GLS_ALPHA			(GLS_SRCBLEND_SRC_ALPHA | GLS_DSTBLEND_ONE_MINUS_SRC_ALPHA)
+
+void	RE_StretchRaw (int x, int y, int w, int h, int cols, int rows, const byte *data, int iClient, qboolean bDirty );
+void	RE_UploadCinematic (int cols, int rows, const byte *data, int client, qboolean dirty);
+void	RE_GetScreenShot(byte *data, int w, int h);
+#ifndef _XBOX
+byte*	RE_TempRawImage_ReadFromFile(const char *psLocalFilename, int *piWidth, int *piHeight, byte *pbReSampleBuffer, qboolean qbVertFlip);
+#endif
+void	RE_TempRawImage_CleanUp();
+
+void		RE_BeginRegistration( glconfig_t *glconfig );
+void		RE_LoadWorldMap( const char *mapname );
+#ifdef _XBOX
+void		RE_SetWorldVisData( SPARC<byte> *vis );
+#else
+void		RE_SetWorldVisData( const byte *vis );
+#endif
+qhandle_t	RE_RegisterModel( const char *name );
+qhandle_t	RE_RegisterSkin( const char *name );
+int			RE_GetAnimationCFG(const char *psCFGFilename, char *psDest, int iDestSize);
+void		RE_Shutdown( qboolean destroyWindow );
+
+void		RE_RegisterMedia_LevelLoadBegin(const char *psMapName, ForceReload_e eForceReload, qboolean bAllowScreenDissolve);
+void		RE_RegisterMedia_LevelLoadEnd(void);
+int			RE_RegisterMedia_GetLevel(void);
+//
+//void		RE_RegisterModels_LevelLoadBegin(const char *psMapName);
+qboolean	RE_RegisterModels_LevelLoadEnd(qboolean bDeleteEverythingNotUsedThisLevel = qfalse );
+void*		RE_RegisterModels_Malloc(int iSize, void *pvDiskBufferIfJustLoaded, const char *psModelFileName, qboolean *pqbAlreadyFound, memtag_t eTag);
+void		RE_RegisterModels_StoreShaderRequest(const char *psModelFileName, const char *psShaderName, const int *piShaderIndexPoke);
+void		RE_RegisterModels_Info_f(void);
+//void		RE_RegisterImages_LevelLoadBegin(const char *psMapName);
+qboolean	RE_RegisterImages_LevelLoadEnd(void);
+void		RE_RegisterImages_Info_f(void);
+
+
+model_t		*R_AllocModel( void );
+
+void    	R_Init( void );
+image_t		*R_FindImageFile( const char *name, qboolean mipmap, qboolean allowPicmip, qboolean allowTC, int glWrapClampMode );
+
+#ifdef _XBOX
+image_t		*R_CreateImage( const char *name, const byte *pic, int width, int height, GLenum format, qboolean mipmap, qboolean allowPicmip, int wrapClampMode);
+#else
+image_t		*R_CreateImage( const char *name, const byte *pic, int width, int height, GLenum format, qboolean mipmap, qboolean allowPicmip, qboolean allowTC, int wrapClampMode,int fileSize=0);
+#endif
+
+qboolean	R_GetModeInfo( int *width, int *height, int mode );
+
+void		R_SetColorMappings( void );
+void		R_GammaCorrect( byte *buffer, int bufSize );
+
+void	R_ImageList_f( void );
+void	R_SkinList_f( void );
+void	R_ScreenShot_f( void );
+void	R_ScreenShotTGA_f( void );
+
+void	R_InitFogTable( void );
+float	R_FogFactor( float s, float t );
+void	R_InitImages( void );
+void	R_DeleteTextures( void );
+float	R_SumOfUsedImages( qboolean bUseFormat );
+void	R_InitSkins( void );
+skin_t	*R_GetSkinByHandle( qhandle_t hSkin );
+
+
+//
+// tr_shader.c
+//
+extern	const int	lightmapsNone[MAXLIGHTMAPS];
+extern	const int	lightmaps2d[MAXLIGHTMAPS];
+extern	const int	lightmapsVertex[MAXLIGHTMAPS];
+extern	const int	lightmapsFullBright[MAXLIGHTMAPS];
+extern	const byte	stylesDefault[MAXLIGHTMAPS];
+
+qhandle_t		 RE_RegisterShader( const char *name );
+qhandle_t		 RE_RegisterShaderNoMip( const char *name );
+
+shader_t	*R_FindShader( const char *name, const int *lightmapIndex, const byte *styles, qboolean mipRawImage );
+shader_t	*R_GetShaderByHandle( qhandle_t hShader );
+void		R_InitShaders( void );
+void		R_ShaderList_f( void );
+
+
+/*
+====================================================================
+
+IMPLEMENTATION SPECIFIC FUNCTIONS
+
+====================================================================
+*/
+
+void		GLimp_Init( void );
+void		GLimp_Shutdown( void );
+void		GLimp_EndFrame( void );
+
+void		GLimp_LogComment( char *comment );
+
+#ifndef _XBOX
+void		GLimp_SetGamma( unsigned char red[256], 
+						    unsigned char green[256],
+							unsigned char blue[256] );
+#endif
+
+
+#ifdef _XBOX
+typedef struct 
+{
+	char		levelName[_MAX_PATH];
+	vec3_t		sundir;
+	bool		hdrEnable;
+	float		hdrBloom;
+	float		hdrCutoff;
+} levelLightParm_t;
+
+void R_GetLightParmsForLevel();
+void R_LoadLevelLightParms();
+#endif
+
+
+/*
+====================================================================
+
+TESSELATOR/SHADER DECLARATIONS
+
+====================================================================
+*/
+typedef byte color4ub_t[4];
+
+typedef struct stageVars
+{
+#ifdef _XBOX
+	unsigned long colors[SHADER_MAX_VERTEXES];
+#else
+	color4ub_t	colors[SHADER_MAX_VERTEXES];
+#endif
+	vec2_t		texcoords[NUM_TEXTURE_BUNDLES][SHADER_MAX_VERTEXES];
+} stageVars_t;
+
+#define	NUM_TEX_COORDS		(MAXLIGHTMAPS+1)
+
+struct shaderCommands_s 
+{
+	glIndex_t	indexes[SHADER_MAX_INDEXES];
+	vec4_t		xyz[SHADER_MAX_VERTEXES];
+	vec4_t		normal[SHADER_MAX_VERTEXES];
+#ifdef _XBOX
+	vec4_t		tangent[SHADER_MAX_VERTEXES];
+#endif
+	vec2_t		texCoords[SHADER_MAX_VERTEXES][NUM_TEX_COORDS];
+	color4ub_t	vertexColors[SHADER_MAX_VERTEXES];
+	byte		vertexAlphas[SHADER_MAX_VERTEXES][4];
+	int			vertexDlightBits[SHADER_MAX_VERTEXES];
+
+	stageVars_t	svars;
+
+	shader_t	*shader;
+	int			fogNum;
+
+	int			dlightBits;	// or together of all vertexDlightBits
+
+	int			numIndexes;
+	int			numVertexes;
+
+	// info extracted from current shader
+	int			numPasses;
+#ifdef _XBOX
+	int		    currentPass;
+	bool		setTangents;
+#endif
+	void		(*currentStageIteratorFunc)( void );
+	shaderStage_t	*xstages;
+
+	int			registration;
+
+	qboolean	SSInitializedWind;
+
+	//rww - doing a fade, don't compute shader color/alpha overrides
+	bool		fading;
+};
+
+typedef __declspec(align(16)) shaderCommands_s	shaderCommands_t;
+
+extern	shaderCommands_t	tess;
+
+extern	color4ub_t	styleColors[MAX_LIGHT_STYLES];
+extern	bool		styleUpdated[MAX_LIGHT_STYLES];
+
+void RB_BeginSurface(shader_t *shader, int fogNum );
+void RB_EndSurface(void);
+void RB_CheckOverflow( int verts, int indexes );
+#define RB_CHECKOVERFLOW(v,i) if (tess.numVertexes + (v) >= SHADER_MAX_VERTEXES || tess.numIndexes + (i) >= SHADER_MAX_INDEXES ) {RB_CheckOverflow(v,i);}
+
+void RB_StageIteratorGeneric( void );
+void RB_StageIteratorSky( void );
+
+void RB_AddQuadStamp( vec3_t origin, vec3_t left, vec3_t up, byte *color );
+void RB_AddQuadStampExt( vec3_t origin, vec3_t left, vec3_t up, byte *color, float s1, float t1, float s2, float t2 );
+
+void RB_ShowImages( void );
+
+/*
+============================================================
+
+WORLD MAP
+
+============================================================
+*/
+
+void R_AddBrushModelSurfaces( trRefEntity_t *e );
+void R_AddWorldSurfaces( void );
+
+
+/*
+============================================================
+
+FLARES
+
+============================================================
+*/
+
+void R_ClearFlares( void );
+
+void RB_AddFlare( void *surface, int fogNum, vec3_t point, vec3_t color, vec3_t normal, float lightScale );
+void RB_AddDlightFlares( void );
+void RB_RenderFlares (void);
+
+/*
+============================================================
+
+LIGHTS
+
+============================================================
+*/
+
+void R_DlightBmodel( bmodel_t *bmodel, qboolean NoLight );
+void R_SetupEntityLighting( const trRefdef_t *refdef, trRefEntity_t *ent );
+void R_TransformDlights( int count, dlight_t *dl, orientationr_t *or );
+
+
+/*
+============================================================
+
+SHADOWS
+
+============================================================
+*/
+
+void RB_ShadowTessEnd( void );
+void RB_ShadowFinish( void );
+void RB_ProjectionShadowDeform( void );
+
+/*
+============================================================
+
+SKIES
+
+============================================================
+*/
+
+void R_BuildCloudData( shaderCommands_t *shader );
+void R_InitSkyTexCoords( float cloudLayerHeight );
+void R_DrawSkyBox( shaderCommands_t *shader );
+void RB_DrawSun( void );
+void RB_ClipSkyPolygons( shaderCommands_t *shader );
+
+/*
+============================================================
+
+CURVE TESSELATION
+
+============================================================
+*/
+#ifdef _XBOX
+srfGridMesh_t *R_SubdividePatchToGrid( int width, int height,
+								drawVert_t* points,
+								drawVert_t* ctl, float* errorTable );
+#else
+srfGridMesh_t *R_SubdividePatchToGrid( int width, int height,
+								drawVert_t points[MAX_PATCH_SIZE*MAX_PATCH_SIZE] );
+#endif
+/*
+Ghoul2 Insert Start
+*/
+
+float ProjectRadius( float r, vec3_t location );
+/*
+Ghoul2 Insert End
+*/
+
+
+/*
+============================================================
+
+MARKERS, POLYGON PROJECTION ON WORLD POLYGONS
+
+============================================================
+*/
+
+int R_MarkFragments( int numPoints, const vec3_t *points, const vec3_t projection,
+				   int maxPoints, vec3_t pointBuffer, int maxFragments, markFragment_t *fragmentBuffer );
+
+/*
+============================================================
+
+SCENE GENERATION
+
+============================================================
+*/
+
+void R_ToggleSmpFrame( void );
+
+void RE_ClearScene( void );
+void RE_AddRefEntityToScene( const refEntity_t *ent );
+void RE_AddPolyToScene( qhandle_t hShader , int numVerts, const polyVert_t *verts );
+void RE_AddLightToScene( const vec3_t org, float intensity, float r, float g, float b );
+void RE_RenderScene( const refdef_t *fd );
+
+qboolean RE_GetLighting( const vec3_t origin, vec3_t ambientLight, vec3_t directedLight, vec3_t lightDir );
+
+// Only returns a four sided face and normal of the best face to break ( this is for glass right now )
+void RE_GetBModelVerts( int bmodelIndex, vec3_t *verts, vec3_t normal );
+
+/*
+=============================================================
+
+ANIMATED MODELS
+
+=============================================================
+*/
+
+void R_MakeAnimModel( model_t *model );
+void R_AddAnimSurfaces( trRefEntity_t *ent );
+/*
+Ghoul2 Insert Start
+*/
+#pragma warning (disable: 4512)	//default assignment operator could not be gened
+class CBoneCache;
+
+class CRenderableSurface
+{
+public:
+#ifdef _G2_GORE
+	int				ident;
+#else
+	const int		ident;			// ident of this surface - required so the materials renderer knows what sort of surface this refers to 
+#endif
+ 	CBoneCache 		*boneCache;		// pointer to transformed bone list for this surf
+	mdxmSurface_t	*surfaceData;	// pointer to surface data loaded into file - only used by client renderer DO NOT USE IN GAME SIDE - if there is a vid restart this will be out of wack on the game
+#ifdef _G2_GORE
+	float			*alternateTex;		// alternate texture coordinates.
+	void			*goreChain;
+
+	float			scale;
+	float			fade;
+	float			impactTime; // this is a number between 0 and 1 that dictates the progression of the bullet impact
+#endif
+
+#ifdef _G2_GORE
+	CRenderableSurface& operator= ( const CRenderableSurface& src )
+	{
+		ident	 = src.ident;
+		boneCache = src.boneCache;
+		surfaceData = src.surfaceData;
+		alternateTex = src.alternateTex;
+		goreChain = src.goreChain;
+
+		return *this;
+	}
+#endif
+
+CRenderableSurface():	
+	ident(SF_MDX),
+	boneCache(0),
+#ifdef _G2_GORE
+	surfaceData(0),
+	alternateTex(0),
+	goreChain(0)
+#else
+	surfaceData(0)
+#endif
+	{}
+
+	void Init()
+	{
+		boneCache=0;
+		surfaceData=0;
+#ifdef _G2_GORE
+		ident = SF_MDX;
+		alternateTex=0;
+		goreChain=0;
+#endif
+	}
+};
+
+void R_AddGhoulSurfaces( trRefEntity_t *ent );
+void RB_SurfaceGhoul( CRenderableSurface *surface );
+/*
+Ghoul2 Insert End
+*/
+
+
+
+/*
+=============================================================
+=============================================================
+*/
+void	R_TransformModelToClip( const vec3_t src, const float *modelMatrix, const float *projectionMatrix,
+							vec4_t eye, vec4_t dst );
+void	R_TransformClipToWindow( const vec4_t clip, const viewParms_t *view, vec4_t normalized, vec4_t window );
+
+void	RB_DeformTessGeometry( void );
+
+void	RB_CalcScaleTexCoords( const float scale[2], float *dstTexCoords );
+void	RB_CalcScrollTexCoords( const float scroll[2], float *dstTexCoords );
+void	RB_CalcStretchTexCoords( const waveForm_t *wf, float *texCoords );
+void	RB_CalcTransformTexCoords( const texModInfo_t *tmi, float *dstTexCoords );
+void	RB_CalcRotateTexCoords( float rotSpeed, float *dstTexCoords );
+
+void	RB_CalcEnvironmentTexCoords( float *dstTexCoords );
+void	RB_CalcFogTexCoords( float *dstTexCoords );
+void	RB_CalcTurbulentTexCoords( const waveForm_t *wf, float *dstTexCoords );
+
+#ifdef _XBOX
+void	RB_CalcWaveColor( const waveForm_t *wf, DWORD *dstColors );
+void	RB_CalcColorFromEntity( DWORD *dstColors );
+void	RB_CalcColorFromOneMinusEntity( DWORD *dstColors );
+void	RB_CalcWaveAlpha( const waveForm_t *wf, DWORD *dstColors );
+void	RB_CalcSpecularAlpha( DWORD *alphas );
+void	RB_CalcAlphaFromEntity( DWORD *dstColors );
+void	RB_CalcAlphaFromOneMinusEntity( DWORD *dstColors );
+void	RB_CalcModulateColorsByFog( DWORD *dstColors );
+void	RB_CalcModulateAlphasByFog( DWORD *dstColors );
+void	RB_CalcModulateRGBAsByFog( DWORD *dstColors );
+#else
+void	RB_CalcWaveColor( const waveForm_t *wf, unsigned char *dstColors );
+void	RB_CalcColorFromEntity( unsigned char *dstColors );
+void	RB_CalcColorFromOneMinusEntity( unsigned char *dstColors );
+void	RB_CalcWaveAlpha( const waveForm_t *wf, unsigned char *dstColors );
+void	RB_CalcSpecularAlpha( unsigned char *alphas );
+void	RB_CalcAlphaFromEntity( unsigned char *dstColors );
+void	RB_CalcAlphaFromOneMinusEntity( unsigned char *dstColors );
+void	RB_CalcModulateColorsByFog( unsigned char *dstColors );
+void	RB_CalcModulateAlphasByFog( unsigned char *dstColors );
+void	RB_CalcModulateRGBAsByFog( unsigned char *dstColors );
+#endif
+
+void	RB_CalcDiffuseColor( unsigned char *colors );
+void	RB_CalcDiffuseEntityColor( unsigned char *colors );
+void	RB_CalcDisintegrateColors( unsigned char *colors, colorGen_t rgbGen );
+void	RB_CalcDisintegrateVertDeform( void );
+/*
+=============================================================
+
+RENDERER BACK END FUNCTIONS
+
+=============================================================
+*/
+
+void RB_RenderThread( void );
+void RB_ExecuteRenderCommands( const void *data );
+
+/*
+=============================================================
+
+RENDERER BACK END COMMAND QUEUE
+
+=============================================================
+*/
+
+#ifdef _XBOX
+#define	MAX_RENDER_COMMANDS	0x18000
+#else
+#define	MAX_RENDER_COMMANDS	0x40000
+#endif
+
+typedef struct {
+	byte	cmds[MAX_RENDER_COMMANDS];
+	int		used;
+} renderCommandList_t;
+
+typedef struct {
+	int		commandId;
+	float	color[4];
+} setColorCommand_t;
+
+typedef struct {
+	int		commandId;
+	int		buffer;
+} drawBufferCommand_t;
+
+typedef struct {
+	int		commandId;
+	image_t	*image;
+	int		width;
+	int		height;
+	void	*data;
+} subImageCommand_t;
+
+typedef struct {
+	int		commandId;
+} swapBuffersCommand_t;
+
+typedef struct {
+	int		commandId;
+	int		buffer;
+} endFrameCommand_t;
+
+typedef struct {
+	int		commandId;
+	shader_t	*shader;
+	float	x, y;
+	float	w, h;
+	float	s1, t1;
+	float	s2, t2;
+} stretchPicCommand_t;
+
+typedef struct {
+	int		commandId;
+	shader_t	*shader;
+	float	x, y;
+	float	w, h;
+	float	s1, t1;
+	float	s2, t2;
+	float	a;
+} rotatePicCommand_t;
+
+typedef struct
+{
+	int			commandId;
+} setModeCommand_t;
+
+typedef struct 
+{
+	int		commandId;
+	float	x, y;
+	float	w, h;
+} scissorCommand_t;
+
+typedef struct {
+	int		commandId;
+	trRefdef_t	refdef;
+	viewParms_t	viewParms;
+	drawSurf_t *drawSurfs;
+	int		numDrawSurfs;
+} drawSurfsCommand_t;
+
+typedef enum {
+	RC_END_OF_LIST,
+	RC_SET_COLOR,
+	RC_STRETCH_PIC,
+	RC_SCISSOR,
+	RC_ROTATE_PIC,
+	RC_ROTATE_PIC2,
+	RC_DRAW_SURFS,
+	RC_DRAW_BUFFER,
+	RC_SWAP_BUFFERS,
+	RC_WORLD_EFFECTS,
+} renderCommand_t;
+
+
+// these are sort of arbitrary limits.
+// the limits apply to the sum of all scenes in a frame --
+// the main view, all the 3D icons, etc
+#ifdef _XBOX
+#define	MAX_POLYS		512
+#else
+#define	MAX_POLYS		2048
+#endif
+#define	MAX_POLYVERTS	( MAX_POLYS * 4 )
+
+// all of the information needed by the back end must be
+// contained in a backEndData_t.  left over from SMP duplications, 
+// could optimize to point directly at frontend data instead of copying?
+typedef struct {
+	drawSurf_t	drawSurfs[MAX_DRAWSURFS];
+#ifndef VV_LIGHTING
+	dlight_t	dlights[MAX_DLIGHTS];
+#endif
+	trRefEntity_t	entities[MAX_ENTITIES];
+	srfPoly_t	polys[MAX_POLYS];
+	polyVert_t	polyVerts[MAX_POLYVERTS];
+	renderCommandList_t	commands;
+} backEndData_t;
+
+extern	backEndData_t	*backEndData;
+
+void *R_GetCommandBuffer( int bytes );
+void RB_ExecuteRenderCommands( const void *data );
+
+void R_InitCommandBuffers( void );
+void R_ShutdownCommandBuffers( void );
+
+void R_SyncRenderThread( void );
+
+void R_AddDrawSurfCmd( drawSurf_t *drawSurfs, int numDrawSurfs );
+
+void RE_SetColor( const float *rgba );
+void RE_StretchPic ( float x, float y, float w, float h, 
+					  float s1, float t1, float s2, float t2, qhandle_t hShader );
+void RE_RotatePic ( float x, float y, float w, float h, 
+					  float s1, float t1, float s2, float t2,float a, qhandle_t hShader );
+void RE_RotatePic2 ( float x, float y, float w, float h, 
+					  float s1, float t1, float s2, float t2,float a, qhandle_t hShader );
+void RE_RenderWorldEffects(void);
+void RE_LAGoggles( void );
+void RE_Scissor ( float x, float y, float w, float h);
+void RE_BeginFrame( stereoFrame_t stereoFrame );
+void RE_EndFrame( int *frontEndMsec, int *backEndMsec );
+qboolean	RE_ProcessDissolve(void);
+qboolean	RE_InitDissolve(qboolean bForceCircularExtroWipe);
+
+
+long generateHashValue( const char *fname );
+#ifdef _XBOX
+void R_LoadImage( const char *shortname, byte **pic, int *width, int *height, int *mipcount, GLenum *format );
+#else
+int R_LoadImage( const char *name, byte **pic, int *width, int *height, GLenum *format );
+#endif
+void		RE_InsertModelIntoHash(const char *name, model_t *mod);
+qboolean R_FogParmsMatch( int fog1, int fog2 );
+
+/*
+Ghoul2 Insert Start
+*/
+
+// tr_ghoul2.cpp
+void		Create_Matrix(const float *angle, mdxaBone_t *matrix);
+void		Multiply_3x4Matrix(mdxaBone_t *out,const mdxaBone_t *in2,const mdxaBone_t *in);
+extern qboolean R_LoadMDXM (model_t *mod, void *buffer, const char *name, qboolean &bAlreadyCached );
+extern qboolean R_LoadMDXA (model_t *mod, void *buffer, const char *name, qboolean &bAlreadyCached );
+bool LoadTGAPalletteImage ( const char *name, byte **pic, int *width, int *height);
+/*
+Ghoul2 Insert End
+*/
+
+// tr_surfacesprites
+void RB_DrawSurfaceSprites( shaderStage_t *stage, shaderCommands_t *input);
+
+#ifdef _XBOX
+struct DDS_PIXELFORMAT
+{
+    DWORD dwSize;
+    DWORD dwFlags;
+    DWORD dwFourCC;
+    DWORD dwRGBBitCount;
+    DWORD dwRBitMask;
+    DWORD dwGBitMask;
+    DWORD dwBBitMask;
+    DWORD dwABitMask;
+};
+
+struct DDS_HEADER
+{
+    DWORD dwSize;
+    DWORD dwHeaderFlags;
+    DWORD dwHeight;
+    DWORD dwWidth;
+    DWORD dwPitchOrLinearSize;
+    DWORD dwDepth;
+    DWORD dwMipMapCount;
+    DWORD dwReserved1[11];
+    DDS_PIXELFORMAT ddspf;
+    DWORD dwSurfaceFlags;
+    DWORD dwCubemapFlags;
+    DWORD dwReserved2[3];
+};
+#endif
+
+#endif //TR_LOCAL_H
diff --git a/code/renderer/tr_main.cpp b/code/renderer/tr_main.cpp
new file mode 100644
index 0000000..9f25ad0
--- /dev/null
+++ b/code/renderer/tr_main.cpp
@@ -0,0 +1,1726 @@
+// tr_main.c -- main control flow for each frame
+
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+
+#include "tr_local.h"
+
+#if !defined(G2_H_INC)
+	#include "../ghoul2/G2.h"
+#endif
+
+void R_AddTerrainSurfaces(void);
+
+trGlobals_t		tr;
+
+static float	s_flipMatrix[16] = {
+	// convert from our coordinate system (looking down X)
+	// to OpenGL's coordinate system (looking down -Z)
+#if defined (_XBOX)
+	0, 0, 1, 0,
+	-1, 0, 0, 0,
+	0, 1, 0, 0,
+	0, 0, 0, 1
+#else
+	0, 0, -1, 0,
+	-1, 0, 0, 0,
+	0, 1, 0, 0,
+	0, 0, 0, 1
+#endif
+};
+
+// entities that will have procedurally generated surfaces will just
+// point at this for their sorting surface
+surfaceType_t	entitySurface = SF_ENTITY;
+
+/*
+=================
+R_CullLocalBox
+
+Returns CULL_IN, CULL_CLIP, or CULL_OUT
+=================
+*/
+int R_CullLocalBox (const vec3_t bounds[2]) {
+	int		i, j;
+	vec3_t	transformed[8];
+	float	dists[8];
+	vec3_t	v;
+	cplane_t	*frust;
+	int			anyBack;
+	int			front, back;
+
+	if ( r_nocull->integer==1 ) {
+		return CULL_CLIP;
+	}
+
+	// transform into world space
+	for (i = 0 ; i < 8 ; i++) {
+		v[0] = bounds[i&1][0];
+		v[1] = bounds[(i>>1)&1][1];
+		v[2] = bounds[(i>>2)&1][2];
+
+		VectorCopy( tr.or.origin, transformed[i] );
+		VectorMA( transformed[i], v[0], tr.or.axis[0], transformed[i] );
+		VectorMA( transformed[i], v[1], tr.or.axis[1], transformed[i] );
+		VectorMA( transformed[i], v[2], tr.or.axis[2], transformed[i] );
+	}
+
+	// check against frustum planes
+	anyBack = 0;
+	for (i = 0 ; i < 5 ; i++) {
+		frust = &tr.viewParms.frustum[i];
+
+		front = back = 0;
+		for (j = 0 ; j < 8 ; j++) {
+			dists[j] = DotProduct(transformed[j], frust->normal);
+			if ( dists[j] > frust->dist ) {
+				front = 1;
+				if ( back ) {
+					break;		// a point is in front
+				}
+			} else {
+				back = 1;
+			}
+		}
+		if ( !front ) {
+			// all points were behind one of the planes
+			return CULL_OUT;
+		}
+		anyBack |= back;
+	}
+
+	if ( !anyBack ) {
+		return CULL_IN;		// completely inside frustum
+	}
+
+	return CULL_CLIP;		// partially clipped
+}
+
+/*
+** R_CullLocalPointAndRadius
+*/
+int R_CullLocalPointAndRadius( const vec3_t pt, float radius )
+{
+	vec3_t transformed;
+
+	R_LocalPointToWorld( pt, transformed );
+
+	return R_CullPointAndRadius( transformed, radius );
+}
+
+/*
+** R_CullPointAndRadius
+*/
+int R_CullPointAndRadius( const vec3_t pt, float radius )
+{
+	int		i;
+	float	dist;
+	cplane_t	*frust;
+	qboolean mightBeClipped = qfalse;
+
+	if ( r_nocull->integer==1 ) {
+		return CULL_CLIP;
+	}
+
+	// check against frustum planes
+	for (i = 0 ; i < 5 ; i++) 
+	{
+		frust = &tr.viewParms.frustum[i];
+
+		dist = DotProduct( pt, frust->normal) - frust->dist;
+		if ( dist < -radius )
+		{
+			return CULL_OUT;
+		}
+		else if ( dist <= radius ) 
+		{
+			mightBeClipped = qtrue;
+		}
+	}
+
+	if ( mightBeClipped )
+	{
+		return CULL_CLIP;
+	}
+
+	return CULL_IN;		// completely inside frustum
+}
+
+
+/*
+=================
+R_LocalNormalToWorld
+
+=================
+*/
+void R_LocalNormalToWorld (const vec3_t local, vec3_t world) {
+	world[0] = local[0] * tr.or.axis[0][0] + local[1] * tr.or.axis[1][0] + local[2] * tr.or.axis[2][0];
+	world[1] = local[0] * tr.or.axis[0][1] + local[1] * tr.or.axis[1][1] + local[2] * tr.or.axis[2][1];
+	world[2] = local[0] * tr.or.axis[0][2] + local[1] * tr.or.axis[1][2] + local[2] * tr.or.axis[2][2];
+}
+
+/*
+=================
+R_LocalPointToWorld
+
+=================
+*/
+void R_LocalPointToWorld (const vec3_t local, vec3_t world) {
+	world[0] = local[0] * tr.or.axis[0][0] + local[1] * tr.or.axis[1][0] + local[2] * tr.or.axis[2][0] + tr.or.origin[0];
+	world[1] = local[0] * tr.or.axis[0][1] + local[1] * tr.or.axis[1][1] + local[2] * tr.or.axis[2][1] + tr.or.origin[1];
+	world[2] = local[0] * tr.or.axis[0][2] + local[1] * tr.or.axis[1][2] + local[2] * tr.or.axis[2][2] + tr.or.origin[2];
+}
+
+float preTransEntMatrix[16];
+
+void R_InvertMatrix(float *sourcemat, float *destmat)
+{
+	int i, j, temp=0;
+
+    for (i = 0; i < 3; i++)
+	{
+        for (j = 0; j < 3; j++)
+		{
+            destmat[j*4 + i] = sourcemat[temp++];
+		}
+	}
+    for (i = 0; i < 3; i++)
+	{
+		temp = i*4;
+        destmat[temp+3]=0;		// destmat[destmat[i][3]=0;
+        for (j = 0; j < 3; j++)
+		{
+            destmat[temp+3]-=destmat[temp+j]*sourcemat[j*4+3];		// dest->matrix[i][3]-=dest->matrix[i][j]*src->matrix[j][3];
+		}
+	}
+}
+
+/*
+=================
+R_WorldNormalToEntity 
+
+=================
+*/
+void R_WorldNormalToEntity (const vec3_t worldvec, vec3_t entvec) 
+{
+	entvec[0] = -worldvec[0] * preTransEntMatrix[0] - worldvec[1] * preTransEntMatrix[4] + worldvec[2] * preTransEntMatrix[8];
+	entvec[1] = -worldvec[0] * preTransEntMatrix[1] - worldvec[1] * preTransEntMatrix[5] + worldvec[2] * preTransEntMatrix[9];
+	entvec[2] = -worldvec[0] * preTransEntMatrix[2] - worldvec[1] * preTransEntMatrix[6] + worldvec[2] * preTransEntMatrix[10];
+}
+
+/*
+=================
+R_WorldPointToEntity 
+
+=================
+*/
+/*void R_WorldPointToEntity (vec3_t worldvec, vec3_t entvec)
+{
+	entvec[0] = worldvec[0] * preTransEntMatrix[0] + worldvec[1] * preTransEntMatrix[4] + worldvec[2] * preTransEntMatrix[8]+preTransEntMatrix[12];
+	entvec[1] = worldvec[0] * preTransEntMatrix[1] + worldvec[1] * preTransEntMatrix[5] + worldvec[2] * preTransEntMatrix[9]+preTransEntMatrix[13];
+	entvec[2] = worldvec[0] * preTransEntMatrix[2] + worldvec[1] * preTransEntMatrix[6] + worldvec[2] * preTransEntMatrix[10]+preTransEntMatrix[14];
+}
+*/
+
+/*
+=================
+R_WorldToLocal
+
+=================
+*/
+void R_WorldToLocal (vec3_t world, vec3_t local) {
+	local[0] = DotProduct(world, tr.or.axis[0]);
+	local[1] = DotProduct(world, tr.or.axis[1]);
+	local[2] = DotProduct(world, tr.or.axis[2]);
+}
+
+/*
+==========================
+R_TransformModelToClip
+
+==========================
+*/
+void R_TransformModelToClip( const vec3_t src, const float *modelMatrix, const float *projectionMatrix,
+							vec4_t eye, vec4_t dst ) {
+	int i;
+
+	for ( i = 0 ; i < 4 ; i++ ) {
+		eye[i] = 
+			src[0] * modelMatrix[ i + 0 * 4 ] +
+			src[1] * modelMatrix[ i + 1 * 4 ] +
+			src[2] * modelMatrix[ i + 2 * 4 ] +
+			1 * modelMatrix[ i + 3 * 4 ];
+	}
+
+	for ( i = 0 ; i < 4 ; i++ ) {
+		dst[i] = 
+			eye[0] * projectionMatrix[ i + 0 * 4 ] +
+			eye[1] * projectionMatrix[ i + 1 * 4 ] +
+			eye[2] * projectionMatrix[ i + 2 * 4 ] +
+			eye[3] * projectionMatrix[ i + 3 * 4 ];
+	}
+}
+
+/*
+==========================
+R_TransformClipToWindow
+
+==========================
+*/
+void R_TransformClipToWindow( const vec4_t clip, const viewParms_t *view, vec4_t normalized, vec4_t window ) {
+	normalized[0] = clip[0] / clip[3];
+	normalized[1] = clip[1] / clip[3];
+	normalized[2] = ( clip[2] + clip[3] ) / ( 2 * clip[3] );
+
+	window[0] = 0.5 * ( 1.0 + normalized[0] ) * view->viewportWidth;
+	window[1] = 0.5 * ( 1.0 + normalized[1] ) * view->viewportHeight;
+	window[2] = normalized[2];
+
+	window[0] = (int) ( window[0] + 0.5 );
+	window[1] = (int) ( window[1] + 0.5 );
+}
+
+
+/*
+==========================
+myGlMultMatrix
+
+==========================
+*/
+void myGlMultMatrix( const float *a, const float *b, float *out ) {
+	int		i, j;
+
+	for ( i = 0 ; i < 4 ; i++ ) {
+		for ( j = 0 ; j < 4 ; j++ ) {
+			out[ i * 4 + j ] =
+				a [ i * 4 + 0 ] * b [ 0 * 4 + j ]
+				+ a [ i * 4 + 1 ] * b [ 1 * 4 + j ]
+				+ a [ i * 4 + 2 ] * b [ 2 * 4 + j ]
+				+ a [ i * 4 + 3 ] * b [ 3 * 4 + j ];
+		}
+	}
+}
+
+/*
+=================
+R_RotateForEntity
+
+Generates an orientation for an entity and viewParms
+Does NOT produce any GL calls
+Called by both the front end and the back end
+=================
+*/
+void R_RotateForEntity( const trRefEntity_t *ent, const viewParms_t *viewParms,
+					   orientationr_t *or ) {
+//	float	glMatrix[16];
+	vec3_t	delta;
+	float	axisLength;
+
+	if ( ent->e.reType != RT_MODEL ) {
+		*or = viewParms->world;
+		return;
+	}
+
+	VectorCopy( ent->e.origin, or->origin );
+
+	VectorCopy( ent->e.axis[0], or->axis[0] );
+	VectorCopy( ent->e.axis[1], or->axis[1] );
+	VectorCopy( ent->e.axis[2], or->axis[2] );
+
+	preTransEntMatrix[0] = or->axis[0][0];
+	preTransEntMatrix[4] = or->axis[1][0];
+	preTransEntMatrix[8] = or->axis[2][0];
+	preTransEntMatrix[12] = or->origin[0];
+
+	preTransEntMatrix[1] = or->axis[0][1];
+	preTransEntMatrix[5] = or->axis[1][1];
+	preTransEntMatrix[9] = or->axis[2][1];
+	preTransEntMatrix[13] = or->origin[1];
+
+	preTransEntMatrix[2] = or->axis[0][2];
+	preTransEntMatrix[6] = or->axis[1][2];
+	preTransEntMatrix[10] = or->axis[2][2];
+	preTransEntMatrix[14] = or->origin[2];
+
+	preTransEntMatrix[3] = 0;
+	preTransEntMatrix[7] = 0;
+	preTransEntMatrix[11] = 0;
+	preTransEntMatrix[15] = 1;
+
+	myGlMultMatrix( preTransEntMatrix, viewParms->world.modelMatrix, or->modelMatrix );
+
+	// calculate the viewer origin in the model's space
+	// needed for fog, specular, and environment mapping
+	VectorSubtract( viewParms->or.origin, or->origin, delta );
+
+	// compensate for scale in the axes if necessary
+	if ( ent->e.nonNormalizedAxes ) {
+		axisLength = VectorLength( ent->e.axis[0] );
+		if ( !axisLength ) {
+			axisLength = 0;
+		} else {
+			axisLength = 1.0 / axisLength;
+		}
+	} else {
+		axisLength = 1.0;
+	}
+
+	or->viewOrigin[0] = DotProduct( delta, or->axis[0] ) * axisLength;
+	or->viewOrigin[1] = DotProduct( delta, or->axis[1] ) * axisLength;
+	or->viewOrigin[2] = DotProduct( delta, or->axis[2] ) * axisLength;
+}
+
+/*
+=================
+R_RotateForViewer
+
+Sets up the modelview matrix for a given viewParm
+=================
+*/
+void R_RotateForViewer (void) 
+{
+	float	viewerMatrix[16];
+	vec3_t	origin;
+
+	memset (&tr.or, 0, sizeof(tr.or));
+	tr.or.axis[0][0] = 1;
+	tr.or.axis[1][1] = 1;
+	tr.or.axis[2][2] = 1;
+	VectorCopy (tr.viewParms.or.origin, tr.or.viewOrigin);
+
+	// transform by the camera placement
+	VectorCopy( tr.viewParms.or.origin, origin );
+
+	viewerMatrix[0] = tr.viewParms.or.axis[0][0];
+	viewerMatrix[4] = tr.viewParms.or.axis[0][1];
+	viewerMatrix[8] = tr.viewParms.or.axis[0][2];
+	viewerMatrix[12] = -origin[0] * viewerMatrix[0] + -origin[1] * viewerMatrix[4] + -origin[2] * viewerMatrix[8];
+
+	viewerMatrix[1] = tr.viewParms.or.axis[1][0];
+	viewerMatrix[5] = tr.viewParms.or.axis[1][1];
+	viewerMatrix[9] = tr.viewParms.or.axis[1][2];
+	viewerMatrix[13] = -origin[0] * viewerMatrix[1] + -origin[1] * viewerMatrix[5] + -origin[2] * viewerMatrix[9];
+
+	viewerMatrix[2] = tr.viewParms.or.axis[2][0];
+	viewerMatrix[6] = tr.viewParms.or.axis[2][1];
+	viewerMatrix[10] = tr.viewParms.or.axis[2][2];
+	viewerMatrix[14] = -origin[0] * viewerMatrix[2] + -origin[1] * viewerMatrix[6] + -origin[2] * viewerMatrix[10];
+
+	viewerMatrix[3] = 0;
+	viewerMatrix[7] = 0;
+	viewerMatrix[11] = 0;
+	viewerMatrix[15] = 1;
+
+	// convert from our coordinate system (looking down X)
+	// to OpenGL's coordinate system (looking down -Z)
+	myGlMultMatrix( viewerMatrix, s_flipMatrix, tr.or.modelMatrix );
+
+	tr.viewParms.world = tr.or;
+
+}
+
+/*
+** SetFarClip
+*/
+static void SetFarClip( void )
+{
+	float	farthestCornerDistance = 0;
+	int		i;
+
+	// if not rendering the world (icons, menus, etc)
+	// set a 2k far clip plane
+	if ( tr.refdef.rdflags & RDF_NOWORLDMODEL ) {
+		tr.viewParms.zFar = 2048;
+		return;
+	}
+
+	//
+	// set far clipping planes dynamically
+	//
+	for ( i = 0; i < 8; i++ )
+	{
+		vec3_t v;
+		float distance;
+
+		if ( i & 1 )
+		{
+			v[0] = tr.viewParms.visBounds[0][0];
+		}
+		else
+		{
+			v[0] = tr.viewParms.visBounds[1][0];
+		}
+
+		if ( i & 2 )
+		{
+			v[1] = tr.viewParms.visBounds[0][1];
+		}
+		else
+		{
+			v[1] = tr.viewParms.visBounds[1][1];
+		}
+
+		if ( i & 4 )
+		{
+			v[2] = tr.viewParms.visBounds[0][2];
+		}
+		else
+		{
+			v[2] = tr.viewParms.visBounds[1][2];
+		}
+
+		distance = DistanceSquared(tr.viewParms.or.origin, v);
+
+		if ( distance > farthestCornerDistance )
+		{
+			farthestCornerDistance = distance;
+		}
+	}
+	// Bring in the zFar to the distanceCull distance
+	// The sky renders at zFar so need to move it out a little
+	// ...and make sure there is a minimum zfar to prevent problems
+	tr.viewParms.zFar = Com_Clamp(2048.0f, tr.distanceCull * (1.732), sqrtf( farthestCornerDistance ));
+}
+
+
+/*
+===============
+R_SetupProjection
+===============
+*/
+void R_SetupProjection( void ) {
+	float	xmin, xmax, ymin, ymax;
+	float	width, height, depth;
+	float	zNear, zFar;
+
+	// dynamically compute far clip plane distance
+	SetFarClip();
+
+	//
+	// set up projection matrix
+	//
+	zNear	= r_znear->value;
+	zFar	= tr.viewParms.zFar;
+
+	ymax = zNear * tan( tr.refdef.fov_y * M_PI / 360.0f );
+	ymin = -ymax;
+
+	xmax = zNear * tan( tr.refdef.fov_x * M_PI / 360.0f );
+	xmin = -xmax;
+
+	width = xmax - xmin;
+	height = ymax - ymin;
+	depth = zFar - zNear;
+
+#if defined (_XBOX)
+	tr.viewParms.projectionMatrix[0] = 2 * zNear / width;
+	tr.viewParms.projectionMatrix[4] = 0;
+	tr.viewParms.projectionMatrix[8] = ( xmax + xmin ) / width;	// normally 0
+	tr.viewParms.projectionMatrix[12] = 0;
+
+	tr.viewParms.projectionMatrix[1] = 0;
+	tr.viewParms.projectionMatrix[5] = 2 * zNear / height;
+	tr.viewParms.projectionMatrix[9] = ( ymax + ymin ) / height;	// normally 0
+	tr.viewParms.projectionMatrix[13] = 0;
+
+	tr.viewParms.projectionMatrix[2] = 0;
+	tr.viewParms.projectionMatrix[6] = 0;
+	tr.viewParms.projectionMatrix[10] = ( zFar + zNear ) / depth;
+	tr.viewParms.projectionMatrix[14] = -2 * zFar * zNear / depth;
+
+	tr.viewParms.projectionMatrix[3] = 0;
+	tr.viewParms.projectionMatrix[7] = 0;
+	tr.viewParms.projectionMatrix[11] = 1;
+	tr.viewParms.projectionMatrix[15] = 0;
+#else
+	tr.viewParms.projectionMatrix[0] = 2 * zNear / width;
+	tr.viewParms.projectionMatrix[4] = 0;
+	tr.viewParms.projectionMatrix[8] = ( xmax + xmin ) / width;	// normally 0
+	tr.viewParms.projectionMatrix[12] = 0;
+
+	tr.viewParms.projectionMatrix[1] = 0;
+	tr.viewParms.projectionMatrix[5] = 2 * zNear / height;
+	tr.viewParms.projectionMatrix[9] = ( ymax + ymin ) / height;	// normally 0
+	tr.viewParms.projectionMatrix[13] = 0;
+
+	tr.viewParms.projectionMatrix[2] = 0;
+	tr.viewParms.projectionMatrix[6] = 0;
+	tr.viewParms.projectionMatrix[10] = -( zFar + zNear ) / depth;
+	tr.viewParms.projectionMatrix[14] = -2 * zFar * zNear / depth;
+
+	tr.viewParms.projectionMatrix[3] = 0;
+	tr.viewParms.projectionMatrix[7] = 0;
+	tr.viewParms.projectionMatrix[11] = -1;
+	tr.viewParms.projectionMatrix[15] = 0;
+#endif
+}
+
+/*
+=================
+R_SetupFrustum
+
+Setup that culling frustum planes for the current view
+=================
+*/
+void R_SetupFrustum (void) {
+	int		i;
+	float	xs, xc;
+	float	ang;
+
+	ang = tr.viewParms.fovX / 180 * M_PI * 0.5;
+	xs = sin( ang );
+	xc = cos( ang );
+
+	VectorScale( tr.viewParms.or.axis[0], xs, tr.viewParms.frustum[0].normal );
+	VectorMA( tr.viewParms.frustum[0].normal, xc, tr.viewParms.or.axis[1], tr.viewParms.frustum[0].normal );
+
+	VectorScale( tr.viewParms.or.axis[0], xs, tr.viewParms.frustum[1].normal );
+	VectorMA( tr.viewParms.frustum[1].normal, -xc, tr.viewParms.or.axis[1], tr.viewParms.frustum[1].normal );
+
+	ang = tr.viewParms.fovY / 180 * M_PI * 0.5;
+	xs = sin( ang );
+	xc = cos( ang );
+
+	VectorScale( tr.viewParms.or.axis[0], xs, tr.viewParms.frustum[2].normal );
+	VectorMA( tr.viewParms.frustum[2].normal, xc, tr.viewParms.or.axis[2], tr.viewParms.frustum[2].normal );
+
+	VectorScale( tr.viewParms.or.axis[0], xs, tr.viewParms.frustum[3].normal );
+	VectorMA( tr.viewParms.frustum[3].normal, -xc, tr.viewParms.or.axis[2], tr.viewParms.frustum[3].normal );
+
+
+	// this is the far plane
+	VectorScale( tr.viewParms.or.axis[0],-1.0f, tr.viewParms.frustum[4].normal );
+
+	for (i=0 ; i<5 ; i++) {
+		tr.viewParms.frustum[i].type = PLANE_NON_AXIAL;
+		tr.viewParms.frustum[i].dist = DotProduct (tr.viewParms.or.origin, tr.viewParms.frustum[i].normal);
+		if (i==4)
+		{
+			// far plane does not go through the view point, it goes alot farther..
+			tr.viewParms.frustum[i].dist -= tr.distanceCull*1.02f; // a little slack so we don't cull stuff 
+		}
+		SetPlaneSignbits( &tr.viewParms.frustum[i] );
+	}
+}
+
+
+/*
+=================
+R_MirrorPoint
+=================
+*/
+void R_MirrorPoint (vec3_t in, orientation_t *surface, orientation_t *camera, vec3_t out) {
+	int		i;
+	vec3_t	local;
+	vec3_t	transformed;
+	float	d;
+
+	VectorSubtract( in, surface->origin, local );
+
+	VectorClear( transformed );
+	for ( i = 0 ; i < 3 ; i++ ) {
+		d = DotProduct(local, surface->axis[i]);
+		VectorMA( transformed, d, camera->axis[i], transformed );
+	}
+
+	VectorAdd( transformed, camera->origin, out );
+}
+
+void R_MirrorVector (vec3_t in, orientation_t *surface, orientation_t *camera, vec3_t out) {
+	int		i;
+	float	d;
+
+	VectorClear( out );
+	for ( i = 0 ; i < 3 ; i++ ) {
+		d = DotProduct(in, surface->axis[i]);
+		VectorMA( out, d, camera->axis[i], out );
+	}
+}
+
+
+/*
+=============
+R_PlaneForSurface
+=============
+*/
+void R_PlaneForSurface (surfaceType_t *surfType, cplane_t *plane) {
+	srfTriangles_t	*tri;
+	srfGridMesh_t *grid;
+	srfPoly_t		*poly;
+	drawVert_t		*v1, *v2, *v3;
+	vec4_t			plane4;
+
+	if (!surfType) {
+		memset (plane, 0, sizeof(*plane));
+		plane->normal[0] = 1;
+		return;
+	}
+	switch (*surfType) {
+	case SF_FACE:
+		*plane = ((srfSurfaceFace_t *)surfType)->plane;
+		return;
+	case SF_TRIANGLES:
+		tri = (srfTriangles_t *)surfType;
+		v1 = tri->verts + tri->indexes[0];
+		v2 = tri->verts + tri->indexes[1];
+		v3 = tri->verts + tri->indexes[2];
+		PlaneFromPoints( plane4, v1->xyz, v2->xyz, v3->xyz );
+		VectorCopy( plane4, plane->normal ); 
+		plane->dist = plane4[3];
+		return;
+	case SF_POLY:
+		poly = (srfPoly_t *)surfType;
+		PlaneFromPoints( plane4, poly->verts[0].xyz, poly->verts[1].xyz, poly->verts[2].xyz );
+		VectorCopy( plane4, plane->normal ); 
+		plane->dist = plane4[3];
+		return;
+	case SF_GRID: 
+		grid = (srfGridMesh_t *)surfType;
+		v1 = &grid->verts[0];
+		v2 = &grid->verts[1];
+		v3 = &grid->verts[2];
+		PlaneFromPoints( plane4, v3->xyz, v2->xyz, v1->xyz );
+		VectorCopy( plane4, plane->normal ); 
+		plane->dist = plane4[3];
+		return;
+	default:
+		memset (plane, 0, sizeof(*plane));
+		plane->normal[0] = 1;		
+		return;
+	}
+}
+
+/*
+=================
+R_GetPortalOrientation
+
+entityNum is the entity that the portal surface is a part of, which may
+be moving and rotating.
+
+Returns qtrue if it should be mirrored
+=================
+*/
+qboolean R_GetPortalOrientations( drawSurf_t *drawSurf, int entityNum, 
+							 orientation_t *surface, orientation_t *camera,
+							 vec3_t pvsOrigin, qboolean *mirror ) {
+	int			i;
+	cplane_t	originalPlane, plane;
+	trRefEntity_t	*e;
+	float		d;
+	vec3_t		transformed;
+
+	// create plane axis for the portal we are seeing
+	R_PlaneForSurface( drawSurf->surface, &originalPlane );
+
+	// rotate the plane if necessary
+	if ( entityNum != TR_WORLDENT ) {
+		tr.currentEntityNum = entityNum;
+		tr.currentEntity = &tr.refdef.entities[entityNum];
+
+		// get the orientation of the entity
+		R_RotateForEntity( tr.currentEntity, &tr.viewParms, &tr.or );
+
+		// rotate the plane, but keep the non-rotated version for matching
+		// against the portalSurface entities
+		R_LocalNormalToWorld( originalPlane.normal, plane.normal );
+		plane.dist = originalPlane.dist + DotProduct( plane.normal, tr.or.origin );
+
+		// translate the original plane
+		originalPlane.dist = originalPlane.dist + DotProduct( originalPlane.normal, tr.or.origin );
+	} else {
+		plane = originalPlane;
+	}
+
+	VectorCopy( plane.normal, surface->axis[0] );
+	PerpendicularVector( surface->axis[1], surface->axis[0] );
+	CrossProduct( surface->axis[0], surface->axis[1], surface->axis[2] );
+
+	// locate the portal entity closest to this plane.
+	// origin will be the origin of the portal, origin2 will be
+	// the origin of the camera
+	for ( i = 0 ; i < tr.refdef.num_entities ; i++ ) {
+		e = &tr.refdef.entities[i];
+		if ( e->e.reType != RT_PORTALSURFACE ) {
+			continue;
+		}
+
+		d = DotProduct( e->e.origin, originalPlane.normal ) - originalPlane.dist;
+		if ( d > 64 || d < -64) {
+			continue;
+		}
+
+		// get the pvsOrigin from the entity
+		VectorCopy( e->e.oldorigin, pvsOrigin );
+
+		// if the entity is just a mirror, don't use as a camera point
+		if ( e->e.oldorigin[0] == e->e.origin[0] && 
+			e->e.oldorigin[1] == e->e.origin[1] && 
+			e->e.oldorigin[2] == e->e.origin[2] ) {
+			VectorScale( plane.normal, plane.dist, surface->origin );
+			VectorCopy( surface->origin, camera->origin );
+			VectorSubtract( vec3_origin, surface->axis[0], camera->axis[0] );
+			VectorCopy( surface->axis[1], camera->axis[1] );
+			VectorCopy( surface->axis[2], camera->axis[2] );
+
+			*mirror = qtrue;
+			return qtrue;
+		}
+
+		// project the origin onto the surface plane to get
+		// an origin point we can rotate around
+		d = DotProduct( e->e.origin, plane.normal ) - plane.dist;
+		VectorMA( e->e.origin, -d, surface->axis[0], surface->origin );
+			
+		// now get the camera origin and orientation
+		VectorCopy( e->e.oldorigin, camera->origin );
+		AxisCopy( e->e.axis, camera->axis );
+		VectorSubtract( vec3_origin, camera->axis[0], camera->axis[0] );
+		VectorSubtract( vec3_origin, camera->axis[1], camera->axis[1] );
+
+		// optionally rotate
+		if ( e->e.frame ) {
+			// continuous rotate
+			d = (tr.refdef.time/1000.0f) * e->e.frame;
+			VectorCopy( camera->axis[1], transformed );
+			RotatePointAroundVector( camera->axis[1], camera->axis[0], transformed, d );
+			CrossProduct( camera->axis[0], camera->axis[1], camera->axis[2] );
+		} else if (e->e.skinNum){
+			// bobbing rotate
+			//d = 4 * sin( tr.refdef.time * 0.003 );
+			d = e->e.skinNum;
+			VectorCopy( camera->axis[1], transformed );
+			RotatePointAroundVector( camera->axis[1], camera->axis[0], transformed, d );
+			CrossProduct( camera->axis[0], camera->axis[1], camera->axis[2] );
+		}
+		*mirror = qfalse;
+		return qtrue;
+	}
+
+	// if we didn't locate a portal entity, don't render anything.
+	// We don't want to just treat it as a mirror, because without a
+	// portal entity the server won't have communicated a proper entity set
+	// in the snapshot
+
+	// unfortunately, with local movement prediction it is easily possible
+	// to see a surface before the server has communicated the matching
+	// portal surface entity, so we don't want to print anything here...
+
+	//VID_Printf( PRINT_ALL, "Portal surface without a portal entity\n" );
+
+	return qfalse;
+}
+
+static qboolean IsMirror( const drawSurf_t *drawSurf, int entityNum )
+{
+	int			i;
+	cplane_t	originalPlane, plane;
+	trRefEntity_t	*e;
+	float		d;
+
+	// create plane axis for the portal we are seeing
+	R_PlaneForSurface( drawSurf->surface, &originalPlane );
+
+	// rotate the plane if necessary
+	if ( entityNum != TR_WORLDENT ) 
+	{
+		tr.currentEntityNum = entityNum;
+		tr.currentEntity = &tr.refdef.entities[entityNum];
+
+		// get the orientation of the entity
+		R_RotateForEntity( tr.currentEntity, &tr.viewParms, &tr.or );
+
+		// rotate the plane, but keep the non-rotated version for matching
+		// against the portalSurface entities
+		R_LocalNormalToWorld( originalPlane.normal, plane.normal );
+		plane.dist = originalPlane.dist + DotProduct( plane.normal, tr.or.origin );
+
+		// translate the original plane
+		originalPlane.dist = originalPlane.dist + DotProduct( originalPlane.normal, tr.or.origin );
+	} 
+	else 
+	{
+		plane = originalPlane;
+	}
+
+	// locate the portal entity closest to this plane.
+	// origin will be the origin of the portal, origin2 will be
+	// the origin of the camera
+	for ( i = 0 ; i < tr.refdef.num_entities ; i++ ) 
+	{
+		e = &tr.refdef.entities[i];
+		if ( e->e.reType != RT_PORTALSURFACE ) {
+			continue;
+		}
+
+		d = DotProduct( e->e.origin, originalPlane.normal ) - originalPlane.dist;
+		if ( d > 64 || d < -64) {
+			continue;
+		}
+
+		// if the entity is just a mirror, don't use as a camera point
+		if ( e->e.oldorigin[0] == e->e.origin[0] && 
+			e->e.oldorigin[1] == e->e.origin[1] && 
+			e->e.oldorigin[2] == e->e.origin[2] ) 
+		{
+			return qtrue;
+		}
+
+		return qfalse;
+	}
+	return qfalse;
+}
+
+/*
+** SurfIsOffscreen
+**
+** Determines if a surface is completely offscreen.
+*/
+static qboolean SurfIsOffscreen( const drawSurf_t *drawSurf, vec4_t clipDest[128] ) {
+	float shortest = 1000000000;
+	int entityNum;
+	int numTriangles;
+	shader_t *shader;
+	int		fogNum;
+	int dlighted;
+	vec4_t clip, eye;
+	int i;
+	unsigned int pointOr = 0;
+	unsigned int pointAnd = (unsigned int)~0;
+
+	R_RotateForViewer();
+
+	R_DecomposeSort( drawSurf->sort, &entityNum, &shader, &fogNum, &dlighted );
+	RB_BeginSurface( shader, fogNum );
+	rb_surfaceTable[ *drawSurf->surface ]( drawSurf->surface );
+
+	assert( tess.numVertexes < 128 );
+
+	for ( i = 0; i < tess.numVertexes; i++ )
+	{
+		int j;
+		unsigned int pointFlags = 0;
+
+		R_TransformModelToClip( tess.xyz[i], tr.or.modelMatrix, tr.viewParms.projectionMatrix, eye, clip );
+
+		for ( j = 0; j < 3; j++ )
+		{
+			if ( clip[j] >= clip[3] )
+			{
+				pointFlags |= (1 << (j*2));
+			}
+			else if ( clip[j] <= -clip[3] )
+			{
+				pointFlags |= ( 1 << (j*2+1));
+			}
+		}
+		pointAnd &= pointFlags;
+		pointOr |= pointFlags;
+	}
+
+	// trivially reject
+	if ( pointAnd )
+	{
+		return qtrue;
+	}
+
+	// determine if this surface is backfaced and also determine the distance
+	// to the nearest vertex so we can cull based on portal range.  Culling
+	// based on vertex distance isn't 100% correct (we should be checking for
+	// range to the surface), but it's good enough for the types of portals
+	// we have in the game right now.
+	numTriangles = tess.numIndexes / 3;
+
+	for ( i = 0; i < tess.numIndexes; i += 3 )
+	{
+		vec3_t normal;
+		float dot;
+		float len;
+
+		VectorSubtract( tess.xyz[tess.indexes[i]], tr.viewParms.or.origin, normal );
+
+		len = VectorLengthSquared( normal );			// lose the sqrt
+		if ( len < shortest )
+		{
+			shortest = len;
+		}
+
+		if ( ( dot = DotProduct( normal, tess.normal[tess.indexes[i]] ) ) >= 0 )
+		{
+			numTriangles--;
+		}
+	}
+	if ( !numTriangles )
+	{
+		return qtrue;
+	}
+
+	// mirrors can early out at this point, since we don't do a fade over distance
+	// with them (although we could)
+	if ( IsMirror( drawSurf, entityNum ) )
+	{
+		return qfalse;
+	}
+
+	if ( shortest > (tess.shader->portalRange * tess.shader->portalRange))
+	{
+		return qtrue;
+	}
+
+	return qfalse;
+}
+
+/*
+========================
+R_MirrorViewBySurface
+
+Returns qtrue if another view has been rendered
+========================
+*/
+int	recursivePortalCount;
+qboolean R_MirrorViewBySurface (drawSurf_t *drawSurf, int entityNum) {
+	vec4_t			clipDest[128];
+	viewParms_t		newParms;
+	viewParms_t		oldParms;
+	orientation_t	surface, camera;
+
+	// don't recursively mirror
+	if (tr.viewParms.isPortal) 
+	{
+		VID_Printf( PRINT_DEVELOPER, "WARNING: recursive mirror/portal found\n" );
+		return qfalse;
+	}
+
+	if ( r_noportals->integer || r_fastsky->integer ) {
+		return qfalse;
+	}
+
+	// trivially reject portal/mirror
+	if ( SurfIsOffscreen( drawSurf, clipDest ) ) {
+		return qfalse;
+	}
+
+	// save old viewParms so we can return to it after the mirror view
+	oldParms = tr.viewParms;
+
+	newParms = tr.viewParms;
+	newParms.isPortal = qtrue;
+	if ( !R_GetPortalOrientations( drawSurf, entityNum, &surface, &camera, 
+		newParms.pvsOrigin, &newParms.isMirror ) ) {
+		return qfalse;		// bad portal, no portalentity
+	}
+
+	R_MirrorPoint (oldParms.or.origin, &surface, &camera, newParms.or.origin );
+
+	VectorSubtract( vec3_origin, camera.axis[0], newParms.portalPlane.normal );
+	newParms.portalPlane.dist = DotProduct( camera.origin, newParms.portalPlane.normal );
+	
+	R_MirrorVector (oldParms.or.axis[0], &surface, &camera, newParms.or.axis[0]);
+	R_MirrorVector (oldParms.or.axis[1], &surface, &camera, newParms.or.axis[1]);
+	R_MirrorVector (oldParms.or.axis[2], &surface, &camera, newParms.or.axis[2]);
+
+	// OPTIMIZE: restrict the viewport on the mirrored view
+
+	// render the mirror view
+	R_RenderView (&newParms);
+
+	tr.viewParms = oldParms;
+	
+	return qtrue;
+}
+
+/*
+=================
+R_SpriteFogNum
+
+See if a sprite is inside a fog volume
+=================
+*/
+int R_SpriteFogNum( trRefEntity_t *ent ) {
+	int				i;
+	fog_t			*fog;
+
+	if ( tr.refdef.rdflags & RDF_NOWORLDMODEL ) {
+		return 0;
+	}
+
+	if ( tr.refdef.rdflags & RDF_doLAGoggles )
+	{
+		return tr.world->numfogs;
+	}
+
+	int partialFog = 0;
+	for ( i = 1 ; i < tr.world->numfogs ; i++ ) {
+		fog = &tr.world->fogs[i];
+		if ( ent->e.origin[0] - ent->e.radius >= fog->bounds[0][0] 
+			&& ent->e.origin[0] + ent->e.radius <= fog->bounds[1][0] 
+			&& ent->e.origin[1] - ent->e.radius >= fog->bounds[0][1]
+			&& ent->e.origin[1] + ent->e.radius <= fog->bounds[1][1] 
+			&& ent->e.origin[2] - ent->e.radius >= fog->bounds[0][2]
+			&& ent->e.origin[2] + ent->e.radius <= fog->bounds[1][2] ) 
+		{//totally inside it
+			return i;
+			break;
+		}
+		if ( ( ent->e.origin[0] - ent->e.radius >= fog->bounds[0][0] && ent->e.origin[1] - ent->e.radius >= fog->bounds[0][1] && ent->e.origin[2] - ent->e.radius >= fog->bounds[0][2] &&
+			ent->e.origin[0] - ent->e.radius <= fog->bounds[1][0] && ent->e.origin[1] - ent->e.radius <= fog->bounds[1][1] && ent->e.origin[2] - ent->e.radius <= fog->bounds[1][2] ) ||
+			( ent->e.origin[0] + ent->e.radius >= fog->bounds[0][0] && ent->e.origin[1] + ent->e.radius >= fog->bounds[0][1] && ent->e.origin[2] + ent->e.radius >= fog->bounds[0][2] &&
+			ent->e.origin[0] + ent->e.radius <= fog->bounds[1][0] && ent->e.origin[1] + ent->e.radius <= fog->bounds[1][1] && ent->e.origin[2] + ent->e.radius <= fog->bounds[1][2] ) )
+		{//partially inside it
+			if ( tr.refdef.fogIndex == i || R_FogParmsMatch( tr.refdef.fogIndex, i ) )
+			{//take new one only if it's the same one that the viewpoint is in
+				return i;
+				break;
+			}
+			else if ( !partialFog )
+			{//first partialFog
+				partialFog = i;
+			}
+		}
+	}
+
+	return partialFog;
+}
+
+/*
+==========================================================================================
+
+DRAWSURF SORTING
+
+==========================================================================================
+*/
+
+/*
+=================
+qsort replacement
+
+=================
+*/
+#define	SWAP_DRAW_SURF(a,b) temp=((int *)a)[0];((int *)a)[0]=((int *)b)[0];((int *)b)[0]=temp; temp=((int *)a)[1];((int *)a)[1]=((int *)b)[1];((int *)b)[1]=temp;
+
+/* this parameter defines the cutoff between using quick sort and
+   insertion sort for arrays; arrays with lengths shorter or equal to the
+   below value use insertion sort */
+
+#define CUTOFF 8            /* testing shows that this is good value */
+
+static void shortsort( drawSurf_t *lo, drawSurf_t *hi ) {
+    drawSurf_t	*p, *max;
+	int			temp;
+
+    while (hi > lo) {
+        max = lo;
+        for (p = lo + 1; p <= hi; p++ ) {
+            if ( p->sort > max->sort ) {
+                max = p;
+            }
+        }
+        SWAP_DRAW_SURF(max, hi);
+        hi--;
+    }
+}
+
+
+/* sort the array between lo and hi (inclusive)
+FIXME: this was lifted and modified from the microsoft lib source...
+ */
+
+void qsortFast (
+    void *base,
+    unsigned num,
+    unsigned width
+    )
+{
+    char *lo, *hi;              /* ends of sub-array currently sorting */
+    char *mid;                  /* points to middle of subarray */
+    char *loguy, *higuy;        /* traveling pointers for partition step */
+    unsigned size;              /* size of the sub-array */
+    char *lostk[30], *histk[30];
+    int stkptr;                 /* stack for saving sub-array to be processed */
+	int	temp;
+
+	if ( sizeof(drawSurf_t) != 8 ) {
+		Com_Error( ERR_DROP, "change SWAP_DRAW_SURF macro" );
+	}
+
+    /* Note: the number of stack entries required is no more than
+       1 + log2(size), so 30 is sufficient for any array */
+
+    if (num < 2 || width == 0)
+        return;                 /* nothing to do */
+
+    stkptr = 0;                 /* initialize stack */
+
+    lo = (char *) base;
+    hi = (char *) base + width * (num-1);        /* initialize limits */
+
+    /* this entry point is for pseudo-recursion calling: setting
+       lo and hi and jumping to here is like recursion, but stkptr is
+       prserved, locals aren't, so we preserve stuff on the stack */
+recurse:
+
+    size = (hi - lo) / width + 1;        /* number of el's to sort */
+
+    /* below a certain size, it is faster to use a O(n^2) sorting method */
+    if (size <= CUTOFF) {
+         shortsort((drawSurf_t *)lo, (drawSurf_t *)hi);
+    }
+    else {
+        /* First we pick a partititioning element.  The efficiency of the
+           algorithm demands that we find one that is approximately the
+           median of the values, but also that we select one fast.  Using
+           the first one produces bad performace if the array is already
+           sorted, so we use the middle one, which would require a very
+           wierdly arranged array for worst case performance.  Testing shows
+           that a median-of-three algorithm does not, in general, increase
+           performance. */
+
+        mid = lo + (size / 2) * width;      /* find middle element */
+        SWAP_DRAW_SURF(mid, lo);               /* swap it to beginning of array */
+
+        /* We now wish to partition the array into three pieces, one
+           consisiting of elements <= partition element, one of elements
+           equal to the parition element, and one of element >= to it.  This
+           is done below; comments indicate conditions established at every
+           step. */
+
+        loguy = lo;
+        higuy = hi + width;
+
+        /* Note that higuy decreases and loguy increases on every iteration,
+           so loop must terminate. */
+        for (;;) {
+            /* lo <= loguy < hi, lo < higuy <= hi + 1,
+               A[i] <= A[lo] for lo <= i <= loguy,
+               A[i] >= A[lo] for higuy <= i <= hi */
+
+            do  {
+                loguy += width;
+            } while (loguy <= hi &&  
+				( ((drawSurf_t *)loguy)->sort <= ((drawSurf_t *)lo)->sort ) );
+
+            /* lo < loguy <= hi+1, A[i] <= A[lo] for lo <= i < loguy,
+               either loguy > hi or A[loguy] > A[lo] */
+
+            do  {
+                higuy -= width;
+            } while (higuy > lo && 
+				( ((drawSurf_t *)higuy)->sort >= ((drawSurf_t *)lo)->sort ) );
+
+            /* lo-1 <= higuy <= hi, A[i] >= A[lo] for higuy < i <= hi,
+               either higuy <= lo or A[higuy] < A[lo] */
+
+            if (higuy < loguy)
+                break;
+
+            /* if loguy > hi or higuy <= lo, then we would have exited, so
+               A[loguy] > A[lo], A[higuy] < A[lo],
+               loguy < hi, highy > lo */
+
+            SWAP_DRAW_SURF(loguy, higuy);
+
+            /* A[loguy] < A[lo], A[higuy] > A[lo]; so condition at top
+               of loop is re-established */
+        }
+
+        /*     A[i] >= A[lo] for higuy < i <= hi,
+               A[i] <= A[lo] for lo <= i < loguy,
+               higuy < loguy, lo <= higuy <= hi
+           implying:
+               A[i] >= A[lo] for loguy <= i <= hi,
+               A[i] <= A[lo] for lo <= i <= higuy,
+               A[i] = A[lo] for higuy < i < loguy */
+
+        SWAP_DRAW_SURF(lo, higuy);     /* put partition element in place */
+
+        /* OK, now we have the following:
+              A[i] >= A[higuy] for loguy <= i <= hi,
+              A[i] <= A[higuy] for lo <= i < higuy
+              A[i] = A[lo] for higuy <= i < loguy    */
+
+        /* We've finished the partition, now we want to sort the subarrays
+           [lo, higuy-1] and [loguy, hi].
+           We do the smaller one first to minimize stack usage.
+           We only sort arrays of length 2 or more.*/
+
+        if ( higuy - 1 - lo >= hi - loguy ) {
+            if (lo + width < higuy) {
+                lostk[stkptr] = lo;
+                histk[stkptr] = higuy - width;
+                ++stkptr;
+            }                           /* save big recursion for later */
+
+            if (loguy < hi) {
+                lo = loguy;
+                goto recurse;           /* do small recursion */
+            }
+        }
+        else {
+            if (loguy < hi) {
+                lostk[stkptr] = loguy;
+                histk[stkptr] = hi;
+                ++stkptr;               /* save big recursion for later */
+            }
+
+            if (lo + width < higuy) {
+                hi = higuy - width;
+                goto recurse;           /* do small recursion */
+            }
+        }
+    }
+
+    /* We have sorted the array, except for any pending sorts on the stack.
+       Check if there are any, and do them. */
+
+    --stkptr;
+    if (stkptr >= 0) {
+        lo = lostk[stkptr];
+        hi = histk[stkptr];
+        goto recurse;           /* pop subarray from stack */
+    }
+    else
+        return;                 /* all subarrays done */
+}
+
+
+//==========================================================================================
+
+/*
+=================
+R_AddDrawSurf
+=================
+*/
+void R_AddDrawSurf( const surfaceType_t *surface, const shader_t *shader, int fogIndex, int dlightMap ) 
+{
+	int			index;
+
+	// instead of checking for overflow, we just mask the index
+	// so it wraps around
+	index = tr.refdef.numDrawSurfs & DRAWSURF_MASK;
+
+	if ( tr.refdef.rdflags & RDF_doLAGoggles )
+	{
+		fogIndex = tr.world->numfogs;
+	}
+
+	if ( (shader->surfaceFlags & SURF_FORCESIGHT) && !(tr.refdef.rdflags & RDF_ForceSightOn) )
+	{	//if shader is only seen with ForceSight and we don't have ForceSight on, then don't draw
+		return;
+	}
+
+	// the sort data is packed into a single 32 bit value so it can be
+	// compared quickly during the qsorting process
+	tr.refdef.drawSurfs[index].sort = (shader->sortedIndex << QSORT_SHADERNUM_SHIFT) 
+		| tr.shiftedEntityNum | ( fogIndex << QSORT_FOGNUM_SHIFT ) | (int)dlightMap;
+	tr.refdef.drawSurfs[index].surface = (surfaceType_t *)surface;
+	tr.refdef.numDrawSurfs++;
+}
+
+/*
+=================
+R_DecomposeSort
+=================
+*/
+void R_DecomposeSort( unsigned sort, int *entityNum, shader_t **shader, 
+					 int *fogNum, int *dlightMap ) {
+	*fogNum = ( sort >> QSORT_FOGNUM_SHIFT ) & 31;
+	*shader = tr.sortedShaders[ ( sort >> QSORT_SHADERNUM_SHIFT ) & (MAX_SHADERS-1) ];
+	*entityNum = ( sort >> QSORT_ENTITYNUM_SHIFT ) & (MAX_ENTITIES-1);
+	*dlightMap = sort & 3;
+}
+
+/*
+=================
+R_SortDrawSurfs
+=================
+*/
+void R_SortDrawSurfs( drawSurf_t *drawSurfs, int numDrawSurfs ) {
+	shader_t		*shader;
+	int				fogNum;
+	int				entityNum;
+	int				dlighted;
+
+	// it is possible for some views to not have any surfaces
+	if ( numDrawSurfs < 1 ) {
+		// we still need to add it for hyperspace cases
+		R_AddDrawSurfCmd( drawSurfs, numDrawSurfs );
+		return;
+	}
+
+	// if we overflowed MAX_DRAWSURFS, the drawsurfs
+	// wrapped around in the buffer and we will be missing
+	// the first surfaces, not the last ones
+	if ( numDrawSurfs > MAX_DRAWSURFS ) {
+		numDrawSurfs = MAX_DRAWSURFS;
+#if defined(_DEBUG) && defined(_XBOX)
+		Com_Printf(S_COLOR_RED"Draw surface overflow!  Tell Brian.\n");
+#endif
+	}
+
+#ifndef _XBOX
+	// sort the drawsurfs by sort type, then orientation, then shader
+	qsortFast (drawSurfs, numDrawSurfs, sizeof(drawSurf_t) );
+#endif
+
+	// check for any pass through drawing, which
+	// may cause another view to be rendered first
+	for ( int i = 0 ; i < numDrawSurfs ; i++ ) {
+		R_DecomposeSort( (drawSurfs+i)->sort, &entityNum, &shader, &fogNum, &dlighted );
+
+		if ( shader->sort > SS_PORTAL ) {
+			break;
+		}
+
+		// no shader should ever have this sort type
+		if ( shader->sort == SS_BAD ) {
+			Com_Error (ERR_DROP, "Shader '%s'with sort == SS_BAD", shader->name );
+		}
+
+		// if the mirror was completely clipped away, we may need to check another surface
+		if ( R_MirrorViewBySurface( (drawSurfs+i), entityNum) ) {
+			// this is a debug option to see exactly what is being mirrored
+			if ( r_portalOnly->integer ) {
+				return;
+			}
+			break;		// only one mirror view at a time
+		}
+	}
+
+#ifdef _XBOX
+	qsortFast (drawSurfs, numDrawSurfs, sizeof(drawSurf_t) );
+#endif
+
+	R_AddDrawSurfCmd( drawSurfs, numDrawSurfs );
+}
+
+/*
+=============
+R_AddEntitySurfaces
+=============
+*/
+void R_AddEntitySurfaces (void) {
+	trRefEntity_t	*ent;
+	shader_t		*shader;
+
+	if ( !r_drawentities->integer ) {
+		return;
+	}
+
+	for ( tr.currentEntityNum = 0; 
+	      tr.currentEntityNum < tr.refdef.num_entities; 
+		  tr.currentEntityNum++ ) {
+		ent = tr.currentEntity = &tr.refdef.entities[tr.currentEntityNum];
+
+		ent->needDlights = qfalse;
+
+		// preshift the value we are going to OR into the drawsurf sort
+		tr.shiftedEntityNum = tr.currentEntityNum << QSORT_ENTITYNUM_SHIFT;
+
+		if ((ent->e.renderfx & RF_ALPHA_FADE))
+		{
+			// we need to make sure this is not sorted before the world..in fact we 
+			// want this to be sorted quite late...like how about last.
+			// I don't want to use the highest bit, since no doubt someone fumbled
+			// handling that as an unsigned quantity somewhere
+			tr.shiftedEntityNum |= 0x80000000;
+		}
+		//
+		// the weapon model must be handled special --
+		// we don't want the hacked weapon position showing in 
+		// mirrors, because the true body position will already be drawn
+		//
+		if ( (ent->e.renderfx & RF_FIRST_PERSON) && tr.viewParms.isPortal) {
+			continue;
+		}
+
+
+		// simple generated models, like sprites and beams, are not culled
+		switch ( ent->e.reType ) {
+		case RT_PORTALSURFACE:
+			break;		// don't draw anything
+		case RT_SPRITE:
+		case RT_ORIENTED_QUAD:
+		case RT_BEAM:
+		case RT_CYLINDER:
+		case RT_LATHE:
+		case RT_CLOUDS:
+		case RT_LINE:
+		case RT_ELECTRICITY:
+		case RT_SABER_GLOW:
+			// self blood sprites, talk balloons, etc should not be drawn in the primary
+			// view.  We can't just do this check for all entities, because md3
+			// entities may still want to cast shadows from them
+			if ( (ent->e.renderfx & RF_THIRD_PERSON) && !tr.viewParms.isPortal) {
+				continue;
+			}
+			shader = R_GetShaderByHandle( ent->e.customShader );
+			R_AddDrawSurf( &entitySurface, shader, R_SpriteFogNum( ent ), 0 );
+			break;
+
+		case RT_MODEL:
+			// we must set up parts of tr.or for model culling
+			R_RotateForEntity( ent, &tr.viewParms, &tr.or );
+
+			tr.currentModel = R_GetModelByHandle( ent->e.hModel );
+			if (!tr.currentModel) {
+				R_AddDrawSurf( &entitySurface, tr.defaultShader, 0, 0 );
+			} else {
+				switch ( tr.currentModel->type ) {
+				case MOD_MESH:
+					R_AddMD3Surfaces( ent );
+					break;
+				case MOD_BRUSH:
+					R_AddBrushModelSurfaces( ent );
+					break;
+/*
+Ghoul2 Insert Start
+*/
+
+				case MOD_MDXM:
+  					R_AddGhoulSurfaces( ent);
+  					break;
+				case MOD_BAD:		// null model axis
+					if ( (ent->e.renderfx & RF_THIRD_PERSON) && !tr.viewParms.isPortal)
+					{
+						if (!(ent->e.renderfx & RF_SHADOW_ONLY))
+						{
+						break;
+					}
+					}
+
+  					if (ent->e.ghoul2 && G2API_HaveWeGhoul2Models(*((CGhoul2Info_v *)ent->e.ghoul2)))
+  					{
+  						R_AddGhoulSurfaces( ent);
+  						break;
+  					}
+
+					R_AddDrawSurf( &entitySurface, tr.defaultShader, 0, false );
+					break;
+/*
+Ghoul2 Insert End
+*/
+					
+				default:
+					Com_Error( ERR_DROP, "R_AddEntitySurfaces: Bad modeltype" );
+					break;
+				}
+			}
+			break;
+		default:
+			Com_Error( ERR_DROP, "R_AddEntitySurfaces: Bad reType" );
+		}
+	}
+
+}
+
+
+/*
+====================
+R_GenerateDrawSurfs
+====================
+*/
+#ifdef _XBOX
+extern void R_MarkLeaves(mleaf_s*);
+void R_GenerateDrawSurfs( bool isPortal ) {
+	// determine which leaves are in the PVS / areamask
+	if ( !(tr.refdef.rdflags & RDF_NOWORLDMODEL) ) {
+		R_MarkLeaves (NULL);
+	}
+
+	R_AddWorldSurfaces ();
+
+	R_AddPolygonSurfaces();
+
+//	R_AddTerrainSurfaces();
+
+	// set the projection matrix with the minimum zfar
+	// now that we have the world bounded
+	// this needs to be done before entities are
+	// added, because they use the projection
+	// matrix for lod calculation
+	R_SetupProjection ();
+
+	R_AddEntitySurfaces ();
+}
+
+#else 
+
+void R_GenerateDrawSurfs( void ) {
+	R_AddWorldSurfaces ();
+
+	R_AddPolygonSurfaces();
+
+	R_AddTerrainSurfaces();
+
+	// set the projection matrix with the minimum zfar
+	// now that we have the world bounded
+	// this needs to be done before entities are
+	// added, because they use the projection
+	// matrix for lod calculation
+	R_SetupProjection ();
+
+	R_AddEntitySurfaces ();
+}
+#endif
+
+/*
+================
+R_DebugPolygon
+================
+*/
+void R_DebugPolygon( int color, int numPoints, float *points ) {
+	int		i;
+
+	GL_State( GLS_DEPTHMASK_TRUE | GLS_SRCBLEND_ONE | GLS_DSTBLEND_ONE );
+
+	// draw solid shade
+
+	qglColor3f( color&1, (color>>1)&1, (color>>2)&1 );
+	qglBegin( GL_POLYGON );
+	for ( i = 0 ; i < numPoints ; i++ ) {
+		qglVertex3fv( points + i * 3 );
+	}
+	qglEnd();
+
+	// draw wireframe outline
+	GL_State( GLS_POLYMODE_LINE | GLS_DEPTHMASK_TRUE | GLS_SRCBLEND_ONE | GLS_DSTBLEND_ONE );
+	qglDepthRange( 0, 0 );
+	qglColor3f( 1, 1, 1 );
+	qglBegin( GL_POLYGON );
+	for ( i = 0 ; i < numPoints ; i++ ) {
+		qglVertex3fv( points + i * 3 );
+	}
+	qglEnd();
+	qglDepthRange( 0, 1 );
+}
+
+/*
+====================
+R_DebugGraphics
+
+Visualization aid for movement clipping debugging
+====================
+*/
+void R_DebugGraphics( void ) {
+	if ( !r_debugSurface->integer ) {
+		return;
+	}
+
+	// the render thread can't make callbacks to the main thread
+	//R_SyncRenderThread();
+
+	GL_Bind( tr.whiteImage);
+	GL_Cull( CT_FRONT_SIDED );
+	CM_DrawDebugSurface( R_DebugPolygon );
+}
+
+qboolean R_FogParmsMatch( int fog1, int fog2 )
+{
+	for ( int i = 0; i < 2; i++ )
+	{
+		if ( tr.world->fogs[fog1].parms.color[i] != tr.world->fogs[fog2].parms.color[i] )
+		{
+			return qfalse;
+		}
+	}
+	return qtrue;
+}
+
+void R_SetViewFogIndex (void)
+{
+	if ( tr.world->numfogs > 1 )
+	{//more than just the LA goggles
+		fog_t *fog;
+		int contents = SV_PointContents( tr.refdef.vieworg, 0 );
+		if ( (contents&CONTENTS_FOG) )
+		{//only take a tr.refdef.fogIndex if the tr.refdef.vieworg is actually *in* that fog brush (assumption: checks pointcontents for any CONTENTS_FOG, not that particular brush...)
+			for ( tr.refdef.fogIndex = 1 ; tr.refdef.fogIndex < tr.world->numfogs ; tr.refdef.fogIndex++ ) 
+			{
+				fog = &tr.world->fogs[tr.refdef.fogIndex]; 
+				if ( tr.refdef.vieworg[0] >= fog->bounds[0][0]
+					&& tr.refdef.vieworg[1] >= fog->bounds[0][1]
+					&& tr.refdef.vieworg[2] >= fog->bounds[0][2]
+					&& tr.refdef.vieworg[0] <= fog->bounds[1][0]
+					&& tr.refdef.vieworg[1] <= fog->bounds[1][1]
+					&& tr.refdef.vieworg[2] <= fog->bounds[1][2] ) 
+				{
+					break;
+				}
+			}
+			if ( tr.refdef.fogIndex == tr.world->numfogs ) 
+			{
+				tr.refdef.fogIndex = 0;
+			}
+		}
+		else
+		{
+			tr.refdef.fogIndex = 0;
+		}
+	}
+	else
+	{
+		tr.refdef.fogIndex = 0;
+	}
+}
+void RE_SetLightStyle(int style, int colors );
+
+/*
+================
+R_RenderView
+
+A view may be either the actual camera view,
+or a mirror / remote location
+================
+*/
+void R_RenderView (viewParms_t *parms) {
+	int		firstDrawSurf;
+
+	if ( parms->viewportWidth <= 0 || parms->viewportHeight <= 0 ) {
+		return;
+	}
+
+	if (r_debugStyle->integer >= 0)
+	{
+		int			i;
+		color4ub_t	whitecolor = {0xff, 0xff, 0xff, 0xff};
+		color4ub_t	blackcolor = {0x00, 0x00, 0x00, 0xff};
+
+		for(i=0;i<MAX_LIGHT_STYLES;i++)
+		{
+			RE_SetLightStyle(i,  *(int*)blackcolor);
+		}
+		RE_SetLightStyle(r_debugStyle->integer,  *(int*)whitecolor);
+	}
+
+	tr.viewCount++;
+
+	tr.viewParms = *parms;
+	tr.viewParms.frameSceneNum = tr.frameSceneNum;
+	tr.viewParms.frameCount = tr.frameCount;
+
+	firstDrawSurf = tr.refdef.numDrawSurfs;
+
+	tr.viewCount++;
+
+	// set viewParms.world
+	R_RotateForViewer ();
+
+	R_SetupFrustum ();
+
+	if (!(tr.refdef.rdflags & RDF_NOWORLDMODEL)) 
+	{	// Trying to do this with no world is not good.
+		R_SetViewFogIndex ();
+	}
+
+#ifdef _XBOX
+	R_GenerateDrawSurfs(parms->isPortal);
+#else
+	R_GenerateDrawSurfs();
+#endif
+
+	R_SortDrawSurfs( tr.refdef.drawSurfs + firstDrawSurf, tr.refdef.numDrawSurfs - firstDrawSurf );
+
+	// draw main system development information (surface outlines, etc)
+	R_DebugGraphics();
+}
\ No newline at end of file
diff --git a/code/renderer/tr_marks.cpp b/code/renderer/tr_marks.cpp
new file mode 100644
index 0000000..fb484a4
--- /dev/null
+++ b/code/renderer/tr_marks.cpp
@@ -0,0 +1,500 @@
+// tr_marks.c -- polygon projection on the world polygons
+
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+
+
+#include "tr_local.h"
+//#include "assert.h"
+
+#define MAX_VERTS_ON_POLY		64
+
+#define MARKER_OFFSET			0	// 1
+
+/*
+=============
+R_ChopPolyBehindPlane
+
+Out must have space for two more vertexes than in
+=============
+*/
+#define	SIDE_FRONT	0
+#define	SIDE_BACK	1
+#define	SIDE_ON		2
+static void R_ChopPolyBehindPlane( int numInPoints, vec3_t inPoints[MAX_VERTS_ON_POLY],
+								   int *numOutPoints, vec3_t outPoints[MAX_VERTS_ON_POLY], 
+							vec3_t normal, vec_t dist, vec_t epsilon) {
+	float		dists[MAX_VERTS_ON_POLY+4];
+	int			sides[MAX_VERTS_ON_POLY+4];
+	int			counts[3];
+	float		dot;
+	int			i, j;
+	float		*p1, *p2, *clip;
+	float		d;
+
+	// don't clip if it might overflow
+	if ( numInPoints >= MAX_VERTS_ON_POLY - 2 ) {
+		*numOutPoints = 0;
+		return;
+	}
+
+	counts[0] = counts[1] = counts[2] = 0;
+
+	// determine sides for each point
+	for ( i = 0 ; i < numInPoints ; i++ ) {
+		dot = DotProduct( inPoints[i], normal );
+		dot -= dist;
+		dists[i] = dot;
+		if ( dot > epsilon ) {
+			sides[i] = SIDE_FRONT;
+		} else if ( dot < -epsilon ) {
+			sides[i] = SIDE_BACK;
+		} else {
+			sides[i] = SIDE_ON;
+		}
+		counts[sides[i]]++;
+	}
+	sides[i] = sides[0];
+	dists[i] = dists[0];
+
+	*numOutPoints = 0;
+
+	if ( !counts[0] ) {
+		return;
+	}
+	if ( !counts[1] ) {
+		*numOutPoints = numInPoints;
+		memcpy( outPoints, inPoints, numInPoints * sizeof(vec3_t) );
+		return;
+	}
+
+	for ( i = 0 ; i < numInPoints ; i++ ) {
+		p1 = inPoints[i];
+		clip = outPoints[ *numOutPoints ];
+		
+		if ( sides[i] == SIDE_ON ) {
+			VectorCopy( p1, clip );
+			(*numOutPoints)++;
+			continue;
+		}
+	
+		if ( sides[i] == SIDE_FRONT ) {
+			VectorCopy( p1, clip );
+			(*numOutPoints)++;
+			clip = outPoints[ *numOutPoints ];
+		}
+
+		if ( sides[i+1] == SIDE_ON || sides[i+1] == sides[i] ) {
+			continue;
+		}
+			
+		// generate a split point
+		p2 = inPoints[ (i+1) % numInPoints ];
+
+		d = dists[i] - dists[i+1];
+		if ( d == 0 ) {
+			dot = 0;
+		} else {
+			dot = dists[i] / d;
+		}
+
+		// clip xyz
+
+		for (j=0 ; j<3 ; j++) {
+			clip[j] = p1[j] + dot * ( p2[j] - p1[j] );
+		}
+
+		(*numOutPoints)++;
+	}
+}
+
+/*
+=================
+R_BoxSurfaces_r
+
+=================
+*/
+void R_BoxSurfaces_r(mnode_t *node, vec3_t mins, vec3_t maxs, surfaceType_t **list, int listsize, int *listlength, vec3_t dir) {
+
+	int			s, c;
+	msurface_t	*surf, **mark;
+
+	// do the tail recursion in a loop
+	while ( node->contents == -1 ) {
+#ifdef _XBOX
+		s = BoxOnPlaneSide( mins, maxs, tr.world->planes + node->planeNum );
+#else
+		s = BoxOnPlaneSide( mins, maxs, node->plane );
+#endif
+		if (s == 1) {
+			node = node->children[0];
+		} else if (s == 2) {
+			node = node->children[1];
+		} else {
+			R_BoxSurfaces_r(node->children[0], mins, maxs, list, listsize, listlength, dir);
+			node = node->children[1];
+		}
+	}
+
+	// add the individual surfaces
+#ifdef _XBOX
+	mleaf_s *leaf = (mleaf_s*)node;
+	mark = tr.world->marksurfaces + leaf->firstMarkSurfNum;
+	c = leaf->nummarksurfaces;
+#else
+	mark = node->firstmarksurface;
+	c = node->nummarksurfaces;
+#endif
+	while (c--) {
+		//
+		if (*listlength >= listsize) break;
+		//
+		surf = *mark;
+
+		// check if the surface has NOIMPACT or NOMARKS set
+		if ( ( surf->shader->surfaceFlags & ( SURF_NOIMPACT | SURF_NOMARKS ) )
+			|| ( surf->shader->contentFlags & CONTENTS_FOG ) ) {
+			surf->viewCount = tr.viewCount;
+		}
+		// extra check for surfaces to avoid list overflows
+		else if (*(surf->data) == SF_FACE) {
+			// the face plane should go through the box
+			s = BoxOnPlaneSide( mins, maxs, &(( srfSurfaceFace_t * ) surf->data)->plane );
+			if (s == 1 || s == 2) {
+				surf->viewCount = tr.viewCount;
+			} else if (DotProduct((( srfSurfaceFace_t * ) surf->data)->plane.normal, dir) > -0.5) {
+			// don't add faces that make sharp angles with the projection direction
+				surf->viewCount = tr.viewCount;
+			}
+		}
+		else if (*(surfaceType_t *) (surf->data) != SF_GRID
+			&& *(surfaceType_t *) (surf->data) != SF_TRIANGLES )
+		{
+			surf->viewCount = tr.viewCount;
+		}
+		// check the viewCount because the surface may have
+		// already been added if it spans multiple leafs
+		if (surf->viewCount != tr.viewCount) {
+			surf->viewCount = tr.viewCount;
+			list[*listlength] = (surfaceType_t *) surf->data;
+			(*listlength)++;
+		}
+		mark++;
+	}
+}
+
+/*
+=================
+R_AddMarkFragments
+
+=================
+*/
+void R_AddMarkFragments(int numClipPoints, vec3_t clipPoints[2][MAX_VERTS_ON_POLY],
+				   int numPlanes, vec3_t *normals, float *dists,
+				   int maxPoints, vec3_t pointBuffer,
+				   int maxFragments, markFragment_t *fragmentBuffer,
+				   int *returnedPoints, int *returnedFragments,
+				   vec3_t mins, vec3_t maxs) {
+	int pingPong, i;
+	markFragment_t	*mf;
+
+	// chop the surface by all the bounding planes of the to be projected polygon
+	pingPong = 0;
+
+	for ( i = 0 ; i < numPlanes ; i++ ) {
+
+		R_ChopPolyBehindPlane( numClipPoints, clipPoints[pingPong],
+						   &numClipPoints, clipPoints[!pingPong],
+							normals[i], dists[i], 0.5 );
+		pingPong ^= 1;
+		if ( numClipPoints == 0 ) {
+			break;
+		}
+	}
+	// completely clipped away?
+	if ( numClipPoints == 0 ) {
+		return;
+	}
+
+	// add this fragment to the returned list
+	if ( numClipPoints + (*returnedPoints) > maxPoints ) {
+		return;	// not enough space for this polygon
+	}
+	/*
+	// all the clip points should be within the bounding box
+	for ( i = 0 ; i < numClipPoints ; i++ ) {
+		int j;
+		for ( j = 0 ; j < 3 ; j++ ) {
+			if (clipPoints[pingPong][i][j] < mins[j] - 0.5) break;
+			if (clipPoints[pingPong][i][j] > maxs[j] + 0.5) break;
+		}
+		if (j < 3) break;
+	}
+	if (i < numClipPoints) return;
+	*/
+
+	mf = fragmentBuffer + (*returnedFragments);
+	mf->firstPoint = (*returnedPoints);
+	mf->numPoints = numClipPoints;
+	memcpy( pointBuffer + (*returnedPoints) * 3, clipPoints[pingPong], numClipPoints * sizeof(vec3_t) );
+
+	(*returnedPoints) += numClipPoints;
+	(*returnedFragments)++;
+}
+
+/*
+=================
+R_MarkFragments
+
+=================
+*/
+int R_MarkFragments( int numPoints, const vec3_t *points, const vec3_t projection,
+				   int maxPoints, vec3_t pointBuffer, int maxFragments, markFragment_t *fragmentBuffer ) {
+	int				numsurfaces, numPlanes;
+	int				i, j, k, m, n;
+	surfaceType_t	*surfaces[64];
+	vec3_t			mins, maxs;
+	int				returnedFragments;
+	int				returnedPoints;
+	vec3_t			normals[MAX_VERTS_ON_POLY+2];
+	float			dists[MAX_VERTS_ON_POLY+2];
+	vec3_t			clipPoints[2][MAX_VERTS_ON_POLY];
+	vec3_t			normal;
+	vec3_t			projectionDir;
+	vec3_t			v1, v2;
+
+	//increment view count for double check prevention
+	tr.viewCount++;
+
+	//
+	VectorNormalize2( projection, projectionDir );
+	// find all the brushes that are to be considered
+	ClearBounds( mins, maxs );
+	for ( i = 0 ; i < numPoints ; i++ ) {
+		vec3_t	temp;
+
+		AddPointToBounds( points[i], mins, maxs );
+		VectorAdd( points[i], projection, temp );
+		AddPointToBounds( temp, mins, maxs );
+		// make sure we get all the leafs (also the one(s) in front of the hit surface)
+		VectorMA( points[i], -20, projectionDir, temp );
+		AddPointToBounds( temp, mins, maxs );
+	}
+
+	if (numPoints > MAX_VERTS_ON_POLY) numPoints = MAX_VERTS_ON_POLY;
+	// create the bounding planes for the to be projected polygon
+	for ( i = 0 ; i < numPoints ; i++ ) {
+		VectorSubtract(points[(i+1)%numPoints], points[i], v1);
+		VectorAdd(points[i], projection, v2);
+		VectorSubtract(points[i], v2, v2);
+		CrossProduct(v1, v2, normals[i]);
+		VectorNormalizeFast(normals[i]);
+		dists[i] = DotProduct(normals[i], points[i]);
+	}
+	// add near and far clipping planes for projection
+	VectorCopy(projectionDir, normals[numPoints]);
+	dists[numPoints] = DotProduct(normals[numPoints], points[0]) - 32;
+	VectorCopy(projectionDir, normals[numPoints+1]);
+	VectorInverse(normals[numPoints+1]);
+	dists[numPoints+1] = DotProduct(normals[numPoints+1], points[0]) - 20;
+	numPlanes = numPoints + 2;
+
+	numsurfaces = 0;
+	R_BoxSurfaces_r(tr.world->nodes, mins, maxs, surfaces, 64, &numsurfaces, projectionDir);
+	//assert(numsurfaces <= 64);
+	//assert(numsurfaces != 64);
+
+	returnedPoints = 0;
+	returnedFragments = 0;
+
+	for ( i = 0 ; i < numsurfaces ; i++ ) {
+
+		if (*surfaces[i] == SF_GRID) {
+			const srfGridMesh_t	* const cv = (srfGridMesh_t *) surfaces[i];
+			for ( m = 0 ; m < cv->height - 1 ; m++ ) {
+				for ( n = 0 ; n < cv->width - 1 ; n++ ) {
+					// We triangulate the grid and chop all triangles within
+					// the bounding planes of the to be projected polygon.
+					// LOD is not taken into account, not such a big deal though.
+					//
+					// It's probably much nicer to chop the grid itself and deal
+					// with this grid as a normal SF_GRID surface so LOD will
+					// be applied. However the LOD of that chopped grid must
+					// be synced with the LOD of the original curve.
+					// One way to do this; the chopped grid shares vertices with
+					// the original curve. When LOD is applied to the original
+					// curve the unused vertices are flagged. Now the chopped curve
+					// should skip the flagged vertices. This still leaves the
+					// problems with the vertices at the chopped grid edges.
+					//
+					// To avoid issues when LOD applied to "hollow curves" (like
+					// the ones around many jump pads) we now just add a 2 unit
+					// offset to the triangle vertices.
+					// The offset is added in the vertex normal vector direction
+					// so all triangles will still fit together.
+					// The 2 unit offset should avoid pretty much all LOD problems.
+
+					const int numClipPoints = 3;
+
+					const drawVert_t * const dv = cv->verts + m * cv->width + n;
+
+					VectorCopy(dv[0].xyz, clipPoints[0][0]);
+					VectorMA(clipPoints[0][0], MARKER_OFFSET, dv[0].normal, clipPoints[0][0]);
+					VectorCopy(dv[cv->width].xyz, clipPoints[0][1]);
+					VectorMA(clipPoints[0][1], MARKER_OFFSET, dv[cv->width].normal, clipPoints[0][1]);
+					VectorCopy(dv[1].xyz, clipPoints[0][2]);
+					VectorMA(clipPoints[0][2], MARKER_OFFSET, dv[1].normal, clipPoints[0][2]);
+					// check the normal of this triangle
+					VectorSubtract(clipPoints[0][0], clipPoints[0][1], v1);
+					VectorSubtract(clipPoints[0][2], clipPoints[0][1], v2);
+					CrossProduct(v1, v2, normal);
+					VectorNormalizeFast(normal);
+					if (DotProduct(normal, projectionDir) < -0.1) {
+						// add the fragments of this triangle
+						R_AddMarkFragments(numClipPoints, clipPoints,
+										   numPlanes, normals, dists,
+										   maxPoints, pointBuffer,
+										   maxFragments, fragmentBuffer,
+										   &returnedPoints, &returnedFragments, mins, maxs);
+
+						if ( returnedFragments == maxFragments ) {
+							return returnedFragments;	// not enough space for more fragments
+						}
+					}
+
+					VectorCopy(dv[1].xyz, clipPoints[0][0]);
+					VectorMA(clipPoints[0][0], MARKER_OFFSET, dv[1].normal, clipPoints[0][0]);
+					VectorCopy(dv[cv->width].xyz, clipPoints[0][1]);
+					VectorMA(clipPoints[0][1], MARKER_OFFSET, dv[cv->width].normal, clipPoints[0][1]);
+					VectorCopy(dv[cv->width+1].xyz, clipPoints[0][2]);
+					VectorMA(clipPoints[0][2], MARKER_OFFSET, dv[cv->width+1].normal, clipPoints[0][2]);
+					// check the normal of this triangle
+					VectorSubtract(clipPoints[0][0], clipPoints[0][1], v1);
+					VectorSubtract(clipPoints[0][2], clipPoints[0][1], v2);
+					CrossProduct(v1, v2, normal);
+					VectorNormalizeFast(normal);
+					if (DotProduct(normal, projectionDir) < -0.05) {
+						// add the fragments of this triangle
+						R_AddMarkFragments(numClipPoints, clipPoints,
+										   numPlanes, normals, dists,
+										   maxPoints, pointBuffer,
+										   maxFragments, fragmentBuffer,
+										   &returnedPoints, &returnedFragments, mins, maxs);
+
+						if ( returnedFragments == maxFragments ) {
+							return returnedFragments;	// not enough space for more fragments
+						}
+					}
+				}
+			}
+		}
+		else if (*surfaces[i] == SF_FACE) {
+			const srfSurfaceFace_t * const surf = ( srfSurfaceFace_t * ) surfaces[i];
+			// check the normal of this face
+			if (DotProduct(surf->plane.normal, projectionDir) > -0.5) {
+				continue;
+			}
+
+			/*
+			VectorSubtract(clipPoints[0][0], clipPoints[0][1], v1);
+			VectorSubtract(clipPoints[0][2], clipPoints[0][1], v2);
+			CrossProduct(v1, v2, normal);
+			VectorNormalize(normal);
+			if (DotProduct(normal, projectionDir) > -0.5) continue;
+			*/
+#ifdef _XBOX
+			const unsigned char * const indexes = (unsigned char *)( (byte *)surf + surf->ofsIndices );
+			int nextSurfPoint = NEXT_SURFPOINT(surf->flags);
+#else
+			const int * const indexes = (int *)( (byte *)surf + surf->ofsIndices );
+#endif
+			for ( k = 0 ; k < surf->numIndices ; k += 3 ) {
+				for ( j = 0 ; j < 3 ; j++ ) {
+#ifdef _XBOX
+					const unsigned short* v = surf->srfPoints + nextSurfPoint * indexes[k+j];
+					float fVec[3];
+					Q_CastShort2Float(&fVec[0], (short*)v + 0);
+					Q_CastShort2Float(&fVec[1], (short*)v + 1);
+					Q_CastShort2Float(&fVec[2], (short*)v + 2);
+					VectorMA( fVec, MARKER_OFFSET, surf->plane.normal, clipPoints[0][j] );
+#else
+					const float	* const v = surf->points[0] + VERTEXSIZE * indexes[k+j];
+					VectorMA( v, MARKER_OFFSET, surf->plane.normal, clipPoints[0][j] );
+#endif
+				}
+				// add the fragments of this face
+				R_AddMarkFragments( 3 , clipPoints,
+								   numPlanes, normals, dists,
+								   maxPoints, pointBuffer,
+								   maxFragments, fragmentBuffer,
+								   &returnedPoints, &returnedFragments, mins, maxs);
+				if ( returnedFragments == maxFragments ) {
+					return returnedFragments;	// not enough space for more fragments
+				}
+			}
+			continue;
+		}
+		else if (*surfaces[i] == SF_TRIANGLES) 
+		{
+			const srfTriangles_t * const surf = ( srfTriangles_t * ) surfaces[i];
+
+			for ( k = 0 ; k < surf->numIndexes ; k += 3 ) 
+			{
+				int i1=surf->indexes[k];
+				int i2=surf->indexes[k+1];
+				int i3=surf->indexes[k+2];
+				VectorSubtract(surf->verts[i1].xyz,surf->verts[i2].xyz, v1);
+				VectorSubtract(surf->verts[i3].xyz,surf->verts[i2].xyz, v2);
+				CrossProduct(v1, v2, normal);
+				VectorNormalizeFast(normal);
+				// check the normal of this triangle
+				if (DotProduct(normal, projectionDir) < -0.1) 
+				{
+#ifdef _XBOX
+					// This is really ugly, and really inefficient. Of course, the inefficiency
+					// pales in comparison to the misery that ensues once you realze that
+					// MARKER_OFFSET is #define'd to be 0.
+					float fVec[3];
+					Q_CastShort2Float(&fVec[0], &surf->verts[i1].xyz[0]);
+					Q_CastShort2Float(&fVec[1], &surf->verts[i1].xyz[1]);
+					Q_CastShort2Float(&fVec[2], &surf->verts[i1].xyz[2]);
+					VectorMA(fVec, MARKER_OFFSET, normal, clipPoints[0][0]);
+					Q_CastShort2Float(&fVec[0], &surf->verts[i2].xyz[0]);
+					Q_CastShort2Float(&fVec[1], &surf->verts[i2].xyz[1]);
+					Q_CastShort2Float(&fVec[2], &surf->verts[i2].xyz[2]);
+					VectorMA(fVec, MARKER_OFFSET, normal, clipPoints[0][1]);
+					Q_CastShort2Float(&fVec[0], &surf->verts[i3].xyz[0]);
+					Q_CastShort2Float(&fVec[1], &surf->verts[i3].xyz[1]);
+					Q_CastShort2Float(&fVec[2], &surf->verts[i3].xyz[2]);
+					VectorMA(fVec, MARKER_OFFSET, normal, clipPoints[0][2]);
+#else
+					VectorMA(surf->verts[i1].xyz, MARKER_OFFSET, normal, clipPoints[0][0]);
+					VectorMA(surf->verts[i2].xyz, MARKER_OFFSET, normal, clipPoints[0][1]);
+					VectorMA(surf->verts[i3].xyz, MARKER_OFFSET, normal, clipPoints[0][2]);
+#endif
+					// add the fragments of this triangle
+					R_AddMarkFragments( 3 , clipPoints,
+						numPlanes, normals, dists,
+						maxPoints, pointBuffer,
+						maxFragments, fragmentBuffer,
+						&returnedPoints, &returnedFragments, mins, maxs);
+					if ( returnedFragments == maxFragments ) 
+					{
+						return returnedFragments;	// not enough space for more fragments
+					}
+				}
+			}
+		}
+		else {
+			// ignore all other world surfaces
+			// might be cool to also project polygons on a triangle soup
+			// however this will probably create huge amounts of extra polys
+			// even more than the projection onto curves
+			continue;
+		}
+	}
+	return returnedFragments;
+}
+
diff --git a/code/renderer/tr_mesh.cpp b/code/renderer/tr_mesh.cpp
new file mode 100644
index 0000000..931315d
--- /dev/null
+++ b/code/renderer/tr_mesh.cpp
@@ -0,0 +1,437 @@
+// tr_mesh.c: triangle model functions
+
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+
+
+
+#include "tr_local.h"
+#include "MatComp.h"
+
+#ifdef VV_LIGHTING
+#include "tr_lightmanager.h"
+#endif
+
+float ProjectRadius( float r, vec3_t location )
+{
+	float pr;
+	float dist;
+	float c;
+	vec3_t	p;
+	float width;
+	float depth;
+
+	c = DotProduct( tr.viewParms.or.axis[0], tr.viewParms.or.origin );
+	dist = DotProduct( tr.viewParms.or.axis[0], location ) - c;
+
+	if ( dist <= 0 )
+		return 0;
+
+	p[0] = 0;
+	p[1] = Q_fabs( r );
+	p[2] = -dist;
+
+	width = p[0] * tr.viewParms.projectionMatrix[1] + 
+		           p[1] * tr.viewParms.projectionMatrix[5] +
+				   p[2] * tr.viewParms.projectionMatrix[9] +
+				   tr.viewParms.projectionMatrix[13];
+
+	depth = p[0] * tr.viewParms.projectionMatrix[3] + 
+		           p[1] * tr.viewParms.projectionMatrix[7] +
+				   p[2] * tr.viewParms.projectionMatrix[11] +
+				   tr.viewParms.projectionMatrix[15];
+
+	pr = width / depth;
+#if defined (_XBOX)
+	pr = -pr;
+#endif
+
+	if ( pr > 1.0f )
+		pr = 1.0f;
+
+	return pr;
+}
+
+/*
+=============
+R_CullModel
+=============
+*/
+static int R_CullModel( md3Header_t *header, trRefEntity_t *ent ) {
+	vec3_t		bounds[2];
+	md3Frame_t	*oldFrame, *newFrame;
+	int			i;
+
+	// compute frame pointers
+	newFrame = ( md3Frame_t * ) ( ( byte * ) header + header->ofsFrames ) + ent->e.frame;
+	oldFrame = ( md3Frame_t * ) ( ( byte * ) header + header->ofsFrames ) + ent->e.oldframe;
+
+	// cull bounding sphere ONLY if this is not an upscaled entity
+	if ( !ent->e.nonNormalizedAxes )
+	{
+		if ( ent->e.frame == ent->e.oldframe )
+		{
+			switch ( R_CullLocalPointAndRadius( newFrame->localOrigin, newFrame->radius ) )
+			{
+			case CULL_OUT:
+				tr.pc.c_sphere_cull_md3_out++;
+				return CULL_OUT;
+
+			case CULL_IN:
+				tr.pc.c_sphere_cull_md3_in++;
+				return CULL_IN;
+
+			case CULL_CLIP:
+				tr.pc.c_sphere_cull_md3_clip++;
+				break;
+			}
+		}
+		else
+		{
+			int sphereCull, sphereCullB;
+
+			sphereCull  = R_CullLocalPointAndRadius( newFrame->localOrigin, newFrame->radius );
+			if ( newFrame == oldFrame ) {
+				sphereCullB = sphereCull;
+			} else {
+				sphereCullB = R_CullLocalPointAndRadius( oldFrame->localOrigin, oldFrame->radius );
+			}
+
+			if ( sphereCull == sphereCullB )
+			{
+				if ( sphereCull == CULL_OUT )
+				{
+					tr.pc.c_sphere_cull_md3_out++;
+					return CULL_OUT;
+				}
+				else if ( sphereCull == CULL_IN )
+				{
+					tr.pc.c_sphere_cull_md3_in++;
+					return CULL_IN;
+				}
+				else
+				{
+					tr.pc.c_sphere_cull_md3_clip++;
+				}
+			}
+		}
+	}
+	
+	// calculate a bounding box in the current coordinate system
+	for (i = 0 ; i < 3 ; i++) {
+		bounds[0][i] = oldFrame->bounds[0][i] < newFrame->bounds[0][i] ? oldFrame->bounds[0][i] : newFrame->bounds[0][i];
+		bounds[1][i] = oldFrame->bounds[1][i] > newFrame->bounds[1][i] ? oldFrame->bounds[1][i] : newFrame->bounds[1][i];
+	}
+
+	switch ( R_CullLocalBox( bounds ) )
+	{
+	case CULL_IN:
+		tr.pc.c_box_cull_md3_in++;
+		return CULL_IN;
+	case CULL_CLIP:
+		tr.pc.c_box_cull_md3_clip++;
+		return CULL_CLIP;
+	case CULL_OUT:
+	default:
+		tr.pc.c_box_cull_md3_out++;
+		return CULL_OUT;
+	}
+}
+
+/*
+=================
+RE_GetModelBounds
+
+  Returns the bounds of the current model
+  (qhandle_t)hModel and (int)frame need to be set
+=================
+*/
+
+void RE_GetModelBounds(refEntity_t *refEnt, vec3_t bounds1, vec3_t bounds2)
+{
+	md3Frame_t		*frame;
+	md3Header_t		*header;
+	model_t			*model;
+
+	assert(refEnt);
+
+	model = R_GetModelByHandle( refEnt->hModel );
+	assert(model);
+	header = model->md3[0];
+	assert(header);
+	frame = ( md3Frame_t * ) ( ( byte * ) header + header->ofsFrames ) + refEnt->frame;
+	assert(frame);
+
+	VectorCopy(frame->bounds[0], bounds1);
+	VectorCopy(frame->bounds[1], bounds2);
+}
+
+/*
+=================
+R_ComputeLOD
+
+=================
+*/
+static int R_ComputeLOD( trRefEntity_t *ent ) {
+	float radius;
+	float flod;
+	float projectedRadius;
+	int		lod;
+
+	if ( tr.currentModel->numLods < 2 )
+	{	// model has only 1 LOD level, skip computations and bias
+		return(0);
+	}
+
+	// multiple LODs exist, so compute projected bounding sphere
+	// and use that as a criteria for selecting LOD
+//	if ( tr.currentModel->md3[0] ) 
+	{	//normal md3
+		md3Frame_t *frame;
+		frame = ( md3Frame_t * ) ( ( ( unsigned char * ) tr.currentModel->md3[0] ) + tr.currentModel->md3[0]->ofsFrames );
+		frame += ent->e.frame;
+		radius = RadiusFromBounds( frame->bounds[0], frame->bounds[1] );
+	}
+
+	if ( ( projectedRadius = ProjectRadius( radius, ent->e.origin ) ) != 0 )
+	{
+		flod = 1.0f - projectedRadius * r_lodscale->value;
+		flod *= tr.currentModel->numLods;
+	}
+	else
+	{	// object intersects near view plane, e.g. view weapon
+		flod = 0;
+	}
+
+	lod = myftol( flod );
+
+	if ( lod < 0 ) {
+		lod = 0;
+	} else if ( lod >= tr.currentModel->numLods ) {
+		lod = tr.currentModel->numLods - 1;
+	}
+	
+	lod += r_lodbias->integer;
+	if ( lod >= tr.currentModel->numLods )
+		lod = tr.currentModel->numLods - 1;
+	if ( lod < 0 )
+		lod = 0;
+
+	return lod;
+}
+
+/*
+=================
+R_ComputeFogNum
+
+=================
+*/
+static int R_ComputeFogNum( md3Header_t *header, trRefEntity_t *ent ) {
+	int				i;
+	fog_t			*fog;
+	md3Frame_t		*md3Frame;
+	vec3_t			localOrigin;
+
+	if ( tr.refdef.rdflags & RDF_NOWORLDMODEL ) {
+		return 0;
+	}
+
+	if ( tr.refdef.rdflags & RDF_doLAGoggles )
+	{
+		return tr.world->numfogs;
+	}
+
+
+	// FIXME: non-normalized axis issues
+	md3Frame = ( md3Frame_t * ) ( ( byte * ) header + header->ofsFrames ) + ent->e.frame;
+	VectorAdd( ent->e.origin, md3Frame->localOrigin, localOrigin );
+
+	int partialFog = 0;
+	for ( i = 1 ; i < tr.world->numfogs ; i++ ) {
+		fog = &tr.world->fogs[i];
+		if ( localOrigin[0] - md3Frame->radius >= fog->bounds[0][0] 
+			&& localOrigin[0] + md3Frame->radius <= fog->bounds[1][0] 
+			&& localOrigin[1] - md3Frame->radius >= fog->bounds[0][1]
+			&& localOrigin[1] + md3Frame->radius <= fog->bounds[1][1] 
+			&& localOrigin[2] - md3Frame->radius >= fog->bounds[0][2]
+			&& localOrigin[2] + md3Frame->radius <= fog->bounds[1][2] ) 
+		{//totally inside it
+			return i;
+			break;
+		}
+		if ( ( localOrigin[0] - md3Frame->radius >= fog->bounds[0][0] && localOrigin[1] - md3Frame->radius >= fog->bounds[0][1] && localOrigin[2] - md3Frame->radius >= fog->bounds[0][2] &&
+				localOrigin[0] - md3Frame->radius <= fog->bounds[1][0] && localOrigin[1] - md3Frame->radius <= fog->bounds[1][1] && localOrigin[2] - md3Frame->radius <= fog->bounds[1][2]) ||
+			( localOrigin[0] + md3Frame->radius >= fog->bounds[0][0] && localOrigin[1] + md3Frame->radius >= fog->bounds[0][1] && localOrigin[2] + md3Frame->radius >= fog->bounds[0][2] &&
+				localOrigin[0] + md3Frame->radius <= fog->bounds[1][0] && localOrigin[1] + md3Frame->radius <= fog->bounds[1][1] && localOrigin[2] + md3Frame->radius <= fog->bounds[1][2] ) ) 
+		{//partially inside it
+			if ( tr.refdef.fogIndex == i || R_FogParmsMatch( tr.refdef.fogIndex, i ) )
+			{//take new one only if it's the same one that the viewpoint is in
+				return i;
+				break;
+			}
+			else if ( !partialFog )
+			{//first partialFog
+				partialFog = i;
+			}
+		}
+	}
+	//if all else fails, return the first partialFog
+	return partialFog;
+}
+
+/*
+=================
+R_AddMD3Surfaces
+
+=================
+*/
+void R_AddMD3Surfaces( trRefEntity_t *ent ) {
+	int				i;
+	md3Header_t		*header = 0;
+	md3Surface_t	*surface = 0;
+	md3Shader_t		*md3Shader = 0;
+	shader_t		*shader = 0;
+	shader_t		*main_shader = 0;
+	int				cull;
+	int				lod;
+	int				fogNum;
+	qboolean		personalModel;
+
+	// don't add third_person objects if not in a portal
+	personalModel = (ent->e.renderfx & RF_THIRD_PERSON) && !tr.viewParms.isPortal;
+
+	if ( ent->e.renderfx & RF_CAP_FRAMES) {
+		if (ent->e.frame > tr.currentModel->md3[0]->numFrames-1)
+			ent->e.frame = tr.currentModel->md3[0]->numFrames-1;
+		if (ent->e.oldframe > tr.currentModel->md3[0]->numFrames-1)
+			ent->e.oldframe = tr.currentModel->md3[0]->numFrames-1;
+	}
+	else if ( ent->e.renderfx & RF_WRAP_FRAMES ) {
+		ent->e.frame %= tr.currentModel->md3[0]->numFrames;
+		ent->e.oldframe %= tr.currentModel->md3[0]->numFrames;
+	}
+
+	//
+	// Validate the frames so there is no chance of a crash.
+	// This will write directly into the entity structure, so
+	// when the surfaces are rendered, they don't need to be
+	// range checked again.
+	//
+	if ( (ent->e.frame >= tr.currentModel->md3[0]->numFrames) 
+		|| (ent->e.frame < 0)
+		|| (ent->e.oldframe >= tr.currentModel->md3[0]->numFrames)
+		|| (ent->e.oldframe < 0) ) 
+	{
+			VID_Printf (PRINT_ALL, "R_AddMD3Surfaces: no such frame %d to %d for '%s'\n",
+				ent->e.oldframe, ent->e.frame,
+				tr.currentModel->name );
+			ent->e.frame = 0;
+			ent->e.oldframe = 0;
+	}
+
+	//
+	// compute LOD
+	//
+	lod = R_ComputeLOD( ent );
+
+	header = tr.currentModel->md3[lod];
+
+	//
+	// cull the entire model if merged bounding box of both frames
+	// is outside the view frustum.
+	//
+	cull = R_CullModel ( header, ent );
+	if ( cull == CULL_OUT ) {
+		return;
+	}
+
+	//
+	// set up lighting now that we know we aren't culled
+	//
+#ifdef VV_LIGHTING
+	if ( !personalModel ) {
+		VVLightMan.R_SetupEntityLighting( &tr.refdef, ent );
+#else
+	if ( !personalModel || r_shadows->integer > 1 ) {
+		R_SetupEntityLighting( &tr.refdef, ent );
+#endif
+	}
+
+	//
+	// see if we are in a fog volume
+	//
+	fogNum = R_ComputeFogNum( header, ent );
+
+	//
+	// draw all surfaces
+	//
+	main_shader = R_GetShaderByHandle( ent->e.customShader );
+
+	surface = (md3Surface_t *)( (byte *)header + header->ofsSurfaces );
+	for ( i = 0 ; i < header->numSurfaces ; i++ ) {
+
+		if ( ent->e.customShader ) {// a little more efficient
+			shader = main_shader;
+		} else if ( ent->e.customSkin > 0 && ent->e.customSkin < tr.numSkins ) {
+			skin_t *skin;
+			int		j;
+
+			skin = R_GetSkinByHandle( ent->e.customSkin );
+
+			// match the surface name to something in the skin file
+			shader = tr.defaultShader;
+			for ( j = 0 ; j < skin->numSurfaces ; j++ ) {
+				// the names have both been lowercased
+				if ( !strcmp( skin->surfaces[j]->name, surface->name ) ) {
+					shader = skin->surfaces[j]->shader;
+					break;
+				}
+			}
+		} else if ( surface->numShaders <= 0 ) {
+			shader = tr.defaultShader;
+		} else {
+			md3Shader = (md3Shader_t *) ( (byte *)surface + surface->ofsShaders );
+			md3Shader += ent->e.skinNum % surface->numShaders;
+			shader = tr.shaders[ md3Shader->shaderIndex ];
+		}
+
+
+		// we will add shadows even if the main object isn't visible in the view
+
+		// stencil shadows can't do personal models unless I polyhedron clip
+		if ( !personalModel
+			&& r_shadows->integer == 2 
+#ifndef VV_LIGHTING
+			&& fogNum == 0
+#endif
+			&& (ent->e.renderfx & RF_SHADOW_PLANE )
+			&& !(ent->e.renderfx & ( RF_NOSHADOW | RF_DEPTHHACK ) ) 
+			&& shader->sort == SS_OPAQUE ) {
+			R_AddDrawSurf( (surfaceType_t *)surface, tr.shadowShader, 0, qfalse );
+		}
+
+		// projection shadows work fine with personal models
+		if ( r_shadows->integer == 3
+			&& fogNum == 0
+			&& (ent->e.renderfx & RF_SHADOW_PLANE )
+			&& shader->sort == SS_OPAQUE ) {
+			R_AddDrawSurf( (surfaceType_t *)surface, tr.projectionShadowShader, 0, qfalse );
+		}
+
+		// don't add third_person objects if not viewing through a portal
+		if ( !personalModel ) {
+#ifdef VV_LIGHTING
+			int dlightBits = ( ent->dlightBits != 0 );
+			R_AddDrawSurf( (surfaceType_t *)surface, shader, fogNum, dlightBits );
+#else
+			R_AddDrawSurf( (surfaceType_t *)surface, shader, fogNum, qfalse );
+#endif
+		}
+
+		surface = (md3Surface_t *)( (byte *)surface + surface->ofsEnd );
+	}
+
+}
+
diff --git a/code/renderer/tr_model.cpp b/code/renderer/tr_model.cpp
new file mode 100644
index 0000000..53ce924
--- /dev/null
+++ b/code/renderer/tr_model.cpp
@@ -0,0 +1,1197 @@
+// tr_models.c -- model loading and caching
+
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+#include "tr_local.h"
+#include "MatComp.h"
+#include "../qcommon/sstring.h"
+
+#define	LL(x) x=LittleLong(x)
+
+void RE_LoadWorldMap_Actual( const char *name, world_t &worldData, int index ); //should only be called for sub-bsp instances
+
+static qboolean R_LoadMD3 (model_t *mod, int lod, void *buffer, const char *name, qboolean &bAlreadyCached );
+
+/*
+Ghoul2 Insert Start
+*/
+
+typedef	struct modelHash_s
+{
+	char		name[MAX_QPATH];
+	qhandle_t	handle;
+	struct		modelHash_s	*next;
+
+}modelHash_t;
+
+#define FILE_HASH_SIZE		1024
+static	modelHash_t 		*mhHashTable[FILE_HASH_SIZE];
+
+
+/*
+Ghoul2 Insert End
+*/
+
+
+
+// This stuff looks a bit messy, but it's kept here as black box, and nothing appears in any .H files for other 
+//	modules to worry about. I may make another module for this sometime.
+//
+typedef pair<int,int> StringOffsetAndShaderIndexDest_t;
+typedef vector <StringOffsetAndShaderIndexDest_t> ShaderRegisterData_t;
+struct CachedEndianedModelBinary_s
+{
+	void	*pModelDiskImage;
+	int		iAllocSize;		// may be useful for mem-query, but I don't actually need it
+	ShaderRegisterData_t ShaderRegisterData;
+
+	int		iLastLevelUsedOn;
+
+	CachedEndianedModelBinary_s()
+	{
+		pModelDiskImage = 0;
+		iLastLevelUsedOn    = -1;
+		iAllocSize = 0;
+		ShaderRegisterData.clear();
+	}
+};
+typedef struct CachedEndianedModelBinary_s CachedEndianedModelBinary_t;
+typedef map <sstring_t,CachedEndianedModelBinary_t>	CachedModels_t;
+													CachedModels_t *CachedModels = NULL;	// the important cache item.
+
+void RE_RegisterModels_StoreShaderRequest(const char *psModelFileName, const char *psShaderName, const int *piShaderIndexPoke)
+{
+	char sModelName[MAX_QPATH];
+
+	Q_strncpyz(sModelName,psModelFileName,sizeof(sModelName));
+	Q_strlwr  (sModelName);
+
+	CachedEndianedModelBinary_t &ModelBin = (*CachedModels)[sModelName];
+
+	if (ModelBin.pModelDiskImage == NULL)
+	{	
+		assert(0);	// should never happen, means that we're being called on a model that wasn't loaded
+	}
+	else
+	{
+		const int iNameOffset =		  psShaderName		- (char *)ModelBin.pModelDiskImage;
+		const int iPokeOffset = (char*) piShaderIndexPoke	- (char *)ModelBin.pModelDiskImage;
+
+		ModelBin.ShaderRegisterData.push_back( StringOffsetAndShaderIndexDest_t( iNameOffset,iPokeOffset) );
+	}
+}
+
+
+static const byte FakeGLAFile[] = 
+{
+0x32, 0x4C, 0x47, 0x41, 0x06, 0x00, 0x00, 0x00, 0x2A, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6C, 0x74,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x3F, 0x01, 0x00, 0x00, 0x00,
+0x14, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x18, 0x01, 0x00, 0x00, 0x68, 0x00, 0x00, 0x00,
+0x26, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x4D, 0x6F, 0x64, 0x56, 0x69, 0x65, 0x77, 0x20,
+0x69, 0x6E, 0x74, 0x65, 0x72, 0x6E, 0x61, 0x6C, 0x20, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6C, 0x74,
+0x00, 0xCD, 0xCD, 0xCD, 0xCD, 0xCD, 0xCD, 0xCD, 0xCD, 0xCD, 0xCD, 0xCD, 0xCD, 0xCD, 0xCD, 0xCD,
+0xCD, 0xCD, 0xCD, 0xCD, 0xCD, 0xCD, 0xCD, 0xCD, 0xCD, 0xCD, 0xCD, 0xCD, 0xCD, 0xCD, 0xCD, 0xCD,
+0xCD, 0xCD, 0xCD, 0xCD, 0xCD, 0xCD, 0xCD, 0xCD, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF,
+0x00, 0x00, 0x80, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x3F, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x80, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x3F, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFD, 0xBF, 0xFE, 0x7F, 0xFE, 0x7F, 0xFE, 0x7F,
+0x00, 0x80, 0x00, 0x80, 0x00, 0x80
+};
+
+
+// returns qtrue if loaded, and sets the supplied qbool to true if it was from cache (instead of disk)
+//   (which we need to know to avoid LittleLong()ing everything again (well, the Mac needs to know anyway)...
+//
+qboolean RE_RegisterModels_GetDiskFile( const char *psModelFileName, void **ppvBuffer, qboolean *pqbAlreadyCached)
+{
+	char sModelName[MAX_QPATH];
+
+	Q_strncpyz(sModelName,psModelFileName,sizeof(sModelName));
+	Q_strlwr  (sModelName);
+
+	CachedEndianedModelBinary_t &ModelBin = (*CachedModels)[sModelName];
+
+	if (ModelBin.pModelDiskImage == NULL)
+	{
+		// didn't have it cached, so try the disk...
+		//
+
+			// special case intercept first...
+			//
+			if (!strcmp(sDEFAULT_GLA_NAME ".gla" , psModelFileName))
+			{
+				// return fake params as though it was found on disk...
+				//
+				void *pvFakeGLAFile = Z_Malloc( sizeof(FakeGLAFile), TAG_FILESYS, qfalse );
+				memcpy(pvFakeGLAFile, &FakeGLAFile[0],  sizeof(FakeGLAFile));
+				*ppvBuffer = pvFakeGLAFile;
+				*pqbAlreadyCached = qfalse;	// faking it like this should mean that it works fine on the Mac as well
+				return qtrue;	
+			}
+
+		FS_ReadFile( sModelName, ppvBuffer );
+		*pqbAlreadyCached = qfalse;
+
+		const bool bSuccess = !!(*ppvBuffer);
+
+		return bSuccess;
+	}
+	else
+	{
+		*ppvBuffer = ModelBin.pModelDiskImage;
+		*pqbAlreadyCached = qtrue;
+		return qtrue;
+	}
+}
+
+
+// if return == true, no further action needed by the caller...
+//
+void *RE_RegisterModels_Malloc(int iSize, void *pvDiskBufferIfJustLoaded, const char *psModelFileName, qboolean *pqbAlreadyFound, memtag_t eTag)
+{
+	char sModelName[MAX_QPATH];
+
+	Q_strncpyz(sModelName,psModelFileName,sizeof(sModelName));
+	Q_strlwr  (sModelName);
+
+	CachedEndianedModelBinary_t &ModelBin = (*CachedModels)[sModelName];
+
+	if (ModelBin.pModelDiskImage == NULL)
+	{
+		// ... then this entry has only just been created, ie we need to load it fully...
+		//
+		// new, instead of doing a Z_Malloc and assigning that we just morph the disk buffer alloc
+		//	then don't thrown it away on return - cuts down on mem overhead
+		//
+		// ... groan, but not if doing a limb hierarchy creation (some VV stuff?), in which case it's NULL
+		//				
+		if ( pvDiskBufferIfJustLoaded )
+		{
+			Z_MorphMallocTag( pvDiskBufferIfJustLoaded, eTag );
+		}
+		else
+		{
+			pvDiskBufferIfJustLoaded =  Z_Malloc(iSize,eTag, qfalse );
+		}
+
+		ModelBin.pModelDiskImage= pvDiskBufferIfJustLoaded;
+		ModelBin.iAllocSize		= iSize;
+		*pqbAlreadyFound		= qfalse;
+	}
+	else
+	{
+		// if we already had this model entry, then re-register all the shaders it wanted...
+		//
+		const int iEntries = ModelBin.ShaderRegisterData.size();
+		for (int i=0; i<iEntries; i++)
+		{
+			int iShaderNameOffset	= ModelBin.ShaderRegisterData[i].first;
+			int iShaderPokeOffset	= ModelBin.ShaderRegisterData[i].second;
+
+			const char *const psShaderName	 =		   &((char*)ModelBin.pModelDiskImage)[iShaderNameOffset];
+				  int  *const piShaderPokePtr= (int *) &((char*)ModelBin.pModelDiskImage)[iShaderPokeOffset];
+
+			shader_t *sh = R_FindShader( psShaderName, lightmapsNone, stylesDefault, qtrue );
+	            
+			if ( sh->defaultShader ) 
+			{
+				*piShaderPokePtr = 0;
+			} else {
+				*piShaderPokePtr = sh->index;
+			}
+		}
+		*pqbAlreadyFound = qtrue;	// tell caller not to re-Endian or re-Shader this binary		
+	}
+
+	ModelBin.iLastLevelUsedOn = RE_RegisterMedia_GetLevel();
+
+	return ModelBin.pModelDiskImage;
+}
+
+
+// dump any models not being used by this level if we're running low on memory...
+//
+static int GetModelDataAllocSize(void)
+{
+	return	Z_MemSize( TAG_MODEL_MD3) +
+			Z_MemSize( TAG_MODEL_GLM) +
+			Z_MemSize( TAG_MODEL_GLA);
+}
+extern cvar_t *r_modelpoolmegs;
+//
+// return qtrue if at least one cached model was freed (which tells z_malloc()-fail recovery code to try again)
+//
+extern qboolean gbInsideRegisterModel;
+qboolean RE_RegisterModels_LevelLoadEnd(qboolean bDeleteEverythingNotUsedThisLevel /* = qfalse */)
+{	
+	qboolean bAtLeastoneModelFreed = qfalse;
+
+	if (gbInsideRegisterModel)
+	{
+		Com_DPrintf( "(Inside RE_RegisterModel (z_malloc recovery?), exiting...\n");
+	}
+	else
+	{
+		int iLoadedModelBytes	=	GetModelDataAllocSize();
+		const int iMaxModelBytes=	r_modelpoolmegs->integer * 1024 * 1024;
+
+		qboolean bEraseOccured = qfalse;
+		for (CachedModels_t::iterator itModel = CachedModels->begin(); itModel != CachedModels->end() && ( bDeleteEverythingNotUsedThisLevel || iLoadedModelBytes > iMaxModelBytes ); bEraseOccured?itModel:++itModel)
+		{			
+			bEraseOccured = qfalse;
+
+			CachedEndianedModelBinary_t &CachedModel = (*itModel).second;
+
+			qboolean bDeleteThis = qfalse;
+
+			if (bDeleteEverythingNotUsedThisLevel)
+			{
+				bDeleteThis = (CachedModel.iLastLevelUsedOn != RE_RegisterMedia_GetLevel());
+			}
+			else
+			{
+				bDeleteThis = (CachedModel.iLastLevelUsedOn < RE_RegisterMedia_GetLevel());
+			}
+
+			// if it wasn't used on this level, dump it...
+			//
+			if (bDeleteThis)
+			{
+	#ifdef _DEBUG
+//				LPCSTR psModelName = (*itModel).first.c_str();
+//				VID_Printf( PRINT_DEVELOPER, "Dumping \"%s\"", psModelName);
+//				VID_Printf( PRINT_DEVELOPER, ", used on lvl %d\n",CachedModel.iLastLevelUsedOn);
+	#endif				
+
+				if (CachedModel.pModelDiskImage) {
+					Z_Free(CachedModel.pModelDiskImage);	
+					//CachedModel.pModelDiskImage = NULL;	// REM for reference, erase() call below negates the need for it.
+					bAtLeastoneModelFreed = qtrue;
+				}
+
+				itModel = CachedModels->erase(itModel);
+				bEraseOccured = qtrue;
+
+				iLoadedModelBytes = GetModelDataAllocSize();				
+			}
+		}
+	}
+
+	//VID_Printf( PRINT_DEVELOPER, "RE_RegisterModels_LevelLoadEnd(): Ok\n");	
+
+	return bAtLeastoneModelFreed;	
+}
+
+void RE_RegisterModels_Info_f( void )
+{	
+	int iTotalBytes = 0;
+	if(!CachedModels) {
+		Com_Printf ("%d bytes total (%.2fMB)\n",iTotalBytes, (float)iTotalBytes / 1024.0f / 1024.0f);
+		return;
+	}
+
+	int iModels = CachedModels->size();
+	int iModel  = 0;
+
+	for (CachedModels_t::iterator itModel = CachedModels->begin(); itModel != CachedModels->end(); ++itModel,iModel++)
+	{	
+		CachedEndianedModelBinary_t &CachedModel = (*itModel).second;
+
+		VID_Printf( PRINT_ALL, "%d/%d: \"%s\" (%d bytes)",iModel,iModels,(*itModel).first.c_str(),CachedModel.iAllocSize );
+
+		#ifdef _DEBUG
+		VID_Printf( PRINT_ALL, ", lvl %d\n",CachedModel.iLastLevelUsedOn);
+		#endif
+
+		iTotalBytes += CachedModel.iAllocSize;
+	}
+	VID_Printf( PRINT_ALL, "%d bytes total (%.2fMB)\n",iTotalBytes, (float)iTotalBytes / 1024.0f / 1024.0f);
+}
+
+
+static void RE_RegisterModels_DeleteAll(void)
+{
+	for (CachedModels_t::iterator itModel = CachedModels->begin(); itModel != CachedModels->end(); )
+	{
+		CachedEndianedModelBinary_t &CachedModel = (*itModel).second;
+
+		if (CachedModel.pModelDiskImage) {
+			Z_Free(CachedModel.pModelDiskImage);					
+		}
+
+		itModel = CachedModels->erase(itModel);			
+	}
+
+	extern void RE_AnimationCFGs_DeleteAll(void);
+	RE_AnimationCFGs_DeleteAll();
+}
+
+
+static int giRegisterMedia_CurrentLevel=0;
+static qboolean gbAllowScreenDissolve = qtrue;
+//
+// param "bAllowScreenDissolve" is just a convenient way of getting hold of a bool which can be checked by the code that
+//	issues the InitDissolve command later in RE_RegisterMedia_LevelLoadEnd()
+//
+void RE_RegisterMedia_LevelLoadBegin(const char *psMapName, ForceReload_e eForceReload, qboolean bAllowScreenDissolve)
+{
+	gbAllowScreenDissolve = bAllowScreenDissolve;
+
+	tr.numBSPModels = 0;
+
+	// for development purposes we may want to ditch certain media just before loading a map...
+	//
+	switch (eForceReload)
+	{
+		case eForceReload_BSP:
+
+			CM_DeleteCachedMap(qtrue);
+			R_Images_DeleteLightMaps();
+			break;
+
+		case eForceReload_MODELS:
+
+			RE_RegisterModels_DeleteAll();
+			break;
+
+		case eForceReload_ALL:
+
+			// BSP...
+			//
+			CM_DeleteCachedMap(qtrue);
+			R_Images_DeleteLightMaps();
+			//
+			// models...
+			//
+			RE_RegisterModels_DeleteAll();
+			break;
+	}
+
+	// at some stage I'll probably want to put some special logic here, like not incrementing the level number
+	//	when going into a map like "brig" or something, so returning to the previous level doesn't require an 
+	//	asset reload etc, but for now...
+	//
+	// only bump level number if we're not on the same level. 
+	//	Note that this will hide uncached models, which is perhaps a bad thing?...
+	//
+	static char sPrevMapName[MAX_QPATH]={0};
+	if (Q_stricmp( psMapName,sPrevMapName ))
+	{
+		Q_strncpyz( sPrevMapName, psMapName, sizeof(sPrevMapName) );
+		giRegisterMedia_CurrentLevel++;
+	}
+}
+
+int RE_RegisterMedia_GetLevel(void)
+{
+	return giRegisterMedia_CurrentLevel;
+}
+
+extern qboolean SND_RegisterAudio_LevelLoadEnd(qboolean bDeleteEverythingNotUsedThisLevel);
+
+void RE_RegisterMedia_LevelLoadEnd(void)
+{
+	RE_RegisterModels_LevelLoadEnd(qfalse);
+	RE_RegisterImages_LevelLoadEnd();
+	SND_RegisterAudio_LevelLoadEnd(qfalse);
+
+	if (gbAllowScreenDissolve)
+	{
+		RE_InitDissolve(qfalse);
+	}
+
+	S_RestartMusic();
+	
+	extern qboolean gbAlreadyDoingLoad;
+					gbAlreadyDoingLoad = qfalse;
+}
+
+
+
+
+/*
+** R_GetModelByHandle
+*/
+model_t	*R_GetModelByHandle( qhandle_t index ) {
+	model_t		*mod;
+
+	// out of range gets the defualt model
+	if ( index < 1 || index >= tr.numModels ) {
+		return tr.models[0];
+	}
+
+	mod = tr.models[index];
+
+	return mod;
+}
+
+//===============================================================================
+
+/*
+** R_AllocModel
+*/
+model_t *R_AllocModel( void ) {
+	model_t		*mod;
+
+	if ( tr.numModels == MAX_MOD_KNOWN ) {
+		return NULL;
+	}
+
+	mod = (model_t*) Hunk_Alloc( sizeof( *tr.models[tr.numModels] ), qtrue );
+	mod->index= tr.numModels;
+	tr.models[tr.numModels] = mod;
+	tr.numModels++;
+
+	return mod;
+}
+
+/*
+Ghoul2 Insert Start
+*/
+
+/*
+================
+return a hash value for the filename
+================
+*/
+static long generateHashValue( const char *fname, const int size ) {
+	int		i;
+	long	hash;
+	char	letter;
+
+	hash = 0;
+	i = 0;
+	while (fname[i] != '\0') {
+		letter = tolower(fname[i]);
+		if (letter =='.') break;				// don't include extension
+		if (letter =='\\') letter = '/';		// damn path names
+		hash+=(long)(letter)*(i+119);
+		i++;
+	}
+	hash &= (size-1);
+	return hash;
+}
+
+void RE_InsertModelIntoHash(const char *name, model_t *mod)
+{
+	int			hash;
+	modelHash_t	*mh;
+
+	hash = generateHashValue(name, FILE_HASH_SIZE);
+
+	// insert this file into the hash table so we can look it up faster later
+	mh = (modelHash_t*)Hunk_Alloc( sizeof( modelHash_t ), qtrue );
+
+	mh->next = mhHashTable[hash];
+	mh->handle = mod->index;
+	strcpy(mh->name, name);
+	mhHashTable[hash] = mh;
+}
+/*
+Ghoul2 Insert End
+*/
+
+
+/*
+====================
+RE_RegisterModel
+
+Loads in a model for the given name
+
+Zero will be returned if the model fails to load.
+An entry will be retained for failed models as an
+optimization to prevent disk rescanning if they are
+asked for again.
+====================
+*/
+static qhandle_t RE_RegisterModel_Actual( const char *name ) 
+{
+	model_t		*mod;
+	unsigned	*buf;
+	int			lod;
+	int			ident;
+	qboolean	loaded;
+//	qhandle_t	hModel;
+	int			numLoaded;
+/*
+Ghoul2 Insert Start
+*/
+	int			hash;
+	modelHash_t	*mh;
+/*
+Ghoul2 Insert End
+*/
+
+	if ( !name || !name[0] ) {
+		VID_Printf( PRINT_WARNING, "RE_RegisterModel: NULL name\n" );
+		return 0;
+	}
+
+	if ( strlen( name ) >= MAX_QPATH ) {
+		VID_Printf( PRINT_DEVELOPER, "Model name exceeds MAX_QPATH\n" );
+		return 0;
+	}
+
+/*
+Ghoul2 Insert Start
+*/
+//	if (!tr.registered) {
+//		VID_Printf( PRINT_WARNING, "RE_RegisterModel (%s) called before ready!\n",name );
+//		return 0;
+//	}
+	//
+	// search the currently loaded models
+	//
+
+	hash = generateHashValue(name, FILE_HASH_SIZE);
+
+	//
+	// see if the model is already loaded
+	//
+	for (mh=mhHashTable[hash]; mh; mh=mh->next) {
+		if (Q_stricmp(mh->name, name) == 0) {
+			if (tr.models[mh->handle]->type == MOD_BAD)
+			{
+				return 0;
+			}
+			return mh->handle;
+		}
+	}
+
+/*
+Ghoul2 Insert End
+*/
+
+	if (name[0] == '#')
+	{
+		char		temp[MAX_QPATH];
+
+		tr.numBSPModels++;
+#ifndef DEDICATED
+		RE_LoadWorldMap_Actual(va("maps/%s.bsp", name + 1), tr.bspModels[tr.numBSPModels - 1], tr.numBSPModels);	//this calls R_LoadSubmodels which will put them into the Hash
+#endif
+		Com_sprintf(temp, MAX_QPATH, "*%d-0", tr.numBSPModels);
+		hash = generateHashValue(temp, FILE_HASH_SIZE);
+		for (mh=mhHashTable[hash]; mh; mh=mh->next) 
+		{
+			if (Q_stricmp(mh->name, temp) == 0) 
+			{
+				return mh->handle;
+			}
+		}
+		
+		return 0;
+	}
+
+	// allocate a new model_t
+
+	if ( ( mod = R_AllocModel() ) == NULL ) {
+		VID_Printf( PRINT_WARNING, "RE_RegisterModel: R_AllocModel() failed for '%s'\n", name);
+		return 0;
+	}
+
+	// only set the name after the model has been successfully loaded
+	Q_strncpyz( mod->name, name, sizeof( mod->name ) );
+
+	// make sure the render thread is stopped
+	//R_SyncRenderThread();
+
+	int iLODStart = 0;
+	if (strstr (name, ".md3")) {
+		iLODStart = MD3_MAX_LODS-1;	//this loads the md3s in reverse so they can be biased
+	}
+	mod->numLods = 0;
+
+	//
+	// load the files
+	//
+	numLoaded = 0;
+
+	for ( lod = iLODStart; lod >= 0 ; lod-- ) {
+		char filename[1024];
+
+		strcpy( filename, name );
+
+		if ( lod != 0 ) {
+			char namebuf[80];
+
+			if ( strrchr( filename, '.' ) ) {
+				*strrchr( filename, '.' ) = 0;
+			}
+			sprintf( namebuf, "_%d.md3", lod );
+			strcat( filename, namebuf );
+		}
+
+		qboolean bAlreadyCached = qfalse;		
+		if (!RE_RegisterModels_GetDiskFile(filename, (void **)&buf, &bAlreadyCached))
+		{
+			if (numLoaded)	//we loaded one already, but a higher LOD is missing!
+			{
+				Com_Error (ERR_DROP, "R_LoadMD3: %s has LOD %d but is missing LOD %d ('%s')!", mod->name, lod+1, lod, filename);
+			}
+			continue;
+		}
+		
+		//loadmodel = mod;	// this seems to be fairly pointless
+
+		// important that from now on we pass 'filename' instead of 'name' to all model load functions,
+		//	because 'filename' accounts for any LOD mangling etc so guarantees unique lookups for yet more
+		//	internal caching...
+		//		
+		ident = *(unsigned *)buf;
+		if (!bAlreadyCached)
+		{
+			ident = LittleLong(ident);
+		}
+
+		switch (ident)
+		{
+			// if you add any new types of model load in this switch-case, tell me, 
+			//	or copy what I've done with the cache scheme (-ste).
+			//
+			case MDXA_IDENT:
+
+				loaded = R_LoadMDXA( mod, buf, filename, bAlreadyCached );
+				break;
+		
+			case MDXM_IDENT:
+				
+				loaded = R_LoadMDXM( mod, buf, filename, bAlreadyCached );
+				break;
+
+			case MD3_IDENT:
+
+				loaded = R_LoadMD3( mod, lod, buf, filename, bAlreadyCached );
+				break;
+
+			default:
+
+				VID_Printf (PRINT_WARNING,"RE_RegisterModel: unknown fileid for %s\n", filename);
+				goto fail;
+		}
+		
+		if (!bAlreadyCached){	// important to check!!
+			FS_FreeFile (buf);
+		}
+
+		if ( !loaded ) {
+			if ( lod == 0 ) {
+				VID_Printf (PRINT_WARNING,"RE_RegisterModel: cannot load %s\n", filename);
+				goto fail;
+			} else {
+				break;
+			}
+		} else {
+			mod->numLods++;
+			numLoaded++;
+			// if we have a valid model and are biased
+			// so that we won't see any higher detail ones,
+			// stop loading them
+			if ( lod <= r_lodbias->integer ) {
+				break;
+			}
+		}
+	}
+
+	if ( numLoaded ) {
+		// duplicate into higher lod spots that weren't
+		// loaded, in case the user changes r_lodbias on the fly
+		for ( lod-- ; lod >= 0 ; lod-- ) {
+			mod->numLods++;
+			mod->md3[lod] = mod->md3[lod+1];
+		}
+/*
+Ghoul2 Insert Start
+*/
+
+	RE_InsertModelIntoHash(name, mod);
+	return mod->index;
+/*
+Ghoul2 Insert End
+*/
+	
+	}
+
+
+fail:
+	// we still keep the model_t around, so if the model name is asked for
+	// again, we won't bother scanning the filesystem
+	mod->type = MOD_BAD;
+	RE_InsertModelIntoHash(name, mod);
+	return 0;
+}
+
+
+
+
+// wrapper function needed to avoid problems with mid-function returns so I can safely use this bool to tell the
+//	z_malloc-fail recovery code whether it's safe to ditch any model caches...
+//
+qboolean gbInsideRegisterModel = qfalse;
+qhandle_t RE_RegisterModel( const char *name )
+{
+	gbInsideRegisterModel = qtrue;	// !!!!!!!!!!!!!!
+
+		qhandle_t q = RE_RegisterModel_Actual( name );
+
+if (stricmp(&name[strlen(name)-4],".gla")){
+	gbInsideRegisterModel = qfalse;		// GLA files recursively call this, so don't turn off half way. A reference count would be nice, but if any ERR_DROP ever occurs within the load then the refcount will be knackered from then on
+}
+
+	return q;
+}
+
+
+/*
+=================
+R_LoadMD3
+=================
+*/
+static qboolean R_LoadMD3 (model_t *mod, int lod, void *buffer, const char *mod_name, qboolean &bAlreadyCached ) {
+	int					i, j;
+	md3Header_t			*pinmodel;
+	md3Surface_t		*surf;
+	md3Shader_t			*shader;
+	int					version;
+	int					size;
+
+#ifndef _M_IX86
+	md3Frame_t			*frame;
+	md3Triangle_t		*tri;
+	md3St_t				*st;
+	md3XyzNormal_t		*xyz;
+	md3Tag_t			*tag;
+#endif
+
+
+	pinmodel= (md3Header_t *)buffer;
+	//
+	// read some fields from the binary, but only LittleLong() them when we know this wasn't an already-cached model...
+	//
+	version = pinmodel->version;
+	size	= pinmodel->ofsEnd;
+
+	if (!bAlreadyCached)
+	{
+		version = LittleLong(version);
+		size	= LittleLong(size);
+	}
+	
+	if (version != MD3_VERSION) {
+		VID_Printf( PRINT_WARNING, "R_LoadMD3: %s has wrong version (%i should be %i)\n",
+				 mod_name, version, MD3_VERSION);
+		return qfalse;
+	}
+
+	mod->type      = MOD_MESH;	
+	mod->dataSize += size;
+
+	qboolean bAlreadyFound = qfalse;
+	mod->md3[lod] = (md3Header_t *) RE_RegisterModels_Malloc(size, buffer, mod_name, &bAlreadyFound, TAG_MODEL_MD3);
+
+	assert(bAlreadyCached == bAlreadyFound);
+
+	if (!bAlreadyFound)
+	{	
+		// horrible new hackery, if !bAlreadyFound then we've just done a tag-morph, so we need to set the 
+		//	bool reference passed into this function to true, to tell the caller NOT to do an FS_Freefile since
+		//	we've hijacked that memory block...
+		//
+		// Aaaargh. Kill me now...
+		//
+		bAlreadyCached = qtrue;
+		assert( mod->md3[lod] == buffer );
+//		memcpy( mod->md3[lod], buffer, size );	// and don't do this now, since it's the same thing
+
+		LL(mod->md3[lod]->ident);
+		LL(mod->md3[lod]->version);
+		LL(mod->md3[lod]->numFrames);
+		LL(mod->md3[lod]->numTags);
+		LL(mod->md3[lod]->numSurfaces);
+		LL(mod->md3[lod]->ofsFrames);
+		LL(mod->md3[lod]->ofsTags);
+		LL(mod->md3[lod]->ofsSurfaces);
+		LL(mod->md3[lod]->ofsEnd);
+	}
+
+	if ( mod->md3[lod]->numFrames < 1 ) {
+		VID_Printf( PRINT_WARNING, "R_LoadMD3: %s has no frames\n", mod_name );
+		return qfalse;
+	}
+
+	if (bAlreadyFound)
+	{
+		return qtrue;	// All done. Stop, go no further, do not pass Go...
+	}
+
+#ifndef _M_IX86
+	//
+	// optimisation, we don't bother doing this for standard intel case since our data's already in that format...
+	//
+
+	// swap all the frames
+    frame = (md3Frame_t *) ( (byte *)mod->md3[lod] + mod->md3[lod]->ofsFrames );
+    for ( i = 0 ; i < mod->md3[lod]->numFrames ; i++, frame++) {
+    	frame->radius = LittleFloat( frame->radius );
+        for ( j = 0 ; j < 3 ; j++ ) {
+            frame->bounds[0][j] = LittleFloat( frame->bounds[0][j] );
+            frame->bounds[1][j] = LittleFloat( frame->bounds[1][j] );
+	    	frame->localOrigin[j] = LittleFloat( frame->localOrigin[j] );
+        }
+	}
+
+	// swap all the tags
+    tag = (md3Tag_t *) ( (byte *)mod->md3[lod] + mod->md3[lod]->ofsTags );
+    for ( i = 0 ; i < mod->md3[lod]->numTags * mod->md3[lod]->numFrames ; i++, tag++) {
+        for ( j = 0 ; j < 3 ; j++ ) {
+			tag->origin[j] = LittleFloat( tag->origin[j] );
+			tag->axis[0][j] = LittleFloat( tag->axis[0][j] );
+			tag->axis[1][j] = LittleFloat( tag->axis[1][j] );
+			tag->axis[2][j] = LittleFloat( tag->axis[2][j] );
+        }
+	}
+#endif
+
+	// swap all the surfaces
+	surf = (md3Surface_t *) ( (byte *)mod->md3[lod] + mod->md3[lod]->ofsSurfaces );
+	for ( i = 0 ; i < mod->md3[lod]->numSurfaces ; i++) {
+        LL(surf->flags);
+        LL(surf->numFrames);
+        LL(surf->numShaders);
+        LL(surf->numTriangles);
+        LL(surf->ofsTriangles);
+        LL(surf->numVerts);
+        LL(surf->ofsShaders);
+        LL(surf->ofsSt);
+        LL(surf->ofsXyzNormals);
+        LL(surf->ofsEnd);
+		
+		if ( surf->numVerts > SHADER_MAX_VERTEXES ) {
+			Com_Error (ERR_DROP, "R_LoadMD3: %s has more than %i verts on a surface (%i)",
+				mod_name, SHADER_MAX_VERTEXES, surf->numVerts );
+		}
+		if ( surf->numTriangles*3 > SHADER_MAX_INDEXES ) {
+			Com_Error (ERR_DROP, "R_LoadMD3: %s has more than %i triangles on a surface (%i)",
+				mod_name, SHADER_MAX_INDEXES / 3, surf->numTriangles );
+		}
+	
+		// change to surface identifier
+		surf->ident = SF_MD3;
+
+		// lowercase the surface name so skin compares are faster
+		Q_strlwr( surf->name );
+
+		// strip off a trailing _1 or _2
+		// this is a crutch for q3data being a mess
+		j = strlen( surf->name );
+		if ( j > 2 && surf->name[j-2] == '_' ) {
+			surf->name[j-2] = 0;
+		}
+
+        // register the shaders
+        shader = (md3Shader_t *) ( (byte *)surf + surf->ofsShaders );
+        for ( j = 0 ; j < surf->numShaders ; j++, shader++ ) {
+            shader_t	*sh;
+
+            sh = R_FindShader( shader->name, lightmapsNone, stylesDefault, qtrue );
+			if ( sh->defaultShader ) {
+				shader->shaderIndex = 0;
+			} else {
+				shader->shaderIndex = sh->index;
+			}
+			RE_RegisterModels_StoreShaderRequest(mod_name, &shader->name[0], &shader->shaderIndex);
+        }
+
+
+#ifndef _M_IX86
+//
+// optimisation, we don't bother doing this for standard intel case since our data's already in that format...
+//
+
+		// swap all the triangles
+		tri = (md3Triangle_t *) ( (byte *)surf + surf->ofsTriangles );
+		for ( j = 0 ; j < surf->numTriangles ; j++, tri++ ) {
+			LL(tri->indexes[0]);
+			LL(tri->indexes[1]);
+			LL(tri->indexes[2]);
+		}
+
+		// swap all the ST
+        st = (md3St_t *) ( (byte *)surf + surf->ofsSt );
+        for ( j = 0 ; j < surf->numVerts ; j++, st++ ) {
+            st->st[0] = LittleFloat( st->st[0] );
+            st->st[1] = LittleFloat( st->st[1] );
+        }
+
+		// swap all the XyzNormals
+        xyz = (md3XyzNormal_t *) ( (byte *)surf + surf->ofsXyzNormals );
+        for ( j = 0 ; j < surf->numVerts * surf->numFrames ; j++, xyz++ ) 
+		{
+            xyz->xyz[0] = LittleShort( xyz->xyz[0] );
+            xyz->xyz[1] = LittleShort( xyz->xyz[1] );
+            xyz->xyz[2] = LittleShort( xyz->xyz[2] );
+
+            xyz->normal = LittleShort( xyz->normal );
+        }
+#endif
+
+		// find the next surface
+		surf = (md3Surface_t *)( (byte *)surf + surf->ofsEnd );
+	}
+    
+	return qtrue;
+}
+
+
+//=============================================================================
+
+void ShaderTableCleanup();
+void CM_LoadShaderText(bool forceReload);
+void CM_SetupShaderProperties(void);
+
+/*
+** RE_BeginRegistration
+*/
+void RE_BeginRegistration( glconfig_t *glconfigOut ) {
+#ifndef _XBOX
+	ShaderTableCleanup();
+#endif
+	Hunk_ClearToMark();
+
+	R_Init();
+	*glconfigOut = glConfig;
+
+	tr.viewCluster = -1;		// force markleafs to regenerate
+	RE_ClearScene();
+	tr.registered = qtrue;
+
+	R_SyncRenderThread();
+}
+
+//=============================================================================
+
+/*
+===============
+R_ModelInit
+===============
+*/
+void R_ModelInit( void ) 
+{
+#ifdef _XBOX
+	// Sorry Raven, but static maps == fragmentation
+	if (!CachedModels)
+	{
+		CachedModels = new CachedModels_t;
+	}
+#else
+	static CachedModels_t singleton;	// sorry vv, your dynamic allocation was a (false) memory leak
+	CachedModels = &singleton;
+#endif
+
+	model_t		*mod;
+
+	// leave a space for NULL model
+	tr.numModels = 0;
+
+	mod = R_AllocModel();
+	mod->type = MOD_BAD;
+/*
+Ghoul2 Insert Start
+*/
+
+	memset(mhHashTable, 0, sizeof(mhHashTable));
+/*
+Ghoul2 Insert End
+*/
+
+}
+
+
+/*
+================
+R_Modellist_f
+================
+*/
+void R_Modellist_f( void ) {
+	int		i, j;
+	model_t	*mod;
+	int		total;
+	int		lods;
+
+	total = 0;
+	for ( i = 1 ; i < tr.numModels; i++ ) {
+		mod = tr.models[i];
+		switch (mod->type)
+		{
+			default:
+				assert(0);
+				VID_Printf( PRINT_ALL, "UNKNOWN  :      %s\n", mod->name );
+				break;
+
+			case MOD_BAD:
+				VID_Printf( PRINT_ALL, "MOD_BAD  :      %s\n", mod->name );
+				break;
+
+			case MOD_BRUSH:
+				VID_Printf( PRINT_ALL, "%8i : (%i) %s\n", mod->dataSize, mod->numLods, mod->name );
+				break;
+
+			case MOD_MDXA:
+
+				VID_Printf( PRINT_ALL, "%8i : (%i) %s\n", mod->dataSize, mod->numLods, mod->name );								
+				break;
+		
+			case MOD_MDXM:
+				
+				VID_Printf( PRINT_ALL, "%8i : (%i) %s\n", mod->dataSize, mod->numLods, mod->name );								
+				break;
+
+			case MOD_MESH:
+
+				lods = 1;
+				for ( j = 1 ; j < MD3_MAX_LODS ; j++ ) {
+					if ( mod->md3[j] && mod->md3[j] != mod->md3[j-1] ) {
+						lods++;
+					}
+				}				
+				VID_Printf( PRINT_ALL, "%8i : (%i) %s\n",mod->dataSize, lods, mod->name );
+				break;		
+		}
+		total += mod->dataSize;
+	}
+	VID_Printf( PRINT_ALL, "%8i : Total models\n", total );
+
+/*	this doesn't work with the new hunks
+	if ( tr.world ) {
+		VID_Printf( PRINT_ALL, "%8i : %s\n", tr.world->dataSize, tr.world->name );
+	} */
+}
+
+//=============================================================================
+
+
+/*
+================
+R_GetTag for MD3s
+================
+*/
+static md3Tag_t *R_GetTag( md3Header_t *mod, int frame, const char *tagName ) {
+	md3Tag_t		*tag;
+	int				i;
+
+	if ( frame >= mod->numFrames ) {
+		// it is possible to have a bad frame while changing models, so don't error
+		frame = mod->numFrames - 1;
+	}
+
+	tag = (md3Tag_t *)((byte *)mod + mod->ofsTags) + frame * mod->numTags;
+	for ( i = 0 ; i < mod->numTags ; i++, tag++ ) {
+		if ( !strcmp( tag->name, tagName ) ) {
+			return tag;	// found it
+		}
+	}
+
+	return NULL;
+}
+
+/*
+================
+R_LerpTag
+================
+*/
+void	R_LerpTag( orientation_t *tag, qhandle_t handle, int startFrame, int endFrame, 
+					 float frac, const char *tagName ) {
+	md3Tag_t	*start, *finish;
+	int		i;
+	float		frontLerp, backLerp;
+	model_t		*model;
+
+	model = R_GetModelByHandle( handle );
+	if ( model->md3[0] ) 
+	{
+		start = R_GetTag( model->md3[0], startFrame, tagName );
+		finish = R_GetTag( model->md3[0], endFrame, tagName );
+	}
+	else
+	{
+		AxisClear( tag->axis );
+		VectorClear( tag->origin );
+		return;
+	}
+
+	if ( !start || !finish ) {
+		AxisClear( tag->axis );
+		VectorClear( tag->origin );
+		return;
+	}
+
+	frontLerp = frac;
+	backLerp = 1.0 - frac;
+
+	for ( i = 0 ; i < 3 ; i++ ) {
+		tag->origin[i] = start->origin[i] * backLerp +  finish->origin[i] * frontLerp;
+		tag->axis[0][i] = start->axis[0][i] * backLerp +  finish->axis[0][i] * frontLerp;
+		tag->axis[1][i] = start->axis[1][i] * backLerp +  finish->axis[1][i] * frontLerp;
+		tag->axis[2][i] = start->axis[2][i] * backLerp +  finish->axis[2][i] * frontLerp;
+	}
+	VectorNormalize( tag->axis[0] );
+	VectorNormalize( tag->axis[1] );
+	VectorNormalize( tag->axis[2] );
+}
+
+
+/*
+====================
+R_ModelBounds
+====================
+*/
+void R_ModelBounds( qhandle_t handle, vec3_t mins, vec3_t maxs ) {
+	model_t		*model;
+
+	model = R_GetModelByHandle( handle );
+
+	if ( model->bmodel ) {
+		VectorCopy( model->bmodel->bounds[0], mins );
+		VectorCopy( model->bmodel->bounds[1], maxs );
+		return;
+	}
+
+	if ( model->md3[0] ) {
+		md3Header_t	*header;
+		md3Frame_t	*frame;
+		header = model->md3[0];
+
+		frame = (md3Frame_t *)( (byte *)header + header->ofsFrames );
+
+		VectorCopy( frame->bounds[0], mins );
+		VectorCopy( frame->bounds[1], maxs );
+	}
+	else
+	{
+		VectorClear( mins );
+		VectorClear( maxs );
+		return;
+	}
+}
+
+
+#ifdef _XBOX
+void R_ModelFree(void)
+{
+	if (CachedModels)
+	{
+		RE_RegisterModels_DeleteAll();
+		delete CachedModels;
+		CachedModels = NULL;
+	}
+}
+#endif
\ No newline at end of file
diff --git a/code/renderer/tr_noise.cpp b/code/renderer/tr_noise.cpp
new file mode 100644
index 0000000..40d349d
--- /dev/null
+++ b/code/renderer/tr_noise.cpp
@@ -0,0 +1,89 @@
+// tr_noise.c
+
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+
+
+#include "tr_local.h"
+
+#define NOISE_SIZE 256
+#define NOISE_MASK ( NOISE_SIZE - 1 )
+
+#define VAL( a ) s_noise_perm[ ( a ) & ( NOISE_MASK )]
+#define INDEX( x, y, z, t ) VAL( x + VAL( y + VAL( z + VAL( t ) ) ) )
+
+static float s_noise_table[NOISE_SIZE];
+static int s_noise_perm[NOISE_SIZE];
+
+#define LERP( a, b, w ) ( a * ( 1.0f - w ) + b * w )
+
+static float GetNoiseValue( int x, int y, int z, int t )
+{
+	int index = INDEX( ( int ) x, ( int ) y, ( int ) z, ( int ) t );
+
+	return s_noise_table[index];
+}
+
+float GetNoiseTime( int t )
+{
+	int index = VAL( t );
+
+	return (1+s_noise_table[index]);
+}
+
+void R_NoiseInit( void )
+{
+	int i;
+
+	srand( 1001 );
+
+	for ( i = 0; i < NOISE_SIZE; i++ )
+	{
+		s_noise_table[i] = ( float ) ( ( ( rand() / ( float ) RAND_MAX ) * 2.0 - 1.0 ) );
+		s_noise_perm[i] = ( unsigned char ) ( rand() / ( float ) RAND_MAX * 255 );
+	}
+	srand( com_frameTime );
+}
+
+float R_NoiseGet4f( float x, float y, float z, float t )
+{
+	int i;
+	int ix, iy, iz, it;
+	float fx, fy, fz, ft;
+	float front[4];
+	float back[4];
+	float fvalue, bvalue, value[2], finalvalue;
+
+	ix = ( int ) floor( x );
+	fx = x - ix;
+	iy = ( int ) floor( y );
+	fy = y - iy;
+	iz = ( int ) floor( z );
+	fz = z - iz;
+	it = ( int ) floor( t );
+	ft = t - it;
+
+	for ( i = 0; i < 2; i++ )
+	{
+		front[0] = GetNoiseValue( ix, iy, iz, it + i );
+		front[1] = GetNoiseValue( ix+1, iy, iz, it + i );
+		front[2] = GetNoiseValue( ix, iy+1, iz, it + i );
+		front[3] = GetNoiseValue( ix+1, iy+1, iz, it + i );
+
+		back[0] = GetNoiseValue( ix, iy, iz + 1, it + i );
+		back[1] = GetNoiseValue( ix+1, iy, iz + 1, it + i );
+		back[2] = GetNoiseValue( ix, iy+1, iz + 1, it + i );
+		back[3] = GetNoiseValue( ix+1, iy+1, iz + 1, it + i );
+
+		fvalue = LERP( LERP( front[0], front[1], fx ), LERP( front[2], front[3], fx ), fy );
+		bvalue = LERP( LERP( back[0], back[1], fx ), LERP( back[2], back[3], fx ), fy );
+
+		value[i] = LERP( fvalue, bvalue, fz );
+	}
+
+	finalvalue = LERP( value[0], value[1], ft );
+
+	return finalvalue;
+}
diff --git a/code/renderer/tr_public.h b/code/renderer/tr_public.h
new file mode 100644
index 0000000..1a82ca3
--- /dev/null
+++ b/code/renderer/tr_public.h
@@ -0,0 +1,147 @@
+#ifndef __TR_PUBLIC_H
+#define __TR_PUBLIC_H
+
+#include "tr_types.h"
+
+#ifdef _XBOX
+// Get font functions with default arguments that we need below
+#include "tr_font.h"
+#endif
+
+#define	REF_API_VERSION		9
+
+//
+// these are the functions exported by the refresh module
+//
+#ifdef _XBOX
+template <class T> class SPARC;
+#endif
+typedef struct {
+	// called before the library is unloaded
+	// if the system is just reconfiguring, pass destroyWindow = qfalse,
+	// which will keep the screen from flashing to the desktop.
+	void	(*Shutdown)( qboolean destroyWindow );
+
+	// All data that will be used in a level should be
+	// registered before rendering any frames to prevent disk hits,
+	// but they can still be registered at a later time
+	// if necessary.
+	//
+	// BeginRegistration makes any existing media pointers invalid
+	// and returns the current gl configuration, including screen width
+	// and height, which can be used by the client to intelligently
+	// size display elements
+	void	(*BeginRegistration)( glconfig_t *config );
+	qhandle_t (*RegisterModel)( const char *name );
+	qhandle_t (*RegisterSkin)( const char *name );
+	int		  (*GetAnimationCFG)(const char *psCFGFilename, char *psDest, int iDestSize);
+	qhandle_t (*RegisterShader)( const char *name );
+	qhandle_t (*RegisterShaderNoMip)( const char *name );
+	void	(*LoadWorld)( const char *name );
+
+	// these two functions added to help with the new model alloc scheme...
+	//
+	void	(*RegisterMedia_LevelLoadBegin)(const char *psMapName, ForceReload_e eForceReload, qboolean bAllowScreenDissolve);
+	void	(*RegisterMedia_LevelLoadEnd)(void);
+
+	// the vis data is a large enough block of data that we go to the trouble
+	// of sharing it with the clipmodel subsystem
+#ifdef _XBOX
+	void	(*SetWorldVisData)( SPARC<byte> *vis );
+#else
+	void	(*SetWorldVisData)( const byte *vis );
+#endif
+
+	// EndRegistration will draw a tiny polygon with each texture, forcing
+	// them to be loaded into card memory
+	void	(*EndRegistration)( void );
+
+	// a scene is built up by calls to R_ClearScene and the various R_Add functions.
+	// Nothing is drawn until R_RenderScene is called.
+	void	(*ClearScene)( void );
+	void	(*AddRefEntityToScene)( const refEntity_t *re );
+	void	(*AddPolyToScene)( qhandle_t hShader , int numVerts, const polyVert_t *verts );
+	void	(*AddLightToScene)( const vec3_t org, float intensity, float r, float g, float b );
+	void	(*RenderScene)( const refdef_t *fd );
+	qboolean(*GetLighting)( const vec3_t org, vec3_t ambientLight, vec3_t directedLight, vec3_t lightDir);
+
+	void	(*SetColor)( const float *rgba );	// NULL = 1,1,1,1
+	void	(*DrawStretchPic) ( float x, float y, float w, float h, 
+		float s1, float t1, float s2, float t2, qhandle_t hShader );	// 0 = white
+	void	(*DrawRotatePic) ( float x, float y, float w, float h, 
+		float s1, float t1, float s2, float t2, float a1, qhandle_t hShader );	// 0 = white
+	void	(*DrawRotatePic2) ( float x, float y, float w, float h, 
+		float s1, float t1, float s2, float t2, float a1, qhandle_t hShader );	// 0 = white
+	void	(*LAGoggles)(void);
+	void	(*Scissor) ( float x, float y, float w, float h);	// 0 = white
+
+	// Draw images for cinematic rendering, pass as 32 bit rgba
+	void	(*DrawStretchRaw) (int x, int y, int w, int h, int cols, int rows, const byte *data, int client, qboolean dirty);
+	void	(*UploadCinematic) (int cols, int rows, const byte *data, int client, qboolean dirty);
+
+	void	(*BeginFrame)( stereoFrame_t stereoFrame );
+
+	// if the pointers are not NULL, timing info will be returned
+	void	(*EndFrame)( int *frontEndMsec, int *backEndMsec );
+
+	qboolean (*ProcessDissolve)(void);
+	qboolean (*InitDissolve)(qboolean bForceCircularExtroWipe);
+
+
+	// for use with save-games mainly...
+	void	(*GetScreenShot)(byte *data, int w, int h);
+
+	// this is so you can get access to raw pixels from a graphics format (TGA/JPG/BMP etc), 
+	//	currently only the save game uses it (to make raw shots for the autosaves)
+	//
+	byte*	(*TempRawImage_ReadFromFile)(const char *psLocalFilename, int *piWidth, int *piHeight, byte *pbReSampleBuffer, qboolean qbVertFlip);
+	void	(*TempRawImage_CleanUp)();
+
+	//misc stuff
+	int		(*MarkFragments)( int numPoints, const vec3_t *points, const vec3_t projection,
+				   int maxPoints, vec3_t pointBuffer, int maxFragments, markFragment_t *fragmentBuffer );
+
+	//model stuff
+	void	(*LerpTag)( orientation_t *tag,  qhandle_t model, int startFrame, int endFrame, 
+					 float frac, const char *tagName );
+	void	(*ModelBounds)( qhandle_t model, vec3_t mins, vec3_t maxs );
+
+	void	(*GetLightStyle)(int style, color4ub_t color);
+	void	(*SetLightStyle)(int style, int color);
+
+	void	(*GetBModelVerts)( int bmodelIndex, vec3_t *vec, vec3_t normal );
+	void	(*WorldEffectCommand)(const char *command);
+
+	int		(*RegisterFont)(const char *name);
+#ifdef _XBOX	// No default arguments through function pointers.
+	int		Font_HeightPixels(const int index, const float scale = 1.0f)
+	{
+		return RE_Font_HeightPixels(index, scale);
+	}
+	int		Font_StrLenPixels(const char *s, const int index, const float scale = 1.0f)
+	{
+		return RE_Font_StrLenPixels(s, index, scale);
+	}
+	void	Font_DrawString(int x, int y, const char *s, const float *rgba, const int iFontHandle, int iMaxPixelWidth, const float scale = 1.0f)
+	{
+		return RE_Font_DrawString(x, y, s, rgba, iFontHandle, iMaxPixelWidth, scale);
+	}
+#else
+	int		(*Font_HeightPixels)(const int index, const float scale = 1.0f);
+	int		(*Font_StrLenPixels)(const char *s, const int index, const float scale = 1.0f);
+	void	(*Font_DrawString)(int x, int y, const char *s, const float *rgba, const int iFontHandle, int iMaxPixelWidth, const float scale = 1.0f);
+#endif
+	int		(*Font_StrLenChars) (const char *s);
+	qboolean (*Language_IsAsian) (void);
+	qboolean (*Language_UsesSpaces) (void);
+	unsigned int (*AnyLanguage_ReadCharFromString)( const char *psText, int * piAdvanceCount, qboolean *pbIsTrailingPunctuation /* = NULL */);
+
+} refexport_t;
+
+
+// this is the only function actually exported at the linker level
+// If the module can't init to a valid rendering state, NULL will be
+// returned.
+refexport_t*GetRefAPI( int apiVersion );
+
+#endif	// __TR_PUBLIC_H
diff --git a/code/renderer/tr_quicksprite.cpp b/code/renderer/tr_quicksprite.cpp
new file mode 100644
index 0000000..2e98924
--- /dev/null
+++ b/code/renderer/tr_quicksprite.cpp
@@ -0,0 +1,229 @@
+// tr_QuickSprite.cpp: implementation of the CQuickSpriteSystem class.
+//
+//////////////////////////////////////////////////////////////////////
+#include "../server/exe_headers.h"
+#include "tr_QuickSprite.h"
+
+extern void R_BindAnimatedImage( const textureBundle_t *bundle );
+
+
+//////////////////////////////////////////////////////////////////////
+// Singleton System
+//////////////////////////////////////////////////////////////////////
+CQuickSpriteSystem SQuickSprite;
+
+
+//////////////////////////////////////////////////////////////////////
+// Construction/Destruction
+//////////////////////////////////////////////////////////////////////
+
+CQuickSpriteSystem::CQuickSpriteSystem(void)
+{
+	int i;
+
+	for (i = 0; i < SHADER_MAX_VERTEXES; i += 4)
+	{
+		// Bottom right
+		mTextureCoords[i + 0][0] = 1.0;
+		mTextureCoords[i + 0][1] = 1.0;
+		// Top right
+		mTextureCoords[i + 1][0] = 1.0;
+		mTextureCoords[i + 1][1] = 0.0;
+		// Top left
+		mTextureCoords[i + 2][0] = 0.0;
+		mTextureCoords[i + 2][1] = 0.0;
+		// Bottom left
+		mTextureCoords[i + 3][0] = 0.0;
+		mTextureCoords[i + 3][1] = 1.0;
+	}
+}
+
+CQuickSpriteSystem::~CQuickSpriteSystem(void)
+{
+}
+
+void CQuickSpriteSystem::Flush(void)
+{
+	if (mNextVert==0)
+	{
+		return;
+	}
+
+	/*
+	if (mUseFog && r_drawfog->integer == 2 &&
+		mFogIndex == tr.world->globalFog)
+	{ //enable hardware fog when we draw this thing if applicable -rww
+		fog_t *fog = tr.world->fogs + mFogIndex;
+
+#ifdef _XBOX
+		qglFogi(GL_FOG_MODE, GL_EXP2);
+#else
+		qglFogf(GL_FOG_MODE, GL_EXP2);
+#endif
+		qglFogf(GL_FOG_DENSITY, logtestExp2 / fog->parms.depthForOpaque);
+		qglFogfv(GL_FOG_COLOR, fog->parms.color);
+		qglEnable(GL_FOG);
+	}
+	*/
+	//this should not be needed, since I just wait to disable fog for the surface til after surface sprites are done
+
+	//
+	// render the main pass
+	//
+	R_BindAnimatedImage( mTexBundle );
+	GL_State(mGLStateBits);
+
+	//
+	// set arrays and lock
+	//
+	qglEnableClientState( GL_TEXTURE_COORD_ARRAY);
+	qglTexCoordPointer( 2, GL_FLOAT, 0, mTextureCoords );
+
+	qglEnableClientState( GL_COLOR_ARRAY);
+	qglColorPointer( 4, GL_UNSIGNED_BYTE, 0, mColors );
+
+	qglVertexPointer (3, GL_FLOAT, 16, mVerts);
+
+	if ( qglLockArraysEXT )
+	{
+		qglLockArraysEXT(0, mNextVert);
+		GLimp_LogComment( "glLockArraysEXT\n" );
+	}
+
+	qglDrawArrays(GL_QUADS, 0, mNextVert);
+
+	backEnd.pc.c_vertexes += mNextVert;
+	backEnd.pc.c_indexes += mNextVert;
+	backEnd.pc.c_totalIndexes += mNextVert;
+
+	//only for software fog pass (global soft/volumetric) -rww
+	if (mUseFog && (r_drawfog->integer != 2 || mFogIndex != tr.world->globalFog))
+	{
+		fog_t *fog = tr.world->fogs + mFogIndex;
+
+		//
+		// render the fog pass
+		//
+		GL_Bind( tr.fogImage );
+		GL_State( GLS_SRCBLEND_SRC_ALPHA | GLS_DSTBLEND_ONE_MINUS_SRC_ALPHA | GLS_DEPTHFUNC_EQUAL );
+
+		//
+		// set arrays and lock
+		//
+		qglTexCoordPointer( 2, GL_FLOAT, 0, mFogTextureCoords);
+//		qglEnableClientState( GL_TEXTURE_COORD_ARRAY);	// Done above
+
+		qglDisableClientState( GL_COLOR_ARRAY );
+		qglColor4ubv((GLubyte *)&fog->colorInt);
+
+//		qglVertexPointer (3, GL_FLOAT, 16, mVerts);	// Done above
+
+		qglDrawArrays(GL_QUADS, 0, mNextVert);
+
+		// Second pass from fog
+		backEnd.pc.c_totalIndexes += mNextVert;
+	}
+
+	// 
+	// unlock arrays
+	//
+	if (qglUnlockArraysEXT) 
+	{
+		qglUnlockArraysEXT();
+		GLimp_LogComment( "glUnlockArraysEXT\n" );
+	}
+
+	mNextVert=0;
+}
+
+
+void CQuickSpriteSystem::StartGroup(textureBundle_t *bundle, unsigned long glbits, int fogIndex )
+{
+	mNextVert = 0;
+
+	mTexBundle = bundle;
+	mGLStateBits = glbits;
+	if (fogIndex != -1)
+	{
+		mUseFog = qtrue;
+		mFogIndex = fogIndex;
+	}
+	else
+	{
+		mUseFog = qfalse;
+	}
+
+	int cullingOn;
+	qglGetIntegerv(GL_CULL_FACE,&cullingOn);
+
+	if(cullingOn)
+	{
+		mTurnCullBackOn=true;
+	}
+	else
+	{
+		mTurnCullBackOn=false;
+	}
+	qglDisable(GL_CULL_FACE);
+}
+
+
+void CQuickSpriteSystem::EndGroup(void)
+{
+	Flush();
+
+	qglColor4ub(255,255,255,255);
+	if(mTurnCullBackOn)
+	{
+		qglEnable(GL_CULL_FACE);
+	}
+}
+
+
+
+
+void CQuickSpriteSystem::Add(float *pointdata, color4ub_t color, vec2_t fog)
+{
+	float *curcoord;
+	float *curfogtexcoord;
+	unsigned long *curcolor;
+
+	if (mNextVert>SHADER_MAX_VERTEXES-4)
+	{
+		Flush();
+	}
+
+	curcoord = mVerts[mNextVert];
+	memcpy(curcoord, pointdata, 4*sizeof(vec4_t));
+
+	// Set up color
+	curcolor = &mColors[mNextVert];
+	*curcolor++ = *(unsigned long *)color;
+	*curcolor++ = *(unsigned long *)color;
+	*curcolor++ = *(unsigned long *)color;
+	*curcolor++ = *(unsigned long *)color;
+
+	if (fog)
+	{
+		curfogtexcoord = &mFogTextureCoords[mNextVert][0];
+		*curfogtexcoord++ = fog[0];
+		*curfogtexcoord++ = fog[1];
+
+		*curfogtexcoord++ = fog[0];
+		*curfogtexcoord++ = fog[1];
+
+		*curfogtexcoord++ = fog[0];
+		*curfogtexcoord++ = fog[1];
+
+		*curfogtexcoord++ = fog[0];
+		*curfogtexcoord++ = fog[1];
+
+		mUseFog=qtrue;
+	}
+	else
+	{
+		mUseFog=qfalse;
+	}
+
+	mNextVert+=4;
+}
diff --git a/code/renderer/tr_quicksprite.h b/code/renderer/tr_quicksprite.h
new file mode 100644
index 0000000..ab3c557
--- /dev/null
+++ b/code/renderer/tr_quicksprite.h
@@ -0,0 +1,48 @@
+// this include must remain at the top of every CPP file
+//#include "../game/q_math.h"
+#include "tr_local.h"
+
+// tr_QuickSprite.h: interface for the CQuickSprite class.
+//
+//////////////////////////////////////////////////////////////////////
+
+#if !defined(AFX_TR_QUICKSPRITE_H__6F05EB85_A1ED_4537_9EC0_9F5D82A5D99A__INCLUDED_)
+#define AFX_TR_QUICKSPRITE_H__6F05EB85_A1ED_4537_9EC0_9F5D82A5D99A__INCLUDED_
+
+#if _MSC_VER > 1000
+#pragma once
+#endif // _MSC_VER > 1000
+
+class CQuickSpriteSystem
+{
+private:
+			textureBundle_t	*mTexBundle;
+			unsigned long	mGLStateBits;
+			int				mFogIndex;
+			qboolean		mUseFog;
+			vec4_t			mVerts[SHADER_MAX_VERTEXES];
+			unsigned int	mIndexes[SHADER_MAX_VERTEXES];			// Ideally this would be static, cause it never changes
+			vec2_t			mTextureCoords[SHADER_MAX_VERTEXES];	// Ideally this would be static, cause it never changes
+			vec2_t			mFogTextureCoords[SHADER_MAX_VERTEXES];
+			unsigned long	mColors[SHADER_MAX_VERTEXES];
+			int				mNextVert;
+			qboolean		mTurnCullBackOn;
+
+			void Flush(void);
+
+public:
+			CQuickSpriteSystem(void);
+			~CQuickSpriteSystem(void);
+
+			void StartGroup(textureBundle_t *bundle, unsigned long glbits, int fogIndex = -1);
+			void EndGroup(void);
+
+			void Add(float *pointdata, color4ub_t color, vec2_t fog=NULL);
+};
+
+extern CQuickSpriteSystem SQuickSprite;
+
+
+#endif // !defined(AFX_TR_QUICKSPRITE_H__6F05EB85_A1ED_4537_9EC0_9F5D82A5D99A__INCLUDED_)
+
+
diff --git a/code/renderer/tr_scene.cpp b/code/renderer/tr_scene.cpp
new file mode 100644
index 0000000..96a096d
--- /dev/null
+++ b/code/renderer/tr_scene.cpp
@@ -0,0 +1,402 @@
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+
+
+#include "tr_local.h"
+
+#ifdef VV_LIGHTING
+#include "tr_lightmanager.h"
+#endif
+
+int			r_firstSceneDrawSurf;
+
+int			r_numdlights;
+int			r_firstSceneDlight;
+
+int			r_numentities;
+int			r_firstSceneEntity;
+
+int			r_numpolys;
+int			r_firstScenePoly;
+
+int			r_numpolyverts;
+
+int			skyboxportal;
+int			drawskyboxportal;
+
+/*
+====================
+R_ToggleSmpFrame
+
+====================
+*/
+void R_ToggleSmpFrame( void ) {
+
+	backEndData->commands.used = 0;
+
+	r_firstSceneDrawSurf = 0;
+
+	r_numdlights = 0;
+	r_firstSceneDlight = 0;
+
+#ifdef VV_LIGHTING
+	VVLightMan.num_dlights = 0;
+#endif
+
+	r_numentities = 0;
+	r_firstSceneEntity = 0;
+
+	r_numpolys = 0;
+	r_firstScenePoly = 0;
+
+	r_numpolyverts = 0;
+}
+
+
+/*
+====================
+RE_ClearScene
+
+====================
+*/
+void RE_ClearScene( void ) {
+	r_firstSceneDlight = r_numdlights;
+	r_firstSceneEntity = r_numentities;
+	r_firstScenePoly = r_numpolys;
+	tr.refdef.rdflags &= ~(RDF_doLAGoggles|RDF_doFullbright);	//probably not needed since it gets copied over in RE_RenderScene
+}
+
+/*
+===========================================================================
+
+DISCRETE POLYS
+
+===========================================================================
+*/
+
+/*
+=====================
+R_AddPolygonSurfaces
+
+Adds all the scene's polys into this view's drawsurf list
+=====================
+*/
+void R_AddPolygonSurfaces( void ) {
+	int			i;
+	shader_t	*sh;
+	srfPoly_t	*poly;
+
+	tr.currentEntityNum = TR_WORLDENT;
+	tr.shiftedEntityNum = tr.currentEntityNum << QSORT_ENTITYNUM_SHIFT;
+
+	for ( i = 0, poly = tr.refdef.polys; i < tr.refdef.numPolys ; i++, poly++ ) {
+		sh = R_GetShaderByHandle( poly->hShader );
+		R_AddDrawSurf( ( surfaceType_t * )poly, sh, poly->fogIndex, qfalse );
+	}
+}
+
+/*
+=====================
+RE_AddPolyToScene
+
+=====================
+*/
+void RE_AddPolyToScene( qhandle_t hShader , int numVerts, const polyVert_t *verts ) {
+	srfPoly_t	*poly;
+	int			i;
+	int			fogIndex = 0;
+	fog_t		*fog;
+	vec3_t		bounds[2];
+
+	if ( !tr.registered ) {
+		return;
+	}
+
+	if ( !hShader ) {
+#ifndef FINAL_BUILD
+		VID_Printf( PRINT_WARNING, "WARNING: RE_AddPolyToScene: NULL poly shader\n");
+#endif
+		return;
+	}
+
+	if ( r_numpolyverts + numVerts > MAX_POLYVERTS || r_numpolys >= MAX_POLYS ) {
+#if defined(_DEBUG)
+		Com_Printf(S_COLOR_RED"Poly overflow!  Tell Brian.\n");
+#endif
+		return;
+	}
+
+	poly = &backEndData->polys[r_numpolys];
+	poly->surfaceType = SF_POLY;
+	poly->hShader = hShader;
+	poly->numVerts = numVerts;
+	poly->verts = &backEndData->polyVerts[r_numpolyverts];
+	
+	memcpy( poly->verts, verts, numVerts * sizeof( *verts ) );
+	r_numpolys++;
+	r_numpolyverts += numVerts;
+
+	// see if it is in a fog volume
+	if ( !tr.world || tr.world->numfogs == 1) {
+		fogIndex = 0;
+	} else {
+		// find which fog volume the poly is in
+		VectorCopy( poly->verts[0].xyz, bounds[0] );
+		VectorCopy( poly->verts[0].xyz, bounds[1] );
+		for ( i = 1 ; i < poly->numVerts ; i++ ) {
+			AddPointToBounds( poly->verts[i].xyz, bounds[0], bounds[1] );
+		}
+		for ( int fI = 1 ; fI < tr.world->numfogs ; fI++ ) {
+			fog = &tr.world->fogs[fI]; 
+			if ( bounds[0][0] >= fog->bounds[0][0]
+				&& bounds[0][1] >= fog->bounds[0][1]
+				&& bounds[0][2] >= fog->bounds[0][2]
+				&& bounds[1][0] <= fog->bounds[1][0]
+				&& bounds[1][1] <= fog->bounds[1][1]
+				&& bounds[1][2] <= fog->bounds[1][2] ) 
+			{//completely in this one
+				fogIndex = fI;
+				break;
+			}
+			else if ( ( bounds[0][0] >= fog->bounds[0][0] && bounds[0][1] >= fog->bounds[0][1] && bounds[0][2] >= fog->bounds[0][2] &&
+						bounds[0][0] <= fog->bounds[1][0] && bounds[0][1] <= fog->bounds[1][1] && bounds[0][2] <= fog->bounds[1][2]) ||
+				( bounds[1][0] >= fog->bounds[0][0] && bounds[1][1] >= fog->bounds[0][1] && bounds[1][2] >= fog->bounds[0][2] &&
+					bounds[1][0] <= fog->bounds[1][0] && bounds[1][1] <= fog->bounds[1][1] && bounds[1][2] <= fog->bounds[1][2] ) ) 
+			{//partially in this one
+				if ( tr.refdef.fogIndex == fI || R_FogParmsMatch( tr.refdef.fogIndex, fI ) )
+				{//take new one only if it's the same one that the viewpoint is in
+					fogIndex = fI;
+					break;
+				}
+				else if ( !fogIndex )
+				{//didn't find one yet, so use this one
+					fogIndex = fI;
+				}
+			}
+		}
+	}
+	poly->fogIndex = fogIndex;
+}
+
+
+//=================================================================================
+
+
+/*
+=====================
+RE_AddRefEntityToScene
+
+=====================
+*/
+void RE_AddRefEntityToScene( const refEntity_t *ent ) {
+	if ( !tr.registered ) {
+		return;
+	}
+	if ( r_numentities >= TR_WORLDENT ) {
+#ifndef FINAL_BUILD
+		VID_Printf( PRINT_WARNING, "WARNING: RE_AddRefEntityToScene: too many entities\n");
+#endif
+		return;
+	}
+	if ( ent->reType < 0 || ent->reType >= RT_MAX_REF_ENTITY_TYPE ) {
+		Com_Error( ERR_DROP, "RE_AddRefEntityToScene: bad reType %i", ent->reType );
+	}
+
+	backEndData->entities[r_numentities].e = *ent;
+	backEndData->entities[r_numentities].lightingCalculated = qfalse;
+
+	r_numentities++;
+}
+
+
+/*
+=====================
+RE_AddLightToScene
+
+=====================
+*/
+void RE_AddLightToScene( const vec3_t org, float intensity, float r, float g, float b ) {
+#ifndef VV_LIGHTING
+	dlight_t	*dl;
+
+	if ( !tr.registered ) {
+		return;
+	}
+	if ( r_numdlights >= MAX_DLIGHTS ) {
+		return;
+	}
+	if ( intensity <= 0 ) {
+		return;
+	}
+	dl = &backEndData->dlights[r_numdlights++];
+	VectorCopy (org, dl->origin);
+	dl->radius = intensity;
+	dl->color[0] = r;
+	dl->color[1] = g;
+	dl->color[2] = b;
+#endif // VV_LIGHTING
+}
+
+
+/*
+@@@@@@@@@@@@@@@@@@@@@
+RE_RenderScene
+
+Draw a 3D view into a part of the window, then return
+to 2D drawing.
+
+Rendering a scene may require multiple views to be rendered
+to handle mirrors,
+@@@@@@@@@@@@@@@@@@@@@
+*/
+extern int	recursivePortalCount;
+void RE_RenderScene( const refdef_t *fd ) {
+	viewParms_t		parms;
+	int				startTime;
+	static int		lastTime = 0;
+
+	if ( !tr.registered ) {
+		return;
+	}
+	GLimp_LogComment( "====== RE_RenderScene =====\n" );
+
+	if ( r_norefresh->integer ) {
+		return;
+	}
+
+	startTime = Sys_Milliseconds();
+
+	if (!tr.world && !( fd->rdflags & RDF_NOWORLDMODEL ) ) {
+		Com_Error (ERR_DROP, "R_RenderScene: NULL worldmodel");
+	}
+
+//	memcpy( tr.refdef.text, fd->text, sizeof( tr.refdef.text ) );
+
+	tr.refdef.x = fd->x;
+	tr.refdef.y = fd->y;
+	tr.refdef.width = fd->width;
+	tr.refdef.height = fd->height;
+	tr.refdef.fov_x = fd->fov_x;
+	tr.refdef.fov_y = fd->fov_y;
+
+	VectorCopy( fd->vieworg, tr.refdef.vieworg );
+	VectorCopy( fd->viewaxis[0], tr.refdef.viewaxis[0] );
+	VectorCopy( fd->viewaxis[1], tr.refdef.viewaxis[1] );
+	VectorCopy( fd->viewaxis[2], tr.refdef.viewaxis[2] );
+
+	tr.refdef.time = fd->time;
+	tr.refdef.frametime = fd->time - lastTime;
+	tr.refdef.rdflags = fd->rdflags;
+
+	if (fd->rdflags & RDF_SKYBOXPORTAL)
+	{
+		skyboxportal = 1;
+	}
+	else
+	{
+		// cdr - only change last time for the real render, not the portal
+		lastTime = fd->time;
+	}
+
+	if (fd->rdflags & RDF_DRAWSKYBOX)
+	{
+		drawskyboxportal = 1;
+	}
+	else
+	{
+		drawskyboxportal = 0;
+	}
+
+	// copy the areamask data over and note if it has changed, which
+	// will force a reset of the visible leafs even if the view hasn't moved
+	tr.refdef.areamaskModified = qfalse;
+	if ( ! (tr.refdef.rdflags & RDF_NOWORLDMODEL) ) {
+		int		areaDiff;
+		int		i;
+
+		// compare the area bits
+		areaDiff = 0;
+		for (i = 0 ; i < MAX_MAP_AREA_BYTES/4 ; i++) {
+			areaDiff |= ((int *)tr.refdef.areamask)[i] ^ ((int *)fd->areamask)[i];
+			((int *)tr.refdef.areamask)[i] = ((int *)fd->areamask)[i];
+		}
+
+		if ( areaDiff ) {
+			// a door just opened or something
+			tr.refdef.areamaskModified = qtrue;
+		}
+	}
+
+
+	// derived info
+
+	tr.refdef.floatTime = tr.refdef.time * 0.001;
+
+	tr.refdef.numDrawSurfs = r_firstSceneDrawSurf;
+	tr.refdef.drawSurfs = backEndData->drawSurfs;
+
+	tr.refdef.num_entities = r_numentities - r_firstSceneEntity;
+	tr.refdef.entities = &backEndData->entities[r_firstSceneEntity];
+
+#ifndef VV_LIGHTING
+	tr.refdef.num_dlights = r_numdlights - r_firstSceneDlight;
+	tr.refdef.dlights = &backEndData->dlights[r_firstSceneDlight];
+#endif
+
+	tr.refdef.numPolys = r_numpolys - r_firstScenePoly;
+	tr.refdef.polys = &backEndData->polys[r_firstScenePoly];
+
+	// turn off dynamic lighting globally by clearing all the
+	// dlights if it needs to be disabled or if vertex lighting is enabled
+#ifndef VV_LIGHTING
+	if ( r_dynamiclight->integer == 0 ||
+		 r_vertexLight->integer == 1 ) {
+		tr.refdef.num_dlights = 0;
+	}
+#endif
+
+	// a single frame may have multiple scenes draw inside it --
+	// a 3D game view, 3D status bar renderings, 3D menus, etc.
+	// They need to be distinguished by the light flare code, because
+	// the visibility state for a given surface may be different in
+	// each scene / view.
+	tr.frameSceneNum++;
+	tr.sceneCount++;
+
+	// setup view parms for the initial view
+	//
+	// set up viewport
+	// The refdef takes 0-at-the-top y coordinates, so
+	// convert to GL's 0-at-the-bottom space
+	//
+	memset( &parms, 0, sizeof( parms ) );
+	parms.viewportX = tr.refdef.x;
+	parms.viewportY = glConfig.vidHeight - ( tr.refdef.y + tr.refdef.height );
+	parms.viewportWidth = tr.refdef.width;
+	parms.viewportHeight = tr.refdef.height;
+	parms.isPortal = qfalse;
+
+	parms.fovX = tr.refdef.fov_x;
+	parms.fovY = tr.refdef.fov_y;
+
+	VectorCopy( fd->vieworg, parms.or.origin );
+	VectorCopy( fd->viewaxis[0], parms.or.axis[0] );
+	VectorCopy( fd->viewaxis[1], parms.or.axis[1] );
+	VectorCopy( fd->viewaxis[2], parms.or.axis[2] );
+
+	VectorCopy( fd->vieworg, parms.pvsOrigin );
+
+	recursivePortalCount = 0;
+	R_RenderView( &parms );
+
+	// the next scene rendered in this frame will tack on after this one
+	r_firstSceneDrawSurf = tr.refdef.numDrawSurfs;
+	r_firstSceneEntity = r_numentities;
+	r_firstSceneDlight = r_numdlights;
+	r_firstScenePoly = r_numpolys;
+
+	tr.frontEndMsec += Sys_Milliseconds() - startTime;
+	RE_RenderWorldEffects();
+}
diff --git a/code/renderer/tr_shade.cpp b/code/renderer/tr_shade.cpp
new file mode 100644
index 0000000..63ae917
--- /dev/null
+++ b/code/renderer/tr_shade.cpp
@@ -0,0 +1,2776 @@
+// tr_shade.c
+
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+#include "tr_local.h"
+
+#ifdef VV_LIGHTING
+#include "tr_lightmanager.h"
+#include "../win32/glw_win_dx8.h"
+#include "../win32/win_lighteffects.h"
+#endif
+
+/*
+
+  THIS ENTIRE FILE IS BACK END
+
+  This file deals with applying shaders to surface data in the tess struct.
+*/
+
+shaderCommands_t	tess;
+static qboolean	setArraysOnce;
+
+color4ub_t	styleColors[MAX_LIGHT_STYLES];
+bool		styleUpdated[MAX_LIGHT_STYLES];
+
+extern bool g_bRenderGlowingObjects;
+
+/*
+================
+R_ArrayElementDiscrete
+
+This is just for OpenGL conformance testing, it should never be the fastest
+================
+*/
+static void APIENTRY R_ArrayElementDiscrete( GLint index ) {
+#ifndef _XBOX
+	qglColor4ubv( tess.svars.colors[ index ] );
+	if ( glState.currenttmu ) {
+		qglMultiTexCoord2fARB( 0, tess.svars.texcoords[ 0 ][ index ][0], tess.svars.texcoords[ 0 ][ index ][1] );
+		qglMultiTexCoord2fARB( 1, tess.svars.texcoords[ 1 ][ index ][0], tess.svars.texcoords[ 1 ][ index ][1] );
+	} else {
+		qglTexCoord2fv( tess.svars.texcoords[ 0 ][ index ] );
+	}
+	qglVertex3fv( tess.xyz[ index ] );
+#endif
+}
+
+/*
+===================
+R_DrawStripElements
+
+===================
+*/
+static int		c_vertexes;		// for seeing how long our average strips are
+static int		c_begins;
+static void R_DrawStripElements( int numIndexes, const glIndex_t *indexes, void ( APIENTRY *element )(GLint) ) {
+	int i;
+	glIndex_t last[3];
+	qboolean even;
+
+	qglBegin( GL_TRIANGLE_STRIP );
+	c_begins++;
+
+	if ( numIndexes <= 0 ) {
+		return;
+	}
+
+	// prime the strip
+	element( indexes[0] );
+	element( indexes[1] );
+	element( indexes[2] );
+	c_vertexes += 3;
+
+	last[0] = indexes[0];
+	last[1] = indexes[1];
+	last[2] = indexes[2];
+
+	even = qfalse;
+
+	for ( i = 3; i < numIndexes; i += 3 )
+	{
+		// odd numbered triangle in potential strip
+		if ( !even )
+		{
+			// check previous triangle to see if we're continuing a strip
+			if ( ( indexes[i+0] == last[2] ) && ( indexes[i+1] == last[1] ) )
+			{
+				element( indexes[i+2] );
+				c_vertexes++;
+				assert( indexes[i+2] < tess.numVertexes );
+				even = qtrue;
+			}
+			// otherwise we're done with this strip so finish it and start
+			// a new one
+			else
+			{
+				qglEnd();
+
+				qglBegin( GL_TRIANGLE_STRIP );
+				c_begins++;
+
+				element( indexes[i+0] );
+				element( indexes[i+1] );
+				element( indexes[i+2] );
+
+				c_vertexes += 3;
+
+				even = qfalse;
+			}
+		}
+		else
+		{
+			// check previous triangle to see if we're continuing a strip
+			if ( ( last[2] == indexes[i+1] ) && ( last[0] == indexes[i+0] ) )
+			{
+				element( indexes[i+2] );
+				c_vertexes++;
+
+				even = qfalse;
+			}
+			// otherwise we're done with this strip so finish it and start
+			// a new one
+			else
+			{
+				qglEnd();
+
+				qglBegin( GL_TRIANGLE_STRIP );
+				c_begins++;
+
+				element( indexes[i+0] );
+				element( indexes[i+1] );
+				element( indexes[i+2] );
+				c_vertexes += 3;
+
+				even = qfalse;
+			}
+		}
+
+		// cache the last three vertices
+		last[0] = indexes[i+0];
+		last[1] = indexes[i+1];
+		last[2] = indexes[i+2];
+	}
+
+	qglEnd();
+}
+
+#ifdef _XBOX
+qboolean RB_IsCurrentShaderTransparent( void );
+#endif
+
+/*
+==================
+R_DrawElements
+
+Optionally performs our own glDrawElements that looks for strip conditions
+instead of using the single glDrawElements call that may be inefficient
+without compiled vertex arrays.
+==================
+*/
+static void R_DrawElements( int numIndexes, const glIndex_t *indexes ) {
+	int		primitives;
+
+	primitives = r_primitives->integer;
+
+	// default is to use triangles if compiled vertex arrays are present
+	if ( primitives == 0 ) {
+		if ( qglLockArraysEXT ) {
+			primitives = 2;
+		} else {
+			primitives = 1;
+		}
+	}
+
+
+	if ( primitives == 2 ) {
+#ifdef _XBOX
+//		if (tess.useConstantColor)
+//		{
+//			qglDisableClientState( GL_COLOR_ARRAY );
+//			qglColor4ubv( tess.constantColor );
+//		}
+#endif
+		qglDrawElements( GL_TRIANGLES, 
+						numIndexes,
+						GL_INDEX_TYPE,
+						indexes );
+		return;
+	}
+
+#ifdef _XBOX
+	if (primitives == 1 || primitives == 3)
+	{
+//		if (tess.useConstantColor)
+//		{
+//			qglDisableClientState( GL_COLOR_ARRAY );
+//			qglColor4ubv( tess.constantColor );
+//		}
+		/*qglDrawElements( GL_TRIANGLES, 
+						numIndexes,
+						GL_INDEX_TYPE,
+						indexes );*/
+#if 1	// VVFIXME : Temporary solution to try and increase framerate
+		//qglIndexedTriToStrip( numIndexes, indexes );
+
+		qglDrawElements( GL_TRIANGLES, 
+						numIndexes,
+						GL_INDEX_TYPE,
+						indexes );
+#endif
+	
+		return;
+	}
+#else // _XBOX
+	if ( primitives == 1 ) {
+		R_DrawStripElements( numIndexes,  indexes, qglArrayElement );
+		return;
+	}
+
+	if ( primitives == 3 ) {
+		R_DrawStripElements( numIndexes,  indexes, R_ArrayElementDiscrete );
+		return;
+	}
+#endif // _XBOX
+
+	// anything else will cause no drawing
+}
+
+
+
+
+
+/*
+=============================================================
+
+SURFACE SHADERS
+
+=============================================================
+*/
+
+
+/*
+=================
+R_BindAnimatedImage
+
+=================
+*/
+void R_BindAnimatedImage( const textureBundle_t *bundle) {
+	int		index;
+
+	if ( bundle->isVideoMap ) {
+		CIN_RunCinematic(bundle->videoMapHandle);
+		CIN_UploadCinematic(bundle->videoMapHandle);
+		return;
+	}
+
+	if ((r_fullbright->integer || (tr.refdef.rdflags & RDF_doFullbright) ) && bundle->isLightmap)
+	{
+		GL_Bind( tr.whiteImage );
+		return;
+	}
+
+	if ( bundle->numImageAnimations <= 1 ) {
+		GL_Bind( bundle->image );
+		return;
+	}
+	
+	if (backEnd.currentEntity->e.renderfx & RF_SETANIMINDEX )
+	{
+		index = backEnd.currentEntity->e.skinNum;
+	}
+	else
+	{
+		// it is necessary to do this messy calc to make sure animations line up
+		// exactly with waveforms of the same frequency
+		index = myftol( backEnd.refdef.floatTime * bundle->imageAnimationSpeed * FUNCTABLE_SIZE );
+		index >>= FUNCTABLE_SIZE2;
+		
+		if ( index < 0 ) {
+			index = 0;	// may happen with shader time offsets
+		}
+	}
+
+	if ( bundle->oneShotAnimMap )
+	{
+		if ( index >= bundle->numImageAnimations )
+		{
+			// stick on last frame
+			index = bundle->numImageAnimations - 1;
+		}
+	}
+	else
+	{
+		// loop
+		index %= bundle->numImageAnimations;
+	}
+
+	GL_Bind( *((image_t**)bundle->image + index) );
+}
+
+
+/*
+================
+DrawTris
+
+Draws triangle outlines for debugging
+================
+*/
+static void DrawTris (shaderCommands_t *input) 
+{
+	GL_Bind( tr.whiteImage );
+
+	if ( r_showtriscolor->integer )
+	{
+		int i = r_showtriscolor->integer;
+		if (i == 42) {
+			i = Q_irand(0,8);
+		}
+		switch (i)
+		{
+		case 1:
+			qglColor3f( 1.0, 0.0, 0.0); //red
+			break;
+		case 2:
+			qglColor3f( 0.0, 1.0, 0.0); //green
+			break;
+		case 3:
+			qglColor3f( 1.0, 1.0, 0.0); //yellow
+			break;
+		case 4:
+			qglColor3f( 0.0, 0.0, 1.0); //blue
+			break;
+		case 5:
+			qglColor3f( 0.0, 1.0, 1.0); //cyan
+			break;
+		case 6:
+			qglColor3f( 1.0, 0.0, 1.0); //magenta
+			break;
+		case 7:
+			qglColor3f( 0.8f, 0.8f, 0.8f); //white/grey
+			break;
+		case 8:
+			qglColor3f( 0.0, 0.0, 0.0); //black
+			break;
+		}		
+	}
+	else
+	{
+		qglColor3f( 1.0, 1.0, 1.0); //white
+	}
+
+	if ( r_showtris->integer == 2 )
+	{
+		// tries to do non-xray style showtris
+		GL_State( GLS_POLYMODE_LINE );
+
+		qglEnable( GL_POLYGON_OFFSET_LINE );
+		qglPolygonOffset( -1, -2 );
+
+		qglDisableClientState( GL_COLOR_ARRAY );
+		qglDisableClientState( GL_TEXTURE_COORD_ARRAY );
+
+		qglVertexPointer( 3, GL_FLOAT, 16, input->xyz );	// padded for SIMD
+
+		if ( qglLockArraysEXT ) 
+		{
+			qglLockArraysEXT( 0, input->numVertexes );
+			GLimp_LogComment( "glLockArraysEXT\n" );
+		}
+
+		R_DrawElements( input->numIndexes, input->indexes );
+
+		if ( qglUnlockArraysEXT ) 
+		{
+			qglUnlockArraysEXT( );
+			GLimp_LogComment( "glUnlockArraysEXT\n" );
+		}
+
+		qglDisable( GL_POLYGON_OFFSET_LINE );
+	}
+	else
+	{
+		// same old showtris
+		GL_State( GLS_POLYMODE_LINE | GLS_DEPTHMASK_TRUE );
+		qglDepthRange( 0, 0 );
+
+		qglDisableClientState (GL_COLOR_ARRAY);
+		qglDisableClientState (GL_TEXTURE_COORD_ARRAY);
+
+		qglVertexPointer (3, GL_FLOAT, 16, input->xyz);	// padded for SIMD
+
+		if (qglLockArraysEXT) {
+			qglLockArraysEXT(0, input->numVertexes);
+			GLimp_LogComment( "glLockArraysEXT\n" );
+		}
+
+		R_DrawElements( input->numIndexes, input->indexes );
+
+		if (qglUnlockArraysEXT) {
+			qglUnlockArraysEXT();
+			GLimp_LogComment( "glUnlockArraysEXT\n" );
+		}
+
+		qglDepthRange( 0, 1 );
+	}
+}
+
+/*
+================
+DrawNormals
+
+Draws vertex normals for debugging
+================
+*/
+static void DrawNormals (shaderCommands_t *input) {
+	int		i;
+	vec3_t	temp;
+
+	GL_Bind( tr.whiteImage );
+	qglColor3f (1,1,1);
+	qglDepthRange( 0, 0 );	// never occluded
+	GL_State( GLS_POLYMODE_LINE | GLS_DEPTHMASK_TRUE );
+
+	qglBegin (GL_LINES);
+	for (i = 0 ; i < input->numVertexes ; i++) {
+		qglVertex3fv (input->xyz[i]);
+		VectorMA (input->xyz[i], 2, input->normal[i], temp);
+		qglVertex3fv (temp);
+	}
+	qglEnd ();
+
+	qglDepthRange( 0, 1 );
+}
+
+
+/*
+==============
+RB_BeginSurface
+
+We must set some things up before beginning any tesselation,
+because a surface may be forced to perform a RB_End due
+to overflow.
+==============
+*/
+void RB_BeginSurface( shader_t *shader, int fogNum ) {
+//	shader_t *state = (shader->remappedShader) ? shader->remappedShader : shader;
+	shader_t *state = shader;
+
+	tess.numIndexes = 0;
+	tess.numVertexes = 0;
+	tess.shader = state;//shader;
+	tess.fogNum = fogNum;
+	tess.dlightBits = 0;		// will be OR'd in by surface functions
+
+	tess.SSInitializedWind = qfalse;	//is this right?
+
+	tess.xstages = state->stages;
+	tess.numPasses = state->numUnfoggedPasses;
+	
+	tess.currentStageIteratorFunc = shader->sky ? RB_StageIteratorSky : RB_StageIteratorGeneric;
+
+	tess.fading = false;
+
+#ifdef _XBOX
+	tess.setTangents = false;
+#endif
+
+	tess.registration++;
+}
+
+/*
+===================
+DrawMultitextured
+
+output = t0 * t1 or t0 + t1
+
+t0 = most upstream according to spec
+t1 = most downstream according to spec
+===================
+*/
+static void DrawMultitextured( shaderCommands_t *input, int stage ) {
+	shaderStage_t	*pStage;
+
+	pStage = &tess.xstages[stage];
+
+	GL_State( pStage->stateBits );
+
+	//
+	// base
+	//
+	GL_SelectTexture( 0 );
+	qglTexCoordPointer( 2, GL_FLOAT, 0, input->svars.texcoords[0] );
+	R_BindAnimatedImage( &pStage->bundle[0] );
+
+	//
+	// lightmap/secondary pass
+	//
+	GL_SelectTexture( 1 );
+	qglEnable( GL_TEXTURE_2D );
+	qglEnableClientState( GL_TEXTURE_COORD_ARRAY );
+
+	if ( r_lightmap->integer ) {
+		GL_TexEnv( GL_REPLACE );
+	} else {
+		GL_TexEnv( tess.shader->multitextureEnv ); 
+	}
+
+	qglTexCoordPointer( 2, GL_FLOAT, 0, input->svars.texcoords[1] );
+
+	R_BindAnimatedImage( &pStage->bundle[1] );
+
+	R_DrawElements( input->numIndexes, input->indexes );
+
+	//
+	// disable texturing on TEXTURE1, then select TEXTURE0
+	//
+	qglDisable( GL_TEXTURE_2D );
+#ifdef _XBOX
+	qglDisableClientState( GL_TEXTURE_COORD_ARRAY );
+#endif
+
+	GL_SelectTexture( 0 );
+}
+
+
+#ifdef VV_LIGHTING
+static void BuildTangentVectors( void ) {
+
+	memset(tess.tangent, 0, sizeof(vec4_t) * SHADER_MAX_VERTEXES);
+
+	for(int i = 0; i < tess.numIndexes; i += 3)
+	{
+		vec3_t vec1, vec2, du, dv, cp;
+
+		vec1[0] = tess.xyz[tess.indexes[i+1]][0] - tess.xyz[tess.indexes[i]][0];
+		vec1[1] = tess.svars.texcoords[0][tess.indexes[i+1]][0] - tess.svars.texcoords[0][tess.indexes[i]][0];
+		vec1[2] = tess.svars.texcoords[0][tess.indexes[i+1]][1] - tess.svars.texcoords[0][tess.indexes[i]][1];
+
+		vec2[0] = tess.xyz[tess.indexes[i+2]][0] - tess.xyz[tess.indexes[i]][0];
+		vec2[1] = tess.svars.texcoords[0][tess.indexes[i+2]][0] - tess.svars.texcoords[0][tess.indexes[i]][0];
+		vec2[2] = tess.svars.texcoords[0][tess.indexes[i+2]][1] - tess.svars.texcoords[0][tess.indexes[i]][1];
+
+		CrossProduct(vec1, vec2, cp);
+
+		if(cp[0] == 0.0f)
+			cp[0] = 0.001f;
+
+		du[0] = -cp[1] / cp[0];
+		dv[0] = -cp[2] / cp[0];
+
+		vec1[0] = tess.xyz[tess.indexes[i+1]][1] - tess.xyz[tess.indexes[i]][1];
+		vec1[1] = tess.svars.texcoords[0][tess.indexes[i+1]][0] - tess.svars.texcoords[0][tess.indexes[i]][0];
+		vec1[2] = tess.svars.texcoords[0][tess.indexes[i+1]][1] - tess.svars.texcoords[0][tess.indexes[i]][1];
+
+		vec2[0] = tess.xyz[tess.indexes[i+2]][1] - tess.xyz[tess.indexes[i]][1];
+		vec2[1] = tess.svars.texcoords[0][tess.indexes[i+2]][0] - tess.svars.texcoords[0][tess.indexes[i]][0];
+		vec2[2] = tess.svars.texcoords[0][tess.indexes[i+2]][1] - tess.svars.texcoords[0][tess.indexes[i]][1];
+
+		CrossProduct(vec1, vec2, cp);
+
+		if(cp[0] == 0.0f)
+			cp[0] = 0.001f;
+
+		du[1] = -cp[1] / cp[0];
+		dv[1] = -cp[2] / cp[0];
+
+		vec1[0] = tess.xyz[tess.indexes[i+1]][2] - tess.xyz[tess.indexes[i]][2];
+		vec1[1] = tess.svars.texcoords[0][tess.indexes[i+1]][0] - tess.svars.texcoords[0][tess.indexes[i]][0];
+		vec1[2] = tess.svars.texcoords[0][tess.indexes[i+1]][1] - tess.svars.texcoords[0][tess.indexes[i]][1];
+
+		vec2[0] = tess.xyz[tess.indexes[i+2]][2] - tess.xyz[tess.indexes[i]][2];
+		vec2[1] = tess.svars.texcoords[0][tess.indexes[i+2]][0] - tess.svars.texcoords[0][tess.indexes[i]][0];
+		vec2[2] = tess.svars.texcoords[0][tess.indexes[i+2]][1] - tess.svars.texcoords[0][tess.indexes[i]][1];
+
+		CrossProduct(vec1, vec2, cp);
+
+		if(cp[0] == 0.0f)
+			cp[0] = 0.001f;
+
+		du[2] = -cp[1] / cp[0];
+		dv[2] = -cp[2] / cp[0];
+
+		tess.tangent[tess.indexes[i]][0] += du[0];
+		tess.tangent[tess.indexes[i]][1] += du[1];
+		tess.tangent[tess.indexes[i]][2] += du[2];
+
+		tess.tangent[tess.indexes[i+1]][0] += du[0];
+		tess.tangent[tess.indexes[i+1]][1] += du[1];
+		tess.tangent[tess.indexes[i+1]][2] += du[2];
+
+		tess.tangent[tess.indexes[i+2]][0] += du[0];
+		tess.tangent[tess.indexes[i+2]][1] += du[1];
+		tess.tangent[tess.indexes[i+2]][2] += du[2];
+	}
+	
+	for(i = 0; i < tess.numVertexes; i++)
+	{
+		VectorNormalizeFast(tess.tangent[i]);
+	}
+}
+#endif // VV_LIGHTING
+
+//--EF_old dlight code...reverting back to Quake III dlight to see if people like that better
+// Lifted the whole function because someone hacked the heck out of this and it doesn't seem to
+//	be a case where it's as easy as just changing the blend mode....
+/*
+===================
+ProjectDlightTexture
+
+Perform dynamic lighting with another rendering pass
+===================
+*/
+/*
+static void ProjectDlightTexture( void ) {
+	int		l;
+	vec3_t	origin;
+	float	*texCoords;
+	byte	*colors;
+	byte	clipBits[SHADER_MAX_VERTEXES];
+	MAC_STATIC float	texCoordsArray[SHADER_MAX_VERTEXES][2];
+	byte	colorArray[SHADER_MAX_VERTEXES][4];
+	unsigned	hitIndexes[SHADER_MAX_INDEXES];
+
+	if ( !backEnd.refdef.num_dlights ) {
+		return;
+	}
+
+	for ( l = 0 ; l < backEnd.refdef.num_dlights ; l++ ) {
+		int		numIndexes;
+		vec3_t	floatColor;
+		float	scale;
+		float	radius, chord;
+		dlight_t	*dl;
+		int i;
+
+		if ( !( tess.dlightBits & ( 1 << l ) ) ) {
+			continue;	// this surface definately doesn't have any of this light
+		}
+		texCoords = texCoordsArray[0];
+		colors = colorArray[0];
+
+		dl = &backEnd.refdef.dlights[l];
+		VectorCopy( dl->transformed, origin );
+		radius = dl->radius;
+		chord = radius*radius*0.25f;
+		scale = 1.0f / radius;
+		floatColor[0] = dl->color[0] * 255f;
+		floatColor[1] = dl->color[1] * 255f;
+		floatColor[2] = dl->color[2] * 255f;
+
+		for ( i = 0 ; i < tess.numVertexes ; i++, texCoords += 2, colors += 4 ) {
+			vec3_t	distVec;
+			int		clip;
+			float	tempColor;
+			float	modulate, dist;
+
+//			if ( 0 ) {
+//				clipBits[i] = 255;	// definately not dlighted
+//				continue;
+//			}
+//
+			backEnd.pc.c_dlightVertexes++;
+
+			VectorSubtract( origin, tess.xyz[i], distVec );
+			dist = VectorLengthSquared(distVec);
+
+			texCoords[0] = 0.5 + distVec[0] * scale;	//xy projection
+			texCoords[1] = 0.5 + distVec[1] * scale;
+
+			clip = 0;
+			if ( texCoords[0] < 0 ) {
+				clip |= 1;
+			} else if ( texCoords[0] > 1 ) {
+				clip |= 2;
+			}
+			if ( texCoords[1] < 0 ) {
+				clip |= 4;
+			} else if ( texCoords[1] > 1 ) {
+				clip |= 8;
+			}
+			clipBits[i] = clip;
+
+			// modulate the strength based on the height and color
+			if ( dist > chord) {
+				clip |= 16;
+				modulate = 255*1.0ff;
+			} else {
+				modulate = 255*2*dist*scale*scale;
+			}
+			tempColor = floatColor[0] + modulate;
+			colors[0] = tempColor > 255 ? 255: myftol(tempColor);
+			
+			tempColor = floatColor[1] + modulate;
+			colors[1] = tempColor > 255 ? 255: myftol(tempColor);
+
+			tempColor = floatColor[2] + modulate;
+			colors[2] = tempColor > 255 ? 255: myftol(tempColor);
+
+//			colors[3] = 255;
+			if ( distVec[2] > radius ) {
+				colors[3] = 0;
+			} else if ( distVec[2] < -radius ) {
+				colors[3] = 0;
+			} else {
+				if ( distVec[2] < 0 ) {
+					distVec[2] = -distVec[2];
+				}
+				if ( distVec[2] < radius * 0.5 ) {
+					colors[3] = 255;
+				} else {
+					colors[3] = myftol(255* (radius - distVec[2]) * scale);
+				}
+			}
+
+		}
+
+		// build a list of triangles that need light
+		numIndexes = 0;
+		for ( i = 0 ; i < tess.numIndexes ; i += 3 ) {
+			int		a, b, c;
+
+			a = tess.indexes[i];
+			b = tess.indexes[i+1];
+			c = tess.indexes[i+2];
+			if ( clipBits[a] & clipBits[b] & clipBits[c] ) {
+				continue;	// not lighted
+			}
+			hitIndexes[numIndexes] = a;
+			hitIndexes[numIndexes+1] = b;
+			hitIndexes[numIndexes+2] = c;
+			numIndexes += 3;
+		}
+
+		if ( !numIndexes ) {
+			continue;
+		}
+
+		qglEnableClientState( GL_TEXTURE_COORD_ARRAY );
+		qglTexCoordPointer( 2, GL_FLOAT, 0, texCoordsArray[0] );
+
+		qglEnableClientState( GL_COLOR_ARRAY );
+		qglColorPointer( 4, GL_UNSIGNED_BYTE, 0, colorArray );
+
+		GL_Bind( tr.dlightImage );
+
+		// include GLS_DEPTHFUNC_EQUAL so alpha tested surfaces don't add light
+		// where they aren't rendered
+		GL_State( GLS_SRCBLEND_SRC_ALPHA | GLS_DSTBLEND_SRC_COLOR | GLS_DEPTHFUNC_EQUAL);//our way
+//		GL_State( GLS_SRCBLEND_DST_COLOR | GLS_DSTBLEND_ONE | GLS_DEPTHFUNC_EQUAL );	//Id way
+		R_DrawElements( numIndexes, hitIndexes );
+		backEnd.pc.c_totalIndexes += numIndexes;
+		backEnd.pc.c_dlightIndexes += numIndexes;
+	}
+}
+*/
+
+// Lifted from Quake III to see if people like this kind of dlight better
+/*
+===================
+ProjectDlightTexture
+
+Perform dynamic lighting with another rendering pass
+===================
+*/
+#ifndef VV_LIGHTING
+static void ProjectDlightTexture2( void ) {
+	int		i, l;
+	vec3_t	origin;
+	byte	clipBits[SHADER_MAX_VERTEXES];
+	MAC_STATIC float	texCoordsArray[SHADER_MAX_VERTEXES][2];
+	MAC_STATIC float	oldTexCoordsArray[SHADER_MAX_VERTEXES][2];
+	MAC_STATIC float	vertCoordsArray[SHADER_MAX_VERTEXES][4];
+	unsigned int		colorArray[SHADER_MAX_VERTEXES];
+	glIndex_t	hitIndexes[SHADER_MAX_INDEXES];
+	int		numIndexes;
+	float	radius;
+	int		fogging;
+	shaderStage_t *dStage;
+	vec3_t	posa;
+	vec3_t	posb;
+	vec3_t	posc;
+	vec3_t	dist;
+	vec3_t	e1;
+	vec3_t	e2;
+	vec3_t	normal;
+	float	fac,modulate;
+	vec3_t	floatColor;
+	byte colorTemp[4];
+
+	int		needResetVerts=0;
+
+	if ( !backEnd.refdef.num_dlights ) 
+	{
+		return;
+	}
+
+	for ( l = 0 ; l < backEnd.refdef.num_dlights ; l++ )
+	{
+		dlight_t	*dl;
+
+		if ( !( tess.dlightBits & ( 1 << l ) ) ) {
+			continue;	// this surface definately doesn't have any of this light
+		}
+
+		dl = &backEnd.refdef.dlights[l];
+		VectorCopy( dl->transformed, origin );
+		radius = dl->radius;
+
+		int		clipall = 63;
+		for ( i = 0 ; i < tess.numVertexes ; i++) 
+		{
+			int		clip;
+			VectorSubtract( origin, tess.xyz[i], dist );
+
+			clip = 0;
+			if (  dist[0] < -radius ) 
+			{
+				clip |= 1;
+			}
+			else if ( dist[0] > radius ) 
+			{
+				clip |= 2;
+			}
+			if (  dist[1] < -radius ) 
+			{
+				clip |= 4;
+			}
+			else if ( dist[1] > radius ) 
+			{
+				clip |= 8;
+			}
+			if (  dist[2] < -radius ) 
+			{
+				clip |= 16;
+			}
+			else if ( dist[2] > radius ) 
+			{
+				clip |= 32;
+			}
+
+			clipBits[i] = clip;
+			clipall &= clip;
+		}
+		if ( clipall ) 
+		{
+			continue;	// this surface doesn't have any of this light
+		}
+		floatColor[0] = dl->color[0] * 255.0f;
+		floatColor[1] = dl->color[1] * 255.0f;
+		floatColor[2] = dl->color[2] * 255.0f;
+		// build a list of triangles that need light
+		numIndexes = 0;
+		for ( i = 0 ; i < tess.numIndexes ; i += 3 ) 
+		{
+			int		a, b, c;
+
+			a = tess.indexes[i];
+			b = tess.indexes[i+1];
+			c = tess.indexes[i+2];
+			if ( clipBits[a] & clipBits[b] & clipBits[c] ) 
+			{
+				continue;	// not lighted
+			}
+
+			// copy the vertex positions
+			VectorCopy(tess.xyz[a],posa);
+			VectorCopy(tess.xyz[b],posb);
+			VectorCopy(tess.xyz[c],posc);
+
+			VectorSubtract( posa, posb,e1);
+			VectorSubtract( posc, posb,e2);
+			CrossProduct(e1,e2,normal);
+//			fac=DotProduct(normal,origin)-DotProduct(normal,posa);
+//			if (fac <= 0.0f || // backface
+			if ( (!r_dlightBacks->integer && DotProduct(normal,origin)-DotProduct(normal,posa) <= 0.0f) || // backface
+				DotProduct(normal,normal) < 1E-8f) // junk triangle
+			{
+				continue;
+			}
+			VectorNormalize(normal);
+			fac=DotProduct(normal,origin)-DotProduct(normal,posa);
+			if (fac >= radius)  // out of range
+			{
+				continue;
+			}
+			modulate = 1.0f-((fac*fac) / (radius*radius));
+			fac = 0.5f/sqrtf(radius*radius - fac*fac);
+
+			// save the verts
+			VectorCopy(posa,vertCoordsArray[numIndexes]);
+			VectorCopy(posb,vertCoordsArray[numIndexes+1]);
+			VectorCopy(posc,vertCoordsArray[numIndexes+2]);
+
+			// now we need e1 and e2 to be an orthonormal basis
+			if (DotProduct(e1,e1) > DotProduct(e2,e2))
+			{
+				VectorNormalize(e1);
+				CrossProduct(e1,normal,e2);
+			}
+			else
+			{
+				VectorNormalize(e2);
+				CrossProduct(normal,e2,e1);
+			}
+			VectorScale(e1,fac,e1);
+			VectorScale(e2,fac,e2);
+
+			VectorSubtract( posa, origin,dist);
+			texCoordsArray[numIndexes][0]=DotProduct(dist,e1)+0.5f;
+			texCoordsArray[numIndexes][1]=DotProduct(dist,e2)+0.5f;
+
+			VectorSubtract( posb, origin,dist);
+			texCoordsArray[numIndexes+1][0]=DotProduct(dist,e1)+0.5f;
+			texCoordsArray[numIndexes+1][1]=DotProduct(dist,e2)+0.5f;
+
+			VectorSubtract( posc, origin,dist);
+			texCoordsArray[numIndexes+2][0]=DotProduct(dist,e1)+0.5f;
+			texCoordsArray[numIndexes+2][1]=DotProduct(dist,e2)+0.5f;
+
+			if ((texCoordsArray[numIndexes][0] < 0.0f && texCoordsArray[numIndexes+1][0] < 0.0f && texCoordsArray[numIndexes+2][0] < 0.0f) ||
+				(texCoordsArray[numIndexes][0] > 1.0f && texCoordsArray[numIndexes+1][0] > 1.0f && texCoordsArray[numIndexes+2][0] > 1.0f) ||
+				(texCoordsArray[numIndexes][1] < 0.0f && texCoordsArray[numIndexes+1][1] < 0.0f && texCoordsArray[numIndexes+2][1] < 0.0f) ||
+				(texCoordsArray[numIndexes][1] > 1.0f && texCoordsArray[numIndexes+1][1] > 1.0f && texCoordsArray[numIndexes+2][1] > 1.0f) )
+			{
+				continue; // didn't end up hitting this tri
+			}
+
+			// these are the old texture coordinates for the multitexture dlight
+
+			/* old code, get from the svars = wrong
+			oldTexCoordsArray[numIndexes][0]=tess.svars.texcoords[0][a][0];
+			oldTexCoordsArray[numIndexes][1]=tess.svars.texcoords[0][a][1];
+			oldTexCoordsArray[numIndexes+1][0]=tess.svars.texcoords[0][b][0];
+			oldTexCoordsArray[numIndexes+1][1]=tess.svars.texcoords[0][b][1];
+			oldTexCoordsArray[numIndexes+2][0]=tess.svars.texcoords[0][c][0];
+			oldTexCoordsArray[numIndexes+2][1]=tess.svars.texcoords[0][c][1];
+			*/
+			oldTexCoordsArray[numIndexes][0]=tess.texCoords[a][0][0];
+			oldTexCoordsArray[numIndexes][1]=tess.texCoords[a][0][1];
+			oldTexCoordsArray[numIndexes+1][0]=tess.texCoords[b][0][0];
+			oldTexCoordsArray[numIndexes+1][1]=tess.texCoords[b][0][1];
+			oldTexCoordsArray[numIndexes+2][0]=tess.texCoords[c][0][0];
+			oldTexCoordsArray[numIndexes+2][1]=tess.texCoords[c][0][1];
+
+			colorTemp[0] = myftol(floatColor[0] * modulate);
+			colorTemp[1] = myftol(floatColor[1] * modulate);
+			colorTemp[2] = myftol(floatColor[2] * modulate);
+			colorTemp[3] = 255;
+			colorArray[numIndexes]=*(unsigned int *)colorTemp;
+			colorArray[numIndexes+1]=*(unsigned int *)colorTemp;
+			colorArray[numIndexes+2]=*(unsigned int *)colorTemp;
+
+			hitIndexes[numIndexes] = numIndexes;
+			hitIndexes[numIndexes+1] = numIndexes+1;
+			hitIndexes[numIndexes+2] = numIndexes+2;
+			numIndexes += 3;
+
+			if (numIndexes>=SHADER_MAX_VERTEXES-3)
+			{
+				break; // we are out of space, so we are done :)
+			}
+		}
+
+		if ( !numIndexes ) {
+			continue;
+		}
+		//don't have fog enabled when we redraw with alpha test, or it will double over
+		//and screw the tri up -rww
+		if (r_drawfog->value == 2 && 
+			tr.world &&
+			(tess.fogNum == tr.world->globalFog || tess.fogNum == tr.world->numfogs))
+		{
+			fogging = qglIsEnabled(GL_FOG);
+
+			if (fogging)
+			{
+				qglDisable(GL_FOG);
+			}
+		}
+		else
+		{
+			fogging = 0;
+		}
+
+		if (!needResetVerts)
+		{
+			needResetVerts=1;
+			if (qglUnlockArraysEXT) 
+			{
+				qglUnlockArraysEXT();
+				GLimp_LogComment( "glUnlockArraysEXT\n" );
+			}
+		}
+		qglVertexPointer (3, GL_FLOAT, 16, vertCoordsArray);	// padded for SIMD
+
+		dStage = NULL;
+		if (tess.shader && qglActiveTextureARB)
+		{
+			int i = 0;
+			while (i < tess.shader->numUnfoggedPasses)
+			{
+				const int blendBits = (GLS_SRCBLEND_BITS+GLS_DSTBLEND_BITS);
+				if (((tess.shader->stages[i].bundle[0].image && !tess.shader->stages[i].bundle[0].isLightmap && !tess.shader->stages[i].bundle[0].numTexMods && tess.shader->stages[i].bundle[0].tcGen != TCGEN_ENVIRONMENT_MAPPED && tess.shader->stages[i].bundle[0].tcGen != TCGEN_FOG) ||
+					 (tess.shader->stages[i].bundle[1].image && !tess.shader->stages[i].bundle[1].isLightmap && !tess.shader->stages[i].bundle[1].numTexMods && tess.shader->stages[i].bundle[1].tcGen != TCGEN_ENVIRONMENT_MAPPED && tess.shader->stages[i].bundle[1].tcGen != TCGEN_FOG)) &&
+					(tess.shader->stages[i].stateBits & blendBits) == 0 )
+				{ //only use non-lightmap opaque stages
+                    dStage = &tess.shader->stages[i];
+					break;
+				}
+				i++;
+			}
+		}
+
+		if (dStage)
+		{
+			GL_SelectTexture( 0 );
+			GL_State(0);
+			qglTexCoordPointer( 2, GL_FLOAT, 0, oldTexCoordsArray[0] );
+			if (dStage->bundle[0].image && !dStage->bundle[0].isLightmap && !dStage->bundle[0].numTexMods && dStage->bundle[0].tcGen != TCGEN_ENVIRONMENT_MAPPED && dStage->bundle[0].tcGen != TCGEN_FOG)
+			{
+				R_BindAnimatedImage( &dStage->bundle[0] );
+			}
+			else
+			{
+				R_BindAnimatedImage( &dStage->bundle[1] );
+			}
+
+			GL_SelectTexture( 1 );
+			qglEnable( GL_TEXTURE_2D );
+			qglEnableClientState( GL_TEXTURE_COORD_ARRAY );
+			qglTexCoordPointer( 2, GL_FLOAT, 0, texCoordsArray[0] );
+			qglEnableClientState( GL_COLOR_ARRAY );
+			qglColorPointer( 4, GL_UNSIGNED_BYTE, 0, colorArray );
+			GL_Bind( tr.dlightImage );
+			GL_TexEnv( GL_MODULATE );
+
+
+			GL_State(GLS_SRCBLEND_ONE | GLS_DSTBLEND_ONE | GLS_DEPTHFUNC_EQUAL);// | GLS_ATEST_GT_0);
+
+			R_DrawElements( numIndexes, hitIndexes );
+
+			qglDisable( GL_TEXTURE_2D );
+			GL_SelectTexture(0);
+		}
+		else
+		{
+			qglEnableClientState( GL_TEXTURE_COORD_ARRAY );
+			qglTexCoordPointer( 2, GL_FLOAT, 0, texCoordsArray[0] );
+
+			qglEnableClientState( GL_COLOR_ARRAY );
+			qglColorPointer( 4, GL_UNSIGNED_BYTE, 0, colorArray );
+
+			GL_Bind( tr.dlightImage );
+			// include GLS_DEPTHFUNC_EQUAL so alpha tested surfaces don't add light
+			// where they aren't rendered
+			//if ( dl->additive ) {
+			//	GL_State( GLS_SRCBLEND_ONE | GLS_DSTBLEND_ONE | GLS_DEPTHFUNC_EQUAL );
+			//}
+			//else 
+			{
+				GL_State( GLS_SRCBLEND_DST_COLOR | GLS_DSTBLEND_ONE | GLS_DEPTHFUNC_EQUAL );
+			}
+
+			R_DrawElements( numIndexes, hitIndexes );
+		}
+
+		if (fogging)
+		{
+			qglEnable(GL_FOG);
+		}
+
+		backEnd.pc.c_totalIndexes += numIndexes;
+		backEnd.pc.c_dlightIndexes += numIndexes;
+	}
+	if (needResetVerts)
+	{
+		qglVertexPointer (3, GL_FLOAT, 16, tess.xyz);	// padded for SIMD
+		if (qglLockArraysEXT)
+		{
+			qglLockArraysEXT(0, tess.numVertexes);
+			GLimp_LogComment( "glLockArraysEXT\n" );
+		}
+	}
+}
+static void ProjectDlightTexture( void ) {
+	int		i, l;
+	vec3_t	origin;
+	float	*texCoords;
+	byte	*colors;
+	byte	clipBits[SHADER_MAX_VERTEXES];
+	MAC_STATIC float	texCoordsArray[SHADER_MAX_VERTEXES][2];
+	byte	colorArray[SHADER_MAX_VERTEXES][4];
+	glIndex_t	hitIndexes[SHADER_MAX_INDEXES];
+	int		numIndexes;
+	float	scale;
+	float	radius;
+	int		fogging;
+	vec3_t	floatColor;
+	shaderStage_t *dStage;
+
+	if ( !backEnd.refdef.num_dlights ) {
+		return;
+	}
+
+	for ( l = 0 ; l < backEnd.refdef.num_dlights ; l++ ) {
+		dlight_t	*dl;
+
+		if ( !( tess.dlightBits & ( 1 << l ) ) ) {
+			continue;	// this surface definately doesn't have any of this light
+		}
+
+		texCoords = texCoordsArray[0];
+		colors = colorArray[0];
+
+		dl = &backEnd.refdef.dlights[l];
+		VectorCopy( dl->transformed, origin );
+		radius = dl->radius;
+		scale = 1.0f / radius;
+
+		floatColor[0] = dl->color[0] * 255.0f;
+		floatColor[1] = dl->color[1] * 255.0f;
+		floatColor[2] = dl->color[2] * 255.0f;
+
+		for ( i = 0 ; i < tess.numVertexes ; i++, texCoords += 2, colors += 4 ) {
+			vec3_t	dist;
+			int		clip;
+			float	modulate;
+
+			backEnd.pc.c_dlightVertexes++;
+
+			VectorSubtract( origin, tess.xyz[i], dist );
+			
+			int l = 1;
+			int bestIndex = 0;
+			float greatest = tess.normal[i][0];
+			if (greatest < 0.0f)
+			{
+				greatest = -greatest;
+			}
+
+			if (VectorCompare(tess.normal[i], vec3_origin))
+			{ //damn you terrain!
+				bestIndex = 2;
+			}
+			else
+			{
+				while (l < 3)
+				{
+					if ((tess.normal[i][l] > greatest && tess.normal[i][l] > 0.0f) ||
+						(tess.normal[i][l] < -greatest && tess.normal[i][l] < 0.0f))
+					{
+						greatest = tess.normal[i][l];
+						if (greatest < 0.0f)
+						{
+							greatest = -greatest;
+						}
+						bestIndex = l;
+					}
+					l++;
+				}
+			}
+
+			float dUse = 0.0f;
+			const float maxScale = 1.5f;
+			const float maxGroundScale = 1.4f;
+			const float lightScaleTolerance = 0.1f;
+
+			if (bestIndex == 2)
+			{
+				dUse = origin[2]-tess.xyz[i][2];
+				if (dUse < 0.0f)
+				{
+					dUse = -dUse;
+				}
+				dUse = (radius*0.5f)/dUse;
+				if (dUse > maxGroundScale)
+				{
+					dUse = maxGroundScale;
+				}
+				else if (dUse < 0.1f)
+				{
+					dUse = 0.1f;
+				}
+
+				if (VectorCompare(tess.normal[i], vec3_origin) ||
+					tess.normal[i][0] > lightScaleTolerance ||
+					tess.normal[i][0] < -lightScaleTolerance ||
+					tess.normal[i][1] > lightScaleTolerance ||
+					tess.normal[i][1] < -lightScaleTolerance)
+				{ //if not perfectly flat, we must use a constant dist
+					scale = 1.0f / radius;
+				}
+				else
+				{
+					scale = 1.0f / (radius*dUse);
+				}
+
+				texCoords[0] = 0.5f + dist[0] * scale;
+				texCoords[1] = 0.5f + dist[1] * scale;
+			}
+			else if (bestIndex == 1)
+			{
+				dUse = origin[1]-tess.xyz[i][1];
+				if (dUse < 0.0f)
+				{
+					dUse = -dUse;
+				}
+				dUse = (radius*0.5f)/dUse;
+				if (dUse > maxScale)
+				{
+					dUse = maxScale;
+				}
+				else if (dUse < 0.1f)
+				{
+					dUse = 0.1f;
+				}
+				if (tess.normal[i][0] > lightScaleTolerance ||
+					tess.normal[i][0] < -lightScaleTolerance ||
+					tess.normal[i][2] > lightScaleTolerance ||
+					tess.normal[i][2] < -lightScaleTolerance)
+				{ //if not perfectly flat, we must use a constant dist
+					scale = 1.0f / radius;
+				}
+				else
+				{
+					scale = 1.0f / (radius*dUse);
+				}
+
+				texCoords[0] = 0.5f + dist[0] * scale;
+				texCoords[1] = 0.5f + dist[2] * scale;
+			}
+			else
+			{
+				dUse = origin[0]-tess.xyz[i][0];
+				if (dUse < 0.0f)
+				{
+					dUse = -dUse;
+				}
+				dUse = (radius*0.5f)/dUse;
+				if (dUse > maxScale)
+				{
+					dUse = maxScale;
+				}
+				else if (dUse < 0.1f)
+				{
+					dUse = 0.1f;
+				}
+				if (tess.normal[i][2] > lightScaleTolerance ||
+					tess.normal[i][2] < -lightScaleTolerance ||
+					tess.normal[i][1] > lightScaleTolerance ||
+					tess.normal[i][1] < -lightScaleTolerance)
+				{ //if not perfectly flat, we must use a constant dist
+					scale = 1.0f / radius;
+				}
+				else
+				{
+					scale = 1.0f / (radius*dUse);
+				}
+
+				texCoords[0] = 0.5f + dist[1] * scale;
+				texCoords[1] = 0.5f + dist[2] * scale;
+			}
+			
+			clip = 0;
+			if ( texCoords[0] < 0.0f ) {
+				clip |= 1;
+			} else if ( texCoords[0] > 1.0f ) {
+				clip |= 2;
+			}
+			if ( texCoords[1] < 0.0f ) {
+				clip |= 4;
+			} else if ( texCoords[1] > 1.0f ) {
+				clip |= 8;
+			}
+			// modulate the strength based on the height and color
+			if ( dist[bestIndex] > radius ) {
+				clip |= 16;
+				modulate = 0.0f;
+			} else if ( dist[bestIndex] < -radius ) {
+				clip |= 32;
+				modulate = 0.0f;
+			} else {
+				dist[bestIndex] = Q_fabs(dist[bestIndex]);
+				if ( dist[bestIndex] < radius * 0.5f ) {
+					modulate = 1.0f;
+				} else {
+					modulate = 2.0f * (radius - dist[bestIndex]) * scale;
+				}
+			}
+			clipBits[i] = clip;
+
+			colors[0] = myftol(floatColor[0] * modulate);
+			colors[1] = myftol(floatColor[1] * modulate);
+			colors[2] = myftol(floatColor[2] * modulate);
+			colors[3] = 255;
+		}
+		// build a list of triangles that need light
+		numIndexes = 0;
+		for ( i = 0 ; i < tess.numIndexes ; i += 3 ) {
+			int		a, b, c;
+
+			a = tess.indexes[i];
+			b = tess.indexes[i+1];
+			c = tess.indexes[i+2];
+			if ( clipBits[a] & clipBits[b] & clipBits[c] ) {
+				continue;	// not lighted
+			}
+			hitIndexes[numIndexes] = a;
+			hitIndexes[numIndexes+1] = b;
+			hitIndexes[numIndexes+2] = c;
+			numIndexes += 3;
+		}
+
+		if ( !numIndexes ) {
+			continue;
+		}
+
+		//don't have fog enabled when we redraw with alpha test, or it will double over
+		//and screw the tri up -rww
+		if (r_drawfog->value == 2 && 
+			tr.world &&
+			(tess.fogNum == tr.world->globalFog || tess.fogNum == tr.world->numfogs))
+		{
+			fogging = qglIsEnabled(GL_FOG);
+
+			if (fogging)
+			{
+				qglDisable(GL_FOG);
+			}
+		}
+		else
+		{
+			fogging = 0;
+		}
+
+
+		dStage = NULL;
+		if (tess.shader && qglActiveTextureARB)
+		{
+			int i = 0;
+			while (i < tess.shader->numUnfoggedPasses)
+			{
+				const int blendBits = (GLS_SRCBLEND_BITS+GLS_DSTBLEND_BITS);
+				if (((tess.shader->stages[i].bundle[0].image && !tess.shader->stages[i].bundle[0].isLightmap && !tess.shader->stages[i].bundle[0].numTexMods && tess.shader->stages[i].bundle[0].tcGen != TCGEN_ENVIRONMENT_MAPPED && tess.shader->stages[i].bundle[0].tcGen != TCGEN_FOG) ||
+					 (tess.shader->stages[i].bundle[1].image && !tess.shader->stages[i].bundle[1].isLightmap && !tess.shader->stages[i].bundle[1].numTexMods && tess.shader->stages[i].bundle[1].tcGen != TCGEN_ENVIRONMENT_MAPPED && tess.shader->stages[i].bundle[1].tcGen != TCGEN_FOG)) &&
+					(tess.shader->stages[i].stateBits & blendBits) == 0 )
+				{ //only use non-lightmap opaque stages
+                    dStage = &tess.shader->stages[i];
+					break;
+				}
+				i++;
+			}
+		}
+
+		if (dStage)
+		{
+			GL_SelectTexture( 0 );
+			GL_State(0);
+			qglTexCoordPointer( 2, GL_FLOAT, 0, tess.svars.texcoords[0] );
+			if (dStage->bundle[0].image && !dStage->bundle[0].isLightmap && !dStage->bundle[0].numTexMods && dStage->bundle[0].tcGen != TCGEN_ENVIRONMENT_MAPPED && dStage->bundle[0].tcGen != TCGEN_FOG)
+			{
+				R_BindAnimatedImage( &dStage->bundle[0] );
+			}
+			else
+			{
+				R_BindAnimatedImage( &dStage->bundle[1] );
+			}
+
+			GL_SelectTexture( 1 );
+			qglEnable( GL_TEXTURE_2D );
+			qglEnableClientState( GL_TEXTURE_COORD_ARRAY );
+			qglTexCoordPointer( 2, GL_FLOAT, 0, texCoordsArray[0] );
+			qglEnableClientState( GL_COLOR_ARRAY );
+			qglColorPointer( 4, GL_UNSIGNED_BYTE, 0, colorArray );
+			GL_Bind( tr.dlightImage );
+			GL_TexEnv( GL_MODULATE );
+
+			GL_State(GLS_SRCBLEND_ONE | GLS_DSTBLEND_ONE | GLS_DEPTHFUNC_EQUAL);// | GLS_ATEST_GT_0);
+
+			R_DrawElements( numIndexes, hitIndexes );
+
+			qglDisable( GL_TEXTURE_2D );
+			GL_SelectTexture(0);
+		}
+		else
+		{
+			qglEnableClientState( GL_TEXTURE_COORD_ARRAY );
+			qglTexCoordPointer( 2, GL_FLOAT, 0, texCoordsArray[0] );
+
+			qglEnableClientState( GL_COLOR_ARRAY );
+			qglColorPointer( 4, GL_UNSIGNED_BYTE, 0, colorArray );
+
+			GL_Bind( tr.dlightImage );
+			// include GLS_DEPTHFUNC_EQUAL so alpha tested surfaces don't add light
+			// where they aren't rendered
+			//if ( dl->additive ) {
+			//	GL_State( GLS_SRCBLEND_ONE | GLS_DSTBLEND_ONE | GLS_DEPTHFUNC_EQUAL );
+			//}
+			//else
+			{
+				GL_State( GLS_SRCBLEND_DST_COLOR | GLS_DSTBLEND_ONE | GLS_DEPTHFUNC_EQUAL );
+			}
+
+			R_DrawElements( numIndexes, hitIndexes );
+		}
+
+		if (fogging)
+		{
+			qglEnable(GL_FOG);
+		}
+
+		backEnd.pc.c_totalIndexes += numIndexes;
+		backEnd.pc.c_dlightIndexes += numIndexes;
+	}
+}
+#endif // VV_LIGHTING
+
+
+/*
+===================
+RB_FogPass
+
+Blends a fog texture on top of everything else
+===================
+*/
+static void RB_FogPass( void ) {
+	fog_t		*fog;
+	int			i;
+
+	qglEnableClientState( GL_COLOR_ARRAY );
+	qglColorPointer( 4, GL_UNSIGNED_BYTE, 0, tess.svars.colors );
+
+	qglEnableClientState( GL_TEXTURE_COORD_ARRAY);
+	qglTexCoordPointer( 2, GL_FLOAT, 0, tess.svars.texcoords[0] );
+
+	fog = tr.world->fogs + tess.fogNum;
+
+	for ( i = 0; i < tess.numVertexes; i++ ) {
+		* ( int * )&tess.svars.colors[i] = fog->colorInt;
+	}
+
+	RB_CalcFogTexCoords( ( float * ) tess.svars.texcoords[0] );
+
+	GL_Bind( tr.fogImage );
+
+	if ( tess.shader->fogPass == FP_EQUAL ) {
+		GL_State( GLS_SRCBLEND_SRC_ALPHA | GLS_DSTBLEND_ONE_MINUS_SRC_ALPHA | GLS_DEPTHFUNC_EQUAL );
+	} else {
+		GL_State( GLS_SRCBLEND_SRC_ALPHA | GLS_DSTBLEND_ONE_MINUS_SRC_ALPHA );
+	}
+
+	R_DrawElements( tess.numIndexes, tess.indexes );
+}
+
+
+/*
+===============
+ComputeColors
+===============
+*/
+#ifdef _XBOX
+static void ComputeColors( shaderStage_t *pStage, alphaGen_t forceAlphaGen, colorGen_t forceRGBGen )
+{
+	int i;
+
+	if ( tess.shader != tr.projectionShadowShader && tess.shader != tr.shadowShader && 
+		( backEnd.currentEntity->e.renderfx & (RF_DISINTEGRATE1|RF_DISINTEGRATE2)))
+	{
+		RB_CalcDisintegrateColors( (unsigned char *)tess.svars.colors, pStage->rgbGen );
+		RB_CalcDisintegrateVertDeform();
+
+		// We've done some custom alpha and color stuff, so we can skip the rest.  Let it do fog though
+		forceRGBGen = CGEN_SKIP;
+		forceAlphaGen = AGEN_SKIP;
+	}
+
+	//
+	// rgbGen
+	//
+	if ( !forceRGBGen )
+	{
+		forceRGBGen = pStage->rgbGen;
+	}
+
+	if ( backEnd.currentEntity->e.renderfx & RF_VOLUMETRIC ) // does not work for rotated models, technically, this should also be a CGEN type, but that would entail adding new shader commands....which is too much work for one thing
+	{
+		int			i;
+		float		*normal, dot;
+		DWORD *color;
+		int			numVertexes;
+
+		normal = tess.normal[0];
+		color = tess.svars.colors;
+
+		numVertexes = tess.numVertexes;
+
+		for ( i = 0 ; i < numVertexes ; i++, normal += 4, color ++) 
+		{
+			dot = DotProduct( normal, backEnd.refdef.viewaxis[0] );
+
+			dot *= dot * dot * dot;
+
+			if ( dot < 0.2f ) // so low, so just clamp it
+			{
+				dot = 0.0f;
+			}
+
+			*color = D3DCOLOR_RGBA( (int)(backEnd.currentEntity->e.shaderRGBA[0] * (1-dot)),
+				(int)(backEnd.currentEntity->e.shaderRGBA[0] * (1-dot)),
+				(int)(backEnd.currentEntity->e.shaderRGBA[0] * (1-dot)),
+				(int)(backEnd.currentEntity->e.shaderRGBA[0] * (1-dot)) );
+		}
+
+		forceRGBGen = CGEN_SKIP;
+		forceAlphaGen = AGEN_SKIP;
+	}
+
+	if ( !forceAlphaGen )	//set this up so we can override below
+	{
+		forceAlphaGen = pStage->alphaGen;
+	}
+
+	DWORD color;
+
+	switch ( forceRGBGen )
+	{
+	case CGEN_SKIP:
+		break;
+	case CGEN_IDENTITY:
+		memset( tess.svars.colors, 0xffffffff, sizeof(DWORD) * tess.numVertexes );
+		break;
+	default:
+	case CGEN_IDENTITY_LIGHTING:
+		color = ((tr.identityLightByte & 0xff) << 24 |
+			(tr.identityLightByte & 0xff) << 16 |
+			(tr.identityLightByte & 0xff) << 8  |
+			(tr.identityLightByte & 0xff) << 0);
+		memset( tess.svars.colors, color, sizeof(DWORD) * tess.numVertexes );
+		break;
+	case CGEN_LIGHTING_DIFFUSE:
+#ifdef VV_LIGHTING
+		VVLightMan.RB_CalcDiffuseColor( tess.svars.colors );
+#else
+		RB_CalcDiffuseColor( ( unsigned char * ) tess.svars.colors );
+#endif
+		break;
+	case CGEN_LIGHTING_DIFFUSE_ENTITY:
+#ifdef VV_LIGHTING
+		VVLightMan.RB_CalcDiffuseEntityColor( tess.svars.colors );
+#else
+		RB_CalcDiffuseEntityColor( ( unsigned char * ) tess.svars.colors );
+#endif
+		if ( forceAlphaGen == AGEN_IDENTITY && 
+			backEnd.currentEntity->e.shaderRGBA[3] == 0xff 
+			)
+		{
+			forceAlphaGen = AGEN_SKIP;	//already got it in this set since it does all 4 components
+		}
+		break;
+	case CGEN_EXACT_VERTEX:
+		for( i = 0; i < tess.numVertexes; i++ )
+		{
+			tess.svars.colors[i] = D3DCOLOR_RGBA( (int)(tess.vertexColors[i][0]),
+												  (int)(tess.vertexColors[i][1]),
+												  (int)(tess.vertexColors[i][2]),
+												  (int)(tess.vertexColors[i][3]) );
+		}
+		break;
+	case CGEN_CONST:
+		for ( i = 0; i < tess.numVertexes; i++ ) {
+			tess.svars.colors[i] = D3DCOLOR_RGBA( (int)(pStage->constantColor[0]),
+												  (int)(pStage->constantColor[1]),
+												  (int)(pStage->constantColor[2]),
+												  (int)(pStage->constantColor[3]) );
+		}
+		break;
+	case CGEN_VERTEX:
+		if ( tr.identityLight == 1 )
+		{
+			for( i = 0; i < tess.numVertexes; i++ )
+			{
+				tess.svars.colors[i] = D3DCOLOR_RGBA( (int)(tess.vertexColors[i][0]),
+					(int)(tess.vertexColors[i][1]),
+					(int)(tess.vertexColors[i][2]),
+					(int)(tess.vertexColors[i][3]));
+			}
+		}
+		else
+		{
+			for ( i = 0; i < tess.numVertexes; i++ )
+			{
+				tess.svars.colors[i] = D3DCOLOR_RGBA( (int)(tess.vertexColors[i][0] * tr.identityLight),
+					(int)(tess.vertexColors[i][1] * tr.identityLight),
+					(int)(tess.vertexColors[i][2] * tr.identityLight),
+					(int)(tess.vertexColors[i][3]));
+			}
+		}
+		break;
+	case CGEN_ONE_MINUS_VERTEX:
+		if ( tr.identityLight == 1 )
+		{
+			for ( i = 0; i < tess.numVertexes; i++ )
+			{
+				tess.svars.colors[i] = D3DCOLOR_XRGB( (int)(255 - tess.vertexColors[i][0]),
+					(int)(255 - tess.vertexColors[i][1]),
+					(int)(255 - tess.vertexColors[i][2]));
+			}
+		}
+		else
+		{
+			for ( i = 0; i < tess.numVertexes; i++ )
+			{
+				tess.svars.colors[i] = D3DCOLOR_XRGB( (int)((255 - tess.vertexColors[i][0]) * tr.identityLight),
+					(int)((255 - tess.vertexColors[i][1]) * tr.identityLight),
+					(int)((255 - tess.vertexColors[i][2]) * tr.identityLight));
+			}
+		}
+		break;
+	case CGEN_FOG:
+		{
+			fog_t		*fog;
+
+			fog = tr.world->fogs + tess.fogNum;
+
+			for ( i = 0; i < tess.numVertexes; i++ ) {
+				* ( int * )&tess.svars.colors[i] = fog->colorInt;
+			}
+		}
+		break;
+	case CGEN_WAVEFORM:
+		RB_CalcWaveColor( &pStage->rgbWave, tess.svars.colors );
+		break;
+	case CGEN_ENTITY:
+		RB_CalcColorFromEntity( tess.svars.colors );
+		if ( forceAlphaGen == AGEN_IDENTITY && 
+			backEnd.currentEntity->e.shaderRGBA[3] == 0xff 
+			)
+		{
+			forceAlphaGen = AGEN_SKIP;	//already got it in this set since it does all 4 components
+		}
+
+		break;
+	case CGEN_ONE_MINUS_ENTITY:
+		RB_CalcColorFromOneMinusEntity( tess.svars.colors );
+		break;
+	case CGEN_LIGHTMAPSTYLE:
+		for ( i = 0; i < tess.numVertexes; i++ ) 
+		{
+			tess.svars.colors[i] = *(DWORD *)styleColors[pStage->lightmapStyle];
+		}
+		break;
+	}
+
+	//
+	// alphaGen
+	//
+	DWORD rgb;
+	switch ( forceAlphaGen )
+	{
+	case AGEN_SKIP:
+		break;
+	case AGEN_IDENTITY:
+		if ( forceRGBGen != CGEN_IDENTITY &&  forceRGBGen != CGEN_LIGHTING_DIFFUSE ) {
+			if ( ( forceRGBGen == CGEN_VERTEX && tr.identityLight != 1 ) ||
+				forceRGBGen != CGEN_VERTEX ) {
+					for ( i = 0; i < tess.numVertexes; i++ ) {
+						rgb = (DWORD)((tess.svars.colors[i]) & 0x00ffffff);
+						tess.svars.colors[i] = rgb | ((255 & 0xff) << 24);
+					}
+				}
+		}
+		break;
+	case AGEN_CONST:
+		if ( forceRGBGen != CGEN_CONST ) {
+			for ( i = 0; i < tess.numVertexes; i++ ) {
+				rgb = (DWORD)((tess.svars.colors[i]) & 0x00ffffff);
+				tess.svars.colors[i] = rgb | ((pStage->constantColor[3] & 0xff) << 24);
+			}
+		}
+		break;
+	case AGEN_WAVEFORM:
+		RB_CalcWaveAlpha( &pStage->alphaWave, tess.svars.colors );
+		break;
+	case AGEN_LIGHTING_SPECULAR:
+		RB_CalcSpecularAlpha( tess.svars.colors );
+		break;
+	case AGEN_ENTITY:
+		if ( forceRGBGen != CGEN_ENTITY ) { //already got it in the CGEN_entity since it does all 4 components
+			RB_CalcAlphaFromEntity( tess.svars.colors );
+		}
+		break;
+	case AGEN_ONE_MINUS_ENTITY:
+		RB_CalcAlphaFromOneMinusEntity( tess.svars.colors );
+		break;
+	case AGEN_VERTEX:
+		if ( forceRGBGen != CGEN_VERTEX ) {
+			for ( i = 0; i < tess.numVertexes; i++ ) {
+				rgb = (DWORD)((tess.svars.colors[i]) & 0x00ffffff);
+				tess.svars.colors[i] = rgb | ((tess.vertexColors[i][3] & 0xff) << 24);
+			}
+		}
+		break;
+	case AGEN_ONE_MINUS_VERTEX:
+		for ( i = 0; i < tess.numVertexes; i++ )
+		{
+			rgb = (DWORD)((tess.svars.colors[i]) & 0x00ffffff);
+			tess.svars.colors[i] = rgb | (((255 - tess.vertexColors[i][3]) & 0xff) << 24);
+		}
+		break;
+	case AGEN_PORTAL:
+		{
+			unsigned char alpha;
+
+			for ( i = 0; i < tess.numVertexes; i++ )
+			{
+				float len;
+				vec3_t v;
+
+				VectorSubtract( tess.xyz[i], backEnd.viewParms.or.origin, v );
+				len = VectorLength( v );
+
+				len /= tess.shader->portalRange;
+
+				if ( len < 0 )
+				{
+					alpha = 0;
+				}
+				else if ( len > 1 )
+				{
+					alpha = 0xff;
+				}
+				else
+				{
+					alpha = len * 0xff;
+				}
+
+				rgb = (DWORD)((tess.svars.colors[i]) & 0x00ffffff);
+				tess.svars.colors[i] = rgb | ((alpha & 0xff) << 24);
+			}
+		}
+		break;
+	case AGEN_BLEND:
+		if ( forceRGBGen != CGEN_VERTEX ) 
+		{
+			for ( i = 0; i < tess.numVertexes; i++ ) 
+			{
+				rgb = (DWORD)((tess.svars.colors[i]) & 0x00ffffff);
+				tess.svars.colors[i] = rgb | ((tess.vertexAlphas[i][pStage->index] & 0xff) << 24);
+			}
+		}
+		break;
+	}
+
+	//
+	// fog adjustment for colors to fade out as fog increases
+	//
+	if ( tess.fogNum )
+	{
+		switch ( pStage->adjustColorsForFog )
+		{
+		case ACFF_MODULATE_RGB:
+			RB_CalcModulateColorsByFog( tess.svars.colors );
+			break;
+		case ACFF_MODULATE_ALPHA:
+			RB_CalcModulateAlphasByFog( tess.svars.colors );
+			break;
+		case ACFF_MODULATE_RGBA:
+			RB_CalcModulateRGBAsByFog( tess.svars.colors );
+			break;
+		case ACFF_NONE:
+			break;
+		}
+	}
+}
+
+#else // _XBOX
+
+static void ComputeColors( shaderStage_t *pStage, alphaGen_t forceAlphaGen, colorGen_t forceRGBGen )
+{
+	int i;
+
+	if ( tess.shader != tr.projectionShadowShader && tess.shader != tr.shadowShader && 
+			( backEnd.currentEntity->e.renderfx & (RF_DISINTEGRATE1|RF_DISINTEGRATE2)))
+	{
+		RB_CalcDisintegrateColors( (unsigned char *)tess.svars.colors, pStage->rgbGen );
+		RB_CalcDisintegrateVertDeform();
+
+		// We've done some custom alpha and color stuff, so we can skip the rest.  Let it do fog though
+		forceRGBGen = CGEN_SKIP;
+		forceAlphaGen = AGEN_SKIP;
+	}
+
+	//
+	// rgbGen
+	//
+	if ( !forceRGBGen )
+	{
+		forceRGBGen = pStage->rgbGen;
+	}
+
+	if ( backEnd.currentEntity->e.renderfx & RF_VOLUMETRIC ) // does not work for rotated models, technically, this should also be a CGEN type, but that would entail adding new shader commands....which is too much work for one thing
+	{
+		int			i;
+		float		*normal, dot;
+		unsigned char *color;
+		int			numVertexes;
+
+		normal = tess.normal[0];
+		color = tess.svars.colors[0];
+
+		numVertexes = tess.numVertexes;
+
+		for ( i = 0 ; i < numVertexes ; i++, normal += 4, color += 4) 
+		{
+			dot = DotProduct( normal, backEnd.refdef.viewaxis[0] );
+
+			dot *= dot * dot * dot;
+
+			if ( dot < 0.2f ) // so low, so just clamp it
+			{
+				dot = 0.0f;
+			}
+
+			color[0] = color[1] = color[2] = color[3] = myftol( backEnd.currentEntity->e.shaderRGBA[0] * (1-dot) );
+		}
+
+		forceRGBGen = CGEN_SKIP;
+		forceAlphaGen = AGEN_SKIP;
+	}
+
+	if ( !forceAlphaGen )	//set this up so we can override below
+	{
+		forceAlphaGen = pStage->alphaGen;
+	}
+
+	switch ( forceRGBGen )
+	{
+		case CGEN_SKIP:
+			break;
+		case CGEN_IDENTITY:
+			memset( tess.svars.colors, 0xff, tess.numVertexes * 4 );
+			break;
+		default:
+		case CGEN_IDENTITY_LIGHTING:
+			memset( tess.svars.colors, tr.identityLightByte, tess.numVertexes * 4 );
+			break;
+		case CGEN_LIGHTING_DIFFUSE:
+			RB_CalcDiffuseColor( ( unsigned char * ) tess.svars.colors );
+			break;
+		case CGEN_LIGHTING_DIFFUSE_ENTITY:
+			RB_CalcDiffuseEntityColor( ( unsigned char * ) tess.svars.colors );
+
+			if ( forceAlphaGen == AGEN_IDENTITY && 
+				 backEnd.currentEntity->e.shaderRGBA[3] == 0xff 
+				)
+			{
+				forceAlphaGen = AGEN_SKIP;	//already got it in this set since it does all 4 components
+			}
+			break;
+		case CGEN_EXACT_VERTEX:
+			memcpy( tess.svars.colors, tess.vertexColors, tess.numVertexes * sizeof( tess.vertexColors[0] ) );
+			break;
+		case CGEN_CONST:
+			for ( i = 0; i < tess.numVertexes; i++ ) {
+				*(int *)tess.svars.colors[i] = *(int *)pStage->constantColor;
+			}
+			break;
+		case CGEN_VERTEX:
+			if ( tr.identityLight == 1 )
+			{
+				memcpy( tess.svars.colors, tess.vertexColors, tess.numVertexes * sizeof( tess.vertexColors[0] ) );
+			}
+			else
+			{
+				for ( i = 0; i < tess.numVertexes; i++ )
+				{
+					tess.svars.colors[i][0] = tess.vertexColors[i][0] * tr.identityLight;
+					tess.svars.colors[i][1] = tess.vertexColors[i][1] * tr.identityLight;
+					tess.svars.colors[i][2] = tess.vertexColors[i][2] * tr.identityLight;
+					tess.svars.colors[i][3] = tess.vertexColors[i][3];
+				}
+			}
+			break;
+		case CGEN_ONE_MINUS_VERTEX:
+			if ( tr.identityLight == 1 )
+			{
+				for ( i = 0; i < tess.numVertexes; i++ )
+				{
+					tess.svars.colors[i][0] = 255 - tess.vertexColors[i][0];
+					tess.svars.colors[i][1] = 255 - tess.vertexColors[i][1];
+					tess.svars.colors[i][2] = 255 - tess.vertexColors[i][2];
+				}
+			}
+			else
+			{
+				for ( i = 0; i < tess.numVertexes; i++ )
+				{
+					tess.svars.colors[i][0] = ( 255 - tess.vertexColors[i][0] ) * tr.identityLight;
+					tess.svars.colors[i][1] = ( 255 - tess.vertexColors[i][1] ) * tr.identityLight;
+					tess.svars.colors[i][2] = ( 255 - tess.vertexColors[i][2] ) * tr.identityLight;
+				}
+			}
+			break;
+		case CGEN_FOG:
+			{
+				fog_t		*fog;
+
+				fog = tr.world->fogs + tess.fogNum;
+
+				for ( i = 0; i < tess.numVertexes; i++ ) {
+					* ( int * )&tess.svars.colors[i] = fog->colorInt;
+				}
+			}
+			break;
+		case CGEN_WAVEFORM:
+			RB_CalcWaveColor( &pStage->rgbWave, ( unsigned char * ) tess.svars.colors );
+			break;
+		case CGEN_ENTITY:
+			RB_CalcColorFromEntity( ( unsigned char * ) tess.svars.colors );
+			if ( forceAlphaGen == AGEN_IDENTITY && 
+				 backEnd.currentEntity->e.shaderRGBA[3] == 0xff 
+				)
+			{
+				forceAlphaGen = AGEN_SKIP;	//already got it in this set since it does all 4 components
+			}
+
+			break;
+		case CGEN_ONE_MINUS_ENTITY:
+			RB_CalcColorFromOneMinusEntity( ( unsigned char * ) tess.svars.colors );
+			break;
+		case CGEN_LIGHTMAPSTYLE:
+			for ( i = 0; i < tess.numVertexes; i++ ) 
+			{
+				* ( int * )&tess.svars.colors[i] = *(int *)styleColors[pStage->lightmapStyle];
+			}
+			break;
+		}
+
+	//
+	// alphaGen
+	//
+
+	switch ( forceAlphaGen )
+	{
+	case AGEN_SKIP:
+		break;
+	case AGEN_IDENTITY:
+		if ( forceRGBGen != CGEN_IDENTITY &&  forceRGBGen != CGEN_LIGHTING_DIFFUSE ) {
+			if ( ( forceRGBGen == CGEN_VERTEX && tr.identityLight != 1 ) ||
+				 forceRGBGen != CGEN_VERTEX ) {
+				for ( i = 0; i < tess.numVertexes; i++ ) {
+					tess.svars.colors[i][3] = 0xff;
+				}
+			}
+		}
+		break;
+	case AGEN_CONST:
+		if ( forceRGBGen != CGEN_CONST ) {
+			for ( i = 0; i < tess.numVertexes; i++ ) {
+				tess.svars.colors[i][3] = pStage->constantColor[3];
+			}
+		}
+		break;
+	case AGEN_WAVEFORM:
+		RB_CalcWaveAlpha( &pStage->alphaWave, ( unsigned char * ) tess.svars.colors );
+		break;
+	case AGEN_LIGHTING_SPECULAR:
+		RB_CalcSpecularAlpha( ( unsigned char * ) tess.svars.colors );
+		break;
+	case AGEN_ENTITY:
+		if ( forceRGBGen != CGEN_ENTITY ) { //already got it in the CGEN_entity since it does all 4 components
+			RB_CalcAlphaFromEntity( ( unsigned char * ) tess.svars.colors );
+		}
+		break;
+	case AGEN_ONE_MINUS_ENTITY:
+		RB_CalcAlphaFromOneMinusEntity( ( unsigned char * ) tess.svars.colors );
+		break;
+	case AGEN_VERTEX:
+		if ( forceRGBGen != CGEN_VERTEX ) {
+			for ( i = 0; i < tess.numVertexes; i++ ) {
+				tess.svars.colors[i][3] = tess.vertexColors[i][3];
+			}
+		}
+        break;
+    case AGEN_ONE_MINUS_VERTEX:
+		for ( i = 0; i < tess.numVertexes; i++ )
+		{
+			tess.svars.colors[i][3] = 255 - tess.vertexColors[i][3];
+		}
+		break;
+	case AGEN_PORTAL:
+		{
+			unsigned char alpha;
+
+			for ( i = 0; i < tess.numVertexes; i++ )
+			{
+				float len;
+				vec3_t v;
+
+				VectorSubtract( tess.xyz[i], backEnd.viewParms.or.origin, v );
+				len = VectorLength( v );
+
+				len /= tess.shader->portalRange;
+
+				if ( len < 0 )
+				{
+					alpha = 0;
+				}
+				else if ( len > 1 )
+				{
+					alpha = 0xff;
+				}
+				else
+				{
+					alpha = len * 0xff;
+				}
+
+				tess.svars.colors[i][3] = alpha;
+			}
+		}
+		break;
+	case AGEN_BLEND:
+		if ( forceRGBGen != CGEN_VERTEX ) 
+		{
+			for ( i = 0; i < tess.numVertexes; i++ ) 
+			{
+				tess.svars.colors[i][3] = tess.vertexAlphas[i][pStage->index];
+			}
+		}
+		break;
+	}
+
+	//
+	// fog adjustment for colors to fade out as fog increases
+	//
+	if ( tess.fogNum )
+	{
+		switch ( pStage->adjustColorsForFog )
+		{
+		case ACFF_MODULATE_RGB:
+			RB_CalcModulateColorsByFog( ( unsigned char * ) tess.svars.colors );
+			break;
+		case ACFF_MODULATE_ALPHA:
+			RB_CalcModulateAlphasByFog( ( unsigned char * ) tess.svars.colors );
+			break;
+		case ACFF_MODULATE_RGBA:
+			RB_CalcModulateRGBAsByFog( ( unsigned char * ) tess.svars.colors );
+			break;
+		case ACFF_NONE:
+			break;
+		}
+	}
+}
+
+#endif // _XBOX
+
+/*
+===============
+ComputeTexCoords
+===============
+*/
+static void ComputeTexCoords( shaderStage_t *pStage ) {
+	int		i;
+	int b;
+
+	for ( b = 0; b < NUM_TEXTURE_BUNDLES; b++ ) {
+		int tm;
+
+		//
+		// generate the texture coordinates
+		//
+		switch ( pStage->bundle[b].tcGen )
+		{
+		case TCGEN_IDENTITY:
+			memset( tess.svars.texcoords[b], 0, sizeof( float ) * 2 * tess.numVertexes );
+			break;
+		case TCGEN_TEXTURE:
+			for ( i = 0 ; i < tess.numVertexes ; i++ ) {
+				tess.svars.texcoords[b][i][0] = tess.texCoords[i][0][0];
+				tess.svars.texcoords[b][i][1] = tess.texCoords[i][0][1];
+			}
+			break;
+		case TCGEN_LIGHTMAP:
+			for ( i = 0 ; i < tess.numVertexes ; i++ ) {
+				tess.svars.texcoords[b][i][0] = tess.texCoords[i][1][0];
+				tess.svars.texcoords[b][i][1] = tess.texCoords[i][1][1];
+			}
+			break;
+		case TCGEN_LIGHTMAP1:
+			for ( i = 0 ; i < tess.numVertexes ; i++ ) {
+				tess.svars.texcoords[b][i][0] = tess.texCoords[i][2][0];
+				tess.svars.texcoords[b][i][1] = tess.texCoords[i][2][1];
+			}
+			break;
+		case TCGEN_LIGHTMAP2:
+			for ( i = 0 ; i < tess.numVertexes ; i++ ) {
+				tess.svars.texcoords[b][i][0] = tess.texCoords[i][3][0];
+				tess.svars.texcoords[b][i][1] = tess.texCoords[i][3][1];
+			}
+			break;
+		case TCGEN_LIGHTMAP3:
+			for ( i = 0 ; i < tess.numVertexes ; i++ ) {
+				tess.svars.texcoords[b][i][0] = tess.texCoords[i][4][0];
+				tess.svars.texcoords[b][i][1] = tess.texCoords[i][4][1];
+			}
+			break;
+		case TCGEN_VECTOR:
+			for ( i = 0 ; i < tess.numVertexes ; i++ ) {
+				tess.svars.texcoords[b][i][0] = DotProduct( tess.xyz[i], pStage->bundle[b].tcGenVectors[0] );
+				tess.svars.texcoords[b][i][1] = DotProduct( tess.xyz[i], pStage->bundle[b].tcGenVectors[1] );
+			}
+			break;
+		case TCGEN_FOG:
+			RB_CalcFogTexCoords( ( float * ) tess.svars.texcoords[b] );
+			break;
+		case TCGEN_ENVIRONMENT_MAPPED:
+#ifdef _XBOX
+			tess.shader->stages[tess.currentPass].isEnvironment = qtrue;
+#else
+			RB_CalcEnvironmentTexCoords( ( float * ) tess.svars.texcoords[b] );
+#endif
+			break;
+		case TCGEN_BAD:
+			return;
+		}
+
+		//
+		// alter texture coordinates
+		//
+		for ( tm = 0; tm < pStage->bundle[b].numTexMods ; tm++ ) {
+			switch ( pStage->bundle[b].texMods[tm].type )
+			{
+			case TMOD_NONE:
+				tm = TR_MAX_TEXMODS;		// break out of for loop
+				break;
+
+			case TMOD_TURBULENT:
+				RB_CalcTurbulentTexCoords( &pStage->bundle[b].texMods[tm].wave, 
+						                 ( float * ) tess.svars.texcoords[b] );
+				break;
+
+			case TMOD_ENTITY_TRANSLATE:
+				RB_CalcScrollTexCoords( backEnd.currentEntity->e.shaderTexCoord,
+									 ( float * ) tess.svars.texcoords[b] );
+				break;
+
+			case TMOD_SCROLL:
+				RB_CalcScrollTexCoords( pStage->bundle[b].texMods[tm].translate,	//union scroll into translate
+										 ( float * ) tess.svars.texcoords[b] );
+				break;
+
+			case TMOD_SCALE:
+				RB_CalcScaleTexCoords( pStage->bundle[b].texMods[tm].translate,		//union scroll into translate
+									 ( float * ) tess.svars.texcoords[b] );
+				break;
+			
+			case TMOD_STRETCH:
+				RB_CalcStretchTexCoords( &pStage->bundle[b].texMods[tm].wave, 
+						               ( float * ) tess.svars.texcoords[b] );
+				break;
+
+			case TMOD_TRANSFORM:
+				RB_CalcTransformTexCoords( &pStage->bundle[b].texMods[tm],
+						                 ( float * ) tess.svars.texcoords[b] );
+				break;
+
+			case TMOD_ROTATE:
+				RB_CalcRotateTexCoords( pStage->bundle[b].texMods[tm].translate[0], //union rotateSpeed into translate[0]
+										( float * ) tess.svars.texcoords[b] );
+				break;
+
+			default:
+				Com_Error( ERR_DROP, "ERROR: unknown texmod '%d' in shader '%s'\n", pStage->bundle[b].texMods[tm].type, tess.shader->name );
+				break;
+			}
+		}
+	}
+}
+
+/*
+** RB_IterateStagesGeneric
+*/
+static vec4_t	GLFogOverrideColors[GLFOGOVERRIDE_MAX] =
+{
+	{ 0.0, 0.0, 0.0, 1.0 },	// GLFOGOVERRIDE_NONE
+	{ 0.0, 0.0, 0.0, 1.0 },	// GLFOGOVERRIDE_BLACK
+	{ 1.0, 1.0, 1.0, 1.0 }	// GLFOGOVERRIDE_WHITE
+};
+
+static const float logtestExp2 = (sqrt( -log( 1.0 / 255.0 ) ));
+extern bool tr_stencilled; //tr_backend.cpp
+static void RB_IterateStagesGeneric( shaderCommands_t *input )
+{
+	int stage;
+	bool	UseGLFog = false;
+	bool	FogColorChange = false;
+	fog_t	*fog = NULL;
+
+	if (tess.fogNum && tess.shader->fogPass && (tess.fogNum == tr.world->globalFog || tess.fogNum == tr.world->numfogs) 
+		&& r_drawfog->value == 2) 
+	{	// only gl fog global fog and the "special fog"
+		fog = tr.world->fogs + tess.fogNum;
+
+		if (tr.rangedFog)
+		{ //ranged fog, used for sniper scope
+			float fStart = fog->parms.depthForOpaque;
+			float fEnd = tr.distanceCull;
+
+			if (tr.rangedFog < 0.0f)
+			{ //special designer override
+				fStart = -tr.rangedFog;
+				fEnd = fog->parms.depthForOpaque;
+
+				if (fStart >= fEnd)
+				{
+					fStart = fEnd-1.0f;
+				}
+			}
+			else
+			{
+				//the greater tr.rangedFog is, the more fog we will get between the view point and cull distance
+				if ((tr.distanceCull-fStart) < tr.rangedFog)
+				{ //assure a minimum range between fog beginning and cutoff distance
+					fStart = tr.distanceCull-tr.rangedFog;
+
+					if (fStart < 16.0f)
+					{
+						fStart = 16.0f;
+					}
+				}
+			}
+
+			qglFogi(GL_FOG_MODE, GL_LINEAR);
+			qglFogf(GL_FOG_START, fStart);
+			qglFogf(GL_FOG_END, fEnd);
+		}
+		else
+		{
+			qglFogi(GL_FOG_MODE, GL_EXP2);
+			qglFogf(GL_FOG_DENSITY, logtestExp2 / fog->parms.depthForOpaque);
+		}
+
+		if ( g_bRenderGlowingObjects )
+		{
+			const float fogColor[3] = { 0.0f, 0.0f, 0.0f };
+			qglFogfv(GL_FOG_COLOR, fogColor );
+		}
+		else
+		{
+			qglFogfv(GL_FOG_COLOR, fog->parms.color);
+		}
+		
+		qglEnable(GL_FOG);
+		UseGLFog = true;
+	}
+
+	for ( stage = 0; stage < input->shader->numUnfoggedPasses; stage++ )
+	{
+		shaderStage_t *pStage = &tess.xstages[stage];
+		if ( !pStage->active )
+		{
+			assert(pStage->active);//wtf?
+			break;
+		}
+
+		// Reject this stage if it's not a glow stage but we are doing a glow pass.
+		if ( g_bRenderGlowingObjects && !pStage->glow )
+		{
+			continue;
+		}
+
+		int	stateBits = pStage->stateBits;
+		alphaGen_t	forceAlphaGen = (alphaGen_t)0;
+		colorGen_t	forceRGBGen = (colorGen_t)0;
+
+#ifdef _XBOX
+		tess.currentPass = stage;
+#endif
+
+		// allow skipping out to show just lightmaps during development
+#ifndef _XBOX
+		if ( stage && r_lightmap->integer)
+		{
+			if ( !( pStage->bundle[0].isLightmap || pStage->bundle[1].isLightmap || pStage->bundle[0].vertexLightmap ) )
+			{
+				continue;	// need to keep going in case the LM is in a later stage
+			} 
+			else
+			{
+				stateBits = (GLS_DSTBLEND_ZERO | GLS_SRCBLEND_ONE);	//we want to replace the prior stages with this LM, not blend
+			}
+		}
+#endif
+
+		if ( backEnd.currentEntity )
+		{
+			if ( backEnd.currentEntity->e.renderfx & RF_DISINTEGRATE1 )
+			{
+				// we want to be able to rip a hole in the thing being disintegrated, and by doing the depth-testing it avoids some kinds of artefacts, but will probably introduce others?
+				//	NOTE: adjusting the alphaFunc seems to help a bit
+				stateBits = GLS_SRCBLEND_SRC_ALPHA | GLS_DSTBLEND_ONE_MINUS_SRC_ALPHA | GLS_DEPTHMASK_TRUE | GLS_ATEST_GE_C0;
+			}
+
+			if ( backEnd.currentEntity->e.renderfx & RF_ALPHA_FADE )
+			{
+				if ( backEnd.currentEntity->e.shaderRGBA[3] < 255 )
+				{
+					stateBits = GLS_SRCBLEND_SRC_ALPHA | GLS_DSTBLEND_ONE_MINUS_SRC_ALPHA;
+					forceAlphaGen = AGEN_ENTITY;
+				}
+			}
+
+			if ( backEnd.currentEntity->e.renderfx & RF_RGB_TINT )
+			{//want to use RGBGen from ent
+				forceRGBGen = CGEN_ENTITY;
+			}
+		}
+
+		if (pStage->ss && pStage->ss->surfaceSpriteType)
+		{
+			// We check for surfacesprites AFTER drawing everything else
+			continue;
+		}
+
+		if (UseGLFog)
+		{
+			if (pStage->mGLFogColorOverride)
+			{
+				qglFogfv(GL_FOG_COLOR, GLFogOverrideColors[pStage->mGLFogColorOverride]);
+				FogColorChange = true;
+			}
+			else if (FogColorChange && fog)
+			{
+				FogColorChange = false;
+				qglFogfv(GL_FOG_COLOR, fog->parms.color);
+			}
+		}
+
+#ifdef _XBOX
+		qglDisable(GL_LIGHTING);
+#endif
+
+		if (!input->fading)
+		{ //this means ignore this, while we do a fade-out
+			ComputeColors( pStage, forceAlphaGen, forceRGBGen );
+		}
+		ComputeTexCoords( pStage );
+
+		if ( !setArraysOnce )
+		{
+			qglEnableClientState( GL_COLOR_ARRAY );
+			qglColorPointer( 4, GL_UNSIGNED_BYTE, 0, input->svars.colors );
+		}
+
+		if (pStage->bundle[0].isLightmap && r_debugStyle->integer >= 0)
+		{
+			if (pStage->lightmapStyle != r_debugStyle->integer)
+			{
+				if (pStage->lightmapStyle == 0)
+				{
+					GL_State( GLS_DSTBLEND_ZERO | GLS_SRCBLEND_ZERO );
+					R_DrawElements( input->numIndexes, input->indexes );
+				}
+				continue;
+			}
+		}
+
+#ifdef VV_LIGHTING
+		if(pStage->rgbGen == CGEN_LIGHTING_DIFFUSE ||
+			pStage->rgbGen == CGEN_LIGHTING_DIFFUSE_ENTITY)
+		{
+            qglEnableClientState( GL_NORMAL_ARRAY );
+			qglNormalPointer(GL_FLOAT, 16, tess.normal );
+		}
+
+		if(pStage->isSpecular)
+		{
+			qglEnableClientState( GL_NORMAL_ARRAY );
+			qglNormalPointer(GL_FLOAT, 16, tess.normal );
+			if(!tess.setTangents)
+                BuildTangentVectors();
+			qglTexCoordPointer( 2, GL_FLOAT, 0, input->svars.texcoords[0] );
+			R_BindAnimatedImage( &pStage->bundle[0] );
+			GL_State( stateBits );
+			glw_state->lightEffects->RenderSpecular();
+			qglDisableClientState( GL_NORMAL_ARRAY );
+			continue;
+		}
+		if(pStage->isEnvironment)
+		{
+			qglEnableClientState( GL_NORMAL_ARRAY );
+			qglNormalPointer( GL_FLOAT, 16, tess.normal );
+			R_BindAnimatedImage( &pStage->bundle[0] );
+			GL_State( stateBits );
+			glw_state->lightEffects->RenderEnvironment();
+			qglDisableClientState( GL_NORMAL_ARRAY );
+			continue;
+		}
+		if(pStage->isBumpMap)
+		{
+			qglEnableClientState( GL_NORMAL_ARRAY );
+			qglNormalPointer( GL_FLOAT, 16, tess.normal );
+			if(!tess.setTangents)
+                BuildTangentVectors();
+			GL_SelectTexture( 0 );
+			R_BindAnimatedImage( &pStage->bundle[0] );
+			GL_SelectTexture( 1 );
+			qglEnable( GL_TEXTURE_2D );
+			qglEnableClientState( GL_TEXTURE_COORD_ARRAY );
+			R_BindAnimatedImage( &pStage->bundle[1] );
+			GL_State( stateBits );
+			glw_state->lightEffects->RenderBump();
+			qglDisable( GL_TEXTURE_2D );
+			qglDisableClientState( GL_TEXTURE_COORD_ARRAY );
+			GL_SelectTexture( 0 );
+			qglDisableClientState( GL_NORMAL_ARRAY );
+			continue;
+		}
+#endif // VV_LIGHTING
+		//
+		// do multitexture
+		//
+		if ( pStage->bundle[1].image != 0 )
+		{
+			DrawMultitextured( input, stage );
+		}
+		else
+		{
+			static bool lStencilled = false;
+
+			if ( !setArraysOnce )
+			{
+				qglTexCoordPointer( 2, GL_FLOAT, 0, input->svars.texcoords[0] );
+			}
+
+			//
+			// set state
+			//
+			if ( (tess.shader == tr.distortionShader) || 
+				 (backEnd.currentEntity && (backEnd.currentEntity->e.renderfx & RF_DISTORTION)) )
+			{ //special distortion effect -rww
+				//tr.screenImage should have been set for this specific entity before we got in here.
+				GL_Bind( tr.screenImage );
+				GL_Cull(CT_TWO_SIDED);
+			}
+			else if ( pStage->bundle[0].vertexLightmap && ( r_vertexLight->integer ) && r_lightmap->integer )
+			{
+				GL_Bind( tr.whiteImage );
+			}
+			else 
+				R_BindAnimatedImage( &pStage->bundle[0] );
+
+			if (tess.shader == tr.distortionShader &&
+				glConfig.stencilBits >= 4)
+			{ //draw it to the stencil buffer!
+				tr_stencilled = true;
+				lStencilled = true;
+				qglEnable(GL_STENCIL_TEST);
+				qglStencilFunc(GL_ALWAYS, 1, 0xFFFFFFFF);
+				qglStencilOp(GL_KEEP, GL_KEEP, GL_INCR);
+				qglColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
+
+				//don't depthmask, don't blend.. don't do anything
+				GL_State(0);
+			}
+			else
+			{
+				GL_State( stateBits );
+			}
+
+			//
+			// draw
+			//
+			R_DrawElements( input->numIndexes, input->indexes );
+
+			if (lStencilled)
+			{ //re-enable the color buffer, disable stencil test
+				lStencilled = false;
+				qglDisable(GL_STENCIL_TEST);
+				qglColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
+			}
+		}
+
+#ifdef VV_LIGHTING
+		// Lighting may have been turned on above
+		qglDisable(GL_LIGHTING);
+		qglDisableClientState( GL_NORMAL_ARRAY );
+#endif
+	}
+	if (FogColorChange)
+	{
+		qglFogfv(GL_FOG_COLOR, fog->parms.color);
+	}
+}
+
+#ifdef _XBOX
+qboolean RB_IsCurrentShaderTransparent( void )
+{
+	if ( backEnd.currentEntity )
+	{
+		if ( backEnd.currentEntity->e.renderfx & RF_DISINTEGRATE1 )
+		{
+			return qtrue;
+		}
+		
+		if ( backEnd.currentEntity->e.renderfx & RF_ALPHA_FADE &&
+			backEnd.currentEntity->e.shaderRGBA[3] < 255 )
+		{
+			return qtrue;
+		}
+	}
+
+	for ( int stage = 0; stage < tess.shader->numUnfoggedPasses; stage++ )
+	{
+		if ( !(tess.xstages[stage].stateBits & (GLS_SRCBLEND_BITS|GLS_DSTBLEND_BITS)) ||
+			tess.xstages[stage].stateBits & GLS_ATEST_BITS )
+		{
+			return qfalse;
+		}
+	}
+
+	return qtrue;
+}
+#endif
+
+/*
+** RB_StageIteratorGeneric
+*/
+void RB_StageIteratorGeneric( void )
+{
+	shaderCommands_t *input;
+	int stage;
+
+	input = &tess;
+
+	RB_DeformTessGeometry();
+
+	//
+	// log this call
+	//
+#ifndef _XBOX
+	if ( r_logFile->integer ) 
+	{
+		// don't just call LogComment, or we will get
+		// a call to va() every frame!
+		GLimp_LogComment( va("--- RB_StageIteratorGeneric( %s ) ---\n", tess.shader->name) );
+	}
+#endif
+
+	//
+	// set face culling appropriately
+	//
+	GL_Cull( input->shader->cullType );
+
+	// set polygon offset if necessary
+	if ( input->shader->polygonOffset )
+	{
+		qglEnable( GL_POLYGON_OFFSET_FILL );
+		qglPolygonOffset( r_offsetFactor->value, r_offsetUnits->value );
+	}
+
+	//
+	// if there is only a single pass then we can enable color
+	// and texture arrays before we compile, otherwise we need
+	// to avoid compiling those arrays since they will change
+	// during multipass rendering
+	//
+	if ( tess.numPasses > 1 || input->shader->multitextureEnv )
+	{
+		setArraysOnce = qfalse;
+		qglDisableClientState (GL_COLOR_ARRAY);
+		qglDisableClientState (GL_TEXTURE_COORD_ARRAY);
+	}
+	else
+	{
+		setArraysOnce = qtrue;
+
+		qglEnableClientState( GL_COLOR_ARRAY);
+		qglColorPointer( 4, GL_UNSIGNED_BYTE, 0, tess.svars.colors );
+
+		qglEnableClientState( GL_TEXTURE_COORD_ARRAY);
+		qglTexCoordPointer( 2, GL_FLOAT, 0, tess.svars.texcoords[0] );
+	}
+
+	//
+	// lock XYZ
+	//
+	qglVertexPointer (3, GL_FLOAT, 16, input->xyz);	// padded for SIMD
+
+	if (qglLockArraysEXT)
+	{
+		qglLockArraysEXT(0, input->numVertexes);
+		GLimp_LogComment( "glLockArraysEXT\n" );
+	}
+
+	//
+	// enable color and texcoord arrays after the lock if necessary
+	//
+	if ( !setArraysOnce )
+	{
+		qglEnableClientState( GL_TEXTURE_COORD_ARRAY );
+		qglEnableClientState( GL_COLOR_ARRAY );
+	}
+
+	//
+	// call shader function
+	//
+	RB_IterateStagesGeneric( input );
+
+	// 
+	// now do any dynamic lighting needed
+	//
+	if ( tess.dlightBits && tess.shader->sort <= SS_OPAQUE
+		&& !(tess.shader->surfaceFlags & (SURF_NODLIGHT | SURF_SKY) ) ) {
+#ifdef VV_LIGHTING
+		qglEnableClientState( GL_NORMAL_ARRAY );
+		qglNormalPointer(GL_FLOAT, 16, tess.normal );
+		if(!tess.setTangents)
+            BuildTangentVectors();
+		glw_state->lightEffects->RenderDynamicLights();
+		qglDisableClientState( GL_NORMAL_ARRAY );
+#else
+		if (r_dlightStyle->integer>0)
+		{
+			ProjectDlightTexture2();
+		}
+		else
+		{
+			ProjectDlightTexture();
+		}
+#endif
+	}
+
+	//
+	// now do fog
+	//
+	if (tr.world && (tess.fogNum != tr.world->globalFog || r_drawfog->value != 2) && r_drawfog->value && tess.fogNum && tess.shader->fogPass)
+	{
+		RB_FogPass();
+	}
+
+	// 
+	// unlock arrays
+	//
+	if (qglUnlockArraysEXT) 
+	{
+		qglUnlockArraysEXT();
+		GLimp_LogComment( "glUnlockArraysEXT\n" );
+	}
+
+	//
+	// reset polygon offset
+	//
+	if ( input->shader->polygonOffset )
+	{
+		qglDisable( GL_POLYGON_OFFSET_FILL );
+	}
+
+	// Now check for surfacesprites.
+	if (r_surfaceSprites->integer)
+	{
+		for ( stage = 1; stage < tess.shader->numUnfoggedPasses; stage++ )
+		{
+			if (tess.xstages[stage].ss && tess.xstages[stage].ss->surfaceSpriteType)
+			{	// Draw the surfacesprite
+				RB_DrawSurfaceSprites( &tess.xstages[stage], input);
+			}
+		}
+	}
+
+	//don't disable the hardware fog til after we do surface sprites
+	if (r_drawfog->value == 2 && 
+		tess.fogNum && tess.shader->fogPass &&
+		(tess.fogNum == tr.world->globalFog || tess.fogNum == tr.world->numfogs))
+	{
+		qglDisable(GL_FOG);
+	}
+}
+
+
+/*
+** RB_EndSurface
+*/
+void RB_EndSurface( void ) {
+	shaderCommands_t *input;
+
+	input = &tess;
+
+	if (input->numIndexes == 0) {
+		return;
+	}
+
+	if (input->indexes[SHADER_MAX_INDEXES-1] != 0) {
+		Com_Error (ERR_DROP, "RB_EndSurface() - SHADER_MAX_INDEXES hit");
+	}	
+	if (input->xyz[SHADER_MAX_VERTEXES-1][0] != 0) {
+		Com_Error (ERR_DROP, "RB_EndSurface() - SHADER_MAX_VERTEXES hit");
+	}
+
+	if ( tess.shader == tr.shadowShader ) {
+		RB_ShadowTessEnd();
+		return;
+	}
+
+	// for debugging of sort order issues, stop rendering after a given sort value
+	if ( r_debugSort->integer && r_debugSort->integer < tess.shader->sort ) {
+		return;
+	}
+
+	if ( skyboxportal )
+	{
+		// world
+		if(!(backEnd.refdef.rdflags & RDF_SKYBOXPORTAL)) 
+		{
+			if(tess.currentStageIteratorFunc == RB_StageIteratorSky)
+			{	// don't process these tris at all
+				return;
+			}
+		}
+		// portal sky
+		else
+		{
+			if(!drawskyboxportal)
+			{
+				if( !(tess.currentStageIteratorFunc == RB_StageIteratorSky))
+				{	// /only/ process sky tris
+					return;
+				}
+			}
+		}
+	}
+
+	//
+	// update performance counters
+	//
+	if (!backEnd.projection2D)
+	{
+		backEnd.pc.c_shaders++;
+		backEnd.pc.c_vertexes += tess.numVertexes;
+		backEnd.pc.c_indexes += tess.numIndexes;
+		backEnd.pc.c_totalIndexes += tess.numIndexes * tess.numPasses;
+		if (tess.fogNum && tess.shader->fogPass && r_drawfog->value == 1)
+		{	// Fogging adds an additional pass
+			backEnd.pc.c_totalIndexes += tess.numIndexes;
+		}
+	}
+
+	//
+	// call off to shader specific tess end function
+	//
+	tess.currentStageIteratorFunc();
+
+#ifdef _XBOX
+	tess.currentPass = 0;
+#endif
+
+	//
+	// draw debugging stuff
+	//
+	if ( r_showtris->integer ) 
+	{
+		DrawTris (input);
+	}
+
+	if ( r_shownormals->integer ) {
+		DrawNormals (input);
+	}
+
+	// clear shader so we can tell we don't have any unclosed surfaces
+	tess.numIndexes = 0;
+
+	GLimp_LogComment( "----------\n" );
+}
+
diff --git a/code/renderer/tr_shade_calc.cpp b/code/renderer/tr_shade_calc.cpp
new file mode 100644
index 0000000..6af98d1
--- /dev/null
+++ b/code/renderer/tr_shade_calc.cpp
@@ -0,0 +1,1587 @@
+// tr_shade_calc.c
+
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+
+
+#include "tr_local.h"
+#define	WAVEVALUE( table, base, amplitude, phase, freq )  ((base) + table[ myftol( ( ( (phase) + backEnd.refdef.floatTime * (freq) ) * FUNCTABLE_SIZE ) ) & FUNCTABLE_MASK ] * (amplitude))
+
+static float *TableForFunc( genFunc_t func ) 
+{
+	switch ( func )
+	{
+	case GF_SIN:
+		return tr.sinTable;
+	case GF_TRIANGLE:
+		return tr.triangleTable;
+	case GF_SQUARE:
+		return tr.squareTable;
+	case GF_SAWTOOTH:
+		return tr.sawToothTable;
+	case GF_INVERSE_SAWTOOTH:
+		return tr.inverseSawToothTable;
+	case GF_NONE:
+	default:
+		break;
+	}
+
+	Com_Error( ERR_DROP, "TableForFunc called with invalid function '%d' in shader '%s'\n", func, tess.shader->name );
+	return NULL;
+}
+
+/*
+** EvalWaveForm
+**
+** Evaluates a given waveForm_t, referencing backEnd.refdef.time directly
+*/
+extern float GetNoiseTime( int t ); //from tr_noise, returns 0 to 2
+static float EvalWaveForm( const waveForm_t *wf ) 
+{
+	float	*table;
+
+	if ( wf->func == GF_NOISE ) {
+		return  ( wf->base + R_NoiseGet4f( 0, 0, 0, ( backEnd.refdef.floatTime + wf->phase ) * wf->frequency ) * wf->amplitude );
+	} else if (wf->func == GF_RAND) {
+		if( GetNoiseTime( backEnd.refdef.time + wf->phase ) <= wf->frequency ) {
+			return (wf->base + wf->amplitude);
+		} else {
+			return wf->base;
+		}
+	}
+	table = TableForFunc( wf->func );
+	return WAVEVALUE( table, wf->base, wf->amplitude, wf->phase, wf->frequency );
+}
+
+static float EvalWaveFormClamped( const waveForm_t *wf )
+{
+	float glow  = EvalWaveForm( wf );
+
+	if ( glow < 0 )
+	{
+		return 0;
+	}
+
+	if ( glow > 1 )
+	{
+		return 1;
+	}
+
+	return glow;
+}
+
+/*
+** RB_CalcStretchTexCoords
+*/
+void RB_CalcStretchTexCoords( const waveForm_t *wf, float *st )
+{
+	float p;
+	texModInfo_t tmi;
+
+	p = 1.0f / EvalWaveForm( wf );
+
+	tmi.matrix[0][0] = p;
+	tmi.matrix[1][0] = 0;
+	tmi.translate[0] = 0.5f - 0.5f * p;
+
+	tmi.matrix[0][1] = 0;
+	tmi.matrix[1][1] = p;
+	tmi.translate[1] = 0.5f - 0.5f * p;
+
+	RB_CalcTransformTexCoords( &tmi, st );
+}
+
+/*
+====================================================================
+
+DEFORMATIONS
+
+====================================================================
+*/
+
+/*
+========================
+RB_CalcDeformVertexes
+
+========================
+*/
+void RB_CalcDeformVertexes( deformStage_t *ds )
+{
+	int i;
+	vec3_t	offset;
+	float	scale;
+	float	*xyz = ( float * ) tess.xyz;
+	float	*normal = ( float * ) tess.normal;
+	float	*table;
+
+	if ( ds->deformationWave.frequency == 0 )
+	{
+		scale = EvalWaveForm( &ds->deformationWave );
+
+		for ( i = 0; i < tess.numVertexes; i++, xyz += 4, normal += 4 )
+		{
+			VectorScale( normal, scale, offset );
+			
+			xyz[0] += offset[0];
+			xyz[1] += offset[1];
+			xyz[2] += offset[2];
+		}
+	}
+	else
+	{
+		table = TableForFunc( ds->deformationWave.func );
+
+		for ( i = 0; i < tess.numVertexes; i++, xyz += 4, normal += 4 )
+		{
+			float off = ( xyz[0] + xyz[1] + xyz[2] ) * ds->deformationSpread;
+
+			scale = WAVEVALUE( table, ds->deformationWave.base, 
+				ds->deformationWave.amplitude,
+				ds->deformationWave.phase + off,
+				ds->deformationWave.frequency );
+
+			VectorScale( normal, scale, offset );
+			
+			xyz[0] += offset[0];
+			xyz[1] += offset[1];
+			xyz[2] += offset[2];
+		}
+	}
+}
+
+/*
+=========================
+RB_CalcDeformNormals
+
+Wiggle the normals for wavy environment mapping
+=========================
+*/
+void RB_CalcDeformNormals( deformStage_t *ds ) {
+	int i;
+	float	scale;
+	float	*xyz = ( float * ) tess.xyz;
+	float	*normal = ( float * ) tess.normal;
+
+	for ( i = 0; i < tess.numVertexes; i++, xyz += 4, normal += 4 ) {
+		scale = 0.98f;
+		scale = R_NoiseGet4f( xyz[0] * scale, xyz[1] * scale, xyz[2] * scale,
+			backEnd.refdef.floatTime * ds->deformationWave.frequency );
+		normal[ 0 ] += ds->deformationWave.amplitude * scale;
+
+		scale = 0.98f;
+		scale = R_NoiseGet4f( 100 + xyz[0] * scale, xyz[1] * scale, xyz[2] * scale,
+			backEnd.refdef.floatTime * ds->deformationWave.frequency );
+		normal[ 1 ] += ds->deformationWave.amplitude * scale;
+
+		scale = 0.98f;
+		scale = R_NoiseGet4f( 200 + xyz[0] * scale, xyz[1] * scale, xyz[2] * scale,
+			backEnd.refdef.floatTime * ds->deformationWave.frequency );
+		normal[ 2 ] += ds->deformationWave.amplitude * scale;
+
+		VectorNormalizeFast( normal );
+	}
+}
+
+/*
+========================
+RB_CalcBulgeVertexes
+
+========================
+*/
+void RB_CalcBulgeVertexes( deformStage_t *ds ) 
+{
+	int		i;
+	float	*xyz = ( float * ) tess.xyz;
+	float	*normal = ( float * ) tess.normal;
+	float	scale;
+
+	if ( ds->bulgeSpeed == 0.0f && ds->bulgeWidth == 0.0f )
+	{
+		// We don't have a speed and width, so just use height to expand uniformly
+		for ( i = 0; i < tess.numVertexes; i++, xyz += 4, normal += 4 ) 
+		{
+			xyz[0] += normal[0] * ds->bulgeHeight;
+			xyz[1] += normal[1] * ds->bulgeHeight;
+			xyz[2] += normal[2] * ds->bulgeHeight;
+		}
+	}
+	else
+	{
+		// I guess do some extra dumb stuff..the fact that it uses ST seems bad though because skin pages may be set up in certain ways that can cause
+		//	very noticeable seams on sufaces ( like on the huge ion_cannon ).
+		const float *st = ( const float * ) tess.texCoords[0];
+		float		now;
+		int			off;
+
+		now = backEnd.refdef.time * ds->bulgeSpeed * 0.001f;
+
+		for ( i = 0; i < tess.numVertexes; i++, xyz += 4, st += 2 * NUM_TEX_COORDS, normal += 4 ) 
+		{
+			off = (float)( FUNCTABLE_SIZE / (M_PI*2) ) * ( st[0] * ds->bulgeWidth + now );
+
+			scale = tr.sinTable[ off & FUNCTABLE_MASK ] * ds->bulgeHeight;
+				
+			xyz[0] += normal[0] * scale;
+			xyz[1] += normal[1] * scale;
+			xyz[2] += normal[2] * scale;
+		}
+	}
+}
+
+
+/*
+======================
+RB_CalcMoveVertexes
+
+A deformation that can move an entire surface along a wave path
+======================
+*/
+void RB_CalcMoveVertexes( deformStage_t *ds ) {
+	int			i;
+	float		*xyz;
+	float		*table;
+	float		scale;
+	vec3_t		offset;
+
+	table = TableForFunc( ds->deformationWave.func );
+
+	scale = WAVEVALUE( table, ds->deformationWave.base, 
+		ds->deformationWave.amplitude,
+		ds->deformationWave.phase,
+		ds->deformationWave.frequency );
+
+	VectorScale( ds->moveVector, scale, offset );
+
+	xyz = ( float * ) tess.xyz;
+	for ( i = 0; i < tess.numVertexes; i++, xyz += 4 ) {
+		VectorAdd( xyz, offset, xyz );
+	}
+}
+
+
+/*
+=============
+DeformText
+
+Change a polygon into a bunch of text polygons
+=============
+*/
+void DeformText( const char *text ) {
+	int		i;
+	vec3_t	origin, width, height;
+	int		len;
+	int		ch;
+	byte	color[4];
+	float	bottom, top;
+	vec3_t	mid;
+
+	height[0] = 0;
+	height[1] = 0;
+	height[2] = -1;
+	CrossProduct( tess.normal[0], height, width );
+
+	// find the midpoint of the box
+	VectorClear( mid );
+	bottom = WORLD_SIZE;	//999999;	// WORLD_SIZE instead of MAX_WORLD_COORD so guaranteed to be...
+	top = -WORLD_SIZE;		//-999999;	// ... outside the legal range.
+	for ( i = 0 ; i < 4 ; i++ ) {
+		VectorAdd( tess.xyz[i], mid, mid );
+		if ( tess.xyz[i][2] < bottom ) {
+			bottom = tess.xyz[i][2];
+		}
+		if ( tess.xyz[i][2] > top ) {
+			top = tess.xyz[i][2];
+		}
+	}
+	VectorScale( mid, 0.25f, origin );
+
+	// determine the individual character size
+	height[0] = 0;
+	height[1] = 0;
+	height[2] = ( top - bottom ) * 0.5f;
+
+	VectorScale( width, height[2] * -0.75f, width );
+
+	// determine the starting position
+	len = strlen( text );
+	VectorMA( origin, (len-1), width, origin );
+
+	// clear the shader indexes
+	tess.numIndexes = 0;
+	tess.numVertexes = 0;
+
+	color[0] = color[1] = color[2] = color[3] = 255;
+
+	// draw each character
+	for ( i = 0 ; i < len ; i++ ) {
+		ch = text[i];
+		ch &= 255;
+
+		if ( ch != ' ' ) {
+			int		row, col;
+			float	frow, fcol, size;
+
+			row = ch>>4;
+			col = ch&15;
+
+			frow = row*0.0625f;
+			fcol = col*0.0625f;
+			size = 0.0625f;
+
+			RB_AddQuadStampExt( origin, width, height, color, fcol, frow, fcol + size, frow + size );
+		}
+		VectorMA( origin, -2, width, origin );
+	}
+}
+
+/*
+==================
+GlobalVectorToLocal
+==================
+*/
+static void GlobalVectorToLocal( const vec3_t in, vec3_t out ) {
+	out[0] = DotProduct( in, backEnd.ori.axis[0] );
+	out[1] = DotProduct( in, backEnd.ori.axis[1] );
+	out[2] = DotProduct( in, backEnd.ori.axis[2] );
+}
+
+/*
+=====================
+AutospriteDeform
+
+Assuming all the triangles for this shader are independant
+quads, rebuild them as forward facing sprites
+=====================
+*/
+static void AutospriteDeform( void ) {
+	int		i;
+	int		oldVerts;
+	float	*xyz;
+	vec3_t	mid, delta;
+	float	radius;
+	vec3_t	left, up;
+	vec3_t	leftDir, upDir;
+
+	if ( tess.numVertexes & 3 ) {
+		Com_Error( ERR_DROP, "Autosprite shader %s had odd vertex count", tess.shader->name );
+	}
+	if ( tess.numIndexes != ( tess.numVertexes >> 2 ) * 6 ) {
+		Com_Error( ERR_DROP, "Autosprite shader %s had odd index count", tess.shader->name );
+	}
+
+	oldVerts = tess.numVertexes;
+	tess.numVertexes = 0;
+	tess.numIndexes = 0;
+
+	if ( backEnd.currentEntity != &tr.worldEntity ) {
+		GlobalVectorToLocal( backEnd.viewParms.or.axis[1], leftDir );
+		GlobalVectorToLocal( backEnd.viewParms.or.axis[2], upDir );
+	} else {
+		VectorCopy( backEnd.viewParms.or.axis[1], leftDir );
+		VectorCopy( backEnd.viewParms.or.axis[2], upDir );
+	}
+
+	for ( i = 0 ; i < oldVerts ; i+=4 ) {
+		// find the midpoint
+		xyz = tess.xyz[i];
+
+		mid[0] = 0.25f * (xyz[0] + xyz[4] + xyz[8] + xyz[12]);
+		mid[1] = 0.25f * (xyz[1] + xyz[5] + xyz[9] + xyz[13]);
+		mid[2] = 0.25f * (xyz[2] + xyz[6] + xyz[10] + xyz[14]);
+
+		VectorSubtract( xyz, mid, delta );
+		radius = VectorLength( delta ) * 0.707f;		// / sqrt(2)
+
+		VectorScale( leftDir, radius, left );
+		VectorScale( upDir, radius, up );
+
+		if ( backEnd.viewParms.isMirror ) {
+			VectorSubtract( vec3_origin, left, left );
+		}
+
+		RB_AddQuadStamp( mid, left, up, tess.vertexColors[i] );
+	}
+}
+
+
+/*
+=====================
+Autosprite2Deform
+
+Autosprite2 will pivot a rectangular quad along the center of its long axis
+=====================
+*/
+static const glIndex_t edgeVerts[6][2] = {
+	{ 0, 1 },
+	{ 0, 2 },
+	{ 0, 3 },
+	{ 1, 2 },
+	{ 1, 3 },
+	{ 2, 3 }
+};
+
+static void Autosprite2Deform( void ) {
+	int		i, j, k;
+	int		indexes;
+	float	*xyz;
+	vec3_t	forward;
+
+	if ( tess.numVertexes & 3 ) {
+		VID_Printf( PRINT_WARNING, "Autosprite shader %s had odd vertex count", tess.shader->name );
+	}
+	if ( tess.numIndexes != ( tess.numVertexes >> 2 ) * 6 ) {
+		VID_Printf( PRINT_WARNING, "Autosprite shader %s had odd index count", tess.shader->name );
+	}
+
+	if ( backEnd.currentEntity != &tr.worldEntity ) {
+		GlobalVectorToLocal( backEnd.viewParms.or.axis[0], forward );
+	} else {
+		VectorCopy( backEnd.viewParms.or.axis[0], forward );
+	}
+
+	// this is a lot of work for two triangles...
+	// we could precalculate a lot of it is an issue, but it would mess up
+	// the shader abstraction
+	for ( i = 0, indexes = 0 ; i < tess.numVertexes ; i+=4, indexes+=6 ) {
+		float	lengths[2];
+		int		nums[2];
+		vec3_t	mid[2];
+		vec3_t	major, minor;
+		float	*v1, *v2;
+
+		// find the midpoint
+		xyz = tess.xyz[i];
+
+		// identify the two shortest edges
+		nums[0] = nums[1] = 0;
+		lengths[0] = lengths[1] = WORLD_SIZE;//999999;	// ... instead of MAX_WORLD_COORD, so guaranteed to be outside legal range
+
+		for ( j = 0 ; j < 6 ; j++ ) {
+			float	l;
+			vec3_t	temp;
+
+			v1 = xyz + 4 * edgeVerts[j][0];
+			v2 = xyz + 4 * edgeVerts[j][1];
+
+			VectorSubtract( v1, v2, temp );
+			
+			l = DotProduct( temp, temp );
+			if ( l < lengths[0] ) {
+				nums[1] = nums[0];
+				lengths[1] = lengths[0];
+				nums[0] = j;
+				lengths[0] = l;
+			} else if ( l < lengths[1] ) {
+				nums[1] = j;
+				lengths[1] = l;
+			}
+		}
+
+		for ( j = 0 ; j < 2 ; j++ ) {
+			v1 = xyz + 4 * edgeVerts[nums[j]][0];
+			v2 = xyz + 4 * edgeVerts[nums[j]][1];
+
+			mid[j][0] = 0.5f * (v1[0] + v2[0]);
+			mid[j][1] = 0.5f * (v1[1] + v2[1]);
+			mid[j][2] = 0.5f * (v1[2] + v2[2]);
+		}
+
+		// find the vector of the major axis
+		VectorSubtract( mid[1], mid[0], major );
+
+		// cross this with the view direction to get minor axis
+		CrossProduct( major, forward, minor );
+		VectorNormalize( minor );
+		
+		// re-project the points
+		for ( j = 0 ; j < 2 ; j++ ) {
+			float	l;
+
+			v1 = xyz + 4 * edgeVerts[nums[j]][0];
+			v2 = xyz + 4 * edgeVerts[nums[j]][1];
+
+			l = 0.5 * sqrt( lengths[j] );
+			
+			// we need to see which direction this edge
+			// is used to determine direction of projection
+			for ( k = 0 ; k < 5 ; k++ ) {
+				if ( tess.indexes[ indexes + k ] == i + edgeVerts[nums[j]][0]
+					&& tess.indexes[ indexes + k + 1 ] == i + edgeVerts[nums[j]][1] ) {
+					break;
+				}
+			}
+
+			if ( k == 5 ) {
+				VectorMA( mid[j], l, minor, v1 );
+				VectorMA( mid[j], -l, minor, v2 );
+			} else {
+				VectorMA( mid[j], -l, minor, v1 );
+				VectorMA( mid[j], l, minor, v2 );
+			}
+		}
+	}
+}
+
+
+/*
+=====================
+RB_DeformTessGeometry
+
+=====================
+*/
+#pragma warning( disable : 4710 )	//vectorLength not inlined in AutospriteDeform which is auto-inlined in here
+void RB_DeformTessGeometry( void ) {
+	int		i;
+	deformStage_t	*ds;
+
+	for ( i = 0 ; i < tess.shader->numDeforms ; i++ ) {
+		ds = tess.shader->deforms[ i ];
+
+		switch ( ds->deformation ) {
+        case DEFORM_NONE:
+            break;
+		case DEFORM_NORMALS:
+			RB_CalcDeformNormals( ds );
+			break;
+		case DEFORM_WAVE:
+			RB_CalcDeformVertexes( ds );
+			break;
+		case DEFORM_BULGE:
+			RB_CalcBulgeVertexes( ds );
+			break;
+		case DEFORM_MOVE:
+			RB_CalcMoveVertexes( ds );
+			break;
+		case DEFORM_PROJECTION_SHADOW:
+			RB_ProjectionShadowDeform();
+			break;
+		case DEFORM_AUTOSPRITE:
+			AutospriteDeform();
+			break;
+		case DEFORM_AUTOSPRITE2:
+			Autosprite2Deform();
+			break;
+		case DEFORM_TEXT0:
+		case DEFORM_TEXT1:
+		case DEFORM_TEXT2:
+		case DEFORM_TEXT3:
+		case DEFORM_TEXT4:
+		case DEFORM_TEXT5:
+		case DEFORM_TEXT6:
+		case DEFORM_TEXT7:
+//			DeformText( backEnd.refdef.text[ds->deformation - DEFORM_TEXT0] );
+			DeformText( "Raven Software" );
+			break;
+		}
+	}
+}
+#pragma warning( default: 4710 )
+
+
+/*
+====================================================================
+
+COLORS
+
+====================================================================
+*/
+
+
+/*
+** RB_CalcColorFromEntity
+*/
+#ifdef _XBOX
+void RB_CalcColorFromEntity( DWORD *dstColors )
+{
+	int	i;
+	DWORD *pColors = dstColors;
+
+	if ( !backEnd.currentEntity )
+		return;
+
+	for ( i = 0; i < tess.numVertexes; i++, pColors++ )
+	{
+		*pColors = D3DCOLOR_RGBA((int)(backEnd.currentEntity->e.shaderRGBA[0]),
+								 (int)(backEnd.currentEntity->e.shaderRGBA[1]),
+								 (int)(backEnd.currentEntity->e.shaderRGBA[2]),
+								 (int)(backEnd.currentEntity->e.shaderRGBA[3]));
+	}
+}
+#else
+void RB_CalcColorFromEntity( unsigned char *dstColors )
+{
+	int	i;
+	int *pColors = ( int * ) dstColors;
+	int c;
+
+	if ( !backEnd.currentEntity )
+		return;
+
+	c = * ( int * ) backEnd.currentEntity->e.shaderRGBA;
+
+	for ( i = 0; i < tess.numVertexes; i++, pColors++ )
+	{
+		*pColors = c;
+	}
+}
+#endif // _XBOX
+
+/*
+** RB_CalcColorFromOneMinusEntity
+*/
+#ifdef _XBOX
+void RB_CalcColorFromOneMinusEntity( DWORD *dstColors )
+{
+	int	i;
+	DWORD *pColors = dstColors;
+	unsigned char invModulate[3];
+
+	if ( !backEnd.currentEntity )
+		return;
+
+	invModulate[0] = 255 - backEnd.currentEntity->e.shaderRGBA[0];
+	invModulate[1] = 255 - backEnd.currentEntity->e.shaderRGBA[1];
+	invModulate[2] = 255 - backEnd.currentEntity->e.shaderRGBA[2];
+	invModulate[3] = 255 - backEnd.currentEntity->e.shaderRGBA[3];	// this trashes alpha, but the AGEN block fixes it
+
+	for ( i = 0; i < tess.numVertexes; i++, pColors++ )
+	{
+		*pColors = D3DCOLOR_RGBA((int)invModulate[0],
+								 (int)invModulate[1],
+								 (int)invModulate[2],
+								 (int)invModulate[3]);
+	}
+}
+#else
+void RB_CalcColorFromOneMinusEntity( unsigned char *dstColors )
+{
+	int	i;
+	int *pColors = ( int * ) dstColors;
+	unsigned char invModulate[3];
+	int c;
+
+	if ( !backEnd.currentEntity )
+		return;
+
+	invModulate[0] = 255 - backEnd.currentEntity->e.shaderRGBA[0];
+	invModulate[1] = 255 - backEnd.currentEntity->e.shaderRGBA[1];
+	invModulate[2] = 255 - backEnd.currentEntity->e.shaderRGBA[2];
+	invModulate[3] = 255 - backEnd.currentEntity->e.shaderRGBA[3];	// this trashes alpha, but the AGEN block fixes it
+
+	c = * ( int * ) invModulate;
+
+	for ( i = 0; i < tess.numVertexes; i++, pColors++ )
+	{
+		*pColors = * ( int * ) invModulate;
+	}
+}
+#endif // _XBOX
+
+/*
+** RB_CalcAlphaFromEntity
+*/
+#ifdef _XBOX
+void RB_CalcAlphaFromEntity( DWORD *dstColors )
+{
+	int	i;
+
+	if ( !backEnd.currentEntity )
+		return;
+
+	for ( i = 0; i < tess.numVertexes; i++, dstColors ++ )
+	{
+		DWORD rgb = (DWORD)((*dstColors) & 0x00ffffff);
+		*dstColors = rgb | ((backEnd.currentEntity->e.shaderRGBA[3] & 0xff) << 24);
+	}
+}
+#else
+void RB_CalcAlphaFromEntity( unsigned char *dstColors )
+{
+	int	i;
+
+	if ( !backEnd.currentEntity )
+		return;
+
+	dstColors += 3;
+
+	for ( i = 0; i < tess.numVertexes; i++, dstColors += 4 )
+	{
+		*dstColors = backEnd.currentEntity->e.shaderRGBA[3];
+	}
+}
+#endif
+
+/*
+** RB_CalcAlphaFromOneMinusEntity
+*/
+#ifdef _XBOX
+void RB_CalcAlphaFromOneMinusEntity( DWORD *dstColors )
+{
+	int	i;
+
+	if ( !backEnd.currentEntity )
+		return;
+
+	for ( i = 0; i < tess.numVertexes; i++, dstColors ++ )
+	{
+		DWORD rgb = (DWORD)((*dstColors) & 0x00ffffff);
+		*dstColors = rgb | (((255 - backEnd.currentEntity->e.shaderRGBA[3]) & 0xff) << 24);
+	}
+}
+#else
+void RB_CalcAlphaFromOneMinusEntity( unsigned char *dstColors )
+{
+	int	i;
+
+	if ( !backEnd.currentEntity )
+		return;
+
+	dstColors += 3;
+
+	for ( i = 0; i < tess.numVertexes; i++, dstColors += 4 )
+	{
+		*dstColors = 0xff - backEnd.currentEntity->e.shaderRGBA[3];
+	}
+}
+#endif
+
+/*
+** RB_CalcWaveColor
+*/
+#ifdef _XBOX
+void RB_CalcWaveColor( const waveForm_t *wf, DWORD *dstColors )
+{
+	int i;
+	int v;
+	float glow;
+	DWORD *colors = dstColors;
+	byte	color[4];
+
+	if ( wf->func == GF_NOISE ) {
+		glow = wf->base + R_NoiseGet4f( 0, 0, 0, ( backEnd.refdef.floatTime + wf->phase ) * wf->frequency ) * wf->amplitude;
+	} else {
+		glow = EvalWaveForm( wf ) * tr.identityLight;
+	}
+
+	if ( glow < 0 ) {
+		glow = 0;
+	}
+	else if ( glow > 1 ) {
+		glow = 1;
+	}
+
+	v = myftol( 255 * glow );
+	color[0] = color[1] = color[2] = v;
+	color[3] = 255;
+
+	for ( i = 0; i < tess.numVertexes; i++, colors++ ) {
+		*colors = D3DCOLOR_RGBA(color[0], color[1], color[2], color[3]);
+	}
+}
+#else // _XBOX
+void RB_CalcWaveColor( const waveForm_t *wf, unsigned char *dstColors )
+{
+	int i;
+	int v;
+	float glow;
+	int *colors = ( int * ) dstColors;
+	byte	color[4];
+	
+	if ( wf->func == GF_NOISE ) {
+		glow = wf->base + R_NoiseGet4f( 0, 0, 0, ( backEnd.refdef.floatTime + wf->phase ) * wf->frequency ) * wf->amplitude;
+	} else {
+		glow = EvalWaveForm( wf ) * tr.identityLight;
+	}
+	
+	if ( glow < 0 ) {
+		glow = 0;
+	}
+	else if ( glow > 1 ) {
+		glow = 1;
+	}
+
+	v = myftol( 255 * glow );
+	color[0] = color[1] = color[2] = v;
+	color[3] = 255;
+	v = *(int *)color;
+	
+	for ( i = 0; i < tess.numVertexes; i++, colors++ ) {
+		*colors = v;
+	}
+}
+#endif // _XBOX
+
+/*
+** RB_CalcWaveAlpha
+*/
+#ifdef _XBOX
+void RB_CalcWaveAlpha( const waveForm_t *wf, DWORD *dstColors )
+{
+	int i;
+	int v;
+	float glow;
+
+	glow = EvalWaveFormClamped( wf );
+
+	v = 255 * glow;
+
+	for ( i = 0; i < tess.numVertexes; i++, dstColors ++ )
+	{
+		DWORD rgb = (DWORD)((*dstColors) & 0x00ffffff);
+		*dstColors = rgb | ((v & 0xff) << 24);
+	}
+}
+#else
+void RB_CalcWaveAlpha( const waveForm_t *wf, unsigned char *dstColors )
+{
+	int i;
+	int v;
+	float glow;
+	
+	glow = EvalWaveFormClamped( wf );
+
+	v = 255 * glow;
+
+	for ( i = 0; i < tess.numVertexes; i++, dstColors += 4 )
+	{
+		dstColors[3] = v;
+	}
+}
+#endif
+
+/*
+** RB_CalcModulateColorsByFog
+*/
+#ifdef _XBOX
+void RB_CalcModulateColorsByFog( DWORD *colors ) {
+
+}
+#else
+void RB_CalcModulateColorsByFog( unsigned char *colors ) {
+	int i;
+	float	texCoords[SHADER_MAX_VERTEXES][2];
+
+	// calculate texcoords so we can derive density
+	// this is not wasted, because it would only have
+	// been previously called if the surface was opaque
+	RB_CalcFogTexCoords( texCoords[0] );
+
+	for ( i = 0; i < tess.numVertexes; i++, colors += 4 ) {
+		float f = 1.0 - R_FogFactor( texCoords[i][0], texCoords[i][1] );
+		colors[0] *= f;
+		colors[1] *= f;
+		colors[2] *= f;
+	}
+}
+#endif
+
+/*
+** RB_CalcModulateAlphasByFog
+*/
+#ifdef _XBOX
+void RB_CalcModulateAlphasByFog( DWORD *colors ) {
+
+}
+#else
+void RB_CalcModulateAlphasByFog( unsigned char *colors ) {
+	int i;
+	float	texCoords[SHADER_MAX_VERTEXES][2];
+
+	// calculate texcoords so we can derive density
+	// this is not wasted, because it would only have
+	// been previously called if the surface was opaque
+	RB_CalcFogTexCoords( texCoords[0] );
+
+	for ( i = 0; i < tess.numVertexes; i++, colors += 4 ) {
+		float f = 1.0 - R_FogFactor( texCoords[i][0], texCoords[i][1] );
+		colors[3] *= f;
+	}
+}
+#endif
+
+/*
+** RB_CalcModulateRGBAsByFog
+*/
+#ifdef _XBOX
+void RB_CalcModulateRGBAsByFog( DWORD *colors ) {
+	
+}
+#else
+void RB_CalcModulateRGBAsByFog( unsigned char *colors ) {
+	int i;
+	float	texCoords[SHADER_MAX_VERTEXES][2];
+
+	// calculate texcoords so we can derive density
+	// this is not wasted, because it would only have
+	// been previously called if the surface was opaque
+	RB_CalcFogTexCoords( texCoords[0] );
+
+	for ( i = 0; i < tess.numVertexes; i++, colors += 4 ) {
+		float f = 1.0 - R_FogFactor( texCoords[i][0], texCoords[i][1] );
+		colors[0] *= f;
+		colors[1] *= f;
+		colors[2] *= f;
+		colors[3] *= f;
+	}
+}
+#endif
+
+
+/*
+====================================================================
+
+TEX COORDS
+
+====================================================================
+*/
+
+/*
+========================
+RB_CalcFogTexCoords
+
+To do the clipped fog plane really correctly, we should use
+projected textures, but I don't trust the drivers and it
+doesn't fit our shader data.
+========================
+*/
+
+void RB_CalcFogTexCoords( float *st ) {
+	int			i;
+	float		*v;
+	float		s, t;
+	float		eyeT;
+	qboolean	eyeOutside;
+	fog_t		*fog;
+	vec3_t		localVec;
+	vec4_t		fogDistanceVector, fogDepthVector;
+
+	fog = tr.world->fogs + tess.fogNum;
+
+	// all fogging distance is based on world Z units
+	VectorSubtract( backEnd.ori.origin, backEnd.viewParms.or.origin, localVec );
+#ifdef _XBOX
+	fogDistanceVector[0] = backEnd.ori.modelMatrix[2];
+	fogDistanceVector[1] = backEnd.ori.modelMatrix[6];
+	fogDistanceVector[2] = backEnd.ori.modelMatrix[10];
+#else
+	fogDistanceVector[0] = -backEnd.ori.modelMatrix[2];
+	fogDistanceVector[1] = -backEnd.ori.modelMatrix[6];
+	fogDistanceVector[2] = -backEnd.ori.modelMatrix[10];
+#endif
+	fogDistanceVector[3] = DotProduct( localVec, backEnd.viewParms.or.axis[0] );
+
+	// scale the fog vectors based on the fog's thickness
+	fogDistanceVector[0] *= fog->tcScale;
+	fogDistanceVector[1] *= fog->tcScale;
+	fogDistanceVector[2] *= fog->tcScale;
+	fogDistanceVector[3] *= fog->tcScale;
+
+	// rotate the gradient vector for this orientation
+	if ( fog->hasSurface ) {
+		fogDepthVector[0] = fog->surface[0] * backEnd.ori.axis[0][0] + 
+			fog->surface[1] * backEnd.ori.axis[0][1] + fog->surface[2] * backEnd.ori.axis[0][2];
+		fogDepthVector[1] = fog->surface[0] * backEnd.ori.axis[1][0] + 
+			fog->surface[1] * backEnd.ori.axis[1][1] + fog->surface[2] * backEnd.ori.axis[1][2];
+		fogDepthVector[2] = fog->surface[0] * backEnd.ori.axis[2][0] + 
+			fog->surface[1] * backEnd.ori.axis[2][1] + fog->surface[2] * backEnd.ori.axis[2][2];
+		fogDepthVector[3] = -fog->surface[3] + DotProduct( backEnd.ori.origin, fog->surface );
+
+		eyeT = DotProduct( backEnd.ori.viewOrigin, fogDepthVector ) + fogDepthVector[3];
+	} else {
+		eyeT = 1;	// non-surface fog always has eye inside
+		fogDepthVector[0] = fogDepthVector[1] = fogDepthVector[2] = 0.0f;
+		fogDepthVector[3] = 1.0f;
+	}
+
+	// see if the viewpoint is outside
+	// this is needed for clipping distance even for constant fog
+
+	if ( eyeT < 0 ) {
+		eyeOutside = qtrue;
+	} else {
+		eyeOutside = qfalse;
+	}
+
+	fogDistanceVector[3] += 1.0/512;
+
+	// calculate density for each point
+	for (i = 0, v = tess.xyz[0] ; i < tess.numVertexes ; i++, v += 4) {
+		// calculate the length in fog
+		s = DotProduct( v, fogDistanceVector ) + fogDistanceVector[3];
+		t = DotProduct( v, fogDepthVector ) + fogDepthVector[3];
+
+		// partially clipped fogs use the T axis		
+		if ( eyeOutside ) {
+			if ( t < 1.0 ) {
+				t = 1.0/32;	// point is outside, so no fogging
+			} else {
+				t = 1.0/32 + 30.0/32 * t / ( t - eyeT );	// cut the distance at the fog plane
+			}
+		} else {
+			if ( t < 0 ) {
+				t = 1.0/32;	// point is outside, so no fogging
+			} else {
+				t = 31.0/32;
+			}
+		}
+
+		st[0] = s;
+		st[1] = t;
+		st += 2;
+	}
+}
+
+
+/*
+** RB_CalcEnvironmentTexCoords
+*/
+void RB_CalcEnvironmentTexCoords( float *st ) 
+{
+	int			i;
+	float		*v, *normal;
+	vec3_t		viewer;
+	float		d;
+
+	v = tess.xyz[0];
+	normal = tess.normal[0];
+
+	if (backEnd.currentEntity && backEnd.currentEntity->e.renderfx&RF_FIRST_PERSON)	//this is a view model so we must use world lights instead of vieworg
+	{
+		for (i = 0 ; i < tess.numVertexes ; i++, v += 4, normal += 4, st += 2 ) 
+		{
+			d = DotProduct (normal, backEnd.currentEntity->lightDir);
+			st[0] = normal[0]*d - backEnd.currentEntity->lightDir[0];
+			st[1] = normal[1]*d - backEnd.currentEntity->lightDir[1];
+		}
+	} else {	//the normal way
+		for (i = 0 ; i < tess.numVertexes ; i++, v += 4, normal += 4, st += 2 ) 
+		{
+			VectorSubtract (backEnd.ori.viewOrigin, v, viewer);
+			VectorNormalizeFast (viewer);
+
+			d = DotProduct (normal, viewer);
+			st[0] = normal[0]*d - 0.5*viewer[0];
+			st[1] = normal[1]*d - 0.5*viewer[1];
+		}
+	}
+}
+
+/*
+** RB_CalcTurbulentTexCoords
+*/
+void RB_CalcTurbulentTexCoords( const waveForm_t *wf, float *st )
+{
+	int i;
+	float now;
+
+	now = ( wf->phase + backEnd.refdef.floatTime * wf->frequency );
+
+	for ( i = 0; i < tess.numVertexes; i++, st += 2 )
+	{
+		float s = st[0];
+		float t = st[1];
+
+		st[0] = s + tr.sinTable[ ( ( int ) ( ( ( tess.xyz[i][0] + tess.xyz[i][2] )* 1.0/128 * 0.125 + now ) * FUNCTABLE_SIZE ) ) & ( FUNCTABLE_MASK ) ] * wf->amplitude;
+		st[1] = t + tr.sinTable[ ( ( int ) ( ( tess.xyz[i][1] * 1.0/128 * 0.125 + now ) * FUNCTABLE_SIZE ) ) & ( FUNCTABLE_MASK ) ] * wf->amplitude;
+	}
+}
+
+/*
+** RB_CalcScaleTexCoords
+*/
+void RB_CalcScaleTexCoords( const float scale[2], float *st )
+{
+	int i;
+
+	for ( i = 0; i < tess.numVertexes; i++, st += 2 )
+	{
+		st[0] *= scale[0];
+		st[1] *= scale[1];
+	}
+}
+
+/*
+** RB_CalcScrollTexCoords
+*/
+void RB_CalcScrollTexCoords( const float scrollSpeed[2], float *st )
+{
+	int i;
+	float timeScale = backEnd.refdef.floatTime;
+	float adjustedScrollS, adjustedScrollT;
+
+	adjustedScrollS = scrollSpeed[0] * timeScale;
+	adjustedScrollT = scrollSpeed[1] * timeScale;
+
+	// clamp so coordinates don't continuously get larger, causing problems
+	// with hardware limits
+	adjustedScrollS = adjustedScrollS - floor( adjustedScrollS );
+	adjustedScrollT = adjustedScrollT - floor( adjustedScrollT );
+
+	for ( i = 0; i < tess.numVertexes; i++, st += 2 )
+	{
+		st[0] += adjustedScrollS;
+		st[1] += adjustedScrollT;
+	}
+}
+
+/*
+** RB_CalcTransformTexCoords
+*/
+void RB_CalcTransformTexCoords( const texModInfo_t *tmi, float *st  )
+{
+	int i;
+
+	for ( i = 0; i < tess.numVertexes; i++, st += 2 )
+	{
+		float s = st[0];
+		float t = st[1];
+
+		st[0] = s * tmi->matrix[0][0] + t * tmi->matrix[1][0] + tmi->translate[0];
+		st[1] = s * tmi->matrix[0][1] + t * tmi->matrix[1][1] + tmi->translate[1];
+	}
+}
+
+
+void RB_CalcRotateTexCoords( float degsPerSecond, float *st )
+{
+	float timeScale = backEnd.refdef.floatTime;
+	float degs;
+	int index;
+	float sinValue, cosValue;
+	texModInfo_t tmi;
+	
+	degs = -degsPerSecond * timeScale;
+	index = degs * ( FUNCTABLE_SIZE / 360.0f );
+
+	sinValue = tr.sinTable[ index & FUNCTABLE_MASK ];
+	cosValue = tr.sinTable[ ( index + FUNCTABLE_SIZE / 4 ) & FUNCTABLE_MASK ];
+
+	tmi.matrix[0][0] = cosValue;
+	tmi.matrix[1][0] = -sinValue;
+	tmi.translate[0] = 0.5 - 0.5 * cosValue + 0.5 * sinValue;
+
+	tmi.matrix[0][1] = sinValue;
+	tmi.matrix[1][1] = cosValue;
+	tmi.translate[1] = 0.5 - 0.5 * sinValue - 0.5 * cosValue;
+
+	RB_CalcTransformTexCoords( &tmi, st );
+}
+
+
+
+
+
+
+#if id386 && !(defined __linux__ && defined __i386__)
+#pragma warning(disable: 4035)
+long myftol( float f ) {
+	static int tmp;
+	__asm fld f
+	__asm fistp tmp
+	__asm mov eax, tmp
+}
+#pragma warning(default: 4035)
+#endif
+
+/*
+** RB_CalcSpecularAlpha
+**
+** Calculates specular coefficient and places it in the alpha channel
+*/
+vec3_t lightOrigin = { -960, 1980, 96 };		// FIXME: track dynamically
+
+#ifdef _XBOX
+void RB_CalcSpecularAlpha( DWORD *alphas ) {
+	int			i;
+	float		*v, *normal;
+	vec3_t		viewer,  reflected;
+	float		l, d;
+	int			a;
+	vec3_t		lightDir;
+	int			numVertexes;
+
+	v = tess.xyz[0];
+	normal = tess.normal[0];
+
+	numVertexes = tess.numVertexes;
+	for (i = 0 ; i < numVertexes ; i++, v += 4, normal += 4, alphas ++) {
+		float ilength;
+
+		if (backEnd.currentEntity && 
+			(backEnd.currentEntity->e.hModel||backEnd.currentEntity->e.ghoul2) )	//this is a model so we can use world lights instead fake light
+		{
+			VectorCopy (backEnd.currentEntity->lightDir, lightDir);
+		} else {
+			VectorSubtract( lightOrigin, v, lightDir );
+			VectorNormalizeFast( lightDir );
+		}
+		// calculate the specular color
+		d = 2 * DotProduct (normal, lightDir);
+
+		// we don't optimize for the d < 0 case since this tends to
+		// cause visual artifacts such as faceted "snapping"
+		reflected[0] = normal[0]*d - lightDir[0];
+		reflected[1] = normal[1]*d - lightDir[1];
+		reflected[2] = normal[2]*d - lightDir[2];
+
+		VectorSubtract (backEnd.ori.viewOrigin, v, viewer);
+		ilength = Q_rsqrt( DotProduct( viewer, viewer ) );
+		l = DotProduct (reflected, viewer);
+		l *= ilength;
+
+		if (l < 0) {
+			a = 0;
+		} else {
+			l = l*l;
+			l = l*l;
+			a = l * 255;
+			if (a > 255) {
+				a = 255;
+			}
+		}
+		DWORD rgb = (DWORD)((*alphas) & 0x00ffffff);
+
+		*alphas = rgb | (a & 0xff) << 24;
+	}
+}
+#else // _XBOX
+void RB_CalcSpecularAlpha( unsigned char *alphas ) {
+	int			i;
+	float		*v, *normal;
+	vec3_t		viewer,  reflected;
+	float		l, d;
+	int			b;
+	vec3_t		lightDir;
+	int			numVertexes;
+
+	v = tess.xyz[0];
+	normal = tess.normal[0];
+
+	alphas += 3;
+
+	numVertexes = tess.numVertexes;
+	for (i = 0 ; i < numVertexes ; i++, v += 4, normal += 4, alphas += 4) {
+		float ilength;
+
+		if (backEnd.currentEntity && 
+			(backEnd.currentEntity->e.hModel||backEnd.currentEntity->e.ghoul2) )	//this is a model so we can use world lights instead fake light
+		{
+			VectorCopy (backEnd.currentEntity->lightDir, lightDir);
+		} else {
+			VectorSubtract( lightOrigin, v, lightDir );
+			VectorNormalizeFast( lightDir );
+		}
+		// calculate the specular color
+		d = 2 * DotProduct (normal, lightDir);
+
+		// we don't optimize for the d < 0 case since this tends to
+		// cause visual artifacts such as faceted "snapping"
+		reflected[0] = normal[0]*d - lightDir[0];
+		reflected[1] = normal[1]*d - lightDir[1];
+		reflected[2] = normal[2]*d - lightDir[2];
+
+		VectorSubtract (backEnd.ori.viewOrigin, v, viewer);
+		ilength = Q_rsqrt( DotProduct( viewer, viewer ) );
+		l = DotProduct (reflected, viewer);
+		l *= ilength;
+
+		if (l < 0) {
+			b = 0;
+		} else {
+			l = l*l;
+			l = l*l;
+			b = l * 255;
+			if (b > 255) {
+				b = 255;
+			}
+		}
+
+		*alphas = b;
+	}
+}
+#endif
+
+/*
+** RB_CalcDiffuseColor
+**
+** The basic vertex lighting calc
+*/
+void RB_CalcDiffuseColor( unsigned char *colors )
+{
+	int				i, j;
+	float			*v, *normal;
+	float			incoming;
+	trRefEntity_t	*ent;
+	int				ambientLightInt;
+	vec3_t			ambientLight;
+	vec3_t			lightDir;
+	vec3_t			directedLight;
+	int				numVertexes;
+
+	ent = backEnd.currentEntity;
+	ambientLightInt = ent->ambientLightInt;
+	VectorCopy( ent->ambientLight, ambientLight );
+	VectorCopy( ent->directedLight, directedLight );
+	VectorCopy( ent->lightDir, lightDir );
+
+	v = tess.xyz[0];
+	normal = tess.normal[0];
+
+	numVertexes = tess.numVertexes;
+
+	for ( i = 0 ; i < numVertexes ; i++, v += 4, normal += 4)
+	{
+		incoming = DotProduct (normal, lightDir);
+		if ( incoming <= 0 ) {
+			*(int *)&colors[i*4] = ambientLightInt;
+			continue;
+		} 
+		j = myftol( ambientLight[0] + incoming * directedLight[0] );
+		if ( j > 255 ) {
+			j = 255;
+		}
+		colors[i*4+0] = j;
+
+		j = myftol( ambientLight[1] + incoming * directedLight[1] );
+		if ( j > 255 ) {
+			j = 255;
+		}
+		colors[i*4+1] = j;
+
+		j = myftol( ambientLight[2] + incoming * directedLight[2] );
+		if ( j > 255 ) {
+			j = 255;
+		}
+		colors[i*4+2] = j;
+
+		colors[i*4+3] = 255;
+	}
+}
+
+/*
+** RB_CalcDiffuseColorEntity
+**
+** The basic vertex lighting calc * Entity Color
+*/
+void RB_CalcDiffuseEntityColor( unsigned char *colors )
+{
+	int				i;
+	float			*v, *normal;
+	float			incoming;
+	trRefEntity_t	*ent;
+	int				ambientLightInt;
+	vec3_t			ambientLight;
+	vec3_t			lightDir;
+	vec3_t			directedLight;
+	int				numVertexes;
+	float			j,r,g,b;
+
+	if ( !backEnd.currentEntity )
+	{//error, use the normal lighting
+		RB_CalcDiffuseColor(colors);
+	}
+
+	ent = backEnd.currentEntity;
+	VectorCopy( ent->ambientLight, ambientLight );
+	VectorCopy( ent->directedLight, directedLight );
+	VectorCopy( ent->lightDir, lightDir );
+
+	r = backEnd.currentEntity->e.shaderRGBA[0]/255.0f;
+	g = backEnd.currentEntity->e.shaderRGBA[1]/255.0f;
+	b = backEnd.currentEntity->e.shaderRGBA[2]/255.0f;
+
+	((byte *)&ambientLightInt)[0] = myftol( r*ent->ambientLight[0] );
+	((byte *)&ambientLightInt)[1] = myftol( g*ent->ambientLight[1] );
+	((byte *)&ambientLightInt)[2] = myftol( b*ent->ambientLight[2] );
+	((byte *)&ambientLightInt)[3] = backEnd.currentEntity->e.shaderRGBA[3];
+
+	v = tess.xyz[0];
+	normal = tess.normal[0];
+
+	numVertexes = tess.numVertexes;
+
+	for ( i = 0 ; i < numVertexes ; i++, v += 4, normal += 4)
+	{
+		incoming = DotProduct (normal, lightDir);
+		if ( incoming <= 0 ) {
+			*(int *)&colors[i*4] = ambientLightInt;
+			continue;
+		} 
+		j = ( ambientLight[0] + incoming * directedLight[0] );
+		if ( j > 255 ) {
+			j = 255;
+		}
+		colors[i*4+0] = myftol(j*r);
+
+		j = ( ambientLight[1] + incoming * directedLight[1] );
+		if ( j > 255 ) {
+			j = 255;
+		}
+		colors[i*4+1] = myftol(j*g);
+
+		j = ( ambientLight[2] + incoming * directedLight[2] );
+		if ( j > 255 ) {
+			j = 255;
+		}
+		colors[i*4+2] = myftol(j*b);
+
+		colors[i*4+3] = backEnd.currentEntity->e.shaderRGBA[3];
+	}
+}
+
+//---------------------------------------------------------
+void RB_CalcDisintegrateColors( unsigned char *colors, colorGen_t rgbGen )
+{
+	int			i, numVertexes;
+	float		dis, threshold;
+	float		*v;
+	vec3_t		temp;
+	refEntity_t	*ent;
+
+	ent = &backEnd.currentEntity->e;
+	v = tess.xyz[0];
+
+	// calculate the burn threshold at the given time, anything that passes the threshold will get burnt
+	threshold = (backEnd.refdef.time - ent->endTime) * 0.045f; // endTime is really the start time, maybe I should just use a completely meaningless substitute?
+
+	numVertexes = tess.numVertexes;
+
+	if ( ent->renderfx & RF_DISINTEGRATE1 )
+	{
+		// this handles the blacken and fading out of the regular player model
+		for ( i = 0 ; i < numVertexes ; i++, v += 4 )
+		{
+			VectorSubtract( backEnd.currentEntity->e.oldorigin, v, temp );
+
+			dis = VectorLengthSquared( temp );
+
+			if ( dis < threshold * threshold )
+			{
+				// completely disintegrated
+				colors[i*4+3] = 0x00;
+			}
+			else if ( dis < threshold * threshold + 60 )
+			{
+				// blacken before fading out
+				colors[i*4+0] = 0x0;
+				colors[i*4+1] = 0x0;
+				colors[i*4+2] = 0x0;
+				colors[i*4+3] = 0xff;
+			}
+			else if ( dis < threshold * threshold + 150 )
+			{
+				// darken more
+				if ( rgbGen == CGEN_LIGHTING_DIFFUSE_ENTITY )
+				{
+					colors[i*4+0] = backEnd.currentEntity->e.shaderRGBA[0]*0x6f/255.0f;
+					colors[i*4+1] = backEnd.currentEntity->e.shaderRGBA[1]*0x6f/255.0f;
+					colors[i*4+2] = backEnd.currentEntity->e.shaderRGBA[2]*0x6f/255.0f;
+				}
+				else
+				{
+					colors[i*4+0] = 0x6f;
+					colors[i*4+1] = 0x6f;
+					colors[i*4+2] = 0x6f;
+				}
+				colors[i*4+3] = 0xff;
+			}
+			else if ( dis < threshold * threshold + 180 )
+			{
+				// darken at edge of burn
+				if ( rgbGen == CGEN_LIGHTING_DIFFUSE_ENTITY )
+				{
+					colors[i*4+0] = backEnd.currentEntity->e.shaderRGBA[0]*0xaf/255.0f;
+					colors[i*4+1] = backEnd.currentEntity->e.shaderRGBA[1]*0xaf/255.0f;
+					colors[i*4+2] = backEnd.currentEntity->e.shaderRGBA[2]*0xaf/255.0f;
+				}
+				else
+				{
+					colors[i*4+0] = 0xaf;
+					colors[i*4+1] = 0xaf;
+					colors[i*4+2] = 0xaf;
+				}
+				colors[i*4+3] = 0xff;
+			}
+			else
+			{
+				// not burning at all yet
+				if ( rgbGen == CGEN_LIGHTING_DIFFUSE_ENTITY )
+				{
+					colors[i*4+0] = backEnd.currentEntity->e.shaderRGBA[0];
+					colors[i*4+1] = backEnd.currentEntity->e.shaderRGBA[1];
+					colors[i*4+2] = backEnd.currentEntity->e.shaderRGBA[2];
+				}
+				else
+				{
+					colors[i*4+0] = 0xff;
+					colors[i*4+1] = 0xff;
+					colors[i*4+2] = 0xff;
+				}
+				colors[i*4+3] = 0xff;
+			}
+		}
+	}
+	else if ( ent->renderfx & RF_DISINTEGRATE2 )
+	{
+		// this handles the glowing, burning bit that scales away from the model
+		for ( i = 0 ; i < numVertexes ; i++, v += 4 )
+		{
+			VectorSubtract( backEnd.currentEntity->e.oldorigin, v, temp );
+
+			dis = VectorLengthSquared( temp );
+
+			if ( dis < threshold * threshold )
+			{
+				// done burning
+				colors[i*4+0] = 0x00;
+				colors[i*4+1] = 0x00;
+				colors[i*4+2] = 0x00;
+				colors[i*4+3] = 0x00;
+			}
+			else
+			{
+				// still full burn
+				colors[i*4+0] = 0xff;
+				colors[i*4+1] = 0xff;
+				colors[i*4+2] = 0xff;
+				colors[i*4+3] = 0xff;
+			}
+		}
+	}
+}
+
+//---------------------------------------------------------
+void RB_CalcDisintegrateVertDeform( void )
+{
+	float	*xyz = ( float * ) tess.xyz;
+	float	*normal = ( float * ) tess.normal;
+	float	scale;
+	vec3_t	temp;
+
+	if ( backEnd.currentEntity->e.renderfx & RF_DISINTEGRATE2 )
+	{
+		float	threshold = (backEnd.refdef.time - backEnd.currentEntity->e.endTime) * 0.045f;
+
+		for ( int i = 0; i < tess.numVertexes; i++, xyz += 4, normal += 4 ) 
+		{
+			VectorSubtract( backEnd.currentEntity->e.oldorigin, xyz, temp );
+
+			scale = VectorLengthSquared( temp );
+
+			if ( scale < threshold * threshold )
+			{
+				xyz[0] += normal[0] * 2.0f;
+				xyz[1] += normal[1] * 2.0f;
+				xyz[2] += normal[2] * 0.5f;
+			}
+			else if ( scale < threshold * threshold + 50 )
+			{
+				xyz[0] += normal[0] * 1.0f;
+				xyz[1] += normal[1] * 1.0f;
+//				xyz[2] += normal[2] * 1;
+			}
+		}
+	}
+}
diff --git a/code/renderer/tr_shader.cpp b/code/renderer/tr_shader.cpp
new file mode 100644
index 0000000..5a7fa1c
--- /dev/null
+++ b/code/renderer/tr_shader.cpp
@@ -0,0 +1,4122 @@
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+
+#include "tr_local.h"
+#include "tr_stl.h"
+
+const int lightmapsNone[MAXLIGHTMAPS] = 
+{ 
+	LIGHTMAP_NONE,
+	LIGHTMAP_NONE,
+	LIGHTMAP_NONE,
+	LIGHTMAP_NONE 
+};
+
+const int lightmaps2d[MAXLIGHTMAPS] = 
+{ 
+	LIGHTMAP_2D,
+	LIGHTMAP_2D,
+	LIGHTMAP_2D,
+	LIGHTMAP_2D 
+};
+
+const int lightmapsVertex[MAXLIGHTMAPS] = 
+{ 
+	LIGHTMAP_BY_VERTEX,
+	LIGHTMAP_BY_VERTEX,
+	LIGHTMAP_BY_VERTEX,
+	LIGHTMAP_BY_VERTEX 
+};
+
+const int lightmapsFullBright[MAXLIGHTMAPS] = 
+{
+	LIGHTMAP_WHITEIMAGE,
+	LIGHTMAP_WHITEIMAGE,
+	LIGHTMAP_WHITEIMAGE,
+	LIGHTMAP_WHITEIMAGE
+};
+
+const byte stylesDefault[MAXLIGHTMAPS] = 
+{
+	LS_NORMAL,
+	LS_NONE,
+	LS_NONE,
+	LS_NONE
+};
+
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// Vertex and Pixel Shader definitions.	- AReis
+/***********************************************************************************************************/
+// This vertex shader basically passes through most values and calculates no lighting. The only
+// unusual thing it does is add the inputed texel offsets to all four texture units (this allows
+// nearest neighbor pixel peeking).
+const unsigned char g_strGlowVShaderARB[] =
+{
+	"!!ARBvp1.0\
+	\
+	# Input.\n\
+	ATTRIB	iPos		= vertex.position;\
+	ATTRIB	iColor		= vertex.color;\
+	ATTRIB	iTex0		= vertex.texcoord[0];\
+	ATTRIB	iTex1		= vertex.texcoord[1];\
+	ATTRIB	iTex2		= vertex.texcoord[2];\
+	ATTRIB	iTex3		= vertex.texcoord[3];\
+	\
+	# Output.\n\
+	OUTPUT	oPos		= result.position;\
+	OUTPUT	oColor		= result.color;\
+	OUTPUT	oTex0		= result.texcoord[0];\
+	OUTPUT	oTex1		= result.texcoord[1];\
+	OUTPUT	oTex2		= result.texcoord[2];\
+	OUTPUT	oTex3		= result.texcoord[3];\
+	\
+	# Constants.\n\
+	PARAM	ModelViewProj[4]= { state.matrix.mvp };\
+	PARAM	TexelOffset0	= program.env[0];\
+	PARAM	TexelOffset1	= program.env[1];\
+	PARAM	TexelOffset2	= program.env[2];\
+	PARAM	TexelOffset3	= program.env[3];\
+	\
+	# Main.\n\
+	DP4		oPos.x, ModelViewProj[0], iPos;\
+	DP4		oPos.y, ModelViewProj[1], iPos;\
+	DP4		oPos.z, ModelViewProj[2], iPos;\
+	DP4		oPos.w, ModelViewProj[3], iPos;\
+	MOV		oColor, iColor;\
+	# Notice the optimization of using one texture coord instead of all four.\n\
+	ADD		oTex0, iTex0, TexelOffset0;\
+	ADD		oTex1, iTex0, TexelOffset1;\
+	ADD		oTex2, iTex0, TexelOffset2;\
+	ADD		oTex3, iTex0, TexelOffset3;\
+	\
+	END"
+};
+
+// This Pixel Shader loads four texture units and adds them all together (with a modifier
+// multiplied to each in the process). The final output is r0 = t0 + t1 + t2 + t3.
+const unsigned char g_strGlowPShaderARB[] =
+{
+	"!!ARBfp1.0\
+	\
+	# Input.\n\
+	ATTRIB	iColor	= fragment.color.primary;\
+	\
+	# Output.\n\
+	OUTPUT	oColor	= result.color;\
+	\
+	# Constants.\n\
+	PARAM	Weight	= program.env[0];\
+	TEMP	t0;\
+	TEMP	t1;\
+	TEMP	t2;\
+	TEMP	t3;\
+	TEMP	r0;\
+	\
+	# Main.\n\
+	TEX		t0, fragment.texcoord[0], texture[0], RECT;\
+	TEX		t1, fragment.texcoord[1], texture[1], RECT;\
+	TEX		t2, fragment.texcoord[2], texture[2], RECT;\
+	TEX		t3, fragment.texcoord[3], texture[3], RECT;\
+	\
+    MUL		r0, t0, Weight;\
+	MAD		r0, t1, Weight, r0;\
+	MAD		r0, t2, Weight, r0;\
+	MAD		r0, t3, Weight, r0;\
+	\
+	MOV		oColor, r0;\
+	\
+	END"
+};
+/***********************************************************************************************************/
+
+
+/*
+===============
+R_CreateExtendedName
+
+  Creates a unique shader name taking into account lightstyles
+===============
+*/
+
+void R_CreateExtendedName(char *extendedName, const char *name, const int *lightmapIndex, const byte *styles)
+{
+	int		i;
+
+	// Set the basename
+	COM_StripExtension( name, extendedName );
+
+	// Add in lightmaps
+	if(lightmapIndex && styles)
+	{
+		if(lightmapIndex == lightmapsNone)
+		{
+			strcat(extendedName, "_nolightmap");
+		}
+		else if(lightmapIndex == lightmaps2d)
+		{
+			strcat(extendedName, "_2d");
+		}
+		else if(lightmapIndex == lightmapsVertex)
+		{
+			strcat(extendedName, "_vertex");
+		}
+		else if(lightmapIndex == lightmapsFullBright)
+		{
+			strcat(extendedName, "_fullbright");
+		}
+		else
+		{
+			for(i = 0; (i < 4) && (styles[i] != 255); i++)
+			{
+				switch(lightmapIndex[i])
+				{
+				case LIGHTMAP_NONE:
+					strcat(extendedName, va("_style(%d,none)", styles[i]));
+					break;
+				case LIGHTMAP_2D:
+					strcat(extendedName, va("_style(%d,2d)", styles[i]));
+					break;
+				case LIGHTMAP_BY_VERTEX:
+					strcat(extendedName, va("_style(%d,vert)", styles[i]));
+					break;
+				case LIGHTMAP_WHITEIMAGE:
+					strcat(extendedName, va("_style(%d,fb)", styles[i]));
+					break;
+				default:
+					strcat(extendedName, va("_style(%d,%d)", styles[i], lightmapIndex[i]));
+					break;
+				}
+			}
+		}
+	}
+}
+
+// tr_shader.c -- this file deals with the parsing and definition of shaders
+
+static char *s_shaderText;
+
+// the shader is parsed into these global variables, then copied into
+// dynamically allocated memory if it is valid.
+static	shaderStage_t	stages[MAX_SHADER_STAGES];		
+static	shader_t		shader;
+static	texModInfo_t	texMods[MAX_SHADER_STAGES][TR_MAX_TEXMODS];
+
+#define FILE_HASH_SIZE		1024
+static	shader_t*		sh_hashTable[FILE_HASH_SIZE];
+
+static void ClearGlobalShader(void)
+{
+	int	i;
+
+	memset( &shader, 0, sizeof( shader ) );
+	memset( &stages, 0, sizeof( stages ) );
+	for ( i = 0 ; i < MAX_SHADER_STAGES ; i++ ) {
+		stages[i].bundle[0].texMods = texMods[i];
+		stages[i].mGLFogColorOverride = GLFOGOVERRIDE_NONE;
+	}
+	shader.contentFlags = CONTENTS_SOLID | CONTENTS_OPAQUE;
+}
+
+
+/* 
+====================
+RE_RegisterShader
+
+This is the exported shader entry point for the rest of the system
+It will always return an index that will be valid.
+
+This should really only be used for explicit shaders, because there is no
+way to ask for different implicit lighting modes (vertex, lightmap, etc)
+====================
+*/
+qhandle_t RE_RegisterShaderLightMap( const char *name, const int *lightmapIndex, const byte *styles ) 
+{
+	shader_t	*sh;
+
+	if ( strlen( name ) >= MAX_QPATH ) {
+		Com_Printf( "Shader name exceeds MAX_QPATH\n" );
+		return 0;
+	}
+
+	sh = R_FindShader( name, lightmapIndex, styles, qtrue );
+
+	// we want to return 0 if the shader failed to
+	// load for some reason, but R_FindShader should
+	// still keep a name allocated for it, so if
+	// something calls RE_RegisterShader again with
+	// the same name, we don't try looking for it again
+	if ( sh->defaultShader ) {
+		return 0;
+	}
+
+	return sh->index;
+}
+
+/*
+==================
+R_FindShaderByName
+
+Will always return a valid shader, but it might be the
+default shader if the real one can't be found.
+==================
+*/
+shader_t *R_FindShaderByName( const char *name ) {
+	char		strippedName[MAX_QPATH];
+	int			hash;
+	shader_t	*sh;
+
+	if ( (name==NULL) || (name[0] == 0) ) {  // bk001205
+		return tr.defaultShader;
+	}
+
+	COM_StripExtension( name, strippedName );
+
+	hash = generateHashValue(strippedName);
+
+	//
+	// see if the shader is already loaded
+	//
+	for (sh=sh_hashTable[hash]; sh; sh=sh->next) {
+		// NOTE: if there was no shader or image available with the name strippedName
+		// then a default shader is created with lightmapIndex == LIGHTMAP_NONE, so we
+		// have to check all default shaders otherwise for every call to R_FindShader
+		// with that same strippedName a new default shader is created.
+		if (Q_stricmp(sh->name, strippedName) == 0) {
+			// match found
+			return sh;
+		}
+	}
+
+	return tr.defaultShader;
+}
+
+/*
+void R_RemapShader(const char *shaderName, const char *newShaderName, const char *timeOffset) {
+	char		strippedName[MAX_QPATH];
+	int			hash;
+	shader_t	*sh, *sh2;
+	qhandle_t	h;
+
+	sh = R_FindShaderByName( shaderName );
+	if (sh == NULL || sh == tr.defaultShader) {
+		h = RE_RegisterShaderLightMap(shaderName, lightmapsNone, stylesDefault);
+		sh = R_GetShaderByHandle(h);
+	}
+	if (sh == NULL || sh == tr.defaultShader) {
+		VID_Printf( PRINT_WARNING, "WARNING: R_RemapShader: shader %s not found\n", shaderName );
+		return;
+	}
+
+	sh2 = R_FindShaderByName( newShaderName );
+	if (sh2 == NULL || sh2 == tr.defaultShader) {
+		h = RE_RegisterShaderLightMap(newShaderName, lightmapsNone, stylesDefault);
+		sh2 = R_GetShaderByHandle(h);
+	}
+
+	if (sh2 == NULL || sh2 == tr.defaultShader) {
+		VID_Printf( PRINT_WARNING, "WARNING: R_RemapShader: new shader %s not found\n", newShaderName );
+		return;
+	}
+
+	// remap all the shaders with the given name
+	// even tho they might have different lightmaps
+	COM_StripExtension( shaderName, strippedName );
+	hash = generateHashValue(strippedName);
+	for (sh = sh_hashTable[hash]; sh; sh = sh->next) {
+		if (Q_stricmp(sh->name, strippedName) == 0) {
+			if (sh != sh2) {
+				sh->remappedShader = sh2;
+			} else {
+				sh->remappedShader = NULL;
+			}
+		}
+	}
+	if (timeOffset) {
+		sh2->timeOffset = atof(timeOffset);
+	}
+}
+*/
+
+/*
+===============
+ParseVector
+===============
+*/
+qboolean ParseVector( const char **text, int count, float *v ) {
+	char	*token;
+	int		i;
+
+	// FIXME: spaces are currently required after parens, should change parseext...
+	token = COM_ParseExt( text, qfalse );
+	if ( strcmp( token, "(" ) ) {
+		VID_Printf( PRINT_WARNING, "WARNING: missing parenthesis in shader '%s'\n", shader.name );
+		return qfalse;
+	}
+
+	for ( i = 0 ; i < count ; i++ ) {
+		token = COM_ParseExt( text, qfalse );
+		if ( !token[0] ) {
+			VID_Printf( PRINT_WARNING, "WARNING: missing vector element in shader '%s'\n", shader.name );
+			return qfalse;
+		}
+		v[i] = atof( token );
+	}
+
+	token = COM_ParseExt( text, qfalse );
+	if ( strcmp( token, ")" ) ) {
+		VID_Printf( PRINT_WARNING, "WARNING: missing parenthesis in shader '%s'\n", shader.name );
+		return qfalse;
+	}
+
+	return qtrue;
+}
+
+
+/*
+===============
+NameToAFunc
+===============
+*/
+static unsigned NameToAFunc( const char *funcname )
+{	
+	if ( !Q_stricmp( funcname, "GT0" ) )
+	{
+		return GLS_ATEST_GT_0;
+	}
+	else if ( !Q_stricmp( funcname, "LT128" ) )
+	{
+		return GLS_ATEST_LT_80;
+	}
+	else if ( !Q_stricmp( funcname, "GE128" ) )
+	{
+		return GLS_ATEST_GE_80;
+	}
+	else if ( !Q_stricmp( funcname, "GE192" ) )
+	{
+		return GLS_ATEST_GE_C0;
+	}
+
+	VID_Printf( PRINT_WARNING, "WARNING: invalid alphaFunc name '%s' in shader '%s'\n", funcname, shader.name );
+	return 0;
+}
+
+
+/*
+===============
+NameToSrcBlendMode
+===============
+*/
+static int NameToSrcBlendMode( const char *name )
+{
+	if ( !Q_stricmp( name, "GL_ONE" ) )
+	{
+		return GLS_SRCBLEND_ONE;
+	}
+	else if ( !Q_stricmp( name, "GL_ZERO" ) )
+	{
+		return GLS_SRCBLEND_ZERO;
+	}
+	else if ( !Q_stricmp( name, "GL_DST_COLOR" ) )
+	{
+		return GLS_SRCBLEND_DST_COLOR;
+	}
+	else if ( !Q_stricmp( name, "GL_ONE_MINUS_DST_COLOR" ) )
+	{
+		return GLS_SRCBLEND_ONE_MINUS_DST_COLOR;
+	}
+	else if ( !Q_stricmp( name, "GL_SRC_ALPHA" ) )
+	{
+		return GLS_SRCBLEND_SRC_ALPHA;
+	}
+	else if ( !Q_stricmp( name, "GL_ONE_MINUS_SRC_ALPHA" ) )
+	{
+		return GLS_SRCBLEND_ONE_MINUS_SRC_ALPHA;
+	}
+	else if ( !Q_stricmp( name, "GL_DST_ALPHA" ) )
+	{
+		return GLS_SRCBLEND_DST_ALPHA;
+	}
+	else if ( !Q_stricmp( name, "GL_ONE_MINUS_DST_ALPHA" ) )
+	{
+		return GLS_SRCBLEND_ONE_MINUS_DST_ALPHA;
+	}
+	else if ( !Q_stricmp( name, "GL_SRC_ALPHA_SATURATE" ) )
+	{
+		return GLS_SRCBLEND_ALPHA_SATURATE;
+	}
+	VID_Printf( PRINT_WARNING, "WARNING: unknown blend mode '%s' in shader '%s', substituting GL_ONE\n", name, shader.name );
+	return GLS_SRCBLEND_ONE;
+}
+
+/*
+===============
+NameToDstBlendMode
+===============
+*/
+static int NameToDstBlendMode( const char *name )
+{
+	if ( !Q_stricmp( name, "GL_ONE" ) )
+	{
+		return GLS_DSTBLEND_ONE;
+	}
+	else if ( !Q_stricmp( name, "GL_ZERO" ) )
+	{
+		return GLS_DSTBLEND_ZERO;
+	}
+	else if ( !Q_stricmp( name, "GL_SRC_ALPHA" ) )
+	{
+		return GLS_DSTBLEND_SRC_ALPHA;
+	}
+	else if ( !Q_stricmp( name, "GL_ONE_MINUS_SRC_ALPHA" ) )
+	{
+		return GLS_DSTBLEND_ONE_MINUS_SRC_ALPHA;
+	}
+	else if ( !Q_stricmp( name, "GL_DST_ALPHA" ) )
+	{
+		return GLS_DSTBLEND_DST_ALPHA;
+	}
+	else if ( !Q_stricmp( name, "GL_ONE_MINUS_DST_ALPHA" ) )
+	{
+		return GLS_DSTBLEND_ONE_MINUS_DST_ALPHA;
+	}
+	else if ( !Q_stricmp( name, "GL_SRC_COLOR" ) )
+	{
+		return GLS_DSTBLEND_SRC_COLOR;
+	}
+	else if ( !Q_stricmp( name, "GL_ONE_MINUS_SRC_COLOR" ) )
+	{
+		return GLS_DSTBLEND_ONE_MINUS_SRC_COLOR;
+	}
+	VID_Printf( PRINT_WARNING, "WARNING: unknown blend mode '%s' in shader '%s', substituting GL_ONE\n", name, shader.name );
+	return GLS_DSTBLEND_ONE;
+}
+
+/*
+===============
+NameToGenFunc
+===============
+*/
+static genFunc_t NameToGenFunc( const char *funcname )
+{
+	if ( !Q_stricmp( funcname, "sin" ) )
+	{
+		return GF_SIN;
+	}
+	else if ( !Q_stricmp( funcname, "square" ) )
+	{
+		return GF_SQUARE;
+	}
+	else if ( !Q_stricmp( funcname, "triangle" ) )
+	{
+		return GF_TRIANGLE;
+	}
+	else if ( !Q_stricmp( funcname, "sawtooth" ) )
+	{
+		return GF_SAWTOOTH;
+	}
+	else if ( !Q_stricmp( funcname, "inversesawtooth" ) )
+	{
+		return GF_INVERSE_SAWTOOTH;
+	}
+	else if ( !Q_stricmp( funcname, "noise" ) )
+	{
+		return GF_NOISE;
+	}
+	else if ( !Q_stricmp( funcname, "random" ) )
+	{
+		return GF_RAND;
+	}
+
+
+	VID_Printf( PRINT_WARNING, "WARNING: invalid genfunc name '%s' in shader '%s'\n", funcname, shader.name );
+	return GF_SIN;
+}
+
+
+/*
+===================
+ParseWaveForm
+===================
+*/
+static void ParseWaveForm( const char **text, waveForm_t *wave )
+{
+	char *token;
+
+	token = COM_ParseExt( text, qfalse );
+	if ( token[0] == 0 )
+	{
+		VID_Printf( PRINT_WARNING, "WARNING: missing waveform parm in shader '%s'\n", shader.name );
+		return;
+	}
+	wave->func = NameToGenFunc( token );
+
+	// BASE, AMP, PHASE, FREQ
+	token = COM_ParseExt( text, qfalse );
+	if ( token[0] == 0 )
+	{
+		VID_Printf( PRINT_WARNING, "WARNING: missing waveform parm in shader '%s'\n", shader.name );
+		return;
+	}
+	wave->base = atof( token );
+
+	token = COM_ParseExt( text, qfalse );
+	if ( token[0] == 0 )
+	{
+		VID_Printf( PRINT_WARNING, "WARNING: missing waveform parm in shader '%s'\n", shader.name );
+		return;
+	}
+	wave->amplitude = atof( token );
+
+	token = COM_ParseExt( text, qfalse );
+	if ( token[0] == 0 )
+	{
+		VID_Printf( PRINT_WARNING, "WARNING: missing waveform parm in shader '%s'\n", shader.name );
+		return;
+	}
+	wave->phase = atof( token );
+
+	token = COM_ParseExt( text, qfalse );
+	if ( token[0] == 0 )
+	{
+		VID_Printf( PRINT_WARNING, "WARNING: missing waveform parm in shader '%s'\n", shader.name );
+		return;
+	}
+	wave->frequency = atof( token );
+}
+
+
+/*
+===================
+ParseTexMod
+===================
+*/
+static void ParseTexMod( const char *_text, shaderStage_t *stage )
+{
+	const char *token;
+	const char **text = &_text;
+	texModInfo_t *tmi;
+
+	if ( stage->bundle[0].numTexMods == TR_MAX_TEXMODS ) {
+		Com_Error( ERR_DROP, "ERROR: too many tcMod stages in shader '%s'\n", shader.name );
+		return;
+	}
+
+	tmi = &stage->bundle[0].texMods[stage->bundle[0].numTexMods];
+	stage->bundle[0].numTexMods++;
+
+	token = COM_ParseExt( text, qfalse );
+
+	//
+	// turb
+	//
+	if ( !Q_stricmp( token, "turb" ) )
+	{
+		token = COM_ParseExt( text, qfalse );
+		if ( token[0] == 0 )
+		{
+			VID_Printf( PRINT_WARNING, "WARNING: missing tcMod turb parms in shader '%s'\n", shader.name );
+			return;
+		}
+		tmi->wave.base = atof( token );
+		token = COM_ParseExt( text, qfalse );
+		if ( token[0] == 0 )
+		{
+			VID_Printf( PRINT_WARNING, "WARNING: missing tcMod turb in shader '%s'\n", shader.name );
+			return;
+		}
+		tmi->wave.amplitude = atof( token );
+		token = COM_ParseExt( text, qfalse );
+		if ( token[0] == 0 )
+		{
+			VID_Printf( PRINT_WARNING, "WARNING: missing tcMod turb in shader '%s'\n", shader.name );
+			return;
+		}
+		tmi->wave.phase = atof( token );
+		token = COM_ParseExt( text, qfalse );
+		if ( token[0] == 0 )
+		{
+			VID_Printf( PRINT_WARNING, "WARNING: missing tcMod turb in shader '%s'\n", shader.name );
+			return;
+		}
+		tmi->wave.frequency = atof( token );
+
+		tmi->type = TMOD_TURBULENT;
+	}
+	//
+	// scale
+	//
+	else if ( !Q_stricmp( token, "scale" ) )
+	{
+		token = COM_ParseExt( text, qfalse );
+		if ( token[0] == 0 )
+		{
+			VID_Printf( PRINT_WARNING, "WARNING: missing scale parms in shader '%s'\n", shader.name );
+			return;
+		}
+		tmi->translate[0] = atof( token );	//scale unioned
+
+		token = COM_ParseExt( text, qfalse );
+		if ( token[0] == 0 )
+		{
+			VID_Printf( PRINT_WARNING, "WARNING: missing scale parms in shader '%s'\n", shader.name );
+			return;
+		}
+		tmi->translate[1] = atof( token );	//scale unioned
+		tmi->type = TMOD_SCALE;
+	}
+	//
+	// scroll
+	//
+	else if ( !Q_stricmp( token, "scroll" ) )
+	{
+		token = COM_ParseExt( text, qfalse );
+		if ( token[0] == 0 )
+		{
+			VID_Printf( PRINT_WARNING, "WARNING: missing scale scroll parms in shader '%s'\n", shader.name );
+			return;
+		}
+		tmi->translate[0] = atof( token );	//scroll unioned
+		token = COM_ParseExt( text, qfalse );
+		if ( token[0] == 0 )
+		{
+			VID_Printf( PRINT_WARNING, "WARNING: missing scale scroll parms in shader '%s'\n", shader.name );
+			return;
+		}
+		tmi->translate[1] = atof( token );	//scroll unioned
+		tmi->type = TMOD_SCROLL;
+	}
+	//
+	// stretch
+	//
+	else if ( !Q_stricmp( token, "stretch" ) )
+	{
+		token = COM_ParseExt( text, qfalse );
+		if ( token[0] == 0 )
+		{
+			VID_Printf( PRINT_WARNING, "WARNING: missing stretch parms in shader '%s'\n", shader.name );
+			return;
+		}
+		tmi->wave.func = NameToGenFunc( token );
+
+		token = COM_ParseExt( text, qfalse );
+		if ( token[0] == 0 )
+		{
+			VID_Printf( PRINT_WARNING, "WARNING: missing stretch parms in shader '%s'\n", shader.name );
+			return;
+		}
+		tmi->wave.base = atof( token );
+
+		token = COM_ParseExt( text, qfalse );
+		if ( token[0] == 0 )
+		{
+			VID_Printf( PRINT_WARNING, "WARNING: missing stretch parms in shader '%s'\n", shader.name );
+			return;
+		}
+		tmi->wave.amplitude = atof( token );
+
+		token = COM_ParseExt( text, qfalse );
+		if ( token[0] == 0 )
+		{
+			VID_Printf( PRINT_WARNING, "WARNING: missing stretch parms in shader '%s'\n", shader.name );
+			return;
+		}
+		tmi->wave.phase = atof( token );
+
+		token = COM_ParseExt( text, qfalse );
+		if ( token[0] == 0 )
+		{
+			VID_Printf( PRINT_WARNING, "WARNING: missing stretch parms in shader '%s'\n", shader.name );
+			return;
+		}
+		tmi->wave.frequency = atof( token );
+		
+		tmi->type = TMOD_STRETCH;
+	}
+	//
+	// transform
+	//
+	else if ( !Q_stricmp( token, "transform" ) )
+	{
+		token = COM_ParseExt( text, qfalse );
+		if ( token[0] == 0 )
+		{
+			VID_Printf( PRINT_WARNING, "WARNING: missing transform parms in shader '%s'\n", shader.name );
+			return;
+		}
+		tmi->matrix[0][0] = atof( token );
+
+		token = COM_ParseExt( text, qfalse );
+		if ( token[0] == 0 )
+		{
+			VID_Printf( PRINT_WARNING, "WARNING: missing transform parms in shader '%s'\n", shader.name );
+			return;
+		}
+		tmi->matrix[0][1] = atof( token );
+
+		token = COM_ParseExt( text, qfalse );
+		if ( token[0] == 0 )
+		{
+			VID_Printf( PRINT_WARNING, "WARNING: missing transform parms in shader '%s'\n", shader.name );
+			return;
+		}
+		tmi->matrix[1][0] = atof( token );
+
+		token = COM_ParseExt( text, qfalse );
+		if ( token[0] == 0 )
+		{
+			VID_Printf( PRINT_WARNING, "WARNING: missing transform parms in shader '%s'\n", shader.name );
+			return;
+		}
+		tmi->matrix[1][1] = atof( token );
+
+		token = COM_ParseExt( text, qfalse );
+		if ( token[0] == 0 )
+		{
+			VID_Printf( PRINT_WARNING, "WARNING: missing transform parms in shader '%s'\n", shader.name );
+			return;
+		}
+		tmi->translate[0] = atof( token );
+
+		token = COM_ParseExt( text, qfalse );
+		if ( token[0] == 0 )
+		{
+			VID_Printf( PRINT_WARNING, "WARNING: missing transform parms in shader '%s'\n", shader.name );
+			return;
+		}
+		tmi->translate[1] = atof( token );
+
+		tmi->type = TMOD_TRANSFORM;
+	}
+	//
+	// rotate
+	//
+	else if ( !Q_stricmp( token, "rotate" ) )
+	{
+		token = COM_ParseExt( text, qfalse );
+		if ( token[0] == 0 )
+		{
+			VID_Printf( PRINT_WARNING, "WARNING: missing tcMod rotate parms in shader '%s'\n", shader.name );
+			return;
+		}
+		tmi->translate[0]= atof( token );	//rotateSpeed unioned
+		tmi->type = TMOD_ROTATE;
+	}
+	//
+	// entityTranslate
+	//
+	else if ( !Q_stricmp( token, "entityTranslate" ) )
+	{
+		tmi->type = TMOD_ENTITY_TRANSLATE;
+	}
+	else
+	{
+		VID_Printf( PRINT_WARNING, "WARNING: unknown tcMod '%s' in shader '%s'\n", token, shader.name );
+	}
+}
+
+
+
+
+/*
+/////===== Part of the VERTIGON system =====/////
+===================
+ParseSurfaceSprites
+===================
+*/
+// surfaceSprites <type> <width> <height> <density> <fadedist>
+//
+// NOTE:  This parsing function used to be 12 pages long and very complex.  The new version of surfacesprites
+// utilizes optional parameters parsed in ParseSurfaceSpriteOptional.
+static void ParseSurfaceSprites(const char *_text, shaderStage_t *stage )
+{
+	const char *token;
+	const char **text = &_text;
+	float width, height, density, fadedist;
+	int sstype=SURFSPRITE_NONE;
+
+	//
+	// spritetype
+	//
+	token = COM_ParseExt( text, qfalse );
+
+	if (token[0]==0)
+	{
+		VID_Printf( PRINT_WARNING, "WARNING: missing surfaceSprites params in shader '%s'\n", shader.name );
+		return;
+	}
+
+	if (!Q_stricmp(token, "vertical"))
+	{
+		sstype = SURFSPRITE_VERTICAL;
+	}
+	else if (!Q_stricmp(token, "oriented"))
+	{
+		sstype = SURFSPRITE_ORIENTED;
+	}
+	else if (!Q_stricmp(token, "effect"))
+	{
+		sstype = SURFSPRITE_EFFECT;
+	}
+	else if (!Q_stricmp(token, "flattened"))
+	{
+		sstype = SURFSPRITE_FLATTENED;
+	}
+	else
+	{
+		VID_Printf( PRINT_WARNING, "WARNING: invalid type in shader '%s'\n", shader.name );
+		return;
+	}
+
+	//
+	// width
+	//
+	token = COM_ParseExt( text, qfalse );
+	if (token[0]==0)
+	{
+		VID_Printf( PRINT_WARNING, "WARNING: missing surfaceSprites params in shader '%s'\n", shader.name );
+		return;
+	}
+	width=atof(token);
+	if (width <= 0)
+	{
+		VID_Printf( PRINT_WARNING, "WARNING: invalid width in shader '%s'\n", shader.name );
+		return;
+	}
+
+	//
+	// height
+	//
+	token = COM_ParseExt( text, qfalse );
+	if (token[0]==0)
+	{
+		VID_Printf( PRINT_WARNING, "WARNING: missing surfaceSprites params in shader '%s'\n", shader.name );
+		return;
+	}
+	height=atof(token);
+	if (height <= 0)
+	{
+		VID_Printf( PRINT_WARNING, "WARNING: invalid height in shader '%s'\n", shader.name );
+		return;
+	}
+
+	//
+	// density
+	//
+	token = COM_ParseExt( text, qfalse );
+	if (token[0]==0)
+	{
+		VID_Printf( PRINT_WARNING, "WARNING: missing surfaceSprites params in shader '%s'\n", shader.name );
+		return;
+	}
+	density=atof(token);
+	if (density <= 0)
+	{
+		VID_Printf( PRINT_WARNING, "WARNING: invalid density in shader '%s'\n", shader.name );
+		return;
+	}
+
+	//
+	// fadedist
+	//
+	token = COM_ParseExt( text, qfalse );
+	if (token[0]==0)
+	{
+		VID_Printf( PRINT_WARNING, "WARNING: missing surfaceSprites params in shader '%s'\n", shader.name );
+		return;
+	}
+	fadedist=atof(token);
+	if (fadedist < 32)
+	{
+		VID_Printf( PRINT_WARNING, "WARNING: invalid fadedist (%f < 32) in shader '%s'\n", fadedist, shader.name );
+		return;
+	}
+
+	if (!stage->ss)
+	{
+		stage->ss = (surfaceSprite_t *)Hunk_Alloc( sizeof( surfaceSprite_t ), qtrue );
+	}
+
+	// These are all set by the command lines.
+	stage->ss->surfaceSpriteType = sstype;
+	stage->ss->width = width;
+	stage->ss->height = height;
+	stage->ss->density = density;
+	stage->ss->fadeDist = fadedist;
+
+#ifdef _XBOX
+	shader.needsNormal = true;
+#endif
+
+	// These are defaults that can be overwritten.
+	stage->ss->fadeMax = fadedist*1.33;
+	stage->ss->fadeScale = 0.0;
+	stage->ss->wind = 0.0;
+	stage->ss->windIdle = 0.0;
+	stage->ss->variance[0] = 0.0;
+	stage->ss->variance[1] = 0.0;
+	stage->ss->facing = SURFSPRITE_FACING_NORMAL;
+
+	// A vertical parameter that needs a default regardless
+	stage->ss->vertSkew;
+
+	// These are effect parameters that need defaults nonetheless.
+	stage->ss->fxDuration = 1000;		// 1 second
+	stage->ss->fxGrow[0] = 0.0;
+	stage->ss->fxGrow[1] = 0.0;
+	stage->ss->fxAlphaStart = 1.0;	
+	stage->ss->fxAlphaEnd = 0.0;
+}
+
+
+
+
+/*
+/////===== Part of the VERTIGON system =====/////
+===========================
+ParseSurfaceSpritesOptional
+===========================
+*/
+//
+// ssFademax <fademax>
+// ssFadescale <fadescale>
+// ssVariance <varwidth> <varheight>
+// ssHangdown
+// ssAnyangle
+// ssFaceup
+// ssWind <wind>
+// ssWindIdle <windidle>
+// ssVertSkew <skew>
+// ssFXDuration <duration>
+// ssFXGrow <growwidth> <growheight>
+// ssFXAlphaRange <alphastart> <startend>
+// ssFXWeather
+//
+// Optional parameters that will override the defaults set in the surfacesprites command above.
+//
+static void ParseSurfaceSpritesOptional( const char *param, const char *_text, shaderStage_t *stage )
+{
+	const char *token;
+	const char **text = &_text;
+	float	value;
+
+	if (!stage->ss)
+	{
+		stage->ss = (surfaceSprite_t *)Hunk_Alloc( sizeof( surfaceSprite_t ), qtrue );
+	}
+	//
+	// fademax
+	//
+	if (!Q_stricmp(param, "ssFademax"))
+	{
+		token = COM_ParseExt( text, qfalse);
+		if (token[0]==0)
+		{
+			VID_Printf( PRINT_WARNING, "WARNING: missing surfacesprite fademax in shader '%s'\n", shader.name );
+			return;
+		}
+		value = atof(token);
+		if (value <= stage->ss->fadeDist)
+		{
+			VID_Printf( PRINT_WARNING, "WARNING: invalid surfacesprite fademax (%.2f <= fadeDist(%.2f)) in shader '%s'\n", value, stage->ss->fadeDist, shader.name );
+			return;
+		}
+		stage->ss->fadeMax=value;
+		return;
+	}
+
+	//
+	// fadescale
+	//
+	if (!Q_stricmp(param, "ssFadescale"))
+	{
+		token = COM_ParseExt( text, qfalse);
+		if (token[0]==0)
+		{
+			VID_Printf( PRINT_WARNING, "WARNING: missing surfacesprite fadescale in shader '%s'\n", shader.name );
+			return;
+		}
+		value = atof(token);
+		stage->ss->fadeScale=value;
+		return;
+	}
+
+	//
+	// variance
+	//
+	if (!Q_stricmp(param, "ssVariance"))
+	{
+		token = COM_ParseExt( text, qfalse);
+		if (token[0]==0)
+		{
+			VID_Printf( PRINT_WARNING, "WARNING: missing surfacesprite variance width in shader '%s'\n", shader.name );
+			return;
+		}
+		value = atof(token);
+		if (value < 0)
+		{
+			VID_Printf( PRINT_WARNING, "WARNING: invalid surfacesprite variance width in shader '%s'\n", shader.name );
+			return;
+		}
+		stage->ss->variance[0]=value;
+
+		token = COM_ParseExt( text, qfalse);
+		if (token[0]==0)
+		{
+			VID_Printf( PRINT_WARNING, "WARNING: missing surfacesprite variance height in shader '%s'\n", shader.name );
+			return;
+		}
+		value = atof(token);
+		if (value < 0)
+		{
+			VID_Printf( PRINT_WARNING, "WARNING: invalid surfacesprite variance height in shader '%s'\n", shader.name );
+			return;
+		}
+		stage->ss->variance[1]=value;
+		return;
+	}
+
+	//
+	// hangdown
+	//
+	if (!Q_stricmp(param, "ssHangdown"))
+	{
+		if (stage->ss->facing != SURFSPRITE_FACING_NORMAL)
+		{
+			VID_Printf( PRINT_WARNING, "WARNING: Hangdown facing overrides previous facing in shader '%s'\n", shader.name );
+			return;
+		}
+		stage->ss->facing=SURFSPRITE_FACING_DOWN;
+		return;
+	}
+
+	//
+	// anyangle
+	//
+	if (!Q_stricmp(param, "ssAnyangle"))
+	{
+		if (stage->ss->facing != SURFSPRITE_FACING_NORMAL)
+		{
+			VID_Printf( PRINT_WARNING, "WARNING: Anyangle facing overrides previous facing in shader '%s'\n", shader.name );
+			return;
+		}
+		stage->ss->facing=SURFSPRITE_FACING_ANY;
+		return;
+	}
+
+	//
+	// faceup
+	//
+	if (!Q_stricmp(param, "ssFaceup"))
+	{
+		if (stage->ss->facing != SURFSPRITE_FACING_NORMAL)
+		{
+			VID_Printf( PRINT_WARNING, "WARNING: Faceup facing overrides previous facing in shader '%s'\n", shader.name );
+			return;
+		}
+		stage->ss->facing=SURFSPRITE_FACING_UP;
+		return;
+	}
+
+	//
+	// wind
+	//
+	if (!Q_stricmp(param, "ssWind"))
+	{
+		token = COM_ParseExt( text, qfalse);
+		if (token[0]==0)
+		{
+			VID_Printf( PRINT_WARNING, "WARNING: missing surfacesprite wind in shader '%s'\n", shader.name );
+			return;
+		}
+		value = atof(token);
+		if (value < 0.0)
+		{
+			VID_Printf( PRINT_WARNING, "WARNING: invalid surfacesprite wind in shader '%s'\n", shader.name );
+			return;
+		}
+		stage->ss->wind=value;
+		if (stage->ss->windIdle <= 0)
+		{	// Also override the windidle, it usually is the same as wind
+			stage->ss->windIdle = value;
+		}
+		return;
+	}
+
+	//
+	// windidle
+	//
+	if (!Q_stricmp(param, "ssWindidle"))
+	{
+		token = COM_ParseExt( text, qfalse);
+		if (token[0]==0)
+		{
+			VID_Printf( PRINT_WARNING, "WARNING: missing surfacesprite windidle in shader '%s'\n", shader.name );
+			return;
+		}
+		value = atof(token);
+		if (value < 0.0)
+		{
+			VID_Printf( PRINT_WARNING, "WARNING: invalid surfacesprite windidle in shader '%s'\n", shader.name );
+			return;
+		}
+		stage->ss->windIdle=value;
+		return;
+	}
+
+	//
+	// vertskew
+	//
+	if (!Q_stricmp(param, "ssVertskew"))
+	{
+		token = COM_ParseExt( text, qfalse);
+		if (token[0]==0)
+		{
+			VID_Printf( PRINT_WARNING, "WARNING: missing surfacesprite vertskew in shader '%s'\n", shader.name );
+			return;
+		}
+		value = atof(token);
+		if (value < 0.0)
+		{
+			VID_Printf( PRINT_WARNING, "WARNING: invalid surfacesprite vertskew in shader '%s'\n", shader.name );
+			return;
+		}
+		stage->ss->vertSkew=value;
+		return;
+	}
+
+	//
+	// fxduration
+	//
+	if (!Q_stricmp(param, "ssFXDuration"))
+	{
+		token = COM_ParseExt( text, qfalse);
+		if (token[0]==0)
+		{
+			VID_Printf( PRINT_WARNING, "WARNING: missing surfacesprite duration in shader '%s'\n", shader.name );
+			return;
+		}
+		value = atof(token);
+		if (value <= 0)
+		{
+			VID_Printf( PRINT_WARNING, "WARNING: invalid surfacesprite duration in shader '%s'\n", shader.name );
+			return;
+		}
+		stage->ss->fxDuration=value;
+		return;
+	}
+
+	//
+	// fxgrow
+	//
+	if (!Q_stricmp(param, "ssFXGrow"))
+	{
+		token = COM_ParseExt( text, qfalse);
+		if (token[0]==0)
+		{
+			VID_Printf( PRINT_WARNING, "WARNING: missing surfacesprite grow width in shader '%s'\n", shader.name );
+			return;
+		}
+		value = atof(token);
+		if (value < 0)
+		{
+			VID_Printf( PRINT_WARNING, "WARNING: invalid surfacesprite grow width in shader '%s'\n", shader.name );
+			return;
+		}
+		stage->ss->fxGrow[0]=value;
+
+		token = COM_ParseExt( text, qfalse);
+		if (token[0]==0)
+		{
+			VID_Printf( PRINT_WARNING, "WARNING: missing surfacesprite grow height in shader '%s'\n", shader.name );
+			return;
+		}
+		value = atof(token);
+		if (value < 0)
+		{
+			VID_Printf( PRINT_WARNING, "WARNING: invalid surfacesprite grow height in shader '%s'\n", shader.name );
+			return;
+		}
+		stage->ss->fxGrow[1]=value;
+		return;
+	}
+
+	//
+	// fxalpharange
+	//
+	if (!Q_stricmp(param, "ssFXAlphaRange"))
+	{
+		token = COM_ParseExt( text, qfalse);
+		if (token[0]==0)
+		{
+			VID_Printf( PRINT_WARNING, "WARNING: missing surfacesprite fxalpha start in shader '%s'\n", shader.name );
+			return;
+		}
+		value = atof(token);
+		if (value < 0 || value > 1.0)
+		{
+			VID_Printf( PRINT_WARNING, "WARNING: invalid surfacesprite fxalpha start in shader '%s'\n", shader.name );
+			return;
+		}
+		stage->ss->fxAlphaStart=value;
+
+		token = COM_ParseExt( text, qfalse);
+		if (token[0]==0)
+		{
+			VID_Printf( PRINT_WARNING, "WARNING: missing surfacesprite fxalpha end in shader '%s'\n", shader.name );
+			return;
+		}
+		value = atof(token);
+		if (value < 0 || value > 1.0)
+		{
+			VID_Printf( PRINT_WARNING, "WARNING: invalid surfacesprite fxalpha end in shader '%s'\n", shader.name );
+			return;
+		}
+		stage->ss->fxAlphaEnd=value;
+		return;
+	}
+
+	//
+	// fxweather
+	//
+	if (!Q_stricmp(param, "ssFXWeather"))
+	{
+		if (stage->ss->surfaceSpriteType != SURFSPRITE_EFFECT)
+		{
+			VID_Printf( PRINT_WARNING, "WARNING: weather applied to non-effect surfacesprite in shader '%s'\n", shader.name );
+			return;
+		}
+		stage->ss->surfaceSpriteType = SURFSPRITE_WEATHERFX;
+		return;
+	}
+
+	// 
+	// invalid ss command.
+	//
+	VID_Printf( PRINT_WARNING, "WARNING: invalid optional surfacesprite param '%s' in shader '%s'\n", param, shader.name );
+	return;
+}
+
+
+/*
+===================
+ParseStage
+===================
+*/
+static qboolean ParseStage( shaderStage_t *stage, const char **text )
+{
+	char *token;
+	int depthMaskBits = GLS_DEPTHMASK_TRUE, blendSrcBits = 0, blendDstBits = 0, atestBits = 0, depthFuncBits = 0;
+	qboolean depthMaskExplicit = qfalse;
+
+	stage->active = true;
+
+	while ( 1 )
+	{
+		token = COM_ParseExt( text, qtrue );
+		if ( !token[0] )
+		{
+			VID_Printf( PRINT_WARNING, "WARNING: no matching '}' found\n" );
+			return qfalse;
+		}
+
+		if ( token[0] == '}' )
+		{
+			break;
+		}
+		//
+		// map <name>
+		//
+		else if ( !Q_stricmp( token, "map" ) )
+		{
+			token = COM_ParseExt( text, qfalse );
+			if ( !token[0] )
+			{
+				VID_Printf( PRINT_WARNING, "WARNING: missing parameter for 'map' keyword in shader '%s'\n", shader.name );
+				return qfalse;
+			}
+
+			if ( !Q_stricmp( token, "$whiteimage" ) )
+			{
+				stage->bundle[0].image = tr.whiteImage;
+				continue;
+			}
+			else if ( !Q_stricmp( token, "$lightmap" ) )
+			{
+				stage->bundle[0].isLightmap = true;
+				if ( shader.lightmapIndex[0] < 0 ) {
+					stage->bundle[0].image = tr.whiteImage;
+#ifndef FINAL_BUILD
+					//VID_Printf( PRINT_WARNING, "WARNING: $lightmap requested but none available '%s'\n", shader.name );
+#endif
+				} else {
+					stage->bundle[0].image = tr.lightmaps[shader.lightmapIndex[0]];
+				}
+				continue;
+			}
+#ifdef _XBOX
+			else if ( !Q_stricmp( token, "$saveGameImage") )
+			{
+				stage->bundle[0].image = tr.saveGameImage;
+				continue;
+			}
+#endif //_XBOX
+			else
+			{
+				stage->bundle[0].image = R_FindImageFile( token, !shader.noMipMaps, !shader.noPicMip, !shader.noTC, GL_REPEAT );
+				if ( !stage->bundle[0].image )
+				{
+					VID_Printf( PRINT_WARNING, "WARNING: R_FindImageFile could not find '%s' in shader '%s'\n", token, shader.name );
+					return qfalse;
+				}
+			}
+		}
+#ifdef VV_LIGHTING
+		//
+		// specularmap <name>
+		//
+		else if ( !Q_stricmp( token, "specularmap" ) )
+		{
+			token = COM_ParseExt( text, qfalse );
+			if ( !token[0] )
+			{
+				VID_Printf( PRINT_WARNING, "WARNING: missing parameter for 'specularmap' keyword in shader '%s'\n", shader.name );
+				return qfalse;
+			}
+
+			stage->bundle[0].image = R_FindImageFile( token, !shader.noMipMaps, !shader.noPicMip, !shader.noTC, GL_REPEAT );
+			if ( !stage->bundle[0].image )
+			{
+				VID_Printf( PRINT_WARNING, "WARNING: R_FindImageFile could not find '%s' in shader '%s'\n", token, shader.name );
+				return qfalse;
+			}
+
+			stage->isSpecular = qtrue;
+
+			shader.needsNormal = true;
+			shader.needsTangent = true;
+		}
+#endif // VV_LIGHTING
+		//
+		// clampmap <name>
+		//
+		else if ( !Q_stricmp( token, "clampmap" ) )
+		{
+			token = COM_ParseExt( text, qfalse );
+			if ( !token[0] )
+			{
+				VID_Printf( PRINT_WARNING, "WARNING: missing parameter for 'clampmap' keyword in shader '%s'\n", shader.name );
+				return qfalse;
+			}
+
+			stage->bundle[0].image = R_FindImageFile( token, !shader.noMipMaps, !shader.noPicMip, !shader.noTC, GL_CLAMP );
+			if ( !stage->bundle[0].image )
+			{
+				VID_Printf( PRINT_WARNING, "WARNING: R_FindImageFile could not find '%s' in shader '%s'\n", token, shader.name );
+				return qfalse;
+			}
+		}
+		//
+		// animMap[/clampanimMap] <frequency> <image1> .... <imageN>
+		//
+		else if ( !Q_stricmp( token, "animMap" ) || !Q_stricmp( token, "clampanimMap" ) || !Q_stricmp( token, "oneshotanimMap" ))
+		{
+			#define	MAX_IMAGE_ANIMATIONS	32
+			image_t *images[MAX_IMAGE_ANIMATIONS];
+			bool bClamp = !Q_stricmp( token, "clampanimMap" );
+			bool oneShot = !Q_stricmp( token, "oneshotanimMap" );
+
+			token = COM_ParseExt( text, qfalse );
+			if ( !token[0] )
+			{
+				VID_Printf( PRINT_WARNING, "WARNING: missing parameter for '%s' keyword in shader '%s'\n", (bClamp ? "animMap":"clampanimMap"), shader.name );
+				return qfalse;
+			}
+			stage->bundle[0].imageAnimationSpeed = atof( token );
+			stage->bundle[0].oneShotAnimMap = oneShot;
+
+			// parse up to MAX_IMAGE_ANIMATIONS animations
+			while ( 1 ) {
+				int		num;
+
+				token = COM_ParseExt( text, qfalse );
+				if ( !token[0] ) {
+					break;
+				}
+				num = stage->bundle[0].numImageAnimations;
+				if ( num < MAX_IMAGE_ANIMATIONS ) {
+					images[num] = R_FindImageFile( token, !shader.noMipMaps, !shader.noPicMip, !shader.noTC, bClamp?GL_CLAMP:GL_REPEAT );
+					if ( !images[num] )
+					{
+						VID_Printf( PRINT_WARNING, "WARNING: R_FindImageFile could not find '%s' in shader '%s'\n", token, shader.name );
+						return qfalse;
+					}
+					stage->bundle[0].numImageAnimations++;
+				}
+			}
+			// Copy image ptrs into an array of ptrs
+			stage->bundle[0].image = (image_t*) Hunk_Alloc( stage->bundle[0].numImageAnimations * sizeof( image_t* ), qfalse );
+			memcpy( stage->bundle[0].image,	images,			stage->bundle[0].numImageAnimations * sizeof( image_t* ) );
+		}
+//#ifndef _XBOX
+		else if ( !Q_stricmp( token, "videoMap" ) )
+		{
+			token = COM_ParseExt( text, qfalse );
+			if ( !token[0] )
+			{
+				VID_Printf( PRINT_WARNING, "WARNING: missing parameter for 'videoMap' keyword in shader '%s'\n", shader.name );
+				return qfalse;
+			}
+			stage->bundle[0].videoMapHandle = CIN_PlayCinematic( token, 0, 0, 256, 256, (CIN_loop | CIN_silent | CIN_shader), NULL);
+			if (stage->bundle[0].videoMapHandle != -1) {
+				stage->bundle[0].isVideoMap = true;
+				stage->bundle[0].image = tr.scratchImage[stage->bundle[0].videoMapHandle];
+			}
+		}
+//#endif
+#ifdef _XBOX
+		//
+		// bumpmap <name>
+		//
+		else if ( !Q_stricmp( token, "bumpmap" ) )
+		{
+			token = COM_ParseExt( text, qfalse );
+			if( !token[0] )
+			{
+				VID_Printf( PRINT_WARNING, "WARNING: missing parameter for 'bumpmap' keyword in shader '%s'\n", shader.name );
+				return qfalse;
+			}
+
+			stage->bundle[0].image = R_FindImageFile( token, !shader.noMipMaps, !shader.noPicMip, 0, GL_REPEAT );
+			if ( !stage->bundle[0].image )
+			{
+				VID_Printf( PRINT_WARNING, "WARNING: R_FindImageFile could not find '%s' in shader '%s'\n", token, shader.name );
+				return qfalse;
+			}
+
+			stage->isBumpMap = qtrue;
+			shader.isBumpMap = qtrue;
+
+			shader.needsNormal = true;
+			shader.needsTangent = true;
+		}
+#endif
+		//
+		// alphafunc <func>
+		//
+		else if ( !Q_stricmp( token, "alphaFunc" ) )
+		{
+			token = COM_ParseExt( text, qfalse );
+			if ( !token[0] )
+			{
+				VID_Printf( PRINT_WARNING, "WARNING: missing parameter for 'alphaFunc' keyword in shader '%s'\n", shader.name );
+				return qfalse;
+			}
+
+			atestBits = NameToAFunc( token );
+		}
+		//
+		// depthFunc <func>
+		//
+		else if ( !Q_stricmp( token, "depthfunc" ) )
+		{
+			token = COM_ParseExt( text, qfalse );
+
+			if ( !token[0] )
+			{
+				VID_Printf( PRINT_WARNING, "WARNING: missing parameter for 'depthfunc' keyword in shader '%s'\n", shader.name );
+				return qfalse;
+			}
+
+			if ( !Q_stricmp( token, "lequal" ) )
+			{
+				depthFuncBits = 0;
+			}
+			else if ( !Q_stricmp( token, "equal" ) )
+			{
+				depthFuncBits = GLS_DEPTHFUNC_EQUAL;
+			}
+			else if ( !Q_stricmp( token, "disable" ) )
+			{
+				depthFuncBits = GLS_DEPTHTEST_DISABLE;
+			}
+			else
+			{
+				VID_Printf( PRINT_WARNING, "WARNING: unknown depthfunc '%s' in shader '%s'\n", token, shader.name );
+				continue;
+			}
+		}
+		//
+		// detail
+		//
+		else if ( !Q_stricmp( token, "detail" ) )
+		{
+			stage->isDetail = true;
+		}
+		//
+		// blendfunc <srcFactor> <dstFactor>
+		// or blendfunc <add|filter|blend>
+		//
+		else if ( !Q_stricmp( token, "blendfunc" ) )
+		{
+			token = COM_ParseExt( text, qfalse );
+			if ( token[0] == 0 )
+			{
+				VID_Printf( PRINT_WARNING, "WARNING: missing parm for blendFunc in shader '%s'\n", shader.name );
+				continue;
+			}
+			// check for "simple" blends first
+			if ( !Q_stricmp( token, "add" ) ) {
+				blendSrcBits = GLS_SRCBLEND_ONE;
+				blendDstBits = GLS_DSTBLEND_ONE;
+			} else if ( !Q_stricmp( token, "filter" ) ) {
+				blendSrcBits = GLS_SRCBLEND_DST_COLOR;
+				blendDstBits = GLS_DSTBLEND_ZERO;
+			} else if ( !Q_stricmp( token, "blend" ) ) {
+				blendSrcBits = GLS_SRCBLEND_SRC_ALPHA;
+				blendDstBits = GLS_DSTBLEND_ONE_MINUS_SRC_ALPHA;
+			} else {
+				// complex double blends
+				blendSrcBits = NameToSrcBlendMode( token );
+
+				token = COM_ParseExt( text, qfalse );
+				if ( token[0] == 0 )
+				{
+					VID_Printf( PRINT_WARNING, "WARNING: missing parm for blendFunc in shader '%s'\n", shader.name );
+					continue;
+				}
+				blendDstBits = NameToDstBlendMode( token );
+			}
+
+			// clear depth mask for blended surfaces
+			if ( !depthMaskExplicit )
+			{
+				depthMaskBits = 0;
+			}
+		}
+		//
+		// rgbGen
+		//
+		else if ( !Q_stricmp( token, "rgbGen" ) )
+		{
+			token = COM_ParseExt( text, qfalse );
+			if ( token[0] == 0 )
+			{
+				VID_Printf( PRINT_WARNING, "WARNING: missing parameters for rgbGen in shader '%s'\n", shader.name );
+				continue;
+			}
+
+			if ( !Q_stricmp( token, "wave" ) )
+			{
+				ParseWaveForm( text, &stage->rgbWave );
+				stage->rgbGen = CGEN_WAVEFORM;
+			}
+			else if ( !Q_stricmp( token, "const" ) )
+			{
+				vec3_t	color;
+
+				ParseVector( text, 3, color );
+				stage->constantColor[0] = 255 * color[0];
+				stage->constantColor[1] = 255 * color[1];
+				stage->constantColor[2] = 255 * color[2];
+
+				stage->rgbGen = CGEN_CONST;
+			}
+			else if ( !Q_stricmp( token, "identity" ) )
+			{
+				stage->rgbGen = CGEN_IDENTITY;
+			}
+			else if ( !Q_stricmp( token, "identityLighting" ) )
+			{
+				stage->rgbGen = CGEN_IDENTITY_LIGHTING;
+			}
+			else if ( !Q_stricmp( token, "entity" ) )
+			{
+				stage->rgbGen = CGEN_ENTITY;
+			}
+			else if ( !Q_stricmp( token, "oneMinusEntity" ) )
+			{
+				stage->rgbGen = CGEN_ONE_MINUS_ENTITY;
+			}
+			else if ( !Q_stricmp( token, "vertex" ) )
+			{
+				if (shader.lightmapIndex[0] == LIGHTMAP_NONE)
+				{
+					VID_Printf( PRINT_ERROR, "ERROR: rgbGen vertex used on a model! in shader '%s'\n", shader.name );
+				}
+				stage->rgbGen = CGEN_VERTEX;
+				if ( stage->alphaGen == 0 ) {
+					stage->alphaGen = AGEN_VERTEX;
+				}
+			}
+			else if ( !Q_stricmp( token, "exactVertex" ) )
+			{
+				stage->rgbGen = CGEN_EXACT_VERTEX;
+			}
+			else if ( !Q_stricmp( token, "lightingDiffuse" ) )
+			{
+				if (shader.lightmapIndex[0] != LIGHTMAP_NONE)
+				{
+					VID_Printf( PRINT_ERROR, "ERROR: rgbGen lightingDiffuse used on a misc_model! in shader '%s'\n", shader.name );
+				}
+				stage->rgbGen = CGEN_LIGHTING_DIFFUSE;
+
+#ifdef _XBOX
+				shader.needsNormal = true;
+#endif
+			}
+			else if ( !Q_stricmp( token, "lightingDiffuseEntity" ) )
+			{
+				if (shader.lightmapIndex[0] != LIGHTMAP_NONE)
+				{
+					VID_Printf( PRINT_ERROR, "ERROR: rgbGen lightingDiffuseEntity used on a misc_model! in shader '%s'\n", shader.name );
+				}
+				stage->rgbGen = CGEN_LIGHTING_DIFFUSE_ENTITY;
+
+#ifdef _XBOX
+				shader.needsNormal = true;
+#endif
+			}
+			else if ( !Q_stricmp( token, "oneMinusVertex" ) )
+			{
+				stage->rgbGen = CGEN_ONE_MINUS_VERTEX;
+			}
+			else
+			{
+				VID_Printf( PRINT_ERROR, "ERROR: unknown rgbGen parameter '%s' in shader '%s'\n", token, shader.name );
+				continue;
+			}
+		}
+		//
+		// alphaGen 
+		//
+		else if ( !Q_stricmp( token, "alphaGen" ) )
+		{
+			token = COM_ParseExt( text, qfalse );
+			if ( token[0] == 0 )
+			{
+				VID_Printf( PRINT_WARNING, "WARNING: missing parameters for alphaGen in shader '%s'\n", shader.name );
+				continue;
+			}
+
+			if ( !Q_stricmp( token, "wave" ) )
+			{
+				ParseWaveForm( text, &stage->alphaWave );
+				stage->alphaGen = AGEN_WAVEFORM;
+			}
+			else if ( !Q_stricmp( token, "const" ) )
+			{
+				token = COM_ParseExt( text, qfalse );
+				stage->constantColor[3] = 255 * atof( token );
+				stage->alphaGen = AGEN_CONST;
+			}
+			else if ( !Q_stricmp( token, "identity" ) )
+			{
+				stage->alphaGen = AGEN_IDENTITY;
+			}
+			else if ( !Q_stricmp( token, "entity" ) )
+			{
+				stage->alphaGen = AGEN_ENTITY;
+			}
+			else if ( !Q_stricmp( token, "oneMinusEntity" ) )
+			{
+				stage->alphaGen = AGEN_ONE_MINUS_ENTITY;
+			}
+			else if ( !Q_stricmp( token, "vertex" ) )
+			{
+				stage->alphaGen = AGEN_VERTEX;
+			}
+			else if ( !Q_stricmp( token, "lightingSpecular" ) )
+			{
+				stage->alphaGen = AGEN_LIGHTING_SPECULAR;
+			}
+			else if ( !Q_stricmp( token, "oneMinusVertex" ) )
+			{
+				stage->alphaGen = AGEN_ONE_MINUS_VERTEX;
+			}
+			else if ( !Q_stricmp( token, "dot" ) )
+			{
+				stage->alphaGen = AGEN_DOT;
+			}
+			else if ( !Q_stricmp( token, "oneMinusDot" ) )
+			{
+				stage->alphaGen = AGEN_ONE_MINUS_DOT;
+			}
+			else if ( !Q_stricmp( token, "portal" ) )
+			{
+				stage->alphaGen = AGEN_PORTAL;
+				token = COM_ParseExt( text, qfalse );
+				if ( token[0] == 0 )
+				{
+					shader.portalRange = 256;
+					VID_Printf( PRINT_WARNING, "WARNING: missing range parameter for alphaGen portal in shader '%s', defaulting to 256\n", shader.name );
+				}
+				else
+				{
+					shader.portalRange = atof( token );
+				}
+			}
+			else
+			{
+				VID_Printf( PRINT_WARNING, "WARNING: unknown alphaGen parameter '%s' in shader '%s'\n", token, shader.name );
+				continue;
+			}
+		}
+		//
+		// tcGen <function>
+		//
+		else if ( !Q_stricmp(token, "texgen") || !Q_stricmp( token, "tcGen" ) ) 
+		{
+			token = COM_ParseExt( text, qfalse );
+			if ( token[0] == 0 )
+			{
+				VID_Printf( PRINT_WARNING, "WARNING: missing texgen parm in shader '%s'\n", shader.name );
+				continue;
+			}
+
+			if ( !Q_stricmp( token, "environment" ) )
+			{
+				stage->bundle[0].tcGen = TCGEN_ENVIRONMENT_MAPPED;
+#ifdef _XBOX
+				shader.needsNormal = true;
+#endif
+			}
+			else if ( !Q_stricmp( token, "lightmap" ) )
+			{
+				stage->bundle[0].tcGen = TCGEN_LIGHTMAP;
+			}
+			else if ( !Q_stricmp( token, "texture" ) || !Q_stricmp( token, "base" ) )
+			{
+				stage->bundle[0].tcGen = TCGEN_TEXTURE;
+			}
+			else if ( !Q_stricmp( token, "vector" ) )
+			{
+				stage->bundle[0].tcGenVectors = ( vec3_t *) Hunk_Alloc( 2 * sizeof( vec3_t ), qfalse );
+
+				ParseVector( text, 3, stage->bundle[0].tcGenVectors[0] );
+				ParseVector( text, 3, stage->bundle[0].tcGenVectors[1] );
+
+				stage->bundle[0].tcGen = TCGEN_VECTOR;
+			}
+			else 
+			{
+				VID_Printf( PRINT_WARNING, "WARNING: unknown texgen parm in shader '%s'\n", shader.name );
+			}
+		}
+		//
+		// tcMod <type> <...>
+		//
+		else if ( !Q_stricmp( token, "tcMod" ) )
+		{
+			char buffer[1024] = "";
+
+			while ( 1 )
+			{
+				token = COM_ParseExt( text, qfalse );
+				if ( token[0] == 0 )
+					break;
+				strcat( buffer, token );
+				strcat( buffer, " " );
+			}
+
+			ParseTexMod( buffer, stage );
+
+			continue;
+		}
+		//
+		// depthmask
+		//
+		else if ( !Q_stricmp( token, "depthwrite" ) )
+		{
+			depthMaskBits = GLS_DEPTHMASK_TRUE;
+			depthMaskExplicit = qtrue;
+
+			continue;
+		}
+		// If this stage has glow...
+		else if ( Q_stricmp( token, "glow" ) == 0 )
+		{
+			stage->glow = true;
+
+			continue;
+		}
+		//
+		// surfaceSprites <type> ...
+		//
+		else if ( !Q_stricmp( token, "surfaceSprites" ) )
+		{
+			char buffer[1024] = "";
+
+			while ( 1 )
+			{
+				token = COM_ParseExt( text, qfalse );
+				if ( token[0] == 0 )
+					break;
+				strcat( buffer, token );
+				strcat( buffer, " " );
+			}
+
+			ParseSurfaceSprites( buffer, stage );
+
+			continue;
+		}
+		//
+		// ssFademax <fademax>
+		// ssFadescale <fadescale>
+		// ssVariance <varwidth> <varheight>
+		// ssHangdown
+		// ssAnyangle
+		// ssFaceup
+		// ssWind <wind>
+		// ssWindIdle <windidle>
+		// ssDuration <duration>
+		// ssGrow <growwidth> <growheight>
+		// ssWeather
+		//
+		else if (!Q_stricmpn(token, "ss", 2))	// <--- NOTE ONLY COMPARING FIRST TWO LETTERS
+		{
+			char buffer[1024] = "";
+			char param[128];
+			strcpy(param,token);
+
+			while ( 1 )
+			{
+				token = COM_ParseExt( text, qfalse );
+				if ( token[0] == 0 )
+					break;
+				strcat( buffer, token );
+				strcat( buffer, " " );
+			}
+
+			ParseSurfaceSpritesOptional( param, buffer, stage );
+
+			continue;
+		}
+		else
+		{
+			VID_Printf( PRINT_WARNING, "WARNING: unknown parameter '%s' in shader '%s'\n", token, shader.name );
+			return qfalse;
+		}
+	}
+
+	//
+	// if cgen isn't explicitly specified, use either identity or identitylighting
+	//
+	if ( stage->rgbGen == CGEN_BAD ) {
+		if ( //blendSrcBits == 0 ||
+			blendSrcBits == GLS_SRCBLEND_ONE || 
+			blendSrcBits == GLS_SRCBLEND_SRC_ALPHA ) {
+			stage->rgbGen = CGEN_IDENTITY_LIGHTING;
+		} else {
+			stage->rgbGen = CGEN_IDENTITY;
+		}
+	}
+
+
+	//
+	// implicitly assume that a GL_ONE GL_ZERO blend mask disables blending
+	//
+	if ( ( blendSrcBits == GLS_SRCBLEND_ONE ) && 
+		 ( blendDstBits == GLS_DSTBLEND_ZERO ) )
+	{
+		blendDstBits = blendSrcBits = 0;
+		depthMaskBits = GLS_DEPTHMASK_TRUE;
+	}
+
+	// decide which agens we can skip
+	if ( stage->alphaGen == AGEN_IDENTITY ) {
+		if ( stage->rgbGen == CGEN_IDENTITY
+			|| stage->rgbGen == CGEN_LIGHTING_DIFFUSE ) {
+			stage->alphaGen = AGEN_SKIP;
+		}
+	}
+
+	//
+	// compute state bits
+	//
+	stage->stateBits = depthMaskBits | 
+		               blendSrcBits | blendDstBits | 
+					   atestBits | 
+					   depthFuncBits;
+
+	return qtrue;
+}
+
+/*
+===============
+ParseDeform
+
+deformVertexes wave <spread> <waveform> <base> <amplitude> <phase> <frequency>
+deformVertexes normal <frequency> <amplitude>
+deformVertexes move <vector> <waveform> <base> <amplitude> <phase> <frequency>
+deformVertexes bulge <bulgeWidth> <bulgeHeight> <bulgeSpeed>
+deformVertexes projectionShadow
+deformVertexes autoSprite
+deformVertexes autoSprite2
+deformVertexes text[0-7]
+===============
+*/
+static void ParseDeform( const char **text ) {
+	char	*token;
+	deformStage_t	*ds;
+
+	token = COM_ParseExt( text, qfalse );
+	if ( token[0] == 0 )
+	{
+		VID_Printf( PRINT_WARNING, "WARNING: missing deform parm in shader '%s'\n", shader.name );
+		return;
+	}
+
+	if ( shader.numDeforms == MAX_SHADER_DEFORMS ) {
+		VID_Printf( PRINT_WARNING, "WARNING: MAX_SHADER_DEFORMS in '%s'\n", shader.name );
+		return;
+	}
+
+	shader.deforms[ shader.numDeforms ] = (deformStage_t *)Hunk_Alloc( sizeof( deformStage_t ), qtrue );
+
+	ds = shader.deforms[ shader.numDeforms ];
+	shader.numDeforms++;
+
+	if ( !Q_stricmp( token, "projectionShadow" ) ) {
+		ds->deformation = DEFORM_PROJECTION_SHADOW;
+		return;
+	}
+
+	if ( !Q_stricmp( token, "autosprite" ) ) {
+		ds->deformation = DEFORM_AUTOSPRITE;
+		return;
+	}
+
+	if ( !Q_stricmp( token, "autosprite2" ) ) {
+		ds->deformation = DEFORM_AUTOSPRITE2;
+		return;
+	}
+
+	if ( !Q_stricmpn( token, "text", 4 ) ) {
+		int		n;
+		
+		n = token[4] - '0';
+		if ( n < 0 || n > 7 ) {
+			n = 0;
+		}
+		ds->deformation = (deform_t) (DEFORM_TEXT0 + n);
+		return;
+	}
+
+	if ( !Q_stricmp( token, "bulge" ) )	{
+		token = COM_ParseExt( text, qfalse );
+		if ( token[0] == 0 )
+		{
+			VID_Printf( PRINT_WARNING, "WARNING: missing deformVertexes bulge parm in shader '%s'\n", shader.name );
+			return;
+		}
+		ds->bulgeWidth = atof( token );
+
+		token = COM_ParseExt( text, qfalse );
+		if ( token[0] == 0 )
+		{
+			VID_Printf( PRINT_WARNING, "WARNING: missing deformVertexes bulge parm in shader '%s'\n", shader.name );
+			return;
+		}
+		ds->bulgeHeight = atof( token );
+
+		token = COM_ParseExt( text, qfalse );
+		if ( token[0] == 0 )
+		{
+			VID_Printf( PRINT_WARNING, "WARNING: missing deformVertexes bulge parm in shader '%s'\n", shader.name );
+			return;
+		}
+		ds->bulgeSpeed = atof( token );
+
+		ds->deformation = DEFORM_BULGE;
+		return;
+	}
+
+	if ( !Q_stricmp( token, "wave" ) )
+	{
+		token = COM_ParseExt( text, qfalse );
+		if ( token[0] == 0 )
+		{
+			VID_Printf( PRINT_WARNING, "WARNING: missing deformVertexes parm in shader '%s'\n", shader.name );
+			return;
+		}
+
+		if ( atof( token ) != 0 )
+		{
+			ds->deformationSpread = 1.0f / atof( token );
+		}
+		else
+		{
+			ds->deformationSpread = 100.0f;
+			VID_Printf( PRINT_WARNING, "WARNING: illegal div value of 0 in deformVertexes command for shader '%s'\n", shader.name );
+		}
+
+		ParseWaveForm( text, &ds->deformationWave );
+		ds->deformation = DEFORM_WAVE;
+		return;
+	}
+
+	if ( !Q_stricmp( token, "normal" ) )
+	{
+		token = COM_ParseExt( text, qfalse );
+		if ( token[0] == 0 )
+		{
+			VID_Printf( PRINT_WARNING, "WARNING: missing deformVertexes parm in shader '%s'\n", shader.name );
+			return;
+		}
+		ds->deformationWave.amplitude = atof( token );
+
+		token = COM_ParseExt( text, qfalse );
+		if ( token[0] == 0 )
+		{
+			VID_Printf( PRINT_WARNING, "WARNING: missing deformVertexes parm in shader '%s'\n", shader.name );
+			return;
+		}
+		ds->deformationWave.frequency = atof( token );
+
+		ds->deformation = DEFORM_NORMALS;
+		return;
+	}
+
+	if ( !Q_stricmp( token, "move" ) ) {
+		int		i;
+
+		for ( i = 0 ; i < 3 ; i++ ) {
+			token = COM_ParseExt( text, qfalse );
+			if ( token[0] == 0 ) {
+				VID_Printf( PRINT_WARNING, "WARNING: missing deformVertexes parm in shader '%s'\n", shader.name );
+				return;
+			}
+			ds->moveVector[i] = atof( token );
+		}
+
+		ParseWaveForm( text, &ds->deformationWave );
+		ds->deformation = DEFORM_MOVE;
+		return;
+	}
+
+	VID_Printf( PRINT_WARNING, "WARNING: unknown deformVertexes subtype '%s' found in shader '%s'\n", token, shader.name );
+}
+
+
+/*
+===============
+ParseSkyParms
+
+skyParms <outerbox> <cloudheight> <innerbox>
+===============
+*/
+static void ParseSkyParms( const char **text ) {
+	char		*token;
+	const char	*suf[6] = {"rt", "lf", "bk", "ft", "up", "dn"};
+	char		pathname[MAX_QPATH];
+	int			i;
+
+	shader.sky = (skyParms_t *)Hunk_Alloc( sizeof( skyParms_t ), qtrue );
+
+	// outerbox
+	token = COM_ParseExt( text, qfalse );
+	if ( token[0] == 0 ) {
+		VID_Printf( PRINT_WARNING, "WARNING: 'skyParms' missing parameter in shader '%s'\n", shader.name );
+		return;
+	}
+	if ( strcmp( token, "-" ) ) {
+		for (i=0 ; i<6 ; i++) {
+			Com_sprintf( pathname, sizeof(pathname), "%s_%s", token, suf[i] );
+			shader.sky->outerbox[i] = R_FindImageFile( ( char * ) pathname, qtrue, qtrue, !shader.noTC, GL_CLAMP );
+			if ( !shader.sky->outerbox[i] ) {
+				if (i) {
+					shader.sky->outerbox[i] = shader.sky->outerbox[i-1];//not found, so let's use the previous image
+				}else{
+					shader.sky->outerbox[i] = tr.defaultImage;
+				}
+			}
+		}
+	}
+
+	// cloudheight
+	token = COM_ParseExt( text, qfalse );
+	if ( token[0] == 0 ) {
+		VID_Printf( PRINT_WARNING, "WARNING: 'skyParms' missing cloudheight in shader '%s'\n", shader.name );
+		return;
+	}
+	shader.sky->cloudHeight = atof( token );
+	if ( !shader.sky->cloudHeight ) {
+		shader.sky->cloudHeight = 512;
+	}
+	R_InitSkyTexCoords( shader.sky->cloudHeight );
+
+
+	// innerbox
+	token = COM_ParseExt( text, qfalse );
+	if ( strcmp( token, "-" ) ) {
+		VID_Printf( PRINT_WARNING, "WARNING: in shader '%s' 'skyParms', innerbox is not supported!", shader.name);
+	}
+}
+
+
+/*
+=================
+ParseSort
+=================
+*/
+void ParseSort( const char **text ) 
+{
+	char	*token;
+
+	token = COM_ParseExt( text, qfalse );
+	if ( token[0] == 0 ) {
+		VID_Printf( PRINT_WARNING, "WARNING: missing sort parameter in shader '%s'\n", shader.name );
+		return;
+	}
+
+	if ( !Q_stricmp( token, "portal" ) ) {
+		shader.sort = SS_PORTAL;
+	} else if ( !Q_stricmp( token, "sky" ) ) {
+		shader.sort = SS_ENVIRONMENT;
+	} else if ( !Q_stricmp( token, "opaque" ) ) {
+		shader.sort = SS_OPAQUE;
+	}else if ( !Q_stricmp( token, "decal" ) ) {
+		shader.sort = SS_DECAL;
+	} else if ( !Q_stricmp( token, "seeThrough" ) ) {
+		shader.sort = SS_SEE_THROUGH;
+	} else if ( !Q_stricmp( token, "banner" ) ) {
+		shader.sort = SS_BANNER;
+	} else if ( !Q_stricmp( token, "additive" ) ) {
+		shader.sort = SS_BLEND1;
+	} else if ( !Q_stricmp( token, "nearest" ) ) {
+		shader.sort = SS_NEAREST;
+	} else if ( !Q_stricmp( token, "underwater" ) ) {
+		shader.sort = SS_UNDERWATER;
+	} else if ( !Q_stricmp( token, "inside" ) ) {
+		shader.sort = SS_INSIDE;
+	} else if ( !Q_stricmp( token, "mid_inside" ) ) {
+		shader.sort = SS_MID_INSIDE;
+	} else if ( !Q_stricmp( token, "middle" ) ) {
+		shader.sort = SS_MIDDLE;
+	} else if ( !Q_stricmp( token, "mid_outside" ) ) {
+		shader.sort = SS_MID_OUTSIDE;
+	} else if ( !Q_stricmp( token, "outside" ) ) {
+		shader.sort = SS_OUTSIDE;
+	}
+	else
+	{
+		shader.sort = atof( token );
+	}
+}
+
+
+// this table is also present in q3map
+
+typedef struct {
+	char	*name;
+	int		clearSolid, surfaceFlags, contents;
+} infoParm_t;
+		
+
+const infoParm_t	infoParms[] = {
+	// Game content Flags
+	{"nonsolid", 	~CONTENTS_SOLID,	0, 				0 },						// special hack to clear solid flag
+	{"nonopaque", 	~CONTENTS_OPAQUE,	0, 				0 },						// special hack to clear opaque flag
+	{"lava",		~CONTENTS_SOLID,	0,				CONTENTS_LAVA },			// very damaging
+	{"slime",		~CONTENTS_SOLID,	0,				CONTENTS_SLIME },			// mildly damaging
+	{"water",		~CONTENTS_SOLID,	0,				CONTENTS_WATER },
+	{"fog",			~CONTENTS_SOLID,	0,				CONTENTS_FOG},				// carves surfaces entering
+	{"shotclip",	~CONTENTS_SOLID,	0,				CONTENTS_SHOTCLIP },		/* block shots, but not people */
+	{"playerclip",	~(CONTENTS_SOLID|CONTENTS_OPAQUE),0,CONTENTS_PLAYERCLIP },	   	/* block only the player */ 
+	{"monsterclip",	~(CONTENTS_SOLID|CONTENTS_OPAQUE),0,CONTENTS_MONSTERCLIP },		
+	{"botclip",		~(CONTENTS_SOLID|CONTENTS_OPAQUE),0,CONTENTS_BOTCLIP },		   	/* NPC do not enter */															
+	{"trigger",		~(CONTENTS_SOLID|CONTENTS_OPAQUE),0,CONTENTS_TRIGGER },
+	{"nodrop",		~(CONTENTS_SOLID|CONTENTS_OPAQUE),0,CONTENTS_NODROP },			// don't drop items or leave bodies (death fog, lava, etc)
+	{"terrain",		~(CONTENTS_SOLID|CONTENTS_OPAQUE),0,CONTENTS_TERRAIN },		   	/* use special terrain collsion */										
+	{"ladder",		~(CONTENTS_SOLID|CONTENTS_OPAQUE),0,CONTENTS_LADDER },			// climb up in it like water
+	{"abseil",		~(CONTENTS_SOLID|CONTENTS_OPAQUE),0,CONTENTS_ABSEIL },			// can abseil down this brush
+	{"outside",		~(CONTENTS_SOLID|CONTENTS_OPAQUE),0,CONTENTS_OUTSIDE },			// volume is considered to be in the outside (i.e. not indoors)
+	{"inside",		~(CONTENTS_SOLID|CONTENTS_OPAQUE),0,CONTENTS_INSIDE },			// volume is considered to be inside (i.e. indoors)
+																		
+	{"detail",		-1,					0,				CONTENTS_DETAIL },			// don't include in structural bsp
+	{"trans",		-1,					0,				CONTENTS_TRANSLUCENT },		// surface has an alpha component
+	
+	/* Game surface flags */
+	{"sky",			-1,					SURF_SKY,		0 },					   	/* emit light from an environment map */
+	{"slick",		-1,					SURF_SLICK,		0 },
+
+	{"nodamage",	-1,					SURF_NODAMAGE,	0 },					   	   																	
+	{"noimpact",	-1,					SURF_NOIMPACT,	0 },					   	/* don't make impact explosions or marks */
+	{"nomarks",		-1,					SURF_NOMARKS,	0 },					   	/* don't make impact marks, but still explode */
+	{"nodraw",		-1,					SURF_NODRAW,	0 },					   	/* don't generate a drawsurface (or a lightmap) */
+	{"nosteps",		-1,					SURF_NOSTEPS,	0 },
+	{"nodlight",	-1,					SURF_NODLIGHT,	0 },					   	/* don't ever add dynamic lights */
+	{"metalsteps",	-1,					SURF_METALSTEPS,0 },
+	{"nomiscents",	-1,					SURF_NOMISCENTS,0 },						/* No misc ents on this surface */
+	{"forcefield",	-1,					SURF_FORCEFIELD,0 },
+	{"forcesight",	-1,					SURF_FORCESIGHT,0 },						// only visible with force sight
+};
+
+
+/*
+===============
+ParseSurfaceParm
+
+surfaceparm <name>
+===============
+*/
+static void ParseSurfaceParm( const char **text ) {
+	char	*token;
+	int		numInfoParms = sizeof(infoParms) / sizeof(infoParms[0]);
+	int		i;
+
+	token = COM_ParseExt( text, qfalse );
+	for ( i = 0 ; i < numInfoParms ; i++ ) {
+		if ( !Q_stricmp( token, infoParms[i].name ) ) {
+			shader.surfaceFlags |= infoParms[i].surfaceFlags;
+			shader.contentFlags |= infoParms[i].contents;
+			shader.contentFlags &= infoParms[i].clearSolid;
+			break;
+		}
+	}
+}
+
+/*
+=================
+ParseMaterial
+=================
+*/
+const char *materialNames[MATERIAL_LAST] =
+{
+	MATERIALS
+};
+
+static void ParseMaterial( const char **text ) 
+{
+	char	*token;
+	int		i;
+
+	token = COM_ParseExt( text, qfalse );
+	if ( token[0] == 0 ) 
+	{
+		Com_Printf( S_COLOR_YELLOW "WARNING: missing material in shader '%s'\n", shader.name );
+		return;
+	}
+	for(i = 0; i < MATERIAL_LAST; i++)
+	{
+		if ( !stricmp( token, materialNames[i] ) ) 
+		{
+			shader.surfaceFlags &= ~MATERIAL_MASK;//safety, clear it first
+			shader.surfaceFlags |= i;
+			break;
+		}
+	}
+}
+
+
+/*
+=================
+ParseShader
+
+The current text pointer is at the explicit text definition of the
+shader.  Parse it into the global shader variable.  Later functions
+will optimize it.
+=================
+*/
+static qboolean ParseShader( const char  **text )
+{
+	char *token;
+	int s = 0;
+
+#ifdef _XBOX
+	shader.needsNormal = false;
+	shader.needsTangent = false;
+#endif
+
+	token = COM_ParseExt( text, qtrue );
+	if ( token[0] != '{' )
+	{
+		VID_Printf( PRINT_WARNING, "WARNING: expecting '{', found '%s' instead in shader '%s'\n", token, shader.name );
+		return qfalse;
+	}
+
+	while ( 1 )
+	{
+		token = COM_ParseExt( text, qtrue );
+		if ( !token[0] )
+		{
+			VID_Printf( PRINT_WARNING, "WARNING: no concluding '}' in shader %s\n", shader.name );
+			return qfalse;
+		}
+
+		// end of shader definition
+		if ( token[0] == '}' )
+		{
+			break;
+		}
+		// stage definition
+		else if ( token[0] == '{' )
+		{
+			if ( !ParseStage( &stages[s], text ) )
+			{
+				return qfalse;
+			}
+			stages[s].active = true;
+#ifndef _XBOX	// GLOWXXX
+			if ( stages[s].glow )
+			{
+				shader.hasGlow = true;
+			}
+#endif
+			s++;
+			continue;
+		}
+		// sun parms
+		else if ( !Q_stricmp( token, "q3map_sun" ) || !Q_stricmp( token, "sun" )) {
+			float	a, b;
+
+			token = COM_ParseExt( text, qfalse );
+			tr.sunLight[0] = atof( token );
+			token = COM_ParseExt( text, qfalse );
+			tr.sunLight[1] = atof( token );
+			token = COM_ParseExt( text, qfalse );
+			tr.sunLight[2] = atof( token );
+			
+			VectorNormalize( tr.sunLight );
+
+			token = COM_ParseExt( text, qfalse );
+			a = atof( token );
+			VectorScale( tr.sunLight, a, tr.sunLight);
+
+			token = COM_ParseExt( text, qfalse );
+			a = atof( token );
+			a = a / 180 * M_PI;
+
+			token = COM_ParseExt( text, qfalse );
+			b = atof( token );
+			b = b / 180 * M_PI;
+
+			tr.sunDirection[0] = cos( a ) * cos( b );
+			tr.sunDirection[1] = sin( a ) * cos( b );
+			tr.sunDirection[2] = sin( b );
+
+#ifdef _XBOX
+			Cvar_SetValue( "r_sundir_x", tr.sunDirection[0] );
+			Cvar_SetValue( "r_sundir_y", tr.sunDirection[1] );
+			Cvar_SetValue( "r_sundir_z", tr.sunDirection[2] );
+#endif
+		}
+		else if ( !Q_stricmp( token, "deformVertexes" ) ) {
+			ParseDeform( text );
+			continue;
+		}
+		else if ( !Q_stricmp( token, "tesssize" ) ) {
+			SkipRestOfLine( text );
+			continue;
+		}
+		// skip stuff that only the QuakeEdRadient needs
+		else if ( !Q_stricmpn( token, "qer", 3 ) ) {
+			SkipRestOfLine( text );
+			continue;
+		}
+		// skip stuff that only the q3map needs
+		else if ( !Q_stricmpn( token, "q3map", 5 ) ) {
+			SkipRestOfLine( text );
+			continue;
+		}
+		// material deprecated as of 11 Jan 01
+		// material undeprecated as of 7 May 01 - q3map_material deprecated
+		else if ( !stricmp( token, "material" ) || !stricmp( token, "q3map_material" ) )
+		{
+			ParseMaterial( text );
+		}
+		// skip stuff that JK2 doesn't use
+		else if ( !Q_stricmp( token, "lightColor") ) {
+			SkipRestOfLine( text );
+			continue;
+		}
+		// surface parms
+		else if ( !Q_stricmp( token, "surfaceParm" ) ) {
+			ParseSurfaceParm( text );
+			continue;
+		}
+		// no mip maps
+		else if ( !Q_stricmp( token, "nomipmaps" ) )
+		{
+			shader.noMipMaps = true;
+			shader.noPicMip = true;
+			continue;
+		}
+		// no picmip adjustment
+		else if ( !Q_stricmp( token, "nopicmip" ) )
+		{
+			shader.noPicMip = true;
+			continue;
+		}
+		// polygonOffset
+		else if ( !Q_stricmp( token, "polygonOffset" ) )
+		{
+			shader.polygonOffset = true;
+			continue;
+		}
+		// polygonOffset
+		else if ( !Q_stricmp( token, "noTC" ) )
+		{
+			shader.noTC = true;
+			continue;
+		}
+		// entityMergable, allowing sprite surfaces from multiple entities
+		// to be merged into one batch.  This is a savings for smoke
+		// puffs and blood, but can't be used for anything where the
+		// shader calcs (not the surface function) reference the entity color or scroll
+		else if ( !Q_stricmp( token, "entityMergable" ) )
+		{
+			shader.entityMergable = true;
+			continue;
+		}
+		// fogParms
+		else if ( !Q_stricmp( token, "fogParms" ) ) 
+		{
+			shader.fogParms = (fogParms_t *)Hunk_Alloc( sizeof( fogParms_t ), qtrue );
+			if ( !ParseVector( text, 3, shader.fogParms->color ) ) {
+				return qfalse;
+			}
+
+			token = COM_ParseExt( text, qfalse );
+			if ( !token[0] ) 
+			{
+				VID_Printf( PRINT_WARNING, "WARNING: missing parm for 'fogParms' keyword in shader '%s'\n", shader.name );
+				continue;
+			}
+			shader.fogParms->depthForOpaque = atof( token );
+
+			// skip any old gradient directions
+			SkipRestOfLine( text );
+			continue;
+		}
+		// portal
+		else if ( !Q_stricmp(token, "portal") )
+		{
+			shader.sort = SS_PORTAL;
+			continue;
+		}
+		// skyparms <cloudheight> <outerbox> <innerbox>
+		else if ( !Q_stricmp( token, "skyparms" ) )
+		{
+			ParseSkyParms( text );
+			continue;
+		}
+		// light <value> determines flaring in q3map, not needed here
+		else if ( !Q_stricmp(token, "light") ) 
+		{
+			token = COM_ParseExt( text, qfalse );
+			continue;
+		}
+		// cull <face>
+		else if ( !Q_stricmp( token, "cull") ) 
+		{
+			token = COM_ParseExt( text, qfalse );
+			if ( token[0] == 0 )
+			{
+				VID_Printf( PRINT_WARNING, "WARNING: missing cull parms in shader '%s'\n", shader.name );
+				continue;
+			}
+
+			if ( !Q_stricmp( token, "none" ) || !Q_stricmp( token, "twosided" ) || !Q_stricmp( token, "disable" ) )
+			{
+				shader.cullType = CT_TWO_SIDED;
+			}
+			else if ( !Q_stricmp( token, "back" ) || !Q_stricmp( token, "backside" ) || !Q_stricmp( token, "backsided" ) )
+			{
+				shader.cullType = CT_BACK_SIDED;
+			}
+			else
+			{
+				VID_Printf( PRINT_WARNING, "WARNING: invalid cull parm '%s' in shader '%s'\n", token, shader.name );
+			}
+			continue;
+		}
+		// sort
+		else if ( !Q_stricmp( token, "sort" ) )
+		{
+			ParseSort( text );
+			continue;
+		}
+/*
+Ghoul2 Insert Start
+*/
+
+		// 
+		// location hit mesh load
+		//
+		else if ( !Q_stricmp( token, "hitLocation" ) )
+		{
+		   
+			// grab the filename of the hit location texture
+			token = COM_ParseExt( text, qfalse );
+			if ( token[0] == 0 )
+				break;
+			continue;
+		}
+		// 
+		// location hit material mesh load
+		//
+		else if ( !Q_stricmp( token, "hitMaterial" ) )
+		{
+
+			// grab the filename of the hit location texture
+			token = COM_ParseExt( text, qfalse );
+			if ( token[0] == 0 )
+				break;
+			continue;
+
+		}
+/*
+Ghoul2 Insert End
+*/
+
+		else
+		{
+			VID_Printf( PRINT_WARNING, "WARNING: unknown general shader parameter '%s' in '%s'\n", token, shader.name );
+			return qfalse;
+		}
+	}
+
+	//
+	// ignore shaders that don't have any stages, unless it is a sky or fog
+	//
+	if ( s == 0 && !shader.sky && !(shader.contentFlags & CONTENTS_FOG ) ) {
+		return qfalse;
+	}
+
+	shader.explicitlyDefined = true;
+
+	return qtrue;
+}
+
+/*
+========================================================================================
+
+SHADER OPTIMIZATION AND FOGGING
+
+========================================================================================
+*/
+
+typedef struct {
+	int		blendA;
+	int		blendB;
+
+	int		multitextureEnv;
+	int		multitextureBlend;
+} collapse_t;
+
+static collapse_t	collapse[] = {
+	{ 0, GLS_DSTBLEND_SRC_COLOR | GLS_SRCBLEND_ZERO,	
+		GL_MODULATE, 0 },
+
+	{ 0, GLS_DSTBLEND_ZERO | GLS_SRCBLEND_DST_COLOR,
+		GL_MODULATE, 0 },
+
+	{ GLS_DSTBLEND_ZERO | GLS_SRCBLEND_DST_COLOR, GLS_DSTBLEND_ZERO | GLS_SRCBLEND_DST_COLOR,
+		GL_MODULATE, GLS_DSTBLEND_ZERO | GLS_SRCBLEND_DST_COLOR },
+
+	{ GLS_DSTBLEND_SRC_COLOR | GLS_SRCBLEND_ZERO, GLS_DSTBLEND_ZERO | GLS_SRCBLEND_DST_COLOR,
+		GL_MODULATE, GLS_DSTBLEND_ZERO | GLS_SRCBLEND_DST_COLOR },
+
+	{ GLS_DSTBLEND_ZERO | GLS_SRCBLEND_DST_COLOR, GLS_DSTBLEND_SRC_COLOR | GLS_SRCBLEND_ZERO,
+		GL_MODULATE, GLS_DSTBLEND_ZERO | GLS_SRCBLEND_DST_COLOR },
+
+	{ GLS_DSTBLEND_SRC_COLOR | GLS_SRCBLEND_ZERO, GLS_DSTBLEND_SRC_COLOR | GLS_SRCBLEND_ZERO,
+		GL_MODULATE, GLS_DSTBLEND_ZERO | GLS_SRCBLEND_DST_COLOR },
+
+	{ 0, GLS_DSTBLEND_ONE | GLS_SRCBLEND_ONE,
+		GL_ADD, 0 },
+
+	{ GLS_DSTBLEND_ONE | GLS_SRCBLEND_ONE, GLS_DSTBLEND_ONE | GLS_SRCBLEND_ONE,
+		GL_ADD, GLS_DSTBLEND_ONE | GLS_SRCBLEND_ONE },
+#if 0
+	{ 0, GLS_DSTBLEND_ONE_MINUS_SRC_ALPHA | GLS_SRCBLEND_SRC_ALPHA,
+		GL_DECAL, 0 },
+#endif
+	{ -1 }
+};
+
+/*
+================
+CollapseMultitexture
+
+Attempt to combine two stages into a single multitexture stage
+FIXME: I think modulated add + modulated add collapses incorrectly
+=================
+*/
+static qboolean CollapseMultitexture( void ) {
+	int abits, bbits;
+	int i;
+	textureBundle_t tmpBundle;
+
+	if ( !qglActiveTextureARB ) {
+		return qfalse;
+	}
+
+	// make sure both stages are active
+	if ( !stages[0].active || !stages[1].active ) {
+		return qfalse;
+	}
+
+	abits = stages[0].stateBits;
+	bbits = stages[1].stateBits;
+
+	// make sure that both stages have identical state other than blend modes
+	if ( ( abits & ~( GLS_DSTBLEND_BITS | GLS_SRCBLEND_BITS | GLS_DEPTHMASK_TRUE ) ) !=
+		( bbits & ~( GLS_DSTBLEND_BITS | GLS_SRCBLEND_BITS | GLS_DEPTHMASK_TRUE ) ) ) {
+		return qfalse;
+	}
+
+	abits &= ( GLS_DSTBLEND_BITS | GLS_SRCBLEND_BITS );
+	bbits &= ( GLS_DSTBLEND_BITS | GLS_SRCBLEND_BITS );
+
+	// search for a valid multitexture blend function
+	for ( i = 0; collapse[i].blendA != -1 ; i++ ) {
+		if ( abits == collapse[i].blendA
+			&& bbits == collapse[i].blendB ) {
+			break;
+		}
+	}
+
+	// nothing found
+	if ( collapse[i].blendA == -1 ) {
+		return qfalse;
+	}
+
+	// GL_ADD is a separate extension
+	if ( collapse[i].multitextureEnv == GL_ADD && !glConfig.textureEnvAddAvailable ) {
+		return qfalse;
+	}
+
+	// make sure waveforms have identical parameters
+	if (( stages[0].rgbGen != stages[1].rgbGen ) ||
+		( stages[0].alphaGen != stages[1].alphaGen ) )  {
+		return qfalse;
+	}
+
+	// an add collapse can only have identity colors
+	if ( collapse[i].multitextureEnv == GL_ADD && stages[0].rgbGen != CGEN_IDENTITY ) {
+		return qfalse;
+	}
+
+	if ( stages[0].rgbGen == CGEN_WAVEFORM )
+	{
+		if ( memcmp( &stages[0].rgbWave,
+					 &stages[1].rgbWave,
+					 sizeof( stages[0].rgbWave ) ) )
+		{
+			return qfalse;
+		}
+	}
+	if ( stages[0].alphaGen == CGEN_WAVEFORM )
+	{
+		if ( memcmp( &stages[0].alphaWave,
+					 &stages[1].alphaWave,
+					 sizeof( stages[0].alphaWave ) ) )
+		{
+			return qfalse;
+		}
+	}
+
+
+	// make sure that lightmaps are in bundle 1 for 3dfx
+	if ( stages[0].bundle[0].isLightmap )
+	{
+		tmpBundle = stages[0].bundle[0];
+		stages[0].bundle[0] = stages[1].bundle[0];
+		stages[0].bundle[1] = tmpBundle;
+	}
+	else
+	{
+		stages[0].bundle[1] = stages[1].bundle[0];
+	}
+
+	// set the new blend state bits
+	shader.multitextureEnv = collapse[i].multitextureEnv;
+	stages[0].stateBits &= ~( GLS_DSTBLEND_BITS | GLS_SRCBLEND_BITS );
+	stages[0].stateBits |= collapse[i].multitextureBlend;
+
+	//
+	// move down subsequent shaders
+	//
+	memmove( &stages[1], &stages[2], sizeof( stages[0] ) * ( MAX_SHADER_STAGES - 2 ) );
+	memset( &stages[MAX_SHADER_STAGES-1], 0, sizeof( stages[0] ) );
+
+	return qtrue;
+}
+
+
+/*
+==============
+SortNewShader
+
+Positions the most recently created shader in the tr.sortedShaders[]
+array so that the shader->sort key is sorted reletive to the other
+shaders.
+
+Sets shader->sortedIndex
+==============
+*/
+static void SortNewShader( void ) {
+	int		i;
+	float	sort;
+	shader_t	*newShader;
+
+	newShader = tr.shaders[ tr.numShaders - 1 ];
+	sort = newShader->sort;
+
+	for ( i = tr.numShaders - 2 ; i >= 0 ; i-- ) {
+		if ( tr.sortedShaders[ i ]->sort <= sort ) {
+			break;
+		}
+		tr.sortedShaders[i+1] = tr.sortedShaders[i];
+		tr.sortedShaders[i+1]->sortedIndex++;
+	}
+
+	newShader->sortedIndex = i+1;
+	tr.sortedShaders[i+1] = newShader;
+}
+
+
+/*
+====================
+GeneratePermanentShader
+====================
+*/
+static shader_t *GeneratePermanentShader( void ) {
+	shader_t	*newShader;
+	int			i, b;
+	int			size;
+
+	if ( tr.numShaders == MAX_SHADERS ) {
+		tr.iNumDeniedShaders++;
+		VID_Printf( PRINT_WARNING, "WARNING: GeneratePermanentShader - MAX_SHADERS (%d) hit (overflowed by %d)\n", MAX_SHADERS, tr.iNumDeniedShaders);
+		return tr.defaultShader;
+	}
+
+	newShader = (shader_t *)Hunk_Alloc( sizeof( shader_t ), qtrue );
+
+	*newShader = shader;
+
+	if ( shader.sort <= /*SS_OPAQUE*/SS_SEE_THROUGH ) {
+		newShader->fogPass = FP_EQUAL;
+	} else if ( shader.contentFlags & CONTENTS_FOG ) {
+		newShader->fogPass = FP_LE;
+	}
+
+	tr.shaders[ tr.numShaders ] = newShader;
+	newShader->index = tr.numShaders;
+	
+	tr.sortedShaders[ tr.numShaders ] = newShader;
+	newShader->sortedIndex = tr.numShaders;
+
+	tr.numShaders++;
+
+	size = newShader->numUnfoggedPasses ? newShader->numUnfoggedPasses * sizeof( stages[0] ) : sizeof( stages[0] );
+	newShader->stages = (shaderStage_t *) Hunk_Alloc( size, qtrue );
+
+	for ( i = 0 ; i < newShader->numUnfoggedPasses ; i++ ) {
+		if ( !stages[i].active ) {
+			break;
+		}
+		newShader->stages[i] = stages[i];
+
+		for ( b = 0 ; b < NUM_TEXTURE_BUNDLES ; b++ ) {
+			if (newShader->stages[i].bundle[b].numTexMods)
+			{
+				size = newShader->stages[i].bundle[b].numTexMods * sizeof( texModInfo_t );
+				newShader->stages[i].bundle[b].texMods = (texModInfo_t *) Hunk_Alloc( size, qfalse );
+				memcpy( newShader->stages[i].bundle[b].texMods, stages[i].bundle[b].texMods, size );
+			}
+			else
+			{
+				newShader->stages[i].bundle[b].texMods = 0;	//clear the globabl ptr jic
+			}
+		}
+	}
+
+	SortNewShader();
+
+	const int hash = generateHashValue(newShader->name);
+	newShader->next = sh_hashTable[hash];
+	sh_hashTable[hash] = newShader;
+
+	return newShader;
+}
+
+/*
+=================
+VertexLightingCollapse
+
+If vertex lighting is enabled, only render a single
+pass, trying to guess which is the correct one to best aproximate
+what it is supposed to look like.
+
+  OUTPUT:  Number of stages after the collapse (in the case of surfacesprites this isn't one).
+=================
+*/
+static int VertexLightingCollapse( void ) {
+	int		stage, nextopenstage;
+	shaderStage_t	*bestStage;
+	int		bestImageRank;
+	int		rank;
+	int		finalstagenum=1;
+
+	// if we aren't opaque, just use the first pass
+	if ( shader.sort == SS_OPAQUE ) {
+
+		// pick the best texture for the single pass
+		bestStage = &stages[0];
+		bestImageRank = -999999;
+
+		for ( stage = 0; stage < MAX_SHADER_STAGES; stage++ ) {
+			shaderStage_t *pStage = &stages[stage];
+
+			if ( !pStage->active ) {
+				break;
+			}
+			rank = 0;
+
+			if ( pStage->bundle[0].isLightmap ) {
+				rank -= 100;
+			}
+			if ( pStage->bundle[0].tcGen != TCGEN_TEXTURE ) {
+				rank -= 5;
+			}
+			if ( pStage->bundle[0].numTexMods ) {
+				rank -= 5;
+			}
+			if ( pStage->rgbGen != CGEN_IDENTITY && pStage->rgbGen != CGEN_IDENTITY_LIGHTING ) {
+				rank -= 3;
+			}
+
+			// SurfaceSprites are most certainly NOT desireable as the collapsed surface texture.
+			if ( pStage->ss && pStage->ss->surfaceSpriteType)
+			{
+				rank -= 1000;
+			}
+
+			if ( rank > bestImageRank  ) {
+				bestImageRank = rank;
+				bestStage = pStage;
+			}
+		}
+
+		stages[0].bundle[0] = bestStage->bundle[0];
+		stages[0].stateBits &= ~( GLS_DSTBLEND_BITS | GLS_SRCBLEND_BITS );
+		stages[0].stateBits |= GLS_DEPTHMASK_TRUE;
+		if ( shader.lightmapIndex[0] == LIGHTMAP_NONE ) {
+			stages[0].rgbGen = CGEN_LIGHTING_DIFFUSE;
+#ifdef _XBOX
+			shader.needsNormal = true;
+#endif
+		} else {
+			stages[0].rgbGen = CGEN_EXACT_VERTEX;
+		}
+		stages[0].alphaGen = AGEN_SKIP;		
+	} else {
+		// don't use a lightmap (tesla coils)
+		if ( stages[0].bundle[0].isLightmap ) {
+			stages[0] = stages[1];
+		}
+
+		// if we were in a cross-fade cgen, hack it to normal
+		if ( stages[0].rgbGen == CGEN_ONE_MINUS_ENTITY || stages[1].rgbGen == CGEN_ONE_MINUS_ENTITY ) {
+			stages[0].rgbGen = CGEN_IDENTITY_LIGHTING;
+		}
+		if ( ( stages[0].rgbGen == CGEN_WAVEFORM && stages[0].rgbWave.func == GF_SAWTOOTH )
+			&& ( stages[1].rgbGen == CGEN_WAVEFORM && stages[1].rgbWave.func == GF_INVERSE_SAWTOOTH ) ) {
+			stages[0].rgbGen = CGEN_IDENTITY_LIGHTING;
+		}
+		if ( ( stages[0].rgbGen == CGEN_WAVEFORM && stages[0].rgbWave.func == GF_INVERSE_SAWTOOTH )
+			&& ( stages[1].rgbGen == CGEN_WAVEFORM && stages[1].rgbWave.func == GF_SAWTOOTH ) ) {
+			stages[0].rgbGen = CGEN_IDENTITY_LIGHTING;
+		}
+	}
+
+	for ( stage=1, nextopenstage=1; stage < MAX_SHADER_STAGES; stage++ ) {
+		shaderStage_t *pStage = &stages[stage];
+
+		if ( !pStage->active ) {
+			break;
+		}
+
+		if (pStage->ss && pStage->ss->surfaceSpriteType)
+		{
+			// Copy this stage to the next open stage list (that is, we don't want any inactive stages before this one)
+			if (nextopenstage != stage)
+			{
+				stages[nextopenstage] = *pStage;
+				stages[nextopenstage].bundle[0] = pStage->bundle[0];
+			}
+			nextopenstage++;
+			finalstagenum++;
+			continue;
+		}
+
+		memset( pStage, 0, sizeof( *pStage ) );
+	}
+
+	return finalstagenum;
+}
+
+/*
+=========================
+FinishShader
+
+Returns a freshly allocated shader with all the needed info
+from the current global working shader
+=========================
+*/
+static shader_t *FinishShader( void ) {
+	int				stage, lmStage, stageIndex;
+	qboolean		hasLightmapStage;
+
+	hasLightmapStage = qfalse;
+
+	//
+	// set sky stuff appropriate
+	//
+	if ( shader.sky ) {
+		shader.sort = SS_ENVIRONMENT;
+	}
+
+	//
+	// set polygon offset
+	//
+	if ( shader.polygonOffset && !shader.sort ) {
+		shader.sort = SS_DECAL;
+	}
+
+	for(lmStage=0;lmStage<MAX_SHADER_STAGES;lmStage++)
+	{
+		shaderStage_t *pStage = &stages[lmStage];
+		if (pStage->active && pStage->bundle[0].isLightmap)
+		{
+			break;
+		}
+	}
+
+	if (lmStage < MAX_SHADER_STAGES)
+	{
+		if (shader.lightmapIndex[0] == LIGHTMAP_BY_VERTEX)
+		{
+			if (lmStage == 0)	//< MAX_SHADER_STAGES-1)
+			{//copy the rest down over the lightmap slot
+				memmove(&stages[lmStage], &stages[lmStage+1], sizeof(shaderStage_t) * (MAX_SHADER_STAGES-lmStage-1));
+				memset(&stages[MAX_SHADER_STAGES-1], 0, sizeof(shaderStage_t));
+				//change blending on the moved down stage
+				stages[lmStage].stateBits = GLS_DEFAULT;
+			}
+			//change anything that was moved down (or the *white if LM is first) to use vertex color
+			stages[lmStage].rgbGen = CGEN_EXACT_VERTEX;
+			stages[lmStage].alphaGen = AGEN_SKIP;
+			lmStage = MAX_SHADER_STAGES;	//skip the style checking below
+		}
+	}
+
+	if (lmStage < MAX_SHADER_STAGES)// && !r_fullbright->value)
+	{
+		int	numStyles;
+		int	i;
+
+		for(numStyles=0;numStyles<MAXLIGHTMAPS;numStyles++)
+		{
+			if (shader.styles[numStyles] >= LS_UNUSED)
+			{
+				break;
+			}
+		}
+		numStyles--;
+		if (numStyles > 0)
+		{
+			for(i=MAX_SHADER_STAGES-1;i>lmStage+numStyles;i--)
+			{
+				stages[i] = stages[i-numStyles];
+			}
+
+			for(i=0;i<numStyles;i++)
+			{
+				stages[lmStage+i+1] = stages[lmStage];
+				if (shader.lightmapIndex[i+1] == LIGHTMAP_BY_VERTEX)
+				{
+					stages[lmStage+i+1].bundle[0].image = tr.whiteImage;
+				}
+				else if (shader.lightmapIndex[i+1] < 0)
+				{
+					Com_Error( ERR_DROP, "FinishShader: light style with no light map or vertex color for shader %s", shader.name);
+				}
+				else
+				{
+					stages[lmStage+i+1].bundle[0].image = tr.lightmaps[shader.lightmapIndex[i+1]];
+					stages[lmStage+i+1].bundle[0].tcGen = (texCoordGen_t)(TCGEN_LIGHTMAP+i+1);
+				}
+				stages[lmStage+i+1].rgbGen = CGEN_LIGHTMAPSTYLE;
+				stages[lmStage+i+1].stateBits &= ~(GLS_SRCBLEND_BITS | GLS_DSTBLEND_BITS);
+				stages[lmStage+i+1].stateBits |= GLS_SRCBLEND_ONE | GLS_DSTBLEND_ONE;
+			}
+		}
+
+		for(i=0;i<=numStyles;i++)
+		{
+			stages[lmStage+i].lightmapStyle = shader.styles[i];
+		}
+	}
+
+	//
+	// set appropriate stage information
+	//
+	stageIndex = 0;
+	for ( stage = 0; stage < MAX_SHADER_STAGES; stage++ ) {
+		shaderStage_t *pStage = &stages[stage];
+
+		if ( !pStage->active ) {
+			break;
+		}
+
+		// check for a missing texture
+		if ( !pStage->bundle[0].image ) {
+			VID_Printf( PRINT_WARNING, "Shader %s has a stage with no image\n", shader.name );
+			pStage->active = false;
+			break;
+		}
+
+		//
+		// ditch this stage if it's detail and detail textures are disabled
+		//
+		if ( pStage->isDetail && !r_detailTextures->integer ) {
+			if ( stage < ( MAX_SHADER_STAGES - 1 ) ) {
+				memmove( pStage, pStage + 1, sizeof( *pStage ) * ( MAX_SHADER_STAGES - stage - 1 ) );
+				memset(  pStage + ( MAX_SHADER_STAGES - stage - 1 ), 0, sizeof( *pStage ) );	//clear the last one moved down
+				stage--;	//look at this stage next time around
+			}
+			continue;
+		}
+
+		pStage->index = stageIndex;
+
+		//
+		// default texture coordinate generation
+		//
+		if ( pStage->bundle[0].isLightmap ) {
+			if ( pStage->bundle[0].tcGen == TCGEN_BAD ) {
+				pStage->bundle[0].tcGen = TCGEN_LIGHTMAP;
+			}
+			hasLightmapStage = qtrue;
+		} else {
+			if ( pStage->bundle[0].tcGen == TCGEN_BAD ) {
+				pStage->bundle[0].tcGen = TCGEN_TEXTURE;
+			}
+		}
+
+		//
+		// determine sort order and fog color adjustment
+		//
+		if ( ( pStage->stateBits & ( GLS_SRCBLEND_BITS | GLS_DSTBLEND_BITS ) ) &&
+			 ( stages[0].stateBits & ( GLS_SRCBLEND_BITS | GLS_DSTBLEND_BITS ) ) ) {
+			int blendSrcBits = pStage->stateBits & GLS_SRCBLEND_BITS;
+			int blendDstBits = pStage->stateBits & GLS_DSTBLEND_BITS;
+
+			// fog color adjustment only works for blend modes that have a contribution
+			// that aproaches 0 as the modulate values aproach 0 --
+			// GL_ONE, GL_ONE
+			// GL_ZERO, GL_ONE_MINUS_SRC_COLOR
+			// GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA
+
+			// modulate, additive
+			if ( ( ( blendSrcBits == GLS_SRCBLEND_ONE ) && ( blendDstBits == GLS_DSTBLEND_ONE ) ) ||
+				( ( blendSrcBits == GLS_SRCBLEND_ZERO ) && ( blendDstBits == GLS_DSTBLEND_ONE_MINUS_SRC_COLOR ) ) ) {
+				pStage->adjustColorsForFog = ACFF_MODULATE_RGB;
+			}
+			// strict blend
+			else if ( ( blendSrcBits == GLS_SRCBLEND_SRC_ALPHA ) && ( blendDstBits == GLS_DSTBLEND_ONE_MINUS_SRC_ALPHA ) )
+			{
+				pStage->adjustColorsForFog = ACFF_MODULATE_ALPHA;
+			}
+			// premultiplied alpha
+			else if ( ( blendSrcBits == GLS_SRCBLEND_ONE ) && ( blendDstBits == GLS_DSTBLEND_ONE_MINUS_SRC_ALPHA ) )
+			{
+				pStage->adjustColorsForFog = ACFF_MODULATE_RGBA;
+			} else {
+				// we can't adjust this one correctly, so it won't be exactly correct in fog
+			}
+
+			// don't screw with sort order if this is a portal or environment
+			if ( !shader.sort ) {
+				// see through item, like a grill or grate
+				if ( pStage->stateBits & GLS_DEPTHMASK_TRUE ) 
+				{
+					shader.sort = SS_SEE_THROUGH;
+				} 
+				else 
+				{
+					if (( blendSrcBits == GLS_SRCBLEND_ONE ) && ( blendDstBits == GLS_DSTBLEND_ONE ))
+					{
+						// GL_ONE GL_ONE needs to come a bit later
+						shader.sort = SS_BLEND1;
+					}
+					else
+					{
+						shader.sort = SS_BLEND0;
+					}
+				}
+			}
+		}
+
+		//rww - begin hw fog
+		if ((pStage->stateBits & (GLS_SRCBLEND_BITS|GLS_DSTBLEND_BITS)) == (GLS_SRCBLEND_ONE|GLS_DSTBLEND_ONE))
+		{
+			pStage->mGLFogColorOverride = GLFOGOVERRIDE_BLACK;
+		}
+		else if ((pStage->stateBits & (GLS_SRCBLEND_BITS|GLS_DSTBLEND_BITS)) == (GLS_SRCBLEND_SRC_ALPHA|GLS_DSTBLEND_ONE) &&
+			pStage->alphaGen == AGEN_LIGHTING_SPECULAR && stage)
+		{
+			pStage->mGLFogColorOverride = GLFOGOVERRIDE_BLACK;
+		}
+		else if ((pStage->stateBits & (GLS_SRCBLEND_BITS|GLS_DSTBLEND_BITS)) == (GLS_SRCBLEND_ZERO|GLS_DSTBLEND_ZERO))
+		{
+			pStage->mGLFogColorOverride = GLFOGOVERRIDE_WHITE;
+		}
+		else if ((pStage->stateBits & (GLS_SRCBLEND_BITS|GLS_DSTBLEND_BITS)) == (GLS_SRCBLEND_ONE|GLS_DSTBLEND_ZERO))
+		{
+			pStage->mGLFogColorOverride = GLFOGOVERRIDE_WHITE;
+		}
+		else if ((pStage->stateBits & (GLS_SRCBLEND_BITS|GLS_DSTBLEND_BITS)) == 0 && stage)
+		{	// 
+			pStage->mGLFogColorOverride = GLFOGOVERRIDE_WHITE;
+		}
+		else if ((pStage->stateBits & (GLS_SRCBLEND_BITS|GLS_DSTBLEND_BITS)) == 0 && pStage->bundle[0].isLightmap && stage < MAX_SHADER_STAGES-1 &&
+			stages[stage+1].bundle[0].isLightmap)
+		{	// multiple light map blending
+			pStage->mGLFogColorOverride = GLFOGOVERRIDE_WHITE;
+		}
+		else if ((pStage->stateBits & (GLS_SRCBLEND_BITS|GLS_DSTBLEND_BITS)) == (GLS_SRCBLEND_DST_COLOR|GLS_DSTBLEND_ZERO) && pStage->bundle[0].isLightmap)
+		{ //I don't know, it works. -rww
+			pStage->mGLFogColorOverride = GLFOGOVERRIDE_WHITE;
+		}
+		else if ((pStage->stateBits & (GLS_SRCBLEND_BITS|GLS_DSTBLEND_BITS)) == (GLS_SRCBLEND_DST_COLOR|GLS_DSTBLEND_ZERO))
+		{ //I don't know, it works. -rww
+			pStage->mGLFogColorOverride = GLFOGOVERRIDE_BLACK;
+		}
+		else if ((pStage->stateBits & (GLS_SRCBLEND_BITS|GLS_DSTBLEND_BITS)) == (GLS_SRCBLEND_ONE|GLS_DSTBLEND_ONE_MINUS_SRC_COLOR))
+		{ //I don't know, it works. -rww
+			pStage->mGLFogColorOverride = GLFOGOVERRIDE_BLACK;
+		}
+		else
+		{
+			pStage->mGLFogColorOverride = GLFOGOVERRIDE_NONE;
+		}
+		//rww - end hw fog
+
+		stageIndex++;
+	}
+
+	// there are times when you will need to manually apply a sort to
+	// opaque alpha tested shaders that have later blend passes
+	if ( !shader.sort ) {
+		shader.sort = SS_OPAQUE;
+	}
+
+	//
+	// if we are in r_vertexLight mode, never use a lightmap texture
+	//
+	if ( stage > 1 && ( r_vertexLight->integer ) ) {
+		stage = VertexLightingCollapse();
+		hasLightmapStage = qfalse;
+	}
+
+	//
+	// look for multitexture potential
+	//
+	if ( stage > 1 && CollapseMultitexture() ) {
+		stage--;
+	}
+
+#ifdef _XBOX
+	for(int i = 0; i < MAX_SHADER_STAGES; i++)
+	{
+		if(stages[i].isBumpMap)
+		{
+			// Bumpmap can't be the first stage
+			assert(i > 0);
+
+			if(stages[i - 1].bundle[1].image)
+			{
+				// Previous stage has already been collapsed
+				stages[i].bundle[1] = stages[i].bundle[0];
+				stages[i].bundle[0] = stages[i - 1].bundle[0];
+			}
+			else
+			{
+				stages[i - 1].bundle[1] = stages[i].bundle[0];
+				stages[i - 1].isBumpMap = qtrue;
+
+				// move down subsequent shaders
+				memmove( &stages[i], &stages[i+1], sizeof( stages[i-1] ) * ( MAX_SHADER_STAGES - 2 ) );
+				memset( &stages[MAX_SHADER_STAGES-1], 0, sizeof( stages[i-1] ) );
+
+				stage--;
+			}
+		}
+	}
+#endif
+
+
+	if ( shader.lightmapIndex[0] >= 0 && !hasLightmapStage ) {
+		VID_Printf( PRINT_ERROR, "ERROR: shader '%s' has lightmap but no lightmap stage!\n", shader.name );
+		memcpy(shader.lightmapIndex, lightmapsNone, sizeof(shader.lightmapIndex));
+		memcpy(shader.styles, stylesDefault, sizeof(shader.styles));
+	}
+
+
+	//
+	// compute number of passes
+	//
+	shader.numUnfoggedPasses = stage;
+
+	// fogonly shaders don't have any normal passes
+	if ( stage == 0 ) {
+		shader.sort = SS_FOG;
+	}
+
+	return GeneratePermanentShader();
+}
+
+//========================================================================================
+
+/*
+====================
+FindShaderInShaderText
+
+Scans the combined text description of all the shader files for
+the given shader name.
+
+return NULL if not found
+
+If found, it will return a valid shader
+=====================
+*/
+static const char *FindShaderInShaderText( const char *shadername ) {
+	char *p = s_shaderText;
+
+	if ( !p ) {
+		return NULL;
+	}
+
+#ifdef USE_STL_FOR_SHADER_LOOKUPS
+	
+	char sLowerCaseName[MAX_QPATH];
+	Q_strncpyz(sLowerCaseName,shadername,sizeof(sLowerCaseName));
+	strlwr(sLowerCaseName);	// Q_strlwr is pretty gay, so I'm not using it
+
+	return ShaderEntryPtrs_Lookup(sLowerCaseName);
+
+#else
+
+	char *token;
+
+	// look for label
+	// note that this could get confused if a shader name is used inside
+	// another shader definition
+	while ( 1 ) {
+
+		token = COM_ParseExt( &p, qtrue );
+		if ( token[0] == 0 ) {
+			break;
+		}
+
+		if ( token[0] == '{' ) {
+			// skip the definition
+			SkipBracedSection( &p );
+		} else if ( !Q_stricmp( token, shadername ) ) {
+			return p;
+		} else {
+			// skip to end of line
+			SkipRestOfLine( &p );
+		}
+	}
+
+	return NULL;
+
+#endif
+}
+
+inline qboolean IsShader(shader_t *sh, const char *name, const int *lightmapIndex, const byte *styles)
+{
+	int	i;
+
+	if (Q_stricmp(sh->name, name))
+	{
+		return qfalse;
+	}
+
+	if (!sh->defaultShader)
+	{
+		for(i=0;i<MAXLIGHTMAPS;i++)
+		{
+			if (sh->lightmapIndex[i] != lightmapIndex[i])
+			{
+				return qfalse;
+			}
+			if (sh->styles[i] != styles[i])
+			{
+				return qfalse;
+			}
+		}
+	}
+
+	return qtrue;
+}
+
+/* 
+=============== 
+R_FindLightmap ( needed for -external LMs created by ydnar's q3map2 ) 
+given a (potentially erroneous) lightmap index, attempts to load 
+an external lightmap image and/or sets the index to a valid number 
+=============== 
+*/  
+#define EXTERNAL_LIGHTMAP     "lm_%04d.tga"     // THIS MUST BE IN SYNC WITH Q3MAP2 
+static inline const int *R_FindLightmap( const int *lightmapIndex ) 
+{
+	image_t          *image; 
+	char          fileName[ MAX_QPATH ]; 
+
+	// don't bother with vertex lighting
+	if( *lightmapIndex < 0 ) 
+		return lightmapIndex; 
+
+	// does this lightmap already exist? 
+	if( *lightmapIndex < tr.numLightmaps && tr.lightmaps[ *lightmapIndex ] != NULL ) 
+		return lightmapIndex; 
+
+	// bail if no world dir 
+	if( tr.worldDir == NULL ) 
+	{ 
+		return lightmapsVertex; 
+	} 
+
+	// sync up render thread, because we're going to have to load an image 
+	//R_SyncRenderThread(); 
+
+	// attempt to load an external lightmap 
+	sprintf( fileName, "$%s/" EXTERNAL_LIGHTMAP, tr.worldDir, *lightmapIndex ); 
+	image = R_FindImageFile( fileName, qfalse, qfalse, r_ext_compressed_lightmaps->integer, GL_CLAMP ); 
+	if( image == NULL ) 
+	{ 
+		return lightmapsVertex; 
+	} 
+
+	// add it to the lightmap list 
+	if( *lightmapIndex >= tr.numLightmaps ) 
+		tr.numLightmaps = *lightmapIndex + 1; 
+	tr.lightmaps[ *lightmapIndex ] = image; 
+	return lightmapIndex;
+}
+
+/*
+===============
+R_FindShader
+
+Will always return a valid shader, but it might be the
+default shader if the real one can't be found.
+
+In the interest of not requiring an explicit shader text entry to
+be defined for every single image used in the game, three default
+shader behaviors can be auto-created for any image:
+
+If lightmapIndex == LIGHTMAP_NONE, then the image will have
+dynamic diffuse lighting applied to it, as apropriate for most
+entity skin surfaces.
+
+If lightmapIndex == LIGHTMAP_2D, then the image will be used
+for 2D rendering unless an explicit shader is found
+
+If lightmapIndex == LIGHTMAP_BY_VERTEX, then the image will use
+the vertex rgba modulate values, as apropriate for misc_model
+pre-lit surfaces.
+
+Other lightmapIndex values will have a lightmap stage created
+and src*dest blending applied with the texture, as apropriate for
+most world construction surfaces.
+===============
+*/
+shader_t *R_FindShader( const char *name, const int *lightmapIndex, const byte *styles, qboolean mipRawImage ) {
+	char		strippedName[MAX_QPATH];
+	int			hash;
+	const char 	*shaderText;
+	image_t		*image;
+	shader_t	*sh;
+
+	if ( strlen( name ) >= MAX_QPATH ) {
+		Com_Printf( S_COLOR_RED"Shader name exceeds MAX_QPATH! %s\n",name );
+		return tr.defaultShader;
+	}
+	if ( name[0] == 0 ) {
+		return tr.defaultShader;
+	}
+
+	// use (fullbright) vertex lighting if the bsp file doesn't have
+	// lightmaps
+/*	if ( lightmapIndex[0] >= 0 && lightmapIndex[0] >= tr.numLightmaps ) {
+		lightmapIndex = lightmapsVertex;
+	}
+*/
+	lightmapIndex = R_FindLightmap(lightmapIndex);
+
+	COM_StripExtension( name, strippedName );
+
+	hash = generateHashValue(strippedName);
+
+	//
+	// see if the shader is already loaded
+	//
+	for (sh=sh_hashTable[hash]; sh; sh=sh->next) {
+		// NOTE: if there was no shader or image available with the name strippedName
+		// then a default shader is created with lightmapIndex == LIGHTMAP_NONE, so we
+		// have to check all default shaders otherwise for every call to R_FindShader
+		// with that same strippedName a new default shader is created.
+		if (IsShader(sh, strippedName, lightmapIndex, styles))
+		{	// match found
+			return sh;
+		}
+	}
+
+	// make sure the render thread is stopped, because we are probably
+	// going to have to upload an image
+	//R_SyncRenderThread();
+
+	// clear the global shader
+	ClearGlobalShader();
+	Q_strncpyz(shader.name, strippedName, sizeof(shader.name));
+	memcpy(shader.lightmapIndex, lightmapIndex, sizeof(shader.lightmapIndex));
+	memcpy(shader.styles, styles, sizeof(shader.styles));
+
+	//
+	// attempt to define shader from an explicit parameter file
+	//
+	shaderText = FindShaderInShaderText( strippedName );
+	if ( shaderText ) {
+		if ( !ParseShader( &shaderText ) ) {
+			// had errors, so use default shader
+			shader.defaultShader = true;
+		}
+		sh = FinishShader();
+		return sh;
+	}
+
+
+	//
+	// if not defined in the in-memory shader descriptions,
+	// look for a single TGA, BMP, or PCX
+	//
+	image = R_FindImageFile( name, mipRawImage, mipRawImage, qtrue, mipRawImage ? GL_REPEAT : GL_CLAMP );
+	if ( !image ) {
+		if (strncmp(name, "levelshots", 10 )  && strcmp(name, "*off")) 
+		{	//hide these warnings
+			VID_Printf( PRINT_WARNING, "WARNING: Couldn't find image for shader %s\n", name );
+		}
+		shader.defaultShader = true;
+		return FinishShader();
+	}
+
+	//
+	// create the default shading commands
+	//
+	if ( shader.lightmapIndex[0] == LIGHTMAP_NONE ) {
+		// dynamic colors at vertexes
+		stages[0].bundle[0].image = image;
+		stages[0].active = true;
+		stages[0].rgbGen = CGEN_LIGHTING_DIFFUSE;
+		stages[0].stateBits = GLS_DEFAULT;
+#ifdef _XBOX
+		shader.needsNormal = true;
+#endif
+	} else if ( shader.lightmapIndex[0] == LIGHTMAP_BY_VERTEX ) {
+		// explicit colors at vertexes
+		stages[0].bundle[0].image = image;
+		stages[0].active = true;
+		stages[0].rgbGen = CGEN_EXACT_VERTEX;
+		stages[0].alphaGen = AGEN_SKIP;
+		stages[0].stateBits = GLS_DEFAULT;
+	} else if ( shader.lightmapIndex[0] == LIGHTMAP_2D ) {
+		// GUI elements
+		stages[0].bundle[0].image = image;
+		stages[0].active = true;
+		stages[0].rgbGen = CGEN_VERTEX;
+		stages[0].alphaGen = AGEN_VERTEX;
+		stages[0].stateBits = GLS_DEPTHTEST_DISABLE |
+			  GLS_SRCBLEND_SRC_ALPHA |
+			  GLS_DSTBLEND_ONE_MINUS_SRC_ALPHA;
+	} else if ( shader.lightmapIndex[0] == LIGHTMAP_WHITEIMAGE ) {
+		// fullbright level
+		stages[0].bundle[0].image = tr.whiteImage;
+		stages[0].active = true;
+		stages[0].rgbGen = CGEN_IDENTITY_LIGHTING;
+		stages[0].stateBits = GLS_DEFAULT;
+
+		stages[1].bundle[0].image = image;
+		stages[1].active = true;
+		stages[1].rgbGen = CGEN_IDENTITY;
+		stages[1].stateBits |= GLS_SRCBLEND_DST_COLOR | GLS_DSTBLEND_ZERO;
+	} else {
+		// two pass lightmap
+		stages[0].bundle[0].image = tr.lightmaps[shader.lightmapIndex[0]];
+		stages[0].bundle[0].isLightmap = true;
+		stages[0].active = true;
+		stages[0].rgbGen = CGEN_IDENTITY;			// lightmaps are scaled on creation
+													// for identitylight
+													// light map 0 should always be style 0, which means
+													// that this will always be on
+		stages[0].stateBits = GLS_DEFAULT;
+
+		stages[1].bundle[0].image = image;
+		stages[1].active = true;
+		stages[1].rgbGen = CGEN_IDENTITY;
+		stages[1].stateBits |= GLS_SRCBLEND_DST_COLOR | GLS_DSTBLEND_ZERO;
+	}
+
+	return FinishShader();
+}
+
+/* 
+====================
+RE_RegisterShader
+
+This is the exported shader entry point for the rest of the system
+It will always return an index that will be valid.
+
+This should really only be used for explicit shaders, because there is no
+way to ask for different implicit lighting modes (vertex, lightmap, etc)
+====================
+*/
+qhandle_t RE_RegisterShader( const char *name ) {
+	shader_t	*sh;
+
+	sh = R_FindShader( name, lightmaps2d, stylesDefault, qtrue );
+
+	// we want to return 0 if the shader failed to
+	// load for some reason, but R_FindShader should
+	// still keep a name allocated for it, so if
+	// something calls RE_RegisterShader again with
+	// the same name, we don't try looking for it again
+	if ( sh->defaultShader ) {
+		return 0;
+	}
+
+	return sh->index;
+}
+
+
+/*
+====================
+RE_RegisterShaderNoMip
+
+For menu graphics that should never be picmiped
+====================
+*/
+qhandle_t RE_RegisterShaderNoMip( const char *name ) {
+	shader_t	*sh;
+
+	sh = R_FindShader( name, lightmaps2d, stylesDefault, qfalse );
+
+	// we want to return 0 if the shader failed to
+	// load for some reason, but R_FindShader should
+	// still keep a name allocated for it, so if
+	// something calls RE_RegisterShader again with
+	// the same name, we don't try looking for it again
+	if ( sh->defaultShader ) {
+		return 0;
+	}
+
+	return sh->index;
+}
+
+
+/*
+====================
+R_GetShaderByHandle
+
+When a handle is passed in by another module, this range checks
+it and returns a valid (possibly default) shader_t to be used internally.
+====================
+*/
+shader_t *R_GetShaderByHandle( qhandle_t hShader ) {
+	if ( hShader < 0 ) {
+		VID_Printf( PRINT_WARNING, "R_GetShaderByHandle: out of range hShader '%d'\n", hShader );
+		return tr.defaultShader;
+	}
+	if ( hShader >= tr.numShaders ) {
+		VID_Printf( PRINT_WARNING, "R_GetShaderByHandle: out of range hShader '%d'\n", hShader );
+		return tr.defaultShader;
+	}
+	return tr.shaders[hShader];
+}
+
+/*
+===============
+R_ShaderList_f
+
+Dump information on all valid shaders to the console
+A second parameter will cause it to print in sorted order
+===============
+*/
+void	R_ShaderList_f (void) {
+	int			i;
+	int			count;
+	shader_t	*shader;
+
+	VID_Printf (PRINT_ALL, "-----------------------\n");
+
+	count = 0;
+	for ( i = 0 ; i < tr.numShaders ; i++ ) {
+		if ( Cmd_Argc() > 1 ) {
+			shader = tr.sortedShaders[i];
+		} else {
+			shader = tr.shaders[i];
+		}
+
+		VID_Printf( PRINT_ALL, "%i ", shader->numUnfoggedPasses );
+
+		if (shader->lightmapIndex[0] >= 0 ) {
+			VID_Printf (PRINT_ALL, "L ");
+		} else {
+			VID_Printf (PRINT_ALL, "  ");
+		}
+		if ( shader->multitextureEnv == GL_ADD ) {
+			VID_Printf( PRINT_ALL, "MT(a) " );
+		} else if ( shader->multitextureEnv == GL_MODULATE ) {
+			VID_Printf( PRINT_ALL, "MT(m) " );
+		} else if ( shader->multitextureEnv == GL_DECAL ) {
+			VID_Printf( PRINT_ALL, "MT(d) " );
+		} else {
+			VID_Printf( PRINT_ALL, "      " );
+		}
+		if ( shader->explicitlyDefined ) {
+			VID_Printf( PRINT_ALL, "E " );
+		} else {
+			VID_Printf( PRINT_ALL, "  " );
+		}
+
+		if ( shader->sky )
+		{
+			VID_Printf( PRINT_ALL, "sky " );
+		} else {
+			VID_Printf( PRINT_ALL, "gen " );
+		}
+		if ( shader->defaultShader ) {
+			VID_Printf (PRINT_ALL,  ": %s (DEFAULTED)\n", shader->name);
+		} else {
+			VID_Printf (PRINT_ALL,  ": %s\n", shader->name);
+		}
+		count++;
+	}
+	VID_Printf (PRINT_ALL, "%i total shaders\n", count);
+	VID_Printf (PRINT_ALL, "------------------\n");
+}
+
+
+
+#ifdef USE_STL_FOR_SHADER_LOOKUPS
+// setup my STL shortcut list as to where all the shaders are, saves re-parsing every line for every .TGA request.
+// 
+static void SetupShaderEntryPtrs(void)
+{
+	const char *p = s_shaderText;
+	char *token;
+
+	ShaderEntryPtrs_Clear();	// extra safe, though done elsewhere already
+
+	if ( !p ) 	
+		return;
+
+	while (1) 
+	{
+		token = COM_ParseExt( &p, qtrue );
+		if ( token[0] == 0 ) 
+			break;				// EOF
+		
+		if ( token[0] == '{' )	// '}'	// counterbrace for matching
+		{				
+			SkipBracedSection( &p );
+		}
+		else
+		{
+			strlwr(token);	// token is always a ptr to com_token here, not the original buffer. 
+							//	(Not that it matters, except for reasons of speed by not strlwr'ing the whole buffer)
+
+			// token = a string of this shader name, p = ptr within s_shadertext it's found at, so store it...
+			//
+			ShaderEntryPtrs_Insert(token,p);			
+			SkipRestOfLine( &p );		// now legally skip over this name and go get the next one
+		}
+	}
+
+	//VID_Printf( PRINT_DEVELOPER, "SetupShaderEntryPtrs(): Stored %d shader ptrs\n",ShaderEntryPtrs_Size() );
+}
+#endif
+
+
+/*
+====================
+ScanAndLoadShaderFiles
+
+Finds and loads all .shader files, combining them into
+a single large text block that can be scanned for shader names
+=====================
+*/
+#define	MAX_SHADER_FILES	1024
+static void ScanAndLoadShaderFiles( void )
+{
+	char **shaderFiles;
+	char *buffers[MAX_SHADER_FILES];
+	int bufferSizes[MAX_SHADER_FILES];
+	int numShaders;
+	int i;
+	long sum = 0;
+
+	// scan for shader files
+	shaderFiles = FS_ListFiles( "shaders", ".shader", &numShaders );
+
+	if ( !shaderFiles || !numShaders )
+	{
+		VID_Printf( PRINT_WARNING, "WARNING: no shader files found\n" );
+		return;
+	}
+
+	if ( numShaders > MAX_SHADER_FILES ) {
+		numShaders = MAX_SHADER_FILES;
+	}
+
+	// load and store shader files
+	for ( i = 0; i < numShaders; i++ )
+	{
+		char filename[MAX_QPATH];
+
+		Com_sprintf( filename, sizeof( filename ), "shaders/%s", shaderFiles[i] );
+		//VID_Printf( PRINT_DEVELOPER, "...loading '%s'\n", filename );
+		// Looks like stripping out crap in the shaders will save about 200k
+		FS_ReadFile( filename, (void **)&buffers[i] );
+		if ( !buffers[i] ) {
+			Com_Error( ERR_DROP, "Couldn't load %s", filename );
+		}
+		sum += (bufferSizes[i] = COM_Compress( buffers[i] ));
+	}
+
+	// free up memory
+	FS_FreeFileList( shaderFiles );
+
+	// build single large buffer
+	s_shaderText = (char *) Hunk_Alloc( sum + numShaders*2, qtrue );
+
+	// free in reverse order, so the temp files are all dumped
+	for ( i = numShaders - 1, sum = 0; i >= 0 ; i-- ) {
+		strcat( s_shaderText + sum, "\n" );
+		strcat( s_shaderText + sum, buffers[i] );
+		sum += bufferSizes[i];
+		FS_FreeFile( buffers[i] );
+	}
+
+	#ifdef USE_STL_FOR_SHADER_LOOKUPS
+	SetupShaderEntryPtrs();
+	#endif
+}
+
+/*
+====================
+R_CreateBlendedShader
+
+  This takes 4 shaders (one per corner of a quad) and creates a blended shader the fades the textures over
+  eg.
+  if [A][A]
+     [B][B]
+  then the shader would be texture A at the top fading to texture B at the bottom
+
+  This is highly biased towards terrain shaders ie vertex lit surfaces
+====================
+*/
+
+static void R_CopyStage(shaderStage_t *orig, shaderStage_t *stage)
+{
+	// Assumption: this stage has not been collapsed
+	*stage = *orig;		//Just copy the whole thing!
+
+	if (orig->ss)
+	{	//definitely need our own copy of SS so we can modify it
+		stage->ss = (surfaceSprite_t *)Hunk_Alloc( sizeof( surfaceSprite_t ), qtrue );
+		memcpy( stage->ss, orig->ss, sizeof( surfaceSprite_t ) );
+	}
+}
+
+static void R_CreateBlendedStage(qhandle_t handle, int idx)
+{
+	shader_t	*work;
+	
+	work = R_GetShaderByHandle(handle);
+	R_CopyStage(work->stages, stages + idx);
+	stages[idx].rgbGen = CGEN_EXACT_VERTEX;
+	stages[idx].alphaGen = AGEN_BLEND;
+	stages[idx].stateBits = GLS_SRCBLEND_SRC_ALPHA | GLS_DSTBLEND_ONE | GLS_DEPTHMASK_TRUE;
+
+	if (stages[idx].ss)
+	{
+		stages[idx].ss->density *= 0.33f;
+	}
+}
+
+static qhandle_t R_MergeShaders(const char *blendedName, qhandle_t a, qhandle_t b, qhandle_t c, bool surfaceSprites)
+{
+	shader_t	*blended;
+	shader_t	*work;
+	int			current, i;
+
+	// Set up default parameters
+	ClearGlobalShader();
+	Q_strncpyz(shader.name, blendedName, sizeof(shader.name));
+	memcpy(shader.lightmapIndex, lightmapsVertex, sizeof(shader.lightmapIndex));
+	memcpy(shader.styles, stylesDefault, sizeof(shader.styles));
+	shader.fogPass = FP_EQUAL;
+
+	// Get the top left shader and set it up as pass 0 - it should be completely opaque
+	work = R_GetShaderByHandle(c);
+	stages[0].active = true;
+	R_CopyStage(&work->stages[0], stages);
+	stages[0].rgbGen = CGEN_EXACT_VERTEX;
+	stages[0].alphaGen = AGEN_BLEND;
+	stages[0].stateBits = GLS_SRCBLEND_SRC_ALPHA | GLS_DSTBLEND_ZERO | GLS_DEPTHMASK_TRUE;
+	shader.multitextureEnv = work->multitextureEnv;	//jic
+
+	// Go through the other verts and add a pass
+	R_CreateBlendedStage(a, 1);
+	R_CreateBlendedStage(b, 2);
+
+	if ( surfaceSprites )
+	{
+		current = 3;
+		work = R_GetShaderByHandle(a);
+		for(i=1;(i<work->numUnfoggedPasses && current<MAX_SHADER_STAGES);i++)
+		{
+			if (work->stages[i].ss)
+			{
+				stages[current] = work->stages[i];
+	//			stages[current].ss->density *= 0.33f;
+				stages[current].ss->density *= 3;
+				current++;
+			}
+		}
+
+		work = R_GetShaderByHandle(b);
+		for(i=1;(i<work->numUnfoggedPasses && current<MAX_SHADER_STAGES);i++)
+		{
+			if (work->stages[i].ss)
+			{
+				stages[current] = work->stages[i];
+	//			stages[current].ss->density *= 0.33f;
+				stages[current].ss->density *= 3;
+				current++;
+			}
+		}
+
+		work = R_GetShaderByHandle(c);
+		for(i=1;(i<work->numUnfoggedPasses && current<MAX_SHADER_STAGES);i++)
+		{
+			if (work->stages[i].ss)
+			{
+				stages[current] = work->stages[i];
+	//			stages[current].ss->density *= 0.33f;
+				stages[current].ss->density *= 3;
+				current++;
+			}
+		}
+	}
+
+	blended = FinishShader();
+	return(blended->index);
+}
+
+
+// Create a 3 pass shader - the last 2 passes are alpha'd out
+
+qhandle_t R_CreateBlendedShader(qhandle_t a, qhandle_t b, qhandle_t c, bool surfaceSprites )
+{
+	qhandle_t	blended;
+	shader_t	*work;
+	char		blendedName[MAX_QPATH];
+	char		extendedName[MAX_QPATH + MAX_QPATH];
+
+	Com_sprintf(blendedName, MAX_QPATH, "blend(%d,%d,%d)", a, b, c);
+	if (!surfaceSprites)
+	{
+		strcat(blendedName, "noSS");
+	}
+
+	// Find if this shader has already been created
+	R_CreateExtendedName(extendedName, blendedName, lightmapsVertex, stylesDefault);
+	work = sh_hashTable[generateHashValue(extendedName/*, FILE_HASH_SIZE*/)];
+	for ( ; work; work = work->next) 
+	{
+		if (Q_stricmp(work->name, extendedName) == 0) 
+		{
+			return work->index;
+		}
+	}
+
+	// Create new shader if it doesn't already exist
+	blended = R_MergeShaders(extendedName, a, b, c, surfaceSprites);
+	return(blended);
+}
+
+/*
+====================
+CreateInternalShaders
+====================
+*/
+static void CreateInternalShaders( void ) {
+	tr.numShaders = 0;
+	tr.iNumDeniedShaders = 0;
+
+	// init the default shader
+	memset( &shader, 0, sizeof( shader ) );
+	memset( &stages, 0, sizeof( stages ) );
+
+	Q_strncpyz( shader.name, "<default>", sizeof( shader.name ) );
+
+	memcpy(shader.lightmapIndex, lightmapsNone, sizeof(shader.lightmapIndex));
+	memcpy(shader.styles, stylesDefault, sizeof(shader.styles));
+	for ( int i = 0 ; i < MAX_SHADER_STAGES ; i++ ) {
+		stages[i].bundle[0].texMods = texMods[i];
+	}
+	stages[0].bundle[0].image = tr.defaultImage;
+	stages[0].active = true;
+	stages[0].stateBits = GLS_DEFAULT;
+	tr.defaultShader = FinishShader();
+
+	// shadow shader is just a marker
+	Q_strncpyz( shader.name, "<stencil shadow>", sizeof( shader.name ) );
+	shader.sort = SS_BANNER; //SS_STENCIL_SHADOW;
+	tr.shadowShader = FinishShader();
+
+	// distortion shader is just a marker
+	Q_strncpyz( shader.name, "internal_distortion", sizeof( shader.name ) );
+	shader.sort = SS_BLEND0;
+	shader.defaultShader = false;
+	tr.distortionShader = FinishShader();
+	shader.defaultShader = true;
+
+
+#ifndef _XBOX	// GLOWXXX
+	#define GL_PROGRAM_ERROR_STRING_ARB						0x8874
+	#define GL_PROGRAM_ERROR_POSITION_ARB					0x864B
+
+	// Allocate and Load the global 'Glow' Vertex Program. - AReis
+	if ( qglGenProgramsARB )
+	{
+		qglGenProgramsARB( 1, &tr.glowVShader );
+		qglBindProgramARB( GL_VERTEX_PROGRAM_ARB, tr.glowVShader );
+		qglProgramStringARB( GL_VERTEX_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB, strlen( ( char * ) g_strGlowVShaderARB ), g_strGlowVShaderARB );
+
+//		const GLubyte *strErr = qglGetString( GL_PROGRAM_ERROR_STRING_ARB );
+		int iErrPos = 0;
+		qglGetIntegerv( GL_PROGRAM_ERROR_POSITION_ARB, &iErrPos );
+		assert( iErrPos == -1 );
+	}
+
+	// NOTE: I make an assumption here. If you have (current) nvidia hardware, you obviously support register combiners instead of fragment
+	// programs, so use those. The problem with this is that nv30 WILL support fragment shaders, breaking this logic. The good thing is that
+	// if you always ask for regcoms before fragment shaders, you'll always just use regcoms (problem solved... for now). - AReis
+
+	// Load Pixel Shaders (either regcoms or fragprogs).
+	if ( qglCombinerParameteriNV )
+	{
+		// The purpose of this regcom is to blend all the pixels together from the 4 texture units, but with their
+		// texture coordinates offset by 1 (or more) texels, effectively letting us blend adjoining pixels. The weight is
+		// used to either strengthen or weaken the pixel intensity. The more it diffuses (the higher the radius of the glow),
+		// the higher the intensity should be for a noticable effect.
+		// Regcom result is: ( tex1 * fBlurWeight ) + ( tex2 * fBlurWeight ) + ( tex2 * fBlurWeight ) + ( tex2 * fBlurWeight )
+
+		// VV guys, this is the pixel shader you would use instead :-)
+		/*
+		// c0 is the blur weight.
+		ps 1.1
+		tex		t0
+		tex		t1
+		tex		t2
+		tex		t3
+
+		mul		r0, c0, t0;
+		madd	r0, c0, t1, r0;
+		madd	r0, c0, t2, r0;
+		madd	r0, c0, t3, r0;
+		*/
+		tr.glowPShader = qglGenLists( 1 );
+		qglNewList( tr.glowPShader, GL_COMPILE );
+			qglCombinerParameteriNV( GL_NUM_GENERAL_COMBINERS_NV, 2 );
+
+			// spare0 = fBlend * tex0 + fBlend * tex1.
+			qglCombinerInputNV( GL_COMBINER0_NV, GL_RGB, GL_VARIABLE_A_NV, GL_TEXTURE0_ARB, GL_UNSIGNED_IDENTITY_NV, GL_RGB );
+			qglCombinerInputNV( GL_COMBINER0_NV, GL_RGB, GL_VARIABLE_B_NV, GL_CONSTANT_COLOR0_NV, GL_UNSIGNED_IDENTITY_NV, GL_RGB );
+			qglCombinerInputNV( GL_COMBINER0_NV, GL_RGB, GL_VARIABLE_C_NV, GL_TEXTURE1_ARB, GL_UNSIGNED_IDENTITY_NV, GL_RGB );
+			qglCombinerInputNV( GL_COMBINER0_NV, GL_RGB, GL_VARIABLE_D_NV, GL_CONSTANT_COLOR0_NV, GL_UNSIGNED_IDENTITY_NV, GL_RGB );
+			qglCombinerOutputNV( GL_COMBINER0_NV, GL_RGB, GL_DISCARD_NV, GL_DISCARD_NV, GL_SPARE0_NV, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE );
+
+			// spare1 = fBlend * tex2 + fBlend * tex3.
+			qglCombinerInputNV( GL_COMBINER1_NV, GL_RGB, GL_VARIABLE_A_NV, GL_TEXTURE2_ARB, GL_UNSIGNED_IDENTITY_NV, GL_RGB );
+			qglCombinerInputNV( GL_COMBINER1_NV, GL_RGB, GL_VARIABLE_B_NV, GL_CONSTANT_COLOR0_NV, GL_UNSIGNED_IDENTITY_NV, GL_RGB );
+			qglCombinerInputNV( GL_COMBINER1_NV, GL_RGB, GL_VARIABLE_C_NV, GL_TEXTURE3_ARB, GL_UNSIGNED_IDENTITY_NV, GL_RGB );
+			qglCombinerInputNV( GL_COMBINER1_NV, GL_RGB, GL_VARIABLE_D_NV, GL_CONSTANT_COLOR0_NV, GL_UNSIGNED_IDENTITY_NV, GL_RGB );
+			qglCombinerOutputNV( GL_COMBINER1_NV, GL_RGB, GL_DISCARD_NV, GL_DISCARD_NV, GL_SPARE1_NV, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE );
+
+			// ( A * B ) + ( ( 1 - A ) * C ) + D = ( spare0 * 1 ) + ( ( 1 - spare0 ) * 0 ) + spare1 == spare0 + spare1.
+			qglFinalCombinerInputNV( GL_VARIABLE_A_NV, GL_SPARE0_NV,    GL_UNSIGNED_IDENTITY_NV, GL_RGB );
+			qglFinalCombinerInputNV( GL_VARIABLE_B_NV, GL_ZERO,			GL_UNSIGNED_INVERT_NV, GL_RGB );
+			qglFinalCombinerInputNV( GL_VARIABLE_C_NV, GL_ZERO,			GL_UNSIGNED_IDENTITY_NV, GL_RGB );
+			qglFinalCombinerInputNV( GL_VARIABLE_D_NV, GL_SPARE1_NV,	GL_UNSIGNED_IDENTITY_NV, GL_RGB );
+		qglEndList();
+	}
+	else if ( qglGenProgramsARB )
+	{
+		qglGenProgramsARB( 1, &tr.glowPShader );
+		qglBindProgramARB( GL_FRAGMENT_PROGRAM_ARB, tr.glowPShader );
+		qglProgramStringARB( GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB, strlen( ( char * ) g_strGlowPShaderARB ), g_strGlowPShaderARB );
+
+//		const GLubyte *strErr = qglGetString( GL_PROGRAM_ERROR_STRING_ARB );
+		int iErrPos = 0;
+		qglGetIntegerv( GL_PROGRAM_ERROR_POSITION_ARB, &iErrPos );
+		assert( iErrPos == -1 );
+	}
+#endif
+}
+
+static void CreateExternalShaders( void ) {
+	tr.projectionShadowShader = R_FindShader( "projectionShadow", lightmapsNone, stylesDefault, qtrue );
+	tr.projectionShadowShader->sort = SS_STENCIL_SHADOW;
+	tr.sunShader = R_FindShader( "sun", lightmapsVertex, stylesDefault, qtrue );
+}
+
+/*
+==================
+R_InitShaders
+==================
+*/
+void R_InitShaders( void ) {
+	//VID_Printf( PRINT_ALL, "Initializing Shaders\n" );
+
+	memset(sh_hashTable, 0, sizeof(sh_hashTable));
+/*
+Ghoul2 Insert Start
+*/
+//	memset(hitMatReg, 0, sizeof(hitMatReg));
+//	hitMatCount = 0;
+/*
+Ghoul2 Insert End
+*/
+
+
+	CreateInternalShaders();
+
+	ScanAndLoadShaderFiles();
+
+	CreateExternalShaders();
+}
diff --git a/code/renderer/tr_shadows.cpp b/code/renderer/tr_shadows.cpp
new file mode 100644
index 0000000..750a75b
--- /dev/null
+++ b/code/renderer/tr_shadows.cpp
@@ -0,0 +1,809 @@
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+
+#include "tr_local.h"
+
+#ifdef VV_LIGHTING
+#include "tr_lightmanager.h"
+#include "../win32/win_stencilshadow.h"
+#endif
+
+
+/*
+
+  for a projection shadow:
+
+  point[x] += light vector * ( z - shadow plane )
+  point[y] +=
+  point[z] = shadow plane
+
+  1 0 light[x] / light[z]
+
+*/
+#ifndef _XBOX
+
+#define _STENCIL_REVERSE
+
+typedef struct {
+	int		i2;
+	int		facing;
+} edgeDef_t;
+
+#define	MAX_EDGE_DEFS	32
+
+static	edgeDef_t	edgeDefs[SHADER_MAX_VERTEXES][MAX_EDGE_DEFS];
+static	int			numEdgeDefs[SHADER_MAX_VERTEXES];
+static	int			facing[SHADER_MAX_INDEXES/3];
+
+#endif // _XBOX
+
+void R_AddEdgeDef( int i1, int i2, int facing ) {
+#ifndef _XBOX
+	int		c;
+
+	c = numEdgeDefs[ i1 ];
+	if ( c == MAX_EDGE_DEFS ) {
+		return;		// overflow
+	}
+	edgeDefs[ i1 ][ c ].i2 = i2;
+	edgeDefs[ i1 ][ c ].facing = facing;
+
+	numEdgeDefs[ i1 ]++;
+#endif // _XBOX
+}
+
+void R_RenderShadowEdges( void ) {
+#if defined(VV_LIGHTING) && defined(_XBOX)
+	StencilShadower.RenderEdges();
+#else
+
+	int		i;
+	int		c;
+	int		j;
+	int		i2;
+	int		c_edges, c_rejected;
+#if 0
+	int		c2, k;
+	int		hit[2];
+#endif
+#ifdef _STENCIL_REVERSE
+	int		numTris;
+	int		o1, o2, o3;
+#endif
+
+	// an edge is NOT a silhouette edge if its face doesn't face the light,
+	// or if it has a reverse paired edge that also faces the light.
+	// A well behaved polyhedron would have exactly two faces for each edge,
+	// but lots of models have dangling edges or overfanned edges
+	c_edges = 0;
+	c_rejected = 0;
+
+	for ( i = 0 ; i < tess.numVertexes ; i++ ) {
+		c = numEdgeDefs[ i ];
+		for ( j = 0 ; j < c ; j++ ) {
+			if ( !edgeDefs[ i ][ j ].facing ) {
+				continue;
+			}
+
+			//with this system we can still get edges shared by more than 2 tris which
+			//produces artifacts including seeing the shadow through walls. So for now
+			//we are going to render all edges even though it is a tiny bit slower. -rww
+#if 1
+			i2 = edgeDefs[ i ][ j ].i2;
+			qglBegin( GL_TRIANGLE_STRIP );
+				qglVertex3fv( tess.xyz[ i ] );
+				qglVertex3fv( tess.xyz[ i + tess.numVertexes ] );
+				qglVertex3fv( tess.xyz[ i2 ] );
+				qglVertex3fv( tess.xyz[ i2 + tess.numVertexes ] );
+			qglEnd();
+#else
+			hit[0] = 0;
+			hit[1] = 0;
+
+			i2 = edgeDefs[ i ][ j ].i2;
+			c2 = numEdgeDefs[ i2 ];
+			for ( k = 0 ; k < c2 ; k++ ) {
+				if ( edgeDefs[ i2 ][ k ].i2 == i ) {
+					hit[ edgeDefs[ i2 ][ k ].facing ]++;
+				}
+			}
+
+			// if it doesn't share the edge with another front facing
+			// triangle, it is a sil edge
+			if ( hit[ 1 ] == 0 ) {
+				qglBegin( GL_TRIANGLE_STRIP );
+				qglVertex3fv( tess.xyz[ i ] );
+				qglVertex3fv( tess.xyz[ i + tess.numVertexes ] );
+				qglVertex3fv( tess.xyz[ i2 ] );
+				qglVertex3fv( tess.xyz[ i2 + tess.numVertexes ] );
+				qglEnd();
+				c_edges++;
+			} else {
+				c_rejected++;
+			}
+#endif
+		}
+	}
+
+#ifdef _STENCIL_REVERSE
+	//Carmack Reverse<tm> method requires that volumes
+	//be capped properly -rww
+	numTris = tess.numIndexes / 3;
+
+	for ( i = 0 ; i < numTris ; i++ )
+	{
+		if ( !facing[i] )
+		{
+			continue;
+		}
+
+		o1 = tess.indexes[ i*3 + 0 ];
+		o2 = tess.indexes[ i*3 + 1 ];
+		o3 = tess.indexes[ i*3 + 2 ];
+
+		qglBegin(GL_TRIANGLES);
+			qglVertex3fv(tess.xyz[o1]);
+			qglVertex3fv(tess.xyz[o2]);
+			qglVertex3fv(tess.xyz[o3]);
+		qglEnd();
+		qglBegin(GL_TRIANGLES);
+			qglVertex3fv(tess.xyz[o3 + tess.numVertexes]);
+			qglVertex3fv(tess.xyz[o2 + tess.numVertexes]);
+			qglVertex3fv(tess.xyz[o1 + tess.numVertexes]);
+		qglEnd();
+	}
+#endif
+#endif // VV_LIGHTING && _XBOX
+}
+
+//#define _DEBUG_STENCIL_SHADOWS
+
+/*
+=================
+RB_ShadowTessEnd
+
+triangleFromEdge[ v1 ][ v2 ]
+
+
+  set triangle from edge( v1, v2, tri )
+  if ( facing[ triangleFromEdge[ v1 ][ v2 ] ] && !facing[ triangleFromEdge[ v2 ][ v1 ] ) {
+  }
+=================
+*/
+void RB_DoShadowTessEnd( vec3_t lightPos );
+void RB_ShadowTessEnd( void )
+{
+#if defined(VV_LIGHTING) && defined(_XBOX)
+	VVdlight_t *dl;
+
+	/*for(int i = 0; i < VVLightMan.num_dlights; i++)
+	{
+		if(tess.dlightBits & (1 << i))
+		{*/
+			dl = &VVLightMan.dlights[0];//i];
+			if(StencilShadower.BuildFromLight(dl))
+				StencilShadower.RenderShadow();
+		/*}
+	}*/
+#else
+#if 0
+	if (backEnd.currentEntity &&
+		(backEnd.currentEntity->directedLight[0] ||
+			backEnd.currentEntity->directedLight[1] ||
+			backEnd.currentEntity->directedLight[2]))
+	{ //an ent that has its light set for it
+		RB_DoShadowTessEnd(NULL); 
+		return;
+	}
+
+//	if (!tess.dlightBits)
+//	{
+//		return;
+//	}
+
+	int i = 0;
+	dlight_t *dl;
+
+	R_TransformDlights( backEnd.refdef.num_dlights, backEnd.refdef.dlights, &backEnd.ori );
+/*	while (i < tr.refdef.num_dlights)
+	{
+		if (tess.dlightBits & (1 << i))
+		{
+			dl = &tr.refdef.dlights[i];
+
+			RB_DoShadowTessEnd(dl->transformed);
+		}
+        
+		i++;
+	}
+	*/
+			dl = &tr.refdef.dlights[0];
+
+			RB_DoShadowTessEnd(dl->transformed);
+
+#else //old ents-only way
+	RB_DoShadowTessEnd(NULL);
+#endif
+#endif // VV_LIGHTING && _XBOX
+}
+
+void RB_DoShadowTessEnd( vec3_t lightPos )
+{
+#ifndef _XBOX
+	int		i;
+	int		numTris;
+	vec3_t	lightDir;
+
+	// we can only do this if we have enough space in the vertex buffers
+	if ( tess.numVertexes >= SHADER_MAX_VERTEXES / 2 ) {
+		return;
+	}
+
+	if ( glConfig.stencilBits < 4 ) {
+		return;
+	}
+
+#if 1 //controlled method - try to keep shadows in range so they don't show through so much -rww
+	vec3_t	worldxyz;
+	vec3_t	entLight;
+	float	groundDist;
+
+	VectorCopy( backEnd.currentEntity->lightDir, entLight );
+	entLight[2] = 0.0f;
+	VectorNormalize(entLight);
+
+	//Oh well, just cast them straight down no matter what onto the ground plane.
+	//This presets no chance of screwups and still looks better than a stupid
+	//shader blob.
+	VectorSet(lightDir, entLight[0]*0.3f, entLight[1]*0.3f, 1.0f);
+	// project vertexes away from light direction
+	for ( i = 0 ; i < tess.numVertexes ; i++ ) {
+		//add or.origin to vert xyz to end up with world oriented coord, then figure
+		//out the ground pos for the vert to project the shadow volume to
+		VectorAdd(tess.xyz[i], backEnd.ori.origin, worldxyz);
+		groundDist = worldxyz[2] - backEnd.currentEntity->e.shadowPlane;
+		groundDist += 16.0f; //fudge factor
+		VectorMA( tess.xyz[i], -groundDist, lightDir, tess.xyz[i+tess.numVertexes] );
+	}
+#else
+	if (lightPos)
+	{
+		for ( i = 0 ; i < tess.numVertexes ; i++ )
+		{
+			tess.xyz[i+tess.numVertexes][0] = tess.xyz[i][0]+(( tess.xyz[i][0]-lightPos[0] )*128.0f);
+			tess.xyz[i+tess.numVertexes][1] = tess.xyz[i][1]+(( tess.xyz[i][1]-lightPos[1] )*128.0f);
+			tess.xyz[i+tess.numVertexes][2] = tess.xyz[i][2]+(( tess.xyz[i][2]-lightPos[2] )*128.0f);
+		}
+	}
+	else
+	{
+		VectorCopy( backEnd.currentEntity->lightDir, lightDir );
+
+		// project vertexes away from light direction
+		for ( i = 0 ; i < tess.numVertexes ; i++ ) {
+			VectorMA( tess.xyz[i], -512, lightDir, tess.xyz[i+tess.numVertexes] );
+		}
+	}
+#endif
+	// decide which triangles face the light
+	memset( numEdgeDefs, 0, 4 * tess.numVertexes );
+
+	numTris = tess.numIndexes / 3;
+	for ( i = 0 ; i < numTris ; i++ ) {
+		int		i1, i2, i3;
+		vec3_t	d1, d2, normal;
+		float	*v1, *v2, *v3;
+		float	d;
+
+		i1 = tess.indexes[ i*3 + 0 ];
+		i2 = tess.indexes[ i*3 + 1 ];
+		i3 = tess.indexes[ i*3 + 2 ];
+
+		v1 = tess.xyz[ i1 ];
+		v2 = tess.xyz[ i2 ];
+		v3 = tess.xyz[ i3 ];
+
+		if (!lightPos)
+		{
+			VectorSubtract( v2, v1, d1 );
+			VectorSubtract( v3, v1, d2 );
+			CrossProduct( d1, d2, normal );
+
+			d = DotProduct( normal, lightDir );
+		}
+		else
+		{
+			float planeEq[4];
+			planeEq[0] = v1[1]*(v2[2]-v3[2]) + v2[1]*(v3[2]-v1[2]) + v3[1]*(v1[2]-v2[2]);
+			planeEq[1] = v1[2]*(v2[0]-v3[0]) + v2[2]*(v3[0]-v1[0]) + v3[2]*(v1[0]-v2[0]);
+			planeEq[2] = v1[0]*(v2[1]-v3[1]) + v2[0]*(v3[1]-v1[1]) + v3[0]*(v1[1]-v2[1]);
+			planeEq[3] = -( v1[0]*( v2[1]*v3[2] - v3[1]*v2[2] ) +
+						v2[0]*(v3[1]*v1[2] - v1[1]*v3[2]) +
+						v3[0]*(v1[1]*v2[2] - v2[1]*v1[2]) );
+
+			d = planeEq[0]*lightPos[0]+
+				planeEq[1]*lightPos[1]+
+				planeEq[2]*lightPos[2]+
+				planeEq[3];
+		}
+
+		if ( d > 0 ) {
+			facing[ i ] = 1;
+		} else {
+			facing[ i ] = 0;
+		}
+
+		// create the edges
+		R_AddEdgeDef( i1, i2, facing[ i ] );
+		R_AddEdgeDef( i2, i3, facing[ i ] );
+		R_AddEdgeDef( i3, i1, facing[ i ] );
+	}
+
+	GL_Bind( tr.whiteImage );
+	//qglEnable( GL_CULL_FACE );
+	GL_State( GLS_SRCBLEND_ONE | GLS_DSTBLEND_ZERO );
+
+#ifndef _DEBUG_STENCIL_SHADOWS
+	qglColor3f( 0.2f, 0.2f, 0.2f );
+
+	// don't write to the color buffer
+	qglColorMask( GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE );
+
+	qglEnable( GL_STENCIL_TEST );
+	qglStencilFunc( GL_ALWAYS, 1, 255 );
+#else
+	qglColor3f( 1.0f, 0.0f, 0.0f );
+	qglPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
+	//qglDisable(GL_DEPTH_TEST);
+#endif
+
+#ifdef _STENCIL_REVERSE
+	qglDepthFunc(GL_LESS);
+
+	//now using the Carmack Reverse<tm> -rww
+	if ( backEnd.viewParms.isMirror ) {
+		//qglCullFace( GL_BACK );
+		GL_Cull(CT_BACK_SIDED);
+		qglStencilOp( GL_KEEP, GL_INCR, GL_KEEP );
+
+		R_RenderShadowEdges();
+
+		//qglCullFace( GL_FRONT );
+		GL_Cull(CT_FRONT_SIDED);
+		qglStencilOp( GL_KEEP, GL_DECR, GL_KEEP );
+
+		R_RenderShadowEdges();
+	} else {
+		//qglCullFace( GL_FRONT );
+		GL_Cull(CT_FRONT_SIDED);
+		qglStencilOp( GL_KEEP, GL_INCR, GL_KEEP );
+
+		R_RenderShadowEdges();
+
+		//qglCullFace( GL_BACK );
+		GL_Cull(CT_BACK_SIDED);
+		qglStencilOp( GL_KEEP, GL_DECR, GL_KEEP );
+
+		R_RenderShadowEdges();
+	}
+
+	qglDepthFunc(GL_LEQUAL);
+#else
+	// mirrors have the culling order reversed
+	if ( backEnd.viewParms.isMirror ) {
+		qglCullFace( GL_FRONT );
+		qglStencilOp( GL_KEEP, GL_KEEP, GL_INCR );
+
+		R_RenderShadowEdges();
+
+		qglCullFace( GL_BACK );
+		qglStencilOp( GL_KEEP, GL_KEEP, GL_DECR );
+
+		R_RenderShadowEdges();
+	} else {
+		qglCullFace( GL_BACK );
+		qglStencilOp( GL_KEEP, GL_KEEP, GL_INCR );
+
+		R_RenderShadowEdges();
+
+		qglCullFace( GL_FRONT );
+		qglStencilOp( GL_KEEP, GL_KEEP, GL_DECR );
+
+		R_RenderShadowEdges();
+	}
+#endif
+
+	// reenable writing to the color buffer
+	qglColorMask( GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE );
+
+#ifdef _DEBUG_STENCIL_SHADOWS
+	qglPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
+#endif
+#endif // _XBOX
+}
+
+
+/*
+=================
+RB_ShadowFinish
+
+Darken everything that is is a shadow volume.
+We have to delay this until everything has been shadowed,
+because otherwise shadows from different body parts would
+overlap and double darken.
+=================
+*/
+void RB_ShadowFinish( void ) {
+#if defined(VV_LIGHTING) && defined(_XBOX)
+	StencilShadower.FinishShadows();
+#else
+	if ( r_shadows->integer != 2 ) {
+		return;
+	}
+	if ( glConfig.stencilBits < 4 ) {
+		return;
+	}
+
+#ifdef _DEBUG_STENCIL_SHADOWS
+	return;
+#endif
+
+	qglEnable( GL_STENCIL_TEST );
+	qglStencilFunc( GL_NOTEQUAL, 0, 255 );
+
+	qglStencilOp( GL_KEEP, GL_KEEP, GL_KEEP );
+
+	bool planeZeroBack = false;
+	if (qglIsEnabled(GL_CLIP_PLANE0))
+	{
+		planeZeroBack = true;
+		qglDisable (GL_CLIP_PLANE0);
+	}
+	GL_Cull(CT_TWO_SIDED);
+	//qglDisable (GL_CULL_FACE);
+
+	GL_Bind( tr.whiteImage );
+
+	qglPushMatrix();
+    qglLoadIdentity ();
+
+//	qglColor3f( 0.6f, 0.6f, 0.6f );
+//	GL_State( GLS_DEPTHMASK_TRUE | GLS_SRCBLEND_DST_COLOR | GLS_DSTBLEND_ZERO );
+
+//	qglColor3f( 1, 0, 0 );
+//	GL_State( GLS_DEPTHMASK_TRUE | GLS_SRCBLEND_ONE | GLS_DSTBLEND_ZERO );
+
+	qglColor4f( 0.0f, 0.0f, 0.0f, 0.5f );
+	//GL_State( GLS_DEPTHMASK_TRUE | GLS_SRCBLEND_SRC_ALPHA | GLS_DSTBLEND_ONE_MINUS_SRC_ALPHA );
+	GL_State( GLS_SRCBLEND_SRC_ALPHA | GLS_DSTBLEND_ONE_MINUS_SRC_ALPHA );
+
+	qglBegin( GL_QUADS );
+	qglVertex3f( -100, 100, -10 );
+	qglVertex3f( 100, 100, -10 );
+	qglVertex3f( 100, -100, -10 );
+	qglVertex3f( -100, -100, -10 );
+	qglEnd ();
+
+	qglColor4f(1,1,1,1);
+	qglDisable( GL_STENCIL_TEST );
+	if (planeZeroBack)
+	{
+		qglEnable (GL_CLIP_PLANE0);
+	}
+	qglPopMatrix();
+#endif // VV_LIGHTING && _XBOX
+}
+
+
+/*
+=================
+RB_ProjectionShadowDeform
+
+=================
+*/
+void RB_ProjectionShadowDeform( void ) {
+#ifdef _XBOX
+	float	shadowMat[4][4];
+	vec3_t light, ground;
+	float d, dot;
+
+	ground[0] = backEnd.ori.axis[0][2];
+	ground[1] = backEnd.ori.axis[1][2];
+	ground[2] = backEnd.ori.axis[2][2];
+	d = backEnd.ori.origin[2] - backEnd.currentEntity->e.shadowPlane;
+
+	light[0] = backEnd.currentEntity->lightDir[0];
+	light[1] = backEnd.currentEntity->lightDir[1];
+	light[2] = backEnd.currentEntity->lightDir[2];
+
+	dot = ground[0] * light[0] + 
+		  ground[1] * light[1] + 
+		  ground[2] * light[2]; 
+	// don't let the shadows get too long or go negative
+	if ( dot < 0.5 ) 
+	{
+		VectorMA( light, (0.5 - dot), ground, light );
+		dot = DotProduct( light, ground );
+	}
+
+	shadowMat[0][0] = dot - light[0] * ground[0]; 
+	shadowMat[1][0] = 0.f - light[0] * ground[1]; 
+	shadowMat[2][0] = 0.f - light[0] * ground[2]; 
+	shadowMat[3][0] = 0.f - light[0] * d; 
+	shadowMat[0][1] = 0.f - light[1] * ground[0]; 
+	shadowMat[1][1] = dot - light[1] * ground[1]; 
+	shadowMat[2][1] = 0.f - light[1] * ground[2]; 
+	shadowMat[3][1] = 0.f - light[1] * d; 
+	shadowMat[0][2] = 0.f - light[2] * ground[0]; 
+	shadowMat[1][2] = 0.f - light[2] * ground[1]; 
+	shadowMat[2][2] = dot - light[2] * ground[2]; 
+	shadowMat[3][2] = 0.f - light[2] * d; 
+	shadowMat[0][3] = 0.f; 
+	shadowMat[1][3] = 0.f; 
+	shadowMat[2][3] = 0.f; 
+	shadowMat[3][3] = dot; 
+
+	qglMatrixMode(GL_MODELVIEW);
+	qglMultMatrixf(&shadowMat[0][0]);
+
+	// Turn on stenciling
+	// This is done to prevent overlapping shadow artifacts
+	qglEnable( GL_STENCIL_TEST ); 
+	qglStencilFunc( GL_NOTEQUAL, 0x1, 0xffffffff );
+	qglStencilMask( 0xffffffff );
+	qglStencilOp( GL_KEEP, GL_KEEP, GL_INCR );
+#else
+	float	*xyz;
+	int		i;
+	float	h;
+	vec3_t	ground;
+	vec3_t	light;
+	float	groundDist;
+	float	d;
+	vec3_t	lightDir;
+
+	xyz = ( float * ) tess.xyz;
+
+	ground[0] = backEnd.ori.axis[0][2];
+	ground[1] = backEnd.ori.axis[1][2];
+	ground[2] = backEnd.ori.axis[2][2];
+
+	groundDist = backEnd.ori.origin[2] - backEnd.currentEntity->e.shadowPlane;
+
+	VectorCopy( backEnd.currentEntity->lightDir, lightDir );
+	d = DotProduct( lightDir, ground );
+	// don't let the shadows get too long or go negative
+	if ( d < 0.5 ) {
+		VectorMA( lightDir, (0.5 - d), ground, lightDir );
+		d = DotProduct( lightDir, ground );
+	}
+	d = 1.0 / d;
+
+	light[0] = lightDir[0] * d;
+	light[1] = lightDir[1] * d;
+	light[2] = lightDir[2] * d;
+
+	for ( i = 0; i < tess.numVertexes; i++, xyz += 4 ) {
+		h = DotProduct( xyz, ground ) + groundDist;
+
+		xyz[0] -= light[0] * h;
+		xyz[1] -= light[1] * h;
+		xyz[2] -= light[2] * h;
+	}
+#endif // _XBOX
+}
+
+//update tr.screenImage
+void RB_CaptureScreenImage(void)
+{
+	int radX = 2048;
+	int radY = 2048;
+	int x = glConfig.vidWidth/2;
+	int y = glConfig.vidHeight/2;
+	int cX, cY;
+
+	GL_Bind( tr.screenImage );
+	//using this method, we could pixel-filter the texture and all sorts of crazy stuff.
+	//but, it is slow as hell.
+	/*
+	static byte *tmp = NULL;
+	if (!tmp)
+	{
+		tmp = (byte *)Z_Malloc((sizeof(byte)*4)*(glConfig.vidWidth*glConfig.vidHeight), TAG_ICARUS, qtrue);
+	}
+	qglReadPixels(0, 0, glConfig.vidWidth, glConfig.vidHeight, GL_RGBA, GL_UNSIGNED_BYTE, tmp);
+	qglTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 512, 512, 0, GL_RGBA, GL_UNSIGNED_BYTE, tmp);
+	*/
+
+	if (radX > glConfig.maxTextureSize)
+	{
+		radX = glConfig.maxTextureSize;
+	}
+	if (radY > glConfig.maxTextureSize)
+	{
+		radY = glConfig.maxTextureSize;
+	}
+
+	while (glConfig.vidWidth < radX)
+	{
+		radX /= 2;
+	}
+	while (glConfig.vidHeight < radY)
+	{
+		radY /= 2;
+	}
+
+	cX = x-(radX/2);
+	cY = y-(radY/2);
+
+	if (cX+radX > glConfig.vidWidth)
+	{ //would it go off screen?
+		cX = glConfig.vidWidth-radX;
+	}
+	else if (cX < 0)
+	{ //cap it off at 0
+		cX = 0;
+	}
+
+	if (cY+radY > glConfig.vidHeight)
+	{ //would it go off screen?
+		cY = glConfig.vidHeight-radY;
+	}
+	else if (cY < 0)
+	{ //cap it off at 0
+		cY = 0;
+	}
+
+#ifndef _XBOX
+	qglCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA16, cX, cY, radX, radY, 0);
+#else
+	qglCopyBackBufferToTexEXT(radX, radY, cX, (480 - cY), (cX + radX), (480 - (cY + radY)));
+#endif // _XBOX
+}
+
+
+//yeah.. not really shadow-related.. but it's stencil-related. -rww
+float tr_distortionAlpha = 1.0f; //opaque
+float tr_distortionStretch = 0.0f; //no stretch override
+qboolean tr_distortionPrePost = qfalse; //capture before postrender phase?
+qboolean tr_distortionNegate = qfalse; //negative blend mode
+void RB_DistortionFill(void)
+{
+	float alpha = tr_distortionAlpha;
+	float spost = 0.0f;
+	float spost2 = 0.0f;
+
+	if ( glConfig.stencilBits < 4 )
+	{
+		return;
+	}
+
+	//ok, cap the stupid thing now I guess
+	if (!tr_distortionPrePost)
+	{
+		RB_CaptureScreenImage();
+	}
+
+	qglEnable(GL_STENCIL_TEST);
+	qglStencilFunc(GL_NOTEQUAL, 0, 0xFFFFFFFF);
+	qglStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
+
+	qglDisable (GL_CLIP_PLANE0);
+	GL_Cull( CT_TWO_SIDED );
+
+	//reset the view matrices and go into ortho mode
+	qglMatrixMode(GL_PROJECTION);
+	qglPushMatrix();
+	qglLoadIdentity();
+	qglOrtho(0, glConfig.vidWidth, glConfig.vidHeight, 32, -1, 1);
+	qglMatrixMode(GL_MODELVIEW);
+	qglPushMatrix();
+	qglLoadIdentity();
+
+	if (tr_distortionStretch)
+	{ //override
+		spost = tr_distortionStretch;
+		spost2 = tr_distortionStretch;
+	}
+	else
+	{ //do slow stretchy effect
+		spost = sin(tr.refdef.time*0.0005f);
+		if (spost < 0.0f)
+		{
+			spost = -spost;
+		}
+		spost *= 0.2f;
+
+		spost2 = sin(tr.refdef.time*0.0005f);
+		if (spost2 < 0.0f)
+		{
+			spost2 = -spost2;
+		}
+		spost2 *= 0.08f;
+	}
+
+	if (alpha != 1.0f)
+	{ //blend
+		GL_State(GLS_SRCBLEND_SRC_ALPHA|GLS_DSTBLEND_SRC_ALPHA);
+	}
+	else
+	{ //be sure to reset the draw state
+		GL_State(0);
+	}
+
+#ifdef _XBOX
+	qglBeginEXT(GL_QUADS, 4, 0, 0, 4, 0);
+#else
+	qglBegin(GL_QUADS);
+#endif // _XBOX
+		qglColor4f(1.0f, 1.0f, 1.0f, alpha);
+		qglTexCoord2f(0+spost2, 1-spost);
+		qglVertex2f(0, 0);
+
+		qglTexCoord2f(0+spost2, 0+spost);
+		qglVertex2f(0, glConfig.vidHeight);
+
+		qglTexCoord2f(1-spost2, 0+spost);
+		qglVertex2f(glConfig.vidWidth, glConfig.vidHeight);
+
+		qglTexCoord2f(1-spost2, 1-spost);
+		qglVertex2f(glConfig.vidWidth, 0);
+	qglEnd();
+
+	if (tr_distortionAlpha == 1.0f && tr_distortionStretch == 0.0f)
+	{ //no overrides
+		if (tr_distortionNegate)
+		{ //probably the crazy alternate saber trail
+			alpha = 0.8f;
+			GL_State(GLS_SRCBLEND_ZERO|GLS_DSTBLEND_ONE_MINUS_SRC_COLOR);
+		}
+		else
+		{
+			alpha = 0.5f;
+			GL_State(GLS_SRCBLEND_SRC_ALPHA|GLS_DSTBLEND_SRC_ALPHA);
+		}
+
+		spost = sin(tr.refdef.time*0.0008f);
+		if (spost < 0.0f)
+		{
+			spost = -spost;
+		}
+		spost *= 0.08f;
+
+		spost2 = sin(tr.refdef.time*0.0008f);
+		if (spost2 < 0.0f)
+		{
+			spost2 = -spost2;
+		}
+		spost2 *= 0.2f;
+
+#ifdef _XBOX
+		qglBeginEXT(GL_QUADS, 4, 0, 0, 4, 0);
+#else
+		qglBegin(GL_QUADS);
+#endif // _XBOX
+			qglColor4f(1.0f, 1.0f, 1.0f, alpha);
+			qglTexCoord2f(0+spost2, 1-spost);
+			qglVertex2f(0, 0);
+
+			qglTexCoord2f(0+spost2, 0+spost);
+			qglVertex2f(0, glConfig.vidHeight);
+
+			qglTexCoord2f(1-spost2, 0+spost);
+			qglVertex2f(glConfig.vidWidth, glConfig.vidHeight);
+
+			qglTexCoord2f(1-spost2, 1-spost);
+			qglVertex2f(glConfig.vidWidth, 0);
+		qglEnd();
+	}
+
+	//pop the view matrices back
+	qglMatrixMode(GL_PROJECTION);
+	qglPopMatrix();
+	qglMatrixMode(GL_MODELVIEW);
+	qglPopMatrix();
+
+	qglDisable( GL_STENCIL_TEST );
+}
\ No newline at end of file
diff --git a/code/renderer/tr_sky.cpp b/code/renderer/tr_sky.cpp
new file mode 100644
index 0000000..785aa37
--- /dev/null
+++ b/code/renderer/tr_sky.cpp
@@ -0,0 +1,845 @@
+// tr_sky.c
+
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+
+#include "tr_local.h"
+
+#define SKY_SUBDIVISIONS		8
+#define HALF_SKY_SUBDIVISIONS	(SKY_SUBDIVISIONS/2)
+
+static float s_cloudTexCoords[6][SKY_SUBDIVISIONS+1][SKY_SUBDIVISIONS+1][2];
+static float s_cloudTexP[6][SKY_SUBDIVISIONS+1][SKY_SUBDIVISIONS+1];
+
+/*
+===================================================================================
+
+POLYGON TO BOX SIDE PROJECTION
+
+===================================================================================
+*/
+
+static vec3_t sky_clip[6] = 
+{
+	{1,1,0},
+	{1,-1,0},
+	{0,-1,1},
+	{0,1,1},
+	{1,0,1},
+	{-1,0,1} 
+};
+
+static float	sky_mins[2][6], sky_maxs[2][6];
+static float	sky_min, sky_max;
+
+/*
+================
+AddSkyPolygon
+================
+*/
+static void AddSkyPolygon (int nump, vec3_t vecs) 
+{
+	int		i,j;
+	vec3_t	v, av;
+	float	s, t, dv;
+	int		axis;
+	float	*vp;
+	// s = [0]/[2], t = [1]/[2]
+	static int	vec_to_st[6][3] =
+	{
+		{-2,3,1},
+		{2,3,-1},
+
+		{1,3,2},
+		{-1,3,-2},
+
+		{-2,-1,3},
+		{-2,1,-3}
+
+	//	{-1,2,3},
+	//	{1,2,-3}
+	};
+
+	// decide which face it maps to
+	VectorCopy (vec3_origin, v);
+	for (i=0, vp=vecs ; i<nump ; i++, vp+=3)
+	{
+		VectorAdd (vp, v, v);
+	}
+	av[0] = fabs(v[0]);
+	av[1] = fabs(v[1]);
+	av[2] = fabs(v[2]);
+	if (av[0] > av[1] && av[0] > av[2])
+	{
+		if (v[0] < 0)
+			axis = 1;
+		else
+			axis = 0;
+	}
+	else if (av[1] > av[2] && av[1] > av[0])
+	{
+		if (v[1] < 0)
+			axis = 3;
+		else
+			axis = 2;
+	}
+	else
+	{
+		if (v[2] < 0)
+			axis = 5;
+		else
+			axis = 4;
+	}
+
+	// project new texture coords
+	for (i=0 ; i<nump ; i++, vecs+=3)
+	{
+		j = vec_to_st[axis][2];
+		if (j > 0)
+			dv = vecs[j - 1];
+		else
+			dv = -vecs[-j - 1];
+		if (dv < 0.001)
+			continue;	// don't divide by zero
+		j = vec_to_st[axis][0];
+		if (j < 0)
+			s = -vecs[-j -1] / dv;
+		else
+			s = vecs[j-1] / dv;
+		j = vec_to_st[axis][1];
+		if (j < 0)
+			t = -vecs[-j -1] / dv;
+		else
+			t = vecs[j-1] / dv;
+
+		if (s < sky_mins[0][axis])
+			sky_mins[0][axis] = s;
+		if (t < sky_mins[1][axis])
+			sky_mins[1][axis] = t;
+		if (s > sky_maxs[0][axis])
+			sky_maxs[0][axis] = s;
+		if (t > sky_maxs[1][axis])
+			sky_maxs[1][axis] = t;
+	}
+}
+
+#define	ON_EPSILON		0.1			// point on plane side epsilon
+#define	MAX_CLIP_VERTS	64
+/*
+================
+ClipSkyPolygon
+================
+*/
+static void ClipSkyPolygon (int nump, vec3_t vecs, int stage) 
+{
+	float	*norm;
+	float	*v;
+	qboolean	front, back;
+	float	d, e;
+	float	dists[MAX_CLIP_VERTS];
+	int		sides[MAX_CLIP_VERTS];
+	vec3_t	newv[2][MAX_CLIP_VERTS];
+	int		newc[2];
+	int		i, j;
+
+	if (nump > MAX_CLIP_VERTS-2)
+		Com_Error (ERR_DROP, "ClipSkyPolygon: MAX_CLIP_VERTS");
+	if (stage == 6)
+	{	// fully clipped, so draw it
+		AddSkyPolygon (nump, vecs);
+		return;
+	}
+
+	front = back = qfalse;
+	norm = sky_clip[stage];
+	for (i=0, v = vecs ; i<nump ; i++, v+=3)
+	{
+		d = DotProduct (v, norm);
+		if (d > ON_EPSILON)
+		{
+			front = qtrue;
+			sides[i] = SIDE_FRONT;
+		}
+		else if (d < -ON_EPSILON)
+		{
+			back = qtrue;
+			sides[i] = SIDE_BACK;
+		}
+		else
+			sides[i] = SIDE_ON;
+		dists[i] = d;
+	}
+
+	if (!front || !back)
+	{	// not clipped
+		ClipSkyPolygon (nump, vecs, stage+1);
+		return;
+	}
+
+	// clip it
+	sides[i] = sides[0];
+	dists[i] = dists[0];
+	VectorCopy (vecs, (vecs+(i*3)) );
+	newc[0] = newc[1] = 0;
+
+	for (i=0, v = vecs ; i<nump ; i++, v+=3)
+	{
+		switch (sides[i])
+		{
+		case SIDE_FRONT:
+			VectorCopy (v, newv[0][newc[0]]);
+			newc[0]++;
+			break;
+		case SIDE_BACK:
+			VectorCopy (v, newv[1][newc[1]]);
+			newc[1]++;
+			break;
+		case SIDE_ON:
+			VectorCopy (v, newv[0][newc[0]]);
+			newc[0]++;
+			VectorCopy (v, newv[1][newc[1]]);
+			newc[1]++;
+			break;
+		}
+
+		if (sides[i] == SIDE_ON || sides[i+1] == SIDE_ON || sides[i+1] == sides[i])
+			continue;
+
+		d = dists[i] / (dists[i] - dists[i+1]);
+		for (j=0 ; j<3 ; j++)
+		{
+			e = v[j] + d*(v[j+3] - v[j]);
+			newv[0][newc[0]][j] = e;
+			newv[1][newc[1]][j] = e;
+		}
+		newc[0]++;
+		newc[1]++;
+	}
+
+	// continue
+	ClipSkyPolygon (newc[0], newv[0][0], stage+1);
+	ClipSkyPolygon (newc[1], newv[1][0], stage+1);
+}
+
+/*
+==============
+ClearSkyBox
+==============
+*/
+static void ClearSkyBox (void) {
+	int		i;
+
+	for (i=0 ; i<6 ; i++) {
+		sky_mins[0][i] = sky_mins[1][i] = MAX_WORLD_COORD;	//9999;
+		sky_maxs[0][i] = sky_maxs[1][i] = MIN_WORLD_COORD;	//-9999;
+	}
+}
+
+/*
+================
+RB_ClipSkyPolygons
+================
+*/
+void RB_ClipSkyPolygons( shaderCommands_t *input )
+{
+	vec3_t		p[5];	// need one extra point for clipping
+	int			i, j;
+
+	ClearSkyBox();
+
+	for ( i = 0; i < input->numIndexes; i += 3 )
+	{
+		for (j = 0 ; j < 3 ; j++) 
+		{
+			VectorSubtract( input->xyz[input->indexes[i+j]],
+							backEnd.viewParms.or.origin, 
+							p[j] );
+		}
+		ClipSkyPolygon( 3, p[0], 0 );
+	}
+}
+
+/*
+===================================================================================
+
+CLOUD VERTEX GENERATION
+
+===================================================================================
+*/
+
+/*
+** MakeSkyVec
+**
+** Parms: s, t range from -1 to 1
+*/
+
+static void MakeSkyVec( float s, float t, int axis, float outSt[2], vec3_t outXYZ )
+{
+	// 1 = s, 2 = t, 3 = 2048
+	static int	st_to_vec[6][3] =
+	{
+		{3,-1,2},
+		{-3,1,2},
+
+		{1,3,2},
+		{-1,-3,2},
+
+		{-2,-1,3},		// 0 degrees yaw, look straight up
+		{2,-1,-3}		// look straight down
+	};
+
+	vec3_t		b;
+	int			j, k;
+	float	boxSize;
+
+	boxSize = backEnd.viewParms.zFar / 1.75;		// div sqrt(3)
+	b[0] = s*boxSize;
+	b[1] = t*boxSize;
+	b[2] = boxSize;
+
+	for (j=0 ; j<3 ; j++)
+	{
+		k = st_to_vec[axis][j];
+		if (k < 0)
+		{
+			outXYZ[j] = -b[-k - 1];
+		}
+		else
+		{
+			outXYZ[j] = b[k - 1];
+		}
+	}
+
+	// avoid bilerp seam
+	s = (s+1)*0.5;
+	t = (t+1)*0.5;
+	if (s < sky_min)
+	{
+		s = sky_min;
+	}
+	else if (s > sky_max)
+	{
+		s = sky_max;
+	}
+
+	if (t < sky_min)
+	{
+		t = sky_min;
+	}
+	else if (t > sky_max)
+	{
+		t = sky_max;
+	}
+
+	t = 1.0 - t;
+
+
+	if ( outSt )
+	{
+		outSt[0] = s;
+		outSt[1] = t;
+	}
+}
+
+static vec3_t	s_skyPoints[SKY_SUBDIVISIONS+1][SKY_SUBDIVISIONS+1];
+static float	s_skyTexCoords[SKY_SUBDIVISIONS+1][SKY_SUBDIVISIONS+1][2];
+
+static void DrawSkySide( struct image_s *image, const int mins[2], const int maxs[2] )
+{
+	int s, t;
+
+	GL_Bind( image );
+
+#ifdef _XBOX
+	int verts = ((maxs[0]+HALF_SKY_SUBDIVISIONS) - (mins[0]+HALF_SKY_SUBDIVISIONS)) * 2 + 2;
+#endif
+
+	for ( t = mins[1]+HALF_SKY_SUBDIVISIONS; t < maxs[1]+HALF_SKY_SUBDIVISIONS; t++ )
+	{
+#ifdef _XBOX
+		qglBeginEXT( GL_TRIANGLE_STRIP, verts, 0, 0, verts, 0);
+#else
+		qglBegin( GL_TRIANGLE_STRIP );
+#endif
+
+		for ( s = mins[0]+HALF_SKY_SUBDIVISIONS; s <= maxs[0]+HALF_SKY_SUBDIVISIONS; s++ )
+		{
+			qglTexCoord2fv( s_skyTexCoords[t][s] );
+			qglVertex3fv( s_skyPoints[t][s] );
+
+			qglTexCoord2fv( s_skyTexCoords[t+1][s] );
+			qglVertex3fv( s_skyPoints[t+1][s] );
+		}
+
+		qglEnd();
+	}
+}
+
+static void DrawSkyBox( shader_t *shader )
+{
+	int		i;
+
+	sky_min = 0.0f;
+	sky_max = 1.0f;
+
+	memset( s_skyTexCoords, 0, sizeof( s_skyTexCoords ) );
+
+	for (i=0 ; i<6 ; i++)
+	{
+		int sky_mins_subd[2], sky_maxs_subd[2];
+		int s, t;
+
+		sky_mins[0][i] = floor( sky_mins[0][i] * HALF_SKY_SUBDIVISIONS ) / HALF_SKY_SUBDIVISIONS;
+		sky_mins[1][i] = floor( sky_mins[1][i] * HALF_SKY_SUBDIVISIONS ) / HALF_SKY_SUBDIVISIONS;
+		sky_maxs[0][i] = ceil( sky_maxs[0][i] * HALF_SKY_SUBDIVISIONS ) / HALF_SKY_SUBDIVISIONS;
+		sky_maxs[1][i] = ceil( sky_maxs[1][i] * HALF_SKY_SUBDIVISIONS ) / HALF_SKY_SUBDIVISIONS;
+
+		if ( ( sky_mins[0][i] >= sky_maxs[0][i] ) ||
+			 ( sky_mins[1][i] >= sky_maxs[1][i] ) )
+		{
+			continue;
+		}
+
+		sky_mins_subd[0] = sky_mins[0][i] * HALF_SKY_SUBDIVISIONS;
+		sky_mins_subd[1] = sky_mins[1][i] * HALF_SKY_SUBDIVISIONS;
+		sky_maxs_subd[0] = sky_maxs[0][i] * HALF_SKY_SUBDIVISIONS;
+		sky_maxs_subd[1] = sky_maxs[1][i] * HALF_SKY_SUBDIVISIONS;
+
+		if ( sky_mins_subd[0] < -HALF_SKY_SUBDIVISIONS ) 
+			sky_mins_subd[0] = -HALF_SKY_SUBDIVISIONS;
+		else if ( sky_mins_subd[0] > HALF_SKY_SUBDIVISIONS ) 
+			sky_mins_subd[0] = HALF_SKY_SUBDIVISIONS;
+		if ( sky_mins_subd[1] < -HALF_SKY_SUBDIVISIONS )
+			sky_mins_subd[1] = -HALF_SKY_SUBDIVISIONS;
+		else if ( sky_mins_subd[1] > HALF_SKY_SUBDIVISIONS ) 
+			sky_mins_subd[1] = HALF_SKY_SUBDIVISIONS;
+
+		if ( sky_maxs_subd[0] < -HALF_SKY_SUBDIVISIONS ) 
+			sky_maxs_subd[0] = -HALF_SKY_SUBDIVISIONS;
+		else if ( sky_maxs_subd[0] > HALF_SKY_SUBDIVISIONS ) 
+			sky_maxs_subd[0] = HALF_SKY_SUBDIVISIONS;
+		if ( sky_maxs_subd[1] < -HALF_SKY_SUBDIVISIONS ) 
+			sky_maxs_subd[1] = -HALF_SKY_SUBDIVISIONS;
+		else if ( sky_maxs_subd[1] > HALF_SKY_SUBDIVISIONS ) 
+			sky_maxs_subd[1] = HALF_SKY_SUBDIVISIONS;
+
+		//
+		// iterate through the subdivisions
+		//
+		for ( t = sky_mins_subd[1]+HALF_SKY_SUBDIVISIONS; t <= sky_maxs_subd[1]+HALF_SKY_SUBDIVISIONS; t++ )
+		{
+			for ( s = sky_mins_subd[0]+HALF_SKY_SUBDIVISIONS; s <= sky_maxs_subd[0]+HALF_SKY_SUBDIVISIONS; s++ )
+			{
+				MakeSkyVec( ( s - HALF_SKY_SUBDIVISIONS ) / ( float ) HALF_SKY_SUBDIVISIONS, 
+							( t - HALF_SKY_SUBDIVISIONS ) / ( float ) HALF_SKY_SUBDIVISIONS, 
+							i, 
+							s_skyTexCoords[t][s], 
+							s_skyPoints[t][s] );
+			}
+		}
+
+		DrawSkySide( shader->sky->outerbox[i],
+			         sky_mins_subd,
+					 sky_maxs_subd );
+	}
+
+}
+
+static void FillCloudySkySide( const int mins[2], const int maxs[2], qboolean addIndexes )
+{
+	int s, t;
+	int vertexStart = tess.numVertexes;
+	int tHeight, sWidth;
+
+	tHeight = maxs[1] - mins[1] + 1;
+	sWidth = maxs[0] - mins[0] + 1;
+
+	for ( t = mins[1]+HALF_SKY_SUBDIVISIONS; t <= maxs[1]+HALF_SKY_SUBDIVISIONS; t++ )
+	{
+		for ( s = mins[0]+HALF_SKY_SUBDIVISIONS; s <= maxs[0]+HALF_SKY_SUBDIVISIONS; s++ )
+		{
+			VectorAdd( s_skyPoints[t][s], backEnd.viewParms.or.origin, tess.xyz[tess.numVertexes] );
+			tess.texCoords[tess.numVertexes][0][0] = s_skyTexCoords[t][s][0];
+			tess.texCoords[tess.numVertexes][0][1] = s_skyTexCoords[t][s][1];
+
+			tess.numVertexes++;
+
+			if ( tess.numVertexes >= SHADER_MAX_VERTEXES )
+			{
+				Com_Error( ERR_DROP, "SHADER_MAX_VERTEXES hit in FillCloudySkySide()\n" );
+			}
+		}
+	}
+
+	// only add indexes for one pass, otherwise it would draw multiple times for each pass
+	if ( addIndexes ) {
+		for ( t = 0; t < tHeight-1; t++ )
+		{	
+			for ( s = 0; s < sWidth-1; s++ )
+			{
+				tess.indexes[tess.numIndexes] = vertexStart + s + t * ( sWidth );
+				tess.numIndexes++;
+				tess.indexes[tess.numIndexes] = vertexStart + s + ( t + 1 ) * ( sWidth );
+				tess.numIndexes++;
+				tess.indexes[tess.numIndexes] = vertexStart + s + 1 + t * ( sWidth );
+				tess.numIndexes++;
+
+				tess.indexes[tess.numIndexes] = vertexStart + s + ( t + 1 ) * ( sWidth );
+				tess.numIndexes++;
+				tess.indexes[tess.numIndexes] = vertexStart + s + 1 + ( t + 1 ) * ( sWidth );
+				tess.numIndexes++;
+				tess.indexes[tess.numIndexes] = vertexStart + s + 1 + t * ( sWidth );
+				tess.numIndexes++;
+			}
+		}
+	}
+}
+
+static void FillCloudBox( const shader_t *shader, int stage )
+{
+	int i;
+
+	for ( i =0; i < 6; i++ )
+	{
+		int sky_mins_subd[2], sky_maxs_subd[2];
+		int s, t;
+		float MIN_T;
+
+		if ( 1 ) // FIXME? shader->sky->fullClouds )
+		{
+			MIN_T = -HALF_SKY_SUBDIVISIONS;
+
+			// still don't want to draw the bottom, even if fullClouds
+			if ( i == 5 )
+				continue;
+		}
+		else
+		{
+			switch( i )
+			{
+			case 0:
+			case 1:
+			case 2:
+			case 3:
+				MIN_T = -1;
+				break;
+			case 5:
+				// don't draw clouds beneath you
+				continue;
+			case 4:		// top
+			default:
+				MIN_T = -HALF_SKY_SUBDIVISIONS;
+				break;
+			}
+		}
+
+		sky_mins[0][i] = floor( sky_mins[0][i] * HALF_SKY_SUBDIVISIONS ) / HALF_SKY_SUBDIVISIONS;
+		sky_mins[1][i] = floor( sky_mins[1][i] * HALF_SKY_SUBDIVISIONS ) / HALF_SKY_SUBDIVISIONS;
+		sky_maxs[0][i] = ceil( sky_maxs[0][i] * HALF_SKY_SUBDIVISIONS ) / HALF_SKY_SUBDIVISIONS;
+		sky_maxs[1][i] = ceil( sky_maxs[1][i] * HALF_SKY_SUBDIVISIONS ) / HALF_SKY_SUBDIVISIONS;
+
+		if ( ( sky_mins[0][i] >= sky_maxs[0][i] ) ||
+			 ( sky_mins[1][i] >= sky_maxs[1][i] ) )
+		{
+			continue;
+		}
+
+		sky_mins_subd[0] = myftol( sky_mins[0][i] * HALF_SKY_SUBDIVISIONS );
+		sky_mins_subd[1] = myftol( sky_mins[1][i] * HALF_SKY_SUBDIVISIONS );
+		sky_maxs_subd[0] = myftol( sky_maxs[0][i] * HALF_SKY_SUBDIVISIONS );
+		sky_maxs_subd[1] = myftol( sky_maxs[1][i] * HALF_SKY_SUBDIVISIONS );
+
+		if ( sky_mins_subd[0] < -HALF_SKY_SUBDIVISIONS ) 
+			sky_mins_subd[0] = -HALF_SKY_SUBDIVISIONS;
+		else if ( sky_mins_subd[0] > HALF_SKY_SUBDIVISIONS ) 
+			sky_mins_subd[0] = HALF_SKY_SUBDIVISIONS;
+		if ( sky_mins_subd[1] < MIN_T )
+			sky_mins_subd[1] = MIN_T;
+		else if ( sky_mins_subd[1] > HALF_SKY_SUBDIVISIONS ) 
+			sky_mins_subd[1] = HALF_SKY_SUBDIVISIONS;
+
+		if ( sky_maxs_subd[0] < -HALF_SKY_SUBDIVISIONS ) 
+			sky_maxs_subd[0] = -HALF_SKY_SUBDIVISIONS;
+		else if ( sky_maxs_subd[0] > HALF_SKY_SUBDIVISIONS ) 
+			sky_maxs_subd[0] = HALF_SKY_SUBDIVISIONS;
+		if ( sky_maxs_subd[1] < MIN_T )
+			sky_maxs_subd[1] = MIN_T;
+		else if ( sky_maxs_subd[1] > HALF_SKY_SUBDIVISIONS ) 
+			sky_maxs_subd[1] = HALF_SKY_SUBDIVISIONS;
+
+		//
+		// iterate through the subdivisions
+		//
+		for ( t = sky_mins_subd[1]+HALF_SKY_SUBDIVISIONS; t <= sky_maxs_subd[1]+HALF_SKY_SUBDIVISIONS; t++ )
+		{
+			for ( s = sky_mins_subd[0]+HALF_SKY_SUBDIVISIONS; s <= sky_maxs_subd[0]+HALF_SKY_SUBDIVISIONS; s++ )
+			{
+				MakeSkyVec( ( s - HALF_SKY_SUBDIVISIONS ) / ( float ) HALF_SKY_SUBDIVISIONS, 
+							( t - HALF_SKY_SUBDIVISIONS ) / ( float ) HALF_SKY_SUBDIVISIONS, 
+							i, 
+							NULL,
+							s_skyPoints[t][s] );
+
+				s_skyTexCoords[t][s][0] = s_cloudTexCoords[i][t][s][0];
+				s_skyTexCoords[t][s][1] = s_cloudTexCoords[i][t][s][1];
+			}
+		}
+
+		// only add indexes for first stage
+		FillCloudySkySide( sky_mins_subd, sky_maxs_subd, ( stage == 0 ) );
+	}
+}
+
+/*
+** R_BuildCloudData
+*/
+void R_BuildCloudData( shaderCommands_t *input )
+{
+	int			i;
+	shader_t	*shader;
+
+	shader = input->shader;
+
+	assert( shader->sky );
+
+	sky_min = 1.0 / 256.0f;		// FIXME: not correct?
+	sky_max = 255.0 / 256.0f;
+
+	// set up for drawing
+	tess.numIndexes = 0;
+	tess.numVertexes = 0;
+
+	if ( input->shader->sky->cloudHeight )
+	{
+		for ( i = 0; i < input->shader->numUnfoggedPasses; i++ )
+		{
+			FillCloudBox( input->shader, i );
+		}
+	}
+}
+
+/*
+** R_InitSkyTexCoords
+** Called when a sky shader is parsed
+*/
+#define SQR( a ) ((a)*(a))
+
+void R_InitSkyTexCoords( float heightCloud )
+{
+	int i, s, t;
+	float radiusWorld = MAX_WORLD_COORD;
+	float p;
+	float sRad, tRad;
+	vec3_t skyVec;
+	vec3_t v;
+
+	// init zfar so MakeSkyVec works even though
+	// a world hasn't been bounded
+	backEnd.viewParms.zFar = 1024;
+
+	for ( i = 0; i < 6; i++ )
+	{
+		for ( t = 0; t <= SKY_SUBDIVISIONS; t++ )
+		{
+			for ( s = 0; s <= SKY_SUBDIVISIONS; s++ )
+			{
+				// compute vector from view origin to sky side integral point
+				MakeSkyVec( ( s - HALF_SKY_SUBDIVISIONS ) / ( float ) HALF_SKY_SUBDIVISIONS, 
+							( t - HALF_SKY_SUBDIVISIONS ) / ( float ) HALF_SKY_SUBDIVISIONS, 
+							i, 
+							NULL,
+							skyVec );
+
+				// compute parametric value 'p' that intersects with cloud layer
+				p = ( 1.0f / ( 2 * DotProduct( skyVec, skyVec ) ) ) *
+					( -2 * skyVec[2] * radiusWorld + 
+					   2 * sqrt( SQR( skyVec[2] ) * SQR( radiusWorld ) + 
+					             2 * SQR( skyVec[0] ) * radiusWorld * heightCloud +
+								 SQR( skyVec[0] ) * SQR( heightCloud ) + 
+								 2 * SQR( skyVec[1] ) * radiusWorld * heightCloud +
+								 SQR( skyVec[1] ) * SQR( heightCloud ) + 
+								 2 * SQR( skyVec[2] ) * radiusWorld * heightCloud +
+								 SQR( skyVec[2] ) * SQR( heightCloud ) ) );
+
+				s_cloudTexP[i][t][s] = p;
+
+				// compute intersection point based on p
+				VectorScale( skyVec, p, v );
+				v[2] += radiusWorld;
+
+				// compute vector from world origin to intersection point 'v'
+				VectorNormalize( v );
+
+				sRad = acos( v[0] );
+				tRad = acos( v[1] );
+
+				s_cloudTexCoords[i][t][s][0] = sRad;
+				s_cloudTexCoords[i][t][s][1] = tRad;
+			}
+		}
+	}
+}
+
+//======================================================================================
+
+/*
+** RB_DrawSun
+*/
+void RB_DrawSun( void ) {
+	float		size;
+	float		dist;
+	vec3_t		origin, vec1, vec2;
+	vec3_t		temp;
+
+	if ( !backEnd.skyRenderedThisView ) {
+		return;
+	}
+	if ( !r_drawSun->integer ) {
+		return;
+	}
+	qglLoadMatrixf( backEnd.viewParms.world.modelMatrix );
+	qglTranslatef (backEnd.viewParms.or.origin[0], backEnd.viewParms.or.origin[1], backEnd.viewParms.or.origin[2]);
+
+	dist = 	backEnd.viewParms.zFar / 1.75;		// div sqrt(3)
+	size = dist * 0.4;
+
+	VectorScale( tr.sunDirection, dist, origin );
+	PerpendicularVector( vec1, tr.sunDirection );
+	CrossProduct( tr.sunDirection, vec1, vec2 );
+
+	VectorScale( vec1, size, vec1 );
+	VectorScale( vec2, size, vec2 );
+
+	// farthest depth range
+	qglDepthRange( 1.0, 1.0 );
+
+	// FIXME: use quad stamp
+	RB_BeginSurface( tr.sunShader, tess.fogNum );
+		VectorCopy( origin, temp );
+		VectorSubtract( temp, vec1, temp );
+		VectorSubtract( temp, vec2, temp );
+		VectorCopy( temp, tess.xyz[tess.numVertexes] );
+		tess.texCoords[tess.numVertexes][0][0] = 0;
+		tess.texCoords[tess.numVertexes][0][1] = 0;
+		tess.vertexColors[tess.numVertexes][0] = 255;
+		tess.vertexColors[tess.numVertexes][1] = 255;
+		tess.vertexColors[tess.numVertexes][2] = 255;
+		tess.numVertexes++;
+
+		VectorCopy( origin, temp );
+		VectorAdd( temp, vec1, temp );
+		VectorSubtract( temp, vec2, temp );
+		VectorCopy( temp, tess.xyz[tess.numVertexes] );
+		tess.texCoords[tess.numVertexes][0][0] = 0;
+		tess.texCoords[tess.numVertexes][0][1] = 1;
+		tess.vertexColors[tess.numVertexes][0] = 255;
+		tess.vertexColors[tess.numVertexes][1] = 255;
+		tess.vertexColors[tess.numVertexes][2] = 255;
+		tess.numVertexes++;
+
+		VectorCopy( origin, temp );
+		VectorAdd( temp, vec1, temp );
+		VectorAdd( temp, vec2, temp );
+		VectorCopy( temp, tess.xyz[tess.numVertexes] );
+		tess.texCoords[tess.numVertexes][0][0] = 1;
+		tess.texCoords[tess.numVertexes][0][1] = 1;
+		tess.vertexColors[tess.numVertexes][0] = 255;
+		tess.vertexColors[tess.numVertexes][1] = 255;
+		tess.vertexColors[tess.numVertexes][2] = 255;
+		tess.numVertexes++;
+
+		VectorCopy( origin, temp );
+		VectorSubtract( temp, vec1, temp );
+		VectorAdd( temp, vec2, temp );
+		VectorCopy( temp, tess.xyz[tess.numVertexes] );
+		tess.texCoords[tess.numVertexes][0][0] = 1;
+		tess.texCoords[tess.numVertexes][0][1] = 0;
+		tess.vertexColors[tess.numVertexes][0] = 255;
+		tess.vertexColors[tess.numVertexes][1] = 255;
+		tess.vertexColors[tess.numVertexes][2] = 255;
+		tess.numVertexes++;
+
+		tess.indexes[tess.numIndexes++] = 0;
+		tess.indexes[tess.numIndexes++] = 1;
+		tess.indexes[tess.numIndexes++] = 2;
+		tess.indexes[tess.numIndexes++] = 0;
+		tess.indexes[tess.numIndexes++] = 2;
+		tess.indexes[tess.numIndexes++] = 3;
+
+	RB_EndSurface();
+
+	// back to normal depth range
+	qglDepthRange( 0.0, 1.0 );
+}
+
+
+
+
+/*
+================
+RB_StageIteratorSky
+
+All of the visible sky triangles are in tess
+
+Other things could be stuck in here, like birds in the sky, etc
+================
+*/
+void RB_StageIteratorSky( void ) {
+	if ( r_fastsky->integer ) {
+		return;
+	}
+
+	if (skyboxportal && !(backEnd.refdef.rdflags & RDF_SKYBOXPORTAL))
+	{
+		return;
+	}
+
+	// go through all the polygons and project them onto
+	// the sky box to see which blocks on each side need
+	// to be drawn
+	RB_ClipSkyPolygons( &tess );
+
+	// r_showsky will let all the sky blocks be drawn in
+	// front of everything to allow developers to see how
+	// much sky is getting sucked in
+	if ( r_showsky->integer ) {
+		qglDepthRange( 0.0, 0.0 );
+	} else {
+#ifdef _XBOX
+		qglDepthRange( 0.99, 1.0 );
+#else
+		qglDepthRange( 1.0, 1.0 );
+#endif
+	}
+
+	// draw the outer skybox
+	if ( tess.shader->sky->outerbox[0] && tess.shader->sky->outerbox[0] != tr.defaultImage ) {
+		qglColor3f( tr.identityLight, tr.identityLight, tr.identityLight );
+
+		qglPushMatrix ();
+		GL_State( 0 );
+		qglTranslatef (backEnd.viewParms.or.origin[0], backEnd.viewParms.or.origin[1], backEnd.viewParms.or.origin[2]);
+
+		DrawSkyBox( tess.shader );
+
+		qglPopMatrix();
+	}
+
+	// generate the vertexes for all the clouds, which will be drawn
+	// by the generic shader routine
+	R_BuildCloudData( &tess );
+
+	RB_StageIteratorGeneric();
+
+	// draw the inner skybox
+
+
+	// back to normal depth range
+	qglDepthRange( 0.0, 1.0 );
+
+	// note that sky was drawn so we will draw a sun later
+	backEnd.skyRenderedThisView = qtrue;
+}
+
diff --git a/code/renderer/tr_stl.cpp b/code/renderer/tr_stl.cpp
new file mode 100644
index 0000000..99566a5
--- /dev/null
+++ b/code/renderer/tr_stl.cpp
@@ -0,0 +1,76 @@
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+
+#pragma warning(disable : 4786)	// identifier was truncated 
+
+// Filename:-	tr_stl.cpp
+//
+// I mainly made this file because I was getting sick of all the stupid error messages in MS's STL implementation,
+//	and didn't want them showing up in the renderer files they were used in. This way keeps them more or less invisible
+//	because of minimal dependancies
+//
+#include "tr_local.h"	// this isn't actually needed other than getting rid of warnings via pragmas
+#include "tr_stl.h"
+
+#pragma warning( push,3 )
+
+#pragma warning(disable : 4514)	// unreferenced inline function has been removed (within STL, not this code)
+#pragma warning(disable : 4710)	// 
+#pragma warning(disable : 4503)	// decorated name length xceeded, name was truncated
+
+#include <map>
+#include "../qcommon/sstring.h"	// #include <string>
+using namespace std;
+
+typedef map<sstring_t, const char *>	ShaderEntryPtrs_t;
+										ShaderEntryPtrs_t ShaderEntryPtrs;
+
+
+
+
+
+
+void ShaderEntryPtrs_Clear(void)
+{
+	ShaderEntryPtrs.clear();
+}
+
+
+int ShaderEntryPtrs_Size(void)
+{
+	return ShaderEntryPtrs.size();
+}
+
+
+void ShaderEntryPtrs_Insert(const char  *token, const char  *p)
+{
+	ShaderEntryPtrs_t::iterator it = ShaderEntryPtrs.find(token);
+
+	if (it == ShaderEntryPtrs.end())
+	{
+		ShaderEntryPtrs[token] = p;
+	}
+}
+
+
+
+// returns NULL if not found...
+//
+const char *ShaderEntryPtrs_Lookup(const char *psShaderName)
+{
+	ShaderEntryPtrs_t::iterator it = ShaderEntryPtrs.find(psShaderName);
+	if (it != ShaderEntryPtrs.end())
+	{
+		const char *p = (*it).second;
+		return p;
+	}
+
+	return NULL;
+}
+
+
+
+#pragma warning ( pop )
+
diff --git a/code/renderer/tr_stl.h b/code/renderer/tr_stl.h
new file mode 100644
index 0000000..536e2a7
--- /dev/null
+++ b/code/renderer/tr_stl.h
@@ -0,0 +1,31 @@
+// Filename: tr_stl.h
+//
+//  I had to make this new file, because if I put the STL "map" include inside tr_local.h then one of the other header
+//	files got compile errors because of using "map" in the function protos as a GLEnum, this way seemed simpler...
+
+#ifndef TR_STL_H
+
+
+// REM this out if you want to compile without using STL (but slower of course)
+//
+#define USE_STL_FOR_SHADER_LOOKUPS
+
+
+
+
+#ifdef USE_STL_FOR_SHADER_LOOKUPS
+
+	void ShaderEntryPtrs_Clear(void);
+	int ShaderEntryPtrs_Size(void);
+	const char  *ShaderEntryPtrs_Lookup(const char *psShaderName);
+	void ShaderEntryPtrs_Insert(const char  *token, const char  *p);
+
+#else
+
+	#define ShaderEntryPtrs_Clear()	
+
+#endif	// #ifdef USE_STL_FOR_SHADER_LOOKUPS
+
+#endif	// #ifndef TR_STL_H
+
+
diff --git a/code/renderer/tr_surface.cpp b/code/renderer/tr_surface.cpp
new file mode 100644
index 0000000..5cce024
--- /dev/null
+++ b/code/renderer/tr_surface.cpp
@@ -0,0 +1,2383 @@
+// tr_surf.c
+
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+
+#include "tr_local.h"
+
+/*
+
+  THIS ENTIRE FILE IS BACK END
+
+backEnd.currentEntity will be valid.
+
+Tess_Begin has already been called for the surface's shader.
+
+The modelview matrix will be set.
+
+It is safe to actually issue drawing commands here if you don't want to
+use the shader system.
+*/
+
+
+//============================================================================
+
+
+/*
+==============
+RB_CheckOverflow
+==============
+*/
+void RB_CheckOverflow( int verts, int indexes ) {
+	if ( tess.shader == tr.shadowShader ) {
+		if (tess.numVertexes + verts < SHADER_MAX_VERTEXES/2
+			&& tess.numIndexes + indexes < SHADER_MAX_INDEXES) {
+			return;
+		}
+	} else 
+		if (tess.numVertexes + verts < SHADER_MAX_VERTEXES
+			&& tess.numIndexes + indexes < SHADER_MAX_INDEXES) {
+			return;
+		}
+
+	RB_EndSurface();
+
+	if ( verts >= SHADER_MAX_VERTEXES ) {
+		Com_Error(ERR_DROP, "RB_CheckOverflow: verts > MAX (%d > %d)", verts, SHADER_MAX_VERTEXES );
+	}
+	if ( indexes >= SHADER_MAX_INDEXES ) {
+		Com_Error(ERR_DROP, "RB_CheckOverflow: indices > MAX (%d > %d)", indexes, SHADER_MAX_INDEXES );
+	}
+
+	RB_BeginSurface(tess.shader, tess.fogNum );
+}
+
+
+/*
+==============
+RB_AddQuadStampExt
+==============
+*/
+void RB_AddQuadStampExt( vec3_t origin, vec3_t left, vec3_t up, byte *color, float s1, float t1, float s2, float t2 ) {
+	vec3_t		normal;
+	int			ndx;
+
+	RB_CHECKOVERFLOW( 4, 6 );
+
+	ndx = tess.numVertexes;
+
+	// triangle indexes for a simple quad
+	tess.indexes[ tess.numIndexes ] = ndx;
+	tess.indexes[ tess.numIndexes + 1 ] = ndx + 1;
+	tess.indexes[ tess.numIndexes + 2 ] = ndx + 3;
+
+	tess.indexes[ tess.numIndexes + 3 ] = ndx + 3;
+	tess.indexes[ tess.numIndexes + 4 ] = ndx + 1;
+	tess.indexes[ tess.numIndexes + 5 ] = ndx + 2;
+
+	tess.xyz[ndx][0] = origin[0] + left[0] + up[0];
+	tess.xyz[ndx][1] = origin[1] + left[1] + up[1];
+	tess.xyz[ndx][2] = origin[2] + left[2] + up[2];
+
+	tess.xyz[ndx+1][0] = origin[0] - left[0] + up[0];
+	tess.xyz[ndx+1][1] = origin[1] - left[1] + up[1];
+	tess.xyz[ndx+1][2] = origin[2] - left[2] + up[2];
+
+	tess.xyz[ndx+2][0] = origin[0] - left[0] - up[0];
+	tess.xyz[ndx+2][1] = origin[1] - left[1] - up[1];
+	tess.xyz[ndx+2][2] = origin[2] - left[2] - up[2];
+
+	tess.xyz[ndx+3][0] = origin[0] + left[0] - up[0];
+	tess.xyz[ndx+3][1] = origin[1] + left[1] - up[1];
+	tess.xyz[ndx+3][2] = origin[2] + left[2] - up[2];
+
+
+	// constant normal all the way around
+	VectorSubtract( vec3_origin, backEnd.viewParms.or.axis[0], normal );
+
+	tess.normal[ndx][0] = tess.normal[ndx+1][0] = tess.normal[ndx+2][0] = tess.normal[ndx+3][0] = normal[0];
+	tess.normal[ndx][1] = tess.normal[ndx+1][1] = tess.normal[ndx+2][1] = tess.normal[ndx+3][1] = normal[1];
+	tess.normal[ndx][2] = tess.normal[ndx+1][2] = tess.normal[ndx+2][2] = tess.normal[ndx+3][2] = normal[2];
+	
+	// standard square texture coordinates
+	tess.texCoords[ndx][0][0] = tess.texCoords[ndx][1][0] = s1;
+	tess.texCoords[ndx][0][1] = tess.texCoords[ndx][1][1] = t1;
+
+	tess.texCoords[ndx+1][0][0] = tess.texCoords[ndx+1][1][0] = s2;
+	tess.texCoords[ndx+1][0][1] = tess.texCoords[ndx+1][1][1] = t1;
+
+	tess.texCoords[ndx+2][0][0] = tess.texCoords[ndx+2][1][0] = s2;
+	tess.texCoords[ndx+2][0][1] = tess.texCoords[ndx+2][1][1] = t2;
+
+	tess.texCoords[ndx+3][0][0] = tess.texCoords[ndx+3][1][0] = s1;
+	tess.texCoords[ndx+3][0][1] = tess.texCoords[ndx+3][1][1] = t2;
+
+	// constant color all the way around
+	// should this be identity and let the shader specify from entity?
+	* ( unsigned int * ) &tess.vertexColors[ndx] = 
+	* ( unsigned int * ) &tess.vertexColors[ndx+1] = 
+	* ( unsigned int * ) &tess.vertexColors[ndx+2] = 
+	* ( unsigned int * ) &tess.vertexColors[ndx+3] = 
+		* ( unsigned int * )color;
+
+	tess.numVertexes += 4;
+	tess.numIndexes += 6;
+}
+
+/*
+==============
+RB_AddQuadStamp
+==============
+*/
+void RB_AddQuadStamp( vec3_t origin, vec3_t left, vec3_t up, byte *color ) {
+	RB_AddQuadStampExt( origin, left, up, color, 0, 0, 1, 1 );
+}
+
+/*
+==============
+RB_SurfaceSprite
+==============
+*/
+static void RB_SurfaceSprite( void ) {
+	vec3_t		left, up;
+	float		radius;
+
+	// calculate the xyz locations for the four corners
+	radius = backEnd.currentEntity->e.radius;
+	if ( backEnd.currentEntity->e.rotation == 0 ) {
+		VectorScale( backEnd.viewParms.or.axis[1], radius, left );
+		VectorScale( backEnd.viewParms.or.axis[2], radius, up );
+	} else {
+		float	s, c;
+		float	ang;
+		
+		ang = M_PI * backEnd.currentEntity->e.rotation / 180;
+		s = sin( ang );
+		c = cos( ang );
+
+		VectorScale( backEnd.viewParms.or.axis[1], c * radius, left );
+		VectorMA( left, -s * radius, backEnd.viewParms.or.axis[2], left );
+
+		VectorScale( backEnd.viewParms.or.axis[2], c * radius, up );
+		VectorMA( up, s * radius, backEnd.viewParms.or.axis[1], up );
+	}
+	if ( backEnd.viewParms.isMirror ) {
+		VectorSubtract( vec3_origin, left, left );
+	}
+
+	RB_AddQuadStamp( backEnd.currentEntity->e.origin, left, up, backEnd.currentEntity->e.shaderRGBA );
+}
+
+/*
+=======================
+RB_SurfaceOrientedQuad
+=======================
+*/
+static void RB_SurfaceOrientedQuad( void )
+{
+	vec3_t	left, up;
+	float	radius;
+
+	// calculate the xyz locations for the four corners
+	radius = backEnd.currentEntity->e.radius;
+	MakeNormalVectors( backEnd.currentEntity->e.axis[0], left, up );
+
+	if ( backEnd.currentEntity->e.rotation == 0 ) 
+	{
+		VectorScale( left, radius, left );
+		VectorScale( up, radius, up );
+	} 
+	else 
+	{
+		vec3_t	tempLeft, tempUp;
+		float	s, c;
+		float	ang;
+		
+		ang = M_PI * backEnd.currentEntity->e.rotation / 180;
+		s = sin( ang );
+		c = cos( ang );
+
+		// Use a temp so we don't trash the values we'll need later
+		VectorScale( left, c * radius, tempLeft );
+		VectorMA( tempLeft, -s * radius, up, tempLeft );
+
+		VectorScale( up, c * radius, tempUp );
+		VectorMA( tempUp, s * radius, left, up ); // no need to use the temp anymore, so copy into the dest vector ( up )
+
+		// This was copied for safekeeping, we're done, so we can move it back to left
+		VectorCopy( tempLeft, left );
+	}
+
+	if ( backEnd.viewParms.isMirror ) 
+	{
+		VectorSubtract( vec3_origin, left, left );
+	}
+
+	RB_AddQuadStamp( backEnd.currentEntity->e.origin, left, up, backEnd.currentEntity->e.shaderRGBA );
+}
+
+/*
+==============
+RB_SurfaceLine
+==============
+*/
+//
+//	Values for a proper line render primitive...
+//		Width
+//		STScale (how many times to loop a texture)
+//		alpha
+//		RGB
+//		
+//  Values for proper line object...
+//		lifetime
+//		dscale
+//		startalpha, endalpha
+//		startRGB, endRGB
+//		
+
+static void DoLine( const vec3_t start, const vec3_t end, const vec3_t up, float spanWidth )
+{
+	float		spanWidth2;
+	int			vbase;
+
+	RB_CHECKOVERFLOW( 4, 6 );
+
+	vbase = tess.numVertexes;
+
+	spanWidth2 = -spanWidth;
+
+	VectorMA( start, spanWidth, up, tess.xyz[tess.numVertexes] );
+	tess.texCoords[tess.numVertexes][0][0] = 0;
+	tess.texCoords[tess.numVertexes][0][1] = 0;
+	tess.vertexColors[tess.numVertexes][0] = backEnd.currentEntity->e.shaderRGBA[0];// * 0.25;//wtf??not sure why the code would be doing this
+	tess.vertexColors[tess.numVertexes][1] = backEnd.currentEntity->e.shaderRGBA[1];// * 0.25;
+	tess.vertexColors[tess.numVertexes][2] = backEnd.currentEntity->e.shaderRGBA[2];// * 0.25;
+	tess.vertexColors[tess.numVertexes][3] = backEnd.currentEntity->e.shaderRGBA[3];// * 0.25;
+	tess.numVertexes++;
+
+	VectorMA( start, spanWidth2, up, tess.xyz[tess.numVertexes] );
+	tess.texCoords[tess.numVertexes][0][0] = 1;//backEnd.currentEntity->e.shaderTexCoord[0];
+	tess.texCoords[tess.numVertexes][0][1] = 0;
+	tess.vertexColors[tess.numVertexes][0] = backEnd.currentEntity->e.shaderRGBA[0];
+	tess.vertexColors[tess.numVertexes][1] = backEnd.currentEntity->e.shaderRGBA[1];
+	tess.vertexColors[tess.numVertexes][2] = backEnd.currentEntity->e.shaderRGBA[2];
+	tess.vertexColors[tess.numVertexes][3] = backEnd.currentEntity->e.shaderRGBA[3];
+	tess.numVertexes++;
+
+	VectorMA( end, spanWidth, up, tess.xyz[tess.numVertexes] );
+
+	tess.texCoords[tess.numVertexes][0][0] = 0;
+	tess.texCoords[tess.numVertexes][0][1] = 1;//backEnd.currentEntity->e.shaderTexCoord[1];
+	tess.vertexColors[tess.numVertexes][0] = backEnd.currentEntity->e.shaderRGBA[0];
+	tess.vertexColors[tess.numVertexes][1] = backEnd.currentEntity->e.shaderRGBA[1];
+	tess.vertexColors[tess.numVertexes][2] = backEnd.currentEntity->e.shaderRGBA[2];
+	tess.vertexColors[tess.numVertexes][3] = backEnd.currentEntity->e.shaderRGBA[3];
+	tess.numVertexes++;
+
+	VectorMA( end, spanWidth2, up, tess.xyz[tess.numVertexes] );
+	tess.texCoords[tess.numVertexes][0][0] = 1;//backEnd.currentEntity->e.shaderTexCoord[0];
+	tess.texCoords[tess.numVertexes][0][1] = 1;//backEnd.currentEntity->e.shaderTexCoord[1];
+	tess.vertexColors[tess.numVertexes][0] = backEnd.currentEntity->e.shaderRGBA[0];
+	tess.vertexColors[tess.numVertexes][1] = backEnd.currentEntity->e.shaderRGBA[1];
+	tess.vertexColors[tess.numVertexes][2] = backEnd.currentEntity->e.shaderRGBA[2];
+	tess.vertexColors[tess.numVertexes][3] = backEnd.currentEntity->e.shaderRGBA[3];
+	tess.numVertexes++;
+
+	tess.indexes[tess.numIndexes++] = vbase;
+	tess.indexes[tess.numIndexes++] = vbase + 1;
+	tess.indexes[tess.numIndexes++] = vbase + 2;
+
+	tess.indexes[tess.numIndexes++] = vbase + 2;
+	tess.indexes[tess.numIndexes++] = vbase + 1;
+	tess.indexes[tess.numIndexes++] = vbase + 3;
+}
+
+static void DoLine2( const vec3_t start, const vec3_t end, const vec3_t up, float spanWidth, float spanWidth2, const float tcStart, const float tcEnd )
+{
+	int			vbase;
+
+	RB_CHECKOVERFLOW( 4, 6 );
+
+	vbase = tess.numVertexes;
+
+	VectorMA( start, spanWidth, up, tess.xyz[tess.numVertexes] );
+	tess.texCoords[tess.numVertexes][0][0] = 0;
+	tess.texCoords[tess.numVertexes][0][1] = tcStart;
+	tess.vertexColors[tess.numVertexes][0] = backEnd.currentEntity->e.shaderRGBA[0];// * 0.25;//wtf??not sure why the code would be doing this
+	tess.vertexColors[tess.numVertexes][1] = backEnd.currentEntity->e.shaderRGBA[1];// * 0.25;
+	tess.vertexColors[tess.numVertexes][2] = backEnd.currentEntity->e.shaderRGBA[2];// * 0.25;
+	tess.vertexColors[tess.numVertexes][3] = backEnd.currentEntity->e.shaderRGBA[3];// * 0.25;
+	tess.numVertexes++;
+
+	VectorMA( start, -spanWidth, up, tess.xyz[tess.numVertexes] );
+	tess.texCoords[tess.numVertexes][0][0] = 1;//backEnd.currentEntity->e.shaderTexCoord[0];
+	tess.texCoords[tess.numVertexes][0][1] = tcStart;
+	tess.vertexColors[tess.numVertexes][0] = backEnd.currentEntity->e.shaderRGBA[0];
+	tess.vertexColors[tess.numVertexes][1] = backEnd.currentEntity->e.shaderRGBA[1];
+	tess.vertexColors[tess.numVertexes][2] = backEnd.currentEntity->e.shaderRGBA[2];
+	tess.vertexColors[tess.numVertexes][3] = backEnd.currentEntity->e.shaderRGBA[3];
+	tess.numVertexes++;
+
+	VectorMA( end, spanWidth2, up, tess.xyz[tess.numVertexes] );
+
+	tess.texCoords[tess.numVertexes][0][0] = 0;
+	tess.texCoords[tess.numVertexes][0][1] = tcEnd;//backEnd.currentEntity->e.shaderTexCoord[1];
+	tess.vertexColors[tess.numVertexes][0] = backEnd.currentEntity->e.shaderRGBA[0];
+	tess.vertexColors[tess.numVertexes][1] = backEnd.currentEntity->e.shaderRGBA[1];
+	tess.vertexColors[tess.numVertexes][2] = backEnd.currentEntity->e.shaderRGBA[2];
+	tess.vertexColors[tess.numVertexes][3] = backEnd.currentEntity->e.shaderRGBA[3];
+	tess.numVertexes++;
+
+	VectorMA( end, -spanWidth2, up, tess.xyz[tess.numVertexes] );
+	tess.texCoords[tess.numVertexes][0][0] = 1;//backEnd.currentEntity->e.shaderTexCoord[0];
+	tess.texCoords[tess.numVertexes][0][1] = tcEnd;//backEnd.currentEntity->e.shaderTexCoord[1];
+	tess.vertexColors[tess.numVertexes][0] = backEnd.currentEntity->e.shaderRGBA[0];
+	tess.vertexColors[tess.numVertexes][1] = backEnd.currentEntity->e.shaderRGBA[1];
+	tess.vertexColors[tess.numVertexes][2] = backEnd.currentEntity->e.shaderRGBA[2];
+	tess.vertexColors[tess.numVertexes][3] = backEnd.currentEntity->e.shaderRGBA[3];
+	tess.numVertexes++;
+
+	tess.indexes[tess.numIndexes++] = vbase;
+	tess.indexes[tess.numIndexes++] = vbase + 1;
+	tess.indexes[tess.numIndexes++] = vbase + 2;
+
+	tess.indexes[tess.numIndexes++] = vbase + 2;
+	tess.indexes[tess.numIndexes++] = vbase + 1;
+	tess.indexes[tess.numIndexes++] = vbase + 3;
+}
+
+//-----------------
+// RB_SurfaceLine
+//-----------------
+static void RB_SurfaceLine( void ) 
+{
+	refEntity_t *e;
+	vec3_t		right;
+	vec3_t		start, end;
+	vec3_t		v1, v2;
+
+	e = &backEnd.currentEntity->e;
+
+	VectorCopy( e->oldorigin, end );
+	VectorCopy( e->origin, start );
+
+	// compute side vector
+	VectorSubtract( start, backEnd.viewParms.or.origin, v1 );
+	VectorSubtract( end, backEnd.viewParms.or.origin, v2 );
+	CrossProduct( v1, v2, right );
+	VectorNormalize( right );
+
+	DoLine( start, end, right, e->radius);
+}
+
+/*
+==============
+RB_SurfaceCylinder
+==============
+*/
+
+#define NUM_CYLINDER_SEGMENTS 40
+
+// e->origin holds the bottom point
+// e->oldorigin holds the top point
+// e->radius holds the radius
+
+// If a cylinder has a tapered end that has a very small radius, the engine converts it to a cone.  Not a huge savings, but the texture mapping is slightly better
+//	and it uses half as many indicies as the cylinder version
+//-------------------------------------
+static void RB_SurfaceCone( void )
+//-------------------------------------
+{
+	static vec3_t points[NUM_CYLINDER_SEGMENTS];
+	vec3_t		vr, vu, midpoint;
+	vec3_t		tapered, base;
+	float		detail, length;
+	int			i;
+	int			segments;
+	refEntity_t *e;
+
+	e = &backEnd.currentEntity->e;
+
+	//Work out the detail level of this cylinder
+	VectorAdd( e->origin, e->oldorigin, midpoint );
+	VectorScale(midpoint, 0.5, midpoint);		// Average start and end
+
+	VectorSubtract( midpoint, backEnd.viewParms.or.origin, midpoint );
+	length = VectorNormalize( midpoint );
+
+	// this doesn't need to be perfect....just a rough compensation for zoom level is enough
+	length *= (backEnd.viewParms.fovX / 90.0f);
+
+	detail = 1 - ((float) length / 2048 );
+	segments = NUM_CYLINDER_SEGMENTS * detail;
+
+	// 3 is the absolute minimum, but the pop between 3-8 is too noticeable
+	if ( segments < 8 )
+	{
+		segments = 8;
+	}
+
+	if ( segments > NUM_CYLINDER_SEGMENTS )
+	{
+		segments = NUM_CYLINDER_SEGMENTS;
+	}
+	
+	// Get the direction vector
+	MakeNormalVectors( e->axis[0], vr, vu );
+
+	// we only need to rotate around the larger radius, the smaller radius get's welded
+	if ( e->radius < e->backlerp )
+	{
+		VectorScale( vu, e->backlerp, vu );
+		VectorCopy( e->origin, base );
+		VectorCopy( e->oldorigin, tapered );
+	}
+	else
+	{
+		VectorScale( vu, e->radius, vu );
+		VectorCopy( e->origin, tapered );
+		VectorCopy( e->oldorigin, base );
+	}
+
+
+	// Calculate the step around the cylinder
+	detail = 360.0f / (float)segments;
+
+	for ( i = 0; i < segments; i++ )
+	{
+		// ring
+		RotatePointAroundVector( points[i], e->axis[0], vu, detail * i );
+		VectorAdd( points[i], base, points[i] );
+	}
+	
+	// Calculate the texture coords so the texture can wrap around the whole cylinder
+	detail = 1.0f / (float)segments;
+
+	RB_CHECKOVERFLOW( 2 * (segments+1), 3 * segments ); // this isn't 100% accurate
+
+	int vbase = tess.numVertexes;
+
+	for ( i = 0; i < segments; i++ )
+	{
+ 		VectorCopy( points[i], tess.xyz[tess.numVertexes] );
+		tess.texCoords[tess.numVertexes][0][0] = detail * i;
+		tess.texCoords[tess.numVertexes][0][1] = 1.0f;
+		tess.vertexColors[tess.numVertexes][0] = e->shaderRGBA[0];
+		tess.vertexColors[tess.numVertexes][1] = e->shaderRGBA[1];
+		tess.vertexColors[tess.numVertexes][2] = e->shaderRGBA[2];
+		tess.vertexColors[tess.numVertexes][3] = e->shaderRGBA[3];
+		tess.numVertexes++;
+
+		// We could add this vert once, but using the given texture mapping method, we need to generate different texture coordinates
+		VectorCopy( tapered, tess.xyz[tess.numVertexes] );
+		tess.texCoords[tess.numVertexes][0][0] = detail * i + detail * 0.5f; // set the texture coordinates to the point half-way between the untapered ends....but on the other end of the texture
+		tess.texCoords[tess.numVertexes][0][1] = 0.0f;
+		tess.vertexColors[tess.numVertexes][0] = e->shaderRGBA[0];
+		tess.vertexColors[tess.numVertexes][1] = e->shaderRGBA[1];
+		tess.vertexColors[tess.numVertexes][2] = e->shaderRGBA[2];
+		tess.vertexColors[tess.numVertexes][3] = e->shaderRGBA[3];
+		tess.numVertexes++;
+	}
+
+	// last point has the same verts as the first, but does not share the same tex coords, so we have to duplicate it
+ 	VectorCopy( points[0], tess.xyz[tess.numVertexes] );
+	tess.texCoords[tess.numVertexes][0][0] = detail * i;
+	tess.texCoords[tess.numVertexes][0][1] = 1.0f;
+	tess.vertexColors[tess.numVertexes][0] = e->shaderRGBA[0];
+	tess.vertexColors[tess.numVertexes][1] = e->shaderRGBA[1];
+	tess.vertexColors[tess.numVertexes][2] = e->shaderRGBA[2];
+	tess.vertexColors[tess.numVertexes][3] = e->shaderRGBA[3];
+	tess.numVertexes++;
+
+ 	VectorCopy( tapered, tess.xyz[tess.numVertexes] );
+	tess.texCoords[tess.numVertexes][0][0] = detail * i + detail * 0.5f;
+	tess.texCoords[tess.numVertexes][0][1] = 0.0f;
+	tess.vertexColors[tess.numVertexes][0] = e->shaderRGBA[0];
+	tess.vertexColors[tess.numVertexes][1] = e->shaderRGBA[1];
+	tess.vertexColors[tess.numVertexes][2] = e->shaderRGBA[2];
+	tess.vertexColors[tess.numVertexes][3] = e->shaderRGBA[3];
+	tess.numVertexes++;
+
+	// do the welding
+	for ( i = 0; i < segments; i++ )
+	{
+		tess.indexes[tess.numIndexes++] = vbase;
+		tess.indexes[tess.numIndexes++] = vbase + 1;
+		tess.indexes[tess.numIndexes++] = vbase + 2;
+
+		vbase += 2;
+	}
+}
+
+//-------------------------------------
+static void RB_SurfaceCylinder( void )
+//-------------------------------------
+{
+	static vec3_t lower_points[NUM_CYLINDER_SEGMENTS], upper_points[NUM_CYLINDER_SEGMENTS];
+	vec3_t		vr, vu, midpoint, v1;
+	float		detail, length;
+	int			i;
+	int			segments;
+	refEntity_t *e;
+
+	e = &backEnd.currentEntity->e;
+
+	// check for tapering
+	if ( !( e->radius < 0.3f && e->backlerp < 0.3f) && ( e->radius < 0.3f || e->backlerp < 0.3f ))
+	{
+		// One end is sufficiently tapered to consider changing it to a cone
+		RB_SurfaceCone();
+		return;
+	}
+
+	//Work out the detail level of this cylinder
+	VectorAdd( e->origin, e->oldorigin, midpoint );
+	VectorScale(midpoint, 0.5, midpoint);		// Average start and end
+
+	VectorSubtract( midpoint, backEnd.viewParms.or.origin, midpoint );
+	length = VectorNormalize( midpoint );
+
+	// this doesn't need to be perfect....just a rough compensation for zoom level is enough
+	length *= (backEnd.viewParms.fovX / 90.0f);
+
+	detail = 1 - ((float) length / 2048 );
+	segments = NUM_CYLINDER_SEGMENTS * detail;
+
+	// 3 is the absolute minimum, but the pop between 3-8 is too noticeable
+	if ( segments < 8 )
+	{
+		segments = 8;
+	}
+
+	if ( segments > NUM_CYLINDER_SEGMENTS )
+	{
+		segments = NUM_CYLINDER_SEGMENTS;
+	}
+	
+	//Get the direction vector
+	MakeNormalVectors( e->axis[0], vr, vu );
+
+	VectorScale( vu, e->radius, v1 );	// size1
+	VectorScale( vu, e->backlerp, vu );	// size2
+
+	// Calculate the step around the cylinder
+	detail = 360.0f / (float)segments;
+
+	for ( i = 0; i < segments; i++ )
+	{
+		//Upper ring
+		RotatePointAroundVector( upper_points[i], e->axis[0], vu, detail * i );
+		VectorAdd( upper_points[i], e->origin, upper_points[i] );
+		
+		//Lower ring
+		RotatePointAroundVector( lower_points[i], e->axis[0], v1, detail * i );
+		VectorAdd( lower_points[i], e->oldorigin, lower_points[i] );
+	}
+	
+	// Calculate the texture coords so the texture can wrap around the whole cylinder
+	detail = 1.0f / (float)segments;
+
+	RB_CHECKOVERFLOW( 2 * (segments+1), 6 * segments ); // this isn't 100% accurate
+
+	int vbase = tess.numVertexes;
+
+	for ( i = 0; i < segments; i++ )
+	{
+ 		VectorCopy( upper_points[i], tess.xyz[tess.numVertexes] );
+		tess.texCoords[tess.numVertexes][0][0] = detail * i;
+		tess.texCoords[tess.numVertexes][0][1] = 1.0f;
+		tess.vertexColors[tess.numVertexes][0] = e->shaderRGBA[0];
+		tess.vertexColors[tess.numVertexes][1] = e->shaderRGBA[1];
+		tess.vertexColors[tess.numVertexes][2] = e->shaderRGBA[2];
+		tess.vertexColors[tess.numVertexes][3] = e->shaderRGBA[3];
+		tess.numVertexes++;
+
+		VectorCopy( lower_points[i], tess.xyz[tess.numVertexes] );
+		tess.texCoords[tess.numVertexes][0][0] = detail * i;
+		tess.texCoords[tess.numVertexes][0][1] = 0.0f;
+		tess.vertexColors[tess.numVertexes][0] = e->shaderRGBA[0];
+		tess.vertexColors[tess.numVertexes][1] = e->shaderRGBA[1];
+		tess.vertexColors[tess.numVertexes][2] = e->shaderRGBA[2];
+		tess.vertexColors[tess.numVertexes][3] = e->shaderRGBA[3];
+		tess.numVertexes++;
+	}
+
+	// last point has the same verts as the first, but does not share the same tex coords, so we have to duplicate it
+ 	VectorCopy( upper_points[0], tess.xyz[tess.numVertexes] );
+	tess.texCoords[tess.numVertexes][0][0] = detail * i;
+	tess.texCoords[tess.numVertexes][0][1] = 1.0f;
+	tess.vertexColors[tess.numVertexes][0] = e->shaderRGBA[0];
+	tess.vertexColors[tess.numVertexes][1] = e->shaderRGBA[1];
+	tess.vertexColors[tess.numVertexes][2] = e->shaderRGBA[2];
+	tess.vertexColors[tess.numVertexes][3] = e->shaderRGBA[3];
+	tess.numVertexes++;
+
+ 	VectorCopy( lower_points[0], tess.xyz[tess.numVertexes] );
+	tess.texCoords[tess.numVertexes][0][0] = detail * i;
+	tess.texCoords[tess.numVertexes][0][1] = 0.0f;
+	tess.vertexColors[tess.numVertexes][0] = e->shaderRGBA[0];
+	tess.vertexColors[tess.numVertexes][1] = e->shaderRGBA[1];
+	tess.vertexColors[tess.numVertexes][2] = e->shaderRGBA[2];
+	tess.vertexColors[tess.numVertexes][3] = e->shaderRGBA[3];
+	tess.numVertexes++;
+
+	// glue the verts
+	for ( i = 0; i < segments; i++ )
+	{
+		tess.indexes[tess.numIndexes++] = vbase;
+		tess.indexes[tess.numIndexes++] = vbase + 1;
+		tess.indexes[tess.numIndexes++] = vbase + 2;
+
+		tess.indexes[tess.numIndexes++] = vbase + 2;
+		tess.indexes[tess.numIndexes++] = vbase + 1;
+		tess.indexes[tess.numIndexes++] = vbase + 3; 
+
+		vbase += 2;
+	}
+}
+
+static vec3_t sh1, sh2;
+static f_count;
+
+// Up front, we create a random "shape", then apply that to each line segment...and then again to each of those segments...kind of like a fractal
+//----------------------------------------------------------------------------
+static void CreateShape()
+//----------------------------------------------------------------------------
+{
+	VectorSet( sh1, 0.66f,// + crandom() * 0.1f,	// fwd
+				0.08f + crandom() * 0.02f,
+				0.08f + crandom() * 0.02f );
+
+	// it seems to look best to have a point on one side of the ideal line, then the other point on the other side.
+	VectorSet( sh2, 0.33f,// + crandom() * 0.1f,	// fwd
+					-sh1[1] + crandom() * 0.02f,	// forcing point to be on the opposite side of the line -- right
+					-sh1[2] + crandom() * 0.02f );// up
+}
+
+//----------------------------------------------------------------------------
+static void ApplyShape( vec3_t start, vec3_t end, vec3_t right, float sradius, float eradius, int count, float startPerc, float endPerc )
+//----------------------------------------------------------------------------
+{
+	vec3_t	point1, point2, fwd;
+	vec3_t	rt, up;
+	float	perc, dis;
+
+    if ( count < 1 )
+	{
+		// done recursing
+		DoLine2( start, end, right, sradius, eradius, startPerc, endPerc );
+		return;
+	}
+
+    CreateShape();
+
+	VectorSubtract( end, start, fwd );
+	dis = VectorNormalize( fwd ) * 0.7f;
+	MakeNormalVectors( fwd, rt, up );
+
+	perc = sh1[0];
+
+	VectorScale( start, perc, point1 );
+	VectorMA( point1, 1.0f - perc, end, point1 );
+	VectorMA( point1, dis * sh1[1], rt, point1 );
+	VectorMA( point1, dis * sh1[2], up, point1 );
+
+	// do a quick and dirty interpolation of the radius at that point
+	float rads1, rads2;
+
+	rads1 = sradius * 0.666f + eradius * 0.333f;
+	rads2 = sradius * 0.333f + eradius * 0.666f;
+
+	// recursion
+    ApplyShape( start, point1, right, sradius, rads1, count - 1, startPerc, startPerc * 0.666f + endPerc * 0.333f );
+
+	perc = sh2[0];
+
+	VectorScale( start, perc, point2 );
+	VectorMA( point2, 1.0f - perc, end, point2 );
+	VectorMA( point2, dis * sh2[1], rt, point2 );
+	VectorMA( point2, dis * sh2[2], up, point2 );
+    
+	// recursion
+    ApplyShape( point2, point1, right, rads1, rads2, count - 1, startPerc * 0.333f + endPerc * 0.666f, startPerc * 0.666f + endPerc * 0.333f );
+	ApplyShape( point2, end, right, rads2, eradius, count - 1, startPerc * 0.333f + endPerc * 0.666f, endPerc );
+}
+
+//----------------------------------------------------------------------------
+static void DoBoltSeg( vec3_t start, vec3_t end, vec3_t right, float radius )
+//----------------------------------------------------------------------------
+{
+	refEntity_t *e;
+	vec3_t fwd, old;
+	vec3_t cur, off={10,10,10};
+	vec3_t rt, up;
+	vec3_t temp;
+	int		i;
+    float dis, oldPerc = 0.0f, perc, oldRadius, newRadius;
+
+	e = &backEnd.currentEntity->e;
+
+	VectorSubtract( end, start, fwd );
+	dis = VectorNormalize( fwd );
+
+	if (dis > 2000)	//freaky long
+	{
+//		VID_Printf( PRINT_WARNING, "DoBoltSeg: insane distance.\n" );
+		dis = 2000;
+	}
+	MakeNormalVectors( fwd, rt, up );
+
+	VectorCopy( start, old );
+    
+	newRadius = oldRadius = radius;
+
+    for ( i = 16; i <= dis; i+= 16 )
+	{
+		// because of our large step size, we may not actually draw to the end.  In this case, fudge our percent so that we are basically complete
+		if ( i + 16 > dis )
+		{
+			perc = 1.0f;
+		}
+		else
+		{
+			// percentage of the amount of line completed
+			perc = (float)i / dis;
+		}
+
+		// create our level of deviation for this point
+		VectorScale( fwd, Q_crandom(&e->frame) * 3.0f, temp );				// move less in fwd direction, chaos also does not affect this
+		VectorMA( temp, Q_crandom(&e->frame) * 7.0f * e->angles[0], rt, temp );	// move more in direction perpendicular to line, angles is really the chaos
+		VectorMA( temp, Q_crandom(&e->frame) * 7.0f * e->angles[0], up, temp );	// move more in direction perpendicular to line
+
+		// track our total level of offset from the ideal line
+		VectorAdd( off, temp, off );
+
+        // Move from start to end, always adding our current level of offset from the ideal line
+		//	Even though we are adding a random offset.....by nature, we always move from exactly start....to end
+		VectorAdd( start, off, cur );
+		VectorScale( cur, 1.0f - perc, cur );
+		VectorMA( cur, perc, end, cur );
+
+		if ( e->renderfx & RF_TAPERED )
+		{
+			// This does pretty close to perfect tapering since apply shape interpolates the old and new as it goes along.
+			//	by using one minus the square, the radius stays fairly constant, then drops off quickly at the very point of the bolt
+			oldRadius = radius * (1.0f-oldPerc*oldPerc);
+			newRadius = radius * (1.0f-perc*perc);
+		}
+
+		// Apply the random shape to our line seg to give it some micro-detail-jaggy-coolness.
+		ApplyShape( cur, old, right, newRadius, oldRadius, 2 - r_lodbias->integer, 0, 1 );
+  
+		// randomly split off to create little tendrils, but don't do it too close to the end and especially if we are not even of the forked variety
+        if (( e->renderfx & RF_FORKED ) && f_count > 0 && Q_random(&e->frame) > 0.93f && (1.0f - perc) > 0.8f )
+		{
+			vec3_t newDest;
+
+			f_count--;
+
+			// Pick a point somewhere between the current point and the final endpoint
+			VectorAdd( cur, e->oldorigin, newDest );
+			VectorScale( newDest, 0.5f, newDest );
+
+			// And then add some crazy offset
+			for ( int t = 0; t < 3; t++ )
+			{
+				newDest[t] += Q_crandom(&e->frame) * 80;
+			}
+			 
+			// we could branch off using OLD and NEWDEST, but that would allow multiple forks...whereas, we just want simpler brancing
+            DoBoltSeg( cur, newDest, right, newRadius );
+		}
+
+		// Current point along the line becomes our new old attach point
+		VectorCopy( cur, old );
+		oldPerc = perc;
+	}
+}
+
+//------------------------------------------
+static void RB_SurfaceElectricity()
+//------------------------------------------
+{
+	refEntity_t *e;
+	vec3_t		right, fwd;
+	vec3_t		start, end;
+	vec3_t		v1, v2;
+	float		radius, perc = 1.0f, dis;
+
+	e = &backEnd.currentEntity->e;
+	radius = e->radius;
+
+	VectorCopy( e->origin, start );
+
+	VectorSubtract( e->oldorigin, start, fwd );
+	dis = VectorNormalize( fwd );
+
+	// see if we should grow from start to end
+	if ( e->renderfx & RF_GROW )
+	{
+		perc = 1.0f - ( e->endTime - tr.refdef.time ) / e->angles[1]/*duration*/;
+
+		if ( perc > 1.0f )
+		{
+			perc = 1.0f;
+		}
+		else if ( perc < 0.0f )
+		{
+			perc = 0.0f;
+		}
+	}
+
+	VectorMA( start, perc * dis, fwd, e->oldorigin );
+	VectorCopy( e->oldorigin, end );
+
+	// compute side vector
+	VectorSubtract( start, backEnd.viewParms.or.origin, v1 );
+	VectorSubtract( end, backEnd.viewParms.or.origin, v2 );
+	CrossProduct( v1, v2, right );
+	VectorNormalize( right );
+
+	// allow now more than three branches on branch type electricity
+	f_count = 3;
+    DoBoltSeg( start, end, right, radius );
+}
+   
+/*
+=============
+RB_SurfacePolychain
+=============
+*/
+/* // we could try to do something similar to this to get better normals into the tess for these types of surfs.  As it stands, any shader pass that
+//	requires a normal ( env map ) will not work properly since the normals seem to essentially be random garbage.
+void RB_SurfacePolychain( srfPoly_t *p ) {
+	int		i;
+	int		numv;
+	vec3_t	a,b,normal={1,0,0};
+
+	RB_CHECKOVERFLOW( p->numVerts, 3*(p->numVerts - 2) );
+
+	if ( p->numVerts >= 3 )
+	{
+		VectorSubtract( p->verts[0].xyz, p->verts[1].xyz, a );
+		VectorSubtract( p->verts[2].xyz, p->verts[1].xyz, b );
+		CrossProduct( a,b, normal );
+		VectorNormalize( normal );
+	}
+
+	// fan triangles into the tess array
+	numv = tess.numVertexes;
+	for ( i = 0; i < p->numVerts; i++ ) {
+		VectorCopy( p->verts[i].xyz, tess.xyz[numv] );
+		tess.texCoords[numv][0][0] = p->verts[i].st[0];
+		tess.texCoords[numv][0][1] = p->verts[i].st[1];
+		VectorCopy( normal, tess.normal[numv] );
+		*(int *)&tess.vertexColors[numv] = *(int *)p->verts[ i ].modulate;
+
+		numv++;
+	}
+
+	// generate fan indexes into the tess array
+	for ( i = 0; i < p->numVerts-2; i++ ) {
+		tess.indexes[tess.numIndexes + 0] = tess.numVertexes;
+		tess.indexes[tess.numIndexes + 1] = tess.numVertexes + i + 1;
+		tess.indexes[tess.numIndexes + 2] = tess.numVertexes + i + 2;
+		tess.numIndexes += 3;
+	}
+
+	tess.numVertexes = numv;
+}
+*/
+void RB_SurfacePolychain( srfPoly_t *p ) {
+	int		i;
+	int		numv;
+
+	RB_CHECKOVERFLOW( p->numVerts, 3*(p->numVerts - 2) );
+
+	// fan triangles into the tess array
+	numv = tess.numVertexes;
+	for ( i = 0; i < p->numVerts; i++ ) {
+		VectorCopy( p->verts[i].xyz, tess.xyz[numv] );
+		tess.texCoords[numv][0][0] = p->verts[i].st[0];
+		tess.texCoords[numv][0][1] = p->verts[i].st[1];
+		*(int *)&tess.vertexColors[numv] = *(int *)p->verts[ i ].modulate;
+
+		numv++;
+	}
+
+	// generate fan indexes into the tess array
+	for ( i = 0; i < p->numVerts-2; i++ ) {
+		tess.indexes[tess.numIndexes + 0] = tess.numVertexes;
+		tess.indexes[tess.numIndexes + 1] = tess.numVertexes + i + 1;
+		tess.indexes[tess.numIndexes + 2] = tess.numVertexes + i + 2;
+		tess.numIndexes += 3;
+	}
+
+	tess.numVertexes = numv;
+}
+
+inline static ulong ComputeFinalVertexColor(const byte *colors)
+{
+	int			k;
+	byte		result[4];
+	ulong		r, g, b;
+
+	*(int *)result = *(int *)colors;
+	if (tess.shader->lightmapIndex[0] != LIGHTMAP_BY_VERTEX )
+	{
+		return *(ulong *)result;
+	}
+	if (r_fullbright->integer)
+	{
+		result[0] = 255;
+		result[1] = 255;
+		result[2] = 255;
+		return *(ulong *)result;
+	}
+	// an optimization could be added here to compute the style[0] (which is always the world normal light)
+	r = g = b = 0;
+	for(k = 0; k < MAXLIGHTMAPS; k++)
+	{
+		if (tess.shader->styles[k] < LS_UNUSED)
+		{
+			byte	*styleColor = styleColors[tess.shader->styles[k]];
+
+			r += (ulong)(*colors++) * (ulong)(*styleColor++);
+			g += (ulong)(*colors++) * (ulong)(*styleColor++);
+			b += (ulong)(*colors++) * (ulong)(*styleColor);
+			colors++;
+		}
+		else
+		{
+			break;
+		}
+	}
+	result[0] = Com_Clamp(0, 255, r >> 8);
+	result[1] = Com_Clamp(0, 255, g >> 8);
+	result[2] = Com_Clamp(0, 255, b >> 8);
+
+	return *(ulong *)result;
+}
+
+#ifdef _XBOX
+//16 bits in, 32 bits out
+inline ulong ComputeFinalVertexColor16(const byte *colors)
+{
+	int			k;
+	byte		result[4];
+	byte		color32[4];
+	ulong		r, g, b;
+
+	result[0] = colors[0] & 0xF0;
+	result[1] = colors[0] << 4;
+	result[2] = colors[1] & 0xF0;
+	result[3] = colors[1] << 4;
+	if (tess.shader->lightmapIndex[0] != LIGHTMAP_BY_VERTEX || r_fullbright->integer )
+	{
+		result[0] = 255;
+		result[1] = 255;
+		result[2] = 255;
+		return *(ulong *)result;
+	}
+	// an optimization could be added here to compute the style[0] (which is always the world normal light)
+	r = g = b = 0;
+	for(k = 0; k < MAXLIGHTMAPS; k++)
+	{
+		if (tess.shader->styles[k] < LS_UNUSED)
+		{
+			byte	*styleColor = styleColors[tess.shader->styles[k]];
+
+			color32[0] = colors[k * 2] & 0xF0;
+			color32[1] = colors[k * 2] << 4;
+			color32[2] = colors[k * 2 + 1] & 0xF0;
+
+			r += (ulong)(color32[0]) * (ulong)(*styleColor++);
+			g += (ulong)(color32[1]) * (ulong)(*styleColor++);
+			b += (ulong)(color32[2]) * (ulong)(*styleColor);
+		}
+		else
+		{
+			break;
+		}
+	}
+	result[0] = Com_Clamp(0, 255, r >> 8);
+	result[1] = Com_Clamp(0, 255, g >> 8);
+	result[2] = Com_Clamp(0, 255, b >> 8);
+
+	return *(ulong *)result;
+}
+#endif
+
+/*
+=============
+RB_SurfaceTriangles
+=============
+*/
+void RB_SurfaceTriangles( srfTriangles_t *srf ) {
+	int			i, k;
+	drawVert_t	*dv;
+	float		*xyz, *normal, *texCoords;
+#ifdef _XBOX
+	float		*tangent;
+#endif
+	byte		*color;
+	int			dlightBits;
+
+	dlightBits = srf->dlightBits;
+	tess.dlightBits |= dlightBits;
+
+	RB_CHECKOVERFLOW( srf->numVerts, srf->numIndexes );
+
+	for ( i = 0 ; i < srf->numIndexes ; i += 3 ) {
+		tess.indexes[ tess.numIndexes + i + 0 ] = tess.numVertexes + srf->indexes[ i + 0 ];
+		tess.indexes[ tess.numIndexes + i + 1 ] = tess.numVertexes + srf->indexes[ i + 1 ];
+		tess.indexes[ tess.numIndexes + i + 2 ] = tess.numVertexes + srf->indexes[ i + 2 ];
+	}
+	tess.numIndexes += srf->numIndexes;
+
+	dv = srf->verts;
+	xyz = tess.xyz[ tess.numVertexes ];
+	normal = tess.normal[ tess.numVertexes ];
+	texCoords = tess.texCoords[ tess.numVertexes ][0];
+	color = tess.vertexColors[ tess.numVertexes ];
+#ifdef _XBOX
+	tangent = tess.tangent[ tess.numVertexes ];
+#endif
+
+	for ( i = 0 ; i < srf->numVerts ; i++, dv++) 
+	{
+#ifdef _XBOX
+		xyz[0] = (float)dv->xyz[0];
+		xyz[1] = (float)dv->xyz[1];
+		xyz[2] = (float)dv->xyz[2];
+		xyz += 4;
+
+		if ( tess.shader->needsNormal || tess.dlightBits )
+		{
+			normal[0] = (float)dv->normal[0] / 32767.f;
+			normal[1] = (float)dv->normal[1] / 32767.f;
+			normal[2] = (float)dv->normal[2] / 32767.f;
+			normal += 4;
+		}
+
+		if( tess.shader->needsTangent || tess.dlightBits )
+		{
+			tangent[0] = dv->tangent[0];
+			tangent[1] = dv->tangent[1];
+			tangent[2] = dv->tangent[2];
+			tangent += 4;
+
+			tess.setTangents = true;
+		}
+
+		Q_CastShort2FloatScale(&texCoords[0], &dv->dvst[0], 1.f / DRAWVERT_ST_SCALE);
+		Q_CastShort2FloatScale(&texCoords[1], &dv->dvst[1], 1.f / DRAWVERT_ST_SCALE);
+
+		for(k=0;k<MAXLIGHTMAPS;k++)
+		{
+			if (tess.shader->lightmapIndex[k] >= 0)
+			{
+				Q_CastShort2FloatScale(&texCoords[2+(k*2)+0], 
+					&dv->dvlightmap[k][0], 1.f / DRAWVERT_LIGHTMAP_SCALE);
+				Q_CastShort2FloatScale(&texCoords[2+(k*2)+1], 
+					&dv->dvlightmap[k][1], 1.f / DRAWVERT_LIGHTMAP_SCALE);
+			}
+			else
+			{	// can't have an empty slot in the middle, so we are done
+				break;
+			}
+		}
+		texCoords += NUM_TEX_COORDS*2;
+
+#ifdef COMPRESS_VERTEX_COLORS
+		*(unsigned int*)color = ComputeFinalVertexColor16((byte *)dv->dvcolor);
+#else
+		*(unsigned int*)color = ComputeFinalVertexColor((byte *)dv->dvcolor);
+#endif
+		color += 4;
+#else // _XBOX
+		xyz[0] = dv->xyz[0];
+		xyz[1] = dv->xyz[1];
+		xyz[2] = dv->xyz[2];
+		xyz += 4;
+
+		//if ( needsNormal ) 
+		{
+			normal[0] = dv->normal[0];
+			normal[1] = dv->normal[1];
+			normal[2] = dv->normal[2];
+		}
+		normal += 4;
+
+		texCoords[0] = dv->st[0];
+		texCoords[1] = dv->st[1];
+
+		for(k=0;k<MAXLIGHTMAPS;k++)
+		{
+			if (tess.shader->lightmapIndex[k] >= 0)
+			{
+				texCoords[2+(k*2)] = dv->lightmap[k][0];
+				texCoords[2+(k*2)+1] = dv->lightmap[k][1];
+			}
+			else
+			{	// can't have an empty slot in the middle, so we are done
+				break;
+			}
+		}
+		texCoords += NUM_TEX_COORDS*2;
+
+		*(unsigned int*)color = ComputeFinalVertexColor((byte *)dv->color);
+		color += 4;
+#endif // _XBOX
+	}
+
+	for ( i = 0 ; i < srf->numVerts ; i++ ) {
+		tess.vertexDlightBits[ tess.numVertexes + i] = dlightBits;
+	}
+
+	tess.numVertexes += srf->numVerts;
+}
+
+
+
+/*
+==============
+RB_SurfaceBeam
+==============
+*/
+static void RB_SurfaceBeam( void ) 
+{
+#define NUM_BEAM_SEGS 6
+	refEntity_t *e;
+	int	i;
+	vec3_t perpvec;
+	vec3_t direction, normalized_direction;
+	vec3_t	start_points[NUM_BEAM_SEGS], end_points[NUM_BEAM_SEGS];
+	vec3_t oldorigin, origin;
+
+	e = &backEnd.currentEntity->e;
+
+	oldorigin[0] = e->oldorigin[0];
+	oldorigin[1] = e->oldorigin[1];
+	oldorigin[2] = e->oldorigin[2];
+
+	origin[0] = e->origin[0];
+	origin[1] = e->origin[1];
+	origin[2] = e->origin[2];
+
+	normalized_direction[0] = direction[0] = oldorigin[0] - origin[0];
+	normalized_direction[1] = direction[1] = oldorigin[1] - origin[1];
+	normalized_direction[2] = direction[2] = oldorigin[2] - origin[2];
+
+	if ( VectorNormalize( normalized_direction ) == 0 )
+		return;
+
+	PerpendicularVector( perpvec, normalized_direction );
+
+	VectorScale( perpvec, 4, perpvec );
+
+	for ( i = 0; i < NUM_BEAM_SEGS ; i++ )
+	{
+		RotatePointAroundVector( start_points[i], normalized_direction, perpvec, (360.0/NUM_BEAM_SEGS)*i );
+//		VectorAdd( start_points[i], origin, start_points[i] );
+		VectorAdd( start_points[i], direction, end_points[i] );
+	}
+
+	GL_Bind( tr.whiteImage );
+
+	GL_State( GLS_SRCBLEND_ONE | GLS_DSTBLEND_ONE );
+
+	switch(e->skinNum)
+	{
+	case 1://Green
+		qglColor3f( 0, 1, 0 );
+		break;
+	case 2://Blue
+		qglColor3f( 0.5, 0.5, 1 );
+		break;
+	case 0://red
+	default:
+		qglColor3f( 1, 0, 0 );
+		break;
+	}
+
+	qglBegin( GL_TRIANGLE_STRIP );
+	for ( i = 0; i <= NUM_BEAM_SEGS; i++ ) {
+		qglVertex3fv( start_points[ i % NUM_BEAM_SEGS] );
+		qglVertex3fv( end_points[ i % NUM_BEAM_SEGS] );
+	}
+	qglEnd();
+}
+
+
+//------------------
+// DoSprite
+//------------------
+static void DoSprite( vec3_t origin, float radius, float rotation ) 
+{
+	float	s, c;
+	float	ang;
+	vec3_t	left, up;
+	
+	ang = M_PI * rotation / 180.0f;
+	s = sin( ang );
+	c = cos( ang );
+
+	VectorScale( backEnd.viewParms.or.axis[1], c * radius, left );
+	VectorMA( left, -s * radius, backEnd.viewParms.or.axis[2], left );
+
+	VectorScale( backEnd.viewParms.or.axis[2], c * radius, up );
+	VectorMA( up, s * radius, backEnd.viewParms.or.axis[1], up );
+
+	if ( backEnd.viewParms.isMirror ) 
+	{
+		VectorSubtract( vec3_origin, left, left );
+	}
+
+	RB_AddQuadStamp( origin, left, up, backEnd.currentEntity->e.shaderRGBA );
+}
+
+//------------------
+// RB_SurfaceSaber
+//------------------
+static void RB_SurfaceSaberGlow()
+{ 
+	vec3_t		end;
+	refEntity_t *e;
+
+	e = &backEnd.currentEntity->e;
+
+	// Render the glow part of the blade
+	for ( float i = e->saberLength; i > 0; i -= e->radius * 0.65f )
+	{
+		VectorMA( e->origin, i, e->axis[0], end );
+
+		DoSprite( end, e->radius, 0.0f );//random() * 360.0f );
+		e->radius += 0.017f;
+	}
+
+	// Big hilt sprite
+	// Please don't kill me Pat...I liked the hilt glow blob, but wanted a subtle pulse.:)  Feel free to ditch it if you don't like it.  --Jeff
+	// Please don't kill me Jeff...  The pulse is good, but now I want the halo bigger if the saber is shorter...  --Pat
+	DoSprite( e->origin, 5.5f + random() * 0.25f, 0.0f );//random() * 360.0f );
+}
+
+/*
+** LerpMeshVertexes
+*/
+static void LerpMeshVertexes (md3Surface_t *surf, float backlerp) 
+{
+	short	*oldXyz, *newXyz, *oldNormals, *newNormals;
+	float	*outXyz, *outNormal;
+	float	oldXyzScale, newXyzScale;
+	float	oldNormalScale, newNormalScale;
+	int		vertNum;
+	unsigned lat, lng;
+	int		numVerts;
+
+	outXyz = tess.xyz[tess.numVertexes];
+	outNormal = tess.normal[tess.numVertexes];
+
+	newXyz = (short *)((byte *)surf + surf->ofsXyzNormals)
+		+ (backEnd.currentEntity->e.frame * surf->numVerts * 4);
+	newNormals = newXyz + 3;
+
+	newXyzScale = MD3_XYZ_SCALE * (1.0 - backlerp);
+	newNormalScale = 1.0 - backlerp;
+
+	numVerts = surf->numVerts;
+
+	if ( backlerp == 0 ) {
+		//
+		// just copy the vertexes
+		//
+		for (vertNum=0 ; vertNum < numVerts ; vertNum++,
+			newXyz += 4, newNormals += 4,
+			outXyz += 4, outNormal += 4) 
+		{
+
+			outXyz[0] = newXyz[0] * newXyzScale;
+			outXyz[1] = newXyz[1] * newXyzScale;
+			outXyz[2] = newXyz[2] * newXyzScale;
+
+			lat = ( newNormals[0] >> 8 ) & 0xff;
+			lng = ( newNormals[0] & 0xff );
+			lat *= (FUNCTABLE_SIZE/256);
+			lng *= (FUNCTABLE_SIZE/256);
+
+			// decode X as cos( lat ) * sin( long )
+			// decode Y as sin( lat ) * sin( long )
+			// decode Z as cos( long )
+#ifdef _XBOX
+			if( tess.shader->needsNormal || tess.dlightBits )
+			{
+				outNormal[0] = tr.sinTable[(lat+(FUNCTABLE_SIZE/4))&FUNCTABLE_MASK] * tr.sinTable[lng];
+				outNormal[1] = tr.sinTable[lat] * tr.sinTable[lng];
+				outNormal[2] = tr.sinTable[(lng+(FUNCTABLE_SIZE/4))&FUNCTABLE_MASK];
+			}
+#else
+			outNormal[0] = tr.sinTable[(lat+(FUNCTABLE_SIZE/4))&FUNCTABLE_MASK] * tr.sinTable[lng];
+			outNormal[1] = tr.sinTable[lat] * tr.sinTable[lng];
+			outNormal[2] = tr.sinTable[(lng+(FUNCTABLE_SIZE/4))&FUNCTABLE_MASK];
+#endif
+		}
+	} else {
+		//
+		// interpolate and copy the vertex and normal
+		//
+		oldXyz = (short *)((byte *)surf + surf->ofsXyzNormals)
+			+ (backEnd.currentEntity->e.oldframe * surf->numVerts * 4);
+		oldNormals = oldXyz + 3;
+
+		oldXyzScale = MD3_XYZ_SCALE * backlerp;
+		oldNormalScale = backlerp;
+
+		for (vertNum=0 ; vertNum < numVerts ; vertNum++,
+			oldXyz += 4, newXyz += 4, oldNormals += 4, newNormals += 4,
+			outXyz += 4, outNormal += 4) 
+		{
+			vec3_t uncompressedOldNormal, uncompressedNewNormal;
+
+			// interpolate the xyz
+			outXyz[0] = oldXyz[0] * oldXyzScale + newXyz[0] * newXyzScale;
+			outXyz[1] = oldXyz[1] * oldXyzScale + newXyz[1] * newXyzScale;
+			outXyz[2] = oldXyz[2] * oldXyzScale + newXyz[2] * newXyzScale;
+
+#ifdef _XBOX
+			if(tess.shader->needsNormal || tess.dlightBits )
+			{
+#endif
+			// FIXME: interpolate lat/long instead?
+			lat = ( newNormals[0] >> 8 ) & 0xff;
+			lng = ( newNormals[0] & 0xff );
+			lat *= 4;
+			lng *= 4;
+			uncompressedNewNormal[0] = tr.sinTable[(lat+(FUNCTABLE_SIZE/4))&FUNCTABLE_MASK] * tr.sinTable[lng];
+			uncompressedNewNormal[1] = tr.sinTable[lat] * tr.sinTable[lng];
+			uncompressedNewNormal[2] = tr.sinTable[(lng+(FUNCTABLE_SIZE/4))&FUNCTABLE_MASK];
+
+			lat = ( oldNormals[0] >> 8 ) & 0xff;
+			lng = ( oldNormals[0] & 0xff );
+			lat *= 4;
+			lng *= 4;
+
+			uncompressedOldNormal[0] = tr.sinTable[(lat+(FUNCTABLE_SIZE/4))&FUNCTABLE_MASK] * tr.sinTable[lng];
+			uncompressedOldNormal[1] = tr.sinTable[lat] * tr.sinTable[lng];
+			uncompressedOldNormal[2] = tr.sinTable[(lng+(FUNCTABLE_SIZE/4))&FUNCTABLE_MASK];
+
+			outNormal[0] = uncompressedOldNormal[0] * oldNormalScale + uncompressedNewNormal[0] * newNormalScale;
+			outNormal[1] = uncompressedOldNormal[1] * oldNormalScale + uncompressedNewNormal[1] * newNormalScale;
+			outNormal[2] = uncompressedOldNormal[2] * oldNormalScale + uncompressedNewNormal[2] * newNormalScale;
+
+			VectorNormalize (outNormal);
+#ifdef _XBOX
+			}
+#endif
+		}
+	}
+}
+
+/*
+=============
+RB_SurfaceMesh
+=============
+*/
+void RB_SurfaceMesh(md3Surface_t *surface) {
+	int				j;
+	float			backlerp;
+	int				*triangles;
+	float			*texCoords;
+	int				indexes;
+	int				Bob, Doug;
+	int				numVerts;
+
+	if (  backEnd.currentEntity->e.oldframe == backEnd.currentEntity->e.frame ) {
+		backlerp = 0;
+	} else  {
+		backlerp = backEnd.currentEntity->e.backlerp;
+	}
+
+#ifdef VV_LIGHTING
+	if(backEnd.currentEntity->dlightBits)
+		tess.dlightBits = backEnd.currentEntity->dlightBits;
+#endif
+
+	RB_CHECKOVERFLOW( surface->numVerts, surface->numTriangles*3 );
+
+	LerpMeshVertexes (surface, backlerp);
+
+	triangles = (int *) ((byte *)surface + surface->ofsTriangles);
+	indexes = surface->numTriangles * 3;
+	Bob = tess.numIndexes;
+	Doug = tess.numVertexes;
+	for (j = 0 ; j < indexes ; j++) {
+		tess.indexes[Bob + j] = Doug + triangles[j];
+	}
+	tess.numIndexes += indexes;
+
+	texCoords = (float *) ((byte *)surface + surface->ofsSt);
+
+	numVerts = surface->numVerts;
+	for ( j = 0; j < numVerts; j++ ) {
+		tess.texCoords[Doug + j][0][0] = texCoords[j*2+0];
+		tess.texCoords[Doug + j][0][1] = texCoords[j*2+1];
+		// FIXME: fill in lightmapST for completeness?
+	}
+
+	tess.numVertexes += surface->numVerts;
+}
+
+
+/*
+==============
+RB_SurfaceFace
+==============
+*/
+void RB_SurfaceFace( srfSurfaceFace_t *surf ) {
+	int			i, k;
+	float		*normal;
+	int			ndx;
+	int			Bob;
+	int			numPoints;
+	int			dlightBits;
+#ifdef _XBOX
+	unsigned char	*indices;
+	unsigned short	*tessIndexes;
+	unsigned short	*v;
+#else
+	unsigned int *indices;
+	glIndex_t	*tessIndexes;
+	float		*v;
+#endif
+
+	RB_CHECKOVERFLOW( surf->numPoints, surf->numIndices );
+
+	dlightBits = surf->dlightBits;
+	tess.dlightBits |= dlightBits;
+
+#ifdef _XBOX
+	indices = ( unsigned char * ) ( ( ( char  * ) surf ) + surf->ofsIndices );
+#else
+	indices = ( unsigned * ) ( ( ( char  * ) surf ) + surf->ofsIndices );
+#endif
+
+	Bob = tess.numVertexes;
+	tessIndexes = tess.indexes + tess.numIndexes;
+	for ( i = surf->numIndices-1 ; i >= 0  ; i-- ) {
+		tessIndexes[i] = indices[i] + Bob;
+	}
+
+	tess.numIndexes += surf->numIndices;
+
+#ifdef _XBOX
+	ndx = tess.numVertexes;
+
+	numPoints = surf->numPoints;
+
+	if ( tess.shader->needsNormal || tess.dlightBits) {
+		normal = surf->plane.normal;
+		for ( i = 0, ndx = tess.numVertexes; i < numPoints; i++, ndx++ ) {
+			VectorCopy( normal, tess.normal[ndx] );
+		}
+	}
+
+	int nextSurfPoint = NEXT_SURFPOINT(surf->flags);
+	int numLightMaps = surf->flags & 0x7F;
+	for ( i = 0, v = surf->srfPoints, ndx = tess.numVertexes; i < numPoints; i++, v += nextSurfPoint, ndx++ ) {
+		Q_CastShort2Float(&tess.xyz[ndx][0], (short*)&v[0]);
+		Q_CastShort2Float(&tess.xyz[ndx][1], (short*)&v[1]);
+		Q_CastShort2Float(&tess.xyz[ndx][2], (short*)&v[2]);
+
+		if(tess.shader->needsTangent || tess.dlightBits)
+		{
+			Q_CastShort2Float(&tess.tangent[ndx][0], (short*)&v[3]);
+			Q_CastShort2Float(&tess.tangent[ndx][1], (short*)&v[4]);
+			Q_CastShort2Float(&tess.tangent[ndx][2], (short*)&v[5]);
+
+			tess.tangent[ndx][0] /= 32767.0f;
+			tess.tangent[ndx][1] /= 32767.0f;
+			tess.tangent[ndx][2] /= 32767.0f;
+
+			tess.setTangents = true;
+		}
+
+		Q_CastShort2FloatScale(&tess.texCoords[ndx][0][0], (short*)&v[6], 1.f / POINTS_ST_SCALE);
+		Q_CastShort2FloatScale(&tess.texCoords[ndx][0][1], (short*)&v[7], 1.f / POINTS_ST_SCALE);
+		for(k=0;k<numLightMaps;k++)
+		{
+			if (tess.shader->lightmapIndex[k] >= 0)
+			{
+				Q_CastUShort2FloatScale(&tess.texCoords[ndx][k+1][0], 
+					&v[VERTEX_LM+(k*2)+0], 1.f / POINTS_LIGHT_SCALE);
+				Q_CastUShort2FloatScale(&tess.texCoords[ndx][k+1][1], 
+					&v[VERTEX_LM+(k*2)+1], 1.f / POINTS_LIGHT_SCALE);
+			}
+			else
+			{
+				//This causes problems.  See bug 57.
+				//assert(0);
+				break;
+			}
+		}
+		if((surf->flags & 0x80) >> 7) {
+#ifdef COMPRESS_VERTEX_COLORS
+			*(unsigned int*) &tess.vertexColors[ndx] = ComputeFinalVertexColor16((byte *)&v[VERTEX_COLOR(surf->flags)]);
+#else
+			*(unsigned int*) &tess.vertexColors[ndx] = ComputeFinalVertexColor((byte *)&v[VERTEX_COLOR(surf->flags)]);
+#endif
+		}
+	}
+#else // _XBOX
+
+	v = surf->points[0];
+
+	ndx = tess.numVertexes;
+
+	numPoints = surf->numPoints;
+ 
+	//if ( tess.shader->needsNormal )
+	{
+		normal = surf->plane.normal;
+		for ( i = 0, ndx = tess.numVertexes; i < numPoints; i++, ndx++ ) {
+			VectorCopy( normal, tess.normal[ndx] );
+		}
+	}
+
+	for ( i = 0, v = surf->points[0], ndx = tess.numVertexes; i < numPoints; i++, v += VERTEXSIZE, ndx++ ) {
+		VectorCopy( v, tess.xyz[ndx]);
+		tess.texCoords[ndx][0][0] = v[3];
+		tess.texCoords[ndx][0][1] = v[4];
+		for(k=0;k<MAXLIGHTMAPS;k++)
+		{
+			if (tess.shader->lightmapIndex[k] >= 0)
+			{
+				tess.texCoords[ndx][k+1][0] = v[VERTEX_LM+(k*2)];
+				tess.texCoords[ndx][k+1][1] = v[VERTEX_LM+(k*2)+1];
+			}
+			else
+			{
+				break;
+			}
+		}
+		*(unsigned int*) &tess.vertexColors[ndx] = ComputeFinalVertexColor((byte *)&v[VERTEX_COLOR]);
+		tess.vertexDlightBits[ndx] = dlightBits;
+	}
+#endif // _XBOX
+
+	tess.numVertexes += surf->numPoints;
+}
+
+
+static float LodErrorForVolume( vec3_t local, float radius ) {
+	vec3_t		world;
+	float		d;
+
+	world[0] = local[0] * backEnd.ori.axis[0][0] + local[1] * backEnd.ori.axis[1][0] + 
+		local[2] * backEnd.ori.axis[2][0] + backEnd.ori.origin[0];
+	world[1] = local[0] * backEnd.ori.axis[0][1] + local[1] * backEnd.ori.axis[1][1] + 
+		local[2] * backEnd.ori.axis[2][1] + backEnd.ori.origin[1];
+	world[2] = local[0] * backEnd.ori.axis[0][2] + local[1] * backEnd.ori.axis[1][2] + 
+		local[2] * backEnd.ori.axis[2][2] + backEnd.ori.origin[2];
+
+	VectorSubtract( world, backEnd.viewParms.or.origin, world );
+	d = DotProduct( world, backEnd.viewParms.or.axis[0] );
+
+	if ( d < 0 ) {
+		d = -d;
+	}
+	d -= radius;
+	if ( d < 1 ) {
+		d = 1;
+	}
+
+	return r_lodCurveError->value / d;
+}
+
+/*
+=============
+RB_SurfaceGrid
+
+Just copy the grid of points and triangulate
+=============
+*/
+void RB_SurfaceGrid( srfGridMesh_t *cv ) {
+	int		i, j, k;
+	float	*xyz;
+	float	*texCoords;
+	float	*normal;
+	unsigned char *color;
+	drawVert_t	*dv;
+	int		rows, irows, vrows;
+	int		used;
+	int		widthTable[MAX_GRID_SIZE];
+	int		heightTable[MAX_GRID_SIZE];
+	float	lodError;
+	int		lodWidth, lodHeight;
+	int		numVertexes;
+	int		dlightBits;
+	int		*vDlightBits;
+
+	dlightBits = cv->dlightBits;
+	tess.dlightBits |= dlightBits;
+
+	// determine the allowable discrepance
+	lodError = LodErrorForVolume( cv->lodOrigin, cv->lodRadius );
+
+	// determine which rows and columns of the subdivision
+	// we are actually going to use
+	widthTable[0] = 0;
+	lodWidth = 1;
+	for ( i = 1 ; i < cv->width-1 ; i++ ) {
+		if ( cv->widthLodError[i] <= lodError ) {
+			widthTable[lodWidth] = i;
+			lodWidth++;
+		}
+	}
+	widthTable[lodWidth] = cv->width-1;
+	lodWidth++;
+
+	heightTable[0] = 0;
+	lodHeight = 1;
+	for ( i = 1 ; i < cv->height-1 ; i++ ) {
+		if ( cv->heightLodError[i] <= lodError ) {
+			heightTable[lodHeight] = i;
+			lodHeight++;
+		}
+	}
+	heightTable[lodHeight] = cv->height-1;
+	lodHeight++;
+
+
+	// very large grids may have more points or indexes than can be fit
+	// in the tess structure, so we may have to issue it in multiple passes
+
+	used = 0;
+	rows = 0;
+	while ( used < lodHeight - 1 ) {
+		// see how many rows of both verts and indexes we can add without overflowing
+		do {
+			vrows = ( SHADER_MAX_VERTEXES - tess.numVertexes ) / lodWidth;
+			irows = ( SHADER_MAX_INDEXES - tess.numIndexes ) / ( lodWidth * 6 );
+
+			// if we don't have enough space for at least one strip, flush the buffer
+			if ( vrows < 2 || irows < 1 ) {
+				RB_EndSurface();
+				RB_BeginSurface(tess.shader, tess.fogNum );
+			} else {
+				break;
+			}
+		} while ( 1 );
+		
+		rows = irows;
+		if ( vrows < irows + 1 ) {
+			rows = vrows - 1;
+		}
+		if ( used + rows > lodHeight ) {
+			rows = lodHeight - used;
+		}
+
+		numVertexes = tess.numVertexes;
+
+		xyz = tess.xyz[numVertexes];
+		normal = tess.normal[numVertexes];
+		texCoords = tess.texCoords[numVertexes][0];
+		color = ( unsigned char * ) &tess.vertexColors[numVertexes];
+		vDlightBits = &tess.vertexDlightBits[numVertexes];
+
+#ifdef _XBOX
+		for ( i = 0 ; i < rows ; i++ ) {
+			for ( j = 0 ; j < lodWidth ; j++ ) {
+				dv = cv->verts + heightTable[ used + i ] * cv->width
+					+ widthTable[ j ];
+
+				xyz[0] = (float)dv->xyz[0];
+				xyz[1] = (float)dv->xyz[1];
+				xyz[2] = (float)dv->xyz[2];
+				xyz += 4;
+
+				Q_CastShort2FloatScale(&texCoords[0], &dv->dvst[0], 1.f / GRID_DRAWVERT_ST_SCALE);
+				Q_CastShort2FloatScale(&texCoords[1], &dv->dvst[1], 1.f / GRID_DRAWVERT_ST_SCALE);
+
+				for(k=0;k<MAXLIGHTMAPS;k++)
+				{
+					Q_CastShort2FloatScale(&texCoords[2+(k*2)+0], 
+						&dv->dvlightmap[k][0], 1.f / DRAWVERT_LIGHTMAP_SCALE);
+					Q_CastShort2FloatScale(&texCoords[2+(k*2)+1], 
+						&dv->dvlightmap[k][1], 1.f / DRAWVERT_LIGHTMAP_SCALE);
+				}
+				texCoords += NUM_TEX_COORDS*2;
+
+				if ( tess.shader->needsNormal || tess.dlightBits) 
+				{
+					normal[0] = (float)dv->normal[0] / 32767.f;
+					normal[1] = (float)dv->normal[1] / 32767.f;
+					normal[2] = (float)dv->normal[2] / 32767.f;
+					normal += 4;
+				}
+#ifdef COMPRESS_VERTEX_COLORS
+				*(unsigned *)color = ComputeFinalVertexColor16((byte *)dv->dvcolor);
+#else
+				*(unsigned *)color = ComputeFinalVertexColor((byte *)dv->dvcolor);
+#endif
+				color += 4;
+				*vDlightBits++ = dlightBits;
+			}
+		}
+#else
+		for ( i = 0 ; i < rows ; i++ ) {
+			for ( j = 0 ; j < lodWidth ; j++ ) {
+				dv = cv->verts + heightTable[ used + i ] * cv->width
+					+ widthTable[ j ];
+
+				xyz[0] = dv->xyz[0];
+				xyz[1] = dv->xyz[1];
+				xyz[2] = dv->xyz[2];
+				xyz += 4;
+
+				texCoords[0] = dv->st[0];
+				texCoords[1] = dv->st[1];
+
+				for(k=0;k<MAXLIGHTMAPS;k++)
+				{
+					texCoords[2+(k*2)]= dv->lightmap[k][0];
+					texCoords[2+(k*2)+1]= dv->lightmap[k][1];
+				}
+				texCoords += NUM_TEX_COORDS*2;
+
+//				if ( needsNormal ) 
+				{
+					normal[0] = dv->normal[0];
+					normal[1] = dv->normal[1];
+					normal[2] = dv->normal[2];
+				}
+				normal += 4;
+				*(unsigned *)color = ComputeFinalVertexColor((byte *)dv->color);
+				color += 4;
+				*vDlightBits++ = dlightBits;
+			}
+		}
+#endif
+
+		// add the indexes
+		{
+			int		numIndexes;
+			int		w, h;
+
+			h = rows - 1;
+			w = lodWidth - 1;
+			numIndexes = tess.numIndexes;
+			for (i = 0 ; i < h ; i++) {
+				for (j = 0 ; j < w ; j++) {
+					int		v1, v2, v3, v4;
+			
+					// vertex order to be reckognized as tristrips
+					v1 = numVertexes + i*lodWidth + j + 1;
+					v2 = v1 - 1;
+					v3 = v2 + lodWidth;
+					v4 = v3 + 1;
+
+					tess.indexes[numIndexes] = v2;
+					tess.indexes[numIndexes+1] = v3;
+					tess.indexes[numIndexes+2] = v1;
+					
+					tess.indexes[numIndexes+3] = v1;
+					tess.indexes[numIndexes+4] = v3;
+					tess.indexes[numIndexes+5] = v4;
+					numIndexes += 6;
+				}
+			}
+
+			tess.numIndexes = numIndexes;
+		}
+
+		tess.numVertexes += rows * lodWidth;
+
+		used += rows - 1;
+	}
+}
+
+static inline void Vector2Set(vec2_t a,float b,float c)
+{
+	a[0] = b;
+	a[1] = c;
+}
+
+static inline void Vector2Copy(vec2_t src,vec2_t dst)
+{
+	dst[0] = src[0];
+	dst[1] = src[1];
+}
+
+#define LATHE_SEG_STEP	10
+#define BEZIER_STEP		0.05f	// must be in the range of 0 to 1
+
+// FIXME: This function is horribly expensive
+static void RB_SurfaceLathe()
+{
+	refEntity_t *e;
+	vec2_t		pt, oldpt, l_oldpt;
+	vec2_t		pt2, oldpt2, l_oldpt2; 
+	float		bezierStep, latheStep;
+    float		temp, mu, mum1;
+	float		mum13, mu3, group1, group2;
+	float		s, c, d = 1.0f, pain = 0.0f;
+	int			i, t, vbase;
+
+	e = &backEnd.currentEntity->e;
+
+	if ( e->endTime && e->endTime > backEnd.refdef.time )
+	{
+		d = 1.0f - ( e->endTime - backEnd.refdef.time ) / 1000.0f;
+	}
+
+	if ( e->frame && e->frame + 1000 > backEnd.refdef.time )
+	{
+		pain = ( backEnd.refdef.time - e->frame ) / 1000.0f;
+//		pain *= pain;
+		pain = ( 1.0f - pain ) * 0.08f;
+	}
+
+	Vector2Set( l_oldpt, e->axis[0][0], e->axis[0][1] );
+
+	// do scalability stuff...r_lodbias 0-3
+	int lod = r_lodbias->integer + 1;
+	if ( lod > 4 )
+	{
+		lod = 4;
+	}
+	bezierStep = BEZIER_STEP * lod;
+	latheStep = LATHE_SEG_STEP * lod;
+
+	// Do bezier profile strip, then lathe this around to make a 3d model
+	for ( mu = 0.0f; mu <= 1.01f * d; mu += bezierStep )
+	{
+		// Four point curve
+		mum1	= 1 - mu;
+		mum13	= mum1 * mum1 * mum1;
+		mu3		= mu * mu * mu;
+		group1	= 3 * mu * mum1 * mum1;
+		group2	= 3 * mu * mu *mum1;
+
+		// Calc the current point on the curve
+		for ( i = 0; i < 2; i++ )
+		{
+			l_oldpt2[i] = mum13 * e->axis[0][i] + group1 * e->axis[1][i] + group2 * e->axis[2][i] + mu3 * e->oldorigin[i];
+		}
+
+		Vector2Set( oldpt, l_oldpt[0], 0 );
+		Vector2Set( oldpt2, l_oldpt2[0], 0 );
+
+		// lathe patch section around in a complete circle
+		for ( t = latheStep; t <= 360; t += latheStep )
+		{
+			Vector2Set( pt, l_oldpt[0], 0 );
+			Vector2Set( pt2, l_oldpt2[0], 0 );
+
+			s = sin( DEG2RAD( t ));
+			c = cos( DEG2RAD( t ));
+
+			// rotate lathe points
+//c -s 0
+//s  c 0
+//0  0 1
+			temp = c * pt[0] - s * pt[1];
+			pt[1] = s * pt[0] + c * pt[1];
+			pt[0] = temp;
+			temp = c * pt2[0] - s * pt2[1];
+			pt2[1] = s * pt2[0] + c * pt2[1];
+			pt2[0] = temp;
+
+			RB_CHECKOVERFLOW( 4, 6 );  
+
+			vbase = tess.numVertexes;
+
+			// Actually generate the necessary verts
+			VectorSet( tess.normal[tess.numVertexes], oldpt[0], oldpt[1], l_oldpt[1] );
+			VectorAdd( e->origin, tess.normal[tess.numVertexes], tess.xyz[tess.numVertexes] );
+			VectorNormalize( tess.normal[tess.numVertexes] );
+			i = oldpt[0] * 0.1f + oldpt[1] * 0.1f;
+			tess.texCoords[tess.numVertexes][0][0] = (t-latheStep)/360.0f;
+			tess.texCoords[tess.numVertexes][0][1] = mu-bezierStep + cos( i + backEnd.refdef.floatTime ) * pain;
+			tess.vertexColors[tess.numVertexes][0] = e->shaderRGBA[0];
+			tess.vertexColors[tess.numVertexes][1] = e->shaderRGBA[1];
+			tess.vertexColors[tess.numVertexes][2] = e->shaderRGBA[2];
+			tess.vertexColors[tess.numVertexes][3] = e->shaderRGBA[3];
+			tess.numVertexes++;
+
+			VectorSet( tess.normal[tess.numVertexes], oldpt2[0], oldpt2[1], l_oldpt2[1] );
+			VectorAdd( e->origin, tess.normal[tess.numVertexes], tess.xyz[tess.numVertexes] );
+			VectorNormalize( tess.normal[tess.numVertexes] );
+			i = oldpt2[0] * 0.1f + oldpt2[1] * 0.1f;
+			tess.texCoords[tess.numVertexes][0][0] = (t-latheStep) / 360.0f;
+			tess.texCoords[tess.numVertexes][0][1] = mu + cos( i + backEnd.refdef.floatTime ) * pain;
+			tess.vertexColors[tess.numVertexes][0] = e->shaderRGBA[0];
+			tess.vertexColors[tess.numVertexes][1] = e->shaderRGBA[1];
+			tess.vertexColors[tess.numVertexes][2] = e->shaderRGBA[2];
+			tess.vertexColors[tess.numVertexes][3] = e->shaderRGBA[3];
+			tess.numVertexes++;
+
+			VectorSet( tess.normal[tess.numVertexes], pt[0], pt[1], l_oldpt[1] );
+			VectorAdd( e->origin, tess.normal[tess.numVertexes], tess.xyz[tess.numVertexes] );
+			VectorNormalize( tess.normal[tess.numVertexes] );
+			i = pt[0] * 0.1f + pt[1] * 0.1f;
+			tess.texCoords[tess.numVertexes][0][0] = t/360.0f;
+			tess.texCoords[tess.numVertexes][0][1] = mu-bezierStep + cos( i + backEnd.refdef.floatTime ) * pain;
+			tess.vertexColors[tess.numVertexes][0] = e->shaderRGBA[0];
+			tess.vertexColors[tess.numVertexes][1] = e->shaderRGBA[1];
+			tess.vertexColors[tess.numVertexes][2] = e->shaderRGBA[2];
+			tess.vertexColors[tess.numVertexes][3] = e->shaderRGBA[3];
+			tess.numVertexes++;
+
+			VectorSet( tess.normal[tess.numVertexes], pt2[0], pt2[1], l_oldpt2[1] );
+			VectorAdd( e->origin, tess.normal[tess.numVertexes], tess.xyz[tess.numVertexes] );
+			VectorNormalize( tess.normal[tess.numVertexes] );
+			i = pt2[0] * 0.1f + pt2[1] * 0.1f;
+			tess.texCoords[tess.numVertexes][0][0] = t/360.0f;
+			tess.texCoords[tess.numVertexes][0][1] = mu + cos( i + backEnd.refdef.floatTime ) * pain;
+			tess.vertexColors[tess.numVertexes][0] = e->shaderRGBA[0];
+			tess.vertexColors[tess.numVertexes][1] = e->shaderRGBA[1];
+			tess.vertexColors[tess.numVertexes][2] = e->shaderRGBA[2];
+			tess.vertexColors[tess.numVertexes][3] = e->shaderRGBA[3];
+			tess.numVertexes++;
+
+			tess.indexes[tess.numIndexes++] = vbase;
+			tess.indexes[tess.numIndexes++] = vbase + 1;
+			tess.indexes[tess.numIndexes++] = vbase + 3;
+
+			tess.indexes[tess.numIndexes++] = vbase + 3;
+			tess.indexes[tess.numIndexes++] = vbase + 2;
+			tess.indexes[tess.numIndexes++] = vbase;
+
+			// Shuffle new points to old
+			Vector2Copy( pt, oldpt );
+			Vector2Copy( pt2, oldpt2 );
+		}
+
+		// shuffle lathe points
+		Vector2Copy( l_oldpt2, l_oldpt );
+	}
+}
+
+#define DISK_DEF	4
+#define TUBE_DEF	6
+
+static void RB_SurfaceClouds()
+{
+	// Disk definition
+	float diskStripDef[DISK_DEF] = { 
+				0.0f,
+				0.4f,
+				0.7f,
+				1.0f };
+
+	float diskAlphaDef[DISK_DEF] = { 
+				1.0f,
+				1.0f,
+				0.4f,
+				0.0f };
+
+	float diskCurveDef[DISK_DEF] = {
+				0.0f,
+				0.0f,
+				0.008f,
+				0.02f };
+
+	// tube definition
+	float tubeStripDef[TUBE_DEF] = { 
+				0.0f,
+				0.05f,
+				0.1f,
+				0.5f,
+				0.7f,
+				1.0f };
+
+	float tubeAlphaDef[TUBE_DEF] = { 
+				0.0f,
+				0.45f,
+				1.0f,
+				1.0f,
+				0.45f,
+				0.0f };
+
+	float tubeCurveDef[TUBE_DEF] = { 
+				0.0f,
+				0.004f,
+				0.006f,
+				0.01f,
+				0.006f,
+				0.0f };
+
+	refEntity_t *e;
+	vec3_t		pt, oldpt;
+	vec3_t		pt2, oldpt2;
+	float		latheStep = 30.0f;
+	float		s, c, temp;
+	float		*stripDef, *alphaDef, *curveDef, ct;
+	int			i, t, vbase;
+
+	e = &backEnd.currentEntity->e;
+
+	// select which type we shall be doing
+	if ( e->renderfx & RF_GROW ) // doing tube type
+	{
+		ct = TUBE_DEF;
+		stripDef = tubeStripDef;
+		alphaDef = tubeAlphaDef;
+		curveDef = tubeCurveDef;
+		e->backlerp *= -1; // needs to be reversed
+	}
+	else
+	{
+		ct = DISK_DEF;
+		stripDef = diskStripDef;
+		alphaDef = diskAlphaDef;
+		curveDef = diskCurveDef;
+	}
+
+	// do the strip def, then lathe this around to make a 3d model
+	for ( i = 0; i < ct - 1; i++ )
+	{
+		VectorSet( oldpt,	(stripDef[i]	* (e->radius - e->rotation)) + e->rotation,	0, curveDef[i] * e->radius * e->backlerp );
+		VectorSet( oldpt2,	(stripDef[i+1]	* (e->radius - e->rotation)) + e->rotation,	0, curveDef[i+1] * e->radius * e->backlerp );
+
+		// lathe section around in a complete circle
+		for ( t = latheStep; t <= 360; t += latheStep )
+		{
+			// rotate every time except last seg
+			if ( t < 360.0f )
+			{
+				VectorCopy( oldpt, pt );
+				VectorCopy( oldpt2, pt2 );
+
+				s = sin( DEG2RAD( latheStep ));
+				c = cos( DEG2RAD( latheStep ));
+
+				// rotate lathe points
+				temp = c * pt[0] - s * pt[1];	// c -s 0
+				pt[1] = s * pt[0] + c * pt[1];	// s  c 0
+				pt[0] = temp;					// 0  0 1
+
+				temp = c * pt2[0] - s * pt2[1];	 // c -s 0
+				pt2[1] = s * pt2[0] + c * pt2[1];// s  c 0
+				pt2[0] = temp;					 // 0  0 1
+			}
+			else
+			{
+				// just glue directly to the def points.
+				VectorSet( pt,	(stripDef[i]	* (e->radius - e->rotation)) + e->rotation,	0, curveDef[i] * e->radius * e->backlerp );
+				VectorSet( pt2,	(stripDef[i+1]	* (e->radius - e->rotation)) + e->rotation,	0, curveDef[i+1] * e->radius * e->backlerp );
+			}
+
+			RB_CHECKOVERFLOW( 4, 6 );  
+
+			vbase = tess.numVertexes;
+
+			// Actually generate the necessary verts
+			VectorAdd( e->origin, oldpt, tess.xyz[tess.numVertexes] );
+			tess.texCoords[tess.numVertexes][0][0] = tess.xyz[tess.numVertexes][0] * 0.1f;
+			tess.texCoords[tess.numVertexes][0][1] = tess.xyz[tess.numVertexes][1] * 0.1f;
+			tess.vertexColors[tess.numVertexes][0] = 
+			tess.vertexColors[tess.numVertexes][1] = 
+			tess.vertexColors[tess.numVertexes][2] = e->shaderRGBA[0] * alphaDef[i];
+			tess.vertexColors[tess.numVertexes][3] = e->shaderRGBA[3];
+			tess.numVertexes++;
+
+			VectorAdd( e->origin, oldpt2, tess.xyz[tess.numVertexes] );
+			tess.texCoords[tess.numVertexes][0][0] = tess.xyz[tess.numVertexes][0] * 0.1f;
+			tess.texCoords[tess.numVertexes][0][1] = tess.xyz[tess.numVertexes][1] * 0.1f;
+			tess.vertexColors[tess.numVertexes][0] = 
+			tess.vertexColors[tess.numVertexes][1] = 
+			tess.vertexColors[tess.numVertexes][2] = e->shaderRGBA[0] * alphaDef[i+1];
+			tess.vertexColors[tess.numVertexes][3] = e->shaderRGBA[3];
+			tess.numVertexes++;
+
+			VectorAdd( e->origin, pt, tess.xyz[tess.numVertexes] );
+			tess.texCoords[tess.numVertexes][0][0] = tess.xyz[tess.numVertexes][0] * 0.1f;
+			tess.texCoords[tess.numVertexes][0][1] = tess.xyz[tess.numVertexes][1] * 0.1f;
+			tess.vertexColors[tess.numVertexes][0] = 
+			tess.vertexColors[tess.numVertexes][1] = 
+			tess.vertexColors[tess.numVertexes][2] = e->shaderRGBA[0] * alphaDef[i];
+			tess.vertexColors[tess.numVertexes][3] = e->shaderRGBA[3];
+			tess.numVertexes++;
+
+			VectorAdd( e->origin, pt2, tess.xyz[tess.numVertexes] );
+			tess.texCoords[tess.numVertexes][0][0] = tess.xyz[tess.numVertexes][0] * 0.1f;
+			tess.texCoords[tess.numVertexes][0][1] = tess.xyz[tess.numVertexes][1] * 0.1f;
+			tess.vertexColors[tess.numVertexes][0] = 
+			tess.vertexColors[tess.numVertexes][1] = 
+			tess.vertexColors[tess.numVertexes][2] = e->shaderRGBA[0] * alphaDef[i+1];
+			tess.vertexColors[tess.numVertexes][3] = e->shaderRGBA[3];
+			tess.numVertexes++;
+
+			tess.indexes[tess.numIndexes++] = vbase;
+			tess.indexes[tess.numIndexes++] = vbase + 1;
+			tess.indexes[tess.numIndexes++] = vbase + 3;
+
+			tess.indexes[tess.numIndexes++] = vbase + 3;
+			tess.indexes[tess.numIndexes++] = vbase + 2;
+			tess.indexes[tess.numIndexes++] = vbase;
+
+			// Shuffle new points to old
+			Vector2Copy( pt, oldpt );
+			Vector2Copy( pt2, oldpt2 );
+		}
+	}
+}
+
+
+/*
+===========================================================================
+
+NULL MODEL
+
+===========================================================================
+*/
+
+/*
+===================
+RB_SurfaceAxis
+
+Draws x/y/z lines from the origin for orientation debugging
+===================
+*/
+static void RB_SurfaceAxis( void ) {
+	GL_Bind( tr.whiteImage );
+	qglLineWidth( 3 );
+#ifdef _XBOX
+	qglBeginEXT( GL_LINES, 6, 3, 0, 0, 0);
+#else
+	qglBegin( GL_LINES );
+#endif
+	qglColor3f( 1,0,0 );
+	qglVertex3f( 0,0,0 );
+	qglVertex3f( 16,0,0 );
+	qglColor3f( 0,1,0 );
+	qglVertex3f( 0,0,0 );
+	qglVertex3f( 0,16,0 );
+	qglColor3f( 0,0,1 );
+	qglVertex3f( 0,0,0 );
+	qglVertex3f( 0,0,16 );
+	qglEnd();
+	qglLineWidth( 1 );
+}
+
+//===========================================================================
+
+/*
+====================
+RB_SurfaceEntity
+
+Entities that have a single procedurally generated surface
+====================
+*/
+void RB_SurfaceEntity( surfaceType_t *surfType ) {
+	switch( backEnd.currentEntity->e.reType ) {
+	case RT_SPRITE:
+		RB_SurfaceSprite();
+		break;
+	case RT_ORIENTED_QUAD:
+		RB_SurfaceOrientedQuad();
+		break;
+	case RT_LINE:
+		RB_SurfaceLine();
+		break;
+	case RT_ELECTRICITY:
+		RB_SurfaceElectricity();
+		break;
+	case RT_BEAM:
+		RB_SurfaceBeam();
+		break;
+	case RT_SABER_GLOW:
+		RB_SurfaceSaberGlow();
+		break;
+	case RT_CYLINDER:
+		RB_SurfaceCylinder();
+		break; 
+	case RT_LATHE:
+		RB_SurfaceLathe();
+		break;
+	case RT_CLOUDS:
+		RB_SurfaceClouds();
+		break;
+	default:
+		RB_SurfaceAxis();
+		break;
+	}
+	return;
+}
+
+void RB_SurfaceBad( surfaceType_t *surfType ) {
+	VID_Printf( PRINT_ALL, "Bad surface tesselated.\n" );
+}
+
+
+/*
+==================
+RB_TestZFlare
+
+This is called at surface tesselation time
+==================
+*/
+static bool RB_TestZFlare( vec3_t point) {
+	int				i;
+	vec4_t			eye, clip, normalized, window;
+
+	// if the point is off the screen, don't bother adding it
+	// calculate screen coordinates and depth
+	R_TransformModelToClip( point, backEnd.ori.modelMatrix, 
+		backEnd.viewParms.projectionMatrix, eye, clip );
+
+	// check to see if the point is completely off screen
+	for ( i = 0 ; i < 3 ; i++ ) {
+		if ( clip[i] >= clip[3] || clip[i] <= -clip[3] ) {
+			return qfalse;
+		}
+	}
+
+	R_TransformClipToWindow( clip, &backEnd.viewParms, normalized, window );
+
+	if ( window[0] < 0 || window[0] >= backEnd.viewParms.viewportWidth
+		|| window[1] < 0 || window[1] >= backEnd.viewParms.viewportHeight ) {
+		return qfalse;	// shouldn't happen, since we check the clip[] above, except for FP rounding
+	}
+
+//do test
+	float			depth = 0.0f;
+	bool			visible;
+	float			screenZ;
+
+	// read back the z buffer contents
+#ifdef _XBOX
+	depth = 0.0f;
+#else
+	if ( r_flares->integer !=1 ) {	//skipping the the z-test
+		return true;
+	}
+	// doing a readpixels is as good as doing a glFinish(), so
+	// don't bother with another sync
+	glState.finishCalled = qfalse;
+	qglReadPixels( backEnd.viewParms.viewportX + window[0],backEnd.viewParms.viewportY + window[1], 1, 1, GL_DEPTH_COMPONENT, GL_FLOAT, &depth );
+#endif
+
+	screenZ = backEnd.viewParms.projectionMatrix[14] / 
+		( ( 2*depth - 1 ) * backEnd.viewParms.projectionMatrix[11] - backEnd.viewParms.projectionMatrix[10] );
+
+	visible = ( -eye[2] - -screenZ ) < 24;
+	return visible;
+}
+
+void RB_SurfaceFlare( srfFlare_t *surf ) {
+	vec3_t		left, up;
+	float		radius;
+	byte		color[4];
+	vec3_t		dir;
+	vec3_t		origin;
+	float		d, dist;
+
+	if ( !r_flares->integer ) {
+		return;
+	}
+
+#ifdef _XBOX
+	vec3_t     sorigin, snormal;
+
+	Q_CastShort2Float(&sorigin[0], (short*)&surf->origin[0]);
+	Q_CastShort2Float(&sorigin[1], (short*)&surf->origin[1]);
+	Q_CastShort2Float(&sorigin[2], (short*)&surf->origin[2]);
+
+	if (!RB_TestZFlare( sorigin) ) {
+		return;
+	}
+
+	Q_CastShort2Float(&snormal[0], (short*)&surf->normal[0]);
+	Q_CastShort2Float(&snormal[1], (short*)&surf->normal[1]);
+	Q_CastShort2Float(&snormal[2], (short*)&surf->normal[2]);
+	snormal[0] /= 32767.0f;
+	snormal[1] /= 32767.0f;
+	snormal[2] /= 32767.0f;
+
+	// calculate the xyz locations for the four corners
+	VectorMA( sorigin, 3, snormal, origin );
+#else
+	if (!RB_TestZFlare( surf->origin ) ) {
+		return;
+	}
+
+	// calculate the xyz locations for the four corners
+	VectorMA( surf->origin, 3, surf->normal, origin );
+	float* snormal = surf->normal;
+#endif // _XBOX
+
+	VectorSubtract( origin, backEnd.viewParms.or.origin, dir );
+	dist = VectorNormalize( dir );
+
+	d = -DotProduct( dir, snormal );
+	if ( d < 0 ) {
+		d = -d;
+	}
+
+	// fade the intensity of the flare down as the
+	// light surface turns away from the viewer
+	color[0] = d * 255;
+	color[1] = d * 255;
+	color[2] = d * 255;
+	color[3] = 255;	//only gets used if the shader has cgen exact_vertex!
+
+	radius = tess.shader->portalRange ? tess.shader->portalRange: 30;
+	if (dist < 512.0f)
+	{
+		radius = radius * dist / 512.0f;
+	}
+	if (radius<5.0f)
+	{
+		radius = 5.0f;
+	}
+	VectorScale( backEnd.viewParms.or.axis[1], radius, left );
+	VectorScale( backEnd.viewParms.or.axis[2], radius, up );
+	if ( backEnd.viewParms.isMirror ) {
+		VectorSubtract( vec3_origin, left, left );
+	}
+
+	RB_AddQuadStamp( origin, left, up, color );
+}
+
+
+void RB_SurfaceDisplayList( srfDisplayList_t *surf ) {
+	// all apropriate state must be set in RB_BeginSurface
+	// this isn't implemented yet...
+	qglCallList( surf->listNum );
+}
+
+void RB_SurfaceSkip( void *surf ) {
+}
+
+void RB_SurfaceTerrain( surfaceInfo_t *surf );
+
+void (*rb_surfaceTable[SF_NUM_SURFACE_TYPES])( void *) = {
+	(void(*)(void*))RB_SurfaceBad,			// SF_BAD, 
+	(void(*)(void*))RB_SurfaceSkip,			// SF_SKIP, 
+	(void(*)(void*))RB_SurfaceFace,			// SF_FACE,
+	(void(*)(void*))RB_SurfaceGrid,			// SF_GRID,
+	(void(*)(void*))RB_SurfaceTriangles,	// SF_TRIANGLES,
+	(void(*)(void*))RB_SurfacePolychain,	// SF_POLY,
+#ifdef _XBOX
+	NULL,
+#else
+	(void(*)(void*))RB_SurfaceTerrain,		// SF_TERRAIN,
+#endif
+	(void(*)(void*))RB_SurfaceMesh,			// SF_MD3,
+/*
+Ghoul2 Insert Start
+*/
+
+	(void(*)(void*))RB_SurfaceGhoul,		// SF_MDX,
+/*
+Ghoul2 Insert End
+*/
+
+	(void(*)(void*))RB_SurfaceFlare,		// SF_FLARE,
+	(void(*)(void*))RB_SurfaceEntity,		// SF_ENTITY
+	(void(*)(void*))RB_SurfaceDisplayList	// SF_DISPLAY_LIST
+};
diff --git a/code/renderer/tr_surfacesprites.cpp b/code/renderer/tr_surfacesprites.cpp
new file mode 100644
index 0000000..482e271
--- /dev/null
+++ b/code/renderer/tr_surfacesprites.cpp
@@ -0,0 +1,1492 @@
+// tr_surfacesprites.c
+
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+
+#include "tr_QuickSprite.h"
+#include "tr_worldeffects.h"
+#include <float.h> //for isnan
+
+/////===== Part of the VERTIGON system =====/////
+// The surfacesprites are a simple system.  When a polygon with this shader stage on it is drawn,
+// there are randomly distributed images (defined by the shader stage) placed on the surface.
+// these are capable of doing effects, grass, or simple oriented sprites.  
+// They usually stick vertically off the surface, hence the term vertigons.
+
+// The vertigons are applied as part of the renderer backend.  That is, they access OpenGL calls directly.
+
+
+unsigned char randomindex, randominterval;
+const float randomchart[256] = {
+	0.6554f, 0.6909f, 0.4806f, 0.6218f, 0.5717f, 0.3896f, 0.0677f, 0.7356f, 
+	0.8333f, 0.1105f, 0.4445f, 0.8161f, 0.4689f, 0.0433f, 0.7152f, 0.0336f, 
+	0.0186f, 0.9140f, 0.1626f, 0.6553f, 0.8340f, 0.7094f, 0.2020f, 0.8087f, 
+	0.9119f, 0.8009f, 0.1339f, 0.8492f, 0.9173f, 0.5003f, 0.6012f, 0.6117f, 
+	0.5525f, 0.5787f, 0.1586f, 0.3293f, 0.9273f, 0.7791f, 0.8589f, 0.4985f, 
+	0.0883f, 0.8545f, 0.2634f, 0.4727f, 0.3624f, 0.1631f, 0.7825f, 0.0662f, 
+	0.6704f, 0.3510f, 0.7525f, 0.9486f, 0.4685f, 0.1535f, 0.1545f, 0.1121f, 
+	0.4724f, 0.8483f, 0.3833f, 0.1917f, 0.8207f, 0.3885f, 0.9702f, 0.9200f, 
+	0.8348f, 0.7501f, 0.6675f, 0.4994f, 0.0301f, 0.5225f, 0.8011f, 0.1696f, 
+	0.5351f, 0.2752f, 0.2962f, 0.7550f, 0.5762f, 0.7303f, 0.2835f, 0.4717f, 
+	0.1818f, 0.2739f, 0.6914f, 0.7748f, 0.7640f, 0.8355f, 0.7314f, 0.5288f, 
+	0.7340f, 0.6692f, 0.6813f, 0.2810f, 0.8057f, 0.0648f, 0.8749f, 0.9199f, 
+	0.1462f, 0.5237f, 0.3014f, 0.4994f, 0.0278f, 0.4268f, 0.7238f, 0.5107f, 
+	0.1378f, 0.7303f, 0.7200f, 0.3819f, 0.2034f, 0.7157f, 0.5552f, 0.4887f, 
+	0.0871f, 0.3293f, 0.2892f, 0.4545f, 0.0088f, 0.1404f, 0.0275f, 0.0238f, 
+	0.0515f, 0.4494f, 0.7206f, 0.2893f, 0.6060f, 0.5785f, 0.4182f, 0.5528f, 
+	0.9118f, 0.8742f, 0.3859f, 0.6030f, 0.3495f, 0.4550f, 0.9875f, 0.6900f, 
+	0.6416f, 0.2337f, 0.7431f, 0.9788f, 0.6181f, 0.2464f, 0.4661f, 0.7621f, 
+	0.7020f, 0.8203f, 0.8869f, 0.2145f, 0.7724f, 0.6093f, 0.6692f, 0.9686f, 
+	0.5609f, 0.0310f, 0.2248f, 0.2950f, 0.2365f, 0.1347f, 0.2342f, 0.1668f, 
+	0.3378f, 0.4330f, 0.2775f, 0.9901f, 0.7053f, 0.7266f, 0.4840f, 0.2820f, 
+	0.5733f, 0.4555f, 0.6049f, 0.0770f, 0.4760f, 0.6060f, 0.4159f, 0.3427f, 
+	0.1234f, 0.7062f, 0.8569f, 0.1878f, 0.9057f, 0.9399f, 0.8139f, 0.1407f, 
+	0.1794f, 0.9123f, 0.9493f, 0.2827f, 0.9934f, 0.0952f, 0.4879f, 0.5160f, 
+	0.4118f, 0.4873f, 0.3642f, 0.7470f, 0.0866f, 0.5172f, 0.6365f, 0.2676f, 
+	0.2407f, 0.7223f, 0.5761f, 0.1143f, 0.7137f, 0.2342f, 0.3353f, 0.6880f, 
+	0.2296f, 0.6023f, 0.6027f, 0.4138f, 0.5408f, 0.9859f, 0.1503f, 0.7238f, 
+	0.6054f, 0.2477f, 0.6804f, 0.1432f, 0.4540f, 0.9776f, 0.8762f, 0.7607f, 
+	0.9025f, 0.9807f, 0.0652f, 0.8661f, 0.7663f, 0.2586f, 0.3994f, 0.0335f, 
+	0.7328f, 0.0166f, 0.9589f, 0.4348f, 0.5493f, 0.7269f, 0.6867f, 0.6614f, 
+	0.6800f, 0.7804f, 0.5591f, 0.8381f, 0.0910f, 0.7573f, 0.8985f, 0.3083f, 
+	0.3188f, 0.8481f, 0.2356f, 0.6736f, 0.4770f, 0.4560f, 0.6266f, 0.4677f
+};
+
+#define WIND_DAMP_INTERVAL 50
+#define WIND_GUST_TIME 2500.0
+#define WIND_GUST_DECAY (1.0 / WIND_GUST_TIME)
+
+int		lastSSUpdateTime = 0;
+float	curWindSpeed=0;
+float	curWindGust=5;
+float	curWeatherAmount=1;
+vec3_t	curWindBlowVect={0,0,0}, targetWindBlowVect={0,0,0};
+vec3_t	curWindGrassDir={0,0,0}, targetWindGrassDir={0,0,0};
+int		totalsurfsprites=0, sssurfaces=0;
+
+qboolean curWindPointActive=qfalse;
+float curWindPointForce = 0;
+vec3_t curWindPoint;
+int nextGustTime=0;
+float gustLeft=0;
+
+qboolean standardfovinitialized=qfalse;
+float	standardfovx = 90, standardscalex = 1.0;
+float	rangescalefactor=1.0;
+
+vec3_t  ssrightvectors[4];
+vec3_t  ssfwdvector;
+int		rightvectorcount;
+
+trRefEntity_t *ssLastEntityDrawn=NULL;
+vec3_t	ssViewOrigin, ssViewRight, ssViewUp;
+
+
+static void R_SurfaceSpriteFrameUpdate(void)
+{
+	float dtime, dampfactor;	// Time since last update and damping time for wind changes
+	float ratio;
+	vec3_t ang, diff, retwindvec;
+	float targetspeed;
+	vec3_t up={0,0,1};
+
+	if (backEnd.refdef.time == lastSSUpdateTime)
+		return;
+
+	if (backEnd.refdef.time < lastSSUpdateTime)
+	{	// Time is BEFORE the last update time, so reset everything.
+		curWindGust = 5;
+		curWindSpeed = r_windSpeed->value;
+		nextGustTime = 0;
+		gustLeft = 0;
+		curWindGrassDir[0]=curWindGrassDir[1]=curWindGrassDir[2]=0.0f;
+	}
+
+	// Reset the last entity drawn, since this is a new frame.
+	ssLastEntityDrawn = NULL;
+
+	// Adjust for an FOV.  If things look twice as wide on the screen, pretend the shaders have twice the range.
+	// ASSUMPTION HERE IS THAT "standard" fov is the first one rendered.
+	
+	if (!standardfovinitialized)
+	{	// This isn't initialized yet.
+		if (backEnd.refdef.fov_x > 50 && backEnd.refdef.fov_x < 135)		// I don't consider anything below 50 or above 135 to be "normal".
+		{
+			standardfovx = backEnd.refdef.fov_x;
+			standardscalex = tan(standardfovx * 0.5 * (M_PI/180.0f));
+			standardfovinitialized = qtrue;
+		}
+		else
+		{
+			standardfovx = 90;
+			standardscalex = tan(standardfovx * 0.5 * (M_PI/180.0f));
+		}
+		rangescalefactor = 1.0;		// Don't multiply the shader range by anything.
+	}
+	else if (standardfovx == backEnd.refdef.fov_x)
+	{	// This is the standard FOV (or higher), don't multiply the shader range.
+		rangescalefactor = 1.0;
+	}
+	else
+	{	// We are using a non-standard FOV.  We need to multiply the range of the shader by a scale factor.
+		if (backEnd.refdef.fov_x > 135)
+		{
+			rangescalefactor = standardscalex / tan(135.0f * 0.5f * (M_PI/180.0f));
+		}
+		else
+		{
+			rangescalefactor = standardscalex / tan(backEnd.refdef.fov_x * 0.5 * (M_PI/180.0f));
+		}
+	}
+
+	// Create a set of four right vectors so that vertical sprites aren't always facing the same way.
+	// First generate a HORIZONTAL forward vector (important).
+	CrossProduct(ssViewRight, up, ssfwdvector);
+	
+	// Right Zero has a nudge forward (10 degrees).
+	VectorScale(ssViewRight, 0.985f, ssrightvectors[0]);
+	VectorMA(ssrightvectors[0], 0.174f, ssfwdvector, ssrightvectors[0]);
+
+	// Right One has a big nudge back (30 degrees).
+	VectorScale(ssViewRight, 0.866f, ssrightvectors[1]);
+	VectorMA(ssrightvectors[1], -0.5f, ssfwdvector, ssrightvectors[1]);
+
+
+	// Right two has a big nudge forward (30 degrees).
+	VectorScale(ssViewRight, 0.866f, ssrightvectors[2]);
+	VectorMA(ssrightvectors[2], 0.5f, ssfwdvector, ssrightvectors[2]);
+
+
+	// Right three has a nudge back (10 degrees).
+	VectorScale(ssViewRight, 0.985f, ssrightvectors[3]);
+	VectorMA(ssrightvectors[3], -0.174f, ssfwdvector, ssrightvectors[3]);
+
+
+	// Update the wind.
+	// If it is raining, get the windspeed from the rain system rather than the cvar
+	if (R_IsRaining() /*|| R_IsSnowing()*/ || R_IsPuffing() )
+	{
+		curWeatherAmount = 1.0;
+	}
+	else
+	{
+		curWeatherAmount = r_surfaceWeather->value;
+	}
+
+	if (R_GetWindSpeed(targetspeed, NULL))
+	{	// We successfully got a speed from the rain system.
+		// Set the windgust to 5, since that looks pretty good.
+		targetspeed *= 0.02f;
+		if (targetspeed >= 1.0)
+		{
+			curWindGust = 300/targetspeed;
+		}
+		else
+		{
+			curWindGust = 0;
+		}
+	}
+	else
+	{	// Use the cvar.
+		targetspeed = r_windSpeed->value;	// Minimum gust delay, in seconds.
+		curWindGust = r_windGust->value;
+	}
+	
+	if (targetspeed > 0 && curWindGust)
+	{
+		if (gustLeft > 0)
+		{	// We are gusting
+			// Add an amount to the target wind speed
+			targetspeed *= 1.0 + gustLeft;
+
+			gustLeft -= (float)(backEnd.refdef.time - lastSSUpdateTime)*WIND_GUST_DECAY;
+			if (gustLeft <= 0)
+			{
+				nextGustTime = backEnd.refdef.time + (curWindGust*1000)*Q_flrand(1.0f,4.0f);
+			}
+		}
+		else if (backEnd.refdef.time >= nextGustTime)
+		{	// See if there is another right now
+			// Gust next time, mano
+			gustLeft = Q_flrand(0.75f,1.5f);
+		}
+	}
+
+	// See if there is a weather system that will tell us a windspeed.
+	if (R_GetWindVector(retwindvec, NULL))
+	{
+		retwindvec[2]=0;
+		//VectorScale(retwindvec, -1.0f, retwindvec);
+		vectoangles(retwindvec, ang);
+	}
+	else
+	{	// Calculate the target wind vector based off cvars
+		ang[YAW] = r_windAngle->value;
+	}
+
+	ang[PITCH] = -90.0 + targetspeed;
+	if (ang[PITCH]>-45.0)
+	{
+		ang[PITCH] = -45.0;
+	}
+	ang[ROLL] = 0;
+
+	if (targetspeed>0)
+	{
+//		ang[YAW] += cos(tr.refdef.time*0.01+flrand(-1.0,1.0))*targetspeed*0.5;
+//		ang[PITCH] += sin(tr.refdef.time*0.01+flrand(-1.0,1.0))*targetspeed*0.5;
+	}
+	
+	// Get the grass wind vector first
+	AngleVectors(ang, targetWindGrassDir, NULL, NULL);
+	targetWindGrassDir[2]-=1.0;
+//		VectorScale(targetWindGrassDir, targetspeed, targetWindGrassDir);
+
+	// Now get the general wind vector (no pitch)
+	ang[PITCH]=0;
+	AngleVectors(ang, targetWindBlowVect, NULL, NULL);
+
+	// Start calculating a smoothing factor so wind doesn't change abruptly between speeds.
+	dampfactor = 1.0-r_windDampFactor->value;	// We must exponent the amount LEFT rather than the amount bled off
+	dtime = (float)(backEnd.refdef.time - lastSSUpdateTime) * (1.0/(float)WIND_DAMP_INTERVAL);	// Our dampfactor is geared towards a time interval equal to "1".
+
+	// Note that since there are a finite number of "practical" delta millisecond values possible, 
+	// the ratio should be initialized into a chart ultimately.
+	ratio = pow(dampfactor, dtime);
+
+	// Apply this ratio to the windspeed...
+	if (fabsf(targetspeed-curWindSpeed) > ratio)
+	{
+		curWindSpeed = targetspeed - (ratio * (targetspeed-curWindSpeed));
+	}
+
+
+	// Use the curWindSpeed to calculate the final target wind vector (with speed)
+	VectorScale(targetWindBlowVect, curWindSpeed, targetWindBlowVect);
+	VectorSubtract(targetWindBlowVect, curWindBlowVect, diff);
+	VectorMA(targetWindBlowVect, -ratio, diff, curWindBlowVect);
+
+	// Update the grass vector now
+	VectorSubtract(targetWindGrassDir, curWindGrassDir, diff);
+	VectorMA(targetWindGrassDir, -ratio, diff, curWindGrassDir);
+
+	lastSSUpdateTime = backEnd.refdef.time;
+
+	if (fabsf(r_windPointForce->value - curWindPointForce) > ratio)
+	{// Make sure not to get infinitly small number here
+		curWindPointForce = r_windPointForce->value - (ratio * (r_windPointForce->value - curWindPointForce));
+	}
+	assert(!_isnan(curWindPointForce));
+	if (curWindPointForce < 0.01)
+	{
+		curWindPointActive = qfalse;
+	}
+	else
+	{
+		curWindPointActive = qtrue;
+		curWindPoint[0] = r_windPointX->value;
+		curWindPoint[1] = r_windPointY->value;
+		curWindPoint[2] = 0;
+	}
+
+	if (r_surfaceSprites->integer >= 2)
+	{
+		Com_Printf("Surfacesprites Drawn: %d, on %d surfaces\n", totalsurfsprites, sssurfaces);
+	}
+
+	totalsurfsprites=0;
+	sssurfaces=0;
+}
+
+
+
+/////////////////////////////////////////////
+// Surface sprite calculation and drawing.
+/////////////////////////////////////////////
+
+#define FADE_RANGE			250.0
+#define WINDPOINT_RADIUS	750.0
+
+float SSVertAlpha[SHADER_MAX_VERTEXES];
+float SSVertWindForce[SHADER_MAX_VERTEXES];
+vec2_t SSVertWindDir[SHADER_MAX_VERTEXES];
+
+qboolean SSAdditiveTransparency=qfalse;
+qboolean SSUsingFog=qfalse;
+
+
+/////////////////////////////////////////////
+// Vertical surface sprites
+
+static void RB_VerticalSurfaceSprite(vec3_t loc, float width, float height, byte light, 
+										byte alpha, float wind, float windidle, vec2_t fog, int hangdown, vec2_t skew, bool flattened)
+{
+	vec3_t loc2, right;
+	float angle;
+	float windsway;
+	float points[16];
+	color4ub_t color;
+
+	angle = ((loc[0]+loc[1])*0.02+(tr.refdef.time*0.0015));
+
+	if (windidle>0.0)
+	{
+		windsway = (height*windidle*0.075);
+		loc2[0] = loc[0]+skew[0]+cos(angle)*windsway;
+		loc2[1] = loc[1]+skew[1]+sin(angle)*windsway;
+
+		if (hangdown)
+		{
+			loc2[2] = loc[2]-height;
+		}
+		else
+		{
+			loc2[2] = loc[2]+height;
+		}
+	}
+	else
+	{
+		loc2[0] = loc[0]+skew[0];
+		loc2[1] = loc[1]+skew[1];
+		if (hangdown)
+		{
+			loc2[2] = loc[2]-height;
+		}
+		else
+		{
+			loc2[2] = loc[2]+height;
+		}
+	}
+
+	if (wind>0.0 && curWindSpeed > 0.001)
+	{
+		windsway = (height*wind*0.075);
+
+		// Add the angle
+		VectorMA(loc2, height*wind, curWindGrassDir, loc2);
+		// Bob up and down
+		if (curWindSpeed < 40.0)
+		{
+			windsway *= curWindSpeed*(1.0/100.0);
+		}
+		else
+		{
+			windsway *= 0.4f;
+		}
+		loc2[2] += sin(angle*2.5)*windsway;
+	}
+
+	if ( flattened )
+	{
+		right[0] = sin( DEG2RAD( loc[0] ) ) * width; 
+		right[1] = cos( DEG2RAD( loc[0] ) ) * height;
+		right[2] = 0.0f;
+	}
+	else
+	{
+		VectorScale(ssrightvectors[rightvectorcount], width*0.5, right);
+	}
+
+	color[0]=light;
+	color[1]=light;
+	color[2]=light;
+	color[3]=alpha;
+
+	// Bottom right
+//	VectorAdd(loc, right, point);
+	points[0] = loc[0] + right[0];
+	points[1] = loc[1] + right[1];
+	points[2] = loc[2] + right[2];
+	points[3] = 0;
+
+	// Top right
+//	VectorAdd(loc2, right, point);
+	points[4] = loc2[0] + right[0];
+	points[5] = loc2[1] + right[1];
+	points[6] = loc2[2] + right[2];
+	points[7] = 0;
+
+	// Top left
+//	VectorSubtract(loc2, right, point);
+	points[8] = loc2[0] - right[0] + ssfwdvector[0] * width * 0.2;
+	points[9] = loc2[1] - right[1] + ssfwdvector[1] * width * 0.2;
+	points[10] = loc2[2] - right[2];
+	points[11] = 0;
+
+	// Bottom left
+//	VectorSubtract(loc, right, point);
+	points[12] = loc[0] - right[0];
+	points[13] = loc[1] - right[1];
+	points[14] = loc[2] - right[2];
+	points[15] = 0;
+
+	// Add the sprite to the render list.
+	SQuickSprite.Add(points, color, fog);
+}
+
+static void RB_VerticalSurfaceSpriteWindPoint(vec3_t loc, float width, float height, byte light, 
+												byte alpha, float wind, float windidle, vec2_t fog, 
+												int hangdown, vec2_t skew, vec2_t winddiff, float windforce, bool flattened)
+{
+	vec3_t loc2, right;
+	float angle;
+	float windsway;
+	float points[16];
+	color4ub_t color;
+
+	if (windforce > 1)
+		windforce = 1;
+
+//	wind += 1.0-windforce;
+
+	angle = (loc[0]+loc[1])*0.02+(tr.refdef.time*0.0015);
+
+	if (curWindSpeed <80.0)
+	{
+		windsway = (height*windidle*0.1)*(1.0+windforce);
+		loc2[0] = loc[0]+skew[0]+cos(angle)*windsway;
+		loc2[1] = loc[1]+skew[1]+sin(angle)*windsway;
+	}
+	else
+	{
+		loc2[0] = loc[0]+skew[0];
+		loc2[1] = loc[1]+skew[1];
+	}
+	if (hangdown)
+	{
+		loc2[2] = loc[2]-height;
+	}
+	else
+	{
+		loc2[2] = loc[2]+height;
+	}
+
+	if (curWindSpeed > 0.001)
+	{
+		// Add the angle
+		VectorMA(loc2, height*wind, curWindGrassDir, loc2);
+	}
+
+	loc2[0] += height*winddiff[0]*windforce;
+	loc2[1] += height*winddiff[1]*windforce;
+	loc2[2] -= height*windforce*(0.75 + 0.15*sin((tr.refdef.time + 500*windforce)*0.01));
+
+	if ( flattened )
+	{
+		right[0] = sin( DEG2RAD( loc[0] ) ) * width; 
+		right[1] = cos( DEG2RAD( loc[0] ) ) * height;
+		right[2] = 0.0f;
+	}
+	else
+	{
+		VectorScale(ssrightvectors[rightvectorcount], width*0.5, right);
+	}
+	
+
+	color[0]=light;
+	color[1]=light;
+	color[2]=light;
+	color[3]=alpha;
+
+	// Bottom right
+//	VectorAdd(loc, right, point);
+	points[0] = loc[0] + right[0];
+	points[1] = loc[1] + right[1];
+	points[2] = loc[2] + right[2];
+	points[3] = 0;
+
+	// Top right
+//	VectorAdd(loc2, right, point);
+	points[4] = loc2[0] + right[0];
+	points[5] = loc2[1] + right[1];
+	points[6] = loc2[2] + right[2];
+	points[7] = 0;
+
+	// Top left
+//	VectorSubtract(loc2, right, point);
+	points[8] = loc2[0] - right[0] + ssfwdvector[0] * width * 0.15;
+	points[9] = loc2[1] - right[1] + ssfwdvector[1] * width * 0.15;
+	points[10] = loc2[2] - right[2];
+	points[11] = 0;
+
+	// Bottom left
+//	VectorSubtract(loc, right, point);
+	points[12] = loc[0] - right[0];
+	points[13] = loc[1] - right[1];
+	points[14] = loc[2] - right[2];
+	points[15] = 0;
+
+	// Add the sprite to the render list.
+	SQuickSprite.Add(points, color, fog);
+}
+
+static void RB_DrawVerticalSurfaceSprites( shaderStage_t *stage, shaderCommands_t *input) 
+{
+	int curindex, curvert;
+ 	vec3_t dist;
+	float triarea;
+	vec2_t vec1to2, vec1to3;
+
+	vec3_t v1,v2,v3;
+	float a1,a2,a3;
+	float l1,l2,l3;
+	vec2_t fog1, fog2, fog3;
+	vec2_t winddiff1, winddiff2, winddiff3;
+	float  windforce1, windforce2, windforce3;
+
+	float posi, posj;
+	float step;
+	float fa,fb,fc;
+
+	vec3_t curpoint;
+	float width, height;
+	float alpha, alphapos, thisspritesfadestart, light;
+
+	byte randomindex2;
+
+	vec2_t skew={0,0};
+	vec2_t fogv;
+	vec2_t winddiffv;
+	float windforce=0;
+	qboolean usewindpoint = (qboolean) !! (curWindPointActive && stage->ss->wind > 0);
+
+	float cutdist=stage->ss->fadeMax*rangescalefactor, cutdist2=cutdist*cutdist;
+	float fadedist=stage->ss->fadeDist*rangescalefactor, fadedist2=fadedist*fadedist;
+
+	assert(cutdist2 != fadedist2);
+	float inv_fadediff = 1.0/(cutdist2-fadedist2);
+
+	// The faderange is the fraction amount it takes for these sprites to fade out, assuming an ideal fade range of 250
+	float faderange = FADE_RANGE/(cutdist-fadedist);
+
+	if (faderange > 1.0)
+	{	// Don't want to force a new fade_rand
+		faderange = 1.0;
+	}
+
+	// Quickly calc all the alphas and windstuff for each vertex
+	for (curvert=0; curvert<input->numVertexes; curvert++)
+	{
+		VectorSubtract(ssViewOrigin, input->xyz[curvert], dist);
+		SSVertAlpha[curvert] = 1.0 - (VectorLengthSquared(dist) - fadedist2) * inv_fadediff;
+	}
+
+	// Wind only needs initialization once per tess.
+	if (usewindpoint && !tess.SSInitializedWind)
+	{
+		for (curvert=0; curvert<input->numVertexes;curvert++)
+		{	// Calc wind at each point
+			dist[0]=input->xyz[curvert][0] - curWindPoint[0];
+			dist[1]=input->xyz[curvert][1] - curWindPoint[1];
+			step = (dist[0]*dist[0] + dist[1]*dist[1]);	// dist squared
+
+			if (step >= (float)(WINDPOINT_RADIUS*WINDPOINT_RADIUS))
+			{	// No wind
+				SSVertWindDir[curvert][0] = 0;
+				SSVertWindDir[curvert][1] = 0;
+				SSVertWindForce[curvert]=0;		// Should be < 1
+			}
+			else
+			{
+				if (step<1)
+				{	// Don't want to divide by zero
+					SSVertWindDir[curvert][0] = 0;
+					SSVertWindDir[curvert][1] = 0;
+					SSVertWindForce[curvert] = curWindPointForce * stage->ss->wind;
+				}
+				else
+				{
+					step = Q_rsqrt(step);		// Equals 1 over the distance.
+					SSVertWindDir[curvert][0] = dist[0] * step;
+					SSVertWindDir[curvert][1] = dist[1] * step;
+					step = 1.0 - (1.0 / (step * WINDPOINT_RADIUS));	// 1- (dist/maxradius) = a scale from 0 to 1 linearly dropping off
+					SSVertWindForce[curvert] = curWindPointForce * stage->ss->wind * step;	// *step means divide by the distance.
+				}
+			}
+		}
+		tess.SSInitializedWind = qtrue;
+	}
+	
+	for (curindex=0; curindex<input->numIndexes-2; curindex+=3)
+	{
+		curvert = input->indexes[curindex];
+		VectorCopy(input->xyz[curvert], v1);
+		if (stage->ss->facing)
+		{	// Hang down
+			if (input->normal[curvert][2] > -0.5)
+			{
+				continue;
+			}
+		}
+		else
+		{	// Point up
+			if (input->normal[curvert][2] < 0.5)
+			{
+				continue;
+			}
+		}
+		l1 = input->vertexColors[curvert][2];
+		a1 = SSVertAlpha[curvert];
+		fog1[0] = *((float *)(tess.svars.texcoords[0])+(curvert<<1));
+		fog1[1] = *((float *)(tess.svars.texcoords[0])+(curvert<<1)+1);
+		winddiff1[0] = SSVertWindDir[curvert][0];
+		winddiff1[1] = SSVertWindDir[curvert][1];
+		windforce1 = SSVertWindForce[curvert];
+
+		curvert = input->indexes[curindex+1];
+		VectorCopy(input->xyz[curvert], v2);
+		if (stage->ss->facing)
+		{	// Hang down
+			if (input->normal[curvert][2] > -0.5)
+			{
+				continue;
+			}
+		}
+		else
+		{	// Point up
+			if (input->normal[curvert][2] < 0.5)
+			{
+				continue;
+			}
+		}
+		l2 = input->vertexColors[curvert][2];
+		a2 = SSVertAlpha[curvert];
+		fog2[0] = *((float *)(tess.svars.texcoords[0])+(curvert<<1));
+		fog2[1] = *((float *)(tess.svars.texcoords[0])+(curvert<<1)+1);
+		winddiff2[0] = SSVertWindDir[curvert][0];
+		winddiff2[1] = SSVertWindDir[curvert][1];
+		windforce2 = SSVertWindForce[curvert];
+
+		curvert = input->indexes[curindex+2];
+		VectorCopy(input->xyz[curvert], v3);
+		if (stage->ss->facing)
+		{	// Hang down
+			if (input->normal[curvert][2] > -0.5)
+			{
+				continue;
+			}
+		}
+		else
+		{	// Point up
+			if (input->normal[curvert][2] < 0.5)
+			{
+				continue;
+			}
+		}
+		l3 = input->vertexColors[curvert][2];
+		a3 = SSVertAlpha[curvert];
+		fog3[0] = *((float *)(tess.svars.texcoords[0])+(curvert<<1));
+		fog3[1] = *((float *)(tess.svars.texcoords[0])+(curvert<<1)+1);
+		winddiff3[0] = SSVertWindDir[curvert][0];
+		winddiff3[1] = SSVertWindDir[curvert][1];
+		windforce3 = SSVertWindForce[curvert];
+
+		if (a1 <= 0.0 && a2 <= 0.0 && a3 <= 0.0)
+		{
+			continue;
+		}
+
+		// Find the area in order to calculate the stepsize
+		vec1to2[0] = v2[0] - v1[0];
+		vec1to2[1] = v2[1] - v1[1];
+		vec1to3[0] = v3[0] - v1[0];
+		vec1to3[1] = v3[1] - v1[1];
+
+		// Now get the cross product of this sum.
+		triarea = vec1to3[0]*vec1to2[1] - vec1to3[1]*vec1to2[0];
+		triarea=fabs(triarea);
+		if (triarea <= 1.0)
+		{	// Insanely small abhorrent triangle.
+			continue;
+		}
+		step = stage->ss->density * Q_rsqrt(triarea);
+
+		randomindex = (byte)(v1[0]+v1[1]+v2[0]+v2[1]+v3[0]+v3[1]);
+		randominterval = (byte)(v1[0]+v2[1]+v3[2])|0x03;	// Make sure the interval is at least 3, and always odd
+		rightvectorcount = 0;
+
+		for (posi=0; posi<1.0; posi+=step)
+		{
+			for (posj=0; posj<(1.0-posi); posj+=step)
+			{
+				fa=posi+randomchart[randomindex]*step;
+				randomindex += randominterval;
+
+				fb=posj+randomchart[randomindex]*step;
+				randomindex += randominterval;
+
+				rightvectorcount=(rightvectorcount+1)&3;
+
+				if (fa>1.0)
+					continue;
+
+				if (fb>(1.0-fa))
+					continue;
+
+				fc = 1.0-fa-fb;
+
+				// total alpha, minus random factor so some things fade out sooner.
+				alphapos = a1*fa + a2*fb + a3*fc;
+				
+				// Note that the alpha at this point is a value from 1.0 to 0.0, but represents when to START fading
+				thisspritesfadestart = faderange + (1.0-faderange) * randomchart[randomindex];
+				randomindex += randominterval;
+
+				// Find where the alpha is relative to the fadestart, and calc the real alpha to draw at.
+				alpha = 1.0 - ((thisspritesfadestart-alphapos)/faderange);
+				if (alpha > 0.0)
+				{
+					if (alpha > 1.0) 
+						alpha=1.0;
+
+					if (SSUsingFog)
+					{
+						fogv[0] = fog1[0]*fa + fog2[0]*fb + fog3[0]*fc;
+						fogv[1] = fog1[1]*fa + fog2[1]*fb + fog3[1]*fc;
+					}
+
+					if (usewindpoint)
+					{
+						winddiffv[0] = winddiff1[0]*fa + winddiff2[0]*fb + winddiff3[0]*fc;
+						winddiffv[1] = winddiff1[1]*fa + winddiff2[1]*fb + winddiff3[1]*fc;
+						windforce = windforce1*fa + windforce2*fb + windforce3*fc;
+					}
+			
+					VectorScale(v1, fa, curpoint);
+					VectorMA(curpoint, fb, v2, curpoint);
+					VectorMA(curpoint, fc, v3, curpoint);
+
+					light = l1*fa + l2*fb + l3*fc;
+					if (SSAdditiveTransparency)
+					{	// Additive transparency, scale light value
+//						light *= alpha;
+						light = (128 + (light*0.5))*alpha;
+						alpha = 1.0;
+					}
+
+					randomindex2 = randomindex;
+					width = stage->ss->width*(1.0 + (stage->ss->variance[0]*randomchart[randomindex2]));
+					height = stage->ss->height*(1.0 + (stage->ss->variance[1]*randomchart[randomindex2++]));
+					if (randomchart[randomindex2++]>0.5)
+					{
+						width = -width;
+					}
+					if (stage->ss->fadeScale!=0 && alphapos < 1.0)
+					{
+						width *= 1.0 + (stage->ss->fadeScale*(1.0-alphapos));
+					}
+
+					if (stage->ss->vertSkew != 0)
+					{	// flrand(-vertskew, vertskew)
+						skew[0] = height * ((stage->ss->vertSkew*2.0f*randomchart[randomindex2++])-stage->ss->vertSkew);
+						skew[1] = height * ((stage->ss->vertSkew*2.0f*randomchart[randomindex2++])-stage->ss->vertSkew);
+					}
+
+					if (usewindpoint && windforce > 0 && stage->ss->wind > 0.0)
+					{
+						if (SSUsingFog)
+						{
+							RB_VerticalSurfaceSpriteWindPoint(curpoint, width, height, (byte)light, (byte)(alpha*255.0), 
+										stage->ss->wind, stage->ss->windIdle, fogv, stage->ss->facing, skew,
+										winddiffv, windforce, SURFSPRITE_FLATTENED == stage->ss->surfaceSpriteType);
+						}
+						else
+						{
+							RB_VerticalSurfaceSpriteWindPoint(curpoint, width, height, (byte)light, (byte)(alpha*255.0), 
+										stage->ss->wind, stage->ss->windIdle, NULL, stage->ss->facing, skew, 
+										winddiffv, windforce, SURFSPRITE_FLATTENED == stage->ss->surfaceSpriteType);
+						}
+					}
+					else
+					{
+						if (SSUsingFog)
+						{
+							RB_VerticalSurfaceSprite(curpoint, width, height, (byte)light, (byte)(alpha*255.0), 
+										stage->ss->wind, stage->ss->windIdle, fogv, stage->ss->facing, skew, SURFSPRITE_FLATTENED == stage->ss->surfaceSpriteType);
+						}
+						else
+						{
+							RB_VerticalSurfaceSprite(curpoint, width, height, (byte)light, (byte)(alpha*255.0), 
+										stage->ss->wind, stage->ss->windIdle, NULL, stage->ss->facing, skew, SURFSPRITE_FLATTENED == stage->ss->surfaceSpriteType);
+						}
+					}
+
+					totalsurfsprites++;
+				}
+			}
+		}
+	}
+}
+
+
+/////////////////////////////////////////////
+// Oriented surface sprites
+
+static void RB_OrientedSurfaceSprite(vec3_t loc, float width, float height, byte light, byte alpha, vec2_t fog, int faceup)
+{
+	vec3_t loc2, right;
+	float points[16];
+	color4ub_t color;
+
+	color[0]=light;
+	color[1]=light;
+	color[2]=light;
+	color[3]=alpha;
+
+	if (faceup)
+	{
+		width *= 0.5;
+		height *= 0.5;
+
+		// Bottom right
+	//	VectorAdd(loc, right, point);
+		points[0] = loc[0] + width;
+		points[1] = loc[1] - width;
+		points[2] = loc[2] + 1.0;
+		points[3] = 0;
+
+		// Top right
+	//	VectorAdd(loc, right, point);
+		points[4] = loc[0] + width;
+		points[5] = loc[1] + width;
+		points[6] = loc[2] + 1.0;
+		points[7] = 0;
+
+		// Top left
+	//	VectorSubtract(loc, right, point);
+		points[8] = loc[0] - width;
+		points[9] = loc[1] + width;
+		points[10] = loc[2] + 1.0;
+		points[11] = 0;
+
+		// Bottom left
+	//	VectorSubtract(loc, right, point);
+		points[12] = loc[0] - width;
+		points[13] = loc[1] - width;
+		points[14] = loc[2] + 1.0;
+		points[15] = 0;
+	}
+	else
+	{
+		VectorMA(loc, height, ssViewUp, loc2);
+		VectorScale(ssViewRight, width*0.5, right);
+
+		// Bottom right
+	//	VectorAdd(loc, right, point);
+		points[0] = loc[0] + right[0];
+		points[1] = loc[1] + right[1];
+		points[2] = loc[2] + right[2];
+		points[3] = 0;
+
+		// Top right
+	//	VectorAdd(loc2, right, point);
+		points[4] = loc2[0] + right[0];
+		points[5] = loc2[1] + right[1];
+		points[6] = loc2[2] + right[2];
+		points[7] = 0;
+
+		// Top left
+	//	VectorSubtract(loc2, right, point);
+		points[8] = loc2[0] - right[0];
+		points[9] = loc2[1] - right[1];
+		points[10] = loc2[2] - right[2];
+		points[11] = 0;
+
+		// Bottom left
+	//	VectorSubtract(loc, right, point);
+		points[12] = loc[0] - right[0];
+		points[13] = loc[1] - right[1];
+		points[14] = loc[2] - right[2];
+		points[15] = 0;
+	}
+
+	// Add the sprite to the render list.
+	SQuickSprite.Add(points, color, fog);
+}
+
+static void RB_DrawOrientedSurfaceSprites( shaderStage_t *stage, shaderCommands_t *input) 
+{
+	int curindex, curvert;
+ 	vec3_t dist;
+	float triarea, minnormal;
+	vec2_t vec1to2, vec1to3;
+
+	vec3_t v1,v2,v3;
+	float a1,a2,a3;
+	float l1,l2,l3;
+	vec2_t fog1, fog2, fog3;
+
+	float posi, posj;
+	float step;
+	float fa,fb,fc;
+
+	vec3_t curpoint;
+	float width, height;
+	float alpha, alphapos, thisspritesfadestart, light;
+	byte randomindex2;
+	vec2_t fogv;
+	
+	float cutdist=stage->ss->fadeMax*rangescalefactor, cutdist2=cutdist*cutdist;
+	float fadedist=stage->ss->fadeDist*rangescalefactor, fadedist2=fadedist*fadedist;
+
+	assert(cutdist2 != fadedist2);
+	float inv_fadediff = 1.0/(cutdist2-fadedist2);
+
+	// The faderange is the fraction amount it takes for these sprites to fade out, assuming an ideal fade range of 250
+	float faderange = FADE_RANGE/(cutdist-fadedist);
+
+	if (faderange > 1.0)
+	{	// Don't want to force a new fade_rand
+		faderange = 1.0;
+	}
+
+	if (stage->ss->facing)
+	{	// Faceup sprite.
+		minnormal = 0.99f;
+	}
+	else
+	{	// Normal oriented sprite
+		minnormal = 0.5f;
+	}
+
+	// Quickly calc all the alphas for each vertex
+	for (curvert=0; curvert<input->numVertexes; curvert++)
+	{
+		// Calc alpha at each point
+		VectorSubtract(ssViewOrigin, input->xyz[curvert], dist);
+		SSVertAlpha[curvert] = 1.0 - (VectorLengthSquared(dist) - fadedist2) * inv_fadediff;
+	}
+
+	for (curindex=0; curindex<input->numIndexes-2; curindex+=3)
+	{
+		curvert = input->indexes[curindex];
+		VectorCopy(input->xyz[curvert], v1);
+		if (input->normal[curvert][2] < minnormal)
+		{
+			continue;
+		}
+		l1 = input->vertexColors[curvert][2];
+		a1 = SSVertAlpha[curvert];
+		fog1[0] = *((float *)(tess.svars.texcoords[0])+(curvert<<1));
+		fog1[1] = *((float *)(tess.svars.texcoords[0])+(curvert<<1)+1);
+
+		curvert = input->indexes[curindex+1];
+		VectorCopy(input->xyz[curvert], v2);
+		if (input->normal[curvert][2] < minnormal)
+		{
+			continue;
+		}
+		l2 = input->vertexColors[curvert][2];
+		a2 = SSVertAlpha[curvert];
+		fog2[0] = *((float *)(tess.svars.texcoords[0])+(curvert<<1));
+		fog2[1] = *((float *)(tess.svars.texcoords[0])+(curvert<<1)+1);
+
+		curvert = input->indexes[curindex+2];
+		VectorCopy(input->xyz[curvert], v3);
+		if (input->normal[curvert][2] < minnormal)
+		{
+			continue;
+		}
+		l3 = input->vertexColors[curvert][2];
+		a3 = SSVertAlpha[curvert];
+		fog3[0] = *((float *)(tess.svars.texcoords[0])+(curvert<<1));
+		fog3[1] = *((float *)(tess.svars.texcoords[0])+(curvert<<1)+1);
+
+		if (a1 <= 0.0 && a2 <= 0.0 && a3 <= 0.0)
+		{
+			continue;
+		}
+
+		// Find the area in order to calculate the stepsize
+		vec1to2[0] = v2[0] - v1[0];
+		vec1to2[1] = v2[1] - v1[1];
+		vec1to3[0] = v3[0] - v1[0];
+		vec1to3[1] = v3[1] - v1[1];
+
+		// Now get the cross product of this sum.
+		triarea = vec1to3[0]*vec1to2[1] - vec1to3[1]*vec1to2[0];
+		triarea=fabs(triarea);
+		if (triarea <= 1.0)
+		{	// Insanely small abhorrent triangle.
+			continue;
+		}
+		step = stage->ss->density * Q_rsqrt(triarea);
+
+		randomindex = (byte)(v1[0]+v1[1]+v2[0]+v2[1]+v3[0]+v3[1]);
+		randominterval = (byte)(v1[0]+v2[1]+v3[2])|0x03;	// Make sure the interval is at least 3, and always odd
+
+		for (posi=0; posi<1.0; posi+=step)
+		{
+			for (posj=0; posj<(1.0-posi); posj+=step)
+			{
+				fa=posi+randomchart[randomindex]*step;
+				randomindex += randominterval;
+				if (fa>1.0)
+					continue;
+
+				fb=posj+randomchart[randomindex]*step;
+				randomindex += randominterval;
+				if (fb>(1.0-fa))
+					continue;
+
+				fc = 1.0-fa-fb;
+
+				// total alpha, minus random factor so some things fade out sooner.
+				alphapos = a1*fa + a2*fb + a3*fc;
+				
+				// Note that the alpha at this point is a value from 1.0 to 0.0, but represents when to START fading
+				thisspritesfadestart = faderange + (1.0-faderange) * randomchart[randomindex];
+				randomindex += randominterval;
+
+				// Find where the alpha is relative to the fadestart, and calc the real alpha to draw at.
+				alpha = 1.0 - ((thisspritesfadestart-alphapos)/faderange);
+
+				randomindex += randominterval;
+				if (alpha > 0.0)
+				{
+					if (alpha > 1.0) 
+						alpha=1.0;
+
+					if (SSUsingFog)
+					{
+						fogv[0] = fog1[0]*fa + fog2[0]*fb + fog3[0]*fc;
+						fogv[1] = fog1[1]*fa + fog2[1]*fb + fog3[1]*fc;
+					}
+
+					VectorScale(v1, fa, curpoint);
+					VectorMA(curpoint, fb, v2, curpoint);
+					VectorMA(curpoint, fc, v3, curpoint);
+
+					light = l1*fa + l2*fb + l3*fc;
+					if (SSAdditiveTransparency)
+					{	// Additive transparency, scale light value
+//						light *= alpha;
+						light = (128 + (light*0.5))*alpha;
+						alpha = 1.0;
+					}
+
+					randomindex2 = randomindex;
+					width = stage->ss->width*(1.0 + (stage->ss->variance[0]*randomchart[randomindex2]));
+					height = stage->ss->height*(1.0 + (stage->ss->variance[1]*randomchart[randomindex2++]));
+					if (randomchart[randomindex2++]>0.5)
+					{
+						width = -width;
+					}
+					if (stage->ss->fadeScale!=0 && alphapos < 1.0)
+					{
+						width *= 1.0 + (stage->ss->fadeScale*(1.0-alphapos));
+					}
+
+					if (SSUsingFog)
+					{
+						RB_OrientedSurfaceSprite(curpoint, width, height, (byte)light, (byte)(alpha*255.0), fogv, stage->ss->facing);
+					}
+					else
+					{
+						RB_OrientedSurfaceSprite(curpoint, width, height, (byte)light, (byte)(alpha*255.0), NULL, stage->ss->facing);
+					}
+
+					totalsurfsprites++;
+				}
+			}
+		}
+	}
+}
+
+
+/////////////////////////////////////////////
+// Effect surface sprites
+
+static void RB_EffectSurfaceSprite(vec3_t loc, float width, float height, byte light, byte alpha, float life, int faceup)
+{
+	vec3_t loc2, right;
+	float points[16];
+	color4ub_t color;
+
+	color[0]=light;	//light;
+	color[1]=light;	//light;
+	color[2]=light;	//light;
+	color[3]=alpha;	//alpha;
+
+	if (faceup)
+	{
+		width *= 0.5;
+		height *= 0.5;
+
+		// Bottom right
+	//	VectorAdd(loc, right, point);
+		points[0] = loc[0] + width;
+		points[1] = loc[1] - width;
+		points[2] = loc[2] + 1.0;
+		points[3] = 0;
+
+		// Top right
+	//	VectorAdd(loc, right, point);
+		points[4] = loc[0] + width;
+		points[5] = loc[1] + width;
+		points[6] = loc[2] + 1.0;
+		points[7] = 0;
+
+		// Top left
+	//	VectorSubtract(loc, right, point);
+		points[8] = loc[0] - width;
+		points[9] = loc[1] + width;
+		points[10] = loc[2] + 1.0;
+		points[11] = 0;
+
+		// Bottom left
+	//	VectorSubtract(loc, right, point);
+		points[12] = loc[0] - width;
+		points[13] = loc[1] - width;
+		points[14] = loc[2] + 1.0;
+		points[15] = 0;
+	}
+	else
+	{
+		VectorMA(loc, height, ssViewUp, loc2);
+		VectorScale(ssViewRight, width*0.5, right);
+
+		// Bottom right
+	//	VectorAdd(loc, right, point);
+		points[0] = loc[0] + right[0];
+		points[1] = loc[1] + right[1];
+		points[2] = loc[2] + right[2];
+		points[3] = 0;
+
+		// Top right
+	//	VectorAdd(loc2, right, point);
+		points[4] = loc2[0] + right[0];
+		points[5] = loc2[1] + right[1];
+		points[6] = loc2[2] + right[2];
+		points[7] = 0;
+
+		// Top left
+	//	VectorSubtract(loc2, right, point);
+		points[8] = loc2[0] - right[0];
+		points[9] = loc2[1] - right[1];
+		points[10] = loc2[2] - right[2];
+		points[11] = 0;
+
+		// Bottom left
+	//	VectorSubtract(loc, right, point);
+		points[12] = loc[0] - right[0];
+		points[13] = loc[1] - right[1];
+		points[14] = loc[2] - right[2];
+		points[15] = 0;
+	}
+
+	// Add the sprite to the render list.
+	SQuickSprite.Add(points, color, NULL);
+}
+
+static void RB_DrawEffectSurfaceSprites( shaderStage_t *stage, shaderCommands_t *input) 
+{
+	int curindex, curvert;
+ 	vec3_t dist;
+	float triarea, minnormal;
+	vec2_t vec1to2, vec1to3;
+
+	vec3_t v1,v2,v3;
+	float a1,a2,a3;
+	float l1,l2,l3;
+
+	float posi, posj;
+	float step;
+	float fa,fb,fc;
+	float effecttime, effectpos;
+	float density;
+
+	vec3_t curpoint;
+	float width, height;
+	float alpha, alphapos, thisspritesfadestart, light;
+	byte randomindex2;
+	
+	float cutdist=stage->ss->fadeMax*rangescalefactor, cutdist2=cutdist*cutdist;
+	float fadedist=stage->ss->fadeDist*rangescalefactor, fadedist2=fadedist*fadedist;
+
+	float fxalpha = stage->ss->fxAlphaEnd - stage->ss->fxAlphaStart;
+	qboolean fadeinout=qfalse;
+	
+	assert(cutdist2 != fadedist2);
+	float inv_fadediff = 1.0/(cutdist2-fadedist2);
+
+	// The faderange is the fraction amount it takes for these sprites to fade out, assuming an ideal fade range of 250
+	float faderange = FADE_RANGE/(cutdist-fadedist);
+	if (faderange > 1.0f)
+	{	// Don't want to force a new fade_rand
+		faderange = 1.0f;
+	}
+
+	if (stage->ss->facing)
+	{	// Faceup sprite.
+		minnormal = 0.99f;
+	}
+	else
+	{	// Normal oriented sprite
+		minnormal = 0.5f;
+	}
+
+	// Make the object fade in.
+	if (stage->ss->fxAlphaEnd < 0.05 && stage->ss->height >= 0.1 && stage->ss->width >= 0.1)
+	{	// The sprite fades out, and it doesn't start at a pinpoint.  Let's fade it in.
+		fadeinout=qtrue;
+	}
+
+	if (stage->ss->surfaceSpriteType == SURFSPRITE_WEATHERFX)
+	{	// This effect is affected by weather settings.
+		if (curWeatherAmount < 0.01)
+		{	// Don't show these effects
+			return;
+		}
+		else
+		{
+			density = stage->ss->density / curWeatherAmount;
+		}
+	}
+	else
+	{
+		density = stage->ss->density;
+	}
+
+	// Quickly calc all the alphas for each vertex
+	for (curvert=0; curvert<input->numVertexes; curvert++)
+	{
+		// Calc alpha at each point
+		VectorSubtract(ssViewOrigin, input->xyz[curvert], dist);
+		SSVertAlpha[curvert] = 1.0f - (VectorLengthSquared(dist) - fadedist2) * inv_fadediff;
+
+	// Note this is the proper equation, but isn't used right now because it would be just a tad slower.
+		// Formula for alpha is 1.0f - ((len-fade)/(cut-fade))
+		// Which is equal to (1.0+fade/(cut-fade)) - (len/(cut-fade))
+		// So mult=1/(cut-fade), and base=(1+fade*mult).
+	//	SSVertAlpha[curvert] = fadebase - (VectorLength(dist) * fademult);
+
+	}
+
+	for (curindex=0; curindex<input->numIndexes-2; curindex+=3)
+	{
+		curvert = input->indexes[curindex];
+		VectorCopy(input->xyz[curvert], v1);
+		if (input->normal[curvert][2] < minnormal)
+		{
+			continue;
+		}
+		l1 = input->vertexColors[curvert][2];
+		a1 = SSVertAlpha[curvert];
+
+		curvert = input->indexes[curindex+1];
+		VectorCopy(input->xyz[curvert], v2);
+		if (input->normal[curvert][2] < minnormal)
+		{
+			continue;
+		}
+		l2 = input->vertexColors[curvert][2];
+		a2 = SSVertAlpha[curvert];
+
+		curvert = input->indexes[curindex+2];
+		VectorCopy(input->xyz[curvert], v3);
+		if (input->normal[curvert][2] < minnormal)
+		{
+			continue;
+		}
+		l3 = input->vertexColors[curvert][2];
+		a3 = SSVertAlpha[curvert];
+
+		if (a1 <= 0.0f && a2 <= 0.0f && a3 <= 0.0f)
+		{
+			continue;
+		}
+
+		// Find the area in order to calculate the stepsize
+		vec1to2[0] = v2[0] - v1[0];
+		vec1to2[1] = v2[1] - v1[1];
+		vec1to3[0] = v3[0] - v1[0];
+		vec1to3[1] = v3[1] - v1[1];
+
+		// Now get the cross product of this sum.
+		triarea = vec1to3[0]*vec1to2[1] - vec1to3[1]*vec1to2[0];
+		triarea=fabs(triarea);
+		if (triarea <= 1.0f)
+		{	// Insanely small abhorrent triangle.
+			continue;
+		}
+		step = density * Q_rsqrt(triarea);
+
+		randomindex = (byte)(v1[0]+v1[1]+v2[0]+v2[1]+v3[0]+v3[1]);
+		randominterval = (byte)(v1[0]+v2[1]+v3[2])|0x03;	// Make sure the interval is at least 3, and always odd
+
+		for (posi=0; posi<1.0f; posi+=step)
+		{
+			for (posj=0; posj<(1.0-posi); posj+=step)
+			{
+				effecttime = (tr.refdef.time+10000.0*randomchart[randomindex])/stage->ss->fxDuration;
+				effectpos = (float)effecttime - (int)effecttime;
+
+				randomindex2 = randomindex+effecttime;
+				randomindex += randominterval;
+				fa=posi+randomchart[randomindex2++]*step;
+				if (fa>1.0f)
+					continue;
+
+				fb=posj+randomchart[randomindex2++]*step;
+				if (fb>(1.0-fa))
+					continue;
+
+				fc = 1.0-fa-fb;
+
+				// total alpha, minus random factor so some things fade out sooner.
+				alphapos = a1*fa + a2*fb + a3*fc;
+				
+				// Note that the alpha at this point is a value from 1.0f to 0.0, but represents when to START fading
+				thisspritesfadestart = faderange + (1.0-faderange) * randomchart[randomindex2];
+				randomindex2 += randominterval;
+
+				// Find where the alpha is relative to the fadestart, and calc the real alpha to draw at.
+				alpha = 1.0f - ((thisspritesfadestart-alphapos)/faderange);
+				if (alpha > 0.0f)
+				{
+					if (alpha > 1.0f) 
+						alpha=1.0f;
+
+					VectorScale(v1, fa, curpoint);
+					VectorMA(curpoint, fb, v2, curpoint);
+					VectorMA(curpoint, fc, v3, curpoint);
+
+					light = l1*fa + l2*fb + l3*fc;
+					randomindex2 = randomindex;
+					width = stage->ss->width*(1.0f + (stage->ss->variance[0]*randomchart[randomindex2]));
+					height = stage->ss->height*(1.0f + (stage->ss->variance[1]*randomchart[randomindex2++]));
+
+					width = width + (effectpos*stage->ss->fxGrow[0]*width);
+					height = height + (effectpos*stage->ss->fxGrow[1]*height);
+
+					// If we want to fade in and out, that's different than a straight fade.
+					if (fadeinout)
+					{
+						if (effectpos > 0.5)
+						{	// Fade out
+							alpha = alpha*(stage->ss->fxAlphaStart+(fxalpha*(effectpos-0.5)*2.0));
+						}
+						else
+						{	// Fade in
+							alpha = alpha*(stage->ss->fxAlphaStart+(fxalpha*(0.5-effectpos)*2.0));
+						}
+					}
+					else
+					{	// Normal fade
+						alpha = alpha*(stage->ss->fxAlphaStart+(fxalpha*effectpos));
+					}
+
+					if (SSAdditiveTransparency)
+					{	// Additive transparency, scale light value
+//						light *= alpha;
+						light = (128 + (light*0.5))*alpha;
+						alpha = 1.0;
+					}
+
+					if (randomchart[randomindex2]>0.5f)
+					{
+						width = -width;
+					}
+					if (stage->ss->fadeScale!=0 && alphapos < 1.0f)
+					{
+						width *= 1.0f + (stage->ss->fadeScale*(1.0-alphapos));
+					}
+
+					if (stage->ss->wind>0.0f && curWindSpeed > 0.001)
+					{
+						vec3_t drawpoint;
+
+						VectorMA(curpoint, effectpos*stage->ss->wind, curWindBlowVect, drawpoint);
+						RB_EffectSurfaceSprite(drawpoint, width, height, (byte)light, (byte)(alpha*255.0f), stage->ss->fxDuration, stage->ss->facing);
+					}
+					else
+					{
+						RB_EffectSurfaceSprite(curpoint, width, height, (byte)light, (byte)(alpha*255.0f), stage->ss->fxDuration, stage->ss->facing);
+					}
+
+					totalsurfsprites++;
+				}
+			}
+		}
+	}
+}
+
+extern void R_WorldToLocal (vec3_t world, vec3_t localVec) ;
+extern float preTransEntMatrix[16], invEntMatrix[16];
+extern void R_InvertMatrix(float *sourcemat, float *destmat);
+
+void RB_DrawSurfaceSprites( shaderStage_t *stage, shaderCommands_t *input) 
+{
+	unsigned long	glbits=stage->stateBits;
+	
+	R_SurfaceSpriteFrameUpdate();
+
+	//
+	// Check fog
+	//
+	if ( tess.fogNum && tess.shader->fogPass && r_drawfog->value) 
+	{
+		SSUsingFog = qtrue;
+		SQuickSprite.StartGroup(&stage->bundle[0], glbits, tess.fogNum);
+	}
+	else
+	{
+		SSUsingFog = qfalse;
+		SQuickSprite.StartGroup(&stage->bundle[0], glbits);
+	}
+
+	// Special provision in case the transparency is additive.
+	if ((glbits & (GLS_SRCBLEND_BITS|GLS_DSTBLEND_BITS)) == (GLS_SRCBLEND_ONE|GLS_DSTBLEND_ONE))
+	{	// Additive transparency, scale light value
+		SSAdditiveTransparency=qtrue;
+	}
+	else
+	{
+		SSAdditiveTransparency=qfalse;
+	}
+
+
+	//Check if this is a new entity transformation (incl. world entity), and update the appropriate vectors if so.
+	if (backEnd.currentEntity != ssLastEntityDrawn)
+	{	
+		if (backEnd.currentEntity == &tr.worldEntity)
+		{	// Drawing the world, so our job is dead-easy, in the viewparms
+			VectorCopy(backEnd.viewParms.or.origin, ssViewOrigin);
+			VectorCopy(backEnd.viewParms.or.axis[1], ssViewRight);
+			VectorCopy(backEnd.viewParms.or.axis[2], ssViewUp);
+		}
+		else
+		{	// Drawing an entity, so we need to transform the viewparms to the model's coordinate system
+//			R_WorldPointToEntity (backEnd.viewParms.or.origin, ssViewOrigin);
+			R_WorldNormalToEntity (backEnd.viewParms.or.axis[1], ssViewRight); 
+			R_WorldNormalToEntity (backEnd.viewParms.or.axis[2], ssViewUp);
+			VectorCopy(backEnd.ori.viewOrigin, ssViewOrigin);
+//			R_WorldToLocal(backEnd.viewParms.or.axis[1], ssViewRight);
+//			R_WorldToLocal(backEnd.viewParms.or.axis[2], ssViewUp);
+		}
+		ssLastEntityDrawn = backEnd.currentEntity;
+	}
+
+	switch(stage->ss->surfaceSpriteType)
+	{
+	case SURFSPRITE_FLATTENED:
+	case SURFSPRITE_VERTICAL:
+		RB_DrawVerticalSurfaceSprites(stage, input);
+		break;
+	case SURFSPRITE_ORIENTED:
+		RB_DrawOrientedSurfaceSprites(stage, input);
+		break;
+	case SURFSPRITE_EFFECT:
+	case SURFSPRITE_WEATHERFX:
+		RB_DrawEffectSurfaceSprites(stage, input);
+		break;
+	}
+
+	SQuickSprite.EndGroup();
+
+	sssurfaces++;
+}
+
diff --git a/code/renderer/tr_terrain.cpp b/code/renderer/tr_terrain.cpp
new file mode 100644
index 0000000..2107a6c
--- /dev/null
+++ b/code/renderer/tr_terrain.cpp
@@ -0,0 +1,1047 @@
+#include "../server/exe_headers.h"
+
+// this include must remain at the top of every CPP file
+#include "tr_local.h"
+
+#if !defined(GENERICPARSER2_H_INC)
+	#include "../game/genericparser2.h"
+#endif
+
+// To do:
+// Alter variance dependent on global distance from player (colour code this for cg_terrainCollisionDebug)
+// Improve texture blending on edge conditions
+// Link to neightbouring terrains or architecture (edge conditions)
+// Post process generated light data to make sure there are no bands within a patch
+
+#include "../qcommon/cm_landscape.h"
+#include "tr_landscape.h"
+
+#define VectorSet5(v,x,y,z,a,b)	((v)[0]=(x), (v)[1]=(y), (v)[2]=(z), (v)[3]=(a), (v)[4]=(b))
+#define VectorScaleVectorAdd(c,a,b,o)	((o)[0]=(c)[0]+((a)[0]*(b)[0]),(o)[1]=(c)[1]+((a)[1]*(b)[1]),(o)[2]=(c)[2]+((a)[2]*(b)[2]))
+
+cvar_t		*r_drawTerrain;
+cvar_t		*r_terrainTessellate;
+cvar_t		*r_terrainWaterOffset;
+
+cvar_t		*r_count;
+
+static int		TerrainFog = 0;
+static float	TerrainDistanceCull;
+
+//
+// Render the tree.
+//
+void CTRPatch::RenderCorner(ivec5_t corner)
+{
+	if((corner[3] < 0) || (tess.registration != corner[4]))
+	{
+		CTerVert	*vert;
+
+		vert = mRenderMap + (corner[1] * owner->GetRealWidth()) + corner[0];
+
+		VectorCopy(vert->coords, tess.xyz[tess.numVertexes]);
+		VectorCopy(vert->normal, tess.normal[tess.numVertexes]);
+
+		*(ulong *)tess.vertexColors[tess.numVertexes] = *(ulong *)vert->tint;
+		*(ulong *)tess.vertexAlphas[tess.numVertexes] = corner[2];
+
+		tess.texCoords[tess.numVertexes][0][0] = vert->tex[0];
+		tess.texCoords[tess.numVertexes][0][1] = vert->tex[1];
+
+		tess.indexes[tess.numIndexes++] = tess.numVertexes;
+		corner[3] = tess.numVertexes++;
+		corner[4] = tess.registration;
+	}
+	else
+	{
+		tess.indexes[tess.numIndexes++] = corner[3];
+	}
+}
+
+void CTRPatch::RecurseRender(int depth, ivec5_t left, ivec5_t right, ivec5_t apex)
+{
+	// All non-leaf nodes have both children, so just check for one
+	if (depth >= 0)
+	{
+		ivec5_t		center;
+		byte		*centerAlphas;
+		byte		*leftAlphas;
+		byte		*rightAlphas;
+
+		// Work out the centre of the hypoteneuse
+		center[0] = (left[0] + right[0]) >> 1;
+		center[1] = (left[1] + right[1]) >> 1;
+		
+		// Work out the relevant texture coefficients at that point
+		leftAlphas = (byte *)&left[2];
+		rightAlphas = (byte *)&right[2];
+		centerAlphas = (byte *)&center[2];
+
+		centerAlphas[0] = (leftAlphas[0] + rightAlphas[0]) >> 1;
+		centerAlphas[1] = (leftAlphas[1] + rightAlphas[1]) >> 1;
+		centerAlphas[2] = (leftAlphas[2] + rightAlphas[2]) >> 1;
+		centerAlphas[3] = (leftAlphas[3] + rightAlphas[3]) >> 1;
+
+		// Make sure the vert index and tesselation registration are not set
+		center[3] = -1;
+		center[4] = 0;
+
+		if (apex[0] == left[0] && apex[0] == center[0])
+		{
+			depth = 0;
+		}
+
+		RecurseRender(depth-1, apex, left, center);
+		RecurseRender(depth-1, right, apex, center);
+	}
+	else										
+	{
+		if (left[0] == right[0] && left[0] == apex[0])
+		{
+			return;
+		}
+		if (left[1] == right[1] && left[1] == apex[1])
+		{
+			return;
+		}
+		// A leaf node!  Output a triangle to be rendered.
+		RB_CheckOverflow(4, 4);
+
+//		assert(left[0] != right[0] || left[1] != right[1]);
+//		assert(left[0] != apex[0] || left[1] != apex[1]);
+
+		RenderCorner(left);
+		RenderCorner(right);
+		RenderCorner(apex);
+	}
+}
+
+//
+// Render the mesh.
+//
+// The order of triangles is critical to the subdivision working
+
+void CTRPatch::Render(int Part)
+{
+	ivec5_t		lTL, lTR, lBL, lBR;
+	int patchTerxels = owner->GetTerxels();
+
+//	VectorSet5(TL, 0, 0, TEXTURE_ALPHA_TL, -1, 0);
+	lTL[0] = 0;
+	lTL[1] = 0;
+	lTL[2] = TEXTURE_ALPHA_TL;
+	lTL[3] = -1;
+	lTL[4] = 0;
+//	VectorSet5(TR, owner->GetTerxels(), 0, TEXTURE_ALPHA_TR, -1, 0);
+	lTR[0] = patchTerxels;
+	lTR[1] = 0;
+	lTR[2] = TEXTURE_ALPHA_TR;
+	lTR[3] = -1;
+	lTR[4] = 0;
+//	VectorSet5(BL, 0, owner->GetTerxels(), TEXTURE_ALPHA_BL, -1, 0);
+	lBL[0] = 0;
+	lBL[1] = patchTerxels;
+	lBL[2] = TEXTURE_ALPHA_BL;
+	lBL[3] = -1;
+	lBL[4] = 0;
+//	VectorSet5(BR, owner->GetTerxels(), owner->GetTerxels(), TEXTURE_ALPHA_BR, -1, 0);
+	lBR[0] = patchTerxels;
+	lBR[1] = patchTerxels;
+	lBR[2] = TEXTURE_ALPHA_BR;
+	lBR[3] = -1;
+	lBR[4] = 0;
+
+	if ((Part & PI_TOP) && mTLShader)
+	{
+/*		float		d;
+
+		d = DotProduct (backEnd.refdef.vieworg, mNormal[0]) - mDistance[0];
+
+		if (d <= 0.0)*/
+		{
+			RecurseRender(r_terrainTessellate->integer, lBL, lTR, lTL);
+		}
+	}
+	
+	if ((Part & PI_BOTTOM) && mBRShader)
+	{
+/*		float		d;
+
+		d = DotProduct (backEnd.refdef.vieworg, mNormal[1]) - mDistance[1];
+
+		if (d >= 0.0)*/
+		{
+			RecurseRender(r_terrainTessellate->integer, lTR, lBL, lBR);
+		}
+	}
+}
+
+//
+// At this point the patch is visible and at least part of it is below water level
+//
+int CTRPatch::RenderWaterVert(int x, int y)
+{
+	CTerVert	*vert;
+
+	vert = mRenderMap + x + (y * owner->GetRealWidth());
+
+	if(vert->tessRegistration == tess.registration)
+	{
+		return(vert->tessIndex);
+	}
+	tess.xyz[tess.numVertexes][0] = vert->coords[0];
+	tess.xyz[tess.numVertexes][1] = vert->coords[1];
+	tess.xyz[tess.numVertexes][2] = owner->GetWaterHeight();
+
+	*(ulong *)tess.vertexColors[tess.numVertexes] = 0xffffffff;
+
+	tess.texCoords[tess.numVertexes][0][0] = vert->tex[0];
+	tess.texCoords[tess.numVertexes][0][1] = vert->tex[1];
+
+	vert->tessIndex = tess.numVertexes;
+	vert->tessRegistration = tess.registration;
+
+	tess.numVertexes++;
+	return(vert->tessIndex);
+}
+
+void CTRPatch::RenderWater(void)
+{
+	RB_CheckOverflow(4, 6);
+
+	// Get the neighbouring patches
+	int TL = RenderWaterVert(0, 0);
+	int TR = RenderWaterVert(owner->GetTerxels(), 0);
+	int BL = RenderWaterVert(0, owner->GetTerxels());
+	int BR = RenderWaterVert(owner->GetTerxels(), owner->GetTerxels());
+
+	// TL
+	tess.indexes[tess.numIndexes++] = BL;
+	tess.indexes[tess.numIndexes++] = TR;
+	tess.indexes[tess.numIndexes++] = TL;
+
+	// BR
+	tess.indexes[tess.numIndexes++] = TR;
+	tess.indexes[tess.numIndexes++] = BL;
+	tess.indexes[tess.numIndexes++] = BR;
+}
+
+const bool CTRPatch::HasWater(void) const
+{
+	owner->SetRealWaterHeight( owner->GetBaseWaterHeight() + r_terrainWaterOffset->integer );
+	return(common->GetMins()[2] < owner->GetWaterHeight()); 
+}
+
+bool CM_CullWorldBox (const cplane_t *frustum, const vec3pair_t bounds);
+
+void CTRPatch::SetVisibility(bool visCheck)
+{
+	if(visCheck)
+	{
+		if(DistanceSquared(mCenter, backEnd.refdef.vieworg) > TerrainDistanceCull)
+		{
+			misVisible = false;
+		}
+		else
+		{
+			// Set the visibility of the patch
+			misVisible = CM_CullWorldBox(backEnd.viewParms.frustum, GetBounds());
+		}
+	}
+	else
+	{
+		misVisible = true;
+	}
+}
+
+/*
+void CTRPatch::CalcNormal(void)
+{
+	CTerVert	*vert1, *vert2, *vert3;
+	ivec5_t		TL, TR, BL, BR;
+	vec3_t		v1, v2;
+
+	VectorSet5(TL, 0, 0, TEXTURE_ALPHA_TL, -1, 0);
+	VectorSet5(TR, owner->GetTerxels(), 0, TEXTURE_ALPHA_TR, -1, 0);
+	VectorSet5(BL, 0, owner->GetTerxels(), TEXTURE_ALPHA_BL, -1, 0);
+	VectorSet5(BR, owner->GetTerxels(), owner->GetTerxels(), TEXTURE_ALPHA_BR, -1, 0);
+
+	vert1 = mRenderMap + (BL[1] * owner->GetRealWidth()) + BL[0];
+	vert2 = mRenderMap + (TR[1] * owner->GetRealWidth()) + TR[0];
+	vert3 = mRenderMap + (TL[1] * owner->GetRealWidth()) + TL[0];
+	VectorSubtract(vert2->coords, vert1->coords, v1);
+	VectorSubtract(vert3->coords, vert1->coords, v2);
+	CrossProduct(v1, v2, mNormal[0]);
+	VectorNormalize(mNormal[0]);
+	mDistance[0] = DotProduct (vert1->coords, mNormal[0]);
+
+	vert1 = mRenderMap + (BL[1] * owner->GetRealWidth()) + BL[0];
+	vert2 = mRenderMap + (TR[1] * owner->GetRealWidth()) + TR[0];
+	vert3 = mRenderMap + (BR[1] * owner->GetRealWidth()) + BR[0];
+	VectorSubtract(vert2->coords, vert1->coords, v1);
+	VectorSubtract(vert3->coords, vert1->coords, v2);
+	CrossProduct(v1, v2, mNormal[1]);
+	VectorNormalize(mNormal[1]);
+	mDistance[1] = DotProduct (vert1->coords, mNormal[1]);
+}
+*/
+//
+// Reset all patches, recompute variance if needed
+//
+void CTRLandScape::Reset(bool visCheck)
+{
+	int			x, y;
+	CTRPatch	*patch;
+
+	TerrainDistanceCull = tr.distanceCull + mPatchSize;
+	TerrainDistanceCull *= TerrainDistanceCull;
+
+	// Go through the patches performing resets, compute variances, and linking.
+	for(y = mPatchMiny; y < mPatchMaxy; y++)
+	{
+		for(x = mPatchMinx; x < mPatchMaxx; x++, patch++)
+		{
+			patch = GetPatch(x, y);
+			patch->SetVisibility(visCheck);
+		}
+	}
+}
+
+
+//
+// Render each patch of the landscape & adjust the frame variance.
+//
+
+void CTRLandScape::Render(void)
+{
+	int			x, y;
+	CTRPatch	*patch;
+	TPatchInfo	*current;
+	int			i;
+	
+	// Render all the visible patches
+	current = mSortedPatches;
+	for(i=0;i<mSortedCount;i++)
+	{
+		if (current->mPatch->isVisible())
+		{
+			if (tess.shader != current->mShader)
+			{
+				RB_EndSurface();
+				RB_BeginSurface(current->mShader, TerrainFog);
+			}
+			current->mPatch->Render(current->mPart);
+		}
+		current++;
+	}
+	RB_EndSurface();
+
+	// Render all the water for visible patches
+	// Done as a separate iteration to reduce the number of tesses created
+	if(mWaterShader && (mWaterShader != tr.defaultShader))
+	{
+		RB_BeginSurface( mWaterShader, tr.world->globalFog );
+
+		for(y = mPatchMiny; y < mPatchMaxy; y++ )
+		{
+			for(x = mPatchMinx; x < mPatchMaxx; x++ )
+			{
+				patch = GetPatch(x, y);
+				if(patch->isVisible() && patch->HasWater())
+				{
+					patch->RenderWater();
+				}
+			}
+		}
+		RB_EndSurface();
+	}
+}
+
+void CTRLandScape::CalculateRegion(void)
+{
+	vec3_t	mins, maxs, size, offset;
+
+#if	_DEBUG
+	mCycleCount++;
+#endif
+	VectorCopy(GetPatchSize(), size);
+	VectorCopy(GetMins(), offset);
+
+	mins[0] = backEnd.refdef.vieworg[0] - tr.distanceCull - (size[0] * 2.0f) - offset[0];
+	mins[1] = backEnd.refdef.vieworg[1] - tr.distanceCull - (size[1] * 2.0f) - offset[1];
+
+	maxs[0] = backEnd.refdef.vieworg[0] + tr.distanceCull + (size[0] * 2.0f) - offset[0];
+	maxs[1] = backEnd.refdef.vieworg[1] + tr.distanceCull + (size[1] * 2.0f) - offset[1];
+
+	mPatchMinx = Com_Clamp(0, GetBlockWidth(), floorf(mins[0] / size[0]));
+	mPatchMaxx = Com_Clamp(0, GetBlockWidth(), ceilf(maxs[0] / size[0]));
+
+	mPatchMiny = Com_Clamp(0, GetBlockHeight(), floorf(mins[1] / size[1]));
+	mPatchMaxy = Com_Clamp(0, GetBlockHeight(), ceilf(maxs[1] / size[1]));
+}
+
+void CTRLandScape::CalculateRealCoords(void)
+{
+	int			x, y;
+
+	// Work out the real world coordinates of each heightmap entry
+	for(y = 0; y < GetRealHeight(); y++)
+	{
+		for(x = 0; x < GetRealWidth(); x++)
+		{
+			ivec3_t		icoords;
+			int			offset;
+
+			offset = (y * GetRealWidth()) + x;
+
+			VectorSet(icoords, x, y, mRenderMap[offset].height);
+			VectorScaleVectorAdd(GetMins(), icoords, GetTerxelSize(), mRenderMap[offset].coords);
+		}
+	}
+}
+
+void CTRLandScape::CalculateNormals(void)
+{
+	int		x, y, offset = 0;
+
+	// Work out the normals for every face
+	for(y = 0; y < GetHeight(); y++)
+	{
+		for(x = 0; x < GetWidth(); x++)
+		{
+			vec3_t		vcenter, vleft;
+			
+			offset = (y * GetRealWidth()) + x;
+
+			VectorSubtract(mRenderMap[offset].coords, mRenderMap[offset + 1].coords, vcenter);
+			VectorSubtract(mRenderMap[offset].coords, mRenderMap[offset + GetRealWidth()].coords, vleft);
+
+			CrossProduct(vcenter, vleft, mRenderMap[offset].normal);
+			VectorNormalize(mRenderMap[offset].normal);
+		}
+		// Duplicate right edge condition
+		VectorCopy(mRenderMap[offset].normal, mRenderMap[offset + 1].normal);
+	}
+	// Duplicate bottom line
+	offset = GetHeight() * GetRealWidth();
+	for(x = 0; x < GetRealWidth(); x++)
+	{
+		VectorCopy(mRenderMap[offset - GetRealWidth() + x].normal, mRenderMap[offset + x].normal);
+	}
+}
+
+int R_LightForPoint( vec3_t point, vec3_t ambientLight, vec3_t directedLight, vec3_t lightDir );
+
+void CTRLandScape::CalculateLighting(void)
+{
+	int		x, y, offset = 0;
+
+	// Work out the vertex normal (average of every attached face normal) and apply to the direction of the light
+	for(y = 0; y < GetHeight(); y++)
+	{
+		for(x = 0; x < GetWidth(); x++)
+		{
+			vec3_t		ambient;
+			vec3_t		directed, direction;
+			vec3_t		total, tint;
+			vec_t		dp;
+			
+			offset = (y * GetRealWidth()) + x;
+			
+			// Work out average normal
+		   	VectorCopy(GetRenderMap(x, y)->normal, total);
+		   	VectorAdd(total, GetRenderMap(x + 1, y)->normal, total);
+		   	VectorAdd(total, GetRenderMap(x + 1, y + 1)->normal, total);
+		   	VectorAdd(total, GetRenderMap(x, y + 1)->normal, total);
+			VectorNormalize(total);
+
+			if (!R_LightForPoint(mRenderMap[offset].coords, ambient, directed, direction))
+			{
+				mRenderMap[offset].tint[0] = 
+					mRenderMap[offset].tint[1] =
+					mRenderMap[offset].tint[2] = 255 >> tr.overbrightBits;
+				mRenderMap[offset].tint[3] = 255;
+				continue;
+			}
+
+			if(mRenderMap[offset].coords[2] < common->GetBaseWaterHeight())
+			{
+				VectorScale(ambient, 0.75f, ambient);
+			}
+
+			// Both normalised, so -1.0 < dp < 1.0
+			dp = Com_Clamp(0.0f, 1.0f, DotProduct(direction, total));
+			dp = powf(dp, 3);
+			VectorScale(ambient, (1.0 - dp) * 0.5, ambient);
+			VectorMA(ambient, dp, directed, tint);
+
+			// rjr - in R_SetupEntityLighting, ambient light is automatically increased by 32, so do it here to match
+			// rjr - decided to disable both the lighting boost automatically in there as well as here.
+			mRenderMap[offset].tint[0] = (byte)Com_Clamp(0.0f, 255.0f, tint[0] ) >> tr.overbrightBits;
+			mRenderMap[offset].tint[1] = (byte)Com_Clamp(0.0f, 255.0f, tint[1] ) >> tr.overbrightBits;
+			mRenderMap[offset].tint[2] = (byte)Com_Clamp(0.0f, 255.0f, tint[2] ) >> tr.overbrightBits;
+			mRenderMap[offset].tint[3] = 0xff;
+		}
+		mRenderMap[offset + 1].tint[0] = mRenderMap[offset].tint[0];
+		mRenderMap[offset + 1].tint[1] = mRenderMap[offset].tint[1];
+		mRenderMap[offset + 1].tint[2] = mRenderMap[offset].tint[2];
+		mRenderMap[offset + 1].tint[3] = 0xff;
+	}
+	// Duplicate bottom line
+	offset = GetHeight() * GetRealWidth();
+	for(x = 0; x < GetRealWidth(); x++)
+	{
+		mRenderMap[offset + x].tint[0] = mRenderMap[offset - GetRealWidth() + x].tint[0];
+		mRenderMap[offset + x].tint[1] = mRenderMap[offset - GetRealWidth() + x].tint[1];
+		mRenderMap[offset + x].tint[2] = mRenderMap[offset - GetRealWidth() + x].tint[2];
+		mRenderMap[offset + x].tint[3] = 0xff;
+	}
+}
+
+void CTRLandScape::CalculateTextureCoords(void)
+{
+	int		x, y;
+
+	for(y = 0; y < GetRealHeight(); y++)
+	{
+		for(x = 0; x < GetRealWidth(); x++)
+		{
+			int offset = (y * GetRealWidth()) + x;
+
+			mRenderMap[offset].tex[0] = x * mTextureScale * GetTerxelSize()[0];
+			mRenderMap[offset].tex[1] = y * mTextureScale * GetTerxelSize()[1];
+		}
+	}
+}
+
+void CTRLandScape::SetShaders(const int height, const qhandle_t shader)
+{
+	int		i;
+
+	for(i = height; shader && (i < HEIGHT_RESOLUTION); i++)
+	{
+		if(!mHeightDetails[i].GetShader())
+		{
+			mHeightDetails[i].SetShader(shader);
+		}
+	}
+}
+
+void CTRLandScape::LoadTerrainDef(const char *td)
+{
+#ifndef PRE_RELEASE_DEMO
+	char			terrainDef[MAX_QPATH];
+	CGenericParser2	parse;
+	CGPGroup		*basegroup, *classes, *items;
+
+	Com_sprintf(terrainDef, MAX_QPATH, "ext_data/RMG/%s.terrain", td);
+	Com_Printf("R_Terrain: Loading and parsing terrainDef %s.....\n", td);
+
+	mWaterShader = NULL;
+	mFlatShader  = NULL;
+
+	if(!Com_ParseTextFile(terrainDef, parse))
+	{
+		Com_sprintf(terrainDef, MAX_QPATH, "ext_data/arioche/%s.terrain", td);
+		if(!Com_ParseTextFile(terrainDef, parse))
+		{
+			Com_Printf("Could not open %s\n", terrainDef);
+			return;
+		}
+	}
+	// The whole file....
+	basegroup = parse.GetBaseParseGroup();
+
+	// The root { } struct
+	classes = basegroup->GetSubGroups();
+	while(classes)
+	{
+		items = classes->GetSubGroups();
+		while(items)
+		{
+			const char* type = items->GetName ( );
+
+			if(!stricmp( type, "altitudetexture"))
+			{
+				int			height;
+				const char	*shaderName;
+			  	qhandle_t	shader;
+
+				// Height must exist - the rest are optional
+				height = atol(items->FindPairValue("height", "0"));
+
+				// Shader for this height
+				shaderName = items->FindPairValue("shader", "");
+				if(shaderName[0])
+				{
+					shader = RE_RegisterShader(shaderName);
+					if(shader)
+					{
+						SetShaders(height, shader); 
+					}
+				}
+			}
+			else if(!stricmp(type, "water"))
+			{
+				mWaterShader = R_GetShaderByHandle(RE_RegisterShader(items->FindPairValue("shader", "")));
+			}
+			else if(!stricmp(type, "flattexture"))
+			{
+				mFlatShader = RE_RegisterShader ( items->FindPairValue("shader", "") );
+			}
+
+			items = (CGPGroup *)items->GetNext();
+		}
+		classes = (CGPGroup *)classes->GetNext();
+	}
+	
+	Com_ParseTextFileDestroy(parse);
+#endif // PRE_RELEASE_DEMO
+}
+
+qhandle_t R_CreateBlendedShader(qhandle_t a, qhandle_t b, qhandle_t c, bool surfaceSprites );
+
+qhandle_t CTRLandScape::GetBlendedShader(qhandle_t a, qhandle_t b, qhandle_t c, bool surfaceSprites)
+{
+	qhandle_t	blended;
+
+	// Special case single pass shader
+	if((a == b) && (a == c))
+	{
+		return(a);
+	}
+
+	blended = R_CreateBlendedShader(a, b, c, surfaceSprites );
+	return(blended);
+}
+
+static int ComparePatchInfo(const TPatchInfo *arg1, const TPatchInfo *arg2)
+{
+	shader_t	*s1, *s2;
+
+	if ((arg1->mPart & PI_TOP))
+	{
+		s1 = arg1->mPatch->GetTLShader();
+	}
+	else
+	{
+		s1 = arg1->mPatch->GetBRShader();
+	}
+
+	if ((arg2->mPart & PI_TOP))
+	{
+		s2 = arg2->mPatch->GetTLShader();
+	}
+	else
+	{
+		s2 = arg2->mPatch->GetBRShader();
+	}
+
+	if (s1 < s2)
+	{
+		return -1;
+	}
+	else if (s1 > s2)
+	{
+		return 1;
+	}
+
+	return 0;
+}
+
+void CTRLandScape::CalculateShaders(void)
+{
+#ifndef PRE_RELEASE_DEMO
+	int						x, y;
+	int						width, height;
+	int						offset;
+//	int						offsets[4];
+	qhandle_t				handles[4];
+	CTRPatch				*patch;
+	qhandle_t				*shaders;
+	TPatchInfo				*current = mSortedPatches;
+	
+	width  = GetWidth ( ) / common->GetTerxels ( );
+	height = GetHeight ( ) / common->GetTerxels ( );
+
+	shaders = new qhandle_t [ (width+1) * (height+1) ];
+
+	// On the first pass determine all of the shaders for the entire 
+	// terrain assuming no flat ground
+	offset = 0;
+	for ( y = 0; y < height + 1; y ++ )
+	{
+		if ( y <= height )
+		{
+			offset = common->GetTerxels ( ) * y * GetRealWidth ( );		
+		}
+		else
+		{
+			offset = common->GetTerxels ( ) * (y-1) * GetRealWidth ( );	
+			offset += GetRealWidth ( );
+		}
+
+		for ( x = 0; x < width + 1; x ++, offset += common->GetTerxels ( ) )
+		{
+			// Save the shader
+			shaders[y * width + x] = GetHeightDetail(mRenderMap[offset].height)->GetShader ( );
+		}
+	}
+
+	// On the second pass determine flat ground and replace the shader
+	// at that point with the flat ground shader
+	byte*	flattenMap = common->GetFlattenMap ( );
+	if ( mFlatShader && flattenMap )
+	{
+		for ( y = 1; y < height; y ++ )
+		{
+			for ( x = 1; x < width; x ++ )
+			{
+				int		offset;
+				int		xx;
+				int		yy;
+				bool	flat	   = false;
+
+				offset  = (x) * common->GetTerxels ( );
+				offset += (y) * common->GetTerxels ( ) * GetRealWidth();
+
+				offset -= GetRealWidth();
+				offset -= 1;
+				
+				for ( yy = 0; yy < 3 && !flat; yy++ )
+				{
+					for ( xx = 0; xx < 3 && !flat; xx++ )
+					{
+						if ( flattenMap [ offset + xx] & 0x80)
+						{
+							flat = true;
+							break;
+						}		
+					}
+
+					offset += GetRealWidth();
+				}
+				// This shader is now a flat shader
+				if ( flat )
+				{
+					shaders[y * width + x] = mFlatShader;
+				}
+
+#ifdef _DEBUG
+				OutputDebugString ( va("Flat Area:  %f %f\n", 
+									GetMins()[0] + (GetMaxs()[0]-GetMins()[0])/width * x,
+									GetMins()[1] + (GetMaxs()[1]-GetMins()[1])/height * y) );
+#endif
+			}
+		}
+	}
+
+	// Now that the shaders have been determined, set them for each patch
+	patch = mTRPatches;
+	mSortedCount = 0;
+	for ( y = 0; y < height; y ++ )
+	{
+		for ( x = 0; x < width; x ++, patch++ )
+		{
+			bool surfaceSprites = true;
+
+			/*
+			handles[INDEX_TL] = shaders[ (x + y) * width ];
+			handles[INDEX_TR] = shaders[ ((x + 1) + y) * width ];
+			handles[INDEX_BL] = shaders[ (x + (y + 1)) * width ];
+			handles[INDEX_BR] = shaders[ ((x + 1) + (y + 1)) * width ];
+			*/
+			handles[INDEX_TL] = shaders[ x + y * width ];
+			handles[INDEX_TR] = shaders[ x + 1 + y * width ];
+			handles[INDEX_BL] = shaders[ x + (y + 1) * width ];
+			handles[INDEX_BR] = shaders[ x + 1 + (y + 1) * width ];
+			
+			if ( handles[INDEX_TL] == mFlatShader ||
+				 handles[INDEX_TR] == mFlatShader ||
+				 handles[INDEX_BL] == mFlatShader ||
+				 handles[INDEX_BR] == mFlatShader    )
+			{
+				surfaceSprites = false;
+			}
+
+			patch->SetTLShader(GetBlendedShader(handles[INDEX_TR], handles[INDEX_BL], handles[INDEX_TL], surfaceSprites));
+			current->mPatch = patch;
+			current->mShader = patch->GetTLShader();
+			current->mPart = PI_TOP;
+			
+			patch->SetBRShader(GetBlendedShader(handles[INDEX_TR], handles[INDEX_BL], handles[INDEX_BR], surfaceSprites));
+			if (patch->GetBRShader() == current->mShader)
+			{
+				current->mPart |= PI_BOTTOM;
+			}
+			else
+			{
+				mSortedCount++;
+				current++;
+
+				current->mPatch = patch;
+				current->mShader = patch->GetBRShader();
+				current->mPart = PI_BOTTOM;
+			}
+			mSortedCount++;
+			current++;
+		}
+	}
+
+	// Cleanup our temporary array
+	delete[] shaders;
+
+	qsort(mSortedPatches, mSortedCount, sizeof(*mSortedPatches), (int (__cdecl *)(const void *,const void *))ComparePatchInfo);
+
+#endif // PRE_RELEASE_DEMO
+}
+
+void CTRPatch::SetRenderMap(const int x, const int y) 
+{ 
+	mRenderMap = localowner->GetRenderMap(x, y); 
+}
+
+void InitRendererPatches( CCMPatch *patch, void *userdata )
+{
+	int			  	tx, ty, bx, by;
+	CTRPatch	  	*localpatch;
+	CCMLandScape	*owner;
+	CTRLandScape	*localowner;
+
+	// Set owning landscape
+	localowner = (CTRLandScape *)userdata;
+	owner = (CCMLandScape *)localowner->GetCommon();
+
+	// Get TRPatch pointer
+	tx = patch->GetHeightMapX();
+	ty = patch->GetHeightMapY();
+	bx = tx / owner->GetTerxels();
+	by = ty / owner->GetTerxels();
+
+	localpatch = localowner->GetPatch(bx, by);
+	localpatch->Clear();
+
+	localpatch->SetCommon(patch);
+	localpatch->SetOwner(owner);
+	localpatch->SetLocalOwner(localowner);
+	localpatch->SetRenderMap(tx, ty);
+	localpatch->SetCenter();
+//	localpatch->CalcNormal();
+}
+
+void CTRLandScape::CopyHeightMap(void)
+{
+	const CCMLandScape	*common = GetCommon();
+	const byte			*heightMap = common->GetHeightMap();
+	CTerVert			*renderMap = mRenderMap;
+	int					i;
+
+	for(i = 0; i < common->GetRealArea(); i++)
+	{
+		renderMap->height = *heightMap;
+		renderMap++;
+		heightMap++;
+	}
+}
+
+CTRLandScape::~CTRLandScape(void)
+{
+	if(mTRPatches)
+	{
+		Z_Free(mTRPatches);
+		mTRPatches = NULL;
+	}
+	if (mSortedPatches)
+	{
+		Z_Free(mSortedPatches);
+		mSortedPatches = 0;
+	}
+	if(mRenderMap)
+	{
+		Z_Free(mRenderMap);
+		mRenderMap = NULL;
+	}
+}
+
+CCMLandScape *CM_RegisterTerrain(const char *config, bool server);
+
+qhandle_t R_GetShaderByNum(int shaderNum, world_t &worldData);
+
+CTRLandScape::CTRLandScape(const char *configstring)
+{
+#ifndef PRE_RELEASE_DEMO
+	int					shaderNum;
+	const CCMLandScape	*common;
+
+	memset(this, 0, sizeof(*this));
+
+	// Sets up the common aspects of the terrain
+	common = CM_RegisterTerrain(configstring, false);
+	SetCommon(common);
+
+	tr.landScape.landscape = this;
+
+	mTextureScale = (float)atof(Info_ValueForKey(configstring, "texturescale")) / common->GetTerxels();
+	LoadTerrainDef(Info_ValueForKey(configstring, "terrainDef"));
+
+	// To normalise the variance value to a reasonable number
+	mScalarSize = VectorLengthSquared(common->GetSize());
+
+	// Calculate and set variance depth
+	mMaxNode = (Q_log2(common->GetTerxels()) << 1) - 1;
+
+	// Allocate space for the renderer specific data
+	mRenderMap = (CTerVert *)Z_Malloc(sizeof(CTerVert) * common->GetRealArea(), TAG_R_TERRAIN, qfalse);
+
+	// Copy byte heightmap to rendermap to speed up calcs
+	CopyHeightMap();
+
+	// Calculate the real world location for each heightmap entry
+	CalculateRealCoords();
+
+	// Calculate the normal of each terxel
+	CalculateNormals();
+
+	// Calculate modulation values for the heightmap
+	CalculateLighting();
+
+	// Calculate texture coords (not projected - real)
+	CalculateTextureCoords();
+
+	Com_Printf ("R_Terrain: Creating renderer patches.....\n");
+	// Initialise all terrain patches
+	mTRPatches = (CTRPatch *)Z_Malloc(sizeof(CTRPatch) * common->GetBlockCount(), TAG_R_TERRAIN, qfalse); 
+
+	mSortedCount = 2 * common->GetBlockCount();
+	mSortedPatches = (TPatchInfo *)Z_Malloc(sizeof(TPatchInfo) * mSortedCount, TAG_R_TERRAIN, qfalse);
+
+	CM_TerrainPatchIterate(common, InitRendererPatches, this);
+
+	// Calculate shaders dependent on the .terrain file
+	CalculateShaders();
+
+	// Get the contents shader
+	shaderNum = atol(Info_ValueForKey(configstring, "shader"));
+
+	mShader = R_GetShaderByHandle(R_GetShaderByNum(shaderNum, *tr.world));
+
+	mPatchSize = VectorLength(common->GetPatchSize());
+
+#if	_DEBUG
+	mCycleCount = 0;
+#endif
+#endif // PRE_RELEASE_DEMO
+}
+
+// ---------------------------------------------------------------------
+
+void RB_SurfaceTerrain( surfaceInfo_t *surf )
+{
+	srfTerrain_t *ls = (srfTerrain_t *)surf;
+	CTRLandScape *landscape = ls->landscape;
+
+	TerrainFog = tr.world->globalFog;
+
+	landscape->CalculateRegion();
+	landscape->Reset();
+//	landscape->Tessellate();
+	landscape->Render();
+}
+
+void R_CalcTerrainVisBounds(CTRLandScape *landscape)
+{
+	const CCMLandScape *common = landscape->GetCommon();
+
+	// Set up the visbounds using terrain data
+	if ( common->GetMins()[0] < tr.viewParms.visBounds[0][0] ) 
+	{
+		tr.viewParms.visBounds[0][0] = common->GetMins()[0];
+	}
+	if ( common->GetMins()[1] < tr.viewParms.visBounds[0][1] ) 
+	{
+		tr.viewParms.visBounds[0][1] = common->GetMins()[1];
+	}
+	if ( common->GetMins()[2] < tr.viewParms.visBounds[0][2] ) 
+	{
+		tr.viewParms.visBounds[0][2] = common->GetMins()[2];
+	}
+
+	if ( common->GetMaxs()[0] > tr.viewParms.visBounds[1][0] ) 
+	{
+		tr.viewParms.visBounds[1][0] = common->GetMaxs()[0];
+	}
+	if ( common->GetMaxs()[1] > tr.viewParms.visBounds[1][1] ) 
+	{
+		tr.viewParms.visBounds[1][1] = common->GetMaxs()[1];
+	}
+	if ( common->GetMaxs()[2] > tr.viewParms.visBounds[1][2] ) 
+	{
+		tr.viewParms.visBounds[1][2] = common->GetMaxs()[2];
+	}
+}
+
+void R_AddTerrainSurfaces(void)
+{
+	CTRLandScape	*landscape;
+
+	if (!r_drawTerrain->integer || (tr.refdef.rdflags & RDF_NOWORLDMODEL))
+	{
+		return;
+	}
+
+	landscape = tr.landScape.landscape;
+	if(landscape)
+	{
+		R_AddDrawSurf( (surfaceType_t *)(&tr.landScape), landscape->GetShader(), 0, qfalse );
+		R_CalcTerrainVisBounds(landscape);
+	}
+}
+
+void RE_InitRendererTerrain( const char *info )
+{
+	CTRLandScape	*ls;
+
+	if ( !info || !info[0] )
+	{
+		Com_Printf( "RE_RegisterTerrain: NULL name\n" );
+		return;
+	}
+
+	Com_Printf("R_Terrain: Creating RENDERER data.....\n");
+
+	// Create and register a new landscape structure
+	ls = new CTRLandScape(info);
+}
+
+void R_TerrainInit(void)
+{
+	int		i;
+
+	for(i = 0; i < MAX_TERRAINS; i++)
+	{
+		tr.landScape.surfaceType = SF_TERRAIN;
+		tr.landScape.landscape = NULL;
+	}
+	r_terrainTessellate = Cvar_Get("r_terrainTessellate", "3", CVAR_CHEAT);
+	r_drawTerrain = Cvar_Get("r_drawTerrain", "1", CVAR_CHEAT);
+	r_terrainWaterOffset = Cvar_Get("r_terrainWaterOffset", "0", 0);
+	r_count = Cvar_Get("r_count", "2", 0);
+}
+
+void CM_ShutdownTerrain( thandle_t terrainId);
+
+void R_TerrainShutdown(void)
+{
+	CTRLandScape	*ls;
+
+	//Com_Printf("R_Terrain: Shutting down RENDERER terrain.....\n");
+	ls = tr.landScape.landscape;
+	if(ls)
+	{
+		CM_ShutdownTerrain(0);
+		delete ls;
+		tr.landScape.landscape = NULL;
+	}
+}
+
+// end
diff --git a/code/renderer/tr_types.h b/code/renderer/tr_types.h
new file mode 100644
index 0000000..9848190
--- /dev/null
+++ b/code/renderer/tr_types.h
@@ -0,0 +1,240 @@
+#ifndef __TR_TYPES_H
+#define __TR_TYPES_H
+
+#include "..\game\ghoul2_shared.h"
+
+#define	MAX_DLIGHTS		32			// can't be increased, because bit flags are used on surfaces
+#ifdef _XBOX
+#define	MAX_ENTITIES	1024		// 11 bits, can't be increased without changing drawsurf bit packing (QSORT_ENTITYNUM_SHIFT)
+#else
+#define	MAX_ENTITIES	2048		// 11 bits, can't be increased without changing drawsurf bit packing (QSORT_ENTITYNUM_SHIFT)
+#endif
+#define TR_WORLDENT (MAX_ENTITIES-1)
+
+// renderfx flags
+#define	RF_MORELIGHT		0x00001	// allways have some light (viewmodel, some items)
+#define	RF_THIRD_PERSON		0x00002	// don't draw through eyes, only mirrors (player bodies, chat sprites)
+#define	RF_FIRST_PERSON		0x00004	// only draw through eyes (view weapon, damage blood blob)
+#define	RF_DEPTHHACK		0x00008	// for view weapon Z crunching
+#define RF_NODEPTH			0x00010	// No depth at all (seeing through walls)
+
+#define RF_VOLUMETRIC		0x00020	// fake volumetric shading
+
+#define	RF_NOSHADOW			0x00040	// don't add stencil shadows
+
+#define RF_LIGHTING_ORIGIN	0x00080	// use refEntity->lightingOrigin instead of refEntity->origin
+									// for lighting.  This allows entities to sink into the floor
+									// with their origin going solid, and allows all parts of a
+									// player to get the same lighting
+#define	RF_SHADOW_PLANE		0x00100	// use refEntity->shadowPlane
+#define	RF_WRAP_FRAMES		0x00200	// mod the model frames by the maxframes to allow continuous
+										// animation without needing to know the frame count
+#define	RF_CAP_FRAMES		0x00400	// cap the model frames by the maxframes for one shot anims
+
+#define RF_ALPHA_FADE		0x00800	// hacks blend mode and uses whatever the set alpha is.
+#define RF_PULSATE			0x01000	// for things like a dropped saber, where we want to add an extra visual clue
+#define RF_RGB_TINT			0x02000	// overrides ent RGB color to the specified color
+
+#define RF_FORKED			0x04000	// override lightning to have forks
+#define RF_TAPERED			0x08000	// lightning tapers
+#define RF_GROW				0x10000	// lightning grows from start to end during its life
+
+#define RF_SETANIMINDEX		0x20000	//use backEnd.currentEntity->e.skinNum for R_BindAnimatedImage
+
+#define RF_DISINTEGRATE1	0x40000	// does a procedural hole-ripping thing.
+#define RF_DISINTEGRATE2	0x80000	// does a procedural hole-ripping thing with scaling at the ripping point
+
+#define RF_G2MINLOD		   0x100000	// force Lowest lod on g2
+
+#define RF_SHADOW_ONLY	   0x200000 //add surfs for shadowing but don't draw them normally -rww
+
+#define	RF_DISTORTION	   0x400000	//area distortion effect -rww
+
+// refdef flags
+#define RDF_NOWORLDMODEL	1		// used for player configuration screen
+#define RDF_HYPERSPACE		4		// teleportation effect
+
+#define RDF_SKYBOXPORTAL	8
+#define RDF_DRAWSKYBOX		16		// the above marks a scene as being a 'portal sky'.  this flag says to draw it or not
+
+#define RDF_doLAGoggles		32		// Light Amp goggles
+#define RDF_doFullbright	64		// Light Amp goggles
+#define RDF_ForceSightOn	128		// using force sight
+
+
+extern int	skyboxportal;
+extern int	drawskyboxportal;
+
+typedef byte color4ub_t[4];
+
+typedef struct {
+	vec3_t		xyz;
+	float		st[2];
+	byte		modulate[4];
+} polyVert_t;
+
+typedef struct poly_s {
+	qhandle_t			hShader;
+	int					numVerts;
+	polyVert_t			*verts;
+} poly_t;
+
+typedef enum 
+{
+	RT_MODEL,
+	RT_POLY,
+	RT_SPRITE,
+	RT_ORIENTED_QUAD,
+	RT_LINE,
+	RT_ELECTRICITY,
+	RT_CYLINDER,
+	RT_LATHE,
+	RT_BEAM,
+	RT_SABER_GLOW,
+	RT_PORTALSURFACE,		// doesn't draw anything, just info for portals
+	RT_CLOUDS,
+
+	RT_MAX_REF_ENTITY_TYPE
+} refEntityType_t;
+
+typedef struct {
+	refEntityType_t	reType;
+	int			renderfx;
+
+	qhandle_t	hModel;				// opaque type outside refresh
+
+	// most recent data
+	vec3_t		lightingOrigin;		// so multi-part models can be lit identically (RF_LIGHTING_ORIGIN)
+	float		shadowPlane;		// projection shadows go here, stencils go slightly lower
+
+	vec3_t		axis[3];			// rotation vectors
+	qboolean	nonNormalizedAxes;	// axis are not normalized, i.e. they have scale
+	float		origin[3];			// also used as MODEL_BEAM's "from"
+	int			frame;				// also used as MODEL_BEAM's diameter
+
+	// previous data for frame interpolation
+	float		oldorigin[3];		// also used as MODEL_BEAM's "to"
+	int			oldframe;
+	float		backlerp;			// 0.0 = current, 1.0 = old
+
+	// texturing
+	int			skinNum;			// inline skin index
+
+	qhandle_t	customSkin;			// NULL for default skin
+	qhandle_t	customShader;		// use one image for the entire thing
+
+	// misc
+	byte		shaderRGBA[4];		// colors used by colorSrc=vertex shaders
+	float		shaderTexCoord[2];	// texture coordinates used by tcMod=vertex modifiers
+	float		shaderTime;			// subtracted from refdef time to control effect start times
+
+	// extra sprite information
+	float		radius;
+
+	// This doesn't have to be unioned, but it does make for more meaningful variable names :)
+	union
+	{
+		float		rotation;
+		float		endTime;
+		float		saberLength;
+	};
+
+/*
+Ghoul2 Insert Start
+*/
+	vec3_t		angles;				// rotation angles - used for Ghoul2
+
+	vec3_t		modelScale;			// axis scale for models
+	CGhoul2Info_v	*ghoul2;  		// has to be at the end of the ref-ent in order for it to be created properly
+/*
+Ghoul2 Insert End
+*/
+
+} refEntity_t;
+
+
+#define	MAX_RENDER_STRINGS			8
+#define	MAX_RENDER_STRING_LENGTH	32
+
+typedef struct {
+	int			x, y, width, height;
+	float		fov_x, fov_y;
+	vec3_t		vieworg;
+	vec3_t		viewaxis[3];		// transformation matrix
+	int			viewContents;		// world contents at vieworg
+
+	// time in milliseconds for shader effects and other time dependent rendering issues
+	int			time;
+
+	int			rdflags;			// RDF_NOWORLDMODEL, etc
+
+	// 1 bits will prevent the associated area from rendering at all
+	byte		areamask[MAX_MAP_AREA_BYTES];
+
+	// text messages for deform text shaders
+//	char		text[MAX_RENDER_STRINGS][MAX_RENDER_STRING_LENGTH];
+} refdef_t;
+
+
+typedef enum {
+	STEREO_CENTER,
+	STEREO_LEFT,
+	STEREO_RIGHT
+} stereoFrame_t;
+
+
+/*
+** glconfig_t
+**
+** Contains variables specific to the OpenGL configuration
+** being run right now.  These are constant once the OpenGL
+** subsystem is initialized.
+*/
+typedef enum {
+	TC_NONE,
+	TC_S3TC,
+	TC_S3TC_DXT
+} textureCompression_t;
+
+typedef struct {
+	const char				*renderer_string;
+	const char				*vendor_string;
+	const char				*version_string;
+	const char				*extensions_string;
+
+	int						maxTextureSize;			// queried from GL
+	int						maxActiveTextures;		// multitexture ability
+	float					maxTextureFilterAnisotropy;
+
+	int						colorBits, depthBits, stencilBits;
+
+	qboolean				deviceSupportsGamma;
+	textureCompression_t	textureCompression;
+	qboolean				textureEnvAddAvailable;
+	qboolean				textureFilterAnisotropicAvailable;
+	qboolean				clampToEdgeAvailable;
+
+	int						vidWidth, vidHeight;
+
+	int						displayFrequency;
+
+	// synonymous with "does rendering consume the entire screen?", therefore
+	// a Voodoo or Voodoo2 will have this set to TRUE, as will a Win32 ICD that
+	// used CDS.
+	qboolean				isFullscreen;
+	qboolean				stereoEnabled;
+} glconfig_t;
+
+
+#if !defined _WIN32
+
+#define OPENGL_DRIVER_NAME	"libGL.so"
+
+#else
+
+#define OPENGL_DRIVER_NAME	"opengl32"
+
+#endif	// !defined _WIN32
+
+
+#endif	// __TR_TYPES_H
diff --git a/code/renderer/tr_world.cpp b/code/renderer/tr_world.cpp
new file mode 100644
index 0000000..2bb04db
--- /dev/null
+++ b/code/renderer/tr_world.cpp
@@ -0,0 +1,1021 @@
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+#include "tr_local.h"
+
+#ifdef VV_LIGHTING
+#include "tr_lightmanager.h"
+#endif
+
+#ifdef _XBOX
+#include "../qcommon/sparc.h"
+#endif
+
+static bool lookingForWorstLeaf = false;
+
+#ifdef _XBOX
+static bool GetCoordsForLeaf(int leafNum, vec3_t coords)
+{
+	srfSurfaceFace_t *face;
+	msurface_t *surf;
+	int i;
+
+	for(i=0; i<tr.world->leafs[leafNum].nummarksurfaces; i++) {
+		surf = *(tr.world->marksurfaces + 
+				tr.world->leafs[leafNum].firstMarkSurfNum + i);
+		
+		if(!surf->data || *surf->data != SF_FACE) {
+			continue;
+		}
+
+		face = (srfSurfaceFace_t*)surf->data;
+		Q_CastShort2Float(&coords[0], (short*)(face->srfPoints + 0));
+		Q_CastShort2Float(&coords[1], (short*)(face->srfPoints + 1));
+		Q_CastShort2Float(&coords[2], (short*)(face->srfPoints + 2));
+		return true;
+	}
+
+	return false;
+}
+#endif
+
+/*
+=================
+R_CullTriSurf
+
+Returns true if the grid is completely culled away.
+Also sets the clipped hint bit in tess
+=================
+*/
+static qboolean	R_CullTriSurf( srfTriangles_t *cv ) {
+	int 	boxCull;
+
+	boxCull = R_CullLocalBox( cv->bounds );
+
+	if ( boxCull == CULL_OUT ) {
+		return qtrue;
+	}
+	return qfalse;
+}
+
+/*
+=================
+R_CullGrid
+
+Returns true if the grid is completely culled away.
+Also sets the clipped hint bit in tess
+=================
+*/
+static qboolean	R_CullGrid( srfGridMesh_t *cv ) {
+	int 	boxCull;
+	int 	sphereCull;
+
+	if ( r_nocurves->integer ) {
+		return qtrue;
+	}
+
+	if ( tr.currentEntityNum != TR_WORLDENT ) {
+		sphereCull = R_CullLocalPointAndRadius( cv->localOrigin, cv->meshRadius );
+	} else {
+		sphereCull = R_CullPointAndRadius( cv->localOrigin, cv->meshRadius );
+	}
+	boxCull = CULL_OUT;
+	
+	// check for trivial reject
+	if ( sphereCull == CULL_OUT )
+	{
+		tr.pc.c_sphere_cull_patch_out++;
+		return qtrue;
+	}
+	// check bounding box if necessary
+	else if ( sphereCull == CULL_CLIP )
+	{
+		tr.pc.c_sphere_cull_patch_clip++;
+
+		boxCull = R_CullLocalBox( cv->meshBounds );
+
+		if ( boxCull == CULL_OUT ) 
+		{
+			tr.pc.c_box_cull_patch_out++;
+			return qtrue;
+		}
+		else if ( boxCull == CULL_IN )
+		{
+			tr.pc.c_box_cull_patch_in++;
+		}
+		else
+		{
+			tr.pc.c_box_cull_patch_clip++;
+		}
+	}
+	else
+	{
+		tr.pc.c_sphere_cull_patch_in++;
+	}
+
+	return qfalse;
+}
+
+
+/*
+================
+R_CullSurface
+
+Tries to back face cull surfaces before they are lighted or
+added to the sorting list.
+
+This will also allow mirrors on both sides of a model without recursion.
+================
+*/
+static qboolean	R_CullSurface( surfaceType_t *surface, shader_t *shader ) {
+	srfSurfaceFace_t *sface;
+	float			d;
+
+	if ( r_nocull->integer==1 ) {
+		return qfalse;
+	}
+
+	if ( *surface == SF_GRID ) {
+		return R_CullGrid( (srfGridMesh_t *)surface );
+	}
+
+	if ( *surface == SF_TRIANGLES ) {
+		return R_CullTriSurf( (srfTriangles_t *)surface );
+	}
+
+	if ( *surface != SF_FACE ) {
+		return qfalse;
+	}
+
+	if ( shader->cullType == CT_TWO_SIDED ) {
+		return qfalse;
+	}
+
+	// face culling
+	if ( !r_facePlaneCull->integer ) {
+		return qfalse;
+	}
+
+	sface = ( srfSurfaceFace_t * ) surface;
+	d = DotProduct (tr.or.viewOrigin, sface->plane.normal);
+
+	// don't cull exactly on the plane, because there are levels of rounding
+	// through the BSP, ICD, and hardware that may cause pixel gaps if an
+	// epsilon isn't allowed here 
+	if ( shader->cullType == CT_FRONT_SIDED ) {
+		if ( d < sface->plane.dist - 8 ) {
+			return qtrue;
+		}
+	} else {
+		if ( d > sface->plane.dist + 8 ) {
+			return qtrue;
+		}
+	}
+
+	return qfalse;
+}
+
+
+#ifndef VV_LIGHTING
+static int R_DlightFace( srfSurfaceFace_t *face, int dlightBits ) {
+	float		d;
+	int			i;
+	dlight_t	*dl;
+
+	for ( i = 0 ; i < tr.refdef.num_dlights ; i++ ) {
+		if ( ! ( dlightBits & ( 1 << i ) ) ) {
+			continue;
+		}
+		dl = &tr.refdef.dlights[i];
+		d = DotProduct( dl->origin, face->plane.normal ) - face->plane.dist;
+		if ( !VectorCompare(face->plane.normal, vec3_origin) && (d < -dl->radius || d > dl->radius) ) {
+			// dlight doesn't reach the plane
+			dlightBits &= ~( 1 << i );
+		}
+	}
+
+	if ( !dlightBits ) {
+		tr.pc.c_dlightSurfacesCulled++;
+	}
+
+	face->dlightBits = dlightBits;
+	return dlightBits;
+}
+#endif // VV_LIGHTING
+
+#ifndef VV_LIGHTING
+static int R_DlightGrid( srfGridMesh_t *grid, int dlightBits ) {
+	int			i;
+	dlight_t	*dl;
+
+	for ( i = 0 ; i < tr.refdef.num_dlights ; i++ ) {
+		if ( ! ( dlightBits & ( 1 << i ) ) ) {
+			continue;
+		}
+		dl = &tr.refdef.dlights[i];
+		if ( dl->origin[0] - dl->radius > grid->meshBounds[1][0]
+			|| dl->origin[0] + dl->radius < grid->meshBounds[0][0]
+			|| dl->origin[1] - dl->radius > grid->meshBounds[1][1]
+			|| dl->origin[1] + dl->radius < grid->meshBounds[0][1]
+			|| dl->origin[2] - dl->radius > grid->meshBounds[1][2]
+			|| dl->origin[2] + dl->radius < grid->meshBounds[0][2] ) {
+			// dlight doesn't reach the bounds
+			dlightBits &= ~( 1 << i );
+		}
+	}
+
+	if ( !dlightBits ) {
+		tr.pc.c_dlightSurfacesCulled++;
+	}
+
+	grid->dlightBits = dlightBits;
+	return dlightBits;
+}
+#endif // VV_LIGHTING
+
+
+#ifndef VV_LIGHTING
+static int R_DlightTrisurf( srfTriangles_t *surf, int dlightBits ) {
+	// FIXME: more dlight culling to trisurfs...
+	surf->dlightBits = dlightBits;
+	return dlightBits;
+#if 0
+	int			i;
+	dlight_t	*dl;
+
+	for ( i = 0 ; i < tr.refdef.num_dlights ; i++ ) {
+		if ( ! ( dlightBits & ( 1 << i ) ) ) {
+			continue;
+		}
+		dl = &tr.refdef.dlights[i];
+		if ( dl->origin[0] - dl->radius > grid->meshBounds[1][0]
+			|| dl->origin[0] + dl->radius < grid->meshBounds[0][0]
+			|| dl->origin[1] - dl->radius > grid->meshBounds[1][1]
+			|| dl->origin[1] + dl->radius < grid->meshBounds[0][1]
+			|| dl->origin[2] - dl->radius > grid->meshBounds[1][2]
+			|| dl->origin[2] + dl->radius < grid->meshBounds[0][2] ) {
+			// dlight doesn't reach the bounds
+			dlightBits &= ~( 1 << i );
+		}
+	}
+
+	if ( !dlightBits ) {
+		tr.pc.c_dlightSurfacesCulled++;
+	}
+
+	grid->dlightBits = dlightBits;
+	return dlightBits;
+#endif
+}
+#endif // VV_LIGHTING
+
+/*
+====================
+R_DlightSurface
+
+The given surface is going to be drawn, and it touches a leaf
+that is touched by one or more dlights, so try to throw out
+more dlights if possible.
+====================
+*/
+#ifndef VV_LIGHTING
+static int R_DlightSurface( msurface_t *surf, int dlightBits ) {
+	if ( *surf->data == SF_FACE ) {
+		dlightBits = R_DlightFace( (srfSurfaceFace_t *)surf->data, dlightBits );
+	} else if ( *surf->data == SF_GRID ) {
+		dlightBits = R_DlightGrid( (srfGridMesh_t *)surf->data, dlightBits );
+	} else if ( *surf->data == SF_TRIANGLES ) {
+		dlightBits = R_DlightTrisurf( (srfTriangles_t *)surf->data, dlightBits );
+	} else {
+		dlightBits = 0;
+	}
+
+	if ( dlightBits ) {
+		tr.pc.c_dlightSurfaces++;
+	}
+
+	return dlightBits;
+}
+#endif // VV_LIGHTING
+
+
+
+/*
+======================
+R_AddWorldSurface
+======================
+*/
+#ifdef VV_LIGHTING
+void R_AddWorldSurface( msurface_t *surf, int dlightBits, qboolean noViewCount ) {
+#else
+static void R_AddWorldSurface( msurface_t *surf, int dlightBits, qboolean noViewCount = qfalse ) {
+#endif
+	/*
+	if ( surf->viewCount == tr.viewCount ) {
+		return;		// already in this view
+	}
+	*/
+
+	//rww - changed this to be like sof2mp's so RMG will look right.
+	//Will this affect anything that is non-rmg?
+
+	if (!noViewCount)
+	{
+		if ( surf->viewCount == tr.viewCount ) 
+		{
+			// already in this view, but lets make sure all the dlight bits are set
+			if ( *surf->data == SF_FACE ) 
+			{
+				((srfSurfaceFace_t *)surf->data)->dlightBits |= dlightBits;
+			} 
+			else if ( *surf->data == SF_GRID ) 
+			{
+				((srfGridMesh_t *)surf->data)->dlightBits |= dlightBits;
+			} 
+			else if ( *surf->data == SF_TRIANGLES ) 
+			{
+				((srfTriangles_t *)surf->data)->dlightBits |= dlightBits;
+			}
+			return;		
+		}
+		surf->viewCount = tr.viewCount;
+		// FIXME: bmodel fog?
+	}
+
+//	surf->viewCount = tr.viewCount;
+	// FIXME: bmodel fog?
+
+	// try to cull before dlighting or adding
+	if ( R_CullSurface( surf->data, surf->shader ) ) {
+		return;
+	}
+
+	// check for dlighting
+	if ( dlightBits ) {
+#ifdef VV_LIGHTING
+		dlightBits = VVLightMan.R_DlightSurface( surf, dlightBits );
+#else
+		dlightBits = R_DlightSurface( surf, dlightBits );
+#endif
+		dlightBits = ( dlightBits != 0 );
+	}
+
+	R_AddDrawSurf( surf->data, surf->shader, surf->fogIndex, dlightBits );
+} 
+
+/*
+=============================================================
+
+	BRUSH MODELS
+
+=============================================================
+*/
+
+/*
+=================
+R_AddBrushModelSurfaces
+=================
+*/
+void R_AddBrushModelSurfaces ( trRefEntity_t *ent ) {
+	bmodel_t	*bmodel;
+	int			clip;
+	model_t		*pModel;
+	int			i;
+
+	pModel = R_GetModelByHandle( ent->e.hModel );
+
+	bmodel = pModel->bmodel;
+
+	clip = R_CullLocalBox( bmodel->bounds );
+	if ( clip == CULL_OUT ) {
+		return;
+	}
+	
+	if(pModel->bspInstance)
+	{
+#ifdef VV_LIGHTING
+		VVLightMan.R_SetupEntityLighting(&tr.refdef, ent);
+#else
+		R_SetupEntityLighting(&tr.refdef, ent);
+#endif
+	}
+
+#ifdef VV_LIGHTING
+	VVLightMan.R_DlightBmodel( bmodel, qfalse );
+#else
+	R_DlightBmodel( bmodel, qfalse );
+#endif
+
+	for ( i = 0 ; i < bmodel->numSurfaces ; i++ ) {
+		R_AddWorldSurface( bmodel->firstSurface + i, tr.currentEntity->dlightBits, qtrue );
+	}
+}
+
+float GetQuadArea( vec3_t v1, vec3_t v2, vec3_t v3, vec3_t v4 )
+{
+	vec3_t	vec1, vec2, dis1, dis2;
+
+	// Get area of tri1
+	VectorSubtract( v1, v2, vec1 );
+	VectorSubtract( v1, v4, vec2 ); 
+	CrossProduct( vec1, vec2, dis1 );
+	VectorScale( dis1, 0.25f, dis1 );
+
+	// Get area of tri2
+	VectorSubtract( v3, v2, vec1 );
+	VectorSubtract( v3, v4, vec2 );
+	CrossProduct( vec1, vec2, dis2 );
+	VectorScale( dis2, 0.25f, dis2 );
+
+	// Return addition of disSqr of each tri area
+	return ( dis1[0] * dis1[0] + dis1[1] * dis1[1] + dis1[2] * dis1[2] +
+				dis2[0] * dis2[0] + dis2[1] * dis2[1] + dis2[2] * dis2[2] );
+}
+
+#ifdef _XBOX
+float GetQuadArea( unsigned short v1[3], unsigned short v2[3], unsigned short v3[3], unsigned short v4[3])
+{
+	vec3_t fv1;
+	vec3_t fv2;
+	vec3_t fv3;
+	vec3_t fv4;
+
+	for(int i=0; i<3; i++) {
+		Q_CastShort2Float(&fv1[i], (short*)&v1[i]);
+		Q_CastShort2Float(&fv2[i], (short*)&v2[i]);
+		Q_CastShort2Float(&fv3[i], (short*)&v3[i]);
+		Q_CastShort2Float(&fv4[i], (short*)&v4[i]);
+	}
+
+	return GetQuadArea(fv1, fv2, fv3, fv4);
+}
+#endif
+
+void RE_GetBModelVerts( int bmodelIndex, vec3_t *verts, vec3_t normal )
+{
+	msurface_t			*surfs;
+	srfSurfaceFace_t	*face;
+	bmodel_t			*bmodel;
+	model_t				*pModel;
+	int					i;
+	//	Not sure if we really need to track the best two candidates
+	int					maxDist[2]={0,0};
+	int					maxIndx[2]={0,0};
+	int					dist = 0;
+	float				dot1, dot2;
+
+	pModel = R_GetModelByHandle( bmodelIndex );
+	bmodel = pModel->bmodel;
+
+	// Loop through all surfaces on the brush and find the best two candidates
+	for ( i = 0 ; i < bmodel->numSurfaces; i++ ) 
+	{
+		surfs = bmodel->firstSurface + i;
+		face = ( srfSurfaceFace_t *)surfs->data;
+
+		// It seems that the safest way to handle this is by finding the area of the faces
+#ifdef _XBOX
+		int nextSurfPoint = NEXT_SURFPOINT(face->flags);
+		dist = GetQuadArea( face->srfPoints, face->srfPoints + nextSurfPoint, 
+				face->srfPoints + nextSurfPoint * 2, face->srfPoints +
+						 nextSurfPoint * 3 );
+#else
+		dist = GetQuadArea( face->points[0], face->points[1], face->points[2], face->points[3] );
+#endif
+
+		// Check against the highest max
+		if ( dist > maxDist[0] )
+		{
+			// Shuffle our current maxes down
+			maxDist[1] = maxDist[0];
+			maxIndx[1] = maxIndx[0];
+
+			maxDist[0] = dist;
+			maxIndx[0] = i;
+		}
+		// Check against the second highest max
+		else if ( dist >= maxDist[1] )
+		{
+			// just stomp the old
+			maxDist[1] = dist;
+			maxIndx[1] = i;
+		}
+	}
+
+	// Hopefully we've found two best case candidates.  Now we should see which of these faces the viewer
+	surfs = bmodel->firstSurface + maxIndx[0];
+	face = ( srfSurfaceFace_t *)surfs->data;
+	dot1 = DotProduct( face->plane.normal, tr.refdef.viewaxis[0] );
+	
+	surfs = bmodel->firstSurface + maxIndx[1];
+	face = ( srfSurfaceFace_t *)surfs->data;
+	dot2 = DotProduct( face->plane.normal, tr.refdef.viewaxis[0] );
+
+	if ( dot2 < dot1 && dot2 < 0.0f )
+	{
+		i = maxIndx[1]; // use the second face
+	}
+	else if ( dot1 < dot2 && dot1 < 0.0f )
+	{
+		i = maxIndx[0]; // use the first face
+	}
+	else
+	{ // Possibly only have one face, so may as well use the first face, which also should be the best one
+		//i = rand() & 1; // ugh, we don't know which to use.  I'd hope this would never happen
+		i = maxIndx[0]; // use the first face
+	}
+
+	surfs = bmodel->firstSurface + i;
+	face = ( srfSurfaceFace_t *)surfs->data;
+
+#ifdef _XBOX
+	int nextSurfPoint = NEXT_SURFPOINT(face->flags);
+	for ( int t = 0; t < 4; t++ )
+	{
+		Q_CastShort2Float(&verts[t][0], (short*)(face->srfPoints + nextSurfPoint * t + 0));
+		Q_CastShort2Float(&verts[t][1], (short*)(face->srfPoints + nextSurfPoint * t + 1));
+		Q_CastShort2Float(&verts[t][2], (short*)(face->srfPoints + nextSurfPoint * t + 2));
+	}
+#else
+	for ( int t = 0; t < 4; t++ )
+	{
+		VectorCopy(	face->points[t], verts[t] );
+	}
+#endif
+}
+
+/*
+=============================================================
+
+	WORLD MODEL
+
+=============================================================
+*/
+
+
+/*
+================
+R_RecursiveWorldNode
+================
+*/
+#ifndef VV_LIGHTING
+static void R_RecursiveWorldNode( mnode_t *node, int planeBits, int dlightBits ) {
+
+	do {
+		int			newDlights[2];
+
+		// if the node wasn't marked as potentially visible, exit
+		if (node->visframe != tr.visCount) {
+			return;
+		}
+
+		// if the bounding volume is outside the frustum, nothing
+		// inside can be visible OPTIMIZE: don't do this all the way to leafs?
+
+		if ( r_nocull->integer!=1 ) {
+			int		r;
+
+			if ( planeBits & 1 ) {
+				r = BoxOnPlaneSide(node->mins, node->maxs, &tr.viewParms.frustum[0]);
+				if (r == 2) {
+					return;						// culled
+				}
+				if ( r == 1 ) {
+					planeBits &= ~1;			// all descendants will also be in front
+				}
+			}
+
+			if ( planeBits & 2 ) {
+				r = BoxOnPlaneSide(node->mins, node->maxs, &tr.viewParms.frustum[1]);
+				if (r == 2) {
+					return;						// culled
+				}
+				if ( r == 1 ) {
+					planeBits &= ~2;			// all descendants will also be in front
+				}
+			}
+
+			if ( planeBits & 4 ) {
+				r = BoxOnPlaneSide(node->mins, node->maxs, &tr.viewParms.frustum[2]);
+				if (r == 2) {
+					return;						// culled
+				}
+				if ( r == 1 ) {
+					planeBits &= ~4;			// all descendants will also be in front
+				}
+			}
+
+			if ( planeBits & 8 ) {
+				r = BoxOnPlaneSide(node->mins, node->maxs, &tr.viewParms.frustum[3]);
+				if (r == 2) {
+					return;						// culled
+				}
+				if ( r == 1 ) {
+					planeBits &= ~8;			// all descendants will also be in front
+				}
+			}
+
+			if ( planeBits & 16 ) {
+				r = BoxOnPlaneSide(node->mins, node->maxs, &tr.viewParms.frustum[4]);
+				if (r == 2) {
+					return;						// culled
+				}
+				if ( r == 1 ) {
+					planeBits &= ~16;			// all descendants will also be in front
+				}
+			}
+
+		}
+
+		if ( node->contents != -1 ) {
+			break;
+		}
+
+		// determine which dlights are needed
+		if ( r_nocull->integer!=2 ) 
+		{
+			newDlights[0] = 0;
+			newDlights[1] = 0;
+			if ( dlightBits ) 
+			{
+				int	i;
+				for ( i = 0 ; i < tr.refdef.num_dlights ; i++ )
+				{
+					dlight_t	*dl;
+					float		dist;
+
+					if ( dlightBits & ( 1 << i ) ) {
+						dl = &tr.refdef.dlights[i];
+						dist = DotProduct( dl->origin, node->plane->normal ) - node->plane->dist;
+						
+						if ( dist > -dl->radius ) {
+							newDlights[0] |= ( 1 << i );
+						}
+						if ( dist < dl->radius ) {
+							newDlights[1] |= ( 1 << i );
+						}
+					}
+				}
+			}
+		}
+		else
+		{
+			newDlights[0] = dlightBits;
+			newDlights[1] = dlightBits;
+		}
+		// recurse down the children, front side first
+		R_RecursiveWorldNode (node->children[0], planeBits, newDlights[0] );
+
+		// tail recurse
+		node = node->children[1];
+		dlightBits = newDlights[1];
+	} while ( 1 );
+
+	{
+		// leaf node, so add mark surfaces
+		int			c;
+		msurface_t	*surf, **mark;
+
+		tr.pc.c_leafs++;
+
+		// add to z buffer bounds
+		if ( node->mins[0] < tr.viewParms.visBounds[0][0] ) {
+			tr.viewParms.visBounds[0][0] = node->mins[0];
+		}
+		if ( node->mins[1] < tr.viewParms.visBounds[0][1] ) {
+			tr.viewParms.visBounds[0][1] = node->mins[1];
+		}
+		if ( node->mins[2] < tr.viewParms.visBounds[0][2] ) {
+			tr.viewParms.visBounds[0][2] = node->mins[2];
+		}
+
+		if ( node->maxs[0] > tr.viewParms.visBounds[1][0] ) {
+			tr.viewParms.visBounds[1][0] = node->maxs[0];
+		}
+		if ( node->maxs[1] > tr.viewParms.visBounds[1][1] ) {
+			tr.viewParms.visBounds[1][1] = node->maxs[1];
+		}
+		if ( node->maxs[2] > tr.viewParms.visBounds[1][2] ) {
+			tr.viewParms.visBounds[1][2] = node->maxs[2];
+		}
+
+		// add the individual surfaces
+		mark = node->firstmarksurface;
+		c = node->nummarksurfaces;
+		while (c--) {
+			// the surface may have already been added if it
+			// spans multiple leafs
+			surf = *mark;
+			R_AddWorldSurface( surf, dlightBits );
+			mark++;
+		}
+	}
+
+}
+#endif // VV_LIGHTING
+
+
+/*
+===============
+R_PointInLeaf
+===============
+*/
+static mnode_t *R_PointInLeaf( vec3_t p ) {
+	mnode_t		*node;
+	float		d;
+	cplane_t	*plane;
+	
+	if ( !tr.world ) {
+		Com_Error (ERR_DROP, "R_PointInLeaf: bad model");
+	}
+
+	node = tr.world->nodes;
+	while( 1 ) {
+		if (node->contents != -1) {
+			break;
+		}
+#ifdef _XBOX
+		plane = tr.world->planes + node->planeNum;
+#else
+		plane = node->plane;
+#endif
+		d = DotProduct (p,plane->normal) - plane->dist;
+		if (d > 0) {
+			node = node->children[0];
+		} else {
+			node = node->children[1];
+		}
+	}
+	
+	return node;
+}
+
+/*
+==============
+R_ClusterPVS
+==============
+*/
+static const byte *R_ClusterPVS (int cluster) {
+	if (!tr.world || !tr.world->vis || cluster < 0 || cluster >= tr.world->numClusters ) {
+		return tr.world->novis;
+	}
+
+#ifdef _XBOX
+	return tr.world->vis->Decompress(cluster * tr.world->clusterBytes,
+			tr.world->numClusters);
+#else
+	return tr.world->vis + cluster * tr.world->clusterBytes;
+#endif
+}
+
+/*
+=================
+R_inPVS
+=================
+*/
+#ifdef _XBOX
+qboolean R_inPVS( vec3_t p1, vec3_t p2 ) {
+	mleaf_s *leaf;
+	byte	*vis;
+
+	leaf = (mleaf_s*)R_PointInLeaf( p1 );
+	vis = (byte*)CM_ClusterPVS( leaf->cluster );
+	leaf = (mleaf_s*)R_PointInLeaf( p2 );
+
+	if ( !vis || (!(vis[leaf->cluster>>3] & (1<<(leaf->cluster&7)))) ) {
+		return qfalse;
+	}
+	return qtrue;
+}
+#else // _XBOX
+
+qboolean R_inPVS( vec3_t p1, vec3_t p2 ) {
+	mnode_t *leaf;
+	byte	*vis;
+
+	leaf = R_PointInLeaf( p1 );
+	vis = CM_ClusterPVS( leaf->cluster );
+	leaf = R_PointInLeaf( p2 );
+
+	if ( !(vis[leaf->cluster>>3] & (1<<(leaf->cluster&7))) ) {
+		return qfalse;
+	}
+	return qtrue;
+}
+#endif // _XBOX
+
+/*
+===============
+R_MarkLeaves
+
+Mark the leaves and nodes that are in the PVS for the current
+cluster
+===============
+*/
+#ifdef _XBOX
+void R_MarkLeaves (mleaf_s *leafOverride) {
+	const byte	*vis;
+	mleaf_s	*leaf;
+   	mnode_s	*parent;
+	int		i;
+	int		cluster;
+
+	// lockpvs lets designers walk around to determine the
+	// extent of the current pvs
+	if ( r_lockpvs->integer ) {
+		return;
+	}
+
+	// current viewcluster
+	if(!leafOverride) {
+		leaf = (mleaf_s*)R_PointInLeaf( tr.viewParms.pvsOrigin );
+	} else {
+		leaf = leafOverride;
+	}
+	cluster = leaf->cluster;
+
+	assert(leaf->contents != -1);
+
+	// if the cluster is the same and the area visibility matrix
+	// hasn't changed, we don't need to mark everything again
+
+	if ( tr.viewCluster == cluster && !tr.refdef.areamaskModified ) {
+		return;
+	}
+
+	tr.visCount++;
+	tr.viewCluster = cluster;
+
+	if ( r_novis->integer || tr.viewCluster == -1 ) {
+		for (i=0 ; i<tr.world->numnodes ; i++) {
+			if (tr.world->nodes[i].contents != CONTENTS_SOLID) {
+				tr.world->nodes[i].visframe = tr.visCount;
+			}
+		}
+		return;
+	}
+
+	vis = R_ClusterPVS (tr.viewCluster);
+	
+	for (i=0,leaf=tr.world->leafs ; i<tr.world->numleafs ; i++, leaf++) {
+		cluster = leaf->cluster;
+		if ( cluster < 0 || cluster >= tr.world->numClusters ) {
+			continue;
+		}
+
+		// check general pvs
+		if ( !(vis[cluster>>3] & (1<<(cluster&7))) ) {
+			continue;
+		}
+
+		// check for door connection
+		if (!lookingForWorstLeaf &&
+			   (tr.refdef.areamask[leaf->area>>3] & (1<<(leaf->area&7)) ) ) {
+			continue;		// not visible
+		}
+
+		parent = (mnode_t*)leaf;
+		assert(leaf->contents != -1);
+		do {
+			if (parent->visframe == tr.visCount)
+				break;
+			parent->visframe = tr.visCount;
+			parent = parent->parent;
+		} while (parent);
+	}
+}
+#else // _XBOX
+
+static void R_MarkLeaves (void) {
+	const byte	*vis;
+	mnode_t	*leaf, *parent;
+	int		i;
+	int		cluster;
+
+	// lockpvs lets designers walk around to determine the
+	// extent of the current pvs
+	if ( r_lockpvs->integer ) {
+		return;
+	}
+
+	// current viewcluster
+	leaf = R_PointInLeaf( tr.viewParms.pvsOrigin );
+	cluster = leaf->cluster;
+
+	// if the cluster is the same and the area visibility matrix
+	// hasn't changed, we don't need to mark everything again
+
+	// if r_showcluster was just turned on, remark everything 
+	if ( tr.viewCluster == cluster && !tr.refdef.areamaskModified 
+		&& !r_showcluster->modified ) {
+		return;
+	}
+
+	if ( r_showcluster->modified || r_showcluster->integer ) {
+		r_showcluster->modified = qfalse;
+		if ( r_showcluster->integer ) {
+			VID_Printf( PRINT_ALL, "cluster:%i  area:%i\n", cluster, leaf->area );
+		}
+	}
+
+	tr.visCount++;
+	tr.viewCluster = cluster;
+
+	if ( r_novis->integer || tr.viewCluster == -1 ) {
+		for (i=0 ; i<tr.world->numnodes ; i++) {
+			if (tr.world->nodes[i].contents != CONTENTS_SOLID) {
+				tr.world->nodes[i].visframe = tr.visCount;
+			}
+		}
+		return;
+	}
+
+	vis = R_ClusterPVS (tr.viewCluster);
+	
+	for (i=0,leaf=tr.world->nodes ; i<tr.world->numnodes ; i++, leaf++) {
+		cluster = leaf->cluster;
+		if ( cluster < 0 || cluster >= tr.world->numClusters ) {
+			continue;
+		}
+
+		// check general pvs
+		if ( !(vis[cluster>>3] & (1<<(cluster&7))) ) {
+			continue;
+		}
+
+		// check for door connection
+		if ( (tr.refdef.areamask[leaf->area>>3] & (1<<(leaf->area&7)) ) ) {
+			continue;		// not visible
+		}
+
+		parent = leaf;
+		do {
+			if (parent->visframe == tr.visCount)
+				break;
+			parent->visframe = tr.visCount;
+			parent = parent->parent;
+		} while (parent);
+	}
+}
+#endif
+
+
+/*
+=============
+R_AddWorldSurfaces
+=============
+*/
+#ifdef _XBOX
+void R_AddWorldSurfaces (void) {
+	if ( !r_drawworld->integer ) {
+		return;
+	}
+
+	if ( tr.refdef.rdflags & RDF_NOWORLDMODEL ) {
+		return;
+	}
+
+	tr.currentEntityNum = TR_WORLDENT;//ENTITYNUM_WORLD;
+	tr.shiftedEntityNum = tr.currentEntityNum << QSORT_ENTITYNUM_SHIFT;
+
+	// clear out the visible min/max
+	ClearBounds( tr.viewParms.visBounds[0], tr.viewParms.visBounds[1] );
+
+	// perform frustum culling and add all the potentially visible surfaces
+	if ( VVLightMan.num_dlights > MAX_DLIGHTS ) {
+		VVLightMan.num_dlights = MAX_DLIGHTS ;
+	}
+
+	VVLightMan.R_RecursiveWorldNode( tr.world->nodes, 15, ( 1 << VVLightMan.num_dlights ) - 1 );
+}
+
+#else // _XBOX
+
+void R_AddWorldSurfaces (void) {
+	if ( !r_drawworld->integer ) {
+		return;
+	}
+
+	if ( tr.refdef.rdflags & RDF_NOWORLDMODEL ) {
+		return;
+	}
+
+	tr.currentEntityNum = TR_WORLDENT;
+	tr.shiftedEntityNum = tr.currentEntityNum << QSORT_ENTITYNUM_SHIFT;
+
+	// determine which leaves are in the PVS / areamask
+	R_MarkLeaves ();
+
+	// clear out the visible min/max
+	ClearBounds( tr.viewParms.visBounds[0], tr.viewParms.visBounds[1] );
+
+	// perform frustum culling and add all the potentially visible surfaces
+	if ( tr.refdef.num_dlights > 32 ) {
+		tr.refdef.num_dlights = 32 ;
+	}
+
+	R_RecursiveWorldNode( tr.world->nodes, 31, ( 1 << tr.refdef.num_dlights ) - 1 );
+}
+
+#endif // _XBOX
diff --git a/code/renderer/vssver.scc b/code/renderer/vssver.scc
new file mode 100644
index 0000000..2e2475e
Binary files /dev/null and b/code/renderer/vssver.scc differ
diff --git a/code/server/exe_headers.cpp b/code/server/exe_headers.cpp
new file mode 100644
index 0000000..67f2b31
--- /dev/null
+++ b/code/server/exe_headers.cpp
@@ -0,0 +1,5 @@
+// The file that generates the PCH for the whole executable...
+//
+
+#include "../server/exe_headers.h"
+
diff --git a/code/server/exe_headers.h b/code/server/exe_headers.h
new file mode 100644
index 0000000..03475b9
--- /dev/null
+++ b/code/server/exe_headers.h
@@ -0,0 +1,13 @@
+// stuff added for PCH files.  I want to have a lot of stuff included here so the PCH is pretty rich,
+//	but without exposing too many extra protos, so for now (while I experiment)...
+//
+
+#include "../game/q_shared.h"
+#include "../qcommon/qcommon.h"
+
+#include "../client/client.h"
+#include "../server/server.h"
+#include "../renderer/tr_local.h"
+
+#pragma hdrstop
+
diff --git a/code/server/server.h b/code/server/server.h
new file mode 100644
index 0000000..f1768b1
--- /dev/null
+++ b/code/server/server.h
@@ -0,0 +1,321 @@
+// server.h
+
+#include "../game/q_shared.h"
+#include "../qcommon/qcommon.h"
+#include "../game/g_public.h"
+#include "../game/bg_public.h"
+
+#ifndef SERVER_H
+#define SERVER_H
+
+
+//=============================================================================
+
+//#define	PERS_SCORE				0		// !!! MUST NOT CHANGE, SERVER AND
+										// GAME BOTH REFERENCE !!!
+//rww - this won't do.. I need to include bg_public.h in the exe elsewhere.
+//I'm including it here instead so we can have our PERS_SCORE value. And have
+//it be the proper enum value.
+
+#define	MAX_ENT_CLUSTERS	16
+
+typedef struct svEntity_s {
+	struct worldSector_s *worldSector;
+	struct svEntity_s *nextEntityInWorldSector;
+	
+	entityState_t	baseline;		// for delta compression of initial sighting
+#ifdef _XBOX
+	signed char		numClusters;		// if -1, use headnode instead
+	short			clusternums[MAX_ENT_CLUSTERS];
+	short			lastCluster;		// if all the clusters don't fit in clusternums
+	short			areanum, areanum2;
+	char			snapshotCounter;	// used to prevent double adding from portal views
+#else
+	int			numClusters;		// if -1, use headnode instead
+	int			clusternums[MAX_ENT_CLUSTERS];
+	int			lastCluster;		// if all the clusters don't fit in clusternums
+	int			areanum, areanum2;
+	int			snapshotCounter;	// used to prevent double adding from portal views
+#endif
+} svEntity_t;
+
+typedef enum {
+	SS_DEAD,			// no map loaded
+	SS_LOADING,			// spawning level entities
+	SS_GAME				// actively running
+} serverState_t;
+
+typedef struct {
+	serverState_t	state;
+	int				serverId;			// changes each server start
+#ifdef _XBOX
+	char			snapshotCounter;	// incremented for each snapshot built
+#else
+	int				snapshotCounter;	// incremented for each snapshot built
+#endif
+	int				time;				// all entities are correct for this time		// These 2 saved out
+	int				timeResidual;		// <= 1000 / sv_frame->value					//   during savegame.
+	float			timeResidualFraction;	// fraction of a msec accumulated
+	int				nextFrameTime;		// when time > nextFrameTime, process world		// this doesn't get used anywhere! -Ste
+	struct cmodel_s	*models[MAX_MODELS];
+	char			*configstrings[MAX_CONFIGSTRINGS];
+	//
+	// be careful, Jake's code uses the 'svEntities' field as a marker to memset-this-far-only inside SV_InitSV()!!!!!
+	//
+	char			*entityParsePoint;	// used during game VM init
+
+	int				mLocalSubBSPIndex;
+	int				mLocalSubBSPModelOffset;
+	char			*mLocalSubBSPEntityParsePoint;
+
+	svEntity_t		svEntities[MAX_GENTITIES];
+} server_t;
+
+
+
+typedef struct {
+	int				areabytes;
+	byte			areabits[MAX_MAP_AREA_BYTES];		// portalarea visibility bits
+	playerState_t	ps;
+	int				num_entities;
+	int				first_entity;		// into the circular sv_packet_entities[]
+										// the entities MUST be in increasing state number
+										// order, otherwise the delta compression will fail
+	int				messageSent;		// time the message was transmitted
+	int				messageAcked;		// time the message was acked
+	int				messageSize;		// used to rate drop packets
+} clientSnapshot_t;
+
+typedef enum {
+	CS_FREE,		// can be reused for a new connection
+	CS_ZOMBIE,		// client has been disconnected, but don't reuse
+					// connection for a couple seconds
+	CS_CONNECTED,	// has been assigned to a client_t, but no gamestate yet
+	CS_PRIMED,		// gamestate has been sent, but client hasn't sent a usercmd
+	CS_ACTIVE		// client is fully in game
+} clientState_t;
+
+
+typedef struct client_s {
+	clientState_t	state;
+	char			userinfo[MAX_INFO_STRING];		// name, etc
+
+	char			*reliableCommands[MAX_RELIABLE_COMMANDS];
+	int				reliableSequence;
+	int				reliableAcknowledge;
+
+	int				gamestateMessageNum;	// netchan->outgoingSequence of gamestate
+
+	usercmd_t		lastUsercmd;
+	int				lastMessageNum;		// for delta compression
+	int				cmdNum;				// command number last executed
+	int				lastClientCommand;	// reliable client message sequence
+	gentity_t		*gentity;			// SV_GentityNum(clientnum)
+	char			name[MAX_NAME_LENGTH];			// extracted from userinfo, high bits masked
+	byte			*download;			// file being downloaded
+	int				downloadsize;		// total bytes (can't use EOF because of paks)
+	int				downloadcount;		// bytes sent
+	int				deltaMessage;		// frame last client usercmd message
+	int				lastPacketTime;		// sv.time when packet was last received
+	int				lastConnectTime;	// sv.time when connection started
+	int				nextSnapshotTime;	// send another snapshot when sv.time >= nextSnapshotTime
+	qboolean		rateDelayed;		// true if nextSnapshotTime was set based on rate instead of snapshotMsec
+	qboolean		droppedCommands;	// true if enough pakets to pass the cl_packetdup were dropped
+	int				timeoutCount;		// must timeout a few frames in a row so debugging doesn't break
+	clientSnapshot_t	frames[PACKET_BACKUP];	// updates can be delta'd from here
+	int				ping;
+	int				rate;				// bytes / second
+	int				snapshotMsec;		// requests a snapshot every snapshotMsec unless rate choked
+	netchan_t		netchan;
+} client_t;
+
+//=============================================================================
+
+
+typedef struct {
+	netadr_t	adr;
+	int			challenge;
+	int			time;
+} challenge_t;
+
+// this structure will be cleared only when the game dll changes
+typedef struct {
+	qboolean	initialized;				// sv_init has completed
+	client_t	*clients;					// [sv_maxclients->integer];
+	int			numSnapshotEntities;		// sv_maxclients->integer*PACKET_BACKUP*MAX_PACKET_ENTITIES
+	int			nextSnapshotEntities;		// next snapshotEntities to use
+	entityState_t	*snapshotEntities;		// [numSnapshotEntities]
+	int			nextHeartbeatTime;
+} serverStatic_t;
+
+//=============================================================================
+
+extern	serverStatic_t	svs;				// persistant server info across maps
+extern	server_t		sv;					// cleared each map
+
+extern	game_export_t	*ge;
+
+extern	cvar_t	*sv_fps;
+extern	cvar_t	*sv_timeout;
+extern	cvar_t	*sv_zombietime;
+extern	cvar_t	*sv_reconnectlimit;
+extern	cvar_t	*sv_showloss;
+extern	cvar_t	*sv_killserver;
+extern	cvar_t	*sv_mapname;
+extern	cvar_t	*sv_spawntarget;
+extern	cvar_t	*sv_mapChecksum;
+extern	cvar_t	*sv_serverid;
+extern  cvar_t	*sv_testsave;
+extern  cvar_t	*sv_compress_saved_games;
+
+//===========================================================
+
+//
+// sv_main.c
+//
+void SV_FinalMessage (char *message);
+void QDECL SV_SendServerCommand( client_t *cl, const char *fmt, ...);
+
+
+void SV_AddOperatorCommands (void);
+void SV_RemoveOperatorCommands (void);
+
+
+//
+// sv_init.c
+//
+void SV_SetConfigstring( int index, const char *val );
+void SV_GetConfigstring( int index, char *buffer, int bufferSize );
+
+void SV_SetUserinfo( int index, const char *val );
+void SV_GetUserinfo( int index, char *buffer, int bufferSize );
+
+void SV_SpawnServer( char *server, ForceReload_e eForceReload, qboolean bAllowScreenDissolve );
+
+
+//
+// sv_client.c
+//
+void SV_DirectConnect( netadr_t from );
+
+void SV_ExecuteClientMessage( client_t *cl, msg_t *msg );
+void SV_UserinfoChanged( client_t *cl );
+
+void SV_ClientEnterWorld( client_t *client, usercmd_t *cmd, SavedGameJustLoaded_e eSavedGameJustLoaded );
+void SV_DropClient( client_t *drop, const char *reason );
+
+void SV_ExecuteClientCommand( client_t *cl, const char *s );
+void SV_ClientThink (client_t *cl, usercmd_t *cmd);
+
+
+//
+// sv_snapshot.c
+//
+void SV_AddServerCommand( client_t *client, const char *cmd );
+void SV_SendMessageToClient( msg_t *msg, client_t *client );
+void SV_SendClientMessages( void );
+void SV_SendClientSnapshot( client_t *client );
+
+
+
+//
+// sv_game.c
+//
+gentity_t	*SV_GentityNum( int num );
+svEntity_t	*SV_SvEntityForGentity( gentity_t *gEnt );
+gentity_t	*SV_GEntityForSvEntity( svEntity_t *svEnt );
+void		SV_InitGameProgs (void);
+void		SV_ShutdownGameProgs (qboolean shutdownCin);
+qboolean	SV_inPVS (const vec3_t p1, const vec3_t p2);
+
+
+//============================================================
+//
+// high level object sorting to reduce interaction tests
+//
+
+void SV_ClearWorld (void);
+// called after the world model has been loaded, before linking any entities
+
+void SV_UnlinkEntity( gentity_t *ent );
+// call before removing an entity, and before trying to move one,
+// so it doesn't clip against itself
+
+void SV_LinkEntity( gentity_t *ent );
+// Needs to be called any time an entity changes origin, mins, maxs,
+// or solid.  Automatically unlinks if needed.
+// sets ent->v.absmin and ent->v.absmax
+// sets ent->leafnums[] for pvs determination even if the entity
+// is not solid
+
+
+clipHandle_t SV_ClipHandleForEntity( const gentity_t *ent );
+
+
+void SV_SectorList_f( void );
+
+
+int SV_AreaEntities( const vec3_t mins, const vec3_t maxs, gentity_t **elist, int maxcount );
+// fills in a table of entity pointers with entities that have bounding boxes
+// that intersect the given area.  It is possible for a non-axial bmodel
+// to be returned that doesn't actually intersect the area on an exact
+// test.
+// returns the number of pointers filled in
+// The world entity is never returned in this list.
+
+
+int SV_PointContents( const vec3_t p, int passEntityNum );
+// returns the CONTENTS_* value from the world and all entities at the given point.
+
+/*
+Ghoul2 Insert Start
+*/
+void SV_Trace( trace_t *results, const vec3_t start, const vec3_t mins, const vec3_t maxs, const vec3_t end, 
+			  const int passEntityNum, const int contentmask, const EG2_Collision eG2TraceType = G2_NOCOLLIDE, const int useLod = 0);
+/*
+Ghoul2 Insert End
+*/
+// mins and maxs are relative
+
+// if the entire move stays in a solid volume, trace.allsolid will be set,
+// trace.startsolid will be set, and trace.fraction will be 0
+
+// if the starting point is in a solid, it will be allowed to move out
+// to an open area
+
+// passEntityNum is explicitly excluded from clipping checks (normally ENTITYNUM_NONE)
+
+
+
+///////////////////////////////////////////////
+//
+// sv_savegame.cpp
+//
+void SV_LoadGame_f(void);
+void SV_LoadTransition_f(void);
+void SV_SaveGame_f(void);
+void SV_WipeGame_f(void);
+qboolean SV_TryLoadTransition( const char *mapname );
+qboolean SG_WriteSavegame(const char *psPathlessBaseName, qboolean qbAutosave);
+qboolean SG_ReadSavegame(const char *psPathlessBaseName);
+void SG_WipeSavegame(const char *psPathlessBaseName);
+qboolean SG_Append(unsigned long chid, const void *data, int length);
+int SG_Read			(unsigned long chid, void *pvAddress, int iLength, void **ppvAddressPtr = NULL);
+int SG_ReadOptional	(unsigned long chid, void *pvAddress, int iLength, void **ppvAddressPtr = NULL);
+void SG_Shutdown();
+void SG_TestSave(void);
+//
+// note that this version number does not mean that a savegame with the same version can necessarily be loaded,
+//	since anyone can change any loadsave-affecting structure somewhere in a header and change a chunk size. 
+// What it's used for is for things like mission pack etc if we need to distinguish "street-copy" savegames from
+//	any new enhanced ones that need to ask for new chunks during loading.
+//
+#define iSAVEGAME_VERSION 1
+int SG_Version(void);	// call this to know what version number a successfully-opened savegame file was
+//
+extern SavedGameJustLoaded_e eSavedGameJustLoaded;
+extern qboolean qbLoadTransition;
+//
+///////////////////////////////////////////////
+
+#endif	// #ifndef SERVER_H
diff --git a/code/server/sv_ccmds.cpp b/code/server/sv_ccmds.cpp
new file mode 100644
index 0000000..fc80491
--- /dev/null
+++ b/code/server/sv_ccmds.cpp
@@ -0,0 +1,484 @@
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+
+
+#include "server.h"
+#include "..\game\weapons.h"
+#include "..\game\g_items.h"
+#include "..\game\statindex.h"
+
+
+/*
+===============================================================================
+
+OPERATOR CONSOLE ONLY COMMANDS
+
+These commands can only be entered from stdin or by a remote operator datagram
+===============================================================================
+*/
+
+qboolean qbLoadTransition = qfalse;
+
+/*
+==================
+SV_SetPlayer
+
+Returns the player
+==================
+*/
+static client_t *SV_SetPlayer( void ) {
+	client_t	*cl;
+
+	cl = &svs.clients[0];
+	if ( !cl->state ) {
+		Com_Printf( "Client is not active\n" );
+		return NULL;
+	}
+	return cl;
+}
+
+
+//=========================================================
+// don't call this directly, it should only be called from SV_Map_f() or SV_MapTransition_f()
+//
+static void SV_Map_( ForceReload_e eForceReload ) 
+{
+	char	*map;
+	char	expanded[MAX_QPATH];
+
+	map = Cmd_Argv(1);
+	if ( !*map ) {
+		return;
+	}
+
+	// make sure the level exists before trying to change, so that
+	// a typo at the server console won't end the game
+	if (strchr (map, '\\') ) {
+		Com_Printf ("Can't have mapnames with a \\\n");
+		return;
+	}
+
+#ifndef _XBOX	// Could check for maps/%s/brushes.mle or something...
+	Com_sprintf (expanded, sizeof(expanded), "maps/%s.bsp", map);
+	if ( FS_ReadFile (expanded, NULL) == -1 ) {
+		Com_Printf ("Can't find map %s\n", expanded);
+		extern	cvar_t	*com_buildScript;
+		if (com_buildScript && com_buildScript->integer)
+		{//yes, it's happened, someone deleted a map during my build...
+			Com_Error( ERR_FATAL, "Can't find map %s\n", expanded );
+		}
+		return;
+	}
+#endif
+
+	if (map[0]!='_')
+	{
+		SG_WipeSavegame("auto");
+	}
+
+	SV_SpawnServer( map, eForceReload, qtrue );	// start up the map
+}
+
+
+
+// Save out some player data for later restore if this is a spawn point with KEEP_PREV (spawnflags&1) set...	
+//
+// (now also called by auto-save code to setup the cvars correctly
+void SV_Player_EndOfLevelSave(void)						   
+{
+	int	i;	
+
+	// I could just call GetClientState() but that's in sv_bot.cpp, and I'm not sure if that's going to be deleted for
+	//	the single player build, so here's the guts again...
+	//
+	client_t* cl = &svs.clients[0];	// 0 because only ever us as a player	
+
+	if (cl 
+		&&
+		cl->gentity && cl->gentity->client	// crash fix for voy4->brig transition when you kill Foster. 
+											//	Shouldn't happen, but does sometimes...
+		)
+	{
+		Cvar_Set( sCVARNAME_PLAYERSAVE, "");	// default to blank
+
+//		clientSnapshot_t*	pFrame = &cl->frames[cl->netchan.outgoingSequence & PACKET_MASK];
+		playerState_t*		pState = cl->gentity->client;
+		const char	*s2;
+			//				|general info				  |-force powers |-saber 1										   |-saber 2										  |-general saber
+		const char *s = va("%i %i %i %i %i %i %i %f %f %f %i %i %i %i %i %s %i %i %i %i %i %i %i %i %i %i %i %i %i %i %i %i %s %i %i %i %i %i %i %i %i %i %i %i %i %i %i %i %i %i %i %i %i",
+							pState->stats[STAT_HEALTH],
+							pState->stats[STAT_ARMOR],
+							pState->stats[STAT_WEAPONS],
+							pState->stats[STAT_ITEMS],
+							pState->weapon,
+							pState->weaponstate,
+							pState->batteryCharge,
+							pState->viewangles[0],
+							pState->viewangles[1],
+							pState->viewangles[2],
+							//force power data
+							pState->forcePowersKnown,
+							pState->forcePower,
+							pState->forcePowerMax,
+							pState->forcePowerRegenRate,
+							pState->forcePowerRegenAmount,
+							//saber 1 data
+							pState->saber[0].name,
+							pState->saber[0].blade[0].active,
+							pState->saber[0].blade[1].active,
+							pState->saber[0].blade[2].active,
+							pState->saber[0].blade[3].active,
+							pState->saber[0].blade[4].active,
+							pState->saber[0].blade[5].active,
+							pState->saber[0].blade[6].active,
+							pState->saber[0].blade[7].active,
+							pState->saber[0].blade[0].color,
+							pState->saber[0].blade[1].color,
+							pState->saber[0].blade[2].color,
+							pState->saber[0].blade[3].color,
+							pState->saber[0].blade[4].color,
+							pState->saber[0].blade[5].color,
+							pState->saber[0].blade[6].color,
+							pState->saber[0].blade[7].color,
+							//saber 2 data
+							pState->saber[1].name,
+							pState->saber[1].blade[0].active,
+							pState->saber[1].blade[1].active,
+							pState->saber[1].blade[2].active,
+							pState->saber[1].blade[3].active,
+							pState->saber[1].blade[4].active,
+							pState->saber[1].blade[5].active,
+							pState->saber[1].blade[6].active,
+							pState->saber[1].blade[7].active,
+							pState->saber[1].blade[0].color,
+							pState->saber[1].blade[1].color,
+							pState->saber[1].blade[2].color,
+							pState->saber[1].blade[3].color,
+							pState->saber[1].blade[4].color,
+							pState->saber[1].blade[5].color,
+							pState->saber[1].blade[6].color,
+							pState->saber[1].blade[7].color,
+							//general saber data
+							pState->saberStylesKnown,
+							pState->saberAnimLevel,
+							pState->saberLockEnemy,
+							pState->saberLockTime
+							);
+		Cvar_Set( sCVARNAME_PLAYERSAVE, s );
+
+		//ammo
+		s2 = "";
+		for (i=0;i< AMMO_MAX; i++)
+		{
+			s2 = va("%s %i",s2, pState->ammo[i]);
+		}
+		Cvar_Set( "playerammo", s2 );
+
+		//inventory
+		s2 = "";
+		for (i=0;i< INV_MAX; i++)
+		{
+			s2 = va("%s %i",s2, pState->inventory[i]);
+		}
+		Cvar_Set( "playerinv", s2 );
+
+		// the new JK2 stuff - force powers, etc...
+		//
+		s2 = "";
+		for (i=0;i< NUM_FORCE_POWERS; i++)
+		{
+			s2 = va("%s %i",s2, pState->forcePowerLevel[i]);
+		}
+		Cvar_Set( "playerfplvl", s2 );
+	}
+}
+
+
+// Restart the server on a different map
+//
+//extern void	SCR_PrecacheScreenshot();  //scr_scrn.cpp
+static void SV_MapTransition_f(void)
+{		
+	char	*spawntarget;
+
+//	SCR_PrecacheScreenshot();
+	SV_Player_EndOfLevelSave();
+
+	spawntarget = Cmd_Argv(2);
+	if ( *spawntarget != NULL ) 
+	{
+		Cvar_Set( "spawntarget", spawntarget );
+	}
+	else
+	{
+		Cvar_Set( "spawntarget", "" );
+	}
+
+	SV_Map_( eForceReload_NOTHING );
+}
+
+/*
+==================
+SV_Map_f
+
+Restart the server on a different map, but clears a cvar so that typing "map blah" doesn't try and preserve
+player weapons/ammo/etc from the previous level that you haven't really exited (ie ignores KEEP_PREV on spawn points)
+==================
+*/
+//void SCR_UnprecacheScreenshot();	//scr_scrn.cpp
+static void SV_Map_f( void ) 
+{
+	Cvar_Set( sCVARNAME_PLAYERSAVE, "");
+	Cvar_Set( "spawntarget", "" );
+	Cvar_Set("tier_storyinfo", "0");
+	Cvar_Set("tiers_complete", "");
+//	SCR_UnprecacheScreenshot();
+
+	ForceReload_e eForceReload = eForceReload_NOTHING;	// default for normal load
+
+	if ( !Q_stricmp( Cmd_Argv(0), "devmapbsp") ) {
+		eForceReload = eForceReload_BSP;
+	}
+	else
+	if ( !Q_stricmp( Cmd_Argv(0), "devmapmdl") ) {
+		eForceReload = eForceReload_MODELS;
+	}
+	else
+	if ( !Q_stricmp( Cmd_Argv(0), "devmapall") ) {
+		eForceReload = eForceReload_ALL;
+	}
+
+	SV_Map_( eForceReload );
+
+	// set the cheat value
+	// if the level was started with "map <levelname>", then
+	// cheats will not be allowed.  If started with "devmap <levelname>"
+	// then cheats will be allowed
+	if ( !Q_stricmpn( Cmd_Argv(0), "devmap", 6 ) ) {
+		Cvar_Set( "helpUsObi", "1" );
+	} else {
+#ifdef _XBOX
+		Cvar_Set( "helpUsObi", "1" );
+#else
+		Cvar_Set( "helpUsObi", "0" );
+#endif
+	}
+}
+
+/*
+==================
+SV_LoadTransition_f
+==================
+*/
+void SV_LoadTransition_f(void)
+{
+	char	*map;
+	char	*spawntarget;
+
+	map = Cmd_Argv(1);
+	if ( !*map ) {
+		return;
+	}
+
+	qbLoadTransition = qtrue;
+
+//	SCR_PrecacheScreenshot();
+	SV_Player_EndOfLevelSave();
+
+	//Save the full current state of the current map so we can return to it later
+	SG_WriteSavegame( va("hub/%s", sv_mapname->string), qfalse );
+
+	//set the spawntarget if there is one
+	spawntarget = Cmd_Argv(2);
+	if ( *spawntarget != NULL ) 
+	{
+		Cvar_Set( "spawntarget", spawntarget );
+	}
+	else
+	{
+		Cvar_Set( "spawntarget", "" );
+	}
+
+	if ( !SV_TryLoadTransition( map ) )
+	{//couldn't load a savegame
+		SV_Map_( eForceReload_NOTHING );
+	}
+	qbLoadTransition = qfalse;
+}
+//===============================================================
+
+/*
+================
+SV_Status_f
+================
+*/
+static void SV_Status_f( void ) {
+	int			i, j, l;
+	client_t	*cl;
+	const char		*s;
+	int			ping;
+
+	// make sure server is running
+	if ( !com_sv_running->integer ) {
+		Com_Printf( "Server is not running.\n" );
+		return;
+	}
+
+	Com_Printf ("map: %s\n", sv_mapname->string );
+
+	Com_Printf ("num score ping name            lastmsg address               qport rate\n");
+	Com_Printf ("--- ----- ---- --------------- ------- --------------------- ----- -----\n");
+	for (i=0,cl=svs.clients ; i < 1 ; i++,cl++)
+	{
+		if (!cl->state)
+			continue;
+		Com_Printf ("%3i ", i);
+		Com_Printf ("%5i ", cl->gentity->client->persistant[PERS_SCORE]);
+
+		if (cl->state == CS_CONNECTED)
+			Com_Printf ("CNCT ");
+		else if (cl->state == CS_ZOMBIE)
+			Com_Printf ("ZMBI ");
+		else
+		{
+			ping = cl->ping < 9999 ? cl->ping : 9999;
+			Com_Printf ("%4i ", ping);
+		}
+
+		Com_Printf ("%s", cl->name);
+		l = 16 - strlen(cl->name);
+		for (j=0 ; j<l ; j++)
+			Com_Printf (" ");
+
+		Com_Printf ("%7i ", sv.time - cl->lastPacketTime );
+
+		s = NET_AdrToString( cl->netchan.remoteAddress );
+		Com_Printf ("%s", s);
+		l = 22 - strlen(s);
+		for (j=0 ; j<l ; j++)
+			Com_Printf (" ");
+		
+		Com_Printf ("%5i", cl->netchan.qport);
+
+		Com_Printf (" %5i", cl->rate);
+
+		Com_Printf ("\n");
+	}
+	Com_Printf ("\n");
+}
+
+/*
+===========
+SV_Serverinfo_f
+
+Examine the serverinfo string
+===========
+*/
+static void SV_Serverinfo_f( void ) {
+	Com_Printf ("Server info settings:\n");
+	Info_Print ( Cvar_InfoString( CVAR_SERVERINFO ) );
+}
+
+
+/*
+===========
+SV_Systeminfo_f
+
+Examine or change the serverinfo string
+===========
+*/
+static void SV_Systeminfo_f( void ) {
+	Com_Printf ("System info settings:\n");
+	Info_Print ( Cvar_InfoString( CVAR_SYSTEMINFO ) );
+}
+
+
+/*
+===========
+SV_DumpUser_f
+
+Examine all a users info strings FIXME: move to game
+===========
+*/
+static void SV_DumpUser_f( void ) {
+	client_t	*cl;
+
+	// make sure server is running
+	if ( !com_sv_running->integer ) {
+		Com_Printf( "Server is not running.\n" );
+		return;
+	}
+
+	if ( Cmd_Argc() != 2 ) {
+		Com_Printf ("Usage: info <userid>\n");
+		return;
+	}
+
+	cl = SV_SetPlayer();
+	if ( !cl ) {
+		return;
+	}
+
+	Com_Printf( "userinfo\n" );
+	Com_Printf( "--------\n" );
+	Info_Print( cl->userinfo );
+}
+
+//===========================================================
+
+/*
+==================
+SV_AddOperatorCommands
+==================
+*/
+void SV_AddOperatorCommands( void ) {
+	static qboolean	initialized;
+
+	if ( initialized ) {
+		return;
+	}
+	initialized = qtrue;
+
+	Cmd_AddCommand ("status", SV_Status_f);
+	Cmd_AddCommand ("serverinfo", SV_Serverinfo_f);
+	Cmd_AddCommand ("systeminfo", SV_Systeminfo_f);
+	Cmd_AddCommand ("dumpuser", SV_DumpUser_f);
+	Cmd_AddCommand ("sectorlist", SV_SectorList_f);
+	Cmd_AddCommand ("map", SV_Map_f);
+	Cmd_AddCommand ("devmap", SV_Map_f);
+	Cmd_AddCommand ("devmapbsp", SV_Map_f);
+	Cmd_AddCommand ("devmapmdl", SV_Map_f);
+	Cmd_AddCommand ("devmapsnd", SV_Map_f);
+	Cmd_AddCommand ("devmapall", SV_Map_f);
+	Cmd_AddCommand ("maptransition", SV_MapTransition_f);
+	Cmd_AddCommand ("load", SV_LoadGame_f);
+	Cmd_AddCommand ("loadtransition", SV_LoadTransition_f);
+	Cmd_AddCommand ("save", SV_SaveGame_f);
+	Cmd_AddCommand ("wipe", SV_WipeGame_f);
+
+//#ifdef _DEBUG
+//	extern void UI_Dump_f(void);
+//	Cmd_AddCommand ("ui_dump", UI_Dump_f);
+//#endif
+}
+
+/*
+==================
+SV_RemoveOperatorCommands
+==================
+*/
+void SV_RemoveOperatorCommands( void ) {
+#if 0
+	// removing these won't let the server start again
+	Cmd_RemoveCommand ("status");
+	Cmd_RemoveCommand ("serverinfo");
+	Cmd_RemoveCommand ("systeminfo");
+	Cmd_RemoveCommand ("dumpuser");
+	Cmd_RemoveCommand ("serverrecord");
+	Cmd_RemoveCommand ("serverstop");
+	Cmd_RemoveCommand ("sectorlist");
+#endif
+}
+
diff --git a/code/server/sv_client.cpp b/code/server/sv_client.cpp
new file mode 100644
index 0000000..9543660
--- /dev/null
+++ b/code/server/sv_client.cpp
@@ -0,0 +1,605 @@
+// sv_client.c -- server code for dealing with clients
+
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+
+
+
+#include "server.h"
+
+/*
+==================
+SV_DirectConnect
+
+A "connect" OOB command has been received
+==================
+*/
+void SV_DirectConnect( netadr_t from ) {
+	char		userinfo[MAX_INFO_STRING];
+	int			i;
+	client_t	*cl, *newcl;
+	MAC_STATIC client_t	temp;
+	gentity_t		*ent;
+	int			clientNum;
+	int			version;
+	int			qport;
+	int			challenge;
+	char		*denied;
+
+	Com_DPrintf ("SVC_DirectConnect ()\n");
+
+	Q_strncpyz( userinfo, Cmd_Argv(1), sizeof(userinfo) );
+
+	version = atoi( Info_ValueForKey( userinfo, "protocol" ) );
+	if ( version != PROTOCOL_VERSION ) {
+		NET_OutOfBandPrint( NS_SERVER, from, "print\nServer uses protocol version %i.\n", PROTOCOL_VERSION );
+		Com_DPrintf ("    rejected connect from version %i\n", version);
+		return;
+	}
+
+	qport = atoi( Info_ValueForKey( userinfo, "qport" ) );
+
+	challenge = atoi( Info_ValueForKey( userinfo, "challenge" ) );
+
+	// see if the challenge is valid (local clients don't need to challenge)
+	if ( !NET_IsLocalAddress (from) ) {
+		NET_OutOfBandPrint( NS_SERVER, from, "print\nNo challenge for address.\n" );
+		return;
+	} else {
+		// force the "ip" info key to "localhost"
+		Info_SetValueForKey( userinfo, "ip", "localhost" );
+	}
+
+	newcl = &temp;
+	memset (newcl, 0, sizeof(client_t));
+
+	// if there is already a slot for this ip, reuse it
+	for (i=0,cl=svs.clients ; i < 1 ; i++,cl++)
+	{
+		if ( cl->state == CS_FREE ) {
+			continue;
+		}
+		if ( NET_CompareBaseAdr( from, cl->netchan.remoteAddress )
+			&& ( cl->netchan.qport == qport 
+			|| from.port == cl->netchan.remoteAddress.port ) )
+		{
+			if (( sv.time - cl->lastConnectTime) 
+				< (sv_reconnectlimit->integer * 1000))
+			{
+				Com_DPrintf ("%s:reconnect rejected : too soon\n", NET_AdrToString (from));
+				return;
+			}
+			Com_Printf ("%s:reconnect\n", NET_AdrToString (from));
+			newcl = cl;
+			goto gotnewcl;
+		}
+	}
+
+
+	newcl = NULL;
+	for ( i = 0; i < 1 ; i++ ) {
+		cl = &svs.clients[i];
+		if (cl->state == CS_FREE) {
+			newcl = cl;
+			break;
+		}
+	}
+
+	if ( !newcl ) {
+		NET_OutOfBandPrint( NS_SERVER, from, "print\nServer is full.\n" );
+		Com_DPrintf ("Rejected a connection.\n");
+		return;
+	}
+
+gotnewcl:	
+	// build a new connection
+	// accept the new client
+	// this is the only place a client_t is ever initialized
+	*newcl = temp;
+	clientNum = newcl - svs.clients;
+	ent = SV_GentityNum( clientNum );
+	newcl->gentity = ent;
+
+	// save the address
+	Netchan_Setup (NS_SERVER, &newcl->netchan , from, qport);
+
+	// save the userinfo
+	Q_strncpyz( newcl->userinfo, userinfo, sizeof(newcl->userinfo) );
+
+	// get the game a chance to reject this connection or modify the userinfo
+	denied = ge->ClientConnect( clientNum, qtrue, eSavedGameJustLoaded ); // firstTime = qtrue
+	if ( denied ) {
+		NET_OutOfBandPrint( NS_SERVER, from, "print\n%s\n", denied );
+		Com_DPrintf ("Game rejected a connection: %s.\n", denied);
+		return;
+	}
+
+	SV_UserinfoChanged( newcl );
+
+	// send the connect packet to the client
+	NET_OutOfBandPrint( NS_SERVER, from, "connectResponse" );
+
+	newcl->state = CS_CONNECTED;
+	newcl->nextSnapshotTime = sv.time;
+	newcl->lastPacketTime = sv.time;
+	newcl->lastConnectTime = sv.time;
+
+	// when we receive the first packet from the client, we will
+	// notice that it is from a different serverid and that the
+	// gamestate message was not just sent, forcing a retransmit
+	newcl->gamestateMessageNum = -1;
+}
+
+
+/*
+=====================
+SV_DropClient
+
+Called when the player is totally leaving the server, either willingly
+or unwillingly.  This is NOT called if the entire server is quiting
+or crashing -- SV_FinalMessage() will handle that
+=====================
+*/
+void SV_DropClient( client_t *drop, const char *reason ) {
+	if ( drop->state == CS_ZOMBIE ) {
+		return;		// already dropped
+	}
+	drop->state = CS_ZOMBIE;		// become free in a few seconds
+
+	if (drop->download)	{
+		FS_FreeFile (drop->download);
+		drop->download = NULL;
+	}
+
+	// call the prog function for removing a client
+	// this will remove the body, among other things
+	ge->ClientDisconnect( drop - svs.clients );
+
+	// tell everyone why they got dropped
+	SV_SendServerCommand( NULL, "print \"%s %s\n\"", drop->name, reason );
+
+	// add the disconnect command
+	SV_SendServerCommand( drop, "disconnect" );
+}
+
+/*
+================
+SV_SendClientGameState
+
+Sends the first message from the server to a connected client.
+This will be sent on the initial connection and upon each new map load.
+
+It will be resent if the client acknowledges a later message but has
+the wrong gamestate.
+================
+*/
+void SV_SendClientGameState( client_t *client ) {
+	int			start;
+	msg_t		msg;
+	byte		msgBuffer[MAX_MSGLEN];
+
+	Com_DPrintf ("SV_SendGameState() for %s\n", client->name);
+	client->state = CS_PRIMED;
+
+	// when we receive the first packet from the client, we will
+	// notice that it is from a different serverid and that the
+	// gamestate message was not just sent, forcing a retransmit
+	client->gamestateMessageNum = client->netchan.outgoingSequence;
+
+	// clear the reliable message list for this client
+	client->reliableSequence = 0;
+	client->reliableAcknowledge = 0;
+
+	MSG_Init( &msg, msgBuffer, sizeof( msgBuffer ) );
+
+	// send the gamestate
+	MSG_WriteByte( &msg, svc_gamestate );
+	MSG_WriteLong( &msg, client->reliableSequence );
+
+	// write the configstrings
+	for ( start = 0 ; start < MAX_CONFIGSTRINGS ; start++ ) {
+		if (sv.configstrings[start][0]) {
+			MSG_WriteByte( &msg, svc_configstring );
+			MSG_WriteShort( &msg, start );
+			MSG_WriteString( &msg, sv.configstrings[start] );
+		}
+	}
+
+	MSG_WriteByte( &msg, 0 );
+
+	// check for overflow
+	if ( msg.overflowed ) {
+		Com_Printf ("WARNING: GameState overflowed for %s\n", client->name);
+	}
+
+	// deliver this to the client
+	SV_SendMessageToClient( &msg, client );
+}
+
+
+/*
+==================
+SV_ClientEnterWorld
+==================
+*/
+void SV_ClientEnterWorld( client_t *client, usercmd_t *cmd, SavedGameJustLoaded_e eSavedGameJustLoaded ) {
+	int		clientNum;
+	gentity_t	*ent;
+
+	Com_DPrintf ("SV_ClientEnterWorld() from %s\n", client->name);
+	client->state = CS_ACTIVE;
+
+	// set up the entity for the client
+	clientNum = client - svs.clients;
+	ent = SV_GentityNum( clientNum );
+	ent->s.number = clientNum;
+	client->gentity = ent;
+
+	// normally I check 'qbFromSavedGame' to avoid overwriting loaded client data, but this stuff I want
+	//	to be reset so that client packet delta-ing bgins afresh, rather than based on your previous frame 
+	//	(which didn't in fact happen now if we've just loaded from a saved game...)
+	//
+	client->deltaMessage = -1;
+	client->cmdNum = 0;
+	client->nextSnapshotTime = sv.time;	// generate a snapshot immediately
+
+	// call the game begin function
+	ge->ClientBegin( client - svs.clients, cmd, eSavedGameJustLoaded );
+}
+
+/*
+============================================================
+
+CLIENT COMMAND EXECUTION
+
+============================================================
+*/
+
+
+/*
+=================
+SV_Disconnect_f
+
+The client is going to disconnect, so remove the connection immediately  FIXME: move to game?
+=================
+*/
+static void SV_Disconnect_f( client_t *cl ) {
+	SV_DropClient( cl, "disconnected" );
+}
+
+
+
+/*
+=================
+SV_UserinfoChanged
+
+Pull specific info from a newly changed userinfo string
+into a more C friendly form.
+=================
+*/
+void SV_UserinfoChanged( client_t *cl ) {
+	char	*val;
+	int		i;
+
+	// name for C code
+	Q_strncpyz( cl->name, Info_ValueForKey (cl->userinfo, "name"), sizeof(cl->name) );
+
+	// rate command
+
+	// if the client is on the same subnet as the server and we aren't running an
+	// internet public server, assume they don't need a rate choke
+	cl->rate = 99999;	// lans should not rate limit
+
+	// snaps command
+	val = Info_ValueForKey (cl->userinfo, "snaps");
+	if (strlen(val)) {
+		i = atoi(val);
+		if ( i < 1 ) {
+			i = 1;
+		} else if ( i > 30 ) {
+			i = 30;
+		}
+		cl->snapshotMsec = 1000/i;
+	} else {
+		cl->snapshotMsec = 50;
+	}
+}
+
+
+/*
+==================
+SV_UpdateUserinfo_f
+==================
+*/
+static void SV_UpdateUserinfo_f( client_t *cl ) {
+	Q_strncpyz( cl->userinfo, Cmd_Argv(1), sizeof(cl->userinfo) );
+
+	// call prog code to allow overrides
+	ge->ClientUserinfoChanged( cl - svs.clients );
+	
+	SV_UserinfoChanged( cl );
+}
+
+typedef struct {
+	char	*name;
+	void	(*func)( client_t *cl );
+} ucmd_t;
+
+static ucmd_t ucmds[] = {
+	{"userinfo", SV_UpdateUserinfo_f},
+	{"disconnect", SV_Disconnect_f},
+
+	{NULL, NULL}
+};
+
+/*
+==================
+SV_ExecuteClientCommand
+==================
+*/
+void SV_ExecuteClientCommand( client_t *cl, const char *s ) {
+	ucmd_t	*u;
+	
+	Cmd_TokenizeString( s );
+
+	// see if it is a server level command
+	for (u=ucmds ; u->name ; u++) {
+		if (!strcmp (Cmd_Argv(0), u->name) ) {
+			u->func( cl );
+			break;
+		}
+	}
+
+	// pass unknown strings to the game
+	if (!u->name && sv.state == SS_GAME) {
+		ge->ClientCommand( cl - svs.clients );
+	}
+}
+
+#define	MAX_STRINGCMDS	8
+
+/*
+===============
+SV_ClientCommand
+===============
+*/
+static void SV_ClientCommand( client_t *cl, msg_t *msg ) {
+	int		seq;
+	const char	*s;
+
+	seq = MSG_ReadLong( msg );
+	s = MSG_ReadString( msg );
+
+	// see if we have already executed it
+	if ( cl->lastClientCommand >= seq ) {
+		return;
+	}
+
+	Com_DPrintf( "clientCommand: %s : %i : %s\n", cl->name, seq, s );
+
+	// drop the connection if we have somehow lost commands
+	if ( seq > cl->lastClientCommand + 1 ) {
+		Com_Printf( "Client %s lost %i clientCommands\n", cl->name, 
+			seq - cl->lastClientCommand + 1 );
+	}
+
+	SV_ExecuteClientCommand( cl, s );
+
+	cl->lastClientCommand = seq;
+}
+
+
+//==================================================================================
+
+
+/*
+==================
+SV_ClientThink
+==================
+*/
+void SV_ClientThink (client_t *cl, usercmd_t *cmd) {
+	cl->lastUsercmd = *cmd;
+
+	if ( cl->state != CS_ACTIVE ) {
+		return;		// may have been kicked during the last usercmd
+	}
+
+	ge->ClientThink( cl - svs.clients, cmd );
+}
+
+/*
+==================
+SV_UserMove
+
+The message usually contains all the movement commands 
+that were in the last three packets, so that the information
+in dropped packets can be recovered.
+
+On very fast clients, there may be multiple usercmd packed into
+each of the backup packets.
+==================
+*/
+static void SV_UserMove( client_t *cl, msg_t *msg ) {
+	int			i, start;
+	int			cmdNum;
+	int			firstNum;
+	int			cmdCount;
+	usercmd_t	nullcmd;
+	usercmd_t	cmds[MAX_PACKET_USERCMDS];
+	usercmd_t	*cmd, *oldcmd;
+	int			clientTime;
+	int			serverId;
+
+	cl->reliableAcknowledge = MSG_ReadLong( msg );
+	serverId = MSG_ReadLong( msg );
+	clientTime = MSG_ReadLong( msg );
+	cl->deltaMessage = MSG_ReadLong( msg );
+
+	// cmdNum is the command number of the most recent included usercmd
+	cmdNum = MSG_ReadLong( msg );
+	cmdCount = MSG_ReadByte( msg );
+
+	if ( cmdCount < 1 ) {
+		Com_Printf( "cmdCount < 1\n" );
+		return;
+	}
+
+	if ( cmdCount > MAX_PACKET_USERCMDS ) {
+		Com_Printf( "cmdCount > MAX_PACKET_USERCMDS\n" );
+		return;
+	}
+
+	memset( &nullcmd, 0, sizeof(nullcmd) );
+	oldcmd = &nullcmd;
+	for ( i = 0 ; i < cmdCount ; i++ ) {
+		cmd = &cmds[i];
+		MSG_ReadDeltaUsercmd( msg, oldcmd, cmd );
+		oldcmd = cmd;
+	}
+
+	// if this is a usercmd from a previous gamestate,
+	// ignore it or retransmit the current gamestate
+	if ( serverId != sv.serverId ) {
+		// if we can tell that the client has dropped the last
+		// gamestate we sent them, resend it
+		if ( cl->netchan.incomingAcknowledged > cl->gamestateMessageNum ) {
+			Com_DPrintf( "%s : dropped gamestate, resending\n", cl->name );
+			SV_SendClientGameState( cl );
+		}
+		return;
+	}
+
+	// if this is the first usercmd we have received
+	// this gamestate, put the client into the world
+	if ( cl->state == CS_PRIMED ) {
+
+		SV_ClientEnterWorld( cl, &cmds[0], eSavedGameJustLoaded );
+#ifndef _XBOX	// No auto-saving for now?
+		if ( sv_mapname->string[0]!='_' )
+		{
+			char savename[MAX_QPATH];
+			if ( eSavedGameJustLoaded == eNO )
+			{
+				SG_WriteSavegame("auto",qtrue);
+				if ( strnicmp(sv_mapname->string, "academy", 7) != 0)
+				{
+					Com_sprintf (savename, sizeof(savename), "auto_%s",sv_mapname->string);
+					SG_WriteSavegame(savename,qtrue);//can't use va becuase it's nested
+				}
+			}
+			else if ( qbLoadTransition == qtrue )
+			{
+				Com_sprintf (savename, sizeof(savename), "hub/%s", sv_mapname->string );
+				SG_WriteSavegame( savename, qfalse );//save a full one
+				SG_WriteSavegame( "auto", qfalse );//need a copy for auto, too
+			}
+		}
+#endif
+		eSavedGameJustLoaded = eNO;
+		// the moves can be processed normaly
+	}
+
+	if ( cl->state != CS_ACTIVE ) {
+		cl->deltaMessage = -1;
+		return;
+	}
+
+
+	// if there is a time gap from the last packet to this packet,
+	// fill in with the first command in the packet
+
+	// with a packetdup of 0, firstNum == cmdNum
+	firstNum = cmdNum - ( cmdCount - 1 );
+	if ( cl->cmdNum < firstNum - 1 ) {
+		cl->droppedCommands = qtrue; 
+		if ( sv_showloss->integer ) {
+			Com_Printf("Lost %i usercmds from %s\n", firstNum - 1 - cl->cmdNum,
+				cl->name);
+		}
+		if ( cl->cmdNum < firstNum - 6 ) {
+			cl->cmdNum = firstNum - 6;		// don't generate too many
+		}
+		while ( cl->cmdNum < firstNum - 1 ) {
+			cl->cmdNum++;
+			SV_ClientThink( cl, &cmds[0] );
+		}
+	}
+	// skip over any usercmd_t we have already executed
+	start = cl->cmdNum - ( firstNum - 1 );
+	for ( i =  start ; i < cmdCount ; i++ ) {
+		SV_ClientThink (cl, &cmds[ i ]);
+	}
+	cl->cmdNum = cmdNum;
+
+}
+
+
+/*
+===========================================================================
+
+USER CMD EXECUTION
+
+===========================================================================
+*/
+
+/*
+===================
+SV_ExecuteClientMessage
+
+Parse a client packet
+===================
+*/
+void SV_ExecuteClientMessage( client_t *cl, msg_t *msg ) {
+	int			c;
+
+	while( 1 ) {
+		if ( msg->readcount > msg->cursize ) {
+			SV_DropClient (cl, "had a badread");
+			return;
+		}	
+
+		c = MSG_ReadByte( msg );
+		if ( c == -1 ) {
+			break;
+		}
+				
+		switch( c ) {
+		default:
+			SV_DropClient( cl,"had an unknown command char" );
+			return;
+						
+		case clc_nop:
+			break;
+
+		case clc_move:
+			SV_UserMove( cl, msg );
+			break;
+
+		case clc_clientCommand:
+			SV_ClientCommand( cl, msg );
+			if (cl->state == CS_ZOMBIE) {
+				return;	// disconnect command
+			}
+			break;
+		}
+	}
+}
+
+
+void SV_FreeClient(client_t *client)
+{
+	int i;
+
+	if (!client) return;
+
+	for(i=0; i<MAX_RELIABLE_COMMANDS; i++) {
+		if ( client->reliableCommands[ i] ) {
+			Z_Free( client->reliableCommands[ i] );
+			client->reliableCommands[i] = NULL;
+			client->reliableSequence = 0;
+		}
+	}
+}
+
diff --git a/code/server/sv_game.cpp b/code/server/sv_game.cpp
new file mode 100644
index 0000000..5f961c5
--- /dev/null
+++ b/code/server/sv_game.cpp
@@ -0,0 +1,715 @@
+// sv_game.c -- interface to the game dll
+
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+#include "../RMG/RM_Headers.h"
+
+#include "../qcommon/cm_local.h"
+
+#include "server.h"
+#include "..\client\vmachine.h"
+#include "..\client\client.h"
+#include "..\renderer\tr_local.h"
+#include "..\renderer\tr_WorldEffects.h"
+/*
+Ghoul2 Insert Start
+*/
+#if !defined(G2_H_INC)
+	#include "..\ghoul2\G2.h"
+#endif
+
+/*
+Ghoul2 Insert End
+*/
+
+//prototypes
+extern void	Sys_UnloadGame( void );
+extern void	*Sys_GetGameAPI( void *parms);
+extern void Com_WriteCam ( const char *text );
+extern void Com_FlushCamFile();
+
+#ifdef _XBOX
+extern int	*s_entityWavVol;
+#else
+extern int	s_entityWavVol[MAX_GENTITIES];
+#endif
+
+
+// these functions must be used instead of pointer arithmetic, because
+// the game allocates gentities with private information after the server shared part
+/*
+int	SV_NumForGentity( gentity_t *ent ) {
+	int		num;
+
+	num = ( (byte *)ent - (byte *)ge->gentities ) / ge->gentitySize;
+
+	return num;
+}
+*/
+gentity_t	*SV_GentityNum( int num ) {
+	gentity_t	*ent;
+
+	assert (num >=0);
+	ent = (gentity_t *)((byte *)ge->gentities + ge->gentitySize*(num));
+
+	return ent;
+}
+
+svEntity_t	*SV_SvEntityForGentity( gentity_t *gEnt ) {
+	if ( !gEnt || gEnt->s.number < 0 || gEnt->s.number >= MAX_GENTITIES ) {
+		Com_Error( ERR_DROP, "SV_SvEntityForGentity: bad gEnt" );
+	}
+	return &sv.svEntities[ gEnt->s.number ];
+}
+
+gentity_t	*SV_GEntityForSvEntity( svEntity_t *svEnt ) {
+	int		num;
+
+	num = svEnt - sv.svEntities;
+	return SV_GentityNum( num );
+}
+
+/*
+===============
+SV_GameSendServerCommand
+
+Sends a command string to a client
+===============
+*/
+void SV_GameSendServerCommand( int clientNum, const char *fmt, ... ) {
+	char		msg[8192];
+	va_list		argptr;
+	
+	va_start (argptr,fmt);
+	vsprintf (msg, fmt, argptr);
+	va_end (argptr);
+
+	if ( clientNum == -1 ) {
+		SV_SendServerCommand( NULL, "%s", msg );
+	} else {
+		if ( clientNum < 0 || clientNum >= 1 ) {
+			return;
+		}
+		SV_SendServerCommand( svs.clients + clientNum, "%s", msg );	
+	}
+}
+
+
+/*
+===============
+SV_GameDropClient
+
+Disconnects the client with a message
+===============
+*/
+void SV_GameDropClient( int clientNum, const char *reason ) {
+	if ( clientNum < 0 || clientNum >= 1 ) {
+		return;
+	}
+	SV_DropClient( svs.clients + clientNum, reason );	
+}
+
+
+/*
+=================
+SV_SetBrushModel
+
+sets mins and maxs for inline bmodels
+=================
+*/
+void SV_SetBrushModel( gentity_t *ent, const char *name ) {
+	clipHandle_t	h;
+	vec3_t			mins, maxs;
+
+	if (!name) 
+	{
+		Com_Error( ERR_DROP, "SV_SetBrushModel: NULL model for ent number %d", ent->s.number );
+	}
+
+	if (name[0] == '*')
+	{
+		ent->s.modelindex = atoi( name + 1 );
+
+		if (sv.mLocalSubBSPIndex != -1)
+		{
+			ent->s.modelindex += sv.mLocalSubBSPModelOffset;
+		}
+
+		h = CM_InlineModel( ent->s.modelindex );
+
+		if (sv.mLocalSubBSPIndex != -1)
+		{
+			CM_ModelBounds( SubBSP[sv.mLocalSubBSPIndex], h, mins, maxs );
+		}
+		else
+		{
+			CM_ModelBounds( cmg, h, mins, maxs);
+		}
+
+		//CM_ModelBounds( h, mins, maxs );
+
+		VectorCopy (mins, ent->mins);
+		VectorCopy (maxs, ent->maxs);
+		ent->bmodel = qtrue;
+
+		if (0) //com_RMG && com_RMG->integer //fixme: this test really should be do we have bsp instances
+		{
+			ent->contents = CM_ModelContents( h, sv.mLocalSubBSPIndex );
+		}
+		else
+		{
+			ent->contents = CM_ModelContents( h, -1 );
+		}
+	}
+	else if (name[0] == '#')
+	{
+		ent->s.modelindex = CM_LoadSubBSP(va("maps/%s.bsp", name + 1), qfalse);
+		CM_ModelBounds( SubBSP[CM_FindSubBSP(ent->s.modelindex)], ent->s.modelindex, mins, maxs );
+
+		VectorCopy (mins, ent->mins);
+		VectorCopy (maxs, ent->maxs);
+		ent->bmodel = qtrue;
+
+		//rwwNOTE: We don't ever want to set contents -1, it includes CONTENTS_LIGHTSABER.
+		//Lots of stuff will explode if there's a brush with CONTENTS_LIGHTSABER that isn't attached to a client owner.
+		//ent->contents = -1;		// we don't know exactly what is in the brushes
+		h = CM_InlineModel( ent->s.modelindex );
+		ent->contents = CM_ModelContents( h, CM_FindSubBSP(ent->s.modelindex) );
+	//	ent->contents = CONTENTS_SOLID;
+	}
+	else
+	{
+		Com_Error( ERR_DROP, "SV_SetBrushModel: %s isn't a brush model (ent %d)", name, ent->s.number );
+	}
+}
+
+const char *SV_SetActiveSubBSP(int index)
+{
+	if (index >= 0)
+	{
+		sv.mLocalSubBSPIndex = CM_FindSubBSP(index);
+		sv.mLocalSubBSPModelOffset = index;
+		sv.mLocalSubBSPEntityParsePoint = CM_SubBSPEntityString (sv.mLocalSubBSPIndex);
+		return sv.mLocalSubBSPEntityParsePoint;
+	}
+	else
+	{
+		sv.mLocalSubBSPIndex = -1;
+	}
+
+	return NULL;
+}
+
+/*
+=================
+SV_inPVS
+
+Also checks portalareas so that doors block sight
+=================
+*/
+qboolean SV_inPVS (const vec3_t p1, const vec3_t p2)
+{
+	int		leafnum;
+	int		cluster;
+	int		area1, area2;
+#ifdef _XBOX 
+	const byte *mask;
+#else
+	byte	*mask;
+#endif
+	int		start=0;
+
+	if ( com_speeds->integer ) {
+		start = Sys_Milliseconds ();
+	}
+	leafnum = CM_PointLeafnum (p1);
+	cluster = CM_LeafCluster (leafnum);
+	area1 = CM_LeafArea (leafnum);
+	mask = CM_ClusterPVS (cluster);
+
+	leafnum = CM_PointLeafnum (p2);
+	cluster = CM_LeafCluster (leafnum);
+	area2 = CM_LeafArea (leafnum);
+	if ( mask && (!(mask[cluster>>3] & (1<<(cluster&7)) ) ) )
+	{
+		if ( com_speeds->integer ) {
+			timeInPVSCheck += Sys_Milliseconds () - start;
+		}
+		return qfalse;
+	}
+	
+	if (!CM_AreasConnected (area1, area2))
+	{
+		timeInPVSCheck += Sys_Milliseconds() - start;
+		return qfalse;		// a door blocks sight
+	}
+	
+	if ( com_speeds->integer ) {
+		timeInPVSCheck += Sys_Milliseconds() - start;
+	}
+	return qtrue;
+}
+
+
+/*
+=================
+SV_inPVSIgnorePortals
+
+Does NOT check portalareas
+=================
+*/
+qboolean SV_inPVSIgnorePortals( const vec3_t p1, const vec3_t p2)
+{
+	int		leafnum;
+	int		cluster;
+	int		area1, area2;
+#ifdef _XBOX
+	const byte *mask;
+#else
+	byte	*mask;
+#endif
+	int		start=0;
+
+	if ( com_speeds->integer ) {
+		start = Sys_Milliseconds ();
+	}
+	
+	leafnum = CM_PointLeafnum (p1);
+	cluster = CM_LeafCluster (leafnum);
+	area1 = CM_LeafArea (leafnum);
+	mask = CM_ClusterPVS (cluster);
+
+	leafnum = CM_PointLeafnum (p2);
+	cluster = CM_LeafCluster (leafnum);
+	area2 = CM_LeafArea (leafnum);
+
+	if ( mask && (!(mask[cluster>>3] & (1<<(cluster&7)) ) ) )
+	{
+		if ( com_speeds->integer ) {
+			timeInPVSCheck += Sys_Milliseconds() - start;
+		}
+		return qfalse;
+	}
+
+	if ( com_speeds->integer ) {
+		timeInPVSCheck += Sys_Milliseconds() - start;
+	}
+	return qtrue;
+}
+
+
+/*
+========================
+SV_AdjustAreaPortalState
+========================
+*/
+void SV_AdjustAreaPortalState( gentity_t *ent, qboolean open ) {
+	if ( !(ent->contents&CONTENTS_OPAQUE) )	{
+#ifndef FINAL_BUILD
+//		Com_Printf( "INFO: entity number %d not opaque: not affecting area portal!\n", ent->s.number );
+#endif
+		return;
+	}
+
+	svEntity_t	*svEnt;
+
+	svEnt = SV_SvEntityForGentity( ent );
+	if ( svEnt->areanum2 == -1 ) {
+		return;
+	}
+	CM_AdjustAreaPortalState( svEnt->areanum, svEnt->areanum2, open );
+}
+
+
+/*
+==================
+SV_GameAreaEntities
+==================
+*/
+qboolean	SV_EntityContact( const vec3_t mins, const vec3_t maxs, const gentity_t *gEnt ) {
+	const float	*origin, *angles;
+	clipHandle_t	ch;
+	trace_t			trace;
+
+	// check for exact collision
+	origin = gEnt->currentOrigin;
+	angles = gEnt->currentAngles;
+
+	ch = SV_ClipHandleForEntity( gEnt );
+	CM_TransformedBoxTrace ( &trace, vec3_origin, vec3_origin, mins, maxs,
+		ch, -1, origin, angles );
+
+	return trace.startsolid;
+}
+
+
+/*
+===============
+SV_GetServerinfo
+
+===============
+*/
+void SV_GetServerinfo( char *buffer, int bufferSize ) {
+	if ( bufferSize < 1 ) {
+		Com_Error( ERR_DROP, "SV_GetServerinfo: bufferSize == %i", bufferSize );
+	}
+	Q_strncpyz( buffer, Cvar_InfoString( CVAR_SERVERINFO ), bufferSize );
+}
+
+qboolean SV_GetEntityToken( char *buffer, int bufferSize )
+{
+	char	*s;
+
+	if (sv.mLocalSubBSPIndex == -1)
+	{
+		s = COM_Parse( (const char **)&sv.entityParsePoint );
+		Q_strncpyz( buffer, s, bufferSize );
+		if ( !sv.entityParsePoint && !s[0] ) 
+		{
+			return qfalse;
+		}
+		else
+		{
+			return qtrue;
+		}
+	}
+	else
+	{
+		s = COM_Parse( (const char **)&sv.mLocalSubBSPEntityParsePoint);
+		Q_strncpyz( buffer, s, bufferSize );
+		if ( !sv.mLocalSubBSPEntityParsePoint && !s[0] ) 
+		{
+			return qfalse;
+		}
+		else
+		{
+			return qtrue;
+		}
+	}
+}
+
+//==============================================
+
+/*
+===============
+SV_ShutdownGameProgs
+
+Called when either the entire server is being killed, or
+it is changing to a different game directory.
+===============
+*/
+void SV_ShutdownGameProgs (qboolean shutdownCin) {
+	if (!ge) {
+		return;
+	}
+	ge->Shutdown ();
+	
+#ifdef _XBOX
+	if(shutdownCin) {
+		SCR_StopCinematic();
+	}
+#else
+	SCR_StopCinematic();
+#endif
+	CL_ShutdownCGame();	//we have cgame burried in here.
+	
+	Sys_UnloadGame ();	//this kills cgame as well.
+
+	ge = NULL;
+	cgvm.entryPoint = 0;
+}
+
+// this is a compile-helper function since Z_Malloc can now become a macro with __LINE__ etc
+//
+static void *G_ZMalloc_Helper( int iSize, memtag_t eTag, qboolean bZeroit)
+{
+	return Z_Malloc( iSize, eTag, bZeroit );
+}
+
+//rww - RAGDOLL_BEGIN
+void G2API_SetRagDoll(CGhoul2Info_v &ghoul2,CRagDollParams *parms);
+void G2API_AnimateG2Models(CGhoul2Info_v &ghoul2, int AcurrentTime,CRagDollUpdateParams *params);
+
+qboolean	G2API_RagPCJConstraint(CGhoul2Info_v &ghoul2, const char *boneName, vec3_t min, vec3_t max);
+qboolean	G2API_RagPCJGradientSpeed(CGhoul2Info_v &ghoul2, const char *boneName, const float speed);
+qboolean	G2API_RagEffectorGoal(CGhoul2Info_v &ghoul2, const char *boneName, vec3_t pos);
+qboolean	G2API_GetRagBonePos(CGhoul2Info_v &ghoul2, const char *boneName, vec3_t pos, vec3_t entAngles, vec3_t entPos, vec3_t entScale);
+qboolean	G2API_RagEffectorKick(CGhoul2Info_v &ghoul2, const char *boneName, vec3_t velocity);
+qboolean	G2API_RagForceSolve(CGhoul2Info_v &ghoul2, qboolean force);
+
+qboolean G2API_SetBoneIKState(CGhoul2Info_v &ghoul2, int time, const char *boneName, int ikState, sharedSetBoneIKStateParams_t *params);
+qboolean G2API_IKMove(CGhoul2Info_v &ghoul2, int time, sharedIKMoveParams_t *params);
+//rww - RAGDOLL_END
+
+//This is as good a place as any I guess.
+#ifndef _XBOX	// Removing terrain from Xbox
+void RMG_Init(int terrainID)
+{
+	if (!TheRandomMissionManager)
+	{
+		TheRandomMissionManager = new CRMManager;
+	}
+	TheRandomMissionManager->SetLandScape(cmg.landScape);
+	if (TheRandomMissionManager->LoadMission(qtrue))
+	{
+		TheRandomMissionManager->SpawnMission(qtrue);
+	}
+//		cmg.landScapes[args[1]]->UpdatePatches();
+	//sv.mRMGChecksum = cm.landScapes[terrainID]->get_rand_seed();
+}
+
+CCMLandScape *CM_RegisterTerrain(const char *config, bool server);
+
+int InterfaceCM_RegisterTerrain (const char *info)
+{
+	return CM_RegisterTerrain(info, false)->GetTerrainId();
+}
+#endif	// _XBOX
+
+/*
+===============
+SV_InitGameProgs
+
+Init the game subsystem for a new map
+===============
+*/
+void SV_InitGameProgs (void) {
+	game_import_t	import;
+	int				i;
+
+	// unload anything we have now
+	if ( ge ) {
+		SV_ShutdownGameProgs (qtrue);
+	}
+
+#ifndef _XBOX
+	if ( !Cvar_VariableIntegerValue("fs_restrict") && !Sys_CheckCD() ) 
+	{
+		Com_Error( ERR_NEED_CD, SE_GetString("CON_TEXT_NEED_CD") ); //"Game CD not in drive" );		
+	}
+#endif
+
+	// load a new game dll
+	import.Printf = Com_Printf;
+	import.WriteCam = Com_WriteCam;
+	import.FlushCamFile = Com_FlushCamFile;
+	import.Error = Com_Error;
+
+	import.Milliseconds = Sys_Milliseconds;
+
+	import.DropClient = SV_GameDropClient;
+
+	import.SendServerCommand = SV_GameSendServerCommand;
+
+
+	import.linkentity = SV_LinkEntity;
+	import.unlinkentity = SV_UnlinkEntity;
+	import.EntitiesInBox = SV_AreaEntities;
+	import.EntityContact = SV_EntityContact;
+	import.trace = SV_Trace;
+	import.pointcontents = SV_PointContents;
+	import.totalMapContents = CM_TotalMapContents;
+	import.SetBrushModel = SV_SetBrushModel;
+
+	import.inPVS = SV_inPVS;
+	import.inPVSIgnorePortals = SV_inPVSIgnorePortals;
+
+	import.SetConfigstring = SV_SetConfigstring;
+	import.GetConfigstring = SV_GetConfigstring;
+
+	import.SetUserinfo = SV_SetUserinfo;
+	import.GetUserinfo = SV_GetUserinfo;
+
+	import.GetServerinfo = SV_GetServerinfo;
+
+	import.cvar = Cvar_Get;
+	import.cvar_set = Cvar_Set;
+	import.Cvar_VariableIntegerValue = Cvar_VariableIntegerValue;
+	import.Cvar_VariableStringBuffer = Cvar_VariableStringBuffer;
+
+	import.argc = Cmd_Argc;
+	import.argv = Cmd_Argv;
+	import.SendConsoleCommand = Cbuf_AddText;
+
+	import.FS_FOpenFile = FS_FOpenFileByMode;
+	import.FS_Read = FS_Read;
+	import.FS_Write = FS_Write;
+	import.FS_FCloseFile = FS_FCloseFile;
+	import.FS_ReadFile = FS_ReadFile;
+	import.FS_FreeFile = FS_FreeFile;
+	import.FS_GetFileList = FS_GetFileList;
+
+	import.AppendToSaveGame = SG_Append;
+#ifndef _XBOX
+	import.ReadFromSaveGame	= SG_Read;
+	import.ReadFromSaveGameOptional = SG_ReadOptional;
+#endif
+
+	import.AdjustAreaPortalState = SV_AdjustAreaPortalState;
+	import.AreasConnected = CM_AreasConnected;
+
+	import.VoiceVolume = s_entityWavVol;
+
+	import.Malloc = G_ZMalloc_Helper;
+	import.Free = Z_Free;
+	import.bIsFromZone = Z_IsFromZone;
+/*
+Ghoul2 Insert Start
+*/
+
+	import.G2API_AddBolt = G2API_AddBolt;
+	import.G2API_AttachEnt = G2API_AttachEnt;
+	import.G2API_AttachG2Model = G2API_AttachG2Model;
+	import.G2API_CollisionDetect = G2API_CollisionDetect;
+	import.G2API_DetachEnt = G2API_DetachEnt;
+	import.G2API_DetachG2Model = G2API_DetachG2Model;
+	import.G2API_GetAnimFileName = G2API_GetAnimFileName;
+	import.G2API_GetBoltMatrix = G2API_GetBoltMatrix;
+	import.G2API_GetBoneAnim = G2API_GetBoneAnim;
+	import.G2API_GetBoneAnimIndex = G2API_GetBoneAnimIndex;
+	import.G2API_AddSurface = G2API_AddSurface;
+	import.G2API_HaveWeGhoul2Models =G2API_HaveWeGhoul2Models;
+#ifndef _XBOX
+	import.G2API_InitGhoul2Model = G2API_InitGhoul2Model;
+	import.G2API_SetBoneAngles = G2API_SetBoneAngles;
+	import.G2API_SetBoneAnglesMatrix = G2API_SetBoneAnglesMatrix;
+	import.G2API_SetBoneAnim = G2API_SetBoneAnim;
+	import.G2API_SetSkin = G2API_SetSkin;
+	import.G2API_CopyGhoul2Instance = G2API_CopyGhoul2Instance;
+	import.G2API_SetBoneAnglesIndex = G2API_SetBoneAnglesIndex;
+	import.G2API_SetBoneAnimIndex = G2API_SetBoneAnimIndex;
+#endif
+	import.G2API_IsPaused = G2API_IsPaused;
+	import.G2API_ListBones = G2API_ListBones;
+	import.G2API_ListSurfaces = G2API_ListSurfaces;
+	import.G2API_PauseBoneAnim = G2API_PauseBoneAnim;
+	import.G2API_PauseBoneAnimIndex = G2API_PauseBoneAnimIndex;
+	import.G2API_PrecacheGhoul2Model = G2API_PrecacheGhoul2Model;
+	import.G2API_RemoveBolt = G2API_RemoveBolt;
+	import.G2API_RemoveBone = G2API_RemoveBone;
+	import.G2API_RemoveGhoul2Model = G2API_RemoveGhoul2Model;
+	import.G2API_SetLodBias = G2API_SetLodBias;
+	import.G2API_SetRootSurface = G2API_SetRootSurface;
+	import.G2API_SetShader = G2API_SetShader;
+	import.G2API_SetSurfaceOnOff = G2API_SetSurfaceOnOff;
+	import.G2API_StopBoneAngles = G2API_StopBoneAngles;
+	import.G2API_StopBoneAnim = G2API_StopBoneAnim;
+	import.G2API_SetGhoul2ModelFlags = G2API_SetGhoul2ModelFlags;
+	import.G2API_AddBoltSurfNum = G2API_AddBoltSurfNum;
+	import.G2API_RemoveSurface = G2API_RemoveSurface;
+	import.G2API_GetAnimRange = G2API_GetAnimRange;
+	import.G2API_GetAnimRangeIndex = G2API_GetAnimRangeIndex;
+	import.G2API_GiveMeVectorFromMatrix = G2API_GiveMeVectorFromMatrix;
+	import.G2API_GetGhoul2ModelFlags = G2API_GetGhoul2ModelFlags;
+	import.G2API_CleanGhoul2Models = G2API_CleanGhoul2Models;
+	import.TheGhoul2InfoArray = TheGhoul2InfoArray;
+	import.G2API_GetParentSurface = G2API_GetParentSurface;
+	import.G2API_GetSurfaceIndex = G2API_GetSurfaceIndex;
+	import.G2API_GetSurfaceName = G2API_GetSurfaceName;
+	import.G2API_GetGLAName = G2API_GetGLAName;
+	import.G2API_SetNewOrigin = G2API_SetNewOrigin;
+	import.G2API_GetBoneIndex = G2API_GetBoneIndex;
+	import.G2API_StopBoneAnglesIndex = G2API_StopBoneAnglesIndex;
+	import.G2API_StopBoneAnimIndex = G2API_StopBoneAnimIndex;
+	import.G2API_SetBoneAnglesMatrixIndex = G2API_SetBoneAnglesMatrixIndex;
+	import.G2API_SetAnimIndex = G2API_SetAnimIndex;
+	import.G2API_GetAnimIndex = G2API_GetAnimIndex;
+
+	import.G2API_SaveGhoul2Models = G2API_SaveGhoul2Models;
+	import.G2API_LoadGhoul2Models = G2API_LoadGhoul2Models;
+	import.G2API_LoadSaveCodeDestructGhoul2Info = G2API_LoadSaveCodeDestructGhoul2Info;
+	import.G2API_GetAnimFileNameIndex = G2API_GetAnimFileNameIndex;
+	import.G2API_GetAnimFileInternalNameIndex = G2API_GetAnimFileInternalNameIndex;
+	import.G2API_GetSurfaceRenderStatus = G2API_GetSurfaceRenderStatus;
+
+	//rww - RAGDOLL_BEGIN
+	import.G2API_SetRagDoll = G2API_SetRagDoll;
+	import.G2API_AnimateG2Models = G2API_AnimateG2Models;
+
+	import.G2API_RagPCJConstraint = G2API_RagPCJConstraint;
+	import.G2API_RagPCJGradientSpeed = G2API_RagPCJGradientSpeed;
+	import.G2API_RagEffectorGoal = G2API_RagEffectorGoal;
+	import.G2API_GetRagBonePos = G2API_GetRagBonePos;
+	import.G2API_RagEffectorKick = G2API_RagEffectorKick;
+	import.G2API_RagForceSolve = G2API_RagForceSolve;
+
+	import.G2API_SetBoneIKState = G2API_SetBoneIKState;
+    import.G2API_IKMove = G2API_IKMove;
+	//rww - RAGDOLL_END
+
+	import.G2API_AddSkinGore = G2API_AddSkinGore;
+	import.G2API_ClearSkinGore = G2API_ClearSkinGore;
+
+#ifndef _XBOX
+	import.RMG_Init = RMG_Init;
+	import.CM_RegisterTerrain = InterfaceCM_RegisterTerrain;
+#endif
+	import.SetActiveSubBSP = SV_SetActiveSubBSP;
+
+	import.RE_RegisterSkin = RE_RegisterSkin;
+	import.RE_GetAnimationCFG = RE_GetAnimationCFG;
+
+
+	import.WE_GetWindVector	= R_GetWindVector;
+	import.WE_GetWindGusting = R_GetWindGusting;
+	import.WE_IsOutside	= R_IsOutside;
+	import.WE_IsOutsideCausingPain	= R_IsOutsideCausingPain;
+	import.WE_GetChanceOfSaberFizz = R_GetChanceOfSaberFizz;
+	import.WE_IsShaking = R_IsShaking;
+	import.WE_AddWeatherZone = R_AddWeatherZone;
+	import.WE_SetTempGlobalFogColor = R_SetTempGlobalFogColor;
+
+
+/*
+Ghoul2 Insert End
+*/
+
+	ge = (game_export_t *)Sys_GetGameAPI (&import);
+
+	if (!ge)
+		Com_Error (ERR_DROP, "failed to load game DLL");
+
+	//hook up the client while we're here
+#ifdef _XBOX
+	VM_Create("cl");
+#else
+	if (!VM_Create("cl"))
+		Com_Error (ERR_DROP, "failed to attach to the client DLL");
+#endif
+
+	if (ge->apiversion != GAME_API_VERSION)
+		Com_Error (ERR_DROP, "game is version %i, not %i", ge->apiversion,
+		GAME_API_VERSION);
+
+	sv.entityParsePoint = CM_EntityString();
+
+	// use the current msec count for a random seed
+	Z_TagFree(TAG_G_ALLOC);
+	ge->Init( sv_mapname->string, sv_spawntarget->string, sv_mapChecksum->integer, CM_EntityString(), sv.time, com_frameTime, Com_Milliseconds(), eSavedGameJustLoaded, qbLoadTransition );
+
+	// clear all gentity pointers that might still be set from
+	// a previous level
+	for ( i = 0 ; i < 1 ; i++ ) {
+		svs.clients[i].gentity = NULL;
+	}
+}
+
+
+
+/*
+====================
+SV_GameCommand
+
+See if the current console command is claimed by the game
+====================
+*/
+qboolean SV_GameCommand( void ) {
+	if ( sv.state != SS_GAME ) {
+		return qfalse;
+	}
+
+	return ge->ConsoleCommand();
+}
+
diff --git a/code/server/sv_init.cpp b/code/server/sv_init.cpp
new file mode 100644
index 0000000..7804557
--- /dev/null
+++ b/code/server/sv_init.cpp
@@ -0,0 +1,596 @@
+
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+#include "../client/snd_music.h"	// didn't want to put this in snd_local because of rebuild times etc.
+#include "server.h"
+
+/*
+Ghoul2 Insert Start
+*/
+#if !defined(TR_LOCAL_H)
+	#include "../renderer/tr_local.h"
+#endif
+
+#if !defined (MINIHEAP_H_INC)
+	#include "../qcommon/miniheap.h"
+#endif
+
+void CM_CleanLeafCache(void);
+extern void SV_FreeClient(client_t*);
+
+CMiniHeap *G2VertSpaceServer = NULL;
+/*
+Ghoul2 Insert End
+*/
+
+
+/*
+===============
+SV_SetConfigstring
+
+===============
+*/
+void SV_SetConfigstring (int index, const char *val) {
+	if ( index < 0 || index >= MAX_CONFIGSTRINGS ) {
+		Com_Error (ERR_DROP, "SV_SetConfigstring: bad index %i\n", index);
+	}
+
+	if ( !val ) {
+		val = "";
+	}
+
+	// don't bother broadcasting an update if no change
+	if ( !strcmp( val, sv.configstrings[ index ] ) ) {
+		return;
+	}
+
+	// change the string in sv
+	Z_Free( sv.configstrings[index] );
+	sv.configstrings[index] = CopyString( val );
+
+	// send it to all the clients if we aren't
+	// spawning a new server
+	if ( sv.state == SS_GAME ) {
+		SV_SendServerCommand( NULL, "cs %i \"%s\"\n", index, val );
+	}
+}
+
+
+
+/*
+===============
+SV_GetConfigstring
+
+===============
+*/
+void SV_GetConfigstring( int index, char *buffer, int bufferSize ) {
+	if ( bufferSize < 1 ) {
+		Com_Error( ERR_DROP, "SV_GetConfigstring: bufferSize == %i", bufferSize );
+	}
+	if ( index < 0 || index >= MAX_CONFIGSTRINGS ) {
+		Com_Error (ERR_DROP, "SV_GetConfigstring: bad index %i\n", index);
+	}
+	if ( !sv.configstrings[index] ) {
+		buffer[0] = 0;
+		return;
+	}
+
+	Q_strncpyz( buffer, sv.configstrings[index], bufferSize );
+}
+
+
+/*
+===============
+SV_SetUserinfo
+
+===============
+*/
+void SV_SetUserinfo( int index, const char *val ) {
+	if ( index < 0 || index >= 1 ) {
+		Com_Error (ERR_DROP, "SV_SetUserinfo: bad index %i\n", index);
+	}
+
+	if ( !val ) {
+		val = "";
+	}
+
+	Q_strncpyz( svs.clients[ index ].userinfo, val, sizeof( svs.clients[ index ].userinfo ) );
+}
+
+
+
+/*
+===============
+SV_GetUserinfo
+
+===============
+*/
+void SV_GetUserinfo( int index, char *buffer, int bufferSize ) {
+	if ( bufferSize < 1 ) {
+		Com_Error( ERR_DROP, "SV_GetUserinfo: bufferSize == %i", bufferSize );
+	}
+	if ( index < 0 || index >= 1 ) {
+		Com_Error (ERR_DROP, "SV_GetUserinfo: bad index %i\n", index);
+	}
+	Q_strncpyz( buffer, svs.clients[ index ].userinfo, bufferSize );
+}
+
+
+/*
+================
+SV_CreateBaseline
+
+Entity baselines are used to compress non-delta messages
+to the clients -- only the fields that differ from the
+baseline will be transmitted
+================
+*/
+void SV_CreateBaseline( void ) {
+	gentity_t			*svent;
+	int				entnum;	
+
+	for ( entnum = 0; entnum < ge->num_entities ; entnum++ ) {
+		svent = SV_GentityNum(entnum);
+		if (!svent->inuse) {
+			continue;
+		}
+		if (!svent->linked) {
+			continue;
+		}
+		svent->s.number = entnum;
+
+		//
+		// take current state as baseline
+		//
+		sv.svEntities[entnum].baseline = svent->s;
+	}
+}
+
+
+
+
+/*
+===============
+SV_Startup
+
+Called when a game is about to begin
+===============
+*/
+void SV_Startup( void ) {
+	if ( svs.initialized ) {
+		Com_Error( ERR_FATAL, "SV_Startup: svs.initialized" );
+	}
+
+	svs.clients = (struct client_s *) Z_Malloc ( sizeof(client_t) * 1, TAG_CLIENTS, qtrue );
+	svs.numSnapshotEntities = 2 * 4 * 64;
+	svs.initialized = qtrue;
+
+	Cvar_Set( "sv_running", "1" );
+}
+
+
+#ifdef _XBOX
+//Xbox-only memory freeing.
+extern void R_ModelFree(void);
+extern void Sys_IORequestQueueClear(void);
+extern void Music_Free(void);
+extern void AS_FreePartial(void);
+extern void G_ASPreCacheFree(void);
+extern void Ghoul2InfoArray_Free(void);
+extern void Ghoul2InfoArray_Reset(void);
+extern void Menu_Reset(void);
+extern void G2_FreeRag(void);
+extern void ClearAllNavStructures(void);
+extern void ClearModelsAlreadyDone(void);
+extern void CL_FreeServerCommands(void);
+extern void CL_FreeReliableCommands(void);
+extern void CM_Free(void);
+extern void ShaderEntryPtrs_Clear(void);
+extern void G_FreeRoffs(void);
+extern int	numVehicles;
+void SV_ClearLastLevel(void)
+{
+	Menu_Reset();
+	Z_TagFree(TAG_G_ALLOC);
+	Z_TagFree(TAG_UI_ALLOC);
+	G_FreeRoffs();
+	R_ModelFree();
+	Music_Free();
+	Sys_IORequestQueueClear();
+	AS_FreePartial();
+	G_ASPreCacheFree();
+	Ghoul2InfoArray_Free();
+	G2_FreeRag();
+	ClearAllNavStructures();
+	ClearModelsAlreadyDone();
+	CL_FreeServerCommands();
+	CL_FreeReliableCommands();
+	CM_Free();
+	ShaderEntryPtrs_Clear();
+
+	numVehicles = 0;
+
+	if (svs.clients)
+	{
+		SV_FreeClient( svs.clients );
+	}
+}
+#endif
+
+qboolean CM_SameMap(char *server);
+qboolean CM_HasTerrain(void);
+void Cvar_Defrag(void);
+
+/*
+================
+SV_SpawnServer
+
+Change the server to a new map, taking all connected
+clients along with it.
+================
+*/
+void SV_SpawnServer( char *server, ForceReload_e eForceReload, qboolean bAllowScreenDissolve )
+{
+	int			i;
+	int			checksum;
+
+// The following fixes for potential issues only work on Xbox
+#ifdef _XBOX
+	extern qboolean stop_icarus;
+	stop_icarus = qfalse;
+
+	//Broken scripts may leave the player locked.  I think that's always bad.
+	extern qboolean player_locked;
+	player_locked = qfalse;
+
+	//If you quit while in Matrix Mode, this never gets cleared!
+	extern qboolean MatrixMode;
+	MatrixMode = qfalse;
+
+	// Temporary code to turn on HDR effect for specific maps only
+	if (!Q_stricmp(server, "t3_rift"))
+	{
+		Cvar_Set( "r_hdreffect", "1" );
+	}
+	else
+	{
+		Cvar_Set( "r_hdreffect", "0" );
+	}
+#endif
+
+	RE_RegisterMedia_LevelLoadBegin( server, eForceReload, bAllowScreenDissolve );
+
+
+	Cvar_SetValue( "cl_paused", 0 );
+	Cvar_Set( "timescale", "1" );//jic we were skipping
+
+	// shut down the existing game if it is running
+	SV_ShutdownGameProgs(qtrue);
+
+	Com_Printf ("------ Server Initialization ------\n%s\n", com_version->string);
+	Com_Printf ("Server: %s\n",server);	
+
+#ifdef _XBOX
+	// disable vsync during load for speed
+	qglDisable(GL_VSYNC);
+#endif
+
+	// don't let sound stutter and dump all stuff on the hunk
+	CL_MapLoading();
+
+	if (!CM_SameMap(server))
+	{ //rww - only clear if not loading the same map
+		CM_ClearMap();
+	}
+#ifndef _XBOX
+	else if (CM_HasTerrain())
+	{ //always clear when going between maps with terrain
+		CM_ClearMap();
+	}
+#endif
+
+	// Miniheap never changes sizes, so I just put it really early in mem.
+	G2VertSpaceServer->ResetHeap();
+
+#ifdef _XBOX
+	// Deletes all textures
+	R_DeleteTextures();
+#endif
+	Hunk_Clear();
+
+	// Moved up from below to help reduce fragmentation
+	if (svs.snapshotEntities)
+	{
+		Z_Free(svs.snapshotEntities);
+		svs.snapshotEntities = NULL;
+	}
+
+	// wipe the entire per-level structure
+	// Also moved up, trying to do all freeing before new allocs
+	for ( i = 0 ; i < MAX_CONFIGSTRINGS ; i++ ) {
+		if ( sv.configstrings[i] ) {
+			Z_Free( sv.configstrings[i] );
+			sv.configstrings[i] = NULL;
+		}
+	}
+
+#ifdef _XBOX
+	SV_ClearLastLevel();
+#endif
+
+	// Collect all the small allocations done by the cvar system
+	// This frees, then allocates. Make it the last thing before other
+	// allocations begin!
+	Cvar_Defrag();
+
+/*
+		This is useful for debugging memory fragmentation.  Please don't
+	   remove it.
+*/
+#ifdef _XBOX
+	// We've over-freed the info array above, this puts it back into a working state
+	Ghoul2InfoArray_Reset();
+
+	extern void Z_DumpMemMap_f(void);
+	extern void Z_Details_f(void);
+	extern void Z_TagPointers(memtag_t);
+	Z_DumpMemMap_f();
+//	Z_TagPointers(TAG_ALL);
+	Z_Details_f();
+#endif
+
+	// init client structures and svs.numSnapshotEntities
+	// This is moved down quite a bit, but should be safe. And keeps
+	// svs.clients right at the beginning of memory
+	if ( !Cvar_VariableIntegerValue("sv_running") ) {
+		SV_Startup();
+	}
+
+ 	// clear out those shaders, images and Models
+	R_InitImages();
+	R_InitShaders();
+	R_ModelInit();
+
+	// allocate the snapshot entities 
+	svs.snapshotEntities = (entityState_t *) Z_Malloc (sizeof(entityState_t)*svs.numSnapshotEntities, TAG_CLIENTS, qtrue );
+
+	Music_SetLevelName(server);
+
+	// toggle the server bit so clients can detect that a
+	// server has changed
+//!@	svs.snapFlagServerBit ^= SNAPFLAG_SERVERCOUNT;
+
+	// set nextmap to the same map, but it may be overriden
+	// by the game startup or another console command
+	Cvar_Set( "nextmap", va("map %s", server) );
+
+
+	memset (&sv, 0, sizeof(sv));
+
+
+	for ( i = 0 ; i < MAX_CONFIGSTRINGS ; i++ ) {
+		sv.configstrings[i] = CopyString("");
+	}
+
+	sv.time = 1000;
+	G2API_SetTime(sv.time,G2T_SV_TIME);
+
+#ifdef _XBOX
+	CL_StartHunkUsers();
+	CM_LoadMap( va("maps/%s.bsp", server), qfalse, &checksum );
+	RE_LoadWorldMap(va("maps/%s.bsp", server));
+#else
+	CM_LoadMap( va("maps/%s.bsp", server), qfalse, &checksum, qfalse );
+#endif
+
+	// set serverinfo visible name
+	Cvar_Set( "mapname", server );
+
+	Cvar_Set( "sv_mapChecksum", va("%i",checksum) );
+
+	// serverid should be different each time
+	sv.serverId = com_frameTime;
+	Cvar_Set( "sv_serverid", va("%i", sv.serverId ) );
+
+	// clear physics interaction links
+	SV_ClearWorld ();
+	
+	// media configstring setting should be done during
+	// the loading stage, so connected clients don't have
+	// to load during actual gameplay
+	sv.state = SS_LOADING;
+
+	// load and spawn all other entities
+	SV_InitGameProgs();
+
+	// run a few frames to allow everything to settle
+	for ( i = 0 ;i < 3 ; i++ ) {
+		ge->RunFrame( sv.time );
+		sv.time += 100;
+		G2API_SetTime(sv.time,G2T_SV_TIME);
+	}
+	ge->ConnectNavs(sv_mapname->string, sv_mapChecksum->integer);
+
+	// create a baseline for more efficient communications
+	SV_CreateBaseline ();
+
+	for (i=0 ; i<1 ; i++) {
+		// clear all time counters, because we have reset sv.time
+		svs.clients[i].lastPacketTime = 0;
+		svs.clients[i].lastConnectTime = 0;
+		svs.clients[i].nextSnapshotTime = 0;
+
+		// send the new gamestate to all connected clients
+		if (svs.clients[i].state >= CS_CONNECTED) {
+			char	*denied;
+
+			// connect the client again
+			denied = ge->ClientConnect( i, qfalse, eNO/*qfalse*/ );	// firstTime = qfalse, qbFromSavedGame
+			if ( denied ) {
+				// this generally shouldn't happen, because the client
+				// was connected before the level change
+				SV_DropClient( &svs.clients[i], denied );
+			} else {
+				svs.clients[i].state = CS_CONNECTED;
+				// when we get the next packet from a connected client,
+				// the new gamestate will be sent
+			}
+		}
+	}	
+
+	// run another frame to allow things to look at all connected clients
+	ge->RunFrame( sv.time );
+	sv.time += 100;
+	G2API_SetTime(sv.time,G2T_SV_TIME);
+
+
+	// save systeminfo and serverinfo strings
+	SV_SetConfigstring( CS_SYSTEMINFO, Cvar_InfoString( CVAR_SYSTEMINFO ) );
+	cvar_modifiedFlags &= ~CVAR_SYSTEMINFO;
+
+	SV_SetConfigstring( CS_SERVERINFO, Cvar_InfoString( CVAR_SERVERINFO ) );
+	cvar_modifiedFlags &= ~CVAR_SERVERINFO;
+
+	// any media configstring setting now should issue a warning
+	// and any configstring changes should be reliably transmitted
+	// to all clients
+	sv.state = SS_GAME;
+	
+	// send a heartbeat now so the master will get up to date info
+	svs.nextHeartbeatTime = -9999999;
+
+	Hunk_SetMark();
+	Z_Validate();
+	Z_Validate();
+	Z_Validate();
+	
+	Com_Printf ("-----------------------------------\n");
+}
+
+/*
+===============
+SV_Init
+
+Only called at main exe startup, not for each game
+===============
+*/
+void SV_Init (void) {
+	SV_AddOperatorCommands ();
+
+	// serverinfo vars
+	Cvar_Get ("protocol", va("%i", PROTOCOL_VERSION), CVAR_SERVERINFO | CVAR_ROM);
+	sv_mapname = Cvar_Get ("mapname", "nomap", CVAR_SERVERINFO | CVAR_ROM);
+
+	// systeminfo
+	Cvar_Get ("helpUsObi", "0", CVAR_SYSTEMINFO );
+	sv_serverid = Cvar_Get ("sv_serverid", "0", CVAR_SYSTEMINFO | CVAR_ROM );
+
+	// server vars
+	sv_fps = Cvar_Get ("sv_fps", "20", CVAR_TEMP );
+	sv_timeout = Cvar_Get ("sv_timeout", "120", CVAR_TEMP );
+	sv_zombietime = Cvar_Get ("sv_zombietime", "2", CVAR_TEMP );
+	Cvar_Get ("nextmap", "", CVAR_TEMP );
+	sv_spawntarget = Cvar_Get ("spawntarget", "", 0 );
+
+	sv_reconnectlimit = Cvar_Get ("sv_reconnectlimit", "3", 0);
+	sv_showloss = Cvar_Get ("sv_showloss", "0", 0);
+	sv_killserver = Cvar_Get ("sv_killserver", "0", 0);
+	sv_mapChecksum = Cvar_Get ("sv_mapChecksum", "", CVAR_ROM);
+	sv_testsave = Cvar_Get ("sv_testsave", "0", 0);
+	sv_compress_saved_games = Cvar_Get ("sv_compress_saved_games", "1", 0);
+
+	// Only allocated once, no point in moving it around and fragmenting
+	// create a heap for Ghoul2 to use for game side model vertex transforms used in collision detection
+	{
+		static CMiniHeap singleton(132096);
+		G2VertSpaceServer = &singleton;
+	}
+}
+
+
+/*
+==================
+SV_FinalMessage
+
+Used by SV_Shutdown to send a final message to all
+connected clients before the server goes down.  The messages are sent immediately,
+not just stuck on the outgoing message list, because the server is going
+to totally exit after returning from this function.
+==================
+*/
+void SV_FinalMessage( char *message ) {
+	int			i, j;
+	client_t	*cl;
+	
+	SV_SendServerCommand( NULL, "print \"%s\"", message );
+	SV_SendServerCommand( NULL, "disconnect" );
+
+	// send it twice, ignoring rate
+	for ( j = 0 ; j < 2 ; j++ ) {
+		for (i=0, cl = svs.clients ; i < 1 ; i++, cl++) {
+			if (cl->state >= CS_CONNECTED) {
+				// force a snapshot to be sent
+				cl->nextSnapshotTime = -1;
+				SV_SendClientSnapshot( cl );
+			}
+		}
+	}
+}
+
+
+/*
+================
+SV_Shutdown
+
+Called when each game quits,
+before Sys_Quit or Sys_Error
+================
+*/
+void SV_Shutdown( char *finalmsg ) {
+	int i;
+
+	if ( !com_sv_running || !com_sv_running->integer ) {
+		return;
+	}
+
+	//Com_Printf( "----- Server Shutdown -----\n" );
+
+	if ( svs.clients && !com_errorEntered ) {
+		SV_FinalMessage( finalmsg );
+	}
+
+	SV_RemoveOperatorCommands();
+	SV_ShutdownGameProgs(qfalse);
+
+	if (svs.snapshotEntities)
+	{
+		Z_Free(svs.snapshotEntities);
+		svs.snapshotEntities = NULL;
+	}
+
+	for ( i = 0 ; i < MAX_CONFIGSTRINGS ; i++ ) {
+		if ( sv.configstrings[i] ) {
+			Z_Free( sv.configstrings[i] );
+		}
+	}
+
+	// free current level
+	memset( &sv, 0, sizeof( sv ) );
+
+	// free server static data
+	if ( svs.clients ) {
+		SV_FreeClient(svs.clients);
+		Z_Free( svs.clients );
+	}
+	memset( &svs, 0, sizeof( svs ) );
+
+	// Ensure we free any memory used by the leaf cache.
+	CM_CleanLeafCache();
+
+	Cvar_Set( "sv_running", "0" );
+
+	//Com_Printf( "---------------------------\n" );
+}
+
diff --git a/code/server/sv_main.cpp b/code/server/sv_main.cpp
new file mode 100644
index 0000000..391fd77
--- /dev/null
+++ b/code/server/sv_main.cpp
@@ -0,0 +1,572 @@
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+
+
+#include "server.h"
+/*
+Ghoul2 Insert Start
+*/
+#if !defined (MINIHEAP_H_INC)
+	#include "../qcommon/miniheap.h"
+#endif
+/*
+Ghoul2 Insert End
+*/
+
+serverStatic_t	svs;				// persistant server info
+server_t		sv;					// local server
+game_export_t	*ge;
+
+cvar_t	*sv_fps;				// time rate for running non-clients
+cvar_t	*sv_timeout;			// seconds without any message
+cvar_t	*sv_zombietime;			// seconds to sink messages after disconnect
+cvar_t	*sv_reconnectlimit;		// minimum seconds between connect messages
+cvar_t	*sv_showloss;			// report when usercmds are lost
+cvar_t	*sv_killserver;			// menu system can set to 1 to shut server down
+cvar_t	*sv_mapname;
+cvar_t	*sv_spawntarget;
+cvar_t	*sv_mapChecksum;
+cvar_t	*sv_serverid;
+cvar_t	*sv_testsave;			// Run the savegame enumeration every game frame
+cvar_t	*sv_compress_saved_games;	// compress the saved games on the way out (only affect saver, loader can read both)
+
+/*
+=============================================================================
+
+EVENT MESSAGES
+
+=============================================================================
+*/
+
+/*
+===============
+SV_ExpandNewlines
+
+Converts newlines to "\n" so a line prints nicer
+===============
+*/
+char	*SV_ExpandNewlines( char *in ) {
+	static	char	string[1024];
+	int		l;
+
+	l = 0;
+	while ( *in && l < sizeof(string) - 3 ) {
+		if ( *in == '\n' ) {
+			string[l++] = '\\';
+			string[l++] = 'n';
+		} else {
+			string[l++] = *in;
+		}
+		in++;
+	}
+	string[l] = 0;
+
+	return string;
+}
+
+/*
+======================
+SV_AddServerCommand
+
+The given command will be transmitted to the client, and is guaranteed to
+not have future snapshot_t executed before it is executed
+======================
+*/
+void SV_AddServerCommand( client_t *client, const char *cmd ) {
+	int		index;
+
+	// if we would be losing an old command that hasn't been acknowledged,
+	// we must drop the connection
+	if ( client->reliableSequence - client->reliableAcknowledge > MAX_RELIABLE_COMMANDS ) {
+		SV_DropClient( client, "Server command overflow" );
+		return;
+	}
+	client->reliableSequence++;
+	index = client->reliableSequence & ( MAX_RELIABLE_COMMANDS - 1 );
+	if ( client->reliableCommands[ index ] ) {
+		Z_Free( client->reliableCommands[ index ] );
+	}
+	client->reliableCommands[ index ] = CopyString( cmd );
+}
+
+
+/*
+=================
+SV_SendServerCommand
+
+Sends a reliable command string to be interpreted by 
+the client game module: "cp", "print", "chat", etc
+A NULL client will broadcast to all clients
+=================
+*/
+void SV_SendServerCommand(client_t *cl, const char *fmt, ...) {
+	va_list		argptr;
+	byte		message[MAX_MSGLEN];
+	int			len;
+	client_t	*client;
+	int			j;
+	
+	message[0] = svc_serverCommand;
+
+	va_start (argptr,fmt);
+	vsprintf ((char *)message+1, fmt,argptr);
+	va_end (argptr);
+	len = strlen( (char *)message ) + 1;
+
+	if ( cl != NULL ) {
+		SV_AddServerCommand( cl, (char *)message );
+		return;
+	}
+
+	// send the data to all relevent clients
+	for (j = 0, client = svs.clients; j < 1 ; j++, client++) {
+		if ( client->state < CS_PRIMED ) {
+			continue;
+		}
+		SV_AddServerCommand( client, (char *)message );
+	}
+}
+
+
+
+/*
+==============================================================================
+
+CONNECTIONLESS COMMANDS
+
+==============================================================================
+*/
+
+/*
+================
+SVC_Status
+
+Responds with all the info that qplug or qspy can see about the server
+and all connected players.  Used for getting detailed information after
+the simple info query.
+================
+*/
+void SVC_Status( netadr_t from ) {
+	char	player[1024];
+	char	status[MAX_MSGLEN];
+	int		i;
+	client_t	*cl;
+	int		statusLength;
+	int		playerLength;
+	int		score;
+	char	infostring[MAX_INFO_STRING];
+
+	strcpy( infostring, Cvar_InfoString( CVAR_SERVERINFO ) );
+
+	// echo back the parameter to status. so servers can use it as a challenge
+	// to prevent timed spoofed reply packets that add ghost servers
+	Info_SetValueForKey( infostring, "challenge", Cmd_Argv(1) );
+
+	status[0] = 0;
+	statusLength = 0;
+
+	for (i=0 ; i < 1 ; i++) {
+		cl = &svs.clients[i];
+		if ( cl->state >= CS_CONNECTED ) {
+			if ( cl->gentity && cl->gentity->client ) {
+				score = cl->gentity->client->persistant[PERS_SCORE];
+			} else {
+				score = 0;
+			}
+			Com_sprintf (player, sizeof(player), "%i %i \"%s\"\n", 
+				score, cl->ping, cl->name);
+			playerLength = strlen(player);
+			if (statusLength + playerLength >= sizeof(status) ) {
+				break;		// can't hold any more
+			}
+			strcpy (status + statusLength, player);
+			statusLength += playerLength;
+		}
+	}
+
+	NET_OutOfBandPrint( NS_SERVER, from, "statusResponse\n%s\n%s", infostring, status );
+}
+
+/*
+================
+SVC_Info
+
+Responds with a short info message that should be enough to determine
+if a user is interested in a server to do a full status
+================
+*/
+static void SVC_Info( netadr_t from ) {
+	int		i, count;
+	char	infostring[MAX_INFO_STRING];
+
+	count = 0;
+	for ( i = 0 ; i < 1 ; i++ ) {
+		if ( svs.clients[i].state >= CS_CONNECTED ) {
+			count++;
+		}
+	}
+
+	infostring[0] = 0;
+
+	// echo back the parameter to status. so servers can use it as a challenge
+	// to prevent timed spoofed reply packets that add ghost servers
+	Info_SetValueForKey( infostring, "challenge", Cmd_Argv(1) );
+
+	Info_SetValueForKey( infostring, "protocol", va("%i", PROTOCOL_VERSION) );
+	//Info_SetValueForKey( infostring, "hostname", sv_hostname->string );
+	Info_SetValueForKey( infostring, "mapname", sv_mapname->string );
+	Info_SetValueForKey( infostring, "clients", va("%i", count) );
+	Info_SetValueForKey( infostring, "sv_maxclients", va("%i", 1) );
+
+	NET_OutOfBandPrint( NS_SERVER, from, "infoResponse\n%s", infostring );
+}
+
+
+/*
+=================
+SV_ConnectionlessPacket
+
+A connectionless packet has four leading 0xff
+characters to distinguish it from a game channel.
+Clients that are in the game can still send
+connectionless packets.
+=================
+*/
+static void SV_ConnectionlessPacket( netadr_t from, msg_t *msg ) {
+	char	*s;
+	char	*c;
+
+	MSG_BeginReading( msg );
+	MSG_ReadLong( msg );		// skip the -1 marker
+
+	s = MSG_ReadStringLine( msg );
+
+	Cmd_TokenizeString( s );
+
+	c = Cmd_Argv(0);
+	Com_DPrintf ("SV packet %s : %s\n", NET_AdrToString(from), c);
+
+	if (!strcmp(c,"getstatus")) {
+		SVC_Status( from  );
+	} else if (!strcmp(c,"getinfo")) {
+		SVC_Info( from );
+	} else if (!strcmp(c,"connect")) {
+		SV_DirectConnect( from );
+	} else if (!strcmp(c,"disconnect")) {
+		// if a client starts up a local server, we may see some spurious
+		// server disconnect messages when their new server sees our final
+		// sequenced messages to the old client
+	} else {
+		Com_DPrintf ("bad connectionless packet from %s:\n%s\n"
+		, NET_AdrToString (from), s);
+	}
+}
+
+
+//============================================================================
+
+/*
+=================
+SV_ReadPackets
+=================
+*/
+void SV_PacketEvent( netadr_t from, msg_t *msg ) {
+	int			i;
+	client_t	*cl;
+	int			qport;
+
+	// check for connectionless packet (0xffffffff) first
+	if ( msg->cursize >= 4 && *(int *)msg->data == -1) {
+		SV_ConnectionlessPacket( from, msg );
+		return;
+	}
+
+	// read the qport out of the message so we can fix up
+	// stupid address translating routers
+	MSG_BeginReading( msg );
+	MSG_ReadLong( msg );				// sequence number
+	MSG_ReadLong( msg );				// sequence number
+	qport = MSG_ReadShort( msg ) & 0xffff;
+
+	// find which client the message is from
+	for (i=0, cl=svs.clients ; i < 1 ; i++,cl++) {
+		if (cl->state == CS_FREE) {
+			continue;
+		}
+		if ( !NET_CompareBaseAdr( from, cl->netchan.remoteAddress ) ) {
+			continue;
+		}
+		// it is possible to have multiple clients from a single IP
+		// address, so they are differentiated by the qport variable
+		if (cl->netchan.qport != qport) {
+			continue;
+		}
+
+		// the IP port can't be used to differentiate them, because
+		// some address translating routers periodically change UDP
+		// port assignments
+		if (cl->netchan.remoteAddress.port != from.port) {
+			Com_Printf( "SV_ReadPackets: fixing up a translated port\n" );
+			cl->netchan.remoteAddress.port = from.port;
+		}
+
+		// make sure it is a valid, in sequence packet
+		if (Netchan_Process(&cl->netchan, msg)) {
+			// zombie clients stil neet to do the Netchan_Process
+			// to make sure they don't need to retransmit the final
+			// reliable message, but they don't do any other processing
+			if (cl->state != CS_ZOMBIE) {
+				cl->lastPacketTime = sv.time;	// don't timeout
+				cl->frames[ cl->netchan.incomingAcknowledged & PACKET_MASK ]
+					.messageAcked = sv.time;
+				SV_ExecuteClientMessage( cl, msg );
+			}
+		}
+		return;
+	}
+	
+	// if we received a sequenced packet from an address we don't reckognize,
+	// send an out of band disconnect packet to it
+	NET_OutOfBandPrint( NS_SERVER, from, "disconnect" );
+}
+
+
+/*
+===================
+SV_CalcPings
+
+Updates the cl->ping variables
+===================
+*/
+void SV_CalcPings (void) {
+	int			i, j;
+	client_t	*cl;
+	int			total, count;
+	int			delta;
+
+	for (i=0 ; i < 1 ; i++) {
+		cl = &svs.clients[i];
+		if ( cl->state != CS_ACTIVE ) {
+			continue;
+		}
+		if ( cl->gentity->svFlags & SVF_BOT ) {
+			continue;
+		}
+
+		total = 0;
+		count = 0;
+		for ( j = 0 ; j < PACKET_BACKUP ; j++ ) {
+			delta = cl->frames[j].messageAcked - cl->frames[j].messageSent;
+			if ( delta >= 0 ) {
+				count++;
+				total += delta;
+			}
+		}
+		if (!count) {
+			cl->ping = 999;
+		} else {
+			cl->ping = total/count;
+			if ( cl->ping > 999 ) {
+				cl->ping = 999;
+			}
+		}
+
+		// let the game dll know about the ping
+		cl->gentity->client->ping = cl->ping;
+	}
+}
+
+/*
+==================
+SV_CheckTimeouts
+
+If a packet has not been received from a client for timeout->integer 
+seconds, drop the conneciton.  Server time is used instead of
+realtime to avoid dropping the local client while debugging.
+
+When a client is normally dropped, the client_t goes into a zombie state
+for a few seconds to make sure any final reliable message gets resent
+if necessary
+==================
+*/
+void SV_CheckTimeouts( void ) {
+	int		i;
+	client_t	*cl;
+	int			droppoint;
+	int			zombiepoint;
+
+	droppoint = sv.time - 1000 * sv_timeout->integer;
+	zombiepoint = sv.time - 1000 * sv_zombietime->integer;
+
+	for (i=0,cl=svs.clients ; i < 1 ; i++,cl++) {
+		// message times may be wrong across a changelevel
+		if (cl->lastPacketTime > sv.time) {
+			cl->lastPacketTime = sv.time;
+		}
+
+		if (cl->state == CS_ZOMBIE
+		&& cl->lastPacketTime < zombiepoint) {
+			cl->state = CS_FREE;	// can now be reused
+			continue;
+		}
+		if ( cl->state >= CS_CONNECTED && cl->lastPacketTime < droppoint) {
+			// wait several frames so a debugger session doesn't
+			// cause a timeout
+			if ( ++cl->timeoutCount > 5 ) {
+				SV_DropClient (cl, "timed out"); 
+				cl->state = CS_FREE;	// don't bother with zombie state
+			}
+		} else {
+			cl->timeoutCount = 0;
+		}
+	}
+}
+
+
+/*
+==================
+SV_CheckPaused
+==================
+*/
+qboolean SV_CheckPaused( void ) {
+	if ( !cl_paused->integer ) {
+		return qfalse;
+	}
+
+	sv_paused->integer = 1;
+	return qtrue;
+}
+
+/*
+This wonderful hack is needed to avoid rendering frames until several camera related things
+have wended their way through the network. The problem is basically that the server asks the
+client where the camera is to decide what entities down to the client. However right after
+certain transitions the client tends to give a wrong answer. CGCam_Disable is one such time/
+When this happens we want to dump all rendered frame until these things have happened, in 
+order:
+
+0) (This state will mean that we are awaiting state 1)
+1) The server has run a frame and built a packet
+2) The client has computed a camera position
+3) The server has run a frame and built a packet
+4) The client has recieved a packet (This state also means the game is running normally).
+
+We will keep track of this here:
+
+*/
+
+
+/*
+==================
+SV_Frame
+
+Player movement occurs as a result of packet events, which
+happen before SV_Frame is called
+==================
+*/
+extern cvar_t	*cl_newClock;
+void SV_Frame( int msec,float fractionMsec ) {
+	int		frameMsec;
+	int		startTime=0;
+
+	// the menu kills the server with this cvar
+	if ( sv_killserver->integer ) {
+		SV_Shutdown ("Server was killed.\n");
+		Cvar_Set( "sv_killserver", "0" );
+		return;
+	}
+
+	if ( !com_sv_running->integer ) {
+		return;
+	}
+
+ 	extern void SE_CheckForLanguageUpdates(void);
+	SE_CheckForLanguageUpdates();	// will fast-return else load different language if menu changed it
+
+	// allow pause if only the local client is connected
+	if ( SV_CheckPaused() ) {
+		return;
+	}
+
+	// go ahead and let time slip if the server really hitched badly
+	if ( msec > 1000 ) {
+		Com_DPrintf( "SV_Frame: Truncating msec of %i to 1000\n", msec );
+		msec = 1000;
+	}
+
+	// if it isn't time for the next frame, do nothing
+	if ( sv_fps->integer < 1 ) {
+		Cvar_Set( "sv_fps", "10" );
+	}
+	frameMsec = 1000 / sv_fps->integer ;
+
+	sv.timeResidual += msec;
+	sv.timeResidualFraction+=fractionMsec;
+	if (sv.timeResidualFraction>=1.0f)
+	{
+		sv.timeResidualFraction-=1.0f;
+		if (cl_newClock&&cl_newClock->integer)
+		{
+			sv.timeResidual++;
+		}
+	}
+	if ( sv.timeResidual < frameMsec ) {
+		return;
+	}
+
+	// if time is about to hit the 32nd bit, restart the
+	// level, which will force the time back to zero, rather
+	// than checking for negative time wraparound everywhere.
+	// 2giga-milliseconds = 23 days, so it won't be too often
+	if ( sv.time > 0x70000000 ) {
+		SV_Shutdown( "Restarting server due to time wrapping" );
+		Com_Printf("You win.  if you can play this long and not die, you deserve to win.\n");
+		return;
+	}
+
+	// update infostrings if anything has been changed
+	if ( cvar_modifiedFlags & CVAR_SERVERINFO ) {
+		SV_SetConfigstring( CS_SERVERINFO, Cvar_InfoString( CVAR_SERVERINFO ) );
+		cvar_modifiedFlags &= ~CVAR_SERVERINFO;
+	}
+	if ( cvar_modifiedFlags & CVAR_SYSTEMINFO ) {
+		SV_SetConfigstring( CS_SYSTEMINFO, Cvar_InfoString( CVAR_SYSTEMINFO ) );
+		cvar_modifiedFlags &= ~CVAR_SYSTEMINFO;
+	}
+
+	if ( com_speeds->integer ) {
+		startTime = Sys_Milliseconds ();
+	}
+
+//	SV_BotFrame( sv.time );
+
+	// run the game simulation in chunks
+	while ( sv.timeResidual >= frameMsec ) {
+		sv.timeResidual -= frameMsec;
+		sv.time += frameMsec;
+		G2API_SetTime(sv.time,G2T_SV_TIME);
+
+		// let everything in the world think and move
+		ge->RunFrame( sv.time );
+	}
+
+	if ( com_speeds->integer ) {
+		time_game = Sys_Milliseconds () - startTime;
+	}
+
+	SG_TestSave();	// returns immediately if not active, used for fake-save-every-cycle to test (mainly) Icarus disk code
+
+	// check timeouts
+	SV_CheckTimeouts ();
+
+	// update ping based on the last known frame from all clients
+	SV_CalcPings ();
+
+	// send messages back to the clients
+	SV_SendClientMessages ();
+}
+
+//============================================================================
+
diff --git a/code/server/sv_savegame.cpp b/code/server/sv_savegame.cpp
new file mode 100644
index 0000000..590a912
--- /dev/null
+++ b/code/server/sv_savegame.cpp
@@ -0,0 +1,2002 @@
+// Filename:-	sv_savegame.cpp
+//
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+// a little naughty, since these are in the renderer, but I need access to them for savegames, so...
+//
+extern void Decompress_JPG( const char *filename, byte *pJPGData, unsigned char **pic, int *width, int *height );
+extern byte *Compress_JPG(int *pOutputSize, int quality, int image_width, int image_height, byte *image_buffer, qboolean bInvertDuringCompression);
+
+#define JPEG_IMAGE_QUALITY 95
+
+
+//#define USE_LAST_SAVE_FROM_THIS_MAP	// enable this if you want to use the last explicity-loaded savegame from this map
+				 						//	when respawning after dying, else it'll just load "auto" regardless 
+										//	(EF1 behaviour). I should maybe time/date check them though?
+
+#include "server.h"
+#include "..\game\statindex.h"
+#include "..\game\weapons.h"
+#include "..\game\g_items.h"
+
+#ifdef _XBOX
+#include <stdlib.h>
+//support for mbstowcs
+HANDLE sg_Handle;
+#define SG_BUFFERSIZE 8192
+byte sg_Buffer[SG_BUFFERSIZE];
+int sg_BufferSize;
+//used for save game reading
+int sg_CurrentBufferPos;
+
+#define filepathlength 120
+
+struct XValidationHeader
+{
+    // Length of the file, including header, in bytes
+    DWORD dwFileLength;
+
+    // File signature (secure hash of file data)
+    XCALCSIG_SIGNATURE Signature;
+};
+
+//validation header going into file and coming out of file
+XValidationHeader sg_validationHeader;
+//validation header calculated on file read to test against file
+XValidationHeader sg_validationHeaderRead;
+
+//signature handle
+HANDLE sg_sigHandle;
+
+
+int SG_Write(const void * chid, const int bytesize, fileHandle_t fhSG);
+qboolean SG_Close();
+int SG_Seek( fileHandle_t fhSaveGame, long offset, int origin );
+
+
+
+#endif
+
+#pragma warning(disable : 4786)  // identifier was truncated (STL crap)
+#pragma warning(disable : 4710)  // function was not inlined (STL crap)
+#pragma warning(disable : 4512)  // yet more STL drivel...
+
+#include <map>
+
+using namespace std;
+
+static char	saveGameComment[iSG_COMMENT_SIZE];
+
+//#define SG_PROFILE	// enable for debug save stats if you want
+
+int giSaveGameVersion;	// filled in when a savegame file is opened
+fileHandle_t fhSaveGame = 0;
+SavedGameJustLoaded_e eSavedGameJustLoaded = eNO;
+qboolean qbSGReadIsTestOnly = qfalse;	// this MUST be left in this state
+char sLastSaveFileLoaded[MAX_QPATH]={0};
+
+#define iSG_MAPCMD_SIZE MAX_QPATH
+
+#ifndef LPCSTR
+typedef const char * LPCSTR;
+#endif
+
+
+static char *SG_GetSaveGameMapName(const char *psPathlessBaseName);
+static void CompressMem_FreeScratchBuffer(void);
+
+
+#ifdef SG_PROFILE
+
+class CChid
+{
+private:
+	int		m_iCount;
+	int		m_iSize;
+public:
+	CChid()
+	{
+		m_iCount = 0;
+		m_iSize = 0;
+	}
+	void Add(int iLength)
+	{
+		m_iCount++;
+		m_iSize += iLength;
+	}
+	int GetCount()
+	{
+		return m_iCount;
+	}
+	int GetSize()
+	{
+		return m_iSize;
+	}
+};
+
+typedef map<unsigned long, CChid> CChidInfo_t;
+CChidInfo_t	save_info;
+#endif
+
+LPCSTR SG_GetChidText(unsigned long chid)
+{
+	static char	chidtext[5];
+
+	*(unsigned long *)chidtext = BigLong(chid);
+	chidtext[4] = 0;
+
+	return chidtext;
+}
+
+
+static const char *GetString_FailedToOpenSaveGame(const char *psFilename, qboolean bOpen)
+{
+	static char sTemp[256];
+
+	strcpy(sTemp,S_COLOR_RED);
+	
+	const char *psReference = bOpen ? "MENUS_FAILED_TO_OPEN_SAVEGAME" : "MENUS3_FAILED_TO_CREATE_SAVEGAME";
+	Q_strncpyz(sTemp + strlen(sTemp), va( SE_GetString(psReference), psFilename),sizeof(sTemp));
+	strcat(sTemp,"\n");
+	return sTemp;
+}
+
+// (copes with up to 8 ptr returns at once)
+//
+static LPCSTR SG_AddSavePath( LPCSTR psPathlessBaseName )
+{
+	static char sSaveName[8][MAX_OSPATH]; 
+	static int  i=0;
+
+	i=++i&7;
+
+	if(psPathlessBaseName)
+	{
+		char *p = strchr(psPathlessBaseName,'/');
+		if (p)
+		{
+			while (p)
+			{
+				*p = '_';
+				p = strchr(p,'/');
+			}
+		}
+	}
+	Com_sprintf( sSaveName[i], MAX_OSPATH, "saves/%s.sav", psPathlessBaseName );
+	return sSaveName[i];
+}
+
+void SG_WipeSavegame( LPCSTR psPathlessBaseName )
+{
+#ifndef _XBOX
+	LPCSTR psLocalFilename  = SG_AddSavePath( psPathlessBaseName );
+	
+	FS_DeleteUserGenFile( psLocalFilename );
+#else
+	unsigned short namebuffer[filepathlength];
+	mbstowcs(namebuffer, psPathlessBaseName,filepathlength);
+	//kill the whole directory
+	//remove it
+	XDeleteSaveGame( "U:\\", namebuffer);
+#endif
+}
+
+static qboolean SG_Move( LPCSTR psPathlessBaseName_Src, LPCSTR psPathlessBaseName_Dst )
+{
+
+
+#ifndef _XBOX
+	LPCSTR psLocalFilename_Src = SG_AddSavePath( psPathlessBaseName_Src );
+	LPCSTR psLocalFilename_Dst = SG_AddSavePath( psPathlessBaseName_Dst );
+
+	qboolean qbCopyWentOk = FS_MoveUserGenFile( psLocalFilename_Src, psLocalFilename_Dst );
+
+	if (!qbCopyWentOk)
+	{
+		Com_Printf(S_COLOR_RED "Error during savegame-rename. Check \"%s\" for write-protect or disk full!\n", psLocalFilename_Dst );
+		return qfalse;
+	}
+
+	return qtrue;
+#else
+	char psLocalFilenameSrc[filepathlength];
+	char psLocalFilenameDest[filepathlength];
+	unsigned short widecharstring[filepathlength];
+	mbstowcs(widecharstring, psPathlessBaseName_Dst, filepathlength);
+
+	if ( ERROR_SUCCESS != XCreateSaveGame("U:\\", widecharstring, OPEN_ALWAYS, 0, psLocalFilenameDest, filepathlength))
+		return qfalse;
+	mbstowcs(widecharstring, psPathlessBaseName_Src, filepathlength);
+	if ( ERROR_SUCCESS != XCreateSaveGame("U:\\", widecharstring, OPEN_ALWAYS, 0, psLocalFilenameSrc, filepathlength))
+	{
+		return qfalse;
+	}
+
+
+	Q_strcat(psLocalFilenameDest, filepathlength, "JK3SG.xsv");
+	Q_strcat(psLocalFilenameSrc, filepathlength, "JK3SG.xsv");
+
+	CopyFile( psLocalFilenameSrc, psLocalFilenameDest,false);
+
+	
+	return qtrue;
+	
+#endif
+}
+
+
+/* JLFSAVEGAME used to find if there is a file on the xbox */
+#ifdef _XBOX
+qboolean SG_Exists(LPCSTR psPathlessBaseName)
+{
+	char psLocalFilename[filepathlength];
+	unsigned short widecharstring[filepathlength];
+	mbstowcs(widecharstring, psPathlessBaseName, filepathlength);
+	if ( ERROR_SUCCESS != XCreateSaveGame("U:\\", widecharstring, CREATE_NEW, 0, psLocalFilename, filepathlength))
+	{
+		return qtrue;
+	}
+	if ( ERROR_SUCCESS == XDeleteSaveGame("U:\\", widecharstring))
+	{
+		return qfalse;
+	}
+	assert(0);
+	return qfalse;
+}
+#endif
+
+
+qboolean gbSGWriteFailed = qfalse;
+
+static qboolean SG_Create( LPCSTR psPathlessBaseName )
+{
+	gbSGWriteFailed = qfalse;
+
+#ifdef _XBOX
+	char psLocalFilename[filepathlength];
+	char psScreenshotFilename[filepathlength];
+	unsigned short widecharstring[filepathlength];
+	mbstowcs(widecharstring, psPathlessBaseName, filepathlength);
+	if ( ERROR_SUCCESS != XCreateSaveGame("U:\\", widecharstring, OPEN_ALWAYS, 0, psLocalFilename, filepathlength))
+		return qfalse;
+
+	// create the path for the screenshot file
+	strcpy(psScreenshotFilename, psLocalFilename);
+	Q_strcat(psScreenshotFilename, filepathlength,"saveimage.xbx");
+
+	// create the path for the savegame
+	Q_strcat(psLocalFilename, filepathlength, "JK3SG.xsv");
+
+	sg_Handle = CreateFile(psLocalFilename, GENERIC_WRITE, FILE_SHARE_READ, 0, 
+		OPEN_ALWAYS,	FILE_ATTRIBUTE_NORMAL, 0);
+	//clear the buffer
+	sg_BufferSize = 0;
+
+	DWORD bytesWritten;
+// save spot for validation
+	WriteFile(sg_Handle,            // handle to file
+			  &sg_validationHeader,                // data buffer
+				sizeof (sg_validationHeader),     // number of bytes to write
+				&bytesWritten,  // number of bytes written
+				NULL        // overlapped buffer
+				);
+	//start the validation key creation
+	// Start the signature hash
+    sg_sigHandle = XCalculateSignatureBegin( 0 );
+    if( sg_sigHandle == INVALID_HANDLE_VALUE )
+        return FALSE;
+
+	// attempt to copy the last screenshot to the save game directory	
+	if( !CopyFile("u:\\saveimage.xbx", psScreenshotFilename, FALSE) )
+	{
+		CopyFile("d:\\base\\media\\defaultsaveimage.xbx", psScreenshotFilename, FALSE);
+	}
+
+#else
+	SG_WipeSavegame( psPathlessBaseName );
+	LPCSTR psLocalFilename = SG_AddSavePath( psPathlessBaseName );		
+	fhSaveGame = FS_FOpenFileWrite( psLocalFilename );
+#endif
+
+#ifdef _XBOX
+	if (!sg_Handle)
+#else
+	if(!fhSaveGame)
+#endif
+	{
+		Com_Printf(GetString_FailedToOpenSaveGame(psLocalFilename,qfalse));//S_COLOR_RED "Failed to create new savegame file \"%s\"\n", psLocalFilename );
+		return qfalse;
+	}
+
+#ifdef SG_PROFILE
+	assert( save_info.empty() );
+#endif
+
+	giSaveGameVersion = iSAVEGAME_VERSION;
+	SG_Append('_VER', &giSaveGameVersion, sizeof(giSaveGameVersion));
+
+	return qtrue;
+}
+
+// called from the ERR_DROP stuff just in case the error occured during loading of a saved game, because if
+//	we didn't do this then we'd run out of quake file handles after the 8th load fail...
+//
+void SG_Shutdown()
+{
+	if (fhSaveGame )
+	{
+		FS_FCloseFile( fhSaveGame );
+		fhSaveGame = NULL;
+	}
+
+	eSavedGameJustLoaded = eNO;	// important to do this if we ERR_DROP during loading, else next map you load after
+								//	a bad save-file you'll arrive at dead :-)
+
+	// and this bit stops people messing up the laoder by repeatedly stabbing at the load key during loads...
+	//
+	extern qboolean gbAlreadyDoingLoad;
+					gbAlreadyDoingLoad = qfalse;
+}
+
+#ifdef _XBOX
+
+qboolean SG_CloseWrite()
+{
+	DWORD bytesWritten;
+	//clear the buffer to the file
+	if (!WriteFile(sg_Handle,                    // handle to file
+					sg_Buffer,                // data buffer
+					sg_BufferSize,     // number of bytes to write
+					&bytesWritten,  // number of bytes written
+					NULL        // overlapped buffer
+					))
+				return qfalse;
+	//get the length of the file
+	unsigned int filelength =GetFileSize (sg_Handle, NULL);
+	// create the validation code
+	sg_validationHeader.dwFileLength = filelength;
+	// Release signature resources
+    DWORD dwSuccess =XCalculateSignatureEnd( sg_sigHandle, &sg_validationHeader.Signature );
+	assert( dwSuccess == ERROR_SUCCESS );
+	//seek to the first of the file
+	SG_Seek(NULL,0,FS_SEEK_SET);
+	//SetFilePointer(sg_Handle,0,0,FILE_BEGIN);
+	//write the validation codes
+	WriteFile (sg_Handle, &sg_validationHeader,sizeof (sg_validationHeader),&bytesWritten, NULL);
+	return SG_Close();
+}
+#endif
+
+
+
+
+
+
+qboolean SG_Close()
+{
+#ifdef _XBOX
+	CloseHandle(sg_Handle);
+	sg_Handle = NULL;
+
+#else
+	assert( fhSaveGame );	
+	FS_FCloseFile( fhSaveGame );
+#endif
+	fhSaveGame = NULL;
+
+#ifdef SG_PROFILE
+	if (!sv_testsave->integer)
+	{
+		CChidInfo_t::iterator it;
+		int iCount = 0, iSize = 0;
+
+		Com_DPrintf(S_COLOR_CYAN "================================\n");
+		Com_DPrintf(S_COLOR_WHITE "CHID   Count      Size\n\n");
+		for(it = save_info.begin(); it != save_info.end(); ++it)
+		{
+			Com_DPrintf("%s   %5d  %8d\n", SG_GetChidText((*it).first), (*it).second.GetCount(), (*it).second.GetSize());
+			iCount += (*it).second.GetCount();
+			iSize  += (*it).second.GetSize();
+		}
+		Com_DPrintf("\n" S_COLOR_WHITE "%d chunks making %d bytes\n", iCount, iSize);
+		Com_DPrintf(S_COLOR_CYAN "================================\n");
+		save_info.clear();
+	}
+#endif
+
+	CompressMem_FreeScratchBuffer();
+	return qtrue;
+}
+
+
+qboolean SG_Open( LPCSTR psPathlessBaseName )
+{	
+//	if ( fhSaveGame )		// hmmm...
+//	{						//
+//		SG_Close();			//
+//	}						//
+	assert( !fhSaveGame);	// I'd rather know about this
+	if(!psPathlessBaseName)
+	{
+		return qfalse;
+	}
+//JLFSAVEGAME
+
+#ifdef _XBOX
+	unsigned short saveGameName[filepathlength];
+	char directoryInfo[filepathlength];
+	char psLocalFilename[filepathlength];
+	DWORD bytesRead;
+	
+	mbstowcs(saveGameName, psPathlessBaseName,filepathlength);
+	
+	XCreateSaveGame("U:\\", saveGameName, OPEN_ALWAYS, 0,directoryInfo, filepathlength);
+
+	strcpy (psLocalFilename , directoryInfo);
+	strcat (psLocalFilename , "JK3SG.xsv");
+
+	sg_Handle = NULL;
+	sg_Handle = CreateFile(psLocalFilename, GENERIC_READ, FILE_SHARE_READ, 0, 
+		OPEN_EXISTING,	FILE_ATTRIBUTE_NORMAL, 0);
+
+	if (!sg_Handle)
+#else
+
+	LPCSTR psLocalFilename = SG_AddSavePath( psPathlessBaseName );	
+	FS_FOpenFileRead( psLocalFilename, &fhSaveGame, qtrue );	//qtrue = dup handle, so I can close it ok later
+	if (!fhSaveGame)
+#endif
+
+	{
+//		Com_Printf(S_COLOR_RED "Failed to open savegame file %s\n", psLocalFilename);
+		Com_DPrintf(GetString_FailedToOpenSaveGame(psLocalFilename, qtrue));
+
+		return qfalse;
+	}
+#ifdef _XBOX
+	//read the validation header
+	if (!ReadFile( sg_Handle, &sg_validationHeader, sizeof(sg_validationHeader), &bytesRead,  NULL ))
+	{
+		SG_Close();
+		Com_Printf (S_COLOR_RED "File \"%s\" has no sig");
+		return qfalse;
+	}
+	//initialize buffer data
+	sg_BufferSize = 0;
+	sg_CurrentBufferPos =0;
+
+#endif
+	giSaveGameVersion=-1;//jic
+	SG_Read('_VER', &giSaveGameVersion, sizeof(giSaveGameVersion));
+	if (giSaveGameVersion != iSAVEGAME_VERSION)
+	{
+		SG_Close();
+		Com_Printf (S_COLOR_RED "File \"%s\" has version # %d (expecting %d)\n",psPathlessBaseName, giSaveGameVersion, iSAVEGAME_VERSION);
+		return qfalse;
+	}
+
+	return qtrue;
+}
+
+// you should only call this when you know you've successfully opened a savegame, and you want to query for
+//	whether it's an old (street-copy) version, or a new (expansion-pack) version
+//
+int SG_Version(void)
+{
+	return giSaveGameVersion;
+}
+
+void SV_WipeGame_f(void)
+{
+	if (Cmd_Argc() != 2)
+	{
+		Com_Printf (S_COLOR_RED "USAGE: wipe <name>\n");
+		return;
+	}
+	if (!stricmp (Cmd_Argv(1), "auto") )
+	{
+		Com_Printf (S_COLOR_RED "Can't wipe 'auto'\n");
+		return;
+	}
+	SG_WipeSavegame(Cmd_Argv(1));
+//	Com_Printf("%s has been wiped\n", Cmd_Argv(1));	// wurde gelöscht in german, but we've only got one string
+//	Com_Printf("Ok\n"); // no localization of this
+}
+
+/*
+// Store given string in saveGameComment for later use when game is 
+// actually saved
+*/
+void SG_StoreSaveGameComment(const char *sComment)
+{	
+	memmove(saveGameComment,sComment,iSG_COMMENT_SIZE);
+}
+
+qboolean SV_TryLoadTransition( const char *mapname )
+{
+	char *psFilename = va( "hub/%s", mapname );
+
+	Com_Printf (S_COLOR_CYAN "Restoring game \"%s\"...\n", psFilename);
+
+	if ( !SG_ReadSavegame( psFilename ) )
+	{//couldn't load a savegame
+		return qfalse;
+	}
+	Com_Printf (S_COLOR_CYAN "%s.\n",SE_GetString("MENUS_DONE"));
+
+	return qtrue;
+}
+
+qboolean gbAlreadyDoingLoad = qfalse;
+void SV_LoadGame_f(void)
+{
+	if (gbAlreadyDoingLoad)
+	{
+		Com_DPrintf ("( Already loading, ignoring extra 'load' commands... )\n");
+		return;
+	}
+
+//	// check server is running
+//	//
+//	if ( !com_sv_running->integer )
+//	{
+//		Com_Printf( "Server is not running\n" );
+//		return;
+//	}
+
+	if (Cmd_Argc() != 2)
+	{
+		Com_Printf ("USAGE: load <filename>\n");
+		return;
+	}
+
+	const char *psFilename = Cmd_Argv(1);
+	if (strstr (psFilename, "..") || strstr (psFilename, "/") || strstr (psFilename, "\\") )
+	{
+		Com_Printf (S_COLOR_RED "Bad loadgame name.\n");
+		return;
+	}
+
+#ifndef _XBOX	// VVFIXME : Part of super-bootleg SG hackery
+	if (!stricmp (psFilename, "current"))
+	{
+		Com_Printf (S_COLOR_RED "Can't load from \"current\"\n");
+		return;
+	}
+#endif
+
+	// special case, if doing a respawn then check that the available auto-save (if any) is from the same map
+	//	as we're currently on (if in a map at all), if so, load that "auto", else re-load the last-loaded file...
+	//
+	if (!stricmp(psFilename, "*respawn"))
+	{
+		psFilename = "auto";	// default to standard respawn behaviour
+
+		// see if there's a last-loaded file to even check against as regards loading...
+		//
+		if ( sLastSaveFileLoaded[0] )
+		{
+			LPCSTR psServerInfo = sv.configstrings[CS_SERVERINFO];
+			LPCSTR psMapName    = Info_ValueForKey( psServerInfo, "mapname" );
+
+			char *psMapNameOfAutoSave = SG_GetSaveGameMapName("auto");
+
+			if ( !Q_stricmp(psMapName,"_brig") )
+			{//if you're in the brig and there is no autosave, load the last loaded savegame
+				if ( !psMapNameOfAutoSave )
+				{
+					psFilename = sLastSaveFileLoaded;
+				}				
+			}
+			else
+			{
+#ifdef USE_LAST_SAVE_FROM_THIS_MAP
+				// if the map name within the name of the last save file we explicitly loaded is the same
+				//	as the current map, then use that...
+				//
+				char *psMapNameOfLastSaveFileLoaded = SG_GetSaveGameMapName(sLastSaveFileLoaded);
+
+				if (!Q_stricmp(psMapName,psMapNameOfLastSaveFileLoaded)))
+				{
+					psFilename = sLastSaveFileLoaded;
+				}							
+				else 
+#endif
+				if (!(psMapName && psMapNameOfAutoSave && !Q_stricmp(psMapName,psMapNameOfAutoSave)))
+				{
+					// either there's no auto file, or it's from a different map to the one we've just died on...
+					//
+					psFilename = sLastSaveFileLoaded;
+				}
+			}
+		}
+		//default will continue to load auto
+	}
+	Com_Printf (S_COLOR_CYAN "%s\n",va(SE_GetString("MENUS_LOADING_MAPNAME"), psFilename));
+
+	gbAlreadyDoingLoad = qtrue;
+	if (!SG_ReadSavegame(psFilename)) {
+		gbAlreadyDoingLoad = qfalse; //	do NOT do this here now, need to wait until client spawn, unless the load failed.
+	} else
+	{
+		Com_Printf (S_COLOR_CYAN "%s.\n",SE_GetString("MENUS_DONE"));
+	}
+}
+
+qboolean SG_GameAllowedToSaveHere(qboolean inCamera);
+
+
+//JLF notes
+//	save game will be in charge of creating a new directory
+void SV_SaveGame_f(void)
+{
+	// check server is running
+	//
+	if ( !com_sv_running->integer )
+	{
+		Com_Printf( S_COLOR_RED "Server is not running\n" );
+		return;
+	}
+
+	if (sv.state != SS_GAME)
+	{
+		Com_Printf (S_COLOR_RED "You must be in a game to save.\n");
+		return;
+	}
+
+	// check args...
+	//
+	if ( Cmd_Argc() != 2 ) 
+	{
+		Com_Printf( "USAGE: \"save <filename>\"\n" );
+		return;
+	}
+
+
+	if (svs.clients[0].frames[svs.clients[0].netchan.outgoingSequence & PACKET_MASK].ps.stats[STAT_HEALTH] <= 0)
+	{
+		Com_Printf (S_COLOR_RED "\n%s\n", SE_GetString("SP_INGAME_CANT_SAVE_DEAD"));
+		return;
+	}
+
+	//this check catches deaths even the instant you die, like during a slo-mo death!
+	gentity_t			*svent;
+	svent = SV_GentityNum(0);
+	if (svent->client->stats[STAT_HEALTH]<=0)
+	{
+		Com_Printf (S_COLOR_RED "\n%s\n", SE_GetString("SP_INGAME_CANT_SAVE_DEAD"));
+		return;
+	}
+
+	char *psFilename = Cmd_Argv(1);
+
+	if (!stricmp (psFilename, "current"))
+	{
+		Com_Printf (S_COLOR_RED "Can't save to 'current'\n");
+		return;
+	}
+
+	if (strstr (psFilename, "..") || strstr (psFilename, "/") || strstr (psFilename, "\\") )
+	{
+		Com_Printf (S_COLOR_RED "Bad savegame name.\n");
+		return;
+	}
+
+	if (!SG_GameAllowedToSaveHere(qfalse))	//full check
+		return;	// this prevents people saving via quick-save now during cinematics.
+
+	if ( !stricmp (psFilename, "auto") )
+	{
+		
+#ifdef _XBOX
+		extern void	SCR_PrecacheScreenshot();  //scr_scrn.cpp
+		SCR_PrecacheScreenshot();
+#endif
+		SG_StoreSaveGameComment("");	// clear previous comment/description, which will force time/date comment.
+	}
+
+	Com_Printf (S_COLOR_CYAN "%s \"%s\"...\n", SE_GetString("CON_TEXT_SAVING_GAME"), psFilename);
+
+	if (SG_WriteSavegame(psFilename, qfalse))
+	{
+		Com_Printf (S_COLOR_CYAN "%s.\n",SE_GetString("MENUS_DONE"));
+	}
+	else
+	{
+		Com_Printf (S_COLOR_RED "%s.\n",SE_GetString("MENUS_FAILED_TO_OPEN_SAVEGAME"));
+	}
+}
+
+
+
+//---------------
+static void WriteGame(qboolean autosave)
+{
+	SG_Append('GAME', &autosave, sizeof(autosave));	
+
+	if (autosave)
+	{
+		// write out player ammo level, health, etc...
+		//
+		extern void SV_Player_EndOfLevelSave(void);
+		SV_Player_EndOfLevelSave();	// this sets up the various cvars needed, so we can then write them to disk
+		//
+		char s[MAX_STRING_CHARS];
+		
+		// write health/armour etc...
+		//
+		memset(s,0,sizeof(s));
+		Cvar_VariableStringBuffer( sCVARNAME_PLAYERSAVE, s, sizeof(s) );
+		SG_Append('CVSV', &s, sizeof(s));	
+
+		// write ammo...
+		//
+		memset(s,0,sizeof(s));
+		Cvar_VariableStringBuffer( "playerammo", s, sizeof(s) );
+		SG_Append('AMMO', &s, sizeof(s));
+
+		// write inventory...
+		//
+		memset(s,0,sizeof(s));
+		Cvar_VariableStringBuffer( "playerinv", s, sizeof(s) );
+		SG_Append('IVTY', &s, sizeof(s));
+		
+		// the new JK2 stuff - force powers, etc...
+		//
+		memset(s,0,sizeof(s));
+		Cvar_VariableStringBuffer( "playerfplvl", s, sizeof(s) );
+		SG_Append('FPLV', &s, sizeof(s));
+	}
+}
+
+static qboolean ReadGame (void)
+{
+	qboolean qbAutoSave;
+	SG_Read('GAME', (void *)&qbAutoSave, sizeof(qbAutoSave));
+
+	if (qbAutoSave)
+	{
+		char s[MAX_STRING_CHARS]={0};
+
+		// read health/armour etc...
+		//
+		memset(s,0,sizeof(s));
+		SG_Read('CVSV', (void *)&s, sizeof(s));
+		Cvar_Set( sCVARNAME_PLAYERSAVE, s );
+
+		// read ammo...
+		//
+		memset(s,0,sizeof(s));			
+		SG_Read('AMMO', (void *)&s, sizeof(s));
+		Cvar_Set( "playerammo", s);
+
+		// read inventory...
+		//
+		memset(s,0,sizeof(s));			
+		SG_Read('IVTY', (void *)&s, sizeof(s));
+		Cvar_Set( "playerinv", s);
+
+		// read force powers...
+		//
+		memset(s,0,sizeof(s));
+		SG_Read('FPLV', (void *)&s, sizeof(s));
+		Cvar_Set( "playerfplvl", s );
+	}
+
+	return qbAutoSave;
+}
+
+//---------------
+
+
+// write all CVAR_SAVEGAME cvars
+// these will be things like model, name, ...
+//
+extern  cvar_t	*cvar_vars;	// I know this is really unpleasant, but I need access for scanning/writing latched cvars during save games
+
+void SG_WriteCvars(void)
+{
+	cvar_t	*var;
+	int		iCount = 0;
+
+	// count the cvars...
+	//	
+	for (var = cvar_vars; var; var = var->next)
+	{
+		if (!(var->flags & CVAR_SAVEGAME))
+		{
+			continue;
+		}
+		iCount++;
+	}
+
+	// store count...
+	//
+	SG_Append('CVCN', &iCount, sizeof(iCount));
+
+	// write 'em...
+	//
+	for (var = cvar_vars; var; var = var->next)
+	{
+		if (!(var->flags & CVAR_SAVEGAME))
+		{
+			continue;
+		}
+		SG_Append('CVAR', var->name,   strlen(var->name) + 1);
+		SG_Append('VALU', var->string, strlen(var->string) + 1);
+	}
+}
+
+void SG_ReadCvars(void)
+{
+	int		iCount;
+	char	*psName;
+	char	*psValue;
+
+	SG_Read('CVCN', &iCount, sizeof(iCount));
+
+	for (int i = 0; i < iCount; i++)
+	{
+		SG_Read('CVAR', NULL, 0, (void **)&psName);
+		SG_Read('VALU', NULL, 0, (void **)&psValue);
+
+		Cvar_Set (psName, psValue);
+
+		Z_Free( psName );
+		Z_Free( psValue );
+	}
+}
+
+void SG_WriteServerConfigStrings( void )
+{
+	int iCount = 0;
+	int i;	// not in FOR statement in case compiler goes weird by reg-optimising it then failing to get the address later
+
+	// count how many non-blank server strings there are...
+	//
+	for ( i=0; i<MAX_CONFIGSTRINGS; i++)
+	{
+		if (i!=CS_SYSTEMINFO)
+		{
+			if (sv.configstrings[i] && strlen(sv.configstrings[i]))		// paranoia... <g>
+			{
+				iCount++;
+			}
+		}
+	}
+
+	SG_Append('CSCN', &iCount, sizeof(iCount));
+
+	// now write 'em...
+	//
+	for (i=0; i<MAX_CONFIGSTRINGS; i++)
+	{
+		if (i!=CS_SYSTEMINFO)
+		{
+			if (sv.configstrings[i]	&& strlen(sv.configstrings[i]))
+			{
+				SG_Append('CSIN', &i, sizeof(i));
+				SG_Append('CSDA', sv.configstrings[i], strlen(sv.configstrings[i])+1);
+			}
+		}
+	}	
+}
+
+void SG_ReadServerConfigStrings( void )
+{
+	// trash the whole table...
+	//
+	for (int i=0; i<MAX_CONFIGSTRINGS; i++)
+	{
+		if (i!=CS_SYSTEMINFO)
+		{
+			if ( sv.configstrings[i] ) 
+			{
+				Z_Free( sv.configstrings[i] );			
+			}
+			sv.configstrings[i] = CopyString("");
+		}
+	}
+
+	// now read the replacement ones...
+	//
+	int iCount;		
+
+	SG_Read('CSCN', &iCount, sizeof(iCount));
+
+	Com_DPrintf( "Reading %d configstrings...\n",iCount);
+
+	for (i=0; i<iCount; i++)
+	{
+		int iIndex;
+		char *psName;
+
+		SG_Read('CSIN', &iIndex, sizeof(iIndex));
+		SG_Read('CSDA', NULL, 0, (void **)&psName);
+
+		Com_DPrintf( "Cfg str %d = %s\n",iIndex, psName);
+
+		//sv.configstrings[iIndex] = psName;
+		SV_SetConfigstring(iIndex, psName);
+		Z_Free(psName);
+	}
+}
+
+
+
+static void SG_WriteComment(qboolean qbAutosave, LPCSTR psMapName)
+{
+	char	sComment[iSG_COMMENT_SIZE];
+
+	if ( qbAutosave || !*saveGameComment)
+	{
+		Com_sprintf( sComment, sizeof(sComment), "---> %s", psMapName );
+	}
+	else
+	{
+		strcpy(sComment,saveGameComment);
+	}
+
+	SG_Append('COMM', sComment, sizeof(sComment));
+
+	// Add Date/Time/Map stamp
+	time_t now;
+	time(&now);
+	SG_Append('CMTM', &now, sizeof(time_t));
+
+	Com_DPrintf("Saving: current (%s)\n", sComment);
+}
+
+
+// Test to see if the given file name is in the save game directory 
+// then grab the comment if it's there
+//
+int SG_GetSaveGameComment(const char *psPathlessBaseName, char *sComment, char *sMapName)
+{
+	int ret = 0;
+	time_t tFileTime;
+
+	qbSGReadIsTestOnly = qtrue;	// do NOT leave this in this state
+
+	if ( !SG_Open( psPathlessBaseName ))
+	{
+		qbSGReadIsTestOnly = qfalse;
+		return 0;
+	}							
+
+	if (SG_Read( 'COMM', sComment, iSG_COMMENT_SIZE ))
+	{	
+		if (SG_Read( 'CMTM', &tFileTime, sizeof( time_t )))	//read
+		{	
+			if (SG_Read('MPCM', sMapName, iSG_MAPCMD_SIZE ))	// read
+			{
+				ret = tFileTime;
+			}
+		}
+	}
+	qbSGReadIsTestOnly = qfalse;
+
+	if (!SG_Close())
+	{
+		return 0;
+	}			
+	return ret;
+}
+
+
+// read the mapname field from the supplied savegame file
+//
+// returns NULL if not found
+//
+static char *SG_GetSaveGameMapName(const char *psPathlessBaseName)
+{
+	static char sMapName[iSG_MAPCMD_SIZE]={0};
+	char *psReturn = NULL;	
+	if (SG_GetSaveGameComment(psPathlessBaseName, NULL, sMapName))
+	{
+		psReturn = sMapName;
+	}
+
+	return psReturn;
+}
+
+
+// pass in qtrue to set as loading screen, else pass in pvDest to read it into there...
+//
+/*
+static qboolean SG_ReadScreenshot(qboolean qbSetAsLoadingScreen, void *pvDest = NULL);
+static qboolean SG_ReadScreenshot(qboolean qbSetAsLoadingScreen, void *pvDest)
+{
+#ifdef _XBOX
+	return qfalse;
+#else
+	qboolean bReturn = qfalse;
+
+	// get JPG screenshot data length...
+	//
+	int iScreenShotLength = 0;
+	SG_Read('SHLN', &iScreenShotLength, sizeof(iScreenShotLength));
+	//
+	// alloc enough space plus extra 4K for sloppy JPG-decode reader to not do memory access violation...
+	//
+	byte *pJPGData = (byte *) Z_Malloc(iScreenShotLength + 4096,TAG_TEMP_SAVEGAME_WORKSPACE, qfalse);
+	//
+	// now read the JPG data...
+	//
+	SG_Read('SHOT', pJPGData, iScreenShotLength, 0);	
+	//
+	// decompress JPG data...
+	//
+	byte *pDecompressedPic = NULL;
+	int iWidth, iHeight;
+	Decompress_JPG( "[savegame]", pJPGData, &pDecompressedPic, &iWidth, &iHeight );
+	//
+	// if the loaded image is the same size as the game is expecting, then copy it to supplied arg (if present)...
+	//
+	if (iWidth == SG_SCR_WIDTH && iHeight == SG_SCR_HEIGHT)
+	{			
+		bReturn = qtrue;
+		
+		if (pvDest)
+		{
+			memcpy(pvDest, pDecompressedPic, SG_SCR_WIDTH * SG_SCR_HEIGHT * 4);
+		}		
+
+		if (qbSetAsLoadingScreen)
+		{
+			SCR_SetScreenshot((byte *)pDecompressedPic, SG_SCR_WIDTH, SG_SCR_HEIGHT);
+		}
+	}
+
+	Z_Free( pJPGData );
+	Z_Free( pDecompressedPic );
+
+	return bReturn;
+#endif
+}
+// Gets the savegame screenshot
+//
+qboolean SG_GetSaveImage( const char *psPathlessBaseName, void *pvAddress )
+{
+	if(!psPathlessBaseName)
+	{
+		return qfalse;
+	}
+//JLFSAVEGAME
+#if 0
+	unsigned short saveGameName[filepathlength];
+	char directoryInfo[filepathlength];
+	char psLocalFilename[filepathlength];
+	DWORD bytesRead;
+	
+	mbstowcs(saveGameName, psPathlessBaseName,filepathlength);
+	
+	XCreateSaveGame("U:\\", saveGameName, OPEN_ALWAYS, 0,directoryInfo, filepathlength);
+
+	strcpy (psLocalFilename , directoryInfo);
+	strcat (psLocalFilename , "saveimage.xbx");
+
+
+	sg_Handle = NULL;
+	sg_Handle = CreateFile(psLocalFilename, GENERIC_READ, FILE_SHARE_READ, 0, 
+		OPEN_EXISTING,	FILE_ATTRIBUTE_NORMAL, 0);
+
+	if (!sg_Handle)
+		return qfalse;
+
+
+
+#else
+
+	if (!SG_Open(psPathlessBaseName))
+	{
+		return qfalse;
+	}
+	
+	SG_Read('COMM', NULL, 0, NULL);	// skip
+	SG_Read('CMTM', NULL, sizeof( time_t ));
+
+	qboolean bGotSaveImage = SG_ReadScreenshot(qfalse, pvAddress);
+
+	SG_Close();
+#endif
+	return bGotSaveImage;
+}
+
+
+static void SG_WriteScreenshot(qboolean qbAutosave, LPCSTR psMapName)
+{
+#ifndef _XBOX
+	byte *pbRawScreenShot = NULL;
+
+	if( qbAutosave )
+	{
+		// try to read a levelshot (any valid TGA/JPG etc named the same as the map)...
+		//
+		int iWidth = SG_SCR_WIDTH;
+		int iHeight= SG_SCR_HEIGHT;
+		byte	byBlank[SG_SCR_WIDTH * SG_SCR_HEIGHT * 4] = {0};
+
+		pbRawScreenShot = SCR_TempRawImage_ReadFromFile(va("levelshots/%s.tga",psMapName), &iWidth, &iHeight, byBlank, qtrue);	// qtrue = vert flip
+	}
+
+	if (!pbRawScreenShot)
+	{
+		pbRawScreenShot = SCR_GetScreenshot(0);
+	}
+
+
+	int iJPGDataSize = 0;
+	byte *pJPGData = Compress_JPG(&iJPGDataSize, JPEG_IMAGE_QUALITY, SG_SCR_WIDTH, SG_SCR_HEIGHT, pbRawScreenShot, qfalse);
+	SG_Append('SHLN', &iJPGDataSize, sizeof(iJPGDataSize));
+	SG_Append('SHOT', pJPGData, iJPGDataSize);
+	Z_Free(pJPGData);
+	SCR_TempRawImage_CleanUp();
+#endif
+}
+*/
+
+qboolean SG_GameAllowedToSaveHere(qboolean inCamera)
+{
+	if (!inCamera) {
+		if ( !com_sv_running || !com_sv_running->integer )
+		{
+			return qfalse;	//		Com_Printf( S_COLOR_RED "Server is not running\n" );		
+		}
+		
+		if (CL_IsRunningInGameCinematic())
+		{
+			return qfalse;	//nope, not during a video
+		}
+
+		if (sv.state != SS_GAME)
+		{
+			return qfalse;	//		Com_Printf (S_COLOR_RED "You must be in a game to save.\n");
+		}
+		
+		//No savegames from "_" maps
+		if ( !sv_mapname || (sv_mapname->string != NULL && sv_mapname->string[0] == '_') )
+		{
+			return qfalse;	//		Com_Printf (S_COLOR_RED "Cannot save on holodeck or brig.\n");
+		}
+		
+		if (svs.clients[0].frames[svs.clients[0].netchan.outgoingSequence & PACKET_MASK].ps.stats[STAT_HEALTH] <= 0)
+		{
+			return qfalse;	//		Com_Printf (S_COLOR_RED "\nCan't savegame while dead!\n");
+		}
+	}
+	if (!ge)
+		return inCamera;	// only happens when called to test if inCamera
+
+	return ge->GameAllowedToSaveHere();
+}
+
+qboolean SG_WriteSavegame(const char *psPathlessBaseName, qboolean qbAutosave)
+{	
+	if (!qbAutosave && !SG_GameAllowedToSaveHere(qfalse))	//full check
+		return qfalse;	// this prevents people saving via quick-save now during cinematics
+
+	int iPrevTestSave = sv_testsave->integer;
+	sv_testsave->integer = 0;
+
+	// Write out server data...
+	//
+	LPCSTR psServerInfo = sv.configstrings[CS_SERVERINFO];
+	LPCSTR psMapName    = Info_ValueForKey( psServerInfo, "mapname" );
+//JLF
+#ifdef _XBOX
+	char mapname[filepathlength];
+	char numberedmapname[filepathlength];
+	int mapnumber =0;
+	char numberbuffer[10];
+	if ( !strcmp("JKSG3",psPathlessBaseName))
+	{
+		//strcpy(mapname, psMapName);
+		strcpy (mapname, psPathlessBaseName);
+		strcpy( numberedmapname, mapname);
+	}
+	else
+	{
+		strcpy(mapname, psMapName);
+		strcpy(numberedmapname, psPathlessBaseName);
+	}
+	while (!qbAutosave && SG_Exists( numberedmapname))
+	{
+		strcpy( numberedmapname, mapname);
+		
+		Com_sprintf(numberbuffer,sizeof(numberbuffer),"_%02i",mapnumber);
+		strcat ( numberedmapname,numberbuffer);
+		mapnumber++;
+	}
+	SG_Create( numberedmapname);
+
+#else
+	if ( !strcmp("quick",psPathlessBaseName))
+	{
+		SG_StoreSaveGameComment(va("--> %s <--",psMapName));
+	}
+
+	if(!SG_Create( "current" ))
+			{
+		Com_Printf (GetString_FailedToOpenSaveGame("current",qfalse));//S_COLOR_RED "Failed to create savegame\n");
+		SG_WipeSavegame( "current" );
+		sv_testsave->integer = iPrevTestSave;
+		return qfalse;
+	}
+#endif
+//END JLF
+
+	char   sMapCmd[iSG_MAPCMD_SIZE]={0};
+	strcpy( sMapCmd,psMapName);	// need as array rather than ptr because const strlen needed for MPCM chunk
+
+	SG_WriteComment(qbAutosave, sMapCmd);
+//	SG_WriteScreenshot(qbAutosave, sMapCmd);
+	SG_Append('MPCM', sMapCmd, sizeof(sMapCmd));
+	SG_WriteCvars();
+
+	WriteGame (qbAutosave);
+
+	// Write out all the level data...
+	//
+	if (!qbAutosave)
+	{
+		SG_Append('TIME', (void *)&sv.time, sizeof(sv.time));
+		SG_Append('TIMR', (void *)&sv.timeResidual, sizeof(sv.timeResidual));
+		CM_WritePortalState();
+		SG_WriteServerConfigStrings();		
+	}
+	ge->WriteLevel(qbAutosave);	// always done now, but ent saver only does player if auto
+#ifdef _XBOX
+	SG_CloseWrite();
+#else
+	SG_Close();
+#endif
+	if (gbSGWriteFailed)
+	{
+		Com_Printf (GetString_FailedToOpenSaveGame("current",qfalse));//S_COLOR_RED "Failed to write savegame!\n");
+		SG_WipeSavegame( "current" );
+		sv_testsave->integer = iPrevTestSave;
+		return qfalse;
+	}
+
+	SG_Move( "current", psPathlessBaseName );
+
+
+	sv_testsave->integer = iPrevTestSave;
+	return qtrue;
+}
+
+qboolean SG_ReadSavegame(const char *psPathlessBaseName)
+{
+	char		sComment[iSG_COMMENT_SIZE];
+	char		sMapCmd [iSG_MAPCMD_SIZE];
+	qboolean	qbAutosave;
+
+	int iPrevTestSave = sv_testsave->integer;
+	sv_testsave->integer = 0;
+
+	if (!SG_Open( psPathlessBaseName ))
+	{
+		Com_Printf (GetString_FailedToOpenSaveGame(psPathlessBaseName, qtrue));//S_COLOR_RED "Failed to open savegame \"%s\"\n", psPathlessBaseName);
+		sv_testsave->integer = iPrevTestSave;
+		return qfalse;
+	}
+
+	// this check isn't really necessary, but it reminds me that these two strings may actually be the same physical one.
+	//
+	if (psPathlessBaseName != sLastSaveFileLoaded)
+	{
+		Q_strncpyz(sLastSaveFileLoaded,psPathlessBaseName,sizeof(sLastSaveFileLoaded));
+	}
+
+	// Read in all the server data...
+	//
+	SG_Read('COMM', sComment, sizeof(sComment));
+	Com_DPrintf("Reading: %s\n", sComment);
+	SG_Read( 'CMTM', NULL, sizeof( time_t ));
+
+//	SG_ReadScreenshot(qtrue);	// qboolean qbSetAsLoadingScreen
+	SG_Read('MPCM', sMapCmd, sizeof(sMapCmd));
+	SG_ReadCvars();
+
+	// read game state
+	qbAutosave = ReadGame();
+	eSavedGameJustLoaded = (qbAutosave)?eAUTO:eFULL;
+
+	SV_SpawnServer(sMapCmd, eForceReload_NOTHING, (eSavedGameJustLoaded != eFULL) );	// note that this also trashes the whole G_Alloc pool as well (of course)		
+
+	// read in all the level data...
+	//
+	if (!qbAutosave)
+	{
+		SG_Read('TIME', (void *)&sv.time, sizeof(sv.time));
+		SG_Read('TIMR', (void *)&sv.timeResidual, sizeof(sv.timeResidual));
+		CM_ReadPortalState();
+		SG_ReadServerConfigStrings();		
+	}
+	ge->ReadLevel(qbAutosave, qbLoadTransition);	// always done now, but ent reader only does player if auto
+
+	if(!SG_Close())
+	{
+		Com_Printf (GetString_FailedToOpenSaveGame(psPathlessBaseName,qfalse));//S_COLOR_RED "Failed to close savegame\n");
+		sv_testsave->integer = iPrevTestSave;
+		return qfalse;
+	}
+
+	sv_testsave->integer = iPrevTestSave;
+	return qtrue;
+}
+
+
+int Compress_RLE(const byte *pIn, int iLength, byte *pOut)
+{
+	int iCount=0,iOutIndex=0;
+	
+	while (iCount < iLength) 
+	{
+		int iIndex = iCount;
+		byte b = pIn[iIndex++];
+
+		while (iIndex<iLength && iIndex-iCount<127 && pIn[iIndex]==b)
+		{
+			iIndex++;
+		}
+
+		if (iIndex-iCount == 1) 
+		{
+			while (iIndex<iLength && iIndex-iCount<127 && (pIn[iIndex]!=pIn[iIndex-1] || iIndex>1 && pIn[iIndex]!=pIn[iIndex-2])){
+				iIndex++;
+			}
+			while (iIndex<iLength && pIn[iIndex]==pIn[iIndex-1]){
+				iIndex--;
+			}
+			pOut[iOutIndex++] = (unsigned char)(iCount-iIndex);
+			for (int i=iCount; i<iIndex; i++){
+				pOut[iOutIndex++] = pIn[i];
+			}
+		}
+		else 
+		{
+			pOut[iOutIndex++] = (unsigned char)(iIndex-iCount);
+			pOut[iOutIndex++] = b;
+		}
+		iCount=iIndex;
+	}
+	return iOutIndex;
+}
+
+void DeCompress_RLE(byte *pOut, const byte *pIn, int iDecompressedBytesRemaining)
+{
+	signed char count;
+	
+	while (iDecompressedBytesRemaining > 0) 
+	{
+		count = (signed char) *pIn++;
+		if (count>0) 
+		{
+			memset(pOut,*pIn++,count);
+		} 
+		else 
+		if (count<0)
+		{
+			count = (signed char) -count;
+			memcpy(pOut,pIn,count);
+			pIn += count;
+		}
+		pOut += count;
+		iDecompressedBytesRemaining -= count;
+	}
+}
+
+// simulate decompression over original data (but don't actually do it), to test de/compress validity...
+//
+qboolean Verify_RLE(const byte *pOut, const byte *pIn, int iDecompressedBytesRemaining)
+{
+	signed char count;
+	const byte *pOutEnd = &pOut[iDecompressedBytesRemaining];
+	
+	while (iDecompressedBytesRemaining > 0) 
+	{			
+		if (pOut >= pOutEnd)
+			return qfalse;
+		count = (signed char) *pIn++;
+		if (count>0) 
+		{	
+			//memset(pOut,*pIn++,count);
+			int iMemSetByte = *pIn++;
+			for (int i=0; i<count; i++)
+			{
+				if (pOut[i] != iMemSetByte)
+					return qfalse;
+			}
+		} 
+		else 
+		if (count<0)
+		{
+			count = (signed char) -count;
+//			memcpy(pOut,pIn,count);
+			if (memcmp(pOut,pIn,count))
+				return qfalse;
+			pIn += count;
+		}
+		pOut += count;
+		iDecompressedBytesRemaining -= count;
+	}
+
+	if (pOut != pOutEnd)
+		return qfalse;
+
+	return qtrue;
+}
+
+
+byte *gpbCompBlock = NULL;
+int   giCompBlockSize = 0;
+static void CompressMem_FreeScratchBuffer(void)
+{
+	if ( gpbCompBlock )
+	{
+		Z_Free(	gpbCompBlock);
+				gpbCompBlock = NULL;
+	}
+	giCompBlockSize = 0;
+}
+
+static byte *CompressMem_AllocScratchBuffer(int iSize)
+{
+	// only alloc new buffer if we need more than the existing one...
+	//
+	if (giCompBlockSize < iSize)
+	{			
+		CompressMem_FreeScratchBuffer();
+
+		gpbCompBlock = (byte *) Z_Malloc(iSize, TAG_TEMP_WORKSPACE, qfalse);
+		giCompBlockSize = iSize;
+	}
+
+	return gpbCompBlock;
+}
+
+// returns -1 for compression-not-worth-it, else compressed length...
+//
+int CompressMem(byte *pbData, int iLength, byte *&pbOut)
+{ 	
+	if (!sv_compress_saved_games->integer)
+		return -1;
+
+	// malloc enough to cope with uncompressable data (it'll never grow to 2* size, so)...
+	//
+	pbOut = CompressMem_AllocScratchBuffer(iLength*2);	
+	//
+	// compress it...
+	//
+	int iOutputLength = Compress_RLE(pbData, iLength, pbOut);
+	//
+	// worth compressing?...
+	//
+	if (iOutputLength >= iLength)
+		return -1;
+	//
+	// compression code works? (I'd hope this is always the case, but for safety)...
+	//
+	if (!Verify_RLE(pbData, pbOut, iLength))
+		return -1;
+
+	return iOutputLength;
+}
+
+
+#ifdef _XBOX// function for xbox
+/*
+int SG_Write(const void * chid, const int bytesize, fileHandle_t fhSG)
+{
+	DWORD bytesWritten;
+	int currentsize;
+
+	
+	if (!WriteFile(sg_Handle,                    // handle to file
+							chid,                // data buffer
+							bytesize,     // number of bytes to write
+							&bytesWritten,  // number of bytes written
+							NULL        // overlapped buffer
+							))
+		{
+			return 0;
+		}
+
+		return bytesWritten;
+}
+*/
+
+
+int SG_Write(const void * chid, const int bytesize, fileHandle_t fhSG)
+{
+	DWORD bytesWritten;
+	int currentsize;
+
+	if (sg_BufferSize + bytesize>= SG_BUFFERSIZE)
+	{	
+		if (!WriteFile(sg_Handle,                    // handle to file
+							sg_Buffer,                // data buffer
+							sg_BufferSize,     // number of bytes to write
+							&bytesWritten,  // number of bytes written
+							NULL        // overlapped buffer
+							))
+	//	return bytesWritten;
+//	else
+		{
+			return 0;
+		}
+		
+		DWORD dwSuccess = XCalculateSignatureUpdate( sg_sigHandle, (BYTE*)(sg_Buffer),
+                                                     sg_BufferSize);
+		sg_BufferSize = 0;
+
+
+	}
+	if (bytesize >= SG_BUFFERSIZE)
+	{
+		if (!WriteFile(sg_Handle,                    // handle to file
+							chid,                // data buffer
+							bytesize,     // number of bytes to write
+							&bytesWritten,  // number of bytes written
+							NULL        // overlapped buffer
+							))
+		{
+			return 0;
+		}
+		DWORD dwSuccess = XCalculateSignatureUpdate( sg_sigHandle, (BYTE*)(chid),
+                                                     bytesize);
+		sg_BufferSize = 0;
+	}
+	else
+	{
+
+		byte * tempptr = &(sg_Buffer[sg_BufferSize]);
+		memcpy(tempptr, chid, bytesize);
+		sg_BufferSize += bytesize;
+	}
+		return bytesize;
+}
+
+#else
+//pass through function
+int SG_Write(const void * chid, const int bytesize, fileHandle_t fhSaveGame)
+{
+		return FS_Write( chid, bytesize, fhSaveGame);
+}
+
+#endif
+
+
+
+qboolean SG_Append(unsigned long chid, const void *pvData, int iLength)
+{	
+	unsigned int	uiCksum;
+	unsigned int	uiSaved;
+	
+#ifdef _DEBUG
+	int				i;
+	unsigned long	*pTest;
+
+	pTest = (unsigned long *) pvData;
+	for (i=0; i<iLength/4; i++, pTest++)
+	{
+		assert(*pTest != 0xfeeefeee);
+		assert(*pTest != 0xcdcdcdcd);
+		assert(*pTest != 0xdddddddd);
+	}
+#endif
+
+	Com_DPrintf("Attempting write of chunk %s length %d\n", SG_GetChidText(chid), iLength);
+
+	// only write data out if we're not in test mode....
+	//
+	if (!sv_testsave->integer)
+	{
+		uiCksum = Com_BlockChecksum (pvData, iLength);
+
+		uiSaved  = SG_Write(&chid,		sizeof(chid),		fhSaveGame);
+
+		byte *pbCompressedData = NULL;
+		int iCompressedLength = CompressMem((byte*)pvData, iLength, pbCompressedData);
+		if (iCompressedLength != -1)
+		{
+			// compressed...  (write length field out as -ve)
+			//
+			iLength = -iLength;
+			uiSaved += SG_Write(&iLength,			sizeof(iLength),			fhSaveGame);
+			iLength = -iLength;
+			//
+			// [compressed length]
+			//
+			uiSaved += SG_Write(&iCompressedLength, sizeof(iCompressedLength),	fhSaveGame);
+			//
+			// compressed data...
+			//
+			uiSaved += SG_Write(pbCompressedData,	iCompressedLength,			fhSaveGame);
+			//
+			// CRC...
+			//
+			uiSaved += SG_Write(&uiCksum,			sizeof(uiCksum),			fhSaveGame);
+
+			if (uiSaved != sizeof(chid) + sizeof(iLength) + sizeof(uiCksum) + sizeof(iCompressedLength) + iCompressedLength)
+			{
+				Com_Printf(S_COLOR_RED "Failed to write %s chunk\n", SG_GetChidText(chid));
+				gbSGWriteFailed = qtrue;
+				return qfalse;
+			}
+		}
+		else
+		{
+			// uncompressed...
+			//
+			uiSaved += SG_Write(&iLength,	sizeof(iLength),	fhSaveGame);
+			//
+			// uncompressed data...
+			//
+			uiSaved += SG_Write( pvData,	iLength,			fhSaveGame);
+			//
+			// CRC...
+			//
+			uiSaved += SG_Write(&uiCksum,	sizeof(uiCksum),	fhSaveGame);
+
+			if (uiSaved != sizeof(chid) + sizeof(iLength) + sizeof(uiCksum) + iLength)
+			{
+				Com_Printf(S_COLOR_RED "Failed to write %s chunk\n", SG_GetChidText(chid));
+				gbSGWriteFailed = qtrue;
+				return qfalse;
+			}
+		}
+		
+		#ifdef SG_PROFILE
+		save_info[chid].Add(iLength);
+		#endif
+	}
+
+	return qtrue;
+}
+
+
+#ifdef _XBOX// function for xbox
+//SG_ReadBytes replaces FS_Read. I was going to use SG_Read but it is already in use
+/*
+int SG_ReadBytes(void * chid, int bytesize, fileHandle_t fhSG)
+{  
+	byte* bufferptr;
+	unsigned char* destptr;
+	DWORD retBytesRead=0;
+	DWORD bytesRead =0;
+	int segmentLength;
+	
+
+	//bufferptr = (byte*)chid;
+	//destptr = NULL;
+	
+	if (ReadFile(sg_Handle,                    // handle to file
+				chid,                // data buffer
+				bytesize,     // number of bytes to write
+				&bytesRead,  // number of bytes written
+				NULL        // overlapped buffer
+				))
+		{	return bytesRead;
+		}
+		else
+		{
+			return 0;
+		}
+		
+	return retBytesRead;
+}
+*/
+
+int SG_ReadBytes(void * chid, int bytesize, fileHandle_t fhSG)
+{  
+	byte* bufferptr;
+	unsigned char* destptr;
+	DWORD retBytesRead=0;
+	DWORD bytesRead =0;
+	int segmentLength;
+	
+
+	//bufferptr = (byte*)chid;
+	//destptr = NULL;
+	
+	if ( bytesize < (sg_BufferSize - sg_CurrentBufferPos))
+	{
+		bufferptr = &(sg_Buffer[sg_CurrentBufferPos]);
+		memcpy(chid,bufferptr, bytesize);
+		sg_CurrentBufferPos+= bytesize;
+		retBytesRead = bytesize;
+	}
+	else
+	{
+		destptr = (byte*)((void*)chid);
+
+ 		while ( bytesize >0)
+		{
+			bufferptr = &(sg_Buffer[sg_CurrentBufferPos]);
+			segmentLength = sg_BufferSize - sg_CurrentBufferPos;
+			if (segmentLength <= bytesize)
+			{
+				memcpy(destptr, bufferptr, segmentLength);
+				destptr += segmentLength;
+				retBytesRead += segmentLength;
+				bytesize -= segmentLength;
+				sg_CurrentBufferPos += segmentLength;
+			}
+			else
+			{
+				memcpy(destptr, bufferptr, bytesize);
+				destptr += bytesize;
+				retBytesRead += bytesize;
+				sg_CurrentBufferPos += bytesize;
+				bytesize -= bytesize;
+				
+			}
+	
+			if (sg_BufferSize - sg_CurrentBufferPos <= 0 && bytesize >0)
+			{
+				if (ReadFile(sg_Handle,                    // handle to file
+							sg_Buffer,                // data buffer
+							SG_BUFFERSIZE,     // number of bytes to write
+							&bytesRead,  // number of bytes written
+							NULL        // overlapped buffer
+							))
+				{
+					sg_BufferSize = bytesRead;
+					sg_CurrentBufferPos = 0;
+					bufferptr = sg_Buffer;
+					//sig processing
+				}
+				else
+				{
+					return 0;
+				}
+			}
+
+		}
+	}
+	return retBytesRead;
+}
+
+
+
+// handle offset origin
+//fhSaveGame not used (use global variable)
+int SG_Seek( fileHandle_t fhSaveGame, long offset, int origin )
+{
+	switch (origin)
+	{
+	case FS_SEEK_CUR:
+		return SetFilePointer(
+					sg_Handle,                // handle to file
+					offset,        // bytes to move pointer
+					NULL,		   // bytes to move pointer
+					FILE_CURRENT   // starting point
+				);
+		break;
+	case FS_SEEK_END:
+		return SetFilePointer(
+					sg_Handle,                // handle to file
+					offset,        // bytes to move pointer
+					NULL,		   // bytes to move pointer
+					FILE_END   // starting point
+				);
+		break;
+	default:
+        //FS_SEEK_SET:
+		return SetFilePointer(
+					sg_Handle,                // handle to file
+					offset,        // bytes to move pointer
+					NULL,		   // bytes to move pointer
+					FILE_BEGIN   // starting point
+				);
+	}
+	return 0;
+}
+
+#else
+//pass through function
+int SG_ReadBytes(void * chid, int bytesize, fileHandle_t fhSaveGame)
+{
+	return FS_Read( chid, bytesize, fhSaveGame);
+}
+
+
+int SG_Seek( fileHandle_t fhSaveGame, long offset, int origin )
+{
+	return FS_Seek(fhSaveGame, offset, origin);
+}
+
+#endif
+
+
+
+// Pass in pvAddress (or NULL if you want memory to be allocated)
+//	if pvAddress==NULL && ppvAddressPtr == NULL then the block is discarded/skipped.
+//
+// If iLength==0 then it counts as a query, else it must match the size found in the file
+//
+// function doesn't return if error (uses ERR_DROP), unless "qbSGReadIsTestOnly == qtrue", then NZ return = success
+//
+static int SG_Read_Actual(unsigned long chid, void *pvAddress, int iLength, void **ppvAddressPtr, qboolean bChunkIsOptional)
+{
+	unsigned int	uiLoadedCksum, uiCksum;
+	unsigned int	uiLoadedLength;
+	unsigned long	ulLoadedChid;
+	unsigned int	uiLoaded;
+	char			sChidText1[MAX_QPATH];
+	char			sChidText2[MAX_QPATH];
+	qboolean		qbTransient = qfalse;
+
+	Com_DPrintf("Attempting read of chunk %s length %d\n", SG_GetChidText(chid), iLength);
+
+	// Load in chid and length...
+	//
+	uiLoaded = SG_ReadBytes( &ulLoadedChid,   sizeof(ulLoadedChid),	fhSaveGame);
+	uiLoaded+= SG_ReadBytes( &uiLoadedLength, sizeof(uiLoadedLength),fhSaveGame);
+
+	qboolean bBlockIsCompressed = ((int)uiLoadedLength < 0);
+	if (	 bBlockIsCompressed)
+	{
+		uiLoadedLength = -((int)uiLoadedLength);
+	}
+
+	// Make sure we are loading the correct chunk...
+	//
+	if( ulLoadedChid != chid)
+	{
+		if (bChunkIsOptional)
+		{
+			SG_Seek( fhSaveGame, -(int)uiLoaded, FS_SEEK_CUR );
+			return 0;
+		}
+
+		strcpy(sChidText1, SG_GetChidText(ulLoadedChid));
+		strcpy(sChidText2, SG_GetChidText(chid));
+		if (!qbSGReadIsTestOnly)
+		{
+			Com_Error(ERR_DROP, "Loaded chunk ID (%s) does not match requested chunk ID (%s)", sChidText1, sChidText2);
+		}
+		return 0;
+	}
+
+	// Find length of chunk and make sure it matches the requested length...
+	//
+	if( iLength )	// .. but only if there was one specified
+	{
+		if(iLength != (int)uiLoadedLength)
+		{
+			if (!qbSGReadIsTestOnly)
+			{
+				Com_Error(ERR_DROP, "Loaded chunk (%s) has different length than requested", SG_GetChidText(chid));
+			}
+			return 0;
+		}
+	}
+	iLength = uiLoadedLength;	// for retval
+
+	// alloc?...
+	//
+	if ( !pvAddress )
+	{
+		pvAddress = Z_Malloc(iLength, TAG_SAVEGAME, qfalse);
+		//
+		// Pass load address back...
+		//
+		if( ppvAddressPtr )
+		{
+			*ppvAddressPtr = pvAddress;
+		}
+		else
+		{
+			qbTransient = qtrue;	// if no passback addr, mark block for skipping
+		}
+	}
+
+	// Load in data and magic number...
+	//
+	unsigned int uiCompressedLength=0;
+	if (bBlockIsCompressed)
+	{
+		//
+		// read compressed data length...
+		//
+		uiLoaded += SG_ReadBytes( &uiCompressedLength, sizeof(uiCompressedLength),fhSaveGame);
+		//
+		// alloc space...
+		//	
+		byte *pTempRLEData = (byte *)Z_Malloc(uiCompressedLength, TAG_SAVEGAME, qfalse);
+		//
+		// read compressed data...
+		//
+		uiLoaded += SG_ReadBytes( pTempRLEData,  uiCompressedLength, fhSaveGame );
+		//
+		// decompress it...
+		//
+		DeCompress_RLE((byte *)pvAddress, pTempRLEData, iLength);
+		//
+		// free workspace...
+		//
+		Z_Free( pTempRLEData );
+	}
+	else
+	{
+		uiLoaded += SG_ReadBytes(  pvAddress, iLength, fhSaveGame );
+	}
+	// Get checksum...
+	//
+	uiLoaded += SG_ReadBytes( &uiLoadedCksum,  sizeof(uiLoadedCksum), fhSaveGame );
+
+	// Make sure the checksums match...
+	//
+	uiCksum = Com_BlockChecksum( pvAddress, iLength );
+	if ( uiLoadedCksum != uiCksum)
+	{
+		if (!qbSGReadIsTestOnly)
+		{
+			Com_Error(ERR_DROP, "Failed checksum check for chunk", SG_GetChidText(chid));
+		}
+		else
+		{
+			if ( qbTransient )
+			{
+				Z_Free( pvAddress );
+			}
+		}
+		return 0;
+	}
+
+	// Make sure we didn't encounter any read errors...
+	//size_t
+	if ( uiLoaded != sizeof(ulLoadedChid) + sizeof(uiLoadedLength) + sizeof(uiLoadedCksum) + (bBlockIsCompressed?sizeof(uiCompressedLength):0) + (bBlockIsCompressed?uiCompressedLength:iLength))
+	{
+		if (!qbSGReadIsTestOnly)
+		{
+			Com_Error(ERR_DROP, "Error during loading chunk %s", SG_GetChidText(chid));
+		}
+		else
+		{
+			if ( qbTransient )
+			{
+				Z_Free( pvAddress );
+			}
+		}
+		return 0;
+	}
+
+	// If we are skipping the chunk, then free the memory...
+	//
+	if ( qbTransient )
+	{
+		Z_Free( pvAddress );
+	}
+
+	return iLength;
+}
+
+int SG_Read(unsigned long chid, void *pvAddress, int iLength, void **ppvAddressPtr /* = NULL */)
+{
+	return SG_Read_Actual(chid, pvAddress, iLength, ppvAddressPtr, qfalse );	// qboolean bChunkIsOptional
+}
+
+int SG_ReadOptional(unsigned long chid, void *pvAddress, int iLength, void **ppvAddressPtr /* = NULL */)
+{
+	return SG_Read_Actual(chid, pvAddress, iLength, ppvAddressPtr, qtrue);		// qboolean bChunkIsOptional
+}
+
+
+void SG_TestSave(void)
+{
+	if (sv_testsave->integer && sv.state == SS_GAME)
+	{
+		WriteGame (false);
+		ge->WriteLevel(false);
+	}
+}
+
+////////////////// eof ////////////////////
+
diff --git a/code/server/sv_snapshot.cpp b/code/server/sv_snapshot.cpp
new file mode 100644
index 0000000..b627362
--- /dev/null
+++ b/code/server/sv_snapshot.cpp
@@ -0,0 +1,749 @@
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+
+
+#include "..\client\vmachine.h"
+#include "server.h"
+
+
+/*
+=============================================================================
+
+Delta encode a client frame onto the network channel
+
+A normal server packet will look like:
+
+4	sequence number (high bit set if an oversize fragment)
+<optional reliable commands>
+1	svc_snapshot
+4	last client reliable command
+4	serverTime
+1	lastframe for delta compression
+1	snapFlags
+1	areaBytes
+<areabytes>
+<playerstate>
+<packetentities>
+
+=============================================================================
+*/
+
+/*
+=============
+SV_EmitPacketEntities
+
+Writes a delta update of an entityState_t list to the message.
+=============
+*/
+static void SV_EmitPacketEntities( clientSnapshot_t *from, clientSnapshot_t *to, msg_t *msg ) {
+	entityState_t	*oldent, *newent;
+	int		oldindex, newindex;
+	int		oldnum, newnum;
+	int		from_num_entities;
+
+	// generate the delta update
+	if ( !from ) {
+		from_num_entities = 0;
+	} else {
+		from_num_entities = from->num_entities;
+	}
+
+	newent = NULL;
+	oldent = NULL;
+	newindex = 0;
+	oldindex = 0;
+	const int num2Send = to->num_entities >= svs.numSnapshotEntities ? svs.numSnapshotEntities : to->num_entities;
+
+	while ( newindex < num2Send || oldindex < from_num_entities ) {
+		if ( newindex >= num2Send ) {
+			newnum = 9999;
+		} else {
+			newent = &svs.snapshotEntities[(to->first_entity+newindex) % svs.numSnapshotEntities];
+			newnum = newent->number;
+		}
+
+		if ( oldindex >= from_num_entities ) {
+			oldnum = 9999;
+		} else {
+			oldent = &svs.snapshotEntities[(from->first_entity+oldindex) % svs.numSnapshotEntities];
+			oldnum = oldent->number;
+		}
+
+		if ( newnum == oldnum ) {
+			// delta update from old position
+			// because the force parm is qfalse, this will not result
+			// in any bytes being emited if the entity has not changed at all
+			MSG_WriteEntity(msg, newent, 0);
+			oldindex++;
+			newindex++;
+			continue;
+		}
+
+		if ( newnum < oldnum ) {
+			// this is a new entity, send it from the baseline
+			MSG_WriteEntity (msg, newent, 0);
+			newindex++;
+			continue;
+		}
+
+		if ( newnum > oldnum ) {
+			// the old entity isn't present in the new message
+			if(oldent) {
+				MSG_WriteEntity (msg, NULL, oldent->number);
+			}
+			oldindex++;
+			continue;
+		}
+	}
+
+	MSG_WriteBits( msg, (MAX_GENTITIES-1), GENTITYNUM_BITS );	// end of packetentities
+}
+
+
+
+/*
+==================
+SV_WriteSnapshotToClient
+==================
+*/
+static void SV_WriteSnapshotToClient( client_t *client, msg_t *msg ) {
+	clientSnapshot_t	*frame, *oldframe;
+	int					lastframe;
+	int					snapFlags;
+
+	// this is the snapshot we are creating
+	frame = &client->frames[ client->netchan.outgoingSequence & PACKET_MASK ];
+
+	// try to use a previous frame as the source for delta compressing the snapshot
+	if ( client->deltaMessage <= 0 || client->state != CS_ACTIVE ) {
+		// client is asking for a retransmit
+		oldframe = NULL;
+		lastframe = 0;
+	} else if ( client->netchan.outgoingSequence - client->deltaMessage 
+		>= (PACKET_BACKUP - 3) ) {
+		// client hasn't gotten a good message through in a long time
+		Com_DPrintf ("%s: Delta request from out of date packet.\n", client->name);
+		oldframe = NULL;
+		lastframe = 0;
+	} else {
+		// we have a valid snapshot to delta from
+		oldframe = &client->frames[ client->deltaMessage & PACKET_MASK ];
+		lastframe = client->netchan.outgoingSequence - client->deltaMessage;
+
+		// the snapshot's entities may still have rolled off the buffer, though
+		if ( oldframe->first_entity <= svs.nextSnapshotEntities - svs.numSnapshotEntities ) {
+			Com_DPrintf ("%s: Delta request from out of date entities.\n", client->name);
+			oldframe = NULL;
+			lastframe = 0;
+		}
+	}
+
+	MSG_WriteByte (msg, svc_snapshot);
+
+	// let the client know which reliable clientCommands we have received
+	MSG_WriteLong( msg, client->lastClientCommand );
+
+	// send over the current server time so the client can drift
+	// its view of time to try to match
+	MSG_WriteLong (msg, sv.time);
+
+	// we must write a message number, because recorded demos won't have
+	// the same network message sequences
+	MSG_WriteLong (msg, client->netchan.outgoingSequence );
+	MSG_WriteByte (msg, lastframe);				// what we are delta'ing from
+	MSG_WriteLong (msg, client->cmdNum);		// we have executed up to here
+
+	snapFlags = client->rateDelayed | ( client->droppedCommands << 1 );
+	client->droppedCommands = 0;
+
+	MSG_WriteByte (msg, snapFlags);
+
+	// send over the areabits
+	MSG_WriteByte (msg, frame->areabytes);
+	MSG_WriteData (msg, frame->areabits, frame->areabytes);
+
+	// delta encode the playerstate
+	if ( oldframe ) {
+		MSG_WriteDeltaPlayerstate( msg, &oldframe->ps, &frame->ps );
+	} else {
+		MSG_WriteDeltaPlayerstate( msg, NULL, &frame->ps );
+	}
+
+	// delta encode the entities
+	SV_EmitPacketEntities (oldframe, frame, msg);
+}
+
+
+/*
+==================
+SV_UpdateServerCommandsToClient
+
+(re)send all server commands the client hasn't acknowledged yet
+==================
+*/
+static void SV_UpdateServerCommandsToClient( client_t *client, msg_t *msg ) {
+	int		i;
+
+	// write any unacknowledged serverCommands
+	for ( i = client->reliableAcknowledge + 1 ; i <= client->reliableSequence ; i++ ) {
+		MSG_WriteByte( msg, svc_serverCommand );
+		MSG_WriteLong( msg, i );
+		MSG_WriteString( msg, client->reliableCommands[ i & (MAX_RELIABLE_COMMANDS-1) ] );
+	}
+}
+
+/*
+=============================================================================
+
+Build a client snapshot structure
+
+=============================================================================
+*/
+
+#define	MAX_SNAPSHOT_ENTITIES	1024
+typedef struct {
+	int		numSnapshotEntities;
+	int		snapshotEntities[MAX_SNAPSHOT_ENTITIES];	
+} snapshotEntityNumbers_t;
+
+/*
+=======================
+SV_QsortEntityNumbers
+=======================
+*/
+static int SV_QsortEntityNumbers( const void *a, const void *b ) {
+	int	*ea, *eb;
+
+	ea = (int *)a;
+	eb = (int *)b;
+
+	if ( *ea == *eb ) {
+		Com_Error( ERR_DROP, "SV_QsortEntityStates: duplicated entity" );
+	}
+
+	if ( *ea < *eb ) {
+		return -1;
+	}
+
+	return 1;
+}
+
+
+/*
+===============
+SV_AddEntToSnapshot
+===============
+*/
+static void SV_AddEntToSnapshot( svEntity_t *svEnt, gentity_t *gEnt, snapshotEntityNumbers_t *eNums ) {
+	// if we have already added this entity to this snapshot, don't add again
+	if ( svEnt->snapshotCounter == sv.snapshotCounter ) {
+		return;
+	}
+	svEnt->snapshotCounter = sv.snapshotCounter;
+
+	// if we are full, silently discard entities
+	if ( eNums->numSnapshotEntities == MAX_SNAPSHOT_ENTITIES ) {
+		return;
+	}
+
+	if (sv.snapshotCounter &1 && eNums->numSnapshotEntities == svs.numSnapshotEntities-1)
+	{	//we're full, and about to wrap around and stomp ents, so half the time send the first set without stomping.
+		return;
+	}
+
+	eNums->snapshotEntities[ eNums->numSnapshotEntities ] = gEnt->s.number;
+	eNums->numSnapshotEntities++;
+}
+
+//rww - bg_public.h won't cooperate in here
+#define EF_PERMANENT			0x00080000
+
+float sv_sightRangeForLevel[6] =
+{
+	0,//FORCE_LEVEL_0
+    1024.f, //FORCE_LEVEL_1
+	2048.0f,//FORCE_LEVEL_2
+	4096.0f,//FORCE_LEVEL_3
+	4096.0f,//FORCE_LEVEL_4
+	4096.0f//FORCE_LEVEL_5
+};
+
+qboolean SV_PlayerCanSeeEnt( gentity_t *ent, int sightLevel )
+{//return true if this ent is in view
+	//NOTE: this is similar to the func CG_PlayerCanSeeCent in cg_players
+	vec3_t viewOrg, viewAngles, viewFwd, dir2Ent;
+	if ( !ent )
+	{
+		return qfalse;
+	}
+	if ( VM_Call( CG_CAMERA_POS, viewOrg))
+	{
+		if ( VM_Call( CG_CAMERA_ANG, viewAngles))
+		{
+			float dot = 0.25f;//1.0f;
+			float range = sv_sightRangeForLevel[sightLevel];
+
+			VectorSubtract( ent->currentOrigin, viewOrg, dir2Ent );
+			float entDist = VectorNormalize( dir2Ent );
+
+			if ( (ent->s.eFlags&EF_FORCE_VISIBLE) )
+			{//no dist check on them?
+			}
+			else
+			{
+				if ( entDist < 128.0f )
+				{//can always see them if they're really close
+					return qtrue;
+				}
+
+				if ( entDist > range )
+				{//too far away to see them
+					return qfalse;
+				}
+			}
+
+			dot += (0.99f-dot)*entDist/range;//the farther away they are, the more in front they have to be
+
+			AngleVectors( viewAngles, viewFwd, NULL, NULL );
+			if ( DotProduct( viewFwd, dir2Ent ) < dot )
+			{
+				return qfalse;
+			}
+			return qtrue;
+		}
+	}
+	return qfalse;
+}
+/*
+===============
+SV_AddEntitiesVisibleFromPoint
+===============
+*/
+static void SV_AddEntitiesVisibleFromPoint( vec3_t origin, clientSnapshot_t *frame, 
+									snapshotEntityNumbers_t *eNums, qboolean portal ) {
+	int		e, i;
+	gentity_t	*ent;
+	svEntity_t	*svEnt;
+	int		l;
+	int		clientarea, clientcluster;
+	int		leafnum;
+	int		c_fullsend;
+	const byte *clientpvs;
+	const byte *bitvector;
+	qboolean sightOn = qfalse;
+
+	// during an error shutdown message we may need to transmit
+	// the shutdown message after the server has shutdown, so
+	// specfically check for it
+	if ( !sv.state ) {
+		return;
+	}
+
+	leafnum = CM_PointLeafnum (origin);
+	clientarea = CM_LeafArea (leafnum);
+	clientcluster = CM_LeafCluster (leafnum);
+
+	// calculate the visible areas
+	frame->areabytes = CM_WriteAreaBits( frame->areabits, clientarea );
+
+	clientpvs = CM_ClusterPVS (clientcluster);
+
+	c_fullsend = 0;
+
+	if ( !portal )
+	{//not if this if through a portal...???  James said to do this...
+		if ( (frame->ps.forcePowersActive&(1<<FP_SEE)) )
+		{
+			sightOn = qtrue;
+		}
+	}
+
+	for ( e = 0 ; e < ge->num_entities ; e++ ) {
+		ent = SV_GentityNum(e);
+
+		if (!ent->inuse) {
+			continue;
+		}
+
+		if (ent->s.eFlags & EF_PERMANENT)
+		{	// he's permanent, so don't send him down!
+			continue;
+		}
+
+		if (ent->s.number != e) {
+			Com_DPrintf ("FIXING ENT->S.NUMBER!!!\n");
+			ent->s.number = e;
+		}
+
+		// never send entities that aren't linked in
+		if ( !ent->linked ) {
+			continue;
+		}
+
+		// entities can be flagged to explicitly not be sent to the client
+		if ( ent->svFlags & SVF_NOCLIENT ) {
+			continue;
+		}
+
+		svEnt = SV_SvEntityForGentity( ent );
+
+		// don't double add an entity through portals
+		if ( svEnt->snapshotCounter == sv.snapshotCounter ) {
+			continue;
+		}
+
+		// broadcast entities are always sent, and so is the main player so we don't see noclip weirdness
+		if ( ent->svFlags & SVF_BROADCAST || !e) {
+			SV_AddEntToSnapshot( svEnt, ent, eNums );
+			continue;
+		}
+
+		if (ent->s.isPortalEnt)
+		{ //rww - portal entities are always sent as well
+			SV_AddEntToSnapshot( svEnt, ent, eNums );
+			continue;
+		}
+
+		if ( sightOn )
+		{//force sight is on, sees through portals, so draw them always if in radius
+			if ( SV_PlayerCanSeeEnt( ent, frame->ps.forcePowerLevel[FP_SEE] ) )
+			{//entity is visible
+				SV_AddEntToSnapshot( svEnt, ent, eNums );
+				continue;
+			}
+		}
+
+		// ignore if not touching a PV leaf
+		// check area
+		if ( !CM_AreasConnected( clientarea, svEnt->areanum ) ) {
+			// doors can legally straddle two areas, so
+			// we may need to check another one
+			if ( !CM_AreasConnected( clientarea, svEnt->areanum2 ) ) {
+				continue;		// blocked by a door
+			}
+		}
+
+		bitvector = clientpvs;
+
+		// check individual leafs
+		if ( !svEnt->numClusters ) {
+			continue;
+		}
+		l = 0;
+#ifdef _XBOX
+		if(bitvector) {
+#endif
+		for ( i=0 ; i < svEnt->numClusters ; i++ ) {
+			l = svEnt->clusternums[i];
+			if ( bitvector[l >> 3] & (1 << (l&7) ) ) {
+				break;
+			}
+		}
+#ifdef _XBOX
+		}
+#endif
+
+		// if we haven't found it to be visible,
+		// check overflow clusters that coudln't be stored
+#ifdef _XBOX
+		if ( bitvector && i == svEnt->numClusters ) {
+#else
+		if ( i == svEnt->numClusters ) {
+#endif
+			if ( svEnt->lastCluster ) {
+				for ( ; l <= svEnt->lastCluster ; l++ ) {
+					if ( bitvector[l >> 3] & (1 << (l&7) ) ) {
+						break;
+					}
+				}
+				if ( l == svEnt->lastCluster ) {
+					continue;		// not visible
+				}
+			} else {
+				continue;
+			}
+		}
+
+		// add it
+		SV_AddEntToSnapshot( svEnt, ent, eNums );
+
+		// if its a portal entity, add everything visible from its camera position
+		if ( ent->svFlags & SVF_PORTAL ) {
+			SV_AddEntitiesVisibleFromPoint( ent->s.origin2, frame, eNums, qtrue );
+#ifdef _XBOX
+			//Must get clientpvs again since above call destroyed it.
+		clientpvs = CM_ClusterPVS (clientcluster);
+#endif
+		}
+	}
+}
+
+/*
+=============
+SV_BuildClientSnapshot
+
+Decides which entities are going to be visible to the client, and
+copies off the playerstate and areabits.
+
+This properly handles multiple recursive portals, but the render
+currently doesn't.
+
+For viewing through other player's eyes, clent can be something other than client->gentity
+=============
+*/
+static clientSnapshot_t *SV_BuildClientSnapshot( client_t *client ) {
+	vec3_t						org;
+	clientSnapshot_t			*frame;
+	snapshotEntityNumbers_t		entityNumbers;
+	int							i;
+	gentity_t					*ent;
+	entityState_t				*state;
+	gentity_t					*clent;
+
+	// bump the counter used to prevent double adding
+	sv.snapshotCounter++;
+
+	// this is the frame we are creating
+	frame = &client->frames[ client->netchan.outgoingSequence & PACKET_MASK ];
+
+	// clear everything in this snapshot
+	entityNumbers.numSnapshotEntities = 0;
+	memset( frame->areabits, 0, sizeof( frame->areabits ) );
+
+	clent = client->gentity;
+	if ( !clent ) {
+		return frame;
+	}
+
+	// grab the current playerState_t
+	frame->ps = *clent->client;
+
+	// this stops the main client entity playerstate from being sent across, which has the effect of breaking
+	// looping sounds for the main client. So I took it out.
+/*	{
+		int							clientNum;
+		svEntity_t					*svEnt;
+		clientNum = frame->ps.clientNum;
+		if ( clientNum < 0 || clientNum >= MAX_GENTITIES ) {
+			Com_Error( ERR_DROP, "SV_SvEntityForGentity: bad gEnt" );
+		}
+		svEnt = &sv.svEntities[ clientNum ];
+		// never send client's own entity, because it can
+		// be regenerated from the playerstate
+		svEnt->snapshotCounter = sv.snapshotCounter;
+	}
+*/
+	// find the client's viewpoint
+
+	//if in camera mode use camera position instead
+	if ( VM_Call( CG_CAMERA_POS, org))
+	{
+		//org[2] += clent->client->viewheight;
+	}
+	else 
+	{ 
+		VectorCopy( clent->client->origin, org );
+		org[2] += clent->client->viewheight;
+
+//============
+		// need to account for lean, or areaportal doors don't draw properly... -slc
+		if (frame->ps.leanofs != 0)
+		{
+			vec3_t	right;
+			//add leaning offset			
+			vec3_t v3ViewAngles;
+			VectorCopy(clent->client->viewangles, v3ViewAngles);
+			v3ViewAngles[2] += (float)frame->ps.leanofs/2;
+			AngleVectors(v3ViewAngles, NULL, right, NULL);
+			VectorMA(org, (float)frame->ps.leanofs, right, org);
+		}
+//============
+	}
+	VectorCopy( org, frame->ps.serverViewOrg );
+	VectorCopy( org, clent->client->serverViewOrg );
+
+	// add all the entities directly visible to the eye, which
+	// may include portal entities that merge other viewpoints
+	SV_AddEntitiesVisibleFromPoint( org, frame, &entityNumbers, qfalse );
+	/*
+	//was in here for debugging- print list of all entities in snapshot when you go over the limit
+	if ( entityNumbers.numSnapshotEntities >= 256 )
+	{
+		for ( int xxx = 0; xxx < entityNumbers.numSnapshotEntities; xxx++ )
+		{	
+			Com_Printf("%d - ", xxx );
+			ge->PrintEntClassname( entityNumbers.snapshotEntities[xxx] );
+		}
+	}
+	else if ( entityNumbers.numSnapshotEntities >= 200 )
+	{
+		Com_Printf(S_COLOR_RED"%d snapshot entities!", entityNumbers.numSnapshotEntities );
+	}
+	else if ( entityNumbers.numSnapshotEntities >= 128 )
+	{
+		Com_Printf(S_COLOR_YELLOW"%d snapshot entities", entityNumbers.numSnapshotEntities );
+	}
+	*/
+
+	// if there were portals visible, there may be out of order entities
+	// in the list which will need to be resorted for the delta compression
+	// to work correctly.  This also catches the error condition
+	// of an entity being included twice.
+	qsort( entityNumbers.snapshotEntities, entityNumbers.numSnapshotEntities, 
+		sizeof( entityNumbers.snapshotEntities[0] ), SV_QsortEntityNumbers );
+
+	// now that all viewpoint's areabits have been OR'd together, invert
+	// all of them to make it a mask vector, which is what the renderer wants
+	for ( i = 0 ; i < MAX_MAP_AREA_BYTES/4 ; i++ ) {
+		((int *)frame->areabits)[i] = ((int *)frame->areabits)[i] ^ -1;
+	}
+
+	// copy the entity states out
+	frame->num_entities = 0;
+	frame->first_entity = svs.nextSnapshotEntities;
+	for ( i = 0 ; i < entityNumbers.numSnapshotEntities ; i++ ) {
+		ent = SV_GentityNum(entityNumbers.snapshotEntities[i]);
+		state = &svs.snapshotEntities[svs.nextSnapshotEntities % svs.numSnapshotEntities];
+		*state = ent->s;
+		svs.nextSnapshotEntities++;
+		frame->num_entities++;
+	}
+
+	return frame;
+}
+
+
+/*
+=======================
+SV_SendMessageToClient
+
+Called by SV_SendClientSnapshot and SV_SendClientGameState
+=======================
+*/
+#define	HEADER_RATE_BYTES	48		// include our header, IP header, and some overhead
+void SV_SendMessageToClient( msg_t *msg, client_t *client ) {
+	int			rateMsec;
+
+	// record information about the message
+	client->frames[client->netchan.outgoingSequence & PACKET_MASK].messageSize = msg->cursize;
+	client->frames[client->netchan.outgoingSequence & PACKET_MASK].messageSent = sv.time;
+
+	// send the datagram
+	Netchan_Transmit( &client->netchan, msg->cursize, msg->data );
+
+	// set nextSnapshotTime based on rate and requested number of updates
+
+	// local clients get snapshots every frame (FIXME: also treat LAN clients)
+	if ( client->netchan.remoteAddress.type == NA_LOOPBACK ) {
+		client->nextSnapshotTime = sv.time - 1;
+		return;
+	}
+
+	// normal rate / snapshotMsec calculation
+	rateMsec = ( msg->cursize + HEADER_RATE_BYTES ) * 1000 / client->rate;
+	if ( rateMsec < client->snapshotMsec ) {
+		rateMsec = client->snapshotMsec;
+		client->rateDelayed = qfalse;
+	} else {
+		client->rateDelayed = qtrue;
+	}
+
+	client->nextSnapshotTime = sv.time + rateMsec;
+
+	// if we haven't gotten a message from the client in over a second, we will
+	// drop to only sending one snapshot a second until they timeout
+	if ( sv.time - client->lastPacketTime > 1000 || client->state != CS_ACTIVE ) {
+		if ( client->nextSnapshotTime < sv.time + 1000 ) {
+			client->nextSnapshotTime = sv.time + 1000;
+		}
+		return;
+	}
+
+}
+
+/*
+=======================
+SV_SendClientEmptyMessage
+
+This is just an empty message so that we can tell if
+the client dropped the gamestate that went out before
+=======================
+*/
+void SV_SendClientEmptyMessage( client_t *client ) {
+	msg_t	msg;
+	byte	buffer[10];
+
+	MSG_Init( &msg, buffer, sizeof( buffer ) );
+	SV_SendMessageToClient( &msg, client );
+}
+
+/*
+=======================
+SV_SendClientSnapshot
+=======================
+*/
+void SV_SendClientSnapshot( client_t *client ) {
+	byte		msg_buf[MAX_MSGLEN];
+	msg_t		msg;
+
+	// build the snapshot
+	SV_BuildClientSnapshot( client );
+
+	// bots need to have their snapshots build, but
+	// the query them directly without needing to be sent
+	if ( client->gentity && client->gentity->svFlags & SVF_BOT ) {
+		return;
+	}
+
+	MSG_Init (&msg, msg_buf, sizeof(msg_buf));
+	msg.allowoverflow = qtrue;
+
+	// (re)send any reliable server commands
+	SV_UpdateServerCommandsToClient( client, &msg );
+
+	// send over all the relevant entityState_t
+	// and the playerState_t
+	SV_WriteSnapshotToClient( client, &msg );
+
+	// check for overflow
+	if ( msg.overflowed ) {
+		Com_Printf ("WARNING: msg overflowed for %s\n", client->name);
+		MSG_Clear (&msg);
+	}
+
+	SV_SendMessageToClient( &msg, client );
+}
+
+
+/*
+=======================
+SV_SendClientMessages
+=======================
+*/
+void SV_SendClientMessages( void ) {
+	int			i;
+	client_t	*c;
+
+	// send a message to each connected client
+	for (i=0, c = svs.clients ; i < 1 ; i++, c++) {
+		if (!c->state) {
+			continue;		// not connected
+		}
+
+		if ( sv.time < c->nextSnapshotTime ) {
+			continue;		// not time yet
+		}
+
+		if ( c->state != CS_ACTIVE ) {
+			if ( c->state != CS_ZOMBIE ) {
+				SV_SendClientEmptyMessage( c );
+			}
+			continue;
+		}
+
+		SV_SendClientSnapshot( c );
+	}
+}
+
diff --git a/code/server/sv_world.cpp b/code/server/sv_world.cpp
new file mode 100644
index 0000000..706025c
--- /dev/null
+++ b/code/server/sv_world.cpp
@@ -0,0 +1,1012 @@
+// world.c -- world query functions
+
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+#include "../qcommon/cm_local.h"
+
+ /*
+Ghoul2 Insert Start
+*/
+
+#if !defined(GHOUL2_SHARED_H_INC)
+	#include "..\game\ghoul2_shared.h"	//for CGhoul2Info_v
+#endif
+#if !defined(G2_H_INC)
+	#include "..\ghoul2\G2.h"
+#endif
+#if !defined (MINIHEAP_H_INC)
+	#include "../qcommon/miniheap.h"
+#endif
+
+#ifdef _DEBUG
+	#include <float.h>
+#endif //_DEBUG
+/*
+Ghoul2 Insert End
+*/
+#if MEM_DEBUG
+#include "..\smartheap\heapagnt.h"
+#define SV_TRACE_PROFILE (0)
+#endif
+
+#if 0 //G2_SUPERSIZEDBBOX is not being used
+static const float superSizedAdd=64.0f;
+#endif
+
+/*
+================
+SV_ClipHandleForEntity
+
+Returns a headnode that can be used for testing or clipping to a
+given entity.  If the entity is a bsp model, the headnode will
+be returned, otherwise a custom box tree will be constructed.
+================
+*/
+clipHandle_t SV_ClipHandleForEntity( const gentity_t *ent ) {
+	if ( ent->bmodel ) {
+		// explicit hulls in the BSP model
+		return CM_InlineModel( ent->s.modelindex );
+	}
+
+	// create a temp tree from bounding box sizes
+	return CM_TempBoxModel( ent->mins, ent->maxs );//, ent->contents );
+}
+
+
+
+/*
+===============================================================================
+
+ENTITY CHECKING
+
+To avoid linearly searching through lists of entities during environment testing,
+the world is carved up with an evenly spaced, axially aligned bsp tree.  Entities
+are kept in chains either at the final leafs, or at the first node that splits
+them, which prevents having to deal with multiple fragments of a single entity.
+
+===============================================================================
+*/
+
+typedef struct worldSector_s {
+	int		axis;		// -1 = leaf node
+	float	dist;
+	struct worldSector_s	*children[2];
+	svEntity_t	*entities;
+} worldSector_t;
+
+#define	AREA_DEPTH	8
+#define	AREA_NODES	1024
+
+worldSector_t	sv_worldSectors[AREA_NODES];
+int			sv_numworldSectors;
+
+/*
+===============
+SV_CreateworldSector
+
+Builds a uniformly subdivided tree for the given world size
+===============
+*/
+worldSector_t *SV_CreateworldSector( int depth, vec3_t mins, vec3_t maxs ) {
+	worldSector_t	*anode;
+	vec3_t		size;
+	vec3_t		mins1, maxs1, mins2, maxs2;
+
+	anode = &sv_worldSectors[sv_numworldSectors];
+	sv_numworldSectors++;
+
+	if (depth == AREA_DEPTH) {
+		anode->axis = -1;
+		anode->children[0] = anode->children[1] = NULL;
+		return anode;
+	}
+	
+	VectorSubtract (maxs, mins, size);
+	if (size[0] > size[1]) {
+		anode->axis = 0;
+	} else {
+		anode->axis = 1;
+	}
+
+	anode->dist = 0.5 * (maxs[anode->axis] + mins[anode->axis]);
+	VectorCopy (mins, mins1);	
+	VectorCopy (mins, mins2);	
+	VectorCopy (maxs, maxs1);	
+	VectorCopy (maxs, maxs2);	
+	
+	maxs1[anode->axis] = mins2[anode->axis] = anode->dist;
+	
+	anode->children[0] = SV_CreateworldSector (depth+1, mins2, maxs2);
+	anode->children[1] = SV_CreateworldSector (depth+1, mins1, maxs1);
+
+	return anode;
+}
+
+/*
+===============
+SV_ClearWorld
+
+===============
+*/
+void SV_ClearWorld( void ) {
+	clipHandle_t	h;
+	vec3_t			mins, maxs;
+
+	memset( sv_worldSectors, 0, sizeof(sv_worldSectors) );
+	sv_numworldSectors = 0;
+
+	// get world map bounds
+	h = CM_InlineModel( 0 );
+	CM_ModelBounds( cmg, h, mins, maxs );
+	SV_CreateworldSector( 0, mins, maxs );
+}
+
+
+/*
+===============
+SV_UnlinkEntity
+
+===============
+*/
+void SV_UnlinkEntity( gentity_t *gEnt ) {
+	svEntity_t		*ent;
+	svEntity_t		*scan;
+	worldSector_t	*ws;
+
+	// this should never be called with a freed entity
+	if ( !gEnt->inuse ) {
+		return;
+	}
+
+	ent = SV_SvEntityForGentity( gEnt );
+
+	gEnt->linked = qfalse;
+
+	ws = ent->worldSector;
+	if ( !ws ) {
+		return;		// not linked in anywhere
+	}
+	ent->worldSector = NULL;
+
+	if ( ws->entities == ent ) {
+		ws->entities = ent->nextEntityInWorldSector;
+		return;
+	}
+
+	for ( scan = ws->entities ; scan ; scan = scan->nextEntityInWorldSector ) {
+		if ( scan->nextEntityInWorldSector == ent ) {
+			scan->nextEntityInWorldSector = ent->nextEntityInWorldSector;
+			return;
+		}
+	}
+
+	Com_Printf( "WARNING: SV_UnlinkEntity: not found in worldSector\n" );
+}
+
+
+/*
+===============
+SV_LinkEntity
+
+===============
+*/
+#define MAX_TOTAL_ENT_LEAFS		128
+void SV_LinkEntity( gentity_t *gEnt ) {
+	worldSector_t	*node;
+	int			leafs[MAX_TOTAL_ENT_LEAFS];
+	int			cluster;
+	int			num_leafs;
+	int			i, j, k;
+	int			area;
+	int			lastLeaf;
+	float		*origin, *angles;
+	svEntity_t	*ent;
+
+	// this should never be called with a freed entity
+	if ( !gEnt->inuse ) {
+		return;
+	}
+
+	ent = SV_SvEntityForGentity( gEnt );
+
+	if ( ent->worldSector ) {
+		SV_UnlinkEntity( gEnt );	// unlink from old position
+	}
+
+	// encode the size into the entityState_t for client prediction
+	if ( gEnt->bmodel ) {
+		gEnt->s.solid = SOLID_BMODEL;		// a solid_box will never create this value
+	} else if ( gEnt->contents & ( CONTENTS_SOLID | CONTENTS_BODY ) ) {
+		// assume that x/y are equal and symetric
+		i = gEnt->maxs[0];
+		if (i<1)
+			i = 1;
+		if (i>255)
+			i = 255;
+
+		// z is not symetric
+		j = (-gEnt->mins[2]);
+		if (j<1)
+			j = 1;
+		if (j>255)
+			j = 255;
+
+		// and z maxs can be negative...
+		k = (gEnt->maxs[2]+32);
+		if (k<1)
+			k = 1;
+		if (k>255)
+			k = 255;
+
+		gEnt->s.solid = (k<<16) | (j<<8) | i;
+	} else {
+		gEnt->s.solid = 0;
+	}
+
+	// get the position
+	origin = gEnt->currentOrigin;
+	angles = gEnt->currentAngles;
+
+	// set the abs box
+	if ( gEnt->bmodel && (angles[0] || angles[1] || angles[2]) )
+	{	// expand for rotation
+		float		max;
+		int			i;
+
+		max = RadiusFromBounds( gEnt->mins, gEnt->maxs );
+		for (i=0 ; i<3 ; i++) {
+			gEnt->absmin[i] = origin[i] - max;
+			gEnt->absmax[i] = origin[i] + max;
+		}
+	} else {
+		// normal
+		VectorAdd (origin, gEnt->mins, gEnt->absmin);	
+		VectorAdd (origin, gEnt->maxs, gEnt->absmax);
+	}
+
+	// because movement is clipped an epsilon away from an actual edge,
+	// we must fully check even when bounding boxes don't quite touch
+	gEnt->absmin[0] -= 1;
+	gEnt->absmin[1] -= 1;
+	gEnt->absmin[2] -= 1;
+	gEnt->absmax[0] += 1;
+	gEnt->absmax[1] += 1;
+	gEnt->absmax[2] += 1;
+
+	// link to PVS leafs
+	ent->numClusters = 0;
+	ent->lastCluster = 0;
+	ent->areanum = -1;
+	ent->areanum2 = -1;
+
+	//get all leafs, including solids
+	num_leafs = CM_BoxLeafnums( gEnt->absmin, gEnt->absmax,
+		leafs, MAX_TOTAL_ENT_LEAFS, &lastLeaf );
+
+	// if none of the leafs were inside the map, the
+	// entity is outside the world and can be considered unlinked
+	if ( !num_leafs ) {
+		return;
+	}
+
+	// set areas, even from clusters that don't fit in the entity array
+	for (i=0 ; i<num_leafs ; i++) {
+		area = CM_LeafArea (leafs[i]);
+		if (area != -1)
+		{	// doors may legally straggle two areas,
+			// but nothing should evern need more than that
+			if (ent->areanum != -1 && ent->areanum != area) {
+				if (ent->areanum2 != -1 && ent->areanum2 != area && sv.state == SS_LOADING) {
+					Com_DPrintf ("Object %i touching 3 areas at %f %f %f\n",
+					gEnt->s.number,
+					gEnt->absmin[0], gEnt->absmin[1], gEnt->absmin[2]);
+				}
+				ent->areanum2 = area;
+			} else {
+				ent->areanum = area;
+			}
+		}
+	}
+
+	// store as many explicit clusters as we can
+	ent->numClusters = 0;
+	for (i=0 ; i < num_leafs ; i++) {
+		cluster = CM_LeafCluster( leafs[i] );
+		if ( cluster != -1 ) {
+			ent->clusternums[ent->numClusters++] = cluster;
+			if ( ent->numClusters == MAX_ENT_CLUSTERS ) {
+					break;
+			}
+		}
+	}
+
+	// store off a last cluster if we need to
+	if ( i != num_leafs ) {
+		ent->lastCluster = CM_LeafCluster( lastLeaf );
+	}
+
+	// find the first world sector node that the ent's box crosses
+	node = sv_worldSectors;
+	while (1)
+	{
+		if (node->axis == -1)
+			break;
+		if ( gEnt->absmin[node->axis] > node->dist)
+			node = node->children[0];
+		else if ( gEnt->absmax[node->axis] < node->dist)
+			node = node->children[1];
+		else
+			break;		// crosses the node
+	}
+	
+	// link it in
+	ent->worldSector = node;
+	ent->nextEntityInWorldSector = node->entities;
+	node->entities = ent;
+
+	gEnt->linked = qtrue;
+}
+
+/*
+============================================================================
+
+AREA QUERY
+
+Fills in a list of all entities who's absmin / absmax intersects the given
+bounds.  This does NOT mean that they actually touch in the case of bmodels.
+============================================================================
+*/
+
+typedef struct {
+	const float	*mins;
+	const float	*maxs;
+	gentity_t	**list;
+	int			count, maxcount;
+} areaParms_t;
+
+
+/*
+====================
+SV_AreaEntities_r
+
+====================
+*/
+void SV_AreaEntities_r( worldSector_t *node, areaParms_t *ap ) {
+	svEntity_t	*check, *next;
+	gentity_t	*gcheck;
+	int			count;
+
+	count = 0;
+
+	for ( check = node->entities  ; check ; check = next ) {
+		next = check->nextEntityInWorldSector;
+
+		gcheck = SV_GEntityForSvEntity( check );
+
+		if ( gcheck->absmin[0] > ap->maxs[0]
+		|| gcheck->absmin[1] > ap->maxs[1]
+		|| gcheck->absmin[2] > ap->maxs[2]
+		|| gcheck->absmax[0] < ap->mins[0]
+		|| gcheck->absmax[1] < ap->mins[1]
+		|| gcheck->absmax[2] < ap->mins[2]) {
+			continue;
+		}
+
+		if ( ap->count == ap->maxcount ) {
+			Com_DPrintf ("SV_AreaEntities: reached maxcount (%d)\n",ap->maxcount);
+			return;
+		}
+
+		ap->list[ap->count] = gcheck;
+		ap->count++;
+	}
+	
+	if (node->axis == -1) {
+		return;		// terminal node
+	}
+
+	// recurse down both sides
+	if ( ap->maxs[node->axis] > node->dist ) {
+		SV_AreaEntities_r ( node->children[0], ap );
+	}
+	if ( ap->mins[node->axis] < node->dist ) {
+		SV_AreaEntities_r ( node->children[1], ap );
+	}
+}
+
+/*
+================
+SV_AreaEntities
+================
+*/
+int SV_AreaEntities( const vec3_t mins, const vec3_t maxs, gentity_t **elist, int maxcount ) {
+	areaParms_t		ap;
+
+	ap.mins = mins;
+	ap.maxs = maxs;
+	ap.list = elist;
+	ap.count = 0;
+	ap.maxcount = maxcount;
+
+#if SV_TRACE_PROFILE
+#if MEM_DEBUG
+	{
+		int old=dbgMemSetCheckpoint(2003);
+		malloc(1);
+		dbgMemSetCheckpoint(old);
+	}
+#endif
+#endif
+	SV_AreaEntities_r( sv_worldSectors, &ap );
+
+	return ap.count;
+}
+
+/*
+===============
+SV_SectorList_f
+===============
+*/
+#if 1
+
+void SV_SectorList_f( void ) {
+	int				i, c;
+	worldSector_t	*sec;
+	svEntity_t		*ent;
+
+	for ( i = 0 ; i < AREA_NODES ; i++ ) {
+		sec = &sv_worldSectors[i];
+
+		c = 0;
+		for ( ent = sec->entities ; ent ; ent = ent->nextEntityInWorldSector ) {
+			c++;
+		}
+		Com_Printf( "sector %i: %i entities\n", i, c );
+	}
+}
+
+#else
+
+#pragma warning (push, 3)	//go back down to 3 for the stl include
+#include <list>
+#include <map>
+#pragma warning (pop)
+using namespace std;
+
+class CBBox
+{
+public:
+	float mMins[3];
+	float mMaxs[3];
+
+	CBBox(vec3_t mins,vec3_t maxs)
+	{
+		VectorCopy(mins,mMins);
+		VectorCopy(maxs,mMaxs);
+	}
+};
+
+static multimap<int,pair<int,list<CBBox> > > entStats;
+
+void SV_AreaEntitiesTree( worldSector_t *node, areaParms_t *ap, int level )
+{
+	svEntity_t		*check, *next;
+	gentity_t		*gcheck;
+	int				count;
+	list<CBBox>	bblist;
+
+	count = 0;
+
+	for ( check = node->entities  ; check ; check = next )
+	{
+		next = check->nextEntityInWorldSector;
+
+		gcheck = SV_GEntityForSvEntity( check );
+
+		CBBox bBox(gcheck->absmin,gcheck->absmax);
+		bblist.push_back(bBox);
+		count++;
+	}
+
+	entStats.insert(pair<int,pair<int,list<CBBox> > >(level,pair<int,list<CBBox> >(count,bblist)));
+	if (node->axis == -1)
+	{
+		return;		// terminal node
+	}
+
+	// recurse down both sides
+	SV_AreaEntitiesTree ( node->children[0], ap, level+1 );
+	SV_AreaEntitiesTree ( node->children[1], ap, level+1 );
+}
+
+void SV_SectorList_f( void )
+{
+	areaParms_t		ap;
+
+//	ap.mins = mins;
+//	ap.maxs = maxs;
+//	ap.list = list;
+//	ap.count = 0;
+//	ap.maxcount = maxcount;
+
+	entStats.clear();
+	SV_AreaEntitiesTree(sv_worldSectors,&ap,0);
+	char mess[1000];
+	multimap<int,pair<int,list<CBBox> > >::iterator j;
+	for(j=entStats.begin();j!=entStats.end();j++)
+	{
+		sprintf(mess,"**************************************************\n");
+		Sleep(5);
+		OutputDebugString(mess);
+		sprintf(mess,"level=%i, count=%i\n",(*j).first,(*j).second.first);
+		Sleep(5);
+		OutputDebugString(mess);
+		list<CBBox>::iterator k;
+		for(k=(*j).second.second.begin();k!=(*j).second.second.end();k++)
+		{
+			sprintf(mess,"mins=%f %f %f, maxs=%f %f %f\n",
+					(*k).mMins[0],(*k).mMins[1],(*k).mMins[2],(*k).mMaxs[0],(*k).mMaxs[1],(*k).mMaxs[2]);
+			OutputDebugString(mess);
+		}
+	}
+
+}
+#endif
+
+//===========================================================================
+
+
+typedef struct {
+	vec3_t		boxmins, boxmaxs;// enclose the test object along entire move
+	const float	*mins;
+	const float *maxs;	// size of the moving object
+/*
+Ghoul2 Insert Start
+*/
+	vec3_t		start;
+/*
+Ghoul2 Insert End
+*/
+	vec3_t		end;
+	int			passEntityNum;
+	int			contentmask;
+/*
+Ghoul2 Insert Start
+*/
+	EG2_Collision	eG2TraceType;
+	int			useLod;
+	trace_t		trace;			// make sure nothing goes under here for Ghoul2 collision purposes
+/*
+Ghoul2 Insert End
+*/
+} moveclip_t;
+
+
+/*
+====================
+SV_ClipMoveToEntities
+
+====================
+*/
+void SV_ClipMoveToEntities( moveclip_t *clip ) {
+	int			i, num;
+	gentity_t		*touchlist[MAX_GENTITIES], *touch, *owner;
+	trace_t		trace, oldTrace;
+	clipHandle_t	clipHandle;
+	const float		*origin, *angles;
+
+	num = SV_AreaEntities( clip->boxmins, clip->boxmaxs, touchlist, MAX_GENTITIES);
+
+	if ( clip->passEntityNum != ENTITYNUM_NONE ) {
+		owner = ( SV_GentityNum( clip->passEntityNum ) )->owner;
+	} else {
+		owner = NULL;
+	}
+
+	for ( i=0 ; i<num ; i++ ) {
+		if (clip->trace.allsolid) {
+			return;
+		}
+		touch = touchlist[i];
+
+		// see if we should ignore this entity
+		if ( clip->passEntityNum != ENTITYNUM_NONE ) {
+			if (touch->s.number == clip->passEntityNum) {
+				continue; // don't clip against the pass entity
+			}
+			if (touch->owner && touch->owner->s.number == clip->passEntityNum) {
+				continue;	// don't clip against own missiles
+			}
+			if ( owner == touch) {
+				continue;	// don't clip against owner
+			}
+			if ( owner && touch->owner == owner) {
+				continue;	// don't clip against other missiles from our owner
+			}
+		}
+
+		// if it doesn't have any brushes of a type we
+		// are looking for, ignore it
+		if ( ! ( clip->contentmask & touch->contents ) ) {
+			continue;
+		}
+
+		// might intersect, so do an exact clip
+		clipHandle = SV_ClipHandleForEntity (touch);
+
+		origin = touch->currentOrigin;
+		angles = touch->currentAngles;
+
+
+		if ( !touch->bmodel ) {
+			angles = vec3_origin;	// boxes don't rotate
+		}
+
+#if 0 //G2_SUPERSIZEDBBOX is not being used
+		bool shrinkBox=true;
+
+		if (clip->eG2TraceType != G2_SUPERSIZEDBBOX)
+		{
+			shrinkBox=false;
+		}
+		else if (trace.entityNum == touch->s.number&&touch->ghoul2.size()&&!(touch->contents & CONTENTS_LIGHTSABER))
+		{
+			shrinkBox=false;
+		}
+		if (shrinkBox)
+		{
+			vec3_t sh_mins;
+			vec3_t sh_maxs;
+			int j;
+			for ( j=0 ; j<3 ; j++ ) 
+			{
+					sh_mins[j]=clip->mins[j]+superSizedAdd;
+					sh_maxs[j]=clip->maxs[j]-superSizedAdd;
+			}
+			CM_TransformedBoxTrace ( &trace, clip->start, clip->end,
+				sh_mins, sh_maxs, clipHandle,  clip->contentmask,
+				origin, angles);
+		}
+		else
+#endif
+		{
+#ifdef __MACOS__
+			// compiler bug with const
+			CM_TransformedBoxTrace ( &trace, (float *)clip->start, (float *)clip->end,
+				(float *)clip->mins, (float *)clip->maxs, clipHandle,  clip->contentmask,
+				origin, angles);
+#else
+			CM_TransformedBoxTrace ( &trace, clip->start, clip->end,
+				clip->mins, clip->maxs, clipHandle,  clip->contentmask,
+				origin, angles);
+#endif
+		//FIXME: when startsolid in another ent, doesn't return correct entityNum 
+		//ALSO: 2 players can be standing next to each other and this function will
+		//think they're in each other!!!
+		}
+		oldTrace = clip->trace;
+
+		if ( trace.allsolid ) 
+		{
+			if(!clip->trace.allsolid)
+			{//We didn't come in here all solid, so set the clip->trace's entityNum
+				clip->trace.entityNum = touch->s.number;
+			}
+			clip->trace.allsolid = qtrue;
+			trace.entityNum = touch->s.number;
+		} 
+		else if ( trace.startsolid ) 
+		{
+			if(!clip->trace.startsolid)
+			{//We didn't come in here starting solid, so set the clip->trace's entityNum
+				clip->trace.entityNum = touch->s.number;
+			}
+			clip->trace.startsolid = qtrue;
+			trace.entityNum = touch->s.number;
+		}
+
+		if ( trace.fraction < clip->trace.fraction ) 
+		{
+			qboolean	oldStart;
+
+			// make sure we keep a startsolid from a previous trace
+			oldStart = clip->trace.startsolid;
+
+			trace.entityNum = touch->s.number;
+			clip->trace = trace;
+			clip->trace.startsolid |= oldStart;
+		}
+/*
+Ghoul2 Insert Start
+*/
+
+		// decide if we should do the ghoul2 collision detection right here
+		if ((trace.entityNum == touch->s.number) && (clip->eG2TraceType != G2_NOCOLLIDE))
+		{
+			// do we actually have a ghoul2 model here?
+			if (touch->ghoul2.size() && !(touch->contents & CONTENTS_LIGHTSABER))
+			{
+				int			oldTraceRecSize = 0;
+				int			newTraceRecSize = 0;
+				int			z;
+
+				// we have to do this because sometimes you may hit a model's bounding box, but not actually penetrate the Ghoul2 Models polygons
+				// this is, needless to say, not good. So we must check to see if we did actually hit the model, and if not, reset the trace stuff
+				// to what it was to begin with
+
+				// set our trace record size
+				for (z=0;z<MAX_G2_COLLISIONS;z++)
+				{
+					if (clip->trace.G2CollisionMap[z].mEntityNum != -1)
+					{
+						oldTraceRecSize++;
+					}
+				}
+
+				// if we are looking at an entity then use the player state to get it's angles and origin from
+				float radius;
+#if 0 //G2_SUPERSIZEDBBOX is not being used
+				if (clip->eG2TraceType == G2_SUPERSIZEDBBOX)
+				{
+					radius=(clip->maxs[0]-clip->mins[0]-2.0f*superSizedAdd)/2.0f;
+				}
+				else
+#endif
+				{
+					radius=(clip->maxs[0]-clip->mins[0])/2.0f;
+				}
+				if (touch->client)
+				{
+					vec3_t world_angles;
+					
+					world_angles[PITCH] =  0;
+					//legs do not *always* point toward the viewangles!
+					//world_angles[YAW] =  touch->client->viewangles[YAW];
+					world_angles[YAW] =  touch->client->legsYaw;
+					world_angles[ROLL] =  0;
+
+					G2API_CollisionDetect(clip->trace.G2CollisionMap, touch->ghoul2,
+							world_angles, touch->client->origin, sv.time, touch->s.number, clip->start, clip->end, touch->s.modelScale, G2VertSpaceServer, clip->eG2TraceType, clip->useLod,radius);
+				}
+				// no, so use the normal entity state
+				else
+				{
+					//use the correct origin and angles!  is this right now?
+					G2API_CollisionDetect(clip->trace.G2CollisionMap, touch->ghoul2,
+						touch->currentAngles, touch->currentOrigin, sv.time, touch->s.number, clip->start, clip->end, touch->s.modelScale, G2VertSpaceServer, clip->eG2TraceType, clip->useLod,radius);
+				}
+
+				// set our new trace record size
+ 
+				for (z=0;z<MAX_G2_COLLISIONS;z++)
+				{
+					if (clip->trace.G2CollisionMap[z].mEntityNum != -1)
+					{
+						newTraceRecSize++;
+					}
+				}
+
+				// did we actually touch this model? If not, lets reset this ent as being hit..
+				if (newTraceRecSize == oldTraceRecSize)
+				{
+					clip->trace = oldTrace;
+				}
+				else//this trace was valid, so copy the best collision into quake trace place info
+				{
+					for (z=0;z<MAX_G2_COLLISIONS;z++)
+					{
+						if (clip->trace.G2CollisionMap[z].mEntityNum==touch->s.number)
+						{
+							clip->trace.plane.normal[0] = clip->trace.G2CollisionMap[z].mCollisionNormal[0];
+							clip->trace.plane.normal[1] = clip->trace.G2CollisionMap[z].mCollisionNormal[1];
+							clip->trace.plane.normal[2] = clip->trace.G2CollisionMap[z].mCollisionNormal[2];
+							break;
+						}
+					}
+					assert(z<MAX_G2_COLLISIONS); // hmm well ah, weird
+					assert(VectorLength(clip->trace.plane.normal)>0.1f);
+				}
+			}
+		}
+/*
+Ghoul2 Insert End
+*/
+
+	}
+}
+
+
+/*
+==================
+SV_Trace
+
+Moves the given mins/maxs volume through the world from start to end.
+passEntityNum and entities owned by passEntityNum are explicitly not checked.
+==================
+*/
+/*
+Ghoul2 Insert Start
+*/
+void SV_Trace( trace_t *results, const vec3_t start, const vec3_t mins, const vec3_t maxs, const vec3_t end, const int passEntityNum, const int contentmask, const EG2_Collision eG2TraceType, const int useLod ) {
+/*
+Ghoul2 Insert End
+*/
+#ifdef _DEBUG
+	assert( !_isnan(start[0])&&!_isnan(start[1])&&!_isnan(start[2])&&!_isnan(end[0])&&!_isnan(end[1])&&!_isnan(end[2]));
+#endif// _DEBUG
+
+#if SV_TRACE_PROFILE
+#if MEM_DEBUG
+	{
+		int old=dbgMemSetCheckpoint(2002);
+		malloc(1);
+		dbgMemSetCheckpoint(old);
+	}
+#endif
+#endif
+
+	moveclip_t	clip;
+	int			i;
+//	int			startMS, endMS;
+	float		world_frac;
+
+	/*
+	startMS = Sys_Milliseconds ();
+	numTraces++;
+	*/
+	if ( !mins ) {
+		mins = vec3_origin;
+	}
+	if ( !maxs ) {
+		maxs = vec3_origin;
+	}
+
+	memset ( &clip, 0, sizeof ( moveclip_t ) - sizeof(clip.trace.G2CollisionMap ));
+
+	// clip to world
+	//NOTE: this will stop not only on static architecture but also entity brushes such as
+	//doors, etc.  This prevents us from being able to shorten the trace so that we can
+	//ignore all ents past this endpoint... perhaps need to check the entityNum in this
+	//BoxTrace or have it not clip against entity brushes here.
+	CM_BoxTrace( &clip.trace, start, end, mins, maxs, 0, contentmask );
+	clip.trace.entityNum = clip.trace.fraction != 1.0 ? ENTITYNUM_WORLD : ENTITYNUM_NONE;
+	if ( clip.trace.fraction == 0 ) 
+	{// blocked immediately by the world
+		*results = clip.trace;
+//		goto addtime;		
+		return;
+	}
+
+	clip.contentmask = contentmask;
+/*
+Ghoul2 Insert Start
+*/	
+	VectorCopy( start, clip.start );
+	clip.eG2TraceType = eG2TraceType;
+	clip.useLod = useLod;
+/*
+Ghoul2 Insert End
+*/
+	//Shorten the trace to the size of the trace until it hit the world
+	VectorCopy( clip.trace.endpos, clip.end );
+	//remember the current completion fraction
+	world_frac = clip.trace.fraction;
+	//set the fraction back to 1.0 for the trace vs. entities
+	clip.trace.fraction = 1.0f;
+	
+	//VectorCopy( end, clip.end );
+	// create the bounding box of the entire move
+	// we can limit it to the part of the move not
+	// already clipped off by the world, which can be
+	// a significant savings for line of sight and shot traces
+	clip.passEntityNum = passEntityNum;
+
+#if 0 //G2_SUPERSIZEDBBOX is not being used
+	vec3_t superMin;
+	vec3_t superMax;  // prison, in boscobel
+
+	if (eG2TraceType==G2_SUPERSIZEDBBOX)
+	{
+		for ( i=0 ; i<3 ; i++ ) 
+		{
+				superMin[i]=mins[i]-superSizedAdd;
+				superMax[i]=maxs[i]+superSizedAdd;
+		}
+		clip.mins = superMin;
+		clip.maxs = superMax;
+	}
+	else
+#endif
+	{
+		clip.mins = mins;
+		clip.maxs = maxs;
+	}
+
+	for ( i=0 ; i<3 ; i++ ) {
+		if ( end[i] > start[i] ) {
+			clip.boxmins[i] = clip.start[i] + clip.mins[i] - 1;
+			clip.boxmaxs[i] = clip.end[i] + clip.maxs[i] + 1;
+		} else {
+			clip.boxmins[i] = clip.end[i] + clip.mins[i] - 1;
+			clip.boxmaxs[i] = clip.start[i] + clip.maxs[i] + 1;
+		}
+	}
+
+	// clip to other solid entities
+	SV_ClipMoveToEntities ( &clip );
+
+	//scale the trace back down by the previous fraction
+	clip.trace.fraction *= world_frac;
+	*results = clip.trace;
+
+/*
+addtime:
+	endMS = Sys_Milliseconds ();
+
+	timeInTrace += endMS - startMS;
+*/
+}
+
+
+
+/*
+=============
+SV_PointContents
+=============
+*/
+int SV_PointContents( const vec3_t p, int passEntityNum ) {
+	gentity_t		*touch[MAX_GENTITIES], *hit;
+	int			i, num;
+	int			contents, c2;
+//	int			startMS, endMS;
+	clipHandle_t	clipHandle;
+	const float		*angles;
+
+#if MEM_DEBUG
+#if SV_TRACE_PROFILE
+	{
+		int old=dbgMemSetCheckpoint(2001);
+		malloc(1);
+		dbgMemSetCheckpoint(old);
+	}
+#endif
+#endif
+
+	/*
+	startMS = Sys_Milliseconds ();
+	numTraces++;
+	*/
+
+	// get base contents from world
+	contents = CM_PointContents( p, 0 );
+
+	// or in contents from all the other entities
+	num = SV_AreaEntities( p, p, touch, MAX_GENTITIES );
+
+	for ( i=0 ; i<num ; i++ ) {
+		hit = touch[i];
+		if ( hit->s.number == passEntityNum ) {
+			continue;
+		}
+		// might intersect, so do an exact clip
+		clipHandle = SV_ClipHandleForEntity( hit );
+		angles = hit->s.angles;
+		if ( !hit->bmodel ) {
+			angles = vec3_origin;	// boxes don't rotate
+		}
+
+		c2 = CM_TransformedPointContents (p, clipHandle, hit->s.origin, hit->s.angles);
+
+		contents |= c2;
+	}
+
+	/*
+	endMS = Sys_Milliseconds ();
+	timeInTrace += endMS - startMS;
+	*/
+	return contents;
+}
+
+
diff --git a/code/server/vssver.scc b/code/server/vssver.scc
new file mode 100644
index 0000000..f09e1ce
Binary files /dev/null and b/code/server/vssver.scc differ
diff --git a/code/smartheap/HAW32M.LIB b/code/smartheap/HAW32M.LIB
new file mode 100644
index 0000000..1fc259c
Binary files /dev/null and b/code/smartheap/HAW32M.LIB differ
diff --git a/code/smartheap/HEAPAGNT.H b/code/smartheap/HEAPAGNT.H
new file mode 100644
index 0000000..6dbdb8c
--- /dev/null
+++ b/code/smartheap/HEAPAGNT.H
@@ -0,0 +1,442 @@
+/* heapagnt.h -- HeapAgent (tm) public C/C++ header file
+ *
+ * Copyright (C) 1991-1997 Compuware Corporation.
+ * All Rights Reserved.
+ *
+ * No part of this source code may be copied, modified or reproduced
+ * in any form without retaining the above copyright notice.
+ * This source code, or source code derived from it, may not be redistributed
+ * without express written permission of the copyright owner.
+ *
+ */
+
+#if !defined(_HEAPAGNT_H)
+#define _HEAPAGNT_H
+
+#if !defined(_SMARTHEAP_H)
+#include "smrtheap.h"
+#endif /* _SMARTHEAP_H */
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define HA_MAJOR_VERSION 3
+#define HA_MINOR_VERSION 1
+#define HA_UPDATE_LEVEL 2
+
+   
+/*** Types ***/
+
+/* Saftey Levels: parameter to dbgMemSetSafetyLevel */
+typedef enum
+{
+   MEM_SAFETY_SOME=2,     /* fast: minimal debug performance degredation   */
+   MEM_SAFETY_FULL,       /* slower: recommended during development        */
+   MEM_SAFETY_DEBUG,      /* entire memory pool is checked each entrypoint */
+   MEM_SAFETY_LEVEL_INT_MAX = INT_MAX  /* to ensure enum is full int in size */
+} MEM_SAFETY_LEVEL;
+
+/* Pointer types: parameter to dbgMemCheckPtr */
+typedef enum
+{
+   MEM_POINTER_HEAP,
+   MEM_POINTER_STACK,
+   MEM_POINTER_STATIC,
+   MEM_POINTER_CODE,
+   MEM_POINTER_READONLY,
+   MEM_POINTER_READWRITE
+} MEM_POINTER_TYPE;
+
+/* Debug Pool Info: parameter to dbgMemPoolInfo */
+typedef struct
+{
+   MEM_POOL pool;
+   const char MEM_FAR *name;
+   MEM_API createAPI;
+   const char MEM_FAR *createFile;
+   int createLine;
+   unsigned long createPass;
+   unsigned long createAllocCount;
+   unsigned createCheckpoint;
+   int isDeferFreeing;
+   unsigned long deferQueueLength;
+   unsigned checkFrequency;
+   MEM_ERROR_INFO lastOkInfo;
+   unsigned long threadID;
+   unsigned long pid;
+	void *callStack[MEM_MAXCALLSTACK];
+} DBGMEM_POOL_INFO;
+
+/* Debug Ptr Info: parameter to dbgMemPtrInfo */
+typedef struct
+{
+   void MEM_FAR *ptr;
+   MEM_POOL pool;
+   unsigned long argSize;
+   MEM_BLOCK_TYPE blockType;
+   MEM_BOOL isInUse;
+   MEM_API createAPI;
+   const char MEM_FAR *createFile;
+   int createLine;
+   unsigned long createPass;
+   unsigned checkpoint;
+   unsigned long allocCount;
+   MEM_BOOL isDeferFreed;
+   MEM_BOOL isFreeFillSuppressed;
+   MEM_BOOL isReadOnly;
+   MEM_BOOL isNoFree;
+   MEM_BOOL isNoRealloc;
+   unsigned long threadID;
+   unsigned long pid;
+	void MEM_FAR *callStack[MEM_MAXCALLSTACK];
+} DBGMEM_PTR_INFO;
+
+/* Stack checking settting: parameter to dbgMemSetStackChecking */
+typedef enum
+{
+	DBGMEM_STACK_CHECK_NONE=1,
+	DBGMEM_STACK_CHECK_ENTRY,
+	DBGMEM_STACK_CHECK_RETURN,
+	DBGMEM_STACK_CHECK_INT_MAX = INT_MAX  /* to ensure enum is full int size */
+} DBGMEM_STACK_CHECKING;
+
+/* Debug Settings Info: parameter to dbgMemSettingsInfo */
+typedef struct
+{
+   MEM_SAFETY_LEVEL safetyLevel;
+   unsigned checkFrequency;
+   unsigned long allocCount;
+   unsigned checkpoint;
+   MEM_BOOL isDeferFreeing;
+   unsigned long deferQueueLength;
+   unsigned long deferSizeThreshold;
+   MEM_BOOL isFreeFillSuppressed;
+   MEM_BOOL isReallocAlwaysMoves;
+   MEM_BOOL isWrongTaskRefReported;
+   unsigned outputFlags;
+   const char MEM_FAR *outputFile;
+   unsigned guardSize;
+	unsigned callstackChains;
+	DBGMEM_STACK_CHECKING stackChecking;
+   unsigned char guardFill;
+   unsigned char freeFill;
+   unsigned char inUseFill;
+} DBGMEM_SETTINGS_INFO;
+
+/* Trace function pointer: parameter to dbgMemSet[Entry/Exit]Handler */
+typedef void (MEM_ENTRY2 * MEM_ENTRY3 MEM_TRACE_FN)
+   (MEM_ERROR_INFO MEM_FAR *, unsigned long);
+
+/* define and initialize these variables at file scope to change defaults */
+extern const unsigned dbgMemGuardSize;
+extern const unsigned char dbgMemGuardFill;
+extern const unsigned char dbgMemFreeFill;
+extern const unsigned char dbgMemInUseFill;
+
+#define DBGMEM_PTR_NOPROTECTION    0x0000u
+#define DBGMEM_PTR_READONLY        0x0001u
+#define DBGMEM_PTR_NOFREE          0x0002u
+#define DBGMEM_PTR_NOREALLOC       0x0004u
+
+#define DBGMEM_OUTPUT_PROMPT       0x0001u
+#define DBGMEM_OUTPUT_CONSOLE      0x0002u
+#define DBGMEM_OUTPUT_BEEP         0x0004u
+#define DBGMEM_OUTPUT_FILE         0x0010u
+#define DBGMEM_OUTPUT_FILE_APPEND  0x0020u
+
+
+
+/*** Function Prototypes ***/
+
+#ifdef MEM_DEBUG
+
+#if defined(MEM_WIN16) || defined(MEM_WIN32)
+#define SHI_MAJOR_VERSION HA_MAJOR_VERSION
+#define SHI_MINOR_VERSION HA_MINOR_VERSION
+#define SHI_UPDATE_LEVEL HA_UPDATE_LEVEL
+#endif /* MEM_WIN16 || MEM_WIN32 */
+
+/* malloc, new, et al call these entry-point in debug lib */
+MEM_ENTRY1 void MEM_FAR * MEM_ENTRY _dbgMemAllocPtr1(MEM_POOL, unsigned long,
+   unsigned, MEM_API, const char MEM_FAR *, int);
+MEM_ENTRY1 MEM_BOOL MEM_ENTRY _dbgMemFreePtr1(void MEM_FAR *, MEM_API,
+   const char MEM_FAR *, int);
+MEM_ENTRY1 void MEM_FAR * MEM_ENTRY _dbgMemReAllocPtr1(void MEM_FAR *,
+   unsigned long, unsigned, MEM_API, const char MEM_FAR *, int);
+MEM_ENTRY1 unsigned long MEM_ENTRY _dbgMemSizePtr1(void MEM_FAR *, MEM_API,
+   const char MEM_FAR *, int);
+void MEM_FAR * MEM_ENTRY _dbgMEM_alloc(size_t, unsigned, MEM_API,
+                                       const char MEM_FAR *, int);
+void MEM_FAR * MEM_ENTRY _dbgMEM_realloc(void MEM_FAR *, size_t,
+                                         const char MEM_FAR *, int);
+void MEM_ENTRY _dbgMEM_free(void MEM_FAR *, const char MEM_FAR *, int);
+MEM_ENTRY1 void MEM_ENTRY _shi_deleteLoc(const char MEM_FAR *file, int line);
+
+
+/* functions to control error detection */
+MEM_ENTRY1 MEM_SAFETY_LEVEL MEM_ENTRY dbgMemSetSafetyLevel(MEM_SAFETY_LEVEL);
+MEM_ENTRY1 MEM_BOOL MEM_ENTRY dbgMemSetGuardSize(unsigned);
+MEM_ENTRY1 MEM_BOOL MEM_ENTRY dbgMemSetGuardFill(MEM_UCHAR);
+MEM_ENTRY1 MEM_BOOL MEM_ENTRY dbgMemSetFreeFill(MEM_UCHAR);
+MEM_ENTRY1 MEM_BOOL MEM_ENTRY dbgMemSetInUseFill(MEM_UCHAR);
+MEM_ENTRY1 MEM_BOOL MEM_ENTRY dbgMemSetCallstackChains(unsigned);
+MEM_ENTRY1 MEM_BOOL MEM_ENTRY dbgMemSetStackChecking(DBGMEM_STACK_CHECKING);
+MEM_ENTRY1 unsigned MEM_ENTRY dbgMemSetCheckpoint(unsigned);
+MEM_ENTRY1 unsigned MEM_ENTRY _dbgMemPoolSetCheckFrequency(MEM_POOL,
+   unsigned, const char MEM_FAR *, int);
+MEM_ENTRY1 MEM_BOOL MEM_ENTRY _dbgMemPoolDeferFreeing(MEM_POOL, int,
+   const char MEM_FAR *, int);
+MEM_ENTRY1 MEM_BOOL MEM_ENTRY _dbgMemPoolFreeDeferred(MEM_POOL,
+   const char MEM_FAR *, int);
+MEM_ENTRY1 MEM_BOOL MEM_ENTRY _dbgMemProtectPtr(void MEM_FAR *, unsigned,
+   const char MEM_FAR *, int);
+
+/* functions to control error reporting */
+MEM_ENTRY1 unsigned MEM_ENTRY dbgMemFormatErrorInfo(MEM_ERROR_INFO MEM_FAR *,
+   char MEM_FAR *, unsigned);
+MEM_ENTRY1 unsigned MEM_ENTRY dbgMemFormatCall(MEM_ERROR_INFO MEM_FAR *,
+   char MEM_FAR *, unsigned);
+MEM_ENTRY1 MEM_BOOL MEM_ENTRY dbgMemSetDefaultErrorOutput(unsigned flags,
+   const char MEM_FAR *file);
+MEM_ENTRY1 MEM_TRACE_FN MEM_ENTRY dbgMemSetEntryHandler(MEM_TRACE_FN);
+MEM_ENTRY1 MEM_TRACE_FN MEM_ENTRY dbgMemSetExitHandler(MEM_TRACE_FN);
+MEM_ENTRY1 MEM_BOOL MEM_ENTRY _dbgMemReportLeakage(MEM_POOL,unsigned,unsigned,
+   const char MEM_FAR *, unsigned);
+
+MEM_ENTRY1 unsigned long MEM_ENTRY _dbgMemTotalCount(const char MEM_FAR *, int);
+MEM_ENTRY1 unsigned long MEM_ENTRY _dbgMemTotalSize(const char MEM_FAR *, int);
+MEM_ENTRY1 void MEM_ENTRY _dbgMemBreakpoint(const char MEM_FAR *, int);
+MEM_ENTRY1 MEM_BOOL MEM_ENTRY _dbg_MemPoolInfo(MEM_POOL,
+   DBGMEM_POOL_INFO MEM_FAR *, const char MEM_FAR *, int);
+MEM_ENTRY1 MEM_BOOL MEM_ENTRY _dbgMemPtrInfo(void MEM_FAR *,
+   DBGMEM_PTR_INFO MEM_FAR *, const char MEM_FAR *, int);
+MEM_ENTRY1 MEM_BOOL MEM_ENTRY _dbgMemSettingsInfo(
+   DBGMEM_SETTINGS_INFO MEM_FAR *, const char MEM_FAR *, int);
+MEM_ENTRY1 unsigned MEM_ENTRY dbgMemSetCheckFrequency(unsigned);
+MEM_ENTRY1 MEM_BOOL MEM_ENTRY dbgMemDeferFreeing(MEM_BOOL);
+MEM_ENTRY1 MEM_BOOL MEM_ENTRY _dbgMemFreeDeferred(const char MEM_FAR *, int);
+MEM_ENTRY1 MEM_BOOL MEM_ENTRY dbgMemReallocMoves(MEM_BOOL);
+MEM_ENTRY1 MEM_BOOL MEM_ENTRY dbgMemSuppressFreeFill(MEM_BOOL);
+MEM_ENTRY1 MEM_BOOL MEM_ENTRY dbgMemReportWrongTaskRef(MEM_BOOL);
+MEM_ENTRY1 unsigned long MEM_ENTRY dbgMemSetDeferQueueLen(unsigned long);
+MEM_ENTRY1 unsigned long MEM_ENTRY dbgMemSetDeferSizeThreshold(unsigned long);
+MEM_ENTRY1 MEM_BOOL MEM_ENTRY _dbgMemPoolSetName(MEM_POOL,
+   const char MEM_FAR *, const char MEM_FAR *, int);
+MEM_ENTRY1 unsigned long MEM_ENTRY _dbgMemPoolSetDeferQueueLen(MEM_POOL,
+   unsigned long, const char MEM_FAR *, int);
+MEM_ENTRY1 MEM_BOOL MEM_ENTRY _dbgMemCheckAll(const char MEM_FAR *, int);
+MEM_POOL_STATUS MEM_ENTRY _dbgMemWalkHeap(
+   MEM_POOL_ENTRY MEM_FAR *, const char MEM_FAR *, int);
+MEM_ENTRY1 MEM_BOOL MEM_ENTRY _dbg_MemCheckPtr(void MEM_FAR *,
+   MEM_POINTER_TYPE, unsigned long, const char MEM_FAR *, int);
+MEM_ENTRY1 MEM_BOOL MEM_ENTRY dbgMemScheduleChecking(MEM_BOOL, int, unsigned);
+#endif
+
+
+/* Wrapper macros for passing file/line info */
+
+#ifndef _SHI_dbgMacros
+#ifdef MEM_DEBUG
+#ifndef MALLOC_MACRO
+#define MEM_malloc(s_) _dbgMEM_alloc(s_, 0, MEM_MEM_MALLOC, __FILE__, __LINE__)
+#define MEM_calloc(s_, c_) _dbgMEM_alloc((s_)*(c_), 1 /*MEM_ZEROINIT*/, \
+   MEM_MEM_CALLOC, __FILE__, __LINE__)
+#define MEM_realloc(p_, s_) _dbgMEM_realloc(p_, s_, __FILE__, __LINE__)
+#define MEM_free(p_) _dbgMEM_free(p_, __FILE__, __LINE__)
+#endif
+#if !defined(NO_MALLOC_MACRO)
+#ifdef malloc
+#undef malloc
+#endif
+#ifdef calloc
+#undef calloc
+#endif
+#ifdef realloc
+#undef realloc
+#endif
+#ifdef free
+#undef free
+#endif
+#define malloc(s_) MEM_malloc(s_)
+#define calloc(s_, c_) MEM_calloc(s_, c_)
+#define realloc(p_, s_) MEM_realloc(p_, s_)
+#define free(p_) MEM_free(p_)
+#endif /* NO_MALLOC_MACRO */
+
+#define dbgMemPoolSetCheckFrequency(p, b) \
+     _dbgMemPoolSetCheckFrequency(p, b, __FILE__, __LINE__)
+#define dbgMemPoolDeferFreeing(p, b) \
+     _dbgMemPoolDeferFreeing(p, b, __FILE__, __LINE__)
+#define dbgMemPoolFreeDeferred(p) _dbgMemPoolFreeDeferred(p,__FILE__,__LINE__)
+#define dbgMemProtectPtr(p, b)    _dbgMemProtectPtr(p, b, __FILE__, __LINE__)
+#define dbgMemReportLeakage(p, c1, c2) \
+     _dbgMemReportLeakage(p, c1, c2, __FILE__, __LINE__)
+
+#define dbgMemTotalCount() _dbgMemTotalCount(__FILE__, __LINE__)
+#define dbgMemTotalSize() _dbgMemTotalSize(__FILE__, __LINE__)
+#define dbgMemPoolInfo(p, b) _dbg_MemPoolInfo(p, b, __FILE__, __LINE__)
+#define dbgMemPtrInfo(p, b) _dbgMemPtrInfo(p, b, __FILE__, __LINE__)
+#define dbgMemSettingsInfo(b) _dbgMemSettingsInfo(b, __FILE__, __LINE__)
+#define dbgMemPoolSetName(p, n) _dbgMemPoolSetName(p, n, __FILE__, __LINE__)
+#define dbgMemPoolSetDeferQueueLen(p, l) \
+   _dbgMemPoolSetDeferQueueLen(p, l, __FILE__, __LINE__)
+#define dbgMemFreeDeferred() _dbgMemFreeDeferred(__FILE__, __LINE__)
+#define dbgMemWalkHeap(b) _dbgMemWalkHeap(b, __FILE__, __LINE__)
+#define dbgMemCheckAll() _dbgMemCheckAll(__FILE__, __LINE__)
+#define dbgMemCheckPtr(p, t, s) _dbg_MemCheckPtr(p, t, s, __FILE__, __LINE__)
+#define dbgMemBreakpoint() _dbgMemBreakpoint(__FILE__, __LINE__)
+
+#endif /* MEM_DEBUG */
+#endif /* _SHI_dbgMacros */
+
+       
+#ifdef __cplusplus
+}
+
+#ifndef __BORLANDC__
+/* Borland C++ does not treat extern "C++" correctly */
+extern "C++"
+{
+#endif /* __BORLANDC__ */
+
+#if defined(_MSC_VER) && _MSC_VER >= 900
+#pragma warning(disable : 4507)
+#endif
+
+#if defined(new)
+#if defined(MEM_DEBUG)
+#undef new
+#define DEFINE_NEW_MACRO 1
+#endif
+#endif
+
+#ifdef DEBUG_NEW
+#undef DEBUG_NEW
+#endif
+#ifdef DEBUG_DELETE
+#undef DEBUG_DELETE
+#endif
+   
+#ifdef MEM_DEBUG
+#define DBG_FORMAL , const char MEM_FAR *file, int line
+#define DBG_ACTUAL , file, line
+
+
+/* both debug and non-debug versions are both defined so that calls
+ * to shi_New from inline versions of operator new in modules
+ * that were not recompiled with MEM_DEBUG will resolve correctly
+ */
+void MEM_FAR * MEM_ENTRY_ANSI shi_New(unsigned long DBG_FORMAL, unsigned=0,
+   MEM_POOL=0);
+
+/* operator new variants: */
+
+/* compiler-specific versions of new */
+#if UINT_MAX == 0xFFFFu
+#if defined(__BORLANDC__)
+#if (defined(__LARGE__) || defined(__COMPACT__) || defined(__HUGE__))
+inline void far *operator new(unsigned long sz DBG_FORMAL)
+   { return shi_New(sz DBG_ACTUAL); }
+#if __BORLANDC__ >= 0x450
+inline void MEM_FAR *operator new[](unsigned long sz DBG_FORMAL)
+   { return shi_New(sz DBG_ACTUAL); }
+#endif /* __BORLANDC__ >= 0x450 */
+#endif /* __LARGE__ */
+
+#elif defined(_MSC_VER)
+#if (defined(M_I86LM) || defined(M_I86CM) || defined(M_I86HM))
+inline void __huge * operator new(unsigned long count, size_t sz DBG_FORMAL)
+   { return (void __huge *)shi_New(count * sz DBG_ACTUAL, MEM_HUGE); }
+#endif /* M_I86LM */
+#endif /* _MSC_VER */
+
+#endif /* compiler-specific versions of new */
+
+/* version of new that passes memory allocation flags */
+inline void MEM_FAR *operator new(size_t sz DBG_FORMAL, unsigned flags)
+   { return shi_New(sz DBG_ACTUAL, flags); }
+
+/* version of new that allocates from a specified memory pool with alloc flags*/
+inline void MEM_FAR *operator new(size_t sz DBG_FORMAL, MEM_POOL pool)
+   { return shi_New(sz DBG_ACTUAL, 0, pool); }
+inline void MEM_FAR *operator new(size_t sz DBG_FORMAL, MEM_POOL pool, 
+                                  unsigned flags)
+   { return shi_New(sz DBG_ACTUAL, flags, pool); }
+#ifdef SHI_ARRAY_NEW
+inline void MEM_FAR *operator new[](size_t sz DBG_FORMAL, MEM_POOL pool)
+   { return shi_New(sz DBG_ACTUAL, 0, pool); }
+inline void MEM_FAR *operator new[](size_t sz DBG_FORMAL, MEM_POOL pool, 
+                                  unsigned flags)
+   { return shi_New(sz DBG_ACTUAL, flags, pool); }
+#endif /* SHI_ARRAY_NEW */
+
+/* version of new that changes the size of a memory block */
+inline void MEM_FAR *operator new(size_t new_sz DBG_FORMAL,
+                                  void MEM_FAR *lpMem, unsigned flags)
+   { return _dbgMemReAllocPtr1(lpMem, new_sz, flags, MEM_NEW DBG_ACTUAL); }
+#ifdef SHI_ARRAY_NEW
+inline void MEM_FAR *operator new[](size_t new_sz DBG_FORMAL,
+                                    void MEM_FAR *lpMem, unsigned flags)
+   { return _dbgMemReAllocPtr1(lpMem, new_sz, flags, MEM_NEW DBG_ACTUAL); }
+#endif /* SHI_ARRAY_NEW */
+
+/* To have HeapAgent track file/line of C++ allocations,
+ * define new/delete as macros:
+ * #define new DEBUG_NEW
+ * #define delete DEBUG_DELETE
+ *
+ * In cases where you use explicit placement syntax, or in modules that define
+ * operator new/delete, you must undefine the new/delete macros, e.g.:
+ * #undef new
+ *    void *x = new(placementArg) char[30];  // cannot track file/line info
+ * #define new DEBUG_NEW
+ *    void *y = new char[20];                // resume tracking file/line info
+ */
+
+#if (!(defined(_AFX) && defined(_DEBUG)) \
+	  && !(defined(_MSC_VER) && _MSC_VER >= 900))
+/* this must be defined out-of-line for _DEBUG MFC and MEM_DEBUG VC++/Win32 */
+inline void MEM_FAR *operator new(size_t sz DBG_FORMAL)
+   { return shi_New(sz DBG_ACTUAL); }
+#else
+void MEM_FAR * MEM_ENTRY_ANSI operator new(size_t sz DBG_FORMAL);
+#endif /* _AFX && _DEBUG */
+
+#ifdef SHI_ARRAY_NEW
+inline void MEM_FAR *operator new[](size_t sz DBG_FORMAL)
+   { return shi_New(sz DBG_ACTUAL); }
+#endif /* SHI_ARRAY_NEW */
+
+#if !(defined(__IBMCPP__) && defined(__DEBUG_ALLOC__))
+/* debug new/delete built in for IBM Set C++ and Visual Age C++ */
+
+#define DEBUG_NEW new(__FILE__, __LINE__)
+#define DEBUG_NEW1(x_) new(__FILE__, __LINE__, x_)
+#define DEBUG_NEW2(x_, y_) new(__FILE__, __LINE__, x_, y_)
+#define DEBUG_NEW3(x_, y_, z_) new(__FILE__, __LINE__, x_, y_, z_)
+
+#define DEBUG_DELETE _shi_deleteLoc(__FILE__, __LINE__), delete
+
+#ifdef DEFINE_NEW_MACRO
+#ifdef macintosh  /* MPW C++ bug precludes new --> DEBUG_NEW --> new(...) */
+#define new new(__FILE__, __LINE__)
+#define delete _shi_deleteLoc(__FILE__, __LINE__), delete
+#else
+#define new DEBUG_NEW
+#define delete DEBUG_DELETE
+#endif /* macintosh */
+#endif /* DEFINE_NEW_MACRO */
+#endif /* __IBMCPP__ */
+#endif /* MEM_DEBUG */
+
+#include "smrtheap.hpp"
+
+#ifndef __BORLANDC__
+}
+#endif /* __BORLANDC__ */
+
+#endif /* __cplusplus */
+
+#endif /* !defined(_HEAPAGNT_H) */
diff --git a/code/smartheap/SMRTHEAP.C b/code/smartheap/SMRTHEAP.C
new file mode 100644
index 0000000..925f52d
--- /dev/null
+++ b/code/smartheap/SMRTHEAP.C
@@ -0,0 +1,54 @@
+extern int SmartHeap_malloc;
+extern int SmartHeap_new;
+
+static void *refSmartHeap_malloc = &SmartHeap_malloc;
+
+#if defined(_DEBUG) && !defined(MEM_DEBUG)
+#define MEM_DEBUG 1
+#endif
+
+#if defined(MFC) && !defined(_AFXDLL)
+
+static void *refSmartHeap_new = &SmartHeap_new;
+
+#ifdef MEM_DEBUG
+#if _MSC_VER < 1000
+#pragma comment(lib, "hamfc32m.lib")
+#else
+#pragma comment(lib, "hamfc4m.lib")
+#endif /* _MSC_VER */
+#else
+#if _MSC_VER >= 1000
+#ifdef _MT
+#pragma comment(lib, "shmfc4mt.lib")
+#else
+#pragma comment(lib, "shmfc4m.lib")
+#endif /* _MT */
+#endif /* _MSC_VER */
+#endif /* MEM_DEBUG */
+
+#endif /* MFC */
+
+#if defined(MEM_DEBUG)
+#pragma comment(lib, "haw32m.lib")
+#elif defined(_DLL)
+#ifdef _MT
+#ifdef MEM_SMP
+#pragma comment(lib, "shdsmpmt.lib")
+#else
+#pragma comment(lib, "shdw32mt.lib")
+#endif /* MEM_SMP */
+#else
+#pragma comment(lib, "shdw32m.lib")
+#endif /* _MT */
+#else /* _DLL */
+#ifdef _MT
+#ifdef MEM_SMP
+#pragma comment(lib, "shlsmpmt.lib")
+#else
+#pragma comment(lib, "shlw32mt.lib")
+#endif /* MEM_SMP */
+#else
+#pragma comment(lib, "shlw32m.lib")
+#endif /* _MT */
+#endif /* MEM_DEBUG */
diff --git a/code/smartheap/SMRTHEAP.H b/code/smartheap/SMRTHEAP.H
new file mode 100644
index 0000000..90bce42
--- /dev/null
+++ b/code/smartheap/SMRTHEAP.H
@@ -0,0 +1,847 @@
+/* smrtheap.h -- SmartHeap (tm) public C header file
+ * Professional Memory Management Library
+ *
+ * Copyright (C) 1991-1999 Compuware Corporation.
+ * All Rights Reserved.
+ *
+ * No part of this source code may be copied, modified or reproduced
+ * in any form without retaining the above copyright notice.
+ * This source code, or source code derived from it, may not be redistributed
+ * without express written permission of the author.
+ *
+ */
+
+#if !defined(_SMARTHEAP_H)
+#define _SMARTHEAP_H
+
+#include <limits.h>
+#include <stddef.h>
+
+#if !defined(macintosh) && !defined(THINK_C) && !defined(__MWERKS__) \
+   && !defined(SHANSI) && UINT_MAX == 0xFFFFu \
+   && (defined(_Windows) || defined(_WINDOWS) || defined(__WINDOWS__))
+   #define MEM_WIN16
+#endif
+
+#if (UINT_MAX == 0xFFFFu) && (defined(MEM_WIN16) \
+	|| defined(MSDOS) || defined(__MSDOS__) || defined(__DOS__))
+   /* 16-bit X86 */
+   #if defined(SYS_DLL)
+      #if defined(_MSC_VER) && _MSC_VER <= 600
+         #define MEM_ENTRY _export _loadds far pascal
+      #else
+         #define MEM_ENTRY _export far pascal
+      #endif
+   #else
+      #define MEM_ENTRY far pascal
+   #endif
+   #ifdef __WATCOMC__
+      #define MEM_ENTRY_ANSI __far
+   #else
+      #define MEM_ENTRY_ANSI far cdecl
+   #endif
+   #define MEM_FAR far
+   #if defined(MEM_WIN16)
+      #define MEM_ENTRY2 _export far pascal
+   #elif defined(DOS16M) || defined(DOSX286)
+      #define MEM_ENTRY2 _export _loadds far pascal
+   #endif
+
+#else  /* not 16-bit X86 */
+
+#if defined(WIN32) || defined(_WIN32) || defined(__WIN32) \
+    || defined(__WIN32__) || defined(__NT__)
+   #define MEM_WIN32
+   #if defined(_MSC_VER)
+      #if defined(_SHI_Pool) && defined(SYS_DLL)
+         #define MEM_ENTRY1 __declspec(dllexport)
+         #define MEM_ENTRY4 __declspec(dllexport) extern
+      #elif !defined(_SHI_Pool) && (defined(MEM_DEBUG) || defined(MEM_DLL))
+         #define MEM_ENTRY1 __declspec(dllimport)
+         #if defined(_M_IX86) || defined(_X86_)
+            #define MemDefaultPool shi_MemDefaultPool
+            #define MEM_ENTRY4 __declspec(dllimport)
+         #endif
+      #endif
+   #endif
+   #if (defined(_MT) || defined(__MT__)) && !defined(MEM_DEBUG)
+/* @@@     #define MEM_MT 1 */
+   #endif
+   #if !defined(_MSC_VER) || defined(_M_IX86) || defined(_X86_)
+      #define MEM_ENTRY __stdcall
+   #else
+      #define MEM_ENTRY __cdecl  /* for NT/RISC */
+   #endif
+   #ifndef __WATCOMC__
+      #define MEM_ENTRY_ANSI __cdecl
+   #endif
+
+#elif defined(__OS2__)
+   #if defined(__BORLANDC__) || defined(__WATCOMC__)
+      #if defined(SYS_DLL)
+         #define MEM_ENTRY __export __syscall
+      #else
+         #define MEM_ENTRY __syscall
+      #endif /* SYS_DLL */
+      #ifdef __BORLANDC__
+         #define MEM_ENTRY_ANSI __stdcall
+      #endif
+   #elif defined(__IBMC__) || defined(__IBMCPP__)
+      #if defined(SYS_DLL) && 0
+         #define MEM_ENTRY _Export _System
+      #else
+         #define MEM_ENTRY _System
+      #endif
+      #define MEM_ENTRY_ANSI _Optlink
+      #define MEM_ENTRY3 MEM_ENTRY
+      #define MEM_CALLBACK MEM_ENTRY3
+      #define MEM_ENTRY2
+   #endif
+
+#elif defined(__sun) || defined(__hpux) || defined(__osf__) || defined(sgi)
+   #if defined(_REENTRANT) && !defined(MEM_DEBUG)
+/* @@@   #define MEM_MT 1 */
+   #endif
+
+#elif defined(_AIX)
+   #if defined(_THREAD_SAFE) && !defined(MEM_DEBUG)
+/*   #define MEM_MT 1 */
+   #endif
+
+#endif /* WIN32, OS2, UNIX */
+
+#if defined(__WATCOMC__) && defined(__SW_3S)
+   /* Watcom stack calling convention */
+#ifndef __OS2__
+#ifdef __WINDOWS_386__
+   #pragma aux syscall "*_" parm routine [eax ebx ecx edx fs gs] modify [eax];
+#else
+   #pragma aux syscall "*_" parm routine [eax ebx ecx edx] modify [eax];
+#endif
+#ifndef MEM_ENTRY
+   #define MEM_ENTRY __syscall
+#endif /* MEM_ENTRY */
+#endif
+#endif /* Watcom stack calling convention */
+
+#endif /* end of system-specific declarations */
+
+#ifndef MEM_ENTRY
+   #define MEM_ENTRY
+#endif
+#ifndef MEM_ENTRY1
+   #define MEM_ENTRY1
+#endif
+#ifndef MEM_ENTRY2
+   #define MEM_ENTRY2 MEM_ENTRY
+#endif
+#ifndef MEM_ENTRY3
+   #define MEM_ENTRY3
+#endif
+#ifndef MEM_ENTRY4
+   #define MEM_ENTRY4 extern
+#endif
+#ifndef MEM_CALLBACK
+#define MEM_CALLBACK MEM_ENTRY2
+#endif
+#ifndef MEM_ENTRY_ANSI
+   #define MEM_ENTRY_ANSI
+#endif
+#ifndef MEM_FAR
+   #define MEM_FAR
+#endif
+
+#ifdef applec
+/* Macintosh: Apple MPW C/C++ passes char/short parms as longs (4 bytes),
+ * whereas Symantec C/C++ for MPW passes these as words (2 bytes);
+ * therefore, canonicalize all integer parms as 'int' for this platform.
+ */
+   #define MEM_USHORT unsigned
+   #define MEM_UCHAR unsigned
+#else
+   #define MEM_USHORT unsigned short
+   #define MEM_UCHAR unsigned char
+#endif /* applec */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+#if !defined(MEM_DEBUG) || !(defined(MEM_WIN16) || defined(MEM_WIN32))
+#define SHI_MAJOR_VERSION 5
+#define SHI_MINOR_VERSION 0
+#define SHI_UPDATE_LEVEL 0
+#endif /* !(MEM_WIN16 || MEM_WIN32) */
+
+	 
+/*** Types ***/
+
+typedef int MEM_BOOL;
+
+/* Version Masks */
+typedef unsigned MEM_VERSION;
+#define MEM_MAJOR_VERSION(v) (((v) & 0xF000u) >> 12)
+#define MEM_MINOR_VERSION(v) (((v) & 0x0F00u) >> 8)
+#define MEM_UPDATE_VERSION(v) ((v) & 0x00FFu)
+
+/* Note: these types are struct's rather than integral types to facilitate
+ * compile-time type-checking.  MEM_POOL and MEM_HANDLE should be regarded
+ * as black boxes, and treated just like handles.
+ * You should not have any type casts to or from MEM_POOL or MEM_HANDLE;
+ * nor should you dereference variables of type MEM_POOL or MEM_HANDLE
+ * (unless you are using SmartHeap to replace NewHandle on the Mac, and
+ * you have existing code that dereferences handles).
+ */
+#ifdef _SHI_Pool
+  typedef struct _SHI_Pool MEM_FAR *MEM_POOL;
+  typedef struct _SHI_MovHandle MEM_FAR *MEM_HANDLE;
+#else
+  #ifdef THINK_C
+    typedef void *MEM_POOL;
+    typedef void **MEM_HANDLE;
+  #else
+    typedef struct _SHI_Pool { int reserved; } MEM_FAR *MEM_POOL;
+    typedef struct _SHI_MovHandle { int reserved; } MEM_FAR *MEM_HANDLE;
+  #endif
+#endif
+    
+
+/* Error codes: errorCode field of MEM_ERROR_INFO */
+typedef enum
+{
+   MEM_NO_ERROR=0,
+   MEM_INTERNAL_ERROR,
+   MEM_OUT_OF_MEMORY,
+   MEM_BLOCK_TOO_BIG,
+   MEM_ALLOC_ZERO,
+   MEM_RESIZE_FAILED,
+   MEM_LOCK_ERROR,
+   MEM_EXCEEDED_CEILING,
+   MEM_TOO_MANY_PAGES,
+   MEM_TOO_MANY_TASKS,
+   MEM_BAD_MEM_POOL,
+   MEM_BAD_BLOCK,
+   MEM_BAD_FREE_BLOCK,
+   MEM_BAD_HANDLE,
+   MEM_BAD_POINTER,
+   MEM_WRONG_TASK,
+   MEM_NOT_FIXED_SIZE,
+   MEM_BAD_FLAGS,
+#ifdef MEM_DEBUG
+   MEM_BAD_BUFFER,
+   MEM_DOUBLE_FREE,
+   MEM_UNDERWRITE,
+   MEM_OVERWRITE, 
+   MEM_FREE_BLOCK_WRITE,
+   MEM_READONLY_MODIFIED,
+   MEM_NOFREE,
+   MEM_NOREALLOC,
+   MEM_LEAKAGE,
+   MEM_FREE_BLOCK_READ,
+   MEM_UNINITIALIZED_READ,
+   MEM_UNINITIALIZED_WRITE,
+   MEM_OUT_OF_BOUNDS_READ,
+	MEM_UNDERWRITE_STACK,
+	MEM_OVERWRITE_STACK,
+	MEM_FREE_STACK_READ,
+	MEM_UNINITIALIZED_READ_STACK,
+	MEM_UNINITIALIZED_WRITE_STACK,
+	MEM_OUT_OF_BOUNDS_READ_STACK,
+   MEM_LASTOK,
+   MEM_BREAKPOINT,
+   MEM_ERROR_CODE_COUNT,
+#endif /* MEM_DEBUG */
+   MEM_ERROR_CODE_INT_MAX = INT_MAX  /* to ensure enum is full int in size */
+} MEM_ERROR_CODE;
+
+/* HeapAgent Entry-Point API identifiers: errorAPI field of MEM_ERROR_INFO */
+typedef enum
+{
+   MEM_NO_API,
+   MEM_MEMVERSION,
+   MEM_MEMREGISTERTASK,
+   MEM_MEMUNREGISTERTASK,
+   MEM_MEMPOOLINIT,
+   MEM_MEMPOOLINITFS,
+   MEM_MEMPOOLFREE,
+   MEM_MEMPOOLSETPAGESIZE,
+   MEM_MEMPOOLSETBLOCKSIZEFS,
+   MEM_MEMPOOLSETFLOOR,
+   MEM_MEMPOOLSETCEILING,
+   MEM_MEMPOOLPREALLOCATE,
+   MEM_MEMPOOLPREALLOCATEHANDLES,
+   MEM_MEMPOOLSHRINK,
+   MEM_MEMPOOLSIZE,
+   MEM_MEMPOOLCOUNT,
+   MEM_MEMPOOLINFO,
+   MEM_MEMPOOLFIRST,
+   MEM_MEMPOOLNEXT,
+   MEM_MEMPOOLWALK,
+   MEM_MEMPOOLCHECK,
+   MEM_MEMALLOC,
+   MEM_MEMREALLOC,
+   MEM_MEMFREE,
+   MEM_MEMLOCK,
+   MEM_MEMUNLOCK,
+   MEM_MEMFIX,
+   MEM_MEMUNFIX,
+   MEM_MEMLOCKCOUNT,
+   MEM_MEMISMOVEABLE,
+   MEM_MEMREFERENCE,
+   MEM_MEMHANDLE,
+   MEM_MEMSIZE,
+   MEM_MEMALLOCPTR,
+   MEM_MEMREALLOCPTR,
+   MEM_MEMFREEPTR,
+   MEM_MEMSIZEPTR,
+   MEM_MEMCHECKPTR,
+   MEM_MEMALLOCFS,
+   MEM_MEMFREEFS,
+   MEM_MEM_MALLOC,
+   MEM_MEM_CALLOC,
+   MEM_MEM_REALLOC,
+   MEM_MEM_FREE,
+   MEM_NEW,
+   MEM_DELETE,
+   MEM_DBGMEMPOOLSETCHECKFREQUENCY,
+   MEM_DBGMEMPOOLDEFERFREEING,
+   MEM_DBGMEMPOOLFREEDEFERRED,
+   MEM_DBGMEMPROTECTPTR,
+   MEM_DBGMEMREPORTLEAKAGE,
+   MEM_MEMPOOLINITNAMEDSHARED,
+   MEM_MEMPOOLINITNAMEDSHAREDEX,
+   MEM_MEMPOOLATTACHSHARED,
+   MEM_DBGMEMPOOLINFO,
+   MEM_DBGMEMPTRINFO,
+   MEM_DBGMEMSETTINGSINFO,
+   MEM_DBGMEMCHECKPTR,
+   MEM_DBGMEMPOOLSETNAME,
+   MEM_DBGMEMPOOLSETDEFERQUEUELEN,
+   MEM_DBGMEMFREEDEFERRED,
+   MEM_DBGMEMCHECKALL,
+   MEM_DBGMEMBREAKPOINT,
+   MEM_MEMPOOLLOCK,
+   MEM_MEMPOOLUNLOCK,
+	MEM_MEMPOOLSETSMALLBLOCKSIZE,
+   MEM_MEMSIZEREQUESTED,
+	MEM_MSIZE,
+	MEM_EXPAND,
+	MEM_GETPROCESSHEAP,
+	MEM_GETPROCESSHEAPS,
+	MEM_GLOBALALLOC,
+	MEM_GLOBALFLAGS,
+	MEM_GLOBALFREE,
+	MEM_GLOBALHANDLE,
+	MEM_GLOBALLOCK,
+	MEM_GLOBALREALLOC,
+	MEM_GLOBALSIZE,
+	MEM_GLOBALUNLOCK,
+	MEM_HEAPALLOC,
+	MEM_HEAPCOMPACT,
+	MEM_HEAPCREATE,
+	MEM_HEAPDESTROY,
+	MEM_HEAPFREE,
+	MEM_HEAPLOCK,
+	MEM_HEAPREALLOC,
+	MEM_HEAPSIZE,
+	MEM_HEAPUNLOCK,
+	MEM_HEAPVALIDATE,
+	MEM_HEAPWALK,
+	MEM_LOCALALLOC,
+	MEM_LOCALFLAGS,
+	MEM_LOCALFREE,
+	MEM_LOCALHANDLE,
+	MEM_LOCALLOCK,
+	MEM_LOCALREALLOC,
+	MEM_LOCALSIZE,
+	MEM_LOCALUNLOCK,
+	MEM_MEMPOOLINITREGION,
+	MEM_TERMINATE,
+   MEM_HEAPAGENT,
+   MEM_USER_API,
+   MEM_API_COUNT,
+   MEM_API_INT_MAX = INT_MAX  /* to ensure enum is full int in size */
+} MEM_API;
+
+#define MEM_MAXCALLSTACK 16  /* maximum number of call stack frames recorded */
+
+/* Error info, passed to error-handling callback routine */
+typedef struct _MEM_ERROR_INFO
+{
+   MEM_ERROR_CODE errorCode; /* error code identifying type of error      */
+   MEM_POOL pool;            /* pool in which error occurred, if known    */
+
+/* all fields below this are valid only for debugging lib                 */
+   /* the following seven fields identify the call where error detected   */
+   MEM_API errorAPI;         /* fn ID of entry-point where error detected */
+   MEM_POOL argPool;         /* memory pool parameter, if applicable      */
+   void MEM_FAR *argPtr;     /* memory pointer parameter, if applicable   */
+   void MEM_FAR *argBuf;     /* result buffer parameter, if applicable    */
+   MEM_HANDLE argHandle;     /* memory handle parameter, if applicable    */
+   unsigned long argSize;    /* size parameter, if applicable             */
+   unsigned long argCount;   /* count parameter, if applicable            */
+   unsigned argFlags;        /* flags parameter, if applicable            */
+
+   /* the following two fields identify the app source file and line      */
+   const char MEM_FAR *file; /* app source file containing above call     */
+   int line;            /* source line in above file                 */
+
+   /* the following two fields identify call instance of error detection  */
+   unsigned long allocCount; /* enumeration of allocation since 1st alloc */
+   unsigned long passCount;  /* enumeration of call at at above file/line */
+   unsigned checkpoint;      /* group with which call has been tagged     */
+   
+   /* the following fields, if non-NULL, points to the address where an
+      overwrite was detected and another MEM_ERROR_INFO structure
+      identifying where the corrupted object was first created, if known  */
+   void MEM_FAR *errorAlloc;  /* ptr to beginning of alloc related to error */
+   void MEM_FAR *corruptAddr;
+   struct _MEM_ERROR_INFO MEM_FAR *objectCreationInfo;
+
+   unsigned long threadID;    /* ID of thread where error detected */
+   unsigned long pid;         /* ID of process where error detected */
+
+	void MEM_FAR *callStack[MEM_MAXCALLSTACK];
+} MEM_ERROR_INFO;
+
+/* Error handling callback function */
+typedef MEM_BOOL (MEM_ENTRY2 * MEM_ENTRY3 MEM_ERROR_FN)
+   (MEM_ERROR_INFO MEM_FAR *);
+
+
+/* Block Type: field of MEM_POOL_ENTRY, field of MEM_POOL_INFO,
+ * parameter to MemPoolPreAllocate
+ */
+typedef enum
+{
+   MEM_FS_BLOCK               = 0x0001u,
+   MEM_VAR_MOVEABLE_BLOCK     = 0x0002u,
+   MEM_VAR_FIXED_BLOCK        = 0x0004u,
+   MEM_EXTERNAL_BLOCK         = 0x0008u,
+   MEM_BLOCK_TYPE_INT_MAX = INT_MAX  /* to ensure enum is full int in size */
+} MEM_BLOCK_TYPE;
+
+typedef enum
+{
+	MEM_SMALL_BLOCK_NONE,
+	MEM_SMALL_BLOCK_SH3,
+	MEM_SMALL_BLOCK_SH5,
+   MEM_SMALL_BLOCK_INT_MAX = INT_MAX  /* to ensure enum is full int in size */
+} MEM_SMALL_BLOCK_ALLOCATOR;
+
+/* Pool Entry: parameter to MemPoolWalk */
+typedef struct
+{
+   void MEM_FAR *entry;
+   MEM_POOL pool;
+   MEM_BLOCK_TYPE type;
+   MEM_BOOL isInUse;
+   unsigned long size;
+   MEM_HANDLE handle;
+   unsigned lockCount;
+   void MEM_FAR *reserved_ptr;
+} MEM_POOL_ENTRY;
+
+/* Pool Status: returned by MemPoolWalk, MemPoolFirst, MemPoolNext */
+typedef enum
+{
+   MEM_POOL_OK            = 1,
+   MEM_POOL_CORRUPT       = -1,
+   MEM_POOL_CORRUPT_FATAL = -2,
+   MEM_POOL_END           = 0,
+   MEM_POOL_STATUS_INT_MAX = INT_MAX  /* to ensure enum is full int in size */
+} MEM_POOL_STATUS;
+
+/* Pointer Status: returned by MemCheckPtr */
+typedef enum
+{
+   MEM_POINTER_OK    = 1,
+   MEM_POINTER_WILD  = 0,
+   MEM_POINTER_FREE  = -1,
+   MEM_POINTER_STATUS_INT_MAX = INT_MAX /* to ensure enum is full int */
+} MEM_POINTER_STATUS;
+
+/* Pool Info: parameter to MemPoolInfo, MemPoolFirst, MemPoolNext */
+typedef struct
+{
+   MEM_POOL pool;
+   MEM_BLOCK_TYPE type; /* disjunctive combination of block type flags */
+	unsigned short blockSizeFS;
+	unsigned short smallBlockSize;
+   unsigned pageSize;
+   unsigned long floor;
+   unsigned long ceiling;
+   unsigned flags;
+   MEM_ERROR_FN errorFn;
+} MEM_POOL_INFO;
+
+/* Flags passed to MemAlloc, MemAllocPtr, MemReAlloc, MemReAllocPtr */
+#define MEM_FIXED           0x0000u /* fixed handle-based block            */
+#define MEM_ZEROINIT        0x0001u /* == TRUE for SH 1.5 compatibility    */
+#define MEM_MOVEABLE        0x0002u /* moveable handle-based block         */
+#define MEM_RESIZEABLE      0x0004u /* reserve space above block           */
+#define MEM_RESIZE_IN_PLACE 0x0008u /* do not move block (realloc)         */
+#define MEM_NOGROW          0x0010u /* do not grow heap to satisfy request */
+#define MEM_NOEXTERNAL      0x0020u /* reserved for internal use           */
+#define MEM_NOCOMPACT       0x0040u /* do not compact to satisfy request   */
+#define MEM_NO_SERIALIZE    0x0080u /* do not serialize this request       */
+#define MEM_HANDLEBASED     0x4000u /* for internal use */
+#define MEM_RESERVED        0x8000u /* for internal use */
+
+#define MEM_UNLOCK_FAILED USHRT_MAX
+
+/* Flags passed to MemPoolInit, MemPoolInitFS */
+#define MEM_POOL_SHARED       0x0001u /* == TRUE for SH 1.5 compatibility  */
+#define MEM_POOL_SERIALIZE    0x0002u /* pool used in more than one thread */
+#define MEM_POOL_VIRTUAL_LOCK 0x0004u /* pool is locked in physical memory */
+#define MEM_POOL_ZEROINIT     0x0008u /* malloc/new from pool zero-inits   */
+#define MEM_POOL_REGION       0x0010u /* store pool in user-supplied region*/
+#define MEM_POOL_DEFAULT      0x8000u /* pool with default characteristics */
+
+/* Default memory pool for C malloc, C++ new (for backwards compatibility) */
+#define MEM_DEFAULT_POOL MemDefaultPool
+
+/* define and initialize these variables at file scope to change defaults */
+extern unsigned short MemDefaultPoolBlockSizeFS;
+extern unsigned MemDefaultPoolPageSize;
+extern unsigned MemDefaultPoolFlags;
+
+/* define SmartHeap_malloc at file scope if you
+ * are intentionally _NOT_ linking in the SmartHeap malloc definition
+ * ditto for SmartHeap operator new, and fmalloc et al.
+ */
+extern int SmartHeap_malloc;
+extern int SmartHeap_far_malloc;
+extern int SmartHeap_new;
+
+#define MEM_ERROR_RET ULONG_MAX
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#ifdef MEM_DEBUG
+#include "heapagnt.h"
+#endif
+
+#endif /* !defined(_SMARTHEAP_H) */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef MEM_MT
+#ifdef MemDefaultPool
+#undef MemDefaultPool
+#endif
+#define MemDefaultPool shi_getThreadPool()
+#ifndef MemInitDefaultPool
+#define MemInitDefaultPool() shi_getThreadPool()
+#define MemFreeDefaultPool() shi_freeThreadPools()
+#endif
+MEM_ENTRY1 MEM_POOL MEM_ENTRY shi_getThreadPool(void);
+MEM_ENTRY1 MEM_BOOL MEM_ENTRY shi_freeThreadPools(void);
+
+#else /* MEM_MT */
+MEM_ENTRY4 MEM_POOL MemDefaultPool;
+MEM_POOL MEM_ENTRY MemInitDefaultPool(void);
+MEM_BOOL MEM_ENTRY MemFreeDefaultPool(void);
+#endif /* MEM_MT */
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+/*** Function Prototypes ***/
+
+#ifndef _SMARTHEAP_PROT
+#define _SMARTHEAP_PROT
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef _shAPI
+   #if defined(MEM_DEBUG) && !defined(SHI_NO_MEM_DEBUG)
+      #define _shAPI(ret, name) MEM_ENTRY1 ret MEM_ENTRY _dbg ## name
+   #else
+      #define _shAPI(ret, name) MEM_ENTRY1 ret MEM_ENTRY name
+   #endif
+#endif
+
+#ifndef _dbgARGS
+   #if defined(MEM_DEBUG) && !defined(SHI_NO_MEM_DEBUG)
+      #define _dbgARGS1 const char MEM_FAR *, int
+      #define _dbgARGS , _dbgARGS1
+   #else
+      #define _dbgARGS1 void
+      #define _dbgARGS
+   #endif
+#endif
+
+   
+/**** HOW TO READ SmartHeap PROTOTYPES ****
+ * prototypes below have the follow syntax in order to support both debug
+ * and non-debug APIs with single-source:
+ *
+ * _shiAPI(<return-type>, <API name>)([<parms>] _dbgARGS);
+ *
+ * the above translates to a C prototype as follows:
+ *
+ * <return-type> <API name>([<parms>]);
+ */
+   
+/* Library Version */
+MEM_ENTRY1 MEM_VERSION MEM_ENTRY MemVersion(void);
+
+/* Library Registration */
+_shAPI(MEM_BOOL, MemRegisterTask)(_dbgARGS1);
+_shAPI(MEM_BOOL, MemUnregisterTask)(_dbgARGS1);
+
+/* Process heap usage */
+MEM_ENTRY1 void MEM_ENTRY MemProcessSetGrowIncrement(unsigned long);
+
+/* Memory Pool Functions */
+_shAPI(MEM_POOL, MemPoolInit)(unsigned _dbgARGS);
+_shAPI(MEM_POOL, MemPoolInitFS)(MEM_USHORT, unsigned long, 
+   unsigned _dbgARGS);
+_shAPI(MEM_POOL, MemPoolInitRegion)(void MEM_FAR *,
+												unsigned long size, unsigned _dbgARGS);
+_shAPI(MEM_POOL, MemPoolInitRegionEx)(void MEM_FAR *addr,
+	unsigned long size, unsigned flags, void MEM_FAR *security _dbgARGS);
+_shAPI(MEM_POOL, MemPoolInitNamedShared)(const char MEM_FAR *,
+                                         unsigned long size,unsigned _dbgARGS);
+_shAPI(MEM_POOL, MemPoolInitNamedSharedEx)(void MEM_FAR *addr,
+   unsigned pidCount, unsigned long MEM_FAR *pids, void MEM_FAR *security,
+   const char MEM_FAR *name, unsigned long size, unsigned flags _dbgARGS);
+_shAPI(MEM_POOL, MemPoolAttachShared)(MEM_POOL, const char MEM_FAR * _dbgARGS);
+_shAPI(MEM_BOOL, MemPoolFree)(MEM_POOL _dbgARGS);
+_shAPI(unsigned, MemPoolSetPageSize)(MEM_POOL, unsigned _dbgARGS);
+_shAPI(MEM_BOOL, MemPoolSetBlockSizeFS)(MEM_POOL, MEM_USHORT _dbgARGS);
+MEM_ENTRY1 unsigned long MEM_ENTRY MemPoolSetGrowIncrement(MEM_POOL,
+	unsigned long);
+MEM_ENTRY1 MEM_BOOL MEM_ENTRY MemPoolSetSmallBlockAllocator(MEM_POOL, MEM_SMALL_BLOCK_ALLOCATOR);
+_shAPI(MEM_BOOL, MemPoolSetSmallBlockSize)(MEM_POOL, MEM_USHORT _dbgARGS);
+_shAPI(unsigned long, MemPoolSetFloor)(MEM_POOL, unsigned long _dbgARGS);
+_shAPI(unsigned long, MemPoolSetCeiling)(MEM_POOL, unsigned long _dbgARGS);
+_shAPI(unsigned long, MemPoolPreAllocate)(MEM_POOL, unsigned long, 
+   MEM_BLOCK_TYPE _dbgARGS);
+_shAPI(unsigned long, MemPoolPreAllocateHandles)(MEM_POOL,
+   unsigned long _dbgARGS);
+_shAPI(unsigned long, MemPoolShrink)(MEM_POOL _dbgARGS);
+_shAPI(unsigned long, MemPoolSize)(MEM_POOL _dbgARGS);
+_shAPI(unsigned long, MemPoolCount)(MEM_POOL _dbgARGS);
+_shAPI(MEM_BOOL, MemPoolInfo)(MEM_POOL, void MEM_FAR *, 
+   MEM_POOL_INFO MEM_FAR* _dbgARGS);
+_shAPI(MEM_POOL_STATUS, MemPoolFirst)(MEM_POOL_INFO MEM_FAR *,
+   MEM_BOOL _dbgARGS);
+_shAPI(MEM_POOL_STATUS,MemPoolNext)(MEM_POOL_INFO MEM_FAR*,MEM_BOOL _dbgARGS);
+_shAPI(MEM_POOL_STATUS,MemPoolWalk)(MEM_POOL,MEM_POOL_ENTRY MEM_FAR*_dbgARGS);
+_shAPI(MEM_BOOL, MemPoolCheck)(MEM_POOL _dbgARGS);
+_shAPI(MEM_BOOL, MemPoolLock)(MEM_POOL _dbgARGS);
+_shAPI(MEM_BOOL, MemPoolUnlock)(MEM_POOL _dbgARGS);
+
+/* Handle-based API for moveable memory within heap. */
+_shAPI(MEM_HANDLE, MemAlloc)(MEM_POOL, unsigned, unsigned long _dbgARGS);
+_shAPI(MEM_HANDLE, MemReAlloc)(MEM_HANDLE,unsigned long,unsigned _dbgARGS);
+_shAPI(MEM_BOOL, MemFree)(MEM_HANDLE _dbgARGS);
+_shAPI(void MEM_FAR *, MemLock)(MEM_HANDLE _dbgARGS);
+_shAPI(unsigned, MemUnlock)(MEM_HANDLE _dbgARGS);
+_shAPI(void MEM_FAR *, MemFix)(MEM_HANDLE _dbgARGS);
+_shAPI(unsigned, MemUnfix)(MEM_HANDLE _dbgARGS);
+_shAPI(unsigned, MemLockCount)(MEM_HANDLE _dbgARGS);
+#ifndef MemFlags
+#define MemFlags(mem) MemLockCount(mem)
+#endif
+_shAPI(MEM_BOOL, MemIsMoveable)(MEM_HANDLE _dbgARGS);
+_shAPI(unsigned long, MemSize)(MEM_HANDLE _dbgARGS);
+_shAPI(unsigned long, MemSizeRequested)(MEM_HANDLE _dbgARGS);
+_shAPI(MEM_HANDLE, MemHandle)(void MEM_FAR * _dbgARGS);
+#ifndef MEM_REFERENCE
+   #ifdef MEM_DEBUG
+      MEM_ENTRY1 void MEM_FAR * MEM_ENTRY _dbgMemReference(MEM_HANDLE, 
+        const char MEM_FAR *, int);
+      #define MEM_REFERENCE(handle) \
+         _dbgMemReference(handle, __FILE__, __LINE__)
+   #else
+      #define MEM_REFERENCE(handle) (*(void MEM_FAR * MEM_FAR *)handle)
+   #endif
+#endif
+
+/* General Heap Allocator (returns direct pointer to memory) */
+_shAPI(void MEM_FAR*,MemAllocPtr)(MEM_POOL,unsigned long,unsigned _dbgARGS);
+_shAPI(void MEM_FAR *, MemReAllocPtr)(void MEM_FAR *, unsigned long,
+   unsigned _dbgARGS);
+_shAPI(MEM_BOOL, MemFreePtr)(void MEM_FAR * _dbgARGS);
+_shAPI(unsigned long, MemSizePtr)(void MEM_FAR * _dbgARGS);
+_shAPI(MEM_POINTER_STATUS, MemCheckPtr)(MEM_POOL, void MEM_FAR * _dbgARGS);
+
+/* Fixed-Size Allocator */
+_shAPI(void MEM_FAR *, MemAllocFS)(MEM_POOL _dbgARGS);
+_shAPI(MEM_BOOL, MemFreeFS)(void MEM_FAR * _dbgARGS);
+
+/* Error Handling Functions */
+MEM_ENTRY1 MEM_ERROR_FN MEM_ENTRY MemSetErrorHandler(MEM_ERROR_FN);
+MEM_ENTRY1 MEM_BOOL MEM_ENTRY MemDefaultErrorHandler(MEM_ERROR_INFO MEM_FAR*);
+MEM_ENTRY1 void MEM_ENTRY MemErrorUnwind(void);
+
+#ifdef MEM_WIN32
+/* patching control */
+
+#ifndef MEM_PATCHING_DEFINED
+#define MEM_PATCHING_DEFINED
+typedef enum
+{
+	MEM_PATCH_ALL = 0,
+	MEM_SKIP_PATCHING_THIS_DLL = 1,
+	MEM_DISABLE_SYSTEM_HEAP_PATCHING = 2,
+	MEM_DISABLE_ALL_PATCHING = 4|2|1,
+   MEM_PATCHING_INT_MAX = INT_MAX /* to ensure enum is full int in size */
+} MEM_PATCHING;
+#endif /* MEM_PATCHING_DEFINED */
+
+#ifdef _MSC_VER
+__declspec(dllexport)
+#endif
+MEM_PATCHING MEM_ENTRY MemSetPatching(const char ***skipDLLs);
+
+#endif /* MEM_WIN32 */
+
+/* Internal routines */
+MEM_ENTRY1 MEM_BOOL MEM_ENTRY _shi_enterCriticalSection(void);
+MEM_ENTRY1 void MEM_ENTRY _shi_leaveCriticalSection(void);
+MEM_BOOL shi_call_new_handler_msc(size_t, MEM_BOOL);
+
+
+/* Wrapper macros for debugging API */
+#ifndef _SHI_dbgMacros
+#ifdef MEM_DEBUG
+#define MemRegisterTask()        _dbgMemRegisterTask(__FILE__, __LINE__)
+#define MemUnregisterTask()      _dbgMemUnregisterTask(__FILE__, __LINE__)
+#define MemPoolInit(flags)       _dbgMemPoolInit(flags, __FILE__, __LINE__)
+#define MemPoolInitFS(bs, bc, f) _dbgMemPoolInitFS(bs,bc,f,__FILE__,__LINE__)
+#define MemPoolInitRegion(addr, sz, f) \
+     _dbgMemPoolInitRegion(addr, sz, f, __FILE__, __LINE__)
+#define MemPoolInitRegionEx(addr, sz, f) \
+     _dbgMemPoolInitRegionEx(addr, sz, f, s, __FILE__, __LINE__)
+#define MemPoolInitNamedShared(nm, sz, f) \
+     _dbgMemPoolInitNamedShared(nm, sz, f, __FILE__, __LINE__)
+#define MemPoolInitNamedSharedEx(a, c, p, sec, nm, sz, f) \
+     _dbgMemPoolInitNamedSharedEx(a, c, p, sec, nm, sz, f, __FILE__, __LINE__)
+#define MemPoolAttachShared(p, n) \
+     _dbgMemPoolAttachShared(p, n, __FILE__, __LINE__)
+#define MemPoolFree(pool)        _dbgMemPoolFree(pool, __FILE__, __LINE__)
+#define MemPoolSetPageSize(p, s) _dbgMemPoolSetPageSize(p,s,__FILE__,__LINE__)
+#define MemPoolSetBlockSizeFS(p, s) \
+     _dbgMemPoolSetBlockSizeFS(p, s, __FILE__, __LINE__)
+#define MemPoolSetSmallBlockSize(p, s) \
+     _dbgMemPoolSetSmallBlockSize(p, s, __FILE__, __LINE__)
+#define MemPoolSetFloor(p, f)    _dbgMemPoolSetFloor(p, f, __FILE__, __LINE__)
+#define MemPoolSetCeiling(p, c)  _dbgMemPoolSetCeiling(p,c,__FILE__, __LINE__)
+#define MemPoolPreAllocate(p,s,t) \
+     _dbgMemPoolPreAllocate(p,s,t,__FILE__, __LINE__)
+#define MemPoolPreAllocateHandles(p,h) \
+     _dbgMemPoolPreAllocateHandles(p,h,__FILE__, __LINE__)
+#define MemPoolShrink(p)         _dbgMemPoolShrink(p, __FILE__, __LINE__)
+#define MemPoolCheck(p)          _dbgMemPoolCheck(p, __FILE__, __LINE__)
+#define MemPoolWalk(p, e)        _dbgMemPoolWalk(p, e, __FILE__, __LINE__)
+#define MemPoolSize(p)           _dbgMemPoolSize(p, __FILE__, __LINE__)
+#define MemPoolCount(p)          _dbgMemPoolCount(p, __FILE__, __LINE__)
+#define MemPoolInfo(p,x,i)       _dbgMemPoolInfo(p,x,i, __FILE__, __LINE__)
+#define MemPoolFirst(i, b)       _dbgMemPoolFirst(i, b, __FILE__, __LINE__)
+#define MemPoolNext(i, b)        _dbgMemPoolNext(i, b, __FILE__, __LINE__)
+#define MemPoolLock(p)           _dbgMemPoolLock(p, __FILE__, __LINE__)
+#define MemPoolUnlock(p)         _dbgMemPoolUnlock(p, __FILE__, __LINE__)
+#define MemAlloc(p, f, s)        _dbgMemAlloc(p, f, s, __FILE__, __LINE__)
+#define MemReAlloc(h, s, f)      _dbgMemReAlloc(h, s, f, __FILE__, __LINE__)
+#define MemFree(h)               _dbgMemFree(h, __FILE__, __LINE__)
+#define MemLock(h)               _dbgMemLock(h, __FILE__, __LINE__)
+#define MemUnlock(h)             _dbgMemUnlock(h, __FILE__, __LINE__)
+#define MemFix(h)                _dbgMemFix(h, __FILE__, __LINE__)
+#define MemUnfix(h)              _dbgMemUnfix(h, __FILE__, __LINE__)
+#define MemSize(h)               _dbgMemSize(h, __FILE__, __LINE__)
+#define MemSizeRequested(h)      _dbgMemSizeRequested(h, __FILE__, __LINE__)
+#define MemLockCount(h)          _dbgMemLockCount(h, __FILE__, __LINE__)
+#define MemIsMoveable(h)         _dbgMemIsMoveable(h, __FILE__, __LINE__)
+#define MemHandle(p)             _dbgMemHandle(p, __FILE__, __LINE__)
+#define MemAllocPtr(p, s, f)     _dbgMemAllocPtr(p, s, f, __FILE__, __LINE__)
+#define MemReAllocPtr(p, s, f)   _dbgMemReAllocPtr(p, s, f, __FILE__,__LINE__)
+#define MemFreePtr(p)            _dbgMemFreePtr(p, __FILE__, __LINE__)
+#define MemSizePtr(p)            _dbgMemSizePtr(p, __FILE__, __LINE__)
+#define MemCheckPtr(p, x)        _dbgMemCheckPtr(p, x, __FILE__, __LINE__)
+#define MemAllocFS(p)            _dbgMemAllocFS(p, __FILE__, __LINE__)
+#define MemFreeFS(p)             _dbgMemFreeFS(p, __FILE__, __LINE__)
+
+#else /* MEM_DEBUG */
+
+/* MEM_DEBUG not defined: define dbgMemXXX as no-op macros
+ * each macro returns "success" value when MEM_DEBUG not defined
+ */
+#ifndef dbgMemBreakpoint
+#define dbgMemBreakpoint() ((void)0)
+#define dbgMemCheckAll() 1
+#define dbgMemCheckPtr(p, f, s) 1
+#define dbgMemDeferFreeing(b) 1
+#define dbgMemFormatCall(i, b, s) 0
+#define dbgMemFormatErrorInfo(i, b, s) 0
+#define dbgMemPoolDeferFreeing(p, b) 1
+#define dbgMemFreeDeferred() 1
+#define dbgMemPoolFreeDeferred(p) 1
+#define dbgMemPoolInfo(p, b) 1
+#define dbgMemPoolSetCheckFrequency(p, f) 1
+#define dbgMemPoolSetDeferQueueLen(p, b) 1
+#define dbgMemPoolSetName(p, n) 1
+#define dbgMemProtectPtr(p, f) 1
+#define dbgMemPtrInfo(p, b) 1
+#define dbgMemReallocMoves(b) 1
+#define dbgMemReportLeakage(p, c1, c2) 1
+#define dbgMemReportWrongTaskRef(b) 1
+#define dbgMemScheduleChecking(b, p, i) 1
+#define dbgMemSetCheckFrequency(f) 1
+#define dbgMemSetCheckpoint(c) 1
+#define dbgMemSetDefaultErrorOutput(x, f) 1
+#define dbgMemSetDeferQueueLen(l) 1
+#define dbgMemSetDeferSizeThreshold(s) 1
+#define dbgMemSetEntryHandler(f) 0
+#define dbgMemSetExitHandler(f) 0
+#define dbgMemSetFreeFill(c) 1
+#define dbgMemSetGuardFill(c) 1
+#define dbgMemSetGuardSize(s) 1
+#define dbgMemSetInUseFill(c) 1
+#define dbgMemSetCallstackChains(s) 1
+#define dbgMemSetStackChecking(s) 1
+#define dbgMemSetSafetyLevel(s) 1
+#define dbgMemSettingsInfo(b) 1
+#define dbgMemSuppressFreeFill(b) 1
+#define dbgMemTotalCount() 1
+#define dbgMemTotalSize() 1
+#define dbgMemWalkHeap(b) MEM_POOL_OK
+#endif /* dbgMemBreakpoint */
+
+#endif /* MEM_DEBUG */
+#endif /* _SHI_dbgMacros */
+
+#if defined(__WATCOMC__) && defined(__SW_3S)
+/* Watcom stack calling convention */
+   #pragma aux MemDefaultPool "_*";
+   #pragma aux MemDefaultPoolBlockSizeFS "_*";
+   #pragma aux MemDefaultPoolPageSize "_*";
+   #pragma aux MemDefaultPoolFlags "_*";
+   #pragma aux SmartHeap_malloc "_*";
+   #pragma aux SmartHeap_far_malloc "_*";
+   #pragma aux SmartHeap_new "_*";
+#ifdef MEM_DEBUG
+   #pragma aux dbgMemGuardSize "_*";
+   #pragma aux dbgMemGuardFill "_*";
+   #pragma aux dbgMemFreeFill "_*";
+   #pragma aux dbgMemInUseFill "_*";
+#endif
+#endif
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* !defined(_SMARTHEAP_PROT) */
diff --git a/code/smartheap/smrtheap.hpp b/code/smartheap/smrtheap.hpp
new file mode 100644
index 0000000..dfc8435
--- /dev/null
+++ b/code/smartheap/smrtheap.hpp
@@ -0,0 +1,197 @@
+// smrtheap.hpp -- SmartHeap public C++ header file
+// Professional Memory Management Library
+//
+// Copyright (C) 1991-1999 Compuware Corporation.
+// All Rights Reserved.
+//
+// No part of this source code may be copied, modified or reproduced
+// in any form without retaining the above copyright notice.
+// This source code, or source code derived from it, may not be redistributed
+// without express written permission of the copyright owner.
+//
+// COMMENTS:
+// - Include this header file to call the SmartHeap-specific versions of
+//   operators new (i.e. with placement syntax), to:
+//     o allocate from a specific memory pool;
+//     o specify allocation flags, such as zero-initialization;
+//     o resize an allocation.
+//
+// - If you include this header file, you must compile and link shnew.cpp, or
+//   link with one of the SmartHeap static operator new libraries:
+//   sh[l|d]XXXX.lib
+//
+// - Can be used in both EXEs and DLLs.
+//
+// - For 16-bit x86 platforms, use only in large or compact memory model.
+//
+// - If you do not want to use SmartHeap's global operator new but you do
+//   want to use SmartHeap's other facilities in a C++ application, then 
+//   include the smrtheap.h header file but do not include this header file,
+//   and do not link with shnew.cpp.  The two ".Xpp" files are present
+//   ONLY for the purpose of defining operator new and operator delete.
+//
+// - Use the MemDefaultPool global variable to refer to a memory pool to pass
+//   to SmartHeap functions that accept a pool as a parameter,
+//   e.g. MemPoolCount, MemPoolSize, MemPoolWalk, etc.
+//
+
+#if !defined(_SMARTHEAP_HPP)
+#define _SMARTHEAP_HPP
+
+#if defined(_MSC_VER) \
+   && (defined(M_I86LM) || defined(M_I86CM) || defined(M_I86HM)) \
+   && !defined(MEM_HUGE)
+#define MEM_HUGE 0x8000u
+#endif
+
+#ifndef __BORLANDC__
+/* Borland C++ does not treat extern "C++" correctly */
+extern "C++"
+{
+#endif /* __BORLANDC__ */
+
+#if defined(_MSC_VER) && _MSC_VER >= 900
+#pragma warning(disable : 4507)
+#endif
+
+#if defined(new)
+#if defined(MEM_DEBUG)
+#undef new
+#endif
+#endif
+
+#include <new.h>
+
+#include "smrtheap.h"
+
+#if defined(new)
+#if defined(MEM_DEBUG)
+#undef new
+#endif
+#endif
+
+#if ((defined(__BORLANDC__) && (__BORLANDC__ >= 0x450)) \
+   || (defined(__WATCOMC__) && __WATCOMC__ >= 1000) \
+   || (defined(__IBMCPP__) && __IBMCPP__ >= 250) \
+	|| defined(__hpux) \
+	|| defined(__osf__) \
+	|| (defined(__SUNPRO_CC) && __SUNPRO_CC >= 0x500) \
+	|| defined(_AIX43))
+#define SHI_ARRAY_NEW 1
+#define SHI_ARRAY_DELETE 1
+#endif
+
+#if !(defined(__SUNPRO_CC) && __SUNPRO_CC >= 0x500)
+#define SHI_NEWDEFARGS 1
+#endif
+
+void MEM_FAR * MEM_ENTRY_ANSI shi_New(unsigned long sz, unsigned flags=0, MEM_POOL pool=0);
+
+// operator new variants:
+
+
+// version of new that passes memory allocation flags
+// (e.g. MEM_ZEROINIT to zero-initialize memory)
+// call with syntax 'ptr = new (flags) <type>'
+inline void MEM_FAR *operator new(size_t sz, unsigned flags)
+   { return shi_New(sz, flags); }
+#if defined(_MSC_VER) && _MSC_VER >= 1200
+inline void MEM_FAR operator delete(void *p, unsigned)
+   { ::operator delete(p); }
+#endif // _MSC_VER
+
+// version of new that allocates from a specified memory pool with alloc flags
+// call with the syntax 'ptr = new (pool, [flags=0]) <type>'
+inline void MEM_FAR *operator new(size_t sz, MEM_POOL pool, unsigned flags
+#ifdef SHI_NEWDEFARGS
+											 =0
+#endif
+											  )
+   { return shi_New(sz, flags, pool); }
+#if defined(_MSC_VER) && _MSC_VER >= 1200
+inline void MEM_FAR operator delete(void *p, MEM_POOL, unsigned)
+   { ::operator delete(p); }
+#endif // _MSC_VER
+
+#ifdef SHI_ARRAY_NEW
+inline void MEM_FAR *operator new[](size_t sz, MEM_POOL pool, unsigned flags
+#ifdef SHI_NEWDEFARGS
+												=0
+#endif
+												 )
+   { return shi_New(sz, flags, pool); }
+#endif
+
+// version of new that changes the size of a memory block previously allocated
+// from an SmartHeap memory pool
+// call with the syntax 'ptr = new (ptr, flags) <type>'
+#if !defined(__BORLANDC__) && !defined(__HIGHC__)
+/* bug in BC++, MetaWare High C++ parsers confuse this with new(file,line) */
+inline void MEM_FAR *operator new(size_t new_sz, void MEM_FAR *lpMem,
+                                  unsigned flags)
+   { return MemReAllocPtr(lpMem, new_sz, flags); }
+#if defined(_MSC_VER) && _MSC_VER >= 1200
+inline void MEM_FAR operator delete(void *p, void MEM_FAR *, unsigned)
+   { ::operator delete(p); }
+#endif // _MSC_VER
+
+#ifdef SHI_ARRAY_NEW
+inline void MEM_FAR *operator new[](size_t new_sz, void MEM_FAR *lpMem,
+                                  unsigned flags)
+   { return MemReAllocPtr(lpMem, new_sz, flags); }
+#endif // SHI_ARRAY_NEW
+#endif
+
+
+// new_handler prototypes: note that MSC/C++ prototype differs from the
+// protosed ANSI standard prototype for set_new_handler
+#if defined(__MWERKS__) \
+	|| defined(__hpux) \
+	|| (defined(__SUNPRO_CC) && __SUNPRO_CC >= 0x500)
+
+#define MEM_CPP_THROW throw()
+#define MEM_CPP_THROW1(x) throw(x)
+//#elif defined(_MSC_VER) && _MSC_VER >= 1100 && defined(_CPPUNWIND)
+//#define MEM_CPP_THROW throw()
+#else
+#define MEM_CPP_THROW
+#define MEM_CPP_THROW1(x)
+#endif // __MWERKS__
+#ifndef _CRTIMP
+#define _CRTIMP
+#endif // _CRTIMP
+#ifdef _MSC_VER
+_CRTIMP _PNH MEM_ENTRY_ANSI _set_new_handler(_PNH);
+#if UINT_MAX == 0xFFFFu
+_PNH MEM_ENTRY_ANSI _set_fnew_handler(_PNH);
+_PNHH MEM_ENTRY_ANSI _set_hnew_handler(_PNHH);
+#endif // UINT_MAX
+#endif // _MSC_VER
+typedef void (MEM_ENTRY_ANSI * pnh)();
+_CRTIMP pnh MEM_ENTRY_ANSI set_new_handler(pnh) MEM_CPP_THROW;
+
+#ifndef DBG_FORMAL
+#define DBG_FORMAL
+#define DBG_ACTUAL
+#ifndef DEBUG_NEW
+#define DEBUG_NEW new
+#endif // DEBUG_NEW
+#define DEBUG_NEW1(x_) new(x_)
+#define DEBUG_NEW2(x_, y_) new(x_, y_)
+#define DEBUG_NEW3(x_, y_, z_) new(x_, y_, z_)
+#define DEBUG_DELETE delete
+#endif
+
+#ifdef DEFINE_NEW_MACRO
+#define new DEBUG_NEW
+#endif
+
+#if defined(_MSC_VER) && _MSC_VER >= 900
+#pragma warning(default : 4507)
+#endif
+
+#ifndef __BORLANDC__
+}
+#endif /* __BORLANDC__ */
+
+#endif /* !defined(_SMARTHEAP_HPP) */
diff --git a/code/smartheap/vssver.scc b/code/smartheap/vssver.scc
new file mode 100644
index 0000000..f8d6308
Binary files /dev/null and b/code/smartheap/vssver.scc differ
diff --git a/code/starwars.vcproj b/code/starwars.vcproj
new file mode 100644
index 0000000..23510e9
--- /dev/null
+++ b/code/starwars.vcproj
@@ -0,0 +1,6784 @@
+<?xml version="1.0" encoding = "Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="7.00"
+	Name="exe"
+	SccProjectName="&quot;$/jedi/code&quot;, ROBAAAAA"
+	SccAuxPath=""
+	SccLocalPath="."
+	SccProvider="MSSCCI:Microsoft Visual SourceSafe">
+	<Platforms>
+		<Platform
+			Name="Win32"/>
+	</Platforms>
+	<Configurations>
+		<Configuration
+			Name="Debug|Win32"
+			OutputDirectory=".\Debug"
+			IntermediateDirectory=".\Debug\exe"
+			ConfigurationType="1"
+			UseOfMFC="0"
+			ATLMinimizesCRunTimeLibraryUsage="FALSE"
+			WholeProgramOptimization="FALSE">
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				OptimizeForProcessor="2"
+				AdditionalIncludeDirectories="ff/ifc"
+				PreprocessorDefinitions="_DEBUG,_JK2EXE,WIN32,_WINDOWS,_IMMERSION,_FF"
+				MinimalRebuild="TRUE"
+				RuntimeLibrary="5"
+				BufferSecurityCheck="FALSE"
+				EnableFunctionLevelLinking="TRUE"
+				UsePrecompiledHeader="2"
+				PrecompiledHeaderThrough="..\server\exe_headers.h"
+				PrecompiledHeaderFile=".\Debug\exe/starwars.pch"
+				AssemblerListingLocation=".\Debug\exe/"
+				ObjectFile=".\Debug\exe/"
+				ProgramDataBaseFileName=".\Debug\exe/"
+				BrowseInformation="1"
+				WarningLevel="4"
+				SuppressStartupBanner="TRUE"
+				DebugInformationFormat="4"
+				CompileAs="0"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalOptions="/MACHINE:I386"
+				AdditionalDependencies="ALut.lib OpenAL32.lib winmm.lib wsock32.lib ff/ifc/ifc22.lib"
+				OutputFile=".\Debug/jasp.exe"
+				LinkIncremental="2"
+				SuppressStartupBanner="TRUE"
+				GenerateDebugInformation="TRUE"
+				ProgramDatabaseFile=".\Debug/jasp.pdb"
+				GenerateMapFile="TRUE"
+				MapFileName=".\Debug\jasp.map"
+				SubSystem="2"
+				StackReserveSize="8388608"/>
+			<Tool
+				Name="VCMIDLTool"
+				PreprocessorDefinitions="_DEBUG"
+				MkTypLibCompatible="TRUE"
+				SuppressStartupBanner="TRUE"
+				TargetEnvironment="1"
+				TypeLibraryName=".\Debug/starwars.tlb"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="VCResourceCompilerTool"
+				PreprocessorDefinitions="_DEBUG"
+				Culture="1033"
+				ResourceOutputFileName="win32\winquake.res"/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"/>
+			<Tool
+				Name="VCWebDeploymentTool"/>
+		</Configuration>
+		<Configuration
+			Name="SHDebug|Win32"
+			OutputDirectory=".\SHDebug"
+			IntermediateDirectory=".\SHDebug\exe"
+			ConfigurationType="1"
+			UseOfMFC="0"
+			ATLMinimizesCRunTimeLibraryUsage="FALSE">
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				OptimizeForProcessor="2"
+				AdditionalIncludeDirectories="ff/ifc"
+				PreprocessorDefinitions="_DEBUG,MEM_DEBUG,_JK2EXE,WIN32,_WINDOWS,_IMMERSION,_FF"
+				RuntimeLibrary="5"
+				UsePrecompiledHeader="2"
+				PrecompiledHeaderThrough="..\server\exe_headers.h"
+				PrecompiledHeaderFile=".\SHDebug\exe/starwars.pch"
+				AssemblerListingLocation=".\SHDebug\exe/"
+				ObjectFile=".\SHDebug\exe/"
+				ProgramDataBaseFileName=".\SHDebug\exe/"
+				BrowseInformation="1"
+				WarningLevel="4"
+				SuppressStartupBanner="TRUE"
+				DebugInformationFormat="4"
+				CompileAs="0"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalOptions="/MACHINE:I386"
+				AdditionalDependencies="./shdebug/exe/smrtheap.obj ALut.lib OpenAL32.lib winmm.lib wsock32.lib ff/ifc/ifc22.lib"
+				OutputFile=".\SHDebug/jk3sp.exe"
+				LinkIncremental="2"
+				SuppressStartupBanner="TRUE"
+				GenerateDebugInformation="TRUE"
+				ProgramDatabaseFile=".\SHDebug/jk3sp.pdb"
+				GenerateMapFile="TRUE"
+				MapFileName=".\SHDebug\jk3sp.map"
+				SubSystem="2"
+				StackReserveSize="8388608"/>
+			<Tool
+				Name="VCMIDLTool"
+				PreprocessorDefinitions="_DEBUG"
+				MkTypLibCompatible="TRUE"
+				SuppressStartupBanner="TRUE"
+				TargetEnvironment="1"
+				TypeLibraryName=".\SHDebug/starwars.tlb"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="VCResourceCompilerTool"
+				PreprocessorDefinitions="_DEBUG"
+				Culture="1033"
+				ResourceOutputFileName="win32\winquake.res"/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"/>
+			<Tool
+				Name="VCWebDeploymentTool"/>
+		</Configuration>
+		<Configuration
+			Name="FinalBuild|Win32"
+			OutputDirectory=".\FinalBuild"
+			IntermediateDirectory=".\FinalBuild\exe"
+			ConfigurationType="1"
+			UseOfMFC="0"
+			ATLMinimizesCRunTimeLibraryUsage="FALSE"
+			WholeProgramOptimization="TRUE">
+			<Tool
+				Name="VCCLCompilerTool"
+				GlobalOptimizations="TRUE"
+				InlineFunctionExpansion="1"
+				OptimizeForProcessor="2"
+				OptimizeForWindowsApplication="TRUE"
+				AdditionalIncludeDirectories="ff/ifc"
+				PreprocessorDefinitions="NDEBUG,FINAL_BUILD,_JK2EXE,WIN32,_WINDOWS,_IMMERSION,_FF"
+				StringPooling="TRUE"
+				RuntimeLibrary="4"
+				BufferSecurityCheck="FALSE"
+				EnableFunctionLevelLinking="FALSE"
+				UsePrecompiledHeader="2"
+				PrecompiledHeaderThrough="..\server\exe_headers.h"
+				PrecompiledHeaderFile=".\FinalBuild\exe/starwars.pch"
+				AssemblerListingLocation=".\FinalBuild\exe/"
+				ObjectFile=".\FinalBuild\exe/"
+				ProgramDataBaseFileName=".\FinalBuild\exe/"
+				WarningLevel="4"
+				SuppressStartupBanner="TRUE"
+				DebugInformationFormat="0"
+				CompileAs="0"
+				DisableSpecificWarnings="4702"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalOptions="/MACHINE:I386"
+				AdditionalDependencies="ALut.lib OpenAL32.lib winmm.lib wsock32.lib ff/ifc/ifc22.lib"
+				OutputFile=".\FinalBuild/jasp.exe"
+				LinkIncremental="1"
+				SuppressStartupBanner="TRUE"
+				GenerateDebugInformation="FALSE"
+				ProgramDatabaseFile=""
+				GenerateMapFile="TRUE"
+				SubSystem="2"
+				StackReserveSize="8388608"
+				OptimizeReferences="2"
+				EnableCOMDATFolding="2"
+				SetChecksum="TRUE"/>
+			<Tool
+				Name="VCMIDLTool"
+				PreprocessorDefinitions="NDEBUG"
+				MkTypLibCompatible="TRUE"
+				SuppressStartupBanner="TRUE"
+				TargetEnvironment="1"
+				TypeLibraryName=".\FinalBuild/starwars.tlb"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="VCResourceCompilerTool"
+				PreprocessorDefinitions="NDEBUG"
+				Culture="1033"/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"/>
+			<Tool
+				Name="VCWebDeploymentTool"/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			OutputDirectory=".\Release"
+			IntermediateDirectory=".\Release\exe"
+			ConfigurationType="1"
+			UseOfMFC="0"
+			ATLMinimizesCRunTimeLibraryUsage="FALSE">
+			<Tool
+				Name="VCCLCompilerTool"
+				GlobalOptimizations="TRUE"
+				InlineFunctionExpansion="1"
+				OptimizeForProcessor="2"
+				OptimizeForWindowsApplication="TRUE"
+				AdditionalIncludeDirectories="ff/ifc"
+				PreprocessorDefinitions="NDEBUG,_JK2EXE,WIN32,_WINDOWS,_IMMERSION,_FF"
+				StringPooling="TRUE"
+				MinimalRebuild="TRUE"
+				RuntimeLibrary="4"
+				EnableFunctionLevelLinking="TRUE"
+				UsePrecompiledHeader="2"
+				PrecompiledHeaderThrough="..\server\exe_headers.h"
+				PrecompiledHeaderFile=".\Release\exe/starwars.pch"
+				AssemblerListingLocation=".\Release\exe/"
+				ObjectFile=".\Release\exe/"
+				ProgramDataBaseFileName=".\Release\exe/"
+				BrowseInformation="1"
+				WarningLevel="4"
+				SuppressStartupBanner="TRUE"
+				DebugInformationFormat="3"
+				CompileAs="0"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalOptions="/MACHINE:I386"
+				AdditionalDependencies="ALut.lib OpenAL32.lib winmm.lib wsock32.lib ff/ifc/ifc22.lib"
+				OutputFile=".\Release/jasp.exe"
+				LinkIncremental="1"
+				SuppressStartupBanner="TRUE"
+				GenerateDebugInformation="TRUE"
+				ProgramDatabaseFile=".\Release/jasp.pdb"
+				GenerateMapFile="TRUE"
+				MapFileName=".\Release\jasp.map"
+				SubSystem="2"
+				StackReserveSize="8388608"/>
+			<Tool
+				Name="VCMIDLTool"
+				PreprocessorDefinitions="NDEBUG"
+				MkTypLibCompatible="TRUE"
+				SuppressStartupBanner="TRUE"
+				TargetEnvironment="1"
+				TypeLibraryName=".\Release/starwars.tlb"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="VCResourceCompilerTool"
+				PreprocessorDefinitions="NDEBUG"
+				Culture="1033"/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"/>
+			<Tool
+				Name="VCWebDeploymentTool"/>
+		</Configuration>
+	</Configurations>
+	<Files>
+		<Filter
+			Name="Source Files"
+			Filter="cpp;c;cxx;rc;def;r;odl;hpj;bat;for;f90">
+			<File
+				RelativePath=".\client\cl_cgame.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\client\cl_cin.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\client\cl_console.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\client\cl_input.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\client\cl_keys.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\client\cl_main.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\client\cl_mp3.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\client\cl_parse.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\client\cl_scrn.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\client\cl_ui.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\qcommon\cm_draw.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\qcommon\cm_load.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\qcommon\cm_patch.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\qcommon\cm_polylib.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\qcommon\cm_randomterrain.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\qcommon\cm_shader.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\qcommon\cm_terrain.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\qcommon\cm_terrainmap.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\qcommon\cm_test.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\qcommon\cm_trace.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\qcommon\cmd.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\qcommon\common.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\qcommon\cvar.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\server\exe_headers.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="1"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="1"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="1"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="1"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\qcommon\files_common.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\qcommon\files_pc.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\game\genericparser2.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\qcommon\md4.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\qcommon\msg.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\qcommon\net_chan.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\game\q_math.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\game\q_shared.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\client\snd_ambient.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\client\snd_dma.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\client\snd_mem.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\client\snd_mix.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\client\snd_music.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\qcommon\stringed_ingame.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\qcommon\stringed_interface.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\server\sv_ccmds.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\server\sv_client.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\server\sv_game.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\server\sv_init.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\server\sv_main.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\server\sv_savegame.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\server\sv_snapshot.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\server\sv_world.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\qcommon\unzip.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\client\vmachine.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\win32\win_input.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../server/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../server/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../server/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../server/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\win32\win_main.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../server/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../server/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../server/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../server/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\win32\win_shared.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../server/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../server/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../server/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../server/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\win32\win_snd.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../server/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../server/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../server/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../server/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\win32\win_syscon.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../server/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../server/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../server/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../server/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\win32\win_video.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../server/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../server/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../server/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../server/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\win32\win_wndproc.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../server/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../server/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../server/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../server/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\qcommon\z_memman_pc.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<Filter
+				Name="0_compiled_first"
+				Filter="">
+				<File
+					RelativePath=".\0_compiled_first\0_SH_Leak.cpp">
+					<FileConfiguration
+						Name="Debug|Win32"
+						ExcludedFromBuild="TRUE">
+						<Tool
+							Name="VCCLCompilerTool"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="SHDebug|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="FinalBuild|Win32"
+						ExcludedFromBuild="TRUE">
+						<Tool
+							Name="VCCLCompilerTool"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="Release|Win32"
+						ExcludedFromBuild="TRUE">
+						<Tool
+							Name="VCCLCompilerTool"/>
+					</FileConfiguration>
+				</File>
+			</Filter>
+			<Filter
+				Name="EAX"
+				Filter="">
+				<File
+					RelativePath=".\client\eax\EaxMan.h">
+				</File>
+				<File
+					RelativePath=".\client\eax\eax.h">
+				</File>
+			</Filter>
+			<Filter
+				Name="OpenAL"
+				Filter="">
+				<File
+					RelativePath=".\client\OpenAL\al.h">
+				</File>
+				<File
+					RelativePath=".\client\OpenAL\alc.h">
+				</File>
+				<File
+					RelativePath=".\client\OpenAL\alctypes.h">
+				</File>
+				<File
+					RelativePath=".\client\OpenAL\altypes.h">
+				</File>
+				<File
+					RelativePath=".\client\OpenAL\alu.h">
+				</File>
+				<File
+					RelativePath=".\client\OpenAL\alut.h">
+				</File>
+			</Filter>
+			<Filter
+				Name="smartheap"
+				Filter="">
+				<File
+					RelativePath=".\SHDebug\HA312W32.DLL">
+				</File>
+				<File
+					RelativePath=".\smartheap\HAW32M.LIB">
+					<FileConfiguration
+						Name="Debug|Win32"
+						ExcludedFromBuild="TRUE">
+						<Tool
+							Name="VCCustomBuildTool"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="FinalBuild|Win32"
+						ExcludedFromBuild="TRUE">
+						<Tool
+							Name="VCCustomBuildTool"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="Release|Win32"
+						ExcludedFromBuild="TRUE">
+						<Tool
+							Name="VCCustomBuildTool"/>
+					</FileConfiguration>
+				</File>
+				<File
+					RelativePath=".\smartheap\HEAPAGNT.H">
+				</File>
+				<File
+					RelativePath=".\SHDebug\SHW32.DLL">
+				</File>
+				<File
+					RelativePath=".\smartheap\SMRTHEAP.C">
+					<FileConfiguration
+						Name="Debug|Win32"
+						ExcludedFromBuild="TRUE">
+						<Tool
+							Name="VCCLCompilerTool"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="SHDebug|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="FinalBuild|Win32"
+						ExcludedFromBuild="TRUE">
+						<Tool
+							Name="VCCLCompilerTool"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="Release|Win32"
+						ExcludedFromBuild="TRUE">
+						<Tool
+							Name="VCCLCompilerTool"/>
+					</FileConfiguration>
+				</File>
+				<File
+					RelativePath=".\smartheap\SMRTHEAP.H">
+				</File>
+				<File
+					RelativePath=".\smartheap\smrtheap.hpp">
+				</File>
+			</Filter>
+		</Filter>
+		<Filter
+			Name="Header Files"
+			Filter="h;hpp;hxx;hm;inl;fi;fd">
+			<File
+				RelativePath=".\game\anims.h">
+			</File>
+			<File
+				RelativePath=".\game\b_public.h">
+			</File>
+			<File
+				RelativePath=".\game\bg_public.h">
+			</File>
+			<File
+				RelativePath=".\game\bset.h">
+			</File>
+			<File
+				RelativePath=".\game\bstate.h">
+			</File>
+			<File
+				RelativePath=".\cgame\cg_public.h">
+			</File>
+			<File
+				RelativePath=".\qcommon\chash.h">
+			</File>
+			<File
+				RelativePath=".\client\cl_mp3.h">
+			</File>
+			<File
+				RelativePath=".\client\client.h">
+			</File>
+			<File
+				RelativePath=".\client\client_ui.h">
+			</File>
+			<File
+				RelativePath=".\qcommon\cm_draw.h">
+			</File>
+			<File
+				RelativePath=".\qcommon\cm_landscape.h">
+			</File>
+			<File
+				RelativePath=".\qcommon\cm_local.h">
+			</File>
+			<File
+				RelativePath=".\qcommon\cm_patch.h">
+			</File>
+			<File
+				RelativePath=".\qcommon\cm_polylib.h">
+			</File>
+			<File
+				RelativePath=".\qcommon\cm_public.h">
+			</File>
+			<File
+				RelativePath=".\qcommon\cm_randomterrain.h">
+			</File>
+			<File
+				RelativePath=".\qcommon\cm_terrainmap.h">
+			</File>
+			<File
+				RelativePath=".\game\common_headers.h">
+			</File>
+			<File
+				RelativePath=".\server\exe_headers.h">
+			</File>
+			<File
+				RelativePath=".\client\fffx.h">
+			</File>
+			<File
+				RelativePath="qcommon\files.h">
+			</File>
+			<File
+				RelativePath=".\game\g_functions.h">
+			</File>
+			<File
+				RelativePath=".\game\g_items.h">
+			</File>
+			<File
+				RelativePath=".\game\g_local.h">
+			</File>
+			<File
+				RelativePath=".\game\g_nav.h">
+			</File>
+			<File
+				RelativePath=".\game\g_public.h">
+			</File>
+			<File
+				RelativePath=".\game\g_shared.h">
+			</File>
+			<File
+				RelativePath=".\game\genericparser2.h">
+			</File>
+			<File
+				RelativePath=".\client\keys.h">
+			</File>
+			<File
+				RelativePath="qcommon\platform.h">
+			</File>
+			<File
+				RelativePath=".\game\q_shared.h">
+			</File>
+			<File
+				RelativePath=".\qcommon\qfiles.h">
+			</File>
+			<File
+				RelativePath=".\server\server.h">
+			</File>
+			<File
+				RelativePath=".\client\snd_ambient.h">
+			</File>
+			<File
+				RelativePath=".\client\snd_local.h">
+			</File>
+			<File
+				RelativePath=".\client\snd_music.h">
+			</File>
+			<File
+				RelativePath=".\client\snd_public.h">
+			</File>
+			<File
+				RelativePath=".\qcommon\sstring.h">
+			</File>
+			<File
+				RelativePath=".\game\statindex.h">
+			</File>
+			<File
+				RelativePath=".\qcommon\stringed_ingame.h">
+			</File>
+			<File
+				RelativePath=".\qcommon\stringed_interface.h">
+			</File>
+			<File
+				RelativePath=".\qcommon\tags.h">
+			</File>
+			<File
+				RelativePath=".\game\teams.h">
+			</File>
+			<File
+				RelativePath=".\qcommon\timing.h">
+			</File>
+			<File
+				RelativePath=".\qcommon\unzip.h">
+			</File>
+			<File
+				RelativePath=".\client\vmachine.h">
+			</File>
+			<File
+				RelativePath=".\game\weapons.h">
+			</File>
+			<File
+				RelativePath=".\win32\win_local.h">
+			</File>
+		</Filter>
+		<Filter
+			Name="Resource Files"
+			Filter="ico;cur;bmp;dlg;rc2;rct;bin;cnt;rtf;gif;jpg;jpeg;jpe">
+			<File
+				RelativePath=".\ALut.lib">
+			</File>
+			<File
+				RelativePath="win32\AutoVersion.h">
+			</File>
+			<File
+				RelativePath=".\EaxMan.dll">
+			</File>
+			<File
+				RelativePath=".\OpenAL32.dll">
+			</File>
+			<File
+				RelativePath=".\OpenAL32.lib">
+			</File>
+			<File
+				RelativePath=".\win32\background.bmp">
+			</File>
+			<File
+				RelativePath=".\win32\clear.bmp">
+			</File>
+			<File
+				RelativePath=".\win32\resource.h">
+			</File>
+			<File
+				RelativePath=".\win32\starwars.ico">
+			</File>
+			<File
+				RelativePath=".\win32\winquake.rc">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCResourceCompilerTool"
+						AdditionalIncludeDirectories="win32;$(NoInherit)"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCResourceCompilerTool"
+						AdditionalIncludeDirectories="win32;$(NoInherit)"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCResourceCompilerTool"
+						AdditionalIncludeDirectories="win32;$(NoInherit)"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCResourceCompilerTool"
+						AdditionalIncludeDirectories="win32;$(NoInherit)"/>
+				</FileConfiguration>
+			</File>
+		</Filter>
+		<Filter
+			Name="MP3 Source"
+			Filter="">
+			<File
+				RelativePath=".\mp3code\cdct.c">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\mp3code\csbt.c">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\mp3code\csbtL3.c">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\mp3code\csbtb.c">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\mp3code\cup.c">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\mp3code\cupL1.c">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\mp3code\cupini.c">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\mp3code\cupl3.c">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\mp3code\cwin.c">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\mp3code\cwinb.c">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\mp3code\cwinm.c">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\mp3code\hwin.c">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\mp3code\l3dq.c">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\mp3code\l3init.c">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\mp3code\mdct.c">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\mp3code\mhead.c">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\mp3code\msis.c">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\mp3code\towave.c">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\mp3code\uph.c">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\mp3code\upsf.c">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\mp3code\wavep.c">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<Filter
+				Name="MP3 Headers"
+				Filter="">
+				<File
+					RelativePath=".\mp3code\L3.h">
+				</File>
+				<File
+					RelativePath=".\mp3code\config.h">
+				</File>
+				<File
+					RelativePath=".\mp3code\copyright.h">
+				</File>
+				<File
+					RelativePath=".\mp3code\htable.h">
+				</File>
+				<File
+					RelativePath=".\mp3code\jdw.h">
+				</File>
+				<File
+					RelativePath=".\mp3code\mhead.h">
+				</File>
+				<File
+					RelativePath=".\mp3code\mp3struct.h">
+				</File>
+				<File
+					RelativePath=".\mp3code\port.h">
+				</File>
+				<File
+					RelativePath=".\mp3code\small_header.h">
+				</File>
+				<File
+					RelativePath=".\mp3code\tableawd.h">
+				</File>
+			</Filter>
+		</Filter>
+		<Filter
+			Name="ForceFeedback Source"
+			Filter="">
+			<File
+				RelativePath=".\win32\FeelIt\fffx.cpp">
+				<FileConfiguration
+					Name="Debug|Win32"
+					ExcludedFromBuild="TRUE">
+					<Tool
+						Name="VCCLCompilerTool"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32"
+					ExcludedFromBuild="TRUE">
+					<Tool
+						Name="VCCLCompilerTool"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32"
+					ExcludedFromBuild="TRUE">
+					<Tool
+						Name="VCCLCompilerTool"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32"
+					ExcludedFromBuild="TRUE">
+					<Tool
+						Name="VCCLCompilerTool"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\win32\FeelIt\fffx_feel.cpp">
+				<FileConfiguration
+					Name="Debug|Win32"
+					ExcludedFromBuild="TRUE">
+					<Tool
+						Name="VCCLCompilerTool"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32"
+					ExcludedFromBuild="TRUE">
+					<Tool
+						Name="VCCLCompilerTool"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32"
+					ExcludedFromBuild="TRUE">
+					<Tool
+						Name="VCCLCompilerTool"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32"
+					ExcludedFromBuild="TRUE">
+					<Tool
+						Name="VCCLCompilerTool"/>
+				</FileConfiguration>
+			</File>
+			<Filter
+				Name="ForceFeedback Headers"
+				Filter="">
+				<File
+					RelativePath=".\win32\FeelIt\FEELitIFR.h">
+				</File>
+				<File
+					RelativePath=".\win32\FeelIt\FFC.h">
+				</File>
+				<File
+					RelativePath=".\win32\FeelIt\FFCErrors.h">
+				</File>
+				<File
+					RelativePath=".\win32\FeelIt\FeelBaseTypes.h">
+				</File>
+				<File
+					RelativePath=".\win32\FeelIt\FeelBox.h">
+				</File>
+				<File
+					RelativePath=".\win32\FeelIt\FeelCompoundEffect.h">
+				</File>
+				<File
+					RelativePath=".\win32\FeelIt\FeelCondition.h">
+				</File>
+				<File
+					RelativePath=".\win32\FeelIt\FeelConstant.h">
+				</File>
+				<File
+					RelativePath=".\win32\FeelIt\FeelDXDevice.h">
+				</File>
+				<File
+					RelativePath=".\win32\FeelIt\FeelDamper.h">
+				</File>
+				<File
+					RelativePath=".\win32\FeelIt\FeelDevice.h">
+				</File>
+				<File
+					RelativePath=".\win32\FeelIt\FeelEffect.h">
+				</File>
+				<File
+					RelativePath=".\win32\FeelIt\FeelEllipse.h">
+				</File>
+				<File
+					RelativePath=".\win32\FeelIt\FeelEnclosure.h">
+				</File>
+				<File
+					RelativePath=".\win32\FeelIt\FeelFriction.h">
+				</File>
+				<File
+					RelativePath=".\win32\FeelIt\FeelGrid.h">
+				</File>
+				<File
+					RelativePath=".\win32\FeelIt\FeelInertia.h">
+				</File>
+				<File
+					RelativePath=".\win32\FeelIt\FeelMouse.h">
+				</File>
+				<File
+					RelativePath=".\win32\FeelIt\FeelPeriodic.h">
+				</File>
+				<File
+					RelativePath=".\win32\FeelIt\FeelProjects.h">
+				</File>
+				<File
+					RelativePath=".\win32\FeelIt\FeelRamp.h">
+				</File>
+				<File
+					RelativePath=".\win32\FeelIt\FeelSpring.h">
+				</File>
+				<File
+					RelativePath=".\win32\FeelIt\FeelTexture.h">
+				</File>
+				<File
+					RelativePath=".\win32\FeelIt\FeelitAPI.h">
+				</File>
+				<File
+					RelativePath=".\win32\FeelIt\fffx_feel.h">
+				</File>
+			</Filter>
+			<Filter
+				Name="ForceFeedback Binaries"
+				Filter="">
+				<File
+					RelativePath=".\win32\FeelIt\FFC10.dll">
+				</File>
+				<File
+					RelativePath=".\win32\FeelIt\FFC10.lib">
+					<FileConfiguration
+						Name="Debug|Win32"
+						ExcludedFromBuild="TRUE">
+						<Tool
+							Name="VCCustomBuildTool"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="SHDebug|Win32"
+						ExcludedFromBuild="TRUE">
+						<Tool
+							Name="VCCustomBuildTool"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="FinalBuild|Win32"
+						ExcludedFromBuild="TRUE">
+						<Tool
+							Name="VCCustomBuildTool"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="Release|Win32"
+						ExcludedFromBuild="TRUE">
+						<Tool
+							Name="VCCustomBuildTool"/>
+					</FileConfiguration>
+				</File>
+				<File
+					RelativePath=".\win32\FeelIt\FFC10d.dll">
+				</File>
+				<File
+					RelativePath=".\win32\FeelIt\FFC10d.lib">
+					<FileConfiguration
+						Name="Debug|Win32"
+						ExcludedFromBuild="TRUE">
+						<Tool
+							Name="VCCustomBuildTool"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="SHDebug|Win32"
+						ExcludedFromBuild="TRUE">
+						<Tool
+							Name="VCCustomBuildTool"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="FinalBuild|Win32"
+						ExcludedFromBuild="TRUE">
+						<Tool
+							Name="VCCustomBuildTool"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="Release|Win32"
+						ExcludedFromBuild="TRUE">
+						<Tool
+							Name="VCCustomBuildTool"/>
+					</FileConfiguration>
+				</File>
+			</Filter>
+		</Filter>
+		<Filter
+			Name="Renderer Source"
+			Filter="">
+			<File
+				RelativePath=".\renderer\MatComp.c">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\renderer\tr_WorldEffects.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\renderer\tr_arioche.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\renderer\tr_backend.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\renderer\tr_bsp.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\renderer\tr_cmds.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\renderer\tr_curve.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\renderer\tr_draw.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\renderer\tr_font.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\renderer\tr_ghoul2.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\renderer\tr_image.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\renderer\tr_init.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\renderer\tr_jpeg_interface.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\renderer\tr_light.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\renderer\tr_main.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\renderer\tr_marks.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\renderer\tr_mesh.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\renderer\tr_model.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\renderer\tr_noise.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\renderer\tr_quicksprite.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\renderer\tr_scene.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\renderer\tr_shade.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\renderer\tr_shade_calc.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\renderer\tr_shader.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\renderer\tr_shadows.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\renderer\tr_sky.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\renderer\tr_stl.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\renderer\tr_surface.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\renderer\tr_surfacesprites.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\renderer\tr_terrain.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\renderer\tr_world.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\win32\win_gamma.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\win32\win_glimp.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\win32\win_qgl.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<Filter
+				Name="Renderer Headers"
+				Filter="">
+				<File
+					RelativePath=".\renderer\glext.h">
+				</File>
+				<File
+					RelativePath=".\win32\glw_win.h">
+				</File>
+				<File
+					RelativePath=".\renderer\qgl.h">
+				</File>
+				<File
+					RelativePath=".\renderer\tr_WorldEffects.h">
+				</File>
+				<File
+					RelativePath=".\renderer\tr_font.h">
+				</File>
+				<File
+					RelativePath=".\renderer\tr_jpeg_interface.h">
+				</File>
+				<File
+					RelativePath=".\renderer\tr_landscape.h">
+				</File>
+				<File
+					RelativePath=".\renderer\tr_local.h">
+				</File>
+				<File
+					RelativePath=".\renderer\tr_public.h">
+				</File>
+				<File
+					RelativePath=".\renderer\tr_quicksprite.h">
+				</File>
+				<File
+					RelativePath=".\renderer\tr_stl.h">
+				</File>
+				<File
+					RelativePath=".\renderer\tr_types.h">
+				</File>
+			</Filter>
+		</Filter>
+		<Filter
+			Name="UI Source"
+			Filter="">
+			<File
+				RelativePath=".\ui\ui_atoms.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\ui\ui_connect.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\ui\ui_main.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="ui\ui_saber.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\ui\ui_shared.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\ui\ui_syscalls.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<Filter
+				Name="UI Headers"
+				Filter="h;hpp;hxx;hm;inl">
+				<File
+					RelativePath=".\cgame\animtable.h">
+				</File>
+				<File
+					RelativePath=".\game\channels.h">
+				</File>
+				<File
+					RelativePath=".\ui\gameinfo.h">
+				</File>
+				<File
+					RelativePath=".\client\keycodes.h">
+				</File>
+				<File
+					RelativePath=".\ui\menudef.h">
+				</File>
+				<File
+					RelativePath=".\qcommon\qcommon.h">
+				</File>
+				<File
+					RelativePath=".\qcommon\stv_version.h">
+				</File>
+				<File
+					RelativePath=".\game\surfaceflags.h">
+				</File>
+				<File
+					RelativePath=".\ui\ui_local.h">
+				</File>
+				<File
+					RelativePath=".\ui\ui_public.h">
+				</File>
+				<File
+					RelativePath=".\ui\ui_shared.h">
+				</File>
+			</Filter>
+		</Filter>
+		<Filter
+			Name="JPEG"
+			Filter="">
+			<File
+				RelativePath=".\jpeg-6\jcapimin.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\jpeg-6\jccoefct.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\jpeg-6\jccolor.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\jpeg-6\jcdctmgr.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\jpeg-6\jchuff.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\jpeg-6\jchuff.h">
+			</File>
+			<File
+				RelativePath=".\jpeg-6\jcinit.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\jpeg-6\jcmainct.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\jpeg-6\jcmarker.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\jpeg-6\jcmaster.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\jpeg-6\jcomapi.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\jpeg-6\jconfig.h">
+			</File>
+			<File
+				RelativePath=".\jpeg-6\jcparam.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\jpeg-6\jcphuff.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\jpeg-6\jcprepct.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\jpeg-6\jcsample.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\jpeg-6\jctrans.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\jpeg-6\jdapimin.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\jpeg-6\jdapistd.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\jpeg-6\jdatadst.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\jpeg-6\jdatasrc.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\jpeg-6\jdcoefct.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\jpeg-6\jdcolor.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\jpeg-6\jdct.h">
+			</File>
+			<File
+				RelativePath=".\jpeg-6\jddctmgr.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\jpeg-6\jdhuff.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\jpeg-6\jdhuff.h">
+			</File>
+			<File
+				RelativePath=".\jpeg-6\jdinput.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\jpeg-6\jdmainct.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\jpeg-6\jdmarker.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\jpeg-6\jdmaster.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\jpeg-6\jdpostct.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\jpeg-6\jdsample.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\jpeg-6\jdtrans.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\jpeg-6\jerror.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\jpeg-6\jerror.h">
+			</File>
+			<File
+				RelativePath=".\jpeg-6\jfdctflt.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\jpeg-6\jidctflt.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\jpeg-6\jinclude.h">
+			</File>
+			<File
+				RelativePath=".\jpeg-6\jmemmgr.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\jpeg-6\jmemnobs.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\jpeg-6\jmemsys.h">
+			</File>
+			<File
+				RelativePath=".\jpeg-6\jmorecfg.h">
+			</File>
+			<File
+				RelativePath=".\jpeg-6\jpegint.h">
+			</File>
+			<File
+				RelativePath=".\jpeg-6\jpeglib.h">
+			</File>
+			<File
+				RelativePath=".\jpeg-6\jutils.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\jpeg-6\jversion.h">
+			</File>
+		</Filter>
+		<Filter
+			Name="FF (Immersion)"
+			Filter="">
+			<File
+				RelativePath=".\ff\cl_ff.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\ff\cl_ff.h">
+			</File>
+			<File
+				RelativePath=".\ff\common_headers.h">
+			</File>
+			<File
+				RelativePath=".\ff\ff.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\ff\ff.h">
+			</File>
+			<File
+				RelativePath=".\ff\ff_ChannelCompound.h">
+			</File>
+			<File
+				RelativePath=".\ff\ff_ChannelSet.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\ff\ff_ChannelSet.h">
+			</File>
+			<File
+				RelativePath=".\ff\ff_ConfigParser.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\ff\ff_ConfigParser.h">
+			</File>
+			<File
+				RelativePath=".\ff\ff_HandleTable.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\ff\ff_HandleTable.h">
+			</File>
+			<File
+				RelativePath=".\ff\ff_MultiCompound.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\ff\ff_MultiCompound.h">
+			</File>
+			<File
+				RelativePath=".\ff\ff_MultiEffect.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\ff\ff_MultiEffect.h">
+			</File>
+			<File
+				RelativePath=".\ff\ff_MultiSet.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\ff\ff_MultiSet.h">
+			</File>
+			<File
+				RelativePath=".\ff\ff_ffset.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\ff\ff_ffset.h">
+			</File>
+			<File
+				RelativePath=".\ff\ff_local.h">
+			</File>
+			<File
+				RelativePath=".\ff\ff_public.h">
+			</File>
+			<File
+				RelativePath=".\ff\ff_snd.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\ff\ff_snd.h">
+			</File>
+			<File
+				RelativePath=".\ff\ff_system.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\ff\ff_system.h">
+			</File>
+			<File
+				RelativePath=".\ff\ff_utils.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\ff\ff_utils.h">
+			</File>
+			<Filter
+				Name="IFC"
+				Filter="">
+				<File
+					RelativePath=".\ff\IFC\FeelitAPI.h">
+				</File>
+				<File
+					RelativePath=".\ff\IFC\IFC.h">
+				</File>
+				<File
+					RelativePath=".\ff\IFC\IFCErrors.h">
+				</File>
+				<File
+					RelativePath=".\ff\IFC\ImmBaseTypes.h">
+				</File>
+				<File
+					RelativePath=".\ff\IFC\ImmBox.h">
+				</File>
+				<File
+					RelativePath=".\ff\IFC\ImmCompoundEffect.h">
+				</File>
+				<File
+					RelativePath=".\ff\IFC\ImmCondition.h">
+				</File>
+				<File
+					RelativePath=".\ff\IFC\ImmConstant.h">
+				</File>
+				<File
+					RelativePath=".\ff\IFC\ImmDXDevice.h">
+				</File>
+				<File
+					RelativePath=".\ff\IFC\ImmDamper.h">
+				</File>
+				<File
+					RelativePath=".\ff\IFC\ImmDevice.h">
+				</File>
+				<File
+					RelativePath=".\ff\IFC\ImmDevices.h">
+				</File>
+				<File
+					RelativePath=".\ff\IFC\ImmEffect.h">
+				</File>
+				<File
+					RelativePath=".\ff\IFC\ImmEffectSuite.h">
+				</File>
+				<File
+					RelativePath=".\ff\IFC\ImmEllipse.h">
+				</File>
+				<File
+					RelativePath=".\ff\IFC\ImmEnclosure.h">
+				</File>
+				<File
+					RelativePath=".\ff\IFC\ImmFriction.h">
+				</File>
+				<File
+					RelativePath=".\ff\IFC\ImmGrid.h">
+				</File>
+				<File
+					RelativePath=".\ff\IFC\ImmIFR.h">
+				</File>
+				<File
+					RelativePath=".\ff\IFC\ImmInertia.h">
+				</File>
+				<File
+					RelativePath=".\ff\IFC\ImmMouse.h">
+				</File>
+				<File
+					RelativePath=".\ff\IFC\ImmPeriodic.h">
+				</File>
+				<File
+					RelativePath=".\ff\IFC\ImmProjects.h">
+				</File>
+				<File
+					RelativePath=".\ff\IFC\ImmRamp.h">
+				</File>
+				<File
+					RelativePath=".\ff\IFC\ImmSpring.h">
+				</File>
+				<File
+					RelativePath=".\ff\IFC\ImmTexture.h">
+				</File>
+			</Filter>
+			<Filter
+				Name="FF Binaries"
+				Filter="*.dll">
+				<File
+					RelativePath=".\IFC22.dll">
+				</File>
+				<File
+					RelativePath=".\ff\IFC\IFC22.lib">
+				</File>
+			</Filter>
+		</Filter>
+		<Filter
+			Name="RMG"
+			Filter="">
+			<File
+				RelativePath=".\RMG\RM_Area.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\RMG\RM_Area.h">
+			</File>
+			<File
+				RelativePath=".\RMG\RM_Headers.h">
+			</File>
+			<File
+				RelativePath=".\RMG\RM_Instance.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\RMG\RM_Instance.h">
+			</File>
+			<File
+				RelativePath=".\RMG\RM_InstanceFile.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\RMG\RM_InstanceFile.h">
+			</File>
+			<File
+				RelativePath=".\RMG\RM_Instance_BSP.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\RMG\RM_Instance_BSP.h">
+			</File>
+			<File
+				RelativePath=".\RMG\RM_Instance_Group.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\RMG\RM_Instance_Group.h">
+			</File>
+			<File
+				RelativePath=".\RMG\RM_Instance_Random.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\RMG\RM_Instance_Random.h">
+			</File>
+			<File
+				RelativePath=".\RMG\RM_Instance_Void.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\RMG\RM_Instance_Void.h">
+			</File>
+			<File
+				RelativePath=".\RMG\RM_Manager.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\RMG\RM_Manager.h">
+			</File>
+			<File
+				RelativePath=".\RMG\RM_Mission.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\RMG\RM_Mission.h">
+			</File>
+			<File
+				RelativePath=".\RMG\RM_Objective.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\RMG\RM_Objective.h">
+			</File>
+			<File
+				RelativePath=".\RMG\RM_Path.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\RMG\RM_Path.h">
+			</File>
+			<File
+				RelativePath=".\RMG\RM_Terrain.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\RMG\RM_Terrain.h">
+			</File>
+		</Filter>
+		<Filter
+			Name="PNG"
+			Filter="">
+			<File
+				RelativePath=".\png\png.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						PrecompiledHeaderThrough="..\server\exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\png\png.h">
+			</File>
+		</Filter>
+		<Filter
+			Name="zlib32"
+			Filter="">
+			<File
+				RelativePath="zlib32\deflate.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="zlib32\deflate.h">
+			</File>
+			<File
+				RelativePath="zlib32\inflate.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="zlib32\inflate.h">
+			</File>
+			<File
+				RelativePath="zlib32\zip.h">
+			</File>
+			<File
+				RelativePath="zlib32\zipcommon.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						PrecompiledHeaderThrough=""/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						PrecompiledHeaderThrough=""/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						PrecompiledHeaderThrough=""/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						PrecompiledHeaderThrough=""/>
+				</FileConfiguration>
+			</File>
+		</Filter>
+		<Filter
+			Name="Ghoul2"
+			Filter="">
+			<File
+				RelativePath=".\ghoul2\G2.h">
+			</File>
+			<File
+				RelativePath=".\ghoul2\G2_API.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../server/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../server/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../server/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../server/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\ghoul2\G2_bolts.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../server/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../server/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../server/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../server/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\ghoul2\G2_bones.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../server/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../server/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../server/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../server/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\ghoul2\G2_misc.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../server/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../server/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../server/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../server/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\ghoul2\G2_surfaces.cpp">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../server/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="SHDebug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../server/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../server/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../server/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\qcommon\MiniHeap.h">
+			</File>
+			<File
+				RelativePath=".\ghoul2\ghoul2_gore.h">
+			</File>
+			<File
+				RelativePath=".\game\ghoul2_shared.h">
+			</File>
+			<File
+				RelativePath=".\renderer\matcomp.h">
+			</File>
+			<File
+				RelativePath=".\renderer\mdx_format.h">
+			</File>
+		</Filter>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>
diff --git a/code/starwars.vcproj.vspscc b/code/starwars.vcproj.vspscc
new file mode 100644
index 0000000..794f014
--- /dev/null
+++ b/code/starwars.vcproj.vspscc
@@ -0,0 +1,10 @@
+""
+{
+"FILE_VERSION" = "9237"
+"ENLISTMENT_CHOICE" = "NEVER"
+"PROJECT_FILE_RELATIVE_PATH" = ""
+"NUMBER_OF_EXCLUDED_FILES" = "0"
+"ORIGINAL_PROJECT_FILE_PATH" = ""
+"NUMBER_OF_NESTED_PROJECTS" = "0"
+"SOURCE_CONTROL_SETTINGS_PROVIDER" = "PROJECT"
+}
diff --git a/code/tonet.bat b/code/tonet.bat
new file mode 100644
index 0000000..1add0c0
--- /dev/null
+++ b/code/tonet.bat
@@ -0,0 +1,10 @@
+del /q release\jk3sp.exe
+del /q release\jk3sp.map
+del /q release\jk3gamex86.dll
+del /q release\jk3gamex86.map
+
+call vu.bat
+
+xcopy/d/y release\jasp.exe w:\game
+xcopy/d/y release\jagamex86.dll w:\game
+xcopy/d/y release\*.map w:\game
\ No newline at end of file
diff --git a/code/tosend.bat b/code/tosend.bat
new file mode 100644
index 0000000..bf55e62
--- /dev/null
+++ b/code/tosend.bat
@@ -0,0 +1,6 @@
+xcopy/y release\jasp.exe c:\send\game\jasp_nocd.exe
+xcopy/y finalbuild\jasp.exe c:\send\game
+xcopy/y finalbuild\jagamex86.dll c:\send\game
+xcopy/y finalbuild\*.map c:\send\game
+
+rd c:\send\game\base\saves
diff --git a/code/ui/gameinfo.cpp b/code/ui/gameinfo.cpp
new file mode 100644
index 0000000..a89342a
--- /dev/null
+++ b/code/ui/gameinfo.cpp
@@ -0,0 +1,35 @@
+//
+// gameinfo.c
+//
+
+// *** This file is used by both the game and the user interface ***
+
+
+// ... and for that reason is excluded from PCH usage for the moment =Ste.
+
+
+#include "gameinfo.h"
+#include "..\game\weapons.h"
+
+
+gameinfo_import_t	gi;
+
+weaponData_t weaponData[WP_NUM_WEAPONS];
+ammoData_t ammoData[AMMO_MAX];
+
+extern void WP_LoadWeaponParms (void);
+
+//
+// Initialization - Read in files and parse into infos
+//
+
+/*
+===============
+GI_Init
+===============
+*/
+void GI_Init( gameinfo_import_t *import ) {
+	gi = *import;
+
+	WP_LoadWeaponParms ();
+}
diff --git a/code/ui/gameinfo.h b/code/ui/gameinfo.h
new file mode 100644
index 0000000..cd35d2a
--- /dev/null
+++ b/code/ui/gameinfo.h
@@ -0,0 +1,24 @@
+#ifndef __GAMEINFO_H__
+#define __GAMEINFO_H__
+
+
+#include "../game/q_shared.h"
+#include <stdio.h>
+
+
+typedef struct {
+	int			(*FS_FOpenFile)( const char *qpath, fileHandle_t *file, fsMode_t mode );
+	int 		(*FS_Read)( void *buffer, int len, fileHandle_t f );
+	void		(*FS_FCloseFile)( fileHandle_t f );
+	void		(*Cvar_Set)( const char *name, const char *value );
+	void		(*Cvar_VariableStringBuffer)( const char *var_name, char *buffer, int bufsize );
+	void		(*Cvar_Create)( const char *var_name, const char *var_value, int flags );
+	int			(*FS_ReadFile)( const char *name, void **buf );
+	void		(*FS_FreeFile)( void *buf );
+	void		(*Printf)( const char *fmt, ... );
+} gameinfo_import_t;
+
+
+void GI_Init( gameinfo_import_t *import );
+
+#endif
diff --git a/code/ui/menudef.h b/code/ui/menudef.h
new file mode 100644
index 0000000..292c0d7
--- /dev/null
+++ b/code/ui/menudef.h
@@ -0,0 +1,138 @@
+
+#define ITEM_TYPE_TEXT				0		// simple text
+#define ITEM_TYPE_BUTTON			1		// button, basically text with a border 
+#define ITEM_TYPE_RADIOBUTTON		2		// toggle button, may be grouped 
+#define ITEM_TYPE_CHECKBOX			3		// check box
+#define ITEM_TYPE_EDITFIELD			4		// editable text, associated with a cvar
+#define ITEM_TYPE_COMBO				5		// drop down list
+#define ITEM_TYPE_LISTBOX			6		// scrollable list  
+#define ITEM_TYPE_MODEL				7		// model
+#define ITEM_TYPE_OWNERDRAW			8		// owner draw, name specs what it is
+#define ITEM_TYPE_NUMERICFIELD		9		// editable text, associated with a cvar
+#define ITEM_TYPE_SLIDER			10		// mouse speed, volume, etc.
+#define ITEM_TYPE_YESNO				11		// yes no cvar setting
+#define ITEM_TYPE_MULTI				12		// multiple list setting, enumerated
+#define ITEM_TYPE_BIND				13		// multiple list setting, enumerated
+#define ITEM_TYPE_TEXTSCROLL		14		// scrolling text
+
+
+#define ITEM_ALIGN_LEFT 0                 // left alignment
+#define ITEM_ALIGN_CENTER 1               // center alignment
+#define ITEM_ALIGN_RIGHT 2                // right alignment
+
+#define ITEM_TEXTSTYLE_NORMAL 0           // normal text
+#define ITEM_TEXTSTYLE_BLINK 1            // fast blinking
+#define ITEM_TEXTSTYLE_PULSE 2            // slow pulsing
+#define ITEM_TEXTSTYLE_SHADOWED 3         // drop shadow ( need a color for this )
+#define ITEM_TEXTSTYLE_OUTLINED 4         // drop shadow ( need a color for this )
+#define ITEM_TEXTSTYLE_OUTLINESHADOWED 5  // drop shadow ( need a color for this )
+#define ITEM_TEXTSTYLE_SHADOWEDMORE 6         // drop shadow ( need a color for this )
+                          
+#define WINDOW_BORDER_NONE 0              // no border
+#define WINDOW_BORDER_FULL 1              // full border based on border color ( single pixel )
+#define WINDOW_BORDER_HORZ 2              // horizontal borders only
+#define WINDOW_BORDER_VERT 3              // vertical borders only 
+#define WINDOW_BORDER_KCGRADIENT 4        // horizontal border using the gradient bars
+  
+#define WINDOW_STYLE_EMPTY 0              // no background
+#define WINDOW_STYLE_FILLED 1             // filled with background color
+#define WINDOW_STYLE_GRADIENT 2           // gradient bar based on background color 
+#define WINDOW_STYLE_SHADER   3           // gradient bar based on background color 
+#define WINDOW_STYLE_TEAMCOLOR 4          // team color
+#define WINDOW_STYLE_CINEMATIC 5          // cinematic
+
+#define MENU_TRUE 1                       // uh.. true
+#define MENU_FALSE 0                      // and false
+
+#define HUD_VERTICAL				0x00
+#define HUD_HORIZONTAL				0x01
+
+// list box element types
+#define LISTBOX_TEXT  0x00
+#define LISTBOX_IMAGE 0x01
+
+// list feeders
+#define FEEDER_SAVEGAMES					0x00			// save games
+#define FEEDER_MAPS							0x01			// text maps based on game type
+#define FEEDER_SERVERS						0x02			// servers
+#define FEEDER_CLANS						0x03			// clan names
+#define FEEDER_ALLMAPS						0x04			// all maps available, in graphic format
+#define FEEDER_REDTEAM_LIST					0x05			// red team members
+#define FEEDER_BLUETEAM_LIST				0x06			// blue team members
+#define FEEDER_PLAYER_LIST					0x07			// players
+#define FEEDER_TEAM_LIST					0x08			// team members for team voting
+#define FEEDER_MODS							0x09			// 
+#define FEEDER_DEMOS 						0x0a			// 
+#define FEEDER_SCOREBOARD					0x0b			// 
+#define FEEDER_Q3HEADS		 				0x0c			// model heads
+#define FEEDER_SERVERSTATUS					0x0d			// server status
+#define FEEDER_FINDPLAYER					0x0e			// find player
+#define FEEDER_CINEMATICS					0x0f			// cinematics
+#define FEEDER_PLAYER_SPECIES				0x10			// models/player/*w
+#define FEEDER_PLAYER_SKIN_HEAD				0x11			// head*.skin files in species folder
+#define FEEDER_PLAYER_SKIN_TORSO			0x12			// torso*.skin files in species folder
+#define FEEDER_PLAYER_SKIN_LEGS				0x13			// lower*.skin files in species folder
+#define FEEDER_COLORCHOICES					0x14			// special hack to feed text/actions from playerchoice.txt in species folder
+#define FEEDER_MOVES						0x15			// moves for the data pad moves screen
+#define FEEDER_MOVES_TITLES					0x16			// move titles for the data pad moves screen
+#define FEEDER_LANGUAGES					0x17			// the list of languages 
+
+
+#define UI_VERSION				200
+#define UI_HANDICAP				200
+#define UI_EFFECTS				201
+#define UI_PLAYERMODEL			202
+#define UI_DATAPAD_MISSION		203
+#define UI_DATAPAD_WEAPONS		204
+#define UI_DATAPAD_INVENTORY	205
+#define UI_DATAPAD_FORCEPOWERS	206
+#define UI_SKILL				207
+#define UI_BLUETEAMNAME			208
+#define UI_REDTEAMNAME			209
+#define UI_BLUETEAM1			210
+#define UI_BLUETEAM2			211
+#define UI_BLUETEAM3			212
+#define UI_BLUETEAM4			213
+#define UI_BLUETEAM5			214
+#define UI_REDTEAM1				215
+#define UI_REDTEAM2				216
+#define UI_REDTEAM3				217
+#define UI_REDTEAM4				218
+#define UI_REDTEAM5				219
+#define UI_NETSOURCE			220
+#define UI_NETMAPPREVIEW		221
+#define UI_NETFILTER			222
+#define UI_TIER					223
+#define UI_OPPONENTMODEL		224
+#define UI_TIERMAP1				225
+#define UI_TIERMAP2				226
+#define UI_TIERMAP3				227
+#define UI_PLAYERLOGO			228
+#define UI_OPPONENTLOGO			229
+#define UI_PLAYERLOGO_METAL		230
+#define UI_OPPONENTLOGO_METAL	231
+#define UI_PLAYERLOGO_NAME		232
+#define UI_OPPONENTLOGO_NAME	233
+#define UI_TIER_MAPNAME			234
+#define UI_TIER_GAMETYPE		235
+#define UI_ALLMAPS_SELECTION	236
+#define UI_OPPONENT_NAME		237
+#define UI_VOTE_KICK			238
+#define UI_BOTNAME				239
+#define UI_BOTSKILL				240
+#define UI_REDBLUE				241
+#define UI_CROSSHAIR			242
+#define UI_SELECTEDPLAYER		243
+#define UI_MAPCINEMATIC			244
+#define UI_NETGAMETYPE			245
+#define UI_NETMAPCINEMATIC		246
+#define UI_SERVERREFRESHDATE	247
+#define UI_SERVERMOTD			248
+#define UI_GLINFO				249
+#define UI_KEYBINDSTATUS		250
+#define UI_CLANCINEMATIC		251
+#define UI_MAP_TIMETOBEAT		252
+#define UI_JOINGAMETYPE			253
+#define UI_PREVIEWCINEMATIC		254
+#define UI_STARTMAPCINEMATIC	255
+#define UI_MAPS_SELECTION		256
diff --git a/code/ui/ui.def b/code/ui/ui.def
new file mode 100644
index 0000000..b82b7f8
--- /dev/null
+++ b/code/ui/ui.def
@@ -0,0 +1,4 @@
+EXPORTS
+	GetUIAPI
+	vmMain
+	dllEntry
\ No newline at end of file
diff --git a/code/ui/ui_atoms.cpp b/code/ui/ui_atoms.cpp
new file mode 100644
index 0000000..5a5d508
--- /dev/null
+++ b/code/ui/ui_atoms.cpp
@@ -0,0 +1,480 @@
+/**********************************************************************
+	UI_ATOMS.C
+
+	User interface building blocks and support functions.
+**********************************************************************/
+
+// leave this at the top of all UI_xxxx files for PCH reasons...
+//
+
+#include "../server/exe_headers.h"
+
+#include "ui_local.h"
+#include "gameinfo.h"
+#include "../qcommon/stv_version.h"
+
+uiimport_t	ui;
+uiStatic_t	uis;
+
+//externs
+static void UI_LoadMenu_f( void );
+static void UI_SaveMenu_f( void );
+
+//locals
+
+
+/*
+=================
+UI_ForceMenuOff
+=================
+*/
+void UI_ForceMenuOff (void)
+{
+	ui.Key_SetCatcher( ui.Key_GetCatcher() & ~KEYCATCH_UI );
+	ui.Key_ClearStates();
+	ui.Cvar_Set( "cl_paused", "0" );
+}
+
+
+/*
+=================
+UI_SetActiveMenu - 
+	this should be the ONLY way the menu system is brought up
+ 
+=================
+*/
+void UI_SetActiveMenu( const char* menuname,const char *menuID ) 
+{
+	// this should be the ONLY way the menu system is brought up (besides the UI_ConsoleCommand below)
+
+	if (cls.state != CA_DISCONNECTED && !ui.SG_GameAllowedToSaveHere(qtrue))	//don't check full sytem, only if incamera
+	{
+		return;
+	}
+
+	if ( !menuname ) {
+		UI_ForceMenuOff();
+		return;
+	}
+
+	//make sure force-speed and slowmodeath doesn't slow down menus - NOTE: they should reset the timescale when the game un-pauses
+	Cvar_SetValue( "timescale", 1.0f );
+
+	UI_Cursor_Show(qtrue);
+
+	// enusure minumum menu data is cached
+	Menu_Cache();
+
+	if ( Q_stricmp (menuname, "mainMenu") == 0 ) 
+	{
+		UI_MainMenu();
+		return;
+	}
+
+	if ( Q_stricmp (menuname, "ingame") == 0 ) 
+	{
+		ui.Cvar_Set( "cl_paused", "1" );
+		UI_InGameMenu(menuID);
+		return;
+	}
+
+	if ( Q_stricmp (menuname, "datapad") == 0 ) 
+	{
+		ui.Cvar_Set( "cl_paused", "1" );
+		UI_DataPadMenu();
+		return;
+	}
+
+	if ( Q_stricmp (menuname, "missionfailed_menu") == 0 ) 
+	{
+		Menus_CloseAll();
+		Menus_ActivateByName("missionfailed_menu");
+		ui.Key_SetCatcher( KEYCATCH_UI );
+		return;
+	}
+//JLF SPLASHMAIN MPSKIPPED
+#ifdef _XBOX
+	{
+		Menus_CloseAll();
+		if (Menus_ActivateByName(menuname))
+			ui.Key_SetCatcher( KEYCATCH_UI );
+		else
+			UI_MainMenu();
+	}
+#endif
+
+}
+
+
+/*
+=================
+UI_Argv
+=================
+*/
+static char *UI_Argv( int arg ) 
+{
+	static char	buffer[MAX_STRING_CHARS];
+
+	ui.Argv( arg, buffer, sizeof( buffer ) );
+
+	return buffer;
+}
+
+
+/*
+=================
+UI_Cvar_VariableString
+=================
+*/
+char *UI_Cvar_VariableString( const char *var_name ) 
+{
+	static char	buffer[MAX_STRING_CHARS];
+
+	ui.Cvar_VariableStringBuffer( var_name, buffer, sizeof( buffer ) );
+
+	return buffer;
+}
+
+/*
+=================
+UI_Cache
+=================
+*/
+static void UI_Cache_f( void ) 
+{
+ int index;
+	Menu_Cache();
+
+extern const char *lukeForceStatusSounds[];
+extern const char *kyleForceStatusSounds[];
+
+	for (index = 0; index < 5; index++)
+	{
+		DC->registerSound(lukeForceStatusSounds[index], qfalse);
+		DC->registerSound(kyleForceStatusSounds[index], qfalse);
+	}
+	for (index = 1; index <= 18; index++)
+	{
+		DC->registerSound(va("sound/chars/storyinfo/%d",index), qfalse);
+	}
+	trap_S_RegisterSound("sound/chars/kyle/04kyk001.mp3", qfalse);
+	trap_S_RegisterSound("sound/chars/kyle/05kyk001.mp3", qfalse);
+	trap_S_RegisterSound("sound/chars/kyle/07kyk001.mp3", qfalse);
+	trap_S_RegisterSound("sound/chars/kyle/14kyk001.mp3", qfalse);
+	trap_S_RegisterSound("sound/chars/kyle/21kyk001.mp3", qfalse);
+	trap_S_RegisterSound("sound/chars/kyle/24kyk001.mp3", qfalse);
+	trap_S_RegisterSound("sound/chars/kyle/25kyk001.mp3", qfalse);
+
+	trap_S_RegisterSound("sound/chars/luke/06luk001.mp3", qfalse);
+	trap_S_RegisterSound("sound/chars/luke/08luk001.mp3", qfalse);
+	trap_S_RegisterSound("sound/chars/luke/22luk001.mp3", qfalse);
+	trap_S_RegisterSound("sound/chars/luke/23luk001.mp3", qfalse);
+	trap_S_RegisterSound("sound/chars/protocol/12pro001.mp3", qfalse);
+	trap_S_RegisterSound("sound/chars/protocol/15pro001.mp3", qfalse);
+	trap_S_RegisterSound("sound/chars/protocol/16pro001.mp3", qfalse);
+	trap_S_RegisterSound("sound/chars/wedge/13wea001.mp3", qfalse);
+
+
+	Menus_ActivateByName("ingameMissionSelect1");
+	Menus_ActivateByName("ingameMissionSelect2");
+	Menus_ActivateByName("ingameMissionSelect3");
+}
+
+
+/*
+=================
+UI_ConsoleCommand
+=================
+*/
+void UI_Load(void);	//in UI_main.cpp
+
+qboolean UI_ConsoleCommand( void ) 
+{
+	char	*cmd;
+
+	if (!ui.SG_GameAllowedToSaveHere(qtrue))	//only check if incamera
+	{
+		return qfalse;
+	}
+
+	cmd = UI_Argv( 0 );
+
+	// ensure minimum menu data is available
+	Menu_Cache();
+
+	if ( Q_stricmp (cmd, "ui_cache") == 0 ) 
+	{
+		UI_Cache_f();
+		return qtrue;
+	}
+
+	if ( Q_stricmp (cmd, "levelselect") == 0 ) 
+	{
+		UI_LoadMenu_f();
+		return qtrue;
+	}
+	
+	if ( Q_stricmp (cmd, "ui_teamOrders") == 0 ) 
+	{
+		UI_SaveMenu_f();
+		return qtrue;
+	}
+
+	if ( Q_stricmp (cmd, "ui_report") == 0 ) 
+	{
+		UI_Report();
+		return qtrue;
+	}
+	
+	if ( Q_stricmp (cmd, "ui_load") == 0 ) 
+	{
+		UI_Load();
+		return qtrue;
+	}
+
+	return qfalse;
+}
+
+
+/*
+=================
+UI_Init
+=================
+*/
+void UI_Init( int apiVersion, uiimport_t *uiimport, qboolean inGameLoad ) 
+{
+	ui = *uiimport;
+
+	if ( apiVersion != UI_API_VERSION ) {
+		ui.Error( ERR_FATAL, "Bad UI_API_VERSION: expected %i, got %i\n", UI_API_VERSION, apiVersion );
+	}
+
+	// get static data (glconfig, media)
+	ui.GetGlconfig( &uis.glconfig );
+
+	uis.scaley = uis.glconfig.vidHeight * (1.0/480.0);
+	uis.scalex = uis.glconfig.vidWidth * (1.0/640.0);
+
+	Menu_Cache( );
+
+	ui.Cvar_Create( "cg_drawCrosshair", "1", CVAR_ARCHIVE );
+	ui.Cvar_Create( "cg_marks", "1", CVAR_ARCHIVE );
+	ui.Cvar_Create ("s_language",			"english",	CVAR_ARCHIVE | CVAR_NORESTART);
+	ui.Cvar_Create( "g_char_model",			"jedi_tf",	CVAR_ARCHIVE|CVAR_SAVEGAME|CVAR_NORESTART );
+	ui.Cvar_Create( "g_char_skin_head",		"head_a1",	CVAR_ARCHIVE|CVAR_SAVEGAME|CVAR_NORESTART );
+	ui.Cvar_Create( "g_char_skin_torso",	"torso_a1",	CVAR_ARCHIVE|CVAR_SAVEGAME|CVAR_NORESTART );
+	ui.Cvar_Create( "g_char_skin_legs",		"lower_a1",	CVAR_ARCHIVE|CVAR_SAVEGAME|CVAR_NORESTART );
+	ui.Cvar_Create( "g_char_color_red",		"255",		CVAR_ARCHIVE|CVAR_SAVEGAME|CVAR_NORESTART );
+	ui.Cvar_Create( "g_char_color_green",	"255",		CVAR_ARCHIVE|CVAR_SAVEGAME|CVAR_NORESTART );
+	ui.Cvar_Create( "g_char_color_blue",	"255",		CVAR_ARCHIVE|CVAR_SAVEGAME|CVAR_NORESTART );
+	ui.Cvar_Create( "g_saber_type",			"single",	CVAR_ARCHIVE|CVAR_SAVEGAME|CVAR_NORESTART );
+	ui.Cvar_Create( "g_saber",				"single_1",	CVAR_ARCHIVE|CVAR_SAVEGAME|CVAR_NORESTART );
+	ui.Cvar_Create( "g_saber2",				"",			CVAR_ARCHIVE|CVAR_SAVEGAME|CVAR_NORESTART );
+	ui.Cvar_Create( "g_saber_color",		"yellow",	CVAR_ARCHIVE|CVAR_SAVEGAME|CVAR_NORESTART );
+	ui.Cvar_Create( "g_saber2_color",		"yellow",	CVAR_ARCHIVE|CVAR_SAVEGAME|CVAR_NORESTART );
+	
+	ui.Cvar_Create( "ui_forcepower_inc",	"0",		CVAR_ROM|CVAR_SAVEGAME|CVAR_NORESTART);
+	ui.Cvar_Create( "tier_storyinfo",		"0",		CVAR_ROM|CVAR_SAVEGAME|CVAR_NORESTART);
+	ui.Cvar_Create( "tiers_complete",		"",			CVAR_ROM|CVAR_SAVEGAME|CVAR_NORESTART);
+	ui.Cvar_Create( "ui_prisonerobj_currtotal", "0",	CVAR_ROM|CVAR_SAVEGAME|CVAR_NORESTART);
+	ui.Cvar_Create( "ui_prisonerobj_mintotal",  "0",	CVAR_ROM|CVAR_SAVEGAME|CVAR_NORESTART);
+
+	ui.Cvar_Create( "g_dismemberment", "3", CVAR_ARCHIVE );//0 = none, 1 = arms and hands, 2 = legs, 3 = waist and head, 4 = mega dismemberment
+	ui.Cvar_Create( "cg_gunAutoFirst", "1", CVAR_ARCHIVE );
+	ui.Cvar_Create( "cg_crosshairIdentifyTarget", "1", CVAR_ARCHIVE );
+	ui.Cvar_Create( "g_subtitles", "0", CVAR_ARCHIVE );
+	ui.Cvar_Create( "cg_marks", "1", CVAR_ARCHIVE );
+	ui.Cvar_Create( "d_slowmodeath", "3", CVAR_ARCHIVE );
+	ui.Cvar_Create( "cg_shadows", "1", CVAR_ARCHIVE );
+
+	ui.Cvar_Create( "cg_runpitch", "0.002", CVAR_ARCHIVE );
+	ui.Cvar_Create( "cg_runroll", "0.005", CVAR_ARCHIVE );
+	ui.Cvar_Create( "cg_bobup", "0.005", CVAR_ARCHIVE );
+	ui.Cvar_Create( "cg_bobpitch", "0.002", CVAR_ARCHIVE );
+	ui.Cvar_Create( "cg_bobroll", "0.002", CVAR_ARCHIVE );
+
+	ui.Cvar_Create( "ui_disableWeaponSway", "0", CVAR_ARCHIVE );
+
+	
+
+	_UI_Init(inGameLoad);
+}
+
+// these are only here so the functions in q_shared.c can link
+
+#ifndef UI_HARD_LINKED
+
+/*
+================
+Com_Error
+=================
+*/
+/*
+void Com_Error( int level, const char *error, ... ) 
+{
+	va_list		argptr;
+	char		text[1024];
+
+	va_start (argptr, error);
+	vsprintf (text, error, argptr);
+	va_end (argptr);
+
+	ui.Error( level, "%s", text);
+}
+*/
+/*
+================
+Com_Printf
+=================
+*/
+/*
+void Com_Printf( const char *msg, ... ) 
+{
+	va_list		argptr;
+	char		text[1024];
+
+	va_start (argptr, msg);
+	vsprintf (text, msg, argptr);
+	va_end (argptr);
+
+	ui.Printf( "%s", text);
+}
+*/
+#endif
+
+
+/*
+================
+UI_DrawNamedPic
+=================
+*/
+void UI_DrawNamedPic( float x, float y, float width, float height, const char *picname ) 
+{
+	qhandle_t	hShader;
+
+	hShader = ui.R_RegisterShaderNoMip( picname );
+	ui.R_DrawStretchPic( x, y, width, height, 0, 0, 1, 1, hShader );
+}
+
+
+/*
+================
+UI_DrawHandlePic
+=================
+*/
+void UI_DrawHandlePic( float x, float y, float w, float h, qhandle_t hShader ) 
+{
+	float	s0;
+	float	s1;
+	float	t0;
+	float	t1;
+
+	if( w < 0 ) {	// flip about horizontal
+		w  = -w;
+		s0 = 1;
+		s1 = 0;
+	}
+	else {
+		s0 = 0;
+		s1 = 1;
+	}
+
+	if( h < 0 ) {	// flip about vertical
+		h  = -h;
+		t0 = 1;
+		t1 = 0;
+	}
+	else {
+		t0 = 0;
+		t1 = 1;
+	}
+
+	ui.R_DrawStretchPic( x, y, w, h, s0, t0, s1, t1, hShader );
+}
+
+/*
+================
+UI_FillRect
+
+Coordinates are 640*480 virtual values
+=================
+*/
+void UI_FillRect( float x, float y, float width, float height, const float *color ) 
+{
+	ui.R_SetColor( color );
+
+	ui.R_DrawStretchPic( x, y, width, height, 0, 0, 0, 0, uis.whiteShader );
+
+	ui.R_SetColor( NULL );
+}
+
+/*
+=================
+UI_UpdateScreen
+=================
+*/
+void UI_UpdateScreen( void ) 
+{
+	ui.UpdateScreen();
+}
+
+
+/*
+===============
+UI_LoadMenu_f
+===============
+*/
+static void UI_LoadMenu_f( void ) 
+{
+	trap_Key_SetCatcher( KEYCATCH_UI );
+	Menus_ActivateByName("ingameloadMenu");
+}
+
+/*
+===============
+UI_SaveMenu_f
+===============
+*/
+static void UI_SaveMenu_f( void ) 
+{
+//	ui.PrecacheScreenshot();
+
+	trap_Key_SetCatcher( KEYCATCH_UI );
+	Menus_ActivateByName("ingamesaveMenu");
+}
+
+
+//--------------------------------------------
+
+/*
+=================
+UI_SetColor
+=================
+*/
+void UI_SetColor( const float *rgba ) 
+{
+	trap_R_SetColor( rgba );
+}
+
+/*int registeredFontCount = 0;
+#define MAX_FONTS 6
+static fontInfo_t registeredFont[MAX_FONTS];
+*/
+
+/*
+=================
+UI_RegisterFont
+=================
+*/
+
+int UI_RegisterFont(const char *fontName) 
+{
+	int iFontIndex = ui.R_RegisterFont(fontName);
+	if (iFontIndex == 0)
+	{
+		iFontIndex = ui.R_RegisterFont("ergoec");	// fall back
+	}
+
+	return iFontIndex;
+}
+
diff --git a/code/ui/ui_connect.cpp b/code/ui/ui_connect.cpp
new file mode 100644
index 0000000..3485d15
--- /dev/null
+++ b/code/ui/ui_connect.cpp
@@ -0,0 +1,95 @@
+// leave this at the top of all UI_xxxx files for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+#include "ui_local.h"
+
+/*
+===============================================================================
+
+CONNECTION SCREEN
+
+===============================================================================
+*/
+
+char		connectionDialogString[1024];
+char		connectionMessageString[1024];
+
+
+/*
+========================
+UI_DrawConnect
+
+========================
+*/
+
+void UI_DrawConnect( const char *servername, const char *updateInfoString ) {
+#if 0
+	// if connecting to a local host, don't draw anything before the
+	// gamestate message.  This allows cinematics to start seamlessly
+	if ( connState < CA_LOADING && !strcmp( cls.servername, "localhost" ) ) {
+		UI_SetColor( g_color_table[0] );
+		re.DrawFill (0, 0, re.scrWidth, re.scrHeight);
+		UI_SetColor( NULL );
+		return;
+	}
+#endif
+
+//	qboolean qValid;
+//	byte *levelPic = ui.SCR_GetScreenshot(&qValid);
+	// draw the dialog background
+//	if (!qValid) 
+	{
+		UI_DrawHandlePic(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, uis.menuBackShader );
+	} 
+//	else {
+//		UI_DrawThumbNail(0,SCREEN_HEIGHT, SCREEN_WIDTH, -SCREEN_HEIGHT, levelPic );
+//	}
+}
+
+
+/*
+========================
+UI_UpdateConnectionString
+
+========================
+*/
+void UI_UpdateConnectionString( char *string ) {
+	Q_strncpyz( connectionDialogString, string, sizeof( connectionDialogString )  );
+	UI_UpdateScreen();
+}
+
+/*
+========================
+UI_UpdateConnectionMessageString
+
+========================
+*/
+void UI_UpdateConnectionMessageString( char *string ) {
+	char		*s;
+
+	Q_strncpyz( connectionMessageString, string, sizeof( connectionMessageString ) );
+
+	// strip \n
+	s = strstr( connectionMessageString, "\n" );
+	if ( s ) {
+		*s = 0;
+	}
+	UI_UpdateScreen();
+}
+
+/*
+===================
+UI_KeyConnect
+===================
+*/
+void UI_KeyConnect( int key ) 
+{
+	if ( key == A_ESCAPE ) 
+	{
+		ui.Cmd_ExecuteText( EXEC_APPEND, "disconnect\n" );
+		return;
+	}
+}
+
+
diff --git a/code/ui/ui_debug.cpp b/code/ui/ui_debug.cpp
new file mode 100644
index 0000000..5593389
--- /dev/null
+++ b/code/ui/ui_debug.cpp
@@ -0,0 +1,747 @@
+// Filename:-	ui_debug.cpp
+//
+// an entire temp module just for doing some evil menu hackery during development...
+//
+
+
+#include "../server/exe_headers.h"
+
+
+#if 0	// this entire module was special code to StripEd-ify *menu, it isn't needed now, but I'll keep the source around for a while	-ste
+
+
+#ifdef _DEBUG
+#include <set>
+#include "../qcommon/sstring.h"
+typedef sstring<4096> sstringBIG_t;
+typedef set<sstring_t>	StringSet_t;
+						StringSet_t		MenusUsed;
+typedef map <sstring_t,	StringSet_t>	ReferencesAndPackages_t;
+										ReferencesAndPackages_t ReferencesAndPackage;
+
+
+struct Reference_t
+{
+	sstringBIG_t	sString;
+	sstring_t		sReference;
+	sstring_t		sMenu;
+
+	Reference_t()
+	{
+		sString		= "";
+		sReference	= "";
+		sMenu		= "";
+	}
+
+	// sort by menu entry, then by reference within menu...
+	//
+	bool operator < (const Reference_t& _X) const 
+	{
+		int i = stricmp(sMenu.c_str(),_X.sMenu.c_str());
+		if (i)
+			return i<0;
+
+		return !!(stricmp(sReference.c_str(),_X.sReference.c_str()) < 0);
+	}
+};
+#include <list>
+typedef list <Reference_t>	References_t;
+							References_t BadReferences;
+
+sstring_t sCurrentMenu;
+void UI_Debug_AddMenuFilePath(LPCSTR psMenuFile)	// eg "ui/blah.menu"
+{
+	sCurrentMenu = psMenuFile;
+
+	OutputDebugString(va("Current menu: \"%s\"\n",psMenuFile));
+}
+
+
+typedef struct
+{
+	// to correct...
+	//
+	sstring_t		sMenuFile;
+	sstringBIG_t	sTextToFind;		// will be either @REFERENCE or "text"
+	sstringBIG_t	sTextToReplaceWith;	// will be @NEWREF
+	//
+	// to generate new data...
+	//
+	sstring_t		sStripEdReference;	// when NZ, this will create a new StripEd entry...
+	sstringBIG_t	sStripEdText;
+	sstring_t		sStripEdFileRef;	// ... in this file reference (eg "SPMENUS%d"), where 0.255 of each all have this in them (for ease of coding)
+
+} CorrectionDataItem_t;
+typedef list<CorrectionDataItem_t>	CorrectionData_t;
+									CorrectionData_t CorrectionData;
+
+
+static LPCSTR CreateUniqueReference(LPCSTR psText)
+{
+	static set <sstringBIG_t> ReferencesSoFar;
+	
+	static sstringBIG_t NewReference;
+
+	LPCSTR psTextScanPos = psText;
+
+	while(*psTextScanPos)
+	{
+		while (isspace(*psTextScanPos)) psTextScanPos++;
+
+		NewReference = psTextScanPos;
+				
+		// cap off text at an approx length...
+		//
+		const int iApproxReferenceLength = 20;
+		char *p;		
+		if (iApproxReferenceLength<strlen(NewReference.c_str()))
+		{
+			p = NewReference.c_str();
+			p+=iApproxReferenceLength;
+			while ( *p && !isspace(*p))
+				p++;
+
+			*p = '\0';
+		}
+
+		// now replace everything except digits and letters with underscores...
+		//
+		p = NewReference.c_str();
+		for (int i=0; i<strlen(p); i++)
+		{
+			if (!isalpha(p[i]) && !isdigit(p[i]))
+			{
+				p[i] = '_';
+			}
+		}
+		strupr(p);
+
+		// remove any trailing underscores...
+		//
+		while ( strlen(NewReference.c_str()) && NewReference.c_str()[strlen(NewReference.c_str())-1]=='_')
+		{
+			NewReference.c_str()[strlen(NewReference.c_str())-1]='\0';
+		}
+
+		// remove any multiple underscores...
+		//
+		while ( (p=strstr(NewReference.c_str(),"__")) != NULL)
+		{
+			memmove(p,p+1,strlen(p+1)+1);
+		}
+
+		// do we already have this reference?...
+		//
+		if (!strlen(NewReference.c_str()))
+		{
+			break;	// empty, shit.
+		}
+		if (ReferencesSoFar.find(NewReference.c_str()) == ReferencesSoFar.end())
+		{
+			// no, so add it in then return...
+			//
+			ReferencesSoFar.insert(NewReference.c_str());
+			return NewReference.c_str();
+		}
+
+		// skip past the first word in the reference and try again...
+		//
+		while (*psTextScanPos && !isspace(*psTextScanPos)) psTextScanPos++;
+	}
+
+	// if we get here then we're getting desperate, so...
+	//		  
+	// (special case check first)...
+	//	
+	for (LPCSTR p2 = psText; *p2 && isspace(*p2); p2++){}
+	if (!*p2)
+	{
+		psText = "BLANK";
+	}
+	
+	int iReScanDigit = 1;
+	while (1)
+	{
+		NewReference = va("%s_%d",psText,iReScanDigit++);
+
+		// now replace everything except digits and letters with underscores...
+		//
+		char *p = NewReference.c_str();
+		for (int i=0; i<strlen(p); i++)
+		{
+			if (!isalpha(p[i]) && !isdigit(p[i]))
+			{
+				p[i] = '_';
+			}
+		}
+		strupr(p);
+
+		// remove any trailing underscores...
+		//
+		while ( strlen(NewReference.c_str()) && NewReference.c_str()[strlen(NewReference.c_str())-1]=='_')
+		{
+			NewReference.c_str()[strlen(NewReference.c_str())-1]='\0';
+		}
+
+		// remove any multiple underscores...
+		//
+		while ( (p=strstr(NewReference.c_str(),"__")) != NULL)
+		{
+			memmove(p,p+1,strlen(p+1)+1);
+		}
+
+
+		if (ReferencesSoFar.find(NewReference.c_str()) == ReferencesSoFar.end())
+		{
+			// no, so add it in then return...
+			//
+			ReferencesSoFar.insert(NewReference.c_str());
+			return NewReference.c_str();
+		}
+	}
+
+	// should never get here...
+	//
+	assert(0);
+	return NULL;
+}
+
+
+static LPCSTR EnterBadRef(LPCSTR ps4LetterType, LPCSTR psBad)
+{
+	Reference_t	BadReference;
+				BadReference.sString = psBad;
+				BadReference.sMenu	 = sCurrentMenu;
+
+	BadReferences.push_back( BadReference );
+
+	LPCSTR	p = NULL;
+//			p = CreateUniqueReference(psBad);
+//	OutputDebugString(va("NEWREF: \"%s\"\n",p));
+	return	p;
+}
+
+static void EnterRef(LPCSTR psReference, LPCSTR psText, LPCSTR psMenuFile)
+{
+	// special hack, StripEd text at this point will have had any "\n" LITERALS replaced by the 0x0D 0x0A pair,
+	//	so we need to put them back to "\n" text ready for saving out into StripEd files again...
+	//
+	string	strNewText( psText );
+	//
+	// not sure whether just 0x0A or 0x0D/0x0A pairs (sigh), so first, eliminate 0x0Ds...
+	//
+	int iLoc;
+	while ( (iLoc = strNewText.find(0x0D,0)) != -1)
+	{
+		strNewText.replace(iLoc, 1, "");
+	}
+	// now replace any 0x0As with literal "\n" strings...
+	//
+	while ( (iLoc = strNewText.find(0x0A,0)) != -1)
+	{
+		strNewText.replace(iLoc, 1, "\\n");
+	}
+	psText = strNewText.c_str();
+
+	// curiousity...
+	//
+	static int iLongestText = 0;
+	if (iLongestText < strlen(psText))
+	{
+		iLongestText = strlen(psText);
+		OutputDebugString(va("Longest StripEd text: %d\n",iLongestText));
+	}
+
+
+
+	typedef map <sstringBIG_t, sstring_t> TextConsolidationTable_t;	// string and ref
+	static TextConsolidationTable_t TextConsolidationTable, RefrConsolidationTable;
+	static int iIndex = 0;	// INC'd every time a new StripEd entry is synthesised
+
+	TextConsolidationTable_t::iterator it = TextConsolidationTable.find(psText);
+	if (it == TextConsolidationTable.end())
+	{
+		// new entry...
+		//
+		LPCSTR psNewReference = CreateUniqueReference( (strlen(psReference) > strlen(psText))?psReference:psText  );
+
+		CorrectionDataItem_t	CorrectionDataItem;
+								CorrectionDataItem.sMenuFile			= psMenuFile;
+								CorrectionDataItem.sTextToFind			= strlen(psReference) ? ( /* !stricmp(psReference,psNewReference) ? "" :*/ va("@%s",psReference) )
+																			: va("\"%s\"",psText);
+								CorrectionDataItem.sTextToReplaceWith	= /* !stricmp(psReference,psNewReference) ? "" : */va("@%s",psNewReference);
+								//
+								CorrectionDataItem.sStripEdReference	= psNewReference;
+								CorrectionDataItem.sStripEdText			= psText;
+
+//		qboolean bIsMulti = !!strstr(psMenuFile,"jk2mp");
+//								CorrectionDataItem.sStripEdFileRef		= va("%sMENUS%d",bIsMulti?"MP":"SP",iIndex/256);
+								CorrectionDataItem.sStripEdFileRef		= va(  "MENUS%d",iIndex/256);
+		iIndex++;
+
+		CorrectionData.push_back( CorrectionDataItem );
+
+		TextConsolidationTable[ psText ] = psNewReference;
+		RefrConsolidationTable[ psText ] = CorrectionDataItem.sStripEdFileRef.c_str();
+	}
+	else
+	{
+		// text already entered, so do a little duplicate-resolving...
+		//
+		// need to find the reference for the existing version...
+		//
+		LPCSTR psNewReference = (*it).second.c_str();
+		LPCSTR psPackageRef	  = (*RefrConsolidationTable.find(psText)).second.c_str();	// yeuch, hack-city
+
+		// only enter correction data if references are different...
+		//
+//		if (stricmp(psReference,psNewReference))
+		{
+			CorrectionDataItem_t	CorrectionDataItem;
+									CorrectionDataItem.sMenuFile			= psMenuFile;
+									CorrectionDataItem.sTextToFind			= strlen(psReference) ? va("@%s",psReference) : va("\"%s\"",psText);
+									CorrectionDataItem.sTextToReplaceWith	= va("@%s",psNewReference);
+									//
+									CorrectionDataItem.sStripEdReference	= "";
+									CorrectionDataItem.sStripEdText			= "";
+									CorrectionDataItem.sStripEdFileRef		= psPackageRef;
+
+
+			CorrectionData.push_back( CorrectionDataItem );
+		}
+	}
+}
+
+static void EnterGoodRef(LPCSTR ps4LetterType, LPCSTR psReference, LPCSTR psPackageReference, LPCSTR psText)
+{
+	EnterRef(psReference, psText, sCurrentMenu.c_str());
+
+	ReferencesAndPackage[psReference].insert(psPackageReference);
+	MenusUsed.insert(psPackageReference);
+}
+
+static bool SendFileToNotepad(LPCSTR psFilename)
+{
+	bool bReturn = false;
+
+	char sExecString[MAX_PATH];
+
+	sprintf(sExecString,"notepad %s",psFilename);
+
+	if (WinExec(sExecString,	//  LPCSTR lpCmdLine,  // address of command line
+				SW_SHOWNORMAL	//  UINT uCmdShow      // window style for new application
+				)
+		>31	// don't ask me, Windoze just uses >31 as OK in this call.
+		)
+	{
+		// ok...
+		//
+		bReturn = true;
+	}
+	else
+	{
+		assert(0);//ErrorBox("Unable to locate/run NOTEPAD on this machine!\n\n(let me know about this -Ste)");		
+	}
+
+	return bReturn;
+}
+
+// creates as temp file, then spawns notepad with it...
+//
+static bool SendStringToNotepad(LPCSTR psWhatever, LPCSTR psLocalFileName)
+{
+	bool bReturn = false;
+
+	LPCSTR psOutputFileName = va("c:\\%s",psLocalFileName);
+
+	FILE *handle = fopen(psOutputFileName,"wt");
+	if (handle)
+	{
+		fprintf(handle,"%s",psWhatever);	// NOT fprintf(handle,psWhatever), which will try and process built-in %s stuff
+		fclose(handle);
+
+		bReturn = SendFileToNotepad(psOutputFileName);
+	}
+	else
+	{
+		assert(0);//ErrorBox(va("Unable to create file \"%s\" for notepad to use!",psOutputFileName));
+	}
+
+	return bReturn;
+}
+
+
+static qboolean DoFileFindReplace( LPCSTR psMenuFile, LPCSTR psFind, LPCSTR psReplace )
+{
+	char *buffer;
+
+	OutputDebugString(va("Loading: \"%s\"\n",psMenuFile));
+
+	int iLen = FS_ReadFile( psMenuFile,(void **) &buffer);
+	if (iLen<1) 
+	{
+		OutputDebugString("Failed!\n");
+		assert(0);
+		return qfalse;
+	}
+	
+
+	// find/rep...
+	//
+	string	str(buffer);
+			str += "\r\n";	// safety for *(char+1) stuff
+
+
+	FS_FreeFile( buffer );	// let go of the buffer
+
+	// originally this kept looping for replacements, but now it only does one (since the find/replace args are repeated
+	//	and this is called again if there are >1 replacements of the same strings to be made...
+	//
+//	int iReplacedCount = 0;
+	char *pFound;
+	int iSearchPos = 0;
+	while ( (pFound = strstr(str.c_str()+iSearchPos,psFind)) != NULL)
+	{
+		// special check, the next char must be whitespace or carriage return etc, or we're not on a whole-word position...
+		//
+		int iFoundLoc = pFound - str.c_str();
+		char cAfterFind = pFound[strlen(psFind)];
+		if (cAfterFind > 32)
+		{
+			// ... then this string was part of a larger one, so ignore it...
+			//
+			iSearchPos = iFoundLoc+1;
+			continue;
+		}		
+
+		str.replace(iFoundLoc, strlen(psFind), psReplace);
+//		iSearchPos = iFoundLoc+1;
+//		iReplacedCount++;
+		break;
+	}
+
+//	assert(iReplacedCount);
+//	if (iReplacedCount>1)
+//	{
+//		int z=1;
+//	}
+	FS_WriteFile( psMenuFile, str.c_str(), strlen(str.c_str()));
+
+	OutputDebugString("Ok\n");
+
+	return qtrue;
+}
+
+void UI_Dump_f(void)
+{
+	string sFinalOutput;
+	vector <string> vStripEdFiles;
+
+#define OUTPUT sFinalOutput+=
+#define OUTPUTSTRIP vStripEdFiles[vStripEdFiles.size()-1] +=
+
+	OUTPUT("### UI_Dump(): Top\n");
+
+	for (ReferencesAndPackages_t::iterator it = ReferencesAndPackage.begin(); it!=ReferencesAndPackage.end(); ++it)
+	{	
+		if ( (*it).second.size()>1)
+		{
+			OUTPUT(va("!!!DUP:  Ref \"%s\" exists in:\n",(*it).first.c_str()));
+			StringSet_t &Set = (*it).second;
+			for (StringSet_t::iterator itS = Set.begin(); itS!=Set.end(); ++itS)
+			{
+				OUTPUT(va("%s\n",(*itS).c_str()));
+			}
+		}
+	}
+
+	OUTPUT("\nSP Package Reference list:\n");
+
+	for (StringSet_t::iterator itS = MenusUsed.begin(); itS!=MenusUsed.end(); ++itS)
+	{
+		OUTPUT(va("%s\n",(*itS).c_str()));
+	}
+
+	OUTPUT("\nBad Text list:\n");
+
+	for (References_t::iterator itBad=BadReferences.begin(); itBad!=BadReferences.end();++itBad)
+	{
+		Reference_t &BadReference = (*itBad);
+
+		OUTPUT(va("File: %30s  \"%s\"\n",BadReference.sMenu.c_str(), BadReference.sString.c_str()));
+	}
+
+	OUTPUT("\nAdding bad references to final correction list...\n");
+
+	for (itBad=BadReferences.begin(); itBad!=BadReferences.end();++itBad)
+	{	
+		Reference_t &BadReference = (*itBad);
+
+		EnterRef("", BadReference.sString.c_str(), BadReference.sMenu.c_str() );
+	}	
+
+
+	OUTPUT("\nFinal correction list:\n");
+
+//	qboolean bIsMulti = !!strstr((*CorrectionData.begin()).sMenuFile.c_str(),"jk2mp");
+
+	// actually do the find/replace...
+	//
+	for (CorrectionData_t::iterator itCorrectionData = CorrectionData.begin(); itCorrectionData != CorrectionData.end(); ++itCorrectionData)
+	{
+		CorrectionDataItem_t &CorrectionDataItem = (*itCorrectionData);
+
+		if (CorrectionDataItem.sTextToFind.c_str()[0] && CorrectionDataItem.sTextToReplaceWith.c_str()[0])
+		{
+			OUTPUT( va("Load File: \"%s\", find \"%s\", replace with \"%s\"\n", 
+												CorrectionDataItem.sMenuFile.c_str(),
+															CorrectionDataItem.sTextToFind.c_str(),
+																				CorrectionDataItem.sTextToReplaceWith.c_str()
+						)
+					);
+
+
+//			if (strstr(CorrectionDataItem.sTextToReplaceWith.c_str(),"START_A_NEW_GAME"))
+//			{
+//				int z=1;
+//			}
+			assert( CorrectionDataItem.sTextToReplaceWith.c_str()[0] );
+			string	sReplace(	CorrectionDataItem.sTextToReplaceWith.c_str() );
+					sReplace.insert(1,"_");
+					sReplace.insert(1,CorrectionDataItem.sStripEdFileRef.c_str());								
+				
+			DoFileFindReplace(	CorrectionDataItem.sMenuFile.c_str(),
+								CorrectionDataItem.sTextToFind.c_str(),
+								sReplace.c_str()//CorrectionDataItem.sTextToReplaceWith.c_str()
+								);
+		}
+	}
+
+
+	// scan in all SP files into one huge string, so I can pick out any foreign translations to add in when generating
+	//	new StripEd files...
+	//
+	char **ppsFiles;
+	char *buffers[1000];	// max # SP files, well-OTT.
+	int iNumFiles;
+	int i;
+	string sStripFiles;
+
+	// scan for shader files
+	ppsFiles = FS_ListFiles( "strip", ".sp", &iNumFiles );
+	if ( !ppsFiles || !iNumFiles )
+	{
+		assert(0);
+	}
+	else
+	{
+		// load files...
+		//
+		for (i=0; i<iNumFiles; i++)
+		{
+			char sFilename[MAX_QPATH];
+
+			Com_sprintf( sFilename, sizeof( sFilename ), "strip/%s", ppsFiles[i] );
+			OutputDebugString( va("...loading '%s'\n", sFilename ) );
+			int iLen = FS_ReadFile( sFilename, (void **)&buffers[i] );
+			if ( iLen<1 ) {
+				assert(0);//Com_Error( ERR_DROP, "Couldn't load %s", filename );
+			}
+		}
+
+		// free up memory...
+		//
+		FS_FreeFileList( ppsFiles );
+
+		// build single large buffer and free up buffers as we go...
+		//		
+		// ( free in reverse order, so the temp files are all dumped )
+		for ( i=iNumFiles-1; i>=0; i-- ) 
+		{
+			sStripFiles += buffers[i];
+			sStripFiles += "\r\n";
+
+			FS_FreeFile( buffers[i] );
+		}
+	}
+
+	int iIndex=0;
+	for (itCorrectionData = CorrectionData.begin(); itCorrectionData != CorrectionData.end(); ++itCorrectionData)
+	{
+		CorrectionDataItem_t &CorrectionDataItem = (*itCorrectionData);
+
+		if (CorrectionDataItem.sStripEdReference.c_str()[0]	// skip over duplicate-resolving entries
+//			&& CorrectionDataItem.sStripEdText.c_str()[0]	//
+			)
+		{	
+			string strAnyForeignStringsFound;	// will be entire line plus CR
+			string strNotes;					// will be just the bit within quotes
+
+			LPCSTR psFoundExisting;
+			int iInitialSearchPos = 0;
+			while (iInitialSearchPos < sStripFiles.size() &&
+					(strAnyForeignStringsFound.empty() || strNotes.empty())
+					)
+			{
+				if ( (psFoundExisting = strstr( sStripFiles.c_str()+iInitialSearchPos, va("\"%s\"",CorrectionDataItem.sStripEdText.c_str()))) != NULL )
+				{
+					// see if we can find any NOTES entry above this...
+					//
+					LPCSTR p;
+
+					if (strNotes.empty())
+					{
+						p = psFoundExisting;
+						while (p > sStripFiles.c_str() && *p!='{')
+						{
+							if (!strnicmp(p,"NOTES",5) && isspace(p[-1]) && isspace(p[5]))
+							{
+								p = strchr(p,'"');
+								if (!p++) 
+									break;
+								while (*p != '"')
+									strNotes += *p++;
+								break;
+							}
+							p--;
+						}
+					}
+
+					// now search for any foreign versions we already have translated...
+					//
+					if (strAnyForeignStringsFound.empty())
+					{
+						p = psFoundExisting;
+						LPCSTR psNextBrace = strchr(p,'}');
+						assert(psNextBrace);
+						if (psNextBrace)
+						{
+							for (int i=2; i<10; i++)
+							{							
+								LPCSTR psForeign = strstr(p,va("TEXT_LANGUAGE%d",i));
+								if (psForeign && psForeign < psNextBrace)
+								{
+									strAnyForeignStringsFound += "   ";
+									while (*psForeign != '\n' && *psForeign != '\0')
+									{
+										strAnyForeignStringsFound += *psForeign++;
+									}
+									strAnyForeignStringsFound += "\n";
+								}
+							}
+						}
+					}
+
+					iInitialSearchPos = psFoundExisting - sStripFiles.c_str();
+					iInitialSearchPos++;	// one past, so we don't re-find ourselves
+				}
+				else
+				{
+					break;
+				}
+			}
+
+			if (!strNotes.empty())
+			{
+				strNotes = va("   NOTES \"%s\"\n",strNotes.c_str());
+			}
+
+			// now do output...
+			//
+			if (!(iIndex%256))
+			{
+				string s;
+				vStripEdFiles.push_back(s);
+
+				OUTPUTSTRIP(	va(	"VERSION 1\n"
+								"CONFIG W:\\bin\\striped.cfg\n"
+								"ID %d\n"
+								"REFERENCE MENUS%d\n"
+								"DESCRIPTION \"menu text\"\n"
+								"COUNT 256\n",		// count will need correcting for last one
+								250 + (iIndex/256),	// 250 range seems to be unused
+								iIndex/256
+								)
+							);
+
+//				OUTPUTSTRIP( va("REFERENCE %s\n", va("%sMENUS%d",bIsMulti?"MP":"SP",iIndex/256)) );
+//				OUTPUTSTRIP( va("REFERENCE %s\n", va(  "MENUS%d",iIndex/256)) );
+			}
+
+			OUTPUTSTRIP( va(	"INDEX %d\n"
+								"{\n"
+								"   REFERENCE %s\n"
+								"%s"
+								"   TEXT_LANGUAGE1 \"%s\"\n"
+								"%s"
+								"}\n",
+								iIndex%256,
+								CorrectionDataItem.sStripEdReference.c_str(),
+								(strNotes.empty()?"":strNotes.c_str()),
+								CorrectionDataItem.sStripEdText.c_str(),
+								strAnyForeignStringsFound.c_str()
+								)
+							);
+
+			iIndex++;
+		}
+	}
+
+	OUTPUT("### UI_Dump(): Bottom\n");
+
+	SendStringToNotepad(sFinalOutput.c_str(), "temp.txt");
+
+	// output the SP files...
+	//
+	for (i=0; i<vStripEdFiles.size(); i++)
+	{
+		// need to make local string, because ingame va() is crippled to 2 depths...
+		//
+		char sName[MAX_PATH];
+		sprintf(sName,"Source\\StarWars\\code\\base\\strip\\MENUS%d.sp",i);
+		SendStringToNotepad(vStripEdFiles[i].c_str(), sName);
+	}
+}
+
+
+void UI_Debug_EnterReference(LPCSTR ps4LetterType, LPCSTR psItemString)
+{
+	if ((int)psItemString < 0)	//string package ID
+	{
+		LPCSTR psPackageName, psPackageReference, psText;
+		psItemString = SP_GetReferenceText(-(int)psItemString, psPackageName, psPackageReference, psText);
+		if (psItemString && psItemString[0]) {
+//			OutputDebugString(va("    TEXT: \"%s\" Package: %s\n",psItemString,psPackageReference));
+			EnterGoodRef(ps4LetterType,psItemString,psPackageReference,psText);
+		}
+		else {
+			assert(0);
+		}
+	}
+	else
+	{	
+		if (psItemString && psItemString[0]) 
+		{
+			if ( !stricmp(psItemString,"english") ||
+				 !stricmp(psItemString,"francais") ||
+				 !stricmp(psItemString,"deutsch")
+				 )
+			{
+				// then don't localise it!
+			}
+			else
+			{
+				//OutputDebugString(va("BAD TEXT: \"%s\"  REF: \"%s\"\n",psItemString, EnterBadText(psItemString)));
+				EnterBadRef(ps4LetterType,psItemString);
+			}
+		}		
+		else {
+			assert(0);
+		}
+	}
+}
+
+#endif
+
+#endif
+
diff --git a/code/ui/ui_local.h b/code/ui/ui_local.h
new file mode 100644
index 0000000..ea681d7
--- /dev/null
+++ b/code/ui/ui_local.h
@@ -0,0 +1,219 @@
+#ifndef __UI_LOCAL_H__
+#define __UI_LOCAL_H__
+
+#include <string.h>
+#include <limits.h>
+
+#include "../game/q_shared.h"
+#include "../renderer/tr_types.h"
+#include "../qcommon/qcommon.h"
+#include "ui_public.h"
+#include "ui_shared.h"
+
+#define MAX_PLAYERMODELS 32
+#define MAX_DEFERRED_SCRIPT		1024
+
+//
+// ui_qmenu.c
+//
+#define	MAX_EDIT_LINE			256
+
+typedef struct {
+	int		cursor;
+	int		scroll;
+	int		widthInChars;
+	char	buffer[MAX_EDIT_LINE];
+	int		maxchars;
+	int		style;
+	int		textEnum;		// Label
+	int		textcolor;		// Normal color
+	int		textcolor2;		// Highlight color
+} uifield_t;
+
+extern void		Menu_Cache( void );
+
+//
+// ui_field.c
+//
+extern void	Field_Clear( uifield_t *edit );
+extern void	Field_CharEvent( uifield_t *edit, int ch );
+extern void Field_Draw( uifield_t *edit, int x, int y, int width, int size,int color,int color2, qboolean showCursor );
+
+
+//
+// ui_menu.c
+//
+extern void UI_MainMenu(void);
+extern void UI_InGameMenu(const char*holoFlag);
+extern void AssetCache(void);
+extern void UI_DataPadMenu(void);
+
+//
+// ui_connect.c
+//
+extern void UI_DrawConnect( const char *servername, const char * updateInfoString );
+extern void UI_UpdateConnectionString( char *string );
+extern void UI_UpdateConnectionMessageString( char *string );
+
+
+//
+// ui_atoms.c
+//
+
+#define UI_FADEOUT	0
+#define UI_FADEIN	1
+
+typedef struct {
+	int					frametime;
+	int					realtime;
+	int					cursorx;
+	int					cursory;
+	
+	glconfig_t			glconfig;
+	qboolean			debugMode;
+	qhandle_t			whiteShader;
+	qhandle_t			menuBackShader;
+	qhandle_t			cursor;
+	float				scalex;
+	float				scaley;
+	//float				bias;
+	qboolean			firstdraw;
+} uiStatic_t;
+
+extern void			UI_FillRect( float x, float y, float width, float height, const float *color );
+extern void			UI_DrawString( int x, int y, const char* str, int style, vec4_t color );
+extern void			UI_DrawHandlePic( float x, float y, float w, float h, qhandle_t hShader ); 
+extern void			UI_UpdateScreen( void );
+extern int			UI_RegisterFont(const char *fontName);
+extern void			UI_SetColor( const float *rgba );
+extern char			*UI_Cvar_VariableString( const char *var_name );
+
+extern uiStatic_t	uis;
+extern uiimport_t	ui;
+
+
+#define MAX_MOVIES 256
+#define MAX_MODS 64
+
+typedef struct {
+	const char *modName;
+	const char *modDescr;
+} modInfo_t;
+
+typedef struct {
+	char		Name[64];
+	int			SkinHeadCount;
+//	qhandle_t	SkinHeadIcons[MAX_PLAYERMODELS];
+	char		SkinHeadNames[MAX_PLAYERMODELS][16];
+	int			SkinTorsoCount;
+//	qhandle_t	SkinTorsoIcons[MAX_PLAYERMODELS];
+	char		SkinTorsoNames[MAX_PLAYERMODELS][16];
+	int			SkinLegCount;
+//	qhandle_t	SkinLegIcons[MAX_PLAYERMODELS];
+	char		SkinLegNames[MAX_PLAYERMODELS][16];
+	char		ColorShader[MAX_PLAYERMODELS][64];
+	int			ColorCount;
+	char		ColorActionText[MAX_PLAYERMODELS][128];
+} playerSpeciesInfo_t;
+
+typedef struct {
+	displayContextDef_t uiDC;
+
+	int effectsColor;
+	int currentCrosshair;
+
+	modInfo_t modList[MAX_MODS];
+	int modIndex;
+	int modCount;
+
+	int					playerSpeciesCount;
+	playerSpeciesInfo_t	playerSpecies[MAX_PLAYERMODELS];
+	int					playerSpeciesIndex;
+
+
+	char		deferredScript [ MAX_DEFERRED_SCRIPT ];
+	itemDef_t*	deferredScriptItem;
+
+	itemDef_t*	runScriptItem;
+
+	qboolean inGameLoad;
+	// Used by Force Power allocation screen
+	short	forcePowerUpdated;					// Enum of which power had the point allocated
+	// Used by Weapon allocation screen
+	short	selectedWeapon1;					// 1st weapon chosen
+	char 	selectedWeapon1ItemName[64];		// Item name of weapon chosen
+	int		selectedWeapon1AmmoIndex;			// Holds index to ammo
+	short	selectedWeapon2;					// 2nd weapon chosen
+	char 	selectedWeapon2ItemName[64];		// Item name of weapon chosen
+	int		selectedWeapon2AmmoIndex;			// Holds index to ammo
+	short	selectedThrowWeapon;				// throwable weapon chosen
+	char 	selectedThrowWeaponItemName[64];	// Item name of weapon chosen
+	int		selectedThrowWeaponAmmoIndex;		// Holds index to ammo
+
+	itemDef_t *weapon1ItemButton;
+	qhandle_t litWeapon1Icon;
+	qhandle_t unlitWeapon1Icon;
+	itemDef_t *weapon2ItemButton;
+	qhandle_t litWeapon2Icon;
+	qhandle_t unlitWeapon2Icon;
+
+	itemDef_t *weaponThrowButton;
+	qhandle_t litThrowableIcon;
+	qhandle_t unlitThrowableIcon;
+	short		movesTitleIndex;
+	char		*movesBaseAnim;
+	int			moveAnimTime;
+	int			languageCount;
+	int			languageCountIndex;
+}	uiInfo_t;
+
+extern uiInfo_t uiInfo;
+
+//
+// ui_main.c
+//
+void _UI_Init( qboolean inGameLoad );
+void _UI_DrawRect( float x, float y, float width, float height, float size, const float *color );
+void _UI_MouseEvent( int dx, int dy );
+void _UI_KeyEvent( int key, qboolean down );
+void UI_Report(void);
+
+extern char GoToMenu[];
+
+
+//
+// ui_syscalls.c
+//
+int				trap_CIN_PlayCinematic( const char *arg0, int xpos, int ypos, int width, int height, int bits, const char *psAudioFile /* = NULL */);
+int				trap_CIN_StopCinematic(int handle); 
+void			trap_Cvar_Set( const char *var_name, const char *value );
+float			trap_Cvar_VariableValue( const char *var_name );
+void			trap_GetGlconfig( glconfig_t *glconfig );
+void			trap_Key_ClearStates( void );
+int				trap_Key_GetCatcher( void );
+qboolean		trap_Key_GetOverstrikeMode( void );
+void			trap_Key_SetBinding( int keynum, const char *binding );
+void			trap_Key_SetCatcher( int catcher );
+void			trap_Key_SetOverstrikeMode( qboolean state );
+void			trap_R_DrawStretchPic( float x, float y, float w, float h, float s1, float t1, float s2, float t2, qhandle_t hShader );
+void			trap_R_ModelBounds( clipHandle_t model, vec3_t mins, vec3_t maxs );
+void			trap_R_SetColor( const float *rgba );
+void			trap_R_ClearScene( void );
+void			trap_R_AddRefEntityToScene( const refEntity_t *re );
+void			trap_R_RenderScene( const refdef_t *fd );
+void			trap_S_StopSounds( void );
+sfxHandle_t		trap_S_RegisterSound( const char *sample, qboolean compressed );
+void			trap_S_StartLocalSound( sfxHandle_t sfx, int channelNum );
+#ifdef _IMMERSION
+ffHandle_t		trap_FF_Register( const char *name, int channel = FF_CHANNEL_MENU );
+void			trap_FF_Start( ffHandle_t ff );
+#endif // _IMMERSION
+#ifndef _XBOX
+int				PASSFLOAT( float x );
+#endif
+
+
+
+void _UI_Refresh( int realtime );
+
+#endif
diff --git a/code/ui/ui_main.cpp b/code/ui/ui_main.cpp
new file mode 100644
index 0000000..9080a7b
--- /dev/null
+++ b/code/ui/ui_main.cpp
@@ -0,0 +1,6314 @@
+// Copyright (C) 1999-2000 Id Software, Inc.
+//
+/*
+=======================================================================
+
+USER INTERFACE MAIN
+
+=======================================================================
+*/
+
+// leave this at the top of all UI_xxxx files for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+#include "ui_local.h"
+
+#include "menudef.h"
+
+#include "ui_shared.h"
+
+#include "../ghoul2/G2.h"
+
+#include "../game/bg_public.h"
+#include "../game/anims.h"
+extern stringID_table_t animTable [MAX_ANIMATIONS+1];
+
+#include "../qcommon/stv_version.h"
+
+#ifdef _XBOX
+#include <xtl.h>
+#define filepathlength 120
+#endif
+
+extern qboolean ItemParse_model_g2anim_go( itemDef_t *item, const char *animName );
+extern qboolean ItemParse_asset_model_go( itemDef_t *item, const char *name );
+extern qboolean ItemParse_model_g2skin_go( itemDef_t *item, const char *skinName );
+extern qboolean UI_SaberModelForSaber( const char *saberName, char *saberModel );
+extern qboolean UI_SaberSkinForSaber( const char *saberName, char *saberSkin );
+extern void UI_SaberAttachToChar( itemDef_t *item );
+
+extern qboolean PC_Script_Parse(const char **out);
+
+#define LISTBUFSIZE 10240
+
+static struct 
+{
+	char	listBuf[LISTBUFSIZE];			//	The list of file names read in
+
+	// For scrolling through file names 
+	int				currentLine;		//	Index to currentSaveFileComments[] currently highlighted
+	int				saveFileCnt;		//	Number of save files read in
+
+	int				awaitingSave;		//	Flag to see if user wants to overwrite a game.
+
+	char			*savegameMap;
+	int				savegameFromFlag;
+} s_savegame;
+
+#ifdef _XBOX
+#define MAX_SAVELOADFILES	8
+#else
+#define MAX_SAVELOADFILES	100
+#endif
+#define MAX_SAVELOADNAME	32
+
+//byte screenShotBuf[SG_SCR_WIDTH * SG_SCR_HEIGHT * 4];
+
+typedef struct 
+{
+	char *currentSaveFileName;						// file name of savegame
+	char currentSaveFileComments[iSG_COMMENT_SIZE];	// file comment
+	char currentSaveFileDateTimeString[iSG_COMMENT_SIZE];	// file time and date
+	time_t currentSaveFileDateTime;
+	char currentSaveFileMap[MAX_TOKEN_CHARS];			// map save game is from
+} savedata_t;
+
+static savedata_t s_savedata[MAX_SAVELOADFILES];
+void UI_SetActiveMenu( const char* menuname,const char *menuID );
+void ReadSaveDirectory (void);
+void Item_RunScript(itemDef_t *item, const char *s);
+qboolean Item_SetFocus(itemDef_t *item, float x, float y);
+
+qboolean		Asset_Parse(char **buffer);
+menuDef_t		*Menus_FindByName(const char *p);
+void			Menus_HideItems(const char *menuName);
+int				Text_Height(const char *text, float scale, int iFontIndex );
+int				Text_Width(const char *text, float scale, int iFontIndex );
+void			_UI_DrawTopBottom(float x, float y, float w, float h, float size);
+void			_UI_DrawSides(float x, float y, float w, float h, float size);
+void			UI_CheckVid1Data(const char *menuTo,const char *warningMenuName);
+void			UI_GetVideoSetup ( void );
+void			UI_UpdateVideoSetup ( void );
+static void		UI_UpdateCharacterCvars ( void );
+static void		UI_GetCharacterCvars ( void );
+static void		UI_UpdateSaberCvars ( void );
+static void		UI_GetSaberCvars ( void );
+static void		UI_ResetSaberCvars ( void );
+static void		UI_InitAllocForcePowers ( const char *forceName );
+static void		UI_AffectForcePowerLevel ( const char *forceName );
+static void		UI_ShowForceLevelDesc ( const char *forceName );
+static void		UI_ResetForceLevels ( void );
+static void		UI_ClearWeapons ( void );
+static void		UI_GiveWeapon ( const int weaponIndex );
+static void		UI_EquipWeapon ( const int weaponIndex );
+static void		UI_LoadMissionSelectMenu( const char *cvarName );
+static void		UI_AddWeaponSelection ( const int weaponIndex, const int ammoIndex, const int ammoAmount, const char *iconItemName,const char *litIconItemName, const char *hexBackground, const char *soundfile );
+static void		UI_AddThrowWeaponSelection ( const int weaponIndex, const int ammoIndex, const int ammoAmount, const char *iconItemName,const char *litIconItemName, const char *hexBackground, const char *soundfile );
+static void		UI_RemoveWeaponSelection ( const int weaponIndex );
+static void		UI_RemoveThrowWeaponSelection ( void );
+static void		UI_HighLightWeaponSelection ( const int selectionslot );
+static void		UI_NormalWeaponSelection ( const int selectionslot );
+static void		UI_NormalThrowSelection ( void );
+static void		UI_HighLightThrowSelection( void );
+static void		UI_ClearInventory ( void );
+static void		UI_GiveInventory ( const int itemIndex, const int amount );
+static void		UI_ForcePowerWeaponsButton(qboolean activeFlag);
+static void		UI_UpdateCharacterSkin( void );
+static void		UI_UpdateCharacter( qboolean changedModel );
+static void		UI_UpdateSaberType( void );
+static void		UI_UpdateSaberHilt( qboolean secondSaber );
+//static void		UI_UpdateSaberColor( qboolean secondSaber );
+static void		UI_InitWeaponSelect( void );
+static void		UI_WeaponHelpActive( void );
+static void		UI_UpdateFightingStyle ( void );
+static void		UI_UpdateFightingStyleChoices ( void );
+static void		UI_CalcForceStatus(void);
+static void		UI_DecrementForcePowerLevel( void );
+static void		UI_DecrementCurrentForcePower ( void );
+static void		UI_ShutdownForceHelp( void );
+static void		UI_ForceHelpActive( void );
+static void		UI_ResetCharacterListBoxes( void );
+
+
+void		UI_LoadMenus(const char *menuFile, qboolean reset);
+static void		UI_OwnerDraw(float x, float y, float w, float h, float text_x, float text_y, int ownerDraw, int ownerDrawFlags, int align, float special, float scale, vec4_t color, qhandle_t shader, int textStyle, int iFontIndex);
+static qboolean UI_OwnerDrawVisible(int flags);
+int				UI_OwnerDrawWidth(int ownerDraw, float scale);
+static void		UI_Update(const char *name);
+void			UI_UpdateCvars( void );
+void			UI_ResetDefaults( void );
+void			UI_AdjustSaveGameListBox( int currentLine );
+
+void			Menus_CloseByName(const char *p);
+
+// Movedata Sounds
+typedef enum
+{
+	MDS_NONE = 0,
+	MDS_FORCE_JUMP,
+	MDS_ROLL,
+	MDS_SABER,
+	MDS_MOVE_SOUNDS_MAX
+};
+
+typedef enum
+{
+	MD_ACROBATICS = 0,
+	MD_SINGLE_FAST,
+	MD_SINGLE_MEDIUM,
+	MD_SINGLE_STRONG,
+	MD_DUAL_SABERS,
+	MD_SABER_STAFF,
+	MD_MOVE_TITLE_MAX
+};
+
+// Some hard coded badness
+// At some point maybe this should be externalized to a .dat file
+char *datapadMoveTitleData[MD_MOVE_TITLE_MAX] =
+{
+"@MENUS_ACROBATICS",
+"@MENUS_SINGLE_FAST",
+"@MENUS_SINGLE_MEDIUM",
+"@MENUS_SINGLE_STRONG",
+"@MENUS_DUAL_SABERS",
+"@MENUS_SABER_STAFF",
+};
+
+char *datapadMoveTitleBaseAnims[MD_MOVE_TITLE_MAX] =
+{
+"BOTH_RUN1",
+"BOTH_SABERFAST_STANCE",
+"BOTH_STAND2",
+"BOTH_SABERSLOW_STANCE",
+"BOTH_SABERDUAL_STANCE",
+"BOTH_SABERSTAFF_STANCE",
+};
+
+#define MAX_MOVES 16
+
+typedef struct 
+{
+	char	*title;	
+	char	*desc;	
+	char	*anim;
+	short	sound;
+} datpadmovedata_t;
+
+static datpadmovedata_t datapadMoveData[MD_MOVE_TITLE_MAX][MAX_MOVES] = 
+{
+// Acrobatics
+"@MENUS_FORCE_JUMP1",				"@MENUS_FORCE_JUMP1_DESC",			"BOTH_FORCEJUMP1",				MDS_FORCE_JUMP,
+"@MENUS_FORCE_FLIP",				"@MENUS_FORCE_FLIP_DESC",			"BOTH_FLIP_F",					MDS_FORCE_JUMP,
+"@MENUS_ROLL",						"@MENUS_ROLL_DESC",					"BOTH_ROLL_F",					MDS_ROLL,
+"@MENUS_BACKFLIP_OFF_WALL",			"@MENUS_BACKFLIP_OFF_WALL_DESC",	"BOTH_WALL_FLIP_BACK1",			MDS_FORCE_JUMP,
+"@MENUS_SIDEFLIP_OFF_WALL",			"@MENUS_SIDEFLIP_OFF_WALL_DESC",	"BOTH_WALL_FLIP_RIGHT",			MDS_FORCE_JUMP,
+"@MENUS_WALL_RUN",					"@MENUS_WALL_RUN_DESC",				"BOTH_WALL_RUN_RIGHT",			MDS_FORCE_JUMP,
+"@MENUS_LONG_JUMP",					"@MENUS_LONG_JUMP_DESC",			"BOTH_FORCELONGLEAP_START",		MDS_FORCE_JUMP,
+"@MENUS_WALL_GRAB_JUMP",			"@MENUS_WALL_GRAB_JUMP_DESC",		"BOTH_FORCEWALLREBOUND_FORWARD",MDS_FORCE_JUMP,
+"@MENUS_RUN_UP_WALL_BACKFLIP",		"@MENUS_RUN_UP_WALL_BACKFLIP_DESC",	"BOTH_FORCEWALLRUNFLIP_START",	MDS_FORCE_JUMP,
+"@MENUS_JUMPUP_FROM_KNOCKDOWN",		"@MENUS_JUMPUP_FROM_KNOCKDOWN_DESC","BOTH_KNOCKDOWN3",				MDS_NONE,
+"@MENUS_JUMPKICK_FROM_KNOCKDOWN",	"@MENUS_JUMPKICK_FROM_KNOCKDOWN_DESC","BOTH_KNOCKDOWN2",			MDS_NONE,
+"@MENUS_ROLL_FROM_KNOCKDOWN",		"@MENUS_ROLL_FROM_KNOCKDOWN_DESC",	"BOTH_KNOCKDOWN1",				MDS_NONE,
+NULL, NULL, 0,	MDS_NONE,
+NULL, NULL, 0,	MDS_NONE,
+NULL, NULL, 0,	MDS_NONE,
+NULL, NULL, 0,	MDS_NONE,
+
+//Single Saber, Fast Style
+"@MENUS_STAB_BACK",					"@MENUS_STAB_BACK_DESC",			"BOTH_A2_STABBACK1",			MDS_SABER,
+"@MENUS_LUNGE_ATTACK",				"@MENUS_LUNGE_ATTACK_DESC",			"BOTH_LUNGE2_B__T_",			MDS_SABER,
+"@MENUS_FORCE_PULL_IMPALE",			"@MENUS_FORCE_PULL_IMPALE_DESC",	"BOTH_PULL_IMPALE_STAB",		MDS_SABER,
+"@MENUS_FAST_ATTACK_KATA",			"@MENUS_FAST_ATTACK_KATA_DESC",		"BOTH_A1_SPECIAL",				MDS_SABER,
+"@MENUS_ATTACK_ENEMYONGROUND",		"@MENUS_ATTACK_ENEMYONGROUND_DESC", "BOTH_STABDOWN",				MDS_FORCE_JUMP,
+"@MENUS_CARTWHEEL",					"@MENUS_CARTWHEEL_DESC",			"BOTH_ARIAL_RIGHT",				MDS_FORCE_JUMP,
+"@MENUS_BOTH_ROLL_STAB",			"@MENUS_BOTH_ROLL_STAB2_DESC",		"BOTH_ROLL_STAB",				MDS_SABER,
+NULL, NULL, 0,	MDS_NONE,
+NULL, NULL, 0,	MDS_NONE,
+NULL, NULL, 0,	MDS_NONE,
+NULL, NULL, 0,	MDS_NONE,
+NULL, NULL, 0,	MDS_NONE,
+NULL, NULL, 0,	MDS_NONE,
+NULL, NULL, 0,	MDS_NONE,
+NULL, NULL, 0,	MDS_NONE,
+NULL, NULL, 0,	MDS_NONE,
+
+//Single Saber, Medium Style
+"@MENUS_SLASH_BACK",				"@MENUS_SLASH_BACK_DESC",			"BOTH_ATTACK_BACK",				MDS_SABER,
+"@MENUS_FLIP_ATTACK",				"@MENUS_FLIP_ATTACK_DESC",			"BOTH_JUMPFLIPSLASHDOWN1",		MDS_FORCE_JUMP,
+"@MENUS_FORCE_PULL_SLASH",			"@MENUS_FORCE_PULL_SLASH_DESC",		"BOTH_PULL_IMPALE_SWING",		MDS_SABER,
+"@MENUS_MEDIUM_ATTACK_KATA",		"@MENUS_MEDIUM_ATTACK_KATA_DESC",	"BOTH_A2_SPECIAL",				MDS_SABER,
+"@MENUS_ATTACK_ENEMYONGROUND",		"@MENUS_ATTACK_ENEMYONGROUND_DESC", "BOTH_STABDOWN",				MDS_FORCE_JUMP,
+"@MENUS_CARTWHEEL",					"@MENUS_CARTWHEEL_DESC",			"BOTH_ARIAL_RIGHT",				MDS_FORCE_JUMP,
+"@MENUS_BOTH_ROLL_STAB",			"@MENUS_BOTH_ROLL_STAB2_DESC",		"BOTH_ROLL_STAB",				MDS_SABER,
+NULL, NULL, 0,	MDS_NONE,
+NULL, NULL, 0,	MDS_NONE,
+NULL, NULL, 0,	MDS_NONE,
+NULL, NULL, 0,	MDS_NONE,
+NULL, NULL, 0,	MDS_NONE,
+NULL, NULL, 0,	MDS_NONE,
+NULL, NULL, 0,	MDS_NONE,
+NULL, NULL, 0,	MDS_NONE,
+NULL, NULL, 0,	MDS_NONE,
+
+//Single Saber, Strong Style
+"@MENUS_SLASH_BACK",				"@MENUS_SLASH_BACK_DESC",			"BOTH_ATTACK_BACK",				MDS_SABER,
+"@MENUS_JUMP_ATTACK",				"@MENUS_JUMP_ATTACK_DESC",			"BOTH_FORCELEAP2_T__B_",		MDS_FORCE_JUMP,
+"@MENUS_FORCE_PULL_SLASH",			"@MENUS_FORCE_PULL_SLASH_DESC",		"BOTH_PULL_IMPALE_SWING",		MDS_SABER,
+"@MENUS_STRONG_ATTACK_KATA",		"@MENUS_STRONG_ATTACK_KATA_DESC",	"BOTH_A3_SPECIAL",				MDS_SABER,
+"@MENUS_ATTACK_ENEMYONGROUND",		"@MENUS_ATTACK_ENEMYONGROUND_DESC", "BOTH_STABDOWN",				MDS_FORCE_JUMP,
+"@MENUS_CARTWHEEL",					"@MENUS_CARTWHEEL_DESC",			"BOTH_ARIAL_RIGHT",				MDS_FORCE_JUMP,
+"@MENUS_BOTH_ROLL_STAB",			"@MENUS_BOTH_ROLL_STAB2_DESC",		"BOTH_ROLL_STAB",				MDS_SABER,
+NULL, NULL, 0,	MDS_NONE,
+NULL, NULL, 0,	MDS_NONE,
+NULL, NULL, 0,	MDS_NONE,
+NULL, NULL, 0,	MDS_NONE,
+NULL, NULL, 0,	MDS_NONE,
+NULL, NULL, 0,	MDS_NONE,
+NULL, NULL, 0,	MDS_NONE,
+NULL, NULL, 0,	MDS_NONE,
+NULL, NULL, 0,	MDS_NONE,
+
+//Dual Sabers
+"@MENUS_SLASH_BACK",				"@MENUS_SLASH_BACK_DESC",			"BOTH_ATTACK_BACK",				MDS_SABER,
+"@MENUS_FLIP_FORWARD_ATTACK",		"@MENUS_FLIP_FORWARD_ATTACK_DESC",	"BOTH_JUMPATTACK6",				MDS_FORCE_JUMP,
+"@MENUS_DUAL_SABERS_TWIRL",			"@MENUS_DUAL_SABERS_TWIRL_DESC",	"BOTH_SPINATTACK6",				MDS_SABER,
+"@MENUS_ATTACK_ENEMYONGROUND",		"@MENUS_ATTACK_ENEMYONGROUND_DESC", "BOTH_STABDOWN_DUAL",			MDS_FORCE_JUMP,
+"@MENUS_DUAL_SABER_BARRIER",		"@MENUS_DUAL_SABER_BARRIER_DESC",	"BOTH_A6_SABERPROTECT",			MDS_SABER,
+"@MENUS_DUAL_STAB_FRONT_BACK",		"@MENUS_DUAL_STAB_FRONT_BACK_DESC", "BOTH_A6_FB",					MDS_SABER,
+"@MENUS_DUAL_STAB_LEFT_RIGHT",		"@MENUS_DUAL_STAB_LEFT_RIGHT_DESC", "BOTH_A6_LR",					MDS_SABER,
+"@MENUS_CARTWHEEL",					"@MENUS_CARTWHEEL_DESC",			"BOTH_ARIAL_RIGHT",				MDS_FORCE_JUMP,
+"@MENUS_BOTH_ROLL_STAB",			"@MENUS_BOTH_ROLL_STAB_DESC",		"BOTH_ROLL_STAB",				MDS_SABER,
+NULL, NULL, 0,	MDS_NONE,
+NULL, NULL, 0,	MDS_NONE,
+NULL, NULL, 0,	MDS_NONE,
+NULL, NULL, 0,	MDS_NONE,
+NULL, NULL, 0,	MDS_NONE,
+NULL, NULL, 0,	MDS_NONE,
+NULL, NULL, 0,	MDS_NONE,
+
+// Saber Staff
+"@MENUS_STAB_BACK",					"@MENUS_STAB_BACK_DESC",			"BOTH_A2_STABBACK1",			MDS_SABER,
+"@MENUS_BACK_FLIP_ATTACK",			"@MENUS_BACK_FLIP_ATTACK_DESC",		"BOTH_JUMPATTACK7",				MDS_FORCE_JUMP,
+"@MENUS_SABER_STAFF_TWIRL",			"@MENUS_SABER_STAFF_TWIRL_DESC",	"BOTH_SPINATTACK7",				MDS_SABER,
+"@MENUS_ATTACK_ENEMYONGROUND",		"@MENUS_ATTACK_ENEMYONGROUND_DESC", "BOTH_STABDOWN_STAFF",			MDS_FORCE_JUMP,
+"@MENUS_SPINNING_KATA",				"@MENUS_SPINNING_KATA_DESC",		"BOTH_A7_SOULCAL",				MDS_SABER,
+"@MENUS_KICK1",						"@MENUS_KICK1_DESC",				"BOTH_A7_KICK_F",				MDS_FORCE_JUMP,
+"@MENUS_JUMP_KICK",					"@MENUS_JUMP_KICK_DESC",			"BOTH_A7_KICK_F_AIR",			MDS_FORCE_JUMP,
+"@MENUS_SPLIT_KICK",				"@MENUS_SPLIT_KICK_DESC",			"BOTH_A7_KICK_RL",				MDS_FORCE_JUMP,
+"@MENUS_SPIN_KICK",					"@MENUS_SPIN_KICK_DESC",			"BOTH_A7_KICK_S",				MDS_FORCE_JUMP,
+"@MENUS_FLIP_KICK",					"@MENUS_FLIP_KICK_DESC",			"BOTH_A7_KICK_BF",				MDS_FORCE_JUMP,
+"@MENUS_BUTTERFLY_ATTACK",			"@MENUS_BUTTERFLY_ATTACK_DESC",		"BOTH_BUTTERFLY_FR1",			MDS_SABER,
+"@MENUS_BOTH_ROLL_STAB",			"@MENUS_BOTH_ROLL_STAB2_DESC",		"BOTH_ROLL_STAB",				MDS_SABER,
+NULL, NULL, 0,	MDS_NONE,
+NULL, NULL, 0,	MDS_NONE,
+NULL, NULL, 0,	MDS_NONE,
+NULL, NULL, 0,	MDS_NONE,
+};
+
+
+static int gamecodetoui[] = {4,2,3,0,5,1,6};
+
+uiInfo_t uiInfo;
+
+static void UI_RegisterCvars( void );
+void UI_Load(void);
+
+
+typedef struct {
+	vmCvar_t	*vmCvar;
+	char		*cvarName;
+	char		*defaultString;
+	int			cvarFlags;
+} cvarTable_t;
+
+
+vmCvar_t	ui_menuFiles;
+vmCvar_t	ui_hudFiles;
+
+vmCvar_t	ui_char_anim;
+vmCvar_t	ui_char_model;
+vmCvar_t	ui_char_skin_head;
+vmCvar_t	ui_char_skin_torso;
+vmCvar_t	ui_char_skin_legs;
+vmCvar_t	ui_saber_type;
+vmCvar_t	ui_saber;
+vmCvar_t	ui_saber2;
+vmCvar_t	ui_saber_color;
+vmCvar_t	ui_saber2_color;
+vmCvar_t	ui_char_color_red;
+vmCvar_t	ui_char_color_green;
+vmCvar_t	ui_char_color_blue;
+vmCvar_t	ui_PrecacheModels;
+
+//JLFCALLOUT MPMOVED
+vmCvar_t	ui_hideAcallout;
+vmCvar_t	ui_hideBcallout;
+vmCvar_t	ui_hideXcallout;
+//END JLFCALLOUT
+
+
+static cvarTable_t cvarTable[] = 
+{
+	{ &ui_menuFiles,			"ui_menuFiles",			"ui/menus.txt", CVAR_ARCHIVE },
+	{ &ui_hudFiles,				"cg_hudFiles",			"ui/jahud.txt",CVAR_ARCHIVE}, 
+
+	{ &ui_char_anim,			"ui_char_anim",			"BOTH_WALK1",0}, 
+
+	{ &ui_char_model,			"ui_char_model",		"",0},	//these are filled in by the "g_*" versions on load
+	{ &ui_char_skin_head,		"ui_char_skin_head",	"",0},	//the "g_*" versions are initialized in UI_Init, ui_atoms.cpp
+	{ &ui_char_skin_torso,		"ui_char_skin_torso",	"",0}, 
+	{ &ui_char_skin_legs,		"ui_char_skin_legs",	"",0}, 
+
+	{ &ui_saber_type,			"ui_saber_type",		"",0},
+	{ &ui_saber,				"ui_saber",				"",0}, 
+	{ &ui_saber2,				"ui_saber2",			"",0}, 
+	{ &ui_saber_color,			"ui_saber_color",		"",0}, 
+	{ &ui_saber2_color,			"ui_saber2_color",		"",0}, 
+
+	{ &ui_char_color_red,		"ui_char_color_red",	"", 0}, 
+	{ &ui_char_color_green,		"ui_char_color_green",	"", 0}, 
+	{ &ui_char_color_blue,		"ui_char_color_blue",	"", 0}, 
+
+	{ &ui_PrecacheModels,		"ui_PrecacheModels",	"1", CVAR_ARCHIVE}, 
+//JLFCALLOUT MPMOVED
+	{ &ui_hideAcallout,		"ui_hideAcallout",	"", 0}, 
+	{ &ui_hideBcallout,		"ui_hideBcallout",	"", 0}, 
+	{ &ui_hideXcallout,		"ui_hideXcallout",	"", 0}, 
+//END JLFCALLOUT
+};
+
+#define FP_UPDATED_NONE -1
+#define NOWEAPON -1
+
+static int cvarTableSize = sizeof(cvarTable) / sizeof(cvarTable[0]);
+
+void Text_Paint(float x, float y, float scale, vec4_t color, const char *text, int iMaxPixelWidth, int style, int iFontIndex);
+int Key_GetCatcher( void );
+
+#define	UI_FPS_FRAMES	4
+void _UI_Refresh( int realtime )
+{
+	static int index;
+	static int	previousTimes[UI_FPS_FRAMES];
+
+	if ( !( Key_GetCatcher() & KEYCATCH_UI ) ) 
+	{
+		return;
+	}
+
+	extern void SE_CheckForLanguageUpdates(void);
+	SE_CheckForLanguageUpdates();
+
+	if ( Menus_AnyFullScreenVisible() )
+	{//if not in full screen, don't mess with ghoul2
+		//rww - ghoul2 needs to know what time it is even if the client/server are not running
+		//FIXME: this screws up the game when you go back to the game...
+		G2API_SetTime(realtime, 0);
+		G2API_SetTime(realtime, 1);
+	}
+
+	uiInfo.uiDC.frameTime = realtime - uiInfo.uiDC.realTime;
+	uiInfo.uiDC.realTime = realtime;
+
+	previousTimes[index % UI_FPS_FRAMES] = uiInfo.uiDC.frameTime;
+	index++;
+	if ( index > UI_FPS_FRAMES ) 
+	{
+		int i, total;
+		// average multiple frames together to smooth changes out a bit
+		total = 0;
+		for ( i = 0 ; i < UI_FPS_FRAMES ; i++ ) 
+		{
+			total += previousTimes[i];
+		}
+		if ( !total ) 
+		{
+			total = 1;
+		}
+		uiInfo.uiDC.FPS = 1000 * UI_FPS_FRAMES / total;
+	}
+
+
+
+	UI_UpdateCvars();
+
+	if (Menu_Count() > 0) 
+	{
+		// paint all the menus
+		Menu_PaintAll();
+		// refresh server browser list
+//		UI_DoServerRefresh();
+		// refresh server status
+//		UI_BuildServerStatus(qfalse);
+		// refresh find player list
+//		UI_BuildFindPlayerList(qfalse);
+	} 
+
+#ifdef _XBOX
+	// display current map name
+	if (Cvar_VariableIntegerValue( "cl_maphack" ))
+	{
+		float rgba[4] = { 1.0f, 1.0f, 0.0f, 1.0f };
+		extern cvar_t *cl_mapname;
+		Text_Paint(130, 100, /* UI_FONT_DEFAULT, */ 0.9f, rgba, cl_mapname->string, 0, ITEM_TEXTSTYLE_NORMAL, 3);
+	}
+#endif
+
+#ifndef _XBOX
+	// draw cursor
+	UI_SetColor( NULL );
+	if (Menu_Count() > 0)
+	{
+		if (uiInfo.uiDC.cursorShow == qtrue)
+		{
+			UI_DrawHandlePic( uiInfo.uiDC.cursorx, uiInfo.uiDC.cursory, 48, 48, uiInfo.uiDC.Assets.cursor);
+		}
+	}
+#endif
+}
+
+/*
+===============
+UI_LoadMods
+===============
+*/
+static void UI_LoadMods() {
+	int		numdirs;
+	char	dirlist[2048];
+	char	*dirptr;
+  char  *descptr;
+	int		i;
+	int		dirlen;
+
+	uiInfo.modCount = 0;
+	numdirs = FS_GetFileList( "$modlist", "", dirlist, sizeof(dirlist) );
+	dirptr  = dirlist;
+	for( i = 0; i < numdirs; i++ ) {
+		dirlen = strlen( dirptr ) + 1;
+		descptr = dirptr + dirlen;
+		uiInfo.modList[uiInfo.modCount].modName = String_Alloc(dirptr);
+		uiInfo.modList[uiInfo.modCount].modDescr = String_Alloc(descptr);
+		dirptr += dirlen + strlen(descptr) + 1;
+		uiInfo.modCount++;
+		if (uiInfo.modCount >= MAX_MODS) {
+			break;
+		}
+	}
+
+}
+
+/*
+================
+vmMain
+
+This is the only way control passes into the module.
+This must be the very first function compiled into the .qvm file
+================
+*/
+int vmMain( int command, int arg0, int arg1, int arg2, int arg3, int arg4, int arg5, int arg6, int arg7, int arg8, int arg9, int arg10, int arg11  ) 
+{
+	return 0;
+}
+
+
+
+/*
+================
+Text_PaintChar
+================
+*/
+/*
+static void Text_PaintChar(float x, float y, float width, float height, float scale, float s, float t, float s2, float t2, qhandle_t hShader) 
+{
+	float w, h;
+
+	w = width * scale;
+	h = height * scale;
+	ui.R_DrawStretchPic((int)x, (int)y, w, h, s, t, s2, t2, hShader );	//make the coords (int) or else the chars bleed
+}
+*/
+
+/*
+================
+Text_Paint
+================
+*/
+// iMaxPixelWidth is 0 here for no limit (but gets converted to -1), else max printable pixel width relative to start pos
+//
+void Text_Paint(float x, float y, float scale, vec4_t color, const char *text, int iMaxPixelWidth, int style, int iFontIndex)
+{
+	if (iFontIndex == 0)
+	{
+		iFontIndex = uiInfo.uiDC.Assets.qhMediumFont;
+	}
+	// kludge.. convert JK2 menu styles to SOF2 printstring ctrl codes...
+	//
+	int iStyleOR = 0;
+	switch (style)
+	{
+//	case  ITEM_TEXTSTYLE_NORMAL:			iStyleOR = 0;break;					// JK2 normal text
+//	case  ITEM_TEXTSTYLE_BLINK:				iStyleOR = STYLE_BLINK;break;		// JK2 fast blinking
+	case  ITEM_TEXTSTYLE_PULSE:				iStyleOR = STYLE_BLINK;break;		// JK2 slow pulsing
+	case  ITEM_TEXTSTYLE_SHADOWED:			iStyleOR = STYLE_DROPSHADOW;break;	// JK2 drop shadow ( need a color for this )
+	case  ITEM_TEXTSTYLE_OUTLINED:			iStyleOR = STYLE_DROPSHADOW;break;	// JK2 drop shadow ( need a color for this )
+	case  ITEM_TEXTSTYLE_OUTLINESHADOWED:	iStyleOR = STYLE_DROPSHADOW;break;	// JK2 drop shadow ( need a color for this )
+	case  ITEM_TEXTSTYLE_SHADOWEDMORE:		iStyleOR = STYLE_DROPSHADOW;break;	// JK2 drop shadow ( need a color for this )
+	}
+
+	ui.R_Font_DrawString(	x,		// int ox
+							y,		// int oy
+							text,	// const char *text
+							color,	// paletteRGBA_c c
+							iStyleOR | iFontIndex,	// const int iFontHandle
+							!iMaxPixelWidth?-1:iMaxPixelWidth,	// iMaxPixelWidth (-1 = none)
+							scale	// const float scale = 1.0f
+							);
+}
+
+
+/*
+================
+Text_PaintWithCursor
+================
+*/
+// iMaxPixelWidth is 0 here for no-limit
+void Text_PaintWithCursor(float x, float y, float scale, vec4_t color, const char *text, int cursorPos, char cursor, int iMaxPixelWidth, int style, int iFontIndex) 
+{
+	Text_Paint(x, y, scale, color, text, iMaxPixelWidth, style, iFontIndex);
+
+	// now print the cursor as well...
+	//
+	char sTemp[1024];
+	int iCopyCount = min(strlen(text), cursorPos);
+		iCopyCount = min(iCopyCount,sizeof(sTemp));
+
+	// copy text into temp buffer for pixel measure...
+	//
+	strncpy(sTemp,text,iCopyCount);
+			sTemp[iCopyCount] = '\0';
+	
+	int iNextXpos  = ui.R_Font_StrLenPixels(sTemp, iFontIndex, scale );
+
+	Text_Paint(x+iNextXpos, y, scale, color, va("%c",cursor), iMaxPixelWidth, style|ITEM_TEXTSTYLE_BLINK, iFontIndex);
+}
+
+
+const char *UI_FeederItemText(float feederID, int index, int column, qhandle_t *handle) 
+{
+	*handle = -1;
+
+	if (feederID == FEEDER_SAVEGAMES) 
+	{
+		if (column==0)
+		{
+			return s_savedata[index].currentSaveFileComments;
+		}
+		else
+		{
+			return s_savedata[index].currentSaveFileDateTimeString;
+		}
+	}
+	else if (feederID == FEEDER_MOVES) 
+	{
+		return datapadMoveData[uiInfo.movesTitleIndex][index].title;
+	}
+	else if (feederID == FEEDER_MOVES_TITLES) 
+	{
+		return datapadMoveTitleData[index];
+	}
+	else if (feederID == FEEDER_PLAYER_SPECIES) 
+	{
+		return uiInfo.playerSpecies[index].Name;
+	} 
+	else if (feederID == FEEDER_LANGUAGES) 
+	{
+		return SE_GetLanguageName( index );
+	} 
+	else if (feederID == FEEDER_PLAYER_SKIN_HEAD)
+	{
+		if (index >= 0 && index < uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].SkinHeadCount) 
+		{
+			*handle = ui.R_RegisterShaderNoMip(va("models/players/%s/icon_%s.jpg", uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].Name, uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].SkinHeadNames[index]));
+			return uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].SkinHeadNames[index];
+		}
+	}
+	else if (feederID == FEEDER_PLAYER_SKIN_TORSO)
+	{
+		if (index >= 0 && index < uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].SkinTorsoCount) 
+		{
+			*handle = ui.R_RegisterShaderNoMip(va("models/players/%s/icon_%s.jpg", uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].Name, uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].SkinTorsoNames[index]));
+			return uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].SkinTorsoNames[index];
+		}
+	}
+	else if (feederID == FEEDER_PLAYER_SKIN_LEGS)
+	{
+		if (index >= 0 && index < uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].SkinLegCount) 
+		{
+			*handle = ui.R_RegisterShaderNoMip(va("models/players/%s/icon_%s.jpg", uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].Name, uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].SkinLegNames[index]));
+			return uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].SkinLegNames[index];
+		}
+	}
+	else if (feederID == FEEDER_COLORCHOICES)
+	{
+		if (index >= 0 && index < uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].ColorCount) 
+		{
+			*handle = ui.R_RegisterShaderNoMip( uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].ColorShader[index]);
+			return uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].ColorShader[index];
+		}
+	}
+	else if (feederID == FEEDER_MODS) 
+	{
+		if (index >= 0 && index < uiInfo.modCount) 
+		{
+			if (uiInfo.modList[index].modDescr && *uiInfo.modList[index].modDescr) 
+			{
+				return uiInfo.modList[index].modDescr;
+			} 
+			else 
+			{
+				return uiInfo.modList[index].modName;
+			}
+		}
+	} 
+
+	return "";
+}
+
+qhandle_t UI_FeederItemImage(float feederID, int index) 
+{
+	if (feederID == FEEDER_PLAYER_SKIN_HEAD) 
+	{
+		if (index >= 0 && index < uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].SkinHeadCount) 
+		{
+			//return uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].SkinHeadIcons[index];
+			return ui.R_RegisterShaderNoMip(va("models/players/%s/icon_%s.jpg", uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].Name, uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].SkinHeadNames[index]));
+		}
+	} 
+	else if (feederID == FEEDER_PLAYER_SKIN_TORSO) 
+	{
+		if (index >= 0 && index < uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].SkinTorsoCount) 
+		{
+			//return uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].SkinTorsoIcons[index];
+			return ui.R_RegisterShaderNoMip(va("models/players/%s/icon_%s.jpg", uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].Name, uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].SkinTorsoNames[index]));
+		}
+	} 
+	else if (feederID == FEEDER_PLAYER_SKIN_LEGS) 
+	{
+		if (index >= 0 && index < uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].SkinLegCount) 
+		{
+			//return uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].SkinLegIcons[index];
+			return ui.R_RegisterShaderNoMip(va("models/players/%s/icon_%s.jpg", uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].Name, uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].SkinLegNames[index]));
+		}
+	} 
+	else if (feederID == FEEDER_COLORCHOICES)
+	{
+		if (index >= 0 && index < uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].ColorCount) 
+		{
+			return ui.R_RegisterShaderNoMip( uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].ColorShader[index]);
+		}
+	}
+/*	else if (feederID == FEEDER_ALLMAPS || feederID == FEEDER_MAPS) 
+	{
+		int actual;
+		UI_SelectedMap(index, &actual);
+		index = actual;
+		if (index >= 0 && index < uiInfo.mapCount) 
+		{
+			if (uiInfo.mapList[index].levelShot == -1) 
+			{
+				uiInfo.mapList[index].levelShot = trap_R_RegisterShaderNoMip(uiInfo.mapList[index].imageName);
+			}
+			return uiInfo.mapList[index].levelShot;
+		}
+	}
+*/
+	return 0;
+}
+
+
+/*
+=================
+CreateNextSaveName
+=================
+*/
+static int CreateNextSaveName(char *fileName)
+{
+	int i;
+
+	// Loop through all the save games and look for the first open name
+	for (i=0;i<MAX_SAVELOADFILES;i++)
+	{
+		Com_sprintf( fileName, MAX_SAVELOADNAME, "jedi_%02d", i );
+
+		if (!ui.SG_GetSaveGameComment(fileName, NULL, NULL))
+		{
+			return qtrue;
+		}
+	}
+
+	return qfalse;
+}
+
+/*
+===============
+UI_DeferMenuScript
+
+Return true if the menu script should be deferred for later
+===============
+*/
+static qboolean UI_DeferMenuScript ( const char **args )
+{
+	const char* name;
+
+	// Whats the reason for being deferred?
+	if (!String_Parse(args, &name)) 
+	{
+		return qfalse;
+	}
+
+	// Handle the custom cases
+	if ( !Q_stricmp ( name, "VideoSetup" ) )
+	{
+		const char* warningMenuName;
+		qboolean	deferred;
+
+		// No warning menu specified
+		if ( !String_Parse(args, &warningMenuName) )
+		{
+			return qfalse;
+		}
+
+		// Defer if the video options were modified
+		deferred = Cvar_VariableIntegerValue( "ui_r_modified" ) ? qtrue : qfalse;
+
+		if ( deferred )
+		{
+			// Open the warning menu
+			Menus_OpenByName(warningMenuName);
+		}
+
+		return deferred;
+	}
+
+	return qfalse;
+}
+
+/*
+===============
+UI_RunMenuScript
+===============
+*/
+static qboolean UI_RunMenuScript ( const char **args ) 
+{
+	const char *name, *name2,*mapName,*menuName,*warningMenuName;
+
+	if (String_Parse(args, &name)) 
+	{
+		if (Q_stricmp(name, "resetdefaults") == 0)		
+		{
+			UI_ResetDefaults();
+		}
+		else if (Q_stricmp(name, "saveControls") == 0) 
+		{
+			Controls_SetConfig(qtrue);
+		} 
+		else if (Q_stricmp(name, "loadControls") == 0) 
+		{
+			Controls_GetConfig();
+		} 
+		else if (Q_stricmp(name, "clearError") == 0) 
+		{
+			Cvar_Set("com_errorMessage", "");
+		} 
+		else if (Q_stricmp(name, "ReadSaveDirectory") == 0) 
+		{
+			s_savegame.saveFileCnt = -1;	//force a refresh at drawtime
+//			ReadSaveDirectory();
+		} 
+		else if (Q_stricmp(name, "loadAuto") == 0) 
+		{
+			Menus_CloseAll();
+			ui.Cmd_ExecuteText( EXEC_APPEND, "load auto\n");	//load game menu
+		}
+		else if (Q_stricmp(name, "loadgame") == 0) 
+		{
+//JLFTODO  PUT THIS BACK (no!)
+//#ifdef _XBOX
+//				Menus_CloseAll();
+//				ui.Cmd_ExecuteText( EXEC_APPEND, va("load JKSG3\n"));
+//#else
+			if (s_savedata[s_savegame.currentLine].currentSaveFileName)// && (*s_file_desc_field.field.buffer))
+			{
+				Menus_CloseAll();
+				ui.Cmd_ExecuteText( EXEC_APPEND, va("load %s\n", s_savedata[s_savegame.currentLine].currentSaveFileName));
+			}
+			// after loading a game, the list box (and it's highlight) get's reset back to 0, but currentLine sticks around, so set it to 0 here
+			s_savegame.currentLine = 0;
+//#endif
+
+		}
+		else if (Q_stricmp(name, "deletegame") == 0) 
+		{
+			if (s_savedata[s_savegame.currentLine].currentSaveFileName)	// A line was chosen
+			{
+#ifndef FINAL_BUILD
+				ui.Printf( va("%s\n","Attempting to delete game"));
+#endif
+
+				ui.Cmd_ExecuteText( EXEC_NOW, va("wipe %s\n", s_savedata[s_savegame.currentLine].currentSaveFileName));
+				
+				if( (s_savegame.currentLine>0) && ((s_savegame.currentLine+1) == s_savegame.saveFileCnt) )
+				{
+					s_savegame.currentLine--;
+					// yeah this is a pretty bad hack
+					// adjust cursor position of listbox so correct item is highlighted
+					UI_AdjustSaveGameListBox( s_savegame.currentLine );			
+				}
+		
+//				ReadSaveDirectory();	//refresh
+				s_savegame.saveFileCnt = -1;	//force a refresh at drawtime
+
+			}
+		}
+		else if (Q_stricmp(name, "savegame") == 0) 
+		{
+			char fileName[MAX_SAVELOADNAME];
+			char description[64];
+			// Create a new save game
+//			if ( !s_savedata[s_savegame.currentLine].currentSaveFileName)	// No line was chosen
+			{
+//JLF MPNOTUSED
+#ifdef _XBOX
+				strcpy(fileName, "JKSG3");
+#else
+				CreateNextSaveName(fileName);	// Get a name to save to
+#endif
+			}
+//			else	// Overwrite a current save game? Ask first.
+			{
+//				s_savegame.yes.generic.flags	= QMF_HIGHLIGHT_IF_FOCUS;
+//				s_savegame.no.generic.flags		= QMF_HIGHLIGHT_IF_FOCUS;
+
+//				strcpy(fileName,s_savedata[s_savegame.currentLine].currentSaveFileName);
+//				s_savegame.awaitingSave = qtrue;
+//				s_savegame.deletegame.generic.flags	= QMF_GRAYED;	// Turn off delete button
+//				break;
+			}
+
+			// Save description line
+			ui.Cvar_VariableStringBuffer("ui_gameDesc",description,sizeof(description));
+			ui.SG_StoreSaveGameComment(description);
+
+			ui.Cmd_ExecuteText( EXEC_APPEND, va("save %s\n", fileName));
+			s_savegame.saveFileCnt = -1;	//force a refresh the next time around
+		}
+		else if (Q_stricmp(name, "LoadMods") == 0) 
+		{
+			UI_LoadMods();
+		} 
+		else if (Q_stricmp(name, "RunMod") == 0) 
+		{
+			if (uiInfo.modList[uiInfo.modIndex].modName)
+			{
+				Cvar_Set( "fs_game", uiInfo.modList[uiInfo.modIndex].modName);
+				extern	void FS_Restart( void );
+				FS_Restart();
+				Cbuf_ExecuteText( EXEC_APPEND, "vid_restart;" );
+			}
+		} 
+		else if (Q_stricmp(name, "Quit") == 0) 
+		{
+			Cbuf_ExecuteText( EXEC_NOW, "quit");
+		} 
+		else if (Q_stricmp(name, "Controls") == 0) 
+		{
+			Cvar_Set( "cl_paused", "1" );
+			trap_Key_SetCatcher( KEYCATCH_UI );
+			Menus_CloseAll();
+			Menus_ActivateByName("setup_menu2");
+		} 
+		else if (Q_stricmp(name, "Leave") == 0) 
+		{
+			Cbuf_ExecuteText( EXEC_APPEND, "disconnect\n" );
+			trap_Key_SetCatcher( KEYCATCH_UI );
+			Menus_CloseAll();
+			//Menus_ActivateByName("mainMenu");
+		} 
+		else if (Q_stricmp(name, "getvideosetup") == 0) 
+		{
+			UI_GetVideoSetup ( );
+		}
+		else if (Q_stricmp(name, "updatevideosetup") == 0)
+		{
+			UI_UpdateVideoSetup ( );
+		}
+		else if (Q_stricmp(name, "nextDataPadForcePower") == 0)		
+		{
+			ui.Cmd_ExecuteText( EXEC_APPEND, "dpforcenext\n");
+		}
+		else if (Q_stricmp(name, "prevDataPadForcePower") == 0)		
+		{
+			ui.Cmd_ExecuteText( EXEC_APPEND, "dpforceprev\n");
+		}
+		else if (Q_stricmp(name, "nextDataPadWeapon") == 0)		
+		{
+			ui.Cmd_ExecuteText( EXEC_APPEND, "dpweapnext\n");
+		}
+		else if (Q_stricmp(name, "prevDataPadWeapon") == 0)		
+		{
+			ui.Cmd_ExecuteText( EXEC_APPEND, "dpweapprev\n");
+		}
+		else if (Q_stricmp(name, "nextDataPadInventory") == 0)		
+		{
+			ui.Cmd_ExecuteText( EXEC_APPEND, "dpinvnext\n");
+		}
+		else if (Q_stricmp(name, "prevDataPadInventory") == 0)		
+		{
+			ui.Cmd_ExecuteText( EXEC_APPEND, "dpinvprev\n");
+		}
+		else if (Q_stricmp(name, "checkvid1data") == 0)		// Warn user data has changed before leaving screen?
+		{
+			String_Parse(args, &menuName);
+
+			String_Parse(args, &warningMenuName);
+
+			UI_CheckVid1Data(menuName,warningMenuName);
+		}
+		else if (Q_stricmp(name, "startgame") == 0) 
+		{
+			Menus_CloseAll();
+			if ( Cvar_VariableIntegerValue("com_demo") )
+			{
+				ui.Cmd_ExecuteText( EXEC_APPEND, "map demo\n");
+			}
+			else
+			{
+				ui.Cmd_ExecuteText( EXEC_APPEND, "map yavin1\n");
+			}
+		} 
+		else if (Q_stricmp(name, "startmap") == 0) 
+		{
+			Menus_CloseAll();
+
+			String_Parse(args, &mapName);
+
+			ui.Cmd_ExecuteText( EXEC_APPEND, va("maptransition %s\n",mapName));
+		} 
+		else if (Q_stricmp(name, "closeingame") == 0) 
+		{
+			trap_Key_SetCatcher( trap_Key_GetCatcher() & ~KEYCATCH_UI );
+			trap_Key_ClearStates();
+			Cvar_Set( "cl_paused", "0" );
+			Menus_CloseAll();
+
+			if (1 == Cvar_VariableIntegerValue("ui_missionfailed"))
+			{
+				Menus_ActivateByName("missionfailed_menu");
+				ui.Key_SetCatcher( KEYCATCH_UI );
+			}
+			else
+			{
+				Menus_ActivateByName("mainhud");
+			}
+		} 
+		else if (Q_stricmp(name, "closedatapad") == 0) 
+		{
+			trap_Key_SetCatcher( trap_Key_GetCatcher() & ~KEYCATCH_UI );
+			trap_Key_ClearStates();
+			Cvar_Set( "cl_paused", "0" );
+			Menus_CloseAll();
+			Menus_ActivateByName("mainhud");
+
+			Cvar_Set( "cg_updatedDataPadForcePower1", "0" );
+			Cvar_Set( "cg_updatedDataPadForcePower2", "0" );
+			Cvar_Set( "cg_updatedDataPadForcePower3", "0" );
+			Cvar_Set( "cg_updatedDataPadObjective", "0" );
+		} 
+		else if (Q_stricmp(name, "closesabermenu") == 0) 
+		{
+			// if we're in the saber menu when creating a character, close this down
+			if( !Cvar_VariableIntegerValue( "saber_menu" ) )
+			{
+				Menus_CloseByName( "saberMenu" );
+				Menus_OpenByName( "characterMenu" );
+			}
+		}
+		else if (Q_stricmp(name, "clearmouseover") == 0) 
+		{
+			itemDef_t *item;
+			menuDef_t *menu = Menu_GetFocused();
+
+			if (menu) 
+			{
+				const char *itemName;
+				String_Parse(args, &itemName);
+				item = (itemDef_s *) Menu_FindItemByName((menuDef_t *) menu, itemName);
+				if (item)
+				{
+					item->window.flags &= ~WINDOW_MOUSEOVER;
+				}
+			}
+		}
+		else if (Q_stricmp(name, "setMovesListDefault") == 0) 
+		{
+			uiInfo.movesTitleIndex = 2;
+		}
+		else if (Q_stricmp(name, "resetMovesDesc") == 0) 
+		{
+			menuDef_t *menu = Menu_GetFocused();
+			itemDef_t *item;
+
+			if (menu) 
+			{
+				item = (itemDef_s *) Menu_FindItemByName(menu, "item_desc");
+				if (item)
+				{
+					listBoxDef_t *listPtr = (listBoxDef_t*)item->typeData;
+					if( listPtr )
+					{
+						listPtr->cursorPos = 0;
+						listPtr->startPos = 0;
+					}
+					item->cursorPos = 0;					
+				}
+			}
+
+		}
+		else if (Q_stricmp(name, "resetMovesList") == 0) 
+		{
+			menuDef_t *menu;
+			menu = Menus_FindByName("datapadMovesMenu");
+			//update saber models
+			if (menu)
+			{
+				itemDef_t *item;
+				item = (itemDef_s *) Menu_FindItemByName((menuDef_t *) menu, "character");
+				if (item)
+				{
+					UI_SaberAttachToChar( item );
+				}
+			}
+
+			Cvar_Set( "ui_move_desc", " " );
+		}
+//		else if (Q_stricmp(name, "setanisotropicmax") == 0) 
+//		{
+//			r_ext_texture_filter_anisotropic->value;
+//		}
+		else if (Q_stricmp(name, "setMoveCharacter") == 0) 
+		{
+			itemDef_t *item;
+			menuDef_t *menu;
+			modelDef_t *modelPtr;
+			char skin[MAX_QPATH];
+
+			UI_GetCharacterCvars();
+			UI_GetSaberCvars();
+
+			uiInfo.movesTitleIndex = 0;
+
+			menu = Menus_FindByName("datapadMovesMenu");
+
+			if (menu)
+			{
+				item = (itemDef_s *) Menu_FindItemByName((menuDef_t *) menu, "character");
+				if (item)
+				{
+					modelPtr = (modelDef_t*)item->typeData;
+					if (modelPtr)
+					{
+						uiInfo.movesBaseAnim = datapadMoveTitleBaseAnims[uiInfo.movesTitleIndex];
+						ItemParse_model_g2anim_go( item, uiInfo.movesBaseAnim );
+
+						uiInfo.moveAnimTime = 0 ;
+						DC->g2hilev_SetAnim(&item->ghoul2[0], "model_root", modelPtr->g2anim, qtrue);
+						Com_sprintf( skin, sizeof( skin ), "models/players/%s/|%s|%s|%s", 
+															Cvar_VariableString ( "g_char_model"), 
+															Cvar_VariableString ( "g_char_skin_head"), 
+															Cvar_VariableString ( "g_char_skin_torso"), 
+															Cvar_VariableString ( "g_char_skin_legs") 
+									);
+
+						ItemParse_model_g2skin_go( item, skin );
+						UI_SaberAttachToChar( item );
+					}
+				}
+			}
+		}
+		else if (Q_stricmp(name, "glCustom") == 0) 
+		{
+			Cvar_Set("ui_r_glCustom", "4");
+		} 
+		else if (Q_stricmp(name, "character") == 0) 
+		{
+			UI_UpdateCharacter( qfalse );
+		}
+		else if (Q_stricmp(name, "characterchanged") == 0) 
+		{
+			UI_UpdateCharacter( qtrue );
+		}
+		else if (Q_stricmp(name, "char_skin") == 0) 
+		{
+			UI_UpdateCharacterSkin();
+		}
+		else if (Q_stricmp(name, "saber_type") == 0) 
+		{
+			UI_UpdateSaberType();
+		}
+		else if (Q_stricmp(name, "saber_hilt") == 0) 
+		{
+			UI_UpdateSaberHilt( qfalse );
+		}
+		else if (Q_stricmp(name, "saber_color") == 0) 
+		{
+//			UI_UpdateSaberColor( qfalse );
+		}
+		else if (Q_stricmp(name, "saber2_hilt") == 0) 
+		{
+			UI_UpdateSaberHilt( qtrue );
+		}
+		else if (Q_stricmp(name, "saber2_color") == 0) 
+		{
+//			UI_UpdateSaberColor( qtrue );
+		}
+		else if (Q_stricmp(name, "updatecharcvars") == 0) 
+		{
+			UI_UpdateCharacterCvars();
+		}
+		else if (Q_stricmp(name, "getcharcvars") == 0) 
+		{
+			UI_GetCharacterCvars();
+		}
+		else if (Q_stricmp(name, "updatesabercvars") == 0) 
+		{
+			UI_UpdateSaberCvars();
+		}
+		else if (Q_stricmp(name, "getsabercvars") == 0) 
+		{
+			UI_GetSaberCvars();
+		}
+		else if (Q_stricmp(name, "resetsabercvardefaults") == 0) 
+		{
+			// NOTE : ONLY do this if saber menu is set properly (ie. first time we enter this menu)
+			if( !Cvar_VariableIntegerValue( "saber_menu" ) )
+			{
+				UI_ResetSaberCvars();
+			}
+    	}
+		else if (Q_stricmp(name, "updatefightingstylechoices") == 0) 
+		{
+			UI_UpdateFightingStyleChoices();
+		}
+		else if (Q_stricmp(name, "initallocforcepower") == 0) 
+		{
+			const char *forceName;
+			String_Parse(args, &forceName);
+
+			UI_InitAllocForcePowers(forceName);
+		}
+		else if (Q_stricmp(name, "affectforcepowerlevel") == 0) 
+		{
+			const char *forceName;
+			String_Parse(args, &forceName);
+
+			UI_AffectForcePowerLevel(forceName);
+		}
+		else if (Q_stricmp(name, "decrementcurrentforcepower") == 0) 
+		{
+			UI_DecrementCurrentForcePower();
+		}
+		else if (Q_stricmp(name, "shutdownforcehelp") == 0) 
+		{
+			UI_ShutdownForceHelp();
+		}
+		else if (Q_stricmp(name, "forcehelpactive") == 0) 
+		{
+			UI_ForceHelpActive();
+		}
+		else if (Q_stricmp(name, "showforceleveldesc") == 0) 
+		{
+			const char *forceName;
+			String_Parse(args, &forceName);
+
+			UI_ShowForceLevelDesc(forceName);
+		}
+		else if (Q_stricmp(name, "resetforcelevels") == 0) 
+		{
+			UI_ResetForceLevels();
+		}
+		else if (Q_stricmp(name, "weaponhelpactive") == 0) 
+		{
+			UI_WeaponHelpActive();
+		}
+		// initialize weapon selection screen
+		else if (Q_stricmp(name, "initweaponselect") == 0) 
+		{
+			UI_InitWeaponSelect();
+		}
+		else if (Q_stricmp(name, "clearweapons") == 0) 
+		{
+			UI_ClearWeapons();
+		}
+		else if (Q_stricmp(name, "stopgamesounds") == 0) 
+		{
+			trap_S_StopSounds();
+		}
+		else if (Q_stricmp(name, "loadmissionselectmenu") == 0) 
+		{
+			const char *cvarName;
+			String_Parse(args, &cvarName);
+
+			if (cvarName)
+			{
+				UI_LoadMissionSelectMenu(cvarName);
+			}
+		}
+		else if (Q_stricmp(name, "calcforcestatus") == 0) 
+		{
+			UI_CalcForceStatus();
+		}
+		else if (Q_stricmp(name, "giveweapon") == 0) 
+		{
+			const char *weaponIndex;
+			String_Parse(args, &weaponIndex);
+			UI_GiveWeapon(atoi(weaponIndex));
+		}
+		else if (Q_stricmp(name, "equipweapon") == 0) 
+		{
+			const char *weaponIndex;
+			String_Parse(args, &weaponIndex);
+			UI_EquipWeapon(atoi(weaponIndex));
+		}
+		else if (Q_stricmp(name, "addweaponselection") == 0) 
+		{
+			const char *weaponIndex;
+			String_Parse(args, &weaponIndex);
+			if (!weaponIndex)
+			{ 
+				return qfalse;
+			}
+
+			const char *ammoIndex;
+			String_Parse(args, &ammoIndex);
+			if (!ammoIndex)
+			{ 
+				return qfalse;
+			}
+
+			const char *ammoAmount;
+			String_Parse(args, &ammoAmount);
+			if (!ammoAmount)
+			{ 
+				return qfalse;
+			}
+
+			const char *itemName;
+			String_Parse(args, &itemName);
+			if (!itemName)
+			{ 
+				return qfalse;
+			}
+
+			const char *litItemName;
+			String_Parse(args, &litItemName);
+			if (!litItemName)
+			{ 
+				return qfalse;
+			}
+
+			const char *backgroundName;
+			String_Parse(args, &backgroundName);
+			if (!backgroundName)
+			{ 
+				return qfalse;
+			}
+
+			const char *soundfile = NULL;
+			String_Parse(args, &soundfile);
+			
+			UI_AddWeaponSelection(atoi(weaponIndex),atoi(ammoIndex),atoi(ammoAmount),itemName,litItemName, backgroundName, soundfile);
+		}
+		else if (Q_stricmp(name, "addthrowweaponselection") == 0) 
+		{
+			const char *weaponIndex;
+			String_Parse(args, &weaponIndex);
+			if (!weaponIndex)
+			{ 
+				return qfalse;
+			}
+
+			const char *ammoIndex;
+			String_Parse(args, &ammoIndex);
+			if (!ammoIndex)
+			{ 
+				return qfalse;
+			}
+
+			const char *ammoAmount;
+			String_Parse(args, &ammoAmount);
+			if (!ammoAmount)
+			{ 
+				return qfalse;
+			}
+
+			const char *itemName;
+			String_Parse(args, &itemName);
+			if (!itemName)
+			{ 
+				return qfalse;
+			}
+
+			const char *litItemName;
+			String_Parse(args, &litItemName);
+			if (!litItemName)
+			{ 
+				return qfalse;
+			}
+
+			const char *backgroundName;
+			String_Parse(args, &backgroundName);
+			if (!backgroundName)
+			{ 
+				return qfalse;
+			}
+
+			const char *soundfile;
+			String_Parse(args, &soundfile);
+
+			UI_AddThrowWeaponSelection(atoi(weaponIndex),atoi(ammoIndex),atoi(ammoAmount),itemName,litItemName,backgroundName, soundfile);
+		}
+		else if (Q_stricmp(name, "removeweaponselection") == 0) 
+		{
+			const char *weaponIndex;
+			String_Parse(args, &weaponIndex);
+			if (weaponIndex)
+			{
+				UI_RemoveWeaponSelection(atoi(weaponIndex));
+			}
+		}
+		else if (Q_stricmp(name, "removethrowweaponselection") == 0) 
+		{
+			UI_RemoveThrowWeaponSelection();
+		}
+		else if (Q_stricmp(name, "normalthrowselection") == 0) 
+		{
+			UI_NormalThrowSelection();
+		}
+		else if (Q_stricmp(name, "highlightthrowselection") == 0) 
+		{
+			UI_HighLightThrowSelection();
+		}
+		else if (Q_stricmp(name, "normalweaponselection") == 0) 
+		{
+			const char *slotIndex;
+			String_Parse(args, &slotIndex);
+			if (!slotIndex)
+			{ 
+				return qfalse;
+			}
+
+			UI_NormalWeaponSelection(atoi(slotIndex));
+		}
+		else if (Q_stricmp(name, "highlightweaponselection") == 0) 
+		{
+			const char *slotIndex;
+			String_Parse(args, &slotIndex);
+			if (!slotIndex)
+			{ 
+				return qfalse;
+			}
+
+			UI_HighLightWeaponSelection(atoi(slotIndex));
+		}
+		else if (Q_stricmp(name, "clearinventory") == 0) 
+		{
+			UI_ClearInventory();
+		}
+		else if (Q_stricmp(name, "giveinventory") == 0) 
+		{
+			const char *inventoryIndex,*amount;
+			String_Parse(args, &inventoryIndex);
+			String_Parse(args, &amount);
+			UI_GiveInventory(atoi(inventoryIndex),atoi(amount));
+		}
+		else if (Q_stricmp(name, "updatefightingstyle") == 0) 
+		{
+			UI_UpdateFightingStyle();
+		}
+		else if (Q_stricmp(name, "update") == 0) 
+		{
+			if (String_Parse(args, &name2)) 
+			{
+				UI_Update(name2);
+			}
+			else 
+			{
+				Com_Printf("update missing cmd\n");
+			}
+		}
+		else if (Q_stricmp(name, "load_quick") == 0) 
+		{
+			ui.Cmd_ExecuteText(EXEC_APPEND,"load quick\n");
+		}
+		else if (Q_stricmp(name, "load_auto") == 0) 
+		{
+			ui.Cmd_ExecuteText(EXEC_APPEND,"load *respawn\n");	//death menu, might load a saved game instead if they just loaded on this map
+		}
+		else if (Q_stricmp(name, "decrementforcepowerlevel") == 0) 
+		{
+			UI_DecrementForcePowerLevel();
+		}
+		else if (Q_stricmp(name, "getmousepitch") == 0)
+		{
+			Cvar_Set("ui_mousePitch", (trap_Cvar_VariableValue("m_pitch") >= 0) ? "0" : "1");
+		}
+		else if (Q_stricmp(name, "resetcharacterlistboxes") == 0)
+		{
+			UI_ResetCharacterListBoxes();
+		}
+#ifdef _XBOX
+		else if (Q_stricmp(name, "multiplayer") == 0)
+		{
+			extern void Sys_Reboot( const char *reason );
+			Sys_Reboot("multiplayer");
+		}
+#endif
+		else 
+		{
+			Com_Printf("unknown UI script %s\n", name);
+		}
+	}
+
+	return qtrue;
+}
+
+/*
+=================
+UI_GetValue
+=================
+*/
+static float UI_GetValue(int ownerDraw) 
+{
+  return 0;
+}
+
+//Force Warnings
+typedef enum
+{
+	FW_VERY_LIGHT = 0,
+	FW_SEMI_LIGHT,
+	FW_NEUTRAL,
+	FW_SEMI_DARK,
+	FW_VERY_DARK
+};
+
+const char *lukeForceStatusSounds[] =
+{
+"sound/chars/luke/misc/MLUK_03.mp3",	// Very Light
+"sound/chars/luke/misc/MLUK_04.mp3",	// Semi Light
+"sound/chars/luke/misc/MLUK_05.mp3",	// Neutral
+"sound/chars/luke/misc/MLUK_01.mp3",	// Semi dark
+"sound/chars/luke/misc/MLUK_02.mp3",	// Very dark
+};
+
+const char *kyleForceStatusSounds[] =
+{
+"sound/chars/kyle/misc/MKYK_05.mp3",	// Very Light
+"sound/chars/kyle/misc/MKYK_04.mp3",	// Semi Light
+"sound/chars/kyle/misc/MKYK_03.mp3",	// Neutral
+"sound/chars/kyle/misc/MKYK_01.mp3",	// Semi dark
+"sound/chars/kyle/misc/MKYK_02.mp3",	// Very dark
+};
+
+
+static void UI_CalcForceStatus(void)
+{
+	float		lightSide,darkSide,total;
+	short		who, index=FW_VERY_LIGHT;
+	qboolean	lukeFlag=qtrue;
+	float		percent;
+	client_t*	cl = &svs.clients[0];	// 0 because only ever us as a player	
+	char		value[256];
+
+	if (!cl)
+	{
+		return;
+	}
+	playerState_t*		pState = cl->gentity->client;
+
+	if (!cl->gentity || !cl->gentity->client)
+	{
+		return;
+	}
+
+	memset(value, 0, sizeof(value));
+
+	lightSide = pState->forcePowerLevel[FP_HEAL] + 
+		pState->forcePowerLevel[FP_TELEPATHY] +
+		pState->forcePowerLevel[FP_PROTECT] +
+		pState->forcePowerLevel[FP_ABSORB];
+	
+	darkSide = pState->forcePowerLevel[FP_GRIP] + 
+		pState->forcePowerLevel[FP_LIGHTNING] +
+		pState->forcePowerLevel[FP_RAGE] +
+		pState->forcePowerLevel[FP_DRAIN];
+	
+	total = lightSide + darkSide;
+
+	percent = lightSide / total;
+
+	who = Q_irand( 0, 100 );
+	if (percent >= 0.90f)	//  90 - 100%
+	{
+		index = FW_VERY_LIGHT;
+		if (who <50)
+		{
+			strcpy(value,"vlk");	// Very light Kyle
+			lukeFlag = qfalse;
+		}
+		else
+		{
+			strcpy(value,"vll");	// Very light Luke
+		}
+
+	}
+	else if (percent > 0.60f )
+	{
+		index = FW_SEMI_LIGHT;
+		if ( who<50 )
+		{
+			strcpy(value,"slk");	// Semi-light Kyle
+			lukeFlag = qfalse;
+		}
+		else
+		{
+			strcpy(value,"sll");	// Semi-light light Luke
+		}
+	}
+	else if (percent > 0.40f )
+	{
+		index = FW_NEUTRAL;
+		if ( who<50 )
+		{
+			strcpy(value,"ntk");	// Neutral Kyle
+			lukeFlag = qfalse;
+		}
+		else
+		{
+			strcpy(value,"ntl");	// Netural Luke
+		}
+	}
+	else if (percent > 0.10f )
+	{
+		index = FW_SEMI_DARK;
+		if ( who<50 )
+		{
+			strcpy(value,"sdk");	// Semi-dark Kyle
+			lukeFlag = qfalse;
+		}
+		else
+		{
+			strcpy(value,"sdl");	// Semi-Dark Luke
+		}
+	}
+	else 
+	{
+		index = FW_VERY_DARK;
+		if ( who<50 )
+		{
+			strcpy(value,"vdk");	// Very dark Kyle
+			lukeFlag = qfalse;
+		}
+		else
+		{
+			strcpy(value,"vdl");	// Very Dark Luke
+		}
+	}
+
+	Cvar_Set("ui_forcestatus", value );
+
+	if (lukeFlag)
+	{
+		DC->startLocalSound(DC->registerSound(lukeForceStatusSounds[index], qfalse), CHAN_VOICE );
+	}
+	else
+	{
+		DC->startLocalSound(DC->registerSound(kyleForceStatusSounds[index], qfalse), CHAN_VOICE );
+	}
+}
+
+/*
+=================
+UI_StopCinematic
+=================
+*/
+static void UI_StopCinematic(int handle) 
+{
+	if (handle >= 0) 
+	{
+		trap_CIN_StopCinematic(handle);
+	} 
+	else 
+	{
+		handle = abs(handle);
+		if (handle == UI_MAPCINEMATIC) 
+		{
+			// FIXME - BOB do we need this?
+//			if (uiInfo.mapList[ui_currentMap.integer].cinematic >= 0) 
+//			{
+//				trap_CIN_StopCinematic(uiInfo.mapList[ui_currentMap.integer].cinematic);
+//				uiInfo.mapList[ui_currentMap.integer].cinematic = -1;
+//			}
+		} 
+		else if (handle == UI_NETMAPCINEMATIC) 
+		{
+			// FIXME - BOB do we need this?
+//			if (uiInfo.serverStatus.currentServerCinematic >= 0) 
+//			{
+//				trap_CIN_StopCinematic(uiInfo.serverStatus.currentServerCinematic);
+//				uiInfo.serverStatus.currentServerCinematic = -1;
+//			}
+		} 
+		else if (handle == UI_CLANCINEMATIC) 
+		{
+			// FIXME - BOB do we need this?
+//			int i = UI_TeamIndexFromName(UI_Cvar_VariableString("ui_teamName"));
+//			if (i >= 0 && i < uiInfo.teamCount) 
+//			{
+//				if (uiInfo.teamList[i].cinematic >= 0) 
+//				{
+//					trap_CIN_StopCinematic(uiInfo.teamList[i].cinematic);
+//					uiInfo.teamList[i].cinematic = -1;
+//				}
+//			}
+		}
+	}
+}
+static void UI_HandleLoadSelection()
+{
+	Cvar_Set("ui_SelectionOK", va("%d",(s_savegame.currentLine < s_savegame.saveFileCnt)) );
+	if (s_savegame.currentLine >= s_savegame.saveFileCnt)
+		return;
+//	Cvar_Set("ui_gameDesc", s_savedata[s_savegame.currentLine].currentSaveFileComments );	// set comment 
+
+#ifdef _XBOX
+	void R_UpdateSaveGameImage(const char *filename);
+	//create the correctfilename
+	unsigned short saveGameName[filepathlength];
+	char directoryInfo[filepathlength];
+	char psLocalFilename[filepathlength];
+
+	
+	mbstowcs(saveGameName, s_savedata[s_savegame.currentLine].currentSaveFileName, filepathlength);
+
+	XCreateSaveGame("U:\\", saveGameName, OPEN_ALWAYS, 0,directoryInfo, filepathlength);
+
+	strcpy (psLocalFilename , directoryInfo);
+	strcat (psLocalFilename , "saveimage.xbx");
+
+
+	R_UpdateSaveGameImage(psLocalFilename);
+#else
+/*	if (!ui.SG_GetSaveImage(s_savedata[s_savegame.currentLine].currentSaveFileName, &screenShotBuf))
+>>>>>>> 1.30
+	{
+		memset( screenShotBuf,0,(SG_SCR_WIDTH * SG_SCR_HEIGHT * 4)); 
+	}
+*/
+#endif
+}
+
+/*
+=================
+UI_FeederCount
+=================
+*/
+static int UI_FeederCount(float feederID) 
+{
+#ifdef _XBOX 
+//JLF MPNOTNEEDED
+	static bool firstSaveRequest = true;
+#endif
+
+	if (feederID == FEEDER_SAVEGAMES ) 
+	{
+//JLF MPNOTNEEDED
+#ifdef _XBOX 
+		if (s_savegame.saveFileCnt == -1 || firstSaveRequest)
+		{
+			firstSaveRequest = false;
+#else
+		if (s_savegame.saveFileCnt == -1)
+		{
+#endif
+
+			ReadSaveDirectory();	//refresh
+			UI_HandleLoadSelection();
+			UI_AdjustSaveGameListBox(s_savegame.currentLine);
+		}
+		return s_savegame.saveFileCnt;
+	} 
+	// count number of moves for the current title
+	else if (feederID == FEEDER_MOVES) 
+	{
+		int count=0,i;
+
+		for (i=0;i<MAX_MOVES;i++)
+		{
+			if (datapadMoveData[uiInfo.movesTitleIndex][i].title)
+			{
+				count++;
+			}
+		}
+
+		return count;
+	}
+	else if (feederID == FEEDER_MOVES_TITLES) 
+	{
+		return (MD_MOVE_TITLE_MAX);
+	}
+	else if (feederID == FEEDER_MODS) 
+	{
+		return uiInfo.modCount;
+	} 
+	else if (feederID == FEEDER_LANGUAGES) 
+	{
+		return uiInfo.languageCount;
+	} 
+	else if (feederID == FEEDER_PLAYER_SPECIES) 
+	{
+		return uiInfo.playerSpeciesCount;
+	} 
+	else if (feederID == FEEDER_PLAYER_SKIN_HEAD) 
+	{
+		return uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].SkinHeadCount;
+	} 
+	else if (feederID == FEEDER_PLAYER_SKIN_TORSO) 
+	{
+		return uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].SkinTorsoCount;
+	} 
+	else if (feederID == FEEDER_PLAYER_SKIN_LEGS) 
+	{
+		return uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].SkinLegCount;
+	} 
+	else if (feederID == FEEDER_COLORCHOICES)
+	{
+		return uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].ColorCount;
+	}
+
+	return 0;
+}
+
+/*
+=================
+UI_FeederSelection
+=================
+*/
+static void UI_FeederSelection(float feederID, int index, itemDef_t *item) 
+{
+	static char info[MAX_STRING_CHARS];
+
+	if (feederID == FEEDER_SAVEGAMES) 
+	{
+		s_savegame.currentLine = index;
+		UI_HandleLoadSelection();
+	} 
+	else if (feederID == FEEDER_MOVES) 
+	{
+		itemDef_t *item;
+		menuDef_t *menu;
+		modelDef_t *modelPtr;
+		char skin[MAX_QPATH];
+
+		menu = Menus_FindByName("datapadMovesMenu");
+
+		if (menu)
+		{
+			item = (itemDef_s *) Menu_FindItemByName((menuDef_t *) menu, "character");
+			if (item)
+			{
+				modelPtr = (modelDef_t*)item->typeData;
+				if (modelPtr)
+				{
+					if (datapadMoveData[uiInfo.movesTitleIndex][index].anim)
+					{
+						ItemParse_model_g2anim_go( item, datapadMoveData[uiInfo.movesTitleIndex][index].anim );
+						uiInfo.moveAnimTime = DC->g2hilev_SetAnim(&item->ghoul2[0], "model_root", modelPtr->g2anim, qtrue);
+
+						uiInfo.moveAnimTime += uiInfo.uiDC.realTime;
+
+						// Play sound for anim
+						if (datapadMoveData[uiInfo.movesTitleIndex][index].sound == MDS_FORCE_JUMP)
+						{
+							DC->startLocalSound(uiInfo.uiDC.Assets.datapadmoveJumpSound, CHAN_LOCAL );
+						}
+						else if (datapadMoveData[uiInfo.movesTitleIndex][index].sound == MDS_ROLL)
+						{
+							DC->startLocalSound(uiInfo.uiDC.Assets.datapadmoveRollSound, CHAN_LOCAL );
+						}
+						else if (datapadMoveData[uiInfo.movesTitleIndex][index].sound == MDS_SABER)
+						{
+							// Randomly choose one sound
+							int soundI = Q_irand( 1, 6 );
+							sfxHandle_t *soundPtr;
+							soundPtr = &uiInfo.uiDC.Assets.datapadmoveSaberSound1;
+							if (soundI == 2)
+							{
+								soundPtr = &uiInfo.uiDC.Assets.datapadmoveSaberSound2;
+							}
+							else if (soundI == 3)
+							{
+								soundPtr = &uiInfo.uiDC.Assets.datapadmoveSaberSound3;
+							}
+							else if (soundI == 4)
+							{
+								soundPtr = &uiInfo.uiDC.Assets.datapadmoveSaberSound4;
+							}
+							else if (soundI == 5)
+							{
+								soundPtr = &uiInfo.uiDC.Assets.datapadmoveSaberSound5;
+							}
+							else if (soundI == 6)
+							{
+								soundPtr = &uiInfo.uiDC.Assets.datapadmoveSaberSound6;
+							}
+
+							DC->startLocalSound(*soundPtr, CHAN_LOCAL );
+						}
+
+						if (datapadMoveData[uiInfo.movesTitleIndex][index].desc)
+						{
+							Cvar_Set( "ui_move_desc", datapadMoveData[uiInfo.movesTitleIndex][index].desc);
+						}
+
+						Com_sprintf( skin, sizeof( skin ), "models/players/%s/|%s|%s|%s", 
+															Cvar_VariableString ( "g_char_model"), 
+															Cvar_VariableString ( "g_char_skin_head"), 
+															Cvar_VariableString ( "g_char_skin_torso"), 
+															Cvar_VariableString ( "g_char_skin_legs") 
+									);
+
+						ItemParse_model_g2skin_go( item, skin );
+
+					}
+				}
+			}
+		}
+	} 
+	else if (feederID == FEEDER_MOVES_TITLES) 
+	{
+		itemDef_t *item;
+		menuDef_t *menu;
+		modelDef_t *modelPtr;
+
+		uiInfo.movesTitleIndex = index;
+		uiInfo.movesBaseAnim = datapadMoveTitleBaseAnims[uiInfo.movesTitleIndex];
+		menu = Menus_FindByName("datapadMovesMenu");
+
+		if (menu)
+		{
+			item = (itemDef_s *) Menu_FindItemByName((menuDef_t *) menu, "character");
+			if (item)
+			{
+				modelPtr = (modelDef_t*)item->typeData;
+				if (modelPtr)
+				{
+					ItemParse_model_g2anim_go( item, uiInfo.movesBaseAnim );
+					uiInfo.moveAnimTime = DC->g2hilev_SetAnim(&item->ghoul2[0], "model_root", modelPtr->g2anim, qtrue);
+				}
+			}
+		}
+	}
+	else if (feederID == FEEDER_MODS) 
+	{
+		uiInfo.modIndex = index;
+	} 
+	else if (feederID == FEEDER_PLAYER_SPECIES) 
+	{
+		uiInfo.playerSpeciesIndex = index;
+	} 
+	else if (feederID == FEEDER_LANGUAGES) 
+	{
+		uiInfo.languageCountIndex = index;
+	} 
+	else if (feederID == FEEDER_PLAYER_SKIN_HEAD) 
+	{
+		if (index >= 0 && index < uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].SkinHeadCount)
+		{
+			Cvar_Set("ui_char_skin_head", uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].SkinHeadNames[index]);
+		}
+	} 
+	else if (feederID == FEEDER_PLAYER_SKIN_TORSO) 
+	{
+		if (index >= 0 && index < uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].SkinTorsoCount)
+		{
+			Cvar_Set("ui_char_skin_torso", uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].SkinTorsoNames[index]);
+		}
+	} 
+	else if (feederID == FEEDER_PLAYER_SKIN_LEGS) 
+	{
+		if (index >= 0 && index < uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].SkinLegCount)
+		{
+			Cvar_Set("ui_char_skin_legs", uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].SkinLegNames[index]);
+		}
+	} 
+	else if (feederID == FEEDER_COLORCHOICES)
+	{
+extern void	Item_RunScript(itemDef_t *item, const char *s);		//from ui_shared;
+		if (index >= 0 && index < uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].ColorCount)
+		{
+			Item_RunScript(item, uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].ColorActionText[index]);
+		}
+	}
+/*	else if (feederID == FEEDER_CINEMATICS) 
+	{
+		uiInfo.movieIndex = index;
+		if (uiInfo.previewMovie >= 0) 
+		{
+			trap_CIN_StopCinematic(uiInfo.previewMovie);
+		}
+		uiInfo.previewMovie = -1;
+	} 
+	else if (feederID == FEEDER_DEMOS) 
+	{
+		uiInfo.demoIndex = index;
+	}
+*/
+}
+
+void Key_KeynumToStringBuf( int keynum, char *buf, int buflen );
+void Key_GetBindingBuf( int keynum, char *buf, int buflen );
+
+static qboolean UI_Crosshair_HandleKey(int flags, float *special, int key) 
+{
+  if (key == A_MOUSE1 || key == A_MOUSE2 || key == A_ENTER || key == A_KP_ENTER) 
+  {
+		if (key == A_MOUSE2) 
+		{
+			uiInfo.currentCrosshair--;
+		} else {
+			uiInfo.currentCrosshair++;
+		}
+
+		if (uiInfo.currentCrosshair >= NUM_CROSSHAIRS) {
+			uiInfo.currentCrosshair = 0;
+		} else if (uiInfo.currentCrosshair < 0) {
+			uiInfo.currentCrosshair = NUM_CROSSHAIRS - 1;
+		}
+		Cvar_Set("cg_drawCrosshair", va("%d", uiInfo.currentCrosshair)); 
+		return qtrue;
+	}
+	return qfalse;
+}
+
+
+static qboolean UI_OwnerDrawHandleKey(int ownerDraw, int flags, float *special, int key) 
+{
+
+	switch (ownerDraw) 
+	{
+		case UI_CROSSHAIR:
+			UI_Crosshair_HandleKey(flags, special, key);
+			break;
+		default:
+			break;
+	}
+
+  return qfalse;
+}
+
+//unfortunately we cannot rely on any game/cgame module code to do our animation stuff,
+//because the ui can be loaded while the game/cgame are not loaded. So we're going to recreate what we need here.
+// On Xbox, we need all the RAM we can get, and this is huge. So we just borrow the one from level. I hope
+// this doesn't cause some apocalypse. Getting access to level in here is nigh impossible, as we'd have to
+// include g_local.h, and the consequences of that are bad. So: This pointer is initialized in a global constructor
+// in class UIAnimFileSetInitializer in g_main.cpp! Look there! Don't forget!
+//#ifdef _XBOX
+//animFileSet_t	*ui_knownAnimFileSets = NULL;
+//#else
+#undef MAX_ANIM_FILES
+#define MAX_ANIM_FILES 4
+typedef struct
+{
+	char			filename[MAX_QPATH];
+	animation_t		animations[MAX_ANIMATIONS];
+} animFileSet_t;
+static animFileSet_t	ui_knownAnimFileSets[MAX_ANIM_FILES];
+//#endif
+
+int				ui_numKnownAnimFileSets;
+
+qboolean UI_ParseAnimationFile( const char *af_filename ) 
+{
+	const char		*text_p;
+	int			len;
+	int			i;
+	const char		*token;
+	float		fps;
+	int			skip;
+	char		text[80000];
+	int			animNum;
+	animation_t	*animations = ui_knownAnimFileSets[ui_numKnownAnimFileSets].animations;
+
+	len = re.GetAnimationCFG(af_filename, text, sizeof(text));
+	if ( len <= 0 ) 
+	{
+		return qfalse;
+	}
+	if ( len >= sizeof( text ) - 1 ) 
+	{
+		Com_Error( ERR_FATAL, "UI_ParseAnimationFile: File %s too long\n (%d > %d)", af_filename, len, sizeof( text ) - 1);
+		return qfalse;
+	}
+
+	// parse the text
+	text_p = text;
+	skip = 0;	// quiet the compiler warning
+
+	//FIXME: have some way of playing anims backwards... negative numFrames?
+
+	//initialize anim array so that from 0 to MAX_ANIMATIONS, set default values of 0 1 0 100
+	for(i = 0; i < MAX_ANIMATIONS; i++)
+	{
+		animations[i].firstFrame = 0;
+		animations[i].numFrames = 0;
+		animations[i].loopFrames = -1;
+		animations[i].frameLerp = 100;
+//		animations[i].initialLerp = 100;
+	}
+
+	// read information for each frame
+	while(1) 
+	{
+		token = COM_Parse( &text_p );
+
+		if ( !token || !token[0]) 
+		{
+			break;
+		}
+
+		animNum = GetIDForString(animTable, token);
+		if(animNum == -1)
+		{
+//#ifndef FINAL_BUILD
+#ifdef _DEBUG
+			if (strcmp(token,"ROOT"))
+			{
+				Com_Printf(S_COLOR_RED"WARNING: Unknown token %s in %s\n", token, af_filename);
+			}
+#endif
+			while (token[0])
+			{
+				token = COM_ParseExt( &text_p, qfalse );	//returns empty string when next token is EOL
+			}
+			continue;
+		}
+
+		token = COM_Parse( &text_p );
+		if ( !token ) 
+		{
+			break;
+		}
+		animations[animNum].firstFrame = atoi( token );
+
+		token = COM_Parse( &text_p );
+		if ( !token ) 
+		{
+			break;
+		}
+		animations[animNum].numFrames = atoi( token );
+
+		token = COM_Parse( &text_p );
+		if ( !token ) 
+		{
+			break;
+		}
+		animations[animNum].loopFrames = atoi( token );
+
+		token = COM_Parse( &text_p );
+		if ( !token ) 
+		{
+			break;
+		}
+		fps = atof( token );
+		if ( fps == 0 ) 
+		{
+			fps = 1;//Don't allow divide by zero error
+		}
+		if ( fps < 0 )
+		{//backwards
+			animations[animNum].frameLerp = floor(1000.0f / fps);
+		}
+		else
+		{
+			animations[animNum].frameLerp = ceil(1000.0f / fps);
+		}
+
+//		animations[animNum].initialLerp = ceil(1000.0f / fabs(fps));
+	}
+
+	return qtrue;
+}
+
+qboolean UI_ParseAnimFileSet( const char *animCFG, int *animFileIndex )
+{ //Not going to bother parsing the sound config here.
+	char		afilename[MAX_QPATH];
+	char		strippedName[MAX_QPATH];
+	int			i;
+	char		*slash;
+
+	Q_strncpyz( strippedName, animCFG, sizeof(strippedName), qtrue);
+	slash = strrchr( strippedName, '/' );
+	if ( slash ) 
+	{
+		// truncate modelName to find just the dir not the extension
+		*slash = 0;
+	}
+
+	//if this anims file was loaded before, don't parse it again, just point to the correct table of info
+	for ( i = 0; i < ui_numKnownAnimFileSets; i++ )
+	{
+		if ( Q_stricmp(ui_knownAnimFileSets[i].filename, strippedName ) == 0 )
+		{
+			*animFileIndex = i;
+			return qtrue;
+		}
+	}
+
+	if ( ui_numKnownAnimFileSets == MAX_ANIM_FILES )
+	{//TOO MANY!
+		for (i = 0; i < MAX_ANIM_FILES; i++)
+		{
+			Com_Printf("animfile[%d]: %s\n", i, ui_knownAnimFileSets[i].filename);
+		}
+		Com_Error( ERR_FATAL, "UI_ParseAnimFileSet: %d == MAX_ANIM_FILES == %d", ui_numKnownAnimFileSets, MAX_ANIM_FILES);
+	}
+
+	//Okay, time to parse in a new one
+	Q_strncpyz( ui_knownAnimFileSets[ui_numKnownAnimFileSets].filename, strippedName, sizeof( ui_knownAnimFileSets[ui_numKnownAnimFileSets].filename ) );
+
+	// Load and parse animations.cfg file
+	Com_sprintf( afilename, sizeof( afilename ), "%s/animation.cfg", strippedName );
+	if ( !UI_ParseAnimationFile( afilename ) )
+	{
+		*animFileIndex = -1;
+		return qfalse;
+	}
+
+	//set index and increment
+	*animFileIndex = ui_numKnownAnimFileSets++;
+
+	return qtrue;
+}
+
+int UI_G2SetAnim(CGhoul2Info *ghlInfo, const char *boneName, int animNum, const qboolean freeze)
+{
+	int animIndex,blendTime;
+	char *GLAName;
+
+	GLAName = G2API_GetGLAName(ghlInfo);
+
+	if (!GLAName || !GLAName[0])
+	{
+		return 0;
+	}
+
+	UI_ParseAnimFileSet(GLAName, &animIndex);
+
+	if (animIndex != -1)
+	{
+		animation_t *anim = &ui_knownAnimFileSets[animIndex].animations[animNum];
+		if (anim->numFrames <= 0)
+		{
+			return 0;
+		}
+		int sFrame = anim->firstFrame;
+		int eFrame = anim->firstFrame + anim->numFrames;
+		int flags = BONE_ANIM_OVERRIDE;
+		int time = uiInfo.uiDC.realTime;
+		float animSpeed = (50.0f / anim->frameLerp);
+
+		blendTime = 150;
+
+		// Freeze anim if it's not looping, special hack for datapad moves menu
+		if (freeze)
+		{
+			if (anim->loopFrames == -1)
+			{
+				flags = BONE_ANIM_OVERRIDE_FREEZE;			
+			}
+			else
+			{
+				flags = BONE_ANIM_OVERRIDE_LOOP;
+			}
+		}
+		else if (anim->loopFrames != -1)
+		{
+			flags = BONE_ANIM_OVERRIDE_LOOP;
+		}
+		flags |= BONE_ANIM_BLEND;
+		blendTime = 150;
+
+
+		G2API_SetBoneAnim(ghlInfo, boneName, sFrame, eFrame, flags, animSpeed, time, -1, blendTime);
+
+		return ((anim->frameLerp * (anim->numFrames-2)));
+	}
+
+	return 0;
+}
+
+static qboolean UI_ParseColorData(char* buf, playerSpeciesInfo_t &species)
+{
+	const char	*token;
+	const char	*p;
+
+	p = buf;
+	COM_BeginParseSession();
+	species.ColorCount = 0;
+
+	while ( p )
+	{
+		token = COM_ParseExt( &p, qtrue );	//looking for the shader
+		if ( token[0] == 0 )
+		{
+			return species.ColorCount;
+		}
+		Q_strncpyz( species.ColorShader[species.ColorCount], token, sizeof(species.ColorShader[0]), qtrue );
+
+		token = COM_ParseExt( &p, qtrue );	//looking for action block {
+		if ( token[0] != '{' )
+		{
+			return qfalse;
+		}
+
+		assert(!species.ColorActionText[species.ColorCount][0]);
+		token = COM_ParseExt( &p, qtrue );	//looking for action commands
+		while (token[0] != '}')
+		{
+			if ( token[0] == 0)
+			{	//EOF
+				return qfalse;
+			}
+			assert(species.ColorCount < sizeof(species.ColorActionText)/sizeof(species.ColorActionText[0]) );
+			Q_strcat(species.ColorActionText[species.ColorCount], sizeof(species.ColorActionText[0]), token);
+			Q_strcat(species.ColorActionText[species.ColorCount], sizeof(species.ColorActionText[0]), " ");
+			token = COM_ParseExt( &p, qtrue );	//looking for action commands or final }
+		}
+		species.ColorCount++;	//next color please
+	}
+	return qtrue;//never get here
+}
+
+/*
+=================
+bIsImageFile
+builds path and scans for valid image extentions
+=================
+*/
+static bool bIsImageFile(const char* dirptr, const char* skinname, qboolean building)
+{
+	char fpath[MAX_QPATH];
+	int f;
+
+#ifdef _XBOX
+	Com_sprintf(fpath, MAX_QPATH, "models/players/%s/icon_%s.dds", dirptr, skinname);
+#else
+	Com_sprintf(fpath, MAX_QPATH, "models/players/%s/icon_%s.jpg", dirptr, skinname);
+#endif
+	ui.FS_FOpenFile(fpath, &f, FS_READ);
+#if !defined(_XBOX) || defined(_DEBUG)
+	if (!f)
+	{ //not there, try png
+		Com_sprintf(fpath, MAX_QPATH, "models/players/%s/icon_%s.png", dirptr, skinname);
+		ui.FS_FOpenFile(fpath, &f, FS_READ);
+	}
+	if (!f)
+	{ //not there, try tga
+		Com_sprintf(fpath, MAX_QPATH, "models/players/%s/icon_%s.tga", dirptr, skinname);
+		ui.FS_FOpenFile(fpath, &f, FS_READ);
+	}
+#endif
+	if (f) 
+	{
+		ui.FS_FCloseFile(f);
+		if ( building ) ui.R_RegisterShaderNoMip(fpath);
+		return true;
+	}
+
+	return false;
+}
+
+/*
+=================
+PlayerModel_BuildList
+=================
+*/
+static void UI_BuildPlayerModel_List( qboolean inGameLoad )
+{
+	int		numdirs;
+	char	dirlist[2048];
+	char*	dirptr;
+	int		dirlen;
+	int		i;
+	const int building = Cvar_VariableIntegerValue("com_buildscript");
+
+	uiInfo.playerSpeciesCount = 0;
+	uiInfo.playerSpeciesIndex = 0;
+	memset(uiInfo.playerSpecies, 0, sizeof (uiInfo.playerSpecies) );
+
+	// iterate directory of all player models
+	numdirs = ui.FS_GetFileList("models/players", "/", dirlist, 2048 );
+	dirptr  = dirlist;
+	for (i=0; i<numdirs; i++,dirptr+=dirlen+1)
+	{
+		char	filelist[2048];
+		char*	fileptr;
+		int		filelen;
+		int f = 0;
+		char fpath[2048];
+
+		dirlen = strlen(dirptr);
+		
+		if (dirlen && dirptr[dirlen-1]=='/') dirptr[dirlen-1]='\0';
+
+		if (!strcmp(dirptr,".") || !strcmp(dirptr,".."))
+			continue;
+			
+		Com_sprintf(fpath, 2048, "models/players/%s/PlayerChoice.txt", dirptr);
+		filelen = ui.FS_FOpenFile(fpath, &f, FS_READ);
+
+		if (f)
+		{ 
+			char buffer[2048];
+			ui.FS_Read(&buffer, filelen, f);
+			ui.FS_FCloseFile(f);
+			buffer[filelen] = 0;	//ensure trailing NULL
+			
+			//record this species
+			Q_strncpyz( uiInfo.playerSpecies[uiInfo.playerSpeciesCount].Name, dirptr, sizeof(uiInfo.playerSpecies[0].Name), qtrue );
+
+			if (!UI_ParseColorData(buffer,uiInfo.playerSpecies[uiInfo.playerSpeciesCount]))
+			{
+				ui.Printf( "UI_BuildPlayerModel_List: Errors parsing '%s'\n", fpath );
+			}
+
+			int		j;
+			char	skinname[64];
+			int		numfiles;
+			int		iSkinParts=0;
+
+			numfiles = ui.FS_GetFileList( va("models/players/%s",dirptr), ".skin", filelist, 2048 );
+			fileptr  = filelist;
+			for (j=0; j<numfiles; j++,fileptr+=filelen+1)
+			{
+				if ( building )
+				{
+					ui.FS_FOpenFile(va("models/players/%s/%s",dirptr,fileptr), &f, FS_READ);
+					if (f) ui.FS_FCloseFile(f);
+					ui.FS_FOpenFile(va("models/players/%s/sounds.cfg", dirptr), &f, FS_READ);
+					if (f) ui.FS_FCloseFile(f);
+					ui.FS_FOpenFile(va("models/players/%s/animevents.cfg", dirptr), &f, FS_READ);
+					if (f) ui.FS_FCloseFile(f);
+				}
+
+				filelen = strlen(fileptr);
+				COM_StripExtension(fileptr,skinname);
+
+				if (bIsImageFile(dirptr, skinname, building))
+				{ //if it exists
+					if (strnicmp(skinname,"head_",5) == 0)
+					{
+						if (uiInfo.playerSpecies[uiInfo.playerSpeciesCount].SkinHeadCount < MAX_PLAYERMODELS) 
+						{
+							Q_strncpyz(uiInfo.playerSpecies[uiInfo.playerSpeciesCount].SkinHeadNames[uiInfo.playerSpecies[uiInfo.playerSpeciesCount].SkinHeadCount++], skinname, sizeof(uiInfo.playerSpecies[0].SkinHeadNames[0]), qtrue);
+							iSkinParts |= 1<<0;
+						}
+					} else
+					if (strnicmp(skinname,"torso_",6) == 0)
+					{
+						if (uiInfo.playerSpecies[uiInfo.playerSpeciesCount].SkinTorsoCount < MAX_PLAYERMODELS) 
+						{
+							Q_strncpyz(uiInfo.playerSpecies[uiInfo.playerSpeciesCount].SkinTorsoNames[uiInfo.playerSpecies[uiInfo.playerSpeciesCount].SkinTorsoCount++], skinname, sizeof(uiInfo.playerSpecies[0].SkinTorsoNames[0]), qtrue);
+							iSkinParts |= 1<<1;
+						}
+					} else
+					if (strnicmp(skinname,"lower_",6) == 0)
+					{
+						if (uiInfo.playerSpecies[uiInfo.playerSpeciesCount].SkinLegCount < MAX_PLAYERMODELS) 
+						{
+							Q_strncpyz(uiInfo.playerSpecies[uiInfo.playerSpeciesCount].SkinLegNames[uiInfo.playerSpecies[uiInfo.playerSpeciesCount].SkinLegCount++], skinname, sizeof(uiInfo.playerSpecies[0].SkinLegNames[0]), qtrue);
+							iSkinParts |= 1<<2;
+						}
+					}
+					
+				}
+			}
+			if (iSkinParts != 7)
+			{	//didn't get a skin for each, then skip this model.
+				memset(&uiInfo.playerSpecies[uiInfo.playerSpeciesCount], 0, sizeof(uiInfo.playerSpecies[uiInfo.playerSpeciesCount]));//undo the colors
+				continue;
+			}
+			uiInfo.playerSpeciesCount++;
+			if (!inGameLoad && ui_PrecacheModels.integer)
+			{
+				CGhoul2Info_v ghoul2;
+				Com_sprintf( fpath, sizeof( fpath ), "models/players/%s/model.glm", dirptr );
+				int g2Model = DC->g2_InitGhoul2Model(ghoul2, fpath, 0, 0, 0, 0, 0);
+				if (g2Model >= 0)
+				{
+					DC->g2_RemoveGhoul2Model( ghoul2, 0 );
+				}
+			}
+			if (uiInfo.playerSpeciesCount >= MAX_PLAYERMODELS)
+			{
+				return;
+			}
+		}
+	}	
+
+}
+
+/*
+=================
+UI_Init
+=================
+*/
+void _UI_Init( qboolean inGameLoad ) 
+{
+	// Get the list of possible languages
+	uiInfo.languageCount = SE_GetNumLanguages();	// this does a dir scan, so use carefully
+
+	uiInfo.inGameLoad = inGameLoad;
+
+	UI_RegisterCvars();
+
+	UI_InitMemory();
+
+	// cache redundant calulations
+	trap_GetGlconfig( &uiInfo.uiDC.glconfig );
+
+	// for 640x480 virtualized screen
+	uiInfo.uiDC.yscale = uiInfo.uiDC.glconfig.vidHeight * (1.0/480.0);
+	uiInfo.uiDC.xscale = uiInfo.uiDC.glconfig.vidWidth * (1.0/640.0);
+	if ( uiInfo.uiDC.glconfig.vidWidth * 480 > uiInfo.uiDC.glconfig.vidHeight * 640 ) 
+	{
+		// wide screen
+		uiInfo.uiDC.bias = 0.5 * ( uiInfo.uiDC.glconfig.vidWidth - ( uiInfo.uiDC.glconfig.vidHeight * (640.0/480.0) ) );
+	}
+	else 
+	{
+		// no wide screen
+		uiInfo.uiDC.bias = 0;
+	}
+
+	Init_Display(&uiInfo.uiDC);
+
+	uiInfo.uiDC.drawText			= &Text_Paint;
+	uiInfo.uiDC.drawHandlePic		= &UI_DrawHandlePic;
+	uiInfo.uiDC.drawRect			= &_UI_DrawRect;
+	uiInfo.uiDC.drawSides			= &_UI_DrawSides;
+	uiInfo.uiDC.drawTextWithCursor	= &Text_PaintWithCursor;
+	uiInfo.uiDC.executeText			= &Cbuf_ExecuteText;
+	uiInfo.uiDC.drawTopBottom		= &_UI_DrawTopBottom;
+	uiInfo.uiDC.feederCount			= &UI_FeederCount;
+	uiInfo.uiDC.feederSelection		= &UI_FeederSelection;
+	uiInfo.uiDC.fillRect			= &UI_FillRect;
+	uiInfo.uiDC.getBindingBuf		= &Key_GetBindingBuf;
+	uiInfo.uiDC.getCVarString		= Cvar_VariableStringBuffer;
+	uiInfo.uiDC.getCVarValue		= trap_Cvar_VariableValue;
+	uiInfo.uiDC.getOverstrikeMode	= &trap_Key_GetOverstrikeMode;
+	uiInfo.uiDC.getValue			= &UI_GetValue;
+	uiInfo.uiDC.keynumToStringBuf	= &Key_KeynumToStringBuf;
+	uiInfo.uiDC.modelBounds			= &trap_R_ModelBounds;
+	uiInfo.uiDC.ownerDrawVisible	= &UI_OwnerDrawVisible;
+	uiInfo.uiDC.ownerDrawWidth		= &UI_OwnerDrawWidth;
+	uiInfo.uiDC.ownerDrawItem		= &UI_OwnerDraw;
+	uiInfo.uiDC.Print				= &Com_Printf; 
+	uiInfo.uiDC.registerSound		= &trap_S_RegisterSound;
+	uiInfo.uiDC.registerModel		= ui.R_RegisterModel;
+	uiInfo.uiDC.clearScene			= &trap_R_ClearScene;
+	uiInfo.uiDC.addRefEntityToScene = &trap_R_AddRefEntityToScene;
+	uiInfo.uiDC.renderScene			= &trap_R_RenderScene;
+	uiInfo.uiDC.runScript			= &UI_RunMenuScript;
+	uiInfo.uiDC.deferScript			= &UI_DeferMenuScript;
+	uiInfo.uiDC.setBinding			= &trap_Key_SetBinding;
+	uiInfo.uiDC.setColor			= &UI_SetColor;
+	uiInfo.uiDC.setCVar				= Cvar_Set;
+	uiInfo.uiDC.setOverstrikeMode	= &trap_Key_SetOverstrikeMode;
+	uiInfo.uiDC.startLocalSound		= &trap_S_StartLocalSound;
+	uiInfo.uiDC.stopCinematic		= &UI_StopCinematic;
+	uiInfo.uiDC.textHeight			= &Text_Height;
+	uiInfo.uiDC.textWidth			= &Text_Width;
+	uiInfo.uiDC.feederItemImage		= &UI_FeederItemImage;
+	uiInfo.uiDC.feederItemText		= &UI_FeederItemText;
+#ifdef _IMMERSION
+	uiInfo.uiDC.registerForce		= &trap_FF_Register;
+	uiInfo.uiDC.startForce			= &trap_FF_Start;
+#endif // _IMMERSION
+	uiInfo.uiDC.ownerDrawHandleKey	= &UI_OwnerDrawHandleKey;
+
+	uiInfo.uiDC.registerSkin		= re.RegisterSkin;
+
+#ifndef _XBOX
+	uiInfo.uiDC.g2_SetSkin = G2API_SetSkin;
+	uiInfo.uiDC.g2_SetBoneAnim = G2API_SetBoneAnim;
+#endif
+	uiInfo.uiDC.g2_RemoveGhoul2Model = G2API_RemoveGhoul2Model;
+	uiInfo.uiDC.g2_InitGhoul2Model = G2API_InitGhoul2Model;
+	uiInfo.uiDC.g2_CleanGhoul2Models = G2API_CleanGhoul2Models;
+	uiInfo.uiDC.g2_AddBolt = G2API_AddBolt;
+	uiInfo.uiDC.g2_GetBoltMatrix = G2API_GetBoltMatrix;
+	uiInfo.uiDC.g2_GiveMeVectorFromMatrix = G2API_GiveMeVectorFromMatrix;
+
+	uiInfo.uiDC.g2hilev_SetAnim = UI_G2SetAnim;
+
+	UI_BuildPlayerModel_List(inGameLoad);
+
+	String_Init();
+
+	char *menuSet = UI_Cvar_VariableString("ui_menuFiles");
+
+	if (menuSet == NULL || menuSet[0] == '\0') 
+	{
+		menuSet = "ui/menus.txt";
+	}
+	if (inGameLoad)
+	{
+		UI_LoadMenus("ui/ingame.txt", qtrue);
+	}
+	else 
+	{
+		UI_LoadMenus(menuSet, qtrue);
+	}
+
+	Menus_CloseAll();
+
+	uiInfo.uiDC.whiteShader = ui.R_RegisterShaderNoMip( "white" );
+
+	AssetCache();
+
+	uis.debugMode = qfalse;
+	
+	// sets defaults for ui temp cvars
+	uiInfo.effectsColor = (int)trap_Cvar_VariableValue("color")-1;
+	if (uiInfo.effectsColor < 0)
+	{
+		uiInfo.effectsColor = 0;
+	}
+	uiInfo.effectsColor = gamecodetoui[uiInfo.effectsColor];
+	uiInfo.currentCrosshair = (int)trap_Cvar_VariableValue("cg_drawCrosshair");
+	Cvar_Set("ui_mousePitch", (trap_Cvar_VariableValue("m_pitch") >= 0) ? "0" : "1");
+
+	Cvar_Set("cg_endcredits", "0");	// Reset value
+	Cvar_Set("ui_missionfailed","0"); // reset
+
+	uiInfo.forcePowerUpdated = FP_UPDATED_NONE;
+	uiInfo.selectedWeapon1 = NOWEAPON;
+	uiInfo.selectedWeapon2 = NOWEAPON;
+	uiInfo.selectedThrowWeapon = NOWEAPON;
+
+	uiInfo.uiDC.Assets.nullSound = trap_S_RegisterSound("sound/null", qfalse);
+
+	trap_S_RegisterSound("sound/interface/weapon_deselect", qfalse);
+
+
+}
+
+
+/*
+=================
+UI_RegisterCvars
+=================
+*/
+static void UI_RegisterCvars( void ) 
+{
+	int			i;
+	cvarTable_t	*cv;
+
+	for ( i = 0, cv = cvarTable ; i < cvarTableSize ; i++, cv++ ) 
+	{
+		Cvar_Register( cv->vmCvar, cv->cvarName, cv->defaultString, cv->cvarFlags );
+	}
+}
+
+#ifdef _XBOX
+//JLFCALLOUT  MPNOTNEEDED->(INCLUDE WORKS)
+qboolean Menu_Parse(char *buffer, menuDef_t *menu);
+
+char * UI_ParseInclude(const char *menuFile, menuDef_t * menu) 
+{
+	char	*buffer,*holdBuffer,*token2;
+	int len;
+//	pc_token_t token;
+
+	//Com_DPrintf("Parsing menu file:%s\n", menuFile);
+
+	len = PC_StartParseSession(menuFile,&buffer, true);
+
+	if (len<=0) 
+	{
+		Com_Printf("UI_ParseMenu: Unable to load menu %s\n", menuFile);
+		return NULL;
+	}
+
+	//	PC_EndParseSession(buffer);
+	return buffer;
+}
+#endif
+
+/*
+=================
+UI_ParseMenu
+=================
+*/
+void UI_ParseMenu(const char *menuFile) 
+{
+	char	*buffer,*holdBuffer,*token2;
+	int len;
+//	pc_token_t token;
+
+	//Com_DPrintf("Parsing menu file:%s\n", menuFile);
+
+	len = PC_StartParseSession(menuFile,&buffer);
+
+	holdBuffer = buffer;
+
+	if (len<=0) 
+	{
+		Com_Printf("UI_ParseMenu: Unable to load menu %s\n", menuFile);
+		return;
+	}
+
+	while ( 1 ) 
+	{
+
+		token2 = PC_ParseExt();
+
+		if (!*token2)
+		{
+			break;
+		}
+/*
+		if ( menuCount == MAX_MENUS ) 
+		{
+			PC_ParseWarning("Too many menus!");		
+			break;
+		}
+*/
+		if ( *token2 == '{') 
+		{
+			continue;
+		}
+		else if ( *token2 == '}' ) 
+		{
+			break;
+		}
+		else if (Q_stricmp(token2, "assetGlobalDef") == 0) 
+		{
+			if (Asset_Parse(&holdBuffer)) 
+			{
+				continue;
+			} 
+			else 
+			{
+				break;
+			}
+		}
+		else if (Q_stricmp(token2, "menudef") == 0) 
+		{
+			// start a new menu
+			Menu_New(holdBuffer);
+			continue;
+		}
+
+		PC_ParseWarning(va("Invalid keyword '%s'",token2));		
+	}
+
+	PC_EndParseSession(buffer);
+	
+}
+
+/*
+=================
+Load_Menu
+	Load current menu file
+=================
+*/
+qboolean Load_Menu(const char **holdBuffer) 
+{
+	const char	*token2;
+
+	token2 = COM_ParseExt( holdBuffer, qtrue );
+
+	if (!token2[0])
+	{
+		return qfalse;
+	}
+
+	if (*token2 != '{') 
+	{
+		return qfalse;
+	}
+
+	while ( 1 ) 
+	{
+		token2 = COM_ParseExt( holdBuffer, qtrue );
+
+		if ((!token2) || (token2 == 0))
+		{
+			return qfalse;
+		}
+			
+		if ( *token2 == '}' ) 
+		{
+			return qtrue;
+		}
+
+//#ifdef _DEBUG
+//		extern void UI_Debug_AddMenuFilePath(const char *);
+//		UI_Debug_AddMenuFilePath(token2);
+//#endif
+		UI_ParseMenu(token2); 
+
+	}
+	return qfalse;
+}
+
+/*
+=================
+UI_LoadMenus
+	Load all menus based on the files listed in the data file in menuFile (default "ui/menus.txt")
+=================
+*/
+void UI_LoadMenus(const char *menuFile, qboolean reset) 
+{
+//	pc_token_t token;
+//	int handle;
+	int start;
+
+	char *buffer;
+	const char *holdBuffer;
+	int len;
+
+	start = Sys_Milliseconds();
+
+	len = ui.FS_ReadFile(menuFile,(void **) &buffer);
+
+	if (len<1) 
+	{
+		Com_Printf( va( S_COLOR_YELLOW "menu file not found: %s, using default\n", menuFile ) );
+		len = ui.FS_ReadFile("ui/menus.txt",(void **) &buffer);
+
+		if (len<1) 
+		{
+			Com_Error( ERR_FATAL, "%s", va("default menu file not found: ui/menus.txt, unable to continue!\n", menuFile ));
+			return;
+		}
+	}
+
+	if (reset) 
+	{
+		Menu_Reset();
+	}
+
+	const char	*token2;
+	holdBuffer = buffer;
+	while ( 1 ) 
+	{
+		token2 = COM_ParseExt( &holdBuffer, qtrue );
+		if (!*token2)
+		{
+			break;
+		}
+
+		if( *token2 == 0 || *token2 == '}')			// End of the menus file 
+		{
+			break;
+		}
+
+		if (*token2 == '{') 
+		{
+				continue;
+		}
+		else if (Q_stricmp(token2, "loadmenu") == 0) 
+		{
+			if (Load_Menu(&holdBuffer)) 
+			{
+				continue;
+			} 
+			else 
+			{
+				break;
+			}
+		} 
+		else
+		{
+			Com_Printf("Unknown keyword '%s' in menus file %s\n", token2, menuFile);
+		} 
+	}
+
+	//Com_Printf("UI menu load time = %d milli seconds\n", Sys_Milliseconds() - start);
+
+	ui.FS_FreeFile( buffer );	//let go of the buffer
+}
+
+/*
+=================
+UI_Load
+=================
+*/
+void UI_Load(void) 
+{
+	char *menuSet;
+	char lastName[1024];
+	menuDef_t *menu = Menu_GetFocused();
+
+	if (menu && menu->window.name) 
+	{
+		strcpy(lastName, menu->window.name);
+	}
+	else
+	{
+		lastName[0] = 0;
+	}
+
+	if (uiInfo.inGameLoad)
+	{
+		menuSet= "ui/ingame.txt";
+	}
+	else 
+	{
+		menuSet= UI_Cvar_VariableString("ui_menuFiles");
+	}
+	if (menuSet == NULL || menuSet[0] == '\0') 
+	{
+		menuSet = "ui/menus.txt";
+	}
+
+	String_Init();
+
+
+	UI_LoadMenus(menuSet, qtrue);
+	Menus_CloseAll();
+	Menus_ActivateByName(lastName);
+}
+
+/*
+=================
+Asset_Parse
+=================
+*/
+qboolean Asset_Parse(char **buffer) 
+{
+	char		*token;
+	const char	*tempStr;
+	int			pointSize;
+
+	token = PC_ParseExt();
+
+	if (!token)
+	{
+		return qfalse;
+	}
+
+	if (*token != '{') 
+	{
+		return qfalse;
+	}
+    
+	while ( 1 ) 
+	{
+
+		token = PC_ParseExt();
+
+		if (!token)
+		{
+			return qfalse;
+		}
+
+		if (*token == '}') 
+		{
+			return qtrue;
+		}
+
+		// fonts
+		if (Q_stricmp(token, "smallFont") == 0)		//legacy, really it only matters which order they are registered
+		{
+			if (PC_ParseString(&tempStr))
+			{
+				PC_ParseWarning("Bad 1st parameter for keyword 'smallFont'");
+				return qfalse;
+			}
+
+			UI_RegisterFont(tempStr);
+
+			//not used anymore
+			if (PC_ParseInt(&pointSize))
+			{
+//				PC_ParseWarning("Bad 2nd parameter for keyword 'smallFont'");
+			}
+
+			continue;
+		}
+
+		if (Q_stricmp(token, "mediumFont") == 0) 
+		{
+			if (PC_ParseString(&tempStr))
+			{
+				PC_ParseWarning("Bad 1st parameter for keyword 'font'");
+				return qfalse;
+			}
+
+			uiInfo.uiDC.Assets.qhMediumFont = UI_RegisterFont(tempStr);
+			uiInfo.uiDC.Assets.fontRegistered = qtrue;
+
+			//not used
+			if (PC_ParseInt(&pointSize))
+			{
+//				PC_ParseWarning("Bad 2nd parameter for keyword 'font'");
+			}
+			continue;
+		}
+
+		if (Q_stricmp(token, "bigFont") == 0) //legacy
+		{
+			if (PC_ParseString(&tempStr))
+			{
+				PC_ParseWarning("Bad 1st parameter for keyword 'bigFont'");
+				return qfalse;
+			}
+
+			UI_RegisterFont(tempStr);
+
+			if (PC_ParseInt(&pointSize))
+			{
+//				PC_ParseWarning("Bad 2nd parameter for keyword 'bigFont'");
+			}
+
+			continue;
+		}
+
+		// gradientbar
+		if (Q_stricmp(token, "gradientbar") == 0) 
+		{
+			if (PC_ParseString(&tempStr))
+			{
+				PC_ParseWarning("Bad 1st parameter for keyword 'gradientbar'");
+				return qfalse;
+			}
+			uiInfo.uiDC.Assets.gradientBar = ui.R_RegisterShaderNoMip(tempStr);
+			continue;
+		}
+
+		// enterMenuSound
+		if (Q_stricmp(token, "menuEnterSound") == 0) 
+		{
+			if (PC_ParseString(&tempStr))
+			{
+				PC_ParseWarning("Bad 1st parameter for keyword 'menuEnterSound'");
+				return qfalse;
+			}
+
+			uiInfo.uiDC.Assets.menuEnterSound = trap_S_RegisterSound( tempStr, qfalse );
+			continue;
+		}
+
+		// exitMenuSound
+		if (Q_stricmp(token, "menuExitSound") == 0) 
+		{
+			if (PC_ParseString(&tempStr))
+			{
+				PC_ParseWarning("Bad 1st parameter for keyword 'menuExitSound'");
+				return qfalse;
+			}
+			uiInfo.uiDC.Assets.menuExitSound = trap_S_RegisterSound( tempStr, qfalse );
+			continue;
+		}
+
+		// itemFocusSound
+		if (Q_stricmp(token, "itemFocusSound") == 0) 
+		{
+			if (PC_ParseString(&tempStr))
+			{
+				PC_ParseWarning("Bad 1st parameter for keyword 'itemFocusSound'");
+				return qfalse;
+			}
+			uiInfo.uiDC.Assets.itemFocusSound = trap_S_RegisterSound( tempStr, qfalse );
+			continue;
+		}
+
+		// menuBuzzSound
+		if (Q_stricmp(token, "menuBuzzSound") == 0) 
+		{
+			if (PC_ParseString(&tempStr))
+			{
+				PC_ParseWarning("Bad 1st parameter for keyword 'menuBuzzSound'");
+				return qfalse;
+			}
+			uiInfo.uiDC.Assets.menuBuzzSound = trap_S_RegisterSound( tempStr, qfalse );
+			continue;
+		}
+
+		// Chose a force power from the ingame force allocation screen (the one where you get to allocate a force power point)
+		if (Q_stricmp(token, "forceChosenSound") == 0) 
+		{
+			if (PC_ParseString(&tempStr))
+			{
+				PC_ParseWarning("Bad 1st parameter for keyword 'forceChosenSound'");
+				return qfalse;
+			}
+
+			uiInfo.uiDC.Assets.forceChosenSound = trap_S_RegisterSound( tempStr, qfalse );
+			continue;
+		}
+
+
+		// Unchose a force power from the ingame force allocation screen (the one where you get to allocate a force power point)
+		if (Q_stricmp(token, "forceUnchosenSound") == 0) 
+		{
+			if (PC_ParseString(&tempStr))
+			{
+				PC_ParseWarning("Bad 1st parameter for keyword 'forceUnchosenSound'");
+				return qfalse;
+			}
+
+			uiInfo.uiDC.Assets.forceUnchosenSound = trap_S_RegisterSound( tempStr, qfalse );
+			continue;
+		}
+
+		if (Q_stricmp(token, "datapadmoveRollSound") == 0) 
+		{
+			if (PC_ParseString(&tempStr))
+			{
+				PC_ParseWarning("Bad 1st parameter for keyword 'datapadmoveRollSound'");
+				return qfalse;
+			}
+
+			uiInfo.uiDC.Assets.datapadmoveRollSound = trap_S_RegisterSound( tempStr, qfalse );
+			continue;
+		}
+
+		if (Q_stricmp(token, "datapadmoveJumpSound") == 0) 
+		{
+			if (PC_ParseString(&tempStr))
+			{
+				PC_ParseWarning("Bad 1st parameter for keyword 'datapadmoveRoll'");
+				return qfalse;
+			}
+
+			uiInfo.uiDC.Assets.datapadmoveJumpSound = trap_S_RegisterSound( tempStr, qfalse );
+			continue;
+		}
+
+		if (Q_stricmp(token, "datapadmoveSaberSound1") == 0) 
+		{
+			if (PC_ParseString(&tempStr))
+			{
+				PC_ParseWarning("Bad 1st parameter for keyword 'datapadmoveSaberSound1'");
+				return qfalse;
+			}
+
+			uiInfo.uiDC.Assets.datapadmoveSaberSound1 = trap_S_RegisterSound( tempStr, qfalse );
+			continue;
+		}
+
+		if (Q_stricmp(token, "datapadmoveSaberSound2") == 0) 
+		{
+			if (PC_ParseString(&tempStr))
+			{
+				PC_ParseWarning("Bad 1st parameter for keyword 'datapadmoveSaberSound2'");
+				return qfalse;
+			}
+
+			uiInfo.uiDC.Assets.datapadmoveSaberSound2 = trap_S_RegisterSound( tempStr, qfalse );
+			continue;
+		}
+
+		if (Q_stricmp(token, "datapadmoveSaberSound3") == 0) 
+		{
+			if (PC_ParseString(&tempStr))
+			{
+				PC_ParseWarning("Bad 1st parameter for keyword 'datapadmoveSaberSound3'");
+				return qfalse;
+			}
+
+			uiInfo.uiDC.Assets.datapadmoveSaberSound3 = trap_S_RegisterSound( tempStr, qfalse );
+			continue;
+		}
+
+		if (Q_stricmp(token, "datapadmoveSaberSound4") == 0) 
+		{
+			if (PC_ParseString(&tempStr))
+			{
+				PC_ParseWarning("Bad 1st parameter for keyword 'datapadmoveSaberSound4'");
+				return qfalse;
+			}
+
+			uiInfo.uiDC.Assets.datapadmoveSaberSound4 = trap_S_RegisterSound( tempStr, qfalse );
+			continue;
+		}
+
+		if (Q_stricmp(token, "datapadmoveSaberSound5") == 0) 
+		{
+			if (PC_ParseString(&tempStr))
+			{
+				PC_ParseWarning("Bad 1st parameter for keyword 'datapadmoveSaberSound5'");
+				return qfalse;
+			}
+
+			uiInfo.uiDC.Assets.datapadmoveSaberSound5 = trap_S_RegisterSound( tempStr, qfalse );
+			continue;
+		}
+
+		if (Q_stricmp(token, "datapadmoveSaberSound6") == 0) 
+		{
+			if (PC_ParseString(&tempStr))
+			{
+				PC_ParseWarning("Bad 1st parameter for keyword 'datapadmoveSaberSound6'");
+				return qfalse;
+			}
+
+			uiInfo.uiDC.Assets.datapadmoveSaberSound6 = trap_S_RegisterSound( tempStr, qfalse );
+			continue;
+		}
+
+#ifdef _IMMERSION
+
+		if (Q_stricmp(token, "menuEnterForce") == 0)
+		{
+			if (PC_ParseString(&tempStr))
+			{
+				PC_ParseWarning("Bad 1st parameter for keyword 'menuEnterForce'");
+				return qfalse;
+			}
+			uiInfo.uiDC.Assets.menuEnterForce = trap_FF_Register( tempStr );
+			continue;
+		}
+
+		if (Q_stricmp(token, "menuExitForce") == 0)
+		{
+			if (PC_ParseString(&tempStr))
+			{
+				PC_ParseWarning("Bad 1st parameter for keyword 'menuExitForce'");
+				return qfalse;
+			}
+			uiInfo.uiDC.Assets.menuExitForce = trap_FF_Register( tempStr );
+			continue;
+		}
+
+		if (Q_stricmp(token, "itemFocusForce") == 0)
+		{
+			if (PC_ParseString(&tempStr))
+			{
+				PC_ParseWarning("Bad 1st parameter for keyword 'itemFocusForce'");
+				return qfalse;
+			}
+			uiInfo.uiDC.Assets.itemFocusForce = trap_FF_Register( tempStr );
+			continue;
+		}
+
+		if (Q_stricmp(token, "menuBuzzForce") == 0)
+		{
+			if (PC_ParseString(&tempStr))
+			{
+				PC_ParseWarning("Bad 1st parameter for keyword 'menuBuzzForce'");
+				return qfalse;
+			}
+			uiInfo.uiDC.Assets.menuBuzzForce = trap_FF_Register( tempStr );
+			continue;
+		}
+
+#endif // _IMMERSION
+		if (Q_stricmp(token, "cursor") == 0) 
+		{
+			if (PC_ParseString(&tempStr))
+			{
+				PC_ParseWarning("Bad 1st parameter for keyword 'cursor'");
+				return qfalse;
+			}
+			uiInfo.uiDC.Assets.cursor = ui.R_RegisterShaderNoMip( tempStr);
+			continue;
+		}
+
+		if (Q_stricmp(token, "fadeClamp") == 0) 
+		{
+			if (PC_ParseFloat(&uiInfo.uiDC.Assets.fadeClamp))
+			{
+				PC_ParseWarning("Bad 1st parameter for keyword 'fadeClamp'");
+				return qfalse;
+			}
+			continue;
+		}
+
+		if (Q_stricmp(token, "fadeCycle") == 0) 
+		{
+			if (PC_ParseInt(&uiInfo.uiDC.Assets.fadeCycle)) 
+			{
+				PC_ParseWarning("Bad 1st parameter for keyword 'fadeCycle'");
+				return qfalse;
+			}
+			continue;
+		}
+
+		if (Q_stricmp(token, "fadeAmount") == 0) 
+		{
+			if (PC_ParseFloat(&uiInfo.uiDC.Assets.fadeAmount)) 
+			{
+				PC_ParseWarning("Bad 1st parameter for keyword 'fadeAmount'");
+				return qfalse;
+			}
+			continue;
+		}
+
+		if (Q_stricmp(token, "shadowX") == 0) 
+		{
+			if (PC_ParseFloat(&uiInfo.uiDC.Assets.shadowX)) 
+			{
+				PC_ParseWarning("Bad 1st parameter for keyword 'shadowX'");
+				return qfalse;
+			}
+			continue;
+		}
+
+		if (Q_stricmp(token, "shadowY") == 0) 
+		{
+			if (PC_ParseFloat(&uiInfo.uiDC.Assets.shadowY)) 
+			{
+				PC_ParseWarning("Bad 1st parameter for keyword 'shadowY'");
+				return qfalse;
+			}
+			continue;
+		}
+
+		if (Q_stricmp(token, "shadowColor") == 0) 
+		{
+			if (PC_ParseColor(&uiInfo.uiDC.Assets.shadowColor)) 
+			{
+				PC_ParseWarning("Bad 1st parameter for keyword 'shadowColor'");
+				return qfalse;
+			}
+			uiInfo.uiDC.Assets.shadowFadeClamp = uiInfo.uiDC.Assets.shadowColor[3];
+			continue;
+		}
+
+		// precaching various sound files used in the menus
+		if (Q_stricmp(token, "precacheSound") == 0)
+		{
+			if (PC_Script_Parse(&tempStr)) 
+			{
+				char *soundFile;
+				do
+				{
+					soundFile = COM_ParseExt(&tempStr, qfalse);	
+					if (soundFile[0] != 0 && soundFile[0] != ';') {
+						if (!trap_S_RegisterSound( soundFile, qfalse ))
+						{
+							PC_ParseWarning("Can't locate precache sound");
+						}
+					}
+				} while (soundFile[0]);
+			}
+			continue;
+		}
+	}
+
+	PC_ParseWarning(va("Invalid keyword '%s'",token));
+	return qfalse;
+}
+
+/*
+=================
+UI_Update
+=================
+*/
+static void UI_Update(const char *name) 
+{
+	int	val = trap_Cvar_VariableValue(name);
+
+
+	if (Q_stricmp(name, "s_khz") == 0) 
+	{
+		ui.Cmd_ExecuteText( EXEC_APPEND, "snd_restart\n" );
+		return;
+	}
+#ifdef _IMMERSION
+	if (Q_stricmp(name, "ff") == 0) 
+	{
+		ui.Cmd_ExecuteText( EXEC_APPEND, "ff_restart\n");
+		return;
+	}
+#endif // _IMMERSION
+
+	if (Q_stricmp(name, "ui_SetName") == 0) 
+	{
+		Cvar_Set( "name", UI_Cvar_VariableString("ui_Name"));
+ 	} 
+	else if (Q_stricmp(name, "ui_setRate") == 0) 
+	{
+		float rate = trap_Cvar_VariableValue("rate");
+		if (rate >= 5000) 
+		{
+			Cvar_Set("cl_maxpackets", "30");
+			Cvar_Set("cl_packetdup", "1");
+		} 
+		else if (rate >= 4000) 
+		{
+			Cvar_Set("cl_maxpackets", "15");
+			Cvar_Set("cl_packetdup", "2");		// favor less prediction errors when there's packet loss
+		} 
+		else 
+		{
+			Cvar_Set("cl_maxpackets", "15");
+			Cvar_Set("cl_packetdup", "1");		// favor lower bandwidth
+		}
+	} 
+	else if (Q_stricmp(name, "ui_GetName") == 0) 
+	{
+		Cvar_Set( "ui_Name", UI_Cvar_VariableString("name"));
+ 	} 
+	else if (Q_stricmp(name, "ui_r_colorbits") == 0) 
+	{
+		switch (val) 
+		{
+			case 0:
+				Cvar_SetValue( "ui_r_depthbits", 0 );
+				break;
+
+			case 16:
+				Cvar_SetValue( "ui_r_depthbits", 16 );
+				break;
+
+			case 32:
+				Cvar_SetValue( "ui_r_depthbits", 24 );
+				break;
+		}
+	} 
+	else if (Q_stricmp(name, "ui_r_lodbias") == 0) 
+	{
+		switch (val) 
+		{
+			case 0:
+				Cvar_SetValue( "ui_r_subdivisions", 4 );
+				break;
+			case 1:
+				Cvar_SetValue( "ui_r_subdivisions", 12 );
+				break;
+
+			case 2:
+				Cvar_SetValue( "ui_r_subdivisions", 20 );
+				break;
+		}
+	} 
+	else if (Q_stricmp(name, "ui_r_glCustom") == 0) 
+	{
+		switch (val) 
+		{
+			case 0:	// high quality
+
+				Cvar_SetValue( "ui_r_fullScreen", 1 );
+				Cvar_SetValue( "ui_r_subdivisions", 4 );
+				Cvar_SetValue( "ui_r_lodbias", 0 );
+				Cvar_SetValue( "ui_r_colorbits", 32 );
+				Cvar_SetValue( "ui_r_depthbits", 24 );
+				Cvar_SetValue( "ui_r_picmip", 0 );
+				Cvar_SetValue( "ui_r_mode", 4 );
+				Cvar_SetValue( "ui_r_texturebits", 32 );
+				Cvar_SetValue( "ui_r_fastSky", 0 );
+				Cvar_SetValue( "ui_r_inGameVideo", 1 );
+				//Cvar_SetValue( "ui_cg_shadows", 2 );//stencil
+				Cvar_Set( "ui_r_texturemode", "GL_LINEAR_MIPMAP_LINEAR" );
+				break;
+
+			case 1: // normal 
+				Cvar_SetValue( "ui_r_fullScreen", 1 );
+				Cvar_SetValue( "ui_r_subdivisions", 4 );
+				Cvar_SetValue( "ui_r_lodbias", 0 );
+				Cvar_SetValue( "ui_r_colorbits", 0 );
+				Cvar_SetValue( "ui_r_depthbits", 24 );
+				Cvar_SetValue( "ui_r_picmip", 1 );
+				Cvar_SetValue( "ui_r_mode", 3 );
+				Cvar_SetValue( "ui_r_texturebits", 0 );
+				Cvar_SetValue( "ui_r_fastSky", 0 );
+				Cvar_SetValue( "ui_r_inGameVideo", 1 );
+				//Cvar_SetValue( "ui_cg_shadows", 2 );
+				Cvar_Set( "ui_r_texturemode", "GL_LINEAR_MIPMAP_LINEAR" );
+				break;
+
+			case 2: // fast
+
+				Cvar_SetValue( "ui_r_fullScreen", 1 );
+				Cvar_SetValue( "ui_r_subdivisions", 12 );
+				Cvar_SetValue( "ui_r_lodbias", 1 );
+				Cvar_SetValue( "ui_r_colorbits", 0 );
+				Cvar_SetValue( "ui_r_depthbits", 0 );
+				Cvar_SetValue( "ui_r_picmip", 2 );
+				Cvar_SetValue( "ui_r_mode", 3 );
+				Cvar_SetValue( "ui_r_texturebits", 0 );
+				Cvar_SetValue( "ui_r_fastSky", 1 );
+				Cvar_SetValue( "ui_r_inGameVideo", 0 );
+				//Cvar_SetValue( "ui_cg_shadows", 1 );
+				Cvar_Set( "ui_r_texturemode", "GL_LINEAR_MIPMAP_NEAREST" );
+				break;
+
+			case 3: // fastest
+
+				Cvar_SetValue( "ui_r_fullScreen", 1 );
+				Cvar_SetValue( "ui_r_subdivisions", 20 );
+				Cvar_SetValue( "ui_r_lodbias", 2 );
+				Cvar_SetValue( "ui_r_colorbits", 16 );
+				Cvar_SetValue( "ui_r_depthbits", 16 );
+				Cvar_SetValue( "ui_r_mode", 3 );
+				Cvar_SetValue( "ui_r_picmip", 3 );
+				Cvar_SetValue( "ui_r_texturebits", 16 );
+				Cvar_SetValue( "ui_r_fastSky", 1 );
+				Cvar_SetValue( "ui_r_inGameVideo", 0 );
+				//Cvar_SetValue( "ui_cg_shadows", 0 );
+				Cvar_Set( "ui_r_texturemode", "GL_LINEAR_MIPMAP_NEAREST" );
+			break;
+		}
+	} 
+	else if (Q_stricmp(name, "ui_mousePitch") == 0) 
+	{
+		if (val == 0) 
+		{
+			Cvar_SetValue( "m_pitch", 0.022f );
+		} 
+		else 
+		{
+			Cvar_SetValue( "m_pitch", -0.022f );
+		}
+	}
+	else
+	{//failure!!
+		Com_Printf("unknown UI script UPDATE %s\n", name);
+	}
+}
+
+#define ASSET_SCROLLBAR             "gfx/menus/scrollbar.tga"
+#define ASSET_SCROLLBAR_ARROWDOWN   "gfx/menus/scrollbar_arrow_dwn_a.tga"
+#define ASSET_SCROLLBAR_ARROWUP     "gfx/menus/scrollbar_arrow_up_a.tga"
+#define ASSET_SCROLLBAR_ARROWLEFT   "gfx/menus/scrollbar_arrow_left.tga"
+#define ASSET_SCROLLBAR_ARROWRIGHT  "gfx/menus/scrollbar_arrow_right.tga"
+#define ASSET_SCROLL_THUMB          "gfx/menus/scrollbar_thumb.tga"
+
+
+/*
+=================
+AssetCache
+=================
+*/
+void AssetCache(void) 
+{
+//	int n;
+	uiInfo.uiDC.Assets.scrollBar = ui.R_RegisterShaderNoMip( ASSET_SCROLLBAR );
+	uiInfo.uiDC.Assets.scrollBarArrowDown = ui.R_RegisterShaderNoMip( ASSET_SCROLLBAR_ARROWDOWN );
+	uiInfo.uiDC.Assets.scrollBarArrowUp = ui.R_RegisterShaderNoMip( ASSET_SCROLLBAR_ARROWUP );
+	uiInfo.uiDC.Assets.scrollBarArrowLeft = ui.R_RegisterShaderNoMip( ASSET_SCROLLBAR_ARROWLEFT );
+	uiInfo.uiDC.Assets.scrollBarArrowRight = ui.R_RegisterShaderNoMip( ASSET_SCROLLBAR_ARROWRIGHT );
+	uiInfo.uiDC.Assets.scrollBarThumb = ui.R_RegisterShaderNoMip( ASSET_SCROLL_THUMB );
+
+	uiInfo.uiDC.Assets.sliderBar = ui.R_RegisterShaderNoMip( "menu/new/slider" );
+	uiInfo.uiDC.Assets.sliderThumb = ui.R_RegisterShaderNoMip( "menu/new/sliderthumb");
+
+	
+	/*
+	for( n = 0; n < NUM_CROSSHAIRS; n++ ) 
+	{
+		uiInfo.uiDC.Assets.crosshairShader[n] = ui.R_RegisterShaderNoMip( va("gfx/2d/crosshair%c", 'a' + n ) );
+	}
+	*/
+}
+
+/*
+================
+_UI_DrawSides
+=================
+*/
+void _UI_DrawSides(float x, float y, float w, float h, float size) 
+{
+	size *= uiInfo.uiDC.xscale;
+	trap_R_DrawStretchPic( x, y, size, h, 0, 0, 0, 0, uiInfo.uiDC.whiteShader );
+	trap_R_DrawStretchPic( x + w - size, y, size, h, 0, 0, 0, 0, uiInfo.uiDC.whiteShader );
+}
+
+/*
+================
+_UI_DrawTopBottom
+=================
+*/
+void _UI_DrawTopBottom(float x, float y, float w, float h, float size) 
+{
+	size *= uiInfo.uiDC.yscale;
+	trap_R_DrawStretchPic( x, y, w, size, 0, 0, 0, 0, uiInfo.uiDC.whiteShader );
+	trap_R_DrawStretchPic( x, y + h - size, w, size, 0, 0, 0, 0, uiInfo.uiDC.whiteShader );
+}
+/*
+================
+UI_DrawRect
+
+Coordinates are 640*480 virtual values
+=================
+*/
+void _UI_DrawRect( float x, float y, float width, float height, float size, const float *color ) 
+{
+	trap_R_SetColor( color );
+
+	_UI_DrawTopBottom(x, y, width, height, size);
+	_UI_DrawSides(x, y, width, height, size);
+
+	trap_R_SetColor( NULL );
+}
+
+/*
+=================
+UI_UpdateCvars
+=================
+*/
+void UI_UpdateCvars( void ) 
+{
+	int			i;
+	cvarTable_t	*cv;
+
+	for ( i = 0, cv = cvarTable ; i < cvarTableSize ; i++, cv++ ) 
+	{
+		Cvar_Update( cv->vmCvar );
+	}
+}
+
+/*
+=================
+UI_DrawEffects
+=================
+*/
+static void UI_DrawEffects(rectDef_t *rect, float scale, vec4_t color) 
+{
+	UI_DrawHandlePic( rect->x, rect->y - 14, 128, 8, 0/*uiInfo.uiDC.Assets.fxBasePic*/ );
+	UI_DrawHandlePic( rect->x + uiInfo.effectsColor * 16 + 8, rect->y - 16, 16, 12, 0/*uiInfo.uiDC.Assets.fxPic[uiInfo.effectsColor]*/ );
+}
+
+/*
+=================
+UI_Version
+=================
+*/
+static void UI_Version(rectDef_t *rect, float scale, vec4_t color, int iFontIndex) 
+{
+	int width;
+	
+	width = DC->textWidth(Q3_VERSION, scale, 0);
+
+	DC->drawText(rect->x - width, rect->y, scale, color, Q3_VERSION, 0, ITEM_TEXTSTYLE_SHADOWED, iFontIndex);
+}
+
+/*
+=================
+UI_DrawKeyBindStatus
+=================
+*/
+static void UI_DrawKeyBindStatus(rectDef_t *rect, float scale, vec4_t color, int textStyle, int iFontIndex) 
+{
+	if (Display_KeyBindPending()) 
+	{
+		Text_Paint(rect->x, rect->y, scale, color, SE_GetString("MENUS_WAITINGFORKEY"), 0, textStyle, iFontIndex);
+	} 
+	else 
+	{
+//		Text_Paint(rect->x, rect->y, scale, color, ui.SP_GetStringTextString("MENUS_ENTERTOCHANGE"), 0, textStyle, iFontIndex);
+	}
+}
+
+/*
+=================
+UI_DrawKeyBindStatus
+=================
+*/
+static void UI_DrawGLInfo(rectDef_t *rect, float scale, vec4_t color, int textStyle, int iFontIndex) 
+{
+#define MAX_LINES 64
+	char buff[4096];
+	char * eptr = buff;
+	const char *lines[MAX_LINES];
+	int y, numLines=0, i=0;
+
+	y = rect->y;	
+	Text_Paint(rect->x, y, scale, color, va("GL_VENDOR: %s",uiInfo.uiDC.glconfig.vendor_string), rect->w, textStyle, iFontIndex);
+	y += 15;
+	Text_Paint(rect->x, y, scale, color, va("GL_VERSION: %s: %s", uiInfo.uiDC.glconfig.version_string,uiInfo.uiDC.glconfig.renderer_string), rect->w, textStyle, iFontIndex);
+	y += 15;
+	Text_Paint(rect->x, y, scale, color, "GL_PIXELFORMAT:", rect->w, textStyle, iFontIndex);
+	y += 15;
+	Text_Paint(rect->x, y, scale, color, va ("Color(%d-bits) Z(%d-bits) stencil(%d-bits)",uiInfo.uiDC.glconfig.colorBits, uiInfo.uiDC.glconfig.depthBits, uiInfo.uiDC.glconfig.stencilBits), rect->w, textStyle, iFontIndex);
+	y += 15;
+	// build null terminated extension strings
+	Q_strncpyz(buff, uiInfo.uiDC.glconfig.extensions_string, sizeof(buff));
+	int testy=y-16;
+	while ( testy <= rect->y + rect->h && *eptr && (numLines < MAX_LINES) )
+	{
+		while ( *eptr && *eptr == ' ' )
+			*eptr++ = '\0';
+
+		// track start of valid string
+		if (*eptr && *eptr != ' ') 
+		{
+			lines[numLines++] = eptr;
+			testy+=16;
+		}
+
+		while ( *eptr && *eptr != ' ' )
+			eptr++;
+	}
+
+	numLines--;
+	while (i < numLines) 
+	{
+		Text_Paint(rect->x, y, scale, color, lines[i++], rect->w, textStyle, iFontIndex);
+		y += 16;
+	}
+}
+
+/*
+=================
+UI_DataPad_Inventory
+=================
+*/
+/*
+static void UI_DataPad_Inventory(rectDef_t *rect, float scale, vec4_t color, int iFontIndex) 
+{
+	Text_Paint(rect->x, rect->y, scale, color, "INVENTORY", 0, 1, iFontIndex);
+}
+*/
+/*
+=================
+UI_DataPad_ForcePowers
+=================
+*/
+/*
+static void UI_DataPad_ForcePowers(rectDef_t *rect, float scale, vec4_t color, int iFontIndex) 
+{
+	Text_Paint(rect->x, rect->y, scale, color, "FORCE POWERS", 0, 1, iFontIndex);
+}
+*/
+
+static void UI_DrawCrosshair(rectDef_t *rect, float scale, vec4_t color) {
+ 	trap_R_SetColor( color );
+	if (uiInfo.currentCrosshair < 0 || uiInfo.currentCrosshair >= NUM_CROSSHAIRS) {
+		uiInfo.currentCrosshair = 0;
+	}
+	UI_DrawHandlePic( rect->x, rect->y, rect->w, rect->h, uiInfo.uiDC.Assets.crosshairShader[uiInfo.currentCrosshair]);
+ 	trap_R_SetColor( NULL );
+}
+
+
+/*
+=================
+UI_OwnerDraw
+=================
+*/
+static void UI_OwnerDraw(float x, float y, float w, float h, float text_x, float text_y, int ownerDraw, int ownerDrawFlags, int align, float special, float scale, vec4_t color, qhandle_t shader, int textStyle, int iFontIndex) 
+{
+	rectDef_t rect;
+
+	rect.x = x + text_x;
+	rect.y = y + text_y;
+	rect.w = w;
+	rect.h = h;
+
+	switch (ownerDraw) 
+	{
+		case UI_EFFECTS:
+			UI_DrawEffects(&rect, scale, color);
+			break;
+		case UI_VERSION:
+			UI_Version(&rect, scale, color, iFontIndex);
+			break;
+
+		case UI_DATAPAD_MISSION:
+			ui.Draw_DataPad(DP_HUD);
+			ui.Draw_DataPad(DP_OBJECTIVES);
+			break;
+
+		case UI_DATAPAD_WEAPONS:
+			ui.Draw_DataPad(DP_HUD);
+			ui.Draw_DataPad(DP_WEAPONS);
+			break;
+
+		case UI_DATAPAD_INVENTORY:
+			ui.Draw_DataPad(DP_HUD);
+			ui.Draw_DataPad(DP_INVENTORY);
+			break;
+
+		case UI_DATAPAD_FORCEPOWERS:
+			ui.Draw_DataPad(DP_HUD);
+			ui.Draw_DataPad(DP_FORCEPOWERS);
+			break;
+
+		case UI_ALLMAPS_SELECTION://saved game thumbnail
+
+//JLF MAPIMAGE MPNOTUSED
+#ifdef _XBOX
+			//create a shader
+			UI_DrawHandlePic(x, y, w, h, shader);
+		
+#else
+			int levelshot;
+			levelshot = ui.R_RegisterShaderNoMip( va( "levelshots/%s", s_savedata[s_savegame.currentLine].currentSaveFileMap ) );
+			if (levelshot)
+			{
+				ui.R_DrawStretchPic( x, y, w, h, 0, 0, 1, 1, levelshot );
+			}
+			else
+			{
+				UI_DrawHandlePic(x, y, w, h, uis.menuBackShader);
+			}
+#endif
+			ui.R_Font_DrawString(	x,		// int ox
+									y+h,	// int oy
+									s_savedata[s_savegame.currentLine].currentSaveFileMap,	// const char *text
+									color,	// paletteRGBA_c c
+									iFontIndex,	// const int iFontHandle
+									w,//-1,		// iMaxPixelWidth (-1 = none)
+									scale	// const float scale = 1.0f
+									);
+			break;
+		case UI_PREVIEWCINEMATIC:
+			// FIXME BOB - make this work?
+//			UI_DrawPreviewCinematic(&rect, scale, color);
+			break;
+		case UI_CROSSHAIR:
+			UI_DrawCrosshair(&rect, scale, color);
+			break;
+		case UI_GLINFO:
+			UI_DrawGLInfo(&rect,scale, color, textStyle, iFontIndex);
+			break;
+		case UI_KEYBINDSTATUS:
+			UI_DrawKeyBindStatus(&rect,scale, color, textStyle, iFontIndex);
+			break;
+		default:
+		  break;
+	}
+
+}
+
+/*
+=================
+UI_OwnerDrawVisible
+=================
+*/
+static qboolean UI_OwnerDrawVisible(int flags) 
+{
+	qboolean vis = qtrue;
+
+	while (flags) 
+	{
+/*		if (flags & UI_SHOW_DEMOAVAILABLE) 
+		{
+			if (!uiInfo.demoAvailable) 
+			{
+				vis = qfalse;
+			}
+			flags &= ~UI_SHOW_DEMOAVAILABLE;
+		} 
+		else 
+*/		{
+			flags = 0;
+		}
+	}
+	return vis;
+}
+
+/*
+=================
+Text_Width
+=================
+*/
+int Text_Width(const char *text, float scale, int iFontIndex) 
+{
+	// temp code until Bob retro-fits all menus to have font specifiers...
+	//
+	if ( iFontIndex == 0 )
+	{
+		iFontIndex = uiInfo.uiDC.Assets.qhMediumFont;
+	}
+	return ui.R_Font_StrLenPixels(text, iFontIndex, scale);
+}
+
+/*
+=================
+UI_OwnerDrawWidth
+=================
+*/
+int UI_OwnerDrawWidth(int ownerDraw, float scale) 
+{
+//	int i, h, value;
+//	const char *text;
+	const char *s = NULL;
+
+
+	switch (ownerDraw) 
+	{
+	case UI_KEYBINDSTATUS:
+		if (Display_KeyBindPending()) 
+		{
+			s = SE_GetString("MENUS_WAITINGFORKEY");
+		} 
+		else 
+		{
+//			s = ui.SP_GetStringTextString("MENUS_ENTERTOCHANGE");
+		}
+		break;
+	
+	// FIXME BOB
+//	case UI_SERVERREFRESHDATE:
+//		s = UI_Cvar_VariableString(va("ui_lastServerRefresh_%i", ui_netSource.integer));
+//		break;
+    default:
+      break;
+	}
+
+	if (s) 
+	{
+		return Text_Width(s, scale, 0);
+	}
+	return 0;
+}
+
+/*
+=================
+Text_Height
+=================
+*/
+int Text_Height(const char *text, float scale, int iFontIndex) 
+{
+	// temp until Bob retro-fits all menu files with font specifiers...
+	//
+	if ( iFontIndex == 0 )
+	{
+		iFontIndex = uiInfo.uiDC.Assets.qhMediumFont;
+	}
+	return ui.R_Font_HeightPixels(iFontIndex, scale);
+}
+
+
+/*
+=================
+UI_MouseEvent
+=================
+*/
+//JLFMOUSE  CALLED EACH FRAME IN UI
+void _UI_MouseEvent( int dx, int dy )
+{
+	// update mouse screen position
+	uiInfo.uiDC.cursorx += dx;
+	if (uiInfo.uiDC.cursorx < 0)
+	{
+		uiInfo.uiDC.cursorx = 0;
+	}
+	else if (uiInfo.uiDC.cursorx > SCREEN_WIDTH)
+	{
+		uiInfo.uiDC.cursorx = SCREEN_WIDTH;
+	}
+
+	uiInfo.uiDC.cursory += dy;
+	if (uiInfo.uiDC.cursory < 0)
+	{
+		uiInfo.uiDC.cursory = 0;
+	}
+	else if (uiInfo.uiDC.cursory > SCREEN_HEIGHT)
+	{
+		uiInfo.uiDC.cursory = SCREEN_HEIGHT;
+	}
+
+	if (Menu_Count() > 0) 
+	{
+    //menuDef_t *menu = Menu_GetFocused();
+    //Menu_HandleMouseMove(menu, uiInfo.uiDC.cursorx, uiInfo.uiDC.cursory);
+		Display_MouseMove(NULL, uiInfo.uiDC.cursorx, uiInfo.uiDC.cursory);
+	}
+
+}
+
+/*
+=================
+UI_KeyEvent
+=================
+*/
+void _UI_KeyEvent( int key, qboolean down ) 
+{
+/*	extern qboolean SwallowBadNumLockedKPKey( int iKey );
+	if (SwallowBadNumLockedKPKey(key)){
+		return;
+	}
+*/
+
+	if (Menu_Count() > 0) 
+	{
+		menuDef_t *menu = Menu_GetFocused();
+		if (menu) 
+		{
+			//DemoEnd();
+//JLF MPMOVED
+#ifdef _XBOX
+//			extern void G_DemoKeypress();//JLF new
+//			G_DemoKeypress();			//JLF new
+			extern void UpdateDemoTimer();
+			UpdateDemoTimer();
+
+#endif
+			if (key == A_ESCAPE && down && !Menus_AnyFullScreenVisible() && !(menu->window.flags & WINDOW_IGNORE_ESCAPE)) 
+			{
+				Menus_CloseAll();
+			} 
+			else 
+			{
+				Menu_HandleKey(menu, key, down );
+			}
+		} 
+		else 
+		{
+			trap_Key_SetCatcher( trap_Key_GetCatcher() & ~KEYCATCH_UI );
+			trap_Key_ClearStates();
+			Cvar_Set( "cl_paused", "0" );
+		}
+	}
+}
+
+/*
+=================
+UI_Report
+=================
+*/
+void UI_Report(void) 
+{
+  String_Report();
+}
+
+
+
+/*
+=================
+UI_DataPadMenu
+=================
+*/
+void UI_DataPadMenu(void)
+{
+	int	newForcePower,newObjective;
+
+	Menus_CloseByName("mainhud");
+
+	newForcePower = (int)trap_Cvar_VariableValue("cg_updatedDataPadForcePower1");
+	newObjective = (int)trap_Cvar_VariableValue("cg_updatedDataPadObjective");
+
+	if (newForcePower)
+	{
+		Menus_ActivateByName("datapadForcePowersMenu");
+	}
+	else if (newObjective)
+	{
+		Menus_ActivateByName("datapadMissionMenu");
+	}
+	else
+	{
+		Menus_ActivateByName("datapadMissionMenu");
+	}
+	ui.Key_SetCatcher( KEYCATCH_UI );
+
+}
+
+/*
+=================
+UI_InGameMenu
+=================
+*/
+void UI_InGameMenu(const char*menuID)
+{
+#ifdef _XBOX
+	ui.PrecacheScreenshot();
+#endif
+
+	Menus_CloseByName("mainhud");
+
+	if (menuID)
+	{
+		Menus_ActivateByName(menuID);
+	}
+	else
+	{
+		Menus_ActivateByName("ingameMainMenu");
+	}
+	ui.Key_SetCatcher( KEYCATCH_UI );
+}
+
+qboolean _UI_IsFullscreen( void ) 
+{
+	return Menus_AnyFullScreenVisible();
+}
+
+/*
+=======================================================================
+
+MAIN MENU
+
+=======================================================================
+*/
+
+
+/*
+===============
+UI_MainMenu
+
+The main menu only comes up when not in a game,
+so make sure that the attract loop server is down
+and that local cinematics are killed
+===============
+*/
+void UI_MainMenu(void)
+{
+	char buf[256];
+	ui.Cvar_Set("sv_killserver", "1");	// let the demo server know it should shut down
+
+	ui.Key_SetCatcher( KEYCATCH_UI );
+
+	menuDef_t *m = Menus_ActivateByName("mainMenu");
+	if (!m)
+	{	//wha? try again
+		UI_LoadMenus("ui/menus.txt",qfalse);
+	}
+	ui.Cvar_VariableStringBuffer("com_errorMessage", buf, sizeof(buf));
+	if (strlen(buf)) {
+		Menus_ActivateByName("error_popmenu");
+	}
+}
+
+
+/*
+=================
+Menu_Cache
+=================
+*/
+void Menu_Cache( void )
+{
+	uis.cursor		= ui.R_RegisterShaderNoMip( "menu/new/crosshairb");
+	// Common menu graphics
+	uis.whiteShader = ui.R_RegisterShader( "white" );
+	uis.menuBackShader = ui.R_RegisterShaderNoMip( "menu/art/unknownmap" );
+}
+
+/*
+=================
+UI_UpdateVideoSetup
+
+Copies the temporary user interface version of the video cvars into
+their real counterparts.  This is to create a interface which allows 
+you to discard your changes if you did something you didnt want
+=================
+*/
+void UI_UpdateVideoSetup ( void )
+{
+	Cvar_Set ( "r_mode", Cvar_VariableString ( "ui_r_mode" ) );
+	Cvar_Set ( "r_fullscreen", Cvar_VariableString ( "ui_r_fullscreen" ) );
+	Cvar_Set ( "r_colorbits", Cvar_VariableString ( "ui_r_colorbits" ) );
+	Cvar_Set ( "r_lodbias", Cvar_VariableString ( "ui_r_lodbias" ) );
+	Cvar_Set ( "r_picmip", Cvar_VariableString ( "ui_r_picmip" ) );
+	Cvar_Set ( "r_texturebits", Cvar_VariableString ( "ui_r_texturebits" ) );
+	Cvar_Set ( "r_texturemode", Cvar_VariableString ( "ui_r_texturemode" ) );
+	Cvar_Set ( "r_detailtextures", Cvar_VariableString ( "ui_r_detailtextures" ) );
+	Cvar_Set ( "r_ext_compress_textures", Cvar_VariableString ( "ui_r_ext_compress_textures" ) );
+	Cvar_Set ( "r_depthbits", Cvar_VariableString ( "ui_r_depthbits" ) );
+	Cvar_Set ( "r_subdivisions", Cvar_VariableString ( "ui_r_subdivisions" ) );
+	Cvar_Set ( "r_fastSky", Cvar_VariableString ( "ui_r_fastSky" ) );
+	Cvar_Set ( "r_inGameVideo", Cvar_VariableString ( "ui_r_inGameVideo" ) );
+	Cvar_Set ( "r_allowExtensions", Cvar_VariableString ( "ui_r_allowExtensions" ) );
+//	Cvar_Set ( "cg_shadows", Cvar_VariableString ( "ui_cg_shadows" ) );
+	Cvar_Set ( "ui_r_modified", "0" );
+
+	Cbuf_ExecuteText( EXEC_APPEND, "vid_restart;" );
+}
+
+/*
+=================
+UI_GetVideoSetup
+
+Retrieves the current actual video settings into the temporary user
+interface versions of the cvars.
+=================
+*/
+void UI_GetVideoSetup ( void )
+{
+	// Make sure the cvars are registered as read only.
+	Cvar_Register ( NULL, "ui_r_glCustom",				"4", CVAR_ROM|CVAR_ARCHIVE );
+
+	Cvar_Register ( NULL, "ui_r_mode",					"0", CVAR_ROM );
+	Cvar_Register ( NULL, "ui_r_fullscreen",			"0", CVAR_ROM );
+	Cvar_Register ( NULL, "ui_r_colorbits",				"0", CVAR_ROM );
+	Cvar_Register ( NULL, "ui_r_lodbias",				"0", CVAR_ROM );
+	Cvar_Register ( NULL, "ui_r_picmip",				"0", CVAR_ROM );
+	Cvar_Register ( NULL, "ui_r_texturebits",			"0", CVAR_ROM );
+	Cvar_Register ( NULL, "ui_r_texturemode",			"0", CVAR_ROM );
+	Cvar_Register ( NULL, "ui_r_detailtextures",		"0", CVAR_ROM );
+	Cvar_Register ( NULL, "ui_r_ext_compress_textures",	"0", CVAR_ROM );
+	Cvar_Register ( NULL, "ui_r_depthbits",				"0", CVAR_ROM );
+	Cvar_Register ( NULL, "ui_r_subdivisions",			"0", CVAR_ROM );
+	Cvar_Register ( NULL, "ui_r_fastSky",				"0", CVAR_ROM );
+	Cvar_Register ( NULL, "ui_r_inGameVideo",			"0", CVAR_ROM );
+	Cvar_Register ( NULL, "ui_r_allowExtensions",		"0", CVAR_ROM );
+//	Cvar_Register ( NULL, "ui_cg_shadows",				"0", CVAR_ROM );
+	Cvar_Register ( NULL, "ui_r_modified",				"0", CVAR_ROM );
+	
+	// Copy over the real video cvars into their temporary counterparts
+	Cvar_Set ( "ui_r_mode", Cvar_VariableString ( "r_mode" ) );
+	Cvar_Set ( "ui_r_colorbits", Cvar_VariableString ( "r_colorbits" ) );
+	Cvar_Set ( "ui_r_fullscreen", Cvar_VariableString ( "r_fullscreen" ) );
+	Cvar_Set ( "ui_r_lodbias", Cvar_VariableString ( "r_lodbias" ) );
+	Cvar_Set ( "ui_r_picmip", Cvar_VariableString ( "r_picmip" ) );
+	Cvar_Set ( "ui_r_texturebits", Cvar_VariableString ( "r_texturebits" ) );
+	Cvar_Set ( "ui_r_texturemode", Cvar_VariableString ( "r_texturemode" ) );
+	Cvar_Set ( "ui_r_detailtextures", Cvar_VariableString ( "r_detailtextures" ) );
+	Cvar_Set ( "ui_r_ext_compress_textures", Cvar_VariableString ( "r_ext_compress_textures" ) );
+	Cvar_Set ( "ui_r_depthbits", Cvar_VariableString ( "r_depthbits" ) );
+	Cvar_Set ( "ui_r_subdivisions", Cvar_VariableString ( "r_subdivisions" ) );
+	Cvar_Set ( "ui_r_fastSky", Cvar_VariableString ( "r_fastSky" ) );
+	Cvar_Set ( "ui_r_inGameVideo", Cvar_VariableString ( "r_inGameVideo" ) );
+	Cvar_Set ( "ui_r_allowExtensions", Cvar_VariableString ( "r_allowExtensions" ) );
+//	Cvar_Set ( "ui_cg_shadows", Cvar_VariableString ( "cg_shadows" ) );
+	Cvar_Set ( "ui_r_modified", "0" );
+}
+
+static void UI_SetSexandSoundForModel(const char* char_model)
+{
+	int			f,i;
+	char		soundpath[MAX_QPATH];
+	qboolean	isFemale = qfalse;
+
+	i = ui.FS_FOpenFile(va("models/players/%s/sounds.cfg", char_model), &f, FS_READ);
+	if ( !f ) 
+	{//no?  oh bother.
+		Cvar_Reset("snd");
+		Cvar_Reset("sex");
+		return;
+	}
+
+	soundpath[0] = 0;
+
+	ui.FS_Read(&soundpath, i, f);
+
+	while (i >= 0 && soundpath[i] != '\n')
+	{
+		if (soundpath[i] == 'f')
+		{
+			isFemale = qtrue;
+			soundpath[i] = 0;
+		}
+
+		i--;
+	}
+
+	i = 0;
+
+	while (soundpath[i] && soundpath[i] != '\r' && soundpath[i] != '\n')
+	{
+		i++;
+	}
+	soundpath[i] = 0;
+
+	ui.FS_FCloseFile(f);
+
+	Cvar_Set ( "snd", soundpath);
+	if (isFemale)
+	{
+		Cvar_Set ( "sex", "f");
+	}
+	else
+	{
+		Cvar_Set ( "sex", "m");
+	}
+}
+static void UI_UpdateCharacterCvars ( void )
+{
+	const char *char_model = Cvar_VariableString ( "ui_char_model" );
+	UI_SetSexandSoundForModel(char_model);
+	Cvar_Set ( "g_char_model", char_model );
+	Cvar_Set ( "g_char_skin_head", Cvar_VariableString ( "ui_char_skin_head" ) );
+	Cvar_Set ( "g_char_skin_torso", Cvar_VariableString ( "ui_char_skin_torso" ) );
+	Cvar_Set ( "g_char_skin_legs", Cvar_VariableString ( "ui_char_skin_legs" ) );
+	Cvar_Set ( "g_char_color_red", Cvar_VariableString ( "ui_char_color_red" ) );
+	Cvar_Set ( "g_char_color_green", Cvar_VariableString ( "ui_char_color_green" ) );
+	Cvar_Set ( "g_char_color_blue", Cvar_VariableString ( "ui_char_color_blue" ) );
+}
+
+static void UI_GetCharacterCvars ( void )
+{
+	Cvar_Set ( "ui_char_skin_head", Cvar_VariableString ( "g_char_skin_head" ) );
+	Cvar_Set ( "ui_char_skin_torso", Cvar_VariableString ( "g_char_skin_torso" ) );
+	Cvar_Set ( "ui_char_skin_legs", Cvar_VariableString ( "g_char_skin_legs" ) );
+	Cvar_Set ( "ui_char_color_red", Cvar_VariableString ( "g_char_color_red" ) );
+	Cvar_Set ( "ui_char_color_green", Cvar_VariableString ( "g_char_color_green" ) );
+	Cvar_Set ( "ui_char_color_blue", Cvar_VariableString ( "g_char_color_blue" ) );
+
+	char* model = Cvar_VariableString ( "g_char_model" );
+	Cvar_Set ( "ui_char_model", model );
+
+	for (int i = 0; i < uiInfo.playerSpeciesCount; i++)
+	{
+		if ( !stricmp(model, uiInfo.playerSpecies[i].Name) )
+		{
+			uiInfo.playerSpeciesIndex = i;
+		}
+	}
+}
+
+static void UI_UpdateSaberCvars ( void )
+{
+	Cvar_Set ( "g_saber_type", Cvar_VariableString ( "ui_saber_type" ) );
+	Cvar_Set ( "g_saber", Cvar_VariableString ( "ui_saber" ) );
+	Cvar_Set ( "g_saber2", Cvar_VariableString ( "ui_saber2" ) );
+	Cvar_Set ( "g_saber_color", Cvar_VariableString ( "ui_saber_color" ) );
+	Cvar_Set ( "g_saber2_color", Cvar_VariableString ( "ui_saber2_color" ) );
+}
+
+static void UI_UpdateFightingStyleChoices ( void )
+{
+	// 
+	if (!strcmpi("staff",Cvar_VariableString ( "ui_saber_type" )))
+	{
+		Cvar_Set ( "ui_fightingstylesallowed", "0" );
+		Cvar_Set ( "ui_newfightingstyle", "1" );		// Default, MEDIUM
+	}
+	else if (!strcmpi("dual",Cvar_VariableString ( "ui_saber_type" )))
+	{
+		Cvar_Set ( "ui_fightingstylesallowed", "0" );
+		Cvar_Set ( "ui_newfightingstyle", "1" );		// Default, MEDIUM
+	}
+	else
+	{
+		// Get player state
+		client_t	*cl = &svs.clients[0];	// 0 because only ever us as a player	
+		playerState_t	*pState;
+
+		if (cl && cl->gentity && cl->gentity->client)
+		{
+			pState = cl->gentity->client;
+
+
+			// Knows Fast style?
+			if (pState->saberStylesKnown & (1<<SS_FAST)) 
+			{
+				// And Medium?
+				if (pState->saberStylesKnown & (1<<SS_MEDIUM)) 
+				{
+					Cvar_Set ( "ui_fightingstylesallowed", "6" );	// Has FAST and MEDIUM, so can only choose STRONG
+					Cvar_Set ( "ui_newfightingstyle", "2" );		// STRONG
+				}
+				else	
+				{
+					Cvar_Set ( "ui_fightingstylesallowed", "1" );	// Has FAST, so can choose from MEDIUM and STRONG
+					Cvar_Set ( "ui_newfightingstyle", "1" );		// MEDIUM
+				}
+			}
+			// Knows Medium style?
+			else if (pState->saberStylesKnown & (1<<SS_MEDIUM))
+			{
+				// And Strong?
+				if (pState->saberStylesKnown & (1<<SS_STRONG)) 
+				{
+					Cvar_Set ( "ui_fightingstylesallowed", "4" );	// Has MEDIUM and STRONG, so can only choose FAST
+					Cvar_Set ( "ui_newfightingstyle", "0" );		// FAST
+				}
+				else	
+				{
+					Cvar_Set ( "ui_fightingstylesallowed", "2" );	// Has MEDIUM, so can choose from FAST and STRONG
+					Cvar_Set ( "ui_newfightingstyle", "0" );		// FAST
+				}
+			}
+			// Knows Strong style?
+			else if (pState->saberStylesKnown & (1<<SS_STRONG))
+			{
+				// And Fast
+				if (pState->saberStylesKnown & (1<<SS_FAST)) 
+				{
+					Cvar_Set ( "ui_fightingstylesallowed", "5" );	// Has STRONG and FAST, so can only take MEDIUM 
+					Cvar_Set ( "ui_newfightingstyle", "1" );		// MEDIUM
+				}
+				else	
+				{
+					Cvar_Set ( "ui_fightingstylesallowed", "3" );	// Has STRONG, so can choose from FAST and MEDIUM
+					Cvar_Set ( "ui_newfightingstyle", "1" );		// MEDIUM
+				}
+			}
+			else		// They have nothing, which should not happen
+			{
+				Cvar_Set ( "ui_currentfightingstyle", "1" );		// Default MEDIUM
+				Cvar_Set ( "ui_newfightingstyle", "0" );			// FAST??
+				Cvar_Set ( "ui_fightingstylesallowed", "0" );		// Default to no new styles allowed
+			}
+
+			// Determine current style
+			if (pState->saberAnimLevel == SS_FAST)
+			{
+				Cvar_Set ( "ui_currentfightingstyle", "0" );			// FAST
+			}
+			else if (pState->saberAnimLevel == SS_STRONG)
+			{
+				Cvar_Set ( "ui_currentfightingstyle", "2" );			// STRONG
+			}
+			else 
+			{
+				Cvar_Set ( "ui_currentfightingstyle", "1" );			// default MEDIUM
+			}
+		}
+		else	// No client so this must be first time
+		{
+			Cvar_Set ( "ui_currentfightingstyle", "1" );		// Default to MEDIUM
+			Cvar_Set ( "ui_fightingstylesallowed", "0" );		// Default to no new styles allowed
+			Cvar_Set ( "ui_newfightingstyle", "1" );			// MEDIUM
+		}
+	}
+}
+
+#define MAX_POWER_ENUMS 16
+
+typedef struct {
+	char	*title;
+	short	powerEnum;
+} powerEnum_t;
+
+static powerEnum_t powerEnums[MAX_POWER_ENUMS] = 
+{
+"absorb",		FP_ABSORB,			
+"heal",			FP_HEAL,			
+"mindtrick",	FP_TELEPATHY,		
+"protect",		FP_PROTECT,			
+
+			// Core powers
+"jump",			FP_LEVITATION,		
+"pull",			FP_PULL,			
+"push",			FP_PUSH,			
+"sense",		FP_SEE,				
+"speed",		FP_SPEED,			
+"sabdef",		FP_SABER_DEFENSE,	
+"saboff",		FP_SABER_OFFENSE,	
+"sabthrow",		FP_SABERTHROW,		
+
+			// Dark powers
+"drain",		FP_DRAIN,			
+"grip",			FP_GRIP,			
+"lightning",	FP_LIGHTNING,		
+"rage",			FP_RAGE				
+};
+
+
+// Find the index to the Force Power in powerEnum array
+static qboolean UI_GetForcePowerIndex ( const char *forceName, short *forcePowerI )
+{
+	int i;
+
+	// Find a match for the forceName passed in
+	for (i=0;i<MAX_POWER_ENUMS;i++)
+	{
+		if ( !Q_stricmp(forceName, powerEnums[i].title ) )
+		{
+			*forcePowerI = i;
+			return(qtrue);
+		}
+	}
+
+	*forcePowerI = FP_UPDATED_NONE;	// Didn't find it
+
+	return(qfalse);
+}
+
+// Set the fields for the allocation of force powers (Used by Force Power Allocation screen) 
+static void UI_InitAllocForcePowers ( const char *forceName )
+{
+	menuDef_t	*menu;
+	itemDef_t	*item;
+	short		forcePowerI=0;
+
+	menu = Menu_GetFocused();	// Get current menu
+
+	if (!menu)
+	{
+		return;
+	}
+
+	if (!UI_GetForcePowerIndex ( forceName, &forcePowerI ))
+	{
+		return;
+	}
+
+	client_t* cl = &svs.clients[0];	// 0 because only ever us as a player	
+
+	if (!cl)
+	{
+		return;
+	}
+	playerState_t*		pState = cl->gentity->client;
+
+	char itemName[128];
+	Com_sprintf (itemName, sizeof(itemName), "%s_hexpic", powerEnums[forcePowerI].title);
+	item = (itemDef_s *) Menu_FindItemByName(menu, itemName);
+	
+	if (item)
+	{
+		char itemGraphic[128];
+		Com_sprintf (itemGraphic, sizeof(itemGraphic), "gfx/menus/hex_pattern_%d",pState->forcePowerLevel[powerEnums[forcePowerI].powerEnum]);
+		item->window.background = ui.R_RegisterShaderNoMip(itemGraphic);
+
+		// If maxed out on power - don't allow update
+/*		if (pState->forcePowerLevel[powerEnums[forcePowerI].powerEnum]>=3)
+		{
+			Com_sprintf (itemName, sizeof(itemName), "%s_fbutton", powerEnums[forcePowerI].title);
+			item = (itemDef_s *) Menu_FindItemByName(menu, itemName);
+			if (item)		// This is okay, because core powers don't have a hex button
+			{
+				item->window.flags &= ~WINDOW_VISIBLE;
+			}
+		} */
+	}
+
+	// Set weapons button to inactive
+	UI_ForcePowerWeaponsButton(qfalse);
+}
+
+// Flip flop between being able to see the text showing the Force Point has or hasn't been allocated (Used by Force Power Allocation screen) 
+static void UI_SetPowerTitleText ( qboolean showAllocated )
+{
+	menuDef_t	*menu;
+	itemDef_t	*item;
+
+	menu = Menu_GetFocused();	// Get current menu
+
+	if (!menu)
+	{
+		return;
+	}
+
+	if (showAllocated)
+	{
+		// Show the text saying the force point has been allocated
+		item = (itemDef_s *) Menu_FindItemByName(menu, "allocated_text");
+		if (item)
+		{
+			item->window.flags |= WINDOW_VISIBLE;
+		}
+
+		// Hide text saying the force point needs to be allocated
+		item = (itemDef_s *) Menu_FindItemByName(menu, "allocate_text");
+		if (item)
+		{
+			item->window.flags &= ~WINDOW_VISIBLE;
+		}
+	}
+	else
+	{
+		// Hide the text saying the force point has been allocated
+		item = (itemDef_s *) Menu_FindItemByName(menu, "allocated_text");
+		if (item)
+		{
+			item->window.flags &= ~WINDOW_VISIBLE;
+		}
+
+		// Show text saying the force point needs to be allocated
+		item = (itemDef_s *) Menu_FindItemByName(menu, "allocate_text");
+		if (item)
+		{
+			item->window.flags |= WINDOW_VISIBLE;
+		}
+	}
+}
+
+//. Find weapons button and make active/inactive  (Used by Force Power Allocation screen) 
+static void UI_ForcePowerWeaponsButton(qboolean activeFlag)
+{
+	menuDef_t	*menu;
+	menu = Menu_GetFocused();	// Get current menu
+
+	if (!menu)
+	{
+		return;
+	}
+
+	// Find weaponsbutton
+	itemDef_t	*item;
+	item = (itemDef_s *) Menu_FindItemByName(menu, "weaponbutton");
+	if (item)
+	{
+		// Make it active
+		if (activeFlag)
+		{
+			item->window.flags &= ~WINDOW_INACTIVE;
+		}
+		else
+		{
+			item->window.flags |= WINDOW_INACTIVE;
+		}
+	}
+}
+
+void UI_SetItemColor(itemDef_t *item,const char *itemname,const char *name,vec4_t color);
+
+static void UI_SetHexPicLevel( const menuDef_t	*menu,const int forcePowerI,const int powerLevel, const qboolean	goldFlag )
+{
+	char itemName[128];
+	itemDef_t	*item;
+
+	// Find proper hex picture on menu
+	Com_sprintf (itemName, sizeof(itemName), "%s_hexpic", powerEnums[forcePowerI].title);
+	item = (itemDef_s *) Menu_FindItemByName((menuDef_t	*) menu, itemName);
+	
+	// Now give it the proper hex graphic
+	if (item)
+	{
+		char itemGraphic[128];
+		if (goldFlag)
+		{
+			Com_sprintf (itemGraphic, sizeof(itemGraphic), "gfx/menus/hex_pattern_%d_gold",powerLevel);
+		}
+		else
+		{
+			Com_sprintf (itemGraphic, sizeof(itemGraphic),  "gfx/menus/hex_pattern_%d",powerLevel);
+		}
+
+		item->window.background = ui.R_RegisterShaderNoMip(itemGraphic);
+
+		Com_sprintf (itemName, sizeof(itemName), "%s_fbutton", powerEnums[forcePowerI].title);
+		item = (itemDef_s *) Menu_FindItemByName((menuDef_t	*)menu, itemName);
+		if (item)
+		{
+			if (goldFlag)
+			{
+				// Change description text to tell player they can decrement the force point
+				item->descText = "@MENUS_REMOVEFP";
+			}
+			else
+			{
+				// Change description text to tell player they can increment the force point
+				item->descText = "@MENUS_ADDFP";
+			}
+		}
+	}
+}
+
+void UI_SetItemVisible(menuDef_t *menu,const char *itemname,qboolean visible);
+
+// if this is the first time into the force power allocation screen, show the INSTRUCTION screen 
+static void	UI_ForceHelpActive( void )
+{
+	int	tier_storyinfo = Cvar_VariableIntegerValue( "tier_storyinfo" );
+
+	// First time, show instructions
+	if (tier_storyinfo==1)
+	{
+//		Menus_OpenByName("ingameForceHelp");
+		Menus_ActivateByName("ingameForceHelp");
+	}
+}
+
+
+// Shut down the help screen in the force power allocation screen
+static void UI_ShutdownForceHelp( void )
+{
+	int i;
+	char itemName[128];
+	menuDef_t	*menu;
+	itemDef_t	*item;
+	vec4_t color = { 0.65f, 0.65f, 0.65f, 1.0f};
+
+	menu = Menu_GetFocused();	// Get current menu
+
+	if (!menu)
+	{
+		return;
+	}
+
+	// Not in upgrade mode so turn on all the force buttons, the big forceicon and description text
+	if (uiInfo.forcePowerUpdated == FP_UPDATED_NONE)
+	{
+		// We just decremented a field so turn all buttons back on
+		// Make it so all  buttons can be clicked
+		for (i=0;i<MAX_POWER_ENUMS;i++)
+		{
+			Com_sprintf (itemName, sizeof(itemName), "%s_fbutton", powerEnums[i].title);
+
+			UI_SetItemVisible(menu,itemName,qtrue);
+		}
+
+		UI_SetItemVisible(menu,"force_icon",qtrue);
+		UI_SetItemVisible(menu,"force_desc",qtrue);
+		UI_SetItemVisible(menu,"leveltext",qtrue);
+
+		// Set focus on the top left button
+		item = (itemDef_s *) Menu_FindItemByName(menu, "absorb_fbutton");
+		item->window.flags |= WINDOW_HASFOCUS;
+
+		if (item->onFocus) 
+		{
+			Item_RunScript(item, item->onFocus);
+		}
+
+	}
+	// In upgrade mode so just turn the deallocate button on
+	else
+	{
+		UI_SetItemVisible(menu,"force_icon",qtrue);
+		UI_SetItemVisible(menu,"force_desc",qtrue);
+		UI_SetItemVisible(menu,"deallocate_fbutton",qtrue);
+
+		item = (itemDef_s *) Menu_FindItemByName(menu, va("%s_fbutton",powerEnums[uiInfo.forcePowerUpdated].title));
+		if (item)
+		{
+	#ifdef _XBOX
+			Item_SetFocus(item, 0,0); 
+	#else
+			item->window.flags |= WINDOW_HASFOCUS;
+	#endif
+		}
+
+		// Get player state
+		client_t* cl = &svs.clients[0];	// 0 because only ever us as a player	
+
+		if (!cl)	// No client, get out
+		{
+			return;
+		}
+
+		playerState_t*		pState = cl->gentity->client;
+
+
+		if (uiInfo.forcePowerUpdated == FP_UPDATED_NONE)
+		{
+			return;
+		}
+
+		// Update level description
+		Com_sprintf (
+			itemName, 
+			sizeof(itemName), 
+			"%s_level%ddesc", 
+			powerEnums[uiInfo.forcePowerUpdated].title,
+			pState->forcePowerLevel[powerEnums[uiInfo.forcePowerUpdated].powerEnum]
+			);
+
+		item = (itemDef_s *) Menu_FindItemByName(menu, itemName);
+		if (item)		
+		{
+			item->window.flags |= WINDOW_VISIBLE;
+		}
+	}
+
+	// If one was a chosen force power, high light it again.
+	if (uiInfo.forcePowerUpdated>FP_UPDATED_NONE)
+	{
+		char itemhexName[128];
+		char itemiconName[128];
+		vec4_t color2 = { 1.0f, 1.0f, 1.0f, 1.0f};
+
+		Com_sprintf (itemhexName, sizeof(itemhexName), "%s_hexpic", powerEnums[uiInfo.forcePowerUpdated].title);
+		Com_sprintf (itemiconName, sizeof(itemiconName), "%s_iconpic", powerEnums[uiInfo.forcePowerUpdated].title);
+		
+		UI_SetItemColor(item,itemhexName,"forecolor",color2);
+		UI_SetItemColor(item,itemiconName,"forecolor",color2);
+	}
+	else
+	{
+		// Un-grey-out all icons
+		UI_SetItemColor(item,"hexpic","forecolor",color);
+		UI_SetItemColor(item,"iconpic","forecolor",color);
+	}
+}
+
+// Decrement force power level (Used by Force Power Allocation screen) 
+static void UI_DecrementCurrentForcePower ( void )
+{
+	menuDef_t	*menu;
+	itemDef_t	*item;
+	short i;
+	vec4_t color = { 0.65f, 0.65f, 0.65f, 1.0f};
+	char itemName[128];
+
+	menu = Menu_GetFocused();	// Get current menu
+
+	if (!menu)
+	{
+		return;
+	}
+
+	// Get player state
+	client_t* cl = &svs.clients[0];	// 0 because only ever us as a player	
+
+	if (!cl)	// No client, get out
+	{
+		return;
+	}
+
+	playerState_t*		pState = cl->gentity->client;
+
+
+	if (uiInfo.forcePowerUpdated == FP_UPDATED_NONE)
+	{
+		return;
+	}
+
+	DC->startLocalSound(uiInfo.uiDC.Assets.forceUnchosenSound, CHAN_AUTO );
+
+	if (pState->forcePowerLevel[powerEnums[uiInfo.forcePowerUpdated].powerEnum]>0)
+	{
+		pState->forcePowerLevel[powerEnums[uiInfo.forcePowerUpdated].powerEnum]--;	// Decrement it
+		// Turn off power if level is 0
+		if (pState->forcePowerLevel[powerEnums[uiInfo.forcePowerUpdated].powerEnum]<1)
+		{
+			pState->forcePowersKnown &= ~( 1 << powerEnums[uiInfo.forcePowerUpdated].powerEnum );
+		}
+	}
+
+	UI_SetHexPicLevel( menu,uiInfo.forcePowerUpdated,pState->forcePowerLevel[powerEnums[uiInfo.forcePowerUpdated].powerEnum],qfalse );
+	
+	UI_ShowForceLevelDesc ( powerEnums[uiInfo.forcePowerUpdated].title );
+
+	// We just decremented a field so turn all buttons back on
+	// Make it so all  buttons can be clicked
+	for (i=0;i<MAX_POWER_ENUMS;i++)
+	{
+		Com_sprintf (itemName, sizeof(itemName), "%s_fbutton", powerEnums[i].title);
+		item = (itemDef_s *) Menu_FindItemByName(menu, itemName);
+		if (item)		// This is okay, because core powers don't have a hex button
+		{
+			item->window.flags |= WINDOW_VISIBLE;
+		}
+	}
+
+	// Show point has not been allocated
+	UI_SetPowerTitleText( qfalse);
+
+	// Make weapons button active
+	UI_ForcePowerWeaponsButton(qfalse);
+
+	// Hide the deallocate button
+	item = (itemDef_s *) Menu_FindItemByName(menu, "deallocate_fbutton");
+	if (item)
+	{
+		item->window.flags &= ~WINDOW_VISIBLE;	// 
+
+		// Un-grey-out all icons
+		UI_SetItemColor(item,"hexpic","forecolor",color);
+		UI_SetItemColor(item,"iconpic","forecolor",color);
+	}
+
+	item = (itemDef_s *) Menu_FindItemByName(menu, va("%s_fbutton",powerEnums[uiInfo.forcePowerUpdated].title));
+	if (item)
+	{
+#ifdef _XBOX
+		Item_SetFocus(item, 0,0); 
+#else
+		item->window.flags |= WINDOW_HASFOCUS;
+#endif
+	}
+
+	uiInfo.forcePowerUpdated = FP_UPDATED_NONE;			// It's as if nothing happened.
+}
+
+void Item_MouseEnter(itemDef_t *item, float x, float y);
+
+// Try to increment force power level (Used by Force Power Allocation screen) 
+static void UI_AffectForcePowerLevel ( const char *forceName )
+{
+	short forcePowerI=0,i;
+	menuDef_t	*menu;
+	itemDef_t	*item;
+
+	menu = Menu_GetFocused();	// Get current menu
+
+	if (!menu)
+	{
+		return;
+	}
+
+	if (!UI_GetForcePowerIndex ( forceName, &forcePowerI ))
+	{
+		return;
+	}
+
+	// Get player state
+	client_t* cl = &svs.clients[0];	// 0 because only ever us as a player	
+
+	if (!cl)	// No client, get out
+	{
+		return;
+	}
+	playerState_t*		pState = cl->gentity->client;
+
+	if (pState->forcePowerLevel[powerEnums[forcePowerI].powerEnum]>2)
+	{	// Too big, can't be incremented
+		return;
+	}
+
+	// Increment power level.
+	DC->startLocalSound(uiInfo.uiDC.Assets.forceChosenSound, CHAN_AUTO );
+
+	uiInfo.forcePowerUpdated = forcePowerI;	// Remember which power was updated
+
+	pState->forcePowerLevel[powerEnums[forcePowerI].powerEnum]++;	// Increment it
+	pState->forcePowersKnown |= ( 1 << powerEnums[forcePowerI].powerEnum );
+
+	UI_SetHexPicLevel( menu,uiInfo.forcePowerUpdated,pState->forcePowerLevel[powerEnums[forcePowerI].powerEnum],qtrue );
+
+	UI_ShowForceLevelDesc ( forceName );
+
+	// A field was updated, so make it so others can't be
+	if (uiInfo.forcePowerUpdated>FP_UPDATED_NONE)
+	{
+		vec4_t color = { 0.25f, 0.25f, 0.25f, 1.0f};
+		char itemName[128];
+
+		// Make it so none of the other buttons can be clicked
+		for (i=0;i<MAX_POWER_ENUMS;i++)
+		{
+			if (i==uiInfo.forcePowerUpdated)
+			{
+				continue;
+			}
+
+			Com_sprintf (itemName, sizeof(itemName), "%s_fbutton", powerEnums[i].title);
+			item = (itemDef_s *) Menu_FindItemByName(menu, itemName);
+			if (item)		// This is okay, because core powers don't have a hex button
+			{
+				item->window.flags &= ~WINDOW_VISIBLE;
+			}
+		}
+
+		// Show point has been allocated
+		UI_SetPowerTitleText ( qtrue );
+
+		// Make weapons button active
+		UI_ForcePowerWeaponsButton(qtrue);
+
+		// Make user_info 
+		Cvar_Set ( "ui_forcepower_inc", va("%d",uiInfo.forcePowerUpdated) );		
+
+		// Just grab an item to hand it to the function.
+		item = (itemDef_s *) Menu_FindItemByName(menu, "deallocate_fbutton");
+
+		if (item)
+		{
+			// Show all icons as greyed-out
+			UI_SetItemColor(item,"hexpic","forecolor",color);
+			UI_SetItemColor(item,"iconpic","forecolor",color);
+
+#ifdef _XBOX
+			Item_SetFocus(item, 0,0); 
+#else
+			item->window.flags |= WINDOW_HASFOCUS;
+#endif
+		}
+	}
+
+}
+
+static void UI_DecrementForcePowerLevel( void )
+{
+	int	forcePowerI = Cvar_VariableIntegerValue( "ui_forcepower_inc" );
+	// Get player state
+	client_t* cl = &svs.clients[0];	// 0 because only ever us as a player	
+
+	if (!cl)	// No client, get out
+	{
+		return;
+	}
+
+	playerState_t*		pState = cl->gentity->client;
+
+	pState->forcePowerLevel[powerEnums[forcePowerI].powerEnum]--;	// Decrement it
+
+}
+
+// Show force level description that matches current player level (Used by Force Power Allocation screen) 
+static void UI_ShowForceLevelDesc ( const char *forceName )
+{
+	short forcePowerI=0;
+	menuDef_t	*menu;
+	itemDef_t	*item;
+	menu = Menu_GetFocused();	// Get current menu
+
+	if (!menu)
+	{
+		return;
+	}
+
+	
+	if (!UI_GetForcePowerIndex ( forceName, &forcePowerI ))
+	{
+		return;
+	}
+
+	// Get player state
+	client_t* cl = &svs.clients[0];	// 0 because only ever us as a player	
+
+	if (!cl)	// No client, get out
+	{
+		return;
+	}
+	playerState_t*		pState = cl->gentity->client;
+
+	char itemName[128];
+
+	// Update level description
+	Com_sprintf (
+		itemName, 
+		sizeof(itemName), 
+		"%s_level%ddesc", 
+		powerEnums[forcePowerI].title,
+		pState->forcePowerLevel[powerEnums[forcePowerI].powerEnum]
+		);
+
+	item = (itemDef_s *) Menu_FindItemByName(menu, itemName);
+	if (item)		
+	{
+		item->window.flags |= WINDOW_VISIBLE;
+	}
+
+}
+
+// Reset force level powers screen to what it was before player upgraded them (Used by Force Power Allocation screen) 
+static void UI_ResetForceLevels ( void )
+{
+
+	// What force ppower had the point added to it?
+	if (uiInfo.forcePowerUpdated!=FP_UPDATED_NONE)
+	{
+		// Get player state
+		client_t* cl = &svs.clients[0];	// 0 because only ever us as a player	
+
+		if (!cl)	// No client, get out
+		{
+			return;
+		}
+		playerState_t*		pState = cl->gentity->client;
+
+		// Decrement that power
+		pState->forcePowerLevel[powerEnums[uiInfo.forcePowerUpdated].powerEnum]--;
+
+		menuDef_t	*menu;
+		itemDef_t	*item;
+
+		menu = Menu_GetFocused();	// Get current menu
+
+		if (!menu)
+		{
+			return;
+		}
+
+		int i;
+		char itemName[128];
+
+		// Make it so all  buttons can be clicked
+		for (i=0;i<MAX_POWER_ENUMS;i++)
+		{
+			Com_sprintf (itemName, sizeof(itemName), "%s_fbutton", powerEnums[i].title);
+			item = (itemDef_s *) Menu_FindItemByName(menu, itemName);
+			if (item)		// This is okay, because core powers don't have a hex button
+			{
+				item->window.flags |= WINDOW_VISIBLE;
+			}
+		}
+
+		UI_SetPowerTitleText( qfalse );
+
+		Com_sprintf (itemName, sizeof(itemName), "%s_fbutton", powerEnums[uiInfo.forcePowerUpdated].title);
+		item = (itemDef_s *) Menu_FindItemByName(menu, itemName);
+		if (item)
+		{
+			// Change description text to tell player they can increment the force point
+			item->descText = "@MENUS_ADDFP";
+		}
+
+		uiInfo.forcePowerUpdated = FP_UPDATED_NONE;
+	}
+
+	UI_ForcePowerWeaponsButton(qfalse);
+}
+
+
+// Set the Players known saber style
+static void UI_UpdateFightingStyle ( void )
+{
+	playerState_t	*pState;
+	int				fightingStyle,saberStyle;
+
+
+	fightingStyle = Cvar_VariableIntegerValue( "ui_newfightingstyle" );
+
+	if (fightingStyle == 1)
+	{
+		saberStyle = SS_MEDIUM;
+	}
+	else if (fightingStyle == 2)
+	{
+		saberStyle = SS_STRONG;
+	}
+	else // 0 is Fast
+	{
+		saberStyle = SS_FAST;
+	}
+
+	// Get player state
+	client_t	*cl = &svs.clients[0];	// 0 because only ever us as a player	
+
+	// No client, get out
+	if (cl && cl->gentity && cl->gentity->client)
+	{
+		pState = cl->gentity->client;
+		pState->saberStylesKnown |= (1<<saberStyle);
+	}
+	else	// Must be at the beginning of the game so the client hasn't been created, shove data in a cvar
+	{
+		Cvar_Set ( "g_fighting_style", va("%d",saberStyle) );		
+	}
+}
+
+static void UI_ResetCharacterListBoxes( void )
+{
+
+	itemDef_t *item;
+	menuDef_t *menu;
+	listBoxDef_t *listPtr;
+
+	menu = Menus_FindByName("characterMenu");
+	
+
+	if (menu)
+	{
+		item = (itemDef_s *) Menu_FindItemByName((menuDef_t *) menu, "headlistbox");
+		if (item)
+		{
+			listBoxDef_t *listPtr = (listBoxDef_t*)item->typeData;
+			if( listPtr )
+			{
+				listPtr->cursorPos = 0;
+			}
+			item->cursorPos = 0;
+		}
+
+		item = (itemDef_s *) Menu_FindItemByName((menuDef_t *) menu, "torsolistbox");
+		if (item)
+		{
+			listPtr = (listBoxDef_t*)item->typeData;
+			if( listPtr )
+			{
+				listPtr->cursorPos = 0;
+			}
+			item->cursorPos = 0;
+		}
+
+		item = (itemDef_s *) Menu_FindItemByName((menuDef_t *) menu, "lowerlistbox");
+		if (item)
+		{
+			listPtr = (listBoxDef_t*)item->typeData;
+			if( listPtr )
+			{
+				listPtr->cursorPos = 0;
+			}
+			item->cursorPos = 0;
+		}
+
+		item = (itemDef_t *) Menu_FindItemByName((menuDef_t *) menu, "colorbox");
+		if (item)
+		{
+			listPtr = (listBoxDef_t*)item->typeData;
+			if( listPtr )
+			{
+				listPtr->cursorPos = 0;
+			}
+			item->cursorPos = 0;
+		}
+	}
+}
+
+static void UI_ClearInventory ( void )
+{
+	// Get player state
+	client_t* cl = &svs.clients[0];	// 0 because only ever us as a player	
+
+	if (!cl)	// No client, get out
+	{
+		return;
+	}
+
+	if (cl->gentity && cl->gentity->client)
+	{
+		playerState_t*		pState = cl->gentity->client;
+
+		// Clear out inventory for the player
+		int i;
+		for (i=0;i<MAX_INVENTORY;i++)
+		{
+			pState->inventory[i] = 0;
+		}
+	}
+}
+
+static void UI_GiveInventory ( const int itemIndex, const int amount )
+{
+	// Get player state
+	client_t* cl = &svs.clients[0];	// 0 because only ever us as a player	
+
+	if (!cl)	// No client, get out
+	{
+		return;
+	}
+
+	if (cl->gentity && cl->gentity->client)
+	{
+		playerState_t*	pState = cl->gentity->client;
+
+		if (itemIndex < MAX_INVENTORY)
+		{
+			pState->inventory[itemIndex]=amount;
+		}
+	}
+
+}
+
+//. Find weapons allocation screen BEGIN button and make active/inactive 
+static void UI_WeaponAllocBeginButton(qboolean activeFlag)
+{
+	menuDef_t	*menu;
+	menu = Menu_GetFocused();	// Get current menu
+
+	if (!menu)
+	{
+		return;
+	}
+
+	int weap =	Cvar_VariableIntegerValue( "weapon_menu" );
+	
+	// Find begin button
+	itemDef_t	*item;
+	item = Menu_GetMatchingItemByNumber(menu, weap, "beginmission");
+
+	if (item)
+	{
+		// Make it active
+		if (activeFlag)
+		{
+			item->window.flags &= ~WINDOW_INACTIVE;
+		}
+		else
+		{
+			item->window.flags |= WINDOW_INACTIVE;
+		}
+	}
+}
+
+// If we have both weapons and the throwable weapon, turn on the begin mission button, 
+// otherwise, turn it off
+static void UI_WeaponsSelectionsComplete( void )
+{
+	// We need two weapons and one throwable
+	if (( uiInfo.selectedWeapon1 != NOWEAPON ) &&
+		( uiInfo.selectedWeapon2 != NOWEAPON ) &&
+		( uiInfo.selectedThrowWeapon != NOWEAPON ))
+	{
+		UI_WeaponAllocBeginButton(qtrue);	// Turn it on
+	}
+	else
+	{
+		UI_WeaponAllocBeginButton(qfalse);	// Turn it off
+	}
+}
+
+// if this is the first time into the weapon allocation screen, show the INSTRUCTION screen 
+static void	UI_WeaponHelpActive( void )
+{
+	int	tier_storyinfo = Cvar_VariableIntegerValue( "tier_storyinfo" );
+	menuDef_t	*menu;
+
+	menu = Menu_GetFocused();	// Get current menu
+
+	if (!menu)
+	{
+		return;
+	}
+
+	// First time, show instructions
+	if (tier_storyinfo==1)
+	{
+		UI_SetItemVisible(menu,"weapon_button",qfalse);
+
+		UI_SetItemVisible(menu,"inst_stuff",qtrue);
+
+	}
+	// just act like normal
+	else
+	{
+		UI_SetItemVisible(menu,"weapon_button",qtrue);
+
+		UI_SetItemVisible(menu,"inst_stuff",qfalse);
+	}
+}
+
+static void UI_InitWeaponSelect( void )
+{
+	UI_WeaponAllocBeginButton(qfalse);
+	uiInfo.selectedWeapon1 = NOWEAPON;
+	uiInfo.selectedWeapon2 = NOWEAPON;
+	uiInfo.selectedThrowWeapon = NOWEAPON;
+}
+
+static void UI_ClearWeapons ( void )
+{
+	// Get player state
+	client_t* cl = &svs.clients[0];	// 0 because only ever us as a player	
+
+	if (!cl)	// No client, get out
+	{
+		return;
+	}
+
+	if (cl->gentity && cl->gentity->client)
+	{
+		playerState_t*		pState = cl->gentity->client;
+
+		// Clear out any weapons for the player
+		pState->stats[ STAT_WEAPONS ] = 0;
+
+		pState->weapon = WP_NONE;
+		
+	}
+
+}
+
+static void UI_GiveWeapon ( const int weaponIndex )
+{
+	// Get player state
+	client_t* cl = &svs.clients[0];	// 0 because only ever us as a player	
+
+	if (!cl)	// No client, get out
+	{
+		return;
+	}
+
+	if (cl->gentity && cl->gentity->client)
+	{
+		playerState_t*	pState = cl->gentity->client;
+
+		if (weaponIndex<WP_NUM_WEAPONS)
+		{
+			pState->stats[ STAT_WEAPONS ] |= ( 1 << weaponIndex );
+		}
+	}
+}
+
+static void UI_EquipWeapon ( const int weaponIndex )
+{
+	// Get player state
+	client_t* cl = &svs.clients[0];	// 0 because only ever us as a player	
+
+	if (!cl)	// No client, get out
+	{
+		return;
+	}
+
+	if (cl->gentity && cl->gentity->client)
+	{
+		playerState_t*	pState = cl->gentity->client;
+
+		if (weaponIndex<WP_NUM_WEAPONS)
+		{
+			pState->weapon = weaponIndex;
+			//force it to change
+			//CG_ChangeWeapon( wp );
+		}
+	}
+}
+
+static void	UI_LoadMissionSelectMenu( const char *cvarName )
+{
+	int holdLevel = (int)trap_Cvar_VariableValue(cvarName);
+
+	// Figure out which tier menu to load 
+	if ((holdLevel > 0) && (holdLevel < 5))
+	{
+		UI_LoadMenus("ui/tier1.txt",qfalse);
+
+		Menus_CloseByName("ingameMissionSelect1");
+	}
+	else if ((holdLevel > 6) && (holdLevel < 10))
+	{
+		UI_LoadMenus("ui/tier2.txt",qfalse);
+
+		Menus_CloseByName("ingameMissionSelect2");
+	}
+	else if ((holdLevel > 11) && (holdLevel < 15))
+	{
+		UI_LoadMenus("ui/tier3.txt",qfalse);
+
+		Menus_CloseByName("ingameMissionSelect3");
+	}
+
+}
+
+// Update the player weapons with the chosen weapon
+static void	UI_AddWeaponSelection ( const int weaponIndex, const int ammoIndex, const int ammoAmount, const char *iconItemName,const char *litIconItemName, const char *hexBackground, const char *soundfile )
+{
+	itemDef_s  *item, *iconItem,*litIconItem;
+	menuDef_t	*menu;
+
+	menu = Menu_GetFocused();	// Get current menu
+
+	if (!menu)
+	{
+		return;
+	}
+
+	iconItem = (itemDef_s *) Menu_FindItemByName(menu, iconItemName );
+	litIconItem = (itemDef_s *) Menu_FindItemByName(menu, litIconItemName );
+
+	char *chosenItemName, *chosenButtonName;
+
+	// has this weapon already been chosen?
+	if (weaponIndex == uiInfo.selectedWeapon1)
+	{
+		UI_RemoveWeaponSelection ( 1 );
+		return;
+	}
+	else if (weaponIndex == uiInfo.selectedWeapon2)
+	{
+		UI_RemoveWeaponSelection ( 2 );
+		return;
+	}
+
+	// See if either slot is empty
+	if ( uiInfo.selectedWeapon1 == NOWEAPON )
+	{
+		chosenItemName = "chosenweapon1_icon";
+		chosenButtonName = "chosenweapon1_button";
+		uiInfo.selectedWeapon1 = weaponIndex;
+		uiInfo.selectedWeapon1AmmoIndex = ammoIndex;
+
+		memcpy( uiInfo.selectedWeapon1ItemName,hexBackground,sizeof(uiInfo.selectedWeapon1ItemName));
+
+		//Save the lit and unlit icons for the selected weapon slot
+		uiInfo.litWeapon1Icon = litIconItem->window.background;
+		uiInfo.unlitWeapon1Icon = iconItem->window.background;
+
+		uiInfo.weapon1ItemButton = uiInfo.runScriptItem;
+		uiInfo.weapon1ItemButton->descText = "@MENUS_CLICKREMOVE";
+	}
+	else if ( uiInfo.selectedWeapon2 == NOWEAPON )
+	{
+		chosenItemName = "chosenweapon2_icon";
+		chosenButtonName = "chosenweapon2_button";
+		uiInfo.selectedWeapon2 = weaponIndex;
+		uiInfo.selectedWeapon2AmmoIndex = ammoIndex;
+
+		memcpy( uiInfo.selectedWeapon2ItemName,hexBackground,sizeof(uiInfo.selectedWeapon2ItemName));
+
+		//Save the lit and unlit icons for the selected weapon slot
+		uiInfo.litWeapon2Icon = litIconItem->window.background;
+		uiInfo.unlitWeapon2Icon = iconItem->window.background;
+
+		uiInfo.weapon2ItemButton = uiInfo.runScriptItem;
+		uiInfo.weapon2ItemButton->descText = "@MENUS_CLICKREMOVE";
+	}
+	else	// Both slots are used, can't add it.
+	{
+		return;
+	}
+
+	item = (itemDef_s *) Menu_FindItemByName(menu, chosenItemName );
+	if ((item) && (iconItem))
+	{
+		item->window.background = iconItem->window.background;
+		item->window.flags |= WINDOW_VISIBLE;
+	}
+
+	// Turn on chosenweapon button so player can unchoose the weapon
+	item = (itemDef_s *) Menu_FindItemByName(menu, chosenButtonName );
+	if (item)
+	{
+		item->window.background = iconItem->window.background;
+		item->window.flags |= WINDOW_VISIBLE;
+	}
+
+	// Switch hex background to be 'on'
+	item = (itemDef_s *) Menu_FindItemByName(menu, hexBackground );
+	if (item)
+	{
+		item->window.foreColor[0] = 0;
+		item->window.foreColor[1] = 1;
+		item->window.foreColor[2] = 0;
+		item->window.foreColor[3] = 1;
+
+	}
+
+	// Get player state
+	client_t* cl = &svs.clients[0];	// 0 because only ever us as a player	
+
+	if (!cl)	// No client, get out
+	{
+		return;
+	}
+
+	// Add weapon
+	if (cl->gentity && cl->gentity->client)
+	{
+		playerState_t*	pState = cl->gentity->client;
+
+		if ((weaponIndex>0) && (weaponIndex<WP_NUM_WEAPONS))
+		{
+			pState->stats[ STAT_WEAPONS ] |= ( 1 << weaponIndex );
+		}
+
+		// Give them ammo too
+		if ((ammoIndex>0) && (ammoIndex<AMMO_MAX))
+		{
+			pState->ammo[ ammoIndex ] = ammoAmount;
+		}
+	}
+
+	if( soundfile )
+	{
+		DC->startLocalSound(DC->registerSound(soundfile, qfalse), CHAN_LOCAL );	
+	}
+
+	UI_WeaponsSelectionsComplete();	// Test to see if the mission begin button should turn on or off
+
+
+}
+
+
+// Update the player weapons with the chosen weapon
+static void UI_RemoveWeaponSelection ( const int weaponSelectionIndex )
+{
+	itemDef_s  *item;
+	menuDef_t	*menu;
+	char *chosenItemName, *chosenButtonName,*background;
+	int		ammoIndex,weaponIndex;
+
+	menu = Menu_GetFocused();	// Get current menu
+
+	// Which item has it?
+	if ( weaponSelectionIndex == 1 )
+	{
+		chosenItemName = "chosenweapon1_icon";
+		chosenButtonName = "chosenweapon1_button";
+		background = uiInfo.selectedWeapon1ItemName;
+		ammoIndex = uiInfo.selectedWeapon1AmmoIndex;
+		weaponIndex = uiInfo.selectedWeapon1;
+
+		if (uiInfo.weapon1ItemButton)
+		{
+			uiInfo.weapon1ItemButton->descText = "@MENUS_CLICKSELECT";
+			uiInfo.weapon1ItemButton = NULL;
+		}
+	}
+	else if ( weaponSelectionIndex == 2 )
+	{
+		chosenItemName = "chosenweapon2_icon";
+		chosenButtonName = "chosenweapon2_button";
+		background = uiInfo.selectedWeapon2ItemName;
+		ammoIndex = uiInfo.selectedWeapon2AmmoIndex;
+		weaponIndex = uiInfo.selectedWeapon2;
+
+		if (uiInfo.weapon2ItemButton)
+		{
+			uiInfo.weapon2ItemButton->descText = "@MENUS_CLICKSELECT";
+			uiInfo.weapon2ItemButton = NULL;
+		}
+	}
+	else
+	{
+		return;
+	}
+
+	// Reset background of upper icon
+	item = (itemDef_s *) Menu_FindItemByName( menu, background );
+	if ( item )
+	{
+		item->window.foreColor[0] = 0.0f;
+		item->window.foreColor[1] = 0.5f;
+		item->window.foreColor[2] = 0.0f;
+		item->window.foreColor[3] = 1.0f;
+	}
+
+	// Hide it icon
+	item = (itemDef_s *) Menu_FindItemByName( menu, chosenItemName );
+	if ( item )
+	{
+		item->window.flags &= ~WINDOW_VISIBLE;
+	}
+
+	// Hide button
+	item = (itemDef_s *) Menu_FindItemByName( menu, chosenButtonName );
+	if ( item )
+	{
+		item->window.flags &= ~WINDOW_VISIBLE;
+	}
+
+	// Get player state
+	client_t* cl = &svs.clients[0];	// 0 because only ever us as a player	
+
+	if (!cl)	// No client, get out
+	{
+		return;
+	}
+
+	// Remove weapon
+	if (cl->gentity && cl->gentity->client)
+	{
+		playerState_t*	pState = cl->gentity->client;
+
+		if ((weaponIndex>0) && (weaponIndex<WP_NUM_WEAPONS))
+		{
+			pState->stats[ STAT_WEAPONS ]  &= ~( 1 << weaponIndex );
+		}
+
+		// Remove ammo too
+		if ((ammoIndex>0) && (ammoIndex<AMMO_MAX))
+		{	// But don't take it away if the other weapon is using that ammo
+			if ( uiInfo.selectedWeapon1AmmoIndex != uiInfo.selectedWeapon2AmmoIndex )
+			{
+				pState->ammo[ ammoIndex ] = 0;
+			}
+		}
+	}
+
+	// Now do a little clean up
+	if ( weaponSelectionIndex == 1 )
+	{
+		uiInfo.selectedWeapon1 = NOWEAPON;
+		memset(uiInfo.selectedWeapon1ItemName,0,sizeof(uiInfo.selectedWeapon1ItemName));
+		uiInfo.selectedWeapon1AmmoIndex = 0;
+	}
+	else if ( weaponSelectionIndex == 2 )
+	{
+		uiInfo.selectedWeapon2 = NOWEAPON;
+		memset(uiInfo.selectedWeapon2ItemName,0,sizeof(uiInfo.selectedWeapon2ItemName));
+		uiInfo.selectedWeapon2AmmoIndex = 0;
+	}
+
+	DC->startLocalSound(DC->registerSound("sound/interface/weapon_deselect.mp3", qfalse), CHAN_LOCAL );
+
+	UI_WeaponsSelectionsComplete();	// Test to see if the mission begin button should turn on or off
+
+
+}
+
+static void	UI_NormalWeaponSelection ( const int selectionslot )
+{
+	itemDef_s  *item;
+	menuDef_t	*menu;
+
+	menu = Menu_GetFocused();	// Get current menu
+	if (!menu)
+	{
+		return;
+	}
+
+	if (selectionslot == 1)
+	{
+		item = (itemDef_s *) Menu_FindItemByName( menu, "chosenweapon1_icon" );
+		if (item)
+		{
+			item->window.background = uiInfo.unlitWeapon1Icon;
+		}
+	}
+
+	if (selectionslot == 2)
+	{
+		item = (itemDef_s *) Menu_FindItemByName( menu, "chosenweapon2_icon" );
+		if (item)
+		{
+			item->window.background = uiInfo.unlitWeapon2Icon;
+		}
+	}
+}
+
+static void	UI_HighLightWeaponSelection ( const int selectionslot )
+{
+	itemDef_s  *item;
+	menuDef_t	*menu;
+
+	menu = Menu_GetFocused();	// Get current menu
+	if (!menu)
+	{
+		return;
+	}
+
+	if (selectionslot == 1)
+	{
+		item = (itemDef_s *) Menu_FindItemByName( menu, "chosenweapon1_icon" );
+		if (item)
+		{
+			item->window.background = uiInfo.litWeapon1Icon;
+		}
+	}
+
+	if (selectionslot == 2)
+	{
+		item = (itemDef_s *) Menu_FindItemByName( menu, "chosenweapon2_icon" );
+		if (item)
+		{
+			item->window.background = uiInfo.litWeapon2Icon;
+		}
+	}
+}
+
+// Update the player throwable weapons (okay it's a bad description) with the chosen weapon
+static void	UI_AddThrowWeaponSelection ( const int weaponIndex, const int ammoIndex, const int ammoAmount, const char *iconItemName,const char *litIconItemName, const char *hexBackground, const char *soundfile )
+{
+	itemDef_s  *item, *iconItem,*litIconItem;
+	menuDef_t	*menu;
+
+	menu = Menu_GetFocused();	// Get current menu
+
+	if (!menu)
+	{
+		return;
+	}
+
+	iconItem = (itemDef_s *) Menu_FindItemByName(menu, iconItemName );
+	litIconItem = (itemDef_s *) Menu_FindItemByName(menu, litIconItemName );
+
+	char *chosenItemName, *chosenButtonName;
+
+	// Has a throw weapon already been chosen?
+	if (uiInfo.selectedThrowWeapon!=NOWEAPON)
+	{
+		// Clicked on the selected throwable weapon
+		if (uiInfo.selectedThrowWeapon==weaponIndex)
+		{	// Deselect it
+			UI_RemoveThrowWeaponSelection();
+		}
+		return;
+	}
+
+	chosenItemName = "chosenthrowweapon_icon";
+	chosenButtonName = "chosenthrowweapon_button";
+	uiInfo.selectedThrowWeapon = weaponIndex;
+	uiInfo.selectedThrowWeaponAmmoIndex = ammoIndex;
+	uiInfo.weaponThrowButton = uiInfo.runScriptItem;
+
+	if (uiInfo.weaponThrowButton)
+	{
+		uiInfo.weaponThrowButton->descText = "@MENUS_CLICKREMOVE";
+	}
+
+	memcpy( uiInfo.selectedThrowWeaponItemName,hexBackground,sizeof(uiInfo.selectedWeapon1ItemName));
+
+	//Save the lit and unlit icons for the selected weapon slot
+	uiInfo.litThrowableIcon = litIconItem->window.background;
+	uiInfo.unlitThrowableIcon = iconItem->window.background;
+
+	item = (itemDef_s *) Menu_FindItemByName(menu, chosenItemName );
+	if ((item) && (iconItem))
+	{
+		item->window.background = iconItem->window.background;
+		item->window.flags |= WINDOW_VISIBLE;
+	}
+
+	// Turn on throwchosenweapon button so player can unchoose the weapon
+	item = (itemDef_s *) Menu_FindItemByName(menu, chosenButtonName );
+	if (item)
+	{
+		item->window.background = iconItem->window.background;
+		item->window.flags |= WINDOW_VISIBLE;
+	}
+
+	// Switch hex background to be 'on'
+	item = (itemDef_s *) Menu_FindItemByName(menu, hexBackground );
+	if (item)
+	{
+		item->window.foreColor[0] = 0.0f;
+		item->window.foreColor[1] = 0.0f;
+		item->window.foreColor[2] = 1.0f;
+		item->window.foreColor[3] = 1.0f;
+
+	}
+
+	// Get player state
+
+	client_t* cl = &svs.clients[0];	// 0 because only ever us as a player	
+
+	if (!cl)	// No client, get out
+	{
+		return;
+	}
+
+	// Add weapon
+	if (cl->gentity && cl->gentity->client)
+	{
+		playerState_t*	pState = cl->gentity->client;
+
+		if ((weaponIndex>0) && (weaponIndex<WP_NUM_WEAPONS))
+		{
+			pState->stats[ STAT_WEAPONS ] |= ( 1 << weaponIndex );
+		}
+
+		// Give them ammo too
+		if ((ammoIndex>0) && (ammoIndex<AMMO_MAX))
+		{
+			pState->ammo[ ammoIndex ] = ammoAmount;
+		}
+	}
+
+	if( soundfile )
+	{
+		DC->startLocalSound(DC->registerSound(soundfile, qfalse), CHAN_LOCAL );	
+	}
+
+	UI_WeaponsSelectionsComplete();	// Test to see if the mission begin button should turn on or off
+
+}
+
+
+// Update the player weapons with the chosen throw weapon
+static void UI_RemoveThrowWeaponSelection ( void )
+{
+	itemDef_s  *item;
+	menuDef_t	*menu;
+	char *chosenItemName, *chosenButtonName,*background;
+
+	menu = Menu_GetFocused();	// Get current menu
+
+	// Weapon not chosen
+	if ( uiInfo.selectedThrowWeapon == NOWEAPON )
+	{
+		return;
+	}
+
+	chosenItemName = "chosenthrowweapon_icon";
+	chosenButtonName = "chosenthrowweapon_button";
+	background = uiInfo.selectedThrowWeaponItemName;
+
+	// Reset background of upper icon
+	item = (itemDef_s *) Menu_FindItemByName( menu, background );
+	if ( item )
+	{
+		item->window.foreColor[0] = 0.0f;
+		item->window.foreColor[1] = 0.0f;
+		item->window.foreColor[2] = 0.5f;
+		item->window.foreColor[3] = 1.0f;
+	}
+
+	// Hide it icon
+	item = (itemDef_s *) Menu_FindItemByName( menu, chosenItemName );
+	if ( item )
+	{
+		item->window.flags &= ~WINDOW_VISIBLE;
+	}
+
+	// Hide button
+	item = (itemDef_s *) Menu_FindItemByName( menu, chosenButtonName );
+	if ( item )
+	{
+		item->window.flags &= ~WINDOW_VISIBLE;
+	}
+
+	// Get player state
+
+	client_t* cl = &svs.clients[0];	// 0 because only ever us as a player	
+
+	if (!cl)	// No client, get out
+	{
+		return;
+	}
+
+	// Remove weapon
+	if (cl->gentity && cl->gentity->client)
+	{
+		playerState_t*	pState = cl->gentity->client;
+
+		if ((uiInfo.selectedThrowWeapon>0) && (uiInfo.selectedThrowWeapon<WP_NUM_WEAPONS))
+		{
+			pState->stats[ STAT_WEAPONS ]  &= ~( 1 << uiInfo.selectedThrowWeapon );
+		}
+
+		// Remove ammo too
+		if ((uiInfo.selectedThrowWeaponAmmoIndex>0) && (uiInfo.selectedThrowWeaponAmmoIndex<AMMO_MAX))
+		{
+			pState->ammo[ uiInfo.selectedThrowWeaponAmmoIndex ] = 0;
+		}
+
+	}
+
+	// Now do a little clean up
+	uiInfo.selectedThrowWeapon = NOWEAPON;
+	memset(uiInfo.selectedThrowWeaponItemName,0,sizeof(uiInfo.selectedThrowWeaponItemName));
+	uiInfo.selectedThrowWeaponAmmoIndex = 0;
+
+	if (uiInfo.weaponThrowButton)
+	{
+		uiInfo.weaponThrowButton->descText = "@MENUS_CLICKSELECT";
+		uiInfo.weaponThrowButton = NULL;
+	}
+
+	DC->startLocalSound(DC->registerSound("sound/interface/weapon_deselect.mp3", qfalse), CHAN_LOCAL );
+
+	UI_WeaponsSelectionsComplete();	// Test to see if the mission begin button should turn on or off
+
+}
+
+static void	UI_NormalThrowSelection ( void )
+{
+	itemDef_s  *item;
+	menuDef_t	*menu;
+
+	menu = Menu_GetFocused();	// Get current menu
+	if (!menu)
+	{
+		return;
+	}
+
+	item = (itemDef_s *) Menu_FindItemByName( menu, "chosenthrowweapon_icon" );
+	item->window.background = uiInfo.unlitThrowableIcon;
+}
+
+static void	UI_HighLightThrowSelection ( void )
+{
+	itemDef_s  *item;
+	menuDef_t	*menu;
+
+	menu = Menu_GetFocused();	// Get current menu
+	if (!menu)
+	{
+		return;
+	}
+
+	item = (itemDef_s *) Menu_FindItemByName( menu, "chosenthrowweapon_icon" );
+	item->window.background = uiInfo.litThrowableIcon;
+}
+
+static void UI_GetSaberCvars ( void )
+{
+	Cvar_Set ( "ui_saber_type", Cvar_VariableString ( "g_saber_type" ) );
+	Cvar_Set ( "ui_saber", Cvar_VariableString ( "g_saber" ) );
+	Cvar_Set ( "ui_saber2", Cvar_VariableString ( "g_saber2" ) );
+	Cvar_Set ( "ui_saber_color", Cvar_VariableString ( "g_saber_color" ) );
+	Cvar_Set ( "ui_saber2_color", Cvar_VariableString ( "g_saber2_color" ) );
+
+	Cvar_Set ( "ui_newfightingstyle", "0");
+
+}
+
+static void UI_ResetSaberCvars ( void )
+{
+	Cvar_Set ( "g_saber_type", "single" );
+	Cvar_Set ( "g_saber", "single_1" );
+	Cvar_Set ( "g_saber2", "" );
+
+	Cvar_Set ( "ui_saber_type", "single" );
+	Cvar_Set ( "ui_saber", "single_1" );
+	Cvar_Set ( "ui_saber2", "" );
+}
+
+extern qboolean ItemParse_asset_model_go( itemDef_t *item, const char *name );
+extern qboolean ItemParse_model_g2skin_go( itemDef_t *item, const char *skinName );
+static void UI_UpdateCharacterSkin( void )
+{
+	menuDef_t *menu;
+	itemDef_t *item;
+	char skin[MAX_QPATH];
+
+	menu = Menu_GetFocused();	// Get current menu
+
+	if (!menu)
+	{
+		return;
+	}
+
+	item = (itemDef_s *) Menu_FindItemByName(menu, "character");
+
+	if (!item)
+	{
+		Com_Error( ERR_FATAL, "UI_UpdateCharacterSkin: Could not find item (character) in menu (%s)", menu->window.name);
+	}
+
+	Com_sprintf( skin, sizeof( skin ), "models/players/%s/|%s|%s|%s", 
+										Cvar_VariableString ( "ui_char_model"), 
+										Cvar_VariableString ( "ui_char_skin_head"), 
+										Cvar_VariableString ( "ui_char_skin_torso"), 
+										Cvar_VariableString ( "ui_char_skin_legs") 
+				);
+
+	ItemParse_model_g2skin_go( item, skin );
+}
+
+static void UI_UpdateCharacter( qboolean changedModel )
+{
+	menuDef_t *menu;
+	itemDef_t *item;
+	char modelPath[MAX_QPATH];
+
+	menu = Menu_GetFocused();	// Get current menu
+
+	if (!menu)
+	{
+		return;
+	}
+
+	item = (itemDef_s *) Menu_FindItemByName(menu, "character");
+
+	if (!item)
+	{
+		Com_Error( ERR_FATAL, "UI_UpdateCharacter: Could not find item (character) in menu (%s)", menu->window.name);
+	}
+
+	ItemParse_model_g2anim_go( item, ui_char_anim.string );
+
+	Com_sprintf( modelPath, sizeof( modelPath ), "models/players/%s/model.glm", Cvar_VariableString ( "ui_char_model" ) );
+	ItemParse_asset_model_go( item, modelPath );
+
+	if ( changedModel )
+	{//set all skins to first skin since we don't know you always have all skins
+		//FIXME: could try to keep the same spot in each list as you swtich models
+		UI_FeederSelection(FEEDER_PLAYER_SKIN_HEAD, 0, item);	//fixme, this is not really the right item!!
+		UI_FeederSelection(FEEDER_PLAYER_SKIN_TORSO, 0, item);
+		UI_FeederSelection(FEEDER_PLAYER_SKIN_LEGS, 0, item);
+		UI_FeederSelection(FEEDER_COLORCHOICES, 0, item);
+	}
+	UI_UpdateCharacterSkin();
+}
+
+void UI_UpdateSaberType( void )
+{
+	char sType[MAX_QPATH];
+	DC->getCVarString( "ui_saber_type", sType, sizeof(sType) );
+	if ( Q_stricmp( "single", sType ) == 0 ||
+		Q_stricmp( "staff", sType ) == 0 )
+	{
+		DC->setCVar( "ui_saber2", "" );
+	}
+}
+
+static void UI_UpdateSaberHilt( qboolean secondSaber )
+{
+	menuDef_t *menu;
+	itemDef_t *item;
+	char model[MAX_QPATH];
+	char modelPath[MAX_QPATH];
+	char skinPath[MAX_QPATH];
+	menu = Menu_GetFocused();	// Get current menu (either video or ingame video, I would assume)
+
+	if (!menu)
+	{
+		return;
+	}
+
+	char *itemName;
+	char *saberCvarName;
+	if ( secondSaber )
+	{
+		itemName = "saber2";
+		saberCvarName = "ui_saber2";
+	}
+	else
+	{
+		itemName = "saber";
+		saberCvarName = "ui_saber";
+	}
+
+	item = (itemDef_s *) Menu_FindItemByName(menu, itemName );
+
+	if(!item)
+	{
+		Com_Error( ERR_FATAL, "UI_UpdateSaberHilt: Could not find item (%s) in menu (%s)", itemName, menu->window.name);
+	}
+	DC->getCVarString( saberCvarName, model, sizeof(model) );
+	//read this from the sabers.cfg
+	if ( UI_SaberModelForSaber( model, modelPath ) )
+	{//successfully found a model
+		ItemParse_asset_model_go( item, modelPath );//set the model
+		//get the customSkin, if any
+		//COM_StripExtension( modelPath, skinPath );
+		//COM_DefaultExtension( skinPath, sizeof( skinPath ), ".skin" );
+		if ( UI_SaberSkinForSaber( model, skinPath ) )
+		{
+			ItemParse_model_g2skin_go( item, skinPath );//apply the skin
+		}
+		else
+		{
+			ItemParse_model_g2skin_go( item, NULL );//apply the skin
+		}
+	}
+}
+
+/*
+static void UI_UpdateSaberColor( qboolean secondSaber )
+{
+	int sabernumber;
+	if (secondSaber)
+		sabernumber = 2;
+	else
+		sabernumber = 1;
+
+	ui.Cmd_ExecuteText( EXEC_APPEND, va("sabercolor %i %s\n",sabernumber, Cvar_VariableString("g_saber_color")));
+}
+*/
+char GoToMenu[1024];
+
+/*
+=================
+Menus_SaveGoToMenu
+=================
+*/
+void Menus_SaveGoToMenu(const char *menuTo)
+{
+	memcpy(GoToMenu, menuTo, sizeof(GoToMenu));
+}
+
+/*
+=================
+UI_CheckVid1Data
+=================
+*/
+void UI_CheckVid1Data(const char *menuTo,const char *warningMenuName)
+{
+	menuDef_t *menu;
+	itemDef_t *applyChanges;
+
+	menu = Menu_GetFocused();	// Get current menu (either video or ingame video, I would assume)
+
+	if (!menu)
+	{
+		Com_Printf(S_COLOR_YELLOW"WARNING: No videoMenu was found. Video data could not be checked\n");
+		return;
+	}
+
+	applyChanges = (itemDef_s *) Menu_FindItemByName(menu, "applyChanges");
+
+	if (!applyChanges)
+	{
+//		Menus_CloseAll();
+		Menus_OpenByName(menuTo);
+		return;
+	}
+
+	if ((applyChanges->window.flags & WINDOW_VISIBLE))	// Is the APPLY CHANGES button active?
+	{
+//		Menus_SaveGoToMenu(menuTo);							// Save menu you're going to
+//		Menus_HideItems(menu->window.name);					// HIDE videMenu in case you have to come back
+		Menus_OpenByName(warningMenuName);				// Give warning
+	}
+	else
+	{
+//		Menus_CloseAll();
+//		Menus_OpenByName(menuTo);
+	}
+}
+
+/*
+=================
+UI_ResetDefaults
+=================
+*/
+void UI_ResetDefaults( void )
+{
+	ui.Cmd_ExecuteText( EXEC_APPEND, "cvar_restart\n");
+	ui.Cmd_ExecuteText( EXEC_APPEND, "exec default.cfg\n");
+	ui.Cmd_ExecuteText( EXEC_APPEND, "vid_restart\n" );
+}
+
+/*
+=======================
+UI_SortSaveGames
+=======================
+*/
+static int UI_SortSaveGames( const void *A, const void *B ) 
+{
+
+	const int &a = ((savedata_t*)A)->currentSaveFileDateTime;
+	const int &b = ((savedata_t*)B)->currentSaveFileDateTime;
+
+	if (a > b)
+	{
+		return -1;
+	}
+	else
+	{
+		return (a < b);
+	}
+}
+
+/*
+=======================
+UI_AdjustSaveGameListBox
+=======================
+*/
+// Yeah I could get fired for this... in a world of good and bad, this is bad
+// I wish we passed in the menu item to RunScript(), oh well...
+void UI_AdjustSaveGameListBox( int currentLine ) 
+{
+	menuDef_t *menu;
+	itemDef_t *item;
+
+	// could be in either the ingame or shell load menu (I know, I know it's bad)
+	menu = Menus_FindByName("loadgameMenu");
+	if( !menu )
+	{
+		menu = Menus_FindByName("ingameloadMenu");
+	}
+
+	if (menu)
+	{
+		item = (itemDef_s *) Menu_FindItemByName((menuDef_t *) menu, "loadgamelist");
+		if (item)
+		{
+			listBoxDef_t *listPtr = (listBoxDef_t*)item->typeData;
+			if( listPtr )
+			{
+				listPtr->cursorPos = currentLine;
+			}
+			
+			item->cursorPos = currentLine;
+		}
+	}
+	
+}
+
+/*
+=================
+ReadSaveDirectory
+=================
+*/
+//JLFSAVEGAME MPNOTUSED
+#ifdef _XBOX //xbox version
+//for the xbox reading the save directory will consist of 
+//iterating through the save game folders
+
+void ReadSaveDirectory (void)
+{
+	int		i;
+	char	*holdChar;
+	int		len;
+	int		fileCnt;
+
+	// Clear out save data
+	memset(s_savedata,0,sizeof(s_savedata));
+	s_savegame.saveFileCnt = 0;
+	Cvar_Set("ui_gameDesc", "" );	// Blank out comment 
+	Cvar_Set("ui_SelectionOK", "0" );
+	//memset( screenShotBuf,0,(SG_SCR_WIDTH * SG_SCR_HEIGHT * 4)); //blank out sshot
+
+	// Get everything in saves directory
+//	fileCnt = ui.FS_GetFileList("saves", ".sav", s_savegame.listBuf, LISTBUFSIZE );
+
+	Cvar_Set("ui_ResumeOK", "0" );
+	holdChar = s_savegame.listBuf;
+	XGAME_FIND_DATA SaveGameData;
+	HANDLE searchhandle;
+	BOOL retval;
+
+    // Any saves?
+	searchhandle = XFindFirstSaveGame( "U:\\", &SaveGameData );
+	if ( searchhandle != INVALID_HANDLE_VALUE )
+    do
+	{
+		 // At least one; count up the rest
+		DWORD dwCount = 1;
+		//get the name of the file
+		char saveGameName[filepathlength];
+		
+		wcstombs(saveGameName, SaveGameData.szSaveGameName, filepathlength);
+		strcpy( holdChar, saveGameName);
+		
+
+		if	( Q_stricmp("current",saveGameName)!=0 )
+		{
+			time_t result;
+			if (Q_stricmp("auto",saveGameName)==0)
+			{
+				Cvar_Set("ui_ResumeOK", "1" );
+			}
+			else
+			{	// Is this a valid file??? & Get comment of file
+				//create full path name
+				
+				result = ui.SG_GetSaveGameComment(saveGameName, s_savedata[s_savegame.saveFileCnt].currentSaveFileComments, s_savedata[s_savegame.saveFileCnt].currentSaveFileMap);
+				if (result != 0) // ignore Bad save game 
+				{
+					strcpy(s_savedata[s_savegame.saveFileCnt].currentSaveFileComments,s_savedata[s_savegame.saveFileCnt].currentSaveFileMap);
+					s_savedata[s_savegame.saveFileCnt].currentSaveFileName = holdChar;
+					s_savedata[s_savegame.saveFileCnt].currentSaveFileDateTime = result;
+					holdChar += strlen(holdChar)+1;
+					
+					struct tm *localTime;
+					localTime = localtime( &result );
+					strcpy(s_savedata[s_savegame.saveFileCnt].currentSaveFileDateTimeString,asctime( localTime ) );
+					s_savegame.saveFileCnt++;
+					if (s_savegame.saveFileCnt == MAX_SAVELOADFILES)
+					{
+						break;
+					}
+				}
+			}
+		}
+		
+		retval =XFindNextSaveGame( searchhandle, &SaveGameData );
+	}while(retval);
+    
+}
+
+#else //pc version
+
+void ReadSaveDirectory (void)
+{
+	int		i;
+	char	*holdChar;
+	int		len;
+	int		fileCnt;
+	// Clear out save data
+	memset(s_savedata,0,sizeof(s_savedata));
+	s_savegame.saveFileCnt = 0;
+	Cvar_Set("ui_gameDesc", "" );	// Blank out comment 
+	Cvar_Set("ui_SelectionOK", "0" );
+	//memset( screenShotBuf,0,(SG_SCR_WIDTH * SG_SCR_HEIGHT * 4)); //blank out sshot
+
+
+	// Get everything in saves directory
+	fileCnt = ui.FS_GetFileList("saves", ".sav", s_savegame.listBuf, LISTBUFSIZE );
+
+	Cvar_Set("ui_ResumeOK", "0" );
+	holdChar = s_savegame.listBuf;
+	for ( i = 0; i < fileCnt; i++ ) 
+	{
+		// strip extension
+		len = strlen( holdChar );
+		holdChar[len-4] = '\0';
+
+		if	( Q_stricmp("current",holdChar)!=0 )
+		{
+			time_t result;
+			if (Q_stricmp("auto",holdChar)==0)
+			{
+				Cvar_Set("ui_ResumeOK", "1" );
+			}
+			else
+			{	// Is this a valid file??? & Get comment of file
+				result = ui.SG_GetSaveGameComment(holdChar, s_savedata[s_savegame.saveFileCnt].currentSaveFileComments, s_savedata[s_savegame.saveFileCnt].currentSaveFileMap);
+				if (result != 0) // ignore Bad save game 
+				{
+					s_savedata[s_savegame.saveFileCnt].currentSaveFileName = holdChar;
+					s_savedata[s_savegame.saveFileCnt].currentSaveFileDateTime = result;
+					
+					struct tm *localTime;
+					localTime = localtime( &result );
+					strcpy(s_savedata[s_savegame.saveFileCnt].currentSaveFileDateTimeString,asctime( localTime ) );
+					s_savegame.saveFileCnt++;
+					if (s_savegame.saveFileCnt == MAX_SAVELOADFILES)
+					{
+						break;
+					}
+				}
+			}
+		}
+		
+		holdChar += len + 1;	//move to next item
+	}
+
+	qsort( s_savedata, s_savegame.saveFileCnt, sizeof(savedata_t), UI_SortSaveGames );
+
+}
+
+#endif
diff --git a/code/ui/ui_public.h b/code/ui/ui_public.h
new file mode 100644
index 0000000..8486f22
--- /dev/null
+++ b/code/ui/ui_public.h
@@ -0,0 +1,250 @@
+#ifndef __UI_PUBLIC_H__
+#define __UI_PUBLIC_H__
+
+
+#include "../client/keycodes.h"
+
+
+#define UI_API_VERSION	3
+
+
+typedef struct {
+	//============== general Quake services ==================
+
+	// print message on the local console
+	void		(*Printf)( const char *fmt, ... );
+
+	// abort the game
+	void		(*Error)( int level, const char *fmt, ... );
+
+	// console variable interaction
+	void		(*Cvar_Set)( const char *name, const char *value );
+	float		(*Cvar_VariableValue)( const char *var_name );
+	void		(*Cvar_VariableStringBuffer)( const char *var_name, char *buffer, int bufsize );
+	void		(*Cvar_SetValue)( const char *var_name, float value );
+	void		(*Cvar_Reset)( const char *name );
+	void		(*Cvar_Create)( const char *var_name, const char *var_value, int flags );
+	void		(*Cvar_InfoStringBuffer)( int bit, char *buffer, int bufsize );
+
+	// console command interaction
+	int			(*Argc)( void );
+	void		(*Argv)( int n, char *buffer, int bufferLength );
+	void		(*Cmd_ExecuteText)( int exec_when, const char *text );
+	void		(*Cmd_TokenizeString)( const char *text );
+
+	// filesystem access
+	int			(*FS_FOpenFile)( const char *qpath, fileHandle_t *file, fsMode_t mode );
+	int 		(*FS_Read)( void *buffer, int len, fileHandle_t f );
+	int 		(*FS_Write)( const void *buffer, int len, fileHandle_t f );
+	void		(*FS_FCloseFile)( fileHandle_t f );
+	int			(*FS_GetFileList)(  const char *path, const char *extension, char *listbuf, int bufsize );
+	int			(*FS_ReadFile)( const char *name, void **buf );
+	void		(*FS_FreeFile)( void *buf );
+
+	// =========== renderer function calls ================
+
+	qhandle_t	(*R_RegisterModel)( const char *name );			// returns rgb axis if not found
+	qhandle_t	(*R_RegisterSkin)( const char *name );			// returns all white if not found
+	qhandle_t	(*R_RegisterShader)( const char *name );			// returns white if not found
+	qhandle_t	(*R_RegisterShaderNoMip)( const char *name );			// returns white if not found
+	qhandle_t	(*R_RegisterFont)( const char *name );			// returns 0 for bad font
+#ifdef _XBOX	// No default arguments on function pointers
+	int			R_Font_StrLenPixels(const char *text, const int setIndex, const float scale = 1.0f)
+	{
+		return RE_Font_StrLenPixels(text, setIndex, scale);
+	}
+	int			R_Font_HeightPixels(const int setIndex, const float scale = 1.0f)
+	{
+		return RE_Font_HeightPixels(setIndex, scale);
+	}
+	void		R_Font_DrawString(int ox, int oy, const char *text, const float *rgba, const int setIndex, int iMaxPixelWidth, const float scale = 1.0f)
+	{
+		RE_Font_DrawString(ox, oy, text, rgba, setIndex, iMaxPixelWidth, scale);
+	}
+#else
+	int			(*R_Font_StrLenPixels)(const char *text, const int setIndex, const float scale = 1.0f);
+	int			(*R_Font_HeightPixels)(const int setIndex, const float scale = 1.0f);
+	void		(*R_Font_DrawString)(int ox, int oy, const char *text, const float *rgba, const int setIndex, int iMaxPixelWidth, const float scale = 1.0f);
+#endif
+	int			(*R_Font_StrLenChars)(const char *text);
+	qboolean	(*Language_IsAsian) (void);
+	qboolean	(*Language_UsesSpaces) (void);
+	unsigned int (*AnyLanguage_ReadCharFromString)( const char *psText, int *piAdvanceCount, qboolean *pbIsTrailingPunctuation /* = NULL */);
+
+	// a scene is built up by calls to R_ClearScene and the various R_Add functions.
+	// Nothing is drawn until R_RenderScene is called.
+	void		(*R_ClearScene)( void );
+	void		(*R_AddRefEntityToScene)( const refEntity_t *re );
+	void		(*R_AddPolyToScene)( qhandle_t hShader , int numVerts, const polyVert_t *verts );
+	void		(*R_AddLightToScene)( const vec3_t org, float intensity, float r, float g, float b );
+	void		(*R_RenderScene)( const refdef_t *fd );
+
+	void		(*R_ModelBounds)( qhandle_t handle, vec3_t mins, vec3_t maxs );
+
+	void		(*R_SetColor)( const float *rgba );	// NULL = 1,1,1,1
+	void		(*R_DrawStretchPic) ( float x, float y, float w, float h, float s1, float t1, float s2, float t2, qhandle_t hShader );	// 0 = white
+	void		(*R_ScissorPic) ( float x, float y, float w, float h, float s1, float t1, float s2, float t2, qhandle_t hShader );	// 0 = white
+
+	// force a screen update, only used during gamestate load
+	void		(*UpdateScreen)( void );
+
+	// stuff for savegame screenshots...
+#ifdef _XBOX
+	void		(*PrecacheScreenshot)( void );
+#endif
+
+	//========= model collision ===============
+
+	// R_LerpTag is only valid for md3 models
+	void		(*R_LerpTag)( orientation_t *tag, clipHandle_t mod, int startFrame, int endFrame, 
+						 float frac, const char *tagName );
+
+	// =========== sound function calls ===============
+
+	void		(*S_StartLocalSound)( sfxHandle_t sfxHandle, int channelNum );
+	sfxHandle_t	(*S_RegisterSound)( const char* name);
+	void		(*S_StartLocalLoopingSound)( sfxHandle_t sfxHandle);
+	void		(*S_StopSounds)( void );
+
+
+	// =========== getting save game picture ===============
+	void	(*DrawStretchRaw) (int x, int y, int w, int h, int cols, int rows, const byte *data, int client, qboolean dirty);
+	//qboolean(*SG_GetSaveImage)( const char *psPathlessBaseName, void *pvAddress );
+	int		(*SG_GetSaveGameComment)(const char *psPathlessBaseName, char *sComment, char *sMapName);
+	qboolean (*SG_GameAllowedToSaveHere)(qboolean inCamera);
+	void (*SG_StoreSaveGameComment)(const char *sComment);
+	//byte *(*SCR_GetScreenshot)(qboolean *);
+
+	// =========== data shared with the client system =============
+
+	// keyboard and key binding interaction
+	void		(*Key_KeynumToStringBuf)( int keynum, char *buf, int buflen );
+	void		(*Key_GetBindingBuf)( int keynum, char *buf, int buflen );
+	void		(*Key_SetBinding)( int keynum, const char *binding );
+	qboolean	(*Key_IsDown)( int keynum );
+	qboolean	(*Key_GetOverstrikeMode)( void );
+	void		(*Key_SetOverstrikeMode)( qboolean state );
+	void		(*Key_ClearStates)( void );
+	int			(*Key_GetCatcher)( void );
+	void		(*Key_SetCatcher)( int catcher );
+
+	void		(*GetClipboardData)( char *buf, int bufsize );
+
+	void		(*GetGlconfig)( glconfig_t *config );
+
+	connstate_t	(*GetClientState)( void );
+
+	void		(*GetConfigString)( int index, char* buff, int buffsize );
+
+	int			(*Milliseconds)( void );
+	void		(*Draw_DataPad)(int HUDType);
+} uiimport_t;
+
+typedef enum {
+	DP_HUD=0,
+	DP_OBJECTIVES,
+	DP_WEAPONS,
+	DP_INVENTORY,
+	DP_FORCEPOWERS
+}dpTypes_t;
+
+typedef enum {
+	UI_ERROR,
+	UI_PRINT,
+	UI_MILLISECONDS,
+	UI_CVAR_SET,
+	UI_CVAR_VARIABLEVALUE,
+	UI_CVAR_VARIABLESTRINGBUFFER,
+	UI_CVAR_SETVALUE,
+	UI_CVAR_RESET,
+	UI_CVAR_CREATE,
+	UI_CVAR_INFOSTRINGBUFFER,
+	UI_ARGC,						//	10
+	UI_ARGV,
+	UI_CMD_EXECUTETEXT,
+	UI_FS_FOPENFILE,
+	UI_FS_READ,
+	UI_FS_WRITE,
+	UI_FS_FCLOSEFILE,
+	UI_FS_GETFILELIST,
+	UI_R_REGISTERMODEL,
+	UI_R_REGISTERSKIN,
+	UI_R_REGISTERSHADERNOMIP,		//	20
+	UI_R_CLEARSCENE,
+	UI_R_ADDREFENTITYTOSCENE,
+	UI_R_ADDPOLYTOSCENE,
+	UI_R_ADDLIGHTTOSCENE,
+	UI_R_RENDERSCENE,
+	UI_R_SETCOLOR,
+	UI_R_DRAWSTRETCHPIC,
+	UI_UPDATESCREEN,
+	UI_CM_LERPTAG,
+	UI_CM_LOADMODEL,				//	30
+	UI_S_REGISTERSOUND,
+	UI_S_STARTLOCALSOUND,
+	UI_KEY_KEYNUMTOSTRINGBUF,
+	UI_KEY_GETBINDINGBUF,
+	UI_KEY_SETBINDING,
+	UI_KEY_ISDOWN,
+	UI_KEY_GETOVERSTRIKEMODE,
+	UI_KEY_SETOVERSTRIKEMODE,
+	UI_KEY_CLEARSTATES,
+	UI_KEY_GETCATCHER,				//	40
+	UI_KEY_SETCATCHER,
+	UI_GETCLIPBOARDDATA,
+	UI_GETGLCONFIG,
+	UI_GETCLIENTSTATE,
+	UI_GETCONFIGSTRING,
+	UI_LAN_GETPINGQUEUECOUNT,
+	UI_LAN_CLEARPING,
+	UI_LAN_GETPING,
+	UI_LAN_GETPINGINFO,
+	UI_CVAR_REGISTER,				//	50
+	UI_CVAR_UPDATE,
+	UI_MEMORY_REMAINING,
+	UI_GET_CDKEY,
+	UI_SET_CDKEY,
+	UI_R_REGISTERFONT,
+	UI_R_MODELBOUNDS,
+	UI_PC_ADD_GLOBAL_DEFINE,
+	UI_PC_LOAD_SOURCE,
+	UI_PC_FREE_SOURCE,
+	UI_PC_READ_TOKEN,				//	60
+	UI_PC_SOURCE_FILE_AND_LINE,
+	UI_S_STOPBACKGROUNDTRACK,
+	UI_S_STARTBACKGROUNDTRACK,
+	UI_REAL_TIME,
+	UI_LAN_GETSERVERCOUNT,
+	UI_LAN_GETSERVERADDRESSSTRING,
+	UI_LAN_GETSERVERINFO,
+	UI_LAN_MARKSERVERVISIBLE,
+	UI_LAN_UPDATEVISIBLEPINGS,
+	UI_LAN_RESETPINGS,				//	70
+	UI_LAN_LOADCACHEDSERVERS,
+	UI_LAN_SAVECACHEDSERVERS,
+	UI_LAN_ADDSERVER,
+	UI_LAN_REMOVESERVER,
+	UI_CIN_PLAYCINEMATIC,
+	UI_CIN_STOPCINEMATIC,
+	UI_CIN_RUNCINEMATIC,
+	UI_CIN_DRAWCINEMATIC,
+	UI_CIN_SETEXTENTS,
+	UI_R_REMAP_SHADER,				//	80
+	UI_VERIFY_CDKEY,
+	UI_LAN_SERVERSTATUS,
+	UI_LAN_GETSERVERPING,
+	UI_LAN_SERVERISVISIBLE,
+	UI_LAN_COMPARESERVERS,
+
+	UI_MEMSET = 100,
+	UI_MEMCPY,
+	UI_STRNCPY,
+	UI_SIN,
+	UI_COS,
+	UI_ATAN2,
+	UI_SQRT,
+	UI_FLOOR,
+	UI_CEIL
+} uiImport_t;
+
+#endif
diff --git a/code/ui/ui_saber.cpp b/code/ui/ui_saber.cpp
new file mode 100644
index 0000000..a2f5768
--- /dev/null
+++ b/code/ui/ui_saber.cpp
@@ -0,0 +1,861 @@
+//
+/*
+=======================================================================
+
+USER INTERFACE SABER LOADING & DISPLAY CODE
+
+=======================================================================
+*/
+
+// leave this at the top of all UI_xxxx files for PCH reasons...
+//
+#include "../server/exe_headers.h"
+#include "ui_local.h"
+#include "ui_shared.h"
+#include "../ghoul2/G2.h"
+
+#define MAX_SABER_DATA_SIZE 0x8000
+// On Xbox, static linking lets us steal the buffer from wp_saberLoad
+// Just make sure that the saber data size is the same
+#ifdef _XBOX
+extern char SaberParms[MAX_SABER_DATA_SIZE];
+#else
+char	SaberParms[MAX_SABER_DATA_SIZE];
+#endif
+qboolean	ui_saber_parms_parsed = qfalse;
+
+static qhandle_t redSaberGlowShader;
+static qhandle_t redSaberCoreShader;
+static qhandle_t orangeSaberGlowShader;
+static qhandle_t orangeSaberCoreShader;
+static qhandle_t yellowSaberGlowShader;
+static qhandle_t yellowSaberCoreShader;
+static qhandle_t greenSaberGlowShader;
+static qhandle_t greenSaberCoreShader;
+static qhandle_t blueSaberGlowShader;
+static qhandle_t blueSaberCoreShader;
+static qhandle_t purpleSaberGlowShader;
+static qhandle_t purpleSaberCoreShader;
+void UI_CacheSaberGlowGraphics( void )
+{//FIXME: these get fucked by vid_restarts
+	redSaberGlowShader		= re.RegisterShader( "gfx/effects/sabers/red_glow" );
+	redSaberCoreShader		= re.RegisterShader( "gfx/effects/sabers/red_line" );
+	orangeSaberGlowShader		= re.RegisterShader( "gfx/effects/sabers/orange_glow" );
+	orangeSaberCoreShader		= re.RegisterShader( "gfx/effects/sabers/orange_line" );
+	yellowSaberGlowShader		= re.RegisterShader( "gfx/effects/sabers/yellow_glow" );
+	yellowSaberCoreShader		= re.RegisterShader( "gfx/effects/sabers/yellow_line" );
+	greenSaberGlowShader		= re.RegisterShader( "gfx/effects/sabers/green_glow" );
+	greenSaberCoreShader		= re.RegisterShader( "gfx/effects/sabers/green_line" );
+	blueSaberGlowShader		= re.RegisterShader( "gfx/effects/sabers/blue_glow" );
+	blueSaberCoreShader		= re.RegisterShader( "gfx/effects/sabers/blue_line" );
+	purpleSaberGlowShader		= re.RegisterShader( "gfx/effects/sabers/purple_glow" );
+	purpleSaberCoreShader		= re.RegisterShader( "gfx/effects/sabers/purple_line" );
+}
+
+qboolean UI_ParseLiteral( const char **data, const char *string ) 
+{
+	const char	*token;
+
+	token = COM_ParseExt( data, qtrue );
+	if ( token[0] == 0 ) 
+	{
+		ui.Printf( "unexpected EOF\n" );
+		return qtrue;
+	}
+
+	if ( Q_stricmp( token, string ) ) 
+	{
+		ui.Printf( "required string '%s' missing\n", string );
+		return qtrue;
+	}
+
+	return qfalse;
+}
+
+qboolean UI_SaberParseParm( const char *saberName, const char *parmname, char *saberData ) 
+{
+	const char	*token;
+	const char	*value;
+	const char	*p;
+
+	if ( !saberName || !saberName[0] ) 
+	{
+		return qfalse;
+	}
+
+	//try to parse it out
+	p = SaberParms;
+	COM_BeginParseSession();
+
+	// look for the right saber
+	while ( p )
+	{
+		token = COM_ParseExt( &p, qtrue );
+		if ( token[0] == 0 )
+		{
+			return qfalse;
+		}
+
+		if ( !Q_stricmp( token, saberName ) ) 
+		{
+			break;
+		}
+
+		SkipBracedSection( &p );
+	}
+	if ( !p ) 
+	{
+		return qfalse;
+	}
+
+	if ( UI_ParseLiteral( &p, "{" ) ) 
+	{
+		return qfalse;
+	}
+		
+	// parse the saber info block
+	while ( 1 ) 
+	{
+		token = COM_ParseExt( &p, qtrue );
+		if ( !token[0] ) 
+		{
+			ui.Printf( S_COLOR_RED"ERROR: unexpected EOF while parsing '%s'\n", saberName );
+			return qfalse;
+		}
+
+		if ( !Q_stricmp( token, "}" ) ) 
+		{
+			break;
+		}
+
+		if ( !Q_stricmp( token, parmname ) ) 
+		{
+			if ( COM_ParseString( &p, &value ) ) 
+			{
+				continue;
+			}
+			strcpy( saberData, value );
+			return qtrue;
+		}
+
+		SkipRestOfLine( &p );
+		continue;
+	}
+
+	return qfalse;
+}
+
+qboolean UI_SaberProperNameForSaber( const char *saberName, char *saberProperName )
+{
+	return UI_SaberParseParm( saberName, "name", saberProperName );
+}
+
+qboolean UI_SaberModelForSaber( const char *saberName, char *saberModel )
+{
+	return UI_SaberParseParm( saberName, "saberModel", saberModel );
+}
+
+qboolean UI_SaberSkinForSaber( const char *saberName, char *saberSkin )
+{
+	return UI_SaberParseParm( saberName, "customSkin", saberSkin );
+}
+
+qboolean UI_SaberTypeForSaber( const char *saberName, char *saberType )
+{
+	return UI_SaberParseParm( saberName, "saberType", saberType );
+}
+
+int UI_SaberNumBladesForSaber( const char *saberName )
+{
+	char	numBladesString[8]={0};
+	UI_SaberParseParm( saberName, "numBlades", numBladesString );
+	int numBlades = atoi( numBladesString );
+	if ( numBlades < 1 )
+	{
+		numBlades = 1;
+	}
+	else if ( numBlades > 8 )
+	{
+		numBlades = 8;
+	}
+	return numBlades;
+}
+
+float UI_SaberBladeLengthForSaber( const char *saberName, int bladeNum )
+{
+	char	lengthString[8]={0};
+	float	length = 40.0f;
+	UI_SaberParseParm( saberName, "saberLength", lengthString );
+	if ( lengthString[0] )
+	{
+		length = atof( lengthString );
+		if ( length < 0.0f )
+		{
+			length = 0.0f;
+		}
+	}
+
+	UI_SaberParseParm( saberName, va("saberLength%d", bladeNum+1), lengthString );
+	if ( lengthString[0] )
+	{
+		length = atof( lengthString );
+		if ( length < 0.0f )
+		{
+			length = 0.0f;
+		}
+	}
+
+	return length;
+}
+
+float UI_SaberBladeRadiusForSaber( const char *saberName, int bladeNum )
+{
+	char	radiusString[8]={0};
+	float	radius = 3.0f;
+	UI_SaberParseParm( saberName, "saberRadius", radiusString );
+	if ( radiusString[0] )
+	{
+		radius = atof( radiusString );
+		if ( radius < 0.0f )
+		{
+			radius = 0.0f;
+		}
+	}
+
+	UI_SaberParseParm( saberName, va("saberRadius%d", bladeNum+1), radiusString );
+	if ( radiusString[0] )
+	{
+		radius = atof( radiusString );
+		if ( radius < 0.0f )
+		{
+			radius = 0.0f;
+		}
+	}
+
+	return radius;
+}
+
+void UI_SaberLoadParms( void ) 
+{
+	int			len, totallen, saberExtFNLen, fileCnt, i;
+	char		*buffer, *holdChar, *marker;
+	char		saberExtensionListBuf[2048];			//	The list of file names read in
+
+	//ui.Printf( "UI Parsing *.sab saber definitions\n" );
+	
+	ui_saber_parms_parsed = qtrue;
+	UI_CacheSaberGlowGraphics();
+
+	//set where to store the first one
+	totallen = 0;
+	marker = SaberParms;
+	marker[0] = '\0';
+
+	//now load in the sabers
+	fileCnt = ui.FS_GetFileList("ext_data/sabers", ".sab", saberExtensionListBuf, sizeof(saberExtensionListBuf) );
+
+	holdChar = saberExtensionListBuf;
+	for ( i = 0; i < fileCnt; i++, holdChar += saberExtFNLen + 1 ) 
+	{
+		saberExtFNLen = strlen( holdChar );
+
+		len = ui.FS_ReadFile( va( "ext_data/sabers/%s", holdChar), (void **) &buffer );
+
+		if ( len == -1 ) 
+		{
+			ui.Printf( "UI_SaberLoadParms: error reading %s\n", holdChar );
+		}
+		else
+		{
+			if ( totallen && *(marker-1) == '}' )
+			{//don't let it end on a } because that should be a stand-alone token
+				strcat( marker, " " );
+				totallen++;
+				marker++; 
+			}
+			len = COM_Compress( buffer );
+
+			if ( totallen + len >= MAX_SABER_DATA_SIZE ) {
+				Com_Error( ERR_FATAL, "UI_SaberLoadParms: ran out of space before reading %s\n(you must make the .npc files smaller)", holdChar );
+			}
+			strcat( marker, buffer );
+			ui.FS_FreeFile( buffer );
+
+			totallen += len;
+			marker += len;
+		}
+	}
+}
+
+void UI_DoSaber( vec3_t origin, vec3_t dir, float length, float lengthMax, float radius, saber_colors_t color )
+{
+	vec3_t		mid, rgb={1,1,1};
+	qhandle_t	blade = 0, glow = 0;
+	refEntity_t saber;
+	float radiusmult;
+
+	if ( length < 0.5f )
+	{
+		// if the thing is so short, just forget even adding me.
+		return;
+	}
+
+	// Find the midpoint of the saber for lighting purposes
+	VectorMA( origin, length * 0.5f, dir, mid );
+
+	switch( color )
+	{
+		case SABER_RED:
+			glow = redSaberGlowShader;
+			blade = redSaberCoreShader;
+			VectorSet( rgb, 1.0f, 0.2f, 0.2f );
+			break;
+		case SABER_ORANGE:
+			glow = orangeSaberGlowShader;
+			blade = orangeSaberCoreShader;
+			VectorSet( rgb, 1.0f, 0.5f, 0.1f );
+			break;
+		case SABER_YELLOW:
+			glow = yellowSaberGlowShader;
+			blade = yellowSaberCoreShader;
+			VectorSet( rgb, 1.0f, 1.0f, 0.2f );
+			break;
+		case SABER_GREEN:
+			glow = greenSaberGlowShader;
+			blade = greenSaberCoreShader;
+			VectorSet( rgb, 0.2f, 1.0f, 0.2f );
+			break;
+		case SABER_BLUE:
+			glow = blueSaberGlowShader;
+			blade = blueSaberCoreShader;
+			VectorSet( rgb, 0.2f, 0.4f, 1.0f );
+			break;
+		case SABER_PURPLE:
+			glow = purpleSaberGlowShader;
+			blade = purpleSaberCoreShader;
+			VectorSet( rgb, 0.9f, 0.2f, 1.0f );
+			break;
+	}
+
+	// always add a light because sabers cast a nice glow before they slice you in half!!  or something...
+	/*
+	if ( doLight )
+	{//FIXME: RGB combine all the colors of the sabers you're using into one averaged color!
+		cgi_R_AddLightToScene( mid, (length*2.0f) + (random()*8.0f), rgb[0], rgb[1], rgb[2] );
+	}
+	*/
+
+	memset( &saber, 0, sizeof( refEntity_t ));
+
+	// Saber glow is it's own ref type because it uses a ton of sprites, otherwise it would eat up too many
+	//	refEnts to do each glow blob individually
+	saber.saberLength = length;
+
+	// Jeff, I did this because I foolishly wished to have a bright halo as the saber is unleashed.  
+	// It's not quite what I'd hoped tho.  If you have any ideas, go for it!  --Pat
+	if (length < lengthMax )
+	{
+		radiusmult = 1.0 + (2.0 / length);		// Note this creates a curve, and length cannot be < 0.5.
+	}
+	else
+	{
+		radiusmult = 1.0;
+	}
+
+	float radiusRange = radius * 0.075f;
+	float radiusStart = radius-radiusRange;
+
+	saber.radius = (radiusStart + crandom() * radiusRange)*radiusmult;
+	//saber.radius = (2.8f + crandom() * 0.2f)*radiusmult;
+
+
+	VectorCopy( origin, saber.origin );
+	VectorCopy( dir, saber.axis[0] );
+	saber.reType = RT_SABER_GLOW;
+	saber.customShader = glow;
+	saber.shaderRGBA[0] = saber.shaderRGBA[1] = saber.shaderRGBA[2] = saber.shaderRGBA[3] = 0xff;
+	//saber.renderfx = rfx;
+
+	DC->addRefEntityToScene( &saber );
+
+	// Do the hot core
+	VectorMA( origin, length, dir, saber.origin );
+	VectorMA( origin, -1, dir, saber.oldorigin );
+	saber.customShader = blade;
+	saber.reType = RT_LINE;
+	radiusStart = radius/3.0f;
+	saber.radius = (radiusStart + crandom() * radiusRange)*radiusmult;
+//	saber.radius = (1.0 + crandom() * 0.2f)*radiusmult;
+
+	DC->addRefEntityToScene( &saber );
+}
+
+saber_colors_t TranslateSaberColor( const char *name ) 
+{
+	if ( !Q_stricmp( name, "red" ) ) 
+	{
+		return SABER_RED;
+	}
+	if ( !Q_stricmp( name, "orange" ) ) 
+	{
+		return SABER_ORANGE;
+	}
+	if ( !Q_stricmp( name, "yellow" ) ) 
+	{
+		return SABER_YELLOW;
+	}
+	if ( !Q_stricmp( name, "green" ) ) 
+	{
+		return SABER_GREEN;
+	}
+	if ( !Q_stricmp( name, "blue" ) ) 
+	{
+		return SABER_BLUE;
+	}
+	if ( !Q_stricmp( name, "purple" ) ) 
+	{
+		return SABER_PURPLE;
+	}
+	if ( !Q_stricmp( name, "random" ) ) 
+	{
+		return ((saber_colors_t)(Q_irand( SABER_ORANGE, SABER_PURPLE )));
+	}
+	return SABER_BLUE;
+}
+
+saberType_t TranslateSaberType( const char *name ) 
+{
+	if ( !Q_stricmp( name, "SABER_SINGLE" ) ) 
+	{
+		return SABER_SINGLE;
+	}
+	if ( !Q_stricmp( name, "SABER_STAFF" ) ) 
+	{
+		return SABER_STAFF;
+	}
+	if ( !Q_stricmp( name, "SABER_BROAD" ) ) 
+	{
+		return SABER_BROAD;
+	}
+	if ( !Q_stricmp( name, "SABER_PRONG" ) ) 
+	{
+		return SABER_PRONG;
+	}
+	if ( !Q_stricmp( name, "SABER_DAGGER" ) ) 
+	{
+		return SABER_DAGGER;
+	}
+	if ( !Q_stricmp( name, "SABER_ARC" ) ) 
+	{
+		return SABER_ARC;
+	}
+	if ( !Q_stricmp( name, "SABER_SAI" ) ) 
+	{
+		return SABER_SAI;
+	}
+	if ( !Q_stricmp( name, "SABER_CLAW" ) ) 
+	{
+		return SABER_CLAW;
+	}
+	if ( !Q_stricmp( name, "SABER_LANCE" ) ) 
+	{
+		return SABER_LANCE;
+	}
+	if ( !Q_stricmp( name, "SABER_STAR" ) ) 
+	{
+		return SABER_STAR;
+	}
+	if ( !Q_stricmp( name, "SABER_TRIDENT" ) ) 
+	{
+		return SABER_TRIDENT;
+	}
+	if ( !Q_stricmp( name, "SABER_SITH_SWORD" ) ) 
+	{
+		return SABER_SITH_SWORD;
+	}
+	return SABER_SINGLE;
+}
+
+void UI_SaberDrawBlade( itemDef_t *item, char *saberName, int saberModel, saberType_t saberType, vec3_t origin, float curYaw, int bladeNum )
+{
+	char bladeColorString[MAX_QPATH];
+	vec3_t	angles={0};
+
+	if ( item->flags&(ITF_ISANYSABER) && item->flags&(ITF_ISCHARACTER) )
+	{	//it's bolted to a dude!
+		angles[YAW] = curYaw;
+	}
+	else
+	{
+		angles[PITCH] = curYaw;
+		angles[ROLL] = 90;
+	}
+
+	if ( saberModel >= item->ghoul2.size() )
+	{//uhh... invalid index!
+		return;
+	}
+
+	if ( (item->flags&ITF_ISSABER) && saberModel < 2 )
+	{
+		DC->getCVarString( "ui_saber_color", bladeColorString, sizeof(bladeColorString) );
+	}
+	else//if ( item->flags&ITF_ISSABER2 ) - presumed
+	{
+		DC->getCVarString( "ui_saber2_color", bladeColorString, sizeof(bladeColorString) );
+	}
+	saber_colors_t bladeColor = TranslateSaberColor( bladeColorString );
+
+	float bladeLength = UI_SaberBladeLengthForSaber( saberName, bladeNum );
+	float bladeRadius = UI_SaberBladeRadiusForSaber( saberName, bladeNum );
+	vec3_t	bladeOrigin={0};
+	vec3_t	axis[3]={0};
+	mdxaBone_t	boltMatrix;
+	qboolean tagHack = qfalse;
+
+	char *tagName = va( "*blade%d", bladeNum+1 );
+	int bolt = DC->g2_AddBolt( &item->ghoul2[saberModel], tagName );
+
+	if ( bolt == -1 )
+	{
+		tagHack = qtrue;
+		//hmm, just fall back to the most basic tag (this will also make it work with pre-JKA saber models
+		bolt = DC->g2_AddBolt( &item->ghoul2[saberModel], "*flash" );
+		if ( bolt == -1 )
+		{//no tag_flash either?!!
+			bolt = 0;
+		}
+	}
+	
+	DC->g2_GetBoltMatrix( item->ghoul2, saberModel, bolt, &boltMatrix, angles, origin, uiInfo.uiDC.realTime, NULL, vec3_origin );//NULL was cgs.model_draw
+
+	// work the matrix axis stuff into the original axis and origins used.
+	DC->g2_GiveMeVectorFromMatrix(boltMatrix, ORIGIN, bladeOrigin);
+	DC->g2_GiveMeVectorFromMatrix(boltMatrix, NEGATIVE_X, axis[0]);//front (was NEGATIVE_Y, but the md3->glm exporter screws up this tag somethin' awful)
+	DC->g2_GiveMeVectorFromMatrix(boltMatrix, NEGATIVE_Y, axis[1]);//right
+	DC->g2_GiveMeVectorFromMatrix(boltMatrix, POSITIVE_Z, axis[2]);//up
+	
+	float scale = DC->xscale;
+
+	if ( tagHack )
+	{
+		switch ( saberType )
+		{
+		case SABER_SINGLE:
+		case SABER_DAGGER:
+		case SABER_LANCE:
+			break;
+		case SABER_STAFF:
+			if ( bladeNum == 1 )
+			{
+				VectorScale( axis[0], -1, axis[0] );
+				VectorMA( bladeOrigin, 16*scale, axis[0], bladeOrigin );
+			}
+			break;
+		case SABER_BROAD:
+			if ( bladeNum == 0 )
+			{
+				VectorMA( bladeOrigin, -1*scale, axis[1], bladeOrigin );
+			}
+			else if ( bladeNum == 1 )
+			{
+				VectorMA( bladeOrigin, 1*scale, axis[1], bladeOrigin );
+			}
+			break;
+		case SABER_PRONG:
+			if ( bladeNum == 0 )
+			{
+				VectorMA( bladeOrigin, -3*scale, axis[1], bladeOrigin );
+			}
+			else if ( bladeNum == 1 )
+			{
+				VectorMA( bladeOrigin, 3*scale, axis[1], bladeOrigin );
+			}
+			break;
+		case SABER_ARC:
+			VectorSubtract( axis[1], axis[2], axis[1] );
+			VectorNormalize( axis[1] );
+			switch ( bladeNum )
+			{
+			case 0:
+				VectorMA( bladeOrigin, 8*scale, axis[0], bladeOrigin );
+				VectorScale( axis[0], 0.75f, axis[0] );
+				VectorScale( axis[1], 0.25f, axis[1] );
+				VectorAdd( axis[0], axis[1], axis[0] );
+				break;
+			case 1:
+				VectorScale( axis[0], 0.25f, axis[0] );
+				VectorScale( axis[1], 0.75f, axis[1] );
+				VectorAdd( axis[0], axis[1], axis[0] );
+				break;
+			case 2:
+				VectorMA( bladeOrigin, -8*scale, axis[0], bladeOrigin );
+				VectorScale( axis[0], -0.25f, axis[0] );
+				VectorScale( axis[1], 0.75f, axis[1] );
+				VectorAdd( axis[0], axis[1], axis[0] );
+				break;
+			case 3:
+				VectorMA( bladeOrigin, -16*scale, axis[0], bladeOrigin );
+				VectorScale( axis[0], -0.75f, axis[0] );
+				VectorScale( axis[1], 0.25f, axis[1] );
+				VectorAdd( axis[0], axis[1], axis[0] );
+				break;
+			}
+			break;
+		case SABER_SAI:
+			if ( bladeNum == 1 )
+			{
+				VectorMA( bladeOrigin, -3*scale, axis[1], bladeOrigin );
+			}
+			else if ( bladeNum == 2 )
+			{
+				VectorMA( bladeOrigin, 3*scale, axis[1], bladeOrigin );
+			}
+			break;
+		case SABER_CLAW:
+			switch ( bladeNum )
+			{
+			case 0:
+				VectorMA( bladeOrigin, 2*scale, axis[0], bladeOrigin );
+				VectorMA( bladeOrigin, 2*scale, axis[2], bladeOrigin );
+				break;
+			case 1:
+				VectorMA( bladeOrigin, 2*scale, axis[0], bladeOrigin );
+				VectorMA( bladeOrigin, 2*scale, axis[2], bladeOrigin );
+				VectorMA( bladeOrigin, 2*scale, axis[1], bladeOrigin );
+				break;
+			case 2:
+				VectorMA( bladeOrigin, 2*scale, axis[0], bladeOrigin );
+				VectorMA( bladeOrigin, 2*scale, axis[2], bladeOrigin );
+				VectorMA( bladeOrigin, -2*scale, axis[1], bladeOrigin );
+				break;
+			}
+			break;
+		case SABER_STAR:
+			switch ( bladeNum )
+			{
+			case 0:
+				VectorMA( bladeOrigin, 8*scale, axis[0], bladeOrigin );
+				break;
+			case 1:
+				VectorScale( axis[0], 0.33f, axis[0] );
+				VectorScale( axis[2], 0.67f, axis[2] );
+				VectorAdd( axis[0], axis[2], axis[0] );
+				VectorMA( bladeOrigin, 8*scale, axis[0], bladeOrigin );
+				break;
+			case 2:
+				VectorScale( axis[0], -0.33f, axis[0] );
+				VectorScale( axis[2], 0.67f, axis[2] );
+				VectorAdd( axis[0], axis[2], axis[0] );
+				VectorMA( bladeOrigin, 8*scale, axis[0], bladeOrigin );
+				break;
+			case 3:
+				VectorScale( axis[0], -1, axis[0] );
+				VectorMA( bladeOrigin, 8*scale, axis[0], bladeOrigin );
+				break;
+			case 4:
+				VectorScale( axis[0], -0.33f, axis[0] );
+				VectorScale( axis[2], -0.67f, axis[2] );
+				VectorAdd( axis[0], axis[2], axis[0] );
+				VectorMA( bladeOrigin, 8*scale, axis[0], bladeOrigin );
+				break;
+			case 5:
+				VectorScale( axis[0], 0.33f, axis[0] );
+				VectorScale( axis[2], -0.67f, axis[2] );
+				VectorAdd( axis[0], axis[2], axis[0] );
+				VectorMA( bladeOrigin, 8*scale, axis[0], bladeOrigin );
+				break;
+			}
+			break;
+		case SABER_TRIDENT:
+			switch ( bladeNum )
+			{
+			case 0:
+				VectorMA( bladeOrigin, 24*scale, axis[0], bladeOrigin );
+				break;
+			case 1:
+				VectorMA( bladeOrigin, -6*scale, axis[1], bladeOrigin );
+				VectorMA( bladeOrigin, 24*scale, axis[0], bladeOrigin );
+				break;
+			case 2:
+				VectorMA( bladeOrigin, 6*scale, axis[1], bladeOrigin );
+				VectorMA( bladeOrigin, 24*scale, axis[0], bladeOrigin );
+				break;
+			case 3:
+				VectorMA( bladeOrigin, -32*scale, axis[0], bladeOrigin );
+				VectorScale( axis[0], -1, axis[0] );
+				break;
+			}
+			break;
+		case SABER_SITH_SWORD:
+			//no blade
+			break;
+		}
+	}
+	if ( saberType == SABER_SITH_SWORD )
+	{//draw no blade
+		return;
+	}
+
+	UI_DoSaber( bladeOrigin, axis[0], bladeLength, bladeLength, bladeRadius, bladeColor );
+}
+
+extern qboolean ItemParse_asset_model_go( itemDef_t *item, const char *name );
+extern qboolean ItemParse_model_g2skin_go( itemDef_t *item, const char *skinName );
+void UI_GetSaberForMenu( char *saber, int saberNum )
+{
+	char saberTypeString[MAX_QPATH]={0};
+	saberType_t saberType = SABER_NONE;
+
+	if ( saberNum == 0 )
+	{
+		DC->getCVarString( "g_saber", saber, MAX_QPATH );
+	}
+	else
+	{
+		DC->getCVarString( "g_saber2", saber, MAX_QPATH );
+	}
+	//read this from the sabers.cfg
+	UI_SaberTypeForSaber( saber, saberTypeString );
+	if ( saberTypeString[0] )
+	{
+		saberType = TranslateSaberType( saberTypeString );
+	}
+
+	switch ( uiInfo.movesTitleIndex )
+	{
+	case 0://MD_ACROBATICS:
+		break;
+	case 1://MD_SINGLE_FAST:
+	case 2://MD_SINGLE_MEDIUM:
+	case 3://MD_SINGLE_STRONG:
+		if ( saberType != SABER_SINGLE )
+		{
+			Q_strncpyz(saber,"single_1",MAX_QPATH,qtrue);
+		}
+		break;
+	case 4://MD_DUAL_SABERS:
+		if ( saberType != SABER_SINGLE )
+		{
+			Q_strncpyz(saber,"single_1",MAX_QPATH,qtrue);
+		}
+		break;
+	case 5://MD_SABER_STAFF:
+		if ( saberType == SABER_SINGLE || saberType == SABER_NONE )
+		{
+			Q_strncpyz(saber,"dual_1",MAX_QPATH,qtrue);
+		}
+		break;
+	}
+
+}
+
+void UI_SaberDrawBlades( itemDef_t *item, vec3_t origin, float curYaw )
+{
+	//NOTE: only allows one saber type in view at a time
+	char saber[MAX_QPATH];
+	int saberNum = 0;
+	int saberModel = 0;
+	int	numSabers = 1;
+
+	if ( (item->flags&ITF_ISCHARACTER)//hacked sabermoves sabers in character's hand
+		&& uiInfo.movesTitleIndex == 4 /*MD_DUAL_SABERS*/ )
+	{
+		numSabers = 2;
+	}
+
+	for ( saberNum = 0; saberNum < numSabers; saberNum++ )
+	{
+		if ( (item->flags&ITF_ISCHARACTER) )//hacked sabermoves sabers in character's hand
+		{
+			UI_GetSaberForMenu( saber, saberNum );
+			saberModel = saberNum + 1;
+		}
+		else if ( (item->flags&ITF_ISSABER) )
+		{
+			DC->getCVarString( "ui_saber", saber, sizeof(saber) );
+			saberModel = 0;
+		}
+		else if ( (item->flags&ITF_ISSABER2) )
+		{
+			DC->getCVarString( "ui_saber2", saber, sizeof(saber) );
+			saberModel = 0;
+		}
+		else
+		{
+			return;
+		}
+		if ( saber[0] )
+		{
+			int numBlades = UI_SaberNumBladesForSaber( saber );
+			if ( numBlades )
+			{//okay, here we go, time to draw each blade...
+				char	saberTypeString[MAX_QPATH]={0};
+				UI_SaberTypeForSaber( saber, saberTypeString );
+				saberType_t saberType = TranslateSaberType( saberTypeString );
+				for ( int curBlade = 0; curBlade < numBlades; curBlade++ )
+				{
+					UI_SaberDrawBlade( item, saber, saberModel, saberType, origin, curYaw, curBlade );
+				}
+			}
+		}
+	}
+}
+
+void UI_SaberAttachToChar( itemDef_t *item )
+{
+	int	numSabers = 1;
+ 	int	saberNum = 0;
+
+	if ( item->ghoul2.size() > 2 && item->ghoul2[2].mModelindex >=0 )
+	{//remove any extra models
+		DC->g2_RemoveGhoul2Model(item->ghoul2, 2);
+	}
+	if ( item->ghoul2.size() > 1 && item->ghoul2[1].mModelindex >=0)
+	{//remove any extra models
+		DC->g2_RemoveGhoul2Model(item->ghoul2, 1);
+	}
+
+	if ( uiInfo.movesTitleIndex == 4 /*MD_DUAL_SABERS*/ )
+	{
+		numSabers = 2;
+	}
+
+	for ( saberNum = 0; saberNum < numSabers; saberNum++ )
+	{
+		//bolt sabers
+		char modelPath[MAX_QPATH];
+		char skinPath[MAX_QPATH];
+		char saber[MAX_QPATH]; 
+
+		UI_GetSaberForMenu( saber, saberNum );
+
+		if ( UI_SaberModelForSaber( saber, modelPath ) )
+		{//successfully found a model
+			int g2Saber = DC->g2_InitGhoul2Model(item->ghoul2, modelPath, 0, 0, 0, 0, 0); //add the model
+			if (g2Saber)
+			{
+				//get the customSkin, if any
+				if ( UI_SaberSkinForSaber( saber, skinPath ) )
+				{
+					int g2skin = DC->registerSkin(skinPath);
+					DC->g2_SetSkin( &item->ghoul2[g2Saber], 0, g2skin );//this is going to set the surfs on/off matching the skin file
+				}
+				else
+				{
+					DC->g2_SetSkin( &item->ghoul2[g2Saber], -1, 0 );//turn off custom skin
+				}
+				int boltNum;
+				if ( saberNum == 0 )
+				{
+					boltNum = G2API_AddBolt(&item->ghoul2[0], "*r_hand");
+				}
+				else
+				{
+					boltNum = G2API_AddBolt(&item->ghoul2[0], "*l_hand");
+				}
+				G2API_AttachG2Model(&item->ghoul2[g2Saber], &item->ghoul2[0], boltNum, 0);
+			}
+		}
+	}
+}
diff --git a/code/ui/ui_shared.cpp b/code/ui/ui_shared.cpp
new file mode 100644
index 0000000..8f70cd1
--- /dev/null
+++ b/code/ui/ui_shared.cpp
@@ -0,0 +1,11977 @@
+// 
+// string allocation/managment
+
+// leave this at the top of all UI_xxxx files for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+#include "ui_local.h"
+
+//rww - added for ui ghoul2 models
+#define UI_SHARED_CPP
+
+#include "../game/anims.h"
+#include "../cgame/animtable.h"
+
+#include "ui_shared.h"
+#include "menudef.h"
+
+void		UI_LoadMenus(const char *menuFile, qboolean reset);
+
+#ifdef _XBOX
+//MAP HACK!
+extern cvar_t *cl_mapname;
+void Menu_MapHack(int key);
+
+//JLF DEMOCODE MPMOVED
+
+//support for attract mode demo timer
+#define DEMO_TIME_MAX  45000 //g_demoTimeBeforeStart
+int g_demoLastKeypress = 0;  //milliseconds
+bool  g_ReturnToSplash = false;
+bool g_runningDemo = false;
+
+void G_DemoStart();
+void G_DemoEnd();
+void G_DemoFrame();
+void G_DemoKeypress();
+
+void PlayDemo();
+void UpdateDemoTimer();
+bool TestDemoTimer();
+
+//END DEMOCODE 
+//JLF used by sliders MPMOVED
+#define TICK_COUNT 20
+
+//JLF MORE PROTOTYPES MPMOVED
+qboolean Item_SetFocus(itemDef_t *item, float x, float y);
+
+qboolean Item_HandleSelectionNext(itemDef_t * item);
+qboolean Item_HandleSelectionPrev(itemDef_t * item);
+
+
+#endif
+
+extern vmCvar_t	ui_char_color_red;
+extern vmCvar_t	ui_char_color_green;
+extern vmCvar_t	ui_char_color_blue;
+
+void *UI_Alloc( int size );
+
+void		Controls_GetConfig( void );
+void		Fade(int *flags, float *f, float clamp, int *nextTime, int offsetTime, qboolean bFlags, float fadeAmount);
+void		Item_Init(itemDef_t *item);
+void		Item_InitControls(itemDef_t *item);
+qboolean	Item_Parse(itemDef_t *item);
+void		Item_RunScript(itemDef_t *item, const char *s);
+void		Item_SetupKeywordHash(void);
+void		Item_Text_AutoWrapped_Paint(itemDef_t *item);
+void		Item_UpdatePosition(itemDef_t *item);
+void		Item_ValidateTypeData(itemDef_t *item);
+void		LerpColor(vec4_t a, vec4_t b, vec4_t c, float t);
+itemDef_t	*Menu_FindItemByName(menuDef_t *menu, const char *p);
+itemDef_t	*Menu_GetMatchingItemByNumber(menuDef_t *menu, int index, const char *name);
+void		Menu_Paint(menuDef_t *menu, qboolean forcePaint);
+void		Menu_SetupKeywordHash(void);
+void		Menus_ShowItems(const char *menuName);
+qboolean	ParseRect(const char **p, rectDef_t *r);
+const char	*String_Alloc(const char *p);
+void		ToWindowCoords(float *x, float *y, windowDef_t *window);
+void		Window_Paint(Window *w, float fadeAmount, float fadeClamp, float fadeCycle);
+int			Item_ListBox_ThumbDrawPosition(itemDef_t *item);
+int			Item_ListBox_ThumbPosition(itemDef_t *item);
+int			Item_ListBox_MaxScroll(itemDef_t *item);
+static qboolean Rect_ContainsPoint(rectDef_t *rect, float x, float y) ;
+static qboolean	Item_Paint(itemDef_t *item, qboolean bDraw); 
+int Item_TextScroll_ThumbDrawPosition ( itemDef_t *item );
+static void Item_TextScroll_BuildLines ( itemDef_t* item );
+
+//static qboolean debugMode = qfalse;
+static qboolean g_waitingForKey = qfalse;
+static qboolean g_editingField = qfalse;
+
+static itemDef_t *g_bindItem = NULL;
+static itemDef_t *g_editItem = NULL;
+static itemDef_t *itemCapture = NULL;   // item that has the mouse captured ( if any )
+
+#define DOUBLE_CLICK_DELAY 300
+static int lastListBoxClickTime = 0;
+
+static void (*captureFunc) (void *p) = NULL;
+static void *captureData = NULL;
+
+//const char defaultString[10] = {"default"};
+#ifndef _XBOX
+#ifdef CGAME
+#define MEM_POOL_SIZE  128 * 1024
+#else
+#define MEM_POOL_SIZE  1024 * 1024
+#endif
+#endif // _XBOX
+
+#define SCROLL_TIME_START				500
+#define SCROLL_TIME_ADJUST				150
+#define SCROLL_TIME_ADJUSTOFFSET		40
+#define SCROLL_TIME_FLOOR				20
+
+typedef struct scrollInfo_s {
+	int nextScrollTime;
+	int nextAdjustTime;
+	int adjustValue;
+	int scrollKey;
+	float xStart;
+	float yStart;
+	itemDef_t *item;
+	qboolean scrollDir;
+} scrollInfo_t;
+
+static scrollInfo_t scrollInfo;
+
+#ifndef _XBOX
+static char		memoryPool[MEM_POOL_SIZE];
+#endif
+static int		allocPoint, outOfMemory;
+
+displayContextDef_t *DC = NULL;
+
+menuDef_t Menus[MAX_MENUS];		// defined menus
+int menuCount = 0;				// how many
+
+menuDef_t *menuStack[MAX_OPEN_MENUS];
+int openMenuCount = 0;
+
+static int strPoolIndex = 0;
+static char strPool[STRING_POOL_SIZE];
+
+typedef struct stringDef_s {
+	struct stringDef_s *next;
+	const char *str;
+} stringDef_t;
+
+#define HASH_TABLE_SIZE 2048
+
+static int strHandleCount = 0;
+static stringDef_t *strHandle[HASH_TABLE_SIZE];
+
+typedef struct  itemFlagsDef_s {
+	char *string;
+	int value;
+}	itemFlagsDef_t;
+
+itemFlagsDef_t itemFlags [] = {
+"WINDOW_INACTIVE",			WINDOW_INACTIVE,
+NULL,					NULL
+};
+
+char *styles [] = {
+"WINDOW_STYLE_EMPTY",
+"WINDOW_STYLE_FILLED",
+"WINDOW_STYLE_GRADIENT",
+"WINDOW_STYLE_SHADER",
+"WINDOW_STYLE_TEAMCOLOR",
+"WINDOW_STYLE_CINEMATIC",
+NULL
+};
+
+char *types [] = {
+"ITEM_TYPE_TEXT",
+"ITEM_TYPE_BUTTON",
+"ITEM_TYPE_RADIOBUTTON",
+"ITEM_TYPE_CHECKBOX",
+"ITEM_TYPE_EDITFIELD",
+"ITEM_TYPE_COMBO",
+"ITEM_TYPE_LISTBOX",
+"ITEM_TYPE_MODEL",
+"ITEM_TYPE_OWNERDRAW",
+"ITEM_TYPE_NUMERICFIELD",
+"ITEM_TYPE_SLIDER",
+"ITEM_TYPE_YESNO",
+"ITEM_TYPE_MULTI",
+"ITEM_TYPE_BIND",
+"ITEM_TYPE_TEXTSCROLL",
+NULL
+};
+
+char *alignment [] = {
+"ITEM_ALIGN_LEFT",
+"ITEM_ALIGN_CENTER",
+"ITEM_ALIGN_RIGHT",
+NULL
+};
+
+/*
+==================
+Init_Display
+
+Initializes the display with a structure to all the drawing routines
+ ==================
+*/
+void Init_Display(displayContextDef_t *dc) 
+{
+	DC = dc;
+}
+
+/*
+==================
+Window_Init
+
+Initializes a window structure ( windowDef_t ) with defaults
+ 
+==================
+*/
+void Window_Init(Window *w) 
+{
+	memset(w, 0, sizeof(windowDef_t));
+	w->borderSize = 1;
+	w->foreColor[0] = w->foreColor[1] = w->foreColor[2] = w->foreColor[3] = 1.0;
+	w->cinematic = -1;
+}
+
+/*
+=================
+PC_SourceError
+=================
+*/
+#ifndef _XBOX
+void PC_SourceError(int handle, char *format, ...) 
+{
+	int line;
+	char filename[128];
+	va_list argptr;
+	static char string[4096];
+
+	va_start (argptr, format);
+	vsprintf (string, format, argptr);
+	va_end (argptr);
+
+	filename[0] = '\0';
+	line = 0;
+
+	Com_Printf(S_COLOR_RED "ERROR: %s, line %d: %s\n", filename, line, string);
+}
+#endif
+
+
+/*
+=================
+PC_ParseStringMem
+=================
+*/
+//static vector<string> RetryPool;
+//void AddMenuPackageRetryKey(const char *psSPPackage)
+//{
+//	RetryPool.push_back(psSPPackage);
+//}
+qboolean PC_ParseStringMem(const char **out) 
+{
+	const char *temp;
+
+	if (PC_ParseString(&temp))
+	{
+		return qfalse;
+	}
+
+	*(out) = String_Alloc(temp);
+
+    return qtrue;
+}
+
+/*
+=================
+PC_ParseRect
+=================
+*/
+qboolean PC_ParseRect(rectDef_t *r) 
+{
+	if (!PC_ParseFloat(&r->x)) 
+	{
+		if (!PC_ParseFloat(&r->y)) 
+		{
+			if (!PC_ParseFloat(&r->w)) 
+			{
+				if (!PC_ParseFloat(&r->h)) 
+				{
+					return qtrue;
+				}
+			}
+		}
+	}
+	return qfalse;
+}
+
+
+/*
+=================
+PC_Script_Parse
+=================
+*/
+qboolean PC_Script_Parse(const char **out) 
+{
+	char script[4096];
+//	pc_token_t token;
+	char *token2;
+
+	script[0]=0;
+	// scripts start with { and have ; separated command lists.. commands are command, arg.. 
+	// basically we want everything between the { } as it will be interpreted at run time
+  
+	token2 = PC_ParseExt();
+	if (!token2)
+	{
+		return qfalse;
+	}
+
+	if (*token2 !='{') 
+	{
+	    return qfalse;
+	}
+
+	while ( 1 ) 
+	{
+		token2 = PC_ParseExt();
+		if (!token2)
+		{
+			return qfalse;
+		}
+
+		if (*token2 =='}')	// End of the script?
+		{
+			*out = String_Alloc(script);
+			return qtrue;
+		}
+
+		if (*(token2 +1) != '\0') 
+		{
+			Q_strcat(script, sizeof(script), va("\"%s\"", token2));
+		} 
+		else 
+		{
+			Q_strcat(script, sizeof(script), token2);
+		}
+		Q_strcat(script, sizeof(script), " ");
+	}
+}
+
+//--------------------------------------------------------------------------------------------
+//	Menu Keyword Parse functions
+//--------------------------------------------------------------------------------------------
+
+/*
+=================
+MenuParse_font
+=================
+*/
+qboolean MenuParse_font( itemDef_t *item) 
+{
+	menuDef_t *menu = (menuDef_t*)item;
+
+	if (!PC_ParseStringMem(&menu->font))
+	{
+		return qfalse;
+	}
+
+	if (!DC->Assets.fontRegistered) 
+	{
+		DC->Assets.qhMediumFont = DC->registerFont(menu->font);
+		DC->Assets.fontRegistered = qtrue;
+	}
+	return qtrue;
+}
+
+
+/*
+=================
+MenuParse_name
+=================
+*/
+qboolean MenuParse_name(itemDef_t *item) 
+{
+	menuDef_t *menu = (menuDef_t*)item;
+
+	if (!PC_ParseStringMem((const char **) &menu->window.name))
+	{
+		return qfalse;
+	}
+
+//	if (Q_stricmp(menu->window.name, "main") == 0) 
+//	{
+		// default main as having focus
+//		menu->window.flags |= WINDOW_HASFOCUS;
+//	}
+	return qtrue;
+}
+
+/*
+=================
+MenuParse_fullscreen
+=================
+*/
+
+qboolean MenuParse_fullscreen( itemDef_t *item ) 
+{
+	menuDef_t *menu = (menuDef_t*)item;
+
+	if (PC_ParseInt((int *) &menu->fullScreen))
+	{
+		return qfalse;
+	}
+	return qtrue;
+}
+
+/*
+=================
+MenuParse_rect
+=================
+*/
+
+qboolean MenuParse_rect( itemDef_t *item) 
+{
+	menuDef_t *menu = (menuDef_t*)item;
+
+	if (!PC_ParseRect(&menu->window.rect)) 
+	{
+		return qfalse;
+	}
+	return qtrue;
+}
+
+/*
+=================
+MenuParse_style
+=================
+*/
+qboolean MenuParse_style( itemDef_t *item) 
+{
+	int		i;
+	const char	*tempStr;
+	menuDef_t *menu = (menuDef_t*)item;
+
+	if (PC_ParseString(&tempStr)) 
+	{
+		return qfalse;
+	}
+
+	i=0;
+	while (styles[i])
+	{
+		if (Q_stricmp(tempStr,styles[i])==0)
+		{
+			menu->window.style = i;
+			break;
+		}
+		i++;
+	}
+
+	if (styles[i] == NULL)
+	{
+		PC_ParseWarning(va("Unknown menu style value '%s'",tempStr));	
+	}
+	return qtrue;
+}
+
+
+/*
+=================
+MenuParse_visible
+=================
+*/
+qboolean MenuParse_visible( itemDef_t *item ) 
+{
+	int i;
+	menuDef_t *menu = (menuDef_t*)item;
+
+	if (PC_ParseInt(&i)) 
+	{
+		return qfalse;
+	}
+
+	if (i) 
+	{
+		menu->window.flags |= WINDOW_VISIBLE;
+	}
+	return qtrue;
+}
+
+/*
+=================
+MenuParse_ignoreescape
+=================
+*/
+qboolean MenuParse_ignoreescape( itemDef_t *item ) 
+{
+	int i;
+	menuDef_t *menu = (menuDef_t*)item;
+
+	if (PC_ParseInt(&i)) 
+	{
+		return qfalse;
+	}
+
+	if (i) 
+	{
+		menu->window.flags |= WINDOW_IGNORE_ESCAPE;
+	}
+	return qtrue;
+}
+
+/*
+=================
+MenuParse_onOpen
+=================
+*/
+qboolean MenuParse_onOpen( itemDef_t *item) 
+{
+	menuDef_t *menu = (menuDef_t*)item;
+
+	if (!PC_Script_Parse(&menu->onOpen)) 
+	{
+		return qfalse;
+	}
+	return qtrue;
+}
+
+/*
+=================
+MenuParse_onClose
+=================
+*/
+qboolean MenuParse_onClose( itemDef_t *item ) 
+{
+	menuDef_t *menu = (menuDef_t*)item;
+
+	if (!PC_Script_Parse(&menu->onClose)) 
+	{
+		return qfalse;
+	}
+	return qtrue;
+}
+
+//JLFACCEPT MPMOVED
+/*
+=================
+MenuParse_onAccept
+=================
+*/
+qboolean MenuParse_onAccept( itemDef_t *item ) 
+{
+	menuDef_t *menu = (menuDef_t*)item;
+
+	if (!PC_Script_Parse(&menu->onAccept)) 
+	{
+		return qfalse;
+	}
+	return qtrue;
+}
+
+
+/*
+=================
+MenuParse_onESC
+=================
+*/
+qboolean MenuParse_onESC( itemDef_t *item ) 
+{
+	menuDef_t *menu = (menuDef_t*)item;
+
+	if (!PC_Script_Parse(&menu->onESC)) 
+	{
+		return qfalse;
+	}
+	return qtrue;
+}
+
+
+/*
+=================
+MenuParse_border
+=================
+*/
+qboolean MenuParse_border( itemDef_t *item) 
+{
+	menuDef_t *menu = (menuDef_t*)item;
+
+	if (PC_ParseInt(&menu->window.border)) 
+	{
+		return qfalse;
+	}
+	return qtrue;
+}
+
+/*
+=================
+MenuParse_borderSize
+=================
+*/
+qboolean MenuParse_borderSize( itemDef_t *item) 
+{
+	menuDef_t *menu = (menuDef_t*)item;
+
+	if (PC_ParseFloat(&menu->window.borderSize)) 
+	{
+		return qfalse;
+	}
+	return qtrue;
+}
+
+/*
+=================
+MenuParse_backcolor
+=================
+*/
+qboolean MenuParse_backcolor( itemDef_t *item ) 
+{
+	int i;
+	float f;
+	menuDef_t *menu = (menuDef_t*)item;
+
+	for (i = 0; i < 4; i++) 
+	{
+		if (PC_ParseFloat(&f)) 
+		{
+			return qfalse;
+		}
+		menu->window.backColor[i]  = f;
+	}
+	return qtrue;
+}
+
+/*
+=================
+MenuParse_forecolor
+=================
+*/
+qboolean MenuParse_forecolor( itemDef_t *item) 
+{
+	int i;
+	float f;
+	menuDef_t *menu = (menuDef_t*)item;
+
+	for (i = 0; i < 4; i++) 
+	{
+		if (PC_ParseFloat(&f)) 
+		{
+			return qfalse;
+		}
+		if (f < 0)
+		{	//special case for player color
+			menu->window.flags |= WINDOW_PLAYERCOLOR;
+			return qtrue;
+		}
+		menu->window.foreColor[i]  = f;
+		menu->window.flags |= WINDOW_FORECOLORSET;
+	}
+	return qtrue;
+}
+
+/*
+=================
+MenuParse_bordercolor
+=================
+*/
+qboolean MenuParse_bordercolor( itemDef_t *item ) 
+{
+	int i;
+	float f;
+	menuDef_t *menu = (menuDef_t*)item;
+
+	for (i = 0; i < 4; i++) 
+	{
+		if (PC_ParseFloat(&f)) 
+		{
+			return qfalse;
+		}
+		menu->window.borderColor[i]  = f;
+	}
+	return qtrue;
+}
+
+/*
+=================
+MenuParse_focuscolor
+=================
+*/
+qboolean MenuParse_focuscolor( itemDef_t *item) 
+{
+	int i;
+	float f;
+	menuDef_t *menu = (menuDef_t*)item;
+
+	for (i = 0; i < 4; i++) 
+	{
+		if (PC_ParseFloat(&f)) 
+		{
+			return qfalse;
+		}
+		menu->focusColor[i]  = f;
+	}
+	return qtrue;
+}
+
+
+/*
+=================
+MenuParse_focuscolor
+=================
+*/
+qboolean MenuParse_appearanceIncrement( itemDef_t *item) 
+{
+	menuDef_t *menu = (menuDef_t*)item;
+
+	if (PC_ParseFloat(&menu->appearanceIncrement)) 
+	{
+		return qfalse;
+	}
+	return qtrue;
+}
+
+
+
+/*
+=================
+MenuParse_descAlignment
+=================
+*/
+qboolean MenuParse_descAlignment( itemDef_t *item) 
+{
+	menuDef_t *menu = (menuDef_t*)item;
+	const char *tempStr;
+	int	i;
+
+	if (PC_ParseString(&tempStr)) 
+	{
+		return qfalse;
+	}
+
+	i=0;
+	while (alignment[i])
+	{
+		if (Q_stricmp(tempStr,alignment[i])==0)
+		{
+			menu->descAlignment = i;
+			break;
+		}
+		i++;
+	}
+
+	if (alignment[i] == NULL)
+	{
+		PC_ParseWarning(va("Unknown desc alignment value '%s'",tempStr));	
+	}
+
+	return qtrue;
+}
+
+/*
+=================
+MenuParse_descTextStyle
+=================
+*/
+qboolean MenuParse_descTextStyle( itemDef_t *item) 
+{
+	menuDef_t *menu = (menuDef_t*)item;
+
+	if (PC_ParseInt(&menu->descTextStyle)) 
+	{
+		return qfalse;
+	}
+	return qtrue;
+}
+/*
+=================
+MenuParse_descX
+=================
+*/
+qboolean MenuParse_descX( itemDef_t *item) 
+{
+	menuDef_t *menu = (menuDef_t*)item;
+
+	if (PC_ParseInt(&menu->descX)) 
+	{
+		return qfalse;
+	}
+	return qtrue;
+}
+
+/*
+=================
+MenuParse_descY
+=================
+*/
+qboolean MenuParse_descY( itemDef_t *item) 
+{
+	menuDef_t *menu = (menuDef_t*)item;
+
+	if (PC_ParseInt(&menu->descY)) 
+	{
+		return qfalse;
+	}
+	return qtrue;
+}
+
+
+/*
+=================
+MenuParse_descScale
+=================
+*/
+qboolean MenuParse_descScale( itemDef_t *item) 
+{
+	menuDef_t *menu = (menuDef_t*)item;
+
+	if (PC_ParseFloat(&menu->descScale)) 
+	{
+		return qfalse;
+	}
+	return qtrue;
+}
+
+/*
+=================
+MenuParse_descColor
+=================
+*/
+qboolean MenuParse_descColor( itemDef_t *item) 
+{
+	int i;
+	float f;
+	menuDef_t *menu = (menuDef_t*)item;
+
+	for (i = 0; i < 4; i++) 
+	{
+		if (PC_ParseFloat(&f)) 
+		{
+			return qfalse;
+		}
+		menu->descColor[i]  = f;
+	}
+	return qtrue;
+}
+
+/*
+=================
+MenuParse_disablecolor
+=================
+*/
+qboolean MenuParse_disablecolor( itemDef_t *item) 
+{
+	int i;
+	float f;
+	menuDef_t *menu = (menuDef_t*)item;
+
+	for (i = 0; i < 4; i++) 
+	{
+		if (PC_ParseFloat(&f)) 
+		{
+			return qfalse;
+		}
+		menu->disableColor[i]  = f;
+	}
+	return qtrue;
+}
+
+
+/*
+=================
+MenuParse_outlinecolor
+=================
+*/
+qboolean MenuParse_outlinecolor( itemDef_t *item) 
+{
+	menuDef_t *menu = (menuDef_t*)item;
+
+	if (PC_ParseColor(&menu->window.outlineColor))
+	{
+		return qfalse;
+	}
+	return qtrue;
+}
+
+/*
+=================
+MenuParse_background
+=================
+*/
+qboolean MenuParse_background( itemDef_t *item) 
+{
+	const char *buff;
+	menuDef_t *menu = (menuDef_t*)item;
+
+	if (PC_ParseString(&buff)) 
+	{
+		return qfalse;
+	}
+
+	menu->window.background = ui.R_RegisterShaderNoMip(buff);
+	return qtrue;
+}
+
+/*
+=================
+MenuParse_cinematic
+=================
+*/
+qboolean MenuParse_cinematic( itemDef_t *item) 
+{
+	menuDef_t *menu = (menuDef_t*)item;
+
+	if (!PC_ParseStringMem((const char **) &menu->window.cinematicName)) 
+	{
+		return qfalse;
+	}
+	return qtrue;
+}
+
+/*
+=================
+MenuParse_ownerdrawFlag
+=================
+*/
+qboolean MenuParse_ownerdrawFlag( itemDef_t *item) 
+{
+	int i;
+	menuDef_t *menu = (menuDef_t*)item;
+
+	if (PC_ParseInt(&i)) 
+	{
+		return qfalse;
+	}
+	menu->window.ownerDrawFlags |= i;
+	return qtrue;
+}
+
+/*
+=================
+MenuParse_ownerdraw
+=================
+*/
+qboolean MenuParse_ownerdraw( itemDef_t *item) 
+{
+	menuDef_t *menu = (menuDef_t*)item;
+
+	if (PC_ParseInt(&menu->window.ownerDraw)) 
+	{
+		return qfalse;
+	}
+	return qtrue;
+}
+
+
+/*
+=================
+MenuParse_popup
+=================
+*/
+qboolean MenuParse_popup( itemDef_t *item) 
+{
+	menuDef_t *menu = (menuDef_t*)item;
+	menu->window.flags |= WINDOW_POPUP;
+	return qtrue;
+}
+
+
+/*
+=================
+MenuParse_outOfBounds
+=================
+*/
+qboolean MenuParse_outOfBounds( itemDef_t *item) 
+{
+	menuDef_t *menu = (menuDef_t*)item;
+
+	menu->window.flags |= WINDOW_OOB_CLICK;
+	return qtrue;
+}
+
+/*
+=================
+MenuParse_soundLoop
+=================
+*/
+qboolean MenuParse_soundLoop( itemDef_t *item) 
+{
+	menuDef_t *menu = (menuDef_t*)item;
+
+	if (!PC_ParseStringMem((const char **) &menu->soundName)) 
+	{
+		return qfalse;
+	}
+	return qtrue;
+}
+
+/*
+================
+MenuParse_fadeClamp
+================
+*/
+qboolean MenuParse_fadeClamp( itemDef_t *item) 
+{
+	menuDef_t *menu = (menuDef_t*)item;
+
+	if (PC_ParseFloat(&menu->fadeClamp)) 
+	{
+		return qfalse;
+	}
+	return qtrue;
+}
+
+/*
+================
+MenuParse_fadeAmount
+================
+*/
+qboolean MenuParse_fadeAmount( itemDef_t *item) 
+{
+	menuDef_t *menu = (menuDef_t*)item;
+
+	if (PC_ParseFloat(&menu->fadeAmount)) 
+	{
+		return qfalse;
+	}
+	return qtrue;
+}
+
+
+/*
+================
+MenuParse_fadeCycle
+================
+*/
+qboolean MenuParse_fadeCycle( itemDef_t *item) 
+{
+	menuDef_t *menu = (menuDef_t*)item;
+
+	if (PC_ParseInt(&menu->fadeCycle)) 
+	{
+		return qfalse;
+	}
+	return qtrue;
+}
+
+
+/*
+================
+MenuParse_itemDef
+================
+*/
+qboolean MenuParse_itemDef( itemDef_t *item) 
+{
+	menuDef_t *menu = (menuDef_t*)item;
+	if (menu->itemCount < MAX_MENUITEMS) 
+	{
+		menu->items[menu->itemCount] = (struct itemDef_s *) UI_Alloc(sizeof(itemDef_t));
+		Item_Init(menu->items[menu->itemCount]);
+		if (!Item_Parse(menu->items[menu->itemCount])) 
+		{
+			return qfalse;
+		}
+		Item_InitControls(menu->items[menu->itemCount]);
+		menu->items[menu->itemCount++]->parent = menu;
+	}
+	else
+	{
+		PC_ParseWarning(va("Exceeded item/menu max of %d", MAX_MENUITEMS));
+	}
+	return qtrue;
+}
+
+#define KEYWORDHASH_SIZE	512
+
+typedef struct keywordHash_s
+{
+	char		*keyword;
+	qboolean	(*func)(itemDef_t *item);
+	struct		keywordHash_s *next;
+} keywordHash_t;
+
+keywordHash_t menuParseKeywords[] = {
+	{"appearanceIncrement",	MenuParse_appearanceIncrement},
+	{"backcolor",			MenuParse_backcolor,	},
+	{"background",			MenuParse_background,	},
+	{"border",				MenuParse_border,		},
+	{"bordercolor",			MenuParse_bordercolor,	},
+	{"borderSize",			MenuParse_borderSize,	},
+	{"cinematic",			MenuParse_cinematic,	},
+	{"descAlignment",		MenuParse_descAlignment	},
+	{"descTextStyle",		MenuParse_descTextStyle	},
+	{"desccolor",			MenuParse_descColor		},
+	{"descX",				MenuParse_descX			},
+	{"descY",				MenuParse_descY			},
+	{"descScale",			MenuParse_descScale		},
+	{"disablecolor",		MenuParse_disablecolor,	},
+	{"fadeClamp",			MenuParse_fadeClamp,	},
+	{"fadeCycle",			MenuParse_fadeCycle,	},
+	{"fadeAmount",			MenuParse_fadeAmount,	},
+	{"focuscolor",			MenuParse_focuscolor,	},
+	{"font",				MenuParse_font,			},
+	{"forecolor",			MenuParse_forecolor,	},
+	{"fullscreen",			MenuParse_fullscreen,	},
+	{"itemDef",				MenuParse_itemDef,		},
+	{"name",				MenuParse_name,			},
+	{"onClose",				MenuParse_onClose,		},
+//JLFACCEPT MPMOVED
+	{"onAccept",			MenuParse_onAccept,		},
+	{"onESC",				MenuParse_onESC,		},
+	{"onOpen",				MenuParse_onOpen,		},
+	{"outlinecolor",		MenuParse_outlinecolor,	},
+	{"outOfBoundsClick",	MenuParse_outOfBounds,	},
+	{"ownerdraw",			MenuParse_ownerdraw,	},
+	{"ownerdrawFlag",		MenuParse_ownerdrawFlag,},
+	{"popup",				MenuParse_popup,		},
+	{"rect",				MenuParse_rect,			},
+	{"soundLoop",			MenuParse_soundLoop,	},
+	{"style",				MenuParse_style,		},
+	{"visible",				MenuParse_visible,		},
+	{"ignoreescape",		MenuParse_ignoreescape,	},
+	{NULL,					NULL,					}
+};
+
+keywordHash_t *menuParseKeywordHash[KEYWORDHASH_SIZE];
+
+/*
+================
+KeywordHash_Key
+================
+*/
+int KeywordHash_Key(const char *keyword) 
+{
+	int register hash, i;
+
+	hash = 0;
+	for (i = 0; keyword[i] != '\0'; i++) {
+		if (keyword[i] >= 'A' && keyword[i] <= 'Z')
+			hash += (keyword[i] + ('a' - 'A')) * (119 + i);
+		else
+			hash += keyword[i] * (119 + i);
+	}
+	hash = (hash ^ (hash >> 10) ^ (hash >> 20)) & (KEYWORDHASH_SIZE-1);
+	return hash;
+}
+
+/*
+================
+KeywordHash_Add
+================
+*/
+void KeywordHash_Add(keywordHash_t *table[], keywordHash_t *key) 
+{
+	int hash;
+
+	hash = KeywordHash_Key(key->keyword);
+	key->next = table[hash];
+	table[hash] = key;
+}
+
+/*
+===============
+KeywordHash_Find
+===============
+*/
+keywordHash_t *KeywordHash_Find(keywordHash_t *table[], const char *keyword)
+{
+	keywordHash_t *key;
+	int hash;
+
+	hash = KeywordHash_Key(keyword);
+	for (key = table[hash]; key; key = key->next) 
+	{
+		if (!Q_stricmp(key->keyword, keyword))
+			return key;
+	}
+	return NULL;
+}
+
+/*
+================
+hashForString
+
+return a hash value for the string
+================
+*/
+static long hashForString(const char *str) 
+{
+	int		i;
+	long	hash;
+	char	letter;
+
+	hash = 0;
+	i = 0;
+	while (str[i] != '\0') 
+	{
+		letter = tolower((unsigned char)str[i]);
+		hash+=(long)(letter)*(i+119);
+		i++;
+	}
+	hash &= (HASH_TABLE_SIZE-1);
+	return hash;
+}
+
+/*
+=================
+String_Alloc
+=================
+*/
+const char *String_Alloc(const char *p) 
+{
+	int len;
+	long hash;
+	stringDef_t *str, *last;
+	static const char *staticNULL = "";
+
+	if (p == NULL) 
+	{
+		return NULL;
+	}
+
+	if (*p == 0) 
+	{
+		return staticNULL;
+	}
+
+	hash = hashForString(p);
+
+	str = strHandle[hash];
+	while (str) 
+	{
+		if (strcmp(p, str->str) == 0) 
+		{
+			return str->str;
+		}
+		str = str->next;
+	}
+
+	len = strlen(p);
+	if (len + strPoolIndex + 1 < STRING_POOL_SIZE) 
+	{
+		int ph = strPoolIndex;
+		strcpy(&strPool[strPoolIndex], p);
+		strPoolIndex += len + 1;
+
+		str = strHandle[hash];
+		last = str;
+		while (last && last->next) 
+		{
+			last = last->next;
+		}
+
+		str  = (stringDef_s *) UI_Alloc( sizeof(stringDef_t));
+		str->next = NULL;
+		str->str = &strPool[ph];
+		if (last) 
+		{
+			last->next = str;
+		} 
+		else 
+		{
+			strHandle[hash] = str;
+		}
+
+		return &strPool[ph];
+	}
+	else
+	{
+		Com_Printf("WARNING: Ran out of strPool space\n");
+	}
+	
+	return NULL;
+}
+
+/*
+=================
+String_Report
+=================
+*/
+void String_Report(void) 
+{
+	float f;
+	Com_Printf("Memory/String Pool Info\n");
+	Com_Printf("----------------\n");
+	f = strPoolIndex;
+	f /= STRING_POOL_SIZE;
+	f *= 100;
+	Com_Printf("String Pool is %.1f%% full, %i bytes out of %i used.\n", f, strPoolIndex, STRING_POOL_SIZE);
+#ifdef _XBOX
+	Com_Printf("Memory Pool is using %i bytes.\n", allocPoint);
+#else
+	f = allocPoint;
+	f /= MEM_POOL_SIZE;
+	f *= 100;
+	Com_Printf("Memory Pool is %.1f%% full, %i bytes out of %i used.\n", f, allocPoint, MEM_POOL_SIZE);
+#endif
+}
+
+/*
+=================
+String_Init
+=================
+*/
+void String_Init(void) 
+{
+	int i;
+
+	for (i = 0; i < HASH_TABLE_SIZE; i++) 
+	{
+		strHandle[i] = 0;
+	}
+
+	strHandleCount = 0;
+	strPoolIndex = 0;
+	UI_InitMemory();
+	Item_SetupKeywordHash();
+	Menu_SetupKeywordHash();
+
+	if (DC && DC->getBindingBuf) 
+	{
+		Controls_GetConfig();
+	}
+}
+
+
+
+//---------------------------------------------------------------------------------------------------------
+//		Memory
+//---------------------------------------------------------------------------------------------------------
+
+/*
+===============
+UI_Alloc
+===============
+*/				  
+void *UI_Alloc( int size ) 
+{
+#ifdef _XBOX
+	allocPoint += size;
+
+	return Z_Malloc(size, TAG_UI_ALLOC, qfalse, 4);
+#else
+	char	*p; 
+
+	if ( allocPoint + size > MEM_POOL_SIZE ) 
+	{
+		outOfMemory = qtrue;
+		if (DC->Print) 
+		{
+			DC->Print("UI_Alloc: Failure. Out of memory!\n");
+		}
+		return NULL;
+	}
+
+	p = &memoryPool[allocPoint];
+
+	allocPoint += ( size + 15 ) & ~15;
+
+	return p;
+#endif
+}
+
+/*
+===============
+UI_InitMemory
+===============
+*/
+void UI_InitMemory( void ) 
+{
+	allocPoint = 0;
+	outOfMemory = qfalse;
+#ifdef _XBOX
+	Z_TagFree(TAG_UI_ALLOC);
+#endif
+}
+
+
+/*
+===============
+Menu_ItemsMatchingGroup
+===============
+*/
+int Menu_ItemsMatchingGroup(menuDef_t *menu, const char *name) 
+{
+	int i;
+	int count = 0;
+
+	for (i = 0; i < menu->itemCount; i++) 
+	{
+		if ((!menu->items[i]->window.name) && (!menu->items[i]->window.group))
+		{
+			Com_Printf(S_COLOR_YELLOW"WARNING: item has neither name or group\n");
+			continue;
+		}
+
+		if (Q_stricmp(menu->items[i]->window.name, name) == 0 || (menu->items[i]->window.group && Q_stricmp(menu->items[i]->window.group, name) == 0)) 
+		{
+			count++;
+		} 
+	}
+
+	return count;
+}
+
+/*
+===============
+Menu_GetMatchingItemByNumber
+===============
+*/
+itemDef_t *Menu_GetMatchingItemByNumber(menuDef_t *menu, int index, const char *name) 
+{
+	int i;
+	int count = 0;
+	for (i = 0; i < menu->itemCount; i++) 
+	{
+		if (Q_stricmp(menu->items[i]->window.name, name) == 0 || (menu->items[i]->window.group && Q_stricmp(menu->items[i]->window.group, name) == 0)) 
+		{
+			if (count == index) 
+			{
+				return menu->items[i];
+			}
+			count++;
+		} 
+	}
+	return NULL;
+}
+
+/*
+===============
+Menu_FadeItemByName
+===============
+*/
+void Menu_FadeItemByName(menuDef_t *menu, const char *p, qboolean fadeOut) 
+{
+	itemDef_t *item;
+	int i;
+	int count = Menu_ItemsMatchingGroup(menu, p);
+	for (i = 0; i < count; i++) 
+	{
+		item = Menu_GetMatchingItemByNumber(menu, i, p);
+		if (item != NULL) 
+		{
+			if (fadeOut) 
+			{
+				item->window.flags |= (WINDOW_FADINGOUT | WINDOW_VISIBLE);
+				item->window.flags &= ~WINDOW_FADINGIN;
+			} 
+			else 
+			{
+				item->window.flags |= (WINDOW_VISIBLE | WINDOW_FADINGIN);
+				item->window.flags &= ~WINDOW_FADINGOUT;
+			}
+		}
+	}
+}
+
+/*
+===============
+Menu_ShowItemByName
+===============
+*/
+void Menu_ShowItemByName(menuDef_t *menu, const char *p, qboolean bShow) 
+{
+	itemDef_t *item;
+	int i;
+	int count;
+
+	count = Menu_ItemsMatchingGroup(menu, p);
+
+	if (!count)
+	{
+		Com_Printf(S_COLOR_YELLOW"WARNING: Menu_ShowItemByName - unable to locate any items named :%s\n",p);
+	}
+
+	for (i = 0; i < count; i++) 
+	{
+		item = Menu_GetMatchingItemByNumber(menu, i, p);
+		if (item != NULL) 
+		{
+			if (bShow) 
+			{
+				item->window.flags |= WINDOW_VISIBLE;
+			} 
+			else 
+			{
+				item->window.flags &= ~(WINDOW_VISIBLE | WINDOW_HASFOCUS);
+				// stop cinematics playing in the window
+				if (item->window.cinematic >= 0) 
+				{
+					DC->stopCinematic(item->window.cinematic);
+					item->window.cinematic = -1;
+				}
+			}
+		}
+	}
+}
+
+/*
+===============
+Menu_GetFocused
+===============
+*/
+menuDef_t *Menu_GetFocused(void) 
+{
+	int i;
+
+	for (i = 0; i < menuCount; i++) 
+	{
+		if ((Menus[i].window.flags & WINDOW_HASFOCUS) && (Menus[i].window.flags & WINDOW_VISIBLE)) 
+		{
+	      return &Menus[i];
+		}
+	}
+
+	return NULL;
+}
+
+/*
+===============
+Menus_OpenByName
+===============
+*/
+void Menus_OpenByName(const char *p) 
+{
+	Menus_ActivateByName(p);
+}
+
+/*
+===============
+Menus_FindByName
+===============
+*/
+menuDef_t *Menus_FindByName(const char *p) 
+{
+	int i;
+	for (i = 0; i < menuCount; i++) 
+	{
+		if (Q_stricmp(Menus[i].window.name, p) == 0) 
+		{
+			return &Menus[i];
+		} 
+	}
+	return NULL;
+}
+
+/*
+===============
+Menu_RunCloseScript
+===============
+*/
+static void Menu_RunCloseScript(menuDef_t *menu) 
+{
+	if (menu && menu->window.flags & WINDOW_VISIBLE && menu->onClose) 
+	{
+		itemDef_t item;
+		item.parent = menu;
+		Item_RunScript(&item, menu->onClose);
+	}
+}
+
+/*
+===============
+Item_ActivateByName
+===============
+*/
+void Item_ActivateByName(const char *menuName,const char *itemName) 
+{
+	itemDef_t *item;
+	menuDef_t *menu;
+		
+	menu = Menus_FindByName(menuName);
+
+	item = (itemDef_s *) Menu_FindItemByName((menuDef_t *) menu, itemName);
+
+	if (item != NULL) 
+	{
+		item->window.flags &= ~WINDOW_INACTIVE;
+	}
+}
+
+/*
+===============
+Menus_CloseByName
+===============
+*/
+void Menus_CloseByName(const char *p) 
+{
+	menuDef_t *menu = Menus_FindByName(p);
+	
+	// If the menu wasnt found just exit
+	if (menu == NULL) 
+	{
+		return;
+	}
+
+	// Run the close script for the menu
+	Menu_RunCloseScript(menu);
+
+	// If this window had the focus then take it away
+	if ( menu->window.flags & WINDOW_HASFOCUS )
+	{	
+		// If there is something still in the open menu list then
+		// set it to have focus now
+		if ( openMenuCount )
+		{
+			// Subtract one from the open menu count to prepare to
+			// remove the top menu from the list
+			openMenuCount -= 1;
+
+			// Set the top menu to have focus now
+			menuStack[openMenuCount]->window.flags |= WINDOW_HASFOCUS;
+
+			// Remove the top menu from the list
+			menuStack[openMenuCount] = NULL;
+		}
+	}
+
+	// Window is now invisible and doenst have focus
+	menu->window.flags &= ~(WINDOW_VISIBLE | WINDOW_HASFOCUS);
+}
+
+/*
+===============
+Menu_FindItemByName
+===============
+*/
+itemDef_t *Menu_FindItemByName(menuDef_t *menu, const char *p) 
+{
+	int i;
+	if (menu == NULL || p == NULL) 
+	{
+		return NULL;
+	}
+
+	for (i = 0; i < menu->itemCount; i++) 
+	{
+		if (Q_stricmp(p, menu->items[i]->window.name) == 0) 
+		{
+			return menu->items[i];
+		}
+	}
+
+	return NULL;
+}
+
+/*
+=================
+Menu_ClearFocus
+=================
+*/
+itemDef_t *Menu_ClearFocus(menuDef_t *menu) 
+{
+	int i;
+	itemDef_t *ret = NULL;
+
+	if (menu == NULL) 
+	{
+		return NULL;
+	}
+	for (i = 0; i < menu->itemCount; i++) 
+	{
+		if (menu->items[i]->window.flags & WINDOW_HASFOCUS) 
+		{
+			ret = menu->items[i];
+			menu->items[i]->window.flags &= ~WINDOW_HASFOCUS;
+			if (menu->items[i]->leaveFocus) 
+			{
+				Item_RunScript(menu->items[i], menu->items[i]->leaveFocus);
+			}
+		} 
+	}
+	return ret;
+}
+
+// Set all the items within a given menu, with the given itemName, to the given shader
+void Menu_SetItemBackground(const menuDef_t *menu,const char *itemName, const char *background) 
+{
+	itemDef_t	*item;
+	int			j, count;
+
+	if (!menu)	// No menu???
+	{
+		return;
+	}
+
+	count = Menu_ItemsMatchingGroup( (menuDef_t *) menu, itemName);
+
+	for (j = 0; j < count; j++) 
+	{
+		item = Menu_GetMatchingItemByNumber( (menuDef_t *) menu, j, itemName);
+		if (item != NULL) 
+		{
+//			item->window.background = DC->registerShaderNoMip(background);
+			item->window.background = ui.R_RegisterShaderNoMip(background);
+		}
+	}
+}
+
+// Set all the items within a given menu, with the given itemName, to the given text
+void Menu_SetItemText(const menuDef_t *menu,const char *itemName, const char *text) 
+{
+	itemDef_t	*item;
+	int			j, count;
+
+	if (!menu)	// No menu???
+	{
+		return;
+	}
+
+	count = Menu_ItemsMatchingGroup( (menuDef_t *) menu, itemName);
+
+	for (j = 0; j < count; j++) 
+	{
+		item = Menu_GetMatchingItemByNumber( (menuDef_t *) menu, j, itemName);
+		if (item != NULL) 
+		{
+			if (text[0] == '*')
+			{
+				item->cvar = text+1;
+				// Just copying what was in ItemParse_cvar()
+				if ( item->typeData)
+				{
+					editFieldDef_t *editPtr;
+					editPtr = (editFieldDef_t*)item->typeData;
+					editPtr->minVal = -1;
+					editPtr->maxVal = -1;
+					editPtr->defVal = -1;
+				}
+			}
+			else
+			{
+				if (item->type == ITEM_TYPE_TEXTSCROLL )
+				{
+					char cvartext[1024];
+					textScrollDef_t *scrollPtr = (textScrollDef_t*)item->typeData;
+					if ( scrollPtr )
+					{
+						scrollPtr->startPos = 0;
+						scrollPtr->endPos = 0;
+					}
+
+					if (item->cvar) 
+					{
+						DC->getCVarString(item->cvar, cvartext, sizeof(cvartext));
+						item->text = cvartext;
+					}
+					else
+					{
+						item->text = (char *) text;
+					}
+
+					Item_TextScroll_BuildLines ( item );
+				}
+				else
+				{
+					item->text = (char *) text;
+				}
+			}
+		}
+	}
+}
+
+/*
+=================
+Menu_TransitionItemByName
+=================
+*/
+void Menu_TransitionItemByName(menuDef_t *menu, const char *p, const rectDef_t *rectFrom, const rectDef_t *rectTo, int time, float amt) 
+{
+	itemDef_t *item;
+	int i;
+	int count = Menu_ItemsMatchingGroup(menu, p);
+	for (i = 0; i < count; i++) 
+	{
+		item = Menu_GetMatchingItemByNumber(menu, i, p);
+		if (item != NULL) 
+		{
+			if (!rectFrom)
+			{
+				rectFrom = &item->window.rect;	//if there are more than one of these with the same name, they'll all use the FIRST one's FROM.
+			}
+			item->window.flags |= (WINDOW_INTRANSITION | WINDOW_VISIBLE);
+			item->window.offsetTime = time;
+			memcpy(&item->window.rectClient, rectFrom, sizeof(rectDef_t));
+			memcpy(&item->window.rectEffects, rectTo, sizeof(rectDef_t));
+			item->window.rectEffects2.x = abs(rectTo->x - rectFrom->x) / amt;
+			item->window.rectEffects2.y = abs(rectTo->y - rectFrom->y) / amt;
+			item->window.rectEffects2.w = abs(rectTo->w - rectFrom->w) / amt;
+			item->window.rectEffects2.h = abs(rectTo->h - rectFrom->h) / amt;
+			Item_UpdatePosition(item);
+		}
+	}
+}
+
+/*
+=================
+Menu_TransitionItemByName
+=================
+*/
+//JLF MOVED
+#define _TRANS3
+#ifdef _TRANS3
+void Menu_Transition3ItemByName(menuDef_t *menu, const char *p, const float minx, const float miny, const float minz,
+								const float maxx, const float maxy, const float maxz, const float fovtx, const float fovty,
+								const int time, const float amt)
+{
+	itemDef_t *item;
+	int i;
+	int count = Menu_ItemsMatchingGroup(menu, p);
+	modelDef_t  * modelptr;
+	for (i = 0; i < count; i++) 
+	{
+		item = Menu_GetMatchingItemByNumber(menu, i, p);
+		if (item != NULL) 
+		{
+			if ( item->type == ITEM_TYPE_MODEL)
+			{
+				modelptr = (modelDef_t*)item->typeData;
+
+				item->window.flags |= (WINDOW_INTRANSITIONMODEL | WINDOW_VISIBLE);
+				item->window.offsetTime = time;
+				modelptr->fov_x2 = fovtx;
+				modelptr->fov_y2 = fovty;
+				VectorSet(modelptr->g2maxs2, maxx, maxy, maxz);
+				VectorSet(modelptr->g2mins2, minx, miny, minz);
+
+//				//modelptr->g2maxs2.x= maxx;
+//				modelptr->g2maxs2.y= maxy;
+//				modelptr->g2maxs2.z= maxz;
+//				modelptr->g2mins2.x= minx;
+//				modelptr->g2mins2.y= miny;
+//				modelptr->g2mins2.z= minz;
+
+//				VectorSet(modelptr->g2maxs2, maxx, maxy, maxz);
+
+				modelptr->g2maxsEffect[0] = abs(modelptr->g2maxs2[0] - modelptr->g2maxs[0]) / amt;
+				modelptr->g2maxsEffect[1] = abs(modelptr->g2maxs2[1] - modelptr->g2maxs[1]) / amt;
+				modelptr->g2maxsEffect[2] = abs(modelptr->g2maxs2[2] - modelptr->g2maxs[2]) / amt;
+
+				modelptr->g2minsEffect[0] = abs(modelptr->g2mins2[0] - modelptr->g2mins[0]) / amt;
+				modelptr->g2minsEffect[1] = abs(modelptr->g2mins2[1] - modelptr->g2mins[1]) / amt;
+				modelptr->g2minsEffect[2] = abs(modelptr->g2mins2[2] - modelptr->g2mins[2]) / amt;
+				
+
+				modelptr->fov_Effectx = abs(modelptr->fov_x2 - modelptr->fov_x) / amt;
+				modelptr->fov_Effecty = abs(modelptr->fov_y2 - modelptr->fov_y) / amt;
+			}
+				
+		}
+	}
+}
+
+#endif
+
+
+
+
+/*
+=================
+Menu_OrbitItemByName
+=================
+*/
+void Menu_OrbitItemByName(menuDef_t *menu, const char *p, float x, float y, float cx, float cy, int time) 
+{
+	itemDef_t *item;
+	int i;
+	int count = Menu_ItemsMatchingGroup(menu, p);
+	for (i = 0; i < count; i++) 
+	{
+		item = Menu_GetMatchingItemByNumber(menu, i, p);
+		if (item != NULL) 
+		{
+			item->window.flags |= (WINDOW_ORBITING | WINDOW_VISIBLE);
+			item->window.offsetTime = time;
+			item->window.rectEffects.x = cx;
+			item->window.rectEffects.y = cy;
+			item->window.rectClient.x = x;
+			item->window.rectClient.y = y;
+			Item_UpdatePosition(item);
+		}
+	}
+}
+
+/*
+=================
+Rect_Parse
+=================
+*/
+qboolean Rect_Parse(const char **p, rectDef_t *r) 
+{
+	if (!COM_ParseFloat(p, &r->x)) 
+	{
+		if (!COM_ParseFloat(p, &r->y)) 
+		{
+			if (!COM_ParseFloat(p, &r->w)) 
+			{
+				if (!COM_ParseFloat(p, &r->h)) 
+				{
+					return qtrue;
+				}
+			}
+		}
+	}
+	return qfalse;
+}
+
+qboolean Script_SetItemRect(itemDef_t *item, const char **args) 
+{
+	const char *itemname;
+	rectDef_t *out;
+	rectDef_t rect;
+
+	// expecting type of color to set and 4 args for the color
+	if (String_Parse(args, &itemname)) 
+	{
+		itemDef_t *item2;
+		int j;
+		int count = Menu_ItemsMatchingGroup((menuDef_t *) item->parent, itemname);
+
+		if (!Rect_Parse(args, &rect)) 
+		{
+			return qtrue;
+		}
+
+		for (j = 0; j < count; j++) 
+		{
+			item2 = Menu_GetMatchingItemByNumber((menuDef_t *) item->parent, j, itemname);
+			if (item2 != NULL) 
+			{
+				out = &item2->window.rect;
+
+				if (out) 
+				{
+					item2->window.rect.x = rect.x;
+					item2->window.rect.y = rect.y;
+					item2->window.rect.w = rect.w;
+					item2->window.rect.h = rect.h;					
+				}
+			}
+		}
+	}
+	return qtrue;
+}
+
+/*
+=================
+Script_SetItemBackground
+=================
+*/
+qboolean Script_SetItemBackground(itemDef_t *item, const char **args) 
+{
+	const char *itemName;
+	const char *name;
+
+	// expecting name of shader
+	if (String_Parse(args, &itemName) && String_Parse(args, &name)) 
+	{
+		Menu_SetItemBackground((menuDef_t *) item->parent, itemName, name);
+	}
+	return qtrue;
+}
+
+/*
+=================
+Script_SetItemText
+=================
+*/
+qboolean Script_SetItemText(itemDef_t *item, const char **args) 
+{
+	const char *itemName;
+	const char *text;
+
+	// expecting text
+	if (String_Parse(args, &itemName) && String_Parse(args, &text)) 
+	{
+		Menu_SetItemText((menuDef_t *) item->parent, itemName, text);
+	}
+	return qtrue;
+}
+
+/*
+=================
+Script_FadeIn
+=================
+*/
+qboolean Script_FadeIn(itemDef_t *item, const char **args) 
+{
+	const char *name;
+	if (String_Parse(args, &name)) 
+	{
+		Menu_FadeItemByName((menuDef_t *) item->parent, name, qfalse);
+	}
+
+	return qtrue;
+}
+
+/*
+=================
+Script_FadeOut
+=================
+*/
+qboolean Script_FadeOut(itemDef_t *item, const char **args) 
+{
+	const char *name;
+	if (String_Parse(args, &name)) 
+	{
+		Menu_FadeItemByName((menuDef_t *) item->parent, name, qtrue);
+	}
+
+	return qtrue;
+}
+
+/*
+=================
+Script_Show
+=================
+*/
+qboolean Script_Show(itemDef_t *item, const char **args) 
+{
+	const char *name;
+	if (String_Parse(args, &name)) 
+	{
+		Menu_ShowItemByName((menuDef_t *) item->parent, name, qtrue);
+	}
+
+	return qtrue;
+}
+
+
+
+/*
+=================
+Script_ShowMenu
+=================
+*/
+qboolean Script_ShowMenu(itemDef_t *item, const char **args) 
+{
+	const char *name;
+	if (String_Parse(args, &name)) 
+	{
+		Menus_ShowItems(name);
+	}
+
+	return qtrue;
+}
+
+
+/*
+=================
+Script_Hide
+=================
+*/
+qboolean Script_Hide(itemDef_t *item, const char **args) 
+{
+	const char *name;
+	if (String_Parse(args, &name)) 
+	{
+		Menu_ShowItemByName((menuDef_t *) item->parent, name, qfalse);
+	}
+
+	return qtrue;
+}
+
+/*
+=================
+Script_SetColor
+=================
+*/
+qboolean Script_SetColor(itemDef_t *item, const char **args) 
+{
+	const char *name;
+	int i;
+	float f;
+	vec4_t *out;
+
+	// expecting type of color to set and 4 args for the color
+	if (String_Parse(args, &name)) 
+	{
+		out = NULL;
+		if (Q_stricmp(name, "backcolor") == 0) 
+		{
+			out = &item->window.backColor;
+			item->window.flags |= WINDOW_BACKCOLORSET;
+		} 
+		else if (Q_stricmp(name, "forecolor") == 0) 
+		{
+			out = &item->window.foreColor;
+			item->window.flags |= WINDOW_FORECOLORSET;
+		} 
+		else if (Q_stricmp(name, "bordercolor") == 0) 
+		{
+			out = &item->window.borderColor;
+		}
+
+		if (out) 
+		{
+			for (i = 0; i < 4; i++) 
+			{
+//				if (!Float_Parse(args, &f)) 
+				if (COM_ParseFloat( args, &f))
+				{
+					return qtrue;
+				}
+				(*out)[i] = f;
+			}
+		}
+	}
+
+	return qtrue;
+}
+
+/*
+=================
+Script_Open
+=================
+*/
+qboolean Script_Open(itemDef_t *item, const char **args) 
+{
+	const char *name;
+	if (String_Parse(args, &name)) 
+	{
+		Menus_OpenByName(name);
+	}
+
+	return qtrue;
+}
+
+qboolean Script_OpenGoToMenu(itemDef_t *item, const char **args) 
+{
+	Menus_OpenByName(GoToMenu);				// Give warning
+	return qtrue;
+}
+
+
+/*
+=================
+Script_Close
+=================
+*/
+qboolean Script_Close(itemDef_t *item, const char **args) 
+{
+	const char *name;
+	if (String_Parse(args, &name)) 
+	{
+		if (Q_stricmp(name, "all") == 0)
+		{
+			Menus_CloseAll();
+		}
+		else
+		{
+			Menus_CloseByName(name);
+		}
+	}
+
+	return qtrue;
+}
+
+/*
+=================
+Script_Activate
+=================
+*/
+qboolean Script_Activate(itemDef_t *item, const char **args) 
+{
+	const char *name, *menu;
+
+	if (String_Parse(args, &menu)) 
+	{
+		if (String_Parse(args, &name)) 
+		{
+			Item_ActivateByName(menu,name);
+		}
+	}
+
+	return qtrue;
+}
+
+/*
+=================
+Script_SetBackground
+=================
+*/
+qboolean Script_SetBackground(itemDef_t *item, const char **args) 
+{
+	const char *name;
+	// expecting name to set asset to
+	if (String_Parse(args, &name)) 
+	{
+		item->window.background = DC->registerShaderNoMip(name);
+	}
+
+	return qtrue;
+}
+
+/*
+=================
+Script_SetAsset
+=================
+*/
+qboolean Script_SetAsset(itemDef_t *item, const char **args) 
+{
+	const char *name;
+	// expecting name to set asset to
+	if (String_Parse(args, &name)) 
+	{
+		// check for a model 
+		if (item->type == ITEM_TYPE_MODEL) 
+		{
+		}
+	}
+
+	return qtrue;
+}
+
+/*
+=================
+Script_SetFocus
+=================
+*/
+qboolean Script_SetFocus(itemDef_t *item, const char **args) 
+{
+	const char *name;
+	itemDef_t *focusItem;
+
+	if (String_Parse(args, &name)) 
+	{
+		focusItem = (itemDef_s *) Menu_FindItemByName((menuDef_t *) item->parent, name);
+		if (focusItem && !(focusItem->window.flags & WINDOW_DECORATION) && !(focusItem->window.flags & WINDOW_HASFOCUS)) 
+		{
+			Menu_ClearFocus((menuDef_t *) item->parent);
+//JLF
+#ifdef _XBOX
+			Item_SetFocus(focusItem, 0,0); 
+#else
+			focusItem->window.flags |= WINDOW_HASFOCUS;
+#endif
+//END JLF
+
+			if (focusItem->onFocus) 
+			{
+				Item_RunScript(focusItem, focusItem->onFocus);
+			}
+			if (DC->Assets.itemFocusSound) 
+			{
+				DC->startLocalSound( DC->Assets.itemFocusSound, CHAN_LOCAL_SOUND );
+			}
+#ifdef _IMMERSION
+			if (DC->Assets.itemFocusForce)
+			{
+				DC->startForce( DC->Assets.itemFocusForce );
+			}
+#endif // _IMMERSION
+		}
+	}
+
+	return qtrue;
+}
+
+
+/*
+=================
+Script_SetItemFlag
+=================
+*/
+qboolean Script_SetItemFlag(itemDef_t *item, const char **args) 
+{
+	const char		*itemName,*number;
+	
+	if (String_Parse(args, &itemName)) 
+	{
+		item = (itemDef_s *) Menu_FindItemByName((menuDef_t *) item->parent, itemName);
+
+		if (String_Parse(args, &number)) 
+		{
+			int amount = atoi(number);
+			item->window.flags |= amount;
+		}
+	}
+
+	return qtrue;
+}
+
+void UI_SetItemVisible(menuDef_t *menu,const char *itemname,qboolean visible)
+{
+	itemDef_t *item;
+	int j;
+	int count = Menu_ItemsMatchingGroup(menu, itemname);
+
+	for (j = 0; j < count; j++) 
+	{
+		item = Menu_GetMatchingItemByNumber(menu, j, itemname);
+		if (item != NULL) 
+		{
+			if (visible==qtrue)
+			{
+				item->window.flags |= WINDOW_VISIBLE;
+			}
+			else
+			{
+				item->window.flags &= ~WINDOW_VISIBLE;
+			}
+		}
+	}
+}
+
+void UI_SetItemColor(itemDef_t *item,const char *itemname,const char *name,vec4_t color)
+{
+	itemDef_t *item2;
+	int i,j;
+	vec4_t *out;
+	int count = Menu_ItemsMatchingGroup((menuDef_t *) item->parent, itemname);
+
+	for (j = 0; j < count; j++) 
+	{
+		item2 = Menu_GetMatchingItemByNumber((menuDef_t *) item->parent, j, itemname);
+		if (item2 != NULL) 
+		{
+			out = NULL;
+			if (Q_stricmp(name, "backcolor") == 0) 
+			{
+				out = &item2->window.backColor;
+			} 
+			else if (Q_stricmp(name, "forecolor") == 0) 
+			{
+				out = &item2->window.foreColor;
+				item2->window.flags |= WINDOW_FORECOLORSET;
+			} 
+			else if (Q_stricmp(name, "bordercolor") == 0) 
+			{
+				out = &item2->window.borderColor;
+			}
+
+			if (out) 
+			{
+				for (i = 0; i < 4; i++) 
+				{
+					(*out)[i] = color[i];
+				}
+			}
+		}
+	}
+}
+
+/*
+=================
+Script_SetItemColor
+=================
+*/
+qboolean Script_SetItemColor(itemDef_t *item, const char **args) 
+{
+	const char *itemname;
+	const char *name;
+	vec4_t color;
+
+	// expecting type of color to set and 4 args for the color
+	if (String_Parse(args, &itemname) && String_Parse(args, &name)) 
+	{
+		if (COM_ParseVec4(args, &color))
+		{
+			return qtrue;
+		}
+
+		UI_SetItemColor(item,itemname,name,color);
+
+	}
+
+	return qtrue;
+}
+
+/*
+=================
+Script_Defer
+
+Defers the rest of the script based on the defer condition.  The deferred
+portion of the script can later be run with the "rundeferred"
+=================
+*/
+qboolean Script_Defer ( itemDef_t* item, const char **args )
+{
+	// Should the script be deferred?
+	if ( DC->deferScript ( args ) )
+	{
+		// Need the item the script was being run on
+		uiInfo.deferredScriptItem = item;
+
+		// Save the rest of the script
+		Q_strncpyz ( uiInfo.deferredScript, *args, MAX_DEFERRED_SCRIPT, qfalse );
+
+		// No more running
+		return qfalse;
+	}
+
+	// Keep running the script, its ok
+	return qtrue;
+}
+
+/*
+=================
+Script_RunDeferred
+
+Runs the last deferred script, there can only be one script deferred at a 
+time so be careful of recursion
+=================
+*/
+qboolean Script_RunDeferred ( itemDef_t* item, const char **args )
+{
+	// Make sure there is something to run.
+	if ( !uiInfo.deferredScript[0] || !uiInfo.deferredScriptItem )
+	{
+		return qtrue;
+	}
+
+	// Run the deferred script now
+	Item_RunScript ( uiInfo.deferredScriptItem, uiInfo.deferredScript );
+
+	return qtrue;
+}
+
+/*
+=================
+Script_Delay
+
+Delays the rest of the script for the specified amount of time
+=================
+*/
+qboolean Script_Delay ( itemDef_t* item, const char **args )
+{
+	int time;
+
+	if (Int_Parse(args, &time))
+	{
+		item->window.flags |= WINDOW_SCRIPTWAITING;
+		item->window.delayTime = DC->realTime + time;	// Flag to set delay time on next paint
+		item->window.delayedScript = (char *)*args;	// Copy current location, we'll resume executing here later
+	}
+	else
+	{
+		Com_Printf(S_COLOR_YELLOW"WARNING: Script_Delay: error parsing\n" );
+	}
+
+	// Stop running
+	return qfalse;
+}
+
+/*
+=================
+Script_Transition
+
+transition		rtvscr		321 0 202 264  415 0 202 264  20 25
+=================
+*/
+qboolean Script_Transition(itemDef_t *item, const char **args) 
+{
+	const char *name;
+	rectDef_t rectFrom, rectTo;
+	int time;
+	float amt;
+
+	if (String_Parse(args, &name)) 
+	{
+		if ( ParseRect(args, &rectFrom) && ParseRect(args, &rectTo) && Int_Parse(args, &time) && !COM_ParseFloat(args, &amt)) 
+		{
+			Menu_TransitionItemByName((menuDef_t *) item->parent, name, &rectFrom, &rectTo, time, amt);
+		}
+		else
+		{
+			Com_Printf(S_COLOR_YELLOW"WARNING: Script_Transition: error parsing '%s'\n", name );
+		}
+	}
+
+	return qtrue;
+}
+
+
+/*
+=================
+Script_Transition2
+uses current origin instead of specifing a starting origin
+
+transition2		lfvscr		25 0 202 264  20 25
+=================
+*/
+qboolean Script_Transition2(itemDef_t *item, const char **args) 
+{
+	const char *name;
+	rectDef_t rectTo;
+	int time;
+	float amt;
+
+	if (String_Parse(args, &name)) 
+	{
+		if ( ParseRect(args, &rectTo) && Int_Parse(args, &time) && !COM_ParseFloat(args, &amt)) 
+		{
+			Menu_TransitionItemByName((menuDef_t *) item->parent, name, 0, &rectTo, time, amt);
+		}
+		else
+		{
+			Com_Printf(S_COLOR_YELLOW"WARNING: Script_Transition2: error parsing '%s'\n", name );
+		}
+	}
+
+	return qtrue;
+}
+
+#ifdef _TRANS3
+/*
+JLF MPMOVED
+=================
+Script_Transition3
+
+used exclusively with model views
+uses current origin instead of specifing a starting origin
+
+
+transition3		lfvscr		(min extent) (max extent) (fovx,y)  20 25
+=================
+*/
+qboolean Script_Transition3(itemDef_t *item, const char **args) 
+{
+	const char *name;
+	const char *value;
+	float minx, miny, minz, maxx, maxy, maxz, fovtx, fovty;
+	int time;
+	float amt;
+
+	if (String_Parse(args, &name)) 
+	{	
+		if (String_Parse( args, &value))
+		{
+			minx = atof(value);
+			if (String_Parse( args, &value))
+			{	
+				miny = atof(value);
+				if (String_Parse( args, &value))
+				{
+					minz = atof(value);
+					if (String_Parse( args, &value))
+					{	
+						maxx = atof(value);
+						if (String_Parse( args, &value))
+						{
+							maxy = atof(value);
+							if (String_Parse( args, &value))
+							{
+								maxz = atof(value);
+								if (String_Parse( args, &value))
+								{
+									fovtx = atof(value);
+									if (String_Parse( args, &value))
+									{	
+										fovty = atof(value);
+										
+										if (String_Parse( args, &value))
+										{	
+											time = atoi(value);
+											if (String_Parse( args, &value))
+											{	
+												amt = atof(value);
+												//set up the variables
+												Menu_Transition3ItemByName((menuDef_t *) item->parent, 
+														name,
+														minx, miny, minz,
+														maxx, maxy, maxz, 
+														fovtx, fovty,
+														time, amt);
+												
+												return qtrue;
+											}
+										}
+									}
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+	Com_Printf(S_COLOR_YELLOW"WARNING: Script_Transition2: error parsing '%s'\n", name );
+	return qtrue;
+}
+#endif
+
+
+//only works on some feeders
+int GetCurrentFeederIndex(itemDef_t * item)
+{
+	float feederID = item->special;
+	char * name;
+	int i, max;
+	
+	if (feederID == FEEDER_PLAYER_SPECIES) 
+	{
+		return uiInfo.playerSpeciesIndex;
+	} 
+	if (feederID == FEEDER_PLAYER_SKIN_HEAD) 
+	{
+		name = Cvar_VariableString("ui_char_skin_head");
+		max = uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].SkinHeadCount;
+		for ( i = 0; i < max ; i++)
+		{
+			if (!Q_stricmp(name, uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].SkinHeadNames[i]))
+			{
+				return i;
+			}
+
+		//	Cvar_Set("ui_char_skin_head", uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].SkinHeadNames[index]);
+		}
+		return -1;
+	} 
+	else if (feederID == FEEDER_PLAYER_SKIN_TORSO) 
+	{
+		name = Cvar_VariableString("ui_char_skin_torso");
+		max = uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].SkinTorsoCount;
+		for ( i = 0; i < max ; i++)
+		{
+			if (!Q_stricmp(name, uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].SkinTorsoNames[i]))
+			{
+				return i;
+			}
+		//	Cvar_Set("ui_char_skin_head", uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].SkinHeadNames[index]);
+		}
+		return -1;
+		
+	} 
+	else if (feederID == FEEDER_PLAYER_SKIN_LEGS) 
+	{
+		name = Cvar_VariableString("ui_char_skin_legs");
+		max = uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].SkinLegCount;
+		for ( i = 0; i < max ; i++)
+		{
+			if (!Q_stricmp(name, uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].SkinLegNames[i]))
+			{
+				return i;
+			}
+		//	Cvar_Set("ui_char_skin_head", uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].SkinHeadNames[index]);
+		}
+		return -1;
+
+
+	//	if (index >= 0 && index < uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].SkinLegCount)
+	//	{
+	//		Cvar_Set("ui_char_skin_legs", uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].SkinLegNames[index]);
+	//	}
+	} 
+
+	
+	else if (feederID == FEEDER_COLORCHOICES)
+	{
+		extern void	Item_RunScript(itemDef_t *item, const char *s);		//from ui_shared;
+		int currR, currG, currB, newR, newG, newB;
+		currR = Cvar_VariableIntegerValue( "ui_char_color_red");
+		currG = Cvar_VariableIntegerValue( "ui_char_color_green");
+		currB = Cvar_VariableIntegerValue( "ui_char_color_blue");
+		
+		max = uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].ColorCount;
+		for ( i = 0; i < max ; i++)
+		{
+			Item_RunScript(item, uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].ColorActionText[i]);
+			newR = Cvar_VariableIntegerValue( "ui_char_color_red");
+			newG = Cvar_VariableIntegerValue( "ui_char_color_green");
+			newB = Cvar_VariableIntegerValue( "ui_char_color_blue");
+			if ( currR == newR && currG == newG && currB == newB)
+				return i;
+		}
+		return -1;
+
+		
+
+//JLF junk copied code
+		/*
+extern void	Item_RunScript(itemDef_t *item, const char *s);		//from ui_shared;
+		name = Cvar_VariableString("ui_char_skin_legs");
+		max = uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].ColorCount;
+		for ( i = 0; i < max ; i++)
+		if (!qstrcmp(name, uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].SkinLegNames[i]))
+		{
+			return i;
+		//	Cvar_Set("ui_char_skin_head", uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].SkinHeadNames[index]);
+		}
+		return -1;
+
+
+
+		if (index >= 0 && index < uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].ColorCount)
+		{
+			Item_RunScript(item, uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].ColorActionText[index]);
+		}
+	*/
+	}
+	return -1;
+
+}
+
+
+
+
+
+
+
+
+
+qboolean Script_IncrementFeeder(itemDef_t * item, const char ** args)
+{
+	
+	int feedercount = uiInfo.uiDC.feederCount(item->special);
+	int value = GetCurrentFeederIndex(item);
+	value++;
+	if ( value >= feedercount)
+		value = 0;
+	DC->feederSelection(item->special, value, item);
+	return qtrue;
+}
+
+qboolean Script_DecrementFeeder(itemDef_t * item, const char ** args)
+{
+	
+	int feedercount = uiInfo.uiDC.feederCount(item->special);
+	int value = GetCurrentFeederIndex(item);
+	value--;
+	if ( value < 0)
+		value = feedercount-1;
+	DC->feederSelection(item->special, value, item);
+	return qtrue;
+}  
+
+
+/*
+=================
+Script_SetCvar
+=================
+*/
+qboolean Script_SetCvar(itemDef_t *item, const char **args) 
+{
+	const char *cvar, *val;
+	if (String_Parse(args, &cvar) && String_Parse(args, &val)) 
+	{
+		DC->setCVar(cvar, val);
+	}
+
+	return qtrue;
+}
+
+/*
+=================
+Script_Exec
+=================
+*/
+qboolean Script_Exec ( itemDef_t *item, const char **args) 
+{
+	const char *val;
+	if (String_Parse(args, &val)) 
+	{
+		DC->executeText(EXEC_APPEND, va("%s ; ", val));
+	}
+
+	return qtrue;
+}
+
+/*
+=================
+Script_Play
+=================
+*/
+static qboolean Script_Play(itemDef_t *item, const char **args) 
+{
+	const char *val;
+	if (String_Parse(args, &val)) 
+	{
+		DC->startLocalSound(DC->registerSound(val, qfalse), CHAN_AUTO );
+	}
+
+	return qtrue;
+}
+
+/*
+=================
+Script_PlayVoice
+=================
+*/
+static qboolean Script_PlayVoice(itemDef_t *item, const char **args) 
+{
+	const char *val;
+	if (String_Parse(args, &val)) 
+	{
+		DC->startLocalSound(DC->registerSound(val, qfalse), CHAN_VOICE );
+	}
+
+	return qtrue;
+}
+
+/*
+=================
+Script_StopVoice
+=================
+*/
+static qboolean Script_StopVoice(itemDef_t *item, const char **args) 
+{
+	DC->startLocalSound(uiInfo.uiDC.Assets.nullSound, CHAN_VOICE );
+
+	return qtrue;
+}
+
+/*
+=================
+Script_playLooped
+=================
+*/
+/*
+qboolean Script_playLooped(itemDef_t *item, const char **args) 
+{
+	const char *val;
+	if (String_Parse(args, &val)) 
+	{
+		// FIXME BOB - is this needed?
+		DC->stopBackgroundTrack();
+		DC->startBackgroundTrack(val, val);
+	}
+
+	return qtrue;
+}
+*/
+#ifdef _IMMERSION
+/*
+=================
+Script_FFPlay
+=================
+*/
+qboolean Script_FFPlay(itemDef_t *item, const char **args) 
+{
+	const char *val;
+	if (String_Parse(args, &val)) 
+	{
+		DC->startForce(DC->registerForce(val));
+	}
+	return qtrue;
+}
+#endif // _IMMERSION
+/*
+=================
+Script_Orbit
+=================
+*/
+qboolean Script_Orbit(itemDef_t *item, const char **args) 
+{
+	const char *name;
+	float cx, cy, x, y;
+	int time;
+
+	if (String_Parse(args, &name)) 
+	{
+//		if ( Float_Parse(args, &x) && Float_Parse(args, &y) && Float_Parse(args, &cx) && Float_Parse(args, &cy) && Int_Parse(args, &time) ) 
+		if ( !COM_ParseFloat(args, &x) && !COM_ParseFloat(args, &y) && !COM_ParseFloat(args, &cx) && !COM_ParseFloat(args, &cy) && Int_Parse(args, &time) ) 
+		{
+			Menu_OrbitItemByName((menuDef_t *) item->parent, name, x, y, cx, cy, time);
+		}
+	}
+
+	return qtrue;
+}
+
+
+commandDef_t commandList[] =
+{	
+  {"activate",		&Script_Activate},				// menu
+  {"close",			&Script_Close},					// menu
+  {"exec",			&Script_Exec},					// group/name
+  {"fadein",		&Script_FadeIn},				// group/name
+  {"fadeout",		&Script_FadeOut},				// group/name
+  {"hide",			&Script_Hide},					// group/name
+  {"open",			&Script_Open},					// menu
+  {"openGoToMenu",	&Script_OpenGoToMenu},			// 
+  {"orbit",			&Script_Orbit},					// group/name
+  {"play",			&Script_Play},					// group/name
+  {"playVoice",		&Script_PlayVoice},					// group/name
+  {"stopVoice",		&Script_StopVoice},					// group/name
+//  {"playlooped",	&Script_playLooped},			// group/name
+#ifdef _IMMERSION
+  {"ffplay",		&Script_FFPlay},
+#endif // _IMMERSION
+  {"setasset",		&Script_SetAsset},				// works on this
+  {"setbackground", &Script_SetBackground},			// works on this
+  {"setcolor",		&Script_SetColor},				// works on this
+  {"setcvar",		&Script_SetCvar},				// group/name
+  {"setfocus",		&Script_SetFocus},				// sets this background color to team color
+  {"setitemcolor",	&Script_SetItemColor},			// group/name
+  {"setitemflag",	&Script_SetItemFlag},			// name
+  {"show",			&Script_Show},					// group/name
+  {"showMenu",		&Script_ShowMenu},				// menu
+  {"transition",	&Script_Transition},			// group/name
+  {"transition2",	&Script_Transition2},			// group/name
+  {"setitembackground", &Script_SetItemBackground},	// group/name
+  {"setitemtext",	&Script_SetItemText},			// group/name
+  {"setitemrect",	&Script_SetItemRect},			// group/name
+  {"defer",			&Script_Defer},					// 
+  {"rundeferred",	&Script_RunDeferred},			//
+  {"delay",			&Script_Delay},					// works on this (script)
+  {"transition3",   &Script_Transition3},			// model exclusive transition
+  {"incrementfeeder", &Script_IncrementFeeder},
+  {"decrementfeeder", &Script_DecrementFeeder}
+};
+
+int scriptCommandCount = sizeof(commandList) / sizeof(commandDef_t);
+
+
+/*
+===============
+Item_Init 
+===============
+*/
+void Item_Init(itemDef_t *item) 
+{
+	memset(item, 0, sizeof(itemDef_t));
+	item->textscale = 0.55f;
+	Window_Init(&item->window);
+}
+
+/*
+===============
+Item_Multi_Setting 
+===============
+*/
+const char *Item_Multi_Setting(itemDef_t *item) 
+{
+	char buff[1024];
+	float value = 0;
+	int i;
+	multiDef_t *multiPtr = (multiDef_t*)item->typeData;
+	if (multiPtr) 
+	{
+		if (multiPtr->strDef) 
+		{
+			if (item->cvar)
+			{
+			    DC->getCVarString(item->cvar, buff, sizeof(buff));
+			}
+			else
+			{
+
+			}
+		} 
+		else 
+		{
+			if (item->cvar)	// Was a cvar given?
+			{
+				value = DC->getCVarValue(item->cvar);
+			}
+			else
+			{
+				value = item->value;
+			}
+		}
+
+		for (i = 0; i < multiPtr->count; i++) 
+		{
+			if (multiPtr->strDef) 
+			{
+				if (Q_stricmp(buff, multiPtr->cvarStr[i]) == 0) 
+				{
+					return multiPtr->cvarList[i];
+				}
+			} 
+			else 
+			{
+ 				if (multiPtr->cvarValue[i] == value) 
+				{
+					return multiPtr->cvarList[i];
+ 				}
+ 			}
+ 		}
+	}
+
+	return "";
+}
+
+//---------------------------------------------------------------------------------------------------------
+//		Item Keyword Parse functions
+//---------------------------------------------------------------------------------------------------------
+
+/*
+===============
+ItemParse_name 
+	name <string>
+===============
+*/
+qboolean ItemParse_name( itemDef_t *item) 
+{
+	if (!PC_ParseStringMem((const char **)&item->window.name)) 
+	{
+		return qfalse;
+	}
+
+	return qtrue;
+}
+
+
+
+qboolean ItemParse_font( itemDef_t *item ) 
+{
+	if (PC_ParseInt(&item->font)) 
+	{
+		return qfalse;
+	}
+	return qtrue;
+}
+
+
+/*
+===============
+ItemParse_focusSound 
+	name <string>
+===============
+*/
+qboolean ItemParse_focusSound( itemDef_t *item) 
+{
+	const char *temp;
+
+	if (PC_ParseString(&temp)) 
+	{
+		return qfalse;
+	}
+	item->focusSound = DC->registerSound(temp, qfalse);
+	return qtrue;
+}
+
+
+
+#ifdef _IMMERSION
+/*
+===============
+ItemParse_focusForce
+	name <string>
+===============
+*/
+qboolean ItemParse_focusForce( itemDef_t *item) 
+{
+	const char *temp;
+
+	if (PC_ParseString(&temp)) 
+	{
+//#ifdef _DEBUG
+//extern void UI_Debug_EnterReference(LPCSTR ps4LetterType, LPCSTR psItemString);
+//#endif
+		return qfalse;
+	}
+	item->focusForce = DC->registerForce(temp);
+	return qtrue;
+}
+#endif // _IMMERSION
+
+/*
+===============
+ItemParse_text 
+	text <string>
+===============
+*/
+qboolean ItemParse_text( itemDef_t *item) 
+{	
+	if (!PC_ParseStringMem((const char **) &item->text))
+	{
+		return qfalse;
+	}
+
+//#ifdef _DEBUG
+//	UI_Debug_EnterReference("TEXT", item->text);
+//#endif
+
+	return qtrue;
+}
+
+/*
+===============
+ItemParse_descText 
+	text <string>
+===============
+*/
+qboolean ItemParse_descText( itemDef_t *item) 
+{
+	if (!PC_ParseStringMem((const char **) &item->descText))
+	{
+		return qfalse;
+	}
+
+//#ifdef _DEBUG
+//	UI_Debug_EnterReference("DESC", item->descText);
+//#endif
+
+	return qtrue;
+}
+
+/*
+===============
+ItemParse_text 
+	text <string>
+===============
+*/
+qboolean ItemParse_text2( itemDef_t *item) 
+{
+	if (!PC_ParseStringMem((const char **) &item->text2))
+	{
+		return qfalse;
+	}
+
+//#ifdef _DEBUG
+//	UI_Debug_EnterReference("TXT2", item->text2);
+//#endif
+
+	return qtrue;
+}
+
+/*
+===============
+ItemParse_group 
+	group <string>
+===============
+*/
+qboolean ItemParse_group( itemDef_t *item) 
+{
+	if (!PC_ParseStringMem((const char **)&item->window.group))
+	{
+		return qfalse;
+	}
+
+	return qtrue;
+}
+
+/*
+===============
+ItemParse_asset_model 
+	asset_model <string>
+===============
+*/
+qboolean ItemParse_asset_model_go( itemDef_t *item, const char *name ) 
+{
+	modelDef_t *modelPtr;
+	Item_ValidateTypeData(item);
+	modelPtr = (modelDef_t*)item->typeData;
+
+	if (!Q_stricmp(&name[strlen(name) - 4], ".glm"))
+	{ //it's a ghoul2 model then
+		if ( item->ghoul2.size() && item->ghoul2[0].mModelindex >= 0)
+		{
+			DC->g2_RemoveGhoul2Model( item->ghoul2, 0 );
+			item->flags &= ~ITF_G2VALID;
+		}
+		int g2Model = DC->g2_InitGhoul2Model(item->ghoul2, name, 0, 0, 0, 0, 0);
+		if (g2Model >= 0)
+		{
+			item->flags |= ITF_G2VALID;
+
+			if (modelPtr->g2anim)
+			{ //does the menu request this model be playing an animation?
+				DC->g2hilev_SetAnim(&item->ghoul2[0], "model_root", modelPtr->g2anim, qfalse);
+			}
+			if ( modelPtr->g2skin )
+			{
+				DC->g2_SetSkin( &item->ghoul2[0], 0, modelPtr->g2skin );//this is going to set the surfs on/off matching the skin file
+			}
+		}
+	}
+	else if(!(item->asset)) 
+	{ //guess it's just an md3
+		item->asset = DC->registerModel(name);
+		item->flags &= ~ITF_G2VALID;
+	}
+	return qtrue;
+}
+
+qboolean ItemParse_asset_model( itemDef_t *item ) 
+{
+	const char *temp;
+	modelDef_t *modelPtr;
+	Item_ValidateTypeData(item);
+	modelPtr = (modelDef_t*)item->typeData;
+
+	if (PC_ParseString(&temp)) 
+	{
+		return qfalse;
+	}
+	char modelPath[MAX_QPATH];
+	
+	if (!stricmp(temp,"ui_char_model") )
+	{
+		Com_sprintf( modelPath, sizeof( modelPath ), "models/players/%s/model.glm", Cvar_VariableString ( "g_char_model" ) );
+	}
+	else
+	{
+		Com_sprintf( modelPath, sizeof( modelPath ), temp); 
+	}
+	return (ItemParse_asset_model_go( item, modelPath ));
+}
+
+/*
+===============
+ItemParse_asset_model 
+	asset_shader <string>
+===============
+*/
+qboolean ItemParse_asset_shader( itemDef_t *item) 
+{
+	const char *temp;
+
+	if (PC_ParseString(&temp)) 
+	{
+		return qfalse;
+	}
+	item->asset = DC->registerShaderNoMip(temp);
+	return qtrue;
+}
+
+/*
+===============
+ItemParse_asset_model 
+	model_origin <number> <number> <number>
+===============
+*/
+qboolean ItemParse_model_origin( itemDef_t *item) 
+{
+	modelDef_t *modelPtr;
+	Item_ValidateTypeData(item);
+	modelPtr = (modelDef_t*)item->typeData;
+
+	if (PC_ParseFloat(&modelPtr->origin[0])) 
+	{
+		if (PC_ParseFloat(&modelPtr->origin[1])) 
+		{
+			if (PC_ParseFloat(&modelPtr->origin[2])) 
+			{
+				return qtrue;
+			}
+		}
+	}
+	return qfalse;
+}
+
+/*
+===============
+ItemParse_model_fovx 
+	model_fovx <number>
+===============
+*/
+qboolean ItemParse_model_fovx( itemDef_t *item) 
+{
+	modelDef_t *modelPtr;
+	Item_ValidateTypeData(item);
+	modelPtr = (modelDef_t*)item->typeData;
+
+	if (PC_ParseFloat(&modelPtr->fov_x)) 
+	{
+		return qfalse;
+	}
+	return qtrue;
+}
+
+/*
+===============
+ItemParse_model_fovy 
+	model_fovy <number>
+===============
+*/
+qboolean ItemParse_model_fovy( itemDef_t *item) 
+{
+	modelDef_t *modelPtr;
+	Item_ValidateTypeData(item);
+	modelPtr = (modelDef_t*)item->typeData;
+
+	if (PC_ParseFloat(&modelPtr->fov_y)) 
+	{
+		return qfalse;
+	}
+	return qtrue;
+}
+
+/*
+===============
+ItemParse_model_rotation 
+	model_rotation <integer>
+===============
+*/
+qboolean ItemParse_model_rotation( itemDef_t *item) 
+{
+	modelDef_t *modelPtr;
+	Item_ValidateTypeData(item);
+	modelPtr = (modelDef_t*)item->typeData;
+
+	if (PC_ParseInt(&modelPtr->rotationSpeed)) 
+	{
+		return qfalse;
+	}
+	return qtrue;
+}
+
+/*
+===============
+ItemParse_model_angle 
+	model_angle <integer>
+===============
+*/
+qboolean ItemParse_model_angle( itemDef_t *item) 
+{
+	modelDef_t *modelPtr;
+	Item_ValidateTypeData(item);
+	modelPtr = (modelDef_t*)item->typeData;
+
+	if (PC_ParseInt(&modelPtr->angle)) 
+	{
+		return qfalse;
+	}
+	return qtrue;
+}
+
+// model_g2mins <number> <number> <number>
+qboolean ItemParse_model_g2mins( itemDef_t *item ) {
+	modelDef_t *modelPtr;
+	Item_ValidateTypeData(item);
+	modelPtr = (modelDef_t*)item->typeData;
+
+	if (!PC_ParseFloat(&modelPtr->g2mins[0])) {
+		if (!PC_ParseFloat(&modelPtr->g2mins[1])) {
+			if (!PC_ParseFloat(&modelPtr->g2mins[2])) {
+				return qtrue;
+			}
+		}
+	}
+	return qfalse;
+}
+
+// model_g2maxs <number> <number> <number>
+qboolean ItemParse_model_g2maxs( itemDef_t *item ) {
+	modelDef_t *modelPtr;
+	Item_ValidateTypeData(item);
+	modelPtr = (modelDef_t*)item->typeData;
+
+	if (!PC_ParseFloat(&modelPtr->g2maxs[0])) {
+		if (!PC_ParseFloat(&modelPtr->g2maxs[1])) {
+			if (!PC_ParseFloat(&modelPtr->g2maxs[2])) {
+				return qtrue;
+			}
+		}
+	}
+	return qfalse;
+}
+
+// model_g2skin <string>
+qboolean ItemParse_model_g2skin_go( itemDef_t *item, const char *skinName ) 
+{
+	modelDef_t *modelPtr;
+
+	Item_ValidateTypeData(item);
+	modelPtr = (modelDef_t*)item->typeData;
+
+	if (!skinName || !skinName[0])
+	{ //it was parsed cor~rectly so still return true.
+		modelPtr->g2skin = 0;
+		DC->g2_SetSkin( &item->ghoul2[0], -1, 0 );//turn off custom skin
+		return qtrue;
+	}
+
+	modelPtr->g2skin = DC->registerSkin(skinName);
+	if ( item->ghoul2.IsValid() )
+	{
+		DC->g2_SetSkin( &item->ghoul2[0], 0, modelPtr->g2skin );//this is going to set the surfs on/off matching the skin file
+	}
+
+	return qtrue;
+}
+
+qboolean ItemParse_model_g2skin( itemDef_t *item ) 
+{
+	const char *skinName;
+
+	if (PC_ParseString(&skinName)) {
+		return qfalse;
+	}
+
+	return (ItemParse_model_g2skin_go( item, skinName ));
+}
+
+// model_g2anim <number>
+qboolean ItemParse_model_g2anim_go( itemDef_t *item, const char *animName ) 
+{
+	modelDef_t *modelPtr;
+	int i = 0;
+
+	Item_ValidateTypeData(item);
+	modelPtr = (modelDef_t*)item->typeData;
+
+	if (!animName || !animName[0])
+	{ //it was parsed correctly so still return true.
+		return qtrue;
+	}
+
+	while (i < MAX_ANIMATIONS)
+	{
+		if (!Q_stricmp(animName, animTable[i].name))
+		{ //found it
+			modelPtr->g2anim = animTable[i].id;
+			return qtrue;
+		}
+		i++;
+	}
+
+	Com_Printf("Could not find '%s' in the anim table\n", animName);
+	return qtrue;
+}
+
+qboolean ItemParse_model_g2anim( itemDef_t *item ) {
+	const char *animName;
+
+	if (PC_ParseString(&animName)) {
+		return qfalse;
+	}
+
+	return ItemParse_model_g2anim_go( item, animName );
+}
+
+/*
+===============
+ItemParse_rect 
+	rect <rectangle>
+===============
+*/
+qboolean ItemParse_rect( itemDef_t *item) 
+{
+	if (!PC_ParseRect(&item->window.rectClient)) 
+	{
+		return qfalse;
+	}
+
+	return qtrue;
+}
+
+/*
+===============
+ItemParse_flag
+	flag <integer>
+===============
+*/
+qboolean ItemParse_flag( itemDef_t *item) 
+{
+	int		i;
+	const char	*tempStr;
+
+	if (PC_ParseString(&tempStr)) 
+	{
+		return qfalse;
+	}
+
+	i=0;
+	while (itemFlags[i].string)
+	{
+		if (Q_stricmp(tempStr,itemFlags[i].string)==0)
+		{
+			item->window.flags |= itemFlags[i].value;
+			break;
+		}
+		i++;
+	}
+
+	if (itemFlags[i].string == NULL)
+	{
+		PC_ParseWarning(va("Unknown item flag value '%s'",tempStr));	
+	}
+
+	return qtrue;
+}
+
+
+/*
+===============
+ItemParse_style 
+	style <integer>
+===============
+*/
+qboolean ItemParse_style( itemDef_t *item) 
+{
+	int		i;
+	const char	*tempStr;
+
+	if (PC_ParseString(&tempStr)) 
+	{
+		return qfalse;
+	}
+
+	i=0;
+	while (styles[i])
+	{
+		if (Q_stricmp(tempStr,styles[i])==0)
+		{
+			item->window.style = i;
+			break;
+		}
+		i++;
+	}
+
+	if (styles[i] == NULL)
+	{
+		PC_ParseWarning(va("Unknown item style value '%s'",tempStr));	
+	}
+
+	return qtrue;
+}
+
+/*
+===============
+ItemParse_decoration 
+	decoration
+===============
+*/
+qboolean ItemParse_decoration( itemDef_t *item ) 
+{
+	item->window.flags |= WINDOW_DECORATION;
+	return qtrue;
+}
+
+/*
+===============
+ItemParse_notselectable 
+	notselectable
+===============
+*/
+qboolean ItemParse_notselectable( itemDef_t *item ) 
+{
+	listBoxDef_t *listPtr;
+	Item_ValidateTypeData(item);
+	listPtr = (listBoxDef_t*)item->typeData;
+
+	if (item->type == ITEM_TYPE_LISTBOX && listPtr) 
+	{
+		listPtr->notselectable = qtrue;
+	}
+	return qtrue;
+}
+
+/*
+===============
+ItemParse_scrollhidden
+	scrollhidden
+===============
+*/
+qboolean ItemParse_scrollhidden( itemDef_t *item ) 
+{
+	listBoxDef_t *listPtr;
+	Item_ValidateTypeData(item);
+	listPtr = (listBoxDef_t*)item->typeData;
+
+	if (item->type == ITEM_TYPE_LISTBOX && listPtr) 
+	{
+		listPtr->scrollhidden = qtrue;
+	}
+	return qtrue;
+}
+
+
+/*
+===============
+ItemParse_wrapped 
+	manually wrapped
+===============
+*/
+qboolean ItemParse_wrapped( itemDef_t *item ) 
+{
+	item->window.flags |= WINDOW_WRAPPED;
+	return qtrue;
+}
+
+
+/*
+===============
+ItemParse_autowrapped 
+	auto wrapped
+===============
+*/
+qboolean ItemParse_autowrapped( itemDef_t *item) 
+{
+	item->window.flags |= WINDOW_AUTOWRAPPED;
+	return qtrue;
+}
+
+
+/*
+===============
+ItemParse_horizontalscroll 
+	horizontalscroll
+===============
+*/
+qboolean ItemParse_horizontalscroll( itemDef_t *item ) 
+{
+	item->window.flags |= WINDOW_HORIZONTAL;
+	return qtrue;
+}
+
+ 
+/*
+===============
+ItemParse_type 
+	type <integer>
+===============
+*/
+qboolean ItemParse_type( itemDef_t *item ) 
+{
+	int		i;
+	const char	*tempStr;
+
+	if (PC_ParseString(&tempStr)) 
+	{
+		return qfalse;
+	}
+
+	i=0;
+	while (types[i])
+	{
+		if (Q_stricmp(tempStr,types[i])==0)
+		{
+			item->type = i;
+			break;
+		}
+		i++;
+	}
+
+	if (types[i] == NULL)
+	{
+		PC_ParseWarning(va("Unknown item type value '%s'",tempStr));	
+	}
+	else
+	{
+		Item_ValidateTypeData(item);
+	}
+	return qtrue;
+}
+
+/*
+===============
+ItemParse_elementwidth
+	 elementwidth, used for listbox image elements
+	 uses textalignx for storage
+===============
+*/
+qboolean ItemParse_elementwidth( itemDef_t *item ) 
+{
+	listBoxDef_t *listPtr;
+
+	Item_ValidateTypeData(item);
+	listPtr = (listBoxDef_t*)item->typeData;
+	if (PC_ParseFloat(&listPtr->elementWidth)) 
+	{
+		return qfalse;
+	}
+	return qtrue;
+
+}
+
+/*
+===============
+ItemParse_elementheight 
+	elementheight, used for listbox image elements
+	uses textaligny for storage
+===============
+*/
+qboolean ItemParse_elementheight( itemDef_t *item ) 
+{
+	listBoxDef_t *listPtr;
+
+	Item_ValidateTypeData(item);
+	listPtr = (listBoxDef_t*)item->typeData;
+	if (PC_ParseFloat(&listPtr->elementHeight)) 
+	{
+		return qfalse;
+	}
+	return qtrue;
+}
+
+/*
+===============
+ItemParse_feeder 
+	feeder <float>
+===============
+*/
+qboolean ItemParse_feeder( itemDef_t *item ) 
+{
+	if (PC_ParseFloat( &item->special)) 
+	{
+		return qfalse;
+	}
+	return qtrue;
+}
+
+/*
+===============
+ItemParse_elementtype 
+	elementtype, used to specify what type of elements a listbox contains
+	uses textstyle for storage
+===============
+*/
+qboolean ItemParse_elementtype( itemDef_t *item ) 
+{
+	listBoxDef_t *listPtr;
+
+	Item_ValidateTypeData(item);
+	if (!item->typeData)
+	{
+		return qfalse;
+	}
+
+	listPtr = (listBoxDef_t*)item->typeData;
+	if (PC_ParseInt(&listPtr->elementStyle)) 
+	{
+		return qfalse;
+	}
+	return qtrue;
+}
+
+/*
+===============
+ItemParse_columns 
+	columns sets a number of columns and an x pos and width per.. 
+===============
+*/
+qboolean ItemParse_columns( itemDef_t *item) 
+{
+	int num, i;
+	listBoxDef_t *listPtr;
+
+	Item_ValidateTypeData(item);
+	if (!item->typeData)
+	{
+		return qfalse;
+	}
+
+	listPtr = (listBoxDef_t*)item->typeData;
+	if (!PC_ParseInt(&num)) 
+	{
+		if (num > MAX_LB_COLUMNS) 
+		{
+			num = MAX_LB_COLUMNS;
+		}
+		listPtr->numColumns = num;
+		for (i = 0; i < num; i++) 
+		{
+			int pos, width, maxChars;
+
+			if (!PC_ParseInt(&pos) && !PC_ParseInt(&width) && !PC_ParseInt(&maxChars)) 
+			{
+				listPtr->columnInfo[i].pos = pos;
+				listPtr->columnInfo[i].width = width;
+				listPtr->columnInfo[i].maxChars = maxChars;
+			} 
+			else 
+			{
+				return qfalse;
+			}
+		}
+	} 
+	else 
+	{
+		return qfalse;
+	}
+
+	return qtrue;
+}
+
+/*
+===============
+ItemParse_border 
+===============
+*/
+qboolean ItemParse_border( itemDef_t *item) 
+{
+	if (PC_ParseInt(&item->window.border)) 
+	{
+		return qfalse;
+	}
+
+	return qtrue;
+}
+
+/*
+===============
+ItemParse_bordersize 
+===============
+*/
+qboolean ItemParse_bordersize( itemDef_t *item ) 
+{
+	if (PC_ParseFloat(&item->window.borderSize)) 
+	{
+		return qfalse;
+	}
+	return qtrue;
+}
+
+/*
+===============
+ItemParse_visible 
+===============
+*/
+qboolean ItemParse_visible( itemDef_t *item) 
+{
+	int i;
+
+	if (PC_ParseInt(&i)) 
+	{
+		return qfalse;
+	}
+	if (i) 
+	{
+		item->window.flags |= WINDOW_VISIBLE;
+	}
+	return qtrue;
+}
+
+/*
+===============
+ItemParse_ownerdraw 
+===============
+*/
+qboolean ItemParse_ownerdraw( itemDef_t *item) 
+{
+	if (PC_ParseInt(&item->window.ownerDraw)) 
+	{
+		return qfalse;
+	}
+	item->type = ITEM_TYPE_OWNERDRAW;
+	return qtrue;
+}
+
+/*
+===============
+ItemParse_align 
+===============
+*/
+qboolean ItemParse_align( itemDef_t *item) 
+{
+	if (PC_ParseInt(&item->alignment)) 
+	{
+		return qfalse;
+	}
+	return qtrue;
+}
+
+/*
+===============
+ItemParse_align 
+===============
+*/
+qboolean ItemParse_Appearance_slot( itemDef_t *item) 
+{
+	if (PC_ParseInt(&item->appearanceSlot)) 
+	{
+		return qfalse;
+	}
+	return qtrue;
+}
+
+
+/*
+===============
+ItemParse_textalign 
+===============
+*/
+qboolean ItemParse_textalign( itemDef_t *item ) 
+{
+	const char *tempStr;
+	int	i;
+
+	if (PC_ParseString(&tempStr)) 
+	{
+		return qfalse;
+	}
+
+	i=0;
+	while (alignment[i])
+	{
+		if (Q_stricmp(tempStr,alignment[i])==0)
+		{
+			item->textalignment = i;
+			break;
+		}
+		i++;
+	}
+
+	if (alignment[i] == NULL)
+	{
+		PC_ParseWarning(va("Unknown text alignment value '%s'",tempStr));	
+	}
+
+	return qtrue;
+
+}
+
+/*
+===============
+ItemParse_text2alignx 
+===============
+*/
+qboolean ItemParse_text2alignx( itemDef_t *item) 
+{
+	if (PC_ParseFloat(&item->text2alignx)) 
+	{
+		return qfalse;
+	}
+	return qtrue;
+}
+
+/*
+===============
+ItemParse_text2aligny 
+===============
+*/
+qboolean ItemParse_text2aligny( itemDef_t *item) 
+{
+	if (PC_ParseFloat(&item->text2aligny)) 
+	{
+		return qfalse;
+	}
+	return qtrue;
+}
+
+/*
+===============
+ItemParse_textalignx 
+===============
+*/
+qboolean ItemParse_textalignx( itemDef_t *item) 
+{
+	if (PC_ParseFloat(&item->textalignx)) 
+	{
+		return qfalse;
+	}
+	return qtrue;
+}
+
+/*
+===============
+ItemParse_textaligny 
+===============
+*/
+qboolean ItemParse_textaligny( itemDef_t *item) 
+{
+	if (PC_ParseFloat(&item->textaligny)) 
+	{
+		return qfalse;
+	}
+	return qtrue;
+}
+
+/*
+===============
+ItemParse_textscale 
+===============
+*/
+qboolean ItemParse_textscale( itemDef_t *item ) 
+{
+	if (PC_ParseFloat(&item->textscale)) 
+	{
+		return qfalse;
+	}
+	return qtrue;
+}
+
+/*
+===============
+ItemParse_textstyle 
+===============
+*/
+qboolean ItemParse_textstyle( itemDef_t *item) 
+{
+	if (PC_ParseInt(&item->textStyle)) 
+	{
+		return qfalse;
+	}
+	return qtrue;
+}
+
+
+/*
+===============
+ItemParse_invertyesno
+===============
+*/
+qboolean ItemParse_invertyesno( itemDef_t *item) 
+{
+	if (PC_ParseInt(&item->invertYesNo)) 
+	{
+		return qfalse;
+	}
+	return qtrue;
+}
+
+/*
+===============
+ItemParse_xoffset (used for yes/no and multi)
+===============
+*/
+qboolean ItemParse_xoffset( itemDef_t *item) 
+{
+	if (PC_ParseInt(&item->xoffset)) 
+	{
+		return qfalse;
+	}
+	return qtrue;
+}
+
+
+/*
+===============
+ItemParse_backcolor 
+===============
+*/
+qboolean ItemParse_backcolor( itemDef_t *item) 
+{
+	int i;
+	float f;
+
+	for (i = 0; i < 4; i++) 
+	{
+		if (PC_ParseFloat(&f)) 
+		{
+			return qfalse;
+		}
+		item->window.backColor[i]  = f;
+	}
+	return qtrue;
+}
+
+/*
+===============
+ItemParse_forecolor 
+===============
+*/
+qboolean ItemParse_forecolor( itemDef_t *item) 
+{
+	int i;
+	float f;
+
+	for (i = 0; i < 4; i++) 
+	{
+		if (PC_ParseFloat(&f)) 
+		{
+			return qfalse;
+		}
+		if (f < 0)
+		{	//special case for player color
+			item->window.flags |= WINDOW_PLAYERCOLOR;
+			return qtrue;
+		}
+		item->window.foreColor[i]  = f;
+		item->window.flags |= WINDOW_FORECOLORSET;
+	}
+	return qtrue;
+}
+
+/*
+===============
+ItemParse_bordercolor 
+===============
+*/
+qboolean ItemParse_bordercolor( itemDef_t *item) 
+{
+	int i;
+	float f;
+
+	for (i = 0; i < 4; i++) 
+	{
+		if (PC_ParseFloat(&f)) 
+		{
+			return qfalse;
+		}
+		item->window.borderColor[i]  = f;
+	}
+	return qtrue;
+}
+
+/*
+===============
+ItemParse_outlinecolor 
+===============
+*/
+qboolean ItemParse_outlinecolor( itemDef_t *item) 
+{
+	if (PC_ParseColor(&item->window.outlineColor))
+	{
+		return qfalse;
+	}
+	return qtrue;
+}
+
+/*
+===============
+ItemParse_background 
+===============
+*/
+qboolean ItemParse_background( itemDef_t *item) 
+{
+	const char *temp;
+
+	if (PC_ParseString(&temp)) 
+	{
+		return qfalse;
+	}
+	item->window.background = ui.R_RegisterShaderNoMip(temp);
+	return qtrue;
+}
+
+/*
+===============
+ItemParse_cinematic 
+===============
+*/
+qboolean ItemParse_cinematic( itemDef_t *item) 
+{
+	if (!PC_ParseStringMem((const char **) &item->window.cinematicName)) 
+	{
+		return qfalse;
+	}
+	return qtrue;
+}
+
+/*
+===============
+ItemParse_doubleClick 
+===============
+*/
+qboolean ItemParse_doubleClick( itemDef_t *item) 
+{
+	listBoxDef_t *listPtr;
+
+	Item_ValidateTypeData(item);
+	if (!item->typeData) 
+	{
+		return qfalse;
+	}
+
+	listPtr = (listBoxDef_t*)item->typeData;
+
+	if (!PC_Script_Parse(&listPtr->doubleClick)) 
+	{
+		return qfalse;
+	}
+	return qtrue;
+}
+
+/*
+===============
+ItemParse_onFocus 
+===============
+*/
+qboolean ItemParse_onFocus( itemDef_t *item) 
+{
+	if (!PC_Script_Parse(&item->onFocus)) 
+	{
+		return qfalse;
+	}
+	return qtrue;
+}
+
+/*
+===============
+ItemParse_leaveFocus 
+===============
+*/
+qboolean ItemParse_leaveFocus( itemDef_t *item ) 
+{
+	if (!PC_Script_Parse(&item->leaveFocus)) 
+	{
+		return qfalse;
+	}
+	return qtrue;
+}
+
+/*
+===============
+ItemParse_mouseEnter 
+===============
+*/
+qboolean ItemParse_mouseEnter( itemDef_t *item) 
+{
+	if (!PC_Script_Parse(&item->mouseEnter)) 
+	{
+		return qfalse;
+	}
+	return qtrue;
+}
+
+/*
+===============
+ItemParse_mouseExit 
+===============
+*/
+qboolean ItemParse_mouseExit( itemDef_t *item) 
+{
+	if (!PC_Script_Parse(&item->mouseExit)) 
+	{
+		return qfalse;
+	}
+	return qtrue;
+}
+
+/*
+===============
+ItemParse_mouseEnterText 
+===============
+*/
+qboolean ItemParse_mouseEnterText( itemDef_t *item) 
+{
+	if (!PC_Script_Parse(&item->mouseEnterText)) 
+	{
+		return qfalse;
+	}
+	return qtrue;
+}
+
+/*
+===============
+ItemParse_mouseExitText 
+===============
+*/
+qboolean ItemParse_mouseExitText( itemDef_t *item) 
+{
+	if (!PC_Script_Parse(&item->mouseExitText)) 
+	{
+		return qfalse;
+	}
+	return qtrue;
+}
+
+
+/*
+===============
+ItemParse_accept 
+===============
+*/
+qboolean ItemParse_accept( itemDef_t *item) 
+{
+	if (!PC_Script_Parse(&item->accept)) 
+	{
+		return qfalse;
+	}
+	return qtrue;
+}
+
+
+//JLFDPADSCRIPT
+/*
+===============
+ItemParse_selectionNext
+===============
+*/
+qboolean ItemParse_selectionNext( itemDef_t *item) 
+{
+	if (!PC_Script_Parse(&item->selectionNext)) 
+	{
+		return qfalse;
+	}
+	return qtrue;
+}
+
+/*
+===============
+ItemParse_selectionPrev
+===============
+*/
+qboolean ItemParse_selectionPrev( itemDef_t *item) 
+{
+	if (!PC_Script_Parse(&item->selectionPrev)) 
+	{
+		return qfalse;
+	}
+	return qtrue;
+}
+// END JLFDPADSCRIPT
+
+
+
+
+
+
+/*
+===============
+ItemParse_action 
+===============
+*/
+qboolean ItemParse_action( itemDef_t *item) 
+{
+	if (!PC_Script_Parse(&item->action)) 
+	{
+		return qfalse;
+	}
+	return qtrue;
+}
+
+
+/*
+===============
+ItemParse_special 
+===============
+*/
+qboolean ItemParse_special( itemDef_t *item) 
+{
+	if (PC_ParseFloat(&item->special)) 
+	{
+		return qfalse;
+	}
+	return qtrue;
+}
+
+/*
+===============
+ItemParse_cvarTest 
+===============
+*/
+qboolean ItemParse_cvarTest( itemDef_t *item) 
+{
+	if (!PC_ParseStringMem((const char **) &item->cvarTest)) 
+	{
+		return qfalse;
+	}
+	return qtrue;
+}
+
+/*
+===============
+ItemParse_cvar 
+===============
+*/
+qboolean ItemParse_cvar( itemDef_t *item) 
+{
+	editFieldDef_t *editPtr;
+
+	Item_ValidateTypeData(item);
+	if (!PC_ParseStringMem(&item->cvar)) 
+	{
+		return qfalse;
+	}
+
+	if ( item->typeData)
+	{
+		switch ( item->type )
+		{
+			case ITEM_TYPE_EDITFIELD:
+			case ITEM_TYPE_NUMERICFIELD:
+			case ITEM_TYPE_YESNO:
+			case ITEM_TYPE_BIND:
+			case ITEM_TYPE_SLIDER:
+			case ITEM_TYPE_TEXT:
+			case ITEM_TYPE_TEXTSCROLL:
+				editPtr = (editFieldDef_t*)item->typeData;
+				editPtr->minVal = -1;
+				editPtr->maxVal = -1;
+				editPtr->defVal = -1;
+				break;
+		}
+	}
+	return qtrue;
+}
+
+/*
+===============
+ItemParse_maxChars 
+===============
+*/
+qboolean ItemParse_maxChars( itemDef_t *item) 
+{
+	editFieldDef_t *editPtr;
+	int maxChars;
+
+	Item_ValidateTypeData(item);
+	if (!item->typeData)
+	{
+		return qfalse;
+	}
+
+	if (PC_ParseInt(&maxChars)) 
+	{
+		return qfalse;
+	}
+	editPtr = (editFieldDef_t*)item->typeData;
+	editPtr->maxChars = maxChars;
+	return qtrue;
+}
+
+/*
+===============
+ItemParse_maxPaintChars 
+===============
+*/
+qboolean ItemParse_maxPaintChars( itemDef_t *item) 
+{
+	editFieldDef_t *editPtr;
+	int maxChars;
+
+	Item_ValidateTypeData(item);
+	if (!item->typeData)
+	{
+		return qfalse;
+	}
+
+	if (PC_ParseInt(&maxChars)) 
+	{
+		return qfalse;
+	}
+	editPtr = (editFieldDef_t*)item->typeData;
+	editPtr->maxPaintChars = maxChars;
+	return qtrue;
+}
+
+
+qboolean ItemParse_lineHeight( itemDef_t *item) 
+{
+	textScrollDef_t *scrollPtr;
+	int				height;
+
+	Item_ValidateTypeData(item);
+	if (!item->typeData)
+	{
+		return qfalse;
+	}
+
+	if (PC_ParseInt(&height)) 
+	{
+		return qfalse;
+	}
+
+	scrollPtr = (textScrollDef_t*)item->typeData;
+	scrollPtr->lineHeight = height;
+
+	return qtrue;
+}
+
+/*
+===============
+ItemParse_cvarFloat 
+===============
+*/
+qboolean ItemParse_cvarFloat( itemDef_t *item) 
+{
+	editFieldDef_t *editPtr;
+
+	Item_ValidateTypeData(item);
+	if (!item->typeData)
+	{
+		return qfalse;
+	}
+	editPtr = (editFieldDef_t*)item->typeData;
+	if (PC_ParseStringMem((const char **) &item->cvar) &&
+		!PC_ParseFloat(&editPtr->defVal) &&
+		!PC_ParseFloat(&editPtr->minVal) &&
+		!PC_ParseFloat(&editPtr->maxVal)) 
+	{
+		if (!stricmp(item->cvar,"r_ext_texture_filter_anisotropic"))
+		{//hehe, hook up the correct max value here.
+			editPtr->maxVal=glConfig.maxTextureFilterAnisotropy;
+		}
+		return qtrue;
+	}
+
+	return qfalse;
+}
+
+/*
+===============
+ItemParse_cvarStrList 
+===============
+*/
+qboolean ItemParse_cvarStrList( itemDef_t *item) 
+{
+	const char	*token;
+	multiDef_t *multiPtr;
+	int pass;
+	
+	Item_ValidateTypeData(item);
+	if (!item->typeData)
+	{
+		return qfalse;
+	}
+	multiPtr = (multiDef_t*)item->typeData;
+	multiPtr->count = 0;
+	multiPtr->strDef = qtrue;
+
+	if (PC_ParseString(&token))
+	{
+		return qfalse;
+	}
+
+	if (!stricmp(token,"feeder") && item->special == FEEDER_PLAYER_SPECIES) 
+	{
+		for (; multiPtr->count < uiInfo.playerSpeciesCount; multiPtr->count++)
+		{
+			multiPtr->cvarList[multiPtr->count] = String_Alloc(strupr(va("@MENUS_%s",uiInfo.playerSpecies[multiPtr->count].Name )));	//look up translation
+			multiPtr->cvarStr[multiPtr->count] = uiInfo.playerSpecies[multiPtr->count].Name;	//value
+		}
+		return qtrue;
+	}
+	// languages
+	if (!stricmp(token,"feeder") && item->special == FEEDER_LANGUAGES) 
+	{
+		for (; multiPtr->count < uiInfo.languageCount; multiPtr->count++)
+		{
+			// The displayed text
+			multiPtr->cvarList[multiPtr->count] = "@MENUS_MYLANGUAGE";
+			// The cvar value that goes into se_language
+			multiPtr->cvarStr[multiPtr->count] = SE_GetLanguageName( multiPtr->count );
+		}
+		return qtrue;
+	}
+	if (*token != '{') 
+	{
+		return qfalse;
+	}
+
+	pass = 0;
+	while ( 1 ) 
+	{
+		if (!PC_ParseStringMem(&token))
+		{
+			PC_ParseWarning("end of file inside menu item\n");
+			return qfalse;
+		}
+		if (*token == '}') 
+		{
+			return qtrue;
+		}
+		
+		if (*token == ',' || *token == ';') 
+		{
+			continue;
+		}
+
+		if (pass == 0) 
+		{
+			multiPtr->cvarList[multiPtr->count] = token;
+			pass = 1;
+		} 
+		else 
+		{
+			multiPtr->cvarStr[multiPtr->count] = token;
+			pass = 0;
+			multiPtr->count++;
+			if (multiPtr->count >= MAX_MULTI_CVARS) 
+			{
+				return qfalse;
+			}
+		}
+	}
+
+	return qfalse;
+}
+
+/*
+===============
+ItemParse_cvarFloatList 
+===============
+*/
+qboolean ItemParse_cvarFloatList( itemDef_t *item) 
+{
+	const char		*token;
+	multiDef_t	*multiPtr;
+	
+	Item_ValidateTypeData(item);
+	if (!item->typeData)
+	{
+		return qfalse;
+	}
+	multiPtr = (multiDef_t*)item->typeData;
+	multiPtr->count = 0;
+	multiPtr->strDef = qfalse;
+
+	if (PC_ParseString(&token))
+	{
+		return qfalse;
+	}
+
+	if (*token != '{') 
+	{
+		return qfalse;
+	}
+
+	while ( 1 ) 
+	{
+		if (!PC_ParseStringMem(&token))
+		{
+			PC_ParseWarning("end of file inside menu item\n");
+			return qfalse;
+		}
+		if (*token == '}') 
+		{
+			return qtrue;
+		}
+
+		if (*token == ',' || *token == ';') 
+		{
+			continue;
+		}
+
+		multiPtr->cvarList[multiPtr->count] = token;	//a StringAlloc ptr
+		if (PC_ParseFloat(&multiPtr->cvarValue[multiPtr->count])) 
+		{
+			return qfalse;
+		}
+
+		multiPtr->count++;
+		if (multiPtr->count >= MAX_MULTI_CVARS) 
+		{
+			return qfalse;
+		}
+
+	}
+
+	return qfalse;
+}
+
+
+/*
+===============
+ItemParse_addColorRange 
+===============
+*/
+qboolean ItemParse_addColorRange( itemDef_t *item) 
+{
+	colorRangeDef_t color;
+
+	if (PC_ParseFloat(&color.low) &&
+		PC_ParseFloat(&color.high) &&
+		PC_ParseColor(&color.color) ) 
+	{
+
+		if (item->numColors < MAX_COLOR_RANGES) 
+		{
+			memcpy(&item->colorRanges[item->numColors], &color, sizeof(color));
+			item->numColors++;
+		}
+		return qtrue;
+	}
+	return qfalse;
+}
+
+/*
+===============
+ItemParse_ownerdrawFlag 
+===============
+*/
+qboolean ItemParse_ownerdrawFlag( itemDef_t *item ) 
+{
+	int i;
+	if (PC_ParseInt(&i)) 
+	{
+		return qfalse;
+	}
+	item->window.ownerDrawFlags |= i;
+	return qtrue;
+}
+
+/*
+===============
+ItemParse_enableCvar 
+===============
+*/
+qboolean ItemParse_enableCvar( itemDef_t *item) 
+{
+	if (PC_Script_Parse(&item->enableCvar)) 
+	{
+		item->cvarFlags = CVAR_ENABLE;
+		return qtrue;
+	}
+	return qfalse;
+}
+
+/*
+===============
+ItemParse_disableCvar 
+===============
+*/
+qboolean ItemParse_disableCvar( itemDef_t *item ) 
+{
+	if (PC_Script_Parse(&item->enableCvar)) 
+	{
+		item->cvarFlags = CVAR_DISABLE;
+		return qtrue;
+	}
+	return qfalse;
+}
+
+/*
+===============
+ItemParse_showCvar 
+===============
+*/
+qboolean ItemParse_showCvar( itemDef_t *item ) 
+{
+	if (PC_Script_Parse(&item->enableCvar)) 
+	{
+		item->cvarFlags = CVAR_SHOW;
+		return qtrue;
+	}
+	return qfalse;
+}
+
+/*
+===============
+ItemParse_hideCvar 
+===============
+*/
+qboolean ItemParse_hideCvar( itemDef_t *item) 
+{
+	if (PC_Script_Parse(&item->enableCvar)) 
+	{
+		item->cvarFlags = CVAR_HIDE;
+		return qtrue;
+	}
+	return qfalse;
+}
+
+/*
+===============
+ItemParse_cvarsubstring
+===============
+*/
+qboolean ItemParse_cvarsubstring( itemDef_t *item) 
+{
+	assert(item->cvarFlags);	//need something set first, then we or in our flag.
+	item->cvarFlags |= CVAR_SUBSTRING;
+	return qtrue;
+}
+
+/*
+===============
+Item_ValidateTypeData
+===============
+*/
+void Item_ValidateTypeData(itemDef_t *item) 
+{
+	if (item->typeData) 
+	{
+		return;
+	}
+
+	if (item->type == ITEM_TYPE_LISTBOX) 
+	{
+		item->typeData = UI_Alloc(sizeof(listBoxDef_t));
+		memset(item->typeData, 0, sizeof(listBoxDef_t));
+	} 
+	else if (item->type == ITEM_TYPE_EDITFIELD || item->type == ITEM_TYPE_NUMERICFIELD || item->type == ITEM_TYPE_YESNO || item->type == ITEM_TYPE_BIND || item->type == ITEM_TYPE_SLIDER || item->type == ITEM_TYPE_TEXT) 
+	{
+		item->typeData = UI_Alloc(sizeof(editFieldDef_t));
+		memset(item->typeData, 0, sizeof(editFieldDef_t));
+		if (item->type == ITEM_TYPE_EDITFIELD) 
+		{
+			if (!((editFieldDef_t *) item->typeData)->maxPaintChars) 
+			{
+				((editFieldDef_t *) item->typeData)->maxPaintChars = MAX_EDITFIELD;
+			}
+		}
+	} 
+	else if (item->type == ITEM_TYPE_MULTI) 
+	{
+		item->typeData = UI_Alloc(sizeof(multiDef_t));
+	} 
+	else if (item->type == ITEM_TYPE_MODEL) 
+	{
+		item->typeData = UI_Alloc(sizeof(modelDef_t));
+		memset(item->typeData, 0, sizeof(modelDef_t));
+	}
+	else if (item->type == ITEM_TYPE_TEXTSCROLL )
+	{
+		item->typeData = UI_Alloc(sizeof(textScrollDef_t));
+	}
+}
+
+qboolean ItemParse_isCharacter( itemDef_t *item )
+{
+	int i;
+	if ( !PC_ParseInt(&i) )
+	{
+		if ( i )
+		{
+			item->flags |= ITF_ISCHARACTER;
+		}
+		else
+		{
+			item->flags &= ~ITF_ISCHARACTER;
+		}
+		return qtrue;
+	}
+	return qfalse;
+}
+
+qboolean ItemParse_isSaber( itemDef_t *item )
+{
+extern void UI_SaberLoadParms( void );
+extern qboolean ui_saber_parms_parsed;
+extern void UI_CacheSaberGlowGraphics( void );
+	int	i;
+	if ( !PC_ParseInt(&i) )
+	{
+		if ( i )
+		{
+			item->flags |= ITF_ISSABER;
+			UI_CacheSaberGlowGraphics();
+			if ( !ui_saber_parms_parsed )
+			{
+				UI_SaberLoadParms();
+			}
+		}
+		else
+		{
+			item->flags &= ~ITF_ISSABER;
+		}
+		return qtrue;
+	}
+	return qfalse;
+}
+
+qboolean ItemParse_isSaber2( itemDef_t *item )
+{
+extern void UI_SaberLoadParms( void );
+extern qboolean ui_saber_parms_parsed;
+extern void UI_CacheSaberGlowGraphics( void );
+	int	i;
+	if ( !PC_ParseInt(&i) )
+	{
+		if ( i )
+		{
+			item->flags |= ITF_ISSABER2;
+			UI_CacheSaberGlowGraphics();
+			if ( !ui_saber_parms_parsed )
+			{
+				UI_SaberLoadParms();
+			}
+		}
+		else
+		{
+			item->flags &= ~ITF_ISSABER2;
+		}
+		return qtrue;
+	}
+	return qfalse;
+}
+
+keywordHash_t itemParseKeywords[] = {
+	{"accept",			ItemParse_accept,			},
+	{"selectNext",		ItemParse_selectionNext,	},
+	{"selectPrev",		ItemParse_selectionPrev,	},
+	{"action",			ItemParse_action,			},
+	{"addColorRange",	ItemParse_addColorRange,	},
+	{"align",			ItemParse_align,			},
+	{"appearance_slot",	ItemParse_Appearance_slot,	},
+	{"asset_model",		ItemParse_asset_model,		},
+	{"asset_shader",	ItemParse_asset_shader,		},
+	{"isCharacter",		ItemParse_isCharacter,		},
+	{"isSaber",			ItemParse_isSaber,			},
+	{"isSaber2",		ItemParse_isSaber2,			},
+	{"autowrapped",		ItemParse_autowrapped,		},
+	{"backcolor",		ItemParse_backcolor,		},
+	{"background",		ItemParse_background,		},
+	{"border",			ItemParse_border,			},
+	{"bordercolor",		ItemParse_bordercolor,		},
+	{"bordersize",		ItemParse_bordersize,		},
+	{"cinematic",		ItemParse_cinematic,		},
+	{"columns",			ItemParse_columns,			},
+	{"cvar",			ItemParse_cvar,				},
+	{"cvarFloat",		ItemParse_cvarFloat,		},
+	{"cvarFloatList",	ItemParse_cvarFloatList,	},
+	{"cvarSubString",	ItemParse_cvarsubstring		},
+	{"cvarStrList",		ItemParse_cvarStrList,		},
+	{"cvarTest",		ItemParse_cvarTest,			},
+	{"decoration",		ItemParse_decoration,		},
+	{"desctext",		ItemParse_descText			},
+	{"disableCvar",		ItemParse_disableCvar,		},
+	{"doubleclick",		ItemParse_doubleClick,		},
+	{"elementheight",	ItemParse_elementheight,	},
+	{"elementtype",		ItemParse_elementtype,		},
+	{"elementwidth",	ItemParse_elementwidth,		},
+	{"enableCvar",		ItemParse_enableCvar,		},
+	{"feeder",			ItemParse_feeder,			},
+	{"flag",			ItemParse_flag,				},
+	{"focusSound",		ItemParse_focusSound,		},
+#ifdef _IMMERSION
+	{"focusForce",		ItemParse_focusForce,		},
+#endif // _IMMERSION
+	{"font",			ItemParse_font,				},
+	{"forecolor",		ItemParse_forecolor,		},
+	{"group",			ItemParse_group,			},
+	{"hideCvar",		ItemParse_hideCvar,			},
+	{"horizontalscroll",ItemParse_horizontalscroll, },
+	{"leaveFocus",		ItemParse_leaveFocus,		},
+	{"maxChars",		ItemParse_maxChars,			},
+	{"maxPaintChars",	ItemParse_maxPaintChars,	},
+	{"model_angle",		ItemParse_model_angle,		},
+	{"model_fovx",		ItemParse_model_fovx,		},
+	{"model_fovy",		ItemParse_model_fovy,		},
+	{"model_origin",	ItemParse_model_origin,		},
+	{"model_rotation",	ItemParse_model_rotation,	},
+	//rww - g2 begin
+	{"model_g2mins",	ItemParse_model_g2mins,		},
+	{"model_g2maxs",	ItemParse_model_g2maxs,		},
+	{"model_g2skin",	ItemParse_model_g2skin,		},
+	{"model_g2anim",	ItemParse_model_g2anim,		},
+	//rww - g2 end
+	{"mouseEnter",		ItemParse_mouseEnter,		},
+	{"mouseEnterText",	ItemParse_mouseEnterText,	},
+	{"mouseExit",		ItemParse_mouseExit,		},
+	{"mouseExitText",	ItemParse_mouseExitText,	},
+	{"name",			ItemParse_name				},
+	{"notselectable",	ItemParse_notselectable,	},
+//JLF
+	{"scrollhidden",	ItemParse_scrollhidden, 	},
+//JLF END
+	{"onFocus",			ItemParse_onFocus,			},
+	{"outlinecolor",	ItemParse_outlinecolor,		},
+	{"ownerdraw",		ItemParse_ownerdraw,		},
+	{"ownerdrawFlag",	ItemParse_ownerdrawFlag,	},
+	{"rect",			ItemParse_rect,				},
+	{"showCvar",		ItemParse_showCvar,			},
+	{"special",			ItemParse_special,			},
+	{"style",			ItemParse_style,			},
+	{"text",			ItemParse_text				},
+	{"text2",			ItemParse_text2				},
+	{"text2alignx",		ItemParse_text2alignx,		},
+	{"text2aligny",		ItemParse_text2aligny,		},
+	{"textalign",		ItemParse_textalign,		},
+	{"textalignx",		ItemParse_textalignx,		},
+	{"textaligny",		ItemParse_textaligny,		},
+	{"textscale",		ItemParse_textscale,		},
+	{"textstyle",		ItemParse_textstyle,		},
+	{"type",			ItemParse_type,				},
+	{"visible",			ItemParse_visible,			},
+	{"wrapped",			ItemParse_wrapped,			},
+	{"invertyesno",		ItemParse_invertyesno		},
+	{"xoffset",			ItemParse_xoffset			},//for yes/no and multi
+
+
+
+	// Text scroll specific
+	{"lineHeight",		ItemParse_lineHeight,		NULL	},
+
+	{NULL,				NULL,						}
+};
+
+keywordHash_t *itemParseKeywordHash[KEYWORDHASH_SIZE];
+
+/*
+===============
+Item_SetupKeywordHash
+===============
+*/
+void Item_SetupKeywordHash(void) 
+{
+	int i;
+
+	memset(itemParseKeywordHash, 0, sizeof(itemParseKeywordHash));
+	for (i = 0; itemParseKeywords[i].keyword; i++) 
+	{
+		KeywordHash_Add(itemParseKeywordHash, &itemParseKeywords[i]);
+	}
+}
+
+
+/*
+===============
+Item_Parse
+===============
+*/
+qboolean Item_Parse(itemDef_t *item) 
+{
+	keywordHash_t *key;
+	const char *token;
+
+
+	if (PC_ParseString(&token))
+	{
+		return qfalse;
+	}
+
+	if (*token != '{') 
+	{
+		return qfalse;
+	}
+
+	while ( 1 ) 
+	{
+		if (PC_ParseString(&token))
+		{
+			PC_ParseWarning("End of file inside menu item");
+			return qfalse;
+		}
+
+		if (*token == '}') 
+		{
+/*			if (!item->window.name) 
+			{
+				item->window.name = defaultString;
+				Com_Printf(S_COLOR_YELLOW"WARNING: Menu item has no name\n");
+			}
+
+			if (!item->window.group)
+			{
+				item->window.group = defaultString;
+				Com_Printf(S_COLOR_YELLOW"WARNING: Menu item has no group\n");
+			}
+*/
+			return qtrue;
+		}
+
+		key = (keywordHash_s *) KeywordHash_Find(itemParseKeywordHash, token);
+		if (!key) 
+		{
+			PC_ParseWarning(va("Unknown item keyword '%s'", token));
+			continue;
+		}
+
+		if ( !key->func(item) ) 
+		{
+			PC_ParseWarning(va("Couldn't parse item keyword '%s'", token));
+			return qfalse;
+		}
+	}
+}
+
+static void Item_TextScroll_BuildLines ( itemDef_t* item )
+{
+	// new asian-aware line breaker...  (pasted from elsewhere late @ night, hence aliasing-vars ;-)
+	//
+	textScrollDef_t* scrollPtr = (textScrollDef_t*) item->typeData;
+	const char *psText = item->text;	// for copy/paste ease
+	int iBoxWidth = item->window.rect.w - SCROLLBAR_SIZE - 10;
+
+	// this could probably be simplified now, but it was converted from something else I didn't originally write, 
+	//	and it works anyway so wtf...
+	//
+	const char *psCurrentTextReadPos;
+	const char *psReadPosAtLineStart;	
+	const char *psBestLineBreakSrcPos;
+	const char *psLastGood_s;	// needed if we get a full screen of chars with no punctuation or space (see usage notes)
+	qboolean bIsTrailingPunctuation;
+	unsigned int uiLetter;
+
+	if (!psText)
+	{
+		return;
+	}
+
+	if (*psText == '@')	// string reference
+	{
+//		trap_SP_GetStringTextString( &psText[1], text, sizeof(text));
+		psText = SE_GetString( &psText[1] );
+	}
+
+	psCurrentTextReadPos = psText;
+	psReadPosAtLineStart = psCurrentTextReadPos;
+	psBestLineBreakSrcPos = psCurrentTextReadPos;
+
+	scrollPtr->iLineCount = 0;
+	memset((char*)scrollPtr->pLines,0,sizeof(scrollPtr->pLines));
+
+	while (*psCurrentTextReadPos && (scrollPtr->iLineCount < MAX_TEXTSCROLL_LINES) )
+	{
+		char sLineForDisplay[2048];	// ott
+
+		// construct a line...
+		//
+		psCurrentTextReadPos = psReadPosAtLineStart;
+		sLineForDisplay[0] = '\0';
+		while ( *psCurrentTextReadPos )
+		{
+			int iAdvanceCount;
+			psLastGood_s = psCurrentTextReadPos;
+
+			// read letter...
+			//
+			uiLetter = ui.AnyLanguage_ReadCharFromString(psCurrentTextReadPos, &iAdvanceCount, &bIsTrailingPunctuation);
+			psCurrentTextReadPos += iAdvanceCount;
+
+			// concat onto string so far...
+			//
+			if (uiLetter == 32 && sLineForDisplay[0] == '\0')
+			{
+				psReadPosAtLineStart++;
+				continue;	// unless it's a space at the start of a line, in which case ignore it.
+			}
+
+			if (uiLetter > 255)
+			{
+				Q_strcat(sLineForDisplay, sizeof(sLineForDisplay),va("%c%c",uiLetter >> 8, uiLetter & 0xFF));
+			}
+			else
+			{
+				Q_strcat(sLineForDisplay, sizeof(sLineForDisplay),va("%c",uiLetter & 0xFF));
+			}
+
+			if (uiLetter == '\n')
+			{
+				// explicit new line...
+				//
+				sLineForDisplay[ strlen(sLineForDisplay)-1 ] = '\0';	// kill the CR
+				psReadPosAtLineStart = psCurrentTextReadPos;
+				psBestLineBreakSrcPos = psCurrentTextReadPos;
+
+				// hack it to fit in with this code...
+				//
+				scrollPtr->pLines[ scrollPtr->iLineCount ] = String_Alloc ( sLineForDisplay );
+				break;	// print this line
+			}
+			else 
+			if ( DC->textWidth( sLineForDisplay, item->textscale, item->font ) >= iBoxWidth )
+			{					
+				// reached screen edge, so cap off string at bytepos after last good position...
+				//
+				if (uiLetter > 255 && bIsTrailingPunctuation && !ui.Language_UsesSpaces())
+				{
+					// Special case, don't consider line breaking if you're on an asian punctuation char of
+					//	a language that doesn't use spaces...
+					//
+					uiLetter = uiLetter;	// breakpoint line only
+				}
+				else
+				{
+					if (psBestLineBreakSrcPos == psReadPosAtLineStart)
+					{
+						//  aarrrggh!!!!!   we'll only get here is someone has fed in a (probably) garbage string,
+						//		since it doesn't have a single space or punctuation mark right the way across one line
+						//		of the screen.  So far, this has only happened in testing when I hardwired a taiwanese 
+						//		string into this function while the game was running in english (which should NEVER happen 
+						//		normally).  On the other hand I suppose it's entirely possible that some taiwanese string 
+						//		might have no punctuation at all, so...
+						//
+						psBestLineBreakSrcPos = psLastGood_s;	// force a break after last good letter
+					}
+
+					sLineForDisplay[ psBestLineBreakSrcPos - psReadPosAtLineStart ] = '\0';
+					psReadPosAtLineStart = psCurrentTextReadPos = psBestLineBreakSrcPos;
+
+					// hack it to fit in with this code...
+					//
+					scrollPtr->pLines[ scrollPtr->iLineCount ] = String_Alloc( sLineForDisplay );
+					break;	// print this line
+				}
+			}
+
+			// record last-good linebreak pos...  (ie if we've just concat'd a punctuation point (western or asian) or space)
+			//
+			if (bIsTrailingPunctuation || uiLetter == ' ' || (uiLetter > 255 && !ui.Language_UsesSpaces()))
+			{
+				psBestLineBreakSrcPos = psCurrentTextReadPos;
+			}
+		}
+
+		/// arrgghh, this is gettng horrible now...
+		//
+		if (scrollPtr->pLines[ scrollPtr->iLineCount ] == NULL && strlen(sLineForDisplay))
+		{
+			// then this is the last line and we've just run out of text, no CR, no overflow etc...
+			//
+			scrollPtr->pLines[ scrollPtr->iLineCount ] = String_Alloc( sLineForDisplay );
+		}
+			
+		scrollPtr->iLineCount++;
+	}
+}
+
+/*
+===============
+Item_InitControls
+	init's special control types
+===============
+*/
+void Item_InitControls(itemDef_t *item) 
+{
+	if (item == NULL) 
+	{
+		return;
+	}
+	if (item->type == ITEM_TYPE_LISTBOX) 
+	{
+		listBoxDef_t *listPtr = (listBoxDef_t*)item->typeData;
+		item->cursorPos = 0;
+		if (listPtr) 
+		{
+			listPtr->cursorPos = 0;
+			listPtr->startPos = 0;
+			listPtr->endPos = 0;
+			listPtr->cursorPos = 0;
+		}
+	}
+}
+
+/*
+=================
+Int_Parse
+=================
+*/
+qboolean Int_Parse(const char **p, int *i) 
+{
+	char	*token;
+	token = COM_ParseExt(p, qfalse);
+
+	if (token && token[0] != 0) 
+	{
+		*i = atoi(token);
+		return qtrue;
+	} 
+	else 
+	{
+		return qfalse;
+	}
+}
+
+/*
+=================
+String_Parse
+=================
+*/
+qboolean String_Parse(const char **p, const char **out) 
+{
+	char *token;
+
+	token = COM_ParseExt(p, qfalse);
+	if (token && token[0] != 0) 
+	{
+		*(out) = String_Alloc(token);
+		return *(out)!=NULL;
+	}
+	return qfalse;
+}
+
+/*
+===============
+Item_RunScript
+===============
+*/
+void Item_RunScript(itemDef_t *item, const char *s) 
+{
+	const char *p;
+	int i;
+	qboolean bRan;
+
+	uiInfo.runScriptItem = item;
+
+	if (item && s && s[0]) 
+	{
+		p = s;
+		while (1) 
+		{
+			const char *command;
+			// expect command then arguments, ; ends command, NULL ends script
+			if (!String_Parse(&p, &command)) 
+			{
+				return;
+			}
+
+			if (command[0] == ';' && command[1] == '\0') 
+			{
+				continue;
+			}
+
+			bRan = qfalse;
+			for (i = 0; i < scriptCommandCount; i++) 
+			{
+				if (Q_stricmp(command, commandList[i].name) == 0) 
+				{
+					if ( !(commandList[i].handler(item, &p)) )
+					{
+						return;
+					}
+
+					bRan = qtrue;
+					break;
+				}
+			}
+			// not in our auto list, pass to handler
+			if (!bRan) 
+			{
+				// Allow any script command to fail
+				if ( !DC->runScript(&p) )
+				{
+					break;
+				}
+			}
+		}
+	}
+}
+
+
+/*
+===============
+Menu_SetupKeywordHash
+===============
+*/
+void Menu_SetupKeywordHash(void) 
+{
+	int i;
+
+	memset(menuParseKeywordHash, 0, sizeof(menuParseKeywordHash));
+	for (i = 0; menuParseKeywords[i].keyword; i++) 
+	{
+		KeywordHash_Add(menuParseKeywordHash, &menuParseKeywords[i]);
+	}
+}
+
+
+/*
+===============
+Menus_ActivateByName
+===============
+*/
+void Menu_HandleMouseMove(menuDef_t *menu, float x, float y);
+menuDef_t *Menus_ActivateByName(const char *p) 
+{
+	int i;
+	menuDef_t *m = NULL;
+	menuDef_t *focus = Menu_GetFocused();
+
+	for (i = 0; i < menuCount; i++) 
+	{
+		// Look for the name in the current list of windows
+		if (Q_stricmp(Menus[i].window.name, p) == 0) 
+		{
+			m = &Menus[i];
+			Menus_Activate(m);
+			if (openMenuCount < MAX_OPEN_MENUS && focus != NULL) 
+			{
+				menuStack[openMenuCount++] = focus;
+			}
+		} 
+		else 
+		{
+			Menus[i].window.flags &= ~WINDOW_HASFOCUS;
+		}
+	}
+
+
+	if (!m)
+	{	// A hack so we don't have to load all three mission menus before we know what tier we're on
+		if (!Q_stricmp( p, "ingameMissionSelect1" ) )
+		{
+			UI_LoadMenus("ui/tier1.txt",qfalse);
+			Menus_CloseAll();
+			Menus_OpenByName("ingameMissionSelect1");
+		}
+		else if (!Q_stricmp( p, "ingameMissionSelect2" ) )
+		{
+			UI_LoadMenus("ui/tier2.txt",qfalse);
+			Menus_CloseAll();
+			Menus_OpenByName("ingameMissionSelect2");
+		}
+		else if (!Q_stricmp( p, "ingameMissionSelect3" ) )
+		{
+			UI_LoadMenus("ui/tier3.txt",qfalse);
+			Menus_CloseAll();
+			Menus_OpenByName("ingameMissionSelect3");
+		}
+		else
+		{
+			Com_Printf(S_COLOR_YELLOW"WARNING: Menus_ActivateByName: Unable to find menu '%s'\n",p);
+		}
+	}
+
+	// First time, show force select instructions
+	if (!Q_stricmp( p, "ingameForceSelect" ) )
+	{
+		int	tier_storyinfo = Cvar_VariableIntegerValue( "tier_storyinfo" );
+
+		if (tier_storyinfo==1)
+		{
+			Menus_OpenByName("ingameForceHelp");
+		}
+	}
+
+	// First time, show weapons select instructions
+	if (!Q_stricmp( p, "ingameWpnSelect" ) )
+	{
+		int	tier_storyinfo = Cvar_VariableIntegerValue( "tier_storyinfo" );
+
+		if (tier_storyinfo==1)
+		{
+			Menus_OpenByName("ingameWpnSelectHelp");
+		}
+	}
+
+	// Want to handle a mouse move on the new menu in case your already over an item
+	Menu_HandleMouseMove ( m, DC->cursorx, DC->cursory );
+
+	return m;
+}
+
+/*
+===============
+Menus_Activate
+===============
+*/
+void  Menus_Activate(menuDef_t *menu) 
+{
+	menu->window.flags |= (WINDOW_HASFOCUS | WINDOW_VISIBLE);
+
+//JLFCALLOUT MPMOVED
+#ifdef _XBOX
+	DC->setCVar("ui_hideAcallout" ,"0");
+	DC->setCVar("ui_hideBcallout" ,"0");
+	DC->setCVar("ui_hideCcallout" ,"0");
+#endif
+//JLF END
+	if (menu->onOpen) 
+	{
+		itemDef_t item;
+		item.parent = menu;
+		item.window.flags = 0;	//err, item is fake here, but we want a valid flag before calling runscript
+		Item_RunScript(&item, menu->onOpen);
+
+		if (item.window.flags & WINDOW_SCRIPTWAITING)	//in case runscript set waiting, copy it up to the menu
+		{
+			menu->window.flags |= WINDOW_SCRIPTWAITING;
+			menu->window.delayedScript = item.window.delayedScript;
+			menu->window.delayTime = item.window.delayTime;
+		}
+	}
+
+//	menu->appearanceTime = DC->realTime + 1000;
+	menu->appearanceTime = 0;
+	menu->appearanceCnt = 0;
+
+}
+
+typedef struct {
+	char	*command;
+	int		id;
+	int		defaultbind1;
+	int		defaultbind2;
+	int		bind1;
+	int		bind2;
+} bind_t;
+
+static bind_t g_bindings[] = 
+{
+	{"invuse",			A_ENTER,			-1,		-1,		-1},
+	{"force_throw",		A_F1,				-1,		-1,		-1},
+	{"force_pull",		A_F2,				-1,		-1,		-1},
+	{"force_speed",		A_F3,				-1,		-1,		-1},
+	{"force_distract",	A_F4,				-1,		-1,		-1},
+	{"force_heal",		A_F5,				-1,		-1,		-1},
+	{"+force_grip",		A_F6,				-1,		-1,		-1},
+	{"+force_lightning",A_F7,				-1,		-1,		-1},
+	//new powers
+	{"+force_drain",	-1,					-1,		-1,		-1},
+	{"force_rage",		-1,					-1,		-1,		-1},
+	{"force_protect",	-1,					-1,		-1,		-1},
+	{"force_absorb",	-1,					-1,		-1,		-1},
+	{"force_sight",		-1,					-1,		-1,		-1},
+
+	{"taunt",			-1,					-1,		-1,		-1},
+
+	{"+useforce",		'f',				-1,		-1,		-1},
+	{"forceprev",		'z',				-1,		-1,		-1},
+	{"forcenext",		'x',				-1,		-1,		-1},
+	{"use_bacta",		-1,					-1,		-1,		-1},
+	{"use_seeker",		-1,					-1,		-1,		-1},
+	{"use_sentry",		-1,					-1,		-1,		-1},
+	{"use_lightamp_goggles",-1,				-1,		-1,		-1},
+	{"use_electrobinoculars",-1,			-1,		-1,		-1},
+	{"invnext",			-1,					-1,		-1,		-1},
+	{"invprev",			-1,					-1,		-1,		-1},
+	{"invuse",			-1,					-1,		-1,		-1},
+	{"+speed", 			A_SHIFT,			-1,		-1,		-1},
+	{"+forward", 		A_CURSOR_UP,		-1,		-1,		-1},
+	{"+back", 			A_CURSOR_DOWN,		-1,		-1,		-1},
+	{"+moveleft", 		',',				-1,		-1,		-1},
+	{"+moveright",		'.',				-1,		-1,		-1},
+	{"+moveup",			'v',				-1,		-1,		-1},
+	{"+movedown",		'c',				-1,		-1,		-1},
+	{"+left", 			A_CURSOR_LEFT,		-1,		-1,		-1},
+	{"+right", 			A_CURSOR_RIGHT,		-1,		-1,		-1},
+	{"+strafe", 		-1,					-1,		-1,		-1},
+	{"+lookup", 		A_PAGE_DOWN,		-1,		-1,		-1},
+	{"+lookdown",		A_DELETE,			-1,		-1,		-1},
+	{"+mlook", 			 '/',				-1,		-1,		-1},
+	{"centerview",		A_END,				-1,		-1,		-1},
+	{"zoom", 			-1,					-1,		-1,		-1},
+	{"weapon 0",		-1,					-1,		-1,		-1},
+	{"weapon 1",		'1',				-1,		-1,		-1},
+	{"weapon 2",		'2',				-1,		-1,		-1},
+	{"weapon 3",		'3',				-1,		-1,		-1},
+	{"weapon 4",		'4',				-1,		-1,		-1},
+	{"weapon 5",		'5',				-1,		-1,		-1},
+	{"weapon 6",		'6',				-1,		-1,		-1},
+	{"weapon 7",		'7',				-1,		-1,		-1},
+	{"weapon 8",		'8',				-1,		-1,		-1},
+	{"weapon 9",		'9',				-1,		-1,		-1},
+	{"weapon 10",		'0',				-1,		-1,		-1},
+	{"weapon 11",		-1,					-1,		-1,		-1},
+	{"weapon 12",		-1,					-1,		-1,		-1},
+	{"weapon 13",		-1,					-1,		-1,		-1},
+	{"+attack", 		A_CTRL,				-1,		-1,		-1},
+	{"+altattack", 		A_ALT,				-1,		-1,		-1},
+	{"weapprev",		'[',				-1,		-1,		-1},
+	{"weapnext", 		']',				-1,		-1,		-1},
+	{"+use",			A_SPACE,			-1,		-1,		-1},
+	{"datapad",			A_TAB,				-1,		-1,		-1},
+	{"save quick",		A_F9,				-1,		-1,		-1},
+	{"load quick",		-1,					-1,		-1,		-1},
+	{"load auto",		-1,					-1,		-1,		-1},
+	{"cg_thirdperson !",'p',				-1,		-1,		-1},
+	{"exitview",		-1,					-1,		-1,		-1},
+	{"uimenu ingameloadmenu",	A_F10,		-1,		-1,		-1},
+	{"uimenu ingamesavemenu",	A_F11,		-1,		-1,		-1},
+	{"saberAttackCycle",-1,					-1,		-1,		-1},
+};
+
+
+static const int g_bindCount = sizeof(g_bindings) / sizeof(bind_t);
+
+/*
+=================
+Controls_GetKeyAssignment
+=================
+*/
+static void Controls_GetKeyAssignment (char *command, int *twokeys)
+{
+	int		count;
+	int		j;
+	char	b[256];
+
+	twokeys[0] = twokeys[1] = -1;
+	count = 0;
+
+	for ( j = 0; j < MAX_KEYS; j++ )
+	{
+		DC->getBindingBuf( j, b, 256 );
+		if ( *b == 0 ) 
+		{
+			continue;
+		}
+		if ( !Q_stricmp( b, command ) ) 
+		{
+			twokeys[count] = j;
+			count++;
+			if (count == 2) 
+			{
+				break;
+			}
+		}
+	}
+}
+
+/*
+=================
+Controls_GetConfig
+=================
+*/
+void Controls_GetConfig( void )
+{
+	int		i;
+	int		twokeys[2];
+
+	// iterate each command, get its numeric binding
+	for (i=0; i < g_bindCount; i++)
+	{
+ 		Controls_GetKeyAssignment(g_bindings[i].command, twokeys);
+
+		g_bindings[i].bind1 = twokeys[0];
+		g_bindings[i].bind2 = twokeys[1];
+	}
+}
+
+
+/*
+===============
+Item_SetScreenCoords
+===============
+*/
+void Item_SetScreenCoords(itemDef_t *item, float x, float y) 
+{
+  
+	if (item == NULL) 
+	{
+		return;
+	}
+
+	if (item->window.border != 0) 
+	{
+		x += item->window.borderSize;
+		y += item->window.borderSize;
+	}
+
+	item->window.rect.x = x + item->window.rectClient.x;
+	item->window.rect.y = y + item->window.rectClient.y;
+	item->window.rect.w = item->window.rectClient.w;
+	item->window.rect.h = item->window.rectClient.h;
+
+	// force the text rects to recompute
+	item->textRect.w = 0;
+	item->textRect.h = 0;
+
+	switch ( item->type)
+	{
+		case ITEM_TYPE_TEXTSCROLL:
+		{
+			textScrollDef_t *scrollPtr = (textScrollDef_t*)item->typeData;
+			if ( scrollPtr )
+			{
+				scrollPtr->startPos = 0;
+				scrollPtr->endPos = 0;
+			}
+
+			Item_TextScroll_BuildLines ( item );
+
+			break;
+		}
+	}
+}
+
+
+static void Menu_FreeGhoulItems(menuDef_t *menu) 
+{
+	int i,j;
+	for (i = 0; i < menu->itemCount; i++) 
+	{
+		for (j=0; j < menu->items[i]->ghoul2.size(); j++)
+		{
+			if ( menu->items[i]->ghoul2[j].mModelindex >= 0)
+			{
+				DC->g2_RemoveGhoul2Model( menu->items[i]->ghoul2, j );
+			}
+		}
+		(menu->items[i]->ghoul2).clear();	//clear is the public Free so i can actually remove this slot
+	}
+}
+/*
+===============
+Menu_Reset
+===============
+*/
+void Menu_Reset(void) 
+{
+	//FIXME iterate menus to destoy G2 assets.
+	int i;
+
+	for (i = 0; i < menuCount; i++) 
+	{
+		Menu_FreeGhoulItems( &Menus[i] );
+	}
+
+	menuCount = 0;
+}
+
+/*
+===============
+Menu_UpdatePosition
+===============
+*/
+void Menu_UpdatePosition(menuDef_t *menu) 
+{
+  int i;
+  float x, y;
+
+  if (menu == NULL) 
+  {
+    return;
+  }
+  
+  x = menu->window.rect.x;
+  y = menu->window.rect.y;
+  if (menu->window.border != 0) 
+  {
+    x += menu->window.borderSize;
+    y += menu->window.borderSize;
+  }
+
+  for (i = 0; i < menu->itemCount; i++) 
+  {
+    Item_SetScreenCoords(menu->items[i], x, y);
+  }
+}
+
+/*
+===============
+Menu_PostParse
+===============
+*/
+void Menu_PostParse(menuDef_t *menu) 
+{
+	if (menu == NULL) 
+	{
+		return;
+	}
+#ifdef _XBOX
+//JLFCALLOUT
+	//for all the call out items define their functionality
+//	for (int i =0 ; i < MAX_CALLOUTITEMS; i++)
+//	{
+	//	menu->calloutitems[i] = (struct itemDef_s *) UI_Alloc(sizeof(itemDef_t));
+	//	Item_Init(menu->calloutitems[i]);
+//	}
+		// fill in the fields
+		// dpad 1 (up/down)
+		//menu->calloutitems[0]->window.flags  
+	
+	
+#endif
+
+
+	if (menu->fullScreen) 
+	{
+		menu->window.rect.x = 0;
+		menu->window.rect.y = 0;
+		menu->window.rect.w = 640;
+		menu->window.rect.h = 480;
+	}
+	Menu_UpdatePosition(menu);
+}
+
+/*
+===============
+Menu_Init
+===============
+*/
+void Menu_Init(menuDef_t *menu) 
+{
+	memset(menu, 0, sizeof(menuDef_t));
+	menu->cursorItem = -1;
+
+	UI_Cursor_Show(qtrue);
+
+	if (DC)
+	{
+		menu->fadeAmount = DC->Assets.fadeAmount;
+		menu->fadeClamp = DC->Assets.fadeClamp;
+		menu->fadeCycle = DC->Assets.fadeCycle;
+	}
+
+	Window_Init(&menu->window);
+}
+
+/*
+===============
+Menu_Parse
+===============
+*/
+qboolean Menu_Parse(char *inbuffer, menuDef_t *menu) 
+{
+//	pc_token_t token;
+	keywordHash_t *key;
+	char	*token2;
+	char * buffer;
+	bool nest= false;
+	buffer = inbuffer;
+#ifdef _XBOX
+	char * includeBuffer;
+#endif
+
+	token2 = PC_ParseExt();
+
+	if (!token2)
+	{
+		return qfalse;
+	}
+
+	if (*token2 != '{') 
+	{
+		PC_ParseWarning("Misplaced {");
+		return qfalse;
+	}
+	while ( 1 ) 
+	{
+
+		token2 = PC_ParseExt();
+		if (!token2)
+		{
+			PC_ParseWarning("End of file inside menu.");
+			return qfalse;
+		}
+
+		if (*token2 == '}') 
+		{
+			return qtrue;
+		}
+#ifdef _XBOX
+//JLFCALLOUT
+char * UI_ParseInclude(const char *menuFile, menuDef_t * menu); 
+
+		if (!strcmp (token2, "#include"))
+		{
+			token2 = PC_ParseExt();
+			char *includeBuffer = UI_ParseInclude(token2, menu );
+			//bufferize thetoken2 
+			nest = true;
+			buffer = includeBuffer;
+			continue;
+		}
+#endif
+
+		if (nest && (*token2 == 0))
+		{
+			PC_EndParseSession(buffer);
+
+			nest = false;
+			continue;
+		}
+		key = KeywordHash_Find(menuParseKeywordHash, token2);
+		
+		if (!key) 
+		{
+			PC_ParseWarning(va("Unknown menu keyword %s",token2));
+			continue;
+		}
+
+		if ( !key->func((itemDef_t*)menu) ) 
+		{
+			PC_ParseWarning(va("Couldn't parse menu keyword %s as %s",token2, key->keyword));
+			return qfalse;
+		} 
+	}
+}
+
+/*
+===============
+Menu_New
+===============
+*/
+void Menu_New(char *buffer) 
+{
+	menuDef_t *menu = &Menus[menuCount];
+
+	if (menuCount < MAX_MENUS) 
+	{
+		Menu_Init(menu);
+		if (Menu_Parse(buffer, menu)) 
+		{
+			Menu_PostParse(menu);
+			menuCount++;
+		}
+	}
+}
+
+/*
+===============
+Menus_CloseAll
+===============
+*/
+void  Menus_CloseAll(void) 
+{
+	int i;
+
+	for (i = 0; i < menuCount; i++) 
+	{
+		Menu_RunCloseScript ( &Menus[i] );
+		Menus[i].window.flags &= ~(WINDOW_HASFOCUS | WINDOW_VISIBLE);
+	}
+
+	// Clear the menu stack
+	openMenuCount = 0;
+}
+
+/*
+===============
+PC_StartParseSession
+===============
+*/
+#ifdef _XBOX
+int PC_StartParseSession(const char *fileName,char **buffer, bool nested)
+#else
+int PC_StartParseSession(const char *fileName,char **buffer)
+#endif
+{
+	int	len;
+
+	// Try to open file and read it in.
+	len = ui.FS_ReadFile( fileName,(void **) buffer  );
+
+	// Not there?
+	if ( len>0 ) 
+	{
+#ifdef _XBOX
+		if (nested)
+			parseDataCount = 1;
+		else
+#endif
+			parseDataCount = 0;
+
+		strncpy(parseData[parseDataCount].fileName, fileName, MAX_QPATH);
+		parseData[parseDataCount].bufferStart = *buffer;
+		parseData[parseDataCount].bufferCurrent = *buffer;
+
+#ifdef _XBOX
+		COM_BeginParseSession(nested);
+#else
+		COM_BeginParseSession();
+#endif
+	}
+
+	return len;
+}
+
+/*
+===============
+PC_EndParseSession
+===============
+*/
+void PC_EndParseSession(char *buffer)
+{
+	parseDataCount--;
+	ui.FS_FreeFile( buffer );	//let go of the buffer
+}
+
+/*
+===============
+PC_ParseWarning
+===============
+*/
+void PC_ParseWarning(const char *message)
+{
+	ui.Printf(S_COLOR_YELLOW "WARNING: %s Line #%d of File '%s'\n", message,parseData[parseDataCount].com_lines,parseData[parseDataCount].fileName);
+}
+
+char *PC_ParseExt(void)
+{
+	return (COM_ParseExt(&parseData[parseDataCount].bufferCurrent, qtrue));
+}
+
+qboolean PC_ParseString(const char **string)
+{
+	int	hold;
+
+	hold = COM_ParseString(&parseData[parseDataCount].bufferCurrent,string);
+
+	while (hold==0 && **string == 0)		
+	{
+		hold = COM_ParseString(&parseData[parseDataCount].bufferCurrent,string);
+	}
+
+	return(hold);
+}
+
+qboolean PC_ParseInt(int *number)
+{
+	return(COM_ParseInt(&parseData[parseDataCount].bufferCurrent,number));
+}
+
+qboolean PC_ParseFloat(float *number)
+{
+	return(COM_ParseFloat(&parseData[parseDataCount].bufferCurrent,number));
+}
+
+qboolean PC_ParseColor(vec4_t *color)
+{
+	return(COM_ParseVec4(&parseData[parseDataCount].bufferCurrent, color));
+}
+
+
+/*
+=================
+Menu_Count
+=================
+*/
+int Menu_Count(void) 
+{
+	return menuCount;
+}
+
+/*
+=================
+Menu_PaintAll
+=================
+*/
+void Menu_PaintAll(void) 
+{
+	int i;
+	if (captureFunc) 
+	{
+		captureFunc(captureData);
+	}
+
+	for (i = 0; i < menuCount; i++) 
+	{
+		Menu_Paint(&Menus[i], qfalse);
+	}
+
+	if (uis.debugMode) 
+	{
+		vec4_t v = {1, 1, 1, 1};
+		DC->drawText(5, 25, .75, v, va("(%d,%d)",DC->cursorx,DC->cursory), 0, 0, DC->Assets.qhMediumFont);
+		DC->drawText(5, 10, .75, v, va("fps: %f", DC->FPS), 0, 0, DC->Assets.qhMediumFont);
+	}
+}
+
+/*
+=================
+Menu_Paint
+=================
+*/
+void Menu_Paint(menuDef_t *menu, qboolean forcePaint) 
+{
+	int i;
+
+	if (menu == NULL) 
+	{
+		return;
+	}
+
+	if (menu->window.flags & WINDOW_SCRIPTWAITING)
+	{
+		if (DC->realTime > menu->window.delayTime)
+		{ // Time has elapsed, resume running whatever script we saved
+			itemDef_t item;
+			item.parent = menu;
+			item.window.flags = 0;	//clear before calling RunScript
+			menu->window.flags &= ~WINDOW_SCRIPTWAITING;
+			Item_RunScript(&item, menu->window.delayedScript);
+
+			// Could have hit another delay. Need to hoist from fake item
+			if (item.window.flags & WINDOW_SCRIPTWAITING)
+			{
+				menu->window.flags |= WINDOW_SCRIPTWAITING;
+				menu->window.delayedScript = item.window.delayedScript;
+				menu->window.delayTime = item.window.delayTime;
+			}
+		}
+	}
+
+	if (!(menu->window.flags & WINDOW_VISIBLE) &&  !forcePaint) 
+	{
+		return;
+	}
+
+//	if (menu->window.ownerDrawFlags && DC->ownerDrawVisible && !DC->ownerDrawVisible(menu->window.ownerDrawFlags)) 
+//	{
+//		return;
+//	}
+	
+	if (forcePaint) 
+	{
+		menu->window.flags |= WINDOW_FORCED;
+	}
+
+	// draw the background if necessary
+	if (menu->fullScreen) 
+	{
+
+		vec4_t	color;
+		color[0] = menu->window.backColor[0];
+		color[1] = menu->window.backColor[1];
+		color[2] = menu->window.backColor[2];
+		color[3] = menu->window.backColor[3];
+
+		ui.R_SetColor( color);
+
+		if (menu->window.background==0)	// No background shader given? Make it blank
+		{
+			menu->window.background = uis.whiteShader;
+		}
+
+		DC->drawHandlePic( 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, menu->window.background );
+	} 
+	else if (menu->window.background) 
+	{
+		// this allows a background shader without being full screen
+		//UI_DrawHandlePic(menu->window.rect.x, menu->window.rect.y, menu->window.rect.w, menu->window.rect.h, menu->backgroundShader);
+	}
+
+	// paint the background and or border
+	Window_Paint(&menu->window, menu->fadeAmount, menu->fadeClamp, menu->fadeCycle );
+
+	// Loop through all items for the menu and paint them
+	int iSlotsVisible = 0;
+	for (i = 0; i < menu->itemCount; i++) 
+	{
+		if (!menu->items[i]->appearanceSlot)
+		{
+			Item_Paint(menu->items[i], qtrue);
+		}
+		else // Timed order of appearance
+		{
+			if (Item_Paint(menu->items[i], qfalse) )
+			{
+				iSlotsVisible++;	//It would paint
+			}
+			if (menu->items[i]->appearanceSlot<=menu->appearanceCnt)
+			{
+				Item_Paint(menu->items[i], qtrue);
+			}
+		}
+#ifdef _XBOX
+//JLFCALLOUT
+//		if ( menu->items[i]->window.flags & WINDOW_HASFOCUS)
+//		{
+//			if ( menu->items[i]->type == ITEM_TYPE_BUTTON || menu->onAccept)
+//			{
+
+//			}
+//		}
+#endif
+	}
+	if (iSlotsVisible && menu->appearanceTime < DC->realTime && menu->appearanceCnt < menu->itemCount)	// Time to show another item
+	{
+		menu->appearanceTime = DC->realTime + menu->appearanceIncrement;
+		menu->appearanceCnt++;
+	}
+
+
+	if (uis.debugMode) 
+	{
+		vec4_t color;
+		color[0] = color[2] = color[3] = 1;
+		color[1] = 0;
+		DC->drawRect(menu->window.rect.x, menu->window.rect.y, menu->window.rect.w, menu->window.rect.h, 1, color);
+	}
+}
+
+/*
+=================
+Item_EnableShowViaCvar
+=================
+*/
+qboolean Item_EnableShowViaCvar(itemDef_t *item, int flag) 
+{
+	if (item && item->enableCvar && *item->enableCvar && item->cvarTest && *item->cvarTest) 
+	{
+		char script[1024];
+		const char *p;
+		char buff[1024];
+		if (item->cvarFlags & CVAR_SUBSTRING)
+		{
+			const char *val;
+			p = item->enableCvar;
+			if (!String_Parse(&p, &val)) 
+			{//strip the quotes off 
+				return (item->cvarFlags & flag) ? qfalse : qtrue;
+			}
+			Q_strncpyz(buff, val, sizeof(buff), qtrue);
+			DC->getCVarString(item->cvarTest, script, sizeof(script));
+			p = script;
+		}
+		else
+		{
+			DC->getCVarString(item->cvarTest, buff, sizeof(buff));
+			Q_strncpyz(script, item->enableCvar, sizeof(script), qtrue);
+			p = script;
+		}
+		while (1) 
+		{
+			const char *val;
+			// expect value then ; or NULL, NULL ends list
+			if (!String_Parse(&p, &val)) 
+			{
+				return (item->cvarFlags & flag) ? qfalse : qtrue;
+			}
+
+			if (val[0] == ';' && val[1] == '\0') 
+			{
+				continue;
+			}
+
+			// enable it if any of the values are true
+			if (item->cvarFlags & flag) 
+			{
+				if (Q_stricmp(buff, val) == 0) 
+				{
+					return qtrue;
+				}
+			} 
+			else 
+			{
+				// disable it if any of the values are true
+				if (Q_stricmp(buff, val) == 0) 
+				{
+					return qfalse;
+				}
+			}
+		}
+		return (item->cvarFlags & flag) ? qfalse : qtrue;
+	}
+	return qtrue;
+}
+
+/*
+=================
+Item_SetTextExtents
+=================
+*/
+void Item_SetTextExtents(itemDef_t *item, int *width, int *height, const char *text) 
+{
+	const char *textPtr = (text) ? text : item->text;
+
+	if (textPtr == NULL ) 
+	{
+		return;
+	}
+
+	*width = item->textRect.w;
+	*height = item->textRect.h;
+
+	// keeps us from computing the widths and heights more than once
+	if (*width == 0 || (item->type == ITEM_TYPE_OWNERDRAW && item->textalignment == ITEM_ALIGN_CENTER)
+		|| (item->text && item->text[0]=='@' && item->asset != se_language->modificationCount )	//string package language changed
+		) 
+	{
+		int originalWidth;
+
+		originalWidth = DC->textWidth(textPtr, item->textscale, item->font);
+
+		if (item->type == ITEM_TYPE_OWNERDRAW && (item->textalignment == ITEM_ALIGN_CENTER || item->textalignment == ITEM_ALIGN_RIGHT)) 
+		{
+			originalWidth += DC->ownerDrawWidth(item->window.ownerDraw, item->textscale);
+		} 
+		else if (item->type == ITEM_TYPE_EDITFIELD && item->textalignment == ITEM_ALIGN_CENTER && item->cvar) 
+		{
+			char buff[256];
+			DC->getCVarString(item->cvar, buff, 256);
+			originalWidth += DC->textWidth(buff, item->textscale, item->font);
+		}
+
+		*width = DC->textWidth(textPtr, item->textscale, item->font);
+		*height = DC->textHeight(textPtr, item->textscale, item->font);
+
+		item->textRect.w = *width;
+		item->textRect.h = *height;
+		item->textRect.x = item->textalignx;
+		item->textRect.y = item->textaligny;
+		if (item->textalignment == ITEM_ALIGN_RIGHT) 
+		{
+			item->textRect.x = item->textalignx - originalWidth;
+		} 
+		else if (item->textalignment == ITEM_ALIGN_CENTER) 
+		{
+			item->textRect.x = item->textalignx - originalWidth / 2;
+		}
+
+		ToWindowCoords(&item->textRect.x, &item->textRect.y, &item->window);
+		if (item->text && item->text[0]=='@' )//string package
+		{//mark language
+			item->asset = se_language->modificationCount;
+		}
+
+	}
+}
+
+/*
+=================
+Item_TextColor
+=================
+*/
+void Item_TextColor(itemDef_t *item, vec4_t *newColor) 
+{
+	vec4_t lowLight;
+	const vec4_t greyColor = { .5, .5, .5, 1};
+	menuDef_t *parent = (menuDef_t*)item->parent;
+
+	Fade(&item->window.flags, &item->window.foreColor[3], parent->fadeClamp, &item->window.nextTime, parent->fadeCycle, qtrue, parent->fadeAmount);
+
+	if ( !(item->type == ITEM_TYPE_TEXT && item->window.flags & WINDOW_AUTOWRAPPED) && item->window.flags & WINDOW_HASFOCUS) 
+	{
+		lowLight[0] = 0.8 * parent->focusColor[0]; 
+		lowLight[1] = 0.8 * parent->focusColor[1]; 
+		lowLight[2] = 0.8 * parent->focusColor[2]; 
+		lowLight[3] = 0.8 * parent->focusColor[3]; 
+		LerpColor(parent->focusColor,lowLight,*newColor,0.5+0.5*sin((float)(DC->realTime / PULSE_DIVISOR)));
+	} 
+/*	else if (item->textStyle == ITEM_TEXTSTYLE_BLINK && !((DC->realTime/BLINK_DIVISOR) & 1)) 
+	{
+		lowLight[0] = 0.8 * item->window.foreColor[0]; 
+		lowLight[1] = 0.8 * item->window.foreColor[1]; 
+		lowLight[2] = 0.8 * item->window.foreColor[2]; 
+		lowLight[3] = 0.8 * item->window.foreColor[3]; 
+		LerpColor(item->window.foreColor,lowLight,*newColor,0.5+0.5*sin(DC->realTime / PULSE_DIVISOR));
+	} 
+*/	else 
+	{
+		memcpy(newColor, &item->window.foreColor, sizeof(vec4_t));
+	}
+
+	// items can be enabled and disabled based on cvars
+	if (item->enableCvar && *item->enableCvar && item->cvarTest && *item->cvarTest) 
+	{
+		if (item->cvarFlags & (CVAR_ENABLE | CVAR_DISABLE) && !Item_EnableShowViaCvar(item, CVAR_ENABLE)) 
+		{
+			memcpy(newColor, &parent->disableColor, sizeof(vec4_t));
+		}
+	}
+
+	if (item->window.flags & WINDOW_INACTIVE)
+	{
+		memcpy(newColor, &greyColor, sizeof(vec4_t));
+	}
+}
+
+/*
+=================
+Item_Text_Wrapped_Paint
+=================
+*/
+void Item_Text_Wrapped_Paint(itemDef_t *item) 
+{
+	char text[1024];
+	const char *p, *start, *textPtr;
+	char buff[1024];
+	int width, height;
+	float x, y;
+	vec4_t color;
+
+	// now paint the text and/or any optional images
+	// default to left
+
+	if (item->text == NULL) 
+	{
+		if (item->cvar == NULL) 
+		{
+			return;
+		}
+		else 
+		{
+			DC->getCVarString(item->cvar, text, sizeof(text));
+			textPtr = text;
+		}
+	}
+	else 
+	{
+		textPtr = item->text;
+	}
+	if (*textPtr == '@')	// string reference
+	{
+		textPtr = SE_GetString( &textPtr[1] );
+	}
+
+	if (*textPtr == '\0') 
+	{
+		return;
+	}
+
+	Item_TextColor(item, &color);
+	Item_SetTextExtents(item, &width, &height, textPtr);
+
+	x = item->textRect.x;
+	y = item->textRect.y;
+	start = textPtr;
+	p = strchr(textPtr, '\r');
+	while (p && *p) 
+	{
+		strncpy(buff, start, p-start+1);
+		buff[p-start] = '\0';
+		DC->drawText(x, y, item->textscale, color, buff, 0, item->textStyle, item->font);
+		y += height + 5;
+		start += p - start + 1;
+		p = strchr(p+1, '\r');
+	}
+	DC->drawText(x, y, item->textscale, color, start, 0, item->textStyle, item->font);
+}
+
+
+/*
+=================
+Menu_Paint
+=================
+*/
+void Item_Text_Paint(itemDef_t *item) 
+{
+	char text[1024];
+	const char *textPtr;
+	int height, width;
+	vec4_t color;
+
+	if (item->window.flags & WINDOW_WRAPPED) 
+	{
+		Item_Text_Wrapped_Paint(item);
+		return;
+	}
+
+	if (item->window.flags & WINDOW_AUTOWRAPPED) 
+	{
+		Item_Text_AutoWrapped_Paint(item);
+		return;
+	}
+
+	if (item->text == NULL) 
+	{
+		if (item->cvar == NULL) 
+		{
+			return;
+		}
+		else 
+		{
+			DC->getCVarString(item->cvar, text, sizeof(text));
+			textPtr = text;
+		}
+	}
+	else 
+	{
+		textPtr = item->text;
+	}
+	if (*textPtr == '@')	// string reference
+	{
+		textPtr = SE_GetString( &textPtr[1] );
+	}
+
+	// this needs to go here as it sets extents for cvar types as well
+	Item_SetTextExtents(item, &width, &height, textPtr);
+
+	if (*textPtr == '\0') 
+	{
+		return;
+	}
+
+	Item_TextColor(item, &color);
+	DC->drawText(item->textRect.x, item->textRect.y, item->textscale, color, textPtr, 0, item->textStyle, item->font);
+
+	if (item->text2)	// Is there a second line of text?
+	{
+		textPtr = item->text2;
+		if (*textPtr == '@')	// string reference
+		{
+			textPtr = SE_GetString( &textPtr[1] );
+		}
+
+		Item_TextColor(item, &color);
+		DC->drawText(item->textRect.x + item->text2alignx, item->textRect.y + item->text2aligny, item->textscale, color, textPtr, 0, item->textStyle, item->font);
+	}
+}
+
+/*
+=================
+Item_UpdatePosition
+=================
+*/
+// FIXME: consolidate this with nearby stuff
+void Item_UpdatePosition(itemDef_t *item) 
+{
+	float x, y;
+	menuDef_t *menu;
+
+	if (item == NULL || item->parent == NULL) 
+	{
+		return;
+	}
+
+	menu = (menuDef_t *) item->parent;
+
+	x = menu->window.rect.x;
+	y = menu->window.rect.y;
+
+	if (menu->window.border != 0) 
+	{
+		x += menu->window.borderSize;
+		y += menu->window.borderSize;
+	}
+
+	Item_SetScreenCoords(item, x, y);
+
+}
+
+/*
+=================
+Item_TextField_Paint
+=================
+*/
+void Item_TextField_Paint(itemDef_t *item) 
+{
+	char buff[1024];
+	vec4_t newColor, lowLight;
+	int offset;
+	menuDef_t *parent = (menuDef_t*)item->parent;
+	editFieldDef_t *editPtr = (editFieldDef_t*)item->typeData;
+
+	Item_Text_Paint(item);
+
+	buff[0] = '\0';
+
+	if (item->cvar) 
+	{
+		DC->getCVarString(item->cvar, buff, sizeof(buff));
+	} 
+
+	parent = (menuDef_t*)item->parent;
+
+	if (item->window.flags & WINDOW_HASFOCUS) 
+	{
+		lowLight[0] = 0.8 * parent->focusColor[0]; 
+		lowLight[1] = 0.8 * parent->focusColor[1]; 
+		lowLight[2] = 0.8 * parent->focusColor[2]; 
+		lowLight[3] = 0.8 * parent->focusColor[3]; 
+		LerpColor(parent->focusColor,lowLight,newColor,0.5+0.5*sin((float)(DC->realTime / PULSE_DIVISOR)));
+	} 
+	else 
+	{
+		memcpy(&newColor, &item->window.foreColor, sizeof(vec4_t));
+	}
+
+	offset = 8;//(item->text && *item->text) ? 8 : 0;
+	if (item->window.flags & WINDOW_HASFOCUS && g_editingField) 
+	{
+		char cursor = DC->getOverstrikeMode() ? '_' : '|';
+		DC->drawTextWithCursor(item->textRect.x + item->textRect.w + offset, item->textRect.y, item->textscale, newColor, buff + editPtr->paintOffset, item->cursorPos - editPtr->paintOffset , cursor, /*editPtr->maxPaintChars*/ item->window.rect.w, item->textStyle, item->font);
+	} 
+	else 
+	{
+		DC->drawText(item->textRect.x + item->textRect.w + offset, item->textRect.y, item->textscale, newColor, buff + editPtr->paintOffset, /*editPtr->maxPaintChars*/ item->window.rect.w, item->textStyle, item->font);
+	}
+}
+
+void Item_TextScroll_Paint(itemDef_t *item) 
+{
+	char cvartext[1024];
+	float x, y, size, count, thumb;
+	int	  i;
+	textScrollDef_t *scrollPtr = (textScrollDef_t*)item->typeData;
+
+	size = item->window.rect.h - 2;
+
+	// Re-arranged this function. Previous version had a plethora of bugs.
+	// Still a little iffy - BTO (VV)
+	if (item->cvar) 
+	{
+		DC->getCVarString(item->cvar, cvartext, sizeof(cvartext));
+		item->text = cvartext;
+	}
+
+	Item_TextScroll_BuildLines ( item );
+	count = scrollPtr->iLineCount;
+
+	// Draw scroll bar if text goes beyond bottom 
+	if (( scrollPtr->iLineCount * scrollPtr->lineHeight ) > size)
+	{
+		// draw scrollbar to right side of the window
+		x = item->window.rect.x + item->window.rect.w - SCROLLBAR_SIZE - 1;
+		y = item->window.rect.y + 1;
+		DC->drawHandlePic(x, y, SCROLLBAR_SIZE, SCROLLBAR_SIZE, DC->Assets.scrollBarArrowUp);
+		y += SCROLLBAR_SIZE - 1;
+
+		scrollPtr->endPos = scrollPtr->startPos;
+		size = item->window.rect.h - (SCROLLBAR_SIZE * 2);
+		DC->drawHandlePic(x, y, SCROLLBAR_SIZE, size+1, DC->Assets.scrollBar);
+		y += size - 1;
+		DC->drawHandlePic(x, y, SCROLLBAR_SIZE, SCROLLBAR_SIZE, DC->Assets.scrollBarArrowDown);
+		
+		// thumb
+		thumb = Item_TextScroll_ThumbDrawPosition(item);
+		if (thumb > y - SCROLLBAR_SIZE - 1) 
+		{
+			thumb = y - SCROLLBAR_SIZE - 1;
+		}
+		DC->drawHandlePic(x, thumb, SCROLLBAR_SIZE, SCROLLBAR_SIZE, DC->Assets.scrollBarThumb);
+	}
+
+	// adjust size for item painting
+	size = item->window.rect.h - 2;
+	x	 = item->window.rect.x + item->textalignx + 1;
+	y	 = item->window.rect.y + item->textaligny + 1;
+
+
+	for (i = scrollPtr->startPos; i < count; i++) 
+	{
+		const char *text;
+
+		text = scrollPtr->pLines[i];
+		if (!text) 
+		{
+			continue;
+		}
+
+		DC->drawText(x + 4, y, item->textscale, item->window.foreColor, text, 0, item->textStyle, item->font);
+
+		size -= scrollPtr->lineHeight;
+		if (size < scrollPtr->lineHeight) 
+		{
+			scrollPtr->drawPadding = scrollPtr->lineHeight - size;
+			break;
+		}
+
+		scrollPtr->endPos++;
+		y += scrollPtr->lineHeight;
+	}
+}
+
+/*
+=================
+Item_ListBox_Paint
+=================
+*/
+
+void Item_ListBox_Paint(itemDef_t *item) 
+{
+	float x, y, size;
+	int count, i, thumb;
+	qhandle_t image;
+	qhandle_t optionalImage;
+	listBoxDef_t *listPtr = (listBoxDef_t*)item->typeData;
+//JLF MPMOVED
+	int numlines;
+
+	// the listbox is horizontal or vertical and has a fixed size scroll bar going either direction
+	// elements are enumerated from the DC and either text or image handles are acquired from the DC as well
+	// textscale is used to size the text, textalignx and textaligny are used to size image elements
+	// there is no clipping available so only the last completely visible item is painted
+	count = DC->feederCount(item->special);
+
+//JLFLISTBOX MPMOVED
+#ifdef _XBOX
+	listPtr->startPos =	item->cursorPos;
+//	item->cursorPos = listPtr->startPos;
+#endif
+//JLFLISTBOX
+
+	if (listPtr->startPos > (count?count-1:count))
+	{//probably changed feeders, so reset
+		listPtr->startPos = 0;
+	}
+
+	if (item->cursorPos > (count?count-1:count))
+	{//probably changed feeders, so reset
+		item->cursorPos = 0;
+	}
+	// default is vertical if horizontal flag is not here
+	if (item->window.flags & WINDOW_HORIZONTAL) 
+	{
+//JLF new variable (code just indented)
+		if (!listPtr->scrollhidden)
+		{
+			// draw scrollbar in bottom of the window
+			// bar
+			if (Item_ListBox_MaxScroll(item) > 0) 
+			{
+				x = item->window.rect.x + 1;
+				y = item->window.rect.y + item->window.rect.h - SCROLLBAR_SIZE - 1;
+				DC->drawHandlePic(x, y, SCROLLBAR_SIZE, SCROLLBAR_SIZE, DC->Assets.scrollBarArrowLeft);
+				x += SCROLLBAR_SIZE - 1;
+				size = item->window.rect.w - (SCROLLBAR_SIZE * 2);
+				DC->drawHandlePic(x, y, size+1, SCROLLBAR_SIZE, DC->Assets.scrollBar);
+				x += size - 1;
+				DC->drawHandlePic(x, y, SCROLLBAR_SIZE, SCROLLBAR_SIZE, DC->Assets.scrollBarArrowRight);
+				// thumb
+				thumb = Item_ListBox_ThumbDrawPosition(item);//Item_ListBox_ThumbPosition(item);
+				if (thumb > x - SCROLLBAR_SIZE - 1) 
+				{
+					thumb = x - SCROLLBAR_SIZE - 1;
+				}
+				DC->drawHandlePic(thumb, y, SCROLLBAR_SIZE, SCROLLBAR_SIZE, DC->Assets.scrollBarThumb);
+			}
+			else if (listPtr->startPos > 0)
+			{
+				listPtr->startPos = 0;
+			}
+		}
+//JLF end
+		//
+		listPtr->endPos = listPtr->startPos;
+		size = item->window.rect.w - 2;
+		// items
+		// size contains max available space
+		if (listPtr->elementStyle == LISTBOX_IMAGE) 
+		{
+			// fit = 0;
+			x = item->window.rect.x + 1;
+			y = item->window.rect.y + 1;
+			for (i = listPtr->startPos; i < count; i++) 
+			{
+				// always draw at least one
+				// which may overdraw the box if it is too small for the element
+				image = DC->feederItemImage(item->special, i);
+				if (image) 
+				{
+					if (item->window.flags & WINDOW_PLAYERCOLOR) 
+					{
+						vec4_t	color;
+						color[0] = ui_char_color_red.integer/255.0f;
+						color[1] = ui_char_color_green.integer/255.0f;
+						color[2] = ui_char_color_blue.integer/255.0f;
+						color[3] = 1;
+						ui.R_SetColor(color);
+					}
+					DC->drawHandlePic(x+1, y+1, listPtr->elementWidth - 2, listPtr->elementHeight - 2, image);
+				}
+
+				if (i == item->cursorPos) 
+				{
+					DC->drawRect(x, y, listPtr->elementWidth-1, listPtr->elementHeight-1, item->window.borderSize, item->window.borderColor);
+				}
+
+				size -= listPtr->elementWidth;
+				if (size < listPtr->elementWidth) 
+				{
+					listPtr->drawPadding = size; //listPtr->elementWidth - size;
+					break;
+				}
+				x += listPtr->elementWidth;
+				listPtr->endPos++;
+				// fit++;
+			}
+		} 
+		else 
+		{
+			//
+		}
+	}
+	else 
+	{
+//JLF MPMOVED
+		numlines = item->window.rect.h / listPtr->elementHeight;
+//JLFEND
+//JLF new variable (code idented with if)
+		if (!listPtr->scrollhidden)
+		{
+			// draw scrollbar to right side of the window
+			x = item->window.rect.x + item->window.rect.w - SCROLLBAR_SIZE - 1;
+			y = item->window.rect.y + 1;
+			DC->drawHandlePic(x, y, SCROLLBAR_SIZE, SCROLLBAR_SIZE, DC->Assets.scrollBarArrowUp);
+			y += SCROLLBAR_SIZE - 1;
+
+			listPtr->endPos = listPtr->startPos;
+			size = item->window.rect.h - (SCROLLBAR_SIZE * 2);
+			DC->drawHandlePic(x, y, SCROLLBAR_SIZE, size+1, DC->Assets.scrollBar);
+			y += size - 1;
+			DC->drawHandlePic(x, y, SCROLLBAR_SIZE, SCROLLBAR_SIZE, DC->Assets.scrollBarArrowDown);
+			// thumb
+			thumb = Item_ListBox_ThumbDrawPosition(item);//Item_ListBox_ThumbPosition(item);
+			if (thumb > y - SCROLLBAR_SIZE - 1) 
+			{
+				thumb = y - SCROLLBAR_SIZE - 1;
+			}
+			DC->drawHandlePic(x, thumb, SCROLLBAR_SIZE, SCROLLBAR_SIZE, DC->Assets.scrollBarThumb);
+		}
+//JLF end
+		// adjust size for item painting
+		size = item->window.rect.h - 2;
+		if (listPtr->elementStyle == LISTBOX_IMAGE) 
+		{
+			// fit = 0;
+			x = item->window.rect.x + 1;
+			y = item->window.rect.y + 1;
+
+			for (i = listPtr->startPos; i < count; i++) 
+			{
+				// always draw at least one
+				// which may overdraw the box if it is too small for the element
+				image = DC->feederItemImage(item->special, i);
+				if (image) 
+				{
+					DC->drawHandlePic(x+1, y+1, listPtr->elementWidth - 2, listPtr->elementHeight - 2, image);
+				}
+
+				if (i == item->cursorPos) 
+				{
+					DC->drawRect(x, y, listPtr->elementWidth - 1, listPtr->elementHeight - 1, item->window.borderSize, item->window.borderColor);
+				}
+
+				listPtr->endPos++;
+				size -= listPtr->elementHeight;
+				if (size < listPtr->elementHeight) 
+				{
+					listPtr->drawPadding = listPtr->elementHeight - size;
+					break;
+				}
+				y += listPtr->elementHeight;
+				// fit++;
+			}
+		} 
+		else 
+		{
+			x = item->window.rect.x + 1;
+			y = item->window.rect.y + 1 - listPtr->elementHeight;
+//JLF MPMOVED
+#ifdef _XBOX 
+			i = listPtr->startPos - (numlines/2);
+#else
+			i = listPtr->startPos;
+#endif
+			for (; i < count; i++) 
+			{
+				const char *text;
+				// always draw at least one
+				// which may overdraw the box if it is too small for the element
+
+				if (listPtr->numColumns > 0) 
+				{
+					int j;
+					for (j = 0; j < listPtr->numColumns; j++) 
+					{
+						text = DC->feederItemText(item->special, i, j, &optionalImage);
+						if (text[0]=='@')
+						{
+							text = SE_GetString( &text[1] );
+						}
+
+						if (optionalImage >= 0) 
+						{
+							DC->drawHandlePic(x + 4 + listPtr->columnInfo[j].pos, y - 1 + listPtr->elementHeight / 2, listPtr->columnInfo[j].width, listPtr->columnInfo[j].width, optionalImage);
+						} 
+						else if (text) 
+						{
+							vec4_t	*color;
+							menuDef_t *parent = (menuDef_t*)item->parent;
+
+							// Use focus color is it has focus.
+							if (i == item->cursorPos) 
+							{
+								color = &parent->focusColor;
+							}
+							else
+							{
+								color = &item->window.foreColor;
+							}
+
+
+							int textyOffset;
+
+//JLF MPMOVED
+#ifdef _XBOX
+							float fScaleA = item->textscale;
+							textyOffset = DC->textHeight (text, fScaleA, item->font);
+							textyOffset *= -1;
+							textyOffset /=2;
+							textyOffset += listPtr->elementHeight/2;
+#else
+							textyOffset = 0;
+#endif
+
+
+							DC->drawText(x + 4 + listPtr->columnInfo[j].pos, y + listPtr->elementHeight+ textyOffset, item->textscale, *color, text, listPtr->columnInfo[j].maxChars, item->textStyle, item->font);
+						}
+					}
+				} 
+				else 
+				{
+//JLF MPMOVED
+#ifdef _XBOX
+					if (i >= 0)
+					{
+#endif
+						text = DC->feederItemText(item->special, i, 0, &optionalImage);
+						if (optionalImage >= 0) 
+						{
+							//DC->drawHandlePic(x + 4 + listPtr->elementHeight, y, listPtr->columnInfo[j].width, listPtr->columnInfo[j].width, optionalImage);
+						} 
+						else if (text) 
+						{
+							DC->drawText(x + 4, y + listPtr->elementHeight, item->textscale, item->window.foreColor, text, 0, item->textStyle, item->font);
+						}
+//JLF MPMOVED
+#ifdef _XBOX
+					}
+#endif
+				}
+
+				// The chosen text
+				if (i == item->cursorPos) 
+				{
+					DC->fillRect(x + 2, y + listPtr->elementHeight + 2, item->window.rect.w - SCROLLBAR_SIZE - 4, listPtr->elementHeight+2, item->window.outlineColor);
+				}
+
+				size -= listPtr->elementHeight;
+				if (size < listPtr->elementHeight) 
+				{
+					listPtr->drawPadding = listPtr->elementHeight - size;
+					break;
+				}
+				listPtr->endPos++;
+				y += listPtr->elementHeight;
+				// fit++;
+			}
+		}
+	}
+}
+
+char g_nameBind1[32];
+char g_nameBind2[32];
+
+typedef struct
+{
+	char*	name;
+	float	defaultvalue;
+	float	value;	
+} configcvar_t;
+
+
+
+/*
+=================
+BindingFromName
+=================
+*/
+void BindingFromName(const char *cvar) 
+{
+	int	i, b1, b2;
+
+	// iterate each command, set its default binding
+	for (i=0; i < g_bindCount; i++)
+	{
+		if (Q_stricmp(cvar, g_bindings[i].command) == 0) {
+			b1 = g_bindings[i].bind1;
+			if (b1 == -1) 
+			{
+				break;
+			}
+			DC->keynumToStringBuf( b1, g_nameBind1, sizeof(g_nameBind1) );
+// do NOT do this or it corrupts asian text!!!					Q_strupr(g_nameBind1);
+
+			b2 = g_bindings[i].bind2;
+			if (b2 != -1)
+			{
+				DC->keynumToStringBuf( b2, g_nameBind2, sizeof(g_nameBind2) );
+// do NOT do this or it corrupts asian text!!!//				Q_strupr(g_nameBind2);
+
+				strcat( g_nameBind1, va(" %s ",SE_GetString("MENUS_KEYBIND_OR" )) );
+				strcat( g_nameBind1, g_nameBind2 );
+			}
+			return;
+		}
+	}
+
+	strcpy(g_nameBind1, "???");
+}
+
+/*
+=================
+Item_Bind_Paint
+=================
+*/
+void Item_Bind_Paint(itemDef_t *item) 
+{
+	vec4_t	newColor, lowLight;
+	float	value,textScale,textWidth;
+	int		maxChars = 0, textHeight,yAdj,startingXPos;
+
+	menuDef_t *parent = (menuDef_t*)item->parent;
+	editFieldDef_t *editPtr = (editFieldDef_t*)item->typeData;
+
+	if (editPtr) 
+	{
+		maxChars = editPtr->maxPaintChars;
+	}
+
+	value = (item->cvar) ? DC->getCVarValue(item->cvar) : 0;
+
+	if (item->window.flags & WINDOW_HASFOCUS) 
+	{
+		if (g_bindItem == item) 
+		{
+			lowLight[0] = 0.8f * 1.0f;
+			lowLight[1] = 0.8f * 0.0f;
+			lowLight[2] = 0.8f * 0.0f;
+			lowLight[3] = 0.8f * 1.0f;
+		} 
+		else 
+		{
+			lowLight[0] = 0.8f * parent->focusColor[0]; 
+			lowLight[1] = 0.8f * parent->focusColor[1]; 
+			lowLight[2] = 0.8f * parent->focusColor[2]; 
+			lowLight[3] = 0.8f * parent->focusColor[3]; 
+		}
+		LerpColor(parent->focusColor,lowLight,newColor,0.5+0.5*sin((float)(DC->realTime / PULSE_DIVISOR)));
+	} 
+	else 
+	{
+		Item_TextColor(	item,&newColor);
+	}
+
+	if (item->text) 
+	{
+		Item_Text_Paint(item);
+		BindingFromName(item->cvar);
+
+		// If the text runs past the limit bring the scale down until it fits.
+		textScale = item->textscale;
+		textWidth = DC->textWidth(g_nameBind1,(float) textScale, uiInfo.uiDC.Assets.qhMediumFont);
+
+		startingXPos = (item->textRect.x + item->textRect.w + 8);
+
+		while ((startingXPos + textWidth) >= SCREEN_WIDTH)
+		{
+			textScale -= .05f;
+			textWidth = DC->textWidth(g_nameBind1,(float) textScale, uiInfo.uiDC.Assets.qhMediumFont);
+		}
+
+		// Try to adjust it's y placement if the scale has changed.
+		yAdj = 0;
+		if (textScale != item->textscale)
+		{
+			textHeight = DC->textHeight(g_nameBind1, item->textscale, uiInfo.uiDC.Assets.qhMediumFont);
+			yAdj = textHeight - DC->textHeight(g_nameBind1, textScale, uiInfo.uiDC.Assets.qhMediumFont);
+		}
+
+		DC->drawText(startingXPos, item->textRect.y + yAdj, textScale, newColor, g_nameBind1, maxChars/*item->textRect.w*/, item->textStyle, item->font);
+	} 
+	else 
+	{
+		DC->drawText(item->textRect.x, item->textRect.y, item->textscale, newColor, (value != 0) ? "FIXME 1" : "FIXME 0", maxChars/*item->textRect.w*/, item->textStyle, item->font);
+	}
+}
+
+void UI_ScaleModelAxis(refEntity_t	*ent)
+
+{		// scale the model should we need to
+		if (ent->modelScale[0] && ent->modelScale[0] != 1.0f)
+		{
+			VectorScale( ent->axis[0], ent->modelScale[0] , ent->axis[0] );
+			ent->nonNormalizedAxes = qtrue;
+		}
+		if (ent->modelScale[1] && ent->modelScale[1] != 1.0f)
+		{
+			VectorScale( ent->axis[1], ent->modelScale[1] , ent->axis[1] );
+			ent->nonNormalizedAxes = qtrue;
+		}
+		if (ent->modelScale[2] && ent->modelScale[2] != 1.0f)
+		{
+			VectorScale( ent->axis[2], ent->modelScale[2] , ent->axis[2] );
+			ent->nonNormalizedAxes = qtrue;
+		}
+}
+
+/*
+=================
+Item_Model_Paint
+=================
+*/
+#ifdef _XBOX
+extern int	*s_entityWavVol;
+#else
+extern int	s_entityWavVol[MAX_GENTITIES];	//from snd_dma.cpp
+#endif
+void UI_TalkingHead(itemDef_t *item) 
+{
+//	static int facial_blink = DC->realTime + Q_flrand(4000.0, 8000.0);
+	static int facial_timer = DC->realTime + Q_flrand(10000.0, 30000.0);
+//	static animNumber_t facial_anim = FACE_ALERT;
+	int anim = -1;
+
+	//are we blinking?
+/*	if (facial_blink < 0)
+	{	// yes, check if we are we done blinking ?
+		if (-(facial_blink) < DC->realTime)
+		{	// yes, so reset blink timer
+			facial_blink = DC->realTime + Q_flrand(4000.0, 8000.0);
+			CG_G2SetHeadBlink( cent, qfalse );	//stop the blink
+		}
+	}
+	else // no we aren't blinking 
+	{	
+		if (facial_blink < DC->realTime)// but should we start ?
+		{
+			CG_G2SetHeadBlink( cent, qtrue );
+			if (facial_blink == 1)
+			{//requested to stay shut by SET_FACEEYESCLOSED
+				facial_blink = -(DC->realTime + 99999999.0f);// set blink timer
+			}
+			else
+			{
+				facial_blink = -(DC->realTime + 300.0f);// set blink timer
+			}
+		} 
+	}
+*/	
+
+	if (s_entityWavVol[0] > 0)	// if we aren't talking, then it will be 0, -1 for talking but paused
+	{
+		anim = FACE_TALK1 + s_entityWavVol[0]-1;
+		if( anim > FACE_TALK4 )
+		{
+			anim = FACE_TALK4;
+		}
+		// reset timers so we don't start right away after talking
+		facial_timer = DC->realTime + Q_flrand(2000.0, 7000.0);
+	}
+	else if (s_entityWavVol[0] == -1)
+	{// talking, but silent
+		anim = FACE_TALK0;
+		// reset timers so we don't start right away after talking
+		facial_timer = DC->realTime + Q_flrand(2000.0, 7000.0);
+	}
+/*	else if (s_entityWavVol[0] == 0)	//don't anim if in a slient part of speech
+	{//not talking
+		if (facial_timer < 0)	// are animating ?
+		{	//yes
+			if (-(facial_timer) < DC->realTime)// are we done animating ?
+			{	// yes, reset timer
+				facial_timer = DC->realTime + Q_flrand(10000.0, 30000.0);
+			}
+			else
+			{	// not yet, so choose anim
+				anim = facial_anim;
+			}
+		}
+		else // no we aren't animating 
+		{	// but should we start ?
+			if (facial_timer < DC->realTime)
+			{//yes
+				facial_anim = FACE_ALERT + Q_irand(0,2);	//alert, smile, frown
+				// set aux timer
+				facial_timer = -(DC->realTime + 2000.0);
+				anim = facial_anim;
+			} 
+		}	
+	}//talking
+*/
+	if (facial_timer < DC->realTime)
+	{//restart the base anim
+//		modelDef_t *modelPtr = (modelDef_t*)item->typeData;
+		//ItemParse_model_g2anim_go( item, "BOTH_STAND5IDLE1" );
+//		facial_timer = DC->realTime + Q_flrand(2000.0, 7000.0) + DC->g2hilev_SetAnim(&item->ghoul2[0], "model_root", modelPtr->g2anim, qtrue);
+	}
+	if (anim != -1)
+	{
+		DC->g2hilev_SetAnim(&item->ghoul2[0], "face", anim, qfalse);
+	}
+}
+
+/*
+=================
+Item_Model_Paint
+=================
+*/
+extern void UI_SaberDrawBlades( itemDef_t *item, vec3_t origin, float curYaw );
+
+void Item_Model_Paint(itemDef_t *item) 
+{
+	float x, y, w, h;
+	refdef_t refdef;
+	refEntity_t		ent;
+	vec3_t			mins, maxs, origin;
+	vec3_t			angles;
+	const modelDef_t *modelPtr = (modelDef_t*)item->typeData;
+
+	if (modelPtr == NULL) 
+	{
+		return;
+	}
+
+	// a moves datapad anim is playing
+	if (uiInfo.moveAnimTime && (uiInfo.moveAnimTime < uiInfo.uiDC.realTime))
+	{ 
+		modelDef_t *modelPtr;
+		modelPtr = (modelDef_t*)item->typeData;
+		if (modelPtr)
+		{
+			//HACKHACKHACK: check for any multi-part anim sequences, and play the next anim, if needbe
+			switch( modelPtr->g2anim )
+			{
+			case BOTH_FORCEWALLREBOUND_FORWARD:
+			case BOTH_FORCEJUMP1: 
+				ItemParse_model_g2anim_go( item, animTable[BOTH_FORCEINAIR1].name );
+				uiInfo.moveAnimTime = DC->g2hilev_SetAnim(&item->ghoul2[0], "model_root", modelPtr->g2anim, qtrue);
+				if ( !uiInfo.moveAnimTime )
+				{
+					uiInfo.moveAnimTime = 500;
+				}
+				uiInfo.moveAnimTime += uiInfo.uiDC.realTime;
+				break;
+			case BOTH_FORCEINAIR1:
+				ItemParse_model_g2anim_go( item, animTable[BOTH_FORCELAND1].name );
+				uiInfo.moveAnimTime = DC->g2hilev_SetAnim(&item->ghoul2[0], "model_root", modelPtr->g2anim, qtrue);
+				uiInfo.moveAnimTime += uiInfo.uiDC.realTime;
+				break;
+			case BOTH_FORCEWALLRUNFLIP_START:
+				ItemParse_model_g2anim_go( item, animTable[BOTH_FORCEWALLRUNFLIP_END].name );
+				uiInfo.moveAnimTime = DC->g2hilev_SetAnim(&item->ghoul2[0], "model_root", modelPtr->g2anim, qtrue);
+				uiInfo.moveAnimTime += uiInfo.uiDC.realTime;
+				break;
+			case BOTH_FORCELONGLEAP_START:
+				ItemParse_model_g2anim_go( item, animTable[BOTH_FORCELONGLEAP_LAND].name );
+				uiInfo.moveAnimTime = DC->g2hilev_SetAnim(&item->ghoul2[0], "model_root", modelPtr->g2anim, qtrue);
+				uiInfo.moveAnimTime += uiInfo.uiDC.realTime;
+				break;
+			case BOTH_KNOCKDOWN3://on front - into force getup
+				DC->startLocalSound(uiInfo.uiDC.Assets.datapadmoveJumpSound, CHAN_LOCAL );
+				ItemParse_model_g2anim_go( item, animTable[BOTH_FORCE_GETUP_F1].name );
+				uiInfo.moveAnimTime = DC->g2hilev_SetAnim(&item->ghoul2[0], "model_root", modelPtr->g2anim, qtrue);
+				uiInfo.moveAnimTime += uiInfo.uiDC.realTime;
+				break;
+			case BOTH_KNOCKDOWN2://on back - kick forward getup
+				DC->startLocalSound(uiInfo.uiDC.Assets.datapadmoveJumpSound, CHAN_LOCAL );
+				ItemParse_model_g2anim_go( item, animTable[BOTH_GETUP_BROLL_F].name );
+				uiInfo.moveAnimTime = DC->g2hilev_SetAnim(&item->ghoul2[0], "model_root", modelPtr->g2anim, qtrue);
+				uiInfo.moveAnimTime += uiInfo.uiDC.realTime;
+				break;
+			case BOTH_KNOCKDOWN1://on back - roll-away
+				DC->startLocalSound(uiInfo.uiDC.Assets.datapadmoveRollSound, CHAN_LOCAL );
+				ItemParse_model_g2anim_go( item, animTable[BOTH_GETUP_BROLL_R].name );
+				uiInfo.moveAnimTime = DC->g2hilev_SetAnim(&item->ghoul2[0], "model_root", modelPtr->g2anim, qtrue);
+				uiInfo.moveAnimTime += uiInfo.uiDC.realTime;
+				break;
+			default:
+				ItemParse_model_g2anim_go( item, uiInfo.movesBaseAnim );
+				DC->g2hilev_SetAnim(&item->ghoul2[0], "model_root", modelPtr->g2anim, qtrue);
+				uiInfo.moveAnimTime = 0;
+				break;
+			}
+		}
+	}
+
+	// setup the refdef
+	memset( &refdef, 0, sizeof( refdef ) );
+	refdef.rdflags = RDF_NOWORLDMODEL;
+	AxisClear( refdef.viewaxis );
+	x = item->window.rect.x+1;
+	y = item->window.rect.y+1;
+	w = item->window.rect.w-2;
+	h = item->window.rect.h-2;
+
+	refdef.x = x * DC->xscale;
+	refdef.y = y * DC->yscale;
+	refdef.width = w * DC->xscale;
+	refdef.height = h * DC->yscale;
+
+	if (item->flags&ITF_G2VALID)
+	{ //ghoul2 models don't have bounds, so we have to parse them.
+		VectorCopy(modelPtr->g2mins, mins);
+		VectorCopy(modelPtr->g2maxs, maxs);
+
+		if (!mins[0] && !mins[1] && !mins[2] &&
+			!maxs[0] && !maxs[1] && !maxs[2])
+		{ //we'll use defaults then I suppose.
+			VectorSet(mins, -16, -16, -24);
+			VectorSet(maxs, 16, 16, 32);
+		}
+	}
+	else
+	{
+		DC->modelBounds( item->asset, mins, maxs );
+	}
+
+	origin[2] = -0.5 * ( mins[2] + maxs[2] );
+	origin[1] = 0.5 * ( mins[1] + maxs[1] );
+
+	refdef.fov_x = (modelPtr->fov_x) ? modelPtr->fov_x : (int)((float)refdef.width / 640.0f * 90.0f);
+	refdef.fov_y = (modelPtr->fov_y) ? modelPtr->fov_y : atan2( refdef.height, refdef.width / tan( refdef.fov_x / 360 * M_PI ) ) * ( 360 / M_PI );
+
+//	refdef.fov_x = (modelPtr->fov_x) ? modelPtr->fov_x : refdef.width;
+//	refdef.fov_y = (modelPtr->fov_y) ? modelPtr->fov_y : refdef.height;
+
+	// calculate distance so the model nearly fills the box
+	float len = 0.5 * ( maxs[2] - mins[2] );		
+	origin[0] = len / 0.268;
+
+	DC->clearScene();
+
+	refdef.time = DC->realTime;
+
+	// add the model
+
+	memset( &ent, 0, sizeof(ent) );
+
+	// use item storage to track
+	float curYaw = modelPtr->angle;
+	if (modelPtr->rotationSpeed) 
+	{
+		curYaw += (float)refdef.time/modelPtr->rotationSpeed;
+	}
+	if ( item->flags&ITF_ISANYSABER && !(item->flags&ITF_ISCHARACTER) )
+	{//hack to put saber on it's side
+		VectorSet( angles, curYaw, 0, 90 );
+	}
+	else
+	{
+		VectorSet( angles, 0, curYaw, 0 );
+	}
+
+	
+	AnglesToAxis( angles, ent.axis );
+
+	if (item->flags&ITF_G2VALID)
+	{
+		ent.ghoul2 = &item->ghoul2;
+		ent.radius = 1000;
+		ent.customSkin = modelPtr->g2skin;
+
+		if ( (item->flags&ITF_ISCHARACTER) )
+		{
+			ent.shaderRGBA[0] = ui_char_color_red.integer;
+			ent.shaderRGBA[1] = ui_char_color_green.integer;
+			ent.shaderRGBA[2] = ui_char_color_blue.integer;
+			ent.shaderRGBA[3] = 255;
+			UI_TalkingHead(item);
+		}
+		if ( item->flags&ITF_ISANYSABER )
+		{//UGH, draw the saber blade!
+			UI_SaberDrawBlades( item, origin, curYaw );
+		}
+	}
+	else
+	{
+		ent.hModel = item->asset;
+	}
+	VectorCopy( origin, ent.origin );
+	VectorCopy( ent.origin, ent.oldorigin );
+
+	// Set up lighting
+	//VectorCopy( refdef.vieworg, ent.lightingOrigin );
+	//ent.renderfx = RF_LIGHTING_ORIGIN | RF_NOSHADOW;
+	ent.renderfx = RF_NOSHADOW ;
+	ui.R_AddLightToScene(refdef.vieworg, 500, 1, 1, 1);	//fixme: specify in menu file!
+
+	DC->addRefEntityToScene( &ent );
+	DC->renderScene( &refdef );
+
+}
+
+/*
+=================
+Item_OwnerDraw_Paint
+=================
+*/
+void Item_OwnerDraw_Paint(itemDef_t *item) 
+{
+	menuDef_t *parent;
+
+	if (item == NULL) 
+	{
+		return;
+	}
+
+	parent = (menuDef_t*)item->parent;
+
+	if (DC->ownerDrawItem) 
+	{
+		vec4_t color, lowLight;
+		menuDef_t *parent = (menuDef_t*)item->parent;
+		Fade(&item->window.flags, &item->window.foreColor[3], parent->fadeClamp, &item->window.nextTime, parent->fadeCycle, qtrue, parent->fadeAmount);
+		memcpy(&color, &item->window.foreColor, sizeof(color));
+		if (item->numColors > 0 && DC->getValue) 
+		{
+			// if the value is within one of the ranges then set color to that, otherwise leave at default
+			int i;
+			float f = DC->getValue(item->window.ownerDraw);
+			for (i = 0; i < item->numColors; i++) 
+			{
+				if (f >= item->colorRanges[i].low && f <= item->colorRanges[i].high) 
+				{
+					memcpy(&color, &item->colorRanges[i].color, sizeof(color));
+					break;
+				}
+			}
+		}
+
+		if (item->window.flags & WINDOW_HASFOCUS) 
+		{
+			lowLight[0] = 0.8 * parent->focusColor[0]; 
+			lowLight[1] = 0.8 * parent->focusColor[1]; 
+			lowLight[2] = 0.8 * parent->focusColor[2]; 
+			lowLight[3] = 0.8 * parent->focusColor[3]; 
+			LerpColor(parent->focusColor,lowLight,color,0.5+0.5*sin((float)(DC->realTime / PULSE_DIVISOR)));
+		} 
+		else if (item->textStyle == ITEM_TEXTSTYLE_BLINK && !((DC->realTime/BLINK_DIVISOR) & 1)) 
+		{
+			lowLight[0] = 0.8 * item->window.foreColor[0]; 
+			lowLight[1] = 0.8 * item->window.foreColor[1]; 
+			lowLight[2] = 0.8 * item->window.foreColor[2]; 
+			lowLight[3] = 0.8 * item->window.foreColor[3]; 
+			LerpColor(item->window.foreColor,lowLight,color,0.5+0.5*sin((float)(DC->realTime / PULSE_DIVISOR)));
+		}
+
+		if (item->cvarFlags & (CVAR_ENABLE | CVAR_DISABLE) && !Item_EnableShowViaCvar(item, CVAR_ENABLE)) 
+		{
+			memcpy(color, parent->disableColor, sizeof(vec4_t));
+		}
+	
+		if (item->text) 
+		{
+			Item_Text_Paint(item);
+
+			// +8 is an offset kludge to properly align owner draw items that have text combined with them
+			DC->ownerDrawItem(item->textRect.x + item->textRect.w + 8, item->window.rect.y, item->window.rect.w, item->window.rect.h, 0, item->textaligny, item->window.ownerDraw, item->window.ownerDrawFlags, item->alignment, item->special, item->textscale, color, item->window.background, item->textStyle, item->font );
+		} 
+		else 
+		{
+			DC->ownerDrawItem(item->window.rect.x, item->window.rect.y, item->window.rect.w, item->window.rect.h, item->textalignx, item->textaligny, item->window.ownerDraw, item->window.ownerDrawFlags, item->alignment, item->special, item->textscale, color, item->window.background, item->textStyle, item->font );
+		}
+	}
+}
+
+void Item_YesNo_Paint(itemDef_t *item) 
+{
+	vec4_t newColor, lowLight;
+	float value;
+	menuDef_t *parent = (menuDef_t*)item->parent;
+
+	value = (item->cvar) ? DC->getCVarValue(item->cvar) : 0;
+
+	if (item->window.flags & WINDOW_HASFOCUS) 
+	{
+		lowLight[0] = 0.8 * parent->focusColor[0]; 
+		lowLight[1] = 0.8 * parent->focusColor[1]; 
+		lowLight[2] = 0.8 * parent->focusColor[2]; 
+		lowLight[3] = 0.8 * parent->focusColor[3]; 
+		LerpColor(parent->focusColor,lowLight,newColor,0.5+0.5*sin((float)(DC->realTime / PULSE_DIVISOR)));
+	} 
+	else 
+	{
+		memcpy(&newColor, &item->window.foreColor, sizeof(vec4_t));
+	}
+
+	const char *psYes = SE_GetString( "MENUS_YES" );
+	const char *psNo  = SE_GetString( "MENUS_NO" );
+	const char *yesnovalue;
+	
+	if (item->invertYesNo)
+		yesnovalue = (value == 0) ? psYes : psNo;
+	else
+		yesnovalue = (value != 0) ? psYes : psNo;
+
+	if (item->text) 
+	{
+		Item_Text_Paint(item);
+//JLF
+#ifdef _XBOX
+		if (item->xoffset == 0)
+			DC->drawText(item->textRect.x + item->textRect.w + item->xoffset + 8, item->textRect.y, item->textscale, newColor, yesnovalue, 0, item->textStyle, item->font);
+		else
+#endif
+			DC->drawText(item->textRect.x + item->textRect.w + 8, item->textRect.y, item->textscale, newColor, yesnovalue, 0, item->textStyle, item->font);
+
+	} 
+	else 
+	{
+//JLF
+#ifdef _XBOX
+		DC->drawText(item->textRect.x + item->xoffset, item->textRect.y, item->textscale, newColor, yesnovalue , 0, item->textStyle, item->font);
+#else
+		DC->drawText(item->textRect.x, item->textRect.y, item->textscale, newColor, yesnovalue , 0, item->textStyle, item->font);
+#endif
+	}		
+			
+}
+
+/*
+=================
+Item_Multi_Paint
+=================
+*/
+void Item_Multi_Paint(itemDef_t *item) 
+{
+	vec4_t newColor, lowLight;
+	const char *text = "";
+	menuDef_t *parent = (menuDef_t*)item->parent;
+
+	if (item->window.flags & WINDOW_HASFOCUS) 
+	{
+		lowLight[0] = 0.8 * parent->focusColor[0]; 
+		lowLight[1] = 0.8 * parent->focusColor[1]; 
+		lowLight[2] = 0.8 * parent->focusColor[2]; 
+		lowLight[3] = 0.8 * parent->focusColor[3]; 
+		LerpColor(parent->focusColor,lowLight,newColor,0.5+0.5*sin((float)(DC->realTime / PULSE_DIVISOR)));
+	} 
+	else 
+	{
+		memcpy(&newColor, &item->window.foreColor, sizeof(vec4_t));
+	}
+
+	text = Item_Multi_Setting(item);
+	if (*text == '@')	// string reference
+	{
+		text = SE_GetString( &text[1] );
+	}
+
+
+	if (item->text) 
+	{
+		Item_Text_Paint(item);
+//JLF
+#ifdef _XBOX
+		if ( item->xoffset)
+			DC->drawText(item->textRect.x + item->textRect.w + item->xoffset, item->textRect.y, item->textscale, newColor, text, 0, item->textStyle, item->font);
+		else
+#endif
+		DC->drawText(item->textRect.x + item->textRect.w + 8, item->textRect.y, item->textscale, newColor, text, 0, item->textStyle, item->font);
+	} 
+	else 
+	{
+//JLF added xoffset
+		DC->drawText(item->textRect.x +item->xoffset, item->textRect.y, item->textscale, newColor, text, 0, item->textStyle, item->font);
+	}
+}
+
+int Item_TextScroll_MaxScroll ( itemDef_t *item ) 
+{
+	textScrollDef_t *scrollPtr = (textScrollDef_t*)item->typeData;
+	
+	int count = scrollPtr->iLineCount;
+	int max   = count - (int)(item->window.rect.h / scrollPtr->lineHeight) + 1;
+
+	if (max < 0) 
+	{
+		return 0;
+	}
+
+	return max;
+}
+
+int Item_TextScroll_ThumbPosition ( itemDef_t *item ) 
+{
+	float max, pos, size;
+	textScrollDef_t *scrollPtr = (textScrollDef_t*)item->typeData;
+
+	max  = Item_TextScroll_MaxScroll ( item );
+	size = item->window.rect.h - (SCROLLBAR_SIZE * 2) - 2;
+
+	if (max > 0) 
+	{
+		pos = (size-SCROLLBAR_SIZE) / (float) max;
+	} 
+	else 
+	{
+		pos = 0;
+	}
+	
+	pos *= scrollPtr->startPos;
+	
+	return item->window.rect.y + 1 + SCROLLBAR_SIZE + pos;
+}
+
+int Item_TextScroll_ThumbDrawPosition ( itemDef_t *item ) 
+{
+	int min, max;
+
+	if (itemCapture == item) 
+	{
+		min = item->window.rect.y + SCROLLBAR_SIZE + 1;
+		max = item->window.rect.y + item->window.rect.h - 2*SCROLLBAR_SIZE - 1;
+
+		if (DC->cursory >= min + SCROLLBAR_SIZE/2 && DC->cursory <= max + SCROLLBAR_SIZE/2) 
+		{
+			return DC->cursory - SCROLLBAR_SIZE/2;
+		}
+
+		return Item_TextScroll_ThumbPosition(item);
+	}
+
+	return Item_TextScroll_ThumbPosition(item);
+}
+
+int Item_TextScroll_OverLB ( itemDef_t *item, float x, float y ) 
+{
+	rectDef_t		r;
+	textScrollDef_t *scrollPtr;
+	int				thumbstart;
+	int				count;
+
+	scrollPtr = (textScrollDef_t*)item->typeData;
+	count     = scrollPtr->iLineCount;
+
+	// Scroll bar isn't drawing so ignore this input 
+	if ((( scrollPtr->iLineCount * scrollPtr->lineHeight ) <= (item->window.rect.h - 2)) && (item->type == ITEM_TYPE_TEXTSCROLL))
+	{
+		return 0;
+	}
+
+	r.x = item->window.rect.x + item->window.rect.w - SCROLLBAR_SIZE;
+	r.y = item->window.rect.y;
+	r.h = r.w = SCROLLBAR_SIZE;
+	if (Rect_ContainsPoint(&r, x, y)) 
+	{
+		return WINDOW_LB_LEFTARROW;
+	}
+
+	r.y = item->window.rect.y + item->window.rect.h - SCROLLBAR_SIZE;
+	if (Rect_ContainsPoint(&r, x, y)) 
+	{
+		return WINDOW_LB_RIGHTARROW;
+	}
+
+	thumbstart = Item_TextScroll_ThumbPosition(item);
+	r.y = thumbstart;
+	if (Rect_ContainsPoint(&r, x, y)) 
+	{
+		return WINDOW_LB_THUMB;
+	}
+
+	r.y = item->window.rect.y + SCROLLBAR_SIZE;
+	r.h = thumbstart - r.y;
+	if (Rect_ContainsPoint(&r, x, y)) 
+	{
+		return WINDOW_LB_PGUP;
+	}
+
+	r.y = thumbstart + SCROLLBAR_SIZE;
+	r.h = item->window.rect.y + item->window.rect.h - SCROLLBAR_SIZE;
+	if (Rect_ContainsPoint(&r, x, y)) 
+	{
+		return WINDOW_LB_PGDN;
+	}
+
+	return 0;
+}
+
+void Item_TextScroll_MouseEnter (itemDef_t *item, float x, float y) 
+{
+	item->window.flags &= ~(WINDOW_LB_LEFTARROW | WINDOW_LB_RIGHTARROW | WINDOW_LB_THUMB | WINDOW_LB_PGUP | WINDOW_LB_PGDN);
+	item->window.flags |= Item_TextScroll_OverLB(item, x, y);
+}
+
+/*
+=================
+Item_Slider_ThumbPosition
+=================
+*/
+int Item_ListBox_ThumbDrawPosition(itemDef_t *item) 
+{
+	int min, max;
+
+	if (itemCapture == item) 
+	{
+		if (item->window.flags & WINDOW_HORIZONTAL) 
+		{
+			min = item->window.rect.x + SCROLLBAR_SIZE + 1;
+			max = item->window.rect.x + item->window.rect.w - 2*SCROLLBAR_SIZE - 1;
+			if (DC->cursorx >= min + SCROLLBAR_SIZE/2 && DC->cursorx <= max + SCROLLBAR_SIZE/2) 
+			{
+				return DC->cursorx - SCROLLBAR_SIZE/2;
+			}
+			else 
+			{
+				return Item_ListBox_ThumbPosition(item);
+			}
+		}
+		else 
+		{
+			min = item->window.rect.y + SCROLLBAR_SIZE + 1;
+			max = item->window.rect.y + item->window.rect.h - 2*SCROLLBAR_SIZE - 1;
+			if (DC->cursory >= min + SCROLLBAR_SIZE/2 && DC->cursory <= max + SCROLLBAR_SIZE/2) 
+			{
+				return DC->cursory - SCROLLBAR_SIZE/2;
+			}
+			else 
+			{
+				return Item_ListBox_ThumbPosition(item);
+			}
+		}
+	}
+	else 
+	{
+		return Item_ListBox_ThumbPosition(item);
+	}
+}
+
+/*
+=================
+Item_Slider_ThumbPosition
+=================
+*/
+float Item_Slider_ThumbPosition(itemDef_t *item) 
+{
+	float value, range, x;
+	editFieldDef_t *editDef = (editFieldDef_t *) item->typeData;
+
+	if (item->text) 
+	{
+		x = item->textRect.x + item->textRect.w + 8;
+	} 
+	else 
+	{
+		x = item->window.rect.x;
+	}
+
+	if (editDef == NULL && item->cvar) 
+	{
+		return x;
+	}
+
+	value = DC->getCVarValue(item->cvar);
+
+	if (value < editDef->minVal) 
+	{
+		value = editDef->minVal;
+	} 
+	else if (value > editDef->maxVal) 
+	{
+		value = editDef->maxVal;
+	}
+
+	range = editDef->maxVal - editDef->minVal;
+	value -= editDef->minVal;
+	value /= range;
+	//value /= (editDef->maxVal - editDef->minVal);
+	value *= SLIDER_WIDTH;
+	x += value;
+	// vm fuckage
+	//x = x + (((float)value / editDef->maxVal) * SLIDER_WIDTH);
+	return x;
+}
+
+/*
+=================
+Item_Slider_Paint
+=================
+*/
+void Item_Slider_Paint(itemDef_t *item) 
+{
+	vec4_t newColor, lowLight;
+	float x, y, value;
+	menuDef_t *parent = (menuDef_t*)item->parent;
+
+	value = (item->cvar) ? DC->getCVarValue(item->cvar) : 0;
+
+	if (item->window.flags & WINDOW_HASFOCUS) 
+	{
+		lowLight[0] = 0.8 * parent->focusColor[0]; 
+		lowLight[1] = 0.8 * parent->focusColor[1]; 
+		lowLight[2] = 0.8 * parent->focusColor[2]; 
+		lowLight[3] = 0.8 * parent->focusColor[3]; 
+		LerpColor(parent->focusColor,lowLight,newColor,0.5+0.5*sin((float)(DC->realTime / PULSE_DIVISOR)));
+	} 
+	else 
+	{
+		memcpy(&newColor, &item->window.foreColor, sizeof(vec4_t));
+	}
+
+	y = item->window.rect.y;
+	if (item->text) 
+	{
+		Item_Text_Paint(item);
+		x = item->textRect.x + item->textRect.w + 8;
+	} 
+	else 
+	{
+		x = item->window.rect.x;
+	}
+	DC->setColor(newColor);
+	DC->drawHandlePic( x, y+2, SLIDER_WIDTH, SLIDER_HEIGHT, DC->Assets.sliderBar );
+
+	x = Item_Slider_ThumbPosition(item);
+//	DC->drawHandlePic( x - (SLIDER_THUMB_WIDTH / 2), y - 2, SLIDER_THUMB_WIDTH, SLIDER_THUMB_HEIGHT, DC->Assets.sliderThumb );
+	DC->drawHandlePic( x - (SLIDER_THUMB_WIDTH / 2), y+2, SLIDER_THUMB_WIDTH, SLIDER_THUMB_HEIGHT, DC->Assets.sliderThumb );
+
+}
+
+/*
+=================
+Item_Paint
+=================
+*/
+static qboolean Item_Paint(itemDef_t *item, qboolean bDraw) 
+{
+	int		xPos,textWidth;
+	vec4_t red;
+	menuDef_t *parent = (menuDef_t*)item->parent;
+	red[0] = red[3] = 1;
+	red[1] = red[2] = 0;
+
+	if (item == NULL) 
+	{
+		return qfalse;
+	}
+
+	if (item->window.flags & WINDOW_SCRIPTWAITING)
+	{
+		if (DC->realTime > item->window.delayTime)
+		{ // Time has elapsed, resume running whatever script we saved
+			item->window.flags &= ~WINDOW_SCRIPTWAITING;
+			Item_RunScript(item, item->window.delayedScript);
+		}
+	}
+
+	if (item->window.flags & WINDOW_ORBITING) 
+	{
+		if (DC->realTime > item->window.nextTime) 
+		{
+			float rx, ry, a, c, s, w, h;
+			item->window.nextTime = DC->realTime + item->window.offsetTime;
+			// translate
+			w = item->window.rectClient.w / 2;
+			h = item->window.rectClient.h / 2;
+			rx = item->window.rectClient.x + w - item->window.rectEffects.x;
+			ry = item->window.rectClient.y + h - item->window.rectEffects.y;
+			a = (float) (3 * M_PI / 180);
+  			c = cos(a);
+			s = sin(a);
+			item->window.rectClient.x = (rx * c - ry * s) + item->window.rectEffects.x - w;
+			item->window.rectClient.y = (rx * s + ry * c) + item->window.rectEffects.y - h;
+			Item_UpdatePosition(item);
+
+		}
+	}
+
+
+	if (item->window.flags & WINDOW_INTRANSITION) 
+	{
+		if (DC->realTime > item->window.nextTime) 
+		{
+			int done = 0;
+			item->window.nextTime = DC->realTime + item->window.offsetTime;
+
+			// transition the x,y
+			if (item->window.rectClient.x == item->window.rectEffects.x) 
+			{
+				done++;
+			} 
+			else 
+			{
+				if (item->window.rectClient.x < item->window.rectEffects.x) 
+				{
+					item->window.rectClient.x += item->window.rectEffects2.x;
+					if (item->window.rectClient.x > item->window.rectEffects.x) 
+					{
+						item->window.rectClient.x = item->window.rectEffects.x;
+						done++;
+					}
+				} 
+				else 
+				{
+					item->window.rectClient.x -= item->window.rectEffects2.x;
+					if (item->window.rectClient.x < item->window.rectEffects.x) 
+					{
+						item->window.rectClient.x = item->window.rectEffects.x;
+						done++;
+					}
+				}
+			}
+
+			if (item->window.rectClient.y == item->window.rectEffects.y) 
+			{
+				done++;
+			} 
+			else 
+			{
+				if (item->window.rectClient.y < item->window.rectEffects.y) 
+				{
+					item->window.rectClient.y += item->window.rectEffects2.y;
+					if (item->window.rectClient.y > item->window.rectEffects.y) 
+					{
+						item->window.rectClient.y = item->window.rectEffects.y;
+						done++;
+					}
+				} 
+				else 
+				{
+					item->window.rectClient.y -= item->window.rectEffects2.y;
+					if (item->window.rectClient.y < item->window.rectEffects.y) 
+					{
+						item->window.rectClient.y = item->window.rectEffects.y;
+						done++;
+					}
+				}
+			}
+
+			if (item->window.rectClient.w == item->window.rectEffects.w) 
+			{
+				done++;
+			} 
+			else 
+			{
+				if (item->window.rectClient.w < item->window.rectEffects.w) 
+				{
+					item->window.rectClient.w += item->window.rectEffects2.w;
+					if (item->window.rectClient.w > item->window.rectEffects.w) 
+					{
+						item->window.rectClient.w = item->window.rectEffects.w;
+						done++;
+					}
+				} 
+				else 
+				{
+					item->window.rectClient.w -= item->window.rectEffects2.w;
+					if (item->window.rectClient.w < item->window.rectEffects.w) 
+					{
+						item->window.rectClient.w = item->window.rectEffects.w;
+						done++;
+					}
+				}
+			}
+
+			if (item->window.rectClient.h == item->window.rectEffects.h) 
+			{
+				done++;
+			} 
+			else 
+			{
+				if (item->window.rectClient.h < item->window.rectEffects.h) 
+				{
+					item->window.rectClient.h += item->window.rectEffects2.h;
+					if (item->window.rectClient.h > item->window.rectEffects.h) 
+					{
+						item->window.rectClient.h = item->window.rectEffects.h;
+						done++;
+					}
+				} 
+				else 
+				{
+					item->window.rectClient.h -= item->window.rectEffects2.h;
+					if (item->window.rectClient.h < item->window.rectEffects.h) 
+					{
+						item->window.rectClient.h = item->window.rectEffects.h;
+						done++;
+					}
+				}
+			}
+
+			Item_UpdatePosition(item);
+
+			if (done == 4) 
+			{
+				item->window.flags &= ~WINDOW_INTRANSITION;
+			}
+
+		}
+	}
+
+#ifdef _TRANS3
+	
+//JLF begin model transition stuff
+	if (item->window.flags & WINDOW_INTRANSITIONMODEL) 
+	{
+		if ( item->type == ITEM_TYPE_MODEL)
+		{
+//fields ing modelptr
+//				vec3_t g2mins2, g2maxs2, g2minsEffect, g2maxsEffect;
+//	float fov_x2, fov_y2, fov_Effectx, fov_Effecty;
+
+			modelDef_t  * modelptr = (modelDef_t *)item->typeData;
+
+			if (DC->realTime > item->window.nextTime) 
+			{
+				int done = 0;
+				item->window.nextTime = DC->realTime + item->window.offsetTime;
+
+
+// transition the x,y,z max
+				if (modelptr->g2maxs[0] == modelptr->g2maxs2[0]) 
+				{
+					done++;
+				} 
+				else 
+				{
+					if (modelptr->g2maxs[0] < modelptr->g2maxs2[0]) 
+					{
+						modelptr->g2maxs[0] += modelptr->g2maxsEffect[0];
+						if (modelptr->g2maxs[0] > modelptr->g2maxs2[0]) 
+						{
+							modelptr->g2maxs[0] = modelptr->g2maxs2[0];
+							done++;
+						}
+					} 
+					else 
+					{
+						modelptr->g2maxs[0] -= modelptr->g2maxsEffect[0];
+						if (modelptr->g2maxs[0] < modelptr->g2maxs2[0]) 
+						{
+							modelptr->g2maxs[0] = modelptr->g2maxs2[0];
+							done++;
+						}
+					}
+				}
+//y
+				if (modelptr->g2maxs[1] == modelptr->g2maxs2[1]) 
+				{
+					done++;
+				} 
+				else 
+				{
+					if (modelptr->g2maxs[1] < modelptr->g2maxs2[1]) 
+					{
+						modelptr->g2maxs[1] += modelptr->g2maxsEffect[1];
+						if (modelptr->g2maxs[1] > modelptr->g2maxs2[1]) 
+						{
+							modelptr->g2maxs[1] = modelptr->g2maxs2[1];
+							done++;
+						}
+					} 
+					else 
+					{
+						modelptr->g2maxs[1] -= modelptr->g2maxsEffect[1];
+						if (modelptr->g2maxs[1] < modelptr->g2maxs2[1]) 
+						{
+							modelptr->g2maxs[1] = modelptr->g2maxs2[1];
+							done++;
+						}
+					}
+				}
+
+
+//z
+
+				if (modelptr->g2maxs[2] == modelptr->g2maxs2[2]) 
+				{
+					done++;
+				} 
+				else 
+				{
+					if (modelptr->g2maxs[2] < modelptr->g2maxs2[2]) 
+					{
+						modelptr->g2maxs[2] += modelptr->g2maxsEffect[2];
+						if (modelptr->g2maxs[2] > modelptr->g2maxs2[2]) 
+						{
+							modelptr->g2maxs[2] = modelptr->g2maxs2[2];
+							done++;
+						}
+					} 
+					else 
+					{
+						modelptr->g2maxs[2] -= modelptr->g2maxsEffect[2];
+						if (modelptr->g2maxs[2] < modelptr->g2maxs2[2]) 
+						{
+							modelptr->g2maxs[2] = modelptr->g2maxs2[2];
+							done++;
+						}
+					}
+				}
+
+// transition the x,y,z min
+				if (modelptr->g2mins[0] == modelptr->g2mins2[0]) 
+				{
+					done++;
+				} 
+				else 
+				{
+					if (modelptr->g2mins[0] < modelptr->g2mins2[0]) 
+					{
+						modelptr->g2mins[0] += modelptr->g2minsEffect[0];
+						if (modelptr->g2mins[0] > modelptr->g2mins2[0]) 
+						{
+							modelptr->g2mins[0] = modelptr->g2mins2[0];
+							done++;
+						}
+					} 
+					else 
+					{
+						modelptr->g2mins[0] -= modelptr->g2minsEffect[0];
+						if (modelptr->g2mins[0] < modelptr->g2mins2[0]) 
+						{
+							modelptr->g2mins[0] = modelptr->g2mins2[0];
+							done++;
+						}
+					}
+				}
+//y
+				if (modelptr->g2mins[1] == modelptr->g2mins2[1]) 
+				{
+					done++;
+				} 
+				else 
+				{
+					if (modelptr->g2mins[1] < modelptr->g2mins2[1]) 
+					{
+						modelptr->g2mins[1] += modelptr->g2minsEffect[1];
+						if (modelptr->g2mins[1] > modelptr->g2mins2[1]) 
+						{
+							modelptr->g2mins[1] = modelptr->g2mins2[1];
+							done++;
+						}
+					} 
+					else 
+					{
+						modelptr->g2mins[1] -= modelptr->g2minsEffect[1];
+						if (modelptr->g2mins[1] < modelptr->g2mins2[1]) 
+						{
+							modelptr->g2mins[1] = modelptr->g2mins2[1];
+							done++;
+						}
+					}
+				}
+
+
+//z
+
+				if (modelptr->g2mins[2] == modelptr->g2mins2[2]) 
+				{
+					done++;
+				} 
+				else 
+				{
+					if (modelptr->g2mins[2] < modelptr->g2mins2[2]) 
+					{
+						modelptr->g2mins[2] += modelptr->g2minsEffect[2];
+						if (modelptr->g2mins[2] > modelptr->g2mins2[2]) 
+						{
+							modelptr->g2mins[2] = modelptr->g2mins2[2];
+							done++;
+						}
+					} 
+					else 
+					{
+						modelptr->g2mins[2] -= modelptr->g2minsEffect[2];
+						if (modelptr->g2mins[2] < modelptr->g2mins2[2]) 
+						{
+							modelptr->g2mins[2] = modelptr->g2mins2[2];
+							done++;
+						}
+					}
+				}
+
+
+
+//fovx
+				if (modelptr->fov_x == modelptr->fov_x2) 
+				{
+					done++;
+				} 
+				else 
+				{
+					if (modelptr->fov_x < modelptr->fov_x2) 
+					{
+						modelptr->fov_x += modelptr->fov_Effectx;
+						if (modelptr->fov_x > modelptr->fov_x2) 
+						{
+							modelptr->fov_x = modelptr->fov_x2;
+							done++;
+						}
+					} 
+					else 
+					{
+						modelptr->fov_x -= modelptr->fov_Effectx;
+						if (modelptr->fov_x < modelptr->fov_x2) 
+						{
+							modelptr->fov_x = modelptr->fov_x2;
+							done++;
+						}
+					}
+				}
+
+//fovy
+				if (modelptr->fov_y == modelptr->fov_y2) 
+				{
+					done++;
+				} 
+				else 
+				{
+					if (modelptr->fov_y < modelptr->fov_y2) 
+					{
+						modelptr->fov_y += modelptr->fov_Effecty;
+						if (modelptr->fov_y > modelptr->fov_y2) 
+						{
+							modelptr->fov_y = modelptr->fov_y2;
+							done++;
+						}
+					} 
+					else 
+					{
+						modelptr->fov_y -= modelptr->fov_Effecty;
+						if (modelptr->fov_y < modelptr->fov_y2) 
+						{
+							modelptr->fov_y = modelptr->fov_y2;
+							done++;
+						}
+					}
+				}
+
+				if (done == 5) 
+				{
+					item->window.flags &= ~WINDOW_INTRANSITIONMODEL;
+				}
+
+			}
+		}
+	}
+#endif
+//JLF end transition stuff for models
+
+	if (item->window.ownerDrawFlags && DC->ownerDrawVisible) 
+	{
+		if (!DC->ownerDrawVisible(item->window.ownerDrawFlags)) 
+		{
+			item->window.flags &= ~WINDOW_VISIBLE;
+		} 
+		else 
+		{
+			item->window.flags |= WINDOW_VISIBLE;
+		}
+	}
+
+	if (item->cvarFlags & (CVAR_SHOW | CVAR_HIDE)) 
+	{
+		if (!Item_EnableShowViaCvar(item, CVAR_SHOW)) 
+		{
+			return qfalse;
+		}
+	}
+
+	
+	if (item->window.flags & WINDOW_TIMEDVISIBLE) 
+	{
+
+	}
+
+	if (!(item->window.flags & WINDOW_VISIBLE)) 
+	{
+		return qfalse;
+	}
+
+	if (!bDraw)
+	{
+		return qtrue;
+	}
+	//okay to paint
+	//JLFMOUSE
+#ifndef _XBOX
+	if (item->window.flags & WINDOW_MOUSEOVER)
+#else
+	if (item->window.flags & WINDOW_HASFOCUS)
+#endif
+	{
+		if (item->descText && !Display_KeyBindPending())
+		{
+			// Make DOUBLY sure that this item should have desctext.
+#ifndef _XBOX
+			// NOTE : we can't just check the mouse position on this, what if we TABBED
+			// to the current menu item -- in that case our mouse isn't over the item.
+			// Removing the WINDOW_MOUSEOVER flag just prevents the item's OnExit script from running
+		//	if (!Rect_ContainsPoint(&item->window.rect, DC->cursorx, DC->cursory)) 
+		//	{	// It isn't something that should, because it isn't live anymore.
+		//		item->window.flags &= ~WINDOW_MOUSEOVER;
+		//	}
+		//	else
+#endif
+	//END JLFMOUSE
+
+			// items can be enabled and disabled based on cvars
+			if( !(item->cvarFlags & (CVAR_ENABLE | CVAR_DISABLE) && !Item_EnableShowViaCvar(item, CVAR_ENABLE)) )
+			{	// Draw the desctext
+				const char *textPtr = item->descText;
+				if (*textPtr == '@')	// string reference
+				{
+					textPtr = SE_GetString( &textPtr[1] );
+				}
+
+				vec4_t color = {1, 1, 1, 1};
+				Item_TextColor(item, &color);
+
+				float fDescScale = parent->descScale ? parent->descScale : 1;
+				float fDescScaleCopy = fDescScale;
+				while (1)
+				{
+					// FIXME - add some type of parameter in the menu file like descfont to specify the font for the descriptions for this menu.
+					textWidth = DC->textWidth(textPtr, fDescScale, 4);	//  item->font);
+
+					if (parent->descAlignment == ITEM_ALIGN_RIGHT)
+					{
+						xPos = parent->descX - textWidth;	// Right justify
+					}
+					else if (parent->descAlignment == ITEM_ALIGN_CENTER)
+					{
+						xPos = parent->descX - (textWidth/2);	// Center justify
+					}
+					else										// Left justify	
+					{
+						xPos = parent->descX;
+					}
+
+					if (parent->descAlignment == ITEM_ALIGN_CENTER)
+					{
+						// only this one will auto-shrink the scale until we eventually fit...
+						//
+						if (xPos + textWidth > (SCREEN_WIDTH-4)) {
+							fDescScale -= 0.001f;
+							continue;
+						}
+					}
+
+
+					// Try to adjust it's y placement if the scale has changed...
+					//
+					int iYadj = 0;
+					if (fDescScale != fDescScaleCopy)
+					{
+						int iOriginalTextHeight = DC->textHeight(textPtr, fDescScaleCopy, uiInfo.uiDC.Assets.qhMediumFont);
+						iYadj = iOriginalTextHeight - DC->textHeight(textPtr, fDescScale, uiInfo.uiDC.Assets.qhMediumFont);
+					}
+
+					// FIXME - add some type of parameter in the menu file like descfont to specify the font for the descriptions for this menu.
+					DC->drawText(xPos, parent->descY + iYadj, fDescScale, parent->descColor, textPtr, 0, parent->descTextStyle, 4);	//item->font);
+					break;
+				}
+			}
+		}
+	}
+
+	// paint the rect first.. 
+	Window_Paint(&item->window, parent->fadeAmount , parent->fadeClamp, parent->fadeCycle);
+
+	// Print a box showing the extents of the rectangle, when in debug mode
+	if (uis.debugMode) 
+	{
+		vec4_t color;
+		color[1] = color[3] = 1;
+		color[0] = color[2] = 0;
+		DC->drawRect(
+			item->window.rect.x, 
+			item->window.rect.y, 
+			item->window.rect.w, 
+			item->window.rect.h, 
+			1, 
+			color);
+	}
+
+  //DC->drawRect(item->window.rect.x, item->window.rect.y, item->window.rect.w, item->window.rect.h, 1, red);
+
+	switch (item->type) 
+	{
+		case ITEM_TYPE_OWNERDRAW:
+			Item_OwnerDraw_Paint(item);
+			break;
+
+		case ITEM_TYPE_TEXT:
+		case ITEM_TYPE_BUTTON:
+			Item_Text_Paint(item);
+			break;
+		case ITEM_TYPE_RADIOBUTTON:
+			break;
+		case ITEM_TYPE_CHECKBOX:
+			break;
+		case ITEM_TYPE_EDITFIELD:
+		case ITEM_TYPE_NUMERICFIELD:
+			Item_TextField_Paint(item);
+			break;
+		case ITEM_TYPE_COMBO:
+			break;
+		case ITEM_TYPE_LISTBOX:
+			Item_ListBox_Paint(item);
+			break;
+		case ITEM_TYPE_TEXTSCROLL:
+			Item_TextScroll_Paint ( item );
+			break;
+		case ITEM_TYPE_MODEL:
+			Item_Model_Paint(item);
+			break;
+		case ITEM_TYPE_YESNO:
+			Item_YesNo_Paint(item);
+			break;
+		case ITEM_TYPE_MULTI:
+			Item_Multi_Paint(item);
+			break;
+		case ITEM_TYPE_BIND:
+			Item_Bind_Paint(item);
+			break;
+		case ITEM_TYPE_SLIDER:
+			Item_Slider_Paint(item);
+			break;
+		default:
+			break;
+	}
+	return qtrue;
+}
+
+/*
+=================
+LerpColor
+=================
+*/
+void LerpColor(vec4_t a, vec4_t b, vec4_t c, float t)
+{
+	int i;
+
+	// lerp and clamp each component
+	for (i=0; i<4; i++)
+	{
+		c[i] = a[i] + t*(b[i]-a[i]);
+		if (c[i] < 0)
+		{
+			c[i] = 0;
+		}
+		else if (c[i] > 1.0)
+		{
+			c[i] = 1.0;
+		}
+	}
+}
+
+/*
+=================
+Fade
+=================
+*/
+void Fade(int *flags, float *f, float clamp, int *nextTime, int offsetTime, qboolean bFlags, float fadeAmount) 
+{
+	if (*flags & (WINDOW_FADINGOUT | WINDOW_FADINGIN)) 
+	{
+		if (DC->realTime > *nextTime) 
+		{
+			*nextTime = DC->realTime + offsetTime;
+			if (*flags & WINDOW_FADINGOUT) 
+			{
+				*f -= fadeAmount;
+				if (bFlags && *f <= 0.0) 
+				{
+					*flags &= ~(WINDOW_FADINGOUT | WINDOW_VISIBLE);
+				}
+			} 
+			else 
+			{
+				*f += fadeAmount;
+				if (*f >= clamp) 
+				{
+				  *f = clamp;
+					if (bFlags) 
+					{
+						*flags &= ~WINDOW_FADINGIN;
+					}
+				}
+			}
+		}
+	}
+}
+
+/*
+=================
+GradientBar_Paint
+=================
+*/
+void GradientBar_Paint(rectDef_t *rect, vec4_t color) 
+{
+	// gradient bar takes two paints
+	DC->setColor( color );
+	DC->drawHandlePic(rect->x, rect->y, rect->w, rect->h, DC->Assets.gradientBar);
+	DC->setColor( NULL );
+}
+
+/*
+=================
+Window_Paint
+=================
+*/
+void Window_Paint(Window *w, float fadeAmount, float fadeClamp, float fadeCycle) 
+{
+  //float bordersize = 0;
+  vec4_t color;
+  rectDef_t fillRect = w->rect;
+
+
+	if (uis.debugMode) 
+	{
+		color[0] = color[1] = color[2] = color[3] = 1;
+		DC->drawRect(w->rect.x, w->rect.y, w->rect.w, w->rect.h, 1, color);
+	}
+
+	if (w == NULL || (w->style == 0 && w->border == 0)) 
+	{
+		return;
+	}
+
+	if (w->border != 0) 
+	{
+		fillRect.x += w->borderSize;
+		fillRect.y += w->borderSize;
+		fillRect.w -= w->borderSize + 1;
+		fillRect.h -= w->borderSize + 1;
+	}
+
+	if (w->style == WINDOW_STYLE_FILLED) 
+	{
+		// box, but possible a shader that needs filled
+		if (w->background) 
+		{
+			Fade(&w->flags, &w->backColor[3], fadeClamp, &w->nextTime, fadeCycle, qtrue, fadeAmount);
+			DC->setColor(w->backColor);
+			DC->drawHandlePic(fillRect.x, fillRect.y, fillRect.w, fillRect.h, w->background);
+			DC->setColor(NULL);
+		} 
+		else 
+		{
+			DC->fillRect(fillRect.x, fillRect.y, fillRect.w, fillRect.h, w->backColor);
+		}
+	} 
+	else if (w->style == WINDOW_STYLE_GRADIENT) 
+	{
+		GradientBar_Paint(&fillRect, w->backColor);
+		// gradient bar
+	} 
+	else if (w->style == WINDOW_STYLE_SHADER) 
+	{
+		if (w->flags & WINDOW_PLAYERCOLOR) 
+		{
+			vec4_t	color;
+			color[0] = ui_char_color_red.integer/255.0f;
+			color[1] = ui_char_color_green.integer/255.0f;
+			color[2] = ui_char_color_blue.integer/255.0f;
+			color[3] = 1;
+			ui.R_SetColor(color);
+		}
+		else if (w->flags & WINDOW_FORECOLORSET) 
+		{
+			DC->setColor(w->foreColor);
+		}
+		DC->drawHandlePic(fillRect.x, fillRect.y, fillRect.w, fillRect.h, w->background);
+		DC->setColor(NULL);
+	} 
+
+	if (w->border == WINDOW_BORDER_FULL) 
+	{
+		// full
+		// HACK HACK HACK
+		if (w->style == WINDOW_STYLE_TEAMCOLOR) 
+		{
+			if (color[0] > 0) 
+			{	
+				// red
+				color[0] = 1;
+				color[1] = color[2] = .5;
+			} 
+			else 
+			{
+				color[2] = 1;
+				color[0] = color[1] = .5;
+			}
+			color[3] = 1;
+			DC->drawRect(w->rect.x, w->rect.y, w->rect.w, w->rect.h, w->borderSize, color);
+		} 
+		else 
+		{
+			DC->drawRect(w->rect.x, w->rect.y, w->rect.w, w->rect.h, w->borderSize, w->borderColor);
+		}
+	} 
+	else if (w->border == WINDOW_BORDER_HORZ) 
+	{
+		// top/bottom
+		DC->setColor(w->borderColor);
+		DC->drawTopBottom(w->rect.x, w->rect.y, w->rect.w, w->rect.h, w->borderSize);
+		DC->setColor( NULL );
+	} 
+	else if (w->border == WINDOW_BORDER_VERT) 
+	{
+		// left right
+		DC->setColor(w->borderColor);
+		DC->drawSides(w->rect.x, w->rect.y, w->rect.w, w->rect.h, w->borderSize);
+		DC->setColor( NULL );
+	} 
+	else if (w->border == WINDOW_BORDER_KCGRADIENT) 
+	{
+		// this is just two gradient bars along each horz edge
+		rectDef_t r = w->rect;
+		r.h = w->borderSize;
+		GradientBar_Paint(&r, w->borderColor);
+		r.y = w->rect.y + w->rect.h - 1;
+		GradientBar_Paint(&r, w->borderColor);
+	}
+}
+
+/*
+=================
+Display_KeyBindPending
+=================
+*/
+qboolean Display_KeyBindPending(void) 
+{
+	return g_waitingForKey;
+}
+
+/*
+=================
+ToWindowCoords
+=================
+*/
+void ToWindowCoords(float *x, float *y, windowDef_t *window) 
+{
+	if (window->border != 0) 
+	{
+		*x += window->borderSize;
+		*y += window->borderSize;
+	} 
+	*x += window->rect.x;
+	*y += window->rect.y;
+}
+
+/*
+=================
+Item_Text_AutoWrapped_Paint
+=================
+*/
+void Item_Text_AutoWrapped_Paint(itemDef_t *item) 
+{
+	char text[1024];
+	const char *p, *textPtr, *newLinePtr;
+	char buff[1024];
+	int height, len, textWidth, newLine, newLineWidth;
+	float y;
+	vec4_t color;
+
+	textWidth = 0;
+	newLinePtr = NULL;
+
+	if (item->text == NULL) 
+	{
+		if (item->cvar == NULL) 
+		{
+			return;
+		}
+		else 
+		{
+			DC->getCVarString(item->cvar, text, sizeof(text));
+			textPtr = text;
+		}
+	}
+	else 
+	{
+		textPtr = item->text;
+	}
+	if (*textPtr == '@')	// string reference
+	{
+		textPtr = SE_GetString( &textPtr[1] );
+	}
+
+	if (*textPtr == '\0') 
+	{
+		return;
+	}
+	Item_TextColor(item, &color);
+	//Item_SetTextExtents(item, &width, &height, textPtr);
+	if (item->value == 0)
+	{
+		item->value = (int)(0.5 + (float)DC->textWidth(textPtr, item->textscale, item->font) / item->window.rect.w);
+	}
+	height = DC->textHeight(textPtr, item->textscale, item->font);
+	item->special = 0;
+
+	y = item->textaligny;
+	len = 0;
+	buff[0] = '\0';
+	newLine = 0;
+	newLineWidth = 0;
+	p = textPtr;
+	int line = 1;
+	while (1) //findmeste (this will break widechar languages)!
+	{
+		if (*p == ' ' || *p == '\t' || *p == '\n' || *p == '\0') 
+		{
+			newLine = len;
+			newLinePtr = p+1;
+			newLineWidth = textWidth;
+		}
+		textWidth = DC->textWidth(buff, item->textscale, 0);
+		if ( (newLine && textWidth >= item->window.rect.w - item->textalignx) || *p == '\n' || *p == '\0') 
+		{
+			if (line > item->cursorPos)	//scroll 
+		{
+			if (len) 
+			{
+				if (item->textalignment == ITEM_ALIGN_LEFT) 
+				{
+					item->textRect.x = item->textalignx;
+				} 
+				else if (item->textalignment == ITEM_ALIGN_RIGHT) 
+				{
+					item->textRect.x = item->textalignx - newLineWidth;
+				} 
+				else if (item->textalignment == ITEM_ALIGN_CENTER) 
+				{
+					item->textRect.x = item->textalignx - newLineWidth / 2;
+				}
+				item->textRect.y = y;
+				ToWindowCoords(&item->textRect.x, &item->textRect.y, &item->window);
+				//
+				buff[newLine] = '\0';
+
+					if ( *p && y + height + 4 > item->window.rect.h - height)
+					{
+						item->special = 1;
+						strcat(buff,"...");//uhh, let's render some ellipses
+					}
+				DC->drawText(item->textRect.x, item->textRect.y, item->textscale, color, buff, 0, item->textStyle, item->font);
+			}
+				y += height + 4;
+				if ( y > item->window.rect.h - height)
+				{//reached the bottom of the box, so stop
+					break;
+				}
+				len = 0;
+			}
+			else
+			{
+				strcpy(buff,"...");
+				len = 3;
+			}
+			if (*p == '\0') 
+			{	//end of string
+				break;
+			}
+			p = newLinePtr;
+			newLine = 0;
+			newLineWidth = 0;
+			line++;
+		}
+		buff[len++] = *p++;
+		buff[len] = '\0';
+	}
+	item->textRect = item->window.rect;
+}
+
+/*
+=================
+Rect_ContainsPoint
+=================
+*/
+static qboolean Rect_ContainsPoint(rectDef_t *rect, float x, float y) 
+{
+	//JLF  ignore mouse pointer location
+//	return true;
+	// END JLF
+	if (rect) 
+	{
+//		if ((x > rect->x) && (x < (rect->x + rect->w)) && (y > rect->y) && (y < (rect->y + rect->h))) 
+		if ((x > rect->x) && (x < (rect->x + rect->w)))
+		{
+			if ((y > rect->y) && (y < (rect->y + rect->h)))
+			{
+				return qtrue;
+			}
+		}
+	}
+	return qfalse;
+}
+
+qboolean Item_TextScroll_HandleKey ( itemDef_t *item, int key, qboolean down, qboolean force) 
+{
+	textScrollDef_t *scrollPtr = (textScrollDef_t*)item->typeData;
+	int				max;
+	int				viewmax;
+
+	if (force || (Rect_ContainsPoint(&item->window.rect, DC->cursorx, DC->cursory) && item->window.flags & WINDOW_HASFOCUS)) 
+	{
+		max = Item_TextScroll_MaxScroll(item);
+
+		viewmax = (item->window.rect.h / scrollPtr->lineHeight);
+		if ( key == A_CURSOR_UP || key == A_KP_8 ) 
+		{
+			scrollPtr->startPos--;
+			if (scrollPtr->startPos < 0)
+			{
+				scrollPtr->startPos = 0;
+			}
+			return qtrue;
+		}
+
+		if ( key == A_CURSOR_DOWN || key == A_KP_2 ) 
+		{
+			scrollPtr->startPos++;
+			if (scrollPtr->startPos > max)
+			{
+				scrollPtr->startPos = max;
+			}
+
+			return qtrue;
+		}
+
+		// mouse hit
+		if (key == A_MOUSE1 || key == A_MOUSE2) 
+		{
+			if (item->window.flags & WINDOW_LB_LEFTARROW) 
+			{
+				scrollPtr->startPos--;
+				if (scrollPtr->startPos < 0) 
+				{
+					scrollPtr->startPos = 0;
+				}
+			} 
+			else if (item->window.flags & WINDOW_LB_RIGHTARROW) 
+			{
+				// one down
+				scrollPtr->startPos++;
+				if (scrollPtr->startPos > max) 
+				{
+					scrollPtr->startPos = max;
+				}
+			} 
+			else if (item->window.flags & WINDOW_LB_PGUP) 
+			{
+				// page up
+				scrollPtr->startPos -= viewmax;
+				if (scrollPtr->startPos < 0) 
+				{
+					scrollPtr->startPos = 0;
+				}
+			} 
+			else if (item->window.flags & WINDOW_LB_PGDN) 
+			{
+				// page down
+				scrollPtr->startPos += viewmax;
+				if (scrollPtr->startPos > max) 
+				{
+					scrollPtr->startPos = max;
+				}
+			} 
+			else if (item->window.flags & WINDOW_LB_THUMB) 
+			{
+				// Display_SetCaptureItem(item);
+			} 
+
+			return qtrue;
+		}
+
+		if ( key == A_HOME || key == A_KP_7) 
+		{
+			// home
+			scrollPtr->startPos = 0;
+			return qtrue;
+		}
+		if ( key == A_END || key == A_KP_1) 
+		{
+			// end
+			scrollPtr->startPos = max;
+			return qtrue;
+		}
+		if (key == A_PAGE_UP || key == A_KP_9 ) 
+		{
+			scrollPtr->startPos -= viewmax;
+			if (scrollPtr->startPos < 0) 
+			{
+					scrollPtr->startPos = 0;
+			}
+
+			return qtrue;
+		}
+		if ( key == A_PAGE_DOWN || key == A_KP_3 ) 
+		{
+			scrollPtr->startPos += viewmax;
+			if (scrollPtr->startPos > max) 
+			{
+				scrollPtr->startPos = max;
+			}
+			return qtrue;
+		}
+	}
+
+	return qfalse;
+}
+
+/*
+=================
+Item_ListBox_MaxScroll
+=================
+*/
+int Item_ListBox_MaxScroll(itemDef_t *item) 
+{
+	listBoxDef_t *listPtr = (listBoxDef_t*)item->typeData;
+	int count = DC->feederCount(item->special);
+	int max;
+
+	if (item->window.flags & WINDOW_HORIZONTAL) 
+	{
+		max = count - (item->window.rect.w / listPtr->elementWidth) + 1;
+	}
+	else 
+	{
+		max = count - (item->window.rect.h / listPtr->elementHeight) + 1;
+	}
+
+	if (max < 0) 
+	{
+		return 0;
+	}
+	return max;
+}
+
+/*
+=================
+Item_ListBox_ThumbPosition
+=================
+*/
+int Item_ListBox_ThumbPosition(itemDef_t *item) 
+{
+	float max, pos, size;
+	listBoxDef_t *listPtr = (listBoxDef_t*)item->typeData;
+
+	max = Item_ListBox_MaxScroll(item);
+	if (item->window.flags & WINDOW_HORIZONTAL) {
+
+		size = item->window.rect.w - (SCROLLBAR_SIZE * 2) - 2;
+		if (max > 0) 
+		{
+			pos = (size-SCROLLBAR_SIZE) / (float) max;
+		} 
+		else 
+		{
+			pos = 0;
+		}
+		pos *= listPtr->startPos;
+		return item->window.rect.x + 1 + SCROLLBAR_SIZE + pos;
+	}
+	else 
+	{
+		size = item->window.rect.h - (SCROLLBAR_SIZE * 2) - 2;
+		if (max > 0) 
+		{
+			pos = (size-SCROLLBAR_SIZE) / (float) max;
+		} 
+		else 
+		{
+			pos = 0;
+		}
+		pos *= listPtr->startPos;
+		return item->window.rect.y + 1 + SCROLLBAR_SIZE + pos;
+	}
+}
+
+/*
+=================
+Item_ListBox_OverLB
+=================
+*/
+int Item_ListBox_OverLB(itemDef_t *item, float x, float y) 
+{
+	rectDef_t r;
+	listBoxDef_t *listPtr;
+	int thumbstart;
+	int count;
+
+	count = DC->feederCount(item->special);
+	listPtr = (listBoxDef_t*)item->typeData;
+	if (item->window.flags & WINDOW_HORIZONTAL) 
+	{
+		// check if on left arrow
+		r.x = item->window.rect.x;
+		r.y = item->window.rect.y + item->window.rect.h - SCROLLBAR_SIZE;
+		r.h = r.w = SCROLLBAR_SIZE;
+		if (Rect_ContainsPoint(&r, x, y)) 
+		{
+			return WINDOW_LB_LEFTARROW;
+		}
+		// check if on right arrow
+		r.x = item->window.rect.x + item->window.rect.w - SCROLLBAR_SIZE;
+		if (Rect_ContainsPoint(&r, x, y)) 
+		{
+			return WINDOW_LB_RIGHTARROW;
+		}
+		// check if on thumb
+		thumbstart = Item_ListBox_ThumbPosition(item);
+		r.x = thumbstart;
+		if (Rect_ContainsPoint(&r, x, y)) 
+		{
+			return WINDOW_LB_THUMB;
+		}
+		r.x = item->window.rect.x + SCROLLBAR_SIZE;
+		r.w = thumbstart - r.x;
+		if (Rect_ContainsPoint(&r, x, y)) 
+		{
+			return WINDOW_LB_PGUP;
+		}
+		r.x = thumbstart + SCROLLBAR_SIZE;
+		r.w = item->window.rect.x + item->window.rect.w - SCROLLBAR_SIZE;
+		if (Rect_ContainsPoint(&r, x, y)) 
+		{
+			return WINDOW_LB_PGDN;
+		}
+	} 
+	else 
+	{
+		r.x = item->window.rect.x + item->window.rect.w - SCROLLBAR_SIZE;
+		r.y = item->window.rect.y;
+		r.h = r.w = SCROLLBAR_SIZE;
+		if (Rect_ContainsPoint(&r, x, y)) 
+		{
+			return WINDOW_LB_LEFTARROW;
+		}
+		r.y = item->window.rect.y + item->window.rect.h - SCROLLBAR_SIZE;
+		if (Rect_ContainsPoint(&r, x, y)) 
+		{
+			return WINDOW_LB_RIGHTARROW;
+		}
+		thumbstart = Item_ListBox_ThumbPosition(item);
+		r.y = thumbstart;
+		if (Rect_ContainsPoint(&r, x, y)) 
+		{
+			return WINDOW_LB_THUMB;
+		}
+		r.y = item->window.rect.y + SCROLLBAR_SIZE;
+		r.h = thumbstart - r.y;
+		if (Rect_ContainsPoint(&r, x, y)) 
+		{
+			return WINDOW_LB_PGUP;
+		}
+		r.y = thumbstart + SCROLLBAR_SIZE;
+		r.h = item->window.rect.y + item->window.rect.h - SCROLLBAR_SIZE;
+		if (Rect_ContainsPoint(&r, x, y)) 
+		{
+			return WINDOW_LB_PGDN;
+		}
+	}
+	return 0;
+}
+
+/*
+=================
+Item_ListBox_MouseEnter
+=================
+*/
+void Item_ListBox_MouseEnter(itemDef_t *item, float x, float y) 
+{
+	rectDef_t r;
+	listBoxDef_t *listPtr = (listBoxDef_t*)item->typeData;
+        
+	item->window.flags &= ~(WINDOW_LB_LEFTARROW | WINDOW_LB_RIGHTARROW | WINDOW_LB_THUMB | WINDOW_LB_PGUP | WINDOW_LB_PGDN);
+	item->window.flags |= Item_ListBox_OverLB(item, x, y);
+
+	if (item->window.flags & WINDOW_HORIZONTAL) 
+	{
+		if (!(item->window.flags & (WINDOW_LB_LEFTARROW | WINDOW_LB_RIGHTARROW | WINDOW_LB_THUMB | WINDOW_LB_PGUP | WINDOW_LB_PGDN))) 
+		{
+			// check for selection hit as we have exausted buttons and thumb
+			if (listPtr->elementStyle == LISTBOX_IMAGE) 
+			{
+				r.x = item->window.rect.x;
+				r.y = item->window.rect.y;
+				r.h = item->window.rect.h - SCROLLBAR_SIZE;
+				r.w = item->window.rect.w - listPtr->drawPadding;
+				if (Rect_ContainsPoint(&r, x, y)) 
+				{
+					listPtr->cursorPos =  (int)((x - r.x) / listPtr->elementWidth)  + listPtr->startPos;
+					if (listPtr->cursorPos > listPtr->endPos) 
+					{
+						listPtr->cursorPos = listPtr->endPos;
+					}
+				}
+			} 
+			else 
+			{
+				// text hit.. 
+			}
+		}
+	} 
+	else if (!(item->window.flags & (WINDOW_LB_LEFTARROW | WINDOW_LB_RIGHTARROW | WINDOW_LB_THUMB | WINDOW_LB_PGUP | WINDOW_LB_PGDN))) 
+	{
+		r.x = item->window.rect.x;
+		r.y = item->window.rect.y;
+		r.w = item->window.rect.w - SCROLLBAR_SIZE;
+		r.h = item->window.rect.h - listPtr->drawPadding;
+		if (Rect_ContainsPoint(&r, x, y)) 
+		{
+			listPtr->cursorPos =  (int)((y - 2 - r.y) / listPtr->elementHeight)  + listPtr->startPos;
+			if (listPtr->cursorPos > listPtr->endPos) 
+			{
+				listPtr->cursorPos = listPtr->endPos;
+			}
+		}
+	}
+}
+
+/*
+=================
+Item_MouseEnter
+=================
+*/
+void Item_MouseEnter(itemDef_t *item, float x, float y) 
+{
+	rectDef_t r;
+	//JLFMOUSE
+	if (item) 
+	{
+		r = item->textRect;
+//		r.y -= r.h;			// NOt sure why this is here, but I commented it out.
+		// in the text rect?
+
+		// items can be enabled and disabled based on cvars
+		if (item->cvarFlags & (CVAR_ENABLE | CVAR_DISABLE) && !Item_EnableShowViaCvar(item, CVAR_ENABLE)) 
+		{
+			return;
+		}
+
+		if (item->cvarFlags & (CVAR_SHOW | CVAR_HIDE) && !Item_EnableShowViaCvar(item, CVAR_SHOW)) 
+		{
+			return;
+		}
+
+//JLFMOUSE 
+#ifndef _XBOX
+		if (Rect_ContainsPoint(&r, x, y)) 
+#else
+		if (item->flags & WINDOW_HASFOCUS)
+#endif
+		{
+			if (!(item->window.flags & WINDOW_MOUSEOVERTEXT)) 
+			{
+				Item_RunScript(item, item->mouseEnterText);
+				item->window.flags |= WINDOW_MOUSEOVERTEXT;
+			}
+
+			if (!(item->window.flags & WINDOW_MOUSEOVER)) 
+			{
+				Item_RunScript(item, item->mouseEnter);
+				item->window.flags |= WINDOW_MOUSEOVER;
+			}
+
+		} 
+		else 
+		{
+			// not in the text rect
+			if (item->window.flags & WINDOW_MOUSEOVERTEXT) 
+			{
+				// if we were
+				Item_RunScript(item, item->mouseExitText);
+				item->window.flags &= ~WINDOW_MOUSEOVERTEXT;
+			}
+
+			if (!(item->window.flags & WINDOW_MOUSEOVER)) 
+			{
+				Item_RunScript(item, item->mouseEnter);
+				item->window.flags |= WINDOW_MOUSEOVER;
+			}
+
+			if (item->type == ITEM_TYPE_LISTBOX) 
+			{
+				Item_ListBox_MouseEnter(item, x, y);
+			}
+			else if ( item->type == ITEM_TYPE_TEXTSCROLL )
+			{
+				Item_TextScroll_MouseEnter ( item, x, y );
+			}
+		}
+	}
+}
+
+
+
+/*
+=================
+Item_SetFocus
+=================
+*/
+// will optionaly set focus to this item 
+qboolean Item_SetFocus(itemDef_t *item, float x, float y) 
+{
+	int i;
+	itemDef_t *oldFocus;
+	sfxHandle_t *sfx = &DC->Assets.itemFocusSound;
+	qboolean playSound = qfalse;
+#ifdef _IMMERSION
+	ffHandle_t *ff = &DC->Assets.itemFocusForce;
+	qboolean playForce = qfalse;
+#endif // _IMMERSION
+	// sanity check, non-null, not a decoration and does not already have the focus
+	if (item == NULL || item->window.flags & WINDOW_DECORATION || item->window.flags & WINDOW_HASFOCUS || !(item->window.flags & WINDOW_VISIBLE) || (item->window.flags & WINDOW_INACTIVE)) 
+	{
+		return qfalse;
+	}
+	menuDef_t *parent = (menuDef_t*)item->parent;
+
+	// items can be enabled and disabled based on cvars
+	if (item->cvarFlags & (CVAR_ENABLE | CVAR_DISABLE) && !Item_EnableShowViaCvar(item, CVAR_ENABLE)) 
+	{
+		return qfalse;
+	}
+
+	if (item->cvarFlags & (CVAR_SHOW | CVAR_HIDE) && !Item_EnableShowViaCvar(item, CVAR_SHOW)) 
+	{
+		return qfalse;
+	}
+
+	oldFocus = Menu_ClearFocus((menuDef_t *) item->parent);
+
+	if (item->type == ITEM_TYPE_TEXT) 
+	{
+		rectDef_t r;
+		r = item->textRect;
+		//r.y -= r.h;
+//JLFMOUSE
+#ifndef _XBOX
+		if (Rect_ContainsPoint(&r, x, y)) 
+#endif
+		{
+			item->window.flags |= WINDOW_HASFOCUS;
+			if (item->focusSound) 
+			{
+				sfx = &item->focusSound;
+			}
+			playSound = qtrue;
+#ifdef _IMMERSION
+			if (item->focusForce)
+			{
+				ff = &item->focusForce;
+			}
+			playForce = qtrue;
+#endif // _IMMERSION
+		}
+#ifndef _XBOX
+		else 
+
+		{
+			if (oldFocus) 
+			{
+				oldFocus->window.flags |= WINDOW_HASFOCUS;
+				if (oldFocus->onFocus) 
+				{
+					Item_RunScript(oldFocus, oldFocus->onFocus);
+				}
+			}
+		}
+#endif
+	} 
+	else 
+	{
+	    item->window.flags |= WINDOW_HASFOCUS;
+		if (item->onFocus) 
+		{
+			Item_RunScript(item, item->onFocus);
+		}
+		if (item->focusSound) 
+		{
+			sfx = &item->focusSound;
+		}
+		playSound = qtrue;
+#ifdef _IMMERSION
+		if (item->focusForce)
+		{
+			ff = &item->focusForce;
+		}
+		playForce = qtrue;
+#endif // _IMMERSION
+	}
+
+	if (playSound && sfx) 
+	{
+		DC->startLocalSound( *sfx, CHAN_LOCAL_SOUND );
+	}
+
+#ifdef _IMMERSION
+	if (playForce && ff)
+	{
+		DC->startForce( *ff );
+	}
+#endif // _IMMERSION
+	for (i = 0; i < parent->itemCount; i++) 
+	{
+		if (parent->items[i] == item) 
+		{
+			parent->cursorItem = i;
+			break;
+		}
+	}
+
+	return qtrue;
+}
+
+
+/*
+=================
+IsVisible
+=================
+*/
+qboolean IsVisible(int flags) 
+{
+  return (flags & WINDOW_VISIBLE && !(flags & WINDOW_FADINGOUT));
+}
+
+/*
+=================
+Item_MouseLeave
+=================
+*/
+void Item_MouseLeave(itemDef_t *item) 
+{
+	if (item) 
+	{
+		if (item->window.flags & WINDOW_MOUSEOVERTEXT) 
+		{
+			Item_RunScript(item, item->mouseExitText);
+			item->window.flags &= ~WINDOW_MOUSEOVERTEXT;
+		}
+		Item_RunScript(item, item->mouseExit);
+		item->window.flags &= ~(WINDOW_LB_RIGHTARROW | WINDOW_LB_LEFTARROW);
+	}
+}
+
+/*
+=================
+Item_SetMouseOver
+=================
+*/
+void Item_SetMouseOver(itemDef_t *item, qboolean focus) 
+{
+	if (item) 
+	{
+		if (focus) 
+		{
+			item->window.flags |= WINDOW_MOUSEOVER;
+		} 
+		else 
+		{
+			item->window.flags &= ~WINDOW_MOUSEOVER;
+		}
+	}
+}
+
+/*
+=================
+Menu_HandleMouseMove
+=================
+*/
+void Menu_HandleMouseMove(menuDef_t *menu, float x, float y) 
+{
+
+	//JLFMOUSE  I THINK THIS JUST SETS THE FOCUS BASED ON THE MOUSE
+#ifdef _XBOX
+	return ;
+#endif
+	//END JLF
+	int i, pass;
+	qboolean focusSet = qfalse;
+
+	itemDef_t *overItem;
+	if (menu == NULL) 
+	{
+		return;
+	}
+
+	if (!(menu->window.flags & (WINDOW_VISIBLE | WINDOW_FORCED))) 
+	{
+		return;
+	}
+
+	if (itemCapture) 
+	{
+		//Item_MouseMove(itemCapture, x, y);
+		return;
+	}
+
+	if (g_waitingForKey || g_editingField) 
+	{
+		return;
+	}
+
+	// FIXME: this is the whole issue of focus vs. mouse over.. 
+	// need a better overall solution as i don't like going through everything twice
+	for (pass = 0; pass < 2; pass++) 
+	{
+		for (i = 0; i < menu->itemCount; i++) 
+		{
+			// turn off focus each item
+			// menu->items[i].window.flags &= ~WINDOW_HASFOCUS;
+
+			if (!(menu->items[i]->window.flags & (WINDOW_VISIBLE | WINDOW_FORCED))) 
+			{
+				continue;
+			}
+
+			if (menu->items[i]->window.flags & WINDOW_INACTIVE) 
+			{
+				continue;
+			}
+
+			// items can be enabled and disabled based on cvars
+			if (menu->items[i]->cvarFlags & (CVAR_ENABLE | CVAR_DISABLE) && !Item_EnableShowViaCvar(menu->items[i], CVAR_ENABLE)) 
+			{
+				continue;
+			}
+
+			if (menu->items[i]->cvarFlags & (CVAR_SHOW | CVAR_HIDE) && !Item_EnableShowViaCvar(menu->items[i], CVAR_SHOW)) 
+			{
+				continue;
+			}
+
+			if (Rect_ContainsPoint(&menu->items[i]->window.rect, x, y)) 
+			{
+				if (pass == 1) 
+				{
+					overItem = menu->items[i];
+					if (overItem->type == ITEM_TYPE_TEXT && overItem->text) 
+					{
+						if (!Rect_ContainsPoint(&overItem->window.rect, x, y)) 
+						{
+							continue;
+						}
+					}
+
+					// if we are over an item
+					if (IsVisible(overItem->window.flags)) 
+					{
+						// different one
+						Item_MouseEnter(overItem, x, y);
+						// Item_SetMouseOver(overItem, qtrue);
+
+						// if item is not a decoration see if it can take focus
+						if (!focusSet) 
+						{
+							focusSet = Item_SetFocus(overItem, x, y);
+						}
+					}
+				}
+
+			} else if (menu->items[i]->window.flags & WINDOW_MOUSEOVER) 
+			{
+				Item_MouseLeave(menu->items[i]);
+				Item_SetMouseOver(menu->items[i], qfalse);
+			}
+		}
+	}
+}
+
+/*
+=================
+Display_MouseMove
+=================
+*/
+qboolean Display_MouseMove(void *p, int x, int y) 
+{
+	//JLFMOUSE  AGAIN I THINK THIS SHOULD BE MOOT
+#ifdef _XBOX
+	return qtrue;
+#endif
+	//END JLF
+	int i;
+	menuDef_t *menu = (menuDef_t *) p;
+
+	if (menu == NULL) 
+	{
+	    menu = Menu_GetFocused();
+		if (menu) 
+		{
+			if (menu->window.flags & WINDOW_POPUP) 
+			{
+				Menu_HandleMouseMove(menu, x, y);
+				return qtrue;
+			}
+		}
+
+		for (i = 0; i < menuCount; i++) 
+		{
+			Menu_HandleMouseMove(&Menus[i], x, y);
+		}
+	} 
+	else 
+	{
+		menu->window.rect.x += x;
+		menu->window.rect.y += y;
+		Menu_UpdatePosition(menu);
+	}
+ 	return qtrue;
+}
+
+/*
+=================
+Menus_AnyFullScreenVisible
+=================
+*/
+qboolean Menus_AnyFullScreenVisible(void) 
+{
+	int i;
+
+	for (i = 0; i < menuCount; i++) 
+	{
+		if (Menus[i].window.flags & WINDOW_VISIBLE && Menus[i].fullScreen) 
+		{
+			return qtrue;
+		}
+
+	}
+	return qfalse;
+}
+
+/*
+=================
+BindingIDFromName
+=================
+*/
+int BindingIDFromName(const char *name) 
+{
+	int i;
+	for (i=0; i < g_bindCount; i++)
+	{
+		if (Q_stricmp(name, g_bindings[i].command) == 0) 
+		{
+			return i;
+		}
+	}
+	return -1;
+}
+
+/*
+=================
+Controls_SetConfig
+=================
+*/
+void Controls_SetConfig(qboolean restart)
+{
+	int		i;
+
+	// iterate each command, get its numeric binding
+	for (i=0; i < g_bindCount; i++)
+	{
+		if (g_bindings[i].bind1 != -1)
+		{	
+			DC->setBinding( g_bindings[i].bind1, g_bindings[i].command );
+
+			if (g_bindings[i].bind2 != -1)
+				DC->setBinding( g_bindings[i].bind2, g_bindings[i].command );
+		}
+	}
+
+	//if ( s_controls.invertmouse.curvalue )
+	//	DC->setCVar("m_pitch", va("%f),-fabs( DC->getCVarValue( "m_pitch" ) ) );
+	//else
+	//	trap_Cvar_SetValue( "m_pitch", fabs( trap_Cvar_VariableValue( "m_pitch" ) ) );
+
+	//trap_Cvar_SetValue( "m_filter", s_controls.smoothmouse.curvalue );
+	//trap_Cvar_SetValue( "cl_run", s_controls.alwaysrun.curvalue );
+	//trap_Cvar_SetValue( "cg_autoswitch", s_controls.autoswitch.curvalue );
+	//trap_Cvar_SetValue( "sensitivity", s_controls.sensitivity.curvalue );
+	//trap_Cvar_SetValue( "in_joystick", s_controls.joyenable.curvalue );
+	//trap_Cvar_SetValue( "joy_threshold", s_controls.joythreshold.curvalue );
+	//trap_Cvar_SetValue( "cl_freelook", s_controls.freelook.curvalue );
+//
+//	DC->executeText(EXEC_APPEND, "in_restart\n");
+// ^--this is bad, it shows the cursor during map load, if you need to, add it as an exec cmd to use_joy or something.
+}
+
+void Item_Bind_Ungrey(itemDef_t *item)
+{
+	menuDef_t *menu;
+	int i;
+
+	menu = (menuDef_t *) item->parent;
+	for (i=0;i<menu->itemCount;++i)
+	{
+		if (menu->items[i] == item)
+		{
+			continue;
+		}
+
+		menu->items[i]->window.flags &= ~WINDOW_INACTIVE;
+	}
+}
+
+/*
+=================
+Item_Bind_HandleKey
+=================
+*/
+qboolean Item_Bind_HandleKey(itemDef_t *item, int key, qboolean down) 
+{
+	int			id;
+	int			i;
+	menuDef_t *menu;
+
+	if (key == A_MOUSE1 && Rect_ContainsPoint(&item->window.rect, DC->cursorx, DC->cursory) && !g_waitingForKey)
+	{
+		if (down) 
+		{
+			g_waitingForKey = qtrue;
+			g_bindItem = item;
+
+			// Set all others in the menu to grey
+			menu = (menuDef_t *) item->parent;
+			for (i=0;i<menu->itemCount;++i)
+			{
+				if (menu->items[i] == item)
+				{
+					continue;
+				}
+				menu->items[i]->window.flags |= WINDOW_INACTIVE;
+			}
+
+		}
+		return qtrue;
+	}
+	else if (key == A_ENTER && !g_waitingForKey)
+	{
+		if (down) 
+		{
+			g_waitingForKey = qtrue;
+			g_bindItem = item;
+
+			// Set all others in the menu to grey
+			menu = (menuDef_t *) item->parent;
+			for (i=0;i<menu->itemCount;++i)
+			{
+				if (menu->items[i] == item)
+				{
+					continue;
+				}
+				menu->items[i]->window.flags |= WINDOW_INACTIVE;
+			}
+
+		}
+		return qtrue;
+	}
+	else
+	{
+		if (!g_waitingForKey || g_bindItem == NULL) 
+		{
+			return qfalse;
+		}
+
+		if (key & K_CHAR_FLAG) 
+		{
+			return qtrue;
+		}
+
+		switch (key)
+		{
+			case A_ESCAPE:
+				g_waitingForKey = qfalse;
+				Item_Bind_Ungrey(item);
+				return qtrue;
+	
+			case A_BACKSPACE:
+				id = BindingIDFromName(item->cvar);
+				if (id != -1) 
+				{
+					DC->setBinding( g_bindings[id].bind1, "" );
+					DC->setBinding( g_bindings[id].bind2, "" );
+					g_bindings[id].bind1 = -1;
+					g_bindings[id].bind2 = -1;
+				}
+				Controls_SetConfig(qtrue);
+				g_waitingForKey = qfalse;
+				g_bindItem = NULL;
+				Item_Bind_Ungrey(item);
+				return qtrue;
+				break;
+			case '`':
+				return qtrue;
+		}
+	}
+
+	// Is the same key being bound to something else?
+	if (key != -1)
+	{
+
+		for (i=0; i < g_bindCount; i++)
+		{
+			// The second binding matches the key
+			if (g_bindings[i].bind2 == key) 
+			{
+				g_bindings[i].bind2 = -1;	// NULL it out
+			}
+
+			if (g_bindings[i].bind1 == key)
+			{
+				g_bindings[i].bind1 = g_bindings[i].bind2;
+				g_bindings[i].bind2 = -1;
+			}
+		}
+	}
+
+
+	id = BindingIDFromName(item->cvar);
+
+	if (id != -1) 
+	{
+		if (key == -1) 
+		{
+			if( g_bindings[id].bind1 != -1 ) 
+			{
+				DC->setBinding( g_bindings[id].bind1, "" );
+				g_bindings[id].bind1 = -1;
+			}
+			if( g_bindings[id].bind2 != -1 ) 
+			{
+				DC->setBinding( g_bindings[id].bind2, "" );
+				g_bindings[id].bind2 = -1;
+			}
+		}
+		else if (g_bindings[id].bind1 == -1) 
+		{
+			g_bindings[id].bind1 = key;
+		}
+		else if (g_bindings[id].bind1 != key && g_bindings[id].bind2 == -1) 
+		{
+			g_bindings[id].bind2 = key;
+		}
+		else 
+		{
+			DC->setBinding( g_bindings[id].bind1, "" );
+			DC->setBinding( g_bindings[id].bind2, "" );
+			g_bindings[id].bind1 = key;
+			g_bindings[id].bind2 = -1;
+		}						
+	}
+
+	Controls_SetConfig(qtrue);	
+	g_waitingForKey = qfalse;
+	Item_Bind_Ungrey(item);
+
+	return qtrue;
+}
+
+/*
+=================
+Menu_SetNextCursorItem
+=================
+*/
+itemDef_t *Menu_SetNextCursorItem(menuDef_t *menu) 
+{
+
+	qboolean wrapped = qfalse;
+	int oldCursor = menu->cursorItem;
+
+
+	if (menu->cursorItem == -1) 
+	{
+		menu->cursorItem = 0;
+		wrapped = qtrue;
+	}
+
+	while (menu->cursorItem < menu->itemCount) 
+	{
+
+		menu->cursorItem++;
+		if (menu->cursorItem >= menu->itemCount && !wrapped) 
+		{
+		  wrapped = qtrue;
+		  menu->cursorItem = 0;
+		}
+
+		if (Item_SetFocus(menu->items[menu->cursorItem], DC->cursorx, DC->cursory)) 
+		{
+			Menu_HandleMouseMove(menu, menu->items[menu->cursorItem]->window.rect.x + 1, menu->items[menu->cursorItem]->window.rect.y + 1);
+			return menu->items[menu->cursorItem];
+		}
+	}
+
+	menu->cursorItem = oldCursor;
+	return NULL;
+}
+
+/*
+=================
+Menu_SetPrevCursorItem
+=================
+*/
+itemDef_t *Menu_SetPrevCursorItem(menuDef_t *menu) 
+{
+	qboolean wrapped = qfalse;
+	int oldCursor = menu->cursorItem;
+
+	if (menu->cursorItem < 0) 
+	{
+		menu->cursorItem = menu->itemCount-1;
+		wrapped = qtrue;
+	} 
+
+	while (menu->cursorItem > -1) 
+	{
+		menu->cursorItem--;
+		if (menu->cursorItem < 0 ) 
+		{
+			if (wrapped)
+		{
+				break;
+			}
+			wrapped = qtrue;
+			menu->cursorItem = menu->itemCount -1;
+		}
+
+		if (Item_SetFocus(menu->items[menu->cursorItem], DC->cursorx, DC->cursory)) 
+		{
+			Menu_HandleMouseMove(menu, menu->items[menu->cursorItem]->window.rect.x + 1, menu->items[menu->cursorItem]->window.rect.y + 1);
+			return menu->items[menu->cursorItem];
+		}
+	}
+	menu->cursorItem = oldCursor;
+	return NULL;
+
+}
+/*
+=================
+Item_TextField_HandleKey
+=================
+*/
+qboolean Item_TextField_HandleKey(itemDef_t *item, int key) 
+{
+	char buff[1024];
+	int len;
+	itemDef_t *newItem = NULL;
+	editFieldDef_t *editPtr = (editFieldDef_t*)item->typeData;
+
+	if (item->cvar) 
+	{
+
+		memset(buff, 0, sizeof(buff));
+		DC->getCVarString(item->cvar, buff, sizeof(buff));
+		len = strlen(buff);
+		if (editPtr->maxChars && len > editPtr->maxChars) 
+		{
+			len = editPtr->maxChars;
+		}
+
+		if ( key & K_CHAR_FLAG ) 
+		{
+			key &= ~K_CHAR_FLAG;
+
+
+			if (key == 'h' - 'a' + 1 )	
+			{	// ctrl-h is backspace
+				if ( item->cursorPos > 0 ) 
+				{
+					memmove( &buff[item->cursorPos - 1], &buff[item->cursorPos], len + 1 - item->cursorPos);
+					item->cursorPos--;
+					if (item->cursorPos < editPtr->paintOffset) 
+					{
+						editPtr->paintOffset--;
+					}
+				}
+				DC->setCVar(item->cvar, buff);
+	    		return qtrue;
+			}
+
+			//
+			// ignore any non printable chars
+			//
+			if ( key < 32 || !item->cvar) 
+			{
+			    return qtrue;
+		    }
+
+			if (item->type == ITEM_TYPE_NUMERICFIELD) 
+			{
+				if (key < '0' || key > '9') 
+				{
+					return qfalse;
+				}
+			}
+
+			if (!DC->getOverstrikeMode()) 
+			{
+				if (( len == MAX_EDITFIELD - 1 ) || (editPtr->maxChars && len >= editPtr->maxChars)) 
+				{
+					return qtrue;
+				}
+				memmove( &buff[item->cursorPos + 1], &buff[item->cursorPos], len + 1 - item->cursorPos );
+			} 
+			else 
+			{
+				if (editPtr->maxChars && item->cursorPos >= editPtr->maxChars) 
+				{
+					return qtrue;
+				}
+			}
+
+			buff[item->cursorPos] = key;
+
+			DC->setCVar(item->cvar, buff);
+
+			if (item->cursorPos < len + 1) 
+			{
+				item->cursorPos++;
+				if (editPtr->maxPaintChars && item->cursorPos > editPtr->maxPaintChars) 
+				{
+					editPtr->paintOffset++;
+				}
+			}
+
+		} 
+		else 
+		{
+
+			if ( key == A_DELETE || key == A_KP_PERIOD ) 
+			{
+				if ( item->cursorPos < len ) 
+				{
+					memmove( buff + item->cursorPos, buff + item->cursorPos + 1, len - item->cursorPos);
+					DC->setCVar(item->cvar, buff);
+				}
+				return qtrue;
+			}
+
+			if ( key == A_CURSOR_RIGHT || key == A_KP_6 ) 
+			{
+				if (editPtr->maxPaintChars && item->cursorPos >= editPtr->maxPaintChars && item->cursorPos < len) 
+				{
+					item->cursorPos++;
+					editPtr->paintOffset++;
+					return qtrue;
+				}
+
+				if (item->cursorPos < len) 
+				{
+					item->cursorPos++;
+				} 
+				return qtrue;
+			}
+
+			if ( key == A_CURSOR_LEFT|| key == A_KP_4 ) 
+			{
+				if ( item->cursorPos > 0 ) 
+				{
+					item->cursorPos--;
+				}
+				if (item->cursorPos < editPtr->paintOffset) 
+				{
+					editPtr->paintOffset--;
+				}
+				return qtrue;
+			}
+
+			if ( key == A_HOME || key == A_KP_7) 
+			{
+				item->cursorPos = 0;
+				editPtr->paintOffset = 0;
+				return qtrue;
+			}
+
+			if ( key == A_END || key == A_KP_1)  
+			{
+				item->cursorPos = len;
+				if(item->cursorPos > editPtr->maxPaintChars) 
+				{
+					editPtr->paintOffset = len - editPtr->maxPaintChars;
+				}
+				return qtrue;
+			}
+
+			if ( key == A_INSERT || key == A_KP_0 ) 
+			{
+				DC->setOverstrikeMode(!DC->getOverstrikeMode());
+				return qtrue;
+			}
+		}
+
+		if (key == A_TAB || key == A_CURSOR_DOWN || key == A_KP_2) 
+		{
+			newItem = Menu_SetNextCursorItem((menuDef_t *) item->parent);
+			if (newItem && (newItem->type == ITEM_TYPE_EDITFIELD || newItem->type == ITEM_TYPE_NUMERICFIELD)) 
+			{
+				g_editItem = newItem;
+			}
+		}
+
+		if (key == A_CURSOR_UP || key == A_KP_8) 
+		{
+			newItem = Menu_SetPrevCursorItem((menuDef_t *) item->parent);
+			if (newItem && (newItem->type == ITEM_TYPE_EDITFIELD || newItem->type == ITEM_TYPE_NUMERICFIELD)) 
+			{
+				g_editItem = newItem;
+			}
+		}
+
+		if ( key == A_ENTER || key == A_KP_ENTER || key == A_ESCAPE)  
+		{
+			return qfalse;
+		}
+
+		return qtrue;
+	}
+	return qfalse;
+
+}
+
+static void Scroll_TextScroll_AutoFunc (void *p) 
+{
+	scrollInfo_t *si = (scrollInfo_t*)p;
+
+	if (DC->realTime > si->nextScrollTime) 
+	{ 
+		// need to scroll which is done by simulating a click to the item
+		// this is done a bit sideways as the autoscroll "knows" that the item is a listbox
+		// so it calls it directly
+		Item_TextScroll_HandleKey(si->item, si->scrollKey, qtrue, qfalse);
+		si->nextScrollTime = DC->realTime + si->adjustValue; 
+	}
+
+	if (DC->realTime > si->nextAdjustTime) 
+	{
+		si->nextAdjustTime = DC->realTime + SCROLL_TIME_ADJUST;
+		if (si->adjustValue > SCROLL_TIME_FLOOR) 
+		{
+			si->adjustValue -= SCROLL_TIME_ADJUSTOFFSET;
+		}
+	}
+}
+
+static void Scroll_TextScroll_ThumbFunc(void *p) 
+{
+	scrollInfo_t *si = (scrollInfo_t*)p;
+	rectDef_t	 r;
+	int			 pos;
+	int			 max;
+
+	textScrollDef_t *scrollPtr = (textScrollDef_t*)si->item->typeData;
+
+	if (DC->cursory != si->yStart) 
+	{
+		r.x = si->item->window.rect.x + si->item->window.rect.w - SCROLLBAR_SIZE - 1;
+		r.y = si->item->window.rect.y + SCROLLBAR_SIZE + 1;
+		r.h = si->item->window.rect.h - (SCROLLBAR_SIZE*2) - 2;
+		r.w = SCROLLBAR_SIZE;
+		max = Item_TextScroll_MaxScroll(si->item);
+		//
+		pos = (DC->cursory - r.y - SCROLLBAR_SIZE/2) * max / (r.h - SCROLLBAR_SIZE);
+		if (pos < 0) 
+		{
+			pos = 0;
+		}
+		else if (pos > max) 
+		{
+			pos = max;
+		}
+
+		scrollPtr->startPos = pos;
+		si->yStart = DC->cursory;
+	}
+
+	if (DC->realTime > si->nextScrollTime) 
+	{ 
+		// need to scroll which is done by simulating a click to the item
+		// this is done a bit sideways as the autoscroll "knows" that the item is a listbox
+		// so it calls it directly
+		Item_TextScroll_HandleKey(si->item, si->scrollKey, qtrue, qfalse);
+		si->nextScrollTime = DC->realTime + si->adjustValue; 
+	}
+
+	if (DC->realTime > si->nextAdjustTime) 
+	{
+		si->nextAdjustTime = DC->realTime + SCROLL_TIME_ADJUST;
+		if (si->adjustValue > SCROLL_TIME_FLOOR) 
+		{
+			si->adjustValue -= SCROLL_TIME_ADJUSTOFFSET;
+		}
+	}
+}
+
+/*
+=================
+Menu_OverActiveItem
+=================
+*/
+static qboolean Menu_OverActiveItem(menuDef_t *menu, float x, float y) 
+{
+	if (menu && menu->window.flags & (WINDOW_VISIBLE | WINDOW_FORCED)) 
+	{
+//JLFMOUSE
+#ifdef _XBOX
+		return qtrue;
+#endif
+		if (Rect_ContainsPoint(&menu->window.rect, x, y)) 
+		{
+			int i;
+			for (i = 0; i < menu->itemCount; i++) 
+			{
+			// turn off focus each item
+			// menu->items[i].window.flags &= ~WINDOW_HASFOCUS;
+
+				if (!(menu->items[i]->window.flags & (WINDOW_VISIBLE | WINDOW_FORCED))) 
+				{
+					continue;
+				}
+
+				if (menu->items[i]->window.flags & WINDOW_DECORATION) 
+				{
+					continue;
+				}
+
+				if (Rect_ContainsPoint(&menu->items[i]->window.rect, x, y)) 
+				{
+					itemDef_t *overItem = menu->items[i];
+					if (overItem->type == ITEM_TYPE_TEXT && overItem->text) 
+					{
+						if (Rect_ContainsPoint(&overItem->window.rect, x, y)) 
+						{
+							return qtrue;
+						} 
+						else 
+						{
+							continue;
+						}
+					} 
+					else 
+					{
+						return qtrue;
+					}
+				}
+			}
+		}
+	}
+	return qfalse;
+}
+
+/*
+=================
+Display_VisibleMenuCount
+=================
+*/
+int Display_VisibleMenuCount(void) 
+{
+	int i, count;
+	count = 0;
+	for (i = 0; i < menuCount; i++) 
+	{
+		if (Menus[i].window.flags & (WINDOW_FORCED | WINDOW_VISIBLE)) 
+		{
+			count++;
+		}
+	}
+	return count;
+}
+
+/*
+=================
+Window_CloseCinematic
+=================
+*/
+static void Window_CloseCinematic(windowDef_t *window) 
+{
+	if (window->style == WINDOW_STYLE_CINEMATIC && window->cinematic >= 0) 
+	{
+		DC->stopCinematic(window->cinematic);
+		window->cinematic = -1;
+	}
+}
+/*
+=================
+Menu_CloseCinematics
+=================
+*/
+static void Menu_CloseCinematics(menuDef_t *menu) 
+{
+	if (menu) 
+	{
+		int i;
+		Window_CloseCinematic(&menu->window);
+		for (i = 0; i < menu->itemCount; i++) 
+		{
+			Window_CloseCinematic(&menu->items[i]->window);
+			if (menu->items[i]->type == ITEM_TYPE_OWNERDRAW) 
+			{
+				DC->stopCinematic(0-menu->items[i]->window.ownerDraw);
+			}
+		}
+	}
+}
+
+/*
+=================
+Display_CloseCinematics
+=================
+*/
+static void Display_CloseCinematics() 
+{
+	int i;
+	for (i = 0; i < menuCount; i++) 
+	{
+		Menu_CloseCinematics(&Menus[i]);
+	}
+}
+
+/*
+=================
+Menus_HandleOOBClick
+=================
+*/
+void Menus_HandleOOBClick(menuDef_t *menu, int key, qboolean down) 
+{
+	if (menu) 
+	{
+//JLFMOUSE
+#ifdef _XBOX
+		Menu_HandleMouseMove(menu, DC->cursorx, DC->cursory);
+		Menu_HandleKey(menu, key, down);
+		return; 
+#endif
+		int i;
+		// basically the behaviour we are looking for is if there are windows in the stack.. see if 
+		// the cursor is within any of them.. if not close them otherwise activate them and pass the 
+		// key on.. force a mouse move to activate focus and script stuff 
+		if (down && menu->window.flags & WINDOW_OOB_CLICK) 
+		{
+			Menu_RunCloseScript(menu);
+			menu->window.flags &= ~(WINDOW_HASFOCUS | WINDOW_VISIBLE);
+		}
+
+		for (i = 0; i < menuCount; i++) 
+		{
+			if (Menu_OverActiveItem(&Menus[i], DC->cursorx, DC->cursory)) 
+			{
+				Menu_RunCloseScript(menu);
+				menu->window.flags &= ~(WINDOW_HASFOCUS | WINDOW_VISIBLE);
+				Menus_Activate(&Menus[i]);
+				Menu_HandleMouseMove(&Menus[i], DC->cursorx, DC->cursory);
+				Menu_HandleKey(&Menus[i], key, down);
+#ifdef _XBOX
+			break;
+#endif
+			}
+		}
+
+		if (Display_VisibleMenuCount() == 0) 
+		{
+			if (DC->Pause) 
+			{
+				DC->Pause(qfalse);
+			}
+		}
+		Display_CloseCinematics();
+	}
+}
+
+/*
+=================
+Item_StopCapture
+=================
+*/
+void Item_StopCapture(itemDef_t *item) 
+{
+
+}
+
+/*
+=================
+Item_ListBox_HandleKey
+=================
+*/
+qboolean Item_ListBox_HandleKey(itemDef_t *item, int key, qboolean down, qboolean force) 
+{
+	listBoxDef_t *listPtr = (listBoxDef_t*)item->typeData;
+	int count = DC->feederCount(item->special);
+	int max, viewmax;
+//JLFMOUSE
+#ifndef _XBOX
+	if (force || (Rect_ContainsPoint(&item->window.rect, DC->cursorx, DC->cursory) && item->window.flags & WINDOW_HASFOCUS))
+#else
+	if (force || item->window.flags & WINDOW_HASFOCUS)
+#endif
+	{
+		max = Item_ListBox_MaxScroll(item);
+		if (item->window.flags & WINDOW_HORIZONTAL) 
+		{
+			viewmax = (item->window.rect.w / listPtr->elementWidth);
+			if ( key == A_CURSOR_LEFT || key == A_KP_4 ) 
+			{
+				if (!listPtr->notselectable) 
+				{
+					listPtr->cursorPos--;
+					if (listPtr->cursorPos < 0) 
+					{
+						listPtr->cursorPos = 0;
+#ifdef _XBOX
+						return qfalse;
+#endif
+					}
+					if (listPtr->cursorPos < listPtr->startPos) 
+					{
+						listPtr->startPos = listPtr->cursorPos;
+					}
+					if (listPtr->cursorPos >= listPtr->startPos + viewmax) 
+					{
+						listPtr->startPos = listPtr->cursorPos - viewmax + 1;
+					}
+					item->cursorPos = listPtr->cursorPos;
+
+					DC->feederSelection(item->special, item->cursorPos, item);
+
+				}
+				else 
+				{
+					listPtr->startPos--;
+//JLF
+#ifdef _XBOX // MPMOVED
+					listPtr->cursorPos--;
+					if (listPtr->cursorPos >= 0)
+						DC->feederSelection(item->special, listPtr->cursorPos, item);
+					else
+						listPtr->cursorPos =0;
+#endif
+					if (listPtr->startPos < 0)
+					{
+						listPtr->startPos = 0;
+//JLFMOUSE
+#ifdef _XBOX // MPMOVED
+						return false;
+#endif
+
+					}
+				}
+				return qtrue;
+			}
+			if ( key == A_CURSOR_RIGHT || key == A_KP_6 ) 
+			{
+				if (!listPtr->notselectable) 
+				{
+					listPtr->cursorPos++;
+
+					if (listPtr->cursorPos < listPtr->startPos) 
+					{
+						listPtr->startPos = listPtr->cursorPos;
+					}
+					if (listPtr->cursorPos >= count) 
+					{
+						listPtr->cursorPos = count-1;
+#ifdef _XBOX
+						return qfalse;
+#endif
+					}
+					if (listPtr->cursorPos >= listPtr->startPos + viewmax) 
+					{
+						listPtr->startPos = listPtr->cursorPos - viewmax + 1;
+					}
+					item->cursorPos = listPtr->cursorPos;
+
+					DC->feederSelection(item->special, item->cursorPos, item);
+				}
+				else 
+				{
+					listPtr->startPos++;
+//JLF
+#ifdef _XBOX // MPMOVED
+					listPtr->cursorPos++;
+					if (listPtr->cursorPos < count)
+						DC->feederSelection(item->special, listPtr->cursorPos, item);
+					else
+						listPtr->cursorPos =count -1;
+#endif
+					if (listPtr->startPos >= count)
+					{
+						listPtr->startPos = count-1;
+//JLFMOUSE
+#ifdef _XBOX // MPMOVED
+						return false;
+#endif
+
+					}
+				}
+				return qtrue;
+			}
+		}
+		else 
+		{
+			viewmax = (item->window.rect.h / listPtr->elementHeight);
+			if ( key == A_CURSOR_UP || key == A_KP_8 ) 
+			{
+				if (!listPtr->notselectable) 
+				{
+					listPtr->cursorPos--;
+
+					if (listPtr->cursorPos < 0) 
+					{
+						listPtr->cursorPos = 0;
+#ifdef _XBOX
+						return qfalse;
+#endif
+					}
+					if (listPtr->cursorPos < listPtr->startPos) 
+					{
+						listPtr->startPos = listPtr->cursorPos;
+					}
+					if (listPtr->cursorPos >= listPtr->startPos + viewmax) 
+					{
+						listPtr->startPos = listPtr->cursorPos - viewmax + 1;
+					}
+					item->cursorPos = listPtr->cursorPos;
+
+					DC->feederSelection(item->special, item->cursorPos, item);
+				}
+				else 
+				{
+					listPtr->startPos--;
+//JLF
+#ifdef _XBOX // MPMOVED
+					listPtr->cursorPos--;
+					if (listPtr->cursorPos >= 0)
+						DC->feederSelection(item->special, listPtr->cursorPos, item);
+					else
+						listPtr->cursorPos = 0;
+#endif
+
+					if (listPtr->startPos < 0)
+					{
+						listPtr->startPos = 0;
+//JLFMOUSE
+#ifdef _XBOX // MPMOVED
+						return false;
+#endif
+
+					}
+				}
+				return qtrue;
+			}
+			if ( key == A_CURSOR_DOWN || key == A_KP_2 ) 
+			{
+				if (!listPtr->notselectable) 
+				{
+					listPtr->cursorPos++;
+					if (listPtr->cursorPos < listPtr->startPos) 
+					{
+						listPtr->startPos = listPtr->cursorPos;
+					}
+					if (listPtr->cursorPos >= count) 
+					{
+						listPtr->cursorPos = count-1;
+#ifdef _XBOX
+						return qfalse;
+#endif
+					}
+					if (listPtr->cursorPos >= listPtr->startPos + viewmax) 
+					{
+						listPtr->startPos = listPtr->cursorPos - viewmax + 1;
+					}
+					item->cursorPos = listPtr->cursorPos;
+
+					DC->feederSelection(item->special, item->cursorPos, item);
+
+				}
+				else 
+				{
+					listPtr->startPos++;
+//JLF
+#ifdef _XBOX // MPMOVED
+					listPtr->cursorPos++;
+					if (listPtr->cursorPos < count)
+						DC->feederSelection(item->special, listPtr->cursorPos, item);
+					else
+						listPtr->cursorPos = count -1;
+#endif
+
+				
+//JLFMOUSE
+#ifdef _XBOX // MPMOVED
+					if (listPtr->startPos > count-1)
+					{
+						listPtr->startPos = count-1;
+						return false;
+#else
+
+					if (listPtr->startPos > max)
+					{
+						listPtr->startPos = max;
+#endif
+
+					}
+				}
+				return qtrue;
+			}
+		}
+		// mouse hit
+		if (key == A_MOUSE1 || key == A_MOUSE2) 
+		{
+			if (item->window.flags & WINDOW_LB_LEFTARROW) 
+			{
+	 			listPtr->startPos--;
+				if (listPtr->startPos < 0) 
+				{
+					listPtr->startPos = 0;
+//JLFMOUSE
+#ifdef _XBOX // MPMOVED
+						return false;
+#endif
+
+				}
+			} 
+			else if (item->window.flags & WINDOW_LB_RIGHTARROW) 
+			{
+				// one down
+				listPtr->startPos++;
+				if (listPtr->startPos > max) 
+				{
+					listPtr->startPos = max;
+//JLFMOUSE
+#ifdef _XBOX // MPMOVED
+						return false;
+#endif
+
+				}
+			} 
+			else if (item->window.flags & WINDOW_LB_PGUP) 
+			{
+				// page up
+				listPtr->startPos -= viewmax;
+				if (listPtr->startPos < 0) 
+				{
+					listPtr->startPos = 0;
+//JLFMOUSE
+#ifdef _XBOX // MPMOVED
+						return false;
+#endif
+
+				}
+			} 
+			else if (item->window.flags & WINDOW_LB_PGDN) 
+			{
+				// page down
+				listPtr->startPos += viewmax;
+				if (listPtr->startPos > max) 
+				{
+					listPtr->startPos = max;
+//JLFMOUSE
+#ifdef _XBOX // MPMOVED
+						return false;
+#endif
+
+				}
+			} 
+			else if (item->window.flags & WINDOW_LB_THUMB) 
+			{
+				// Display_SetCaptureItem(item);
+			} 
+			else 
+			{
+				// select an item
+				if (DC->realTime < lastListBoxClickTime && listPtr->doubleClick) 
+				{
+					Item_RunScript(item, listPtr->doubleClick);
+				}
+				lastListBoxClickTime = DC->realTime + DOUBLE_CLICK_DELAY;
+				item->cursorPos = listPtr->cursorPos;
+				DC->feederSelection(item->special, item->cursorPos, item);
+			}
+			return qtrue;
+		}
+		if ( key == A_HOME || key == A_KP_7) 
+		{
+			// home
+			listPtr->startPos = 0;
+			return qtrue;
+		}
+		if ( key == A_END || key == A_KP_1) 
+		{
+			// end
+			listPtr->startPos = max;
+			return qtrue;
+		}
+		if (key == A_PAGE_UP || key == A_KP_9 ) 
+		{
+			// page up
+			if (!listPtr->notselectable) 
+			{
+				listPtr->cursorPos -= viewmax;
+				if (listPtr->cursorPos < 0) 
+				{
+					listPtr->cursorPos = 0;
+				}
+				if (listPtr->cursorPos < listPtr->startPos) 
+				{
+					listPtr->startPos = listPtr->cursorPos;
+				}
+				if (listPtr->cursorPos >= listPtr->startPos + viewmax) 
+				{
+					listPtr->startPos = listPtr->cursorPos - viewmax + 1;
+				}
+				item->cursorPos = listPtr->cursorPos;
+				DC->feederSelection(item->special, item->cursorPos, item);
+			}
+			else 
+			{
+				listPtr->startPos -= viewmax;
+				if (listPtr->startPos < 0) 
+				{
+					listPtr->startPos = 0;
+				}
+			}
+			return qtrue;
+		}
+		if ( key == A_PAGE_DOWN || key == A_KP_3 ) 
+		{
+			// page down
+			if (!listPtr->notselectable) 
+			{
+				listPtr->cursorPos += viewmax;
+				if (listPtr->cursorPos < listPtr->startPos) 
+				{
+					listPtr->startPos = listPtr->cursorPos;
+				}
+				if (listPtr->cursorPos >= count) 
+				{
+					listPtr->cursorPos = count-1;
+				}
+				if (listPtr->cursorPos >= listPtr->startPos + viewmax) 
+				{
+					listPtr->startPos = listPtr->cursorPos - viewmax + 1;
+				}
+				item->cursorPos = listPtr->cursorPos;
+				DC->feederSelection(item->special, item->cursorPos, item);
+			}
+			else 
+			{
+				listPtr->startPos += viewmax;
+				if (listPtr->startPos > max) 
+				{
+					listPtr->startPos = max;
+				}
+			}
+			return qtrue;
+		}
+	}
+	return qfalse;
+}
+
+/*
+=================
+Scroll_ListBox_AutoFunc
+=================
+*/
+static void Scroll_ListBox_AutoFunc(void *p) 
+{
+	scrollInfo_t *si = (scrollInfo_t*)p;
+	if (DC->realTime > si->nextScrollTime) 
+	{		
+		// need to scroll which is done by simulating a click to the item
+		// this is done a bit sideways as the autoscroll "knows" that the item is a listbox
+		// so it calls it directly
+		Item_ListBox_HandleKey(si->item, si->scrollKey, qtrue, qfalse);
+		si->nextScrollTime = DC->realTime + si->adjustValue; 
+	}
+
+	if (DC->realTime > si->nextAdjustTime) 
+	{
+		si->nextAdjustTime = DC->realTime + SCROLL_TIME_ADJUST;
+		if (si->adjustValue > SCROLL_TIME_FLOOR) 
+		{
+			si->adjustValue -= SCROLL_TIME_ADJUSTOFFSET;
+		}
+	}
+}
+
+/*
+=================
+Scroll_ListBox_ThumbFunc
+=================
+*/
+static void Scroll_ListBox_ThumbFunc(void *p) 
+{
+	scrollInfo_t *si = (scrollInfo_t*)p;
+	rectDef_t r;
+	int pos, max;
+
+	listBoxDef_t *listPtr = (listBoxDef_t*)si->item->typeData;
+	if (si->item->window.flags & WINDOW_HORIZONTAL) 
+	{
+		if (DC->cursorx == si->xStart) 
+		{
+			return;
+		}
+		r.x = si->item->window.rect.x + SCROLLBAR_SIZE + 1;
+		r.y = si->item->window.rect.y + si->item->window.rect.h - SCROLLBAR_SIZE - 1;
+		r.h = SCROLLBAR_SIZE;
+		r.w = si->item->window.rect.w - (SCROLLBAR_SIZE*2) - 2;
+		max = Item_ListBox_MaxScroll(si->item);
+		//
+		pos = (DC->cursorx - r.x - SCROLLBAR_SIZE/2) * max / (r.w - SCROLLBAR_SIZE);
+		if (pos < 0) 
+		{
+			pos = 0;
+		}
+		else if (pos > max) 
+		{
+			pos = max;
+		}
+		listPtr->startPos = pos;
+		si->xStart = DC->cursorx;
+	}
+	else if (DC->cursory != si->yStart) 
+	{
+
+		r.x = si->item->window.rect.x + si->item->window.rect.w - SCROLLBAR_SIZE - 1;
+		r.y = si->item->window.rect.y + SCROLLBAR_SIZE + 1;
+		r.h = si->item->window.rect.h - (SCROLLBAR_SIZE*2) - 2;
+		r.w = SCROLLBAR_SIZE;
+		max = Item_ListBox_MaxScroll(si->item);
+		//
+		pos = (DC->cursory - r.y - SCROLLBAR_SIZE/2) * max / (r.h - SCROLLBAR_SIZE);
+		if (pos < 0) 
+		{
+			pos = 0;
+		}
+		else if (pos > max) 
+		{
+			pos = max;
+		}
+		listPtr->startPos = pos;
+		si->yStart = DC->cursory;
+	}
+
+	if (DC->realTime > si->nextScrollTime) 
+	{	
+		// need to scroll which is done by simulating a click to the item
+		// this is done a bit sideways as the autoscroll "knows" that the item is a listbox
+		// so it calls it directly
+		Item_ListBox_HandleKey(si->item, si->scrollKey, qtrue, qfalse);
+		si->nextScrollTime = DC->realTime + si->adjustValue; 
+	}
+
+	if (DC->realTime > si->nextAdjustTime) 
+	{
+		si->nextAdjustTime = DC->realTime + SCROLL_TIME_ADJUST;
+		if (si->adjustValue > SCROLL_TIME_FLOOR) 
+		{
+			si->adjustValue -= SCROLL_TIME_ADJUSTOFFSET;
+		}
+	}
+}
+
+/*
+=================
+Item_Slider_OverSlider
+=================
+*/
+int Item_Slider_OverSlider(itemDef_t *item, float x, float y) 
+{
+	rectDef_t r;
+
+	r.x = Item_Slider_ThumbPosition(item) - (SLIDER_THUMB_WIDTH / 2);
+	r.y = item->window.rect.y - 2;
+	r.w = SLIDER_THUMB_WIDTH;
+	r.h = SLIDER_THUMB_HEIGHT;
+
+	if (Rect_ContainsPoint(&r, x, y)) 
+	{
+		return WINDOW_LB_THUMB;
+	}
+	return 0;
+}
+
+/*
+=================
+Scroll_Slider_ThumbFunc
+=================
+*/
+static void Scroll_Slider_ThumbFunc(void *p) 
+{
+	float x, value, cursorx;
+	scrollInfo_t *si = (scrollInfo_t*)p;
+	editFieldDef_t *editDef = (struct editFieldDef_s *) si->item->typeData;
+
+	if (si->item->text) 
+	{
+		x = si->item->textRect.x + si->item->textRect.w + 8;
+	} 
+	else 
+	{
+		x = si->item->window.rect.x;
+	}
+
+	cursorx = DC->cursorx;
+
+	if (cursorx < x) 
+	{
+		cursorx = x;
+	} 
+	else if (cursorx > x + SLIDER_WIDTH) 
+	{
+		cursorx = x + SLIDER_WIDTH;
+	}
+	value = cursorx - x;
+	value /= SLIDER_WIDTH;
+	value *= (editDef->maxVal - editDef->minVal);
+	value += editDef->minVal;
+	DC->setCVar(si->item->cvar, va("%f", value));
+}
+/*
+=================
+Item_StartCapture
+=================
+*/
+void Item_StartCapture(itemDef_t *item, int key) 
+{
+	int flags;
+	switch (item->type) 
+	{
+		case ITEM_TYPE_EDITFIELD:
+		case ITEM_TYPE_NUMERICFIELD:
+
+		case ITEM_TYPE_LISTBOX:
+		{
+			flags = Item_ListBox_OverLB(item, DC->cursorx, DC->cursory);
+			if (flags & (WINDOW_LB_LEFTARROW | WINDOW_LB_RIGHTARROW)) 
+			{
+				scrollInfo.nextScrollTime = DC->realTime + SCROLL_TIME_START;
+				scrollInfo.nextAdjustTime = DC->realTime + SCROLL_TIME_ADJUST;
+				scrollInfo.adjustValue = SCROLL_TIME_START;
+				scrollInfo.scrollKey = key;
+				scrollInfo.scrollDir = (flags & WINDOW_LB_LEFTARROW) ? qtrue : qfalse;
+				scrollInfo.item = item;
+				captureData = &scrollInfo;
+				captureFunc = &Scroll_ListBox_AutoFunc;
+				itemCapture = item;
+			} 
+			else if (flags & WINDOW_LB_THUMB) 
+			{
+				scrollInfo.scrollKey = key;
+				scrollInfo.item = item;
+				scrollInfo.xStart = DC->cursorx;
+				scrollInfo.yStart = DC->cursory;
+				captureData = &scrollInfo;
+				captureFunc = &Scroll_ListBox_ThumbFunc;
+				itemCapture = item;
+			}
+			break;
+		}
+
+		case ITEM_TYPE_TEXTSCROLL:
+			flags = Item_TextScroll_OverLB (item, DC->cursorx, DC->cursory);
+			if (flags & (WINDOW_LB_LEFTARROW | WINDOW_LB_RIGHTARROW)) 
+			{
+				scrollInfo.nextScrollTime = DC->realTime + SCROLL_TIME_START;
+				scrollInfo.nextAdjustTime = DC->realTime + SCROLL_TIME_ADJUST;
+				scrollInfo.adjustValue = SCROLL_TIME_START;
+				scrollInfo.scrollKey = key;
+				scrollInfo.scrollDir = (flags & WINDOW_LB_LEFTARROW) ? qtrue : qfalse;
+				scrollInfo.item = item;
+				captureData = &scrollInfo;
+				captureFunc = &Scroll_TextScroll_AutoFunc;
+				itemCapture = item;
+			} 
+			else if (flags & WINDOW_LB_THUMB) 
+			{
+				scrollInfo.scrollKey = key;
+				scrollInfo.item = item;
+				scrollInfo.xStart = DC->cursorx;
+				scrollInfo.yStart = DC->cursory;
+				captureData = &scrollInfo;
+				captureFunc = &Scroll_TextScroll_ThumbFunc;
+				itemCapture = item;
+			}
+			break;
+
+		case ITEM_TYPE_SLIDER:
+		{
+			flags = Item_Slider_OverSlider(item, DC->cursorx, DC->cursory);
+			if (flags & WINDOW_LB_THUMB) 
+			{
+				scrollInfo.scrollKey = key;
+				scrollInfo.item = item;
+				scrollInfo.xStart = DC->cursorx;
+				scrollInfo.yStart = DC->cursory;
+				captureData = &scrollInfo;
+				captureFunc = &Scroll_Slider_ThumbFunc;
+				itemCapture = item;
+			}
+			break;
+		}
+	}
+}
+
+/*
+=================
+Item_YesNo_HandleKey
+=================
+*/
+qboolean Item_YesNo_HandleKey(itemDef_t *item, int key) 
+{
+//JLFMOUSE MPMOVED
+#ifndef _XBOX
+  if (Rect_ContainsPoint(&item->window.rect, DC->cursorx, DC->cursory) && item->window.flags & WINDOW_HASFOCUS && item->cvar) 
+#else
+	if (item->window.flags & WINDOW_HASFOCUS && item->cvar) 
+#endif	
+	{
+//JLFDPAD MPMOVED
+#ifndef _XBOX
+		if (key == A_MOUSE1 || key == A_ENTER || key == A_MOUSE2 || key == A_MOUSE3) 
+#else
+		if ( key == A_CURSOR_RIGHT || key == A_CURSOR_LEFT)
+#endif
+//end JLFDPAD
+		{
+			DC->setCVar(item->cvar, va("%i", !DC->getCVarValue(item->cvar)));
+			return qtrue;
+		}
+	}
+
+	return qfalse;
+
+}
+
+/*
+=================
+Item_Multi_FindCvarByValue
+=================
+*/
+int Item_Multi_FindCvarByValue(itemDef_t *item) 
+{
+	char buff[1024];
+	float value = 0;
+	int i;
+	multiDef_t *multiPtr = (multiDef_t*)item->typeData;
+	if (multiPtr) 
+	{
+		if (multiPtr->strDef) 
+		{
+			DC->getCVarString(item->cvar, buff, sizeof(buff));
+		} 
+		else 
+		{
+			value = DC->getCVarValue(item->cvar);
+		}
+		for (i = 0; i < multiPtr->count; i++) 
+		{
+			if (multiPtr->strDef) 
+			{
+				if (Q_stricmp(buff, multiPtr->cvarStr[i]) == 0) 
+				{
+					return i;
+				}
+			} 
+			else 
+			{
+ 				if (multiPtr->cvarValue[i] == value) 
+				{
+ 					return i;
+ 				}
+ 			}
+ 		}
+	}
+	return 0;
+}
+
+/*
+=================
+Item_Multi_CountSettings
+=================
+*/
+int Item_Multi_CountSettings(itemDef_t *item) 
+{
+	multiDef_t *multiPtr = (multiDef_t*)item->typeData;
+	if (multiPtr == NULL) 
+	{
+		return 0;
+	}
+	return multiPtr->count;
+}
+
+
+
+/*
+=================
+Item_OwnerDraw_HandleKey
+=================
+*/
+qboolean Item_OwnerDraw_HandleKey(itemDef_t *item, int key) 
+{
+  if (item && DC->ownerDrawHandleKey) 
+  {
+		return DC->ownerDrawHandleKey(item->window.ownerDraw, item->window.ownerDrawFlags, &item->special, key);
+  }
+  return qfalse;
+}
+
+//JLF new selection LEFT/RIGHT
+qboolean Item_Button_HandleKey(itemDef_t *item, int key) 
+{
+#ifdef _XBOX
+	if ( key == A_CURSOR_RIGHT)
+	{
+		if (Item_HandleSelectionNext(item))
+		{
+			//Item processed it 
+			return qtrue;
+		}
+	}
+	else if ( key ==  A_CURSOR_LEFT)
+	{
+		if (Item_HandleSelectionPrev(item))
+		{
+			//Item processed it 
+			return qtrue;
+		}
+	}
+#endif
+	return false;
+}
+
+
+/*
+=================
+Item_Text_HandleKey
+=================
+*/
+qboolean Item_Text_HandleKey(itemDef_t *item, int key) 
+{
+//JLFSELECTIONRightLeft
+#ifdef _XBOX
+	if ( key == A_CURSOR_RIGHT)
+	{
+		if (Item_HandleSelectionNext(item))
+		{
+			//Item processed it 
+			return qtrue;
+		}
+	}
+	else if ( key ==  A_CURSOR_LEFT)
+	{
+		if (Item_HandleSelectionPrev(item))
+		{
+			//Item processed it 
+			return qtrue;
+		}
+	}
+
+
+#else
+	if (Rect_ContainsPoint(&item->window.rect, DC->cursorx, DC->cursory) && item->window.flags & WINDOW_AUTOWRAPPED)
+
+
+	{
+		if (key == A_MOUSE1 || key == A_ENTER || key == A_MOUSE2 || key == A_MOUSE3) 
+		{
+			if (key == A_MOUSE2)
+			{
+				item->cursorPos--;
+				if ( item->cursorPos < 0 ) 
+				{
+					item->cursorPos = 0;
+				}
+			}
+			else if (item->special)
+			{
+				item->cursorPos++;
+				if ( item->cursorPos >= item->value ) 
+				{
+					item->cursorPos = 0;
+				}
+			}
+			return qtrue;
+		}
+	}
+#endif
+	return qfalse;
+}
+
+
+/*
+=================
+Item_Multi_HandleKey
+=================
+*/
+qboolean Item_Multi_HandleKey(itemDef_t *item, int key) 
+{
+	multiDef_t *multiPtr = (multiDef_t*)item->typeData;
+	if (multiPtr) 
+	{
+//JLF MPMOVED
+#ifndef _XBOX
+		if (Rect_ContainsPoint(&item->window.rect, DC->cursorx, DC->cursory) && item->window.flags & WINDOW_HASFOCUS) 
+#else
+		if (item->window.flags & WINDOW_HASFOCUS)// JLF* && item->cvar)
+#endif
+		{
+#ifndef _XBOX
+					
+			if (key == A_MOUSE1 || key == A_ENTER || key == A_MOUSE2 || key == A_MOUSE3) 
+#else
+//JLFDPAD MPMOVED
+		if ( key == A_CURSOR_RIGHT || key == A_CURSOR_LEFT)
+//end JLFDPAD
+#endif
+			{
+				if (item->cvar)
+				{
+					int current = Item_Multi_FindCvarByValue(item);
+					int max = Item_Multi_CountSettings(item);
+#ifndef _XBOX
+					if (key == A_MOUSE2)
+#else
+					if (key == A_CURSOR_LEFT)
+#endif
+					{
+						current--;
+						if ( current < 0 ) 
+						{
+							current = max-1;
+						}
+					}
+					else
+					{
+						current++;
+						if ( current >= max ) 
+						{
+							current = 0;
+						}
+					}
+
+					if (multiPtr->strDef) 
+					{
+						DC->setCVar(item->cvar, multiPtr->cvarStr[current]);
+					} 
+					else 
+					{
+						float value = multiPtr->cvarValue[current];
+						if (((float)((int) value)) == value) 
+						{
+							DC->setCVar(item->cvar, va("%i", (int) value ));
+						}
+						else 
+						{
+							DC->setCVar(item->cvar, va("%f", value ));
+						}
+					}
+					if (item->special)
+					{//its a feeder?
+						DC->feederSelection(item->special, current, item);
+					}
+				}
+				else
+				{
+					int max = Item_Multi_CountSettings(item);
+#ifndef _XBOX
+					if (key == A_MOUSE2)
+#else
+					if (key == A_CURSOR_LEFT)
+#endif
+					{
+						item->value--;
+						if ( item->value < 0 ) 
+						{
+							item->value = max;
+						}
+					}
+					else
+					{
+						item->value++;
+						if ( item->value >= max ) 
+						{
+							item->value = 0;
+						}
+					}
+					if (item->special)
+					{//its a feeder?
+						DC->feederSelection(item->special, item->value, item);
+					}
+				}
+//JLF
+#ifdef _XBOX
+				if ( key == A_CURSOR_RIGHT)
+				{
+					if (Item_HandleSelectionNext(item))
+					{
+						//Item processed it 
+						return qtrue;
+					}
+				}
+				else if ( key ==  A_CURSOR_LEFT)
+				{
+					if (Item_HandleSelectionPrev(item))
+					{
+						//Item processed it 
+						return qtrue;
+					}
+				}
+
+#endif
+
+				return qtrue;
+			}
+		}
+	}
+	return qfalse;
+}
+
+/*
+=================
+Item_Slider_HandleKey
+=================
+*/
+qboolean Item_Slider_HandleKey(itemDef_t *item, int key, qboolean down) 
+{
+	//DC->Print("slider handle key\n");
+//JLF MPMOVED
+#ifndef _XBOX
+	float x, value, width, work;
+
+	if (item->window.flags & WINDOW_HASFOCUS && item->cvar && Rect_ContainsPoint(&item->window.rect, DC->cursorx, DC->cursory)) 
+	{
+
+		if (key == A_MOUSE1 || key == A_ENTER || key == A_MOUSE2 || key == A_MOUSE3) 
+		{
+			editFieldDef_t *editDef = (editFieldDef_s *) item->typeData;
+			if (editDef) 
+			{
+				rectDef_t testRect;
+				width = SLIDER_WIDTH;
+				if (item->text) 
+				{
+					x = item->textRect.x + item->textRect.w + 8;
+				} 
+				else 
+				{
+					x = item->window.rect.x;
+				}
+
+				testRect = item->window.rect;
+				testRect.x = x;
+				value = (float)SLIDER_THUMB_WIDTH / 2;
+				testRect.x -= value;
+				//DC->Print("slider x: %f\n", testRect.x);
+				testRect.w = (SLIDER_WIDTH + (float)SLIDER_THUMB_WIDTH / 2);
+				//DC->Print("slider w: %f\n", testRect.w);
+				if (Rect_ContainsPoint(&testRect, DC->cursorx, DC->cursory)) 
+				{
+					work = DC->cursorx - x;
+					value = work / width;
+					value *= (editDef->maxVal - editDef->minVal);
+					// vm fuckage
+					// value = (((float)(DC->cursorx - x)/ SLIDER_WIDTH) * (editDef->maxVal - editDef->minVal));
+					value += editDef->minVal;
+					DC->setCVar(item->cvar, va("%f", value));
+					return qtrue;
+				}
+			}
+		}
+	}
+#else  //_XBOX
+	float value;
+
+	if (item->window.flags & WINDOW_HASFOCUS && item->cvar)
+	{
+		if (key == A_CURSOR_LEFT)
+		{
+			editFieldDef_t *editDef = (editFieldDef_s *) item->typeData;
+			if (editDef) 
+			{
+				value = DC->getCVarValue(item->cvar);
+				value -= (editDef->maxVal-editDef->minVal)/TICK_COUNT;
+				if ( value < editDef->minVal)
+					value = editDef->minVal;
+				DC->setCVar(item->cvar, va("%f", value));
+				return qtrue;
+			}
+		}
+		if (key == A_CURSOR_RIGHT)
+		{
+			editFieldDef_t *editDef = (editFieldDef_s *) item->typeData;
+			if (editDef) 
+			{
+				value = DC->getCVarValue(item->cvar);
+				value += (editDef->maxVal-editDef->minVal)/TICK_COUNT;
+				if ( value > editDef->maxVal)
+					value = editDef->maxVal;
+				DC->setCVar(item->cvar, va("%f", value));
+				return qtrue;
+			}
+		}
+	}
+#endif
+
+	
+	//DC->Print("slider handle key exit\n");
+	return qfalse;
+}
+
+/*
+=================
+Item_HandleKey
+=================
+*/
+qboolean Item_HandleKey(itemDef_t *item, int key, qboolean down) 
+{
+
+	if (itemCapture) 
+	{
+		Item_StopCapture(itemCapture);
+		itemCapture = NULL;
+		captureFunc = NULL;
+		captureData = NULL;
+	} 
+	else 
+	{
+		if (down && key == A_MOUSE1 || key == A_MOUSE2 || key == A_MOUSE3) 
+		{
+			Item_StartCapture(item, key);
+		}
+	}
+
+	if (!down) 
+	{
+		return qfalse;
+	}
+
+	switch (item->type) 
+	{
+		case ITEM_TYPE_BUTTON:
+#ifdef _XBOX
+			return Item_Button_HandleKey(item, key);
+#else
+			return qfalse;
+#endif
+			break;
+		case ITEM_TYPE_RADIOBUTTON:
+			return qfalse;
+			break;
+		case ITEM_TYPE_CHECKBOX:
+			return qfalse;
+			break;
+		case ITEM_TYPE_EDITFIELD:
+		case ITEM_TYPE_NUMERICFIELD:
+			//return Item_TextField_HandleKey(item, key);
+			return qfalse;
+			break;
+		case ITEM_TYPE_COMBO:
+			return qfalse;
+			break;
+		case ITEM_TYPE_LISTBOX:
+			return Item_ListBox_HandleKey(item, key, down, qfalse);
+			break;
+		case ITEM_TYPE_TEXTSCROLL:
+			return Item_TextScroll_HandleKey(item, key, down, qfalse);
+			break;
+		case ITEM_TYPE_YESNO:
+			return Item_YesNo_HandleKey(item, key);
+			break;
+		case ITEM_TYPE_MULTI:
+			return Item_Multi_HandleKey(item, key);
+			break;
+		case ITEM_TYPE_OWNERDRAW:
+			return Item_OwnerDraw_HandleKey(item, key);
+			break;
+		case ITEM_TYPE_BIND:
+			return Item_Bind_HandleKey(item, key, down);
+			break;
+		case ITEM_TYPE_SLIDER:
+			return Item_Slider_HandleKey(item, key, down);
+			break;
+//JLF MPMOVED
+		case ITEM_TYPE_TEXT:
+			return Item_Text_HandleKey(item, key);
+			break;
+		default:
+			return qfalse;
+		break;
+	}
+
+  //return qfalse;
+}
+
+
+
+//JLFACCEPT MPMOVED
+/*
+-----------------------------------------
+Item_HandleAccept
+	If Item has an accept script, run it.
+-------------------------------------------
+*/
+qboolean Item_HandleAccept(itemDef_t * item)
+{
+	if (item->accept)
+	{
+		Item_RunScript(item, item->accept);
+		return true;
+	}
+	return false;
+}
+
+
+//JLFDPADSCRIPT MPMOVED
+/*
+-----------------------------------------
+Item_HandleSelectionNext
+	If Item has an selectionNext script, run it.
+-------------------------------------------
+*/
+qboolean Item_HandleSelectionNext(itemDef_t * item)
+{
+	if (item->selectionNext)
+	{
+		Item_RunScript(item, item->selectionNext);
+		return true;
+	}
+	return false;
+}
+
+//JLFDPADSCRIPT MPMOVED
+/*
+-----------------------------------------
+Item_HandleSelectionPrev
+	If Item has an selectionPrev script, run it.
+-------------------------------------------
+*/
+qboolean Item_HandleSelectionPrev(itemDef_t * item)
+{
+	if (item->selectionPrev)
+	{
+		Item_RunScript(item, item->selectionPrev);
+		return true;
+	}
+	return false;
+}
+
+
+/*
+=================
+Item_Action
+=================
+*/
+void Item_Action(itemDef_t *item) 
+{
+	if (item) 
+	{
+		Item_RunScript(item, item->action);
+	}
+}
+
+/*
+=================
+Menu_HandleKey
+=================
+*/
+void Menu_HandleKey(menuDef_t *menu, int key, qboolean down) 
+{
+	int i;
+	itemDef_t *item = NULL;
+	qboolean inHandler = qfalse;
+
+	if (inHandler) 
+	{
+		return;
+	}
+
+	inHandler = qtrue;
+	if (g_waitingForKey && down) 
+	{
+		Item_Bind_HandleKey(g_bindItem, key, down);
+		inHandler = qfalse;
+		return;
+	}
+
+	if (g_editingField && down) 
+	{
+		if (!Item_TextField_HandleKey(g_editItem, key)) 
+		{
+			g_editingField = qfalse;
+			g_editItem = NULL;
+			inHandler = qfalse;
+			return;
+		} 
+		else if (key == A_MOUSE1 || key == A_MOUSE2 || key == A_MOUSE3) 
+		{
+			g_editingField = qfalse;
+			g_editItem = NULL;
+			Display_MouseMove(NULL, DC->cursorx, DC->cursory);
+		} 
+		else if (key == A_TAB || key == A_CURSOR_UP || key == A_CURSOR_DOWN) 
+		{
+			return;
+		}
+	}
+
+	if (menu == NULL) 
+	{
+		inHandler = qfalse;
+		return;
+	}
+
+	//JLFMOUSE  MPMOVED
+		// see if the mouse is within the window bounds and if so is this a mouse click
+#ifndef _XBOX
+	if (down && !(menu->window.flags & WINDOW_POPUP) && !Rect_ContainsPoint(&menu->window.rect, DC->cursorx, DC->cursory)) 
+#else
+	if (down) 
+#endif
+	{
+		static qboolean inHandleKey = qfalse;
+		if (!inHandleKey && key == A_MOUSE1 || key == A_MOUSE2 || key == A_MOUSE3) 
+		{
+			inHandleKey = qtrue;
+			Menus_HandleOOBClick(menu, key, down);
+			inHandleKey = qfalse;
+			inHandler = qfalse;
+			return;
+		}
+	}
+
+#ifdef _XBOX
+		Menu_MapHack(key);
+#endif
+
+	// get the item with focus
+	for (i = 0; i < menu->itemCount; i++) 
+	{
+		if (menu->items[i]->window.flags & WINDOW_HASFOCUS) 
+		{
+			item = menu->items[i];
+			break;
+		}
+	}
+
+	if (item != NULL) 
+	{
+		if (Item_HandleKey(item, key, down)) 
+//JLFLISTBOX
+		{
+#ifdef _XBOX
+			if (key == A_MOUSE1 || key == A_MOUSE2 ||(item->type == ITEM_TYPE_MULTI && (key == A_CURSOR_RIGHT || key == A_CURSOR_LEFT)))
+#endif
+
+				Item_Action(item);
+			inHandler = qfalse;
+			return;
+		}
+
+	}
+
+	if (!down) 
+	{
+		inHandler = qfalse;
+		return;
+	}
+
+	// Special Data Pad key handling (gotta love the datapad)
+	if (!(key & K_CHAR_FLAG) ) 
+	{	//only check keys not chars
+		char	b[256];
+		DC->getBindingBuf( key, b, 256 );
+		if (Q_stricmp(b,"datapad") == 0)	// They hit the datapad key again.
+		{
+			if (( Q_stricmp(menu->window.name,"datapadMissionMenu") == 0) ||
+			 (Q_stricmp(menu->window.name,"datapadWeaponsMenu") == 0) ||
+			 (Q_stricmp(menu->window.name,"datapadForcePowersMenu") == 0) ||
+			 (Q_stricmp(menu->window.name,"datapadInventoryMenu") == 0))
+			{
+				key = A_ESCAPE;	//pop on outta here
+			}
+		}
+	}
+	// default handling
+	switch ( key ) 
+	{
+		case A_F11:
+			if (DC->getCVarValue("developer")) 
+			{
+				uis.debugMode ^= 1;
+			}
+			break;
+
+		case A_F12:
+			if (DC->getCVarValue("developer")) 
+			{
+				DC->executeText(EXEC_APPEND, "screenshot\n");
+			}
+			break;
+		case A_KP_8:
+		case A_CURSOR_UP:
+			Menu_SetPrevCursorItem(menu);
+			break;
+
+	
+		case A_ESCAPE:
+			if (!g_waitingForKey && menu->onESC) 
+			{
+				itemDef_t it;
+				it.parent = menu;
+				Item_RunScript(&it, menu->onESC);
+			}
+			break;
+		case A_TAB:
+		case A_KP_2:
+		case A_CURSOR_DOWN:
+			Menu_SetNextCursorItem(menu);
+			break;
+
+		case A_MOUSE1:
+		case A_MOUSE2:
+			if (item) 
+			{
+				if (item->type == ITEM_TYPE_TEXT) 
+				{
+//JLFMOUSE
+#ifndef _XBOX
+					if (Rect_ContainsPoint(&item->window.rect, DC->cursorx, DC->cursory)) 
+#endif
+					{
+						if ( item->action )
+							Item_Action(item);
+						else
+						{
+							if (menu->onAccept) 
+							{
+								itemDef_t it;
+								it.parent = menu;
+								Item_RunScript(&it, menu->onAccept);
+							}
+						}
+
+					}
+				} 
+				else if (item->type == ITEM_TYPE_EDITFIELD || item->type == ITEM_TYPE_NUMERICFIELD) 
+				{
+//JLFMOUSE
+#ifndef _XBOX
+					if (Rect_ContainsPoint(&item->window.rect, DC->cursorx, DC->cursory)) 
+#endif
+					{
+						item->cursorPos = 0;
+						g_editingField = qtrue;
+						g_editItem = item;
+						DC->setOverstrikeMode(qtrue);
+					}
+				} 
+//JLFACCEPT
+// add new types here as needed
+/* Notes:
+	Most controls will use the dpad to move through the selection possibilies.  Buttons are the only exception.
+	Buttons will be assumed to all be on one menu together.  If the start or A button is pressed on a control focus, that
+	means that the menu is accepted and move onto the next menu.  If the start or A button is pressed on a button focus it
+	should just process the action and not support the accept functionality.
+*/
+//JLFACCEPT
+				else if ( item->type == ITEM_TYPE_MULTI || item->type == ITEM_TYPE_YESNO || item->type == ITEM_TYPE_SLIDER)
+				{
+
+					if (Item_HandleAccept(item))
+					{
+						//Item processed it overriding the menu processing
+						return;
+					}
+					else if (menu->onAccept) 
+					{
+						itemDef_t it;
+						it.parent = menu;
+						Item_RunScript(&it, menu->onAccept);
+					}
+
+					
+				}
+
+//END JLFACCEPT
+				else 
+				{
+//JLFMOUSE
+#ifndef _XBOX
+					if (Rect_ContainsPoint(&item->window.rect, DC->cursorx, DC->cursory)) 
+#endif
+					{
+						Item_Action(item);
+					}
+				}
+			}
+			else if (menu->onAccept) 
+			{
+				itemDef_t it;
+				it.parent = menu;
+				Item_RunScript(&it, menu->onAccept);
+			}
+			break;
+
+		case A_JOY0:
+		case A_JOY1:
+		case A_JOY2:
+		case A_JOY3:
+		case A_JOY4:
+		case A_AUX0:
+		case A_AUX1:
+		case A_AUX2:
+		case A_AUX3:
+		case A_AUX4:
+		case A_AUX5:
+		case A_AUX6:
+		case A_AUX7:
+		case A_AUX8:
+		case A_AUX9:
+		case A_AUX10:
+		case A_AUX11:
+		case A_AUX12:
+		case A_AUX13:
+		case A_AUX14:
+		case A_AUX15:
+		case A_AUX16:
+			break;
+		case A_KP_ENTER:
+		case A_ENTER:
+			if (item) 
+			{
+				if (item->type == ITEM_TYPE_EDITFIELD || item->type == ITEM_TYPE_NUMERICFIELD) 
+				{
+					item->cursorPos = 0;
+					g_editingField = qtrue;
+					g_editItem = item;
+					DC->setOverstrikeMode(qtrue);
+				} 
+				else 
+				{
+						Item_Action(item);
+				}
+			}
+			break;
+	}
+	inHandler = qfalse;
+}
+
+/*
+=================
+ParseRect
+=================
+*/
+qboolean ParseRect(const char **p, rectDef_t *r) 
+{
+	if (!COM_ParseFloat(p, &r->x)) 
+	{
+		if (!COM_ParseFloat(p, &r->y)) 
+		{
+			if (!COM_ParseFloat(p, &r->w)) 
+			{
+				if (!COM_ParseFloat(p, &r->h)) 
+				{
+					return qtrue;
+				}
+			}
+		}
+	}
+	return qfalse;
+}
+
+
+/*
+=================
+Menus_HideItems
+=================
+*/
+void Menus_HideItems(const char *menuName)
+{
+	menuDef_t	*menu;
+	int			i;
+
+	menu =Menus_FindByName(menuName);	// Get menu
+
+	if (!menu)
+	{
+		Com_Printf(S_COLOR_YELLOW"WARNING: No menu was found. Could not hide items.\n");
+		return;
+	}
+
+	menu->window.flags &= ~(WINDOW_HASFOCUS | WINDOW_VISIBLE);
+
+	for (i = 0; i < menu->itemCount; i++) 
+	{
+		menu->items[i]->cvarFlags = CVAR_HIDE;
+	}
+}
+
+/*
+=================
+Menus_ShowItems
+=================
+*/
+void Menus_ShowItems(const char *menuName)
+{
+	menuDef_t	*menu;
+	int			i;
+
+	menu =Menus_FindByName(menuName);	// Get menu
+
+	if (!menu)
+	{
+		Com_Printf(S_COLOR_YELLOW"WARNING: No menu was found. Could not show items.\n");
+		return;
+	}
+
+	menu->window.flags |= (WINDOW_HASFOCUS | WINDOW_VISIBLE);
+
+	for (i = 0; i < menu->itemCount; i++) 
+	{
+		menu->items[i]->cvarFlags = CVAR_SHOW;
+	}
+}
+
+/*
+=================
+UI_Cursor_Show
+=================
+*/
+void UI_Cursor_Show(qboolean flag)
+{
+	DC->cursorShow = flag;
+
+	if ((DC->cursorShow != qtrue) && (DC->cursorShow != qfalse))
+	{
+		DC->cursorShow = qtrue;
+	}
+}
+
+#ifdef _XBOX
+/*
+=================
+Menu_MapHack
+=================
+*/
+void Menu_MapHack(int key)
+{
+	if (key == A_F1 || key == A_F2)
+	{
+		const char *maps[] =
+		{
+			"academy1",
+			"academy2",
+			"academy3",
+			"academy4",
+			"academy5",
+			"academy6",
+			"hoth2",
+			"hoth3",
+			"kor1",
+			"kor2",
+			"t1_danger",
+			"t1_fatal",
+			"t1_inter",
+			"t1_rail",
+			"t1_sour",
+			"t1_surprise",
+			"t2_dpred",
+			"t2_rancor",
+			"t2_rogue",
+			"t2_trip",
+			"t2_wedge",
+			"t3_bounty",
+			"t3_byss",
+			"t3_hevil",
+			"t3_rift",
+			"t3_stamp",
+			"taspir1",
+			"taspir2",
+			"vjun1",
+			"vjun2",
+			"vjun3",
+			"yavin1",
+			"yavin2",
+		};
+		
+		const int num_maps = sizeof(maps) / sizeof(char*);
+
+		int current = 0;
+		while (current < num_maps)
+		{
+			if (!strcmp(cl_mapname->string, maps[current])) break;
+			++current;
+		}
+		
+		if (key == A_F1) --current;
+		if (key == A_F2) ++current;
+
+		if (current < 0) current = num_maps - 1;
+		if (current >= num_maps) current = 0;
+
+		DC->setCVar( "cl_mapname", maps[current] );
+	}
+	else if (key == A_F3)
+	{
+		char localMapname[32];
+		DC->getCVarString("cl_mapname", localMapname, sizeof(localMapname));
+		DC->executeText( EXEC_APPEND, va("devmapall %s\n", localMapname ) );
+	}
+}
+
+
+//JLF DEMOCODE
+// IS ALREADY IN #ifdef _XBOX
+
+
+void G_DemoStart()
+{
+//	demoDelay = 0;
+//	lastChange = 0;
+	g_runningDemo = true;
+
+//	g_demoLastChange = 0;
+
+
+	extern void Menus_CloseAll();
+	
+	Menus_CloseAll();
+
+	trap_Key_SetCatcher( trap_Key_GetCatcher() & ~KEYCATCH_UI );
+	trap_Key_ClearStates();
+	Cvar_Set( "cl_paused", "0" );
+
+//	g_demoStartFade = 0;
+//	g_demoStartTransition = 0;
+}
+
+const char *attractMovieNames[] = {
+	"jk1",
+	"jk2",
+	"jk3",
+	"jk4",
+	"jk5",
+};
+
+const int	numAttractMovies = sizeof(attractMovieNames) / sizeof(attractMovieNames[0]);
+static int	curAttractMovie = 0;
+
+void G_DemoFrame()
+{
+	bool keypressed = false;
+	if (g_runningDemo)
+	{
+		while (!keypressed)
+			keypressed = CIN_PlayAllFrames( "atvi.bik", 0, 0, 640, 480, 0, true );
+		G_DemoEnd();
+//		if (!g_demoStartTransition && level->time > g_demoLastChange - 750)
+//		{
+//			g_demoTransitionType = rand() % 8;
+//			g_demoStartTransition = level->time + 750;
+//			if (level->time < 5000)
+//			{
+//				g_demoStartTransition = -g_demoStartTransition;
+//				g_demoTransitionType = 0;
+//			}
+//		}
+
+//		if (g_demoLastChange < level->time)
+//		{
+//			int nEnt = (rand() % 7) + 1;
+//			if (nEnt == g_entities[0].client->ps.viewEntity)
+//				g_entities[0].client->ps.viewEntity = ((nEnt + 1) % 7) + 1;
+//			else
+//				g_entities[0].client->ps.viewEntity = nEnt;
+//			g_demoLastChange = level->time + Q_irand(g_demoTimeBeforeChangePlayer - 3000, g_demoTimeBeforeChangePlayer + 3000);
+//		}	
+
+//		if (!g_demoStartFade && level->time > g_demoTimeBeforeStop-3000)
+//		{
+//			g_demoStartFade = level->time + 2000;
+//		}
+
+//		if (level->time > g_demoTimeBeforeStop)
+//		{
+//			G_DemoEnd();
+//			return;
+//		}
+
+
+	}
+	else 
+	{
+		menuDef_t* curMenu = Menu_GetFocused();
+		
+		if (curMenu && curMenu->window.name &&
+			(!Q_stricmp(curMenu->window.name , "mainMenu") ||
+			!Q_stricmp(curMenu->window.name, "splashMenu")))
+		{
+			if (!g_demoLastKeypress)
+				g_demoLastKeypress = Sys_Milliseconds();
+			else if (g_demoLastKeypress + DEMO_TIME_MAX < Sys_Milliseconds())
+				G_DemoStart();
+		}
+		else
+		{
+			g_demoLastKeypress = Sys_Milliseconds();
+		}
+	}
+}
+
+void G_DemoKeypress()
+{
+	g_demoLastKeypress = Sys_Milliseconds();
+		
+//JLF moved
+//	g_demoLastKeypress = Sys_Milliseconds();
+	
+}
+
+
+void G_DemoEnd()
+{
+	
+	if (!g_runningDemo)
+		return;
+	//CIN_StopCinematic(1);
+	CIN_CloseAllVideos();
+//	Key_SetCatcher( KEYCATCH_UI );
+	Menus_CloseAll();
+	g_ReturnToSplash = true;
+	g_runningDemo = qfalse;
+	G_DemoKeypress();
+	trap_Key_SetCatcher( trap_Key_GetCatcher() & KEYCATCH_UI );
+	trap_Key_ClearStates();
+	Cvar_Set( "cl_paused", "0" );
+
+//	g_demoStartFade = 0;
+//	g_demoStartTransition = 0;
+//	g_demoLastKeypress = 0;
+}
+
+void PlayDemo()
+{
+//	bool keypressed = false;
+	G_DemoStart();
+	CIN_PlayAllFrames( attractMovieNames[curAttractMovie], 0, 0, 640, 480, 0, true );
+	curAttractMovie = (curAttractMovie + 1) % numAttractMovies;
+//	while (!keypressed)
+//		keypressed = CIN_PlayAllFrames( "atvi.bik", 0, 0, 640, 480, 0, true );
+	G_DemoEnd();
+}
+
+void UpdateDemoTimer()
+{
+	g_demoLastKeypress = Sys_Milliseconds();
+}
+
+bool TestDemoTimer()
+{
+//JLF TEMP DEBUG
+	return false;
+
+
+	menuDef_t* curMenu = Menu_GetFocused();
+	if (curMenu && curMenu->window.name &&
+			(!Q_stricmp(curMenu->window.name , "mainMenu") ||
+			!Q_stricmp(curMenu->window.name, "splashMenu")))
+	{	
+		if (!g_demoLastKeypress)
+			g_demoLastKeypress = Sys_Milliseconds();
+		else if (g_demoLastKeypress + DEMO_TIME_MAX < Sys_Milliseconds())
+			return true;
+	}
+	return false;
+}
+
+//END DEMOCODE
+
+
+#endif // _XBOX
diff --git a/code/ui/ui_shared.h b/code/ui/ui_shared.h
new file mode 100644
index 0000000..3fe7ba1
--- /dev/null
+++ b/code/ui/ui_shared.h
@@ -0,0 +1,528 @@
+#ifndef __UI_SHARED_H
+#define __UI_SHARED_H
+
+#define MAX_TOKENLENGTH		1024
+#define MAX_OPEN_MENUS 16
+#define	MAX_TEXTSCROLL_LINES		256
+
+#define MAX_EDITFIELD 256
+
+#ifndef TT_STRING
+//token types
+#define TT_STRING					1			// string
+#define TT_LITERAL					2			// literal
+#define TT_NUMBER					3			// number
+#define TT_NAME						4			// name
+#define TT_PUNCTUATION				5			// punctuation
+#endif
+
+#define SLIDER_WIDTH 128.0
+#define SLIDER_HEIGHT 16.0
+#define SLIDER_THUMB_WIDTH 12.0
+#define SLIDER_THUMB_HEIGHT 16.0
+#define SCROLLBAR_SIZE 16.0
+
+typedef struct pc_token_s
+{
+	int			type;
+	int			subtype;
+	int			intvalue;
+	float		floatvalue;
+	char		string[MAX_TOKENLENGTH];
+} pc_token_t;
+
+
+
+// FIXME: combine flags into bitfields to save space
+// FIXME: consolidate all of the common stuff in one structure for menus and items
+// THINKABOUTME: is there any compelling reason not to have items contain items
+// and do away with a menu per say.. major issue is not being able to dynamically allocate 
+// and destroy stuff.. Another point to consider is adding an alloc free call for vm's and have 
+// the engine just allocate the pool for it based on a cvar
+// many of the vars are re-used for different item types, as such they are not always named appropriately
+// the benefits of c++ in DOOM will greatly help crap like this
+// FIXME: need to put a type ptr that points to specific type info per type
+// 
+#define MAX_LB_COLUMNS 16
+
+typedef struct columnInfo_s {
+	int			pos;
+	int			width;
+	int			maxChars;
+} columnInfo_t;
+
+typedef struct listBoxDef_s {
+	int			startPos;
+	int			endPos;
+	int			drawPadding;
+	int			cursorPos;
+	float		elementWidth;
+	float		elementHeight;
+	int			elementStyle;
+	int			numColumns;
+	columnInfo_t columnInfo[MAX_LB_COLUMNS];
+	const char	*doubleClick;
+	qboolean	notselectable;
+//JLF MPMOVED
+	qboolean	scrollhidden;
+} listBoxDef_t;
+
+
+typedef struct editFieldDef_s {
+	float		minVal;						//	edit field limits
+	float		maxVal;						//
+	float		defVal;						//
+	float		range;						// 
+	int			maxChars;					// for edit fields
+	int			maxPaintChars;				// for edit fields
+	int			paintOffset;				// 
+} editFieldDef_t;
+
+#define MAX_MULTI_CVARS 64//32
+
+typedef struct multiDef_s {
+	const char *cvarList[MAX_MULTI_CVARS];
+	const char *cvarStr[MAX_MULTI_CVARS];
+	float		cvarValue[MAX_MULTI_CVARS];
+	int			count;
+	qboolean	strDef;
+} multiDef_t;
+
+#define CVAR_ENABLE		0x00000001
+#define CVAR_DISABLE	0x00000002
+#define CVAR_SHOW		0x00000004
+#define CVAR_HIDE		0x00000008
+#define CVAR_SUBSTRING	0x00000010	//when using enable or disable, just check for strstr instead of ==
+
+
+#ifdef _XBOX
+// Super small - doesn't need to be bigger yet, helps us get into 64 MB
+//#define STRING_POOL_SIZE 16*1024
+#define STRING_POOL_SIZE 64*1024
+
+#else
+#ifdef CGAME
+#define STRING_POOL_SIZE 128*1024
+#else
+#define STRING_POOL_SIZE 384*1024
+#endif
+#endif
+
+#define	NUM_CROSSHAIRS			9
+
+typedef struct {
+	qhandle_t	qhMediumFont;
+	qhandle_t	cursor;
+	qhandle_t	gradientBar;
+	qhandle_t	scrollBarArrowUp;
+	qhandle_t	scrollBarArrowDown;
+	qhandle_t	scrollBarArrowLeft;
+	qhandle_t	scrollBarArrowRight;
+	qhandle_t	scrollBar;
+	qhandle_t	scrollBarThumb;
+	qhandle_t	buttonMiddle;
+	qhandle_t	buttonInside;
+	qhandle_t	solidBox;
+	qhandle_t	sliderBar;
+	qhandle_t	sliderThumb;
+	sfxHandle_t menuEnterSound;
+	sfxHandle_t menuExitSound;
+	sfxHandle_t menuBuzzSound;
+	sfxHandle_t itemFocusSound;
+	sfxHandle_t forceChosenSound;
+	sfxHandle_t forceUnchosenSound;
+	sfxHandle_t datapadmoveRollSound;
+	sfxHandle_t datapadmoveJumpSound;
+	sfxHandle_t datapadmoveSaberSound1;
+	sfxHandle_t datapadmoveSaberSound2;
+	sfxHandle_t datapadmoveSaberSound3;
+	sfxHandle_t datapadmoveSaberSound4;
+	sfxHandle_t datapadmoveSaberSound5;
+	sfxHandle_t datapadmoveSaberSound6;
+
+	sfxHandle_t nullSound;
+	
+#ifdef _IMMERSION
+	ffHandle_t	menuEnterForce;
+	ffHandle_t	menuExitForce;
+	ffHandle_t	menuBuzzForce;
+	ffHandle_t	itemFocusForce;
+#endif // _IMMERSION
+	float		fadeClamp;
+	int			fadeCycle;
+	float		fadeAmount;
+	float		shadowX;
+	float		shadowY;
+	vec4_t		shadowColor;
+	float		shadowFadeClamp;
+	qboolean	fontRegistered;
+
+  // player settings
+//	qhandle_t	fxBasePic;
+//	qhandle_t	fxPic[7];
+	qhandle_t	crosshairShader[NUM_CROSSHAIRS];
+
+} cachedAssets_t;
+
+struct itemDef_s;
+
+typedef struct {
+
+	void		(*addRefEntityToScene) (const refEntity_t *re );
+	void		(*clearScene) ();
+	void		(*drawHandlePic) (float x, float y, float w, float h, qhandle_t asset);
+	void		(*drawRect) ( float x, float y, float w, float h, float size, const vec4_t color);
+	void		(*drawSides) (float x, float y, float w, float h, float size);
+	void		(*drawText) (float x, float y, float scale, vec4_t color, const char *text, int iMaxPixelWidth, int style, int iFontIndex );
+	void		(*drawTextWithCursor)(float x, float y, float scale, vec4_t color, const char *text, int cursorPos, char cursor, int iMaxPixelWidth, int style, int iFontIndex);
+	void		(*drawTopBottom) (float x, float y, float w, float h, float size);
+	void		(*executeText)(int exec_when, const char *text );	
+	int			(*feederCount)(float feederID);
+	void		(*feederSelection)(float feederID, int index, struct itemDef_s *item);
+	void		(*fillRect) ( float x, float y, float w, float h, const vec4_t color);
+	void		(*getBindingBuf)( int keynum, char *buf, int buflen );
+	void		(*getCVarString)(const char *cvar, char *buffer, int bufsize);
+	float		(*getCVarValue)(const char *cvar);
+	qboolean	(*getOverstrikeMode)();
+	float		(*getValue) (int ownerDraw);
+	void		(*keynumToStringBuf)( int keynum, char *buf, int buflen );
+	void		(*modelBounds) (qhandle_t model, vec3_t min, vec3_t max);
+	qboolean	(*ownerDrawHandleKey)(int ownerDraw, int flags, float *special, int key);
+	void		(*ownerDrawItem) (float x, float y, float w, float h, float text_x, float text_y, int ownerDraw, int ownerDrawFlags, int align, float special, float scale, vec4_t color, qhandle_t shader, int textStyle, int iFontIndex);
+	qboolean	(*ownerDrawVisible) (int flags);
+	int			(*ownerDrawWidth)(int ownerDraw, float scale);
+	void		(*Pause)(qboolean b);
+	void		(*Print)(const char *msg, ...);
+	int			(*registerFont) (const char *pFontname);
+	qhandle_t	(*registerModel) (const char *p);
+	qhandle_t	(*registerShaderNoMip) (const char *p);	
+	sfxHandle_t (*registerSound)(const char *name, qboolean compressed);
+	void		(*renderScene) ( const refdef_t *fd );
+	qboolean	(*runScript)(const char **p);
+	qboolean	(*deferScript)(const char **p);
+	void		(*setBinding)( int keynum, const char *binding );
+	void		(*setColor) (const vec4_t v);
+	void		(*setCVar)(const char *cvar, const char *value);
+	void		(*setOverstrikeMode)(qboolean b);
+	void		(*startLocalSound)( sfxHandle_t sfx, int channelNum );
+	void		(*stopCinematic)(int handle);
+	int			(*textHeight) (const char *text, float scale, int iFontIndex);
+	int			(*textWidth) (const char *text, float scale, int iFontIndex);
+	qhandle_t	(*feederItemImage) (float feederID, int index);
+	const char *(*feederItemText) (float feederID, int index, int column, qhandle_t *handle);
+
+	qhandle_t	(*registerSkin)( const char *name );
+
+	//rww - ghoul2 stuff. Add whatever you need here, remember to set it in _UI_Init or it will crash when you try to use it.
+#ifdef _XBOX	// No default arguments on function pointers
+	qboolean	g2_SetSkin(CGhoul2Info *ghlInfo, qhandle_t customSkin, qhandle_t renderSkin = 0)
+	{
+		return G2API_SetSkin(ghlInfo, customSkin, renderSkin);
+	}
+	qboolean	g2_SetBoneAnim(CGhoul2Info *ghlInfo, const char *boneName, const int startFrame, const int endFrame,
+					  const int flags, const float animSpeed, const int currentTime, const float setFrame = -1, const int blendTime = -1)
+	{
+		return G2API_SetBoneAnim(ghlInfo, boneName, startFrame, endFrame, flags, animSpeed, currentTime, setFrame, blendTime);
+	}
+#else
+	qboolean	(*g2_SetSkin)(CGhoul2Info *ghlInfo, qhandle_t customSkin, qhandle_t renderSkin = 0);
+	qboolean	(*g2_SetBoneAnim)(CGhoul2Info *ghlInfo, const char *boneName, const int startFrame, const int endFrame,
+					  const int flags, const float animSpeed, const int currentTime, const float setFrame = -1, const int blendTime = -1);
+#endif
+	qboolean	(*g2_RemoveGhoul2Model)(CGhoul2Info_v &ghlInfo, const int modelIndex);
+	int			(*g2_InitGhoul2Model)(CGhoul2Info_v &ghoul2, const char *fileName, int, qhandle_t customSkin, qhandle_t customShader, int modelFlags, int lodBias);
+	void		(*g2_CleanGhoul2Models)(CGhoul2Info_v &ghoul2);
+	int			(*g2_AddBolt)(CGhoul2Info *ghlInfo, const char *boneName);
+	qboolean	(*g2_GetBoltMatrix)(CGhoul2Info_v &ghoul2, const int modelIndex, const int boltIndex, mdxaBone_t *matrix,
+									const vec3_t angles, const vec3_t position, const int frameNum, qhandle_t *modelList, const vec3_t scale);
+	void		(*g2_GiveMeVectorFromMatrix)(mdxaBone_t &boltMatrix, Eorientations flags, vec3_t &vec);
+
+	//Utility functions that don't immediately redirect to ghoul2 functions
+	int			(*g2hilev_SetAnim)(CGhoul2Info *ghlInfo, const char *boneName, int animNum, const qboolean freeze);
+
+#ifdef _IMMERSION
+	ffHandle_t	(*registerForce)(const char *name, int channel=FF_CHANNEL_MENU);
+	void		(*startForce)(ffHandle_t ff);
+#endif // _IMMERSION
+
+	float		yscale;
+	float		xscale;
+	float		bias;
+	int			realTime;
+	int			frameTime;
+	qboolean	cursorShow;
+	int			cursorx;
+	int			cursory;
+	qboolean	debug;
+
+	cachedAssets_t Assets;
+
+	glconfig_t	glconfig;
+	qhandle_t	whiteShader;
+	qhandle_t	gradientImage;
+	float FPS;
+
+} displayContextDef_t;
+
+void UI_InitMemory( void );
+
+
+#define MAX_COLOR_RANGES	10
+#define MAX_MENUITEMS		150
+#define MAX_MENUS			64
+
+
+
+#define WINDOW_MOUSEOVER		0x00000001	// mouse is over it, non exclusive
+#define WINDOW_HASFOCUS			0x00000002	// has cursor focus, exclusive
+#define WINDOW_VISIBLE			0x00000004	// is visible
+#define WINDOW_INACTIVE			0x00000008	// is visible but grey ( non-active )
+#define WINDOW_DECORATION		0x00000010	// for decoration only, no mouse, keyboard, etc.. 
+#define WINDOW_FADINGOUT		0x00000020	// fading out, non-active
+#define WINDOW_FADINGIN			0x00000040	// fading in
+#define WINDOW_MOUSEOVERTEXT	0x00000080	// mouse is over it, non exclusive
+#define WINDOW_INTRANSITION		0x00000100	// window is in transition
+#define WINDOW_FORECOLORSET		0x00000200	// forecolor was explicitly set ( used to color alpha images or not )
+#define WINDOW_HORIZONTAL		0x00000400	// for list boxes and sliders, vertical is default this is set of horizontal
+#define WINDOW_LB_LEFTARROW		0x00000800	// mouse is over left/up arrow
+#define WINDOW_LB_RIGHTARROW	0x00001000	// mouse is over right/down arrow
+#define WINDOW_LB_THUMB			0x00002000	// mouse is over thumb
+#define WINDOW_LB_PGUP			0x00004000	// mouse is over page up
+#define WINDOW_LB_PGDN			0x00008000	// mouse is over page down
+#define WINDOW_ORBITING			0x00010000	// item is in orbit
+#define WINDOW_OOB_CLICK		0x00020000	// close on out of bounds click
+#define WINDOW_WRAPPED			0x00040000	// manually wrap text
+#define WINDOW_AUTOWRAPPED		0x00080000	// auto wrap text
+#define WINDOW_FORCED			0x00100000	// forced open
+#define WINDOW_POPUP			0x00200000	// popup
+#define WINDOW_BACKCOLORSET		0x00400000	// backcolor was explicitly set 
+#define WINDOW_TIMEDVISIBLE		0x00800000	// visibility timing ( NOT implemented )
+#define WINDOW_PLAYERCOLOR		0x01000000	// hack the forecolor to match ui_char_color_*
+#define WINDOW_SCRIPTWAITING	0x02000000	// delayed script waiting to run
+//JLF MPMOVED
+#define WINDOW_INTRANSITIONMODEL	0x04000000	// delayed script waiting to run
+#define WINDOW_IGNORE_ESCAPE	0x08000000	// ignore normal closeall menus escape functionality
+
+typedef struct {
+	float		x;							// horiz position
+	float		y;							// vert position
+	float		w;							// width
+	float		h;							// height;
+} rectDef_t;
+
+typedef rectDef_t UIRectangle;
+
+// FIXME: do something to separate text vs window stuff
+typedef struct {
+	UIRectangle	rect;						// client coord rectangle
+	UIRectangle	rectClient;					// screen coord rectangle
+	char		*name;						//
+	char		*group;						// if it belongs to a group
+	const char	*cinematicName;				// cinematic name
+	int			cinematic;					// cinematic handle
+	int			style;                      //
+	int			border;                     //
+	int			ownerDraw;					// ownerDraw style
+	int			ownerDrawFlags;				// show flags for ownerdraw items
+	float		borderSize;					// 
+	int			flags;						// visible, focus, mouseover, cursor
+	UIRectangle	rectEffects;				// for various effects
+	UIRectangle	rectEffects2;				// for various effects
+	int			offsetTime;					// time based value for various effects
+	int			nextTime;                   // time next effect should cycle
+	int			delayTime;					// time when delay expires
+	char		*delayedScript;				// points into another script's text while delaying
+	vec4_t		foreColor;					// text color
+	vec4_t		backColor;					// border color
+	vec4_t		borderColor;				// border color
+	vec4_t		outlineColor;				// border color
+	qhandle_t	background;					// background asset  
+} windowDef_t;
+
+typedef windowDef_t Window;
+
+typedef struct {
+	vec4_t		color;						//
+	float		low;						//
+	float		high;						//
+} colorRangeDef_t;
+
+typedef struct modelDef_s {
+	int		angle;
+	vec3_t	origin;
+	float	fov_x;
+	float	fov_y;
+	int		rotationSpeed;
+
+	vec3_t g2mins; //required
+	vec3_t g2maxs; //required
+	int g2skin; //optional
+	int g2anim; //optional
+//JLF MPMOVED
+//Transition extras
+	vec3_t g2mins2, g2maxs2, g2minsEffect, g2maxsEffect;
+	float fov_x2, fov_y2, fov_Effectx, fov_Effecty;
+} modelDef_t;
+
+#define ITF_G2VALID			0x0001					// indicates whether or not g2 instance is valid.
+#define ITF_ISCHARACTER		0x0002					// a character item, uses customRGBA
+#define ITF_ISSABER			0x0004					// first saber item, draws blade
+#define ITF_ISSABER2		0x0008					// second saber item, draws blade
+
+#define ITF_ISANYSABER		(ITF_ISSABER|ITF_ISSABER2)	//either saber
+
+typedef struct itemDef_s {
+	Window		window;						// common positional, border, style, layout info
+	UIRectangle	textRect;					// rectangle the text ( if any ) consumes     
+	int			type;						// text, button, radiobutton, checkbox, textfield, listbox, combo
+	int			alignment;					// left center right
+	int			textalignment;				// ( optional ) alignment for text within rect based on text width
+	float		textalignx;					// ( optional ) text alignment x coord
+	float		textaligny;					// ( optional ) text alignment y coord
+	float		text2alignx;				// ( optional ) text2 alignment x coord
+	float		text2aligny;				// ( optional ) text2 alignment y coord
+	float		textscale;					// scale percentage from 72pts
+	int			textStyle;					// ( optional ) style, normal and shadowed are it for now
+	char		*text;						// display text
+	char		*text2;						// display text2
+	char		*descText;					//	Description text
+	void		*parent;					// menu owner
+	qhandle_t	asset;						// handle to asset
+	CGhoul2Info_v ghoul2;					// ghoul2 instance if available instead of a model.
+	int			flags;						// flags like g2valid, character, saber, saber2, etc.
+	const char	*mouseEnterText;			// mouse enter script
+	const char	*mouseExitText;				// mouse exit script
+	const char	*mouseEnter;				// mouse enter script
+	const char	*mouseExit;					// mouse exit script 
+	const char	*action;					// select script
+//JLFACCEPT MPMOVED
+	const char  *accept;
+//JLFDPADSCRIPT MPMOVED
+	const char * selectionNext;
+	const char * selectionPrev;
+
+	const char	*onFocus;					// select script
+	const char	*leaveFocus;				// select script
+	const char	*cvar;						// associated cvar 
+	const char	*cvarTest;					// associated cvar for enable actions
+	const char	*enableCvar;				// enable, disable, show, or hide based on value, this can contain a list
+	int			cvarFlags;					//	what type of action to take on cvarenables
+	sfxHandle_t focusSound;					//
+#ifdef _IMMERSION
+	ffHandle_t	focusForce;
+#endif // _IMMERSION
+	int			numColors;					// number of color ranges
+	colorRangeDef_t colorRanges[MAX_COLOR_RANGES];
+	float		special;					// used for feeder id's etc.. diff per type
+	int			cursorPos;					// cursor position in characters
+	void		*typeData;					// type specific data ptr's	
+	int			appearanceSlot;				// order of appearance
+	int			value;						// used by ITEM_TYPE_MULTI that aren't linked to a particular cvar.
+	int			font;						// FONT_SMALL,FONT_MEDIUM,FONT_LARGE
+	int			invertYesNo;
+	int			xoffset;
+
+} itemDef_t;
+
+typedef struct {
+	Window window;
+	const char  *font;						// font
+	qboolean	fullScreen;					// covers entire screen 
+	int			itemCount;					// number of items;
+	int			fontIndex;					// 
+	int			cursorItem;					// which item as the cursor
+	int			fadeCycle;					//
+	float		fadeClamp;					//
+	float		fadeAmount;					//
+	const char	*onOpen;					// run when the menu is first opened
+	const char	*onClose;					// run when the menu is closed
+//JLFACCEPT MPMOVED
+	const char  *onAccept;					// run when menu is closed with acceptance
+
+	const char	*onESC;						// run when the menu is closed
+	const char	*soundName;					// background loop sound for menu
+
+	vec4_t		focusColor;					// focus color for items
+	vec4_t		disableColor;				// focus color for items
+	itemDef_t	*items[MAX_MENUITEMS];		// items this menu contains   
+	float		appearanceTime;				//	when next item should appear
+	int			appearanceCnt;				//	current item displayed
+	float		appearanceIncrement;		//
+	int			descX;						// X position of description
+	int			descY;						// X position of description
+	vec4_t		descColor;					// description text color for items
+	int			descAlignment;				// Description of alignment
+	float		descScale;					// Description scale
+	int			descTextStyle;					// ( optional ) style, normal and shadowed are it for now
+
+	
+} menuDef_t;
+
+typedef struct textScrollDef_s 
+{
+	int				startPos;
+	int				endPos;
+
+	float			lineHeight;
+	int				maxLineChars;
+	int				drawPadding;
+
+	// changed spelling to make them fall out during compile while I made them asian-aware	-Ste
+	//
+	int				iLineCount;
+	const char*		pLines[MAX_TEXTSCROLL_LINES];	// can contain NULL ptrs that you should skip over during paint.
+
+} textScrollDef_t;
+
+typedef struct 
+{
+	const char *name;
+	qboolean (*handler) (itemDef_t *item, const char** args);
+
+} commandDef_t;
+
+menuDef_t	*Menu_GetFocused(void);
+
+void		Controls_GetConfig( void );
+void		Controls_SetConfig(qboolean restart);
+qboolean	Display_KeyBindPending(void);
+qboolean	Display_MouseMove(void *p, int x, int y);
+int			Display_VisibleMenuCount(void);
+qboolean	Int_Parse(const char **p, int *i);
+void		Init_Display(displayContextDef_t *dc);
+void		Menus_Activate(menuDef_t *menu);
+menuDef_t	*Menus_ActivateByName(const char *p);
+qboolean	Menus_AnyFullScreenVisible(void);
+void		Menus_CloseAll(void);
+int			Menu_Count(void);
+itemDef_t	*Menu_FindItemByName(menuDef_t *menu, const char *p);
+void		Menu_HandleKey(menuDef_t *menu, int key, qboolean down);
+void		Menu_New(char *buffer);
+void		Menus_OpenByName(const char *p);
+void		Menu_PaintAll(void);
+void		Menu_Reset(void); 
+void		PC_EndParseSession(char *buffer);
+qboolean	PC_Float_Parse(int handle, float *f);
+qboolean	PC_ParseString(const char **tempStr);
+qboolean	PC_ParseStringMem(const char **out);
+void		PC_ParseWarning(const char *message);
+qboolean	PC_String_Parse(int handle, const char **out);
+#ifdef _XBOX	
+int			PC_StartParseSession(const char *fileName,char **buffer, bool nested = false);
+#else
+int			PC_StartParseSession(const char *fileName,char **buffer);
+#endif
+char		*PC_ParseExt(void);
+qboolean	PC_ParseInt(int *number);
+qboolean	PC_ParseFloat(float *number);
+qboolean	PC_ParseColor(vec4_t *c);
+const char	*String_Alloc(const char *p);
+void		String_Init(void);
+qboolean	String_Parse(const char **p, const char **out);
+void		String_Report(void);
+void		UI_Cursor_Show(qboolean flag);
+itemDef_t *Menu_GetMatchingItemByNumber(menuDef_t *menu, int index, const char *name);
+
+extern displayContextDef_t *DC;
+
+#endif
diff --git a/code/ui/ui_splash.cpp b/code/ui/ui_splash.cpp
new file mode 100644
index 0000000..0731041
--- /dev/null
+++ b/code/ui/ui_splash.cpp
@@ -0,0 +1,290 @@
+
+#include "../client/client.h"
+#include "../renderer/tr_local.h"
+#include "../win32/glw_win_dx8.h"
+#include "../win32/win_local.h"
+#include "../win32/win_file.h"
+#include "../ui/ui_splash.h"
+
+#define SP_TextureExt "dds"
+
+extern bool Sys_QuickStart( void );
+
+/*********
+Globals
+*********/
+static bool SP_LicenseDone = false;
+
+/*********
+SP_DisplayIntros
+Draws intro movies to the screen
+*********/
+void SP_DisplayLogos(void)
+{
+	if( !Sys_QuickStart() )
+		CIN_PlayAllFrames( "logos", 0, 0, 640, 480, 0, true );
+}
+
+/*********
+SP_DrawTexture
+*********/
+void SP_DrawTexture(void* pixels, float width, float height, float vShift)
+{
+	if (!pixels)
+	{
+		// Ug.  We were not even able to load the error message texture.
+		return;
+	}
+	
+	// Create a texture from the buffered file
+	GLuint texid;
+	qglGenTextures(1, &texid);
+	qglBindTexture(GL_TEXTURE_2D, texid);
+	qglTexImage2D(GL_TEXTURE_2D, 0, GL_DDS1_EXT, width, height, 0, GL_DDS1_EXT, GL_UNSIGNED_BYTE, pixels);
+
+	qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
+	qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
+	qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP );
+	qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP );
+
+	// Reset every GL state we've got.  Who knows what state
+	// the renderer could be in when this function gets called.
+	qglColor3f(1.f, 1.f, 1.f);
+	qglViewport(0, 0, 640, 480);
+
+	GLboolean alpha = qglIsEnabled(GL_ALPHA_TEST);
+	qglDisable(GL_ALPHA_TEST);
+
+	GLboolean blend = qglIsEnabled(GL_BLEND);
+	qglDisable(GL_BLEND);
+
+	GLboolean cull = qglIsEnabled(GL_CULL_FACE);
+	qglDisable(GL_CULL_FACE);
+
+	GLboolean depth = qglIsEnabled(GL_DEPTH_TEST);
+	qglDisable(GL_DEPTH_TEST);
+
+	GLboolean fog = qglIsEnabled(GL_FOG);
+	qglDisable(GL_FOG);
+
+	GLboolean lighting = qglIsEnabled(GL_LIGHTING);
+	qglDisable(GL_LIGHTING);
+
+	GLboolean offset = qglIsEnabled(GL_POLYGON_OFFSET_FILL);
+	qglDisable(GL_POLYGON_OFFSET_FILL);
+
+	GLboolean scissor = qglIsEnabled(GL_SCISSOR_TEST);
+	qglDisable(GL_SCISSOR_TEST);
+
+	GLboolean stencil = qglIsEnabled(GL_STENCIL_TEST);
+	qglDisable(GL_STENCIL_TEST);
+
+	GLboolean texture = qglIsEnabled(GL_TEXTURE_2D);
+	qglEnable(GL_TEXTURE_2D);
+
+	qglMatrixMode(GL_MODELVIEW);
+	qglLoadIdentity();
+	qglMatrixMode(GL_PROJECTION);
+	qglLoadIdentity();
+	qglOrtho(0, 640, 0, 480, 0, 1);
+	
+	qglMatrixMode(GL_TEXTURE0);
+	qglLoadIdentity();
+	qglMatrixMode(GL_TEXTURE1);
+	qglLoadIdentity();
+
+	qglActiveTextureARB(GL_TEXTURE0_ARB);
+	qglClientActiveTextureARB(GL_TEXTURE0_ARB);
+
+	memset(&tess, 0, sizeof(tess));
+
+	// Draw the error message
+	qglBeginFrame();
+
+	if (!SP_LicenseDone)
+	{
+		// clear the screen if we haven't done the
+		// license yet...
+		qglClearColor(0, 0, 0, 1);
+		qglClear(GL_COLOR_BUFFER_BIT);
+	}
+
+	float x1 = 320 - width / 2;
+	float x2 = 320 + width / 2;
+	float y1 = 240 - height / 2;
+	float y2 = 240 + height / 2;
+
+	y1 += vShift;
+	y2 += vShift;
+
+	qglBeginEXT (GL_TRIANGLE_STRIP, 4, 0, 0, 4, 0);
+		qglTexCoord2f( 0,  0 );
+		qglVertex2f(x1, y1);
+		qglTexCoord2f( 1 ,  0 );
+		qglVertex2f(x2, y1);
+		qglTexCoord2f( 0, 1 );
+		qglVertex2f(x1, y2);
+		qglTexCoord2f( 1, 1 );
+		qglVertex2f(x2, y2);
+	qglEnd();
+	
+	qglEndFrame();
+	qglFlush();
+
+	// Restore (most) of the render states we reset
+	if (alpha) qglEnable(GL_ALPHA_TEST);
+	else qglDisable(GL_ALPHA_TEST);
+
+	if (blend) qglEnable(GL_BLEND);
+	else qglDisable(GL_BLEND);
+
+	if (cull) qglEnable(GL_CULL_FACE);
+	else qglDisable(GL_CULL_FACE);
+
+	if (depth) qglEnable(GL_DEPTH_TEST);
+	else qglDisable(GL_DEPTH_TEST);
+
+	if (fog) qglEnable(GL_FOG);
+	else qglDisable(GL_FOG);
+
+	if (lighting) qglEnable(GL_LIGHTING);
+	else qglDisable(GL_LIGHTING);
+
+	if (offset) qglEnable(GL_POLYGON_OFFSET_FILL);
+	else qglDisable(GL_POLYGON_OFFSET_FILL);
+
+	if (scissor) qglEnable(GL_SCISSOR_TEST);
+	else qglDisable(GL_SCISSOR_TEST);
+
+	if (stencil) qglEnable(GL_STENCIL_TEST);
+	else qglDisable(GL_STENCIL_TEST);
+
+	if (texture) qglEnable(GL_TEXTURE_2D);
+	else qglDisable(GL_TEXTURE_2D);
+
+	// Kill the texture
+	qglDeleteTextures(1, &texid);
+}
+
+
+/*********
+SP_GetLanguageExt
+
+Retuns the extension for the current language, or
+english if the language is unknown.
+*********/
+char* SP_GetLanguageExt()
+{
+	switch(XGetLanguage())
+	{
+	case XC_LANGUAGE_ENGLISH:
+		return "EN";
+	case XC_LANGUAGE_JAPANESE:
+		return "JA";
+	case XC_LANGUAGE_GERMAN:
+		return "GE";
+	case XC_LANGUAGE_SPANISH:
+		return "SP";
+	case XC_LANGUAGE_ITALIAN:
+		return "IT";
+	case XC_LANGUAGE_KOREAN:
+		return "KO";
+	case XC_LANGUAGE_TCHINESE:
+		return "CH";
+	case XC_LANGUAGE_PORTUGUESE:
+		return "PO";
+	default:
+		return "EN";
+	}
+}
+
+/*********
+SP_LoadFileWithLanguage
+
+Loads a screen with the appropriate language
+*********/
+void *SP_LoadFileWithLanguage(const char *name)
+{
+	char fullname[MAX_QPATH];
+	void *buffer = NULL;
+	char *ext;
+
+	// get the language extension
+	ext = SP_GetLanguageExt();
+
+	// creat the fullpath name and try to load the texture
+	sprintf(fullname,"%s_%s." SP_TextureExt,name,ext);
+	buffer = SP_LoadFile(fullname);
+
+	if (!buffer)
+	{
+		sprintf(fullname, "%s." SP_TextureExt, name);
+		buffer = SP_LoadFile(fullname);
+	}
+
+	return buffer;
+}
+
+/*********
+SP_LoadFile
+*********/
+void* SP_LoadFile(const char* name)
+{
+	wfhandle_t h = WF_Open(name, true, false);
+	if (h < 0) return NULL;
+
+	if (WF_Seek(0, SEEK_END, h))
+	{
+		WF_Close(h);
+		return NULL;
+	}
+
+	int len = WF_Tell(h);
+	
+	if (WF_Seek(0, SEEK_SET, h))
+	{
+		WF_Close(h);
+		return NULL;
+	}
+
+	void *buf = Z_Malloc(len, TAG_TEMP_WORKSPACE, false, 32);
+
+	if (WF_Read(buf, len, h) != len)
+	{
+		Z_Free(buf);
+		WF_Close(h);
+		return NULL;
+	}
+
+	WF_Close(h);
+
+	return buf;
+}
+
+/********
+SP_DoLicense
+
+Draws the license splash to the screen
+*********/
+void SP_DoLicense(void)
+{
+	if( Sys_QuickStart() )
+		return;
+
+	// Load the license screen
+	void *license;
+	license = SP_LoadFileWithLanguage("d:\\base\\media\\LicenseScreen");
+
+	if (license)
+	{
+
+		for (int c = 0; c < 3; ++c)
+		{
+			SP_DrawTexture(license, 1024, 1024, -20.0);
+		}
+		Z_Free(license);
+	}
+
+	SP_LicenseDone = true;
+}
+
diff --git a/code/ui/ui_splash.h b/code/ui/ui_splash.h
new file mode 100644
index 0000000..f27df31
--- /dev/null
+++ b/code/ui/ui_splash.h
@@ -0,0 +1,11 @@
+#ifndef __UI_SPLASH_H
+#define __UI_SPLASH_H
+
+void	SP_DisplayLogos(void);
+void	SP_DoLicense(void);
+void*	SP_LoadFile(const char* name);
+void*	SP_LoadFileWithLanguage(const char *name);
+char*	SP_GetLanguageExt();
+void	SP_DrawTexture(void* pixels, float width, float height, float vShift);
+
+#endif
diff --git a/code/ui/ui_syscalls.cpp b/code/ui/ui_syscalls.cpp
new file mode 100644
index 0000000..38b2383
--- /dev/null
+++ b/code/ui/ui_syscalls.cpp
@@ -0,0 +1,177 @@
+// Copyright (C) 1999-2000 Id Software, Inc.
+//
+// leave this at the top of all UI_xxxx files for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+#include "ui_local.h"
+
+#ifdef _IMMERSION
+#include "../ff/ff.h"
+#endif // _IMMERSION
+
+// this file is only included when building a dll
+// syscalls.asm is included instead when building a qvm
+
+static int (*syscall)( int arg, ... ) = (int (*)( int, ...))-1;
+
+void dllEntry( int (*syscallptr)( int arg,... ) ) {
+	syscall = syscallptr;
+//	CG_PreInit();
+}
+
+inline int PASSFLOAT( float x ) 
+{
+	float	floatTemp;
+	floatTemp = x;
+	return *(int *)&floatTemp;
+}
+
+int CL_UISystemCalls( int *args );
+
+
+int FloatAsInt( float f );
+
+float trap_Cvar_VariableValue( const char *var_name ) 
+{
+	int temp;
+//	temp = syscall( UI_CVAR_VARIABLEVALUE, var_name );
+	temp = FloatAsInt( Cvar_VariableValue(var_name) );
+	return (*(float*)&temp);
+}
+
+
+void trap_R_ClearScene( void )
+{
+	ui.R_ClearScene();
+}
+
+void trap_R_AddRefEntityToScene( const refEntity_t *re )
+{
+	ui.R_AddRefEntityToScene(re);
+}
+
+void trap_R_RenderScene( const refdef_t *fd ) 
+{
+//	syscall( UI_R_RENDERSCENE, fd );
+	ui.R_RenderScene(fd);
+}
+
+void trap_R_SetColor( const float *rgba ) 
+{
+//	syscall( UI_R_SETCOLOR, rgba );
+//	re.SetColor( rgba );
+	ui.R_SetColor(rgba);
+}
+
+void trap_R_DrawStretchPic( float x, float y, float w, float h, float s1, float t1, float s2, float t2, qhandle_t hShader ) 
+{
+//	syscall( UI_R_DRAWSTRETCHPIC, PASSFLOAT(x), PASSFLOAT(y), PASSFLOAT(w), PASSFLOAT(h), PASSFLOAT(s1), PASSFLOAT(t1), PASSFLOAT(s2), PASSFLOAT(t2), hShader );
+//	re.DrawStretchPic( x, y, w, h, s1, t1, s2, t2, hShader  );
+
+	ui.R_DrawStretchPic( x, y, w, h, s1, t1, s2, t2, hShader );
+
+}
+
+void	trap_R_ModelBounds( clipHandle_t model, vec3_t mins, vec3_t maxs ) 
+{
+//	syscall( UI_R_MODELBOUNDS, model, mins, maxs );
+	ui.R_ModelBounds(model, mins, maxs);
+}
+
+void trap_S_StartLocalSound( sfxHandle_t sfx, int channelNum ) 
+{
+//	syscall( UI_S_STARTLOCALSOUND, sfx, channelNum );
+	S_StartLocalSound( sfx, channelNum );
+}
+
+
+void trap_S_StopSounds( void ) 
+{
+	S_StopSounds( );
+}
+
+sfxHandle_t	trap_S_RegisterSound( const char *sample, qboolean compressed ) 
+{
+	return S_RegisterSound(sample);
+}
+
+#ifdef _IMMERSION
+
+void trap_FF_Start( ffHandle_t ff )
+{
+	FF_AddForce( ff );
+}
+
+ffHandle_t trap_FF_Register( const char *name, int channel )
+{
+	return FF_Register( name, channel, qtrue );
+}
+
+#endif // _IMMERSION
+
+void trap_Key_SetBinding( int keynum, const char *binding ) 
+{
+	Key_SetBinding( keynum, binding);
+}
+
+qboolean trap_Key_GetOverstrikeMode( void ) 
+{
+	return Key_GetOverstrikeMode();
+}
+
+void trap_Key_SetOverstrikeMode( qboolean state ) 
+{
+	Key_SetOverstrikeMode( state );
+}
+
+void trap_Key_ClearStates( void ) 
+{
+	Key_ClearStates();
+}
+
+int Key_GetCatcher( void );
+
+int trap_Key_GetCatcher( void ) 
+{
+	return Key_GetCatcher();
+}
+
+void Key_SetCatcher( int catcher ); 
+
+void trap_Key_SetCatcher( int catcher ) 
+{
+	Key_SetCatcher( catcher );
+}
+/*
+void trap_GetClipboardData( char *buf, int bufsize ) {
+	syscall( UI_GETCLIPBOARDDATA, buf, bufsize );
+}
+
+void trap_GetClientState( uiClientState_t *state ) {
+	syscall( UI_GETCLIENTSTATE, state );
+}
+*/
+
+void CL_GetGlconfig( glconfig_t *glconfig );
+
+void trap_GetGlconfig( glconfig_t *glconfig ) 
+{
+//	syscall( UI_GETGLCONFIG, glconfig );
+	CL_GetGlconfig( glconfig );
+}
+
+#ifndef _XBOX
+// this returns a handle.  arg0 is the name in the format "idlogo.roq", set arg1 to NULL, alteredstates to qfalse (do not alter gamestate)
+int trap_CIN_PlayCinematic( const char *arg0, int xpos, int ypos, int width, int height, int bits, const char *psAudioFile) {
+  return syscall(UI_CIN_PLAYCINEMATIC, arg0, xpos, ypos, width, height, bits, psAudioFile);
+}
+#endif
+
+// stops playing the cinematic and ends it.  should always return FMV_EOF
+// cinematics must be stopped in reverse order of when they are started
+int trap_CIN_StopCinematic(int handle) 
+{
+  return syscall(UI_CIN_STOPCINEMATIC, handle);
+}
+
diff --git a/code/ui/vssver.scc b/code/ui/vssver.scc
new file mode 100644
index 0000000..4cc024e
Binary files /dev/null and b/code/ui/vssver.scc differ
diff --git a/code/unix/Makefile b/code/unix/Makefile
new file mode 100644
index 0000000..5c8dda8
--- /dev/null
+++ b/code/unix/Makefile
@@ -0,0 +1,988 @@
+#
+# Quake3 Unix Makefile
+#
+# Currently build for the following:
+#	Linux i386 (full client)
+#	Linux Alpha (dedicated server only)
+#	SGI IRIX (full client)
+#
+# Nov '98 by Zoid <zoid@idsoftware.com>
+#
+# GNU Make required
+#
+
+PLATFORM=$(shell uname|tr '[:upper:]' '[:lower:]')
+PLATFORM_RELEASE=$(shell uname -r)
+
+###
+### These paths are where you probably want to change things
+###
+
+# Where we are building to, libMesaVoodooGL.so.3.1 should be here, etc.
+# the demo pk3 file should be here in demoq3/pak0.pk3 or baseq3/pak0.pk3
+BUILD_DIR=/home/zoid/Quake3
+
+# Where we are building from (where the source code should be!)
+MOUNT_DIR=/devel/Quake3/q3code
+
+#############################################################################
+##
+## You shouldn't have to touch anything below here
+##
+#############################################################################
+
+DEMO_PAK=$(BUILD_DIR)/demoq3/pak0.pk3
+
+BUILD_DEBUG_DIR=debug$(ARCH)$(GLIBC)
+BUILD_RELEASE_DIR=release$(ARCH)$(GLIBC)
+CLIENT_DIR=$(MOUNT_DIR)/client
+SERVER_DIR=$(MOUNT_DIR)/server
+REF_DIR=$(MOUNT_DIR)/renderer
+COMMON_DIR=$(MOUNT_DIR)/qcommon
+UNIX_DIR=$(MOUNT_DIR)/unix
+GAME_DIR=$(MOUNT_DIR)/game
+CGAME_DIR=$(MOUNT_DIR)/cgame
+NULL_DIR=$(MOUNT_DIR)/null
+
+#used for linux i386 builds
+MESA_DIR=/usr/local/src/Mesa-3.0
+
+VERSION=1.05
+
+VERSION_FN=$(VERSION)$(GLIBC)
+RPM_RELEASE=9
+
+#############################################################################
+# SETUP AND BUILD
+#############################################################################
+
+ifeq ($(PLATFORM),irix)
+
+ARCH=mips  #default to MIPS
+VENDOR=sgi
+GLIBC=  #libc is irrelevant
+
+CC=cc
+BASE_CFLAGS=-Dstricmp=strcasecmp -Xcpluscomm -woff 1185 -mips3 \
+	-nostdinc -I. -I$(ROOT)/usr/include
+RELEASE_CFLAGS=$(BASE_CFLAGS) -O3
+DEBUG_CFLAGS=$(BASE_CFLAGS) -g
+
+SHLIBEXT=so
+SHLIBCFLAGS=
+SHLIBLDFLAGS=-shared
+
+LDFLAGS=-ldl -lm
+GLLDFLAGS=-L/usr/X11/lib -lGL -lX11 -lXext -lm
+
+TARGETS=$(BUILDDIR)/sgiquake3 \
+	$(BUILDDIR)/qagame$(ARCH).$(SHLIBEXT) \
+	$(BUILDDIR)/cgame$(ARCH).$(SHLIBEXT)
+
+else
+ifeq ($(PLATFORM),linux)
+
+ifneq (,$(findstring libc6,$(shell if [ -e /lib/libc.so.6* ];then echo libc6;fi)))
+GLIBC=-glibc
+else
+GLIBC=
+endif #libc6 test
+
+
+ifneq (,$(findstring alpha,$(shell uname -m)))
+ARCH=axp
+RPMARCH=alpha
+VENDOR=dec
+else #default to i386
+ARCH=i386
+RPMARCH=i386
+VENDOR=unknown
+endif #alpha test
+
+BASE_CFLAGS=-Dstricmp=strcasecmp -I$(MESA_DIR)/include -I/usr/include/glide \
+	-DREF_HARD_LINKED -pipe
+
+DEBUG_CFLAGS=$(BASE_CFLAGS) -g
+ifeq ($(ARCH),axp)
+RELEASE_CFLAGS=$(BASE_CFLAGS) -DNDEBUG -O6 -ffast-math -funroll-loops -fomit-frame-pointer -fexpensive-optimizations
+else
+RELEASE_CFLAGS=$(BASE_CFLAGS) -DNDEBUG -O3 -m486 -fomit-frame-pointer -pipe -ffast-math -fexpensive-optimizations -malign-loops=2 -malign-jumps=2 -malign-functions=2
+endif
+
+CC=gcc
+
+SHLIBEXT=so
+SHLIBCFLAGS=-fPIC
+SHLIBLDFLAGS=-shared
+
+LDFLAGS=-ldl -lm
+GLLDFLAGS=-L/usr/X11R6/lib -L$(MESA_DIR)/lib -lX11 -lXext -lXxf86dga -lXxf86vm
+GL_SVGA_LDFLAGS=-L/usr/X11R6/lib -L$(MESA_DIR)/lib -lX11 -lXext -lvga
+
+ifeq ($(ARCH),axp)
+TARGETS=$(BUILDDIR)/linuxq3ded $(BUILDDIR)/qagame$(ARCH).$(SHLIBEXT)
+else
+# $(BUILDDIR)/linuxquake3.vga
+TARGETS=\
+	$(BUILDDIR)/linuxquake3 \
+	$(BUILDDIR)/qagame$(ARCH).$(SHLIBEXT) \
+	$(BUILDDIR)/cgame$(ARCH).$(SHLIBEXT)
+#$(BUILDDIR)/quake3
+endif
+
+
+else #generic
+
+CC=cc
+BASE_CFLAGS=-Dstricmp=strcasecmp
+DEBUG_CFLAGS=$(BASE_CFLAGS) -g
+RELEASE_CFLAGS=$(BASE_CFLAGS) -DNDEBUG -O
+
+SHLIBEXT=so
+SHLIBCFLAGS=-fPIC
+SHLIBLDFLAGS=-shared
+
+LDFLAGS=-ldl -lm
+
+TARGETS=$(BUILDDIR)/q3ded $(BUILDDIR)/qagame$(ARCH).$(SHLIBEXT)
+
+endif #Linux
+endif #IRIX
+
+DO_CC=$(CC) $(CFLAGS) -o $@ -c $<
+DO_DEBUG_CC=$(CC) $(DEBUG_CFLAGS) -o $@ -c $<
+DO_SHLIB_CC=$(CC) $(CFLAGS) $(SHLIBCFLAGS) -o $@ -c $<
+DO_SHLIB_DEBUG_CC=$(CC) $(DEBUG_CFLAGS) $(SHLIBCFLAGS) -o $@ -c $<
+DO_AS=$(CC) $(CFLAGS) -DELF -x assembler-with-cpp -o $@ -c $<
+
+#### DEFAULT TARGET
+# default: build_release
+
+build_debug:
+	$(MAKE) targets BUILDDIR=$(BUILD_DEBUG_DIR) CFLAGS="$(DEBUG_CFLAGS)"
+
+build_release:
+	$(MAKE) targets BUILDDIR=$(BUILD_RELEASE_DIR) CFLAGS="$(RELEASE_CFLAGS)"
+
+#Build both debug and release builds
+all: build_debug build_release
+
+targets: makedirs $(TARGETS)
+
+makedirs:
+	@if [ ! -d $(BUILDDIR) ];then mkdir $(BUILDDIR);fi
+	@if [ ! -d $(BUILDDIR)/client ];then mkdir $(BUILDDIR)/client;fi
+	@if [ ! -d $(BUILDDIR)/ded ];then mkdir $(BUILDDIR)/ded;fi
+	@if [ ! -d $(BUILDDIR)/ref ];then mkdir $(BUILDDIR)/ref;fi
+	@if [ ! -d $(BUILDDIR)/game ];then mkdir $(BUILDDIR)/game;fi
+	@if [ ! -d $(BUILDDIR)/cgame ];then mkdir $(BUILDDIR)/cgame;fi
+
+#############################################################################
+# CLIENT/SERVER
+#############################################################################
+
+QUAKE3_OBJS = \
+	$(BUILDDIR)/client/cl_cgame.o \
+	$(BUILDDIR)/client/cl_cin.o \
+	$(BUILDDIR)/client/cl_console.o \
+	$(BUILDDIR)/client/cl_input.o \
+	$(BUILDDIR)/client/cl_keys.o \
+	$(BUILDDIR)/client/cl_main.o \
+	$(BUILDDIR)/client/cl_parse.o \
+	$(BUILDDIR)/client/cl_scrn.o \
+	$(BUILDDIR)/client/snd_dma.o \
+	$(BUILDDIR)/client/snd_mem.o \
+	$(BUILDDIR)/client/snd_mix.o \
+	$(BUILDDIR)/client/sv_bot.o \
+	$(BUILDDIR)/client/sv_client.o \
+	$(BUILDDIR)/client/sv_ccmds.o \
+	$(BUILDDIR)/client/sv_game.o \
+	$(BUILDDIR)/client/sv_init.o \
+	$(BUILDDIR)/client/sv_main.o \
+	$(BUILDDIR)/client/sv_snapshot.o \
+	$(BUILDDIR)/client/sv_world.o \
+	$(BUILDDIR)/client/ui_arena.o \
+	$(BUILDDIR)/client/ui_connect.o \
+	$(BUILDDIR)/client/ui_controls.o \
+	$(BUILDDIR)/client/ui_demo.o \
+	$(BUILDDIR)/client/ui_maps.o \
+	$(BUILDDIR)/client/ui_menu.o \
+	$(BUILDDIR)/client/ui_network.o \
+	$(BUILDDIR)/client/ui_preferences.o \
+	$(BUILDDIR)/client/ui_qmenu.o \
+	$(BUILDDIR)/client/ui_servers.o \
+	$(BUILDDIR)/client/ui_startserver.o \
+	$(BUILDDIR)/client/ui_video.o \
+	\
+	$(BUILDDIR)/client/cm_load.o \
+	$(BUILDDIR)/client/cm_patch.o \
+	$(BUILDDIR)/client/cm_polylib.o \
+	$(BUILDDIR)/client/cm_tag.o \
+	$(BUILDDIR)/client/cm_test.o \
+	$(BUILDDIR)/client/cm_trace.o \
+	$(BUILDDIR)/client/cmd.o \
+	$(BUILDDIR)/client/common.o \
+	$(BUILDDIR)/client/cvar.o \
+	$(BUILDDIR)/client/files.o \
+	$(BUILDDIR)/client/gameinfo.o \
+	$(BUILDDIR)/client/md4.o \
+	$(BUILDDIR)/client/msg.o \
+	$(BUILDDIR)/client/net_chan.o \
+	$(BUILDDIR)/client/vm.o \
+	\
+	$(BUILDDIR)/client/q_shared.o \
+	$(BUILDDIR)/client/q_math.o \
+	\
+	$(BUILDDIR)/client/tr_backend.o \
+	$(BUILDDIR)/client/tr_bsp.o \
+	$(BUILDDIR)/client/tr_calc.o \
+	$(BUILDDIR)/client/tr_calc_3dnow.o \
+	$(BUILDDIR)/client/tr_calc_c.o \
+	$(BUILDDIR)/client/tr_calc_kni.o \
+	$(BUILDDIR)/client/tr_cmds.o \
+	$(BUILDDIR)/client/tr_curve.o \
+	$(BUILDDIR)/client/tr_draw.o \
+	$(BUILDDIR)/client/tr_flares.o \
+	$(BUILDDIR)/client/tr_image.o \
+	$(BUILDDIR)/client/tr_init.o \
+	$(BUILDDIR)/client/tr_light.o \
+	$(BUILDDIR)/client/tr_main.o \
+	$(BUILDDIR)/client/tr_mesh.o \
+	$(BUILDDIR)/client/tr_misc.o \
+	$(BUILDDIR)/client/tr_model.o \
+	$(BUILDDIR)/client/tr_noise.o \
+	$(BUILDDIR)/client/tr_scene.o \
+	$(BUILDDIR)/client/tr_shade.o \
+	$(BUILDDIR)/client/tr_shader.o \
+	$(BUILDDIR)/client/tr_shade_calc.o \
+	$(BUILDDIR)/client/tr_shadows.o \
+	$(BUILDDIR)/client/tr_smp.o \
+	$(BUILDDIR)/client/tr_sky.o \
+	$(BUILDDIR)/client/tr_surf.o \
+	$(BUILDDIR)/client/tr_world.o \
+	\
+	$(BUILDDIR)/client/unix_main.o \
+	$(BUILDDIR)/client/unix_net.o \
+	$(BUILDDIR)/client/unix_shared.o
+
+#platform specific objects
+ifeq ($(PLATFORM),irix)
+	QUAKE3_PLATOBJ=\
+		$(BUILDDIR)/client/irix_qgl.o \
+		$(BUILDDIR)/client/irix_glimp.o \
+		$(BUILDDIR)/client/irix_snd.o
+else
+ifeq ($(PLATFORM),linux)
+ifeq ($(ARCH),axp)
+	QUAKE3_PLATOBJ=
+else
+	QUAKE3_PLATOBJ=\
+		$(BUILDDIR)/client/linux_qgl.o \
+		$(BUILDDIR)/client/linux_glimp.o \
+		$(BUILDDIR)/client/linux_snd.o \
+		$(BUILDDIR)/client/snd_mixa.o \
+		$(BUILDDIR)/client/matha.o \
+		$(BUILDDIR)/client/sys_dosa.o
+	QUAKE3_VGA=\
+		$(BUILDDIR)/client/linux_qgl.o \
+		$(BUILDDIR)/client/linux_glimp_vga.o \
+		$(BUILDDIR)/client/linux_input_vga.o \
+		$(BUILDDIR)/client/linux_snd.o \
+		$(BUILDDIR)/client/snd_mixa.o \
+		$(BUILDDIR)/client/matha.o \
+		$(BUILDDIR)/client/sys_dosa.o
+
+endif
+endif #Linux
+endif #IRIX
+
+
+$(BUILDDIR)/linuxquake3 : $(QUAKE3_OBJS) $(QUAKE3_PLATOBJ)
+	$(CC) $(CFLAGS) -o $@ $(QUAKE3_OBJS) $(QUAKE3_PLATOBJ) $(GLLDFLAGS) $(LDFLAGS) 
+
+ifeq ($(PLATFORM),linux)
+ifeq ($(ARCH),i386)
+$(BUILDDIR)/linuxquake3.vga : $(QUAKE3_OBJS) $(QUAKE3_VGA)
+	$(CC) $(CFLAGS) -o $@ $(QUAKE3_OBJS) $(QUAKE3_VGA) $(GL_SVGA_LDFLAGS) $(LDFLAGS) 
+endif
+endif
+
+$(BUILDDIR)/client/cl_cgame.o :			$(CLIENT_DIR)/cl_cgame.c
+	$(DO_CC)
+
+$(BUILDDIR)/client/cl_cin.o :			$(CLIENT_DIR)/cl_cin.c
+	$(DO_CC)
+
+$(BUILDDIR)/client/cl_console.o :       $(CLIENT_DIR)/cl_console.c
+	$(DO_CC)
+
+$(BUILDDIR)/client/cl_input.o :         $(CLIENT_DIR)/cl_input.c
+	$(DO_CC)
+
+$(BUILDDIR)/client/cl_keys.o :          $(CLIENT_DIR)/cl_keys.c
+	$(DO_CC)
+
+$(BUILDDIR)/client/cl_main.o :          $(CLIENT_DIR)/cl_main.c
+	$(DO_CC)
+
+$(BUILDDIR)/client/cl_parse.o :         $(CLIENT_DIR)/cl_parse.c
+	$(DO_CC)
+
+$(BUILDDIR)/client/cl_scrn.o :          $(CLIENT_DIR)/cl_scrn.c
+	$(DO_CC)
+
+$(BUILDDIR)/client/snd_dma.o :          $(CLIENT_DIR)/snd_dma.c
+	$(DO_CC)
+
+$(BUILDDIR)/client/snd_mem.o :          $(CLIENT_DIR)/snd_mem.c
+	$(DO_CC)
+
+$(BUILDDIR)/client/snd_mix.o :          $(CLIENT_DIR)/snd_mix.c
+	$(DO_CC)
+
+$(BUILDDIR)/client/sv_bot.o :           $(SERVER_DIR)/sv_bot.c
+	$(DO_CC)
+
+$(BUILDDIR)/client/sv_client.o :           $(SERVER_DIR)/sv_client.c
+	$(DO_CC)
+
+$(BUILDDIR)/client/sv_ccmds.o :         $(SERVER_DIR)/sv_ccmds.c
+	$(DO_CC)
+
+$(BUILDDIR)/client/sv_game.o :          $(SERVER_DIR)/sv_game.c
+	$(DO_CC)
+
+$(BUILDDIR)/client/sv_init.o :          $(SERVER_DIR)/sv_init.c
+	$(DO_CC)
+
+$(BUILDDIR)/client/sv_main.o :          $(SERVER_DIR)/sv_main.c
+	$(DO_CC)
+
+$(BUILDDIR)/client/sv_snapshot.o :      $(SERVER_DIR)/sv_snapshot.c
+	$(DO_CC)
+
+$(BUILDDIR)/client/sv_world.o :         $(SERVER_DIR)/sv_world.c
+	$(DO_CC)
+
+$(BUILDDIR)/client/ui_arena.o :         $(CLIENT_DIR)/ui_arena.c
+	$(DO_CC)
+
+$(BUILDDIR)/client/ui_connect.o :       $(CLIENT_DIR)/ui_connect.c
+	$(DO_CC)
+
+$(BUILDDIR)/client/ui_controls.o :       $(CLIENT_DIR)/ui_controls.c
+	$(DO_CC)
+
+$(BUILDDIR)/client/ui_demo.o :          $(CLIENT_DIR)/ui_demo.c
+	$(DO_CC)
+
+$(BUILDDIR)/client/ui_maps.o :          $(CLIENT_DIR)/ui_maps.c
+	$(DO_CC)
+
+$(BUILDDIR)/client/ui_menu.o :          $(CLIENT_DIR)/ui_menu.c
+	$(DO_CC)
+
+$(BUILDDIR)/client/ui_network.o :       $(CLIENT_DIR)/ui_network.c
+	$(DO_CC)
+
+$(BUILDDIR)/client/ui_preferences.o :   $(CLIENT_DIR)/ui_preferences.c
+	$(DO_CC)
+
+$(BUILDDIR)/client/ui_qmenu.o :         $(CLIENT_DIR)/ui_qmenu.c
+	$(DO_CC)
+
+$(BUILDDIR)/client/ui_servers.o :       $(CLIENT_DIR)/ui_servers.c
+	$(DO_CC)
+
+$(BUILDDIR)/client/ui_startserver.o :       $(CLIENT_DIR)/ui_startserver.c
+	$(DO_CC)
+
+$(BUILDDIR)/client/ui_video.o :         $(UNIX_DIR)/ui_video.c
+	$(DO_CC)
+
+$(BUILDDIR)/client/cm_trace.o :         $(COMMON_DIR)/cm_trace.c
+	$(DO_CC)
+
+$(BUILDDIR)/client/cm_load.o :         $(COMMON_DIR)/cm_load.c
+	$(DO_CC)
+
+$(BUILDDIR)/client/cm_test.o :         $(COMMON_DIR)/cm_test.c
+	$(DO_CC)
+
+$(BUILDDIR)/client/cm_patch.o :         $(COMMON_DIR)/cm_patch.c
+	$(DO_CC)
+
+$(BUILDDIR)/client/cm_polylib.o :         $(COMMON_DIR)/cm_polylib.c
+	$(DO_CC)
+
+$(BUILDDIR)/client/cm_tag.o :         $(COMMON_DIR)/cm_tag.c
+	$(DO_CC)
+
+$(BUILDDIR)/client/cmd.o :              $(COMMON_DIR)/cmd.c
+	$(DO_CC)
+
+$(BUILDDIR)/client/common.o :           $(COMMON_DIR)/common.c
+	$(DO_CC)
+
+$(BUILDDIR)/client/cvar.o :             $(COMMON_DIR)/cvar.c
+	$(DO_CC)
+
+$(BUILDDIR)/client/files.o :            $(COMMON_DIR)/files.c
+	$(DO_CC)
+
+$(BUILDDIR)/client/gameinfo.o :         $(COMMON_DIR)/gameinfo.c
+	$(DO_CC)
+
+$(BUILDDIR)/client/md4.o :              $(COMMON_DIR)/md4.c
+	$(DO_CC)
+
+$(BUILDDIR)/client/msg.o :              $(COMMON_DIR)/msg.c
+	$(DO_CC)
+
+$(BUILDDIR)/client/net_chan.o :         $(COMMON_DIR)/net_chan.c
+	$(DO_CC)
+
+$(BUILDDIR)/client/vm.o :         $(COMMON_DIR)/vm.c
+	$(DO_CC)
+
+$(BUILDDIR)/client/q_shared.o :         $(GAME_DIR)/q_shared.c
+	$(DO_DEBUG_CC)
+
+$(BUILDDIR)/client/q_math.o :         $(GAME_DIR)/q_math.c
+	$(DO_CC)
+
+$(BUILDDIR)/client/tr_bsp.o :           $(REF_DIR)/tr_bsp.c
+	$(DO_CC)
+
+$(BUILDDIR)/client/tr_backend.o :       $(REF_DIR)/tr_backend.c
+	$(DO_CC)
+
+$(BUILDDIR)/client/tr_calc.o :          $(REF_DIR)/tr_calc.c
+	$(DO_CC)
+
+$(BUILDDIR)/client/tr_calc_3dnow.o :    $(REF_DIR)/tr_calc_3dnow.c
+	$(DO_CC)
+
+$(BUILDDIR)/client/tr_calc_c.o :        $(REF_DIR)/tr_calc_c.c
+	$(DO_CC)
+
+$(BUILDDIR)/client/tr_calc_kni.o :      $(REF_DIR)/tr_calc_kni.c
+	$(DO_CC)
+
+$(BUILDDIR)/client/tr_cmds.o :      $(REF_DIR)/tr_cmds.c
+	$(DO_CC)
+
+$(BUILDDIR)/client/tr_curve.o :      $(REF_DIR)/tr_curve.c
+	$(DO_CC)
+
+$(BUILDDIR)/client/tr_draw.o :          $(REF_DIR)/tr_draw.c
+	$(DO_CC)
+
+$(BUILDDIR)/client/tr_flares.o :          $(REF_DIR)/tr_flares.c
+	$(DO_CC)
+
+$(BUILDDIR)/client/tr_image.o :         $(REF_DIR)/tr_image.c
+	$(DO_CC)
+
+$(BUILDDIR)/client/tr_init.o :          $(REF_DIR)/tr_init.c
+	$(DO_CC)
+
+$(BUILDDIR)/client/tr_light.o :         $(REF_DIR)/tr_light.c
+	$(DO_CC)
+
+$(BUILDDIR)/client/tr_main.o :          $(REF_DIR)/tr_main.c
+	$(DO_CC)
+
+$(BUILDDIR)/client/tr_mesh.o :          $(REF_DIR)/tr_mesh.c
+	$(DO_CC)
+
+$(BUILDDIR)/client/tr_misc.o :          $(REF_DIR)/tr_misc.c
+	$(DO_CC)
+
+$(BUILDDIR)/client/tr_model.o :         $(REF_DIR)/tr_model.c
+	$(DO_CC)
+
+$(BUILDDIR)/client/tr_noise.o :         $(REF_DIR)/tr_noise.c
+	$(DO_CC)
+
+$(BUILDDIR)/client/tr_scene.o :         $(REF_DIR)/tr_scene.c
+	$(DO_CC)
+
+$(BUILDDIR)/client/tr_shade.o :         $(REF_DIR)/tr_shade.c
+	$(DO_CC)
+
+$(BUILDDIR)/client/tr_shader.o :        $(REF_DIR)/tr_shader.c
+	$(DO_CC)
+
+$(BUILDDIR)/client/tr_shade_calc.o :         $(REF_DIR)/tr_shade_calc.c
+	$(DO_CC)
+
+$(BUILDDIR)/client/tr_shadows.o :        $(REF_DIR)/tr_shadows.c
+	$(DO_CC)
+
+$(BUILDDIR)/client/tr_sky.o :           $(REF_DIR)/tr_sky.c
+	$(DO_CC)
+
+$(BUILDDIR)/client/tr_smp.o :           $(REF_DIR)/tr_smp.c
+	$(DO_CC)
+
+$(BUILDDIR)/client/tr_stripify.o :      $(REF_DIR)/tr_stripify.c
+	$(DO_CC)
+
+$(BUILDDIR)/client/tr_subdivide.o :     $(REF_DIR)/tr_subdivide.c
+	$(DO_CC)
+
+$(BUILDDIR)/client/tr_surf.o :          $(REF_DIR)/tr_surf.c
+	$(DO_CC)
+
+$(BUILDDIR)/client/tr_world.o :         $(REF_DIR)/tr_world.c
+	$(DO_CC)
+
+$(BUILDDIR)/client/unix_qgl.o :         $(UNIX_DIR)/unix_qgl.c
+	$(DO_CC)
+
+$(BUILDDIR)/client/unix_dedicated.o :   $(UNIX_DIR)/unix_dedicated.c
+	$(DO_CC)
+
+$(BUILDDIR)/client/unix_earlycon.o :    $(UNIX_DIR)/unix_earlycon.c
+	$(DO_CC)
+
+$(BUILDDIR)/client/unix_main.o :        $(UNIX_DIR)/unix_main.c
+	$(DO_CC)
+
+$(BUILDDIR)/client/unix_net.o :         $(UNIX_DIR)/unix_net.c
+	$(DO_CC)
+
+$(BUILDDIR)/client/unix_shared.o :      $(UNIX_DIR)/unix_shared.c
+	$(DO_CC)
+
+$(BUILDDIR)/client/irix_glimp.o :       $(UNIX_DIR)/irix_glimp.c
+	$(DO_CC)
+
+$(BUILDDIR)/client/irix_snd.o :         $(UNIX_DIR)/irix_snd.c
+	$(DO_CC)
+
+$(BUILDDIR)/client/irix_input.o :       $(UNIX_DIR)/irix_input.c
+	$(DO_CC)
+
+$(BUILDDIR)/client/linux_glimp.o :      $(UNIX_DIR)/linux_glimp.c
+	$(DO_CC)
+
+$(BUILDDIR)/client/linux_qgl.o :        $(UNIX_DIR)/linux_qgl.c
+	$(DO_CC)
+
+$(BUILDDIR)/client/linux_input.o :      $(UNIX_DIR)/linux_input.c
+	$(DO_CC)
+
+$(BUILDDIR)/client/linux_glimp_vga.o :  $(UNIX_DIR)/linux_glimp_vga.c
+	$(DO_CC)
+
+$(BUILDDIR)/client/linux_snd.o :        $(UNIX_DIR)/linux_snd.c
+	$(DO_CC)
+
+$(BUILDDIR)/client/snd_mixa.o :   $(UNIX_DIR)/snd_mixa.s
+	$(DO_AS)
+
+$(BUILDDIR)/client/matha.o :   $(UNIX_DIR)/matha.s
+	$(DO_AS)
+
+$(BUILDDIR)/client/sys_dosa.o :   $(UNIX_DIR)/sys_dosa.s
+	$(DO_AS)
+
+$(BUILDDIR)/client/linux_input_vga.o :  $(UNIX_DIR)/linux_input_vga.c
+	$(DO_CC)
+
+#############################################################################
+# DEDICATED SERVER                        
+#############################################################################
+
+Q3DED_OBJS = \
+	$(BUILDDIR)/ded/sv_bot.o \
+	$(BUILDDIR)/ded/sv_client.o \
+	$(BUILDDIR)/ded/sv_ccmds.o \
+	$(BUILDDIR)/ded/sv_game.o \
+	$(BUILDDIR)/ded/sv_init.o \
+	$(BUILDDIR)/ded/sv_main.o \
+	$(BUILDDIR)/ded/sv_snapshot.o \
+	$(BUILDDIR)/ded/sv_world.o \
+	\
+	$(BUILDDIR)/ded/cm_trace.o \
+	$(BUILDDIR)/ded/cm_load.o \
+	$(BUILDDIR)/ded/cm_test.o \
+	$(BUILDDIR)/ded/cm_patch.o \
+	$(BUILDDIR)/ded/cm_tag.o \
+	$(BUILDDIR)/ded/cmd.o \
+	$(BUILDDIR)/ded/common.o \
+	$(BUILDDIR)/ded/cvar.o \
+	$(BUILDDIR)/ded/files.o \
+	$(BUILDDIR)/ded/gameinfo.o \
+	$(BUILDDIR)/ded/md4.o \
+	$(BUILDDIR)/ded/msg.o \
+	$(BUILDDIR)/ded/net_chan.o \
+	\
+	$(BUILDDIR)/ded/unix_dedicated.o \
+	$(BUILDDIR)/ded/unix_main.o \
+	$(BUILDDIR)/ded/unix_net.o \
+	$(BUILDDIR)/ded/unix_shared.o \
+	\
+	$(BUILDDIR)/ded/cl_null.o
+
+$(BUILDDIR)/linuxq3ded : $(Q3DED_OBJS)
+	$(CC) $(CFLAGS) -o $@ $(Q3DED_OBJS) $(LDFLAGS)
+
+$(BUILDDIR)/ded/sv_bot.o :			$(SERVER_DIR)/sv_bot.c
+	$(DO_DED_CC)
+
+$(BUILDDIR)/ded/sv_client.o :			$(SERVER_DIR)/sv_client.c
+	$(DO_DED_CC)
+
+$(BUILDDIR)/ded/sv_ccmds.o :        $(SERVER_DIR)/sv_ccmds.c
+	$(DO_DED_CC)
+
+$(BUILDDIR)/ded/sv_game.o :         $(SERVER_DIR)/sv_game.c
+	$(DO_DED_CC)
+
+$(BUILDDIR)/ded/sv_init.o :         $(SERVER_DIR)/sv_init.c
+	$(DO_DED_CC)
+
+$(BUILDDIR)/ded/sv_main.o :         $(SERVER_DIR)/sv_main.c
+	$(DO_DED_CC)
+
+$(BUILDDIR)/ded/sv_snapshot.o :     $(SERVER_DIR)/sv_snapshot.c
+	$(DO_DED_CC)
+
+$(BUILDDIR)/ded/sv_world.o :        $(SERVER_DIR)/sv_world.c
+	$(DO_DED_CC)
+
+$(BUILDDIR)/ded/cm_trace.o :        $(COMMON_DIR)/cm_trace.c
+	$(DO_DED_CC)
+
+$(BUILDDIR)/ded/cm_load.o :        $(COMMON_DIR)/cm_load.c
+	$(DO_DED_CC)
+
+$(BUILDDIR)/ded/cm_test.o :        $(COMMON_DIR)/cm_test.c
+	$(DO_DED_CC)
+
+$(BUILDDIR)/ded/cm_patch.o :        $(COMMON_DIR)/cm_patch.c
+	$(DO_DED_CC)
+
+$(BUILDDIR)/ded/cm_tag.o :        $(COMMON_DIR)/cm_tag.c
+	$(DO_DED_CC)
+
+$(BUILDDIR)/ded/cmd.o :             $(COMMON_DIR)/cmd.c
+	$(DO_DED_CC)
+
+$(BUILDDIR)/ded/common.o :          $(COMMON_DIR)/common.c
+	$(DO_DED_CC)
+
+$(BUILDDIR)/ded/cvar.o :            $(COMMON_DIR)/cvar.c
+	$(DO_DED_CC)
+
+$(BUILDDIR)/ded/files.o :           $(COMMON_DIR)/files.c
+	$(DO_DED_CC)
+
+$(BUILDDIR)/ded/gameinfo.o :        $(COMMON_DIR)/gameinfo.c
+	$(DO_DED_CC)
+
+$(BUILDDIR)/ded/md4.o :             $(COMMON_DIR)/md4.c
+	$(DO_DED_CC)
+
+$(BUILDDIR)/ded/msg.o :             $(COMMON_DIR)/msg.c
+	$(DO_DED_CC)
+
+$(BUILDDIR)/ded/net_chan.o :        $(COMMON_DIR)/net_chan.c
+	$(DO_DED_CC)
+
+$(BUILDDIR)/ded/unix_dedicated.o :  $(UNIX_DIR)/unix_dedicated.c
+	$(DO_DED_CC)
+
+$(BUILDDIR)/ded/unix_main.o :       $(UNIX_DIR)/unix_main.c
+	$(DO_DED_CC)
+
+$(BUILDDIR)/ded/unix_net.o :        $(UNIX_DIR)/unix_net.c
+	$(DO_DED_CC)
+
+$(BUILDDIR)/ded/unix_shared.o :     $(UNIX_DIR)/unix_shared.c
+	$(DO_DED_CC)
+
+$(BUILDDIR)/ded/cl_null.o :         $(NULL_DIR)/cl_null.c
+	$(DO_DED_CC)
+
+#############################################################################
+# GAME
+#############################################################################
+
+GAME_OBJS = \
+	$(BUILDDIR)/game/b_ai.o \
+	$(BUILDDIR)/game/b_files.o \
+	$(BUILDDIR)/game/b_items.o \
+	$(BUILDDIR)/game/b_main.o \
+	$(BUILDDIR)/game/b_nav.o \
+	$(BUILDDIR)/game/b_navgen.o \
+	$(BUILDDIR)/game/bg_misc.o \
+	$(BUILDDIR)/game/bg_pmove.o \
+	$(BUILDDIR)/game/g_active.o \
+	$(BUILDDIR)/game/g_aim.o \
+	$(BUILDDIR)/game/g_client.o \
+	$(BUILDDIR)/game/g_cmds.o \
+	$(BUILDDIR)/game/g_combat.o \
+	$(BUILDDIR)/game/g_items.o \
+	$(BUILDDIR)/game/g_main.o \
+	$(BUILDDIR)/game/g_mem.o \
+	$(BUILDDIR)/game/g_misc.o \
+	$(BUILDDIR)/game/g_missile.o \
+	$(BUILDDIR)/game/g_mover.o \
+	$(BUILDDIR)/game/g_spawn.o \
+	$(BUILDDIR)/game/g_svcmds.o \
+	$(BUILDDIR)/game/g_target.o \
+	$(BUILDDIR)/game/g_team.o \
+	$(BUILDDIR)/game/g_trigger.o \
+	$(BUILDDIR)/game/g_utils.o \
+	$(BUILDDIR)/game/g_weapon.o \
+	$(BUILDDIR)/game/q_shared.o \
+	$(BUILDDIR)/game/q_math.o
+
+$(BUILDDIR)/qagame$(ARCH).$(SHLIBEXT) : $(GAME_OBJS)
+	$(CC) $(CFLAGS) $(SHLIBLDFLAGS) -o $@ $(GAME_OBJS)
+
+$(BUILDDIR)/game/b_ai.o :		$(GAME_DIR)/b_ai.c
+	$(DO_SHLIB_CC)
+
+$(BUILDDIR)/game/b_files.o :     $(GAME_DIR)/b_files.c
+	$(DO_SHLIB_CC)
+
+$(BUILDDIR)/game/b_items.o :     $(GAME_DIR)/b_items.c
+	$(DO_SHLIB_CC)
+
+$(BUILDDIR)/game/b_main.o :     $(GAME_DIR)/b_main.c
+	$(DO_SHLIB_CC)
+
+$(BUILDDIR)/game/b_nav.o :      $(GAME_DIR)/b_nav.c
+	$(DO_SHLIB_CC)
+
+$(BUILDDIR)/game/b_navgen.o :      $(GAME_DIR)/b_navgen.c
+	$(DO_SHLIB_CC)
+
+$(BUILDDIR)/game/bg_misc.o :   $(GAME_DIR)/bg_misc.c
+	$(DO_SHLIB_CC)
+
+$(BUILDDIR)/game/bg_pmove.o :   $(GAME_DIR)/bg_pmove.c
+	$(DO_SHLIB_CC)
+
+$(BUILDDIR)/game/g_active.o :   $(GAME_DIR)/g_active.c
+	$(DO_SHLIB_CC)
+
+$(BUILDDIR)/game/g_aim.o :   $(GAME_DIR)/g_aim.c
+	$(DO_SHLIB_CC)
+
+$(BUILDDIR)/game/g_client.o :   $(GAME_DIR)/g_client.c
+	$(DO_SHLIB_CC)
+
+$(BUILDDIR)/game/g_cmds.o :     $(GAME_DIR)/g_cmds.c
+	$(DO_SHLIB_CC)
+
+$(BUILDDIR)/game/g_combat.o :   $(GAME_DIR)/g_combat.c
+	$(DO_SHLIB_CC)
+
+$(BUILDDIR)/game/g_items.o :    $(GAME_DIR)/g_items.c
+	$(DO_SHLIB_CC)
+
+$(BUILDDIR)/game/g_main.o :     $(GAME_DIR)/g_main.c
+	$(DO_SHLIB_CC)
+
+$(BUILDDIR)/game/g_mem.o :     $(GAME_DIR)/g_mem.c
+	$(DO_SHLIB_CC)
+
+$(BUILDDIR)/game/g_misc.o :     $(GAME_DIR)/g_misc.c
+	$(DO_SHLIB_CC)
+
+$(BUILDDIR)/game/g_missile.o :  $(GAME_DIR)/g_missile.c
+	$(DO_SHLIB_CC)
+
+$(BUILDDIR)/game/g_mover.o :    $(GAME_DIR)/g_mover.c
+	$(DO_SHLIB_CC)
+
+$(BUILDDIR)/game/g_spawn.o :    $(GAME_DIR)/g_spawn.c
+	$(DO_SHLIB_CC)
+
+$(BUILDDIR)/game/g_svcmds.o :   $(GAME_DIR)/g_svcmds.c
+	$(DO_SHLIB_CC)
+
+$(BUILDDIR)/game/g_target.o :   $(GAME_DIR)/g_target.c
+	$(DO_SHLIB_CC)
+
+$(BUILDDIR)/game/g_team.o :   $(GAME_DIR)/g_team.c
+	$(DO_SHLIB_CC)
+
+$(BUILDDIR)/game/g_trigger.o :  $(GAME_DIR)/g_trigger.c
+	$(DO_SHLIB_CC)
+
+$(BUILDDIR)/game/g_utils.o :    $(GAME_DIR)/g_utils.c
+	$(DO_SHLIB_CC)
+
+$(BUILDDIR)/game/g_weapon.o :   $(GAME_DIR)/g_weapon.c
+	$(DO_SHLIB_CC)
+
+$(BUILDDIR)/game/q_shared.o :   $(GAME_DIR)/q_shared.c
+	$(DO_SHLIB_DEBUG_CC)
+
+$(BUILDDIR)/game/q_math.o :   $(GAME_DIR)/q_math.c
+	$(DO_SHLIB_CC)
+
+#############################################################################
+# CGAME
+#############################################################################
+
+CGAME_OBJS = \
+	$(BUILDDIR)/cgame/bg_misc.o \
+	$(BUILDDIR)/cgame/bg_pmove.o \
+	$(BUILDDIR)/cgame/cg_draw.o \
+	$(BUILDDIR)/cgame/cg_effects.o \
+	$(BUILDDIR)/cgame/cg_ents.o \
+	$(BUILDDIR)/cgame/cg_event.o \
+	$(BUILDDIR)/cgame/cg_info.o \
+	$(BUILDDIR)/cgame/cg_localents.o \
+	$(BUILDDIR)/cgame/cg_main.o \
+	$(BUILDDIR)/cgame/cg_marks.o \
+	$(BUILDDIR)/cgame/cg_menu.o \
+	$(BUILDDIR)/cgame/cg_players.o \
+	$(BUILDDIR)/cgame/cg_predict.o \
+	$(BUILDDIR)/cgame/cg_scoreboard.o \
+	$(BUILDDIR)/cgame/cg_snapshot.o \
+	$(BUILDDIR)/cgame/cg_view.o \
+	$(BUILDDIR)/cgame/cg_weapons.o \
+	$(BUILDDIR)/cgame/q_shared.o \
+	$(BUILDDIR)/cgame/q_math.o
+
+$(BUILDDIR)/cgame$(ARCH).$(SHLIBEXT) : $(CGAME_OBJS)
+	$(CC) $(CFLAGS) $(SHLIBLDFLAGS) -o $@ $(CGAME_OBJS)
+
+$(BUILDDIR)/cgame/bg_misc.o :		$(GAME_DIR)/bg_misc.c
+	$(DO_SHLIB_CC)
+
+$(BUILDDIR)/cgame/bg_pmove.o :      $(GAME_DIR)/bg_pmove.c
+	$(DO_SHLIB_CC)
+
+$(BUILDDIR)/cgame/cg_draw.o :       $(CGAME_DIR)/cg_draw.c
+	$(DO_SHLIB_CC)
+
+$(BUILDDIR)/cgame/cg_effects.o :       $(CGAME_DIR)/cg_effects.c
+	$(DO_SHLIB_CC)
+
+$(BUILDDIR)/cgame/cg_ents.o :       $(CGAME_DIR)/cg_ents.c
+	$(DO_SHLIB_CC)
+
+$(BUILDDIR)/cgame/cg_event.o :      $(CGAME_DIR)/cg_event.c
+	$(DO_SHLIB_CC)
+
+$(BUILDDIR)/cgame/cg_info.o :      $(CGAME_DIR)/cg_info.c
+	$(DO_SHLIB_CC)
+
+$(BUILDDIR)/cgame/cg_localents.o :       $(CGAME_DIR)/cg_localents.c
+	$(DO_SHLIB_CC)
+
+$(BUILDDIR)/cgame/cg_main.o :       $(CGAME_DIR)/cg_main.c
+	$(DO_SHLIB_CC)
+
+$(BUILDDIR)/cgame/cg_marks.o :       $(CGAME_DIR)/cg_marks.c
+	$(DO_SHLIB_CC)
+
+$(BUILDDIR)/cgame/cg_menu.o :       $(CGAME_DIR)/cg_menu.c
+	$(DO_SHLIB_CC)
+
+$(BUILDDIR)/cgame/cg_players.o :    $(CGAME_DIR)/cg_players.c
+	$(DO_SHLIB_CC)
+
+$(BUILDDIR)/cgame/cg_predict.o :    $(CGAME_DIR)/cg_predict.c
+	$(DO_SHLIB_CC)
+
+$(BUILDDIR)/cgame/cg_scoreboard.o :       $(CGAME_DIR)/cg_scoreboard.c
+	$(DO_SHLIB_CC)
+
+$(BUILDDIR)/cgame/cg_snapshot.o :       $(CGAME_DIR)/cg_snapshot.c
+	$(DO_SHLIB_CC)
+
+$(BUILDDIR)/cgame/cg_view.o :       $(CGAME_DIR)/cg_view.c
+	$(DO_SHLIB_CC)
+
+$(BUILDDIR)/cgame/cg_weapons.o :    $(CGAME_DIR)/cg_weapons.c
+	$(DO_SHLIB_CC)
+
+$(BUILDDIR)/cgame/q_shared.o :      $(GAME_DIR)/q_shared.c
+	$(DO_SHLIB_DEBUG_CC)
+
+$(BUILDDIR)/cgame/q_math.o :      $(GAME_DIR)/q_math.c
+	$(DO_SHLIB_CC)
+
+
+#############################################################################
+# RPM
+#############################################################################
+
+###### DISABLED
+
+TMPDIR=/var/tmp
+TARDIR=$(TMPDIR)/q3test
+TARFILE = q3test-$(VERSION_FN)-$(RPM_RELEASE).$(ARCH).tar
+
+tar:
+	if [ ! -d archives ];then mkdir archives;chmod 755 archives;fi
+	$(MAKE) copyfiles COPYDIR=$(TARDIR)
+	cd $(TARDIR)/..; tar cvf $(TARFILE) q3test && gzip -9 $(TARFILE)
+	mv $(TARDIR)/../$(TARFILE).gz archives/.
+	chmod 644 archives/$(TARFILE).gz
+	rm -rf $(TARDIR)
+ 
+# Make RPMs.  You need to be root to make this work
+RPMROOT=/usr/src/redhat
+RPM = rpm
+RPMFLAGS = -bb
+INSTALLDIR = /usr/local/games/q3test
+RPMDIR = $(TMPDIR)/q3test-$(VERSION_FN)
+DESTDIR= $(RPMDIR)/$(INSTALLDIR)
+
+rpm: q3test.spec
+	touch $(RPMROOT)/SOURCES/q3test-$(VERSION_FN).tar.gz
+	if [ ! -d archives ];then mkdir archives;fi
+	$(MAKE) copyfiles COPYDIR=$(DESTDIR)
+	cp $(UNIX_DIR)/quake3.gif $(RPMROOT)/SOURCES/.
+	cp q3test.spec $(RPMROOT)/SPECS/.
+	cd $(RPMROOT)/SPECS; $(RPM) $(RPMFLAGS) q3test.spec
+	rm -rf $(RPMDIR)
+	mv $(RPMROOT)/RPMS/$(RPMARCH)/q3test-$(VERSION_FN)-$(RPM_RELEASE).$(RPMARCH).rpm archives/q3test-$(VERSION_FN)-$(RPM_RELEASE).$(RPMARCH).rpm 
+	chmod 644 archives/q3test-$(VERSION_FN)-$(RPM_RELEASE).$(RPMARCH).rpm 
+
+copyfiles:
+	-mkdirhier $(COPYDIR)
+	cp $(BUILD_RELEASE_DIR)/linuxquake3 $(COPYDIR)
+	strip $(COPYDIR)/linuxquake3
+	chmod 755 $(COPYDIR)/linuxquake3
+	cp $(BUILD_RELEASE_DIR)/qagame$(ARCH).$(SHLIBEXT) $(COPYDIR)
+	chmod 755 $(COPYDIR)/qagame$(ARCH).$(SHLIBEXT)
+	cp $(BUILD_RELEASE_DIR)/cgame$(ARCH).$(SHLIBEXT) $(COPYDIR)
+	chmod 755 $(COPYDIR)/cgame$(ARCH).$(SHLIBEXT)
+	cp $(BUILD_DIR)/libMesaVoodooGL.so.3.1 $(COPYDIR)/.
+	chmod 755 $(COPYDIR)/libMesaVoodooGL.so.3.1
+	-mkdir $(COPYDIR)/demoq3
+	chmod 1777 $(COPYDIR)/demoq3
+	cp $(DEMO_PAK) $(COPYDIR)/demoq3/pak0.pk3
+	cp $(UNIX_DIR)/README.EULA $(COPYDIR)
+	chmod 644 $(COPYDIR)/README.EULA
+	cp $(UNIX_DIR)/README.Q3Test $(COPYDIR)
+	chmod 644 $(COPYDIR)/README.Q3Test
+
+q3test.spec : $(UNIX_DIR)/q3test.spec.sh Makefile
+	sh $< $(VERSION_FN) $(RPM_RELEASE) $(ARCH) $(INSTALLDIR) > $@
+
+#############################################################################
+# MISC
+#############################################################################
+
+clean: clean-debug clean-release
+
+clean-debug:
+	$(MAKE) clean2 BUILDDIR=$(BUILD_DEBUG_DIR) CFLAGS="$(DEBUG_CFLAGS)"
+
+clean-release:
+	$(MAKE) clean2 BUILDDIR=$(BUILD_RELEASE_DIR) CFLAGS="$(DEBUG_CFLAGS)"
+
diff --git a/code/unix/linux_glimp.c b/code/unix/linux_glimp.c
new file mode 100644
index 0000000..8bfe671
--- /dev/null
+++ b/code/unix/linux_glimp.c
@@ -0,0 +1,1387 @@
+/*
+** GLW_IMP.C
+**
+** This file contains ALL Linux specific stuff having to do with the
+** OpenGL refresh.  When a port is being made the following functions
+** must be implemented by the port:
+**
+** GLimp_EndFrame
+** GLimp_Init
+** GLimp_Shutdown
+** GLimp_SwitchFullscreen
+**
+*/
+
+#include <termios.h>
+#include <sys/ioctl.h>
+#include <sys/stat.h>
+#include <sys/vt.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <signal.h>
+#include <pthread.h>
+#include <semaphore.h>
+
+//#include "../qcommon/qcommon.h"
+//#include "../client/keys.h"
+#include "../renderer/tr_local.h"
+#include "../client/client.h"
+
+#include "unix_glw.h"
+
+#include <GL/glx.h>
+
+#include <X11/keysym.h>
+#include <X11/cursorfont.h>
+
+#include <X11/extensions/xf86dga.h>
+#include <X11/extensions/xf86vmode.h>
+
+typedef enum {
+	RSERR_OK,
+
+	RSERR_INVALID_FULLSCREEN,
+	RSERR_INVALID_MODE,
+
+	RSERR_UNKNOWN
+} rserr_t;
+
+glwstate_t glw_state;
+
+static Display *dpy = NULL;
+static int scrnum;
+static Window win = 0;
+static GLXContext ctx = NULL;
+
+static qboolean autorepeaton = qtrue;
+
+#define KEY_MASK (KeyPressMask | KeyReleaseMask)
+#define MOUSE_MASK (ButtonPressMask | ButtonReleaseMask | \
+		    PointerMotionMask | ButtonMotionMask )
+#define X_MASK (KEY_MASK | MOUSE_MASK | VisibilityChangeMask | StructureNotifyMask )
+
+static qboolean        mouse_avail;
+static qboolean        mouse_active;
+static int   mx, my;
+
+static cvar_t	*in_mouse;
+static cvar_t	*in_dgamouse;
+
+static cvar_t	*r_fakeFullscreen;
+
+qboolean dgamouse = qfalse;
+qboolean vidmode_ext = qfalse;
+
+static int win_x, win_y;
+
+static XF86VidModeModeInfo **vidmodes;
+static int default_dotclock_vidmode;
+static int num_vidmodes;
+static qboolean vidmode_active = qfalse;
+
+static int mouse_accel_numerator;
+static int mouse_accel_denominator;
+static int mouse_threshold;    
+
+/*****************************************************************************/
+/* KEYBOARD                                                                  */
+/*****************************************************************************/
+
+static unsigned int	keyshift[256];		// key to map to if shift held down in console
+static qboolean shift_down=qfalse;
+
+static char *XLateKey(XKeyEvent *ev, int *key)
+{
+	static char buf[64];
+	KeySym keysym;
+	static qboolean setup = qfalse;
+	int i;
+
+	*key = 0;
+
+	XLookupString(ev, buf, sizeof buf, &keysym, 0);
+
+// ri.Printf( PRINT_ALL, "keysym=%04X\n", (int)keysym);
+	switch(keysym)
+	{
+		case XK_KP_Page_Up:	
+		case XK_KP_9:	 *key = K_KP_PGUP; break;
+		case XK_Page_Up:	 *key = K_PGUP; break;
+
+		case XK_KP_Page_Down: 
+		case XK_KP_3: *key = K_KP_PGDN; break;
+		case XK_Page_Down:	 *key = K_PGDN; break;
+
+		case XK_KP_Home: *key = K_KP_HOME; break;
+		case XK_KP_7: *key = K_KP_HOME; break;
+		case XK_Home:	 *key = K_HOME; break;
+
+		case XK_KP_End:
+		case XK_KP_1:	  *key = K_KP_END; break;
+		case XK_End:	 *key = K_END; break;
+
+		case XK_KP_Left: *key = K_KP_LEFTARROW; break;
+		case XK_KP_4: *key = K_KP_LEFTARROW; break;
+		case XK_Left:	 *key = K_LEFTARROW; break;
+
+		case XK_KP_Right: *key = K_KP_RIGHTARROW; break;
+		case XK_KP_6: *key = K_KP_RIGHTARROW; break;
+		case XK_Right:	*key = K_RIGHTARROW;		break;
+
+		case XK_KP_Down:
+		case XK_KP_2: 	 *key = K_KP_DOWNARROW; break;
+		case XK_Down:	 *key = K_DOWNARROW; break;
+
+		case XK_KP_Up:   
+		case XK_KP_8:    *key = K_KP_UPARROW; break;
+		case XK_Up:		 *key = K_UPARROW;	 break;
+
+		case XK_Escape: *key = K_ESCAPE;		break;
+
+		case XK_KP_Enter: *key = K_KP_ENTER;	break;
+		case XK_Return: *key = K_ENTER;		 break;
+
+		case XK_Tab:		*key = K_TAB;			 break;
+
+		case XK_F1:		 *key = K_F1;				break;
+
+		case XK_F2:		 *key = K_F2;				break;
+
+		case XK_F3:		 *key = K_F3;				break;
+
+		case XK_F4:		 *key = K_F4;				break;
+
+		case XK_F5:		 *key = K_F5;				break;
+
+		case XK_F6:		 *key = K_F6;				break;
+
+		case XK_F7:		 *key = K_F7;				break;
+
+		case XK_F8:		 *key = K_F8;				break;
+
+		case XK_F9:		 *key = K_F9;				break;
+
+		case XK_F10:		*key = K_F10;			 break;
+
+		case XK_F11:		*key = K_F11;			 break;
+
+		case XK_F12:		*key = K_F12;			 break;
+
+//		case XK_BackSpace: *key = K_BACKSPACE; break;
+		case XK_BackSpace: *key = 8; break; // ctrl-h
+
+		case XK_KP_Delete:
+		case XK_KP_Decimal: *key = K_KP_DEL; break;
+		case XK_Delete: *key = K_DEL; break;
+
+		case XK_Pause:	*key = K_PAUSE;		 break;
+
+		case XK_Shift_L:
+		case XK_Shift_R:	*key = K_SHIFT;		break;
+
+		case XK_Execute: 
+		case XK_Control_L: 
+		case XK_Control_R:	*key = K_CTRL;		 break;
+
+		case XK_Alt_L:	
+		case XK_Meta_L: 
+		case XK_Alt_R:	
+		case XK_Meta_R: *key = K_ALT;			break;
+
+		case XK_KP_Begin: *key = K_KP_5;	break;
+
+		case XK_Insert:		*key = K_INS; break;
+		case XK_KP_Insert:
+		case XK_KP_0: *key = K_KP_INS; break;
+
+		case XK_KP_Multiply: *key = '*'; break;
+		case XK_KP_Add:  *key = K_KP_PLUS; break;
+		case XK_KP_Subtract: *key = K_KP_MINUS; break;
+		case XK_KP_Divide: *key = K_KP_SLASH; break;
+
+		default:
+			*key = *(unsigned char *)buf;
+			if (*key >= 'A' && *key <= 'Z')
+				*key = *key - 'A' + 'a';
+			break;
+	} 
+
+	return buf;
+}
+
+// ========================================================================
+// makes a null cursor
+// ========================================================================
+
+static Cursor CreateNullCursor(Display *display, Window root)
+{
+    Pixmap cursormask; 
+    XGCValues xgc;
+    GC gc;
+    XColor dummycolour;
+    Cursor cursor;
+
+    cursormask = XCreatePixmap(display, root, 1, 1, 1/*depth*/);
+    xgc.function = GXclear;
+    gc =  XCreateGC(display, cursormask, GCFunction, &xgc);
+    XFillRectangle(display, cursormask, gc, 0, 0, 1, 1);
+    dummycolour.pixel = 0;
+    dummycolour.red = 0;
+    dummycolour.flags = 04;
+    cursor = XCreatePixmapCursor(display, cursormask, cursormask,
+          &dummycolour,&dummycolour, 0,0);
+    XFreePixmap(display,cursormask);
+    XFreeGC(display,gc);
+    return cursor;
+}
+
+static void install_grabs(void)
+{
+// inviso cursor
+	XDefineCursor(dpy, win, CreateNullCursor(dpy, win));
+
+	XGrabPointer(dpy, win,
+				 False,
+				 MOUSE_MASK,
+				 GrabModeAsync, GrabModeAsync,
+				 win,
+				 None,
+				 CurrentTime);
+
+	XGetPointerControl(dpy, &mouse_accel_numerator, &mouse_accel_denominator,
+		&mouse_threshold);
+
+	XChangePointerControl(dpy, qtrue, qtrue, 2, 1, 0);
+
+	if (in_dgamouse->value) {
+		int MajorVersion, MinorVersion;
+
+		if (!XF86DGAQueryVersion(dpy, &MajorVersion, &MinorVersion)) { 
+			// unable to query, probalby not supported
+			ri.Printf( PRINT_ALL, "Failed to detect XF86DGA Mouse\n" );
+			ri.Cvar_Set( "in_dgamouse", "0" );
+		} else {
+			dgamouse = qtrue;
+			XF86DGADirectVideo(dpy, DefaultScreen(dpy), XF86DGADirectMouse);
+			XWarpPointer(dpy, None, win, 0, 0, 0, 0, 0, 0);
+		}
+	} else {
+		XWarpPointer(dpy, None, win,
+					 0, 0, 0, 0,
+					 glConfig.vidWidth / 2, glConfig.vidHeight / 2);
+	}
+
+	XGrabKeyboard(dpy, win,
+				  False,
+				  GrabModeAsync, GrabModeAsync,
+				  CurrentTime);
+
+//	XSync(dpy, True);
+}
+
+static void uninstall_grabs(void)
+{
+	if (dgamouse) {
+		dgamouse = qfalse;
+		XF86DGADirectVideo(dpy, DefaultScreen(dpy), 0);
+	}
+
+	XChangePointerControl(dpy, qtrue, qtrue, mouse_accel_numerator, 
+		mouse_accel_denominator, mouse_threshold);
+
+	XUngrabPointer(dpy, CurrentTime);
+	XUngrabKeyboard(dpy, CurrentTime);
+
+// inviso cursor
+	XUndefineCursor(dpy, win);
+
+//	XAutoRepeatOn(dpy);
+
+//	XSync(dpy, True);
+}
+
+static void HandleEvents(void)
+{
+	int b;
+	int key;
+	XEvent event;
+	qboolean dowarp = qfalse;
+	int mwx = glConfig.vidWidth/2;
+	int mwy = glConfig.vidHeight/2;
+	char *p;
+   
+	if (!dpy)
+		return;
+
+	while (XPending(dpy)) {
+		XNextEvent(dpy, &event);
+		switch(event.type) {
+		case KeyPress:
+			p = XLateKey(&event.xkey, &key);
+			if (key)
+				Sys_QueEvent( 0, SE_KEY, key, qtrue, 0, NULL );
+			while (*p)
+				Sys_QueEvent( 0, SE_CHAR, *p++, 0, 0, NULL );
+			break;
+		case KeyRelease:
+			XLateKey(&event.xkey, &key);
+			
+			Sys_QueEvent( 0, SE_KEY, key, qfalse, 0, NULL );
+			break;
+
+#if 0
+		case KeyPress:
+		case KeyRelease:
+			key = XLateKey(&event.xkey);
+			
+			Sys_QueEvent( 0, SE_KEY, key, event.type == KeyPress, 0, NULL );
+			if (key == K_SHIFT)
+				shift_down = (event.type == KeyPress);
+			if (key < 128 && (event.type == KeyPress)) {
+				if (shift_down)
+					key = keyshift[key];
+				Sys_QueEvent( 0, SE_CHAR, key, 0, 0, NULL );
+			}
+#endif
+			break;
+
+		case MotionNotify:
+			if (mouse_active) {
+				if (dgamouse) {
+					if (abs(event.xmotion.x_root) > 1)
+						mx += event.xmotion.x_root * 2;
+					else
+						mx += event.xmotion.x_root;
+					if (abs(event.xmotion.y_root) > 1)
+						my += event.xmotion.y_root * 2;
+					else
+						my += event.xmotion.y_root;
+//					ri.Printf(PRINT_ALL, "mouse (%d,%d) (root=%d,%d)\n", event.xmotion.x + win_x, event.xmotion.y + win_y, event.xmotion.x_root, event.xmotion.y_root);
+				} 
+				else 
+				{
+//					ri.Printf(PRINT_ALL, "mouse x=%d,y=%d\n", (int)event.xmotion.x - mwx, (int)event.xmotion.y - mwy);
+					mx += ((int)event.xmotion.x - mwx);
+					my += ((int)event.xmotion.y - mwy);
+					mwx = event.xmotion.x;
+					mwy = event.xmotion.y;
+
+					if (mx || my)
+						dowarp = qtrue;
+				}
+			}
+			break;
+
+		case ButtonPress:
+			b=-1;
+			if (event.xbutton.button == 1)
+				b = 0;
+			else if (event.xbutton.button == 2)
+				b = 2;
+			else if (event.xbutton.button == 3)
+				b = 1;
+			Sys_QueEvent( 0, SE_KEY, K_MOUSE1 + b, qtrue, 0, NULL );
+			break;
+
+		case ButtonRelease:
+			b=-1;
+			if (event.xbutton.button == 1)
+				b = 0;
+			else if (event.xbutton.button == 2)
+				b = 2;
+			else if (event.xbutton.button == 3)
+				b = 1;
+			Sys_QueEvent( 0, SE_KEY, K_MOUSE1 + b, qfalse, 0, NULL );
+			break;
+
+		case CreateNotify :
+			win_x = event.xcreatewindow.x;
+			win_y = event.xcreatewindow.y;
+			break;
+
+		case ConfigureNotify :
+			win_x = event.xconfigure.x;
+			win_y = event.xconfigure.y;
+			break;
+		}
+	}
+
+	if (dowarp) {
+		/* move the mouse to the window center again */
+		XWarpPointer(dpy,None,win,0,0,0,0, 
+				(glConfig.vidWidth/2),(glConfig.vidHeight/2));
+	}
+
+}
+
+void KBD_Init(void)
+{
+}
+
+void KBD_Close(void)
+{
+}
+
+void IN_ActivateMouse( void ) 
+{
+	if (!mouse_avail || !dpy || !win)
+		return;
+
+	if (!mouse_active) {
+		mx = my = 0; // don't spazz
+		install_grabs();
+		mouse_active = qtrue;
+	}
+}
+
+void IN_DeactivateMouse( void ) 
+{
+	if (!mouse_avail || !dpy || !win)
+		return;
+
+	if (mouse_active) {
+		uninstall_grabs();
+		mouse_active = qfalse;
+	}
+}
+/*****************************************************************************/
+
+static qboolean signalcaught = qfalse;;
+
+static void signal_handler(int sig)
+{
+	if (signalcaught) {
+		printf("DOUBLE SIGNAL FAULT: Received signal %d, exiting...\n", sig);
+		_exit(1);
+	}
+
+	signalcaught = qtrue;
+	printf("Received signal %d, exiting...\n", sig);
+	GLimp_Shutdown();
+	_exit(1);
+}
+
+static void InitSig(void)
+{
+	signal(SIGHUP, signal_handler);
+	signal(SIGQUIT, signal_handler);
+	signal(SIGILL, signal_handler);
+	signal(SIGTRAP, signal_handler);
+	signal(SIGIOT, signal_handler);
+	signal(SIGBUS, signal_handler);
+	signal(SIGFPE, signal_handler);
+	signal(SIGSEGV, signal_handler);
+	signal(SIGTERM, signal_handler);
+}
+
+/*
+** GLimp_SetGamma
+**
+** This routine should only be called if glConfig.deviceSupportsGamma is TRUE
+*/
+void GLimp_SetGamma( unsigned char red[256], unsigned char green[256], unsigned char blue[256] )
+{
+}
+
+/*
+** GLimp_Shutdown
+**
+** This routine does all OS specific shutdown procedures for the OpenGL
+** subsystem.  Under OpenGL this means NULLing out the current DC and
+** HGLRC, deleting the rendering context, and releasing the DC acquired
+** for the window.  The state structure is also nulled out.
+**
+*/
+void GLimp_Shutdown( void )
+{
+	if (!ctx || !dpy)
+		return;
+	IN_DeactivateMouse();
+	XAutoRepeatOn(dpy);
+	if (dpy) {
+		if (ctx)
+			qglXDestroyContext(dpy, ctx);
+		if (win)
+			XDestroyWindow(dpy, win);
+		if (vidmode_active)
+			XF86VidModeSwitchToMode(dpy, scrnum, vidmodes[0]);
+		XCloseDisplay(dpy);
+	}
+	vidmode_active = qfalse;
+	dpy = NULL;
+	win = 0;
+	ctx = NULL;
+
+	memset( &glConfig, 0, sizeof( glConfig ) );
+	memset( &glState, 0, sizeof( glState ) );
+
+	QGL_Shutdown();
+}
+
+/*
+** GLimp_LogComment
+*/
+void GLimp_LogComment( char *comment ) 
+{
+	if ( glw_state.log_fp ) {
+		fprintf( glw_state.log_fp, "%s", comment );
+	}
+}
+
+/*
+** GLW_StartDriverAndSetMode
+*/
+static qboolean GLW_StartDriverAndSetMode( const char *drivername, 
+										   int mode, 
+										   qboolean fullscreen )
+{
+	rserr_t err;
+
+	// don't ever bother going into fullscreen with a voodoo card
+#if 1	// JDC: I reenabled this
+	if ( strstr( drivername, "Voodoo" ) ) {
+		ri.Cvar_Set( "r_fullscreen", "0" );
+		r_fullscreen->modified = qfalse;
+		fullscreen = qfalse;
+	}
+#endif
+
+	err = GLW_SetMode( drivername, mode, fullscreen );
+
+	switch ( err )
+	{
+	case RSERR_INVALID_FULLSCREEN:
+		ri.Printf( PRINT_ALL, "...WARNING: fullscreen unavailable in this mode\n" );
+		return qfalse;
+	case RSERR_INVALID_MODE:
+		ri.Printf( PRINT_ALL, "...WARNING: could not set the given mode (%d)\n", mode );
+		return qfalse;
+	default:
+		break;
+	}
+	return qtrue;
+}
+
+/*
+** GLW_SetMode
+*/
+int GLW_SetMode( const char *drivername, int mode, qboolean fullscreen )
+{
+	int attrib[] = {
+		GLX_RGBA,					// 0
+		GLX_RED_SIZE, 4,			// 1, 2
+		GLX_GREEN_SIZE, 4,			// 3, 4
+		GLX_BLUE_SIZE, 4,			// 5, 6
+		GLX_DOUBLEBUFFER,			// 7
+		GLX_DEPTH_SIZE, 1,			// 8, 9
+		GLX_STENCIL_SIZE, 1,		// 10, 11
+		None
+	};
+// these match in the array
+#define ATTR_RED_IDX 2
+#define ATTR_GREEN_IDX 4
+#define ATTR_BLUE_IDX 6
+#define ATTR_DEPTH_IDX 9
+#define ATTR_STENCIL_IDX 11
+	Window root;
+	XVisualInfo *visinfo;
+	XSetWindowAttributes attr;
+	unsigned long mask;
+	int colorbits, depthbits, stencilbits;
+	int tcolorbits, tdepthbits, tstencilbits;
+	int MajorVersion, MinorVersion;
+	int actualWidth, actualHeight;
+	int i;
+
+	r_fakeFullscreen = ri.Cvar_Get( "r_fakeFullscreen", "0", CVAR_ARCHIVE);
+
+	ri.Printf( PRINT_ALL, "Initializing OpenGL display\n");
+
+	ri.Printf (PRINT_ALL, "...setting mode %d:", mode );
+
+	if ( !R_GetModeInfo( &glConfig.vidWidth, &glConfig.vidHeight, &glConfig.windowAspect, mode ) )
+	{
+		ri.Printf( PRINT_ALL, " invalid mode\n" );
+		return RSERR_INVALID_MODE;
+	}
+	ri.Printf( PRINT_ALL, " %d %d\n", glConfig.vidWidth, glConfig.vidHeight);
+
+	if (!(dpy = XOpenDisplay(NULL))) {
+		fprintf(stderr, "Error couldn't open the X display\n");
+		return RSERR_INVALID_MODE;
+	}
+
+	scrnum = DefaultScreen(dpy);
+	root = RootWindow(dpy, scrnum);
+
+	actualWidth = glConfig.vidWidth;
+	actualHeight = glConfig.vidHeight;
+
+	// Get video mode list
+	MajorVersion = MinorVersion = 0;
+	if (!XF86VidModeQueryVersion(dpy, &MajorVersion, &MinorVersion)) { 
+		vidmode_ext = qfalse;
+	} else {
+		ri.Printf(PRINT_ALL, "Using XFree86-VidModeExtension Version %d.%d\n",
+			MajorVersion, MinorVersion);
+		vidmode_ext = qtrue;
+	}
+
+	if (vidmode_ext) {
+		int best_fit, best_dist, dist, x, y;
+		
+		XF86VidModeGetAllModeLines(dpy, scrnum, &num_vidmodes, &vidmodes);
+
+		// Are we going fullscreen?  If so, let's change video mode
+		if (fullscreen && !r_fakeFullscreen->integer) {
+			best_dist = 9999999;
+			best_fit = -1;
+
+			for (i = 0; i < num_vidmodes; i++) {
+				if (glConfig.vidWidth > vidmodes[i]->hdisplay ||
+					glConfig.vidHeight > vidmodes[i]->vdisplay)
+					continue;
+
+				x = glConfig.vidWidth - vidmodes[i]->hdisplay;
+				y = glConfig.vidHeight - vidmodes[i]->vdisplay;
+				dist = (x * x) + (y * y);
+				if (dist < best_dist) {
+					best_dist = dist;
+					best_fit = i;
+				}
+			}
+
+			if (best_fit != -1) {
+				actualWidth = vidmodes[best_fit]->hdisplay;
+				actualHeight = vidmodes[best_fit]->vdisplay;
+
+				// change to the mode
+				XF86VidModeSwitchToMode(dpy, scrnum, vidmodes[best_fit]);
+				vidmode_active = qtrue;
+
+				// Move the viewport to top left
+				XF86VidModeSetViewPort(dpy, scrnum, 0, 0);
+			} else
+				fullscreen = 0;
+		}
+	}
+
+
+	if (!r_colorbits->value)
+		colorbits = 24;
+	else
+		colorbits = r_colorbits->value;
+
+	if ( !Q_stricmp( r_glDriver->string, _3DFX_DRIVER_NAME ) )
+		colorbits = 16;
+
+	if (!r_depthbits->value)
+		depthbits = 24;
+	else
+		depthbits = r_depthbits->value;
+	stencilbits = r_stencilbits->value;
+
+	for (i = 0; i < 16; i++) {
+		// 0 - default
+		// 1 - minus colorbits
+		// 2 - minus depthbits
+		// 3 - minus stencil
+		if ((i % 4) == 0 && i) {
+			// one pass, reduce
+			switch (i / 4) {
+			case 2 :
+				if (colorbits == 24)
+					colorbits = 16;
+				break;
+			case 1 :
+				if (depthbits == 24)
+					depthbits = 16;
+				else if (depthbits == 16)
+					depthbits = 8;
+			case 3 :
+				if (stencilbits == 24)
+					stencilbits = 16;
+				else if (stencilbits == 16)
+					stencilbits = 8;
+			}
+		}
+
+		tcolorbits = colorbits;
+		tdepthbits = depthbits;
+		tstencilbits = stencilbits;
+
+		if ((i % 4) == 3) { // reduce colorbits
+			if (tcolorbits == 24)
+				tcolorbits = 16;
+		}	
+
+		if ((i % 4) == 2) { // reduce depthbits
+			if (tdepthbits == 24)
+				tdepthbits = 16;
+			else if (tdepthbits == 16)
+				tdepthbits = 8;
+		}
+
+		if ((i % 4) == 1) { // reduce stencilbits
+			if (tstencilbits == 24)
+				tstencilbits = 16;
+			else if (tstencilbits == 16)
+				tstencilbits = 8;
+			else
+				tstencilbits = 0;
+		}
+
+		if (tcolorbits == 24) {
+			attrib[ATTR_RED_IDX] = 8;
+			attrib[ATTR_GREEN_IDX] = 8;
+			attrib[ATTR_BLUE_IDX] = 8;
+		} else  {
+			// must be 16 bit
+			attrib[ATTR_RED_IDX] = 4;
+			attrib[ATTR_GREEN_IDX] = 4;
+			attrib[ATTR_BLUE_IDX] = 4;
+		}
+
+		attrib[ATTR_DEPTH_IDX] = tdepthbits; // default to 24 depth
+		attrib[ATTR_STENCIL_IDX] = tstencilbits;
+
+#if 0
+		ri.Printf( PRINT_DEVELOPER, "Attempting %d/%d/%d Color bits, %d depth, %d stencil display...", 
+			attrib[ATTR_RED_IDX], attrib[ATTR_GREEN_IDX], attrib[ATTR_BLUE_IDX],
+			attrib[ATTR_DEPTH_IDX], attrib[ATTR_STENCIL_IDX]);
+#endif
+
+		visinfo = qglXChooseVisual(dpy, scrnum, attrib);
+		if (!visinfo) {
+#if 0
+			ri.Printf( PRINT_DEVELOPER, "failed\n");
+#endif
+			continue;
+		}
+
+#if 0
+		ri.Printf( PRINT_DEVELOPER, "Successful\n");
+#endif
+
+		ri.Printf( PRINT_ALL, "Using %d/%d/%d Color bits, %d depth, %d stencil display.\n", 
+			attrib[ATTR_RED_IDX], attrib[ATTR_GREEN_IDX], attrib[ATTR_BLUE_IDX],
+			attrib[ATTR_DEPTH_IDX], attrib[ATTR_STENCIL_IDX]);
+
+		glConfig.colorBits = tcolorbits;
+		glConfig.depthBits = tdepthbits;
+		glConfig.stencilBits = tstencilbits;
+		break;
+	}
+
+	if (!visinfo) {
+		ri.Printf( PRINT_ALL, "Couldn't get a visual\n" );
+		return RSERR_INVALID_MODE;
+	}
+
+	/* window attributes */
+	attr.background_pixel = BlackPixel(dpy, scrnum);
+	attr.border_pixel = 0;
+	attr.colormap = XCreateColormap(dpy, root, visinfo->visual, AllocNone);
+	attr.event_mask = X_MASK;
+	if (vidmode_active) {
+		mask = CWBackPixel | CWColormap | CWSaveUnder | CWBackingStore | 
+			CWEventMask | CWOverrideRedirect;
+		attr.override_redirect = True;
+		attr.backing_store = NotUseful;
+		attr.save_under = False;
+	} else
+		mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask;
+
+	win = XCreateWindow(dpy, root, 0, 0, 
+			actualWidth, actualHeight, 
+			0, visinfo->depth, InputOutput,
+			visinfo->visual, mask, &attr);
+	XMapWindow(dpy, win);
+
+	if (vidmode_active)
+		XMoveWindow(dpy, win, 0, 0);
+
+	// Check for DGA
+	if (in_dgamouse->value) {
+		if (!XF86DGAQueryVersion(dpy, &MajorVersion, &MinorVersion)) { 
+			// unable to query, probalby not supported
+			ri.Printf( PRINT_ALL, "Failed to detect XF86DGA Mouse\n" );
+			ri.Cvar_Set( "in_dgamouse", "0" );
+		} else
+			ri.Printf( PRINT_ALL, "XF86DGA Mouse (Version %d.%d) initialized\n",
+				MajorVersion, MinorVersion);
+	}
+
+	XFlush(dpy);
+
+	ctx = qglXCreateContext(dpy, visinfo, NULL, True);
+
+	qglXMakeCurrent(dpy, win, ctx);
+
+	return RSERR_OK;
+}
+
+/*
+** GLW_InitExtensions
+*/
+static void GLW_InitExtensions( void )
+{
+	// Use modern texture compression extensions
+	if ( strstr( glConfig.extensions_string, "ARB_texture_compression" ) && strstr( glConfig.extensions_string, "EXT_texture_compression_s3tc" ) )
+	{
+		if ( r_ext_compressed_textures->value )
+		{
+			glConfig.textureCompression = TC_S3TC_DXT;
+			ri.Printf( PRINT_ALL, "...using GL_EXT_texture_compression_s3tc\n" );
+		}
+		else
+		{
+			glConfig.textureCompression = TC_NONE;
+			ri.Printf( PRINT_ALL, "...ignoring GL_EXT_texture_compression_s3tc\n" );
+		}
+	}
+	// Or check for old ones
+	else if ( strstr( glConfig.extensions_string, "GL_S3_s3tc" ) )
+	{
+		if ( r_ext_compressed_textures->value )
+		{
+			glConfig.textureCompression = TC_S3TC;
+			ri.Printf( PRINT_ALL, "...using GL_S3_s3tc\n" );
+		}
+		else
+		{
+			glConfig.textureCompression = TC_NONE;
+			ri.Printf( PRINT_ALL, "...ignoring GL_S3_s3tc\n" );
+		}
+	}
+	else
+	{
+		glConfig.textureCompression = TC_NONE;
+		ri.Printf( PRINT_ALL, "...no texture compression found\n" );
+	}
+
+#if 0
+	// WGL_EXT_swap_control
+	if ( strstr( glConfig.extensions_string, "WGL_EXT_swap_control" ) )
+	{
+		qwglSwapIntervalEXT = ( BOOL (WINAPI *)(int)) qwglGetProcAddress( "wglSwapIntervalEXT" );
+		ri.Printf( PRINT_ALL, "...using WGL_EXT_swap_control\n" );
+	}
+	else
+	{
+		ri.Printf( PRINT_ALL, "...WGL_EXT_swap_control not found\n" );
+	}
+#endif
+
+	// GL_ARB_multitexture
+	qglMultiTexCoord2fARB = NULL;
+	qglActiveTextureARB = NULL;
+	qglClientActiveTextureARB = NULL;
+	if ( strstr( glConfig.extensions_string, "GL_ARB_multitexture" ) )
+	{
+		if ( r_ext_multitexture->value )
+		{
+			qglMultiTexCoord2fARB = ( PFNGLMULTITEXCOORD2FARBPROC ) dlsym( glw_state.OpenGLLib, "glMultiTexCoord2fARB" );
+			qglActiveTextureARB = ( PFNGLACTIVETEXTUREARBPROC ) dlsym( glw_state.OpenGLLib, "glActiveTextureARB" );
+			qglClientActiveTextureARB = ( PFNGLCLIENTACTIVETEXTUREARBPROC ) dlsym( glw_state.OpenGLLib, "glClientActiveTextureARB" );
+
+			if ( qglActiveTextureARB )
+			{
+				ri.Printf( PRINT_ALL, "...using GL_ARB_multitexture\n" );
+			}
+			else
+			{
+				ri.Printf( PRINT_ALL, "...blind search for ARB_multitexture failed\n" );
+			}
+		}
+		else
+		{
+			ri.Printf( PRINT_ALL, "...ignoring GL_ARB_multitexture\n" );
+		}
+	}
+	else
+	{
+		ri.Printf( PRINT_ALL, "...GL_ARB_multitexture not found\n" );
+	}
+
+	// GL_EXT_texture_filter_anisotropic
+	glConfig.textureFilterAnisotropicAvailable = qfalse;
+	if ( strstr( glConfig.extensions_string, "EXT_texture_filter_anisotropic" ) )
+	{
+		glConfig.textureFilterAnisotropicAvailable = qtrue;
+		ri.Printf( PRINT_ALL, "...GL_EXT_texture_filter_anisotropic available\n" );
+
+		if ( r_ext_texture_filter_anisotropic->integer )
+		{
+			ri.Printf( PRINT_ALL, "...using GL_EXT_texture_filter_anisotropic\n" );
+		}
+		else
+		{
+			ri.Printf( PRINT_ALL, "...ignoring GL_EXT_texture_filter_anisotropic\n" );
+		}
+		ri.Cvar_Set( "r_ext_texture_filter_anisotropic_avail", "1" );
+	}
+	else
+	{
+		ri.Printf( PRINT_ALL, "...GL_EXT_texture_filter_anisotropic not found\n" );
+		ri.Cvar_Set( "r_ext_texture_filter_anisotropic_avail", "0" );
+	}
+
+	// GL_EXT_compiled_vertex_array
+	if ( strstr( glConfig.extensions_string, "GL_EXT_compiled_vertex_array" ) )
+	{
+		if ( r_ext_compiled_vertex_array->value )
+		{
+			ri.Printf( PRINT_ALL, "...using GL_EXT_compiled_vertex_array\n" );
+			qglLockArraysEXT = ( void ( APIENTRY * )( int, int ) ) dlsym( glw_state.OpenGLLib, "glLockArraysEXT" );
+			qglUnlockArraysEXT = ( void ( APIENTRY * )( void ) ) dlsym( glw_state.OpenGLLib, "glUnlockArraysEXT" );
+			if (!qglLockArraysEXT || !qglUnlockArraysEXT) {
+				ri.Error (ERR_FATAL, "bad getprocaddress");
+			}
+		}
+		else
+		{
+			ri.Printf( PRINT_ALL, "...ignoring GL_EXT_compiled_vertex_array\n" );
+		}
+	}
+	else
+	{
+		ri.Printf( PRINT_ALL, "...GL_EXT_compiled_vertex_array not found\n" );
+	}
+
+}
+
+/*
+** GLW_LoadOpenGL
+**
+** GLimp_win.c internal function that that attempts to load and use 
+** a specific OpenGL DLL.
+*/
+static qboolean GLW_LoadOpenGL( const char *name )
+{
+	qboolean fullscreen;
+
+	ri.Printf( PRINT_ALL, "...loading %s: ", name );
+
+	// disable the 3Dfx splash screen and set gamma
+	// we do this all the time, but it shouldn't hurt anything
+	// on non-3Dfx stuff
+	putenv("FX_GLIDE_NO_SPLASH=0");
+
+	// Mesa VooDoo hacks
+	putenv("MESA_GLX_FX=fullscreen\n");
+
+	// load the QGL layer
+	if ( QGL_Init( name ) ) 
+	{
+		fullscreen = r_fullscreen->integer;
+
+		// create the window and set up the context
+		if ( !GLW_StartDriverAndSetMode( name, r_mode->integer, fullscreen ) )
+		{
+			if (r_mode->integer != 3) {
+				if ( !GLW_StartDriverAndSetMode( name, 3, fullscreen ) ) {
+					goto fail;
+				}
+			} else
+				goto fail;
+		}
+
+		return qtrue;
+	}
+	else
+	{
+		ri.Printf( PRINT_ALL, "failed\n" );
+	}
+fail:
+
+	QGL_Shutdown();
+
+	return qfalse;
+}
+
+/*
+** GLimp_Init
+**
+** This routine is responsible for initializing the OS specific portions
+** of OpenGL.  
+*/
+void GLimp_Init( void )
+{
+	qboolean attemptedlibGL = qfalse;
+	qboolean attempted3Dfx = qfalse;
+	qboolean success = qfalse;
+	char	buf[1024];
+	cvar_t *lastValidRenderer = ri.Cvar_Get( "r_lastValidRenderer", "(uninitialized)", CVAR_ARCHIVE );
+	cvar_t	*cv;
+
+	glConfig.deviceSupportsGamma = qfalse;
+
+	InitSig();
+
+	//
+	// load and initialize the specific OpenGL driver
+	//
+	if ( !GLW_LoadOpenGL( r_glDriver->string ) )
+	{
+		if ( !Q_stricmp( r_glDriver->string, OPENGL_DRIVER_NAME ) )
+		{
+			attemptedlibGL = qtrue;
+		}
+		else if ( !Q_stricmp( r_glDriver->string, _3DFX_DRIVER_NAME ) )
+		{
+			attempted3Dfx = qtrue;
+		}
+
+		if ( !attempted3Dfx && !success )
+		{
+			attempted3Dfx = qtrue;
+			if ( GLW_LoadOpenGL( _3DFX_DRIVER_NAME ) )
+			{
+				ri.Cvar_Set( "r_glDriver", _3DFX_DRIVER_NAME );
+				r_glDriver->modified = qfalse;
+				success = qtrue;
+			}
+		}
+
+		// try ICD before trying 3Dfx standalone driver
+		if ( !attemptedlibGL && !success )
+		{
+			attemptedlibGL = qtrue;
+			if ( GLW_LoadOpenGL( OPENGL_DRIVER_NAME ) )
+			{
+				ri.Cvar_Set( "r_glDriver", OPENGL_DRIVER_NAME );
+				r_glDriver->modified = qfalse;
+				success = qtrue;
+			}
+		} 
+		
+		if (!success)
+			ri.Error( ERR_FATAL, "GLimp_Init() - could not load OpenGL subsystem\n" );
+
+	}
+
+	// get our config strings
+	Q_strncpyz( glConfig.vendor_string, qglGetString (GL_VENDOR), sizeof( glConfig.vendor_string ) );
+	Q_strncpyz( glConfig.renderer_string, qglGetString (GL_RENDERER), sizeof( glConfig.renderer_string ) );
+	if (*glConfig.renderer_string && glConfig.renderer_string[strlen(glConfig.renderer_string) - 1] == '\n')
+		glConfig.renderer_string[strlen(glConfig.renderer_string) - 1] = 0;
+	Q_strncpyz( glConfig.version_string, qglGetString (GL_VERSION), sizeof( glConfig.version_string ) );
+	Q_strncpyz( glConfig.extensions_string, qglGetString (GL_EXTENSIONS), sizeof( glConfig.extensions_string ) );
+
+	//
+	// chipset specific configuration
+	//
+	strcpy( buf, glConfig.renderer_string );
+	strlwr( buf );
+
+	if ( Q_stricmp( lastValidRenderer->string, glConfig.renderer_string ) )
+	{
+		ri.Cvar_Set( "r_picmip", "1" );
+		ri.Cvar_Set( "r_twopartfog", "0" );
+		ri.Cvar_Set( "r_textureMode", "GL_LINEAR_MIPMAP_NEAREST" );
+
+		//
+		// voodoo issues
+		//
+		if ( strstr( buf, "voodoo" ) && !strstr( buf, "banshee" ) )
+		{
+			ri.Cvar_Set( "r_fakeFullscreen", "1");
+		}
+
+		//
+		// Riva128 issues
+		//
+		if ( strstr( buf, "riva 128" ) )
+		{
+			ri.Cvar_Set( "r_twopartfog", "1" );
+		}
+
+		//
+		// Rage Pro issues
+		//
+		if ( strstr( buf, "rage pro" ) )
+		{
+			ri.Cvar_Set( "r_mode", "2" );
+			ri.Cvar_Set( "r_twopartfog", "1" );
+		}
+
+		//
+		// Permedia2 issues
+		//
+		if ( strstr( buf, "permedia2" ) )
+		{
+			ri.Cvar_Set( "r_vertexLight", "1" );
+		}
+
+		//
+		// Riva TNT issues
+		//
+		if ( strstr( buf, "riva tnt " ) )
+		{
+			if ( r_texturebits->integer == 32 ||
+				 ( ( r_texturebits->integer == 0 ) && glConfig.colorBits > 16 ) )
+			{
+				ri.Cvar_Set( "r_picmip", "1" );
+			}
+		}
+
+		ri.Cvar_Set( "r_lastValidRenderer", glConfig.renderer_string );
+	}
+
+	// initialize extensions
+	GLW_InitExtensions();
+
+	InitSig();
+
+	return;
+}
+
+
+/*
+** GLimp_EndFrame
+** 
+** Responsible for doing a swapbuffers and possibly for other stuff
+** as yet to be determined.  Probably better not to make this a GLimp
+** function and instead do a call to GLimp_SwapBuffers.
+*/
+void GLimp_EndFrame (void)
+{
+#if 0
+	int	err;
+
+	if ( !glState.finishCalled )
+		qglFinish();
+
+	// check for errors
+	if ( !gl_ignore_errors->value ) {
+		if ( ( err = qglGetError() ) != GL_NO_ERROR )
+		{
+			ri.Error( ERR_FATAL, "GLimp_EndFrame() - glGetError() failed (0x%x)!\n", err );
+		}
+	}
+#endif
+
+	// don't flip if drawing to front buffer
+	if ( stricmp( r_drawBuffer->string, "GL_FRONT" ) != 0 )
+	{
+		qglXSwapBuffers(dpy, win);
+	}
+
+	// check logging
+	QGL_EnableLogging( r_logFile->value );
+
+#if 0
+	GLimp_LogComment( "*** RE_EndFrame ***\n" );
+
+	// decrement log
+	if ( gl_log->value )
+	{
+		ri.Cvar_Set( "gl_log", va("%i",gl_log->value - 1 ) );
+	}
+#endif
+}
+
+/*
+===========================================================
+
+SMP acceleration
+
+===========================================================
+*/
+
+sem_t	renderCommandsEvent;
+sem_t	renderCompletedEvent;
+sem_t	renderActiveEvent;
+
+void (*glimpRenderThread)( void );
+
+void GLimp_RenderThreadWrapper( void *stub ) {
+	glimpRenderThread();
+
+#if 0
+	// unbind the context before we die
+	qglXMakeCurrent(dpy, None, NULL);
+#endif
+}
+
+
+/*
+=======================
+GLimp_SpawnRenderThread
+=======================
+*/
+pthread_t	renderThreadHandle;
+qboolean GLimp_SpawnRenderThread( void (*function)( void ) ) {
+
+	sem_init( &renderCommandsEvent, 0, 0 );
+	sem_init( &renderCompletedEvent, 0, 0 );
+	sem_init( &renderActiveEvent, 0, 0 );
+
+	glimpRenderThread = function;
+
+	if (pthread_create( &renderThreadHandle, NULL,
+		GLimp_RenderThreadWrapper, NULL)) {
+		return qfalse;
+	}
+
+	return qtrue;
+}
+
+static	void	*smpData;
+static	int		glXErrors;
+
+void *GLimp_RendererSleep( void ) {
+	void	*data;
+
+#if 0
+	if ( !qglXMakeCurrent(dpy, None, NULL) ) {
+		glXErrors++;
+	}
+#endif
+
+//	ResetEvent( renderActiveEvent );
+
+	// after this, the front end can exit GLimp_FrontEndSleep
+	sem_post ( &renderCompletedEvent );
+
+	sem_wait ( &renderCommandsEvent );
+
+#if 0
+	if ( !qglXMakeCurrent(dpy, win, ctx) ) {
+		glXErrors++;
+	}
+#endif
+
+//	ResetEvent( renderCompletedEvent );
+//	ResetEvent( renderCommandsEvent );
+
+	data = smpData;
+
+	// after this, the main thread can exit GLimp_WakeRenderer
+	sem_post ( &renderActiveEvent );
+
+	return data;
+}
+
+
+void GLimp_FrontEndSleep( void ) {
+	sem_wait ( &renderCompletedEvent );
+
+#if 0
+	if ( !qglXMakeCurrent(dpy, win, ctx) ) {
+		glXErrors++;
+	}
+#endif
+}
+
+
+void GLimp_WakeRenderer( void *data ) {
+	smpData = data;
+
+#if 0
+	if ( !qglXMakeCurrent(dpy, None, NULL) ) {
+		glXErrors++;
+	}
+#endif
+
+	// after this, the renderer can continue through GLimp_RendererSleep
+	sem_post( &renderCommandsEvent );
+
+	sem_wait( &renderActiveEvent );
+}
+
+/*===========================================================*/
+
+/*****************************************************************************/
+/* MOUSE                                                                     */
+/*****************************************************************************/
+
+void IN_Init(void)
+{
+	// mouse variables
+    in_mouse = Cvar_Get ("in_mouse", "1", CVAR_ARCHIVE);
+    in_dgamouse = Cvar_Get ("in_dgamouse", "1", CVAR_ARCHIVE);
+
+	if (in_mouse->value)
+		mouse_avail = qtrue;
+	else
+		mouse_avail = qfalse;
+}
+
+void IN_Shutdown(void)
+{
+	mouse_avail = qfalse;
+}
+
+void IN_MouseMove(void)
+{
+	if (!mouse_avail || !dpy || !win)
+		return;
+
+#if 0
+	if (!dgamouse) {
+		Window root, child;
+		int root_x, root_y;
+		int win_x, win_y;
+		unsigned int mask_return;
+		int mwx = glConfig.vidWidth/2;
+		int mwy = glConfig.vidHeight/2;
+
+		XQueryPointer(dpy, win, &root, &child, 
+			&root_x, &root_y, &win_x, &win_y, &mask_return);
+
+		mx = win_x - mwx;
+		my = win_y - mwy;
+
+		XWarpPointer(dpy,None,win,0,0,0,0, mwx, mwy);
+	}
+#endif
+
+	if (mx || my)
+		Sys_QueEvent( 0, SE_MOUSE, mx, my, 0, NULL );
+	mx = my = 0;
+}
+
+void IN_Frame (void)
+{
+	if ( cls.keyCatchers || cls.state != CA_ACTIVE ) {
+		// temporarily deactivate if not in the game and
+		// running on the desktop
+		// voodoo always counts as full screen
+		if (Cvar_VariableValue ("r_fullscreen") == 0
+			&& strcmp( Cvar_VariableString("r_glDriver"), _3DFX_DRIVER_NAME ) )	{
+			IN_DeactivateMouse ();
+			return;
+		}
+		if (dpy && !autorepeaton) {
+			XAutoRepeatOn(dpy);
+			autorepeaton = qtrue;
+		}
+	} else if (dpy && autorepeaton) {
+		XAutoRepeatOff(dpy);
+		autorepeaton = qfalse;
+	}
+
+	IN_ActivateMouse();
+
+	// post events to the system que
+	IN_MouseMove();
+}
+
+void IN_Activate(void)
+{
+}
+
+void Sys_SendKeyEvents (void)
+{
+	XEvent event;
+
+	if (!dpy)
+		return;
+
+	HandleEvents();
+//	while (XCheckMaskEvent(dpy,KEY_MASK|MOUSE_MASK,&event))
+//		HandleEvent(&event);
+}
+
diff --git a/code/unix/linux_qgl.c b/code/unix/linux_qgl.c
new file mode 100644
index 0000000..3dac0a7
--- /dev/null
+++ b/code/unix/linux_qgl.c
@@ -0,0 +1,4111 @@
+/*
+** LINUX_QGL.C
+**
+** This file implements the operating system binding of GL to QGL function
+** pointers.  When doing a port of Quake2 you must implement the following
+** two functions:
+**
+** QGL_Init() - loads libraries, assigns function pointers, etc.
+** QGL_Shutdown() - unloads libraries, NULLs function pointers
+*/
+#include <float.h>
+#include "../renderer/tr_local.h"
+#include "unix_glw.h"
+
+#include <GL/fxmesa.h>
+#include <GL/glx.h>
+
+#include <dlfcn.h>
+
+//FX Mesa Functions
+fxMesaContext (*qfxMesaCreateContext)(GLuint win, GrScreenResolution_t, GrScreenRefresh_t, const GLint attribList[]);
+fxMesaContext (*qfxMesaCreateBestContext)(GLuint win, GLint width, GLint height, const GLint attribList[]);
+void (*qfxMesaDestroyContext)(fxMesaContext ctx);
+void (*qfxMesaMakeCurrent)(fxMesaContext ctx);
+fxMesaContext (*qfxMesaGetCurrentContext)(void);
+void (*qfxMesaSwapBuffers)(void);
+
+//GLX Functions
+XVisualInfo * (*qglXChooseVisual)( Display *dpy, int screen, int *attribList );
+GLXContext (*qglXCreateContext)( Display *dpy, XVisualInfo *vis, GLXContext shareList, Bool direct );
+void (*qglXDestroyContext)( Display *dpy, GLXContext ctx );
+Bool (*qglXMakeCurrent)( Display *dpy, GLXDrawable drawable, GLXContext ctx);
+void (*qglXCopyContext)( Display *dpy, GLXContext src, GLXContext dst, GLuint mask );
+void (*qglXSwapBuffers)( Display *dpy, GLXDrawable drawable );
+
+void ( APIENTRY * qglAccum )(GLenum op, GLfloat value);
+void ( APIENTRY * qglAlphaFunc )(GLenum func, GLclampf ref);
+GLboolean ( APIENTRY * qglAreTexturesResident )(GLsizei n, const GLuint *textures, GLboolean *residences);
+void ( APIENTRY * qglArrayElement )(GLint i);
+void ( APIENTRY * qglBegin )(GLenum mode);
+void ( APIENTRY * qglBindTexture )(GLenum target, GLuint texture);
+void ( APIENTRY * qglBitmap )(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap);
+void ( APIENTRY * qglBlendFunc )(GLenum sfactor, GLenum dfactor);
+void ( APIENTRY * qglCallList )(GLuint list);
+void ( APIENTRY * qglCallLists )(GLsizei n, GLenum type, const GLvoid *lists);
+void ( APIENTRY * qglClear )(GLbitfield mask);
+void ( APIENTRY * qglClearAccum )(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
+void ( APIENTRY * qglClearColor )(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
+void ( APIENTRY * qglClearDepth )(GLclampd depth);
+void ( APIENTRY * qglClearIndex )(GLfloat c);
+void ( APIENTRY * qglClearStencil )(GLint s);
+void ( APIENTRY * qglClipPlane )(GLenum plane, const GLdouble *equation);
+void ( APIENTRY * qglColor3b )(GLbyte red, GLbyte green, GLbyte blue);
+void ( APIENTRY * qglColor3bv )(const GLbyte *v);
+void ( APIENTRY * qglColor3d )(GLdouble red, GLdouble green, GLdouble blue);
+void ( APIENTRY * qglColor3dv )(const GLdouble *v);
+void ( APIENTRY * qglColor3f )(GLfloat red, GLfloat green, GLfloat blue);
+void ( APIENTRY * qglColor3fv )(const GLfloat *v);
+void ( APIENTRY * qglColor3i )(GLint red, GLint green, GLint blue);
+void ( APIENTRY * qglColor3iv )(const GLint *v);
+void ( APIENTRY * qglColor3s )(GLshort red, GLshort green, GLshort blue);
+void ( APIENTRY * qglColor3sv )(const GLshort *v);
+void ( APIENTRY * qglColor3ub )(GLubyte red, GLubyte green, GLubyte blue);
+void ( APIENTRY * qglColor3ubv )(const GLubyte *v);
+void ( APIENTRY * qglColor3ui )(GLuint red, GLuint green, GLuint blue);
+void ( APIENTRY * qglColor3uiv )(const GLuint *v);
+void ( APIENTRY * qglColor3us )(GLushort red, GLushort green, GLushort blue);
+void ( APIENTRY * qglColor3usv )(const GLushort *v);
+void ( APIENTRY * qglColor4b )(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha);
+void ( APIENTRY * qglColor4bv )(const GLbyte *v);
+void ( APIENTRY * qglColor4d )(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha);
+void ( APIENTRY * qglColor4dv )(const GLdouble *v);
+void ( APIENTRY * qglColor4f )(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
+void ( APIENTRY * qglColor4fv )(const GLfloat *v);
+void ( APIENTRY * qglColor4i )(GLint red, GLint green, GLint blue, GLint alpha);
+void ( APIENTRY * qglColor4iv )(const GLint *v);
+void ( APIENTRY * qglColor4s )(GLshort red, GLshort green, GLshort blue, GLshort alpha);
+void ( APIENTRY * qglColor4sv )(const GLshort *v);
+void ( APIENTRY * qglColor4ub )(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha);
+void ( APIENTRY * qglColor4ubv )(const GLubyte *v);
+void ( APIENTRY * qglColor4ui )(GLuint red, GLuint green, GLuint blue, GLuint alpha);
+void ( APIENTRY * qglColor4uiv )(const GLuint *v);
+void ( APIENTRY * qglColor4us )(GLushort red, GLushort green, GLushort blue, GLushort alpha);
+void ( APIENTRY * qglColor4usv )(const GLushort *v);
+void ( APIENTRY * qglColorMask )(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
+void ( APIENTRY * qglColorMaterial )(GLenum face, GLenum mode);
+void ( APIENTRY * qglColorPointer )(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
+void ( APIENTRY * qglCopyPixels )(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type);
+void ( APIENTRY * qglCopyTexImage1D )(GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border);
+void ( APIENTRY * qglCopyTexImage2D )(GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
+void ( APIENTRY * qglCopyTexSubImage1D )(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);
+void ( APIENTRY * qglCopyTexSubImage2D )(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
+void ( APIENTRY * qglCullFace )(GLenum mode);
+void ( APIENTRY * qglDeleteLists )(GLuint list, GLsizei range);
+void ( APIENTRY * qglDeleteTextures )(GLsizei n, const GLuint *textures);
+void ( APIENTRY * qglDepthFunc )(GLenum func);
+void ( APIENTRY * qglDepthMask )(GLboolean flag);
+void ( APIENTRY * qglDepthRange )(GLclampd zNear, GLclampd zFar);
+void ( APIENTRY * qglDisable )(GLenum cap);
+void ( APIENTRY * qglDisableClientState )(GLenum array);
+void ( APIENTRY * qglDrawArrays )(GLenum mode, GLint first, GLsizei count);
+void ( APIENTRY * qglDrawBuffer )(GLenum mode);
+void ( APIENTRY * qglDrawElements )(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices);
+void ( APIENTRY * qglDrawPixels )(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
+void ( APIENTRY * qglEdgeFlag )(GLboolean flag);
+void ( APIENTRY * qglEdgeFlagPointer )(GLsizei stride, const GLvoid *pointer);
+void ( APIENTRY * qglEdgeFlagv )(const GLboolean *flag);
+void ( APIENTRY * qglEnable )(GLenum cap);
+void ( APIENTRY * qglEnableClientState )(GLenum array);
+void ( APIENTRY * qglEnd )(void);
+void ( APIENTRY * qglEndList )(void);
+void ( APIENTRY * qglEvalCoord1d )(GLdouble u);
+void ( APIENTRY * qglEvalCoord1dv )(const GLdouble *u);
+void ( APIENTRY * qglEvalCoord1f )(GLfloat u);
+void ( APIENTRY * qglEvalCoord1fv )(const GLfloat *u);
+void ( APIENTRY * qglEvalCoord2d )(GLdouble u, GLdouble v);
+void ( APIENTRY * qglEvalCoord2dv )(const GLdouble *u);
+void ( APIENTRY * qglEvalCoord2f )(GLfloat u, GLfloat v);
+void ( APIENTRY * qglEvalCoord2fv )(const GLfloat *u);
+void ( APIENTRY * qglEvalMesh1 )(GLenum mode, GLint i1, GLint i2);
+void ( APIENTRY * qglEvalMesh2 )(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2);
+void ( APIENTRY * qglEvalPoint1 )(GLint i);
+void ( APIENTRY * qglEvalPoint2 )(GLint i, GLint j);
+void ( APIENTRY * qglFeedbackBuffer )(GLsizei size, GLenum type, GLfloat *buffer);
+void ( APIENTRY * qglFinish )(void);
+void ( APIENTRY * qglFlush )(void);
+void ( APIENTRY * qglFogf )(GLenum pname, GLfloat param);
+void ( APIENTRY * qglFogfv )(GLenum pname, const GLfloat *params);
+void ( APIENTRY * qglFogi )(GLenum pname, GLint param);
+void ( APIENTRY * qglFogiv )(GLenum pname, const GLint *params);
+void ( APIENTRY * qglFrontFace )(GLenum mode);
+void ( APIENTRY * qglFrustum )(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
+GLuint ( APIENTRY * qglGenLists )(GLsizei range);
+void ( APIENTRY * qglGenTextures )(GLsizei n, GLuint *textures);
+void ( APIENTRY * qglGetBooleanv )(GLenum pname, GLboolean *params);
+void ( APIENTRY * qglGetClipPlane )(GLenum plane, GLdouble *equation);
+void ( APIENTRY * qglGetDoublev )(GLenum pname, GLdouble *params);
+GLenum ( APIENTRY * qglGetError )(void);
+void ( APIENTRY * qglGetFloatv )(GLenum pname, GLfloat *params);
+void ( APIENTRY * qglGetIntegerv )(GLenum pname, GLint *params);
+void ( APIENTRY * qglGetLightfv )(GLenum light, GLenum pname, GLfloat *params);
+void ( APIENTRY * qglGetLightiv )(GLenum light, GLenum pname, GLint *params);
+void ( APIENTRY * qglGetMapdv )(GLenum target, GLenum query, GLdouble *v);
+void ( APIENTRY * qglGetMapfv )(GLenum target, GLenum query, GLfloat *v);
+void ( APIENTRY * qglGetMapiv )(GLenum target, GLenum query, GLint *v);
+void ( APIENTRY * qglGetMaterialfv )(GLenum face, GLenum pname, GLfloat *params);
+void ( APIENTRY * qglGetMaterialiv )(GLenum face, GLenum pname, GLint *params);
+void ( APIENTRY * qglGetPixelMapfv )(GLenum map, GLfloat *values);
+void ( APIENTRY * qglGetPixelMapuiv )(GLenum map, GLuint *values);
+void ( APIENTRY * qglGetPixelMapusv )(GLenum map, GLushort *values);
+void ( APIENTRY * qglGetPointerv )(GLenum pname, GLvoid* *params);
+void ( APIENTRY * qglGetPolygonStipple )(GLubyte *mask);
+const GLubyte * ( APIENTRY * qglGetString )(GLenum name);
+void ( APIENTRY * qglGetTexEnvfv )(GLenum target, GLenum pname, GLfloat *params);
+void ( APIENTRY * qglGetTexEnviv )(GLenum target, GLenum pname, GLint *params);
+void ( APIENTRY * qglGetTexGendv )(GLenum coord, GLenum pname, GLdouble *params);
+void ( APIENTRY * qglGetTexGenfv )(GLenum coord, GLenum pname, GLfloat *params);
+void ( APIENTRY * qglGetTexGeniv )(GLenum coord, GLenum pname, GLint *params);
+void ( APIENTRY * qglGetTexImage )(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels);
+void ( APIENTRY * qglGetTexLevelParameterfv )(GLenum target, GLint level, GLenum pname, GLfloat *params);
+void ( APIENTRY * qglGetTexLevelParameteriv )(GLenum target, GLint level, GLenum pname, GLint *params);
+void ( APIENTRY * qglGetTexParameterfv )(GLenum target, GLenum pname, GLfloat *params);
+void ( APIENTRY * qglGetTexParameteriv )(GLenum target, GLenum pname, GLint *params);
+void ( APIENTRY * qglHint )(GLenum target, GLenum mode);
+void ( APIENTRY * qglIndexMask )(GLuint mask);
+void ( APIENTRY * qglIndexPointer )(GLenum type, GLsizei stride, const GLvoid *pointer);
+void ( APIENTRY * qglIndexd )(GLdouble c);
+void ( APIENTRY * qglIndexdv )(const GLdouble *c);
+void ( APIENTRY * qglIndexf )(GLfloat c);
+void ( APIENTRY * qglIndexfv )(const GLfloat *c);
+void ( APIENTRY * qglIndexi )(GLint c);
+void ( APIENTRY * qglIndexiv )(const GLint *c);
+void ( APIENTRY * qglIndexs )(GLshort c);
+void ( APIENTRY * qglIndexsv )(const GLshort *c);
+void ( APIENTRY * qglIndexub )(GLubyte c);
+void ( APIENTRY * qglIndexubv )(const GLubyte *c);
+void ( APIENTRY * qglInitNames )(void);
+void ( APIENTRY * qglInterleavedArrays )(GLenum format, GLsizei stride, const GLvoid *pointer);
+GLboolean ( APIENTRY * qglIsEnabled )(GLenum cap);
+GLboolean ( APIENTRY * qglIsList )(GLuint list);
+GLboolean ( APIENTRY * qglIsTexture )(GLuint texture);
+void ( APIENTRY * qglLightModelf )(GLenum pname, GLfloat param);
+void ( APIENTRY * qglLightModelfv )(GLenum pname, const GLfloat *params);
+void ( APIENTRY * qglLightModeli )(GLenum pname, GLint param);
+void ( APIENTRY * qglLightModeliv )(GLenum pname, const GLint *params);
+void ( APIENTRY * qglLightf )(GLenum light, GLenum pname, GLfloat param);
+void ( APIENTRY * qglLightfv )(GLenum light, GLenum pname, const GLfloat *params);
+void ( APIENTRY * qglLighti )(GLenum light, GLenum pname, GLint param);
+void ( APIENTRY * qglLightiv )(GLenum light, GLenum pname, const GLint *params);
+void ( APIENTRY * qglLineStipple )(GLint factor, GLushort pattern);
+void ( APIENTRY * qglLineWidth )(GLfloat width);
+void ( APIENTRY * qglListBase )(GLuint base);
+void ( APIENTRY * qglLoadIdentity )(void);
+void ( APIENTRY * qglLoadMatrixd )(const GLdouble *m);
+void ( APIENTRY * qglLoadMatrixf )(const GLfloat *m);
+void ( APIENTRY * qglLoadName )(GLuint name);
+void ( APIENTRY * qglLogicOp )(GLenum opcode);
+void ( APIENTRY * qglMap1d )(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points);
+void ( APIENTRY * qglMap1f )(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points);
+void ( APIENTRY * qglMap2d )(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points);
+void ( APIENTRY * qglMap2f )(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points);
+void ( APIENTRY * qglMapGrid1d )(GLint un, GLdouble u1, GLdouble u2);
+void ( APIENTRY * qglMapGrid1f )(GLint un, GLfloat u1, GLfloat u2);
+void ( APIENTRY * qglMapGrid2d )(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2);
+void ( APIENTRY * qglMapGrid2f )(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2);
+void ( APIENTRY * qglMaterialf )(GLenum face, GLenum pname, GLfloat param);
+void ( APIENTRY * qglMaterialfv )(GLenum face, GLenum pname, const GLfloat *params);
+void ( APIENTRY * qglMateriali )(GLenum face, GLenum pname, GLint param);
+void ( APIENTRY * qglMaterialiv )(GLenum face, GLenum pname, const GLint *params);
+void ( APIENTRY * qglMatrixMode )(GLenum mode);
+void ( APIENTRY * qglMultMatrixd )(const GLdouble *m);
+void ( APIENTRY * qglMultMatrixf )(const GLfloat *m);
+void ( APIENTRY * qglNewList )(GLuint list, GLenum mode);
+void ( APIENTRY * qglNormal3b )(GLbyte nx, GLbyte ny, GLbyte nz);
+void ( APIENTRY * qglNormal3bv )(const GLbyte *v);
+void ( APIENTRY * qglNormal3d )(GLdouble nx, GLdouble ny, GLdouble nz);
+void ( APIENTRY * qglNormal3dv )(const GLdouble *v);
+void ( APIENTRY * qglNormal3f )(GLfloat nx, GLfloat ny, GLfloat nz);
+void ( APIENTRY * qglNormal3fv )(const GLfloat *v);
+void ( APIENTRY * qglNormal3i )(GLint nx, GLint ny, GLint nz);
+void ( APIENTRY * qglNormal3iv )(const GLint *v);
+void ( APIENTRY * qglNormal3s )(GLshort nx, GLshort ny, GLshort nz);
+void ( APIENTRY * qglNormal3sv )(const GLshort *v);
+void ( APIENTRY * qglNormalPointer )(GLenum type, GLsizei stride, const GLvoid *pointer);
+void ( APIENTRY * qglOrtho )(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
+void ( APIENTRY * qglPassThrough )(GLfloat token);
+void ( APIENTRY * qglPixelMapfv )(GLenum map, GLsizei mapsize, const GLfloat *values);
+void ( APIENTRY * qglPixelMapuiv )(GLenum map, GLsizei mapsize, const GLuint *values);
+void ( APIENTRY * qglPixelMapusv )(GLenum map, GLsizei mapsize, const GLushort *values);
+void ( APIENTRY * qglPixelStoref )(GLenum pname, GLfloat param);
+void ( APIENTRY * qglPixelStorei )(GLenum pname, GLint param);
+void ( APIENTRY * qglPixelTransferf )(GLenum pname, GLfloat param);
+void ( APIENTRY * qglPixelTransferi )(GLenum pname, GLint param);
+void ( APIENTRY * qglPixelZoom )(GLfloat xfactor, GLfloat yfactor);
+void ( APIENTRY * qglPointSize )(GLfloat size);
+void ( APIENTRY * qglPolygonMode )(GLenum face, GLenum mode);
+void ( APIENTRY * qglPolygonOffset )(GLfloat factor, GLfloat units);
+void ( APIENTRY * qglPolygonStipple )(const GLubyte *mask);
+void ( APIENTRY * qglPopAttrib )(void);
+void ( APIENTRY * qglPopClientAttrib )(void);
+void ( APIENTRY * qglPopMatrix )(void);
+void ( APIENTRY * qglPopName )(void);
+void ( APIENTRY * qglPrioritizeTextures )(GLsizei n, const GLuint *textures, const GLclampf *priorities);
+void ( APIENTRY * qglPushAttrib )(GLbitfield mask);
+void ( APIENTRY * qglPushClientAttrib )(GLbitfield mask);
+void ( APIENTRY * qglPushMatrix )(void);
+void ( APIENTRY * qglPushName )(GLuint name);
+void ( APIENTRY * qglRasterPos2d )(GLdouble x, GLdouble y);
+void ( APIENTRY * qglRasterPos2dv )(const GLdouble *v);
+void ( APIENTRY * qglRasterPos2f )(GLfloat x, GLfloat y);
+void ( APIENTRY * qglRasterPos2fv )(const GLfloat *v);
+void ( APIENTRY * qglRasterPos2i )(GLint x, GLint y);
+void ( APIENTRY * qglRasterPos2iv )(const GLint *v);
+void ( APIENTRY * qglRasterPos2s )(GLshort x, GLshort y);
+void ( APIENTRY * qglRasterPos2sv )(const GLshort *v);
+void ( APIENTRY * qglRasterPos3d )(GLdouble x, GLdouble y, GLdouble z);
+void ( APIENTRY * qglRasterPos3dv )(const GLdouble *v);
+void ( APIENTRY * qglRasterPos3f )(GLfloat x, GLfloat y, GLfloat z);
+void ( APIENTRY * qglRasterPos3fv )(const GLfloat *v);
+void ( APIENTRY * qglRasterPos3i )(GLint x, GLint y, GLint z);
+void ( APIENTRY * qglRasterPos3iv )(const GLint *v);
+void ( APIENTRY * qglRasterPos3s )(GLshort x, GLshort y, GLshort z);
+void ( APIENTRY * qglRasterPos3sv )(const GLshort *v);
+void ( APIENTRY * qglRasterPos4d )(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+void ( APIENTRY * qglRasterPos4dv )(const GLdouble *v);
+void ( APIENTRY * qglRasterPos4f )(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+void ( APIENTRY * qglRasterPos4fv )(const GLfloat *v);
+void ( APIENTRY * qglRasterPos4i )(GLint x, GLint y, GLint z, GLint w);
+void ( APIENTRY * qglRasterPos4iv )(const GLint *v);
+void ( APIENTRY * qglRasterPos4s )(GLshort x, GLshort y, GLshort z, GLshort w);
+void ( APIENTRY * qglRasterPos4sv )(const GLshort *v);
+void ( APIENTRY * qglReadBuffer )(GLenum mode);
+void ( APIENTRY * qglReadPixels )(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels);
+void ( APIENTRY * qglRectd )(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2);
+void ( APIENTRY * qglRectdv )(const GLdouble *v1, const GLdouble *v2);
+void ( APIENTRY * qglRectf )(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2);
+void ( APIENTRY * qglRectfv )(const GLfloat *v1, const GLfloat *v2);
+void ( APIENTRY * qglRecti )(GLint x1, GLint y1, GLint x2, GLint y2);
+void ( APIENTRY * qglRectiv )(const GLint *v1, const GLint *v2);
+void ( APIENTRY * qglRects )(GLshort x1, GLshort y1, GLshort x2, GLshort y2);
+void ( APIENTRY * qglRectsv )(const GLshort *v1, const GLshort *v2);
+GLint ( APIENTRY * qglRenderMode )(GLenum mode);
+void ( APIENTRY * qglRotated )(GLdouble angle, GLdouble x, GLdouble y, GLdouble z);
+void ( APIENTRY * qglRotatef )(GLfloat angle, GLfloat x, GLfloat y, GLfloat z);
+void ( APIENTRY * qglScaled )(GLdouble x, GLdouble y, GLdouble z);
+void ( APIENTRY * qglScalef )(GLfloat x, GLfloat y, GLfloat z);
+void ( APIENTRY * qglScissor )(GLint x, GLint y, GLsizei width, GLsizei height);
+void ( APIENTRY * qglSelectBuffer )(GLsizei size, GLuint *buffer);
+void ( APIENTRY * qglShadeModel )(GLenum mode);
+void ( APIENTRY * qglStencilFunc )(GLenum func, GLint ref, GLuint mask);
+void ( APIENTRY * qglStencilMask )(GLuint mask);
+void ( APIENTRY * qglStencilOp )(GLenum fail, GLenum zfail, GLenum zpass);
+void ( APIENTRY * qglTexCoord1d )(GLdouble s);
+void ( APIENTRY * qglTexCoord1dv )(const GLdouble *v);
+void ( APIENTRY * qglTexCoord1f )(GLfloat s);
+void ( APIENTRY * qglTexCoord1fv )(const GLfloat *v);
+void ( APIENTRY * qglTexCoord1i )(GLint s);
+void ( APIENTRY * qglTexCoord1iv )(const GLint *v);
+void ( APIENTRY * qglTexCoord1s )(GLshort s);
+void ( APIENTRY * qglTexCoord1sv )(const GLshort *v);
+void ( APIENTRY * qglTexCoord2d )(GLdouble s, GLdouble t);
+void ( APIENTRY * qglTexCoord2dv )(const GLdouble *v);
+void ( APIENTRY * qglTexCoord2f )(GLfloat s, GLfloat t);
+void ( APIENTRY * qglTexCoord2fv )(const GLfloat *v);
+void ( APIENTRY * qglTexCoord2i )(GLint s, GLint t);
+void ( APIENTRY * qglTexCoord2iv )(const GLint *v);
+void ( APIENTRY * qglTexCoord2s )(GLshort s, GLshort t);
+void ( APIENTRY * qglTexCoord2sv )(const GLshort *v);
+void ( APIENTRY * qglTexCoord3d )(GLdouble s, GLdouble t, GLdouble r);
+void ( APIENTRY * qglTexCoord3dv )(const GLdouble *v);
+void ( APIENTRY * qglTexCoord3f )(GLfloat s, GLfloat t, GLfloat r);
+void ( APIENTRY * qglTexCoord3fv )(const GLfloat *v);
+void ( APIENTRY * qglTexCoord3i )(GLint s, GLint t, GLint r);
+void ( APIENTRY * qglTexCoord3iv )(const GLint *v);
+void ( APIENTRY * qglTexCoord3s )(GLshort s, GLshort t, GLshort r);
+void ( APIENTRY * qglTexCoord3sv )(const GLshort *v);
+void ( APIENTRY * qglTexCoord4d )(GLdouble s, GLdouble t, GLdouble r, GLdouble q);
+void ( APIENTRY * qglTexCoord4dv )(const GLdouble *v);
+void ( APIENTRY * qglTexCoord4f )(GLfloat s, GLfloat t, GLfloat r, GLfloat q);
+void ( APIENTRY * qglTexCoord4fv )(const GLfloat *v);
+void ( APIENTRY * qglTexCoord4i )(GLint s, GLint t, GLint r, GLint q);
+void ( APIENTRY * qglTexCoord4iv )(const GLint *v);
+void ( APIENTRY * qglTexCoord4s )(GLshort s, GLshort t, GLshort r, GLshort q);
+void ( APIENTRY * qglTexCoord4sv )(const GLshort *v);
+void ( APIENTRY * qglTexCoordPointer )(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
+void ( APIENTRY * qglTexEnvf )(GLenum target, GLenum pname, GLfloat param);
+void ( APIENTRY * qglTexEnvfv )(GLenum target, GLenum pname, const GLfloat *params);
+void ( APIENTRY * qglTexEnvi )(GLenum target, GLenum pname, GLint param);
+void ( APIENTRY * qglTexEnviv )(GLenum target, GLenum pname, const GLint *params);
+void ( APIENTRY * qglTexGend )(GLenum coord, GLenum pname, GLdouble param);
+void ( APIENTRY * qglTexGendv )(GLenum coord, GLenum pname, const GLdouble *params);
+void ( APIENTRY * qglTexGenf )(GLenum coord, GLenum pname, GLfloat param);
+void ( APIENTRY * qglTexGenfv )(GLenum coord, GLenum pname, const GLfloat *params);
+void ( APIENTRY * qglTexGeni )(GLenum coord, GLenum pname, GLint param);
+void ( APIENTRY * qglTexGeniv )(GLenum coord, GLenum pname, const GLint *params);
+void ( APIENTRY * qglTexImage1D )(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
+void ( APIENTRY * qglTexImage2D )(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
+void ( APIENTRY * qglTexParameterf )(GLenum target, GLenum pname, GLfloat param);
+void ( APIENTRY * qglTexParameterfv )(GLenum target, GLenum pname, const GLfloat *params);
+void ( APIENTRY * qglTexParameteri )(GLenum target, GLenum pname, GLint param);
+void ( APIENTRY * qglTexParameteriv )(GLenum target, GLenum pname, const GLint *params);
+void ( APIENTRY * qglTexSubImage1D )(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels);
+void ( APIENTRY * qglTexSubImage2D )(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
+void ( APIENTRY * qglTranslated )(GLdouble x, GLdouble y, GLdouble z);
+void ( APIENTRY * qglTranslatef )(GLfloat x, GLfloat y, GLfloat z);
+void ( APIENTRY * qglVertex2d )(GLdouble x, GLdouble y);
+void ( APIENTRY * qglVertex2dv )(const GLdouble *v);
+void ( APIENTRY * qglVertex2f )(GLfloat x, GLfloat y);
+void ( APIENTRY * qglVertex2fv )(const GLfloat *v);
+void ( APIENTRY * qglVertex2i )(GLint x, GLint y);
+void ( APIENTRY * qglVertex2iv )(const GLint *v);
+void ( APIENTRY * qglVertex2s )(GLshort x, GLshort y);
+void ( APIENTRY * qglVertex2sv )(const GLshort *v);
+void ( APIENTRY * qglVertex3d )(GLdouble x, GLdouble y, GLdouble z);
+void ( APIENTRY * qglVertex3dv )(const GLdouble *v);
+void ( APIENTRY * qglVertex3f )(GLfloat x, GLfloat y, GLfloat z);
+void ( APIENTRY * qglVertex3fv )(const GLfloat *v);
+void ( APIENTRY * qglVertex3i )(GLint x, GLint y, GLint z);
+void ( APIENTRY * qglVertex3iv )(const GLint *v);
+void ( APIENTRY * qglVertex3s )(GLshort x, GLshort y, GLshort z);
+void ( APIENTRY * qglVertex3sv )(const GLshort *v);
+void ( APIENTRY * qglVertex4d )(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+void ( APIENTRY * qglVertex4dv )(const GLdouble *v);
+void ( APIENTRY * qglVertex4f )(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+void ( APIENTRY * qglVertex4fv )(const GLfloat *v);
+void ( APIENTRY * qglVertex4i )(GLint x, GLint y, GLint z, GLint w);
+void ( APIENTRY * qglVertex4iv )(const GLint *v);
+void ( APIENTRY * qglVertex4s )(GLshort x, GLshort y, GLshort z, GLshort w);
+void ( APIENTRY * qglVertex4sv )(const GLshort *v);
+void ( APIENTRY * qglVertexPointer )(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
+void ( APIENTRY * qglViewport )(GLint x, GLint y, GLsizei width, GLsizei height);
+
+void ( APIENTRY * qglMultiTexCoord2fARB )( GLenum texture, GLfloat s, GLfloat t );
+void ( APIENTRY * qglActiveTextureARB )( GLenum texture );
+void ( APIENTRY * qglClientActiveTextureARB )( GLenum texture );
+
+void ( APIENTRY * qglLockArraysEXT)( int, int);
+void ( APIENTRY * qglUnlockArraysEXT) ( void );
+
+void ( APIENTRY * qglPointParameterfEXT)( GLenum param, GLfloat value );
+void ( APIENTRY * qglPointParameterfvEXT)( GLenum param, const GLfloat *value );
+void ( APIENTRY * qglColorTableEXT)( int, int, int, int, int, const void * );
+void ( APIENTRY * qgl3DfxSetPaletteEXT)( GLuint * );
+void ( APIENTRY * qglSelectTextureSGIS)( GLenum );
+void ( APIENTRY * qglMTexCoord2fSGIS)( GLenum, GLfloat, GLfloat );
+
+static void ( APIENTRY * dllAccum )(GLenum op, GLfloat value);
+static void ( APIENTRY * dllAlphaFunc )(GLenum func, GLclampf ref);
+GLboolean ( APIENTRY * dllAreTexturesResident )(GLsizei n, const GLuint *textures, GLboolean *residences);
+static void ( APIENTRY * dllArrayElement )(GLint i);
+static void ( APIENTRY * dllBegin )(GLenum mode);
+static void ( APIENTRY * dllBindTexture )(GLenum target, GLuint texture);
+static void ( APIENTRY * dllBitmap )(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap);
+static void ( APIENTRY * dllBlendFunc )(GLenum sfactor, GLenum dfactor);
+static void ( APIENTRY * dllCallList )(GLuint list);
+static void ( APIENTRY * dllCallLists )(GLsizei n, GLenum type, const GLvoid *lists);
+static void ( APIENTRY * dllClear )(GLbitfield mask);
+static void ( APIENTRY * dllClearAccum )(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
+static void ( APIENTRY * dllClearColor )(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
+static void ( APIENTRY * dllClearDepth )(GLclampd depth);
+static void ( APIENTRY * dllClearIndex )(GLfloat c);
+static void ( APIENTRY * dllClearStencil )(GLint s);
+static void ( APIENTRY * dllClipPlane )(GLenum plane, const GLdouble *equation);
+static void ( APIENTRY * dllColor3b )(GLbyte red, GLbyte green, GLbyte blue);
+static void ( APIENTRY * dllColor3bv )(const GLbyte *v);
+static void ( APIENTRY * dllColor3d )(GLdouble red, GLdouble green, GLdouble blue);
+static void ( APIENTRY * dllColor3dv )(const GLdouble *v);
+static void ( APIENTRY * dllColor3f )(GLfloat red, GLfloat green, GLfloat blue);
+static void ( APIENTRY * dllColor3fv )(const GLfloat *v);
+static void ( APIENTRY * dllColor3i )(GLint red, GLint green, GLint blue);
+static void ( APIENTRY * dllColor3iv )(const GLint *v);
+static void ( APIENTRY * dllColor3s )(GLshort red, GLshort green, GLshort blue);
+static void ( APIENTRY * dllColor3sv )(const GLshort *v);
+static void ( APIENTRY * dllColor3ub )(GLubyte red, GLubyte green, GLubyte blue);
+static void ( APIENTRY * dllColor3ubv )(const GLubyte *v);
+static void ( APIENTRY * dllColor3ui )(GLuint red, GLuint green, GLuint blue);
+static void ( APIENTRY * dllColor3uiv )(const GLuint *v);
+static void ( APIENTRY * dllColor3us )(GLushort red, GLushort green, GLushort blue);
+static void ( APIENTRY * dllColor3usv )(const GLushort *v);
+static void ( APIENTRY * dllColor4b )(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha);
+static void ( APIENTRY * dllColor4bv )(const GLbyte *v);
+static void ( APIENTRY * dllColor4d )(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha);
+static void ( APIENTRY * dllColor4dv )(const GLdouble *v);
+static void ( APIENTRY * dllColor4f )(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
+static void ( APIENTRY * dllColor4fv )(const GLfloat *v);
+static void ( APIENTRY * dllColor4i )(GLint red, GLint green, GLint blue, GLint alpha);
+static void ( APIENTRY * dllColor4iv )(const GLint *v);
+static void ( APIENTRY * dllColor4s )(GLshort red, GLshort green, GLshort blue, GLshort alpha);
+static void ( APIENTRY * dllColor4sv )(const GLshort *v);
+static void ( APIENTRY * dllColor4ub )(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha);
+static void ( APIENTRY * dllColor4ubv )(const GLubyte *v);
+static void ( APIENTRY * dllColor4ui )(GLuint red, GLuint green, GLuint blue, GLuint alpha);
+static void ( APIENTRY * dllColor4uiv )(const GLuint *v);
+static void ( APIENTRY * dllColor4us )(GLushort red, GLushort green, GLushort blue, GLushort alpha);
+static void ( APIENTRY * dllColor4usv )(const GLushort *v);
+static void ( APIENTRY * dllColorMask )(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
+static void ( APIENTRY * dllColorMaterial )(GLenum face, GLenum mode);
+static void ( APIENTRY * dllColorPointer )(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
+static void ( APIENTRY * dllCopyPixels )(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type);
+static void ( APIENTRY * dllCopyTexImage1D )(GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border);
+static void ( APIENTRY * dllCopyTexImage2D )(GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
+static void ( APIENTRY * dllCopyTexSubImage1D )(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);
+static void ( APIENTRY * dllCopyTexSubImage2D )(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
+static void ( APIENTRY * dllCullFace )(GLenum mode);
+static void ( APIENTRY * dllDeleteLists )(GLuint list, GLsizei range);
+static void ( APIENTRY * dllDeleteTextures )(GLsizei n, const GLuint *textures);
+static void ( APIENTRY * dllDepthFunc )(GLenum func);
+static void ( APIENTRY * dllDepthMask )(GLboolean flag);
+static void ( APIENTRY * dllDepthRange )(GLclampd zNear, GLclampd zFar);
+static void ( APIENTRY * dllDisable )(GLenum cap);
+static void ( APIENTRY * dllDisableClientState )(GLenum array);
+static void ( APIENTRY * dllDrawArrays )(GLenum mode, GLint first, GLsizei count);
+static void ( APIENTRY * dllDrawBuffer )(GLenum mode);
+static void ( APIENTRY * dllDrawElements )(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices);
+static void ( APIENTRY * dllDrawPixels )(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
+static void ( APIENTRY * dllEdgeFlag )(GLboolean flag);
+static void ( APIENTRY * dllEdgeFlagPointer )(GLsizei stride, const GLvoid *pointer);
+static void ( APIENTRY * dllEdgeFlagv )(const GLboolean *flag);
+static void ( APIENTRY * dllEnable )(GLenum cap);
+static void ( APIENTRY * dllEnableClientState )(GLenum array);
+static void ( APIENTRY * dllEnd )(void);
+static void ( APIENTRY * dllEndList )(void);
+static void ( APIENTRY * dllEvalCoord1d )(GLdouble u);
+static void ( APIENTRY * dllEvalCoord1dv )(const GLdouble *u);
+static void ( APIENTRY * dllEvalCoord1f )(GLfloat u);
+static void ( APIENTRY * dllEvalCoord1fv )(const GLfloat *u);
+static void ( APIENTRY * dllEvalCoord2d )(GLdouble u, GLdouble v);
+static void ( APIENTRY * dllEvalCoord2dv )(const GLdouble *u);
+static void ( APIENTRY * dllEvalCoord2f )(GLfloat u, GLfloat v);
+static void ( APIENTRY * dllEvalCoord2fv )(const GLfloat *u);
+static void ( APIENTRY * dllEvalMesh1 )(GLenum mode, GLint i1, GLint i2);
+static void ( APIENTRY * dllEvalMesh2 )(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2);
+static void ( APIENTRY * dllEvalPoint1 )(GLint i);
+static void ( APIENTRY * dllEvalPoint2 )(GLint i, GLint j);
+static void ( APIENTRY * dllFeedbackBuffer )(GLsizei size, GLenum type, GLfloat *buffer);
+static void ( APIENTRY * dllFinish )(void);
+static void ( APIENTRY * dllFlush )(void);
+static void ( APIENTRY * dllFogf )(GLenum pname, GLfloat param);
+static void ( APIENTRY * dllFogfv )(GLenum pname, const GLfloat *params);
+static void ( APIENTRY * dllFogi )(GLenum pname, GLint param);
+static void ( APIENTRY * dllFogiv )(GLenum pname, const GLint *params);
+static void ( APIENTRY * dllFrontFace )(GLenum mode);
+static void ( APIENTRY * dllFrustum )(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
+GLuint ( APIENTRY * dllGenLists )(GLsizei range);
+static void ( APIENTRY * dllGenTextures )(GLsizei n, GLuint *textures);
+static void ( APIENTRY * dllGetBooleanv )(GLenum pname, GLboolean *params);
+static void ( APIENTRY * dllGetClipPlane )(GLenum plane, GLdouble *equation);
+static void ( APIENTRY * dllGetDoublev )(GLenum pname, GLdouble *params);
+GLenum ( APIENTRY * dllGetError )(void);
+static void ( APIENTRY * dllGetFloatv )(GLenum pname, GLfloat *params);
+static void ( APIENTRY * dllGetIntegerv )(GLenum pname, GLint *params);
+static void ( APIENTRY * dllGetLightfv )(GLenum light, GLenum pname, GLfloat *params);
+static void ( APIENTRY * dllGetLightiv )(GLenum light, GLenum pname, GLint *params);
+static void ( APIENTRY * dllGetMapdv )(GLenum target, GLenum query, GLdouble *v);
+static void ( APIENTRY * dllGetMapfv )(GLenum target, GLenum query, GLfloat *v);
+static void ( APIENTRY * dllGetMapiv )(GLenum target, GLenum query, GLint *v);
+static void ( APIENTRY * dllGetMaterialfv )(GLenum face, GLenum pname, GLfloat *params);
+static void ( APIENTRY * dllGetMaterialiv )(GLenum face, GLenum pname, GLint *params);
+static void ( APIENTRY * dllGetPixelMapfv )(GLenum map, GLfloat *values);
+static void ( APIENTRY * dllGetPixelMapuiv )(GLenum map, GLuint *values);
+static void ( APIENTRY * dllGetPixelMapusv )(GLenum map, GLushort *values);
+static void ( APIENTRY * dllGetPointerv )(GLenum pname, GLvoid* *params);
+static void ( APIENTRY * dllGetPolygonStipple )(GLubyte *mask);
+const GLubyte * ( APIENTRY * dllGetString )(GLenum name);
+static void ( APIENTRY * dllGetTexEnvfv )(GLenum target, GLenum pname, GLfloat *params);
+static void ( APIENTRY * dllGetTexEnviv )(GLenum target, GLenum pname, GLint *params);
+static void ( APIENTRY * dllGetTexGendv )(GLenum coord, GLenum pname, GLdouble *params);
+static void ( APIENTRY * dllGetTexGenfv )(GLenum coord, GLenum pname, GLfloat *params);
+static void ( APIENTRY * dllGetTexGeniv )(GLenum coord, GLenum pname, GLint *params);
+static void ( APIENTRY * dllGetTexImage )(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels);
+static void ( APIENTRY * dllGetTexLevelParameterfv )(GLenum target, GLint level, GLenum pname, GLfloat *params);
+static void ( APIENTRY * dllGetTexLevelParameteriv )(GLenum target, GLint level, GLenum pname, GLint *params);
+static void ( APIENTRY * dllGetTexParameterfv )(GLenum target, GLenum pname, GLfloat *params);
+static void ( APIENTRY * dllGetTexParameteriv )(GLenum target, GLenum pname, GLint *params);
+static void ( APIENTRY * dllHint )(GLenum target, GLenum mode);
+static void ( APIENTRY * dllIndexMask )(GLuint mask);
+static void ( APIENTRY * dllIndexPointer )(GLenum type, GLsizei stride, const GLvoid *pointer);
+static void ( APIENTRY * dllIndexd )(GLdouble c);
+static void ( APIENTRY * dllIndexdv )(const GLdouble *c);
+static void ( APIENTRY * dllIndexf )(GLfloat c);
+static void ( APIENTRY * dllIndexfv )(const GLfloat *c);
+static void ( APIENTRY * dllIndexi )(GLint c);
+static void ( APIENTRY * dllIndexiv )(const GLint *c);
+static void ( APIENTRY * dllIndexs )(GLshort c);
+static void ( APIENTRY * dllIndexsv )(const GLshort *c);
+static void ( APIENTRY * dllIndexub )(GLubyte c);
+static void ( APIENTRY * dllIndexubv )(const GLubyte *c);
+static void ( APIENTRY * dllInitNames )(void);
+static void ( APIENTRY * dllInterleavedArrays )(GLenum format, GLsizei stride, const GLvoid *pointer);
+GLboolean ( APIENTRY * dllIsEnabled )(GLenum cap);
+GLboolean ( APIENTRY * dllIsList )(GLuint list);
+GLboolean ( APIENTRY * dllIsTexture )(GLuint texture);
+static void ( APIENTRY * dllLightModelf )(GLenum pname, GLfloat param);
+static void ( APIENTRY * dllLightModelfv )(GLenum pname, const GLfloat *params);
+static void ( APIENTRY * dllLightModeli )(GLenum pname, GLint param);
+static void ( APIENTRY * dllLightModeliv )(GLenum pname, const GLint *params);
+static void ( APIENTRY * dllLightf )(GLenum light, GLenum pname, GLfloat param);
+static void ( APIENTRY * dllLightfv )(GLenum light, GLenum pname, const GLfloat *params);
+static void ( APIENTRY * dllLighti )(GLenum light, GLenum pname, GLint param);
+static void ( APIENTRY * dllLightiv )(GLenum light, GLenum pname, const GLint *params);
+static void ( APIENTRY * dllLineStipple )(GLint factor, GLushort pattern);
+static void ( APIENTRY * dllLineWidth )(GLfloat width);
+static void ( APIENTRY * dllListBase )(GLuint base);
+static void ( APIENTRY * dllLoadIdentity )(void);
+static void ( APIENTRY * dllLoadMatrixd )(const GLdouble *m);
+static void ( APIENTRY * dllLoadMatrixf )(const GLfloat *m);
+static void ( APIENTRY * dllLoadName )(GLuint name);
+static void ( APIENTRY * dllLogicOp )(GLenum opcode);
+static void ( APIENTRY * dllMap1d )(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points);
+static void ( APIENTRY * dllMap1f )(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points);
+static void ( APIENTRY * dllMap2d )(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points);
+static void ( APIENTRY * dllMap2f )(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points);
+static void ( APIENTRY * dllMapGrid1d )(GLint un, GLdouble u1, GLdouble u2);
+static void ( APIENTRY * dllMapGrid1f )(GLint un, GLfloat u1, GLfloat u2);
+static void ( APIENTRY * dllMapGrid2d )(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2);
+static void ( APIENTRY * dllMapGrid2f )(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2);
+static void ( APIENTRY * dllMaterialf )(GLenum face, GLenum pname, GLfloat param);
+static void ( APIENTRY * dllMaterialfv )(GLenum face, GLenum pname, const GLfloat *params);
+static void ( APIENTRY * dllMateriali )(GLenum face, GLenum pname, GLint param);
+static void ( APIENTRY * dllMaterialiv )(GLenum face, GLenum pname, const GLint *params);
+static void ( APIENTRY * dllMatrixMode )(GLenum mode);
+static void ( APIENTRY * dllMultMatrixd )(const GLdouble *m);
+static void ( APIENTRY * dllMultMatrixf )(const GLfloat *m);
+static void ( APIENTRY * dllNewList )(GLuint list, GLenum mode);
+static void ( APIENTRY * dllNormal3b )(GLbyte nx, GLbyte ny, GLbyte nz);
+static void ( APIENTRY * dllNormal3bv )(const GLbyte *v);
+static void ( APIENTRY * dllNormal3d )(GLdouble nx, GLdouble ny, GLdouble nz);
+static void ( APIENTRY * dllNormal3dv )(const GLdouble *v);
+static void ( APIENTRY * dllNormal3f )(GLfloat nx, GLfloat ny, GLfloat nz);
+static void ( APIENTRY * dllNormal3fv )(const GLfloat *v);
+static void ( APIENTRY * dllNormal3i )(GLint nx, GLint ny, GLint nz);
+static void ( APIENTRY * dllNormal3iv )(const GLint *v);
+static void ( APIENTRY * dllNormal3s )(GLshort nx, GLshort ny, GLshort nz);
+static void ( APIENTRY * dllNormal3sv )(const GLshort *v);
+static void ( APIENTRY * dllNormalPointer )(GLenum type, GLsizei stride, const GLvoid *pointer);
+static void ( APIENTRY * dllOrtho )(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
+static void ( APIENTRY * dllPassThrough )(GLfloat token);
+static void ( APIENTRY * dllPixelMapfv )(GLenum map, GLsizei mapsize, const GLfloat *values);
+static void ( APIENTRY * dllPixelMapuiv )(GLenum map, GLsizei mapsize, const GLuint *values);
+static void ( APIENTRY * dllPixelMapusv )(GLenum map, GLsizei mapsize, const GLushort *values);
+static void ( APIENTRY * dllPixelStoref )(GLenum pname, GLfloat param);
+static void ( APIENTRY * dllPixelStorei )(GLenum pname, GLint param);
+static void ( APIENTRY * dllPixelTransferf )(GLenum pname, GLfloat param);
+static void ( APIENTRY * dllPixelTransferi )(GLenum pname, GLint param);
+static void ( APIENTRY * dllPixelZoom )(GLfloat xfactor, GLfloat yfactor);
+static void ( APIENTRY * dllPointSize )(GLfloat size);
+static void ( APIENTRY * dllPolygonMode )(GLenum face, GLenum mode);
+static void ( APIENTRY * dllPolygonOffset )(GLfloat factor, GLfloat units);
+static void ( APIENTRY * dllPolygonStipple )(const GLubyte *mask);
+static void ( APIENTRY * dllPopAttrib )(void);
+static void ( APIENTRY * dllPopClientAttrib )(void);
+static void ( APIENTRY * dllPopMatrix )(void);
+static void ( APIENTRY * dllPopName )(void);
+static void ( APIENTRY * dllPrioritizeTextures )(GLsizei n, const GLuint *textures, const GLclampf *priorities);
+static void ( APIENTRY * dllPushAttrib )(GLbitfield mask);
+static void ( APIENTRY * dllPushClientAttrib )(GLbitfield mask);
+static void ( APIENTRY * dllPushMatrix )(void);
+static void ( APIENTRY * dllPushName )(GLuint name);
+static void ( APIENTRY * dllRasterPos2d )(GLdouble x, GLdouble y);
+static void ( APIENTRY * dllRasterPos2dv )(const GLdouble *v);
+static void ( APIENTRY * dllRasterPos2f )(GLfloat x, GLfloat y);
+static void ( APIENTRY * dllRasterPos2fv )(const GLfloat *v);
+static void ( APIENTRY * dllRasterPos2i )(GLint x, GLint y);
+static void ( APIENTRY * dllRasterPos2iv )(const GLint *v);
+static void ( APIENTRY * dllRasterPos2s )(GLshort x, GLshort y);
+static void ( APIENTRY * dllRasterPos2sv )(const GLshort *v);
+static void ( APIENTRY * dllRasterPos3d )(GLdouble x, GLdouble y, GLdouble z);
+static void ( APIENTRY * dllRasterPos3dv )(const GLdouble *v);
+static void ( APIENTRY * dllRasterPos3f )(GLfloat x, GLfloat y, GLfloat z);
+static void ( APIENTRY * dllRasterPos3fv )(const GLfloat *v);
+static void ( APIENTRY * dllRasterPos3i )(GLint x, GLint y, GLint z);
+static void ( APIENTRY * dllRasterPos3iv )(const GLint *v);
+static void ( APIENTRY * dllRasterPos3s )(GLshort x, GLshort y, GLshort z);
+static void ( APIENTRY * dllRasterPos3sv )(const GLshort *v);
+static void ( APIENTRY * dllRasterPos4d )(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+static void ( APIENTRY * dllRasterPos4dv )(const GLdouble *v);
+static void ( APIENTRY * dllRasterPos4f )(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+static void ( APIENTRY * dllRasterPos4fv )(const GLfloat *v);
+static void ( APIENTRY * dllRasterPos4i )(GLint x, GLint y, GLint z, GLint w);
+static void ( APIENTRY * dllRasterPos4iv )(const GLint *v);
+static void ( APIENTRY * dllRasterPos4s )(GLshort x, GLshort y, GLshort z, GLshort w);
+static void ( APIENTRY * dllRasterPos4sv )(const GLshort *v);
+static void ( APIENTRY * dllReadBuffer )(GLenum mode);
+static void ( APIENTRY * dllReadPixels )(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels);
+static void ( APIENTRY * dllRectd )(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2);
+static void ( APIENTRY * dllRectdv )(const GLdouble *v1, const GLdouble *v2);
+static void ( APIENTRY * dllRectf )(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2);
+static void ( APIENTRY * dllRectfv )(const GLfloat *v1, const GLfloat *v2);
+static void ( APIENTRY * dllRecti )(GLint x1, GLint y1, GLint x2, GLint y2);
+static void ( APIENTRY * dllRectiv )(const GLint *v1, const GLint *v2);
+static void ( APIENTRY * dllRects )(GLshort x1, GLshort y1, GLshort x2, GLshort y2);
+static void ( APIENTRY * dllRectsv )(const GLshort *v1, const GLshort *v2);
+GLint ( APIENTRY * dllRenderMode )(GLenum mode);
+static void ( APIENTRY * dllRotated )(GLdouble angle, GLdouble x, GLdouble y, GLdouble z);
+static void ( APIENTRY * dllRotatef )(GLfloat angle, GLfloat x, GLfloat y, GLfloat z);
+static void ( APIENTRY * dllScaled )(GLdouble x, GLdouble y, GLdouble z);
+static void ( APIENTRY * dllScalef )(GLfloat x, GLfloat y, GLfloat z);
+static void ( APIENTRY * dllScissor )(GLint x, GLint y, GLsizei width, GLsizei height);
+static void ( APIENTRY * dllSelectBuffer )(GLsizei size, GLuint *buffer);
+static void ( APIENTRY * dllShadeModel )(GLenum mode);
+static void ( APIENTRY * dllStencilFunc )(GLenum func, GLint ref, GLuint mask);
+static void ( APIENTRY * dllStencilMask )(GLuint mask);
+static void ( APIENTRY * dllStencilOp )(GLenum fail, GLenum zfail, GLenum zpass);
+static void ( APIENTRY * dllTexCoord1d )(GLdouble s);
+static void ( APIENTRY * dllTexCoord1dv )(const GLdouble *v);
+static void ( APIENTRY * dllTexCoord1f )(GLfloat s);
+static void ( APIENTRY * dllTexCoord1fv )(const GLfloat *v);
+static void ( APIENTRY * dllTexCoord1i )(GLint s);
+static void ( APIENTRY * dllTexCoord1iv )(const GLint *v);
+static void ( APIENTRY * dllTexCoord1s )(GLshort s);
+static void ( APIENTRY * dllTexCoord1sv )(const GLshort *v);
+static void ( APIENTRY * dllTexCoord2d )(GLdouble s, GLdouble t);
+static void ( APIENTRY * dllTexCoord2dv )(const GLdouble *v);
+static void ( APIENTRY * dllTexCoord2f )(GLfloat s, GLfloat t);
+static void ( APIENTRY * dllTexCoord2fv )(const GLfloat *v);
+static void ( APIENTRY * dllTexCoord2i )(GLint s, GLint t);
+static void ( APIENTRY * dllTexCoord2iv )(const GLint *v);
+static void ( APIENTRY * dllTexCoord2s )(GLshort s, GLshort t);
+static void ( APIENTRY * dllTexCoord2sv )(const GLshort *v);
+static void ( APIENTRY * dllTexCoord3d )(GLdouble s, GLdouble t, GLdouble r);
+static void ( APIENTRY * dllTexCoord3dv )(const GLdouble *v);
+static void ( APIENTRY * dllTexCoord3f )(GLfloat s, GLfloat t, GLfloat r);
+static void ( APIENTRY * dllTexCoord3fv )(const GLfloat *v);
+static void ( APIENTRY * dllTexCoord3i )(GLint s, GLint t, GLint r);
+static void ( APIENTRY * dllTexCoord3iv )(const GLint *v);
+static void ( APIENTRY * dllTexCoord3s )(GLshort s, GLshort t, GLshort r);
+static void ( APIENTRY * dllTexCoord3sv )(const GLshort *v);
+static void ( APIENTRY * dllTexCoord4d )(GLdouble s, GLdouble t, GLdouble r, GLdouble q);
+static void ( APIENTRY * dllTexCoord4dv )(const GLdouble *v);
+static void ( APIENTRY * dllTexCoord4f )(GLfloat s, GLfloat t, GLfloat r, GLfloat q);
+static void ( APIENTRY * dllTexCoord4fv )(const GLfloat *v);
+static void ( APIENTRY * dllTexCoord4i )(GLint s, GLint t, GLint r, GLint q);
+static void ( APIENTRY * dllTexCoord4iv )(const GLint *v);
+static void ( APIENTRY * dllTexCoord4s )(GLshort s, GLshort t, GLshort r, GLshort q);
+static void ( APIENTRY * dllTexCoord4sv )(const GLshort *v);
+static void ( APIENTRY * dllTexCoordPointer )(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
+static void ( APIENTRY * dllTexEnvf )(GLenum target, GLenum pname, GLfloat param);
+static void ( APIENTRY * dllTexEnvfv )(GLenum target, GLenum pname, const GLfloat *params);
+static void ( APIENTRY * dllTexEnvi )(GLenum target, GLenum pname, GLint param);
+static void ( APIENTRY * dllTexEnviv )(GLenum target, GLenum pname, const GLint *params);
+static void ( APIENTRY * dllTexGend )(GLenum coord, GLenum pname, GLdouble param);
+static void ( APIENTRY * dllTexGendv )(GLenum coord, GLenum pname, const GLdouble *params);
+static void ( APIENTRY * dllTexGenf )(GLenum coord, GLenum pname, GLfloat param);
+static void ( APIENTRY * dllTexGenfv )(GLenum coord, GLenum pname, const GLfloat *params);
+static void ( APIENTRY * dllTexGeni )(GLenum coord, GLenum pname, GLint param);
+static void ( APIENTRY * dllTexGeniv )(GLenum coord, GLenum pname, const GLint *params);
+static void ( APIENTRY * dllTexImage1D )(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
+static void ( APIENTRY * dllTexImage2D )(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
+static void ( APIENTRY * dllTexParameterf )(GLenum target, GLenum pname, GLfloat param);
+static void ( APIENTRY * dllTexParameterfv )(GLenum target, GLenum pname, const GLfloat *params);
+static void ( APIENTRY * dllTexParameteri )(GLenum target, GLenum pname, GLint param);
+static void ( APIENTRY * dllTexParameteriv )(GLenum target, GLenum pname, const GLint *params);
+static void ( APIENTRY * dllTexSubImage1D )(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels);
+static void ( APIENTRY * dllTexSubImage2D )(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
+static void ( APIENTRY * dllTranslated )(GLdouble x, GLdouble y, GLdouble z);
+static void ( APIENTRY * dllTranslatef )(GLfloat x, GLfloat y, GLfloat z);
+static void ( APIENTRY * dllVertex2d )(GLdouble x, GLdouble y);
+static void ( APIENTRY * dllVertex2dv )(const GLdouble *v);
+static void ( APIENTRY * dllVertex2f )(GLfloat x, GLfloat y);
+static void ( APIENTRY * dllVertex2fv )(const GLfloat *v);
+static void ( APIENTRY * dllVertex2i )(GLint x, GLint y);
+static void ( APIENTRY * dllVertex2iv )(const GLint *v);
+static void ( APIENTRY * dllVertex2s )(GLshort x, GLshort y);
+static void ( APIENTRY * dllVertex2sv )(const GLshort *v);
+static void ( APIENTRY * dllVertex3d )(GLdouble x, GLdouble y, GLdouble z);
+static void ( APIENTRY * dllVertex3dv )(const GLdouble *v);
+static void ( APIENTRY * dllVertex3f )(GLfloat x, GLfloat y, GLfloat z);
+static void ( APIENTRY * dllVertex3fv )(const GLfloat *v);
+static void ( APIENTRY * dllVertex3i )(GLint x, GLint y, GLint z);
+static void ( APIENTRY * dllVertex3iv )(const GLint *v);
+static void ( APIENTRY * dllVertex3s )(GLshort x, GLshort y, GLshort z);
+static void ( APIENTRY * dllVertex3sv )(const GLshort *v);
+static void ( APIENTRY * dllVertex4d )(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+static void ( APIENTRY * dllVertex4dv )(const GLdouble *v);
+static void ( APIENTRY * dllVertex4f )(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+static void ( APIENTRY * dllVertex4fv )(const GLfloat *v);
+static void ( APIENTRY * dllVertex4i )(GLint x, GLint y, GLint z, GLint w);
+static void ( APIENTRY * dllVertex4iv )(const GLint *v);
+static void ( APIENTRY * dllVertex4s )(GLshort x, GLshort y, GLshort z, GLshort w);
+static void ( APIENTRY * dllVertex4sv )(const GLshort *v);
+static void ( APIENTRY * dllVertexPointer )(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
+static void ( APIENTRY * dllViewport )(GLint x, GLint y, GLsizei width, GLsizei height);
+
+static void APIENTRY logAccum(GLenum op, GLfloat value)
+{
+	fprintf( glw_state.log_fp, "glAccum\n" );
+	dllAccum( op, value );
+}
+
+static void APIENTRY logAlphaFunc(GLenum func, GLclampf ref)
+{
+	fprintf( glw_state.log_fp, "glAlphaFunc( 0x%x, %f )\n", func, ref );
+	dllAlphaFunc( func, ref );
+}
+
+static GLboolean APIENTRY logAreTexturesResident(GLsizei n, const GLuint *textures, GLboolean *residences)
+{
+	fprintf( glw_state.log_fp, "glAreTexturesResident\n" );
+	return dllAreTexturesResident( n, textures, residences );
+}
+
+static void APIENTRY logArrayElement(GLint i)
+{
+	fprintf( glw_state.log_fp, "glArrayElement\n" );
+	dllArrayElement( i );
+}
+
+static void APIENTRY logBegin(GLenum mode)
+{
+	fprintf( glw_state.log_fp, "glBegin( 0x%x )\n", mode );
+	dllBegin( mode );
+}
+
+static void APIENTRY logBindTexture(GLenum target, GLuint texture)
+{
+	fprintf( glw_state.log_fp, "glBindTexture( 0x%x, %u )\n", target, texture );
+	dllBindTexture( target, texture );
+}
+
+static void APIENTRY logBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap)
+{
+	fprintf( glw_state.log_fp, "glBitmap\n" );
+	dllBitmap( width, height, xorig, yorig, xmove, ymove, bitmap );
+}
+
+static void APIENTRY logBlendFunc(GLenum sfactor, GLenum dfactor)
+{
+	fprintf( glw_state.log_fp, "glBlendFunc( 0x%x, 0x%x )\n", sfactor, dfactor );
+	dllBlendFunc( sfactor, dfactor );
+}
+
+static void APIENTRY logCallList(GLuint list)
+{
+	fprintf( glw_state.log_fp, "glCallList( %u )\n", list );
+	dllCallList( list );
+}
+
+static void APIENTRY logCallLists(GLsizei n, GLenum type, const void *lists)
+{
+	fprintf( glw_state.log_fp, "glCallLists\n" );
+	dllCallLists( n, type, lists );
+}
+
+static void APIENTRY logClear(GLbitfield mask)
+{
+	fprintf( glw_state.log_fp, "glClear\n" );
+	dllClear( mask );
+}
+
+static void APIENTRY logClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
+{
+	fprintf( glw_state.log_fp, "glClearAccum\n" );
+	dllClearAccum( red, green, blue, alpha );
+}
+
+static void APIENTRY logClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
+{
+	fprintf( glw_state.log_fp, "glClearColor\n" );
+	dllClearColor( red, green, blue, alpha );
+}
+
+static void APIENTRY logClearDepth(GLclampd depth)
+{
+	fprintf( glw_state.log_fp, "glClearDepth\n" );
+	dllClearDepth( depth );
+}
+
+static void APIENTRY logClearIndex(GLfloat c)
+{
+	fprintf( glw_state.log_fp, "glClearIndex\n" );
+	dllClearIndex( c );
+}
+
+static void APIENTRY logClearStencil(GLint s)
+{
+	fprintf( glw_state.log_fp, "glClearStencil\n" );
+	dllClearStencil( s );
+}
+
+static void APIENTRY logClipPlane(GLenum plane, const GLdouble *equation)
+{
+	fprintf( glw_state.log_fp, "glClipPlane\n" );
+	dllClipPlane( plane, equation );
+}
+
+static void APIENTRY logColor3b(GLbyte red, GLbyte green, GLbyte blue)
+{
+	fprintf( glw_state.log_fp, "glColor3b\n" );
+	dllColor3b( red, green, blue );
+}
+
+static void APIENTRY logColor3bv(const GLbyte *v)
+{
+	fprintf( glw_state.log_fp, "glColor3bv\n" );
+	dllColor3bv( v );
+}
+
+static void APIENTRY logColor3d(GLdouble red, GLdouble green, GLdouble blue)
+{
+	fprintf( glw_state.log_fp, "glColor3d\n" );
+	dllColor3d( red, green, blue );
+}
+
+static void APIENTRY logColor3dv(const GLdouble *v)
+{
+	fprintf( glw_state.log_fp, "glColor3dv\n" );
+	dllColor3dv( v );
+}
+
+static void APIENTRY logColor3f(GLfloat red, GLfloat green, GLfloat blue)
+{
+	fprintf( glw_state.log_fp, "glColor3f\n" );
+	dllColor3f( red, green, blue );
+}
+
+static void APIENTRY logColor3fv(const GLfloat *v)
+{
+	fprintf( glw_state.log_fp, "glColor3fv\n" );
+	dllColor3fv( v );
+}
+
+static void APIENTRY logColor3i(GLint red, GLint green, GLint blue)
+{
+	fprintf( glw_state.log_fp, "glColor3i\n" );
+	dllColor3i( red, green, blue );
+}
+
+static void APIENTRY logColor3iv(const GLint *v)
+{
+	fprintf( glw_state.log_fp, "glColor3iv\n" );
+	dllColor3iv( v );
+}
+
+static void APIENTRY logColor3s(GLshort red, GLshort green, GLshort blue)
+{
+	fprintf( glw_state.log_fp, "glColor3s\n" );
+	dllColor3s( red, green, blue );
+}
+
+static void APIENTRY logColor3sv(const GLshort *v)
+{
+	fprintf( glw_state.log_fp, "glColor3sv\n" );
+	dllColor3sv( v );
+}
+
+static void APIENTRY logColor3ub(GLubyte red, GLubyte green, GLubyte blue)
+{
+	fprintf( glw_state.log_fp, "glColor3ub\n" );
+	dllColor3ub( red, green, blue );
+}
+
+static void APIENTRY logColor3ubv(const GLubyte *v)
+{
+	fprintf( glw_state.log_fp, "glColor3ubv\n" );
+	dllColor3ubv( v );
+}
+
+#define SIG( x ) fprintf( glw_state.log_fp, x "\n" )
+
+static void APIENTRY logColor3ui(GLuint red, GLuint green, GLuint blue)
+{
+	SIG( "glColor3ui" );
+	dllColor3ui( red, green, blue );
+}
+
+static void APIENTRY logColor3uiv(const GLuint *v)
+{
+	SIG( "glColor3uiv" );
+	dllColor3uiv( v );
+}
+
+static void APIENTRY logColor3us(GLushort red, GLushort green, GLushort blue)
+{
+	SIG( "glColor3us" );
+	dllColor3us( red, green, blue );
+}
+
+static void APIENTRY logColor3usv(const GLushort *v)
+{
+	SIG( "glColor3usv" );
+	dllColor3usv( v );
+}
+
+static void APIENTRY logColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha)
+{
+	SIG( "glColor4b" );
+	dllColor4b( red, green, blue, alpha );
+}
+
+static void APIENTRY logColor4bv(const GLbyte *v)
+{
+	SIG( "glColor4bv" );
+	dllColor4bv( v );
+}
+
+static void APIENTRY logColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha)
+{
+	SIG( "glColor4d" );
+	dllColor4d( red, green, blue, alpha );
+}
+static void APIENTRY logColor4dv(const GLdouble *v)
+{
+	SIG( "glColor4dv" );
+	dllColor4dv( v );
+}
+static void APIENTRY logColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
+{
+	fprintf( glw_state.log_fp, "glColor4f( %f,%f,%f,%f )\n", red, green, blue, alpha );
+	dllColor4f( red, green, blue, alpha );
+}
+static void APIENTRY logColor4fv(const GLfloat *v)
+{
+	fprintf( glw_state.log_fp, "glColor4fv( %f,%f,%f,%f )\n", v[0], v[1], v[2], v[3] );
+	dllColor4fv( v );
+}
+static void APIENTRY logColor4i(GLint red, GLint green, GLint blue, GLint alpha)
+{
+	SIG( "glColor4i" );
+	dllColor4i( red, green, blue, alpha );
+}
+static void APIENTRY logColor4iv(const GLint *v)
+{
+	SIG( "glColor4iv" );
+	dllColor4iv( v );
+}
+static void APIENTRY logColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha)
+{
+	SIG( "glColor4s" );
+	dllColor4s( red, green, blue, alpha );
+}
+static void APIENTRY logColor4sv(const GLshort *v)
+{
+	SIG( "glColor4sv" );
+	dllColor4sv( v );
+}
+static void APIENTRY logColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
+{
+	SIG( "glColor4b" );
+	dllColor4b( red, green, blue, alpha );
+}
+static void APIENTRY logColor4ubv(const GLubyte *v)
+{
+	SIG( "glColor4ubv" );
+	dllColor4ubv( v );
+}
+static void APIENTRY logColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha)
+{
+	SIG( "glColor4ui" );
+	dllColor4ui( red, green, blue, alpha );
+}
+static void APIENTRY logColor4uiv(const GLuint *v)
+{
+	SIG( "glColor4uiv" );
+	dllColor4uiv( v );
+}
+static void APIENTRY logColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha)
+{
+	SIG( "glColor4us" );
+	dllColor4us( red, green, blue, alpha );
+}
+static void APIENTRY logColor4usv(const GLushort *v)
+{
+	SIG( "glColor4usv" );
+	dllColor4usv( v );
+}
+static void APIENTRY logColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
+{
+	SIG( "glColorMask" );
+	dllColorMask( red, green, blue, alpha );
+}
+static void APIENTRY logColorMaterial(GLenum face, GLenum mode)
+{
+	SIG( "glColorMaterial" );
+	dllColorMaterial( face, mode );
+}
+
+static void APIENTRY logColorPointer(GLint size, GLenum type, GLsizei stride, const void *pointer)
+{
+	SIG( "glColorPointer" );
+	dllColorPointer( size, type, stride, pointer );
+}
+
+static void APIENTRY logCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type)
+{
+	SIG( "glCopyPixels" );
+	dllCopyPixels( x, y, width, height, type );
+}
+
+static void APIENTRY logCopyTexImage1D(GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border)
+{
+	SIG( "glCopyTexImage1D" );
+	dllCopyTexImage1D( target, level, internalFormat, x, y, width, border );
+}
+
+static void APIENTRY logCopyTexImage2D(GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
+{
+	SIG( "glCopyTexImage2D" );
+	dllCopyTexImage2D( target, level, internalFormat, x, y, width, height, border );
+}
+
+static void APIENTRY logCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
+{
+	SIG( "glCopyTexSubImage1D" );
+	dllCopyTexSubImage1D( target, level, xoffset, x, y, width );
+}
+
+static void APIENTRY logCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
+{
+	SIG( "glCopyTexSubImage2D" );
+	dllCopyTexSubImage2D( target, level, xoffset, yoffset, x, y, width, height );
+}
+
+static void APIENTRY logCullFace(GLenum mode)
+{
+	SIG( "glCullFace" );
+	dllCullFace( mode );
+}
+
+static void APIENTRY logDeleteLists(GLuint list, GLsizei range)
+{
+	SIG( "glDeleteLists" );
+	dllDeleteLists( list, range );
+}
+
+static void APIENTRY logDeleteTextures(GLsizei n, const GLuint *textures)
+{
+	SIG( "glDeleteTextures" );
+	dllDeleteTextures( n, textures );
+}
+
+static void APIENTRY logDepthFunc(GLenum func)
+{
+	SIG( "glDepthFunc" );
+	dllDepthFunc( func );
+}
+
+static void APIENTRY logDepthMask(GLboolean flag)
+{
+	SIG( "glDepthMask" );
+	dllDepthMask( flag );
+}
+
+static void APIENTRY logDepthRange(GLclampd zNear, GLclampd zFar)
+{
+	SIG( "glDepthRange" );
+	dllDepthRange( zNear, zFar );
+}
+
+static void APIENTRY logDisable(GLenum cap)
+{
+	fprintf( glw_state.log_fp, "glDisable( 0x%x )\n", cap );
+	dllDisable( cap );
+}
+
+static void APIENTRY logDisableClientState(GLenum array)
+{
+	SIG( "glDisableClientState" );
+	dllDisableClientState( array );
+}
+
+static void APIENTRY logDrawArrays(GLenum mode, GLint first, GLsizei count)
+{
+	SIG( "glDrawArrays" );
+	dllDrawArrays( mode, first, count );
+}
+
+static void APIENTRY logDrawBuffer(GLenum mode)
+{
+	SIG( "glDrawBuffer" );
+	dllDrawBuffer( mode );
+}
+
+static void APIENTRY logDrawElements(GLenum mode, GLsizei count, GLenum type, const void *indices)
+{
+	SIG( "glDrawElements" );
+	dllDrawElements( mode, count, type, indices );
+}
+
+static void APIENTRY logDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels)
+{
+	SIG( "glDrawPixels" );
+	dllDrawPixels( width, height, format, type, pixels );
+}
+
+static void APIENTRY logEdgeFlag(GLboolean flag)
+{
+	SIG( "glEdgeFlag" );
+	dllEdgeFlag( flag );
+}
+
+static void APIENTRY logEdgeFlagPointer(GLsizei stride, const void *pointer)
+{
+	SIG( "glEdgeFlagPointer" );
+	dllEdgeFlagPointer( stride, pointer );
+}
+
+static void APIENTRY logEdgeFlagv(const GLboolean *flag)
+{
+	SIG( "glEdgeFlagv" );
+	dllEdgeFlagv( flag );
+}
+
+static void APIENTRY logEnable(GLenum cap)
+{
+	fprintf( glw_state.log_fp, "glEnable( 0x%x )\n", cap );
+	dllEnable( cap );
+}
+
+static void APIENTRY logEnableClientState(GLenum array)
+{
+	SIG( "glEnableClientState" );
+	dllEnableClientState( array );
+}
+
+static void APIENTRY logEnd(void)
+{
+	SIG( "glEnd" );
+	dllEnd();
+}
+
+static void APIENTRY logEndList(void)
+{
+	SIG( "glEndList" );
+	dllEndList();
+}
+
+static void APIENTRY logEvalCoord1d(GLdouble u)
+{
+	SIG( "glEvalCoord1d" );
+	dllEvalCoord1d( u );
+}
+
+static void APIENTRY logEvalCoord1dv(const GLdouble *u)
+{
+	SIG( "glEvalCoord1dv" );
+	dllEvalCoord1dv( u );
+}
+
+static void APIENTRY logEvalCoord1f(GLfloat u)
+{
+	SIG( "glEvalCoord1f" );
+	dllEvalCoord1f( u );
+}
+
+static void APIENTRY logEvalCoord1fv(const GLfloat *u)
+{
+	SIG( "glEvalCoord1fv" );
+	dllEvalCoord1fv( u );
+}
+static void APIENTRY logEvalCoord2d(GLdouble u, GLdouble v)
+{
+	SIG( "glEvalCoord2d" );
+	dllEvalCoord2d( u, v );
+}
+static void APIENTRY logEvalCoord2dv(const GLdouble *u)
+{
+	SIG( "glEvalCoord2dv" );
+	dllEvalCoord2dv( u );
+}
+static void APIENTRY logEvalCoord2f(GLfloat u, GLfloat v)
+{
+	SIG( "glEvalCoord2f" );
+	dllEvalCoord2f( u, v );
+}
+static void APIENTRY logEvalCoord2fv(const GLfloat *u)
+{
+	SIG( "glEvalCoord2fv" );
+	dllEvalCoord2fv( u );
+}
+
+static void APIENTRY logEvalMesh1(GLenum mode, GLint i1, GLint i2)
+{
+	SIG( "glEvalMesh1" );
+	dllEvalMesh1( mode, i1, i2 );
+}
+static void APIENTRY logEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)
+{
+	SIG( "glEvalMesh2" );
+	dllEvalMesh2( mode, i1, i2, j1, j2 );
+}
+static void APIENTRY logEvalPoint1(GLint i)
+{
+	SIG( "glEvalPoint1" );
+	dllEvalPoint1( i );
+}
+static void APIENTRY logEvalPoint2(GLint i, GLint j)
+{
+	SIG( "glEvalPoint2" );
+	dllEvalPoint2( i, j );
+}
+
+static void APIENTRY logFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer)
+{
+	SIG( "glFeedbackBuffer" );
+	dllFeedbackBuffer( size, type, buffer );
+}
+
+static void APIENTRY logFinish(void)
+{
+	SIG( "glFinish" );
+	dllFinish();
+}
+
+static void APIENTRY logFlush(void)
+{
+	SIG( "glFlush" );
+	dllFlush();
+}
+
+static void APIENTRY logFogf(GLenum pname, GLfloat param)
+{
+	SIG( "glFogf" );
+	dllFogf( pname, param );
+}
+
+static void APIENTRY logFogfv(GLenum pname, const GLfloat *params)
+{
+	SIG( "glFogfv" );
+	dllFogfv( pname, params );
+}
+
+static void APIENTRY logFogi(GLenum pname, GLint param)
+{
+	SIG( "glFogi" );
+	dllFogi( pname, param );
+}
+
+static void APIENTRY logFogiv(GLenum pname, const GLint *params)
+{
+	SIG( "glFogiv" );
+	dllFogiv( pname, params );
+}
+
+static void APIENTRY logFrontFace(GLenum mode)
+{
+	SIG( "glFrontFace" );
+	dllFrontFace( mode );
+}
+
+static void APIENTRY logFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
+{
+	SIG( "glFrustum" );
+	dllFrustum( left, right, bottom, top, zNear, zFar );
+}
+
+static GLuint APIENTRY logGenLists(GLsizei range)
+{
+	SIG( "glGenLists" );
+	return dllGenLists( range );
+}
+
+static void APIENTRY logGenTextures(GLsizei n, GLuint *textures)
+{
+	SIG( "glGenTextures" );
+	dllGenTextures( n, textures );
+}
+
+static void APIENTRY logGetBooleanv(GLenum pname, GLboolean *params)
+{
+	SIG( "glGetBooleanv" );
+	dllGetBooleanv( pname, params );
+}
+
+static void APIENTRY logGetClipPlane(GLenum plane, GLdouble *equation)
+{
+	SIG( "glGetClipPlane" );
+	dllGetClipPlane( plane, equation );
+}
+
+static void APIENTRY logGetDoublev(GLenum pname, GLdouble *params)
+{
+	SIG( "glGetDoublev" );
+	dllGetDoublev( pname, params );
+}
+
+static GLenum APIENTRY logGetError(void)
+{
+	SIG( "glGetError" );
+	return dllGetError();
+}
+
+static void APIENTRY logGetFloatv(GLenum pname, GLfloat *params)
+{
+	SIG( "glGetFloatv" );
+	dllGetFloatv( pname, params );
+}
+
+static void APIENTRY logGetIntegerv(GLenum pname, GLint *params)
+{
+	SIG( "glGetIntegerv" );
+	dllGetIntegerv( pname, params );
+}
+
+static void APIENTRY logGetLightfv(GLenum light, GLenum pname, GLfloat *params)
+{
+	SIG( "glGetLightfv" );
+	dllGetLightfv( light, pname, params );
+}
+
+static void APIENTRY logGetLightiv(GLenum light, GLenum pname, GLint *params)
+{
+	SIG( "glGetLightiv" );
+	dllGetLightiv( light, pname, params );
+}
+
+static void APIENTRY logGetMapdv(GLenum target, GLenum query, GLdouble *v)
+{
+	SIG( "glGetMapdv" );
+	dllGetMapdv( target, query, v );
+}
+
+static void APIENTRY logGetMapfv(GLenum target, GLenum query, GLfloat *v)
+{
+	SIG( "glGetMapfv" );
+	dllGetMapfv( target, query, v );
+}
+
+static void APIENTRY logGetMapiv(GLenum target, GLenum query, GLint *v)
+{
+	SIG( "glGetMapiv" );
+	dllGetMapiv( target, query, v );
+}
+
+static void APIENTRY logGetMaterialfv(GLenum face, GLenum pname, GLfloat *params)
+{
+	SIG( "glGetMaterialfv" );
+	dllGetMaterialfv( face, pname, params );
+}
+
+static void APIENTRY logGetMaterialiv(GLenum face, GLenum pname, GLint *params)
+{
+	SIG( "glGetMaterialiv" );
+	dllGetMaterialiv( face, pname, params );
+}
+
+static void APIENTRY logGetPixelMapfv(GLenum map, GLfloat *values)
+{
+	SIG( "glGetPixelMapfv" );
+	dllGetPixelMapfv( map, values );
+}
+
+static void APIENTRY logGetPixelMapuiv(GLenum map, GLuint *values)
+{
+	SIG( "glGetPixelMapuiv" );
+	dllGetPixelMapuiv( map, values );
+}
+
+static void APIENTRY logGetPixelMapusv(GLenum map, GLushort *values)
+{
+	SIG( "glGetPixelMapusv" );
+	dllGetPixelMapusv( map, values );
+}
+
+static void APIENTRY logGetPointerv(GLenum pname, GLvoid* *params)
+{
+	SIG( "glGetPointerv" );
+	dllGetPointerv( pname, params );
+}
+
+static void APIENTRY logGetPolygonStipple(GLubyte *mask)
+{
+	SIG( "glGetPolygonStipple" );
+	dllGetPolygonStipple( mask );
+}
+
+static const GLubyte * APIENTRY logGetString(GLenum name)
+{
+	SIG( "glGetString" );
+	return dllGetString( name );
+}
+
+static void APIENTRY logGetTexEnvfv(GLenum target, GLenum pname, GLfloat *params)
+{
+	SIG( "glGetTexEnvfv" );
+	dllGetTexEnvfv( target, pname, params );
+}
+
+static void APIENTRY logGetTexEnviv(GLenum target, GLenum pname, GLint *params)
+{
+	SIG( "glGetTexEnviv" );
+	dllGetTexEnviv( target, pname, params );
+}
+
+static void APIENTRY logGetTexGendv(GLenum coord, GLenum pname, GLdouble *params)
+{
+	SIG( "glGetTexGendv" );
+	dllGetTexGendv( coord, pname, params );
+}
+
+static void APIENTRY logGetTexGenfv(GLenum coord, GLenum pname, GLfloat *params)
+{
+	SIG( "glGetTexGenfv" );
+	dllGetTexGenfv( coord, pname, params );
+}
+
+static void APIENTRY logGetTexGeniv(GLenum coord, GLenum pname, GLint *params)
+{
+	SIG( "glGetTexGeniv" );
+	dllGetTexGeniv( coord, pname, params );
+}
+
+static void APIENTRY logGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, void *pixels)
+{
+	SIG( "glGetTexImage" );
+	dllGetTexImage( target, level, format, type, pixels );
+}
+static void APIENTRY logGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params )
+{
+	SIG( "glGetTexLevelParameterfv" );
+	dllGetTexLevelParameterfv( target, level, pname, params );
+}
+
+static void APIENTRY logGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params)
+{
+	SIG( "glGetTexLevelParameteriv" );
+	dllGetTexLevelParameteriv( target, level, pname, params );
+}
+
+static void APIENTRY logGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params)
+{
+	SIG( "glGetTexParameterfv" );
+	dllGetTexParameterfv( target, pname, params );
+}
+
+static void APIENTRY logGetTexParameteriv(GLenum target, GLenum pname, GLint *params)
+{
+	SIG( "glGetTexParameteriv" );
+	dllGetTexParameteriv( target, pname, params );
+}
+
+static void APIENTRY logHint(GLenum target, GLenum mode)
+{
+	fprintf( glw_state.log_fp, "glHint( 0x%x, 0x%x )\n", target, mode );
+	dllHint( target, mode );
+}
+
+static void APIENTRY logIndexMask(GLuint mask)
+{
+	SIG( "glIndexMask" );
+	dllIndexMask( mask );
+}
+
+static void APIENTRY logIndexPointer(GLenum type, GLsizei stride, const void *pointer)
+{
+	SIG( "glIndexPointer" );
+	dllIndexPointer( type, stride, pointer );
+}
+
+static void APIENTRY logIndexd(GLdouble c)
+{
+	SIG( "glIndexd" );
+	dllIndexd( c );
+}
+
+static void APIENTRY logIndexdv(const GLdouble *c)
+{
+	SIG( "glIndexdv" );
+	dllIndexdv( c );
+}
+
+static void APIENTRY logIndexf(GLfloat c)
+{
+	SIG( "glIndexf" );
+	dllIndexf( c );
+}
+
+static void APIENTRY logIndexfv(const GLfloat *c)
+{
+	SIG( "glIndexfv" );
+	dllIndexfv( c );
+}
+
+static void APIENTRY logIndexi(GLint c)
+{
+	SIG( "glIndexi" );
+	dllIndexi( c );
+}
+
+static void APIENTRY logIndexiv(const GLint *c)
+{
+	SIG( "glIndexiv" );
+	dllIndexiv( c );
+}
+
+static void APIENTRY logIndexs(GLshort c)
+{
+	SIG( "glIndexs" );
+	dllIndexs( c );
+}
+
+static void APIENTRY logIndexsv(const GLshort *c)
+{
+	SIG( "glIndexsv" );
+	dllIndexsv( c );
+}
+
+static void APIENTRY logIndexub(GLubyte c)
+{
+	SIG( "glIndexub" );
+	dllIndexub( c );
+}
+
+static void APIENTRY logIndexubv(const GLubyte *c)
+{
+	SIG( "glIndexubv" );
+	dllIndexubv( c );
+}
+
+static void APIENTRY logInitNames(void)
+{
+	SIG( "glInitNames" );
+	dllInitNames();
+}
+
+static void APIENTRY logInterleavedArrays(GLenum format, GLsizei stride, const void *pointer)
+{
+	SIG( "glInterleavedArrays" );
+	dllInterleavedArrays( format, stride, pointer );
+}
+
+static GLboolean APIENTRY logIsEnabled(GLenum cap)
+{
+	SIG( "glIsEnabled" );
+	return dllIsEnabled( cap );
+}
+static GLboolean APIENTRY logIsList(GLuint list)
+{
+	SIG( "glIsList" );
+	return dllIsList( list );
+}
+static GLboolean APIENTRY logIsTexture(GLuint texture)
+{
+	SIG( "glIsTexture" );
+	return dllIsTexture( texture );
+}
+
+static void APIENTRY logLightModelf(GLenum pname, GLfloat param)
+{
+	SIG( "glLightModelf" );
+	dllLightModelf( pname, param );
+}
+
+static void APIENTRY logLightModelfv(GLenum pname, const GLfloat *params)
+{
+	SIG( "glLightModelfv" );
+	dllLightModelfv( pname, params );
+}
+
+static void APIENTRY logLightModeli(GLenum pname, GLint param)
+{
+	SIG( "glLightModeli" );
+	dllLightModeli( pname, param );
+
+}
+
+static void APIENTRY logLightModeliv(GLenum pname, const GLint *params)
+{
+	SIG( "glLightModeliv" );
+	dllLightModeliv( pname, params );
+}
+
+static void APIENTRY logLightf(GLenum light, GLenum pname, GLfloat param)
+{
+	SIG( "glLightf" );
+	dllLightf( light, pname, param );
+}
+
+static void APIENTRY logLightfv(GLenum light, GLenum pname, const GLfloat *params)
+{
+	SIG( "glLightfv" );
+	dllLightfv( light, pname, params );
+}
+
+static void APIENTRY logLighti(GLenum light, GLenum pname, GLint param)
+{
+	SIG( "glLighti" );
+	dllLighti( light, pname, param );
+}
+
+static void APIENTRY logLightiv(GLenum light, GLenum pname, const GLint *params)
+{
+	SIG( "glLightiv" );
+	dllLightiv( light, pname, params );
+}
+
+static void APIENTRY logLineStipple(GLint factor, GLushort pattern)
+{
+	SIG( "glLineStipple" );
+	dllLineStipple( factor, pattern );
+}
+
+static void APIENTRY logLineWidth(GLfloat width)
+{
+	SIG( "glLineWidth" );
+	dllLineWidth( width );
+}
+
+static void APIENTRY logListBase(GLuint base)
+{
+	SIG( "glListBase" );
+	dllListBase( base );
+}
+
+static void APIENTRY logLoadIdentity(void)
+{
+	SIG( "glLoadIdentity" );
+	dllLoadIdentity();
+}
+
+static void APIENTRY logLoadMatrixd(const GLdouble *m)
+{
+	SIG( "glLoadMatrixd" );
+	dllLoadMatrixd( m );
+}
+
+static void APIENTRY logLoadMatrixf(const GLfloat *m)
+{
+	SIG( "glLoadMatrixf" );
+	dllLoadMatrixf( m );
+}
+
+static void APIENTRY logLoadName(GLuint name)
+{
+	SIG( "glLoadName" );
+	dllLoadName( name );
+}
+
+static void APIENTRY logLogicOp(GLenum opcode)
+{
+	SIG( "glLogicOp" );
+	dllLogicOp( opcode );
+}
+
+static void APIENTRY logMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points)
+{
+	SIG( "glMap1d" );
+	dllMap1d( target, u1, u2, stride, order, points );
+}
+
+static void APIENTRY logMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points)
+{
+	SIG( "glMap1f" );
+	dllMap1f( target, u1, u2, stride, order, points );
+}
+
+static void APIENTRY logMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points)
+{
+	SIG( "glMap2d" );
+	dllMap2d( target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points );
+}
+
+static void APIENTRY logMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points)
+{
+	SIG( "glMap2f" );
+	dllMap2f( target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points );
+}
+
+static void APIENTRY logMapGrid1d(GLint un, GLdouble u1, GLdouble u2)
+{
+	SIG( "glMapGrid1d" );
+	dllMapGrid1d( un, u1, u2 );
+}
+
+static void APIENTRY logMapGrid1f(GLint un, GLfloat u1, GLfloat u2)
+{
+	SIG( "glMapGrid1f" );
+	dllMapGrid1f( un, u1, u2 );
+}
+
+static void APIENTRY logMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2)
+{
+	SIG( "glMapGrid2d" );
+	dllMapGrid2d( un, u1, u2, vn, v1, v2 );
+}
+static void APIENTRY logMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2)
+{
+	SIG( "glMapGrid2f" );
+	dllMapGrid2f( un, u1, u2, vn, v1, v2 );
+}
+static void APIENTRY logMaterialf(GLenum face, GLenum pname, GLfloat param)
+{
+	SIG( "glMaterialf" );
+	dllMaterialf( face, pname, param );
+}
+static void APIENTRY logMaterialfv(GLenum face, GLenum pname, const GLfloat *params)
+{
+	SIG( "glMaterialfv" );
+	dllMaterialfv( face, pname, params );
+}
+
+static void APIENTRY logMateriali(GLenum face, GLenum pname, GLint param)
+{
+	SIG( "glMateriali" );
+	dllMateriali( face, pname, param );
+}
+
+static void APIENTRY logMaterialiv(GLenum face, GLenum pname, const GLint *params)
+{
+	SIG( "glMaterialiv" );
+	dllMaterialiv( face, pname, params );
+}
+
+static void APIENTRY logMatrixMode(GLenum mode)
+{
+	SIG( "glMatrixMode" );
+	dllMatrixMode( mode );
+}
+
+static void APIENTRY logMultMatrixd(const GLdouble *m)
+{
+	SIG( "glMultMatrixd" );
+	dllMultMatrixd( m );
+}
+
+static void APIENTRY logMultMatrixf(const GLfloat *m)
+{
+	SIG( "glMultMatrixf" );
+	dllMultMatrixf( m );
+}
+
+static void APIENTRY logNewList(GLuint list, GLenum mode)
+{
+	SIG( "glNewList" );
+	dllNewList( list, mode );
+}
+
+static void APIENTRY logNormal3b(GLbyte nx, GLbyte ny, GLbyte nz)
+{
+	SIG ("glNormal3b" );
+	dllNormal3b( nx, ny, nz );
+}
+
+static void APIENTRY logNormal3bv(const GLbyte *v)
+{
+	SIG( "glNormal3bv" );
+	dllNormal3bv( v );
+}
+
+static void APIENTRY logNormal3d(GLdouble nx, GLdouble ny, GLdouble nz)
+{
+	SIG( "glNormal3d" );
+	dllNormal3d( nx, ny, nz );
+}
+
+static void APIENTRY logNormal3dv(const GLdouble *v)
+{
+	SIG( "glNormal3dv" );
+	dllNormal3dv( v );
+}
+
+static void APIENTRY logNormal3f(GLfloat nx, GLfloat ny, GLfloat nz)
+{
+	SIG( "glNormal3f" );
+	dllNormal3f( nx, ny, nz );
+}
+
+static void APIENTRY logNormal3fv(const GLfloat *v)
+{
+	SIG( "glNormal3fv" );
+	dllNormal3fv( v );
+}
+static void APIENTRY logNormal3i(GLint nx, GLint ny, GLint nz)
+{
+	SIG( "glNormal3i" );
+	dllNormal3i( nx, ny, nz );
+}
+static void APIENTRY logNormal3iv(const GLint *v)
+{
+	SIG( "glNormal3iv" );
+	dllNormal3iv( v );
+}
+static void APIENTRY logNormal3s(GLshort nx, GLshort ny, GLshort nz)
+{
+	SIG( "glNormal3s" );
+	dllNormal3s( nx, ny, nz );
+}
+static void APIENTRY logNormal3sv(const GLshort *v)
+{
+	SIG( "glNormal3sv" );
+	dllNormal3sv( v );
+}
+static void APIENTRY logNormalPointer(GLenum type, GLsizei stride, const void *pointer)
+{
+	SIG( "glNormalPointer" );
+	dllNormalPointer( type, stride, pointer );
+}
+static void APIENTRY logOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
+{
+	SIG( "glOrtho" );
+	dllOrtho( left, right, bottom, top, zNear, zFar );
+}
+
+static void APIENTRY logPassThrough(GLfloat token)
+{
+	SIG( "glPassThrough" );
+	dllPassThrough( token );
+}
+
+static void APIENTRY logPixelMapfv(GLenum map, GLsizei mapsize, const GLfloat *values)
+{
+	SIG( "glPixelMapfv" );
+	dllPixelMapfv( map, mapsize, values );
+}
+
+static void APIENTRY logPixelMapuiv(GLenum map, GLsizei mapsize, const GLuint *values)
+{
+	SIG( "glPixelMapuiv" );
+	dllPixelMapuiv( map, mapsize, values );
+}
+
+static void APIENTRY logPixelMapusv(GLenum map, GLsizei mapsize, const GLushort *values)
+{
+	SIG( "glPixelMapusv" );
+	dllPixelMapusv( map, mapsize, values );
+}
+static void APIENTRY logPixelStoref(GLenum pname, GLfloat param)
+{
+	SIG( "glPixelStoref" );
+	dllPixelStoref( pname, param );
+}
+static void APIENTRY logPixelStorei(GLenum pname, GLint param)
+{
+	SIG( "glPixelStorei" );
+	dllPixelStorei( pname, param );
+}
+static void APIENTRY logPixelTransferf(GLenum pname, GLfloat param)
+{
+	SIG( "glPixelTransferf" );
+	dllPixelTransferf( pname, param );
+}
+
+static void APIENTRY logPixelTransferi(GLenum pname, GLint param)
+{
+	SIG( "glPixelTransferi" );
+	dllPixelTransferi( pname, param );
+}
+
+static void APIENTRY logPixelZoom(GLfloat xfactor, GLfloat yfactor)
+{
+	SIG( "glPixelZoom" );
+	dllPixelZoom( xfactor, yfactor );
+}
+
+static void APIENTRY logPointSize(GLfloat size)
+{
+	SIG( "glPointSize" );
+	dllPointSize( size );
+}
+
+static void APIENTRY logPolygonMode(GLenum face, GLenum mode)
+{
+	fprintf( glw_state.log_fp, "glPolygonMode( 0x%x, 0x%x )\n", face, mode );
+	dllPolygonMode( face, mode );
+}
+
+static void APIENTRY logPolygonOffset(GLfloat factor, GLfloat units)
+{
+	SIG( "glPolygonOffset" );
+	dllPolygonOffset( factor, units );
+}
+static void APIENTRY logPolygonStipple(const GLubyte *mask )
+{
+	SIG( "glPolygonStipple" );
+	dllPolygonStipple( mask );
+}
+static void APIENTRY logPopAttrib(void)
+{
+	SIG( "glPopAttrib" );
+	dllPopAttrib();
+}
+
+static void APIENTRY logPopClientAttrib(void)
+{
+	SIG( "glPopClientAttrib" );
+	dllPopClientAttrib();
+}
+
+static void APIENTRY logPopMatrix(void)
+{
+	SIG( "glPopMatrix" );
+	dllPopMatrix();
+}
+
+static void APIENTRY logPopName(void)
+{
+	SIG( "glPopName" );
+	dllPopName();
+}
+
+static void APIENTRY logPrioritizeTextures(GLsizei n, const GLuint *textures, const GLclampf *priorities)
+{
+	SIG( "glPrioritizeTextures" );
+	dllPrioritizeTextures( n, textures, priorities );
+}
+
+static void APIENTRY logPushAttrib(GLbitfield mask)
+{
+	SIG( "glPushAttrib" );
+	dllPushAttrib( mask );
+}
+
+static void APIENTRY logPushClientAttrib(GLbitfield mask)
+{
+	SIG( "glPushClientAttrib" );
+	dllPushClientAttrib( mask );
+}
+
+static void APIENTRY logPushMatrix(void)
+{
+	SIG( "glPushMatrix" );
+	dllPushMatrix();
+}
+
+static void APIENTRY logPushName(GLuint name)
+{
+	SIG( "glPushName" );
+	dllPushName( name );
+}
+
+static void APIENTRY logRasterPos2d(GLdouble x, GLdouble y)
+{
+	SIG ("glRasterPot2d" );
+	dllRasterPos2d( x, y );
+}
+
+static void APIENTRY logRasterPos2dv(const GLdouble *v)
+{
+	SIG( "glRasterPos2dv" );
+	dllRasterPos2dv( v );
+}
+
+static void APIENTRY logRasterPos2f(GLfloat x, GLfloat y)
+{
+	SIG( "glRasterPos2f" );
+	dllRasterPos2f( x, y );
+}
+static void APIENTRY logRasterPos2fv(const GLfloat *v)
+{
+	SIG( "glRasterPos2dv" );
+	dllRasterPos2fv( v );
+}
+static void APIENTRY logRasterPos2i(GLint x, GLint y)
+{
+	SIG( "glRasterPos2if" );
+	dllRasterPos2i( x, y );
+}
+static void APIENTRY logRasterPos2iv(const GLint *v)
+{
+	SIG( "glRasterPos2iv" );
+	dllRasterPos2iv( v );
+}
+static void APIENTRY logRasterPos2s(GLshort x, GLshort y)
+{
+	SIG( "glRasterPos2s" );
+	dllRasterPos2s( x, y );
+}
+static void APIENTRY logRasterPos2sv(const GLshort *v)
+{
+	SIG( "glRasterPos2sv" );
+	dllRasterPos2sv( v );
+}
+static void APIENTRY logRasterPos3d(GLdouble x, GLdouble y, GLdouble z)
+{
+	SIG( "glRasterPos3d" );
+	dllRasterPos3d( x, y, z );
+}
+static void APIENTRY logRasterPos3dv(const GLdouble *v)
+{
+	SIG( "glRasterPos3dv" );
+	dllRasterPos3dv( v );
+}
+static void APIENTRY logRasterPos3f(GLfloat x, GLfloat y, GLfloat z)
+{
+	SIG( "glRasterPos3f" );
+	dllRasterPos3f( x, y, z );
+}
+static void APIENTRY logRasterPos3fv(const GLfloat *v)
+{
+	SIG( "glRasterPos3fv" );
+	dllRasterPos3fv( v );
+}
+static void APIENTRY logRasterPos3i(GLint x, GLint y, GLint z)
+{
+	SIG( "glRasterPos3i" );
+	dllRasterPos3i( x, y, z );
+}
+static void APIENTRY logRasterPos3iv(const GLint *v)
+{
+	SIG( "glRasterPos3iv" );
+	dllRasterPos3iv( v );
+}
+static void APIENTRY logRasterPos3s(GLshort x, GLshort y, GLshort z)
+{
+	SIG( "glRasterPos3s" );
+	dllRasterPos3s( x, y, z );
+}
+static void APIENTRY logRasterPos3sv(const GLshort *v)
+{
+	SIG( "glRasterPos3sv" );
+	dllRasterPos3sv( v );
+}
+static void APIENTRY logRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
+{
+	SIG( "glRasterPos4d" );
+	dllRasterPos4d( x, y, z, w );
+}
+static void APIENTRY logRasterPos4dv(const GLdouble *v)
+{
+	SIG( "glRasterPos4dv" );
+	dllRasterPos4dv( v );
+}
+static void APIENTRY logRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
+{
+	SIG( "glRasterPos4f" );
+	dllRasterPos4f( x, y, z, w );
+}
+static void APIENTRY logRasterPos4fv(const GLfloat *v)
+{
+	SIG( "glRasterPos4fv" );
+	dllRasterPos4fv( v );
+}
+static void APIENTRY logRasterPos4i(GLint x, GLint y, GLint z, GLint w)
+{
+	SIG( "glRasterPos4i" );
+	dllRasterPos4i( x, y, z, w );
+}
+static void APIENTRY logRasterPos4iv(const GLint *v)
+{
+	SIG( "glRasterPos4iv" );
+	dllRasterPos4iv( v );
+}
+static void APIENTRY logRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w)
+{
+	SIG( "glRasterPos4s" );
+	dllRasterPos4s( x, y, z, w );
+}
+static void APIENTRY logRasterPos4sv(const GLshort *v)
+{
+	SIG( "glRasterPos4sv" );
+	dllRasterPos4sv( v );
+}
+static void APIENTRY logReadBuffer(GLenum mode)
+{
+	SIG( "glReadBuffer" );
+	dllReadBuffer( mode );
+}
+static void APIENTRY logReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void *pixels)
+{
+	SIG( "glReadPixels" );
+	dllReadPixels( x, y, width, height, format, type, pixels );
+}
+
+static void APIENTRY logRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2)
+{
+	SIG( "glRectd" );
+	dllRectd( x1, y1, x2, y2 );
+}
+
+static void APIENTRY logRectdv(const GLdouble *v1, const GLdouble *v2)
+{
+	SIG( "glRectdv" );
+	dllRectdv( v1, v2 );
+}
+
+static void APIENTRY logRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)
+{
+	SIG( "glRectf" );
+	dllRectf( x1, y1, x2, y2 );
+}
+
+static void APIENTRY logRectfv(const GLfloat *v1, const GLfloat *v2)
+{
+	SIG( "glRectfv" );
+	dllRectfv( v1, v2 );
+}
+static void APIENTRY logRecti(GLint x1, GLint y1, GLint x2, GLint y2)
+{
+	SIG( "glRecti" );
+	dllRecti( x1, y1, x2, y2 );
+}
+static void APIENTRY logRectiv(const GLint *v1, const GLint *v2)
+{
+	SIG( "glRectiv" );
+	dllRectiv( v1, v2 );
+}
+static void APIENTRY logRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2)
+{
+	SIG( "glRects" );
+	dllRects( x1, y1, x2, y2 );
+}
+static void APIENTRY logRectsv(const GLshort *v1, const GLshort *v2)
+{
+	SIG( "glRectsv" );
+	dllRectsv( v1, v2 );
+}
+static GLint APIENTRY logRenderMode(GLenum mode)
+{
+	SIG( "glRenderMode" );
+	return dllRenderMode( mode );
+}
+static void APIENTRY logRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z)
+{
+	SIG( "glRotated" );
+	dllRotated( angle, x, y, z );
+}
+
+static void APIENTRY logRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
+{
+	SIG( "glRotatef" );
+	dllRotatef( angle, x, y, z );
+}
+
+static void APIENTRY logScaled(GLdouble x, GLdouble y, GLdouble z)
+{
+	SIG( "glScaled" );
+	dllScaled( x, y, z );
+}
+
+static void APIENTRY logScalef(GLfloat x, GLfloat y, GLfloat z)
+{
+	SIG( "glScalef" );
+	dllScalef( x, y, z );
+}
+
+static void APIENTRY logScissor(GLint x, GLint y, GLsizei width, GLsizei height)
+{
+	SIG( "glScissor" );
+	dllScissor( x, y, width, height );
+}
+
+static void APIENTRY logSelectBuffer(GLsizei size, GLuint *buffer)
+{
+	SIG( "glSelectBuffer" );
+	dllSelectBuffer( size, buffer );
+}
+
+static void APIENTRY logShadeModel(GLenum mode)
+{
+	SIG( "glShadeModel" );
+	dllShadeModel( mode );
+}
+
+static void APIENTRY logStencilFunc(GLenum func, GLint ref, GLuint mask)
+{
+	SIG( "glStencilFunc" );
+	dllStencilFunc( func, ref, mask );
+}
+
+static void APIENTRY logStencilMask(GLuint mask)
+{
+	SIG( "glStencilMask" );
+	dllStencilMask( mask );
+}
+
+static void APIENTRY logStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
+{
+	SIG( "glStencilOp" );
+	dllStencilOp( fail, zfail, zpass );
+}
+
+static void APIENTRY logTexCoord1d(GLdouble s)
+{
+	SIG( "glTexCoord1d" );
+	dllTexCoord1d( s );
+}
+
+static void APIENTRY logTexCoord1dv(const GLdouble *v)
+{
+	SIG( "glTexCoord1dv" );
+	dllTexCoord1dv( v );
+}
+
+static void APIENTRY logTexCoord1f(GLfloat s)
+{
+	SIG( "glTexCoord1f" );
+	dllTexCoord1f( s );
+}
+static void APIENTRY logTexCoord1fv(const GLfloat *v)
+{
+	SIG( "glTexCoord1fv" );
+	dllTexCoord1fv( v );
+}
+static void APIENTRY logTexCoord1i(GLint s)
+{
+	SIG( "glTexCoord1i" );
+	dllTexCoord1i( s );
+}
+static void APIENTRY logTexCoord1iv(const GLint *v)
+{
+	SIG( "glTexCoord1iv" );
+	dllTexCoord1iv( v );
+}
+static void APIENTRY logTexCoord1s(GLshort s)
+{
+	SIG( "glTexCoord1s" );
+	dllTexCoord1s( s );
+}
+static void APIENTRY logTexCoord1sv(const GLshort *v)
+{
+	SIG( "glTexCoord1sv" );
+	dllTexCoord1sv( v );
+}
+static void APIENTRY logTexCoord2d(GLdouble s, GLdouble t)
+{
+	SIG( "glTexCoord2d" );
+	dllTexCoord2d( s, t );
+}
+
+static void APIENTRY logTexCoord2dv(const GLdouble *v)
+{
+	SIG( "glTexCoord2dv" );
+	dllTexCoord2dv( v );
+}
+static void APIENTRY logTexCoord2f(GLfloat s, GLfloat t)
+{
+	SIG( "glTexCoord2f" );
+	dllTexCoord2f( s, t );
+}
+static void APIENTRY logTexCoord2fv(const GLfloat *v)
+{
+	SIG( "glTexCoord2fv" );
+	dllTexCoord2fv( v );
+}
+static void APIENTRY logTexCoord2i(GLint s, GLint t)
+{
+	SIG( "glTexCoord2i" );
+	dllTexCoord2i( s, t );
+}
+static void APIENTRY logTexCoord2iv(const GLint *v)
+{
+	SIG( "glTexCoord2iv" );
+	dllTexCoord2iv( v );
+}
+static void APIENTRY logTexCoord2s(GLshort s, GLshort t)
+{
+	SIG( "glTexCoord2s" );
+	dllTexCoord2s( s, t );
+}
+static void APIENTRY logTexCoord2sv(const GLshort *v)
+{
+	SIG( "glTexCoord2sv" );
+	dllTexCoord2sv( v );
+}
+static void APIENTRY logTexCoord3d(GLdouble s, GLdouble t, GLdouble r)
+{
+	SIG( "glTexCoord3d" );
+	dllTexCoord3d( s, t, r );
+}
+static void APIENTRY logTexCoord3dv(const GLdouble *v)
+{
+	SIG( "glTexCoord3dv" );
+	dllTexCoord3dv( v );
+}
+static void APIENTRY logTexCoord3f(GLfloat s, GLfloat t, GLfloat r)
+{
+	SIG( "glTexCoord3f" );
+	dllTexCoord3f( s, t, r );
+}
+static void APIENTRY logTexCoord3fv(const GLfloat *v)
+{
+	SIG( "glTexCoord3fv" );
+	dllTexCoord3fv( v );
+}
+static void APIENTRY logTexCoord3i(GLint s, GLint t, GLint r)
+{
+	SIG( "glTexCoord3i" );
+	dllTexCoord3i( s, t, r );
+}
+static void APIENTRY logTexCoord3iv(const GLint *v)
+{
+	SIG( "glTexCoord3iv" );
+	dllTexCoord3iv( v );
+}
+static void APIENTRY logTexCoord3s(GLshort s, GLshort t, GLshort r)
+{
+	SIG( "glTexCoord3s" );
+	dllTexCoord3s( s, t, r );
+}
+static void APIENTRY logTexCoord3sv(const GLshort *v)
+{
+	SIG( "glTexCoord3sv" );
+	dllTexCoord3sv( v );
+}
+static void APIENTRY logTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q)
+{
+	SIG( "glTexCoord4d" );
+	dllTexCoord4d( s, t, r, q );
+}
+static void APIENTRY logTexCoord4dv(const GLdouble *v)
+{
+	SIG( "glTexCoord4dv" );
+	dllTexCoord4dv( v );
+}
+static void APIENTRY logTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q)
+{
+	SIG( "glTexCoord4f" );
+	dllTexCoord4f( s, t, r, q );
+}
+static void APIENTRY logTexCoord4fv(const GLfloat *v)
+{
+	SIG( "glTexCoord4fv" );
+	dllTexCoord4fv( v );
+}
+static void APIENTRY logTexCoord4i(GLint s, GLint t, GLint r, GLint q)
+{
+	SIG( "glTexCoord4i" );
+	dllTexCoord4i( s, t, r, q );
+}
+static void APIENTRY logTexCoord4iv(const GLint *v)
+{
+	SIG( "glTexCoord4iv" );
+	dllTexCoord4iv( v );
+}
+static void APIENTRY logTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q)
+{
+	SIG( "glTexCoord4s" );
+	dllTexCoord4s( s, t, r, q );
+}
+static void APIENTRY logTexCoord4sv(const GLshort *v)
+{
+	SIG( "glTexCoord4sv" );
+	dllTexCoord4sv( v );
+}
+static void APIENTRY logTexCoordPointer(GLint size, GLenum type, GLsizei stride, const void *pointer)
+{
+	SIG( "glTexCoordPointer" );
+	dllTexCoordPointer( size, type, stride, pointer );
+}
+
+static void APIENTRY logTexEnvf(GLenum target, GLenum pname, GLfloat param)
+{
+	fprintf( glw_state.log_fp, "glTexEnvf( 0x%x, 0x%x, %f )\n", target, pname, param );
+	dllTexEnvf( target, pname, param );
+}
+
+static void APIENTRY logTexEnvfv(GLenum target, GLenum pname, const GLfloat *params)
+{
+	SIG( "glTexEnvfv" );
+	dllTexEnvfv( target, pname, params );
+}
+
+static void APIENTRY logTexEnvi(GLenum target, GLenum pname, GLint param)
+{
+	fprintf( glw_state.log_fp, "glTexEnvi( 0x%x, 0x%x, 0x%x )\n", target, pname, param );
+	dllTexEnvi( target, pname, param );
+}
+static void APIENTRY logTexEnviv(GLenum target, GLenum pname, const GLint *params)
+{
+	SIG( "glTexEnviv" );
+	dllTexEnviv( target, pname, params );
+}
+
+static void APIENTRY logTexGend(GLenum coord, GLenum pname, GLdouble param)
+{
+	SIG( "glTexGend" );
+	dllTexGend( coord, pname, param );
+}
+
+static void APIENTRY logTexGendv(GLenum coord, GLenum pname, const GLdouble *params)
+{
+	SIG( "glTexGendv" );
+	dllTexGendv( coord, pname, params );
+}
+
+static void APIENTRY logTexGenf(GLenum coord, GLenum pname, GLfloat param)
+{
+	SIG( "glTexGenf" );
+	dllTexGenf( coord, pname, param );
+}
+static void APIENTRY logTexGenfv(GLenum coord, GLenum pname, const GLfloat *params)
+{
+	SIG( "glTexGenfv" );
+	dllTexGenfv( coord, pname, params );
+}
+static void APIENTRY logTexGeni(GLenum coord, GLenum pname, GLint param)
+{
+	SIG( "glTexGeni" );
+	dllTexGeni( coord, pname, param );
+}
+static void APIENTRY logTexGeniv(GLenum coord, GLenum pname, const GLint *params)
+{
+	SIG( "glTexGeniv" );
+	dllTexGeniv( coord, pname, params );
+}
+static void APIENTRY logTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void *pixels)
+{
+	SIG( "glTexImage1D" );
+	dllTexImage1D( target, level, internalformat, width, border, format, type, pixels );
+}
+static void APIENTRY logTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels)
+{
+	SIG( "glTexImage2D" );
+	dllTexImage2D( target, level, internalformat, width, height, border, format, type, pixels );
+}
+
+static void APIENTRY logTexParameterf(GLenum target, GLenum pname, GLfloat param)
+{
+	fprintf( glw_state.log_fp, "glTexParameterf( 0x%x, 0x%x, %f )\n", target, pname, param );
+	dllTexParameterf( target, pname, param );
+}
+
+static void APIENTRY logTexParameterfv(GLenum target, GLenum pname, const GLfloat *params)
+{
+	SIG( "glTexParameterfv" );
+	dllTexParameterfv( target, pname, params );
+}
+static void APIENTRY logTexParameteri(GLenum target, GLenum pname, GLint param)
+{
+	fprintf( glw_state.log_fp, "glTexParameteri( 0x%x, 0x%x, 0x%x )\n", target, pname, param );
+	dllTexParameteri( target, pname, param );
+}
+static void APIENTRY logTexParameteriv(GLenum target, GLenum pname, const GLint *params)
+{
+	SIG( "glTexParameteriv" );
+	dllTexParameteriv( target, pname, params );
+}
+static void APIENTRY logTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels)
+{
+	SIG( "glTexSubImage1D" );
+	dllTexSubImage1D( target, level, xoffset, width, format, type, pixels );
+}
+static void APIENTRY logTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels)
+{
+	SIG( "glTexSubImage2D" );
+	dllTexSubImage2D( target, level, xoffset, yoffset, width, height, format, type, pixels );
+}
+static void APIENTRY logTranslated(GLdouble x, GLdouble y, GLdouble z)
+{
+	SIG( "glTranslated" );
+	dllTranslated( x, y, z );
+}
+
+static void APIENTRY logTranslatef(GLfloat x, GLfloat y, GLfloat z)
+{
+	SIG( "glTranslatef" );
+	dllTranslatef( x, y, z );
+}
+
+static void APIENTRY logVertex2d(GLdouble x, GLdouble y)
+{
+	SIG( "glVertex2d" );
+	dllVertex2d( x, y );
+}
+
+static void APIENTRY logVertex2dv(const GLdouble *v)
+{
+	SIG( "glVertex2dv" );
+	dllVertex2dv( v );
+}
+static void APIENTRY logVertex2f(GLfloat x, GLfloat y)
+{
+	SIG( "glVertex2f" );
+	dllVertex2f( x, y );
+}
+static void APIENTRY logVertex2fv(const GLfloat *v)
+{
+	SIG( "glVertex2fv" );
+	dllVertex2fv( v );
+}
+static void APIENTRY logVertex2i(GLint x, GLint y)
+{
+	SIG( "glVertex2i" );
+	dllVertex2i( x, y );
+}
+static void APIENTRY logVertex2iv(const GLint *v)
+{
+	SIG( "glVertex2iv" );
+	dllVertex2iv( v );
+}
+static void APIENTRY logVertex2s(GLshort x, GLshort y)
+{
+	SIG( "glVertex2s" );
+	dllVertex2s( x, y );
+}
+static void APIENTRY logVertex2sv(const GLshort *v)
+{
+	SIG( "glVertex2sv" );
+	dllVertex2sv( v );
+}
+static void APIENTRY logVertex3d(GLdouble x, GLdouble y, GLdouble z)
+{
+	SIG( "glVertex3d" );
+	dllVertex3d( x, y, z );
+}
+static void APIENTRY logVertex3dv(const GLdouble *v)
+{
+	SIG( "glVertex3dv" );
+	dllVertex3dv( v );
+}
+static void APIENTRY logVertex3f(GLfloat x, GLfloat y, GLfloat z)
+{
+	SIG( "glVertex3f" );
+	dllVertex3f( x, y, z );
+}
+static void APIENTRY logVertex3fv(const GLfloat *v)
+{
+	SIG( "glVertex3fv" );
+	dllVertex3fv( v );
+}
+static void APIENTRY logVertex3i(GLint x, GLint y, GLint z)
+{
+	SIG( "glVertex3i" );
+	dllVertex3i( x, y, z );
+}
+static void APIENTRY logVertex3iv(const GLint *v)
+{
+	SIG( "glVertex3iv" );
+	dllVertex3iv( v );
+}
+static void APIENTRY logVertex3s(GLshort x, GLshort y, GLshort z)
+{
+	SIG( "glVertex3s" );
+	dllVertex3s( x, y, z );
+}
+static void APIENTRY logVertex3sv(const GLshort *v)
+{
+	SIG( "glVertex3sv" );
+	dllVertex3sv( v );
+}
+static void APIENTRY logVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
+{
+	SIG( "glVertex4d" );
+	dllVertex4d( x, y, z, w );
+}
+static void APIENTRY logVertex4dv(const GLdouble *v)
+{
+	SIG( "glVertex4dv" );
+	dllVertex4dv( v );
+}
+static void APIENTRY logVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
+{
+	SIG( "glVertex4f" );
+	dllVertex4f( x, y, z, w );
+}
+static void APIENTRY logVertex4fv(const GLfloat *v)
+{
+	SIG( "glVertex4fv" );
+	dllVertex4fv( v );
+}
+static void APIENTRY logVertex4i(GLint x, GLint y, GLint z, GLint w)
+{
+	SIG( "glVertex4i" );
+	dllVertex4i( x, y, z, w );
+}
+static void APIENTRY logVertex4iv(const GLint *v)
+{
+	SIG( "glVertex4iv" );
+	dllVertex4iv( v );
+}
+static void APIENTRY logVertex4s(GLshort x, GLshort y, GLshort z, GLshort w)
+{
+	SIG( "glVertex4s" );
+	dllVertex4s( x, y, z, w );
+}
+static void APIENTRY logVertex4sv(const GLshort *v)
+{
+	SIG( "glVertex4sv" );
+	dllVertex4sv( v );
+}
+static void APIENTRY logVertexPointer(GLint size, GLenum type, GLsizei stride, const void *pointer)
+{
+	SIG( "glVertexPointer" );
+	dllVertexPointer( size, type, stride, pointer );
+}
+static void APIENTRY logViewport(GLint x, GLint y, GLsizei width, GLsizei height)
+{
+	SIG( "glViewport" );
+	dllViewport( x, y, width, height );
+}
+
+/*
+** QGL_Shutdown
+**
+** Unloads the specified DLL then nulls out all the proc pointers.
+*/
+void QGL_Shutdown( void )
+{
+	if ( glw_state.OpenGLLib )
+	{
+		dlclose ( glw_state.OpenGLLib );
+		glw_state.OpenGLLib = NULL;
+	}
+
+	glw_state.OpenGLLib = NULL;
+
+	qglAccum                     = NULL;
+	qglAlphaFunc                 = NULL;
+	qglAreTexturesResident       = NULL;
+	qglArrayElement              = NULL;
+	qglBegin                     = NULL;
+	qglBindTexture               = NULL;
+	qglBitmap                    = NULL;
+	qglBlendFunc                 = NULL;
+	qglCallList                  = NULL;
+	qglCallLists                 = NULL;
+	qglClear                     = NULL;
+	qglClearAccum                = NULL;
+	qglClearColor                = NULL;
+	qglClearDepth                = NULL;
+	qglClearIndex                = NULL;
+	qglClearStencil              = NULL;
+	qglClipPlane                 = NULL;
+	qglColor3b                   = NULL;
+	qglColor3bv                  = NULL;
+	qglColor3d                   = NULL;
+	qglColor3dv                  = NULL;
+	qglColor3f                   = NULL;
+	qglColor3fv                  = NULL;
+	qglColor3i                   = NULL;
+	qglColor3iv                  = NULL;
+	qglColor3s                   = NULL;
+	qglColor3sv                  = NULL;
+	qglColor3ub                  = NULL;
+	qglColor3ubv                 = NULL;
+	qglColor3ui                  = NULL;
+	qglColor3uiv                 = NULL;
+	qglColor3us                  = NULL;
+	qglColor3usv                 = NULL;
+	qglColor4b                   = NULL;
+	qglColor4bv                  = NULL;
+	qglColor4d                   = NULL;
+	qglColor4dv                  = NULL;
+	qglColor4f                   = NULL;
+	qglColor4fv                  = NULL;
+	qglColor4i                   = NULL;
+	qglColor4iv                  = NULL;
+	qglColor4s                   = NULL;
+	qglColor4sv                  = NULL;
+	qglColor4ub                  = NULL;
+	qglColor4ubv                 = NULL;
+	qglColor4ui                  = NULL;
+	qglColor4uiv                 = NULL;
+	qglColor4us                  = NULL;
+	qglColor4usv                 = NULL;
+	qglColorMask                 = NULL;
+	qglColorMaterial             = NULL;
+	qglColorPointer              = NULL;
+	qglCopyPixels                = NULL;
+	qglCopyTexImage1D            = NULL;
+	qglCopyTexImage2D            = NULL;
+	qglCopyTexSubImage1D         = NULL;
+	qglCopyTexSubImage2D         = NULL;
+	qglCullFace                  = NULL;
+	qglDeleteLists               = NULL;
+	qglDeleteTextures            = NULL;
+	qglDepthFunc                 = NULL;
+	qglDepthMask                 = NULL;
+	qglDepthRange                = NULL;
+	qglDisable                   = NULL;
+	qglDisableClientState        = NULL;
+	qglDrawArrays                = NULL;
+	qglDrawBuffer                = NULL;
+	qglDrawElements              = NULL;
+	qglDrawPixels                = NULL;
+	qglEdgeFlag                  = NULL;
+	qglEdgeFlagPointer           = NULL;
+	qglEdgeFlagv                 = NULL;
+	qglEnable                    = NULL;
+	qglEnableClientState         = NULL;
+	qglEnd                       = NULL;
+	qglEndList                   = NULL;
+	qglEvalCoord1d               = NULL;
+	qglEvalCoord1dv              = NULL;
+	qglEvalCoord1f               = NULL;
+	qglEvalCoord1fv              = NULL;
+	qglEvalCoord2d               = NULL;
+	qglEvalCoord2dv              = NULL;
+	qglEvalCoord2f               = NULL;
+	qglEvalCoord2fv              = NULL;
+	qglEvalMesh1                 = NULL;
+	qglEvalMesh2                 = NULL;
+	qglEvalPoint1                = NULL;
+	qglEvalPoint2                = NULL;
+	qglFeedbackBuffer            = NULL;
+	qglFinish                    = NULL;
+	qglFlush                     = NULL;
+	qglFogf                      = NULL;
+	qglFogfv                     = NULL;
+	qglFogi                      = NULL;
+	qglFogiv                     = NULL;
+	qglFrontFace                 = NULL;
+	qglFrustum                   = NULL;
+	qglGenLists                  = NULL;
+	qglGenTextures               = NULL;
+	qglGetBooleanv               = NULL;
+	qglGetClipPlane              = NULL;
+	qglGetDoublev                = NULL;
+	qglGetError                  = NULL;
+	qglGetFloatv                 = NULL;
+	qglGetIntegerv               = NULL;
+	qglGetLightfv                = NULL;
+	qglGetLightiv                = NULL;
+	qglGetMapdv                  = NULL;
+	qglGetMapfv                  = NULL;
+	qglGetMapiv                  = NULL;
+	qglGetMaterialfv             = NULL;
+	qglGetMaterialiv             = NULL;
+	qglGetPixelMapfv             = NULL;
+	qglGetPixelMapuiv            = NULL;
+	qglGetPixelMapusv            = NULL;
+	qglGetPointerv               = NULL;
+	qglGetPolygonStipple         = NULL;
+	qglGetString                 = NULL;
+	qglGetTexEnvfv               = NULL;
+	qglGetTexEnviv               = NULL;
+	qglGetTexGendv               = NULL;
+	qglGetTexGenfv               = NULL;
+	qglGetTexGeniv               = NULL;
+	qglGetTexImage               = NULL;
+	qglGetTexLevelParameterfv    = NULL;
+	qglGetTexLevelParameteriv    = NULL;
+	qglGetTexParameterfv         = NULL;
+	qglGetTexParameteriv         = NULL;
+	qglHint                      = NULL;
+	qglIndexMask                 = NULL;
+	qglIndexPointer              = NULL;
+	qglIndexd                    = NULL;
+	qglIndexdv                   = NULL;
+	qglIndexf                    = NULL;
+	qglIndexfv                   = NULL;
+	qglIndexi                    = NULL;
+	qglIndexiv                   = NULL;
+	qglIndexs                    = NULL;
+	qglIndexsv                   = NULL;
+	qglIndexub                   = NULL;
+	qglIndexubv                  = NULL;
+	qglInitNames                 = NULL;
+	qglInterleavedArrays         = NULL;
+	qglIsEnabled                 = NULL;
+	qglIsList                    = NULL;
+	qglIsTexture                 = NULL;
+	qglLightModelf               = NULL;
+	qglLightModelfv              = NULL;
+	qglLightModeli               = NULL;
+	qglLightModeliv              = NULL;
+	qglLightf                    = NULL;
+	qglLightfv                   = NULL;
+	qglLighti                    = NULL;
+	qglLightiv                   = NULL;
+	qglLineStipple               = NULL;
+	qglLineWidth                 = NULL;
+	qglListBase                  = NULL;
+	qglLoadIdentity              = NULL;
+	qglLoadMatrixd               = NULL;
+	qglLoadMatrixf               = NULL;
+	qglLoadName                  = NULL;
+	qglLogicOp                   = NULL;
+	qglMap1d                     = NULL;
+	qglMap1f                     = NULL;
+	qglMap2d                     = NULL;
+	qglMap2f                     = NULL;
+	qglMapGrid1d                 = NULL;
+	qglMapGrid1f                 = NULL;
+	qglMapGrid2d                 = NULL;
+	qglMapGrid2f                 = NULL;
+	qglMaterialf                 = NULL;
+	qglMaterialfv                = NULL;
+	qglMateriali                 = NULL;
+	qglMaterialiv                = NULL;
+	qglMatrixMode                = NULL;
+	qglMultMatrixd               = NULL;
+	qglMultMatrixf               = NULL;
+	qglNewList                   = NULL;
+	qglNormal3b                  = NULL;
+	qglNormal3bv                 = NULL;
+	qglNormal3d                  = NULL;
+	qglNormal3dv                 = NULL;
+	qglNormal3f                  = NULL;
+	qglNormal3fv                 = NULL;
+	qglNormal3i                  = NULL;
+	qglNormal3iv                 = NULL;
+	qglNormal3s                  = NULL;
+	qglNormal3sv                 = NULL;
+	qglNormalPointer             = NULL;
+	qglOrtho                     = NULL;
+	qglPassThrough               = NULL;
+	qglPixelMapfv                = NULL;
+	qglPixelMapuiv               = NULL;
+	qglPixelMapusv               = NULL;
+	qglPixelStoref               = NULL;
+	qglPixelStorei               = NULL;
+	qglPixelTransferf            = NULL;
+	qglPixelTransferi            = NULL;
+	qglPixelZoom                 = NULL;
+	qglPointSize                 = NULL;
+	qglPolygonMode               = NULL;
+	qglPolygonOffset             = NULL;
+	qglPolygonStipple            = NULL;
+	qglPopAttrib                 = NULL;
+	qglPopClientAttrib           = NULL;
+	qglPopMatrix                 = NULL;
+	qglPopName                   = NULL;
+	qglPrioritizeTextures        = NULL;
+	qglPushAttrib                = NULL;
+	qglPushClientAttrib          = NULL;
+	qglPushMatrix                = NULL;
+	qglPushName                  = NULL;
+	qglRasterPos2d               = NULL;
+	qglRasterPos2dv              = NULL;
+	qglRasterPos2f               = NULL;
+	qglRasterPos2fv              = NULL;
+	qglRasterPos2i               = NULL;
+	qglRasterPos2iv              = NULL;
+	qglRasterPos2s               = NULL;
+	qglRasterPos2sv              = NULL;
+	qglRasterPos3d               = NULL;
+	qglRasterPos3dv              = NULL;
+	qglRasterPos3f               = NULL;
+	qglRasterPos3fv              = NULL;
+	qglRasterPos3i               = NULL;
+	qglRasterPos3iv              = NULL;
+	qglRasterPos3s               = NULL;
+	qglRasterPos3sv              = NULL;
+	qglRasterPos4d               = NULL;
+	qglRasterPos4dv              = NULL;
+	qglRasterPos4f               = NULL;
+	qglRasterPos4fv              = NULL;
+	qglRasterPos4i               = NULL;
+	qglRasterPos4iv              = NULL;
+	qglRasterPos4s               = NULL;
+	qglRasterPos4sv              = NULL;
+	qglReadBuffer                = NULL;
+	qglReadPixels                = NULL;
+	qglRectd                     = NULL;
+	qglRectdv                    = NULL;
+	qglRectf                     = NULL;
+	qglRectfv                    = NULL;
+	qglRecti                     = NULL;
+	qglRectiv                    = NULL;
+	qglRects                     = NULL;
+	qglRectsv                    = NULL;
+	qglRenderMode                = NULL;
+	qglRotated                   = NULL;
+	qglRotatef                   = NULL;
+	qglScaled                    = NULL;
+	qglScalef                    = NULL;
+	qglScissor                   = NULL;
+	qglSelectBuffer              = NULL;
+	qglShadeModel                = NULL;
+	qglStencilFunc               = NULL;
+	qglStencilMask               = NULL;
+	qglStencilOp                 = NULL;
+	qglTexCoord1d                = NULL;
+	qglTexCoord1dv               = NULL;
+	qglTexCoord1f                = NULL;
+	qglTexCoord1fv               = NULL;
+	qglTexCoord1i                = NULL;
+	qglTexCoord1iv               = NULL;
+	qglTexCoord1s                = NULL;
+	qglTexCoord1sv               = NULL;
+	qglTexCoord2d                = NULL;
+	qglTexCoord2dv               = NULL;
+	qglTexCoord2f                = NULL;
+	qglTexCoord2fv               = NULL;
+	qglTexCoord2i                = NULL;
+	qglTexCoord2iv               = NULL;
+	qglTexCoord2s                = NULL;
+	qglTexCoord2sv               = NULL;
+	qglTexCoord3d                = NULL;
+	qglTexCoord3dv               = NULL;
+	qglTexCoord3f                = NULL;
+	qglTexCoord3fv               = NULL;
+	qglTexCoord3i                = NULL;
+	qglTexCoord3iv               = NULL;
+	qglTexCoord3s                = NULL;
+	qglTexCoord3sv               = NULL;
+	qglTexCoord4d                = NULL;
+	qglTexCoord4dv               = NULL;
+	qglTexCoord4f                = NULL;
+	qglTexCoord4fv               = NULL;
+	qglTexCoord4i                = NULL;
+	qglTexCoord4iv               = NULL;
+	qglTexCoord4s                = NULL;
+	qglTexCoord4sv               = NULL;
+	qglTexCoordPointer           = NULL;
+	qglTexEnvf                   = NULL;
+	qglTexEnvfv                  = NULL;
+	qglTexEnvi                   = NULL;
+	qglTexEnviv                  = NULL;
+	qglTexGend                   = NULL;
+	qglTexGendv                  = NULL;
+	qglTexGenf                   = NULL;
+	qglTexGenfv                  = NULL;
+	qglTexGeni                   = NULL;
+	qglTexGeniv                  = NULL;
+	qglTexImage1D                = NULL;
+	qglTexImage2D                = NULL;
+	qglTexParameterf             = NULL;
+	qglTexParameterfv            = NULL;
+	qglTexParameteri             = NULL;
+	qglTexParameteriv            = NULL;
+	qglTexSubImage1D             = NULL;
+	qglTexSubImage2D             = NULL;
+	qglTranslated                = NULL;
+	qglTranslatef                = NULL;
+	qglVertex2d                  = NULL;
+	qglVertex2dv                 = NULL;
+	qglVertex2f                  = NULL;
+	qglVertex2fv                 = NULL;
+	qglVertex2i                  = NULL;
+	qglVertex2iv                 = NULL;
+	qglVertex2s                  = NULL;
+	qglVertex2sv                 = NULL;
+	qglVertex3d                  = NULL;
+	qglVertex3dv                 = NULL;
+	qglVertex3f                  = NULL;
+	qglVertex3fv                 = NULL;
+	qglVertex3i                  = NULL;
+	qglVertex3iv                 = NULL;
+	qglVertex3s                  = NULL;
+	qglVertex3sv                 = NULL;
+	qglVertex4d                  = NULL;
+	qglVertex4dv                 = NULL;
+	qglVertex4f                  = NULL;
+	qglVertex4fv                 = NULL;
+	qglVertex4i                  = NULL;
+	qglVertex4iv                 = NULL;
+	qglVertex4s                  = NULL;
+	qglVertex4sv                 = NULL;
+	qglVertexPointer             = NULL;
+	qglViewport                  = NULL;
+
+	qfxMesaCreateContext         = NULL;
+	qfxMesaCreateBestContext     = NULL;
+	qfxMesaDestroyContext        = NULL;
+	qfxMesaMakeCurrent           = NULL;
+	qfxMesaGetCurrentContext     = NULL;
+	qfxMesaSwapBuffers           = NULL;
+
+	qglXChooseVisual             = NULL;
+	qglXCreateContext            = NULL;
+	qglXDestroyContext           = NULL;
+	qglXMakeCurrent              = NULL;
+	qglXCopyContext              = NULL;
+	qglXSwapBuffers              = NULL;
+}
+
+#define GPA( a ) dlsym( glw_state.OpenGLLib, a )
+
+void *qwglGetProcAddress(char *symbol)
+{
+	if (glw_state.OpenGLLib)
+		return GPA ( symbol );
+	return NULL;
+}
+
+/*
+** QGL_Init
+**
+** This is responsible for binding our qgl function pointers to 
+** the appropriate GL stuff.  In Windows this means doing a 
+** LoadLibrary and a bunch of calls to GetProcAddress.  On other
+** operating systems we need to do the right thing, whatever that
+** might be.
+** 
+*/
+
+qboolean QGL_Init( const char *dllname )
+{
+#if 0 //FIXME
+	// update 3Dfx gamma irrespective of underlying DLL
+	{
+		char envbuffer[1024];
+		float g;
+
+		g = 2.00 * ( 0.8 - ( vid_gamma->value - 0.5 ) ) + 1.0F;
+		Com_sprintf( envbuffer, sizeof(envbuffer), "SSTV2_GAMMA=%f", g );
+		putenv( envbuffer );
+		Com_sprintf( envbuffer, sizeof(envbuffer), "SST_GAMMA=%f", g );
+		putenv( envbuffer );
+	}
+#endif
+
+	if ( ( glw_state.OpenGLLib = dlopen( dllname, RTLD_LAZY ) ) == 0 )
+	{
+		char	fn[1024];
+		FILE *fp;
+		extern uid_t saved_euid; // unix_main.c
+
+//fprintf(stdout, "uid=%d,euid=%d\n", getuid(), geteuid()); fflush(stdout);
+
+		// if we are not setuid, try current directory
+		if (getuid() == saved_euid) {
+			getcwd(fn, sizeof(fn));
+			Q_strcat(fn, sizeof(fn), "/");
+			Q_strcat(fn, sizeof(fn), dllname);
+
+			if ( ( glw_state.OpenGLLib = dlopen( fn, RTLD_LAZY ) ) == 0 ) {
+				ri.Printf(PRINT_ALL, "QGL_Init: Can't load %s from /etc/ld.so.conf or current dir: %s\n", dllname, dlerror());
+				return qfalse;
+			}
+		} else {
+			ri.Printf(PRINT_ALL, "QGL_Init: Can't load %s from /etc/ld.so.conf: %s\n", dllname, dlerror());
+			return qfalse;
+		}
+	}
+
+	qglAccum                     = dllAccum = GPA( "glAccum" );
+	qglAlphaFunc                 = dllAlphaFunc = GPA( "glAlphaFunc" );
+	qglAreTexturesResident       = dllAreTexturesResident = GPA( "glAreTexturesResident" );
+	qglArrayElement              = dllArrayElement = GPA( "glArrayElement" );
+	qglBegin                     = dllBegin = GPA( "glBegin" );
+	qglBindTexture               = dllBindTexture = GPA( "glBindTexture" );
+	qglBitmap                    = dllBitmap = GPA( "glBitmap" );
+	qglBlendFunc                 = dllBlendFunc = GPA( "glBlendFunc" );
+	qglCallList                  = dllCallList = GPA( "glCallList" );
+	qglCallLists                 = dllCallLists = GPA( "glCallLists" );
+	qglClear                     = dllClear = GPA( "glClear" );
+	qglClearAccum                = dllClearAccum = GPA( "glClearAccum" );
+	qglClearColor                = dllClearColor = GPA( "glClearColor" );
+	qglClearDepth                = dllClearDepth = GPA( "glClearDepth" );
+	qglClearIndex                = dllClearIndex = GPA( "glClearIndex" );
+	qglClearStencil              = dllClearStencil = GPA( "glClearStencil" );
+	qglClipPlane                 = dllClipPlane = GPA( "glClipPlane" );
+	qglColor3b                   = dllColor3b = GPA( "glColor3b" );
+	qglColor3bv                  = dllColor3bv = GPA( "glColor3bv" );
+	qglColor3d                   = dllColor3d = GPA( "glColor3d" );
+	qglColor3dv                  = dllColor3dv = GPA( "glColor3dv" );
+	qglColor3f                   = dllColor3f = GPA( "glColor3f" );
+	qglColor3fv                  = dllColor3fv = GPA( "glColor3fv" );
+	qglColor3i                   = dllColor3i = GPA( "glColor3i" );
+	qglColor3iv                  = dllColor3iv = GPA( "glColor3iv" );
+	qglColor3s                   = dllColor3s = GPA( "glColor3s" );
+	qglColor3sv                  = dllColor3sv = GPA( "glColor3sv" );
+	qglColor3ub                  = dllColor3ub = GPA( "glColor3ub" );
+	qglColor3ubv                 = dllColor3ubv = GPA( "glColor3ubv" );
+	qglColor3ui                  = dllColor3ui = GPA( "glColor3ui" );
+	qglColor3uiv                 = dllColor3uiv = GPA( "glColor3uiv" );
+	qglColor3us                  = dllColor3us = GPA( "glColor3us" );
+	qglColor3usv                 = dllColor3usv = GPA( "glColor3usv" );
+	qglColor4b                   = dllColor4b = GPA( "glColor4b" );
+	qglColor4bv                  = dllColor4bv = GPA( "glColor4bv" );
+	qglColor4d                   = dllColor4d = GPA( "glColor4d" );
+	qglColor4dv                  = dllColor4dv = GPA( "glColor4dv" );
+	qglColor4f                   = dllColor4f = GPA( "glColor4f" );
+	qglColor4fv                  = dllColor4fv = GPA( "glColor4fv" );
+	qglColor4i                   = dllColor4i = GPA( "glColor4i" );
+	qglColor4iv                  = dllColor4iv = GPA( "glColor4iv" );
+	qglColor4s                   = dllColor4s = GPA( "glColor4s" );
+	qglColor4sv                  = dllColor4sv = GPA( "glColor4sv" );
+	qglColor4ub                  = dllColor4ub = GPA( "glColor4ub" );
+	qglColor4ubv                 = dllColor4ubv = GPA( "glColor4ubv" );
+	qglColor4ui                  = dllColor4ui = GPA( "glColor4ui" );
+	qglColor4uiv                 = dllColor4uiv = GPA( "glColor4uiv" );
+	qglColor4us                  = dllColor4us = GPA( "glColor4us" );
+	qglColor4usv                 = dllColor4usv = GPA( "glColor4usv" );
+	qglColorMask                 = dllColorMask = GPA( "glColorMask" );
+	qglColorMaterial             = dllColorMaterial = GPA( "glColorMaterial" );
+	qglColorPointer              = dllColorPointer = GPA( "glColorPointer" );
+	qglCopyPixels                = dllCopyPixels = GPA( "glCopyPixels" );
+	qglCopyTexImage1D            = dllCopyTexImage1D = GPA( "glCopyTexImage1D" );
+	qglCopyTexImage2D            = dllCopyTexImage2D = GPA( "glCopyTexImage2D" );
+	qglCopyTexSubImage1D         = dllCopyTexSubImage1D = GPA( "glCopyTexSubImage1D" );
+	qglCopyTexSubImage2D         = dllCopyTexSubImage2D = GPA( "glCopyTexSubImage2D" );
+	qglCullFace                  = dllCullFace = GPA( "glCullFace" );
+	qglDeleteLists               = dllDeleteLists = GPA( "glDeleteLists" );
+	qglDeleteTextures            = dllDeleteTextures = GPA( "glDeleteTextures" );
+	qglDepthFunc                 = dllDepthFunc = GPA( "glDepthFunc" );
+	qglDepthMask                 = dllDepthMask = GPA( "glDepthMask" );
+	qglDepthRange                = dllDepthRange = GPA( "glDepthRange" );
+	qglDisable                   = dllDisable = GPA( "glDisable" );
+	qglDisableClientState        = dllDisableClientState = GPA( "glDisableClientState" );
+	qglDrawArrays                = dllDrawArrays = GPA( "glDrawArrays" );
+	qglDrawBuffer                = dllDrawBuffer = GPA( "glDrawBuffer" );
+	qglDrawElements              = dllDrawElements = GPA( "glDrawElements" );
+	qglDrawPixels                = dllDrawPixels = GPA( "glDrawPixels" );
+	qglEdgeFlag                  = dllEdgeFlag = GPA( "glEdgeFlag" );
+	qglEdgeFlagPointer           = dllEdgeFlagPointer = GPA( "glEdgeFlagPointer" );
+	qglEdgeFlagv                 = dllEdgeFlagv = GPA( "glEdgeFlagv" );
+	qglEnable                    = 	dllEnable                    = GPA( "glEnable" );
+	qglEnableClientState         = 	dllEnableClientState         = GPA( "glEnableClientState" );
+	qglEnd                       = 	dllEnd                       = GPA( "glEnd" );
+	qglEndList                   = 	dllEndList                   = GPA( "glEndList" );
+	qglEvalCoord1d				 = 	dllEvalCoord1d				 = GPA( "glEvalCoord1d" );
+	qglEvalCoord1dv              = 	dllEvalCoord1dv              = GPA( "glEvalCoord1dv" );
+	qglEvalCoord1f               = 	dllEvalCoord1f               = GPA( "glEvalCoord1f" );
+	qglEvalCoord1fv              = 	dllEvalCoord1fv              = GPA( "glEvalCoord1fv" );
+	qglEvalCoord2d               = 	dllEvalCoord2d               = GPA( "glEvalCoord2d" );
+	qglEvalCoord2dv              = 	dllEvalCoord2dv              = GPA( "glEvalCoord2dv" );
+	qglEvalCoord2f               = 	dllEvalCoord2f               = GPA( "glEvalCoord2f" );
+	qglEvalCoord2fv              = 	dllEvalCoord2fv              = GPA( "glEvalCoord2fv" );
+	qglEvalMesh1                 = 	dllEvalMesh1                 = GPA( "glEvalMesh1" );
+	qglEvalMesh2                 = 	dllEvalMesh2                 = GPA( "glEvalMesh2" );
+	qglEvalPoint1                = 	dllEvalPoint1                = GPA( "glEvalPoint1" );
+	qglEvalPoint2                = 	dllEvalPoint2                = GPA( "glEvalPoint2" );
+	qglFeedbackBuffer            = 	dllFeedbackBuffer            = GPA( "glFeedbackBuffer" );
+	qglFinish                    = 	dllFinish                    = GPA( "glFinish" );
+	qglFlush                     = 	dllFlush                     = GPA( "glFlush" );
+	qglFogf                      = 	dllFogf                      = GPA( "glFogf" );
+	qglFogfv                     = 	dllFogfv                     = GPA( "glFogfv" );
+	qglFogi                      = 	dllFogi                      = GPA( "glFogi" );
+	qglFogiv                     = 	dllFogiv                     = GPA( "glFogiv" );
+	qglFrontFace                 = 	dllFrontFace                 = GPA( "glFrontFace" );
+	qglFrustum                   = 	dllFrustum                   = GPA( "glFrustum" );
+	qglGenLists                  = 	dllGenLists                  = GPA( "glGenLists" );
+	qglGenTextures               = 	dllGenTextures               = GPA( "glGenTextures" );
+	qglGetBooleanv               = 	dllGetBooleanv               = GPA( "glGetBooleanv" );
+	qglGetClipPlane              = 	dllGetClipPlane              = GPA( "glGetClipPlane" );
+	qglGetDoublev                = 	dllGetDoublev                = GPA( "glGetDoublev" );
+	qglGetError                  = 	dllGetError                  = GPA( "glGetError" );
+	qglGetFloatv                 = 	dllGetFloatv                 = GPA( "glGetFloatv" );
+	qglGetIntegerv               = 	dllGetIntegerv               = GPA( "glGetIntegerv" );
+	qglGetLightfv                = 	dllGetLightfv                = GPA( "glGetLightfv" );
+	qglGetLightiv                = 	dllGetLightiv                = GPA( "glGetLightiv" );
+	qglGetMapdv                  = 	dllGetMapdv                  = GPA( "glGetMapdv" );
+	qglGetMapfv                  = 	dllGetMapfv                  = GPA( "glGetMapfv" );
+	qglGetMapiv                  = 	dllGetMapiv                  = GPA( "glGetMapiv" );
+	qglGetMaterialfv             = 	dllGetMaterialfv             = GPA( "glGetMaterialfv" );
+	qglGetMaterialiv             = 	dllGetMaterialiv             = GPA( "glGetMaterialiv" );
+	qglGetPixelMapfv             = 	dllGetPixelMapfv             = GPA( "glGetPixelMapfv" );
+	qglGetPixelMapuiv            = 	dllGetPixelMapuiv            = GPA( "glGetPixelMapuiv" );
+	qglGetPixelMapusv            = 	dllGetPixelMapusv            = GPA( "glGetPixelMapusv" );
+	qglGetPointerv               = 	dllGetPointerv               = GPA( "glGetPointerv" );
+	qglGetPolygonStipple         = 	dllGetPolygonStipple         = GPA( "glGetPolygonStipple" );
+	qglGetString                 = 	dllGetString                 = GPA( "glGetString" );
+	qglGetTexEnvfv               = 	dllGetTexEnvfv               = GPA( "glGetTexEnvfv" );
+	qglGetTexEnviv               = 	dllGetTexEnviv               = GPA( "glGetTexEnviv" );
+	qglGetTexGendv               = 	dllGetTexGendv               = GPA( "glGetTexGendv" );
+	qglGetTexGenfv               = 	dllGetTexGenfv               = GPA( "glGetTexGenfv" );
+	qglGetTexGeniv               = 	dllGetTexGeniv               = GPA( "glGetTexGeniv" );
+	qglGetTexImage               = 	dllGetTexImage               = GPA( "glGetTexImage" );
+	qglGetTexLevelParameterfv    = 	dllGetTexLevelParameterfv    = GPA( "glGetLevelParameterfv" );
+	qglGetTexLevelParameteriv    = 	dllGetTexLevelParameteriv    = GPA( "glGetLevelParameteriv" );
+	qglGetTexParameterfv         = 	dllGetTexParameterfv         = GPA( "glGetTexParameterfv" );
+	qglGetTexParameteriv         = 	dllGetTexParameteriv         = GPA( "glGetTexParameteriv" );
+	qglHint                      = 	dllHint                      = GPA( "glHint" );
+	qglIndexMask                 = 	dllIndexMask                 = GPA( "glIndexMask" );
+	qglIndexPointer              = 	dllIndexPointer              = GPA( "glIndexPointer" );
+	qglIndexd                    = 	dllIndexd                    = GPA( "glIndexd" );
+	qglIndexdv                   = 	dllIndexdv                   = GPA( "glIndexdv" );
+	qglIndexf                    = 	dllIndexf                    = GPA( "glIndexf" );
+	qglIndexfv                   = 	dllIndexfv                   = GPA( "glIndexfv" );
+	qglIndexi                    = 	dllIndexi                    = GPA( "glIndexi" );
+	qglIndexiv                   = 	dllIndexiv                   = GPA( "glIndexiv" );
+	qglIndexs                    = 	dllIndexs                    = GPA( "glIndexs" );
+	qglIndexsv                   = 	dllIndexsv                   = GPA( "glIndexsv" );
+	qglIndexub                   = 	dllIndexub                   = GPA( "glIndexub" );
+	qglIndexubv                  = 	dllIndexubv                  = GPA( "glIndexubv" );
+	qglInitNames                 = 	dllInitNames                 = GPA( "glInitNames" );
+	qglInterleavedArrays         = 	dllInterleavedArrays         = GPA( "glInterleavedArrays" );
+	qglIsEnabled                 = 	dllIsEnabled                 = GPA( "glIsEnabled" );
+	qglIsList                    = 	dllIsList                    = GPA( "glIsList" );
+	qglIsTexture                 = 	dllIsTexture                 = GPA( "glIsTexture" );
+	qglLightModelf               = 	dllLightModelf               = GPA( "glLightModelf" );
+	qglLightModelfv              = 	dllLightModelfv              = GPA( "glLightModelfv" );
+	qglLightModeli               = 	dllLightModeli               = GPA( "glLightModeli" );
+	qglLightModeliv              = 	dllLightModeliv              = GPA( "glLightModeliv" );
+	qglLightf                    = 	dllLightf                    = GPA( "glLightf" );
+	qglLightfv                   = 	dllLightfv                   = GPA( "glLightfv" );
+	qglLighti                    = 	dllLighti                    = GPA( "glLighti" );
+	qglLightiv                   = 	dllLightiv                   = GPA( "glLightiv" );
+	qglLineStipple               = 	dllLineStipple               = GPA( "glLineStipple" );
+	qglLineWidth                 = 	dllLineWidth                 = GPA( "glLineWidth" );
+	qglListBase                  = 	dllListBase                  = GPA( "glListBase" );
+	qglLoadIdentity              = 	dllLoadIdentity              = GPA( "glLoadIdentity" );
+	qglLoadMatrixd               = 	dllLoadMatrixd               = GPA( "glLoadMatrixd" );
+	qglLoadMatrixf               = 	dllLoadMatrixf               = GPA( "glLoadMatrixf" );
+	qglLoadName                  = 	dllLoadName                  = GPA( "glLoadName" );
+	qglLogicOp                   = 	dllLogicOp                   = GPA( "glLogicOp" );
+	qglMap1d                     = 	dllMap1d                     = GPA( "glMap1d" );
+	qglMap1f                     = 	dllMap1f                     = GPA( "glMap1f" );
+	qglMap2d                     = 	dllMap2d                     = GPA( "glMap2d" );
+	qglMap2f                     = 	dllMap2f                     = GPA( "glMap2f" );
+	qglMapGrid1d                 = 	dllMapGrid1d                 = GPA( "glMapGrid1d" );
+	qglMapGrid1f                 = 	dllMapGrid1f                 = GPA( "glMapGrid1f" );
+	qglMapGrid2d                 = 	dllMapGrid2d                 = GPA( "glMapGrid2d" );
+	qglMapGrid2f                 = 	dllMapGrid2f                 = GPA( "glMapGrid2f" );
+	qglMaterialf                 = 	dllMaterialf                 = GPA( "glMaterialf" );
+	qglMaterialfv                = 	dllMaterialfv                = GPA( "glMaterialfv" );
+	qglMateriali                 = 	dllMateriali                 = GPA( "glMateriali" );
+	qglMaterialiv                = 	dllMaterialiv                = GPA( "glMaterialiv" );
+	qglMatrixMode                = 	dllMatrixMode                = GPA( "glMatrixMode" );
+	qglMultMatrixd               = 	dllMultMatrixd               = GPA( "glMultMatrixd" );
+	qglMultMatrixf               = 	dllMultMatrixf               = GPA( "glMultMatrixf" );
+	qglNewList                   = 	dllNewList                   = GPA( "glNewList" );
+	qglNormal3b                  = 	dllNormal3b                  = GPA( "glNormal3b" );
+	qglNormal3bv                 = 	dllNormal3bv                 = GPA( "glNormal3bv" );
+	qglNormal3d                  = 	dllNormal3d                  = GPA( "glNormal3d" );
+	qglNormal3dv                 = 	dllNormal3dv                 = GPA( "glNormal3dv" );
+	qglNormal3f                  = 	dllNormal3f                  = GPA( "glNormal3f" );
+	qglNormal3fv                 = 	dllNormal3fv                 = GPA( "glNormal3fv" );
+	qglNormal3i                  = 	dllNormal3i                  = GPA( "glNormal3i" );
+	qglNormal3iv                 = 	dllNormal3iv                 = GPA( "glNormal3iv" );
+	qglNormal3s                  = 	dllNormal3s                  = GPA( "glNormal3s" );
+	qglNormal3sv                 = 	dllNormal3sv                 = GPA( "glNormal3sv" );
+	qglNormalPointer             = 	dllNormalPointer             = GPA( "glNormalPointer" );
+	qglOrtho                     = 	dllOrtho                     = GPA( "glOrtho" );
+	qglPassThrough               = 	dllPassThrough               = GPA( "glPassThrough" );
+	qglPixelMapfv                = 	dllPixelMapfv                = GPA( "glPixelMapfv" );
+	qglPixelMapuiv               = 	dllPixelMapuiv               = GPA( "glPixelMapuiv" );
+	qglPixelMapusv               = 	dllPixelMapusv               = GPA( "glPixelMapusv" );
+	qglPixelStoref               = 	dllPixelStoref               = GPA( "glPixelStoref" );
+	qglPixelStorei               = 	dllPixelStorei               = GPA( "glPixelStorei" );
+	qglPixelTransferf            = 	dllPixelTransferf            = GPA( "glPixelTransferf" );
+	qglPixelTransferi            = 	dllPixelTransferi            = GPA( "glPixelTransferi" );
+	qglPixelZoom                 = 	dllPixelZoom                 = GPA( "glPixelZoom" );
+	qglPointSize                 = 	dllPointSize                 = GPA( "glPointSize" );
+	qglPolygonMode               = 	dllPolygonMode               = GPA( "glPolygonMode" );
+	qglPolygonOffset             = 	dllPolygonOffset             = GPA( "glPolygonOffset" );
+	qglPolygonStipple            = 	dllPolygonStipple            = GPA( "glPolygonStipple" );
+	qglPopAttrib                 = 	dllPopAttrib                 = GPA( "glPopAttrib" );
+	qglPopClientAttrib           = 	dllPopClientAttrib           = GPA( "glPopClientAttrib" );
+	qglPopMatrix                 = 	dllPopMatrix                 = GPA( "glPopMatrix" );
+	qglPopName                   = 	dllPopName                   = GPA( "glPopName" );
+	qglPrioritizeTextures        = 	dllPrioritizeTextures        = GPA( "glPrioritizeTextures" );
+	qglPushAttrib                = 	dllPushAttrib                = GPA( "glPushAttrib" );
+	qglPushClientAttrib          = 	dllPushClientAttrib          = GPA( "glPushClientAttrib" );
+	qglPushMatrix                = 	dllPushMatrix                = GPA( "glPushMatrix" );
+	qglPushName                  = 	dllPushName                  = GPA( "glPushName" );
+	qglRasterPos2d               = 	dllRasterPos2d               = GPA( "glRasterPos2d" );
+	qglRasterPos2dv              = 	dllRasterPos2dv              = GPA( "glRasterPos2dv" );
+	qglRasterPos2f               = 	dllRasterPos2f               = GPA( "glRasterPos2f" );
+	qglRasterPos2fv              = 	dllRasterPos2fv              = GPA( "glRasterPos2fv" );
+	qglRasterPos2i               = 	dllRasterPos2i               = GPA( "glRasterPos2i" );
+	qglRasterPos2iv              = 	dllRasterPos2iv              = GPA( "glRasterPos2iv" );
+	qglRasterPos2s               = 	dllRasterPos2s               = GPA( "glRasterPos2s" );
+	qglRasterPos2sv              = 	dllRasterPos2sv              = GPA( "glRasterPos2sv" );
+	qglRasterPos3d               = 	dllRasterPos3d               = GPA( "glRasterPos3d" );
+	qglRasterPos3dv              = 	dllRasterPos3dv              = GPA( "glRasterPos3dv" );
+	qglRasterPos3f               = 	dllRasterPos3f               = GPA( "glRasterPos3f" );
+	qglRasterPos3fv              = 	dllRasterPos3fv              = GPA( "glRasterPos3fv" );
+	qglRasterPos3i               = 	dllRasterPos3i               = GPA( "glRasterPos3i" );
+	qglRasterPos3iv              = 	dllRasterPos3iv              = GPA( "glRasterPos3iv" );
+	qglRasterPos3s               = 	dllRasterPos3s               = GPA( "glRasterPos3s" );
+	qglRasterPos3sv              = 	dllRasterPos3sv              = GPA( "glRasterPos3sv" );
+	qglRasterPos4d               = 	dllRasterPos4d               = GPA( "glRasterPos4d" );
+	qglRasterPos4dv              = 	dllRasterPos4dv              = GPA( "glRasterPos4dv" );
+	qglRasterPos4f               = 	dllRasterPos4f               = GPA( "glRasterPos4f" );
+	qglRasterPos4fv              = 	dllRasterPos4fv              = GPA( "glRasterPos4fv" );
+	qglRasterPos4i               = 	dllRasterPos4i               = GPA( "glRasterPos4i" );
+	qglRasterPos4iv              = 	dllRasterPos4iv              = GPA( "glRasterPos4iv" );
+	qglRasterPos4s               = 	dllRasterPos4s               = GPA( "glRasterPos4s" );
+	qglRasterPos4sv              = 	dllRasterPos4sv              = GPA( "glRasterPos4sv" );
+	qglReadBuffer                = 	dllReadBuffer                = GPA( "glReadBuffer" );
+	qglReadPixels                = 	dllReadPixels                = GPA( "glReadPixels" );
+	qglRectd                     = 	dllRectd                     = GPA( "glRectd" );
+	qglRectdv                    = 	dllRectdv                    = GPA( "glRectdv" );
+	qglRectf                     = 	dllRectf                     = GPA( "glRectf" );
+	qglRectfv                    = 	dllRectfv                    = GPA( "glRectfv" );
+	qglRecti                     = 	dllRecti                     = GPA( "glRecti" );
+	qglRectiv                    = 	dllRectiv                    = GPA( "glRectiv" );
+	qglRects                     = 	dllRects                     = GPA( "glRects" );
+	qglRectsv                    = 	dllRectsv                    = GPA( "glRectsv" );
+	qglRenderMode                = 	dllRenderMode                = GPA( "glRenderMode" );
+	qglRotated                   = 	dllRotated                   = GPA( "glRotated" );
+	qglRotatef                   = 	dllRotatef                   = GPA( "glRotatef" );
+	qglScaled                    = 	dllScaled                    = GPA( "glScaled" );
+	qglScalef                    = 	dllScalef                    = GPA( "glScalef" );
+	qglScissor                   = 	dllScissor                   = GPA( "glScissor" );
+	qglSelectBuffer              = 	dllSelectBuffer              = GPA( "glSelectBuffer" );
+	qglShadeModel                = 	dllShadeModel                = GPA( "glShadeModel" );
+	qglStencilFunc               = 	dllStencilFunc               = GPA( "glStencilFunc" );
+	qglStencilMask               = 	dllStencilMask               = GPA( "glStencilMask" );
+	qglStencilOp                 = 	dllStencilOp                 = GPA( "glStencilOp" );
+	qglTexCoord1d                = 	dllTexCoord1d                = GPA( "glTexCoord1d" );
+	qglTexCoord1dv               = 	dllTexCoord1dv               = GPA( "glTexCoord1dv" );
+	qglTexCoord1f                = 	dllTexCoord1f                = GPA( "glTexCoord1f" );
+	qglTexCoord1fv               = 	dllTexCoord1fv               = GPA( "glTexCoord1fv" );
+	qglTexCoord1i                = 	dllTexCoord1i                = GPA( "glTexCoord1i" );
+	qglTexCoord1iv               = 	dllTexCoord1iv               = GPA( "glTexCoord1iv" );
+	qglTexCoord1s                = 	dllTexCoord1s                = GPA( "glTexCoord1s" );
+	qglTexCoord1sv               = 	dllTexCoord1sv               = GPA( "glTexCoord1sv" );
+	qglTexCoord2d                = 	dllTexCoord2d                = GPA( "glTexCoord2d" );
+	qglTexCoord2dv               = 	dllTexCoord2dv               = GPA( "glTexCoord2dv" );
+	qglTexCoord2f                = 	dllTexCoord2f                = GPA( "glTexCoord2f" );
+	qglTexCoord2fv               = 	dllTexCoord2fv               = GPA( "glTexCoord2fv" );
+	qglTexCoord2i                = 	dllTexCoord2i                = GPA( "glTexCoord2i" );
+	qglTexCoord2iv               = 	dllTexCoord2iv               = GPA( "glTexCoord2iv" );
+	qglTexCoord2s                = 	dllTexCoord2s                = GPA( "glTexCoord2s" );
+	qglTexCoord2sv               = 	dllTexCoord2sv               = GPA( "glTexCoord2sv" );
+	qglTexCoord3d                = 	dllTexCoord3d                = GPA( "glTexCoord3d" );
+	qglTexCoord3dv               = 	dllTexCoord3dv               = GPA( "glTexCoord3dv" );
+	qglTexCoord3f                = 	dllTexCoord3f                = GPA( "glTexCoord3f" );
+	qglTexCoord3fv               = 	dllTexCoord3fv               = GPA( "glTexCoord3fv" );
+	qglTexCoord3i                = 	dllTexCoord3i                = GPA( "glTexCoord3i" );
+	qglTexCoord3iv               = 	dllTexCoord3iv               = GPA( "glTexCoord3iv" );
+	qglTexCoord3s                = 	dllTexCoord3s                = GPA( "glTexCoord3s" );
+	qglTexCoord3sv               = 	dllTexCoord3sv               = GPA( "glTexCoord3sv" );
+	qglTexCoord4d                = 	dllTexCoord4d                = GPA( "glTexCoord4d" );
+	qglTexCoord4dv               = 	dllTexCoord4dv               = GPA( "glTexCoord4dv" );
+	qglTexCoord4f                = 	dllTexCoord4f                = GPA( "glTexCoord4f" );
+	qglTexCoord4fv               = 	dllTexCoord4fv               = GPA( "glTexCoord4fv" );
+	qglTexCoord4i                = 	dllTexCoord4i                = GPA( "glTexCoord4i" );
+	qglTexCoord4iv               = 	dllTexCoord4iv               = GPA( "glTexCoord4iv" );
+	qglTexCoord4s                = 	dllTexCoord4s                = GPA( "glTexCoord4s" );
+	qglTexCoord4sv               = 	dllTexCoord4sv               = GPA( "glTexCoord4sv" );
+	qglTexCoordPointer           = 	dllTexCoordPointer           = GPA( "glTexCoordPointer" );
+	qglTexEnvf                   = 	dllTexEnvf                   = GPA( "glTexEnvf" );
+	qglTexEnvfv                  = 	dllTexEnvfv                  = GPA( "glTexEnvfv" );
+	qglTexEnvi                   = 	dllTexEnvi                   = GPA( "glTexEnvi" );
+	qglTexEnviv                  = 	dllTexEnviv                  = GPA( "glTexEnviv" );
+	qglTexGend                   = 	dllTexGend                   = GPA( "glTexGend" );
+	qglTexGendv                  = 	dllTexGendv                  = GPA( "glTexGendv" );
+	qglTexGenf                   = 	dllTexGenf                   = GPA( "glTexGenf" );
+	qglTexGenfv                  = 	dllTexGenfv                  = GPA( "glTexGenfv" );
+	qglTexGeni                   = 	dllTexGeni                   = GPA( "glTexGeni" );
+	qglTexGeniv                  = 	dllTexGeniv                  = GPA( "glTexGeniv" );
+	qglTexImage1D                = 	dllTexImage1D                = GPA( "glTexImage1D" );
+	qglTexImage2D                = 	dllTexImage2D                = GPA( "glTexImage2D" );
+	qglTexParameterf             = 	dllTexParameterf             = GPA( "glTexParameterf" );
+	qglTexParameterfv            = 	dllTexParameterfv            = GPA( "glTexParameterfv" );
+	qglTexParameteri             = 	dllTexParameteri             = GPA( "glTexParameteri" );
+	qglTexParameteriv            = 	dllTexParameteriv            = GPA( "glTexParameteriv" );
+	qglTexSubImage1D             = 	dllTexSubImage1D             = GPA( "glTexSubImage1D" );
+	qglTexSubImage2D             = 	dllTexSubImage2D             = GPA( "glTexSubImage2D" );
+	qglTranslated                = 	dllTranslated                = GPA( "glTranslated" );
+	qglTranslatef                = 	dllTranslatef                = GPA( "glTranslatef" );
+	qglVertex2d                  = 	dllVertex2d                  = GPA( "glVertex2d" );
+	qglVertex2dv                 = 	dllVertex2dv                 = GPA( "glVertex2dv" );
+	qglVertex2f                  = 	dllVertex2f                  = GPA( "glVertex2f" );
+	qglVertex2fv                 = 	dllVertex2fv                 = GPA( "glVertex2fv" );
+	qglVertex2i                  = 	dllVertex2i                  = GPA( "glVertex2i" );
+	qglVertex2iv                 = 	dllVertex2iv                 = GPA( "glVertex2iv" );
+	qglVertex2s                  = 	dllVertex2s                  = GPA( "glVertex2s" );
+	qglVertex2sv                 = 	dllVertex2sv                 = GPA( "glVertex2sv" );
+	qglVertex3d                  = 	dllVertex3d                  = GPA( "glVertex3d" );
+	qglVertex3dv                 = 	dllVertex3dv                 = GPA( "glVertex3dv" );
+	qglVertex3f                  = 	dllVertex3f                  = GPA( "glVertex3f" );
+	qglVertex3fv                 = 	dllVertex3fv                 = GPA( "glVertex3fv" );
+	qglVertex3i                  = 	dllVertex3i                  = GPA( "glVertex3i" );
+	qglVertex3iv                 = 	dllVertex3iv                 = GPA( "glVertex3iv" );
+	qglVertex3s                  = 	dllVertex3s                  = GPA( "glVertex3s" );
+	qglVertex3sv                 = 	dllVertex3sv                 = GPA( "glVertex3sv" );
+	qglVertex4d                  = 	dllVertex4d                  = GPA( "glVertex4d" );
+	qglVertex4dv                 = 	dllVertex4dv                 = GPA( "glVertex4dv" );
+	qglVertex4f                  = 	dllVertex4f                  = GPA( "glVertex4f" );
+	qglVertex4fv                 = 	dllVertex4fv                 = GPA( "glVertex4fv" );
+	qglVertex4i                  = 	dllVertex4i                  = GPA( "glVertex4i" );
+	qglVertex4iv                 = 	dllVertex4iv                 = GPA( "glVertex4iv" );
+	qglVertex4s                  = 	dllVertex4s                  = GPA( "glVertex4s" );
+	qglVertex4sv                 = 	dllVertex4sv                 = GPA( "glVertex4sv" );
+	qglVertexPointer             = 	dllVertexPointer             = GPA( "glVertexPointer" );
+	qglViewport                  = 	dllViewport                  = GPA( "glViewport" );
+
+	qfxMesaCreateContext         =  GPA("fxMesaCreateContext");
+	qfxMesaCreateBestContext     =  GPA("fxMesaCreateBestContext");
+	qfxMesaDestroyContext        =  GPA("fxMesaDestroyContext");
+	qfxMesaMakeCurrent           =  GPA("fxMesaMakeCurrent");
+	qfxMesaGetCurrentContext     =  GPA("fxMesaGetCurrentContext");
+	qfxMesaSwapBuffers           =  GPA("fxMesaSwapBuffers");
+
+	qglXChooseVisual             =  GPA("glXChooseVisual");
+	qglXCreateContext            =  GPA("glXCreateContext");
+	qglXDestroyContext           =  GPA("glXDestroyContext");
+	qglXMakeCurrent              =  GPA("glXMakeCurrent");
+	qglXCopyContext              =  GPA("glXCopyContext");
+	qglXSwapBuffers              =  GPA("glXSwapBuffers");
+
+	qglLockArraysEXT = 0;
+	qglUnlockArraysEXT = 0;
+	qglPointParameterfEXT = 0;
+	qglPointParameterfvEXT = 0;
+	qglColorTableEXT = 0;
+	qgl3DfxSetPaletteEXT = 0;
+	qglSelectTextureSGIS = 0;
+	qglMTexCoord2fSGIS = 0;
+	qglActiveTextureARB = 0;
+	qglClientActiveTextureARB = 0;
+	qglMultiTexCoord2fARB = 0;
+
+	return qtrue;
+}
+
+void QGL_EnableLogging( qboolean enable )
+{
+	if ( enable )
+	{
+		if ( !glw_state.log_fp )
+		{
+			struct tm *newtime;
+			time_t aclock;
+			char buffer[1024];
+			cvar_t	*basedir;
+
+			time( &aclock );
+			newtime = localtime( &aclock );
+
+			asctime( newtime );
+
+			basedir = ri.Cvar_Get( "basedir", "", 0 );
+			Com_sprintf( buffer, sizeof(buffer), "%s/gl.log", basedir->string ); 
+			glw_state.log_fp = fopen( buffer, "wt" );
+
+			fprintf( glw_state.log_fp, "%s\n", asctime( newtime ) );
+		}
+
+		qglAccum                     = logAccum;
+		qglAlphaFunc                 = logAlphaFunc;
+		qglAreTexturesResident       = logAreTexturesResident;
+		qglArrayElement              = logArrayElement;
+		qglBegin                     = logBegin;
+		qglBindTexture               = logBindTexture;
+		qglBitmap                    = logBitmap;
+		qglBlendFunc                 = logBlendFunc;
+		qglCallList                  = logCallList;
+		qglCallLists                 = logCallLists;
+		qglClear                     = logClear;
+		qglClearAccum                = logClearAccum;
+		qglClearColor                = logClearColor;
+		qglClearDepth                = logClearDepth;
+		qglClearIndex                = logClearIndex;
+		qglClearStencil              = logClearStencil;
+		qglClipPlane                 = logClipPlane;
+		qglColor3b                   = logColor3b;
+		qglColor3bv                  = logColor3bv;
+		qglColor3d                   = logColor3d;
+		qglColor3dv                  = logColor3dv;
+		qglColor3f                   = logColor3f;
+		qglColor3fv                  = logColor3fv;
+		qglColor3i                   = logColor3i;
+		qglColor3iv                  = logColor3iv;
+		qglColor3s                   = logColor3s;
+		qglColor3sv                  = logColor3sv;
+		qglColor3ub                  = logColor3ub;
+		qglColor3ubv                 = logColor3ubv;
+		qglColor3ui                  = logColor3ui;
+		qglColor3uiv                 = logColor3uiv;
+		qglColor3us                  = logColor3us;
+		qglColor3usv                 = logColor3usv;
+		qglColor4b                   = logColor4b;
+		qglColor4bv                  = logColor4bv;
+		qglColor4d                   = logColor4d;
+		qglColor4dv                  = logColor4dv;
+		qglColor4f                   = logColor4f;
+		qglColor4fv                  = logColor4fv;
+		qglColor4i                   = logColor4i;
+		qglColor4iv                  = logColor4iv;
+		qglColor4s                   = logColor4s;
+		qglColor4sv                  = logColor4sv;
+		qglColor4ub                  = logColor4ub;
+		qglColor4ubv                 = logColor4ubv;
+		qglColor4ui                  = logColor4ui;
+		qglColor4uiv                 = logColor4uiv;
+		qglColor4us                  = logColor4us;
+		qglColor4usv                 = logColor4usv;
+		qglColorMask                 = logColorMask;
+		qglColorMaterial             = logColorMaterial;
+		qglColorPointer              = logColorPointer;
+		qglCopyPixels                = logCopyPixels;
+		qglCopyTexImage1D            = logCopyTexImage1D;
+		qglCopyTexImage2D            = logCopyTexImage2D;
+		qglCopyTexSubImage1D         = logCopyTexSubImage1D;
+		qglCopyTexSubImage2D         = logCopyTexSubImage2D;
+		qglCullFace                  = logCullFace;
+		qglDeleteLists               = logDeleteLists ;
+		qglDeleteTextures            = logDeleteTextures ;
+		qglDepthFunc                 = logDepthFunc ;
+		qglDepthMask                 = logDepthMask ;
+		qglDepthRange                = logDepthRange ;
+		qglDisable                   = logDisable ;
+		qglDisableClientState        = logDisableClientState ;
+		qglDrawArrays                = logDrawArrays ;
+		qglDrawBuffer                = logDrawBuffer ;
+		qglDrawElements              = logDrawElements ;
+		qglDrawPixels                = logDrawPixels ;
+		qglEdgeFlag                  = logEdgeFlag ;
+		qglEdgeFlagPointer           = logEdgeFlagPointer ;
+		qglEdgeFlagv                 = logEdgeFlagv ;
+		qglEnable                    = 	logEnable                    ;
+		qglEnableClientState         = 	logEnableClientState         ;
+		qglEnd                       = 	logEnd                       ;
+		qglEndList                   = 	logEndList                   ;
+		qglEvalCoord1d				 = 	logEvalCoord1d				 ;
+		qglEvalCoord1dv              = 	logEvalCoord1dv              ;
+		qglEvalCoord1f               = 	logEvalCoord1f               ;
+		qglEvalCoord1fv              = 	logEvalCoord1fv              ;
+		qglEvalCoord2d               = 	logEvalCoord2d               ;
+		qglEvalCoord2dv              = 	logEvalCoord2dv              ;
+		qglEvalCoord2f               = 	logEvalCoord2f               ;
+		qglEvalCoord2fv              = 	logEvalCoord2fv              ;
+		qglEvalMesh1                 = 	logEvalMesh1                 ;
+		qglEvalMesh2                 = 	logEvalMesh2                 ;
+		qglEvalPoint1                = 	logEvalPoint1                ;
+		qglEvalPoint2                = 	logEvalPoint2                ;
+		qglFeedbackBuffer            = 	logFeedbackBuffer            ;
+		qglFinish                    = 	logFinish                    ;
+		qglFlush                     = 	logFlush                     ;
+		qglFogf                      = 	logFogf                      ;
+		qglFogfv                     = 	logFogfv                     ;
+		qglFogi                      = 	logFogi                      ;
+		qglFogiv                     = 	logFogiv                     ;
+		qglFrontFace                 = 	logFrontFace                 ;
+		qglFrustum                   = 	logFrustum                   ;
+		qglGenLists                  = 	logGenLists                  ;
+		qglGenTextures               = 	logGenTextures               ;
+		qglGetBooleanv               = 	logGetBooleanv               ;
+		qglGetClipPlane              = 	logGetClipPlane              ;
+		qglGetDoublev                = 	logGetDoublev                ;
+		qglGetError                  = 	logGetError                  ;
+		qglGetFloatv                 = 	logGetFloatv                 ;
+		qglGetIntegerv               = 	logGetIntegerv               ;
+		qglGetLightfv                = 	logGetLightfv                ;
+		qglGetLightiv                = 	logGetLightiv                ;
+		qglGetMapdv                  = 	logGetMapdv                  ;
+		qglGetMapfv                  = 	logGetMapfv                  ;
+		qglGetMapiv                  = 	logGetMapiv                  ;
+		qglGetMaterialfv             = 	logGetMaterialfv             ;
+		qglGetMaterialiv             = 	logGetMaterialiv             ;
+		qglGetPixelMapfv             = 	logGetPixelMapfv             ;
+		qglGetPixelMapuiv            = 	logGetPixelMapuiv            ;
+		qglGetPixelMapusv            = 	logGetPixelMapusv            ;
+		qglGetPointerv               = 	logGetPointerv               ;
+		qglGetPolygonStipple         = 	logGetPolygonStipple         ;
+		qglGetString                 = 	logGetString                 ;
+		qglGetTexEnvfv               = 	logGetTexEnvfv               ;
+		qglGetTexEnviv               = 	logGetTexEnviv               ;
+		qglGetTexGendv               = 	logGetTexGendv               ;
+		qglGetTexGenfv               = 	logGetTexGenfv               ;
+		qglGetTexGeniv               = 	logGetTexGeniv               ;
+		qglGetTexImage               = 	logGetTexImage               ;
+		qglGetTexLevelParameterfv    = 	logGetTexLevelParameterfv    ;
+		qglGetTexLevelParameteriv    = 	logGetTexLevelParameteriv    ;
+		qglGetTexParameterfv         = 	logGetTexParameterfv         ;
+		qglGetTexParameteriv         = 	logGetTexParameteriv         ;
+		qglHint                      = 	logHint                      ;
+		qglIndexMask                 = 	logIndexMask                 ;
+		qglIndexPointer              = 	logIndexPointer              ;
+		qglIndexd                    = 	logIndexd                    ;
+		qglIndexdv                   = 	logIndexdv                   ;
+		qglIndexf                    = 	logIndexf                    ;
+		qglIndexfv                   = 	logIndexfv                   ;
+		qglIndexi                    = 	logIndexi                    ;
+		qglIndexiv                   = 	logIndexiv                   ;
+		qglIndexs                    = 	logIndexs                    ;
+		qglIndexsv                   = 	logIndexsv                   ;
+		qglIndexub                   = 	logIndexub                   ;
+		qglIndexubv                  = 	logIndexubv                  ;
+		qglInitNames                 = 	logInitNames                 ;
+		qglInterleavedArrays         = 	logInterleavedArrays         ;
+		qglIsEnabled                 = 	logIsEnabled                 ;
+		qglIsList                    = 	logIsList                    ;
+		qglIsTexture                 = 	logIsTexture                 ;
+		qglLightModelf               = 	logLightModelf               ;
+		qglLightModelfv              = 	logLightModelfv              ;
+		qglLightModeli               = 	logLightModeli               ;
+		qglLightModeliv              = 	logLightModeliv              ;
+		qglLightf                    = 	logLightf                    ;
+		qglLightfv                   = 	logLightfv                   ;
+		qglLighti                    = 	logLighti                    ;
+		qglLightiv                   = 	logLightiv                   ;
+		qglLineStipple               = 	logLineStipple               ;
+		qglLineWidth                 = 	logLineWidth                 ;
+		qglListBase                  = 	logListBase                  ;
+		qglLoadIdentity              = 	logLoadIdentity              ;
+		qglLoadMatrixd               = 	logLoadMatrixd               ;
+		qglLoadMatrixf               = 	logLoadMatrixf               ;
+		qglLoadName                  = 	logLoadName                  ;
+		qglLogicOp                   = 	logLogicOp                   ;
+		qglMap1d                     = 	logMap1d                     ;
+		qglMap1f                     = 	logMap1f                     ;
+		qglMap2d                     = 	logMap2d                     ;
+		qglMap2f                     = 	logMap2f                     ;
+		qglMapGrid1d                 = 	logMapGrid1d                 ;
+		qglMapGrid1f                 = 	logMapGrid1f                 ;
+		qglMapGrid2d                 = 	logMapGrid2d                 ;
+		qglMapGrid2f                 = 	logMapGrid2f                 ;
+		qglMaterialf                 = 	logMaterialf                 ;
+		qglMaterialfv                = 	logMaterialfv                ;
+		qglMateriali                 = 	logMateriali                 ;
+		qglMaterialiv                = 	logMaterialiv                ;
+		qglMatrixMode                = 	logMatrixMode                ;
+		qglMultMatrixd               = 	logMultMatrixd               ;
+		qglMultMatrixf               = 	logMultMatrixf               ;
+		qglNewList                   = 	logNewList                   ;
+		qglNormal3b                  = 	logNormal3b                  ;
+		qglNormal3bv                 = 	logNormal3bv                 ;
+		qglNormal3d                  = 	logNormal3d                  ;
+		qglNormal3dv                 = 	logNormal3dv                 ;
+		qglNormal3f                  = 	logNormal3f                  ;
+		qglNormal3fv                 = 	logNormal3fv                 ;
+		qglNormal3i                  = 	logNormal3i                  ;
+		qglNormal3iv                 = 	logNormal3iv                 ;
+		qglNormal3s                  = 	logNormal3s                  ;
+		qglNormal3sv                 = 	logNormal3sv                 ;
+		qglNormalPointer             = 	logNormalPointer             ;
+		qglOrtho                     = 	logOrtho                     ;
+		qglPassThrough               = 	logPassThrough               ;
+		qglPixelMapfv                = 	logPixelMapfv                ;
+		qglPixelMapuiv               = 	logPixelMapuiv               ;
+		qglPixelMapusv               = 	logPixelMapusv               ;
+		qglPixelStoref               = 	logPixelStoref               ;
+		qglPixelStorei               = 	logPixelStorei               ;
+		qglPixelTransferf            = 	logPixelTransferf            ;
+		qglPixelTransferi            = 	logPixelTransferi            ;
+		qglPixelZoom                 = 	logPixelZoom                 ;
+		qglPointSize                 = 	logPointSize                 ;
+		qglPolygonMode               = 	logPolygonMode               ;
+		qglPolygonOffset             = 	logPolygonOffset             ;
+		qglPolygonStipple            = 	logPolygonStipple            ;
+		qglPopAttrib                 = 	logPopAttrib                 ;
+		qglPopClientAttrib           = 	logPopClientAttrib           ;
+		qglPopMatrix                 = 	logPopMatrix                 ;
+		qglPopName                   = 	logPopName                   ;
+		qglPrioritizeTextures        = 	logPrioritizeTextures        ;
+		qglPushAttrib                = 	logPushAttrib                ;
+		qglPushClientAttrib          = 	logPushClientAttrib          ;
+		qglPushMatrix                = 	logPushMatrix                ;
+		qglPushName                  = 	logPushName                  ;
+		qglRasterPos2d               = 	logRasterPos2d               ;
+		qglRasterPos2dv              = 	logRasterPos2dv              ;
+		qglRasterPos2f               = 	logRasterPos2f               ;
+		qglRasterPos2fv              = 	logRasterPos2fv              ;
+		qglRasterPos2i               = 	logRasterPos2i               ;
+		qglRasterPos2iv              = 	logRasterPos2iv              ;
+		qglRasterPos2s               = 	logRasterPos2s               ;
+		qglRasterPos2sv              = 	logRasterPos2sv              ;
+		qglRasterPos3d               = 	logRasterPos3d               ;
+		qglRasterPos3dv              = 	logRasterPos3dv              ;
+		qglRasterPos3f               = 	logRasterPos3f               ;
+		qglRasterPos3fv              = 	logRasterPos3fv              ;
+		qglRasterPos3i               = 	logRasterPos3i               ;
+		qglRasterPos3iv              = 	logRasterPos3iv              ;
+		qglRasterPos3s               = 	logRasterPos3s               ;
+		qglRasterPos3sv              = 	logRasterPos3sv              ;
+		qglRasterPos4d               = 	logRasterPos4d               ;
+		qglRasterPos4dv              = 	logRasterPos4dv              ;
+		qglRasterPos4f               = 	logRasterPos4f               ;
+		qglRasterPos4fv              = 	logRasterPos4fv              ;
+		qglRasterPos4i               = 	logRasterPos4i               ;
+		qglRasterPos4iv              = 	logRasterPos4iv              ;
+		qglRasterPos4s               = 	logRasterPos4s               ;
+		qglRasterPos4sv              = 	logRasterPos4sv              ;
+		qglReadBuffer                = 	logReadBuffer                ;
+		qglReadPixels                = 	logReadPixels                ;
+		qglRectd                     = 	logRectd                     ;
+		qglRectdv                    = 	logRectdv                    ;
+		qglRectf                     = 	logRectf                     ;
+		qglRectfv                    = 	logRectfv                    ;
+		qglRecti                     = 	logRecti                     ;
+		qglRectiv                    = 	logRectiv                    ;
+		qglRects                     = 	logRects                     ;
+		qglRectsv                    = 	logRectsv                    ;
+		qglRenderMode                = 	logRenderMode                ;
+		qglRotated                   = 	logRotated                   ;
+		qglRotatef                   = 	logRotatef                   ;
+		qglScaled                    = 	logScaled                    ;
+		qglScalef                    = 	logScalef                    ;
+		qglScissor                   = 	logScissor                   ;
+		qglSelectBuffer              = 	logSelectBuffer              ;
+		qglShadeModel                = 	logShadeModel                ;
+		qglStencilFunc               = 	logStencilFunc               ;
+		qglStencilMask               = 	logStencilMask               ;
+		qglStencilOp                 = 	logStencilOp                 ;
+		qglTexCoord1d                = 	logTexCoord1d                ;
+		qglTexCoord1dv               = 	logTexCoord1dv               ;
+		qglTexCoord1f                = 	logTexCoord1f                ;
+		qglTexCoord1fv               = 	logTexCoord1fv               ;
+		qglTexCoord1i                = 	logTexCoord1i                ;
+		qglTexCoord1iv               = 	logTexCoord1iv               ;
+		qglTexCoord1s                = 	logTexCoord1s                ;
+		qglTexCoord1sv               = 	logTexCoord1sv               ;
+		qglTexCoord2d                = 	logTexCoord2d                ;
+		qglTexCoord2dv               = 	logTexCoord2dv               ;
+		qglTexCoord2f                = 	logTexCoord2f                ;
+		qglTexCoord2fv               = 	logTexCoord2fv               ;
+		qglTexCoord2i                = 	logTexCoord2i                ;
+		qglTexCoord2iv               = 	logTexCoord2iv               ;
+		qglTexCoord2s                = 	logTexCoord2s                ;
+		qglTexCoord2sv               = 	logTexCoord2sv               ;
+		qglTexCoord3d                = 	logTexCoord3d                ;
+		qglTexCoord3dv               = 	logTexCoord3dv               ;
+		qglTexCoord3f                = 	logTexCoord3f                ;
+		qglTexCoord3fv               = 	logTexCoord3fv               ;
+		qglTexCoord3i                = 	logTexCoord3i                ;
+		qglTexCoord3iv               = 	logTexCoord3iv               ;
+		qglTexCoord3s                = 	logTexCoord3s                ;
+		qglTexCoord3sv               = 	logTexCoord3sv               ;
+		qglTexCoord4d                = 	logTexCoord4d                ;
+		qglTexCoord4dv               = 	logTexCoord4dv               ;
+		qglTexCoord4f                = 	logTexCoord4f                ;
+		qglTexCoord4fv               = 	logTexCoord4fv               ;
+		qglTexCoord4i                = 	logTexCoord4i                ;
+		qglTexCoord4iv               = 	logTexCoord4iv               ;
+		qglTexCoord4s                = 	logTexCoord4s                ;
+		qglTexCoord4sv               = 	logTexCoord4sv               ;
+		qglTexCoordPointer           = 	logTexCoordPointer           ;
+		qglTexEnvf                   = 	logTexEnvf                   ;
+		qglTexEnvfv                  = 	logTexEnvfv                  ;
+		qglTexEnvi                   = 	logTexEnvi                   ;
+		qglTexEnviv                  = 	logTexEnviv                  ;
+		qglTexGend                   = 	logTexGend                   ;
+		qglTexGendv                  = 	logTexGendv                  ;
+		qglTexGenf                   = 	logTexGenf                   ;
+		qglTexGenfv                  = 	logTexGenfv                  ;
+		qglTexGeni                   = 	logTexGeni                   ;
+		qglTexGeniv                  = 	logTexGeniv                  ;
+		qglTexImage1D                = 	logTexImage1D                ;
+		qglTexImage2D                = 	logTexImage2D                ;
+		qglTexParameterf             = 	logTexParameterf             ;
+		qglTexParameterfv            = 	logTexParameterfv            ;
+		qglTexParameteri             = 	logTexParameteri             ;
+		qglTexParameteriv            = 	logTexParameteriv            ;
+		qglTexSubImage1D             = 	logTexSubImage1D             ;
+		qglTexSubImage2D             = 	logTexSubImage2D             ;
+		qglTranslated                = 	logTranslated                ;
+		qglTranslatef                = 	logTranslatef                ;
+		qglVertex2d                  = 	logVertex2d                  ;
+		qglVertex2dv                 = 	logVertex2dv                 ;
+		qglVertex2f                  = 	logVertex2f                  ;
+		qglVertex2fv                 = 	logVertex2fv                 ;
+		qglVertex2i                  = 	logVertex2i                  ;
+		qglVertex2iv                 = 	logVertex2iv                 ;
+		qglVertex2s                  = 	logVertex2s                  ;
+		qglVertex2sv                 = 	logVertex2sv                 ;
+		qglVertex3d                  = 	logVertex3d                  ;
+		qglVertex3dv                 = 	logVertex3dv                 ;
+		qglVertex3f                  = 	logVertex3f                  ;
+		qglVertex3fv                 = 	logVertex3fv                 ;
+		qglVertex3i                  = 	logVertex3i                  ;
+		qglVertex3iv                 = 	logVertex3iv                 ;
+		qglVertex3s                  = 	logVertex3s                  ;
+		qglVertex3sv                 = 	logVertex3sv                 ;
+		qglVertex4d                  = 	logVertex4d                  ;
+		qglVertex4dv                 = 	logVertex4dv                 ;
+		qglVertex4f                  = 	logVertex4f                  ;
+		qglVertex4fv                 = 	logVertex4fv                 ;
+		qglVertex4i                  = 	logVertex4i                  ;
+		qglVertex4iv                 = 	logVertex4iv                 ;
+		qglVertex4s                  = 	logVertex4s                  ;
+		qglVertex4sv                 = 	logVertex4sv                 ;
+		qglVertexPointer             = 	logVertexPointer             ;
+		qglViewport                  = 	logViewport                  ;
+	}
+	else
+	{
+		qglAccum                     = dllAccum;
+		qglAlphaFunc                 = dllAlphaFunc;
+		qglAreTexturesResident       = dllAreTexturesResident;
+		qglArrayElement              = dllArrayElement;
+		qglBegin                     = dllBegin;
+		qglBindTexture               = dllBindTexture;
+		qglBitmap                    = dllBitmap;
+		qglBlendFunc                 = dllBlendFunc;
+		qglCallList                  = dllCallList;
+		qglCallLists                 = dllCallLists;
+		qglClear                     = dllClear;
+		qglClearAccum                = dllClearAccum;
+		qglClearColor                = dllClearColor;
+		qglClearDepth                = dllClearDepth;
+		qglClearIndex                = dllClearIndex;
+		qglClearStencil              = dllClearStencil;
+		qglClipPlane                 = dllClipPlane;
+		qglColor3b                   = dllColor3b;
+		qglColor3bv                  = dllColor3bv;
+		qglColor3d                   = dllColor3d;
+		qglColor3dv                  = dllColor3dv;
+		qglColor3f                   = dllColor3f;
+		qglColor3fv                  = dllColor3fv;
+		qglColor3i                   = dllColor3i;
+		qglColor3iv                  = dllColor3iv;
+		qglColor3s                   = dllColor3s;
+		qglColor3sv                  = dllColor3sv;
+		qglColor3ub                  = dllColor3ub;
+		qglColor3ubv                 = dllColor3ubv;
+		qglColor3ui                  = dllColor3ui;
+		qglColor3uiv                 = dllColor3uiv;
+		qglColor3us                  = dllColor3us;
+		qglColor3usv                 = dllColor3usv;
+		qglColor4b                   = dllColor4b;
+		qglColor4bv                  = dllColor4bv;
+		qglColor4d                   = dllColor4d;
+		qglColor4dv                  = dllColor4dv;
+		qglColor4f                   = dllColor4f;
+		qglColor4fv                  = dllColor4fv;
+		qglColor4i                   = dllColor4i;
+		qglColor4iv                  = dllColor4iv;
+		qglColor4s                   = dllColor4s;
+		qglColor4sv                  = dllColor4sv;
+		qglColor4ub                  = dllColor4ub;
+		qglColor4ubv                 = dllColor4ubv;
+		qglColor4ui                  = dllColor4ui;
+		qglColor4uiv                 = dllColor4uiv;
+		qglColor4us                  = dllColor4us;
+		qglColor4usv                 = dllColor4usv;
+		qglColorMask                 = dllColorMask;
+		qglColorMaterial             = dllColorMaterial;
+		qglColorPointer              = dllColorPointer;
+		qglCopyPixels                = dllCopyPixels;
+		qglCopyTexImage1D            = dllCopyTexImage1D;
+		qglCopyTexImage2D            = dllCopyTexImage2D;
+		qglCopyTexSubImage1D         = dllCopyTexSubImage1D;
+		qglCopyTexSubImage2D         = dllCopyTexSubImage2D;
+		qglCullFace                  = dllCullFace;
+		qglDeleteLists               = dllDeleteLists ;
+		qglDeleteTextures            = dllDeleteTextures ;
+		qglDepthFunc                 = dllDepthFunc ;
+		qglDepthMask                 = dllDepthMask ;
+		qglDepthRange                = dllDepthRange ;
+		qglDisable                   = dllDisable ;
+		qglDisableClientState        = dllDisableClientState ;
+		qglDrawArrays                = dllDrawArrays ;
+		qglDrawBuffer                = dllDrawBuffer ;
+		qglDrawElements              = dllDrawElements ;
+		qglDrawPixels                = dllDrawPixels ;
+		qglEdgeFlag                  = dllEdgeFlag ;
+		qglEdgeFlagPointer           = dllEdgeFlagPointer ;
+		qglEdgeFlagv                 = dllEdgeFlagv ;
+		qglEnable                    = 	dllEnable                    ;
+		qglEnableClientState         = 	dllEnableClientState         ;
+		qglEnd                       = 	dllEnd                       ;
+		qglEndList                   = 	dllEndList                   ;
+		qglEvalCoord1d				 = 	dllEvalCoord1d				 ;
+		qglEvalCoord1dv              = 	dllEvalCoord1dv              ;
+		qglEvalCoord1f               = 	dllEvalCoord1f               ;
+		qglEvalCoord1fv              = 	dllEvalCoord1fv              ;
+		qglEvalCoord2d               = 	dllEvalCoord2d               ;
+		qglEvalCoord2dv              = 	dllEvalCoord2dv              ;
+		qglEvalCoord2f               = 	dllEvalCoord2f               ;
+		qglEvalCoord2fv              = 	dllEvalCoord2fv              ;
+		qglEvalMesh1                 = 	dllEvalMesh1                 ;
+		qglEvalMesh2                 = 	dllEvalMesh2                 ;
+		qglEvalPoint1                = 	dllEvalPoint1                ;
+		qglEvalPoint2                = 	dllEvalPoint2                ;
+		qglFeedbackBuffer            = 	dllFeedbackBuffer            ;
+		qglFinish                    = 	dllFinish                    ;
+		qglFlush                     = 	dllFlush                     ;
+		qglFogf                      = 	dllFogf                      ;
+		qglFogfv                     = 	dllFogfv                     ;
+		qglFogi                      = 	dllFogi                      ;
+		qglFogiv                     = 	dllFogiv                     ;
+		qglFrontFace                 = 	dllFrontFace                 ;
+		qglFrustum                   = 	dllFrustum                   ;
+		qglGenLists                  = 	dllGenLists                  ;
+		qglGenTextures               = 	dllGenTextures               ;
+		qglGetBooleanv               = 	dllGetBooleanv               ;
+		qglGetClipPlane              = 	dllGetClipPlane              ;
+		qglGetDoublev                = 	dllGetDoublev                ;
+		qglGetError                  = 	dllGetError                  ;
+		qglGetFloatv                 = 	dllGetFloatv                 ;
+		qglGetIntegerv               = 	dllGetIntegerv               ;
+		qglGetLightfv                = 	dllGetLightfv                ;
+		qglGetLightiv                = 	dllGetLightiv                ;
+		qglGetMapdv                  = 	dllGetMapdv                  ;
+		qglGetMapfv                  = 	dllGetMapfv                  ;
+		qglGetMapiv                  = 	dllGetMapiv                  ;
+		qglGetMaterialfv             = 	dllGetMaterialfv             ;
+		qglGetMaterialiv             = 	dllGetMaterialiv             ;
+		qglGetPixelMapfv             = 	dllGetPixelMapfv             ;
+		qglGetPixelMapuiv            = 	dllGetPixelMapuiv            ;
+		qglGetPixelMapusv            = 	dllGetPixelMapusv            ;
+		qglGetPointerv               = 	dllGetPointerv               ;
+		qglGetPolygonStipple         = 	dllGetPolygonStipple         ;
+		qglGetString                 = 	dllGetString                 ;
+		qglGetTexEnvfv               = 	dllGetTexEnvfv               ;
+		qglGetTexEnviv               = 	dllGetTexEnviv               ;
+		qglGetTexGendv               = 	dllGetTexGendv               ;
+		qglGetTexGenfv               = 	dllGetTexGenfv               ;
+		qglGetTexGeniv               = 	dllGetTexGeniv               ;
+		qglGetTexImage               = 	dllGetTexImage               ;
+		qglGetTexLevelParameterfv    = 	dllGetTexLevelParameterfv    ;
+		qglGetTexLevelParameteriv    = 	dllGetTexLevelParameteriv    ;
+		qglGetTexParameterfv         = 	dllGetTexParameterfv         ;
+		qglGetTexParameteriv         = 	dllGetTexParameteriv         ;
+		qglHint                      = 	dllHint                      ;
+		qglIndexMask                 = 	dllIndexMask                 ;
+		qglIndexPointer              = 	dllIndexPointer              ;
+		qglIndexd                    = 	dllIndexd                    ;
+		qglIndexdv                   = 	dllIndexdv                   ;
+		qglIndexf                    = 	dllIndexf                    ;
+		qglIndexfv                   = 	dllIndexfv                   ;
+		qglIndexi                    = 	dllIndexi                    ;
+		qglIndexiv                   = 	dllIndexiv                   ;
+		qglIndexs                    = 	dllIndexs                    ;
+		qglIndexsv                   = 	dllIndexsv                   ;
+		qglIndexub                   = 	dllIndexub                   ;
+		qglIndexubv                  = 	dllIndexubv                  ;
+		qglInitNames                 = 	dllInitNames                 ;
+		qglInterleavedArrays         = 	dllInterleavedArrays         ;
+		qglIsEnabled                 = 	dllIsEnabled                 ;
+		qglIsList                    = 	dllIsList                    ;
+		qglIsTexture                 = 	dllIsTexture                 ;
+		qglLightModelf               = 	dllLightModelf               ;
+		qglLightModelfv              = 	dllLightModelfv              ;
+		qglLightModeli               = 	dllLightModeli               ;
+		qglLightModeliv              = 	dllLightModeliv              ;
+		qglLightf                    = 	dllLightf                    ;
+		qglLightfv                   = 	dllLightfv                   ;
+		qglLighti                    = 	dllLighti                    ;
+		qglLightiv                   = 	dllLightiv                   ;
+		qglLineStipple               = 	dllLineStipple               ;
+		qglLineWidth                 = 	dllLineWidth                 ;
+		qglListBase                  = 	dllListBase                  ;
+		qglLoadIdentity              = 	dllLoadIdentity              ;
+		qglLoadMatrixd               = 	dllLoadMatrixd               ;
+		qglLoadMatrixf               = 	dllLoadMatrixf               ;
+		qglLoadName                  = 	dllLoadName                  ;
+		qglLogicOp                   = 	dllLogicOp                   ;
+		qglMap1d                     = 	dllMap1d                     ;
+		qglMap1f                     = 	dllMap1f                     ;
+		qglMap2d                     = 	dllMap2d                     ;
+		qglMap2f                     = 	dllMap2f                     ;
+		qglMapGrid1d                 = 	dllMapGrid1d                 ;
+		qglMapGrid1f                 = 	dllMapGrid1f                 ;
+		qglMapGrid2d                 = 	dllMapGrid2d                 ;
+		qglMapGrid2f                 = 	dllMapGrid2f                 ;
+		qglMaterialf                 = 	dllMaterialf                 ;
+		qglMaterialfv                = 	dllMaterialfv                ;
+		qglMateriali                 = 	dllMateriali                 ;
+		qglMaterialiv                = 	dllMaterialiv                ;
+		qglMatrixMode                = 	dllMatrixMode                ;
+		qglMultMatrixd               = 	dllMultMatrixd               ;
+		qglMultMatrixf               = 	dllMultMatrixf               ;
+		qglNewList                   = 	dllNewList                   ;
+		qglNormal3b                  = 	dllNormal3b                  ;
+		qglNormal3bv                 = 	dllNormal3bv                 ;
+		qglNormal3d                  = 	dllNormal3d                  ;
+		qglNormal3dv                 = 	dllNormal3dv                 ;
+		qglNormal3f                  = 	dllNormal3f                  ;
+		qglNormal3fv                 = 	dllNormal3fv                 ;
+		qglNormal3i                  = 	dllNormal3i                  ;
+		qglNormal3iv                 = 	dllNormal3iv                 ;
+		qglNormal3s                  = 	dllNormal3s                  ;
+		qglNormal3sv                 = 	dllNormal3sv                 ;
+		qglNormalPointer             = 	dllNormalPointer             ;
+		qglOrtho                     = 	dllOrtho                     ;
+		qglPassThrough               = 	dllPassThrough               ;
+		qglPixelMapfv                = 	dllPixelMapfv                ;
+		qglPixelMapuiv               = 	dllPixelMapuiv               ;
+		qglPixelMapusv               = 	dllPixelMapusv               ;
+		qglPixelStoref               = 	dllPixelStoref               ;
+		qglPixelStorei               = 	dllPixelStorei               ;
+		qglPixelTransferf            = 	dllPixelTransferf            ;
+		qglPixelTransferi            = 	dllPixelTransferi            ;
+		qglPixelZoom                 = 	dllPixelZoom                 ;
+		qglPointSize                 = 	dllPointSize                 ;
+		qglPolygonMode               = 	dllPolygonMode               ;
+		qglPolygonOffset             = 	dllPolygonOffset             ;
+		qglPolygonStipple            = 	dllPolygonStipple            ;
+		qglPopAttrib                 = 	dllPopAttrib                 ;
+		qglPopClientAttrib           = 	dllPopClientAttrib           ;
+		qglPopMatrix                 = 	dllPopMatrix                 ;
+		qglPopName                   = 	dllPopName                   ;
+		qglPrioritizeTextures        = 	dllPrioritizeTextures        ;
+		qglPushAttrib                = 	dllPushAttrib                ;
+		qglPushClientAttrib          = 	dllPushClientAttrib          ;
+		qglPushMatrix                = 	dllPushMatrix                ;
+		qglPushName                  = 	dllPushName                  ;
+		qglRasterPos2d               = 	dllRasterPos2d               ;
+		qglRasterPos2dv              = 	dllRasterPos2dv              ;
+		qglRasterPos2f               = 	dllRasterPos2f               ;
+		qglRasterPos2fv              = 	dllRasterPos2fv              ;
+		qglRasterPos2i               = 	dllRasterPos2i               ;
+		qglRasterPos2iv              = 	dllRasterPos2iv              ;
+		qglRasterPos2s               = 	dllRasterPos2s               ;
+		qglRasterPos2sv              = 	dllRasterPos2sv              ;
+		qglRasterPos3d               = 	dllRasterPos3d               ;
+		qglRasterPos3dv              = 	dllRasterPos3dv              ;
+		qglRasterPos3f               = 	dllRasterPos3f               ;
+		qglRasterPos3fv              = 	dllRasterPos3fv              ;
+		qglRasterPos3i               = 	dllRasterPos3i               ;
+		qglRasterPos3iv              = 	dllRasterPos3iv              ;
+		qglRasterPos3s               = 	dllRasterPos3s               ;
+		qglRasterPos3sv              = 	dllRasterPos3sv              ;
+		qglRasterPos4d               = 	dllRasterPos4d               ;
+		qglRasterPos4dv              = 	dllRasterPos4dv              ;
+		qglRasterPos4f               = 	dllRasterPos4f               ;
+		qglRasterPos4fv              = 	dllRasterPos4fv              ;
+		qglRasterPos4i               = 	dllRasterPos4i               ;
+		qglRasterPos4iv              = 	dllRasterPos4iv              ;
+		qglRasterPos4s               = 	dllRasterPos4s               ;
+		qglRasterPos4sv              = 	dllRasterPos4sv              ;
+		qglReadBuffer                = 	dllReadBuffer                ;
+		qglReadPixels                = 	dllReadPixels                ;
+		qglRectd                     = 	dllRectd                     ;
+		qglRectdv                    = 	dllRectdv                    ;
+		qglRectf                     = 	dllRectf                     ;
+		qglRectfv                    = 	dllRectfv                    ;
+		qglRecti                     = 	dllRecti                     ;
+		qglRectiv                    = 	dllRectiv                    ;
+		qglRects                     = 	dllRects                     ;
+		qglRectsv                    = 	dllRectsv                    ;
+		qglRenderMode                = 	dllRenderMode                ;
+		qglRotated                   = 	dllRotated                   ;
+		qglRotatef                   = 	dllRotatef                   ;
+		qglScaled                    = 	dllScaled                    ;
+		qglScalef                    = 	dllScalef                    ;
+		qglScissor                   = 	dllScissor                   ;
+		qglSelectBuffer              = 	dllSelectBuffer              ;
+		qglShadeModel                = 	dllShadeModel                ;
+		qglStencilFunc               = 	dllStencilFunc               ;
+		qglStencilMask               = 	dllStencilMask               ;
+		qglStencilOp                 = 	dllStencilOp                 ;
+		qglTexCoord1d                = 	dllTexCoord1d                ;
+		qglTexCoord1dv               = 	dllTexCoord1dv               ;
+		qglTexCoord1f                = 	dllTexCoord1f                ;
+		qglTexCoord1fv               = 	dllTexCoord1fv               ;
+		qglTexCoord1i                = 	dllTexCoord1i                ;
+		qglTexCoord1iv               = 	dllTexCoord1iv               ;
+		qglTexCoord1s                = 	dllTexCoord1s                ;
+		qglTexCoord1sv               = 	dllTexCoord1sv               ;
+		qglTexCoord2d                = 	dllTexCoord2d                ;
+		qglTexCoord2dv               = 	dllTexCoord2dv               ;
+		qglTexCoord2f                = 	dllTexCoord2f                ;
+		qglTexCoord2fv               = 	dllTexCoord2fv               ;
+		qglTexCoord2i                = 	dllTexCoord2i                ;
+		qglTexCoord2iv               = 	dllTexCoord2iv               ;
+		qglTexCoord2s                = 	dllTexCoord2s                ;
+		qglTexCoord2sv               = 	dllTexCoord2sv               ;
+		qglTexCoord3d                = 	dllTexCoord3d                ;
+		qglTexCoord3dv               = 	dllTexCoord3dv               ;
+		qglTexCoord3f                = 	dllTexCoord3f                ;
+		qglTexCoord3fv               = 	dllTexCoord3fv               ;
+		qglTexCoord3i                = 	dllTexCoord3i                ;
+		qglTexCoord3iv               = 	dllTexCoord3iv               ;
+		qglTexCoord3s                = 	dllTexCoord3s                ;
+		qglTexCoord3sv               = 	dllTexCoord3sv               ;
+		qglTexCoord4d                = 	dllTexCoord4d                ;
+		qglTexCoord4dv               = 	dllTexCoord4dv               ;
+		qglTexCoord4f                = 	dllTexCoord4f                ;
+		qglTexCoord4fv               = 	dllTexCoord4fv               ;
+		qglTexCoord4i                = 	dllTexCoord4i                ;
+		qglTexCoord4iv               = 	dllTexCoord4iv               ;
+		qglTexCoord4s                = 	dllTexCoord4s                ;
+		qglTexCoord4sv               = 	dllTexCoord4sv               ;
+		qglTexCoordPointer           = 	dllTexCoordPointer           ;
+		qglTexEnvf                   = 	dllTexEnvf                   ;
+		qglTexEnvfv                  = 	dllTexEnvfv                  ;
+		qglTexEnvi                   = 	dllTexEnvi                   ;
+		qglTexEnviv                  = 	dllTexEnviv                  ;
+		qglTexGend                   = 	dllTexGend                   ;
+		qglTexGendv                  = 	dllTexGendv                  ;
+		qglTexGenf                   = 	dllTexGenf                   ;
+		qglTexGenfv                  = 	dllTexGenfv                  ;
+		qglTexGeni                   = 	dllTexGeni                   ;
+		qglTexGeniv                  = 	dllTexGeniv                  ;
+		qglTexImage1D                = 	dllTexImage1D                ;
+		qglTexImage2D                = 	dllTexImage2D                ;
+		qglTexParameterf             = 	dllTexParameterf             ;
+		qglTexParameterfv            = 	dllTexParameterfv            ;
+		qglTexParameteri             = 	dllTexParameteri             ;
+		qglTexParameteriv            = 	dllTexParameteriv            ;
+		qglTexSubImage1D             = 	dllTexSubImage1D             ;
+		qglTexSubImage2D             = 	dllTexSubImage2D             ;
+		qglTranslated                = 	dllTranslated                ;
+		qglTranslatef                = 	dllTranslatef                ;
+		qglVertex2d                  = 	dllVertex2d                  ;
+		qglVertex2dv                 = 	dllVertex2dv                 ;
+		qglVertex2f                  = 	dllVertex2f                  ;
+		qglVertex2fv                 = 	dllVertex2fv                 ;
+		qglVertex2i                  = 	dllVertex2i                  ;
+		qglVertex2iv                 = 	dllVertex2iv                 ;
+		qglVertex2s                  = 	dllVertex2s                  ;
+		qglVertex2sv                 = 	dllVertex2sv                 ;
+		qglVertex3d                  = 	dllVertex3d                  ;
+		qglVertex3dv                 = 	dllVertex3dv                 ;
+		qglVertex3f                  = 	dllVertex3f                  ;
+		qglVertex3fv                 = 	dllVertex3fv                 ;
+		qglVertex3i                  = 	dllVertex3i                  ;
+		qglVertex3iv                 = 	dllVertex3iv                 ;
+		qglVertex3s                  = 	dllVertex3s                  ;
+		qglVertex3sv                 = 	dllVertex3sv                 ;
+		qglVertex4d                  = 	dllVertex4d                  ;
+		qglVertex4dv                 = 	dllVertex4dv                 ;
+		qglVertex4f                  = 	dllVertex4f                  ;
+		qglVertex4fv                 = 	dllVertex4fv                 ;
+		qglVertex4i                  = 	dllVertex4i                  ;
+		qglVertex4iv                 = 	dllVertex4iv                 ;
+		qglVertex4s                  = 	dllVertex4s                  ;
+		qglVertex4sv                 = 	dllVertex4sv                 ;
+		qglVertexPointer             = 	dllVertexPointer             ;
+		qglViewport                  = 	dllViewport                  ;
+	}
+}
+
+
+void GLimp_LogNewFrame( void )
+{
+	fprintf( glw_state.log_fp, "*** R_BeginFrame ***\n" );
+}
+
+
diff --git a/code/unix/linux_snd.c b/code/unix/linux_snd.c
new file mode 100644
index 0000000..77c816a
--- /dev/null
+++ b/code/unix/linux_snd.c
@@ -0,0 +1,244 @@
+#include <unistd.h>
+#include <fcntl.h>
+#include <stdlib.h>
+#include <sys/types.h>
+#include <sys/ioctl.h>
+#include <sys/mman.h>
+#include <sys/shm.h>
+#include <sys/wait.h>
+#include <linux/soundcard.h>
+#include <stdio.h>
+
+#include "../client/snd_local.h"
+
+int audio_fd;
+int snd_inited=0;
+
+cvar_t *sndbits;
+cvar_t *sndspeed;
+cvar_t *sndchannels;
+
+cvar_t *snddevice;
+
+/* Some devices may work only with 48000 */
+static int tryrates[] = { 22050, 11025, 44100, 48000, 8000 };
+
+qboolean SNDDMA_Init(void)
+{
+	int rc;
+    int fmt;
+	int tmp;
+    int i;
+    char *s;
+	struct audio_buf_info info;
+	int caps;
+	extern uid_t saved_euid;
+
+	if (snd_inited)
+		return;
+
+	if (!snddevice) {
+		sndbits = Cvar_Get("sndbits", "16", CVAR_ARCHIVE);
+		sndspeed = Cvar_Get("sndspeed", "0", CVAR_ARCHIVE);
+		sndchannels = Cvar_Get("sndchannels", "2", CVAR_ARCHIVE);
+		snddevice = Cvar_Get("snddevice", "/dev/dsp", CVAR_ARCHIVE);
+	}
+
+// open /dev/dsp, confirm capability to mmap, and get size of dma buffer
+	if (!audio_fd) {
+		seteuid(saved_euid);
+
+		audio_fd = open(snddevice->string, O_RDWR);
+
+		seteuid(getuid());
+
+		if (audio_fd < 0) {
+			perror(snddevice->string);
+			Com_Printf("Could not open %s\n", snddevice->string);
+			return 0;
+			}
+	}
+
+#if 0
+    /* Not applicable here */
+    rc = ioctl(audio_fd, SNDCTL_DSP_RESET, 0);
+    if (rc < 0) {
+		perror(snddevice->string);
+		Com_Printf("Could not reset %s\n", snddevice->string);
+		close(audio_fd);
+
+		return 0;
+	}
+#endif
+
+	if (ioctl(audio_fd, SNDCTL_DSP_GETCAPS, &caps) == -1) {
+		perror(snddevice->string);
+        Com_Printf("Sound driver too old\n");
+		close(audio_fd);
+		return 0;
+	}
+
+	if (!(caps & DSP_CAP_TRIGGER) || !(caps & DSP_CAP_MMAP)) {
+		Com_Printf("Sorry but your soundcard can't do this\n");
+		close(audio_fd);
+		return 0;
+	}
+
+
+/* SNDCTL_DSP_GETOSPACE moved to be called later */
+    
+// set sample bits & speed
+    dma.samplebits = (int)sndbits->value;
+	if (dma.samplebits != 16 && dma.samplebits != 8) {
+        ioctl(audio_fd, SNDCTL_DSP_GETFMTS, &fmt);
+        if (fmt & AFMT_S16_LE) 
+			dma.samplebits = 16;
+        else if (fmt & AFMT_U8) 
+			dma.samplebits = 8;
+    }
+
+	dma.speed = (int)sndspeed->value;
+	if (!dma.speed) {
+        for (i=0 ; i<sizeof(tryrates)/4 ; i++)
+            if (!ioctl(audio_fd, SNDCTL_DSP_SPEED, &tryrates[i])) 
+				break;
+        dma.speed = tryrates[i];
+    }
+
+	dma.channels = (int)sndchannels->value;
+	if (dma.channels < 1 || dma.channels > 2)
+		dma.channels = 2;
+        
+/*  mmap() call moved forward */
+
+	tmp = 0;
+	if (dma.channels == 2)
+		tmp = 1;
+    rc = ioctl(audio_fd, SNDCTL_DSP_STEREO, &tmp);
+    if (rc < 0) {
+		perror(snddevice->string);
+        Com_Printf("Could not set %s to stereo=%d", snddevice->string, dma.channels);
+		close(audio_fd);
+        return 0;
+    }
+
+	if (tmp)
+		dma.channels = 2;
+	else
+		dma.channels = 1;
+
+    rc = ioctl(audio_fd, SNDCTL_DSP_SPEED, &dma.speed);
+    if (rc < 0) {
+		perror(snddevice->string);
+        Com_Printf("Could not set %s speed to %d", snddevice->string, dma.speed);
+		close(audio_fd);
+        return 0;
+    }
+
+    if (dma.samplebits == 16) {
+        rc = AFMT_S16_LE;
+        rc = ioctl(audio_fd, SNDCTL_DSP_SETFMT, &rc);
+        if (rc < 0) {
+			perror(snddevice->string);
+			Com_Printf("Could not support 16-bit data.  Try 8-bit.\n");
+			close(audio_fd);
+			return 0;
+		}
+    } else if (dma.samplebits == 8) {
+        rc = AFMT_U8;
+        rc = ioctl(audio_fd, SNDCTL_DSP_SETFMT, &rc);
+        if (rc < 0) {
+			perror(snddevice->string);
+			Com_Printf("Could not support 8-bit data.\n");
+			close(audio_fd);
+			return 0;
+		}
+    } else {
+		perror(snddevice->string);
+		Com_Printf("%d-bit sound not supported.", dma.samplebits);
+		close(audio_fd);
+		return 0;
+	}
+
+    if (ioctl(audio_fd, SNDCTL_DSP_GETOSPACE, &info)==-1) {   
+        perror("GETOSPACE");
+		Com_Printf("Um, can't do GETOSPACE?\n");
+		close(audio_fd);
+		return 0;
+    }
+
+	dma.samples = info.fragstotal * info.fragsize / (dma.samplebits/8);
+	dma.submission_chunk = 1;
+
+// memory map the dma buffer
+
+	if (!dma.buffer)
+		dma.buffer = (unsigned char *) mmap(NULL, info.fragstotal
+			* info.fragsize, PROT_WRITE, MAP_FILE|MAP_SHARED, audio_fd, 0);
+
+	if (!dma.buffer) {
+		perror(snddevice->string);
+		Com_Printf("Could not mmap %s\n", snddevice->string);
+		close(audio_fd);
+		return 0;
+	}
+
+// toggle the trigger & start her up
+
+    tmp = 0;
+    rc  = ioctl(audio_fd, SNDCTL_DSP_SETTRIGGER, &tmp);
+	if (rc < 0) {
+		perror(snddevice->string);
+		Com_Printf("Could not toggle.\n");
+		close(audio_fd);
+		return 0;
+	}
+
+    tmp = PCM_ENABLE_OUTPUT;
+    rc = ioctl(audio_fd, SNDCTL_DSP_SETTRIGGER, &tmp);
+	if (rc < 0) {
+		perror(snddevice->string);
+		Com_Printf("Could not toggle.\n");
+		close(audio_fd);
+
+		return 0;
+	}
+
+	snd_inited = 1;
+	return 1;
+}
+
+int SNDDMA_GetDMAPos(void)
+{
+	struct count_info count;
+
+	if (!snd_inited) return 0;
+
+	if (ioctl(audio_fd, SNDCTL_DSP_GETOPTR, &count) == -1) {
+		perror(snddevice->string);
+		Com_Printf("Uh, sound dead.\n");
+		close(audio_fd);
+		snd_inited = 0;
+		return 0;
+	}
+	return count.ptr / (dma.samplebits / 8);
+}
+
+void SNDDMA_Shutdown(void)
+{
+}
+
+/*
+==============
+SNDDMA_Submit
+
+Send sound to device if buffer isn't really the dma buffer
+===============
+*/
+void SNDDMA_Submit(void)
+{
+}
+
+void SNDDMA_BeginPainting (void)
+{
+}
diff --git a/code/unix/matha.s b/code/unix/matha.s
new file mode 100644
index 0000000..73174ee
--- /dev/null
+++ b/code/unix/matha.s
@@ -0,0 +1,402 @@
+//
+// math.s
+// x86 assembly-language math routines.
+
+#define GLQUAKE	1	// don't include unneeded defs
+#include "qasm.h"
+
+
+#if	id386
+
+	.data
+
+	.align	4
+Ljmptab:	.long	Lcase0, Lcase1, Lcase2, Lcase3
+			.long	Lcase4, Lcase5, Lcase6, Lcase7
+
+	.text
+
+// TODO: rounding needed?
+// stack parameter offset
+#define	val	4
+
+.globl C(Invert24To16)
+C(Invert24To16):
+
+	movl	val(%esp),%ecx
+	movl	$0x100,%edx		// 0x10000000000 as dividend
+	cmpl	%edx,%ecx
+	jle		LOutOfRange
+
+	subl	%eax,%eax
+	divl	%ecx
+
+	ret
+
+LOutOfRange:
+	movl	$0xFFFFFFFF,%eax
+	ret
+
+#if 0
+
+#define	in	4
+#define out	8
+
+	.align 2
+.globl C(TransformVector)
+C(TransformVector):
+	movl	in(%esp),%eax
+	movl	out(%esp),%edx
+
+	flds	(%eax)		// in[0]
+	fmuls	C(vright)		// in[0]*vright[0]
+	flds	(%eax)		// in[0] | in[0]*vright[0]
+	fmuls	C(vup)		// in[0]*vup[0] | in[0]*vright[0]
+	flds	(%eax)		// in[0] | in[0]*vup[0] | in[0]*vright[0]
+	fmuls	C(vpn)		// in[0]*vpn[0] | in[0]*vup[0] | in[0]*vright[0]
+
+	flds	4(%eax)		// in[1] | ...
+	fmuls	C(vright)+4	// in[1]*vright[1] | ...
+	flds	4(%eax)		// in[1] | in[1]*vright[1] | ...
+	fmuls	C(vup)+4		// in[1]*vup[1] | in[1]*vright[1] | ...
+	flds	4(%eax)		// in[1] | in[1]*vup[1] | in[1]*vright[1] | ...
+	fmuls	C(vpn)+4		// in[1]*vpn[1] | in[1]*vup[1] | in[1]*vright[1] | ...
+	fxch	%st(2)		// in[1]*vright[1] | in[1]*vup[1] | in[1]*vpn[1] | ...
+
+	faddp	%st(0),%st(5)	// in[1]*vup[1] | in[1]*vpn[1] | ...
+	faddp	%st(0),%st(3)	// in[1]*vpn[1] | ...
+	faddp	%st(0),%st(1)	// vpn_accum | vup_accum | vright_accum
+
+	flds	8(%eax)		// in[2] | ...
+	fmuls	C(vright)+8	// in[2]*vright[2] | ...
+	flds	8(%eax)		// in[2] | in[2]*vright[2] | ...
+	fmuls	C(vup)+8		// in[2]*vup[2] | in[2]*vright[2] | ...
+	flds	8(%eax)		// in[2] | in[2]*vup[2] | in[2]*vright[2] | ...
+	fmuls	C(vpn)+8		// in[2]*vpn[2] | in[2]*vup[2] | in[2]*vright[2] | ...
+	fxch	%st(2)		// in[2]*vright[2] | in[2]*vup[2] | in[2]*vpn[2] | ...
+
+	faddp	%st(0),%st(5)	// in[2]*vup[2] | in[2]*vpn[2] | ...
+	faddp	%st(0),%st(3)	// in[2]*vpn[2] | ...
+	faddp	%st(0),%st(1)	// vpn_accum | vup_accum | vright_accum
+
+	fstps	8(%edx)		// out[2]
+	fstps	4(%edx)		// out[1]
+	fstps	(%edx)		// out[0]
+
+	ret
+
+#endif
+
+#define EMINS	4+4
+#define EMAXS	4+8
+#define P		4+12
+
+	.align 2
+.globl C(BoxOnPlaneSide)
+C(BoxOnPlaneSide):
+	pushl	%ebx
+
+	movl	P(%esp),%edx
+	movl	EMINS(%esp),%ecx
+	xorl	%eax,%eax
+	movl	EMAXS(%esp),%ebx
+	movb	pl_signbits(%edx),%al
+	cmpb	$8,%al
+	jge		Lerror
+	flds	pl_normal(%edx)		// p->normal[0]
+	fld		%st(0)				// p->normal[0] | p->normal[0]
+	jmp		Ljmptab(,%eax,4)
+
+
+//dist1= p->normal[0]*emaxs[0] + p->normal[1]*emaxs[1] + p->normal[2]*emaxs[2];
+//dist2= p->normal[0]*emins[0] + p->normal[1]*emins[1] + p->normal[2]*emins[2];
+Lcase0:
+	fmuls	(%ebx)				// p->normal[0]*emaxs[0] | p->normal[0]
+	flds	pl_normal+4(%edx)	// p->normal[1] | p->normal[0]*emaxs[0] |
+								//  p->normal[0]
+	fxch	%st(2)				// p->normal[0] | p->normal[0]*emaxs[0] |
+								//  p->normal[1]
+	fmuls	(%ecx)				// p->normal[0]*emins[0] |
+								//  p->normal[0]*emaxs[0] | p->normal[1]
+	fxch	%st(2)				// p->normal[1] | p->normal[0]*emaxs[0] |
+								//  p->normal[0]*emins[0]
+	fld		%st(0)				// p->normal[1] | p->normal[1] |
+								//  p->normal[0]*emaxs[0] |
+								//  p->normal[0]*emins[0]
+	fmuls	4(%ebx)				// p->normal[1]*emaxs[1] | p->normal[1] |
+								//  p->normal[0]*emaxs[0] |
+								//  p->normal[0]*emins[0]
+	flds	pl_normal+8(%edx)	// p->normal[2] | p->normal[1]*emaxs[1] |
+								//  p->normal[1] | p->normal[0]*emaxs[0] |
+								//  p->normal[0]*emins[0]
+	fxch	%st(2)				// p->normal[1] | p->normal[1]*emaxs[1] |
+								//  p->normal[2] | p->normal[0]*emaxs[0] |
+								//  p->normal[0]*emins[0]
+	fmuls	4(%ecx)				// p->normal[1]*emins[1] |
+								//  p->normal[1]*emaxs[1] |
+								//  p->normal[2] | p->normal[0]*emaxs[0] |
+								//  p->normal[0]*emins[0]
+	fxch	%st(2)				// p->normal[2] | p->normal[1]*emaxs[1] |
+								//  p->normal[1]*emins[1] |
+								//  p->normal[0]*emaxs[0] |
+								//  p->normal[0]*emins[0]
+	fld		%st(0)				// p->normal[2] | p->normal[2] |
+								//  p->normal[1]*emaxs[1] |
+								//  p->normal[1]*emins[1] |
+								//  p->normal[0]*emaxs[0] |
+								//  p->normal[0]*emins[0]
+	fmuls	8(%ebx)				// p->normal[2]*emaxs[2] |
+								//  p->normal[2] |
+								//  p->normal[1]*emaxs[1] |
+								//  p->normal[1]*emins[1] |
+								//  p->normal[0]*emaxs[0] |
+								//  p->normal[0]*emins[0]
+	fxch	%st(5)				// p->normal[0]*emins[0] |
+								//  p->normal[2] |
+								//  p->normal[1]*emaxs[1] |
+								//  p->normal[1]*emins[1] |
+								//  p->normal[0]*emaxs[0] |
+								//  p->normal[2]*emaxs[2]
+	faddp	%st(0),%st(3)		//p->normal[2] |
+								// p->normal[1]*emaxs[1] |
+								// p->normal[1]*emins[1]+p->normal[0]*emins[0]|
+								// p->normal[0]*emaxs[0] |
+								// p->normal[2]*emaxs[2]
+	fmuls	8(%ecx)				//p->normal[2]*emins[2] |
+								// p->normal[1]*emaxs[1] |
+								// p->normal[1]*emins[1]+p->normal[0]*emins[0]|
+								// p->normal[0]*emaxs[0] |
+								// p->normal[2]*emaxs[2]
+	fxch	%st(1)				//p->normal[1]*emaxs[1] |
+								// p->normal[2]*emins[2] |
+								// p->normal[1]*emins[1]+p->normal[0]*emins[0]|
+								// p->normal[0]*emaxs[0] |
+								// p->normal[2]*emaxs[2]
+	faddp	%st(0),%st(3)		//p->normal[2]*emins[2] |
+								// p->normal[1]*emins[1]+p->normal[0]*emins[0]|
+								// p->normal[0]*emaxs[0]+p->normal[1]*emaxs[1]|
+								// p->normal[2]*emaxs[2]
+	fxch	%st(3)				//p->normal[2]*emaxs[2] +
+								// p->normal[1]*emins[1]+p->normal[0]*emins[0]|
+								// p->normal[0]*emaxs[0]+p->normal[1]*emaxs[1]|
+								// p->normal[2]*emins[2]
+	faddp	%st(0),%st(2)		//p->normal[1]*emins[1]+p->normal[0]*emins[0]|
+								// dist1 | p->normal[2]*emins[2]
+
+	jmp		LSetSides
+
+//dist1= p->normal[0]*emins[0] + p->normal[1]*emaxs[1] + p->normal[2]*emaxs[2];
+//dist2= p->normal[0]*emaxs[0] + p->normal[1]*emins[1] + p->normal[2]*emins[2];
+Lcase1:
+	fmuls	(%ecx)				// emins[0]
+	flds	pl_normal+4(%edx)
+	fxch	%st(2)
+	fmuls	(%ebx)				// emaxs[0]
+	fxch	%st(2)
+	fld		%st(0)
+	fmuls	4(%ebx)				// emaxs[1]
+	flds	pl_normal+8(%edx)
+	fxch	%st(2)
+	fmuls	4(%ecx)				// emins[1]
+	fxch	%st(2)
+	fld		%st(0)
+	fmuls	8(%ebx)				// emaxs[2]
+	fxch	%st(5)
+	faddp	%st(0),%st(3)
+	fmuls	8(%ecx)				// emins[2]
+	fxch	%st(1)
+	faddp	%st(0),%st(3)
+	fxch	%st(3)
+	faddp	%st(0),%st(2)
+
+	jmp		LSetSides
+
+//dist1= p->normal[0]*emaxs[0] + p->normal[1]*emins[1] + p->normal[2]*emaxs[2];
+//dist2= p->normal[0]*emins[0] + p->normal[1]*emaxs[1] + p->normal[2]*emins[2];
+Lcase2:
+	fmuls	(%ebx)				// emaxs[0]
+	flds	pl_normal+4(%edx)
+	fxch	%st(2)
+	fmuls	(%ecx)				// emins[0]
+	fxch	%st(2)
+	fld		%st(0)
+	fmuls	4(%ecx)				// emins[1]
+	flds	pl_normal+8(%edx)
+	fxch	%st(2)
+	fmuls	4(%ebx)				// emaxs[1]
+	fxch	%st(2)
+	fld		%st(0)
+	fmuls	8(%ebx)				// emaxs[2]
+	fxch	%st(5)
+	faddp	%st(0),%st(3)
+	fmuls	8(%ecx)				// emins[2]
+	fxch	%st(1)
+	faddp	%st(0),%st(3)
+	fxch	%st(3)
+	faddp	%st(0),%st(2)
+
+	jmp		LSetSides
+
+//dist1= p->normal[0]*emins[0] + p->normal[1]*emins[1] + p->normal[2]*emaxs[2];
+//dist2= p->normal[0]*emaxs[0] + p->normal[1]*emaxs[1] + p->normal[2]*emins[2];
+Lcase3:
+	fmuls	(%ecx)				// emins[0]
+	flds	pl_normal+4(%edx)
+	fxch	%st(2)
+	fmuls	(%ebx)				// emaxs[0]
+	fxch	%st(2)
+	fld		%st(0)
+	fmuls	4(%ecx)				// emins[1]
+	flds	pl_normal+8(%edx)
+	fxch	%st(2)
+	fmuls	4(%ebx)				// emaxs[1]
+	fxch	%st(2)
+	fld		%st(0)
+	fmuls	8(%ebx)				// emaxs[2]
+	fxch	%st(5)
+	faddp	%st(0),%st(3)
+	fmuls	8(%ecx)				// emins[2]
+	fxch	%st(1)
+	faddp	%st(0),%st(3)
+	fxch	%st(3)
+	faddp	%st(0),%st(2)
+
+	jmp		LSetSides
+
+//dist1= p->normal[0]*emaxs[0] + p->normal[1]*emaxs[1] + p->normal[2]*emins[2];
+//dist2= p->normal[0]*emins[0] + p->normal[1]*emins[1] + p->normal[2]*emaxs[2];
+Lcase4:
+	fmuls	(%ebx)				// emaxs[0]
+	flds	pl_normal+4(%edx)
+	fxch	%st(2)
+	fmuls	(%ecx)				// emins[0]
+	fxch	%st(2)
+	fld		%st(0)
+	fmuls	4(%ebx)				// emaxs[1]
+	flds	pl_normal+8(%edx)
+	fxch	%st(2)
+	fmuls	4(%ecx)				// emins[1]
+	fxch	%st(2)
+	fld		%st(0)
+	fmuls	8(%ecx)				// emins[2]
+	fxch	%st(5)
+	faddp	%st(0),%st(3)
+	fmuls	8(%ebx)				// emaxs[2]
+	fxch	%st(1)
+	faddp	%st(0),%st(3)
+	fxch	%st(3)
+	faddp	%st(0),%st(2)
+
+	jmp		LSetSides
+
+//dist1= p->normal[0]*emins[0] + p->normal[1]*emaxs[1] + p->normal[2]*emins[2];
+//dist2= p->normal[0]*emaxs[0] + p->normal[1]*emins[1] + p->normal[2]*emaxs[2];
+Lcase5:
+	fmuls	(%ecx)				// emins[0]
+	flds	pl_normal+4(%edx)
+	fxch	%st(2)
+	fmuls	(%ebx)				// emaxs[0]
+	fxch	%st(2)
+	fld		%st(0)
+	fmuls	4(%ebx)				// emaxs[1]
+	flds	pl_normal+8(%edx)
+	fxch	%st(2)
+	fmuls	4(%ecx)				// emins[1]
+	fxch	%st(2)
+	fld		%st(0)
+	fmuls	8(%ecx)				// emins[2]
+	fxch	%st(5)
+	faddp	%st(0),%st(3)
+	fmuls	8(%ebx)				// emaxs[2]
+	fxch	%st(1)
+	faddp	%st(0),%st(3)
+	fxch	%st(3)
+	faddp	%st(0),%st(2)
+
+	jmp		LSetSides
+
+//dist1= p->normal[0]*emaxs[0] + p->normal[1]*emins[1] + p->normal[2]*emins[2];
+//dist2= p->normal[0]*emins[0] + p->normal[1]*emaxs[1] + p->normal[2]*emaxs[2];
+Lcase6:
+	fmuls	(%ebx)				// emaxs[0]
+	flds	pl_normal+4(%edx)
+	fxch	%st(2)
+	fmuls	(%ecx)				// emins[0]
+	fxch	%st(2)
+	fld		%st(0)
+	fmuls	4(%ecx)				// emins[1]
+	flds	pl_normal+8(%edx)
+	fxch	%st(2)
+	fmuls	4(%ebx)				// emaxs[1]
+	fxch	%st(2)
+	fld		%st(0)
+	fmuls	8(%ecx)				// emins[2]
+	fxch	%st(5)
+	faddp	%st(0),%st(3)
+	fmuls	8(%ebx)				// emaxs[2]
+	fxch	%st(1)
+	faddp	%st(0),%st(3)
+	fxch	%st(3)
+	faddp	%st(0),%st(2)
+
+	jmp		LSetSides
+
+//dist1= p->normal[0]*emins[0] + p->normal[1]*emins[1] + p->normal[2]*emins[2];
+//dist2= p->normal[0]*emaxs[0] + p->normal[1]*emaxs[1] + p->normal[2]*emaxs[2];
+Lcase7:
+	fmuls	(%ecx)				// emins[0]
+	flds	pl_normal+4(%edx)
+	fxch	%st(2)
+	fmuls	(%ebx)				// emaxs[0]
+	fxch	%st(2)
+	fld		%st(0)
+	fmuls	4(%ecx)				// emins[1]
+	flds	pl_normal+8(%edx)
+	fxch	%st(2)
+	fmuls	4(%ebx)				// emaxs[1]
+	fxch	%st(2)
+	fld		%st(0)
+	fmuls	8(%ecx)				// emins[2]
+	fxch	%st(5)
+	faddp	%st(0),%st(3)
+	fmuls	8(%ebx)				// emaxs[2]
+	fxch	%st(1)
+	faddp	%st(0),%st(3)
+	fxch	%st(3)
+	faddp	%st(0),%st(2)
+
+LSetSides:
+
+//	sides = 0;
+//	if (dist1 >= p->dist)
+//		sides = 1;
+//	if (dist2 < p->dist)
+//		sides |= 2;
+
+	faddp	%st(0),%st(2)		// dist1 | dist2
+	fcomps	pl_dist(%edx)
+	xorl	%ecx,%ecx
+	fnstsw	%ax
+	fcomps	pl_dist(%edx)
+	andb	$1,%ah
+	xorb	$1,%ah
+	addb	%ah,%cl
+
+	fnstsw	%ax
+	andb	$1,%ah
+	addb	%ah,%ah
+	addb	%ah,%cl
+
+//	return sides;
+
+	popl	%ebx
+	movl	%ecx,%eax	// return status
+
+	ret
+
+
+Lerror:
+	movl	1, %eax
+	ret
+
+#endif	// id386
diff --git a/code/unix/q3test.spec.sh b/code/unix/q3test.spec.sh
new file mode 100644
index 0000000..a50e1f6
--- /dev/null
+++ b/code/unix/q3test.spec.sh
@@ -0,0 +1,41 @@
+#!/bin/sh
+# Generate Quake3 test
+# $1 is version
+# $2 is release
+# $3 is arch
+# $4 is install dir (assumed to be in /var/tmp)
+cat <<EOF
+%define name q3test
+%define version ${1}
+%define release ${2}
+%define arch ${3}
+%define builddir \$RPM_BUILD_DIR/%{name}-%{version}
+Name:		%{name}
+Version:	%{version}
+Release:	%{release}
+Vendor:		id Software
+Packager:	Dave "Zoid" Kirsch <zoid@idsoftware.com>
+URL:		http://www.idsoftware.com/
+Source:		q3test-%{version}.tar.gz
+Group:		Games
+Copyright:	Restricted
+Icon:		quake3.gif
+BuildRoot:	/var/tmp/%{name}-%{version}
+Summary:	Q3Test for Linux
+
+%description
+
+%install
+
+%files
+
+%attr(644,root,root) $4/README.EULA
+%attr(644,root,root) $4/README.Q3Test
+%attr(755,root,root) $4/linuxquake3
+%attr(755,root,root) $4/cgamei386.so
+%attr(755,root,root) $4/qagamei386.so
+%attr(755,root,root) $4/libMesaVoodooGL.so.3.1
+%attr(644,root,root) $4/demoq3/pak0.pk3
+
+EOF
+
diff --git a/code/unix/qasm.h b/code/unix/qasm.h
new file mode 100644
index 0000000..c31b6b8
--- /dev/null
+++ b/code/unix/qasm.h
@@ -0,0 +1,459 @@
+#ifndef __ASM_I386__
+#define __ASM_I386__
+
+#ifdef ELF
+#define C(label) label
+#else
+#define C(label) _##label
+#endif
+
+
+//#define GLQUAKE	1
+
+#if defined(_WIN32) && !defined(WINDED)
+
+#if defined(_M_IX86)
+#define __i386__	1
+#endif
+
+#endif
+
+#ifdef __i386__
+#define id386	1
+#else
+#define id386	0
+#endif
+
+// !!! must be kept the same as in d_iface.h !!!
+#define TRANSPARENT_COLOR	255
+
+#ifndef GLQUAKE
+	.extern C(d_zistepu)
+	.extern C(d_pzbuffer)
+	.extern C(d_zistepv)
+	.extern C(d_zrowbytes)
+	.extern C(d_ziorigin)
+	.extern C(r_turb_s)
+	.extern C(r_turb_t)
+	.extern C(r_turb_pdest)
+	.extern C(r_turb_spancount)
+	.extern C(r_turb_turb)
+	.extern C(r_turb_pbase)
+	.extern C(r_turb_sstep)
+	.extern C(r_turb_tstep)
+	.extern	C(r_bmodelactive)
+	.extern	C(d_sdivzstepu)
+	.extern	C(d_tdivzstepu)
+	.extern	C(d_sdivzstepv)
+	.extern	C(d_tdivzstepv)
+	.extern	C(d_sdivzorigin)
+	.extern	C(d_tdivzorigin)
+	.extern	C(sadjust)
+	.extern	C(tadjust)
+	.extern	C(bbextents)
+	.extern	C(bbextentt)
+	.extern	C(cacheblock)
+	.extern	C(d_viewbuffer)
+	.extern	C(cachewidth)
+	.extern	C(d_pzbuffer)
+	.extern	C(d_zrowbytes)
+	.extern	C(d_zwidth)
+	.extern C(d_scantable)
+	.extern C(r_lightptr)
+	.extern C(r_numvblocks)
+	.extern C(prowdestbase)
+	.extern C(pbasesource)
+	.extern C(r_lightwidth)
+	.extern C(lightright)
+	.extern C(lightrightstep)
+	.extern C(lightdeltastep)
+	.extern C(lightdelta)
+	.extern C(lightright)
+	.extern C(lightdelta)
+	.extern C(sourcetstep)
+	.extern C(surfrowbytes)
+	.extern C(lightrightstep)
+	.extern C(lightdeltastep)
+	.extern C(r_sourcemax)
+	.extern C(r_stepback)
+	.extern C(colormap)
+	.extern C(blocksize)
+	.extern C(sourcesstep)
+	.extern C(lightleft)
+	.extern C(blockdivshift)
+	.extern C(blockdivmask)
+	.extern C(lightleftstep)
+	.extern C(r_origin)
+	.extern C(r_ppn)
+	.extern C(r_pup)
+	.extern C(r_pright)
+	.extern C(ycenter)
+	.extern C(xcenter)
+	.extern C(d_vrectbottom_particle)
+	.extern C(d_vrectright_particle)
+	.extern C(d_vrecty)
+	.extern C(d_vrectx)
+	.extern C(d_pix_shift)
+	.extern C(d_pix_min)
+	.extern C(d_pix_max)
+	.extern C(d_y_aspect_shift)
+	.extern C(screenwidth)
+	.extern C(r_leftclipped)
+	.extern C(r_leftenter)
+	.extern C(r_rightclipped)
+	.extern C(r_rightenter)
+	.extern C(modelorg)
+	.extern C(xscale)
+	.extern C(r_refdef)
+	.extern C(yscale)
+	.extern C(r_leftexit)
+	.extern C(r_rightexit)
+	.extern C(r_lastvertvalid)
+	.extern C(cacheoffset)
+	.extern C(newedges)
+	.extern C(removeedges)
+	.extern C(r_pedge)
+	.extern C(r_framecount)
+	.extern C(r_u1)
+	.extern C(r_emitted)
+	.extern C(edge_p)
+	.extern C(surface_p)
+	.extern C(surfaces)
+	.extern C(r_lzi1)
+	.extern C(r_v1)
+	.extern C(r_ceilv1)
+	.extern C(r_nearzi)
+	.extern C(r_nearzionly)
+	.extern C(edge_aftertail)
+	.extern C(edge_tail)
+	.extern C(current_iv)
+	.extern C(edge_head_u_shift20)
+	.extern C(span_p)
+	.extern C(edge_head)
+	.extern C(fv)
+	.extern C(edge_tail_u_shift20)
+	.extern C(r_apverts)
+	.extern C(r_anumverts)
+	.extern C(aliastransform)
+	.extern C(r_avertexnormals)
+	.extern C(r_plightvec)
+	.extern C(r_ambientlight)
+	.extern C(r_shadelight)
+	.extern C(aliasxcenter)
+	.extern C(aliasycenter)
+	.extern C(a_sstepxfrac)
+	.extern C(r_affinetridesc)
+	.extern C(acolormap)
+	.extern C(d_pcolormap)
+	.extern C(r_affinetridesc)
+	.extern C(d_sfrac)
+	.extern C(d_ptex)
+	.extern C(d_pedgespanpackage)
+	.extern C(d_tfrac)
+	.extern C(d_light)
+	.extern C(d_zi)
+	.extern C(d_pdest)
+	.extern C(d_pz)
+	.extern C(d_aspancount)
+	.extern C(erroradjustup)
+	.extern C(errorterm)
+	.extern C(d_xdenom)
+	.extern C(r_p0)
+	.extern C(r_p1)
+	.extern C(r_p2)
+	.extern C(a_tstepxfrac)
+	.extern C(r_sstepx)
+	.extern C(r_tstepx)
+	.extern C(a_ststepxwhole)
+	.extern C(zspantable)
+	.extern C(skintable)
+	.extern C(r_zistepx)
+	.extern C(erroradjustdown)
+	.extern C(d_countextrastep)
+	.extern C(ubasestep)
+	.extern C(a_ststepxwhole)
+	.extern C(a_tstepxfrac)
+	.extern C(r_lstepx)
+	.extern C(a_spans)
+	.extern C(erroradjustdown)
+	.extern C(d_pdestextrastep)
+	.extern C(d_pzextrastep)
+	.extern C(d_sfracextrastep)
+	.extern C(d_ptexextrastep)
+	.extern C(d_countextrastep)
+	.extern C(d_tfracextrastep)
+	.extern C(d_lightextrastep)
+	.extern C(d_ziextrastep)
+	.extern C(d_pdestbasestep)
+	.extern C(d_pzbasestep)
+	.extern C(d_sfracbasestep)
+	.extern C(d_ptexbasestep)
+	.extern C(ubasestep)
+	.extern C(d_tfracbasestep)
+	.extern C(d_lightbasestep)
+	.extern C(d_zibasestep)
+	.extern C(zspantable)
+	.extern C(r_lstepy)
+	.extern C(r_sstepy)
+	.extern C(r_tstepy)
+	.extern C(r_zistepy)
+	.extern C(D_PolysetSetEdgeTable)
+	.extern C(D_RasterizeAliasPolySmooth)
+
+	.extern float_point5
+	.extern Float2ToThe31nd
+	.extern izistep
+	.extern izi
+	.extern FloatMinus2ToThe31nd
+	.extern float_1
+	.extern float_particle_z_clip
+	.extern float_minus_1
+	.extern float_0
+	.extern fp_16
+	.extern fp_64k
+	.extern fp_1m
+	.extern fp_1m_minus_1
+	.extern fp_8 
+	.extern entryvec_table
+	.extern advancetable
+	.extern sstep
+	.extern tstep
+	.extern pspantemp
+	.extern counttemp
+	.extern jumptemp
+	.extern reciprocal_table
+	.extern DP_Count
+	.extern DP_u
+	.extern DP_v
+	.extern DP_32768
+	.extern DP_Color
+	.extern DP_Pix
+	.extern DP_EntryTable
+	.extern	pbase
+	.extern s
+	.extern t
+	.extern sfracf
+	.extern tfracf
+	.extern snext
+	.extern tnext
+	.extern	spancountminus1
+	.extern zi16stepu
+	.extern sdivz16stepu
+	.extern tdivz16stepu
+	.extern	zi8stepu
+	.extern sdivz8stepu
+	.extern tdivz8stepu
+	.extern reciprocal_table_16
+	.extern entryvec_table_16
+	.extern ceil_cw
+	.extern single_cw
+	.extern fp_64kx64k
+	.extern pz
+	.extern spr8entryvec_table
+#endif
+
+	.extern C(snd_scaletable)
+	.extern C(paintbuffer)
+	.extern C(snd_linear_count)
+	.extern C(snd_p)
+	.extern C(snd_vol)
+	.extern C(snd_out)
+	.extern C(vright)
+	.extern C(vup)
+	.extern C(vpn)
+	.extern C(BOPS_Error)
+
+//
+// !!! note that this file must match the corresponding C structures at all
+// times !!!
+//
+
+// plane_t structure
+// !!! if this is changed, it must be changed in model.h too !!!
+// !!! if the size of this is changed, the array lookup in SV_HullPointContents
+//     must be changed too !!!
+#define pl_normal	0
+#define pl_dist		12
+#define pl_type		16
+#define pl_signbits	17
+#define pl_pad		18
+#define pl_size		20
+
+// hull_t structure
+// !!! if this is changed, it must be changed in model.h too !!!
+#define	hu_clipnodes		0
+#define	hu_planes			4
+#define	hu_firstclipnode	8
+#define	hu_lastclipnode		12
+#define	hu_clip_mins		16
+#define	hu_clip_maxs		28
+#define hu_size  			40
+
+// dnode_t structure
+// !!! if this is changed, it must be changed in bspfile.h too !!!
+#define	nd_planenum		0
+#define	nd_children		4
+#define	nd_mins			8
+#define	nd_maxs			20
+#define	nd_firstface	32
+#define	nd_numfaces		36
+#define nd_size			40
+
+// sfxcache_t structure
+// !!! if this is changed, it much be changed in sound.h too !!!
+#define sfxc_length		0
+#define sfxc_loopstart	4
+#define sfxc_speed		8
+#define sfxc_width		12
+#define sfxc_stereo		16
+#define sfxc_data		20
+
+// channel_t structure
+// !!! if this is changed, it much be changed in sound.h too !!!
+#define ch_sfx			0
+#define ch_leftvol		4
+#define ch_rightvol		8
+#define ch_end			12
+#define ch_pos			16
+#define ch_looping		20
+#define ch_entnum		24
+#define ch_entchannel	28
+#define ch_origin		32
+#define ch_dist_mult	44
+#define ch_master_vol	48
+#define ch_size			52
+
+// portable_samplepair_t structure
+// !!! if this is changed, it much be changed in sound.h too !!!
+#define psp_left		0
+#define psp_right		4
+#define psp_size		8
+
+
+//
+// !!! note that this file must match the corresponding C structures at all
+// times !!!
+//
+
+// !!! if this is changed, it must be changed in r_local.h too !!!
+#define	NEAR_CLIP	0.01
+
+// !!! if this is changed, it must be changed in r_local.h too !!!
+#define	CYCLE	128
+
+// espan_t structure
+// !!! if this is changed, it must be changed in r_shared.h too !!!
+#define espan_t_u    	0
+#define espan_t_v	    4
+#define espan_t_count   8
+#define espan_t_pnext	12
+#define espan_t_size    16
+
+// sspan_t structure
+// !!! if this is changed, it must be changed in d_local.h too !!!
+#define sspan_t_u    	0
+#define sspan_t_v	    4
+#define sspan_t_count   8
+#define sspan_t_size    12
+
+// spanpackage_t structure
+// !!! if this is changed, it must be changed in d_polyset.c too !!!
+#define spanpackage_t_pdest				0
+#define spanpackage_t_pz				4
+#define spanpackage_t_count				8
+#define spanpackage_t_ptex				12
+#define spanpackage_t_sfrac				16
+#define spanpackage_t_tfrac				20
+#define spanpackage_t_light				24
+#define spanpackage_t_zi				28
+#define spanpackage_t_size				32 
+
+// edge_t structure
+// !!! if this is changed, it must be changed in r_shared.h too !!!
+#define et_u			0
+#define et_u_step		4
+#define et_prev			8
+#define et_next			12
+#define et_surfs		16
+#define et_nextremove	20
+#define et_nearzi		24
+#define et_owner		28
+#define et_size			32
+
+// surf_t structure
+// !!! if this is changed, it must be changed in r_shared.h too !!!
+#define SURF_T_SHIFT	6
+#define st_next			0
+#define st_prev			4
+#define st_spans		8
+#define st_key			12
+#define st_last_u		16
+#define st_spanstate	20
+#define st_flags		24
+#define st_data			28
+#define st_entity		32
+#define st_nearzi		36
+#define st_insubmodel	40
+#define st_d_ziorigin	44
+#define st_d_zistepu	48
+#define st_d_zistepv	52
+#define st_pad			56
+#define st_size			64
+
+// clipplane_t structure
+// !!! if this is changed, it must be changed in r_local.h too !!!
+#define cp_normal		0
+#define cp_dist			12
+#define cp_next			16
+#define cp_leftedge		20
+#define cp_rightedge	21
+#define cp_reserved		22
+#define cp_size			24
+
+// medge_t structure
+// !!! if this is changed, it must be changed in model.h too !!!
+#define me_v				0
+#define me_cachededgeoffset	4
+#define me_size				8
+
+// mvertex_t structure
+// !!! if this is changed, it must be changed in model.h too !!!
+#define mv_position		0
+#define mv_size			12
+
+// refdef_t structure
+// !!! if this is changed, it must be changed in render.h too !!!
+#define rd_vrect					0
+#define rd_aliasvrect				20
+#define rd_vrectright				40
+#define rd_vrectbottom				44
+#define rd_aliasvrectright			48
+#define rd_aliasvrectbottom			52
+#define rd_vrectrightedge			56
+#define rd_fvrectx					60
+#define rd_fvrecty					64
+#define rd_fvrectx_adj				68
+#define rd_fvrecty_adj				72
+#define rd_vrect_x_adj_shift20		76
+#define rd_vrectright_adj_shift20	80
+#define rd_fvrectright_adj			84
+#define rd_fvrectbottom_adj			88
+#define rd_fvrectright				92
+#define rd_fvrectbottom				96
+#define rd_horizontalFieldOfView	100
+#define rd_xOrigin					104
+#define rd_yOrigin					108
+#define rd_vieworg					112
+#define rd_viewangles				124
+#define rd_ambientlight				136
+#define rd_size						140
+
+// mtriangle_t structure
+// !!! if this is changed, it must be changed in model.h too !!!
+#define mtri_facesfront		0
+#define mtri_vertindex		4
+#define mtri_size			16	// !!! if this changes, array indexing in !!!
+								// !!! d_polysa.s must be changed to match !!!
+#define mtri_shift			4
+
+#endif
diff --git a/code/unix/quake3.gif b/code/unix/quake3.gif
new file mode 100644
index 0000000..0e7a01c
Binary files /dev/null and b/code/unix/quake3.gif differ
diff --git a/code/unix/snd_mixa.s b/code/unix/snd_mixa.s
new file mode 100644
index 0000000..d6c2945
--- /dev/null
+++ b/code/unix/snd_mixa.s
@@ -0,0 +1,197 @@
+//
+// snd_mixa.s
+// x86 assembly-language sound code
+//
+
+#include "qasm.h"
+
+#if	id386
+
+	.text
+
+#if 0 
+//----------------------------------------------------------------------
+// 8-bit sound-mixing code
+//----------------------------------------------------------------------
+
+#define ch		4+16
+#define sc		8+16
+#define count	12+16
+
+.globl C(S_PaintChannelFrom8)
+C(S_PaintChannelFrom8):
+	pushl	%esi				// preserve register variables
+	pushl	%edi
+	pushl	%ebx
+	pushl	%ebp
+
+//	int 	data;
+//	short	*lscale, *rscale;
+//	unsigned char *sfx;
+//	int		i;
+
+	movl	ch(%esp),%ebx
+	movl	sc(%esp),%esi
+
+//	if (ch->leftvol > 255)
+//		ch->leftvol = 255;
+//	if (ch->rightvol > 255)
+//		ch->rightvol = 255;
+	movl	ch_leftvol(%ebx),%eax
+	movl	ch_rightvol(%ebx),%edx
+	cmpl	$255,%eax
+	jna		LLeftSet
+	movl	$255,%eax
+LLeftSet:
+	cmpl	$255,%edx
+	jna		LRightSet
+	movl	$255,%edx
+LRightSet:
+
+//	lscale = snd_scaletable[ch->leftvol >> 3];
+//	rscale = snd_scaletable[ch->rightvol >> 3];
+//	sfx = (signed char *)sc->data + ch->pos;
+//	ch->pos += count;
+	andl	$0xF8,%eax
+	addl	$20,%esi
+	movl	(%esi),%esi
+	andl	$0xF8,%edx
+	movl	ch_pos(%ebx),%edi
+	movl	count(%esp),%ecx
+	addl	%edi,%esi
+	shll	$7,%eax
+	addl	%ecx,%edi
+	shll	$7,%edx
+	movl	%edi,ch_pos(%ebx)
+	addl	$(C(snd_scaletable)),%eax
+	addl	$(C(snd_scaletable)),%edx
+	subl	%ebx,%ebx
+	movb	-1(%esi,%ecx,1),%bl
+
+	testl	$1,%ecx
+	jz		LMix8Loop
+
+	movl	(%eax,%ebx,4),%edi
+	movl	(%edx,%ebx,4),%ebp
+	addl	C(paintbuffer)+psp_left-psp_size(,%ecx,psp_size),%edi
+	addl	C(paintbuffer)+psp_right-psp_size(,%ecx,psp_size),%ebp
+	movl	%edi,C(paintbuffer)+psp_left-psp_size(,%ecx,psp_size)
+	movl	%ebp,C(paintbuffer)+psp_right-psp_size(,%ecx,psp_size)
+	movb	-2(%esi,%ecx,1),%bl
+
+	decl	%ecx
+	jz		LDone
+
+//	for (i=0 ; i<count ; i++)
+//	{
+LMix8Loop:
+
+//		data = sfx[i];
+//		paintbuffer[i].left += lscale[data];
+//		paintbuffer[i].right += rscale[data];
+	movl	(%eax,%ebx,4),%edi
+	movl	(%edx,%ebx,4),%ebp
+	addl	C(paintbuffer)+psp_left-psp_size(,%ecx,psp_size),%edi
+	addl	C(paintbuffer)+psp_right-psp_size(,%ecx,psp_size),%ebp
+	movb	-2(%esi,%ecx,1),%bl
+	movl	%edi,C(paintbuffer)+psp_left-psp_size(,%ecx,psp_size)
+	movl	%ebp,C(paintbuffer)+psp_right-psp_size(,%ecx,psp_size)
+
+	movl	(%eax,%ebx,4),%edi
+	movl	(%edx,%ebx,4),%ebp
+	movb	-3(%esi,%ecx,1),%bl
+	addl	C(paintbuffer)+psp_left-psp_size*2(,%ecx,psp_size),%edi
+	addl	C(paintbuffer)+psp_right-psp_size*2(,%ecx,psp_size),%ebp
+	movl	%edi,C(paintbuffer)+psp_left-psp_size*2(,%ecx,psp_size)
+	movl	%ebp,C(paintbuffer)+psp_right-psp_size*2(,%ecx,psp_size)
+
+//	}
+	subl	$2,%ecx
+	jnz		LMix8Loop
+
+LDone:
+	popl	%ebp
+	popl	%ebx
+	popl	%edi
+	popl	%esi
+
+	ret
+
+
+#endif
+
+//----------------------------------------------------------------------
+// Transfer of stereo buffer to 16-bit DMA buffer code
+//----------------------------------------------------------------------
+
+.globl C(S_WriteLinearBlastStereo16)
+C(S_WriteLinearBlastStereo16):
+	pushl	%edi
+	pushl	%ebx
+
+//	int		i;
+//	int		val;
+	movl	C(snd_linear_count),%ecx
+	movl	C(snd_p),%ebx
+	movl	C(snd_out),%edi
+
+//	for (i=0 ; i<snd_linear_count ; i+=2)
+//	{
+LWLBLoopTop:
+
+//		val = (snd_p[i]*snd_vol)>>8;
+//		if (val > 0x7fff)
+//			snd_out[i] = 0x7fff;
+//		else if (val < (short)0x8000)
+//			snd_out[i] = (short)0x8000;
+//		else
+//			snd_out[i] = val;
+	movl	-8(%ebx,%ecx,4),%eax
+	sarl	$8,%eax
+	cmpl	$0x7FFF,%eax
+	jg		LClampHigh
+	cmpl	$0xFFFF8000,%eax
+	jnl		LClampDone
+	movl	$0xFFFF8000,%eax
+	jmp		LClampDone
+LClampHigh:
+	movl	$0x7FFF,%eax
+LClampDone:
+
+//		val = (snd_p[i+1]*snd_vol)>>8;
+//		if (val > 0x7fff)
+//			snd_out[i+1] = 0x7fff;
+//		else if (val < (short)0x8000)
+//			snd_out[i+1] = (short)0x8000;
+//		else
+//			snd_out[i+1] = val;
+	movl	-4(%ebx,%ecx,4),%edx
+	sarl	$8,%edx
+	cmpl	$0x7FFF,%edx
+	jg		LClampHigh2
+	cmpl	$0xFFFF8000,%edx
+	jnl		LClampDone2
+	movl	$0xFFFF8000,%edx
+	jmp		LClampDone2
+LClampHigh2:
+	movl	$0x7FFF,%edx
+LClampDone2:
+	shll	$16,%edx
+	andl	$0xFFFF,%eax
+	orl		%eax,%edx
+	movl	%edx,-4(%edi,%ecx,2)
+
+//	}
+	subl	$2,%ecx
+	jnz		LWLBLoopTop
+
+//	snd_p += snd_linear_count;
+
+	popl	%ebx
+	popl	%edi
+
+	ret
+
+
+#endif	// id386
+
diff --git a/code/unix/sys_dosa.s b/code/unix/sys_dosa.s
new file mode 100644
index 0000000..cc29312
--- /dev/null
+++ b/code/unix/sys_dosa.s
@@ -0,0 +1,94 @@
+//
+// sys_dosa.s
+// x86 assembly-language DOS-dependent routines.
+
+#include "qasm.h"
+
+
+	.data
+
+	.align	4
+fpenv:
+	.long	0, 0, 0, 0, 0, 0, 0, 0
+
+	.text
+
+.globl C(MaskExceptions)
+C(MaskExceptions):
+	fnstenv	fpenv
+	orl		$0x3F,fpenv
+	fldenv	fpenv
+
+	ret
+
+#if 0
+.globl C(unmaskexceptions)
+C(unmaskexceptions):
+	fnstenv	fpenv
+	andl		$0xFFFFFFE0,fpenv
+	fldenv	fpenv
+
+	ret
+#endif
+
+	.data
+
+	.align	4
+.globl	ceil_cw, single_cw, full_cw, cw, pushed_cw
+ceil_cw:	.long	0
+single_cw:	.long	0
+full_cw:	.long	0
+cw:			.long	0
+pushed_cw:	.long	0
+
+	.text
+
+.globl C(Sys_LowFPPrecision)
+C(Sys_LowFPPrecision):
+	fldcw	single_cw
+
+	ret
+
+.globl C(Sys_HighFPPrecision)
+C(Sys_HighFPPrecision):
+	fldcw	full_cw
+
+	ret
+
+.globl C(Sys_PushFPCW_SetHigh)
+C(Sys_PushFPCW_SetHigh):
+	fnstcw	pushed_cw
+	fldcw	full_cw
+
+	ret
+
+.globl C(Sys_PopFPCW)
+C(Sys_PopFPCW):
+	fldcw	pushed_cw
+
+	ret
+
+.globl C(Sys_SetFPCW)
+C(Sys_SetFPCW):
+	fnstcw	cw
+	movl	cw,%eax
+#if	id386
+	andb	$0xF0,%ah
+	orb		$0x03,%ah	// round mode, 64-bit precision
+#endif
+	movl	%eax,full_cw
+
+#if	id386
+	andb	$0xF0,%ah
+	orb		$0x0C,%ah	// chop mode, single precision
+#endif
+	movl	%eax,single_cw
+
+#if	id386
+	andb	$0xF0,%ah
+	orb		$0x08,%ah	// ceil mode, single precision
+#endif
+	movl	%eax,ceil_cw
+
+	ret
+
diff --git a/code/unix/ui_video.c b/code/unix/ui_video.c
new file mode 100644
index 0000000..e1a3cce
--- /dev/null
+++ b/code/unix/ui_video.c
@@ -0,0 +1,702 @@
+#include "../client/client.h"
+#include "../client/ui_local.h"
+
+extern void UI_ForceMenuOff( void );
+
+static const char *s_driver_names[] =
+{
+	"[default OpenGL]",
+	"[Voodoo OpenGL]",
+	"[Custom       ]",
+	0
+};
+
+static const char *s_drivers[] =
+{
+	OPENGL_DRIVER_NAME,
+	_3DFX_DRIVER_NAME,
+	"",
+	0
+};
+
+/*
+====================================================================
+
+MENU INTERACTION
+
+====================================================================
+*/
+static menuframework_s	s_menu;
+
+static menulist_s		s_graphics_options_list;
+static menulist_s		s_mode_list;
+static menulist_s		s_driver_list;
+static menuslider_s		s_tq_slider;
+static menulist_s  		s_fs_box;
+static menulist_s  		s_lighting_box;
+static menulist_s  		s_allow_extensions_box;
+static menulist_s  		s_texturebits_box;
+static menulist_s  		s_colordepth_list;
+static menulist_s  		s_geometry_box;
+static menulist_s  		s_filter_box;
+static menuaction_s		s_driverinfo_action;
+static menuaction_s		s_apply_action;
+static menuaction_s		s_defaults_action;
+
+typedef struct
+{
+	int mode;
+	qboolean fullscreen;
+	int tq;
+	int lighting;
+	int colordepth;
+	int texturebits;
+	int geometry;
+	int filter;
+	int driver;
+	qboolean extensions;
+} InitialVideoOptions_s;
+
+static InitialVideoOptions_s s_ivo;
+
+static InitialVideoOptions_s s_ivo_templates[] =
+{
+	{
+		4, qtrue, 2, 0, 2, 2, 1, 1, 0, qtrue	// JDC: this was tq 3
+	},
+	{
+		3, qtrue, 2, 0, 0, 0, 1, 0, 0, qtrue
+	},
+	{
+		2, qtrue, 1, 0, 1, 0, 0, 0, 0, qtrue
+	},
+	{
+		1, qtrue, 1, 1, 1, 0, 0, 0, 0, qtrue
+	},
+	{
+		3, qtrue, 1, 0, 0, 0, 1, 0, 0, qtrue
+	}
+};
+
+#define NUM_IVO_TEMPLATES ( sizeof( s_ivo_templates ) / sizeof( s_ivo_templates[0] ) )
+
+static void DrvInfo_MenuDraw( void );
+static const char * DrvInfo_MenuKey( int key );
+
+static void GetInitialVideoVars( void )
+{
+	s_ivo.colordepth = s_colordepth_list.curvalue;
+	s_ivo.driver = s_driver_list.curvalue;
+	s_ivo.mode = s_mode_list.curvalue;
+	s_ivo.fullscreen = s_fs_box.curvalue;
+	s_ivo.extensions = s_allow_extensions_box.curvalue;
+	s_ivo.tq = s_tq_slider.curvalue;
+	s_ivo.lighting = s_lighting_box.curvalue;
+	s_ivo.geometry = s_geometry_box.curvalue;
+	s_ivo.filter = s_filter_box.curvalue;
+	s_ivo.texturebits = s_texturebits_box.curvalue;
+}
+
+static void CheckConfigVsTemplates( void )
+{
+	int i;
+
+	for ( i = 0; i < NUM_IVO_TEMPLATES; i++ )
+	{
+		if ( s_driver_list.curvalue != 1 )
+			if ( s_ivo_templates[i].colordepth != s_colordepth_list.curvalue )
+				continue;
+#if 0
+		if ( s_ivo_templates[i].driver != s_driver_list.curvalue )
+			continue;
+#endif
+		if ( s_ivo_templates[i].mode != s_mode_list.curvalue )
+			continue;
+		if ( s_driver_list.curvalue != 1 )
+			if ( s_ivo_templates[i].fullscreen != s_fs_box.curvalue )
+				continue;
+		if ( s_ivo_templates[i].tq != s_tq_slider.curvalue )
+			continue;
+		if ( s_ivo_templates[i].lighting != s_lighting_box.curvalue )
+			continue;
+		if ( s_ivo_templates[i].geometry != s_geometry_box.curvalue )
+			continue;
+		if ( s_ivo_templates[i].filter != s_filter_box.curvalue )
+			continue;
+//		if ( s_ivo_templates[i].texturebits != s_texturebits_box.curvalue )
+//			continue;
+		s_graphics_options_list.curvalue = i;
+		return;
+	}
+	s_graphics_options_list.curvalue = 4;
+}
+
+static void UpdateMenuItemValues( void )
+{
+	if ( s_driver_list.curvalue == 1 )
+	{
+		s_fs_box.curvalue = 1;
+		s_fs_box.generic.flags = QMF_GRAYED;
+		s_colordepth_list.curvalue = 1;
+	}
+	else
+	{
+		s_fs_box.generic.flags = 0;
+	}
+
+	if ( s_fs_box.curvalue == 0 || s_driver_list.curvalue == 1 )
+	{
+		s_colordepth_list.curvalue = 0;
+		s_colordepth_list.generic.flags = QMF_GRAYED;
+	}
+	else
+	{
+		s_colordepth_list.generic.flags = 0;
+	}
+
+	if ( s_allow_extensions_box.curvalue == 0 )
+	{
+		if ( s_texturebits_box.curvalue == 0 )
+		{
+			s_texturebits_box.curvalue = 1;
+		}
+	}
+
+	s_apply_action.generic.flags = QMF_GRAYED;
+
+	if ( s_ivo.mode != s_mode_list.curvalue )
+	{
+		s_apply_action.generic.flags = QMF_BLINK;
+	}
+	if ( s_ivo.fullscreen != s_fs_box.curvalue )
+	{
+		s_apply_action.generic.flags = QMF_BLINK;
+	}
+	if ( s_ivo.extensions != s_allow_extensions_box.curvalue )
+	{
+		s_apply_action.generic.flags = QMF_BLINK;
+	}
+	if ( s_ivo.tq != s_tq_slider.curvalue )
+	{
+		s_apply_action.generic.flags = QMF_BLINK;
+	}
+	if ( s_ivo.lighting != s_lighting_box.curvalue )
+	{
+		s_apply_action.generic.flags = QMF_BLINK;
+	}
+	if ( s_ivo.colordepth != s_colordepth_list.curvalue )
+	{
+		s_apply_action.generic.flags = QMF_BLINK;
+	}
+	if ( s_ivo.driver != s_driver_list.curvalue )
+	{
+		s_apply_action.generic.flags = QMF_BLINK;
+	}
+	if ( s_ivo.texturebits != s_texturebits_box.curvalue )
+	{
+		s_apply_action.generic.flags = QMF_BLINK;
+	}
+	if ( s_ivo.geometry != s_geometry_box.curvalue )
+	{
+		s_apply_action.generic.flags = QMF_BLINK;
+	}
+	if ( s_ivo.filter != s_filter_box.curvalue )
+	{
+		s_apply_action.generic.flags = QMF_BLINK;
+	}
+
+	CheckConfigVsTemplates();
+}	
+
+static void SetMenuItemValues( void )
+{
+	s_mode_list.curvalue = Cvar_VariableValue( "r_mode" );
+	s_fs_box.curvalue = Cvar_VariableValue("r_fullscreen");
+	s_allow_extensions_box.curvalue = Cvar_VariableValue("r_allowExtensions");
+	s_tq_slider.curvalue = 3-Cvar_VariableValue( "r_picmip");
+	if ( s_tq_slider.curvalue < 0 )
+	{
+	   s_tq_slider.curvalue = 0;
+	}
+	else if ( s_tq_slider.curvalue > 3 )
+	{
+	   s_tq_slider.curvalue = 3;
+	}
+
+	s_lighting_box.curvalue = Cvar_VariableValue( "r_vertexLight" ) != 0;
+	switch ( ( int ) Cvar_VariableValue( "r_texturebits" ) )
+	{
+	case 0:
+	default:
+		s_texturebits_box.curvalue = 0;
+		break;
+	case 16:
+		s_texturebits_box.curvalue = 1;
+		break;
+	case 32:
+		s_texturebits_box.curvalue = 2;
+		break;
+	}
+
+	if ( !Q_stricmp( Cvar_VariableString( "r_textureMode" ), "GL_LINEAR_MIPMAP_NEAREST" ) )
+	{
+		s_filter_box.curvalue = 0;
+	}
+	else
+	{
+		s_filter_box.curvalue = 1;
+	}
+
+	if ( Cvar_VariableValue( "r_subdivisions" ) == 999 ||
+		 Cvar_VariableValue( "r_lodBias" ) > 0 )
+	{
+		s_geometry_box.curvalue = 0;
+	}
+	else
+	{
+		s_geometry_box.curvalue = 1;
+	}
+
+	switch ( ( int ) Cvar_VariableValue( "r_colorbits" ) )
+	{
+	default:
+	case 0:
+		s_colordepth_list.curvalue = 0;
+		break;
+	case 16:
+		s_colordepth_list.curvalue = 1;
+		break;
+	case 32:
+		s_colordepth_list.curvalue = 2;
+		break;
+	}
+
+	if ( s_fs_box.curvalue == 0 )
+	{
+		s_colordepth_list.curvalue = 0;
+	}
+	if ( s_driver_list.curvalue == 1 )
+	{
+		s_colordepth_list.curvalue = 1;
+	}
+}
+
+static void FullscreenCallback( void *s )
+{
+}
+
+static void ModeCallback( void *s )
+{
+	// clamp 3dfx video modes
+	if ( s_driver_list.curvalue == 1 )
+	{
+		if ( s_mode_list.curvalue < 2 )
+		{
+			s_mode_list.curvalue = 2;
+		}
+		else if ( s_mode_list.curvalue > 6 )
+		{
+			s_mode_list.curvalue = 6;
+		}
+	}
+}
+
+static void GraphicsOptionsCallback( void *s )
+{
+	InitialVideoOptions_s *ivo = &s_ivo_templates[s_graphics_options_list.curvalue];
+
+	s_mode_list.curvalue = ivo->mode;
+	s_tq_slider.curvalue = ivo->tq;
+	s_lighting_box.curvalue = ivo->lighting;
+	s_colordepth_list.curvalue = ivo->colordepth;
+	s_texturebits_box.curvalue = ivo->texturebits;
+	s_geometry_box.curvalue = ivo->geometry;
+	s_filter_box.curvalue = ivo->filter;
+	s_fs_box.curvalue = ivo->fullscreen;
+}
+
+static void TextureDetailCallback( void *s )
+{
+}
+
+static void TextureQualityCallback( void *s )
+{
+}
+
+static void ExtensionsCallback( void *s )
+{
+}
+
+static void ColorDepthCallback( void *s )
+{
+}
+
+static void DriverInfoCallback( void *s )
+{
+	UI_PushMenu( DrvInfo_MenuDraw, DrvInfo_MenuKey );
+}
+
+static void LightingCallback( void * s )
+{
+}
+
+static void ApplyChanges( void *unused )
+{
+	switch ( s_texturebits_box.curvalue  )
+	{
+	case 0:
+		Cvar_SetValue( "r_texturebits", 0 );
+		Cvar_SetValue( "r_ext_compress_textures", 1 );
+		break;
+	case 1:
+		Cvar_SetValue( "r_texturebits", 16 );
+		Cvar_SetValue( "r_ext_compress_textures", 0 );
+		break;
+	case 2:
+		Cvar_SetValue( "r_texturebits", 32 );
+		Cvar_SetValue( "r_ext_compress_textures", 0 );
+		break;
+	}
+	Cvar_SetValue( "r_picmip", 3 - s_tq_slider.curvalue );
+	Cvar_SetValue( "r_allowExtensions", s_allow_extensions_box.curvalue );
+	Cvar_SetValue( "r_mode", s_mode_list.curvalue );
+	Cvar_SetValue( "r_fullscreen", s_fs_box.curvalue );
+	if (*s_drivers[s_driver_list.curvalue] )
+		Cvar_Set( "r_glDriver", ( char * ) s_drivers[s_driver_list.curvalue] );
+	switch ( s_colordepth_list.curvalue )
+	{
+	case 0:
+		Cvar_SetValue( "r_colorbits", 0 );
+		Cvar_SetValue( "r_depthbits", 0 );
+		Cvar_SetValue( "r_stencilbits", 0 );
+		break;
+	case 1:
+		Cvar_SetValue( "r_colorbits", 16 );
+		Cvar_SetValue( "r_depthbits", 16 );
+		Cvar_SetValue( "r_stencilbits", 0 );
+		break;
+	case 2:
+		Cvar_SetValue( "r_colorbits", 32 );
+		Cvar_SetValue( "r_depthbits", 24 );
+		break;
+	}
+	Cvar_SetValue( "r_vertexLight", s_lighting_box.curvalue );
+
+	if ( s_geometry_box.curvalue )
+	{
+		Cvar_SetValue( "r_lodBias", 0 );
+		Cvar_SetValue( "r_subdivisions", 4 );
+	}
+	else
+	{
+		Cvar_SetValue( "r_lodBias", 1 );
+		Cvar_SetValue( "r_subdivisions", 999 );
+	}
+
+	if ( s_filter_box.curvalue )
+	{
+		Cvar_Set( "r_textureMode", "GL_LINEAR_MIPMAP_LINEAR" );
+	}
+	else
+	{
+		Cvar_Set( "r_textureMode", "GL_LINEAR_MIPMAP_NEAREST" );
+	}
+
+	UI_ForceMenuOff();
+
+	CL_Vid_Restart_f();
+
+	VID_MenuInit();
+
+//	s_fs_box.curvalue = Cvar_VariableValue( "r_fullscreen" );
+}
+
+/*
+** VID_MenuInit
+*/
+void VID_MenuInit( void )
+{
+	static const char *tq_names[] =
+	{
+		"compressed",
+		"16-bit",
+		"32-bit",
+		0
+	};
+
+	static const char *s_graphics_options_names[] =
+	{
+		"high quality",
+		"normal",
+		"fast",
+		"fastest",
+		"custom",
+		0
+	};
+
+	static const char *lighting_names[] =
+	{
+		"lightmap",
+		"vertex",
+		0
+	};
+
+	static const char *colordepth_names[] =
+	{
+		"default",
+		"16-bit",
+		"32-bit",
+		0
+	};
+
+	static const char *resolutions[] = 
+	{
+		"[320 240  ]",
+		"[400 300  ]",
+		"[512 384  ]",
+		"[640 480  ]",
+		"[800 600  ]",
+		"[960 720  ]",
+		"[1024 768 ]",
+		"[1152 864 ]",
+		"[1280 960 ]",
+		"[1600 1200]",
+		"[2048 1536]",
+		"[856 480 W]",
+		0
+	};
+	static const char *filter_names[] =
+	{
+		"bilinear",
+		"trilinear",
+		0
+	};
+	static const char *quality_names[] =
+	{
+		"low",
+		"high",
+		0
+	};
+	static const char *enabled_names[] =
+	{
+		"disabled",
+		"enabled",
+		0
+	};
+	int y = 0;
+	int i;
+	char *p;
+
+	s_menu.x = SCREEN_WIDTH * 0.50;
+	s_menu.nitems = 0;
+	s_menu.wrapAround = qtrue;
+
+	s_graphics_options_list.generic.type = MTYPE_SPINCONTROL;
+	s_graphics_options_list.generic.name = "graphics mode";
+	s_graphics_options_list.generic.x = 0;
+	s_graphics_options_list.generic.y = y;
+	s_graphics_options_list.generic.callback = GraphicsOptionsCallback;
+	s_graphics_options_list.itemnames = s_graphics_options_names;
+
+	s_driver_list.generic.type = MTYPE_SPINCONTROL;
+	s_driver_list.generic.name = "driver";
+	s_driver_list.generic.x = 0;
+	s_driver_list.generic.y = y += 18;
+
+	p = Cvar_VariableString( "r_glDriver" );
+	for (i = 0; s_drivers[i]; i++) {
+		if (strcmp(s_drivers[i], p) == 0)
+			break;
+	}
+	if (!s_drivers[i])
+		i--; // go back one, to default 'custom'
+	s_driver_list.curvalue = i;
+
+	s_driver_list.itemnames = s_driver_names;
+
+	// references/modifies "r_allowExtensions"
+	s_allow_extensions_box.generic.type = MTYPE_SPINCONTROL;
+	s_allow_extensions_box.generic.x	= 0;
+	s_allow_extensions_box.generic.y	= y += 18;
+	s_allow_extensions_box.generic.name	= "OpenGL extensions";
+	s_allow_extensions_box.generic.callback = ExtensionsCallback;
+	s_allow_extensions_box.itemnames = enabled_names;
+
+	// references/modifies "r_mode"
+	s_mode_list.generic.type = MTYPE_SPINCONTROL;
+	s_mode_list.generic.name = "video mode";
+	s_mode_list.generic.x = 0;
+	s_mode_list.generic.y = y += 36;
+	s_mode_list.itemnames = resolutions;
+	s_mode_list.generic.callback = ModeCallback;
+
+	// references "r_colorbits"
+	s_colordepth_list.generic.type = MTYPE_SPINCONTROL;
+	s_colordepth_list.generic.name = "color depth";
+	s_colordepth_list.generic.x = 0;
+	s_colordepth_list.generic.y = y += 18;
+	s_colordepth_list.itemnames = colordepth_names;
+	s_colordepth_list.generic.callback = ColorDepthCallback;
+
+	// references/modifies "r_fullscreen"
+	s_fs_box.generic.type = MTYPE_RADIOBUTTON;
+	s_fs_box.generic.x	= 0;
+	s_fs_box.generic.y	= y += 18;
+	s_fs_box.generic.name	= "fullscreen";
+	s_fs_box.generic.callback = FullscreenCallback;
+
+	// references/modifies "r_vertexLight"
+	s_lighting_box.generic.type = MTYPE_SPINCONTROL;
+	s_lighting_box.generic.x	= 0;
+	s_lighting_box.generic.y	= y += 18;
+	s_lighting_box.generic.name	= "lighting";
+	s_lighting_box.itemnames = lighting_names;
+	s_lighting_box.generic.callback = LightingCallback;
+
+	// references/modifies "r_lodBias" & "subdivisions"
+	s_geometry_box.generic.type = MTYPE_SPINCONTROL;
+	s_geometry_box.generic.x	= 0;
+	s_geometry_box.generic.y	= y += 18;
+	s_geometry_box.generic.name	= "geometric detail";
+	s_geometry_box.itemnames = quality_names;
+
+	// references/modifies "r_picmip"
+	s_tq_slider.generic.type	= MTYPE_SLIDER;
+	s_tq_slider.generic.x		= 0;
+	s_tq_slider.generic.y		= y += 18;
+	s_tq_slider.generic.name	= "texture detail";
+	s_tq_slider.generic.callback = TextureDetailCallback;
+	s_tq_slider.minvalue = 0;
+	s_tq_slider.maxvalue = 3;
+
+	// references/modifies "r_textureBits"
+	s_texturebits_box.generic.type = MTYPE_SPINCONTROL;
+	s_texturebits_box.generic.x	= 0;
+	s_texturebits_box.generic.y	= y += 18;
+	s_texturebits_box.generic.name	= "texture quality";
+	s_texturebits_box.generic.callback = TextureQualityCallback;
+	s_texturebits_box.itemnames = tq_names;
+
+	// references/modifies "r_textureMode"
+	s_filter_box.generic.type = MTYPE_SPINCONTROL;
+	s_filter_box.generic.x	= 0;
+	s_filter_box.generic.y	= y += 18;
+	s_filter_box.generic.name	= "texture filter";
+	s_filter_box.itemnames = filter_names;
+
+	s_driverinfo_action.generic.type = MTYPE_ACTION;
+	s_driverinfo_action.generic.name = "driver information";
+	s_driverinfo_action.generic.x    = 0;
+	s_driverinfo_action.generic.y    = y += 36;
+	s_driverinfo_action.generic.callback = DriverInfoCallback;
+
+	s_apply_action.generic.type = MTYPE_ACTION;
+	s_apply_action.generic.name = "apply";
+	s_apply_action.generic.x    = 0;
+	s_apply_action.generic.y    = y += 36;
+	s_apply_action.generic.callback = ApplyChanges;
+	s_apply_action.generic.flags = QMF_GRAYED;
+
+	SetMenuItemValues();
+	GetInitialVideoVars();
+
+	Menu_AddItem( &s_menu, ( void * ) &s_graphics_options_list );
+	Menu_AddItem( &s_menu, ( void * ) &s_driver_list );
+	Menu_AddItem( &s_menu, ( void * ) &s_allow_extensions_box );
+	Menu_AddItem( &s_menu, ( void * ) &s_mode_list );
+	Menu_AddItem( &s_menu, ( void * ) &s_colordepth_list );
+	Menu_AddItem( &s_menu, ( void * ) &s_fs_box );
+	Menu_AddItem( &s_menu, ( void * ) &s_lighting_box );
+	Menu_AddItem( &s_menu, ( void * ) &s_geometry_box );
+	Menu_AddItem( &s_menu, ( void * ) &s_tq_slider );
+	Menu_AddItem( &s_menu, ( void * ) &s_texturebits_box );
+	Menu_AddItem( &s_menu, ( void * ) &s_filter_box );
+
+	Menu_AddItem( &s_menu, ( void * ) &s_driverinfo_action );
+	Menu_AddItem( &s_menu, ( void * ) &s_apply_action );
+
+	Menu_Center( &s_menu );
+	s_menu.y -= 6;
+}
+
+/*
+================
+VID_MenuDraw
+================
+*/
+void VID_MenuDraw (void)
+{
+	UpdateMenuItemValues();
+	Menu_AdjustCursor( &s_menu, 1 );
+	Menu_Draw( &s_menu );
+}
+
+/*
+================
+VID_MenuKey
+================
+*/
+const char *VID_MenuKey( int key )
+{
+	menuframework_s *m = &s_menu;
+	static const char *sound = "sound/misc/menu1.wav";
+
+	if ( key == K_ENTER )
+	{
+		if ( !Menu_SelectItem( m ) )
+			ApplyChanges( NULL );
+		return NULL;
+	}
+	return Default_MenuKey( m, key );
+
+}
+
+static void DrvInfo_MenuDraw( void )
+{
+	float labelColor[] = { 0, 1.0, 0, 1.0 };
+	float textColor[] = { 1, 1, 1, 1 };
+	int i = 14;
+	char extensionsString[1024], *eptr = extensionsString;
+
+	SCR_DrawBigStringColor( BIGCHAR_WIDTH * 4, BIGCHAR_HEIGHT * 3, "VENDOR:", labelColor );
+	SCR_DrawBigStringColor( BIGCHAR_WIDTH * 4, BIGCHAR_HEIGHT * 4, Cvar_VariableString( "gl_vendor" ), textColor );
+	SCR_DrawBigStringColor( BIGCHAR_WIDTH * 4, BIGCHAR_HEIGHT * 5.5, "VERSION:", labelColor );
+	SCR_DrawBigStringColor( BIGCHAR_WIDTH * 4, BIGCHAR_HEIGHT * 6.5, Cvar_VariableString( "gl_version" ), textColor );
+	SCR_DrawBigStringColor( BIGCHAR_WIDTH * 4, BIGCHAR_HEIGHT * 8, "RENDERER:", labelColor );
+	SCR_DrawBigStringColor( BIGCHAR_WIDTH * 4, BIGCHAR_HEIGHT * 9, Cvar_VariableString( "gl_renderer" ), textColor );
+	SCR_DrawBigStringColor( BIGCHAR_WIDTH * 4, BIGCHAR_HEIGHT * 10.5, "PIXELFORMAT:", labelColor );
+	SCR_DrawBigStringColor( BIGCHAR_WIDTH * 4, BIGCHAR_HEIGHT * 11.5, Cvar_VariableString( "gl_pixelformat" ), textColor );
+
+	SCR_DrawBigStringColor( BIGCHAR_WIDTH * 4, BIGCHAR_HEIGHT * 13, "EXTENSIONS:", labelColor );
+	strcpy( extensionsString, Cvar_VariableString( "gl_extensions" ) );
+	while ( i < 25 && *eptr )
+	{
+		while ( *eptr )
+		{
+			char buf[2] = " ";
+			int j = BIGCHAR_WIDTH * 6;
+
+			while ( *eptr && *eptr != ' ' )
+			{
+				buf[0] = *eptr;
+				SCR_DrawBigStringColor( j, i * BIGCHAR_HEIGHT, buf, textColor );
+				j += BIGCHAR_WIDTH;
+				eptr++;
+			}
+
+			i++;
+
+			while ( *eptr && *eptr == ' ' )
+				eptr++;
+		}
+	}
+}
+
+static const char * DrvInfo_MenuKey( int key )
+{
+	if ( key == K_ESCAPE )
+		UI_PopMenu();
+	return NULL;
+}
+
+
diff --git a/code/unix/unix_glw.h b/code/unix/unix_glw.h
new file mode 100644
index 0000000..41a02f1
--- /dev/null
+++ b/code/unix/unix_glw.h
@@ -0,0 +1,17 @@
+#ifndef __linux__
+#error You shouldnt be including this file on non-Linux platforms
+#endif
+
+#ifndef __GLW_LINUX_H__
+#define __GLW_LINUX_H__
+
+typedef struct
+{
+	void *OpenGLLib; // instance of OpenGL library
+
+	FILE *log_fp;
+} glwstate_t;
+
+extern glwstate_t glw_state;
+
+#endif
diff --git a/code/unix/unix_main.c b/code/unix/unix_main.c
new file mode 100644
index 0000000..d2d415f
--- /dev/null
+++ b/code/unix/unix_main.c
@@ -0,0 +1,809 @@
+#include <unistd.h>
+#include <signal.h>
+#include <stdlib.h>
+#include <limits.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <sys/ipc.h>
+#include <sys/shm.h>
+#include <sys/stat.h>
+#include <string.h>
+#include <ctype.h>
+#include <sys/wait.h>
+#include <sys/mman.h>
+#include <errno.h>
+#include <mntent.h>
+
+#include <dlfcn.h>
+
+#include "../game/q_shared.h"
+#include "../qcommon/qcommon.h"
+#include "../renderer/tr_public.h"
+
+cvar_t *nostdout;
+
+// Structure containing functions exported from refresh DLL
+refexport_t	re;
+
+unsigned	sys_frame_time;
+
+uid_t saved_euid;
+qboolean stdin_active = qtrue;
+
+// =======================================================================
+// General routines
+// =======================================================================
+
+void Sys_BeginProfiling( void ) {
+}
+
+/*
+=================
+Sys_In_Restart_f
+
+Restart the input subsystem
+=================
+*/
+void Sys_In_Restart_f( void ) 
+{
+	IN_Shutdown();
+	IN_Init();
+}
+
+void Sys_ConsoleOutput (char *string)
+{
+	if (nostdout && nostdout->value)
+		return;
+
+	fputs(string, stdout);
+}
+
+void Sys_Printf (char *fmt, ...)
+{
+	va_list		argptr;
+	char		text[1024];
+	unsigned char		*p;
+
+	va_start (argptr,fmt);
+	vsprintf (text,fmt,argptr);
+	va_end (argptr);
+
+	if (strlen(text) > sizeof(text))
+		Sys_Error("memory overwrite in Sys_Printf");
+
+    if (nostdout && nostdout->value)
+        return;
+
+	for (p = (unsigned char *)text; *p; p++) {
+		*p &= 0x7f;
+		if ((*p > 128 || *p < 32) && *p != 10 && *p != 13 && *p != 9)
+			printf("[%02x]", *p);
+		else
+			putc(*p, stdout);
+	}
+}
+
+void Sys_Quit (void)
+{
+	CL_Shutdown ();
+    fcntl (0, F_SETFL, fcntl (0, F_GETFL, 0) & ~FNDELAY);
+	_exit(0);
+}
+
+void Sys_Init(void)
+{
+	Cmd_AddCommand ("in_restart", Sys_In_Restart_f);
+
+#if id386
+	Sys_SetFPCW();
+#endif
+
+#if defined __linux__
+#if defined __i386__
+	Cvar_Set( "arch", "linux i386" );
+#elif defined __alpha__
+	Cvar_Set( "arch", "linux alpha" );
+#elif defined __sparc__
+	Cvar_Set( "arch", "linux sparc" );
+#else
+	Cvar_Set( "arch", "linux unknown" );
+#endif
+#elif defined __sun__
+#if defined __i386__
+	Cvar_Set( "arch", "solaris x86" );
+#elif defined __sparc__
+	Cvar_Set( "arch", "solaris sparc" );
+#else
+	Cvar_Set( "arch", "solaris unknown" );
+#endif
+#elif defined __sgi__
+#if defined __mips__
+	Cvar_Set( "arch", "sgi mips" );
+#else
+	Cvar_Set( "arch", "sgi unknown" );
+#endif
+#else
+	Cvar_Set( "arch", "unknown" );
+#endif
+
+	IN_Init();
+
+}
+
+void	Sys_Error( const char *error, ...)
+{ 
+    va_list     argptr;
+    char        string[1024];
+
+// change stdin to non blocking
+    fcntl (0, F_SETFL, fcntl (0, F_GETFL, 0) & ~FNDELAY);
+
+	CL_Shutdown ();
+    
+    va_start (argptr,error);
+    vsprintf (string,error,argptr);
+    va_end (argptr);
+	fprintf(stderr, "Error: %s\n", string);
+
+	_exit (1);
+
+} 
+
+void Sys_Warn (char *warning, ...)
+{ 
+    va_list     argptr;
+    char        string[1024];
+    
+    va_start (argptr,warning);
+    vsprintf (string,warning,argptr);
+    va_end (argptr);
+	fprintf(stderr, "Warning: %s", string);
+} 
+
+/*
+============
+Sys_FileTime
+
+returns -1 if not present
+============
+*/
+int	Sys_FileTime (char *path)
+{
+	struct	stat	buf;
+	
+	if (stat (path,&buf) == -1)
+		return -1;
+	
+	return buf.st_mtime;
+}
+
+void floating_point_exception_handler(int whatever)
+{
+//	Sys_Warn("floating point exception\n");
+	signal(SIGFPE, floating_point_exception_handler);
+}
+
+char *Sys_ConsoleInput(void)
+{
+    static char text[256];
+    int     len;
+	fd_set	fdset;
+    struct timeval timeout;
+
+	if (!com_dedicated || !com_dedicated->value)
+		return NULL;
+
+	if (!stdin_active)
+		return NULL;
+
+	FD_ZERO(&fdset);
+	FD_SET(0, &fdset); // stdin
+	timeout.tv_sec = 0;
+	timeout.tv_usec = 0;
+	if (select (1, &fdset, NULL, NULL, &timeout) == -1 || !FD_ISSET(0, &fdset))
+		return NULL;
+
+	len = read (0, text, sizeof(text));
+	if (len == 0) { // eof!
+		stdin_active = qfalse;
+		return NULL;
+	}
+
+	if (len < 1)
+		return NULL;
+	text[len-1] = 0;    // rip off the /n and terminate
+
+	return text;
+}
+
+/*****************************************************************************/
+
+static void *game_library;
+
+#ifdef __i386__
+	const char *gamename = "qagamei386.so";
+#elif defined __alpha__
+	const char *gamename = "qagameaxp.so";
+#elif defined __mips__
+	const char *gamename = "qagamemips.so";
+#else
+#error Unknown arch
+#endif
+
+/*
+=================
+Sys_UnloadGame
+=================
+*/
+void Sys_UnloadGame (void)
+{
+	Com_Printf("------ Unloading %s ------\n", gamename);
+	if (game_library) 
+		dlclose (game_library);
+	game_library = NULL;
+}
+
+/*
+=================
+Sys_GetGameAPI
+
+Loads the game dll
+=================
+*/
+void *Sys_GetGameAPI (void *parms)
+{
+	void	*(*GetGameAPI) (void *);
+
+	char	name[MAX_OSPATH];
+	char	curpath[MAX_OSPATH];
+	char	*path;
+	if (game_library)
+		Com_Error (ERR_FATAL, "Sys_GetGameAPI without Sys_UnloadingGame");
+
+	// check the current debug directory first for development purposes
+	getcwd(curpath, sizeof(curpath));
+
+	Com_Printf("------- Loading %s -------\n", gamename);
+	Com_sprintf (name, sizeof(name), "%s/%s", curpath, gamename);
+
+	game_library = dlopen (name, RTLD_LAZY );
+	if (game_library)
+		Com_DPrintf ("LoadLibrary (%s)\n",name);
+	else {
+		Com_Printf( "LoadLibrary(\"%s\") failed\n", name);
+		Com_Printf( "...reason: '%s'\n", dlerror() );
+		Com_Error( ERR_FATAL, "Couldn't load game" );
+	}
+
+	GetGameAPI = (void *)dlsym (game_library, "GetGameAPI");
+	if (!GetGameAPI)
+	{
+		Sys_UnloadGame ();		
+		return NULL;
+	}
+
+	return GetGameAPI (parms);
+}
+
+/*****************************************************************************/
+
+static void *cgame_library;
+
+/*
+=================
+Sys_UnloadGame
+=================
+*/
+void Sys_UnloadCGame (void)
+{
+	if (cgame_library) 
+		dlclose (cgame_library);
+	cgame_library = NULL;
+}
+
+/*
+=================
+Sys_GetGameAPI
+
+Loads the game dll
+=================
+*/
+void *Sys_GetCGameAPI (void)
+{
+	void	*(*api) (void);
+
+	char	name[MAX_OSPATH];
+	char	curpath[MAX_OSPATH];
+#ifdef __i386__
+	const char *cgamename = "cgamei386.so";
+#elif defined __alpha__
+	const char *cgamename = "cgameaxp.so";
+#elif defined __mips__
+	const char *cgamename = "cgamemips.so";
+#else
+#error Unknown arch
+#endif
+
+	Sys_UnloadCGame();
+
+	getcwd(curpath, sizeof(curpath));
+
+	Com_Printf("------- Loading %s -------\n", cgamename);
+
+	sprintf (name, "%s/%s", curpath, cgamename);
+	cgame_library = dlopen (name, RTLD_LAZY );
+	if (!cgame_library)
+	{
+		Com_Printf ("LoadLibrary (%s)\n",name);
+		Com_Error( ERR_FATAL, "Couldn't load cgame: %s", dlerror() );
+	}
+
+	api = (void *)dlsym (cgame_library, "GetCGameAPI");
+	if (!api)
+	{
+		Com_Error( ERR_FATAL, "dlsym() failed on GetCGameAPI" );
+	}
+
+	return api();
+}
+
+/*****************************************************************************/
+
+static void *ui_library;
+
+/*
+=================
+Sys_UnloadUI
+=================
+*/
+void Sys_UnloadUI(void)
+{
+	if (ui_library) 
+		dlclose (ui_library);
+	ui_library = NULL;
+}
+
+/*
+=================
+Sys_GetUIAPI
+
+Loads the ui dll
+=================
+*/
+void *Sys_GetUIAPI (void)
+{
+	void	*api;
+
+	char	name[MAX_OSPATH];
+	char	curpath[MAX_OSPATH];
+#ifdef __i386__
+	const char *uiname = "uii386.so";
+#elif defined __alpha__
+	const char *uiname = "uiaxp.so";
+#elif defined __mips__
+	const char *uiname = "uimips.so";
+#else
+#error Unknown arch
+#endif
+
+	Sys_UnloadUI();
+
+	getcwd(curpath, sizeof(curpath));
+
+	Com_Printf("------- Loading %s -------\n", uiname);
+
+	sprintf (name, "%s/%s", curpath, uiname);
+	ui_library = dlopen (name, RTLD_LAZY );
+	if (!ui_library)
+	{
+		Com_Printf ("LoadLibrary (%s)\n",name);
+		Com_Error( ERR_FATAL, "Couldn't load ui: %s", dlerror() );
+	}
+
+	api = (void *)dlsym (ui_library, "GetUIAPI");
+	if (!api)
+	{
+		Com_Error( ERR_FATAL, "dlsym() failed on GetUIAPI" );
+	}
+
+	return api;
+}
+
+/*****************************************************************************/
+
+void *Sys_GetRefAPI (void *parms) 
+{
+	return (void *)GetRefAPI(REF_API_VERSION, parms);
+}
+
+/*
+========================================================================
+
+BACKGROUND FILE STREAMING
+
+========================================================================
+*/
+
+typedef struct {
+#if 0
+	HANDLE	threadHandle;
+	int		threadId;
+	CRITICAL_SECTION	crit;
+#endif
+	FILE	*file;
+	byte	*buffer;
+	qboolean	eof;
+	int		bufferSize;
+	int		streamPosition;	// next byte to be returned by Sys_StreamRead
+	int		threadPosition;	// next byte to be read from file
+} streamState_t;
+
+streamState_t	stream;
+
+/*
+===============
+Sys_StreamThread
+
+A thread will be sitting in this loop forever
+================
+*/
+void Sys_StreamThread( void ) 
+{
+	int		buffer;
+	int		count;
+	int		readCount;
+	int		bufferPoint;
+	int		r;
+
+//Loop here
+//	EnterCriticalSection (&stream.crit);
+
+	// if there is any space left in the buffer, fill it up
+	if ( !stream.eof ) {
+		count = stream.bufferSize - (stream.threadPosition - stream.streamPosition);
+		if ( count ) {
+			bufferPoint = stream.threadPosition % stream.bufferSize;
+			buffer = stream.bufferSize - bufferPoint;
+			readCount = buffer < count ? buffer : count;
+			r = fread( stream.buffer + bufferPoint, 1, readCount, stream.file );
+			stream.threadPosition += r;
+
+			if ( r != readCount )
+				stream.eof = qtrue;
+		}
+	}
+
+//	LeaveCriticalSection (&stream.crit);
+}
+
+/*
+===============
+Sys_InitStreamThread
+
+================
+*/
+void Sys_InitStreamThread( void ) 
+{
+}
+
+/*
+===============
+Sys_ShutdownStreamThread
+
+================
+*/
+void Sys_ShutdownStreamThread( void ) 
+{
+}
+
+
+/*
+===============
+Sys_BeginStreamedFile
+
+================
+*/
+void Sys_BeginStreamedFile( fileHandle_t f, int readAhead ) 
+{
+	if ( stream.file ) {
+		Com_Error( ERR_FATAL, "Sys_BeginStreamedFile: unclosed stream");
+	}
+
+	stream.file = f;
+	stream.buffer = Z_Malloc( readAhead );
+	stream.bufferSize = readAhead;
+	stream.streamPosition = 0;
+	stream.threadPosition = 0;
+	stream.eof = qfalse;
+
+	// let the thread start running
+//	LeaveCriticalSection( &stream.crit );
+}
+
+/*
+===============
+Sys_EndStreamedFile
+
+================
+*/
+void Sys_EndStreamedFile( FILE *f ) 
+{
+	if ( f != stream.file ) {
+		Com_Error( ERR_FATAL, "Sys_EndStreamedFile: wrong file");
+	}
+	// don't leave critical section until another stream is started
+//	EnterCriticalSection( &stream.crit );
+
+	stream.file = NULL;
+	Z_Free( stream.buffer );
+}
+
+
+/*
+===============
+Sys_StreamedRead
+
+================
+*/
+int Sys_StreamedRead( void *buffer, int size, int count, FILE *f ) 
+{
+	int		available;
+	int		remaining;
+	int		sleepCount;
+	int		copy;
+	int		bufferCount;
+	int		bufferPoint;
+	byte	*dest;
+
+	dest = (byte *)buffer;
+	remaining = size * count;
+
+	if ( remaining <= 0 ) {
+		Com_Error( ERR_FATAL, "Streamed read with non-positive size" );
+	}
+
+	sleepCount = 0;
+	while ( remaining > 0 ) {
+		available = stream.threadPosition - stream.streamPosition;
+		if ( !available ) {
+			if (stream.eof)
+				break;
+			Sys_StreamThread();
+			continue;
+		}
+
+		bufferPoint = stream.streamPosition % stream.bufferSize;
+		bufferCount = stream.bufferSize - bufferPoint;
+
+		copy = available < bufferCount ? available : bufferCount;
+		if ( copy > remaining ) {
+			copy = remaining;
+		}
+		memcpy( dest, stream.buffer + bufferPoint, copy );
+		stream.streamPosition += copy;
+		dest += copy;
+		remaining -= copy;
+	}
+
+	return (count * size - remaining) / size;
+}
+
+/*
+===============
+Sys_StreamSeek
+
+================
+*/
+void Sys_StreamSeek( FILE *f, int offset, int origin ) {
+
+	// halt the thread
+//	EnterCriticalSection( &stream.crit );
+
+	// clear to that point
+	fseek( f, offset, origin );
+	stream.streamPosition = 0;
+	stream.threadPosition = 0;
+	stream.eof = qfalse;
+
+	// let the thread start running at the new position
+//	LeaveCriticalSection( &stream.crit );
+}
+
+
+/*
+========================================================================
+
+EVENT LOOP
+
+========================================================================
+*/
+
+#define	MAX_QUED_EVENTS		64
+#define	MASK_QUED_EVENTS	( MAX_QUED_EVENTS - 1 )
+
+sysEvent_t	eventQue[MAX_QUED_EVENTS];
+int			eventHead, eventTail;
+byte		sys_packetReceived[MAX_MSGLEN];
+
+/*
+================
+Sys_QueEvent
+
+A time of 0 will get the current time
+Ptr should either be null, or point to a block of data that can
+be freed by the game later.
+================
+*/
+void Sys_QueEvent( int time, sysEventType_t type, int value, int value2, int ptrLength, void *ptr ) {
+	sysEvent_t	*ev;
+
+	ev = &eventQue[ eventHead & MASK_QUED_EVENTS ];
+	eventHead++;
+
+	if ( time == 0 ) {
+		time = Sys_Milliseconds();
+	}
+
+	ev->evTime = time;
+	ev->evType = type;
+	ev->evValue = value;
+	ev->evValue2 = value2;
+	ev->evPtrLength = ptrLength;
+	ev->evPtr = ptr;
+}
+
+/*
+================
+Sys_GetEvent
+
+================
+*/
+sysEvent_t Sys_GetEvent( void ) {
+	sysEvent_t	ev;
+	char		*s;
+	msg_t		netmsg;
+	netadr_t	adr;
+
+	// return if we have data
+	if ( eventHead > eventTail ) {
+		eventTail++;
+		return eventQue[ ( eventTail - 1 ) & MASK_QUED_EVENTS ];
+	}
+
+	// pump the message loop
+	// in vga this calls KBD_Update, under X, it calls GetEvent
+	Sys_SendKeyEvents ();
+
+	// check for console commands
+	s = Sys_ConsoleInput();
+	if ( s ) {
+		char	*b;
+		int		len;
+
+		len = strlen( s ) + 1;
+		b = malloc( len );
+		strcpy( b, s );
+		Sys_QueEvent( 0, SE_CONSOLE, 0, 0, len, b );
+	}
+
+	// check for other input devices
+	IN_Frame();
+
+	// check for network packets
+	MSG_Init( &netmsg, sys_packetReceived, sizeof( sys_packetReceived ) );
+	if ( Sys_GetPacket ( &adr, &netmsg ) ) {
+		netadr_t		*buf;
+		int				len;
+
+		// copy out to a seperate buffer for qeueing
+		len = sizeof( netadr_t ) + netmsg.cursize;
+		buf = malloc( len );
+		*buf = adr;
+		memcpy( buf+1, netmsg.data, netmsg.cursize );
+		Sys_QueEvent( 0, SE_PACKET, 0, 0, len, buf );
+	}
+
+	// return if we have data
+	if ( eventHead > eventTail ) {
+		eventTail++;
+		return eventQue[ ( eventTail - 1 ) & MASK_QUED_EVENTS ];
+	}
+
+	// create an empty event to return
+
+	memset( &ev, 0, sizeof( ev ) );
+	ev.evTime = Sys_Milliseconds();
+
+	return ev;
+}
+
+/*****************************************************************************/
+
+void Sys_AppActivate (void)
+{
+}
+
+char *Sys_GetClipboardData(void)
+{
+	return NULL;
+}
+
+void	Sys_Print( const char *msg )
+{
+	fputs(msg, stderr);
+}
+
+int main (int argc, char **argv)
+{
+	int 	oldtime, newtime;
+	int		len, i;
+	char	*cmdline;
+	void SetProgramPath(char *path);
+
+	// go back to real user for config loads
+	saved_euid = geteuid();
+	seteuid(getuid());
+
+	SetProgramPath(argv[0]);
+
+	// merge the command line, this is kinda silly
+	for (len = 1, i = 1; i < argc; i++)
+		len += strlen(argv[i]) + 1;
+	cmdline = malloc(len);
+	*cmdline = 0;
+	for (i = 1; i < argc; i++) {
+		if (i > 1)
+			strcat(cmdline, " ");
+		strcat(cmdline, argv[i]);
+	}
+	Com_Init(cmdline);
+	NET_Init();
+
+	fcntl(0, F_SETFL, fcntl (0, F_GETFL, 0) | FNDELAY);
+
+	nostdout = Cvar_Get("nostdout", "0", 0);
+	if (!nostdout->value) {
+		fcntl(0, F_SETFL, fcntl (0, F_GETFL, 0) | FNDELAY);
+//		printf ("Linux Quake -- Version %0.3f\n", LINUX_VERSION);
+	}
+
+    while (1)
+    {
+		// set low precision every frame, because some system calls
+		// reset it arbitrarily
+		Sys_LowFPPrecision ();    
+
+        Com_Frame ();
+    }
+}
+
+#if 0
+/*
+================
+Sys_MakeCodeWriteable
+================
+*/
+void Sys_MakeCodeWriteable (unsigned long startaddr, unsigned long length)
+{
+
+	int r;
+	unsigned long addr;
+	int psize = getpagesize();
+
+	addr = (startaddr & ~(psize-1)) - psize;
+
+//	fprintf(stderr, "writable code %lx(%lx)-%lx, length=%lx\n", startaddr,
+//			addr, startaddr+length, length);
+
+	r = mprotect((char*)addr, length + startaddr - addr + psize, 7);
+
+	if (r < 0)
+    		Sys_Error("Protection change failed\n");
+
+}
+
+#endif
diff --git a/code/unix/unix_net.c b/code/unix/unix_net.c
new file mode 100644
index 0000000..72806f2
--- /dev/null
+++ b/code/unix/unix_net.c
@@ -0,0 +1,443 @@
+// unix_net.c
+
+#include "../game/q_shared.h"
+#include "../qcommon/qcommon.h"
+
+#include <unistd.h>
+#include <sys/socket.h>
+#include <sys/time.h>
+#include <netinet/in.h>
+#include <netdb.h>
+#include <sys/param.h>
+#include <sys/ioctl.h>
+#include <sys/uio.h>
+#include <errno.h>
+
+#ifdef NeXT
+#include <libc.h>
+#endif
+
+static cvar_t	*noudp;
+
+netadr_t	net_local_adr;
+
+int			ip_socket;
+int			ipx_socket;
+
+#define	MAX_IPS		16
+static	int		numIP;
+static	byte	localIP[MAX_IPS][4];
+
+int NET_Socket (char *net_interface, int port);
+char *NET_ErrorString (void);
+
+//=============================================================================
+
+void NetadrToSockadr (netadr_t *a, struct sockaddr_in *s)
+{
+	memset (s, 0, sizeof(*s));
+
+	if (a->type == NA_BROADCAST)
+	{
+		s->sin_family = AF_INET;
+
+		s->sin_port = a->port;
+		*(int *)&s->sin_addr = -1;
+	}
+	else if (a->type == NA_IP)
+	{
+		s->sin_family = AF_INET;
+
+		*(int *)&s->sin_addr = *(int *)&a->ip;
+		s->sin_port = a->port;
+	}
+}
+
+void SockadrToNetadr (struct sockaddr_in *s, netadr_t *a)
+{
+	*(int *)&a->ip = *(int *)&s->sin_addr;
+	a->port = s->sin_port;
+	a->type = NA_IP;
+}
+
+char	*NET_BaseAdrToString (netadr_t a)
+{
+	static	char	s[64];
+	
+	Com_sprintf (s, sizeof(s), "%i.%i.%i.%i", a.ip[0], a.ip[1], a.ip[2], a.ip[3]);
+
+	return s;
+}
+
+/*
+=============
+Sys_StringToAdr
+
+idnewt
+192.246.40.70
+=============
+*/
+qboolean	Sys_StringToSockaddr (const char *s, struct sockaddr *sadr)
+{
+	struct hostent	*h;
+	char	*colon;
+	
+	memset (sadr, 0, sizeof(*sadr));
+	((struct sockaddr_in *)sadr)->sin_family = AF_INET;
+	
+	((struct sockaddr_in *)sadr)->sin_port = 0;
+	
+	if ( s[0] >= '0' && s[0] <= '9')
+	{
+		*(int *)&((struct sockaddr_in *)sadr)->sin_addr = inet_addr(s);
+	}
+	else
+	{
+		if (! (h = gethostbyname(s)) )
+			return qfalse;
+		*(int *)&((struct sockaddr_in *)sadr)->sin_addr = *(int *)h->h_addr_list[0];
+	}
+	
+	return qtrue;
+}
+
+/*
+=============
+Sys_StringToAdr
+
+localhost
+idnewt
+idnewt:28000
+192.246.40.70
+192.246.40.70:28000
+=============
+*/
+qboolean	Sys_StringToAdr (const char *s, netadr_t *a)
+{
+	struct sockaddr_in sadr;
+	
+	if (!Sys_StringToSockaddr (s, (struct sockaddr *)&sadr))
+		return qfalse;
+	
+	SockadrToNetadr (&sadr, a);
+
+	return qtrue;
+}
+
+
+//=============================================================================
+
+qboolean	Sys_GetPacket (netadr_t *net_from, msg_t *net_message)
+{
+	int 	ret;
+	struct sockaddr_in	from;
+	int		fromlen;
+	int		net_socket;
+	int		protocol;
+	int		err;
+
+	for (protocol = 0 ; protocol < 2 ; protocol++)
+	{
+		if (protocol == 0)
+			net_socket = ip_socket;
+		else
+			net_socket = ipx_socket;
+
+		if (!net_socket)
+			continue;
+
+		fromlen = sizeof(from);
+		ret = recvfrom (net_socket, net_message->data, net_message->maxsize
+			, 0, (struct sockaddr *)&from, &fromlen);
+
+		SockadrToNetadr (&from, net_from);
+
+		if (ret == -1)
+		{
+			err = errno;
+
+			if (err == EWOULDBLOCK || err == ECONNREFUSED)
+				continue;
+			Com_Printf ("NET_GetPacket: %s from %s\n", NET_ErrorString(),
+						NET_AdrToString(*net_from));
+			continue;
+		}
+
+		if (ret == net_message->maxsize)
+		{
+			Com_Printf ("Oversize packet from %s\n", NET_AdrToString (*net_from));
+			continue;
+		}
+
+		net_message->cursize = ret;
+		return qtrue;
+	}
+
+	return qfalse;
+}
+
+//=============================================================================
+
+void	Sys_SendPacket( int length, const void *data, netadr_t to )
+{
+	int		ret;
+	struct sockaddr_in	addr;
+	int		net_socket;
+
+	if (to.type == NA_BROADCAST)
+	{
+		net_socket = ip_socket;
+	}
+	else if (to.type == NA_IP)
+	{
+		net_socket = ip_socket;
+	}
+	else if (to.type == NA_IPX)
+	{
+		net_socket = ipx_socket;
+	}
+	else if (to.type == NA_BROADCAST_IPX)
+	{
+		net_socket = ipx_socket;
+	}
+	else {
+		Com_Error (ERR_FATAL, "NET_SendPacket: bad address type");
+		return;
+	}
+
+	if (!net_socket)
+		return;
+
+	NetadrToSockadr (&to, &addr);
+
+	ret = sendto (net_socket, data, length, 0, (struct sockaddr *)&addr, sizeof(addr) );
+	if (ret == -1)
+	{
+		Com_Printf ("NET_SendPacket ERROR: %s to %s\n", NET_ErrorString(),
+				NET_AdrToString (to));
+	}
+}
+
+
+//=============================================================================
+
+/*
+==================
+Sys_IsLANAddress
+
+LAN clients will have their rate var ignored
+==================
+*/
+qboolean	Sys_IsLANAddress (netadr_t adr) {
+	int		i;
+	if ( adr.type == NA_LOOPBACK ) {
+		return qtrue;
+	}
+
+	// FIXME: ipx?
+
+	if ( adr.type == NA_IP ) {
+		for ( i = 0 ; i < numIP ; i++ ) {
+			// assuming a class C network, which may not be smart...
+			if ( adr.ip[0] == localIP[i][0]
+				&& adr.ip[1] == localIP[i][1]
+				&& adr.ip[2] == localIP[i][2] ) {
+				return qtrue;
+			}
+		}
+	}
+
+	return qfalse;
+}
+
+/*
+=====================
+NET_GetLocalAddress
+=====================
+*/
+void NET_GetLocalAddress( void ) {
+	char				hostname[256];
+	struct hostent		*hostInfo;
+	int					error;
+	char				*p;
+	int					ip;
+	int					n;
+
+	if ( gethostname( hostname, 256 ) == -1 ) {
+		return;
+	}
+
+	hostInfo = gethostbyname( hostname );
+	if ( !hostInfo ) {
+		return;
+	}
+
+	Com_Printf( "Hostname: %s\n", hostInfo->h_name );
+	n = 0;
+	while( ( p = hostInfo->h_aliases[n++] ) != NULL ) {
+		Com_Printf( "Alias: %s\n", p );
+	}
+
+	if ( hostInfo->h_addrtype != AF_INET ) {
+		return;
+	}
+
+	numIP = 0;
+	while( ( p = hostInfo->h_addr_list[numIP++] ) != NULL && numIP < MAX_IPS ) {
+		ip = ntohl( *(int *)p );
+		localIP[ numIP ][0] = p[0];
+		localIP[ numIP ][1] = p[1];
+		localIP[ numIP ][2] = p[2];
+		localIP[ numIP ][3] = p[3];
+		Com_Printf( "IP: %i.%i.%i.%i\n", ( ip >> 24 ) & 0xff, ( ip >> 16 ) & 0xff, ( ip >> 8 ) & 0xff, ip & 0xff );
+	}
+}
+
+/*
+====================
+NET_OpenIP
+====================
+*/
+void NET_OpenIP (void)
+{
+	cvar_t	*ip;
+	int		port;
+	int		i;
+
+	ip = Cvar_Get ("net_ip", "localhost", 0);
+
+	port = Cvar_Get("net_port", va("%i", PORT_SERVER), 0)->value;
+
+	for ( i = 0 ; i < 10 ; i++ ) {
+		ip_socket = NET_IPSocket (ip->string, port + i);
+		if ( ip_socket ) {
+			Cvar_SetValue( "net_port", port + i );
+			NET_GetLocalAddress();
+			return;
+		}
+	}
+	Com_Error (ERR_FATAL, "Couldn't allocate IP port");
+}
+
+
+/*
+====================
+NET_Init
+====================
+*/
+void NET_Init (void)
+{
+	noudp = Cvar_Get ("net_noudp", "0", 0);
+	// open sockets
+	if (! noudp->value) {
+		NET_OpenIP ();
+	}
+}
+
+
+/*
+====================
+NET_Socket
+====================
+*/
+int NET_IPSocket (char *net_interface, int port)
+{
+	int newsocket;
+	struct sockaddr_in address;
+	qboolean _qtrue = qtrue;
+	int	i = 1;
+
+	if ( net_interface ) {
+		Com_Printf("Opening IP socket: %s:%i\n", net_interface, port );
+	} else {
+		Com_Printf("Opening IP socket: localhost:%i\n", port );
+	}
+
+	if ((newsocket = socket (PF_INET, SOCK_DGRAM, IPPROTO_UDP)) == -1)
+	{
+		Com_Printf ("ERROR: UDP_OpenSocket: socket: %s", NET_ErrorString());
+		return 0;
+	}
+
+	// make it non-blocking
+	if (ioctl (newsocket, FIONBIO, &_qtrue) == -1)
+	{
+		Com_Printf ("ERROR: UDP_OpenSocket: ioctl FIONBIO:%s\n", NET_ErrorString());
+		return 0;
+	}
+
+	// make it broadcast capable
+	if (setsockopt(newsocket, SOL_SOCKET, SO_BROADCAST, (char *)&i, sizeof(i)) == -1)
+	{
+		Com_Printf ("ERROR: UDP_OpenSocket: setsockopt SO_BROADCAST:%s\n", NET_ErrorString());
+		return 0;
+	}
+
+	if (!net_interface || !net_interface[0] || !stricmp(net_interface, "localhost"))
+		address.sin_addr.s_addr = INADDR_ANY;
+	else
+		Sys_StringToSockaddr (net_interface, (struct sockaddr *)&address);
+
+	if (port == PORT_ANY)
+		address.sin_port = 0;
+	else
+		address.sin_port = htons((short)port);
+
+	address.sin_family = AF_INET;
+
+	if( bind (newsocket, (void *)&address, sizeof(address)) == -1)
+	{
+		Com_Printf ("ERROR: UDP_OpenSocket: bind: %s\n", NET_ErrorString());
+		close (newsocket);
+		return 0;
+	}
+
+	return newsocket;
+}
+
+/*
+====================
+NET_Shutdown
+====================
+*/
+void	NET_Shutdown (void)
+{
+	if (ip_socket) {
+		close(ip_socket);
+		ip_socket = 0;
+	}
+}
+
+
+/*
+====================
+NET_ErrorString
+====================
+*/
+char *NET_ErrorString (void)
+{
+	int		code;
+
+	code = errno;
+	return strerror (code);
+}
+
+// sleeps msec or until net socket is ready
+void NET_Sleep(int msec)
+{
+    struct timeval timeout;
+	fd_set	fdset;
+	extern qboolean stdin_active;
+
+	if (!ip_socket || !com_dedicated->integer)
+		return; // we're not a server, just run full speed
+
+	FD_ZERO(&fdset);
+	if (stdin_active)
+		FD_SET(0, &fdset); // stdin is processed too
+	FD_SET(ip_socket, &fdset); // network socket
+	timeout.tv_sec = msec/1000;
+	timeout.tv_usec = (msec%1000)*1000;
+	select(ip_socket+1, &fdset, NULL, NULL, &timeout);
+}
+
diff --git a/code/unix/unix_shared.c b/code/unix/unix_shared.c
new file mode 100644
index 0000000..558d7d9
--- /dev/null
+++ b/code/unix/unix_shared.c
@@ -0,0 +1,369 @@
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <errno.h>
+#include <stdio.h>
+#include <dirent.h>
+#include <unistd.h>
+#include <sys/mman.h>
+#include <sys/time.h>
+
+#include "../game/q_shared.h"
+#include "../qcommon/qcommon.h"
+
+//===============================================================================
+
+// Used to determine CD Path
+static char programpath[MAX_OSPATH];
+
+/*
+================
+Sys_Milliseconds
+================
+*/
+int curtime;
+int	sys_timeBase;
+int Sys_Milliseconds (void)
+{
+	struct timeval tp;
+	struct timezone tzp;
+
+	gettimeofday(&tp, &tzp);
+	
+	if (!sys_timeBase)
+	{
+		sys_timeBase = tp.tv_sec;
+		return tp.tv_usec/1000;
+	}
+
+	curtime = (tp.tv_sec - sys_timeBase)*1000 + tp.tv_usec/1000;
+	
+	return curtime;
+}
+
+void	Sys_Mkdir( const char *path )
+{
+    mkdir (path, 0777);
+}
+
+char *strlwr (char *s)
+{
+	while (*s) {
+		*s = tolower(*s);
+		s++;
+	}
+}
+
+//============================================
+
+/* Like glob_match, but match PATTERN against any final segment of TEXT.  */
+static int glob_match_after_star(char *pattern, char *text)
+{
+	register char *p = pattern, *t = text;
+	register char c, c1;
+
+	while ((c = *p++) == '?' || c == '*')
+		if (c == '?' && *t++ == '\0')
+			return 0;
+
+	if (c == '\0')
+		return 1;
+
+	if (c == '\\')
+		c1 = *p;
+	else
+		c1 = c;
+
+	while (1) {
+		if ((c == '[' || *t == c1) && glob_match(p - 1, t))
+			return 1;
+		if (*t++ == '\0')
+			return 0;
+	}
+}
+
+/* Return nonzero if PATTERN has any special globbing chars in it.  */
+static int glob_pattern_p(char *pattern)
+{
+	register char *p = pattern;
+	register char c;
+	int open = 0;
+
+	while ((c = *p++) != '\0')
+		switch (c) {
+		case '?':
+		case '*':
+			return 1;
+
+		case '[':		/* Only accept an open brace if there is a close */
+			open++;		/* brace to match it.  Bracket expressions must be */
+			continue;	/* complete, according to Posix.2 */
+		case ']':
+			if (open)
+				return 1;
+			continue;
+
+		case '\\':
+			if (*p++ == '\0')
+				return 0;
+		}
+
+	return 0;
+}
+
+/* Match the pattern PATTERN against the string TEXT;
+   return 1 if it matches, 0 otherwise.
+
+   A match means the entire string TEXT is used up in matching.
+
+   In the pattern string, `*' matches any sequence of characters,
+   `?' matches any character, [SET] matches any character in the specified set,
+   [!SET] matches any character not in the specified set.
+
+   A set is composed of characters or ranges; a range looks like
+   character hyphen character (as in 0-9 or A-Z).
+   [0-9a-zA-Z_] is the set of characters allowed in C identifiers.
+   Any other character in the pattern must be matched exactly.
+
+   To suppress the special syntactic significance of any of `[]*?!-\',
+   and match the character exactly, precede it with a `\'.
+*/
+
+int glob_match(char *pattern, char *text)
+{
+	register char *p = pattern, *t = text;
+	register char c;
+
+	while ((c = *p++) != '\0')
+		switch (c) {
+		case '?':
+			if (*t == '\0')
+				return 0;
+			else
+				++t;
+			break;
+
+		case '\\':
+			if (*p++ != *t++)
+				return 0;
+			break;
+
+		case '*':
+			return glob_match_after_star(p, t);
+
+		case '[':
+			{
+				register char c1 = *t++;
+				int invert;
+
+				if (!c1)
+					return (0);
+
+				invert = ((*p == '!') || (*p == '^'));
+				if (invert)
+					p++;
+
+				c = *p++;
+				while (1) {
+					register char cstart = c, cend = c;
+
+					if (c == '\\') {
+						cstart = *p++;
+						cend = cstart;
+					}
+					if (c == '\0')
+						return 0;
+
+					c = *p++;
+					if (c == '-' && *p != ']') {
+						cend = *p++;
+						if (cend == '\\')
+							cend = *p++;
+						if (cend == '\0')
+							return 0;
+						c = *p++;
+					}
+					if (c1 >= cstart && c1 <= cend)
+						goto match;
+					if (c == ']')
+						break;
+				}
+				if (!invert)
+					return 0;
+				break;
+
+			  match:
+				/* Skip the rest of the [...] construct that already matched.  */
+				while (c != ']') {
+					if (c == '\0')
+						return 0;
+					c = *p++;
+					if (c == '\0')
+						return 0;
+					else if (c == '\\')
+						++p;
+				}
+				if (invert)
+					return 0;
+				break;
+			}
+
+		default:
+			if (c != *t++)
+				return 0;
+		}
+
+	return *t == '\0';
+}
+
+//============================================
+
+#define	MAX_FOUND_FILES	0x1000
+
+char **Sys_ListFiles( const char *directory, const char *extension, int *numfiles, qboolean wantsubs )
+{
+	struct dirent *d;
+	char *p;
+	DIR		*fdir;
+	qboolean dironly = wantsubs;
+	char		search[MAX_OSPATH];
+	int			nfiles;
+	char		**listCopy;
+	char		*list[MAX_FOUND_FILES];
+	int			flag;
+	int			i;
+	struct stat st;
+
+	int			extLen;
+
+	if ( !extension)
+		extension = "";
+
+	if ( extension[0] == '/' && extension[1] == 0 ) {
+		extension = "";
+		dironly = qtrue;
+	}
+
+	extLen = strlen( extension );
+	
+	// search
+	nfiles = 0;
+
+	if ((fdir = opendir(directory)) == NULL) {
+		*numfiles = 0;
+		return NULL;
+	}
+
+	while ((d = readdir(fdir)) != NULL) {
+		Com_sprintf(search, sizeof(search), "%s/%s", directory, d->d_name);
+		if (stat(search, &st) == -1)
+			continue;
+		if ((dironly && !(st.st_mode & S_IFDIR)) ||
+			(!dironly && (st.st_mode & S_IFDIR)))
+			continue;
+
+		if (*extension) {
+			if ( strlen( d->d_name ) < strlen( extension ) ||
+				Q_stricmp( 
+					d->d_name + strlen( d->d_name ) - strlen( extension ),
+					extension ) ) {
+				continue; // didn't match
+			}
+		}
+
+		if ( nfiles == MAX_FOUND_FILES - 1 )
+			break;
+		list[ nfiles ] = CopyString( d->d_name );
+		nfiles++;
+	}
+
+	list[ nfiles ] = 0;
+
+	closedir(fdir);
+
+	// return a copy of the list
+	*numfiles = nfiles;
+
+	if ( !nfiles ) {
+		return NULL;
+	}
+
+	listCopy = Z_Malloc( ( nfiles + 1 ) * sizeof( *listCopy ) );
+	for ( i = 0 ; i < nfiles ; i++ ) {
+		listCopy[i] = list[i];
+	}
+	listCopy[i] = NULL;
+
+	return listCopy;
+}
+
+void	Sys_FreeFileList( char **list ) {
+	int		i;
+
+	if ( !list ) {
+		return;
+	}
+
+	for ( i = 0 ; list[i] ; i++ ) {
+		Z_Free( list[i] );
+	}
+
+	Z_Free( list );
+}
+
+char *Sys_Cwd( void ) 
+{
+	static char cwd[MAX_OSPATH];
+
+	getcwd( cwd, sizeof( cwd ) - 1 );
+	cwd[MAX_OSPATH-1] = 0;
+
+	return cwd;
+}
+
+void SetProgramPath(char *path)
+{
+	char *p;
+
+	Q_strncpyz(programpath, path, sizeof(programpath));
+	if ((p = strrchr(programpath, '/')) != NULL)
+		*p = 0; // remove program name, leave only path
+}
+
+char *Sys_DefaultCDPath(void)
+{
+	if (*programpath)
+		return programpath;
+	else
+		return Sys_Cwd();
+}
+
+char *Sys_DefaultBasePath(void)
+{
+	char *p;
+	static char basepath[MAX_OSPATH];
+	int e;
+
+	if ((p = getenv("HOME")) != NULL) {
+		Q_strncpyz(basepath, p, sizeof(basepath));
+		Q_strcat(basepath, sizeof(basepath), "/.q3a");
+		if (mkdir(basepath, 0777)) {
+			if (errno != EEXIST) 
+				Sys_Error("Unable to create directory \"%s\", error is %s(%d)\n", basepath, strerror(errno), errno);
+		}
+		return basepath;
+	}
+	return ""; // assume current dir
+}
+
+//============================================
+
+int Sys_GetProcessorId( void )
+{
+	return CPUID_GENERIC;
+}
+
+void Sys_ShowConsole( int visLevel, qboolean quitOnClose )
+{
+}
+
+
diff --git a/code/unix/vssver.scc b/code/unix/vssver.scc
new file mode 100644
index 0000000..19a4372
Binary files /dev/null and b/code/unix/vssver.scc differ
diff --git a/code/update_spents.bat b/code/update_spents.bat
new file mode 100644
index 0000000..6f36921
--- /dev/null
+++ b/code/update_spents.bat
@@ -0,0 +1 @@
+k:\util\EntityDefMaker w:\bin\gamesource\*.cpp w:\game\base\scripts\sp_entities.def
diff --git a/code/vssver.scc b/code/vssver.scc
new file mode 100644
index 0000000..8279590
Binary files /dev/null and b/code/vssver.scc differ
diff --git a/code/win32/AutoVersion.h b/code/win32/AutoVersion.h
new file mode 100644
index 0000000..5d7f440
--- /dev/null
+++ b/code/win32/AutoVersion.h
@@ -0,0 +1,79 @@
+#ifndef __AUTO_VERSION_HEADER
+#define __AUTO_VERSION_HEADER
+
+#define VERSION_MAJOR_RELEASE		1
+#define VERSION_MINOR_RELEASE		0
+#define VERSION_EXTERNAL_BUILD		0
+#define VERSION_INTERNAL_BUILD		0
+
+#define VERSION_STRING				"1, 0, 0, 0"
+#define VERSION_STRING_DOTTED		"1.0.0.0"
+
+#define VERSION_BUILD_NUMBER		73
+
+// BEGIN COMMENTS
+// 1.0.0.0		07/21/2003 16:09:23		jmonroe		going gold
+// 0.0.12.0		07/20/2003 19:04:44		jmonroe		build 0.12 for qa
+// 0.0.11.0		07/19/2003 15:30:08		jmonroe		stuff
+// 0.0.11.0		07/17/2003 17:08:09		jmonroe		build 0.11 for qa
+// 0.0.10.1		07/16/2003 17:33:28		mgummelt		General Update With Latest Code
+// 0.0.10.0		07/16/2003 10:28:51		jmonroe		new product id, remove outcast.roq at end, menu ignoreescape, eax looping sounds support chan_less_atten
+// 0.0.10.0		07/14/2003 19:04:42		jmonroe		build 0.10 for qa
+// 0.0.9.0		07/12/2003 13:05:57		jmonroe		increase numsnapshot ents
+// 0.0.9.0		07/11/2003 17:48:40		jmonroe		buil 0.09 for qa
+// 0.0.8.4		07/11/2003 15:47:55		jmonroe		weatherzone caching
+// 0.0.8.3		07/11/2003 12:05:44		mgummelt		Lava & Acid fixes
+// 0.0.8.2		07/10/2003 17:26:42		mgummelt		General Update with today's bug fixes
+// 0.0.8.1		07/09/2003 19:24:19		jmonroe		eax voice stomp fix, increased weather zones, ...
+// 0.0.8.0		07/08/2003 17:28:27		jmonroe		build 0.08 for qa
+// 0.0.7.2		07/07/2003 16:28:40		mgummelt		Blaster Pistol alt-fire returns, Rancor spawnflags corrected
+// 0.0.7.1		07/07/2003 10:48:29		jmonroe		load menu fixes, darkside autoload fix,...
+// 0.0.7.0		07/02/2003 19:31:37		jmonroe		buil 7 for qa
+// 0.0.6.5		07/02/2003 18:17:17		mgummelt		Boss balancing
+// 0.0.6.3		07/02/2003 01:34:48		jmonroe		saber in moves menu
+// 0.0.6.2		06/30/2003 15:33:37		mgummelt		Force Sight change (designers readme)
+// 0.0.6.1		06/29/2003 19:00:17		jmonroe		vv merged, aev_soundchan
+// 0.0.6.0		06/28/2003 16:38:27		jmonroe		eax update, force sight on key dudes
+// 0.0.6.0		06/26/2003 16:45:26		jmonroe		qa build
+// 0.0.5.6		06/25/2003 21:22:38		mgummelt		"redcrosshair" field on misc_model_breakables and func_breakables
+// 0.0.5.5		06/25/2003 18:31:52		mgummelt		Force Visible on all applicable ents
+// 0.0.5.4		06/25/2003 10:45:12		jmonroe		EAX 4.0
+// 0.0.5.3		06/24/2003 22:59:31		mgummelt		Reborn tweaks
+// 0.0.5.2		06/24/2003 18:53:55		mgummelt		New Reborn Master
+// 0.0.5.1		06/23/2003 20:47:44		jmonroe		fix NULL NPC usage
+// 0.0.5.0		06/21/2003 13:04:27		jmonroe		fix eweb crash
+// 0.0.4.2		06/18/2003 14:24:35		jmonroe		script cmd SET_WEAPON  now precaches weapon, gil's optimized dlights
+// 0.0.4.1		06/17/2003 19:04:28		mgummelt		Various Force Power, saber move & Enemy Jedi tweaks
+// 0.0.4.0		06/16/2003 19:41:54		jmonroe		bug stuff
+// 0.0.4.0		06/13/2003 23:52:36		jmonroe		inc version to match qa beta
+// 0.0.2.6		06/12/2003 13:11:21		creed		new z-far cull
+// 0.0.2.5		06/10/2003 17:02:17		creed		targetJump & other navigation
+// 0.0.2.4		06/10/2003 11:18:58		jmonroe		footstep sounds in per material
+// 0.0.2.3		06/10/2003 01:37:10		mgummelt		helping with entity limit at spawntime
+// 0.0.2.2		06/09/2003 14:10:32		scork		fix for asian languages being bust by bad font
+// 0.0.2.1		06/08/2003 17:57:11		mgummelt		Area portal fix
+// 0.0.2.0		06/08/2003 14:02:03		mgummelt		Force sight change
+// 0.0.2.0		06/08/2003 00:03:58		jmonroe		CGEN_LIGHTING_DIFFUSE_ENTITY merges lightingdiffuse and entity color
+// 0.0.1.25		06/05/2003 20:51:30		mgummelt		Saber pull-attacks done
+// 0.0.1.24		06/05/2003 18:11:06		mgummelt		Both saber control schemes implemented
+// 0.0.1.23		05/30/2003 17:12:34		mgummelt		Fixed Noghri and Sand Creature
+// 0.0.1.22		05/30/2003 12:15:37		mgummelt		Saboteur change, new cultist
+// 0.0.1.21		05/29/2003 16:02:48		creed		Fixes For Assassin, ST AI changes
+// 0.0.1.20		05/29/2003 12:00:18		mgummelt		Navigation changes
+// 0.0.1.19		05/29/2003 11:08:06		mgummelt		various tweaks
+// 0.0.1.18		05/28/2003 22:08:16		creed		Boba Fett ++
+// 0.0.1.17		05/28/2003 20:38:33		mgummelt		force grip and force sense changes
+// 0.0.1.15		05/28/2003 17:07:26		mgummelt		tweaks of force drain, protect and absorb
+// 0.0.1.14		05/28/2003 14:48:57		mgummelt		various saber & AI fixes
+// 0.0.1.13		05/27/2003 17:26:30		areis		Ported Glow stuff from MP (with support for nVidia and ATI cards). Added solid flag for roffs (in behaved) and made tie-bombers explode with effect.
+// 0.0.1.12		05/27/2003 13:06:03		mgummelt		Noghri stick weapon shoots a projectile, E-Web uses proper sounds
+// 0.0.1.7		05/19/2003 15:00:10		mgummelt		adding random jedi, elder prisoners, jedi master
+// 0.0.1.6		05/19/2003 09:22:18		creed		Weather Effects & Haz Trooper
+// 0.0.1.5		05/16/2003 18:55:10		creed		New Wind Spawn Flags For Dusty Fog & 1/2 way through Haz Trooper Fixins
+// 0.0.1.4		05/15/2003 14:29:35		jmonroe		misc_model_static stay around after a vid_start
+// 0.0.1.3		05/14/2003 17:53:44		mgummelt		testing misc_model_breakable scaling
+// 0.0.1.2		05/13/2003 20:48:35		jmonroe		vv post merge
+// 0.0.1.1		05/13/2003 14:17:20		scork		ste test comment
+// END COMMENTS
+
+#endif // __AUTO_VERSION_HEADER
diff --git a/code/win32/FeelIt/FEELitIFR.h b/code/win32/FeelIt/FEELitIFR.h
new file mode 100644
index 0000000..bbc39fe
--- /dev/null
+++ b/code/win32/FeelIt/FEELitIFR.h
@@ -0,0 +1,247 @@
+/**********************************************************************
+	Copyright (c) 1999 Immersion Corporation
+
+	Permission to use, copy, modify, distribute, and sell this
+	software and its documentation may be granted without fee;
+	interested parties are encouraged to request permission from
+		Immersion Corporation
+		2158 Paragon Drive
+		San Jose, CA 95131
+		408-467-1900
+
+	IMMERSION DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+	INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.
+	IN NO EVENT SHALL IMMERSION BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+	CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+	LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+	NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+	CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+  FILE:		FEELitIFR.h
+
+  PURPOSE:	Input/Output for IFR Files, FEELit version
+
+  STARTED:	
+
+  NOTES/REVISIONS:
+
+**********************************************************************/
+
+#if !defined( _FEELIT2_H_)
+#define _FEELIT2_H_
+
+#ifndef __FEELITAPI_INCLUDED__
+	#error include 'dinput.h' before including this file for structures.
+#endif /* !__DINPUT_INCLUDED__ */
+
+#define IFRAPI __stdcall
+
+#if !defined(_FFCDLL_)
+#define DLLAPI __declspec(dllimport)
+#else
+#define DLLAPI __declspec(dllexport)
+#endif
+
+#if defined __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+/*
+**  CONSTANTS
+*/
+
+/*
+**  RT_FEELIT - Resource type for IFR projects stored as resources.
+**   This is the resource type looked for by IFLoadProjectResource().
+*/
+#define	RT_FEELIT	((LPCSTR)"FEELIT")
+
+
+/*
+**  TYPES/STRUCTURES
+*/
+
+/*
+**  HIFRPROJECT - used to identify a loaded project as a whole.
+**   individual objects within a project are uniquely referenced by name.
+**   Created by the IFLoadProject*() functions and released by IFReleaseProject().
+*/
+typedef	LPVOID HIFRPROJECT;
+
+/*
+**  IFREffect - contains the information needed to create a DI effect
+**   using IDirectInputEffect::CreateEffect(). An array of pointers to these
+**	 structures is allocated and returned by IFCreateEffectStructs().
+*/
+typedef struct {
+	GUID		guid;
+	LPFEELIT_EFFECT	lpDIEffect;
+} IFREffect;
+
+
+/*
+**  FUNCTION DECLARATIONS
+*/
+
+/*
+**  IFLoadProjectResource() - Load a project from a resource.
+**   hRsrcModule - handle of the module containing the project definition resource.
+**   pRsrcName - name or MAKEINTRESOURCE(id) identifier of resource to load.
+**   pDevice - device for which the project is being loaded. If NULL,
+**     effects will be created generically, and IFCreateEffects() will fail.
+**   Returns an identifier for the loaded project, or NULL if unsuccessful.
+*/
+DLLAPI
+HIFRPROJECT
+IFRAPI
+IFRLoadProjectResource(
+	HMODULE hRsrcModule,
+	LPCSTR pRsrcName,
+	LPIFEELIT_DEVICE pDevice );
+
+/*
+**  IFLoadProjectPointer() - Load a project from a pointer.
+**   pProject - points to a project definition.
+**   pDevice - device for which the project is being loaded. If NULL,
+**     effects will be created generically, and IFCreateEffects() will fail.
+**   Returns an identifier for the loaded project, or NULL if unsuccessful.
+*/
+DLLAPI
+HIFRPROJECT
+IFRAPI
+IFRLoadProjectPointer(
+	LPVOID pProject,
+	LPIFEELIT_DEVICE pDevice );
+
+/*
+**  IFLoadProjectFile() - Load a project from a file.
+**    pProjectFileName - points to a project file name.
+**    pDevice - device for which the project is being loaded. If NULL,
+**       effects will be created generically, and IFCreateEffects() will fail.
+**    Returns an identifier for the loaded project, or NULL if unsuccessful.
+*/
+DLLAPI
+HIFRPROJECT
+IFRAPI
+IFRLoadProjectFile(
+	LPCSTR pProjectFileName,
+	LPIFEELIT_DEVICE pDevice );
+
+/*
+**  IFLoadProjectObjectPointer() - Load a project from a pointer to a single
+**     object definition (usually used only by the editor).
+**   pObject - points to an object definition.
+**   pDevice - device for which the project is being loaded. If NULL,
+**     effects will be created generically, and IFCreateEffects() will fail.
+**   Returns an identifier for the loaded project, or NULL if unsuccessful.
+*/
+DLLAPI
+HIFRPROJECT
+IFRAPI
+IFRLoadProjectObjectPointer(
+	LPVOID pObject,
+	LPIFEELIT_DEVICE pDevice );
+
+/*
+**  IFReleaseProject() - Release a loaded project.
+**   hProject - identifies the project to be released.
+**   Returns TRUE if the project is released, FALSE if it is an invalid project.
+*/
+DLLAPI
+BOOL
+IFRAPI
+IFRReleaseProject(
+	HIFRPROJECT hProject );
+
+/*
+**  IFCreateEffectStructs() - Create IFREffects for a named effect.
+**   hProject - identifies the project containing the object.
+**   pObjectName - name of the object for which to create structures.
+**   pNumEffects - if not NULL will be set to a count of the IFREffect
+**     structures in the array (not including the terminating NULL pointer.)
+**   Returns a pointer to the allocated array of pointers to IFREffect
+**     structures. The array is terminated with a NULL pointer. If the
+**     function fails, a NULL pointer is returned.
+*/
+DLLAPI
+IFREffect **
+IFRAPI
+IFRCreateEffectStructs(
+	HIFRPROJECT hProject,
+	LPCSTR pObjectName,
+	int *pNumEffects );
+
+DLLAPI
+IFREffect **
+IFRAPI
+IFRCreateEffectStructsByIndex(
+	HIFRPROJECT hProject,
+	int nObjectIndex,
+	int *pNumEffects );
+
+DLLAPI
+LPCSTR
+IFRAPI
+IFRGetObjectNameByIndex(
+	HIFRPROJECT hProject,
+	int nObjectIndex );
+
+/*
+**  IFReleaseEffectStructs() - Release an array of IFREffects.
+**   hProject - identifies the project for which the effects were created.
+**   pEffects - points to the array of IFREffect pointers to be released.
+**   Returns TRUE if the array is released, FALSE if it is an invalid array.
+*/
+DLLAPI
+BOOL
+IFRAPI
+IFRReleaseEffectStructs(
+	HIFRPROJECT hProject,
+	IFREffect **pEffects );
+
+/*
+**  IFCreateEffects() - Creates the DirectInput effects using
+**     IDirectInput::CreateEffect().
+**   hProject - identifies the project containing the object.
+**   pObjectName - name of the object for which to create effects.
+**   pNumEffects - if not NULL will be set to a count of the IDirectInputEffect
+**     pointers in the array (not including the terminating NULL pointer.)
+**   Returns a pointer to the allocated array of pointers to IDirectInputEffects.
+**     The array is terminated with a NULL pointer. If the function fails,
+**     a NULL pointer is returned.
+*/
+DLLAPI
+LPIFEELIT_EFFECT *
+IFRAPI
+IFRCreateEffects(
+	HIFRPROJECT hProject,
+	LPCSTR pObjectName,
+	int *pNumEffects );
+
+/*
+**  IFReleaseEffects() - Releases an array of IDirectInputEffect structures.
+**   hProject - identifies the project for which the effects were created.
+**   pEffects - points to the array if IDirectInputEffect pointers to be released.
+**   Returns TRUE if the array is released, FALSE if it is an invalid array.
+*/
+DLLAPI
+BOOL
+IFRAPI
+IFRReleaseEffects(
+	HIFRPROJECT hProject,
+	LPIFEELIT_EFFECT *pEffects );
+
+DLLAPI
+BOOL
+IFRAPI
+DllMain(
+	HINSTANCE hInstDLL,
+	DWORD fdwReason,
+	LPVOID lpvReserved );
+
+
+#if defined __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* !IForce2_h */
diff --git a/code/win32/FeelIt/FFC.h b/code/win32/FeelIt/FFC.h
new file mode 100644
index 0000000..07cfeea
--- /dev/null
+++ b/code/win32/FeelIt/FFC.h
@@ -0,0 +1,78 @@
+/**********************************************************************
+	Copyright (c) 1997,8,9 Immersion Corporation
+
+	Permission to use, copy, modify, distribute, and sell this
+	software and its documentation may be granted without fee;
+	interested parties are encouraged to request permission from
+		Immersion Corporation
+		2158 Paragon Drive
+		San Jose, CA 95131
+		408-467-1900
+
+	IMMERSION DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+	INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.
+	IN NO EVENT SHALL IMMERSION BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+	CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+	LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+	NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+	CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+  FILE:		FFC.h
+
+  PURPOSE:	Class Types for the Force Foundation Classes
+
+  STARTED:	10/29/97
+
+  NOTES/REVISIONS:
+     3/2/99 jrm (Jeff Mallett): Force-->Feel renaming
+
+**********************************************************************/
+
+
+#if !defined(AFX_FFC_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_)
+#define AFX_FFC_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_
+
+#if _MSC_VER >= 1000
+#pragma once
+#endif // _MSC_VER >= 1000
+
+
+#include "FeelBox.h"
+#include "FeelCondition.h"
+#include "FeelConstant.h"
+#include "FeelDamper.h"
+#include "FeelDevice.h"
+#include "FeelDXDevice.h"
+#include "FeelEffect.h"
+#include "FeelEllipse.h"
+#include "FeelEnclosure.h"
+#include "FeelMouse.h"
+#include "FeelFriction.h"
+#include "FeelGrid.h"
+#include "FeelInertia.h"
+#include "FeelPeriodic.h"
+#include "FeelProjects.h"
+#include "FeelRamp.h"
+#include "FeelSpring.h"
+#include "FeelTexture.h"
+#include "FFCErrors.h"
+
+
+#endif // !defined(AFX_FFC_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/code/win32/FeelIt/FFC10.dll b/code/win32/FeelIt/FFC10.dll
new file mode 100644
index 0000000..0536f23
Binary files /dev/null and b/code/win32/FeelIt/FFC10.dll differ
diff --git a/code/win32/FeelIt/FFC10.lib b/code/win32/FeelIt/FFC10.lib
new file mode 100644
index 0000000..54ca7f4
Binary files /dev/null and b/code/win32/FeelIt/FFC10.lib differ
diff --git a/code/win32/FeelIt/FFC10d.dll b/code/win32/FeelIt/FFC10d.dll
new file mode 100644
index 0000000..1f546c2
Binary files /dev/null and b/code/win32/FeelIt/FFC10d.dll differ
diff --git a/code/win32/FeelIt/FFC10d.lib b/code/win32/FeelIt/FFC10d.lib
new file mode 100644
index 0000000..786d23d
Binary files /dev/null and b/code/win32/FeelIt/FFC10d.lib differ
diff --git a/code/win32/FeelIt/FFCErrors.h b/code/win32/FeelIt/FFCErrors.h
new file mode 100644
index 0000000..eff43b8
--- /dev/null
+++ b/code/win32/FeelIt/FFCErrors.h
@@ -0,0 +1,171 @@
+/**********************************************************************
+	Copyright (c) 1999 Immersion Corporation
+
+	Permission to use, copy, modify, distribute, and sell this
+	software and its documentation may be granted without fee;
+	interested parties are encouraged to request permission from
+		Immersion Corporation
+		2158 Paragon Drive
+		San Jose, CA 95131
+		408-467-1900
+
+	IMMERSION DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+	INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.
+	IN NO EVENT SHALL IMMERSION BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+	CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+	LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+	NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+	CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+  FILE:		FFCErrors.h
+
+  PURPOSE:	Error codes returned in FFC; Error handling in FFC
+
+  STARTED:	2/28/99 by Jeff Mallett
+
+  NOTES/REVISIONS:
+     3/2/99 jrm (Jeff Mallett): Force-->Feel renaming
+	 3/6/99 jrm: Added user error handling control
+	 3/15/99 jrm: __declspec(dllimport/dllexport) the whole class
+
+**********************************************************************/
+
+
+#if !defined(FFCERRORS_H__INCLUDED_)
+#define FFCERRORS_H__INCLUDED_
+
+#if _MSC_VER >= 1000
+#pragma once
+#endif // _MSC_VER >= 1000
+
+#ifndef _FFCDLL_
+#define DLLFFC __declspec(dllimport)
+#else
+#define DLLFFC __declspec(dllexport)
+#endif
+
+#include <winerror.h>
+#include "FeelBaseTypes.h"
+
+
+/****************************************************************************
+ *
+ *      Error Codes
+ *
+ ****************************************************************************/
+
+typedef enum {
+    FFC_ERR_OK							=   0,
+
+	FFC_ERR_UNKNOWN_ERROR				=   1,
+
+	FFC_ERR_ALLOCATION_FAILED			=   2,
+	FFC_ERR_INVALID_PARAMETER			=   3,
+	FFC_ERR_NULL_PARAMETER				=   4,
+	FFC_ERR_WRONG_FORM					=   5,
+
+	FFC_ERR_DEVICE_IS_NULL				=   6,
+	FFC_ERR_INVALID_GUID				=   7,
+	FFC_ERR_EFFECT_NOT_INITIALIZED		=   8,
+
+	FFC_ERR_CANT_INITIALIZE_DEVICE		=   9,
+
+	FFC_ERR_CANT_CREATE_EFFECT			=  10,
+	FFC_ERR_CANT_CREATE_EFFECT_FROM_IFR	=  11,
+	FFC_ERR_NO_EFFECTS_FOUND			=  12,
+	FFC_ERR_EFFECT_IS_COMPOUND			=  13,
+
+	FFC_ERR_PROJECT_ALREADY_OPEN		=  14,
+	FFC_ERR_PROJECT_NOT_OPEN			=  15
+} FFC_ERROR_CODE;
+
+typedef enum {
+	FFC_OUTPUT_ERR_TO_DEBUG				= 0x0001,
+	FFC_OUTPUT_ERR_TO_DIALOG			= 0x0002
+} FFC_ERROR_HANDLING_FLAGS;
+
+
+/****************************************************************************
+ *
+ *      Macros
+ *
+ ****************************************************************************/
+
+//
+// ------ PUBLIC MACROS ------ 
+//
+#define FFC_GET_LAST_ERROR			CFFCErrors::GetLastErrorCode()
+#define FFC_SET_ERROR_HANDLING		CFFCErrors::SetErrorHandling
+
+
+//
+// ------ PRIVATE MACROS ------ 
+//
+#if (FFC_VERSION >= 0x0110)
+ #define FFC_SET_ERROR(err)			CFFCErrors::SetErrorCode(err, __FILE__, __LINE__)
+#else
+ #define FFC_SET_ERROR(err)			CFFCErrors::SetErrorCode(err)
+#endif
+#define FFC_CLEAR_ERROR				FFC_SET_ERROR(FFC_ERR_OK)
+
+
+
+/****************************************************************************
+ *
+ *      CFFCErrors
+ *
+ ****************************************************************************/
+// All members are static.  Don't bother instantiating an object of this class.
+
+//
+// ------ PUBLIC INTERFACE ------ 
+//
+        
+class DLLFFC CFFCErrors
+{
+    //
+    // ATTRIBUTES
+    //
+
+	public:
+
+	static HRESULT
+	GetLastErrorCode()
+		{ return m_Err; }
+
+	static void
+	SetErrorHandling(unsigned long dwFlags)
+		{ m_dwErrHandlingFlags = dwFlags; }
+
+
+//
+// ------ PRIVATE INTERFACE ------ 
+//
+
+	// Internally used by FFC classes
+	static void
+	SetErrorCode(
+		HRESULT err
+#if (FFC_VERSION >= 0x0110)
+		, const char *sFile, int nLine
+#endif
+		);
+
+    //
+    // HELPERS
+    //
+
+	protected:
+
+    //
+    // INTERNAL DATA
+    //
+
+	private:
+
+	static HRESULT m_Err;
+	static unsigned long m_dwErrHandlingFlags;
+};
+
+
+#endif // FFCERRORS_H__INCLUDED_
diff --git a/code/win32/FeelIt/FeelBaseTypes.h b/code/win32/FeelIt/FeelBaseTypes.h
new file mode 100644
index 0000000..e2a8c4f
--- /dev/null
+++ b/code/win32/FeelIt/FeelBaseTypes.h
@@ -0,0 +1,265 @@
+/**********************************************************************
+	Copyright (c) 1997 Immersion Corporation
+
+	Permission to use, copy, modify, distribute, and sell this
+	software and its documentation may be granted without fee;
+	interested parties are encouraged to request permission from
+		Immersion Corporation
+		2158 Paragon Drive
+		San Jose, CA 95131
+		408-467-1900
+
+	IMMERSION DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+	INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.
+	IN NO EVENT SHALL IMMERSION BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+	CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+	LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+	NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+	CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+  FILE:		FeelBaseTypes.h
+
+  PURPOSE:	Base Types for Feelit API Foundation Classes
+
+  STARTED:	10/29/97
+
+  NOTES/REVISIONS:
+     3/2/99 jrm (Jeff Mallett): Force-->Feel renaming
+
+**********************************************************************/
+
+
+#if !defined(AFX_FEELBASETYPES_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_)
+#define AFX_FEELBASETYPES_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_
+
+#if _MSC_VER >= 1000
+#pragma once
+#endif // _MSC_VER >= 1000
+
+//#include <windows.h>
+#include "FeelitApi.h"
+
+#ifndef FFC_VERSION
+ #define FFC_VERSION         0x0100
+#endif
+
+#if (FFC_VERSION >= 0x0110)
+ #define FFC_START_DELAY
+ #define FFC_EFFECT_CACHING
+#endif
+
+//	These are defined in FEELitAPI.h
+//
+//	#define FEELIT_DEVICETYPE_DEVICE    1
+//	#define FEELIT_DEVICETYPE_MOUSE     2
+//	#define FEELIT_DEVICETYPE_HID       0x00010000
+//
+//	Add define for DirectInput Device emulating FEELit Device
+#define FEELIT_DEVICETYPE_DIRECTINPUT	3
+
+
+//================================================================
+// TYPE WRAPPERS
+//================================================================
+
+//
+// FEEL --> FEELIT Wrappers
+//
+#define FEEL_DEVICETYPE_DEVICE	FEELIT_DEVICETYPE_DEVICE
+#define FEEL_DEVICETYPE_MOUSE	FEELIT_DEVICETYPE_MOUSE
+#define FEEL_DEVICETYPE_DIRECTINPUT	FEELIT_DEVICETYPE_DIRECTINPUT
+
+#define FEEL_EFFECT		FEELIT_EFFECT
+#define LPFEEL_EFFECT	LPFEELIT_EFFECT
+#define LPCFEEL_EFFECT	LPCFEELIT_EFFECT
+
+#define FEEL_CONDITION     FEELIT_CONDITION
+#define LPFEEL_CONDITION   LPFEELIT_CONDITION
+#define LPCFEEL_CONDITION  LPCFEELIT_CONDITION
+
+#define FEEL_TEXTURE       FEELIT_TEXTURE
+#define LPFEEL_TEXTURE     LPFEELIT_TEXTURE
+#define LPCFEEL_TEXTURE    LPCFEELIT_TEXTURE
+
+#define FEEL_PERIODIC      FEELIT_PERIODIC
+#define LPFEEL_PERIODIC    LPFEELIT_PERIODIC
+#define LPCFEEL_PERIODIC   LPCFEELIT_PERIODIC
+
+#define FEEL_CONSTANTFORCE     FEELIT_CONSTANTFORCE
+#define LPFEEL_CONSTANTFORCE   LPFEELIT_CONSTANTFORCE
+#define LPCFEEL_CONSTANTFORCE  LPCFEELIT_CONSTANTFORCE
+
+#define FEEL_RAMPFORCE     FEELIT_RAMPFORCE
+#define LPFEEL_RAMPFORCE   LPFEELIT_RAMPFORCE
+#define LPCFEEL_RAMPFORCE  LPCFEELIT_RAMPFORCE
+
+#define FEEL_ENVELOPE      FEELIT_ENVELOPE
+#define LPFEEL_ENVELOPE    LPFEELIT_ENVELOPE
+#define LPCFEEL_ENVELOPE   LPCFEELIT_ENVELOPE
+
+#define LPIFEEL_API        LPIFEELIT
+#define LPIFEEL_EFFECT     LPIFEELIT_EFFECT
+#define LPIFEEL_DEVICE     LPIFEELIT_DEVICE
+
+#define LPFEEL_DEVICEINSTANCE              LPFEELIT_DEVICEINSTANCE       
+#define LPCFEEL_DEVICEOBJECTINSTANCE       LPCFEELIT_DEVICEOBJECTINSTANCE
+#define LPCFEEL_EFFECTINFO                 LPCFEELIT_EFFECTINFO          
+
+
+#define FEEL_FPARAM_DURATION               FEELIT_FPARAM_DURATION             
+#define FEEL_FPARAM_SAMPLEPERIOD           FEELIT_FPARAM_SAMPLEPERIOD         
+#define FEEL_FPARAM_GAIN                   FEELIT_FPARAM_GAIN                 
+#define FEEL_FPARAM_TRIGGERBUTTON          FEELIT_FPARAM_TRIGGERBUTTON        
+#define FEEL_FPARAM_TRIGGERREPEATINTERVAL  FEELIT_FPARAM_TRIGGERREPEATINTERVAL
+#define FEEL_FPARAM_AXES                   FEELIT_FPARAM_AXES                 
+#define FEEL_FPARAM_DIRECTION              FEELIT_FPARAM_DIRECTION            
+#define FEEL_FPARAM_ENVELOPE               FEELIT_FPARAM_ENVELOPE             
+#define FEEL_FPARAM_TYPESPECIFICPARAMS     FEELIT_FPARAM_TYPESPECIFICPARAMS   
+#define FEEL_FPARAM_ALLPARAMS              FEELIT_FPARAM_ALLPARAMS            
+#define FEEL_FPARAM_START                  FEELIT_FPARAM_START                
+#define FEEL_FPARAM_NORESTART              FEELIT_FPARAM_NORESTART            
+#define FEEL_FPARAM_NODOWNLOAD             FEELIT_FPARAM_NODOWNLOAD           
+
+#define FEEL_FEFFECT_OBJECTIDS             FEELIT_FEFFECT_OBJECTIDS      
+#define FEEL_FEFFECT_OBJECTOFFSETS         FEELIT_FEFFECT_OBJECTOFFSETS  
+#define FEEL_FEFFECT_CARTESIAN             FEELIT_FEFFECT_CARTESIAN      
+#define FEEL_FEFFECT_POLAR                 FEELIT_FEFFECT_POLAR          
+#define FEEL_FEFFECT_SPHERICAL             FEELIT_FEFFECT_SPHERICAL      
+
+#define FEEL_PARAM_NOTRIGGER               FEELIT_PARAM_NOTRIGGER
+
+#define FEEL_MOUSEOFFSET_XAXIS             FEELIT_MOUSEOFFSET_XAXIS
+#define FEEL_MOUSEOFFSET_YAXIS             FEELIT_MOUSEOFFSET_YAXIS
+#define FEEL_MOUSEOFFSET_ZAXIS             FEELIT_MOUSEOFFSET_ZAXIS
+
+//
+// FORCE --> FEELIT Wrappers
+//
+#define FORCE_EFFECT FEELIT_EFFECT
+#define LPFORCE_EFFECT LPFEELIT_EFFECT
+#define LPCFORCE_EFFECT LPCFEELIT_EFFECT
+
+#define FORCE_CONDITION     FEELIT_CONDITION
+#define LPFORCE_CONDITION   LPFEELIT_CONDITION
+#define LPCFORCE_CONDITION  LPCFEELIT_CONDITION
+
+#define FORCE_TEXTURE       FEELIT_TEXTURE
+#define LPFORCE_TEXTURE     LPFEELIT_TEXTURE
+#define LPCFORCE_TEXTURE    LPCFEELIT_TEXTURE
+
+#define FORCE_PERIODIC      FEELIT_PERIODIC
+#define LPFORCE_PERIODIC    LPFEELIT_PERIODIC
+#define LPCFORCE_PERIODIC   LPCFEELIT_PERIODIC
+
+#define FORCE_CONSTANTFORCE     FEELIT_CONSTANTFORCE
+#define LPFORCE_CONSTANTFORCE   LPFEELIT_CONSTANTFORCE
+#define LPCFORCE_CONSTANTFORCE  LPCFEELIT_CONSTANTFORCE
+
+#define FORCE_RAMPFORCE     FEELIT_RAMPFORCE
+#define LPFORCE_RAMPFORCE   LPFEELIT_RAMPFORCE
+#define LPCFORCE_RAMPFORCE  LPCFEELIT_RAMPFORCE
+
+#define FORCE_ENVELOPE      FEELIT_ENVELOPE
+#define LPFORCE_ENVELOPE    LPFEELIT_ENVELOPE
+#define LPCFORCE_ENVELOPE   LPCFEELIT_ENVELOPE
+
+#define LPIFORCE_API        LPIFEELIT
+#define LPIFORCE_EFFECT     LPIFEELIT_EFFECT
+#define LPIFORCE_DEVICE     LPIFEELIT_DEVICE
+
+#define LPFORCE_DEVICEINSTANCE              LPFEELIT_DEVICEINSTANCE       
+#define LPCFORCE_DEVICEOBJECTINSTANCE       LPCFEELIT_DEVICEOBJECTINSTANCE
+#define LPCFORCE_EFFECTINFO                 LPCFEELIT_EFFECTINFO          
+
+
+#define FORCE_FPARAM_DURATION               FEELIT_FPARAM_DURATION             
+#define FORCE_FPARAM_SAMPLEPERIOD           FEELIT_FPARAM_SAMPLEPERIOD         
+#define FORCE_FPARAM_GAIN                   FEELIT_FPARAM_GAIN                 
+#define FORCE_FPARAM_TRIGGERBUTTON          FEELIT_FPARAM_TRIGGERBUTTON        
+#define FORCE_FPARAM_TRIGGERREPEATINTERVAL  FEELIT_FPARAM_TRIGGERREPEATINTERVAL
+#define FORCE_FPARAM_AXES                   FEELIT_FPARAM_AXES                 
+#define FORCE_FPARAM_DIRECTION              FEELIT_FPARAM_DIRECTION            
+#define FORCE_FPARAM_ENVELOPE               FEELIT_FPARAM_ENVELOPE             
+#define FORCE_FPARAM_TYPESPECIFICPARAMS     FEELIT_FPARAM_TYPESPECIFICPARAMS   
+#define FORCE_FPARAM_ALLPARAMS              FEELIT_FPARAM_ALLPARAMS            
+#define FORCE_FPARAM_START                  FEELIT_FPARAM_START                
+#define FORCE_FPARAM_NORESTART              FEELIT_FPARAM_NORESTART            
+#define FORCE_FPARAM_NODOWNLOAD             FEELIT_FPARAM_NODOWNLOAD           
+
+#define FORCE_FEFFECT_OBJECTIDS             FEELIT_FEFFECT_OBJECTIDS      
+#define FORCE_FEFFECT_OBJECTOFFSETS         FEELIT_FEFFECT_OBJECTOFFSETS  
+#define FORCE_FEFFECT_CARTESIAN             FEELIT_FEFFECT_CARTESIAN      
+#define FORCE_FEFFECT_POLAR                 FEELIT_FEFFECT_POLAR          
+#define FORCE_FEFFECT_SPHERICAL             FEELIT_FEFFECT_SPHERICAL      
+
+#define FORCE_PARAM_NOTRIGGER               FEELIT_PARAM_NOTRIGGER
+
+#define FORCE_MOUSEOFFSET_XAXIS             FEELIT_MOUSEOFFSET_XAXIS
+#define FORCE_MOUSEOFFSET_YAXIS             FEELIT_MOUSEOFFSET_YAXIS
+#define FORCE_MOUSEOFFSET_ZAXIS             FEELIT_MOUSEOFFSET_ZAXIS
+
+
+//================================================================
+// GUID WRAPPERS
+//================================================================
+
+//
+// Feel --> Feelit Wrappers
+//
+#define GUID_Feel_ConstantForce	GUID_Feelit_ConstantForce
+#define GUID_Feel_RampForce		GUID_Feelit_RampForce
+#define GUID_Feel_Square		GUID_Feelit_Square
+#define GUID_Feel_Sine			GUID_Feelit_Sine
+#define GUID_Feel_Triangle		GUID_Feelit_Triangle
+#define GUID_Feel_SawtoothUp	GUID_Feelit_SawtoothUp
+#define GUID_Feel_SawtoothDown	GUID_Feelit_SawtoothDown
+#define GUID_Feel_Spring		GUID_Feelit_Spring
+#define GUID_Feel_DeviceSpring	GUID_Feelit_DeviceSpring
+#define GUID_Feel_Damper		GUID_Feelit_Damper
+#define GUID_Feel_Inertia		GUID_Feelit_Inertia
+#define GUID_Feel_Friction		GUID_Feelit_Friction
+#define GUID_Feel_Texture		GUID_Feelit_Texture
+#define GUID_Feel_Grid			GUID_Feelit_Grid
+#define GUID_Feel_Enclosure		GUID_Feelit_Enclosure
+#define GUID_Feel_Ellipse		GUID_Feelit_Ellipse
+#define GUID_Feel_CustomForce	GUID_Feelit_CustomForce
+
+//
+// Force --> Feelit Wrappers
+//
+#define GUID_Force_ConstantForce   GUID_Feelit_ConstantForce
+#define GUID_Force_RampForce       GUID_Feelit_RampForce
+#define GUID_Force_Square          GUID_Feelit_Square
+#define GUID_Force_Sine            GUID_Feelit_Sine
+#define GUID_Force_Triangle        GUID_Feelit_Triangle
+#define GUID_Force_SawtoothUp      GUID_Feelit_SawtoothUp
+#define GUID_Force_SawtoothDown    GUID_Feelit_SawtoothDown
+#define GUID_Force_Spring          GUID_Feelit_Spring
+#define GUID_Force_Damper          GUID_Feelit_Damper
+#define GUID_Force_Inertia         GUID_Feelit_Inertia
+#define GUID_Force_Friction        GUID_Feelit_Friction
+#define GUID_Force_Texture         GUID_Feelit_Texture
+#define GUID_Force_Grid            GUID_Feelit_Grid
+#define GUID_Force_Enclosure       GUID_Feelit_Enclosure
+#define GUID_Force_Ellipse         GUID_Feelit_Ellipse
+#define GUID_Force_CustomForce     GUID_Feelit_CustomForce
+
+
+#endif // !defined(AFX_FEELBASETYPES_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/code/win32/FeelIt/FeelBox.h b/code/win32/FeelIt/FeelBox.h
new file mode 100644
index 0000000..d3e459c
--- /dev/null
+++ b/code/win32/FeelIt/FeelBox.h
@@ -0,0 +1,178 @@
+/**********************************************************************
+	Copyright (c) 1997 Immersion Corporation
+
+	Permission to use, copy, modify, distribute, and sell this
+	software and its documentation may be granted without fee;
+	interested parties are encouraged to request permission from
+		Immersion Corporation
+		2158 Paragon Drive
+		San Jose, CA 95131
+		408-467-1900
+
+	IMMERSION DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+	INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.
+	IN NO EVENT SHALL IMMERSION BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+	CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+	LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+	NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+	CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+  FILE:		FeelBox.h
+
+  PURPOSE:	Box Class for Feelit API Foundation Classes
+
+  STARTED:	11/04/97
+
+  NOTES/REVISIONS:
+     3/2/99 jrm (Jeff Mallett): Force-->Feel renaming
+	 3/15/99 jrm: __declspec(dllimport/dllexport) the whole class
+
+**********************************************************************/
+
+
+#if !defined(AFX_FEELBOX_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_)
+#define AFX_FEELBOX_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_
+
+#if _MSC_VER >= 1000
+#pragma once
+#endif // _MSC_VER >= 1000
+
+#ifndef _FFCDLL_
+#define DLLFFC __declspec(dllimport)
+#else
+#define DLLFFC __declspec(dllexport)
+#endif
+
+#include "FeelBaseTypes.h"
+#include "FeelEffect.h"
+#include "FeelEnclosure.h"
+
+
+
+//================================================================
+// Constants
+//================================================================
+
+const POINT FEEL_BOX_MOUSE_POS_AT_START = { MAXLONG, MAXLONG };
+
+#define     FEEL_BOX_DEFAULT_STIFFNESS      5000
+#define     FEEL_BOX_DEFAULT_WIDTH          10
+#define     FEEL_BOX_DEFAULT_HEIGHT         FEEL_ENCLOSURE_HEIGHT_AUTO
+#define     FEEL_BOX_DEFAULT_WALL_WIDTH     FEEL_ENCLOSURE_WALL_WIDTH_AUTO
+
+#define     FEEL_BOX_DEFAULT_CENTER_POINT   FEEL_BOX_MOUSE_POS_AT_START
+
+//
+// FORCE --> FEEL Wrappers
+//
+#define     FORCE_BOX_MOUSE_POS_AT_START	FEEL_BOX_DEFAULT_STIFFNESS
+
+#define     FORCE_BOX_DEFAULT_STIFFNESS		FEEL_BOX_DEFAULT_STIFFNESS
+#define     FORCE_BOX_DEFAULT_WIDTH			FEEL_BOX_DEFAULT_WIDTH
+#define     FORCE_BOX_DEFAULT_HEIGHT		FEEL_BOX_DEFAULT_HEIGHT
+#define     FORCE_BOX_DEFAULT_WALL_WIDTH	FEEL_BOX_DEFAULT_WALL_WIDTH
+
+#define     FORCE_BOX_DEFAULT_CENTER_POINT	FEEL_BOX_DEFAULT_CENTER_POINT
+
+
+
+//================================================================
+// CFeelBox
+//================================================================
+
+//
+// ------ PUBLIC INTERFACE ------ 
+//
+
+class DLLFFC CFeelBox : public CFeelEnclosure
+{
+    //
+    // CONSTRUCTOR/DESCTRUCTOR
+    //
+
+    public:
+    
+    // Constructor
+	CFeelBox();
+
+	// Destructor
+	virtual
+	~CFeelBox();
+
+
+    //
+    // ATTRIBUTES
+    //
+
+    public:
+
+
+    BOOL
+    ChangeParameters( 
+        POINT pntCenter,
+        LONG lStiffness = FEEL_EFFECT_DONT_CHANGE,
+        DWORD dwWidth = FEEL_EFFECT_DONT_CHANGE,
+        DWORD dwHeight = FEEL_EFFECT_DONT_CHANGE,
+        DWORD dwWallWidth = FEEL_EFFECT_DONT_CHANGE,
+        CFeelEffect* pInsideEffect = (CFeelEffect*) FEEL_EFFECT_DONT_CHANGE  
+        );
+
+    BOOL
+	ChangeParameters( 
+        LPCRECT pRectOutside,
+        LONG lStiffness = FEEL_EFFECT_DONT_CHANGE,
+        DWORD dwWallWidth = FEEL_EFFECT_DONT_CHANGE,
+        CFeelEffect* pInsideEffect = (CFeelEffect*) FEEL_EFFECT_DONT_CHANGE  
+        );
+
+
+    //
+    // OPERATIONS
+    //
+
+    public:
+
+
+    BOOL 
+	Initialize( 
+        CFeelDevice* pDevice, 
+        DWORD dwWidth = FEEL_ENCLOSURE_DEFAULT_WIDTH,
+        DWORD dwHeight = FEEL_ENCLOSURE_DEFAULT_HEIGHT,
+        LONG lStiffness = FEEL_BOX_DEFAULT_STIFFNESS,
+        DWORD dwWallWidth = FEEL_BOX_DEFAULT_WALL_WIDTH,
+        POINT pntCenter = FEEL_BOX_DEFAULT_CENTER_POINT,
+        CFeelEffect* pInsideEffect = NULL  
+        );
+
+
+    BOOL 
+	Initialize( 
+        CFeelDevice* pDevice, 
+        LPCRECT pRectOutside,
+        LONG lStiffness = FEEL_BOX_DEFAULT_STIFFNESS,
+        DWORD dwWallWidth = FEEL_BOX_DEFAULT_WALL_WIDTH,
+        CFeelEffect* pInsideEffect = NULL  
+        );
+
+
+//
+// ------ PRIVATE INTERFACE ------ 
+//
+        
+    //
+    // HELPERS
+    //
+
+    protected:
+
+
+    //
+    // INTERNAL DATA
+    //
+    
+    protected:
+
+};
+
+
+#endif // !defined(AFX_FEELBOX_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_)
diff --git a/code/win32/FeelIt/FeelCompoundEffect.h b/code/win32/FeelIt/FeelCompoundEffect.h
new file mode 100644
index 0000000..e2f688e
--- /dev/null
+++ b/code/win32/FeelIt/FeelCompoundEffect.h
@@ -0,0 +1,184 @@
+/**********************************************************************
+	Copyright (c) 1999 Immersion Corporation
+
+	Permission to use, copy, modify, distribute, and sell this
+	software and its documentation may be granted without fee;
+	interested parties are encouraged to request permission from
+		Immersion Corporation
+		2158 Paragon Drive
+		San Jose, CA 95131
+		408-467-1900
+
+	IMMERSION DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+	INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.
+	IN NO EVENT SHALL IMMERSION BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+	CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+	LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+	NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+	CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+  FILE:		FeelCompoundEffect.h
+
+  PURPOSE:	Manages Compound Effects for Force Foundation Classes
+
+  STARTED:	2/24/99 by Jeff Mallett
+
+  NOTES/REVISIONS:
+     3/2/99 jrm (Jeff Mallett): Force-->Feel renaming
+	 3/15/99 jrm: __declspec(dllimport/dllexport) the whole class
+
+**********************************************************************/
+
+
+#if !defined(__FEELCOMPOUNDEFFECT_H)
+#define __FEELCOMPOUNDEFFECT_H
+
+#if _MSC_VER >= 1000
+#pragma once
+#endif // _MSC_VER >= 1000
+
+#ifndef _FFCDLL_
+#define DLLFFC __declspec(dllimport)
+#else
+#define DLLFFC __declspec(dllexport)
+#endif
+
+#include "FeelBaseTypes.h"
+#include "FeelEffect.h"
+
+#include "FeelitIFR.h"
+
+
+//================================================================
+// CFeelCompoundEffect
+//================================================================
+// Represents a compound effect, such as might be created in
+// I-FORCE Studio.  Contains an array of effect objects.
+// Methods iterate over component effects, passing the message
+// to each one.
+// Also, has stuff for being used by CFeelProject:
+//   * next pointer so can be put on a linked list
+//   * force name
+
+//
+// ------ PUBLIC INTERFACE ------ 
+//
+
+class DLLFFC CFeelCompoundEffect
+{
+    //
+    // CONSTRUCTOR/DESTRUCTOR
+    //
+
+	protected:
+	// Constructs a CFeelCompoundEffect
+	// Don't try to construct a CFeelCompoundEffect yourself.
+    // Instead let CFeelProject construct it for you.
+	CFeelCompoundEffect(
+		IFREffect **hEffects,
+		long nEffects
+		);
+
+	public:
+
+	~CFeelCompoundEffect();
+
+
+    //
+    // ATTRIBUTES
+    //
+
+	public:
+
+	long
+	GetNumberOfContainedEffects() const
+		{ return m_nEffects; }
+    
+	const char *
+	GetName() const
+		{ return m_lpszName; }
+
+	GENERIC_EFFECT_PTR
+	GetContainedEffect(
+		long index
+		);
+
+
+	//
+    // OPERATIONS
+    //
+
+	public:
+
+	// Start all the contained effects
+	BOOL Start(
+		DWORD dwIterations = 1,
+		DWORD dwFlags = 0
+		);
+
+	// Stop all the contained effects
+	BOOL Stop();
+
+
+//
+// ------ PRIVATE INTERFACE ------ 
+//
+
+    //
+    // HELPERS
+    //
+
+    protected:
+
+	BOOL initialize(
+		CFeelDevice* pDevice,
+		IFREffect **hEffects
+		);
+
+	BOOL
+	set_contained_effect(
+		GENERIC_EFFECT_PTR pObject,
+		int index = 0
+		);
+
+	BOOL
+	set_name(
+		const char *lpszName
+		);
+
+	void
+	set_next(
+		CFeelCompoundEffect *pNext
+		)
+		{ m_pNext = pNext; }
+
+	CFeelCompoundEffect *
+	get_next() const
+		{ return m_pNext; }
+
+
+    //
+    // FRIENDS
+    //
+
+	public:
+
+	friend class CFeelProject;
+
+
+    //
+    // INTERNAL DATA
+    //
+
+	protected:
+
+	GENERIC_EFFECT_PTR *m_paEffects; // Array of force class object pointers
+	long m_nEffects; // Number of effects in m_paEffects
+
+	private:
+
+	char *m_lpszName; // Name of the compound effect
+	CFeelCompoundEffect *m_pNext; // Next compound effect in the project
+};
+
+#endif
diff --git a/code/win32/FeelIt/FeelCondition.h b/code/win32/FeelIt/FeelCondition.h
new file mode 100644
index 0000000..8218812
--- /dev/null
+++ b/code/win32/FeelIt/FeelCondition.h
@@ -0,0 +1,345 @@
+/**********************************************************************
+	Copyright (c) 1997 Immersion Corporation
+
+	Permission to use, copy, modify, distribute, and sell this
+	software and its documentation may be granted without fee;
+	interested parties are encouraged to request permission from
+		Immersion Corporation
+		2158 Paragon Drive
+		San Jose, CA 95131
+		408-467-1900
+
+	IMMERSION DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+	INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.
+	IN NO EVENT SHALL IMMERSION BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+	CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+	LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+	NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+	CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+  FILE:		FeelCondition.h
+
+  PURPOSE:	Base Condition Class for Feelit API Foundation Classes
+
+  STARTED:	10/10/97
+
+  NOTES/REVISIONS:
+     3/2/99 jrm (Jeff Mallett): Force-->Feel renaming
+	 3/2/99 jrm: Added GetIsCompatibleGUID
+	 3/15/99 jrm: __declspec(dllimport/dllexport) the whole class
+
+**********************************************************************/
+
+
+#if !defined(AFX_FEELCONDITION_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_)
+#define AFX_FEELCONDITION_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_
+
+#if _MSC_VER >= 1000
+#pragma once
+#endif // _MSC_VER >= 1000
+
+#ifndef _FFCDLL_
+#define DLLFFC __declspec(dllimport)
+#else
+#define DLLFFC __declspec(dllexport)
+#endif
+
+#include "FeelBaseTypes.h"
+#include "FeelEffect.h"
+
+
+
+//================================================================
+// Constants
+//================================================================
+
+const POINT FEEL_CONDITION_PT_NULL = { 0, 0 };
+
+#define     FEEL_CONDITION_DEFAULT_COEFFICIENT    2500
+#define     FEEL_CONDITION_DEFAULT_SATURATION     10000
+#define     FEEL_CONDITION_DEFAULT_DEADBAND       100
+#define     FEEL_CONDITION_DEFAULT_CENTER_POINT   FEEL_EFFECT_MOUSE_POS_AT_START
+#define     FEEL_CONDITION_DEFAULT_DURATION       INFINITE
+
+typedef enum {
+	FC_NULL = 0,
+	FC_POSITIVE_COEFFICIENT,
+	FC_NEGATIVE_COEFFICIENT,
+	FC_POSITIVE_SATURATION,
+	FC_NEGATIVE_SATURATION,
+	FC_DEAD_BAND,
+	FC_AXIS,
+	FC_CENTER,
+	FC_DIRECTION_X,
+	FC_DIRECTION_Y,
+	FC_ANGLE,
+	FC_CONDITION_X,
+	FC_CONDITION_Y
+} FC_ArgumentType;
+
+#define FC_CONDITION	FC_CONDITION_X
+
+//
+// FORCE --> FEEL Wrappers
+//
+#define		FORCE_CONDITION_PT_NULL					FEEL_CONDITION_PT_NULL
+
+#define     FORCE_CONDITION_DEFAULT_COEFFICIENT		FEEL_CONDITION_DEFAULT_COEFFICIENT
+#define     FORCE_CONDITION_DEFAULT_SATURATION		FEEL_CONDITION_DEFAULT_SATURATION
+#define     FORCE_CONDITION_DEFAULT_DEADBAND		FEEL_CONDITION_DEFAULT_DEADBAND
+#define     FORCE_CONDITION_DEFAULT_CENTER_POINT	FEEL_CONDITION_DEFAULT_CENTER_POINT
+#define     FORCE_CONDITION_DEFAULT_DURATION		FEEL_CONDITION_DEFAULT_DURATION
+
+
+
+//================================================================
+// CFeelCondition
+//================================================================
+
+//
+// ------ PUBLIC INTERFACE ------ 
+//
+
+class DLLFFC CFeelCondition : public CFeelEffect
+{
+    //
+    // CONSTRUCTOR/DESCTRUCTOR
+    //
+
+    public:
+    
+    // Constructor
+	CFeelCondition(
+		const GUID& rguidEffect
+		);
+
+	// Destructor
+	virtual
+	~CFeelCondition();
+
+
+    //
+    // ATTRIBUTES
+    //
+
+    public:
+
+	virtual BOOL
+	GetIsCompatibleGUID(
+		GUID &guid
+		);
+
+    // Use this form for single-axis and dual-axis effects
+	BOOL
+    ChangeConditionParams( 
+        LPCFEELIT_CONDITION pConditionX,
+        LPCFEELIT_CONDITION pConditionY
+        );
+
+    // Use this form for directional effects
+    BOOL
+	ChangeConditionParams( 
+        LPCFEELIT_CONDITION pCondition,
+        LONG lDirectionX,
+        LONG lDirectionY
+        );
+
+    // Use this form for directional effects
+    BOOL
+	ChangeConditionParamsPolar( 
+        LPCFEELIT_CONDITION pCondition,
+        LONG lAngle
+        );
+
+    // Use this form for single-axis, dual-axis symetrical, or directional effects
+    BOOL
+	ChangeConditionParams( 
+        LONG lPositiveCoefficient,
+        LONG lNegativeCoefficient = FEEL_EFFECT_DONT_CHANGE,
+        DWORD dwPositiveSaturation = FEEL_EFFECT_DONT_CHANGE,
+        DWORD dwNegativeSaturation = FEEL_EFFECT_DONT_CHANGE,
+        LONG lDeadBand = FEEL_EFFECT_DONT_CHANGE,
+        POINT pntCenter = FEEL_EFFECT_DONT_CHANGE_POINT,
+        LONG lDirectionX = FEEL_EFFECT_DONT_CHANGE,
+        LONG lDirectionY = FEEL_EFFECT_DONT_CHANGE
+        );
+
+    // Use this form for single-axis, dual-axis symetrical, or directional effects
+    BOOL
+	ChangeConditionParamsPolar( 
+        LONG lPositiveCoefficient,
+        LONG lNegativeCoefficient,
+        DWORD dwPositiveSaturation,
+        DWORD dwNegativeSaturation,
+        LONG lDeadBand,
+        POINT pntCenter,
+        LONG lAngle
+        );
+
+
+    BOOL
+	SetCenter( 
+        POINT pntCenter 
+        );
+
+	BOOL 
+	ChangeConditionParams2(
+		FC_ArgumentType type,
+		...
+	);
+
+    //
+    // OPERATIONS
+    //
+
+    public:
+
+	virtual BOOL
+	Initialize( 
+		CFeelDevice* pDevice, 
+		const FEEL_EFFECT &effect
+		);
+
+	// Use this form for single-axis and dual-axis effects
+    BOOL 
+	InitCondition( 
+        CFeelDevice* pDevice, 
+        LPCFEELIT_CONDITION pConditionX,
+        LPCFEELIT_CONDITION pConditionY,
+        BOOL bUseDeviceCoordinates = FALSE
+		);
+
+
+    // Use this form for directional effects
+    BOOL 
+	InitCondition( 
+        CFeelDevice* pDevice, 
+        LPCFEELIT_CONDITION pCondition,
+        LONG lDirectionX,
+        LONG lDirectionY,
+        BOOL bUseDeviceCoordinates = FALSE
+		);
+
+
+    // Use this form for directional effects
+    BOOL 
+    InitConditionPolar( 
+        CFeelDevice* pDevice, 
+        LPCFEELIT_CONDITION pCondition,
+        LONG lAngle,
+        BOOL bUseDeviceCoordinates = FALSE
+		);
+
+
+    // Use this form for single-axis, dual-axis symetrical, or directional effects
+    BOOL 
+    InitCondition( 
+        CFeelDevice* pDevice, 
+        LONG lPositiveCoefficient = FEEL_CONDITION_DEFAULT_COEFFICIENT,
+        LONG lNegativeCoefficient = FEEL_CONDITION_DEFAULT_COEFFICIENT,
+        DWORD dwPositiveSaturation = FEEL_CONDITION_DEFAULT_SATURATION,
+        DWORD dwNegativeSaturation = FEEL_CONDITION_DEFAULT_SATURATION,
+        LONG lDeadBand = FEEL_CONDITION_DEFAULT_DEADBAND,
+        DWORD dwfAxis = FEEL_EFFECT_AXIS_BOTH,
+        POINT pntCenter = FEEL_CONDITION_DEFAULT_CENTER_POINT,
+        LONG lDirectionX = FEEL_EFFECT_DEFAULT_DIRECTION_X,
+        LONG lDirectionY = FEEL_EFFECT_DEFAULT_DIRECTION_Y,
+        BOOL bUseDeviceCoordinates = FALSE
+		);
+
+    // Use this form for directional effects
+    BOOL 
+    InitConditionPolar( 
+        CFeelDevice* pDevice, 
+        LONG lPositiveCoefficient = FEEL_CONDITION_DEFAULT_COEFFICIENT,
+        LONG lNegativeCoefficient = FEEL_CONDITION_DEFAULT_COEFFICIENT,
+        DWORD dwPositiveSaturation = FEEL_CONDITION_DEFAULT_SATURATION,
+        DWORD dwNegativeSaturation = FEEL_CONDITION_DEFAULT_SATURATION,
+        LONG lDeadBand = FEEL_CONDITION_DEFAULT_DEADBAND,
+        POINT pntCenter = FEEL_CONDITION_DEFAULT_CENTER_POINT,
+        LONG lAngle = FEEL_EFFECT_DEFAULT_ANGLE,
+        BOOL bUseDeviceCoordinates = FALSE
+		);
+
+
+    virtual BOOL
+#ifdef FFC_START_DELAY
+    StartNow(
+#else
+    Start(
+#endif
+        DWORD dwIterations = 1,
+        DWORD dwFlags = 0
+        );
+
+        
+//
+// ------ PRIVATE INTERFACE ------ 
+//
+
+    //
+    // HELPERS
+    //
+
+    protected:
+
+	void
+	convert_line_point_to_offset(
+		POINT pntOnLine
+		);
+
+    BOOL
+    set_parameters( 
+        DWORD dwfAxis,
+        DWORD dwfCoordinates,
+        LONG lDirection0,
+        LONG lDirection1,
+        LPCFEELIT_CONDITION pConditionX, 
+        LPCFEELIT_CONDITION pConditionY
+        );
+
+    BOOL
+    set_parameters( 
+        DWORD dwfAxis,
+        DWORD dwfCoordinates,
+        LONG lDirection0,
+        LONG lDirection1,
+        LONG lPositiveCoefficient,
+        LONG lNegativeCoefficient,
+        DWORD dwPositiveSaturation,
+        DWORD dwNegativeSaturation,
+        LONG lDeadBand,
+        POINT pntCenter
+        );
+
+    //
+    // INTERNAL DATA
+    //
+
+    FEEL_CONDITION m_aCondition[2];
+    DWORD m_dwfAxis;
+    BOOL m_bUseMousePosAtStart;
+    
+    protected:
+	    BOOL m_bUseDeviceCoordinates;
+
+};
+
+
+//
+// INLINES
+//
+
+inline BOOL
+CFeelCondition::GetIsCompatibleGUID(GUID &guid)
+{
+	return  IsEqualGUID(guid, GUID_Feel_Spring) ||
+			IsEqualGUID(guid, GUID_Feel_DeviceSpring) ||
+			IsEqualGUID(guid, GUID_Feel_Damper) ||
+			IsEqualGUID(guid, GUID_Feel_Inertia) ||
+			IsEqualGUID(guid, GUID_Feel_Friction) ||
+			IsEqualGUID(guid, GUID_Feel_Texture) ||
+			IsEqualGUID(guid, GUID_Feel_Grid);
+}
+
+#endif // !defined(AFX_FEELCONDITION_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_)
diff --git a/code/win32/FeelIt/FeelConstant.h b/code/win32/FeelIt/FeelConstant.h
new file mode 100644
index 0000000..5b586f4
--- /dev/null
+++ b/code/win32/FeelIt/FeelConstant.h
@@ -0,0 +1,193 @@
+/**********************************************************************
+	Copyright (c) 1997 Immersion Corporation
+
+	Permission to use, copy, modify, distribute, and sell this
+	software and its documentation may be granted without fee;
+	interested parties are encouraged to request permission from
+		Immersion Corporation
+		2158 Paragon Drive
+		San Jose, CA 95131
+		408-467-1900
+
+	IMMERSION DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+	INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.
+	IN NO EVENT SHALL IMMERSION BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+	CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+	LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+	NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+	CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+  FILE:		FeelConstant.h
+
+  PURPOSE:	Base Constant Class for Feelit API Foundation Classes
+
+  STARTED:	11/03/97
+
+  NOTES/REVISIONS:
+     3/2/99 jrm (Jeff Mallett): Force-->Feel renaming
+	 3/2/99 jrm: Added GetIsCompatibleGUID
+	 3/15/99 jrm: __declspec(dllimport/dllexport) the whole class
+
+**********************************************************************/
+
+
+#if !defined(AFX_FEELCONSTANT_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_)
+#define AFX_FEELCONSTANT_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_
+
+#if _MSC_VER >= 1000
+#pragma once
+#endif // _MSC_VER >= 1000
+
+#ifndef _FFCDLL_
+#define DLLFFC __declspec(dllimport)
+#else
+#define DLLFFC __declspec(dllexport)
+#endif
+
+#include "FeelBaseTypes.h"
+#include "FeelEffect.h"
+
+
+
+//================================================================
+// Constants
+//================================================================
+
+const POINT FEEL_CONSTANT_DEFAULT_DIRECTION = { 1, 0 };
+#define     FEEL_CONSTANT_DEFAULT_DURATION       1000 // Milliseconds
+#define     FEEL_CONSTANT_DEFAULT_MAGNITUDE      5000
+
+//
+// FORCE --> FEEL Wrappers
+//
+#define FORCE_CONSTANT_DEFAULT_DIRECTION	FEEL_CONSTANT_DEFAULT_DIRECTION
+#define FORCE_CONSTANT_DEFAULT_DURATION		FEEL_CONSTANT_DEFAULT_DURATION
+#define FORCE_CONSTANT_DEFAULT_MAGNITUDE	FEEL_CONSTANT_DEFAULT_MAGNITUDE
+
+
+//================================================================
+// CFeelConstant
+//================================================================
+
+//
+// ------ PUBLIC INTERFACE ------ 
+//
+
+class DLLFFC CFeelConstant : public CFeelEffect
+{
+    //
+    // CONSTRUCTOR/DESTRUCTOR
+    //
+
+    public:
+    
+    // Constructor
+	CFeelConstant();
+
+	// Destructor
+	virtual
+	~CFeelConstant();
+
+
+    //
+    // ATTRIBUTES
+    //
+
+    public:
+
+	virtual BOOL
+	GetIsCompatibleGUID(
+		GUID &guid
+		);
+
+	BOOL
+    ChangeParameters( 
+        LONG lDirectionX,
+        LONG lDirectionY,
+        DWORD dwDuration = FEEL_EFFECT_DONT_CHANGE,
+        LONG lMagnitude = FEEL_EFFECT_DONT_CHANGE,
+        LPFEEL_ENVELOPE pEnvelope = (LPFEEL_ENVELOPE) FEEL_EFFECT_DONT_CHANGE_PTR
+        );
+
+    BOOL
+    ChangeParametersPolar( 
+        LONG lAngle,
+        DWORD dwDuration = FEEL_EFFECT_DONT_CHANGE,
+        LONG lMagnitude = FEEL_EFFECT_DONT_CHANGE,
+        LPFEEL_ENVELOPE pEnvelope = (LPFEEL_ENVELOPE) FEEL_EFFECT_DONT_CHANGE_PTR
+        );
+
+
+    //
+    // OPERATIONS
+    //
+
+    public:
+
+    virtual
+	BOOL
+    Initialize( 
+        CFeelDevice* pDevice, 
+        LONG lDirectionX = FEEL_EFFECT_DEFAULT_DIRECTION_X,
+        LONG lDirectionY = FEEL_EFFECT_DEFAULT_DIRECTION_Y,
+        DWORD dwDuration = FEEL_CONSTANT_DEFAULT_DURATION,
+        LONG lMagnitude = FEEL_CONSTANT_DEFAULT_MAGNITUDE,
+        LPFEEL_ENVELOPE pEnvelope = NULL
+        );
+
+    virtual
+	BOOL
+    InitializePolar( 
+        CFeelDevice* pDevice, 
+        LONG lArray = FEEL_EFFECT_DEFAULT_ANGLE,
+        DWORD dwDuration = FEEL_CONSTANT_DEFAULT_DURATION,
+        LONG lMagnitude = FEEL_CONSTANT_DEFAULT_MAGNITUDE,
+        LPFEEL_ENVELOPE pEnvelope = NULL
+        );
+
+        
+//
+// ------ PRIVATE INTERFACE ------ 
+//
+
+    //
+    // HELPERS
+    //
+
+    protected:
+
+    BOOL
+    set_parameters( 
+        DWORD dwfCoordinates,
+        LONG lDirection0,
+        LONG lDirection1,
+        DWORD dwDuration,
+        LONG lMagnitude,
+        LPFEEL_ENVELOPE pEnvelope
+        );
+
+
+    //
+    // INTERNAL DATA
+    //
+
+    FEEL_CONSTANTFORCE m_ConstantForce;
+    
+    protected:
+
+};
+
+
+
+//
+// INLINES
+//
+
+inline BOOL
+CFeelConstant::GetIsCompatibleGUID(GUID &guid)
+{
+	return IsEqualGUID(guid, GUID_Feel_ConstantForce);
+}
+
+
+#endif // !defined(AFX_FEELCONSTANT_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_)
diff --git a/code/win32/FeelIt/FeelDXDevice.h b/code/win32/FeelIt/FeelDXDevice.h
new file mode 100644
index 0000000..302fe1f
--- /dev/null
+++ b/code/win32/FeelIt/FeelDXDevice.h
@@ -0,0 +1,126 @@
+/**********************************************************************
+	Copyright (c) 1997 Immersion Corporation
+
+	Permission to use, copy, modify, distribute, and sell this
+	software and its documentation may be granted without fee;
+	interested parties are encouraged to request permission from
+		Immersion Corporation
+		2158 Paragon Drive
+		San Jose, CA 95131
+		408-467-1900
+
+	IMMERSION DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+	INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.
+	IN NO EVENT SHALL IMMERSION BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+	CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+	LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+	NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+	CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+  FILE:		FeelDXDevice.h
+
+  PURPOSE:	Abstraction of DirectX Force Feedback device
+
+  STARTED:	10/10/97
+
+  NOTES/REVISIONS:
+     3/2/99 jrm (Jeff Mallett): Force-->Feel renaming
+	 3/15/99 jrm: __declspec(dllimport/dllexport) the whole class
+
+**********************************************************************/
+
+#ifndef FeelDXDevice_h
+#define FeelDXDevice_h
+
+#ifndef _FFCDLL_
+#define DLLFFC __declspec(dllimport)
+#else
+#define DLLFFC __declspec(dllexport)
+#endif
+
+#include "FeelDevice.h"
+
+
+//================================================================
+// CFeelDXDevice
+//================================================================
+
+//
+// ------ PUBLIC INTERFACE ------ 
+//
+
+class DLLFFC CFeelDXDevice : public CFeelDevice
+{
+
+    //
+    // CONSTRUCTOR/DESCTRUCTOR
+    //
+
+    public:
+    
+    // Constructor
+	CFeelDXDevice();
+
+	// Destructor
+    virtual
+	~CFeelDXDevice();
+
+
+    //
+    // ATTRIBUTES
+    //
+
+    public:
+
+	virtual LPIFEEL_API
+    GetAPI() 
+	{ return (LPIFEEL_API) m_piApi; } // actually LPDIRECTINPUT
+
+	virtual LPIFEEL_DEVICE
+    GetDevice() 
+	{ return (LPIFEEL_DEVICE) m_piDevice; } // actually LPDIRECTINPUTDEVICE2
+
+
+    //
+    // OPERATIONS
+    //
+
+	public:
+
+	BOOL
+	Initialize(
+		HANDLE hinstApp,
+		HANDLE hwndApp,
+		LPDIRECTINPUT pDI = NULL,
+		LPDIRECTINPUTDEVICE2 piDevice = NULL
+		);
+
+
+//
+// ------ PRIVATE INTERFACE ------ 
+//
+
+	//
+	// HELPERS
+	//
+
+	protected:
+
+	virtual void
+	reset();
+
+
+    //
+    // INTERNAL DATA
+    //
+
+    protected:
+
+	BOOL m_bpDIPreExist;
+	BOOL m_bpDIDevicePreExist;
+
+	LPDIRECTINPUT m_piApi;
+	LPDIRECTINPUTDEVICE2 m_piDevice;
+};
+
+#endif // ForceDXDevice_h
diff --git a/code/win32/FeelIt/FeelDamper.h b/code/win32/FeelIt/FeelDamper.h
new file mode 100644
index 0000000..1034b9d
--- /dev/null
+++ b/code/win32/FeelIt/FeelDamper.h
@@ -0,0 +1,177 @@
+/**********************************************************************
+	Copyright (c) 1997,8,9 Immersion Corporation
+
+	Permission to use, copy, modify, distribute, and sell this
+	software and its documentation may be granted without fee;
+	interested parties are encouraged to request permission from
+		Immersion Corporation
+		2158 Paragon Drive
+		San Jose, CA 95131
+		408-467-1900
+
+	IMMERSION DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+	INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.
+	IN NO EVENT SHALL IMMERSION BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+	CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+	LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+	NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+	CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+  FILE:		FeelDamper.h
+
+  PURPOSE:	Feelit API Damper Effect Class
+
+  STARTED:	10/14/97
+
+  NOTES/REVISIONS:
+     3/2/99 jrm (Jeff Mallett): Force-->Feel renaming
+	 3/2/99 jrm: Added GetIsCompatibleGUID
+	 3/15/99 jrm: __declspec(dllimport/dllexport) the whole class
+
+**********************************************************************/
+
+
+#if !defined(AFX_FEELDamper_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_)
+#define AFX_FEELDamper_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_
+
+#if _MSC_VER >= 1000
+#pragma once
+#endif // _MSC_VER >= 1000
+
+#ifndef _FFCDLL_
+#define DLLFFC __declspec(dllimport)
+#else
+#define DLLFFC __declspec(dllexport)
+#endif
+
+#include <windows.h>
+#include "FeelCondition.h"
+
+
+//================================================================
+// Constants
+//================================================================
+
+#define     FEEL_DAMPER_DEFAULT_VISCOSITY      2500
+#define     FEEL_DAMPER_DEFAULT_SATURATION     10000
+#define     FEEL_DAMPER_DEFAULT_MIN_VELOCITY   0
+
+//
+// FORCE --> FEEL Wrappers
+//
+#define     FORCE_DAMPER_DEFAULT_VISCOSITY      FEEL_DAMPER_DEFAULT_VISCOSITY
+#define     FORCE_DAMPER_DEFAULT_SATURATION     FEEL_DAMPER_DEFAULT_SATURATION
+#define     FORCE_DAMPER_DEFAULT_MIN_VELOCITY   FEEL_DAMPER_DEFAULT_MIN_VELOCITY
+
+
+//================================================================
+// CFeelDamper
+//================================================================
+
+//
+// ------ PUBLIC INTERFACE ------ 
+//
+
+class DLLFFC CFeelDamper : public CFeelCondition
+{
+    //
+    // CONSTRUCTOR/DESTRUCTOR
+    //
+
+    public:
+    
+    // Constructor
+	CFeelDamper();
+
+	// Destructor
+	virtual ~CFeelDamper();
+
+
+    //
+    // ATTRIBUTES
+    //
+
+    public:
+
+	virtual BOOL
+	GetIsCompatibleGUID(
+		GUID &guid
+		);
+
+    BOOL
+    ChangeParameters( 
+        DWORD dwViscosity,
+        DWORD dwSaturation = FEEL_EFFECT_DONT_CHANGE,
+        DWORD dwMinVelocity = FEEL_EFFECT_DONT_CHANGE,
+        LONG lDirectionX = FEEL_EFFECT_DONT_CHANGE,
+        LONG lDirectionY = FEEL_EFFECT_DONT_CHANGE
+        );
+
+    BOOL
+    ChangeParametersPolar( 
+        DWORD dwViscosity,
+        DWORD dwSaturation,
+        DWORD dwMinVelocity,
+        LONG lAngle
+        );
+
+
+    //
+    // OPERATIONS
+    //
+
+    public:
+
+    virtual BOOL 
+    Initialize( 
+        CFeelDevice* pDevice, 
+        DWORD dwViscosity = FEEL_DAMPER_DEFAULT_VISCOSITY,
+        DWORD dwSaturation = FEEL_DAMPER_DEFAULT_SATURATION,
+        DWORD dwMinVelocity = FEEL_DAMPER_DEFAULT_MIN_VELOCITY,
+        DWORD dwfAxis = FEEL_EFFECT_AXIS_BOTH,
+        LONG lDirectionX = FEEL_EFFECT_DEFAULT_DIRECTION_X,
+        LONG lDirectionY = FEEL_EFFECT_DEFAULT_DIRECTION_Y
+        );
+
+    virtual BOOL 
+    InitializePolar( 
+        CFeelDevice* pDevice, 
+        DWORD dwViscosity,
+        DWORD dwSaturation,
+        DWORD dwMinVelocity,
+        LONG lAngle
+        );
+
+
+//
+// ------ PRIVATE INTERFACE ------ 
+//
+        
+    //
+    // HELPERS
+    //
+
+    protected:
+
+    //
+    // INTERNAL DATA
+    //
+    
+    protected:
+
+};
+
+
+
+//
+// INLINES
+//
+
+inline BOOL
+CFeelDamper::GetIsCompatibleGUID(GUID &guid)
+{
+	return IsEqualGUID(guid, GUID_Feel_Damper);
+}
+
+
+#endif // !defined(AFX_FEELDamper_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_)
diff --git a/code/win32/FeelIt/FeelDevice.h b/code/win32/FeelIt/FeelDevice.h
new file mode 100644
index 0000000..2016219
--- /dev/null
+++ b/code/win32/FeelIt/FeelDevice.h
@@ -0,0 +1,196 @@
+/**********************************************************************
+	Copyright (c) 1997 Immersion Corporation
+
+	Permission to use, copy, modify, distribute, and sell this
+	software and its documentation may be granted without fee;
+	interested parties are encouraged to request permission from
+		Immersion Corporation
+		2158 Paragon Drive
+		San Jose, CA 95131
+		408-467-1900
+
+	IMMERSION DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+	INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.
+	IN NO EVENT SHALL IMMERSION BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+	CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+	LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+	NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+	CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+  FILE:		FeelDevice.h
+
+  PURPOSE:	Abstract Base Device Class for Force Foundation Classes
+
+  STARTED:	10/10/97
+
+  NOTES/REVISIONS:
+     3/2/99 jrm (Jeff Mallett): Force-->Feel renaming
+	 3/15/99 jrm: __declspec(dllimport/dllexport) the whole class
+	 3/16/99 jrm: Made abstract. Moved functionality to CFeelMouse/CFeelDXDevice
+
+**********************************************************************/
+
+#if !defined(AFX_FORCEDEVICE_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_)
+#define AFX_FORCEDEVICE_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_
+
+#if _MSC_VER >= 1000
+#pragma once
+#endif // _MSC_VER >= 1000
+
+#ifndef _FFCDLL_
+#define DLLFFC __declspec(dllimport)
+#else
+#define DLLFFC __declspec(dllexport)
+#endif
+
+#define DIRECTINPUT_VERSION 0x0800 //[ 0x0300 | 0x0500 | 0x0700 | 0x0800 ]
+#include "dinput.h"
+#include "FeelBaseTypes.h"
+
+#ifdef FFC_EFFECT_CACHING
+ #include "FeelEffectSuite.h"
+#endif
+
+
+
+//================================================================
+// CFeelDevice
+//================================================================
+
+//
+// ------ PUBLIC INTERFACE ------ 
+//
+
+class DLLFFC CFeelDevice  
+{
+    //
+    // CONSTRUCTOR/DESCTRUCTOR
+    //
+
+    public:
+    
+    // Constructor
+	CFeelDevice();
+
+	// Destructor
+	virtual
+	~CFeelDevice();
+
+
+    //
+    // ATTRIBUTES
+    //
+
+    public:
+
+	virtual LPIFEEL_API
+    GetAPI() 
+		= 0; // pure virtual function
+
+	virtual LPIFEEL_DEVICE // Will actually return LPDIRECTINPUTDEVICE2 if non-FEELit
+    GetDevice()
+		= 0; // pure virtual function
+
+	DWORD
+    GetDeviceType() const
+		{ return m_dwDeviceType; }
+
+
+    //
+    // OPERATIONS
+    //
+
+    public:
+
+	static CFeelDevice *
+	CreateDevice(HINSTANCE hinstApp, HWND hwndApp);
+	
+    virtual BOOL 
+    ChangeScreenResolution( 
+		BOOL bAutoSet,
+		DWORD dwXScreenSize = 0,
+		DWORD dwYScreenSize = 0
+		);
+
+	// The default state is using standard Win32 Mouse messages (e.g., WM_MOUSEMOVE)  
+	// and functions (e.g, GetCursorPos).  Call only to switch to relative mode
+	// if not using standard Win32 Mouse services (e.g., DirectInput) for mouse
+	// input.  
+	BOOL
+	UsesWin32MouseServices(
+		BOOL bWin32MouseServ
+		);
+
+	// Another syntax for SwitchToAbsoluteMode.
+	// The default is Absolute mode.  Call only to switch to Relative mode or
+	// to switch back to Absolute mode.
+	virtual BOOL
+	SwitchToAbsoluteMode(
+		BOOL bAbsMode
+		);
+
+//
+// ------ PRIVATE INTERFACE ------ 
+//
+
+    //
+    // CACHING
+    //
+
+#ifdef FFC_EFFECT_CACHING
+	public:
+
+	void Cache_AddEffect(CFeelEffect *pFeelEffect);
+	void Cache_RemoveEffect(const CFeelEffect *pFeelEffect);
+	void Cache_SwapOutEffect();
+
+    protected:
+
+	void Cache_LoadEffectSuite(CFeelEffectSuite *pSuite, BOOL bCreateOnDevice);
+	void Cache_UnloadEffectSuite(CFeelEffectSuite *pSuite, BOOL bUnloadFromDevice);
+
+	CEffectList m_Cache; // List of all effects created on device
+#endif
+
+    //
+    // HELPERS
+    //
+
+    protected:
+
+    // Performs device preparation by setting the device's parameters
+    virtual BOOL 
+    prepare_device();
+
+    virtual void
+	reset()
+		= 0; // pure virtual function
+
+	static BOOL CALLBACK
+    enum_didevices_proc(
+        LPDIDEVICEINSTANCE pForceDevInst, 
+        LPVOID pv
+        );
+
+	static BOOL CALLBACK
+    enum_devices_proc(
+        LPFORCE_DEVICEINSTANCE pForceDevInst, 
+        LPVOID pv
+        );
+
+
+    //
+    // INTERNAL DATA
+    //
+
+    protected:
+	
+	BOOL m_bInitialized;
+    DWORD m_dwDeviceType;
+	GUID m_guidDevice;
+	BOOL m_bGuidValid;
+
+};
+
+
+#endif // !defined(AFX_FORCEDEVICE_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_)
diff --git a/code/win32/FeelIt/FeelEffect.h b/code/win32/FeelIt/FeelEffect.h
new file mode 100644
index 0000000..d7039ef
--- /dev/null
+++ b/code/win32/FeelIt/FeelEffect.h
@@ -0,0 +1,344 @@
+/**********************************************************************
+	Copyright (c) 1997 Immersion Corporation
+
+	Permission to use, copy, modify, distribute, and sell this
+	software and its documentation may be granted without fee;
+	interested parties are encouraged to request permission from
+		Immersion Corporation
+		2158 Paragon Drive
+		San Jose, CA 95131
+		408-467-1900
+
+	IMMERSION DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+	INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.
+	IN NO EVENT SHALL IMMERSION BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+	CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+	LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+	NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+	CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+  FILE:		FeelEffect.h
+
+  PURPOSE:	Base Effect Class for Feelit API Foundation Classes
+
+  STARTED:	10/10/97
+
+  NOTES/REVISIONS:
+     3/2/99 jrm (Jeff Mallett): Force-->Feel renaming
+	 3/2/99 jrm: Added GetIsCompatibleGUID and feel_to_DI_GUID
+	 3/15/99 jrm: __declspec(dllimport/dllexport) the whole class
+
+**********************************************************************/
+
+
+#if !defined(AFX_FEELEFFECT_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_)
+#define AFX_FEELEFFECT_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_
+
+#if _MSC_VER >= 1000
+#pragma once
+#endif // _MSC_VER >= 1000
+
+#ifndef _FFCDLL_
+#define DLLFFC __declspec(dllimport)
+#else
+#define DLLFFC __declspec(dllexport)
+#endif
+
+#include "FeelBaseTypes.h"
+#include "FeelDevice.h"
+class CFeelProject;
+
+
+//================================================================
+// Constants
+//================================================================
+
+#define     FEEL_EFFECT_AXIS_X             1
+#define     FEEL_EFFECT_AXIS_Y             2
+#define     FEEL_EFFECT_AXIS_BOTH          3
+#define     FEEL_EFFECT_AXIS_DIRECTIONAL   4
+#define     FEEL_EFFECT_DONT_CHANGE        MINLONG
+#define     FEEL_EFFECT_DONT_CHANGE_PTR    MAXDWORD
+const POINT FEEL_EFFECT_DONT_CHANGE_POINT = { 0xFFFFFFFF, 0xFFFFFFFF };
+const POINT FEEL_EFFECT_MOUSE_POS_AT_START = { MAXLONG, MAXLONG };
+
+#define     FEEL_EFFECT_DEFAULT_ENVELOPE   NULL
+#define     FEEL_EFFECT_DEFAULT_DIRECTION_X    1
+#define     FEEL_EFFECT_DEFAULT_DIRECTION_Y    1
+#define     FEEL_EFFECT_DEFAULT_ANGLE          0
+
+//
+// FORCE --> FEEL Wrappers
+//
+#define     FORCE_EFFECT_AXIS_X					FEEL_EFFECT_AXIS_X
+#define     FORCE_EFFECT_AXIS_Y					FEEL_EFFECT_AXIS_Y
+#define     FORCE_EFFECT_AXIS_BOTH				FEEL_EFFECT_AXIS_BOTH
+#define     FORCE_EFFECT_AXIS_DIRECTIONAL		FEEL_EFFECT_AXIS_DIRECTIONAL
+#define     FORCE_EFFECT_DONT_CHANGE			FEEL_EFFECT_DONT_CHANGE
+#define     FORCE_EFFECT_DONT_CHANGE_PTR		FEEL_EFFECT_DONT_CHANGE_PTR
+#define     FORCE_EFFECT_DONT_CHANGE_POINT		FEEL_EFFECT_DONT_CHANGE_POINT
+#define     FORCE_EFFECT_MOUSE_POS_AT_START		FEEL_EFFECT_MOUSE_POS_AT_START
+
+#define     FORCE_EFFECT_DEFAULT_ENVELOPE		FEEL_EFFECT_DEFAULT_ENVELOPE
+#define     FORCE_EFFECT_DEFAULT_DIRECTION_X	FEEL_EFFECT_DEFAULT_DIRECTION_X
+#define     FORCE_EFFECT_DEFAULT_DIRECTION_Y	FEEL_EFFECT_DEFAULT_DIRECTION_Y
+#define     FORCE_EFFECT_DEFAULT_ANGLE			FEEL_EFFECT_DEFAULT_ANGLE
+
+
+
+// GENERIC_EFFECT_PTR
+// This is really a pointer to a child of CFeelEffect.
+typedef class CFeelEffect * 	GENERIC_EFFECT_PTR;
+
+
+//================================================================
+// CFeelEffect
+//================================================================
+
+//
+// ------ PUBLIC INTERFACE ------ 
+//
+
+class DLLFFC CFeelEffect  
+{
+    //
+    // CONSTRUCTOR/DESTRUCTOR
+    //
+
+    public:
+    
+    // Constructor
+	CFeelEffect(
+		const GUID& rguidEffect
+		);
+
+	// Destructor
+	virtual
+	~CFeelEffect();
+
+    //
+    // ATTRIBUTES
+    //
+
+    public:
+
+	LPIFEEL_EFFECT
+    GetEffect() 
+		{ return m_piFeelitEffect; }
+
+    BOOL 
+    GetStatus(
+		DWORD* pdwStatus
+		)
+#if (FFC_VERSION >= 0x0110) || defined(FFC_EFFECT_CACHING)
+		const
+#endif
+		;
+
+    GUID
+	GetGUID()
+		{ return m_guidEffect; }
+
+	virtual BOOL
+	GetIsCompatibleGUID(
+		GUID & /* guid */
+		)
+		{ return true; }
+ 
+	// Allocates an object of the correct FFC class from the given GUID
+	static GENERIC_EFFECT_PTR
+	NewObjectFromGUID(
+		GUID &guid
+		);
+
+    BOOL
+    ChangeBaseParams( 
+        LONG lDirectionX,
+        LONG lDirectionY,
+        DWORD dwDuration = FEEL_EFFECT_DONT_CHANGE,
+        LPFEEL_ENVELOPE pEnvelope = (LPFEEL_ENVELOPE) FEEL_EFFECT_DONT_CHANGE_PTR,
+        DWORD dwSamplePeriod = FEEL_EFFECT_DONT_CHANGE,
+        DWORD dwGain = FEEL_EFFECT_DONT_CHANGE,
+        DWORD dwTriggerButton = FEEL_EFFECT_DONT_CHANGE,
+        DWORD dwTriggerRepeatInterval = FEEL_EFFECT_DONT_CHANGE
+#ifdef FFC_START_DELAY
+		,DWORD dwStartDelay = FEEL_EFFECT_DONT_CHANGE
+#endif
+		);
+
+    BOOL
+    ChangeBaseParamsPolar( 
+        LONG lAngle,
+        DWORD dwDuration = FEEL_EFFECT_DONT_CHANGE,
+        LPFEEL_ENVELOPE pEnvelope = (LPFEEL_ENVELOPE) FEEL_EFFECT_DONT_CHANGE_PTR,
+        DWORD dwSamplePeriod = FEEL_EFFECT_DONT_CHANGE,
+        DWORD dwGain = FEEL_EFFECT_DONT_CHANGE,
+        DWORD dwTriggerButton = FEEL_EFFECT_DONT_CHANGE,
+        DWORD dwTriggerRepeatInterval = FEEL_EFFECT_DONT_CHANGE
+#ifdef FFC_START_DELAY
+		,DWORD dwStartDelay = FEEL_EFFECT_DONT_CHANGE
+#endif
+		);
+
+    BOOL
+    ChangeDirection( 
+        LONG lDirectionX,
+        LONG lDirectionY 
+		);
+
+    BOOL
+    ChangeDirection( 
+        LONG lAngle
+        );
+
+
+    BOOL
+    SetEnvelope(
+        DWORD dwAttackLevel,
+        DWORD dwAttackTime,
+        DWORD dwFadeLevel,
+        DWORD dwFadeTime
+        );
+
+    BOOL
+    SetEnvelope(
+        LPFEEL_ENVELOPE pEnvelope
+        );
+
+
+    //
+    // OPERATIONS
+    //
+
+    public:
+
+    virtual BOOL
+    Initialize( 
+        CFeelDevice* pDevice, 
+        const FEEL_EFFECT &effect
+        );
+
+	virtual BOOL 
+	InitializeFromProject(
+		CFeelProject &project,
+		LPCSTR lpszEffectName,
+		CFeelDevice* pDevice = NULL
+	);
+
+	virtual BOOL 
+	Start(
+        DWORD dwIterations = 1,
+        DWORD dwFlags = 0
+        );
+
+#ifdef FFC_START_DELAY
+	virtual BOOL 
+	StartNow(
+        DWORD dwIterations = 1,
+        DWORD dwFlags = 0
+        );
+#endif
+
+    virtual BOOL 
+    Stop();
+   
+
+//
+// ------ PRIVATE INTERFACE ------ 
+//
+
+	//
+    // CACHING
+    //
+
+#ifdef FFC_EFFECT_CACHING
+
+	public:
+
+	BOOL GetIsPlaying() const;
+	BOOL GetIsTriggered() const;
+	short GetPriority() const { return m_Priority; }
+	void SetPriority(short priority) { m_Priority = priority; }
+	HRESULT Unload();
+	void Reload();
+
+	public:
+
+	ECacheState m_CacheState; // effect's status in the cache
+	BOOL m_bInCurrentSuite; // is the effect in the currently loaded suite?
+	short m_Priority; // Priority within suite: higher number is higher priority
+	DWORD m_dwLastStarted; // when last started (0 = never) or when param change made on device
+	DWORD m_dwLastStopped; // when last stopped (0 = not since last start)
+	DWORD m_dwLastLoaded; // when last loaded with CFeelEffectSuite::Load or Create
+
+    protected:
+
+	CFeelDevice *m_pFeelDevice; // ### Use instead of m_piFeelitDevice
+#endif
+
+	//
+    // HELPERS
+    //
+    protected:
+
+#ifdef FFC_EFFECT_CACHING
+	public: // initalize needs to be called by CFeelDevice
+#endif
+   BOOL 
+    initialize( 
+        CFeelDevice* pDevice
+        );
+#ifdef FFC_EFFECT_CACHING
+	protected:
+#endif
+
+	HRESULT
+	set_parameters_on_device(
+		DWORD dwFlags
+		);
+
+	void 
+	feel_to_DI_GUID( 
+		GUID &guid
+		);
+
+    void
+    reset();
+
+    void
+    reset_effect_struct();
+
+
+    //
+    // INTERNAL DATA
+    //
+
+    protected:
+
+    FEEL_EFFECT m_Effect;
+    DWORD m_dwaAxes[2];
+    LONG m_laDirections[2];
+
+    GUID m_guidEffect;
+    BOOL m_bIsPlaying;
+	DWORD m_dwDeviceType;
+    LPIFEEL_DEVICE m_piFeelitDevice; // Might also be holding LPDIRECTINPUTDEVICE2
+    LPIFEEL_EFFECT m_piFeelitEffect;
+	DWORD m_cAxes; // Number of axes
+
+#ifdef FFC_START_DELAY
+	public:
+	// Prevents access to dangling pointer when this is deleted
+	// All relevent code may be removed when all hardware and drivers support start delay
+	CFeelEffect **m_ppTimerRef; // pointer to pointer to this.
+#endif
+};
+
+
+#if (DIRECTINPUT_VERSION >= 0x0700)
+ #define DIRECT_INPUT_STARTDELAY_SUPPORTED TRUE
+#else
+ #define DIRECT_INPUT_STARTDELAY_SUPPORTED FALSE
+#endif /* DIRECTINPUT_VERSION >= 0x0700 */
+
+#endif // !defined(AFX_FEELEFFECT_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_)
diff --git a/code/win32/FeelIt/FeelEllipse.h b/code/win32/FeelIt/FeelEllipse.h
new file mode 100644
index 0000000..0484013
--- /dev/null
+++ b/code/win32/FeelIt/FeelEllipse.h
@@ -0,0 +1,253 @@
+/**********************************************************************
+	Copyright (c) 1997 Immersion Corporation
+
+	Permission to use, copy, modify, distribute, and sell this
+	software and its documentation may be granted without fee;
+	interested parties are encouraged to request permission from
+		Immersion Corporation
+		2158 Paragon Drive
+		San Jose, CA 95131
+		408-467-1900
+
+	IMMERSION DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+	INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.
+	IN NO EVENT SHALL IMMERSION BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+	CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+	LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+	NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+	CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+  FILE:		FeelEllipse.h
+
+  PURPOSE:	Base Ellipse Class for Feelit API Foundation Classes
+
+  STARTED:	10/29/97
+
+  NOTES/REVISIONS:
+     3/2/99 jrm (Jeff Mallett): Force-->Feel renaming
+	 3/2/99 jrm: Added GetIsCompatibleGUID
+	 3/15/99 jrm: __declspec(dllimport/dllexport) the whole class
+
+**********************************************************************/
+
+
+#if !defined(AFX_FEELELLIPSE_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_)
+#define AFX_FEELELLIPSE_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_
+
+#if _MSC_VER >= 1000
+#pragma once
+#endif // _MSC_VER >= 1000
+
+#ifndef _FFCDLL_
+#define DLLFFC __declspec(dllimport)
+#else
+#define DLLFFC __declspec(dllexport)
+#endif
+
+#include "FeelBaseTypes.h"
+#include "FeelEffect.h"
+
+
+
+//================================================================
+// Constants
+//================================================================
+
+#define     FEEL_ELLIPSE_DEFAULT_STIFFNESS      5000
+#define     FEEL_ELLIPSE_DEFAULT_SATURATION     10000
+#define     FEEL_ELLIPSE_DEFAULT_WIDTH          10
+#define     FEEL_ELLIPSE_HEIGHT_AUTO            MAXDWORD
+#define     FEEL_ELLIPSE_DEFAULT_HEIGHT         FEEL_ELLIPSE_HEIGHT_AUTO
+#define     FEEL_ELLIPSE_WALL_WIDTH_AUTO        MAXDWORD
+#define     FEEL_ELLIPSE_DEFAULT_WALL_WIDTH     FEEL_ELLIPSE_WALL_WIDTH_AUTO
+#define     FEEL_ELLIPSE_DEFAULT_STIFFNESS_MASK FEELIT_FSTIFF_ANYWALL
+#define     FEEL_ELLIPSE_DEFAULT_CLIPPING_MASK  FEELIT_FCLIP_NONE
+
+#define     FEEL_ELLIPSE_DEFAULT_CENTER_POINT   FEEL_EFFECT_MOUSE_POS_AT_START
+
+//
+// FEEL --> FORCE Wrappers
+//
+#define     FORCE_ELLIPSE_DEFAULT_STIFFNESS      FEEL_ELLIPSE_DEFAULT_STIFFNESS
+#define     FORCE_ELLIPSE_DEFAULT_SATURATION     FEEL_ELLIPSE_DEFAULT_SATURATION
+#define     FORCE_ELLIPSE_DEFAULT_WIDTH          FEEL_ELLIPSE_DEFAULT_WIDTH
+#define     FORCE_ELLIPSE_HEIGHT_AUTO            FEEL_ELLIPSE_HEIGHT_AUTO
+#define     FORCE_ELLIPSE_DEFAULT_HEIGHT         FEEL_ELLIPSE_DEFAULT_HEIGHT
+#define     FORCE_ELLIPSE_WALL_WIDTH_AUTO        FEEL_ELLIPSE_WALL_WIDTH_AUTO
+#define     FORCE_ELLIPSE_DEFAULT_WALL_WIDTH     FEEL_ELLIPSE_DEFAULT_WALL_WIDTH
+#define     FORCE_ELLIPSE_DEFAULT_STIFFNESS_MASK FEEL_ELLIPSE_DEFAULT_STIFFNESS_MASK
+#define     FORCE_ELLIPSE_DEFAULT_CLIPPING_MASK  FEEL_ELLIPSE_DEFAULT_CLIPPING_MASK
+
+#define     FORCE_ELLIPSE_DEFAULT_CENTER_POINT   FEEL_ELLIPSE_DEFAULT_CENTER_POINT
+
+
+
+
+//================================================================
+// CFeelEllipse
+//================================================================
+
+//
+// ------ PUBLIC INTERFACE ------ 
+//
+
+class DLLFFC CFeelEllipse : public CFeelEffect
+{
+    //
+    // CONSTRUCTOR/DESCTRUCTOR
+    //
+
+    public:
+    
+    // Constructor
+	CFeelEllipse();
+
+	// Destructor
+	virtual
+	~CFeelEllipse();
+
+
+    //
+    // ATTRIBUTES
+    //
+
+    public:
+
+	virtual BOOL
+	GetIsCompatibleGUID(
+		GUID &guid
+		);
+
+    BOOL
+    ChangeParameters( 
+        POINT pntCenter,
+        DWORD dwWidth = FEEL_EFFECT_DONT_CHANGE,
+        DWORD dwHeight = FEEL_EFFECT_DONT_CHANGE,
+        LONG lStiffness = FEEL_EFFECT_DONT_CHANGE,
+        DWORD dwWallWidth = FEEL_EFFECT_DONT_CHANGE,
+        DWORD dwSaturation = FEEL_EFFECT_DONT_CHANGE,
+        DWORD dwStiffnessMask = FEEL_EFFECT_DONT_CHANGE,
+        DWORD dwClippingMask = FEEL_EFFECT_DONT_CHANGE,
+        CFeelEffect* pInsideEffect = (CFeelEffect*) FEEL_EFFECT_DONT_CHANGE  
+        );
+
+    BOOL
+    ChangeParameters( 
+        LPCRECT pRectOutside,
+        LONG lStiffness = FEEL_EFFECT_DONT_CHANGE,
+        DWORD dwWallWidth = FEEL_EFFECT_DONT_CHANGE,
+        DWORD dwSaturation = FEEL_EFFECT_DONT_CHANGE,
+        DWORD dwStiffnessMask = FEEL_EFFECT_DONT_CHANGE,
+        DWORD dwClippingMask = FEEL_EFFECT_DONT_CHANGE,
+        CFeelEffect* pInsideEffect = (CFeelEffect*) FEEL_EFFECT_DONT_CHANGE  
+        );
+
+
+    BOOL
+    SetRect( 
+        LPCRECT pRect 
+        );
+
+
+    BOOL
+    SetCenter( 
+        POINT pntCenter 
+        );
+
+
+    BOOL
+    SetCenter( 
+        LONG x, 
+        LONG y 
+        );
+
+
+    //
+    // OPERATIONS
+    //
+
+    public:
+
+    BOOL 
+    Initialize( 
+        CFeelDevice* pDevice, 
+        DWORD dwWidth = FEEL_ELLIPSE_DEFAULT_WIDTH,
+        DWORD dwHeight = FEEL_ELLIPSE_DEFAULT_HEIGHT,
+        LONG lStiffness = FEEL_ELLIPSE_DEFAULT_STIFFNESS,
+        DWORD dwWallWidth = FEEL_ELLIPSE_DEFAULT_WALL_WIDTH,
+        DWORD dwSaturation = FEEL_ELLIPSE_DEFAULT_SATURATION,
+        DWORD dwStiffnessMask = FEEL_ELLIPSE_DEFAULT_STIFFNESS_MASK,
+        DWORD dwClippingMask = FEEL_ELLIPSE_DEFAULT_CLIPPING_MASK,
+        POINT pntCenter = FEEL_ELLIPSE_DEFAULT_CENTER_POINT,
+        CFeelEffect* pInsideEffect = NULL  
+        );
+
+
+    BOOL 
+    Initialize( 
+        CFeelDevice* pDevice, 
+        LPCRECT pRectOutside,
+        LONG lStiffness = FEEL_ELLIPSE_DEFAULT_STIFFNESS,
+        DWORD dwWallWidth = FEEL_ELLIPSE_DEFAULT_WALL_WIDTH,
+        DWORD dwSaturation = FEEL_ELLIPSE_DEFAULT_SATURATION,
+        DWORD dwStiffnessMask = FEEL_ELLIPSE_DEFAULT_STIFFNESS_MASK,
+        DWORD dwClippingMask = FEEL_ELLIPSE_DEFAULT_CLIPPING_MASK,
+        CFeelEffect* pInsideEffect = NULL  
+        );
+
+
+    virtual BOOL 
+#ifdef FFC_START_DELAY
+	StartNow(
+#else
+	Start(
+#endif
+        DWORD dwFlags = 0
+        );
+
+        
+//
+// ------ PRIVATE INTERFACE ------ 
+//
+
+    //
+    // HELPERS
+    //
+
+    protected:
+
+    BOOL
+        set_parameters( 
+        LPCRECT pRectOutside,
+        LONG lStiffness,
+        DWORD dwWallWidth,
+        DWORD dwSaturation,
+        DWORD dwStiffnessMask,
+        DWORD dwClippingMask,
+        CFeelEffect* pInsideEffect  
+        );
+
+    //
+    // INTERNAL DATA
+    //
+    
+    protected:
+
+    FEELIT_ELLIPSE m_ellipse;
+    BOOL m_bUseMousePosAtStart;
+
+};
+
+
+
+//
+// INLINES
+//
+
+inline BOOL
+CFeelEllipse::GetIsCompatibleGUID(GUID &guid)
+{
+	return IsEqualGUID(guid, GUID_Feel_Ellipse);
+}
+
+#endif // !defined(AFX_FEELELLIPSE_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_)
diff --git a/code/win32/FeelIt/FeelEnclosure.h b/code/win32/FeelIt/FeelEnclosure.h
new file mode 100644
index 0000000..aa79a1f
--- /dev/null
+++ b/code/win32/FeelIt/FeelEnclosure.h
@@ -0,0 +1,268 @@
+/**********************************************************************
+	Copyright (c) 1997 Immersion Corporation
+
+	Permission to use, copy, modify, distribute, and sell this
+	software and its documentation may be granted without fee;
+	interested parties are encouraged to request permission from
+		Immersion Corporation
+		2158 Paragon Drive
+		San Jose, CA 95131
+		408-467-1900
+
+	IMMERSION DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+	INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.
+	IN NO EVENT SHALL IMMERSION BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+	CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+	LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+	NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+	CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+  FILE:		FeelEnclosure.h
+
+  PURPOSE:	Base Enclosure Class for Feelit API Foundation Classes
+
+  STARTED:	10/29/97
+
+  NOTES/REVISIONS:
+     3/2/99 jrm (Jeff Mallett): Force-->Feel renaming
+	 3/2/99 jrm: Added GetIsCompatibleGUID
+	 3/15/99 jrm: __declspec(dllimport/dllexport) the whole class
+
+**********************************************************************/
+
+
+#if !defined(AFX_FEELENCLOSURE_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_)
+#define AFX_FEELENCLOSURE_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_
+
+#if _MSC_VER >= 1000
+#pragma once
+#endif // _MSC_VER >= 1000
+
+#ifndef _FFCDLL_
+#define DLLFFC __declspec(dllimport)
+#else
+#define DLLFFC __declspec(dllexport)
+#endif
+
+#include "FeelBaseTypes.h"
+#include "FeelEffect.h"
+
+
+
+//================================================================
+// Constants
+//================================================================
+
+
+#define     FEEL_ENCLOSURE_DEFAULT_STIFFNESS      5000
+#define     FEEL_ENCLOSURE_DEFAULT_SATURATION     10000
+#define     FEEL_ENCLOSURE_DEFAULT_WIDTH          10
+#define     FEEL_ENCLOSURE_HEIGHT_AUTO            MAXDWORD
+#define     FEEL_ENCLOSURE_DEFAULT_HEIGHT         FEEL_ENCLOSURE_HEIGHT_AUTO
+#define     FEEL_ENCLOSURE_WALL_WIDTH_AUTO        MAXDWORD
+#define     FEEL_ENCLOSURE_DEFAULT_WALL_WIDTH     FEEL_ENCLOSURE_WALL_WIDTH_AUTO
+#define     FEEL_ENCLOSURE_DEFAULT_STIFFNESS_MASK FEELIT_FSTIFF_ANYWALL
+#define     FEEL_ENCLOSURE_DEFAULT_CLIPPING_MASK  FEELIT_FCLIP_NONE
+
+#define     FEEL_ENCLOSURE_DEFAULT_CENTER_POINT   FEEL_EFFECT_MOUSE_POS_AT_START
+
+//
+// FORCE --> FEEL Wrappers
+//
+#define     FORCE_ENCLOSURE_DEFAULT_STIFFNESS      FEEL_ENCLOSURE_DEFAULT_STIFFNESS
+#define     FORCE_ENCLOSURE_DEFAULT_SATURATION     FEEL_ENCLOSURE_DEFAULT_SATURATION
+#define     FORCE_ENCLOSURE_DEFAULT_WIDTH          FEEL_ENCLOSURE_DEFAULT_WIDTH
+#define     FORCE_ENCLOSURE_HEIGHT_AUTO            FEEL_ENCLOSURE_HEIGHT_AUTO
+#define     FORCE_ENCLOSURE_DEFAULT_HEIGHT         FEEL_ENCLOSURE_DEFAULT_HEIGHT
+#define     FORCE_ENCLOSURE_WALL_WIDTH_AUTO        FEEL_ENCLOSURE_WALL_WIDTH_AUTO
+#define     FORCE_ENCLOSURE_DEFAULT_WALL_WIDTH     FEEL_ENCLOSURE_DEFAULT_WALL_WIDTH
+#define     FORCE_ENCLOSURE_DEFAULT_STIFFNESS_MASK FEEL_ENCLOSURE_DEFAULT_STIFFNESS_MASK
+#define     FORCE_ENCLOSURE_DEFAULT_CLIPPING_MASK  FEEL_ENCLOSURE_DEFAULT_CLIPPING_MASK
+
+#define     FORCE_ENCLOSURE_DEFAULT_CENTER_POINT   FEEL_ENCLOSURE_DEFAULT_CENTER_POINT
+
+
+
+
+//================================================================
+// CFeelEnclosure
+//================================================================
+
+//
+// ------ PUBLIC INTERFACE ------ 
+//
+
+class DLLFFC CFeelEnclosure : public CFeelEffect
+{
+    //
+    // CONSTRUCTOR/DESCTRUCTOR
+    //
+
+    public:
+    
+    // Constructor
+	CFeelEnclosure();
+
+	// Destructor
+	virtual
+	~CFeelEnclosure();
+
+
+    //
+    // ATTRIBUTES
+    //
+
+    public:
+
+	virtual BOOL
+	GetIsCompatibleGUID(
+		GUID &guid
+		);
+
+    BOOL
+    ChangeParameters( 
+        POINT pntCenter,
+        DWORD dwWidth = FEEL_EFFECT_DONT_CHANGE,
+        DWORD dwHeight = FEEL_EFFECT_DONT_CHANGE,
+        LONG lTopAndBottomWallStiffness = FEEL_EFFECT_DONT_CHANGE,
+        LONG lLeftAndRightWallStiffness = FEEL_EFFECT_DONT_CHANGE,
+        DWORD dwTopAndBottomWallWallWidth = FEEL_EFFECT_DONT_CHANGE,
+        DWORD dwLeftAndRightWallWallWidth = FEEL_EFFECT_DONT_CHANGE,
+        DWORD dwTopAndBottomWallSaturation = FEEL_EFFECT_DONT_CHANGE,
+        DWORD dwLeftAndRightWallSaturation = FEEL_EFFECT_DONT_CHANGE,
+        DWORD dwStiffnessMask = FEEL_EFFECT_DONT_CHANGE,
+        DWORD dwClippingMask = FEEL_EFFECT_DONT_CHANGE,
+        CFeelEffect* pInsideEffect = (CFeelEffect*) FEEL_EFFECT_DONT_CHANGE  
+        );
+
+    BOOL
+    ChangeParameters( 
+        LPCRECT pRectOutside,
+        LONG lTopAndBottomWallStiffness = FEEL_EFFECT_DONT_CHANGE,
+        LONG lLeftAndRightWallStiffness = FEEL_EFFECT_DONT_CHANGE,
+        DWORD dwTopAndBottomWallWallWidth = FEEL_EFFECT_DONT_CHANGE,
+        DWORD dwLeftAndRightWallWallWidth = FEEL_EFFECT_DONT_CHANGE,
+        DWORD dwTopAndBottomWallSaturation = FEEL_EFFECT_DONT_CHANGE,
+        DWORD dwLeftAndRightWallSaturation = FEEL_EFFECT_DONT_CHANGE,
+        DWORD dwStiffnessMask = FEEL_EFFECT_DONT_CHANGE,
+        DWORD dwClippingMask = FEEL_EFFECT_DONT_CHANGE,
+        CFeelEffect* pInsideEffect = (CFeelEffect*) FEEL_EFFECT_DONT_CHANGE  
+        );
+
+
+    BOOL
+    SetRect( 
+        LPCRECT pRect 
+        );
+
+
+    BOOL
+    SetCenter( 
+        POINT pntCenter 
+        );
+
+
+    BOOL
+    SetCenter( 
+        LONG x, 
+        LONG y 
+        );
+
+
+    //
+    // OPERATIONS
+    //
+
+    public:
+
+    BOOL 
+    Initialize( 
+        CFeelDevice* pDevice, 
+        DWORD dwWidth = FEEL_ENCLOSURE_DEFAULT_WIDTH,
+        DWORD dwHeight = FEEL_ENCLOSURE_DEFAULT_HEIGHT,
+        LONG lTopAndBottomWallStiffness = FEEL_ENCLOSURE_DEFAULT_STIFFNESS,
+        LONG lLeftAndRightWallStiffness = FEEL_ENCLOSURE_DEFAULT_STIFFNESS,
+        DWORD dwTopAndBottomWallWallWidth = FEEL_ENCLOSURE_DEFAULT_WALL_WIDTH,
+        DWORD dwLeftAndRightWallWallWidth = FEEL_ENCLOSURE_DEFAULT_WALL_WIDTH,
+        DWORD dwTopAndBottomWallSaturation = FEEL_ENCLOSURE_DEFAULT_SATURATION,
+        DWORD dwLeftAndRightWallSaturation = FEEL_ENCLOSURE_DEFAULT_SATURATION,
+        DWORD dwStiffnessMask = FEEL_ENCLOSURE_DEFAULT_STIFFNESS_MASK,
+        DWORD dwClippingMask = FEEL_ENCLOSURE_DEFAULT_CLIPPING_MASK,
+        POINT pntCenter = FEEL_ENCLOSURE_DEFAULT_CENTER_POINT,
+        CFeelEffect* pInsideEffect = NULL  
+        );
+
+
+    BOOL 
+    Initialize( 
+        CFeelDevice* pDevice, 
+        LPCRECT pRectOutside,
+        LONG lTopAndBottomWallStiffness = FEEL_ENCLOSURE_DEFAULT_STIFFNESS,
+        LONG lLeftAndRightWallStiffness = FEEL_ENCLOSURE_DEFAULT_STIFFNESS,
+        DWORD dwTopAndBottomWallWallWidth = FEEL_ENCLOSURE_DEFAULT_WALL_WIDTH,
+        DWORD dwLeftAndRightWallWallWidth = FEEL_ENCLOSURE_DEFAULT_WALL_WIDTH,
+        DWORD dwTopAndBottomWallSaturation = FEEL_ENCLOSURE_DEFAULT_SATURATION,
+        DWORD dwLeftAndRightWallSaturation = FEEL_ENCLOSURE_DEFAULT_SATURATION,
+        DWORD dwStiffnessMask = FEEL_ENCLOSURE_DEFAULT_STIFFNESS_MASK,
+        DWORD dwClippingMask = FEEL_ENCLOSURE_DEFAULT_CLIPPING_MASK,
+        CFeelEffect* pInsideEffect = NULL  
+        );
+
+
+    virtual BOOL 
+#ifdef FFC_START_DELAY
+    StartNow(
+#else
+    Start(
+#endif
+        DWORD dwFlags = 0
+        );
+
+        
+//
+// ------ PRIVATE INTERFACE ------ 
+//
+
+    //
+    // HELPERS
+    //
+
+    protected:
+
+    BOOL
+        set_parameters( 
+        LPCRECT pRectOutside,
+        LONG lTopAndBottomWallStiffness,
+        LONG lLeftAndRightWallStiffness,
+        DWORD dwTopAndBottomWallWallWidth,
+        DWORD dwLeftAndRightWallWallWidth,
+        DWORD dwTopAndBottomWallSaturation,
+        DWORD dwLeftAndRightWallSaturation,
+        DWORD dwStiffnessMask,
+        DWORD dwClippingMask,
+        CFeelEffect* pInsideEffect  
+        );
+
+    //
+    // INTERNAL DATA
+    //
+    
+    protected:
+
+    FEELIT_ENCLOSURE m_enclosure;
+    BOOL m_bUseMousePosAtStart;
+
+};
+
+
+//
+// INLINES
+//
+
+inline BOOL
+CFeelEnclosure::GetIsCompatibleGUID(GUID &guid)
+{
+	return IsEqualGUID(guid, GUID_Feel_Enclosure);
+}
+
+#endif // !defined(AFX_FEELENCLOSURE_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_)
diff --git a/code/win32/FeelIt/FeelFriction.h b/code/win32/FeelIt/FeelFriction.h
new file mode 100644
index 0000000..2548c47
--- /dev/null
+++ b/code/win32/FeelIt/FeelFriction.h
@@ -0,0 +1,172 @@
+/**********************************************************************
+	Copyright (c) 1997 Immersion Corporation
+
+	Permission to use, copy, modify, distribute, and sell this
+	software and its documentation may be granted without fee;
+	interested parties are encouraged to request permission from
+		Immersion Corporation
+		2158 Paragon Drive
+		San Jose, CA 95131
+		408-467-1900
+
+	IMMERSION DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+	INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.
+	IN NO EVENT SHALL IMMERSION BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+	CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+	LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+	NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+	CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+  FILE:		FeelFriction.h
+
+  PURPOSE:	Feelit API Friction Effect Class
+
+  STARTED:	12/29/97
+
+  NOTES/REVISIONS:
+     3/2/99 jrm (Jeff Mallett): Force-->Feel renaming
+	 3/2/99 jrm: Added GetIsCompatibleGUID
+	 3/15/99 jrm: __declspec(dllimport/dllexport) the whole class
+
+**********************************************************************/
+
+
+#if !defined(AFX_FEELFriction_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_)
+#define AFX_FEELFriction_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_
+
+#if _MSC_VER >= 1000
+#pragma once
+#endif // _MSC_VER >= 1000
+
+#ifndef _FFCDLL_
+#define DLLFFC __declspec(dllimport)
+#else
+#define DLLFFC __declspec(dllexport)
+#endif
+
+#include <windows.h>
+#include "FeelCondition.h"
+
+
+//================================================================
+// Constants
+//================================================================
+
+#define     FEEL_FRICTION_DEFAULT_COEFFICIENT    2500
+#define     FEEL_FRICTION_DEFAULT_MIN_VELOCITY   0
+
+//
+// FORCE --> FEEL Wrappers
+//
+#define     FORCE_FRICTION_DEFAULT_COEFFICIENT    FEEL_FRICTION_DEFAULT_COEFFICIENT
+#define     FORCE_FRICTION_DEFAULT_MIN_VELOCITY   FEEL_FRICTION_DEFAULT_MIN_VELOCITY
+
+
+//================================================================
+// CFeelFriction
+//================================================================
+
+//
+// ------ PUBLIC INTERFACE ------ 
+//
+
+class DLLFFC CFeelFriction : public CFeelCondition
+{
+    //
+    // CONSTRUCTOR/DESTRUCTOR
+    //
+
+    public:
+    
+    // Constructor
+	CFeelFriction();
+
+	// Destructor
+	virtual
+	~CFeelFriction();
+
+
+    //
+    // ATTRIBUTES
+    //
+
+    public:
+
+	virtual BOOL
+	GetIsCompatibleGUID(
+		GUID &guid
+		);
+
+    BOOL
+    ChangeParameters( 
+        DWORD dwCoefficient,
+        DWORD dwMinVelocity = FEEL_EFFECT_DONT_CHANGE,
+        LONG lDirectionX = FEEL_EFFECT_DONT_CHANGE,
+        LONG lDirectionY = FEEL_EFFECT_DONT_CHANGE
+        );
+
+    BOOL
+    ChangeParametersPolar( 
+        DWORD dwCoefficient,
+        DWORD dwMinVelocity,
+        LONG lAngle
+        );
+
+
+    //
+    // OPERATIONS
+    //
+
+    public:
+
+    virtual BOOL 
+    Initialize( 
+        CFeelDevice* pDevice, 
+        DWORD dwCoefficient = FEEL_FRICTION_DEFAULT_COEFFICIENT,
+        DWORD dwMinVelocity = FEEL_FRICTION_DEFAULT_MIN_VELOCITY,
+        DWORD dwfAxis = FEEL_EFFECT_AXIS_BOTH,
+        LONG lDirectionX = FEEL_EFFECT_DEFAULT_DIRECTION_X,
+        LONG lDirectionY = FEEL_EFFECT_DEFAULT_DIRECTION_Y
+        );
+
+    virtual BOOL 
+    InitializePolar( 
+        CFeelDevice* pDevice, 
+        DWORD dwCoefficient,
+        DWORD dwMinVelocity,
+        LONG lAngle
+        );
+
+        
+//
+// ------ PRIVATE INTERFACE ------ 
+//
+
+    //
+    // HELPERS
+    //
+
+    protected:
+
+    //
+    // INTERNAL DATA
+    //
+    
+    protected:
+
+};
+
+
+
+//
+// INLINES
+//
+
+inline BOOL
+CFeelFriction::GetIsCompatibleGUID(GUID &guid)
+{
+	return IsEqualGUID(guid, GUID_Feel_Friction);
+}
+
+
+#endif // !defined(AFX_FEELFriction_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_)
diff --git a/code/win32/FeelIt/FeelGrid.h b/code/win32/FeelIt/FeelGrid.h
new file mode 100644
index 0000000..807eba8
--- /dev/null
+++ b/code/win32/FeelIt/FeelGrid.h
@@ -0,0 +1,171 @@
+/**********************************************************************
+	Copyright (c) 1997 Immersion Corporation
+
+	Permission to use, copy, modify, distribute, and sell this
+	software and its documentation may be granted without fee;
+	interested parties are encouraged to request permission from
+		Immersion Corporation
+		2158 Paragon Drive
+		San Jose, CA 95131
+		408-467-1900
+
+	IMMERSION DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+	INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.
+	IN NO EVENT SHALL IMMERSION BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+	CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+	LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+	NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+	CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+  FILE:		FeelGrid.h
+
+  PURPOSE:	Feelit API Grid Effect Class
+
+  STARTED:	12/11/97
+
+  NOTES/REVISIONS:
+     3/2/99 jrm (Jeff Mallett): Force-->Feel renaming
+	 3/2/99 jrm: Added GetIsCompatibleGUID
+	 3/15/99 jrm: __declspec(dllimport/dllexport) the whole class
+
+**********************************************************************/
+
+
+#if !defined(AFX_FEELGrid_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_)
+#define AFX_FEELGrid_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_
+
+#if _MSC_VER >= 1000
+#pragma once
+#endif // _MSC_VER >= 1000
+
+#ifndef _FFCDLL_
+#define DLLFFC __declspec(dllimport)
+#else
+#define DLLFFC __declspec(dllexport)
+#endif
+
+#include <windows.h>
+#include "FeelCondition.h"
+
+
+//================================================================
+// Constants
+//================================================================
+
+#define     FEEL_GRID_DEFAULT_HORIZ_OFFSET     0  
+#define     FEEL_GRID_DEFAULT_VERT_OFFSET      0
+#define     FEEL_GRID_DEFAULT_HORIZ_SPACING    100
+#define     FEEL_GRID_DEFAULT_VERT_SPACING     100
+#define     FEEL_GRID_DEFAULT_NODE_STRENGTH    5000
+#define     FEEL_GRID_DEFAULT_NODE_SATURATION  10000   
+
+//
+// FORCE --> FEEL Wrappers
+//
+#define     FORCE_GRID_DEFAULT_HORIZ_OFFSET     FEEL_GRID_DEFAULT_HORIZ_OFFSET 
+#define     FORCE_GRID_DEFAULT_VERT_OFFSET      FEEL_GRID_DEFAULT_VERT_OFFSET
+#define     FORCE_GRID_DEFAULT_HORIZ_SPACING    FEEL_GRID_DEFAULT_HORIZ_SPACING
+#define     FORCE_GRID_DEFAULT_VERT_SPACING     FEEL_GRID_DEFAULT_VERT_SPACING
+#define     FORCE_GRID_DEFAULT_NODE_STRENGTH    FEEL_GRID_DEFAULT_NODE_STRENGTH
+#define     FORCE_GRID_DEFAULT_NODE_SATURATION  FEEL_GRID_DEFAULT_NODE_SATURATION
+
+
+//================================================================
+// CFeelGrid
+//================================================================
+
+//
+// ------ PUBLIC INTERFACE ------ 
+//
+
+class DLLFFC CFeelGrid : public CFeelCondition
+{
+    //
+    // CONSTRUCTOR/DESTRUCTOR
+    //
+
+    public:
+    
+    // Constructor
+	CFeelGrid();
+
+	// Destructor
+	virtual
+	~CFeelGrid();
+
+
+    //
+    // ATTRIBUTES
+    //
+
+    public:
+
+	virtual BOOL
+	GetIsCompatibleGUID(
+		GUID &guid
+		);
+
+    BOOL
+    ChangeParameters( 
+        DWORD dwHorizSpacing,
+        DWORD dwVertSpacing,
+        LONG  lHorizNodeStrength = FEEL_EFFECT_DONT_CHANGE,
+        LONG  lVertNodeStrength = FEEL_EFFECT_DONT_CHANGE,
+        DWORD dwHorizOffset = FEEL_EFFECT_DONT_CHANGE,
+        DWORD dwVertOffset = FEEL_EFFECT_DONT_CHANGE,
+        DWORD dwHorizNodeSaturation = FEEL_EFFECT_DONT_CHANGE,
+        DWORD dwVertNodeSaturation = FEEL_EFFECT_DONT_CHANGE
+        );
+
+
+    //
+    // OPERATIONS
+    //
+
+    public:
+
+    virtual BOOL 
+    Initialize( 
+        CFeelDevice* pDevice, 
+        DWORD dwHorizSpacing = FEEL_GRID_DEFAULT_HORIZ_SPACING,
+        DWORD dwVertSpacing = FEEL_GRID_DEFAULT_VERT_SPACING,
+        LONG  lHorizNodeStrength = FEEL_GRID_DEFAULT_NODE_STRENGTH,
+        LONG  lVertNodeStrength = FEEL_GRID_DEFAULT_NODE_STRENGTH,
+        DWORD dwHorizOffset = FEEL_GRID_DEFAULT_HORIZ_OFFSET,
+        DWORD dwVertOffset = FEEL_GRID_DEFAULT_VERT_OFFSET,
+        DWORD dwHorizNodeSaturation = FEEL_GRID_DEFAULT_NODE_SATURATION,
+        DWORD dwVertNodeSaturation = FEEL_GRID_DEFAULT_NODE_SATURATION
+        );
+
+
+//
+// ------ PRIVATE INTERFACE ------ 
+//
+
+    //
+    // HELPERS
+    //
+
+    protected:
+
+    //
+    // INTERNAL DATA
+    //
+    
+    protected:
+
+};
+
+
+
+//
+// INLINES
+//
+
+inline BOOL
+CFeelGrid::GetIsCompatibleGUID(GUID &guid)
+{
+	return IsEqualGUID(guid, GUID_Feel_Grid);
+}
+		
+#endif // !defined(AFX_FEELGrid_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_)
diff --git a/code/win32/FeelIt/FeelInertia.h b/code/win32/FeelIt/FeelInertia.h
new file mode 100644
index 0000000..c1a22d3
--- /dev/null
+++ b/code/win32/FeelIt/FeelInertia.h
@@ -0,0 +1,178 @@
+/**********************************************************************
+	Copyright (c) 1997 Immersion Corporation
+
+	Permission to use, copy, modify, distribute, and sell this
+	software and its documentation may be granted without fee;
+	interested parties are encouraged to request permission from
+		Immersion Corporation
+		2158 Paragon Drive
+		San Jose, CA 95131
+		408-467-1900
+
+	IMMERSION DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+	INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.
+	IN NO EVENT SHALL IMMERSION BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+	CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+	LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+	NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+	CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+  FILE:		FeelInertia.h
+
+  PURPOSE:	Feelit API Inertia Effect Class
+
+  STARTED:	12/29/97
+
+  NOTES/REVISIONS:
+     3/2/99 jrm (Jeff Mallett): Force-->Feel renaming
+	 3/2/99 jrm: Added GetIsCompatibleGUID
+	 3/15/99 jrm: __declspec(dllimport/dllexport) the whole class
+
+**********************************************************************/
+
+
+#if !defined(AFX_FEELInertia_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_)
+#define AFX_FEELInertia_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_
+
+#if _MSC_VER >= 1000
+#pragma once
+#endif // _MSC_VER >= 1000
+
+#ifndef _FFCDLL_
+#define DLLFFC __declspec(dllimport)
+#else
+#define DLLFFC __declspec(dllexport)
+#endif
+
+#include <windows.h>
+#include "FeelCondition.h"
+
+
+//================================================================
+// Constants
+//================================================================
+
+#define     FEEL_INERTIA_DEFAULT_COEFFICIENT		2500
+#define     FEEL_INERTIA_DEFAULT_SATURATION			10000
+#define     FEEL_INERTIA_DEFAULT_MIN_ACCELERATION	0
+
+//
+// FORCE --> FEEL Wrappers
+//
+#define     FORCE_INERTIA_DEFAULT_COEFFICIENT		FEEL_INERTIA_DEFAULT_COEFFICIENT
+#define     FORCE_INERTIA_DEFAULT_SATURATION		FEEL_INERTIA_DEFAULT_SATURATION
+#define     FORCE_INERTIA_DEFAULT_MIN_ACCELERATION	FEEL_INERTIA_DEFAULT_MIN_ACCELERATION
+
+
+//================================================================
+// CFeelInertia
+//================================================================
+
+//
+// ------ PUBLIC INTERFACE ------ 
+//
+
+class DLLFFC CFeelInertia : public CFeelCondition
+{
+    //
+    // CONSTRUCTOR/DESTRUCTOR
+    //
+
+    public:
+    
+    // Constructor
+	CFeelInertia();
+
+	// Destructor
+	virtual
+	~CFeelInertia();
+
+
+    //
+    // ATTRIBUTES
+    //
+
+    public:
+
+	virtual BOOL
+	GetIsCompatibleGUID(
+		GUID &guid
+		);
+
+    BOOL
+    ChangeParameters( 
+        DWORD dwCoefficient,
+        DWORD dwSaturation = FEEL_EFFECT_DONT_CHANGE,
+        DWORD dwMinAcceleration = FEEL_EFFECT_DONT_CHANGE,
+        LONG lDirectionX = FEEL_EFFECT_DONT_CHANGE,
+        LONG lDirectionY = FEEL_EFFECT_DONT_CHANGE
+        );
+
+    BOOL
+    ChangeParametersPolar( 
+        DWORD dwCoefficient,
+        DWORD dwSaturation,
+        DWORD dwMinAcceleration,
+        LONG lAngle
+        );
+
+
+    //
+    // OPERATIONS
+    //
+
+    public:
+
+    virtual BOOL 
+    Initialize( 
+        CFeelDevice* pDevice, 
+        DWORD dwCoefficient = FEEL_INERTIA_DEFAULT_COEFFICIENT,
+        DWORD dwSaturation = FEEL_INERTIA_DEFAULT_SATURATION,
+        DWORD dwMinAcceleration = FEEL_INERTIA_DEFAULT_MIN_ACCELERATION,
+        DWORD dwfAxis = FEEL_EFFECT_AXIS_BOTH,
+        LONG lDirectionX = FEEL_EFFECT_DEFAULT_DIRECTION_X,
+        LONG lDirectionY = FEEL_EFFECT_DEFAULT_DIRECTION_Y
+        );
+
+    virtual BOOL 
+    InitializePolar( 
+        CFeelDevice* pDevice, 
+        DWORD dwCoefficient,
+        DWORD dwSaturation,
+        DWORD dwMinAcceleration,
+        LONG lAngle
+        );
+
+
+//
+// ------ PRIVATE INTERFACE ------ 
+//
+        
+    //
+    // HELPERS
+    //
+
+    protected:
+
+    //
+    // INTERNAL DATA
+    //
+    
+    protected:
+
+};
+
+
+
+//
+// INLINES
+//
+
+inline BOOL
+CFeelInertia::GetIsCompatibleGUID(GUID &guid)
+{
+	return IsEqualGUID(guid, GUID_Feel_Inertia);
+}
+
+
+#endif // !defined(AFX_FEELInertia_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_)
diff --git a/code/win32/FeelIt/FeelMouse.h b/code/win32/FeelIt/FeelMouse.h
new file mode 100644
index 0000000..b0e3989
--- /dev/null
+++ b/code/win32/FeelIt/FeelMouse.h
@@ -0,0 +1,143 @@
+/**********************************************************************
+	Copyright (c) 1997 Immersion Corporation
+
+	Permission to use, copy, modify, distribute, and sell this
+	software and its documentation may be granted without fee;
+	interested parties are encouraged to request permission from
+		Immersion Corporation
+		2158 Paragon Drive
+		San Jose, CA 95131
+		408-467-1900
+
+	IMMERSION DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+	INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.
+	IN NO EVENT SHALL IMMERSION BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+	CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+	LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+	NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+	CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+  FILE:		FeelMouse.h
+
+  PURPOSE:	Abstraction of Feelit mouse device
+
+  STARTED:	10/10/97
+
+  NOTES/REVISIONS:
+     3/2/99 jrm (Jeff Mallett): Force-->Feel renaming
+	 3/15/99 jrm: __declspec(dllimport/dllexport) the whole class
+
+**********************************************************************/
+
+#ifndef FeelMouse_h
+#define FeelMouse_h
+
+#ifndef _FFCDLL_
+#define DLLFFC __declspec(dllimport)
+#else
+#define DLLFFC __declspec(dllexport)
+#endif
+
+#include "FeelDevice.h"
+
+
+//================================================================
+// CFeelMouse
+//================================================================
+
+//
+// ------ PUBLIC INTERFACE ------ 
+//
+
+class DLLFFC CFeelMouse : public CFeelDevice
+{
+
+    //
+    // CONSTRUCTOR/DESCTRUCTOR
+    //
+
+    public:
+    
+    // Constructor
+	CFeelMouse();
+
+	// Destructor
+    virtual 
+	~CFeelMouse();
+
+
+    //
+    // ATTRIBUTES
+    //
+
+    public:
+
+	virtual LPIFEEL_API
+    GetAPI() 
+		{ return m_piApi; }
+
+	virtual LPIFEEL_DEVICE
+    GetDevice() 
+		{ return m_piDevice; }
+
+	BOOL 
+    HaveForceFeelitMouse() 
+		{ return m_piDevice != NULL; }
+
+
+    //
+    // OPERATIONS
+    //
+
+	public:
+
+	BOOL
+	Initialize(
+		HANDLE hinstApp,
+		HANDLE hwndApp,
+		DWORD dwCooperativeFlag = FEELIT_FCOOPLEVEL_FOREGROUND
+		);
+
+	virtual BOOL 
+	ChangeScreenResolution(
+		BOOL bAutoSet,
+		DWORD dwXScreenSize = 0,
+		DWORD dwYScreenSize = 0
+		);
+
+	// Another syntax for SwitchToAbsoluteMode.
+	// The default is Absolute mode.  Call only to switch to Relative mode or
+	// to switch back to Absolute mode.
+	virtual BOOL
+	SwitchToAbsoluteMode(
+		BOOL bAbsMode
+		);
+
+//
+// ------ PRIVATE INTERFACE ------ 
+//
+
+	//
+	// HELPERS
+	//
+
+	protected:
+
+	virtual void
+	reset();
+
+	virtual BOOL 
+	prepare_device();
+
+
+    //
+    // INTERNAL DATA
+    //
+
+    protected:
+
+    LPIFEEL_API m_piApi;
+    LPIFEEL_DEVICE m_piDevice;
+};
+
+#endif // ForceFeelitMouse_h
\ No newline at end of file
diff --git a/code/win32/FeelIt/FeelPeriodic.h b/code/win32/FeelIt/FeelPeriodic.h
new file mode 100644
index 0000000..bd870fd
--- /dev/null
+++ b/code/win32/FeelIt/FeelPeriodic.h
@@ -0,0 +1,227 @@
+/**********************************************************************
+	Copyright (c) 1997 Immersion Corporation
+
+	Permission to use, copy, modify, distribute, and sell this
+	software and its documentation may be granted without fee;
+	interested parties are encouraged to request permission from
+		Immersion Corporation
+		2158 Paragon Drive
+		San Jose, CA 95131
+		408-467-1900
+
+	IMMERSION DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+	INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.
+	IN NO EVENT SHALL IMMERSION BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+	CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+	LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+	NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+	CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+  FILE:		FeelPeriodic.h
+
+  PURPOSE:	Base Periodic Class for Feelit API Foundation Classes
+
+  STARTED:	11/03/97
+
+  NOTES/REVISIONS:
+     3/2/99 jrm (Jeff Mallett): Force-->Feel renaming
+	 3/2/99 jrm: Added GetIsCompatibleGUID
+	 3/15/99 jrm: __declspec(dllimport/dllexport) the whole class
+
+**********************************************************************/
+
+
+#if !defined(AFX_FEELPERIODIC_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_)
+#define AFX_FEELPERIODIC_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_
+
+#if _MSC_VER >= 1000
+#pragma once
+#endif // _MSC_VER >= 1000
+
+#ifndef _FFCDLL_
+#define DLLFFC __declspec(dllimport)
+#else
+#define DLLFFC __declspec(dllexport)
+#endif
+
+#include "FeelBaseTypes.h"
+#include "FeelEffect.h"
+
+
+
+//================================================================
+// Constants
+//================================================================
+
+#define     FEEL_PERIODIC_DEFAULT_DURATION       1000 // Milliseconds
+#define     FEEL_PERIODIC_DEFAULT_MAGNITUDE      5000
+#define     FEEL_PERIODIC_DEFAULT_PERIOD         100  // Milliseconds
+#define     FEEL_PERIODIC_DEFAULT_OFFSET         0
+#define     FEEL_PERIODIC_DEFAULT_PHASE          0    // Degrees
+#define     FEEL_PERIODIC_DEFAULT_DIRECTION_X    1    // Pixels
+#define     FEEL_PERIODIC_DEFAULT_DIRECTION_Y    0    // Pixels
+#define     FEEL_PERIODIC_DEFAULT_ANGLE          9000 // 100ths of degrees
+
+//
+// FORCE --> FEEL Wrappers
+//
+#define     FORCE_PERIODIC_DEFAULT_DURATION       FEEL_PERIODIC_DEFAULT_DURATION
+#define     FORCE_PERIODIC_DEFAULT_MAGNITUDE      FEEL_PERIODIC_DEFAULT_MAGNITUDE
+#define     FORCE_PERIODIC_DEFAULT_PERIOD         FEEL_PERIODIC_DEFAULT_PERIOD
+#define     FORCE_PERIODIC_DEFAULT_OFFSET         FEEL_PERIODIC_DEFAULT_OFFSET
+#define     FORCE_PERIODIC_DEFAULT_PHASE          FEEL_PERIODIC_DEFAULT_PHASE
+#define     FORCE_PERIODIC_DEFAULT_DIRECTION_X    FEEL_PERIODIC_DEFAULT_DIRECTION_X
+#define     FORCE_PERIODIC_DEFAULT_DIRECTION_Y    FEEL_PERIODIC_DEFAULT_DIRECTION_Y
+#define     FORCE_PERIODIC_DEFAULT_ANGLE          FEEL_PERIODIC_DEFAULT_ANGLE
+
+
+
+//================================================================
+// CFeelPeriodic
+//================================================================
+
+//
+// ------ PUBLIC INTERFACE ------ 
+//
+
+class DLLFFC CFeelPeriodic : public CFeelEffect
+{
+    //
+    // CONSTRUCTOR/DESTRUCTOR
+    //
+
+    public:
+    
+    // Constructors
+
+	// You may use this form if you will immediately initialize it
+	//   from an IFR file...
+	CFeelPeriodic();
+
+	// Otherwise use this form...
+	CFeelPeriodic(
+		const GUID& rguidEffect
+		);
+
+	// Destructor
+	virtual
+	~CFeelPeriodic();
+
+
+    //
+    // ATTRIBUTES
+    //
+
+    public:
+
+	virtual BOOL
+	GetIsCompatibleGUID(
+		GUID &guid
+		);
+
+    BOOL
+    ChangeParameters( 
+        DWORD dwMagnitude,
+        DWORD dwPeriod = FEEL_EFFECT_DONT_CHANGE,
+        DWORD dwDuration = FEEL_EFFECT_DONT_CHANGE,
+        LONG lDirectionX = FEEL_EFFECT_DONT_CHANGE,
+        LONG lDirectionY = FEEL_EFFECT_DONT_CHANGE,
+        LONG  lOffset = FEEL_EFFECT_DONT_CHANGE,
+        DWORD dwPhase = FEEL_EFFECT_DONT_CHANGE,
+        LPFEEL_ENVELOPE pEnvelope = (LPFEEL_ENVELOPE) FEEL_EFFECT_DONT_CHANGE_PTR
+        );
+
+    BOOL
+    ChangeParametersPolar( 
+        DWORD dwMagnitude,
+        DWORD dwPeriod = FEEL_EFFECT_DONT_CHANGE,
+        DWORD dwDuration = FEEL_EFFECT_DONT_CHANGE,
+        LONG lAngle = FEEL_EFFECT_DONT_CHANGE,
+        LONG  lOffset = FEEL_EFFECT_DONT_CHANGE,
+        DWORD dwPhase = FEEL_EFFECT_DONT_CHANGE,
+        LPFEEL_ENVELOPE pEnvelope = (LPFEEL_ENVELOPE) FEEL_EFFECT_DONT_CHANGE_PTR
+        );
+
+
+    //
+    // OPERATIONS
+    //
+
+    public:
+
+    virtual BOOL
+    Initialize( 
+        CFeelDevice* pDevice, 
+        DWORD dwMagnitude = FEEL_PERIODIC_DEFAULT_MAGNITUDE,
+        DWORD dwPeriod = FEEL_PERIODIC_DEFAULT_PERIOD,
+        DWORD dwDuration = FEEL_PERIODIC_DEFAULT_DURATION,
+        LONG lDirectionX = FEEL_PERIODIC_DEFAULT_DIRECTION_X,
+        LONG lDirectionY = FEEL_PERIODIC_DEFAULT_DIRECTION_Y,
+        LONG  lOffset = FEEL_PERIODIC_DEFAULT_OFFSET,
+        DWORD dwPhase = FEEL_PERIODIC_DEFAULT_PHASE,
+        LPFEEL_ENVELOPE pEnvelope = NULL
+        );
+
+    virtual BOOL
+    InitializePolar( 
+        CFeelDevice* pDevice, 
+        DWORD dwMagnitude = FEEL_PERIODIC_DEFAULT_MAGNITUDE,
+        DWORD dwPeriod = FEEL_PERIODIC_DEFAULT_PERIOD,
+        DWORD dwDuration = FEEL_PERIODIC_DEFAULT_DURATION,
+        LONG lAngle = FEEL_PERIODIC_DEFAULT_ANGLE,
+        LONG  lOffset = FEEL_PERIODIC_DEFAULT_OFFSET,
+        DWORD dwPhase = FEEL_PERIODIC_DEFAULT_PHASE,
+        LPFEEL_ENVELOPE pEnvelope = NULL
+        );
+
+
+//
+// ------ PRIVATE INTERFACE ------ 
+//
+        
+    //
+    // HELPERS
+    //
+
+    protected:
+
+    BOOL
+    set_parameters( 
+        DWORD dwfCoordinates,
+        LONG lDirection0,
+        LONG lDirection1,
+        DWORD dwDuration,
+        DWORD dwMagnitude,
+        DWORD dwPeriod,
+        LONG  lOffset,
+        DWORD dwPhase,
+        LPFEEL_ENVELOPE pEnvelope
+        );
+
+
+    //
+    // INTERNAL DATA
+    //
+
+	protected:
+
+    FEEL_PERIODIC m_Periodic;
+    
+};
+
+
+//
+// INLINES
+//
+
+inline BOOL
+CFeelPeriodic::GetIsCompatibleGUID(GUID &guid)
+{
+	return	IsEqualGUID(guid, GUID_Feel_Sine) ||
+			IsEqualGUID(guid, GUID_Feel_Square) ||
+			IsEqualGUID(guid, GUID_Feel_Triangle) ||
+			IsEqualGUID(guid, GUID_Feel_SawtoothUp) ||
+			IsEqualGUID(guid, GUID_Feel_SawtoothDown);
+}
+
+#endif // !defined(AFX_FEELPERIODIC_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_)
diff --git a/code/win32/FeelIt/FeelProjects.h b/code/win32/FeelIt/FeelProjects.h
new file mode 100644
index 0000000..46768dc
--- /dev/null
+++ b/code/win32/FeelIt/FeelProjects.h
@@ -0,0 +1,302 @@
+/**********************************************************************
+	Copyright (c) 1999 Immersion Corporation
+
+	Permission to use, copy, modify, distribute, and sell this
+	software and its documentation may be granted without fee;
+	interested parties are encouraged to request permission from
+		Immersion Corporation
+		2158 Paragon Drive
+		San Jose, CA 95131
+		408-467-1900
+
+	IMMERSION DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+	INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.
+	IN NO EVENT SHALL IMMERSION BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+	CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+	LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+	NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+	CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+  FILE:		FeelProjects.h
+
+  PURPOSE:	CFeelProject
+               Manages a set of forces in a project.
+               There will be a project for each opened IFR file.
+			CFeelProjects
+			   Manages a set of projects
+
+  STARTED:	2/22/99 by Jeff Mallett
+
+
+  NOTES/REVISIONS:
+     3/2/99 jrm (Jeff Mallett): Force-->Feel renaming
+	 3/15/99 jrm: __declspec(dllimport/dllexport) the whole class
+
+**********************************************************************/
+
+#ifndef	__FEEL_PROJECTS_H
+#define __FEEL_PROJECTS_H
+
+#if _MSC_VER >= 1000
+#pragma once
+#endif // _MSC_VER >= 1000
+
+#ifndef _FFCDLL_
+#define DLLFFC __declspec(dllimport)
+#else
+#define DLLFFC __declspec(dllexport)
+#endif
+
+
+#include "FFCErrors.h"
+#include "FeelBaseTypes.h"
+#include "FeelDevice.h"
+#include "FeelCompoundEffect.h"
+
+class CFeelProjects;
+
+
+//================================================================
+// CFeelProject
+//================================================================
+
+//
+// ------ PUBLIC INTERFACE ------ 
+//
+
+class DLLFFC CFeelProject
+{
+    //
+    // CONSTRUCTOR/DESTRUCTOR
+    //
+
+	public:
+
+	CFeelProject() :
+			m_hProj(NULL), m_pCreatedEffects(NULL),
+			m_pNext(NULL), m_pDevice(NULL)
+		{ }
+
+	~CFeelProject();
+
+	void
+	Close();
+
+
+    //
+    // ATTRIBUTES
+    //
+
+	public:
+
+	CFeelDevice*
+	GetDevice() const
+		{ return m_pDevice; }
+
+	BOOL
+	GetIsOpen() const
+		{ return m_hProj != NULL; }
+
+	CFeelCompoundEffect *
+	GetCreatedEffect(
+		LPCSTR lpszEffectName
+		);
+
+
+    //
+    // OPERATIONS
+    //
+
+	public:
+
+	BOOL
+	Start(
+		LPCSTR lpszEffectName = NULL, 
+		DWORD dwIterations = 1,
+		DWORD dwFlags = 0,
+		CFeelDevice* pDevice = NULL
+		);
+
+	BOOL
+	Stop(
+		LPCSTR lpszEffectName = NULL
+		);
+
+	BOOL
+	OpenFile(
+		LPCSTR lpszFilePath,
+		CFeelDevice *pDevice
+		);
+
+	LoadProjectObjectPointer(
+		BYTE *pMem,
+		CFeelDevice *pDevice
+		);
+
+	CFeelCompoundEffect *
+	CreateEffect(
+		LPCSTR lpszEffectName,
+		CFeelDevice* pDevice = NULL
+		);
+
+	CFeelCompoundEffect *
+	CreateEffectByIndex(
+		int nEffectIndex,
+		CFeelDevice* pDevice = NULL
+		);
+
+	CFeelCompoundEffect *
+	AddEffect(
+		LPCSTR lpszEffectName,
+		GENERIC_EFFECT_PTR pObject
+		);
+
+
+//
+// ------ PRIVATE INTERFACE ------ 
+//
+
+    //
+    // HELPERS
+    //
+
+    protected:
+
+	void
+	set_next(
+		CFeelProject *pNext
+		)
+		{ m_pNext = pNext; }
+
+	CFeelProject *
+	get_next() const
+		{ return m_pNext; }
+
+	void
+	append_effect_to_list(
+		CFeelCompoundEffect* pEffect
+		);
+
+	IFREffect **
+	create_effect_structs(
+		LPCSTR lpszEffectName,
+		int &nEff
+		);
+
+	IFREffect **
+	create_effect_structs_by_index(
+		int nEffectIndex,
+		int &nEff
+		);
+
+	BOOL
+	release_effect_structs(
+		IFREffect **hEffects
+		);
+
+    //
+    // FRIENDS
+    //
+
+	public:
+
+	friend BOOL 
+		CFeelEffect::InitializeFromProject(
+			CFeelProject &project,
+			LPCSTR lpszEffectName,
+			CFeelDevice* pDevice /* = NULL */
+		);
+
+	friend class CFeelProjects;
+
+    //
+    // INTERNAL DATA
+    //
+
+	protected:
+
+	HIFRPROJECT m_hProj;
+	CFeelCompoundEffect* m_pCreatedEffects;
+	CFeelDevice* m_pDevice;
+
+	private:
+
+	CFeelProject* m_pNext;
+};
+
+
+
+//================================================================
+// CFeelProjects
+//================================================================
+
+//
+// ------ PUBLIC INTERFACE ------ 
+//
+
+class DLLFFC CFeelProjects
+{
+    //
+    // CONSTRUCTOR/DESTRUCTOR
+    //
+
+	public:
+
+	CFeelProjects() : m_pProjects(NULL) { }
+
+	~CFeelProjects();
+
+	void
+	Close();
+
+
+    //
+    // ATTRIBUTES
+    //
+
+	public:
+
+	CFeelProject *
+	GetProject(
+		int index = 0
+		);
+
+
+    //
+    // OPERATIONS
+    //
+
+	public:
+
+	BOOL
+	Stop();
+
+	long
+	OpenFile(
+		LPCSTR lpszFilePath,
+		CFeelDevice *pDevice
+		);
+
+
+//
+// ------ PRIVATE INTERFACE ------ 
+//
+
+    //
+    // HELPERS
+    //
+
+    protected:
+
+
+    //
+    // INTERNAL DATA
+    //
+	protected:
+
+	CFeelProject *m_pProjects;
+};
+
+
+
+#endif // __FEEL_PROJECTS_H
diff --git a/code/win32/FeelIt/FeelRamp.h b/code/win32/FeelIt/FeelRamp.h
new file mode 100644
index 0000000..8fd98a4
--- /dev/null
+++ b/code/win32/FeelIt/FeelRamp.h
@@ -0,0 +1,194 @@
+/**********************************************************************
+	Copyright (c) 1997 Immersion Corporation
+
+	Permission to use, copy, modify, distribute, and sell this
+	software and its documentation may be granted without fee;
+	interested parties are encouraged to request permission from
+		Immersion Corporation
+		2158 Paragon Drive
+		San Jose, CA 95131
+		408-467-1900
+
+	IMMERSION DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+	INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.
+	IN NO EVENT SHALL IMMERSION BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+	CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+	LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+	NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+	CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+  FILE:		FeelRamp.h
+
+  PURPOSE:	Base Ramp Force Class for Feelit API Foundation Classes
+
+  STARTED:	12/11/97
+
+  NOTES/REVISIONS:
+     3/2/99 jrm (Jeff Mallett): Force-->Feel renaming
+	 3/2/99 jrm: Added GetIsCompatibleGUID
+	 3/15/99 jrm: __declspec(dllimport/dllexport) the whole class
+
+**********************************************************************/
+
+
+#if !defined(AFX_FEELRAMP_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_)
+#define AFX_FEELRAMP_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_
+
+#if _MSC_VER >= 1000
+#pragma once
+#endif // _MSC_VER >= 1000
+
+#ifndef _FFCDLL_
+#define DLLFFC __declspec(dllimport)
+#else
+#define DLLFFC __declspec(dllexport)
+#endif
+
+#include "FeelBaseTypes.h"
+#include "FeelEffect.h"
+
+
+
+//================================================================
+// Constants
+//================================================================
+
+#define     FEEL_RAMP_DEFAULT_DURATION			1000 // Milliseconds
+#define     FEEL_RAMP_DEFAULT_MAGNITUDE_START	0
+#define     FEEL_RAMP_DEFAULT_MAGNITUDE_END		10000
+
+//
+// FORCE --> FEEL Wrappers
+//
+#define     FORCE_RAMP_DEFAULT_DURATION			FEEL_RAMP_DEFAULT_DURATION
+#define     FORCE_RAMP_DEFAULT_MAGNITUDE_START	FEEL_RAMP_DEFAULT_MAGNITUDE_START
+#define     FORCE_RAMP_DEFAULT_MAGNITUDE_END	FEEL_RAMP_DEFAULT_MAGNITUDE_END
+
+
+//================================================================
+// CFeelRamp
+//================================================================
+
+//
+// ------ PUBLIC INTERFACE ------ 
+//
+        
+class DLLFFC CFeelRamp : public CFeelEffect
+{
+    //
+    // CONSTRUCTOR/DESTRUCTOR
+    //
+
+    public:
+    
+    // Constructor
+	CFeelRamp();
+
+	// Destructor
+	virtual
+	~CFeelRamp();
+
+
+    //
+    // ATTRIBUTES
+    //
+
+    public:
+
+	virtual BOOL
+	GetIsCompatibleGUID(
+		GUID &guid
+		);
+
+    BOOL
+    ChangeParameters( 
+        LONG lDirectionX,
+        LONG lDirectionY,
+        DWORD dwDuration = FEEL_EFFECT_DONT_CHANGE,
+        LONG lMagStart = FEEL_EFFECT_DONT_CHANGE,
+        LONG lMagEnd = FEEL_EFFECT_DONT_CHANGE,
+        LPFEEL_ENVELOPE pEnvelope = (LPFEEL_ENVELOPE) FEEL_EFFECT_DONT_CHANGE_PTR
+        );
+
+    BOOL
+    ChangeParametersPolar( 
+        LONG lAngle,
+        DWORD dwDuration = FEEL_EFFECT_DONT_CHANGE,
+        LONG lMagStart = FEEL_EFFECT_DONT_CHANGE,
+        LONG lMagEnd = FEEL_EFFECT_DONT_CHANGE,
+        LPFEEL_ENVELOPE pEnvelope = (LPFEEL_ENVELOPE) FEEL_EFFECT_DONT_CHANGE_PTR
+        );
+
+
+    //
+    // OPERATIONS
+    //
+
+    public:
+
+    virtual BOOL
+    Initialize( 
+        CFeelDevice* pDevice, 
+        LONG lDirectionX = FEEL_EFFECT_DEFAULT_DIRECTION_X,
+        LONG lDirectionY = FEEL_EFFECT_DEFAULT_DIRECTION_Y,
+        DWORD dwDuration = FEEL_RAMP_DEFAULT_DURATION,
+        LONG lMagStart = FEEL_RAMP_DEFAULT_MAGNITUDE_START,
+        LONG lMagEnd = FEEL_RAMP_DEFAULT_MAGNITUDE_END,
+        LPFEEL_ENVELOPE pEnvelope = NULL
+        );
+
+    virtual BOOL
+    InitializePolar( 
+        CFeelDevice* pDevice, 
+        LONG lAngle = FEEL_EFFECT_DEFAULT_ANGLE,
+        DWORD dwDuration = FEEL_RAMP_DEFAULT_DURATION,
+        LONG lMagStart = FEEL_RAMP_DEFAULT_MAGNITUDE_START,
+        LONG lMagEnd = FEEL_RAMP_DEFAULT_MAGNITUDE_END,
+        LPFEEL_ENVELOPE pEnvelope = NULL
+        );
+
+
+//
+// ------ PRIVATE INTERFACE ------ 
+//
+        
+    //
+    // HELPERS
+    //
+
+    protected:
+
+    BOOL
+    set_parameters( 
+        DWORD dwfCoordinates,
+        LONG lDirection0,
+        LONG lDirection1,
+        DWORD dwDuration,
+        LONG lMagStart,
+        LONG lMagEnd,
+        LPFEEL_ENVELOPE pEnvelope
+        );
+
+
+    //
+    // INTERNAL DATA
+    //
+
+    protected:
+
+    FEEL_RAMPFORCE m_RampForce;
+    
+};
+
+
+//
+// INLINES
+//
+
+inline BOOL
+CFeelRamp::GetIsCompatibleGUID(GUID &guid)
+{
+	return IsEqualGUID(guid, GUID_Feel_RampForce);
+}
+
+#endif // !defined(AFX_FEELRAMP_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_)
diff --git a/code/win32/FeelIt/FeelSpring.h b/code/win32/FeelIt/FeelSpring.h
new file mode 100644
index 0000000..617ca75
--- /dev/null
+++ b/code/win32/FeelIt/FeelSpring.h
@@ -0,0 +1,191 @@
+/**********************************************************************
+	Copyright (c) 1997 Immersion Corporation
+
+	Permission to use, copy, modify, distribute, and sell this
+	software and its documentation may be granted without fee;
+	interested parties are encouraged to request permission from
+		Immersion Corporation
+		2158 Paragon Drive
+		San Jose, CA 95131
+		408-467-1900
+
+	IMMERSION DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+	INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.
+	IN NO EVENT SHALL IMMERSION BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+	CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+	LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+	NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+	CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+  FILE:		FeelSpring.h
+
+  PURPOSE:	Feelit API Spring Class
+
+  STARTED:	10/10/97
+
+  NOTES/REVISIONS:
+     3/2/99 jrm (Jeff Mallett): Force-->Feel renaming
+	 3/2/99 jrm: Added GetIsCompatibleGUID
+	 3/15/99 jrm: __declspec(dllimport/dllexport) the whole class
+
+**********************************************************************/
+
+
+#if !defined(AFX_FEELSPRING_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_)
+#define AFX_FEELSPRING_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_
+
+#if _MSC_VER >= 1000
+#pragma once
+#endif // _MSC_VER >= 1000
+
+#ifndef _FFCDLL_
+#define DLLFFC __declspec(dllimport)
+#else
+#define DLLFFC __declspec(dllexport)
+#endif
+
+#include <windows.h>
+#include "FeelCondition.h"
+
+
+//================================================================
+// Constants
+//================================================================
+
+#define     FEEL_SPRING_DEFAULT_STIFFNESS      2500
+#define     FEEL_SPRING_DEFAULT_SATURATION     10000
+#define     FEEL_SPRING_DEFAULT_DEADBAND       100
+#define     FEEL_SPRING_DEFAULT_CENTER_POINT   FEEL_EFFECT_MOUSE_POS_AT_START
+#define     FEEL_SPRING_DEFAULT_DIRECTION_X    1
+#define     FEEL_SPRING_DEFAULT_DIRECTION_Y    0
+#define     FEEL_SPRING_DEFAULT_ANGLE          0
+
+//
+// FORCE --> FEEL Wrappers
+//
+#define     FORCE_SPRING_DEFAULT_STIFFNESS      FEEL_SPRING_DEFAULT_STIFFNESS
+#define     FORCE_SPRING_DEFAULT_SATURATION     FEEL_SPRING_DEFAULT_SATURATION
+#define     FORCE_SPRING_DEFAULT_DEADBAND       FEEL_SPRING_DEFAULT_DEADBAND
+#define     FORCE_SPRING_DEFAULT_CENTER_POINT   FEEL_SPRING_DEFAULT_CENTER_POINT
+#define     FORCE_SPRING_DEFAULT_DIRECTION_X    FEEL_SPRING_DEFAULT_DIRECTION_X
+#define     FORCE_SPRING_DEFAULT_DIRECTION_Y    FEEL_SPRING_DEFAULT_DIRECTION_Y
+#define     FORCE_SPRING_DEFAULT_ANGLE          FEEL_SPRING_DEFAULT_ANGLE
+
+
+//================================================================
+// CFeelSpring
+//================================================================
+
+//
+// ------ PUBLIC INTERFACE ------ 
+//
+        
+class DLLFFC CFeelSpring : public CFeelCondition
+{
+    //
+    // CONSTRUCTOR/DESTRUCTOR
+    //
+
+    public:
+    
+    // Constructor
+	CFeelSpring();
+
+	// Destructor
+	virtual
+	~CFeelSpring();
+
+
+    //
+    // ATTRIBUTES
+    //
+
+    public:
+
+	virtual BOOL
+	GetIsCompatibleGUID(
+		GUID &guid
+		);
+
+    BOOL
+    ChangeParameters( 
+        POINT pntCenter,
+        LONG lStiffness = FEEL_EFFECT_DONT_CHANGE,
+        DWORD dwSaturation = FEEL_EFFECT_DONT_CHANGE,
+        DWORD dwDeadband = FEEL_EFFECT_DONT_CHANGE,
+        LONG lDirectionX = FEEL_EFFECT_DONT_CHANGE,
+        LONG lDirectionY = FEEL_EFFECT_DONT_CHANGE
+        );
+
+    BOOL
+    ChangeParametersPolar( 
+        POINT pntCenter,
+        LONG lStiffness,
+        DWORD dwSaturation,
+        DWORD dwDeadband,
+        LONG lAngle
+        );
+
+    //
+    // OPERATIONS
+    //
+
+    public:
+
+    virtual BOOL 
+    Initialize( 
+        CFeelDevice* pDevice, 
+        LONG lStiffness = FEEL_SPRING_DEFAULT_STIFFNESS,
+        DWORD dwSaturation = FEEL_SPRING_DEFAULT_SATURATION,
+        DWORD dwDeadband = FEEL_SPRING_DEFAULT_DEADBAND,
+        DWORD dwfAxis = FEEL_EFFECT_AXIS_BOTH, 
+        POINT pntCenter = FEEL_SPRING_DEFAULT_CENTER_POINT,
+        LONG lDirectionX = FEEL_SPRING_DEFAULT_DIRECTION_X,
+        LONG lDirectionY = FEEL_SPRING_DEFAULT_DIRECTION_Y,
+		BOOL bUseDeviceCoordinates = FALSE
+		);
+
+    virtual BOOL 
+    InitializePolar( 
+        CFeelDevice* pDevice, 
+        LONG lStiffness,
+        DWORD dwSaturation,
+        DWORD dwDeadband,
+        POINT pntCenter,
+        LONG lAngle,
+        BOOL bUseDeviceCoordinates = FALSE
+		);
+
+
+//
+// ------ PRIVATE INTERFACE ------ 
+//
+            
+    //
+    // HELPERS
+    //
+
+    protected:
+
+    //
+    // INTERNAL DATA
+    //
+    
+    protected:
+
+};
+
+
+
+//
+// INLINES
+//
+
+inline BOOL
+CFeelSpring::GetIsCompatibleGUID(GUID &guid)
+{
+	return IsEqualGUID(guid, GUID_Feel_Spring);
+}
+
+#endif // !defined(AFX_FEELSPRING_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_)
+
diff --git a/code/win32/FeelIt/FeelTexture.h b/code/win32/FeelIt/FeelTexture.h
new file mode 100644
index 0000000..b5a72c3
--- /dev/null
+++ b/code/win32/FeelIt/FeelTexture.h
@@ -0,0 +1,287 @@
+/**********************************************************************
+	Copyright (c) 1997 Immersion Corporation
+
+	Permission to use, copy, modify, distribute, and sell this
+	software and its documentation may be granted without fee;
+	interested parties are encouraged to request permission from
+		Immersion Corporation
+		2158 Paragon Drive
+		San Jose, CA 95131
+		408-467-1900
+
+	IMMERSION DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+	INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.
+	IN NO EVENT SHALL IMMERSION BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+	CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+	LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+	NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+	CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+  FILE:		FeelTexture.h
+
+  PURPOSE:	Texture Class for Feelit API Foundation Classes
+
+  STARTED:	2/27/98
+
+  NOTES/REVISIONS:
+     3/2/99 jrm (Jeff Mallett): Force-->Feel renaming
+	 3/2/99 jrm: Added GetIsCompatibleGUID
+	 3/15/99 jrm: __declspec(dllimport/dllexport) the whole class
+
+**********************************************************************/
+
+
+#if !defined(AFX_FeelTexture_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_)
+#define AFX_FeelTexture_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_
+
+#if _MSC_VER >= 1000
+#pragma once
+#endif // _MSC_VER >= 1000
+
+#ifndef _FFCDLL_
+#define DLLFFC __declspec(dllimport)
+#else
+#define DLLFFC __declspec(dllexport)
+#endif
+
+#include <windows.h>
+#include "FeelBaseTypes.h"
+#include "FeelEffect.h"
+
+
+
+//================================================================
+// Constants
+//================================================================
+
+const POINT FEEL_TEXTURE_PT_NULL = { 0, 0 };
+const POINT FEEL_TEXTURE_DEFAULT_OFFSET_POINT = { 0, 0};
+
+#define     FEEL_TEXTURE_DEFAULT_MAGNITUDE        5000
+#define     FEEL_TEXTURE_DEFAULT_WIDTH		       10
+#define     FEEL_TEXTURE_DEFAULT_SPACING		   20
+
+//
+// FORCE --> FEEL Wrappers
+//
+#define     FORCE_TEXTURE_PT_NULL				FEEL_TEXTURE_PT_NULL
+#define     FORCE_TEXTURE_DEFAULT_OFFSET_POINT	FEEL_TEXTURE_DEFAULT_OFFSET_POINT
+
+#define     FORCE_TEXTURE_DEFAULT_MAGNITUDE		FEEL_TEXTURE_DEFAULT_MAGNITUDE
+#define     FORCE_TEXTURE_DEFAULT_WIDTH			FEEL_TEXTURE_DEFAULT_WIDTH
+#define     FORCE_TEXTURE_DEFAULT_SPACING		FEEL_TEXTURE_DEFAULT_SPACING
+
+
+//================================================================
+// CFeelTexture
+//================================================================
+
+//
+// ------ PUBLIC INTERFACE ------ 
+//
+        
+class DLLFFC CFeelTexture : public CFeelEffect
+{
+    //
+    // CONSTRUCTOR/DESTRUCTOR
+    //
+
+    public:
+    
+    // Constructor
+	CFeelTexture();
+
+	// Destructor
+	virtual
+	~CFeelTexture();
+
+
+    //
+    // ATTRIBUTES
+    //
+
+    public:
+
+	virtual BOOL
+	GetIsCompatibleGUID(
+		GUID &guid
+		);
+
+    // Use this form for single-axis and dual-axis effects
+    BOOL
+    ChangeTextureParams( 
+        LPCFEELIT_TEXTURE pTextureX,
+        LPCFEELIT_TEXTURE pTextureY
+        );
+
+    // Use this form for directional effects
+    BOOL
+    ChangeTextureParams( 
+        LPCFEELIT_TEXTURE pTexture,
+        LONG lDirectionX,
+        LONG lDirectionY
+        );
+
+    // Use this form for directional effects
+	BOOL
+    ChangeTextureParamsPolar( 
+        LPCFEELIT_TEXTURE pTexture,
+        LONG lAngle
+        );
+
+    // Use this form for single-axis, dual-axis symetrical, or directional effects
+    BOOL
+    ChangeTextureParams( 
+        LONG lPosBumpMag = FEEL_EFFECT_DONT_CHANGE,
+        DWORD dwPosBumpWidth = FEEL_EFFECT_DONT_CHANGE,
+        DWORD dwPosBumpSpacing = FEEL_EFFECT_DONT_CHANGE,
+        LONG lNegBumpMag = FEEL_EFFECT_DONT_CHANGE,
+        DWORD dwNegBumpWidth = FEEL_EFFECT_DONT_CHANGE,
+        DWORD dwNegBumpSpacing = FEEL_EFFECT_DONT_CHANGE,
+        POINT pntOffset = FEEL_EFFECT_DONT_CHANGE_POINT,
+        LONG lDirectionX = FEEL_EFFECT_DONT_CHANGE,
+        LONG lDirectionY = FEEL_EFFECT_DONT_CHANGE
+        );
+
+    // Use this form for single-axis, dual-axis symetrical, or directional effects
+    BOOL
+    ChangeTextureParamsPolar( 
+        LONG lPosBumpMag = FEEL_EFFECT_DONT_CHANGE,
+        DWORD dwPosBumpWidth = FEEL_EFFECT_DONT_CHANGE,
+        DWORD dwPosBumpSpacing = FEEL_EFFECT_DONT_CHANGE,
+        LONG lNegBumpMag = FEEL_EFFECT_DONT_CHANGE,
+        DWORD dwNegBumpWidth = FEEL_EFFECT_DONT_CHANGE,
+        DWORD dwNegBumpSpacing = FEEL_EFFECT_DONT_CHANGE,
+        POINT pntOffset = FEEL_EFFECT_DONT_CHANGE_POINT,
+        LONG lAngle = FEEL_EFFECT_DONT_CHANGE
+        );
+
+    BOOL
+    SetOffset( 
+        POINT pntOffset 
+        );
+
+    //
+    // OPERATIONS
+    //
+
+    public:
+
+    // Use this form for single-axis and dual-axis effects
+    BOOL 
+    InitTexture( 
+        CFeelDevice* pDevice, 
+        LPCFEELIT_TEXTURE pTextureX,
+        LPCFEELIT_TEXTURE pTextureY
+        );
+
+
+    // Use this form for directional effects
+    BOOL 
+    InitTexture( 
+        CFeelDevice* pDevice, 
+        LPCFEELIT_TEXTURE pTexture,
+        LONG lDirectionX,
+        LONG lDirectionY
+        );
+
+
+    // Use this form for directional effects
+    BOOL 
+    InitTexturePolar( 
+        CFeelDevice* pDevice, 
+        LPCFEELIT_TEXTURE pTexture,
+        LONG lAngle
+        );
+
+
+    // Use this form for single-axis, dual-axis symetrical, or directional effects
+    BOOL 
+    InitTexture( 
+        CFeelDevice* pDevice, 
+        LONG lPosBumpMag = FEEL_TEXTURE_DEFAULT_MAGNITUDE,
+        DWORD dwPosBumpWidth = FEEL_TEXTURE_DEFAULT_WIDTH,
+        DWORD dwPosBumpSpacing = FEEL_TEXTURE_DEFAULT_SPACING,
+        LONG lNegBumpMag = FEEL_TEXTURE_DEFAULT_MAGNITUDE,
+        DWORD dwNegBumpWidth = FEEL_TEXTURE_DEFAULT_WIDTH,
+        DWORD dwNegBumpSpacing = FEEL_TEXTURE_DEFAULT_SPACING,
+        DWORD dwfAxis = FEEL_EFFECT_AXIS_BOTH,
+        POINT pntOffset = FEEL_TEXTURE_DEFAULT_OFFSET_POINT,
+        LONG lDirectionX = FEEL_EFFECT_DEFAULT_DIRECTION_X,
+        LONG lDirectionY = FEEL_EFFECT_DEFAULT_DIRECTION_Y
+        );
+
+    // Use this form for directional effects
+    BOOL 
+    InitTexturePolar( 
+        CFeelDevice* pDevice, 
+        LONG lPosBumpMag = FEEL_TEXTURE_DEFAULT_MAGNITUDE,
+        DWORD dwPosBumpWidth = FEEL_TEXTURE_DEFAULT_WIDTH,
+        DWORD dwPosBumpSpacing = FEEL_TEXTURE_DEFAULT_SPACING,
+        LONG lNegBumpMag = FEEL_TEXTURE_DEFAULT_MAGNITUDE,
+        DWORD dwNegBumpWidth = FEEL_TEXTURE_DEFAULT_WIDTH,
+        DWORD dwNegBumpSpacing = FEEL_TEXTURE_DEFAULT_SPACING,
+        POINT pntOffset = FEEL_TEXTURE_DEFAULT_OFFSET_POINT,
+        LONG lAngle = FEEL_EFFECT_DEFAULT_ANGLE
+        );
+
+
+//
+// ------ PRIVATE INTERFACE ------ 
+//
+                
+    //
+    // HELPERS
+    //
+
+    protected:
+
+    BOOL
+    set_parameters( 
+        DWORD dwfAxis,
+        DWORD dwfCoordinates,
+        LONG lDirection0,
+        LONG lDirection1,
+        LPCFEELIT_TEXTURE pTextureX,
+        LPCFEELIT_TEXTURE pTextureY
+        );
+
+    BOOL
+    set_parameters( 
+        DWORD dwfAxis,
+        DWORD dwfCoordinates,
+        LONG lDirection0,
+        LONG lDirection1,
+        LONG lPosBumpMag,
+        DWORD dwPosBumpWidth,
+        DWORD dwPosBumpSpacing,
+        LONG lNegBumpMag,
+        DWORD dwNegBumpWidth,
+        DWORD dwNegBumpSpacing,
+        POINT pntOffset
+        );
+
+    //
+    // INTERNAL DATA
+    //
+
+    FEEL_TEXTURE m_aTexture[2];
+    DWORD m_dwfAxis;
+    
+    protected:
+
+};
+
+
+
+//
+// INLINES
+//
+
+inline BOOL
+CFeelTexture::GetIsCompatibleGUID(GUID &guid)
+{
+	return IsEqualGUID(guid, GUID_Feel_Texture);
+}
+
+#endif // !defined(AFX_FeelTexture_H__135B88C4_4175_11D1_B049_0020AF30269A__INCLUDED_)
diff --git a/code/win32/FeelIt/FeelitAPI.h b/code/win32/FeelIt/FeelitAPI.h
new file mode 100644
index 0000000..d88fc4e
--- /dev/null
+++ b/code/win32/FeelIt/FeelitAPI.h
@@ -0,0 +1,1252 @@
+/**********************************************************************
+	Copyright (c) 1997, 1998, 1999 Immersion Corporation
+
+	Permission to use, copy, modify, distribute, and sell this
+	software and its documentation may be granted without fee;
+	interested parties are encouraged to request permission from
+		Immersion Corporation
+		2158 Paragon Drive
+		San Jose, CA 95131
+		408-467-1900
+
+	IMMERSION DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+	INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.
+	IN NO EVENT SHALL IMMERSION BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+	CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+	LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+	NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+	CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+  FILE:		FeelitAPI.h
+
+  PURPOSE:	Feelit API
+
+  STARTED:	09/08/97
+
+  NOTES/REVISIONS:
+
+**********************************************************************/
+
+#ifndef __FEELITAPI_INCLUDED__
+#define __FEELITAPI_INCLUDED__
+
+#ifndef FEELIT_VERSION
+#define FEELIT_VERSION         0x0103
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if (FEELIT_VERSION >= 0x0101)
+#undef IS_VXD
+#endif // FEELIT_VERSION
+
+#ifndef IS_VXD
+
+#ifdef _WIN32
+#define COM_NO_WINDOWS_H
+#include <objbase.h>
+#endif
+
+#endif // IS_VXD not defined
+
+
+#ifndef IS_VXD
+
+/****************************************************************************
+ *
+ *      Class IDs
+ *
+ ****************************************************************************/
+
+DEFINE_GUID(CLSID_Feelit,		0x5959df60,0x2911,0x11d1,0xb0,0x49,0x00,0x20,0xaf,0x30,0x26,0x9a);
+DEFINE_GUID(CLSID_FeelitDevice,	0x5959df61,0x2911,0x11d1,0xb0,0x49,0x00,0x20,0xaf,0x30,0x26,0x9a);
+
+
+/****************************************************************************
+ *
+ *      Interfaces
+ *
+ ****************************************************************************/
+
+DEFINE_GUID(IID_IFeelit,		0x5959df62,0x2911,0x11d1,0xb0,0x49,0x00,0x20,0xaf,0x30,0x26,0x9a);
+DEFINE_GUID(IID_IFeelitDevice,	0x5959df63,0x2911,0x11d1,0xb0,0x49,0x00,0x20,0xaf,0x30,0x26,0x9a);
+DEFINE_GUID(IID_IFeelitEffect,	0x5959df64,0x2911,0x11d1,0xb0,0x49,0x00,0x20,0xaf,0x30,0x26,0x9a);
+DEFINE_GUID(IID_IFeelitConfig,  0x900c39e0,0xcc5c,0x11d2,0x8c,0x5d,0x00,0x10,0x5a,0x17,0x8a,0xd1);
+
+
+/****************************************************************************
+ *
+ *      Predefined object types
+ *
+ ****************************************************************************/
+
+DEFINE_GUID(GUID_Feelit_XAxis,   0x5959df65,0x2911,0x11d1,0xb0,0x49,0x00,0x20,0xaf,0x30,0x26,0x9a);
+DEFINE_GUID(GUID_Feelit_YAxis,   0x5959df66,0x2911,0x11d1,0xb0,0x49,0x00,0x20,0xaf,0x30,0x26,0x9a);
+DEFINE_GUID(GUID_Feelit_ZAxis,   0x5959df67,0x2911,0x11d1,0xb0,0x49,0x00,0x20,0xaf,0x30,0x26,0x9a);
+DEFINE_GUID(GUID_Feelit_RxAxis,  0x5959df68,0x2911,0x11d1,0xb0,0x49,0x00,0x20,0xaf,0x30,0x26,0x9a);
+DEFINE_GUID(GUID_Feelit_RyAxis,  0x5959df69,0x2911,0x11d1,0xb0,0x49,0x00,0x20,0xaf,0x30,0x26,0x9a);
+DEFINE_GUID(GUID_Feelit_RzAxis,  0x5959df6a,0x2911,0x11d1,0xb0,0x49,0x00,0x20,0xaf,0x30,0x26,0x9a);
+DEFINE_GUID(GUID_Feelit_Slider,  0x5959df6b,0x2911,0x11d1,0xb0,0x49,0x00,0x20,0xaf,0x30,0x26,0x9a);
+
+DEFINE_GUID(GUID_Feelit_Button,  0x5959df6c,0x2911,0x11d1,0xb0,0x49,0x00,0x20,0xaf,0x30,0x26,0x9a);
+DEFINE_GUID(GUID_Feelit_Key,     0x5959df6d,0x2911,0x11d1,0xb0,0x49,0x00,0x20,0xaf,0x30,0x26,0x9a);
+
+DEFINE_GUID(GUID_Feelit_POV,     0x5959df6e,0x2911,0x11d1,0xb0,0x49,0x00,0x20,0xaf,0x30,0x26,0x9a);
+
+DEFINE_GUID(GUID_Feelit_Unknown, 0x5959df6f,0x2911,0x11d1,0xb0,0x49,0x00,0x20,0xaf,0x30,0x26,0x9a);
+
+
+/****************************************************************************
+ *
+ *      Predefined Product GUIDs
+ *
+ ****************************************************************************/
+
+DEFINE_GUID(GUID_Feelit_Mouse,   0x99bb5400,0x2b94,0x11d1,0xb0,0x49,0x00,0x20,0xaf,0x30,0x26,0x9a);
+
+/****************************************************************************
+ *
+ *      Force feedback effects
+ *
+ ****************************************************************************/
+
+
+/* Constant Force */
+DEFINE_GUID(GUID_Feelit_ConstantForce,0x5959df71,0x2911,0x11d1,0xb0,0x49,0x00,0x20,0xaf,0x30,0x26,0x9a);
+
+/* Ramp Force */
+DEFINE_GUID(GUID_Feelit_RampForce,	0x5959df72,0x2911,0x11d1,0xb0,0x49,0x00,0x20,0xaf,0x30,0x26,0x9a);
+
+/* Periodic Effects */
+DEFINE_GUID(GUID_Feelit_Square,      0x5959df73,0x2911,0x11d1,0xb0,0x49,0x00,0x20,0xaf,0x30,0x26,0x9a);
+DEFINE_GUID(GUID_Feelit_Sine,        0x5959df74,0x2911,0x11d1,0xb0,0x49,0x00,0x20,0xaf,0x30,0x26,0x9a);
+DEFINE_GUID(GUID_Feelit_Triangle,    0x5959df75,0x2911,0x11d1,0xb0,0x49,0x00,0x20,0xaf,0x30,0x26,0x9a);
+DEFINE_GUID(GUID_Feelit_SawtoothUp,	0x5959df76,0x2911,0x11d1,0xb0,0x49,0x00,0x20,0xaf,0x30,0x26,0x9a);
+DEFINE_GUID(GUID_Feelit_SawtoothDown,0x5959df77,0x2911,0x11d1,0xb0,0x49,0x00,0x20,0xaf,0x30,0x26,0x9a);
+
+
+/* Conditions */
+DEFINE_GUID(GUID_Feelit_Spring,      0x5959df78,0x2911,0x11d1,0xb0,0x49,0x00,0x20,0xaf,0x30,0x26,0x9a);
+DEFINE_GUID(GUID_Feelit_DeviceSpring,0x5959df83,0x2911,0x11d1,0xb0,0x49,0x00,0x20,0xaf,0x30,0x26,0x9a);
+DEFINE_GUID(GUID_Feelit_Damper,      0x5959df79,0x2911,0x11d1,0xb0,0x49,0x00,0x20,0xaf,0x30,0x26,0x9a);
+DEFINE_GUID(GUID_Feelit_Inertia,     0x5959df7a,0x2911,0x11d1,0xb0,0x49,0x00,0x20,0xaf,0x30,0x26,0x9a);
+DEFINE_GUID(GUID_Feelit_Friction,    0x5959df7b,0x2911,0x11d1,0xb0,0x49,0x00,0x20,0xaf,0x30,0x26,0x9a);
+DEFINE_GUID(GUID_Feelit_Texture,		0x5959df7c,0x2911,0x11d1,0xb0,0x49,0x00,0x20,0xaf,0x30,0x26,0x9a);
+DEFINE_GUID(GUID_Feelit_Grid,		0x5959df7d,0x2911,0x11d1,0xb0,0x49,0x00,0x20,0xaf,0x30,0x26,0x9a);
+
+/* Enclosures */
+DEFINE_GUID(GUID_Feelit_Enclosure,	0x5959df7f,0x2911,0x11d1,0xb0,0x49,0x00,0x20,0xaf,0x30,0x26,0x9a);
+DEFINE_GUID(GUID_Feelit_Ellipse,	    0x5959df82,0x2911,0x11d1,0xb0,0x49,0x00,0x20,0xaf,0x30,0x26,0x9a);
+
+/* Custom Force */
+DEFINE_GUID(GUID_Feelit_CustomForce, 0x5959df7e,0x2911,0x11d1,0xb0,0x49,0x00,0x20,0xaf,0x30,0x26,0x9a);
+
+#endif // IS_VXD not defined
+
+/****************************************************************************
+ *
+ *      Interfaces and Structures...
+ *
+ ****************************************************************************/
+
+
+/****************************************************************************
+ *
+ *      IFeelitEffect
+ *
+ ****************************************************************************/
+
+#define FEELIT_FEFFECTTYPE_ALL					0x00000000
+
+#define FEELIT_FEFFECTTYPE_CONSTANTFORCE		0x00000001
+#define FEELIT_FEFFECTTYPE_RAMPFORCE			0x00000002
+#define FEELIT_FEFFECTTYPE_PERIODIC				0x00000003
+#define FEELIT_FEFFECTTYPE_CONDITION			0x00000004
+#define FEELIT_FEFFECTTYPE_ENCLOSURE			0x00000005
+#define FEELIT_FEFFECTTYPE_ELLIPSE				0x00000006
+#define FEELIT_FEFFECTTYPE_TEXTURE				0x00000007
+#define FEELIT_FEFFECTTYPE_CUSTOMFORCE			0x000000F0
+#define FEELIT_FEFFECTTYPE_HARDWARE				0x000000FF
+
+#define FEELIT_FEFFECTTYPE_FFATTACK				0x00000200
+#define FEELIT_FEFFECTTYPE_FFFADE				0x00000400
+#define FEELIT_FEFFECTTYPE_SATURATION			0x00000800
+#define FEELIT_FEFFECTTYPE_POSNEGCOEFFICIENTS	0x00001000
+#define FEELIT_FEFFECTTYPE_POSNEGSATURATION		0x00002000
+#define FEELIT_FEFFECTTYPE_DEADBAND				0x00004000
+
+#define FEELIT_EFFECTTYPE_GETTYPE(n)             LOBYTE(n)
+#define FEELIT_EFFECTTYPE_GETFLAGS(n)            ( n & 0xFFFFFF00 )
+
+#define FEELIT_DEGREES                  100
+#define FEELIT_FFNOMINALMAX             10000
+#define FEELIT_SECONDS                  1000000
+
+typedef struct FEELIT_CONSTANTFORCE {
+    LONG  lMagnitude;	/* Magnitude of the effect, in the range -10000 to 10000 */
+} FEELIT_CONSTANTFORCE, *LPFEELIT_CONSTANTFORCE;
+typedef const FEELIT_CONSTANTFORCE *LPCFEELIT_CONSTANTFORCE;
+
+typedef struct FEELIT_RAMPFORCE {
+    LONG  lStart;	/* Magnitude at start of effect. Range -10000 to 10000 */
+    LONG  lEnd;		/* Magnitude at end of effect. Range -10000 to 10000 */
+} FEELIT_RAMPFORCE, *LPFEELIT_RAMPFORCE;
+typedef const FEELIT_RAMPFORCE *LPCFEELIT_RAMPFORCE;
+
+typedef struct FEELIT_PERIODIC {
+    DWORD dwMagnitude;  /* Magnitude of the effect, in the range 0 to 10000 */
+    LONG  lOffset;		/* Force will be gen'd in range lOffset - dwMagnitude to lOffset + dwMagnitude */
+    DWORD dwPhase;		/* Position in cycle at wich playback begins. Range 0 - 35,999 */
+    DWORD dwPeriod;		/* Period (length of one cycle) of the effect in microseconds */
+} FEELIT_PERIODIC, *LPFEELIT_PERIODIC;
+typedef const FEELIT_PERIODIC *LPCFEELIT_PERIODIC;
+
+typedef struct FEELIT_CONDITION {
+    LONG  lCenter;				/* Center-point in screen coords. Axis depends on that in FEELIT_EFFECT */
+    LONG  lPositiveCoefficient;	/* Coef. on pos. side of the offset. Range -10000 to 10000 */
+    LONG  lNegativeCoefficient;	/* Coef. on neg. side of the offset. Range -10000 to 10000 */
+    DWORD dwPositiveSaturation; /* Max force output on pos. side of offset. Range 0 to 10000 */
+    DWORD dwNegativeSaturation;	/* Max force output on neg. side of offset. Range 0 to 10000 */
+    LONG  lDeadBand;			/* Region around lOffset where condition is not active. Range 0 to 10000 */
+} FEELIT_CONDITION, *LPFEELIT_CONDITION;
+typedef const FEELIT_CONDITION *LPCFEELIT_CONDITION;
+
+typedef struct FEELIT_TEXTURE {
+    DWORD dwSize;			    /* sizeof(FEELIT_TEXTURE)   */
+    LONG lOffset;				/* Offset in screen coords of first texture from left or top edge */
+    LONG lPosBumpMag;			/* Magnitude of bumps felt when mouse travels in positive direction */
+    DWORD dwPosBumpWidth;		/* Width of bumps felt when mouse travels in positive direction */
+    DWORD dwPosBumpSpacing;		/* Center-to-Center spacing of bumps felt when mouse travels in positive direction */
+    LONG lNegBumpMag;	        /* Magnitude of bumps felt when mouse travels in negative direction */
+    DWORD dwNegBumpWidth;		/* Width of bumps felt when mouse travels in negative direction */
+    DWORD dwNegBumpSpacing;		/* Center-to-Center spacing of bumps felt when mouse travels in negative direction */
+} FEELIT_TEXTURE, *LPFEELIT_TEXTURE;
+typedef const FEELIT_TEXTURE *LPCFEELIT_TEXTURE;
+
+typedef struct FEELIT_CUSTOMFORCE {
+    DWORD cChannels;		/* No. of channels (axes) affected by this force */
+    DWORD dwSamplePeriod;	/* Sample period in microseconds */
+    DWORD cSamples;			/* Total number of samples in the rglForceData */
+    LPLONG rglForceData;	/* long[cSamples]. Array of force values. Channels are interleaved */
+} FEELIT_CUSTOMFORCE, *LPFEELIT_CUSTOMFORCE;
+typedef const FEELIT_CUSTOMFORCE *LPCFEELIT_CUSTOMFORCE;
+
+typedef struct FEELIT_ENVELOPE {
+    DWORD dwSize;			/* sizeof(FEELIT_ENVELOPE)   */
+    DWORD dwAttackLevel;	/* Ampl. for start of env., rel. to baseline. Range 0 to 10000 */
+    DWORD dwAttackTime;     /* Time, in microseconds, to reach sustain level */
+    DWORD dwFadeLevel;		/* Ampl. for end of env., rel. to baseline. Range 0 to 10000 */
+    DWORD dwFadeTime;       /* Time, in microseconds, to reach fade level */
+} FEELIT_ENVELOPE, *LPFEELIT_ENVELOPE;
+typedef const FEELIT_ENVELOPE *LPCFEELIT_ENVELOPE;
+
+typedef struct FEELIT_EFFECT {
+    DWORD dwSize;                   /* sizeof(FEELIT_EFFECT) */
+	GUID guidEffect;			    /* Effect Identifier    */
+	DWORD dwFlags;                  /* FEELIT_FEFFECT_*      */
+    DWORD dwDuration;               /* Microseconds         */
+    DWORD dwSamplePeriod;           /* RESERVED             */
+    DWORD dwGain;					/* RESERVED             */
+    DWORD dwTriggerButton;          /* RESERVED             */
+    DWORD dwTriggerRepeatInterval;  /* RESERVED             */
+    DWORD cAxes;                    /* Number of axes       */
+    LPDWORD rgdwAxes;               /* Array of axes        */
+    LPLONG rglDirection;            /* Array of directions  */
+    LPFEELIT_ENVELOPE lpEnvelope;   /* Optional             */
+    DWORD cbTypeSpecificParams;     /* Size of params       */
+    LPVOID lpvTypeSpecificParams;   /* Pointer to params    */
+	 DWORD dwStartDelay;             /* Microseconds delay    */
+} FEELIT_EFFECT, *LPFEELIT_EFFECT;
+typedef const FEELIT_EFFECT *LPCFEELIT_EFFECT;
+
+
+/* Effect Flags */
+#define FEELIT_FEFFECT_OBJECTIDS             0x00000001
+#define FEELIT_FEFFECT_OBJECTOFFSETS         0x00000002
+#define FEELIT_FEFFECT_CARTESIAN             0x00000010
+#define FEELIT_FEFFECT_POLAR                 0x00000020
+#define FEELIT_FEFFECT_SPHERICAL             0x00000040
+
+/* Parameter Flags */
+#define FEELIT_FPARAM_DURATION               0x00000001
+#define FEELIT_FPARAM_SAMPLEPERIOD           0x00000002
+#define FEELIT_FPARAM_GAIN                   0x00000004
+#define FEELIT_FPARAM_TRIGGERBUTTON          0x00000008
+#define FEELIT_FPARAM_TRIGGERREPEATINTERVAL  0x00000010
+#define FEELIT_FPARAM_AXES                   0x00000020
+#define FEELIT_FPARAM_DIRECTION              0x00000040
+#define FEELIT_FPARAM_ENVELOPE               0x00000080
+#define FEELIT_FPARAM_TYPESPECIFICPARAMS     0x00000100
+#define FEELIT_FPARAM_STARTDELAY             0x00000200
+#define FEELIT_FPARAM_ALLPARAMS              0x000003FF
+#define FEELIT_FPARAM_START                  0x20000000
+#define FEELIT_FPARAM_NORESTART              0x40000000
+#define FEELIT_FPARAM_NODOWNLOAD             0x80000000
+
+#define FEELIT_PARAM_NOTRIGGER               0xFFFFFFFF
+
+/* Start Flags */
+#define FEELIT_FSTART_SOLO                   0x00000001
+#define FEELIT_FSTART_NODOWNLOAD             0x80000000
+
+/* Status Flags */
+#define FEELIT_FSTATUS_PLAYING               0x00000001
+#define FEELIT_FSTATUS_EMULATED              0x00000002
+
+/* Stiffness Mask Flags */
+#define FEELIT_FSTIFF_NONE				0x00000000
+#define FEELIT_FSTIFF_OUTERLEFTWALL		0x00000001
+#define FEELIT_FSTIFF_INNERLEFTWALL		0x00000002
+#define FEELIT_FSTIFF_INNERRIGHTWALL	0x00000004
+#define FEELIT_FSTIFF_OUTERRIGHTWALL	0x00000008
+#define FEELIT_FSTIFF_OUTERTOPWALL		0x00000010
+#define FEELIT_FSTIFF_INNERTOPWALL		0x00000020
+#define FEELIT_FSTIFF_INNERBOTTOMWALL	0x00000040
+#define FEELIT_FSTIFF_OUTERBOTTOMWALL	0x00000080
+#define FEELIT_FSTIFF_OUTERANYWALL		( FEELIT_FSTIFF_OUTERTOPWALL | FEELIT_FSTIFF_OUTERBOTTOMWALL | FEELIT_FSTIFF_OUTERLEFTWALL | FEELIT_FSTIFF_OUTERRIGHTWALL )
+#define FEELIT_FSTIFF_INBOUNDANYWALL	FEELIT_FSTIFF_OUTERANYWALL
+#define FEELIT_FSTIFF_INNERANYWALL		( FEELIT_FSTIFF_INNERTOPWALL | FEELIT_FSTIFF_INNERBOTTOMWALL | FEELIT_FSTIFF_INNERLEFTWALL | FEELIT_FSTIFF_INNERRIGHTWALL )
+#define FEELIT_FSTIFF_OUTBOUNDANYWALL	FEELIT_FSTIFF_INNERANYWALL
+#define FEELIT_FSTIFF_ANYWALL			( FEELIT_FSTIFF_OUTERANYWALL | FEELIT_FSTIFF_INNERANYWALL )
+
+/* Clipping Mask Flags */
+#define FEELIT_FCLIP_NONE				0x00000000
+#define FEELIT_FCLIP_OUTERLEFTWALL		0x00000001
+#define FEELIT_FCLIP_INNERLEFTWALL		0x00000002
+#define FEELIT_FCLIP_INNERRIGHTWALL		0x00000004
+#define FEELIT_FCLIP_OUTERRIGHTWALL		0x00000008
+#define FEELIT_FCLIP_OUTERTOPWALL		0x00000010
+#define FEELIT_FCLIP_INNERTOPWALL		0x00000020
+#define FEELIT_FCLIP_INNERBOTTOMWALL	0x00000040
+#define FEELIT_FCLIP_OUTERBOTTOMWALL	0x00000080
+#define FEELIT_FCLIP_OUTERANYWALL		( FEELIT_FCLIP_OUTERTOPWALL | FEELIT_FCLIP_OUTERBOTTOMWALL | FEELIT_FCLIP_OUTERLEFTWALL | FEELIT_FCLIP_OUTERRIGHTWALL )
+#define FEELIT_FCLIP_INNERANYWALL		( FEELIT_FCLIP_INNERTOPWALL | FEELIT_FCLIP_INNERBOTTOMWALL | FEELIT_FCLIP_INNERLEFTWALL | FEELIT_FCLIP_INNERRIGHTWALL )
+#define FEELIT_FCLIP_ANYWALL			( FEELIT_FCLIP_OUTERANYWALL | FEELIT_FCLIP_INNERANYWALL )
+
+typedef struct FEELIT_EFFESCAPE {
+    DWORD   dwSize;			/* sizeof( FEELIT_EFFESCAPE ) */
+    DWORD   dwCommand;		/* Driver-specific command number */
+    LPVOID  lpvInBuffer;	/* Buffer containing data required to perform the operation */
+    DWORD   cbInBuffer;		/* Size, in bytes, of lpvInBuffer */
+    LPVOID  lpvOutBuffer;	/* Buffer in which the operation's output data is returned */
+    DWORD   cbOutBuffer;	/* Size, in bytes, of lpvOutBuffer */
+} FEELIT_EFFESCAPE, *LPFEELIT_EFFESCAPE;
+
+
+#ifndef IS_VXD
+
+#undef INTERFACE
+#define INTERFACE IFeelitEffect
+
+DECLARE_INTERFACE_(IFeelitEffect, IUnknown)
+{
+    /*** IUnknown methods ***/
+    STDMETHOD(QueryInterface)(THIS_ REFIID riid, LPVOID * ppvObj) PURE;
+    STDMETHOD_(ULONG,AddRef)(THIS) PURE;
+    STDMETHOD_(ULONG,Release)(THIS) PURE;
+
+    /*** IFeelitEffect methods ***/
+    STDMETHOD(GetEffectGuid)(THIS_ LPGUID) PURE;
+    STDMETHOD(GetParameters)(THIS_ LPFEELIT_EFFECT,DWORD) PURE;
+    STDMETHOD(SetParameters)(THIS_ LPCFEELIT_EFFECT,DWORD) PURE;
+    STDMETHOD(Start)(THIS_ DWORD,DWORD) PURE;
+    STDMETHOD(Stop)(THIS) PURE;
+    STDMETHOD(GetEffectStatus)(THIS_ LPDWORD) PURE;
+    STDMETHOD(Download)(THIS) PURE;
+    STDMETHOD(Unload)(THIS) PURE;
+    STDMETHOD(Escape)(THIS_ LPFEELIT_EFFESCAPE) PURE;
+};
+
+typedef struct IFeelitEffect *LPIFEELIT_EFFECT;
+
+
+#if !defined(__cplusplus) || defined(CINTERFACE)
+#define IFeelitEffect_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IFeelitEffect_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IFeelitEffect_Release(p) (p)->lpVtbl->Release(p)
+#define IFeelitEffect_GetEffectGuid(p,a) (p)->lpVtbl->GetEffectGuid(p,a)
+#define IFeelitEffect_GetParameters(p,a,b) (p)->lpVtbl->GetParameters(p,a,b)
+#define IFeelitEffect_SetParameters(p,a,b) (p)->lpVtbl->SetParameters(p,a,b)
+#define IFeelitEffect_Start(p,a,b) (p)->lpVtbl->Start(p,a,b)
+#define IFeelitEffect_Stop(p) (p)->lpVtbl->Stop(p)
+#define IFeelitEffect_GetEffectStatus(p,a) (p)->lpVtbl->GetEffectStatus(p,a)
+#define IFeelitEffect_Download(p) (p)->lpVtbl->Download(p)
+#define IFeelitEffect_Unload(p) (p)->lpVtbl->Unload(p)
+#define IFeelitEffect_Escape(p,a) (p)->lpVtbl->Escape(p,a)
+#else
+#define IFeelitEffect_QueryInterface(p,a,b) (p)->QueryInterface(a,b)
+#define IFeelitEffect_AddRef(p) (p)->AddRef()
+#define IFeelitEffect_Release(p) (p)->Release()
+#define IFeelitEffect_GetEffectGuid(p,a) (p)->GetEffectGuid(a)
+#define IFeelitEffect_GetParameters(p,a,b) (p)->GetParameters(a,b)
+#define IFeelitEffect_SetParameters(p,a,b) (p)->SetParameters(a,b)
+#define IFeelitEffect_Start(p,a,b) (p)->Start(a,b)
+#define IFeelitEffect_Stop(p) (p)->Stop()
+#define IFeelitEffect_GetEffectStatus(p,a) (p)->GetEffectStatus(a)
+#define IFeelitEffect_Download(p) (p)->Download()
+#define IFeelitEffect_Unload(p) (p)->Unload()
+#define IFeelitEffect_Escape(p,a) (p)->Escape(a)
+#endif
+
+
+typedef struct FEELIT_ENCLOSURE {
+    DWORD dwSize;                       /* sizeof(FEELIT_ENCLOSURE) */
+    RECT rectBoundary;                  /* Rectangle defining the boundaries of the effect, in screen coords */
+    DWORD dwTopAndBottomWallThickness;  /* Thickness (pixels) of top/bottom walls. Must be < rectOutside.Height()/2 */
+    DWORD dwLeftAndRightWallThickness;  /* Thickness (pixels) of left/right walls. Must be < rectOutside.Width()/2 */
+    LONG lTopAndBottomWallStiffness;    /* Stiffness of horizontal borders */
+    LONG lLeftAndRightWallStiffness;    /* Stiffness of vertical borders */
+    DWORD dwStiffnessMask;              /* Borders where stiffness is turned on (FEELIT_FSTIFF*) */
+    DWORD dwClippingMask;               /* Borders where clipping is turned on  (FEELIT_FCLIP*) */
+    DWORD dwTopAndBottomWallSaturation; /* Saturation level of spring effect for top/bottom borders */
+    DWORD dwLeftAndRightWallSaturation; /* Saturation level of spring effect for left/right borders */
+    LPIFEELIT_EFFECT piInsideEffect;    /* Interface pointer to effect active in inner area of the enclosure */
+} FEELIT_ENCLOSURE, *LPFEELIT_ENCLOSURE;
+typedef const FEELIT_ENCLOSURE *LPCFEELIT_ENCLOSURE;
+
+
+typedef struct FEELIT_ELLIPSE {
+    DWORD dwSize;                       /* sizeof(FEELIT_ELLIPSE) */
+    RECT  rectBoundary;                 /* Rectangle which circumscribes the ellipse (screen coords) */
+    DWORD dwWallThickness;              /* Thickness (pixels) of ellipse wall at its thickest point */
+    LONG lStiffness;                    /* Stiffness of ellipse borders */
+    DWORD dwStiffnessMask;              /* Borders where stiffness is turned on (FEELIT_FSTIFF*) */
+    DWORD dwClippingMask;               /* Borders where clipping is turned on  (FEELIT_FCLIP*) */
+    DWORD dwSaturation;                 /* Saturation level of spring effect for ellipse borders */
+    LPIFEELIT_EFFECT piInsideEffect;    /* Interface pointer to effect active in inner area of the ellipse */
+} FEELIT_ELLIPSE, *LPFEELIT_ELLIPSE;
+typedef const FEELIT_ELLIPSE *LPCFEELIT_ELLIPSE;
+
+#endif // IS_VXD
+
+/****************************************************************************
+ *
+ *      IFeelitDevice
+ *
+ ****************************************************************************/
+
+/* Device types */
+#define FEELIT_DEVICETYPE_DEVICE    1
+#define FEELIT_DEVICETYPE_MOUSE     2
+#define FEELIT_DEVICETYPE_HID       0x00010000
+
+/* Device subtypes */
+#define FEELIT_DEVICETYPEMOUSE_UNKNOWN          1
+#define FEELIT_DEVICETYPEMOUSE_TRADITIONAL_FF   2
+
+/* Device type macros */
+#define GET_FEELIT_DEVICE_TYPE(dwDevType)    LOBYTE(dwDevType)
+#define GET_FEELIT_DEVICE_SUBTYPE(dwDevType) HIBYTE(dwDevType)
+
+typedef struct FEELIT_DEVCAPS {
+    DWORD   dwSize;					/* sizeof( FEELIT_DEVCAPS ) */
+    DWORD   dwFlags;				/* FEELIT_FDEVCAPS_* */
+    DWORD   dwDevType;				/* FEELIT_DEVICETYPE* */
+    DWORD   dwAxes;					/* No. of axes available on the device */
+    DWORD   dwButtons;				/* No. of buttons available on the device */
+    DWORD   dwPOVs;					/* No. of point-of-view controllers on the device */
+    DWORD   dwFFSamplePeriod;		/* Min. time btwn playback of consec. raw force commands */
+    DWORD   dwFFMinTimeResolution;	/* Min. time, in microseconds, the device can resolve */
+    DWORD   dwFirmwareRevision;		/* Firmware revision number of the device */
+    DWORD   dwHardwareRevision;		/* Hardware revision number of the device */
+    DWORD   dwFFDriverVersion;		/* Version number of the device driver */
+} FEELIT_DEVCAPS, *LPFEELIT_DEVCAPS;
+typedef const FEELIT_DEVCAPS *LPCFEELIT_DEVCAPS;
+
+/* Device capabilities flags */
+#define FEELIT_FDEVCAPS_ATTACHED           0x00000001
+#define FEELIT_FDEVCAPS_POLLEDDEVICE       0x00000002
+#define FEELIT_FDEVCAPS_EMULATED           0x00000004
+#define FEELIT_FDEVCAPS_POLLEDDATAFORMAT   0x00000008
+#define FEELIT_FDEVCAPS_FORCEFEEDBACK      0x00000100
+#define FEELIT_FDEVCAPS_FFATTACK           0x00000200
+#define FEELIT_FDEVCAPS_FFFADE             0x00000400
+#define FEELIT_FDEVCAPS_SATURATION         0x00000800
+#define FEELIT_FDEVCAPS_POSNEGCOEFFICIENTS 0x00001000
+#define FEELIT_FDEVCAPS_POSNEGSATURATION   0x00002000
+#define FEELIT_FDEVCAPS_DEADBAND           0x00004000
+
+
+/* Data Format Type Flags */
+
+#define FEELIT_FOBJDATAFMT_ALL               0x00000000
+
+#define FEELIT_FOBJDATAFMT_RELAXIS           0x00000001
+#define FEELIT_FOBJDATAFMT_ABSAXIS           0x00000002
+#define FEELIT_FOBJDATAFMT_AXIS              0x00000003
+
+#define FEELIT_FOBJDATAFMT_PSHBUTTON         0x00000004
+#define FEELIT_FOBJDATAFMT_TGLBUTTON         0x00000008
+#define FEELIT_FOBJDATAFMT_BUTTON            0x0000000C
+
+#define FEELIT_FOBJDATAFMT_POV               0x00000010
+
+#define FEELIT_FOBJDATAFMT_COLLECTION        0x00000040
+#define FEELIT_FOBJDATAFMT_NODATA            0x00000080
+#define FEELIT_FOBJDATAFMT_FFACTUATOR        0x01000000
+#define FEELIT_FOBJDATAFMT_FFEFFECTTRIGGER   0x02000000
+#define FEELIT_FOBJDATAFMT_NOCOLLECTION      0x00FFFF00
+
+#define FEELIT_FOBJDATAFMT_ANYINSTANCE       0x00FFFF00
+#define FEELIT_FOBJDATAFMT_INSTANCEMASK      FEELIT_FOBJDATAFMT_ANYINSTANCE
+
+
+/* Data Format Type Macros */
+#define FEELIT_OBJDATAFMT_MAKEINSTANCE(n)	((WORD)(n) << 8)
+#define FEELIT_OBJDATAFMT_GETTYPE(n)			LOBYTE(n)
+#define FEELIT_OBJDATAFMT_GETINSTANCE(n)		LOWORD((n) >> 8)
+#define FEELIT_OBJDATAFMT_ENUMCOLLECTION(n)	((WORD)(n) << 8)
+
+#ifndef IS_VXD
+
+typedef struct _FEELIT_OBJECTDATAFORMAT {
+    const GUID *pguid;	/* Unique ID for the axis, button, or other input source. */
+    DWORD   dwOfs;		/* Offset in data packet where input source data is stored */
+    DWORD   dwType;		/* Device type describing the object. (FEELIT_FOBJDATAFMT_*) */
+    DWORD   dwFlags;	/* Aspect flags.  Zero or more of FEELIT_FDEVOBJINST_ASPECT* */
+} FEELIT_OBJECTDATAFORMAT, *LPFEELIT_OBJECTDATAFORMAT;
+typedef const FEELIT_OBJECTDATAFORMAT *LPCFEELIT_OBJECTDATAFORMAT;
+
+typedef struct _FEELIT_DATAFORMAT {
+    DWORD   dwSize;		/* sizeof( FEELIT_DATAFORMAT ) */
+    DWORD   dwObjSize;	/* sizeof( FEELIT_OBJECTDATAFORMAT ) */
+    DWORD   dwFlags;	/* One of FEELIT_FDATAFORMAT_* */
+    DWORD   dwDataSize;	/* Size, in bytes, of data packet returned by the device */
+    DWORD   dwNumObjs;	/* Number of object in the rgodf array */
+    LPFEELIT_OBJECTDATAFORMAT rgodf;	/* Ptr to array of FEELIT_OBJECTDATAFORMAT */
+} FEELIT_DATAFORMAT, *LPFEELIT_DATAFORMAT;
+typedef const FEELIT_DATAFORMAT *LPCFEELIT_DATAFORMAT;
+
+/* Data Format Flags */
+#define FEELIT_FDATAFORMAT_ABSAXIS            0x00000001
+#define FEELIT_FDATAFORMAT_RELAXIS            0x00000002
+
+/* Predefined Data Formats */
+extern const FEELIT_DATAFORMAT c_dfFeelitMouse;
+
+typedef struct FEELIT_DEVICEOBJECTINSTANCE {
+    DWORD   dwSize;					/* sizeof( FEELIT_DEVICEOBJECTINSTANCE ) */
+    GUID    guidType;				/* Optional unique ID indicating object type */
+    DWORD   dwOfs;					/* Offset within data format for data from this object */
+    DWORD   dwType;					/* Device type describing the object. (FEELIT_FOBJDATAFMT_*) */
+    DWORD   dwFlags;				/* Zero or more of FEELIT_FDEVOBJINST_* */
+    CHAR    tszName[MAX_PATH];		/* Name of object (e.g. "X-Axis") */
+    DWORD   dwFFMaxForce;			/* Mag. of max force created by actuator for this object */
+    DWORD   dwFFForceResolution;	/* Force resolution of the actuator for this object */
+    WORD    wCollectionNumber;		/* RESERVED */
+    WORD    wDesignatorIndex;		/* RESERVED */
+    WORD    wUsagePage;				/* HID usage page associated with the object */
+    WORD    wUsage;					/* HID usage associated with the object */
+    DWORD   dwDimension;			/* Dimensional units in which object's value is reported */
+    WORD    wExponent;				/* Exponent to associate with the demension */
+    WORD    wReserved;
+} FEELIT_DEVICEOBJECTINSTANCE, *LPFEELIT_DEVICEOBJECTINSTANCE;
+typedef const FEELIT_DEVICEOBJECTINSTANCE  *LPCFEELIT_DEVICEOBJECTINSTANCE;
+
+typedef BOOL (FAR PASCAL * LPFEELIT_ENUMDEVICEOBJECTSCALLBACK)(LPCFEELIT_DEVICEOBJECTINSTANCE, LPVOID);
+
+/* Device Object Instance Flags */
+#define FEELIT_FDEVOBJINST_FFACTUATOR        0x00000001
+#define FEELIT_FDEVOBJINST_FFEFFECTTRIGGER   0x00000002
+#define FEELIT_FDEVOBJINST_POLLED            0x00008000
+#define FEELIT_FDEVOBJINST_ASPECTPOSITION    0x00000100
+#define FEELIT_FDEVOBJINST_ASPECTVELOCITY    0x00000200
+#define FEELIT_FDEVOBJINST_ASPECTACCEL       0x00000300
+#define FEELIT_FDEVOBJINST_ASPECTFORCE       0x00000400
+#define FEELIT_FDEVOBJINST_ASPECTMASK        0x00000F00
+
+#endif // IS_VXD
+
+typedef struct FEELIT_PROPHEADER {
+    DWORD   dwSize;			/* Size of enclosing struct, to which this struct is header */
+    DWORD   dwHeaderSize;	/* sizeof ( FEELIT_PROPHEADER ) */
+    DWORD   dwObj;			/* Object for which the property is to be accessed */
+    DWORD   dwHow;			/* Specifies how dwObj is interpreted. ( FEELIT_FPROPHEADER_* ) */
+} FEELIT_PROPHEADER, *LPFEELIT_PROPHEADER;
+typedef const FEELIT_PROPHEADER *LPCFEELIT_PROPHEADER;
+
+/* Prop header flags */
+#define FEELIT_FPROPHEADER_DEVICE             0
+#define FEELIT_FPROPHEADER_BYOFFSET           1
+#define FEELIT_FPROPHEADER_BYID               2
+
+typedef struct FEELIT_PROPDWORD {
+    FEELIT_PROPHEADER feelitph;	/* Feelit property header struct */
+    DWORD   dwData;				/* Property-specific value being retrieved */
+} FEELIT_PROPDWORD, *LPFEELIT_PROPDWORD;
+typedef const FEELIT_PROPDWORD *LPCFEELIT_PROPDWORD;
+
+typedef struct FEELIT_PROPRANGE {
+    FEELIT_PROPHEADER feelitph;	/* Feelit property header struct */
+    LONG    lMin;				/* Lower limit of range, inclusive */
+    LONG    lMax;				/* Upper limit of range, inclusive */
+} FEELIT_PROPRANGE, *LPFEELIT_PROPRANGE;
+typedef const FEELIT_PROPRANGE *LPCFEELIT_PROPRANGE;
+
+#define FEELIT_PROPRANGE_NOMIN       ((LONG)0x80000000)
+#define FEELIT_PROPRANGE_NOMAX       ((LONG)0x7FFFFFFF)
+
+#ifdef __cplusplus
+#define MAKE_FEELIT_PROP(prop)    (*(const GUID *)(prop))
+#else
+#define MAKE_FEELIT_PROP(prop)    ((REFGUID)(prop))
+#endif
+
+#define FEELIT_PROP_BUFFERSIZE       MAKE_FEELIT_PROP(1)
+
+#define FEELIT_PROP_AXISMODE         MAKE_FEELIT_PROP(2)
+
+#define FEELIT_PROPAXISMODE_ABS      0
+#define FEELIT_PROPAXISMODE_REL      1
+
+#define FEELIT_PROP_GRANULARITY      MAKE_FEELIT_PROP(3)
+
+#define FEELIT_PROP_RANGE            MAKE_FEELIT_PROP(4)
+
+#define FEELIT_PROP_DEADZONE         MAKE_FEELIT_PROP(5)
+
+#define FEELIT_PROP_SATURATION       MAKE_FEELIT_PROP(6)
+
+#define FEELIT_PROP_FFGAIN           MAKE_FEELIT_PROP(7)
+
+#define FEELIT_PROP_FFLOAD           MAKE_FEELIT_PROP(8)
+
+#define FEELIT_PROP_AUTOCENTER       MAKE_FEELIT_PROP(9)
+
+#define FEELIT_PROPAUTOCENTER_OFF    0
+#define FEELIT_PROPAUTOCENTER_ON     1
+
+#define FEELIT_PROP_CALIBRATIONMODE  MAKE_FEELIT_PROP(10)
+
+#define FEELIT_PROPCALIBRATIONMODE_COOKED    0
+#define FEELIT_PROPCALIBRATIONMODE_RAW       1
+
+// Device configuration/control, for use by control panels
+
+#define FEELIT_PROP_DEVICEGAIN       MAKE_FEELIT_PROP(11)
+#define FEELIT_PROP_BALLISTICS       MAKE_FEELIT_PROP(12)
+
+typedef struct FEELIT_PROPBALLISTICS {
+    FEELIT_PROPHEADER feelitph;	/* Feelit property header struct */
+    INT   Sensitivity;			/* Property-specific value */
+    INT   LowThreshhold;		/* Property-specific value */
+    INT   HighThreshhold;		/* Property-specific value */
+} FEELIT_PROPBALLISTICS, *LPFEELIT_PROPBALLISTICS;
+typedef const FEELIT_PROPBALLISTICS *LPCFEELIT_PROPBALLISTICS;
+
+#define FEELIT_PROP_SCREENSIZE       MAKE_FEELIT_PROP(13)
+
+typedef struct FEELIT_PROPSCREENSIZE {
+    FEELIT_PROPHEADER feelitph;	/* Feelit property header struct */
+    DWORD   dwXScreenSize;		/* Max X screen coord value */
+    DWORD   dwYScreenSize;		/* Max Y screen coord value */
+} FEELIT_PROPSCREENSIZE, *LPFEELIT_PROPSCREENSIZE;
+typedef const FEELIT_PROPSCREENSIZE *LPCFEELIT_PROPSCREENSIZE;
+
+#define FEELIT_PROP_ABSOLUTEMODE       MAKE_FEELIT_PROP(14)
+
+typedef struct FEELIT_PROPABSOLUTEMODE {
+	FEELIT_PROPHEADER feelitph;	/* Feelit property header struct */
+	BOOL bAbsMode;				/* TRUE for Absolute mode FALSE for Relative mode */
+} FEELIT_PROPABSOLUTEMODE, *LPFEELIT_PROPABSOLUTEMODE;
+typedef const FEELIT_PROPABSOLUTEMODE *LPCFEELIT_PROPABSOLUTEMODE;
+
+
+#define FEELIT_PROP_DEVICEMODE            MAKE_FEELIT_PROP(15)
+#define FEELIT_PROPDEVICEMODE_MOUSE       1			
+#define FEELIT_PROPDEVICEMODE_JOYSTICK    2
+
+
+typedef struct FEELIT_DEVICEOBJECTDATA {
+    DWORD   dwOfs;			/* Offset into current data format of this data's object */
+    DWORD   dwData;			/* Data obtained from the device */
+    DWORD   dwTimeStamp;	/* Tick count, in milliseconds, at which event was generated */
+    DWORD   dwSequence;		/* Sequence number for this event */
+} FEELIT_DEVICEOBJECTDATA, *LPFEELIT_DEVICEOBJECTDATA;
+typedef const FEELIT_DEVICEOBJECTDATA *LPCFEELIT_DEVICEOBJECTDATA;
+
+#define FEELIT_SEQUENCE_COMPARE(dwSequence1, cmp, dwSequence2) \
+                        ((int)((dwSequence1) - (dwSequence2)) cmp 0)
+
+/* GetDeviceData Flags */
+#define FEELIT_FGETDEVDATA_PEEK          0x00000001
+
+/* Cooperative Level Flags */
+#define FEELIT_FCOOPLEVEL_FOREGROUND    0x00000004
+#define FEELIT_FCOOPLEVEL_BACKGROUND    0x00000008
+
+#ifndef IS_VXD
+
+typedef struct FEELIT_DEVICEINSTANCE {
+    DWORD   dwSize;						/* sizeof ( FEELIT_DEVICEINSTANCE ) */
+    GUID    guidInstance;				/* Unique id for instance of device */
+    GUID    guidProduct;				/* Unique id for the product */
+    DWORD   dwDevType;					/* Device type (FEELIT_DEVICETYPE*) */
+    CHAR    tszInstanceName[MAX_PATH];	/* Friendly name for the instance (e.g. "Feelit Mouse 1") */
+    CHAR    tszProductName[MAX_PATH];	/* Friendly name for the product (e.g. "Feelit Mouse") */
+    GUID    guidFFDriver;				/* Unique id for the driver being used for force feedback */
+    WORD    wUsagePage;					/* HID usage page code (if the device driver is a HID device) */
+    WORD    wUsage;						/* HID usage code (if the device driver is a HID device) */
+} FEELIT_DEVICEINSTANCE, *LPFEELIT_DEVICEINSTANCE;
+typedef const FEELIT_DEVICEINSTANCE  *LPCFEELIT_DEVICEINSTANCE;
+
+#endif // IS_VXD
+
+#define FEELIT_FCOMMAND_RESET            0x00000001
+#define FEELIT_FCOMMAND_STOPALL          0x00000002
+#define FEELIT_FCOMMAND_PAUSE            0x00000004
+#define FEELIT_FCOMMAND_CONTINUE         0x00000008
+#define FEELIT_FCOMMAND_SETACTUATORSON   0x00000010
+#define FEELIT_FCOMMAND_SETACTUATORSOFF  0x00000020
+
+#define FEELIT_FDEVICESTATE_EMPTY            0x00000001
+#define FEELIT_FDEVICESTATE_STOPPED          0x00000002
+#define FEELIT_FDEVICESTATE_PAUSED           0x00000004
+#define FEELIT_FDEVICESTATE_ACTUATORSON      0x00000010
+#define FEELIT_FDEVICESTATE_ACTUATORSOFF     0x00000020
+#define FEELIT_FDEVICESTATE_POWERON          0x00000040
+#define FEELIT_FDEVICESTATE_POWEROFF         0x00000080
+#define FEELIT_FDEVICESTATE_SAFETYSWITCHON   0x00000100
+#define FEELIT_FDEVICESTATE_SAFETYSWITCHOFF  0x00000200
+#define FEELIT_FDEVICESTATE_USERFFSWITCHON   0x00000400
+#define FEELIT_FDEVICESTATE_USERFFSWITCHOFF  0x00000800
+#define FEELIT_FDEVICESTATE_DEVICELOST       0x80000000
+
+#ifndef IS_VXD
+
+typedef struct FEELIT_EFFECTINFO {
+    DWORD   dwSize;				/* sizeof( FEELIT_EFFECTINFO ) */
+    GUID    guid;				/* Unique ID of the effect */
+    DWORD   dwEffType;			/* Zero or more of FEELIT_FEFFECTTYPE_* */
+    DWORD   dwStaticParams;		/* All params supported. Zero or more of FEELIT_FPARAM_* */
+    DWORD   dwDynamicParams;	/* Params modifiable while effect playing. (FEELIT_FPARAM_*) */
+    CHAR    tszName[MAX_PATH];	/* Name of effect (e.g. "Enclosure" ) */
+} FEELIT_EFFECTINFO, *LPFEELIT_EFFECTINFO;
+typedef const FEELIT_EFFECTINFO  *LPCFEELIT_EFFECTINFO;
+
+typedef BOOL (FAR PASCAL * LPFEELIT_ENUMEFFECTSCALLBACK)(LPCFEELIT_EFFECTINFO, LPVOID);
+typedef BOOL (FAR PASCAL * LPFEELIT_ENUMCREATEDEFFECTOBJECTSCALLBACK)(LPFEELIT_EFFECT, LPVOID);
+
+#endif // IS_VXD
+
+
+/*
+				Feelit Events
+
+Feelit events are defined using a FEELIT_EVENT struct.  They are created by 
+passing the struct to CreateFeelitEvent, which returns an HFEELITEVENT handle.
+Feelit notifies clients that Feelit Event has triggered by sending a message to
+the window handle associated with the event.  Window handles are associated with
+events using the hWndEventHandler param. of the FEELIT_EVENT struct. The window 
+message that Feelit sends to notify of an event, contains information in the
+WPARAM and LPARAM as described below.
+
+DURING INITIALIZATION:
+const UINT g_wmFeelitEvent = RegisterWindowMessage( FEELIT_EVENT_MSG_STRING );
+
+IN MESSAGE LOOP:
+if ( msgID == g_wmFeelitEvent )
+{
+    WORD wRef = LOWORD(wParam);				// 16-bit app-defined event id
+    WORD wfTriggers = HIWORD(wParam);		// Trigger Flags
+    short xForce = (short) LOWORD(lParam);	// Force applied along X-axis
+    short yForce = (short) HIWORD(lParam);	// Force applied along Y-axis
+}
+
+*/
+
+#define FEELIT_EVENT_MSG_STRING  "FEELIT_EVENT_MSG"
+
+typedef HANDLE HFEELITEVENT, *LPHFEELITEVENT;		/* Handle type used to manage Feelit Events */
+
+typedef struct FEELIT_EVENT {
+   DWORD dwSize;                   /* sizeof(FEELIT_EVENT) */
+   HWND hWndEventHandler;			/* Handle of window to which event msgs are sent */
+   WORD wRef;						/* 16-bit app-defined value to identify the event to the app */
+   DWORD dwEventTriggerMask;		/* Mask specifying events which trigger the callback  (FEELIT_FTRIG*) */
+   LPIFEELIT_EFFECT	piEffect;		/* Effect, if any, that this event is associated with */
+} FEELIT_EVENT, *LPFEELIT_EVENT;
+
+typedef const FEELIT_EVENT *LPCFEELIT_EVENT;
+
+
+/* Event Trigger Flags */
+
+#define FEELIT_FTRIG_NONE			0x00000000
+#define FEELIT_FTRIG_ENTER 		    0x00000001
+#define FEELIT_FTRIG_EXIT      	    0x00000002
+#define FEELIT_FTRIG_OUTER		    0x00000004
+#define FEELIT_FTRIG_INBOUND		FEELIT_FTRIG_OUTER
+#define FEELIT_FTRIG_INNER  	    0x00000008
+#define FEELIT_FTRIG_OUTBOUND  	    FEELIT_FTRIG_INNER
+#define FEELIT_FTRIG_TOPWALL		0x00000010
+#define FEELIT_FTRIG_BOTTOMWALL	    0x00000020
+#define FEELIT_FTRIG_LEFTWALL		0x00000040
+#define FEELIT_FTRIG_RIGHTWALL	    0x00000080
+#define FEELIT_FTRIG_ANYWALL		( FEELIT_FTRIG_TOPWALL | FEELIT_FTRIG_BOTTOMWALL | FEELIT_FTRIG_LEFTWALL | FEELIT_FTRIG_RIGHTWALL )
+#define FEELIT_FTRIG_ONENTERANY		( FEELIT_FTRIG_ENTER | FEELIT_FTRIG_ANYWALL )
+#define FEELIT_FTRIG_ONEXITANY		( FEELIT_FTRIG_EXIT | FEELIT_FTRIG_ANYWALL )
+#define FEELIT_FTRIG_ONOUTERANY		( FEELIT_FTRIG_OUTER | FEELIT_FTRIG_ANYWALL )
+#define FEELIT_FTRIG_ONINBOUNDANY	FEELIT_FTRIG_ONOUTERANY
+#define FEELIT_FTRIG_ONINNERANY		( FEELIT_FTRIG_INNER | FEELIT_FTRIG_ANYWALL )
+#define FEELIT_FTRIG_ONOUTBOUNDANY	FEELIT_FTRIG_ONINNERANY
+#define FEELIT_FTRIG_ONANYENCLOSURE ( FEELIT_FTRIG_ONENTERANY | FEELIT_FTRIG_ONEXITANY | FEELIT_FTRIG_ONOUTERANY | FEELIT_FTRIG_ONINNERANY )
+
+#define FEELIT_FTRIG_ONSCROLL			0x0000100
+#define FEELIT_FTRIG_ONEFFECTCOMPLETION	0x0000200
+
+#ifndef IS_VXD
+
+#undef INTERFACE
+#define INTERFACE IFeelitDevice
+
+DECLARE_INTERFACE_(IFeelitDevice, IUnknown)
+{
+    /*** IUnknown methods ***/
+    STDMETHOD(QueryInterface)(THIS_ REFIID riid, LPVOID * ppvObj) PURE;
+    STDMETHOD_(ULONG,AddRef)(THIS) PURE;
+    STDMETHOD_(ULONG,Release)(THIS) PURE;
+
+    /*** IFeelitDevice methods ***/
+    STDMETHOD(GetCapabilities)(THIS_ LPFEELIT_DEVCAPS) PURE;
+    STDMETHOD(EnumObjects)(THIS_ LPFEELIT_ENUMDEVICEOBJECTSCALLBACK,LPVOID,DWORD) PURE;
+    STDMETHOD(GetProperty)(THIS_ REFGUID,LPFEELIT_PROPHEADER) PURE;
+    STDMETHOD(SetProperty)(THIS_ REFGUID,LPCFEELIT_PROPHEADER) PURE;
+    STDMETHOD(Acquire)(THIS) PURE;
+    STDMETHOD(Unacquire)(THIS) PURE;
+    STDMETHOD(GetDeviceState)(THIS_ DWORD,LPVOID) PURE;
+    STDMETHOD(GetDeviceData)(THIS_ DWORD,LPFEELIT_DEVICEOBJECTDATA,LPDWORD,DWORD) PURE;
+    STDMETHOD(SetDataFormat)(THIS_ LPCFEELIT_DATAFORMAT) PURE;
+    STDMETHOD(SetEventNotification)(THIS_ HANDLE) PURE;
+    STDMETHOD(SetCooperativeLevel)(THIS_ HWND,DWORD) PURE;
+    STDMETHOD(GetObjectInfo)(THIS_ LPFEELIT_DEVICEOBJECTINSTANCE,DWORD,DWORD) PURE;
+    STDMETHOD(GetDeviceInfo)(THIS_ LPFEELIT_DEVICEINSTANCE) PURE;
+    STDMETHOD(RunControlPanel)(THIS_ HWND,DWORD) PURE;
+    STDMETHOD(CreateEffect)(THIS_ LPCFEELIT_EFFECT,LPIFEELIT_EFFECT *,LPUNKNOWN) PURE;
+    STDMETHOD(EnumEffects)(THIS_ LPFEELIT_ENUMEFFECTSCALLBACK,LPVOID,DWORD) PURE;
+    STDMETHOD(GetEffectInfo)(THIS_ LPFEELIT_EFFECTINFO,REFGUID) PURE;
+    STDMETHOD(GetForceFeedbackState)(THIS_ LPDWORD) PURE;
+    STDMETHOD(SendForceFeedbackCommand)(THIS_ DWORD) PURE;
+    STDMETHOD(EnumCreatedEffectObjects)(THIS_ LPFEELIT_ENUMCREATEDEFFECTOBJECTSCALLBACK,LPVOID,DWORD) PURE;
+    STDMETHOD(Escape)(THIS_ LPFEELIT_EFFESCAPE) PURE;
+    STDMETHOD(Poll)(THIS) PURE;
+    STDMETHOD(SendDeviceData)(THIS_ DWORD,LPFEELIT_DEVICEOBJECTDATA,LPDWORD,DWORD) PURE;
+    STDMETHOD(CreateFeelitEvent)(THIS_ LPCFEELIT_EVENT,LPHFEELITEVENT) PURE;
+    STDMETHOD(DestroyFeelitEvent)(THIS_ HFEELITEVENT) PURE;
+    STDMETHOD(EnableFeelitEvent)(THIS_ HFEELITEVENT,BOOL) PURE;
+    STDMETHOD(SetEventNotificationPeriodicity)(THIS_ DWORD) PURE;
+};
+
+typedef struct IFeelitDevice *LPIFEELIT_DEVICE;
+
+#if !defined(__cplusplus) || defined(CINTERFACE)
+#define IFeelitDevice_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IFeelitDevice_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IFeelitDevice_Release(p) (p)->lpVtbl->Release(p)
+#define IFeelitDevice_GetCapabilities(p,a) (p)->lpVtbl->GetCapabilities(p,a)
+#define IFeelitDevice_EnumObjects(p,a,b,c) (p)->lpVtbl->EnumObjects(p,a,b,c)
+#define IFeelitDevice_GetProperty(p,a,b) (p)->lpVtbl->GetProperty(p,a,b)
+#define IFeelitDevice_SetProperty(p,a,b) (p)->lpVtbl->SetProperty(p,a,b)
+#define IFeelitDevice_Acquire(p) (p)->lpVtbl->Acquire(p)
+#define IFeelitDevice_Unacquire(p) (p)->lpVtbl->Unacquire(p)
+#define IFeelitDevice_GetDeviceState(p,a,b) (p)->lpVtbl->GetDeviceState(p,a,b)
+#define IFeelitDevice_GetDeviceData(p,a,b,c,d) (p)->lpVtbl->GetDeviceData(p,a,b,c,d)
+#define IFeelitDevice_SetDataFormat(p,a) (p)->lpVtbl->SetDataFormat(p,a)
+#define IFeelitDevice_SetEventNotification(p,a) (p)->lpVtbl->SetEventNotification(p,a)
+#define IFeelitDevice_SetCooperativeLevel(p,a,b) (p)->lpVtbl->SetCooperativeLevel(p,a,b)
+#define IFeelitDevice_GetObjectInfo(p,a,b,c) (p)->lpVtbl->GetObjectInfo(p,a,b,c)
+#define IFeelitDevice_GetDeviceInfo(p,a) (p)->lpVtbl->GetDeviceInfo(p,a)
+#define IFeelitDevice_RunControlPanel(p,a,b) (p)->lpVtbl->RunControlPanel(p,a,b)
+#define IFeelitDevice_CreateEffect(p,a,b,c,d) (p)->lpVtbl->CreateEffect(p,a,b,c,d)
+#define IFeelitDevice_EnumEffects(p,a,b,c) (p)->lpVtbl->EnumEffects(p,a,b,c)
+#define IFeelitDevice_GetEffectInfo(p,a,b) (p)->lpVtbl->GetEffectInfo(p,a,b)
+#define IFeelitDevice_GetForceFeedbackState(p,a) (p)->lpVtbl->GetForceFeedbackState(p,a)
+#define IFeelitDevice_SendForceFeedbackCommand(p,a) (p)->lpVtbl->SendForceFeedbackCommand(p,a)
+#define IFeelitDevice_EnumCreatedEffectObjects(p,a,b,c) (p)->lpVtbl->EnumCreatedEffectObjects(p,a,b,c)
+#define IFeelitDevice_Escape(p,a) (p)->lpVtbl->Escape(p,a)
+#define IFeelitDevice_Poll(p) (p)->lpVtbl->Poll(p)
+#define IFeelitDevice_SendDeviceData(p,a,b,c,d) (p)->lpVtbl->SendDeviceData(p,a,b,c,d)
+#define IFeelitDevice_CreateFeelitEvent(p,a,b) (p)->lpVtbl->CreateFeelitEvent(p,a,b)
+#define IFeelitDevice_DestroyFeelitEvent(p,a) (p)->lpVtbl->DestroyFeelitEvent(p,a)
+#define IFeelitDevice_EnableFeelitEvent(p,a,b) (p)->lpVtbl->EnableFeelitEvent(p,a,b)
+#define IFeelitDevice_SetEventNotificationPeriodicity(p,a) (p)->lpVtbl->SetEventNotificationPeriodicity(p,a)
+#else
+#define IFeelitDevice_QueryInterface(p,a,b) (p)->QueryInterface(a,b)
+#define IFeelitDevice_AddRef(p) (p)->AddRef()
+#define IFeelitDevice_Release(p) (p)->Release()
+#define IFeelitDevice_GetCapabilities(p,a) (p)->GetCapabilities(a)
+#define IFeelitDevice_EnumObjects(p,a,b,c) (p)->EnumObjects(a,b,c)
+#define IFeelitDevice_GetProperty(p,a,b) (p)->GetProperty(a,b)
+#define IFeelitDevice_SetProperty(p,a,b) (p)->SetProperty(a,b)
+#define IFeelitDevice_Acquire(p) (p)->Acquire()
+#define IFeelitDevice_Unacquire(p) (p)->Unacquire()
+#define IFeelitDevice_GetDeviceState(p,a,b) (p)->GetDeviceState(a,b)
+#define IFeelitDevice_GetDeviceData(p,a,b,c,d) (p)->GetDeviceData(a,b,c,d)
+#define IFeelitDevice_SetDataFormat(p,a) (p)->SetDataFormat(a)
+#define IFeelitDevice_SetEventNotification(p,a) (p)->SetEventNotification(a)
+#define IFeelitDevice_SetCooperativeLevel(p,a,b) (p)->SetCooperativeLevel(a,b)
+#define IFeelitDevice_GetObjectInfo(p,a,b,c) (p)->GetObjectInfo(a,b,c)
+#define IFeelitDevice_GetDeviceInfo(p,a) (p)->GetDeviceInfo(a)
+#define IFeelitDevice_RunControlPanel(p,a,b) (p)->RunControlPanel(a,b)
+#define IFeelitDevice_CreateEffect(p,a,b,c,d) (p)->CreateEffect(a,b,c,d)
+#define IFeelitDevice_EnumEffects(p,a,b,c) (p)->EnumEffects(a,b,c)
+#define IFeelitDevice_GetEffectInfo(p,a,b) (p)->GetEffectInfo(a,b)
+#define IFeelitDevice_GetForceFeedbackState(p,a) (p)->GetForceFeedbackState(a)
+#define IFeelitDevice_SendForceFeedbackCommand(p,a) (p)->SendForceFeedbackCommand(a)
+#define IFeelitDevice_EnumCreatedEffectObjects(p,a,b,c) (p)->EnumCreatedEffectObjects(a,b,c)
+#define IFeelitDevice_Escape(p,a) (p)->Escape(a)
+#define IFeelitDevice_Poll(p) (p)->Poll()
+#define IFeelitDevice_SendDeviceData(p,a,b,c,d) (p)->SendDeviceData(a,b,c,d)
+#define IFeelitDevice_CreateFeelitEvent(p,a,b) (p)->CreateFeelitEvent(a,b)
+#define IFeelitDevice_DestroyFeelitEvent(p,a) (p)->DestroyFeelitEvent(a)
+#define IFeelitDevice_EnableFeelitEvent(p,a,b) (p)->EnableFeelitEvent(a,b)
+#define IFeelitDevice_SetEventNotificationPeriodicity(p,a) (p)->SetEventNotificationPeriodicity(a)
+#endif
+
+#endif // IS_VXD
+
+/****************************************************************************
+ *
+ *      Mouse State
+ *
+ ****************************************************************************/
+
+typedef struct _FEELIT_MOUSESTATE {
+    LONG    lXpos;
+    LONG    lYpos;
+    LONG    lZpos;
+    LONG    lXforce;
+    LONG    lYforce;
+    LONG    lZforce;
+    BYTE    rgbButtons[4];
+} FEELIT_MOUSESTATE, *LPFEELIT_MOUSESTATE;
+
+#define FEELIT_MOUSEOFFSET_XAXIS		FIELD_OFFSET(FEELIT_MOUSESTATE, lXpos)
+#define FEELIT_MOUSEOFFSET_YAXIS     FIELD_OFFSET(FEELIT_MOUSESTATE, lYpos)
+#define FEELIT_MOUSEOFFSET_ZAXIS     FIELD_OFFSET(FEELIT_MOUSESTATE, lZpos)
+#define FEELIT_MOUSEOFFSET_XFORCE    FIELD_OFFSET(FEELIT_MOUSESTATE, lXforce)
+#define FEELIT_MOUSEOFFSET_YFORCE    FIELD_OFFSET(FEELIT_MOUSESTATE, lYforce)
+#define FEELIT_MOUSEOFFSET_ZFORCE    FIELD_OFFSET(FEELIT_MOUSESTATE, lZforce)
+#define FEELIT_MOUSEOFFSET_BUTTON0	(FIELD_OFFSET(FEELIT_MOUSESTATE, rgbButtons) + 0)
+#define FEELIT_MOUSEOFFSET_BUTTON1	(FIELD_OFFSET(FEELIT_MOUSESTATE, rgbButtons) + 1)
+#define FEELIT_MOUSEOFFSET_BUTTON2	(FIELD_OFFSET(FEELIT_MOUSESTATE, rgbButtons) + 2)
+#define FEELIT_MOUSEOFFSET_BUTTON3	(FIELD_OFFSET(FEELIT_MOUSESTATE, rgbButtons) + 3)
+
+
+/****************************************************************************
+ *
+ *  IFeelit
+ *
+ ****************************************************************************/
+
+#define FEELIT_ENUM_STOP             0
+#define FEELIT_ENUM_CONTINUE         1
+
+#ifndef IS_VXD
+typedef BOOL (FAR PASCAL * LPFEELIT_ENUMDEVICESCALLBACK)(LPCFEELIT_DEVICEINSTANCE, LPVOID);
+#endif // IS_VXD
+
+#define FEELIT_FENUMDEV_ALLDEVICES       0x00000000
+#define FEELIT_FENUMDEV_ATTACHEDONLY     0x00000001
+#define FEELIT_FENUMDEV_FORCEFEEDBACK    0x00000100
+
+#ifndef IS_VXD
+
+#undef INTERFACE
+#define INTERFACE IFeelit
+
+DECLARE_INTERFACE_(IFeelit, IUnknown)
+{
+    /*** IUnknown methods ***/
+    STDMETHOD(QueryInterface)(THIS_ REFIID riid, LPVOID * ppvObj) PURE;
+    STDMETHOD_(ULONG,AddRef)(THIS) PURE;
+    STDMETHOD_(ULONG,Release)(THIS) PURE;
+
+    /*** IFeelit methods ***/
+    STDMETHOD(CreateDevice)(THIS_ REFGUID,LPIFEELIT_DEVICE *,LPUNKNOWN) PURE;
+    STDMETHOD(EnumDevices)(THIS_ DWORD,LPFEELIT_ENUMDEVICESCALLBACK,LPVOID,DWORD) PURE;
+    STDMETHOD(GetDeviceStatus)(THIS_ REFGUID) PURE;
+    STDMETHOD(RunControlPanel)(THIS_ HWND,DWORD) PURE;
+    STDMETHOD(Initialize)(THIS_ HINSTANCE,DWORD) PURE;
+};
+
+typedef struct IFeelit *LPIFEELIT;
+
+#if !defined(__cplusplus) || defined(CINTERFACE)
+#define IFeelit_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IFeelit_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IFeelit_Release(p) (p)->lpVtbl->Release(p)
+#define IFeelit_CreateDevice(p,a,b,c) (p)->lpVtbl->CreateDevice(p,a,b,c)
+#define IFeelit_EnumDevices(p,a,b,c,d) (p)->lpVtbl->EnumDevices(p,a,b,c,d)
+#define IFeelit_GetDeviceStatus(p,a) (p)->lpVtbl->GetDeviceStatus(p,a)
+#define IFeelit_RunControlPanel(p,a,b) (p)->lpVtbl->RunControlPanel(p,a,b)
+#define IFeelit_Initialize(p,a,b) (p)->lpVtbl->Initialize(p,a,b)
+#define IFeelit_FindDevice(p,a,b,c) (p)->lpVtbl->FindDevice(p,a,b,c)
+#endif
+
+extern HRESULT WINAPI FeelitCreateA(HINSTANCE hinst, DWORD dwVersion, LPIFEELIT *ppFeelit, LPUNKNOWN punkOuter);
+#define FeelitCreate FeelitCreateA
+
+#endif // IS_VXD
+
+
+/****************************************************************************
+ *
+ *  Return Codes
+ *
+ ****************************************************************************/
+
+/*
+ *  The operation completed successfully.
+ */
+#define FEELIT_RESULT_OK                           S_OK
+
+/*
+ *  The device exists but is not currently attached.
+ */
+#define FEELIT_RESULT_NOTATTACHED                  S_FALSE
+
+/*
+ *  The device buffer overflowed.  Some input was lost.
+ */
+#define FEELIT_RESULT_BUFFEROVERFLOW               S_FALSE
+
+/*
+ *  The change in device properties had no effect.
+ */
+#define FEELIT_RESULT_PROPNOEFFECT                 S_FALSE
+
+/*
+ *  The operation had no effect.
+ */
+#define FEELIT_RESULT_NOEFFECT                     S_FALSE
+
+/*
+ *  The device is a polled device.  As a result, device buffering
+ *  will not collect any data and event notifications will not be
+ *  signalled until GetDeviceState is called.
+ */
+#define FEELIT_RESULT_POLLEDDEVICE                 ((HRESULT)0x00000002L)
+
+/*
+ *  The parameters of the effect were successfully updated by
+ *  IFeelitEffect::SetParameters, but the effect was not
+ *  downloaded because the device is not exclusively acquired
+ *  or because the FEELIT_FPARAM_NODOWNLOAD flag was passed.
+ */
+#define FEELIT_RESULT_DOWNLOADSKIPPED              ((HRESULT)0x00000003L)
+
+/*
+ *  The parameters of the effect were successfully updated by
+ *  IFeelitEffect::SetParameters, but in order to change
+ *  the parameters, the effect needed to be restarted.
+ */
+#define FEELIT_RESULT_EFFECTRESTARTED              ((HRESULT)0x00000004L)
+
+/*
+ *  The parameters of the effect were successfully updated by
+ *  IFeelitEffect::SetParameters, but some of them were
+ *  beyond the capabilities of the device and were truncated.
+ */
+#define FEELIT_RESULT_TRUNCATED                    ((HRESULT)0x00000008L)
+
+/*
+ *  Equal to FEELIT_RESULT_EFFECTRESTARTED | FEELIT_RESULT_TRUNCATED.
+ */
+#define FEELIT_RESULT_TRUNCATEDANDRESTARTED        ((HRESULT)0x0000000CL)
+
+/*
+ *  The application requires a newer version of Feelit.
+ */
+#define FEELIT_ERROR_OLDFEELITVERSION     \
+    MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, ERROR_OLD_WIN_VERSION)
+
+/*
+ *  The application was written for an unsupported prerelease version
+ *  of Feelit.
+ */
+#define FEELIT_ERROR_BETAFEELITVERSION    \
+    MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, ERROR_RMODE_APP)
+
+/*
+ *  The object could not be created due to an incompatible driver version
+ *  or mismatched or incomplete driver components.
+ */
+#define FEELIT_ERROR_BADDRIVERVER              \
+    MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, ERROR_BAD_DRIVER_LEVEL)
+
+/*
+ * The device or device instance or effect is not registered with Feelit.
+ */
+#define FEELIT_ERROR_DEVICENOTREG              REGDB_E_CLASSNOTREG
+
+/*
+ * The requested object does not exist.
+ */
+#define FEELIT_ERROR_NOTFOUND                  \
+    MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, ERROR_FILE_NOT_FOUND)
+
+/*
+ * The requested object does not exist.
+ */
+#define FEELIT_ERROR_OBJECTNOTFOUND            \
+    MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, ERROR_FILE_NOT_FOUND)
+
+/*
+ * An invalid parameter was passed to the returning function,
+ * or the object was not in a state that admitted the function
+ * to be called.
+ */
+#define FEELIT_ERROR_INVALIDPARAM              E_INVALIDARG
+
+/*
+ * The specified interface is not supported by the object
+ */
+#define FEELIT_ERROR_NOINTERFACE               E_NOINTERFACE
+
+/*
+ * An undetermined error occured inside the Feelit subsystem
+ */
+#define FEELIT_ERROR_GENERIC                   E_FAIL
+
+/*
+ * The Feelit subsystem couldn't allocate sufficient memory to complete the
+ * caller's request.
+ */
+#define FEELIT_ERROR_OUTOFMEMORY               E_OUTOFMEMORY
+
+/*
+ * The function called is not supported at this time
+ */
+#define FEELIT_ERROR_UNSUPPORTED               E_NOTIMPL
+
+/*
+ * This object has not been initialized
+ */
+#define FEELIT_ERROR_NOTINITIALIZED            \
+    MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, ERROR_NOT_READY)
+
+/*
+ * This object is already initialized
+ */
+#define FEELIT_ERROR_ALREADYINITIALIZED        \
+    MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, ERROR_ALREADY_INITIALIZED)
+
+/*
+ * This object does not support aggregation
+ */
+#define FEELIT_ERROR_NOAGGREGATION             CLASS_E_NOAGGREGATION
+
+/*
+ * Another app has a higher priority level, preventing this call from
+ * succeeding.
+ */
+#define FEELIT_ERROR_OTHERAPPHASPRIO           E_ACCESSDENIED
+
+/*
+ * Access to the device has been lost.  It must be re-acquired.
+ */
+#define FEELIT_ERROR_INPUTLOST                 \
+    MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, ERROR_READ_FAULT)
+
+/*
+ * The operation cannot be performed while the device is acquired.
+ */
+#define FEELIT_ERROR_ACQUIRED                  \
+    MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, ERROR_BUSY)
+
+/*
+ * The operation cannot be performed unless the device is acquired.
+ */
+#define FEELIT_ERROR_NOTACQUIRED               \
+    MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, ERROR_INVALID_ACCESS)
+
+/*
+ * The specified property cannot be changed.
+ */
+#define FEELIT_ERROR_READONLY                  E_ACCESSDENIED
+
+/*
+ * The device already has an event notification associated with it.
+ */
+#define FEELIT_ERROR_HANDLEEXISTS              E_ACCESSDENIED
+
+/*
+ * Data is not yet available.
+ */
+#ifndef E_PENDING
+#define E_PENDING                       0x80070007L
+#endif
+
+/*
+ * Unable to perform the requested operation because the user
+ * does not have sufficient privileges.
+ */
+#define FEELIT_ERROR_INSUFFICIENTPRIVS         0x80040200L
+
+/*
+ * The device is full.
+ */
+#define FEELIT_ERROR_DEVICEFULL                0x80040201L
+
+/*
+ * Not all the requested information fit into the buffer.
+ */
+#define FEELIT_ERROR_MOREDATA                  0x80040202L
+
+/*
+ * The effect is not downloaded.
+ */
+#define FEELIT_ERROR_NOTDOWNLOADED             0x80040203L
+
+/*
+ *  The device cannot be reinitialized because there are still effects
+ *  attached to it.
+ */
+#define FEELIT_ERROR_HASEFFECTS                0x80040204L
+
+/*
+ *  The operation cannot be performed unless the device is acquired
+ *  in FEELIT_FCOOPLEVEL_EXCLUSIVE mode.
+ */
+#define FEELIT_ERROR_NOTEXCLUSIVEACQUIRED      0x80040205L
+
+/*
+ *  The effect could not be downloaded because essential information
+ *  is missing.  For example, no axes have been associated with the
+ *  effect, or no type-specific information has been created.
+ */
+#define FEELIT_ERROR_INCOMPLETEEFFECT          0x80040206L
+
+/*
+ *  Attempted to read buffered device data from a device that is
+ *  not buffered.
+ */
+#define FEELIT_ERROR_NOTBUFFERED               0x80040207L
+
+/*
+ *  An attempt was made to modify parameters of an effect while it is
+ *  playing.  Not all hardware devices support altering the parameters
+ *  of an effect while it is playing.
+ */
+#define FEELIT_ERROR_EFFECTPLAYING             0x80040208L
+
+/*
+ *  An internal error occurred (inside the API or the driver)
+ */
+#define FEELIT_ERROR_INTERNAL             0x80040209L
+
+/*
+ *  Effect set referenced by a command is not the active set
+ */
+#define FEELIT_ERROR_INACTIVE             0x8004020AL
+
+#ifdef __cplusplus
+};
+#endif
+
+
+#endif  /* __FEELITAPI_INCLUDED__ */
+
diff --git a/code/win32/FeelIt/fffx.cpp b/code/win32/FeelIt/fffx.cpp
new file mode 100644
index 0000000..74e8571
--- /dev/null
+++ b/code/win32/FeelIt/fffx.cpp
@@ -0,0 +1,680 @@
+// Filename:-	fffx.cpp	(Force-Feedback FX)
+//
+// (Function names with "_FF_" beginnings are my internal stuff only, "FF_" beginnings are for external stuff)
+//
+#define INITGUID	// this will need removing if already defined in someone else's module. Only one must exist in whole game
+
+#include "../../client/client.h"
+#include "../win_local.h"
+#include "ffc.h"
+#include "fffx_feel.h"
+
+// these now MUST default to NULL...
+//
+CFeelDevice		*g_pFeelDevice=NULL;
+CFeelProject	*g_pFeelProject=NULL;
+CFeelSpring		*g_pFeelSpring=NULL;
+
+
+ffFX_e	ffFXLoaded[MAX_CONCURRENT_FFFXs];
+
+//extern	HINSTANCE	global_hInstance;
+//extern	HWND		cl_hwnd;
+extern WinVars_t	g_wv;
+
+
+extern cvar_t *in_joystick;
+cvar_t	*use_ff;
+cvar_t	*ff_defaultTension;
+
+
+void _FF_ClearUsageArray(void);
+void _FF_ClearFXSlot(int i);
+void _FF_ClearCreatePlayFXSlot(int iSlotNum, ffFX_e fffx);
+void _FF_CreatePlayFXSlot(int iSlotNum, ffFX_e fffx);
+void _FF_PlayFXSlot(int iSlotNum);
+
+
+
+// externally accessed
+qboolean FF_IsAvailable(void)
+{
+	return g_pFeelDevice?TRUE:FALSE;
+}
+
+qboolean FF_IsMouse(void)
+{
+	if (g_pFeelDevice && (g_pFeelDevice->GetDeviceType() == FEEL_DEVICETYPE_MOUSE))
+		return TRUE;
+
+	return FALSE;
+}
+
+
+// 4 semi-useful CMD functions...
+void CMD_FF_UseMouse(void)
+{
+	FF_Init(TRUE);
+}
+
+void CMD_FF_UseJoy(void)
+{
+	FF_Init(FALSE);
+}
+
+// arg = 0..3
+//
+void CMD_FF_Tension(void)
+{	
+	if (Cmd_Argc() != 2)
+	{
+		Com_Printf ("ff_tension <tension [0..3]> (default = 1)\n");
+		return;
+	}
+
+	int iTension = atoi(Cmd_Argv(1));
+	if (iTension<0 || iTension>3)
+	{
+		Com_Printf ("ff_tension <tension [0..3]>\n");
+		return;
+	}
+
+	if (g_pFeelSpring)
+	{
+		Com_Printf(va("Setting tension %d\n",iTension));
+		Cvar_Set(ff_defaultTension->name,va("%d",iTension));
+		FF_SetTension(iTension);
+	}
+	else
+	{
+		Com_Printf("No spring device\n");
+	}
+}
+
+
+typedef struct
+{
+	char*	psName;
+	ffFX_e	eFXNum;
+}FFFX_LOOKUP;
+
+#define FFFX_ENTRY(blah) {#blah,(ffFX_e)fffx_ ## blah}
+FFFX_LOOKUP FFFX_Lookup[fffx_NUMBEROF]=
+{
+	FFFX_ENTRY( RandomNoise ),
+	FFFX_ENTRY( AircraftCarrierTakeOff ),	// this one is pointless / dumb
+	FFFX_ENTRY( BasketballDribble ),
+	FFFX_ENTRY( CarEngineIdle ),
+	FFFX_ENTRY( ChainsawIdle ),
+	FFFX_ENTRY( ChainsawInAction ),
+	FFFX_ENTRY( DieselEngineIdle ),
+	FFFX_ENTRY( Jump ),
+	FFFX_ENTRY( Land ),
+	FFFX_ENTRY( MachineGun ),
+	FFFX_ENTRY( Punched ),
+	FFFX_ENTRY( RocketLaunch ),
+	FFFX_ENTRY( SecretDoor ),
+	FFFX_ENTRY( SwitchClick ),
+	FFFX_ENTRY( WindGust ),
+	FFFX_ENTRY( WindShear ),		// also pretty crap
+	FFFX_ENTRY( Pistol ),
+	FFFX_ENTRY( Shotgun ),
+	FFFX_ENTRY( Laser1 ),
+	FFFX_ENTRY( Laser2 ),
+	FFFX_ENTRY( Laser3 ),
+	FFFX_ENTRY( Laser4 ),
+	FFFX_ENTRY( Laser5 ),
+	FFFX_ENTRY( Laser6 ),
+	FFFX_ENTRY( OutOfAmmo ),
+	FFFX_ENTRY( LightningGun ),
+	FFFX_ENTRY( Missile ),
+	FFFX_ENTRY( GatlingGun ),
+	FFFX_ENTRY( ShortPlasma ),
+	FFFX_ENTRY( PlasmaCannon1 ),
+	FFFX_ENTRY( PlasmaCannon2 ),
+	FFFX_ENTRY( Cannon )
+};
+
+void CMD_FF_Play(void)
+{
+	if (Cmd_Argc() != 2 && Cmd_Argc() != 3)
+	{
+		Com_Printf ("ff_play <n> (where n = 0..%d)	||	ff_play name \"fxname\"\n",fffx_NUMBEROF-1);
+		return;
+	}
+
+	ffFX_e eFX = fffx_NULL;
+
+	if (!Q_stricmp(Cmd_Argv(1),"name"))
+	{
+		if (Cmd_Argc() != 3)
+		{
+			Com_Printf ("ff_play <n> (where n = 0..%d)	||	ff_play name \"fxname\"\n",0,fffx_NUMBEROF-1);
+			return;
+		}
+
+		for (int i=0; i<fffx_NUMBEROF; i++)
+		{
+			if (!Q_stricmp(FFFX_Lookup[i].psName,Cmd_Argv(2)))
+			{
+				eFX = FFFX_Lookup[i].eFXNum;
+				break;
+			}
+		}
+	}
+	else
+	{
+		eFX = (ffFX_e) atoi(Cmd_Argv(1));
+	}
+
+	if (eFX>=0 && eFX<fffx_NUMBEROF)
+	{
+		Com_Printf ("Playing FFFX # %d...(%s)\n",eFX,FFFX_Lookup[eFX].psName);
+		FF_Play(eFX);
+	}
+}
+	
+
+// arg 0..n..10000
+void CMD_FF_Spring(void)
+{
+	if (Cmd_Argc() != 2)
+	{
+		Com_Printf ("ff_spring <0..10000>\n");
+		return;
+	}
+
+	long lSpring = atoi(Cmd_Argv(1));
+	if (lSpring<0 || lSpring>10000)
+	{
+		Com_Printf ("ff_spring <0..10000>\n");
+		return;
+	}
+
+	if (g_pFeelSpring)
+	{
+		Com_Printf(va("Setting spring to %d\n",lSpring));
+		FF_SetSpring(lSpring);
+	}
+	else
+	{
+		Com_Printf("No spring device\n");
+	}
+}
+
+
+// Called once only during .exe lifetime...
+//
+void FF_Init(qboolean bTryMouseFirst)
+{
+	FF_Shutdown();
+
+	Cmd_AddCommand ("ff_usemouse",	CMD_FF_UseMouse);
+	Cmd_AddCommand ("ff_usejoy",	CMD_FF_UseJoy);
+	Cmd_AddCommand ("ff_tension",	CMD_FF_Tension);
+	Cmd_AddCommand ("ff_spring",	CMD_FF_Spring);
+	Cmd_AddCommand ("ff_play",		CMD_FF_Play);
+
+	// ====================================
+
+	Com_Printf("\n" S_COLOR_CYAN "------- Force Feedback Initialization -------\n");
+
+	// for the moment default to OFF until usage tables are in...
+	use_ff				= Cvar_Get ("use_ff", "0", CVAR_ARCHIVE); 
+	ff_defaultTension	= Cvar_Get ("ff_defaultTension", "1", CVAR_ARCHIVE); 
+
+	// don't bother initializing if user specifically turned off force feedback...
+	//	
+	if (!use_ff->value)	
+	{
+		Com_Printf("...inhibited, not initializing\n\n");
+		return;
+	}
+
+	Com_Printf("Creating feedback device:\n");
+
+	if ( bTryMouseFirst )
+	{
+		CFeelMouse* m_pFeelMouse = new CFeelMouse;
+		if (m_pFeelMouse)
+		{
+			if (m_pFeelMouse->Initialize( g_wv.hInstance, g_wv.hWnd))
+			{
+				g_pFeelDevice = m_pFeelMouse;				
+			}
+			else
+			{
+				delete m_pFeelMouse;
+				m_pFeelMouse = NULL;
+			}
+		}
+	}
+
+	if (!g_pFeelDevice)
+	{
+		// try a general DI FF device...
+		//
+		CFeelDXDevice* m_pFeelDXDevice = new CFeelDXDevice;
+		if (m_pFeelDXDevice)
+		{
+			if (m_pFeelDXDevice->Initialize( g_wv.hInstance, g_wv.hWnd))
+			{
+				g_pFeelDevice = m_pFeelDXDevice;
+			}
+			else
+			{
+				delete m_pFeelDXDevice;
+				m_pFeelDXDevice = NULL;
+			}
+		}
+	}
+  
+
+//	g_pFeelDevice = CFeelDevice::CreateDevice(g_wv.hInstance, g_wv.hWnd);
+	if (!g_pFeelDevice)
+	{
+		Com_Printf("...no feedback devices found\n");		
+		return;
+	}
+	else
+	{
+		_FeelInitEffects();
+
+		for (int _i=0; _i<MAX_CONCURRENT_FFFXs; _i++)
+		{
+			ffFXLoaded[_i] = fffx_NULL;
+		}
+		
+		if (g_pFeelDevice->GetDeviceType() == FEEL_DEVICETYPE_MOUSE)
+		{
+			Com_Printf("...found FEELit Mouse\n");		
+			g_pFeelDevice->UsesWin32MouseServices(FALSE);
+		}
+		else if (g_pFeelDevice->GetDeviceType() == FEEL_DEVICETYPE_DIRECTINPUT)
+		{
+			Com_Printf("...found feedback device\n");					
+			g_pFeelSpring = new CFeelSpring;
+			if (!g_pFeelSpring->Initialize(		g_pFeelDevice,
+												2000,	//10000,					// LONG lStiffness = FEEL_SPRING_DEFAULT_STIFFNESS
+												10000,	//5000,						// DWORD dwSaturation = FEEL_SPRING_DEFAULT_SATURATION
+												1000,	//0,						// DWORD dwDeadband = FEEL_SPRING_DEFAULT_DEADBAND	// must be 0..n..10000
+												FEEL_EFFECT_AXIS_BOTH,				// DWORD dwfAxis = FEEL_EFFECT_AXIS_BOTH
+												FEEL_SPRING_DEFAULT_CENTER_POINT,	// POINT pntCenter = FEEL_SPRING_DEFAULT_CENTER_POINT
+												FEEL_EFFECT_DEFAULT_DIRECTION_X,	// LONG lDirectionX = FEEL_EFFECT_DEFAULT_DIRECTION_X
+												FEEL_EFFECT_DEFAULT_DIRECTION_Y,	// LONG lDirectionY = FEEL_EFFECT_DEFAULT_DIRECTION_Y
+												TRUE  // TRUE = rel coords, else screen coords // BOOL bUseDeviceCoordinates = FALSE
+												)
+				)
+			{
+				Com_Printf("...(no device return spring)\n");
+				delete g_pFeelSpring;
+				g_pFeelSpring = NULL;
+			}
+			else
+			{
+				Com_Printf("...device return spring ok\n");
+				FF_SetTension(ff_defaultTension->integer);	// 0..3
+			}
+		}// if (g_pFeelDevice->GetDeviceType() == FEEL_DEVICETYPE_DIRECTINPUT)
+	}
+}
+
+
+// call this at app shutdown... (or when switching controllers)
+//
+// (also called by FF_Init in case you're switching controllers so do everything
+//	as if-protected)
+//
+void FF_Shutdown(void)
+{
+	// note the check first before print, since this is called from the init code
+	// as well, and it'd be weird to see the sutdown string first...
+	//
+	if (g_pFeelSpring || g_pFeelDevice)
+	{
+		Com_Printf("\n" S_COLOR_CYAN "------- Force Feedback Shutdown -------\n");		
+	}
+
+	if (g_pFeelSpring)
+	{
+		Com_Printf("...closing return spring\n");		
+		delete g_pFeelSpring;
+		g_pFeelSpring = NULL;
+	}
+
+	if (g_pFeelDevice)
+	{
+		Com_Printf("...closing feedback device\n");		
+		_FF_ClearUsageArray();
+		delete g_pFeelDevice;
+		g_pFeelDevice = NULL;
+	}
+
+	Cmd_RemoveCommand ("ff_usemouse");
+	Cmd_RemoveCommand ("ff_usejoy");
+	Cmd_RemoveCommand ("ff_tension");
+	Cmd_RemoveCommand ("ff_spring");
+	Cmd_RemoveCommand ("ff_play");
+}
+
+
+
+
+
+
+
+
+
+void FF_EnsurePlaying(ffFX_e fffx)
+{
+	if (fffx<0 || fffx>=fffx_NUMBEROF)
+		return;
+
+	// if user has specifically turned off force feedback at command line,
+	//	or is not using the joystick as current input method (though this can be ignored because stick has a hands-on sensor),
+	//	then forget it...
+	//
+	if (!use_ff->value)
+		return; 			
+
+
+	if (FF_IsAvailable())
+	{
+		// Have we already got this FF FX loaded?
+		//
+		for (int i=0; i<MAX_CONCURRENT_FFFXs; i++)
+		{
+			if (ffFXLoaded[i]==fffx)
+			{
+				// yes, is it playing now?
+				//
+				if (_FeelEffectPlaying(i))				
+					return;
+				
+				_FF_PlayFXSlot(i);
+				return;
+			}
+		}
+
+	// if we got this far then it ain't even loaded, so...
+	//
+	FF_Play(fffx);
+	
+	}// if (FF_IsAvailable())
+
+}// void FF_EnsurePlaying(ffFX_e fffx)
+			
+
+
+
+
+
+
+
+
+
+// strictly speaking I suppose I should check that the current player is actually using a 
+//	joystick as his current input method before sending an FF FX to it, but considering the stick
+//	will only move if he's holding it then he's daft to hold it and still use the keyboard or 
+//	something, so for now I'll just leave it in to avoid yet another IF statement...
+//
+// Since the joystick appears to run out of FX ram very quickly I'll have to use a sort of rolling
+//	buffer principle I think...
+//
+// (watch the mid-func returns if you put anything at the end!)
+//
+void _FF_Play(ffFX_e fffx)
+{
+	int i;	
+
+	if (fffx<0 || fffx>=fffx_NUMBEROF)
+		return;
+
+	// if user has specifically turned off force feedback at command line,
+	//	or is not using the joystick as current input method (though this can be ignored because stick has a hands-on sensor),
+	//	then forget it...
+	//
+	if (!use_ff->value)
+		return;
+
+	if (FF_IsAvailable())
+	{
+		// first, search for an instance of this FF FX that's already loaded, if found, start it off again...
+		//
+		for (i=0; i<MAX_CONCURRENT_FFFXs; i++)
+		{
+			if (ffFXLoaded[i]==fffx)
+			{
+				_FF_PlayFXSlot(i);
+				return;
+			}
+		}
+		// ok, so we didn't find one of these already here, so search for any FF FX that's loaded but
+		//	finished playing...
+		//
+		// (note that I prefer to re-use an existing one before looking for an empty slot so
+		//	there's less chance of the create call failing because of lack of j/s ram)
+		//
+		for (i=0; i<MAX_CONCURRENT_FFFXs; i++)
+		{
+			if (ffFXLoaded[i] != fffx_NULL)
+			{
+				// slot has an effect, has it finished?
+				//
+				if (!_FeelEffectPlaying(i))
+				{
+					_FF_ClearCreatePlayFXSlot(i,fffx);
+					return;
+				}
+
+			}// if (lpDIEffectsCreated[i])
+		}// for (i=0; i<MAX_CONCURRENT_FFFXs; i++)
+		
+		// At this point we haven't found an existing one to re-start, and there are no dead ones to reclaim, so
+		//	we just look for an empty slot...
+		//						
+		for (i=0; i<MAX_CONCURRENT_FFFXs; i++)
+		{
+			if (ffFXLoaded[i] == fffx_NULL)
+			{
+				_FF_CreatePlayFXSlot(i,fffx);
+				return;
+			}
+		}
+
+		// Hmmm, we seem to have several FF FX's playing at once and we need another. Let's just trash one of the slots
+		//	and take it over anyway. I'll use the second slot in case the first is some sort of permanent engine throb
+		//	or similar...
+		//
+		_FF_ClearCreatePlayFXSlot(1,fffx);
+
+	}// if (FF_IsAvailable())
+
+}// void FF_Play(ffFX_e fffx)
+			
+
+// hack-wrapper around original play() function because the stick keeps going slack!
+//
+void FF_Play(ffFX_e fffx)
+{
+	if (FF_IsAvailable())
+	{
+		_FF_Play(fffx);
+		FF_SetTension(ff_defaultTension->integer);
+	}
+}
+
+
+
+
+
+void _FF_ClearUsageArray(void)
+{
+	int i;
+
+	for (i=0; i<MAX_CONCURRENT_FFFXs; i++)		
+	{
+		_FF_ClearFXSlot(i);		
+	}		
+}
+
+// called from more than one place, subroutinised to avoid bugs if method changes...
+//
+void _FF_ClearFXSlot(int i)
+{
+	if (ffFXLoaded[i] != fffx_NULL)
+	{
+		_FeelClearEffect(i);
+	}
+	ffFXLoaded		[i]=fffx_NULL;
+}
+
+
+
+
+void _FF_ClearCreatePlayFXSlot(int iSlotNum, ffFX_e fffx)	
+{
+	// if this slot has a FF FX, zap it...
+	//
+
+	if (ffFXLoaded[iSlotNum] != fffx_NULL)
+	{
+		// if playing, stop it...
+		//
+		if (_FeelEffectPlaying(iSlotNum))
+		{
+			if (!_FeelStopEffect(iSlotNum))
+			{
+				return;
+			}
+		}
+	}
+
+
+	_FF_ClearFXSlot(iSlotNum);	// so slot is left clear if err creating next ffFX_e
+	_FF_CreatePlayFXSlot(iSlotNum,fffx);
+}
+
+void _FF_CreatePlayFXSlot(int iSlotNum, ffFX_e fffx)
+{
+	if (!_FeelCreateEffect(iSlotNum, fffx, g_pFeelDevice))
+	{
+		return;
+	}
+	// effect created ok, so record it's type...
+	//
+	ffFXLoaded[iSlotNum]=fffx;
+	//
+	// ... and start it playing...
+	//
+	_FF_PlayFXSlot(iSlotNum);	
+}
+
+
+
+void _FF_PlayFXSlot(int iSlotNum)
+{
+
+#define FFFX_DURATION 1	//  1 = duration (repeat count?) (could be 'INFINITE')
+#define FFFX_FLAGS    0	//	0 = special flags
+
+	if (!_FeelStartEffect(iSlotNum, FFFX_DURATION, FFFX_FLAGS))
+	{
+		return;
+	}
+
+}
+
+
+
+void FF_StopAll(void)
+{
+	if (FF_IsAvailable())
+	{
+		for (int i=0; i<MAX_CONCURRENT_FFFXs; i++)
+		{
+			if (ffFXLoaded[i] != fffx_NULL)
+			{
+				/*BOOL bRes = */_FeelStopEffect(i);
+			}
+		}
+	}
+}
+
+
+void FF_Stop(ffFX_e fffx)
+{
+	if (fffx<0 || fffx>=fffx_NUMBEROF)
+		return;
+
+	if (FF_IsAvailable())
+	{
+		for (int i=0; i<MAX_CONCURRENT_FFFXs; i++)
+		{
+			if (ffFXLoaded[i] == fffx)
+			{
+				/*BOOL bRes = */_FeelStopEffect(i);
+			}
+		}
+	}
+}
+
+
+
+
+
+// 0..n..10000
+//
+qboolean FF_SetSpring(long lSpring)
+{
+	static qboolean bFXPlaying = FALSE;
+
+	if (FF_IsAvailable())
+	{
+		// this plays a spring effect, and set the tension accordingly. Tension of 0 results in an effect-stop call
+		//
+		if (g_pFeelSpring)
+		{
+			if (lSpring)
+			{
+				if (!bFXPlaying && !g_pFeelSpring->Start())
+				{
+					return FALSE;
+				}
+				bFXPlaying = TRUE;
+
+				static POINT p={0,0};
+				g_pFeelSpring->ChangeParameters(p, lSpring);
+			}
+			else
+			{
+				if (bFXPlaying && !g_pFeelSpring->Stop())
+				{
+					return FALSE;
+				}
+				bFXPlaying = FALSE;
+			}
+
+			return TRUE;
+		}
+	}
+
+	return FALSE;
+}
+
+// tension is 0 (none) to 3 (max)...
+//
+qboolean FF_SetTension(int iTension)
+{	
+	static long lSpringValues[4] = {0, 1000, 5000, 10000};
+
+	if (iTension>3)
+		iTension=3;
+	if (iTension<0)
+		iTension=0;	
+
+	return FF_SetSpring(lSpringValues[iTension]);
+}	
+
+///////////////////////// eof //////////////////////////////
+
diff --git a/code/win32/FeelIt/fffx_feel.cpp b/code/win32/FeelIt/fffx_feel.cpp
new file mode 100644
index 0000000..bb34457
--- /dev/null
+++ b/code/win32/FeelIt/fffx_feel.cpp
@@ -0,0 +1,689 @@
+// Filename:-	fffx_Feel.cpp	(Force-Feedback FX)
+
+#include "../../client/client.h"
+//#include "stdafx.h"
+//#include "resource.h"
+#include "fffx_feel.h"
+
+extern cvar_t* js_ffmult;
+
+
+#define MAX_EFFECTS_IN_COMPOUND 3    // This needs to be at least 3 for now.  I can add array bounds checking later
+
+CFeelEffect* g_pEffects[MAX_CONCURRENT_FFFXs][MAX_EFFECTS_IN_COMPOUND];
+
+void _FeelInitEffects()
+{
+	for (int i = 0; i < MAX_CONCURRENT_FFFXs; i++)
+	{
+		for (int j = 0; j < MAX_EFFECTS_IN_COMPOUND; j++)
+		{
+			g_pEffects[i][j] = NULL;
+		}
+	}
+}
+
+BOOL _FeelCreateEffect(int iSlotNum, ffFX_e fffx, CFeelDevice* pFeelDevice)
+{
+	BOOL success = TRUE;
+	FEELIT_ENVELOPE envelope;
+	envelope.dwSize = sizeof(FEELIT_ENVELOPE);
+
+	switch (fffx)
+	{
+	case fffx_RandomNoise:
+		g_pEffects[iSlotNum][0] = new CFeelPeriodic(GUID_Feel_Square);
+		if (!((CFeelPeriodic*)(g_pEffects[iSlotNum][0]))->InitializePolar(pFeelDevice,
+												7500 * js_ffmult->value,	// magnitude
+												95,	// period
+												10000,	// duration
+												0,	// angle
+												0,	// offset
+												0,	// phase
+												NULL))	// envelope
+			success = FALSE;
+		g_pEffects[iSlotNum][1] = new CFeelPeriodic(GUID_Feel_SawtoothDown);
+		if (!((CFeelPeriodic*)(g_pEffects[iSlotNum][1]))->InitializePolar(pFeelDevice,
+												8300 * js_ffmult->value,	// magnitude
+												160,	// period
+												10000,	// duration
+												9000,	// angle
+												0,	// offset
+												0,	// phase
+												NULL))	// envelope
+			success = FALSE;
+		g_pEffects[iSlotNum][2] = new CFeelPeriodic(GUID_Feel_Square);
+		if (!((CFeelPeriodic*)(g_pEffects[iSlotNum][2]))->InitializePolar(pFeelDevice,
+												8300 * js_ffmult->value,	// magnitude
+												34,	// period
+												10000,	// duration
+												31000,	// angle
+												0,	// offset
+												0,	// phase
+												NULL))	// envelope
+								
+			success = FALSE;
+		break;
+	case fffx_AircraftCarrierTakeOff:
+		envelope.dwAttackLevel = 0;
+		envelope.dwAttackTime = 600000;
+		envelope.dwFadeLevel = 0;
+		envelope.dwFadeTime = 750000;
+
+		g_pEffects[iSlotNum][0] = new CFeelConstant;
+		if (!((CFeelConstant*)(g_pEffects[iSlotNum][0]))->InitializePolar(pFeelDevice,
+												0,	// angle
+												2500,	// duration
+												10000 * js_ffmult->value,	// magnitude
+												&envelope))// envelope
+
+			success = FALSE;
+		break;
+	case fffx_BasketballDribble:
+		envelope.dwAttackLevel = 0;
+		envelope.dwAttackTime = 40000;
+		envelope.dwFadeLevel = 0;
+		envelope.dwFadeTime = 30000;
+
+		g_pEffects[iSlotNum][0] = new CFeelConstant;
+		if (!((CFeelConstant*)(g_pEffects[iSlotNum][0]))->InitializePolar(pFeelDevice,
+												18000,	// angle
+												150,	// duration
+												5000 * js_ffmult->value,	// magnitude
+												&envelope))// envelope
+
+			success = FALSE;
+		break;
+	case fffx_CarEngineIdle:
+		g_pEffects[iSlotNum][0] = new CFeelPeriodic(GUID_Feel_Sine);
+		if (!((CFeelPeriodic*)(g_pEffects[iSlotNum][0]))->InitializePolar(pFeelDevice,
+												2500 * js_ffmult->value,	// magnitude
+												50,	// period
+												10000,	// duration
+												0,	// angle
+												0,	// offset
+												0,	// phase
+												NULL))	// envelope
+			success = FALSE;
+		break;
+	case fffx_ChainsawIdle:
+		g_pEffects[iSlotNum][0] = new CFeelPeriodic(GUID_Feel_Square);
+		if (!((CFeelPeriodic*)(g_pEffects[iSlotNum][0]))->InitializePolar(pFeelDevice,
+												3600 * js_ffmult->value,	// magnitude
+												60,	// period
+												1000,	// duration
+												9000,	// angle
+												0,	// offset
+												0,	// phase
+												NULL))	// envelope
+			success = FALSE;
+		g_pEffects[iSlotNum][1] = new CFeelPeriodic(GUID_Feel_Square);
+		if (!((CFeelPeriodic*)(g_pEffects[iSlotNum][1]))->InitializePolar(pFeelDevice,
+												4000 * js_ffmult->value,	// magnitude
+												100,	// period
+												1000,	// duration
+												18000,	// angle
+												4000,	// offset
+												0,	// phase
+												NULL))	// envelope
+			success = FALSE;
+		break;
+	case fffx_ChainsawInAction:
+		g_pEffects[iSlotNum][0] = new CFeelPeriodic(GUID_Feel_Square);
+		if (!((CFeelPeriodic*)(g_pEffects[iSlotNum][0]))->InitializePolar(pFeelDevice,
+												6700 * js_ffmult->value,	// magnitude
+												60,	// period
+												1000,	// duration
+												9000,	// angle
+												0,	// offset
+												0,	// phase
+												NULL))	// envelope
+			success = FALSE;
+		g_pEffects[iSlotNum][1] = new CFeelPeriodic(GUID_Feel_Square);
+		if (!((CFeelPeriodic*)(g_pEffects[iSlotNum][1]))->InitializePolar(pFeelDevice,
+												5000 * js_ffmult->value,	// magnitude
+												100,	// period
+												1000,	// duration
+												18000,	// angle
+												5000,	// offset
+												0,	// phase
+												NULL))	// envelope
+			success = FALSE;
+		g_pEffects[iSlotNum][2] = new CFeelPeriodic(GUID_Feel_Square);
+		if (!((CFeelPeriodic*)(g_pEffects[iSlotNum][2]))->InitializePolar(pFeelDevice,
+												10000 * js_ffmult->value,	// magnitude
+												340,	// period
+												1000,	// duration
+												18000,	// angle
+												4000,	// offset
+												0,	// phase
+												NULL))	// envelope
+			success = FALSE;
+		break;
+	case fffx_DieselEngineIdle:
+		g_pEffects[iSlotNum][0] = new CFeelPeriodic(GUID_Feel_SawtoothDown);
+		if (!((CFeelPeriodic*)(g_pEffects[iSlotNum][0]))->InitializePolar(pFeelDevice,
+												2000 * js_ffmult->value,	// magnitude
+												250,	// period
+												10000,	// duration
+												18000,	// angle
+												0,	// offset
+												0,	// phase
+												NULL))	// envelope
+			success = FALSE;
+		g_pEffects[iSlotNum][1] = new CFeelPeriodic(GUID_Feel_Sine);
+		if (!((CFeelPeriodic*)(g_pEffects[iSlotNum][1]))->InitializePolar(pFeelDevice,
+												4000 * js_ffmult->value,	// magnitude
+												125,	// period
+												10000,	// duration
+												18000,	// angle
+												1500,	// offset
+												0,	// phase
+												NULL))	// envelope
+			success = FALSE;
+		break;
+	case fffx_Jump:
+		g_pEffects[iSlotNum][0] = new CFeelPeriodic(GUID_Feel_Square);
+		if (!((CFeelPeriodic*)(g_pEffects[iSlotNum][0]))->InitializePolar(pFeelDevice,
+												5000 * js_ffmult->value,	// magnitude
+												500,	// period
+												300,	// duration
+												18000,	// angle
+												0,	// offset
+												0,	// phase
+												NULL))	// envelope
+			success = FALSE;
+		break;
+	case fffx_Land:
+		envelope.dwAttackLevel = 6000;
+		envelope.dwAttackTime = 200000;
+		envelope.dwFadeLevel = 3000;
+		envelope.dwFadeTime = 50000;
+
+		g_pEffects[iSlotNum][0] = new CFeelPeriodic(GUID_Feel_Square);
+		if (!((CFeelPeriodic*)(g_pEffects[iSlotNum][0]))->InitializePolar(pFeelDevice,
+												1000 * js_ffmult->value,	// magnitude
+												750,	// period
+												250,	// duration
+												0,	// angle
+												0,	// offset
+												0,	// phase
+												&envelope))	// envelope
+			success = FALSE;
+		break;
+	case fffx_MachineGun:
+		g_pEffects[iSlotNum][0] = new CFeelPeriodic(GUID_Feel_Square);
+		if (!((CFeelPeriodic*)(g_pEffects[iSlotNum][0]))->InitializePolar(pFeelDevice,
+												3500 * js_ffmult->value,	// magnitude
+												70,	// period
+												1000,	// duration
+												0,	// angle
+												2500,	// offset
+												0,	// phase
+												NULL))	// envelope
+			success = FALSE;
+		break;
+	case fffx_Punched:
+		envelope.dwAttackLevel = 0;
+		envelope.dwAttackTime = 0;
+		envelope.dwFadeLevel = 0;
+		envelope.dwFadeTime = 50000;
+
+		g_pEffects[iSlotNum][0] = new CFeelPeriodic(GUID_Feel_Square);
+		if (!((CFeelPeriodic*)(g_pEffects[iSlotNum][0]))->InitializePolar(pFeelDevice,
+												8000 * js_ffmult->value,	// magnitude
+												130,	// period
+												70,	// duration
+												0,	// angle
+												0,	// offset
+												0,	// phase
+												&envelope))	// envelope
+			success = FALSE;
+		break;
+	case fffx_RocketLaunch:
+		envelope.dwAttackLevel = 0;
+		envelope.dwAttackTime = 200000;
+		envelope.dwFadeLevel = 0;
+		envelope.dwFadeTime = 0;
+
+		g_pEffects[iSlotNum][1] = new CFeelConstant;
+		if (!((CFeelConstant*)(g_pEffects[iSlotNum][1]))->InitializePolar(pFeelDevice,
+												18000,	// angle
+												400,	// duration
+												10000 * js_ffmult->value,	// magnitude
+												&envelope))// envelope
+			success = FALSE;
+
+		envelope.dwAttackLevel = 0;
+		envelope.dwAttackTime = 300000;
+		envelope.dwFadeLevel = 0;
+		envelope.dwFadeTime = 100000;
+
+		g_pEffects[iSlotNum][0] = new CFeelConstant;
+		if (!((CFeelConstant*)(g_pEffects[iSlotNum][0]))->InitializePolar(pFeelDevice,
+												0,	// angle
+												1000,	// duration
+												10000 * js_ffmult->value,	// magnitude
+												&envelope))// envelope
+			success = FALSE;
+		break;
+	case fffx_SecretDoor:
+		envelope.dwAttackLevel = 0;
+		envelope.dwAttackTime = 400000;
+		envelope.dwFadeLevel = 0;
+		envelope.dwFadeTime = 0;
+
+		g_pEffects[iSlotNum][0] = new CFeelConstant;
+		if (!((CFeelConstant*)(g_pEffects[iSlotNum][0]))->InitializePolar(pFeelDevice,
+												0,	// angle
+												400,	// duration
+												10000 * js_ffmult->value,	// magnitude
+												&envelope))// envelope
+
+			success = FALSE;
+		break;
+	case fffx_SwitchClick:
+		g_pEffects[iSlotNum][0] = new CFeelConstant;
+		if (!((CFeelConstant*)(g_pEffects[iSlotNum][0]))->InitializePolar(pFeelDevice,
+												18000,	// angle
+												50,	// duration
+												7000 * js_ffmult->value,	// magnitude
+												NULL))// envelope
+
+			success = FALSE;
+		break;
+	case fffx_WindGust:
+		g_pEffects[iSlotNum][0] = new CFeelPeriodic(GUID_Feel_Sine);
+		if (!((CFeelPeriodic*)(g_pEffects[iSlotNum][0]))->InitializePolar(pFeelDevice,
+												6000 * js_ffmult->value,	// magnitude
+												1000,	// period
+												500,	// duration
+												18000,	// angle
+												0,	// offset
+												0,	// phase
+												NULL))	// envelope
+			success = FALSE;
+		break;
+	case fffx_WindShear:
+		envelope.dwAttackLevel = 0;
+		envelope.dwAttackTime = 1500000;
+		envelope.dwFadeLevel = 0;
+		envelope.dwFadeTime = 500000;
+
+		g_pEffects[iSlotNum][0] = new CFeelPeriodic(GUID_Feel_SawtoothDown);
+		if (!((CFeelPeriodic*)(g_pEffects[iSlotNum][0]))->InitializePolar(pFeelDevice,
+												10000 * js_ffmult->value,	// magnitude
+												80,	// period
+												2000,	// duration
+												0,	// angle
+												0,	// offset
+												0,	// phase
+												&envelope))	// envelope
+			success = FALSE;
+		break;
+	case fffx_Pistol:
+		g_pEffects[iSlotNum][0] = new CFeelPeriodic(GUID_Feel_Square);
+		if (!((CFeelPeriodic*)(g_pEffects[iSlotNum][0]))->InitializePolar(pFeelDevice,
+												8500 * js_ffmult->value,	// magnitude
+												130,	// period
+												50,	// duration
+												0,	// angle
+												0,	// offset
+												0,	// phase
+												NULL))	// envelope
+			success = FALSE;
+		break;
+	case fffx_Shotgun:
+		g_pEffects[iSlotNum][0] = new CFeelPeriodic(GUID_Feel_Square);
+		if (!((CFeelPeriodic*)(g_pEffects[iSlotNum][0]))->InitializePolar(pFeelDevice,
+												6000 * js_ffmult->value,	// magnitude
+												100,	// period
+												100,	// duration
+												18000,	// angle
+												0,	// offset
+												0,	// phase
+												NULL))	// envelope
+			success = FALSE;
+
+		envelope.dwAttackLevel = 0;
+		envelope.dwAttackTime = 100000;
+		envelope.dwFadeLevel = 0;
+		envelope.dwFadeTime = 100000;
+
+		g_pEffects[iSlotNum][1] = new CFeelConstant;
+		if (!((CFeelConstant*)(g_pEffects[iSlotNum][1]))->InitializePolar(pFeelDevice,
+												0,	// angle
+												300,	// duration
+												7000 * js_ffmult->value,	// magnitude
+												&envelope))// envelope
+			success = FALSE;
+		break;
+	case fffx_Laser1:
+		g_pEffects[iSlotNum][0] = new CFeelPeriodic(GUID_Feel_Sine);
+		if (!((CFeelPeriodic*)(g_pEffects[iSlotNum][0]))->InitializePolar(pFeelDevice,
+												6000 * js_ffmult->value,	// magnitude
+												25,	// period
+												1000,	// duration
+												18000,	// angle
+												2000,	// offset
+												0,	// phase
+												NULL))	// envelope
+			success = FALSE;
+		break;
+	case fffx_Laser2:
+		g_pEffects[iSlotNum][0] = new CFeelPeriodic(GUID_Feel_Sine);
+		if (!((CFeelPeriodic*)(g_pEffects[iSlotNum][0]))->InitializePolar(pFeelDevice,
+												5000 * js_ffmult->value,	// magnitude
+												25,	// period
+												1000,	// duration
+												0,	// angle
+												3000,	// offset
+												0,	// phase
+												NULL))	// envelope
+			success = FALSE;
+		break;
+	case fffx_Laser3:
+		g_pEffects[iSlotNum][0] = new CFeelPeriodic(GUID_Feel_Sine);
+		if (!((CFeelPeriodic*)(g_pEffects[iSlotNum][0]))->InitializePolar(pFeelDevice,
+												5000 * js_ffmult->value,	// magnitude
+												25,	// period
+												1000,	// duration
+												9000,	// angle
+												0,	// offset
+												0,	// phase
+												NULL))	// envelope
+			success = FALSE;
+		break;
+	case fffx_Laser4:
+		g_pEffects[iSlotNum][0] = new CFeelPeriodic(GUID_Feel_Sine);
+		if (!((CFeelPeriodic*)(g_pEffects[iSlotNum][0]))->InitializePolar(pFeelDevice,
+												7000 * js_ffmult->value,	// magnitude
+												25,	// period
+												1000,	// duration
+												9000,	// angle
+												0,	// offset
+												0,	// phase
+												NULL))	// envelope
+			success = FALSE;
+		break;
+	case fffx_Laser5:
+		g_pEffects[iSlotNum][0] = new CFeelPeriodic(GUID_Feel_Sine);
+		if (!((CFeelPeriodic*)(g_pEffects[iSlotNum][0]))->InitializePolar(pFeelDevice,
+												5000 * js_ffmult->value,	// magnitude
+												25,	// period
+												1000,	// duration
+												0,	// angle
+												0,	// offset
+												0,	// phase
+												NULL))	// envelope
+			success = FALSE;
+		break;
+	case fffx_Laser6:
+		g_pEffects[iSlotNum][0] = new CFeelPeriodic(GUID_Feel_Sine);
+		if (!((CFeelPeriodic*)(g_pEffects[iSlotNum][0]))->InitializePolar(pFeelDevice,
+												5000 * js_ffmult->value,	// magnitude
+												25,	// period
+												1000,	// duration
+												0,	// angle
+												2000,	// offset
+												0,	// phase
+												NULL))	// envelope
+			success = FALSE;
+		break;
+	case fffx_OutOfAmmo:
+		g_pEffects[iSlotNum][0] = new CFeelConstant;
+		if (!((CFeelConstant*)(g_pEffects[iSlotNum][0]))->InitializePolar(pFeelDevice,
+												18000,	// angle
+												10,	// duration
+												6000 * js_ffmult->value,	// magnitude
+												NULL))// envelope
+
+			success = FALSE;
+		break;
+	case fffx_LightningGun:
+		g_pEffects[iSlotNum][0] = new CFeelPeriodic(GUID_Feel_Sine);
+		if (!((CFeelPeriodic*)(g_pEffects[iSlotNum][0]))->InitializePolar(pFeelDevice,
+												1500 * js_ffmult->value,	// magnitude
+												250,	// period
+												1000,	// duration
+												18000,	// angle
+												0,	// offset
+												0,	// phase
+												NULL))	// envelope
+
+			success = FALSE;
+		g_pEffects[iSlotNum][1] = new CFeelPeriodic(GUID_Feel_Sine);
+		if (!((CFeelPeriodic*)(g_pEffects[iSlotNum][1]))->InitializePolar(pFeelDevice,
+												6000 * js_ffmult->value,	// magnitude
+												50,	// period
+												1000,	// duration
+												0,	// angle
+												0,	// offset
+												0,	// phase
+												NULL))	// envelope
+			success = FALSE;
+		break;
+	case fffx_Missile:
+		envelope.dwAttackLevel = 0;
+		envelope.dwAttackTime = 500000;
+		envelope.dwFadeLevel = 0;
+		envelope.dwFadeTime = 200000;
+
+		g_pEffects[iSlotNum][0] = new CFeelConstant;
+		if (!((CFeelConstant*)(g_pEffects[iSlotNum][0]))->InitializePolar(pFeelDevice,
+												0,	// angle
+												250,	// duration
+												10000 * js_ffmult->value,	// magnitude
+												&envelope))// envelope
+
+			success = FALSE;
+		break;
+	case fffx_GatlingGun:
+		g_pEffects[iSlotNum][0] = new CFeelPeriodic(GUID_Feel_SawtoothDown);
+		if (!((CFeelPeriodic*)(g_pEffects[iSlotNum][0]))->InitializePolar(pFeelDevice,
+												6000 * js_ffmult->value,	// magnitude
+												100,	// period
+												1000,	// duration
+												0,	// angle
+												1000,	// offset
+												0,	// phase
+												NULL))	// envelope
+			success = FALSE;
+		break;
+	case fffx_ShortPlasma:
+		envelope.dwAttackLevel = 7000;
+		envelope.dwAttackTime = 250000;
+		envelope.dwFadeLevel = 0;
+		envelope.dwFadeTime = 0;
+
+		g_pEffects[iSlotNum][0] = new CFeelConstant;
+		if (!((CFeelConstant*)(g_pEffects[iSlotNum][0]))->InitializePolar(pFeelDevice,
+												0,	// angle
+												250,	// duration
+												0,	// magnitude
+												&envelope))// envelope
+
+			success = FALSE;
+
+		envelope.dwAttackLevel = 0;
+		envelope.dwAttackTime = 0;
+		envelope.dwFadeLevel = 0;
+		envelope.dwFadeTime = 250000;
+
+		g_pEffects[iSlotNum][1] = new CFeelPeriodic(GUID_Feel_Sine);
+		if (!((CFeelPeriodic*)(g_pEffects[iSlotNum][1]))->InitializePolar(pFeelDevice,
+												5000 * js_ffmult->value,	// magnitude
+												30,	// period
+												250,	// duration
+												0,	// angle
+												0,	// offset
+												0,	// phase
+												&envelope))	// envelope
+			success = FALSE;
+		break;
+	case fffx_PlasmaCannon1:
+		g_pEffects[iSlotNum][0] = new CFeelPeriodic(GUID_Feel_Square);
+		if (!((CFeelPeriodic*)(g_pEffects[iSlotNum][0]))->InitializePolar(pFeelDevice,
+												5000 * js_ffmult->value,	// magnitude
+												500,	// period
+												400,	// duration
+												18000,	// angle
+												-5000,	// offset
+												0,	// phase
+												NULL))	// envelope
+
+			success = FALSE;
+
+		envelope.dwAttackLevel = 0;
+		envelope.dwAttackTime = 250000;
+		envelope.dwFadeLevel = 0;
+		envelope.dwFadeTime = 0;
+
+		g_pEffects[iSlotNum][1] = new CFeelPeriodic(GUID_Feel_Sine);
+		if (!((CFeelPeriodic*)(g_pEffects[iSlotNum][1]))->InitializePolar(pFeelDevice,
+												6000 * js_ffmult->value,	// magnitude
+												30,	// period
+												250,	// duration
+												0,	// angle
+												0,	// offset
+												0,	// phase
+												&envelope))	// envelope
+			success = FALSE;
+		break;
+	case fffx_PlasmaCannon2:
+		g_pEffects[iSlotNum][0] = new CFeelPeriodic(GUID_Feel_Square);
+		if (!((CFeelPeriodic*)(g_pEffects[iSlotNum][0]))->InitializePolar(pFeelDevice,
+												4000 * js_ffmult->value,	// magnitude
+												1000,	// period
+												800,	// duration
+												18000,	// angle
+												-4000,	// offset
+												0,	// phase
+												NULL))	// envelope
+			success = FALSE;
+
+		envelope.dwAttackLevel = 0;
+		envelope.dwAttackTime = 500000;
+		envelope.dwFadeLevel = 0;
+		envelope.dwFadeTime = 0;
+
+		g_pEffects[iSlotNum][1] = new CFeelPeriodic(GUID_Feel_Sine);
+		if (!((CFeelPeriodic*)(g_pEffects[iSlotNum][1]))->InitializePolar(pFeelDevice,
+												8000 * js_ffmult->value,	// magnitude
+												35,	// period
+												500,	// duration
+												0,	// angle
+												0,	// offset
+												0,	// phase
+												&envelope))	// envelope
+			success = FALSE;
+		break;
+	case fffx_Cannon:
+		g_pEffects[iSlotNum][0] = new CFeelPeriodic(GUID_Feel_Square);
+		if (!((CFeelPeriodic*)(g_pEffects[iSlotNum][0]))->InitializePolar(pFeelDevice,
+												8000 * js_ffmult->value,	// magnitude
+												100,	// period
+												100,	// duration
+												18000,	// angle
+												0,	// offset
+												0,	// phase
+												NULL))	// envelope
+			success = FALSE;
+
+		envelope.dwAttackLevel = 0;
+		envelope.dwAttackTime = 100000;
+		envelope.dwFadeLevel = 0;
+		envelope.dwFadeTime = 100000;
+
+		g_pEffects[iSlotNum][1] = new CFeelConstant;
+		if (!((CFeelConstant*)(g_pEffects[iSlotNum][1]))->InitializePolar(pFeelDevice,
+												0,	// angle
+												300,	// duration
+												10000 * js_ffmult->value,	// magnitude
+												&envelope))// envelope
+			success = FALSE;
+		break;
+	}// switch (fffx)
+
+	// if any effect in the compound failed to initialize, dump the lot
+	if (!success)
+	{
+		for (int i = 0; i < MAX_EFFECTS_IN_COMPOUND; i++)
+		{
+			if (g_pEffects[iSlotNum][i])
+			{
+				delete g_pEffects[iSlotNum][i];
+				g_pEffects[iSlotNum][i] = NULL;
+			}
+		}
+	}
+
+	return success;
+}
+
+BOOL _FeelStartEffect(int iSlotNum, DWORD dwIterations, DWORD dwFlags)
+{
+	BOOL success = TRUE;
+
+	for (int i = 0; i < MAX_EFFECTS_IN_COMPOUND; i++)
+	{
+		if (g_pEffects[iSlotNum][i])
+		{
+			if (!g_pEffects[iSlotNum][i]->Start(dwIterations, dwFlags))
+				success = FALSE;
+		}
+	}
+
+	return success;
+}
+
+BOOL _FeelEffectPlaying(int iSlotNum)
+{
+	DWORD	dwFlags;	
+	dwFlags = 0;
+
+	// check to see if any effect within the compound is still playing
+	for (int i = 0; i < MAX_EFFECTS_IN_COMPOUND; i++)
+	{
+		if (g_pEffects[iSlotNum][i])
+		{
+			g_pEffects[iSlotNum][i]->GetStatus(&dwFlags);
+			if (dwFlags & FEELIT_FSTATUS_PLAYING)
+				return TRUE;
+		}
+	}
+
+	return FALSE;
+}
+
+BOOL _FeelStopEffect(int iSlotNum)
+{
+	BOOL success = TRUE;
+
+	for (int i = 0; i < MAX_EFFECTS_IN_COMPOUND; i++)
+	{
+		if (g_pEffects[iSlotNum][i])
+		{
+			if (!g_pEffects[iSlotNum][i]->Stop())
+				success = FALSE;
+		}
+	}
+
+	return success;
+}
+
+BOOL _FeelClearEffect(int iSlotNum)
+{
+	for (int i = 0; i < MAX_EFFECTS_IN_COMPOUND; i++)
+	{
+		if (g_pEffects[iSlotNum][i])
+		{
+			delete g_pEffects[iSlotNum][i];
+			g_pEffects[iSlotNum][i] = NULL;
+		}
+	}
+
+	return TRUE;
+}
+
+
diff --git a/code/win32/FeelIt/fffx_feel.h b/code/win32/FeelIt/fffx_feel.h
new file mode 100644
index 0000000..7f1661d
--- /dev/null
+++ b/code/win32/FeelIt/fffx_feel.h
@@ -0,0 +1,29 @@
+// Filename:-	fffx_Feel.h	(Force-Feedback FX)
+// ADDED BY IMMRESION
+
+#ifndef FFFX_FEEL_H
+#define FFFX_FEEL_H
+
+#include "../../client/fffx.h"
+#include "ffc.h"
+
+/////////////////////////////////////////////////////////////////////////
+/*  These functions were created to make the code a little easier to read.
+ *  _FeelCreateEffect is quite long since it needs to create different
+ *  kinds of effects.  When playing effects, the number of iterations
+ *  may not act as expected.  I can't use CFeelCompound effects since I
+ *  don't have a Project (which requires an ifr file at this point).  So,
+ *  I simulate compound effects with arrays.  If an effect has multiple
+ *  CFeelEffect in it, each CFeelEffect will be started individually with
+ *  that number of iterations.  The only case where this will act strange
+ *  is when the CFeelEffects have different durations.
+*/
+/////////////////////////////////////////////////////////////////////////
+void _FeelInitEffects();
+BOOL _FeelCreateEffect(int iSlotNum, ffFX_e fffx, CFeelDevice* pFeelDevice);
+BOOL _FeelStartEffect(int iSlotNum, DWORD dwIterations, DWORD dwFlags);
+BOOL _FeelEffectPlaying(int iSlotNum);
+BOOL _FeelStopEffect(int iSlotNum);
+BOOL _FeelClearEffect(int iSlotNum);
+
+#endif	// #ifndef FFFX_FEEL_H
diff --git a/code/win32/FeelIt/vssver.scc b/code/win32/FeelIt/vssver.scc
new file mode 100644
index 0000000..0e2ef87
Binary files /dev/null and b/code/win32/FeelIt/vssver.scc differ
diff --git a/code/win32/background.bmp b/code/win32/background.bmp
new file mode 100644
index 0000000..88b3dab
Binary files /dev/null and b/code/win32/background.bmp differ
diff --git a/code/win32/bink.h b/code/win32/bink.h
new file mode 100644
index 0000000..4a4b273
--- /dev/null
+++ b/code/win32/bink.h
@@ -0,0 +1,620 @@
+#ifndef BINKH
+#define BINKH
+
+#define BINKVERSION "1.0p"
+#define BINKDATE    "2000-06-26"
+
+#ifndef __RADRES__
+
+#include "rad.h"				
+
+RADDEFSTART
+
+typedef struct BINK PTR4* HBINK;
+
+typedef s32  (RADLINK PTR4* BINKIOOPEN)         (struct BINKIO PTR4* Bnkio, const char PTR4 *name, u32 flags);
+typedef u32  (RADLINK PTR4* BINKIOREADHEADER)   (struct BINKIO PTR4* Bnkio, s32 Offset, void PTR4* Dest,u32 Size);
+typedef u32  (RADLINK PTR4* BINKIOREADFRAME)    (struct BINKIO PTR4* Bnkio, u32 Framenum,s32 origofs,void PTR4* dest,u32 size);
+typedef u32  (RADLINK PTR4* BINKIOGETBUFFERSIZE)(struct BINKIO PTR4* Bnkio, u32 Size);
+typedef void (RADLINK PTR4* BINKIOSETINFO)      (struct BINKIO PTR4* Bnkio, void PTR4* Buf,u32 Size,u32 FileSize,u32 simulate);
+typedef u32  (RADLINK PTR4* BINKIOIDLE)         (struct BINKIO PTR4* Bnkio);
+typedef void (RADLINK PTR4* BINKIOCLOSE)        (struct BINKIO PTR4* Bnkio);
+
+typedef struct BINKIO {
+  BINKIOREADHEADER ReadHeader;
+  BINKIOREADFRAME  ReadFrame;
+  BINKIOGETBUFFERSIZE GetBufferSize;
+  BINKIOSETINFO SetInfo;
+  BINKIOIDLE Idle;
+  BINKIOCLOSE Close;
+  HBINK bink;
+  volatile u32 ReadError;
+  volatile u32 DoingARead;
+  volatile u32 BytesRead;
+  volatile u32 Working;
+  volatile u32 TotalTime;
+  volatile u32 ForegroundTime;
+  volatile u32 IdleTime;
+  volatile u32 ThreadTime;
+  volatile u32 BufSize;
+  volatile u32 BufHighUsed;
+  volatile u32 CurBufSize;
+  volatile u32 CurBufUsed;
+  volatile u8 iodata[128];
+} BINKIO;
+
+typedef s32  (RADLINK PTR4* BINKSNDOPEN)     (struct BINKSND PTR4* BnkSnd, u32 freq, s32 bits, s32 chans, u32 flags, HBINK bink);
+typedef s32  (RADLINK PTR4* BINKSNDREADY)    (struct BINKSND PTR4* BnkSnd);
+typedef s32  (RADLINK PTR4* BINKSNDLOCK)     (struct BINKSND PTR4* BnkSnd, u8 PTR4* PTR4* addr, u32 PTR4* len);
+typedef s32  (RADLINK PTR4* BINKSNDUNLOCK)   (struct BINKSND PTR4* BnkSnd, u32 filled);
+typedef void (RADLINK PTR4* BINKSNDVOLUME)   (struct BINKSND PTR4* BnkSnd, s32 volume);
+typedef void (RADLINK PTR4* BINKSNDPAN)      (struct BINKSND PTR4* BnkSnd, s32 pan);
+typedef s32  (RADLINK PTR4* BINKSNDONOFF)    (struct BINKSND PTR4* BnkSnd, s32 status);
+typedef s32  (RADLINK PTR4* BINKSNDPAUSE)    (struct BINKSND PTR4* BnkSnd, s32 status);
+typedef void (RADLINK PTR4* BINKSNDCLOSE)    (struct BINKSND PTR4* BnkSnd);
+
+typedef BINKSNDOPEN  (RADLINK PTR4* BINKSNDSYSOPEN) (u32 param);
+
+typedef struct BINKSND {
+  BINKSNDREADY Ready;
+  BINKSNDLOCK Lock;
+  BINKSNDUNLOCK Unlock;
+  BINKSNDVOLUME Volume;
+  BINKSNDPAN Pan;
+  BINKSNDPAUSE Pause;
+  BINKSNDONOFF SetOnOff;
+  BINKSNDCLOSE Close;
+  u32 BestSizeIn16;
+  u32 SoundDroppedOut;
+  s32 OnOff;
+  u32 Latency;
+  u32 freq;
+  s32 bits,chans;
+  u8 snddata[128];
+} BINKSND;
+
+typedef struct BINKRECT {
+  s32 Left,Top,Width,Height;
+} BINKRECT;
+
+#define BINKMAXDIRTYRECTS 8
+
+typedef struct BUNDLEPOINTERS {
+  void* typeptr;
+  void* type16ptr;
+  void* colorptr;
+  void* bits2ptr;
+  void* motionXptr;
+  void* motionYptr;
+  void* dctptr;
+  void* mdctptr;
+  void* patptr;
+} BUNDLEPOINTERS;
+
+
+typedef struct BINK {
+  u32 Width;             // Width (1 based, 640 for example)
+  u32 Height;            // Height (1 based, 480 for example)
+  u32 Frames;            // Number of frames (1 based, 100 = 100 frames)
+  u32 FrameNum;          // Frame to *be* displayed (1 based)
+  u32 LastFrameNum;      // Last frame decompressed or skipped (1 based)
+
+  u32 FrameRate;         // Frame Rate Numerator
+  u32 FrameRateDiv;      // Frame Rate Divisor (frame rate=numerator/divisor)
+
+  u32 ReadError;         // Non-zero if a read error has ocurred
+  u32 OpenFlags;         // flags used on open
+  u32 BinkType;          // Bink flags
+
+  u32 Size;              // size of file
+  u32 FrameSize;         // The current frame's size in bytes
+  u32 SndSize;           // The current frame sound tracks' size in bytes
+
+  BINKRECT FrameRects[BINKMAXDIRTYRECTS];// Dirty rects from BinkGetRects
+  s32 NumRects;
+
+  u32 PlaneNum;          // which set of planes is current
+  void PTR4* YPlane[2];  // pointer to the uncompressed Y (Cr and Cr follow)
+  void PTR4* APlane[2];  // decompressed alpha plane (if present)
+  u32 YWidth;            // widths and heights of the video planes
+  u32 YHeight;
+  u32 UVWidth;
+  u32 UVHeight;
+
+  void PTR4* MaskPlane;  // pointer to the mask plane (Ywidth/16*Yheight/16)
+  u32 MaskPitch;         // Mask Pitch
+  u32 MaskLength;        // total length of the mask plane
+
+  u32 LargestFrameSize;  // Largest frame size
+  u32 InternalFrames;    // how many frames were potentially compressed
+
+  s32 NumTracks;         // how many tracks
+
+  u32 Highest1SecRate;   // Highest 1 sec data rate
+  u32 Highest1SecFrame;  // Highest 1 sec data rate starting frame
+
+  s32 Paused;            // is the bink movie paused?
+
+  u32 BackgroundThread;  // handle to background thread
+
+  // everything below is for internal Bink use
+
+  void PTR4* compframe;       // compressed frame data
+  void PTR4* preloadptr;      // preloaded compressed frame data
+  u32* frameoffsets;          // offsets of each of the frames
+
+  BINKIO bio;                 // IO structure
+  u8 PTR4* ioptr;             // io buffer ptr
+  u32 iosize;                 // io buffer size
+  u32 decompwidth;            // width not include scaling
+  u32 decompheight;           // height not include scaling
+
+  s32 trackindex;             // track index
+  u32 PTR4* tracksizes;       // largest single frame of track
+  u32 PTR4* tracktypes;       // type of each sound track
+  s32 PTR4* trackIDs;         // external track numbers
+
+  u32 numrects;               // number of rects from BinkGetRects
+
+  u32 playedframes;           // how many frames have we played
+  u32 firstframetime;         // very first frame start
+  u32 startframetime;         // start frame start
+  u32 startblittime;          // start of blit period
+  u32 startsynctime;          // start of synched time
+  u32 startsyncframe;         // frame of startsynctime
+  u32 twoframestime;          // two frames worth of time
+  u32 entireframetime;        // entire frame time
+
+  u32 slowestframetime;       // slowest frame in ms
+  u32 slowestframe;           // slowest frame number
+  u32 slowest2frametime;      // second slowest frame in ms
+  u32 slowest2frame;          // second slowest frame
+
+  u32 soundon;                // sound turned on?
+  u32 videoon;                // video turned on?
+
+  u32 totalmem;               // total memory used
+  u32 timevdecomp;            // total time decompressing video
+  u32 timeadecomp;            // total time decompressing audio
+  u32 timeblit;               // total time blitting
+  u32 timeopen;               // total open time
+
+  u32 fileframerate;          // frame rate originally in the file
+  u32 fileframeratediv;
+
+  volatile u32 threadcontrol; // controls the background reading thread
+
+  u32 runtimeframes;          // max frames for runtime analysis
+  u32 runtimemoveamt;         // bytes to move each frame
+  u32 PTR4* rtframetimes;     // start times for runtime frames
+  u32 PTR4* rtadecomptimes;   // decompress times for runtime frames
+  u32 PTR4* rtvdecomptimes;   // decompress times for runtime frames
+  u32 PTR4* rtblittimes;      // blit times for runtime frames
+  u32 PTR4* rtreadtimes;      // read times for runtime frames
+  u32 PTR4* rtidlereadtimes;  // idle read times for runtime frames
+  u32 PTR4* rtthreadreadtimes;// thread read times for runtime frames
+
+  u32 lastblitflags;          // flags used on last blit
+  u32 lastdecompframe;        // last frame number decompressed
+
+  u32 sndbufsize;             // sound buffer size
+  u8 PTR4* sndbuf;            // sound buffer
+  u8 PTR4* sndend;            // end of the sound buffer
+  u8 PTR4* sndwritepos;       // current write position
+  u8 PTR4* sndreadpos;        // current read position
+  u32 sndcomp;                // sound compression handle
+  u32 sndamt;                 // amount of sound currently in the buffer
+  volatile u32 sndreenter;    // re-entrancy check on the sound
+  u32 sndconvert8;            // convert back to 8-bit sound at runtime
+  BINKSND bsnd;               // SND structure
+  u32 skippedlastblit;        // skipped last frame?
+  u32 skippedblits;           // how many blits were skipped
+  u32 soundskips;             // number of sound stops
+  u32 sndendframe;            // frame number that the sound ends on
+  u32 sndprime;               // amount of data to prime the playahead
+  u32 sndpad;                 // padded this much audio
+
+  BUNDLEPOINTERS bunp;        // pointers to internal temporary memory
+} BINK;
+
+
+typedef struct BINKSUMMARY {
+  u32 Width;                  // Width of frames
+  u32 Height;                 // Height of frames
+  u32 TotalTime;              // total time (ms)
+  u32 FileFrameRate;          // frame rate
+  u32 FileFrameRateDiv;       // frame rate divisor
+  u32 FrameRate;              // frame rate
+  u32 FrameRateDiv;           // frame rate divisor
+  u32 TotalOpenTime;          // Time to open and prepare for decompression
+  u32 TotalFrames;            // Total Frames
+  u32 TotalPlayedFrames;      // Total Frames played
+  u32 SkippedFrames;          // Total number of skipped frames
+  u32 SkippedBlits;           // Total number of skipped blits
+  u32 SoundSkips;             // Total number of sound skips
+  u32 TotalBlitTime;          // Total time spent blitting
+  u32 TotalReadTime;          // Total time spent reading
+  u32 TotalVideoDecompTime;   // Total time spent decompressing video
+  u32 TotalAudioDecompTime;   // Total time spent decompressing audio
+  u32 TotalIdleReadTime;      // Total time spent reading while idle
+  u32 TotalBackReadTime;      // Total time spent reading in background
+  u32 TotalReadSpeed;         // Total io speed (bytes/second)
+  u32 SlowestFrameTime;       // Slowest single frame time (ms)
+  u32 Slowest2FrameTime;      // Second slowest single frame time (ms)
+  u32 SlowestFrameNum;        // Slowest single frame number
+  u32 Slowest2FrameNum;       // Second slowest single frame number
+  u32 AverageDataRate;        // Average data rate of the movie
+  u32 AverageFrameSize;       // Average size of the frame
+  u32 HighestMemAmount;       // Highest amount of memory allocated
+  u32 TotalIOMemory;          // Total extra memory allocated
+  u32 HighestIOUsed;          // Highest extra memory actually used
+  u32 Highest1SecRate;        // Highest 1 second rate
+  u32 Highest1SecFrame;       // Highest 1 second start frame
+} BINKSUMMARY;
+
+
+typedef struct BINKREALTIME {
+  u32 FrameNum;               // Current frame number
+  u32 FrameRate;              // frame rate
+  u32 FrameRateDiv;           // frame rate divisor
+  u32 Frames;                 // frames in this sample period
+  u32 FramesTime;             // time is ms for these frames
+  u32 FramesVideoDecompTime;  // time decompressing these frames
+  u32 FramesAudioDecompTime;  // time decompressing these frames
+  u32 FramesReadTime;         // time reading these frames
+  u32 FramesIdleReadTime;     // time reading these frames at idle
+  u32 FramesThreadReadTime;   // time reading these frames in background
+  u32 FramesBlitTime;         // time blitting these frames
+  u32 ReadBufferSize;         // size of read buffer
+  u32 ReadBufferUsed;         // amount of read buffer currently used
+  u32 FramesDataRate;         // data rate for these frames
+} BINKREALTIME;
+
+#define BINKMARKER1 'fKIB'
+#define BINKMARKER2 'gKIB'    // new Bink files use this tag
+#define BINKMARKER3 'hKIB'    // newer Bink files use this tag
+#define BINKMARKER4 'iKIB'    // even newer Bink files use this tag
+
+typedef struct BINKHDR {
+  u32 Marker;                 // Bink marker
+  u32 Size;                   // size of the file-8
+  u32 Frames;                 // Number of frames (1 based, 100 = 100 frames)
+  u32 LargestFrameSize;       // Size in bytes of largest frame
+  u32 InternalFrames;         // Number of internal frames
+
+  u32 Width;                  // Width (1 based, 640 for example)
+  u32 Height;                 // Height (1 based, 480 for example)
+  u32 FrameRate;              // frame rate
+  u32 FrameRateDiv;           // frame rate divisor (framerate/frameratediv=fps)
+
+  u32 Flags;                  // height compression options
+  u32 NumTracks;              // number of tracks
+} BINKHDR;
+
+
+//=======================================================================
+#define BINKFRAMERATE         0x00001000L // Override fr (call BinkFrameRate first)
+#define BINKPRELOADALL        0x00002000L // Preload the entire animation
+#define BINKSNDTRACK          0x00004000L // Set the track number to play
+#define BINKOLDFRAMEFORMAT    0x00008000L // using the old Bink frame format (internal use only)
+#define BINKRBINVERT          0x00010000L // use reversed R and B planes (internal use only)
+#define BINKGRAYSCALE         0x00020000L // Force Bink to use grayscale
+#define BINKNOMMX             0x00040000L // Don't use MMX
+#define BINKNOSKIP            0x00080000L // Don't skip frames if falling behind
+#define BINKALPHA             0x00100000L // Decompress alpha plane (if present)
+#define BINKNOFILLIOBUF       0x00200000L // Fill the IO buffer in SmackOpen
+#define BINKSIMULATE          0x00400000L // Simulate the speed (call BinkSim first)
+#define BINKFILEHANDLE        0x00800000L // Use when passing in a file handle
+#define BINKIOSIZE            0x01000000L // Set an io size (call BinkIOSize first)
+#define BINKIOPROCESSOR       0x02000000L // Set an io processor (call BinkIO first)
+#define BINKFROMMEMORY        0x04000000L // Use when passing in a pointer to the file
+#define BINKNOTHREADEDIO      0x08000000L // Don't use a background thread for IO
+
+#define BINKSURFACEFAST       0x00000000L
+#define BINKSURFACESLOW       0x08000000L
+#define BINKSURFACEDIRECT     0x04000000L
+
+#define BINKCOPYALL           0x80000000L // copy all pixels (not just changed)
+#define BINKCOPY2XH           0x10000000L // Force doubling height scaling
+#define BINKCOPY2XHI          0x20000000L // Force interleaving height scaling
+#define BINKCOPY2XW           0x30000000L // copy the width zoomed by two
+#define BINKCOPY2XWH          0x40000000L // copy the width and height zoomed by two
+#define BINKCOPY2XWHI         0x50000000L // copy the width and height zoomed by two
+#define BINKCOPY1XI           0x60000000L // copy the width and height zoomed by two
+#define BINKCOPYNOSCALING     0x70000000L // Force scaling off
+
+//#define BINKALPHA           0x00100000L // Decompress alpha plane (if present)
+//#define BINKNOSKIP          0x00080000L // don't skip the blit if behind in sound
+//#define BINKNOMMX           0x00040000L // Don't skip frames if falling behind
+//#define BINKGRAYSCALE       0x00020000L // force Bink to use grayscale
+//#define BINKRBINVERT        0x00010000L // use reversed R and B planes
+
+#define BINKSURFACE8P          0
+#define BINKSURFACE24          1
+#define BINKSURFACE24R         2
+#define BINKSURFACE32          3
+#define BINKSURFACE32R         4
+#define BINKSURFACE32A         5
+#define BINKSURFACE32RA        6
+#define BINKSURFACE4444        7
+#define BINKSURFACE5551        8
+#define BINKSURFACE555         9
+#define BINKSURFACE565        10
+#define BINKSURFACE655        11
+#define BINKSURFACE664        12
+#define BINKSURFACEYUY2       13
+#define BINKSURFACEUYVY       14
+#define BINKSURFACEYV12       15
+#define BINKSURFACEMASK       15
+
+#define BINKGOTOQUICK          1
+
+#define BINKGETKEYPREVIOUS     0
+#define BINKGETKEYNEXT         1
+#define BINKGETKEYCLOSEST      2
+#define BINKGETKEYNOTEQUAL   128
+
+//=======================================================================
+
+#ifdef __RADMAC__
+  #include <files.h>
+
+  #pragma export on
+
+  RADEXPFUNC HBINK RADEXPLINK BinkMacOpen(FSSpec* fsp,u32 flags);
+#endif
+
+RADEXPFUNC void PTR4* RADEXPLINK BinkLogoAddress(void);
+
+RADEXPFUNC void RADEXPLINK BinkSetError(const char PTR4* err);
+RADEXPFUNC char PTR4* RADEXPLINK BinkGetError(void);
+
+RADEXPFUNC HBINK RADEXPLINK BinkOpen(const char PTR4* name,u32 flags);
+
+RADEXPFUNC s32  RADEXPLINK BinkDoFrame(HBINK bnk);
+RADEXPFUNC void RADEXPLINK BinkNextFrame(HBINK bnk);
+RADEXPFUNC s32  RADEXPLINK BinkWait(HBINK bnk);
+RADEXPFUNC void RADEXPLINK BinkClose(HBINK bnk);
+RADEXPFUNC s32  RADEXPLINK BinkPause(HBINK bnk,s32 pause);
+RADEXPFUNC s32  RADEXPLINK BinkCopyToBuffer(HBINK bnk,void* dest,s32 destpitch,u32 destheight,u32 destx,u32 desty,u32 flags);
+RADEXPFUNC s32  RADEXPLINK BinkGetRects(HBINK bnk,u32 flags);
+RADEXPFUNC void RADEXPLINK BinkGoto(HBINK bnk,u32 frame,s32 flags);  // use 1 for the first frame
+RADEXPFUNC u32  RADEXPLINK BinkGetKeyFrame(HBINK bnk,u32 frame,s32 flags);
+
+RADEXPFUNC s32  RADEXPLINK BinkSetVideoOnOff(HBINK bnk,s32 onoff);
+RADEXPFUNC s32  RADEXPLINK BinkSetSoundOnOff(HBINK bnk,s32 onoff);
+RADEXPFUNC void RADEXPLINK BinkSetVolume(HBINK bnk,s32 volume);
+RADEXPFUNC void RADEXPLINK BinkSetPan(HBINK bnk,s32 pan);
+RADEXPFUNC void RADEXPLINK BinkService(HBINK bink);
+
+typedef struct BINKTRACK PTR4* HBINKTRACK;
+
+typedef struct BINKTRACK
+{
+  u32 Frequency;
+  u32 Bits;
+  u32 Channels;
+  u32 MaxSize;
+
+  HBINK bink;
+  u32 sndcomp;
+  s32 trackindex;
+} BINKTRACK;
+
+
+RADEXPFUNC HBINKTRACK RADEXPLINK BinkOpenTrack(HBINK bnk,u32 trackindex);
+RADEXPFUNC void RADEXPLINK BinkCloseTrack(HBINKTRACK bnkt);
+RADEXPFUNC u32  RADEXPLINK BinkGetTrackData(HBINKTRACK bnkt,void PTR4* dest);
+
+RADEXPFUNC u32  RADEXPLINK BinkGetTrackType(HBINK bnk,u32 trackindex);
+RADEXPFUNC u32  RADEXPLINK BinkGetTrackMaxSize(HBINK bnk,u32 trackindex);
+RADEXPFUNC u32  RADEXPLINK BinkGetTrackID(HBINK bnk,u32 trackindex);
+RADEXPFUNC u32  RADEXPLINK BinkGetTrackLargest(HBINK bnk,u32 trackindex);
+
+RADEXPFUNC void RADEXPLINK BinkGetSummary(HBINK bnk,BINKSUMMARY PTR4* sum);
+RADEXPFUNC void RADEXPLINK BinkGetRealtime(HBINK bink,BINKREALTIME PTR4* run,u32 frames);
+
+#define BINKNOSOUND 0xffffffff
+
+RADEXPFUNC void RADEXPLINK BinkSetSoundTrack(u32 track);
+RADEXPFUNC void RADEXPLINK BinkSetIO(BINKIOOPEN io);
+RADEXPFUNC void RADEXPLINK BinkSetFrameRate(u32 forcerate,u32 forceratediv);
+RADEXPFUNC void RADEXPLINK BinkSetSimulate(u32 sim);
+RADEXPFUNC void RADEXPLINK BinkSetIOSize(u32 iosize);
+
+RADEXPFUNC s32  RADEXPLINK BinkSetSoundSystem(BINKSNDSYSOPEN open, u32 param);
+
+#ifdef __RADWIN__
+
+  RADEXPFUNC BINKSNDOPEN RADEXPLINK BinkOpenDirectSound(u32 param); // don't call directly
+  #define BinkSoundUseDirectSound(lpDS) BinkSetSoundSystem(BinkOpenDirectSound,(u32)lpDS)
+
+  RADEXPFUNC BINKSNDOPEN RADEXPLINK BinkOpenWaveOut(u32 param); // don't call directly
+  #define BinkSoundUseWaveOut() BinkSetSoundSystem(BinkOpenWaveOut,0)
+
+  #define INCLUDE_MMSYSTEM_H
+  #include "windows.h"
+  #include "windowsx.h"
+
+  #ifdef __RADNT__          // to combat WIN32_LEAN_AND_MEAN
+    #include "mmsystem.h"
+  #endif
+
+#endif
+
+
+#ifndef __RADMAC__
+
+  RADEXPFUNC BINKSNDOPEN RADEXPLINK BinkOpenMiles(u32 param); // don't call directly
+  #define BinkSoundUseMiles(hdigdriver) BinkSetSoundSystem(BinkOpenMiles,(u32)hdigdriver)
+
+#endif
+
+
+#ifdef __RADMAC__
+
+  RADEXPFUNC BINKSNDOPEN RADEXPLINK BinkOpenSoundManager(u32 param); // don't call directly
+  #define BinkSoundUseSoundManager() BinkSetSoundSystem(BinkOpenSoundManager,0)
+
+#endif
+
+
+// The BinkBuffer API isn't currently implemented on DOS
+#if !defined(__RADDOS__)
+
+//=========================================================================
+typedef struct BINKBUFFER * HBINKBUFFER;
+
+#define BINKBUFFERSTRETCHXINT    0x80000000
+#define BINKBUFFERSTRETCHX       0x40000000
+#define BINKBUFFERSHRINKXINT     0x20000000
+#define BINKBUFFERSHRINKX        0x10000000
+#define BINKBUFFERSTRETCHYINT    0x08000000
+#define BINKBUFFERSTRETCHY       0x04000000
+#define BINKBUFFERSHRINKYINT     0x02000000
+#define BINKBUFFERSHRINKY        0x01000000
+#define BINKBUFFERSCALES         0xff000000
+#define BINKBUFFERRESOLUTION     0x00800000
+
+#ifdef __RADMAC__
+
+#include <windows.h>
+#include <palettes.h>
+#include <qdoffscreen.h>
+
+typedef struct BINKBUFFER {
+  u32 Width;
+  u32 Height;
+  u32 WindowWidth;
+  u32 WindowHeight;
+  u32 SurfaceType;
+  void* Buffer;
+  s32 BufferPitch;
+  u32 ScreenWidth;
+  u32 ScreenHeight;
+  u32 ScreenDepth;
+  u32 ScaleFlags;
+
+  s32 destx,desty;
+  s32 wndx,wndy;
+  u32 wnd;
+
+  s32 noclipping;
+  u32 type;
+  s32 issoftcur;
+  u32 cursorcount;
+
+} BINKBUFFER;
+
+
+#define BINKBUFFERAUTO                0
+#define BINKBUFFERDIRECT              1
+#define BINKBUFFERGWORLD              2
+#define BINKBUFFERTYPEMASK           31
+
+RADEXPFUNC HBINKBUFFER RADEXPLINK BinkBufferOpen( WindowPtr wnd, u32 width, u32 height, u32 bufferflags);
+RADEXPFUNC s32 RADEXPLINK BinkGDSurfaceType( GDHandle gd );
+RADEXPFUNC s32 RADEXPLINK BinkIsSoftwareCursor(GDHandle gd);
+RADEXPFUNC s32 RADEXPLINK BinkCheckCursor(WindowPtr wp,s32 x,s32 y,s32 w,s32 h);
+
+#else
+
+typedef struct BINKBUFFER {
+  u32 Width;
+  u32 Height;
+  u32 WindowWidth;
+  u32 WindowHeight;
+  u32 SurfaceType;
+  void* Buffer;
+  s32 BufferPitch;
+  s32 ClientOffsetX;
+  s32 ClientOffsetY;
+  u32 ScreenWidth;
+  u32 ScreenHeight;
+  u32 ScreenDepth;
+  u32 ExtraWindowWidth;
+  u32 ExtraWindowHeight;
+  u32 ScaleFlags;
+  u32 StretchWidth;
+  u32 StretchHeight;
+
+  s32 surface;
+  void* ddsurface;
+  void* ddclipper;
+  s32 destx,desty;
+  s32 wndx,wndy;
+  u32 wnd;
+  s32 ddoverlay;
+  s32 ddoffscreen;
+  s32 lastovershow;
+
+  s32 issoftcur;
+  u32 cursorcount;
+  void* buffertop;
+  u32 type;
+  s32 noclipping;
+
+  s32 loadeddd;
+  s32 loadedwin;
+
+  void* dibh;
+  void* dibbuffer;
+  s32 dibpitch;
+  void* dibinfo;
+  u32 dibdc;
+  u32 diboldbitmap;
+
+} BINKBUFFER;
+
+
+#define BINKBUFFERAUTO                0
+#define BINKBUFFERPRIMARY             1
+#define BINKBUFFERDIBSECTION          2
+#define BINKBUFFERYV12OVERLAY         3
+#define BINKBUFFERYUY2OVERLAY         4
+#define BINKBUFFERUYVYOVERLAY         5
+#define BINKBUFFERYV12OFFSCREEN       6
+#define BINKBUFFERYUY2OFFSCREEN       7
+#define BINKBUFFERUYVYOFFSCREEN       8
+#define BINKBUFFERRGBOFFSCREENVIDEO   9
+#define BINKBUFFERRGBOFFSCREENSYSTEM 10
+#define BINKBUFFERLAST               10
+#define BINKBUFFERTYPEMASK           31
+
+RADEXPFUNC HBINKBUFFER RADEXPLINK BinkBufferOpen( HWND wnd, u32 width, u32 height, u32 bufferflags);
+RADEXPFUNC s32 RADEXPLINK BinkBufferSetHWND( HBINKBUFFER buf, HWND newwnd);
+RADEXPFUNC s32 RADEXPLINK BinkDDSurfaceType(void PTR4* lpDDS);
+RADEXPFUNC s32 RADEXPLINK BinkIsSoftwareCursor(void PTR4* lpDDSP,HCURSOR cur);
+RADEXPFUNC s32 RADEXPLINK BinkCheckCursor(HWND wnd,s32 x,s32 y,s32 w,s32 h);
+RADEXPFUNC s32 RADEXPLINK BinkBufferSetDirectDraw(void PTR4* lpDirectDraw, void PTR4* lpPrimary);
+
+#endif
+
+RADEXPFUNC void RADEXPLINK BinkBufferClose( HBINKBUFFER buf);
+RADEXPFUNC s32 RADEXPLINK BinkBufferLock( HBINKBUFFER buf);
+RADEXPFUNC s32 RADEXPLINK BinkBufferUnlock( HBINKBUFFER buf);
+RADEXPFUNC void RADEXPLINK BinkBufferSetResolution( s32 w, s32 h, s32 bits);
+RADEXPFUNC void RADEXPLINK BinkBufferCheckWinPos( HBINKBUFFER buf, s32 PTR4* NewWindowX, s32 PTR4* NewWindowY);
+RADEXPFUNC s32 RADEXPLINK BinkBufferSetOffset( HBINKBUFFER buf, s32 destx, s32 desty);
+RADEXPFUNC void RADEXPLINK BinkBufferBlit( HBINKBUFFER buf, BINKRECT PTR4* rects, u32 numrects );
+RADEXPFUNC s32 RADEXPLINK BinkBufferSetScale( HBINKBUFFER buf, u32 w, u32 h);
+RADEXPFUNC char PTR4* RADEXPLINK BinkBufferGetDescription( HBINKBUFFER buf);
+RADEXPFUNC char PTR4* RADEXPLINK BinkBufferGetError();
+RADEXPFUNC s32 RADEXPLINK BinkBufferClear(HBINKBUFFER buf, u32 RGB);
+
+RADEXPFUNC void RADEXPLINK BinkRestoreCursor(s32 checkcount);
+
+#endif
+
+#ifdef __RADMAC__
+
+#pragma export off
+
+#endif
+
+RADDEFEND
+
+#endif
+
+#endif
+
diff --git a/code/win32/binkw32.lib b/code/win32/binkw32.lib
new file mode 100644
index 0000000..75369a3
Binary files /dev/null and b/code/win32/binkw32.lib differ
diff --git a/code/win32/clear.bmp b/code/win32/clear.bmp
new file mode 100644
index 0000000..1451638
Binary files /dev/null and b/code/win32/clear.bmp differ
diff --git a/code/win32/dbg_console_xbox.cpp b/code/win32/dbg_console_xbox.cpp
new file mode 100644
index 0000000..021f031
--- /dev/null
+++ b/code/win32/dbg_console_xbox.cpp
@@ -0,0 +1,172 @@
+//-----------------------------------------------------------------------------
+// File: dbg_console_xbox.cpp
+//
+// Desc: Listens for string commands sent from a debug console on a
+//       remote dev machine, and forwards them to the Q3 engine.
+//
+//       Commands are sent from the remote debug console through the debug
+//       channel to the debug monitor on the Xbox machine.  The Xbox machine
+//       receives the commands on a separate thread through a
+//       registered command processor callback function. The callback
+//       function will store commands in a buffer, and the app should
+//       poll this buffer once per frame and then decipher and handle
+//       the commands.
+//
+// Hist: 02.05.01 - Initial creation for March XDK release
+//       08.21.02 - Revision and code cleanup
+//       04.10.02 - Buthcered by BTO for use in JK3:JA
+//
+// Copyright (c) Microsoft Corporation. All rights reserved.
+//-----------------------------------------------------------------------------
+#include <xtl.h>
+#include <xbdm.h>
+#include <stdio.h>
+#include "dbg_console_xbox.h"
+#include "../client/client.h"
+#include "../qcommon/qcommon.h"
+
+
+// Command prefix for things sent across the dubg channel
+static const CHAR g_strDebugConsoleCommandPrefix[] = "XCMD";
+
+
+// Global buffer to receive remote commands from the debug console. Note that
+// since this data is accessed by the app's main thread, and the debug monitor
+// thread, we need to protect access with a critical section
+static CHAR g_strRemoteBuf[MAXRCMDLENGTH];
+
+
+// The critical section used to protect data that is shared between threads
+static CRITICAL_SECTION g_CriticalSection;
+
+
+// Temporary replacement for CRT string funcs, since
+// we can't call CRT functions on the debug monitor
+// thread right now.
+
+
+//-----------------------------------------------------------------------------
+// Name: dbgtolower()
+// Desc: Returns lowercase of char
+//-----------------------------------------------------------------------------
+inline CHAR dbgtolower( CHAR ch )
+{
+    if( ch >= 'A' && ch <= 'Z' )
+        return ch - ( 'A' - 'a' );
+    else
+        return ch;
+}
+
+
+//-----------------------------------------------------------------------------
+// Name: dbgstrnicmp()
+// Desc: Critical section safe string compare.
+//-----------------------------------------------------------------------------
+BOOL dbgstrnicmp( const CHAR* str1, const CHAR* str2, int n )
+{
+    while( ( dbgtolower( *str1 ) == dbgtolower( *str2 ) ) && *str1 && n > 0 )
+    {
+        --n;
+        ++str1;
+        ++str2;
+    }
+
+    return( n == 0 || dbgtolower( *str1 ) == dbgtolower( *str2 ) );
+}
+
+
+//-----------------------------------------------------------------------------
+// Name: dbgstrcpy()
+// Desc: Critical section safe string copy
+//-----------------------------------------------------------------------------
+VOID dbgstrcpy( CHAR* strDest, const CHAR* strSrc )
+{
+    while( ( *strDest++ = *strSrc++ ) != 0 );
+}
+    
+
+//-----------------------------------------------------------------------------
+// Name: DebugConsoleCmdProcessor()
+// Desc: Command notification proc that is called by the Xbox debug monitor to
+//       have us process a command.  What we'll actually attempt to do is tell
+//       it to make calls to us on a separate thread, so that we can just block
+//       until we're able to process a command.
+//
+// Note: Do NOT include newlines in the response string! To do so will confuse
+//       the internal WinSock networking code used by the debug monitor API.
+//-----------------------------------------------------------------------------
+HRESULT __stdcall DebugConsoleCmdProcessor( const CHAR* strCommand,
+                                            CHAR* strResponse, DWORD dwResponseLen,
+                                            PDM_CMDCONT pdmcc )
+{
+    // Skip over the command prefix and the exclamation mark
+    strCommand += strlen(g_strDebugConsoleCommandPrefix) + 1;
+
+    // Check if this is the initial connect signal
+    if( dbgstrnicmp( strCommand, "__connect__", 11 ) )
+    {
+        // If so, respond that we're connected
+        lstrcpynA( strResponse, "Connected.", dwResponseLen );
+        return XBDM_NOERR;
+    }
+
+	// g_strRemoteBuf needs to be protected by the critical section
+	EnterCriticalSection( &g_CriticalSection );
+	if( g_strRemoteBuf[0] )
+	{
+		// This means the application has probably stopped polling for debug commands
+		dbgstrcpy( strResponse, "Cannot execute - previous command still pending" );
+	}
+	else
+	{
+		dbgstrcpy( g_strRemoteBuf, strCommand );
+	}
+	LeaveCriticalSection( &g_CriticalSection );
+
+    return XBDM_NOERR;
+}
+
+
+//-----------------------------------------------------------------------------
+// Name: DebugConsoleHandleCommands()
+// Desc: Poll routine called periodically (typically every frame) by the Xbox
+//       app to see if there is a command waiting to be executed, and if so,
+//       execute it.
+//-----------------------------------------------------------------------------
+BOOL DebugConsoleHandleCommands()
+{
+    static BOOL bInitialized = FALSE;
+    CHAR  strLocalBuf[MAXRCMDLENGTH+1]; // local copy of command
+
+    // Initialize ourselves when we're first called.
+    if( !bInitialized )
+    {
+        // Register our command handler with the debug monitor
+        HRESULT hr = DmRegisterCommandProcessor( g_strDebugConsoleCommandPrefix, 
+                                                 DebugConsoleCmdProcessor );
+        if( FAILED(hr) )
+            return FALSE;
+
+        // We'll also need a critical section to protect access to g_strRemoteBuf
+        InitializeCriticalSection( &g_CriticalSection );
+
+        bInitialized = TRUE;
+    }
+
+    // If there's nothing waiting, return.
+    if( !g_strRemoteBuf[0] )
+        return FALSE;
+
+    // Grab a local copy of the command received in the remote buffer
+    EnterCriticalSection( &g_CriticalSection );
+
+    lstrcpyA( strLocalBuf, g_strRemoteBuf );
+    g_strRemoteBuf[0] = 0;
+
+    LeaveCriticalSection( &g_CriticalSection );
+
+	Cbuf_ExecuteText( EXEC_APPEND, va("%s\n", strLocalBuf) );
+
+    return TRUE;
+}
+
diff --git a/code/win32/dbg_console_xbox.h b/code/win32/dbg_console_xbox.h
new file mode 100644
index 0000000..c6b3732
--- /dev/null
+++ b/code/win32/dbg_console_xbox.h
@@ -0,0 +1,34 @@
+//-----------------------------------------------------------------------------
+// File: dbg_console_xbox.h
+//
+// Desc: Header file for communicating with a remote debug console. Please read
+//       the comments in the dbg_console_xbox.cpp file for more info
+//       on the API.
+//
+//       This header defines the following arrays:
+//
+//          g_RemoteCommands -  This is the list of commands your application provides.
+//                              Note that "help" and "set" are provided automatically
+//                              This is implemented in DebugCmd.cpp
+//
+//          g_RemoteVariables - This is a list of variables that your application
+//                              exposes. They can be examined and modified by the
+//                              remote debug console with the "set" command. 
+//                              This is implemented in DebugChannel.cpp
+//
+// Hist: 02.05.01 - Initial creation for March XDK release
+//       08.21.02 - Revision and code cleanup
+//
+// Copyright (c) Microsoft Corporation. All rights reserved.
+//-----------------------------------------------------------------------------
+#ifndef DEBUGCMD_H
+#define DEBUGCMD_H
+
+#define MAXRCMDLENGTH       256                 // Size of the remote cmd buffer
+
+// Handle any remote commands that have been sent - this should be called
+// periodically by the application
+BOOL DebugConsoleHandleCommands();
+
+#endif // DEBUGCMD_H
+
diff --git a/code/win32/game.rc b/code/win32/game.rc
new file mode 100644
index 0000000..8cd9d35
--- /dev/null
+++ b/code/win32/game.rc
@@ -0,0 +1,104 @@
+// Microsoft Visual C++ generated resource script.
+//
+#include "resource.h"
+
+#define APSTUDIO_READONLY_SYMBOLS
+/////////////////////////////////////////////////////////////////////////////
+//
+// Generated from the TEXTINCLUDE 2 resource.
+//
+#include "afxres.h"
+
+/////////////////////////////////////////////////////////////////////////////
+#undef APSTUDIO_READONLY_SYMBOLS
+
+/////////////////////////////////////////////////////////////////////////////
+// English (U.S.) resources
+
+#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU)
+#ifdef _WIN32
+LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US
+#pragma code_page(1252)
+#endif //_WIN32
+
+#ifdef APSTUDIO_INVOKED
+/////////////////////////////////////////////////////////////////////////////
+//
+// TEXTINCLUDE
+//
+
+1 TEXTINCLUDE 
+BEGIN
+    "resource.h\0"
+END
+
+2 TEXTINCLUDE 
+BEGIN
+    "#include ""afxres.h""\r\n"
+    "\0"
+END
+
+3 TEXTINCLUDE 
+BEGIN
+    "\r\n"
+    "\0"
+END
+
+#endif    // APSTUDIO_INVOKED
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// Version
+//
+#include "AutoVersion.h"
+
+VS_VERSION_INFO VERSIONINFO
+ FILEVERSION VERSION_MAJOR_RELEASE,VERSION_MINOR_RELEASE,VERSION_EXTERNAL_BUILD,VERSION_INTERNAL_BUILD
+ PRODUCTVERSION VERSION_MAJOR_RELEASE,VERSION_MINOR_RELEASE,VERSION_EXTERNAL_BUILD,VERSION_INTERNAL_BUILD
+ FILEFLAGSMASK 0x17L
+#ifdef _DEBUG
+ FILEFLAGS 0x1L
+#else
+ FILEFLAGS 0x0L
+#endif
+ FILEOS 0x4L
+ FILETYPE 0x2L
+ FILESUBTYPE 0x0L
+BEGIN
+    BLOCK "StringFileInfo"
+    BEGIN
+        BLOCK "040904b0"
+        BEGIN
+            VALUE "Comments", "Raven Software"
+            VALUE "CompanyName", "Activision Inc"
+            VALUE "FileDescription", "Jedi Academy Game DLL"
+            VALUE "FileVersion", VERSION_STRING
+            VALUE "InternalName", "ja game.dll"
+            VALUE "LegalCopyright", "Copyright (C) 2003"
+            VALUE "OriginalFilename", "jagamex86.dll"
+            VALUE "ProductName", "Jedi Knight®: Jedi Academy"
+            VALUE "ProductVersion", VERSION_STRING
+        END
+    END
+    BLOCK "VarFileInfo"
+    BEGIN
+        VALUE "Translation", 0x409, 1200
+    END
+END
+
+#endif    // English (U.S.) resources
+/////////////////////////////////////////////////////////////////////////////
+
+
+
+#ifndef APSTUDIO_INVOKED
+/////////////////////////////////////////////////////////////////////////////
+//
+// Generated from the TEXTINCLUDE 3 resource.
+//
+
+
+/////////////////////////////////////////////////////////////////////////////
+#endif    // not APSTUDIO_INVOKED
+
diff --git a/code/win32/glw_win.h b/code/win32/glw_win.h
new file mode 100644
index 0000000..cb08641
--- /dev/null
+++ b/code/win32/glw_win.h
@@ -0,0 +1,30 @@
+#ifndef _WIN32
+#  error You should not be including this file on this platform
+#endif
+
+#ifndef __GLW_WIN_H__
+#define __GLW_WIN_H__
+
+typedef struct
+{
+	WNDPROC		wndproc;
+
+	HDC     hDC;			// handle to device context
+	HGLRC   hGLRC;			// handle to GL rendering context
+
+	HINSTANCE hinstOpenGL;	// HINSTANCE for the OpenGL library
+
+	qboolean allowdisplaydepthchange;
+	qboolean pixelFormatSet;
+
+	int		 desktopBitsPixel;
+	int		 desktopWidth, desktopHeight;
+
+	qboolean	cdsFullscreen;
+
+	FILE *log_fp;
+} glwstate_t;
+
+extern glwstate_t glw_state;
+
+#endif
diff --git a/code/win32/glw_win_dx8.h b/code/win32/glw_win_dx8.h
new file mode 100644
index 0000000..02e352f
--- /dev/null
+++ b/code/win32/glw_win_dx8.h
@@ -0,0 +1,180 @@
+
+/*
+ * UNPUBLISHED -- Rights  reserved  under  the  copyright  laws  of the 
+ * United States.  Use  of a copyright notice is precautionary only and 
+ * does not imply publication or disclosure.                            
+ *                                                                      
+ * THIS DOCUMENTATION CONTAINS CONFIDENTIAL AND PROPRIETARY INFORMATION 
+ * OF    VICARIOUS   VISIONS,  INC.    ANY  DUPLICATION,  MODIFICATION, 
+ * DISTRIBUTION, OR DISCLOSURE IS STRICTLY PROHIBITED WITHOUT THE PRIOR 
+ * EXPRESS WRITTEN PERMISSION OF VICARIOUS VISIONS, INC.
+ */
+
+#ifndef __GLW_WIN_H__
+#define __GLW_WIN_H__
+
+#include <map>
+
+#include <d3d8.h>
+#ifdef _WIN32
+#include <d3dx8.h>
+#endif 
+
+#include "../renderer/qgl_console.h"
+#include "../game/q_shared.h"
+#include "../qcommon/qfiles.h"
+
+#define GLW_MAX_TEXTURE_STAGES 2
+#define GLW_MAX_STRIPS 2048 
+
+
+struct glwstate_t
+{
+	// Interface to DX
+	IDirect3DDevice8* device;
+
+	// Matrix stuff
+	enum MatrixMode
+	{
+		MatrixMode_Model = 0,
+		MatrixMode_Projection = 1,
+		MatrixMode_Texture0 = 2,
+		MatrixMode_Texture1 = 3,
+		MatrixMode_Texture2 = 4,
+		MatrixMode_Texture3 = 5,
+
+		Num_MatrixModes
+	};
+	
+	ID3DXMatrixStack* matrixStack[Num_MatrixModes];
+	MatrixMode matrixMode;
+
+	// Current primitive mode (triangles/quads/strips)
+	D3DPRIMITIVETYPE primitiveMode;
+
+	// Are we in a glBegin/glEnd block? (Used for sanity checks.)
+	bool inDrawBlock;
+	
+	// Texturing
+	bool textureStageDirty[GLW_MAX_TEXTURE_STAGES];
+	bool textureStageEnable[GLW_MAX_TEXTURE_STAGES];
+	GLuint currentTexture[GLW_MAX_TEXTURE_STAGES];
+	D3DTEXTUREOP textureEnv[GLW_MAX_TEXTURE_STAGES];
+	
+	struct TextureInfo
+	{
+		IDirect3DTexture8* mipmap;
+		D3DTEXTUREFILTERTYPE minFilter, mipFilter, magFilter;
+		D3DTEXTUREADDRESS wrapU, wrapV;
+		float anisotropy;
+	};
+
+	typedef std::map<GLuint, TextureInfo> texturexlat_t;
+	texturexlat_t textureXlat;
+
+	GLuint textureBindNum;
+
+	GLuint serverTU, clientTU;
+
+	// Pointers to various draw buffers
+	const void* vertexPointer;
+	const void* normalPointer;
+	const void* texCoordPointer[GLW_MAX_TEXTURE_STAGES];
+	const void* colorPointer;
+
+#ifdef _WINDOWS
+	// Temporary storage used when rendering quads
+	const void* vertexPointerBack;
+	const void* normalPointerBack;
+	const void* texCoordPointerBack[GLW_MAX_TEXTURE_STAGES];
+	const void* colorPointerBack;
+#endif
+
+	// State of draw buffers
+	bool colorArrayState;
+	bool texCoordArrayState[GLW_MAX_TEXTURE_STAGES];
+	bool vertexArrayState;
+	bool normalArrayState;
+	
+	// Stride of various draw buffers
+	int vertexStride;
+	int texCoordStride[GLW_MAX_TEXTURE_STAGES];
+	int colorStride;
+	int normalStride;
+
+	// Current number of verts in this packet
+	int numVertices;
+
+	// Max verts allowed in this packet
+	int maxVertices;
+
+	// Total verts to draw (may take multiple packets)
+	int totalVertices;
+
+	// Current number of indices in this packet
+	int numIndices;
+
+	// Max indices allowed in this packet
+	int maxIndices;
+
+	// Total indices to draw
+	int totalIndices;
+
+	// Culling
+	bool cullEnable;
+	D3DCULL cullMode;
+
+	// Viewport
+	D3DVIEWPORT8 viewport;
+
+	// Clearing info
+	D3DCOLOR clearColor;
+	float clearDepth;
+	int clearStencil;
+
+	// Widescreen mode
+	bool isWidescreen;
+
+	// Global color
+	D3DCOLOR currentColor;
+
+	// Scissoring
+	bool scissorEnable;
+	D3DRECT scissorBox;
+
+	// Directional Light
+	D3DLIGHT8	dirLight;
+	D3DMATERIAL8 mtrl;
+
+	// Description of current shader
+	DWORD shaderMask;
+
+	// Should we reset matrices on next draw?
+	bool matricesDirty[Num_MatrixModes];
+
+	// Render commands go here
+	DWORD* drawArray;
+	DWORD drawStride;
+
+	// This is designed to be an optimization for triangle strips
+	// as well as making life easier for the flare effect
+	GLushort strip_dest[SHADER_MAX_INDEXES];
+	GLuint strip_lengths[GLW_MAX_STRIPS];
+	GLsizei num_strip_lengths;
+
+#ifdef _XBOX
+//	class FlareEffect*	flareEffect;
+	class LightEffects* lightEffects;
+#endif
+};
+
+extern glwstate_t *glw_state;
+
+void renderObject_HACK();
+void renderObject_Light();
+void renderObject_Env();
+void renderObject_Bump();
+bool CreateVertexShader( const CHAR* strFilename, const DWORD* pdwVertexDecl, DWORD* pdwVertexShader );
+bool CreatePixelShader( const CHAR* strFilename, DWORD* pdwPixelShader );
+
+#endif
diff --git a/code/win32/rad.h b/code/win32/rad.h
new file mode 100644
index 0000000..e669360
--- /dev/null
+++ b/code/win32/rad.h
@@ -0,0 +1,962 @@
+#ifndef __RAD__
+#define __RAD__
+
+#define RADCOPYRIGHT "Copyright (C) 1994-2000, RAD Game Tools, Inc."
+
+#ifndef __RADRES__
+
+//  __RAD16__ means 16 bit code (Win16)
+//  __RAD32__ means 32 bit code (DOS, Win386, Win32s, Mac)
+
+//  __RADDOS__ means DOS code (16 or 32 bit)
+//  __RADWIN__ means Windows code (Win16, Win386, Win32s)
+//  __RADWINEXT__ means Windows 386 extender (Win386)
+//  __RADNT__ means Win32s code
+//  __RADMAC__ means Macintosh
+
+//  __RADX86__ means Intel x86
+//  __RADMMX__ means Intel x86 MMX instructions are allowed
+//  __RAD68K__ means 68K
+//  __RADPPC__ means PowerPC
+
+// __RADLITTLEENDIAN__ means processor is little-endian (x86)
+// __RADBIGENDIAN__ means processor is big-endian (680x0, PPC)
+
+// __RADALLOWINLINES__ means this compiler allows inline function declarations
+//                     use RADINLINE for the appropriate keyword
+
+
+#if (defined(__MWERKS__) && !defined(__INTEL__)) || defined(__MRC__) || defined(THINK_C) || defined(powerc) || defined(macintosh) || defined(__powerc)
+
+  #define __RADMAC__
+  #if defined(powerc) || defined(__powerc)
+    #define __RADPPC__
+  #else
+    #define __RAD68K__
+  #endif
+
+  #define __RAD32__
+
+  #define __RADBIGENDIAN__
+
+  #if defined(__MWERKS__)
+    #if (defined(__cplusplus) || ! __option(only_std_keywords))
+      #define __RADALLOWINLINES__
+      #define RADINLINE inline
+    #endif
+  #elif defined(__MRC__)
+    #if defined(__cplusplus)
+      #define __RADALLOWINLINES__
+      #define RADINLINE inline
+    #endif
+  #endif
+
+#else
+
+  #define __RADX86__
+  #define __RADMMX__
+
+  #ifdef __MWERKS__
+    #define _WIN32
+  #endif
+
+  #ifdef __DOS__
+    #define __RADDOS__
+  #endif
+
+  #ifdef __386__
+    #define __RAD32__
+  #endif
+
+  #ifdef _Windows    //For Borland
+    #ifdef __WIN32__
+      #define WIN32
+    #else
+      #define __WINDOWS__
+    #endif
+  #endif
+
+  #ifdef _WINDOWS    //For MS
+    #ifndef _WIN32
+      #define __WINDOWS__
+    #endif
+  #endif
+
+  #ifdef _WIN32
+    #define __RADWIN__
+    #define __RADNT__
+    #define __RAD32__
+  #else
+    #ifdef __NT__
+      #define __RADWIN__
+      #define __RADNT__
+      #define __RAD32__
+    #else
+      #ifdef __WINDOWS_386__
+        #define __RADWIN__
+        #define __RADWINEXT__
+        #define __RAD32__
+      #else
+        #ifdef __WINDOWS__
+          #define __RADWIN__
+          #define __RAD16__
+        #else
+          #ifdef WIN32
+            #define __RADWIN__
+            #define __RADNT__
+            #define __RAD32__
+          #endif
+        #endif
+      #endif
+    #endif
+  #endif
+
+  #define __RADLITTLEENDIAN__
+
+  // TODO - make sure these are set correctly for non-Mac versions
+  #define __RADALLOWINLINES__
+  #define RADINLINE __inline
+
+#endif
+
+#ifndef __RADALLOWINLINES__
+  #define RADINLINE
+#endif
+
+#if (!defined(__RADDOS__) && !defined(__RADWIN__) && !defined(__RADMAC__))
+  #error RAD.H did not detect your platform.  Define __DOS__, __WINDOWS__, WIN32, macintosh, or powerc.
+#endif
+
+#ifdef __RADMAC__
+
+  // this define is for CodeWarrior 11's stupid new libs (even though
+  //   we don't use longlong's).
+
+  #define __MSL_LONGLONG_SUPPORT__
+
+  #define RADLINK
+  #define RADEXPLINK
+
+  #ifdef __CFM68K__
+    #ifdef __RADINDLL__
+      #define RADEXPFUNC RADDEFFUNC __declspec(export)
+    #else
+      #define RADEXPFUNC RADDEFFUNC __declspec(import)
+    #endif
+  #else
+    #define RADEXPFUNC RADDEFFUNC
+  #endif
+  #define RADASMLINK
+
+#else
+
+  #ifdef __RADNT__
+    #ifndef _WIN32
+      #define _WIN32
+    #endif
+    #ifndef WIN32
+      #define WIN32
+    #endif
+  #endif
+
+  #ifdef __RADWIN__
+    #ifdef __RAD32__
+      #ifdef __RADNT__
+
+        #define RADLINK __stdcall
+        #define RADEXPLINK __stdcall
+
+        #ifdef __RADINEXE__
+          #define RADEXPFUNC RADDEFFUNC
+        #else
+          #ifndef __RADINDLL__
+            #define RADEXPFUNC RADDEFFUNC __declspec(dllimport)
+            #ifdef __BORLANDC__
+              #if __BORLANDC__<=0x460
+                #undef RADEXPFUNC
+                #define RADEXPFUNC RADDEFFUNC
+              #endif
+            #endif
+          #else
+            #define RADEXPFUNC RADDEFFUNC __declspec(dllexport)
+          #endif
+        #endif
+      #else
+        #define RADLINK __pascal
+        #define RADEXPLINK __far __pascal
+        #define RADEXPFUNC RADDEFFUNC
+      #endif
+    #else
+      #define RADLINK __pascal
+      #define RADEXPLINK __far __pascal __export
+      #define RADEXPFUNC RADDEFFUNC
+    #endif
+  #else
+    #define RADLINK __pascal
+    #define RADEXPLINK __pascal
+    #define RADEXPFUNC RADDEFFUNC
+  #endif
+
+  #define RADASMLINK __cdecl
+
+#endif
+
+#ifdef __RADWIN__
+  #ifndef _WINDOWS
+    #define _WINDOWS
+  #endif
+#endif
+
+#ifdef __cplusplus
+  #define RADDEFFUNC extern "C"
+  #define RADDEFSTART extern "C" {
+  #define RADDEFEND }
+#else
+  #define RADDEFFUNC
+  #define RADDEFSTART
+  #define RADDEFEND
+#endif
+
+
+RADDEFSTART
+
+#define s8 signed char
+#define u8 unsigned char
+#define u32 unsigned long
+#define s32 signed long
+#define f32 float
+#define f64 double
+
+#if defined(__MWERKS__) || defined(__MRC__)
+#define u64 unsigned long long
+#define s64 signed long long
+#else
+#define u64 unsigned __int64
+#define s64 signed __int64
+#endif
+
+/* 32 bit implementations */
+
+#ifdef __RAD32__
+  #define PTR4
+
+  #define u16 unsigned short
+  #define s16 signed short
+
+  #ifdef __RADMAC__
+
+    #include <string.h>
+    #include <MacTypes.h>
+    #include <Memory.h>
+    #include <OSUtils.h>
+    #ifdef __MRC__
+      #include "intrinsics.h"    
+    #endif
+
+    void radconv32a(void* p, u32 n);
+
+    u32 radloadu32(u32 a);
+
+    u32 radloadu32ptr(u32* p);
+
+    #define radstrcpy strcpy
+
+    #define radstrcat strcat
+
+    #define radmemcpy(dest,source,size) BlockMoveData((Ptr)(source),(Ptr)(dest),size)
+
+    #define radmemcpydb(dest,source,size) BlockMoveData((Ptr)(source),(Ptr)(dest),size)
+
+    #define radmemcmp memcmp
+
+    #define radmemset memset
+
+    #define radstrlen strlen
+
+    #define radstrchr strchr
+
+    #define radtoupper toupper
+
+    #define radstru32(s) ((u32)atol(s))
+
+    //s8 radstricmp(const void* s1,const void* s2);
+
+    #define radstrcmp strcmp
+
+    //char* radstrupr(void* s1);
+
+    //char* radstrlwr(void* s1);
+
+    u32 radsqr(u32 a);
+
+    u32 mult64anddiv(u32 m1,u32 m2,u32 d);
+
+    s32 radabs(s32 ab);
+
+    #define radabs32 radabs
+
+    //char* radstpcpy(void* dest,const void* source);
+
+    //char* radstpcpyrs(void* dest,const void* source);
+
+    void radmemset16(void* dest,u16 value,u32 size);
+
+    //void radmemset32(void* dest,u32 value,u32 size);
+
+    #define BreakPoint() DebugStr("\pBreakPoint() was called")
+
+    //u8 radinp(u16 p);
+
+    //void radoutp(u16 p,u8 v);
+
+    //u32 RADsqrt(u32 sq);
+
+    u32 RADCycleTimerAvail(void);
+
+    void RADCycleTimerStartAddr(u32* addr);
+
+    u32 RADCycleTimerDeltaAddr(u32* addr);
+
+    void RADCycleTimerStartAddr64(u64* addr);
+
+    void RADCycleTimerDeltaAddr64(u64* addr);
+
+    #define RADCycleTimerStart(var) RADCycleTimerStartAddr(&var)
+
+    #define RADCycleTimerDelta(var) RADCycleTimerDeltaAddr(&var)
+
+    #define RADCycleTimerStart64(var) RADCycleTimerStartAddr64(&var)
+
+    #define RADCycleTimerDelta64(var) RADCycleTimerDeltaAddr64(&var)
+
+
+    #ifdef __RAD68K__
+      #pragma parameter radconv32a(__A0,__D0)
+      void radconv32a(void* p,u32 n) ={0x4A80,0x600C,0x2210,0xE059,0x4841,0xE059,0x20C1,0x5380,0x6EF2};
+      // tst.l d0  bra.s @loope  @loop:  move.l (a0),d1  ror.w #8,d1  swap d1 ror.w #8,d1  move.l d1,(a0)+  sub.l #1,d0  bgt.s @loop  @loope:
+    #endif
+
+    #ifdef __RADALLOWINLINES__
+      #if defined __RADPPC__ && defined(__MWERKS__) && (__MWERKS__ >= 0x2301) && 0
+        u32 RADINLINE radloadu32(register u32 x) {
+          register u32 t1, t2;
+          asm {                   // x  = aa bb cc dd
+            rlwinm t1,x,24,0,23   // t1 = dd aa bb 00
+            rlwinm t2,x,8,24,31   // t2 = 00 00 00 aa
+            rlwimi t1,x,8, 8,15   // t1 = dd cc bb 00
+            or x,t1,t2            // x  = dd cc bb aa
+          }
+          return x;
+        }
+      #else
+        u32 RADINLINE radloadu32(register u32 x) {
+          return (((x << 24) & 0xFF000000) |
+                  ((x <<  8) & 0x00FF0000) |
+                  ((x >>  8) & 0x0000FF00) |
+                  ((x >> 24) & 0x000000FF));
+        }
+      #endif
+    #endif
+
+    #if defined(__RADPPC__) && (defined(__MWERKS__) || defined(__MRC__))
+      #define radloadu32ptr(p) (u32) __lwbrx((p),0)
+    #else
+      #define radloadu32ptr(p) radloadu32(*(u32*)(p));
+    #endif
+
+    #ifdef __RADALLOWINLINES__
+      u32 RADINLINE radsqr(u32 a) {  return(a*a);  }
+    #endif
+
+    #ifdef __RAD68K__
+      #pragma parameter __D0 mult64anddiv(__D0,__D1,__D2)
+      u32 mult64anddiv(u32 m1,u32 m2,u32 d) ={0x4C01,0x0C01,0x4C42,0x0C01};
+      //  muls.l d1,d1:d0  divs.l d2,d1:d0
+    #endif
+
+    #if defined(__RADPPC__) && (defined(__MWERKS__) || defined(__MRC__))
+      #define radabs(ab) __abs((s32)(ab))
+    #elif defined(__RADALLOWINLINES__)
+      s32 RADINLINE radabs(s32 ab) { return (ab < 0) ? -ab : ab; }
+    #endif
+
+  #else
+
+    #define radconv32a(p,n) ((void)0)
+
+    #define radloadu32(a) ((u32)(a))
+
+    #define radloadu32ptr(p) *((u32*)(p))
+
+    #ifdef __WATCOMC__
+
+      u32 radsqr(s32 a);
+      #pragma aux radsqr = "mul eax" parm [eax] modify [EDX eax];
+
+      u32 mult64anddiv(u32 m1,u32 m2,u32 d);
+      #pragma aux mult64anddiv = "mul ecx" "div ebx" parm [eax] [ecx] [ebx] modify [EDX eax];
+
+      s32 radabs(s32 ab);
+      #pragma aux radabs = "test eax,eax" "jge skip" "neg eax" "skip:" parm [eax];
+
+      #define radabs32 radabs
+
+      u32 DOSOut(const char* str);
+      #pragma aux DOSOut = "cld" "mov ecx,0xffffffff" "xor eax,eax" "mov edx,edi" "repne scasb" "not ecx" "dec ecx" "mov ebx,1" "mov ah,0x40" "int 0x21" parm [EDI] modify [EAX EBX ECX EDX EDI] value [ecx];
+    
+      void DOSOutNum(const char* str,u32 len);
+      #pragma aux DOSOutNum = "mov ah,0x40" "mov ebx,1" "int 0x21" parm [edx] [ecx] modify [eax ebx];
+
+      u32 ErrOut(const char* str);
+      #pragma aux ErrOut = "cld" "mov ecx,0xffffffff" "xor eax,eax" "mov edx,edi" "repne scasb" "not ecx" "dec ecx" "xor ebx,ebx" "mov ah,0x40" "int 0x21" parm [EDI] modify [EAX EBX ECX EDX EDI] value [ecx];
+    
+      void ErrOutNum(const char* str,u32 len);
+      #pragma aux ErrOutNum = "mov ah,0x40" "xor ebx,ebx" "int 0x21" parm [edx] [ecx] modify [eax ebx];
+
+      void radmemset16(void* dest,u16 value,u32 size);
+      #pragma aux radmemset16 = "cld" "mov bx,ax" "shl eax,16" "mov ax,bx" "mov bl,cl" "shr ecx,1" "rep stosd" "mov cl,bl" "and cl,1" "rep stosw" parm [EDI] [EAX] [ECX] modify [EAX EDX EBX ECX EDI];
+    
+      void radmemset(void* dest,u8 value,u32 size);
+      #pragma aux radmemset = "cld" "mov ah,al" "mov bx,ax" "shl eax,16" "mov ax,bx" "mov bl,cl" "shr ecx,2" "and bl,3" "rep stosd" "mov cl,bl" "rep stosb" parm [EDI] [AL] [ECX] modify [EAX EDX EBX ECX EDI];
+
+      void radmemset32(void* dest,u32 value,u32 size);
+      #pragma aux radmemset32 = "cld" "rep stosd" parm [EDI] [EAX] [ECX] modify [EAX EDX EBX ECX EDI];
+
+      void radmemcpy(void* dest,const void* source,u32 size);
+      #pragma aux radmemcpy = "cld" "mov bl,cl" "shr ecx,2" "rep movsd" "mov cl,bl" "and cl,3" "rep movsb" parm [EDI] [ESI] [ECX] modify [EBX ECX EDI ESI];
+
+      void __far *radfmemcpy(void __far* dest,const void __far* source,u32 size);
+      #pragma aux radfmemcpy = "cld" "push es" "push ds" "mov es,cx" "mov ds,dx" "mov ecx,eax" "shr ecx,2" "rep movsd" "mov cl,al" "and cl,3" "rep movsb" "pop ds" "pop es" parm [CX EDI] [DX ESI] [EAX] modify [ECX EDI ESI] value [CX EDI];
+
+      void radmemcpydb(void* dest,const void* source,u32 size);  //Destination bigger
+      #pragma aux radmemcpydb = "std" "mov bl,cl" "lea esi,[esi+ecx-4]" "lea edi,[edi+ecx-4]" "shr ecx,2" "rep movsd" "and bl,3" "jz dne" "add esi,3" "add edi,3" "mov cl,bl" "rep movsb" "dne:" "cld" parm [EDI] [ESI] [ECX] modify [EBX ECX EDI ESI];
+
+      char* radstrcpy(void* dest,const void* source);
+      #pragma aux radstrcpy = "cld" "mov edx,edi" "lp:" "mov al,[esi]" "inc esi" "mov [edi],al" "inc edi" "cmp al,0" "jne lp" parm [EDI] [ESI] modify [EAX EDX EDI ESI] value [EDX];
+
+      char __far* radfstrcpy(void __far* dest,const void __far* source);
+      #pragma aux radfstrcpy = "cld" "push es" "push ds" "mov es,cx" "mov ds,dx" "mov edx,edi" "lp:" "lodsb" "stosb" "test al,0xff" "jnz lp" "pop ds" "pop es" parm [CX EDI] [DX ESI] modify [EAX EDX EDI ESI] value [CX EDX];
+
+      char* radstpcpy(void* dest,const void* source);
+      #pragma aux radstpcpy = "cld" "lp:" "mov al,[esi]" "inc esi" "mov [edi],al" "inc edi" "cmp al,0" "jne lp" "dec edi" parm [EDI] [ESI] modify [EAX EDI ESI] value [EDI];
+
+      char* radstpcpyrs(void* dest,const void* source);
+      #pragma aux radstpcpyrs = "cld" "lp:" "mov al,[esi]" "inc esi" "mov [edi],al" "inc edi" "cmp al,0" "jne lp" "dec esi" parm [EDI] [ESI] modify [EAX EDI ESI] value [ESI];
+
+      u32 radstrlen(const void* dest);
+      #pragma aux radstrlen = "cld" "mov ecx,0xffffffff" "xor eax,eax" "repne scasb" "not ecx" "dec ecx" parm [EDI] modify [EAX ECX EDI] value [ECX];
+    
+      char* radstrcat(void* dest,const void* source);
+      #pragma aux radstrcat = "cld" "mov ecx,0xffffffff" "mov edx,edi" "xor eax,eax" "repne scasb" "dec edi" "lp:" "lodsb" "stosb" "test al,0xff" "jnz lp" \
+      parm [EDI] [ESI] modify [EAX ECX EDI ESI] value [EDX];
+
+      char* radstrchr(const void* dest,char chr);
+      #pragma aux radstrchr = "cld" "lp:" "lodsb" "cmp al,dl" "je fnd" "cmp al,0" "jnz lp" "mov esi,1" "fnd:" "dec esi" parm [ESI] [DL] modify [EAX ESI] value [esi];
+
+      s8 radmemcmp(const void* s1,const void* s2,u32 len);
+      #pragma aux radmemcmp = "cld" "rep cmpsb" "setne al" "jbe end" "neg al" "end:"  parm [EDI] [ESI] [ECX] modify [ECX EDI ESI];
+
+      s8 radstrcmp(const void* s1,const void* s2);
+      #pragma aux radstrcmp = "lp:" "mov al,[esi]" "mov ah,[edi]" "cmp al,ah" "jne set" "cmp al,0" "je set" "inc esi" "inc edi" "jmp lp" "set:" "setne al" "jbe end" "neg al" "end:" \
+      parm [EDI] [ESI] modify [EAX EDI ESI];
+
+      s8 radstricmp(const void* s1,const void* s2);
+      #pragma aux radstricmp = "lp:" "mov al,[esi]" "mov ah,[edi]" "cmp al,'a'" "jb c1" "cmp al,'z'" "ja c1" "sub al,32" "c1:" "cmp ah,'a'" "jb c2" "cmp ah,'z'" "ja c2" "sub ah,32" "c2:" "cmp al,ah" "jne set" "cmp al,0" "je set" \
+     "inc esi" "inc edi" "jmp lp" "set:" "setne al" "jbe end" "neg al" "end:" \
+      parm [EDI] [ESI] modify [EAX EDI ESI];
+
+      s8 radstrnicmp(const void* s1,const void* s2,u32 len);
+      #pragma aux radstrnicmp = "lp:" "mov al,[esi]" "mov ah,[edi]" "cmp al,'a'" "jb c1" "cmp al,'z'" "ja c1" "sub al,32" "c1:" "cmp ah,'a'" "jb c2" "cmp ah,'z'" "ja c2" "sub ah,32" "c2:" "cmp al,ah" "jne set" "cmp al,0" "je set" \
+      "dec ecx" "jz set" "inc esi" "inc edi" "jmp lp" "set:" "setne al" "jbe end" "neg al" "end:" \
+      parm [EDI] [ESI] [ECX] modify [EAX ECX EDI ESI];
+
+      char* radstrupr(void* s1);
+      #pragma aux radstrupr = "mov ecx,edi" "lp:" "mov al,[edi]" "cmp al,'a'" "jb c1" "cmp al,'z'" "ja c1" "sub [edi],32" "c1:" "inc edi" "cmp al,0" "jne lp" parm [EDI] modify [EAX EDI] value [ecx];
+
+      char* radstrlwr(void* s1);
+      #pragma aux radstrlwr = "mov ecx,edi" "lp:" "mov al,[edi]" "cmp al,'A'" "jb c1" "cmp al,'Z'" "ja c1" "add [edi],32" "c1:" "inc edi" "cmp al,0" "jne lp" parm [EDI] modify [EAX EDI] value [ecx];
+
+      u32 radstru32(const void* dest);
+        #pragma aux radstru32 = "cld" "xor ecx,ecx" "xor ebx,ebx" "xor edi,edi" "lodsb" "cmp al,45" "jne skip2" "mov edi,1" "jmp skip" "lp:" "mov eax,10" "mul ecx" "lea ecx,[eax+ebx]" \
+        "skip:" "lodsb" "skip2:" "cmp al,0x39" "ja dne" "cmp al,0x30" "jb dne" "mov bl,al" "sub bl,0x30" "jmp lp" "dne:" "test edi,1" "jz pos" "neg ecx" "pos:" \
+        parm [ESI] modify [EAX EBX EDX EDI ESI] value [ecx];
+                                                             
+      u16 GetDS();
+      #pragma aux GetDS = "mov ax,ds" value [ax];
+
+      #ifdef __RADWINEXT__
+    
+        #define _16To32(ptr16) ((void*)(((GetSelectorBase((u16)(((u32)(ptr16))>>16))+((u16)(u32)(ptr16)))-GetSelectorBase(GetDS()))))
+
+      #endif
+
+      #ifndef __RADWIN__
+        #define int86 int386
+        #define int86x int386x
+      #endif
+    
+      #define u32regs x
+      #define u16regs w
+    
+    #else
+
+      #define radstrcpy strcpy
+      #define radstrcat strcat
+      #define radmemcpy memcpy
+      #define radmemcpydb memmove
+      #define radmemcmp memcmp
+      #define radmemset memset
+      #define radstrlen strlen
+      #define radstrchr strchr
+      #define radtoupper toupper
+      #define radstru32(s) ((u32)atol(s))
+      #define radstricmp _stricmp
+      #define radstrcmp strcmp
+      #define radstrupr _strupr
+      #define radstrlwr _strlwr
+      #define BreakPoint() __asm {int 3}
+      #define DOSOut(str)
+
+      #ifdef _MSC_VER
+
+        #pragma warning( disable : 4035)
+
+        typedef char* RADPCHAR;
+
+        u32 __inline radsqr(u32 m) {
+          __asm {
+            mov eax,[m]
+            mul eax
+          }
+        }
+
+        u32 __inline mult64anddiv(u32 m1,u32 m2, u32 d) {
+          __asm {
+            mov eax,[m1]
+            mov ecx,[m2]
+            mul ecx
+            mov ecx,[d]
+            div ecx
+          }
+        }
+
+        s32 __inline radabs(s32 ab) {
+          __asm {
+            mov eax,[ab]
+            test eax,eax
+            jge skip
+            neg eax
+           skip:
+          }
+        }
+
+        u8 __inline radinp(u16 p) {
+          __asm {
+            mov dx,[p] 
+            in al,dx 
+          } 
+        }
+
+        void __inline radoutp(u16 p,u8 v) {
+          __asm {
+            mov dx,[p] 
+            mov al,[v]
+            out dx,al 
+          }
+        }
+
+        RADPCHAR __inline radstpcpy(char* p1, char* p2) { 
+          __asm {
+             mov edx,[p1] 
+             mov ecx,[p2]
+             cld
+            lp:
+             mov al,[ecx] 
+             inc ecx 
+             mov [edx],al 
+             inc edx
+             cmp al,0 
+             jne lp 
+             dec edx 
+             mov eax,edx
+          } 
+        }
+        
+        RADPCHAR __inline radstpcpyrs(char* p1, char* p2) { 
+          __asm {
+            mov edx,[p1]
+            mov ecx,[p2]
+            cld
+           lp:
+            mov al,[ecx]
+            inc ecx
+            mov [edx],al
+            inc edx
+            cmp al,0 
+            jne lp
+            dec ecx
+            mov eax,ecx 
+          } 
+        }
+
+        void __inline radmemset16(void* dest,u16 value,u32 sizeb) {
+          __asm {
+            mov edi,[dest]
+            mov ax,[value] 
+            mov ecx,[sizeb]
+            shl eax,16 
+            cld 
+            mov ax,[value] 
+            mov bl,cl 
+            shr ecx,1 
+            rep stosd
+            mov cl,bl 
+            and cl,1 
+            rep stosw
+          }
+        }
+
+        void __inline radmemset32(void* dest,u32 value,u32 sizeb) {
+          __asm {
+            mov edi,[dest]
+            mov eax,[value]
+            mov ecx,[sizeb]
+            cld
+            rep stosd
+          }
+        }
+
+        u32 __inline __stdcall RADsqrt(u32 sq) {
+          __asm {
+            fild dword ptr [sq]
+            fsqrt
+            fistp word ptr [sq]
+            movzx eax,word ptr [sq]
+          }
+        }
+
+        u32 __inline RADCycleTimerAvail(void)
+        {
+          u32 rdtscavail=(u32)-1;
+          __try
+          {
+            __asm
+            {
+#ifdef __MWERKS__
+              rdtsc
+#else
+#if _MSC_VER<=1100
+              __emit 0xf
+              __emit 0x31
+#else
+              rdtsc
+#endif
+#endif
+            }
+            rdtscavail=1;
+          }
+          __except (1)
+          {
+            rdtscavail=(u32)-1;
+          }
+          return rdtscavail;
+        }
+
+        void __inline RADCycleTimerStartAddr(u32* addr)
+        {
+          __asm {
+            mov ecx,[addr]
+#ifdef __MWERKS__
+            rdtsc
+#else
+#if _MSC_VER<=1100
+            __emit 0xf
+            __emit 0x31
+#else
+            rdtsc
+#endif
+#endif
+            mov [ecx],eax
+          }
+        }
+
+        u32 __inline RADCycleTimerDeltaAddr(u32* addr)
+        {
+          __asm {
+#ifdef __MWERKS__
+            rdtsc
+#else
+#if _MSC_VER<=1100
+            __emit 0xf
+            __emit 0x31
+#else
+            rdtsc
+#endif
+#endif
+            mov ecx,[addr]
+            mov edx,eax
+            sub eax,[ecx]
+            mov [ecx],eax
+          }
+        }
+
+        void __inline RADCycleTimerStartAddr64(u64* addr)
+        {
+          __asm {
+            mov ecx,[addr]
+#ifdef __MWERKS__
+            rdtsc
+#else
+#if _MSC_VER<=1100
+            __emit 0xf
+            __emit 0x31
+#else
+            rdtsc
+#endif
+#endif
+            mov [ecx],eax
+            mov [ecx+4],edx
+          }
+        }
+
+        void __inline RADCycleTimerDeltaAddr64(u64* addr)
+        {
+          __asm {
+#ifdef __MWERKS__
+            rdtsc
+#else
+#if _MSC_VER<=1100
+            __emit 0xf
+            __emit 0x31
+#else
+            rdtsc
+#endif
+#endif
+            mov ecx,[addr]
+            sub eax,[ecx]
+            sbb edx,[ecx+4]
+            mov [ecx],eax
+            mov [ecx+4],edx
+          }
+        }
+
+        #define RADCycleTimerStart(var) RADCycleTimerStartAddr(&var)
+        #define RADCycleTimerDelta(var) RADCycleTimerDeltaAddr(&var)
+
+        #define RADCycleTimerStart64(var) RADCycleTimerStartAddr64(&var)
+        #define RADCycleTimerDelta64(var) RADCycleTimerDeltaAddr64(&var)
+
+        #pragma warning( default : 4035)
+
+      #endif
+
+    #endif
+
+  #endif
+
+#else
+
+  #define PTR4 __far
+
+  #define u16 unsigned int
+  #define s16 signed int
+
+  #ifdef __WATCOMC__
+
+    u32 radsqr(s32 a);
+    #pragma aux radsqr = "shl edx,16" "mov dx,ax" "mov eax,edx" "xor edx,edx" "mul eax" "shld edx,eax,16" parm [dx ax] modify [DX ax] value [dx ax];
+
+    s16 radabs(s16 ab);
+    #pragma aux radabs = "test ax,ax" "jge skip" "neg ax" "skip:" parm [ax] value [ax];
+
+    s32 radabs32(s32 ab);
+    #pragma aux radabs32 = "test dx,dx" "jge skip" "neg dx" "neg ax" "sbb dx,0" "skip:" parm [dx ax] value [dx ax];
+    
+    u32 DOSOut(const char far* dest);
+    #pragma aux DOSOut = "cld" "and edi,0xffff" "mov dx,di" "mov ecx,0xffffffff" "xor eax,eax" 0x67 "repne scasb" "not ecx" "dec ecx" "mov bx,1" "push ds" "push es" "pop ds" "mov ah,0x40" "int 0x21" "pop ds" "movzx eax,cx" "shr ecx,16" \
+       parm [ES DI] modify [AX BX CX DX DI ES] value [CX AX];
+    
+    void DOSOutNum(const char far* str,u16 len);
+    #pragma aux DOSOutNum = "push ds" "mov ds,cx" "mov cx,bx" "mov ah,0x40" "mov bx,1" "int 0x21" "pop ds" parm [cx dx] [bx] modify [ax bx cx];
+
+    u32 ErrOut(const char far* dest);
+    #pragma aux ErrOut = "cld" "and edi,0xffff" "mov dx,di" "mov ecx,0xffffffff" "xor eax,eax" 0x67 "repne scasb" "not ecx" "dec ecx" "xor bx,bx" "push ds" "push es" "pop ds" "mov ah,0x40" "int 0x21" "pop ds" "movzx eax,cx" "shr ecx,16" \
+       parm [ES DI] modify [AX BX CX DX DI ES] value [CX AX];
+
+    void ErrOutNum(const char far* str,u16 len);
+    #pragma aux ErrOutNum = "push ds" "mov ds,cx" "mov cx,bx" "mov ah,0x40" "xor bx,bx" "int 0x21" "pop ds" parm [cx dx] [bx] modify [ax bx cx];
+
+    void radmemset(void far *dest,u8 value,u32 size);
+    #pragma aux radmemset = "cld" "and edi,0ffffh" "shl ecx,16" "mov cx,bx" "mov ah,al" "mov bx,ax" "shl eax,16" "mov ax,bx" "mov bl,cl" "shr ecx,2" 0x67 "rep stosd" "mov cl,bl" "and cl,3" "rep stosb" parm [ES DI] [AL] [CX BX];
+
+    void radmemset16(void far* dest,u16 value,u32 size);
+    #pragma aux radmemset16 = "cld" "and edi,0ffffh" "shl ecx,16" "mov cx,bx" "mov bx,ax" "shl eax,16" "mov ax,bx" "mov bl,cl" "shr ecx,1" "rep stosd" "mov cl,bl" "and cl,1" "rep stosw" parm [ES DI] [AX] [CX BX];
+
+    void radmemcpy(void far* dest,const void far* source,u32 size);
+    #pragma aux radmemcpy = "cld" "push ds" "mov ds,dx" "and esi,0ffffh" "and edi,0ffffh" "shl ecx,16" "mov cx,bx" "shr ecx,2" 0x67 "rep movsd" "mov cl,bl" "and cl,3" "rep movsb" "pop ds" parm [ES DI] [DX SI] [CX BX] modify [CX SI DI ES];
+
+    s8 radmemcmp(const void far* s1,const void far* s2,u32 len);
+    #pragma aux radmemcmp = "cld" "push ds" "mov ds,dx" "shl ecx,16" "mov cx,bx" "rep cmpsb" "setne al" "jbe end" "neg al" "end:" "pop ds"  parm [ES DI] [DX SI] [CX BX] modify [CX SI DI ES];
+
+    char far* radstrcpy(void far* dest,const void far* source);
+    #pragma aux radstrcpy = "cld" "push ds" "mov ds,dx" "and esi,0xffff" "and edi,0xffff" "mov dx,di" "lp:" "lodsb" "stosb" "test al,0xff" "jnz lp" "pop ds" parm [ES DI] [DX SI] modify [AX DX DI SI ES] value [es dx];
+
+    char far* radstpcpy(void far* dest,const void far* source);
+    #pragma aux radstpcpy = "cld" "push ds" "mov ds,dx" "and esi,0xffff" "and edi,0xffff" "lp:" "lodsb" "stosb" "test al,0xff" "jnz lp" "dec di" "pop ds" parm [ES DI] [DX SI] modify [DI SI ES] value [es di];
+
+    u32 radstrlen(const void far* dest);
+    #pragma aux radstrlen = "cld" "and edi,0xffff" "mov ecx,0xffffffff" "xor eax,eax" 0x67 "repne scasb" "not ecx" "dec ecx" "movzx eax,cx" "shr ecx,16" parm [ES DI] modify [AX CX DI ES] value [CX AX];
+    
+    char far* radstrcat(void far* dest,const void far* source);
+    #pragma aux radstrcat = "cld" "and edi,0xffff" "mov ecx,0xffffffff" "and esi,0xffff" "push ds" "mov ds,dx" "mov dx,di" "xor eax,eax" 0x67 "repne scasb" "dec edi" "lp:" "lodsb" "stosb" "test al,0xff" "jnz lp" "pop ds" \
+      parm [ES DI] [DX SI] modify [AX CX DI SI ES] value [es dx];
+    
+    char far* radstrchr(const void far* dest,char chr);
+    #pragma aux radstrchr = "cld" "lp:" 0x26 "lodsb" "cmp al,dl" "je fnd" "cmp al,0" "jnz lp" "xor ax,ax" "mov es,ax" "mov si,1" "fnd:" "dec si" parm [ES SI] [DL] modify [AX SI ES] value [es si];
+
+    s8 radstricmp(const void far* s1,const void far* s2);
+    #pragma aux radstricmp = "and edi,0xffff" "push ds" "mov ds,dx" "and esi,0xffff" "lp:" "mov al,[esi]" "mov ah,[edi]" "cmp al,'a'" "jb c1" "cmp al,'z'" "ja c1" "sub al,32" "c1:" \
+      "cmp ah,'a'" "jb c2" "cmp ah,'z'" "ja c2" "sub ah,32" "c2:" "cmp al,ah" "jne set" "cmp al,0" "je set" \
+      "inc esi" "inc edi" "jmp lp" "set:" "setne al" "jbe end" "neg al" "end:" "pop ds" \
+      parm [ES DI] [DX SI] modify [AX DI SI];
+
+    u32 radstru32(const void far* dest);
+    #pragma aux radstru32 = "cld" "xor ecx,ecx" "xor ebx,ebx" "xor edi,edi" 0x26 "lodsb" "cmp al,45" "jne skip2" "mov edi,1" "jmp skip" "lp:" "mov eax,10" "mul ecx" "lea ecx,[eax+ebx]" \
+      "skip:" 0x26 "lodsb" "skip2:" "cmp al,0x39" "ja dne" "cmp al,0x30" "jb dne" "mov bl,al" "sub bl,0x30" "jmp lp" "dne:" "test edi,1" "jz pos" "neg ecx" "pos:" \
+      "movzx eax,cx" "shr ecx,16" parm [ES SI] modify [AX BX DX DI SI] value [cx ax];
+
+    u32 mult64anddiv(u32 m1,u32 m2,u32 d);
+    #pragma aux mult64anddiv = "shl ecx,16" "mov cx,ax" "shrd eax,edx,16" "mov ax,si" "mul ecx" "shl edi,16" "mov di,bx" "div edi" "shld edx,eax,16" "and edx,0xffff" "and eax,0xffff" parm [cx ax] [dx si] [di bx] \
+      modify [ax bx cx dx si di] value [dx ax];
+
+  #endif
+
+#endif
+
+RADDEFEND
+
+#define u32neg1 ((u32)(s32)-1)
+#define RAD_align(var) var; u8 junk##var[4-(sizeof(var)&3)];
+#define RAD_align_after(var) u8 junk##var[4-(sizeof(var)&3)]={0};
+#define RAD_align_init(var,val) var=val; u8 junk##var[4-(sizeof(var)&3)]={0};
+#define RAD_align_array(var,num) var[num]; u8 junk##var[4-(sizeof(var)&3)];
+#define RAD_align_string(var,str) char var[]=str; u8 junk##var[4-(sizeof(var)&3)]={0};
+
+
+typedef void PTR4* (RADLINK PTR4* RADMEMALLOC) (u32 bytes);
+typedef void       (RADLINK PTR4* RADMEMFREE)  (void PTR4* ptr);
+
+#ifdef __RADMAC__
+  #pragma export on
+#endif
+RADEXPFUNC void RADEXPLINK RADSetMemory(RADMEMALLOC a,RADMEMFREE f);
+#ifdef __RADMAC__
+  #pragma export off
+#endif
+
+RADEXPFUNC void PTR4* RADEXPLINK radmalloc(u32 numbytes);
+RADEXPFUNC void RADEXPLINK radfree(void PTR4* ptr);
+
+#ifdef __RADDOS__
+
+  RADDEFSTART
+  extern void* RADTimerSetupAddr;
+  extern void* RADTimerReadAddr;
+  extern void* RADTimerDoneAddr;
+  RADDEFEND
+
+  typedef void RADEXPLINK (*RADTimerSetupType)(void);
+  typedef u32 RADEXPLINK (*RADTimerReadType)(void);
+  typedef void RADEXPLINK (*RADTimerDoneType)(void);
+
+  #define RADTimerSetup() ((RADTimerSetupType)(RADTimerSetupAddr))()
+  #define RADTimerRead() ((RADTimerReadType)(RADTimerReadAddr))()
+  #define RADTimerDone() ((RADTimerDoneType)(RADTimerDoneAddr))()
+
+#else
+
+  #define RADTimerSetup()
+  #define RADTimerDone()
+
+  #if (defined(__RAD16__) || defined(__RADWINEXT__))
+
+    #define RADTimerRead timeGetTime
+
+  #else
+
+    RADEXPFUNC u32 RADEXPLINK RADTimerRead(void);
+
+  #endif
+
+#endif
+
+
+#ifdef __WATCOMC__
+
+  char bkbhit();
+  #pragma aux bkbhit = "mov ah,1" "int 0x16" "lahf" "shr eax,14" "and eax,1" "xor al,1" ;
+
+  char bgetch();
+  #pragma aux bgetch = "xor ah,ah" "int 0x16" "test al,0xff" "jnz done" "mov al,ah" "or al,0x80" "done:" modify [AX];
+
+  void BreakPoint();
+  #pragma aux BreakPoint = "int 3";
+
+  u8 radinp(u16 p);
+  #pragma aux radinp = "in al,dx" parm [DX];
+
+  u8 radtoupper(u8 p);
+  #pragma aux radtoupper = "cmp al,'a'" "jb c1" "cmp al,'z'" "ja c1" "sub al,32" "c1:" parm [al] value [al];
+
+  void radoutp(u16 p,u8 v);
+  #pragma aux radoutp = "out dx,al" parm [DX] [AL];
+
+#else
+
+// for multi-processor machines
+
+#ifdef __RADNT__
+  #define LockedIncrement(var) __asm { lock inc [var] }
+  #define LockedDecrement(var) __asm { lock dec [var] }
+  void __inline LockedIncrementFunc(void PTR4* var) {
+    __asm {
+      mov eax,[var]
+      lock inc [eax]
+    }
+  }
+
+  void __inline LockedDecrementFunc(void PTR4* var) {
+    __asm {
+       mov eax,[var]
+       lock dec [eax]
+    }
+  }
+
+#else
+  
+  #ifdef __RADMAC__
+
+    #define LockedIncrement(var) {++(var);}
+    #define LockedDecrement(var) {--(var);}
+
+    #define LockedIncrementFunc(ptr) {++(*((u32*)(ptr)));}
+    #define LockedDecrementFunc(ptr) {--(*((u32*)(ptr)));}
+
+  #else
+
+    #define LockedIncrement(var) __asm { inc [var] }
+    #define LockedDecrement(var) __asm { dec [var] }
+    void __inline LockedIncrementFunc(void PTR4* var) { __asm { mov eax,[var]
+                                                                inc [eax] } }
+    void __inline LockedDecrementFunc(void PTR4* var) { __asm { mov eax,[var]
+                                                                dec [eax] } }
+  #endif
+
+#endif
+
+#endif
+
+#endif
+
+#endif
+
diff --git a/code/win32/resource.h b/code/win32/resource.h
new file mode 100644
index 0000000..fa16c02
--- /dev/null
+++ b/code/win32/resource.h
@@ -0,0 +1,21 @@
+//{{NO_DEPENDENCIES}}
+// Microsoft Developer Studio generated include file.
+// Used by winquake.rc
+//
+#define IDS_STRING1                     1
+#define IDI_ICON1                       1
+#define IDB_BITMAP1                     1
+#define IDB_BITMAP2                     128
+#define IDC_CURSOR1                     129
+
+// Next default values for new objects
+// 
+#ifdef APSTUDIO_INVOKED
+#ifndef APSTUDIO_READONLY_SYMBOLS
+#define _APS_NO_MFC                     1
+#define _APS_NEXT_RESOURCE_VALUE        130
+#define _APS_NEXT_COMMAND_VALUE         40001
+#define _APS_NEXT_CONTROL_VALUE         1005
+#define _APS_NEXT_SYMED_VALUE           101
+#endif
+#endif
diff --git a/code/win32/snd_fx_img.h b/code/win32/snd_fx_img.h
new file mode 100644
index 0000000..d226885
--- /dev/null
+++ b/code/win32/snd_fx_img.h
@@ -0,0 +1,85 @@
+
+#pragma once
+
+typedef enum _DSP_IMAGE_image_FX_INDICES {
+    GraphI3DL2_I3DL2Reverb = 0,
+    GraphXTalk_XTalk = 1,
+    GraphVoice_Voice_0 = 2,
+    GraphVoice_Voice_1 = 3,
+    GraphVoice_Voice_2 = 4,
+    GraphVoice_Voice_3 = 5
+} DSP_IMAGE_image_FX_INDICES;
+
+#define DSI3DL2_ENVIRONMENT_GraphI3DL2_I3DL2Reverb -1000, -100, 0.000000, 1.490000, 0.830000, -2602, 0.007000, 200, 0.011000, 100.000000, 100.000000, 5000.000000
+
+typedef struct _GraphI3DL2_FX0_I3DL2Reverb_STATE {
+    DWORD dwScratchOffset;        // Offset in bytes, of scratch area for this FX
+    DWORD dwScratchLength;        // Length in DWORDS, of scratch area for this FX
+    DWORD dwYMemoryOffset;        // Offset in DSP WORDS, of Y memory area for this FX
+    DWORD dwYMemoryLength;        // Length in DSP WORDS, of Y memory area for this FX
+    DWORD dwFlags;                // FX bitfield for various flags. See xgpimage documentation
+    DWORD dwInMixbinPtrs[2];      // XRAM offsets in DSP WORDS, of input mixbins
+    DWORD dwOutMixbinPtrs[35];     // XRAM offsets in DSP WORDS, of output mixbins
+} GraphI3DL2_FX0_I3DL2Reverb_STATE, *LPGraphI3DL2_FX0_I3DL2Reverb_STATE;
+
+typedef const GraphI3DL2_FX0_I3DL2Reverb_STATE *LPCGraphI3DL2_FX0_I3DL2Reverb_STATE;
+
+typedef struct _GraphXTalk_FX0_XTalk_STATE {
+    DWORD dwScratchOffset;        // Offset in bytes, of scratch area for this FX
+    DWORD dwScratchLength;        // Length in DWORDS, of scratch area for this FX
+    DWORD dwYMemoryOffset;        // Offset in DSP WORDS, of Y memory area for this FX
+    DWORD dwYMemoryLength;        // Length in DSP WORDS, of Y memory area for this FX
+    DWORD dwFlags;                // FX bitfield for various flags. See xgpimage documentation
+    DWORD dwInMixbinPtrs[4];      // XRAM offsets in DSP WORDS, of input mixbins
+    DWORD dwOutMixbinPtrs[4];     // XRAM offsets in DSP WORDS, of output mixbins
+} GraphXTalk_FX0_XTalk_STATE, *LPGraphXTalk_FX0_XTalk_STATE;
+
+typedef const GraphXTalk_FX0_XTalk_STATE *LPCGraphXTalk_FX0_XTalk_STATE;
+
+typedef struct _GraphVoice_FX0_Voice_0_STATE {
+    DWORD dwScratchOffset;        // Offset in bytes, of scratch area for this FX
+    DWORD dwScratchLength;        // Length in DWORDS, of scratch area for this FX
+    DWORD dwYMemoryOffset;        // Offset in DSP WORDS, of Y memory area for this FX
+    DWORD dwYMemoryLength;        // Length in DSP WORDS, of Y memory area for this FX
+    DWORD dwFlags;                // FX bitfield for various flags. See xgpimage documentation
+    DWORD dwInMixbinPtrs[1];      // XRAM offsets in DSP WORDS, of input mixbins
+    DWORD dwOutMixbinPtrs[1];     // XRAM offsets in DSP WORDS, of output mixbins
+} GraphVoice_FX0_Voice_0_STATE, *LPGraphVoice_FX0_Voice_0_STATE;
+
+typedef const GraphVoice_FX0_Voice_0_STATE *LPCGraphVoice_FX0_Voice_0_STATE;
+
+typedef struct _GraphVoice_FX1_Voice_1_STATE {
+    DWORD dwScratchOffset;        // Offset in bytes, of scratch area for this FX
+    DWORD dwScratchLength;        // Length in DWORDS, of scratch area for this FX
+    DWORD dwYMemoryOffset;        // Offset in DSP WORDS, of Y memory area for this FX
+    DWORD dwYMemoryLength;        // Length in DSP WORDS, of Y memory area for this FX
+    DWORD dwFlags;                // FX bitfield for various flags. See xgpimage documentation
+    DWORD dwInMixbinPtrs[1];      // XRAM offsets in DSP WORDS, of input mixbins
+    DWORD dwOutMixbinPtrs[1];     // XRAM offsets in DSP WORDS, of output mixbins
+} GraphVoice_FX1_Voice_1_STATE, *LPGraphVoice_FX1_Voice_1_STATE;
+
+typedef const GraphVoice_FX1_Voice_1_STATE *LPCGraphVoice_FX1_Voice_1_STATE;
+
+typedef struct _GraphVoice_FX2_Voice_2_STATE {
+    DWORD dwScratchOffset;        // Offset in bytes, of scratch area for this FX
+    DWORD dwScratchLength;        // Length in DWORDS, of scratch area for this FX
+    DWORD dwYMemoryOffset;        // Offset in DSP WORDS, of Y memory area for this FX
+    DWORD dwYMemoryLength;        // Length in DSP WORDS, of Y memory area for this FX
+    DWORD dwFlags;                // FX bitfield for various flags. See xgpimage documentation
+    DWORD dwInMixbinPtrs[1];      // XRAM offsets in DSP WORDS, of input mixbins
+    DWORD dwOutMixbinPtrs[1];     // XRAM offsets in DSP WORDS, of output mixbins
+} GraphVoice_FX2_Voice_2_STATE, *LPGraphVoice_FX2_Voice_2_STATE;
+
+typedef const GraphVoice_FX2_Voice_2_STATE *LPCGraphVoice_FX2_Voice_2_STATE;
+
+typedef struct _GraphVoice_FX3_Voice_3_STATE {
+    DWORD dwScratchOffset;        // Offset in bytes, of scratch area for this FX
+    DWORD dwScratchLength;        // Length in DWORDS, of scratch area for this FX
+    DWORD dwYMemoryOffset;        // Offset in DSP WORDS, of Y memory area for this FX
+    DWORD dwYMemoryLength;        // Length in DSP WORDS, of Y memory area for this FX
+    DWORD dwFlags;                // FX bitfield for various flags. See xgpimage documentation
+    DWORD dwInMixbinPtrs[1];      // XRAM offsets in DSP WORDS, of input mixbins
+    DWORD dwOutMixbinPtrs[1];     // XRAM offsets in DSP WORDS, of output mixbins
+} GraphVoice_FX3_Voice_3_STATE, *LPGraphVoice_FX3_Voice_3_STATE;
+
+typedef const GraphVoice_FX3_Voice_3_STATE *LPCGraphVoice_FX3_Voice_3_STATE;
diff --git a/code/win32/starwars.ico b/code/win32/starwars.ico
new file mode 100644
index 0000000..ceefbbd
Binary files /dev/null and b/code/win32/starwars.ico differ
diff --git a/code/win32/vssver.scc b/code/win32/vssver.scc
new file mode 100644
index 0000000..04d9926
Binary files /dev/null and b/code/win32/vssver.scc differ
diff --git a/code/win32/win_file.h b/code/win32/win_file.h
new file mode 100644
index 0000000..0fafd40
--- /dev/null
+++ b/code/win32/win_file.h
@@ -0,0 +1,33 @@
+
+/*
+ * UNPUBLISHED -- Rights  reserved  under  the  copyright  laws  of the 
+ * United States.  Use  of a copyright notice is precautionary only and 
+ * does not imply publication or disclosure.                            
+ *                                                                      
+ * THIS DOCUMENTATION CONTAINS CONFIDENTIAL AND PROPRIETARY INFORMATION 
+ * OF    VICARIOUS   VISIONS,  INC.    ANY  DUPLICATION,  MODIFICATION, 
+ * DISTRIBUTION, OR DISCLOSURE IS STRICTLY PROHIBITED WITHOUT THE PRIOR 
+ * EXPRESS WRITTEN PERMISSION OF VICARIOUS VISIONS, INC.
+ */
+
+#ifndef _WIN_FILE_
+#define _WIN_FILE_
+
+typedef int wfhandle_t;
+
+extern void WF_Init(void);
+extern void WF_Shutdown(void);
+extern wfhandle_t WF_Open(const char* name, bool read, bool aligned);
+extern void WF_Close(wfhandle_t handle);
+extern int WF_Read(void* buffer, int len, wfhandle_t handle);
+extern int WF_Write(const void* buffer, int len, wfhandle_t handle);
+extern int WF_Seek(int offset, int origin, wfhandle_t handle);
+extern int WF_Tell(wfhandle_t handle);
+extern int WF_Resize(int size, wfhandle_t handle);
+
+int Sys_GetFileCode(const char *name);
+void Sys_InitFileCodes(void);
+void Sys_ShutdownFileCodes(void);
+
+
+#endif _WIN_FILE_
diff --git a/code/win32/win_file_xbox.cpp b/code/win32/win_file_xbox.cpp
new file mode 100644
index 0000000..66dcc9d
--- /dev/null
+++ b/code/win32/win_file_xbox.cpp
@@ -0,0 +1,173 @@
+
+/*
+ * UNPUBLISHED -- Rights  reserved  under  the  copyright  laws  of the 
+ * United States.  Use  of a copyright notice is precautionary only and 
+ * does not imply publication or disclosure.                            
+ *                                                                      
+ * THIS DOCUMENTATION CONTAINS CONFIDENTIAL AND PROPRIETARY INFORMATION 
+ * OF    VICARIOUS   VISIONS,  INC.    ANY  DUPLICATION,  MODIFICATION, 
+ * DISTRIBUTION, OR DISCLOSURE IS STRICTLY PROHIBITED WITHOUT THE PRIOR 
+ * EXPRESS WRITTEN PERMISSION OF VICARIOUS VISIONS, INC.
+ */
+
+#include "../game/q_shared.h"
+#include "win_file.h"
+#include "../qcommon/qcommon.h"
+
+#ifdef _XBOX
+#include <Xtl.h>
+#endif
+
+#ifdef _WINDOWS
+#include <windows.h>
+#endif
+
+
+struct FileTable
+{
+	bool m_bUsed;
+	bool m_bErrorsFatal;
+	HANDLE m_Handle;
+};
+
+FileTable* s_FileTable = NULL;
+const int WF_MAX_OPEN_FILES = 8;
+
+void WF_Init(void)
+{
+	assert(!s_FileTable);
+
+	s_FileTable = new FileTable[WF_MAX_OPEN_FILES];
+
+	for (wfhandle_t i = 0; i < WF_MAX_OPEN_FILES; ++i)
+	{
+		s_FileTable[i].m_bUsed = false;
+	}
+}
+
+void WF_Shutdown(void)
+{
+	assert(s_FileTable);
+	
+	for (wfhandle_t i = 0; i < WF_MAX_OPEN_FILES; ++i)
+	{
+		if (s_FileTable[i].m_bUsed)
+		{
+			WF_Close(i);
+		}
+	}
+
+	delete [] s_FileTable;
+	s_FileTable = NULL;
+}
+
+static wfhandle_t WF_GetFreeHandle(void)
+{
+	for (int i = 0; i < WF_MAX_OPEN_FILES; ++i)
+	{
+		if (!s_FileTable[i].m_bUsed)
+		{
+			return i;
+		}
+	}
+
+	return -1;
+}
+
+int WF_Open(const char* name, bool read, bool aligned)
+{
+	wfhandle_t handle = WF_GetFreeHandle();
+	if (handle == -1) return -1;
+	
+	s_FileTable[handle].m_Handle = 
+		CreateFile(name, read ? GENERIC_READ : GENERIC_READ | GENERIC_WRITE, 
+		FILE_SHARE_READ, 0, 
+		read ? OPEN_EXISTING : OPEN_ALWAYS, 
+		FILE_ATTRIBUTE_NORMAL |(aligned ? FILE_FLAG_NO_BUFFERING : 0) , 0);
+
+	if (s_FileTable[handle].m_Handle != INVALID_HANDLE_VALUE)
+	{
+		s_FileTable[handle].m_bUsed = true;
+		
+		// errors are fatal on game partition
+		s_FileTable[handle].m_bErrorsFatal = (name[0] == 'D' || name[0] == 'd');
+		
+		return handle;
+	}
+	
+	return -1;
+}
+
+void WF_Close(wfhandle_t handle)
+{
+	assert(handle >= 0 && handle < WF_MAX_OPEN_FILES && 
+		s_FileTable[handle].m_bUsed);
+
+	CloseHandle(s_FileTable[handle].m_Handle);
+	s_FileTable[handle].m_bUsed = false;
+}
+
+int WF_Read(void* buffer, int len, wfhandle_t handle)
+{
+	assert(handle >= 0 && handle < WF_MAX_OPEN_FILES && 
+		s_FileTable[handle].m_bUsed);
+
+	DWORD bytes;
+	if (!ReadFile(s_FileTable[handle].m_Handle, buffer, len, &bytes, 0) &&
+		s_FileTable[handle].m_bErrorsFatal)
+	{
+#if defined(FINAL_BUILD)
+		/*
+		extern void ERR_DiscFail(bool);
+		ERR_DiscFail(false);
+		*/
+#else
+		assert(0);
+#endif
+	}
+
+	return bytes;
+}
+
+int WF_Write(const void* buffer, int len, wfhandle_t handle)
+{
+	assert(handle >= 0 && handle < WF_MAX_OPEN_FILES && 
+		s_FileTable[handle].m_bUsed);
+
+	DWORD bytes;
+	WriteFile(s_FileTable[handle].m_Handle, buffer, len, &bytes, 0);
+	return bytes;
+}
+
+int WF_Seek(int offset, int origin, wfhandle_t handle)
+{
+	assert(handle >= 0 && handle < WF_MAX_OPEN_FILES && 
+		s_FileTable[handle].m_bUsed);
+
+	switch (origin)
+	{
+	case SEEK_CUR: origin = FILE_CURRENT; break;
+	case SEEK_END: origin = FILE_END; break;
+	case SEEK_SET: origin = FILE_BEGIN; break;
+	default: assert(false);
+	}
+
+	return SetFilePointer(s_FileTable[handle].m_Handle, offset, 0, origin) < 0;
+}
+
+int WF_Tell(wfhandle_t handle)
+{
+	assert(handle >= 0 && handle < WF_MAX_OPEN_FILES && 
+		s_FileTable[handle].m_bUsed);
+
+	return SetFilePointer(s_FileTable[handle].m_Handle, 0, 0, FILE_CURRENT);
+}
+
+int WF_Resize(int size, wfhandle_t handle)
+{
+	assert(handle >= 0 && handle < WF_MAX_OPEN_FILES && 
+		s_FileTable[handle].m_bUsed);
+
+	SetFilePointer(s_FileTable[handle].m_Handle, size, NULL, FILE_BEGIN);
+	return SetEndOfFile(s_FileTable[handle].m_Handle);
+}
diff --git a/code/win32/win_filecode.cpp b/code/win32/win_filecode.cpp
new file mode 100644
index 0000000..7dd55f8
--- /dev/null
+++ b/code/win32/win_filecode.cpp
@@ -0,0 +1,346 @@
+
+/*
+ * UNPUBLISHED -- Rights  reserved  under  the  copyright  laws  of the 
+ * United States.  Use  of a copyright notice is precautionary only and 
+ * does not imply publication or disclosure.                            
+ *                                                                      
+ * THIS DOCUMENTATION CONTAINS CONFIDENTIAL AND PROPRIETARY INFORMATION 
+ * OF    VICARIOUS   VISIONS,  INC.    ANY  DUPLICATION,  MODIFICATION, 
+ * DISTRIBUTION, OR DISCLOSURE IS STRICTLY PROHIBITED WITHOUT THE PRIOR 
+ * EXPRESS WRITTEN PERMISSION OF VICARIOUS VISIONS, INC.
+ */
+
+#include "../server/exe_headers.h"
+#include "../client/client.h"
+#include "../win32/win_local.h"
+#include "../qcommon/qcommon.h"
+#include "../qcommon/fixedmap.h"
+#include "../zlib/zlib.h"
+#include "../qcommon/files.h"
+
+/***********************************************
+*
+* WINDOWS/XBOX VERSION
+*
+* Build a translation table, CRC -> file name.  We have the memory.
+*
+************************************************/
+
+#if defined(_WINDOWS)
+#include <windows.h>
+#elif defined(_XBOX)
+#include <xtl.h>
+#endif
+
+struct FileInfo
+{
+	char* name;
+	int size;
+};
+static VVFixedMap< FileInfo, unsigned int >* s_Files = NULL;
+static byte* buffer;
+
+HANDLE s_Mutex = INVALID_HANDLE_VALUE;
+
+int _buildFileList(const char* path, bool insert, bool buildList)
+{
+	WIN32_FIND_DATA data;
+	char spec[MAX_OSPATH];
+	int count = 0;
+
+	// Look for all files
+	Com_sprintf(spec, sizeof(spec), "%s\\*.*", path);
+
+	HANDLE h = FindFirstFile(spec, &data);
+	while (h != INVALID_HANDLE_VALUE)
+	{
+		char full[MAX_OSPATH];
+		Com_sprintf(full, sizeof(full), "%s\\%s", path, data.cFileName);
+
+		if (data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
+		{
+			// Directory -- lets go recursive
+			if (data.cFileName[0] != '.') {
+				count += _buildFileList(full, insert, buildList);
+			}
+		}
+		else
+		{
+
+			if(insert || buildList)
+			{
+				// Regular file -- add it to the table
+				strlwr(full);
+				unsigned int code = crc32(0, (const byte *)full, strlen(full));
+
+				FileInfo info;
+				info.name = CopyString(full);
+				info.size = data.nFileSizeLow;
+
+				if(insert)
+				{
+					s_Files->Insert(info, code);
+				}
+
+				if(buildList)
+				{
+					// get the length of the filename
+					int len;
+					len = strlen(info.name) + 1;
+
+					// save the file code
+					*(int*)buffer		=  code;
+					buffer				+= sizeof(code);
+
+					// save the name of the file
+					strcpy((char*)buffer,info.name);
+					buffer				+= len;
+
+					// save the size of the file
+					*(int*)buffer		= info.size;
+					buffer				+= sizeof(info.size);
+				}
+			}
+
+			count++;
+		}
+
+		// Continue the loop
+		if (!FindNextFile(h, &data))
+		{
+			FindClose(h);
+			return count;
+		}
+	}
+	return count;
+}
+
+bool _buildFileListFromSavedList(void)
+{
+	// open the file up for reading
+	FILE*	in;
+	in = fopen("d:\\xbx_filelist","rb");
+	if(!in)
+	{
+		return false;
+	}
+
+	// read in the number of files
+	int count;
+	if(!(fread(&count,sizeof(count),1,in)))
+	{
+		fclose(in);
+		return false;
+	}
+
+	// allocate memory for a temp buffer
+	byte*	baseAddr;
+	int bufferSize;
+	bufferSize	= count * ( 2 * sizeof(int) + MAX_OSPATH );
+	buffer		= (byte*)Z_Malloc(bufferSize,TAG_TEMP_WORKSPACE,qtrue,32);
+	baseAddr	= buffer;
+
+	// read the rest of the file into a big buffer
+	if(!(fread(buffer,bufferSize,1,in)))
+	{
+		fclose(in);
+		Z_Free(baseAddr);
+		return false;
+	}
+
+	// allocate some memory for s_Files
+	s_Files = new VVFixedMap<FileInfo, unsigned int>(count);
+
+	// loop through all the files write out the codes
+	int i;
+	for(i = 0; i < count; i++)
+	{
+		FileInfo info;
+		unsigned int code;
+
+		// read the code for the file
+		code	=  *(int*)buffer;
+		buffer	+= sizeof(code);
+
+		// read the filename
+		info.name = CopyString((char*)buffer);
+		buffer	+= (strlen(info.name) + 1);
+
+		// read the size of the file
+		info.size	=  *(int*)buffer;
+		buffer		+= sizeof(info.size);
+
+		// save the data
+		s_Files->Insert(info, code);
+	}
+
+	fclose(in);
+	Z_Free(baseAddr);
+	return true;
+}
+
+bool Sys_SaveFileCodes(void)
+{
+	bool ret;
+	int res;
+
+	// get the number of files
+	int count;
+	count = _buildFileList(Sys_Cwd(), false, false);
+
+	// open a file for writing
+	FILE* out;
+	out = fopen("d:\\xbx_filelist","wb");
+	if(!out)
+	{
+		return false;
+	}
+
+	// allocate a buffer for writing
+	byte*	baseAddr;
+	int		bufferSize;
+	
+	bufferSize	= sizeof(int) + ( count * ( 2 * sizeof(int) + MAX_OSPATH ) );
+	baseAddr	= (byte*)Z_Malloc(bufferSize,TAG_TEMP_WORKSPACE,qtrue,32);
+	buffer		= baseAddr;
+
+	// write the number of files to the buffer
+	*(int*)buffer	=  count;
+	buffer			+= sizeof(count);
+
+	// fill up the rest of the buffer
+	ret = _buildFileList(Sys_Cwd(), false, true);
+
+	if(!ret)
+	{
+		// there was a problem
+		fclose(out);
+		Z_Free(baseAddr);
+		return false;
+	}
+
+	// attempt to write out the data
+	if(!(fwrite(baseAddr,bufferSize,1,out)))
+	{
+		// there was a problem
+		fclose(out);
+		Z_Free(baseAddr);
+		return false;
+	}
+
+	// everything went ok
+	fclose(out);
+	Z_Free(baseAddr);
+	return true;
+}
+
+void Sys_InitFileCodes(void)
+{
+	bool ret;
+	int count = 0;
+
+	// First: try to load an existing filecode cache
+	ret = _buildFileListFromSavedList();
+
+	// if we had trouble building the list that way
+	// we need to do it by searching the files
+	if( !ret )
+	{
+		// There was no filelist cache, make one
+		if( !Sys_SaveFileCodes() )
+			Com_Error( ERR_DROP, "ERROR: Couldn't create filecode cache\n" );
+
+		// Now re-read it
+		if( !_buildFileListFromSavedList() )
+			Com_Error( ERR_DROP, "ERROR: Couldn't re-read filecode cache\n" );
+	}
+	s_Files->Sort();
+
+	// make it thread safe
+	s_Mutex = CreateMutex(NULL, FALSE, NULL);
+}
+
+void Sys_ShutdownFileCodes(void)
+{
+	FileInfo*	info = NULL;
+
+	info = s_Files->Pop();
+	while(info)
+	{
+		Z_Free(info->name);
+		info->name = NULL;
+		info = s_Files->Pop();
+	}
+
+	delete s_Files;
+	s_Files = NULL;
+
+	CloseHandle(s_Mutex);
+}
+
+int Sys_GetFileCode(const char* name)
+{
+	WaitForSingleObject(s_Mutex, INFINITE);
+
+	// Get system level path
+	char* osname = FS_BuildOSPath(name);
+	
+	// Generate hash for file name
+	strlwr(osname);
+	unsigned int code = crc32(0, (const byte *)osname, strlen(osname));
+	
+	// Check if the file exists
+	if (!s_Files->Find(code))
+	{
+		ReleaseMutex(s_Mutex);
+		return -1;
+	}
+
+	ReleaseMutex(s_Mutex);
+	return code;
+}
+
+const char* Sys_GetFileCodeName(int code)
+{
+	WaitForSingleObject(s_Mutex, INFINITE);
+
+	FileInfo *entry = s_Files->Find(code);
+	if (entry)
+	{
+		ReleaseMutex(s_Mutex);
+		return entry->name;
+	}
+	
+	ReleaseMutex(s_Mutex);
+	return NULL;
+}
+
+int Sys_GetFileCodeSize(int code)
+{
+	WaitForSingleObject(s_Mutex, INFINITE);
+
+	FileInfo *entry = s_Files->Find(code);
+	if (entry)
+	{
+		ReleaseMutex(s_Mutex);
+		return entry->size;
+	}
+	
+	ReleaseMutex(s_Mutex);
+	return -1;
+}
+
+// Quick function to re-scan for new files, update the filecode
+// table, and dump the new one to disk
+void Sys_FilecodeScan_f( void )
+{
+	// Make an updated filecode cache
+	if( !Sys_SaveFileCodes() )
+		Com_Error( ERR_DROP, "ERROR: Couldn't create filecode cache\n" );
+
+	// Throw out our current list
+	Sys_ShutdownFileCodes();
+
+	// Re-init, which should use the new list we just made
+	Sys_InitFileCodes();
+}
diff --git a/code/win32/win_gamma.cpp b/code/win32/win_gamma.cpp
new file mode 100644
index 0000000..5849eea
--- /dev/null
+++ b/code/win32/win_gamma.cpp
@@ -0,0 +1,141 @@
+/*
+** WIN_GAMMA.C
+*/
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+
+
+#include <assert.h>
+#include "../renderer/tr_local.h"
+#include "../qcommon/qcommon.h"
+#include "glw_win.h"
+#include "win_local.h"
+
+static unsigned short s_oldHardwareGamma[3][256];
+
+/*
+** WG_CheckHardwareGamma
+**
+** Determines if the underlying hardware supports the Win32 gamma correction API.
+*/
+void WG_CheckHardwareGamma( void )
+{
+	HDC			hDC;
+
+	glConfig.deviceSupportsGamma = qfalse;
+
+	if ( !r_ignorehwgamma->integer )
+	{
+		hDC = GetDC( GetDesktopWindow() );
+		glConfig.deviceSupportsGamma = GetDeviceGammaRamp( hDC, s_oldHardwareGamma );
+		ReleaseDC( GetDesktopWindow(), hDC );
+
+		if ( glConfig.deviceSupportsGamma )
+		{
+			//
+			// do a sanity check on the gamma values
+			//
+			if ( ( HIBYTE( s_oldHardwareGamma[0][255] ) <= HIBYTE( s_oldHardwareGamma[0][0] ) ) ||
+				 ( HIBYTE( s_oldHardwareGamma[1][255] ) <= HIBYTE( s_oldHardwareGamma[1][0] ) ) ||
+				 ( HIBYTE( s_oldHardwareGamma[2][255] ) <= HIBYTE( s_oldHardwareGamma[2][0] ) ) )
+			{
+				glConfig.deviceSupportsGamma = qfalse;
+				VID_Printf( PRINT_WARNING, "WARNING: device has broken gamma support, generated gamma.dat\n" );
+			}
+
+			//
+			// make sure that we didn't have a prior crash in the game, and if so we need to
+			// restore the gamma values to at least a linear value
+			//
+			if ( ( HIBYTE( s_oldHardwareGamma[0][181] ) == 255 ) )
+			{
+				int g;
+
+				VID_Printf( PRINT_WARNING, "WARNING: suspicious gamma tables, using linear ramp for restoration\n" );
+
+				for ( g = 0; g < 255; g++ )
+				{
+					s_oldHardwareGamma[0][g] = g << 8;
+					s_oldHardwareGamma[1][g] = g << 8;
+					s_oldHardwareGamma[2][g] = g << 8;
+				}
+			}
+		}
+	}
+}
+
+/*
+** GLimp_SetGamma
+**
+** This routine should only be called if glConfig.deviceSupportsGamma is TRUE
+*/
+void GLimp_SetGamma( unsigned char red[256], unsigned char green[256], unsigned char blue[256] ) {
+	unsigned short table[3][256];
+	int		i, j;
+	int		ret;
+	OSVERSIONINFO	vinfo;
+
+	if ( !glConfig.deviceSupportsGamma || r_ignorehwgamma->integer || !glw_state.hDC ) {
+		return;
+	}
+
+//mapGammaMax();
+
+	for ( i = 0; i < 256; i++ ) {
+		table[0][i] = ( ( ( unsigned short ) red[i] ) << 8 ) | red[i];
+		table[1][i] = ( ( ( unsigned short ) green[i] ) << 8 ) | green[i];
+		table[2][i] = ( ( ( unsigned short ) blue[i] ) << 8 ) | blue[i];
+	}
+
+	// Win2K puts this odd restriction on gamma ramps...
+	vinfo.dwOSVersionInfoSize = sizeof(vinfo);
+	GetVersionEx( &vinfo );
+	if ( vinfo.dwMajorVersion == 5 && vinfo.dwPlatformId == VER_PLATFORM_WIN32_NT ) {
+		Com_DPrintf( "performing W2K gamma clamp.\n" );
+		for ( j = 0 ; j < 3 ; j++ ) {
+			for ( i = 0 ; i < 128 ; i++ ) {
+				if ( table[j][i] > ( (128+i) << 8 ) ) {
+					table[j][i] = (128+i) << 8;
+				}
+			}
+			if ( table[j][127] > 254<<8 ) {
+				table[j][127] = 254<<8;
+			}
+		}
+	} else {
+		Com_DPrintf( "skipping W2K gamma clamp.\n" );
+	}
+
+	// enforce constantly increasing
+	for ( j = 0 ; j < 3 ; j++ ) {
+		for ( i = 1 ; i < 256 ; i++ ) {
+			if ( table[j][i] < table[j][i-1] ) {
+				table[j][i] = table[j][i-1];
+			}
+		}
+	}
+
+
+	ret = SetDeviceGammaRamp( glw_state.hDC, table );
+	if ( !ret ) {
+		Com_Printf( "SetDeviceGammaRamp failed.\n" );
+	}
+}
+
+/*
+** WG_RestoreGamma
+*/
+void WG_RestoreGamma( void )
+{
+	if ( glConfig.deviceSupportsGamma )
+	{
+		HDC hDC;
+		
+		hDC = GetDC( GetDesktopWindow() );
+		SetDeviceGammaRamp( hDC, s_oldHardwareGamma );
+		ReleaseDC( GetDesktopWindow(), hDC );
+	}
+}
+
diff --git a/code/win32/win_gamma_console.cpp b/code/win32/win_gamma_console.cpp
new file mode 100644
index 0000000..309845c
--- /dev/null
+++ b/code/win32/win_gamma_console.cpp
@@ -0,0 +1,73 @@
+/*
+** WIN_GAMMA.C
+*/
+// leave this as first line for PCH reasons...
+//
+//#include "../server/exe_headers.h"
+
+
+
+#include <assert.h>
+#include "../game/q_shared.h"
+#include "../renderer/tr_local.h"
+#include "../qcommon/qcommon.h"
+#include "win_local.h"
+
+#if defined(_XBOX)
+#include "glw_win_dx8.h"
+#endif
+
+
+/*
+** WG_CheckHardwareGamma
+**
+** Determines if the underlying hardware supports the Win32 gamma correction API.
+*/
+void WG_CheckHardwareGamma( void )
+{
+	glConfig.deviceSupportsGamma = qtrue;
+}
+
+/*
+** GLimp_SetGamma
+**
+** This routine should only be called if glConfig.deviceSupportsGamma is TRUE
+*/
+void GLimp_SetGamma( float g ) {
+#if defined(_GAMECUBE)
+	GXGamma gamma = GX_GM_1_0;
+	if (g >= 2.2f)
+	{
+		gamma = GX_GM_2_2;
+	}
+	else if (g >= 1.7f)
+	{
+		gamma = GX_GM_1_7;
+	}
+	GXSetDispCopyGamma(gamma);
+#elif defined(_XBOX)
+	const int maxval = 255;
+
+	D3DGAMMARAMP ramp;
+	for ( int i = 0; i < 256; i++ )
+	{
+		int inf;
+		if ( g == 1 ) {
+			inf = maxval * i / 255.0f;
+		} else {
+			inf = maxval * pow ( i/255.0f, 1.0f / g ) + 0.5f;
+		}
+		if (inf < 0) {
+			inf = 0;
+		}
+		if (inf > maxval) {
+			inf = maxval;
+		}
+		ramp.red[i] = inf;
+		ramp.green[i] = inf;
+		ramp.blue[i] = inf;
+	}
+	glw_state->device->SetGammaRamp(D3DSGR_CALIBRATE, &ramp);
+#endif
+}
+
diff --git a/code/win32/win_glimp.cpp b/code/win32/win_glimp.cpp
new file mode 100644
index 0000000..ee7445e
--- /dev/null
+++ b/code/win32/win_glimp.cpp
@@ -0,0 +1,1815 @@
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+
+/*
+** WIN_GLIMP.C
+**
+** This file contains ALL Win32 specific stuff having to do with the
+** OpenGL refresh.  When a port is being made the following functions
+** must be implemented by the port:
+**
+** GLimp_EndFrame
+** GLimp_Init
+** GLimp_LogComment
+** GLimp_Shutdown
+**
+** Note that the GLW_xxx functions are Windows specific GL-subsystem
+** related functions that are relevant ONLY to win_glimp.c
+*/
+#include <assert.h>
+#include "../renderer/tr_local.h"
+#include "../qcommon/qcommon.h"
+#include "glw_win.h"
+#include "win_local.h"
+#include "resource.h"	//JFM: to get icon
+
+extern void WG_CheckHardwareGamma( void );
+extern void WG_RestoreGamma( void );
+
+typedef enum {
+	RSERR_OK,
+
+	RSERR_INVALID_FULLSCREEN,
+	RSERR_INVALID_MODE,
+
+	RSERR_UNKNOWN
+} rserr_t;
+
+#define TRY_PFD_SUCCESS		0
+#define TRY_PFD_FAIL_SOFT	1
+#define TRY_PFD_FAIL_HARD	2
+
+#define	WINDOW_CLASS_NAME	"Jedi Knight®: Jedi Academy"
+
+static void		GLW_InitExtensions( void );
+static rserr_t	GLW_SetMode( int mode, 
+							 int colorbits, 
+							 qboolean cdsFullscreen );
+
+static qboolean s_classRegistered = qfalse;
+
+//
+// function declaration
+//
+void	 QGL_EnableLogging( qboolean enable );
+qboolean QGL_Init( const char *dllname );
+void     QGL_Shutdown( void );
+
+//
+// variable declarations
+//
+glwstate_t glw_state;
+
+cvar_t	*r_allowSoftwareGL;		// don't abort out if the pixelformat claims software
+cvar_t	*r_maskMinidriver;		// allow a different dll name to be treated as if it were opengl32.dll
+
+// Whether the current hardware supports dynamic glows/flares.
+extern bool g_bDynamicGlowSupported;
+
+// Hack variable for deciding which kind of texture rectangle thing to do (for some
+// reason it acts different on radeon! It's against the spec!).
+bool g_bTextureRectangleHack = false;
+
+
+/*
+** GLW_StartDriverAndSetMode
+*/
+static qboolean GLW_StartDriverAndSetMode( int mode, 
+										   int colorbits,
+										   qboolean cdsFullscreen )
+{
+	rserr_t err;
+
+	err = GLW_SetMode( mode, colorbits, cdsFullscreen );
+
+	switch ( err )
+	{
+	case RSERR_INVALID_FULLSCREEN:
+		VID_Printf( PRINT_ALL, "...WARNING: fullscreen unavailable in this mode\n" );
+		return qfalse;
+	case RSERR_INVALID_MODE:
+		VID_Printf( PRINT_ALL, "...WARNING: could not set the given mode (%d)\n", mode );
+		return qfalse;
+	default:
+		break;
+	}
+	return qtrue;
+}
+
+/*
+** ChoosePFD
+**
+** Helper function that replaces ChoosePixelFormat.
+*/
+#define MAX_PFDS 256
+
+static int GLW_ChoosePFD( HDC hDC, PIXELFORMATDESCRIPTOR *pPFD )
+{
+	PIXELFORMATDESCRIPTOR pfds[MAX_PFDS+1];
+	int maxPFD = 0;
+	int i;
+	int bestMatch = 0;
+
+	VID_Printf( PRINT_ALL, "...GLW_ChoosePFD( %d, %d, %d )\n", ( int ) pPFD->cColorBits, ( int ) pPFD->cDepthBits, ( int ) pPFD->cStencilBits );
+
+	// count number of PFDs
+	maxPFD = DescribePixelFormat( hDC, 1, sizeof( PIXELFORMATDESCRIPTOR ), &pfds[0] );
+	if ( maxPFD > MAX_PFDS )
+	{
+		VID_Printf( PRINT_WARNING, "...numPFDs > MAX_PFDS (%d > %d)\n", maxPFD, MAX_PFDS );
+		maxPFD = MAX_PFDS;
+	}
+
+	VID_Printf( PRINT_ALL, "...%d PFDs found\n", maxPFD - 1 );
+
+	// grab information
+	for ( i = 1; i <= maxPFD; i++ )
+	{
+		DescribePixelFormat( hDC, i, sizeof( PIXELFORMATDESCRIPTOR ), &pfds[i] );
+	}
+
+	// look for a best match
+	for ( i = 1; i <= maxPFD; i++ )
+	{
+		//
+		// make sure this has hardware acceleration
+		//
+		if ( ( pfds[i].dwFlags & PFD_GENERIC_FORMAT ) != 0 ) 
+		{
+			if ( !r_allowSoftwareGL->integer )
+			{
+				if ( r_verbose->integer )
+				{
+					VID_Printf( PRINT_ALL, "...PFD %d rejected, software acceleration\n", i );
+				}
+				continue;
+			}
+		}
+
+		// verify pixel type
+		if ( pfds[i].iPixelType != PFD_TYPE_RGBA )
+		{
+			if ( r_verbose->integer )
+			{
+				VID_Printf( PRINT_ALL, "...PFD %d rejected, not RGBA\n", i );
+			}
+			continue;
+		}
+
+		// verify proper flags
+		if ( ( ( pfds[i].dwFlags & pPFD->dwFlags ) & pPFD->dwFlags ) != pPFD->dwFlags ) 
+		{
+			if ( r_verbose->integer )
+			{
+				VID_Printf( PRINT_ALL, "...PFD %d rejected, improper flags (%x instead of %x)\n", i, pfds[i].dwFlags, pPFD->dwFlags );
+			}
+			continue;
+		}
+
+		// verify enough bits
+		if ( pfds[i].cDepthBits < 15 )
+		{
+			continue;
+		}
+		if ( ( pfds[i].cStencilBits < 4 ) && ( pPFD->cStencilBits > 0 ) )
+		{
+			continue;
+		}
+
+		//
+		// selection criteria (in order of priority):
+		// 
+		//  PFD_STEREO
+		//  colorBits
+		//  depthBits
+		//  stencilBits
+		//
+		if ( bestMatch )
+		{
+			// check stereo
+			if ( ( pfds[i].dwFlags & PFD_STEREO ) && ( !( pfds[bestMatch].dwFlags & PFD_STEREO ) ) && ( pPFD->dwFlags & PFD_STEREO ) )
+			{
+				bestMatch = i;
+				continue;
+			}
+			
+			if ( !( pfds[i].dwFlags & PFD_STEREO ) && ( pfds[bestMatch].dwFlags & PFD_STEREO ) && ( pPFD->dwFlags & PFD_STEREO ) )
+			{
+				bestMatch = i;
+				continue;
+			}
+
+			// check color
+			if ( pfds[bestMatch].cColorBits != pPFD->cColorBits )
+			{
+				// prefer perfect match
+				if ( pfds[i].cColorBits == pPFD->cColorBits )
+				{
+					bestMatch = i;
+					continue;
+				}
+				// otherwise if this PFD has more bits than our best, use it
+				else if ( pfds[i].cColorBits > pfds[bestMatch].cColorBits )
+				{
+					bestMatch = i;
+					continue;
+				}
+			}
+
+			// check depth
+			if ( pfds[bestMatch].cDepthBits != pPFD->cDepthBits )
+			{
+				// prefer perfect match
+				if ( pfds[i].cDepthBits == pPFD->cDepthBits )
+				{
+					bestMatch = i;
+					continue;
+				}
+				// otherwise if this PFD has more bits than our best, use it
+				else if ( pfds[i].cDepthBits > pfds[bestMatch].cDepthBits )
+				{
+					bestMatch = i;
+					continue;
+				}
+			}
+
+			// check stencil
+			if ( pfds[bestMatch].cStencilBits != pPFD->cStencilBits )
+			{
+				// prefer perfect match
+				if ( pfds[i].cStencilBits == pPFD->cStencilBits )
+				{
+					bestMatch = i;
+					continue;
+				}
+				// otherwise if this PFD has more bits than our best, use it
+				else if ( ( pfds[i].cStencilBits > pfds[bestMatch].cStencilBits ) && 
+					 ( pPFD->cStencilBits > 0 ) )
+				{
+					bestMatch = i;
+					continue;
+				}
+			}
+		}
+		else
+		{
+			bestMatch = i;
+		}
+	}
+	
+	if ( !bestMatch )
+		return 0;
+
+	if ( ( pfds[bestMatch].dwFlags & PFD_GENERIC_FORMAT ) != 0 )
+	{
+		if ( !r_allowSoftwareGL->integer )
+		{
+			VID_Printf( PRINT_ALL, "...no hardware acceleration found\n" );
+			return 0;
+		}
+		else
+		{
+			VID_Printf( PRINT_ALL, "...using software emulation\n" );
+		}
+	}
+	else if ( pfds[bestMatch].dwFlags & PFD_GENERIC_ACCELERATED )
+	{
+		VID_Printf( PRINT_ALL, "...MCD acceleration found\n" );
+	}
+	else
+	{
+		VID_Printf( PRINT_ALL, "...hardware acceleration found\n" );
+	}
+
+	*pPFD = pfds[bestMatch];
+
+	return bestMatch;
+}
+
+/*
+** void GLW_CreatePFD
+**
+** Helper function zeros out then fills in a PFD
+*/
+static void GLW_CreatePFD( PIXELFORMATDESCRIPTOR *pPFD, int colorbits, int depthbits, int stencilbits, qboolean stereo )
+{
+    PIXELFORMATDESCRIPTOR src = 
+	{
+		sizeof(PIXELFORMATDESCRIPTOR),	// size of this pfd
+		1,								// version number
+		PFD_DRAW_TO_WINDOW |			// support window
+		PFD_SUPPORT_OPENGL |			// support OpenGL
+		PFD_DOUBLEBUFFER,				// double buffered
+		PFD_TYPE_RGBA,					// RGBA type
+		24,								// 24-bit color depth
+		0, 0, 0, 0, 0, 0,				// color bits ignored
+		0,								// no alpha buffer
+		0,								// shift bit ignored
+		0,								// no accumulation buffer
+		0, 0, 0, 0, 					// accum bits ignored
+		24,								// 24-bit z-buffer	
+		8,								// 8-bit stencil buffer
+		0,								// no auxiliary buffer
+		PFD_MAIN_PLANE,					// main layer
+		0,								// reserved
+		0, 0, 0							// layer masks ignored
+    };
+
+	src.cColorBits = colorbits;
+	src.cDepthBits = depthbits;
+	src.cStencilBits = stencilbits;
+
+	if ( stereo )
+	{
+		VID_Printf( PRINT_ALL, "...attempting to use stereo\n" );
+		src.dwFlags |= PFD_STEREO;
+		glConfig.stereoEnabled = qtrue;
+	}
+	else
+	{
+		glConfig.stereoEnabled = qfalse;
+	}
+
+	*pPFD = src;
+}
+
+/*
+** GLW_MakeContext
+*/
+static int GLW_MakeContext( PIXELFORMATDESCRIPTOR *pPFD )
+{
+	int pixelformat;
+
+	//
+	// don't putz around with pixelformat if it's already set (e.g. this is a soft
+	// reset of the graphics system)
+	//
+	if ( !glw_state.pixelFormatSet )
+	{
+		//
+		// choose, set, and describe our desired pixel format.  If we're
+		// using a minidriver then we need to bypass the GDI functions,
+		// otherwise use the GDI functions.
+		//
+		if ( ( pixelformat = GLW_ChoosePFD( glw_state.hDC, pPFD ) ) == 0 )
+		{
+			VID_Printf( PRINT_ALL, "...GLW_ChoosePFD failed\n");
+			return TRY_PFD_FAIL_SOFT;
+		}
+		VID_Printf( PRINT_ALL, "...PIXELFORMAT %d selected\n", pixelformat );
+
+		DescribePixelFormat( glw_state.hDC, pixelformat, sizeof( *pPFD ), pPFD );
+
+		if ( SetPixelFormat( glw_state.hDC, pixelformat, pPFD ) == FALSE )
+		{
+			VID_Printf (PRINT_ALL, "...SetPixelFormat failed\n", glw_state.hDC );
+			return TRY_PFD_FAIL_SOFT;
+		}
+
+		glw_state.pixelFormatSet = qtrue;
+	}
+
+	//
+	// startup the OpenGL subsystem by creating a context and making it current
+	//
+	if ( !glw_state.hGLRC )
+	{
+		VID_Printf( PRINT_ALL, "...creating GL context: " );
+		if ( ( glw_state.hGLRC = qwglCreateContext( glw_state.hDC ) ) == 0 )
+		{
+			VID_Printf (PRINT_ALL, "failed\n");
+
+			return TRY_PFD_FAIL_HARD;
+		}
+		VID_Printf( PRINT_ALL, "succeeded\n" );
+
+		VID_Printf( PRINT_ALL, "...making context current: " );
+		if ( !qwglMakeCurrent( glw_state.hDC, glw_state.hGLRC ) )
+		{
+			qwglDeleteContext( glw_state.hGLRC );
+			glw_state.hGLRC = NULL;
+			VID_Printf (PRINT_ALL, "failed\n");
+			return TRY_PFD_FAIL_HARD;
+		}
+		VID_Printf( PRINT_ALL, "succeeded\n" );
+	}
+
+	return TRY_PFD_SUCCESS;
+}
+
+
+/*
+** GLW_InitDriver
+**
+** - get a DC if one doesn't exist
+** - create an HGLRC if one doesn't exist
+*/
+static qboolean GLW_InitDriver( int colorbits )
+{
+	int		tpfd;
+	int		depthbits, stencilbits;
+    static PIXELFORMATDESCRIPTOR pfd;		// save between frames since 'tr' gets cleared
+
+	VID_Printf( PRINT_ALL, "Initializing OpenGL driver\n" );
+
+	//
+	// get a DC for our window if we don't already have one allocated
+	//
+	if ( glw_state.hDC == NULL )
+	{
+		VID_Printf( PRINT_ALL, "...getting DC: " );
+
+		if ( ( glw_state.hDC = GetDC( g_wv.hWnd ) ) == NULL )
+		{
+			VID_Printf( PRINT_ALL, "failed\n" );
+			return qfalse;
+		}
+		VID_Printf( PRINT_ALL, "succeeded\n" );
+	}
+
+	if ( colorbits == 0 )
+	{
+		colorbits = glw_state.desktopBitsPixel;
+	}
+
+	//
+	// implicitly assume Z-buffer depth == desktop color depth
+	//
+	if ( r_depthbits->integer == 0 ) {
+		if ( colorbits > 16 ) {
+			depthbits = 24;
+		} else {
+			depthbits = 16;
+		}
+	} else {
+		depthbits = r_depthbits->integer;
+	}
+
+	//
+	// do not allow stencil if Z-buffer depth likely won't contain it
+	//
+	stencilbits = r_stencilbits->integer;
+	if ( depthbits < 24 )
+	{
+		stencilbits = 0;
+	}
+
+	//
+	// make two attempts to set the PIXELFORMAT
+	//
+
+	//
+	// first attempt: r_colorbits, depthbits, and r_stencilbits
+	//
+	if ( !glw_state.pixelFormatSet )
+	{
+		GLW_CreatePFD( &pfd, colorbits, depthbits, stencilbits, r_stereo->integer );
+		if ( ( tpfd = GLW_MakeContext( &pfd ) ) != TRY_PFD_SUCCESS )
+		{
+			if ( tpfd == TRY_PFD_FAIL_HARD )
+			{
+				VID_Printf( PRINT_WARNING, "...failed hard\n" );
+				return qfalse;
+			}
+
+			//
+			// punt if we've already tried the desktop bit depth and no stencil bits
+			//
+			if ( ( r_colorbits->integer == glw_state.desktopBitsPixel ) &&
+				 ( stencilbits == 0 ) )
+			{
+				ReleaseDC( g_wv.hWnd, glw_state.hDC );
+				glw_state.hDC = NULL;
+
+				VID_Printf( PRINT_ALL, "...failed to find an appropriate PIXELFORMAT\n" );
+
+				return qfalse;
+			}
+
+			//
+			// second attempt: desktop's color bits and no stencil
+			//
+			if ( colorbits > glw_state.desktopBitsPixel )
+			{
+				colorbits = glw_state.desktopBitsPixel;
+			}
+			GLW_CreatePFD( &pfd, colorbits, depthbits, 0, r_stereo->integer );
+			if ( GLW_MakeContext( &pfd ) != TRY_PFD_SUCCESS )
+			{
+				if ( glw_state.hDC )
+				{
+					ReleaseDC( g_wv.hWnd, glw_state.hDC );
+					glw_state.hDC = NULL;
+				}
+
+				VID_Printf( PRINT_ALL, "...failed to find an appropriate PIXELFORMAT\n" );
+
+				return qfalse;
+			}
+		}
+
+		/*
+		** report if stereo is desired but unavailable
+		*/
+		if ( !( pfd.dwFlags & PFD_STEREO ) && ( r_stereo->integer != 0 ) ) 
+		{
+			VID_Printf( PRINT_ALL, "...failed to select stereo pixel format\n" );
+			glConfig.stereoEnabled = qfalse;
+		}
+	}
+
+	/*
+	** store PFD specifics 
+	*/
+	glConfig.colorBits = ( int ) pfd.cColorBits;
+	glConfig.depthBits = ( int ) pfd.cDepthBits;
+	glConfig.stencilBits = ( int ) pfd.cStencilBits;
+
+	return qtrue;
+}
+
+/*
+** GLW_CreateWindow
+**
+** Responsible for creating the Win32 window and initializing the OpenGL driver.
+*/
+#define	WINDOW_STYLE	(WS_OVERLAPPED|WS_BORDER|WS_CAPTION|WS_VISIBLE)
+static qboolean GLW_CreateWindow( int width, int height, int colorbits, qboolean cdsFullscreen )
+{
+	RECT			r;
+	cvar_t			*vid_xpos, *vid_ypos;
+	int				stylebits;
+	int				x, y, w, h;
+	int				exstyle;
+
+	//
+	// register the window class if necessary
+	//
+	if ( !s_classRegistered )
+	{
+		WNDCLASS wc;
+
+		memset( &wc, 0, sizeof( wc ) );
+
+		wc.style         = 0;
+		wc.lpfnWndProc   = (WNDPROC) glw_state.wndproc;
+		wc.cbClsExtra    = 0;
+		wc.cbWndExtra    = 0;
+		wc.hInstance     = g_wv.hInstance;
+	    wc.hIcon         = LoadIcon (g_wv.hInstance, MAKEINTRESOURCE(IDI_ICON1));	//jfm: to get icon
+		wc.hCursor       = LoadCursor (NULL,IDC_ARROW);
+		wc.hbrBackground = 0;//(struct HBRUSH__ *)COLOR_GRAYTEXT;
+		wc.lpszMenuName  = 0;
+		wc.lpszClassName = WINDOW_CLASS_NAME;
+
+		if ( !RegisterClass( &wc ) )
+		{
+			Com_Error( ERR_FATAL, "GLW_CreateWindow: could not register window class" );
+		}
+		s_classRegistered = qtrue;
+		VID_Printf( PRINT_ALL, "...registered window class\n" );
+	}
+
+	//
+	// create the HWND if one does not already exist
+	//
+	if ( !g_wv.hWnd )
+	{
+		//
+		// compute width and height
+		//
+		r.left = 0;
+		r.top = 0;
+		r.right  = width;
+		r.bottom = height;
+
+		if ( cdsFullscreen )
+		{
+			exstyle = WS_EX_TOPMOST;
+			stylebits = WS_SYSMENU|WS_POPUP|WS_VISIBLE;	//sysmenu gives you the icon
+		}
+		else
+		{
+			exstyle = 0;
+			stylebits = WS_SYSMENU|WINDOW_STYLE|WS_MINIMIZEBOX;
+			AdjustWindowRect (&r, stylebits, FALSE);
+		}
+
+		w = r.right - r.left;
+		h = r.bottom - r.top;
+
+		if ( cdsFullscreen )
+		{
+			x = 0;
+			y = 0;
+		}
+		else
+		{
+			vid_xpos = Cvar_Get ("vid_xpos", "", 0);
+			vid_ypos = Cvar_Get ("vid_ypos", "", 0);
+			x = vid_xpos->integer;
+			y = vid_ypos->integer;
+
+			// adjust window coordinates if necessary 
+			// so that the window is completely on screen
+			if ( x < 0 )
+				x = 0;
+			if ( y < 0 )
+				y = 0;
+
+			if ( w < glw_state.desktopWidth &&
+				 h < glw_state.desktopHeight )
+			{
+				if ( x + w > glw_state.desktopWidth )
+					x = ( glw_state.desktopWidth - w );
+				if ( y + h > glw_state.desktopHeight )
+					y = ( glw_state.desktopHeight - h );
+			}
+		}
+
+		g_wv.hWnd = CreateWindowEx (
+			 exstyle, 
+			 WINDOW_CLASS_NAME,	//class
+			 WINDOW_CLASS_NAME,	//window title
+			 stylebits,
+			 x, y, w, h,
+			 NULL,
+			 NULL,
+			 g_wv.hInstance,
+			 NULL);
+
+		if ( !g_wv.hWnd )
+		{
+			Com_Error (ERR_FATAL, "GLW_CreateWindow() - Couldn't create window");
+		}
+	
+		ShowWindow( g_wv.hWnd, SW_SHOW );
+		UpdateWindow( g_wv.hWnd );
+		VID_Printf( PRINT_ALL, "...created window@%d,%d (%dx%d)\n", x, y, w, h );
+	}
+	else
+	{
+		VID_Printf( PRINT_ALL, "...window already present, CreateWindowEx skipped\n" );
+	}
+
+	if ( !GLW_InitDriver( colorbits ) )
+	{
+		ShowWindow( g_wv.hWnd, SW_HIDE );
+		DestroyWindow( g_wv.hWnd );
+		g_wv.hWnd = NULL;
+
+		return qfalse;
+	}
+
+	SetForegroundWindow( g_wv.hWnd );
+	SetFocus( g_wv.hWnd );
+
+	return qtrue;
+}
+
+static void PrintCDSError( int value )
+{
+	switch ( value )
+	{
+	case DISP_CHANGE_RESTART:
+		VID_Printf( PRINT_ALL, "restart required\n" );
+		break;
+	case DISP_CHANGE_BADPARAM:
+		VID_Printf( PRINT_ALL, "bad param\n" );
+		break;
+	case DISP_CHANGE_BADFLAGS:
+		VID_Printf( PRINT_ALL, "bad flags\n" );
+		break;
+	case DISP_CHANGE_FAILED:
+		VID_Printf( PRINT_ALL, "DISP_CHANGE_FAILED\n" );
+		break;
+	case DISP_CHANGE_BADMODE:
+		VID_Printf( PRINT_ALL, "bad mode\n" );
+		break;
+	case DISP_CHANGE_NOTUPDATED:
+		VID_Printf( PRINT_ALL, "not updated\n" );
+		break;
+	default:
+		VID_Printf( PRINT_ALL, "unknown error %d\n", value );
+		break;
+	}
+}
+
+/*
+** GLW_SetMode
+*/
+static rserr_t GLW_SetMode( int mode, 
+							int colorbits, 
+							qboolean cdsFullscreen )
+{
+	HDC hDC;
+	const char *win_fs[] = { "W", "FS" };
+	int		cdsRet;
+	DEVMODE dm;
+		
+	//
+	// print out informational messages
+	//
+	VID_Printf( PRINT_ALL, "...setting mode %d:", mode );
+	if ( !R_GetModeInfo( &glConfig.vidWidth, &glConfig.vidHeight, mode ) )
+	{
+		VID_Printf( PRINT_ALL, " invalid mode\n" );
+		return RSERR_INVALID_MODE;
+	}
+	VID_Printf( PRINT_ALL, " %d %d %s\n", glConfig.vidWidth, glConfig.vidHeight, win_fs[cdsFullscreen] );
+
+	//
+	// check our desktop attributes
+	//
+	hDC = GetDC( GetDesktopWindow() );
+	glw_state.desktopBitsPixel = GetDeviceCaps( hDC, BITSPIXEL );
+	glw_state.desktopWidth = GetDeviceCaps( hDC, HORZRES );
+	glw_state.desktopHeight = GetDeviceCaps( hDC, VERTRES );
+	ReleaseDC( GetDesktopWindow(), hDC );
+
+	//
+	// verify desktop bit depth
+	//
+	if ( glw_state.desktopBitsPixel < 15 || glw_state.desktopBitsPixel == 24 )
+	{
+		if ( !cdsFullscreen && (colorbits == 0 || colorbits >= 15 ) )
+		{	
+			// since I can't be bothered trying to mess around with asian codepages and MBCS stuff for a windows
+			//	error box that'll only appear if something's seriously fucked then I'm going to fallback to
+			//	english text when these would otherwise be used...
+			//
+			char sErrorHead[1024];	// ott
+
+			extern qboolean Language_IsAsian(void);
+			Q_strncpyz(sErrorHead, Language_IsAsian() ? "Low Desktop Color Depth" : SE_GetString("CON_TEXT_LOW_DESKTOP_COLOUR_DEPTH"), sizeof(sErrorHead) );
+
+			const char *psErrorBody = Language_IsAsian() ?
+												"It is highly unlikely that a correct windowed\n"
+												"display can be initialized with the current\n"
+												"desktop display depth.  Select 'OK' to try\n"
+												"anyway.  Select 'Cancel' to try a fullscreen\n"
+												"mode instead."
+												:
+												SE_GetString("CON_TEXT_TRY_ANYWAY");
+
+			if ( MessageBox( NULL, 							
+						psErrorBody,
+						sErrorHead,
+						MB_OKCANCEL | MB_ICONEXCLAMATION ) != IDOK )
+			{
+				return RSERR_INVALID_MODE;
+			}
+		}
+	}
+
+	// do a CDS if needed
+	if ( cdsFullscreen )
+	{
+		memset( &dm, 0, sizeof( dm ) );
+		
+		dm.dmSize = sizeof( dm );
+		
+		dm.dmPelsWidth  = glConfig.vidWidth;
+		dm.dmPelsHeight = glConfig.vidHeight;
+		dm.dmFields     = DM_PELSWIDTH | DM_PELSHEIGHT;
+
+		if ( r_displayRefresh->integer != 0 )
+		{
+			dm.dmDisplayFrequency = r_displayRefresh->integer;
+			dm.dmFields |= DM_DISPLAYFREQUENCY;
+		}
+		
+		// try to change color depth if possible
+		if ( colorbits != 0 )
+		{
+			if ( glw_state.allowdisplaydepthchange )
+			{
+				dm.dmBitsPerPel = colorbits;
+				dm.dmFields |= DM_BITSPERPEL;
+				VID_Printf( PRINT_ALL, "...using colorsbits of %d\n", colorbits );
+			}
+			else
+			{
+				VID_Printf( PRINT_ALL, "WARNING:...changing depth not supported on Win95 < pre-OSR 2.x\n" );
+			}
+		}
+		else
+		{
+			VID_Printf( PRINT_ALL, "...using desktop display depth of %d\n", glw_state.desktopBitsPixel );
+		}
+
+		//
+		// if we're already in fullscreen then just create the window
+		//
+		if ( glw_state.cdsFullscreen )
+		{
+			VID_Printf( PRINT_ALL, "...already fullscreen, avoiding redundant CDS\n" );
+
+			if ( !GLW_CreateWindow ( glConfig.vidWidth, glConfig.vidHeight, colorbits, qtrue ) )
+			{
+				VID_Printf( PRINT_ALL, "...restoring display settings\n" );
+				ChangeDisplaySettings( 0, 0 );
+				return RSERR_INVALID_MODE;
+			}
+		}
+		//
+		// need to call CDS
+		//
+		else
+		{
+			VID_Printf( PRINT_ALL, "...calling CDS: " );
+			
+			// try setting the exact mode requested, because some drivers don't report
+			// the low res modes in EnumDisplaySettings, but still work
+			if ( ( cdsRet = ChangeDisplaySettings( &dm, CDS_FULLSCREEN ) ) == DISP_CHANGE_SUCCESSFUL )
+			{
+				VID_Printf( PRINT_ALL, "ok\n" );
+
+				if ( !GLW_CreateWindow ( glConfig.vidWidth, glConfig.vidHeight, colorbits, qtrue) )
+				{
+					VID_Printf( PRINT_ALL, "...restoring display settings\n" );
+					ChangeDisplaySettings( 0, 0 );
+					return RSERR_INVALID_MODE;
+				}
+				
+				glw_state.cdsFullscreen = qtrue;
+			}
+			else
+			{
+				//
+				// the exact mode failed, so scan EnumDisplaySettings for the next largest mode
+				//
+				DEVMODE		devmode;
+				int			modeNum;
+
+				VID_Printf( PRINT_ALL, "failed, " );
+				
+				PrintCDSError( cdsRet );
+				
+				VID_Printf( PRINT_ALL, "...trying next higher resolution:" );
+				
+				// we could do a better matching job here...
+				for ( modeNum = 0 ; ; modeNum++ ) {
+					if ( !EnumDisplaySettings( NULL, modeNum, &devmode ) ) {
+						modeNum = -1;
+						break;
+					}
+					if ( devmode.dmPelsWidth >= glConfig.vidWidth
+						&& devmode.dmPelsHeight >= glConfig.vidHeight
+						&& devmode.dmBitsPerPel >= 15 ) {
+						break;
+					}
+				}
+				
+				if ( modeNum != -1 && ( cdsRet = ChangeDisplaySettings( &devmode, CDS_FULLSCREEN ) ) == DISP_CHANGE_SUCCESSFUL )
+				{
+					VID_Printf( PRINT_ALL, " ok\n" );
+					if ( !GLW_CreateWindow( glConfig.vidWidth, glConfig.vidHeight, colorbits, qtrue) )
+					{
+						VID_Printf( PRINT_ALL, "...restoring display settings\n" );
+						ChangeDisplaySettings( 0, 0 );
+						return RSERR_INVALID_MODE;
+					}
+					
+					glw_state.cdsFullscreen = qtrue;
+				}
+				else
+				{
+					VID_Printf( PRINT_ALL, " failed, " );
+					
+					PrintCDSError( cdsRet );
+					
+					VID_Printf( PRINT_ALL, "...restoring display settings\n" );
+					ChangeDisplaySettings( 0, 0 );
+					
+/*				jfm:  i took out the following code to allow fallback to mode 3, with this code it goes half windowed and just doesn't work.
+					glw_state.cdsFullscreen = qfalse;
+					glConfig.isFullscreen = qfalse;
+					if ( !GLW_CreateWindow( glConfig.vidWidth, glConfig.vidHeight, colorbits, qfalse) )
+					{
+						return RSERR_INVALID_MODE;
+					}
+*/
+					return RSERR_INVALID_FULLSCREEN;
+				}
+			}
+		}
+	}
+	else
+	{
+		if ( glw_state.cdsFullscreen )
+		{
+			ChangeDisplaySettings( 0, 0 );
+		}
+
+		glw_state.cdsFullscreen = qfalse;
+		if ( !GLW_CreateWindow( glConfig.vidWidth, glConfig.vidHeight, colorbits, qfalse ) )
+		{
+			return RSERR_INVALID_MODE;
+		}
+	}
+
+	//
+	// success, now check display frequency, although this won't be valid on Voodoo(2)
+	//
+	memset( &dm, 0, sizeof( dm ) );
+	dm.dmSize = sizeof( dm );
+	if ( EnumDisplaySettings( NULL, ENUM_CURRENT_SETTINGS, &dm ) )
+	{
+		glConfig.displayFrequency = dm.dmDisplayFrequency;
+	}
+
+	// NOTE: this is overridden later on standalone 3Dfx drivers
+	glConfig.isFullscreen = cdsFullscreen;
+
+	return RSERR_OK;
+}
+
+//--------------------------------------------
+static void GLW_InitTextureCompression( void )
+{
+	qboolean newer_tc, old_tc;
+
+	// Check for available tc methods.
+	newer_tc = ( strstr( glConfig.extensions_string, "ARB_texture_compression" )
+		&& strstr( glConfig.extensions_string, "EXT_texture_compression_s3tc" )) ? qtrue : qfalse;
+	old_tc = ( strstr( glConfig.extensions_string, "GL_S3_s3tc" )) ? qtrue : qfalse;
+
+	if ( old_tc )
+	{
+		VID_Printf( PRINT_ALL, "...GL_S3_s3tc available\n" );
+	}
+
+	if ( newer_tc )
+	{
+		VID_Printf( PRINT_ALL, "...GL_EXT_texture_compression_s3tc available\n" );
+	}
+
+	if ( !r_ext_compressed_textures->value )
+	{
+		// Compressed textures are off
+		glConfig.textureCompression = TC_NONE;
+		VID_Printf( PRINT_ALL, "...ignoring texture compression\n" );
+	}
+	else if ( !old_tc && !newer_tc )
+	{
+		// Requesting texture compression, but no method found
+		glConfig.textureCompression = TC_NONE;
+		VID_Printf( PRINT_ALL, "...no supported texture compression method found\n" );
+		VID_Printf( PRINT_ALL, ".....ignoring texture compression\n" );
+	}
+	else
+	{
+		// some form of supported texture compression is avaiable, so see if the user has a preference
+		if ( r_ext_preferred_tc_method->integer == TC_NONE )
+		{
+			// No preference, so pick the best
+			if ( newer_tc )
+			{
+				VID_Printf( PRINT_ALL, "...no tc preference specified\n" );
+				VID_Printf( PRINT_ALL, ".....using GL_EXT_texture_compression_s3tc\n" );
+				glConfig.textureCompression = TC_S3TC_DXT;
+			}
+			else
+			{
+				VID_Printf( PRINT_ALL, "...no tc preference specified\n" );
+				VID_Printf( PRINT_ALL, ".....using GL_S3_s3tc\n" );
+				glConfig.textureCompression = TC_S3TC;
+			}
+		}
+		else
+		{
+			// User has specified a preference, now see if this request can be honored
+			if ( old_tc && newer_tc )
+			{
+				// both are avaiable, so we can use the desired tc method
+				if ( r_ext_preferred_tc_method->integer == TC_S3TC )
+				{
+					VID_Printf( PRINT_ALL, "...using preferred tc method, GL_S3_s3tc\n" );
+					glConfig.textureCompression = TC_S3TC;
+				}
+				else
+				{
+					VID_Printf( PRINT_ALL, "...using preferred tc method, GL_EXT_texture_compression_s3tc\n" );
+					glConfig.textureCompression = TC_S3TC_DXT;
+				}
+			}
+			else
+			{
+				// Both methods are not available, so this gets trickier
+				if ( r_ext_preferred_tc_method->integer == TC_S3TC )
+				{
+					// Preferring to user older compression
+					if ( old_tc )
+					{
+						VID_Printf( PRINT_ALL, "...using GL_S3_s3tc\n" );
+						glConfig.textureCompression = TC_S3TC;
+					}
+					else
+					{
+						// Drat, preference can't be honored 
+						VID_Printf( PRINT_ALL, "...preferred tc method, GL_S3_s3tc not available\n" );
+						VID_Printf( PRINT_ALL, ".....falling back to GL_EXT_texture_compression_s3tc\n" );
+						glConfig.textureCompression = TC_S3TC_DXT;
+					}
+				}
+				else
+				{
+					// Preferring to user newer compression
+					if ( newer_tc )
+					{
+						VID_Printf( PRINT_ALL, "...using GL_EXT_texture_compression_s3tc\n" );
+						glConfig.textureCompression = TC_S3TC_DXT;
+					}
+					else
+					{
+						// Drat, preference can't be honored 
+						VID_Printf( PRINT_ALL, "...preferred tc method, GL_EXT_texture_compression_s3tc not available\n" );
+						VID_Printf( PRINT_ALL, ".....falling back to GL_S3_s3tc\n" );
+						glConfig.textureCompression = TC_S3TC;
+					}
+				}
+			}
+		}
+	}
+}
+
+/*
+** GLW_InitExtensions
+*/
+static void GLW_InitExtensions( void )
+{
+	if ( !r_allowExtensions->integer )
+	{
+		VID_Printf( PRINT_ALL, "*** IGNORING OPENGL EXTENSIONS ***\n" );
+		g_bDynamicGlowSupported = false;
+		Cvar_Set( "r_DynamicGlow","0" );
+		return;
+	}
+
+	VID_Printf( PRINT_ALL, "Initializing OpenGL extensions\n" );
+
+	// Select our tc scheme
+	GLW_InitTextureCompression();
+
+	// GL_EXT_texture_env_add
+	glConfig.textureEnvAddAvailable = qfalse;
+	if ( strstr( glConfig.extensions_string, "EXT_texture_env_add" ) )
+	{
+		if ( r_ext_texture_env_add->integer )
+		{
+			glConfig.textureEnvAddAvailable = qtrue;
+			VID_Printf( PRINT_ALL, "...using GL_EXT_texture_env_add\n" );
+		}
+		else
+		{
+			glConfig.textureEnvAddAvailable = qfalse;
+			VID_Printf( PRINT_ALL, "...ignoring GL_EXT_texture_env_add\n" );
+		}
+	}
+	else
+	{
+		VID_Printf( PRINT_ALL, "...GL_EXT_texture_env_add not found\n" );
+	}
+
+	// GL_EXT_texture_filter_anisotropic
+	glConfig.maxTextureFilterAnisotropy = 0;
+	if ( strstr( glConfig.extensions_string, "EXT_texture_filter_anisotropic" ) )
+	{
+#define GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT 0x84FF	//can't include glext.h here ... sigh
+		qglGetFloatv( GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &glConfig.maxTextureFilterAnisotropy );
+		Com_Printf ("...GL_EXT_texture_filter_anisotropic available\n" );
+
+		if ( r_ext_texture_filter_anisotropic->integer>1 )
+		{
+			Com_Printf ("...using GL_EXT_texture_filter_anisotropic\n" );
+		}
+		else
+		{
+			Com_Printf ("...ignoring GL_EXT_texture_filter_anisotropic\n" );
+		}
+		Cvar_Set( "r_ext_texture_filter_anisotropic_avail", va("%f",glConfig.maxTextureFilterAnisotropy) );
+		if ( r_ext_texture_filter_anisotropic->value > glConfig.maxTextureFilterAnisotropy )
+		{
+			Cvar_Set( "r_ext_texture_filter_anisotropic", va("%f",glConfig.maxTextureFilterAnisotropy) );
+		}
+	}
+	else
+	{
+		Com_Printf ("...GL_EXT_texture_filter_anisotropic not found\n" );
+		Cvar_Set( "r_ext_texture_filter_anisotropic_avail", "0" );
+	}
+
+	// GL_EXT_clamp_to_edge
+	glConfig.clampToEdgeAvailable = qfalse;
+	if ( strstr( glConfig.extensions_string, "GL_EXT_texture_edge_clamp" ) )
+	{
+		glConfig.clampToEdgeAvailable = qtrue;
+		VID_Printf( PRINT_ALL, "...Using GL_EXT_texture_edge_clamp\n" );
+	}
+
+	// WGL_EXT_swap_control
+	qwglSwapIntervalEXT = ( BOOL (WINAPI *)(int)) qwglGetProcAddress( "wglSwapIntervalEXT" );
+	if ( qwglSwapIntervalEXT )
+	{
+		VID_Printf( PRINT_ALL, "...using WGL_EXT_swap_control\n" );
+		r_swapInterval->modified = qtrue;	// force a set next frame
+	}
+	else
+	{
+		VID_Printf( PRINT_ALL, "...WGL_EXT_swap_control not found\n" );
+	}
+
+	// GL_ARB_multitexture
+	qglMultiTexCoord2fARB = NULL;
+	qglActiveTextureARB = NULL;
+	qglClientActiveTextureARB = NULL;
+	if ( strstr( glConfig.extensions_string, "GL_ARB_multitexture" )  )
+	{
+		if ( r_ext_multitexture->integer )
+		{
+			qglMultiTexCoord2fARB = ( PFNGLMULTITEXCOORD2FARBPROC ) qwglGetProcAddress( "glMultiTexCoord2fARB" );
+			qglActiveTextureARB = ( PFNGLACTIVETEXTUREARBPROC ) qwglGetProcAddress( "glActiveTextureARB" );
+			qglClientActiveTextureARB = ( PFNGLCLIENTACTIVETEXTUREARBPROC ) qwglGetProcAddress( "glClientActiveTextureARB" );
+
+			if ( qglActiveTextureARB )
+			{
+				qglGetIntegerv( GL_MAX_ACTIVE_TEXTURES_ARB, &glConfig.maxActiveTextures );
+
+				if ( glConfig.maxActiveTextures > 1 )
+				{
+					VID_Printf( PRINT_ALL, "...using GL_ARB_multitexture\n" );
+				}
+				else
+				{
+					qglMultiTexCoord2fARB = NULL;
+					qglActiveTextureARB = NULL;
+					qglClientActiveTextureARB = NULL;
+					VID_Printf( PRINT_ALL, "...not using GL_ARB_multitexture, < 2 texture units\n" );
+				}
+			}
+		}
+		else
+		{
+			VID_Printf( PRINT_ALL, "...ignoring GL_ARB_multitexture\n" );
+		}
+	}
+	else
+	{
+		VID_Printf( PRINT_ALL, "...GL_ARB_multitexture not found\n" );
+	}
+
+	// GL_EXT_compiled_vertex_array
+	qglLockArraysEXT = NULL;
+	qglUnlockArraysEXT = NULL;
+	if ( strstr( glConfig.extensions_string, "GL_EXT_compiled_vertex_array" ) )
+	{
+		if ( r_ext_compiled_vertex_array->integer )
+		{
+			VID_Printf( PRINT_ALL, "...using GL_EXT_compiled_vertex_array\n" );
+			qglLockArraysEXT = ( void ( APIENTRY * )( int, int ) ) qwglGetProcAddress( "glLockArraysEXT" );
+			qglUnlockArraysEXT = ( void ( APIENTRY * )( void ) ) qwglGetProcAddress( "glUnlockArraysEXT" );
+			if (!qglLockArraysEXT || !qglUnlockArraysEXT) {
+				Com_Error (ERR_FATAL, "bad getprocaddress");
+			}
+		}
+		else
+		{
+			VID_Printf( PRINT_ALL, "...ignoring GL_EXT_compiled_vertex_array\n" );
+		}
+	}
+	else
+	{
+		VID_Printf( PRINT_ALL, "...GL_EXT_compiled_vertex_array not found\n" );
+	}
+
+	// GL_EXT_point_parameters
+	qglPointParameterfEXT = NULL;
+	qglPointParameterfvEXT = NULL;
+	if ( strstr( glConfig.extensions_string, "GL_EXT_point_parameters" ) )
+	{
+		if ( r_ext_point_parameters->integer )
+		{
+			qglPointParameterfEXT = ( void ( APIENTRY * )( GLenum, GLfloat) ) qwglGetProcAddress( "glPointParameterfEXT" );
+			qglPointParameterfvEXT = ( void ( APIENTRY * )( GLenum, GLfloat *) ) qwglGetProcAddress( "glPointParameterfvEXT" );
+			if (!qglPointParameterfEXT || !qglPointParameterfvEXT) 
+			{
+				VID_Printf( ERR_FATAL, "Bad GetProcAddress for GL_EXT_point_parameters");
+			}
+			VID_Printf( PRINT_ALL, "...using GL_EXT_point_parameters\n" );
+		}
+		else
+		{
+			VID_Printf( PRINT_ALL, "...ignoring GL_EXT_point_parameters\n" );
+		}
+	}
+	else
+	{
+		VID_Printf( PRINT_ALL, "...GL_EXT_point_parameters not found\n" );
+	}
+
+	// GL_NV_point_sprite
+	qglPointParameteriNV = NULL;
+	qglPointParameterivNV = NULL;
+	if ( strstr( glConfig.extensions_string, "GL_NV_point_sprite" ) )
+	{
+		if ( r_ext_nv_point_sprite->integer )
+		{
+			qglPointParameteriNV = ( void ( APIENTRY * )( GLenum, GLint) ) qwglGetProcAddress( "glPointParameteriNV" );
+			qglPointParameterivNV = ( void ( APIENTRY * )( GLenum, const GLint *) ) qwglGetProcAddress( "glPointParameterivNV" );
+			if (!qglPointParameteriNV || !qglPointParameterivNV) 
+			{
+				VID_Printf( ERR_FATAL, "Bad GetProcAddress for GL_NV_point_sprite");
+			}
+			VID_Printf( PRINT_ALL, "...using GL_NV_point_sprite\n" );
+		}
+		else
+		{
+			VID_Printf( PRINT_ALL,  "...ignoring GL_NV_point_sprite\n" );
+		}
+	}
+	else
+	{
+		VID_Printf( PRINT_ALL, "...GL_NV_point_sprite not found\n" );
+	}
+
+	bool bNVRegisterCombiners = false;
+	// Register Combiners.
+	if ( strstr( glConfig.extensions_string, "GL_NV_register_combiners" ) )
+	{
+		// NOTE: This extension requires multitexture support (over 2 units).
+		if ( glConfig.maxActiveTextures >= 2 )
+		{
+			bNVRegisterCombiners = true;
+			// Register Combiners function pointer address load.	- AReis
+			// NOTE: VV guys will _definetly_ not be able to use regcoms. Pixel Shaders are just as good though :-)
+			// NOTE: Also, this is an nVidia specific extension (of course), so fragment shaders would serve the same purpose
+			// if we needed some kind of fragment/pixel manipulation support.
+			qglCombinerParameterfvNV = ( PFNGLCOMBINERPARAMETERFVNV ) qwglGetProcAddress( "glCombinerParameterfvNV" );
+			qglCombinerParameterivNV = ( PFNGLCOMBINERPARAMETERIVNV ) qwglGetProcAddress( "glCombinerParameterivNV" );
+			qglCombinerParameterfNV = ( PFNGLCOMBINERPARAMETERFNV ) qwglGetProcAddress( "glCombinerParameterfNV" );
+			qglCombinerParameteriNV = ( PFNGLCOMBINERPARAMETERINV ) qwglGetProcAddress( "glCombinerParameteriNV" );
+			qglCombinerInputNV = ( PFNGLCOMBINERINPUTNV ) qwglGetProcAddress( "glCombinerInputNV" );
+			qglCombinerOutputNV = ( PFNGLCOMBINEROUTPUTNV ) qwglGetProcAddress( "glCombinerOutputNV" );
+			qglFinalCombinerInputNV = ( PFNGLFINALCOMBINERINPUTNV ) qwglGetProcAddress( "glFinalCombinerInputNV" );
+			qglGetCombinerInputParameterfvNV	= ( PFNGLGETCOMBINERINPUTPARAMETERFVNV ) qwglGetProcAddress( "glGetCombinerInputParameterfvNV" );
+			qglGetCombinerInputParameterivNV	= ( PFNGLGETCOMBINERINPUTPARAMETERIVNV ) qwglGetProcAddress( "glGetCombinerInputParameterivNV" );
+			qglGetCombinerOutputParameterfvNV = ( PFNGLGETCOMBINEROUTPUTPARAMETERFVNV ) qwglGetProcAddress( "glGetCombinerOutputParameterfvNV" );
+			qglGetCombinerOutputParameterivNV = ( PFNGLGETCOMBINEROUTPUTPARAMETERIVNV ) qwglGetProcAddress( "glGetCombinerOutputParameterivNV" );
+			qglGetFinalCombinerInputParameterfvNV = ( PFNGLGETFINALCOMBINERINPUTPARAMETERFVNV ) qwglGetProcAddress( "glGetFinalCombinerInputParameterfvNV" );
+			qglGetFinalCombinerInputParameterivNV = ( PFNGLGETFINALCOMBINERINPUTPARAMETERIVNV ) qwglGetProcAddress( "glGetFinalCombinerInputParameterivNV" );
+
+			// Validate the functions we need.
+			if ( !qglCombinerParameterfvNV || !qglCombinerParameterivNV || !qglCombinerParameterfNV || !qglCombinerParameteriNV || !qglCombinerInputNV ||
+				 !qglCombinerOutputNV || !qglFinalCombinerInputNV || !qglGetCombinerInputParameterfvNV || !qglGetCombinerInputParameterivNV ||
+				 !qglGetCombinerOutputParameterfvNV || !qglGetCombinerOutputParameterivNV || !qglGetFinalCombinerInputParameterfvNV || !qglGetFinalCombinerInputParameterivNV )
+			{
+				bNVRegisterCombiners = false;
+				qglCombinerParameterfvNV = NULL;
+				qglCombinerParameteriNV = NULL;
+				Com_Printf ("...GL_NV_register_combiners failed\n" );
+			}
+		}
+		else
+		{
+			bNVRegisterCombiners = false;
+			Com_Printf ("...ignoring GL_NV_register_combiners\n" );
+		}
+	}
+	else
+	{
+		bNVRegisterCombiners = false;
+		Com_Printf ("...GL_NV_register_combiners not found\n" );
+	}
+
+	// NOTE: Vertex and Fragment Programs are very dependant on each other - this is actually a
+	// good thing! So, just check to see which we support (one or the other) and load the shared
+	// function pointers. ARB rocks!
+
+	// Vertex Programs.
+	bool bARBVertexProgram = false;
+	if ( strstr( glConfig.extensions_string, "GL_ARB_vertex_program" ) )
+	{
+		bARBVertexProgram = true;
+	}
+	else
+	{
+		bARBVertexProgram = false;
+		Com_Printf ("...GL_ARB_vertex_program not found\n" );
+	}
+
+	bool bARBFragmentProgram = false;
+	// Fragment Programs.
+	if ( strstr( glConfig.extensions_string, "GL_ARB_fragment_program" ) )
+	{
+		bARBFragmentProgram = true;
+	}
+	else
+	{
+		bARBFragmentProgram = false;
+		Com_Printf ("...GL_ARB_fragment_program not found\n" );
+	}
+
+	// If we support one or the other, load the shared function pointers.
+	if ( bARBVertexProgram || bARBFragmentProgram )
+	{
+		qglProgramStringARB					= (PFNGLPROGRAMSTRINGARBPROC)  qwglGetProcAddress("glProgramStringARB");
+		qglBindProgramARB					= (PFNGLBINDPROGRAMARBPROC)    qwglGetProcAddress("glBindProgramARB");
+		qglDeleteProgramsARB				= (PFNGLDELETEPROGRAMSARBPROC) qwglGetProcAddress("glDeleteProgramsARB");
+		qglGenProgramsARB					= (PFNGLGENPROGRAMSARBPROC)    qwglGetProcAddress("glGenProgramsARB");
+		qglProgramEnvParameter4dARB			= (PFNGLPROGRAMENVPARAMETER4DARBPROC)    qwglGetProcAddress("glProgramEnvParameter4dARB");
+		qglProgramEnvParameter4dvARB		= (PFNGLPROGRAMENVPARAMETER4DVARBPROC)   qwglGetProcAddress("glProgramEnvParameter4dvARB");
+		qglProgramEnvParameter4fARB			= (PFNGLPROGRAMENVPARAMETER4FARBPROC)    qwglGetProcAddress("glProgramEnvParameter4fARB");
+		qglProgramEnvParameter4fvARB		= (PFNGLPROGRAMENVPARAMETER4FVARBPROC)   qwglGetProcAddress("glProgramEnvParameter4fvARB");
+		qglProgramLocalParameter4dARB		= (PFNGLPROGRAMLOCALPARAMETER4DARBPROC)  qwglGetProcAddress("glProgramLocalParameter4dARB");
+		qglProgramLocalParameter4dvARB		= (PFNGLPROGRAMLOCALPARAMETER4DVARBPROC) qwglGetProcAddress("glProgramLocalParameter4dvARB");
+		qglProgramLocalParameter4fARB		= (PFNGLPROGRAMLOCALPARAMETER4FARBPROC)  qwglGetProcAddress("glProgramLocalParameter4fARB");
+		qglProgramLocalParameter4fvARB		= (PFNGLPROGRAMLOCALPARAMETER4FVARBPROC) qwglGetProcAddress("glProgramLocalParameter4fvARB");
+		qglGetProgramEnvParameterdvARB		= (PFNGLGETPROGRAMENVPARAMETERDVARBPROC) qwglGetProcAddress("glGetProgramEnvParameterdvARB");
+		qglGetProgramEnvParameterfvARB		= (PFNGLGETPROGRAMENVPARAMETERFVARBPROC) qwglGetProcAddress("glGetProgramEnvParameterfvARB");
+		qglGetProgramLocalParameterdvARB	= (PFNGLGETPROGRAMLOCALPARAMETERDVARBPROC) qwglGetProcAddress("glGetProgramLocalParameterdvARB");
+		qglGetProgramLocalParameterfvARB	= (PFNGLGETPROGRAMLOCALPARAMETERFVARBPROC) qwglGetProcAddress("glGetProgramLocalParameterfvARB");
+		qglGetProgramivARB					= (PFNGLGETPROGRAMIVARBPROC)     qwglGetProcAddress("glGetProgramivARB");
+		qglGetProgramStringARB				= (PFNGLGETPROGRAMSTRINGARBPROC) qwglGetProcAddress("glGetProgramStringARB");
+		qglIsProgramARB						= (PFNGLISPROGRAMARBPROC)        qwglGetProcAddress("glIsProgramARB");
+
+		// Validate the functions we need.
+		if ( !qglProgramStringARB || !qglBindProgramARB || !qglDeleteProgramsARB || !qglGenProgramsARB ||
+			 !qglProgramEnvParameter4dARB || !qglProgramEnvParameter4dvARB || !qglProgramEnvParameter4fARB ||
+             !qglProgramEnvParameter4fvARB || !qglProgramLocalParameter4dARB || !qglProgramLocalParameter4dvARB ||
+             !qglProgramLocalParameter4fARB || !qglProgramLocalParameter4fvARB || !qglGetProgramEnvParameterdvARB ||
+             !qglGetProgramEnvParameterfvARB || !qglGetProgramLocalParameterdvARB || !qglGetProgramLocalParameterfvARB ||
+             !qglGetProgramivARB || !qglGetProgramStringARB || !qglIsProgramARB )
+		{
+			bARBVertexProgram = false;
+			bARBFragmentProgram = false;
+			qglGenProgramsARB = NULL;	//clear ptrs that get checked
+			qglProgramEnvParameter4fARB = NULL;
+			Com_Printf ("...ignoring GL_ARB_vertex_program\n" );
+			Com_Printf ("...ignoring GL_ARB_fragment_program\n" );
+		}
+	}
+
+	// Figure out which texture rectangle extension to use.
+	// TOTAL HACK!!! This will need to be fixed.
+	// FIXMEFIXMEFIXME!
+	bool bTexRectSupported = false;
+	if ( strstr( glConfig.extensions_string, "GL_EXT_texture_rectangle" ) )
+	{
+		g_bTextureRectangleHack = true;
+		bTexRectSupported = true;
+	}
+	else if ( strstr( glConfig.extensions_string, "GL_NV_texture_rectangle" ) )
+	{
+		g_bTextureRectangleHack = false;
+		bTexRectSupported = true;
+	}
+	
+	// OK, so not so good to put this here, but no one else uses it!!! -AReis
+	typedef const char * (WINAPI * PFNWGLGETEXTENSIONSSTRINGARBPROC) (HDC hdc);
+	PFNWGLGETEXTENSIONSSTRINGARBPROC			qwglGetExtensionsStringARB;
+	qwglGetExtensionsStringARB = (PFNWGLGETEXTENSIONSSTRINGARBPROC) qwglGetProcAddress("wglGetExtensionsStringARB");
+
+	const char *wglExtensions = NULL;
+	bool bHasPixelFormat = false;
+	bool bHasRenderTexture = false;
+
+	// Get the WGL extensions string.
+	if ( qwglGetExtensionsStringARB )
+	{
+		wglExtensions = qwglGetExtensionsStringARB( glw_state.hDC );
+	}
+
+	// This externsion is used to get the wgl extension string.
+	if ( wglExtensions )
+	{
+		// Pixel Format.
+		if ( strstr( wglExtensions, "WGL_ARB_pixel_format" ) )
+		{
+			qwglGetPixelFormatAttribivARB			=	(PFNWGLGETPIXELFORMATATTRIBIVARBPROC) qwglGetProcAddress("wglGetPixelFormatAttribivARB");
+			qwglGetPixelFormatAttribfvARB			=	(PFNWGLGETPIXELFORMATATTRIBFVARBPROC) qwglGetProcAddress("wglGetPixelFormatAttribfvARB");
+			qwglChoosePixelFormatARB				=	(PFNWGLCHOOSEPIXELFORMATARBPROC) qwglGetProcAddress("wglChoosePixelFormatARB");
+	
+			// Validate the functions we need.
+			if ( !qwglGetPixelFormatAttribivARB || !qwglGetPixelFormatAttribfvARB || !qwglChoosePixelFormatARB )
+			{
+				Com_Printf ("...ignoring WGL_ARB_pixel_format\n" );
+			}
+			else
+			{
+				bHasPixelFormat = true;
+			}
+		}
+		else
+		{
+			Com_Printf ("...ignoring WGL_ARB_pixel_format\n" );
+		}
+
+		// Offscreen pixel-buffer.
+		// NOTE: VV guys can use the equivelant SetRenderTarget() with the correct texture surfaces.
+		bool bWGLARBPbuffer = false;
+		if ( strstr( wglExtensions, "WGL_ARB_pbuffer" ) && bHasPixelFormat )
+		{
+			bWGLARBPbuffer = true;
+			qwglCreatePbufferARB		=	(PFNWGLCREATEPBUFFERARBPROC) qwglGetProcAddress("wglCreatePbufferARB");
+			qwglGetPbufferDCARB			=	(PFNWGLGETPBUFFERDCARBPROC) qwglGetProcAddress("wglGetPbufferDCARB");
+			qwglReleasePbufferDCARB		=	(PFNWGLRELEASEPBUFFERDCARBPROC) qwglGetProcAddress("wglReleasePbufferDCARB");
+			qwglDestroyPbufferARB		=	(PFNWGLDESTROYPBUFFERARBPROC) qwglGetProcAddress("wglDestroyPbufferARB");
+			qwglQueryPbufferARB			=	(PFNWGLQUERYPBUFFERARBPROC) qwglGetProcAddress("wglQueryPbufferARB");
+	
+			// Validate the functions we need.
+			if ( !qwglCreatePbufferARB || !qwglGetPbufferDCARB || !qwglReleasePbufferDCARB || !qwglDestroyPbufferARB || !qwglQueryPbufferARB )
+			{
+				bWGLARBPbuffer = false;
+				Com_Printf ("...WGL_ARB_pbuffer failed\n" );
+			}
+		}
+		else
+		{
+			bWGLARBPbuffer = false;
+			Com_Printf ("...WGL_ARB_pbuffer not found\n" );
+		}
+
+		// Render-Texture (requires pbuffer ext (and it's dependancies of course).
+		if ( strstr( wglExtensions, "WGL_ARB_render_texture" ) && bWGLARBPbuffer )
+		{
+			qwglBindTexImageARB			=	(PFNWGLBINDTEXIMAGEARBPROC) qwglGetProcAddress("wglBindTexImageARB");
+			qwglReleaseTexImageARB		=	(PFNWGLRELEASETEXIMAGEARBPROC) qwglGetProcAddress("wglReleaseTexImageARB");
+			qwglSetPbufferAttribARB		=	(PFNWGLSETPBUFFERATTRIBARBPROC) qwglGetProcAddress("wglSetPbufferAttribARB");
+	
+			// Validate the functions we need.
+			if ( !qwglCreatePbufferARB || !qwglGetPbufferDCARB || !qwglReleasePbufferDCARB || !qwglDestroyPbufferARB || !qwglQueryPbufferARB )
+			{
+				Com_Printf ("...ignoring WGL_ARB_render_texture\n" );
+			}
+			else
+			{
+				bHasRenderTexture = true;
+			}
+		}
+		else
+		{
+			Com_Printf ("...ignoring WGL_ARB_render_texture\n" );
+		}
+	}
+
+	// Find out how many general combiners they have.
+	#define GL_MAX_GENERAL_COMBINERS_NV       0x854D
+	GLint iNumGeneralCombiners = 0;
+	qglGetIntegerv( GL_MAX_GENERAL_COMBINERS_NV, &iNumGeneralCombiners );
+
+	// Only allow dynamic glows/flares if they have the hardware
+	if ( bTexRectSupported && bARBVertexProgram && bHasRenderTexture && qglActiveTextureARB && glConfig.maxActiveTextures >= 4 &&
+		( ( bNVRegisterCombiners && iNumGeneralCombiners >= 2 ) || bARBFragmentProgram ) )
+	{
+		g_bDynamicGlowSupported = true;
+		// this would overwrite any achived setting gwg
+		// Cvar_Set( "r_DynamicGlow", "1" );
+	}
+	else
+	{
+		g_bDynamicGlowSupported = false;
+		Cvar_Set( "r_DynamicGlow","0" );
+	}
+}
+
+/*
+** GLW_CheckOSVersion
+*/
+static qboolean GLW_CheckOSVersion( void )
+{
+#define OSR2_BUILD_NUMBER 1111
+
+	OSVERSIONINFO	vinfo;
+
+	vinfo.dwOSVersionInfoSize = sizeof(vinfo);
+
+	glw_state.allowdisplaydepthchange = qfalse;
+
+	if ( GetVersionEx( &vinfo) )
+	{
+		if ( vinfo.dwMajorVersion > 4 )
+		{
+			glw_state.allowdisplaydepthchange = qtrue;
+		}
+		else if ( vinfo.dwMajorVersion == 4 )
+		{
+			if ( vinfo.dwPlatformId == VER_PLATFORM_WIN32_NT )
+			{
+				glw_state.allowdisplaydepthchange = qtrue;
+			}
+			else if ( vinfo.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS )
+			{
+				if ( LOWORD( vinfo.dwBuildNumber ) >= OSR2_BUILD_NUMBER )
+				{
+					glw_state.allowdisplaydepthchange = qtrue;
+				}
+			}
+		}
+	}
+	else
+	{
+		VID_Printf( PRINT_ALL, "GLW_CheckOSVersion() - GetVersionEx failed\n" );
+		return qfalse;
+	}
+
+	return qtrue;
+}
+
+/*
+** GLW_LoadOpenGL
+**
+** GLimp_win.c internal function that attempts to load and use 
+** a specific OpenGL DLL.
+*/
+static qboolean GLW_LoadOpenGL()
+{
+	char buffer[1024];
+	qboolean cdsFullscreen;
+
+	strlwr( strcpy( buffer, OPENGL_DRIVER_NAME ) );
+
+	//
+	// load the driver and bind our function pointers to it
+	// 
+	if ( QGL_Init( buffer ) ) 
+	{
+		cdsFullscreen = r_fullscreen->integer;
+
+		// create the window and set up the context
+		if ( !GLW_StartDriverAndSetMode( r_mode->integer, r_colorbits->integer, cdsFullscreen ) )
+		{
+			// if we're on a 24/32-bit desktop and we're going fullscreen
+			// try it again but with a 16-bit desktop
+			if ( r_colorbits->integer != 16 ||
+				 cdsFullscreen != (int)qtrue ||
+				 r_mode->integer != 3 )
+			{
+				if ( !GLW_StartDriverAndSetMode( 3, 16, qtrue ) )
+				{
+					goto fail;
+				}
+			}
+		}
+		return qtrue;
+	}
+fail:
+
+	QGL_Shutdown();
+
+	return qfalse;
+}
+
+/*
+** GLimp_EndFrame
+*/
+void GLimp_EndFrame (void)
+{
+	//
+	// swapinterval stuff
+	//
+	if ( r_swapInterval->modified ) {
+		r_swapInterval->modified = qfalse;
+
+		if ( !glConfig.stereoEnabled ) {	// why?
+			if ( qwglSwapIntervalEXT ) {
+				qwglSwapIntervalEXT( r_swapInterval->integer );
+			}
+		}
+	}
+
+
+	// don't flip if drawing to front buffer
+	//if ( stricmp( r_drawBuffer->string, "GL_FRONT" ) != 0 )
+	{
+		SwapBuffers( glw_state.hDC );
+	}
+
+	// check logging
+	QGL_EnableLogging( r_logFile->integer );
+}
+
+static void GLW_StartOpenGL( void )
+{
+	//
+	// load and initialize the specific OpenGL driver
+	//
+	if ( !GLW_LoadOpenGL() )
+	{
+		Com_Error( ERR_FATAL, "GLW_StartOpenGL() - could not load OpenGL subsystem\n" );
+	}
+}
+
+/*
+** GLimp_Init
+**
+** This is the platform specific OpenGL initialization function.  It
+** is responsible for loading OpenGL, initializing it, setting
+** extensions, creating a window of the appropriate size, doing
+** fullscreen manipulations, etc.  Its overall responsibility is
+** to make sure that a functional OpenGL subsystem is operating
+** when it returns to the ref.
+*/
+void GLimp_Init( void )
+{
+	char	buf[MAX_STRING_CHARS];
+	cvar_t *lastValidRenderer = Cvar_Get( "r_lastValidRenderer", "(uninitialized)", CVAR_ARCHIVE );
+	cvar_t	*cv;
+
+	VID_Printf( PRINT_ALL, "Initializing OpenGL subsystem\n" );
+
+	//
+	// check OS version to see if we can do fullscreen display changes
+	//
+	if ( !GLW_CheckOSVersion() )
+	{
+		Com_Error( ERR_FATAL, "GLimp_Init() - incorrect operating system\n" );
+	}
+
+	// save off hInstance and wndproc
+	cv = Cvar_Get( "win_hinstance", "", 0 );
+	sscanf( cv->string, "%i", (int *)&g_wv.hInstance );
+
+	cv = Cvar_Get( "win_wndproc", "", 0 );
+	sscanf( cv->string, "%i", (int *)&glw_state.wndproc );
+
+	r_allowSoftwareGL = Cvar_Get( "r_allowSoftwareGL", "0", CVAR_LATCH );
+
+	// load appropriate DLL and initialize subsystem
+	GLW_StartOpenGL();
+
+	// get our config strings
+	glConfig.vendor_string = (const char *) qglGetString (GL_VENDOR);
+	glConfig.renderer_string = (const char *) qglGetString (GL_RENDERER);
+	glConfig.version_string = (const char *) qglGetString (GL_VERSION);
+	glConfig.extensions_string = (const char *) qglGetString (GL_EXTENSIONS);
+	
+	if (!glConfig.vendor_string || !glConfig.renderer_string || !glConfig.version_string || !glConfig.extensions_string)
+	{
+		Com_Error( ERR_FATAL, "GLimp_Init() - Invalid GL Driver\n" );
+	}
+
+	// OpenGL driver constants
+	qglGetIntegerv( GL_MAX_TEXTURE_SIZE, &glConfig.maxTextureSize );
+	// stubbed or broken drivers may have reported 0...
+	if ( glConfig.maxTextureSize <= 0 ) 
+	{
+		glConfig.maxTextureSize = 0;
+	}
+
+	//
+	// chipset specific configuration
+	//
+	strcpy( buf, glConfig.renderer_string );
+	strlwr( buf );
+
+	//
+	// NOTE: if changing cvars, do it within this block.  This allows them
+	// to be overridden when testing driver fixes, etc. but only sets
+	// them to their default state when the hardware is first installed/run.
+	//
+extern qboolean Sys_LowPhysicalMemory();
+	if ( Q_stricmp( lastValidRenderer->string, glConfig.renderer_string ) )
+	{
+		if (Sys_LowPhysicalMemory())
+		{
+			Cvar_Set("s_khz", "11");// this will get called before S_Init
+			Cvar_Set("cg_VariantSoundCap", "2");
+			Cvar_Set("s_allowDynamicMusic","0");
+		}
+		//reset to defaults
+		Cvar_Set( "r_picmip", "1" );
+		
+		// Savage3D and Savage4 should always have trilinear enabled
+		if ( strstr( buf, "savage3d" ) || strstr( buf, "s3 savage4" ) || strstr( buf, "geforce" ) || strstr( buf, "quadro" ) )
+		{
+			Cvar_Set( "r_texturemode", "GL_LINEAR_MIPMAP_LINEAR" );
+		}
+		else
+		{
+			Cvar_Set( "r_textureMode", "GL_LINEAR_MIPMAP_NEAREST" );
+		}
+
+		if ( strstr( buf, "kyro" ) )	
+		{
+			Cvar_Set( "r_ext_texture_filter_anisotropic", "0");	//KYROs have it avail, but suck at it!
+			Cvar_Set( "r_ext_preferred_tc_method", "1");			//(Use DXT1 instead of DXT5 - same quality but much better performance on KYRO)
+		}
+
+		if ( strstr( buf, "geforce2" ) )	
+		{
+			Cvar_Set( "cg_renderToTextureFX", "0");	// slow to zero bug fix
+		}
+
+		if ( strstr( buf, "radeon 9000" ) )	
+		{
+			Cvar_Set( "cg_renderToTextureFX", "0");	// white texture bug
+		}
+
+		GLW_InitExtensions();	//get the values for test below
+		//this must be a really sucky card!
+		if ( (glConfig.textureCompression == TC_NONE) || (glConfig.maxActiveTextures < 2)  || (glConfig.maxTextureSize <= 512) )
+		{
+			Cvar_Set( "r_picmip", "2");
+			Cvar_Set( "r_colorbits", "16");
+			Cvar_Set( "r_texturebits", "16");
+			Cvar_Set( "r_mode", "3");	//force 640
+			Cmd_ExecuteString ("exec low.cfg\n");	//get the rest which can be pulled in after init
+		}
+	}
+	
+	Cvar_Set( "r_lastValidRenderer", glConfig.renderer_string );
+	GLW_InitExtensions();
+
+	WG_CheckHardwareGamma();
+}
+
+/*
+** GLimp_Shutdown
+**
+** This routine does all OS specific shutdown procedures for the OpenGL
+** subsystem.
+*/
+void GLimp_Shutdown( void )
+{
+//	const char *strings[] = { "soft", "hard" };
+	const char *success[] = { "failed", "success" };
+	int retVal;
+
+	// FIXME: Brian, we need better fallbacks from partially initialized failures
+	if ( !qwglMakeCurrent ) {
+		return;
+	}
+
+	VID_Printf( PRINT_ALL, "Shutting down OpenGL subsystem\n" );
+
+	// restore gamma.  We do this first because 3Dfx's extension needs a valid OGL subsystem
+	WG_RestoreGamma();
+
+	// set current context to NULL
+	if ( qwglMakeCurrent )
+	{
+		retVal = qwglMakeCurrent( NULL, NULL ) != 0;
+
+		VID_Printf( PRINT_ALL, "...wglMakeCurrent( NULL, NULL ): %s\n", success[retVal] );
+	}
+
+	// delete HGLRC
+	if ( glw_state.hGLRC )
+	{
+		retVal = qwglDeleteContext( glw_state.hGLRC ) != 0;
+		VID_Printf( PRINT_ALL, "...deleting GL context: %s\n", success[retVal] );
+		glw_state.hGLRC = NULL;
+	}
+
+	// release DC
+	if ( glw_state.hDC )
+	{
+		retVal = ReleaseDC( g_wv.hWnd, glw_state.hDC ) != 0;
+		VID_Printf( PRINT_ALL, "...releasing DC: %s\n", success[retVal] );
+		glw_state.hDC   = NULL;
+	}
+
+	// destroy window
+	if ( g_wv.hWnd )
+	{
+		VID_Printf( PRINT_ALL, "...destroying window\n" );
+		ShowWindow( g_wv.hWnd, SW_HIDE );
+		DestroyWindow( g_wv.hWnd );
+		g_wv.hWnd = NULL;
+		glw_state.pixelFormatSet = qfalse;
+	}
+
+	// close the r_logFile
+	if ( glw_state.log_fp )
+	{
+		fclose( glw_state.log_fp );
+		glw_state.log_fp = 0;
+	}
+
+	// reset display settings
+	if ( glw_state.cdsFullscreen )
+	{
+		VID_Printf( PRINT_ALL, "...resetting display\n" );
+		ChangeDisplaySettings( 0, 0 );
+		glw_state.cdsFullscreen = qfalse;
+	}
+
+	// shutdown QGL subsystem
+	QGL_Shutdown();
+
+	memset( &glConfig, 0, sizeof( glConfig ) );
+	memset( &glState, 0, sizeof( glState ) );
+}
+
+/*
+** GLimp_LogComment
+*/
+void GLimp_LogComment( char *comment ) 
+{
+	if ( glw_state.log_fp ) {
+		fprintf( glw_state.log_fp, "%s", comment );
+	}
+}
\ No newline at end of file
diff --git a/code/win32/win_glimp_console.cpp b/code/win32/win_glimp_console.cpp
new file mode 100644
index 0000000..42f8114
--- /dev/null
+++ b/code/win32/win_glimp_console.cpp
@@ -0,0 +1,261 @@
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+
+/*
+** WIN_GLIMP.C
+**
+** This file contains ALL Win32 specific stuff having to do with the
+** OpenGL refresh.  When a port is being made the following functions
+** must be implemented by the port:
+**
+** GLimp_EndFrame
+** GLimp_Init
+** GLimp_LogComment
+** GLimp_Shutdown
+**
+** Note that the GLW_xxx functions are Windows specific GL-subsystem
+** related functions that are relevant ONLY to win_glimp.c
+*/
+#include <assert.h>
+#include "../renderer/tr_local.h"
+#include "../qcommon/qcommon.h"
+#include "win_local.h"
+
+#if defined(_WINDOWS) || defined(_XBOX)
+#include "glw_win_dx8.h"
+#elif defined(_GAMECUBE)
+#include "glw_win_gc.h"
+#endif
+
+
+extern void WG_CheckHardwareGamma( void );
+
+static void		GLW_InitExtensions( void );
+static int		GLW_CreateWindow( void );
+
+//
+// function declaration
+//
+void	 QGL_EnableLogging( qboolean enable );
+qboolean QGL_Init( const char *dllname );
+void     QGL_Shutdown( void );
+void	 GLW_Init(int width, int height, int colorbits, qboolean cdsFullscreen);
+void	 GLW_Shutdown(void);
+
+
+//
+// variable declarations
+//
+glwstate_t *glw_state = NULL;
+
+
+/*
+** GLW_CreateWindow
+**
+** Responsible for creating the Alchemy window and initializing the OpenGL driver.
+*/
+static qboolean GLW_CreateWindow( int width, int height, int colorbits, qboolean cdsFullscreen )
+{
+	GLW_Init(width, height, colorbits, cdsFullscreen);
+	IN_Init();
+
+	return qtrue;
+}
+
+//--------------------------------------------
+static void GLW_InitTextureCompression( void )
+{
+	glConfig.textureCompression = TC_NONE;
+}
+
+/*
+** GLW_InitExtensions
+*/
+static void GLW_InitExtensions( void )
+{
+	// Select our tc scheme
+	GLW_InitTextureCompression();
+
+	// GL_EXT_texture_env_add
+	glConfig.textureEnvAddAvailable = qfalse;
+	if ( strstr( glConfig.extensions_string, "EXT_texture_env_add" ) )
+	{
+		glConfig.textureEnvAddAvailable = qtrue;
+	}
+
+	// GL_EXT_texture_filter_anisotropic
+	glConfig.textureFilterAnisotropicAvailable = qfalse;
+	if ( strstr( glConfig.extensions_string, "EXT_texture_filter_anisotropic" ) )
+	{
+		glConfig.textureFilterAnisotropicAvailable = qtrue;
+	}
+
+	// GL_EXT_clamp_to_edge
+	glConfig.clampToEdgeAvailable = qfalse;
+	if ( strstr( glConfig.extensions_string, "GL_EXT_texture_edge_clamp" ) )
+	{
+		glConfig.clampToEdgeAvailable = qtrue;
+	}
+
+	// GL_ARB_multitexture
+	if ( strstr( glConfig.extensions_string, "GL_ARB_multitexture" )  )
+	{
+		if ( qglActiveTextureARB )
+		{
+			qglGetIntegerv( GL_MAX_ACTIVE_TEXTURES_ARB, &glConfig.maxActiveTextures );
+			
+			if ( glConfig.maxActiveTextures < 2 )
+			{
+				qglMultiTexCoord2fARB = NULL;
+				qglActiveTextureARB = NULL;
+				qglClientActiveTextureARB = NULL;
+			}
+		}
+	}
+}
+
+/*
+** GLW_LoadOpenGL
+**
+** GLimp_win.c internal function that attempts to load and use 
+** a specific OpenGL DLL.
+*/
+static qboolean GLW_LoadOpenGL()
+{
+	char buffer[1024];
+
+	strlwr( strcpy( buffer, OPENGL_DRIVER_NAME ) );
+
+	//
+	// load the driver and bind our function pointers to it
+	// 
+	if ( QGL_Init( buffer ) ) 
+	{
+		GLW_CreateWindow(640, 480, 24, 1);
+		return qtrue;
+	}
+
+	QGL_Shutdown();
+
+	return qfalse;
+}
+
+
+/*
+** GLimp_EndFrame
+*/
+void GLimp_EndFrame (void)
+{
+	// don't flip if drawing to front buffer
+//	if ( stricmp( r_drawBuffer->string, "GL_FRONT" ) != 0 )
+	{
+	}
+}
+
+static void GLW_StartOpenGL( void )
+{
+	//
+	// load and initialize the specific OpenGL driver
+	//
+	if ( !GLW_LoadOpenGL() )
+	{
+		Com_Error( ERR_FATAL, "GLW_StartOpenGL() - could not load OpenGL subsystem\n" );
+	}
+}
+
+/*
+** GLimp_Init
+**
+** This is the platform specific OpenGL initialization function.  It
+** is responsible for loading OpenGL, initializing it, setting
+** extensions, creating a window of the appropriate size, doing
+** fullscreen manipulations, etc.  Its overall responsibility is
+** to make sure that a functional OpenGL subsystem is operating
+** when it returns to the ref.
+*/
+void GLimp_Init( void )
+{
+	// load appropriate DLL and initialize subsystem
+	GLW_StartOpenGL();
+
+	// get our config strings
+	glConfig.vendor_string = (const char *) qglGetString (GL_VENDOR);
+	glConfig.renderer_string = (const char *) qglGetString (GL_RENDERER);
+	glConfig.version_string = (const char *) qglGetString (GL_VERSION);
+	glConfig.extensions_string = (const char *) qglGetString (GL_EXTENSIONS);
+	
+	if (!glConfig.vendor_string || !glConfig.renderer_string || !glConfig.version_string || !glConfig.extensions_string)
+	{
+		Com_Error( ERR_FATAL, "GLimp_Init() - Invalid GL Driver\n" );
+	}
+
+	// OpenGL driver constants
+	qglGetIntegerv( GL_MAX_TEXTURE_SIZE, &glConfig.maxTextureSize );
+	// stubbed or broken drivers may have reported 0...
+	if ( glConfig.maxTextureSize <= 0 ) 
+	{
+		glConfig.maxTextureSize = 0;
+	}
+
+	GLW_InitExtensions();
+	WG_CheckHardwareGamma();
+}
+
+/*
+** GLimp_Shutdown
+**
+** This routine does all OS specific shutdown procedures for the OpenGL
+** subsystem.
+*/
+void GLimp_Shutdown( void )
+{
+	// FIXME: Brian, we need better fallbacks from partially initialized failures
+	VID_Printf( PRINT_ALL, "Shutting down OpenGL subsystem\n" );
+
+	// Set the gamma back to normal
+//	GLimp_SetGamma(1.f);
+
+	// kill input system (tied to window)
+	IN_Shutdown();
+
+	// shutdown QGL subsystem
+	GLW_Shutdown();
+	QGL_Shutdown();
+
+	memset( &glConfig, 0, sizeof( glConfig ) );
+	memset( &glState, 0, sizeof( glState ) );
+}
+
+/*
+** GLimp_LogComment
+*/
+void GLimp_LogComment( char *comment ) 
+{
+}
+
+
+/*
+===========================================================
+
+SMP acceleration
+
+===========================================================
+*/
+
+qboolean GLimp_SpawnRenderThread( void (*function)( void ) ) {
+	return qfalse;
+}
+
+void *GLimp_RendererSleep( void ) {
+	return NULL;
+}
+
+
+void GLimp_FrontEndSleep( void ) {
+}
+
+
+void GLimp_WakeRenderer( void *data ) {
+}
diff --git a/code/win32/win_input.cpp b/code/win32/win_input.cpp
new file mode 100644
index 0000000..293cfaf
--- /dev/null
+++ b/code/win32/win_input.cpp
@@ -0,0 +1,1147 @@
+// win_input.c -- win32 mouse and joystick code
+// 02/21/97 JCB Added extended DirectInput code to support external controllers.
+
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+
+
+
+#include "../client/client.h"
+#ifndef _IMMERSION
+#include "../client/fffx.h"
+#endif // _IMMERSION
+#include "win_local.h"
+
+typedef struct {
+	int			oldButtonState;
+
+	qboolean	mouseActive;
+	qboolean	mouseInitialized;
+} WinMouseVars_t;
+
+static WinMouseVars_t s_wmv;
+
+static int	window_center_x, window_center_y;
+
+//
+// MIDI definitions
+//
+static void IN_StartupMIDI( void );
+static void IN_ShutdownMIDI( void );
+
+#define MAX_MIDIIN_DEVICES	8
+
+typedef struct {
+	int			numDevices;
+	MIDIINCAPS	caps[MAX_MIDIIN_DEVICES];
+
+	HMIDIIN		hMidiIn;
+} MidiInfo_t;
+
+static MidiInfo_t s_midiInfo;
+
+//
+// Joystick definitions
+//
+#define	JOY_MAX_AXES		6				// X, Y, Z, R, U, V
+
+typedef struct {
+	qboolean	avail;
+	int			id;			// joystick number
+	JOYCAPS		jc;
+
+	int			oldbuttonstate;
+	int			oldpovstate;
+
+	JOYINFOEX	ji;
+} joystickInfo_t;
+
+static	joystickInfo_t	joy;
+
+
+cvar_t	*in_midi;
+cvar_t	*in_midiport;
+cvar_t	*in_midichannel;
+cvar_t	*in_mididevice;
+
+cvar_t	*in_mouse;
+cvar_t	*in_joystick;
+cvar_t	*in_joyBallScale;
+cvar_t	*in_debugJoystick;
+cvar_t	*joy_threshold;
+cvar_t	*js_ffmult;
+cvar_t	*joy_xbutton;
+cvar_t	*joy_ybutton;
+
+qboolean	in_appactive;
+
+// forward-referenced functions
+void IN_StartupJoystick (void);
+void IN_JoyMove(void);
+
+static void MidiInfo_f( void );
+
+/*
+============================================================
+
+WIN32 MOUSE CONTROL
+
+============================================================
+*/
+
+/*
+================
+IN_InitWin32Mouse
+================
+*/
+void IN_InitWin32Mouse( void ) 
+{
+}
+
+/*
+================
+IN_ShutdownWin32Mouse
+================
+*/
+void IN_ShutdownWin32Mouse( void ) {
+}
+
+/*
+================
+IN_ActivateWin32Mouse
+================
+*/
+void IN_ActivateWin32Mouse( void ) {
+	int			width, height;
+	RECT		window_rect;
+
+	width = GetSystemMetrics (SM_CXSCREEN);
+	height = GetSystemMetrics (SM_CYSCREEN);
+
+	GetWindowRect ( g_wv.hWnd, &window_rect);
+	if (window_rect.left < 0)
+		window_rect.left = 0;
+	if (window_rect.top < 0)
+		window_rect.top = 0;
+	if (window_rect.right >= width)
+		window_rect.right = width-1;
+	if (window_rect.bottom >= height-1)
+		window_rect.bottom = height-1;
+	window_center_x = (window_rect.right + window_rect.left)/2;
+	window_center_y = (window_rect.top + window_rect.bottom)/2;
+
+	SetCursorPos (window_center_x, window_center_y);
+
+	SetCapture ( g_wv.hWnd );
+	ClipCursor (&window_rect);
+	while (ShowCursor (FALSE) >= 0)
+		;
+}
+
+/*
+================
+IN_DeactivateWin32Mouse
+================
+*/
+void IN_DeactivateWin32Mouse( void ) 
+{
+	ClipCursor (NULL);
+	ReleaseCapture ();
+	while (ShowCursor (TRUE) < 0)
+		;
+}
+
+/*
+================
+IN_Win32Mouse
+================
+*/
+void IN_Win32Mouse( int *mx, int *my ) {
+	POINT		current_pos;
+
+	// find mouse movement
+	GetCursorPos (&current_pos);
+
+	// force the mouse to the center, so there's room to move
+	SetCursorPos (window_center_x, window_center_y);
+
+	*mx = current_pos.x - window_center_x;
+	*my = current_pos.y - window_center_y;
+}
+
+
+/*
+============================================================
+
+DIRECT INPUT MOUSE CONTROL
+
+============================================================
+*/
+
+#undef DEFINE_GUID
+
+#define DEFINE_GUID(name, l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8) \
+        EXTERN_C const GUID name \
+                = { l, w1, w2, { b1, b2,  b3,  b4,  b5,  b6,  b7,  b8 } }
+
+DEFINE_GUID(qGUID_SysMouse,   0x6F1D2B60,0xD5A0,0x11CF,0xBF,0xC7,0x44,0x45,0x53,0x54,0x00,0x00);
+DEFINE_GUID(qGUID_XAxis,   0xA36D02E0,0xC9F3,0x11CF,0xBF,0xC7,0x44,0x45,0x53,0x54,0x00,0x00);
+DEFINE_GUID(qGUID_YAxis,   0xA36D02E1,0xC9F3,0x11CF,0xBF,0xC7,0x44,0x45,0x53,0x54,0x00,0x00);
+DEFINE_GUID(qGUID_ZAxis,   0xA36D02E2,0xC9F3,0x11CF,0xBF,0xC7,0x44,0x45,0x53,0x54,0x00,0x00);
+
+
+#define DINPUT_BUFFERSIZE           16
+#define iDirectInputCreate(a,b,c,d)	pDirectInputCreate(a,b,c,d)
+
+HRESULT (WINAPI *pDirectInputCreate)(HINSTANCE hinst, DWORD dwVersion,
+	LPDIRECTINPUT * lplpDirectInput, LPUNKNOWN punkOuter);
+
+static HINSTANCE hInstDI;
+
+typedef struct MYDATA {
+	LONG  lX;                   // X axis goes here
+	LONG  lY;                   // Y axis goes here
+	LONG  lZ;                   // Z axis goes here
+	BYTE  bButtonA;             // One button goes here
+	BYTE  bButtonB;             // Another button goes here
+	BYTE  bButtonC;             // Another button goes here
+	BYTE  bButtonD;             // Another button goes here
+} MYDATA;
+
+static DIOBJECTDATAFORMAT rgodf[] = {
+  { &qGUID_XAxis,    FIELD_OFFSET(MYDATA, lX),       DIDFT_AXIS | DIDFT_ANYINSTANCE,   0,},
+  { &qGUID_YAxis,    FIELD_OFFSET(MYDATA, lY),       DIDFT_AXIS | DIDFT_ANYINSTANCE,   0,},
+  { &qGUID_ZAxis,    FIELD_OFFSET(MYDATA, lZ),       0x80000000 | DIDFT_AXIS | DIDFT_ANYINSTANCE,   0,},
+  { 0,              FIELD_OFFSET(MYDATA, bButtonA), DIDFT_BUTTON | DIDFT_ANYINSTANCE, 0,},
+  { 0,              FIELD_OFFSET(MYDATA, bButtonB), DIDFT_BUTTON | DIDFT_ANYINSTANCE, 0,},
+  { 0,              FIELD_OFFSET(MYDATA, bButtonC), 0x80000000 | DIDFT_BUTTON | DIDFT_ANYINSTANCE, 0,},
+  { 0,              FIELD_OFFSET(MYDATA, bButtonD), 0x80000000 | DIDFT_BUTTON | DIDFT_ANYINSTANCE, 0,},
+};
+
+#define NUM_OBJECTS (sizeof(rgodf) / sizeof(rgodf[0]))
+
+static DIDATAFORMAT	df = {
+	sizeof(DIDATAFORMAT),       // this structure
+	sizeof(DIOBJECTDATAFORMAT), // size of object data format
+	DIDF_RELAXIS,               // absolute axis coordinates
+	sizeof(MYDATA),             // device data size
+	NUM_OBJECTS,                // number of objects
+	rgodf,                      // and here they are
+};
+
+static LPDIRECTINPUT		g_pdi;
+static LPDIRECTINPUTDEVICE	g_pMouse;
+
+void IN_DIMouse( int *mx, int *my );
+
+/*
+========================
+IN_InitDIMouse
+========================
+*/
+qboolean IN_InitDIMouse( void ) {
+    HRESULT		hr;
+	int			x, y;
+	DIPROPDWORD	dipdw = {
+		{
+			sizeof(DIPROPDWORD),        // diph.dwSize
+			sizeof(DIPROPHEADER),       // diph.dwHeaderSize
+			0,                          // diph.dwObj
+			DIPH_DEVICE,                // diph.dwHow
+		},
+		DINPUT_BUFFERSIZE,              // dwData
+	};
+
+	Com_Printf( "Initializing DirectInput...\n");
+
+	if (!hInstDI) {
+		hInstDI = LoadLibrary("dinput.dll");
+		
+		if (hInstDI == NULL) {
+			Com_Printf ("Couldn't load dinput.dll\n");
+			return qfalse;
+		}
+	}
+
+	if (!pDirectInputCreate) {
+		pDirectInputCreate = (long (__stdcall *)(struct HINSTANCE__ *,unsigned long,struct IDirectInputA ** ,struct IUnknown *))
+			GetProcAddress(hInstDI,"DirectInputCreateA");
+
+		if (!pDirectInputCreate) {
+			Com_Printf ("Couldn't get DI proc addr\n");
+			return qfalse;
+		}
+	}
+
+	// register with DirectInput and get an IDirectInput to play with.
+	hr = iDirectInputCreate( g_wv.hInstance, DIRECTINPUT_VERSION, &g_pdi, NULL);
+
+	if (FAILED(hr)) {
+		Com_Printf ("iDirectInputCreate failed\n");
+		return qfalse;
+	}
+
+	// obtain an interface to the system mouse device.
+	hr = g_pdi->CreateDevice( qGUID_SysMouse, &g_pMouse, NULL);
+
+	if (FAILED(hr)) {
+		Com_Printf ("Couldn't open DI mouse device\n");
+		return qfalse;
+	}
+
+	// set the data format to "mouse format".
+	hr = IDirectInputDevice_SetDataFormat(g_pMouse, &df);
+
+	if (FAILED(hr)) 	{
+		Com_Printf ("Couldn't set DI mouse format\n");
+		return qfalse;
+	}
+
+	// set the cooperativity level.
+	hr = IDirectInputDevice_SetCooperativeLevel(g_pMouse, g_wv.hWnd,
+			DISCL_EXCLUSIVE | DISCL_FOREGROUND);
+
+	if (FAILED(hr)) {
+		Com_Printf ("Couldn't set DI coop level\n");
+		return qfalse;
+	}
+
+
+	// set the buffer size to DINPUT_BUFFERSIZE elements.
+	// the buffer size is a DWORD property associated with the device
+	hr = IDirectInputDevice_SetProperty(g_pMouse, DIPROP_BUFFERSIZE, &dipdw.diph);
+
+	if (FAILED(hr)) {
+		Com_Printf ("Couldn't set DI buffersize\n");
+		return qfalse;
+	}
+
+	// clear any pending samples
+	IN_DIMouse( &x, &y );
+	IN_DIMouse( &x, &y );
+
+	Com_Printf( "DirectInput initialized.\n");
+	return qtrue;
+}
+
+/*
+==========================
+IN_ShutdownDIMouse
+==========================
+*/
+void IN_ShutdownDIMouse( void ) 
+{
+    if (g_pMouse) 
+	{
+		IDirectInputDevice_Release(g_pMouse);
+		g_pMouse = NULL;
+	}
+	if (g_pdi) 
+	{
+		IDirectInput_Release(g_pdi);
+		g_pdi = NULL;
+	}
+	if(hInstDI)
+	{
+		FreeLibrary(hInstDI);
+		hInstDI = NULL;
+	}
+}
+
+/*
+==========================
+IN_ActivateDIMouse
+==========================
+*/
+void IN_ActivateDIMouse( void ) {
+	HRESULT		hr;
+
+	if (!g_pMouse) {
+		return;
+	}
+
+	// we may fail to reacquire if the window has been recreated
+	hr = IDirectInputDevice_Acquire( g_pMouse );
+	if (FAILED(hr)) {
+		if ( !IN_InitDIMouse() ) {
+			Com_Printf ("Falling back to Win32 mouse support...\n");
+			Cvar_Set( "in_mouse", "-1" );
+		}
+	}
+}
+
+/*
+==========================
+IN_DeactivateDIMouse
+==========================
+*/
+void IN_DeactivateDIMouse( void ) {
+	if (!g_pMouse) {
+		return;
+	}
+	IDirectInputDevice_Unacquire( g_pMouse );
+}
+
+
+/*
+===================
+IN_DIMouse
+===================
+*/
+void IN_DIMouse( int *mx, int *my ) {
+	DIDEVICEOBJECTDATA	od;
+	DIMOUSESTATE		state;
+	DWORD				dwElements;
+	HRESULT				hr;
+	static float		oldSysTime;
+
+	if ( !g_pMouse ) {
+		return;
+	}
+
+	// fetch new events
+	for (;;)
+	{
+		dwElements = 1;
+
+		hr = IDirectInputDevice_GetDeviceData(g_pMouse,
+				sizeof(DIDEVICEOBJECTDATA), &od, &dwElements, 0);
+		if ((hr == DIERR_INPUTLOST) || (hr == DIERR_NOTACQUIRED)) {
+			IDirectInputDevice_Acquire(g_pMouse);
+			return;
+		}
+
+		/* Unable to read data or no data available */
+		if ( FAILED(hr) ) {
+			break;
+		}
+
+		if ( dwElements == 0 ) {
+			break;
+		}
+
+		switch (od.dwOfs) {
+		case DIMOFS_BUTTON0:
+			if (od.dwData & 0x80)
+				Sys_QueEvent( od.dwTimeStamp, SE_KEY, A_MOUSE1, qtrue, 0, NULL );
+			else
+				Sys_QueEvent( od.dwTimeStamp, SE_KEY, A_MOUSE1, qfalse, 0, NULL );
+			break;
+
+		case DIMOFS_BUTTON1:
+			if (od.dwData & 0x80)
+				Sys_QueEvent( od.dwTimeStamp, SE_KEY, A_MOUSE2, qtrue, 0, NULL );
+			else
+				Sys_QueEvent( od.dwTimeStamp, SE_KEY, A_MOUSE2, qfalse, 0, NULL );
+			break;
+			
+		case DIMOFS_BUTTON2:
+			if (od.dwData & 0x80)
+				Sys_QueEvent( od.dwTimeStamp, SE_KEY, A_MOUSE3, qtrue, 0, NULL );
+			else
+				Sys_QueEvent( od.dwTimeStamp, SE_KEY, A_MOUSE3, qfalse, 0, NULL );
+			break;
+		}
+	}
+
+	// read the raw delta counter and ignore
+	// the individual sample time / values
+	hr = IDirectInputDevice_GetDeviceState(g_pMouse,
+			sizeof(DIDEVICEOBJECTDATA), &state);
+	if ( FAILED(hr) ) {
+		*mx = *my = 0;
+		return;
+	}
+	*mx = state.lX;
+	*my = state.lY;
+}
+
+/*
+============================================================
+
+  MOUSE CONTROL
+
+============================================================
+*/
+
+/*
+===========
+IN_ActivateMouse
+
+Called when the window gains focus or changes in some way
+===========
+*/
+void IN_ActivateMouse( void ) 
+{
+	if (!s_wmv.mouseInitialized ) {
+		return;
+	}
+	if ( !in_mouse->integer ) 
+	{
+		s_wmv.mouseActive = qfalse;
+		return;
+	}
+	if ( s_wmv.mouseActive ) 
+	{
+		return;
+	}
+
+	s_wmv.mouseActive = qtrue;
+
+	if ( in_mouse->integer != -1 ) {
+		IN_ActivateDIMouse();
+	}
+	IN_ActivateWin32Mouse();
+}
+
+
+/*
+===========
+IN_DeactivateMouse
+
+Called when the window loses focus
+===========
+*/
+void IN_DeactivateMouse( void ) {
+	if (!s_wmv.mouseInitialized ) {
+		return;
+	}
+	if (!s_wmv.mouseActive ) {
+		return;
+	}
+	s_wmv.mouseActive = qfalse;
+
+	IN_DeactivateDIMouse();
+	IN_DeactivateWin32Mouse();
+}
+
+
+
+/*
+===========
+IN_StartupMouse
+===========
+*/
+void IN_StartupMouse( void ) 
+{
+	s_wmv.mouseInitialized = qfalse;
+
+	if ( in_mouse->integer == 0 ) {
+		Com_Printf ("Mouse control not active.\n");
+		return;
+	}
+
+	// nt4.0 direct input is screwed up
+	if ( ( g_wv.osversion.dwPlatformId == VER_PLATFORM_WIN32_NT ) &&
+		 ( g_wv.osversion.dwMajorVersion == 4 ) )
+	{
+		Com_Printf ("Disallowing DirectInput on NT 4.0\n");
+		Cvar_Set( "in_mouse", "-1" );
+	}
+
+	s_wmv.mouseInitialized = qtrue;
+
+	if ( in_mouse->integer == -1 ) {
+		Com_Printf ("Skipping check for DirectInput\n");
+	} else {
+		if ( IN_InitDIMouse() ) {
+			return;
+		}
+		Com_Printf ("Falling back to Win32 mouse support...\n");
+	}
+	IN_InitWin32Mouse();
+}
+
+/*
+===========
+IN_MouseEvent
+===========
+*/
+#define MAX_MOUSE_BUTTONS	5
+
+static int mouseConvert[MAX_MOUSE_BUTTONS] =
+{
+	A_MOUSE1,
+	A_MOUSE2,
+	A_MOUSE3,
+	A_MOUSE4,
+	A_MOUSE5
+};
+
+void IN_MouseEvent (int mstate)
+{
+	int		i;
+
+	if ( !s_wmv.mouseInitialized )
+	{
+		return;
+	}
+
+	// perform button actions
+	for  (i = 0 ; i < MAX_MOUSE_BUTTONS ; i++ )
+	{
+		if ( (mstate & (1 << i)) && !(s_wmv.oldButtonState & (1 << i)) )
+		{
+			Sys_QueEvent( g_wv.sysMsgTime, SE_KEY, mouseConvert[i], true, 0, NULL );
+		}
+		if ( !(mstate & (1 << i)) && (s_wmv.oldButtonState & (1 << i)) )
+		{
+			Sys_QueEvent( g_wv.sysMsgTime, SE_KEY, mouseConvert[i], false, 0, NULL );
+		}
+	}	
+	s_wmv.oldButtonState = mstate;
+}
+
+
+
+/*
+===========
+IN_MouseMove
+===========
+*/
+void IN_MouseMove ( void ) {
+	int		mx, my;
+
+	if ( g_pMouse ) {
+		IN_DIMouse( &mx, &my );
+	} else {
+		IN_Win32Mouse( &mx, &my );
+	}
+
+	if ( !mx && !my ) {
+		return;
+	}
+
+	Sys_QueEvent( 0, SE_MOUSE, mx, my, 0, NULL );
+}
+
+
+/*
+=========================================================================
+
+=========================================================================
+*/
+
+/*
+===========
+IN_Startup
+===========
+*/
+void IN_Startup( void ) {
+	Com_Printf ("\n------- Input Initialization -------\n");
+	IN_StartupMouse ();
+	IN_StartupJoystick ();
+	IN_StartupMIDI();
+	Com_Printf ("------------------------------------\n");
+
+	in_mouse->modified = qfalse;
+	in_joystick->modified = qfalse;
+}
+
+/*
+===========
+IN_Shutdown
+===========
+*/
+void IN_Shutdown( void ) {
+	IN_DeactivateMouse();
+	IN_ShutdownDIMouse();
+	IN_ShutdownMIDI();
+	Cmd_RemoveCommand("midiinfo" );
+#ifndef _IMMERSION
+	FF_Shutdown();
+#endif // _IMMERSION
+}
+
+
+/*
+===========
+IN_Init
+===========
+*/
+void IN_Init( void ) {
+	// MIDI input controler variables
+	in_midi					= Cvar_Get ("in_midi",					"0",		CVAR_ARCHIVE);
+	in_midiport				= Cvar_Get ("in_midiport",				"1",		CVAR_ARCHIVE);
+	in_midichannel			= Cvar_Get ("in_midichannel",			"1",		CVAR_ARCHIVE);
+	in_mididevice			= Cvar_Get ("in_mididevice",			"0",		CVAR_ARCHIVE);
+
+	Cmd_AddCommand( "midiinfo", MidiInfo_f );
+
+	// mouse variables
+    in_mouse				= Cvar_Get ("in_mouse",					"-1",		CVAR_ARCHIVE|CVAR_LATCH);
+
+	// joystick variables
+	in_joystick				= Cvar_Get ("in_joystick",				"0",		CVAR_ARCHIVE|CVAR_LATCH);
+	in_joyBallScale			= Cvar_Get ("in_joyBallScale",			"0.02",		CVAR_ARCHIVE);
+	in_debugJoystick		= Cvar_Get ("in_debugjoystick",			"0",		CVAR_TEMP);
+
+	joy_threshold			= Cvar_Get ("joy_threshold",			"0.15",		CVAR_ARCHIVE);
+
+	js_ffmult				= Cvar_Get ("js_ffmult",				"3.0",		CVAR_ARCHIVE);	// force feedback
+
+	joy_xbutton			= Cvar_Get ("joy_xbutton",			"1",		CVAR_ARCHIVE);	// treat axis as a button
+	joy_ybutton			= Cvar_Get ("joy_ybutton",			"0",		CVAR_ARCHIVE);	// treat axis as a button
+
+	IN_Startup();
+#ifndef _IMMERSION
+	FF_Init();
+#endif // _IMMERSION
+}
+
+
+/*
+===========
+IN_Activate
+
+Called when the main window gains or loses focus.
+The window may have been destroyed and recreated
+between a deactivate and an activate.
+===========
+*/
+void IN_Activate (qboolean active) {
+	in_appactive = active;
+
+	if ( !active )
+	{
+		IN_DeactivateMouse();
+	}
+}
+
+
+/*
+==================
+IN_Frame
+
+Called every frame, even if not generating commands
+==================
+*/
+void IN_Frame (void) {
+	// post joystick events
+	IN_JoyMove();
+
+	if ( !s_wmv.mouseInitialized ) {
+		return;
+	}
+
+	if ( cls.keyCatchers & KEYCATCH_CONSOLE ) {
+		// temporarily deactivate if not in the game and
+		// running on the desktop
+		if (Cvar_VariableIntegerValue ("r_fullscreen") == 0 )	{
+			IN_DeactivateMouse ();
+			return;
+		}
+	}
+
+	if ( !in_appactive ) {
+		IN_DeactivateMouse ();
+		return;
+	}
+
+	IN_ActivateMouse();
+
+	// post events to the system que
+	IN_MouseMove();
+
+}
+
+
+/*
+===================
+IN_ClearStates
+===================
+*/
+void IN_ClearStates (void) 
+{
+	s_wmv.oldButtonState = 0;
+}
+
+
+/*
+=========================================================================
+
+JOYSTICK
+
+=========================================================================
+*/
+
+/* 
+=============== 
+IN_StartupJoystick 
+=============== 
+*/  
+void IN_StartupJoystick (void) { 
+	int			numdevs;
+	MMRESULT	mmr;
+
+	// assume no joystick
+	joy.avail = qfalse; 
+
+	if (! in_joystick->integer ) {
+		Com_Printf ("Joystick is not active.\n");
+		return;
+	}
+
+	// verify joystick driver is present
+	if ((numdevs = joyGetNumDevs ()) == 0)
+	{
+		Com_Printf ("joystick not found -- driver not present\n");
+		return;
+	}
+
+	// cycle through the joystick ids for the first valid one
+	mmr = 0;
+	for (joy.id=0 ; joy.id<numdevs ; joy.id++)
+	{
+		memset (&joy.ji, 0, sizeof(joy.ji));
+		joy.ji.dwSize = sizeof(joy.ji);
+		joy.ji.dwFlags = JOY_RETURNCENTERED;
+
+		if ((mmr = joyGetPosEx (joy.id, &joy.ji)) == JOYERR_NOERROR)
+			break;
+	} 
+
+	// abort startup if we didn't find a valid joystick
+	if (mmr != JOYERR_NOERROR)
+	{
+		Com_Printf ("joystick not found -- no valid joysticks (%x)\n", mmr);
+		return;
+	}
+
+	// get the capabilities of the selected joystick
+	// abort startup if command fails
+	memset (&joy.jc, 0, sizeof(joy.jc));
+	if ((mmr = joyGetDevCaps (joy.id, &joy.jc, sizeof(joy.jc))) != JOYERR_NOERROR)
+	{
+		Com_Printf ("joystick not found -- invalid joystick capabilities (%x)\n", mmr); 
+		return;
+	}
+
+	Com_Printf( "Joystick found.\n" );
+	Com_Printf( "Pname: %s\n", joy.jc.szPname );
+	Com_Printf( "OemVxD: %s\n", joy.jc.szOEMVxD );
+	Com_Printf( "RegKey: %s\n", joy.jc.szRegKey );
+
+	Com_Printf( "Numbuttons: %i / %i\n", joy.jc.wNumButtons, joy.jc.wMaxButtons );
+	Com_Printf( "Axis: %i / %i\n", joy.jc.wNumAxes, joy.jc.wMaxAxes );
+	Com_Printf( "Caps: 0x%x\n", joy.jc.wCaps );
+	if ( joy.jc.wCaps & JOYCAPS_HASPOV ) {
+		Com_Printf( "HASPOV\n" );
+	} else {
+		Com_Printf( "no POV\n" );
+	}
+
+	// old button and POV states default to no buttons pressed
+	joy.oldbuttonstate = 0;
+	joy.oldpovstate = 0;
+
+	// mark the joystick as available
+	joy.avail = qtrue; 
+}
+
+/*
+===========
+JoyToF
+===========
+*/
+float JoyToF( int value ) {
+	float	fValue;
+
+	// move centerpoint to zero
+	value -= 32768;
+
+	// convert range from -32768..32767 to -1..1 
+	fValue = (float)value / 32768.0;
+
+	if ( fValue < -1 ) {
+		fValue = -1;
+	}
+	if ( fValue > 1 ) {
+		fValue = 1;
+	}
+	return fValue;
+}
+
+int JoyToI( int value ) {
+	// move centerpoint to zero
+	value -= 32768;
+
+	return value;
+}
+
+int	joyDirectionKeys[16] = {
+	A_CURSOR_LEFT, A_CURSOR_RIGHT,
+	A_CURSOR_UP, A_CURSOR_DOWN,
+	A_JOY16, A_JOY17,
+	A_JOY18, A_JOY19,
+	A_JOY20, A_JOY21,
+	A_JOY22, A_JOY23,
+
+	A_JOY24, A_JOY25,
+	A_JOY26, A_JOY27
+};
+
+/*
+===========
+IN_JoyMove
+===========
+*/
+void IN_JoyMove( void ) {
+	float	fAxisValue;
+	int		i;
+	DWORD	buttonstate, povstate;
+	int		x, y;
+
+	// verify joystick is available and that the user wants to use it
+	if ( !joy.avail ) {
+		return; 
+	}
+
+	// collect the joystick data, if possible
+	memset (&joy.ji, 0, sizeof(joy.ji));
+	joy.ji.dwSize = sizeof(joy.ji);
+	joy.ji.dwFlags = JOY_RETURNALL;
+
+	if ( joyGetPosEx (joy.id, &joy.ji) != JOYERR_NOERROR ) {
+		// read error occurred
+		// turning off the joystick seems too harsh for 1 read error,\
+		// but what should be done?
+		// Com_Printf ("IN_ReadJoystick: no response\n");
+		// joy.avail = false;
+		return;
+	}
+
+	if ( in_debugJoystick->integer ) {
+		Com_Printf( "%8x %5i %5.2f %5.2f %5.2f %5.2f %6i %6i\n", 
+			joy.ji.dwButtons,
+			joy.ji.dwPOV,
+			JoyToF( joy.ji.dwXpos ), JoyToF( joy.ji.dwYpos ),
+			JoyToF( joy.ji.dwZpos ), JoyToF( joy.ji.dwRpos ),
+			JoyToI( joy.ji.dwUpos ), JoyToI( joy.ji.dwVpos ) );
+	}
+
+	// loop through the joystick buttons
+	// key a joystick event or auxillary event for higher number buttons for each state change
+	buttonstate = joy.ji.dwButtons;
+	for ( i=0 ; i < joy.jc.wNumButtons ; i++ ) {
+		if ( (buttonstate & (1<<i)) && !(joy.oldbuttonstate & (1<<i)) ) {
+			Sys_QueEvent( g_wv.sysMsgTime, SE_KEY, A_JOY0 + i, qtrue, 0, NULL );
+		}
+		if ( !(buttonstate & (1<<i)) && (joy.oldbuttonstate & (1<<i)) ) {
+			Sys_QueEvent( g_wv.sysMsgTime, SE_KEY, A_JOY0 + i, qfalse, 0, NULL );
+		}
+	}
+	joy.oldbuttonstate = buttonstate;
+
+	povstate = 0;
+
+	// convert main joystick motion into 6 direction button bits
+	for (i = 0; i < joy.jc.wNumAxes && i < 4 ; i++) {
+		// get the floating point zero-centered, potentially-inverted data for the current axis
+		fAxisValue = JoyToF( (&joy.ji.dwXpos)[i] );
+		
+		if (i == 0 && !joy_xbutton->integer) {
+			if ( fAxisValue < -joy_threshold->value || fAxisValue > joy_threshold->value){
+				Sys_QueEvent( g_wv.sysMsgTime, SE_JOYSTICK_AXIS, AXIS_SIDE, (int) -(fAxisValue*127.0), 0, NULL );
+			}else{
+				Sys_QueEvent( g_wv.sysMsgTime, SE_JOYSTICK_AXIS, AXIS_SIDE, 0, 0, NULL );
+			}
+			continue;
+		}
+		
+		if (i == 1 && !joy_ybutton->integer) {
+			if ( fAxisValue < -joy_threshold->value || fAxisValue > joy_threshold->value){
+				Sys_QueEvent( g_wv.sysMsgTime, SE_JOYSTICK_AXIS, AXIS_FORWARD, (int) -(fAxisValue*127.0), 0, NULL );
+			}else{
+				Sys_QueEvent( g_wv.sysMsgTime, SE_JOYSTICK_AXIS, AXIS_FORWARD, 0, 0, NULL );
+			}
+			continue;
+		}
+		
+		if ( fAxisValue < -joy_threshold->value ) {
+			povstate |= (1<<(i*2));
+		} else if ( fAxisValue > joy_threshold->value ) {
+			povstate |= (1<<(i*2+1));
+		}
+	}		
+
+	// convert POV information from a direction into 4 button bits
+	if ( joy.jc.wCaps & JOYCAPS_HASPOV ) {
+		if ( joy.ji.dwPOV != JOY_POVCENTERED ) {
+			if (joy.ji.dwPOV == JOY_POVFORWARD)
+				povstate |= 1<<12;
+			if (joy.ji.dwPOV == JOY_POVBACKWARD)
+				povstate |= 1<<13;
+			if (joy.ji.dwPOV == JOY_POVRIGHT)
+				povstate |= 1<<14;
+			if (joy.ji.dwPOV == JOY_POVLEFT)
+				povstate |= 1<<15;
+		}
+	}
+
+	// determine which bits have changed and key an auxillary event for each change
+	for (i=0 ; i < 16 ; i++) {
+		if ( (povstate & (1<<i)) && !(joy.oldpovstate & (1<<i)) ) {
+			Sys_QueEvent( g_wv.sysMsgTime, SE_KEY, joyDirectionKeys[i], qtrue, 0, NULL );
+		}
+
+		if ( !(povstate & (1<<i)) && (joy.oldpovstate & (1<<i)) ) {
+			Sys_QueEvent( g_wv.sysMsgTime, SE_KEY, joyDirectionKeys[i], qfalse, 0, NULL );
+		}
+	}
+	joy.oldpovstate = povstate;
+
+	// if there is a trackball like interface, simulate mouse moves
+	if ( joy.jc.wNumAxes >= 6 ) {
+		x = JoyToI( joy.ji.dwUpos ) * in_joyBallScale->value;
+		y = JoyToI( joy.ji.dwVpos ) * in_joyBallScale->value;
+		if ( x || y ) {
+			Sys_QueEvent( g_wv.sysMsgTime, SE_MOUSE, x, y, 0, NULL );
+		}
+	}
+}
+
+/*
+=========================================================================
+
+MIDI
+
+=========================================================================
+*/
+
+static void MIDI_NoteOff( int note )
+{
+	int qkey;
+
+	qkey = note - 60 + A_AUX0;
+
+	if ( qkey < A_AUX0 )
+	{
+		return;
+	}
+	Sys_QueEvent( g_wv.sysMsgTime, SE_KEY, qkey, qfalse, 0, NULL );
+}
+
+static void MIDI_NoteOn( int note, int velocity )
+{
+	int qkey;
+
+	if ( velocity == 0 )
+	{
+		MIDI_NoteOff( note );
+	}
+
+	qkey = note - 60 + A_AUX0;
+
+	if ( qkey < A_AUX0 )
+	{
+		return;
+	}
+	Sys_QueEvent( g_wv.sysMsgTime, SE_KEY, qkey, qtrue, 0, NULL );
+}
+
+static void CALLBACK MidiInProc( HMIDIIN hMidiIn, UINT uMsg, DWORD dwInstance, 
+								 DWORD dwParam1, DWORD dwParam2 )
+{
+	int message;
+
+	switch ( uMsg )
+	{
+	case MIM_OPEN:
+		break;
+	case MIM_CLOSE:
+		break;
+	case MIM_DATA:
+		message = dwParam1 & 0xff;
+
+		// note on
+		if ( ( message & 0xf0 ) == 0x90 )
+		{
+			if ( ( ( message & 0x0f ) + 1 ) == in_midichannel->integer )
+				MIDI_NoteOn( ( dwParam1 & 0xff00 ) >> 8, ( dwParam1 & 0xff0000 ) >> 16 );
+		}
+		else if ( ( message & 0xf0 ) == 0x80 )
+		{
+			if ( ( ( message & 0x0f ) + 1 ) == in_midichannel->integer )
+				MIDI_NoteOff( ( dwParam1 & 0xff00 ) >> 8 );
+		}
+		break;
+	case MIM_LONGDATA:
+		break;
+	case MIM_ERROR:
+		break;
+	case MIM_LONGERROR:
+		break;
+	}
+
+//	Sys_QueEvent( sys_msg_time, SE_KEY, wMsg, qtrue, 0, NULL );
+}
+
+static void MidiInfo_f( void )
+{
+	int i;
+
+	const char *enableStrings[] = { "disabled", "enabled" };
+
+	Com_Printf( "\nMIDI control:       %s\n", enableStrings[in_midi->integer != 0] );
+	Com_Printf( "port:               %d\n", in_midiport->integer );
+	Com_Printf( "channel:            %d\n", in_midichannel->integer );
+	Com_Printf( "current device:     %d\n", in_mididevice->integer );
+	Com_Printf( "number of devices:  %d\n", s_midiInfo.numDevices );
+	for ( i = 0; i < s_midiInfo.numDevices; i++ )
+	{
+		if ( i == Cvar_VariableIntegerValue( "in_mididevice" ) )
+			Com_Printf( "***" );
+		else
+			Com_Printf( "..." );
+		Com_Printf(    "device %2d:       %s\n", i, s_midiInfo.caps[i].szPname );
+		Com_Printf( "...manufacturer ID: 0x%hx\n", s_midiInfo.caps[i].wMid );
+		Com_Printf( "...product ID:      0x%hx\n", s_midiInfo.caps[i].wPid );
+
+		Com_Printf( "\n" );
+	}
+}
+
+static void IN_StartupMIDI( void )
+{
+	int i;
+
+	if ( !Cvar_VariableIntegerValue( "in_midi" ) )
+		return;
+
+	//
+	// enumerate MIDI IN devices
+	//
+	s_midiInfo.numDevices = midiInGetNumDevs();
+
+	for ( i = 0; i < s_midiInfo.numDevices; i++ )
+	{
+		midiInGetDevCaps( i, &s_midiInfo.caps[i], sizeof( s_midiInfo.caps[i] ) );
+	}
+
+	//
+	// open the MIDI IN port
+	//
+	if ( midiInOpen( &s_midiInfo.hMidiIn, 
+		             in_mididevice->integer,
+					 ( unsigned long ) MidiInProc,
+					 ( unsigned long ) NULL,
+					 CALLBACK_FUNCTION ) != MMSYSERR_NOERROR )
+	{
+		Com_Printf( "WARNING: could not open MIDI device %d: '%s'\n", in_mididevice->integer , s_midiInfo.caps[( int ) in_mididevice->value] );
+		return;
+	}
+
+	midiInStart( s_midiInfo.hMidiIn );
+}
+
+static void IN_ShutdownMIDI( void )
+{
+	if ( s_midiInfo.hMidiIn )
+	{
+		midiInClose( s_midiInfo.hMidiIn );
+	}
+	memset( &s_midiInfo, 0, sizeof( s_midiInfo ) );
+}
diff --git a/code/win32/win_input.h b/code/win32/win_input.h
new file mode 100644
index 0000000..56d47cc
--- /dev/null
+++ b/code/win32/win_input.h
@@ -0,0 +1,101 @@
+#ifndef _WIN_INPUT_H_
+#define _WIN_INPUT_H_
+
+bool IN_ControllersChanged(int inserted[], int removed[]);
+
+#if defined (_XBOX ) || defined (_GAMECUBE)
+#define _USE_RUMBLE
+#endif
+
+bool	IN_AnyButtonPressed(void);
+
+void	IN_enableRumble( void );
+void	IN_disableRumble( void );
+bool	IN_usingRumble( void );
+
+int		IN_CreateRumbleScript(int controller, int numStates, bool deleteWhenFinished);
+void	IN_DeleteRumbleScript(int whichScript);
+void	IN_KillRumbleScript(int whichScript);
+void	IN_ExecuteRumbleScript(int whichScript);
+
+bool	IN_AdvanceToNextState(int whichScript);
+
+void	IN_KillRumbleScripts(int controller);
+void	IN_KillRumbleScripts( void );
+
+#define IN_CMD_GOTO_XTIMES	-5
+#define IN_CMD_GOTO			-6
+
+#define IN_CMD_DEC_ARG2		-7
+#define IN_CMD_INC_ARG2		-8
+#define IN_CMD_DEC_ARG1		-9
+#define IN_CMD_INC_ARG1		-10
+
+#ifdef _XBOX
+	#define IN_CMD_DEC_LEFT		-70
+	#define IN_CMD_DEC_RIGHT	-71
+	#define IN_CMD_INC_LEFT		-72
+	#define IN_CMD_INC_RIGHT	-73
+#endif
+
+
+#if defined (_XBOX)			// ----- XBOX --------
+
+int IN_AddRumbleState(int whichScript, int leftSpeed, int rightSpeed, int timeInMs);
+int IN_AddEffectFade4(int whichScript, int startLeft, int startRight, int endLeft, int endRight, int timeInMs);
+int IN_AddEffectFadeExp6(int whichScript, int startLeft, int startRight, int endLeft, int endRight, char factor, int timeInMs);
+
+#elif defined (_GAMECUBE)	// ---- GAME CUBE ----
+
+#define IN_GCACTION_START		1
+#define IN_GCACTION_STOP		2
+#define IN_GCACTION_STOPHARD	3
+int IN_AddRumbleState(int whichScript, int action, int timeInMs, int arg = 0);
+
+#endif						// ------END IF-------
+
+int		IN_AddRumbleStateSpecial(int whichScript, int action, int arg1, int arg2);
+void	IN_KillRumbleState(int whichScript, int index);
+
+void	IN_PauseRumbling(int controller);
+void	IN_PauseRumbling( void );
+
+void	IN_UnPauseRumbling(int controller);
+void	IN_UnPauseRumbling( void );
+
+void	IN_TogglePauseRumbling(int controller);
+void	IN_TogglePauseRumbling( void );
+int		IN_GetMainController();
+void	IN_SetMainController(int id);
+
+void	IN_PadUnplugged(int controller);
+void	IN_PadPlugged(int controller);
+
+void	IN_CommonJoyPress(int controller, fakeAscii_t button, bool pressed);
+void	IN_CommonUpdate(void);
+
+#define IN_MAX_JOYSTICKS 2
+// Stores gamepad joystick info
+struct JoystickInfo
+{
+	bool valid;
+	float x, y;
+};
+
+// Stores gamepad id and joysick info
+struct PadInfo
+{
+	JoystickInfo joyInfo[2];
+	int padId;
+};
+
+// Buffer for gamepad info
+extern PadInfo _padInfo;
+
+bool IN_RumbleAdjust(int controller, int left, int right);
+void IN_RumbleInit (void);
+void IN_RumbleShutdown (void);
+void IN_RumbleFrame (void);
+
+
+#endif // END _WIN_INPUT_H_
diff --git a/code/win32/win_input_console.cpp b/code/win32/win_input_console.cpp
new file mode 100644
index 0000000..a5507f2
--- /dev/null
+++ b/code/win32/win_input_console.cpp
@@ -0,0 +1,523 @@
+// #include "../server/exe_headers.h"
+
+#include "../client/client.h"
+#include "../qcommon/qcommon.h"
+#ifdef _JK2MP
+#include "../ui/keycodes.h"
+#else
+#include "../client/keycodes.h"
+#endif
+
+#include "win_local.h"
+#include "win_input.h"
+
+
+static void HandleDebugJoystickPress(fakeAscii_t button);
+
+static bool _UIRunning = false;
+
+static bool IN_ControllerMustBePlugged(int controller);
+
+// Comment out next line to turn off debug controller. This should be
+// forced off in FINAL_BUILD, but for now, I want to send builds to
+// Activision made with FINAL_BUILD but that support the cheatpad.
+#define DEBUG_CONTROLLER
+
+// Controller connection globals
+static signed char uiControllerNotification = -1;
+bool noControllersConnected = false;
+bool wasPlugged[4];
+
+PadInfo _padInfo; // gamepad thumbstick buffer
+
+
+
+//If the Xbox white or black button was held for less than this amount of
+//time while a selection bar was up, the user wants to use the button rather
+//than reassign it.
+#define MAX_WB_HOLD_TIME 500
+
+static fakeAscii_t UIJoy2Key(fakeAscii_t button)
+{
+	switch(button) {
+	case A_JOY7:
+		return A_CURSOR_DOWN;
+	case A_JOY5:
+		return A_CURSOR_UP;
+	case A_JOY6:
+		return A_CURSOR_RIGHT;
+	case A_JOY8:
+		return A_CURSOR_LEFT;
+	case A_JOY15:
+		return A_MOUSE1;
+#ifdef _GAMECUBE
+	case A_JOY16:
+		return A_ESCAPE;
+	case A_JOY14:
+		return A_DELETE;
+#else
+	case A_JOY14:
+		return A_ESCAPE;
+	case A_JOY16:
+		return A_DELETE;
+#endif
+
+	//left and right trigger for scrolling
+	case A_JOY11:
+		return A_PAGE_UP;
+	case A_JOY12:
+		return A_PAGE_DOWN;
+
+	// start and back button on xbox
+	case A_JOY1:
+		//JLF
+		return A_ESCAPE;
+	case A_JOY2:
+	case A_JOY4:
+		//JLF
+		return A_MOUSE1;
+		//return button;
+
+	case A_JOY3:
+		return A_MOUSE1;
+	}
+
+	return A_SPACE; //Invalid button.
+}
+
+struct
+{
+	int button;
+	bool pressed;
+}	uiKeyQueue[2][5] = {0};
+int	uiQueueLen[2] = {0};
+int uiLastKeyUpDown[2] = {0};
+int uiLastKeyLeftRight[2] = {0};
+
+void IN_UIEmptyQueue()
+{
+	/// If the ui is not running then this doesn't have any effect
+	if (!_UIRunning)
+	{
+		uiQueueLen[0] = uiQueueLen[1] = 0;
+		return;
+	}
+
+// BTO - No CM, bypass that logic.
+//	for (int i = 0; i < ClientManager::NumClients(); i++)
+	for (int i = 0; i < 1; ++i)
+	{
+//		ClientManager::ActivateClient(i);
+		int found = 0;
+		int bCancel = 0;
+		for (int j = 0; j < uiQueueLen[i]; j++)
+		{
+			switch (uiKeyQueue[i][j].button)
+			{
+			case A_CURSOR_DOWN:
+			case A_CURSOR_UP:
+				if ( found & 2 )	// Was a left/right key pressed already?
+					bCancel = 1;
+				found |= 1;
+				break;
+			case A_CURSOR_RIGHT:
+			case A_CURSOR_LEFT:
+				if ( found & 1 )	// Was an up/down key already pressed?
+					bCancel = 1;
+				found |= 2;
+				break;
+			}
+		}
+
+		if (!bCancel)				// was it cancelled?
+		{
+			for (int j = 0; j < uiQueueLen[i]; j++)
+			{
+				int time = Sys_Milliseconds();
+				switch (uiKeyQueue[i][j].button)
+				{
+				case A_CURSOR_DOWN:
+				case A_CURSOR_UP:
+					if (uiLastKeyLeftRight[i])
+					{
+						if (uiLastKeyLeftRight[i] > time)		// don't allow up/down till left/right has enough leway time
+						{
+							continue;
+						}
+					}
+					uiLastKeyUpDown[i] = time + 150;			/// 250 ms sound right?
+					break;
+				case A_CURSOR_LEFT:
+				case A_CURSOR_RIGHT:
+					if (uiLastKeyUpDown[i])
+					{
+						if (uiLastKeyUpDown[i] > time)		// don't allow up/down till left/right has enough leway time
+						{
+							continue;
+						}
+					}
+					uiLastKeyLeftRight[i] = time + 150;			/// 250 ms sound right?
+					break;
+				}
+				Sys_QueEvent(0, SE_KEY, uiKeyQueue[i][j].button, uiKeyQueue[i][j].pressed, 0, NULL);
+			}
+		}
+	}
+
+	// Reset the queue
+	uiQueueLen[0] = uiQueueLen[1] = 0;
+}
+
+// extern void G_DemoKeypress();
+// extern void CG_SkipCredits(void);
+void IN_CommonJoyPress(int controller, fakeAscii_t button, bool pressed)
+{
+	// Check for special cases for map hack
+	// This should be #ifdef'd out in FINAL_BUILD, but I really don't care.
+	// If someone wants to copy the retail version to their modded xbox and
+	// edit the config file to turn on maphack, let them.
+	if (Cvar_VariableIntegerValue("cl_maphack"))
+	{
+		if (_UIRunning && button == A_JOY11 && pressed)
+		{
+			// Left trigger -> F1
+			Sys_QueEvent( 0, SE_KEY, A_F1, pressed, 0, NULL );
+			return;
+		}
+		else if (_UIRunning && button == A_JOY12 && pressed)
+		{
+			// Right trigger -> F2
+			Sys_QueEvent( 0, SE_KEY, A_F2, pressed, 0, NULL );
+			return;
+		}
+		else if (_UIRunning && button == A_JOY4 && pressed)
+		{
+			// Start button -> F3
+			IN_SetMainController(controller);
+			Sys_QueEvent( 0, SE_KEY, A_F3, pressed, 0, NULL );
+			return;
+		}
+	}
+
+
+	if(IN_GetMainController() == controller || _UIRunning)
+	{
+		// Always map start button to ESCAPE
+		if (!_UIRunning && button == A_JOY4 && cls.state != CA_CINEMATIC)
+			Sys_QueEvent( 0, SE_KEY, A_ESCAPE, pressed, 0, NULL );
+
+#ifdef DEBUG_CONTROLLER
+		if (controller != 3)
+#endif
+			Sys_QueEvent( 0, SE_KEY, _UIRunning ? UIJoy2Key(button) : button, pressed, 0, NULL );
+	}
+
+#ifdef DEBUG_CONTROLLER
+	if (controller == 3 && pressed)
+	{
+		HandleDebugJoystickPress(button);
+		return;
+	}
+#endif
+}
+
+qboolean g_noCheckAxis = qfalse;
+
+/**********
+IN_CommonUpdate
+Updates thumbstick events based on _padInfo and ui_thumbStickMode
+**********/
+void IN_CommonUpdate()
+{
+	extern int Key_GetCatcher( void );
+	_UIRunning = Key_GetCatcher() == KEYCATCH_UI;
+
+	// if the UI is running, then let all gamepad sticks work, else only main controller
+	if(_UIRunning)
+		Sys_QueEvent( 0, SE_MOUSE, _padInfo.joyInfo[1].x *  4.0f, _padInfo.joyInfo[1].y *  -4.0f, 0, NULL );
+	else if(_padInfo.padId == IN_GetMainController())
+	{
+		// Find out how to configure the thumbsticks
+		//int thumbStickMode = Cvar_Get("ui_thumbStickMode", "0" , 0)->integer;
+		int thumbStickMode = cl_thumbStickMode->integer;
+
+		switch(thumbStickMode)
+		{
+		case 0:
+			// Configure left thumbstick to move forward/back & strafe left/right
+			Sys_QueEvent( 0, SE_JOYSTICK_AXIS, AXIS_SIDE,	 _padInfo.joyInfo[0].x * 127.0f, 0, NULL );
+			Sys_QueEvent( 0, SE_JOYSTICK_AXIS, AXIS_FORWARD, _padInfo.joyInfo[0].y * 127.0f, 0, NULL );
+
+			// Configure right thumbstick for freelook
+			Sys_QueEvent( 0, SE_MOUSE, _padInfo.joyInfo[1].x * 48.0f,  _padInfo.joyInfo[1].y * 48.0f, 0, NULL );
+			break;
+		case 1:
+			// Configure left thumbstick for freelook
+			Sys_QueEvent( 0, SE_MOUSE, _padInfo.joyInfo[0].x * 48.0f,  _padInfo.joyInfo[0].y * 48.0f, 0, NULL );
+
+			// Configure right thumbstick to move forward/back & strafe left/right
+			Sys_QueEvent( 0, SE_JOYSTICK_AXIS, AXIS_SIDE,	 _padInfo.joyInfo[1].x * 127.0f, 0, NULL );
+			Sys_QueEvent( 0, SE_JOYSTICK_AXIS, AXIS_FORWARD, _padInfo.joyInfo[1].y * 127.0f, 0, NULL );
+			break;
+		case 2:
+			// Configure left thumbstick to move forward/back & turn left/right
+			Sys_QueEvent( 0, SE_JOYSTICK_AXIS, AXIS_FORWARD, _padInfo.joyInfo[0].y * 127.0f, 0, NULL );
+			Sys_QueEvent( 0, SE_MOUSE, _padInfo.joyInfo[0].x * 48.0f, 0.0f, 0, NULL );
+
+			// Configure right thumbstick to look up/down & strafe left/right
+			Sys_QueEvent( 0, SE_JOYSTICK_AXIS, AXIS_SIDE, _padInfo.joyInfo[1].x * 127.f, 0, NULL );
+			Sys_QueEvent( 0, SE_MOUSE, 0.0f,  _padInfo.joyInfo[1].y * 48.0f, 0, NULL );		
+			break;
+		case 3:
+			// Configure left thumbstick to look up/down & strafe left/right
+			Sys_QueEvent( 0, SE_JOYSTICK_AXIS, AXIS_SIDE, _padInfo.joyInfo[0].x * 127.f, 0, NULL );
+			Sys_QueEvent( 0, SE_MOUSE, 0.0f,  _padInfo.joyInfo[0].y * 48.0f, 0, NULL );
+			
+			// Configure right thumbstick to move forward/back & turn left/right
+			Sys_QueEvent( 0, SE_JOYSTICK_AXIS, AXIS_FORWARD, _padInfo.joyInfo[1].y * 127.0f, 0, NULL );
+			Sys_QueEvent( 0, SE_MOUSE, _padInfo.joyInfo[1].x * 48.0f, 0.0f, 0, NULL );		
+			break;
+		default:
+			break;
+		}
+	}
+}
+
+/*********
+IN_DisplayControllerUnplugged
+*********/
+static void IN_DisplayControllerUnplugged(int controller)
+{
+	uiControllerNotification = controller;
+
+	//TODO Add a call to the UI that draws a controller disconnected message
+	// on the screen.
+//	VM_Call( uivm, UI_CONTROLLER_UNPLUGGED, true, controller);
+}
+
+/*********
+IN_ClearControllerUnplugged
+*********/
+static void IN_ClearControllerUnplugged(void)
+{
+	uiControllerNotification = -1;
+
+	//TODO Add a call to the UI that removes the controller disconnected
+	// message from the screen.
+//	VM_Call( uivm, UI_CONTROLLER_UNPLUGGED, false, 0);
+}
+
+/*********
+IN_ControllerMustBePlugged
+*********/
+static bool IN_ControllerMustBePlugged(int controller)
+{
+	if( cls.state == CA_LOADING		||
+		cls.state == CA_CONNECTING	||
+		cls.state == CA_CONNECTED	||
+		cls.state == CA_CHALLENGING	||
+		cls.state == CA_PRIMED		||
+		cls.state == CA_CINEMATIC)
+	{
+		return false;
+	}
+
+	if(!_UIRunning && controller == IN_GetMainController())
+	{
+		return true;
+	}
+
+	if(noControllersConnected)
+	{
+		return true;
+	}
+
+	return false;
+}
+
+/*********
+IN_PadUnplugged
+*********/
+void IN_PadUnplugged(int controller)
+{
+	if(wasPlugged[controller])
+	{
+		Com_Printf("\tController %d unplugged\n",controller); 
+	}
+
+	if(IN_ControllerMustBePlugged(controller))
+	{
+		//If UI isn't busy, inform it about controller loss.
+		if(uiControllerNotification == -1)
+		{
+			IN_DisplayControllerUnplugged(controller);
+		}
+	}
+	wasPlugged[controller] = false;
+}
+
+/*********
+IN_PadPlugged
+*********/
+void IN_PadPlugged(int controller)
+{
+	if(!wasPlugged[controller])
+	{
+		Com_Printf("\tController %d plugged\n",controller); 
+	}
+
+	if(IN_ControllerMustBePlugged(controller))
+	{
+		//If UI is dealing with this controller, tell it to stop.
+		if(uiControllerNotification == controller)
+		{
+			IN_ClearControllerUnplugged();
+		}
+	}
+	wasPlugged[controller] = true;
+	noControllersConnected = false;
+}
+
+/*********
+IN_GetMainController
+*********/
+int IN_GetMainController(void)
+{
+	return cls.mainGamepad;
+}
+
+/*********
+IN_SetMainController
+*********/
+void IN_SetMainController(int id)
+{
+	cls.mainGamepad = id;
+}
+
+/*********
+IN_SetThumbStickConfig
+Sets the thumbstick configuration value
+*********/
+void IN_SetThumbStickConfig(int configValue)
+{
+	Cvar_Set("ui_thumbStickMode", va("%i", configValue));
+}
+
+/*********
+IN_SetButtonConfig
+Execs a button configuration script based on configValue
+*********/
+void IN_SetButtonConfig(int configValue)
+{
+	// Set the cvar
+	Cvar_Set("ui_buttonMode", va("%i", configValue));
+
+	// Exec the script
+	char				execString[40];
+	sprintf				(execString, "exec cfg\\buttonConfig%i.cfg\n", configValue);
+	Cbuf_ExecuteText	(EXEC_NOW, execString);
+}
+
+/*********
+IN_SetDpadConfig
+Execs a dpad configuration script based on configValue
+*********/
+void IN_SetDpadConfig(int configValue)
+{
+	// Set the cvar
+	Cvar_Set("ui_dpadMode", va("%i", configValue));
+
+	// Exec the script
+	char				execString[40];
+	sprintf				(execString, "exec cfg\\dpadConfig%i.cfg\n", configValue);
+	Cbuf_ExecuteText	(EXEC_NOW, execString);
+}
+
+/**********************************************************
+*
+* DEBUGGING CODE
+*
+**********************************************************/
+
+#ifdef DEBUG_CONTROLLER
+static void HandleDebugJoystickPress(fakeAscii_t button)
+{
+	// Super hackalicious crap used below. Please remove this at some point.
+	static int curSaberSet = 0;
+	static int curPlayerSet = 0;
+	static short dpadmode = 0;
+	static short buttonmode = 0;
+	static short thumbmode = 0;
+
+	switch(button) {
+	case A_JOY13: // Right pad up
+		Cbuf_ExecuteText(EXEC_APPEND, "give all\n");
+		break;
+	case A_JOY16: // Right pad left
+		Cbuf_ExecuteText(EXEC_APPEND, "viewpos\n");
+		break;
+	case A_JOY14: // Right pad right
+		Cbuf_ExecuteText(EXEC_APPEND, "noclip\n");
+		break;
+	case A_JOY15: // Right pad down
+		Cbuf_ExecuteText(EXEC_APPEND, "god\n");
+		break;
+	case A_JOY4: // Start
+		Cvar_SetValue("m_pitch", -Cvar_VariableValue("m_pitch"));
+		break;
+	case A_JOY1: // back
+		Cvar_SetValue("cl_autolevel", !Cvar_VariableIntegerValue("cl_autolevel"));
+		break;
+	case A_JOY2: // Left thumbstick
+		extern void Z_CompactStats(void);
+		Z_CompactStats();
+		break;
+	case A_JOY12: // Upper right trigger
+		Cbuf_ExecuteText(EXEC_APPEND, "load dbg-game\n");
+		break;
+	case A_JOY8: // Left pad left
+		thumbmode++;
+		if(thumbmode == 4)
+		{
+			thumbmode = 0;
+		}
+		IN_SetThumbStickConfig(thumbmode);
+		break;
+	case A_JOY6: // Left pad right
+		dpadmode++;
+		if(dpadmode == 4)
+		{
+			dpadmode = 0;
+		}
+		IN_SetDpadConfig(0);
+		break;
+	case A_JOY5: // Left pad up
+		buttonmode++;
+		if(buttonmode == 4)
+		{
+			buttonmode = 0;
+		}
+		IN_SetButtonConfig(buttonmode);
+		break;
+	case A_JOY7: // Left pad down
+//		Cbuf_ExecuteText(EXEC_APPEND, "vid_restart\n");
+		extern void Sys_Reboot(const char *reason);
+		Sys_Reboot("multiplayer");
+		break;
+	case A_JOY11: // Upper left trigger
+		Cbuf_ExecuteText(EXEC_APPEND, "save dbg-game\n");
+		break; 
+	case A_JOY9: // White button
+		// Hacky. Really hacky. No, hackier than that.
+		curSaberSet = (curSaberSet + 1) % 3;	// Number of xsaber strings in config file
+		Cbuf_ExecuteText(EXEC_APPEND, va("vstr xsaber%d\n", curSaberSet));
+		break;
+	case A_JOY10: // Black button
+		curPlayerSet = (curPlayerSet + 1) % 6;	// Number of xplayer strings in config file
+		Cbuf_ExecuteText(EXEC_APPEND, va("vstr xplayer%d\n", curPlayerSet));
+		break;
+	}
+}
+
+#endif
+
diff --git a/code/win32/win_input_rumble.cpp b/code/win32/win_input_rumble.cpp
new file mode 100644
index 0000000..3cd6e30
--- /dev/null
+++ b/code/win32/win_input_rumble.cpp
@@ -0,0 +1,707 @@
+
+/*
+ * UNPUBLISHED -- Rights  reserved  under  the  copyright  laws  of the 
+ * United States.  Use  of a copyright notice is precautionary only and 
+ * does not imply publication or disclosure.                            
+ *                                                                      
+ * THIS DOCUMENTATION CONTAINS CONFIDENTIAL AND PROPRIETARY INFORMATION 
+ * OF    VICARIOUS   VISIONS,  INC.    ANY  DUPLICATION,  MODIFICATION, 
+ * DISTRIBUTION, OR DISCLOSURE IS STRICTLY PROHIBITED WITHOUT THE PRIOR 
+ * EXPRESS WRITTEN PERMISSION OF VICARIOUS VISIONS, INC.
+ */
+#include "../cgame/cg_local.h"
+#include "../server/exe_headers.h"
+
+#include "win_local.h"
+#include "win_input.h"
+
+
+//MB #include "../client/cl_data.h"
+#include "../game/q_shared.h"
+
+extern qboolean G_ActivePlayerNormal(void);
+
+struct rumblestate_t
+{
+	int timeToStop;
+	
+	// Right motor speed on Xbox, action type on Gamecube
+	int arg1;
+
+	// Left motor speed on Xbox, secondary action type on Gamecube
+	int arg2;
+};
+
+struct rumblestate_special_t
+{
+	int code;
+	int arg1;
+	int arg2;
+};
+
+struct rumblescript_t
+{
+	int nextStateAt;
+	
+	int controller;
+	
+	int currentState;
+	int usedStates;
+	int numStates;
+
+	bool autoDelete;
+	rumblestate_t *states;
+};
+
+struct rumblestatus_t
+{
+	bool changed;
+	bool killed;
+	bool paused;
+	int timePaused;
+};
+
+#define MAX_RUMBLE_STATES		10
+#define MAX_RUMBLE_SCRIPTS		10
+#define MAX_RUMBLE_CONTROLLERS	4
+
+// In rumblestate, highest speed for each side takes precidence
+// Number of rumble states is fairly small, so a plain array will work fine
+static rumblestatus_t rumbleStatus[MAX_RUMBLE_CONTROLLERS];
+static rumblescript_t rumbleScripts[MAX_RUMBLE_SCRIPTS];
+
+cvar_t* in_useRumble = NULL;
+
+/***** FIXME Some functions that would be found in a client manager *****/
+/***** BEGIN FILLER *****/
+
+// Always return 0 because we have only one client (right now anyway)
+int ActiveClientNum(void)
+{
+	return 0;
+}
+
+// The active controller will always be number 0 for now
+int ActiveController(void)
+{
+	return 0;
+}
+/***** END FILLER *****/
+
+void IN_enableRumble( void ) 
+{
+	if (ActiveClientNum() == 0)
+	{
+		Cvar_Set( "in_useRumble",   "1"); 
+	}
+	else
+	{
+		Cvar_Set( "in_useRumble2",   "1"); 
+	}
+}
+
+void IN_disableRumble( void ) 
+{
+	if (ActiveClientNum() == 0)
+	{
+		Cvar_Set( "in_useRumble",   "0"); 
+	}
+	else
+	{
+		Cvar_Set( "in_useRumble2",   "0"); 
+	}
+}									
+	 
+bool IN_usingRumble( void )
+{
+	if (ActiveClientNum() == 0)
+	{
+		//return Cvar_VariableIntegerValue( "in_useRumble"); 
+		return in_useRumble->integer;
+	}
+	else
+	{
+		//return Cvar_VariableIntegerValue( "in_useRumble2"); 
+		return in_useRumble->integer;
+	}
+
+	return true;
+}
+
+
+// Creates a rumble script with numStates
+// Returns -1 on no more room, otherwise an identifier to use for scripts
+int IN_CreateRumbleScript(int controller, int numStates, bool deleteWhenFinished)
+{
+	if (!IN_usingRumble()) return -1;
+
+	if (controller <= -1 || controller >= MAX_RUMBLE_CONTROLLERS) return -1;
+	assert (numStates > 0 && numStates < MAX_RUMBLE_STATES);
+	
+	int i;
+	for (i = 0; i < MAX_RUMBLE_SCRIPTS; i++)
+	{
+		if (rumbleScripts[i].states == 0)
+			break;
+	}
+
+	if (i == MAX_RUMBLE_SCRIPTS) 
+		return -1;		// Ran out of scripts
+	
+	rumbleScripts[i].autoDelete = deleteWhenFinished;
+	rumbleScripts[i].controller = controller;
+	rumbleScripts[i].currentState = 0;
+	rumbleScripts[i].nextStateAt = 0;
+	rumbleScripts[i].numStates = numStates;
+	rumbleScripts[i].usedStates = 0;
+	rumbleScripts[i].states = new rumblestate_t[numStates];
+	memset(rumbleScripts[i].states, 0, sizeof(rumblestate_t) * numStates);
+	return i;
+}
+
+// A negative time will last until you kill it explicitly
+// Returns index, used to kill or change a state in a script
+int IN_AddRumbleStateFull(int whichScript, int arg1, int arg2, int timeInMs)
+{
+	if (!IN_usingRumble()) return -1;
+
+	assert(whichScript >= 0 && whichScript < MAX_RUMBLE_SCRIPTS);
+	assert(rumbleScripts[whichScript].usedStates < rumbleScripts[whichScript].numStates);
+	
+	// Get the current state
+	rumblescript_t *curScript = &rumbleScripts[whichScript];
+	rumblestate_t *curState = &curScript->states[curScript->usedStates];
+
+	curState->arg1 = arg1;
+	curState->arg2 = arg2;
+
+	curState->timeToStop = timeInMs;
+	return curScript->usedStates++;
+}
+
+int IN_AddRumbleState(int whichScript, int leftSpeed, int rightSpeed, int timeInMs)
+{
+	return IN_AddRumbleStateFull(whichScript, leftSpeed, rightSpeed, timeInMs);
+}
+
+int IN_AddRumbleStateSpecial(int whichScript, int action, int arg1, int arg2)
+{
+	if (!IN_usingRumble()) return -1;
+	
+	assert(whichScript >= 0 && whichScript < MAX_RUMBLE_SCRIPTS);
+	assert(rumbleScripts[whichScript].usedStates < rumbleScripts[whichScript].numStates);
+	
+	// Get the current state
+	rumblescript_t *curScript = &rumbleScripts[whichScript];
+	rumblestate_special_t *curState = (rumblestate_special_t*)&curScript->states[curScript->usedStates];
+
+	curState->code = action;
+	curState->arg1 = arg1;
+	curState->arg2 = arg2;
+	return curScript->usedStates++;
+}
+
+int IN_AddEffectFade4(int whichScript, int startLeft, int startRight, 
+					  int endLeft, int endRight, int timeInMs)
+{
+	const int fadeSmoothness = 50;		// number of ms between updates, smaller is smoother
+
+	int e = IN_AddRumbleState(whichScript, startLeft, startRight, fadeSmoothness);	// Lasts for fadeSmoothness ms
+
+	if (startLeft < endLeft)		// Fade increases
+	{
+		IN_AddRumbleStateSpecial(whichScript, IN_CMD_INC_LEFT, e, 
+			(endLeft - startLeft) * fadeSmoothness / timeInMs);	
+	}
+	else
+	{
+		IN_AddRumbleStateSpecial(whichScript, IN_CMD_DEC_LEFT, e, 
+			(startLeft - endLeft) * fadeSmoothness / timeInMs);	
+	}
+
+	if (startRight < endRight)
+	{
+		IN_AddRumbleStateSpecial(whichScript, IN_CMD_INC_RIGHT, e, 
+			(endRight - startRight) * fadeSmoothness / timeInMs);
+	}
+	else
+	{
+		IN_AddRumbleStateSpecial(whichScript, IN_CMD_DEC_RIGHT, e, 
+			(startRight - endRight) * fadeSmoothness / timeInMs);
+	}
+
+	return IN_AddRumbleStateSpecial(whichScript, IN_CMD_GOTO_XTIMES, 
+		e, timeInMs / fadeSmoothness);
+}
+
+int IN_AddEffectFadeExp6(int whichScript, int startLeft, int startRight, 
+						 int endLeft, int endRight, char factor, int timeInMs)
+{
+	const int fadeSmoothness = 10;		// number of ms between updates, smaller is smoother
+
+	int state = IN_AddRumbleState(whichScript, startLeft, startRight, fadeSmoothness);	// Lasts for fadeSmoothness ms
+
+	if (startLeft < endLeft)		// Fade increases
+	{
+		IN_AddRumbleStateSpecial(whichScript, IN_CMD_INC_LEFT, state, 
+			(endLeft - startLeft) * fadeSmoothness / timeInMs - 
+			(factor / 2) * ( 1 - timeInMs / fadeSmoothness)
+			);	
+	}
+	else
+	{
+		IN_AddRumbleStateSpecial(whichScript, IN_CMD_DEC_LEFT, state, 
+			(startLeft - endLeft) * fadeSmoothness / timeInMs - 
+			(factor / 2) * ( 1 - timeInMs / fadeSmoothness)
+			);	
+	}
+
+	if (startRight < endRight)
+	{
+		IN_AddRumbleStateSpecial(whichScript, IN_CMD_INC_RIGHT, state, 
+			(endRight - startRight) * fadeSmoothness / timeInMs - 
+			(factor / 2) * ( 1 - timeInMs / fadeSmoothness)
+			);	
+	}
+	else
+	{
+		IN_AddRumbleStateSpecial(whichScript, IN_CMD_DEC_RIGHT, state,
+			(startRight - endRight) * fadeSmoothness / timeInMs - 
+			(factor / 2) * ( 1 - timeInMs / fadeSmoothness)
+			);	
+	}
+
+	IN_AddRumbleStateSpecial(whichScript, IN_CMD_INC_ARG2, state + 1, factor);
+	IN_AddRumbleStateSpecial(whichScript, IN_CMD_INC_ARG2, state + 2, factor);
+	return IN_AddRumbleStateSpecial(whichScript, IN_CMD_GOTO_XTIMES, 
+		state, timeInMs / fadeSmoothness);
+}
+
+// Kills a rumble state based on index
+void IN_KillRumbleState(int whichScript, int index)
+{
+	if (!IN_usingRumble()) return;
+
+	assert( whichScript >= 0 && whichScript < MAX_RUMBLE_SCRIPTS);
+	assert( index < rumbleScripts[whichScript].numStates );
+
+	rumbleScripts[whichScript].states[index].timeToStop = 0;
+	rumbleStatus[rumbleScripts[whichScript].controller].changed = true;
+}
+
+// Stops the script, if script has autodelete on then it will get deleted, otherwise it will only stop
+void IN_KillRumbleScript(int whichScript)
+{
+	if (!IN_usingRumble()) return;
+
+	assert (whichScript >= 0 && whichScript < MAX_RUMBLE_SCRIPTS);
+
+	rumbleScripts[whichScript].nextStateAt = 0;
+	if (rumbleScripts[whichScript].autoDelete)
+	{
+		if (rumbleScripts[whichScript].states)
+			delete [] rumbleScripts[whichScript].states;
+		rumbleScripts[whichScript].states = 0;
+	}
+
+	rumbleStatus[rumbleScripts[whichScript].controller].changed = true;
+}
+
+// Stops Rumbling for specific controller
+void IN_KillRumbleScripts(int controller)
+{
+	if (!IN_usingRumble()) return;
+	if (controller <= -1 || controller >= MAX_RUMBLE_CONTROLLERS) return;
+	if (rumbleStatus[controller].killed == true) return;
+
+	for (int i = 0; i < MAX_RUMBLE_SCRIPTS; i++)
+	{
+		if (rumbleScripts[i].controller == controller)
+			IN_KillRumbleScript(i);
+	}
+
+	rumbleStatus[controller].killed = IN_RumbleAdjust(controller, 0, 0);
+}
+
+// Stops Rumbling on all controllers
+void IN_KillRumbleScripts( void )
+{
+	if (!IN_usingRumble()) return;
+
+	for (int i = 0; i < MAX_RUMBLE_SCRIPTS; i++)
+		IN_KillRumbleScript(i);
+
+	for (int j = 0; j < MAX_RUMBLE_CONTROLLERS; j++)
+	{
+		if (!rumbleStatus[j].killed)
+		{
+			rumbleStatus[j].killed = IN_RumbleAdjust(j, 0, 0);
+		}
+	}
+}
+
+void IN_DeleteRumbleScript(int whichScript)
+{
+	if (!IN_usingRumble()) return;
+
+	assert (whichScript >= 0 && whichScript < MAX_RUMBLE_SCRIPTS);
+
+	if (rumbleScripts[whichScript].states)
+		delete [] rumbleScripts[whichScript].states;
+	rumbleScripts[whichScript].nextStateAt = 0;
+	rumbleScripts[whichScript].states = 0;
+
+	rumbleStatus[rumbleScripts[whichScript].controller].changed = true;
+}
+
+int IN_RunSpecialScript(int whichScript)
+{
+	rumblestate_special_t *sp = (rumblestate_special_t*)&rumbleScripts[whichScript].states[rumbleScripts[whichScript].currentState];
+	switch (sp->code)
+	{
+		// updates the current state pointer
+		// uses arg1
+	case IN_CMD_GOTO:
+		rumbleScripts[whichScript].currentState = sp->arg1;
+		return rumbleScripts[whichScript].states[sp->arg1].timeToStop;
+		break;	
+		// does a goto, and decreases count of arg2, until 0
+	case IN_CMD_GOTO_XTIMES:
+		if (--sp->arg2 >= 0)
+		{
+			rumbleScripts[whichScript].currentState = sp->arg1;
+			return rumbleScripts[whichScript].states[sp->arg1].timeToStop;
+		}
+		else		// Go onto next cmd
+		{
+			if (!IN_AdvanceToNextState(whichScript))
+				return -2;	// Done
+			return -1;
+		}
+		break;
+
+		// Decreasae Arg2 of a State,		sp->arg1 = state, sp->arg2 = amount to decrease arg2 of state by
+	case IN_CMD_DEC_ARG2:
+		{
+			rumblestate_special_t *temp = (rumblestate_special_t*)&rumbleScripts[whichScript].states[sp->arg1];
+			temp->arg2 -= sp->arg2;
+		}
+		break;
+
+		// Increase Arg2 of a State,		sp->arg1 = state, sp->arg2 = amount to increase arg2 of state by
+	case IN_CMD_INC_ARG2:
+		{
+			rumblestate_special_t *temp = (rumblestate_special_t*)&rumbleScripts[whichScript].states[sp->arg1];
+			temp->arg2 += sp->arg2;
+		}
+		break;
+
+		// Decreasae Arg1 of a State,		sp->arg1 = state, sp->arg2 = amount to decrease arg1 of state by
+	case IN_CMD_DEC_ARG1:
+		{
+			rumblestate_special_t *temp = (rumblestate_special_t*)&rumbleScripts[whichScript].states[sp->arg1];
+			temp->arg1 -= sp->arg2;
+		}
+		break;
+
+		// Increase Arg2 of a State,		sp->arg1 = state, sp->arg2 = amount to increase arg1 of state by
+	case IN_CMD_INC_ARG1:
+		{
+			rumblestate_special_t *temp = (rumblestate_special_t*)&rumbleScripts[whichScript].states[sp->arg1];
+			temp->arg1 += sp->arg2;
+		}
+		break;
+
+	case IN_CMD_DEC_LEFT:
+		rumbleScripts[whichScript].states[sp->arg1].arg2 -=  sp->arg2;
+		if (rumbleScripts[whichScript].states[sp->arg1].arg2 < 0)
+			rumbleScripts[whichScript].states[sp->arg1].arg2 = 0;
+		if (rumbleScripts[whichScript].currentState >= rumbleScripts[whichScript].usedStates - 1)
+			return -2;	// Done
+		return rumbleScripts[whichScript].states[++rumbleScripts[whichScript].currentState].timeToStop;
+		break;
+
+	case IN_CMD_DEC_RIGHT:
+		rumbleScripts[whichScript].states[sp->arg1].arg1 -=  sp->arg2;
+		if (rumbleScripts[whichScript].states[sp->arg1].arg1 < 0)
+			rumbleScripts[whichScript].states[sp->arg1].arg1 = 0;
+		if (rumbleScripts[whichScript].currentState >= rumbleScripts[whichScript].usedStates - 1)
+			return -2;	// Done
+		return rumbleScripts[whichScript].states[++rumbleScripts[whichScript].currentState].timeToStop;
+		break;
+
+	case IN_CMD_INC_LEFT:
+		rumbleScripts[whichScript].states[sp->arg1].arg2 +=  sp->arg2;
+		if (rumbleScripts[whichScript].states[sp->arg1].arg2 > 65534)
+			rumbleScripts[whichScript].states[sp->arg1].arg2 = 65534;
+		if (rumbleScripts[whichScript].currentState >= rumbleScripts[whichScript].usedStates - 1)
+			return -2;	// Done
+		return rumbleScripts[whichScript].states[++rumbleScripts[whichScript].currentState].timeToStop;
+		break;
+
+	case IN_CMD_INC_RIGHT:
+		rumbleScripts[whichScript].states[sp->arg1].arg1 += sp->arg2;
+		if (rumbleScripts[whichScript].states[sp->arg1].arg1 > 65534)
+			rumbleScripts[whichScript].states[sp->arg1].arg1 = 65534;
+		if (rumbleScripts[whichScript].currentState >= rumbleScripts[whichScript].usedStates - 1)
+			return -2;	// Done
+		return rumbleScripts[whichScript].states[++rumbleScripts[whichScript].currentState].timeToStop;
+		break;
+	}
+	return 0;
+}
+
+int IN_Time()
+{
+	//mb return ClientManager::ActiveClient().cg.time;
+	return cg.time;
+}
+
+void IN_ExecuteRumbleScript(int whichScript)
+{
+	if (!IN_usingRumble()) return;
+
+	assert (whichScript >= 0 && whichScript < MAX_RUMBLE_SCRIPTS);
+	
+	// Can't execute an empty script???
+	assert (rumbleScripts[whichScript].usedStates > 0);
+
+	rumbleScripts[whichScript].currentState = 0;
+	int cmd = rumbleScripts[whichScript].states[rumbleScripts[whichScript].currentState].timeToStop;
+	if (cmd < 0)
+	{
+		cmd = IN_RunSpecialScript(whichScript);
+	}
+	
+	rumbleScripts[whichScript].nextStateAt = IN_Time() + cmd;
+	
+	rumbleStatus[rumbleScripts[whichScript].controller].changed = true;
+	rumbleStatus[rumbleScripts[whichScript].controller].killed = false;
+}
+
+
+
+void IN_PauseRumbling(int controller)
+{ 
+	if (!IN_usingRumble()) return;
+	if (controller <= -1 || controller >= MAX_RUMBLE_CONTROLLERS) return;
+	if (rumbleStatus[controller].paused == true) return;
+
+	rumbleStatus[controller].timePaused = IN_Time();
+	rumbleStatus[controller].paused = IN_RumbleAdjust(controller, 0, 0);
+}
+
+void IN_UnPauseRumbling(int controller)
+{
+	if (!IN_usingRumble()) return;
+	if (controller <= -1 || controller >= MAX_RUMBLE_CONTROLLERS) return;
+	
+	// can't unpause a control that wasn't paused
+	if (rumbleStatus[controller].paused == false) return;
+
+	int cur_time = IN_Time();
+	for (int i = 0; i < MAX_RUMBLE_SCRIPTS; i++)
+	{
+		if (rumbleScripts[i].controller == controller)
+		{
+			if (rumbleScripts[i].nextStateAt == 0) continue;
+			// update the time to stop based on how long it was paused
+			rumbleScripts[i].nextStateAt += (cur_time - rumbleStatus[controller].timePaused);
+		}
+	}
+
+	rumbleStatus[controller].paused = false; 
+	rumbleStatus[controller].changed = true;
+	rumbleStatus[controller].killed = false;
+}
+
+void IN_TogglePauseRumbling(int controller)
+{ 
+	if (!IN_usingRumble()) return;
+	if (controller <= -1 || controller >= MAX_RUMBLE_CONTROLLERS) return;
+	if (rumbleStatus[controller].paused)
+		IN_UnPauseRumbling(controller);
+	else
+		IN_PauseRumbling(controller);
+}
+
+// Pauses rumbling on all controllers
+void IN_PauseRumbling( void )
+{ 
+	if (!IN_usingRumble()) return;
+	for (int i = 0; i < MAX_RUMBLE_CONTROLLERS; i++)
+		IN_PauseRumbling(i);
+}
+
+// UnPauses rumbling on all controllers
+void IN_UnPauseRumbling( void )
+{ 
+	if (!IN_usingRumble()) return;
+	for (int i = 0; i < MAX_RUMBLE_CONTROLLERS; i++)
+		IN_UnPauseRumbling(i);
+}
+
+// Toggles Pausing on all controllers
+void IN_TogglePauseRumbling( void )
+{ 
+	if (!IN_usingRumble()) return;
+	for (int i = 0; i < MAX_RUMBLE_CONTROLLERS; i++)
+		IN_TogglePauseRumbling(i);
+}
+
+// Returns false when the end of the script is reached
+bool IN_AdvanceToNextState(int whichScript)
+{
+	assert( whichScript >= 0 && whichScript < MAX_RUMBLE_SCRIPTS );
+	
+	if (rumbleScripts[whichScript].currentState >= rumbleScripts[whichScript].usedStates - 1)
+	{
+		// Script is at its end, so kill it( which deletes only if autodelete
+		IN_KillRumbleScript(whichScript);
+		return false;
+	}
+
+	// Advance a state
+	rumbleScripts[whichScript].currentState++;
+
+	int cmd = rumbleScripts[whichScript].states[rumbleScripts[whichScript].currentState].timeToStop;
+	while (cmd < 0)
+	{
+		cmd = IN_RunSpecialScript(whichScript);
+		if (cmd == -1) return true;
+		if (cmd == -2) return false;
+	}
+
+	rumbleScripts[whichScript].nextStateAt = IN_Time() + cmd;
+	return true;
+}
+
+// Max rumble takes precidence
+// Other possibility is some kind of sum of all the speeds 
+// Call this once a frame, to update the controller based on the rumble states
+void IN_UpdateRumbleFromStates()
+{
+	//if (!IN_usingRumble()) return;
+/*mb	extern int G_ShouldBeRumbling();
+	if (!G_ShouldBeRumbling())
+		return;
+*/
+	int usingRumble[2];
+	usingRumble[0] = Cvar_VariableIntegerValue("in_useRumble");
+	usingRumble[1] = Cvar_VariableIntegerValue("in_useRumble2");
+	
+	int i;
+	int value[MAX_RUMBLE_CONTROLLERS][2];		
+	int cur_time = IN_Time();
+
+	memset(value, 0, sizeof(int)*MAX_RUMBLE_CONTROLLERS*2);
+	for (i = 0; i < MAX_RUMBLE_SCRIPTS; i++)
+	{
+		// If rumble is paused on current controller than skip this rumble state
+		if ( rumbleStatus[rumbleScripts[i].controller].paused) continue;
+
+//*mb	ClientManager::ActivateByControllerId(rumbleScripts[i].controller);
+		if ( !usingRumble[ActiveClientNum()] ) 
+		{
+			IN_KillRumbleScript(i);
+			continue;
+		}
+/*mb
+		if (!ClientManager::ActiveGentity() || !G_ActivePlayerNormal())
+		{
+			IN_KillRumbleScript(i);
+			continue;
+		}
+*/
+		// Unset state so skip
+		if ( rumbleScripts[i].nextStateAt == 0) continue;
+
+		// Time is up on this rumble state
+		if ( rumbleScripts[i].nextStateAt < cur_time) 
+		{
+			// If timeToStop is < cur_time and > 0 then end this state otherwise (negative number) always rumble 
+			if (rumbleScripts[i].nextStateAt > 0) 
+			{	
+				rumbleStatus[rumbleScripts[i].controller].changed = true;
+				rumbleStatus[rumbleScripts[i].controller].killed = false;
+				if (!IN_AdvanceToNextState(i))		// Returns false if reached the end of script
+					continue;
+			}
+		}
+
+		rumblescript_t *curScript = &rumbleScripts[i];
+
+		if (value[curScript->controller][0] < curScript->states[curScript->currentState].arg2)
+			value[curScript->controller][0] = curScript->states[curScript->currentState].arg2;
+		if (value[curScript->controller][1] < curScript->states[curScript->currentState].arg1)
+			value[curScript->controller][1] = curScript->states[curScript->currentState].arg1;
+	}
+	
+	// Go through the 4 controller ports
+	for (i = 0; i < MAX_RUMBLE_CONTROLLERS; i++) 
+	{
+		// paused, so do nothing for this controller
+		if ( rumbleStatus[i].paused) continue;
+
+		// Only update the actual hardware if a state has changed
+		if (!rumbleStatus[i].changed) continue;
+		
+		IN_RumbleAdjust(i, value[i][0], value[i][1]);
+		
+		// State has changed
+		rumbleStatus[i].changed = false;
+	}
+}
+
+
+
+/*
+==================
+IN_RumbleInit
+==================
+*/
+void IN_RumbleInit (void) {
+	memset(&rumbleStatus, 0, sizeof(rumblestatus_t)*MAX_RUMBLE_CONTROLLERS);
+	memset(&rumbleScripts, 0, sizeof(rumblescript_t)*MAX_RUMBLE_SCRIPTS);
+
+	in_useRumble = Cvar_Get( "in_useRumble", "1", 0 );
+	Cvar_Get("in_useRumble2", "1", 0);
+}
+
+
+/*
+==================
+IN_RumbleShutdown
+==================
+*/
+void IN_RumbleShutdown (void) {
+	for (int i = 0; i < MAX_RUMBLE_SCRIPTS; i++)
+	{
+		if (rumbleScripts[i].states)
+			delete [] rumbleScripts[i].states;
+		rumbleScripts[i].states = 0;
+		rumbleScripts[i].nextStateAt = 0;
+	}
+}
+
+
+/*
+==================
+IN_RumbleFrame
+==================
+*/
+void IN_RumbleFrame (void)
+{
+	// Check to see if we need to pause rumbling
+	if(cl_paused->integer && !rumbleStatus[IN_GetMainController()].paused)
+	{
+		IN_PauseRumbling(IN_GetMainController());
+	}
+	else if(!cl_paused->integer && rumbleStatus[IN_GetMainController()].paused)
+	{
+		IN_UnPauseRumbling(IN_GetMainController());
+	}
+	
+	// Update the states
+	IN_UpdateRumbleFromStates();
+}
diff --git a/code/win32/win_input_xbox.cpp b/code/win32/win_input_xbox.cpp
new file mode 100644
index 0000000..ab7d59d
--- /dev/null
+++ b/code/win32/win_input_xbox.cpp
@@ -0,0 +1,306 @@
+// win_input.c -- win32 mouse and joystick code
+// 02/21/97 JCB Added extended DirectInput code to support external controllers.
+
+// leave this as first line for PCH reasons...
+//
+// #include "../server/exe_headers.h"
+
+#include <xtl.h>
+#include "glw_win_dx8.h"
+
+#include "../client/client.h"
+#include "../qcommon/qcommon.h"
+#ifdef _JK2MP
+#include "../ui/keycodes.h"
+#else
+#include "../client/keycodes.h"
+#endif
+
+#include "win_local.h"
+#include "win_input.h"
+
+#define IN_MAX_CONTROLLERS 4
+
+void IN_UIEmptyQueue();
+
+struct inputstate_t
+{
+	struct controller_t
+	{
+		HANDLE handle;
+		XINPUT_STATE state;
+		XINPUT_FEEDBACK feedback;
+	};
+	controller_t controllers[IN_MAX_CONTROLLERS];
+};
+
+inputstate_t *in_state = NULL;
+
+/*
+=========================================================================
+
+JOYSTICK
+
+=========================================================================
+*/
+// Process all the insertions and removals, updating handles and such
+void IN_ProcessChanges(DWORD dwInsert, DWORD dwRemove)
+{
+	for(int port = 0; port < IN_MAX_CONTROLLERS; ++port)
+	{
+		// Close removals.
+		if( ((1 << port) & dwRemove) && in_state->controllers[port].handle )
+		{
+			XInputClose( in_state->controllers[port].handle );
+			in_state->controllers[port].handle = 0;
+			IN_PadUnplugged(port);
+		}
+
+		// Open insertions.
+		if( (1 << port) & dwInsert )
+		{
+			in_state->controllers[port].handle = XInputOpen( XDEVICE_TYPE_GAMEPAD, port, XDEVICE_NO_SLOT, NULL );
+			IN_PadPlugged(port);
+		}
+	}
+
+	return;
+}
+
+/*********
+IN_CheckForNoControllers()
+If there are no controllers plugged in, the UI
+is notified so it can display an appropriate
+message.
+*********/
+void IN_CheckForNoControllers()
+{
+	extern bool noControllersConnected;
+	if(!noControllersConnected)
+	{
+		extern bool wasPlugged[4];
+		if( !wasPlugged[0] &&
+			!wasPlugged[1] &&
+			!wasPlugged[2] &&
+			!wasPlugged[3] )
+		{
+			// Tell the UI that there are no controllers connected
+		//	VM_Call( uivm, UI_CONTROLLER_UNPLUGGED, true, -1);
+			noControllersConnected = true;
+		}
+	}
+}
+
+/*
+=========================================================================
+
+  RUMBLE SUPPORT
+
+=========================================================================
+*/
+
+bool IN_RumbleAdjust(int controller, int left, int right)
+{
+	assert(controller >= 0 && controller < IN_MAX_CONTROLLERS);
+
+	// Get a device handle for the controller.  This may fail.
+	HANDLE handle = in_state->controllers[controller].handle;
+
+	if (!handle) return false;
+	
+	XINPUT_FEEDBACK* fb = &in_state->controllers[controller].feedback;
+	
+	// If a prior rumble update is still pending, go away
+	if (fb->Header.dwStatus == ERROR_IO_PENDING) return false;
+
+	fb->Rumble.wLeftMotorSpeed = left;
+	fb->Rumble.wRightMotorSpeed = right;
+	
+	return ERROR_IO_PENDING == XInputSetState(handle, fb);
+}
+
+
+/*
+=========================================================================
+
+=========================================================================
+*/
+
+/*
+igBool IN_WindowClose(igWindow *window)
+{
+	SV_Shutdown ("Server quit\n");
+	CL_Shutdown ();
+	Com_Shutdown ();
+	Sys_Quit ();
+	return true;
+}
+*/
+
+/*
+===========
+IN_Shutdown
+===========
+*/
+void IN_Shutdown( void ) {
+	IN_RumbleShutdown();
+
+	delete in_state;
+	in_state = NULL;
+}
+
+
+/*
+===========
+IN_Init
+===========
+*/
+void IN_Init( void )
+{
+		in_state = new inputstate_t;
+
+		// Initialize support for 4 gamepads
+		XDEVICE_PREALLOC_TYPE xdpt[] = {
+			{XDEVICE_TYPE_GAMEPAD, 4}
+		};
+
+    // Initialize the peripherals. We can only ever
+	// call XInitDevices once, no matter what.
+	static bool bInputInitialized = false;
+	if (!bInputInitialized)
+		XInitDevices( sizeof(xdpt) / sizeof(XDEVICE_PREALLOC_TYPE), xdpt );
+	bInputInitialized = true;
+
+		// Zero all of our data, including handles
+		memset(in_state->controllers, 0, sizeof(in_state->controllers));
+
+		// Find out the status of all gamepad ports, then open them
+		IN_ProcessChanges( XGetDevices( XDEVICE_TYPE_GAMEPAD ), 0 );
+
+		IN_RumbleInit();
+	}
+
+static inline float _joyAxisConvert(SHORT x)
+{
+	// Change scale
+	float y = x / 32767.0;
+
+	// Cheesy deadzone
+	if(fabs(y) < 0.25f)
+	{
+		y = 0.0f;
+	}
+
+	return y;
+}
+
+// How many controls on the xbox gamepad?
+#define IN_NUM_DIGITAL_BUTTONS 8
+#define IN_NUM_ANALOG_BUTTONS 8
+// Cutoff where the analog buttons are considered to be "pressed"
+// This should be smarter.
+#define IN_ANALOG_BUTTON_THRESHOLD 64
+
+void IN_UpdateGamepad(int port)
+{
+	// Lookup table to convert the digital buttons to fakeAscii_t, in mask order
+	const fakeAscii_t digitalXlat[IN_NUM_DIGITAL_BUTTONS] = {
+		A_JOY5, // DPAD_UP
+		A_JOY7, // DPAD_DOWN
+		A_JOY8, // DPAD_LEFT
+		A_JOY6, // DPAD_LEFT
+		A_JOY4, // Start
+		A_JOY1, // Back
+		A_JOY2, // Left stick
+		A_JOY3  // Right stick
+	};
+
+	// Lookup table to convet the analog buttons to fakeAscii_t, in DX order
+	const fakeAscii_t analogXlat[IN_NUM_ANALOG_BUTTONS] = {
+		A_JOY15, // A
+		A_JOY14, // B
+		A_JOY16, // X
+		A_JOY13, // Y
+		A_JOY10, // Black
+		A_JOY9,  // White
+		A_JOY11, // Left trigger
+		A_JOY12  // Right trigger
+	};
+
+	// Get new state
+	XINPUT_STATE newState;
+	XInputGetState( in_state->controllers[port].handle, &newState );
+
+	// Get old state
+	XINPUT_STATE &oldState(in_state->controllers[port].state);
+
+	int buttonIdx;
+	bool oldPressed, newPressed;
+
+	// Check all digital buttons first
+	for (buttonIdx = 0; buttonIdx < IN_NUM_DIGITAL_BUTTONS; ++buttonIdx)
+	{
+		oldPressed = oldState.Gamepad.wButtons & (1 << buttonIdx);
+		newPressed = newState.Gamepad.wButtons & (1 << buttonIdx);
+
+		if (oldPressed != newPressed)
+			IN_CommonJoyPress(port, digitalXlat[buttonIdx], newPressed);
+	}
+
+	// Now check all analog buttons
+	for (buttonIdx = 0; buttonIdx < IN_NUM_ANALOG_BUTTONS; ++buttonIdx)
+	{
+		oldPressed = oldState.Gamepad.bAnalogButtons[buttonIdx] > IN_ANALOG_BUTTON_THRESHOLD;
+		newPressed = newState.Gamepad.bAnalogButtons[buttonIdx] > IN_ANALOG_BUTTON_THRESHOLD;
+
+		if (oldPressed != newPressed)
+			IN_CommonJoyPress(port, analogXlat[buttonIdx], newPressed);
+	}
+
+	// Update joysticks
+	_padInfo.joyInfo[0].x = _joyAxisConvert(newState.Gamepad.sThumbLX);
+	_padInfo.joyInfo[0].y = _joyAxisConvert(newState.Gamepad.sThumbLY);
+	_padInfo.joyInfo[1].x = _joyAxisConvert(newState.Gamepad.sThumbRX);
+	_padInfo.joyInfo[1].y = _joyAxisConvert(newState.Gamepad.sThumbRY);
+	_padInfo.joyInfo[0].valid = _padInfo.joyInfo[1].valid = true;
+	_padInfo.padId = port;
+
+	// Copy state back
+	oldState = newState;
+
+	// Update game
+	IN_CommonUpdate();
+}
+
+/*
+==================
+IN_Frame
+
+Called every frame, even if not generating commands
+==================
+*/
+//extern int ignoreInputTime;
+void IN_Frame (void)
+{
+	if (in_state)
+	{
+		// First, check for changes in device status (removed/inserted pads)
+		DWORD dwInsert, dwRemove;
+		if( XGetDeviceChanges( XDEVICE_TYPE_GAMEPAD, &dwInsert, &dwRemove ) )
+		{
+			IN_ProcessChanges(dwInsert, dwRemove);
+		}
+		else
+		{
+			IN_CheckForNoControllers();
+		}
+
+		// Generate callbacks for each controller that's plugged in
+		for (int port = 0; port < IN_MAX_CONTROLLERS; ++port)
+			if (in_state->controllers[port].handle)
+				IN_UpdateGamepad(port);
+
+		IN_UIEmptyQueue();
+		IN_RumbleFrame();
+	}
+}
diff --git a/code/win32/win_local.h b/code/win32/win_local.h
new file mode 100644
index 0000000..86b1e09
--- /dev/null
+++ b/code/win32/win_local.h
@@ -0,0 +1,76 @@
+// win_local.h: Win32-specific Quake3 header file
+
+#if defined (_MSC_VER) && (_MSC_VER >= 1200)
+#pragma warning(disable : 4201)
+#pragma warning( push )
+#endif
+
+#if defined (_MSC_VER) && (_MSC_VER >= 1200)
+#pragma warning( pop )
+#endif
+
+#ifndef _XBOX
+#define DIRECTINPUT_VERSION 0x0800 //[ 0x0300 | 0x0500 | 0x0700 | 0x0800 ]
+#include <dinput.h>
+#include <dsound.h>
+#else
+#include "../qcommon/platform.h"
+#endif
+
+void	IN_MouseEvent (int mstate);
+
+void Sys_QueEvent( int time, sysEventType_t type, int value, int value2, int ptrLength, void *ptr );
+
+void	Sys_CreateConsole( void );
+void	Sys_DestroyConsole( void );
+
+char	*Sys_ConsoleInput (void);
+
+// Input subsystem
+
+void	IN_Init (void);
+void	IN_Shutdown (void);
+void	IN_JoystickCommands (void);
+
+void	IN_Move (usercmd_t *cmd);
+// add additional non keyboard / non mouse movement on top of the keyboard move cmd
+
+void	IN_DeactivateWin32Mouse( void);
+
+void	IN_Activate (qboolean active);
+void	IN_Frame (void);
+
+// window procedure
+#ifndef _XBOX
+LONG WINAPI MainWndProc (
+    HWND    hWnd,
+    UINT    uMsg,
+    WPARAM  wParam,
+    LPARAM  lParam);
+#endif
+
+void Conbuf_AppendText( const char *msg );
+
+void SNDDMA_Activate( qboolean bAppActive );
+
+#ifndef _XBOX
+typedef struct
+{
+	HWND			hWnd;
+	HINSTANCE		hInstance;
+	qboolean		activeApp;
+	qboolean		isMinimized;
+	OSVERSIONINFO	osversion;
+
+	// when we get a windows message, we store the time off so keyboard processing
+	// can know the exact time of an event
+	unsigned		sysMsgTime;
+} WinVars_t;
+
+extern WinVars_t	g_wv;
+#endif
+
+
+#define	MAX_QUED_EVENTS		256
+#define	MASK_QUED_EVENTS	( MAX_QUED_EVENTS - 1 )
+
diff --git a/code/win32/win_main.cpp b/code/win32/win_main.cpp
new file mode 100644
index 0000000..386dc46
--- /dev/null
+++ b/code/win32/win_main.cpp
@@ -0,0 +1,1241 @@
+// win_main.h
+
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+
+
+#include "../client/client.h"
+#include "win_local.h"
+#include "resource.h"
+#include <errno.h>
+#include <float.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <direct.h>
+#include <io.h>
+#include <conio.h>
+#include <crtdbg.h>
+
+// The following macros set and clear, respectively, given bits
+// of the C runtime library debug flag, as specified by a bitmask.
+
+#ifdef   _DEBUG
+#define  SET_CRT_DEBUG_FIELD(a) \
+            _CrtSetDbgFlag((a) | _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG))
+#define  CLEAR_CRT_DEBUG_FIELD(a) \
+            _CrtSetDbgFlag(~(a) & _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG))
+#else
+#define  SET_CRT_DEBUG_FIELD(a)   ((void) 0)
+#define  CLEAR_CRT_DEBUG_FIELD(a) ((void) 0)
+#endif
+
+#define	CD_BASEDIR	"gamedata\\gamedata"
+#define	CD_EXE		"jasp.exe"
+#define	CD_VOLUME	"JEDIACAD"
+
+#define MEM_THRESHOLD 128*1024*1024
+
+static char		sys_cmdline[MAX_STRING_CHARS];
+
+
+/*
+==================
+Sys_GetFileTime()
+==================
+*/
+bool Sys_GetFileTime(LPCSTR psFileName, FILETIME &ft)
+{
+	bool bSuccess = false;
+	HANDLE hFile = INVALID_HANDLE_VALUE;	
+
+	hFile = CreateFile(	psFileName,	// LPCTSTR lpFileName,          // pointer to name of the file
+						GENERIC_READ,			// DWORD dwDesiredAccess,       // access (read-write) mode
+						FILE_SHARE_READ,		// DWORD dwShareMode,           // share mode
+						NULL,					// LPSECURITY_ATTRIBUTES lpSecurityAttributes,	// pointer to security attributes
+						OPEN_EXISTING,			// DWORD dwCreationDisposition,  // how to create
+						FILE_FLAG_NO_BUFFERING,// DWORD dwFlagsAndAttributes,   // file attributes
+						NULL					// HANDLE hTemplateFile          // handle to file with attributes to 
+						);
+
+	if (hFile != INVALID_HANDLE_VALUE)
+	{			
+		if (GetFileTime(hFile,	// handle to file
+						NULL,	// LPFILETIME lpCreationTime
+						NULL,	// LPFILETIME lpLastAccessTime
+						&ft		// LPFILETIME lpLastWriteTime
+						)
+			)
+		{
+			bSuccess = true;
+		}
+
+		CloseHandle(hFile);
+	}
+
+	return bSuccess;
+}
+
+
+/*
+==================
+Sys_FileOutOfDate()
+==================
+*/
+qboolean Sys_FileOutOfDate( LPCSTR psFinalFileName /* dest */, LPCSTR psDataFileName /* src */ )
+{
+	FILETIME ftFinalFile, ftDataFile;
+
+	if (Sys_GetFileTime(psFinalFileName, ftFinalFile) && Sys_GetFileTime(psDataFileName, ftDataFile))
+	{
+		// timer res only accurate to within 2 seconds on FAT, so can't do exact compare...
+		//
+		//LONG l = CompareFileTime( &ftFinalFile, &ftDataFile );
+		if (  (abs(ftFinalFile.dwLowDateTime - ftDataFile.dwLowDateTime) <= 20000000 ) &&
+				  ftFinalFile.dwHighDateTime == ftDataFile.dwHighDateTime				
+			)
+		{
+			return false;	// file not out of date, ie use it.
+		}
+		return true;	// flag return code to copy over a replacement version of this file
+	}
+
+
+	// extra error check, report as suspicious if you find a file locally but not out on the net.,.
+	//
+	if (com_developer->integer)
+	{
+		if (!Sys_GetFileTime(psDataFileName, ftDataFile))
+		{
+			Com_Printf( "Sys_FileOutOfDate: reading %s but it's not on the net!\n", psFinalFileName);
+		}
+	}
+
+	return false;
+}
+
+/*
+==================
+Sys_LowPhysicalMemory()
+==================
+*/
+qboolean Sys_CopyFile(LPCSTR lpExistingFileName, LPCSTR lpNewFileName, qboolean bOverWrite)
+{
+	qboolean bOk = qtrue;
+	if (!CopyFile( lpExistingFileName, lpNewFileName, !bOverWrite ) && bOverWrite)
+	{
+		DWORD dwAttrs = GetFileAttributes(lpNewFileName);
+		SetFileAttributes(lpNewFileName, dwAttrs & ~FILE_ATTRIBUTE_READONLY);
+		bOk = CopyFile( lpExistingFileName, lpNewFileName, FALSE );
+	}
+	return bOk;
+}
+
+/*
+==================
+Sys_LowPhysicalMemory()
+==================
+*/
+qboolean Sys_LowPhysicalMemory() 
+{
+	static MEMORYSTATUS stat;
+	static qboolean bAsked = qfalse;
+	static cvar_t* sys_lowmem = Cvar_Get( "sys_lowmem", "0", 0 );
+
+	if (!bAsked)	// just in case it takes a little time for GlobalMemoryStatus() to gather stats on
+	{				//	stuff we don't care about such as virtual mem etc.
+		bAsked = qtrue;
+		GlobalMemoryStatus (&stat);
+	}
+	if (sys_lowmem->integer)
+	{
+		return qtrue;
+	}
+	return (stat.dwTotalPhys <= MEM_THRESHOLD) ? qtrue : qfalse;
+}
+
+
+/*
+==================
+Sys_BeginProfiling
+==================
+*/
+void Sys_BeginProfiling( void ) {
+	// this is just used on the mac build
+}
+
+/*
+=============
+Sys_Error
+
+Show the early console as an error dialog
+=============
+*/
+void QDECL Sys_Error( const char *error, ... ) {
+	va_list		argptr;
+	char		text[4096];
+    MSG        msg;
+
+	va_start (argptr, error);
+	vsprintf (text, error, argptr);
+	va_end (argptr);
+
+	Conbuf_AppendText( text );
+	Conbuf_AppendText( "\n" );
+
+	Sys_SetErrorText( text );
+	Sys_ShowConsole( 1, qtrue );
+
+	timeEndPeriod( 1 );
+
+	IN_Shutdown();
+
+	// wait for the user to quit
+	while ( 1 ) {
+		if (!GetMessage (&msg, NULL, 0, 0))
+			Com_Quit_f ();
+		TranslateMessage (&msg);
+      	DispatchMessage (&msg);
+	}
+
+	Sys_DestroyConsole();
+  	Com_ShutdownZoneMemory();
+  	Com_ShutdownHunkMemory();
+
+	exit (1);
+}
+
+/*
+==============
+Sys_Quit
+==============
+*/
+void Sys_Quit( void ) {
+	timeEndPeriod( 1 );
+	IN_Shutdown();
+	Sys_DestroyConsole();
+  	Com_ShutdownZoneMemory();
+  	Com_ShutdownHunkMemory();
+
+	exit (0);
+}
+
+/*
+==============
+Sys_Print
+==============
+*/
+void Sys_Print( const char *msg ) {
+	Conbuf_AppendText( msg );
+}
+
+
+/*
+==============
+Sys_Mkdir
+==============
+*/
+void Sys_Mkdir( const char *path ) {
+	_mkdir (path);
+}
+
+/*
+==============
+Sys_Cwd
+==============
+*/
+char *Sys_Cwd( void ) {
+	static char cwd[MAX_OSPATH];
+
+	_getcwd( cwd, sizeof( cwd ) - 1 );
+	cwd[MAX_OSPATH-1] = 0;
+
+	return cwd;
+}
+
+/*
+==============
+Sys_DefaultCDPath
+==============
+*/
+char *Sys_DefaultCDPath( void ) {
+	return "";
+}
+
+/*
+==============
+Sys_DefaultBasePath
+==============
+*/
+char *Sys_DefaultBasePath( void ) {
+	return Sys_Cwd();
+}
+
+/*
+==============================================================
+
+DIRECTORY SCANNING
+
+==============================================================
+*/
+
+#define	MAX_FOUND_FILES	0x1000
+
+char **Sys_ListFiles( const char *directory, const char *extension, int *numfiles, qboolean wantsubs ) {
+	char		search[MAX_OSPATH];
+	int			nfiles;
+	char		**listCopy;
+	char		*list[MAX_FOUND_FILES];
+	struct _finddata_t findinfo;
+	int			findhandle;
+	int			flag;
+	int			i;
+
+	if ( !extension) {
+		extension = "";
+	}
+
+	// passing a slash as extension will find directories
+	if ( extension[0] == '/' && extension[1] == 0 ) {
+		extension = "";
+		flag = 0;
+	} else {
+		flag = _A_SUBDIR;
+	}
+
+	Com_sprintf( search, sizeof(search), "%s\\*%s", directory, extension );
+
+	// search
+	nfiles = 0;
+
+	findhandle = _findfirst (search, &findinfo);
+	if (findhandle == -1) {
+		*numfiles = 0;
+		return NULL;
+	}
+
+	do {
+		if ( (!wantsubs && flag ^ ( findinfo.attrib & _A_SUBDIR )) || (wantsubs && findinfo.attrib & _A_SUBDIR) ) {
+			if ( nfiles == MAX_FOUND_FILES - 1 ) {
+				break;
+			}
+			list[ nfiles ] = CopyString( findinfo.name );
+			nfiles++;
+		}
+	} while ( _findnext (findhandle, &findinfo) != -1 );
+
+	list[ nfiles ] = 0;
+
+	_findclose (findhandle);
+
+	// return a copy of the list
+	*numfiles = nfiles;
+
+	if ( !nfiles ) {
+		return NULL;
+	}
+
+	listCopy = (char **) Z_Malloc( ( nfiles + 1 ) * sizeof( *listCopy ), TAG_LISTFILES, qfalse);
+	for ( i = 0 ; i < nfiles ; i++ ) {
+		listCopy[i] = list[i];
+	}
+	listCopy[i] = NULL;
+
+	return listCopy;
+}
+
+void	Sys_FreeFileList( char **filelist ) {
+	int		i;
+
+	if ( !filelist ) {
+		return;
+	}
+
+	for ( i = 0 ; filelist[i] ; i++ ) {
+		Z_Free( filelist[i] );
+	}
+
+	Z_Free( filelist );
+}
+
+//========================================================
+
+
+/*
+================
+Sys_ScanForCD
+
+Search all the drives to see if there is a valid CD to grab
+the cddir from
+================
+*/
+#ifdef FINAL_BUILD
+static qboolean Sys_ScanForCD( void ) {
+	char		drive[4];
+	FILE		*f;
+	char		test[MAX_OSPATH];
+
+	drive[0] = 'c';
+	drive[1] = ':';
+	drive[2] = '\\';
+	drive[3] = 0;
+
+	// scan the drives
+	for ( drive[0] = 'c' ; drive[0] <= 'z' ; drive[0]++ ) {
+		if ( GetDriveType (drive) == DRIVE_CDROM ) {			
+			BOOL Result;
+			char VolumeName[MAX_PATH],FileSystemName[MAX_PATH];
+			DWORD VolumeSerialNumber,MaximumComponentLength,FileSystemFlags;
+			
+			Result = GetVolumeInformation(drive,VolumeName,sizeof(VolumeName),&VolumeSerialNumber,
+				&MaximumComponentLength,&FileSystemFlags,FileSystemName,sizeof(FileSystemName));
+
+			if (Result && (strnicmp(VolumeName,CD_VOLUME,8) == 0 ) )
+			{
+				sprintf (test, "%s%s\\%s", drive, CD_BASEDIR, CD_EXE);
+				f = fopen( test, "r");
+				if ( f ) {
+					fclose (f);
+					return Result;
+				}
+			}
+		}
+	}
+
+	return qfalse;
+}
+#endif
+/*
+================
+Sys_CheckCD
+
+Return true if the proper CD is in the drive
+================
+*/
+qboolean	Sys_CheckCD( void ) {
+#ifdef FINAL_BUILD
+	return Sys_ScanForCD();
+#else
+	return qtrue;
+#endif
+}
+
+/*
+================
+Sys_GetClipboardData
+
+================
+*/
+char *Sys_GetClipboardData( void ) {
+	char *data = NULL;
+	char *cliptext;
+
+	if ( OpenClipboard( NULL ) != 0 ) {
+		HANDLE hClipboardData;
+
+		if ( ( hClipboardData = GetClipboardData( CF_TEXT ) ) != 0 ) {
+			if ( ( cliptext = (char *) GlobalLock( hClipboardData ) ) != 0 ) {
+				data = (char *) Z_Malloc( GlobalSize( hClipboardData ) + 1, TAG_CLIPBOARD, qfalse);
+				strcpy( data, cliptext );
+				GlobalUnlock( hClipboardData );
+				
+				strtok( data, "\n\r\b" );
+			}
+		}
+		CloseClipboard();
+	}
+	return data;
+}
+
+
+/*
+========================================================================
+
+GAME DLL
+
+========================================================================
+*/
+static HINSTANCE	game_library;
+
+/*
+=================
+Sys_UnloadGame
+=================
+*/
+void Sys_UnloadGame( void ) {
+	if ( !game_library ) {
+		return;
+	}
+	if ( !FreeLibrary (game_library) ) {
+		Com_Error (ERR_FATAL, "FreeLibrary failed for game library");
+	}
+	game_library = NULL;
+}
+
+/*
+=================
+Sys_GetGameAPI
+
+Loads the game dll
+=================
+*/
+void *Sys_GetGameAPI (void *parms)
+{
+	void	*(*GetGameAPI) (void *);
+	char	name[MAX_OSPATH];
+	char	cwd[MAX_OSPATH];
+#if defined _M_IX86
+	const char *gamename = "jagamex86.dll";
+
+#ifdef NDEBUG
+	const char *debugdir = "release";
+#elif MEM_DEBUG
+	const char *debugdir = "shdebug";
+#else
+	const char *debugdir = "debug";
+#endif	//NDEBUG
+
+#elif defined _M_ALPHA
+	const char *gamename = "jagameaxp.dll";
+
+#ifdef NDEBUG
+	const char *debugdir = "releaseaxp";
+#else
+	const char *debugdir = "debugaxp";
+#endif //NDEBUG
+
+#endif //_M__IX86
+
+	if (game_library)
+		Com_Error (ERR_FATAL, "Sys_GetGameAPI without Sys_UnloadingGame");
+
+	// check the current debug directory first for development purposes
+	_getcwd (cwd, sizeof(cwd));
+	Com_sprintf (name, sizeof(name), "%s/%s/%s", cwd, debugdir, gamename);
+	game_library = LoadLibrary ( name );
+	if (game_library)
+	{
+		Com_DPrintf ("LoadLibrary (%s)\n", name);
+	}
+	else
+	{
+		// check the current directory for other development purposes
+		Com_sprintf (name, sizeof(name), "%s/%s", cwd, gamename);
+		game_library = LoadLibrary ( name );
+		if (game_library)
+		{
+			Com_DPrintf ("LoadLibrary (%s)\n", name);
+		} else {
+			char *buf;
+
+			FormatMessage( FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, GetLastError(), MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR) &buf, 0, NULL );
+
+			Com_Printf( "LoadLibrary(\"%s\") failed\n", name);
+			Com_Printf( "...reason: '%s'\n", buf );
+			Com_Error( ERR_FATAL, "Couldn't load game" );
+		}
+	}
+
+	GetGameAPI = (void *(*)(void *))GetProcAddress (game_library, "GetGameAPI");
+	if (!GetGameAPI)
+	{
+		Sys_UnloadGame ();		
+		return NULL;
+	}
+	return GetGameAPI (parms);
+}
+
+
+/*
+=================
+Sys_LoadCgame
+
+Used to hook up a development dll
+=================
+*/
+void * Sys_LoadCgame( int (**entryPoint)(int, ...), int (*systemcalls)(int, ...) ) 
+{
+	void	(*dllEntry)( int (*syscallptr)(int, ...) );
+
+	dllEntry = ( void (*)( int (*)( int, ... ) ) )GetProcAddress( game_library, "dllEntry" ); 
+	*entryPoint = (int (*)(int,...))GetProcAddress( game_library, "vmMain" );
+	if ( !*entryPoint || !dllEntry ) {
+		FreeLibrary( game_library );
+		return NULL;
+	}
+
+	dllEntry( systemcalls );
+	return game_library;
+}
+
+/*
+========================================================================
+
+BACKGROUND FILE STREAMING
+
+========================================================================
+*/
+
+#if 1
+
+void Sys_InitStreamThread( void ) {
+}
+
+void Sys_ShutdownStreamThread( void ) {
+}
+
+void Sys_BeginStreamedFile( fileHandle_t f, int readAhead ) {
+}
+
+void Sys_EndStreamedFile( fileHandle_t f ) {
+}
+
+int Sys_StreamedRead( void *buffer, int size, int count, fileHandle_t f ) {
+   return FS_Read( buffer, size * count, f );
+}
+
+void Sys_StreamSeek( fileHandle_t f, int offset, int origin ) {
+   FS_Seek( f, offset, origin );
+}
+
+
+#else
+
+typedef struct {
+	HANDLE	threadHandle;
+	int		threadId;
+	CRITICAL_SECTION	crit;
+	fileHandle_t	file;
+	byte	*buffer;
+	qboolean	eof;
+	int		bufferSize;
+	int		streamPosition;	// next byte to be returned by Sys_StreamRead
+	int		threadPosition;	// next byte to be read from file
+} streamState_t;
+
+streamState_t	stream;
+
+/*
+===============
+Sys_StreamThread
+
+A thread will be sitting in this loop forever
+================
+*/
+void Sys_StreamThread( void ) {
+	int		buffer;
+	int		count;
+	int		readCount;
+	int		bufferPoint;
+	int		r;
+
+	while (1) {
+		Sleep( 10 );
+		EnterCriticalSection (&stream.crit);
+
+		// if there is any space left in the buffer, fill it up
+		while ( !stream.eof ) {
+			count = stream.bufferSize - (stream.threadPosition - stream.streamPosition);
+			if ( !count ) {
+				break;
+			}
+
+			bufferPoint = stream.threadPosition % stream.bufferSize;
+			buffer = stream.bufferSize - bufferPoint;
+			readCount = buffer < count ? buffer : count;
+
+			r = FS_Read( stream.buffer + bufferPoint, readCount, stream.file );
+			stream.threadPosition += r;
+
+			if ( r != readCount ) {
+				stream.eof = qtrue;
+				break;
+			}
+		}
+
+		LeaveCriticalSection (&stream.crit);
+	}
+}
+
+/*
+===============
+Sys_InitStreamThread
+
+================
+*/
+void Sys_InitStreamThread( void ) {
+
+	InitializeCriticalSection ( &stream.crit );
+
+	// don't leave the critical section until there is a
+	// valid file to stream, which will cause the StreamThread
+	// to sleep without any overhead
+	EnterCriticalSection( &stream.crit );
+
+	stream.threadHandle = CreateThread(
+	   NULL,	// LPSECURITY_ATTRIBUTES lpsa,
+	   0,		// DWORD cbStack,
+	   (LPTHREAD_START_ROUTINE)Sys_StreamThread,	// LPTHREAD_START_ROUTINE lpStartAddr,
+	   0,			// LPVOID lpvThreadParm,
+	   0,			//   DWORD fdwCreate,
+	   (unsigned long *) &stream.threadId);
+}
+
+/*
+===============
+Sys_ShutdownStreamThread
+
+================
+*/
+void Sys_ShutdownStreamThread( void ) {
+}
+
+
+/*
+===============
+Sys_BeginStreamedFile
+
+================
+*/
+void Sys_BeginStreamedFile( fileHandle_t f, int readAhead ) {
+	if ( stream.file ) {
+		Sys_EndStreamedFile( stream.file );
+	}
+
+	stream.file = f;
+	stream.buffer = (unsigned char *) Z_Malloc( readAhead );
+	stream.bufferSize = readAhead;
+	stream.streamPosition = 0;
+	stream.threadPosition = 0;
+	stream.eof = qfalse;
+
+	// let the thread start running
+	LeaveCriticalSection( &stream.crit );
+}
+
+/*
+===============
+Sys_EndStreamedFile
+
+================
+*/
+void Sys_EndStreamedFile( fileHandle_t f ) {
+	if ( f != stream.file ) {
+		Com_Error( ERR_FATAL, "Sys_EndStreamedFile: wrong file");
+	}
+	// don't leave critical section until another stream is started
+	EnterCriticalSection( &stream.crit );
+
+	stream.file = 0;
+	Z_Free( stream.buffer );
+
+}
+
+
+/*
+===============
+Sys_StreamedRead
+
+================
+*/
+int Sys_StreamedRead( void *buffer, int size, int count, fileHandle_t f ) {
+	int		available;
+	int		remaining;
+	int		sleepCount;
+	int		copy;
+	int		bufferCount;
+	int		bufferPoint;
+	byte	*dest;
+
+	dest = (byte *)buffer;
+	remaining = size * count;
+
+	if ( remaining <= 0 ) {
+		Com_Error( ERR_FATAL, "Streamed read with non-positive size" );
+	}
+
+	sleepCount = 0;
+	while ( remaining > 0 ) {
+		available = stream.threadPosition - stream.streamPosition;
+		if ( !available ) {
+			if ( stream.eof ) {
+				break;
+			}
+			if ( sleepCount == 1 ) {
+				Com_DPrintf( "Sys_StreamedRead: waiting\n" );
+			}
+			if ( ++sleepCount > 100 ) {
+				Com_Error( ERR_FATAL, "Sys_StreamedRead: thread has died");
+			}
+			Sleep( 10 );
+			continue;
+		}
+
+		bufferPoint = stream.streamPosition % stream.bufferSize;
+		bufferCount = stream.bufferSize - bufferPoint;
+
+		copy = available < bufferCount ? available : bufferCount;
+		if ( copy > remaining ) {
+			copy = remaining;
+		}
+		memcpy( dest, stream.buffer + bufferPoint, copy );
+		stream.streamPosition += copy;
+		dest += copy;
+		remaining -= copy;
+	}
+
+	return (count * size - remaining) / size;
+}
+
+/*
+===============
+Sys_StreamSeek
+
+================
+*/
+void Sys_StreamSeek( fileHandle_t f, int offset, int origin ) {
+
+	// halt the thread
+	EnterCriticalSection( &stream.crit );
+
+	// clear to that point
+	FS_Seek( f, offset, origin );
+	stream.streamPosition = 0;
+	stream.threadPosition = 0;
+	stream.eof = qfalse;
+
+	// let the thread start running at the new position
+	LeaveCriticalSection( &stream.crit );
+}
+
+#endif
+
+
+/*
+========================================================================
+
+EVENT LOOP
+
+========================================================================
+*/
+
+#define	MAX_QUED_EVENTS		256
+#define	MASK_QUED_EVENTS	( MAX_QUED_EVENTS - 1 )
+
+sysEvent_t	eventQue[MAX_QUED_EVENTS];
+int			eventHead, eventTail;
+byte		sys_packetReceived[MAX_MSGLEN];
+
+/*
+================
+Sys_QueEvent
+
+A time of 0 will get the current time
+Ptr should either be null, or point to a block of data that can
+be freed by the game later.
+================
+*/
+void Sys_QueEvent( int time, sysEventType_t type, int value, int value2, int ptrLength, void *ptr ) {
+	sysEvent_t	*ev;
+
+	ev = &eventQue[ eventHead & MASK_QUED_EVENTS ];
+	if ( eventHead - eventTail >= MAX_QUED_EVENTS ) {
+		Com_Printf("Sys_QueEvent: overflow\n");
+		// we are discarding an event, but don't leak memory
+		if ( ev->evPtr ) {
+			Z_Free( ev->evPtr );
+		}
+		eventTail++;
+	}
+
+	eventHead++;
+
+	if ( time == 0 ) {
+		time = Sys_Milliseconds();
+	}
+
+	ev->evTime = time;
+	ev->evType = type;
+	ev->evValue = value;
+	ev->evValue2 = value2;
+	ev->evPtrLength = ptrLength;
+	ev->evPtr = ptr;
+}
+
+/*
+================
+Sys_GetEvent
+
+================
+*/
+sysEvent_t Sys_GetEvent( void ) {
+    MSG			msg;
+	sysEvent_t	ev;
+	char		*s;
+	msg_t		netmsg;
+
+	// return if we have data
+	if ( eventHead > eventTail ) {
+		eventTail++;
+		return eventQue[ ( eventTail - 1 ) & MASK_QUED_EVENTS ];
+	}
+
+	// pump the message loop
+	while (PeekMessage (&msg, NULL, 0, 0, PM_NOREMOVE)) {
+		if ( !GetMessage (&msg, NULL, 0, 0) ) {
+			Com_Quit_f();
+		}
+
+		// save the msg time, because wndprocs don't have access to the timestamp
+		g_wv.sysMsgTime = msg.time;
+
+		TranslateMessage (&msg);
+      	DispatchMessage (&msg);
+	}
+
+	// check for console commands
+	s = Sys_ConsoleInput();
+	if ( s ) {
+		char	*b;
+		int		len;
+
+		len = strlen( s ) + 1;
+		b = (char *) Z_Malloc( len, TAG_EVENT, qfalse);
+		strcpy( b, s );
+		Sys_QueEvent( 0, SE_CONSOLE, 0, 0, len, b );
+	}
+
+	// check for network packets
+	MSG_Init( &netmsg, sys_packetReceived, sizeof( sys_packetReceived ) );
+
+	// return if we have data
+	if ( eventHead > eventTail ) {
+		eventTail++;
+		return eventQue[ ( eventTail - 1 ) & MASK_QUED_EVENTS ];
+	}
+
+	// create an empty event to return
+
+	memset( &ev, 0, sizeof( ev ) );
+	ev.evTime = timeGetTime();
+
+	return ev;
+}
+
+//================================================================
+
+/*
+=================
+Sys_In_Restart_f
+
+Restart the input subsystem
+=================
+*/
+void Sys_In_Restart_f( void ) {
+	IN_Shutdown();
+	IN_Init();
+}
+
+static inline bool Sys_IsExpired()
+{
+#if 0
+//								sec min Hr Day Mon Yr
+    struct tm t_valid_start	= { 0, 0, 8, 5, 8, 103 };	//zero based months!
+//								sec min Hr Day Mon Yr
+    struct tm t_valid_end	= { 0, 0, 20, 13, 8, 103 };
+//    struct tm t_valid_end	= t_valid_start;
+//	t_valid_end.tm_mday += 8;
+	time_t startTime  = mktime( &t_valid_start);
+	time_t expireTime = mktime( &t_valid_end);
+	time_t now;
+	time(&now);
+	if((now < startTime) || (now> expireTime))
+	{
+		return true;
+	}
+#endif
+	return false;
+}
+
+/*
+================
+Sys_Init
+
+Called after the common systems (cvars, files, etc)
+are initialized
+================
+*/
+#define OSR2_BUILD_NUMBER 1111
+#define WIN98_BUILD_NUMBER 1998
+
+#if MEM_DEBUG
+void SH_Register(void);
+#endif
+
+void Sys_Init( void ) {
+	int cpuid;
+
+	// make sure the timer is high precision, otherwise
+	// NT gets 18ms resolution
+	timeBeginPeriod( 1 );
+
+	Cmd_AddCommand ("in_restart", Sys_In_Restart_f);
+#if MEM_DEBUG
+	SH_Register();
+#endif
+
+	g_wv.osversion.dwOSVersionInfoSize = sizeof( g_wv.osversion );
+
+	if (!GetVersionEx (&g_wv.osversion))
+		Sys_Error ("Couldn't get OS info");
+	if (Sys_IsExpired()) {
+		g_wv.osversion.dwPlatformId = VER_PLATFORM_WIN32s;	//sneaky: hide the expire with this error
+	}
+
+	if (g_wv.osversion.dwMajorVersion < 4)
+		Sys_Error ("This game requires Windows version 4 or greater");
+	if (g_wv.osversion.dwPlatformId == VER_PLATFORM_WIN32s)
+		Sys_Error ("This game doesn't run on Win32s");
+
+	if ( g_wv.osversion.dwPlatformId == VER_PLATFORM_WIN32_NT )
+	{
+		Cvar_Set( "arch", "winnt" );
+	}
+	else if ( g_wv.osversion.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS )
+	{
+		if ( LOWORD( g_wv.osversion.dwBuildNumber ) >= WIN98_BUILD_NUMBER )
+		{
+			Cvar_Set( "arch", "win98" );
+		}
+		else if ( LOWORD( g_wv.osversion.dwBuildNumber ) >= OSR2_BUILD_NUMBER )
+		{
+			Cvar_Set( "arch", "win95 osr2.x" );
+		}
+		else
+		{
+			Cvar_Set( "arch", "win95" );
+		}
+	}
+	else
+	{
+		Cvar_Set( "arch", "unknown Windows variant" );
+	}
+
+	// save out a couple things in rom cvars for the renderer to access
+	Cvar_Get( "win_hinstance", va("%i", (int)g_wv.hInstance), CVAR_ROM );
+	Cvar_Get( "win_wndproc", va("%i", (int)MainWndProc), CVAR_ROM );
+
+	//
+	// figure out our CPU
+	//
+	Cvar_Get( "sys_cpustring", "detect", CVAR_ROM );
+	if ( !Q_stricmp( Cvar_VariableString( "sys_cpustring"), "detect" ) )
+	{
+		Com_Printf( "...detecting CPU, found " );
+
+		cpuid = Sys_GetProcessorId();
+
+		switch ( cpuid )
+		{
+		case CPUID_GENERIC:
+			Cvar_Set( "sys_cpustring", "generic" );
+			break;
+		case CPUID_INTEL_UNSUPPORTED:
+			Cvar_Set( "sys_cpustring", "x86 (pre-Pentium)" );
+			break;
+		case CPUID_INTEL_PENTIUM:
+			Cvar_Set( "sys_cpustring", "x86 (P5/PPro, non-MMX)" );
+			break;
+		case CPUID_INTEL_MMX:
+			Cvar_Set( "sys_cpustring", "x86 (P5/Pentium2, MMX)" );
+			break;
+		case CPUID_INTEL_KATMAI:
+			Cvar_Set( "sys_cpustring", "Intel Pentium III" );
+			break;
+		case CPUID_INTEL_WILLIAMETTE:
+			Cvar_Set( "sys_cpustring", "Intel Pentium IV" );
+			break;
+		case CPUID_AMD_3DNOW:
+			Cvar_Set( "sys_cpustring", "AMD w/ 3DNow!" );
+			break;
+		case CPUID_AXP:
+			Cvar_Set( "sys_cpustring", "Alpha AXP" );
+			break;
+		default:
+			Com_Error( ERR_FATAL, "Unknown cpu type %d\n", cpuid );
+			break;
+		}
+	}
+	else
+	{
+		Com_Printf( "...forcing CPU type to " );
+		if ( !Q_stricmp( Cvar_VariableString( "sys_cpustring" ), "generic" ) )
+		{
+			cpuid = CPUID_GENERIC;
+		}
+		else if ( !Q_stricmp( Cvar_VariableString( "sys_cpustring" ), "x87" ) )
+		{
+			cpuid = CPUID_INTEL_PENTIUM;
+		}
+		else if ( !Q_stricmp( Cvar_VariableString( "sys_cpustring" ), "mmx" ) )
+		{
+			cpuid = CPUID_INTEL_MMX;
+		}
+		else if ( !Q_stricmp( Cvar_VariableString( "sys_cpustring" ), "3dnow" ) )
+		{
+			cpuid = CPUID_AMD_3DNOW;
+		}
+		else if ( !Q_stricmp( Cvar_VariableString( "sys_cpustring" ), "PentiumIII" ) )
+		{
+			cpuid = CPUID_INTEL_KATMAI;
+		}
+		else if ( !Q_stricmp( Cvar_VariableString( "sys_cpustring" ), "PentiumIV" ) )
+		{
+			cpuid = CPUID_INTEL_WILLIAMETTE;
+		}
+		else if ( !Q_stricmp( Cvar_VariableString( "sys_cpustring" ), "axp" ) )
+		{
+			cpuid = CPUID_AXP;
+		}
+		else
+		{
+			Com_Printf( "WARNING: unknown sys_cpustring '%s'\n", Cvar_VariableString( "sys_cpustring" ) );
+			cpuid = CPUID_GENERIC;
+		}
+	}
+	Cvar_SetValue( "sys_cpuid", cpuid );
+	Com_Printf( "%s\n", Cvar_VariableString( "sys_cpustring" ) );
+
+	Cvar_Set( "username", Sys_GetCurrentUser() );
+
+	IN_Init();		// FIXME: not in dedicated?
+}
+
+
+
+// do a quick mem test to check for any potential future mem problems...
+//
+static void QuickMemTest(void)
+{
+//	if (!Sys_LowPhysicalMemory())
+	{
+		const int iMemTestMegs = 128;	// useful search label
+		// special test, 
+		void *pvData = malloc(iMemTestMegs * 1024 * 1024);
+		if (pvData)
+		{
+			free(pvData);
+		}
+		else
+		{
+			// err...
+			//
+			extern qboolean Language_IsAsian(void);
+			LPCSTR psContinue = Language_IsAsian() ? 
+								"Your machine failed to allocate %dMB in a memory test, which may mean you'll have problems running this game all the way through.\n\nContinue anyway?"
+								: 
+								SE_GetString("CON_TEXT_FAILED_MEMTEST");
+								// ( since it's too much hassle doing MBCS code pages and decodings etc for MessageBox command )
+
+			#define GetYesNo(psQuery)	(!!(MessageBox(NULL,psQuery,"Query",MB_YESNO|MB_ICONWARNING|MB_TASKMODAL)==IDYES))
+			if (!GetYesNo(va(psContinue,iMemTestMegs)))
+			{
+				LPCSTR psNoMem = Language_IsAsian() ?
+								"Insufficient memory to run this game!\n"
+								:
+								SE_GetString("CON_TEXT_INSUFFICIENT_MEMORY");
+								// ( since it's too much hassle doing MBCS code pages and decodings etc for MessageBox command )
+
+				Com_Error( ERR_FATAL, psNoMem );
+			}
+		}
+	}
+}
+
+
+//=======================================================================
+//int	totalMsec, countMsec;
+
+/*
+==================
+WinMain
+
+==================
+*/
+int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow) {
+	char		cwd[MAX_OSPATH];
+//	int			startTime, endTime;
+
+   SET_CRT_DEBUG_FIELD( _CRTDBG_LEAK_CHECK_DF );
+//   _CrtSetBreakAlloc(34804);
+
+    // should never get a previous instance in Win32
+    if ( hPrevInstance ) {
+        return 0;
+	}
+
+	g_wv.hInstance = hInstance;
+	Q_strncpyz( sys_cmdline, lpCmdLine, sizeof( sys_cmdline ) );
+
+	// done before Com/Sys_Init since we need this for error output
+	Sys_CreateConsole();
+
+	// no abort/retry/fail errors
+	SetErrorMode( SEM_FAILCRITICALERRORS );
+
+	// get the initial time base
+	Sys_Milliseconds();
+
+#if 0
+	// if we find the CD, add a +set cddir xxx command line
+	Sys_ScanForCD();
+#endif
+
+	Sys_InitStreamThread();
+
+	Com_Init( sys_cmdline );
+
+	QuickMemTest();
+
+	_getcwd (cwd, sizeof(cwd));
+	Com_Printf("Working directory: %s\n", cwd);
+
+	// hide the early console since we've reached the point where we
+	// have a working graphics subsystems
+	if ( !com_viewlog->integer ) {
+		Sys_ShowConsole( 0, qfalse );
+	}
+
+    // main game loop
+	while( 1 ) {
+		// if not running as a game client, sleep a bit
+		if ( g_wv.isMinimized ) {
+			Sleep( 5 );
+		}
+#ifdef _DEBUG
+		if (!g_wv.activeApp)
+		{
+			Sleep(50);
+		}
+#endif // _DEBUG
+
+		// set low precision every frame, because some system calls
+		// reset it arbitrarily
+//		_controlfp( _PC_24, _MCW_PC );
+
+//		startTime = Sys_Milliseconds();
+
+		// make sure mouse and joystick are only called once a frame
+		IN_Frame();
+
+		// run the game
+		Com_Frame();
+
+//		endTime = Sys_Milliseconds();
+//		totalMsec += endTime - startTime;
+//		countMsec++;
+	}
+
+	// never gets here
+}
diff --git a/code/win32/win_main_common.cpp b/code/win32/win_main_common.cpp
new file mode 100644
index 0000000..3753dba
--- /dev/null
+++ b/code/win32/win_main_common.cpp
@@ -0,0 +1,332 @@
+// win_main.h
+
+#include "../game/q_shared.h"
+#include "../qcommon/qcommon.h"
+#include "../client/client.h"
+#include "win_local.h"
+#include "resource.h"
+
+#ifndef _GAMECUBE
+#include <errno.h>
+#include <float.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <direct.h>
+#include <io.h>
+#include <conio.h>
+#endif
+
+
+
+//#define SPANK_MONKEYS	//----(SA)	commented out for running net developer release builds
+int	sys_monkeySpank;
+
+
+/*
+==================
+Sys_MonkeyShouldBeSpanked
+==================
+*/
+int Sys_MonkeyShouldBeSpanked( void ) {
+	return sys_monkeySpank;
+}
+
+
+
+
+/*
+==================
+Sys_FunctionCmp
+==================
+*/
+int Sys_FunctionCmp(void *f1, void *f2) {
+
+	int i, j, l;
+	byte func_end[32] = {0xC3, 0x90, 0x90, 0x00};
+	byte *ptr, *ptr2;
+	byte *f1_ptr, *f2_ptr;
+
+	ptr = (byte *) f1;
+	if (*(byte *)ptr == 0xE9) {
+		//Com_Printf("f1 %p1 jmp %d\n", (int *) f1, *(int*)(ptr+1));
+		f1_ptr = (byte*)(((byte*)f1) + (*(int *)(ptr+1)) + 5);
+	}
+	else {
+		f1_ptr = ptr;
+	}
+	//Com_Printf("f1 ptr %p\n", f1_ptr);
+
+	ptr = (byte *) f2;
+	if (*(byte *)ptr == 0xE9) {
+		//Com_Printf("f2 %p jmp %d\n", (int *) f2, *(int*)(ptr+1));
+		f2_ptr = (byte*)(((byte*)f2) + (*(int *)(ptr+1)) + 5);
+	}
+	else {
+		f2_ptr = ptr;
+	}
+	//Com_Printf("f2 ptr %p\n", f2_ptr);
+
+#ifdef _DEBUG
+	sprintf((char *)func_end, "%c%c%c%c%c%c%c", 0x5F, 0x5E, 0x5B, 0x8B, 0xE5, 0x5D, 0xC3);
+#endif
+	for (i = 0; i < 1024; i++) {
+		for (j = 0; func_end[j]; j++) {
+			if (f1_ptr[i+j] != func_end[j])
+				break;
+		}
+		if (!func_end[j]) {
+			break;
+		}
+	}
+#ifdef _DEBUG
+	l = i + 7;
+#else
+	l = i + 2;
+#endif
+	//Com_Printf("function length = %d\n", l);
+
+	for (i = 0; i < l; i++) {
+		// check for a potential function call
+		if (*((byte *) &f1_ptr[i]) == 0xE8) {
+			// get the function pointers in case this really is a function call
+			ptr = (byte *) (((byte *) &f1_ptr[i]) + (*(int *) &f1_ptr[i+1])) + 5;
+			ptr2 = (byte *) (((byte *) &f2_ptr[i]) + (*(int *) &f2_ptr[i+1])) + 5;
+			// if it was a function call and both f1 and f2 call the same function
+			if (ptr == ptr2) {
+				i += 4;
+				continue;
+			}
+		}
+		if (f1_ptr[i] != f2_ptr[i])
+			return qfalse;
+	}
+	return qtrue;
+}
+
+/*
+==================
+Sys_FunctionCheckSum
+==================
+*/
+int Sys_FunctionCheckSum(void *f1) {
+
+	int i, j, l;
+	unsigned shermcrap;
+	byte func_end[32] = {0xC3, 0x90, 0x90, 0x00};
+	byte *ptr;
+	byte *f1_ptr;
+
+	ptr = (byte *) f1;
+	if (*(byte *)ptr == 0xE9) {
+		//Com_Printf("f1 %p1 jmp %d\n", (int *) f1, *(int*)(ptr+1));
+		f1_ptr = (byte*)(((byte*)f1) + (*(int *)(ptr+1)) + 5);
+	}
+	else {
+		f1_ptr = ptr;
+	}
+	//Com_Printf("f1 ptr %p\n", f1_ptr);
+
+#ifdef _DEBUG
+	sprintf((char *)func_end, "%c%c%c%c%c%c%c", 0x5F, 0x5E, 0x5B, 0x8B, 0xE5, 0x5D, 0xC3);
+#endif
+	for (i = 0; i < 1024; i++) {
+		for (j = 0; func_end[j]; j++) {
+			if (f1_ptr[i+j] != func_end[j])
+				break;
+		}
+		if (!func_end[j]) {
+			break;
+		}
+	}
+#ifdef _DEBUG
+	l = i + 7;
+#else
+	l = i + 2;
+#endif
+	//Com_Printf("function length = %d\n", l);
+	shermcrap = Com_BlockChecksum( f1_ptr, l );
+	return (int)shermcrap;
+}
+
+
+//NOTE TTimo: heavily NON PORTABLE, PLZ DON'T USE
+//  https://zerowing.idsoftware.com/bugzilla/show_bug.cgi?id=447
+#if 0
+//----(SA) added
+/*
+==============
+Sys_ShellExecute
+
+-	Windows only
+
+	Performs an operation on a specified file. 
+
+	See info on ShellExecute() for details
+  
+==============
+*/
+int Sys_ShellExecute(char *op, char *file, qboolean doexit, char *params, char *dir ) {
+	unsigned int retval;
+	char *se_op;
+	
+	// set default operation to "open"
+	if(op)	se_op = op;
+	else	se_op = "open";
+
+
+	// probably need to protect this some in the future so people have
+	// less chance of system invasion with this powerful interface
+	// (okay, not so invasive, but could be annoying/rude)
+
+
+	retval = (UINT)ShellExecute(NULL, se_op, file, params, dir, SW_NORMAL);	// only option forced by game is 'sw_normal'
+	
+	if( retval <= 32) {	// ERROR
+		Com_DPrintf("Sys_ShellExecuteERROR: %d\n", retval);
+		return retval;
+	}
+
+	if ( doexit ) {
+		// (SA) this works better for exiting cleanly...
+		Cbuf_ExecuteText( EXEC_APPEND, "quit" );
+	}
+
+	return 999;	// success
+}
+//----(SA) end
+#endif
+
+/*
+==================
+Sys_BeginProfiling
+==================
+*/
+void Sys_BeginProfiling( void ) {
+	// this is just used on the mac build
+}
+
+
+
+
+
+/*
+==============
+Sys_DefaultCDPath
+==============
+*/
+char *Sys_DefaultCDPath( void ) {
+	return "";
+}
+
+/*
+==============
+Sys_DefaultBasePath
+==============
+*/
+char *Sys_DefaultBasePath( void ) {
+	return Sys_Cwd();
+}
+
+
+
+
+/*
+========================================================================
+
+EVENT LOOP
+
+========================================================================
+*/
+
+
+sysEvent_t	eventQue[MAX_QUED_EVENTS];
+int			eventHead, eventTail;
+byte		sys_packetReceived[MAX_MSGLEN];
+
+/*
+================
+Sys_QueEvent
+
+A time of 0 will get the current time
+Ptr should either be null, or point to a block of data that can
+be freed by the game later.
+================
+*/
+void Sys_QueEvent( int time, sysEventType_t type, int value, int value2, int ptrLength, void *ptr ) {
+	sysEvent_t	*ev;
+
+	ev = &eventQue[ eventHead & MASK_QUED_EVENTS ];
+	if ( eventHead - eventTail >= MAX_QUED_EVENTS ) {
+		Com_Printf("Sys_QueEvent: overflow\n");
+		// we are discarding an event, but don't leak memory
+		if ( ev->evPtr ) {
+			Z_Free( ev->evPtr );
+		}
+		eventTail++;
+	}
+
+	eventHead++;
+
+	if ( time == 0 ) {
+		time = Sys_Milliseconds();
+	}
+
+	ev->evTime = time;
+	ev->evType = type;
+	ev->evValue = value;
+	ev->evValue2 = value2;
+	ev->evPtrLength = ptrLength;
+	ev->evPtr = ptr;
+}
+
+
+//================================================================
+
+
+/*
+=================
+Sys_Net_Restart_f
+
+Restart the network subsystem
+=================
+*/
+void Sys_Net_Restart_f( void ) {
+//	NET_Restart();
+}
+
+
+
+//=======================================================================
+
+
+void Sys_InitStreamThread( void ) {
+}
+
+void Sys_ShutdownStreamThread( void ) {
+}
+
+void Sys_BeginStreamedFile( fileHandle_t f, int readAhead ) {
+}
+
+void Sys_EndStreamedFile( fileHandle_t f ) {
+}
+
+int Sys_StreamedRead( void *buffer, int size, int count, fileHandle_t f ) {
+   return FS_Read( buffer, size * count, f );
+}
+
+void Sys_StreamSeek( fileHandle_t f, int offset, int origin ) {
+   FS_Seek( f, offset, origin );
+}
+
+
+void *Sys_InitializeCriticalSection() {
+	return (void*)-1;
+}
+
+void Sys_EnterCriticalSection(void *ptr) {
+}
+
+void Sys_LeaveCriticalSection(void *ptr) {
+}
+
diff --git a/code/win32/win_main_console.cpp b/code/win32/win_main_console.cpp
new file mode 100644
index 0000000..21a6d29
--- /dev/null
+++ b/code/win32/win_main_console.cpp
@@ -0,0 +1,584 @@
+#include "../game/q_shared.h"
+#include "../qcommon/qcommon.h"
+#include "../client/client.h"
+#include "win_local.h"
+#include "resource.h"
+#include <float.h>
+#include <stdio.h>
+#include "../game/g_public.h"
+
+#ifdef _XBOX
+#include <IO.h>
+#define NEWDECL __cdecl
+
+#ifndef FINAL_BUILD
+#include "dbg_console_xbox.h"
+#endif
+
+#endif
+
+extern int eventHead, eventTail;
+extern sysEvent_t eventQue[MAX_QUED_EVENTS];
+extern byte		sys_packetReceived[MAX_MSGLEN];
+
+void *NEWDECL operator new(size_t size)
+{
+	return Z_Malloc(size, TAG_NEWDEL, qfalse);
+}
+
+
+void *NEWDECL operator new[](size_t size)
+{
+	return Z_Malloc(size, TAG_NEWDEL, qfalse);
+}
+
+
+void NEWDECL operator delete[](void *ptr)
+{
+	if (ptr)
+		Z_Free(ptr);
+}
+
+
+void NEWDECL operator delete(void *ptr)
+{
+	if (ptr)
+		Z_Free(ptr);
+}
+
+/*
+================
+Sys_Init
+
+Called after the common systems (cvars, files, etc)
+are initialized
+================
+*/
+extern void Sys_In_Restart_f(void);
+extern void Sys_Net_Restart_f(void);
+void Sys_Init( void ) 
+{
+	Cmd_AddCommand ("in_restart", Sys_In_Restart_f);
+	Cmd_AddCommand ("net_restart", Sys_Net_Restart_f);
+}
+
+
+
+
+char *Sys_Cwd( void ) {
+	static char cwd[MAX_OSPATH];
+
+#ifdef _XBOX
+	strcpy(cwd, "d:");
+#endif
+
+#ifdef _GAMECUBE
+	strcpy(cwd, ".");
+#endif
+
+	return cwd;
+}
+
+/*
+=================
+Sys_In_Restart_f
+
+Restart the input subsystem
+=================
+*/
+void Sys_In_Restart_f( void ) {
+}
+
+
+
+/*
+=============
+Sys_Error
+
+Show the early console as an error dialog
+=============
+*/
+void Sys_Error( const char *error, ... ) {
+        va_list                argptr;
+        char                text[256];
+
+        va_start (argptr, error);
+        vsprintf (text, error, argptr);
+        va_end (argptr);
+
+#ifdef _GAMECUBE
+        printf(text);
+#else
+        OutputDebugString(text);
+#endif
+
+#if 0 // UN-PORT
+        Com_ShutdownZoneMemory();
+        Com_ShutdownHunkMemory();
+#endif
+
+        exit (1);
+}
+
+
+/*
+================
+Sys_GetEvent
+
+================
+*/
+sysEvent_t Sys_GetEvent( void ) {
+        sysEvent_t        ev;
+
+        // return if we have data
+        if ( eventHead > eventTail ) {
+                eventTail++;
+                return eventQue[ ( eventTail - 1 ) & MASK_QUED_EVENTS ];
+        }
+
+        // check for network packets
+        msg_t                netmsg;
+        MSG_Init( &netmsg, sys_packetReceived, sizeof( sys_packetReceived ) );
+
+        // return if we have data
+        if ( eventHead > eventTail ) {
+                eventTail++;
+                return eventQue[ ( eventTail - 1 ) & MASK_QUED_EVENTS ];
+        }
+
+        // create an empty event to return
+        memset( &ev, 0, sizeof( ev ) );
+        ev.evTime = Sys_Milliseconds();
+
+        return ev;
+}
+
+
+void Sys_Print(const char *msg)
+{
+#ifdef _GAMECUBE
+	printf(msg);
+#else
+	OutputDebugString(msg);
+#endif
+}
+
+/*
+==============
+Sys_Log
+==============
+*/
+void Sys_Log( const char *file, const char *msg ) {
+	Sys_Log(file, msg, strlen(msg), strchr(msg, '\n') ? true : false);
+}
+
+/*
+==============
+Sys_Log
+==============
+*/
+void Sys_Log( const char *file, const void *buffer, int size, bool flush ) {
+#ifndef FINAL_BUILD
+	static bool unableToLog = false;
+
+	// Once we've failed to write to the log files once, bail out.
+	// This lets us put release builds on DVD without recompiling.
+	if (unableToLog)
+		return;
+
+	struct FileInfo
+	{
+		char name[MAX_QPATH];
+		FILE *handle;
+	};
+
+	const int LOG_MAX_FILES = 4;
+	static FileInfo files[LOG_MAX_FILES];
+	static int num_files = 0;
+
+	FileInfo* cur = NULL;
+	for (int f = 0; f < num_files; ++f)
+	{
+		if (!stricmp(file, files[f].name))
+		{
+			cur = &files[f];
+			break;
+		}
+	}
+
+	if (cur == NULL)
+	{
+		if (num_files >= LOG_MAX_FILES)
+		{
+			Sys_Print("Too many log files!\n");
+			return;
+		}
+
+		cur = &files[num_files++];
+		strcpy(cur->name, file);
+		cur->handle = NULL;
+	}
+
+	char fullname[MAX_QPATH];
+	sprintf(fullname, "d:\\%s", cur->name);
+	if (!cur->handle)
+	{
+		cur->handle = fopen(fullname, "wb");
+		if (cur->handle == NULL)
+		{
+			Sys_Print("Unable to open log file!\n");
+			unableToLog = true;
+			return;
+		}
+	}
+
+	if (size == 1) fputc(*(char*)buffer, cur->handle);
+	else fwrite(buffer, size, 1, cur->handle);
+
+	if (flush)
+	{
+		fflush(cur->handle);
+	}
+#endif
+}
+
+#ifdef _XBOX
+HANDLE Sys_FileStreamMutex = INVALID_HANDLE_VALUE;
+#endif
+
+void Win_Init(void)
+{
+#ifdef _XBOX
+	Sys_FileStreamMutex = CreateMutex(NULL, FALSE, NULL);
+#endif
+}
+
+/*
+=====================
+
+XBE SWITCHING SUPPORT
+
+=====================
+*/
+
+// Despite what you may think, this function actually just returns
+// a value telling you if you *should* quick-boot -- ie skip intro
+// cinematics and such. Only supposed to XGetLaunchInfo once per
+// boot, so we cache the results.
+#define LAUNCH_MAGIC "J3D1"
+bool Sys_QuickStart( void )
+{
+	static bool retVal = false;
+	static bool initialized = false;
+
+	if( initialized )
+		return retVal;
+
+	initialized = true;
+
+	DWORD launchType;
+	LAUNCH_DATA ld;
+
+	if( (XGetLaunchInfo( &launchType, &ld ) != ERROR_SUCCESS) ||
+		(launchType != LDT_TITLE) ||
+		strcmp((const char *)&ld.Data[0], LAUNCH_MAGIC) )
+		return (retVal = false);
+
+	return (retVal = true);
+}
+
+void Sys_Reboot( const char *reason )
+{
+	LAUNCH_DATA ld;
+	const char *path = NULL;
+
+	memset( &ld, 0, sizeof(ld) );
+
+	if (!Q_stricmp(reason, "multiplayer"))
+	{
+		path = "d:\\jamp.xbe";
+	}
+	else
+	{
+		Com_Error( ERR_FATAL, "Unknown reboot code %s\n", reason );
+	}
+
+	// Title should not be doing ANYTHING in the background.
+	// Shutting down sound ensures that the sound thread is gone
+	S_Shutdown();
+	// Similarly, kill off the streaming thread
+	extern void Sys_StreamShutdown(void);
+	Sys_StreamShutdown();
+
+	XLaunchNewImage(path, &ld);
+
+	// This function should not return!
+	Com_Error( ERR_FATAL, "ERROR: XLaunchNewImage returned\n" );
+}
+
+
+/*
+==================
+WinMain
+
+==================
+*/
+#if defined (_XBOX)
+int __cdecl main()
+#elif defined (_GAMECUBE)
+int main(int argc, char* argv[])
+#endif
+{
+//	Z_SetFreeOSMem();
+
+	// I'm going to kill someone. This should not be necessary. No, really.
+	Direct3D_SetPushBufferSize(1024*1024, 128*1024);
+
+	// get the initial time base
+	Sys_Milliseconds();
+
+	Win_Init();
+	Com_Init( "" );
+
+	// main game loop
+	while( 1 ) {
+		IN_Frame();
+		Com_Frame();
+
+		// Poll debug console for new commands
+#ifndef FINAL_BUILD
+		DebugConsoleHandleCommands();
+#endif
+	}
+
+	return 0;
+}
+
+
+char *Sys_GetClipboardData(void) { return NULL; }
+
+void Sys_StartProcess(char *, qboolean) {}
+
+void Sys_OpenURL(char *, int) {}
+
+void Sys_Quit(void) {}
+
+void Sys_ShowConsole(int, int) {}
+
+void Sys_Mkdir(const char *) {}
+
+int Sys_LowPhysicalMemory(void) { return 0; }
+
+void Sys_FreeFileList(char **filelist)
+{
+	// All strings in a file list are allocated at once, so we just need to
+	// do two frees, one for strings, one for the pointers.
+	if ( filelist )
+	{
+		if ( filelist[0] )
+			Z_Free( filelist[0] );
+
+		Z_Free( filelist );
+	}
+}
+
+#ifdef _JK2MP
+char** Sys_ListFiles(const char *directory, const char *extension, char *filter, int *numfiles, qboolean wantsubs)
+#else
+char** Sys_ListFiles(const char *directory, const char *extension, int *numfiles, qboolean wantsubs)
+#endif
+{
+#ifdef _JK2MP
+	// MP has extra filter paramter. We don't support that.
+	if (filter)
+	{
+		assert(!"Sys_ListFiles doesn't support filter on console!");
+		return NULL;
+	}
+#endif
+
+	// Hax0red console version of Sys_ListFiles. We mangle our arguments to get a standard filename
+	// That file should exist, and contain the list of files that meet this search criteria.
+	char	listFilename[MAX_OSPATH];
+	char	*listFile, *curFile, *end;
+	int		nfiles;
+	char	**retList;
+
+	// S00per hack
+	if (strstr(directory, "d:\\base\\"))
+		directory += 8;
+
+	if (!extension)
+	{
+		extension = "";
+	}
+	else if (extension[0] == '/' && extension[1] == 0)
+	{
+		// Passing a slash as extension will find directories
+		extension = "dir";
+	}
+	else if (extension[0] == '.')
+	{
+		// Skip over leading .
+		extension++;
+	}
+
+	// Build our filename
+	Com_sprintf(listFilename, sizeof(listFilename), "%s\\_console_%s_list_", directory, extension);
+	if (FS_ReadFile( listFilename, (void**)&listFile ) <= 0)
+	{
+		if(listFile) {
+			FS_FreeFile(listFile);
+		}
+		Com_Printf( "WARNING: List file %s not found\n", listFilename );
+		if (numfiles)
+			*numfiles = 0;
+		return NULL;
+	}
+
+	// Do a first pass to count number of files in the list
+	nfiles = 0;
+	curFile = listFile;
+	while (true)
+	{
+		// Find end of line
+		end = strchr(curFile, '\r');
+		if (end)
+		{
+			// Should have a \n next -- skip them both
+			end += 2;
+		}
+		else
+		{
+			end = strchr(curFile, '\n');
+			if (end) end++;
+			else end = curFile + strlen(curFile);
+		}
+
+		// Is the line empty?  If so, we're done.
+		if (!curFile || !curFile[0]) break;
+		++nfiles;
+
+		// Advance to next line
+		curFile = end;
+	}
+
+	// Fill in caller's pointer for number of files found
+	if (numfiles) *numfiles = nfiles;
+
+	// Did we find any files at all?
+	if (nfiles == 0)
+	{
+		FS_FreeFile(listFile);
+		return NULL;
+	}
+
+	// Allocate a file list, and quick string pool, but use LISTFILES
+	retList = (char **) Z_Malloc( ( nfiles + 1 ) * sizeof( *retList ), TAG_LISTFILES, qfalse);
+	// Our string pool is actually slightly too large, but it's temporary, and that's better
+	// than slightly too small
+	char *stringPool = (char *) Z_Malloc( strlen(listFile) + 1, TAG_LISTFILES, qfalse );
+
+	// Now go through the list of files again, and fill in the list to be returned
+	nfiles = 0;
+	curFile = listFile;
+	while (true)
+	{
+		// Find end of line
+		end = strchr(curFile, '\r');
+		if (end)
+		{
+			// Should have a \n next -- skip them both
+			*end++ = '\0';
+			*end++ = '\0';
+		}
+		else
+		{
+			end = strchr(curFile, '\n');
+			if (end) *end++ = '\0';
+			else end = curFile + strlen(curFile);
+		}
+
+		// Is the line empty?  If so, we're done.
+		int curStrSize = strlen(curFile);
+		if (curStrSize < 1)
+		{
+			retList[nfiles] = NULL;
+			break;
+		}
+
+		// Alloc a small copy
+		//retList[nfiles++] = CopyString( curFile );
+		retList[nfiles++] = stringPool;
+		strcpy(stringPool, curFile);
+		stringPool += (curStrSize + 1);
+
+		// Advance to next line
+		curFile = end;
+	}
+
+	// Free the special file's buffer
+	FS_FreeFile( listFile );
+
+	return retList;
+}
+
+/*
+=================
+Sys_UnloadGame
+=================
+*/
+void Sys_UnloadGame( void ) {
+}
+
+/*
+=================
+Sys_GetGameAPI
+
+Loads the game dll
+=================
+*/
+#ifndef _JK2MP
+void *Sys_GetGameAPI (void *parms)
+{
+	extern game_export_t *GetGameAPI( game_import_t *import );
+	return GetGameAPI((game_import_t *)parms);
+}
+#endif
+
+/*
+=================
+Sys_LoadCgame
+
+Used to hook up a development dll
+=================
+*/
+// void * Sys_LoadCgame( void ) 
+#ifndef _JK2MP
+void * Sys_LoadCgame( int (**entryPoint)(int, ...), int (*systemcalls)(int, ...) )
+{
+	extern void CG_PreInit();
+	extern void cg_dllEntry( int (*syscallptr)( int arg,... ) );
+	extern int vmMain( int command, int arg0, int arg1, int arg2, int arg3, int arg4, int arg5, int arg6, int arg7 );
+	cg_dllEntry(systemcalls);
+	*entryPoint = (int (*)(int,...))vmMain;
+//	CG_PreInit();
+	return 0;
+}
+#endif
+
+/* VVFIXME: More stubs */
+qboolean Sys_FileOutOfDate( LPCSTR psFinalFileName /* dest */, LPCSTR psDataFileName /* src */ )
+{
+	return qfalse;
+}
+
+qboolean Sys_CopyFile(LPCSTR lpExistingFileName, LPCSTR lpNewFileName, qboolean bOverwrite)
+{
+	return qfalse;
+}
+
+qboolean Sys_CheckCD( void )
+{
+	return qtrue;
+}
diff --git a/code/win32/win_qal_xbox.cpp b/code/win32/win_qal_xbox.cpp
new file mode 100644
index 0000000..cb82a92
--- /dev/null
+++ b/code/win32/win_qal_xbox.cpp
@@ -0,0 +1,1301 @@
+
+/*
+ * UNPUBLISHED -- Rights  reserved  under  the  copyright  laws  of the 
+ * United States.  Use  of a copyright notice is precautionary only and 
+ * does not imply publication or disclosure.                            
+ *                                                                      
+ * THIS DOCUMENTATION CONTAINS CONFIDENTIAL AND PROPRIETARY INFORMATION 
+ * OF    VICARIOUS   VISIONS,  INC.    ANY  DUPLICATION,  MODIFICATION, 
+ * DISTRIBUTION, OR DISCLOSURE IS STRICTLY PROHIBITED WITHOUT THE PRIOR 
+ * EXPRESS WRITTEN PERMISSION OF VICARIOUS VISIONS, INC.
+ */
+
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+
+#include "win_local.h"
+
+#include "../client/openal/al.h"
+#include "../client/openal/alc.h"
+
+#include <dsound.h>
+//#include <dsstdfx.h>
+#include "snd_fx_img.h"
+
+#include <cmath>
+#include <deque>
+#include <map>
+
+#define QAL_STREAM_WAIT_TIME (500)
+#define QAL_MAX_STREAM_PACKETS (2)
+
+// About 1 second of audio at 44100, stereo, ADPCM
+#define QAL_STREAM_PACKET_SIZE (44136)
+
+// Un-comment to enable 5-channel 3-d sound mixing
+//#define _FIVE_CHANNEL
+
+extern HANDLE Sys_FileStreamMutex;
+extern const char* Sys_GetFileCodeName(int code);
+
+/***********************************************
+*
+* OpenAL STATE - Main container for all AL objects
+*
+************************************************/
+
+struct QALState
+{
+	IDirectSound8* m_SoundObject;
+	
+	ALuint m_MemoryUsed;
+	ALenum m_Error;
+	FLOAT m_Gain;
+
+	struct ListenerInfo
+	{
+		D3DXVECTOR3 m_Position;
+		D3DXMATRIX m_LTM;
+	};
+	typedef std::map<ALuint, ListenerInfo*> listener_t;
+	listener_t m_Listeners;
+	ALuint m_NextListener;
+
+	struct SourceInfo
+	{
+		typedef std::map<ALuint, IDirectSoundBuffer*> voice_t;
+		voice_t m_Voices;
+		
+		ALuint m_Buffer;
+		
+		FLOAT m_Gain;
+		bool m_GainDirty;
+
+		bool m_Loop;
+		
+		bool m_Is3d;
+		D3DXVECTOR3 m_Position;
+	};
+	typedef std::map<ALuint, SourceInfo*> source_t;
+	source_t m_Sources;
+	ALuint m_NextSource;
+
+	struct BufferInfo
+	{
+		void* m_Data;
+		DWORD m_DataOffset;
+		XBOXADPCMWAVEFORMAT m_WAVFormat;
+		
+		DWORD m_Freq;
+		DWORD m_Size;
+		
+		bool m_Valid;
+	};
+	typedef std::map<ALuint, BufferInfo*> buffer_t;
+	buffer_t m_Buffers;
+	ALuint m_NextBuffer;
+
+	struct StreamInfo
+	{
+		IDirectSoundStream* m_pVoice;
+		XFileMediaObject* m_pFile;
+
+		unsigned int m_StartTime;
+
+		bool m_Open;
+		bool m_Playing;
+		bool m_Valid;
+		
+		FLOAT m_Gain;
+		bool m_GainDirty;
+
+		bool m_Looping;
+
+		void* m_pPacketBuffer;
+		DWORD m_PacketStatus[QAL_MAX_STREAM_PACKETS];
+		DWORD m_CurrentPacket;
+
+		HANDLE m_Thread;
+		HANDLE m_Mutex;
+		HANDLE m_QueueLen;
+
+		enum RequestType
+		{
+			REQ_NOP,
+			REQ_PLAY,
+			REQ_STOP,
+			REQ_SHUTDOWN,
+		};
+
+		struct Request
+		{
+			RequestType m_Type;
+			DWORD m_Data[3];
+		};
+		
+		typedef std::deque<Request> queue_t;
+		queue_t m_Queue;
+	};
+	StreamInfo m_Stream;
+};
+
+static QALState* s_pState = NULL;
+
+
+/***********************************************
+*
+* DEVICES AND CONTEXTS
+*
+************************************************/
+
+ALCdevice* alcOpenDevice(ALCubyte *deviceName)
+{
+	if (s_pState) return NULL;
+	s_pState = new QALState;
+
+	s_pState->m_Gain = 1.f;
+	s_pState->m_Error = AL_NO_ERROR;
+	s_pState->m_MemoryUsed = 0;
+	s_pState->m_NextBuffer = 1;
+	s_pState->m_NextListener = 1;
+	s_pState->m_NextSource = 1;
+	s_pState->m_Stream.m_Valid = false;
+	
+	// init the sound hardware
+	if (DirectSoundCreate(NULL, &s_pState->m_SoundObject, NULL) != DS_OK)
+	{
+		delete s_pState;
+		return NULL;
+	}
+
+	DirectSoundUseFullHRTF();
+
+	// download effects image to hardware
+	void* image;
+	int len = FS_ReadFile("sound/dsstdfx.bin", &image);
+	if (len <= 0)
+	{
+		delete s_pState;
+		return NULL;
+	}
+	
+	LPDSEFFECTIMAGEDESC desc;
+	DSEFFECTIMAGELOC effect;
+	effect.dwI3DL2ReverbIndex = GraphI3DL2_I3DL2Reverb;
+	effect.dwCrosstalkIndex = GraphXTalk_XTalk;
+	s_pState->m_SoundObject->DownloadEffectsImage(image, len, &effect, &desc);
+
+	Z_Free(image);
+
+	// setup default reverb
+	DSI3DL2LISTENER reverb = { DSI3DL2_ENVIRONMENT_PRESET_NOREVERB };
+	s_pState->m_SoundObject->SetI3DL2Listener(&reverb, DS3D_DEFERRED);
+
+	return (ALCdevice*)s_pState->m_SoundObject;
+}
+
+ALCvoid alcCloseDevice(ALCdevice *device)
+{
+	// shutdown the sound hardware
+	s_pState->m_SoundObject->Release();
+	
+	delete s_pState;
+	s_pState = NULL;
+}
+
+ALCcontext* alcCreateContext(ALCdevice *device,ALCint *attrList)
+{
+	return (ALCcontext*)1;
+}
+
+ALCboolean alcMakeContextCurrent(ALCcontext *context)
+{
+	return true;
+}
+
+ALCcontext* alcGetCurrentContext(ALCvoid)
+{
+	return (ALCcontext*)1;
+}
+
+ALCdevice* alcGetContextsDevice(ALCcontext *context)
+{
+	if (!s_pState) return NULL;
+	return (ALCdevice*)s_pState->m_SoundObject;
+}
+
+ALCvoid alcDestroyContext(ALCcontext *context)
+{
+}
+
+ALCenum	alcGetError(ALCdevice *device)
+{
+	return ALC_NO_ERROR;
+}
+
+
+
+
+/***********************************************
+*
+* LISTENERS
+*
+************************************************/
+
+ALvoid alGenListeners( ALsizei n, ALuint* listeners )
+{
+	while (n--)
+	{
+		QALState::ListenerInfo* info = new QALState::ListenerInfo;
+
+		info->m_Position.x = 0.f;
+		info->m_Position.y = 0.f;
+		info->m_Position.z = 0.f;
+
+		D3DXMatrixIdentity(&info->m_LTM);
+		
+		s_pState->m_Listeners[s_pState->m_NextListener] = info;
+		listeners[n] = s_pState->m_NextListener++;
+	}
+}
+
+ALvoid alDeleteListeners( ALsizei n, ALuint* listeners )
+{
+	while (n--)
+	{
+		QALState::listener_t::iterator i = 
+			s_pState->m_Listeners.find(listeners[n]);
+		
+		if (i != s_pState->m_Listeners.end())
+		{
+			delete i->second;
+			s_pState->m_Listeners.erase(i);
+		}
+	}
+}
+
+ALvoid alListenerfv( ALuint listener, ALenum param, ALfloat* values )
+{
+	assert(s_pState->m_Listeners.find(listener) != 
+		s_pState->m_Listeners.end());
+	
+	QALState::ListenerInfo* info = s_pState->m_Listeners[listener];
+	D3DXVECTOR3 right;
+	D3DXMATRIX trans;
+	FLOAT det;
+	
+	switch (param)
+	{
+	case AL_POSITION:
+		info->m_Position.x = values[0];
+		info->m_Position.y = values[1];
+		info->m_Position.z = values[2];
+
+		// translation
+		D3DXMatrixTranslation(&trans, -values[0], -values[1], -values[2]);
+		D3DXMatrixMultiply(&info->m_LTM, &trans, &info->m_LTM);
+		break;
+
+	case AL_ORIENTATION:
+		D3DXMatrixIdentity(&info->m_LTM);
+
+		// at vector
+		info->m_LTM(2, 0) = values[0];
+		info->m_LTM(2, 1) = values[1];
+		info->m_LTM(2, 2) = values[2];
+
+		// up vector
+		info->m_LTM(1, 0) = values[3];
+		info->m_LTM(1, 1) = values[4];
+		info->m_LTM(1, 2) = values[5];
+		
+		// Hack. We switched the sign on values[2] up above, need to do that here
+		D3DXVec3Cross(&right, (D3DXVECTOR3*)&values[0], (D3DXVECTOR3*)&values[3]);
+		
+		// right vector
+		info->m_LTM(0, 0) = right.x;
+		info->m_LTM(0, 1) = right.y;
+		info->m_LTM(0, 2) = right.z;
+
+		// convert to local space transform
+		D3DXMatrixInverse(&info->m_LTM, &det, &info->m_LTM);
+
+		// translation
+		D3DXMatrixTranslation(&trans, 
+			-info->m_Position.x, -info->m_Position.y, -info->m_Position.z);
+		D3DXMatrixMultiply(&info->m_LTM, &trans, &info->m_LTM);
+		break;
+	}
+}
+
+
+
+
+/***********************************************
+*
+* SOURCES
+*
+************************************************/
+
+static void _wavSetFormat(XBOXADPCMWAVEFORMAT* wav, ALenum format, ALsizei freq)
+{
+	switch (format)
+	{
+	case AL_FORMAT_MONO4:
+		wav->wfx.wFormatTag = WAVE_FORMAT_XBOX_ADPCM;
+		wav->wfx.nChannels = 1;
+		wav->wfx.nSamplesPerSec = freq;
+		wav->wfx.nBlockAlign = 36 * wav->wfx.nChannels;
+		wav->wfx.nAvgBytesPerSec = wav->wfx.nSamplesPerSec * wav->wfx.nBlockAlign / 64;
+		wav->wfx.wBitsPerSample = 4;
+		wav->wfx.cbSize = sizeof(XBOXADPCMWAVEFORMAT) - sizeof(WAVEFORMATEX);
+		wav->wSamplesPerBlock = 64;
+		break;
+
+	case AL_FORMAT_STEREO4:
+		wav->wfx.wFormatTag = WAVE_FORMAT_XBOX_ADPCM;
+		wav->wfx.nChannels = 2;
+		wav->wfx.nSamplesPerSec = freq;
+		wav->wfx.nBlockAlign = 36 * wav->wfx.nChannels;
+		wav->wfx.nAvgBytesPerSec = wav->wfx.nSamplesPerSec * wav->wfx.nBlockAlign / 64;
+		wav->wfx.wBitsPerSample = 4;
+		wav->wfx.cbSize = sizeof(XBOXADPCMWAVEFORMAT) - sizeof(WAVEFORMATEX);
+		wav->wSamplesPerBlock = 64;
+		break;
+
+	case AL_FORMAT_MONO8:
+	case AL_FORMAT_STEREO8:
+	case AL_FORMAT_MONO16:
+	case AL_FORMAT_STEREO16:
+	default:
+		assert(0);
+		break;
+	}
+}
+
+static int _genSource(bool is3d)
+{
+	// alloc a new source
+	QALState::SourceInfo* sinfo = new QALState::SourceInfo;
+
+	// describe the voice
+	XBOXADPCMWAVEFORMAT wav;
+	_wavSetFormat(&wav, AL_FORMAT_MONO4, 22050);
+	
+	DSBUFFERDESC desc;
+	desc.dwSize = sizeof(desc);
+	if (is3d) desc.dwFlags = DSBCAPS_CTRL3D | DSBCAPS_MUTE3DATMAXDISTANCE;
+	else desc.dwFlags = 0;
+	desc.dwBufferBytes = 0;
+	desc.lpwfxFormat = (WAVEFORMATEX*)&wav;
+	desc.lpMixBins = NULL;
+	desc.dwInputMixBin = 0;
+
+	// create voice for all listeners
+	for (QALState::listener_t::iterator l = s_pState->m_Listeners.begin();
+	l != s_pState->m_Listeners.end(); ++l)
+	{
+		// create the voice
+		IDirectSoundBuffer* voice;
+		if (s_pState->m_SoundObject->CreateSoundBuffer(&desc, &voice, NULL) != DS_OK)
+		{
+			s_pState->m_Error = AL_OUT_OF_MEMORY;
+			return false;
+		}
+
+		sinfo->m_Voices[l->first] = voice;
+
+		// only create a single voice for 2d sounds
+		if (!is3d) break;
+	}
+
+	// setup some defaults
+	sinfo->m_Buffer = 0;
+
+	sinfo->m_Gain = 1.f;
+	sinfo->m_GainDirty = true;
+	sinfo->m_Loop = false;
+
+	sinfo->m_Is3d = is3d;
+	sinfo->m_Position.x = 0.f;
+	sinfo->m_Position.y = 0.f;
+	sinfo->m_Position.z = 0.f;
+	
+	s_pState->m_Sources[s_pState->m_NextSource] = sinfo;
+
+	return true;
+}
+
+static void _attachBuffer(ALuint source, ALuint buffer)
+{
+	assert(s_pState->m_Sources.find(source) != s_pState->m_Sources.end());
+	assert(s_pState->m_Buffers.find(buffer) != s_pState->m_Buffers.end());
+	
+	QALState::SourceInfo* sinfo = s_pState->m_Sources[source];
+	QALState::BufferInfo* binfo = s_pState->m_Buffers[buffer];
+	
+	// setup voices for all listeners
+	for (QALState::SourceInfo::voice_t::iterator v = sinfo->m_Voices.begin(); 
+	v != sinfo->m_Voices.end(); ++v)
+	{
+		v->second->SetFormat((WAVEFORMATEX*)&binfo->m_WAVFormat);
+
+#ifdef _FIVE_CHANNEL
+		DSMIXBINVOLUMEPAIR dsmbvp[6] = {
+			DSMIXBINVOLUMEPAIRS_DEFAULT_5CHANNEL_3D,
+		};
+		DSMIXBINS dsmb;
+		dsmb.dwMixBinCount = 6;
+		dsmb.lpMixBinVolumePairs = dsmbvp;
+		
+		v->second->SetMixBins(&dsmb);
+#endif
+
+		v->second->SetBufferData((char*)binfo->m_Data + binfo->m_DataOffset, binfo->m_Size);
+	}
+	
+	sinfo->m_Buffer = buffer;
+}
+
+static void _dettachBuffer(ALuint source)
+{
+	assert(s_pState->m_Sources.find(source) != s_pState->m_Sources.end());
+	
+	QALState::SourceInfo* info = s_pState->m_Sources[source];
+
+	// clear buffer on voices
+	for (QALState::SourceInfo::voice_t::iterator v = info->m_Voices.begin(); 
+	v != info->m_Voices.end(); ++v)
+	{
+		v->second->Stop();
+		v->second->SetBufferData(NULL, 0);
+	}
+
+	info->m_Buffer = 0;
+}
+
+static void _sourceSetRefDist(QALState::SourceInfo* info, FLOAT value)
+{
+	for (QALState::SourceInfo::voice_t::iterator v = info->m_Voices.begin(); 
+	v != info->m_Voices.end(); ++v)
+	{
+		// In order to prevent debug DX from complaining that
+		// the max dist is greater than the min dist, I clear
+		// the min dist _before_ setting the max.  Ug.
+		v->second->SetMinDistance(1, DS3D_DEFERRED);
+
+		// New algorithm - ref dist is supposed to be dist at which sound is 1/2 volume,
+		// which happens at double min distance in DS, thus: (reverted)
+		v->second->SetMaxDistance(value * 10.f, DS3D_DEFERRED);
+		v->second->SetMinDistance(value, DS3D_DEFERRED);
+//		v->second->SetMinDistance(value / 2.f, DS3D_DEFERRED);
+	}
+}
+
+ALvoid alGenSources2D( ALsizei n, ALuint* sources )
+{
+	while (n--)
+	{
+		if (!_genSource(false)) break;
+		sources[n] = s_pState->m_NextSource++;
+	}
+}
+
+ALvoid alGenSources3D( ALsizei n, ALuint* sources )
+{
+	while (n--)
+	{
+		if (!_genSource(true)) break;
+		sources[n] = s_pState->m_NextSource++;
+	}
+}
+
+ALvoid alDeleteSources( ALsizei n, ALuint* sources )
+{
+	while (n--)
+	{
+		QALState::source_t::iterator i = 
+			s_pState->m_Sources.find(sources[n]);
+
+		if (i != s_pState->m_Sources.end())
+		{
+			QALState::SourceInfo* info = i->second;
+
+			// stop using any buffers
+			_dettachBuffer(sources[n]);			
+
+			// free associated voices
+			for (QALState::SourceInfo::voice_t::iterator v = info->m_Voices.begin(); 
+			v != info->m_Voices.end(); ++v)
+			{
+				v->second->Release();
+			}
+			
+			delete info;
+			s_pState->m_Sources.erase(i);
+		}
+	}
+}
+
+ALvoid alSourcei( ALuint source, ALenum param, ALint value )
+{
+	assert(s_pState->m_Sources.find(source) != s_pState->m_Sources.end());
+
+	switch (param)
+	{
+	case AL_LOOPING:
+		s_pState->m_Sources[source]->m_Loop = value;
+		break;
+
+	case AL_BUFFER:
+		if (value) _attachBuffer(source, value);
+		break;
+
+	default:
+		assert(0);
+		break;
+	}
+}
+
+ALvoid alSourcef( ALuint source, ALenum param, ALfloat value )
+{
+	assert(s_pState->m_Sources.find(source) != s_pState->m_Sources.end());
+	
+	QALState::SourceInfo* info = s_pState->m_Sources[source];
+
+	switch (param)
+	{
+	case AL_REFERENCE_DISTANCE:
+		_sourceSetRefDist(info, value);
+		break;
+	case AL_GAIN:
+		info->m_Gain = value;
+		info->m_GainDirty = true;
+		break;
+	default:
+		assert(0);
+		break;
+	}
+}
+
+ALvoid alSourcefv( ALuint source, ALenum param, ALfloat* values )
+{
+	assert(s_pState->m_Sources.find(source) != s_pState->m_Sources.end());
+	
+	QALState::SourceInfo* info = s_pState->m_Sources[source];
+
+	switch (param)
+	{
+	case AL_POSITION:
+		assert(info->m_Is3d);
+		info->m_Position.x = values[0];
+		info->m_Position.y = values[1];
+		info->m_Position.z = values[2];
+		break;
+	default:
+		assert(0);
+		break;
+	}
+}
+
+ALvoid alSourceStop( ALuint source )
+{
+	assert(s_pState->m_Sources.find(source) != s_pState->m_Sources.end());
+	
+	QALState::SourceInfo* info = s_pState->m_Sources[source];
+
+	// stop playing for all listeners
+	for (QALState::SourceInfo::voice_t::iterator v = info->m_Voices.begin(); 
+	v != info->m_Voices.end(); ++v)
+	{
+		v->second->Stop();
+		
+		DWORD status = 1;		// Wait for voice to turn off
+		do { 
+			v->second->GetStatus(&status);
+		} while (status != 0);
+			
+	}
+}
+
+ALvoid alSourcePlay( ALuint source )
+{
+	assert(s_pState->m_Sources.find(source) != s_pState->m_Sources.end());
+	
+	QALState::SourceInfo* info = s_pState->m_Sources[source];
+
+	if (!info->m_Buffer)
+	{
+		return;
+	}
+
+	// start playing for all listeners
+	for (QALState::SourceInfo::voice_t::iterator v = info->m_Voices.begin(); 
+	v != info->m_Voices.end(); ++v)
+	{
+		v->second->SetCurrentPosition(0);
+		v->second->Play(0, 0, info->m_Loop ? DSBPLAY_LOOPING : 0);
+	}
+}
+
+ALvoid alGetSourcei( ALuint source, ALenum param, ALint* value )
+{
+	assert(s_pState->m_Sources.find(source) != s_pState->m_Sources.end());
+	
+	QALState::SourceInfo* info = s_pState->m_Sources[source];
+
+	switch (param)
+	{
+	case AL_SOURCE_STATE:
+		{
+			DWORD status;
+			info->m_Voices.begin()->second->GetStatus(&status);
+			*value = (status & DSBSTATUS_PLAYING) ? AL_PLAYING : AL_STOPPED;
+		}
+		break;
+	default:
+		assert(0);
+		break;
+	}
+}
+
+
+
+
+/***********************************************
+*
+* BUFFERS
+*
+************************************************/
+
+ALvoid alGenBuffers( ALsizei n, ALuint* buffers )
+{
+	while (n--)
+	{
+		QALState::BufferInfo* info = new QALState::BufferInfo;
+
+		info->m_Valid = false;
+
+		s_pState->m_Buffers[s_pState->m_NextBuffer] = info;
+		buffers[n] = s_pState->m_NextBuffer++;
+	}
+}
+
+ALvoid alDeleteBuffers( ALsizei n, ALuint* buffers )
+{
+	while (n--)
+	{
+		QALState::buffer_t::iterator b = 
+			s_pState->m_Buffers.find(buffers[n]);
+
+		// check if the buffer exists
+		if (b != s_pState->m_Buffers.end())
+		{
+			QALState::BufferInfo* binfo = b->second;
+			
+			if (binfo->m_Valid)
+			{
+				// dettach buffer from any sources using it (may block)
+				for (QALState::source_t::iterator s = s_pState->m_Sources.begin();
+				s != s_pState->m_Sources.end(); ++s)
+				{
+					QALState::SourceInfo* sinfo = s->second;
+					if (sinfo->m_Buffer == buffers[n])
+					{
+						_dettachBuffer(s->first);
+					}
+				}
+			
+				// free the memory
+				Z_Free(binfo->m_Data);
+				s_pState->m_MemoryUsed -= binfo->m_Size;
+			}
+		
+			delete b->second;
+			s_pState->m_Buffers.erase(b);
+		}
+	}
+}
+
+ALvoid alBufferData( ALuint buffer, ALenum format, ALvoid* data, ALsizei size, ALsizei freq )
+{
+	assert(s_pState->m_Buffers.find(buffer) != s_pState->m_Buffers.end());
+	
+	QALState::BufferInfo* info = s_pState->m_Buffers[buffer];
+	
+	// if this buffer has been used before, clear the old data
+	if (info->m_Valid)
+	{
+		Z_Free(info->m_Data);
+		s_pState->m_MemoryUsed -= info->m_Size;
+		info->m_Valid = false;
+	}
+
+	info->m_Data = data;
+
+	// assume we have a wave file...
+	WAVEFORMATEX* wav = (WAVEFORMATEX*)((char*)data + 20);
+	info->m_DataOffset = 20 + sizeof(WAVEFORMATEX) + wav->cbSize + 8;
+
+	info->m_Size = size;
+	s_pState->m_MemoryUsed += info->m_Size;
+
+	_wavSetFormat(&info->m_WAVFormat, format, freq);
+	
+	info->m_Valid = true;
+}
+
+
+/***********************************************
+*
+* STREAMS
+*
+************************************************/
+
+static int _streamFromFile(void)
+{
+	DWORD total = 0;
+	DWORD used = 0;
+	
+	// setup a media packet for reading from the file
+	XMEDIAPACKET xmp;
+	ZeroMemory(&xmp, sizeof(xmp));
+	xmp.pvBuffer = (BYTE *)s_pState->m_Stream.m_pPacketBuffer +
+		(QAL_STREAM_PACKET_SIZE * s_pState->m_Stream.m_CurrentPacket);
+	xmp.dwMaxSize = QAL_STREAM_PACKET_SIZE;
+	xmp.pdwCompletedSize = &used;
+	
+	WaitForSingleObject(Sys_FileStreamMutex, INFINITE);
+
+	// loop until we have a full packet of data
+	while (total < QAL_STREAM_PACKET_SIZE)
+	{
+		if (DS_OK != s_pState->m_Stream.m_pFile->Process(NULL, &xmp))
+		{
+			ReleaseMutex(Sys_FileStreamMutex);
+			return -1;
+		}
+		
+		total += used;
+		
+		// did we get enough data?
+		if (used < xmp.dwMaxSize)
+		{
+			if (s_pState->m_Stream.m_Looping)
+			{
+				// must have reached the end of the file, loop back
+				// around to the beginning and get more data
+				xmp.pvBuffer  = (BYTE*)xmp.pvBuffer + used;
+				xmp.dwMaxSize = xmp.dwMaxSize - used;
+				
+				if (DS_OK != s_pState->m_Stream.m_pFile->Seek(
+					0, FILE_BEGIN, NULL))
+				{
+					ReleaseMutex(Sys_FileStreamMutex);
+					return -1;
+				}
+			}
+			else
+			{
+				// reached end, finish up
+				s_pState->m_Stream.m_Playing = false;
+				ReleaseMutex(Sys_FileStreamMutex);
+				return used;
+			}
+		}
+	}
+
+	ReleaseMutex(Sys_FileStreamMutex);
+
+	return QAL_STREAM_PACKET_SIZE;
+}
+
+static void _streamToVoice(int size)
+{
+	// setup a packet with the current data
+	XMEDIAPACKET xmp;
+	ZeroMemory(&xmp, sizeof(xmp));
+	xmp.pvBuffer = (BYTE *)s_pState->m_Stream.m_pPacketBuffer +
+		(QAL_STREAM_PACKET_SIZE * s_pState->m_Stream.m_CurrentPacket);
+	xmp.dwMaxSize = size;
+	xmp.pdwStatus = &s_pState->m_Stream.m_PacketStatus[
+		s_pState->m_Stream.m_CurrentPacket];
+
+	// sent to the voice
+	s_pState->m_Stream.m_pVoice->Process(&xmp, NULL);
+
+	// make sure we're playing
+	s_pState->m_Stream.m_pVoice->Pause(DSSTREAMPAUSE_RESUME);
+	if (s_pState->m_Stream.m_StartTime == 0)
+	{
+		s_pState->m_Stream.m_StartTime = Sys_Milliseconds();
+	}
+}
+
+static void _streamFill(void)
+{
+	// do we have any free packets?
+	if (XMEDIAPACKET_STATUS_PENDING !=
+		s_pState->m_Stream.m_PacketStatus[s_pState->m_Stream.m_CurrentPacket])
+	{
+		// get some data
+		int size = _streamFromFile();
+		if (size > 0)
+		{
+			_streamToVoice(size);
+	
+			// next packet...
+			++s_pState->m_Stream.m_CurrentPacket;
+			s_pState->m_Stream.m_CurrentPacket %= QAL_MAX_STREAM_PACKETS;
+		}
+
+		if (!s_pState->m_Stream.m_Playing)
+		{
+			// Non-looping stream finished playback
+			s_pState->m_Stream.m_pVoice->Discontinuity();
+		}
+	}
+}
+
+static void _streamOpen(DWORD file, DWORD offset, bool loop)
+{
+	if (s_pState->m_Stream.m_Open)
+	{
+		// if a stream is current playing, interrupt it
+		s_pState->m_Stream.m_pVoice->Flush();
+		s_pState->m_Stream.m_pFile->Release();
+		s_pState->m_Stream.m_Playing = false;
+		s_pState->m_Stream.m_Open = false;
+	}
+
+	const char* name = Sys_GetFileCodeName(file);
+	
+	WaitForSingleObject(Sys_FileStreamMutex, INFINITE);
+
+	// open the file for streaming
+	LPCWAVEFORMATEX fmt;
+	if (DS_OK == XWaveFileCreateMediaObject(
+		name, &fmt, &s_pState->m_Stream.m_pFile))
+	{
+		// set the voice based on the file format
+		s_pState->m_Stream.m_pVoice->SetFormat(fmt);
+
+#ifdef _FIVE_CHANNEL
+		DSMIXBINVOLUMEPAIR dsmbvp[6] = {
+			DSMIXBINVOLUMEPAIRS_DEFAULT_5CHANNEL_3D,
+		};
+		DSMIXBINS dsmb;
+		dsmb.dwMixBinCount = 6;
+		dsmb.lpMixBinVolumePairs = dsmbvp;
+
+		s_pState->m_Stream.m_pVoice->SetMixBins(&dsmb);
+#endif
+
+		// seek the requested start position
+		s_pState->m_Stream.m_pFile->Seek(RoundDown(offset, 72), 
+			FILE_BEGIN, NULL);
+		
+		s_pState->m_Stream.m_StartTime = 0;
+		s_pState->m_Stream.m_Looping = loop;
+		s_pState->m_Stream.m_Playing = true;
+		s_pState->m_Stream.m_Open = true;
+	}
+
+	ReleaseMutex(Sys_FileStreamMutex);
+}
+
+static void _streamClose(void)
+{
+	if (s_pState->m_Stream.m_Open)
+	{
+		// stop the stream
+		s_pState->m_Stream.m_pVoice->Flush();
+		s_pState->m_Stream.m_pFile->Release();
+		s_pState->m_Stream.m_Playing = false;
+		s_pState->m_Stream.m_Open = false;
+	}
+}
+
+static DWORD WINAPI _streamThread(LPVOID lpParameter)
+{
+	for (;;)
+	{
+		QALState::StreamInfo* strm = &s_pState->m_Stream;
+		QALState::StreamInfo::Request req;
+		
+		// Wait for the queue to fill
+		WaitForSingleObject(strm->m_QueueLen, QAL_STREAM_WAIT_TIME);
+		
+		// Grab the next request
+		WaitForSingleObject(strm->m_Mutex, INFINITE);
+		if (!strm->m_Queue.empty())
+		{
+			req = strm->m_Queue.front();
+			strm->m_Queue.pop_front();
+		}
+		else
+		{
+			req.m_Type = QALState::StreamInfo::REQ_NOP;
+		}
+		ReleaseMutex(strm->m_Mutex);
+
+		// Process request
+		switch (req.m_Type)
+		{
+		case QALState::StreamInfo::REQ_PLAY:
+			_streamOpen(req.m_Data[0], req.m_Data[1], req.m_Data[2]);
+			break;
+
+		case QALState::StreamInfo::REQ_STOP:
+			_streamClose();
+			break;
+
+		case QALState::StreamInfo::REQ_SHUTDOWN:
+			ExitThread(0);
+			break;
+
+		case QALState::StreamInfo::REQ_NOP:
+			break;
+		}
+
+		// fill the stream with data
+		if (strm->m_Open && strm->m_Playing)
+		{
+			_streamFill();
+		}
+	}
+}
+
+static void _postStreamRequest(const QALState::StreamInfo::Request& req)
+{
+	// Add request to queue
+	WaitForSingleObject(s_pState->m_Stream.m_Mutex, INFINITE);
+	s_pState->m_Stream.m_Queue.push_back(req);
+	ReleaseMutex(s_pState->m_Stream.m_Mutex);
+
+	// Let thread know it has one more pending request
+	ReleaseSemaphore(s_pState->m_Stream.m_QueueLen, 1, NULL);
+
+	// Give the stream thread some CPU
+	Sleep(0);
+}
+
+ALvoid alGenStream( ALvoid )
+{
+	assert(!s_pState->m_Stream.m_Valid);
+	
+	// describe the stream
+	XBOXADPCMWAVEFORMAT wav;
+	_wavSetFormat(&wav, AL_FORMAT_STEREO4, 44100);
+	
+	DSSTREAMDESC desc;
+	ZeroMemory(&desc, sizeof(desc));
+	desc.dwMaxAttachedPackets = QAL_MAX_STREAM_PACKETS;
+	desc.lpwfxFormat = (WAVEFORMATEX*)&wav;
+	
+	// create a voice for the stream
+	if (s_pState->m_SoundObject->CreateSoundStream(&desc, 
+		&s_pState->m_Stream.m_pVoice, NULL) != DS_OK)
+	{
+		s_pState->m_Error = AL_OUT_OF_MEMORY;
+		return;
+	}
+
+	// get some memory to hold the stream data
+	s_pState->m_Stream.m_pPacketBuffer = 
+		XPhysicalAlloc(QAL_MAX_STREAM_PACKETS * QAL_STREAM_PACKET_SIZE,
+		MAXULONG_PTR, 0, PAGE_READWRITE | PAGE_NOCACHE);
+
+	// setup some defaults
+	s_pState->m_Stream.m_Gain = 1.f;
+	s_pState->m_Stream.m_GainDirty = true;
+
+	s_pState->m_Stream.m_CurrentPacket = 0;
+	for (int p = 0; p < QAL_MAX_STREAM_PACKETS; ++p)
+	{
+		s_pState->m_Stream.m_PacketStatus[p] = XMEDIAPACKET_STATUS_SUCCESS;
+	}
+
+	s_pState->m_Stream.m_Open = false;
+	s_pState->m_Stream.m_Playing = false;
+	s_pState->m_Stream.m_Valid = true;
+
+	// setup a thread to service the stream (keep blocking IO out
+	// of the main thread)
+	s_pState->m_Stream.m_QueueLen = CreateSemaphore(NULL, 0, 256, NULL);
+	s_pState->m_Stream.m_Mutex = CreateMutex(NULL, FALSE, NULL);
+	s_pState->m_Stream.m_Thread = CreateThread(NULL, 64*1024, 
+		_streamThread, NULL, 0, NULL );
+}
+
+ALvoid alDeleteStream( ALvoid )
+{
+	assert(s_pState->m_Stream.m_Valid);
+	
+	// stop the audio
+	alStreamStop();
+
+	// kill the thread
+	QALState::StreamInfo::Request req;
+	req.m_Type = QALState::StreamInfo::REQ_SHUTDOWN;
+	_postStreamRequest(req);
+	
+	// Wait for thread to close
+	WaitForSingleObject(s_pState->m_Stream.m_Thread, INFINITE);
+
+	// thread handles
+	CloseHandle(s_pState->m_Stream.m_Thread);
+	CloseHandle(s_pState->m_Stream.m_Mutex);
+	CloseHandle(s_pState->m_Stream.m_QueueLen);
+
+	// release the stream
+	s_pState->m_Stream.m_pVoice->Release();
+	XPhysicalFree(s_pState->m_Stream.m_pPacketBuffer);
+
+	s_pState->m_Stream.m_Valid = false;
+}
+
+ALvoid alStreamStop( ALvoid )
+{
+	assert(s_pState->m_Stream.m_Valid);
+
+	QALState::StreamInfo::Request req;
+	req.m_Type = QALState::StreamInfo::REQ_STOP;
+	_postStreamRequest(req);	
+}
+
+ALvoid alStreamPlay( ALsizei offset, ALint file, ALint loop )
+{
+	assert(s_pState->m_Stream.m_Valid);
+
+	QALState::StreamInfo::Request req;
+	req.m_Type = QALState::StreamInfo::REQ_PLAY;
+	req.m_Data[0] = file;
+	req.m_Data[1] = offset;
+	req.m_Data[2] = loop;
+	_postStreamRequest(req);
+
+	s_pState->m_Stream.m_Playing = true;
+}
+
+ALvoid alStreamf( ALenum param, ALfloat value )
+{
+	assert(s_pState->m_Stream.m_Valid);
+
+	switch (param)
+	{
+	case AL_GAIN:
+		s_pState->m_Stream.m_Gain = value;
+		s_pState->m_Stream.m_GainDirty = true;
+		break;
+	default:
+		assert(0);
+		break;
+	}
+}
+
+ALvoid alGetStreamf( ALenum param, ALfloat* value )
+{
+	assert(s_pState->m_Stream.m_Valid);
+
+	switch (param)
+	{
+	case AL_TIME:
+		if (s_pState->m_Stream.m_Open && s_pState->m_Stream.m_StartTime)
+		{
+			*value = (float)(Sys_Milliseconds() - 
+				s_pState->m_Stream.m_StartTime) / 1000.f;
+		}
+		else
+		{
+			*value = 0.f;
+		}
+		break;
+	default:
+		assert(0);
+		break;
+	}
+}
+
+ALvoid alGetStreami( ALenum param, ALint* value )
+{
+	assert(s_pState->m_Stream.m_Valid);
+
+	switch (param)
+	{
+	case AL_SOURCE_STATE:
+		*value = s_pState->m_Stream.m_Playing ? AL_PLAYING : AL_STOPPED;
+		break;
+	default:
+		assert(0);
+		break;
+	}
+}
+
+
+
+/***********************************************
+*
+* ADDITIONAL FUNCTIONS
+*
+************************************************/
+
+static void _updateVoiceGain(IDirectSoundBuffer* voice, FLOAT gain)
+{
+	// compute aggregate gain
+	FLOAT g = s_pState->m_Gain * gain;
+	
+	if (g <= 0.f)
+	{
+		// mute the sound
+		voice->SetVolume(DSBVOLUME_MIN);
+	}
+	else
+	{
+		// convert to dB
+		g = 20.f * log10(g);
+
+		if(g < -100.0f) {
+			g = -100.0f;
+		}
+
+		// set the volume
+		voice->SetVolume(g * 100.f);
+	}
+}
+
+static void _updateVoicePos(IDirectSoundBuffer* voice, D3DXVECTOR3* pos,
+	QALState::ListenerInfo* listener)
+{
+	// get source pos in listener space
+	D3DXVECTOR4 lpos;
+	D3DXVec3Transform(&lpos, pos, &listener->m_LTM);
+
+	voice->SetPosition(lpos.x, lpos.y, lpos.z, DS3D_DEFERRED);
+}
+
+static void _updateSource(QALState::SourceInfo* source)
+{
+	// loop through all the voices at this source
+	for (QALState::SourceInfo::voice_t::iterator v = source->m_Voices.begin(); 
+	v != source->m_Voices.end(); ++v)
+	{
+		// update the gain
+		if (source->m_GainDirty)
+		{
+			_updateVoiceGain(v->second, source->m_Gain);
+		}
+
+		// update position
+		if (source->m_Is3d)
+		{
+			// get the listener for this voice
+			QALState::listener_t::iterator l = s_pState->m_Listeners.find(v->first);
+
+			if (l != s_pState->m_Listeners.end())
+			{
+				_updateVoicePos(
+					v->second,
+					&source->m_Position, 
+					l->second);
+			}
+		}
+	}
+
+	source->m_GainDirty = false;
+}
+
+static void _updateStream(void)
+{
+	if (s_pState->m_Stream.m_Open && s_pState->m_Stream.m_GainDirty)
+	{
+		// compute aggregate gain
+		FLOAT g = s_pState->m_Gain * s_pState->m_Stream.m_Gain;
+		if (g <= 0.f)
+		{
+			// mute the sound
+			s_pState->m_Stream.m_pVoice->SetVolume(DSBVOLUME_MIN);
+		}
+		else
+		{
+			// convert to dB
+			g = 20.f * log10(g);
+
+			if(g < -100.0f) {
+				g = -100.0f;
+			}
+
+			// set the volume
+			s_pState->m_Stream.m_pVoice->SetVolume(g * 100.f);
+		}
+
+		s_pState->m_Stream.m_GainDirty = false;
+	}
+}
+
+ALenum alGetError( ALvoid )
+{
+	ALenum error = s_pState->m_Error;
+	s_pState->m_Error = AL_NO_ERROR;
+	return error;
+}
+
+ALvoid alUpdate( ALvoid )
+{
+	DirectSoundDoWork();
+
+	// update sources
+	for (QALState::source_t::iterator i = s_pState->m_Sources.begin();
+	i != s_pState->m_Sources.end(); ++i)
+	{
+		QALState::SourceInfo* info = i->second;
+		
+		// 3d sounds and dirty sources must be updated
+		if (info->m_Is3d || info->m_GainDirty)
+		{
+			// only playing sources should be updated
+			DWORD status;
+			info->m_Voices.begin()->second->GetStatus(&status);
+
+			if (status & DSBSTATUS_PLAYING)
+			{
+				_updateSource(info);
+			}
+		}
+	}
+
+	// update stream
+	_updateStream();
+
+	s_pState->m_SoundObject->CommitDeferredSettings();
+}
+
+ALvoid alGeti( ALenum param, ALint* value )
+{
+	switch (param)
+	{
+	case AL_MEMORY_USED:
+		*value = s_pState->m_MemoryUsed;
+		break;
+
+	default:
+		assert(0);
+	}
+}
+
+ALvoid alGain( ALfloat value )
+{
+	s_pState->m_Gain = value;
+
+	// set gain dirty for all sources
+	for (QALState::source_t::iterator i = s_pState->m_Sources.begin();
+	i != s_pState->m_Sources.end(); ++i)
+	{
+		i->second->m_GainDirty = true;
+	}
+
+	// set gain dirty for stream
+	s_pState->m_Stream.m_GainDirty = true;
+}
diff --git a/code/win32/win_qgl.cpp b/code/win32/win_qgl.cpp
new file mode 100644
index 0000000..f488748
--- /dev/null
+++ b/code/win32/win_qgl.cpp
@@ -0,0 +1,4276 @@
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+
+/*
+** QGL_WIN.C
+**
+** This file implements the operating system binding of GL to QGL function
+** pointers.  When doing a port of Quake3 you must implement the following
+** two functions:
+**
+** QGL_Init() - loads libraries, assigns function pointers, etc.
+** QGL_Shutdown() - unloads libraries, NULLs function pointers
+*/
+#include <float.h>
+#include "../renderer/tr_local.h"
+#include "glw_win.h"
+
+void QGL_EnableLogging( qboolean enable );
+
+int ( WINAPI * qwglSwapIntervalEXT)( int interval );
+
+BOOL  ( WINAPI * qwglCopyContext)(HGLRC, HGLRC, UINT);
+HGLRC ( WINAPI * qwglCreateContext)(HDC);
+HGLRC ( WINAPI * qwglCreateLayerContext)(HDC, int);
+BOOL  ( WINAPI * qwglDeleteContext)(HGLRC);
+HGLRC ( WINAPI * qwglGetCurrentContext)(VOID);
+HDC   ( WINAPI * qwglGetCurrentDC)(VOID);
+PROC  ( WINAPI * qwglGetProcAddress)(LPCSTR);
+BOOL  ( WINAPI * qwglMakeCurrent)(HDC, HGLRC);
+BOOL  ( WINAPI * qwglShareLists)(HGLRC, HGLRC);
+BOOL  ( WINAPI * qwglUseFontBitmaps)(HDC, DWORD, DWORD, DWORD);
+
+BOOL  ( WINAPI * qwglUseFontOutlines)(HDC, DWORD, DWORD, DWORD, FLOAT,
+                                           FLOAT, int, LPGLYPHMETRICSFLOAT);
+
+BOOL ( WINAPI * qwglDescribeLayerPlane)(HDC, int, int, UINT,
+                                            LPLAYERPLANEDESCRIPTOR);
+int  ( WINAPI * qwglSetLayerPaletteEntries)(HDC, int, int, int,
+                                                CONST COLORREF *);
+int  ( WINAPI * qwglGetLayerPaletteEntries)(HDC, int, int, int,
+                                                COLORREF *);
+BOOL ( WINAPI * qwglRealizeLayerPalette)(HDC, int, BOOL);
+BOOL ( WINAPI * qwglSwapLayerBuffers)(HDC, UINT);
+
+void ( APIENTRY * qglAccum )(GLenum op, GLfloat value);
+void ( APIENTRY * qglAlphaFunc )(GLenum func, GLclampf ref);
+GLboolean ( APIENTRY * qglAreTexturesResident )(GLsizei n, const GLuint *textures, GLboolean *residences);
+void ( APIENTRY * qglArrayElement )(GLint i);
+void ( APIENTRY * qglBegin )(GLenum mode);
+void ( APIENTRY * qglBindTexture )(GLenum target, GLuint texture);
+void ( APIENTRY * qglBitmap )(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap);
+void ( APIENTRY * qglBlendFunc )(GLenum sfactor, GLenum dfactor);
+void ( APIENTRY * qglCallList )(GLuint list);
+void ( APIENTRY * qglCallLists )(GLsizei n, GLenum type, const GLvoid *lists);
+void ( APIENTRY * qglClear )(GLbitfield mask);
+void ( APIENTRY * qglClearAccum )(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
+void ( APIENTRY * qglClearColor )(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
+void ( APIENTRY * qglClearDepth )(GLclampd depth);
+void ( APIENTRY * qglClearIndex )(GLfloat c);
+void ( APIENTRY * qglClearStencil )(GLint s);
+void ( APIENTRY * qglClipPlane )(GLenum plane, const GLdouble *equation);
+void ( APIENTRY * qglColor3b )(GLbyte red, GLbyte green, GLbyte blue);
+void ( APIENTRY * qglColor3bv )(const GLbyte *v);
+void ( APIENTRY * qglColor3d )(GLdouble red, GLdouble green, GLdouble blue);
+void ( APIENTRY * qglColor3dv )(const GLdouble *v);
+void ( APIENTRY * qglColor3f )(GLfloat red, GLfloat green, GLfloat blue);
+void ( APIENTRY * qglColor3fv )(const GLfloat *v);
+void ( APIENTRY * qglColor3i )(GLint red, GLint green, GLint blue);
+void ( APIENTRY * qglColor3iv )(const GLint *v);
+void ( APIENTRY * qglColor3s )(GLshort red, GLshort green, GLshort blue);
+void ( APIENTRY * qglColor3sv )(const GLshort *v);
+void ( APIENTRY * qglColor3ub )(GLubyte red, GLubyte green, GLubyte blue);
+void ( APIENTRY * qglColor3ubv )(const GLubyte *v);
+void ( APIENTRY * qglColor3ui )(GLuint red, GLuint green, GLuint blue);
+void ( APIENTRY * qglColor3uiv )(const GLuint *v);
+void ( APIENTRY * qglColor3us )(GLushort red, GLushort green, GLushort blue);
+void ( APIENTRY * qglColor3usv )(const GLushort *v);
+void ( APIENTRY * qglColor4b )(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha);
+void ( APIENTRY * qglColor4bv )(const GLbyte *v);
+void ( APIENTRY * qglColor4d )(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha);
+void ( APIENTRY * qglColor4dv )(const GLdouble *v);
+void ( APIENTRY * qglColor4f )(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
+void ( APIENTRY * qglColor4fv )(const GLfloat *v);
+void ( APIENTRY * qglColor4i )(GLint red, GLint green, GLint blue, GLint alpha);
+void ( APIENTRY * qglColor4iv )(const GLint *v);
+void ( APIENTRY * qglColor4s )(GLshort red, GLshort green, GLshort blue, GLshort alpha);
+void ( APIENTRY * qglColor4sv )(const GLshort *v);
+void ( APIENTRY * qglColor4ub )(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha);
+void ( APIENTRY * qglColor4ubv )(const GLubyte *v);
+void ( APIENTRY * qglColor4ui )(GLuint red, GLuint green, GLuint blue, GLuint alpha);
+void ( APIENTRY * qglColor4uiv )(const GLuint *v);
+void ( APIENTRY * qglColor4us )(GLushort red, GLushort green, GLushort blue, GLushort alpha);
+void ( APIENTRY * qglColor4usv )(const GLushort *v);
+void ( APIENTRY * qglColorMask )(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
+void ( APIENTRY * qglColorMaterial )(GLenum face, GLenum mode);
+void ( APIENTRY * qglColorPointer )(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
+void ( APIENTRY * qglCopyPixels )(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type);
+void ( APIENTRY * qglCopyTexImage1D )(GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border);
+void ( APIENTRY * qglCopyTexImage2D )(GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
+void ( APIENTRY * qglCopyTexSubImage1D )(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);
+void ( APIENTRY * qglCopyTexSubImage2D )(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
+void ( APIENTRY * qglCullFace )(GLenum mode);
+void ( APIENTRY * qglDeleteLists )(GLuint list, GLsizei range);
+void ( APIENTRY * qglDeleteTextures )(GLsizei n, const GLuint *textures);
+void ( APIENTRY * qglDepthFunc )(GLenum func);
+void ( APIENTRY * qglDepthMask )(GLboolean flag);
+void ( APIENTRY * qglDepthRange )(GLclampd zNear, GLclampd zFar);
+void ( APIENTRY * qglDisable )(GLenum cap);
+void ( APIENTRY * qglDisableClientState )(GLenum array);
+void ( APIENTRY * qglDrawArrays )(GLenum mode, GLint first, GLsizei count);
+void ( APIENTRY * qglDrawBuffer )(GLenum mode);
+void ( APIENTRY * qglDrawElements )(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices);
+void ( APIENTRY * qglDrawPixels )(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
+void ( APIENTRY * qglEdgeFlag )(GLboolean flag);
+void ( APIENTRY * qglEdgeFlagPointer )(GLsizei stride, const GLvoid *pointer);
+void ( APIENTRY * qglEdgeFlagv )(const GLboolean *flag);
+void ( APIENTRY * qglEnable )(GLenum cap);
+void ( APIENTRY * qglEnableClientState )(GLenum array);
+void ( APIENTRY * qglEnd )(void);
+void ( APIENTRY * qglEndList )(void);
+void ( APIENTRY * qglEvalCoord1d )(GLdouble u);
+void ( APIENTRY * qglEvalCoord1dv )(const GLdouble *u);
+void ( APIENTRY * qglEvalCoord1f )(GLfloat u);
+void ( APIENTRY * qglEvalCoord1fv )(const GLfloat *u);
+void ( APIENTRY * qglEvalCoord2d )(GLdouble u, GLdouble v);
+void ( APIENTRY * qglEvalCoord2dv )(const GLdouble *u);
+void ( APIENTRY * qglEvalCoord2f )(GLfloat u, GLfloat v);
+void ( APIENTRY * qglEvalCoord2fv )(const GLfloat *u);
+void ( APIENTRY * qglEvalMesh1 )(GLenum mode, GLint i1, GLint i2);
+void ( APIENTRY * qglEvalMesh2 )(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2);
+void ( APIENTRY * qglEvalPoint1 )(GLint i);
+void ( APIENTRY * qglEvalPoint2 )(GLint i, GLint j);
+void ( APIENTRY * qglFeedbackBuffer )(GLsizei size, GLenum type, GLfloat *buffer);
+void ( APIENTRY * qglFinish )(void);
+void ( APIENTRY * qglFlush )(void);
+void ( APIENTRY * qglFogf )(GLenum pname, GLfloat param);
+void ( APIENTRY * qglFogfv )(GLenum pname, const GLfloat *params);
+void ( APIENTRY * qglFogi )(GLenum pname, GLint param);
+void ( APIENTRY * qglFogiv )(GLenum pname, const GLint *params);
+void ( APIENTRY * qglFrontFace )(GLenum mode);
+void ( APIENTRY * qglFrustum )(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
+GLuint ( APIENTRY * qglGenLists )(GLsizei range);
+void ( APIENTRY * qglGenTextures )(GLsizei n, GLuint *textures);
+void ( APIENTRY * qglGetBooleanv )(GLenum pname, GLboolean *params);
+void ( APIENTRY * qglGetClipPlane )(GLenum plane, GLdouble *equation);
+void ( APIENTRY * qglGetDoublev )(GLenum pname, GLdouble *params);
+GLenum ( APIENTRY * qglGetError )(void);
+void ( APIENTRY * qglGetFloatv )(GLenum pname, GLfloat *params);
+void ( APIENTRY * qglGetIntegerv )(GLenum pname, GLint *params);
+void ( APIENTRY * qglGetLightfv )(GLenum light, GLenum pname, GLfloat *params);
+void ( APIENTRY * qglGetLightiv )(GLenum light, GLenum pname, GLint *params);
+void ( APIENTRY * qglGetMapdv )(GLenum target, GLenum query, GLdouble *v);
+void ( APIENTRY * qglGetMapfv )(GLenum target, GLenum query, GLfloat *v);
+void ( APIENTRY * qglGetMapiv )(GLenum target, GLenum query, GLint *v);
+void ( APIENTRY * qglGetMaterialfv )(GLenum face, GLenum pname, GLfloat *params);
+void ( APIENTRY * qglGetMaterialiv )(GLenum face, GLenum pname, GLint *params);
+void ( APIENTRY * qglGetPixelMapfv )(GLenum gmap, GLfloat *values);
+void ( APIENTRY * qglGetPixelMapuiv )(GLenum gmap, GLuint *values);
+void ( APIENTRY * qglGetPixelMapusv )(GLenum gmap, GLushort *values);
+void ( APIENTRY * qglGetPointerv )(GLenum pname, GLvoid* *params);
+void ( APIENTRY * qglGetPolygonStipple )(GLubyte *mask);
+const GLubyte * ( APIENTRY * qglGetString )(GLenum name);
+void ( APIENTRY * qglGetTexEnvfv )(GLenum target, GLenum pname, GLfloat *params);
+void ( APIENTRY * qglGetTexEnviv )(GLenum target, GLenum pname, GLint *params);
+void ( APIENTRY * qglGetTexGendv )(GLenum coord, GLenum pname, GLdouble *params);
+void ( APIENTRY * qglGetTexGenfv )(GLenum coord, GLenum pname, GLfloat *params);
+void ( APIENTRY * qglGetTexGeniv )(GLenum coord, GLenum pname, GLint *params);
+void ( APIENTRY * qglGetTexImage )(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels);
+void ( APIENTRY * qglGetTexLevelParameterfv )(GLenum target, GLint level, GLenum pname, GLfloat *params);
+void ( APIENTRY * qglGetTexLevelParameteriv )(GLenum target, GLint level, GLenum pname, GLint *params);
+void ( APIENTRY * qglGetTexParameterfv )(GLenum target, GLenum pname, GLfloat *params);
+void ( APIENTRY * qglGetTexParameteriv )(GLenum target, GLenum pname, GLint *params);
+void ( APIENTRY * qglHint )(GLenum target, GLenum mode);
+void ( APIENTRY * qglIndexMask )(GLuint mask);
+void ( APIENTRY * qglIndexPointer )(GLenum type, GLsizei stride, const GLvoid *pointer);
+void ( APIENTRY * qglIndexd )(GLdouble c);
+void ( APIENTRY * qglIndexdv )(const GLdouble *c);
+void ( APIENTRY * qglIndexf )(GLfloat c);
+void ( APIENTRY * qglIndexfv )(const GLfloat *c);
+void ( APIENTRY * qglIndexi )(GLint c);
+void ( APIENTRY * qglIndexiv )(const GLint *c);
+void ( APIENTRY * qglIndexs )(GLshort c);
+void ( APIENTRY * qglIndexsv )(const GLshort *c);
+void ( APIENTRY * qglIndexub )(GLubyte c);
+void ( APIENTRY * qglIndexubv )(const GLubyte *c);
+void ( APIENTRY * qglInitNames )(void);
+void ( APIENTRY * qglInterleavedArrays )(GLenum format, GLsizei stride, const GLvoid *pointer);
+GLboolean ( APIENTRY * qglIsEnabled )(GLenum cap);
+GLboolean ( APIENTRY * qglIsList )(GLuint list);
+GLboolean ( APIENTRY * qglIsTexture )(GLuint texture);
+void ( APIENTRY * qglLightModelf )(GLenum pname, GLfloat param);
+void ( APIENTRY * qglLightModelfv )(GLenum pname, const GLfloat *params);
+void ( APIENTRY * qglLightModeli )(GLenum pname, GLint param);
+void ( APIENTRY * qglLightModeliv )(GLenum pname, const GLint *params);
+void ( APIENTRY * qglLightf )(GLenum light, GLenum pname, GLfloat param);
+void ( APIENTRY * qglLightfv )(GLenum light, GLenum pname, const GLfloat *params);
+void ( APIENTRY * qglLighti )(GLenum light, GLenum pname, GLint param);
+void ( APIENTRY * qglLightiv )(GLenum light, GLenum pname, const GLint *params);
+void ( APIENTRY * qglLineStipple )(GLint factor, GLushort pattern);
+void ( APIENTRY * qglLineWidth )(GLfloat width);
+void ( APIENTRY * qglListBase )(GLuint base);
+void ( APIENTRY * qglLoadIdentity )(void);
+void ( APIENTRY * qglLoadMatrixd )(const GLdouble *m);
+void ( APIENTRY * qglLoadMatrixf )(const GLfloat *m);
+void ( APIENTRY * qglLoadName )(GLuint name);
+void ( APIENTRY * qglLogicOp )(GLenum opcode);
+void ( APIENTRY * qglMap1d )(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points);
+void ( APIENTRY * qglMap1f )(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points);
+void ( APIENTRY * qglMap2d )(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points);
+void ( APIENTRY * qglMap2f )(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points);
+void ( APIENTRY * qglMapGrid1d )(GLint un, GLdouble u1, GLdouble u2);
+void ( APIENTRY * qglMapGrid1f )(GLint un, GLfloat u1, GLfloat u2);
+void ( APIENTRY * qglMapGrid2d )(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2);
+void ( APIENTRY * qglMapGrid2f )(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2);
+void ( APIENTRY * qglMaterialf )(GLenum face, GLenum pname, GLfloat param);
+void ( APIENTRY * qglMaterialfv )(GLenum face, GLenum pname, const GLfloat *params);
+void ( APIENTRY * qglMateriali )(GLenum face, GLenum pname, GLint param);
+void ( APIENTRY * qglMaterialiv )(GLenum face, GLenum pname, const GLint *params);
+void ( APIENTRY * qglMatrixMode )(GLenum mode);
+void ( APIENTRY * qglMultMatrixd )(const GLdouble *m);
+void ( APIENTRY * qglMultMatrixf )(const GLfloat *m);
+void ( APIENTRY * qglNewList )(GLuint list, GLenum mode);
+void ( APIENTRY * qglNormal3b )(GLbyte nx, GLbyte ny, GLbyte nz);
+void ( APIENTRY * qglNormal3bv )(const GLbyte *v);
+void ( APIENTRY * qglNormal3d )(GLdouble nx, GLdouble ny, GLdouble nz);
+void ( APIENTRY * qglNormal3dv )(const GLdouble *v);
+void ( APIENTRY * qglNormal3f )(GLfloat nx, GLfloat ny, GLfloat nz);
+void ( APIENTRY * qglNormal3fv )(const GLfloat *v);
+void ( APIENTRY * qglNormal3i )(GLint nx, GLint ny, GLint nz);
+void ( APIENTRY * qglNormal3iv )(const GLint *v);
+void ( APIENTRY * qglNormal3s )(GLshort nx, GLshort ny, GLshort nz);
+void ( APIENTRY * qglNormal3sv )(const GLshort *v);
+void ( APIENTRY * qglNormalPointer )(GLenum type, GLsizei stride, const GLvoid *pointer);
+void ( APIENTRY * qglOrtho )(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
+void ( APIENTRY * qglPassThrough )(GLfloat token);
+void ( APIENTRY * qglPixelMapfv )(GLenum gmap, GLsizei mapsize, const GLfloat *values);
+void ( APIENTRY * qglPixelMapuiv )(GLenum gmap, GLsizei mapsize, const GLuint *values);
+void ( APIENTRY * qglPixelMapusv )(GLenum gmap, GLsizei mapsize, const GLushort *values);
+void ( APIENTRY * qglPixelStoref )(GLenum pname, GLfloat param);
+void ( APIENTRY * qglPixelStorei )(GLenum pname, GLint param);
+void ( APIENTRY * qglPixelTransferf )(GLenum pname, GLfloat param);
+void ( APIENTRY * qglPixelTransferi )(GLenum pname, GLint param);
+void ( APIENTRY * qglPixelZoom )(GLfloat xfactor, GLfloat yfactor);
+void ( APIENTRY * qglPointSize )(GLfloat size);
+void ( APIENTRY * qglPolygonMode )(GLenum face, GLenum mode);
+void ( APIENTRY * qglPolygonOffset )(GLfloat factor, GLfloat units);
+void ( APIENTRY * qglPolygonStipple )(const GLubyte *mask);
+void ( APIENTRY * qglPopAttrib )(void);
+void ( APIENTRY * qglPopClientAttrib )(void);
+void ( APIENTRY * qglPopMatrix )(void);
+void ( APIENTRY * qglPopName )(void);
+void ( APIENTRY * qglPrioritizeTextures )(GLsizei n, const GLuint *textures, const GLclampf *priorities);
+void ( APIENTRY * qglPushAttrib )(GLbitfield mask);
+void ( APIENTRY * qglPushClientAttrib )(GLbitfield mask);
+void ( APIENTRY * qglPushMatrix )(void);
+void ( APIENTRY * qglPushName )(GLuint name);
+void ( APIENTRY * qglRasterPos2d )(GLdouble x, GLdouble y);
+void ( APIENTRY * qglRasterPos2dv )(const GLdouble *v);
+void ( APIENTRY * qglRasterPos2f )(GLfloat x, GLfloat y);
+void ( APIENTRY * qglRasterPos2fv )(const GLfloat *v);
+void ( APIENTRY * qglRasterPos2i )(GLint x, GLint y);
+void ( APIENTRY * qglRasterPos2iv )(const GLint *v);
+void ( APIENTRY * qglRasterPos2s )(GLshort x, GLshort y);
+void ( APIENTRY * qglRasterPos2sv )(const GLshort *v);
+void ( APIENTRY * qglRasterPos3d )(GLdouble x, GLdouble y, GLdouble z);
+void ( APIENTRY * qglRasterPos3dv )(const GLdouble *v);
+void ( APIENTRY * qglRasterPos3f )(GLfloat x, GLfloat y, GLfloat z);
+void ( APIENTRY * qglRasterPos3fv )(const GLfloat *v);
+void ( APIENTRY * qglRasterPos3i )(GLint x, GLint y, GLint z);
+void ( APIENTRY * qglRasterPos3iv )(const GLint *v);
+void ( APIENTRY * qglRasterPos3s )(GLshort x, GLshort y, GLshort z);
+void ( APIENTRY * qglRasterPos3sv )(const GLshort *v);
+void ( APIENTRY * qglRasterPos4d )(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+void ( APIENTRY * qglRasterPos4dv )(const GLdouble *v);
+void ( APIENTRY * qglRasterPos4f )(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+void ( APIENTRY * qglRasterPos4fv )(const GLfloat *v);
+void ( APIENTRY * qglRasterPos4i )(GLint x, GLint y, GLint z, GLint w);
+void ( APIENTRY * qglRasterPos4iv )(const GLint *v);
+void ( APIENTRY * qglRasterPos4s )(GLshort x, GLshort y, GLshort z, GLshort w);
+void ( APIENTRY * qglRasterPos4sv )(const GLshort *v);
+void ( APIENTRY * qglReadBuffer )(GLenum mode);
+void ( APIENTRY * qglReadPixels )(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels);
+void ( APIENTRY * qglRectd )(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2);
+void ( APIENTRY * qglRectdv )(const GLdouble *v1, const GLdouble *v2);
+void ( APIENTRY * qglRectf )(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2);
+void ( APIENTRY * qglRectfv )(const GLfloat *v1, const GLfloat *v2);
+void ( APIENTRY * qglRecti )(GLint x1, GLint y1, GLint x2, GLint y2);
+void ( APIENTRY * qglRectiv )(const GLint *v1, const GLint *v2);
+void ( APIENTRY * qglRects )(GLshort x1, GLshort y1, GLshort x2, GLshort y2);
+void ( APIENTRY * qglRectsv )(const GLshort *v1, const GLshort *v2);
+GLint ( APIENTRY * qglRenderMode )(GLenum mode);
+void ( APIENTRY * qglRotated )(GLdouble angle, GLdouble x, GLdouble y, GLdouble z);
+void ( APIENTRY * qglRotatef )(GLfloat angle, GLfloat x, GLfloat y, GLfloat z);
+void ( APIENTRY * qglScaled )(GLdouble x, GLdouble y, GLdouble z);
+void ( APIENTRY * qglScalef )(GLfloat x, GLfloat y, GLfloat z);
+void ( APIENTRY * qglScissor )(GLint x, GLint y, GLsizei width, GLsizei height);
+void ( APIENTRY * qglSelectBuffer )(GLsizei size, GLuint *buffer);
+void ( APIENTRY * qglShadeModel )(GLenum mode);
+void ( APIENTRY * qglStencilFunc )(GLenum func, GLint ref, GLuint mask);
+void ( APIENTRY * qglStencilMask )(GLuint mask);
+void ( APIENTRY * qglStencilOp )(GLenum fail, GLenum zfail, GLenum zpass);
+void ( APIENTRY * qglTexCoord1d )(GLdouble s);
+void ( APIENTRY * qglTexCoord1dv )(const GLdouble *v);
+void ( APIENTRY * qglTexCoord1f )(GLfloat s);
+void ( APIENTRY * qglTexCoord1fv )(const GLfloat *v);
+void ( APIENTRY * qglTexCoord1i )(GLint s);
+void ( APIENTRY * qglTexCoord1iv )(const GLint *v);
+void ( APIENTRY * qglTexCoord1s )(GLshort s);
+void ( APIENTRY * qglTexCoord1sv )(const GLshort *v);
+void ( APIENTRY * qglTexCoord2d )(GLdouble s, GLdouble t);
+void ( APIENTRY * qglTexCoord2dv )(const GLdouble *v);
+void ( APIENTRY * qglTexCoord2f )(GLfloat s, GLfloat t);
+void ( APIENTRY * qglTexCoord2fv )(const GLfloat *v);
+void ( APIENTRY * qglTexCoord2i )(GLint s, GLint t);
+void ( APIENTRY * qglTexCoord2iv )(const GLint *v);
+void ( APIENTRY * qglTexCoord2s )(GLshort s, GLshort t);
+void ( APIENTRY * qglTexCoord2sv )(const GLshort *v);
+void ( APIENTRY * qglTexCoord3d )(GLdouble s, GLdouble t, GLdouble r);
+void ( APIENTRY * qglTexCoord3dv )(const GLdouble *v);
+void ( APIENTRY * qglTexCoord3f )(GLfloat s, GLfloat t, GLfloat r);
+void ( APIENTRY * qglTexCoord3fv )(const GLfloat *v);
+void ( APIENTRY * qglTexCoord3i )(GLint s, GLint t, GLint r);
+void ( APIENTRY * qglTexCoord3iv )(const GLint *v);
+void ( APIENTRY * qglTexCoord3s )(GLshort s, GLshort t, GLshort r);
+void ( APIENTRY * qglTexCoord3sv )(const GLshort *v);
+void ( APIENTRY * qglTexCoord4d )(GLdouble s, GLdouble t, GLdouble r, GLdouble q);
+void ( APIENTRY * qglTexCoord4dv )(const GLdouble *v);
+void ( APIENTRY * qglTexCoord4f )(GLfloat s, GLfloat t, GLfloat r, GLfloat q);
+void ( APIENTRY * qglTexCoord4fv )(const GLfloat *v);
+void ( APIENTRY * qglTexCoord4i )(GLint s, GLint t, GLint r, GLint q);
+void ( APIENTRY * qglTexCoord4iv )(const GLint *v);
+void ( APIENTRY * qglTexCoord4s )(GLshort s, GLshort t, GLshort r, GLshort q);
+void ( APIENTRY * qglTexCoord4sv )(const GLshort *v);
+void ( APIENTRY * qglTexCoordPointer )(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
+void ( APIENTRY * qglTexEnvf )(GLenum target, GLenum pname, GLfloat param);
+void ( APIENTRY * qglTexEnvfv )(GLenum target, GLenum pname, const GLfloat *params);
+void ( APIENTRY * qglTexEnvi )(GLenum target, GLenum pname, GLint param);
+void ( APIENTRY * qglTexEnviv )(GLenum target, GLenum pname, const GLint *params);
+void ( APIENTRY * qglTexGend )(GLenum coord, GLenum pname, GLdouble param);
+void ( APIENTRY * qglTexGendv )(GLenum coord, GLenum pname, const GLdouble *params);
+void ( APIENTRY * qglTexGenf )(GLenum coord, GLenum pname, GLfloat param);
+void ( APIENTRY * qglTexGenfv )(GLenum coord, GLenum pname, const GLfloat *params);
+void ( APIENTRY * qglTexGeni )(GLenum coord, GLenum pname, GLint param);
+void ( APIENTRY * qglTexGeniv )(GLenum coord, GLenum pname, const GLint *params);
+void ( APIENTRY * qglTexImage1D )(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
+void ( APIENTRY * qglTexImage2D )(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
+void ( APIENTRY * qglTexParameterf )(GLenum target, GLenum pname, GLfloat param);
+void ( APIENTRY * qglTexParameterfv )(GLenum target, GLenum pname, const GLfloat *params);
+void ( APIENTRY * qglTexParameteri )(GLenum target, GLenum pname, GLint param);
+void ( APIENTRY * qglTexParameteriv )(GLenum target, GLenum pname, const GLint *params);
+void ( APIENTRY * qglTexSubImage1D )(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels);
+void ( APIENTRY * qglTexSubImage2D )(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
+void ( APIENTRY * qglTranslated )(GLdouble x, GLdouble y, GLdouble z);
+void ( APIENTRY * qglTranslatef )(GLfloat x, GLfloat y, GLfloat z);
+void ( APIENTRY * qglVertex2d )(GLdouble x, GLdouble y);
+void ( APIENTRY * qglVertex2dv )(const GLdouble *v);
+void ( APIENTRY * qglVertex2f )(GLfloat x, GLfloat y);
+void ( APIENTRY * qglVertex2fv )(const GLfloat *v);
+void ( APIENTRY * qglVertex2i )(GLint x, GLint y);
+void ( APIENTRY * qglVertex2iv )(const GLint *v);
+void ( APIENTRY * qglVertex2s )(GLshort x, GLshort y);
+void ( APIENTRY * qglVertex2sv )(const GLshort *v);
+void ( APIENTRY * qglVertex3d )(GLdouble x, GLdouble y, GLdouble z);
+void ( APIENTRY * qglVertex3dv )(const GLdouble *v);
+void ( APIENTRY * qglVertex3f )(GLfloat x, GLfloat y, GLfloat z);
+void ( APIENTRY * qglVertex3fv )(const GLfloat *v);
+void ( APIENTRY * qglVertex3i )(GLint x, GLint y, GLint z);
+void ( APIENTRY * qglVertex3iv )(const GLint *v);
+void ( APIENTRY * qglVertex3s )(GLshort x, GLshort y, GLshort z);
+void ( APIENTRY * qglVertex3sv )(const GLshort *v);
+void ( APIENTRY * qglVertex4d )(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+void ( APIENTRY * qglVertex4dv )(const GLdouble *v);
+void ( APIENTRY * qglVertex4f )(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+void ( APIENTRY * qglVertex4fv )(const GLfloat *v);
+void ( APIENTRY * qglVertex4i )(GLint x, GLint y, GLint z, GLint w);
+void ( APIENTRY * qglVertex4iv )(const GLint *v);
+void ( APIENTRY * qglVertex4s )(GLshort x, GLshort y, GLshort z, GLshort w);
+void ( APIENTRY * qglVertex4sv )(const GLshort *v);
+void ( APIENTRY * qglVertexPointer )(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
+void ( APIENTRY * qglViewport )(GLint x, GLint y, GLsizei width, GLsizei height);
+
+
+
+static void ( APIENTRY * dllAccum )(GLenum op, GLfloat value);
+static void ( APIENTRY * dllAlphaFunc )(GLenum func, GLclampf ref);
+GLboolean ( APIENTRY * dllAreTexturesResident )(GLsizei n, const GLuint *textures, GLboolean *residences);
+static void ( APIENTRY * dllArrayElement )(GLint i);
+static void ( APIENTRY * dllBegin )(GLenum mode);
+static void ( APIENTRY * dllBindTexture )(GLenum target, GLuint texture);
+static void ( APIENTRY * dllBitmap )(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap);
+static void ( APIENTRY * dllBlendFunc )(GLenum sfactor, GLenum dfactor);
+static void ( APIENTRY * dllCallList )(GLuint list);
+static void ( APIENTRY * dllCallLists )(GLsizei n, GLenum type, const GLvoid *lists);
+static void ( APIENTRY * dllClear )(GLbitfield mask);
+static void ( APIENTRY * dllClearAccum )(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
+static void ( APIENTRY * dllClearColor )(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
+static void ( APIENTRY * dllClearDepth )(GLclampd depth);
+static void ( APIENTRY * dllClearIndex )(GLfloat c);
+static void ( APIENTRY * dllClearStencil )(GLint s);
+static void ( APIENTRY * dllClipPlane )(GLenum plane, const GLdouble *equation);
+static void ( APIENTRY * dllColor3b )(GLbyte red, GLbyte green, GLbyte blue);
+static void ( APIENTRY * dllColor3bv )(const GLbyte *v);
+static void ( APIENTRY * dllColor3d )(GLdouble red, GLdouble green, GLdouble blue);
+static void ( APIENTRY * dllColor3dv )(const GLdouble *v);
+static void ( APIENTRY * dllColor3f )(GLfloat red, GLfloat green, GLfloat blue);
+static void ( APIENTRY * dllColor3fv )(const GLfloat *v);
+static void ( APIENTRY * dllColor3i )(GLint red, GLint green, GLint blue);
+static void ( APIENTRY * dllColor3iv )(const GLint *v);
+static void ( APIENTRY * dllColor3s )(GLshort red, GLshort green, GLshort blue);
+static void ( APIENTRY * dllColor3sv )(const GLshort *v);
+static void ( APIENTRY * dllColor3ub )(GLubyte red, GLubyte green, GLubyte blue);
+static void ( APIENTRY * dllColor3ubv )(const GLubyte *v);
+static void ( APIENTRY * dllColor3ui )(GLuint red, GLuint green, GLuint blue);
+static void ( APIENTRY * dllColor3uiv )(const GLuint *v);
+static void ( APIENTRY * dllColor3us )(GLushort red, GLushort green, GLushort blue);
+static void ( APIENTRY * dllColor3usv )(const GLushort *v);
+static void ( APIENTRY * dllColor4b )(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha);
+static void ( APIENTRY * dllColor4bv )(const GLbyte *v);
+static void ( APIENTRY * dllColor4d )(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha);
+static void ( APIENTRY * dllColor4dv )(const GLdouble *v);
+static void ( APIENTRY * dllColor4f )(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
+static void ( APIENTRY * dllColor4fv )(const GLfloat *v);
+static void ( APIENTRY * dllColor4i )(GLint red, GLint green, GLint blue, GLint alpha);
+static void ( APIENTRY * dllColor4iv )(const GLint *v);
+static void ( APIENTRY * dllColor4s )(GLshort red, GLshort green, GLshort blue, GLshort alpha);
+static void ( APIENTRY * dllColor4sv )(const GLshort *v);
+static void ( APIENTRY * dllColor4ub )(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha);
+static void ( APIENTRY * dllColor4ubv )(const GLubyte *v);
+static void ( APIENTRY * dllColor4ui )(GLuint red, GLuint green, GLuint blue, GLuint alpha);
+static void ( APIENTRY * dllColor4uiv )(const GLuint *v);
+static void ( APIENTRY * dllColor4us )(GLushort red, GLushort green, GLushort blue, GLushort alpha);
+static void ( APIENTRY * dllColor4usv )(const GLushort *v);
+static void ( APIENTRY * dllColorMask )(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
+static void ( APIENTRY * dllColorMaterial )(GLenum face, GLenum mode);
+static void ( APIENTRY * dllColorPointer )(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
+static void ( APIENTRY * dllCopyPixels )(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type);
+static void ( APIENTRY * dllCopyTexImage1D )(GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border);
+static void ( APIENTRY * dllCopyTexImage2D )(GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
+static void ( APIENTRY * dllCopyTexSubImage1D )(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);
+static void ( APIENTRY * dllCopyTexSubImage2D )(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
+static void ( APIENTRY * dllCullFace )(GLenum mode);
+static void ( APIENTRY * dllDeleteLists )(GLuint list, GLsizei range);
+static void ( APIENTRY * dllDeleteTextures )(GLsizei n, const GLuint *textures);
+static void ( APIENTRY * dllDepthFunc )(GLenum func);
+static void ( APIENTRY * dllDepthMask )(GLboolean flag);
+static void ( APIENTRY * dllDepthRange )(GLclampd zNear, GLclampd zFar);
+static void ( APIENTRY * dllDisable )(GLenum cap);
+static void ( APIENTRY * dllDisableClientState )(GLenum array);
+static void ( APIENTRY * dllDrawArrays )(GLenum mode, GLint first, GLsizei count);
+static void ( APIENTRY * dllDrawBuffer )(GLenum mode);
+static void ( APIENTRY * dllDrawElements )(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices);
+static void ( APIENTRY * dllDrawPixels )(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
+static void ( APIENTRY * dllEdgeFlag )(GLboolean flag);
+static void ( APIENTRY * dllEdgeFlagPointer )(GLsizei stride, const GLvoid *pointer);
+static void ( APIENTRY * dllEdgeFlagv )(const GLboolean *flag);
+static void ( APIENTRY * dllEnable )(GLenum cap);
+static void ( APIENTRY * dllEnableClientState )(GLenum array);
+static void ( APIENTRY * dllEnd )(void);
+static void ( APIENTRY * dllEndList )(void);
+static void ( APIENTRY * dllEvalCoord1d )(GLdouble u);
+static void ( APIENTRY * dllEvalCoord1dv )(const GLdouble *u);
+static void ( APIENTRY * dllEvalCoord1f )(GLfloat u);
+static void ( APIENTRY * dllEvalCoord1fv )(const GLfloat *u);
+static void ( APIENTRY * dllEvalCoord2d )(GLdouble u, GLdouble v);
+static void ( APIENTRY * dllEvalCoord2dv )(const GLdouble *u);
+static void ( APIENTRY * dllEvalCoord2f )(GLfloat u, GLfloat v);
+static void ( APIENTRY * dllEvalCoord2fv )(const GLfloat *u);
+static void ( APIENTRY * dllEvalMesh1 )(GLenum mode, GLint i1, GLint i2);
+static void ( APIENTRY * dllEvalMesh2 )(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2);
+static void ( APIENTRY * dllEvalPoint1 )(GLint i);
+static void ( APIENTRY * dllEvalPoint2 )(GLint i, GLint j);
+static void ( APIENTRY * dllFeedbackBuffer )(GLsizei size, GLenum type, GLfloat *buffer);
+static void ( APIENTRY * dllFinish )(void);
+static void ( APIENTRY * dllFlush )(void);
+static void ( APIENTRY * dllFogf )(GLenum pname, GLfloat param);
+static void ( APIENTRY * dllFogfv )(GLenum pname, const GLfloat *params);
+static void ( APIENTRY * dllFogi )(GLenum pname, GLint param);
+static void ( APIENTRY * dllFogiv )(GLenum pname, const GLint *params);
+static void ( APIENTRY * dllFrontFace )(GLenum mode);
+static void ( APIENTRY * dllFrustum )(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
+GLuint ( APIENTRY * dllGenLists )(GLsizei range);
+static void ( APIENTRY * dllGenTextures )(GLsizei n, GLuint *textures);
+static void ( APIENTRY * dllGetBooleanv )(GLenum pname, GLboolean *params);
+static void ( APIENTRY * dllGetClipPlane )(GLenum plane, GLdouble *equation);
+static void ( APIENTRY * dllGetDoublev )(GLenum pname, GLdouble *params);
+GLenum ( APIENTRY * dllGetError )(void);
+static void ( APIENTRY * dllGetFloatv )(GLenum pname, GLfloat *params);
+static void ( APIENTRY * dllGetIntegerv )(GLenum pname, GLint *params);
+static void ( APIENTRY * dllGetLightfv )(GLenum light, GLenum pname, GLfloat *params);
+static void ( APIENTRY * dllGetLightiv )(GLenum light, GLenum pname, GLint *params);
+static void ( APIENTRY * dllGetMapdv )(GLenum target, GLenum query, GLdouble *v);
+static void ( APIENTRY * dllGetMapfv )(GLenum target, GLenum query, GLfloat *v);
+static void ( APIENTRY * dllGetMapiv )(GLenum target, GLenum query, GLint *v);
+static void ( APIENTRY * dllGetMaterialfv )(GLenum face, GLenum pname, GLfloat *params);
+static void ( APIENTRY * dllGetMaterialiv )(GLenum face, GLenum pname, GLint *params);
+static void ( APIENTRY * dllGetPixelMapfv )(GLenum map, GLfloat *values);
+static void ( APIENTRY * dllGetPixelMapuiv )(GLenum map, GLuint *values);
+static void ( APIENTRY * dllGetPixelMapusv )(GLenum map, GLushort *values);
+static void ( APIENTRY * dllGetPointerv )(GLenum pname, GLvoid* *params);
+static void ( APIENTRY * dllGetPolygonStipple )(GLubyte *mask);
+const GLubyte * ( APIENTRY * dllGetString )(GLenum name);
+static void ( APIENTRY * dllGetTexEnvfv )(GLenum target, GLenum pname, GLfloat *params);
+static void ( APIENTRY * dllGetTexEnviv )(GLenum target, GLenum pname, GLint *params);
+static void ( APIENTRY * dllGetTexGendv )(GLenum coord, GLenum pname, GLdouble *params);
+static void ( APIENTRY * dllGetTexGenfv )(GLenum coord, GLenum pname, GLfloat *params);
+static void ( APIENTRY * dllGetTexGeniv )(GLenum coord, GLenum pname, GLint *params);
+static void ( APIENTRY * dllGetTexImage )(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels);
+static void ( APIENTRY * dllGetTexLevelParameterfv )(GLenum target, GLint level, GLenum pname, GLfloat *params);
+static void ( APIENTRY * dllGetTexLevelParameteriv )(GLenum target, GLint level, GLenum pname, GLint *params);
+static void ( APIENTRY * dllGetTexParameterfv )(GLenum target, GLenum pname, GLfloat *params);
+static void ( APIENTRY * dllGetTexParameteriv )(GLenum target, GLenum pname, GLint *params);
+static void ( APIENTRY * dllHint )(GLenum target, GLenum mode);
+static void ( APIENTRY * dllIndexMask )(GLuint mask);
+static void ( APIENTRY * dllIndexPointer )(GLenum type, GLsizei stride, const GLvoid *pointer);
+static void ( APIENTRY * dllIndexd )(GLdouble c);
+static void ( APIENTRY * dllIndexdv )(const GLdouble *c);
+static void ( APIENTRY * dllIndexf )(GLfloat c);
+static void ( APIENTRY * dllIndexfv )(const GLfloat *c);
+static void ( APIENTRY * dllIndexi )(GLint c);
+static void ( APIENTRY * dllIndexiv )(const GLint *c);
+static void ( APIENTRY * dllIndexs )(GLshort c);
+static void ( APIENTRY * dllIndexsv )(const GLshort *c);
+static void ( APIENTRY * dllIndexub )(GLubyte c);
+static void ( APIENTRY * dllIndexubv )(const GLubyte *c);
+static void ( APIENTRY * dllInitNames )(void);
+static void ( APIENTRY * dllInterleavedArrays )(GLenum format, GLsizei stride, const GLvoid *pointer);
+GLboolean ( APIENTRY * dllIsEnabled )(GLenum cap);
+GLboolean ( APIENTRY * dllIsList )(GLuint list);
+GLboolean ( APIENTRY * dllIsTexture )(GLuint texture);
+static void ( APIENTRY * dllLightModelf )(GLenum pname, GLfloat param);
+static void ( APIENTRY * dllLightModelfv )(GLenum pname, const GLfloat *params);
+static void ( APIENTRY * dllLightModeli )(GLenum pname, GLint param);
+static void ( APIENTRY * dllLightModeliv )(GLenum pname, const GLint *params);
+static void ( APIENTRY * dllLightf )(GLenum light, GLenum pname, GLfloat param);
+static void ( APIENTRY * dllLightfv )(GLenum light, GLenum pname, const GLfloat *params);
+static void ( APIENTRY * dllLighti )(GLenum light, GLenum pname, GLint param);
+static void ( APIENTRY * dllLightiv )(GLenum light, GLenum pname, const GLint *params);
+static void ( APIENTRY * dllLineStipple )(GLint factor, GLushort pattern);
+static void ( APIENTRY * dllLineWidth )(GLfloat width);
+static void ( APIENTRY * dllListBase )(GLuint base);
+static void ( APIENTRY * dllLoadIdentity )(void);
+static void ( APIENTRY * dllLoadMatrixd )(const GLdouble *m);
+static void ( APIENTRY * dllLoadMatrixf )(const GLfloat *m);
+static void ( APIENTRY * dllLoadName )(GLuint name);
+static void ( APIENTRY * dllLogicOp )(GLenum opcode);
+static void ( APIENTRY * dllMap1d )(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points);
+static void ( APIENTRY * dllMap1f )(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points);
+static void ( APIENTRY * dllMap2d )(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points);
+static void ( APIENTRY * dllMap2f )(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points);
+static void ( APIENTRY * dllMapGrid1d )(GLint un, GLdouble u1, GLdouble u2);
+static void ( APIENTRY * dllMapGrid1f )(GLint un, GLfloat u1, GLfloat u2);
+static void ( APIENTRY * dllMapGrid2d )(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2);
+static void ( APIENTRY * dllMapGrid2f )(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2);
+static void ( APIENTRY * dllMaterialf )(GLenum face, GLenum pname, GLfloat param);
+static void ( APIENTRY * dllMaterialfv )(GLenum face, GLenum pname, const GLfloat *params);
+static void ( APIENTRY * dllMateriali )(GLenum face, GLenum pname, GLint param);
+static void ( APIENTRY * dllMaterialiv )(GLenum face, GLenum pname, const GLint *params);
+static void ( APIENTRY * dllMatrixMode )(GLenum mode);
+static void ( APIENTRY * dllMultMatrixd )(const GLdouble *m);
+static void ( APIENTRY * dllMultMatrixf )(const GLfloat *m);
+static void ( APIENTRY * dllNewList )(GLuint list, GLenum mode);
+static void ( APIENTRY * dllNormal3b )(GLbyte nx, GLbyte ny, GLbyte nz);
+static void ( APIENTRY * dllNormal3bv )(const GLbyte *v);
+static void ( APIENTRY * dllNormal3d )(GLdouble nx, GLdouble ny, GLdouble nz);
+static void ( APIENTRY * dllNormal3dv )(const GLdouble *v);
+static void ( APIENTRY * dllNormal3f )(GLfloat nx, GLfloat ny, GLfloat nz);
+static void ( APIENTRY * dllNormal3fv )(const GLfloat *v);
+static void ( APIENTRY * dllNormal3i )(GLint nx, GLint ny, GLint nz);
+static void ( APIENTRY * dllNormal3iv )(const GLint *v);
+static void ( APIENTRY * dllNormal3s )(GLshort nx, GLshort ny, GLshort nz);
+static void ( APIENTRY * dllNormal3sv )(const GLshort *v);
+static void ( APIENTRY * dllNormalPointer )(GLenum type, GLsizei stride, const GLvoid *pointer);
+static void ( APIENTRY * dllOrtho )(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
+static void ( APIENTRY * dllPassThrough )(GLfloat token);
+static void ( APIENTRY * dllPixelMapfv )(GLenum map, GLsizei mapsize, const GLfloat *values);
+static void ( APIENTRY * dllPixelMapuiv )(GLenum map, GLsizei mapsize, const GLuint *values);
+static void ( APIENTRY * dllPixelMapusv )(GLenum map, GLsizei mapsize, const GLushort *values);
+static void ( APIENTRY * dllPixelStoref )(GLenum pname, GLfloat param);
+static void ( APIENTRY * dllPixelStorei )(GLenum pname, GLint param);
+static void ( APIENTRY * dllPixelTransferf )(GLenum pname, GLfloat param);
+static void ( APIENTRY * dllPixelTransferi )(GLenum pname, GLint param);
+static void ( APIENTRY * dllPixelZoom )(GLfloat xfactor, GLfloat yfactor);
+static void ( APIENTRY * dllPointSize )(GLfloat size);
+static void ( APIENTRY * dllPolygonMode )(GLenum face, GLenum mode);
+static void ( APIENTRY * dllPolygonOffset )(GLfloat factor, GLfloat units);
+static void ( APIENTRY * dllPolygonStipple )(const GLubyte *mask);
+static void ( APIENTRY * dllPopAttrib )(void);
+static void ( APIENTRY * dllPopClientAttrib )(void);
+static void ( APIENTRY * dllPopMatrix )(void);
+static void ( APIENTRY * dllPopName )(void);
+static void ( APIENTRY * dllPrioritizeTextures )(GLsizei n, const GLuint *textures, const GLclampf *priorities);
+static void ( APIENTRY * dllPushAttrib )(GLbitfield mask);
+static void ( APIENTRY * dllPushClientAttrib )(GLbitfield mask);
+static void ( APIENTRY * dllPushMatrix )(void);
+static void ( APIENTRY * dllPushName )(GLuint name);
+static void ( APIENTRY * dllRasterPos2d )(GLdouble x, GLdouble y);
+static void ( APIENTRY * dllRasterPos2dv )(const GLdouble *v);
+static void ( APIENTRY * dllRasterPos2f )(GLfloat x, GLfloat y);
+static void ( APIENTRY * dllRasterPos2fv )(const GLfloat *v);
+static void ( APIENTRY * dllRasterPos2i )(GLint x, GLint y);
+static void ( APIENTRY * dllRasterPos2iv )(const GLint *v);
+static void ( APIENTRY * dllRasterPos2s )(GLshort x, GLshort y);
+static void ( APIENTRY * dllRasterPos2sv )(const GLshort *v);
+static void ( APIENTRY * dllRasterPos3d )(GLdouble x, GLdouble y, GLdouble z);
+static void ( APIENTRY * dllRasterPos3dv )(const GLdouble *v);
+static void ( APIENTRY * dllRasterPos3f )(GLfloat x, GLfloat y, GLfloat z);
+static void ( APIENTRY * dllRasterPos3fv )(const GLfloat *v);
+static void ( APIENTRY * dllRasterPos3i )(GLint x, GLint y, GLint z);
+static void ( APIENTRY * dllRasterPos3iv )(const GLint *v);
+static void ( APIENTRY * dllRasterPos3s )(GLshort x, GLshort y, GLshort z);
+static void ( APIENTRY * dllRasterPos3sv )(const GLshort *v);
+static void ( APIENTRY * dllRasterPos4d )(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+static void ( APIENTRY * dllRasterPos4dv )(const GLdouble *v);
+static void ( APIENTRY * dllRasterPos4f )(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+static void ( APIENTRY * dllRasterPos4fv )(const GLfloat *v);
+static void ( APIENTRY * dllRasterPos4i )(GLint x, GLint y, GLint z, GLint w);
+static void ( APIENTRY * dllRasterPos4iv )(const GLint *v);
+static void ( APIENTRY * dllRasterPos4s )(GLshort x, GLshort y, GLshort z, GLshort w);
+static void ( APIENTRY * dllRasterPos4sv )(const GLshort *v);
+static void ( APIENTRY * dllReadBuffer )(GLenum mode);
+static void ( APIENTRY * dllReadPixels )(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels);
+static void ( APIENTRY * dllRectd )(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2);
+static void ( APIENTRY * dllRectdv )(const GLdouble *v1, const GLdouble *v2);
+static void ( APIENTRY * dllRectf )(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2);
+static void ( APIENTRY * dllRectfv )(const GLfloat *v1, const GLfloat *v2);
+static void ( APIENTRY * dllRecti )(GLint x1, GLint y1, GLint x2, GLint y2);
+static void ( APIENTRY * dllRectiv )(const GLint *v1, const GLint *v2);
+static void ( APIENTRY * dllRects )(GLshort x1, GLshort y1, GLshort x2, GLshort y2);
+static void ( APIENTRY * dllRectsv )(const GLshort *v1, const GLshort *v2);
+GLint ( APIENTRY * dllRenderMode )(GLenum mode);
+static void ( APIENTRY * dllRotated )(GLdouble angle, GLdouble x, GLdouble y, GLdouble z);
+static void ( APIENTRY * dllRotatef )(GLfloat angle, GLfloat x, GLfloat y, GLfloat z);
+static void ( APIENTRY * dllScaled )(GLdouble x, GLdouble y, GLdouble z);
+static void ( APIENTRY * dllScalef )(GLfloat x, GLfloat y, GLfloat z);
+static void ( APIENTRY * dllScissor )(GLint x, GLint y, GLsizei width, GLsizei height);
+static void ( APIENTRY * dllSelectBuffer )(GLsizei size, GLuint *buffer);
+static void ( APIENTRY * dllShadeModel )(GLenum mode);
+static void ( APIENTRY * dllStencilFunc )(GLenum func, GLint ref, GLuint mask);
+static void ( APIENTRY * dllStencilMask )(GLuint mask);
+static void ( APIENTRY * dllStencilOp )(GLenum fail, GLenum zfail, GLenum zpass);
+static void ( APIENTRY * dllTexCoord1d )(GLdouble s);
+static void ( APIENTRY * dllTexCoord1dv )(const GLdouble *v);
+static void ( APIENTRY * dllTexCoord1f )(GLfloat s);
+static void ( APIENTRY * dllTexCoord1fv )(const GLfloat *v);
+static void ( APIENTRY * dllTexCoord1i )(GLint s);
+static void ( APIENTRY * dllTexCoord1iv )(const GLint *v);
+static void ( APIENTRY * dllTexCoord1s )(GLshort s);
+static void ( APIENTRY * dllTexCoord1sv )(const GLshort *v);
+static void ( APIENTRY * dllTexCoord2d )(GLdouble s, GLdouble t);
+static void ( APIENTRY * dllTexCoord2dv )(const GLdouble *v);
+static void ( APIENTRY * dllTexCoord2f )(GLfloat s, GLfloat t);
+static void ( APIENTRY * dllTexCoord2fv )(const GLfloat *v);
+static void ( APIENTRY * dllTexCoord2i )(GLint s, GLint t);
+static void ( APIENTRY * dllTexCoord2iv )(const GLint *v);
+static void ( APIENTRY * dllTexCoord2s )(GLshort s, GLshort t);
+static void ( APIENTRY * dllTexCoord2sv )(const GLshort *v);
+static void ( APIENTRY * dllTexCoord3d )(GLdouble s, GLdouble t, GLdouble r);
+static void ( APIENTRY * dllTexCoord3dv )(const GLdouble *v);
+static void ( APIENTRY * dllTexCoord3f )(GLfloat s, GLfloat t, GLfloat r);
+static void ( APIENTRY * dllTexCoord3fv )(const GLfloat *v);
+static void ( APIENTRY * dllTexCoord3i )(GLint s, GLint t, GLint r);
+static void ( APIENTRY * dllTexCoord3iv )(const GLint *v);
+static void ( APIENTRY * dllTexCoord3s )(GLshort s, GLshort t, GLshort r);
+static void ( APIENTRY * dllTexCoord3sv )(const GLshort *v);
+static void ( APIENTRY * dllTexCoord4d )(GLdouble s, GLdouble t, GLdouble r, GLdouble q);
+static void ( APIENTRY * dllTexCoord4dv )(const GLdouble *v);
+static void ( APIENTRY * dllTexCoord4f )(GLfloat s, GLfloat t, GLfloat r, GLfloat q);
+static void ( APIENTRY * dllTexCoord4fv )(const GLfloat *v);
+static void ( APIENTRY * dllTexCoord4i )(GLint s, GLint t, GLint r, GLint q);
+static void ( APIENTRY * dllTexCoord4iv )(const GLint *v);
+static void ( APIENTRY * dllTexCoord4s )(GLshort s, GLshort t, GLshort r, GLshort q);
+static void ( APIENTRY * dllTexCoord4sv )(const GLshort *v);
+static void ( APIENTRY * dllTexCoordPointer )(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
+static void ( APIENTRY * dllTexEnvf )(GLenum target, GLenum pname, GLfloat param);
+static void ( APIENTRY * dllTexEnvfv )(GLenum target, GLenum pname, const GLfloat *params);
+static void ( APIENTRY * dllTexEnvi )(GLenum target, GLenum pname, GLint param);
+static void ( APIENTRY * dllTexEnviv )(GLenum target, GLenum pname, const GLint *params);
+static void ( APIENTRY * dllTexGend )(GLenum coord, GLenum pname, GLdouble param);
+static void ( APIENTRY * dllTexGendv )(GLenum coord, GLenum pname, const GLdouble *params);
+static void ( APIENTRY * dllTexGenf )(GLenum coord, GLenum pname, GLfloat param);
+static void ( APIENTRY * dllTexGenfv )(GLenum coord, GLenum pname, const GLfloat *params);
+static void ( APIENTRY * dllTexGeni )(GLenum coord, GLenum pname, GLint param);
+static void ( APIENTRY * dllTexGeniv )(GLenum coord, GLenum pname, const GLint *params);
+static void ( APIENTRY * dllTexImage1D )(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
+static void ( APIENTRY * dllTexImage2D )(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
+static void ( APIENTRY * dllTexParameterf )(GLenum target, GLenum pname, GLfloat param);
+static void ( APIENTRY * dllTexParameterfv )(GLenum target, GLenum pname, const GLfloat *params);
+static void ( APIENTRY * dllTexParameteri )(GLenum target, GLenum pname, GLint param);
+static void ( APIENTRY * dllTexParameteriv )(GLenum target, GLenum pname, const GLint *params);
+static void ( APIENTRY * dllTexSubImage1D )(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels);
+static void ( APIENTRY * dllTexSubImage2D )(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
+static void ( APIENTRY * dllTranslated )(GLdouble x, GLdouble y, GLdouble z);
+static void ( APIENTRY * dllTranslatef )(GLfloat x, GLfloat y, GLfloat z);
+static void ( APIENTRY * dllVertex2d )(GLdouble x, GLdouble y);
+static void ( APIENTRY * dllVertex2dv )(const GLdouble *v);
+static void ( APIENTRY * dllVertex2f )(GLfloat x, GLfloat y);
+static void ( APIENTRY * dllVertex2fv )(const GLfloat *v);
+static void ( APIENTRY * dllVertex2i )(GLint x, GLint y);
+static void ( APIENTRY * dllVertex2iv )(const GLint *v);
+static void ( APIENTRY * dllVertex2s )(GLshort x, GLshort y);
+static void ( APIENTRY * dllVertex2sv )(const GLshort *v);
+static void ( APIENTRY * dllVertex3d )(GLdouble x, GLdouble y, GLdouble z);
+static void ( APIENTRY * dllVertex3dv )(const GLdouble *v);
+static void ( APIENTRY * dllVertex3f )(GLfloat x, GLfloat y, GLfloat z);
+static void ( APIENTRY * dllVertex3fv )(const GLfloat *v);
+static void ( APIENTRY * dllVertex3i )(GLint x, GLint y, GLint z);
+static void ( APIENTRY * dllVertex3iv )(const GLint *v);
+static void ( APIENTRY * dllVertex3s )(GLshort x, GLshort y, GLshort z);
+static void ( APIENTRY * dllVertex3sv )(const GLshort *v);
+static void ( APIENTRY * dllVertex4d )(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+static void ( APIENTRY * dllVertex4dv )(const GLdouble *v);
+static void ( APIENTRY * dllVertex4f )(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+static void ( APIENTRY * dllVertex4fv )(const GLfloat *v);
+static void ( APIENTRY * dllVertex4i )(GLint x, GLint y, GLint z, GLint w);
+static void ( APIENTRY * dllVertex4iv )(const GLint *v);
+static void ( APIENTRY * dllVertex4s )(GLshort x, GLshort y, GLshort z, GLshort w);
+static void ( APIENTRY * dllVertex4sv )(const GLshort *v);
+static void ( APIENTRY * dllVertexPointer )(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
+static void ( APIENTRY * dllViewport )(GLint x, GLint y, GLsizei width, GLsizei height);
+
+static const char * BooleanToString( GLboolean b )
+{
+	if ( b == GL_FALSE )
+		return "GL_FALSE";
+	else if ( b == GL_TRUE )
+		return "GL_TRUE";
+	else
+		return "OUT OF RANGE FOR BOOLEAN";
+}
+
+static const char * FuncToString( GLenum f )
+{
+	switch ( f )
+	{
+	case GL_ALWAYS:
+		return "GL_ALWAYS";
+	case GL_NEVER:
+		return "GL_NEVER";
+	case GL_LEQUAL:
+		return "GL_LEQUAL";
+	case GL_LESS:
+		return "GL_LESS";
+	case GL_EQUAL:
+		return "GL_EQUAL";
+	case GL_GREATER:
+		return "GL_GREATER";
+	case GL_GEQUAL:
+		return "GL_GEQUAL";
+	case GL_NOTEQUAL:
+		return "GL_NOTEQUAL";
+	default:
+		return "!!! UNKNOWN !!!";
+	}
+}
+
+static const char * PrimToString( GLenum mode )
+{
+	static char prim[1024];
+
+	if ( mode == GL_TRIANGLES )
+		strcpy( prim, "GL_TRIANGLES" );
+	else if ( mode == GL_TRIANGLE_STRIP )
+		strcpy( prim, "GL_TRIANGLE_STRIP" );
+	else if ( mode == GL_TRIANGLE_FAN )
+		strcpy( prim, "GL_TRIANGLE_FAN" );
+	else if ( mode == GL_QUADS )
+		strcpy( prim, "GL_QUADS" );
+	else if ( mode == GL_QUAD_STRIP )
+		strcpy( prim, "GL_QUAD_STRIP" );
+	else if ( mode == GL_POLYGON )
+		strcpy( prim, "GL_POLYGON" );
+	else if ( mode == GL_POINTS )
+		strcpy( prim, "GL_POINTS" );
+	else if ( mode == GL_LINES )
+		strcpy( prim, "GL_LINES" );
+	else if ( mode == GL_LINE_STRIP )
+		strcpy( prim, "GL_LINE_STRIP" );
+	else if ( mode == GL_LINE_LOOP )
+		strcpy( prim, "GL_LINE_LOOP" );
+	else
+		sprintf( prim, "0x%x", mode );
+
+	return prim;
+}
+
+static const char * CapToString( GLenum cap )
+{
+	static char buffer[1024];
+
+	switch ( cap )
+	{
+	case GL_TEXTURE_2D:
+		return "GL_TEXTURE_2D";
+	case GL_BLEND:
+		return "GL_BLEND";
+	case GL_DEPTH_TEST:
+		return "GL_DEPTH_TEST";
+	case GL_CULL_FACE:
+		return "GL_CULL_FACE";
+	case GL_CLIP_PLANE0:
+		return "GL_CLIP_PLANE0";
+	case GL_COLOR_ARRAY:
+		return "GL_COLOR_ARRAY";
+	case GL_TEXTURE_COORD_ARRAY:
+		return "GL_TEXTURE_COORD_ARRAY";
+	case GL_VERTEX_ARRAY:
+		return "GL_VERTEX_ARRAY";
+	case GL_ALPHA_TEST:
+		return "GL_ALPHA_TEST";
+	case GL_STENCIL_TEST:
+		return "GL_STENCIL_TEST";
+	default:
+		sprintf( buffer, "0x%x", cap );
+	}
+
+	return buffer;
+}
+
+static const char * TypeToString( GLenum t )
+{
+	switch ( t )
+	{
+	case GL_BYTE:
+		return "GL_BYTE";
+	case GL_UNSIGNED_BYTE:
+		return "GL_UNSIGNED_BYTE";
+	case GL_SHORT:
+		return "GL_SHORT";
+	case GL_UNSIGNED_SHORT:
+		return "GL_UNSIGNED_SHORT";
+	case GL_INT:
+		return "GL_INT";
+	case GL_UNSIGNED_INT:
+		return "GL_UNSIGNED_INT";
+	case GL_FLOAT:
+		return "GL_FLOAT";
+	case GL_DOUBLE:
+		return "GL_DOUBLE";
+	default:
+		return "!!! UNKNOWN !!!";
+	}
+}
+
+static void APIENTRY logAccum(GLenum op, GLfloat value)
+{
+	fprintf( glw_state.log_fp, "glAccum\n" );
+	dllAccum( op, value );
+}
+
+static void APIENTRY logAlphaFunc(GLenum func, GLclampf ref)
+{
+	fprintf( glw_state.log_fp, "glAlphaFunc( 0x%x, %f )\n", func, ref );
+	dllAlphaFunc( func, ref );
+}
+
+static GLboolean APIENTRY logAreTexturesResident(GLsizei n, const GLuint *textures, GLboolean *residences)
+{
+	fprintf( glw_state.log_fp, "glAreTexturesResident\n" );
+	return dllAreTexturesResident( n, textures, residences );
+}
+
+static void APIENTRY logArrayElement(GLint i)
+{
+	fprintf( glw_state.log_fp, "glArrayElement\n" );
+	dllArrayElement( i );
+}
+
+static void APIENTRY logBegin(GLenum mode)
+{
+	fprintf( glw_state.log_fp, "glBegin( %s )\n", PrimToString( mode ));
+	dllBegin( mode );
+}
+
+static void APIENTRY logBindTexture(GLenum target, GLuint texture)
+{
+	fprintf( glw_state.log_fp, "glBindTexture( 0x%x, %u )\n", target, texture );
+	dllBindTexture( target, texture );
+}
+
+static void APIENTRY logBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap)
+{
+	fprintf( glw_state.log_fp, "glBitmap\n" );
+	dllBitmap( width, height, xorig, yorig, xmove, ymove, bitmap );
+}
+
+static void BlendToName( char *n, GLenum f )
+{
+	switch ( f )
+	{
+	case GL_ONE:
+		strcpy( n, "GL_ONE" );
+		break;
+	case GL_ZERO:
+		strcpy( n, "GL_ZERO" );
+		break;
+	case GL_SRC_ALPHA:
+		strcpy( n, "GL_SRC_ALPHA" );
+		break;
+	case GL_ONE_MINUS_SRC_ALPHA:
+		strcpy( n, "GL_ONE_MINUS_SRC_ALPHA" );
+		break;
+	case GL_DST_COLOR:
+		strcpy( n, "GL_DST_COLOR" );
+		break;
+	case GL_ONE_MINUS_DST_COLOR:
+		strcpy( n, "GL_ONE_MINUS_DST_COLOR" );
+		break;
+	case GL_DST_ALPHA:
+		strcpy( n, "GL_DST_ALPHA" );
+		break;
+	default:
+		sprintf( n, "0x%x", f );
+	}
+}
+static void APIENTRY logBlendFunc(GLenum sfactor, GLenum dfactor)
+{
+	char sf[128], df[128];
+
+	BlendToName( sf, sfactor );
+	BlendToName( df, dfactor );
+
+	fprintf( glw_state.log_fp, "glBlendFunc( %s, %s )\n", sf, df );
+	dllBlendFunc( sfactor, dfactor );
+}
+
+static void APIENTRY logCallList(GLuint list)
+{
+	fprintf( glw_state.log_fp, "glCallList( %u )\n", list );
+	dllCallList( list );
+}
+
+static void APIENTRY logCallLists(GLsizei n, GLenum type, const void *lists)
+{
+	fprintf( glw_state.log_fp, "glCallLists\n" );
+	dllCallLists( n, type, lists );
+}
+
+static void APIENTRY logClear(GLbitfield mask)
+{
+	fprintf( glw_state.log_fp, "glClear( 0x%x = ", mask );
+
+	if ( mask & GL_COLOR_BUFFER_BIT )
+		fprintf( glw_state.log_fp, "GL_COLOR_BUFFER_BIT " );
+	if ( mask & GL_DEPTH_BUFFER_BIT )
+		fprintf( glw_state.log_fp, "GL_DEPTH_BUFFER_BIT " );
+	if ( mask & GL_STENCIL_BUFFER_BIT )
+		fprintf( glw_state.log_fp, "GL_STENCIL_BUFFER_BIT " );
+	if ( mask & GL_ACCUM_BUFFER_BIT )
+		fprintf( glw_state.log_fp, "GL_ACCUM_BUFFER_BIT " );
+
+	fprintf( glw_state.log_fp, ")\n" );
+	dllClear( mask );
+}
+
+static void APIENTRY logClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
+{
+	fprintf( glw_state.log_fp, "glClearAccum\n" );
+	dllClearAccum( red, green, blue, alpha );
+}
+
+static void APIENTRY logClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
+{
+	fprintf( glw_state.log_fp, "glClearColor\n" );
+	dllClearColor( red, green, blue, alpha );
+}
+
+static void APIENTRY logClearDepth(GLclampd depth)
+{
+	fprintf( glw_state.log_fp, "glClearDepth( %f )\n", ( float ) depth );
+	dllClearDepth( depth );
+}
+
+static void APIENTRY logClearIndex(GLfloat c)
+{
+	fprintf( glw_state.log_fp, "glClearIndex\n" );
+	dllClearIndex( c );
+}
+
+static void APIENTRY logClearStencil(GLint s)
+{
+	fprintf( glw_state.log_fp, "glClearStencil( %d )\n", s );
+	dllClearStencil( s );
+}
+
+static void APIENTRY logClipPlane(GLenum plane, const GLdouble *equation)
+{
+	fprintf( glw_state.log_fp, "glClipPlane\n" );
+	dllClipPlane( plane, equation );
+}
+
+static void APIENTRY logColor3b(GLbyte red, GLbyte green, GLbyte blue)
+{
+	fprintf( glw_state.log_fp, "glColor3b\n" );
+	dllColor3b( red, green, blue );
+}
+
+static void APIENTRY logColor3bv(const GLbyte *v)
+{
+	fprintf( glw_state.log_fp, "glColor3bv\n" );
+	dllColor3bv( v );
+}
+
+static void APIENTRY logColor3d(GLdouble red, GLdouble green, GLdouble blue)
+{
+	fprintf( glw_state.log_fp, "glColor3d\n" );
+	dllColor3d( red, green, blue );
+}
+
+static void APIENTRY logColor3dv(const GLdouble *v)
+{
+	fprintf( glw_state.log_fp, "glColor3dv\n" );
+	dllColor3dv( v );
+}
+
+static void APIENTRY logColor3f(GLfloat red, GLfloat green, GLfloat blue)
+{
+	fprintf( glw_state.log_fp, "glColor3f\n" );
+	dllColor3f( red, green, blue );
+}
+
+static void APIENTRY logColor3fv(const GLfloat *v)
+{
+	fprintf( glw_state.log_fp, "glColor3fv\n" );
+	dllColor3fv( v );
+}
+
+static void APIENTRY logColor3i(GLint red, GLint green, GLint blue)
+{
+	fprintf( glw_state.log_fp, "glColor3i\n" );
+	dllColor3i( red, green, blue );
+}
+
+static void APIENTRY logColor3iv(const GLint *v)
+{
+	fprintf( glw_state.log_fp, "glColor3iv\n" );
+	dllColor3iv( v );
+}
+
+static void APIENTRY logColor3s(GLshort red, GLshort green, GLshort blue)
+{
+	fprintf( glw_state.log_fp, "glColor3s\n" );
+	dllColor3s( red, green, blue );
+}
+
+static void APIENTRY logColor3sv(const GLshort *v)
+{
+	fprintf( glw_state.log_fp, "glColor3sv\n" );
+	dllColor3sv( v );
+}
+
+static void APIENTRY logColor3ub(GLubyte red, GLubyte green, GLubyte blue)
+{
+	fprintf( glw_state.log_fp, "glColor3ub\n" );
+	dllColor3ub( red, green, blue );
+}
+
+static void APIENTRY logColor3ubv(const GLubyte *v)
+{
+	fprintf( glw_state.log_fp, "glColor3ubv\n" );
+	dllColor3ubv( v );
+}
+
+#define SIG( x ) fprintf( glw_state.log_fp, x "\n" )
+
+static void APIENTRY logColor3ui(GLuint red, GLuint green, GLuint blue)
+{
+	SIG( "glColor3ui" );
+	dllColor3ui( red, green, blue );
+}
+
+static void APIENTRY logColor3uiv(const GLuint *v)
+{
+	SIG( "glColor3uiv" );
+	dllColor3uiv( v );
+}
+
+static void APIENTRY logColor3us(GLushort red, GLushort green, GLushort blue)
+{
+	SIG( "glColor3us" );
+	dllColor3us( red, green, blue );
+}
+
+static void APIENTRY logColor3usv(const GLushort *v)
+{
+	SIG( "glColor3usv" );
+	dllColor3usv( v );
+}
+
+static void APIENTRY logColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha)
+{
+	SIG( "glColor4b" );
+	dllColor4b( red, green, blue, alpha );
+}
+
+static void APIENTRY logColor4bv(const GLbyte *v)
+{
+	SIG( "glColor4bv" );
+	dllColor4bv( v );
+}
+
+static void APIENTRY logColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha)
+{
+	SIG( "glColor4d" );
+	dllColor4d( red, green, blue, alpha );
+}
+static void APIENTRY logColor4dv(const GLdouble *v)
+{
+	SIG( "glColor4dv" );
+	dllColor4dv( v );
+}
+static void APIENTRY logColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
+{
+	fprintf( glw_state.log_fp, "glColor4f( %f,%f,%f,%f )\n", red, green, blue, alpha );
+	dllColor4f( red, green, blue, alpha );
+}
+static void APIENTRY logColor4fv(const GLfloat *v)
+{
+	fprintf( glw_state.log_fp, "glColor4fv( %f,%f,%f,%f )\n", v[0], v[1], v[2], v[3] );
+	dllColor4fv( v );
+}
+static void APIENTRY logColor4i(GLint red, GLint green, GLint blue, GLint alpha)
+{
+	SIG( "glColor4i" );
+	dllColor4i( red, green, blue, alpha );
+}
+static void APIENTRY logColor4iv(const GLint *v)
+{
+	SIG( "glColor4iv" );
+	dllColor4iv( v );
+}
+static void APIENTRY logColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha)
+{
+	SIG( "glColor4s" );
+	dllColor4s( red, green, blue, alpha );
+}
+static void APIENTRY logColor4sv(const GLshort *v)
+{
+	SIG( "glColor4sv" );
+	dllColor4sv( v );
+}
+static void APIENTRY logColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
+{
+	SIG( "glColor4b" );
+	dllColor4b( red, green, blue, alpha );
+}
+static void APIENTRY logColor4ubv(const GLubyte *v)
+{
+	SIG( "glColor4ubv" );
+	dllColor4ubv( v );
+}
+static void APIENTRY logColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha)
+{
+	SIG( "glColor4ui" );
+	dllColor4ui( red, green, blue, alpha );
+}
+static void APIENTRY logColor4uiv(const GLuint *v)
+{
+	SIG( "glColor4uiv" );
+	dllColor4uiv( v );
+}
+static void APIENTRY logColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha)
+{
+	SIG( "glColor4us" );
+	dllColor4us( red, green, blue, alpha );
+}
+static void APIENTRY logColor4usv(const GLushort *v)
+{
+	SIG( "glColor4usv" );
+	dllColor4usv( v );
+}
+static void APIENTRY logColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
+{
+	SIG( "glColorMask" );
+	dllColorMask( red, green, blue, alpha );
+}
+static void APIENTRY logColorMaterial(GLenum face, GLenum mode)
+{
+	SIG( "glColorMaterial" );
+	dllColorMaterial( face, mode );
+}
+
+static void APIENTRY logColorPointer(GLint size, GLenum type, GLsizei stride, const void *pointer)
+{
+	fprintf( glw_state.log_fp, "glColorPointer( %d, %s, %d, MEM )\n", size, TypeToString( type ), stride );
+	dllColorPointer( size, type, stride, pointer );
+}
+
+static void APIENTRY logCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type)
+{
+	SIG( "glCopyPixels" );
+	dllCopyPixels( x, y, width, height, type );
+}
+
+static void APIENTRY logCopyTexImage1D(GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border)
+{
+	SIG( "glCopyTexImage1D" );
+	dllCopyTexImage1D( target, level, internalFormat, x, y, width, border );
+}
+
+static void APIENTRY logCopyTexImage2D(GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
+{
+	SIG( "glCopyTexImage2D" );
+	dllCopyTexImage2D( target, level, internalFormat, x, y, width, height, border );
+}
+
+static void APIENTRY logCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
+{
+	SIG( "glCopyTexSubImage1D" );
+	dllCopyTexSubImage1D( target, level, xoffset, x, y, width );
+}
+
+static void APIENTRY logCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
+{
+	SIG( "glCopyTexSubImage2D" );
+	dllCopyTexSubImage2D( target, level, xoffset, yoffset, x, y, width, height );
+}
+
+static void APIENTRY logCullFace(GLenum mode)
+{
+	fprintf( glw_state.log_fp, "glCullFace( %s )\n", ( mode == GL_FRONT ) ? "GL_FRONT" : "GL_BACK" );
+	dllCullFace( mode );
+}
+
+static void APIENTRY logDeleteLists(GLuint list, GLsizei range)
+{
+	SIG( "glDeleteLists" );
+	dllDeleteLists( list, range );
+}
+
+static void APIENTRY logDeleteTextures(GLsizei n, const GLuint *textures)
+{
+	SIG( "glDeleteTextures" );
+	dllDeleteTextures( n, textures );
+}
+
+static void APIENTRY logDepthFunc(GLenum func)
+{
+	fprintf( glw_state.log_fp, "glDepthFunc( %s )\n", FuncToString( func ) );
+	dllDepthFunc( func );
+}
+
+static void APIENTRY logDepthMask(GLboolean flag)
+{
+	fprintf( glw_state.log_fp, "glDepthMask( %s )\n", BooleanToString( flag ) );
+	dllDepthMask( flag );
+}
+
+static void APIENTRY logDepthRange(GLclampd zNear, GLclampd zFar)
+{
+	fprintf( glw_state.log_fp, "glDepthRange( %f, %f )\n", ( float ) zNear, ( float ) zFar );
+	dllDepthRange( zNear, zFar );
+}
+
+static void APIENTRY logDisable(GLenum cap)
+{
+	fprintf( glw_state.log_fp, "glDisable( %s )\n", CapToString( cap ) );
+	dllDisable( cap );
+}
+
+static void APIENTRY logDisableClientState(GLenum array)
+{
+	fprintf( glw_state.log_fp, "glDisableClientState( %s )\n", CapToString( array ) );
+	dllDisableClientState( array );
+}
+
+static void APIENTRY logDrawArrays(GLenum mode, GLint first, GLsizei count)
+{
+	SIG( "glDrawArrays" );
+	dllDrawArrays( mode, first, count );
+}
+
+static void APIENTRY logDrawBuffer(GLenum mode)
+{
+	SIG( "glDrawBuffer" );
+	dllDrawBuffer( mode );
+}
+
+static void APIENTRY logDrawElements(GLenum mode, GLsizei count, GLenum type, const void *indices)
+{
+	fprintf( glw_state.log_fp, "glDrawElements( %s, %d, %s, MEM )\n", PrimToString( mode ), count, TypeToString( type ) );
+	dllDrawElements( mode, count, type, indices );
+}
+
+static void APIENTRY logDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels)
+{
+	SIG( "glDrawPixels" );
+	dllDrawPixels( width, height, format, type, pixels );
+}
+
+static void APIENTRY logEdgeFlag(GLboolean flag)
+{
+	SIG( "glEdgeFlag" );
+	dllEdgeFlag( flag );
+}
+
+static void APIENTRY logEdgeFlagPointer(GLsizei stride, const void *pointer)
+{
+	SIG( "glEdgeFlagPointer" );
+	dllEdgeFlagPointer( stride, pointer );
+}
+
+static void APIENTRY logEdgeFlagv(const GLboolean *flag)
+{
+	SIG( "glEdgeFlagv" );
+	dllEdgeFlagv( flag );
+}
+
+static void APIENTRY logEnable(GLenum cap)
+{
+	fprintf( glw_state.log_fp, "glEnable( %s )\n", CapToString( cap ) );
+	dllEnable( cap );
+}
+
+static void APIENTRY logEnableClientState(GLenum array)
+{
+	fprintf( glw_state.log_fp, "glEnableClientState( %s )\n", CapToString( array ) );
+	dllEnableClientState( array );
+}
+
+static void APIENTRY logEnd(void)
+{
+	SIG( "glEnd" );
+	dllEnd();
+}
+
+static void APIENTRY logEndList(void)
+{
+	SIG( "glEndList" );
+	dllEndList();
+}
+
+static void APIENTRY logEvalCoord1d(GLdouble u)
+{
+	SIG( "glEvalCoord1d" );
+	dllEvalCoord1d( u );
+}
+
+static void APIENTRY logEvalCoord1dv(const GLdouble *u)
+{
+	SIG( "glEvalCoord1dv" );
+	dllEvalCoord1dv( u );
+}
+
+static void APIENTRY logEvalCoord1f(GLfloat u)
+{
+	SIG( "glEvalCoord1f" );
+	dllEvalCoord1f( u );
+}
+
+static void APIENTRY logEvalCoord1fv(const GLfloat *u)
+{
+	SIG( "glEvalCoord1fv" );
+	dllEvalCoord1fv( u );
+}
+static void APIENTRY logEvalCoord2d(GLdouble u, GLdouble v)
+{
+	SIG( "glEvalCoord2d" );
+	dllEvalCoord2d( u, v );
+}
+static void APIENTRY logEvalCoord2dv(const GLdouble *u)
+{
+	SIG( "glEvalCoord2dv" );
+	dllEvalCoord2dv( u );
+}
+static void APIENTRY logEvalCoord2f(GLfloat u, GLfloat v)
+{
+	SIG( "glEvalCoord2f" );
+	dllEvalCoord2f( u, v );
+}
+static void APIENTRY logEvalCoord2fv(const GLfloat *u)
+{
+	SIG( "glEvalCoord2fv" );
+	dllEvalCoord2fv( u );
+}
+
+static void APIENTRY logEvalMesh1(GLenum mode, GLint i1, GLint i2)
+{
+	SIG( "glEvalMesh1" );
+	dllEvalMesh1( mode, i1, i2 );
+}
+static void APIENTRY logEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)
+{
+	SIG( "glEvalMesh2" );
+	dllEvalMesh2( mode, i1, i2, j1, j2 );
+}
+static void APIENTRY logEvalPoint1(GLint i)
+{
+	SIG( "glEvalPoint1" );
+	dllEvalPoint1( i );
+}
+static void APIENTRY logEvalPoint2(GLint i, GLint j)
+{
+	SIG( "glEvalPoint2" );
+	dllEvalPoint2( i, j );
+}
+
+static void APIENTRY logFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer)
+{
+	SIG( "glFeedbackBuffer" );
+	dllFeedbackBuffer( size, type, buffer );
+}
+
+static void APIENTRY logFinish(void)
+{
+	SIG( "glFinish" );
+	dllFinish();
+}
+
+static void APIENTRY logFlush(void)
+{
+	SIG( "glFlush" );
+	dllFlush();
+}
+
+static void APIENTRY logFogf(GLenum pname, GLfloat param)
+{
+	SIG( "glFogf" );
+	dllFogf( pname, param );
+}
+
+static void APIENTRY logFogfv(GLenum pname, const GLfloat *params)
+{
+	SIG( "glFogfv" );
+	dllFogfv( pname, params );
+}
+
+static void APIENTRY logFogi(GLenum pname, GLint param)
+{
+	SIG( "glFogi" );
+	dllFogi( pname, param );
+}
+
+static void APIENTRY logFogiv(GLenum pname, const GLint *params)
+{
+	SIG( "glFogiv" );
+	dllFogiv( pname, params );
+}
+
+static void APIENTRY logFrontFace(GLenum mode)
+{
+	SIG( "glFrontFace" );
+	dllFrontFace( mode );
+}
+
+static void APIENTRY logFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
+{
+	SIG( "glFrustum" );
+	dllFrustum( left, right, bottom, top, zNear, zFar );
+}
+
+static GLuint APIENTRY logGenLists(GLsizei range)
+{
+	SIG( "glGenLists" );
+	return dllGenLists( range );
+}
+
+static void APIENTRY logGenTextures(GLsizei n, GLuint *textures)
+{
+	SIG( "glGenTextures" );
+	dllGenTextures( n, textures );
+}
+
+static void APIENTRY logGetBooleanv(GLenum pname, GLboolean *params)
+{
+	SIG( "glGetBooleanv" );
+	dllGetBooleanv( pname, params );
+}
+
+static void APIENTRY logGetClipPlane(GLenum plane, GLdouble *equation)
+{
+	SIG( "glGetClipPlane" );
+	dllGetClipPlane( plane, equation );
+}
+
+static void APIENTRY logGetDoublev(GLenum pname, GLdouble *params)
+{
+	SIG( "glGetDoublev" );
+	dllGetDoublev( pname, params );
+}
+
+static GLenum APIENTRY logGetError(void)
+{
+	SIG( "glGetError" );
+	return dllGetError();
+}
+
+static void APIENTRY logGetFloatv(GLenum pname, GLfloat *params)
+{
+	SIG( "glGetFloatv" );
+	dllGetFloatv( pname, params );
+}
+
+static void APIENTRY logGetIntegerv(GLenum pname, GLint *params)
+{
+	SIG( "glGetIntegerv" );
+	dllGetIntegerv( pname, params );
+}
+
+static void APIENTRY logGetLightfv(GLenum light, GLenum pname, GLfloat *params)
+{
+	SIG( "glGetLightfv" );
+	dllGetLightfv( light, pname, params );
+}
+
+static void APIENTRY logGetLightiv(GLenum light, GLenum pname, GLint *params)
+{
+	SIG( "glGetLightiv" );
+	dllGetLightiv( light, pname, params );
+}
+
+static void APIENTRY logGetMapdv(GLenum target, GLenum query, GLdouble *v)
+{
+	SIG( "glGetMapdv" );
+	dllGetMapdv( target, query, v );
+}
+
+static void APIENTRY logGetMapfv(GLenum target, GLenum query, GLfloat *v)
+{
+	SIG( "glGetMapfv" );
+	dllGetMapfv( target, query, v );
+}
+
+static void APIENTRY logGetMapiv(GLenum target, GLenum query, GLint *v)
+{
+	SIG( "glGetMapiv" );
+	dllGetMapiv( target, query, v );
+}
+
+static void APIENTRY logGetMaterialfv(GLenum face, GLenum pname, GLfloat *params)
+{
+	SIG( "glGetMaterialfv" );
+	dllGetMaterialfv( face, pname, params );
+}
+
+static void APIENTRY logGetMaterialiv(GLenum face, GLenum pname, GLint *params)
+{
+	SIG( "glGetMaterialiv" );
+	dllGetMaterialiv( face, pname, params );
+}
+
+static void APIENTRY logGetPixelMapfv(GLenum map, GLfloat *values)
+{
+	SIG( "glGetPixelMapfv" );
+	dllGetPixelMapfv( map, values );
+}
+
+static void APIENTRY logGetPixelMapuiv(GLenum map, GLuint *values)
+{
+	SIG( "glGetPixelMapuiv" );
+	dllGetPixelMapuiv( map, values );
+}
+
+static void APIENTRY logGetPixelMapusv(GLenum map, GLushort *values)
+{
+	SIG( "glGetPixelMapusv" );
+	dllGetPixelMapusv( map, values );
+}
+
+static void APIENTRY logGetPointerv(GLenum pname, GLvoid* *params)
+{
+	SIG( "glGetPointerv" );
+	dllGetPointerv( pname, params );
+}
+
+static void APIENTRY logGetPolygonStipple(GLubyte *mask)
+{
+	SIG( "glGetPolygonStipple" );
+	dllGetPolygonStipple( mask );
+}
+
+static const GLubyte * APIENTRY logGetString(GLenum name)
+{
+	SIG( "glGetString" );
+	return dllGetString( name );
+}
+
+static void APIENTRY logGetTexEnvfv(GLenum target, GLenum pname, GLfloat *params)
+{
+	SIG( "glGetTexEnvfv" );
+	dllGetTexEnvfv( target, pname, params );
+}
+
+static void APIENTRY logGetTexEnviv(GLenum target, GLenum pname, GLint *params)
+{
+	SIG( "glGetTexEnviv" );
+	dllGetTexEnviv( target, pname, params );
+}
+
+static void APIENTRY logGetTexGendv(GLenum coord, GLenum pname, GLdouble *params)
+{
+	SIG( "glGetTexGendv" );
+	dllGetTexGendv( coord, pname, params );
+}
+
+static void APIENTRY logGetTexGenfv(GLenum coord, GLenum pname, GLfloat *params)
+{
+	SIG( "glGetTexGenfv" );
+	dllGetTexGenfv( coord, pname, params );
+}
+
+static void APIENTRY logGetTexGeniv(GLenum coord, GLenum pname, GLint *params)
+{
+	SIG( "glGetTexGeniv" );
+	dllGetTexGeniv( coord, pname, params );
+}
+
+static void APIENTRY logGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, void *pixels)
+{
+	SIG( "glGetTexImage" );
+	dllGetTexImage( target, level, format, type, pixels );
+}
+static void APIENTRY logGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params )
+{
+	SIG( "glGetTexLevelParameterfv" );
+	dllGetTexLevelParameterfv( target, level, pname, params );
+}
+
+static void APIENTRY logGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params)
+{
+	SIG( "glGetTexLevelParameteriv" );
+	dllGetTexLevelParameteriv( target, level, pname, params );
+}
+
+static void APIENTRY logGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params)
+{
+	SIG( "glGetTexParameterfv" );
+	dllGetTexParameterfv( target, pname, params );
+}
+
+static void APIENTRY logGetTexParameteriv(GLenum target, GLenum pname, GLint *params)
+{
+	SIG( "glGetTexParameteriv" );
+	dllGetTexParameteriv( target, pname, params );
+}
+
+static void APIENTRY logHint(GLenum target, GLenum mode)
+{
+	fprintf( glw_state.log_fp, "glHint( 0x%x, 0x%x )\n", target, mode );
+	dllHint( target, mode );
+}
+
+static void APIENTRY logIndexMask(GLuint mask)
+{
+	SIG( "glIndexMask" );
+	dllIndexMask( mask );
+}
+
+static void APIENTRY logIndexPointer(GLenum type, GLsizei stride, const void *pointer)
+{
+	SIG( "glIndexPointer" );
+	dllIndexPointer( type, stride, pointer );
+}
+
+static void APIENTRY logIndexd(GLdouble c)
+{
+	SIG( "glIndexd" );
+	dllIndexd( c );
+}
+
+static void APIENTRY logIndexdv(const GLdouble *c)
+{
+	SIG( "glIndexdv" );
+	dllIndexdv( c );
+}
+
+static void APIENTRY logIndexf(GLfloat c)
+{
+	SIG( "glIndexf" );
+	dllIndexf( c );
+}
+
+static void APIENTRY logIndexfv(const GLfloat *c)
+{
+	SIG( "glIndexfv" );
+	dllIndexfv( c );
+}
+
+static void APIENTRY logIndexi(GLint c)
+{
+	SIG( "glIndexi" );
+	dllIndexi( c );
+}
+
+static void APIENTRY logIndexiv(const GLint *c)
+{
+	SIG( "glIndexiv" );
+	dllIndexiv( c );
+}
+
+static void APIENTRY logIndexs(GLshort c)
+{
+	SIG( "glIndexs" );
+	dllIndexs( c );
+}
+
+static void APIENTRY logIndexsv(const GLshort *c)
+{
+	SIG( "glIndexsv" );
+	dllIndexsv( c );
+}
+
+static void APIENTRY logIndexub(GLubyte c)
+{
+	SIG( "glIndexub" );
+	dllIndexub( c );
+}
+
+static void APIENTRY logIndexubv(const GLubyte *c)
+{
+	SIG( "glIndexubv" );
+	dllIndexubv( c );
+}
+
+static void APIENTRY logInitNames(void)
+{
+	SIG( "glInitNames" );
+	dllInitNames();
+}
+
+static void APIENTRY logInterleavedArrays(GLenum format, GLsizei stride, const void *pointer)
+{
+	SIG( "glInterleavedArrays" );
+	dllInterleavedArrays( format, stride, pointer );
+}
+
+static GLboolean APIENTRY logIsEnabled(GLenum cap)
+{
+	SIG( "glIsEnabled" );
+	return dllIsEnabled( cap );
+}
+static GLboolean APIENTRY logIsList(GLuint list)
+{
+	SIG( "glIsList" );
+	return dllIsList( list );
+}
+static GLboolean APIENTRY logIsTexture(GLuint texture)
+{
+	SIG( "glIsTexture" );
+	return dllIsTexture( texture );
+}
+
+static void APIENTRY logLightModelf(GLenum pname, GLfloat param)
+{
+	SIG( "glLightModelf" );
+	dllLightModelf( pname, param );
+}
+
+static void APIENTRY logLightModelfv(GLenum pname, const GLfloat *params)
+{
+	SIG( "glLightModelfv" );
+	dllLightModelfv( pname, params );
+}
+
+static void APIENTRY logLightModeli(GLenum pname, GLint param)
+{
+	SIG( "glLightModeli" );
+	dllLightModeli( pname, param );
+
+}
+
+static void APIENTRY logLightModeliv(GLenum pname, const GLint *params)
+{
+	SIG( "glLightModeliv" );
+	dllLightModeliv( pname, params );
+}
+
+static void APIENTRY logLightf(GLenum light, GLenum pname, GLfloat param)
+{
+	SIG( "glLightf" );
+	dllLightf( light, pname, param );
+}
+
+static void APIENTRY logLightfv(GLenum light, GLenum pname, const GLfloat *params)
+{
+	SIG( "glLightfv" );
+	dllLightfv( light, pname, params );
+}
+
+static void APIENTRY logLighti(GLenum light, GLenum pname, GLint param)
+{
+	SIG( "glLighti" );
+	dllLighti( light, pname, param );
+}
+
+static void APIENTRY logLightiv(GLenum light, GLenum pname, const GLint *params)
+{
+	SIG( "glLightiv" );
+	dllLightiv( light, pname, params );
+}
+
+static void APIENTRY logLineStipple(GLint factor, GLushort pattern)
+{
+	SIG( "glLineStipple" );
+	dllLineStipple( factor, pattern );
+}
+
+static void APIENTRY logLineWidth(GLfloat width)
+{
+	SIG( "glLineWidth" );
+	dllLineWidth( width );
+}
+
+static void APIENTRY logListBase(GLuint base)
+{
+	SIG( "glListBase" );
+	dllListBase( base );
+}
+
+static void APIENTRY logLoadIdentity(void)
+{
+	SIG( "glLoadIdentity" );
+	dllLoadIdentity();
+}
+
+static void APIENTRY logLoadMatrixd(const GLdouble *m)
+{
+	SIG( "glLoadMatrixd" );
+	dllLoadMatrixd( m );
+}
+
+static void APIENTRY logLoadMatrixf(const GLfloat *m)
+{
+	SIG( "glLoadMatrixf" );
+	dllLoadMatrixf( m );
+}
+
+static void APIENTRY logLoadName(GLuint name)
+{
+	SIG( "glLoadName" );
+	dllLoadName( name );
+}
+
+static void APIENTRY logLogicOp(GLenum opcode)
+{
+	SIG( "glLogicOp" );
+	dllLogicOp( opcode );
+}
+
+static void APIENTRY logMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points)
+{
+	SIG( "glMap1d" );
+	dllMap1d( target, u1, u2, stride, order, points );
+}
+
+static void APIENTRY logMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points)
+{
+	SIG( "glMap1f" );
+	dllMap1f( target, u1, u2, stride, order, points );
+}
+
+static void APIENTRY logMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points)
+{
+	SIG( "glMap2d" );
+	dllMap2d( target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points );
+}
+
+static void APIENTRY logMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points)
+{
+	SIG( "glMap2f" );
+	dllMap2f( target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points );
+}
+
+static void APIENTRY logMapGrid1d(GLint un, GLdouble u1, GLdouble u2)
+{
+	SIG( "glMapGrid1d" );
+	dllMapGrid1d( un, u1, u2 );
+}
+
+static void APIENTRY logMapGrid1f(GLint un, GLfloat u1, GLfloat u2)
+{
+	SIG( "glMapGrid1f" );
+	dllMapGrid1f( un, u1, u2 );
+}
+
+static void APIENTRY logMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2)
+{
+	SIG( "glMapGrid2d" );
+	dllMapGrid2d( un, u1, u2, vn, v1, v2 );
+}
+static void APIENTRY logMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2)
+{
+	SIG( "glMapGrid2f" );
+	dllMapGrid2f( un, u1, u2, vn, v1, v2 );
+}
+static void APIENTRY logMaterialf(GLenum face, GLenum pname, GLfloat param)
+{
+	SIG( "glMaterialf" );
+	dllMaterialf( face, pname, param );
+}
+static void APIENTRY logMaterialfv(GLenum face, GLenum pname, const GLfloat *params)
+{
+	SIG( "glMaterialfv" );
+	dllMaterialfv( face, pname, params );
+}
+
+static void APIENTRY logMateriali(GLenum face, GLenum pname, GLint param)
+{
+	SIG( "glMateriali" );
+	dllMateriali( face, pname, param );
+}
+
+static void APIENTRY logMaterialiv(GLenum face, GLenum pname, const GLint *params)
+{
+	SIG( "glMaterialiv" );
+	dllMaterialiv( face, pname, params );
+}
+
+static void APIENTRY logMatrixMode(GLenum mode)
+{
+	SIG( "glMatrixMode" );
+	dllMatrixMode( mode );
+}
+
+static void APIENTRY logMultMatrixd(const GLdouble *m)
+{
+	SIG( "glMultMatrixd" );
+	dllMultMatrixd( m );
+}
+
+static void APIENTRY logMultMatrixf(const GLfloat *m)
+{
+	SIG( "glMultMatrixf" );
+	dllMultMatrixf( m );
+}
+
+static void APIENTRY logNewList(GLuint list, GLenum mode)
+{
+	SIG( "glNewList" );
+	dllNewList( list, mode );
+}
+
+static void APIENTRY logNormal3b(GLbyte nx, GLbyte ny, GLbyte nz)
+{
+	SIG ("glNormal3b" );
+	dllNormal3b( nx, ny, nz );
+}
+
+static void APIENTRY logNormal3bv(const GLbyte *v)
+{
+	SIG( "glNormal3bv" );
+	dllNormal3bv( v );
+}
+
+static void APIENTRY logNormal3d(GLdouble nx, GLdouble ny, GLdouble nz)
+{
+	SIG( "glNormal3d" );
+	dllNormal3d( nx, ny, nz );
+}
+
+static void APIENTRY logNormal3dv(const GLdouble *v)
+{
+	SIG( "glNormal3dv" );
+	dllNormal3dv( v );
+}
+
+static void APIENTRY logNormal3f(GLfloat nx, GLfloat ny, GLfloat nz)
+{
+	SIG( "glNormal3f" );
+	dllNormal3f( nx, ny, nz );
+}
+
+static void APIENTRY logNormal3fv(const GLfloat *v)
+{
+	SIG( "glNormal3fv" );
+	dllNormal3fv( v );
+}
+static void APIENTRY logNormal3i(GLint nx, GLint ny, GLint nz)
+{
+	SIG( "glNormal3i" );
+	dllNormal3i( nx, ny, nz );
+}
+static void APIENTRY logNormal3iv(const GLint *v)
+{
+	SIG( "glNormal3iv" );
+	dllNormal3iv( v );
+}
+static void APIENTRY logNormal3s(GLshort nx, GLshort ny, GLshort nz)
+{
+	SIG( "glNormal3s" );
+	dllNormal3s( nx, ny, nz );
+}
+static void APIENTRY logNormal3sv(const GLshort *v)
+{
+	SIG( "glNormal3sv" );
+	dllNormal3sv( v );
+}
+static void APIENTRY logNormalPointer(GLenum type, GLsizei stride, const void *pointer)
+{
+	SIG( "glNormalPointer" );
+	dllNormalPointer( type, stride, pointer );
+}
+static void APIENTRY logOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
+{
+	SIG( "glOrtho" );
+	dllOrtho( left, right, bottom, top, zNear, zFar );
+}
+
+static void APIENTRY logPassThrough(GLfloat token)
+{
+	SIG( "glPassThrough" );
+	dllPassThrough( token );
+}
+
+static void APIENTRY logPixelMapfv(GLenum map, GLsizei mapsize, const GLfloat *values)
+{
+	SIG( "glPixelMapfv" );
+	dllPixelMapfv( map, mapsize, values );
+}
+
+static void APIENTRY logPixelMapuiv(GLenum map, GLsizei mapsize, const GLuint *values)
+{
+	SIG( "glPixelMapuiv" );
+	dllPixelMapuiv( map, mapsize, values );
+}
+
+static void APIENTRY logPixelMapusv(GLenum map, GLsizei mapsize, const GLushort *values)
+{
+	SIG( "glPixelMapusv" );
+	dllPixelMapusv( map, mapsize, values );
+}
+static void APIENTRY logPixelStoref(GLenum pname, GLfloat param)
+{
+	SIG( "glPixelStoref" );
+	dllPixelStoref( pname, param );
+}
+static void APIENTRY logPixelStorei(GLenum pname, GLint param)
+{
+	SIG( "glPixelStorei" );
+	dllPixelStorei( pname, param );
+}
+static void APIENTRY logPixelTransferf(GLenum pname, GLfloat param)
+{
+	SIG( "glPixelTransferf" );
+	dllPixelTransferf( pname, param );
+}
+
+static void APIENTRY logPixelTransferi(GLenum pname, GLint param)
+{
+	SIG( "glPixelTransferi" );
+	dllPixelTransferi( pname, param );
+}
+
+static void APIENTRY logPixelZoom(GLfloat xfactor, GLfloat yfactor)
+{
+	SIG( "glPixelZoom" );
+	dllPixelZoom( xfactor, yfactor );
+}
+
+static void APIENTRY logPointSize(GLfloat size)
+{
+	SIG( "glPointSize" );
+	dllPointSize( size );
+}
+
+static void APIENTRY logPolygonMode(GLenum face, GLenum mode)
+{
+	fprintf( glw_state.log_fp, "glPolygonMode( 0x%x, 0x%x )\n", face, mode );
+	dllPolygonMode( face, mode );
+}
+
+static void APIENTRY logPolygonOffset(GLfloat factor, GLfloat units)
+{
+	SIG( "glPolygonOffset" );
+	dllPolygonOffset( factor, units );
+}
+static void APIENTRY logPolygonStipple(const GLubyte *mask )
+{
+	SIG( "glPolygonStipple" );
+	dllPolygonStipple( mask );
+}
+static void APIENTRY logPopAttrib(void)
+{
+	SIG( "glPopAttrib" );
+	dllPopAttrib();
+}
+
+static void APIENTRY logPopClientAttrib(void)
+{
+	SIG( "glPopClientAttrib" );
+	dllPopClientAttrib();
+}
+
+static void APIENTRY logPopMatrix(void)
+{
+	SIG( "glPopMatrix" );
+	dllPopMatrix();
+}
+
+static void APIENTRY logPopName(void)
+{
+	SIG( "glPopName" );
+	dllPopName();
+}
+
+static void APIENTRY logPrioritizeTextures(GLsizei n, const GLuint *textures, const GLclampf *priorities)
+{
+	SIG( "glPrioritizeTextures" );
+	dllPrioritizeTextures( n, textures, priorities );
+}
+
+static void APIENTRY logPushAttrib(GLbitfield mask)
+{
+	SIG( "glPushAttrib" );
+	dllPushAttrib( mask );
+}
+
+static void APIENTRY logPushClientAttrib(GLbitfield mask)
+{
+	SIG( "glPushClientAttrib" );
+	dllPushClientAttrib( mask );
+}
+
+static void APIENTRY logPushMatrix(void)
+{
+	SIG( "glPushMatrix" );
+	dllPushMatrix();
+}
+
+static void APIENTRY logPushName(GLuint name)
+{
+	SIG( "glPushName" );
+	dllPushName( name );
+}
+
+static void APIENTRY logRasterPos2d(GLdouble x, GLdouble y)
+{
+	SIG ("glRasterPot2d" );
+	dllRasterPos2d( x, y );
+}
+
+static void APIENTRY logRasterPos2dv(const GLdouble *v)
+{
+	SIG( "glRasterPos2dv" );
+	dllRasterPos2dv( v );
+}
+
+static void APIENTRY logRasterPos2f(GLfloat x, GLfloat y)
+{
+	SIG( "glRasterPos2f" );
+	dllRasterPos2f( x, y );
+}
+static void APIENTRY logRasterPos2fv(const GLfloat *v)
+{
+	SIG( "glRasterPos2dv" );
+	dllRasterPos2fv( v );
+}
+static void APIENTRY logRasterPos2i(GLint x, GLint y)
+{
+	SIG( "glRasterPos2if" );
+	dllRasterPos2i( x, y );
+}
+static void APIENTRY logRasterPos2iv(const GLint *v)
+{
+	SIG( "glRasterPos2iv" );
+	dllRasterPos2iv( v );
+}
+static void APIENTRY logRasterPos2s(GLshort x, GLshort y)
+{
+	SIG( "glRasterPos2s" );
+	dllRasterPos2s( x, y );
+}
+static void APIENTRY logRasterPos2sv(const GLshort *v)
+{
+	SIG( "glRasterPos2sv" );
+	dllRasterPos2sv( v );
+}
+static void APIENTRY logRasterPos3d(GLdouble x, GLdouble y, GLdouble z)
+{
+	SIG( "glRasterPos3d" );
+	dllRasterPos3d( x, y, z );
+}
+static void APIENTRY logRasterPos3dv(const GLdouble *v)
+{
+	SIG( "glRasterPos3dv" );
+	dllRasterPos3dv( v );
+}
+static void APIENTRY logRasterPos3f(GLfloat x, GLfloat y, GLfloat z)
+{
+	SIG( "glRasterPos3f" );
+	dllRasterPos3f( x, y, z );
+}
+static void APIENTRY logRasterPos3fv(const GLfloat *v)
+{
+	SIG( "glRasterPos3fv" );
+	dllRasterPos3fv( v );
+}
+static void APIENTRY logRasterPos3i(GLint x, GLint y, GLint z)
+{
+	SIG( "glRasterPos3i" );
+	dllRasterPos3i( x, y, z );
+}
+static void APIENTRY logRasterPos3iv(const GLint *v)
+{
+	SIG( "glRasterPos3iv" );
+	dllRasterPos3iv( v );
+}
+static void APIENTRY logRasterPos3s(GLshort x, GLshort y, GLshort z)
+{
+	SIG( "glRasterPos3s" );
+	dllRasterPos3s( x, y, z );
+}
+static void APIENTRY logRasterPos3sv(const GLshort *v)
+{
+	SIG( "glRasterPos3sv" );
+	dllRasterPos3sv( v );
+}
+static void APIENTRY logRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
+{
+	SIG( "glRasterPos4d" );
+	dllRasterPos4d( x, y, z, w );
+}
+static void APIENTRY logRasterPos4dv(const GLdouble *v)
+{
+	SIG( "glRasterPos4dv" );
+	dllRasterPos4dv( v );
+}
+static void APIENTRY logRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
+{
+	SIG( "glRasterPos4f" );
+	dllRasterPos4f( x, y, z, w );
+}
+static void APIENTRY logRasterPos4fv(const GLfloat *v)
+{
+	SIG( "glRasterPos4fv" );
+	dllRasterPos4fv( v );
+}
+static void APIENTRY logRasterPos4i(GLint x, GLint y, GLint z, GLint w)
+{
+	SIG( "glRasterPos4i" );
+	dllRasterPos4i( x, y, z, w );
+}
+static void APIENTRY logRasterPos4iv(const GLint *v)
+{
+	SIG( "glRasterPos4iv" );
+	dllRasterPos4iv( v );
+}
+static void APIENTRY logRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w)
+{
+	SIG( "glRasterPos4s" );
+	dllRasterPos4s( x, y, z, w );
+}
+static void APIENTRY logRasterPos4sv(const GLshort *v)
+{
+	SIG( "glRasterPos4sv" );
+	dllRasterPos4sv( v );
+}
+static void APIENTRY logReadBuffer(GLenum mode)
+{
+	SIG( "glReadBuffer" );
+	dllReadBuffer( mode );
+}
+static void APIENTRY logReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void *pixels)
+{
+	SIG( "glReadPixels" );
+	dllReadPixels( x, y, width, height, format, type, pixels );
+}
+
+static void APIENTRY logRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2)
+{
+	SIG( "glRectd" );
+	dllRectd( x1, y1, x2, y2 );
+}
+
+static void APIENTRY logRectdv(const GLdouble *v1, const GLdouble *v2)
+{
+	SIG( "glRectdv" );
+	dllRectdv( v1, v2 );
+}
+
+static void APIENTRY logRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)
+{
+	SIG( "glRectf" );
+	dllRectf( x1, y1, x2, y2 );
+}
+
+static void APIENTRY logRectfv(const GLfloat *v1, const GLfloat *v2)
+{
+	SIG( "glRectfv" );
+	dllRectfv( v1, v2 );
+}
+static void APIENTRY logRecti(GLint x1, GLint y1, GLint x2, GLint y2)
+{
+	SIG( "glRecti" );
+	dllRecti( x1, y1, x2, y2 );
+}
+static void APIENTRY logRectiv(const GLint *v1, const GLint *v2)
+{
+	SIG( "glRectiv" );
+	dllRectiv( v1, v2 );
+}
+static void APIENTRY logRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2)
+{
+	SIG( "glRects" );
+	dllRects( x1, y1, x2, y2 );
+}
+static void APIENTRY logRectsv(const GLshort *v1, const GLshort *v2)
+{
+	SIG( "glRectsv" );
+	dllRectsv( v1, v2 );
+}
+static GLint APIENTRY logRenderMode(GLenum mode)
+{
+	SIG( "glRenderMode" );
+	return dllRenderMode( mode );
+}
+static void APIENTRY logRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z)
+{
+	SIG( "glRotated" );
+	dllRotated( angle, x, y, z );
+}
+
+static void APIENTRY logRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
+{
+	SIG( "glRotatef" );
+	dllRotatef( angle, x, y, z );
+}
+
+static void APIENTRY logScaled(GLdouble x, GLdouble y, GLdouble z)
+{
+	SIG( "glScaled" );
+	dllScaled( x, y, z );
+}
+
+static void APIENTRY logScalef(GLfloat x, GLfloat y, GLfloat z)
+{
+	SIG( "glScalef" );
+	dllScalef( x, y, z );
+}
+
+static void APIENTRY logScissor(GLint x, GLint y, GLsizei width, GLsizei height)
+{
+	fprintf( glw_state.log_fp, "glScissor( %d, %d, %d, %d )\n", x, y, width, height );
+	dllScissor( x, y, width, height );
+}
+
+static void APIENTRY logSelectBuffer(GLsizei size, GLuint *buffer)
+{
+	SIG( "glSelectBuffer" );
+	dllSelectBuffer( size, buffer );
+}
+
+static void APIENTRY logShadeModel(GLenum mode)
+{
+	SIG( "glShadeModel" );
+	dllShadeModel( mode );
+}
+
+static void APIENTRY logStencilFunc(GLenum func, GLint ref, GLuint mask)
+{
+	SIG( "glStencilFunc" );
+	dllStencilFunc( func, ref, mask );
+}
+
+static void APIENTRY logStencilMask(GLuint mask)
+{
+	SIG( "glStencilMask" );
+	dllStencilMask( mask );
+}
+
+static void APIENTRY logStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
+{
+	SIG( "glStencilOp" );
+	dllStencilOp( fail, zfail, zpass );
+}
+
+static void APIENTRY logTexCoord1d(GLdouble s)
+{
+	SIG( "glTexCoord1d" );
+	dllTexCoord1d( s );
+}
+
+static void APIENTRY logTexCoord1dv(const GLdouble *v)
+{
+	SIG( "glTexCoord1dv" );
+	dllTexCoord1dv( v );
+}
+
+static void APIENTRY logTexCoord1f(GLfloat s)
+{
+	SIG( "glTexCoord1f" );
+	dllTexCoord1f( s );
+}
+static void APIENTRY logTexCoord1fv(const GLfloat *v)
+{
+	SIG( "glTexCoord1fv" );
+	dllTexCoord1fv( v );
+}
+static void APIENTRY logTexCoord1i(GLint s)
+{
+	SIG( "glTexCoord1i" );
+	dllTexCoord1i( s );
+}
+static void APIENTRY logTexCoord1iv(const GLint *v)
+{
+	SIG( "glTexCoord1iv" );
+	dllTexCoord1iv( v );
+}
+static void APIENTRY logTexCoord1s(GLshort s)
+{
+	SIG( "glTexCoord1s" );
+	dllTexCoord1s( s );
+}
+static void APIENTRY logTexCoord1sv(const GLshort *v)
+{
+	SIG( "glTexCoord1sv" );
+	dllTexCoord1sv( v );
+}
+static void APIENTRY logTexCoord2d(GLdouble s, GLdouble t)
+{
+	SIG( "glTexCoord2d" );
+	dllTexCoord2d( s, t );
+}
+
+static void APIENTRY logTexCoord2dv(const GLdouble *v)
+{
+	SIG( "glTexCoord2dv" );
+	dllTexCoord2dv( v );
+}
+static void APIENTRY logTexCoord2f(GLfloat s, GLfloat t)
+{
+	SIG( "glTexCoord2f" );
+	dllTexCoord2f( s, t );
+}
+static void APIENTRY logTexCoord2fv(const GLfloat *v)
+{
+	SIG( "glTexCoord2fv" );
+	dllTexCoord2fv( v );
+}
+static void APIENTRY logTexCoord2i(GLint s, GLint t)
+{
+	SIG( "glTexCoord2i" );
+	dllTexCoord2i( s, t );
+}
+static void APIENTRY logTexCoord2iv(const GLint *v)
+{
+	SIG( "glTexCoord2iv" );
+	dllTexCoord2iv( v );
+}
+static void APIENTRY logTexCoord2s(GLshort s, GLshort t)
+{
+	SIG( "glTexCoord2s" );
+	dllTexCoord2s( s, t );
+}
+static void APIENTRY logTexCoord2sv(const GLshort *v)
+{
+	SIG( "glTexCoord2sv" );
+	dllTexCoord2sv( v );
+}
+static void APIENTRY logTexCoord3d(GLdouble s, GLdouble t, GLdouble r)
+{
+	SIG( "glTexCoord3d" );
+	dllTexCoord3d( s, t, r );
+}
+static void APIENTRY logTexCoord3dv(const GLdouble *v)
+{
+	SIG( "glTexCoord3dv" );
+	dllTexCoord3dv( v );
+}
+static void APIENTRY logTexCoord3f(GLfloat s, GLfloat t, GLfloat r)
+{
+	SIG( "glTexCoord3f" );
+	dllTexCoord3f( s, t, r );
+}
+static void APIENTRY logTexCoord3fv(const GLfloat *v)
+{
+	SIG( "glTexCoord3fv" );
+	dllTexCoord3fv( v );
+}
+static void APIENTRY logTexCoord3i(GLint s, GLint t, GLint r)
+{
+	SIG( "glTexCoord3i" );
+	dllTexCoord3i( s, t, r );
+}
+static void APIENTRY logTexCoord3iv(const GLint *v)
+{
+	SIG( "glTexCoord3iv" );
+	dllTexCoord3iv( v );
+}
+static void APIENTRY logTexCoord3s(GLshort s, GLshort t, GLshort r)
+{
+	SIG( "glTexCoord3s" );
+	dllTexCoord3s( s, t, r );
+}
+static void APIENTRY logTexCoord3sv(const GLshort *v)
+{
+	SIG( "glTexCoord3sv" );
+	dllTexCoord3sv( v );
+}
+static void APIENTRY logTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q)
+{
+	SIG( "glTexCoord4d" );
+	dllTexCoord4d( s, t, r, q );
+}
+static void APIENTRY logTexCoord4dv(const GLdouble *v)
+{
+	SIG( "glTexCoord4dv" );
+	dllTexCoord4dv( v );
+}
+static void APIENTRY logTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q)
+{
+	SIG( "glTexCoord4f" );
+	dllTexCoord4f( s, t, r, q );
+}
+static void APIENTRY logTexCoord4fv(const GLfloat *v)
+{
+	SIG( "glTexCoord4fv" );
+	dllTexCoord4fv( v );
+}
+static void APIENTRY logTexCoord4i(GLint s, GLint t, GLint r, GLint q)
+{
+	SIG( "glTexCoord4i" );
+	dllTexCoord4i( s, t, r, q );
+}
+static void APIENTRY logTexCoord4iv(const GLint *v)
+{
+	SIG( "glTexCoord4iv" );
+	dllTexCoord4iv( v );
+}
+static void APIENTRY logTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q)
+{
+	SIG( "glTexCoord4s" );
+	dllTexCoord4s( s, t, r, q );
+}
+static void APIENTRY logTexCoord4sv(const GLshort *v)
+{
+	SIG( "glTexCoord4sv" );
+	dllTexCoord4sv( v );
+}
+static void APIENTRY logTexCoordPointer(GLint size, GLenum type, GLsizei stride, const void *pointer)
+{
+	fprintf( glw_state.log_fp, "glTexCoordPointer( %d, %s, %d, MEM )\n", size, TypeToString( type ), stride );
+	dllTexCoordPointer( size, type, stride, pointer );
+}
+
+static void APIENTRY logTexEnvf(GLenum target, GLenum pname, GLfloat param)
+{
+	fprintf( glw_state.log_fp, "glTexEnvf( 0x%x, 0x%x, %f )\n", target, pname, param );
+	dllTexEnvf( target, pname, param );
+}
+
+static void APIENTRY logTexEnvfv(GLenum target, GLenum pname, const GLfloat *params)
+{
+	SIG( "glTexEnvfv" );
+	dllTexEnvfv( target, pname, params );
+}
+
+static void APIENTRY logTexEnvi(GLenum target, GLenum pname, GLint param)
+{
+	fprintf( glw_state.log_fp, "glTexEnvi( 0x%x, 0x%x, 0x%x )\n", target, pname, param );
+	dllTexEnvi( target, pname, param );
+}
+static void APIENTRY logTexEnviv(GLenum target, GLenum pname, const GLint *params)
+{
+	SIG( "glTexEnviv" );
+	dllTexEnviv( target, pname, params );
+}
+
+static void APIENTRY logTexGend(GLenum coord, GLenum pname, GLdouble param)
+{
+	SIG( "glTexGend" );
+	dllTexGend( coord, pname, param );
+}
+
+static void APIENTRY logTexGendv(GLenum coord, GLenum pname, const GLdouble *params)
+{
+	SIG( "glTexGendv" );
+	dllTexGendv( coord, pname, params );
+}
+
+static void APIENTRY logTexGenf(GLenum coord, GLenum pname, GLfloat param)
+{
+	SIG( "glTexGenf" );
+	dllTexGenf( coord, pname, param );
+}
+static void APIENTRY logTexGenfv(GLenum coord, GLenum pname, const GLfloat *params)
+{
+	SIG( "glTexGenfv" );
+	dllTexGenfv( coord, pname, params );
+}
+static void APIENTRY logTexGeni(GLenum coord, GLenum pname, GLint param)
+{
+	SIG( "glTexGeni" );
+	dllTexGeni( coord, pname, param );
+}
+static void APIENTRY logTexGeniv(GLenum coord, GLenum pname, const GLint *params)
+{
+	SIG( "glTexGeniv" );
+	dllTexGeniv( coord, pname, params );
+}
+static void APIENTRY logTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void *pixels)
+{
+	SIG( "glTexImage1D" );
+	dllTexImage1D( target, level, internalformat, width, border, format, type, pixels );
+}
+static void APIENTRY logTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels)
+{
+	SIG( "glTexImage2D" );
+	dllTexImage2D( target, level, internalformat, width, height, border, format, type, pixels );
+}
+
+static void APIENTRY logTexParameterf(GLenum target, GLenum pname, GLfloat param)
+{
+	fprintf( glw_state.log_fp, "glTexParameterf( 0x%x, 0x%x, %f )\n", target, pname, param );
+	dllTexParameterf( target, pname, param );
+}
+
+static void APIENTRY logTexParameterfv(GLenum target, GLenum pname, const GLfloat *params)
+{
+	SIG( "glTexParameterfv" );
+	dllTexParameterfv( target, pname, params );
+}
+static void APIENTRY logTexParameteri(GLenum target, GLenum pname, GLint param)
+{
+	fprintf( glw_state.log_fp, "glTexParameteri( 0x%x, 0x%x, 0x%x )\n", target, pname, param );
+	dllTexParameteri( target, pname, param );
+}
+static void APIENTRY logTexParameteriv(GLenum target, GLenum pname, const GLint *params)
+{
+	SIG( "glTexParameteriv" );
+	dllTexParameteriv( target, pname, params );
+}
+static void APIENTRY logTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels)
+{
+	SIG( "glTexSubImage1D" );
+	dllTexSubImage1D( target, level, xoffset, width, format, type, pixels );
+}
+static void APIENTRY logTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels)
+{
+	SIG( "glTexSubImage2D" );
+	dllTexSubImage2D( target, level, xoffset, yoffset, width, height, format, type, pixels );
+}
+static void APIENTRY logTranslated(GLdouble x, GLdouble y, GLdouble z)
+{
+	SIG( "glTranslated" );
+	dllTranslated( x, y, z );
+}
+
+static void APIENTRY logTranslatef(GLfloat x, GLfloat y, GLfloat z)
+{
+	SIG( "glTranslatef" );
+	dllTranslatef( x, y, z );
+}
+
+static void APIENTRY logVertex2d(GLdouble x, GLdouble y)
+{
+	SIG( "glVertex2d" );
+	dllVertex2d( x, y );
+}
+
+static void APIENTRY logVertex2dv(const GLdouble *v)
+{
+	SIG( "glVertex2dv" );
+	dllVertex2dv( v );
+}
+static void APIENTRY logVertex2f(GLfloat x, GLfloat y)
+{
+	SIG( "glVertex2f" );
+	dllVertex2f( x, y );
+}
+static void APIENTRY logVertex2fv(const GLfloat *v)
+{
+	SIG( "glVertex2fv" );
+	dllVertex2fv( v );
+}
+static void APIENTRY logVertex2i(GLint x, GLint y)
+{
+	SIG( "glVertex2i" );
+	dllVertex2i( x, y );
+}
+static void APIENTRY logVertex2iv(const GLint *v)
+{
+	SIG( "glVertex2iv" );
+	dllVertex2iv( v );
+}
+static void APIENTRY logVertex2s(GLshort x, GLshort y)
+{
+	SIG( "glVertex2s" );
+	dllVertex2s( x, y );
+}
+static void APIENTRY logVertex2sv(const GLshort *v)
+{
+	SIG( "glVertex2sv" );
+	dllVertex2sv( v );
+}
+static void APIENTRY logVertex3d(GLdouble x, GLdouble y, GLdouble z)
+{
+	SIG( "glVertex3d" );
+	dllVertex3d( x, y, z );
+}
+static void APIENTRY logVertex3dv(const GLdouble *v)
+{
+	SIG( "glVertex3dv" );
+	dllVertex3dv( v );
+}
+static void APIENTRY logVertex3f(GLfloat x, GLfloat y, GLfloat z)
+{
+	SIG( "glVertex3f" );
+	dllVertex3f( x, y, z );
+}
+static void APIENTRY logVertex3fv(const GLfloat *v)
+{
+	SIG( "glVertex3fv" );
+	dllVertex3fv( v );
+}
+static void APIENTRY logVertex3i(GLint x, GLint y, GLint z)
+{
+	SIG( "glVertex3i" );
+	dllVertex3i( x, y, z );
+}
+static void APIENTRY logVertex3iv(const GLint *v)
+{
+	SIG( "glVertex3iv" );
+	dllVertex3iv( v );
+}
+static void APIENTRY logVertex3s(GLshort x, GLshort y, GLshort z)
+{
+	SIG( "glVertex3s" );
+	dllVertex3s( x, y, z );
+}
+static void APIENTRY logVertex3sv(const GLshort *v)
+{
+	SIG( "glVertex3sv" );
+	dllVertex3sv( v );
+}
+static void APIENTRY logVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
+{
+	SIG( "glVertex4d" );
+	dllVertex4d( x, y, z, w );
+}
+static void APIENTRY logVertex4dv(const GLdouble *v)
+{
+	SIG( "glVertex4dv" );
+	dllVertex4dv( v );
+}
+static void APIENTRY logVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
+{
+	SIG( "glVertex4f" );
+	dllVertex4f( x, y, z, w );
+}
+static void APIENTRY logVertex4fv(const GLfloat *v)
+{
+	SIG( "glVertex4fv" );
+	dllVertex4fv( v );
+}
+static void APIENTRY logVertex4i(GLint x, GLint y, GLint z, GLint w)
+{
+	SIG( "glVertex4i" );
+	dllVertex4i( x, y, z, w );
+}
+static void APIENTRY logVertex4iv(const GLint *v)
+{
+	SIG( "glVertex4iv" );
+	dllVertex4iv( v );
+}
+static void APIENTRY logVertex4s(GLshort x, GLshort y, GLshort z, GLshort w)
+{
+	SIG( "glVertex4s" );
+	dllVertex4s( x, y, z, w );
+}
+static void APIENTRY logVertex4sv(const GLshort *v)
+{
+	SIG( "glVertex4sv" );
+	dllVertex4sv( v );
+}
+static void APIENTRY logVertexPointer(GLint size, GLenum type, GLsizei stride, const void *pointer)
+{
+	fprintf( glw_state.log_fp, "glVertexPointer( %d, %s, %d, MEM )\n", size, TypeToString( type ), stride );
+	dllVertexPointer( size, type, stride, pointer );
+}
+static void APIENTRY logViewport(GLint x, GLint y, GLsizei width, GLsizei height)
+{
+	fprintf( glw_state.log_fp, "glViewport( %d, %d, %d, %d )\n", x, y, width, height );
+	dllViewport( x, y, width, height );
+}
+
+/*
+** QGL_Shutdown
+**
+** Unloads the specified DLL then nulls out all the proc pointers.  This
+** is only called during a hard shutdown of the OGL subsystem (e.g. vid_restart).
+*/
+void QGL_Shutdown( void )
+{
+	VID_Printf( PRINT_ALL, "...shutting down QGL\n" );
+
+	if ( glw_state.hinstOpenGL )
+	{
+		VID_Printf( PRINT_ALL, "...unloading OpenGL DLL\n" );
+		FreeLibrary( glw_state.hinstOpenGL );
+	}
+
+	glw_state.hinstOpenGL = NULL;
+
+	qglAccum                     = NULL;
+	qglAlphaFunc                 = NULL;
+	qglAreTexturesResident       = NULL;
+	qglArrayElement              = NULL;
+	qglBegin                     = NULL;
+	qglBindTexture               = NULL;
+	qglBitmap                    = NULL;
+	qglBlendFunc                 = NULL;
+	qglCallList                  = NULL;
+	qglCallLists                 = NULL;
+	qglClear                     = NULL;
+	qglClearAccum                = NULL;
+	qglClearColor                = NULL;
+	qglClearDepth                = NULL;
+	qglClearIndex                = NULL;
+	qglClearStencil              = NULL;
+	qglClipPlane                 = NULL;
+	qglColor3b                   = NULL;
+	qglColor3bv                  = NULL;
+	qglColor3d                   = NULL;
+	qglColor3dv                  = NULL;
+	qglColor3f                   = NULL;
+	qglColor3fv                  = NULL;
+	qglColor3i                   = NULL;
+	qglColor3iv                  = NULL;
+	qglColor3s                   = NULL;
+	qglColor3sv                  = NULL;
+	qglColor3ub                  = NULL;
+	qglColor3ubv                 = NULL;
+	qglColor3ui                  = NULL;
+	qglColor3uiv                 = NULL;
+	qglColor3us                  = NULL;
+	qglColor3usv                 = NULL;
+	qglColor4b                   = NULL;
+	qglColor4bv                  = NULL;
+	qglColor4d                   = NULL;
+	qglColor4dv                  = NULL;
+	qglColor4f                   = NULL;
+	qglColor4fv                  = NULL;
+	qglColor4i                   = NULL;
+	qglColor4iv                  = NULL;
+	qglColor4s                   = NULL;
+	qglColor4sv                  = NULL;
+	qglColor4ub                  = NULL;
+	qglColor4ubv                 = NULL;
+	qglColor4ui                  = NULL;
+	qglColor4uiv                 = NULL;
+	qglColor4us                  = NULL;
+	qglColor4usv                 = NULL;
+	qglColorMask                 = NULL;
+	qglColorMaterial             = NULL;
+	qglColorPointer              = NULL;
+	qglCopyPixels                = NULL;
+	qglCopyTexImage1D            = NULL;
+	qglCopyTexImage2D            = NULL;
+	qglCopyTexSubImage1D         = NULL;
+	qglCopyTexSubImage2D         = NULL;
+	qglCullFace                  = NULL;
+	qglDeleteLists               = NULL;
+	qglDeleteTextures            = NULL;
+	qglDepthFunc                 = NULL;
+	qglDepthMask                 = NULL;
+	qglDepthRange                = NULL;
+	qglDisable                   = NULL;
+	qglDisableClientState        = NULL;
+	qglDrawArrays                = NULL;
+	qglDrawBuffer                = NULL;
+	qglDrawElements              = NULL;
+	qglDrawPixels                = NULL;
+	qglEdgeFlag                  = NULL;
+	qglEdgeFlagPointer           = NULL;
+	qglEdgeFlagv                 = NULL;
+	qglEnable                    = NULL;
+	qglEnableClientState         = NULL;
+	qglEnd                       = NULL;
+	qglEndList                   = NULL;
+	qglEvalCoord1d               = NULL;
+	qglEvalCoord1dv              = NULL;
+	qglEvalCoord1f               = NULL;
+	qglEvalCoord1fv              = NULL;
+	qglEvalCoord2d               = NULL;
+	qglEvalCoord2dv              = NULL;
+	qglEvalCoord2f               = NULL;
+	qglEvalCoord2fv              = NULL;
+	qglEvalMesh1                 = NULL;
+	qglEvalMesh2                 = NULL;
+	qglEvalPoint1                = NULL;
+	qglEvalPoint2                = NULL;
+	qglFeedbackBuffer            = NULL;
+	qglFinish                    = NULL;
+	qglFlush                     = NULL;
+	qglFogf                      = NULL;
+	qglFogfv                     = NULL;
+	qglFogi                      = NULL;
+	qglFogiv                     = NULL;
+	qglFrontFace                 = NULL;
+	qglFrustum                   = NULL;
+	qglGenLists                  = NULL;
+	qglGenTextures               = NULL;
+	qglGetBooleanv               = NULL;
+	qglGetClipPlane              = NULL;
+	qglGetDoublev                = NULL;
+	qglGetError                  = NULL;
+	qglGetFloatv                 = NULL;
+	qglGetIntegerv               = NULL;
+	qglGetLightfv                = NULL;
+	qglGetLightiv                = NULL;
+	qglGetMapdv                  = NULL;
+	qglGetMapfv                  = NULL;
+	qglGetMapiv                  = NULL;
+	qglGetMaterialfv             = NULL;
+	qglGetMaterialiv             = NULL;
+	qglGetPixelMapfv             = NULL;
+	qglGetPixelMapuiv            = NULL;
+	qglGetPixelMapusv            = NULL;
+	qglGetPointerv               = NULL;
+	qglGetPolygonStipple         = NULL;
+	qglGetString                 = NULL;
+	qglGetTexEnvfv               = NULL;
+	qglGetTexEnviv               = NULL;
+	qglGetTexGendv               = NULL;
+	qglGetTexGenfv               = NULL;
+	qglGetTexGeniv               = NULL;
+	qglGetTexImage               = NULL;
+	qglGetTexLevelParameterfv    = NULL;
+	qglGetTexLevelParameteriv    = NULL;
+	qglGetTexParameterfv         = NULL;
+	qglGetTexParameteriv         = NULL;
+	qglHint                      = NULL;
+	qglIndexMask                 = NULL;
+	qglIndexPointer              = NULL;
+	qglIndexd                    = NULL;
+	qglIndexdv                   = NULL;
+	qglIndexf                    = NULL;
+	qglIndexfv                   = NULL;
+	qglIndexi                    = NULL;
+	qglIndexiv                   = NULL;
+	qglIndexs                    = NULL;
+	qglIndexsv                   = NULL;
+	qglIndexub                   = NULL;
+	qglIndexubv                  = NULL;
+	qglInitNames                 = NULL;
+	qglInterleavedArrays         = NULL;
+	qglIsEnabled                 = NULL;
+	qglIsList                    = NULL;
+	qglIsTexture                 = NULL;
+	qglLightModelf               = NULL;
+	qglLightModelfv              = NULL;
+	qglLightModeli               = NULL;
+	qglLightModeliv              = NULL;
+	qglLightf                    = NULL;
+	qglLightfv                   = NULL;
+	qglLighti                    = NULL;
+	qglLightiv                   = NULL;
+	qglLineStipple               = NULL;
+	qglLineWidth                 = NULL;
+	qglListBase                  = NULL;
+	qglLoadIdentity              = NULL;
+	qglLoadMatrixd               = NULL;
+	qglLoadMatrixf               = NULL;
+	qglLoadName                  = NULL;
+	qglLogicOp                   = NULL;
+	qglMap1d                     = NULL;
+	qglMap1f                     = NULL;
+	qglMap2d                     = NULL;
+	qglMap2f                     = NULL;
+	qglMapGrid1d                 = NULL;
+	qglMapGrid1f                 = NULL;
+	qglMapGrid2d                 = NULL;
+	qglMapGrid2f                 = NULL;
+	qglMaterialf                 = NULL;
+	qglMaterialfv                = NULL;
+	qglMateriali                 = NULL;
+	qglMaterialiv                = NULL;
+	qglMatrixMode                = NULL;
+	qglMultMatrixd               = NULL;
+	qglMultMatrixf               = NULL;
+	qglNewList                   = NULL;
+	qglNormal3b                  = NULL;
+	qglNormal3bv                 = NULL;
+	qglNormal3d                  = NULL;
+	qglNormal3dv                 = NULL;
+	qglNormal3f                  = NULL;
+	qglNormal3fv                 = NULL;
+	qglNormal3i                  = NULL;
+	qglNormal3iv                 = NULL;
+	qglNormal3s                  = NULL;
+	qglNormal3sv                 = NULL;
+	qglNormalPointer             = NULL;
+	qglOrtho                     = NULL;
+	qglPassThrough               = NULL;
+	qglPixelMapfv                = NULL;
+	qglPixelMapuiv               = NULL;
+	qglPixelMapusv               = NULL;
+	qglPixelStoref               = NULL;
+	qglPixelStorei               = NULL;
+	qglPixelTransferf            = NULL;
+	qglPixelTransferi            = NULL;
+	qglPixelZoom                 = NULL;
+	qglPointSize                 = NULL;
+	qglPolygonMode               = NULL;
+	qglPolygonOffset             = NULL;
+	qglPolygonStipple            = NULL;
+	qglPopAttrib                 = NULL;
+	qglPopClientAttrib           = NULL;
+	qglPopMatrix                 = NULL;
+	qglPopName                   = NULL;
+	qglPrioritizeTextures        = NULL;
+	qglPushAttrib                = NULL;
+	qglPushClientAttrib          = NULL;
+	qglPushMatrix                = NULL;
+	qglPushName                  = NULL;
+	qglRasterPos2d               = NULL;
+	qglRasterPos2dv              = NULL;
+	qglRasterPos2f               = NULL;
+	qglRasterPos2fv              = NULL;
+	qglRasterPos2i               = NULL;
+	qglRasterPos2iv              = NULL;
+	qglRasterPos2s               = NULL;
+	qglRasterPos2sv              = NULL;
+	qglRasterPos3d               = NULL;
+	qglRasterPos3dv              = NULL;
+	qglRasterPos3f               = NULL;
+	qglRasterPos3fv              = NULL;
+	qglRasterPos3i               = NULL;
+	qglRasterPos3iv              = NULL;
+	qglRasterPos3s               = NULL;
+	qglRasterPos3sv              = NULL;
+	qglRasterPos4d               = NULL;
+	qglRasterPos4dv              = NULL;
+	qglRasterPos4f               = NULL;
+	qglRasterPos4fv              = NULL;
+	qglRasterPos4i               = NULL;
+	qglRasterPos4iv              = NULL;
+	qglRasterPos4s               = NULL;
+	qglRasterPos4sv              = NULL;
+	qglReadBuffer                = NULL;
+	qglReadPixels                = NULL;
+	qglRectd                     = NULL;
+	qglRectdv                    = NULL;
+	qglRectf                     = NULL;
+	qglRectfv                    = NULL;
+	qglRecti                     = NULL;
+	qglRectiv                    = NULL;
+	qglRects                     = NULL;
+	qglRectsv                    = NULL;
+	qglRenderMode                = NULL;
+	qglRotated                   = NULL;
+	qglRotatef                   = NULL;
+	qglScaled                    = NULL;
+	qglScalef                    = NULL;
+	qglScissor                   = NULL;
+	qglSelectBuffer              = NULL;
+	qglShadeModel                = NULL;
+	qglStencilFunc               = NULL;
+	qglStencilMask               = NULL;
+	qglStencilOp                 = NULL;
+	qglTexCoord1d                = NULL;
+	qglTexCoord1dv               = NULL;
+	qglTexCoord1f                = NULL;
+	qglTexCoord1fv               = NULL;
+	qglTexCoord1i                = NULL;
+	qglTexCoord1iv               = NULL;
+	qglTexCoord1s                = NULL;
+	qglTexCoord1sv               = NULL;
+	qglTexCoord2d                = NULL;
+	qglTexCoord2dv               = NULL;
+	qglTexCoord2f                = NULL;
+	qglTexCoord2fv               = NULL;
+	qglTexCoord2i                = NULL;
+	qglTexCoord2iv               = NULL;
+	qglTexCoord2s                = NULL;
+	qglTexCoord2sv               = NULL;
+	qglTexCoord3d                = NULL;
+	qglTexCoord3dv               = NULL;
+	qglTexCoord3f                = NULL;
+	qglTexCoord3fv               = NULL;
+	qglTexCoord3i                = NULL;
+	qglTexCoord3iv               = NULL;
+	qglTexCoord3s                = NULL;
+	qglTexCoord3sv               = NULL;
+	qglTexCoord4d                = NULL;
+	qglTexCoord4dv               = NULL;
+	qglTexCoord4f                = NULL;
+	qglTexCoord4fv               = NULL;
+	qglTexCoord4i                = NULL;
+	qglTexCoord4iv               = NULL;
+	qglTexCoord4s                = NULL;
+	qglTexCoord4sv               = NULL;
+	qglTexCoordPointer           = NULL;
+	qglTexEnvf                   = NULL;
+	qglTexEnvfv                  = NULL;
+	qglTexEnvi                   = NULL;
+	qglTexEnviv                  = NULL;
+	qglTexGend                   = NULL;
+	qglTexGendv                  = NULL;
+	qglTexGenf                   = NULL;
+	qglTexGenfv                  = NULL;
+	qglTexGeni                   = NULL;
+	qglTexGeniv                  = NULL;
+	qglTexImage1D                = NULL;
+	qglTexImage2D                = NULL;
+	qglTexParameterf             = NULL;
+	qglTexParameterfv            = NULL;
+	qglTexParameteri             = NULL;
+	qglTexParameteriv            = NULL;
+	qglTexSubImage1D             = NULL;
+	qglTexSubImage2D             = NULL;
+	qglTranslated                = NULL;
+	qglTranslatef                = NULL;
+	qglVertex2d                  = NULL;
+	qglVertex2dv                 = NULL;
+	qglVertex2f                  = NULL;
+	qglVertex2fv                 = NULL;
+	qglVertex2i                  = NULL;
+	qglVertex2iv                 = NULL;
+	qglVertex2s                  = NULL;
+	qglVertex2sv                 = NULL;
+	qglVertex3d                  = NULL;
+	qglVertex3dv                 = NULL;
+	qglVertex3f                  = NULL;
+	qglVertex3fv                 = NULL;
+	qglVertex3i                  = NULL;
+	qglVertex3iv                 = NULL;
+	qglVertex3s                  = NULL;
+	qglVertex3sv                 = NULL;
+	qglVertex4d                  = NULL;
+	qglVertex4dv                 = NULL;
+	qglVertex4f                  = NULL;
+	qglVertex4fv                 = NULL;
+	qglVertex4i                  = NULL;
+	qglVertex4iv                 = NULL;
+	qglVertex4s                  = NULL;
+	qglVertex4sv                 = NULL;
+	qglVertexPointer             = NULL;
+	qglViewport                  = NULL;
+
+	qwglCopyContext              = NULL;
+	qwglCreateContext            = NULL;
+	qwglCreateLayerContext       = NULL;
+	qwglDeleteContext            = NULL;
+	qwglDescribeLayerPlane       = NULL;
+	qwglGetCurrentContext        = NULL;
+	qwglGetCurrentDC             = NULL;
+	qwglGetLayerPaletteEntries   = NULL;
+	qwglGetProcAddress           = NULL;
+	qwglMakeCurrent              = NULL;
+	qwglRealizeLayerPalette      = NULL;
+	qwglSetLayerPaletteEntries   = NULL;
+	qwglShareLists               = NULL;
+	qwglSwapLayerBuffers         = NULL;
+	qwglUseFontBitmaps           = NULL;
+	qwglUseFontOutlines          = NULL;
+}
+
+#	pragma warning (disable : 4113 4133 4047 )
+#	define GPA( a ) GetProcAddress( glw_state.hinstOpenGL, a )
+
+/*
+** QGL_Init
+**
+** This is responsible for binding our qgl function pointers to 
+** the appropriate GL stuff.  In Windows this means doing a 
+** LoadLibrary and a bunch of calls to GetProcAddress.  On other
+** operating systems we need to do the right thing, whatever that
+** might be.
+*/
+qboolean QGL_Init( const char *dllname )
+{
+	assert( glw_state.hinstOpenGL == 0 );
+
+	VID_Printf( PRINT_ALL, "...initializing QGL\n" );
+
+	//VID_Printf( PRINT_ALL, "...calling LoadLibrary( '%s.dll' ): ", dllname );
+
+	if ( ( glw_state.hinstOpenGL = LoadLibrary( dllname ) ) == 0 )
+	{
+		VID_Printf( PRINT_ALL, "failed\n" );
+		return qfalse;
+	}
+	VID_Printf( PRINT_ALL, "succeeded\n" );
+
+	qglAccum                     = dllAccum = (void (__stdcall *)(unsigned int,float))GPA( "glAccum" );
+	qglAlphaFunc                 = dllAlphaFunc = (void (__stdcall *)(unsigned int,float))GPA( "glAlphaFunc" );
+	qglAreTexturesResident       = dllAreTexturesResident = (unsigned char (__stdcall *)(int,const unsigned int *,unsigned char *))GPA( "glAreTexturesResident" );
+	qglArrayElement              = dllArrayElement = (void (__stdcall *)(int))GPA( "glArrayElement" );
+	qglBegin                     = dllBegin = (void (__stdcall *)(unsigned int))GPA( "glBegin" );
+	qglBindTexture               = dllBindTexture = (void (__stdcall *)(unsigned int,unsigned int))GPA( "glBindTexture" );
+	qglBitmap                    = dllBitmap = (void (__stdcall *)(int,int,float,float,float,float,const unsigned char *))GPA( "glBitmap" );
+	qglBlendFunc                 = dllBlendFunc = (void (__stdcall *)(unsigned int,unsigned int))GPA( "glBlendFunc" );
+	qglCallList                  = dllCallList = (void (__stdcall *)(unsigned int))GPA( "glCallList" );
+	qglCallLists                 = dllCallLists = (void (__stdcall *)(int,unsigned int,const void *))GPA( "glCallLists" );
+	qglClear                     = dllClear = (void (__stdcall *)(unsigned int))GPA( "glClear" );
+	qglClearAccum                = dllClearAccum = (void (__stdcall *)(float,float,float,float))GPA( "glClearAccum" );
+	qglClearColor                = dllClearColor = (void (__stdcall *)(float,float,float,float))GPA( "glClearColor" );
+	qglClearDepth                = dllClearDepth = (void (__stdcall *)(double))GPA( "glClearDepth" );
+	qglClearIndex                = dllClearIndex = (void (__stdcall *)(float))GPA( "glClearIndex" );
+	qglClearStencil              = dllClearStencil = (void (__stdcall *)(int))GPA( "glClearStencil" );
+	qglClipPlane                 = dllClipPlane = (void (__stdcall *)(unsigned int,const double *))GPA( "glClipPlane" );
+	qglColor3b                   = dllColor3b = (void (__stdcall *)(signed char,signed char,signed char))GPA( "glColor3b" );
+	qglColor3bv                  = dllColor3bv = (void (__stdcall *)(const signed char *))GPA( "glColor3bv" );
+	qglColor3d                   = dllColor3d = (void (__stdcall *)(double,double,double))GPA( "glColor3d" );
+	qglColor3dv                  = dllColor3dv = (void (__stdcall *)(const double *))GPA( "glColor3dv" );
+	qglColor3f                   = dllColor3f = (void (__stdcall *)(float,float,float))GPA( "glColor3f" );
+	qglColor3fv                  = dllColor3fv = (void (__stdcall *)(const float *))GPA( "glColor3fv" );
+	qglColor3i                   = dllColor3i = (void (__stdcall *)(int,int,int))GPA( "glColor3i" );
+	qglColor3iv                  = dllColor3iv = (void (__stdcall *)(const int *))GPA( "glColor3iv" );
+	qglColor3s                   = dllColor3s =(void (__stdcall *)(short,short,short))GPA( "glColor3s" );
+	qglColor3sv                  = dllColor3sv =(void (__stdcall *)(const short *))GPA( "glColor3sv" );
+	qglColor3ub                  = dllColor3ub =(void (__stdcall *)(unsigned char,unsigned char,unsigned char))GPA( "glColor3ub" );
+	qglColor3ubv                 = dllColor3ubv =(void (__stdcall *)(const unsigned char *))GPA( "glColor3ubv" );
+	qglColor3ui                  = dllColor3ui =(void (__stdcall *)(unsigned int,unsigned int,unsigned int))GPA( "glColor3ui" );
+	qglColor3uiv                 = dllColor3uiv =(void (__stdcall *)(const unsigned int *))GPA( "glColor3uiv" );
+	qglColor3us                  = dllColor3us =(void (__stdcall *)(unsigned short,unsigned short,unsigned short))GPA( "glColor3us" );
+	qglColor3usv                 = dllColor3usv =(void (__stdcall *)(const unsigned short *))GPA( "glColor3usv" );
+	qglColor4b                   = dllColor4b =(void (__stdcall *)(signed char,signed char,signed char,signed char))GPA( "glColor4b" );
+	qglColor4bv                  = dllColor4bv =(void (__stdcall *)(const signed char *))GPA( "glColor4bv" );
+	qglColor4d                   = dllColor4d =(void (__stdcall *)(double,double,double,double))GPA( "glColor4d" );
+	qglColor4dv                  = dllColor4dv =(void (__stdcall *)(const double *))GPA( "glColor4dv" );
+	qglColor4f                   = dllColor4f =(void (__stdcall *)(float,float,float,float))GPA( "glColor4f" );
+	qglColor4fv                  = dllColor4fv =(void (__stdcall *)(const float *))GPA( "glColor4fv" );
+	qglColor4i                   = dllColor4i =(void (__stdcall *)(int,int,int,int))GPA( "glColor4i" );
+	qglColor4iv                  = dllColor4iv =(void (__stdcall *)(const int *))GPA( "glColor4iv" );
+	qglColor4s                   = dllColor4s =(void (__stdcall *)(short,short,short,short))GPA( "glColor4s" );
+	qglColor4sv                  = dllColor4sv =(void (__stdcall *)(const short *))GPA( "glColor4sv" );
+	qglColor4ub                  = dllColor4ub =(void (__stdcall *)(unsigned char,unsigned char,unsigned char,unsigned char))GPA( "glColor4ub" );
+	qglColor4ubv                 = dllColor4ubv =(void (__stdcall *)(const unsigned char *))GPA( "glColor4ubv" );
+	qglColor4ui                  = dllColor4ui =(void (__stdcall *)(unsigned int,unsigned int,unsigned int,unsigned int))GPA( "glColor4ui" );
+	qglColor4uiv                 = dllColor4uiv =(void (__stdcall *)(const unsigned int *))GPA( "glColor4uiv" );
+	qglColor4us                  = dllColor4us =(void (__stdcall *)(unsigned short,unsigned short,unsigned short,unsigned short))GPA( "glColor4us" );
+	qglColor4usv                 = dllColor4usv =(void (__stdcall *)(const unsigned short *))GPA( "glColor4usv" );
+	qglColorMask                 = dllColorMask =(void (__stdcall *)(unsigned char,unsigned char,unsigned char,unsigned char))GPA( "glColorMask" );
+	qglColorMaterial             = dllColorMaterial =(void (__stdcall *)(unsigned int,unsigned int))GPA( "glColorMaterial" );
+	qglColorPointer              = dllColorPointer =(void (__stdcall *)(int,unsigned int,int,const void *))GPA( "glColorPointer" );
+	qglCopyPixels                = dllCopyPixels =(void (__stdcall *)(int,int,int,int,unsigned int))GPA( "glCopyPixels" );
+	qglCopyTexImage1D            = dllCopyTexImage1D =(void (__stdcall *)(unsigned int,int,unsigned int,int,int,int,int))GPA( "glCopyTexImage1D" );
+	qglCopyTexImage2D            = dllCopyTexImage2D =(void (__stdcall *)(unsigned int,int,unsigned int,int,int,int,int,int))GPA( "glCopyTexImage2D" );
+	qglCopyTexSubImage1D         = dllCopyTexSubImage1D =(void (__stdcall *)(unsigned int,int,int,int,int,int))GPA( "glCopyTexSubImage1D" );
+	qglCopyTexSubImage2D         = dllCopyTexSubImage2D =(void (__stdcall *)(unsigned int,int,int,int,int,int,int,int))GPA( "glCopyTexSubImage2D" );
+	qglCullFace                  = dllCullFace =(void (__stdcall *)(unsigned int))GPA( "glCullFace" );
+	qglDeleteLists               = dllDeleteLists =(void (__stdcall *)(unsigned int,int))GPA( "glDeleteLists" );
+	qglDeleteTextures            = dllDeleteTextures =(void (__stdcall *)(int,const unsigned int *))GPA( "glDeleteTextures" );
+	qglDepthFunc                 = dllDepthFunc =(void (__stdcall *)(unsigned int))GPA( "glDepthFunc" );
+	qglDepthMask                 = dllDepthMask =(void (__stdcall *)(unsigned char))GPA( "glDepthMask" );
+	qglDepthRange                = dllDepthRange =(void (__stdcall *)(double,double))GPA( "glDepthRange" );
+	qglDisable                   = dllDisable =(void (__stdcall *)(unsigned int))GPA( "glDisable" );
+	qglDisableClientState        = dllDisableClientState =(void (__stdcall *)(unsigned int))GPA( "glDisableClientState" );
+	qglDrawArrays                = dllDrawArrays =(void (__stdcall *)(unsigned int,int,int))GPA( "glDrawArrays" );
+	qglDrawBuffer                = dllDrawBuffer =(void (__stdcall *)(unsigned int))GPA( "glDrawBuffer" );
+	qglDrawElements              = dllDrawElements =(void (__stdcall *)(unsigned int,int,unsigned int,const void *))GPA( "glDrawElements" );
+	qglDrawPixels                = dllDrawPixels =(void (__stdcall *)(int,int,unsigned int,unsigned int,const void *))GPA( "glDrawPixels" );
+	qglEdgeFlag                  = dllEdgeFlag =(void (__stdcall *)(unsigned char))GPA( "glEdgeFlag" );
+	qglEdgeFlagPointer           = dllEdgeFlagPointer =(void (__stdcall *)(int,const void *))GPA( "glEdgeFlagPointer" );
+	qglEdgeFlagv                 = dllEdgeFlagv =(void (__stdcall *)(const unsigned char *))GPA( "glEdgeFlagv" );
+	qglEnable                    = 	dllEnable                    =(void (__stdcall *)(unsigned int))GPA( "glEnable" );
+	qglEnableClientState         = 	dllEnableClientState         =(void (__stdcall *)(unsigned int))GPA( "glEnableClientState" );
+	qglEnd                       = 	dllEnd                       =(void (__stdcall *)(void))GPA( "glEnd" );
+	qglEndList                   = 	dllEndList                   =(void (__stdcall *)(void))GPA( "glEndList" );
+	qglEvalCoord1d				 = 	dllEvalCoord1d				 =(void (__stdcall *)(double))GPA( "glEvalCoord1d" );
+	qglEvalCoord1dv              = 	dllEvalCoord1dv              =(void (__stdcall *)(const double *))GPA( "glEvalCoord1dv" );
+	qglEvalCoord1f               = 	dllEvalCoord1f               =(void (__stdcall *)(float))GPA( "glEvalCoord1f" );
+	qglEvalCoord1fv              = 	dllEvalCoord1fv              =(void (__stdcall *)(const float *))GPA( "glEvalCoord1fv" );
+	qglEvalCoord2d               = 	dllEvalCoord2d               =(void (__stdcall *)(double,double))GPA( "glEvalCoord2d" );
+	qglEvalCoord2dv              = 	dllEvalCoord2dv              =(void (__stdcall *)(const double *))GPA( "glEvalCoord2dv" );
+	qglEvalCoord2f               = 	dllEvalCoord2f               =(void (__stdcall *)(float,float))GPA( "glEvalCoord2f" );
+	qglEvalCoord2fv              = 	dllEvalCoord2fv              =(void (__stdcall *)(const float *))GPA( "glEvalCoord2fv" );
+	qglEvalMesh1                 = 	dllEvalMesh1                 =(void (__stdcall *)(unsigned int,int,int))GPA( "glEvalMesh1" );
+	qglEvalMesh2                 = 	dllEvalMesh2                 =(void (__stdcall *)(unsigned int,int,int,int,int))GPA( "glEvalMesh2" );
+	qglEvalPoint1                = 	dllEvalPoint1                =(void (__stdcall *)(int))GPA( "glEvalPoint1" );
+	qglEvalPoint2                = 	dllEvalPoint2                =(void (__stdcall *)(int,int))GPA( "glEvalPoint2" );
+	qglFeedbackBuffer            = 	dllFeedbackBuffer            =(void (__stdcall *)(int,unsigned int,float *))GPA( "glFeedbackBuffer" );
+	qglFinish                    = 	dllFinish                    =(void (__stdcall *)(void))GPA( "glFinish" );
+	qglFlush                     = 	dllFlush                     =(void (__stdcall *)(void))GPA( "glFlush" );
+	qglFogf                      = 	dllFogf                      =(void (__stdcall *)(unsigned int,float))GPA( "glFogf" );
+	qglFogfv                     = 	dllFogfv                     =(void (__stdcall *)(unsigned int,const float *))GPA( "glFogfv" );
+	qglFogi                      = 	dllFogi                      =(void (__stdcall *)(unsigned int,int))GPA( "glFogi" );
+	qglFogiv                     = 	dllFogiv                     =(void (__stdcall *)(unsigned int,const int *))GPA( "glFogiv" );
+	qglFrontFace                 = 	dllFrontFace                 =(void (__stdcall *)(unsigned int))GPA( "glFrontFace" );
+	qglFrustum                   = 	dllFrustum                   =(void (__stdcall *)(double,double,double,double,double,double))GPA( "glFrustum" );
+	qglGenLists                  = 	dllGenLists                  =(unsigned int (__stdcall *)(int))GPA( "glGenLists" );
+	qglGenTextures               = 	dllGenTextures               =(void (__stdcall *)(int,unsigned int *))GPA( "glGenTextures" );
+	qglGetBooleanv               = 	dllGetBooleanv               =(void (__stdcall *)(unsigned int,unsigned char *))GPA( "glGetBooleanv" );
+	qglGetClipPlane              = 	dllGetClipPlane              =(void (__stdcall *)(unsigned int,double *))GPA( "glGetClipPlane" );
+	qglGetDoublev                = 	dllGetDoublev                =(void (__stdcall *)(unsigned int,double *))GPA( "glGetDoublev" );
+	qglGetError                  = 	dllGetError                  =(unsigned int (__stdcall *)(void))GPA( "glGetError" );
+	qglGetFloatv                 = 	dllGetFloatv                 =(void (__stdcall *)(unsigned int,float *))GPA( "glGetFloatv" );
+	qglGetIntegerv               = 	dllGetIntegerv               =(void (__stdcall *)(unsigned int,int *))GPA( "glGetIntegerv" );
+	qglGetLightfv                = 	dllGetLightfv                =(void (__stdcall *)(unsigned int,unsigned int,float *))GPA( "glGetLightfv" );
+	qglGetLightiv                = 	dllGetLightiv                =(void (__stdcall *)(unsigned int,unsigned int,int *))GPA( "glGetLightiv" );
+	qglGetMapdv                  = 	dllGetMapdv                  =(void (__stdcall *)(unsigned int,unsigned int,double *))GPA( "glGetMapdv" );
+	qglGetMapfv                  = 	dllGetMapfv                  =(void (__stdcall *)(unsigned int,unsigned int,float *))GPA( "glGetMapfv" );
+	qglGetMapiv                  = 	dllGetMapiv                  =(void (__stdcall *)(unsigned int,unsigned int,int *))GPA( "glGetMapiv" );
+	qglGetMaterialfv             = 	dllGetMaterialfv             =(void (__stdcall *)(unsigned int,unsigned int,float *))GPA( "glGetMaterialfv" );
+	qglGetMaterialiv             = 	dllGetMaterialiv             =(void (__stdcall *)(unsigned int,unsigned int,int *))GPA( "glGetMaterialiv" );
+	qglGetPixelMapfv             = 	dllGetPixelMapfv             =(void (__stdcall *)(unsigned int,float *))GPA( "glGetPixelMapfv" );
+	qglGetPixelMapuiv            = 	dllGetPixelMapuiv            =(void (__stdcall *)(unsigned int,unsigned int *))GPA( "glGetPixelMapuiv" );
+	qglGetPixelMapusv            = 	dllGetPixelMapusv            =(void (__stdcall *)(unsigned int,unsigned short *))GPA( "glGetPixelMapusv" );
+	qglGetPointerv               = 	dllGetPointerv               =(void (__stdcall *)(unsigned int,void ** ))GPA( "glGetPointerv" );
+	qglGetPolygonStipple         = 	dllGetPolygonStipple         =(void (__stdcall *)(unsigned char *))GPA( "glGetPolygonStipple" );
+	qglGetString                 = 	dllGetString                 =(const unsigned char *(__stdcall *)(unsigned int))GPA( "glGetString" );
+	qglGetTexEnvfv               = 	dllGetTexEnvfv               =(void (__stdcall *)(unsigned int,unsigned int,float *))GPA( "glGetTexEnvfv" );
+	qglGetTexEnviv               = 	dllGetTexEnviv               =(void (__stdcall *)(unsigned int,unsigned int,int *))GPA( "glGetTexEnviv" );
+	qglGetTexGendv               = 	dllGetTexGendv               =(void (__stdcall *)(unsigned int,unsigned int,double *))GPA( "glGetTexGendv" );
+	qglGetTexGenfv               = 	dllGetTexGenfv               =(void (__stdcall *)(unsigned int,unsigned int,float *))GPA( "glGetTexGenfv" );
+	qglGetTexGeniv               = 	dllGetTexGeniv               =(void (__stdcall *)(unsigned int,unsigned int,int *))GPA( "glGetTexGeniv" );
+	qglGetTexImage               = 	dllGetTexImage               =(void (__stdcall *)(unsigned int,int,unsigned int,unsigned int,void *))GPA( "glGetTexImage" );
+//	qglGetTexLevelParameterfv    = 	dllGetTexLevelParameterfv    =(void (__stdcall *)(unsigned int,int,unsigned int,float *))GPA( "glGetTexLevelParameterfv" );
+//	qglGetTexLevelParameteriv    = 	dllGetTexLevelParameteriv    =(void (__stdcall *)(unsigned int,int,unsigned int,int *))GPA( "glGetTexLevelParameteriv" );
+	qglGetTexParameterfv         = 	dllGetTexParameterfv         =(void (__stdcall *)(unsigned int,unsigned int,float *))GPA( "glGetTexParameterfv" );
+	qglGetTexParameteriv         = 	dllGetTexParameteriv         =(void (__stdcall *)(unsigned int,unsigned int,int *))GPA( "glGetTexParameteriv" );
+	qglHint                      = 	dllHint                      =(void (__stdcall *)(unsigned int,unsigned int))GPA( "glHint" );
+	qglIndexMask                 = 	dllIndexMask                 =(void (__stdcall *)(unsigned int))GPA( "glIndexMask" );
+	qglIndexPointer              = 	dllIndexPointer              =(void (__stdcall *)(unsigned int,int,const void *))GPA( "glIndexPointer" );
+	qglIndexd                    = 	dllIndexd                    =(void (__stdcall *)(double))GPA( "glIndexd" );
+	qglIndexdv                   = 	dllIndexdv                   =(void (__stdcall *)(const double *))GPA( "glIndexdv" );
+	qglIndexf                    = 	dllIndexf                    =(void (__stdcall *)(float))GPA( "glIndexf" );
+	qglIndexfv                   = 	dllIndexfv                   =(void (__stdcall *)(const float *))GPA( "glIndexfv" );
+	qglIndexi                    = 	dllIndexi                    =(void (__stdcall *)(int))GPA( "glIndexi" );
+	qglIndexiv                   = 	dllIndexiv                   =(void (__stdcall *)(const int *))GPA( "glIndexiv" );
+	qglIndexs                    = 	dllIndexs                    =(void (__stdcall *)(short))GPA( "glIndexs" );
+	qglIndexsv                   = 	dllIndexsv                   =(void (__stdcall *)(const short *))GPA( "glIndexsv" );
+	qglIndexub                   = 	dllIndexub                   =(void (__stdcall *)(unsigned char))GPA( "glIndexub" );
+	qglIndexubv                  = 	dllIndexubv                  =(void (__stdcall *)(const unsigned char *))GPA( "glIndexubv" );
+	qglInitNames                 = 	dllInitNames                 =(void (__stdcall *)(void))GPA( "glInitNames" );
+	qglInterleavedArrays         = 	dllInterleavedArrays         =(void (__stdcall *)(unsigned int,int,const void *))GPA( "glInterleavedArrays" );
+	qglIsEnabled                 = 	dllIsEnabled                 =(unsigned char (__stdcall *)(unsigned int))GPA( "glIsEnabled" );
+	qglIsList                    = 	dllIsList                    =(unsigned char (__stdcall *)(unsigned int))GPA( "glIsList" );
+	qglIsTexture                 = 	dllIsTexture                 =(unsigned char (__stdcall *)(unsigned int))GPA( "glIsTexture" );
+	qglLightModelf               = 	dllLightModelf               =(void (__stdcall *)(unsigned int,float))GPA( "glLightModelf" );
+	qglLightModelfv              = 	dllLightModelfv              =(void (__stdcall *)(unsigned int,const float *))GPA( "glLightModelfv" );
+	qglLightModeli               = 	dllLightModeli               =(void (__stdcall *)(unsigned int,int))GPA( "glLightModeli" );
+	qglLightModeliv              = 	dllLightModeliv              =(void (__stdcall *)(unsigned int,const int *))GPA( "glLightModeliv" );
+	qglLightf                    = 	dllLightf                    =(void (__stdcall *)(unsigned int,unsigned int,float))GPA( "glLightf" );
+	qglLightfv                   = 	dllLightfv                   =(void (__stdcall *)(unsigned int,unsigned int,const float *))GPA( "glLightfv" );
+	qglLighti                    = 	dllLighti                    =(void (__stdcall *)(unsigned int,unsigned int,int))GPA( "glLighti" );
+	qglLightiv                   = 	dllLightiv                   =(void (__stdcall *)(unsigned int,unsigned int,const int *))GPA( "glLightiv" );
+	qglLineStipple               = 	dllLineStipple               =(void (__stdcall *)(int,unsigned short))GPA( "glLineStipple" );
+	qglLineWidth                 = 	dllLineWidth                 =(void (__stdcall *)(float))GPA( "glLineWidth" );
+	qglListBase                  = 	dllListBase                  =(void (__stdcall *)(unsigned int))GPA( "glListBase" );
+	qglLoadIdentity              = 	dllLoadIdentity              =(void (__stdcall *)(void))GPA( "glLoadIdentity" );
+	qglLoadMatrixd               = 	dllLoadMatrixd               =(void (__stdcall *)(const double *))GPA( "glLoadMatrixd" );
+	qglLoadMatrixf               = 	dllLoadMatrixf               =(void (__stdcall *)(const float *))GPA( "glLoadMatrixf" );
+	qglLoadName                  = 	dllLoadName                  =(void (__stdcall *)(unsigned int))GPA( "glLoadName" );
+	qglLogicOp                   = 	dllLogicOp                   =(void (__stdcall *)(unsigned int))GPA( "glLogicOp" );
+	qglMap1d                     = 	dllMap1d                     =(void (__stdcall *)(unsigned int,double,double,int,int,const double *))GPA( "glMap1d" );
+	qglMap1f                     = 	dllMap1f                     =(void (__stdcall *)(unsigned int,float,float,int,int,const float *))GPA( "glMap1f" );
+	qglMap2d                     = 	dllMap2d                     =(void (__stdcall *)(unsigned int,double,double,int,int,double,double,int,int,const double *))GPA( "glMap2d" );
+	qglMap2f                     = 	dllMap2f                     =(void (__stdcall *)(unsigned int,float,float,int,int,float,float,int,int,const float *))GPA( "glMap2f" );
+	qglMapGrid1d                 = 	dllMapGrid1d                 =(void (__stdcall *)(int,double,double))GPA( "glMapGrid1d" );
+	qglMapGrid1f                 = 	dllMapGrid1f                 =(void (__stdcall *)(int,float,float))GPA( "glMapGrid1f" );
+	qglMapGrid2d                 = 	dllMapGrid2d                 =(void (__stdcall *)(int,double,double,int,double,double))GPA( "glMapGrid2d" );
+	qglMapGrid2f                 = 	dllMapGrid2f                 =(void (__stdcall *)(int,float,float,int,float,float))GPA( "glMapGrid2f" );
+	qglMaterialf                 = 	dllMaterialf                 =(void (__stdcall *)(unsigned int,unsigned int,float))GPA( "glMaterialf" );
+	qglMaterialfv                = 	dllMaterialfv                =(void (__stdcall *)(unsigned int,unsigned int,const float *))GPA( "glMaterialfv" );
+	qglMateriali                 = 	dllMateriali                 =(void (__stdcall *)(unsigned int,unsigned int,int))GPA( "glMateriali" );
+	qglMaterialiv                = 	dllMaterialiv                =(void (__stdcall *)(unsigned int,unsigned int,const int *))GPA( "glMaterialiv" );
+	qglMatrixMode                = 	dllMatrixMode                =(void (__stdcall *)(unsigned int))GPA( "glMatrixMode" );
+	qglMultMatrixd               = 	dllMultMatrixd               =(void (__stdcall *)(const double *))GPA( "glMultMatrixd" );
+	qglMultMatrixf               = 	dllMultMatrixf               =(void (__stdcall *)(const float *))GPA( "glMultMatrixf" );
+	qglNewList                   = 	dllNewList                   =(void (__stdcall *)(unsigned int,unsigned int))GPA( "glNewList" );
+	qglNormal3b                  = 	dllNormal3b                  =(void (__stdcall *)(signed char,signed char,signed char))GPA( "glNormal3b" );
+	qglNormal3bv                 = 	dllNormal3bv                 =(void (__stdcall *)(const signed char *))GPA( "glNormal3bv" );
+	qglNormal3d                  = 	dllNormal3d                  =(void (__stdcall *)(double,double,double))GPA( "glNormal3d" );
+	qglNormal3dv                 = 	dllNormal3dv                 =(void (__stdcall *)(const double *))GPA( "glNormal3dv" );
+	qglNormal3f                  = 	dllNormal3f                  =(void (__stdcall *)(float,float,float))GPA( "glNormal3f" );
+	qglNormal3fv                 = 	dllNormal3fv                 =(void (__stdcall *)(const float *))GPA( "glNormal3fv" );
+	qglNormal3i                  = 	dllNormal3i                  =(void (__stdcall *)(int,int,int))GPA( "glNormal3i" );
+	qglNormal3iv                 = 	dllNormal3iv                 =(void (__stdcall *)(const int *))GPA( "glNormal3iv" );
+	qglNormal3s                  = 	dllNormal3s                  =(void (__stdcall *)(short,short,short))GPA( "glNormal3s" );
+	qglNormal3sv                 = 	dllNormal3sv                 =(void (__stdcall *)(const short *))GPA( "glNormal3sv" );
+	qglNormalPointer             = 	dllNormalPointer             =(void (__stdcall *)(unsigned int,int,const void *))GPA( "glNormalPointer" );
+	qglOrtho                     = 	dllOrtho                     =(void (__stdcall *)(double,double,double,double,double,double))GPA( "glOrtho" );
+	qglPassThrough               = 	dllPassThrough               =(void (__stdcall *)(float))GPA( "glPassThrough" );
+	qglPixelMapfv                = 	dllPixelMapfv                =(void (__stdcall *)(unsigned int,int,const float *))GPA( "glPixelMapfv" );
+	qglPixelMapuiv               = 	dllPixelMapuiv               =(void (__stdcall *)(unsigned int,int,const unsigned int *))GPA( "glPixelMapuiv" );
+	qglPixelMapusv               = 	dllPixelMapusv               =(void (__stdcall *)(unsigned int,int,const unsigned short *))GPA( "glPixelMapusv" );
+	qglPixelStoref               = 	dllPixelStoref               =(void (__stdcall *)(unsigned int,float))GPA( "glPixelStoref" );
+	qglPixelStorei               = 	dllPixelStorei               =(void (__stdcall *)(unsigned int,int))GPA( "glPixelStorei" );
+	qglPixelTransferf            = 	dllPixelTransferf            =(void (__stdcall *)(unsigned int,float))GPA( "glPixelTransferf" );
+	qglPixelTransferi            = 	dllPixelTransferi            =(void (__stdcall *)(unsigned int,int))GPA( "glPixelTransferi" );
+	qglPixelZoom                 = 	dllPixelZoom                 =(void (__stdcall *)(float,float))GPA( "glPixelZoom" );
+	qglPointSize                 = 	dllPointSize                 =(void (__stdcall *)(float))GPA( "glPointSize" );
+	qglPolygonMode               = 	dllPolygonMode               =(void (__stdcall *)(unsigned int,unsigned int))GPA( "glPolygonMode" );
+	qglPolygonOffset             = 	dllPolygonOffset             =(void (__stdcall *)(float,float))GPA( "glPolygonOffset" );
+	qglPolygonStipple            = 	dllPolygonStipple            =(void (__stdcall *)(const unsigned char *))GPA( "glPolygonStipple" );
+	qglPopAttrib                 = 	dllPopAttrib                 =(void (__stdcall *)(void))GPA( "glPopAttrib" );
+	qglPopClientAttrib           = 	dllPopClientAttrib           =(void (__stdcall *)(void))GPA( "glPopClientAttrib" );
+	qglPopMatrix                 = 	dllPopMatrix                 =(void (__stdcall *)(void))GPA( "glPopMatrix" );
+	qglPopName                   = 	dllPopName                   =(void (__stdcall *)(void))GPA( "glPopName" );
+	qglPrioritizeTextures        = 	dllPrioritizeTextures        =(void (__stdcall *)(int,const unsigned int *,const float *))GPA( "glPrioritizeTextures" );
+	qglPushAttrib                = 	dllPushAttrib                =(void (__stdcall *)(unsigned int))GPA( "glPushAttrib" );
+	qglPushClientAttrib          = 	dllPushClientAttrib          =(void (__stdcall *)(unsigned int))GPA( "glPushClientAttrib" );
+	qglPushMatrix                = 	dllPushMatrix                =(void (__stdcall *)(void))GPA( "glPushMatrix" );
+	qglPushName                  = 	dllPushName                  =(void (__stdcall *)(unsigned int))GPA( "glPushName" );
+	qglRasterPos2d               = 	dllRasterPos2d               =(void (__stdcall *)(double,double))GPA( "glRasterPos2d" );
+	qglRasterPos2dv              = 	dllRasterPos2dv              =(void (__stdcall *)(const double *))GPA( "glRasterPos2dv" );
+	qglRasterPos2f               = 	dllRasterPos2f               =(void (__stdcall *)(float,float))GPA( "glRasterPos2f" );
+	qglRasterPos2fv              = 	dllRasterPos2fv              =(void (__stdcall *)(const float *))GPA( "glRasterPos2fv" );
+	qglRasterPos2i               = 	dllRasterPos2i               =(void (__stdcall *)(int,int))GPA( "glRasterPos2i" );
+	qglRasterPos2iv              = 	dllRasterPos2iv              =(void (__stdcall *)(const int *))GPA( "glRasterPos2iv" );
+	qglRasterPos2s               = 	dllRasterPos2s               =(void (__stdcall *)(short,short))GPA( "glRasterPos2s" );
+	qglRasterPos2sv              = 	dllRasterPos2sv              =(void (__stdcall *)(const short *))GPA( "glRasterPos2sv" );
+	qglRasterPos3d               = 	dllRasterPos3d               =(void (__stdcall *)(double,double,double))GPA( "glRasterPos3d" );
+	qglRasterPos3dv              = 	dllRasterPos3dv              =(void (__stdcall *)(const double *))GPA( "glRasterPos3dv" );
+	qglRasterPos3f               = 	dllRasterPos3f               =(void (__stdcall *)(float,float,float))GPA( "glRasterPos3f" );
+	qglRasterPos3fv              = 	dllRasterPos3fv              =(void (__stdcall *)(const float *))GPA( "glRasterPos3fv" );
+	qglRasterPos3i               = 	dllRasterPos3i               =(void (__stdcall *)(int,int,int))GPA( "glRasterPos3i" );
+	qglRasterPos3iv              = 	dllRasterPos3iv              =(void (__stdcall *)(const int *))GPA( "glRasterPos3iv" );
+	qglRasterPos3s               = 	dllRasterPos3s               =(void (__stdcall *)(short,short,short))GPA( "glRasterPos3s" );
+	qglRasterPos3sv              = 	dllRasterPos3sv              =(void (__stdcall *)(const short *))GPA( "glRasterPos3sv" );
+	qglRasterPos4d               = 	dllRasterPos4d               =(void (__stdcall *)(double,double,double,double))GPA( "glRasterPos4d" );
+	qglRasterPos4dv              = 	dllRasterPos4dv              =(void (__stdcall *)(const double *))GPA( "glRasterPos4dv" );
+	qglRasterPos4f               = 	dllRasterPos4f               =(void (__stdcall *)(float,float,float,float))GPA( "glRasterPos4f" );
+	qglRasterPos4fv              = 	dllRasterPos4fv              =(void (__stdcall *)(const float *))GPA( "glRasterPos4fv" );
+	qglRasterPos4i               = 	dllRasterPos4i               =(void (__stdcall *)(int,int,int,int))GPA( "glRasterPos4i" );
+	qglRasterPos4iv              = 	dllRasterPos4iv              =(void (__stdcall *)(const int *))GPA( "glRasterPos4iv" );
+	qglRasterPos4s               = 	dllRasterPos4s               =(void (__stdcall *)(short,short,short,short))GPA( "glRasterPos4s" );
+	qglRasterPos4sv              = 	dllRasterPos4sv              =(void (__stdcall *)(const short *))GPA( "glRasterPos4sv" );
+	qglReadBuffer                = 	dllReadBuffer                =(void (__stdcall *)(unsigned int))GPA( "glReadBuffer" );
+	qglReadPixels                = 	dllReadPixels                =(void (__stdcall *)(int,int,int,int,unsigned int,unsigned int,void *))GPA( "glReadPixels" );
+	qglRectd                     = 	dllRectd                     =(void (__stdcall *)(double,double,double,double))GPA( "glRectd" );
+	qglRectdv                    = 	dllRectdv                    =(void (__stdcall *)(const double *,const double *))GPA( "glRectdv" );
+	qglRectf                     = 	dllRectf                     =(void (__stdcall *)(float,float,float,float))GPA( "glRectf" );
+	qglRectfv                    = 	dllRectfv                    =(void (__stdcall *)(const float *,const float *))GPA( "glRectfv" );
+	qglRecti                     = 	dllRecti                     =(void (__stdcall *)(int,int,int,int))GPA( "glRecti" );
+	qglRectiv                    = 	dllRectiv                    =(void (__stdcall *)(const int *,const int *))GPA( "glRectiv" );
+	qglRects                     = 	dllRects                     =(void (__stdcall *)(short,short,short,short))GPA( "glRects" );
+	qglRectsv                    = 	dllRectsv                    =(void (__stdcall *)(const short *,const short *))GPA( "glRectsv" );
+	qglRenderMode                = 	dllRenderMode                =(int (__stdcall *)(unsigned int))GPA( "glRenderMode" );
+	qglRotated                   = 	dllRotated                   =(void (__stdcall *)(double,double,double,double))GPA( "glRotated" );
+	qglRotatef                   = 	dllRotatef                   =(void (__stdcall *)(float,float,float,float))GPA( "glRotatef" );
+	qglScaled                    = 	dllScaled                    =(void (__stdcall *)(double,double,double))GPA( "glScaled" );
+	qglScalef                    = 	dllScalef                    =(void (__stdcall *)(float,float,float))GPA( "glScalef" );
+	qglScissor                   = 	dllScissor                   =(void (__stdcall *)(int,int,int,int))GPA( "glScissor" );
+	qglSelectBuffer              = 	dllSelectBuffer              =(void (__stdcall *)(int,unsigned int *))GPA( "glSelectBuffer" );
+	qglShadeModel                = 	dllShadeModel                =(void (__stdcall *)(unsigned int))GPA( "glShadeModel" );
+	qglStencilFunc               = 	dllStencilFunc               =(void (__stdcall *)(unsigned int,int,unsigned int))GPA( "glStencilFunc" );
+	qglStencilMask               = 	dllStencilMask               =(void (__stdcall *)(unsigned int))GPA( "glStencilMask" );
+	qglStencilOp                 = 	dllStencilOp                 =(void (__stdcall *)(unsigned int,unsigned int,unsigned int))GPA( "glStencilOp" );
+	qglTexCoord1d                = 	dllTexCoord1d                =(void (__stdcall *)(double))GPA( "glTexCoord1d" );
+	qglTexCoord1dv               = 	dllTexCoord1dv               =(void (__stdcall *)(const double *))GPA( "glTexCoord1dv" );
+	qglTexCoord1f                = 	dllTexCoord1f                =(void (__stdcall *)(float))GPA( "glTexCoord1f" );
+	qglTexCoord1fv               = 	dllTexCoord1fv               =(void (__stdcall *)(const float *))GPA( "glTexCoord1fv" );
+	qglTexCoord1i                = 	dllTexCoord1i                =(void (__stdcall *)(int))GPA( "glTexCoord1i" );
+	qglTexCoord1iv               = 	dllTexCoord1iv               =(void (__stdcall *)(const int *))GPA( "glTexCoord1iv" );
+	qglTexCoord1s                = 	dllTexCoord1s                =(void (__stdcall *)(short))GPA( "glTexCoord1s" );
+	qglTexCoord1sv               = 	dllTexCoord1sv               =(void (__stdcall *)(const short *))GPA( "glTexCoord1sv" );
+	qglTexCoord2d                = 	dllTexCoord2d                =(void (__stdcall *)(double,double))GPA( "glTexCoord2d" );
+	qglTexCoord2dv               = 	dllTexCoord2dv               =(void (__stdcall *)(const double *))GPA( "glTexCoord2dv" );
+	qglTexCoord2f                = 	dllTexCoord2f                =(void (__stdcall *)(float,float))GPA( "glTexCoord2f" );
+	qglTexCoord2fv               = 	dllTexCoord2fv               =(void (__stdcall *)(const float *))GPA( "glTexCoord2fv" );
+	qglTexCoord2i                = 	dllTexCoord2i                =(void (__stdcall *)(int,int))GPA( "glTexCoord2i" );
+	qglTexCoord2iv               = 	dllTexCoord2iv               =(void (__stdcall *)(const int *))GPA( "glTexCoord2iv" );
+	qglTexCoord2s                = 	dllTexCoord2s                =(void (__stdcall *)(short,short))GPA( "glTexCoord2s" );
+	qglTexCoord2sv               = 	dllTexCoord2sv               =(void (__stdcall *)(const short *))GPA( "glTexCoord2sv" );
+	qglTexCoord3d                = 	dllTexCoord3d                =(void (__stdcall *)(double,double,double))GPA( "glTexCoord3d" );
+	qglTexCoord3dv               = 	dllTexCoord3dv               =(void (__stdcall *)(const double *))GPA( "glTexCoord3dv" );
+	qglTexCoord3f                = 	dllTexCoord3f                =(void (__stdcall *)(float,float,float))GPA( "glTexCoord3f" );
+	qglTexCoord3fv               = 	dllTexCoord3fv               =(void (__stdcall *)(const float *))GPA( "glTexCoord3fv" );
+	qglTexCoord3i                = 	dllTexCoord3i                =(void (__stdcall *)(int,int,int))GPA( "glTexCoord3i" );
+	qglTexCoord3iv               = 	dllTexCoord3iv               =(void (__stdcall *)(const int *))GPA( "glTexCoord3iv" );
+	qglTexCoord3s                = 	dllTexCoord3s                =(void (__stdcall *)(short,short,short))GPA( "glTexCoord3s" );
+	qglTexCoord3sv               = 	dllTexCoord3sv               =(void (__stdcall *)(const short *))GPA( "glTexCoord3sv" );
+	qglTexCoord4d                = 	dllTexCoord4d                =(void (__stdcall *)(double,double,double,double))GPA( "glTexCoord4d" );
+	qglTexCoord4dv               = 	dllTexCoord4dv               =(void (__stdcall *)(const double *))GPA( "glTexCoord4dv" );
+	qglTexCoord4f                = 	dllTexCoord4f                =(void (__stdcall *)(float,float,float,float))GPA( "glTexCoord4f" );
+	qglTexCoord4fv               = 	dllTexCoord4fv               =(void (__stdcall *)(const float *))GPA( "glTexCoord4fv" );
+	qglTexCoord4i                = 	dllTexCoord4i                =(void (__stdcall *)(int,int,int,int))GPA( "glTexCoord4i" );
+	qglTexCoord4iv               = 	dllTexCoord4iv               =(void (__stdcall *)(const int *))GPA( "glTexCoord4iv" );
+	qglTexCoord4s                = 	dllTexCoord4s                =(void (__stdcall *)(short,short,short,short))GPA( "glTexCoord4s" );
+	qglTexCoord4sv               = 	dllTexCoord4sv               =(void (__stdcall *)(const short *))GPA( "glTexCoord4sv" );
+	qglTexCoordPointer           = 	dllTexCoordPointer           =(void (__stdcall *)(int,unsigned int,int,const void *))GPA( "glTexCoordPointer" );
+	qglTexEnvf                   = 	dllTexEnvf                   =(void (__stdcall *)(unsigned int,unsigned int,float))GPA( "glTexEnvf" );
+	qglTexEnvfv                  = 	dllTexEnvfv                  =(void (__stdcall *)(unsigned int,unsigned int,const float *))GPA( "glTexEnvfv" );
+	qglTexEnvi                   = 	dllTexEnvi                   =(void (__stdcall *)(unsigned int,unsigned int,int))GPA( "glTexEnvi" );
+	qglTexEnviv                  = 	dllTexEnviv                  =(void (__stdcall *)(unsigned int,unsigned int,const int *))GPA( "glTexEnviv" );
+	qglTexGend                   = 	dllTexGend                   =(void (__stdcall *)(unsigned int,unsigned int,double))GPA( "glTexGend" );
+	qglTexGendv                  = 	dllTexGendv                  =(void (__stdcall *)(unsigned int,unsigned int,const double *))GPA( "glTexGendv" );
+	qglTexGenf                   = 	dllTexGenf                   =(void (__stdcall *)(unsigned int,unsigned int,float))GPA( "glTexGenf" );
+	qglTexGenfv                  = 	dllTexGenfv                  =(void (__stdcall *)(unsigned int,unsigned int,const float *))GPA( "glTexGenfv" );
+	qglTexGeni                   = 	dllTexGeni                   =(void (__stdcall *)(unsigned int,unsigned int,int))GPA( "glTexGeni" );
+	qglTexGeniv                  = 	dllTexGeniv                  =(void (__stdcall *)(unsigned int,unsigned int,const int *))GPA( "glTexGeniv" );
+	qglTexImage1D                = 	dllTexImage1D                =(void (__stdcall *)(unsigned int,int,int,int,int,unsigned int,unsigned int,const void *))GPA( "glTexImage1D" );
+	qglTexImage2D                = 	dllTexImage2D                =(void (__stdcall *)(unsigned int,int,int,int,int,int,unsigned int,unsigned int,const void *))GPA( "glTexImage2D" );
+	qglTexParameterf             = 	dllTexParameterf             =(void (__stdcall *)(unsigned int,unsigned int,float))GPA( "glTexParameterf" );
+	qglTexParameterfv            = 	dllTexParameterfv            =(void (__stdcall *)(unsigned int,unsigned int,const float *))GPA( "glTexParameterfv" );
+	qglTexParameteri             = 	dllTexParameteri             =(void (__stdcall *)(unsigned int,unsigned int,int))GPA( "glTexParameteri" );
+	qglTexParameteriv            = 	dllTexParameteriv            =(void (__stdcall *)(unsigned int,unsigned int,const int *))GPA( "glTexParameteriv" );
+	qglTexSubImage1D             = 	dllTexSubImage1D             =(void (__stdcall *)(unsigned int,int,int,int,unsigned int,unsigned int,const void *))GPA( "glTexSubImage1D" );
+	qglTexSubImage2D             = 	dllTexSubImage2D             =(void (__stdcall *)(unsigned int,int,int,int,int,int,unsigned int,unsigned int,const void *))GPA( "glTexSubImage2D" );
+	qglTranslated                = 	dllTranslated                =(void (__stdcall *)(double,double,double))GPA( "glTranslated" );
+	qglTranslatef                = 	dllTranslatef                =(void (__stdcall *)(float,float,float))GPA( "glTranslatef" );
+	qglVertex2d                  = 	dllVertex2d                  =(void (__stdcall *)(double,double))GPA( "glVertex2d" );
+	qglVertex2dv                 = 	dllVertex2dv                 =(void (__stdcall *)(const double *))GPA( "glVertex2dv" );
+	qglVertex2f                  = 	dllVertex2f                  =(void (__stdcall *)(float,float))GPA( "glVertex2f" );
+	qglVertex2fv                 = 	dllVertex2fv                 =(void (__stdcall *)(const float *))GPA( "glVertex2fv" );
+	qglVertex2i                  = 	dllVertex2i                  =(void (__stdcall *)(int,int))GPA( "glVertex2i" );
+	qglVertex2iv                 = 	dllVertex2iv                 =(void (__stdcall *)(const int *))GPA( "glVertex2iv" );
+	qglVertex2s                  = 	dllVertex2s                  =(void (__stdcall *)(short,short))GPA( "glVertex2s" );
+	qglVertex2sv                 = 	dllVertex2sv                 =(void (__stdcall *)(const short *))GPA( "glVertex2sv" );
+	qglVertex3d                  = 	dllVertex3d                  =(void (__stdcall *)(double,double,double))GPA( "glVertex3d" );
+	qglVertex3dv                 = 	dllVertex3dv                 =(void (__stdcall *)(const double *))GPA( "glVertex3dv" );
+	qglVertex3f                  = 	dllVertex3f                  =(void (__stdcall *)(float,float,float))GPA( "glVertex3f" );
+	qglVertex3fv                 = 	dllVertex3fv                 =(void (__stdcall *)(const float *))GPA( "glVertex3fv" );
+	qglVertex3i                  = 	dllVertex3i                  =(void (__stdcall *)(int,int,int))GPA( "glVertex3i" );
+	qglVertex3iv                 = 	dllVertex3iv                 =(void (__stdcall *)(const int *))GPA( "glVertex3iv" );
+	qglVertex3s                  = 	dllVertex3s                  =(void (__stdcall *)(short,short,short))GPA( "glVertex3s" );
+	qglVertex3sv                 = 	dllVertex3sv                 =(void (__stdcall *)(const short *))GPA( "glVertex3sv" );
+	qglVertex4d                  = 	dllVertex4d                  =(void (__stdcall *)(double,double,double,double))GPA( "glVertex4d" );
+	qglVertex4dv                 = 	dllVertex4dv                 =(void (__stdcall *)(const double *))GPA( "glVertex4dv" );
+	qglVertex4f                  = 	dllVertex4f                  =(void (__stdcall *)(float,float,float,float))GPA( "glVertex4f" );
+	qglVertex4fv                 = 	dllVertex4fv                 =(void (__stdcall *)(const float *))GPA( "glVertex4fv" );
+	qglVertex4i                  = 	dllVertex4i                  =(void (__stdcall *)(int,int,int,int))GPA( "glVertex4i" );
+	qglVertex4iv                 = 	dllVertex4iv                 =(void (__stdcall *)(const int *))GPA( "glVertex4iv" );
+	qglVertex4s                  = 	dllVertex4s                  =(void (__stdcall *)(short,short,short,short))GPA( "glVertex4s" );
+	qglVertex4sv                 = 	dllVertex4sv                 =(void (__stdcall *)(const short *))GPA( "glVertex4sv" );
+	qglVertexPointer             = 	dllVertexPointer             =(void (__stdcall *)(int,unsigned int,int,const void *))GPA( "glVertexPointer" );
+	qglViewport                  = 	dllViewport                  =(void (__stdcall *)(int,int,int,int))GPA( "glViewport" );
+
+	qwglCopyContext              =(int (__stdcall *)(struct HGLRC__ *,struct HGLRC__ *,unsigned int))GPA( "wglCopyContext" );
+	qwglCreateContext            =(struct HGLRC__ *(__stdcall *)(struct HDC__ *))GPA( "wglCreateContext" );
+	qwglCreateLayerContext       =(struct HGLRC__ *(__stdcall *)(struct HDC__ *,int))GPA( "wglCreateLayerContext" );
+	qwglDeleteContext            =(int (__stdcall *)(struct HGLRC__ *))GPA( "wglDeleteContext" );
+	qwglDescribeLayerPlane       =(int (__stdcall *)(struct HDC__ *,int,int,unsigned int,struct tagLAYERPLANEDESCRIPTOR *))GPA( "wglDescribeLayerPlane" );
+	qwglGetCurrentContext        =(struct HGLRC__ *(__stdcall *)(void))GPA( "wglGetCurrentContext" );
+	qwglGetCurrentDC             =(struct HDC__ *(__stdcall *)(void))GPA( "wglGetCurrentDC" );
+	qwglGetLayerPaletteEntries   =(int (__stdcall *)(struct HDC__ *,int,int,int,unsigned long *))GPA( "wglGetLayerPaletteEntries" );
+	qwglGetProcAddress           =(int (__stdcall *(__stdcall *)(const char *))(void))GPA( "wglGetProcAddress" );
+	qwglMakeCurrent              =(int (__stdcall *)(struct HDC__ *,struct HGLRC__ *))GPA( "wglMakeCurrent" );
+	qwglRealizeLayerPalette      =(int (__stdcall *)(struct HDC__ *,int,int))GPA( "wglRealizeLayerPalette" );
+	qwglSetLayerPaletteEntries   =(int (__stdcall *)(struct HDC__ *,int,int,int,const unsigned long *))GPA( "wglSetLayerPaletteEntries" );
+	qwglShareLists               =(int (__stdcall *)(struct HGLRC__ *,struct HGLRC__ *))GPA( "wglShareLists" );
+	qwglSwapLayerBuffers         =(int (__stdcall *)(struct HDC__ *,unsigned int))GPA( "wglSwapLayerBuffers" );
+	qwglUseFontBitmaps           =(int (__stdcall *)(struct HDC__ *,unsigned long,unsigned long,unsigned long))GPA( "wglUseFontBitmapsA" );
+	qwglUseFontOutlines          =(int (__stdcall *)(struct HDC__ *,unsigned long,unsigned long,unsigned long,float,float,int,struct _GLYPHMETRICSFLOAT *))GPA( "wglUseFontOutlinesA" );
+
+	qwglSwapIntervalEXT = 0;
+	qglActiveTextureARB = 0;
+	qglClientActiveTextureARB = 0;
+	qglMultiTexCoord2fARB = 0;
+	qglLockArraysEXT = 0;
+	qglUnlockArraysEXT = 0;
+	qglPointParameterfEXT = NULL;
+	qglPointParameterfvEXT = NULL;
+	qglPointParameteriNV	= NULL;
+	qglPointParameterivNV	= NULL;
+
+	// check logging
+	QGL_EnableLogging( r_logFile->integer );
+
+	return qtrue;
+}
+
+void QGL_EnableLogging( qboolean enable )
+{
+	static qboolean isEnabled;
+
+	// return if we're already active
+	if ( isEnabled && enable ) {
+		// decrement log counter and stop if it has reached 0
+		Cvar_Set( "r_logFile", va("%d", r_logFile->integer - 1 ) );
+		if ( r_logFile->integer ) {
+			return;
+		}
+		enable = qfalse;
+	}
+
+	// return if we're already disabled
+	if ( !enable && !isEnabled )
+		return;
+
+	isEnabled = enable;
+
+	if ( enable )
+	{
+		if ( !glw_state.log_fp )
+		{
+			struct tm *newtime;
+			time_t aclock;
+			char buffer[1024];
+			cvar_t	*basedir;
+
+			time( &aclock );
+			newtime = localtime( &aclock );
+
+			asctime( newtime );
+
+			basedir = Cvar_Get( "fs_basepath", "", 0 );
+			Com_sprintf( buffer, sizeof(buffer), "%s/gl.log", basedir->string ); 
+			glw_state.log_fp = fopen( buffer, "wt" );
+
+			fprintf( glw_state.log_fp, "%s\n", asctime( newtime ) );
+		}
+
+		qglAccum                     = logAccum;
+		qglAlphaFunc                 = logAlphaFunc;
+		qglAreTexturesResident       = logAreTexturesResident;
+		qglArrayElement              = logArrayElement;
+		qglBegin                     = logBegin;
+		qglBindTexture               = logBindTexture;
+		qglBitmap                    = logBitmap;
+		qglBlendFunc                 = logBlendFunc;
+		qglCallList                  = logCallList;
+		qglCallLists                 = logCallLists;
+		qglClear                     = logClear;
+		qglClearAccum                = logClearAccum;
+		qglClearColor                = logClearColor;
+		qglClearDepth                = logClearDepth;
+		qglClearIndex                = logClearIndex;
+		qglClearStencil              = logClearStencil;
+		qglClipPlane                 = logClipPlane;
+		qglColor3b                   = logColor3b;
+		qglColor3bv                  = logColor3bv;
+		qglColor3d                   = logColor3d;
+		qglColor3dv                  = logColor3dv;
+		qglColor3f                   = logColor3f;
+		qglColor3fv                  = logColor3fv;
+		qglColor3i                   = logColor3i;
+		qglColor3iv                  = logColor3iv;
+		qglColor3s                   = logColor3s;
+		qglColor3sv                  = logColor3sv;
+		qglColor3ub                  = logColor3ub;
+		qglColor3ubv                 = logColor3ubv;
+		qglColor3ui                  = logColor3ui;
+		qglColor3uiv                 = logColor3uiv;
+		qglColor3us                  = logColor3us;
+		qglColor3usv                 = logColor3usv;
+		qglColor4b                   = logColor4b;
+		qglColor4bv                  = logColor4bv;
+		qglColor4d                   = logColor4d;
+		qglColor4dv                  = logColor4dv;
+		qglColor4f                   = logColor4f;
+		qglColor4fv                  = logColor4fv;
+		qglColor4i                   = logColor4i;
+		qglColor4iv                  = logColor4iv;
+		qglColor4s                   = logColor4s;
+		qglColor4sv                  = logColor4sv;
+		qglColor4ub                  = logColor4ub;
+		qglColor4ubv                 = logColor4ubv;
+		qglColor4ui                  = logColor4ui;
+		qglColor4uiv                 = logColor4uiv;
+		qglColor4us                  = logColor4us;
+		qglColor4usv                 = logColor4usv;
+		qglColorMask                 = logColorMask;
+		qglColorMaterial             = logColorMaterial;
+		qglColorPointer              = logColorPointer;
+		qglCopyPixels                = logCopyPixels;
+		qglCopyTexImage1D            = logCopyTexImage1D;
+		qglCopyTexImage2D            = logCopyTexImage2D;
+		qglCopyTexSubImage1D         = logCopyTexSubImage1D;
+		qglCopyTexSubImage2D         = logCopyTexSubImage2D;
+		qglCullFace                  = logCullFace;
+		qglDeleteLists               = logDeleteLists ;
+		qglDeleteTextures            = logDeleteTextures ;
+		qglDepthFunc                 = logDepthFunc ;
+		qglDepthMask                 = logDepthMask ;
+		qglDepthRange                = logDepthRange ;
+		qglDisable                   = logDisable ;
+		qglDisableClientState        = logDisableClientState ;
+		qglDrawArrays                = logDrawArrays ;
+		qglDrawBuffer                = logDrawBuffer ;
+		qglDrawElements              = logDrawElements ;
+		qglDrawPixels                = logDrawPixels ;
+		qglEdgeFlag                  = logEdgeFlag ;
+		qglEdgeFlagPointer           = logEdgeFlagPointer ;
+		qglEdgeFlagv                 = logEdgeFlagv ;
+		qglEnable                    = 	logEnable                    ;
+		qglEnableClientState         = 	logEnableClientState         ;
+		qglEnd                       = 	logEnd                       ;
+		qglEndList                   = 	logEndList                   ;
+		qglEvalCoord1d				 = 	logEvalCoord1d				 ;
+		qglEvalCoord1dv              = 	logEvalCoord1dv              ;
+		qglEvalCoord1f               = 	logEvalCoord1f               ;
+		qglEvalCoord1fv              = 	logEvalCoord1fv              ;
+		qglEvalCoord2d               = 	logEvalCoord2d               ;
+		qglEvalCoord2dv              = 	logEvalCoord2dv              ;
+		qglEvalCoord2f               = 	logEvalCoord2f               ;
+		qglEvalCoord2fv              = 	logEvalCoord2fv              ;
+		qglEvalMesh1                 = 	logEvalMesh1                 ;
+		qglEvalMesh2                 = 	logEvalMesh2                 ;
+		qglEvalPoint1                = 	logEvalPoint1                ;
+		qglEvalPoint2                = 	logEvalPoint2                ;
+		qglFeedbackBuffer            = 	logFeedbackBuffer            ;
+		qglFinish                    = 	logFinish                    ;
+		qglFlush                     = 	logFlush                     ;
+		qglFogf                      = 	logFogf                      ;
+		qglFogfv                     = 	logFogfv                     ;
+		qglFogi                      = 	logFogi                      ;
+		qglFogiv                     = 	logFogiv                     ;
+		qglFrontFace                 = 	logFrontFace                 ;
+		qglFrustum                   = 	logFrustum                   ;
+		qglGenLists                  = 	logGenLists                  ;
+		qglGenTextures               = 	logGenTextures               ;
+		qglGetBooleanv               = 	logGetBooleanv               ;
+		qglGetClipPlane              = 	logGetClipPlane              ;
+		qglGetDoublev                = 	logGetDoublev                ;
+		qglGetError                  = 	logGetError                  ;
+		qglGetFloatv                 = 	logGetFloatv                 ;
+		qglGetIntegerv               = 	logGetIntegerv               ;
+		qglGetLightfv                = 	logGetLightfv                ;
+		qglGetLightiv                = 	logGetLightiv                ;
+		qglGetMapdv                  = 	logGetMapdv                  ;
+		qglGetMapfv                  = 	logGetMapfv                  ;
+		qglGetMapiv                  = 	logGetMapiv                  ;
+		qglGetMaterialfv             = 	logGetMaterialfv             ;
+		qglGetMaterialiv             = 	logGetMaterialiv             ;
+		qglGetPixelMapfv             = 	logGetPixelMapfv             ;
+		qglGetPixelMapuiv            = 	logGetPixelMapuiv            ;
+		qglGetPixelMapusv            = 	logGetPixelMapusv            ;
+		qglGetPointerv               = 	logGetPointerv               ;
+		qglGetPolygonStipple         = 	logGetPolygonStipple         ;
+		qglGetString                 = 	logGetString                 ;
+		qglGetTexEnvfv               = 	logGetTexEnvfv               ;
+		qglGetTexEnviv               = 	logGetTexEnviv               ;
+		qglGetTexGendv               = 	logGetTexGendv               ;
+		qglGetTexGenfv               = 	logGetTexGenfv               ;
+		qglGetTexGeniv               = 	logGetTexGeniv               ;
+		qglGetTexImage               = 	logGetTexImage               ;
+		qglGetTexLevelParameterfv    = 	logGetTexLevelParameterfv    ;
+		qglGetTexLevelParameteriv    = 	logGetTexLevelParameteriv    ;
+		qglGetTexParameterfv         = 	logGetTexParameterfv         ;
+		qglGetTexParameteriv         = 	logGetTexParameteriv         ;
+		qglHint                      = 	logHint                      ;
+		qglIndexMask                 = 	logIndexMask                 ;
+		qglIndexPointer              = 	logIndexPointer              ;
+		qglIndexd                    = 	logIndexd                    ;
+		qglIndexdv                   = 	logIndexdv                   ;
+		qglIndexf                    = 	logIndexf                    ;
+		qglIndexfv                   = 	logIndexfv                   ;
+		qglIndexi                    = 	logIndexi                    ;
+		qglIndexiv                   = 	logIndexiv                   ;
+		qglIndexs                    = 	logIndexs                    ;
+		qglIndexsv                   = 	logIndexsv                   ;
+		qglIndexub                   = 	logIndexub                   ;
+		qglIndexubv                  = 	logIndexubv                  ;
+		qglInitNames                 = 	logInitNames                 ;
+		qglInterleavedArrays         = 	logInterleavedArrays         ;
+		qglIsEnabled                 = 	logIsEnabled                 ;
+		qglIsList                    = 	logIsList                    ;
+		qglIsTexture                 = 	logIsTexture                 ;
+		qglLightModelf               = 	logLightModelf               ;
+		qglLightModelfv              = 	logLightModelfv              ;
+		qglLightModeli               = 	logLightModeli               ;
+		qglLightModeliv              = 	logLightModeliv              ;
+		qglLightf                    = 	logLightf                    ;
+		qglLightfv                   = 	logLightfv                   ;
+		qglLighti                    = 	logLighti                    ;
+		qglLightiv                   = 	logLightiv                   ;
+		qglLineStipple               = 	logLineStipple               ;
+		qglLineWidth                 = 	logLineWidth                 ;
+		qglListBase                  = 	logListBase                  ;
+		qglLoadIdentity              = 	logLoadIdentity              ;
+		qglLoadMatrixd               = 	logLoadMatrixd               ;
+		qglLoadMatrixf               = 	logLoadMatrixf               ;
+		qglLoadName                  = 	logLoadName                  ;
+		qglLogicOp                   = 	logLogicOp                   ;
+		qglMap1d                     = 	logMap1d                     ;
+		qglMap1f                     = 	logMap1f                     ;
+		qglMap2d                     = 	logMap2d                     ;
+		qglMap2f                     = 	logMap2f                     ;
+		qglMapGrid1d                 = 	logMapGrid1d                 ;
+		qglMapGrid1f                 = 	logMapGrid1f                 ;
+		qglMapGrid2d                 = 	logMapGrid2d                 ;
+		qglMapGrid2f                 = 	logMapGrid2f                 ;
+		qglMaterialf                 = 	logMaterialf                 ;
+		qglMaterialfv                = 	logMaterialfv                ;
+		qglMateriali                 = 	logMateriali                 ;
+		qglMaterialiv                = 	logMaterialiv                ;
+		qglMatrixMode                = 	logMatrixMode                ;
+		qglMultMatrixd               = 	logMultMatrixd               ;
+		qglMultMatrixf               = 	logMultMatrixf               ;
+		qglNewList                   = 	logNewList                   ;
+		qglNormal3b                  = 	logNormal3b                  ;
+		qglNormal3bv                 = 	logNormal3bv                 ;
+		qglNormal3d                  = 	logNormal3d                  ;
+		qglNormal3dv                 = 	logNormal3dv                 ;
+		qglNormal3f                  = 	logNormal3f                  ;
+		qglNormal3fv                 = 	logNormal3fv                 ;
+		qglNormal3i                  = 	logNormal3i                  ;
+		qglNormal3iv                 = 	logNormal3iv                 ;
+		qglNormal3s                  = 	logNormal3s                  ;
+		qglNormal3sv                 = 	logNormal3sv                 ;
+		qglNormalPointer             = 	logNormalPointer             ;
+		qglOrtho                     = 	logOrtho                     ;
+		qglPassThrough               = 	logPassThrough               ;
+		qglPixelMapfv                = 	logPixelMapfv                ;
+		qglPixelMapuiv               = 	logPixelMapuiv               ;
+		qglPixelMapusv               = 	logPixelMapusv               ;
+		qglPixelStoref               = 	logPixelStoref               ;
+		qglPixelStorei               = 	logPixelStorei               ;
+		qglPixelTransferf            = 	logPixelTransferf            ;
+		qglPixelTransferi            = 	logPixelTransferi            ;
+		qglPixelZoom                 = 	logPixelZoom                 ;
+		qglPointSize                 = 	logPointSize                 ;
+		qglPolygonMode               = 	logPolygonMode               ;
+		qglPolygonOffset             = 	logPolygonOffset             ;
+		qglPolygonStipple            = 	logPolygonStipple            ;
+		qglPopAttrib                 = 	logPopAttrib                 ;
+		qglPopClientAttrib           = 	logPopClientAttrib           ;
+		qglPopMatrix                 = 	logPopMatrix                 ;
+		qglPopName                   = 	logPopName                   ;
+		qglPrioritizeTextures        = 	logPrioritizeTextures        ;
+		qglPushAttrib                = 	logPushAttrib                ;
+		qglPushClientAttrib          = 	logPushClientAttrib          ;
+		qglPushMatrix                = 	logPushMatrix                ;
+		qglPushName                  = 	logPushName                  ;
+		qglRasterPos2d               = 	logRasterPos2d               ;
+		qglRasterPos2dv              = 	logRasterPos2dv              ;
+		qglRasterPos2f               = 	logRasterPos2f               ;
+		qglRasterPos2fv              = 	logRasterPos2fv              ;
+		qglRasterPos2i               = 	logRasterPos2i               ;
+		qglRasterPos2iv              = 	logRasterPos2iv              ;
+		qglRasterPos2s               = 	logRasterPos2s               ;
+		qglRasterPos2sv              = 	logRasterPos2sv              ;
+		qglRasterPos3d               = 	logRasterPos3d               ;
+		qglRasterPos3dv              = 	logRasterPos3dv              ;
+		qglRasterPos3f               = 	logRasterPos3f               ;
+		qglRasterPos3fv              = 	logRasterPos3fv              ;
+		qglRasterPos3i               = 	logRasterPos3i               ;
+		qglRasterPos3iv              = 	logRasterPos3iv              ;
+		qglRasterPos3s               = 	logRasterPos3s               ;
+		qglRasterPos3sv              = 	logRasterPos3sv              ;
+		qglRasterPos4d               = 	logRasterPos4d               ;
+		qglRasterPos4dv              = 	logRasterPos4dv              ;
+		qglRasterPos4f               = 	logRasterPos4f               ;
+		qglRasterPos4fv              = 	logRasterPos4fv              ;
+		qglRasterPos4i               = 	logRasterPos4i               ;
+		qglRasterPos4iv              = 	logRasterPos4iv              ;
+		qglRasterPos4s               = 	logRasterPos4s               ;
+		qglRasterPos4sv              = 	logRasterPos4sv              ;
+		qglReadBuffer                = 	logReadBuffer                ;
+		qglReadPixels                = 	logReadPixels                ;
+		qglRectd                     = 	logRectd                     ;
+		qglRectdv                    = 	logRectdv                    ;
+		qglRectf                     = 	logRectf                     ;
+		qglRectfv                    = 	logRectfv                    ;
+		qglRecti                     = 	logRecti                     ;
+		qglRectiv                    = 	logRectiv                    ;
+		qglRects                     = 	logRects                     ;
+		qglRectsv                    = 	logRectsv                    ;
+		qglRenderMode                = 	logRenderMode                ;
+		qglRotated                   = 	logRotated                   ;
+		qglRotatef                   = 	logRotatef                   ;
+		qglScaled                    = 	logScaled                    ;
+		qglScalef                    = 	logScalef                    ;
+		qglScissor                   = 	logScissor                   ;
+		qglSelectBuffer              = 	logSelectBuffer              ;
+		qglShadeModel                = 	logShadeModel                ;
+		qglStencilFunc               = 	logStencilFunc               ;
+		qglStencilMask               = 	logStencilMask               ;
+		qglStencilOp                 = 	logStencilOp                 ;
+		qglTexCoord1d                = 	logTexCoord1d                ;
+		qglTexCoord1dv               = 	logTexCoord1dv               ;
+		qglTexCoord1f                = 	logTexCoord1f                ;
+		qglTexCoord1fv               = 	logTexCoord1fv               ;
+		qglTexCoord1i                = 	logTexCoord1i                ;
+		qglTexCoord1iv               = 	logTexCoord1iv               ;
+		qglTexCoord1s                = 	logTexCoord1s                ;
+		qglTexCoord1sv               = 	logTexCoord1sv               ;
+		qglTexCoord2d                = 	logTexCoord2d                ;
+		qglTexCoord2dv               = 	logTexCoord2dv               ;
+		qglTexCoord2f                = 	logTexCoord2f                ;
+		qglTexCoord2fv               = 	logTexCoord2fv               ;
+		qglTexCoord2i                = 	logTexCoord2i                ;
+		qglTexCoord2iv               = 	logTexCoord2iv               ;
+		qglTexCoord2s                = 	logTexCoord2s                ;
+		qglTexCoord2sv               = 	logTexCoord2sv               ;
+		qglTexCoord3d                = 	logTexCoord3d                ;
+		qglTexCoord3dv               = 	logTexCoord3dv               ;
+		qglTexCoord3f                = 	logTexCoord3f                ;
+		qglTexCoord3fv               = 	logTexCoord3fv               ;
+		qglTexCoord3i                = 	logTexCoord3i                ;
+		qglTexCoord3iv               = 	logTexCoord3iv               ;
+		qglTexCoord3s                = 	logTexCoord3s                ;
+		qglTexCoord3sv               = 	logTexCoord3sv               ;
+		qglTexCoord4d                = 	logTexCoord4d                ;
+		qglTexCoord4dv               = 	logTexCoord4dv               ;
+		qglTexCoord4f                = 	logTexCoord4f                ;
+		qglTexCoord4fv               = 	logTexCoord4fv               ;
+		qglTexCoord4i                = 	logTexCoord4i                ;
+		qglTexCoord4iv               = 	logTexCoord4iv               ;
+		qglTexCoord4s                = 	logTexCoord4s                ;
+		qglTexCoord4sv               = 	logTexCoord4sv               ;
+		qglTexCoordPointer           = 	logTexCoordPointer           ;
+		qglTexEnvf                   = 	logTexEnvf                   ;
+		qglTexEnvfv                  = 	logTexEnvfv                  ;
+		qglTexEnvi                   = 	logTexEnvi                   ;
+		qglTexEnviv                  = 	logTexEnviv                  ;
+		qglTexGend                   = 	logTexGend                   ;
+		qglTexGendv                  = 	logTexGendv                  ;
+		qglTexGenf                   = 	logTexGenf                   ;
+		qglTexGenfv                  = 	logTexGenfv                  ;
+		qglTexGeni                   = 	logTexGeni                   ;
+		qglTexGeniv                  = 	logTexGeniv                  ;
+		qglTexImage1D                = 	logTexImage1D                ;
+		qglTexImage2D                = 	logTexImage2D                ;
+		qglTexParameterf             = 	logTexParameterf             ;
+		qglTexParameterfv            = 	logTexParameterfv            ;
+		qglTexParameteri             = 	logTexParameteri             ;
+		qglTexParameteriv            = 	logTexParameteriv            ;
+		qglTexSubImage1D             = 	logTexSubImage1D             ;
+		qglTexSubImage2D             = 	logTexSubImage2D             ;
+		qglTranslated                = 	logTranslated                ;
+		qglTranslatef                = 	logTranslatef                ;
+		qglVertex2d                  = 	logVertex2d                  ;
+		qglVertex2dv                 = 	logVertex2dv                 ;
+		qglVertex2f                  = 	logVertex2f                  ;
+		qglVertex2fv                 = 	logVertex2fv                 ;
+		qglVertex2i                  = 	logVertex2i                  ;
+		qglVertex2iv                 = 	logVertex2iv                 ;
+		qglVertex2s                  = 	logVertex2s                  ;
+		qglVertex2sv                 = 	logVertex2sv                 ;
+		qglVertex3d                  = 	logVertex3d                  ;
+		qglVertex3dv                 = 	logVertex3dv                 ;
+		qglVertex3f                  = 	logVertex3f                  ;
+		qglVertex3fv                 = 	logVertex3fv                 ;
+		qglVertex3i                  = 	logVertex3i                  ;
+		qglVertex3iv                 = 	logVertex3iv                 ;
+		qglVertex3s                  = 	logVertex3s                  ;
+		qglVertex3sv                 = 	logVertex3sv                 ;
+		qglVertex4d                  = 	logVertex4d                  ;
+		qglVertex4dv                 = 	logVertex4dv                 ;
+		qglVertex4f                  = 	logVertex4f                  ;
+		qglVertex4fv                 = 	logVertex4fv                 ;
+		qglVertex4i                  = 	logVertex4i                  ;
+		qglVertex4iv                 = 	logVertex4iv                 ;
+		qglVertex4s                  = 	logVertex4s                  ;
+		qglVertex4sv                 = 	logVertex4sv                 ;
+		qglVertexPointer             = 	logVertexPointer             ;
+		qglViewport                  = 	logViewport                  ;
+	}
+	else
+	{
+		if ( glw_state.log_fp )	{
+			fprintf( glw_state.log_fp, "*** CLOSING LOG ***\n" );
+			fclose( glw_state.log_fp );
+			glw_state.log_fp = NULL;
+		}
+		qglAccum                     = dllAccum;
+		qglAlphaFunc                 = dllAlphaFunc;
+		qglAreTexturesResident       = dllAreTexturesResident;
+		qglArrayElement              = dllArrayElement;
+		qglBegin                     = dllBegin;
+		qglBindTexture               = dllBindTexture;
+		qglBitmap                    = dllBitmap;
+		qglBlendFunc                 = dllBlendFunc;
+		qglCallList                  = dllCallList;
+		qglCallLists                 = dllCallLists;
+		qglClear                     = dllClear;
+		qglClearAccum                = dllClearAccum;
+		qglClearColor                = dllClearColor;
+		qglClearDepth                = dllClearDepth;
+		qglClearIndex                = dllClearIndex;
+		qglClearStencil              = dllClearStencil;
+		qglClipPlane                 = dllClipPlane;
+		qglColor3b                   = dllColor3b;
+		qglColor3bv                  = dllColor3bv;
+		qglColor3d                   = dllColor3d;
+		qglColor3dv                  = dllColor3dv;
+		qglColor3f                   = dllColor3f;
+		qglColor3fv                  = dllColor3fv;
+		qglColor3i                   = dllColor3i;
+		qglColor3iv                  = dllColor3iv;
+		qglColor3s                   = dllColor3s;
+		qglColor3sv                  = dllColor3sv;
+		qglColor3ub                  = dllColor3ub;
+		qglColor3ubv                 = dllColor3ubv;
+		qglColor3ui                  = dllColor3ui;
+		qglColor3uiv                 = dllColor3uiv;
+		qglColor3us                  = dllColor3us;
+		qglColor3usv                 = dllColor3usv;
+		qglColor4b                   = dllColor4b;
+		qglColor4bv                  = dllColor4bv;
+		qglColor4d                   = dllColor4d;
+		qglColor4dv                  = dllColor4dv;
+		qglColor4f                   = dllColor4f;
+		qglColor4fv                  = dllColor4fv;
+		qglColor4i                   = dllColor4i;
+		qglColor4iv                  = dllColor4iv;
+		qglColor4s                   = dllColor4s;
+		qglColor4sv                  = dllColor4sv;
+		qglColor4ub                  = dllColor4ub;
+		qglColor4ubv                 = dllColor4ubv;
+		qglColor4ui                  = dllColor4ui;
+		qglColor4uiv                 = dllColor4uiv;
+		qglColor4us                  = dllColor4us;
+		qglColor4usv                 = dllColor4usv;
+		qglColorMask                 = dllColorMask;
+		qglColorMaterial             = dllColorMaterial;
+		qglColorPointer              = dllColorPointer;
+		qglCopyPixels                = dllCopyPixels;
+		qglCopyTexImage1D            = dllCopyTexImage1D;
+		qglCopyTexImage2D            = dllCopyTexImage2D;
+		qglCopyTexSubImage1D         = dllCopyTexSubImage1D;
+		qglCopyTexSubImage2D         = dllCopyTexSubImage2D;
+		qglCullFace                  = dllCullFace;
+		qglDeleteLists               = dllDeleteLists ;
+		qglDeleteTextures            = dllDeleteTextures ;
+		qglDepthFunc                 = dllDepthFunc ;
+		qglDepthMask                 = dllDepthMask ;
+		qglDepthRange                = dllDepthRange ;
+		qglDisable                   = dllDisable ;
+		qglDisableClientState        = dllDisableClientState ;
+		qglDrawArrays                = dllDrawArrays ;
+		qglDrawBuffer                = dllDrawBuffer ;
+		qglDrawElements              = dllDrawElements ;
+		qglDrawPixels                = dllDrawPixels ;
+		qglEdgeFlag                  = dllEdgeFlag ;
+		qglEdgeFlagPointer           = dllEdgeFlagPointer ;
+		qglEdgeFlagv                 = dllEdgeFlagv ;
+		qglEnable                    = 	dllEnable                    ;
+		qglEnableClientState         = 	dllEnableClientState         ;
+		qglEnd                       = 	dllEnd                       ;
+		qglEndList                   = 	dllEndList                   ;
+		qglEvalCoord1d				 = 	dllEvalCoord1d				 ;
+		qglEvalCoord1dv              = 	dllEvalCoord1dv              ;
+		qglEvalCoord1f               = 	dllEvalCoord1f               ;
+		qglEvalCoord1fv              = 	dllEvalCoord1fv              ;
+		qglEvalCoord2d               = 	dllEvalCoord2d               ;
+		qglEvalCoord2dv              = 	dllEvalCoord2dv              ;
+		qglEvalCoord2f               = 	dllEvalCoord2f               ;
+		qglEvalCoord2fv              = 	dllEvalCoord2fv              ;
+		qglEvalMesh1                 = 	dllEvalMesh1                 ;
+		qglEvalMesh2                 = 	dllEvalMesh2                 ;
+		qglEvalPoint1                = 	dllEvalPoint1                ;
+		qglEvalPoint2                = 	dllEvalPoint2                ;
+		qglFeedbackBuffer            = 	dllFeedbackBuffer            ;
+		qglFinish                    = 	dllFinish                    ;
+		qglFlush                     = 	dllFlush                     ;
+		qglFogf                      = 	dllFogf                      ;
+		qglFogfv                     = 	dllFogfv                     ;
+		qglFogi                      = 	dllFogi                      ;
+		qglFogiv                     = 	dllFogiv                     ;
+		qglFrontFace                 = 	dllFrontFace                 ;
+		qglFrustum                   = 	dllFrustum                   ;
+		qglGenLists                  = 	dllGenLists                  ;
+		qglGenTextures               = 	dllGenTextures               ;
+		qglGetBooleanv               = 	dllGetBooleanv               ;
+		qglGetClipPlane              = 	dllGetClipPlane              ;
+		qglGetDoublev                = 	dllGetDoublev                ;
+		qglGetError                  = 	dllGetError                  ;
+		qglGetFloatv                 = 	dllGetFloatv                 ;
+		qglGetIntegerv               = 	dllGetIntegerv               ;
+		qglGetLightfv                = 	dllGetLightfv                ;
+		qglGetLightiv                = 	dllGetLightiv                ;
+		qglGetMapdv                  = 	dllGetMapdv                  ;
+		qglGetMapfv                  = 	dllGetMapfv                  ;
+		qglGetMapiv                  = 	dllGetMapiv                  ;
+		qglGetMaterialfv             = 	dllGetMaterialfv             ;
+		qglGetMaterialiv             = 	dllGetMaterialiv             ;
+		qglGetPixelMapfv             = 	dllGetPixelMapfv             ;
+		qglGetPixelMapuiv            = 	dllGetPixelMapuiv            ;
+		qglGetPixelMapusv            = 	dllGetPixelMapusv            ;
+		qglGetPointerv               = 	dllGetPointerv               ;
+		qglGetPolygonStipple         = 	dllGetPolygonStipple         ;
+		qglGetString                 = 	dllGetString                 ;
+		qglGetTexEnvfv               = 	dllGetTexEnvfv               ;
+		qglGetTexEnviv               = 	dllGetTexEnviv               ;
+		qglGetTexGendv               = 	dllGetTexGendv               ;
+		qglGetTexGenfv               = 	dllGetTexGenfv               ;
+		qglGetTexGeniv               = 	dllGetTexGeniv               ;
+		qglGetTexImage               = 	dllGetTexImage               ;
+		qglGetTexLevelParameterfv    = 	dllGetTexLevelParameterfv    ;
+		qglGetTexLevelParameteriv    = 	dllGetTexLevelParameteriv    ;
+		qglGetTexParameterfv         = 	dllGetTexParameterfv         ;
+		qglGetTexParameteriv         = 	dllGetTexParameteriv         ;
+		qglHint                      = 	dllHint                      ;
+		qglIndexMask                 = 	dllIndexMask                 ;
+		qglIndexPointer              = 	dllIndexPointer              ;
+		qglIndexd                    = 	dllIndexd                    ;
+		qglIndexdv                   = 	dllIndexdv                   ;
+		qglIndexf                    = 	dllIndexf                    ;
+		qglIndexfv                   = 	dllIndexfv                   ;
+		qglIndexi                    = 	dllIndexi                    ;
+		qglIndexiv                   = 	dllIndexiv                   ;
+		qglIndexs                    = 	dllIndexs                    ;
+		qglIndexsv                   = 	dllIndexsv                   ;
+		qglIndexub                   = 	dllIndexub                   ;
+		qglIndexubv                  = 	dllIndexubv                  ;
+		qglInitNames                 = 	dllInitNames                 ;
+		qglInterleavedArrays         = 	dllInterleavedArrays         ;
+		qglIsEnabled                 = 	dllIsEnabled                 ;
+		qglIsList                    = 	dllIsList                    ;
+		qglIsTexture                 = 	dllIsTexture                 ;
+		qglLightModelf               = 	dllLightModelf               ;
+		qglLightModelfv              = 	dllLightModelfv              ;
+		qglLightModeli               = 	dllLightModeli               ;
+		qglLightModeliv              = 	dllLightModeliv              ;
+		qglLightf                    = 	dllLightf                    ;
+		qglLightfv                   = 	dllLightfv                   ;
+		qglLighti                    = 	dllLighti                    ;
+		qglLightiv                   = 	dllLightiv                   ;
+		qglLineStipple               = 	dllLineStipple               ;
+		qglLineWidth                 = 	dllLineWidth                 ;
+		qglListBase                  = 	dllListBase                  ;
+		qglLoadIdentity              = 	dllLoadIdentity              ;
+		qglLoadMatrixd               = 	dllLoadMatrixd               ;
+		qglLoadMatrixf               = 	dllLoadMatrixf               ;
+		qglLoadName                  = 	dllLoadName                  ;
+		qglLogicOp                   = 	dllLogicOp                   ;
+		qglMap1d                     = 	dllMap1d                     ;
+		qglMap1f                     = 	dllMap1f                     ;
+		qglMap2d                     = 	dllMap2d                     ;
+		qglMap2f                     = 	dllMap2f                     ;
+		qglMapGrid1d                 = 	dllMapGrid1d                 ;
+		qglMapGrid1f                 = 	dllMapGrid1f                 ;
+		qglMapGrid2d                 = 	dllMapGrid2d                 ;
+		qglMapGrid2f                 = 	dllMapGrid2f                 ;
+		qglMaterialf                 = 	dllMaterialf                 ;
+		qglMaterialfv                = 	dllMaterialfv                ;
+		qglMateriali                 = 	dllMateriali                 ;
+		qglMaterialiv                = 	dllMaterialiv                ;
+		qglMatrixMode                = 	dllMatrixMode                ;
+		qglMultMatrixd               = 	dllMultMatrixd               ;
+		qglMultMatrixf               = 	dllMultMatrixf               ;
+		qglNewList                   = 	dllNewList                   ;
+		qglNormal3b                  = 	dllNormal3b                  ;
+		qglNormal3bv                 = 	dllNormal3bv                 ;
+		qglNormal3d                  = 	dllNormal3d                  ;
+		qglNormal3dv                 = 	dllNormal3dv                 ;
+		qglNormal3f                  = 	dllNormal3f                  ;
+		qglNormal3fv                 = 	dllNormal3fv                 ;
+		qglNormal3i                  = 	dllNormal3i                  ;
+		qglNormal3iv                 = 	dllNormal3iv                 ;
+		qglNormal3s                  = 	dllNormal3s                  ;
+		qglNormal3sv                 = 	dllNormal3sv                 ;
+		qglNormalPointer             = 	dllNormalPointer             ;
+		qglOrtho                     = 	dllOrtho                     ;
+		qglPassThrough               = 	dllPassThrough               ;
+		qglPixelMapfv                = 	dllPixelMapfv                ;
+		qglPixelMapuiv               = 	dllPixelMapuiv               ;
+		qglPixelMapusv               = 	dllPixelMapusv               ;
+		qglPixelStoref               = 	dllPixelStoref               ;
+		qglPixelStorei               = 	dllPixelStorei               ;
+		qglPixelTransferf            = 	dllPixelTransferf            ;
+		qglPixelTransferi            = 	dllPixelTransferi            ;
+		qglPixelZoom                 = 	dllPixelZoom                 ;
+		qglPointSize                 = 	dllPointSize                 ;
+		qglPolygonMode               = 	dllPolygonMode               ;
+		qglPolygonOffset             = 	dllPolygonOffset             ;
+		qglPolygonStipple            = 	dllPolygonStipple            ;
+		qglPopAttrib                 = 	dllPopAttrib                 ;
+		qglPopClientAttrib           = 	dllPopClientAttrib           ;
+		qglPopMatrix                 = 	dllPopMatrix                 ;
+		qglPopName                   = 	dllPopName                   ;
+		qglPrioritizeTextures        = 	dllPrioritizeTextures        ;
+		qglPushAttrib                = 	dllPushAttrib                ;
+		qglPushClientAttrib          = 	dllPushClientAttrib          ;
+		qglPushMatrix                = 	dllPushMatrix                ;
+		qglPushName                  = 	dllPushName                  ;
+		qglRasterPos2d               = 	dllRasterPos2d               ;
+		qglRasterPos2dv              = 	dllRasterPos2dv              ;
+		qglRasterPos2f               = 	dllRasterPos2f               ;
+		qglRasterPos2fv              = 	dllRasterPos2fv              ;
+		qglRasterPos2i               = 	dllRasterPos2i               ;
+		qglRasterPos2iv              = 	dllRasterPos2iv              ;
+		qglRasterPos2s               = 	dllRasterPos2s               ;
+		qglRasterPos2sv              = 	dllRasterPos2sv              ;
+		qglRasterPos3d               = 	dllRasterPos3d               ;
+		qglRasterPos3dv              = 	dllRasterPos3dv              ;
+		qglRasterPos3f               = 	dllRasterPos3f               ;
+		qglRasterPos3fv              = 	dllRasterPos3fv              ;
+		qglRasterPos3i               = 	dllRasterPos3i               ;
+		qglRasterPos3iv              = 	dllRasterPos3iv              ;
+		qglRasterPos3s               = 	dllRasterPos3s               ;
+		qglRasterPos3sv              = 	dllRasterPos3sv              ;
+		qglRasterPos4d               = 	dllRasterPos4d               ;
+		qglRasterPos4dv              = 	dllRasterPos4dv              ;
+		qglRasterPos4f               = 	dllRasterPos4f               ;
+		qglRasterPos4fv              = 	dllRasterPos4fv              ;
+		qglRasterPos4i               = 	dllRasterPos4i               ;
+		qglRasterPos4iv              = 	dllRasterPos4iv              ;
+		qglRasterPos4s               = 	dllRasterPos4s               ;
+		qglRasterPos4sv              = 	dllRasterPos4sv              ;
+		qglReadBuffer                = 	dllReadBuffer                ;
+		qglReadPixels                = 	dllReadPixels                ;
+		qglRectd                     = 	dllRectd                     ;
+		qglRectdv                    = 	dllRectdv                    ;
+		qglRectf                     = 	dllRectf                     ;
+		qglRectfv                    = 	dllRectfv                    ;
+		qglRecti                     = 	dllRecti                     ;
+		qglRectiv                    = 	dllRectiv                    ;
+		qglRects                     = 	dllRects                     ;
+		qglRectsv                    = 	dllRectsv                    ;
+		qglRenderMode                = 	dllRenderMode                ;
+		qglRotated                   = 	dllRotated                   ;
+		qglRotatef                   = 	dllRotatef                   ;
+		qglScaled                    = 	dllScaled                    ;
+		qglScalef                    = 	dllScalef                    ;
+		qglScissor                   = 	dllScissor                   ;
+		qglSelectBuffer              = 	dllSelectBuffer              ;
+		qglShadeModel                = 	dllShadeModel                ;
+		qglStencilFunc               = 	dllStencilFunc               ;
+		qglStencilMask               = 	dllStencilMask               ;
+		qglStencilOp                 = 	dllStencilOp                 ;
+		qglTexCoord1d                = 	dllTexCoord1d                ;
+		qglTexCoord1dv               = 	dllTexCoord1dv               ;
+		qglTexCoord1f                = 	dllTexCoord1f                ;
+		qglTexCoord1fv               = 	dllTexCoord1fv               ;
+		qglTexCoord1i                = 	dllTexCoord1i                ;
+		qglTexCoord1iv               = 	dllTexCoord1iv               ;
+		qglTexCoord1s                = 	dllTexCoord1s                ;
+		qglTexCoord1sv               = 	dllTexCoord1sv               ;
+		qglTexCoord2d                = 	dllTexCoord2d                ;
+		qglTexCoord2dv               = 	dllTexCoord2dv               ;
+		qglTexCoord2f                = 	dllTexCoord2f                ;
+		qglTexCoord2fv               = 	dllTexCoord2fv               ;
+		qglTexCoord2i                = 	dllTexCoord2i                ;
+		qglTexCoord2iv               = 	dllTexCoord2iv               ;
+		qglTexCoord2s                = 	dllTexCoord2s                ;
+		qglTexCoord2sv               = 	dllTexCoord2sv               ;
+		qglTexCoord3d                = 	dllTexCoord3d                ;
+		qglTexCoord3dv               = 	dllTexCoord3dv               ;
+		qglTexCoord3f                = 	dllTexCoord3f                ;
+		qglTexCoord3fv               = 	dllTexCoord3fv               ;
+		qglTexCoord3i                = 	dllTexCoord3i                ;
+		qglTexCoord3iv               = 	dllTexCoord3iv               ;
+		qglTexCoord3s                = 	dllTexCoord3s                ;
+		qglTexCoord3sv               = 	dllTexCoord3sv               ;
+		qglTexCoord4d                = 	dllTexCoord4d                ;
+		qglTexCoord4dv               = 	dllTexCoord4dv               ;
+		qglTexCoord4f                = 	dllTexCoord4f                ;
+		qglTexCoord4fv               = 	dllTexCoord4fv               ;
+		qglTexCoord4i                = 	dllTexCoord4i                ;
+		qglTexCoord4iv               = 	dllTexCoord4iv               ;
+		qglTexCoord4s                = 	dllTexCoord4s                ;
+		qglTexCoord4sv               = 	dllTexCoord4sv               ;
+		qglTexCoordPointer           = 	dllTexCoordPointer           ;
+		qglTexEnvf                   = 	dllTexEnvf                   ;
+		qglTexEnvfv                  = 	dllTexEnvfv                  ;
+		qglTexEnvi                   = 	dllTexEnvi                   ;
+		qglTexEnviv                  = 	dllTexEnviv                  ;
+		qglTexGend                   = 	dllTexGend                   ;
+		qglTexGendv                  = 	dllTexGendv                  ;
+		qglTexGenf                   = 	dllTexGenf                   ;
+		qglTexGenfv                  = 	dllTexGenfv                  ;
+		qglTexGeni                   = 	dllTexGeni                   ;
+		qglTexGeniv                  = 	dllTexGeniv                  ;
+		qglTexImage1D                = 	dllTexImage1D                ;
+		qglTexImage2D                = 	dllTexImage2D                ;
+		qglTexParameterf             = 	dllTexParameterf             ;
+		qglTexParameterfv            = 	dllTexParameterfv            ;
+		qglTexParameteri             = 	dllTexParameteri             ;
+		qglTexParameteriv            = 	dllTexParameteriv            ;
+		qglTexSubImage1D             = 	dllTexSubImage1D             ;
+		qglTexSubImage2D             = 	dllTexSubImage2D             ;
+		qglTranslated                = 	dllTranslated                ;
+		qglTranslatef                = 	dllTranslatef                ;
+		qglVertex2d                  = 	dllVertex2d                  ;
+		qglVertex2dv                 = 	dllVertex2dv                 ;
+		qglVertex2f                  = 	dllVertex2f                  ;
+		qglVertex2fv                 = 	dllVertex2fv                 ;
+		qglVertex2i                  = 	dllVertex2i                  ;
+		qglVertex2iv                 = 	dllVertex2iv                 ;
+		qglVertex2s                  = 	dllVertex2s                  ;
+		qglVertex2sv                 = 	dllVertex2sv                 ;
+		qglVertex3d                  = 	dllVertex3d                  ;
+		qglVertex3dv                 = 	dllVertex3dv                 ;
+		qglVertex3f                  = 	dllVertex3f                  ;
+		qglVertex3fv                 = 	dllVertex3fv                 ;
+		qglVertex3i                  = 	dllVertex3i                  ;
+		qglVertex3iv                 = 	dllVertex3iv                 ;
+		qglVertex3s                  = 	dllVertex3s                  ;
+		qglVertex3sv                 = 	dllVertex3sv                 ;
+		qglVertex4d                  = 	dllVertex4d                  ;
+		qglVertex4dv                 = 	dllVertex4dv                 ;
+		qglVertex4f                  = 	dllVertex4f                  ;
+		qglVertex4fv                 = 	dllVertex4fv                 ;
+		qglVertex4i                  = 	dllVertex4i                  ;
+		qglVertex4iv                 = 	dllVertex4iv                 ;
+		qglVertex4s                  = 	dllVertex4s                  ;
+		qglVertex4sv                 = 	dllVertex4sv                 ;
+		qglVertexPointer             = 	dllVertexPointer             ;
+		qglViewport                  = 	dllViewport                  ;
+	}
+}
+
+#pragma warning (default : 4113 4133 4047 )
+
+
+
diff --git a/code/win32/win_qgl_dx8.cpp b/code/win32/win_qgl_dx8.cpp
new file mode 100644
index 0000000..b59911d
--- /dev/null
+++ b/code/win32/win_qgl_dx8.cpp
@@ -0,0 +1,6680 @@
+
+/*
+ * UNPUBLISHED -- Rights  reserved  under  the  copyright  laws  of the 
+ * United States.  Use  of a copyright notice is precautionary only and 
+ * does not imply publication or disclosure.                            
+ *                                                                      
+ * THIS DOCUMENTATION CONTAINS CONFIDENTIAL AND PROPRIETARY INFORMATION 
+ * OF    VICARIOUS   VISIONS,  INC.    ANY  DUPLICATION,  MODIFICATION, 
+ * DISTRIBUTION, OR DISCLOSURE IS STRICTLY PROHIBITED WITHOUT THE PRIOR 
+ * EXPRESS WRITTEN PERMISSION OF VICARIOUS VISIONS, INC.
+ */
+
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+
+/*
+** QGL_WIN.C
+**
+** This file implements the operating system binding of GL to QGL function
+** pointers.  When doing a port of Quake3 you must implement the following
+** two functions:
+**
+** QGL_Init() - loads libraries, assigns function pointers, etc.
+** QGL_Shutdown() - unloads libraries, NULLs function pointers
+*/
+#include <float.h>
+#include "../renderer/tr_local.h"
+#include "glw_win_dx8.h"
+#include "win_local.h"
+
+#ifdef _XBOX
+#include <xgraphics.h>
+//#include "win_flareeffect.h"
+#include "win_lighteffects.h"
+#include "win_highdynamicrange.h"
+
+#ifndef FINAL_BUILD
+#include <d3d8perf.h>
+#endif
+
+#endif
+
+#include <vector>
+
+extern void Z_SetNewDeleteTemporary(bool);
+
+#define GLW_USE_TRI_STRIPS 1
+
+#ifdef _XBOX
+#define GLW_MAX_DRAW_PACKET_SIZE 2040
+#else
+#define GLW_MAX_DRAW_PACKET_SIZE (SHADER_MAX_VERTEXES*12)
+#endif
+
+#define MEMORY_PROFILE 1
+
+int texMemSize = 0;
+
+#if MEMORY_PROFILE
+ 
+static int getTexMemSize(IDirect3DTexture8* mipmap)
+{
+	int levels = mipmap->GetLevelCount();
+	int size = 0;
+	while (levels--)
+	{ 
+		D3DSURFACE_DESC desc;
+		mipmap->GetLevelDesc(levels, &desc);
+		size += desc.Size;
+	}
+	return size;
+}
+#endif
+
+void QGL_EnableLogging( qboolean enable );
+
+void ( * qglAccum )(GLenum op, GLfloat value);
+void ( * qglAlphaFunc )(GLenum func, GLclampf ref);
+GLboolean ( * qglAreTexturesResident )(GLsizei n, const GLuint *textures, GLboolean *residences);
+void ( * qglArrayElement )(GLint i);
+void ( * qglBegin )(GLenum mode);
+void ( * qglBeginEXT )(GLenum mode, GLint verts, GLint colors, GLint normals, GLint tex0, GLint tex1);//, GLint tex2, GLint tex3);
+GLboolean ( * qglBeginFrame )(void);
+void ( * qglBeginShadow )(void);
+void ( * qglBindTexture )(GLenum target, GLuint texture);
+void ( * qglBitmap )(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap);
+void ( * qglBlendFunc )(GLenum sfactor, GLenum dfactor);
+void ( * qglCallList )(GLuint lnum);
+void ( * qglCallLists )(GLsizei n, GLenum type, const GLvoid *lists);
+void ( * qglClear )(GLbitfield mask);
+void ( * qglClearAccum )(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
+void ( * qglClearColor )(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
+void ( * qglClearDepth )(GLclampd depth);
+void ( * qglClearIndex )(GLfloat c);
+void ( * qglClearStencil )(GLint s);
+void ( * qglClipPlane )(GLenum plane, const GLdouble *equation);
+void ( * qglColor3b )(GLbyte red, GLbyte green, GLbyte blue);
+void ( * qglColor3bv )(const GLbyte *v);
+void ( * qglColor3d )(GLdouble red, GLdouble green, GLdouble blue);
+void ( * qglColor3dv )(const GLdouble *v);
+void ( * qglColor3f )(GLfloat red, GLfloat green, GLfloat blue);
+void ( * qglColor3fv )(const GLfloat *v);
+void ( * qglColor3i )(GLint red, GLint green, GLint blue);
+void ( * qglColor3iv )(const GLint *v);
+void ( * qglColor3s )(GLshort red, GLshort green, GLshort blue);
+void ( * qglColor3sv )(const GLshort *v);
+void ( * qglColor3ub )(GLubyte red, GLubyte green, GLubyte blue);
+void ( * qglColor3ubv )(const GLubyte *v);
+void ( * qglColor3ui )(GLuint red, GLuint green, GLuint blue);
+void ( * qglColor3uiv )(const GLuint *v);
+void ( * qglColor3us )(GLushort red, GLushort green, GLushort blue);
+void ( * qglColor3usv )(const GLushort *v);
+void ( * qglColor4b )(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha);
+void ( * qglColor4bv )(const GLbyte *v);
+void ( * qglColor4d )(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha);
+void ( * qglColor4dv )(const GLdouble *v);
+void ( * qglColor4f )(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
+void ( * qglColor4fv )(const GLfloat *v);
+void ( * qglColor4i )(GLint red, GLint green, GLint blue, GLint alpha);
+void ( * qglColor4iv )(const GLint *v);
+void ( * qglColor4s )(GLshort red, GLshort green, GLshort blue, GLshort alpha);
+void ( * qglColor4sv )(const GLshort *v);
+void ( * qglColor4ub )(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha);
+void ( * qglColor4ubv )(const GLubyte *v);
+void ( * qglColor4ui )(GLuint red, GLuint green, GLuint blue, GLuint alpha);
+void ( * qglColor4uiv )(const GLuint *v);
+void ( * qglColor4us )(GLushort red, GLushort green, GLushort blue, GLushort alpha);
+void ( * qglColor4usv )(const GLushort *v);
+void ( * qglColorMask )(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
+void ( * qglColorMaterial )(GLenum face, GLenum mode);
+void ( * qglColorPointer )(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
+void ( * qglCopyPixels )(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type);
+void ( * qglCopyTexImage1D )(GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border);
+void ( * qglCopyTexImage2D )(GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
+void ( * qglCopyTexSubImage1D )(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);
+void ( * qglCopyTexSubImage2D )(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
+void ( * qglCullFace )(GLenum mode);
+void ( * qglDeleteLists )(GLuint lnum, GLsizei range);
+void ( * qglDeleteTextures )(GLsizei n, const GLuint *textures);
+void ( * qglDepthFunc )(GLenum func);
+void ( * qglDepthMask )(GLboolean flag);
+void ( * qglDepthRange )(GLclampd zNear, GLclampd zFar);
+void ( * qglDisable )(GLenum cap);
+void ( * qglDisableClientState )(GLenum array);
+void ( * qglDrawArrays )(GLenum mode, GLint first, GLsizei count);
+void ( * qglDrawBuffer )(GLenum mode);
+void ( * qglDrawElements )(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices);
+void ( * qglDrawPixels )(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
+void ( * qglEdgeFlag )(GLboolean flag);
+void ( * qglEdgeFlagPointer )(GLsizei stride, const GLvoid *pointer);
+void ( * qglEdgeFlagv )(const GLboolean *flag);
+void ( * qglEnable )(GLenum cap);
+void ( * qglEnableClientState )(GLenum array);
+void ( * qglEnd )(void);
+void ( * qglEndFrame )(void);
+void ( * qglEndShadow )(void);
+void ( * qglEndList )(void);
+void ( * qglEvalCoord1d )(GLdouble u);
+void ( * qglEvalCoord1dv )(const GLdouble *u);
+void ( * qglEvalCoord1f )(GLfloat u);
+void ( * qglEvalCoord1fv )(const GLfloat *u);
+void ( * qglEvalCoord2d )(GLdouble u, GLdouble v);
+void ( * qglEvalCoord2dv )(const GLdouble *u);
+void ( * qglEvalCoord2f )(GLfloat u, GLfloat v);
+void ( * qglEvalCoord2fv )(const GLfloat *u);
+void ( * qglEvalMesh1 )(GLenum mode, GLint i1, GLint i2);
+void ( * qglEvalMesh2 )(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2);
+void ( * qglEvalPoint1 )(GLint i);
+void ( * qglEvalPoint2 )(GLint i, GLint j);
+void ( * qglFeedbackBuffer )(GLsizei size, GLenum type, GLfloat *buffer);
+void ( * qglFinish )(void);
+void ( * qglFlush )(void);
+void ( * qglFlushShadow )(void);
+void ( * qglFogf )(GLenum pname, GLfloat param);
+void ( * qglFogfv )(GLenum pname, const GLfloat *params);
+void ( * qglFogi )(GLenum pname, GLint param);
+void ( * qglFogiv )(GLenum pname, const GLint *params);
+void ( * qglFrontFace )(GLenum mode);
+void ( * qglFrustum )(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
+GLuint ( * qglGenLists )(GLsizei range);
+void ( * qglGenTextures )(GLsizei n, GLuint *textures);
+void ( * qglGetBooleanv )(GLenum pname, GLboolean *params);
+void ( * qglGetClipPlane )(GLenum plane, GLdouble *equation);
+void ( * qglGetDoublev )(GLenum pname, GLdouble *params);
+GLenum ( * qglGetError )(void);
+void ( * qglGetFloatv )(GLenum pname, GLfloat *params);
+void ( * qglGetIntegerv )(GLenum pname, GLint *params);
+void ( * qglGetLightfv )(GLenum light, GLenum pname, GLfloat *params);
+void ( * qglGetLightiv )(GLenum light, GLenum pname, GLint *params);
+void ( * qglGetMapdv )(GLenum target, GLenum query, GLdouble *v);
+void ( * qglGetMapfv )(GLenum target, GLenum query, GLfloat *v);
+void ( * qglGetMapiv )(GLenum target, GLenum query, GLint *v);
+void ( * qglGetMaterialfv )(GLenum face, GLenum pname, GLfloat *params);
+void ( * qglGetMaterialiv )(GLenum face, GLenum pname, GLint *params);
+void ( * qglGetPixelMapfv )(GLenum gmap, GLfloat *values);
+void ( * qglGetPixelMapuiv )(GLenum gmap, GLuint *values);
+void ( * qglGetPixelMapusv )(GLenum gmap, GLushort *values);
+void ( * qglGetPointerv )(GLenum pname, GLvoid* *params);
+void ( * qglGetPolygonStipple )(GLubyte *mask);
+const GLubyte * ( * qglGetString )(GLenum name);
+void ( * qglGetTexEnvfv )(GLenum target, GLenum pname, GLfloat *params);
+void ( * qglGetTexEnviv )(GLenum target, GLenum pname, GLint *params);
+void ( * qglGetTexGendv )(GLenum coord, GLenum pname, GLdouble *params);
+void ( * qglGetTexGenfv )(GLenum coord, GLenum pname, GLfloat *params);
+void ( * qglGetTexGeniv )(GLenum coord, GLenum pname, GLint *params);
+void ( * qglGetTexImage )(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels);
+void ( * qglGetTexLevelParameterfv )(GLenum target, GLint level, GLenum pname, GLfloat *params);
+void ( * qglGetTexLevelParameteriv )(GLenum target, GLint level, GLenum pname, GLint *params);
+void ( * qglGetTexParameterfv )(GLenum target, GLenum pname, GLfloat *params);
+void ( * qglGetTexParameteriv )(GLenum target, GLenum pname, GLint *params);
+void ( * qglHint )(GLenum target, GLenum mode);
+void ( * qglIndexedTriToStrip )(GLsizei count, const GLushort *indices);
+void ( * qglIndexMask )(GLuint mask);
+void ( * qglIndexPointer )(GLenum type, GLsizei stride, const GLvoid *pointer);
+void ( * qglIndexd )(GLdouble c);
+void ( * qglIndexdv )(const GLdouble *c);
+void ( * qglIndexf )(GLfloat c);
+void ( * qglIndexfv )(const GLfloat *c);
+void ( * qglIndexi )(GLint c);
+void ( * qglIndexiv )(const GLint *c);
+void ( * qglIndexs )(GLshort c);
+void ( * qglIndexsv )(const GLshort *c);
+void ( * qglIndexub )(GLubyte c);
+void ( * qglIndexubv )(const GLubyte *c);
+void ( * qglInitNames )(void);
+void ( * qglInterleavedArrays )(GLenum format, GLsizei stride, const GLvoid *pointer);
+GLboolean ( * qglIsEnabled )(GLenum cap);
+GLboolean ( * qglIsList )(GLuint lnum);
+GLboolean ( * qglIsTexture )(GLuint texture);
+void ( * qglLightModelf )(GLenum pname, GLfloat param);
+void ( * qglLightModelfv )(GLenum pname, const GLfloat *params);
+void ( * qglLightModeli )(GLenum pname, GLint param);
+void ( * qglLightModeliv )(GLenum pname, const GLint *params);
+void ( * qglLightf )(GLenum light, GLenum pname, GLfloat param);
+void ( * qglLightfv )(GLenum light, GLenum pname, const GLfloat *params);
+void ( * qglLighti )(GLenum light, GLenum pname, GLint param);
+void ( * qglLightiv )(GLenum light, GLenum pname, const GLint *params);
+void ( * qglLineStipple )(GLint factor, GLushort pattern);
+void ( * qglLineWidth )(GLfloat width);
+void ( * qglListBase )(GLuint base);
+void ( * qglLoadIdentity )(void);
+void ( * qglLoadMatrixd )(const GLdouble *m);
+void ( * qglLoadMatrixf )(const GLfloat *m);
+void ( * qglLoadName )(GLuint name);
+void ( * qglLogicOp )(GLenum opcode);
+void ( * qglMap1d )(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points);
+void ( * qglMap1f )(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points);
+void ( * qglMap2d )(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points);
+void ( * qglMap2f )(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points);
+void ( * qglMapGrid1d )(GLint un, GLdouble u1, GLdouble u2);
+void ( * qglMapGrid1f )(GLint un, GLfloat u1, GLfloat u2);
+void ( * qglMapGrid2d )(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2);
+void ( * qglMapGrid2f )(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2);
+void ( * qglMaterialf )(GLenum face, GLenum pname, GLfloat param);
+void ( * qglMaterialfv )(GLenum face, GLenum pname, const GLfloat *params);
+void ( * qglMateriali )(GLenum face, GLenum pname, GLint param);
+void ( * qglMaterialiv )(GLenum face, GLenum pname, const GLint *params);
+void ( * qglMatrixMode )(GLenum mode);
+void ( * qglMultMatrixd )(const GLdouble *m);
+void ( * qglMultMatrixf )(const GLfloat *m);
+void ( * qglNewList )(GLuint lnum, GLenum mode);
+void ( * qglNormal3b )(GLbyte nx, GLbyte ny, GLbyte nz);
+void ( * qglNormal3bv )(const GLbyte *v);
+void ( * qglNormal3d )(GLdouble nx, GLdouble ny, GLdouble nz);
+void ( * qglNormal3dv )(const GLdouble *v);
+void ( * qglNormal3f )(GLfloat nx, GLfloat ny, GLfloat nz);
+void ( * qglNormal3fv )(const GLfloat *v);
+void ( * qglNormal3i )(GLint nx, GLint ny, GLint nz);
+void ( * qglNormal3iv )(const GLint *v);
+void ( * qglNormal3s )(GLshort nx, GLshort ny, GLshort nz);
+void ( * qglNormal3sv )(const GLshort *v);
+void ( * qglNormalPointer )(GLenum type, GLsizei stride, const GLvoid *pointer);
+void ( * qglOrtho )(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
+void ( * qglPassThrough )(GLfloat token);
+void ( * qglPixelMapfv )(GLenum gmap, GLsizei mapsize, const GLfloat *values);
+void ( * qglPixelMapuiv )(GLenum gmap, GLsizei mapsize, const GLuint *values);
+void ( * qglPixelMapusv )(GLenum gmap, GLsizei mapsize, const GLushort *values);
+void ( * qglPixelStoref )(GLenum pname, GLfloat param);
+void ( * qglPixelStorei )(GLenum pname, GLint param);
+void ( * qglPixelTransferf )(GLenum pname, GLfloat param);
+void ( * qglPixelTransferi )(GLenum pname, GLint param);
+void ( * qglPixelZoom )(GLfloat xfactor, GLfloat yfactor);
+void ( * qglPointSize )(GLfloat size);
+void ( * qglPolygonMode )(GLenum face, GLenum mode);
+void ( * qglPolygonOffset )(GLfloat factor, GLfloat units);
+void ( * qglPolygonStipple )(const GLubyte *mask);
+void ( * qglPopAttrib )(void);
+void ( * qglPopClientAttrib )(void);
+void ( * qglPopMatrix )(void);
+void ( * qglPopName )(void);
+void ( * qglPrioritizeTextures )(GLsizei n, const GLuint *textures, const GLclampf *priorities);
+void ( * qglPushAttrib )(GLbitfield mask);
+void ( * qglPushClientAttrib )(GLbitfield mask);
+void ( * qglPushMatrix )(void);
+void ( * qglPushName )(GLuint name);
+void ( * qglRasterPos2d )(GLdouble x, GLdouble y);
+void ( * qglRasterPos2dv )(const GLdouble *v);
+void ( * qglRasterPos2f )(GLfloat x, GLfloat y);
+void ( * qglRasterPos2fv )(const GLfloat *v);
+void ( * qglRasterPos2i )(GLint x, GLint y);
+void ( * qglRasterPos2iv )(const GLint *v);
+void ( * qglRasterPos2s )(GLshort x, GLshort y);
+void ( * qglRasterPos2sv )(const GLshort *v);
+void ( * qglRasterPos3d )(GLdouble x, GLdouble y, GLdouble z);
+void ( * qglRasterPos3dv )(const GLdouble *v);
+void ( * qglRasterPos3f )(GLfloat x, GLfloat y, GLfloat z);
+void ( * qglRasterPos3fv )(const GLfloat *v);
+void ( * qglRasterPos3i )(GLint x, GLint y, GLint z);
+void ( * qglRasterPos3iv )(const GLint *v);
+void ( * qglRasterPos3s )(GLshort x, GLshort y, GLshort z);
+void ( * qglRasterPos3sv )(const GLshort *v);
+void ( * qglRasterPos4d )(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+void ( * qglRasterPos4dv )(const GLdouble *v);
+void ( * qglRasterPos4f )(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+void ( * qglRasterPos4fv )(const GLfloat *v);
+void ( * qglRasterPos4i )(GLint x, GLint y, GLint z, GLint w);
+void ( * qglRasterPos4iv )(const GLint *v);
+void ( * qglRasterPos4s )(GLshort x, GLshort y, GLshort z, GLshort w);
+void ( * qglRasterPos4sv )(const GLshort *v);
+void ( * qglReadBuffer )(GLenum mode);
+//void ( * qglReadPixels )(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei twidth, GLsizei theight, GLvoid *pixels);
+void ( * qglReadPixels )(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels);
+void ( * qglCopyBackBufferToTexEXT ) (float width, float height, float u1, float v1, float u2, float v2);
+void ( * qglCopyBackBufferToTex ) (void);
+void ( * qglRectd )(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2);
+void ( * qglRectdv )(const GLdouble *v1, const GLdouble *v2);
+void ( * qglRectf )(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2);
+void ( * qglRectfv )(const GLfloat *v1, const GLfloat *v2);
+void ( * qglRecti )(GLint x1, GLint y1, GLint x2, GLint y2);
+void ( * qglRectiv )(const GLint *v1, const GLint *v2);
+void ( * qglRects )(GLshort x1, GLshort y1, GLshort x2, GLshort y2);
+void ( * qglRectsv )(const GLshort *v1, const GLshort *v2);
+GLint ( * qglRenderMode )(GLenum mode);
+void ( * qglRotated )(GLdouble angle, GLdouble x, GLdouble y, GLdouble z);
+void ( * qglRotatef )(GLfloat angle, GLfloat x, GLfloat y, GLfloat z);
+void ( * qglScaled )(GLdouble x, GLdouble y, GLdouble z);
+void ( * qglScalef )(GLfloat x, GLfloat y, GLfloat z);
+void ( * qglScissor )(GLint x, GLint y, GLsizei width, GLsizei height);
+void ( * qglSelectBuffer )(GLsizei size, GLuint *buffer);
+void ( * qglShadeModel )(GLenum mode);
+void ( * qglStencilFunc )(GLenum func, GLint ref, GLuint mask);
+void ( * qglStencilMask )(GLuint mask);
+void ( * qglStencilOp )(GLenum fail, GLenum zfail, GLenum zpass);
+void ( * qglTexCoord1d )(GLdouble s);
+void ( * qglTexCoord1dv )(const GLdouble *v);
+void ( * qglTexCoord1f )(GLfloat s);
+void ( * qglTexCoord1fv )(const GLfloat *v);
+void ( * qglTexCoord1i )(GLint s);
+void ( * qglTexCoord1iv )(const GLint *v);
+void ( * qglTexCoord1s )(GLshort s);
+void ( * qglTexCoord1sv )(const GLshort *v);
+void ( * qglTexCoord2d )(GLdouble s, GLdouble t);
+void ( * qglTexCoord2dv )(const GLdouble *v);
+void ( * qglTexCoord2f )(GLfloat s, GLfloat t);
+void ( * qglTexCoord2fv )(const GLfloat *v);
+void ( * qglTexCoord2i )(GLint s, GLint t);
+void ( * qglTexCoord2iv )(const GLint *v);
+void ( * qglTexCoord2s )(GLshort s, GLshort t);
+void ( * qglTexCoord2sv )(const GLshort *v);
+void ( * qglTexCoord3d )(GLdouble s, GLdouble t, GLdouble r);
+void ( * qglTexCoord3dv )(const GLdouble *v);
+void ( * qglTexCoord3f )(GLfloat s, GLfloat t, GLfloat r);
+void ( * qglTexCoord3fv )(const GLfloat *v);
+void ( * qglTexCoord3i )(GLint s, GLint t, GLint r);
+void ( * qglTexCoord3iv )(const GLint *v);
+void ( * qglTexCoord3s )(GLshort s, GLshort t, GLshort r);
+void ( * qglTexCoord3sv )(const GLshort *v);
+void ( * qglTexCoord4d )(GLdouble s, GLdouble t, GLdouble r, GLdouble q);
+void ( * qglTexCoord4dv )(const GLdouble *v);
+void ( * qglTexCoord4f )(GLfloat s, GLfloat t, GLfloat r, GLfloat q);
+void ( * qglTexCoord4fv )(const GLfloat *v);
+void ( * qglTexCoord4i )(GLint s, GLint t, GLint r, GLint q);
+void ( * qglTexCoord4iv )(const GLint *v);
+void ( * qglTexCoord4s )(GLshort s, GLshort t, GLshort r, GLshort q);
+void ( * qglTexCoord4sv )(const GLshort *v);
+void ( * qglTexCoordPointer )(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
+void ( * qglTexEnvf )(GLenum target, GLenum pname, GLfloat param);
+void ( * qglTexEnvfv )(GLenum target, GLenum pname, const GLfloat *params);
+void ( * qglTexEnvi )(GLenum target, GLenum pname, GLint param);
+void ( * qglTexEnviv )(GLenum target, GLenum pname, const GLint *params);
+void ( * qglTexGend )(GLenum coord, GLenum pname, GLdouble param);
+void ( * qglTexGendv )(GLenum coord, GLenum pname, const GLdouble *params);
+void ( * qglTexGenf )(GLenum coord, GLenum pname, GLfloat param);
+void ( * qglTexGenfv )(GLenum coord, GLenum pname, const GLfloat *params);
+void ( * qglTexGeni )(GLenum coord, GLenum pname, GLint param);
+void ( * qglTexGeniv )(GLenum coord, GLenum pname, const GLint *params);
+void ( * qglTexImage1D )(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
+void ( * qglTexImage2D )(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
+void ( * qglTexImage2DEXT )(GLenum target, GLint level, GLint numlevels, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
+void ( * qglTexParameterf )(GLenum target, GLenum pname, GLfloat param);
+void ( * qglTexParameterfv )(GLenum target, GLenum pname, const GLfloat *params);
+void ( * qglTexParameteri )(GLenum target, GLenum pname, GLint param);
+void ( * qglTexParameteriv )(GLenum target, GLenum pname, const GLint *params);
+void ( * qglTexSubImage1D )(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels);
+void ( * qglTexSubImage2D )(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
+void ( * qglTranslated )(GLdouble x, GLdouble y, GLdouble z);
+void ( * qglTranslatef )(GLfloat x, GLfloat y, GLfloat z);
+void ( * qglVertex2d )(GLdouble x, GLdouble y);
+void ( * qglVertex2dv )(const GLdouble *v);
+void ( * qglVertex2f )(GLfloat x, GLfloat y);
+void ( * qglVertex2fv )(const GLfloat *v);
+void ( * qglVertex2i )(GLint x, GLint y);
+void ( * qglVertex2iv )(const GLint *v);
+void ( * qglVertex2s )(GLshort x, GLshort y);
+void ( * qglVertex2sv )(const GLshort *v);
+void ( * qglVertex3d )(GLdouble x, GLdouble y, GLdouble z);
+void ( * qglVertex3dv )(const GLdouble *v);
+void ( * qglVertex3f )(GLfloat x, GLfloat y, GLfloat z);
+void ( * qglVertex3fv )(const GLfloat *v);
+void ( * qglVertex3i )(GLint x, GLint y, GLint z);
+void ( * qglVertex3iv )(const GLint *v);
+void ( * qglVertex3s )(GLshort x, GLshort y, GLshort z);
+void ( * qglVertex3sv )(const GLshort *v);
+void ( * qglVertex4d )(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+void ( * qglVertex4dv )(const GLdouble *v);
+void ( * qglVertex4f )(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+void ( * qglVertex4fv )(const GLfloat *v);
+void ( * qglVertex4i )(GLint x, GLint y, GLint z, GLint w);
+void ( * qglVertex4iv )(const GLint *v);
+void ( * qglVertex4s )(GLshort x, GLshort y, GLshort z, GLshort w);
+void ( * qglVertex4sv )(const GLshort *v);
+void ( * qglVertexPointer )(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
+void ( * qglViewport )(GLint x, GLint y, GLsizei width, GLsizei height);
+
+#if 0
+void ( * qglMultiTexCoord2fARB )( GLenum texture, GLfloat s, GLfloat t );
+void ( * qglActiveTextureARB )( GLenum texture );
+void ( * qglClientActiveTextureARB )( GLenum texture );
+#endif
+
+
+#ifdef _WINDOWS
+static bool surfaceToBMP(LPDIRECT3DDEVICE8 pd3dDevice, LPDIRECT3DSURFACE8 lpSurface, const char *fname)
+{
+	DWORD outpixel;
+	BITMAPFILEHEADER fh;
+	BITMAPINFOHEADER bi;
+	int outbyte, BufferIndex, width, height, pitch;
+	char *WriteBuffer;
+	FILE *file;
+	HRESULT Error;
+	IDirect3DSurface8 *pTempSurf = NULL;
+
+	// Get the surface description first
+	D3DSURFACE_DESC ddsd;
+	D3DLOCKED_RECT lrSurf;
+	
+	Error = lpSurface->GetDesc(&ddsd);
+	// This writes out 32 bit values, so whatever surface format we were passed in,
+	// copy it into a 32 bit surface
+	Error = pd3dDevice->CreateImageSurface(ddsd.Width, ddsd.Height, D3DFMT_A8R8G8B8, &pTempSurf);
+
+	Error = D3DXLoadSurfaceFromSurface(pTempSurf, NULL, NULL, lpSurface, NULL, NULL, D3DX_DEFAULT, 0);
+
+	file = fopen(fname, "wb");
+	if(!file)
+		return FALSE;
+
+	Error = pTempSurf->LockRect(&lrSurf, NULL, 0);
+
+	BufferIndex = 0;
+	width = ddsd.Width;
+	height = ddsd.Height;
+	pitch = lrSurf.Pitch;
+	WriteBuffer = new char[width * height * 3];
+
+	// Setup the file headers
+	((char*)&(fh.bfType))[0] = 'B';
+	((char*)&(fh.bfType))[1] = 'M';
+	fh.bfSize = (long)(sizeof(BITMAPINFOHEADER) + sizeof(BITMAPFILEHEADER) + width * height * 3);
+	fh.bfReserved1 = 0;
+	fh.bfReserved2 = 0;
+	fh.bfOffBits = sizeof(BITMAPINFOHEADER) + sizeof(BITMAPFILEHEADER);
+	bi.biSize = sizeof(BITMAPINFOHEADER);
+	bi.biWidth = width;
+	bi.biHeight = height;
+	bi.biPlanes = 1;
+	bi.biBitCount = 24;
+	bi.biCompression = BI_RGB;
+	bi.biSizeImage = 0;
+	bi.biXPelsPerMeter = 10000;
+	bi.biYPelsPerMeter = 10000;
+	bi.biClrUsed = 0;
+	bi.biClrImportant = 0;
+
+	fwrite(&fh, sizeof(BITMAPFILEHEADER), 1, file);
+	fwrite(&bi, sizeof(BITMAPINFOHEADER), 1, file);
+
+	char *Bitmap_in = (char*)lrSurf.pBits;
+
+	for(int y = height - 1; y >= 0; y--) 
+	{
+		for(int x = 0; x < width; x++)
+		{
+			outpixel = *((DWORD *)(Bitmap_in + x * 4 + y * pitch)); //Load a word
+
+			//Load up the Blue component and output it
+			outbyte = (((outpixel)&0x000000ff));//blue
+			WriteBuffer [BufferIndex++] = outbyte;
+
+			//Load up the green component and output it 
+			outbyte = (((outpixel>>8)&0x000000ff)); 
+			WriteBuffer [BufferIndex++] = outbyte;
+
+			//Load up the red component and output it 
+			outbyte = (((outpixel>>16)&0x000000ff));
+			WriteBuffer [BufferIndex++] = outbyte;
+		}
+	}
+
+	//At this point the buffer should be full, so just write it out
+	fwrite(WriteBuffer, BufferIndex, 1, file);
+
+	//Now unlock the surface and we're done
+	pTempSurf->UnlockRect();
+	pTempSurf->Release();
+
+	fclose(file);
+
+	delete [] WriteBuffer;
+	return true;
+}
+#endif
+
+/*
+=================
+_fixupScreenCoords
+
+Clamp coords to screen dimensions and fix Y direction.
+=================
+*/
+static void _fixupScreenCoords(GLint& x, GLint& y, GLsizei& width, GLsizei& height)
+{
+	if (x < 0) x = 0;
+	else if (x > glConfig.vidWidth) x = glConfig.vidWidth;
+	if (y < 0)
+	{
+		
+#ifdef _XBOX
+		height += y;
+#endif
+		y = 0;
+	}
+	else if (y > glConfig.vidHeight) y = glConfig.vidHeight;
+	
+	if (width < 0) width = 0;
+#ifdef _XBOX
+	else if (x + width > glConfig.vidWidth) width = glConfig.vidWidth - x;
+#endif
+//	else if (x + width > glConfig.vidWidth) width = glConfig.vidWidth - x;
+	if (height < 0) height = 0;
+	else if (y + height > glConfig.vidHeight) height = glConfig.vidHeight - y;
+
+	// GL and DX disagree on the direction of Y
+	y = glConfig.vidHeight - (y + height);
+}
+
+
+/*
+=================
+_convertCompare
+
+Convert GL compare function to DX function.
+=================
+*/
+static D3DCMPFUNC _convertCompare(GLenum func)
+{
+	switch (func)
+	{
+	case GL_NEVER: return D3DCMP_NEVER;
+	case GL_LESS: return D3DCMP_LESS;
+	case GL_EQUAL: return D3DCMP_EQUAL;
+	case GL_LEQUAL: return D3DCMP_LESSEQUAL;
+	case GL_GREATER: return D3DCMP_GREATER;
+	case GL_NOTEQUAL: return D3DCMP_NOTEQUAL;
+	case GL_GEQUAL: return D3DCMP_GREATEREQUAL;
+	default: case GL_ALWAYS: return D3DCMP_ALWAYS;
+	}
+}
+
+
+/*
+=================
+_convertBlendFactor
+
+Convert GL blend mode to DX blend mode.
+=================
+*/
+static D3DBLEND _convertBlendFactor(GLenum factor)
+{
+	switch (factor)
+	{
+	case GL_ZERO: return D3DBLEND_ZERO;
+	default: case GL_ONE: return D3DBLEND_ONE;
+	case GL_SRC_COLOR: return D3DBLEND_SRCCOLOR;
+	case GL_ONE_MINUS_SRC_COLOR: return D3DBLEND_INVSRCCOLOR;
+	case GL_SRC_ALPHA: return D3DBLEND_SRCALPHA;
+	case GL_ONE_MINUS_SRC_ALPHA: return D3DBLEND_INVSRCALPHA;
+	case GL_DST_COLOR: return D3DBLEND_DESTCOLOR;
+	case GL_ONE_MINUS_DST_COLOR: return D3DBLEND_INVDESTCOLOR;
+	case GL_DST_ALPHA: return D3DBLEND_DESTALPHA;
+	case GL_ONE_MINUS_DST_ALPHA: return D3DBLEND_INVDESTALPHA;
+	case GL_SRC_ALPHA_SATURATE: return D3DBLEND_SRCALPHASAT;
+	}
+}
+
+
+/*
+=================
+_convertPrimMode
+
+Convert GL primitive mode to DX primitive mode.
+=================
+*/
+static D3DPRIMITIVETYPE _convertPrimMode(GLenum mode)
+{
+	switch (mode)
+	{
+	case GL_POINTS: return D3DPT_POINTLIST;
+	case GL_LINES: return D3DPT_LINELIST;
+	case GL_LINE_STRIP: return D3DPT_LINESTRIP;
+	case GL_TRIANGLES: return D3DPT_TRIANGLELIST;
+	case GL_TRIANGLE_STRIP: return D3DPT_TRIANGLESTRIP;
+	case GL_TRIANGLE_FAN: return D3DPT_TRIANGLEFAN;
+#ifdef _XBOX
+	case GL_QUADS: return D3DPT_QUADLIST;
+	case GL_QUAD_STRIP: return D3DPT_QUADSTRIP;
+#else
+	case GL_QUADS: return D3DPT_TRIANGLELIST;
+	case GL_QUAD_STRIP: return D3DPT_TRIANGLESTRIP;
+#endif
+	case GL_POLYGON: return D3DPT_TRIANGLEFAN;
+	default: assert(0); return D3DPT_TRIANGLEFAN;
+	}
+}
+
+
+/*
+=================
+_updateDrawStride
+
+Update the stride of the draw array based on
+the number of vertex attributes.  The stride
+is in DWORDs.
+=================
+*/
+static void _updateDrawStride(GLint normal, GLint tex0, GLint tex1)
+{
+	glw_state->drawStride = 4;
+	if (normal) glw_state->drawStride += 3;
+	if (tex0) glw_state->drawStride += 2;
+	if (tex1) glw_state->drawStride += 2;
+}
+
+
+/*
+=================
+_updateShader
+
+Set the vertex shader based on the number
+of texture coordinates.
+=================
+*/
+static void _updateShader(bool normal, bool tex0, bool tex1)//, bool tex2, bool tex3)
+{
+	DWORD mask = D3DFVF_XYZ;
+	if (normal) mask |= D3DFVF_NORMAL;
+	mask |= D3DFVF_DIFFUSE;
+	if (tex0 && !tex1) mask |= D3DFVF_TEX1;
+	else if (tex1) mask |= D3DFVF_TEX2;
+
+//	if (mask != glw_state->shaderMask)
+//	{
+		glw_state->device->SetVertexShader(mask);
+		glw_state->shaderMask = mask;
+//	}
+}
+
+
+/*
+=================
+_getCurrentTexture
+
+Get the texture information for the currently
+bound texture at a stage.
+=================
+*/
+static glwstate_t::TextureInfo* _getCurrentTexture(int stage)
+{
+	glwstate_t::texturexlat_t::iterator i = glw_state->textureXlat.find(
+		glw_state->currentTexture[stage]);
+
+	if (i == glw_state->textureXlat.end()) return NULL;
+	else return &i->second;
+}
+
+
+/*
+=================
+_updateTextures
+
+Setup texture stages with color operations, filters
+and wrapping modes as needed.
+=================
+*/
+static void _updateTextures(void)
+{
+	for (int t = 0; t < GLW_MAX_TEXTURE_STAGES; ++t)
+	{
+		if (glw_state->textureStageDirty[t])
+		{
+			glw_state->textureStageDirty[t] = false;
+
+			if (glw_state->textureStageEnable[t] && glw_state->currentTexture[t])
+			{
+				glwstate_t::TextureInfo* info = _getCurrentTexture(t);
+				if (!info) continue;
+
+				glw_state->device->SetTexture(t, info->mipmap);
+				glw_state->device->SetTextureStageState(t, D3DTSS_COLOROP, glw_state->textureEnv[t]);
+
+				glw_state->device->SetTextureStageState(t, D3DTSS_COLORARG1, 
+					D3DTA_TEXTURE);
+				glw_state->device->SetTextureStageState(t, D3DTSS_COLORARG2, 
+					D3DTA_CURRENT);
+				glw_state->device->SetTextureStageState(t, D3DTSS_ALPHAOP, 
+					glw_state->textureEnv[t]);
+				glw_state->device->SetTextureStageState(t, D3DTSS_ALPHAARG1, 
+					D3DTA_TEXTURE);
+				glw_state->device->SetTextureStageState(t, D3DTSS_ALPHAARG2, 
+					D3DTA_CURRENT);
+
+				glw_state->device->SetTextureStageState(t, D3DTSS_MAXANISOTROPY, 
+					info->anisotropy);
+				glw_state->device->SetTextureStageState(t, D3DTSS_MINFILTER, 
+					info->minFilter);
+				glw_state->device->SetTextureStageState(t, D3DTSS_MIPFILTER, 
+					info->mipFilter);
+				glw_state->device->SetTextureStageState(t, D3DTSS_MAGFILTER, 
+					info->magFilter);
+
+				glw_state->device->SetTextureStageState(t, D3DTSS_ADDRESSU, 
+					info->wrapU);
+				glw_state->device->SetTextureStageState(t, D3DTSS_ADDRESSV, 
+					info->wrapV);
+
+				glw_state->device->SetTextureStageState(t, D3DTSS_TEXCOORDINDEX, t);
+
+				glw_state->device->SetTextureStageState( t, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT2 );
+
+				/*if(tess.shader)
+				{
+					if(tess.currentPass < tess.shader->numUnfoggedPasses)
+					{ 
+						if(tess.shader->stages[tess.currentPass].isEnvironment)
+						{
+							glw_state->device->SetTextureStageState(t, D3DTSS_TEXCOORDINDEX, t | D3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR);
+						}
+					}
+				}*/				
+			}
+			else
+			{
+				glw_state->device->SetTexture(t, NULL);
+				glw_state->device->SetTextureStageState(t, D3DTSS_COLOROP, D3DTOP_DISABLE);
+				glw_state->device->SetTextureStageState(t, D3DTSS_ALPHAOP, D3DTOP_DISABLE);
+			}
+		}
+		//else
+		//{
+		//	// Hard-wired check for turning on hardware environment mapping
+		//	if( glw_state->textureStageEnable[t] &&
+		//		glw_state->currentTexture[t] &&
+		//		tess.shader &&
+		//		tess.currentPass < tess.shader->numUnfoggedPasses &&
+		//		tess.shader->stages[tess.currentPass].isEnvironment)
+		//	{
+		//			glw_state->device->SetTextureStageState(t, D3DTSS_TEXCOORDINDEX, t | D3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR);
+		//	}
+		//}
+	}
+}
+
+
+/*
+=================
+_updateMatrices
+
+Set the current projection and view transforms to
+the matrices at the top of the relevant stacks.
+=================
+*/
+static void _updateMatrices(void)
+{
+	if(glw_state->matricesDirty[glwstate_t::MatrixMode_Projection])
+	{
+		glw_state->device->SetTransform(D3DTS_PROJECTION, 
+			glw_state->matrixStack[glwstate_t::MatrixMode_Projection]->GetTop());
+
+		glw_state->matricesDirty[glwstate_t::MatrixMode_Projection] = false;
+	}
+
+	if(glw_state->matricesDirty[glwstate_t::MatrixMode_Model])
+	{
+		glw_state->device->SetTransform(D3DTS_VIEW, 
+			glw_state->matrixStack[glwstate_t::MatrixMode_Model]->GetTop());
+
+		glw_state->matricesDirty[glwstate_t::MatrixMode_Model] = false;
+	}
+
+	if(glw_state->matricesDirty[glwstate_t::MatrixMode_Texture0])
+	{
+		glw_state->device->SetTransform(D3DTS_TEXTURE0,
+			glw_state->matrixStack[glwstate_t::MatrixMode_Texture0]->GetTop());
+
+		glw_state->matricesDirty[glwstate_t::MatrixMode_Texture0] = false;
+	}
+
+	if(glw_state->matricesDirty[glwstate_t::MatrixMode_Texture1])
+	{
+		glw_state->device->SetTransform(D3DTS_TEXTURE1,
+			glw_state->matrixStack[glwstate_t::MatrixMode_Texture1]->GetTop());
+
+		glw_state->matricesDirty[glwstate_t::MatrixMode_Texture1] = false;
+	}
+}
+
+
+/*
+=================
+_getMaxVerts
+
+Calculate the maximum number of verts to draw
+given a total number to draw, stride and max
+packet size.
+=================
+*/
+static int _getMaxVerts(void)
+{
+	int max = glw_state->totalVertices;
+	if (max > GLW_MAX_DRAW_PACKET_SIZE / glw_state->drawStride)
+	{
+		max = GLW_MAX_DRAW_PACKET_SIZE / glw_state->drawStride;
+	}
+	return max;
+}
+
+static int _getMaxIndices(void)
+{
+	int max = glw_state->totalIndices;
+	if(max > 1022)
+		max = 1022;
+
+	return max;
+}
+
+#ifdef _XBOX
+/*
+=================
+_restartDrawPacket
+
+Encode a new draw packet header into the draw array.
+=================
+*/
+inline static DWORD* _restartDrawPacket(DWORD* packet, int verts)
+{
+	packet[0] = D3DPUSH_ENCODE(D3DPUSH_SET_BEGIN_END, 1);
+	packet[1] = glw_state->primitiveMode;
+	packet[2] = D3DPUSH_ENCODE(
+		D3DPUSH_NOINCREMENT_FLAG|D3DPUSH_INLINE_ARRAY, 
+		glw_state->drawStride * verts);
+	return packet + 3;
+}
+
+/*
+=================
+_terminateDrawPacket
+
+Finish up the last draw packet.
+=================
+*/
+inline static DWORD* _terminateDrawPacket(DWORD* packet)
+{
+	packet[0] = D3DPUSH_ENCODE(D3DPUSH_SET_BEGIN_END, 1);
+	packet[1] = 0;
+	return packet + 2;
+}
+
+#define CMD_DRAW_INDEX_BATCH 0x1800
+inline static DWORD* _restartIndexPacket(DWORD* packet, int numIndices)
+{
+	packet[0] = D3DPUSH_ENCODE(D3DPUSH_SET_BEGIN_END, 1);
+	packet[1] = glw_state->primitiveMode;
+	packet[2] = D3DPUSH_ENCODE(	D3DPUSH_NOINCREMENT_FLAG | CMD_DRAW_INDEX_BATCH, numIndices / 2 );
+	return packet + 3;
+}
+
+inline static DWORD* _terminateIndexPacket(DWORD* packet)
+{
+	packet[0] = D3DPUSH_ENCODE(D3DPUSH_SET_BEGIN_END, 1);
+	packet[1] = 0;
+	return packet + 2;
+}
+
+
+/*
+=================
+_handleDrawOverflow
+
+Prevent a draw packet from getting too
+big for the hardware by restarting it as needed.
+=================
+*/
+static void _handleDrawOverflow(void)
+{
+	if (glw_state->numVertices >= glw_state->maxVertices)
+	{
+		glw_state->drawArray += glw_state->numVertices *
+			glw_state->drawStride;
+		
+		glw_state->totalVertices -= glw_state->numVertices;
+		glw_state->maxVertices = _getMaxVerts();
+		glw_state->numVertices = 0;
+
+		glw_state->drawArray = _restartDrawPacket(
+			glw_state->drawArray, glw_state->maxVertices);
+	}
+}
+#else _XBOX
+inline static DWORD* _restartDrawPacket(DWORD* packet, int verts)
+{
+	return packet;
+}
+
+inline static DWORD* _terminateDrawPacket(DWORD* packet)
+{
+	return packet;
+}
+
+static void _handleDrawOverflow(void)
+{
+}
+#endif _XBOX
+
+
+/*
+=================
+_vertexElement
+
+Copy position information from the source vertex
+array into a draw array.
+=================
+*/
+#define _vertexElement(push, i)									\
+{																\
+	DWORD* vert = (DWORD*)((BYTE*)glw_state->vertexPointer +	\
+		(i) * glw_state->vertexStride);							\
+	(push)[0] = vert[0];										\
+	(push)[1] = vert[1];										\
+	(push)[2] = vert[2];										\
+}
+
+/*
+=================
+_colorElement
+
+Copy color information from the source color
+array into a draw array.
+=================
+*/
+#define _colorElement(push, i)									\
+{																\
+	DWORD col = *(DWORD*)((BYTE*)glw_state->colorPointer +		\
+		(i) * glw_state->colorStride);							\
+	(push)[0] =													\
+		((col & 0xFF000000) >> 0) |								\
+		((col & 0x00FF0000) >> 16) |							\
+		((col & 0x0000FF00) << 0) |								\
+		((col & 0x000000FF) << 16);								\
+}
+
+/*
+=================
+_texCoordElement
+
+Copy tex coord information from the source tex coord
+array into a draw array.
+=================
+*/
+#define _texCoordElement(push, i, t)							\
+{																\
+	DWORD* tc = (DWORD*)((BYTE*)glw_state->texCoordPointer[t] +	\
+		(i) * glw_state->texCoordStride[t]);					\
+	(push)[0] = tc[0];											\
+	(push)[1] = tc[1];											\
+}
+
+/*
+=================
+_normalElement
+
+  Copy normal information from the source normal
+  array into a draw array
+=================
+*/
+#define _normalElement(push, i)									\
+{																\
+	DWORD* norm = (DWORD*)((BYTE*)glw_state->normalPointer +	\
+		(i) * glw_state->normalStride);							\
+	(push)[0] = norm[0];										\
+	(push)[1] = norm[1];										\
+	(push)[2] = norm[2];										\
+}
+
+
+#define _tangentElement(push, i)								\
+{																\
+	DWORD* tang = (DWORD*)((BYTE*)&tess.tangent[i]);				\
+	(push)[0] = tang[0];										\
+	(push)[1] = tang[1];										\
+	(push)[2] = tang[2];										\
+}
+
+
+
+/*
+=========================================================
+FAST INDEXED GEOMETRY DRAW LOOPS
+
+Used by core draw routines to quickly copy
+geometry from various source arrays to main
+draw array.
+=========================================================
+*/
+static void _drawElementsV(GLsizei count, const GLushort* indices)
+{
+	DWORD* push = glw_state->drawArray;
+	for (int i = 0; i < count; ++i)
+	{
+		_vertexElement(&push[0], indices[i]);
+		push[3] = glw_state->currentColor;
+		push += 4;
+	}
+}
+
+static void _drawElementsVN(GLsizei count, const GLushort* indices)
+{
+	DWORD* push = glw_state->drawArray;
+	for (int i = 0; i < count; ++i)
+	{
+		_vertexElement(&push[0], indices[i]);
+		_normalElement(&push[3], indices[i]);
+		push[6] = glw_state->currentColor;
+		push += 7;
+	}
+}
+
+static void _drawElementsVC(GLsizei count, const GLushort* indices)
+{
+	DWORD* push = glw_state->drawArray;
+	for (int i = 0; i < count; ++i)
+	{
+		_vertexElement(&push[0], indices[i]);
+		_colorElement(&push[3], indices[i]);
+		push += 4;
+	}
+}
+
+static void _drawElementsVCN(GLsizei count, const GLushort* indices)
+{
+	DWORD* push = glw_state->drawArray;
+	for (int i = 0; i < count; ++i)
+	{
+		_vertexElement(&push[0], indices[i]);
+		_normalElement(&push[3], indices[i]);
+		_colorElement(&push[6], indices[i]);
+		push += 7;
+	}
+}
+
+static void _drawElementsVCT(GLsizei count, const GLushort* indices)
+{
+	DWORD* push = glw_state->drawArray;
+	for (int i = 0; i < count; ++i)
+	{
+		_vertexElement(&push[0], indices[i]);
+		_colorElement(&push[3], indices[i]);
+		_texCoordElement(&push[4], indices[i], 0);
+		push += 6;
+	}
+}
+
+static void _drawElementsVCNT(GLsizei count, const GLushort* indices)
+{
+	DWORD* push = glw_state->drawArray;
+	for (int i = 0; i < count; ++i)
+	{
+		_vertexElement(&push[0], indices[i]);
+		_normalElement(&push[3], indices[i]);
+		_colorElement(&push[6], indices[i]);
+		_texCoordElement(&push[7], indices[i], 0);
+		push += 9;
+	}
+}
+
+static void _drawElementsVCTT(GLsizei count, const GLushort* indices)
+{
+	DWORD* push = glw_state->drawArray;
+	for (int i = 0; i < count; ++i)
+	{
+		_vertexElement(&push[0], indices[i]);
+		_colorElement(&push[3], indices[i]);
+		_texCoordElement(&push[4], indices[i], 0);
+		_texCoordElement(&push[6], indices[i], 1);
+		push += 8;
+	}
+}
+
+static void _drawElementsVCNTT(GLsizei count, const GLushort* indices)
+{
+	DWORD* push = glw_state->drawArray;
+	for (int i = 0; i < count; ++i)
+	{
+		_vertexElement(&push[0], indices[i]);
+		_normalElement(&push[3], indices[i]);
+		_colorElement(&push[6], indices[i]);
+		_texCoordElement(&push[7], indices[i], 0);
+		_texCoordElement(&push[9], indices[i], 1);
+		push += 11;
+	}
+}
+
+static void _drawElementsVT(GLsizei count, const GLushort* indices)
+{
+	DWORD* push = glw_state->drawArray;
+	for (int i = 0; i < count; ++i)
+	{
+		_vertexElement(&push[0], indices[i]);
+		push[3] = glw_state->currentColor;
+		_texCoordElement(&push[4], indices[i], 0);
+		push += 6;
+	}
+}
+
+static void _drawElementsVNT(GLsizei count, const GLushort* indices)
+{
+	DWORD* push = glw_state->drawArray;
+	for (int i = 0; i < count; ++i)
+	{
+		_vertexElement(&push[0], indices[i]);
+		_normalElement(&push[3], indices[i]);
+		push[6] = glw_state->currentColor;
+		_texCoordElement(&push[7], indices[i], 0);
+		push += 9;
+	}
+}
+
+static void _drawElementsVTT(GLsizei count, const GLushort* indices)
+{
+	DWORD* push = glw_state->drawArray;
+	for (int i = 0; i < count; ++i)
+	{
+		_vertexElement(&push[0], indices[i]);
+		push[3] = glw_state->currentColor;
+		_texCoordElement(&push[4], indices[i], 0);
+		_texCoordElement(&push[6], indices[i], 1);
+		push += 8;
+	}
+}
+
+static void _drawElementsVNTT(GLsizei count, const GLushort* indices)
+{
+	DWORD* push = glw_state->drawArray;
+	for (int i = 0; i < count; ++i)
+	{
+		_vertexElement(&push[0], indices[i]);
+		_normalElement(&push[3], indices[i]);
+		push[6] = glw_state->currentColor;
+		_texCoordElement(&push[7], indices[i], 0);
+		_texCoordElement(&push[9], indices[i], 1);
+		push += 11;
+	}
+}
+
+
+static void _drawElementsLightShader(GLsizei count, const GLushort* indices)
+{
+	DWORD* push = glw_state->drawArray;
+	for(int i = 0; i < count; ++i)
+	{
+		_vertexElement(&push[0], indices[i]);
+		_normalElement(&push[3], indices[i]);
+		_texCoordElement(&push[6], indices[i], 0);
+		_tangentElement(&push[8], indices[i]);
+		push += 11;
+	}
+}
+
+static void _drawElementsBumpShader(GLsizei count, const GLushort* indices)
+{
+	DWORD* push = glw_state->drawArray;
+	for(int i = 0; i < count; ++i)
+	{
+		_vertexElement(&push[0], indices[i]);
+		_normalElement(&push[3], indices[i]);
+		_texCoordElement(&push[6], indices[i], 0);
+		_texCoordElement(&push[8], indices[i], 1);
+		_tangentElement(&push[10], indices[i]);
+		push += 13;
+	}
+}
+
+static void _drawElementsEnvShader(GLsizei count, const GLushort* indices)
+{
+	DWORD* push = glw_state->drawArray;
+	for(int i = 0; i < count; ++i)
+	{
+		_vertexElement(&push[0], indices[i]);
+		_normalElement(&push[3], indices[i]);
+		push += 6;
+	}
+}
+
+typedef void(*drawelemfunc_t)(GLsizei, const GLushort*);
+static drawelemfunc_t _drawElementFuncTable[12] =
+{
+	_drawElementsV,
+	_drawElementsVN,
+	_drawElementsVT,
+	_drawElementsVNT,
+	_drawElementsVTT,
+	_drawElementsVNTT,
+	_drawElementsVC,
+	_drawElementsVCN,
+	_drawElementsVCT,
+	_drawElementsVCNT,
+	_drawElementsVCTT,
+	_drawElementsVCNTT,
+};
+
+
+
+/*
+=========================================================
+FAST GEOMETRY DRAW LOOPS
+
+Used by core draw routines to quickly copy
+geometry from various source arrays to main
+draw array.
+=========================================================
+*/
+static void _drawArraysV(GLsizei first, GLsizei last)
+{
+	DWORD* push = glw_state->drawArray;
+	for (int i = first; i < last; ++i)
+	{
+		_vertexElement(&push[0], i);
+		push[3] = glw_state->currentColor;
+		push += 4;
+	}
+}
+
+static void _drawArraysVN(GLsizei first, GLsizei last)
+{
+	DWORD* push = glw_state->drawArray;
+	for (int i = first; i < last; ++i)
+	{
+		_vertexElement(&push[0], i);
+		_normalElement(&push[3], i);
+		push[6] = glw_state->currentColor;
+		push += 7;
+	}
+}
+
+static void _drawArraysVC(GLsizei first, GLsizei last)
+{
+	DWORD* push = glw_state->drawArray;
+	for (int i = first; i < last; ++i)
+	{
+		_vertexElement(&push[0], i);
+		_colorElement(&push[3], i);
+		push += 4;
+	}
+}
+
+static void _drawArraysVCN(GLsizei first, GLsizei last)
+{
+	DWORD* push = glw_state->drawArray;
+	for (int i = first; i < last; ++i)
+	{
+		_vertexElement(&push[0], i);
+		_normalElement(&push[3], i);
+		_colorElement(&push[6], i);
+		push += 7;
+	}
+}
+
+static void _drawArraysVCT(GLsizei first, GLsizei last)
+{
+	DWORD* push = glw_state->drawArray;
+	for (int i = first; i < last; ++i)
+	{
+		_vertexElement(&push[0], i);
+		_colorElement(&push[3], i);
+		_texCoordElement(&push[4], i, 0);
+		push += 6;
+	}
+}
+
+static void _drawArraysVCNT(GLsizei first, GLsizei last)
+{
+	DWORD* push = glw_state->drawArray;
+	for (int i = first; i < last; ++i)
+	{
+		_vertexElement(&push[0], i);
+		_normalElement(&push[3], i);
+		_colorElement(&push[6], i);
+		_texCoordElement(&push[7], i, 0);
+		push += 9;
+	}
+}
+
+static void _drawArraysVCTT(GLsizei first, GLsizei last)
+{
+	DWORD* push = glw_state->drawArray;
+	for (int i = first; i < last; ++i)
+	{
+		_vertexElement(&push[0], i);
+		_colorElement(&push[3], i);
+		_texCoordElement(&push[4], i, 0);
+		_texCoordElement(&push[6], i, 1);
+		push += 8;
+	}
+}
+
+static void _drawArraysVCNTT(GLsizei first, GLsizei last)
+{
+	DWORD* push = glw_state->drawArray;
+	for (int i = first; i < last; ++i)
+	{
+		_vertexElement(&push[0], i);
+		_normalElement(&push[3], i);
+		_colorElement(&push[6], i);
+		_texCoordElement(&push[7], i, 0);
+		_texCoordElement(&push[9], i, 1);
+		push += 11;
+	}
+}
+
+static void _drawArraysVT(GLsizei first, GLsizei last)
+{
+	DWORD* push = glw_state->drawArray;
+	for (int i = first; i < last; ++i)
+	{
+		_vertexElement(&push[0], i);
+		push[3] = glw_state->currentColor;
+		_texCoordElement(&push[4], i, 0);
+		push += 6;
+	}
+}
+
+static void _drawArraysVNT(GLsizei first, GLsizei last)
+{
+	DWORD* push = glw_state->drawArray;
+	for (int i = first; i < last; ++i)
+	{
+		_vertexElement(&push[0], i);
+		_normalElement(&push[3], i);
+		push[6] = glw_state->currentColor;
+		_texCoordElement(&push[7], i, 0);
+		push += 9;
+	}
+}
+
+static void _drawArraysVTT(GLsizei first, GLsizei last)
+{
+	DWORD* push = glw_state->drawArray;
+	for (int i = first; i < last; ++i)
+	{
+		_vertexElement(&push[0], i);
+		push[3] = glw_state->currentColor;
+		_texCoordElement(&push[4], i, 0);
+		_texCoordElement(&push[6], i, 1);
+		push += 8;
+	}
+}
+
+static void _drawArraysVNTT(GLsizei first, GLsizei last)
+{
+	DWORD* push = glw_state->drawArray;
+	for (int i = first; i < last; ++i)
+	{
+		_vertexElement(&push[0], i);
+		_normalElement(&push[3], i);
+		push[6] = glw_state->currentColor;
+		_texCoordElement(&push[7], i, 0);
+		_texCoordElement(&push[9], i, 1);
+		push += 11;
+	}
+}
+
+typedef void(*drawarrayfunc_t)(GLsizei, GLsizei);
+static drawarrayfunc_t _drawArrayFuncTable[12] =
+{
+	_drawArraysV,
+	_drawArraysVN,
+	_drawArraysVT,
+	_drawArraysVNT,
+	_drawArraysVTT,
+	_drawArraysVNTT,
+	_drawArraysVC,
+	_drawArraysVCN,
+	_drawArraysVCT,
+	_drawArraysVCNT,
+	_drawArraysVCTT,
+	_drawArraysVCNTT,
+};
+
+
+/*
+=================
+_getDrawFunc
+
+Figure which drawing function we need based on
+what vertex components we have.  Use the returned
+integer to index the draw function tables.
+=================
+*/
+static int _getDrawFunc(void)
+{
+	int func = 0;
+	if (glw_state->colorArrayState) func += 6;
+	if (glw_state->texCoordArrayState[0]) func += 2;
+	if (glw_state->texCoordArrayState[1]) func += 2;
+	if (glw_state->normalArrayState) ++func;
+	return func;
+}
+
+
+static void dllAccum(GLenum op, GLfloat value)
+{
+	assert(false);
+}
+
+static void dllAlphaFunc(GLenum func, GLclampf ref)
+{
+	D3DCMPFUNC f = _convertCompare(func);
+	glw_state->device->SetRenderState(D3DRS_ALPHAFUNC, f);
+	glw_state->device->SetRenderState(D3DRS_ALPHAREF, (DWORD)(ref * 255.));
+}
+
+GLboolean dllAreTexturesResident(GLsizei n, const GLuint *textures, GLboolean *residences)
+{
+	assert(false);
+	return 1;
+}
+
+static void dllArrayElement(GLint i)
+{
+	assert(glw_state->inDrawBlock);
+	
+	_handleDrawOverflow();
+
+	DWORD* push = &glw_state->drawArray[glw_state->numVertices * 
+		glw_state->drawStride];
+
+	_vertexElement(push, i);
+	push += 3;
+	
+	if (glw_state->colorArrayState)
+	{
+		_colorElement(push, i);
+		++push;
+	}
+	else
+	{
+		*push++ = glw_state->currentColor;
+	}
+	
+	for (int t = 0; t < GLW_MAX_TEXTURE_STAGES; ++t)
+	{
+		if (glw_state->texCoordArrayState[t])
+		{
+			_texCoordElement(push, i, t);
+			push += 2;
+		}
+	}
+
+	++glw_state->numVertices;
+}
+
+// EXTENSION: Begin a drawing block with at verts vertices
+static void dllBeginEXT(GLenum mode, GLint verts, GLint colors, GLint normals, GLint tex0, GLint tex1)//, GLint tex2, GLint tex3)
+{
+	assert(!glw_state->inDrawBlock);
+
+	// start the draw block
+	glw_state->inDrawBlock = true;
+	glw_state->primitiveMode = _convertPrimMode(mode);
+
+	// update DX with any pending state changes
+	_updateDrawStride(normals, tex0, tex1);//, tex2, tex3);
+	_updateShader(normals, tex0, tex1);//, tex2, tex3);
+	_updateTextures();
+	_updateMatrices();
+
+	// set vertex counters
+	glw_state->numVertices = 0;
+	glw_state->totalVertices = verts;
+	glw_state->maxVertices = _getMaxVerts();	
+
+#ifdef _XBOX
+	// open a draw packet
+	//int num_packets = ((verts * glw_state->drawStride) / GLW_MAX_DRAW_PACKET_SIZE) + 1;
+	int num_packets;
+	if(glw_state->maxVertices == 0) {
+		num_packets = 1;
+	} else {
+		num_packets = (verts / glw_state->maxVertices) + (!!(verts % glw_state->maxVertices));
+	}
+	int cmd_size = num_packets * 3;
+	int vert_size = glw_state->drawStride * verts;
+	
+	glw_state->device->BeginPush(vert_size + cmd_size + 2, 
+		&glw_state->drawArray);
+	
+	glw_state->drawArray = _restartDrawPacket(
+		glw_state->drawArray, glw_state->maxVertices);
+#endif
+}
+
+static void dllBegin(GLenum mode)
+{
+	assert(0);
+}
+
+// EXTENSION: Start a new drawing frame
+GLboolean dllBeginFrame(void)
+{
+	GLboolean result = glw_state->device->BeginScene() == D3D_OK;
+	return result;
+}
+
+// EXTENSION: Begin shadow draw mode
+static void dllBeginShadow(void)
+{
+	//Intentionally left blank
+}
+
+static void dllBindTexture(GLenum target, GLuint texture)
+{
+	assert(target == GL_TEXTURE_2D);
+
+	if (glw_state->currentTexture[glw_state->serverTU] != texture)
+	{
+		glw_state->currentTexture[glw_state->serverTU] = texture;
+		glw_state->textureStageDirty[glw_state->serverTU] = true;
+	}
+}
+
+static void dllBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap)
+{
+	assert(false);
+}
+
+static void dllBlendFunc(GLenum sfactor, GLenum dfactor)
+{
+	D3DBLEND s = _convertBlendFactor(sfactor);
+	D3DBLEND d = _convertBlendFactor(dfactor);
+	
+	glw_state->device->SetRenderState(D3DRS_SRCBLEND, s);
+	glw_state->device->SetRenderState(D3DRS_DESTBLEND, d);
+}
+
+static void dllCallList(GLuint lnum)
+{
+	assert(0);
+}
+
+static void dllCallLists(GLsizei n, GLenum type, const GLvoid *lists)
+{
+	assert(0);
+}
+
+static void dllClear(GLbitfield mask)
+{
+	DWORD m = 0;
+
+	if (mask & GL_COLOR_BUFFER_BIT) m |= D3DCLEAR_TARGET;
+	if (mask & GL_STENCIL_BUFFER_BIT) m |= D3DCLEAR_STENCIL;
+
+#ifdef _XBOX
+	// Clearing stencil when clearing depth buffer
+	// is faster on Xbox than just clearing depth alone.
+	if (mask & GL_DEPTH_BUFFER_BIT) m |= D3DCLEAR_ZBUFFER|D3DCLEAR_STENCIL;
+#else
+	if (mask & GL_DEPTH_BUFFER_BIT) m |= D3DCLEAR_ZBUFFER;
+#endif
+	
+	glw_state->device->Clear(0, NULL, m, glw_state->clearColor, 
+		glw_state->clearDepth, glw_state->clearStencil);
+}
+
+static void dllClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
+{
+	assert(0);
+}
+
+static void dllClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
+{
+	glw_state->clearColor = D3DCOLOR_COLORVALUE(red, green, blue, alpha);
+}
+
+static void dllClearDepth(GLclampd depth)
+{
+	glw_state->clearDepth = depth;
+}
+
+static void dllClearIndex(GLfloat c)
+{
+	assert(0);
+}
+
+static void dllClearStencil(GLint s)
+{
+	glw_state->clearStencil = s;
+}
+
+static void dllClipPlane(GLenum plane, const GLdouble *equation)
+{
+	//FIXME
+}
+
+static void setIntColor(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha)
+{
+	glw_state->currentColor = D3DCOLOR_RGBA(red, green, blue, alpha);
+}
+
+static void setFloatColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
+{
+	glw_state->currentColor = D3DCOLOR_COLORVALUE(red, green, blue, alpha);
+}
+
+static void dllColor3b(GLbyte red, GLbyte green, GLbyte blue)
+{
+	setIntColor(red, green, blue, 127);
+}
+
+static void dllColor3bv(const GLbyte *v)
+{
+	setIntColor(v[0], v[1], v[2], 127);
+}
+
+static void dllColor3d(GLdouble red, GLdouble green, GLdouble blue)
+{
+	setFloatColor(red, green, blue, 1.f);
+}
+
+static void dllColor3dv(const GLdouble *v)
+{
+	setFloatColor(v[0], v[1], v[2], 1.f);
+}
+
+static void dllColor3f(GLfloat red, GLfloat green, GLfloat blue)
+{
+	setFloatColor(red, green, blue, 1.f);
+}
+
+static void dllColor3fv(const GLfloat *v)
+{
+	setFloatColor(v[0], v[1], v[2], 1.f);
+}
+
+static void dllColor3i(GLint red, GLint green, GLint blue)
+{
+	setIntColor(red, green, blue, 127);
+}
+
+static void dllColor3iv(const GLint *v)
+{
+	setIntColor(v[0], v[1], v[2], 127);
+}
+
+static void dllColor3s(GLshort red, GLshort green, GLshort blue)
+{
+	setIntColor(red, green, blue, 127);
+}
+
+static void dllColor3sv(const GLshort *v)
+{
+	setIntColor(v[0], v[1], v[2], 127);
+}
+
+static void dllColor3ub(GLubyte red, GLubyte green, GLubyte blue)
+{
+	setIntColor(red, green, blue, 127);
+}
+
+static void dllColor3ubv(const GLubyte *v)
+{
+	setIntColor(v[0], v[1], v[2], 127);
+}
+
+static void dllColor3ui(GLuint red, GLuint green, GLuint blue)
+{
+	setIntColor(red, green, blue, 127);
+}
+
+static void dllColor3uiv(const GLuint *v)
+{
+	setIntColor(v[0], v[1], v[2], 127);
+}
+
+static void dllColor3us(GLushort red, GLushort green, GLushort blue)
+{
+	setIntColor(red, green, blue, 127);
+}
+
+static void dllColor3usv(const GLushort *v)
+{
+	setIntColor(v[0], v[1], v[2], 127);
+}
+
+static void dllColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha)
+{
+	setIntColor(red, green, blue, alpha);
+}
+
+static void dllColor4bv(const GLbyte *v)
+{
+	setIntColor(v[0], v[1], v[2], v[3]);
+}
+
+static void dllColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha)
+{
+	setFloatColor(red, green, blue, alpha);
+}
+
+static void dllColor4dv(const GLdouble *v)
+{
+	setFloatColor(v[0], v[1], v[2], v[3]);
+}
+
+static void dllColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
+{
+	setFloatColor(red, green, blue, alpha);
+}
+
+static void dllColor4fv(const GLfloat *v)
+{
+	setFloatColor(v[0], v[1], v[2], v[3]);
+}
+
+static void dllColor4i(GLint red, GLint green, GLint blue, GLint alpha)
+{
+	setIntColor(red, green, blue, alpha);
+}
+
+static void dllColor4iv(const GLint *v)
+{
+	setIntColor(v[0], v[1], v[2], v[3]);
+}
+
+static void dllColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha)
+{
+	setIntColor(red, green, blue, alpha);
+}
+
+static void dllColor4sv(const GLshort *v)
+{
+	setIntColor(v[0], v[1], v[2], v[3]);
+}
+
+static void dllColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
+{
+	setIntColor(red, green, blue, alpha);
+}
+
+static void dllColor4ubv(const GLubyte *v)
+{
+	setIntColor(v[0], v[1], v[2], v[3]);
+}
+
+static void dllColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha)
+{
+	setIntColor(red, green, blue, alpha);
+}
+
+static void dllColor4uiv(const GLuint *v)
+{
+	setIntColor(v[0], v[1], v[2], v[3]);
+}
+
+static void dllColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha)
+{
+	setIntColor(red, green, blue, alpha);
+}
+
+static void dllColor4usv(const GLushort *v)
+{
+	setIntColor(v[0], v[1], v[2], v[3]);
+}
+
+static void dllColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
+{
+	DWORD m = 0;
+	if (red) m |= D3DCOLORWRITEENABLE_RED;
+	if (green) m |= D3DCOLORWRITEENABLE_GREEN;
+	if (blue) m |= D3DCOLORWRITEENABLE_BLUE;
+	if (alpha) m |= D3DCOLORWRITEENABLE_ALPHA;
+	glw_state->device->SetRenderState(D3DRS_COLORWRITEENABLE, m);
+}
+
+static void dllColorMaterial(GLenum face, GLenum mode)
+{
+	assert(0);
+}
+
+static void dllColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
+{
+	assert(!glw_state->inDrawBlock);
+	assert(size == 4 && type == GL_UNSIGNED_BYTE);
+	
+	stride = (stride == 0) ? sizeof(GLint) : stride;
+
+	glw_state->colorPointer = pointer; 
+	glw_state->colorStride = stride;
+}
+
+static void dllCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type)
+{
+	assert(0);
+}
+
+static void dllCopyTexImage1D(GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border)
+{
+	assert(0);
+}
+
+/**********
+copies a portion of the backbuffer to the current texture.
+the current texture must be a linear format texture, if
+a swizzled texture format is needed, use
+dllCopyBackBufferToTexEXT
+**********/
+static void dllCopyTexImage2D(GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
+{
+	// check to make sure everything passed in is supported
+	assert((target == GL_TEXTURE_2D) && (level == 0) && (border == 0));
+
+	// locals
+	RECT						rSrc;
+	POINT						ptUpperLeft;
+	LPDIRECT3DSURFACE8			tSurf;
+	LPDIRECT3DSURFACE8			backbuffer;
+	glwstate_t::TextureInfo*	tex;
+	HRESULT						res;
+		
+	// get the current texture
+	tex = _getCurrentTexture(glw_state->serverTU);
+	if (tex == NULL)
+	{
+		return;
+	}
+
+	// set up the source rectangle
+	rSrc.left	= x;
+	rSrc.right	= x + width;
+	rSrc.top	= (480 - y) - height;
+	rSrc.bottom	= (480 - y);
+
+	// set up the target point
+	ptUpperLeft.x	= 0;
+	ptUpperLeft.y	= 0;
+
+	// attach the current texture to a surface
+	tex->mipmap->GetSurfaceLevel(0, &tSurf);
+
+	// attach the back buffer to a surface
+	res = glw_state->device->GetBackBuffer(0, D3DBACKBUFFER_TYPE_MONO, &backbuffer);
+
+	// copy the data
+	res = glw_state->device->CopyRects(backbuffer, &rSrc, 0, tSurf, &ptUpperLeft);
+
+	// release surfaces
+	tSurf->Release();
+	backbuffer->Release();
+}
+
+static void dllCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
+{
+	assert(0);
+}
+
+static void dllCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
+{
+	assert(0);
+}
+
+static void dllCullFace(GLenum mode)
+{
+	switch (mode)
+	{
+	default: case GL_BACK: glw_state->cullMode = D3DCULL_CW; break;
+	case GL_FRONT: glw_state->cullMode = D3DCULL_CCW; break;
+	}
+
+	glw_state->device->SetRenderState(D3DRS_CULLMODE, glw_state->cullMode);
+}
+
+static void dllDeleteLists(GLuint lnum, GLsizei range)
+{
+	assert(0);
+}
+
+static void dllDeleteTextures(GLsizei n, const GLuint *textures)
+{
+	for (int t = 0; t < n; ++t)
+	{
+		glwstate_t::texturexlat_t::iterator i = 
+			glw_state->textureXlat.find(textures[t]);
+
+		if (i != glw_state->textureXlat.end())
+		{
+#if MEMORY_PROFILE
+			texMemSize -= getTexMemSize(i->second.mipmap);
+#endif
+			i->second.mipmap->Release();
+			glw_state->textureXlat.erase(i);
+		}
+	}
+}
+
+static void dllDepthFunc(GLenum func)
+{
+	D3DCMPFUNC f = _convertCompare(func);
+	glw_state->device->SetRenderState(D3DRS_ZFUNC, f);
+}
+
+static void dllDepthMask(GLboolean flag)
+{
+	glw_state->device->SetRenderState(D3DRS_ZWRITEENABLE, flag);
+}
+
+static void dllDepthRange(GLclampd zNear, GLclampd zFar)
+{
+	glw_state->viewport.MinZ = zNear;
+	glw_state->viewport.MaxZ = zFar;
+	glw_state->device->SetViewport(&glw_state->viewport);
+}
+
+#ifdef _XBOX
+static void setPresent(bool vsync)
+{
+	//extern void ShowOSMemory();
+	//ShowOSMemory();
+
+	D3DPRESENT_PARAMETERS pp;
+	pp.BackBufferWidth = glConfig.vidWidth;
+	pp.BackBufferHeight = glConfig.vidHeight;
+	pp.BackBufferFormat = D3DFMT_X8R8G8B8;
+	pp.BackBufferCount = 1;
+	pp.MultiSampleType  = D3DMULTISAMPLE_NONE; //D3DMULTISAMPLE_4_SAMPLES_SUPERSAMPLE_LINEAR;
+	pp.SwapEffect = D3DSWAPEFFECT_DISCARD;
+	pp.hDeviceWindow = 0;
+	pp.Windowed  = FALSE;
+	pp.EnableAutoDepthStencil = TRUE;
+	pp.AutoDepthStencilFormat = D3DFMT_D24S8;
+	pp.Flags = 0;
+	pp.FullScreen_RefreshRateInHz = D3DPRESENT_RATE_DEFAULT;
+	pp.FullScreen_PresentationInterval = 
+		vsync ? D3DPRESENT_INTERVAL_DEFAULT : D3DPRESENT_INTERVAL_IMMEDIATE;
+	pp.BufferSurfaces[0] = pp.BufferSurfaces[1] = pp.BufferSurfaces[2] = 0;
+	pp.DepthStencilSurface = 0;
+	glw_state->device->PersistDisplay();
+	glw_state->device->Reset(&pp);
+
+	//ShowOSMemory();
+}
+#endif
+
+static void setCap(GLenum cap, bool flag)
+{
+	switch (cap)
+	{
+	case GL_ALPHA_TEST: glw_state->device->SetRenderState(D3DRS_ALPHATESTENABLE, flag); break;
+	case GL_BLEND: glw_state->device->SetRenderState(D3DRS_ALPHABLENDENABLE, flag); break;
+	case GL_CULL_FACE:
+		glw_state->cullEnable = flag;
+		glw_state->device->SetRenderState(D3DRS_CULLMODE, 
+			flag ? glw_state->cullMode : D3DCULL_NONE);
+		break;
+	case GL_DEPTH_TEST: glw_state->device->SetRenderState(D3DRS_ZENABLE, flag); break;
+	case GL_LIGHTING: glw_state->device->SetRenderState(D3DRS_LIGHTING, flag); break;
+#ifdef _XBOX
+	case GL_POLYGON_OFFSET_POINT:
+		glw_state->device->SetRenderState(D3DRS_POINTOFFSETENABLE, flag);
+		break;
+	case GL_POLYGON_OFFSET_LINE:
+		glw_state->device->SetRenderState(D3DRS_WIREFRAMEOFFSETENABLE, flag);
+		break;
+	case GL_POLYGON_OFFSET_FILL:
+		glw_state->device->SetRenderState(D3DRS_SOLIDOFFSETENABLE, flag);
+		break;
+	case GL_SCISSOR_TEST:
+		glw_state->scissorEnable = flag;
+		glw_state->device->SetScissors(flag ? 1 : 0, FALSE, &glw_state->scissorBox);
+		break;
+#endif
+	case GL_STENCIL_TEST: glw_state->device->SetRenderState(D3DRS_STENCILENABLE, flag); break;
+	case GL_TEXTURE_2D: 
+		glw_state->textureStageEnable[glw_state->serverTU] = flag;
+		glw_state->textureStageDirty[glw_state->serverTU] = true;
+		break;
+	case GL_FOG:
+		glw_state->device->SetRenderState(D3DRS_FOGENABLE, flag);
+		break;
+#ifdef _XBOX
+	case GL_VSYNC:
+		setPresent(flag);
+		break;
+#endif
+	default: break;
+	}
+}
+
+static void dllDisable(GLenum cap)
+{
+	setCap(cap, false);
+}
+
+static void setArrayState(GLenum cap, bool state)
+{
+	switch (cap)
+	{
+	case GL_COLOR_ARRAY: glw_state->colorArrayState = state; break; 
+	case GL_TEXTURE_COORD_ARRAY: glw_state->texCoordArrayState[glw_state->clientTU] = state; break;
+	case GL_VERTEX_ARRAY: glw_state->vertexArrayState = state; break;
+	case GL_NORMAL_ARRAY: glw_state->normalArrayState = state; break;
+	}
+}
+
+static void dllDisableClientState(GLenum array)
+{
+	assert(!glw_state->inDrawBlock);
+	setArrayState(array, false);
+}
+
+#ifdef _WINDOWS
+static void _convertQuadsToTris(GLint first, GLsizei count)
+{
+	glw_state->vertexPointerBack = glw_state->vertexPointer;
+	glw_state->normalPointerBack = glw_state->normalPointer;
+	glw_state->colorPointerBack = glw_state->colorPointer;
+	glw_state->texCoordPointerBack[0] = glw_state->texCoordPointer[0];
+	glw_state->texCoordPointerBack[1] = glw_state->texCoordPointer[1];
+	
+	{
+		glw_state->vertexPointer = 
+			Z_Malloc(count * glw_state->vertexStride * 3 / 2, 
+			TAG_TEMP_WORKSPACE, qfalse);
+		for (int i = 0; i < count; i += 4)
+		{
+			int stride = glw_state->vertexStride / sizeof(float);
+			float* dst = (float*)glw_state->vertexPointer + (i * 3 / 2) * stride;
+			const float* src = (const float*)glw_state->vertexPointerBack + 
+				(first + i) * stride;
+			
+			for (int j = 0; j < 3; ++j)
+			{
+				dst[0 * stride + j] = src[0 * stride + j];
+				dst[1 * stride + j] = src[1 * stride + j];
+				dst[2 * stride + j] = src[2 * stride + j];
+				dst[3 * stride + j] = src[0 * stride + j];
+				dst[4 * stride + j] = src[2 * stride + j];
+				dst[5 * stride + j] = src[3 * stride + j];
+			}
+		}
+	}
+	
+	if (glw_state->normalArrayState)
+	{
+		glw_state->normalPointer = 
+			Z_Malloc(count * glw_state->normalStride * 3 / 2, 
+			TAG_TEMP_WORKSPACE, qfalse);
+		
+		for (int i = 0; i < count; i += 4)
+		{
+			int stride = glw_state->normalStride / sizeof(float);
+			float* dst = (float*)glw_state->normalPointer + (i * 3 / 2) * stride;
+			const float* src = (const float*)glw_state->normalPointerBack + 
+				(first + i) * stride;
+			
+			for (int j = 0; j < 3; ++j)
+			{
+				dst[0 * stride + j] = src[0 * stride + j];
+				dst[1 * stride + j] = src[1 * stride + j];
+				dst[2 * stride + j] = src[2 * stride + j];
+				dst[3 * stride + j] = src[0 * stride + j];
+				dst[4 * stride + j] = src[2 * stride + j];
+				dst[5 * stride + j] = src[3 * stride + j];
+			}
+		}
+	}
+	
+	if (glw_state->colorArrayState)
+	{
+		glw_state->colorPointer = 
+			Z_Malloc(count * glw_state->colorStride * 3 / 2, 
+			TAG_TEMP_WORKSPACE, qfalse);
+		
+		for (int i = 0; i < count; i += 4)
+		{
+			int stride = glw_state->colorStride / sizeof(DWORD);
+			DWORD* dst = (DWORD*)glw_state->colorPointer + (i * 3 / 2) * stride;
+			const DWORD* src = (const DWORD*)glw_state->colorPointerBack + 
+				(first + i) * stride;
+			
+			dst[0 * stride] = src[0 * stride];
+			dst[1 * stride] = src[1 * stride];
+			dst[2 * stride] = src[2 * stride];
+			dst[3 * stride] = src[0 * stride];
+			dst[4 * stride] = src[2 * stride];
+			dst[5 * stride] = src[3 * stride];
+		}
+	}
+	
+	for (int t = 0; t < GLW_MAX_TEXTURE_STAGES; ++t)
+	{
+		if (glw_state->texCoordArrayState[t])
+		{
+			glw_state->texCoordPointer[t] = 
+				Z_Malloc(count * glw_state->texCoordStride[t] * 3 / 2, 
+				TAG_TEMP_WORKSPACE, qfalse);
+			
+			for (int i = 0; i < count; i += 4)
+			{
+				int stride = glw_state->texCoordStride[t] / sizeof(float);
+				float* dst = (float*)glw_state->texCoordPointer[t] + (i * 3 / 2) * stride;
+				const float* src = (const float*)glw_state->texCoordPointerBack[t] + 
+					(first + i) * stride;
+				
+				for (int j = 0; j < 2; ++j)
+				{
+					dst[0 * stride + j] = src[0 * stride + j];
+					dst[1 * stride + j] = src[1 * stride + j];
+					dst[2 * stride + j] = src[2 * stride + j];
+					dst[3 * stride + j] = src[0 * stride + j];
+					dst[4 * stride + j] = src[2 * stride + j];
+					dst[5 * stride + j] = src[3 * stride + j];
+				}
+			}
+		}
+	}
+}
+
+static void _cleanupQuadsToTris(void)
+{
+	Z_Free(const_cast<void*>(glw_state->vertexPointer));
+	glw_state->vertexPointer = glw_state->vertexPointerBack;
+	
+	if (glw_state->normalArrayState)
+	{
+		Z_Free(const_cast<void*>(glw_state->normalPointer));
+		glw_state->normalPointer = glw_state->normalPointerBack;
+	}
+	
+	if (glw_state->colorArrayState)
+	{
+		Z_Free(const_cast<void*>(glw_state->colorPointer));
+		glw_state->colorPointer = glw_state->colorPointerBack;
+	}
+
+	for (int t = 0; t < GLW_MAX_TEXTURE_STAGES; ++t)
+	{
+		if (glw_state->texCoordArrayState[t])
+		{
+			Z_Free(const_cast<void*>(glw_state->texCoordPointer[t]));
+			glw_state->texCoordPointer[t] = glw_state->texCoordPointerBack[t];
+		}
+	}
+}
+#endif
+
+// NOTE: This is a core draw routine.  It should be fast.
+static void dllDrawArrays(GLenum mode, GLint first, GLsizei count)
+{
+#ifdef _WINDOWS
+	if (mode == GL_QUADS)
+	{
+		_convertQuadsToTris(first, count);
+		count = count * 3 / 2;
+		first = 0;
+	}
+#endif
+
+	// start the draw mode
+	qglBeginEXT(mode, count, glw_state->colorArrayState ? count : 0, 
+		glw_state->normalArrayState ? count : 0,
+		glw_state->texCoordArrayState[0] ? count : 0,
+		glw_state->texCoordArrayState[1] ? count : 0);
+
+	// get the draw function we need
+	drawarrayfunc_t func = _drawArrayFuncTable[_getDrawFunc()];
+
+#ifndef _XBOX
+	DWORD* base = glw_state->drawArray;
+#endif
+
+	int inc = glw_state->maxVertices;
+	// loop taking care not to draw too much at a time
+	for (int start = first; ; start += inc)//glw_state->maxVertices)
+	{
+		// draw glw_state->maxVertices amount of geometry
+		func(start, start + glw_state->maxVertices);
+		
+		// are we done yet?
+		glw_state->totalVertices -= glw_state->maxVertices;
+		if (glw_state->totalVertices <= 0)
+		{
+			glw_state->numVertices = glw_state->maxVertices;
+			break;
+		}
+		
+		// ready for another cycle
+		glw_state->drawArray += glw_state->maxVertices *
+			glw_state->drawStride;
+		glw_state->maxVertices = _getMaxVerts();
+
+		glw_state->drawArray = _restartDrawPacket(
+			glw_state->drawArray, glw_state->maxVertices); 
+	}
+	
+#ifndef _XBOX
+	glw_state->drawArray = base;
+#endif
+
+#ifdef _WINDOWS
+	if (mode == GL_QUADS)
+	{
+		_cleanupQuadsToTris();
+	}
+#endif
+
+	// finish up the draw
+	qglEnd();
+}
+
+static void dllDrawBuffer(GLenum mode)
+{
+	//FIXME
+}
+
+
+static void PushIndices(GLsizei count, const GLushort *indices)
+{
+	// open the index packet
+	// can only send 2047 indices thru at a time
+	// BUT, Microsoft recommends 511 pairs at a time (?)
+	int num_packets, numpairs, cnt;
+	bool singleindex = false;
+
+	numpairs = count / 2;
+
+	if(numpairs <= 511) 
+	{
+		num_packets = 1;
+
+		if(glw_state->maxIndices % 2)
+		{
+			glw_state->maxIndices -= 1;
+			singleindex = true;
+		}
+	} else 
+	{
+		num_packets = (count / glw_state->maxIndices) + (!!(count % glw_state->maxIndices));
+	}
+	
+	glw_state->drawArray = _restartIndexPacket(glw_state->drawArray, glw_state->maxIndices);
+
+	int inc = glw_state->maxIndices;
+	for (int start = 0; ; start += inc)
+	{
+		for(int i = start; i < start + glw_state->maxIndices; i += 2)
+		{
+			*glw_state->drawArray++ = (DWORD)(((WORD)indices[i + 1] << 16) + (WORD)indices[i]);
+		}
+		// are we done yet?
+		glw_state->totalIndices -= glw_state->maxIndices;
+		if (glw_state->totalIndices <= 1)
+		{
+			glw_state->numIndices = glw_state->maxIndices;
+			break;
+		}
+
+		// ready for another cycle
+		//glw_state->drawArray += glw_state->maxVertices * glw_state->drawStride;
+		glw_state->maxIndices = _getMaxIndices();
+
+		if(glw_state->maxIndices % 2)
+		{
+			glw_state->maxIndices -= 1;
+			singleindex = true;
+		}
+
+		glw_state->drawArray = _restartIndexPacket(glw_state->drawArray, glw_state->maxIndices);
+	}
+
+#define CMD_DRAW_INDEX_LAST 0x1808 
+	if(singleindex)
+	{
+		*glw_state->drawArray++ = D3DPUSH_ENCODE(CMD_DRAW_INDEX_LAST, 1);
+		*glw_state->drawArray++ = indices[count - 1];
+	}
+}
+
+// NOTE: This is a core draw routine.  It should be fast.
+static void dllDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)
+{
+	int normals, tex0, tex1, num_streams = 2;
+
+	assert(type == GL_UNSIGNED_SHORT);
+
+	normals = glw_state->normalArrayState ? tess.numVertexes : 0;
+	tex0 = glw_state->texCoordArrayState[0] ? tess.numVertexes : 0;
+	tex1 = glw_state->texCoordArrayState[1] ? tess.numVertexes : 0;
+
+	num_streams += ((normals > 0) + (tex0 > 0) + (tex1 > 0));
+
+	// start the draw block
+	glw_state->inDrawBlock = true;
+	glw_state->primitiveMode = _convertPrimMode(mode);
+
+	// update DX with any pending state changes
+	_updateDrawStride(normals, tex0, tex1);
+	_updateShader(normals, tex0, tex1);
+	_updateTextures();
+	_updateMatrices();
+
+	glw_state->drawStride += normals ? 2 : 1;
+
+	glw_state->numIndices = 0;
+	glw_state->totalIndices = count;
+	glw_state->maxIndices = _getMaxIndices();
+
+	glw_state->device->SetStreamSource(0, NULL, glw_state->drawStride * 4);
+
+	int vert_size = glw_state->drawStride * tess.numVertexes;
+	int index_size = count / 2; 
+
+	glw_state->device->BeginPush(vert_size + index_size + 60, &glw_state->drawArray);
+
+	glw_state->drawArray = (DWORD*)*((DWORD*)glw_state->device);
+
+	DWORD *jumpaddress = 0, *stream = 0;
+
+	// Determine where the end of the vertex data is gonna be,
+	// that's where we're going to jump to
+	jumpaddress = (DWORD*)*((DWORD*)glw_state->device) + (vert_size + 1);
+
+	// Write the jump address
+	*glw_state->drawArray++ = ((DWORD)jumpaddress & 0x7fffffff) | 1;
+
+	// Set up our own fake vertex buffer
+	stream = glw_state->drawArray;
+
+	memcpy(glw_state->drawArray, tess.xyz, sizeof(vec4_t) * tess.numVertexes);
+	glw_state->drawArray += tess.numVertexes * 4;
+
+	if(normals)
+	{
+		memcpy(glw_state->drawArray, tess.normal, sizeof(vec4_t) * tess.numVertexes);
+		glw_state->drawArray += tess.numVertexes * 4;
+	}
+
+	if(glw_state->colorArrayState)
+	{
+		memcpy(glw_state->drawArray, tess.svars.colors, sizeof(D3DCOLOR) * tess.numVertexes);
+	}
+	else
+	{
+		for( int v = 0; v < tess.numVertexes; ++v )
+			glw_state->drawArray[v] = glw_state->currentColor;
+	}
+	glw_state->drawArray += tess.numVertexes;
+
+	if(tex0)
+	{
+		memcpy(glw_state->drawArray, tess.svars.texcoords[0], sizeof(vec2_t) * tess.numVertexes);
+		glw_state->drawArray += tess.numVertexes * 2;
+	}
+
+	if(tex1)
+	{
+		memcpy(glw_state->drawArray, tess.svars.texcoords[1], sizeof(vec2_t) * tess.numVertexes);
+		glw_state->drawArray += tess.numVertexes * 2;
+	}
+
+	// Write the vertex shader
+#define CMD_STREAM_STRIDEANDTYPE0 0x1760
+	*glw_state->drawArray++ = D3DPUSH_ENCODE(CMD_STREAM_STRIDEANDTYPE0, 16);
+	*glw_state->drawArray++ = (16 << 8)|D3DVSDT_FLOAT3;
+
+	if(1)
+	{
+		*glw_state->drawArray++ = ((glw_state->drawStride * 4) << 8) | D3DVSDT_NONE;
+	}
+
+	if(normals)
+	{
+		*glw_state->drawArray++ = (16 << 8) | D3DVSDT_FLOAT3;
+	}
+	else
+	{
+		*glw_state->drawArray++ = ((glw_state->drawStride * 4) << 8) | D3DVSDT_NONE;
+	}
+
+	*glw_state->drawArray++ = (4 << 8) | D3DVSDT_D3DCOLOR;
+
+	for(int i = 0; i < 5; i++)
+	{
+		*glw_state->drawArray++ = ((glw_state->drawStride * 4) << 8) | D3DVSDT_NONE;
+	}
+
+	if(tex0)
+	{
+		*glw_state->drawArray++ = (8 << 8) | D3DVSDT_FLOAT2;
+	}
+	else
+	{
+		*glw_state->drawArray++ = ((glw_state->drawStride * 4) << 8) | D3DVSDT_NONE;
+	}
+
+	if(tex1)
+	{
+		*glw_state->drawArray++ = (8 << 8) | D3DVSDT_FLOAT2;
+	}
+	else
+	{
+		*glw_state->drawArray++ = ((glw_state->drawStride * 4) << 8) | D3DVSDT_NONE;
+	}
+
+	for(i = 0; i < 5; i++)
+	{
+		*glw_state->drawArray++ = ((glw_state->drawStride * 4) << 8) | D3DVSDT_NONE;
+	}
+
+//	 Write the indicator to our vertex stream
+#define CMD_VERTEXSTREAM_XYZ		0x1720
+#define CMD_VERTEXSTREAM_NORMAL		0x1728
+#define CMD_VERTEXSTREAM_COLOR		0x172c
+#define CMD_VERTEXSTREAM_TEX0		0x1744
+#define CMD_VERTEXSTREAM_TEX1		0x1748
+
+	*glw_state->drawArray++ = D3DPUSH_ENCODE(CMD_VERTEXSTREAM_XYZ, 1);
+	*glw_state->drawArray++ = (DWORD)stream & 0x7fffffff;
+	stream += tess.numVertexes * 4;//3;
+
+	if(normals)
+	{
+		*glw_state->drawArray++ = D3DPUSH_ENCODE(CMD_VERTEXSTREAM_NORMAL, 1);
+		*glw_state->drawArray++ = (DWORD)stream & 0x7fffffff;
+		stream += tess.numVertexes * 4;//3;
+	}
+
+	*glw_state->drawArray++ = D3DPUSH_ENCODE(CMD_VERTEXSTREAM_COLOR, 1);
+	*glw_state->drawArray++ = (DWORD)stream & 0x7fffffff;
+	stream += tess.numVertexes;//1;
+
+	if(tex0)
+	{
+		*glw_state->drawArray++ = D3DPUSH_ENCODE(CMD_VERTEXSTREAM_TEX0, 1);
+		*glw_state->drawArray++ = (DWORD)stream & 0x7fffffff;
+		stream += tess.numVertexes * 2;//2;
+	}
+
+	if(tex1)
+	{
+		*glw_state->drawArray++ = D3DPUSH_ENCODE(CMD_VERTEXSTREAM_TEX1, 1);
+		*glw_state->drawArray++ = (DWORD)stream & 0x7fffffff;
+	}
+
+	// Send thru the index data
+	PushIndices(count, (GLushort*)indices);
+
+	// finish up the draw
+	glw_state->inDrawBlock = false;
+
+	DWORD* push = _terminateIndexPacket(glw_state->drawArray);
+
+	glw_state->device->EndPush(push);
+}
+
+static void dllDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
+{
+	assert(0);
+}
+
+static void dllEdgeFlag(GLboolean flag)
+{
+	assert(0);
+}
+
+static void dllEdgeFlagPointer(GLsizei stride, const GLvoid *pointer)
+{
+	assert(0);
+}
+
+static void dllEdgeFlagv(const GLboolean *flag)
+{
+	assert(0);
+}
+
+static void dllEnable(GLenum cap)
+{
+	setCap(cap, true);
+}
+
+static void dllEnableClientState(GLenum array)
+{
+	assert(!glw_state->inDrawBlock);
+	setArrayState(array, true);
+}
+
+static void dllEnd(void)
+{
+	assert(glw_state->inDrawBlock);
+	glw_state->inDrawBlock = false;
+#ifdef _XBOX
+	// on Xbox, just close the draw packet
+	DWORD* push = _terminateDrawPacket(
+		&glw_state->drawArray[glw_state->numVertices * 
+		glw_state->drawStride]);
+	
+	glw_state->device->EndPush(push);
+#else
+	// on the PC, use DrawPrimitiveUp (a little slow)
+	int num = 0;
+	switch (glw_state->primitiveMode)
+	{
+	case D3DPT_POINTLIST: num = glw_state->numVertices; break;
+	case D3DPT_LINELIST: num = glw_state->numVertices / 2; break;
+	case D3DPT_LINESTRIP: num = glw_state->numVertices - 1; break;
+	case D3DPT_TRIANGLELIST: num = glw_state->numVertices / 3; break;
+	case D3DPT_TRIANGLESTRIP: num = glw_state->numVertices - 2; break;
+	case D3DPT_TRIANGLEFAN: num = glw_state->numVertices - 2; break;
+	}
+	
+	glw_state->device->DrawPrimitiveUP(
+		glw_state->primitiveMode, num, 
+		glw_state->drawArray, glw_state->drawStride * sizeof(DWORD));
+#endif
+}
+
+// EXTENSION: End drawing for a frame
+static void dllEndFrame(void)
+{
+	assert(!glw_state->inDrawBlock);
+
+	// the blend state can get reset by Present()...
+	GLboolean blend = qglIsEnabled(GL_BLEND);
+	
+	glw_state->device->EndScene();
+	
+	qglViewport(0, 0, glConfig.vidWidth, glConfig.vidHeight);
+	glw_state->device->Present(NULL, NULL, NULL, NULL);
+
+	// restore the pre-Present state
+	if (blend) qglEnable(GL_BLEND);
+	else qglDisable(GL_BLEND);
+}
+
+// EXTENSION: End shadow draw mode
+static void dllEndShadow(void)
+{
+	//Intentionally left blank
+}
+
+static void dllEndList(void)
+{
+	assert(0);
+}
+
+static void dllEvalCoord1d(GLdouble u)
+{
+	assert(0);
+}
+
+static void dllEvalCoord1dv(const GLdouble *u)
+{
+	assert(0);
+}
+
+static void dllEvalCoord1f(GLfloat u)
+{
+	assert(0);
+}
+
+static void dllEvalCoord1fv(const GLfloat *u)
+{
+	assert(0);
+}
+
+static void dllEvalCoord2d(GLdouble u, GLdouble v)
+{
+	assert(0);
+}
+
+static void dllEvalCoord2dv(const GLdouble *u)
+{
+	assert(0);
+}
+
+static void dllEvalCoord2f(GLfloat u, GLfloat v)
+{
+	assert(0);
+}
+
+static void dllEvalCoord2fv(const GLfloat *u)
+{
+	assert(0);
+}
+
+static void dllEvalMesh1(GLenum mode, GLint i1, GLint i2)
+{
+	assert(0);
+}
+
+static void dllEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)
+{
+	assert(0);
+}
+
+static void dllEvalPoint1(GLint i)
+{
+	assert(0);
+}
+
+static void dllEvalPoint2(GLint i, GLint j)
+{
+	assert(0);
+}
+
+static void dllFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer)
+{
+	assert(0);
+}
+
+static void dllFinish(void)
+{
+#ifdef _XBOX
+	glw_state->device->BlockUntilIdle();
+#endif
+}
+
+static void dllFlush(void)
+{
+#ifdef _XBOX
+	glw_state->device->BlockUntilIdle();
+#endif
+}
+
+// EXTENSION: Draw the shadow
+static void dllFlushShadow(void)
+{
+	//Intentionally left blank
+}
+
+static D3DFOGMODE _convertFogMode(GLint param)
+{
+	switch(param)
+	{
+	case GL_LINEAR: return D3DFOG_LINEAR; break;
+	case GL_EXP: return D3DFOG_EXP; break;
+	case GL_EXP2: return D3DFOG_EXP2; break;
+	}
+
+	return D3DFOG_NONE;
+}
+
+static void dllFogf(GLenum pname, GLfloat param)
+{
+	assert(pname == GL_FOG_DENSITY || pname == GL_FOG_START || pname == GL_FOG_END);	
+
+	switch(pname)
+	{
+	case GL_FOG_DENSITY: glw_state->device->SetRenderState( D3DRS_FOGDENSITY, *(DWORD*)&param ); break;
+	case GL_FOG_START: glw_state->device->SetRenderState( D3DRS_FOGSTART, *(DWORD*)&param ); break;
+	case GL_FOG_END: glw_state->device->SetRenderState( D3DRS_FOGEND, *(DWORD*)&param ); break;
+	}
+}
+
+static void dllFogfv(GLenum pname, const GLfloat *params)
+{
+	assert(pname == GL_FOG_COLOR);
+
+	D3DCOLOR color = D3DCOLOR_ARGB(0x00, 
+								  (int)(params[0] * 255.0f),
+								  (int)(params[1] * 255.0f),
+								  (int)(params[2] * 255.0f));
+
+	glw_state->device->SetRenderState( D3DRS_FOGCOLOR, color );
+}
+
+static void dllFogi(GLenum pname, GLint param)
+{
+	assert(pname == GL_FOG_MODE);
+
+	glw_state->device->SetRenderState( D3DRS_FOGTABLEMODE, _convertFogMode(param) );
+}
+
+static void dllFogiv(GLenum pname, const GLint *params)
+{
+	assert(0);
+}
+
+static void dllFrontFace(GLenum mode)
+{
+	assert(0);
+}
+
+static void dllFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
+{
+	D3DXMATRIX m;
+	D3DXMatrixPerspectiveOffCenterRH(&m, left, right, bottom, top, zNear, zFar);
+	glw_state->matrixStack[glw_state->matrixMode]->MultMatrix(&m);
+	glw_state->matricesDirty[glw_state->matrixMode] = true;
+}
+
+GLuint dllGenLists(GLsizei range)
+{
+	assert(0);
+	return 0;
+}
+
+static void dllGenTextures(GLsizei n, GLuint *textures)
+{
+	for (int i = 0; i < n; ++i)
+	{
+		textures[i] = glw_state->textureBindNum++;
+	}
+}
+
+// Implemented only the states we use.
+template <typename T>
+static void _getState(GLenum pname, T *params)
+{
+	switch (pname)
+	{
+	case GL_CULL_FACE: params[0] = (T)glw_state->cullEnable; break;
+	case GL_MAX_TEXTURE_SIZE: params[0] = (T)512; break;
+	case GL_MAX_ACTIVE_TEXTURES_ARB: params[0] = GLW_MAX_TEXTURE_STAGES; break;
+	default:
+		assert(0);
+		params[0] = (T)0;
+		break;
+	}
+}
+
+static void dllGetBooleanv(GLenum pname, GLboolean *params)
+{
+	_getState(pname, params);
+}
+
+static void dllGetClipPlane(GLenum plane, GLdouble *equation)
+{
+	assert(0);
+}
+
+static void dllGetDoublev(GLenum pname, GLdouble *params)
+{
+	_getState(pname, params);
+}
+
+GLenum dllGetError(void)
+{
+	return 0;
+}
+
+static void dllGetFloatv(GLenum pname, GLfloat *params)
+{
+	_getState(pname, params);
+}
+
+static void dllGetIntegerv(GLenum pname, GLint *params)
+{
+	_getState(pname, params);
+}
+
+static void dllGetLightfv(GLenum light, GLenum pname, GLfloat *params)
+{
+	assert(0);
+}
+
+static void dllGetLightiv(GLenum light, GLenum pname, GLint *params)
+{
+	assert(0);
+}
+
+static void dllGetMapdv(GLenum target, GLenum query, GLdouble *v)
+{
+	assert(0);
+}
+
+static void dllGetMapfv(GLenum target, GLenum query, GLfloat *v)
+{
+	assert(0);
+}
+
+static void dllGetMapiv(GLenum target, GLenum query, GLint *v)
+{
+	assert(0);
+}
+
+static void dllGetMaterialfv(GLenum face, GLenum pname, GLfloat *params)
+{
+	assert(0);
+}
+
+static void dllGetMaterialiv(GLenum face, GLenum pname, GLint *params)
+{
+	assert(0);
+}
+
+static void dllGetPixelMapfv(GLenum map, GLfloat *values)
+{
+	assert(0);
+}
+
+static void dllGetPixelMapuiv(GLenum map, GLuint *values)
+{
+	assert(0);
+}
+
+static void dllGetPixelMapusv(GLenum map, GLushort *values)
+{
+	assert(0);
+}
+
+static void dllGetPointerv(GLenum pname, GLvoid* *params)
+{
+	assert(0);
+}
+
+static void dllGetPolygonStipple(GLubyte *mask)
+{
+	assert(0);
+}
+
+const GLubyte * dllGetString(GLenum name)
+{
+	switch (name)
+	{
+	case GL_VENDOR: return (const unsigned char*)"Vicarious Visions";
+	case GL_RENDERER: return (const unsigned char*)"Optimized DX8/OpenGL Layer";
+	case GL_VERSION: return (const unsigned char*)"0.1";
+	case GL_EXTENSIONS:
+		return (const unsigned char*)
+			"EXT_texture_env_add GL_ARB_multitexture EXT_texture_filter_anisotropic";
+	default: return (const unsigned char*)"";
+	}
+}
+
+static void dllGetTexEnvfv(GLenum target, GLenum pname, GLfloat *params)
+{
+	assert(0);
+}
+
+static void dllGetTexEnviv(GLenum target, GLenum pname, GLint *params)
+{
+	assert(0);
+}
+
+static void dllGetTexGendv(GLenum coord, GLenum pname, GLdouble *params)
+{
+	assert(0);
+}
+
+static void dllGetTexGenfv(GLenum coord, GLenum pname, GLfloat *params)
+{
+	assert(0);
+}
+
+static void dllGetTexGeniv(GLenum coord, GLenum pname, GLint *params)
+{
+	assert(0);
+}
+
+static void dllGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels)
+{
+	assert(0);
+}
+
+static void dllGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params)
+{
+	assert(0);
+}
+
+static void dllGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params)
+{
+	assert(0);
+}
+
+static void dllGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params)
+{
+	assert(0);
+}
+
+static void dllGetTexParameteriv(GLenum target, GLenum pname, GLint *params)
+{
+	assert(0);
+}
+
+static void dllHint(GLenum target, GLenum mode)
+{
+	assert(0);
+}
+
+// Convert an triangle index array (indices) to a 
+// triangle strip index array (dest) with primitive 
+// length array.
+static void buildStrips(GLuint* len, GLsizei* num_lens, GLushort* dest, GLsizei* num_indices, const GLushort* src)
+{
+	GLushort last[3];
+
+	// prime the strip
+	GLsizei cur_index = 0;
+	dest[cur_index++] = src[0];
+	dest[cur_index++] = src[1];
+	dest[cur_index++] = src[2];
+	GLuint cur_length = 3;
+	GLsizei num_strips = 0;
+
+	GLuint max_length = GLW_MAX_DRAW_PACKET_SIZE / glw_state->drawStride;
+	
+	last[0] = src[0];
+	last[1] = src[1];
+	last[2] = src[2];
+
+	qboolean even = qfalse;
+
+	for ( GLsizei i = 3; i < *num_indices; i += 3 )
+	{
+		// odd numbered triangle in potential strip
+		if ( !even )
+		{
+			// check previous triangle to see if we're continuing a strip
+			if ( ( src[i+0] == last[2] ) && ( src[i+1] == last[1] ) &&
+				cur_length < max_length )
+			{
+				++cur_length;
+				dest[cur_index++] = src[i+2];
+				even = qtrue;
+			}
+			// otherwise we're done with this strip so finish it and start
+			// a new one
+			else
+			{
+				len[num_strips++] = cur_length;
+				cur_length = 3;
+
+				dest[cur_index++] = src[i+0];
+				dest[cur_index++] = src[i+1];
+				dest[cur_index++] = src[i+2];
+
+				even = qfalse;
+			}
+		}
+		else
+		{
+			// check previous triangle to see if we're continuing a strip
+			if ( ( last[2] == src[i+1] ) && ( last[0] == src[i+0] ) &&
+				cur_length < max_length )
+			{
+				++cur_length;
+				dest[cur_index++] = src[i+2];
+				even = qfalse;
+			}
+			// otherwise we're done with this strip so finish it and start
+			// a new one
+			else
+			{
+				len[num_strips++] = cur_length;
+				cur_length = 3;
+
+				dest[cur_index++] = src[i+0];
+				dest[cur_index++] = src[i+1];
+				dest[cur_index++] = src[i+2];
+
+				even = qfalse;
+			}
+		}
+
+		// cache the last three vertices
+		last[0] = src[i+0];
+		last[1] = src[i+1];
+		last[2] = src[i+2];
+	}
+
+	len[num_strips++] = cur_length;
+	*num_lens = num_strips;
+	*num_indices = cur_index;
+
+	assert(num_strips <= GLW_MAX_STRIPS);
+}
+
+#ifdef _XBOX
+void renderObject_Light()
+{
+	int i;
+
+	// start the draw mode
+	assert(!glw_state->inDrawBlock);
+
+	glw_state->inDrawBlock = true;
+	glw_state->primitiveMode = D3DPT_TRIANGLELIST;
+
+	glw_state->drawStride = 14;
+
+	glw_state->numIndices = 0;
+	glw_state->totalIndices = tess.numIndexes;
+	glw_state->maxIndices = _getMaxIndices();
+
+	glw_state->device->SetStreamSource(0, NULL, glw_state->drawStride * 4);	
+
+	int vert_size = glw_state->drawStride * tess.numVertexes;
+	int index_size = tess.numIndexes / 2;
+	
+	glw_state->device->BeginPush(vert_size + index_size + 60, &glw_state->drawArray);
+
+	glw_state->drawArray = (DWORD*)*((DWORD*)glw_state->device);
+
+	DWORD *jumpaddress = 0, *stream = 0;
+
+	// Determine where the end of the vertex data is gonna be,
+	// that's where we're going to jump to
+	jumpaddress = (DWORD*)*((DWORD*)glw_state->device) + (vert_size + 1);
+
+	// Write the jump address
+	*glw_state->drawArray++ = ((DWORD)jumpaddress & 0x7fffffff) | 1;
+
+	// Set up our own fake vertex buffer
+	stream = glw_state->drawArray;
+
+	memcpy(glw_state->drawArray, tess.xyz, sizeof(vec4_t) * tess.numVertexes);
+	glw_state->drawArray += tess.numVertexes * 4;
+
+	memcpy(glw_state->drawArray, tess.normal, sizeof(vec4_t) * tess.numVertexes);
+	glw_state->drawArray += tess.numVertexes * 4;
+
+	memcpy(glw_state->drawArray, tess.svars.texcoords[0], sizeof(vec2_t) * tess.numVertexes);
+	glw_state->drawArray += tess.numVertexes * 2;
+
+	memcpy(glw_state->drawArray, tess.tangent, sizeof(vec4_t) * tess.numVertexes);
+	glw_state->drawArray += tess.numVertexes * 4;
+
+	// Write the vertex shader
+#define CMD_STREAM_STRIDEANDTYPE0 0x1760
+	*glw_state->drawArray++ = D3DPUSH_ENCODE(CMD_STREAM_STRIDEANDTYPE0, 16);
+
+	// Position
+	*glw_state->drawArray++ = (16 << 8)|D3DVSDT_FLOAT3;
+
+	// Normal
+	*glw_state->drawArray++ = (16 << 8) | D3DVSDT_FLOAT3;
+
+	// Tex Coord
+	*glw_state->drawArray++ = (8 << 8) | D3DVSDT_FLOAT2;
+
+	// Tangent
+	*glw_state->drawArray++ = (16 << 8) | D3DVSDT_FLOAT3;
+
+	for(i = 0; i < 12; i++)
+	{
+		*glw_state->drawArray++ = ((glw_state->drawStride * 4) << 8) | D3DVSDT_NONE;
+	}
+
+	//	 Write the indicator to our vertex stream
+	*glw_state->drawArray++ = D3DPUSH_ENCODE(0x1720, 1);
+	*glw_state->drawArray++ = (DWORD)stream & 0x7fffffff;
+	stream += tess.numVertexes * 4;
+
+	*glw_state->drawArray++ = D3DPUSH_ENCODE(0x1724, 1);
+	*glw_state->drawArray++ = (DWORD)stream & 0x7fffffff;
+	stream += tess.numVertexes * 4;
+
+	*glw_state->drawArray++ = D3DPUSH_ENCODE(0x1728, 1);
+	*glw_state->drawArray++ = (DWORD)stream & 0x7fffffff;
+	stream += tess.numVertexes * 2;
+
+	*glw_state->drawArray++ = D3DPUSH_ENCODE(0x172c, 1);
+	*glw_state->drawArray++ = (DWORD)stream & 0x7fffffff;
+	stream += tess.numVertexes * 4;
+
+	// Send thru the index data
+	PushIndices(tess.numIndexes, (GLushort*)tess.indexes);
+
+	// finish up the draw
+	glw_state->inDrawBlock = false;
+
+	DWORD* push = _terminateIndexPacket(glw_state->drawArray);
+
+	glw_state->device->EndPush(push);
+}
+
+void renderObject_Bump()
+{
+	// start the draw mode
+	assert(!glw_state->inDrawBlock);
+
+	glw_state->inDrawBlock = true;
+	glw_state->primitiveMode = D3DPT_TRIANGLELIST;
+
+	glw_state->drawStride = 16;
+
+	glw_state->numIndices = 0;
+	glw_state->totalIndices = tess.numIndexes;
+	glw_state->maxIndices = _getMaxIndices();
+
+	glw_state->device->SetStreamSource(0, NULL, glw_state->drawStride * 4);	
+
+	int vert_size = glw_state->drawStride * tess.numVertexes;
+	int index_size = tess.numIndexes / 2;
+
+	glw_state->device->BeginPush(vert_size + index_size + 60, &glw_state->drawArray);
+
+	glw_state->drawArray = (DWORD*)*((DWORD*)glw_state->device);
+
+	DWORD *jumpaddress = 0, *stream = 0;
+
+	// Determine where the end of the vertex data is gonna be,
+	// that's where we're going to jump to
+	jumpaddress = (DWORD*)*((DWORD*)glw_state->device) + (vert_size + 1);
+
+	// Write the jump address
+	*glw_state->drawArray++ = ((DWORD)jumpaddress & 0x7fffffff) | 1;
+
+	// Set up our own fake vertex buffer
+	stream = glw_state->drawArray;
+
+	memcpy(glw_state->drawArray, tess.xyz, sizeof(vec4_t) * tess.numVertexes);
+	glw_state->drawArray += tess.numVertexes * 4;
+
+	memcpy(glw_state->drawArray, tess.normal, sizeof(vec4_t) * tess.numVertexes);
+	glw_state->drawArray += tess.numVertexes * 4;
+
+	memcpy(glw_state->drawArray, tess.svars.texcoords[0], sizeof(vec2_t) * tess.numVertexes);
+	glw_state->drawArray += tess.numVertexes * 2;
+
+	memcpy(glw_state->drawArray, tess.svars.texcoords[1], sizeof(vec2_t) * tess.numVertexes);
+	glw_state->drawArray += tess.numVertexes * 2;
+
+	memcpy(glw_state->drawArray, tess.tangent, sizeof(vec4_t) * tess.numVertexes);
+	glw_state->drawArray += tess.numVertexes * 4;
+
+	// Write the vertex shader
+#define CMD_STREAM_STRIDEANDTYPE0 0x1760
+	*glw_state->drawArray++ = D3DPUSH_ENCODE(CMD_STREAM_STRIDEANDTYPE0, 16);
+
+	// Position
+	*glw_state->drawArray++ = (16 << 8)|D3DVSDT_FLOAT3;
+
+	// Normal
+	*glw_state->drawArray++ = (16 << 8) | D3DVSDT_FLOAT3;
+
+	// Tex Coord 0
+	*glw_state->drawArray++ = (8 << 8) | D3DVSDT_FLOAT2;
+
+	// Tex Coord 1
+	*glw_state->drawArray++ = (8 << 8) | D3DVSDT_FLOAT2;
+
+	// Tangent
+	*glw_state->drawArray++ = (16 << 8) | D3DVSDT_FLOAT3;
+
+	for(int i = 0; i < 11; i++)
+	{
+		*glw_state->drawArray++ = ((glw_state->drawStride * 4) << 8) | D3DVSDT_NONE;
+	}
+
+	//	 Write the indicator to our vertex stream
+	*glw_state->drawArray++ = D3DPUSH_ENCODE(0x1720, 1);
+	*glw_state->drawArray++ = (DWORD)stream & 0x7fffffff;
+	stream += tess.numVertexes * 4;
+
+	*glw_state->drawArray++ = D3DPUSH_ENCODE(0x1724, 1);
+	*glw_state->drawArray++ = (DWORD)stream & 0x7fffffff;
+	stream += tess.numVertexes * 4;
+
+	*glw_state->drawArray++ = D3DPUSH_ENCODE(0x1728, 1);
+	*glw_state->drawArray++ = (DWORD)stream & 0x7fffffff;
+	stream += tess.numVertexes * 2;
+
+	*glw_state->drawArray++ = D3DPUSH_ENCODE(0x172c, 1);
+	*glw_state->drawArray++ = (DWORD)stream & 0x7fffffff;
+	stream += tess.numVertexes * 2;
+
+	*glw_state->drawArray++ = D3DPUSH_ENCODE(0x1730, 1);
+	*glw_state->drawArray++ = (DWORD)stream & 0x7fffffff;
+	stream += tess.numVertexes * 4;
+
+	// Send thru the index data
+	PushIndices(tess.numIndexes, (GLushort*)tess.indexes);
+
+	// finish up the draw
+	glw_state->inDrawBlock = false;
+
+	DWORD* push = _terminateIndexPacket(glw_state->drawArray);
+
+	glw_state->device->EndPush(push);
+}
+
+void renderObject_Env()
+{
+	// start the draw mode
+	assert(!glw_state->inDrawBlock);
+
+	glw_state->inDrawBlock = true;
+	glw_state->primitiveMode = D3DPT_TRIANGLELIST;
+
+	glw_state->drawStride = 9;
+	_updateTextures();
+
+	glw_state->numIndices = 0;
+	glw_state->totalIndices = tess.numIndexes;
+	glw_state->maxIndices = _getMaxIndices();
+
+	glw_state->device->SetStreamSource(0, NULL, glw_state->drawStride * 4);	
+
+	int vert_size = glw_state->drawStride * tess.numVertexes;
+	int index_size = tess.numIndexes / 2;
+
+	glw_state->device->BeginPush(vert_size + index_size + 60, &glw_state->drawArray);
+
+	glw_state->drawArray = (DWORD*)*((DWORD*)glw_state->device);
+
+	DWORD *jumpaddress = 0, *stream = 0;
+
+	// Determine where the end of the vertex data is gonna be,
+	// that's where we're going to jump to
+	jumpaddress = (DWORD*)*((DWORD*)glw_state->device) + (vert_size + 1);
+
+	// Write the jump address
+	*glw_state->drawArray++ = ((DWORD)jumpaddress & 0x7fffffff) | 1;
+
+	// Set up our own fake vertex buffer
+	stream = glw_state->drawArray;
+
+	memcpy(glw_state->drawArray, tess.xyz, sizeof(vec4_t) * tess.numVertexes);
+	glw_state->drawArray += tess.numVertexes * 4;
+
+	memcpy(glw_state->drawArray, tess.normal, sizeof(vec4_t) * tess.numVertexes);
+	glw_state->drawArray += tess.numVertexes * 4; 
+
+	memcpy(glw_state->drawArray, tess.svars.colors, sizeof(D3DCOLOR) * tess.numVertexes);
+	glw_state->drawArray += tess.numVertexes;
+ 
+	// Write the vertex shader
+#define CMD_STREAM_STRIDEANDTYPE0 0x1760
+	*glw_state->drawArray++ = D3DPUSH_ENCODE(CMD_STREAM_STRIDEANDTYPE0, 16);
+
+	// Position
+	*glw_state->drawArray++ = (16 << 8)|D3DVSDT_FLOAT3;
+
+	// Normal
+	*glw_state->drawArray++ = (16 << 8) | D3DVSDT_FLOAT3;
+
+	// Color
+	*glw_state->drawArray++ = (4 << 8) | D3DVSDT_D3DCOLOR;
+
+	for(int i = 0; i < 13; i++)
+	{
+		*glw_state->drawArray++ = ((glw_state->drawStride * 4) << 8) | D3DVSDT_NONE;
+	}
+
+	//	 Write the indicator to our vertex stream
+	*glw_state->drawArray++ = D3DPUSH_ENCODE(0x1720, 1);
+	*glw_state->drawArray++ = (DWORD)stream & 0x7fffffff;
+	stream += tess.numVertexes * 4;
+
+	*glw_state->drawArray++ = D3DPUSH_ENCODE(0x1724, 1);
+	*glw_state->drawArray++ = (DWORD)stream & 0x7fffffff;
+	stream += tess.numVertexes * 4;
+
+	*glw_state->drawArray++ = D3DPUSH_ENCODE(0x1728, 1);
+	*glw_state->drawArray++ = (DWORD)stream & 0x7fffffff;
+	stream += tess.numVertexes;
+
+	// Send thru the index data
+	PushIndices(tess.numIndexes, (GLushort*)tess.indexes);
+
+	// finish up the draw
+	glw_state->inDrawBlock = false;
+
+	DWORD* push = _terminateIndexPacket(glw_state->drawArray);
+
+	glw_state->device->EndPush(push);
+}
+#endif
+
+// EXTENSION: Take an array of triangle indices and draw
+// the appropriate triangle strips.  Virtually ALL geometry
+// is drawn with this function so it better be fast.
+static void dllIndexedTriToStrip(GLsizei count, const GLushort *indices)
+{
+#ifndef _XBOX
+#ifdef GLW_USE_TRI_STRIPS
+
+	// update the render state
+	_updateDrawStride(glw_state->normalArrayState,
+		glw_state->texCoordArrayState[0] ? count : 0,
+		glw_state->texCoordArrayState[1] ? count : 0);
+	_updateShader(glw_state->normalArrayState,
+		glw_state->texCoordArrayState[0],
+		glw_state->texCoordArrayState[1]);
+	_updateTextures();
+	_updateMatrices();
+	
+	// convert triangles to strips -- guarantees that
+	// no strip exceeds the max draw packet size
+	if(tess.currentPass == 0)
+	{
+		buildStrips(glw_state->strip_lengths, 
+			&glw_state->num_strip_lengths, glw_state->strip_dest, &count, indices);
+	}
+
+	// Yeah, its a hack, but I gotta do this so bumpmapping
+	// doesnt go all crazy on the 'force speed' effect and 
+	// 'disintegration' effect
+	if(tess.shader && 
+		tess.shader->isBumpMap && 
+		(backEnd.currentEntity->e.renderfx & 
+// VVFIXME : This is probably wrong. It looks like RF_ALPHA_FADE is renamed
+// RF_RGB_TINT in MP. Substitute?
+#ifndef _JK2MP
+		(RF_ALPHA_FADE | RF_DISINTEGRATE1 | RF_DISINTEGRATE2)))
+#else
+		(RF_DISINTEGRATE1 | RF_DISINTEGRATE2)))
+#endif
+	{
+		if(tess.currentPass != 2)
+			return;
+	}
+
+#ifdef _XBOX
+	glw_state->primitiveMode = D3DPT_TRIANGLESTRIP;
+
+	// get the necessary draw function
+	drawelemfunc_t func = _drawElementFuncTable[_getDrawFunc()];
+	int stride = glw_state->drawStride;
+	
+	int index = 0;
+	for (int l = 0; l < glw_state->num_strip_lengths; ++l)
+	{
+		int cur_len = glw_state->strip_lengths[l];
+		
+		// start a draw packet
+		DWORD* push;
+		glw_state->device->BeginPush(stride * cur_len + 5, &push);
+		push = _restartDrawPacket(push, cur_len);
+		
+		// draw the geometry
+		glw_state->drawArray = push;
+		func(cur_len, &glw_state->strip_dest[index]);
+		index += cur_len;
+		
+		// finish the draw packet
+		push = _terminateDrawPacket(&push[stride * cur_len]);
+		glw_state->device->EndPush(push);
+	}
+#else _XBOX
+	// simplified render on the PC
+	int index = 0;
+	for (int l = 0; l < glw_state->num_strip_lengths; ++l)
+	{
+		dllDrawElements(GL_TRIANGLE_STRIP, glw_state->strip_lengths[l], 
+			GL_UNSIGNED_SHORT, &glw_state->strip_dest[index]);
+		index += glw_state->strip_lengths[l];
+	}
+#endif _XBOX
+
+#else GLW_USE_TRI_STRIPS
+	// just render simple triangles
+	dllDrawElements(GL_TRIANGLES, count, GL_UNSIGNED_SHORT, indices);
+#endif GLW_USE_TRI_STRIPS
+#endif 
+}
+
+static void dllIndexMask(GLuint mask)
+{
+	assert(0);
+}
+
+static void dllIndexPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
+{
+	assert(0);
+}
+
+static void dllIndexd(GLdouble c)
+{
+	assert(0);
+}
+
+static void dllIndexdv(const GLdouble *c)
+{
+	assert(0);
+}
+
+static void dllIndexf(GLfloat c)
+{
+	assert(0);
+}
+
+static void dllIndexfv(const GLfloat *c)
+{
+	assert(0);
+}
+
+static void dllIndexi(GLint c)
+{
+	assert(0);
+}
+
+static void dllIndexiv(const GLint *c)
+{
+	assert(0);
+}
+
+static void dllIndexs(GLshort c)
+{
+	assert(0);
+}
+
+static void dllIndexsv(const GLshort *c)
+{
+	assert(0);
+}
+
+static void dllIndexub(GLubyte c)
+{
+	assert(0);
+}
+
+static void dllIndexubv(const GLubyte *c)
+{
+	assert(0);
+}
+
+static void dllInitNames(void)
+{
+	assert(0);
+}
+
+static void dllInterleavedArrays(GLenum format, GLsizei stride, const GLvoid *pointer)
+{
+	assert(0);
+}
+
+GLboolean dllIsEnabled(GLenum cap)
+{
+	DWORD flag;
+	switch (cap)
+	{
+	case GL_ALPHA_TEST: glw_state->device->GetRenderState(D3DRS_ALPHATESTENABLE, &flag); break;
+	case GL_BLEND: glw_state->device->GetRenderState(D3DRS_ALPHABLENDENABLE, &flag); break;
+	case GL_CULL_FACE: return glw_state->cullEnable;
+	case GL_DEPTH_TEST: glw_state->device->GetRenderState(D3DRS_ZENABLE, &flag); break;
+	case GL_FOG: glw_state->device->GetRenderState(D3DRS_FOGENABLE, &flag); break;
+	case GL_LIGHTING: glw_state->device->GetRenderState(D3DRS_LIGHTING, &flag); break;
+#ifdef _XBOX
+	case GL_POLYGON_OFFSET_FILL: glw_state->device->GetRenderState(D3DRS_SOLIDOFFSETENABLE, &flag); break;
+#else
+	case GL_POLYGON_OFFSET_FILL: return FALSE;
+#endif
+	case GL_SCISSOR_TEST: return glw_state->scissorEnable;
+	case GL_STENCIL_TEST: glw_state->device->GetRenderState(D3DRS_STENCILENABLE, &flag); break;
+	case GL_TEXTURE_2D: return glw_state->textureStageEnable[glw_state->serverTU];
+	default: return FALSE;
+	}
+	return flag;
+}
+
+GLboolean dllIsList(GLuint lnum)
+{
+	assert(0);
+	return 1;
+}
+
+GLboolean dllIsTexture(GLuint texture)
+{
+	assert(0);
+	return 1;
+}
+
+static void dllLightModelf(GLenum pname, GLfloat param)
+{
+	assert(0);
+}
+
+static void dllLightModelfv(GLenum pname, const GLfloat *params)
+{
+	assert(0);
+}
+
+static void dllLightModeli(GLenum pname, GLint param)
+{
+	assert(0);
+}
+
+static void dllLightModeliv(GLenum pname, const GLint *params)
+{
+	assert(0);
+}
+
+static void dllLightf(GLenum light, GLenum pname, GLfloat param)
+{
+	assert(0);
+}
+
+static void dllLightfv(GLenum light, GLenum pname, const GLfloat *params)
+{
+	switch(pname)
+	{
+	case GL_AMBIENT:
+		{
+			glw_state->dirLight.Ambient.r = params[0] / 255.0f;
+			glw_state->dirLight.Ambient.g = params[1] / 255.0f;
+			glw_state->dirLight.Ambient.b = params[2] / 255.0f;
+		}
+		break;
+
+	case GL_DIFFUSE:
+		{
+			glw_state->dirLight.Diffuse.r = params[0] / 255.0f;
+			glw_state->dirLight.Diffuse.g = params[1] / 255.0f;
+			glw_state->dirLight.Diffuse.b = params[2] / 255.0f;
+		}
+		break;
+
+	case GL_SPECULAR:
+		{
+			glw_state->dirLight.Specular.r = params[0] / 255.0f;
+			glw_state->dirLight.Specular.g = params[1] / 255.0f;
+			glw_state->dirLight.Specular.b = params[2] / 255.0f;
+		}
+		break;
+	case GL_POSITION:
+		{
+			glw_state->dirLight.Position.x = params[0];
+			glw_state->dirLight.Position.y = params[1];
+			glw_state->dirLight.Position.z = params[2];
+		}
+		break;
+
+	case GL_SPOT_DIRECTION:
+		{
+			glw_state->dirLight.Direction.x = -params[0];
+			glw_state->dirLight.Direction.y = -params[1];
+			glw_state->dirLight.Direction.z = -params[2];
+		}
+		break;
+
+	default:
+		assert(0);
+		break;
+	}
+
+	glw_state->device->SetLight(light, &glw_state->dirLight);
+	glw_state->device->LightEnable(light, TRUE);
+}
+
+static void dllLighti(GLenum light, GLenum pname, GLint param)
+{
+	assert(0);
+}
+
+static void dllLightiv(GLenum light, GLenum pname, const GLint *params)
+{
+	assert(0);
+}
+
+static void dllLineStipple(GLint factor, GLushort pattern)
+{
+	assert(0);
+}
+
+static void dllLineWidth(GLfloat width)
+{
+//	assert(0);
+}
+
+static void dllListBase(GLuint base)
+{
+	assert(0);
+}
+
+static void dllLoadIdentity(void)
+{
+	glw_state->matrixStack[glw_state->matrixMode]->LoadIdentity();
+	glw_state->matricesDirty[glw_state->matrixMode] = true;
+}
+
+static void dllLoadMatrixd(const GLdouble *m)
+{
+	assert(0);
+}
+
+static void dllLoadMatrixf(const GLfloat *m)
+{
+	glw_state->matrixStack[glw_state->matrixMode]->LoadMatrix((D3DXMATRIX*)m);
+	glw_state->matricesDirty[glw_state->matrixMode] = true;
+}
+
+static void dllLoadName(GLuint name)
+{
+	assert(0);
+}
+
+static void dllLogicOp(GLenum opcode)
+{
+	assert(0);
+}
+
+static void dllMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points)
+{
+	assert(0);
+}
+
+static void dllMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points)
+{
+	assert(0);
+}
+
+static void dllMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points)
+{
+	assert(0);
+}
+
+static void dllMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points)
+{
+	assert(0);
+}
+
+static void dllMapGrid1d(GLint un, GLdouble u1, GLdouble u2)
+{
+	assert(0);
+}
+
+static void dllMapGrid1f(GLint un, GLfloat u1, GLfloat u2)
+{
+	assert(0);
+}
+
+static void dllMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2)
+{
+	assert(0);
+}
+
+static void dllMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2)
+{
+	assert(0);
+}
+
+static void dllMaterialf(GLenum face, GLenum pname, GLfloat param)
+{
+	assert(0);
+}
+
+static void dllMaterialfv(GLenum face, GLenum pname, const GLfloat *params)
+{
+	switch(pname)
+	{
+	case GL_AMBIENT:
+		glw_state->mtrl.Ambient.r = params[0] / 255.0f;
+		glw_state->mtrl.Ambient.g = params[1] / 255.0f;
+		glw_state->mtrl.Ambient.b = params[2] / 255.0f;
+		glw_state->mtrl.Ambient.a = params[3] / 255.0f;
+		break;
+
+	case GL_DIFFUSE:
+		glw_state->mtrl.Diffuse.r = params[0] / 255.0f;
+		glw_state->mtrl.Diffuse.g = params[1] / 255.0f;
+		glw_state->mtrl.Diffuse.b = params[2] / 255.0f;
+		glw_state->mtrl.Diffuse.a = params[3] / 255.0f;
+		break;
+
+	case GL_SPECULAR:
+		glw_state->mtrl.Specular.r = params[0] / 255.0f;
+		glw_state->mtrl.Specular.g = params[1] / 255.0f;
+		glw_state->mtrl.Specular.b = params[2] / 255.0f;
+		glw_state->mtrl.Specular.a = params[3] / 255.0f;
+		break;
+
+	case GL_EMISSION:
+		glw_state->mtrl.Emissive.r = params[0] / 255.0f;
+		glw_state->mtrl.Emissive.g = params[1] / 255.0f;
+		glw_state->mtrl.Emissive.b = params[2] / 255.0f;
+		glw_state->mtrl.Emissive.a = params[3] / 255.0f;
+		break;
+
+	default:
+		assert(0);
+		break;
+	}
+
+	glw_state->device->SetMaterial(&glw_state->mtrl);
+}
+
+static void dllMateriali(GLenum face, GLenum pname, GLint param)
+{
+	assert(0);
+}
+
+static void dllMaterialiv(GLenum face, GLenum pname, const GLint *params)
+{
+	assert(0);
+}
+
+static void dllMatrixMode(GLenum mode)
+{
+	switch (mode)
+	{
+	case GL_MODELVIEW: glw_state->matrixMode = glwstate_t::MatrixMode_Model; break;
+	case GL_PROJECTION: glw_state->matrixMode = glwstate_t::MatrixMode_Projection; break;
+#ifdef _XBOX
+	case GL_TEXTURE0: glw_state->matrixMode = glwstate_t::MatrixMode_Texture0; break;
+	case GL_TEXTURE1: glw_state->matrixMode = glwstate_t::MatrixMode_Texture1; break;
+#endif
+	default: assert(false); break;
+	}
+}
+
+static void dllMultMatrixd(const GLdouble *m)
+{
+	assert(0);
+}
+
+static void dllMultMatrixf(const GLfloat *m)
+{
+	glw_state->matrixStack[glw_state->matrixMode]->MultMatrixLocal((D3DXMATRIX*)m);
+	glw_state->matricesDirty[glw_state->matrixMode] = true;
+}
+
+static void dllNewList(GLuint lnum, GLenum mode)
+{
+	assert(0);
+}
+
+static void setNormal(float x, float y, float z)
+{
+	assert(glw_state->inDrawBlock);
+
+	_handleDrawOverflow();
+	
+	DWORD* push = &glw_state->drawArray[glw_state->numVertices * glw_state->drawStride + 4];
+	push[0] = *((DWORD*)&x);
+	push[1] = *((DWORD*)&y);
+	push[2] = *((DWORD*)&z);
+	push[3] = glw_state->currentColor;
+}
+static void dllNormal3b(GLbyte nx, GLbyte ny, GLbyte nz)
+{
+	assert(0);
+}
+
+static void dllNormal3bv(const GLbyte *v)
+{
+	assert(0);
+}
+
+static void dllNormal3d(GLdouble nx, GLdouble ny, GLdouble nz)
+{
+	assert(0);
+}
+
+static void dllNormal3dv(const GLdouble *v)
+{
+	assert(0);
+}
+
+static void dllNormal3f(GLfloat nx, GLfloat ny, GLfloat nz)
+{
+	setNormal(nx, ny, nz);
+}
+
+static void dllNormal3fv(const GLfloat *v)
+{
+	setNormal(v[0], v[1], v[2]);
+}
+
+static void dllNormal3i(GLint nx, GLint ny, GLint nz)
+{
+	assert(0);
+}
+
+static void dllNormal3iv(const GLint *v)
+{
+	assert(0);
+}
+
+static void dllNormal3s(GLshort nx, GLshort ny, GLshort nz)
+{
+	assert(0);
+}
+
+static void dllNormal3sv(const GLshort *v)
+{
+	assert(0);
+}
+
+static void dllNormalPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
+{
+	assert(type == GL_FLOAT);
+	
+	stride = (stride == 0) ? (sizeof(GLfloat) * 3) : stride;
+
+	glw_state->normalPointer = pointer;
+	glw_state->normalStride = stride;
+}
+
+static void dllOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
+{
+	D3DXMATRIX m;
+	D3DXMatrixOrthoOffCenterRH(&m, left, right, top, bottom, zNear, zFar);
+	glw_state->matrixStack[glw_state->matrixMode]->MultMatrix(&m);
+	glw_state->matricesDirty[glw_state->matrixMode] = true;
+}
+
+static void dllPassThrough(GLfloat token)
+{
+	assert(0);
+}
+
+static void dllPixelMapfv(GLenum map, GLsizei mapsize, const GLfloat *values)
+{
+	assert(0);
+}
+
+static void dllPixelMapuiv(GLenum map, GLsizei mapsize, const GLuint *values)
+{
+	assert(0);
+}
+
+static void dllPixelMapusv(GLenum map, GLsizei mapsize, const GLushort *values)
+{
+	assert(0);
+}
+
+static void dllPixelStoref(GLenum pname, GLfloat param)
+{
+	assert(0);
+}
+
+static void dllPixelStorei(GLenum pname, GLint param)
+{
+	assert(0);
+}
+
+static void dllPixelTransferf(GLenum pname, GLfloat param)
+{
+	assert(0);
+}
+
+static void dllPixelTransferi(GLenum pname, GLint param)
+{
+	assert(0);
+}
+
+static void dllPixelZoom(GLfloat xfactor, GLfloat yfactor)
+{
+	assert(0);
+}
+
+static void dllPointSize(GLfloat size)
+{
+	glw_state->device->SetRenderState(D3DRS_POINTSCALEENABLE, TRUE);
+	glw_state->device->SetRenderState(D3DRS_POINTSIZE, *((DWORD*)&size));
+}
+
+static void dllPolygonMode(GLenum face, GLenum mode)
+{
+	D3DFILLMODE m;
+	switch (mode)
+	{
+	case GL_POINT: m = D3DFILL_POINT; break;
+	case GL_LINE: m = D3DFILL_WIREFRAME; break;
+	case GL_FILL: m = D3DFILL_SOLID; break;
+	default: assert(0); break;
+	}
+
+	switch (face)
+	{
+	case GL_FRONT:
+		glw_state->device->SetRenderState(D3DRS_FILLMODE, m);
+		break;
+	case GL_BACK:
+#ifdef _XBOX
+		glw_state->device->SetRenderState(D3DRS_BACKFILLMODE, m);
+#endif
+		break;
+	case GL_FRONT_AND_BACK:
+		glw_state->device->SetRenderState(D3DRS_FILLMODE, m);
+#ifdef _XBOX
+		glw_state->device->SetRenderState(D3DRS_BACKFILLMODE, m);
+#endif
+		break;
+	}
+}
+
+static void dllPolygonOffset(GLfloat factor, GLfloat units)
+{
+#ifdef _XBOX
+	glw_state->device->SetRenderState(D3DRS_POLYGONOFFSETZOFFSET, *((DWORD*)&factor));
+	glw_state->device->SetRenderState(D3DRS_POLYGONOFFSETZSLOPESCALE, *((DWORD*)&units));
+#endif
+}
+
+static void dllPolygonStipple(const GLubyte *mask)
+{
+	assert(0);
+}
+
+static void dllPopAttrib(void)
+{
+	assert(0);
+}
+
+static void dllPopClientAttrib(void)
+{
+	assert(0);
+}
+
+static void dllPopMatrix(void)
+{
+	glw_state->matrixStack[glw_state->matrixMode]->Pop();
+	glw_state->matricesDirty[glw_state->matrixMode] = true;
+}
+
+static void dllPopName(void)
+{
+	assert(0);
+}
+
+static void dllPrioritizeTextures(GLsizei n, const GLuint *textures, const GLclampf *priorities)
+{
+	assert(0);
+}
+
+static void dllPushAttrib(GLbitfield mask)
+{
+	assert(0);
+}
+
+static void dllPushClientAttrib(GLbitfield mask)
+{
+	assert(0);
+}
+
+static void dllPushMatrix(void)
+{
+	glw_state->matrixStack[glw_state->matrixMode]->Push();
+	glw_state->matricesDirty[glw_state->matrixMode] = true;
+}
+
+static void dllPushName(GLuint name)
+{
+	assert(0);
+}
+
+static void dllRasterPos2d(GLdouble x, GLdouble y)
+{
+	assert(0);
+}
+
+static void dllRasterPos2dv(const GLdouble *v)
+{
+	assert(0);
+}
+
+static void dllRasterPos2f(GLfloat x, GLfloat y)
+{
+	assert(0);
+}
+
+static void dllRasterPos2fv(const GLfloat *v)
+{
+	assert(0);
+}
+
+static void dllRasterPos2i(GLint x, GLint y)
+{
+	assert(0);
+}
+
+static void dllRasterPos2iv(const GLint *v)
+{
+	assert(0);
+}
+
+static void dllRasterPos2s(GLshort x, GLshort y)
+{
+	assert(0);
+}
+
+static void dllRasterPos2sv(const GLshort *v)
+{
+	assert(0);
+}
+
+static void dllRasterPos3d(GLdouble x, GLdouble y, GLdouble z)
+{
+	assert(0);
+}
+
+static void dllRasterPos3dv(const GLdouble *v)
+{
+	assert(0);
+}
+
+static void dllRasterPos3f(GLfloat x, GLfloat y, GLfloat z)
+{
+	assert(0);
+}
+
+static void dllRasterPos3fv(const GLfloat *v)
+{
+	assert(0);
+}
+
+static void dllRasterPos3i(GLint x, GLint y, GLint z)
+{
+	assert(0);
+}
+
+static void dllRasterPos3iv(const GLint *v)
+{
+	assert(0);
+}
+
+static void dllRasterPos3s(GLshort x, GLshort y, GLshort z)
+{
+	assert(0);
+}
+
+static void dllRasterPos3sv(const GLshort *v)
+{
+	assert(0);
+}
+
+static void dllRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
+{
+	assert(0);
+}
+
+static void dllRasterPos4dv(const GLdouble *v)
+{
+	assert(0);
+}
+
+static void dllRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
+{
+	assert(0);
+}
+
+static void dllRasterPos4fv(const GLfloat *v)
+{
+	assert(0);
+}
+
+static void dllRasterPos4i(GLint x, GLint y, GLint z, GLint w)
+{
+	assert(0);
+}
+
+static void dllRasterPos4iv(const GLint *v)
+{
+	assert(0);
+}
+
+static void dllRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w)
+{
+	assert(0);
+}
+
+static void dllRasterPos4sv(const GLshort *v)
+{
+	assert(0);
+}
+
+static void dllReadBuffer(GLenum mode)
+{
+	assert(0);
+}
+
+//static void dllReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei twidth, GLsizei theight, GLvoid *pixels)
+static void dllReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels)
+{
+	return;
+
+	/*
+	// assert((format == GL_LIN_RGB8) && (type == GL_UNSIGNED_BYTE));
+
+	// create a temporary storage surface 
+	IDirect3DSurface8 *target;
+	glw_state->device->CreateImageSurface(twidth, theight, D3DFMT_A8R8G8B8, &target);
+
+	// get a pointer to the back buffer
+	IDirect3DSurface8* screen;
+	glw_state->device->GetBackBuffer(0, D3DBACKBUFFER_TYPE_MONO, &screen);
+	
+	// copy the back buffer into a surface of the appropriate size and format	
+	RECT r;
+	r.left = x;
+	r.top = y;
+	r.right = x + width;
+	r.bottom = y + height;
+	D3DXLoadSurfaceFromSurface(target, NULL, NULL, screen, NULL, &r, D3DX_DEFAULT, 0);
+	screen->Release();
+
+	// lock the target surface
+	D3DLOCKED_RECT lock;
+	target->LockRect(&lock, NULL, D3DLOCK_READONLY);
+
+	// copy the pixel data
+	for (int y = 0; y < theight; ++y)
+	{
+		memcpy((char*)pixels + twidth * y * 4, 
+			(char*)lock.pBits + lock.Pitch * y, 
+			twidth * 4);
+	}
+
+	// all done
+	target->UnlockRect();
+	target->Release();
+	*/
+
+	/*
+	// create target storage surface
+	IDirect3DSurface8 *target;
+	glw_state->device->CreateImageSurface(twidth, theight, D3DFMT_A8R8G8B8, &target);
+
+	// get a pointer to the back buffer
+	IDirect3DSurface8* back;
+	glw_state->device->GetBackBuffer(0, D3DBACKBUFFER_TYPE_MONO, &back);
+
+	D3DSURFACE_DESC ddsd;
+	back->GetDesc(&ddsd);
+	int bpp = XGBytesPerPixelFromFormat(ddsd.Format);
+	
+	// create surface to hold screen data
+	// (512x512 is exactly big enough to hold the screen but we
+	// need to save some memory so I'm going to clip the edges)
+	IDirect3DSurface8 *screen;
+	glw_state->device->CreateImageSurface(512, 512, ddsd.Format, &screen);
+
+	// copy back buffer to non-tiled screen surface
+	RECT r;
+	r.left = 64;
+	r.top = 0;
+	r.right = 576;
+	r.bottom = 480;
+	POINT ul = {0, 0};
+	glw_state->device->CopyRects(back, &r, 1, screen, &ul);
+	back->Release();
+
+	// deswizzle the screen
+	D3DLOCKED_RECT lock;
+	screen->LockRect(&lock, NULL, D3DLOCK_READONLY);
+	void* deswizzled = Z_Malloc(512*512*bpp, TAG_TEMP_WORKSPACE, qfalse, 16);
+	XGUnswizzleRect(lock.pBits, 512, 512, NULL, deswizzled, 0, NULL, bpp);
+	screen->UnlockRect();
+	screen->Release();
+	
+	// copy the screen into a surface of the appropriate size and format	
+	r.left = 0;
+	r.top = 0;
+	r.right = 512;
+	r.bottom = 480;
+	D3DXLoadSurfaceFromMemory(target, NULL, NULL, deswizzled, ddsd.Format, 
+		512*bpp, NULL, &r, D3DX_DEFAULT, 0);
+	Z_Free(deswizzled);
+
+	// lock the target surface
+	target->LockRect(&lock, NULL, D3DLOCK_READONLY);
+
+	// copy the pixel data
+	for (int y = 0; y < theight; ++y)
+	{
+		memcpy((char*)pixels + twidth * y * 4, 
+			(char*)lock.pBits + lock.Pitch * y, 
+			twidth * 4);
+	}
+
+	// all done
+	target->UnlockRect();
+	target->Release();
+	*/
+}
+/**********
+dllCopyBackBufferToTex
+Does a direct copy of the backbuffer to the current texture. The current texture
+must be linear, and it must be 640 x 480 in size. If a more complex copy is
+needed, use dllCopyBackBufferToTexEXT.
+**********/
+static void dllCopyBackBufferToTex()
+{
+	glwstate_t::TextureInfo* info = _getCurrentTexture(glw_state->serverTU);
+	if (info == NULL) return;
+
+	LPDIRECT3DSURFACE8 surf;
+	LPDIRECT3DSURFACE8 backbuffer;
+
+	info->mipmap->GetSurfaceLevel(0, &surf);
+	glw_state->device->GetBackBuffer(0, D3DBACKBUFFER_TYPE_MONO, &backbuffer);
+
+	glw_state->device->CopyRects(backbuffer, NULL, 0, surf, NULL);
+
+	surf->Release();
+	backbuffer->Release();
+}
+
+/**********
+dllCopyBackBufferToTexEXT
+Copies a portion of the backbuffer to a texture
+If the destination is a DXT1 texture, then the buffer will be compressed
+width	- width of the backbuffer polygon rendered to the destination texture
+height	- height of the backbuffer polygon rendered to the destination texture
+u,v		- describes the potion of the backbuffer to be copied in screen coords
+**********/
+static void dllCopyBackBufferToTexEXT(float width, float height, float u1, float v1, float u2, float v2)
+{
+	glwstate_t::TextureInfo* info = _getCurrentTexture(glw_state->serverTU);
+	if (info == NULL) return;
+
+	struct QUAD { D3DXVECTOR4 p; FLOAT tu,tv;} q[4];
+	q[0].p	= D3DXVECTOR4( 0.0f, 0.0f, 1.0f, 1.0f );
+	q[0].tu = u1;		q[0].tv = v1;
+	q[1].p	= D3DXVECTOR4( width, 0.0f, 1.0f, 1.0f );
+	q[1].tu = u2;	q[1].tv = v1;
+	q[2].p	= D3DXVECTOR4( 0.0f, height , 1.0f, 1.0f );
+	q[2].tu = u1;		q[2].tv = v2;
+	q[3].p	= D3DXVECTOR4( width, height, 1.0f, 1.0f );
+	q[3].tu = u2;	q[3].tv = v2;
+
+
+	LPDIRECT3DSURFACE8	pSurface;
+	LPDIRECT3DSURFACE8	pBackBuffer;
+	LPDIRECT3DSURFACE8	pStencilBuffer;
+	D3DSURFACE_DESC		desc;
+	D3DBaseTexture*		pTexStage0;
+	D3DBaseTexture*		pTexStage1;
+	D3DBaseTexture*		pTexStage2;
+	D3DBaseTexture*		pTexStage3;
+	D3DTexture*			pRenderTex;
+	int					w	= 0;
+	int					h	= 0;
+
+	DWORD srcblend, destblend, alphablend, alphatest, zwrite, zenable, vShader, pShader;
+	DWORD colorop, colorarg1, addressu, addressv, minfilter, magfilter, colorwriteenable;
+
+	// save the current state
+	glw_state->device->GetRenderState( D3DRS_SRCBLEND, &srcblend );
+	glw_state->device->GetRenderState( D3DRS_DESTBLEND, &destblend );
+	glw_state->device->GetRenderState( D3DRS_ALPHABLENDENABLE, &alphablend );
+	glw_state->device->GetRenderState( D3DRS_ALPHATESTENABLE, &alphatest );
+	glw_state->device->GetRenderState( D3DRS_ZWRITEENABLE, &zwrite );
+	glw_state->device->GetRenderState( D3DRS_ZENABLE, &zenable );
+	glw_state->device->GetRenderState( D3DRS_COLORWRITEENABLE, &colorwriteenable);
+	glw_state->device->GetVertexShader( &vShader );
+	glw_state->device->GetPixelShader( &pShader );
+	glw_state->device->GetTexture(0,&pTexStage0);
+	glw_state->device->GetTexture(1,&pTexStage1);
+	glw_state->device->GetTexture(2,&pTexStage2);
+	glw_state->device->GetTexture(3,&pTexStage3);
+	glw_state->device->GetTextureStageState(0, D3DTSS_COLOROP, &colorop);
+	glw_state->device->GetTextureStageState(0, D3DTSS_COLORARG1, &colorarg1);
+	glw_state->device->GetTextureStageState(0, D3DTSS_ADDRESSU, &addressu);
+	glw_state->device->GetTextureStageState(0, D3DTSS_ADDRESSV, &addressv);
+	glw_state->device->GetTextureStageState(0, D3DTSS_MINFILTER, &minfilter);
+	glw_state->device->GetTextureStageState(0, D3DTSS_MAGFILTER, &magfilter);
+
+	// get the buffers
+	glw_state->device->GetBackBuffer(0, D3DBACKBUFFER_TYPE_MONO, &pBackBuffer);
+	glw_state->device->GetDepthStencilSurface(&pStencilBuffer);
+
+	// get a surface desc
+	info->mipmap->GetLevelDesc(0, &desc);
+
+	// check to see if the texture needs to be resized
+	if( desc.Width != width || desc.Height != height)
+	{
+		int refCount;
+		refCount = info->mipmap->Release();
+
+		// Had to remove this. Multiple characters using force push in one
+		// frame triggers the assert. Things clean up by the end of the frame.
+//		assert(refCount == 0);
+
+		glw_state->device->CreateTexture(	width,
+											height,
+											1,
+											0,
+											desc.Format,
+											0,
+											&info->mipmap );
+	}
+
+	// check to see if we want a compressed output texture
+	if( desc.Format == D3DFMT_DXT1)
+	{
+
+		w	= desc.Width;
+		h	= desc.Height;
+
+		// create a new texture to use as a render target
+		glw_state->device->CreateTexture(	w,
+											h,
+											1,
+											0,
+											D3DFMT_LIN_X8R8G8B8,
+											0,
+											&pRenderTex );
+	}
+	else
+	{
+		pRenderTex = info->mipmap;
+		
+	}
+
+	// make our current surface a render target
+	pRenderTex->GetSurfaceLevel(0, &pSurface);
+	glw_state->device->SetRenderTarget( pSurface, NULL );
+	
+	// set texture 0 to the back buffer data
+	glw_state->device->SetTexture(0,(LPDIRECT3DTEXTURE8)pBackBuffer);
+
+	// clear the other texture stages
+	glw_state->device->SetTexture(1, NULL);
+	glw_state->device->SetTexture(2, NULL);
+	glw_state->device->SetTexture(3, NULL);
+
+	// set the texture 0 state
+	glw_state->device->SetTextureStageState( 0, D3DTSS_COLOROP,   D3DTOP_SELECTARG1 );
+    glw_state->device->SetTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
+    glw_state->device->SetTextureStageState( 0, D3DTSS_ADDRESSU, D3DTADDRESS_CLAMP );
+    glw_state->device->SetTextureStageState( 0, D3DTSS_ADDRESSV, D3DTADDRESS_CLAMP );
+    glw_state->device->SetTextureStageState( 0, D3DTSS_MINFILTER, D3DTEXF_LINEAR );
+    glw_state->device->SetTextureStageState( 0, D3DTSS_MAGFILTER, D3DTEXF_LINEAR );
+	
+	// set the render state
+	glw_state->device->SetRenderState( D3DRS_ZENABLE,         FALSE );
+    glw_state->device->SetRenderState( D3DRS_ALPHATESTENABLE, FALSE );
+	glw_state->device->SetRenderState( D3DRS_ALPHABLENDENABLE, FALSE);
+	glw_state->device->SetRenderState( D3DRS_SRCBLEND, D3DBLEND_SRCALPHA );
+	glw_state->device->SetRenderState( D3DRS_DESTBLEND, D3DBLEND_SRCALPHA | D3DBLEND_INVSRCALPHA );
+	glw_state->device->SetRenderState( D3DRS_COLORWRITEENABLE, D3DCOLORWRITEENABLE_ALL);
+
+	// set our vertex shader and draw the backbuffer to the texture
+	glw_state->device->SetVertexShader( D3DFVF_XYZRHW|D3DFVF_TEX1 );
+	glw_state->device->SetPixelShader( NULL );
+	glw_state->device->Clear(NULL,NULL,D3DCLEAR_TARGET,D3DCOLOR_COLORVALUE(1.0f, 1.0f, 1.0f, 1.0f), 1.0f, 0);
+	glw_state->device->DrawPrimitiveUP( D3DPT_QUADSTRIP, 1, q, sizeof(QUAD) );
+
+	// now that everything is rendered, check again to see
+	// if we want a compressed texture
+	if( desc.Format == D3DFMT_DXT1)
+	{
+		LPDIRECT3DTEXTURE8	pSrcTex;
+		LPDIRECT3DTEXTURE8	pDstTex;
+		D3DLOCKED_RECT		srcLock;
+		D3DLOCKED_RECT		dstLock;
+
+		pSrcTex	= pRenderTex;
+		pDstTex	= info->mipmap;
+
+		// lock our textures
+		pSrcTex->LockRect(0, &srcLock, NULL, 0);
+		pDstTex->LockRect(0, &dstLock, NULL, 0);
+
+		// compress the texture
+		XGCompressRect(	dstLock.pBits,
+						D3DFMT_DXT1,
+						dstLock.Pitch,
+						w,
+						h,
+						srcLock.pBits,
+						D3DFMT_LIN_X8R8G8B8,
+						srcLock.Pitch,
+						1,
+						0 );
+
+		// unlock
+		pSrcTex->UnlockRect(0);
+		pDstTex->UnlockRect(0);
+
+		// release the render texture
+		pRenderTex->Release();
+	}
+
+	// return our state
+	glw_state->device->SetRenderState( D3DRS_SRCBLEND, srcblend );
+	glw_state->device->SetRenderState( D3DRS_DESTBLEND, destblend );
+	glw_state->device->SetRenderState( D3DRS_ALPHABLENDENABLE, alphablend );
+	glw_state->device->SetRenderState( D3DRS_ALPHATESTENABLE, alphatest );
+	glw_state->device->SetRenderState( D3DRS_ZWRITEENABLE, zwrite );
+	glw_state->device->SetRenderState( D3DRS_ZENABLE, zenable );
+	glw_state->device->SetRenderState( D3DRS_COLORWRITEENABLE, colorwriteenable);
+
+	glw_state->device->SetTexture(0,pTexStage0);
+	glw_state->device->SetTexture(1,pTexStage1);
+	glw_state->device->SetTexture(2,pTexStage2);
+	glw_state->device->SetTexture(3,pTexStage3);
+	glw_state->device->SetTextureStageState(0, D3DTSS_COLOROP, colorop);
+	glw_state->device->SetTextureStageState(0, D3DTSS_COLORARG1, colorarg1);
+	glw_state->device->SetTextureStageState(0, D3DTSS_ADDRESSU, addressu);
+	glw_state->device->SetTextureStageState(0, D3DTSS_ADDRESSV, addressv);
+	glw_state->device->SetTextureStageState(0, D3DTSS_MINFILTER, minfilter);
+	glw_state->device->SetTextureStageState(0, D3DTSS_MAGFILTER, magfilter);
+
+	glw_state->device->SetVertexShader( vShader );
+	glw_state->device->SetPixelShader( pShader );
+
+	glw_state->device->SetRenderTarget( pBackBuffer, pStencilBuffer );
+
+	// release our surfaces/textures
+	if(pTexStage0)
+		pTexStage0->Release();
+
+	if(pTexStage1)
+		pTexStage1->Release();
+
+	if(pTexStage2)
+		pTexStage2->Release();
+
+	if(pTexStage3)
+		pTexStage3->Release();
+
+	pSurface->Release();
+	pBackBuffer->Release();
+	pStencilBuffer->Release();
+}
+
+static void dllRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2)
+{
+	assert(0);
+}
+
+static void dllRectdv(const GLdouble *v1, const GLdouble *v2)
+{
+	assert(0);
+}
+
+static void dllRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)
+{
+	assert(0);
+}
+
+static void dllRectfv(const GLfloat *v1, const GLfloat *v2)
+{
+	assert(0);
+}
+
+static void dllRecti(GLint x1, GLint y1, GLint x2, GLint y2)
+{
+	assert(0);
+}
+
+static void dllRectiv(const GLint *v1, const GLint *v2)
+{
+	assert(0);
+}
+
+static void dllRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2)
+{
+	assert(0);
+}
+
+static void dllRectsv(const GLshort *v1, const GLshort *v2)
+{
+	assert(0);
+}
+
+GLint dllRenderMode(GLenum mode)
+{
+	assert(0);
+	return 0;
+}
+
+static void dllRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z)
+{
+	assert(0);
+}
+
+static void dllRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
+{
+	D3DXVECTOR3 v(x, y, z);
+	glw_state->matrixStack[glw_state->matrixMode]->RotateAxisLocal(&v, angle);
+	glw_state->matricesDirty[glw_state->matrixMode] = true;
+}
+
+static void dllScaled(GLdouble x, GLdouble y, GLdouble z)
+{
+	assert(0);
+}
+
+static void dllScalef(GLfloat x, GLfloat y, GLfloat z)
+{
+	glw_state->matrixStack[glw_state->matrixMode]->Scale(x, y, z);
+	glw_state->matricesDirty[glw_state->matrixMode] = true;
+}
+
+static void dllScissor(GLint x, GLint y, GLsizei width, GLsizei height)
+{
+#ifdef _XBOX
+	_fixupScreenCoords(x, y, width, height);
+
+	glw_state->scissorBox.x1 = x;
+	glw_state->scissorBox.y1 = y;
+	glw_state->scissorBox.x2 = x + width;
+	glw_state->scissorBox.y2 = y + height;
+	
+	if (glw_state->scissorEnable)
+	{
+		glw_state->device->SetScissors(1, FALSE, &glw_state->scissorBox);
+	}
+#endif
+}
+
+static void dllSelectBuffer(GLsizei size, GLuint *buffer)
+{
+	assert(0);
+}
+
+static void dllShadeModel(GLenum mode)
+{
+	D3DSHADEMODE m;
+	switch (mode)
+	{
+	case GL_FLAT: m = D3DSHADE_FLAT; break;
+	case GL_SMOOTH: default: m = D3DSHADE_GOURAUD; break;
+	}
+	
+	glw_state->device->SetRenderState(D3DRS_SHADEMODE, m);
+}
+
+static void dllStencilFunc(GLenum func, GLint ref, GLuint mask)
+{
+	D3DCMPFUNC f = _convertCompare(func);
+
+	glw_state->device->SetRenderState(D3DRS_STENCILFUNC, f);
+	glw_state->device->SetRenderState(D3DRS_STENCILREF, ref);
+	glw_state->device->SetRenderState(D3DRS_STENCILMASK, mask);
+}
+
+static void dllStencilMask(GLuint mask)
+{
+	glw_state->device->SetRenderState(D3DRS_STENCILWRITEMASK, mask);
+}
+
+static D3DSTENCILOP _convertStencilOp(GLenum op)
+{
+	switch (op)
+	{
+	default: case GL_KEEP: return D3DSTENCILOP_KEEP;
+	case GL_ZERO: return D3DSTENCILOP_ZERO;
+	case GL_REPLACE: return D3DSTENCILOP_REPLACE;
+	case GL_INCR: return D3DSTENCILOP_INCR;
+	case GL_DECR: return D3DSTENCILOP_DECR;
+	case GL_INVERT: return D3DSTENCILOP_INVERT;
+	}
+}
+
+static void dllStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
+{
+	D3DSTENCILOP f = _convertStencilOp(fail);
+	D3DSTENCILOP zf = _convertStencilOp(zfail);
+	D3DSTENCILOP zp = _convertStencilOp(zpass);
+
+	glw_state->device->SetRenderState(D3DRS_STENCILFAIL, f);
+	glw_state->device->SetRenderState(D3DRS_STENCILZFAIL, zf);
+	glw_state->device->SetRenderState(D3DRS_STENCILPASS, zp);
+}
+
+static void dllTexCoord1d(GLdouble s)
+{
+	assert(0);
+}
+
+static void dllTexCoord1dv(const GLdouble *v)
+{
+	assert(0);
+}
+
+static void dllTexCoord1f(GLfloat s)
+{
+	assert(0);
+}
+
+static void dllTexCoord1fv(const GLfloat *v)
+{
+	assert(0);
+}
+
+static void dllTexCoord1i(GLint s)
+{
+	assert(0);
+}
+
+static void dllTexCoord1iv(const GLint *v)
+{
+	assert(0);
+}
+
+static void dllTexCoord1s(GLshort s)
+{
+	assert(0);
+}
+
+static void dllTexCoord1sv(const GLshort *v)
+{
+	assert(0);
+}
+
+static void setTexCoord(float s, float t)
+{
+	assert(glw_state->inDrawBlock);
+
+	_handleDrawOverflow();
+
+	int off = 0;
+	if(glw_state->normalArrayState)
+		off = 3;
+	
+	DWORD* push = &glw_state->drawArray[
+		glw_state->numVertices * glw_state->drawStride + 
+		4 + off + glw_state->serverTU * 2];
+	
+	*push++ = *((DWORD*)&s);
+	*push++ = *((DWORD*)&t);
+}
+
+static void dllTexCoord2d(GLdouble s, GLdouble t)
+{
+	assert(0);
+}
+
+static void dllTexCoord2dv(const GLdouble *v)
+{
+	assert(0);
+}
+
+static void dllTexCoord2f(GLfloat s, GLfloat t)
+{
+	setTexCoord(s, t);
+}
+
+static void dllTexCoord2fv(const GLfloat *v)
+{
+	setTexCoord(v[0], v[1]);
+}
+
+static void dllTexCoord2i(GLint s, GLint t)
+{
+	assert(0);
+}
+
+static void dllTexCoord2iv(const GLint *v)
+{
+	assert(0);
+}
+
+static void dllTexCoord2s(GLshort s, GLshort t)
+{
+	assert(0);
+}
+
+static void dllTexCoord2sv(const GLshort *v)
+{
+	assert(0);
+}
+
+static void dllTexCoord3d(GLdouble s, GLdouble t, GLdouble r)
+{
+	assert(0);
+}
+
+static void dllTexCoord3dv(const GLdouble *v)
+{
+	assert(0);
+}
+
+static void dllTexCoord3f(GLfloat s, GLfloat t, GLfloat r)
+{
+	assert(0);
+}
+
+static void dllTexCoord3fv(const GLfloat *v)
+{
+	assert(0);
+}
+
+static void dllTexCoord3i(GLint s, GLint t, GLint r)
+{
+	assert(0);
+}
+
+static void dllTexCoord3iv(const GLint *v)
+{
+	assert(0);
+}
+
+static void dllTexCoord3s(GLshort s, GLshort t, GLshort r)
+{
+	assert(0);
+}
+
+static void dllTexCoord3sv(const GLshort *v)
+{
+	assert(0);
+}
+
+static void dllTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q)
+{
+	assert(0);
+}
+
+static void dllTexCoord4dv(const GLdouble *v)
+{
+	assert(0);
+}
+
+static void dllTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q)
+{
+	assert(0);
+}
+
+static void dllTexCoord4fv(const GLfloat *v)
+{
+	assert(0);
+}
+
+static void dllTexCoord4i(GLint s, GLint t, GLint r, GLint q)
+{
+	assert(0);
+}
+
+static void dllTexCoord4iv(const GLint *v)
+{
+	assert(0);
+}
+
+static void dllTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q)
+{
+	assert(0);
+}
+
+static void dllTexCoord4sv(const GLshort *v)
+{
+	assert(0);
+}
+
+static void dllTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
+{
+	assert(size == 2 && type == GL_FLOAT);
+
+	stride = (stride == 0) ? (sizeof(GLfloat) * 2) : stride;
+	
+	glw_state->texCoordPointer[glw_state->clientTU] = pointer;
+	glw_state->texCoordStride[glw_state->clientTU] = stride;
+}
+
+static void dllTexEnvf(GLenum target, GLenum pname, GLfloat param)
+{
+	qglTexEnvi(target, pname, (GLint)param);
+}
+
+static void dllTexEnvfv(GLenum target, GLenum pname, const GLfloat *params)
+{
+	assert(0);
+}
+
+static void dllTexEnvi(GLenum target, GLenum pname, GLint param)
+{
+	assert(target == GL_TEXTURE_ENV && pname == GL_TEXTURE_ENV_MODE);
+
+	/*glwstate_t::TextureInfo* info = _getCurrentTexture(glw_state->serverTU);
+	if (!info) return;*/
+
+	D3DTEXTUREOP env;
+	switch (param)
+	{
+	case GL_MODULATE: default: env = D3DTOP_MODULATE; break;
+	case GL_REPLACE: env = D3DTOP_SELECTARG1; break;
+	// MATT! - I use GL_DECAL as the bumpmapping state
+	case GL_DECAL: env = D3DTOP_DOTPRODUCT3; break;
+	case GL_ADD: env = D3DTOP_ADD; break;
+	case GL_NONE: env = D3DTOP_DISABLE; break;
+	}
+
+	if (glw_state->textureEnv[glw_state->serverTU] != env)
+	{
+		glw_state->textureEnv[glw_state->serverTU] = env;
+		glw_state->textureStageDirty[glw_state->serverTU] = true;
+	}
+}
+
+static void dllTexEnviv(GLenum target, GLenum pname, const GLint *params)
+{
+	assert(0);
+}
+
+static void dllTexGend(GLenum coord, GLenum pname, GLdouble param)
+{
+	assert(0);
+}
+
+static void dllTexGendv(GLenum coord, GLenum pname, const GLdouble *params)
+{
+	assert(0);
+}
+
+static void dllTexGenf(GLenum coord, GLenum pname, GLfloat param)
+{
+	assert(0);
+}
+
+static void dllTexGenfv(GLenum coord, GLenum pname, const GLfloat *params)
+{
+	assert(0);
+}
+
+static void dllTexGeni(GLenum coord, GLenum pname, GLint param)
+{
+	assert(0);
+}
+
+static void dllTexGeniv(GLenum coord, GLenum pname, const GLint *params)
+{
+	assert(0);
+}
+
+static void dllTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
+{
+	assert(0);
+}
+
+static void _d3d_check(HRESULT err, const char* func)
+{
+	if (err != D3D_OK)
+	{
+		MEMORYSTATUS status;
+		GlobalMemoryStatus(&status);
+		Sys_Print(va("%s returned %d!  Memfree=%d\n", func, err, status.dwAvailPhys));
+	}
+}
+
+static void _texImageDDS(glwstate_t::TextureInfo* info, GLint numlevels, GLsizei width, GLsizei height, GLenum format, const GLvoid *pixels)
+{
+	_d3d_check(D3DXCreateTextureFromFileInMemoryEx(glw_state->device,
+		pixels, 
+		Z_Size(const_cast<void*>(pixels)),
+		width, 
+		height,
+		numlevels,
+		0,
+		D3DFMT_UNKNOWN,
+		D3DPOOL_MANAGED,
+		D3DX_DEFAULT,
+		D3DX_DEFAULT,
+		0,
+		NULL,
+		NULL,
+		&info->mipmap),
+		"D3DXCreateTextureFromFileInMemoryEx");
+}
+
+static void _texImageRGBA(glwstate_t::TextureInfo* info, GLint numlevels, GLint internalformat, GLsizei width, GLsizei height, GLenum format, const GLvoid *pixels)
+{
+	IDirect3DSurface8 *pSurf = NULL;
+	D3DFORMAT f;
+	float bpp;
+	int pitch;
+	RECT	srcRect;
+	
+	srcRect.top = 0;
+	srcRect.left = 0;
+	srcRect.right = width;
+	srcRect.bottom = height;
+
+	switch(format)
+	{
+	case GL_RGB:
+		f = D3DFMT_X8R8G8B8;
+		bpp = 3;
+		break;
+		
+	case GL_RGBA:
+		f = D3DFMT_A8R8G8B8;
+		bpp = 4;
+		break;
+
+	case GL_LIN_RGBA:
+		f = D3DFMT_LIN_A8R8G8B8;
+		bpp = 4;
+		break;
+
+	case GL_LIN_RGB:
+		f = D3DFMT_LIN_X8R8G8B8;
+		bpp = 4;
+		break;
+
+	case GL_LIN_RGB8:
+		f = D3DFMT_LIN_X8R8G8B8;
+		bpp = 4;
+		break;
+
+	case GL_RGB8:
+		f = D3DFMT_X8R8G8B8;
+		bpp = 4;
+		break;
+
+	case GL_RGB_SWIZZLE_EXT:
+		f = D3DFMT_R5G6B5;
+		bpp = 2;
+		break;
+
+	case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
+		f = D3DFMT_DXT1;
+		bpp = 0.5;
+		break;
+
+	default:
+		assert(0);
+	}
+
+	_d3d_check(glw_state->device->CreateImageSurface(width, height, f, &pSurf),
+		"CreateImageSurface");
+
+	pitch = (int)((float)width * bpp);
+
+	_d3d_check(D3DXLoadSurfaceFromMemory(pSurf, 
+								   NULL, 
+								   NULL, 
+								   (LPCVOID)pixels, 
+								   f, 
+								   pitch, 
+								   NULL, 
+								   &srcRect, 
+								   D3DX_FILTER_NONE, 
+								   0),
+								   "D3DXLoadSurfaceFromMemory");
+
+	switch(internalformat)
+	{
+	case GL_RGB5:
+	case GL_RGB4_S3TC:
+		f = D3DFMT_R5G6B5;
+		break;
+
+	case GL_RGBA4:
+		f = D3DFMT_A4R4G4B4;
+		break;
+
+	case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
+		f = D3DFMT_DXT1;
+		break;
+
+	case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
+		f = D3DFMT_DXT5;
+		break;
+
+	case GL_RGB8:
+	case 3:
+		f = D3DFMT_X8R8G8B8;
+		break;
+
+	case GL_LIN_RGBA8:
+		f = D3DFMT_LIN_A8R8G8B8;
+		break;
+	case GL_LIN_RGB8:
+		f = D3DFMT_LIN_X8R8G8B8;
+		break;
+
+	case GL_RGBA8:
+	case 4:
+		f = D3DFMT_A8R8G8B8;
+		break;
+	case GL_RGB:
+		f = D3DFMT_X8R8G8B8;
+		break;
+
+	default:
+		assert(0);
+	}
+	
+	_d3d_check(D3DXCreateTexture(glw_state->device, 
+							   width, 
+							   height, 
+							   numlevels, 
+							   0, 
+							   f, 
+							   D3DPOOL_MANAGED,
+							   &info->mipmap),
+							   "D3DXCreateTexture");
+
+	LPDIRECT3DSURFACE8 txtSurf;
+	_d3d_check(info->mipmap->GetSurfaceLevel(0, &txtSurf),
+		"GetSurfaceLevel");
+	
+	_d3d_check(D3DXLoadSurfaceFromSurface(txtSurf, NULL, NULL, 
+		pSurf, NULL, NULL, D3DX_DEFAULT, 0),
+		"D3DXLoadSurfaceFromSurface");
+
+	txtSurf->Release();
+	pSurf->Release();
+
+	if(numlevels > 1)
+	{
+		_d3d_check(D3DXFilterTexture(info->mipmap, 
+							   NULL, 
+							   D3DX_DEFAULT, 
+							   D3DX_DEFAULT),
+							   "D3DXFilterTexture");
+	}
+}
+
+// EXTENSION: glTexImage2D plus "numlevels" number of mipmaps
+static void dllTexImage2DEXT(GLenum target, GLint level, GLint numlevels, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
+{
+	assert(target == GL_TEXTURE_2D && border == 0 && type == GL_UNSIGNED_BYTE);
+
+	// In Direct3D, setting 0 for number of mipmap 
+	// levels means create the whole chain....
+	/*if(numlevels == 0)
+		numlevels = 1;*/
+
+	glwstate_t::TextureInfo* info;
+
+	glwstate_t::texturexlat_t::iterator current = 
+		glw_state->textureXlat.find(
+		glw_state->currentTexture[glw_state->serverTU]);
+
+	// If we already have a texture bound to this ID, remove it.
+	if (current != glw_state->textureXlat.end())
+	{
+		info = &current->second;
+		info->mipmap->Release();
+	}
+	// Otherwise, initialize it.
+	else
+	{
+		info = &glw_state->textureXlat[
+			glw_state->currentTexture[glw_state->serverTU]];
+
+		info->minFilter = D3DTEXF_NONE;
+		info->mipFilter = D3DTEXF_NONE;
+		info->magFilter = D3DTEXF_NONE;
+		info->anisotropy = 1.f;
+		info->wrapU = D3DTADDRESS_CLAMP;
+		info->wrapV = D3DTADDRESS_CLAMP;
+
+		glw_state->textureStageDirty[glw_state->serverTU] = true;
+	}
+
+	// force any DX allocs to temp memory
+	Z_SetNewDeleteTemporary(true);
+
+	if (format == GL_DDS1_EXT || 
+		format == GL_DDS5_EXT || 
+		format == GL_DDS_RGB16_EXT || 
+		format == GL_DDS_RGBA32_EXT)
+	{
+		_texImageDDS(info, numlevels, width, height, format, pixels);
+	}
+	else
+	{
+		_texImageRGBA(info, numlevels, 
+			internalformat, width, height, 
+			format, pixels);
+	}
+
+	// Done DX calls to new and delete
+	Z_SetNewDeleteTemporary(false);
+
+#if MEMORY_PROFILE
+	texMemSize += getTexMemSize(info->mipmap);
+#endif
+}
+
+static void dllTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
+{
+	dllTexImage2DEXT(target, level, 1, internalformat, width, height, border, format, type, pixels);
+}
+
+static void dllTexParameteri(GLenum target, GLenum pname, GLint param)
+{
+	assert(target == GL_TEXTURE_2D);
+	
+	if (glw_state->currentTexture[glw_state->serverTU] == 0) return;
+
+	glwstate_t::TextureInfo* info = _getCurrentTexture(glw_state->serverTU);
+	if (!info) return;
+
+	glw_state->textureStageDirty[glw_state->serverTU] = true;
+	
+	switch (pname)
+	{
+	case GL_TEXTURE_MIN_FILTER:
+		switch (param)
+		{
+		case GL_NEAREST:
+			info->minFilter = D3DTEXF_POINT;
+			info->mipFilter = D3DTEXF_NONE;
+			break;
+		case GL_LINEAR:
+			info->minFilter = D3DTEXF_LINEAR;
+			info->mipFilter = D3DTEXF_NONE;
+			break;
+		case GL_NEAREST_MIPMAP_NEAREST:
+			info->minFilter = D3DTEXF_POINT;
+			info->mipFilter = D3DTEXF_POINT;
+			break;
+		case GL_LINEAR_MIPMAP_NEAREST:
+			info->minFilter = D3DTEXF_LINEAR;
+			info->mipFilter = D3DTEXF_POINT;
+			break;
+		case GL_NEAREST_MIPMAP_LINEAR:
+			info->minFilter = D3DTEXF_POINT;
+			info->mipFilter = D3DTEXF_LINEAR;
+			break;
+		case GL_LINEAR_MIPMAP_LINEAR:
+			info->minFilter = D3DTEXF_LINEAR;
+			info->mipFilter = D3DTEXF_LINEAR;
+			break;
+		}
+		info->anisotropy = 1.f;
+		break;
+	case GL_TEXTURE_MAG_FILTER:
+		switch (param)
+		{
+		case GL_NEAREST:
+			info->magFilter = D3DTEXF_POINT;
+			break;
+		case GL_LINEAR:
+			info->magFilter = D3DTEXF_LINEAR;
+			break;
+		}
+		info->anisotropy = 1.f;
+		break;
+	case GL_TEXTURE_WRAP_S:
+		switch (param)
+		{
+		case GL_REPEAT: info->wrapU = D3DTADDRESS_WRAP; break;
+		case GL_CLAMP: info->wrapU = D3DTADDRESS_CLAMP; break;
+		}
+		break;
+	case GL_TEXTURE_WRAP_T:
+		switch (param)
+		{
+		case GL_REPEAT: info->wrapV = D3DTADDRESS_WRAP; break;
+		case GL_CLAMP: info->wrapV = D3DTADDRESS_CLAMP; break;
+		}
+		break;
+	case GL_TEXTURE_MAX_ANISOTROPY_EXT:
+		info->anisotropy = (float)param;
+		info->minFilter = D3DTEXF_ANISOTROPIC;
+		info->magFilter = D3DTEXF_ANISOTROPIC;
+		break;
+	}
+}
+
+static void dllTexParameterf(GLenum target, GLenum pname, GLfloat param)
+{
+	dllTexParameteri(target, pname, param);
+}
+
+static void dllTexParameterfv(GLenum target, GLenum pname, const GLfloat *params)
+{
+	// Intentionally left blank
+}
+
+static void dllTexParameteriv(GLenum target, GLenum pname, const GLint *params)
+{
+	// Intentionally left blank
+}
+
+static void dllTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels)
+{
+	assert(0);
+}
+
+static void dllTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
+{
+	assert(target == GL_TEXTURE_2D && level == 0 && type == GL_UNSIGNED_BYTE);
+
+	glwstate_t::TextureInfo* info = _getCurrentTexture(glw_state->serverTU);
+	if (info == NULL) return;
+
+	RECT sr;
+	sr.top = 0;
+	sr.left = 0;
+	sr.right = width;
+	sr.bottom = height;
+
+	RECT dr;
+	dr.top = xoffset;
+	dr.left = yoffset;
+	dr.right = xoffset + width;
+	dr.bottom = yoffset + height;
+
+	Z_SetNewDeleteTemporary(true);
+
+	LPDIRECT3DSURFACE8 surf;
+	info->mipmap->GetSurfaceLevel(0, &surf);
+	
+	// We use the supplied format to handle pixel data correctly, the way OGL would
+	D3DFORMAT srcFormat;
+	switch(format)
+	{
+		case GL_RGB:
+			srcFormat = D3DFMT_LIN_X8R8G8B8;
+			break;
+
+		case GL_RGBA:
+			srcFormat = D3DFMT_LIN_A8R8G8B8;
+			break;
+
+		default:
+			assert(0 && "Unsupported format in dllTexSubImage2D");
+			return;
+	}
+
+	D3DXLoadSurfaceFromMemory(surf, NULL, &dr, pixels,
+		srcFormat, width * 4, NULL, &sr, D3DX_DEFAULT, 0);
+
+	surf->Release();
+
+	Z_SetNewDeleteTemporary(false);
+}
+
+static void dllTranslated(GLdouble x, GLdouble y, GLdouble z)
+{
+	assert(0);
+}
+
+static void dllTranslatef(GLfloat x, GLfloat y, GLfloat z)
+{
+	glw_state->matrixStack[glw_state->matrixMode]->TranslateLocal(x, y, z);
+	glw_state->matricesDirty[glw_state->matrixMode] = true;
+}
+
+static void setVertex(float x, float y, float z)
+{
+	assert(glw_state->inDrawBlock);
+
+	_handleDrawOverflow();
+	
+	DWORD* push = &glw_state->drawArray[glw_state->numVertices * glw_state->drawStride];
+	push[0] = *((DWORD*)&x);
+	push[1] = *((DWORD*)&y);
+	push[2] = *((DWORD*)&z);
+	push[3] = glw_state->currentColor;
+
+	++glw_state->numVertices;
+}
+
+static void dllVertex2d(GLdouble x, GLdouble y)
+{
+	assert(0);
+}
+
+static void dllVertex2dv(const GLdouble *v)
+{
+	assert(0);
+}
+
+static void dllVertex2f(GLfloat x, GLfloat y)
+{
+	setVertex(x, y, 0.f);
+}
+
+static void dllVertex2fv(const GLfloat *v)
+{
+	setVertex(v[0], v[1], 0.f);
+}
+
+static void dllVertex2i(GLint x, GLint y)
+{
+	assert(0);
+}
+
+static void dllVertex2iv(const GLint *v)
+{
+	assert(0);
+}
+
+static void dllVertex2s(GLshort x, GLshort y)
+{
+	assert(0);
+}
+
+static void dllVertex2sv(const GLshort *v)
+{
+	assert(0);
+}
+
+static void dllVertex3d(GLdouble x, GLdouble y, GLdouble z)
+{
+	assert(0);
+}
+
+static void dllVertex3dv(const GLdouble *v)
+{
+	assert(0);
+}
+
+static void dllVertex3f(GLfloat x, GLfloat y, GLfloat z)
+{
+	setVertex(x, y, z);
+}
+
+static void dllVertex3fv(const GLfloat *v)
+{
+	setVertex(v[0], v[1], v[2]);
+}
+
+static void dllVertex3i(GLint x, GLint y, GLint z)
+{
+	assert(0);
+}
+
+static void dllVertex3iv(const GLint *v)
+{
+	assert(0);
+}
+
+static void dllVertex3s(GLshort x, GLshort y, GLshort z)
+{
+	assert(0);
+}
+
+static void dllVertex3sv(const GLshort *v)
+{
+	assert(0);
+}
+
+static void dllVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
+{
+	assert(0);
+}
+
+static void dllVertex4dv(const GLdouble *v)
+{
+	assert(0);
+}
+
+static void dllVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
+{
+	setVertex(x, y, z);
+}
+
+static void dllVertex4fv(const GLfloat *v)
+{
+	setVertex(v[0], v[1], v[2]);
+}
+
+static void dllVertex4i(GLint x, GLint y, GLint z, GLint w)
+{
+	assert(0);
+}
+
+static void dllVertex4iv(const GLint *v)
+{
+	assert(0);
+}
+
+static void dllVertex4s(GLshort x, GLshort y, GLshort z, GLshort w)
+{
+	assert(0);
+}
+
+static void dllVertex4sv(const GLshort *v)
+{
+	assert(0);
+}
+
+static void dllVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
+{
+	assert(size == 3 && type == GL_FLOAT);
+	
+	stride = (stride == 0) ? (sizeof(GLfloat) * 3) : stride;
+
+	glw_state->vertexPointer = pointer;
+	glw_state->vertexStride = stride;
+}
+
+static void dllViewport(GLint x, GLint y, GLsizei width, GLsizei height)
+{
+	_fixupScreenCoords(x, y, width, height);
+
+	glw_state->viewport.X = x;
+	glw_state->viewport.Y = y;
+	glw_state->viewport.Width = width;
+	glw_state->viewport.Height = height;
+	glw_state->device->SetViewport(&glw_state->viewport);
+}
+
+
+static void dllMultiTexCoord2fARB(GLenum texture, GLfloat s, GLfloat t)
+{
+	assert(glw_state->inDrawBlock);
+
+	_handleDrawOverflow();
+
+	DWORD* push = &glw_state->drawArray[
+		glw_state->numVertices * glw_state->drawStride + 
+		4 + (texture - GL_TEXTURE0_ARB) * 2];
+	
+	*push++ = *((DWORD*)&s);
+	*push++ = *((DWORD*)&t);
+}
+
+static void dllActiveTextureARB(GLenum texture)
+{
+	assert(GLW_MAX_TEXTURE_STAGES > texture - GL_TEXTURE0_ARB);
+	glw_state->serverTU = texture - GL_TEXTURE0_ARB;
+}
+
+static void dllClientActiveTextureARB(GLenum texture)
+{
+	assert(GLW_MAX_TEXTURE_STAGES > texture - GL_TEXTURE0_ARB);
+	glw_state->clientTU = texture - GL_TEXTURE0_ARB;
+}
+
+
+/*
+** QGL_Shutdown
+**
+** Unloads the specified DLL then nulls out all the proc pointers.  This
+** is only called during a hard shutdown of the OGL subsystem (e.g. vid_restart).
+*/
+void QGL_Shutdown( void )
+{
+	VID_Printf( PRINT_ALL, "...shutting down QGL\n" );
+
+	qglAccum                     = NULL;
+	qglAlphaFunc                 = NULL;
+	qglAreTexturesResident       = NULL;
+	qglArrayElement              = NULL;
+	qglBegin                     = NULL;
+	qglBeginEXT                  = NULL;
+	qglBeginFrame                = NULL;
+	qglBeginShadow               = NULL;
+	qglBindTexture               = NULL;
+	qglBitmap                    = NULL;
+	qglBlendFunc                 = NULL;
+	qglCallList                  = NULL;
+	qglCallLists                 = NULL;
+	qglClear                     = NULL;
+	qglClearAccum                = NULL;
+	qglClearColor                = NULL;
+	qglClearDepth                = NULL;
+	qglClearIndex                = NULL;
+	qglClearStencil              = NULL;
+	qglClipPlane                 = NULL;
+	qglColor3b                   = NULL;
+	qglColor3bv                  = NULL;
+	qglColor3d                   = NULL;
+	qglColor3dv                  = NULL;
+	qglColor3f                   = NULL;
+	qglColor3fv                  = NULL;
+	qglColor3i                   = NULL;
+	qglColor3iv                  = NULL;
+	qglColor3s                   = NULL;
+	qglColor3sv                  = NULL;
+	qglColor3ub                  = NULL;
+	qglColor3ubv                 = NULL;
+	qglColor3ui                  = NULL;
+	qglColor3uiv                 = NULL;
+	qglColor3us                  = NULL;
+	qglColor3usv                 = NULL;
+	qglColor4b                   = NULL;
+	qglColor4bv                  = NULL;
+	qglColor4d                   = NULL;
+	qglColor4dv                  = NULL;
+	qglColor4f                   = NULL;
+	qglColor4fv                  = NULL;
+	qglColor4i                   = NULL;
+	qglColor4iv                  = NULL;
+	qglColor4s                   = NULL;
+	qglColor4sv                  = NULL;
+	qglColor4ub                  = NULL;
+	qglColor4ubv                 = NULL;
+	qglColor4ui                  = NULL;
+	qglColor4uiv                 = NULL;
+	qglColor4us                  = NULL;
+	qglColor4usv                 = NULL;
+	qglColorMask                 = NULL;
+	qglColorMaterial             = NULL;
+	qglColorPointer              = NULL;
+	qglCopyPixels                = NULL;
+	qglCopyTexImage1D            = NULL;
+	qglCopyTexImage2D            = NULL;
+	qglCopyTexSubImage1D         = NULL;
+	qglCopyTexSubImage2D         = NULL;
+	qglCullFace                  = NULL;
+	qglDeleteLists               = NULL;
+	qglDeleteTextures            = NULL;
+	qglDepthFunc                 = NULL;
+	qglDepthMask                 = NULL;
+	qglDepthRange                = NULL;
+	qglDisable                   = NULL;
+	qglDisableClientState        = NULL;
+	qglDrawArrays                = NULL;
+	qglDrawBuffer                = NULL;
+	qglDrawElements              = NULL;
+	qglDrawPixels                = NULL;
+	qglEdgeFlag                  = NULL;
+	qglEdgeFlagPointer           = NULL;
+	qglEdgeFlagv                 = NULL;
+	qglEnable                    = NULL;
+	qglEnableClientState         = NULL;
+	qglEnd                       = NULL;
+	qglEndFrame                  = NULL;
+	qglEndShadow                 = NULL;
+	qglEndList                   = NULL;
+	qglEvalCoord1d               = NULL;
+	qglEvalCoord1dv              = NULL;
+	qglEvalCoord1f               = NULL;
+	qglEvalCoord1fv              = NULL;
+	qglEvalCoord2d               = NULL;
+	qglEvalCoord2dv              = NULL;
+	qglEvalCoord2f               = NULL;
+	qglEvalCoord2fv              = NULL;
+	qglEvalMesh1                 = NULL;
+	qglEvalMesh2                 = NULL;
+	qglEvalPoint1                = NULL;
+	qglEvalPoint2                = NULL;
+	qglFeedbackBuffer            = NULL;
+	qglFinish                    = NULL;
+	qglFlush                     = NULL;
+	qglFlushShadow               = NULL;
+	qglFogf                      = NULL;
+	qglFogfv                     = NULL;
+	qglFogi                      = NULL;
+	qglFogiv                     = NULL;
+	qglFrontFace                 = NULL;
+	qglFrustum                   = NULL;
+	qglGenLists                  = NULL;
+	qglGenTextures               = NULL;
+	qglGetBooleanv               = NULL;
+	qglGetClipPlane              = NULL;
+	qglGetDoublev                = NULL;
+	qglGetError                  = NULL;
+	qglGetFloatv                 = NULL;
+	qglGetIntegerv               = NULL;
+	qglGetLightfv                = NULL;
+	qglGetLightiv                = NULL;
+	qglGetMapdv                  = NULL;
+	qglGetMapfv                  = NULL;
+	qglGetMapiv                  = NULL;
+	qglGetMaterialfv             = NULL;
+	qglGetMaterialiv             = NULL;
+	qglGetPixelMapfv             = NULL;
+	qglGetPixelMapuiv            = NULL;
+	qglGetPixelMapusv            = NULL;
+	qglGetPointerv               = NULL;
+	qglGetPolygonStipple         = NULL;
+	qglGetString                 = NULL;
+	qglGetTexEnvfv               = NULL;
+	qglGetTexEnviv               = NULL;
+	qglGetTexGendv               = NULL;
+	qglGetTexGenfv               = NULL;
+	qglGetTexGeniv               = NULL;
+	qglGetTexImage               = NULL;
+	qglGetTexLevelParameterfv    = NULL;
+	qglGetTexLevelParameteriv    = NULL;
+	qglGetTexParameterfv         = NULL;
+	qglGetTexParameteriv         = NULL;
+	qglHint                      = NULL;
+	qglIndexedTriToStrip         = NULL;
+	qglIndexMask                 = NULL;
+	qglIndexPointer              = NULL;
+	qglIndexd                    = NULL;
+	qglIndexdv                   = NULL;
+	qglIndexf                    = NULL;
+	qglIndexfv                   = NULL;
+	qglIndexi                    = NULL;
+	qglIndexiv                   = NULL;
+	qglIndexs                    = NULL;
+	qglIndexsv                   = NULL;
+	qglIndexub                   = NULL;
+	qglIndexubv                  = NULL;
+	qglInitNames                 = NULL;
+	qglInterleavedArrays         = NULL;
+	qglIsEnabled                 = NULL;
+	qglIsList                    = NULL;
+	qglIsTexture                 = NULL;
+	qglLightModelf               = NULL;
+	qglLightModelfv              = NULL;
+	qglLightModeli               = NULL;
+	qglLightModeliv              = NULL;
+	qglLightf                    = NULL;
+	qglLightfv                   = NULL;
+	qglLighti                    = NULL;
+	qglLightiv                   = NULL;
+	qglLineStipple               = NULL;
+	qglLineWidth                 = NULL;
+	qglListBase                  = NULL;
+	qglLoadIdentity              = NULL;
+	qglLoadMatrixd               = NULL;
+	qglLoadMatrixf               = NULL;
+	qglLoadName                  = NULL;
+	qglLogicOp                   = NULL;
+	qglMap1d                     = NULL;
+	qglMap1f                     = NULL;
+	qglMap2d                     = NULL;
+	qglMap2f                     = NULL;
+	qglMapGrid1d                 = NULL;
+	qglMapGrid1f                 = NULL;
+	qglMapGrid2d                 = NULL;
+	qglMapGrid2f                 = NULL;
+	qglMaterialf                 = NULL;
+	qglMaterialfv                = NULL;
+	qglMateriali                 = NULL;
+	qglMaterialiv                = NULL;
+	qglMatrixMode                = NULL;
+	qglMultMatrixd               = NULL;
+	qglMultMatrixf               = NULL;
+	qglNewList                   = NULL;
+	qglNormal3b                  = NULL;
+	qglNormal3bv                 = NULL;
+	qglNormal3d                  = NULL;
+	qglNormal3dv                 = NULL;
+	qglNormal3f                  = NULL;
+	qglNormal3fv                 = NULL;
+	qglNormal3i                  = NULL;
+	qglNormal3iv                 = NULL;
+	qglNormal3s                  = NULL;
+	qglNormal3sv                 = NULL;
+	qglNormalPointer             = NULL;
+	qglOrtho                     = NULL;
+	qglPassThrough               = NULL;
+	qglPixelMapfv                = NULL;
+	qglPixelMapuiv               = NULL;
+	qglPixelMapusv               = NULL;
+	qglPixelStoref               = NULL;
+	qglPixelStorei               = NULL;
+	qglPixelTransferf            = NULL;
+	qglPixelTransferi            = NULL;
+	qglPixelZoom                 = NULL;
+	qglPointSize                 = NULL;
+	qglPolygonMode               = NULL;
+	qglPolygonOffset             = NULL;
+	qglPolygonStipple            = NULL;
+	qglPopAttrib                 = NULL;
+	qglPopClientAttrib           = NULL;
+	qglPopMatrix                 = NULL;
+	qglPopName                   = NULL;
+	qglPrioritizeTextures        = NULL;
+	qglPushAttrib                = NULL;
+	qglPushClientAttrib          = NULL;
+	qglPushMatrix                = NULL;
+	qglPushName                  = NULL;
+	qglRasterPos2d               = NULL;
+	qglRasterPos2dv              = NULL;
+	qglRasterPos2f               = NULL;
+	qglRasterPos2fv              = NULL;
+	qglRasterPos2i               = NULL;
+	qglRasterPos2iv              = NULL;
+	qglRasterPos2s               = NULL;
+	qglRasterPos2sv              = NULL;
+	qglRasterPos3d               = NULL;
+	qglRasterPos3dv              = NULL;
+	qglRasterPos3f               = NULL;
+	qglRasterPos3fv              = NULL;
+	qglRasterPos3i               = NULL;
+	qglRasterPos3iv              = NULL;
+	qglRasterPos3s               = NULL;
+	qglRasterPos3sv              = NULL;
+	qglRasterPos4d               = NULL;
+	qglRasterPos4dv              = NULL;
+	qglRasterPos4f               = NULL;
+	qglRasterPos4fv              = NULL;
+	qglRasterPos4i               = NULL;
+	qglRasterPos4iv              = NULL;
+	qglRasterPos4s               = NULL;
+	qglRasterPos4sv              = NULL;
+	qglReadBuffer                = NULL;
+	qglReadPixels                = NULL;
+	qglRectd                     = NULL;
+	qglRectdv                    = NULL;
+	qglRectf                     = NULL;
+	qglRectfv                    = NULL;
+	qglRecti                     = NULL;
+	qglRectiv                    = NULL;
+	qglRects                     = NULL;
+	qglRectsv                    = NULL;
+	qglRenderMode                = NULL;
+	qglRotated                   = NULL;
+	qglRotatef                   = NULL;
+	qglScaled                    = NULL;
+	qglScalef                    = NULL;
+	qglScissor                   = NULL;
+	qglSelectBuffer              = NULL;
+	qglShadeModel                = NULL;
+	qglStencilFunc               = NULL;
+	qglStencilMask               = NULL;
+	qglStencilOp                 = NULL;
+	qglTexCoord1d                = NULL;
+	qglTexCoord1dv               = NULL;
+	qglTexCoord1f                = NULL;
+	qglTexCoord1fv               = NULL;
+	qglTexCoord1i                = NULL;
+	qglTexCoord1iv               = NULL;
+	qglTexCoord1s                = NULL;
+	qglTexCoord1sv               = NULL;
+	qglTexCoord2d                = NULL;
+	qglTexCoord2dv               = NULL;
+	qglTexCoord2f                = NULL;
+	qglTexCoord2fv               = NULL;
+	qglTexCoord2i                = NULL;
+	qglTexCoord2iv               = NULL;
+	qglTexCoord2s                = NULL;
+	qglTexCoord2sv               = NULL;
+	qglTexCoord3d                = NULL;
+	qglTexCoord3dv               = NULL;
+	qglTexCoord3f                = NULL;
+	qglTexCoord3fv               = NULL;
+	qglTexCoord3i                = NULL;
+	qglTexCoord3iv               = NULL;
+	qglTexCoord3s                = NULL;
+	qglTexCoord3sv               = NULL;
+	qglTexCoord4d                = NULL;
+	qglTexCoord4dv               = NULL;
+	qglTexCoord4f                = NULL;
+	qglTexCoord4fv               = NULL;
+	qglTexCoord4i                = NULL;
+	qglTexCoord4iv               = NULL;
+	qglTexCoord4s                = NULL;
+	qglTexCoord4sv               = NULL;
+	qglTexCoordPointer           = NULL;
+	qglTexEnvf                   = NULL;
+	qglTexEnvfv                  = NULL;
+	qglTexEnvi                   = NULL;
+	qglTexEnviv                  = NULL;
+	qglTexGend                   = NULL;
+	qglTexGendv                  = NULL;
+	qglTexGenf                   = NULL;
+	qglTexGenfv                  = NULL;
+	qglTexGeni                   = NULL;
+	qglTexGeniv                  = NULL;
+	qglTexImage1D                = NULL;
+	qglTexImage2D                = NULL;
+	qglTexImage2DEXT             = NULL;
+	qglTexParameterf             = NULL;
+	qglTexParameterfv            = NULL;
+	qglTexParameteri             = NULL;
+	qglTexParameteriv            = NULL;
+	qglTexSubImage1D             = NULL;
+	qglTexSubImage2D             = NULL;
+	qglTranslated                = NULL;
+	qglTranslatef                = NULL;
+	qglVertex2d                  = NULL;
+	qglVertex2dv                 = NULL;
+	qglVertex2f                  = NULL;
+	qglVertex2fv                 = NULL;
+	qglVertex2i                  = NULL;
+	qglVertex2iv                 = NULL;
+	qglVertex2s                  = NULL;
+	qglVertex2sv                 = NULL;
+	qglVertex3d                  = NULL;
+	qglVertex3dv                 = NULL;
+	qglVertex3f                  = NULL;
+	qglVertex3fv                 = NULL;
+	qglVertex3i                  = NULL;
+	qglVertex3iv                 = NULL;
+	qglVertex3s                  = NULL;
+	qglVertex3sv                 = NULL;
+	qglVertex4d                  = NULL;
+	qglVertex4dv                 = NULL;
+	qglVertex4f                  = NULL;
+	qglVertex4fv                 = NULL;
+	qglVertex4i                  = NULL;
+	qglVertex4iv                 = NULL;
+	qglVertex4s                  = NULL;
+	qglVertex4sv                 = NULL;
+	qglVertexPointer             = NULL;
+	qglViewport                  = NULL;
+
+	qglActiveTextureARB          = NULL;
+	qglClientActiveTextureARB    = NULL;
+	qglMultiTexCoord2fARB        = NULL;
+}
+
+/*
+** QGL_Init
+**
+** This is responsible for binding our qgl function pointers to 
+** the appropriate GL stuff.  In Windows this means doing a 
+** LoadLibrary and a bunch of calls to GetProcAddress.  On other
+** operating systems we need to do the right thing, whatever that
+** might be.
+*/
+qboolean QGL_Init( const char *dllname )
+{
+	qglAccum                     = dllAccum;
+	qglAlphaFunc                 = dllAlphaFunc;
+	qglAreTexturesResident       = dllAreTexturesResident;
+	qglArrayElement              = dllArrayElement;
+	qglBegin                     = dllBegin;
+	qglBeginEXT                  = dllBeginEXT;
+	qglBeginFrame                = dllBeginFrame;
+	qglBeginShadow               = dllBeginShadow;
+	qglBindTexture               = dllBindTexture;
+	qglBitmap                    = dllBitmap;
+	qglBlendFunc                 = dllBlendFunc;
+	qglCallList                  = dllCallList;
+	qglCallLists                 = dllCallLists;
+	qglClear                     = dllClear;
+	qglClearAccum                = dllClearAccum;
+	qglClearColor                = dllClearColor;
+	qglClearDepth                = dllClearDepth;
+	qglClearIndex                = dllClearIndex;
+	qglClearStencil              = dllClearStencil;
+	qglClipPlane                 = dllClipPlane;
+	qglColor3b                   = dllColor3b;
+	qglColor3bv                  = dllColor3bv;
+	qglColor3d                   = dllColor3d;
+	qglColor3dv                  = dllColor3dv;
+	qglColor3f                   = dllColor3f;
+	qglColor3fv                  = dllColor3fv;
+	qglColor3i                   = dllColor3i;
+	qglColor3iv                  = dllColor3iv;
+	qglColor3s                   = dllColor3s;
+	qglColor3sv                  = dllColor3sv;
+	qglColor3ub                  = dllColor3ub;
+	qglColor3ubv                 = dllColor3ubv;
+	qglColor3ui                  = dllColor3ui;
+	qglColor3uiv                 = dllColor3uiv;
+	qglColor3us                  = dllColor3us;
+	qglColor3usv                 = dllColor3usv;
+	qglColor4b                   = dllColor4b;
+	qglColor4bv                  = dllColor4bv;
+	qglColor4d                   = dllColor4d;
+	qglColor4dv                  = dllColor4dv;
+	qglColor4f                   = dllColor4f;
+	qglColor4fv                  = dllColor4fv;
+	qglColor4i                   = dllColor4i;
+	qglColor4iv                  = dllColor4iv;
+	qglColor4s                   = dllColor4s;
+	qglColor4sv                  = dllColor4sv;
+	qglColor4ub                  = dllColor4ub;
+	qglColor4ubv                 = dllColor4ubv;
+	qglColor4ui                  = dllColor4ui;
+	qglColor4uiv                 = dllColor4uiv;
+	qglColor4us                  = dllColor4us;
+	qglColor4usv                 = dllColor4usv;
+	qglColorMask                 = dllColorMask;
+	qglColorMaterial             = dllColorMaterial;
+	qglColorPointer              = dllColorPointer;
+	qglCopyPixels                = dllCopyPixels;
+	qglCopyTexImage1D            = dllCopyTexImage1D;
+	qglCopyTexImage2D            = dllCopyTexImage2D;
+	qglCopyTexSubImage1D         = dllCopyTexSubImage1D;
+	qglCopyTexSubImage2D         = dllCopyTexSubImage2D;
+	qglCullFace                  = dllCullFace;
+	qglDeleteLists               = dllDeleteLists;
+	qglDeleteTextures            = dllDeleteTextures;
+	qglDepthFunc                 = dllDepthFunc;
+	qglDepthMask                 = dllDepthMask;
+	qglDepthRange                = dllDepthRange;
+	qglDisable                   = dllDisable;
+	qglDisableClientState        = dllDisableClientState;
+	qglDrawArrays                = dllDrawArrays;
+	qglDrawBuffer                = dllDrawBuffer;
+	qglDrawElements              = dllDrawElements;
+	qglDrawPixels                = dllDrawPixels;
+	qglEdgeFlag                  = dllEdgeFlag;
+	qglEdgeFlagPointer           = dllEdgeFlagPointer;
+	qglEdgeFlagv                 = dllEdgeFlagv;
+	qglEnable                    = 	dllEnable                   ;
+	qglEnableClientState         = 	dllEnableClientState        ;
+	qglEnd                       = 	dllEnd                      ;
+	qglEndFrame                  = 	dllEndFrame                 ;
+	qglEndShadow                 = 	dllEndShadow                ;
+	qglEndList                   = 	dllEndList                  ;
+	qglEvalCoord1d				 = 	dllEvalCoord1d				;
+	qglEvalCoord1dv              = 	dllEvalCoord1dv             ;
+	qglEvalCoord1f               = 	dllEvalCoord1f              ;
+	qglEvalCoord1fv              = 	dllEvalCoord1fv             ;
+	qglEvalCoord2d               = 	dllEvalCoord2d              ;
+	qglEvalCoord2dv              = 	dllEvalCoord2dv             ;
+	qglEvalCoord2f               = 	dllEvalCoord2f              ;
+	qglEvalCoord2fv              = 	dllEvalCoord2fv             ;
+	qglEvalMesh1                 = 	dllEvalMesh1                ;
+	qglEvalMesh2                 = 	dllEvalMesh2                ;
+	qglEvalPoint1                = 	dllEvalPoint1               ;
+	qglEvalPoint2                = 	dllEvalPoint2               ;
+	qglFeedbackBuffer            = 	dllFeedbackBuffer           ;
+	qglFinish                    = 	dllFinish                   ;
+	qglFlush                     = 	dllFlush                    ;
+	qglFlushShadow               = 	dllFlushShadow              ;
+	qglFogf                      = 	dllFogf                     ;
+	qglFogfv                     = 	dllFogfv                    ;
+	qglFogi                      = 	dllFogi                     ;
+	qglFogiv                     = 	dllFogiv                    ;
+	qglFrontFace                 = 	dllFrontFace                ;
+	qglFrustum                   = 	dllFrustum                  ;
+	qglGenLists                  = 	dllGenLists                 ;
+	qglGenTextures               = 	dllGenTextures              ;
+	qglGetBooleanv               = 	dllGetBooleanv              ;
+	qglGetClipPlane              = 	dllGetClipPlane             ;
+	qglGetDoublev                = 	dllGetDoublev               ;
+	qglGetError                  = 	dllGetError                 ;
+	qglGetFloatv                 = 	dllGetFloatv                ;
+	qglGetIntegerv               = 	dllGetIntegerv              ;
+	qglGetLightfv                = 	dllGetLightfv               ;
+	qglGetLightiv                = 	dllGetLightiv               ;
+	qglGetMapdv                  = 	dllGetMapdv                 ;
+	qglGetMapfv                  = 	dllGetMapfv                 ;
+	qglGetMapiv                  = 	dllGetMapiv                 ;
+	qglGetMaterialfv             = 	dllGetMaterialfv            ;
+	qglGetMaterialiv             = 	dllGetMaterialiv            ;
+	qglGetPixelMapfv             = 	dllGetPixelMapfv            ;
+	qglGetPixelMapuiv            = 	dllGetPixelMapuiv           ;
+	qglGetPixelMapusv            = 	dllGetPixelMapusv           ;
+	qglGetPointerv               = 	dllGetPointerv              ;
+	qglGetPolygonStipple         = 	dllGetPolygonStipple        ;
+	qglGetString                 = 	dllGetString                ;
+	qglGetTexEnvfv               = 	dllGetTexEnvfv              ;
+	qglGetTexEnviv               = 	dllGetTexEnviv              ;
+	qglGetTexGendv               = 	dllGetTexGendv              ;
+	qglGetTexGenfv               = 	dllGetTexGenfv              ;
+	qglGetTexGeniv               = 	dllGetTexGeniv              ;
+	qglGetTexImage               = 	dllGetTexImage              ;
+//	qglGetTexLevelParameterfv    = 	dllGetTexLevelParameterfv   ;
+//	qglGetTexLevelParameteriv    = 	dllGetTexLevelParameteriv   ;
+	qglGetTexParameterfv         = 	dllGetTexParameterfv        ;
+	qglGetTexParameteriv         = 	dllGetTexParameteriv        ;
+	qglHint                      = 	dllHint                     ;
+	qglIndexedTriToStrip         =  dllIndexedTriToStrip        ;
+	qglIndexMask                 = 	dllIndexMask                ;
+	qglIndexPointer              = 	dllIndexPointer             ;
+	qglIndexd                    = 	dllIndexd                   ;
+	qglIndexdv                   = 	dllIndexdv                  ;
+	qglIndexf                    = 	dllIndexf                   ;
+	qglIndexfv                   = 	dllIndexfv                  ;
+	qglIndexi                    = 	dllIndexi                   ;
+	qglIndexiv                   = 	dllIndexiv                  ;
+	qglIndexs                    = 	dllIndexs                   ;
+	qglIndexsv                   = 	dllIndexsv                  ;
+	qglIndexub                   = 	dllIndexub                  ;
+	qglIndexubv                  = 	dllIndexubv                 ;
+	qglInitNames                 = 	dllInitNames                ;
+	qglInterleavedArrays         = 	dllInterleavedArrays        ;
+	qglIsEnabled                 = 	dllIsEnabled                ;
+	qglIsList                    = 	dllIsList                   ;
+	qglIsTexture                 = 	dllIsTexture                ;
+	qglLightModelf               = 	dllLightModelf              ;
+	qglLightModelfv              = 	dllLightModelfv             ;
+	qglLightModeli               = 	dllLightModeli              ;
+	qglLightModeliv              = 	dllLightModeliv             ;
+	qglLightf                    = 	dllLightf                   ;
+	qglLightfv                   = 	dllLightfv                  ;
+	qglLighti                    = 	dllLighti                   ;
+	qglLightiv                   = 	dllLightiv                  ;
+	qglLineStipple               = 	dllLineStipple              ;
+	qglLineWidth                 = 	dllLineWidth                ;
+	qglListBase                  = 	dllListBase                 ;
+	qglLoadIdentity              = 	dllLoadIdentity             ;
+	qglLoadMatrixd               = 	dllLoadMatrixd              ;
+	qglLoadMatrixf               = 	dllLoadMatrixf              ;
+	qglLoadName                  = 	dllLoadName                 ;
+	qglLogicOp                   = 	dllLogicOp                  ;
+	qglMap1d                     = 	dllMap1d                    ;
+	qglMap1f                     = 	dllMap1f                    ;
+	qglMap2d                     = 	dllMap2d                    ;
+	qglMap2f                     = 	dllMap2f                    ;
+	qglMapGrid1d                 = 	dllMapGrid1d                ;
+	qglMapGrid1f                 = 	dllMapGrid1f                ;
+	qglMapGrid2d                 = 	dllMapGrid2d                ;
+	qglMapGrid2f                 = 	dllMapGrid2f                ;
+	qglMaterialf                 = 	dllMaterialf                ;
+	qglMaterialfv                = 	dllMaterialfv               ;
+	qglMateriali                 = 	dllMateriali                ;
+	qglMaterialiv                = 	dllMaterialiv               ;
+	qglMatrixMode                = 	dllMatrixMode               ;
+	qglMultMatrixd               = 	dllMultMatrixd              ;
+	qglMultMatrixf               = 	dllMultMatrixf              ;
+	qglNewList                   = 	dllNewList                  ;
+	qglNormal3b                  = 	dllNormal3b                 ;
+	qglNormal3bv                 = 	dllNormal3bv                ;
+	qglNormal3d                  = 	dllNormal3d                 ;
+	qglNormal3dv                 = 	dllNormal3dv                ;
+	qglNormal3f                  = 	dllNormal3f                 ;
+	qglNormal3fv                 = 	dllNormal3fv                ;
+	qglNormal3i                  = 	dllNormal3i                 ;
+	qglNormal3iv                 = 	dllNormal3iv                ;
+	qglNormal3s                  = 	dllNormal3s                 ;
+	qglNormal3sv                 = 	dllNormal3sv                ;
+	qglNormalPointer             = 	dllNormalPointer            ;
+	qglOrtho                     = 	dllOrtho                    ;
+	qglPassThrough               = 	dllPassThrough              ;
+	qglPixelMapfv                = 	dllPixelMapfv               ;
+	qglPixelMapuiv               = 	dllPixelMapuiv              ;
+	qglPixelMapusv               = 	dllPixelMapusv              ;
+	qglPixelStoref               = 	dllPixelStoref              ;
+	qglPixelStorei               = 	dllPixelStorei              ;
+	qglPixelTransferf            = 	dllPixelTransferf           ;
+	qglPixelTransferi            = 	dllPixelTransferi           ;
+	qglPixelZoom                 = 	dllPixelZoom                ;
+	qglPointSize                 = 	dllPointSize                ;
+	qglPolygonMode               = 	dllPolygonMode              ;
+	qglPolygonOffset             = 	dllPolygonOffset            ;
+	qglPolygonStipple            = 	dllPolygonStipple           ;
+	qglPopAttrib                 = 	dllPopAttrib                ;
+	qglPopClientAttrib           = 	dllPopClientAttrib          ;
+	qglPopMatrix                 = 	dllPopMatrix                ;
+	qglPopName                   = 	dllPopName                  ;
+	qglPrioritizeTextures        = 	dllPrioritizeTextures       ;
+	qglPushAttrib                = 	dllPushAttrib               ;
+	qglPushClientAttrib          = 	dllPushClientAttrib         ;
+	qglPushMatrix                = 	dllPushMatrix               ;
+	qglPushName                  = 	dllPushName                 ;
+	qglRasterPos2d               = 	dllRasterPos2d              ;
+	qglRasterPos2dv              = 	dllRasterPos2dv             ;
+	qglRasterPos2f               = 	dllRasterPos2f              ;
+	qglRasterPos2fv              = 	dllRasterPos2fv             ;
+	qglRasterPos2i               = 	dllRasterPos2i              ;
+	qglRasterPos2iv              = 	dllRasterPos2iv             ;
+	qglRasterPos2s               = 	dllRasterPos2s              ;
+	qglRasterPos2sv              = 	dllRasterPos2sv             ;
+	qglRasterPos3d               = 	dllRasterPos3d              ;
+	qglRasterPos3dv              = 	dllRasterPos3dv             ;
+	qglRasterPos3f               = 	dllRasterPos3f              ;
+	qglRasterPos3fv              = 	dllRasterPos3fv             ;
+	qglRasterPos3i               = 	dllRasterPos3i              ;
+	qglRasterPos3iv              = 	dllRasterPos3iv             ;
+	qglRasterPos3s               = 	dllRasterPos3s              ;
+	qglRasterPos3sv              = 	dllRasterPos3sv             ;
+	qglRasterPos4d               = 	dllRasterPos4d              ;
+	qglRasterPos4dv              = 	dllRasterPos4dv             ;
+	qglRasterPos4f               = 	dllRasterPos4f              ;
+	qglRasterPos4fv              = 	dllRasterPos4fv             ;
+	qglRasterPos4i               = 	dllRasterPos4i              ;
+	qglRasterPos4iv              = 	dllRasterPos4iv             ;
+	qglRasterPos4s               = 	dllRasterPos4s              ;
+	qglRasterPos4sv              = 	dllRasterPos4sv             ;
+	qglReadBuffer                = 	dllReadBuffer               ;
+	qglReadPixels                = 	dllReadPixels               ;
+	qglCopyBackBufferToTexEXT	 =	dllCopyBackBufferToTexEXT	;
+	qglCopyBackBufferToTex		 =	dllCopyBackBufferToTex		;
+	qglRectd                     = 	dllRectd                    ;
+	qglRectdv                    = 	dllRectdv                   ;
+	qglRectf                     = 	dllRectf                    ;
+	qglRectfv                    = 	dllRectfv                   ;
+	qglRecti                     = 	dllRecti                    ;
+	qglRectiv                    = 	dllRectiv                   ;
+	qglRects                     = 	dllRects                    ;
+	qglRectsv                    = 	dllRectsv                   ;
+	qglRenderMode                = 	dllRenderMode               ;
+	qglRotated                   = 	dllRotated                  ;
+	qglRotatef                   = 	dllRotatef                  ;
+	qglScaled                    = 	dllScaled                   ;
+	qglScalef                    = 	dllScalef                   ;
+	qglScissor                   = 	dllScissor                  ;
+	qglSelectBuffer              = 	dllSelectBuffer             ;
+	qglShadeModel                = 	dllShadeModel               ;
+	qglStencilFunc               = 	dllStencilFunc              ;
+	qglStencilMask               = 	dllStencilMask              ;
+	qglStencilOp                 = 	dllStencilOp                ;
+	qglTexCoord1d                = 	dllTexCoord1d               ;
+	qglTexCoord1dv               = 	dllTexCoord1dv              ;
+	qglTexCoord1f                = 	dllTexCoord1f               ;
+	qglTexCoord1fv               = 	dllTexCoord1fv              ;
+	qglTexCoord1i                = 	dllTexCoord1i               ;
+	qglTexCoord1iv               = 	dllTexCoord1iv              ;
+	qglTexCoord1s                = 	dllTexCoord1s               ;
+	qglTexCoord1sv               = 	dllTexCoord1sv              ;
+	qglTexCoord2d                = 	dllTexCoord2d               ;
+	qglTexCoord2dv               = 	dllTexCoord2dv              ;
+	qglTexCoord2f                = 	dllTexCoord2f               ;
+	qglTexCoord2fv               = 	dllTexCoord2fv              ;
+	qglTexCoord2i                = 	dllTexCoord2i               ;
+	qglTexCoord2iv               = 	dllTexCoord2iv              ;
+	qglTexCoord2s                = 	dllTexCoord2s               ;
+	qglTexCoord2sv               = 	dllTexCoord2sv              ;
+	qglTexCoord3d                = 	dllTexCoord3d               ;
+	qglTexCoord3dv               = 	dllTexCoord3dv              ;
+	qglTexCoord3f                = 	dllTexCoord3f               ;
+	qglTexCoord3fv               = 	dllTexCoord3fv              ;
+	qglTexCoord3i                = 	dllTexCoord3i               ;
+	qglTexCoord3iv               = 	dllTexCoord3iv              ;
+	qglTexCoord3s                = 	dllTexCoord3s               ;
+	qglTexCoord3sv               = 	dllTexCoord3sv              ;
+	qglTexCoord4d                = 	dllTexCoord4d               ;
+	qglTexCoord4dv               = 	dllTexCoord4dv              ;
+	qglTexCoord4f                = 	dllTexCoord4f               ;
+	qglTexCoord4fv               = 	dllTexCoord4fv              ;
+	qglTexCoord4i                = 	dllTexCoord4i               ;
+	qglTexCoord4iv               = 	dllTexCoord4iv              ;
+	qglTexCoord4s                = 	dllTexCoord4s               ;
+	qglTexCoord4sv               = 	dllTexCoord4sv              ;
+	qglTexCoordPointer           = 	dllTexCoordPointer          ;
+	qglTexEnvf                   = 	dllTexEnvf                  ;
+	qglTexEnvfv                  = 	dllTexEnvfv                 ;
+	qglTexEnvi                   = 	dllTexEnvi                  ;
+	qglTexEnviv                  = 	dllTexEnviv                 ;
+	qglTexGend                   = 	dllTexGend                  ;
+	qglTexGendv                  = 	dllTexGendv                 ;
+	qglTexGenf                   = 	dllTexGenf                  ;
+	qglTexGenfv                  = 	dllTexGenfv                 ;
+	qglTexGeni                   = 	dllTexGeni                  ;
+	qglTexGeniv                  = 	dllTexGeniv                 ;
+	qglTexImage1D                = 	dllTexImage1D               ;
+	qglTexImage2D                = 	dllTexImage2D               ;
+	qglTexImage2DEXT             = 	dllTexImage2DEXT            ;
+	qglTexParameterf             = 	dllTexParameterf            ;
+	qglTexParameterfv            = 	dllTexParameterfv           ;
+	qglTexParameteri             = 	dllTexParameteri            ;
+	qglTexParameteriv            = 	dllTexParameteriv           ;
+	qglTexSubImage1D             = 	dllTexSubImage1D            ;
+	qglTexSubImage2D             = 	dllTexSubImage2D            ;
+	qglTranslated                = 	dllTranslated               ;
+	qglTranslatef                = 	dllTranslatef               ;
+	qglVertex2d                  = 	dllVertex2d                 ;
+	qglVertex2dv                 = 	dllVertex2dv                ;
+	qglVertex2f                  = 	dllVertex2f                 ;
+	qglVertex2fv                 = 	dllVertex2fv                ;
+	qglVertex2i                  = 	dllVertex2i                 ;
+	qglVertex2iv                 = 	dllVertex2iv                ;
+	qglVertex2s                  = 	dllVertex2s                 ;
+	qglVertex2sv                 = 	dllVertex2sv                ;
+	qglVertex3d                  = 	dllVertex3d                 ;
+	qglVertex3dv                 = 	dllVertex3dv                ;
+	qglVertex3f                  = 	dllVertex3f                 ;
+	qglVertex3fv                 = 	dllVertex3fv                ;
+	qglVertex3i                  = 	dllVertex3i                 ;
+	qglVertex3iv                 = 	dllVertex3iv                ;
+	qglVertex3s                  = 	dllVertex3s                 ;
+	qglVertex3sv                 = 	dllVertex3sv                ;
+	qglVertex4d                  = 	dllVertex4d                 ;
+	qglVertex4dv                 = 	dllVertex4dv                ;
+	qglVertex4f                  = 	dllVertex4f                 ;
+	qglVertex4fv                 = 	dllVertex4fv                ;
+	qglVertex4i                  = 	dllVertex4i                 ;
+	qglVertex4iv                 = 	dllVertex4iv                ;
+	qglVertex4s                  = 	dllVertex4s                 ;
+	qglVertex4sv                 = 	dllVertex4sv                ;
+	qglVertexPointer             = 	dllVertexPointer            ;
+	qglViewport                  = 	dllViewport                 ;
+
+	qglActiveTextureARB          =  dllActiveTextureARB         ;
+	qglClientActiveTextureARB    =  dllClientActiveTextureARB   ;
+	qglMultiTexCoord2fARB        =  dllMultiTexCoord2fARB       ;
+
+	return qtrue;
+}
+
+void QGL_EnableLogging( qboolean enable )
+{
+}
+
+// Extra functions bound to d3d_ commands for controlling crazy D3D performance things
+#ifndef FINAL_BUILD
+
+// D3D_AutoPerfData controls automatic display of performance information:
+// framerate, push buffer data, etc... Usage:
+// d3d_autoperf				- Toggle on and off
+// d3d_autoperf n			- Set display frequency in ms (default 5000)
+static void D3D_AutoPerfData_f( void )
+{
+	static DWORD sdwInterval = 5000;
+	static bool sbEnabled = false;
+
+	int numArgs = Cmd_Argc();
+
+	if (numArgs > 2)
+	{
+		Com_Printf("D3D_AutoPerfData_f: Too many arguments.\n");
+	}
+	else if (numArgs <= 1)
+	{
+		sbEnabled = !sbEnabled;
+		D3DPERF_SetShowFrameRateInterval(sbEnabled ? sdwInterval : 0);
+	}
+	else // numArgs == 2 -> Exactly one real argument
+	{
+		int new_interval = atoi(Cmd_Argv(1));
+
+		if (!new_interval)
+		{
+			// Fancy way to turn it off, don't change stored interval
+			sbEnabled = false;
+		}
+		else
+		{
+			// Force it on
+			sdwInterval = new_interval;
+			sbEnabled = true;
+		}
+		D3DPERF_SetShowFrameRateInterval(sbEnabled ? sdwInterval : 0);
+	}
+}
+
+#endif
+
+extern void GLimp_SetGamma(float);
+
+
+static void _createWindow(int width, int height, int colorbits, qboolean cdsFullscreen)
+{
+	glConfig.colorBits = colorbits;
+
+	if ( r_depthbits->integer == 0 ) {
+		if ( colorbits > 16 ) {
+			glConfig.depthBits = 24;
+		} else {
+			glConfig.depthBits = 16;
+		}
+	} else {
+		glConfig.depthBits = r_depthbits->integer;
+	}
+	
+	glConfig.stencilBits = r_stencilbits->integer;
+	if ( glConfig.depthBits < 24 )
+	{
+		glConfig.stencilBits = 0;
+	}
+	
+	glConfig.displayFrequency = 75;
+	glConfig.stereoEnabled = qfalse;
+
+	// VVFIXME : This is surely wrong.
+	glConfig.vidHeight = height;
+	glConfig.vidWidth = width;
+
+}
+
+enum VideoModes
+{
+	VM_480i = 0,
+	VM_480p,
+	VM_720p,
+	VM_1080i
+};
+
+
+void GLW_Init(int width, int height, int colorbits, qboolean cdsFullscreen)
+{
+	glw_state = new glwstate_t;
+	int mode = VM_480i;
+
+	glw_state->isWidescreen = false;
+	if( XGetVideoFlags() & XC_VIDEO_FLAGS_WIDESCREEN )
+	{
+		glw_state->isWidescreen = true;
+
+		if( XGetVideoFlags() & XC_VIDEO_FLAGS_HDTV_480p )
+		{
+			width = 720;
+			height = 480;
+			mode = VM_480p;
+		}
+
+		/*if( XGetVideoFlags() & XC_VIDEO_FLAGS_HDTV_720p )
+		{
+			width = 1280;
+			height = 720;
+			mode = VM_720p;
+		}
+
+		if( XGetVideoFlags() & XC_VIDEO_FLAGS_HDTV_1080i )
+		{
+			width = 1920;
+			height = 1080;
+			mode = VM_1080i;
+		}*/
+	}
+
+	_createWindow(width, height, colorbits, cdsFullscreen);
+	
+	glw_state->matrixMode = glwstate_t::MatrixMode_Model;
+	glw_state->inDrawBlock = false;
+	
+	glw_state->serverTU = 0;
+	glw_state->clientTU = 0;
+	
+	glw_state->colorArrayState = false;
+	glw_state->vertexArrayState = false;
+	glw_state->normalArrayState = false;
+
+	glw_state->cullEnable = true;
+	glw_state->cullMode = D3DCULL_CCW;
+
+	glw_state->scissorEnable = false;
+	glw_state->scissorBox.x1 = 0;
+	glw_state->scissorBox.y1 = 0;
+	glw_state->scissorBox.x2 = glConfig.vidWidth;
+	glw_state->scissorBox.y2 = glConfig.vidHeight;
+
+	glw_state->shaderMask = 0;
+
+	glw_state->clearColor = D3DCOLOR_RGBA(255, 255, 255, 255);
+	glw_state->clearDepth = 1.f;
+	glw_state->clearStencil = 0;
+
+	glw_state->currentColor = D3DCOLOR_RGBA(255, 255, 255, 255);
+
+	glw_state->viewport.MinZ = 0.f;
+	glw_state->viewport.MaxZ = 1.f;
+
+	for (int t = 0; t < GLW_MAX_TEXTURE_STAGES; ++t)
+	{
+		glw_state->textureEnv[t] = D3DTOP_MODULATE;
+		glw_state->texCoordArrayState[t] = false;
+		glw_state->currentTexture[t] = 0;
+		glw_state->textureStageDirty[t] = false;
+	}
+
+	glw_state->textureBindNum = 1;
+	
+D3DPRESENT_PARAMETERS present;
+	present.BackBufferWidth = width;
+	present.BackBufferHeight = height;
+	present.BackBufferFormat = D3DFMT_A8R8G8B8;
+	present.BackBufferCount = 1;
+	present.MultiSampleType = D3DMULTISAMPLE_NONE;
+	present.SwapEffect = D3DSWAPEFFECT_DISCARD;
+	present.hDeviceWindow = 0;
+	present.Windowed = FALSE;
+	present.EnableAutoDepthStencil = TRUE;
+	present.AutoDepthStencilFormat = D3DFMT_LIN_D24S8;
+	present.Flags = 0;
+	if( glw_state->isWidescreen )
+	{
+		present.Flags = D3DPRESENTFLAG_WIDESCREEN;
+		extern void CGCam_SetWidescreen(qboolean widescreen);
+		if(mode == VM_480p)
+		{
+			present.Flags |= D3DPRESENTFLAG_PROGRESSIVE;
+		}
+		//else if(mode == VM_720p)
+		//{
+		//	present.Flags |= D3DPRESENTFLAG_PROGRESSIVE;
+		//}
+		//else if(mode == VM_1080i)
+		//{
+		//	present.Flags |= D3DPRESENTFLAG_INTERLACED; // | D3DPRESENTFLAG_FIELD;
+		//}
+
+
+        present.Flags |= D3DPRESENTFLAG_WIDESCREEN;
+		CGCam_SetWidescreen(qtrue);
+	}
+
+	present.FullScreen_RefreshRateInHz = D3DPRESENT_RATE_DEFAULT;
+	present.FullScreen_PresentationInterval = D3DPRESENT_INTERVAL_DEFAULT;
+	present.BufferSurfaces[0] = NULL;
+	present.BufferSurfaces[1] = NULL;
+	present.BufferSurfaces[2] = NULL;
+	present.DepthStencilSurface = NULL;
+
+	if (IDirect3D8::CreateDevice(D3DADAPTER_DEFAULT,
+								D3DDEVTYPE_HAL,
+								NULL,
+								D3DCREATE_HARDWARE_VERTEXPROCESSING,
+								&present,
+								&glw_state->device) != D3D_OK)
+	{
+		Com_Printf("Failed to create device. That's bad.\n");
+	}
+//	qglEnable(GL_VSYNC);
+	
+	for (int m = 0; m < glwstate_t::Num_MatrixModes; ++m)
+	{
+		D3DXCreateMatrixStack(0, &glw_state->matrixStack[m]);
+		glw_state->matrixStack[m]->LoadIdentity();
+		glw_state->matricesDirty[m] = false;
+	}
+
+	// VVFIXME: Hack - turn off lighting
+	dllDisable(GL_LIGHTING);
+
+	// Set a material (for lighting)
+	memset( &glw_state->mtrl, 0, sizeof(D3DMATERIAL8) );
+	glw_state->mtrl.Diffuse.r = glw_state->mtrl.Ambient.r = 1.0f;
+	glw_state->mtrl.Diffuse.g = glw_state->mtrl.Ambient.g = 1.0f;
+	glw_state->mtrl.Diffuse.b = glw_state->mtrl.Ambient.b = 1.0f;
+	glw_state->mtrl.Diffuse.a = glw_state->mtrl.Ambient.a = 1.0f;
+	glw_state->device->SetMaterial( &glw_state->mtrl );
+	// Gamma hack
+	GLimp_SetGamma(1.3f);
+
+	// Set up our directional light (used for diffuse lighting)
+	memset(&glw_state->dirLight, 0, sizeof(D3DLIGHT8));
+
+	// Set up a white point light.
+	glw_state->dirLight.Type = D3DLIGHT_DIRECTIONAL;
+	glw_state->dirLight.Diffuse.r  = 1.0f;
+	glw_state->dirLight.Diffuse.g  = 1.0f;
+	glw_state->dirLight.Diffuse.b  = 1.0f;
+	glw_state->dirLight.Direction.x = 1.0f;
+	glw_state->dirLight.Direction.y = 0.0f;
+	glw_state->dirLight.Direction.z = 0.0f;
+
+	// Don't attenuate.
+	glw_state->dirLight.Attenuation0 = 1.0f; 
+	glw_state->dirLight.Range        = 1000.0f;
+
+	//glw_state->drawArray = new DWORD[SHADER_MAX_VERTEXES * 12];
+	glw_state->drawArray = NULL;
+
+#ifdef _XBOX
+#ifdef VV_LIGHTING
+//	glw_state->flareEffect = new FlareEffect;
+//	glw_state->flareEffect->Initialize();
+	glw_state->lightEffects = new LightEffects;
+#endif // VV_LIGHTING
+	HDREffect.Initialize();
+#endif
+
+#ifndef FINAL_BUILD
+	Cmd_AddCommand("d3d_autoperf", D3D_AutoPerfData_f);
+#endif
+}
+
+void GLW_Shutdown(void)
+{
+#ifdef _XBOX
+#ifdef VV_LIGHTING
+	delete glw_state->lightEffects;
+#endif
+#endif
+
+	for (int m = 0; m < glwstate_t::Num_MatrixModes; ++m)
+	{
+		glw_state->matrixStack[m]->Release();
+	}
+
+	glw_state->device->Release();
+
+#ifdef _XBOX
+//	delete glw_state->flareEffect;
+#endif
+
+	delete glw_state;
+}
+
+//-----------------------------------------------------------------------------
+// Compressed Screen Shot code for the save game system
+//-----------------------------------------------------------------------------
+
+#define CSS_IMAGE_HDR_SIZE			2048									
+#define	CSS_IMAGE_WH				256										
+#define	CSS_IMAGE_DATA_SIZE			((CSS_IMAGE_WH * CSS_IMAGE_WH) / 2 )	
+
+struct XprImageHeader
+{
+    XPR_HEADER        xpr;           // Standard XPR struct
+    IDirect3DTexture8 txt;           // Standard D3D texture struct
+    DWORD             dwEndOfHeader; // 0xFFFFFFFF
+};
+
+struct XprImage
+{
+    XprImageHeader hdr;
+    CHAR           strPad[ CSS_IMAGE_HDR_SIZE - sizeof( XprImageHeader ) ];
+    BYTE           pBits[ CSS_IMAGE_DATA_SIZE ];     // data bits
+};
+
+//-----------------------------------------------------------------------------
+// SaveCompressedScreenshot
+// Saves a copy of the backbuffer to a .xbx file specified by filename
+//-----------------------------------------------------------------------------
+void SaveCompressedScreenshot(const char* filename)
+{
+	LPDIRECT3DSURFACE8 screenShot = 0;
+	HRESULT res;
+	glw_state->device->GetBackBuffer(0, D3DBACKBUFFER_TYPE_MONO, &screenShot);
+
+	// Copy over the screen shot to the new image that is CSS_IMAGE_WH x CSS_IMAGE_WH
+	LPDIRECT3DSURFACE8 compressedSaveGameImage = 0;
+    glw_state->device->CreateImageSurface( CSS_IMAGE_WH, CSS_IMAGE_WH, D3DFMT_DXT1, &compressedSaveGameImage );
+	D3DXLoadSurfaceFromSurface( compressedSaveGameImage, NULL, NULL,  screenShot, NULL, NULL, D3DX_DEFAULT, D3DCOLOR( 0 ) );
+  
+	// Free the big screenshot 640x480x4?
+	if ( screenShot )
+		screenShot->Release();
+
+	// Write out the saveimage to the utility drive
+    res = XGWriteSurfaceOrTextureToXPR( compressedSaveGameImage, filename, TRUE );
+
+	// Free the compressed CSS_IMAGE_WH x CSS_IMAGE_WH image
+    if ( compressedSaveGameImage )
+		compressedSaveGameImage->Release();
+}
+
+//-----------------------------------------------------------------------------
+// LoadCompressedScreenshot
+// Loads a .xbx screenshot file and replaces the current texture
+//-----------------------------------------------------------------------------
+BOOL LoadCompressedScreenshot(const char* filename)
+{
+	// get the current texture
+	glwstate_t::TextureInfo* info = _getCurrentTexture(glw_state->serverTU);
+	if (info == NULL) return FALSE;
+
+	// locals
+	LPDIRECT3DTEXTURE8	lpThumbTex;
+	XprImageHeader		XprHeader;
+	DWORD				dwBytesRead;
+	BOOL				bSuccess;
+
+	// See if the image file for this saved game exists
+	HANDLE hFile = CreateFile( filename, GENERIC_READ, 0, NULL, OPEN_EXISTING,0, NULL );
+
+	if( hFile == INVALID_HANDLE_VALUE )
+	{
+		DWORD err = GetLastError();
+
+		// If there was a problem, we might want to load the default image for TRC
+		// TCR C4-18 Saved Game Representative Image
+		// No specific image found; see if the default save image exists
+	/*	
+		hFile = CreateFile( "u:\\default_screen.xbx", GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL );
+		if( hFile == INVALID_HANDLE_VALUE )
+		{
+			m_bIsValidImage = FALSE;
+			return FALSE;
+		}
+	*/
+		return FALSE;
+	}
+
+	
+	// Read the image header from disk
+	bSuccess = ReadFile( hFile, &XprHeader, sizeof( XprImageHeader ), &dwBytesRead, NULL );
+
+	// Validate the image
+	bSuccess &=	dwBytesRead					== sizeof( XprImageHeader ) &&
+				XprHeader.xpr.dwMagic		== XPR_MAGIC_VALUE &&
+				XprHeader.xpr.dwTotalSize	== CSS_IMAGE_HDR_SIZE + CSS_IMAGE_DATA_SIZE &&
+				XprHeader.xpr.dwHeaderSize	== CSS_IMAGE_HDR_SIZE &&
+				XprHeader.dwEndOfHeader		== 0xFFFFFFFF;
+
+	// If image looks good, store the bits in a texture
+	if( bSuccess )
+	{
+		HRESULT hr;
+		hr = glw_state->device->CreateTexture(	CSS_IMAGE_WH,
+												CSS_IMAGE_WH, 
+												1,
+												0,
+												D3DFMT_DXT1,
+												D3DPOOL(),
+												&lpThumbTex );
+		bSuccess = SUCCEEDED(hr);
+
+		if( bSuccess )
+		{
+			D3DLOCKED_RECT lr;
+            lpThumbTex->LockRect( 0, &lr, NULL, D3DLOCK_READONLY );
+
+            // Copy the bits from the file to the texture
+            SetFilePointer( hFile, CSS_IMAGE_HDR_SIZE, NULL, FILE_BEGIN );
+            bSuccess = ReadFile( hFile, lr.pBits, CSS_IMAGE_DATA_SIZE, &dwBytesRead, NULL );
+            bSuccess &= ( dwBytesRead == CSS_IMAGE_DATA_SIZE );
+            lpThumbTex->UnlockRect( 0 );
+
+			// If everything was ok, then set the texture ptrs
+			DWORD refcount;
+			if( bSuccess )
+            {
+				refcount = info->mipmap->Release();
+				
+				assert(refcount == 0);
+
+				info->mipmap = lpThumbTex;
+				info->mipmap->AddRef();
+
+				refcount = lpThumbTex->Release();
+
+				assert(refcount == 1);
+            }
+			else
+			{
+				refcount = lpThumbTex->Release();
+
+				assert(refcount == 0);
+			}
+
+        }
+    }
+    else
+	{
+		return FALSE;
+    }
+
+    CloseHandle( hFile );
+	return bSuccess;
+}
+
+bool CreateVertexShader( const CHAR* strFilename, const DWORD* pdwVertexDecl, DWORD* pdwVertexShader )
+{
+    HRESULT hr;
+
+    // Open the vertex shader file
+    HANDLE hFile;
+    DWORD dwNumBytesRead;
+    hFile = CreateFile( strFilename, GENERIC_READ, FILE_SHARE_READ, NULL,
+                        OPEN_EXISTING, FILE_ATTRIBUTE_READONLY, NULL );
+    if( hFile == INVALID_HANDLE_VALUE )
+        return false;
+
+    // Allocate memory to read the vertex shader file
+    DWORD dwSize = GetFileSize(hFile, NULL);
+    BYTE* pData  = new BYTE[dwSize+4];
+    if( NULL == pData )
+    {
+        CloseHandle( hFile );
+        return false;
+    }
+    ZeroMemory( pData, dwSize+4 );
+
+    // Read the pre-compiled vertex shader microcode
+    ReadFile(hFile, pData, dwSize, &dwNumBytesRead, 0);
+    
+    // Create the vertex shader
+    hr = glw_state->device->CreateVertexShader( pdwVertexDecl, (const DWORD*)pData,
+                                        pdwVertexShader, 0 );
+
+    // Cleanup and return
+    CloseHandle( hFile );
+    delete [] pData;
+
+	if(hr == S_OK)
+		return true;
+
+	return false;
+}
+
+
+bool CreatePixelShader( const CHAR* strFilename, DWORD* pdwPixelShader )
+{
+    HRESULT hr;
+
+    // Open the pixel shader file
+    HANDLE hFile;
+    DWORD dwNumBytesRead;
+    hFile = CreateFile( strFilename, GENERIC_READ, FILE_SHARE_READ, NULL,
+                        OPEN_EXISTING, FILE_ATTRIBUTE_READONLY, NULL );
+    if( hFile == INVALID_HANDLE_VALUE )
+        return false;
+
+    // Load the pre-compiled pixel shader microcode
+    D3DPIXELSHADERDEF_FILE psdf;
+    ReadFile( hFile, &psdf, sizeof(D3DPIXELSHADERDEF_FILE), &dwNumBytesRead, NULL );
+    
+    // Make sure the pixel shader is valid
+    if( psdf.FileID != D3DPIXELSHADERDEF_FILE_ID )
+    {
+        CloseHandle( hFile );
+        return false;
+    }
+
+    // Create the pixel shader
+    if( FAILED( hr = glw_state->device->CreatePixelShader( &(psdf.Psd), pdwPixelShader ) ) )
+    {
+        CloseHandle( hFile );
+        return false;
+    }
+
+    // Cleanup
+    CloseHandle( hFile );
+
+    return true;
+}
diff --git a/code/win32/win_shared.cpp b/code/win32/win_shared.cpp
new file mode 100644
index 0000000..440ac5b
--- /dev/null
+++ b/code/win32/win_shared.cpp
@@ -0,0 +1,281 @@
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+
+
+
+#include "../game/q_shared.h"
+#include "../qcommon/qcommon.h"
+#include "win_local.h"
+
+/*
+================
+Sys_Milliseconds
+================
+*/
+int Sys_Milliseconds (void)
+{
+	static int sys_timeBase = timeGetTime();
+	int			sys_curtime;
+
+	sys_curtime = timeGetTime() - sys_timeBase;
+
+	return sys_curtime;
+}
+
+/*
+** --------------------------------------------------------------------------------
+**
+** PROCESSOR STUFF
+**
+** --------------------------------------------------------------------------------
+*/
+static inline void CPUID( int func, unsigned int regs[4] )
+{
+	unsigned regEAX, regEBX, regECX, regEDX;
+
+	__asm mov eax, func
+	__asm __emit 00fh
+	__asm __emit 0a2h
+	__asm mov regEAX, eax
+	__asm mov regEBX, ebx
+	__asm mov regECX, ecx
+	__asm mov regEDX, edx
+
+	regs[0] = regEAX;
+	regs[1] = regEBX;
+	regs[2] = regECX;
+	regs[3] = regEDX;
+}
+
+static int IsPentium( void )
+{
+	__asm 
+	{
+		pushfd						// save eflags
+		pop		eax
+		test	eax, 0x00200000		// check ID bit
+		jz		set21				// bit 21 is not set, so jump to set_21
+		and		eax, 0xffdfffff		// clear bit 21
+		push	eax					// save new value in register
+		popfd						// store new value in flags
+		pushfd
+		pop		eax
+		test	eax, 0x00200000		// check ID bit
+		jz		good
+		jmp		err					// cpuid not supported
+set21:
+		or		eax, 0x00200000		// set ID bit
+		push	eax					// store new value
+		popfd						// store new value in EFLAGS
+		pushfd
+		pop		eax
+		test	eax, 0x00200000		// if bit 21 is on
+		jnz		good
+		jmp		err
+	}
+
+err:
+	return qfalse;
+good:
+	return qtrue;
+}
+
+static int Is3DNOW( void )
+{
+	unsigned regs[4];
+	char pstring[16];
+	char processorString[13];
+
+	// get name of processor
+	CPUID( 0, ( unsigned int * ) pstring );
+	processorString[0] = pstring[4];
+	processorString[1] = pstring[5];
+	processorString[2] = pstring[6];
+	processorString[3] = pstring[7];
+	processorString[4] = pstring[12];
+	processorString[5] = pstring[13];
+	processorString[6] = pstring[14];
+	processorString[7] = pstring[15];
+	processorString[8] = pstring[8];
+	processorString[9] = pstring[9];
+	processorString[10] = pstring[10];
+	processorString[11] = pstring[11];
+	processorString[12] = 0;
+
+//  REMOVED because you can have 3DNow! on non-AMD systems
+//	if ( strcmp( processorString, "AuthenticAMD" ) )
+//		return qfalse;
+
+	// check AMD-specific functions
+	CPUID( 0x80000000, regs );
+	if ( regs[0] < 0x80000000 )
+		return qfalse;
+
+	// bit 31 of EDX denotes 3DNOW! support
+	CPUID( 0x80000001, regs );
+	if ( regs[3] & ( 1 << 31 ) )
+		return qtrue;
+
+	return qfalse;
+}
+
+static int IsKNI( void )
+{
+	unsigned regs[4];
+
+	// get CPU feature bits
+	CPUID( 1, regs );
+
+	// bit 25 of EDX denotes KNI existence
+	if ( regs[3] & ( 1 << 25 ) )
+	{
+		// Ok, CPU supports this instruction, but does the OS?
+		//
+		// Test a KNI instruction and make sure you don't get an exception...
+		//
+		__try
+		{
+			__asm
+			{
+				pushad;
+			//	orps xmm1,xmm1;		// Below are the op codes for this instruction
+									// emits will compile w/ MSVC 5.0 compiler
+									// You can comment these out and uncomment the
+									// orps when using the Intel Compiler
+				__emit 0x0f
+				__emit 0x56
+				__emit 0xc9
+				popad;
+			}
+		}// If OS creates an exception, it doesn't support Pentium III Instructions
+		__except(EXCEPTION_EXECUTE_HANDLER)
+		{
+			return qfalse;
+		}
+
+		return qtrue;
+	}
+
+	return qfalse;
+}
+
+static int IsWIL( void )
+{
+	unsigned regs[4];
+
+	// get CPU feature bits
+	CPUID( 1, regs );
+
+	// bit 26 of EDX denotes WIL existence
+	if ( regs[3] & ( 1 << 26 ) )
+	{
+		// Ok, CPU supports this instruction, but does the OS?
+		//
+		// Test a WIL instruction and make sure you don't get an exception...
+		//
+		__try
+		{
+			__asm
+			{
+				pushad;
+			// 	xorpd xmm0,xmm0;  // Willamette New Instructions 
+					__emit 0x0f
+					__emit 0x56
+					__emit 0xc9
+				popad;
+			}
+		}// If OS creates an exception, it doesn't support PentiumIV Instructions
+		__except(EXCEPTION_EXECUTE_HANDLER)
+		{
+//			if(_exception_code()==STATUS_ILLEGAL_INSTRUCTION)	// forget it, any exception should count as fail for safety
+				return qfalse; // Willamette New Instructions not supported
+		}
+
+		return qtrue;	// Williamette/P4 instructions available
+	}
+
+	return qfalse;
+
+}
+
+
+static int IsMMX( void )
+{
+	unsigned int regs[4];
+
+	// get CPU feature bits
+	CPUID( 1, regs );
+
+	// bit 23 of EDX denotes MMX existence
+	if ( regs[3] & ( 1 << 23 ) )
+		return qtrue;
+	return qfalse;
+}
+
+int Sys_GetProcessorId( void )
+{
+#if defined _M_ALPHA
+	return CPUID_AXP;
+#elif !defined _M_IX86
+	return CPUID_GENERIC;
+#else
+
+	// verify we're at least a Pentium or 486 w/ CPUID support
+	if ( !IsPentium() )
+		return CPUID_INTEL_UNSUPPORTED;
+
+	// check for MMX
+	if ( !IsMMX() )
+	{
+		// Pentium or PPro
+		return CPUID_INTEL_PENTIUM;
+	}
+
+	// see if we're an AMD 3DNOW! processor
+	if ( Is3DNOW() )
+	{
+		return CPUID_AMD_3DNOW;
+	}
+
+	// see if we're an Intel Katmai
+	if ( IsKNI() )
+	{
+		// if we are, see if we're a Williamette as well...
+		//
+		if ( IsWIL() )
+		{
+			return CPUID_INTEL_WILLIAMETTE;
+		}
+		return CPUID_INTEL_KATMAI;
+	}
+
+	// by default we're functionally a vanilla Pentium/MMX or P2/MMX
+	return CPUID_INTEL_MMX;
+
+#endif
+}
+
+//============================================
+
+char *Sys_GetCurrentUser( void )
+{
+#ifdef _XBOX
+	return NULL;
+#else
+	static char s_userName[1024];
+	unsigned long size = sizeof( s_userName );
+
+
+	if ( !GetUserName( s_userName, &size ) )
+		strcpy( s_userName, "player" );
+
+	if ( !s_userName[0] )
+	{
+		strcpy( s_userName, "player" );
+	}
+
+	return s_userName;
+#endif
+}
\ No newline at end of file
diff --git a/code/win32/win_snd.cpp b/code/win32/win_snd.cpp
new file mode 100644
index 0000000..074dd3f
--- /dev/null
+++ b/code/win32/win_snd.cpp
@@ -0,0 +1,414 @@
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+
+
+#include <float.h>
+
+#include "../client/snd_local.h"
+#include "win_local.h"
+
+HRESULT (WINAPI *pDirectSoundCreate)(GUID FAR *lpGUID, LPDIRECTSOUND FAR *lplpDS, IUnknown FAR *pUnkOuter);
+#define iDirectSoundCreate(a,b,c)	pDirectSoundCreate(a,b,c)
+
+#define SECONDARY_BUFFER_SIZE	0x10000
+
+
+extern int s_UseOpenAL;
+
+static qboolean	dsound_init;
+static int		sample16;
+static DWORD	gSndBufSize;
+static DWORD	locksize;
+static LPDIRECTSOUND pDS;
+static LPDIRECTSOUNDBUFFER pDSBuf, pDSPBuf;
+static HINSTANCE hInstDS;
+
+static int  SNDDMA_InitDS ();
+
+static const char *DSoundError( int error ) {
+	switch ( error ) {
+	case DSERR_BUFFERLOST:
+		return "DSERR_BUFFERLOST";
+	case DSERR_INVALIDCALL:
+		return "DSERR_INVALIDCALLS";
+	case DSERR_INVALIDPARAM:
+		return "DSERR_INVALIDPARAM";
+	case DSERR_PRIOLEVELNEEDED:
+		return "DSERR_PRIOLEVELNEEDED";
+	case DSERR_ALLOCATED:
+		return "DSERR_ALLOCATED";
+	case DSERR_UNINITIALIZED:
+		return "DSERR_UNINITIALIZED";
+	case DSERR_UNSUPPORTED:
+		return "DSERR_UNSUPPORTED ";
+	}
+
+	return "unknown";
+}
+
+/*
+==================
+SNDDMA_Shutdown
+==================
+*/
+void SNDDMA_Shutdown( void ) {
+	Com_DPrintf( "Shutting down sound system\n" );
+
+	if ( pDS ) {
+		Com_DPrintf( "Destroying DS buffers\n" );
+		if ( pDS )
+		{
+			Com_DPrintf( "...setting NORMAL coop level\n" );
+			pDS->SetCooperativeLevel( g_wv.hWnd, DSSCL_NORMAL );
+		}
+
+		if ( pDSBuf )
+		{
+			Com_DPrintf( "...stopping and releasing sound buffer\n" );
+			pDSBuf->Stop( );
+			pDSBuf->Release( );
+		}
+
+		// only release primary buffer if it's not also the mixing buffer we just released
+		if ( pDSPBuf && ( pDSBuf != pDSPBuf ) )
+		{
+			Com_DPrintf( "...releasing primary buffer\n" );
+			pDSPBuf->Release( );
+		}
+		pDSBuf = NULL;
+		pDSPBuf = NULL;
+
+		dma.buffer = NULL;
+
+		Com_DPrintf( "...releasing DS object\n" );
+		pDS->Release( );
+	}
+
+	if ( hInstDS ) {
+		Com_DPrintf( "...freeing DSOUND.DLL\n" );
+		FreeLibrary( hInstDS );
+		hInstDS = NULL;
+	}
+
+	pDS = NULL;
+	pDSBuf = NULL;
+	pDSPBuf = NULL;
+	dsound_init = qfalse;
+	memset ((void *)&dma, 0, sizeof (dma));
+}
+
+/*
+==================
+SNDDMA_Init
+
+Initialize direct sound
+Returns false if failed
+==================
+*/
+qboolean SNDDMA_Init(void) {
+
+	memset ((void *)&dma, 0, sizeof (dma));
+	dsound_init = qfalse;
+
+	if ( !SNDDMA_InitDS () ) {
+		return qfalse;
+	}
+
+	dsound_init = qtrue;
+
+	Com_DPrintf("Completed successfully\n" );
+
+    return qtrue;
+}
+
+
+static int SNDDMA_InitDS ()
+{
+	HRESULT			hresult;
+	qboolean		pauseTried;
+	DSBUFFERDESC	dsbuf;
+	DSBCAPS			dsbcaps;
+	WAVEFORMATEX	format;
+
+	Com_Printf( "Initializing DirectSound\n");
+
+	if ( !hInstDS ) {
+		Com_DPrintf( "...loading dsound.dll: " );
+
+		hInstDS = LoadLibrary("dsound.dll");
+		
+		if ( hInstDS == NULL ) {
+			Com_Printf ("failed\n");
+			return 0;
+		}
+
+		Com_DPrintf ("ok\n");
+		pDirectSoundCreate = (long (__stdcall *)(struct _GUID *,struct IDirectSound ** ,struct IUnknown *))
+			GetProcAddress(hInstDS,"DirectSoundCreate");
+
+		if ( !pDirectSoundCreate ) {
+			Com_Printf ("*** couldn't get DS proc addr ***\n");
+			return 0;
+		}
+	}
+
+	Com_DPrintf( "...creating DS object: " );
+	pauseTried = qfalse;
+	while ( ( hresult = iDirectSoundCreate( NULL, &pDS, NULL ) ) != DS_OK ) {
+		if ( hresult != DSERR_ALLOCATED ) {
+			Com_Printf( "failed\n" );
+			return 0;
+		}
+
+		if ( pauseTried ) {
+			Com_Printf ("failed, hardware already in use\n" );
+			return 0;
+		}
+		// first try just waiting five seconds and trying again
+		// this will handle the case of a sysyem beep playing when the
+		// game starts
+		Com_DPrintf ("retrying...\n");
+		Sleep( 3000 );
+		pauseTried = qtrue;
+	}
+	Com_DPrintf( "ok\n" );
+
+	Com_DPrintf("...setting DSSCL_PRIORITY coop level: " );
+
+	if ( DS_OK != pDS->SetCooperativeLevel( g_wv.hWnd, DSSCL_PRIORITY ) )	{
+		Com_Printf ("failed\n");
+		SNDDMA_Shutdown ();
+		return qfalse;
+	}
+	Com_DPrintf("ok\n" );
+
+
+	// create the secondary buffer we'll actually work with
+	dma.channels = 2;
+	dma.samplebits = 16;
+
+	if (s_khz->integer == 44)
+		dma.speed = 44100;
+	else if (s_khz->integer == 22)
+		dma.speed = 22050;
+	else
+		dma.speed = 11025;
+
+	memset (&format, 0, sizeof(format));
+	format.wFormatTag = WAVE_FORMAT_PCM;
+    format.nChannels = dma.channels;
+    format.wBitsPerSample = dma.samplebits;
+    format.nSamplesPerSec = dma.speed;
+    format.nBlockAlign = format.nChannels * format.wBitsPerSample / 8;
+    format.cbSize = 0;
+    format.nAvgBytesPerSec = format.nSamplesPerSec*format.nBlockAlign; 
+
+	memset (&dsbuf, 0, sizeof(dsbuf));
+	dsbuf.dwSize = sizeof(DSBUFFERDESC);
+
+#define idDSBCAPS_GETCURRENTPOSITION2 0x00010000
+
+	dsbuf.dwFlags = DSBCAPS_CTRLFREQUENCY | DSBCAPS_LOCHARDWARE | idDSBCAPS_GETCURRENTPOSITION2;
+	dsbuf.dwBufferBytes = SECONDARY_BUFFER_SIZE;
+	dsbuf.lpwfxFormat = &format;
+	
+	Com_DPrintf( "...creating secondary buffer: " );
+	hresult = pDS->CreateSoundBuffer(&dsbuf, &pDSBuf, NULL);
+	if (hresult != DS_OK) 
+	{
+		if ( hresult == DSERR_CONTROLUNAVAIL )
+		{
+			Com_Printf( " - Ancient version of DirectX - this will slow FPS\n" );
+			dsbuf.dwFlags &= ~idDSBCAPS_GETCURRENTPOSITION2;	// lose this DX8 cursor-position feature, and try again
+			hresult = pDS->CreateSoundBuffer(&dsbuf, &pDSBuf, NULL);
+		}
+
+		if (hresult != DS_OK)
+		{
+			// we can't even specify sounds should be in hardware?...  
+			//
+			//  ( this seems to happen on integrated sound devices (eg SoundMax), regardless of DX version )
+			//
+			dsbuf.dwFlags = DSBCAPS_CTRLFREQUENCY;	// note that DX docs say that this can still use hardware if it wants to, since neither DSBCAPS_LOCHARDWARE nor DSBCAPS_LOCSOFTWARE were specified
+			hresult = pDS->CreateSoundBuffer(&dsbuf, &pDSBuf, NULL);
+			if (hresult != DS_OK) {			
+				Com_Printf( "failed to create secondary buffer - %s\n", DSoundError( hresult ) );
+				SNDDMA_Shutdown ();
+				return qfalse;
+			}
+		}
+	}
+	Com_Printf( "locked hardware.  ok\n" );
+		
+	// Make sure mixer is active
+	if ( DS_OK != pDSBuf->Play(0, 0, DSBPLAY_LOOPING) ) {
+		Com_Printf ("*** Looped sound play failed ***\n");
+		SNDDMA_Shutdown ();
+		return qfalse;
+	}
+
+	memset(&dsbcaps, 0, sizeof(dsbcaps));
+	dsbcaps.dwSize = sizeof(dsbcaps);
+	// get the returned buffer size
+	if ( DS_OK != pDSBuf->GetCaps (&dsbcaps) ) {
+		Com_Printf ("*** GetCaps failed ***\n");
+		SNDDMA_Shutdown ();
+		return qfalse;
+	}
+	
+	gSndBufSize = dsbcaps.dwBufferBytes;
+
+	dma.channels = format.nChannels;
+	dma.samplebits = format.wBitsPerSample;
+	dma.speed = format.nSamplesPerSec;
+	dma.samples = gSndBufSize/(dma.samplebits/8);
+	dma.submission_chunk = 1;
+	dma.buffer = NULL;			// must be locked first
+
+	sample16 = (dma.samplebits/8) - 1;
+
+	SNDDMA_BeginPainting ();
+	if (dma.buffer)
+		memset(dma.buffer, 0, dma.samples * dma.samplebits/8);
+	SNDDMA_Submit ();
+	return 1;
+}
+/*
+==============
+SNDDMA_GetDMAPos
+
+return the current sample position (in mono samples read)
+inside the recirculating dma buffer, so the mixing code will know
+how many sample are required to fill it up.
+===============
+*/
+int SNDDMA_GetDMAPos( void ) {
+	MMTIME	mmtime;
+	int		s;
+	DWORD	dwWrite;
+
+	if ( !dsound_init ) {
+		return 0;
+	}
+
+	mmtime.wType = TIME_SAMPLES;
+	pDSBuf->GetCurrentPosition(&mmtime.u.sample, &dwWrite);
+
+	s = mmtime.u.sample;
+
+	s >>= sample16;
+
+	s &= (dma.samples-1);
+
+	return s;
+}
+
+/*
+==============
+SNDDMA_BeginPainting
+
+Makes sure dma.buffer is valid
+===============
+*/
+void SNDDMA_BeginPainting( void ) {
+	int		reps;
+	DWORD	dwSize2;
+	DWORD	*pbuf, *pbuf2;
+	HRESULT	hresult;
+	DWORD	dwStatus;
+
+	if ( !pDSBuf ) {
+		return;
+	}
+
+	// if the buffer was lost or stopped, restore it and/or restart it
+	if ( pDSBuf->GetStatus (&dwStatus) != DS_OK ) {
+		Com_Printf ("Couldn't get sound buffer status\n");
+	}
+	
+	if (dwStatus & DSBSTATUS_BUFFERLOST)
+		pDSBuf->Restore ();
+	
+	if (!(dwStatus & DSBSTATUS_PLAYING))
+		pDSBuf->Play(0, 0, DSBPLAY_LOOPING);
+
+	// lock the dsound buffer
+
+	reps = 0;
+	dma.buffer = NULL;
+
+	while ((hresult = pDSBuf->Lock(0, gSndBufSize, (void **)&pbuf, &locksize, 
+								   (void **)&pbuf2, &dwSize2, 0)) != DS_OK)
+	{
+		if (hresult != DSERR_BUFFERLOST)
+		{
+			Com_Printf( "SNDDMA_BeginPainting: Lock failed with error '%s'\n", DSoundError( hresult ) );
+			S_Shutdown ();
+			return;
+		}
+		else
+		{
+			pDSBuf->Restore( );
+		}
+
+		if (++reps > 2)
+			return;
+	}
+	dma.buffer = (unsigned char *)pbuf;
+}
+
+/*
+==============
+SNDDMA_Submit
+
+Send sound to device if buffer isn't really the dma buffer
+Also unlocks the dsound buffer
+===============
+*/
+void SNDDMA_Submit( void ) {
+    // unlock the dsound buffer
+	if ( pDSBuf ) {
+		pDSBuf->Unlock(dma.buffer, locksize, NULL, 0);
+	}
+}
+
+
+/*
+=================
+SNDDMA_Activate
+
+When we change windows we need to do this
+=================
+*/
+void SNDDMA_Activate( qboolean bAppActive )
+{
+	if (s_UseOpenAL)
+	{
+		S_AL_MuteAllSounds(!bAppActive);
+	}
+
+	if ( !pDS ) {
+		return;
+	}
+
+	if ( DS_OK != pDS->SetCooperativeLevel( g_wv.hWnd, DSSCL_PRIORITY ) )	{
+		Com_Printf ("sound SetCooperativeLevel failed\n");
+		SNDDMA_Shutdown ();
+	}
+}
+
+
+
+// I know this is a bit horrible, but I need to pass our LPDIRECTSOUND ptr to Bink for video playback,
+//	and I don't want other modules to have to know about LPDIRECTSOUND handles, hence the int casting
+//
+// (I'd prefer to use DWORD, but not all modules understand those)
+//
+unsigned int SNDDMA_GetDSHandle(void)
+{
+	return (unsigned int) pDS;
+}
+
+
diff --git a/code/win32/win_stencilshadow.cpp b/code/win32/win_stencilshadow.cpp
new file mode 100644
index 0000000..9fc0dcb
--- /dev/null
+++ b/code/win32/win_stencilshadow.cpp
@@ -0,0 +1,437 @@
+//
+//
+// win_stencilshadow.cpp
+//
+// Stencil shadow computation/rendering
+//
+//
+
+#include "../server/exe_headers.h"
+
+#include "../renderer/tr_local.h"
+#include "../renderer/tr_lightmanager.h"
+#include "glw_win_dx8.h"
+#include "win_local.h"
+
+#include "win_stencilshadow.h"
+
+
+StencilShadow StencilShadower;
+
+
+StencilShadow::StencilShadow()
+{
+}
+
+
+StencilShadow::~StencilShadow()
+{
+}
+
+
+void StencilShadow::AddEdge( int i1, int i2, int facing )
+{
+    int		c;
+
+	c = m_numEdgeDefs[ i1 ];
+	if ( c == MAX_EDGE_DEFS ) 
+	{
+		Com_Printf("WARNING: MAX_EDGE_DEFS overflow!\n");
+		return;		// overflow
+	}
+	m_edgeDefs[ i1 ][ c ].i2 = i2;
+	m_edgeDefs[ i1 ][ c ].facing = facing;
+
+	m_numEdgeDefs[ i1 ]++;
+}
+
+
+void StencilShadow::RenderEdges()
+{
+ //   int		i;
+	//int		c, c2;
+	//int		j, k;
+	//int		i2;
+	//int		c_edges, c_rejected;
+	//int		hit[2];
+
+	//// an edge is NOT a silhouette edge if its face doesn't face the light,
+	//// or if it has a reverse paired edge that also faces the light.
+	//// A well behaved polyhedron would have exactly two faces for each edge,
+	//// but lots of models have dangling edges or overfanned edges
+	//c_edges = 0;
+	//c_rejected = 0;
+
+	//for ( i = 0 ; i < tess.numVertexes ; i++ ) 
+	//{
+	//	c = m_numEdgeDefs[ i ];
+	//	for ( j = 0 ; j < c ; j++ ) 
+	//	{
+	//		if ( !m_edgeDefs[ i ][ j ].facing ) 
+	//		{
+	//			continue;
+	//		}
+
+	//		hit[0] = 0;
+	//		hit[1] = 0;
+
+	//		i2 = m_edgeDefs[ i ][ j ].i2;
+	//		c2 = m_numEdgeDefs[ i2 ];
+	//		for ( k = 0 ; k < c2 ; k++ ) 
+	//		{
+	//			if ( m_edgeDefs[ i2 ][ k ].i2 == i ) 
+	//			{
+	//				hit[ m_edgeDefs[ i2 ][ k ].facing ]++;
+	//			}
+	//		}
+
+	//		// if it doesn't share the edge with another front facing
+	//		// triangle, it is a sil edge
+	//		if ( hit[ 1 ] == 0 ) 
+	//		{
+	//			VectorCopy( tess.xyz[i],					 m_shadowVerts[0] );
+	//			VectorCopy( tess.xyz[i + tess.numVertexes],  m_shadowVerts[1] );
+	//			VectorCopy( tess.xyz[i2],					 m_shadowVerts[2] );
+	//			VectorCopy( tess.xyz[i2 + tess.numVertexes], m_shadowVerts[3] );
+
+	//			c_edges++;
+
+	//			glw_state->device->SetVertexShader( D3DFVF_XYZ );
+	//			glw_state->device->DrawPrimitiveUP( D3DPT_TRIANGLESTRIP, 2, m_shadowVerts, sizeof(vec3_t) );
+	//		} 
+	//		else 
+	//		{
+	//			c_rejected++;
+	//		}
+	//	}
+	//}
+
+	int		i;
+	int		c;
+	int		j;
+	int		i2;
+	int		c_edges, c_rejected;
+	int		numTris;
+	int		o1, o2, o3;
+
+	// an edge is NOT a silhouette edge if its face doesn't face the light,
+	// or if it has a reverse paired edge that also faces the light.
+	// A well behaved polyhedron would have exactly two faces for each edge,
+	// but lots of models have dangling edges or overfanned edges
+	c_edges = 0;
+	c_rejected = 0;
+
+	int nVerts = 0, numPrims = 0;
+
+	for ( i = 0 ; i < tess.numVertexes ; i++ ) 
+	{
+		c = m_numEdgeDefs[ i ];
+		for ( j = 0 ; j < c ; j++ ) 
+		{
+			if ( !m_edgeDefs[ i ][ j ].facing ) 
+			{
+				continue;
+			}
+
+			//with this system we can still get edges shared by more than 2 tris which
+			//produces artifacts including seeing the shadow through walls. So for now
+			//we are going to render all edges even though it is a tiny bit slower. -rww
+			i2 = m_edgeDefs[ i ][ j ].i2;
+			VectorCopy( tess.xyz[i],					 m_shadowVerts[nVerts++] );
+			VectorCopy( tess.xyz[i + tess.numVertexes],  m_shadowVerts[nVerts++] );
+			VectorCopy( tess.xyz[i2 + tess.numVertexes], m_shadowVerts[nVerts++] );
+			VectorCopy( tess.xyz[i2],					 m_shadowVerts[nVerts++] );
+			numPrims++;
+		}
+	}
+
+	if(!numPrims || !nVerts)
+		return;
+
+	glw_state->device->SetTextureStageState( 0, D3DTSS_COLOROP,   D3DTOP_DISABLE );
+
+	glw_state->device->SetVertexShader( D3DFVF_XYZ );
+	glw_state->device->DrawPrimitiveUP( D3DPT_QUADLIST, numPrims, m_shadowVerts, sizeof(vec3_t) );
+
+	nVerts = 0;
+	numPrims = 0;
+
+	//Carmack Reverse<tm> method requires that volumes
+	//be capped properly -rww
+	numTris = tess.numIndexes / 3;
+
+	for ( i = 0 ; i < numTris ; i++ )
+	{
+		if ( !m_facing[i] )
+		{
+			continue;
+		}
+
+		o1 = tess.indexes[ i*3 + 0 ];
+		o2 = tess.indexes[ i*3 + 1 ];
+		o3 = tess.indexes[ i*3 + 2 ];
+
+		VectorCopy( tess.xyz[o1],  m_shadowVerts[nVerts++] );
+		VectorCopy( tess.xyz[o2],  m_shadowVerts[nVerts++] );
+		VectorCopy( tess.xyz[o3],  m_shadowVerts[nVerts++] );
+		VectorCopy( tess.xyz[o3 + tess.numVertexes],  m_shadowVerts[nVerts++] );
+		VectorCopy( tess.xyz[o2 + tess.numVertexes],  m_shadowVerts[nVerts++] );
+		VectorCopy( tess.xyz[o1 + tess.numVertexes],  m_shadowVerts[nVerts++] );
+		numPrims += 2;
+	}
+
+	glw_state->device->SetVertexShader( D3DFVF_XYZ );
+	glw_state->device->DrawPrimitiveUP( D3DPT_TRIANGLELIST, numPrims, m_shadowVerts, sizeof(vec3_t) );
+}
+
+
+bool StencilShadow::BuildFromLight( VVdlight_t *dl )
+{
+ //   int		i;
+	//int		numTris;
+	//vec3_t	lightDir;
+	//D3DXMATRIX matWorldInv;
+	//D3DXVECTOR4 viewLightPos;
+
+	//// we can only do this if we have enough space in the vertex buffers
+	//if ( tess.numVertexes >= SHADER_MAX_VERTEXES / 2 ) {
+	//	return false;
+	//}
+
+	//// project vertexes away from light direction
+	//for ( i = 0 ; i < tess.numVertexes ; i++ ) 
+	//{
+	//	// Get the light direction to the vertex
+	//	VectorCopy( backEnd.currentEntity->lightDir, lightDir );
+
+	//	VectorMA( tess.xyz[i], -512, lightDir, tess.xyz[i+tess.numVertexes] );
+	//}
+
+	int		i;
+	int		numTris;
+	vec3_t	lightDir, ground;
+	float   d;
+
+	// we can only do this if we have enough space in the vertex buffers
+	if ( tess.numVertexes >= SHADER_MAX_VERTEXES / 2 ) {
+		return false;
+	}
+
+	//controlled method - try to keep shadows in range so they don't show through so much -rww
+	vec3_t	worldxyz, ld;
+	float	groundDist, extlength;
+
+	VectorCopy( backEnd.currentEntity->lightDir, lightDir );
+	
+	ground[0] = backEnd.ori.axis[0][2];
+	ground[1] = backEnd.ori.axis[1][2];
+	ground[2] = backEnd.ori.axis[2][2];
+
+	d = DotProduct( lightDir, ground );
+	// don't let the shadows get too long or go negative
+	if ( d < 0.5 ) {
+		VectorMA( lightDir, (0.5 - d), ground, lightDir );
+		d = DotProduct( lightDir, ground );
+	}
+	d = 1.0 / d;
+
+	lightDir[0] = lightDir[0] * d;
+	lightDir[1] = lightDir[1] * d;
+	lightDir[2] = lightDir[2] * d;
+
+	VectorNormalize(lightDir);
+	
+	//Oh well, just cast them straight down no matter what onto the ground plane.
+	//This presents no chance of screwups and still looks better than a stupid
+	//shader blob.
+	//VectorSet(lightDir, 0.0f, 0.0f, 1.0f);
+
+	// project vertexes away from light direction
+	for ( i = 0 ; i < tess.numVertexes ; i++ ) {
+		//add or.origin to vert xyz to end up with world oriented coord, then figure
+		//out the ground pos for the vert to project the shadow volume to
+		//VectorAdd(tess.xyz[i], backEnd.ori.origin, worldxyz);
+		//groundDist = worldxyz[2] - backEnd.currentEntity->e.shadowPlane;
+		//groundDist += 2.0f; //fudge factor
+		//VectorMA( tess.xyz[i], -groundDist, lightDir, tess.xyz[i+tess.numVertexes] );
+		VectorMA( tess.xyz[i], -200.0f, lightDir, tess.xyz[i+tess.numVertexes] );
+	}
+
+
+	// decide which triangles face the light
+	memset( m_numEdgeDefs, 0, 4 * tess.numVertexes );
+
+	numTris = tess.numIndexes / 3;
+	for ( i = 0 ; i < numTris ; i++ ) 
+	{
+		int		i1, i2, i3;
+		vec3_t	d1, d2, normal;
+		float	*v1, *v2, *v3;
+		float	d;
+
+		i1 = tess.indexes[ i*3 + 0 ];
+		i2 = tess.indexes[ i*3 + 1 ];
+		i3 = tess.indexes[ i*3 + 2 ];
+
+		v1 = tess.xyz[ i1 ];
+		v2 = tess.xyz[ i2 ];
+		v3 = tess.xyz[ i3 ];
+
+		VectorSubtract( v2, v1, d1 );
+		VectorSubtract( v3, v1, d2 );
+		CrossProduct( d1, d2, normal );
+
+		d = DotProduct( normal, lightDir );
+		if ( d > 0 ) {
+			m_facing[ i ] = 1;
+		} else {
+			m_facing[ i ] = 0;
+		}
+
+		// create the edges
+		AddEdge( i1, i2, m_facing[ i ] );
+		AddEdge( i2, i3, m_facing[ i ] );
+		AddEdge( i3, i1, m_facing[ i ] );
+	}
+
+	return true;
+}
+
+
+void StencilShadow::RenderShadow()
+{
+	DWORD lighting, fog, srcblend, destblend, alphablend, zwrite, zfunc;
+
+	glw_state->device->GetRenderState( D3DRS_LIGHTING, &lighting );
+	glw_state->device->GetRenderState( D3DRS_FOGENABLE, &fog );
+	glw_state->device->GetRenderState( D3DRS_SRCBLEND, &srcblend );
+	glw_state->device->GetRenderState( D3DRS_DESTBLEND, &destblend );
+	glw_state->device->GetRenderState( D3DRS_ALPHABLENDENABLE, &alphablend );
+	glw_state->device->GetRenderState( D3DRS_ZWRITEENABLE, &zwrite );
+	glw_state->device->GetRenderState( D3DRS_ZFUNC, &zfunc );
+
+	GL_Bind( tr.whiteImage );
+
+	glw_state->device->SetRenderState( D3DRS_LIGHTING, FALSE );
+	glw_state->device->SetRenderState( D3DRS_FOGENABLE, FALSE );
+
+    // Disable z-buffer writes (note: z-testing still occurs), and enable the
+    // stencil-buffer
+    glw_state->device->SetRenderState( D3DRS_ZWRITEENABLE,  FALSE );
+    glw_state->device->SetRenderState( D3DRS_STENCILENABLE, TRUE );
+
+    // Don't bother with interpolating color
+    glw_state->device->SetRenderState( D3DRS_SHADEMODE,     D3DSHADE_FLAT );
+
+	glw_state->device->SetRenderState( D3DRS_ZFUNC,			D3DCMP_LESS );
+
+    // Set up stencil compare function, reference value, and masks.
+    // Stencil test passes if ((ref & mask) cmpfn (stencil & mask)) is true.
+    // Note: since we set up the stencil-test to always pass, the STENCILFAIL
+    // renderstate is really not needed.
+    glw_state->device->SetRenderState( D3DRS_STENCILFUNC,   D3DCMP_ALWAYS );
+    glw_state->device->SetRenderState( D3DRS_STENCILZFAIL,  D3DSTENCILOP_INCR );
+    glw_state->device->SetRenderState( D3DRS_STENCILFAIL,   D3DSTENCILOP_KEEP );
+
+    // If ztest passes, inc/decrement stencil buffer value
+    glw_state->device->SetRenderState( D3DRS_STENCILREF,       0x1 );
+    glw_state->device->SetRenderState( D3DRS_STENCILMASK,      0xffffffff );
+    glw_state->device->SetRenderState( D3DRS_STENCILWRITEMASK, 0xffffffff );
+    glw_state->device->SetRenderState( D3DRS_STENCILPASS,      D3DSTENCILOP_KEEP );
+
+    // Make sure that no pixels get drawn to the frame buffer
+    glw_state->device->SetRenderState( D3DRS_ALPHABLENDENABLE, TRUE );
+    glw_state->device->SetRenderState( D3DRS_SRCBLEND,  D3DBLEND_ZERO );
+    glw_state->device->SetRenderState( D3DRS_DESTBLEND, D3DBLEND_ONE );
+
+	glw_state->device->SetTransform(D3DTS_VIEW, 
+			glw_state->matrixStack[glwstate_t::MatrixMode_Model]->GetTop());
+
+	glw_state->device->SetTexture(0, NULL);
+	glw_state->device->SetTexture(1, NULL);
+
+	qglCullFace( GL_FRONT );
+
+    // Draw front-side of shadow volume in stencil/z only
+    RenderEdges();
+
+    // Now reverse cull order so back sides of shadow volume are written.
+    qglCullFace( GL_BACK );
+
+    // Decrement stencil buffer value
+    glw_state->device->SetRenderState( D3DRS_STENCILZFAIL, D3DSTENCILOP_DECR );
+
+    // Draw back-side of shadow volume in stencil/z only
+    RenderEdges();
+
+    // Restore render states
+    glw_state->device->SetRenderState( D3DRS_SHADEMODE, D3DSHADE_GOURAUD );
+	glw_state->device->SetRenderState( D3DRS_STENCILENABLE,    FALSE );
+	glw_state->device->SetRenderState( D3DRS_LIGHTING, lighting );
+	glw_state->device->SetRenderState( D3DRS_FOGENABLE, fog );
+	glw_state->device->SetRenderState( D3DRS_SRCBLEND, srcblend );
+	glw_state->device->SetRenderState( D3DRS_DESTBLEND, destblend );
+	glw_state->device->SetRenderState( D3DRS_ALPHABLENDENABLE, alphablend );
+	glw_state->device->SetRenderState( D3DRS_ZWRITEENABLE, zwrite );
+	glw_state->device->SetRenderState( D3DRS_ZFUNC, zfunc );
+	glw_state->device->SetRenderState( D3DRS_CULLMODE,  D3DCULL_CCW );
+}
+
+
+void StencilShadow::FinishShadows()
+{
+	DWORD lighting, fog, srcblend, destblend, alphablend;
+
+	glw_state->device->GetRenderState( D3DRS_LIGHTING, &lighting );
+	glw_state->device->GetRenderState( D3DRS_FOGENABLE, &fog );
+	glw_state->device->GetRenderState( D3DRS_SRCBLEND, &srcblend );
+	glw_state->device->GetRenderState( D3DRS_DESTBLEND, &destblend );
+	glw_state->device->GetRenderState( D3DRS_ALPHABLENDENABLE, &alphablend );
+
+    // The stencilbuffer values indicates # of shadows that overlap each pixel.
+    // We only want to draw pixels that are in shadow, which was set up in
+    // RenderShadow() such that StencilBufferValue >= 1. In the Direct3D API, 
+    // the stencil test is pseudo coded as:
+    //    StencilRef CompFunc StencilBufferValue
+    // so we set our renderstates with StencilRef = 1 and CompFunc = LESSEQUAL.
+    glw_state->device->SetRenderState( D3DRS_STENCILENABLE, TRUE );
+    glw_state->device->SetRenderState( D3DRS_STENCILREF,    0);//0x1 );
+    glw_state->device->SetRenderState( D3DRS_STENCILFUNC,   D3DCMP_NOTEQUAL);//D3DCMP_LESSEQUAL );
+	glw_state->device->SetRenderState( D3DRS_STENCILWRITEMASK, 255 );
+
+    // Set renderstates (disable z-buffering and turn on alphablending)
+    glw_state->device->SetRenderState( D3DRS_ZENABLE,          FALSE );
+    glw_state->device->SetRenderState( D3DRS_ALPHABLENDENABLE, TRUE );
+    glw_state->device->SetRenderState( D3DRS_SRCBLEND,  D3DBLEND_SRCALPHA );
+    glw_state->device->SetRenderState( D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA );
+
+    // Set the hardware to draw black, alpha-blending pixels
+    glw_state->device->SetTextureStageState( 0, D3DTSS_COLOROP,   D3DTOP_SELECTARG1 );
+    glw_state->device->SetTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TFACTOR );
+    glw_state->device->SetTextureStageState( 0, D3DTSS_ALPHAOP,   D3DTOP_SELECTARG1 );
+    glw_state->device->SetTextureStageState( 0, D3DTSS_ALPHAARG1, D3DTA_TFACTOR );
+    glw_state->device->SetRenderState( D3DRS_TEXTUREFACTOR, 0x7f000000 );
+
+	glw_state->device->SetRenderState( D3DRS_FOGENABLE, FALSE );
+
+    // Draw the big, darkening square
+    static FLOAT v[4][4] = 
+    {
+        {   0 - 0.5f,   0 - 0.5f, 0.0f, 1.0f },
+        { 640 - 0.5f,   0 - 0.5f, 0.0f, 1.0f }, 
+        { 640 - 0.5f, 480 - 0.5f, 0.0f, 1.0f },
+        {   0 - 0.5f, 480 - 0.5f, 0.0f, 1.0f },
+    };
+
+    glw_state->device->SetVertexShader( D3DFVF_XYZRHW );
+    glw_state->device->DrawPrimitiveUP( D3DPT_QUADLIST, 1, v, sizeof(v[0]) );
+
+    // Restore render states
+    glw_state->device->SetRenderState( D3DRS_ZENABLE,          TRUE );
+    glw_state->device->SetRenderState( D3DRS_STENCILENABLE,    FALSE );
+    glw_state->device->SetRenderState( D3DRS_LIGHTING, lighting );
+	glw_state->device->SetRenderState( D3DRS_FOGENABLE, fog );
+	glw_state->device->SetRenderState( D3DRS_SRCBLEND, srcblend );
+	glw_state->device->SetRenderState( D3DRS_DESTBLEND, destblend );
+	glw_state->device->SetRenderState( D3DRS_ALPHABLENDENABLE, alphablend );
+}
diff --git a/code/win32/win_stencilshadow.h b/code/win32/win_stencilshadow.h
new file mode 100644
index 0000000..35ba45d
--- /dev/null
+++ b/code/win32/win_stencilshadow.h
@@ -0,0 +1,45 @@
+//
+//
+// win_stencilshadow.h
+//
+// Declaration for stencil shadowing class
+//
+//
+
+#ifndef _WIN_STENCILSHADOW_H_
+#define _WIN_STENCILSHADOW_H_
+
+typedef struct 
+{
+	// facing is only one bit, but we can't do better than 4 bytes without
+	// packing all the data we need into a single unsigned short, which
+	// isn't really worth it. (unless we REALLY need 64k at some point).
+	short	i2;
+	short	facing;
+} edgeDef_t;
+
+#define	MAX_EDGE_DEFS	16
+
+
+class StencilShadow
+{
+public:
+
+	edgeDef_t	m_edgeDefs[SHADER_MAX_VERTEXES][MAX_EDGE_DEFS];
+	int			m_numEdgeDefs[SHADER_MAX_VERTEXES];
+	int			m_facing[SHADER_MAX_INDEXES/3];
+	vec3_t		m_shadowVerts[SHADER_MAX_VERTEXES * 8];
+
+	StencilShadow();
+	~StencilShadow();
+	void AddEdge( int i1, int i2, int facing );
+	void RenderEdges();
+	bool BuildFromLight( VVdlight_t *dl );
+	void RenderShadow();
+	void FinishShadows();
+};
+
+extern StencilShadow StencilShadower;
+
+
+#endif
\ No newline at end of file
diff --git a/code/win32/win_stream_dx8.cpp b/code/win32/win_stream_dx8.cpp
new file mode 100644
index 0000000..1ea0875
--- /dev/null
+++ b/code/win32/win_stream_dx8.cpp
@@ -0,0 +1,290 @@
+
+/*
+ * UNPUBLISHED -- Rights  reserved  under  the  copyright  laws  of the 
+ * United States.  Use  of a copyright notice is precautionary only and 
+ * does not imply publication or disclosure.                            
+ *                                                                      
+ * THIS DOCUMENTATION CONTAINS CONFIDENTIAL AND PROPRIETARY INFORMATION 
+ * OF    VICARIOUS   VISIONS,  INC.    ANY  DUPLICATION,  MODIFICATION, 
+ * DISTRIBUTION, OR DISCLOSURE IS STRICTLY PROHIBITED WITHOUT THE PRIOR 
+ * EXPRESS WRITTEN PERMISSION OF VICARIOUS VISIONS, INC.
+ */
+
+#include "../server/exe_headers.h"
+
+#include "../client/client.h"
+#include "win_local.h"
+#include "../qcommon/qcommon.h"
+
+#if defined(_WINDOWS)
+#include <windows.h>
+#elif defined(_XBOX)
+#include <xtl.h>
+#endif
+
+extern void Z_SetNewDeleteTemporary(bool);
+
+#define STREAM_SLOW_READ 0
+
+#include "../client/snd_local_console.h"
+
+#include <deque>
+
+extern HANDLE Sys_FileStreamMutex;
+extern const char* Sys_GetFileCodeName(int code);
+extern int Sys_GetFileCodeSize(int code);
+
+#define STREAM_MAX_OPEN 48
+struct StreamInfo
+{
+	volatile HANDLE file;
+	volatile bool used;
+	volatile bool error;
+	volatile bool opening;
+	volatile bool reading;
+};
+static StreamInfo* s_Streams = NULL;
+
+enum IORequestType
+{
+	IOREQ_OPEN,
+	IOREQ_READ,
+	IOREQ_SHUTDOWN,
+};
+
+struct IORequest
+{
+	IORequestType type;
+	streamHandle_t handle;
+	DWORD data[3];
+};
+typedef std::deque<IORequest> requestqueue_t;
+requestqueue_t* s_IORequestQueue = NULL;
+
+HANDLE s_Thread = INVALID_HANDLE_VALUE;
+HANDLE s_QueueMutex = INVALID_HANDLE_VALUE;
+HANDLE s_QueueLen = INVALID_HANDLE_VALUE;
+
+
+static DWORD WINAPI _streamThread(LPVOID)
+{
+	for (;;)
+	{
+		IORequest req;
+		DWORD bytes;
+		StreamInfo* strm;
+
+		// Wait for the IO queue to fill
+		WaitForSingleObject(s_QueueLen, INFINITE);
+		
+		// Grab the next IO request
+		WaitForSingleObject(s_QueueMutex, INFINITE);
+		assert(!s_IORequestQueue->empty());
+		req = s_IORequestQueue->front();
+		s_IORequestQueue->pop_front();
+		ReleaseMutex(s_QueueMutex);
+
+		// Process request
+		switch (req.type)
+		{
+		case IOREQ_OPEN:
+			strm = &s_Streams[req.handle];
+			assert(strm->used);
+		
+			{
+				const char* name = Sys_GetFileCodeName(req.data[0]);
+
+				WaitForSingleObject(Sys_FileStreamMutex, INFINITE);
+			
+				strm->file = 
+					CreateFile(name, GENERIC_READ, 
+					FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);
+			
+				ReleaseMutex(Sys_FileStreamMutex);
+			}
+
+			strm->error = (strm->file == INVALID_HANDLE_VALUE);
+			strm->opening = false;
+			break;
+
+		case IOREQ_READ:
+			strm = &s_Streams[req.handle];
+			assert(strm->used);
+		
+			WaitForSingleObject(Sys_FileStreamMutex, INFINITE);
+
+#			if STREAM_SLOW_READ
+			Sleep(200);
+#			endif
+
+			strm->error = 
+				(SetFilePointer(strm->file, req.data[2], 0, FILE_BEGIN) != req.data[2] ||
+				ReadFile(strm->file, (void*)req.data[0], req.data[1], &bytes, NULL) == 0);
+			
+			ReleaseMutex(Sys_FileStreamMutex);
+
+			strm->reading = false;
+			break;
+
+		case IOREQ_SHUTDOWN:
+			ExitThread(0);
+			break;
+		}
+	}
+
+	return TRUE;
+}
+
+
+static void _sendIORequest(const IORequest& req)
+{
+	// Add request to queue
+	WaitForSingleObject(s_QueueMutex, INFINITE);
+	Z_SetNewDeleteTemporary(true);
+	s_IORequestQueue->push_back(req);
+	Z_SetNewDeleteTemporary(false);
+	ReleaseMutex(s_QueueMutex);
+
+	// Let IO thread know it has one more pending request
+	ReleaseSemaphore(s_QueueLen, 1, NULL);
+}
+
+void Sys_IORequestQueueClear(void)
+{
+	WaitForSingleObject(s_QueueMutex, INFINITE);
+	delete s_IORequestQueue;
+	s_IORequestQueue = new requestqueue_t;
+	ReleaseMutex(s_QueueMutex);
+}
+
+void Sys_StreamInit(void)
+{
+	// Create array for storing open streams
+	s_Streams = (StreamInfo*)Z_Malloc(
+		STREAM_MAX_OPEN * sizeof(StreamInfo), TAG_FILESYS, qfalse);
+	for (int i = 0; i < STREAM_MAX_OPEN; ++i)
+	{
+		s_Streams[i].used = false;
+	}
+
+	// Create queue to hold requests for IO thread
+	s_IORequestQueue = new requestqueue_t;
+
+	// Create a thread to service IO
+	s_QueueMutex = CreateMutex(NULL, FALSE, NULL);
+	s_QueueLen = CreateSemaphore(NULL, 0, STREAM_MAX_OPEN * 3, NULL);
+	s_Thread = CreateThread(NULL, 64*1024, _streamThread, 0, 0, NULL);
+}
+
+void Sys_StreamShutdown(void)
+{
+	// Tell the IO thread to shutdown
+	IORequest req;
+	req.type = IOREQ_SHUTDOWN;
+	_sendIORequest(req);
+
+	// Wait for thread to close
+	WaitForSingleObject(s_Thread, INFINITE);
+	
+	// Kill IO thread
+	CloseHandle(s_Thread);
+	CloseHandle(s_QueueLen);
+	CloseHandle(s_QueueMutex);
+
+	// Remove queue of IO requests
+	delete s_IORequestQueue;
+	
+	// Remove streaming table
+	Z_Free(s_Streams);
+}
+
+static streamHandle_t GetFreeHandle(void)
+{
+	for (streamHandle_t i = 1; i < STREAM_MAX_OPEN; ++i)
+	{
+		if (!s_Streams[i].used) return i;
+	}
+	
+	// handle 0 is invalid by convention
+	return 0;
+}
+
+int Sys_StreamOpen(int code, streamHandle_t *handle)
+{
+	// Find a free handle
+	*handle = GetFreeHandle();
+	if (*handle == 0)
+	{
+		return -1;
+	}
+
+	// Find the file size
+	int size = Sys_GetFileCodeSize(code);
+	if (size < 0)
+	{
+		*handle = 0;
+		return -1;
+	}
+
+	// Init stream data
+	s_Streams[*handle].used = true;
+	s_Streams[*handle].opening = true;
+	s_Streams[*handle].reading = false;
+	s_Streams[*handle].error = false;
+
+	// Send an open request to the thread
+	IORequest req;
+	req.type = IOREQ_OPEN;
+	req.handle = *handle;
+	req.data[0] = code;
+	_sendIORequest(req);
+
+	// Return file size
+	return size;
+}
+
+bool Sys_StreamRead(void* buffer, int size, int pos, streamHandle_t handle)
+{
+	assert((unsigned int)buffer % 32 == 0);
+
+	// Handle must be valid.  Do not allow multiple reads.
+	if (!s_Streams[handle].used || s_Streams[handle].reading) return false;
+
+	// Ready to read
+	s_Streams[handle].reading = true;
+	s_Streams[handle].error = false;
+	
+	// Request IO threading reading
+	IORequest req;
+	req.type = IOREQ_READ;
+	req.handle = handle;
+	req.data[0] = (DWORD)buffer;
+	req.data[1] = size;
+	req.data[2] = pos;
+	_sendIORequest(req);
+	
+	return true;
+}
+
+bool Sys_StreamIsReading(streamHandle_t handle)
+{
+	return s_Streams[handle].used && s_Streams[handle].reading;
+}
+
+bool Sys_StreamIsError(streamHandle_t handle)
+{
+	return s_Streams[handle].used && s_Streams[handle].error;
+}
+
+void Sys_StreamClose(streamHandle_t handle)
+{
+	if (s_Streams[handle].used)
+	{
+		// Block until read is done
+		while (s_Streams[handle].opening || s_Streams[handle].reading);
+		
+		// Close the file
+		CloseHandle(s_Streams[handle].file);
+		s_Streams[handle].used = false;
+	}
+}
diff --git a/code/win32/win_syscon.cpp b/code/win32/win_syscon.cpp
new file mode 100644
index 0000000..439d8c7
--- /dev/null
+++ b/code/win32/win_syscon.cpp
@@ -0,0 +1,536 @@
+// win_syscon.h
+
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+
+
+
+#include "../client/client.h"
+#include "win_local.h"
+#include "resource.h"
+#include <errno.h>
+#include <float.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <direct.h>
+#include <io.h>
+#include <conio.h>
+
+#define COPY_ID			1
+#define QUIT_ID			2
+#define CLEAR_ID		3
+
+#define ERRORBOX_ID		10
+#define ERRORTEXT_ID	11
+
+#define EDIT_ID			100
+#define INPUT_ID		101
+
+typedef struct
+{
+	HWND		hWnd;
+	HWND		hwndBuffer;
+
+	HWND		hwndButtonClear;
+	HWND		hwndButtonCopy;
+	HWND		hwndButtonQuit;
+
+	HWND		hwndErrorBox;
+	HWND		hwndErrorText;
+
+	HBITMAP		hbmLogo;
+	HBITMAP		hbmClearBitmap;
+
+	HBRUSH		hbrEditBackground;
+	HBRUSH		hbrErrorBackground;
+
+	HFONT		hfBufferFont;
+	HFONT		hfButtonFont;
+
+	HWND		hwndInputLine;
+
+	char		errorString[80];
+
+	char		consoleText[512], returnedText[512];
+	int			visLevel;
+	qboolean	quitOnClose;
+	int			windowWidth, windowHeight;
+	
+	WNDPROC		SysInputLineWndProc;
+
+} WinConData;
+
+static WinConData s_wcd;
+
+static LONG WINAPI ConWndProc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
+{
+	char *cmdString;
+	static qboolean s_timePolarity;
+
+	switch (uMsg)
+	{
+	case WM_ACTIVATE:
+		if ( LOWORD( wParam ) != WA_INACTIVE )
+		{
+			SetFocus( s_wcd.hwndInputLine );
+		}
+
+		if ( com_viewlog )
+		{
+			// if the viewlog is open, check to see if it's being minimized
+			if ( com_viewlog->integer == 1 )
+			{
+				if ( HIWORD( wParam ) )		// minimized flag
+				{
+					Cvar_Set( "viewlog", "2" );
+				}
+			}
+			else if ( com_viewlog->integer == 2 )
+			{
+				if ( !HIWORD( wParam ) )		// minimized flag
+				{
+					Cvar_Set( "viewlog", "1" );
+				}
+			}
+		}
+		break;
+
+	case WM_CLOSE:
+		//cmdString = CopyString( "quit" );
+		//Sys_QueEvent( 0, SE_CONSOLE, 0, 0, strlen( cmdString ) + 1, cmdString );
+		if ( s_wcd.quitOnClose )
+		{
+			PostQuitMessage( 0 );
+		}
+		else
+		{
+			Sys_ShowConsole( 0, qfalse );
+			Cvar_Set( "viewlog", "0" );
+		}
+		return 0;
+	case WM_CTLCOLORSTATIC:
+		if ( ( HWND ) lParam == s_wcd.hwndBuffer )
+		{
+			SetBkColor( ( HDC ) wParam, RGB( 0, 0, 0 ) );
+			SetTextColor( ( HDC ) wParam, RGB( 249, 249, 000 ) );
+			return ( long ) s_wcd.hbrEditBackground;
+		}
+		else if ( ( HWND ) lParam == s_wcd.hwndErrorBox )
+		{
+			if ( s_timePolarity & 1 )
+			{
+				SetBkColor(   ( HDC ) wParam, RGB( 0x80, 0x80, 0x80 ) );
+				SetTextColor( ( HDC ) wParam, RGB( 0xff, 0x00, 0x00 ) );
+			}
+			else
+			{
+				SetBkColor(   ( HDC ) wParam, RGB( 0x80, 0x80, 0x80 ) );
+				SetTextColor( ( HDC ) wParam, RGB( 0x00, 0x00, 0x00 ) );
+			}
+			return ( long ) s_wcd.hbrErrorBackground;
+		}
+		return FALSE;
+		break;
+
+	case WM_COMMAND:
+		if ( wParam == COPY_ID )
+		{
+			SendMessage( s_wcd.hwndBuffer, EM_SETSEL, 0, -1 );
+			SendMessage( s_wcd.hwndBuffer, WM_COPY, 0, 0 );
+		}
+		else if ( wParam == QUIT_ID )
+		{
+			if ( s_wcd.quitOnClose )
+			{
+				PostQuitMessage( 0 );
+			}
+			else
+			{
+				cmdString = CopyString( "quit" );
+				Sys_QueEvent( 0, SE_CONSOLE, 0, 0, strlen( cmdString ) + 1, cmdString );
+			}
+		}
+		else if ( wParam == CLEAR_ID )
+		{
+			SendMessage( s_wcd.hwndBuffer, EM_SETSEL, 0, -1 );
+			SendMessage( s_wcd.hwndBuffer, EM_REPLACESEL, FALSE, ( LPARAM ) "" );
+			UpdateWindow( s_wcd.hwndBuffer );
+		}
+		break;
+	case WM_CREATE:
+		s_wcd.hbrEditBackground =  CreateSolidBrush( RGB( 0x00, 0x00, 0x00 ) );
+		s_wcd.hbrErrorBackground = CreateSolidBrush( RGB( 0x80, 0x80, 0x80 ) );
+		SetTimer( hWnd, 1, 1000, NULL );
+		break;
+	case WM_ERASEBKGND:
+	    return DefWindowProc( hWnd, uMsg, wParam, lParam );
+	case WM_TIMER:
+		if ( wParam == 1 )
+		{
+			s_timePolarity = !s_timePolarity;
+			if ( s_wcd.hwndErrorBox )
+			{
+				InvalidateRect( s_wcd.hwndErrorBox, NULL, FALSE );
+			}
+		}
+		break;
+    }
+
+    return DefWindowProc( hWnd, uMsg, wParam, lParam );
+}
+
+LONG WINAPI InputLineWndProc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
+{
+	char inputBuffer[1024];
+
+	switch ( uMsg )
+	{
+	case WM_KILLFOCUS:
+		if ( ( HWND ) wParam == s_wcd.hWnd ||
+			 ( HWND ) wParam == s_wcd.hwndErrorBox )
+		{
+			SetFocus( hWnd );
+			return 0;
+		}
+		break;
+
+	case WM_CHAR:
+		if ( wParam == 13 )
+		{
+			GetWindowText( s_wcd.hwndInputLine, inputBuffer, sizeof( inputBuffer ) );
+			strncat( s_wcd.consoleText, inputBuffer, sizeof( s_wcd.consoleText ) - strlen( s_wcd.consoleText ) - 5 );
+			strcat( s_wcd.consoleText, "\n" );
+			SetWindowText( s_wcd.hwndInputLine, "" );
+
+			Sys_Print( va( "]%s\n", inputBuffer ) );
+
+			return 0;
+		}
+	}
+
+	return CallWindowProc( s_wcd.SysInputLineWndProc, hWnd, uMsg, wParam, lParam );
+}
+
+/*
+** Sys_CreateConsole
+*/
+void Sys_CreateConsole( void )
+{
+	HDC hDC;
+	WNDCLASS wc;
+	RECT rect;
+	const char *DEDCLASS = "JK2MP WinConsole";
+	int nHeight;
+	int swidth, sheight;
+	int DEDSTYLE = WS_POPUPWINDOW | WS_CAPTION | WS_MINIMIZEBOX;
+
+	memset( &wc, 0, sizeof( wc ) );
+
+	wc.style         = 0;
+	wc.lpfnWndProc   = (WNDPROC) ConWndProc;
+	wc.cbClsExtra    = 0;
+	wc.cbWndExtra    = 0;
+	wc.hInstance     = g_wv.hInstance;
+	wc.hIcon         = LoadIcon( g_wv.hInstance, MAKEINTRESOURCE(IDI_ICON1));
+	wc.hCursor       = LoadCursor (NULL,IDC_ARROW);
+	wc.hbrBackground = (HBRUSH__ *)COLOR_INACTIVEBORDER;//(HBRUSH__ *)COLOR_WINDOW;
+	wc.lpszMenuName  = 0;
+	wc.lpszClassName = DEDCLASS;
+
+	if ( !RegisterClass (&wc) ) {
+		return;
+	}
+
+	rect.left = 0;
+	rect.right = 600;
+	rect.top = 0;
+	rect.bottom = 450;
+	AdjustWindowRect( &rect, DEDSTYLE, FALSE );
+
+	hDC = GetDC( GetDesktopWindow() );
+	swidth = GetDeviceCaps( hDC, HORZRES );
+	sheight = GetDeviceCaps( hDC, VERTRES );
+	ReleaseDC( GetDesktopWindow(), hDC );
+
+	s_wcd.windowWidth = rect.right - rect.left + 1;
+	s_wcd.windowHeight = rect.bottom - rect.top + 1;
+
+	s_wcd.hWnd = CreateWindowEx( 0,
+							   DEDCLASS,
+							   "Jedi Knight®: Jedi Academy SP Console",
+							   DEDSTYLE,
+							   ( swidth - 600 ) / 2, ( sheight - 450 ) / 2 , rect.right - rect.left + 1, rect.bottom - rect.top + 1,
+							   NULL,
+							   NULL,
+							   g_wv.hInstance,
+							   NULL );
+
+	if ( s_wcd.hWnd == NULL )
+	{
+		return;
+	}
+
+	//
+	// create fonts
+	//
+	hDC = GetDC( s_wcd.hWnd );
+	nHeight = -MulDiv( 8, GetDeviceCaps( hDC, LOGPIXELSY), 72);
+
+	s_wcd.hfBufferFont = CreateFont( nHeight,
+									  0,
+									  0,
+									  0,
+									  FW_LIGHT,
+									  0,
+									  0,
+									  0,
+									  DEFAULT_CHARSET,
+									  OUT_DEFAULT_PRECIS,
+									  CLIP_DEFAULT_PRECIS,
+									  DEFAULT_QUALITY,
+									  FF_MODERN | FIXED_PITCH,
+									  "Courier New" );
+
+	ReleaseDC( s_wcd.hWnd, hDC );
+
+	//
+	// create the input line
+	//
+	s_wcd.hwndInputLine = CreateWindow( "edit", NULL, WS_CHILD | WS_VISIBLE | WS_BORDER | 
+												ES_LEFT | ES_AUTOHSCROLL,
+												6, 400, s_wcd.windowWidth-20, 20,
+												s_wcd.hWnd, 
+												( HMENU ) INPUT_ID,	// child window ID
+												g_wv.hInstance, NULL );
+
+	//
+	// create the buttons
+	//
+	s_wcd.hwndButtonCopy = CreateWindow( "button", NULL, BS_PUSHBUTTON | WS_VISIBLE | WS_CHILD | BS_DEFPUSHBUTTON,
+												5, 425, 72, 24,
+												s_wcd.hWnd, 
+												( HMENU ) COPY_ID,	// child window ID
+												g_wv.hInstance, NULL );
+	SendMessage( s_wcd.hwndButtonCopy, WM_SETTEXT, 0, ( LPARAM ) "copy" );
+
+	s_wcd.hwndButtonClear = CreateWindow( "button", NULL, BS_PUSHBUTTON | WS_VISIBLE | WS_CHILD | BS_DEFPUSHBUTTON,
+												82, 425, 72, 24,
+												s_wcd.hWnd, 
+												( HMENU ) CLEAR_ID,	// child window ID
+												g_wv.hInstance, NULL );
+	SendMessage( s_wcd.hwndButtonClear, WM_SETTEXT, 0, ( LPARAM ) "clear" );
+
+	s_wcd.hwndButtonQuit = CreateWindow( "button", NULL, BS_PUSHBUTTON | WS_VISIBLE | WS_CHILD | BS_DEFPUSHBUTTON,
+												s_wcd.windowWidth-92, 425, 72, 24,
+												s_wcd.hWnd, 
+												( HMENU ) QUIT_ID,	// child window ID
+												g_wv.hInstance, NULL );
+	SendMessage( s_wcd.hwndButtonQuit, WM_SETTEXT, 0, ( LPARAM ) "quit" );
+
+
+	//
+	// create the scrollbuffer
+	//
+	s_wcd.hwndBuffer = CreateWindow( "edit", NULL, WS_CHILD | WS_VISIBLE | WS_VSCROLL | WS_BORDER | 
+												ES_LEFT | ES_MULTILINE | ES_AUTOVSCROLL | ES_READONLY,
+												6, 40, s_wcd.windowWidth-20, 354,
+												s_wcd.hWnd, 
+												( HMENU ) EDIT_ID,	// child window ID
+												g_wv.hInstance, NULL );
+	SendMessage( s_wcd.hwndBuffer, WM_SETFONT, ( WPARAM ) s_wcd.hfBufferFont, 0 );
+
+	s_wcd.SysInputLineWndProc = ( WNDPROC ) SetWindowLong( s_wcd.hwndInputLine, GWL_WNDPROC, ( long ) InputLineWndProc );
+	SendMessage( s_wcd.hwndInputLine, WM_SETFONT, ( WPARAM ) s_wcd.hfBufferFont, 0 );
+	SendMessage( s_wcd.hwndBuffer, EM_LIMITTEXT, ( WPARAM ) 0x7fff, 0 );
+
+	ShowWindow( s_wcd.hWnd, SW_SHOWDEFAULT);
+	UpdateWindow( s_wcd.hWnd );
+	SetForegroundWindow( s_wcd.hWnd );
+	SetFocus( s_wcd.hwndInputLine );
+
+	s_wcd.visLevel = 1;
+}
+
+/*
+** Sys_DestroyConsole
+*/
+void Sys_DestroyConsole( void ) {
+	if ( s_wcd.hWnd ) {
+		DeleteObject(s_wcd.hbrEditBackground);
+		DeleteObject(s_wcd.hbrErrorBackground);
+		DeleteObject(s_wcd.hfBufferFont);
+		ShowWindow( s_wcd.hWnd, SW_HIDE );
+		CloseWindow( s_wcd.hWnd );
+		DestroyWindow( s_wcd.hWnd );
+		s_wcd.hWnd = 0;
+	}
+}
+
+/*
+** Sys_ShowConsole
+*/
+void Sys_ShowConsole( int visLevel, qboolean quitOnClose )
+{
+	s_wcd.quitOnClose = quitOnClose;
+
+	if ( visLevel == s_wcd.visLevel )
+	{
+		if (quitOnClose) {//attempt to bring it to the front on error exit
+			SetForegroundWindow( s_wcd.hWnd );
+			SetFocus( s_wcd.hwndInputLine );
+		}
+		return;
+	}
+
+	s_wcd.visLevel = visLevel;
+
+	if ( !s_wcd.hWnd ){
+		return;
+	}
+
+	switch ( visLevel )
+	{
+	case 0:
+		ShowWindow( s_wcd.hWnd, SW_HIDE );
+		break;
+	case 1:
+		ShowWindow( s_wcd.hWnd, SW_SHOWNORMAL );
+		SendMessage( s_wcd.hwndBuffer, EM_LINESCROLL, 0, 0xffff );
+		if (quitOnClose) {//attempt to bring it to the front on error exit
+			SetForegroundWindow( s_wcd.hWnd );
+			SetFocus( s_wcd.hwndInputLine );
+		}
+		break;
+	case 2:
+		ShowWindow( s_wcd.hWnd, SW_MINIMIZE );
+		break;
+	default:
+		Sys_Error( "Invalid visLevel %d sent to Sys_ShowConsole\n", visLevel );
+		break;
+	}
+}
+
+/*
+** Sys_ConsoleInput
+*/
+char *Sys_ConsoleInput( void )
+{
+	if ( s_wcd.consoleText[0] == 0 )
+	{
+		return NULL;
+	}
+		
+	strcpy( s_wcd.returnedText, s_wcd.consoleText );
+	s_wcd.consoleText[0] = 0;
+	
+	return s_wcd.returnedText;
+}
+
+/*
+** Conbuf_AppendText
+*/
+void Conbuf_AppendText( const char *pMsg )
+{
+#define CONSOLE_BUFFER_SIZE		16384
+	if ( !s_wcd.hWnd ) {
+		return;
+	}
+	char buffer[CONSOLE_BUFFER_SIZE*4];
+	char *b = buffer;
+	const char *msg;
+	int bufLen;
+	int i = 0;
+	static unsigned long s_totalChars;
+
+	//
+	// if the message is REALLY long, use just the last portion of it
+	//
+	if ( strlen( pMsg ) > CONSOLE_BUFFER_SIZE - 1 )
+	{
+		msg = pMsg + strlen( pMsg ) - CONSOLE_BUFFER_SIZE + 1;
+	}
+	else
+	{
+		msg = pMsg;
+	}
+
+	//
+	// copy into an intermediate buffer
+	//
+	while ( msg[i] && ( ( b - buffer ) < sizeof( buffer ) - 1 ) )
+	{
+		if ( msg[i] == '\n' && msg[i+1] == '\r' )
+		{
+			b[0] = '\r';
+			b[1] = '\n';
+			b += 2;
+			i++;
+		}
+		else if ( msg[i] == '\r' )
+		{
+			b[0] = '\r';
+			b[1] = '\n';
+			b += 2;
+		}
+		else if ( msg[i] == '\n' )
+		{
+			b[0] = '\r';
+			b[1] = '\n';
+			b += 2;
+		}
+		else if ( Q_IsColorString( &msg[i] ) )
+		{
+			i++;
+		}
+		else
+		{
+			*b= msg[i];
+			b++;
+		}
+		i++;
+	}
+	*b = 0;
+	bufLen = b - buffer;
+
+	s_totalChars += bufLen;
+
+	//
+	// replace selection instead of appending if we're overflowing
+	//
+	if ( s_totalChars > 0x7fff )
+	{
+		SendMessage( s_wcd.hwndBuffer, EM_SETSEL, 0, -1 );
+		s_totalChars = bufLen;
+	}
+
+	//
+	// put this text into the windows console
+	//
+	SendMessage( s_wcd.hwndBuffer, EM_LINESCROLL, 0, 0xffff );
+	SendMessage( s_wcd.hwndBuffer, EM_SCROLLCARET, 0, 0 );
+	SendMessage( s_wcd.hwndBuffer, EM_REPLACESEL, 0, (LPARAM) buffer );
+}
+
+/*
+** Sys_SetErrorText
+*/
+void Sys_SetErrorText( const char *buf )
+{
+	Q_strncpyz( s_wcd.errorString, buf, sizeof( s_wcd.errorString ) );
+
+	if ( !s_wcd.hwndErrorBox )
+	{
+		s_wcd.hwndErrorBox = CreateWindow( "static", NULL, WS_CHILD | WS_VISIBLE | SS_SUNKEN,
+													6, 5, s_wcd.windowWidth-20, 30,
+													s_wcd.hWnd, 
+													( HMENU ) ERRORBOX_ID,	// child window ID
+													g_wv.hInstance, NULL );
+		SendMessage( s_wcd.hwndErrorBox, WM_SETFONT, ( WPARAM ) s_wcd.hfBufferFont, 0 );
+		SetWindowText( s_wcd.hwndErrorBox, s_wcd.errorString );
+
+		DestroyWindow( s_wcd.hwndInputLine );
+		s_wcd.hwndInputLine = NULL;
+	}
+}
diff --git a/code/win32/win_video.cpp b/code/win32/win_video.cpp
new file mode 100644
index 0000000..d836916
--- /dev/null
+++ b/code/win32/win_video.cpp
@@ -0,0 +1,325 @@
+// Filename:-	win_video.cpp
+//
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+			   
+
+#include "../client/client.h"
+#include "win_local.h"
+
+/*
+#include "bink.h"
+
+
+static HANDLE	hBinkFile	= NULL;
+static HBINK	hBink		= NULL;
+*/
+
+extern unsigned int SNDDMA_GetDSHandle(void);
+extern			int s_soundStarted;	// if 0, game is running in silent mode
+
+// ret qtrue if success...
+//
+qboolean VIDEO_GetDims(int *piWidth, int *piHeight)
+{
+/*
+	if (hBink)
+	{
+		if (piWidth && piHeight)
+		{
+//			*piWidth = hBink->Width;             // Width (1 based, 640 for example)
+
+			if (hBink->decompwidth	== hBink->Width/2)
+			{
+				*piWidth  = hBink->decompwidth;
+			}
+			else
+			{
+				*piWidth  = hBink->Width;
+			}
+
+			if (hBink->decompheight == hBink->Height/2)
+			{
+				*piHeight = hBink->decompheight;
+			}
+			else
+			{
+				*piHeight = hBink->Height;
+			}
+
+			return qtrue;
+		}
+	}
+*/
+	return qfalse;
+}
+
+
+// ret qtrue if no reason to delay...
+//
+qboolean VIDEO_NextFrameReady(void)
+{
+/*	if (hBink && BinkWait(hBink))
+	{
+		return qfalse;
+	}
+*/
+	return qtrue;
+}
+
+void VIDEO_Pause(qboolean bPaused)
+{
+/*
+	if (hBink)
+	{
+		BinkPause(hBink, bPaused);
+	}
+*/
+}
+
+void VIDEO_Mute(qboolean bMute)
+{
+/*
+	if (!s_soundStarted)
+		bMute = qtrue;	// <g>
+
+	if (hBink)
+	{
+//		BinkSetSoundOnOff(hBink, !bMute);		// this has a bug, and freezes video playback
+		BinkSetVolume(hBink,bMute?0:32768);		// effectively the same, and instant, not just to next audio packet
+	}
+*/
+}
+
+// advance to the next Bink Frame, qtrue if not finished playback
+//
+//qboolean VIDEO_NextFrame( byte *pbDestBuffer )	// pbDestBuffer will be sizeof Vid dims *4
+qboolean VIDEO_NextFrame( byte *pbDestBuffer, int iBytesPerLine, qboolean &bFrameSkipped)
+{
+/*
+	if (hBink)
+	{	
+		bFrameSkipped = BinkDoFrame(hBink);
+
+		if (!bFrameSkipped)
+		{
+
+//extern	cvar_t	*r_speeds;
+//int start,end;
+//if ( r_speeds->integer ) 
+//{
+//	start = Sys_Milliseconds();
+//}				
+			BinkCopyToBuffer(	hBink,			// HBINK bnk,
+								pbDestBuffer,	// void* dest,
+								iBytesPerLine,//hBink->Width*4,	// u32 destpitch (bytes, not pixels)
+								hBink->Height,	// u32 destheight
+								0,				// u32 destx
+								0,				// u32 desty,
+								BINKSURFACE32R								
+								//|BINKCOPYALL								
+								|BINKCOPYNOSCALING	// important, or you'll crash on half-height compressed videos now!
+							);
+
+//if ( r_speeds->integer ) 
+//{
+//	end = Sys_Milliseconds();
+//	Com_Printf( "BinkCopyToBuffer(): %i msec\n", end - start );
+//}
+		}
+
+		// finished?
+		//
+		qboolean bStillPlaying = qtrue;
+
+		if (hBink->FrameNum == hBink->Frames)
+		{
+			bStillPlaying = qfalse;	// finished
+		}
+		else
+		{
+			BinkNextFrame(hBink);
+		}
+
+		return bStillPlaying;
+	}
+*/
+	return qfalse;	// will only get here if some sort of error in Q3 logic (which does happen) so that this is called
+					//	at the wrong time.
+}
+
+
+
+// called even if not fully opened, so check everything...
+//
+void VIDEO_Close(void)
+{
+/*
+	if (hBink) 
+	{
+#ifdef _DEBUG
+		BINKSUMMARY Summary;
+		BinkGetSummary(hBink, &Summary);
+		Com_DPrintf("\nBINK Playback Summary:\n\n");
+		Com_DPrintf("TotalTime:            %d\n",Summary.TotalTime);    // 
+		Com_DPrintf("FileFrameRate:        %d\n",Summary.FileFrameRate);    //          frame rate
+		Com_DPrintf("FileFrameRateDiv:     %d\n",Summary.FileFrameRateDiv);    //       frame rate divisor
+		Com_DPrintf("FrameRate:            %d\n",Summary.FrameRate);    //              frame rate
+		Com_DPrintf("FrameRateDiv:         %d\n",Summary.FrameRateDiv);    //           frame rate divisor
+		Com_DPrintf("TotalOpenTime:        %d\n",Summary.TotalOpenTime);    //          Time to open and prepare for decompression
+		Com_DPrintf("TotalFrames:          %d\n",Summary.TotalFrames);    //            Total Frames
+		Com_DPrintf("TotalPlayedFrames:    %d\n",Summary.TotalPlayedFrames);    //      Total Frames played
+		Com_DPrintf("SkippedFrames:        %d\n",Summary.SkippedFrames);    //          Total number of skipped frames
+		Com_DPrintf("SkippedBlits:         %d\n",Summary.SkippedBlits);    //           Total number of skipped blits
+		Com_DPrintf("SoundSkips:           %d\n",Summary.SoundSkips);    //             Total number of sound skips
+		Com_DPrintf("TotalBlitTime:        %d\n",Summary.TotalBlitTime);    //          Total time spent blitting
+		Com_DPrintf("TotalReadTime:        %d\n",Summary.TotalReadTime);    //          Total time spent reading
+		Com_DPrintf("TotalVideoDecompTime: %d\n",Summary.TotalVideoDecompTime);    //   Total time spent decompressing video
+		Com_DPrintf("TotalAudioDecompTime: %d\n",Summary.TotalAudioDecompTime);    //   Total time spent decompressing audio
+		Com_DPrintf("TotalBackReadTime:    %d\n",Summary.TotalBackReadTime);    //      Total time spent reading in background
+		Com_DPrintf("TotalReadSpeed:       %d\n",Summary.TotalReadSpeed);    //         Total io speed (bytes/second)
+		Com_DPrintf("SlowestFrameTime:     %d\n",Summary.SlowestFrameTime);    //       Slowest single frame time (ms)
+		Com_DPrintf("Slowest2FrameTime:    %d\n",Summary.Slowest2FrameTime);    //      Second slowest single frame time (ms)
+		Com_DPrintf("SlowestFrameNum:      %d\n",Summary.SlowestFrameNum);    //        Slowest single frame number
+		Com_DPrintf("Slowest2FrameNum:     %d\n",Summary.Slowest2FrameNum);    //       Second slowest single frame number
+		Com_DPrintf("AverageDataRate:      %d\n",Summary.AverageDataRate);    //        Average data rate of the movie
+		Com_DPrintf("AverageFrameSize:     %d\n",Summary.AverageFrameSize);    //       Average size of the frame
+		Com_DPrintf("HighestMemAmount:     %d\n",Summary.HighestMemAmount);    //       Highest amount of memory allocated
+		Com_DPrintf("TotalIOMemory:        %d\n",Summary.TotalIOMemory);    //          Total extra memory allocated
+		Com_DPrintf("HighestIOUsed:        %d\n",Summary.HighestIOUsed);    //          Highest extra memory actually used
+		Com_DPrintf("Highest1SecRate:      %d\n",Summary.Highest1SecRate);    //        Highest 1 second rate
+		Com_DPrintf("Highest1SecFrame:     %d\n",Summary.Highest1SecFrame);    //       Highest 1 second start frame
+		Com_DPrintf("\n");
+#endif
+		BinkClose(hBink);
+		hBink = NULL;
+		SNDDMA_Activate();
+	}
+
+	if (hBinkFile)
+	{
+		CloseHandle(hBinkFile);
+		hBinkFile = NULL;
+	}
+*/
+}
+/*
+static qboolean VIDEO_Open2(char *psPathlessBaseName, qboolean qbInGame, qboolean qbTestOpenOnly, int iLanguageNumber)
+{
+	char sLocalFilename[MAX_OSPATH];
+
+	// Get the Quake filesystem to see if it exists, and fill in some internal structs as to where it really is,
+	//	and what offset (if PAK) etc...
+	//	
+	Com_sprintf (sLocalFilename, sizeof(sLocalFilename), "video/%s.bik", psPathlessBaseName);
+	char *psActualFilename;
+	int  iSeekOffset;
+	qboolean bResult = FS_GetExtendedInfo_FOpenFileRead(sLocalFilename, &psActualFilename, &iSeekOffset);
+	if (!bResult) 
+	{
+		if (!qbTestOpenOnly)
+		{
+			Com_Printf(S_COLOR_RED"Couldn't open %s\n", sLocalFilename);
+		}
+		return qfalse;
+	}
+
+	if (qbTestOpenOnly)
+		return qtrue;
+
+
+	// Now re-open as a Windoze HANDLE, because Bink doesn't use FILE * types...
+	//
+	hBinkFile =	CreateFile(	psActualFilename,		// LPCTSTR lpFileName,          // pointer to name of the file
+							GENERIC_READ,			// DWORD dwDesiredAccess,       // access (read-write) mode
+							FILE_SHARE_READ,		// DWORD dwShareMode,           // share mode
+							NULL,					// LPSECURITY_ATTRIBUTES lpSecurityAttributes,	// pointer to security attributes
+							OPEN_EXISTING,			// DWORD dwCreationDisposition,  // how to create
+							FILE_FLAG_SEQUENTIAL_SCAN,// DWORD dwFlagsAndAttributes,   // file attributes
+							NULL					// HANDLE hTemplateFile          // handle to file with attributes to 
+	  						);
+
+	if (hBinkFile == INVALID_HANDLE_VALUE)
+	{
+		Com_Printf(S_COLOR_RED"Error converting FILE* to HANDLE for Bink, file: %s\n", psActualFilename);
+		return qfalse;
+	}
+
+
+	// Opened ok, now seek the handle to the correct position for starting (ie if inside a PAK file etc)
+	//
+	DWORD dwFileOffset = SetFilePointer(hBinkFile,	// HANDLE hFile,          // handle of file
+										iSeekOffset,// LONG lDistanceToMove,  // number of bytes to move file pointer
+										NULL,		// PLONG lpDistanceToMoveHigh, // pointer to high-order DWORD of distance to move
+										FILE_BEGIN	// DWORD dwMoveMethod     // how to move
+										);
+
+	if (dwFileOffset != iSeekOffset)
+	{
+		VIDEO_Close();
+		Com_Printf( S_COLOR_RED"Error seeking to Bink video start (offset %d), file: %s\n", iSeekOffset,psActualFilename);
+		return qfalse;
+	}
+	
+ 
+	// ok, I think we're ready...
+	//
+	if (!cls.soundStarted || s_soundStarted)	// sound system not started (occurs in very first video), or sound desired
+	{
+		BinkSoundUseDirectSound(SNDDMA_GetDSHandle());
+		BinkSetSoundTrack(iLanguageNumber);	// select the language anyway here, regardless of multi-lingual file or not
+	}
+	else
+	{
+		BinkSetSoundTrack(BINKNOSOUND);
+	}
+
+//	hBink = BinkOpen("d:\\kiss.bik",0);
+	hBink = BinkOpen((char *)hBinkFile,BINKFILEHANDLE | BINKSNDTRACK);
+	if (!hBink) 
+	{
+		VIDEO_Close();
+		Com_Printf( S_COLOR_RED"Unrecognised video file: %s\n", psActualFilename);
+		return qfalse;
+	}
+		
+	if (!s_soundStarted)	// game running in silent mode?
+	{
+		VIDEO_Mute(qtrue);
+	}
+
+	return qtrue;
+}
+*/
+
+// now modified to take different languages into account...
+//
+qboolean VIDEO_Open(char *psPathlessBaseName, qboolean qbInGame, qboolean qbTestOpenOnly, int iLanguageNumber)
+{
+/*
+	qboolean qbReturn = VIDEO_Open2(psPathlessBaseName, qbInGame, qbTestOpenOnly, iLanguageNumber);
+
+	if (qbReturn)
+	{
+		if (!qbTestOpenOnly && hBink)
+		{
+			// check we didn't try to (eg) select German audio on a file with 1 track (eg just music)
+			//
+			if (iLanguageNumber+1 > hBink->NumTracks)
+			{
+				VIDEO_Close();
+				return VIDEO_Open2(psPathlessBaseName, qbInGame, qbTestOpenOnly, 0);
+			}
+		}
+	}
+
+	return qbReturn;
+*/ 
+	return qfalse;
+}
+
+
+//////////////// eof //////////////////
+
diff --git a/code/win32/win_wndproc.cpp b/code/win32/win_wndproc.cpp
new file mode 100644
index 0000000..e884a40
--- /dev/null
+++ b/code/win32/win_wndproc.cpp
@@ -0,0 +1,532 @@
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+
+	    
+
+#include "../client/client.h"
+#include "win_local.h"
+
+// The only directly referenced keycode - the console key (which gives different ascii codes depending on locale)
+#define CONSOLE_SCAN_CODE	0x29
+
+
+WinVars_t	g_wv;
+
+#ifndef WM_MOUSEWHEEL
+#define WM_MOUSEWHEEL (WM_MOUSELAST+1)  // message that will be supported by the OS 
+#endif
+
+static UINT MSH_MOUSEWHEEL;
+
+// Console variables that we need to access from this module
+cvar_t		*vid_xpos;			// X coordinate of window position
+cvar_t		*vid_ypos;			// Y coordinate of window position
+cvar_t		*sr_fullscreen;
+
+#define VID_NUM_MODES ( sizeof( vid_modes ) / sizeof( vid_modes[0] ) )
+
+LONG WINAPI MainWndProc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam );
+
+static qboolean s_alttab_disabled;
+
+static void WIN_DisableAltTab( void )
+{
+	if ( s_alttab_disabled )
+		return;
+
+	if ( !Q_stricmp( Cvar_VariableString( "arch" ), "winnt" ) )
+	{
+		RegisterHotKey( 0, 0, MOD_ALT, VK_TAB );
+	}
+	else
+	{
+		BOOL old;
+
+		SystemParametersInfo( SPI_SCREENSAVERRUNNING, 1, &old, 0 );
+	}
+	s_alttab_disabled = qtrue;
+}
+
+static void WIN_EnableAltTab( void )
+{
+	if ( s_alttab_disabled )
+	{
+		if ( !Q_stricmp( Cvar_VariableString( "arch" ), "winnt" ) )
+		{
+			UnregisterHotKey( 0, 0 );
+		}
+		else
+		{
+			BOOL old;
+
+			SystemParametersInfo( SPI_SCREENSAVERRUNNING, 0, &old, 0 );
+		}
+
+		s_alttab_disabled = qfalse;
+	}
+}
+
+/*
+==================
+VID_AppActivate
+==================
+*/
+static void VID_AppActivate(BOOL fActive, BOOL minimize)
+{
+	g_wv.isMinimized = minimize;
+
+	Key_ClearStates();	// FIXME!!!
+
+	// we don't want to act like we're active if we're minimized
+	if (fActive && !g_wv.isMinimized )
+	{
+		g_wv.activeApp = qtrue;
+	}
+	else
+	{
+		g_wv.activeApp = qfalse;
+	}
+
+	// minimize/restore mouse-capture on demand
+	if (!g_wv.activeApp )
+	{
+		IN_Activate (qfalse);
+	}
+	else
+	{
+		IN_Activate (qtrue);
+	}
+}
+
+static byte virtualKeyConvert[0x92][2] =
+{
+	{ 0,				0				},     
+	{ A_MOUSE1,			A_MOUSE1		}, // VK_LBUTTON 01 Left mouse button  
+	{ A_MOUSE2,			A_MOUSE2		}, // VK_RBUTTON 02 Right mouse button  
+	{ 0,				0				}, // VK_CANCEL 03 Control-break processing  
+	{ A_MOUSE3,			A_MOUSE3		}, // VK_MBUTTON 04 Middle mouse button (three-button mouse)  
+	{ A_MOUSE4,			A_MOUSE4		}, // VK_XBUTTON1 05 Windows 2000/XP: X1 mouse button 
+	{ A_MOUSE5,			A_MOUSE5		}, // VK_XBUTTON2 06 Windows 2000/XP: X2 mouse button 
+	{ 0,				0				}, // 07 Undefined  
+	{ A_BACKSPACE,		A_BACKSPACE		}, // VK_BACK 08 BACKSPACE key  
+	{ A_TAB,			A_TAB			}, // VK_TAB 09 TAB key  
+	{ 0,				0				}, // 0A Reserved  
+	{ 0,				0				}, // 0B Reserved  
+	{ A_KP_5,			0				}, // VK_CLEAR 0C CLEAR key  
+	{ A_ENTER, 			A_KP_ENTER 		}, // VK_RETURN 0D ENTER key  
+	{ 0,				0				}, // 0E Undefined  
+	{ 0,				0				}, // 0F Undefined  
+	{ A_SHIFT,			A_SHIFT			}, // VK_SHIFT 10 SHIFT key  
+	{ A_CTRL,			A_CTRL			}, // VK_CONTROL 11 CTRL key  
+	{ A_ALT,			A_ALT			}, // VK_MENU 12 ALT key  
+	{ A_PAUSE,			A_PAUSE			}, // VK_PAUSE 13 PAUSE key  
+	{ A_CAPSLOCK,		A_CAPSLOCK		}, // VK_CAPITAL 14 CAPS LOCK key  
+	{ 0,				0				}, // VK_KANA 15 IME Kana mode 
+	{ 0,				0				}, // 16 Undefined  
+	{ 0,				0				}, // VK_JUNJA 17 IME Junja mode 
+	{ 0,				0				}, // VK_FINAL 18 IME final mode 
+	{ 0,				0				}, // VK_KANJI 19 IME Kanji mode 
+	{ 0,				0				}, // 1A Undefined  
+	{ A_ESCAPE,			A_ESCAPE		}, // VK_ESCAPE 1B ESC key  
+	{ 0,				0				}, // VK_CONVERT 1C IME convert 
+	{ 0,				0				}, // VK_NONCONVERT 1D IME nonconvert 
+	{ 0,				0				}, // VK_ACCEPT 1E IME accept 
+	{ 0,				0				}, // VK_MODECHANGE 1F IME mode change request 
+	{ A_SPACE,			A_SPACE			}, // VK_SPACE 20 SPACEBAR  
+	{ A_KP_9,			A_PAGE_UP		}, // VK_PRIOR 21 PAGE UP key  
+	{ A_KP_3,			A_PAGE_DOWN		}, // VK_NEXT 22 PAGE DOWN key  
+	{ A_KP_1,			A_END			}, // VK_END 23 END key  
+	{ A_KP_7,			A_HOME			}, // VK_HOME 24 HOME key  
+	{ A_KP_4,			A_CURSOR_LEFT	}, // VK_LEFT 25 LEFT ARROW key  
+	{ A_KP_8,			A_CURSOR_UP   	}, // VK_UP 26 UP ARROW key  
+	{ A_KP_6,			A_CURSOR_RIGHT	}, // VK_RIGHT 27 RIGHT ARROW key  
+	{ A_KP_2,			A_CURSOR_DOWN	}, // VK_DOWN 28 DOWN ARROW key  
+	{ 0,				0				}, // VK_SELECT 29 SELECT key  
+	{ 0,				0				}, // VK_PRINT 2A PRINT key 
+	{ 0,				0				}, // VK_EXECUTE 2B EXECUTE key  
+	{ A_PRINTSCREEN,	A_PRINTSCREEN	}, // VK_SNAPSHOT 2C PRINT SCREEN key  
+	{ A_KP_0,			A_INSERT		}, // VK_INSERT 2D INS key  
+	{ A_KP_PERIOD,		A_DELETE		}, // VK_DELETE 2E DEL key  
+	{ 0,				0				}, // VK_HELP 2F HELP key  
+	{ A_0,				A_0				}, // 30 0 key  
+	{ A_1,				A_1				}, // 31 1 key  
+	{ A_2,				A_2				}, // 32 2 key  
+	{ A_3,				A_3				}, // 33 3 key  
+	{ A_4,				A_4				}, // 34 4 key  
+	{ A_5,				A_5				}, // 35 5 key  
+	{ A_6,				A_6				}, // 36 6 key  
+	{ A_7,				A_7				}, // 37 7 key  
+	{ A_8,				A_8				}, // 38 8 key  
+	{ A_9,				A_9				}, // 39 9 key  
+	{ 0,				0				}, // 3A Undefined  
+	{ 0,				0				}, // 3B Undefined  
+	{ 0,				0				}, // 3C Undefined  
+	{ 0,				0				}, // 3D Undefined  
+	{ 0,				0				}, // 3E Undefined  
+	{ 0,				0				}, // 3F Undefined  
+	{ 0,				0				}, // 40 Undefined  
+	{ A_CAP_A,			A_CAP_A			}, // 41 A key  
+	{ A_CAP_B,			A_CAP_B			}, // 42 B key  
+	{ A_CAP_C,			A_CAP_C			}, // 43 C key  
+	{ A_CAP_D,			A_CAP_D			}, // 44 D key  
+	{ A_CAP_E,			A_CAP_E			}, // 45 E key  
+	{ A_CAP_F,			A_CAP_F			}, // 46 F key  
+	{ A_CAP_G,			A_CAP_G			}, // 47 G key  
+	{ A_CAP_H,			A_CAP_H			}, // 48 H key  
+	{ A_CAP_I,			A_CAP_I			}, // 49 I key  
+	{ A_CAP_J,			A_CAP_J			}, // 4A J key  
+	{ A_CAP_K,			A_CAP_K			}, // 4B K key  
+	{ A_CAP_L,			A_CAP_L			}, // 4C L key  
+	{ A_CAP_M,			A_CAP_M			}, // 4D M key  
+	{ A_CAP_N,			A_CAP_N			}, // 4E N key  
+	{ A_CAP_O,			A_CAP_O			}, // 4F O key  
+	{ A_CAP_P,			A_CAP_P			}, // 50 P key  
+	{ A_CAP_Q,			A_CAP_Q			}, // 51 Q key  
+	{ A_CAP_R,			A_CAP_R			}, // 52 R key  
+	{ A_CAP_S,			A_CAP_S			}, // 53 S key  
+	{ A_CAP_T,			A_CAP_T			}, // 54 T key  
+	{ A_CAP_U,			A_CAP_U			}, // 55 U key  
+	{ A_CAP_V,			A_CAP_V			}, // 56 V key  
+	{ A_CAP_W,			A_CAP_W			}, // 57 W key  
+	{ A_CAP_X,			A_CAP_X			}, // 58 X key  
+	{ A_CAP_Y,			A_CAP_Y			}, // 59 Y key  
+	{ A_CAP_Z,			A_CAP_Z			}, // 5A Z key  
+	{ 0,				0				}, // VK_LWIN 5B Left Windows key (Microsoft® Natural® keyboard)  
+	{ 0,				0				}, // VK_RWIN 5C Right Windows key (Natural keyboard)  
+	{ 0,				0				}, // VK_APPS 5D Applications key (Natural keyboard)  
+	{ 0,				0				}, // 5E Reserved  
+	{ 0,				0				}, // VK_SLEEP 5F Computer Sleep key 
+	{ A_KP_0,			A_KP_0			}, // VK_NUMPAD0 60 Numeric keypad 0 key  
+	{ A_KP_1,			A_KP_1			}, // VK_NUMPAD1 61 Numeric keypad 1 key  
+	{ A_KP_2,			A_KP_2			}, // VK_NUMPAD2 62 Numeric keypad 2 key  
+	{ A_KP_3,			A_KP_3			}, // VK_NUMPAD3 63 Numeric keypad 3 key  
+	{ A_KP_4,			A_KP_4			}, // VK_NUMPAD4 64 Numeric keypad 4 key  
+	{ A_KP_5,			A_KP_5			}, // VK_NUMPAD5 65 Numeric keypad 5 key  
+	{ A_KP_6,			A_KP_6			}, // VK_NUMPAD6 66 Numeric keypad 6 key  
+	{ A_KP_7,			A_KP_7			}, // VK_NUMPAD7 67 Numeric keypad 7 key  
+	{ A_KP_8,			A_KP_8			}, // VK_NUMPAD8 68 Numeric keypad 8 key  
+	{ A_KP_9,			A_KP_9			}, // VK_NUMPAD9 69 Numeric keypad 9 key  
+	{ A_MULTIPLY,		A_MULTIPLY		}, // VK_MULTIPLY 6A Multiply key  
+	{ A_KP_PLUS, 		A_KP_PLUS 		}, // VK_ADD 6B Add key  
+	{ 0,				0				}, // VK_SEPARATOR 6C Separator key  
+	{ A_KP_MINUS,		A_KP_MINUS		}, // VK_SUBTRACT 6D Subtract key  
+	{ A_KP_PERIOD,		A_KP_PERIOD		}, // VK_DECIMAL 6E Decimal key  
+	{ A_DIVIDE,			A_DIVIDE		}, // VK_DIVIDE 6F Divide key  
+	{ A_F1,				A_F1			}, // VK_F1 70 F1 key  
+	{ A_F2,				A_F2			}, // VK_F2 71 F2 key  
+	{ A_F3,				A_F3			}, // VK_F3 72 F3 key  
+	{ A_F4,				A_F4			}, // VK_F4 73 F4 key  
+	{ A_F5,				A_F5			}, // VK_F5 74 F5 key  
+	{ A_F6,				A_F6			}, // VK_F6 75 F6 key  
+	{ A_F7,				A_F7			}, // VK_F7 76 F7 key  
+	{ A_F8,				A_F8			}, // VK_F8 77 F8 key  
+	{ A_F9,				A_F9			}, // VK_F9 78 F9 key  
+	{ A_F10,			A_F10			}, // VK_F10 79 F10 key  
+	{ A_F11,			A_F11			}, // VK_F11 7A F11 key  
+	{ A_F12,			A_F12			}, // VK_F12 7B F12 key  
+	{ 0,				0				}, // VK_F13 7C F13 key  
+	{ 0,				0				}, // VK_F14 7D F14 key  
+	{ 0,				0				}, // VK_F15 7E F15 key  
+	{ 0,				0				}, // VK_F16 7F F16 key  
+	{ 0,				0				}, // VK_F17 80H F17 key  
+	{ 0,				0				}, // VK_F18 81H F18 key  
+	{ 0,				0				}, // VK_F19 82H F19 key  
+	{ 0,				0				}, // VK_F20 83H F20 key  
+	{ 0,				0				}, // VK_F21 84H F21 key  
+	{ 0,				0				}, // VK_F22 85H F22 key  
+	{ 0,				0				}, // VK_F23 86H F23 key  
+	{ 0,				0				}, // VK_F24 87H F24 key  
+	{ 0,				0				}, // 88 Unassigned
+	{ 0,				0				}, // 89 Unassigned
+	{ 0,				0				}, // 8A Unassigned
+	{ 0,				0				}, // 8B Unassigned
+	{ 0,				0				}, // 8C Unassigned
+	{ 0,				0				}, // 8D Unassigned
+	{ 0,				0				}, // 8E Unassigned
+	{ 0,				0				}, // 8F Unassigned
+	{ A_NUMLOCK,		A_NUMLOCK		}, // VK_NUMLOCK 90 NUM LOCK key  
+	{ A_SCROLLLOCK,		A_SCROLLLOCK	}  // VK_SCROLL 91 
+};
+
+/*
+=======
+MapKey
+
+Map from windows to quake keynums
+=======
+*/
+static int MapKey (ulong key, word wParam)
+{
+	ulong	result, scan, extended;
+
+	// Check for the console key (hard code to the key you would expect)
+	scan = ( key >> 16 ) & 0xff;
+	if(scan == CONSOLE_SCAN_CODE)
+	{
+		return(A_CONSOLE);
+	}
+
+	// Try to convert the virtual key directly
+	result = 0;
+	extended = (key >> 24) & 1;
+	if(wParam > 0 && wParam <= VK_SCROLL)
+	{
+		result = virtualKeyConvert[wParam][extended];
+	}
+	// Get the unshifted ascii code (if any)
+	if(!result)
+	{
+		result = MapVirtualKey(wParam, 2) & 0xff;
+	}
+	// Output any debug prints
+//	if(in_debug && in_debug->integer & 1)
+//	{
+//		Com_Printf("WM_KEY: %x : %x : %x\n", key, wParam, result);
+//	}
+	return(result);
+}
+
+
+/*
+====================
+MainWndProc
+
+main window procedure
+====================
+*/
+
+#define WM_BUTTON4DOWN	(WM_MOUSELAST+2)
+#define WM_BUTTON4UP	(WM_MOUSELAST+3)
+#define MK_BUTTON4L		0x0020
+#define MK_BUTTON4R		0x0040
+
+LONG WINAPI MainWndProc (
+    HWND    hWnd,
+    UINT    uMsg,
+    WPARAM  wParam,
+    LPARAM  lParam)
+{
+	byte	code;
+
+	if ( uMsg == MSH_MOUSEWHEEL )
+	{
+		if ( ( ( int ) wParam ) > 0 )
+		{
+			Sys_QueEvent( g_wv.sysMsgTime, SE_KEY, A_MWHEELUP, qtrue, 0, NULL );
+			Sys_QueEvent( g_wv.sysMsgTime, SE_KEY, A_MWHEELUP, qfalse, 0, NULL );
+		}
+		else
+		{
+			Sys_QueEvent( g_wv.sysMsgTime, SE_KEY, A_MWHEELDOWN, qtrue, 0, NULL );
+			Sys_QueEvent( g_wv.sysMsgTime, SE_KEY, A_MWHEELDOWN, qfalse, 0, NULL );
+		}
+        return DefWindowProc (hWnd, uMsg, wParam, lParam);
+	}
+
+	switch (uMsg)
+	{
+	case WM_MOUSEWHEEL:
+		//
+		//
+		// this chunk of code theoretically only works under NT4 and Win98
+		// since this message doesn't exist under Win95
+		//
+		if ( ( short ) HIWORD( wParam ) > 0 )
+		{
+			Sys_QueEvent( g_wv.sysMsgTime, SE_KEY, A_MWHEELUP, qtrue, 0, NULL );
+			Sys_QueEvent( g_wv.sysMsgTime, SE_KEY, A_MWHEELUP, qfalse, 0, NULL );
+		}
+		else
+		{
+			Sys_QueEvent( g_wv.sysMsgTime, SE_KEY, A_MWHEELDOWN, qtrue, 0, NULL );
+			Sys_QueEvent( g_wv.sysMsgTime, SE_KEY, A_MWHEELDOWN, qfalse, 0, NULL );
+		}
+		break;
+
+	case WM_CREATE:
+
+		g_wv.hWnd = hWnd;
+
+		vid_xpos = Cvar_Get ("vid_xpos", "3", CVAR_ARCHIVE);
+		vid_ypos = Cvar_Get ("vid_ypos", "22", CVAR_ARCHIVE);
+		sr_fullscreen = Cvar_Get ("r_fullscreen", "1", CVAR_ARCHIVE | CVAR_LATCH );
+
+		MSH_MOUSEWHEEL = RegisterWindowMessage("MSWHEEL_ROLLMSG"); 
+		if ( sr_fullscreen->integer )
+		{
+			WIN_DisableAltTab();
+		}
+		else
+		{
+			WIN_EnableAltTab();
+		}
+
+		break;
+#if 0
+	case WM_DISPLAYCHANGE:
+		Com_DPrintf( "WM_DISPLAYCHANGE\n" );
+		// we need to force a vid_restart if the user has changed
+		// their desktop resolution while the game is running,
+		// but don't do anything if the message is a result of
+		// our own calling of ChangeDisplaySettings
+		if ( com_insideVidInit ) {
+			break;		// we did this on purpose
+		}
+		// something else forced a mode change, so restart all our gl stuff
+		Cbuf_AddText( "vid_restart\n" );
+		break;
+#endif
+	case WM_DESTROY:
+		// let sound and input know about this?
+		g_wv.hWnd = NULL;
+		if ( sr_fullscreen->integer )
+		{
+			WIN_EnableAltTab();
+		}
+		break;
+
+	case WM_CLOSE:
+		Cbuf_ExecuteText( EXEC_APPEND, "quit" );
+		break;
+
+	case WM_ACTIVATE:
+		{
+			int	fActive, fMinimized;
+
+			fActive = LOWORD(wParam);
+			fMinimized = (BOOL) HIWORD(wParam);
+
+			VID_AppActivate( fActive != WA_INACTIVE, fMinimized);
+			SNDDMA_Activate( fActive != WA_INACTIVE && !fMinimized );
+		}
+		break;
+
+	case WM_MOVE:
+		{
+			int		xPos, yPos;
+			RECT r;
+			int		style;
+
+			if (!sr_fullscreen->integer )
+			{
+				xPos = (short) LOWORD(lParam);    // horizontal position 
+				yPos = (short) HIWORD(lParam);    // vertical position 
+
+				r.left   = 0;
+				r.top    = 0;
+				r.right  = 1;
+				r.bottom = 1;
+
+				style = GetWindowLong( hWnd, GWL_STYLE );
+				AdjustWindowRect( &r, style, FALSE );
+
+				Cvar_SetValue( "vid_xpos", xPos + r.left);
+				Cvar_SetValue( "vid_ypos", yPos + r.top);
+				vid_xpos->modified = qfalse;
+				vid_ypos->modified = qfalse;
+				if ( g_wv.activeApp )
+				{
+					IN_Activate (qtrue);
+				}
+			}
+		}
+		break;
+
+// this is complicated because Win32 seems to pack multiple mouse events into
+// one update sometimes, so we always check all states and look for events
+	case WM_LBUTTONDOWN:
+	case WM_LBUTTONUP:
+	case WM_RBUTTONDOWN:
+	case WM_RBUTTONUP:
+	case WM_MBUTTONDOWN:
+	case WM_MBUTTONUP:
+	case WM_MOUSEMOVE:
+	case WM_BUTTON4DOWN:
+	case WM_BUTTON4UP:
+		{
+			int	temp;
+
+			temp = 0;
+
+			if (wParam & MK_LBUTTON)
+				temp |= 1;
+
+			if (wParam & MK_RBUTTON)
+				temp |= 2;
+
+			if (wParam & MK_MBUTTON)
+				temp |= 4;
+
+		 	if (wParam & MK_BUTTON4L)
+				temp |= 8;
+
+			if (wParam & MK_BUTTON4R)
+				temp |= 16;
+
+			IN_MouseEvent (temp);
+		}
+		break;
+
+	case WM_SYSCOMMAND:
+		if ( (wParam&0xFFF0) == SC_SCREENSAVE || (wParam&0xFFF0) == SC_MONITORPOWER)
+		{
+			return 0;
+		}
+		break;
+
+	case WM_SYSKEYDOWN:
+		if ( wParam == VK_RETURN )	//alt-enter
+		{
+			if ( sr_fullscreen && !ge || (ge->GameAllowedToSaveHere() && !(cls.keyCatchers&KEYCATCH_UI)) )
+			{//okay, don't switch if the game is running while in a cinematic or in the menu
+				Cvar_SetValue( "r_fullscreen", !sr_fullscreen->integer );
+				Cbuf_AddText( "vid_restart\n" );
+			}
+			return 0;
+		}
+		// fall through
+	case WM_KEYDOWN:
+		code = MapKey( lParam, wParam );
+		if(code)
+		{
+			Sys_QueEvent( g_wv.sysMsgTime, SE_KEY, code, qtrue, 0, NULL );
+		}
+		break;
+
+	case WM_SYSKEYUP:
+	case WM_KEYUP:
+		code = MapKey( lParam, wParam );
+		if(code)
+		{
+			Sys_QueEvent( g_wv.sysMsgTime, SE_KEY, code, qfalse, 0, NULL );
+		}
+		break;
+
+	case WM_CHAR:
+		if(((lParam >> 16) & 0xff) != CONSOLE_SCAN_CODE)
+		{
+			Sys_QueEvent( g_wv.sysMsgTime, SE_CHAR, wParam, 0, 0, NULL );
+		}
+		// Output any debug prints
+//		if(in_debug && in_debug->integer & 2)
+//		{
+//			Com_Printf("WM_CHAR: %x\n", wParam);
+//		}
+		break;
+
+	case WM_POWERBROADCAST:
+		if (wParam == PBT_APMQUERYSUSPEND)
+		{
+#ifndef FINAL_BUILD
+			Com_Printf("Cannot go into hibernate / standby mode while game is running!\n");
+#endif
+			return BROADCAST_QUERY_DENY;
+		}
+		break;
+    }
+
+    return DefWindowProc( hWnd, uMsg, wParam, lParam );
+}
+
diff --git a/code/win32/winquake.rc b/code/win32/winquake.rc
new file mode 100644
index 0000000..140f0a5
--- /dev/null
+++ b/code/win32/winquake.rc
@@ -0,0 +1,101 @@
+// Microsoft Visual C++ generated resource script.
+//
+#include "resource.h"
+
+#define APSTUDIO_READONLY_SYMBOLS
+/////////////////////////////////////////////////////////////////////////////
+//
+// Generated from the TEXTINCLUDE 2 resource.
+//
+#include "winres.h"
+
+/////////////////////////////////////////////////////////////////////////////
+#undef APSTUDIO_READONLY_SYMBOLS
+
+/////////////////////////////////////////////////////////////////////////////
+// English (U.S.) resources
+
+#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU)
+#ifdef _WIN32
+LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US
+#pragma code_page(1252)
+#endif //_WIN32
+
+#ifdef APSTUDIO_INVOKED
+/////////////////////////////////////////////////////////////////////////////
+//
+// TEXTINCLUDE
+//
+
+1 TEXTINCLUDE 
+BEGIN
+    "resource.h\0"
+END
+
+2 TEXTINCLUDE 
+BEGIN
+    "#include ""winres.h""\r\n"
+    "\0"
+END
+
+3 TEXTINCLUDE 
+BEGIN
+    "\0"
+END
+
+#endif    // APSTUDIO_INVOKED
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// Icon
+//
+
+// Icon with lowest ID value placed first to ensure application icon
+// remains consistent on all systems.
+IDI_ICON1               ICON                    "starwars.ico"
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// Version
+//
+#include "AutoVersion.h"
+
+VS_VERSION_INFO VERSIONINFO
+ FILEVERSION VERSION_MAJOR_RELEASE,VERSION_MINOR_RELEASE,VERSION_EXTERNAL_BUILD,VERSION_INTERNAL_BUILD
+ PRODUCTVERSION VERSION_MAJOR_RELEASE,VERSION_MINOR_RELEASE,VERSION_EXTERNAL_BUILD,VERSION_INTERNAL_BUILD
+ FILEFLAGSMASK 0x17L
+#ifdef _DEBUG
+ FILEFLAGS 0x1L
+#else
+ FILEFLAGS 0x0L
+#endif
+ FILEOS 0x4L
+ FILETYPE 0x1L
+ FILESUBTYPE 0x0L
+BEGIN
+    BLOCK "StringFileInfo"
+    BEGIN
+        BLOCK "040904b0"
+        BEGIN
+            VALUE "Comments", "Raven Software"
+            VALUE "CompanyName", "Activision Inc"
+            VALUE "FileDescription", "Jedi Academy SP"
+            VALUE "FileVersion",  VERSION_STRING
+            VALUE "InternalName", "JASP"
+            VALUE "LegalCopyright", "Copyright (C) 2003"
+            VALUE "OriginalFilename", "jasp.exe"
+            VALUE "ProductName", "Jedi Knight®: Jedi Academy"
+            VALUE "ProductVersion",  VERSION_STRING
+        END
+    END
+    BLOCK "VarFileInfo"
+    BEGIN
+        VALUE "Translation", 0x409, 1200
+    END
+END
+
+#endif    // English (U.S.) resources
+/////////////////////////////////////////////////////////////////////////////
+
+
diff --git a/code/x_exe/mssccprj.scc b/code/x_exe/mssccprj.scc
new file mode 100644
index 0000000..3bfb92d
--- /dev/null
+++ b/code/x_exe/mssccprj.scc
@@ -0,0 +1,5 @@
+SCC = This is a Source Code Control file
+
+[x_exe.vcproj]
+SCC_Aux_Path = "\\ravendata1\vss\central_code"
+SCC_Project_Name = "$/jedi/code/x_exe", YUHAAAAA
diff --git a/code/x_exe/vssver.scc b/code/x_exe/vssver.scc
new file mode 100644
index 0000000..4e78126
Binary files /dev/null and b/code/x_exe/vssver.scc differ
diff --git a/code/x_exe/x_exe.vcproj b/code/x_exe/x_exe.vcproj
new file mode 100644
index 0000000..c162fa7
--- /dev/null
+++ b/code/x_exe/x_exe.vcproj
@@ -0,0 +1,1062 @@
+<?xml version="1.0" encoding = "Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="7.00"
+	Name="x_exe"
+	ProjectGUID="{FD1DA207-0D4A-47A8-A6AD-B81AE1BA28DA}"
+	Keyword="XboxProj">
+	<Platforms>
+		<Platform
+			Name="Xbox"/>
+	</Platforms>
+	<Configurations>
+		<Configuration
+			Name="Debug|Xbox"
+			OutputDirectory=".\Debug"
+			IntermediateDirectory=".\Debug\exe"
+			ConfigurationType="1"
+			CharacterSet="2">
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				OptimizeForProcessor="2"
+				AdditionalIncludeDirectories="$(BINK_XBOX_ROOT)"
+				PreprocessorDefinitions="_DEBUG;_XBOX;_JK2EXE;WIN32;VV_LIGHTING"
+				MinimalRebuild="TRUE"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="1"
+				EnableEnhancedInstructionSet="1"
+				UsePrecompiledHeader="0"
+				PrecompiledHeaderThrough="..\server\exe_headers.h"
+				PrecompiledHeaderFile=".\Debug\exe/starwars.pch"
+				BrowseInformation="1"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="FALSE"
+				DebugInformationFormat="3"
+				FastCAP="FALSE"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="xapilibd.lib d3d8d.lib d3dx8d.lib xgraphicsd.lib dsoundd.lib dmusicd.lib xboxkrnl.lib x_game.lib xbdm.lib goblib.lib  binkxbox.lib"
+				OutputFile=".\Debug\ja-debug.exe"
+				LinkIncremental="2"
+				AdditionalLibraryDirectories=".\Debug;&quot;$(BINK_XBOX_ROOT)&quot;"
+				GenerateDebugInformation="TRUE"
+				ProgramDatabaseFile="$(OutDir)/$(ProjectName).pdb"
+				SubSystem="2"
+				OptimizeForWindows98="1"
+				TargetMachine="1"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="XboxDeploymentTool"
+				RemotePath="xe:\JK3\$(TargetName).xbe"
+				AdditionalFiles="xe:\JK3\base\shaders=$(SolutionDir)x_shaders"/>
+			<Tool
+				Name="XboxImageTool"
+				StackSize="0x20000"
+				IncludeDebugInfo="TRUE"
+				LimitAvailableMemoryTo64MB="FALSE"
+				NoLibWarn="TRUE"
+				TitleID="0x4C41000B"/>
+		</Configuration>
+		<Configuration
+			Name="Release|Xbox"
+			OutputDirectory=".\Release"
+			IntermediateDirectory=".\Release\exe"
+			ConfigurationType="1"
+			CharacterSet="2">
+			<Tool
+				Name="VCCLCompilerTool"
+				AdditionalOptions="/Oy-"
+				Optimization="2"
+				InlineFunctionExpansion="1"
+				OmitFramePointers="FALSE"
+				OptimizeForProcessor="2"
+				AdditionalIncludeDirectories="$(BINK_XBOX_ROOT)"
+				PreprocessorDefinitions="NDEBUG;_XBOX;_JK2EXE;WIN32;VV_LIGHTING"
+				StringPooling="TRUE"
+				RuntimeLibrary="0"
+				BufferSecurityCheck="TRUE"
+				EnableFunctionLevelLinking="TRUE"
+				EnableEnhancedInstructionSet="1"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="FALSE"
+				DebugInformationFormat="3"
+				FastCAP="FALSE"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="xapilib.lib d3d8I.lib d3dx8.lib xgraphics.lib dsound.lib dmusic.lib xboxkrnl.lib x_game.lib goblib.lib binkxbox.lib xbdm.lib"
+				OutputFile=".\Release\ja-release.exe"
+				LinkIncremental="1"
+				AdditionalLibraryDirectories=".\Release;&quot;$(BINK_XBOX_ROOT)&quot;"
+				GenerateDebugInformation="TRUE"
+				ProgramDatabaseFile="$(OutDir)/$(ProjectName).pdb"
+				SubSystem="2"
+				OptimizeReferences="2"
+				EnableCOMDATFolding="2"
+				OptimizeForWindows98="1"
+				SetChecksum="TRUE"
+				TargetMachine="1"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="XboxDeploymentTool"
+				RemotePath="xe:\JK3\$(TargetName).xbe"
+				AdditionalFiles="xe:\JK3\base\shaders=$(SolutionDir)x_shaders"/>
+			<Tool
+				Name="XboxImageTool"
+				StackSize="0x20000"
+				LimitAvailableMemoryTo64MB="FALSE"
+				NoLibWarn="TRUE"
+				TitleID="0x4C41000B"/>
+		</Configuration>
+		<Configuration
+			Name="FinalBuild|Xbox"
+			OutputDirectory=".\FinalBuild"
+			IntermediateDirectory=".\FinalBuild\exe"
+			ConfigurationType="1"
+			CharacterSet="2">
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="3"
+				GlobalOptimizations="TRUE"
+				InlineFunctionExpansion="2"
+				EnableIntrinsicFunctions="TRUE"
+				FavorSizeOrSpeed="1"
+				OmitFramePointers="TRUE"
+				OptimizeForProcessor="2"
+				AdditionalIncludeDirectories="$(BINK_XBOX_ROOT)"
+				PreprocessorDefinitions="NDEBUG;_XBOX;_JK2EXE;WIN32;FINAL_BUILD;VV_LIGHTING;_FINAL"
+				StringPooling="TRUE"
+				RuntimeLibrary="0"
+				BufferSecurityCheck="TRUE"
+				EnableFunctionLevelLinking="TRUE"
+				EnableEnhancedInstructionSet="1"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="FALSE"
+				DebugInformationFormat="3"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="xapilib.lib d3d8.lib d3dx8.lib xgraphics.lib dsound.lib dmusic.lib xboxkrnl.lib binkxbox.lib"
+				OutputFile=".\FinalBuild\ja-final.exe"
+				LinkIncremental="1"
+				AdditionalLibraryDirectories=".\FinalBuild;&quot;$(BINK_XBOX_ROOT)&quot;"
+				GenerateDebugInformation="TRUE"
+				ProgramDatabaseFile="$(OutDir)/$(ProjectName).pdb"
+				SubSystem="2"
+				OptimizeReferences="2"
+				EnableCOMDATFolding="2"
+				OptimizeForWindows98="1"
+				SetChecksum="TRUE"
+				TargetMachine="1"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="XboxDeploymentTool"
+				RemotePath="xe:\JK3\$(TargetName).xbe"/>
+			<Tool
+				Name="XboxImageTool"
+				StackSize="0x20000"
+				LimitAvailableMemoryTo64MB="TRUE"
+				NoLibWarn="TRUE"
+				TitleID="0x4C41000B"/>
+		</Configuration>
+	</Configurations>
+	<Files>
+		<Filter
+			Name="Source Files">
+			<File
+				RelativePath="..\client\BinkVideo.cpp">
+			</File>
+			<File
+				RelativePath="..\client\BinkVideo.h">
+			</File>
+			<File
+				RelativePath="..\client\cl_cgame.cpp">
+			</File>
+			<File
+				RelativePath="..\client\cl_cin_console.cpp">
+			</File>
+			<File
+				RelativePath="..\client\cl_console.cpp">
+			</File>
+			<File
+				RelativePath="..\client\cl_input.cpp">
+			</File>
+			<File
+				RelativePath="..\client\cl_input_hotswap.cpp">
+			</File>
+			<File
+				RelativePath="..\client\cl_keys.cpp">
+			</File>
+			<File
+				RelativePath="..\client\cl_main.cpp">
+			</File>
+			<File
+				RelativePath="..\client\cl_parse.cpp">
+			</File>
+			<File
+				RelativePath="..\client\cl_scrn.cpp">
+			</File>
+			<File
+				RelativePath="..\client\cl_ui.cpp">
+			</File>
+			<File
+				RelativePath="..\qcommon\cm_load_xbox.cpp">
+			</File>
+			<File
+				RelativePath="..\qcommon\cm_patch.cpp">
+			</File>
+			<File
+				RelativePath="..\qcommon\cm_polylib.cpp">
+			</File>
+			<File
+				RelativePath="..\qcommon\cm_test.cpp">
+			</File>
+			<File
+				RelativePath="..\qcommon\cm_trace.cpp">
+			</File>
+			<File
+				RelativePath="..\qcommon\cmd.cpp">
+			</File>
+			<File
+				RelativePath="..\qcommon\common.cpp">
+			</File>
+			<File
+				RelativePath="..\qcommon\cvar.cpp">
+			</File>
+			<File
+				RelativePath="..\win32\dbg_console_xbox.cpp">
+				<FileConfiguration
+					Name="FinalBuild|Xbox"
+					ExcludedFromBuild="TRUE">
+					<Tool
+						Name="VCCLCompilerTool"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\win32\dbg_console_xbox.h">
+			</File>
+			<File
+				RelativePath="..\ff\ff_console.cpp">
+			</File>
+			<File
+				RelativePath="..\qcommon\files_common.cpp">
+			</File>
+			<File
+				RelativePath="..\qcommon\files_console.cpp">
+			</File>
+			<File
+				RelativePath="..\game\genericparser2.cpp">
+			</File>
+			<File
+				RelativePath="..\qcommon\md4.cpp">
+			</File>
+			<File
+				RelativePath="..\qcommon\msg.cpp">
+			</File>
+			<File
+				RelativePath="..\qcommon\net_chan.cpp">
+			</File>
+			<File
+				RelativePath="..\game\q_math.cpp">
+			</File>
+			<File
+				RelativePath="..\game\q_shared.cpp">
+			</File>
+			<File
+				RelativePath="..\client\snd_ambient.cpp">
+			</File>
+			<File
+				RelativePath="..\client\snd_dma_console.cpp">
+			</File>
+			<File
+				RelativePath="..\client\snd_mem_console.cpp">
+			</File>
+			<File
+				RelativePath="..\client\snd_music.cpp">
+			</File>
+			<File
+				RelativePath="..\qcommon\stringed_ingame.cpp">
+			</File>
+			<File
+				RelativePath="..\qcommon\stringed_interface.cpp">
+			</File>
+			<File
+				RelativePath="..\server\sv_ccmds.cpp">
+			</File>
+			<File
+				RelativePath="..\server\sv_client.cpp">
+			</File>
+			<File
+				RelativePath="..\server\sv_game.cpp">
+			</File>
+			<File
+				RelativePath="..\server\sv_init.cpp">
+			</File>
+			<File
+				RelativePath="..\server\sv_main.cpp">
+			</File>
+			<File
+				RelativePath="..\server\sv_savegame.cpp">
+			</File>
+			<File
+				RelativePath="..\server\sv_snapshot.cpp">
+			</File>
+			<File
+				RelativePath="..\server\sv_world.cpp">
+			</File>
+			<File
+				RelativePath="..\client\vmachine.cpp">
+			</File>
+			<File
+				RelativePath="..\win32\win_file_xbox.cpp">
+			</File>
+			<File
+				RelativePath="..\win32\win_filecode.cpp">
+			</File>
+			<File
+				RelativePath="..\win32\win_input_console.cpp">
+			</File>
+			<File
+				RelativePath="..\win32\win_input_rumble.cpp">
+			</File>
+			<File
+				RelativePath="..\win32\win_input_xbox.cpp">
+			</File>
+			<File
+				RelativePath="..\win32\win_main_common.cpp">
+			</File>
+			<File
+				RelativePath="..\win32\win_main_console.cpp">
+			</File>
+			<File
+				RelativePath="..\win32\win_qal_xbox.cpp">
+			</File>
+			<File
+				RelativePath="..\win32\win_shared.cpp">
+			</File>
+			<File
+				RelativePath="..\win32\win_stream_dx8.cpp">
+			</File>
+			<File
+				RelativePath="..\qcommon\z_memman_console.cpp">
+			</File>
+			<Filter
+				Name="EAX">
+				<File
+					RelativePath="..\client\eax\EaxMan.h">
+				</File>
+				<File
+					RelativePath="..\client\eax\eax.h">
+				</File>
+			</Filter>
+			<Filter
+				Name="OpenAL">
+				<File
+					RelativePath="..\client\OpenAL\al.h">
+				</File>
+				<File
+					RelativePath="..\client\OpenAL\alc.h">
+				</File>
+				<File
+					RelativePath="..\client\OpenAL\alctypes.h">
+				</File>
+				<File
+					RelativePath="..\client\OpenAL\altypes.h">
+				</File>
+				<File
+					RelativePath="..\client\OpenAL\alu.h">
+				</File>
+				<File
+					RelativePath="..\client\OpenAL\alut.h">
+				</File>
+			</Filter>
+		</Filter>
+		<Filter
+			Name="zlib32">
+			<File
+				RelativePath="..\zlib32\deflate.cpp">
+			</File>
+			<File
+				RelativePath="..\zlib32\deflate.h">
+			</File>
+			<File
+				RelativePath="..\zlib32\inflate.cpp">
+			</File>
+			<File
+				RelativePath="..\zlib32\inflate.h">
+			</File>
+			<File
+				RelativePath="..\zlib32\zip.h">
+			</File>
+			<File
+				RelativePath="..\zlib32\zipcommon.cpp">
+			</File>
+		</Filter>
+		<Filter
+			Name="Header Files">
+			<File
+				RelativePath="..\game\anims.h">
+			</File>
+			<File
+				RelativePath="..\game\b_public.h">
+			</File>
+			<File
+				RelativePath="..\game\bg_public.h">
+			</File>
+			<File
+				RelativePath="..\game\bset.h">
+			</File>
+			<File
+				RelativePath="..\game\bstate.h">
+			</File>
+			<File
+				RelativePath="..\cgame\cg_public.h">
+			</File>
+			<File
+				RelativePath="..\qcommon\chash.h">
+			</File>
+			<File
+				RelativePath="..\client\cl_mp3.h">
+			</File>
+			<File
+				RelativePath="..\client\client.h">
+			</File>
+			<File
+				RelativePath="..\client\client_ui.h">
+			</File>
+			<File
+				RelativePath="..\qcommon\cm_draw.h">
+			</File>
+			<File
+				RelativePath="..\qcommon\cm_landscape.h">
+			</File>
+			<File
+				RelativePath="..\qcommon\cm_local.h">
+			</File>
+			<File
+				RelativePath="..\qcommon\cm_patch.h">
+			</File>
+			<File
+				RelativePath="..\qcommon\cm_polylib.h">
+			</File>
+			<File
+				RelativePath="..\qcommon\cm_public.h">
+			</File>
+			<File
+				RelativePath="..\qcommon\cm_randomterrain.h">
+			</File>
+			<File
+				RelativePath="..\qcommon\cm_terrainmap.h">
+			</File>
+			<File
+				RelativePath="..\game\common_headers.h">
+			</File>
+			<File
+				RelativePath="..\server\exe_headers.h">
+			</File>
+			<File
+				RelativePath="..\client\fffx.h">
+			</File>
+			<File
+				RelativePath="..\qcommon\files.h">
+			</File>
+			<File
+				RelativePath="..\qcommon\fixedmap.h">
+			</File>
+			<File
+				RelativePath="..\game\g_functions.h">
+			</File>
+			<File
+				RelativePath="..\game\g_items.h">
+			</File>
+			<File
+				RelativePath="..\game\g_local.h">
+			</File>
+			<File
+				RelativePath="..\game\g_nav.h">
+			</File>
+			<File
+				RelativePath="..\game\g_public.h">
+			</File>
+			<File
+				RelativePath="..\game\g_shared.h">
+			</File>
+			<File
+				RelativePath="..\game\genericparser2.h">
+			</File>
+			<File
+				RelativePath="..\qcommon\hstring.h">
+			</File>
+			<File
+				RelativePath="..\client\keys.h">
+			</File>
+			<File
+				RelativePath="..\qcommon\platform.h">
+			</File>
+			<File
+				RelativePath="..\game\q_shared.h">
+			</File>
+			<File
+				RelativePath="..\qcommon\qfiles.h">
+			</File>
+			<File
+				RelativePath="..\server\server.h">
+			</File>
+			<File
+				RelativePath="..\client\snd_ambient.h">
+			</File>
+			<File
+				RelativePath="..\client\snd_local.h">
+			</File>
+			<File
+				RelativePath="..\client\snd_music.h">
+			</File>
+			<File
+				RelativePath="..\client\snd_public.h">
+			</File>
+			<File
+				RelativePath="..\qcommon\sstring.h">
+			</File>
+			<File
+				RelativePath="..\game\statindex.h">
+			</File>
+			<File
+				RelativePath="..\qcommon\stringed_ingame.h">
+			</File>
+			<File
+				RelativePath="..\qcommon\stringed_interface.h">
+			</File>
+			<File
+				RelativePath="..\qcommon\tags.h">
+			</File>
+			<File
+				RelativePath="..\game\teams.h">
+			</File>
+			<File
+				RelativePath="..\qcommon\timing.h">
+			</File>
+			<File
+				RelativePath="..\qcommon\unzip.h">
+			</File>
+			<File
+				RelativePath="..\client\vmachine.h">
+			</File>
+			<File
+				RelativePath="..\game\weapons.h">
+			</File>
+			<File
+				RelativePath="..\win32\win_file.h">
+			</File>
+			<File
+				RelativePath="..\win32\win_input.h">
+			</File>
+			<File
+				RelativePath="..\win32\win_local.h">
+			</File>
+		</Filter>
+		<Filter
+			Name="Ghoul2">
+			<File
+				RelativePath="..\ghoul2\G2.h">
+			</File>
+			<File
+				RelativePath="..\ghoul2\G2_API.cpp">
+			</File>
+			<File
+				RelativePath="..\ghoul2\G2_bolts.cpp">
+			</File>
+			<File
+				RelativePath="..\ghoul2\G2_bones.cpp">
+			</File>
+			<File
+				RelativePath="..\ghoul2\G2_misc.cpp">
+			</File>
+			<File
+				RelativePath="..\ghoul2\G2_surfaces.cpp">
+			</File>
+			<File
+				RelativePath="..\qcommon\MiniHeap.h">
+			</File>
+			<File
+				RelativePath="..\ghoul2\ghoul2_gore.h">
+			</File>
+			<File
+				RelativePath="..\game\ghoul2_shared.h">
+			</File>
+			<File
+				RelativePath="..\renderer\matcomp.h">
+			</File>
+			<File
+				RelativePath="..\renderer\mdx_format.h">
+			</File>
+		</Filter>
+		<Filter
+			Name="Renderer Source">
+			<File
+				RelativePath="..\renderer\matcomp.c">
+			</File>
+			<File
+				RelativePath="..\renderer\tr_WorldEffects.cpp">
+			</File>
+			<File
+				RelativePath="..\renderer\tr_backend.cpp">
+			</File>
+			<File
+				RelativePath="..\renderer\tr_bsp_xbox.cpp">
+			</File>
+			<File
+				RelativePath="..\renderer\tr_cmds.cpp">
+			</File>
+			<File
+				RelativePath="..\renderer\tr_curve.cpp">
+			</File>
+			<File
+				RelativePath="..\renderer\tr_draw.cpp">
+			</File>
+			<File
+				RelativePath="..\renderer\tr_font.cpp">
+			</File>
+			<File
+				RelativePath="..\renderer\tr_ghoul2.cpp">
+			</File>
+			<File
+				RelativePath="..\renderer\tr_image.cpp">
+			</File>
+			<File
+				RelativePath="..\renderer\tr_init.cpp">
+			</File>
+			<File
+				RelativePath="..\renderer\tr_light.cpp">
+			</File>
+			<File
+				RelativePath="..\renderer\tr_lightmanager.cpp">
+			</File>
+			<File
+				RelativePath="..\renderer\tr_main.cpp">
+			</File>
+			<File
+				RelativePath="..\renderer\tr_marks.cpp">
+			</File>
+			<File
+				RelativePath="..\renderer\tr_mesh.cpp">
+			</File>
+			<File
+				RelativePath="..\renderer\tr_model.cpp">
+			</File>
+			<File
+				RelativePath="..\renderer\tr_noise.cpp">
+			</File>
+			<File
+				RelativePath="..\renderer\tr_quicksprite.cpp">
+			</File>
+			<File
+				RelativePath="..\renderer\tr_scene.cpp">
+			</File>
+			<File
+				RelativePath="..\renderer\tr_shade.cpp">
+			</File>
+			<File
+				RelativePath="..\renderer\tr_shade_calc.cpp">
+			</File>
+			<File
+				RelativePath="..\renderer\tr_shader.cpp">
+			</File>
+			<File
+				RelativePath="..\renderer\tr_shadows.cpp">
+			</File>
+			<File
+				RelativePath="..\renderer\tr_sky.cpp">
+			</File>
+			<File
+				RelativePath="..\renderer\tr_stl.cpp">
+			</File>
+			<File
+				RelativePath="..\renderer\tr_surface.cpp">
+			</File>
+			<File
+				RelativePath="..\renderer\tr_surfacesprites.cpp">
+			</File>
+			<File
+				RelativePath="..\renderer\tr_world.cpp">
+			</File>
+			<File
+				RelativePath="..\win32\win_gamma_console.cpp">
+			</File>
+			<File
+				RelativePath="..\win32\win_glimp_console.cpp">
+			</File>
+			<File
+				RelativePath="..\win32\win_highdynamicrange.cpp">
+			</File>
+			<File
+				RelativePath="..\win32\win_lighteffects.cpp">
+			</File>
+			<File
+				RelativePath="..\win32\win_qgl_dx8.cpp">
+			</File>
+			<File
+				RelativePath="..\win32\win_stencilshadow.cpp">
+			</File>
+			<Filter
+				Name="Renderer Headers">
+				<File
+					RelativePath="..\renderer\glext.h">
+				</File>
+				<File
+					RelativePath="..\win32\glw_win_dx8.h">
+				</File>
+				<File
+					RelativePath="..\renderer\qgl.h">
+				</File>
+				<File
+					RelativePath="..\win32\shader_constants.h">
+				</File>
+				<File
+					RelativePath="..\renderer\tr_WorldEffects.h">
+				</File>
+				<File
+					RelativePath="..\renderer\tr_font.h">
+				</File>
+				<File
+					RelativePath="..\renderer\tr_jpeg_interface.h">
+				</File>
+				<File
+					RelativePath="..\renderer\tr_landscape.h">
+				</File>
+				<File
+					RelativePath="..\renderer\tr_lightmanager.h">
+				</File>
+				<File
+					RelativePath="..\renderer\tr_local.h">
+				</File>
+				<File
+					RelativePath="..\renderer\tr_public.h">
+				</File>
+				<File
+					RelativePath="..\renderer\tr_quicksprite.h">
+				</File>
+				<File
+					RelativePath="..\renderer\tr_stl.h">
+				</File>
+				<File
+					RelativePath="..\renderer\tr_types.h">
+				</File>
+				<File
+					RelativePath="..\win32\win_highdynamicrange.h">
+				</File>
+				<File
+					RelativePath="..\win32\win_lighteffects.h">
+				</File>
+				<File
+					RelativePath="..\win32\win_stencilshadow.h">
+				</File>
+			</Filter>
+			<Filter
+				Name="x_shaders"
+				Filter="">
+				<File
+					RelativePath="..\x_shaders\bump.psh">
+					<FileConfiguration
+						Name="Debug|Xbox">
+						<Tool
+							Name="VCCustomBuildTool"
+							Description="Assembling vertex/pixel shaders"
+							CommandLine="xsasm $(InputPath)"
+							Outputs="$(InputDir)bump.xpu"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="Release|Xbox">
+						<Tool
+							Name="VCCustomBuildTool"
+							Description="Assembling vertex/pixel shaders"
+							CommandLine="xsasm $(InputPath)"
+							Outputs="$(InputDir)bump.xpu"/>
+					</FileConfiguration>
+				</File>
+				<File
+					RelativePath="..\x_shaders\bump.vsh">
+					<FileConfiguration
+						Name="Debug|Xbox">
+						<Tool
+							Name="VCCustomBuildTool"
+							Description="Assembling vertex/pixel shaders"
+							CommandLine="xsasm $(InputPath)"
+							Outputs="$(InputDir)bump.xvu"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="Release|Xbox">
+						<Tool
+							Name="VCCustomBuildTool"
+							Description="Assembling vertex/pixel shaders"
+							CommandLine="xsasm $(InputPath)"
+							Outputs="$(InputDir)bump.xvu"/>
+					</FileConfiguration>
+				</File>
+				<File
+					RelativePath="..\x_shaders\dlight.psh">
+					<FileConfiguration
+						Name="Debug|Xbox">
+						<Tool
+							Name="VCCustomBuildTool"
+							Description="Assembling vertex/pixel shaders"
+							CommandLine="xsasm $(InputPath)"
+							Outputs="$(InputDir)dlight.xpu"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="Release|Xbox">
+						<Tool
+							Name="VCCustomBuildTool"
+							Description="Assembling vertex/pixel shaders"
+							CommandLine="xsasm $(InputPath)"
+							Outputs="$(InputDir)dlight.xpu"/>
+					</FileConfiguration>
+				</File>
+				<File
+					RelativePath="..\x_shaders\dlight.vsh">
+					<FileConfiguration
+						Name="Debug|Xbox">
+						<Tool
+							Name="VCCustomBuildTool"
+							Description="Assembling vertex/pixel shaders"
+							CommandLine="xsasm $(InputPath)"
+							Outputs="$(InputDir)dlight.xvu"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="Release|Xbox">
+						<Tool
+							Name="VCCustomBuildTool"
+							Description="Assembling vertex/pixel shaders"
+							CommandLine="xsasm $(InputPath)"
+							Outputs="$(InputDir)dlight.xvu"/>
+					</FileConfiguration>
+				</File>
+				<File
+					RelativePath="..\x_shaders\environment.vsh">
+					<FileConfiguration
+						Name="Debug|Xbox">
+						<Tool
+							Name="VCCustomBuildTool"
+							Description="Assembling vertex/pixel shaders"
+							CommandLine="xsasm $(InputPath)"
+							Outputs="$(InputDir)environment.xvu"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="Release|Xbox">
+						<Tool
+							Name="VCCustomBuildTool"
+							Description="Assembling vertex/pixel shaders"
+							CommandLine="xsasm $(InputPath)"
+							Outputs="$(InputDir)environment.xvu"/>
+					</FileConfiguration>
+				</File>
+				<File
+					RelativePath="..\x_shaders\extracthot.psh">
+					<FileConfiguration
+						Name="Debug|Xbox">
+						<Tool
+							Name="VCCustomBuildTool"
+							Description="Assembling vertex/pixel shaders"
+							CommandLine="xsasm $(InputPath)"
+							Outputs="$(InputDir)extracthot.xpu"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="Release|Xbox">
+						<Tool
+							Name="VCCustomBuildTool"
+							Description="Assembling vertex/pixel shaders"
+							CommandLine="xsasm $(InputPath)"
+							Outputs="$(InputDir)extracthot.xpu"/>
+					</FileConfiguration>
+				</File>
+				<File
+					RelativePath="..\x_shaders\hotblur.psh">
+					<FileConfiguration
+						Name="Debug|Xbox">
+						<Tool
+							Name="VCCustomBuildTool"
+							Description="Assembling vertex/pixel shaders"
+							CommandLine="xsasm $(InputPath)"
+							Outputs="$(InputDir)hotblur.xpu"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="Release|Xbox">
+						<Tool
+							Name="VCCustomBuildTool"
+							Description="Assembling vertex/pixel shaders"
+							CommandLine="xsasm $(InputPath)"
+							Outputs="$(InputDir)hotblur.xpu"/>
+					</FileConfiguration>
+				</File>
+				<File
+					RelativePath="..\x_shaders\specular_dynamic.psh">
+					<FileConfiguration
+						Name="Debug|Xbox">
+						<Tool
+							Name="VCCustomBuildTool"
+							Description="Assembling vertex/pixel shaders"
+							CommandLine="xsasm $(InputPath)"
+							Outputs="$(InputDir)specular_dynamic.xpu"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="Release|Xbox">
+						<Tool
+							Name="VCCustomBuildTool"
+							Description="Assembling vertex/pixel shaders"
+							CommandLine="xsasm $(InputPath)"
+							Outputs="$(InputDir)specular_dynamic.xpu"/>
+					</FileConfiguration>
+				</File>
+				<File
+					RelativePath="..\x_shaders\specular_dynamic.vsh">
+					<FileConfiguration
+						Name="Debug|Xbox">
+						<Tool
+							Name="VCCustomBuildTool"
+							Description="Assembling vertex/pixel shaders"
+							CommandLine="xsasm $(InputPath)"
+							Outputs="$(InputDir)specular_dynamic.xvu"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="Release|Xbox">
+						<Tool
+							Name="VCCustomBuildTool"
+							Description="Assembling vertex/pixel shaders"
+							CommandLine="xsasm $(InputPath)"
+							Outputs="$(InputDir)specular_dynamic.xvu"/>
+					</FileConfiguration>
+				</File>
+				<File
+					RelativePath="..\x_shaders\specular_static.psh">
+					<FileConfiguration
+						Name="Debug|Xbox">
+						<Tool
+							Name="VCCustomBuildTool"
+							Description="Assembling vertex/pixel shaders"
+							CommandLine="xsasm $(InputPath)"
+							Outputs="$(InputDir)specular_static.xpu"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="Release|Xbox">
+						<Tool
+							Name="VCCustomBuildTool"
+							Description="Assembling vertex/pixel shaders"
+							CommandLine="xsasm $(InputPath)"
+							Outputs="$(InputDir)specular_static.xpu"/>
+					</FileConfiguration>
+				</File>
+				<File
+					RelativePath="..\x_shaders\specular_static.vsh">
+					<FileConfiguration
+						Name="Debug|Xbox">
+						<Tool
+							Name="VCCustomBuildTool"
+							Description="Assembling vertex/pixel shaders"
+							CommandLine="xsasm $(InputPath)"
+							Outputs="$(InputDir)specular_static.xvu"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="Release|Xbox">
+						<Tool
+							Name="VCCustomBuildTool"
+							Description="Assembling vertex/pixel shaders"
+							CommandLine="xsasm $(InputPath)"
+							Outputs="$(InputDir)specular_static.xvu"/>
+					</FileConfiguration>
+				</File>
+			</Filter>
+		</Filter>
+		<Filter
+			Name="UI Source">
+			<File
+				RelativePath="..\ui\ui_atoms.cpp">
+			</File>
+			<File
+				RelativePath="..\ui\ui_connect.cpp">
+			</File>
+			<File
+				RelativePath="..\ui\ui_debug.cpp">
+			</File>
+			<File
+				RelativePath="..\ui\ui_main.cpp">
+			</File>
+			<File
+				RelativePath="..\ui\ui_saber.cpp">
+			</File>
+			<File
+				RelativePath="..\ui\ui_shared.cpp">
+			</File>
+			<File
+				RelativePath="..\ui\ui_splash.cpp">
+			</File>
+			<File
+				RelativePath="..\ui\ui_syscalls.cpp">
+			</File>
+			<Filter
+				Name="UI Headers">
+				<File
+					RelativePath="..\cgame\animtable.h">
+				</File>
+				<File
+					RelativePath="..\game\channels.h">
+				</File>
+				<File
+					RelativePath="..\ui\gameinfo.h">
+				</File>
+				<File
+					RelativePath="..\client\keycodes.h">
+				</File>
+				<File
+					RelativePath="..\ui\menudef.h">
+				</File>
+				<File
+					RelativePath="..\qcommon\qcommon.h">
+				</File>
+				<File
+					RelativePath="..\qcommon\stv_version.h">
+				</File>
+				<File
+					RelativePath="..\game\surfaceflags.h">
+				</File>
+				<File
+					RelativePath="..\ui\ui_local.h">
+				</File>
+				<File
+					RelativePath="..\ui\ui_playerinfo.h">
+				</File>
+				<File
+					RelativePath="..\ui\ui_public.h">
+				</File>
+				<File
+					RelativePath="..\ui\ui_shared.h">
+				</File>
+				<File
+					RelativePath="..\ui\ui_splash.h">
+				</File>
+			</Filter>
+		</Filter>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>
diff --git a/code/x_game/mssccprj.scc b/code/x_game/mssccprj.scc
new file mode 100644
index 0000000..c5430d3
--- /dev/null
+++ b/code/x_game/mssccprj.scc
@@ -0,0 +1,5 @@
+SCC = This is a Source Code Control file
+
+[x_game.vcproj]
+SCC_Aux_Path = "\\ravendata1\vss\central_code"
+SCC_Project_Name = "$/jedi/code/x_game", XUHAAAAA
diff --git a/code/x_game/vssver.scc b/code/x_game/vssver.scc
new file mode 100644
index 0000000..fd18bfa
Binary files /dev/null and b/code/x_game/vssver.scc differ
diff --git a/code/x_game/x_game.vcproj b/code/x_game/x_game.vcproj
new file mode 100644
index 0000000..aab4eaf
--- /dev/null
+++ b/code/x_game/x_game.vcproj
@@ -0,0 +1,1019 @@
+<?xml version="1.0" encoding = "Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="7.00"
+	Name="x_game"
+	ProjectGUID="{E7A12117-F3B0-4C68-9B44-66CEFCA3AEAA}"
+	Keyword="XboxProj">
+	<Platforms>
+		<Platform
+			Name="Xbox"/>
+	</Platforms>
+	<Configurations>
+		<Configuration
+			Name="Debug|Xbox"
+			OutputDirectory=".\..\x_exe\Debug"
+			IntermediateDirectory=".\..\x_exe\Debug\game"
+			ConfigurationType="4"
+			CharacterSet="2">
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				OptimizeForProcessor="2"
+				AdditionalIncludeDirectories="..\ICARUS"
+				PreprocessorDefinitions="_DEBUG;_XBOX;_LIB;WIN32;GAME_HARD_LINKED;VV_LIGHTING"
+				MinimalRebuild="FALSE"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="1"
+				EnableEnhancedInstructionSet="1"
+				UsePrecompiledHeader="0"
+				PrecompiledHeaderThrough="g_headers.h"
+				PrecompiledHeaderFile=".\..\x_exe\Debug\game/game.pch"
+				BrowseInformation="1"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="FALSE"
+				DebugInformationFormat="3"
+				FastCAP="FALSE"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLibrarianTool"
+				OutputFile=".\..\x_exe\Debug\x_game.lib"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+		</Configuration>
+		<Configuration
+			Name="Release|Xbox"
+			OutputDirectory=".\..\x_exe\Release"
+			IntermediateDirectory=".\..\x_exe\Release\game"
+			ConfigurationType="4"
+			CharacterSet="2">
+			<Tool
+				Name="VCCLCompilerTool"
+				AdditionalOptions="/Oy-"
+				Optimization="2"
+				InlineFunctionExpansion="1"
+				OmitFramePointers="FALSE"
+				OptimizeForProcessor="2"
+				AdditionalIncludeDirectories="..\ICARUS"
+				PreprocessorDefinitions="NDEBUG;_XBOX;_LIB;WIN32;GAME_HARD_LINKED"
+				StringPooling="TRUE"
+				RuntimeLibrary="0"
+				BufferSecurityCheck="TRUE"
+				EnableFunctionLevelLinking="TRUE"
+				EnableEnhancedInstructionSet="1"
+				UsePrecompiledHeader="0"
+				PrecompiledHeaderFile="$(OutDir)/$(ProjectName).pch"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="FALSE"
+				DebugInformationFormat="3"
+				FastCAP="FALSE"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLibrarianTool"
+				OutputFile=".\..\x_exe\Release\x_game.lib"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+		</Configuration>
+		<Configuration
+			Name="FinalBuild|Xbox"
+			OutputDirectory=".\..\x_exe\FinalBuild"
+			IntermediateDirectory=".\..\x_exe\FinalBuild\game"
+			ConfigurationType="4"
+			CharacterSet="2">
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="3"
+				GlobalOptimizations="TRUE"
+				InlineFunctionExpansion="2"
+				EnableIntrinsicFunctions="TRUE"
+				FavorSizeOrSpeed="1"
+				OmitFramePointers="TRUE"
+				OptimizeForProcessor="2"
+				AdditionalIncludeDirectories="..\ICARUS"
+				PreprocessorDefinitions="NDEBUG;_XBOX;_LIB;WIN32;GAME_HARD_LINKED;FINAL_BUILD;_FINAL"
+				StringPooling="TRUE"
+				RuntimeLibrary="0"
+				BufferSecurityCheck="TRUE"
+				EnableFunctionLevelLinking="TRUE"
+				EnableEnhancedInstructionSet="1"
+				UsePrecompiledHeader="0"
+				PrecompiledHeaderFile="$(OutDir)/$(ProjectName).pch"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="FALSE"
+				DebugInformationFormat="3"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLibrarianTool"
+				OutputFile=".\..\x_exe\FinalBuild\x_game.lib"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+		</Configuration>
+	</Configurations>
+	<Files>
+		<Filter
+			Name="Source Files">
+			<File
+				RelativePath="..\game\AI_Animal.cpp">
+			</File>
+			<File
+				RelativePath="..\game\AI_AssassinDroid.cpp">
+			</File>
+			<File
+				RelativePath="..\game\AI_Atst.cpp">
+			</File>
+			<File
+				RelativePath="..\game\AI_BobaFett.cpp">
+			</File>
+			<File
+				RelativePath="..\game\AI_Civilian.cpp">
+			</File>
+			<File
+				RelativePath="..\game\AI_Default.cpp">
+			</File>
+			<File
+				RelativePath="..\game\AI_Droid.cpp">
+			</File>
+			<File
+				RelativePath="..\game\AI_GalakMech.cpp">
+			</File>
+			<File
+				RelativePath="..\game\AI_Grenadier.cpp">
+			</File>
+			<File
+				RelativePath="..\game\AI_HazardTrooper.cpp">
+			</File>
+			<File
+				RelativePath="..\game\AI_Howler.cpp">
+			</File>
+			<File
+				RelativePath="..\game\AI_ImperialProbe.cpp">
+			</File>
+			<File
+				RelativePath="..\game\AI_Interrogator.cpp">
+			</File>
+			<File
+				RelativePath="..\game\AI_Jedi.cpp">
+			</File>
+			<File
+				RelativePath="..\game\AI_Mark1.cpp">
+			</File>
+			<File
+				RelativePath="..\game\AI_Mark2.cpp">
+			</File>
+			<File
+				RelativePath="..\game\AI_MineMonster.cpp">
+			</File>
+			<File
+				RelativePath="..\game\AI_Rancor.cpp">
+			</File>
+			<File
+				RelativePath="..\game\AI_Remote.cpp">
+			</File>
+			<File
+				RelativePath="..\game\AI_RocketTrooper.cpp">
+			</File>
+			<File
+				RelativePath="..\game\AI_SaberDroid.cpp">
+			</File>
+			<File
+				RelativePath="..\game\AI_SandCreature.cpp">
+			</File>
+			<File
+				RelativePath="..\game\AI_Seeker.cpp">
+			</File>
+			<File
+				RelativePath="..\game\AI_Sentry.cpp">
+			</File>
+			<File
+				RelativePath="..\game\AI_Sniper.cpp">
+			</File>
+			<File
+				RelativePath="..\game\AI_Stormtrooper.cpp">
+			</File>
+			<File
+				RelativePath="..\game\AI_Tusken.cpp">
+			</File>
+			<File
+				RelativePath="..\game\AI_Utils.cpp">
+			</File>
+			<File
+				RelativePath="..\game\AI_Wampa.cpp">
+			</File>
+			<File
+				RelativePath="..\game\G_Timer.cpp">
+			</File>
+			<File
+				RelativePath="..\game\NPC.cpp">
+			</File>
+			<File
+				RelativePath="..\game\NPC_behavior.cpp">
+			</File>
+			<File
+				RelativePath="..\game\NPC_combat.cpp">
+			</File>
+			<File
+				RelativePath="..\game\NPC_goal.cpp">
+			</File>
+			<File
+				RelativePath="..\game\NPC_misc.cpp">
+			</File>
+			<File
+				RelativePath="..\game\NPC_move.cpp">
+			</File>
+			<File
+				RelativePath="..\game\NPC_reactions.cpp">
+			</File>
+			<File
+				RelativePath="..\game\NPC_senses.cpp">
+			</File>
+			<File
+				RelativePath="..\game\NPC_sounds.cpp">
+			</File>
+			<File
+				RelativePath="..\game\NPC_spawn.cpp">
+			</File>
+			<File
+				RelativePath="..\game\NPC_stats.cpp">
+			</File>
+			<File
+				RelativePath="..\game\NPC_utils.cpp">
+			</File>
+			<File
+				RelativePath="..\game\g_active.cpp">
+			</File>
+			<File
+				RelativePath="..\game\g_breakable.cpp">
+			</File>
+			<File
+				RelativePath="..\game\g_camera.cpp">
+			</File>
+			<File
+				RelativePath="..\game\g_client.cpp">
+			</File>
+			<File
+				RelativePath="..\game\g_cmds.cpp">
+			</File>
+			<File
+				RelativePath="..\game\g_combat.cpp">
+			</File>
+			<File
+				RelativePath="..\game\g_emplaced.cpp">
+			</File>
+			<File
+				RelativePath="..\game\g_functions.cpp">
+			</File>
+			<File
+				RelativePath="..\game\g_fx.cpp">
+			</File>
+			<File
+				RelativePath="..\game\g_headers.cpp">
+			</File>
+			<File
+				RelativePath="..\game\g_inventory.cpp">
+			</File>
+			<File
+				RelativePath="..\game\g_itemLoad.cpp">
+			</File>
+			<File
+				RelativePath="..\game\g_items.cpp">
+			</File>
+			<File
+				RelativePath="..\game\g_main.cpp">
+			</File>
+			<File
+				RelativePath="..\game\g_mem.cpp">
+			</File>
+			<File
+				RelativePath="..\game\g_misc.cpp">
+			</File>
+			<File
+				RelativePath="..\game\g_misc_model.cpp">
+			</File>
+			<File
+				RelativePath="..\game\g_missile.cpp">
+			</File>
+			<File
+				RelativePath="..\game\g_mover.cpp">
+			</File>
+			<File
+				RelativePath="..\game\g_nav.cpp">
+			</File>
+			<File
+				RelativePath="..\game\g_navigator.cpp">
+			</File>
+			<File
+				RelativePath="..\game\g_navnew.cpp">
+			</File>
+			<File
+				RelativePath="..\game\g_object.cpp">
+			</File>
+			<File
+				RelativePath="..\game\g_objectives.cpp">
+			</File>
+			<File
+				RelativePath="..\game\g_rail.cpp">
+			</File>
+			<File
+				RelativePath="..\game\g_ref.cpp">
+			</File>
+			<File
+				RelativePath="..\game\g_roff.cpp">
+			</File>
+			<File
+				RelativePath="..\game\g_savegame.cpp">
+			</File>
+			<File
+				RelativePath="..\game\g_session.cpp">
+			</File>
+			<File
+				RelativePath="..\game\g_spawn.cpp">
+			</File>
+			<File
+				RelativePath="..\game\g_svcmds.cpp">
+			</File>
+			<File
+				RelativePath="..\game\g_target.cpp">
+			</File>
+			<File
+				RelativePath="..\game\g_trigger.cpp">
+			</File>
+			<File
+				RelativePath="..\game\g_turret.cpp">
+			</File>
+			<File
+				RelativePath="..\game\g_usable.cpp">
+			</File>
+			<File
+				RelativePath="..\game\g_utils.cpp">
+			</File>
+			<File
+				RelativePath="..\game\g_weapon.cpp">
+			</File>
+			<File
+				RelativePath="..\game\g_weaponLoad.cpp">
+			</File>
+			<File
+				RelativePath="..\ui\gameinfo.cpp">
+			</File>
+			<File
+				RelativePath="..\game\genericparser2.cpp">
+			</File>
+			<File
+				RelativePath="..\game\q_math.cpp">
+			</File>
+			<File
+				RelativePath="..\game\q_shared.cpp">
+			</File>
+			<File
+				RelativePath="..\qcommon\tri_coll_test.cpp">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						AdditionalIncludeDirectories="../game"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						AdditionalIncludeDirectories="../game"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						AdditionalIncludeDirectories="../game"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\wp_saber.cpp">
+			</File>
+			<File
+				RelativePath="..\game\wp_saberLoad.cpp">
+			</File>
+		</Filter>
+		<Filter
+			Name="Vehicles">
+			<File
+				RelativePath="..\game\AnimalNPC.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\FighterNPC.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\SpeederNPC.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\WalkerNPC.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\bg_vehicleLoad.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\g_vehicles.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="FinalBuild|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\g_vehicles.h">
+			</File>
+		</Filter>
+		<Filter
+			Name="Header Files">
+			<File
+				RelativePath="..\ghoul2\G2.h">
+			</File>
+			<File
+				RelativePath="..\game\ai.h">
+			</File>
+			<File
+				RelativePath="..\game\anims.h">
+			</File>
+			<File
+				RelativePath="..\game\b_local.h">
+			</File>
+			<File
+				RelativePath="..\game\b_public.h">
+			</File>
+			<File
+				RelativePath="..\game\bg_local.h">
+			</File>
+			<File
+				RelativePath="..\game\bg_public.h">
+			</File>
+			<File
+				RelativePath="..\game\bset.h">
+			</File>
+			<File
+				RelativePath="..\game\bstate.h">
+			</File>
+			<File
+				RelativePath="..\cgame\cg_camera.h">
+			</File>
+			<File
+				RelativePath="..\cgame\cg_lights.h">
+			</File>
+			<File
+				RelativePath="..\game\channels.h">
+			</File>
+			<File
+				RelativePath="..\game\common_headers.h">
+			</File>
+			<File
+				RelativePath="..\game\dmstates.h">
+			</File>
+			<File
+				RelativePath="..\game\events.h">
+			</File>
+			<File
+				RelativePath="..\ff\ff.h">
+			</File>
+			<File
+				RelativePath="..\ff\ff_public.h">
+			</File>
+			<File
+				RelativePath="..\client\fffx.h">
+			</File>
+			<File
+				RelativePath="..\game\fields.h">
+			</File>
+			<File
+				RelativePath="..\game\g_functions.h">
+			</File>
+			<File
+				RelativePath="..\game\g_headers.h">
+			</File>
+			<File
+				RelativePath="..\game\g_items.h">
+			</File>
+			<File
+				RelativePath="..\game\g_local.h">
+			</File>
+			<File
+				RelativePath="..\game\g_nav.h">
+			</File>
+			<File
+				RelativePath="..\game\g_navigator.h">
+			</File>
+			<File
+				RelativePath="..\game\g_public.h">
+			</File>
+			<File
+				RelativePath="..\game\g_roff.h">
+			</File>
+			<File
+				RelativePath="..\game\g_shared.h">
+			</File>
+			<File
+				RelativePath="..\ui\gameinfo.h">
+			</File>
+			<File
+				RelativePath="..\game\genericparser2.h">
+			</File>
+			<File
+				RelativePath="..\ghoul2\ghoul2_gore.h">
+			</File>
+			<File
+				RelativePath="..\game\ghoul2_shared.h">
+			</File>
+			<File
+				RelativePath="..\renderer\mdx_format.h">
+			</File>
+			<File
+				RelativePath="..\game\npc_headers.h">
+			</File>
+			<File
+				RelativePath="..\game\objectives.h">
+			</File>
+			<File
+				RelativePath="..\qcommon\platform.h">
+			</File>
+			<File
+				RelativePath="..\game\q_shared.h">
+			</File>
+			<File
+				RelativePath="..\game\say.h">
+			</File>
+			<File
+				RelativePath="..\qcommon\sstring.h">
+			</File>
+			<File
+				RelativePath="..\game\statindex.h">
+			</File>
+			<File
+				RelativePath="..\game\surfaceflags.h">
+			</File>
+			<File
+				RelativePath="..\qcommon\tags.h">
+			</File>
+			<File
+				RelativePath="..\game\teams.h">
+			</File>
+			<File
+				RelativePath="..\qcommon\timing.h">
+			</File>
+			<File
+				RelativePath="..\game\weapons.h">
+			</File>
+			<File
+				RelativePath="..\game\wp_saber.h">
+			</File>
+		</Filter>
+		<Filter
+			Name="ICARUS">
+			<File
+				RelativePath="..\icarus\BlockStream.cpp">
+			</File>
+			<File
+				RelativePath="..\icarus\IcarusImplementation.cpp">
+			</File>
+			<File
+				RelativePath="..\icarus\IcarusImplementation.h">
+			</File>
+			<File
+				RelativePath="..\icarus\IcarusInterface.h">
+			</File>
+			<File
+				RelativePath="..\game\Q3_Interface.cpp">
+			</File>
+			<File
+				RelativePath="..\game\Q3_Interface.h">
+			</File>
+			<File
+				RelativePath="..\icarus\Sequence.cpp">
+			</File>
+			<File
+				RelativePath="..\icarus\Sequencer.cpp">
+			</File>
+			<File
+				RelativePath="..\icarus\StdAfx.h">
+			</File>
+			<File
+				RelativePath="..\icarus\TaskManager.cpp">
+			</File>
+			<File
+				RelativePath="..\icarus\blockstream.h">
+			</File>
+			<File
+				RelativePath="..\icarus\sequence.h">
+			</File>
+			<File
+				RelativePath="..\icarus\sequencer.h">
+			</File>
+			<File
+				RelativePath="..\icarus\taskmanager.h">
+			</File>
+		</Filter>
+		<Filter
+			Name="Cgame">
+			<File
+				RelativePath="..\cgame\FX_ATSTMain.cpp">
+			</File>
+			<File
+				RelativePath="..\cgame\FX_Blaster.cpp">
+			</File>
+			<File
+				RelativePath="..\cgame\FX_Bowcaster.cpp">
+			</File>
+			<File
+				RelativePath="..\cgame\FX_BryarPistol.cpp">
+			</File>
+			<File
+				RelativePath="..\cgame\FX_Concussion.cpp">
+			</File>
+			<File
+				RelativePath="..\cgame\FX_DEMP2.cpp">
+			</File>
+			<File
+				RelativePath="..\cgame\FX_Disruptor.cpp">
+			</File>
+			<File
+				RelativePath="..\cgame\FX_Emplaced.cpp">
+			</File>
+			<File
+				RelativePath="..\cgame\FX_Flechette.cpp">
+			</File>
+			<File
+				RelativePath="..\cgame\FX_HeavyRepeater.cpp">
+			</File>
+			<File
+				RelativePath="..\cgame\FX_NoghriShot.cpp">
+			</File>
+			<File
+				RelativePath="..\cgame\FX_RocketLauncher.cpp">
+			</File>
+			<File
+				RelativePath="..\cgame\FX_TuskenShot.cpp">
+			</File>
+			<File
+				RelativePath="..\cgame\FxParsing.cpp">
+			</File>
+			<File
+				RelativePath="..\cgame\FxPrimitives.cpp">
+			</File>
+			<File
+				RelativePath="..\cgame\FxScheduler.cpp">
+			</File>
+			<File
+				RelativePath="..\cgame\FxSystem.cpp">
+			</File>
+			<File
+				RelativePath="..\cgame\FxTemplate.cpp">
+			</File>
+			<File
+				RelativePath="..\cgame\FxUtil.cpp">
+			</File>
+			<File
+				RelativePath="..\game\bg_misc.cpp">
+			</File>
+			<File
+				RelativePath="..\game\bg_pangles.cpp">
+			</File>
+			<File
+				RelativePath="..\game\bg_panimate.cpp">
+			</File>
+			<File
+				RelativePath="..\game\bg_pmove.cpp">
+			</File>
+			<File
+				RelativePath="..\game\bg_slidemove.cpp">
+			</File>
+			<File
+				RelativePath="..\cgame\cg_camera.cpp">
+			</File>
+			<File
+				RelativePath="..\cgame\cg_consolecmds.cpp">
+			</File>
+			<File
+				RelativePath="..\cgame\cg_credits.cpp">
+			</File>
+			<File
+				RelativePath="..\cgame\cg_draw.cpp">
+			</File>
+			<File
+				RelativePath="..\cgame\cg_drawtools.cpp">
+			</File>
+			<File
+				RelativePath="..\cgame\cg_effects.cpp">
+			</File>
+			<File
+				RelativePath="..\cgame\cg_ents.cpp">
+			</File>
+			<File
+				RelativePath="..\cgame\cg_event.cpp">
+			</File>
+			<File
+				RelativePath="..\cgame\cg_headers.cpp">
+			</File>
+			<File
+				RelativePath="..\cgame\cg_info.cpp">
+			</File>
+			<File
+				RelativePath="..\cgame\cg_lights.cpp">
+			</File>
+			<File
+				RelativePath="..\cgame\cg_localents.cpp">
+			</File>
+			<File
+				RelativePath="..\cgame\cg_main.cpp">
+			</File>
+			<File
+				RelativePath="..\cgame\cg_marks.cpp">
+			</File>
+			<File
+				RelativePath="..\cgame\cg_players.cpp">
+			</File>
+			<File
+				RelativePath="..\cgame\cg_playerstate.cpp">
+			</File>
+			<File
+				RelativePath="..\cgame\cg_predict.cpp">
+			</File>
+			<File
+				RelativePath="..\cgame\cg_scoreboard.cpp">
+			</File>
+			<File
+				RelativePath="..\cgame\cg_servercmds.cpp">
+			</File>
+			<File
+				RelativePath="..\cgame\cg_snapshot.cpp">
+			</File>
+			<File
+				RelativePath="..\cgame\cg_syscalls.cpp">
+			</File>
+			<File
+				RelativePath="..\cgame\cg_text.cpp">
+			</File>
+			<File
+				RelativePath="..\cgame\cg_view.cpp">
+			</File>
+			<File
+				RelativePath="..\cgame\cg_weapons.cpp">
+			</File>
+			<Filter
+				Name="CGame Headers">
+				<File
+					RelativePath="..\cgame\FxParsing.h">
+				</File>
+				<File
+					RelativePath="..\cgame\FxPrimitives.h">
+				</File>
+				<File
+					RelativePath="..\cgame\FxScheduler.h">
+				</File>
+				<File
+					RelativePath="..\cgame\FxSystem.h">
+				</File>
+				<File
+					RelativePath="..\cgame\FxUtil.h">
+				</File>
+				<File
+					RelativePath="..\cgame\animtable.h">
+				</File>
+				<File
+					RelativePath="..\cgame\cg_headers.h">
+				</File>
+				<File
+					RelativePath="..\cgame\cg_local.h">
+				</File>
+				<File
+					RelativePath="..\cgame\cg_media.h">
+				</File>
+				<File
+					RelativePath="..\cgame\cg_public.h">
+				</File>
+				<File
+					RelativePath="..\cgame\common_headers.h">
+				</File>
+				<File
+					RelativePath="..\cgame\strip_objectives.h">
+				</File>
+				<File
+					RelativePath="..\renderer\tr_types.h">
+				</File>
+				<File
+					RelativePath="..\client\vmachine.h">
+				</File>
+			</Filter>
+		</Filter>
+		<Filter
+			Name="Ratl">
+			<File
+				RelativePath="..\ratl\array_vs.h">
+			</File>
+			<File
+				RelativePath="..\ratl\bits_vs.h">
+			</File>
+			<File
+				RelativePath="..\ratl\grid_vs.h">
+			</File>
+			<File
+				RelativePath="..\ratl\handle_pool_vs.h">
+			</File>
+			<File
+				RelativePath="..\ratl\hash_pool_vs.h">
+			</File>
+			<File
+				RelativePath="..\ratl\heap_vs.h">
+			</File>
+			<File
+				RelativePath="..\ratl\list_vs.h">
+			</File>
+			<File
+				RelativePath="..\ratl\map_vs.h">
+			</File>
+			<File
+				RelativePath="..\ratl\pool_vs.h">
+			</File>
+			<File
+				RelativePath="..\ratl\queue_vs.h">
+			</File>
+			<File
+				RelativePath="..\ratl\ratl.cpp">
+			</File>
+			<File
+				RelativePath="..\ratl\ratl_common.h">
+			</File>
+			<File
+				RelativePath="..\ratl\scheduler_vs.h">
+			</File>
+			<File
+				RelativePath="..\ratl\stack_vs.h">
+			</File>
+			<File
+				RelativePath="..\ratl\string_vs.h">
+			</File>
+			<File
+				RelativePath="..\ratl\vector_vs.h">
+			</File>
+		</Filter>
+		<Filter
+			Name="Ragl">
+			<File
+				RelativePath="..\ragl\graph_region.h">
+			</File>
+			<File
+				RelativePath="..\ragl\graph_triangulate.h">
+			</File>
+			<File
+				RelativePath="..\ragl\graph_vs.h">
+			</File>
+			<File
+				RelativePath="..\ragl\kdtree_vs.h">
+			</File>
+			<File
+				RelativePath="..\ragl\ragl_common.h">
+			</File>
+		</Filter>
+		<Filter
+			Name="Ravl">
+			<File
+				RelativePath="..\ravl\CBounds.cpp">
+			</File>
+			<File
+				RelativePath="..\ravl\CBounds.h">
+			</File>
+			<File
+				RelativePath="..\ravl\CMatrix.h">
+			</File>
+			<File
+				RelativePath="..\ravl\CVec.cpp">
+			</File>
+			<File
+				RelativePath="..\ravl\CVec.h">
+			</File>
+		</Filter>
+		<Filter
+			Name="Rufl">
+			<File
+				RelativePath="..\rufl\hstring.cpp">
+			</File>
+			<File
+				RelativePath="..\rufl\hstring.h">
+			</File>
+		</Filter>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>
diff --git a/code/zlib32/deflate.cpp b/code/zlib32/deflate.cpp
new file mode 100644
index 0000000..0301b6a
--- /dev/null
+++ b/code/zlib32/deflate.cpp
@@ -0,0 +1,2078 @@
+#include "../game/q_shared.h"
+#include "../qcommon/qcommon.h"
+
+#include "zip.h"
+#include "deflate.h"
+
+#ifdef _TIMING
+int		totalDeflateTime[Z_MAX_COMPRESSION + 1];
+int		totalDeflateCount[Z_MAX_COMPRESSION + 1];
+#endif
+
+// If you use the zlib library in a product, an acknowledgment is welcome
+// in the documentation of your product. If for some reason you cannot
+// include such an acknowledgment, I would appreciate that you keep this
+// copyright string in the executable of your product.
+const char deflate_copyright[] = "Deflate 1.1.3 Copyright 1995-1998 Jean-loup Gailly ";
+
+static const char *deflate_error = "OK";
+
+//  ALGORITHM
+// 
+//  The "deflation" process depends on being able to identify portions
+//  of the input text which are identical to earlier input (within a
+//  sliding window trailing behind the input currently being processed).
+// 
+//  The most straightforward technique turns out to be the fastest for
+//  most input files: try all possible matches and select the longest.
+//  The key feature of this algorithm is that insertions into the string
+//  dictionary are very simple and thus fast, and deletions are avoided
+//  completely. Insertions are performed at each input character, whereas
+//  string matches are performed only when the previous match ends. So it
+//  is preferable to spend more time in matches to allow very fast string
+//  insertions and avoid deletions. The matching algorithm for small
+//  strings is inspired from that of Rabin & Karp. A brute force approach
+//  is used to find longer strings when a small match has been found.
+//  A similar algorithm is used in comic (by Jan-Mark Wams) and freeze
+//  (by Leonid Broukhis).
+//
+// ACKNOWLEDGEMENTS
+//
+//  The idea of lazy evaluation of matches is due to Jan-Mark Wams, and
+//  I found it in 'freeze' written by Leonid Broukhis.
+//  Thanks to many people for bug reports and testing.
+//
+// REFERENCES
+//
+//  Deutsch, L.P.,"DEFLATE Compressed Data Format Specification".
+//  Available in ftp://ds.internic.net/rfc/rfc1951.txt
+//
+//  A description of the Rabin and Karp algorithm is given in the book
+//     "Algorithms" by R. Sedgewick, Addison-Wesley, p252.
+//
+//  Fiala,E.R., and Greene,D.H.
+//     Data Compression with Finite Windows, Comm.ACM, 32,4 (1989) 490-595
+
+// ===============================================================================
+//  A word is an index in the character window. We use short instead of int to
+//  save space in the various tables. ulong is used only for parameter passing.
+
+//  The static literal tree. Since the bit lengths are imposed, there is no
+//  need for the L_CODES extra codes used during heap construction. However
+//  The codes 286 and 287 are needed to build a canonical tree (see _tr_init
+//  below).
+static const ct_data static_ltree[L_CODES + 2] = 
+{
+	{{  12 }, { 8 }}, {{ 140 }, { 8 }}, {{  76 }, { 8 }}, {{ 204 }, { 8 }}, {{  44 }, { 8 }},
+	{{ 172 }, { 8 }}, {{ 108 }, { 8 }}, {{ 236 }, { 8 }}, {{  28 }, { 8 }}, {{ 156 }, { 8 }},
+	{{  92 }, { 8 }}, {{ 220 }, { 8 }}, {{  60 }, { 8 }}, {{ 188 }, { 8 }}, {{ 124 }, { 8 }},
+	{{ 252 }, { 8 }}, {{   2 }, { 8 }}, {{ 130 }, { 8 }}, {{  66 }, { 8 }}, {{ 194 }, { 8 }},
+	{{  34 }, { 8 }}, {{ 162 }, { 8 }}, {{  98 }, { 8 }}, {{ 226 }, { 8 }}, {{  18 }, { 8 }},
+	{{ 146 }, { 8 }}, {{  82 }, { 8 }}, {{ 210 }, { 8 }}, {{  50 }, { 8 }}, {{ 178 }, { 8 }},
+	{{ 114 }, { 8 }}, {{ 242 }, { 8 }}, {{  10 }, { 8 }}, {{ 138 }, { 8 }}, {{  74 }, { 8 }},
+	{{ 202 }, { 8 }}, {{  42 }, { 8 }}, {{ 170 }, { 8 }}, {{ 106 }, { 8 }}, {{ 234 }, { 8 }},
+	{{  26 }, { 8 }}, {{ 154 }, { 8 }}, {{  90 }, { 8 }}, {{ 218 }, { 8 }}, {{  58 }, { 8 }},
+	{{ 186 }, { 8 }}, {{ 122 }, { 8 }}, {{ 250 }, { 8 }}, {{   6 }, { 8 }}, {{ 134 }, { 8 }},
+	{{  70 }, { 8 }}, {{ 198 }, { 8 }}, {{  38 }, { 8 }}, {{ 166 }, { 8 }}, {{ 102 }, { 8 }},
+	{{ 230 }, { 8 }}, {{  22 }, { 8 }}, {{ 150 }, { 8 }}, {{  86 }, { 8 }}, {{ 214 }, { 8 }},
+	{{  54 }, { 8 }}, {{ 182 }, { 8 }}, {{ 118 }, { 8 }}, {{ 246 }, { 8 }}, {{  14 }, { 8 }},
+	{{ 142 }, { 8 }}, {{  78 }, { 8 }}, {{ 206 }, { 8 }}, {{  46 }, { 8 }}, {{ 174 }, { 8 }},
+	{{ 110 }, { 8 }}, {{ 238 }, { 8 }}, {{  30 }, { 8 }}, {{ 158 }, { 8 }}, {{  94 }, { 8 }},
+	{{ 222 }, { 8 }}, {{  62 }, { 8 }}, {{ 190 }, { 8 }}, {{ 126 }, { 8 }}, {{ 254 }, { 8 }},
+	{{   1 }, { 8 }}, {{ 129 }, { 8 }}, {{  65 }, { 8 }}, {{ 193 }, { 8 }}, {{  33 }, { 8 }},
+	{{ 161 }, { 8 }}, {{  97 }, { 8 }}, {{ 225 }, { 8 }}, {{  17 }, { 8 }}, {{ 145 }, { 8 }},
+	{{  81 }, { 8 }}, {{ 209 }, { 8 }}, {{  49 }, { 8 }}, {{ 177 }, { 8 }}, {{ 113 }, { 8 }},
+	{{ 241 }, { 8 }}, {{   9 }, { 8 }}, {{ 137 }, { 8 }}, {{  73 }, { 8 }}, {{ 201 }, { 8 }},
+	{{  41 }, { 8 }}, {{ 169 }, { 8 }}, {{ 105 }, { 8 }}, {{ 233 }, { 8 }}, {{  25 }, { 8 }},
+	{{ 153 }, { 8 }}, {{  89 }, { 8 }}, {{ 217 }, { 8 }}, {{  57 }, { 8 }}, {{ 185 }, { 8 }},
+	{{ 121 }, { 8 }}, {{ 249 }, { 8 }}, {{   5 }, { 8 }}, {{ 133 }, { 8 }}, {{  69 }, { 8 }},
+	{{ 197 }, { 8 }}, {{  37 }, { 8 }}, {{ 165 }, { 8 }}, {{ 101 }, { 8 }}, {{ 229 }, { 8 }},
+	{{  21 }, { 8 }}, {{ 149 }, { 8 }}, {{  85 }, { 8 }}, {{ 213 }, { 8 }}, {{  53 }, { 8 }},
+	{{ 181 }, { 8 }}, {{ 117 }, { 8 }}, {{ 245 }, { 8 }}, {{  13 }, { 8 }}, {{ 141 }, { 8 }},
+	{{  77 }, { 8 }}, {{ 205 }, { 8 }}, {{  45 }, { 8 }}, {{ 173 }, { 8 }}, {{ 109 }, { 8 }},
+	{{ 237 }, { 8 }}, {{  29 }, { 8 }}, {{ 157 }, { 8 }}, {{  93 }, { 8 }}, {{ 221 }, { 8 }},
+	{{  61 }, { 8 }}, {{ 189 }, { 8 }}, {{ 125 }, { 8 }}, {{ 253 }, { 8 }}, {{  19 }, { 9 }},
+	{{ 275 }, { 9 }}, {{ 147 }, { 9 }}, {{ 403 }, { 9 }}, {{  83 }, { 9 }}, {{ 339 }, { 9 }},
+	{{ 211 }, { 9 }}, {{ 467 }, { 9 }}, {{  51 }, { 9 }}, {{ 307 }, { 9 }}, {{ 179 }, { 9 }},
+	{{ 435 }, { 9 }}, {{ 115 }, { 9 }}, {{ 371 }, { 9 }}, {{ 243 }, { 9 }}, {{ 499 }, { 9 }},
+	{{  11 }, { 9 }}, {{ 267 }, { 9 }}, {{ 139 }, { 9 }}, {{ 395 }, { 9 }}, {{  75 }, { 9 }},
+	{{ 331 }, { 9 }}, {{ 203 }, { 9 }}, {{ 459 }, { 9 }}, {{  43 }, { 9 }}, {{ 299 }, { 9 }},
+	{{ 171 }, { 9 }}, {{ 427 }, { 9 }}, {{ 107 }, { 9 }}, {{ 363 }, { 9 }}, {{ 235 }, { 9 }},
+	{{ 491 }, { 9 }}, {{  27 }, { 9 }}, {{ 283 }, { 9 }}, {{ 155 }, { 9 }}, {{ 411 }, { 9 }},
+	{{  91 }, { 9 }}, {{ 347 }, { 9 }}, {{ 219 }, { 9 }}, {{ 475 }, { 9 }}, {{  59 }, { 9 }},
+	{{ 315 }, { 9 }}, {{ 187 }, { 9 }}, {{ 443 }, { 9 }}, {{ 123 }, { 9 }}, {{ 379 }, { 9 }},
+	{{ 251 }, { 9 }}, {{ 507 }, { 9 }}, {{   7 }, { 9 }}, {{ 263 }, { 9 }}, {{ 135 }, { 9 }},
+	{{ 391 }, { 9 }}, {{  71 }, { 9 }}, {{ 327 }, { 9 }}, {{ 199 }, { 9 }}, {{ 455 }, { 9 }},
+	{{  39 }, { 9 }}, {{ 295 }, { 9 }}, {{ 167 }, { 9 }}, {{ 423 }, { 9 }}, {{ 103 }, { 9 }},
+	{{ 359 }, { 9 }}, {{ 231 }, { 9 }}, {{ 487 }, { 9 }}, {{  23 }, { 9 }}, {{ 279 }, { 9 }},
+	{{ 151 }, { 9 }}, {{ 407 }, { 9 }}, {{  87 }, { 9 }}, {{ 343 }, { 9 }}, {{ 215 }, { 9 }},
+	{{ 471 }, { 9 }}, {{  55 }, { 9 }}, {{ 311 }, { 9 }}, {{ 183 }, { 9 }}, {{ 439 }, { 9 }},
+	{{ 119 }, { 9 }}, {{ 375 }, { 9 }}, {{ 247 }, { 9 }}, {{ 503 }, { 9 }}, {{  15 }, { 9 }},
+	{{ 271 }, { 9 }}, {{ 143 }, { 9 }}, {{ 399 }, { 9 }}, {{  79 }, { 9 }}, {{ 335 }, { 9 }},
+	{{ 207 }, { 9 }}, {{ 463 }, { 9 }}, {{  47 }, { 9 }}, {{ 303 }, { 9 }}, {{ 175 }, { 9 }},
+	{{ 431 }, { 9 }}, {{ 111 }, { 9 }}, {{ 367 }, { 9 }}, {{ 239 }, { 9 }}, {{ 495 }, { 9 }},
+	{{  31 }, { 9 }}, {{ 287 }, { 9 }}, {{ 159 }, { 9 }}, {{ 415 }, { 9 }}, {{  95 }, { 9 }},
+	{{ 351 }, { 9 }}, {{ 223 }, { 9 }}, {{ 479 }, { 9 }}, {{  63 }, { 9 }}, {{ 319 }, { 9 }},
+	{{ 191 }, { 9 }}, {{ 447 }, { 9 }}, {{ 127 }, { 9 }}, {{ 383 }, { 9 }}, {{ 255 }, { 9 }},
+	{{ 511 }, { 9 }}, {{   0 }, { 7 }}, {{  64 }, { 7 }}, {{  32 }, { 7 }}, {{  96 }, { 7 }},
+	{{  16 }, { 7 }}, {{  80 }, { 7 }}, {{  48 }, { 7 }}, {{ 112 }, { 7 }}, {{   8 }, { 7 }},
+	{{  72 }, { 7 }}, {{  40 }, { 7 }}, {{ 104 }, { 7 }}, {{  24 }, { 7 }}, {{  88 }, { 7 }},
+	{{  56 }, { 7 }}, {{ 120 }, { 7 }}, {{   4 }, { 7 }}, {{  68 }, { 7 }}, {{  36 }, { 7 }},
+	{{ 100 }, { 7 }}, {{  20 }, { 7 }}, {{  84 }, { 7 }}, {{  52 }, { 7 }}, {{ 116 }, { 7 }},
+	{{   3 }, { 8 }}, {{ 131 }, { 8 }}, {{  67 }, { 8 }}, {{ 195 }, { 8 }}, {{  35 }, { 8 }},
+	{{ 163 }, { 8 }}, {{  99 }, { 8 }}, {{ 227 }, { 8 }}	 	 	    	   	   		  
+};
+
+// The static distance tree. (Actually a trivial tree since all codes use 5 bits.)
+static const ct_data static_dtree[D_CODES] = 
+{
+	{{  0 }, { 5 }}, {{ 16 }, { 5 }}, {{  8 },{ 5 }}, {{ 24 },{ 5 }}, {{  4 },{ 5 }},
+	{{ 20 }, { 5 }}, {{ 12 }, { 5 }}, {{ 28 },{ 5 }}, {{  2 },{ 5 }}, {{ 18 },{ 5 }},
+	{{ 10 }, { 5 }}, {{ 26 }, { 5 }}, {{  6 },{ 5 }}, {{ 22 },{ 5 }}, {{ 14 },{ 5 }},
+	{{ 30 }, { 5 }}, {{  1 }, { 5 }}, {{ 17 },{ 5 }}, {{  9 },{ 5 }}, {{ 25 },{ 5 }},
+	{{  5 }, { 5 }}, {{ 21 }, { 5 }}, {{ 13 },{ 5 }}, {{ 29 },{ 5 }}, {{  3 },{ 5 }},
+	{{ 19 }, { 5 }}, {{ 11 }, { 5 }}, {{ 27 },{ 5 }}, {{  7 },{ 5 }}, {{ 23 },{ 5 }}
+};
+
+// Distance codes. The first 256 values correspond to the distances
+// 3 .. 258, the last 256 values correspond to the top 8 bits of
+// the 15 bit distances.
+static const byte tr_dist_code[DIST_CODE_LEN] = 
+{
+	 0,  1,  2,  3,  4,  4,  5,  5,  6,  6,  6,  6,  7,  7,  7,  7,  8,  8,  8,  8,
+	 8,  8,  8,  8,  9,  9,  9,  9,  9,  9,  9,  9, 10, 10, 10, 10, 10, 10, 10, 10,
+	10, 10, 10, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+	11, 11, 11, 11, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+	12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 13, 13, 13, 13,
+	13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+	13, 13, 13, 13, 13, 13, 13, 13, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+	14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+	14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+	14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 15, 15, 15, 15, 15, 15, 15, 15,
+	15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+	15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+	15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,  0,  0, 16, 17,
+	18, 18, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 22, 22, 22, 22, 22, 22, 22, 22,
+	23, 23, 23, 23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
+	24, 24, 24, 24, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
+	26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
+	26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 27,
+	27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
+	27, 27, 27, 27, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
+	28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
+	28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
+	28, 28, 28, 28, 28, 28, 28, 28, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+	29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+	29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+	29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29
+};
+
+// length code for each normalized match length (0 == MIN_MATCH)
+static const byte tr_length_code[MAX_MATCH - MIN_MATCH + 1] = 
+{
+	 0,  1,  2,  3,  4,  5,  6,  7,  8,  8,  9,  9, 10, 10, 11, 11, 12, 12, 12, 12,
+	13, 13, 13, 13, 14, 14, 14, 14, 15, 15, 15, 15, 16, 16, 16, 16, 16, 16, 16, 16,
+	17, 17, 17, 17, 17, 17, 17, 17, 18, 18, 18, 18, 18, 18, 18, 18, 19, 19, 19, 19,
+	19, 19, 19, 19, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20,
+	21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 22, 22, 22, 22,
+	22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 23, 23, 23, 23, 23, 23, 23, 23,
+	23, 23, 23, 23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
+	24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
+	25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
+	25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 26, 26, 26, 26, 26, 26, 26, 26,
+	26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
+	26, 26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
+	27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 28
+};
+
+// First normalized length for each code (0 = MIN_MATCH)
+static const int base_length[LENGTH_CODES] = 
+{
+	0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 12, 14, 16, 20, 24, 28, 32, 40, 48, 56,
+	64, 80, 96, 112, 128, 160, 192, 224, 0
+};
+
+// First normalized distance for each code (0 = distance of 1)
+static const int base_dist[D_CODES] = 
+{
+    0,     1,     2,     3,     4,     6,     8,    12,    16,    24,
+   32,    48,    64,    96,   128,   192,   256,   384,   512,   768,
+ 1024,  1536,  2048,  3072,  4096,  6144,  8192, 12288, 16384, 24576
+};
+
+// Note: the deflate() code requires max_lazy >= MIN_MATCH and max_chain >= 4
+// For deflate_fast() (levels <= 3) good is ignored and lazy has a different
+// meaning.
+static block_state deflate_stored(deflate_state *s, EFlush flush);
+static block_state deflate_fast(deflate_state *s, EFlush flush);
+static block_state deflate_slow(deflate_state *s, EFlush flush);
+
+// Values for max_lazy_match, good_match and max_chain_length, depending on
+// the desired pack level (0..9). The values given below have been tuned to
+// exclude worst case performance for pathological files. Better values may be
+// found for specific files.
+static const config configuration_table[10] = 
+{
+  // good lazy nice chain
+	{ 0,    0,   0,    0, deflate_stored },		// store only
+
+	{ 4,    4,   8,    4, deflate_fast },		// maximum speed, no lazy matches
+	{ 4,    5,  16,    8, deflate_fast },
+	{ 4,    6,  32,   32, deflate_fast },
+		  
+	{ 4,    4,  16,   16, deflate_slow },		// lazy matches
+	{ 8,   16,  32,   32, deflate_slow },
+	{ 8,   16, 128,  128, deflate_slow },
+	{ 8,   32, 128,  256, deflate_slow },
+	{ 32, 128, 258, 1024, deflate_slow },
+	{ 32, 258, 258, 4096, deflate_slow }		// maximum compression
+}; 
+
+// extra bits for each length code
+static ulong extra_lbits[LENGTH_CODES] = 
+{
+	0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0
+};
+
+// Extra bits for distance codes
+const ulong extra_dbits[D_CODES] = 
+{ 
+	0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6,	7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13
+};
+
+// extra bits for each bit length code
+static ulong extra_blbits[BL_CODES] = 
+{
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3, 7
+};
+
+// The lengths of the bit length codes are sent in order of decreasing
+// probability, to avoid transmitting the lengths for unused bit length codes.
+static const byte bl_order[BL_CODES] = 
+{
+	16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15
+};
+
+static static_tree_desc static_l_desc = 
+{
+	static_ltree, extra_lbits, LITERALS + 1, L_CODES, MAX_WBITS
+};
+
+static static_tree_desc static_d_desc = 
+{
+	static_dtree, extra_dbits, 0, D_CODES, MAX_WBITS
+};
+
+static static_tree_desc static_bl_desc = 
+{
+	NULL, extra_blbits, 0, BL_CODES, MAX_BL_BITS
+};
+
+// ===============================================================================
+// Output bytes to the output stream. Inlined for speed
+// ===============================================================================
+
+inline void put_byte(deflate_state *s, const byte c)
+{
+	s->pending_buf[s->pending++] = c;
+}
+
+// Fixme: write as 1 short
+inline void put_short(deflate_state *s, const word w)
+{
+	s->pending_buf[s->pending++] = (byte)(w & 0xff);
+	s->pending_buf[s->pending++] = (byte)(w >> 8);
+}
+
+inline void put_shortMSB(deflate_state *s, const word w)
+{
+	s->pending_buf[s->pending++] = (byte)(w >> 8);
+	s->pending_buf[s->pending++] = (byte)(w & 0xff);
+}   
+
+inline void put_longMSB(deflate_state *s, const ulong l)
+{
+    s->pending_buf[s->pending++] = (byte)(l >> 24);
+    s->pending_buf[s->pending++] = (byte)(l >> 16);
+    s->pending_buf[s->pending++] = (byte)(l >> 8);
+    s->pending_buf[s->pending++] = (byte)(l & 0xff);
+}   
+
+// ===============================================================================
+// Send a value on a given number of bits.
+// IN assertion: length <= 16 and value fits in length bits.
+// ===============================================================================
+
+static void send_bits(deflate_state *s, const ulong val, const ulong len)
+{
+	assert(len <= 16);
+	assert(val <= 65536);
+
+	if(s->bi_valid > (BUF_SIZE - len)) 
+	{
+		s->bi_buf |= val << s->bi_valid;
+		put_short(s, s->bi_buf);
+		s->bi_buf = (word)(val >> (BUF_SIZE - s->bi_valid));
+		s->bi_valid += len - BUF_SIZE;
+	}
+	else
+	{
+		s->bi_buf |= val << s->bi_valid;
+		s->bi_valid += len;
+	}
+}
+
+// ===============================================================================
+// Initialize a new block.
+// ===============================================================================
+
+static void init_block(deflate_state *s)
+{
+    int		n;						// iterates over tree elements
+
+    // Initialize the trees.
+    for(n = 0; n < L_CODES;  n++) 
+	{
+		s->dyn_ltree[n].fc.freq = 0;
+	}
+    for(n = 0; n < D_CODES;  n++) 
+	{
+		s->dyn_dtree[n].fc.freq = 0;
+	}
+    for(n = 0; n < BL_CODES; n++) 
+	{
+		s->bl_tree[n].fc.freq = 0;
+	}
+    s->dyn_ltree[END_BLOCK].fc.freq = 1;
+    s->opt_len = 0;
+	s->static_len = 0;
+    s->last_lit = 0;
+	s->matches = 0;
+}
+
+// ===============================================================================
+// Initialize the tree data structures for a new zlib stream.
+// ===============================================================================
+
+static void tr_init(deflate_state *s)
+{
+    s->l_desc.dyn_tree = s->dyn_ltree;
+    s->l_desc.stat_desc = &static_l_desc;
+
+    s->d_desc.dyn_tree = s->dyn_dtree;
+    s->d_desc.stat_desc = &static_d_desc;
+
+    s->bl_desc.dyn_tree = s->bl_tree;
+    s->bl_desc.stat_desc = &static_bl_desc;
+
+    s->bi_buf = 0;
+    s->bi_valid = 0;
+	// enough lookahead for inflate
+    s->last_eob_len = 8; 
+
+    // Initialize the first block of the first file:
+    init_block(s);
+}
+
+// ===============================================================================
+// Compares to subtrees, using the tree depth as tie breaker when
+// the subtrees have equal frequency. This minimizes the worst case length.
+// ===============================================================================
+
+static bool smaller(ct_data *tree, ulong son, ulong daughter, byte *depth)
+{
+	if(tree[son].fc.freq < tree[daughter].fc.freq)
+	{
+		return(true);
+	}
+	if((tree[son].fc.freq == tree[daughter].fc.freq) && (depth[son] <= depth[daughter]))
+	{
+		return(true);
+	}
+	return(false);
+}
+
+// ===============================================================================
+// Restore the heap property by moving down the tree starting at node k,
+// exchanging a node with the smallest of its two sons if necessary, stopping
+// when the heap property is re-established (each father smaller than its
+// two sons).
+// ===============================================================================
+
+static void pqdownheap(deflate_state *s, ct_data *tree, ulong node)
+{
+    ulong	base; 
+    ulong	sibling;				// left son of node
+
+	base = s->heap[node];
+	sibling = node << 1;
+
+    while(sibling <= s->heap_len) 
+	{
+        // Set sibling to the smallest of the two children
+        if((sibling < s->heap_len) && smaller(tree, s->heap[sibling + 1], s->heap[sibling], s->depth)) 
+		{
+            sibling++;
+        }
+        // Exit if base is smaller than both sons
+        if(smaller(tree, base, s->heap[sibling], s->depth)) 
+		{
+			break;
+		}
+        // Exchange base with the smallest son
+        s->heap[node] = s->heap[sibling];  
+		node = sibling;
+
+        // And continue down the tree, setting sibling to the left son of base
+        sibling <<= 1;
+    }
+    s->heap[node] = base;
+}
+
+// ===============================================================================
+// Compute the optimal bit lengths for a tree and update the total bit length
+// for the current block.
+// IN assertion: the fields freq and dad are set, heap[heap_max] and
+//    above are the tree nodes sorted by increasing frequency.
+// OUT assertions: the field len is set to the optimal bit length, the
+//     array bl_count contains the frequencies for each bit length.
+//     The length opt_len is updated; static_len is also updated if stree is
+//     not null.
+// ===============================================================================
+
+static void gen_bitlen(deflate_state *s, tree_desc *desc)
+{
+    const ct_data	*stree;
+    const ulong		*extra;
+    ulong			base;
+    ulong			max_length;
+    ulong			heapIdx;		// heap index
+    ulong			n, m;			// iterate over the tree elements
+    ulong			bits;			// bit length
+    ulong			xbits;			// extra bits
+    word			freq;			// frequency
+    ulong			overflow;		// number of elements with bit length too large
+
+    stree = desc->stat_desc->static_tree;
+    extra = desc->stat_desc->extra_bits;
+    base = desc->stat_desc->extra_base;
+    max_length = desc->stat_desc->max_length;
+	overflow = 0;
+
+    for(bits = 0; bits <= MAX_WBITS; bits++) 
+	{
+		s->bl_count[bits] = 0;
+	}
+
+    // In a first pass, compute the optimal bit lengths (which may
+    // overflow in the case of the bit length tree).
+	// root of the heap
+    desc->dyn_tree[s->heap[s->heap_max]].dl.len = 0;
+
+    for(heapIdx = s->heap_max + 1; heapIdx < HEAP_SIZE; heapIdx++) 
+	{
+        n = s->heap[heapIdx];
+        bits = desc->dyn_tree[desc->dyn_tree[n].dl.dad].dl.len + 1;
+        if(bits > max_length)
+		{
+			bits = max_length;
+			overflow++;
+		}
+        // We overwrite tree[n].dl.dad which is no longer needed
+        desc->dyn_tree[n].dl.len = (word)bits;
+
+		// not a leaf node
+        if(n > desc->max_code) 
+		{
+			continue; 
+		}
+
+        s->bl_count[bits]++;
+        xbits = 0;
+        if(n >= base) 
+		{
+			xbits = extra[n - base];
+		}
+        freq = desc->dyn_tree[n].fc.freq;
+        s->opt_len += freq * (bits + xbits);
+        if(stree) 
+		{
+			s->static_len += freq * (stree[n].dl.len + xbits);
+		}
+    }
+    if(!overflow) 
+	{
+		return;
+	}
+
+    // Find the first bit length which could increase
+    do 
+	{
+        bits = max_length - 1;
+        while(!s->bl_count[bits]) 
+		{
+			bits--;
+		}
+		// move one leaf down the tree
+        s->bl_count[bits]--;      
+		// move one overflow item as its brother
+        s->bl_count[bits + 1] += 2;
+        // The brother of the overflow item also moves one step up,
+        // but this does not affect bl_count[max_length]
+        s->bl_count[max_length]--;
+        overflow -= 2;
+    } 
+	while(overflow > 0);
+
+    // Now recompute all bit lengths, scanning in increasing frequency.
+    // heapIdx is still equal to HEAP_SIZE. (It is simpler to reconstruct all
+    // lengths instead of fixing only the wrong ones. This idea is taken
+    // from 'ar' written by Haruhiko Okumura.)
+    for(bits = max_length; bits; bits--) 
+	{
+        n = s->bl_count[bits];
+        while(n) 
+		{
+            m = s->heap[--heapIdx];
+            if(m > desc->max_code) 
+			{
+				continue;
+			}
+            if(desc->dyn_tree[m].dl.len != bits) 
+			{
+                s->opt_len += (bits - desc->dyn_tree[m].dl.len) * desc->dyn_tree[m].fc.freq;
+                desc->dyn_tree[m].dl.len = (word)bits;
+            }
+            n--;
+        }
+    }
+}
+
+// ===============================================================================
+// Flush the bit buffer and align the output on a byte boundary
+// ===============================================================================
+
+static void bi_windup(deflate_state *s)
+{
+    if(s->bi_valid > 8) 
+	{
+        put_short(s, s->bi_buf);
+    } 
+	else if(s->bi_valid > 0) 
+	{
+        put_byte(s, (byte)s->bi_buf);
+    }
+    s->bi_buf = 0;
+    s->bi_valid = 0;
+}
+
+// ===============================================================================
+// Reverse the first len bits of a code, using straightforward code (a faster
+// method would use a table)
+// ===============================================================================
+
+static ulong bi_reverse(ulong code, ulong len)
+{
+    ulong	res;
+
+	assert(1 <= len);
+	assert(len <= 15);
+
+    res = 0;
+    do 
+	{
+        res |= code & 1;
+        code >>= 1;
+		res <<= 1;
+    } 
+	while(--len > 0);
+
+    return(res >> 1);
+}
+
+// ===============================================================================
+// Generate the codes for a given tree and bit counts (which need not be optimal).
+// IN assertion: the array bl_count contains the bit length statistics for
+// the given tree and the field len is set for all tree elements.
+// OUT assertion: the field code is set for all tree elements of non zero code length.
+// ===============================================================================
+
+static void gen_codes(ct_data *tree, ulong max_code, word *bl_count)
+{
+    word	next_code[MAX_WBITS + 1];	// next code value for each bit length
+    word	code;						// running code value
+    ulong	bits;						// bit index
+    ulong	codes;						// code index
+	ulong	len;
+
+    // The distribution counts are first used to generate the code values
+    // without bit reversal.
+	code = 0;
+    for(bits = 1; bits <= MAX_WBITS; bits++) 
+	{
+		code = (word)((code + bl_count[bits - 1]) << 1);
+        next_code[bits] = code;
+    }
+
+    // Check that the bit counts in bl_count are consistent. The last code
+    // must be all ones.
+    for(codes = 0; codes <= max_code; codes++) 
+	{
+        len = tree[codes].dl.len;
+
+        if(!len) 
+		{
+			continue;
+		}
+        // Now reverse the bits
+        tree[codes].fc.code = (word)bi_reverse(next_code[len]++, len);
+    }
+}
+
+// ===============================================================================
+// Construct one Huffman tree and assigns the code bit strings and lengths.
+// Update the total bit length for the current block.
+// IN assertion: the field freq is set for all tree elements.
+// OUT assertions: the fields len and code are set to the optimal bit length
+//     and corresponding code. The length opt_len is updated; static_len is
+//     also updated if stree is not null. The field max_code is set.
+// ===============================================================================
+
+static void build_tree(deflate_state *s, tree_desc *desc)
+{
+    ct_data			*tree;
+    const ct_data	*stree;
+    ulong			elems;
+    ulong			n, m;	 		// iterate over heap elements
+    ulong			max_code;		// largest code with non zero frequency
+    ulong			node;			// new node being created
+
+    tree = desc->dyn_tree;
+    stree = desc->stat_desc->static_tree;
+    elems = desc->stat_desc->elems;
+	max_code = 0;
+
+    // Construct the initial heap, with least frequent element in
+    // heap[SMALLEST]. The sons of heap[n] are heap[2*n] and heap[2*n+1].
+    // heap[0] is not used.
+    s->heap_len = 0;
+	s->heap_max = HEAP_SIZE;
+
+    for(n = 0; n < elems; n++) 
+	{
+        if(tree[n].fc.freq) 
+		{
+			max_code = n;
+            s->heap[++s->heap_len] = n;
+            s->depth[n] = 0;
+        } 
+		else 
+		{
+            tree[n].dl.len = 0;
+        }
+    }
+
+    // The pkzip format requires that at least one distance code exists,
+    // and that at least one bit should be sent even if there is only one
+    // possible code. So to avoid special checks later on we force at least
+    // two codes of non zero frequency.
+    while(s->heap_len < 2) 
+	{
+		s->heap[++s->heap_len] = (max_code < 2 ? ++max_code : 0);
+        node = s->heap[s->heap_len];
+        tree[node].fc.freq = 1;
+        s->depth[node] = 0;
+        s->opt_len--; 
+		if(stree) 
+		{
+			s->static_len -= stree[node].dl.len;
+		}
+        // node is 0 or 1 so it does not have extra bits
+    }
+    desc->max_code = max_code;
+
+    // The elements heap[heap_len/2+1 .. heap_len] are leaves of the tree,
+    // establish sub-heaps of increasing lengths:
+    for(n = s->heap_len >> 1; n >= 1; n--) 
+	{
+		pqdownheap(s, tree, n);
+	}
+
+    // Construct the Huffman tree by repeatedly combining the least two
+    // frequent nodes.
+
+	// next internal node of the tree
+    node = elems;              
+    do 
+	{
+	    n = s->heap[SMALLEST];
+		s->heap[SMALLEST] = s->heap[s->heap_len--];
+		pqdownheap(s, tree, SMALLEST);
+        m = s->heap[SMALLEST];						// m = node of next least frequency
+
+        s->heap[--s->heap_max] = n;					// keep the nodes sorted by frequency
+        s->heap[--s->heap_max] = m;
+
+        // Create a new node father of n and m
+        tree[node].fc.freq = (word)(tree[n].fc.freq + tree[m].fc.freq);
+		if(s->depth[n] > s->depth[m])
+		{
+			s->depth[node] = s->depth[n];
+		}
+		else
+		{
+			s->depth[node] = s->depth[m];
+			s->depth[node]++;
+		}
+		tree[m].dl.dad = (word)node;
+        tree[n].dl.dad = (word)node;
+
+        // and insert the new node in the heap
+        s->heap[SMALLEST] = node++;
+        pqdownheap(s, tree, SMALLEST);
+    } 
+	while(s->heap_len >= 2);
+
+    s->heap[--s->heap_max] = s->heap[SMALLEST];
+
+    // At this point, the fields freq and dad are set. We can now
+    // generate the bit lengths.
+    gen_bitlen(s, desc);
+
+    // The field len is now set, we can generate the bit codes
+    gen_codes (tree, max_code, s->bl_count);
+}
+
+// ===============================================================================
+// Scan a literal or distance tree to determine the frequencies of the codes
+// in the bit length tree.
+// ===============================================================================
+
+static void scan_tree (deflate_state *s, ct_data *tree, ulong max_code)
+{
+    ulong 	n;						// iterates over all tree elements
+    ulong	prevlen;				// last emitted length
+    ulong	curlen;					// length of current code
+    ulong	nextlen;				// length of next code
+    ulong	count;					// repeat count of the current code
+    ulong	max_count;				// max repeat count
+    ulong	min_count;				// min repeat count
+
+    prevlen = 0xffff;
+    nextlen = tree[0].dl.len;
+    count = 0;
+    max_count = 7;
+    min_count = 4;
+
+    if(!nextlen) 
+	{
+		max_count = 138;
+		min_count = 3;
+	}
+	// guard
+    tree[max_code + 1].dl.len = (word)prevlen; 
+
+    for(n = 0; n <= max_code; n++) 
+	{
+        curlen = nextlen; 
+		nextlen = tree[n + 1].dl.len;
+        if((++count < max_count) && (curlen == nextlen)) 
+		{
+            continue;
+        }
+		else if(count < min_count) 
+		{
+            s->bl_tree[curlen].fc.freq += (word)count;
+        } 
+		else if(curlen) 
+		{
+            if(curlen != prevlen) 
+			{
+				s->bl_tree[curlen].fc.freq++;
+			}
+            s->bl_tree[REP_3_6].fc.freq++;
+        } 
+		else if(count <= 10) 
+		{
+            s->bl_tree[REPZ_3_10].fc.freq++;
+        } 
+		else 
+		{
+            s->bl_tree[REPZ_11_138].fc.freq++;
+        }
+        count = 0; 
+		prevlen = curlen;
+        if(!nextlen) 
+		{
+            max_count = 138;
+			min_count = 3;
+        } 
+		else if(curlen == nextlen) 
+		{
+            max_count = 6;
+			min_count = 3;
+        } 
+		else 
+		{
+            max_count = 7;
+			min_count = 4;
+        }
+    }
+}
+
+// ===============================================================================
+// Send a literal or distance tree in compressed form, using the codes in bl_tree.
+// ===============================================================================
+
+static void send_tree(deflate_state *s, ct_data *tree, ulong max_code)
+{
+    ulong	n;						// iterates over all tree elements
+    ulong	prevlen;				// last emitted length
+    ulong	curlen;					// length of current code
+    ulong	nextlen;				// length of next code
+    ulong	count;					// repeat count of the current code
+    ulong	max_count;				// max repeat count
+    ulong	min_count;				// min repeat count
+
+    prevlen = 0xffff;
+    nextlen = tree[0].dl.len;
+    count = 0;
+    max_count = 7;
+    min_count = 4;
+
+    if(!nextlen)
+	{
+		max_count = 138;
+		min_count = 3;
+	}
+
+    for(n = 0; n <= max_code; n++) 
+	{
+        curlen = nextlen; 
+		nextlen = tree[n + 1].dl.len;
+        if((++count < max_count) && (curlen == nextlen))
+		{
+            continue;
+        } 
+		else if(count < min_count) 
+		{
+            do 
+			{ 
+				send_bits(s, s->bl_tree[curlen].fc.code, s->bl_tree[curlen].dl.len);
+			} 
+			while(--count);
+
+        } 
+		else if(curlen) 
+		{
+            if(curlen != prevlen) 
+			{
+				send_bits(s, s->bl_tree[curlen].fc.code, s->bl_tree[curlen].dl.len);
+				count--;
+            }
+			send_bits(s, s->bl_tree[REP_3_6].fc.code, s->bl_tree[REP_3_6].dl.len);
+			send_bits(s, count - 3, 2);
+
+        } 
+		else if(count <= 10) 
+		{
+			send_bits(s, s->bl_tree[REPZ_3_10].fc.code, s->bl_tree[REPZ_3_10].dl.len);
+			send_bits(s, count - 3, 3);
+
+        } 
+		else 
+		{
+			send_bits(s, s->bl_tree[REPZ_11_138].fc.code, s->bl_tree[REPZ_11_138].dl.len);
+			send_bits(s, count - 11, 7);
+        }
+        count = 0; 
+		prevlen = curlen;
+        if(!nextlen) 
+		{
+            max_count = 138;
+			min_count = 3;
+        } 
+		else if(curlen == nextlen) 
+		{
+            max_count = 6;
+			min_count = 3;
+        } 
+		else 
+		{
+            max_count = 7;
+			min_count = 4;
+        }
+    }
+}
+
+// ===============================================================================
+// Construct the Huffman tree for the bit lengths and return the index in
+// bl_order of the last bit length code to send.
+// ===============================================================================
+
+static ulong build_bl_tree(deflate_state *s)
+{
+    ulong	max_blindex;			// index of last bit length code of non zero freq
+
+    // Determine the bit length frequencies for literal and distance trees
+    scan_tree(s, s->dyn_ltree, s->l_desc.max_code);
+    scan_tree(s, s->dyn_dtree, s->d_desc.max_code);
+
+    // Build the bit length tree
+    build_tree(s, &s->bl_desc);
+    // opt_len now includes the length of the tree representations, except
+    // the lengths of the bit lengths codes and the 5+5+4 bits for the counts.
+
+    // Determine the number of bit length codes to send. The pkzip format
+    // requires that at least 4 bit length codes be sent. (appnote.txt says
+    // 3 but the actual value used is 4.)
+    for(max_blindex = BL_CODES - 1; max_blindex >= 3; max_blindex--) 
+	{
+        if(s->bl_tree[bl_order[max_blindex]].dl.len)
+		{
+			break;
+		}
+    }
+    // Update opt_len to include the bit length tree and counts
+    s->opt_len += 3 * (max_blindex + 1) + 5 + 5 + 4;
+    return(max_blindex);
+}
+
+// ===========================================================================
+// Send the header for a block using dynamic Huffman trees: the counts, the
+// lengths of the bit length codes, the literal tree and the distance tree.
+// IN assertion: lcodes >= 257, dcodes >= 1, blcodes >= 4.
+// ===========================================================================
+
+static void send_all_trees(deflate_state *s, ulong lcodes, ulong dcodes, ulong blcodes)
+{
+    ulong	rank;				// index in bl_order
+
+	// not +255 as stated in appnote.txt
+    send_bits(s, lcodes - 257, 5); 
+    send_bits(s, dcodes - 1, 5);
+	// not -3 as stated in appnote.txt
+    send_bits(s, blcodes - 4, 4); 
+
+    for(rank = 0; rank < blcodes; rank++) 
+	{
+        send_bits(s, s->bl_tree[bl_order[rank]].dl.len, 3);
+    }
+
+	// literal tree
+    send_tree(s, (ct_data *)s->dyn_ltree, lcodes - 1); 
+	// distance tree
+    send_tree(s, (ct_data *)s->dyn_dtree, dcodes - 1); 
+}
+
+// ===========================================================================
+// Send the block data compressed using the given Huffman trees
+// ===========================================================================
+
+static void compress_block(deflate_state *s, const ct_data *ltree, const ct_data *dtree)
+{
+    ulong	dist;					// distance of matched string
+    ulong	lenCount;				// match length or unmatched char (if dist == 0)
+    ulong	lenIdx;					// running index in l_buf
+    ulong	code;					// the code to send
+    ulong	extra;					// number of extra bits to send
+
+	lenIdx = 0;
+    if(s->last_lit) 
+	{
+		do 
+		{
+			dist = s->d_buf[lenIdx];
+			lenCount = s->l_buf[lenIdx++];
+			if(!dist) 
+			{
+				// send a literal byte
+				send_bits(s, ltree[lenCount].fc.code, ltree[lenCount].dl.len);
+			} 
+			else 
+			{
+				// Here, lenCount is the match length - MIN_MATCH
+				code = tr_length_code[lenCount];
+				// send the length code
+				send_bits(s, ltree[code + LITERALS + 1].fc.code, ltree[code + LITERALS + 1].dl.len);
+				extra = extra_lbits[code];
+				if(extra) 
+				{
+					lenCount -= base_length[code];
+					// send the extra length bits
+					send_bits(s, lenCount, extra);       
+				}
+				// dist is now the match distance - 1
+				dist--; 
+				code = (dist < 256 ? tr_dist_code[dist] : tr_dist_code[256 + (dist >> 7)]);
+
+				// send the distance code
+				send_bits(s, dtree[code].fc.code, dtree[code].dl.len);
+				extra = extra_dbits[code];
+				if(extra) 
+				{
+					dist -= base_dist[code];
+					// send the extra distance bits
+					send_bits(s, dist, extra);   
+				}
+			}
+		} 
+		while(lenIdx < s->last_lit);
+	}
+
+	send_bits(s, ltree[END_BLOCK].fc.code, ltree[END_BLOCK].dl.len);
+    s->last_eob_len = ltree[END_BLOCK].dl.len;
+}
+
+// ===========================================================================
+// Send a stored block
+// ===========================================================================
+
+static void tr_stored_block(deflate_state *s, const byte *buf, ulong stored_len, bool eof)
+{
+	// send block type
+    send_bits(s, (STORED_BLOCK << 1) + (ulong)eof, 3);
+
+	// align on byte boundary
+    bi_windup(s);        
+	// enough lookahead for inflate
+    s->last_eob_len = 8; 
+
+	put_short(s, (word)stored_len);   
+	put_short(s, (word)~stored_len);
+
+    while(stored_len--)
+	{
+        put_byte(s, *buf++);
+    }
+}
+
+// ===========================================================================
+// Determine the best encoding for the current block: dynamic trees, static
+// trees or store, and output the encoded block to the zip file.
+// ===========================================================================
+
+static void tr_flush_block(deflate_state *s, const byte *buf, ulong stored_len, bool eof)
+{
+    ulong	opt_lenb;
+    ulong	static_lenb;
+    ulong	max_blindex;			// index of last bit length code of non zero freq
+
+    max_blindex = 0;
+
+    // Build the Huffman trees unless a stored block is forced
+    if(s->level > 0) 
+	{
+		// Construct the literal and distance trees
+		build_tree(s, &s->l_desc);
+		build_tree(s, &s->d_desc);
+		// At this point, opt_len and static_len are the total bit lengths of
+		// the compressed block data, excluding the tree representations.
+
+		// Build the bit length tree for the above two trees, and get the index
+		// in bl_order of the last bit length code to send.
+		max_blindex = build_bl_tree(s);
+
+		// Determine the best encoding. Compute first the block length in bytes
+		opt_lenb = (s->opt_len + 3 + 7) >> 3;
+		static_lenb = (s->static_len + 3 + 7) >> 3;
+
+		if(static_lenb <= opt_lenb) 
+		{
+			opt_lenb = static_lenb;
+		}
+    } 
+	else 
+	{
+		static_lenb = stored_len + 5;
+		// force a stored block
+		opt_lenb = static_lenb;		
+    }
+
+    if(stored_len + 4 <= opt_lenb && buf) 
+	{
+		// 4: two words for the lengths
+        // The test buf != NULL is only necessary if LIT_BUFSIZE > WSIZE.
+        // Otherwise we can't have processed more than WSIZE input bytes since
+        // the last block flush, because compression would have been
+        // successful. If LIT_BUFSIZE <= WSIZE, it is never too late to
+        // transform a block into a stored block.
+        tr_stored_block(s, buf, stored_len, eof);
+
+    } 
+	else if(static_lenb == opt_lenb) 
+	{
+        send_bits(s, (STATIC_TREES << 1) + (ulong)eof, 3);
+        compress_block(s, static_ltree, static_dtree);
+    } 
+	else 
+	{
+        send_bits(s, (DYN_TREES << 1) + (ulong)eof, 3);
+        send_all_trees(s, s->l_desc.max_code + 1, s->d_desc.max_code + 1, max_blindex + 1);
+        compress_block(s, s->dyn_ltree, s->dyn_dtree);
+    }
+
+    // The above check is made mod 2^32, for files larger than 512 MB
+    // and uLong implemented on 32 bits.
+    init_block(s);
+
+    if(eof) 
+	{
+        bi_windup(s);
+    }
+}
+
+// ===============================================================================
+// ===============================================================================
+
+inline bool tr_tally_lit(deflate_state *s, byte c)
+{
+	s->d_buf[s->last_lit] = 0;
+	s->l_buf[s->last_lit++] = c;
+	s->dyn_ltree[c].fc.freq++;
+
+	return(s->last_lit == LIT_BUFSIZE - 1);
+}
+
+// ===============================================================================
+// ===============================================================================
+
+inline bool tr_tally_dist(deflate_state *s, ulong dist, ulong len)
+{ 
+	assert(dist < 65536);
+	assert(len < 256);
+
+	dist &= 0xffff;
+	len &= 0xff;
+
+    s->d_buf[s->last_lit] = (word)dist;
+    s->l_buf[s->last_lit++] = (byte)len;
+    dist--;
+    s->dyn_ltree[tr_length_code[len] + LITERALS + 1].fc.freq++;
+    s->dyn_dtree[(dist < 256 ? tr_dist_code[dist] : tr_dist_code[256 + (dist >> 7)])].fc.freq++;
+
+    return(s->last_lit == LIT_BUFSIZE - 1);
+}
+
+// ===============================================================================
+// Insert string str in the dictionary and set match_head to the previous head
+// of the hash chain (the most recent string with same hash key). Return
+// the previous length of the hash chain.
+// If this file is compiled with -DFASTEST, the compression level is forced
+// to 1, and no hash chains are maintained.
+// IN  assertion: all calls to to INSERT_STRING are made with consecutive
+//    input characters and the first MIN_MATCH bytes of str are valid
+//    (except for the last MIN_MATCH-1 bytes of the input file).
+// ===============================================================================
+
+inline void insert_string(deflate_state *s, ulong str, ulong &match_head)
+{
+	s->ins_h = ((s->ins_h << HASH_SHIFT) ^ s->window[str + (MIN_MATCH - 1)]) & HASH_MASK;
+	match_head = s->head[s->ins_h];
+    s->prev[str & WINDOW_MASK] = s->head[s->ins_h]; 
+    s->head[s->ins_h] = (word)str;
+}
+
+// ===========================================================================
+// Initialize the "longest match" routines for a new zlib stream
+// ===========================================================================
+
+static void lm_init(deflate_state *s)
+{
+    s->head[HASH_SIZE - 1] = NULL;
+    memset(s->head, 0, (HASH_SIZE - 1) * sizeof(*s->head));
+
+    // Set the default configuration parameters:
+    s->max_lazy_match = configuration_table[s->level].max_lazy;
+    s->good_match = configuration_table[s->level].good_length;
+    s->nice_match = configuration_table[s->level].nice_length;
+    s->max_chain_length = configuration_table[s->level].max_chain;
+
+    s->strstart = 0;
+    s->block_start = 0;
+    s->lookahead = 0;
+	s->prev_length = MIN_MATCH - 1;
+    s->match_length = MIN_MATCH - 1;
+    s->match_available = 0;
+    s->ins_h = 0;
+}
+
+// ===========================================================================
+// Set match_start to the longest match starting at the given string and
+// return its length. Matches shorter or equal to prev_length are discarded,
+// in which case the result is equal to prev_length and match_start is
+// garbage.
+// IN assertions: cur_match is the head of the hash chain for the current
+//  string (strstart) and its distance is <= MAX_DIST, and prev_length >= 1
+// OUT assertion: the match length is not greater than s->lookahead.
+// ===========================================================================
+
+inline byte *qcmp(byte *scan, byte *match, ulong count)
+{
+	byte	*retval;
+	_asm
+	{
+		push	esi
+		push	edi
+		push	ecx
+
+		mov		esi, [scan]
+		mov		edi, [match]
+		mov		ecx, [count]
+		repe	cmpsb
+
+		pop		ecx
+		pop		edi
+		mov		[retval], esi
+		pop		esi
+	}
+	return(--retval);
+}
+
+static ulong longest_match(deflate_state *s, ulong cur_match)
+{
+	ulong	chain_length;			// max hash chain length
+	ulong	limit;
+	byte	*scan;					// current string
+	byte	*match;					// matched string
+	ulong	len;					// length of current match
+	ulong	best_len;				// best match length so far
+	ulong	nice_match;				// stop if match long enough
+    byte	scan_end1;
+    byte	scan_end;
+
+	chain_length = s->max_chain_length;
+	scan = s->window + s->strstart;
+	best_len = s->prev_length;
+	nice_match = s->nice_match;
+
+    // Stop when cur_match becomes <= limit. To simplify the code,
+    // we prevent matches with the string of window index 0.
+	limit = s->strstart > (WINDOW_SIZE - MIN_LOOKAHEAD) ? s->strstart - (WINDOW_SIZE - MIN_LOOKAHEAD) : NULL;
+
+    scan_end1 = scan[best_len - 1];
+    scan_end = scan[best_len];
+
+    // Do not waste too much time if we already have a good match:
+    if(s->prev_length >= s->good_match) 
+	{
+        chain_length >>= 2;
+    }
+    // Do not look for matches beyond the end of the input. This is necessary
+    // to make deflate deterministic.
+    if(nice_match > s->lookahead) 
+	{
+		nice_match = s->lookahead;
+	}
+    do 
+	{
+        match = s->window + cur_match;
+
+        // Skip to next match if the match length cannot increase
+        // or if the match length is less than 2:
+        if((match[best_len] != scan_end) || (match[best_len - 1] != scan_end1) || (match[0] != scan[0]) || (match[1] != scan[1]))
+		{
+			continue;
+		}
+
+        // The check at best_len-1 can be removed because it will be made
+        // again later. (This heuristic is not always a win.)
+        // It is not necessary to compare scan[2] and match[2] since they
+        // are always equal when the other bytes match, given that
+        // the hash keys are equal
+		scan = qcmp(scan + 3, match + 3, MAX_MATCH - 2);
+
+        len = scan - (s->window + s->strstart);
+        scan = s->window + s->strstart;
+
+        if(len > best_len) 
+		{
+            s->match_start = cur_match;
+            best_len = len;
+            if(len >= nice_match) 
+			{
+				break;
+			}
+            scan_end1 = scan[best_len - 1];
+            scan_end = scan[best_len];
+        }
+    } while((cur_match = s->prev[cur_match & WINDOW_MASK]) > limit && --chain_length);
+
+    if(best_len <= s->lookahead) 
+	{
+		return(best_len);
+	}
+    return(s->lookahead);
+}
+
+// ===========================================================================
+// Flush as much pending output as possible. All deflate() output goes
+// through this function so some applications may wish to modify it
+// to avoid allocating a large z->next_out buffer and copying into it.
+// (See also read_buf()).
+// ===========================================================================
+
+static void flush_pending(z_stream *z)
+{
+    ulong	len = z->dstate->pending;
+
+    if(len > z->avail_out) 
+	{
+		len = z->avail_out;
+	}
+    if(!len) 
+	{
+		return;
+	}
+	assert(len <= MAX_BLOCK_SIZE + 5);
+	assert(z->dstate->pending_out + len <= z->dstate->pending_buf + MAX_BLOCK_SIZE + 5);
+
+    memcpy(z->next_out, z->dstate->pending_out, len);
+    z->next_out += len;
+	z->total_out += len;
+    z->dstate->pending_out += len;
+    z->avail_out -= len;
+    z->dstate->pending -= len;
+    if(!z->dstate->pending) 
+	{
+        z->dstate->pending_out = z->dstate->pending_buf;
+    }
+}
+
+// ===========================================================================
+// Read a new buffer from the current input stream, update the adler32
+// and total number of bytes read.  All deflate() input goes through
+// this function so some applications may wish to modify it to avoid
+// allocating a large z->next_in buffer and copying from it.
+// (See also flush_pending()).
+// ===========================================================================
+
+static ulong read_buf(z_stream *z, byte *buf, ulong size)
+{
+    ulong	len;
+
+    len = z->avail_in;
+    if(len > size)
+	{
+		len = size;
+	}
+    if(!len) 
+	{
+		return(0);
+	}
+    z->avail_in -= len;
+
+	if(!z->dstate->noheader)
+	{
+        z->dstate->adler = adler32(z->dstate->adler, z->next_in, len);
+	}
+    memcpy(buf, z->next_in, len);
+    z->next_in += len;
+    return(len);
+}
+
+// ===========================================================================
+// Fill the window when the lookahead becomes insufficient.
+// Updates strstart and lookahead.
+//
+// IN assertion: lookahead < MIN_LOOKAHEAD
+// OUT assertions: strstart <= BIG_WINDOW_SIZE - MIN_LOOKAHEAD
+//    At least one byte has been read, or avail_in == 0; reads are
+//    performed for at least two bytes (required for the zip translate_eol
+//    option -- not supported here).
+// ===========================================================================
+
+static void fill_window(deflate_state *s)
+{
+	ulong		n, m;
+	word		*p;
+    ulong		more;				// Amount of free space at the end of the window.
+
+    do 
+	{
+        more = BIG_WINDOW_SIZE - s->lookahead - s->strstart;
+
+		if(s->strstart >= WINDOW_SIZE + (WINDOW_SIZE - MIN_LOOKAHEAD)) 
+		{
+            memcpy(s->window, s->window + WINDOW_SIZE, WINDOW_SIZE);
+            s->match_start -= WINDOW_SIZE;
+			// Make strstart >= MAX_DIST
+            s->strstart -= WINDOW_SIZE;					
+            s->block_start -= WINDOW_SIZE;
+
+			// Slide the hash table (could be avoided with 32 bit values
+            // at the expense of memory usage). We slide even when level == 0
+            // to keep the hash table consistent if we switch back to level > 0
+            // later. (Using level 0 permanently is not an optimal usage of
+            // zlib, so we don't care about this pathological case.)
+			n = HASH_SIZE;
+			p = &s->head[n];
+			do
+			{
+				m = *--p;
+				*p = (word)(m >= WINDOW_SIZE ? m - WINDOW_SIZE : 0);
+			}
+			while(--n);
+
+			n = WINDOW_SIZE;
+			p = &s->prev[n];
+			do
+			{
+				m = *--p;
+				*p = (word)(m >= WINDOW_SIZE ? m - WINDOW_SIZE : 0);
+				// If n is not on any hash chain, prev[n] is garbage but
+				// its value will never be used.
+			}
+			while(--n);
+
+            more += WINDOW_SIZE;
+        }
+		if(!s->z->avail_in)
+		{
+			return;
+		}
+
+        // If there was no sliding:
+        //    strstart <= WSIZE+MAX_DIST-1 && lookahead <= MIN_LOOKAHEAD - 1 &&
+        //    more == BIG_WINDOW_SIZE - lookahead - strstart
+        // => more >= BIG_WINDOW_SIZE - (MIN_LOOKAHEAD-1 + WSIZE + MAX_DIST-1)
+        // => more >= BIG_WINDOW_SIZE- 2*WSIZE + 2
+        // If there was sliding, more >= WSIZE. So in all cases, more >= 2.
+        n = read_buf(s->z, s->window + s->strstart + s->lookahead, more);
+        s->lookahead += n;
+
+        // Initialize the hash value now that we have some input:
+        if(s->lookahead >= MIN_MATCH) 
+		{
+			s->ins_h = ((s->window[s->strstart] << HASH_SHIFT) ^ s->window[s->strstart + 1]) & HASH_MASK;
+        }
+        // If the whole input has less than MIN_MATCH bytes, ins_h is garbage,
+        // but this is not important since only literal bytes will be emitted.
+    } 
+	while(s->lookahead < MIN_LOOKAHEAD && s->z->avail_in);
+}
+
+// ===========================================================================
+// Flush the current block, with given end-of-file flag.
+// IN assertion: strstart is set to the end of the current match.
+// ===========================================================================
+
+inline void flush_block_only(deflate_state *s, bool eof)
+{
+	if(s->block_start >= 0)
+	{
+		tr_flush_block(s, &s->window[s->block_start], s->strstart - s->block_start, eof);
+	}
+	else
+	{
+		tr_flush_block(s, 0, s->strstart - s->block_start, eof);
+	}
+   s->block_start = s->strstart;
+   flush_pending(s->z);
+}
+
+// ===========================================================================
+// Copy without compression as much as possible from the input stream, return
+// the current block state.
+// This function does not insert new strings in the dictionary since
+// uncompressible data is probably not useful. This function is used
+// only for the level=0 compression option.
+// NOTE: this function should be optimized to avoid extra copying from
+// window to pending_buf.
+// ===========================================================================
+
+static block_state deflate_stored(deflate_state *s, EFlush flush)
+{
+    // Stored blocks are limited to 0xffff bytes, pending_buf is limited
+    // to pending_buf_size, and each stored block has a 5 byte header:
+    ulong	max_start;
+
+    // Copy as much as possible from input to output:
+    while(true) 
+	{
+        // Fill the window as much as possible
+        if(s->lookahead <= 1) 
+		{
+            fill_window(s);
+            if(!s->lookahead && (flush == Z_NO_FLUSH))
+			{
+				return(NEED_MORE);
+			}
+            if(!s->lookahead) 
+			{
+				// flush the current block
+				break;
+			}
+        }
+		s->strstart += s->lookahead;
+		s->lookahead = 0;
+
+		// Emit a stored block if pending_buf will be full
+		max_start = s->block_start + MAX_BLOCK_SIZE;
+        if(!s->strstart || (s->strstart >= max_start))
+		{
+			// strstart == 0 is possible when wraparound on 16-bit machine
+			s->lookahead = s->strstart - max_start;
+			s->strstart = max_start;
+			flush_block_only(s, false);
+			if(!s->z->avail_out)
+			{
+				return(NEED_MORE);
+			}
+		}
+		// Flush if we may have to slide, otherwise block_start may become
+        // negative and the data will be gone:
+		if(s->strstart - s->block_start >= WINDOW_SIZE - MIN_LOOKAHEAD) 
+		{
+			flush_block_only(s, false);
+			if(!s->z->avail_out)
+			{
+				return(NEED_MORE);
+			}
+		}
+    }
+	flush_block_only(s, flush == Z_FINISH);
+	if(!s->z->avail_out)
+	{
+		return((flush == Z_FINISH) ? FINISH_STARTED : NEED_MORE);
+	}
+    return(flush == Z_FINISH ? FINISH_DONE : BLOCK_DONE);
+}
+
+// ===========================================================================
+// Compress as much as possible from the input stream, return the current block state.
+// This function does not perform lazy evaluation of matches and inserts
+// new strings in the dictionary only for unmatched strings or for short
+// matches. It is used only for the fast compression options.
+// ===========================================================================
+
+static block_state deflate_fast(deflate_state *s, EFlush flush)
+{
+    ulong		hash_head;			// head of the hash chain
+    bool		bflush;	 			// set if current block must be flushed
+
+    hash_head = 0;
+    while(true)
+	{
+        // Make sure that we always have enough lookahead, except
+        // at the end of the input file. We need MAX_MATCH bytes
+        // for the next match, plus MIN_MATCH bytes to insert the
+        // string following the next match.
+        if(s->lookahead < MIN_LOOKAHEAD) 
+		{
+            fill_window(s);
+            if((s->lookahead < MIN_LOOKAHEAD) && (flush == Z_NO_FLUSH))
+			{
+		        return(NEED_MORE);
+			}
+            if(!s->lookahead) 
+			{
+				// flush the current block
+				break; 
+			}
+        }
+
+        // Insert the string window[strstart .. strstart+2] in the
+        // dictionary, and set hash_head to the head of the hash chain:
+        if(s->lookahead >= MIN_MATCH) 
+		{
+            insert_string(s, s->strstart, hash_head);
+        }
+
+        // Find the longest match, discarding those <= prev_length.
+        // At this point we have always match_length < MIN_MATCH
+        if(hash_head && (s->strstart - hash_head <= WINDOW_SIZE - MIN_LOOKAHEAD)) 
+		{
+            // To simplify the code, we prevent matches with the string
+            // of window index 0 (in particular we have to avoid a match
+            // of the string with itself at the start of the input file).
+			s->match_length = longest_match(s, hash_head);
+            // longest_match() sets match_start
+        }
+        if(s->match_length >= MIN_MATCH) 
+		{
+			s->z->quality++;
+
+            bflush = tr_tally_dist(s, s->strstart - s->match_start, s->match_length - MIN_MATCH);
+            s->lookahead -= s->match_length;
+
+            // Insert new strings in the hash table only if the match length
+            // is not too large. This saves time but degrades compression.
+            if((s->match_length <= s->max_lazy_match) && (s->lookahead >= MIN_MATCH))
+			{
+				// string at strstart already in hash table
+                s->match_length--; 
+                do 
+				{
+                    // strstart never exceeds WSIZE-MAX_MATCH, so there are
+                    // always MIN_MATCH bytes ahead.
+                    s->strstart++;
+                    insert_string(s, s->strstart, hash_head);
+                } 
+				while(--s->match_length);
+                s->strstart++; 
+            } 
+			else
+			{
+				s->z->quality++;
+
+                s->strstart += s->match_length;
+                s->match_length = 0;
+				s->ins_h = ((s->window[s->strstart] << HASH_SHIFT) ^ s->window[s->strstart + 1]) & HASH_MASK;
+                // If lookahead < MIN_MATCH, ins_h is garbage, but it does not
+                // matter since it will be recomputed at next deflate call.
+            }
+        } 
+		else 
+		{
+            // No match, output a literal byte
+            bflush = tr_tally_lit(s, s->window[s->strstart]);
+            s->lookahead--;
+            s->strstart++; 
+        }
+        if(bflush) 
+		{
+			flush_block_only(s, false);
+			if(!s->z->avail_out)
+			{
+				return(NEED_MORE);
+			}
+		}
+    }
+	flush_block_only(s, flush == Z_FINISH);
+	if(!s->z->avail_out)
+	{
+		return(flush == Z_FINISH ? FINISH_STARTED : NEED_MORE);
+	}
+    return(flush == Z_FINISH ? FINISH_DONE : BLOCK_DONE);
+}
+
+// ===========================================================================
+// Same as above, but achieves better compression. We use a lazy
+// evaluation for matches: a match is finally adopted only if there is
+// no better match at the next window position.
+// ===========================================================================
+
+static block_state deflate_slow(deflate_state *s, EFlush flush)
+{
+    ulong		hash_head;			// head of hash chain
+	ulong		max_insert;
+    bool		bflush;				// set if current block must be flushed
+
+    hash_head = 0;
+    // Process the input block.
+    while(true) 
+	{
+        // Make sure that we always have enough lookahead, except
+        // at the end of the input file. We need MAX_MATCH bytes
+        // for the next match, plus MIN_MATCH bytes to insert the
+        // string following the next match.
+        if(s->lookahead < MIN_LOOKAHEAD) 
+		{
+            fill_window(s);
+            if((s->lookahead < MIN_LOOKAHEAD) && (flush == Z_NO_FLUSH))
+			{
+				return(NEED_MORE);
+			}
+            if(!s->lookahead) 
+			{
+				// flush the current block
+				break; 
+			}
+        }
+
+        // Insert the string window[strstart .. strstart+2] in the
+        // dictionary, and set hash_head to the head of the hash chain:
+        if(s->lookahead >= MIN_MATCH) 
+		{
+            insert_string(s, s->strstart, hash_head);
+        }
+
+        // Find the longest match, discarding those <= prev_length.
+        s->prev_length = s->match_length;
+		s->prev_match = s->match_start;
+        s->match_length = MIN_MATCH - 1;
+
+        if(hash_head && (s->prev_length < s->max_lazy_match) && (s->strstart - hash_head <= WINDOW_SIZE - MIN_LOOKAHEAD)) 
+		{
+            // To simplify the code, we prevent matches with the string
+            // of window index 0 (in particular we have to avoid a match
+            // of the string with itself at the start of the input file).
+			// longest_match() sets match_start
+			s->match_length = longest_match(s, hash_head);
+
+            if((s->match_length <= 5) && ((s->match_length == MIN_MATCH) && (s->strstart - s->match_start > TOO_FAR))) 
+			{
+                // If prev_match is also MIN_MATCH, match_start is garbage
+                // but we will ignore the current match anyway.
+                s->match_length = MIN_MATCH - 1;
+            }
+        }
+        // If there was a match at the previous step and the current
+        // match is not better, output the previous match:
+        if((s->prev_length >= MIN_MATCH) && (s->match_length <= s->prev_length))
+		{
+            // Do not insert strings in hash table beyond this.
+			max_insert = s->strstart + s->lookahead - MIN_MATCH;
+
+            bflush = tr_tally_dist(s, s->strstart - 1 - s->prev_match, s->prev_length - MIN_MATCH);
+
+            // Insert in hash table all strings up to the end of the match.
+            // strstart-1 and strstart are already inserted. If there is not
+            // enough lookahead, the last two strings are not inserted in
+            // the hash table.
+            s->lookahead -= s->prev_length - 1;
+            s->prev_length -= 2;
+            do 
+			{
+                if(++s->strstart <= max_insert) 
+				{
+                    insert_string(s, s->strstart, hash_head);
+                }
+            } 
+			while(--s->prev_length);
+
+            s->match_available = 0;
+            s->match_length = MIN_MATCH - 1;
+            s->strstart++;
+
+            if(bflush) 
+			{
+				flush_block_only(s, false);
+				if(!s->z->avail_out)
+				{
+					return(NEED_MORE);
+				}
+			}
+        } 
+		else if(s->match_available)
+		{
+            // If there was no match at the previous position, output a
+            // single literal. If there was a match but the current match
+            // is longer, truncate the previous match to a single literal.
+		    bflush = tr_tally_lit(s, s->window[s->strstart - 1]);
+		    if(bflush) 
+			{
+                flush_block_only(s, false);
+            }
+            s->strstart++;
+            s->lookahead--;
+            if(!s->z->avail_out) 
+			{
+				return(NEED_MORE);
+			}
+        } 
+		else 
+		{
+            // There is no previous match to compare with, wait for
+            // the next step to decide.
+            s->match_available = 1;
+            s->strstart++;
+            s->lookahead--;
+        }
+    }
+    if(s->match_available) 
+	{
+        bflush = tr_tally_lit(s, s->window[s->strstart - 1]);
+        s->match_available = 0;
+    }
+	flush_block_only(s, flush == Z_FINISH);
+	if(!s->z->avail_out)
+	{
+		return(flush == Z_FINISH ? FINISH_STARTED : NEED_MORE);
+	}
+    return(flush == Z_FINISH ? FINISH_DONE : BLOCK_DONE);
+}
+
+// -------------------------------------------------------------------------------------------------
+// Controlling routines
+// -------------------------------------------------------------------------------------------------
+
+EStatus deflateInit(z_stream *z, ELevel level, int noWrap)
+{
+    deflate_state	*s;
+
+	assert(z);
+
+    deflate_error = "OK";
+    if((level < Z_STORE_COMPRESSION) || (level > Z_MAX_COMPRESSION)) 
+	{
+		deflate_error = "Invalid compression level";
+        return(Z_STREAM_ERROR);
+    }
+    s = (deflate_state *)Z_Malloc(sizeof(deflate_state), TAG_DEFLATE, qtrue);
+    z->dstate = (deflate_state *)s;
+    s->z = z;
+
+  	// undocumented feature: suppress zlib header
+	s->noheader = noWrap;
+    s->level = level;
+
+	z->total_out = 0;
+	z->quality = 0;
+
+    s->pending = 0;
+    s->pending_out = s->pending_buf;
+
+    s->status = s->noheader ? BUSY_STATE : INIT_STATE;
+    s->adler = 1;
+    s->last_flush = Z_NO_FLUSH;
+
+    tr_init(s);
+    lm_init(s);
+	return(Z_OK);
+}
+
+// ===========================================================================
+// Copy the source state to the destination state.
+// To simplify the source, this is not supported for 16-bit MSDOS (which
+// doesn't have enough memory anyway to duplicate compression states).
+// ===========================================================================
+
+EStatus deflateCopy(z_stream *dest, z_stream *source)
+{
+    deflate_state	*ds;
+    deflate_state	*ss;
+
+	assert(source);
+	assert(dest);
+	assert(source->dstate);
+	assert(!dest->dstate);
+
+    *dest = *source;
+
+    ss = source->dstate;
+    ds = (deflate_state *)Z_Malloc(sizeof(deflate_state), TAG_DEFLATE, qtrue);
+    dest->dstate = ds;
+    *ds = *ss;
+    ds->z = dest;
+
+    ds->pending_out = ds->pending_buf + (ss->pending_out - ss->pending_buf);
+
+    ds->l_desc.dyn_tree = ds->dyn_ltree;
+    ds->d_desc.dyn_tree = ds->dyn_dtree;
+    ds->bl_desc.dyn_tree = ds->bl_tree;
+
+    return(Z_OK);
+}
+
+// ===========================================================================
+// ===========================================================================
+
+EStatus deflate(z_stream *z, EFlush flush)
+{
+    EFlush			old_flush;		// value of flush param for previous deflate call
+    deflate_state	*s;
+	ulong			header;
+	ulong			level_flags;
+
+	assert(z);
+	assert(z->dstate);
+
+    if((flush > Z_FINISH) || (flush < Z_NO_FLUSH)) 
+	{
+		deflate_error = "Invalid flush type"; 
+        return(Z_STREAM_ERROR);
+    }
+    s = z->dstate;
+
+    if(!z->next_out || (!z->next_in && z->avail_in) || (s->status == FINISH_STATE && flush != Z_FINISH)) 
+	{
+		deflate_error = "Invalid output data"; 
+		return (Z_STREAM_ERROR);
+    }
+    if(!z->avail_out)
+	{
+		deflate_error = "No output space"; 
+		return (Z_BUF_ERROR);
+	}
+
+    old_flush = s->last_flush;
+    s->last_flush = flush;
+
+    // Write the zlib header
+    if(s->status == INIT_STATE) 
+	{
+		header = (ZF_DEFLATED + ((MAX_WBITS - 8) << 4)) << 8;
+        level_flags = (s->level - 1) >> 1;
+
+        if(level_flags > 3)
+		{
+			level_flags = 3;
+		}
+        header |= (level_flags << 6);
+
+        header += 31 - (header % 31);
+
+        s->status = BUSY_STATE;
+        put_shortMSB(s, (word)header);
+		s->adler = 1;
+    }
+
+	// Flush as much pending output as possible
+	if(s->pending)
+	{
+        flush_pending(z);
+        if(!z->avail_out)
+		{
+			// Since avail_out is 0, deflate will be called again with
+			// more output space, but possibly with both pending and
+			// avail_in equal to zero. There won't be anything to do,
+			// but this is not an error situation so make sure we
+			// return OK instead of BUF_ERROR at next call of deflate:
+			s->last_flush = Z_NEED_MORE;
+			return(Z_OK);
+		}
+
+		// Make sure there is something to do and avoid duplicate consecutive
+		// flushes. For repeated and useless calls with Z_FINISH, we keep
+		// returning Z_STREAM_END instead of Z_BUFF_ERROR.
+	}
+	else if(!z->avail_in && (flush <= old_flush) && (flush != Z_FINISH))
+	{
+		deflate_error = "No available input"; 
+		return(Z_BUF_ERROR);
+    }
+
+    // User must not provide more input after the first FINISH
+    if((s->status == FINISH_STATE) && z->avail_in)
+	{        
+		deflate_error = "Trying to finish while input available"; 
+		return(Z_BUF_ERROR);
+    }
+
+    // Start a new block or continue the current one.
+    if(z->avail_in || s->lookahead || ((flush != Z_NO_FLUSH) && (s->status != FINISH_STATE)))
+	{
+        block_state	bstate;
+
+		bstate = (*(configuration_table[s->level].func))(s, flush);
+
+        if((bstate == FINISH_STARTED) || (bstate == FINISH_DONE))
+		{
+            s->status = FINISH_STATE;
+        }
+        if((bstate == NEED_MORE) || (bstate == FINISH_STARTED))
+		{
+			if(!z->avail_out) 
+			{
+				// avoid BUF_ERROR next call, see above
+				s->last_flush = Z_NEED_MORE; 
+			}
+			return(Z_OK);
+
+			// If flush != Z_NO_FLUSH && avail_out == 0, the next call
+			// of deflate should use the same flush parameter to make sure
+			// that the flush is complete. So we don't have to output an
+			// empty block here, this will be done at next call. This also
+			// ensures that for a very small output buffer, we emit at most
+			// one empty block.
+		}
+		if(bstate == BLOCK_DONE) 
+		{
+			// FULL_FLUSH or SYNC_FLUSH
+            tr_stored_block(s, NULL, 0, false);
+
+            flush_pending(z);
+			if(!z->avail_out)
+			{
+				// avoid BUF_ERROR at next call, see above
+				s->last_flush = Z_NEED_MORE; 
+				return(Z_OK);
+			}
+		}
+	}
+
+    if(flush != Z_FINISH)
+	{
+		return(Z_OK);
+	}
+    if(s->noheader) 
+	{
+		return(Z_STREAM_END);
+	}
+
+    // Write the zlib trailer (adler32)
+    put_longMSB(s, s->adler);
+    flush_pending(z);
+
+    // If avail_out is zero, the application will call deflate again
+    // to flush the rest. Write the trailer only once!
+    s->noheader = -1; 
+    return(!!s->pending ? Z_OK : Z_STREAM_END);
+}
+
+// ===========================================================================
+// ===========================================================================
+
+EStatus deflateEnd(z_stream *z)
+{
+    int		status;
+
+	assert(z);
+	assert(z->dstate);
+
+    status = z->dstate->status;
+    if((status != INIT_STATE) && (status != BUSY_STATE) && (status != FINISH_STATE))
+	{
+		deflate_error = "Invalid state while ending";
+		return(Z_STREAM_ERROR);
+    }
+
+    Z_Free(z->dstate);
+    z->dstate = NULL;
+
+	if(status == BUSY_STATE)
+	{
+		deflate_error = "Ending while in busy state";
+		return(Z_DATA_ERROR);
+	}
+    return(Z_OK);
+}
+
+// ===========================================================================
+// ===========================================================================
+
+const char *deflateError(void)
+{
+	return(deflate_error);
+}
+
+// ===============================================================================
+// External calls
+// ===============================================================================
+
+bool DeflateFile(byte *src, ulong uncompressedSize, byte *dst, ulong maxCompressedSize, ulong *compressedSize, ELevel level, int noWrap)
+{
+	z_stream	z = { 0 };
+
+	if(deflateInit(&z, level, noWrap) != Z_OK)
+	{
+		return(false);
+	}
+
+	z.next_in = src;
+	z.avail_in = uncompressedSize;
+	z.next_out = dst;
+	z.avail_out = maxCompressedSize;
+#ifdef _TIMING
+	int temp = timeGetTime();
+#endif
+	if(deflate(&z, Z_FINISH) != Z_STREAM_END)
+	{
+		deflateEnd(&z);
+		return(false);
+	}
+#ifdef _TIMING
+	totalDeflateTime[level] += timeGetTime() - temp;
+	totalDeflateCount[level]++;
+#endif
+	if(deflateEnd(&z) != Z_OK)
+	{
+		return(false);
+	}
+	*compressedSize = z.total_out;
+	return(true);
+}
+
+// end
\ No newline at end of file
diff --git a/code/zlib32/deflate.h b/code/zlib32/deflate.h
new file mode 100644
index 0000000..1f7d4a0
--- /dev/null
+++ b/code/zlib32/deflate.h
@@ -0,0 +1,231 @@
+// Stream status
+#define INIT_STATE					42
+#define BUSY_STATE					113
+#define FINISH_STATE				666
+
+#define HASH_BITS					15
+#define HASH_SIZE					(1 << HASH_BITS)
+#define HASH_MASK					(HASH_SIZE - 1)
+
+// Size of match buffer for literals/lengths.  There are 4 reasons for
+// limiting lit_bufsize to 64K:
+//   - frequencies can be kept in 16 bit counters
+//   - if compression is not successful for the first block, all input
+//     data is still in the window so we can still emit a stored block even
+//     when input comes from standard input.  (This can also be done for
+//     all blocks if lit_bufsize is not greater than 32K.)
+//   - if compression is not successful for a file smaller than 64K, we can
+//     even emit a stored file instead of a stored block (saving 5 bytes).
+//     This is applicable only for zip (not gzip or zlib).
+//   - creating new Huffman trees less frequently may not provide fast
+//     adaptation to changes in the input data statistics. (Take for
+//     example a binary file with poorly compressible code followed by
+//     a highly compressible string table.) Smaller buffer sizes give
+//     fast adaptation but have of course the overhead of transmitting
+//     trees more frequently.
+//   - I can't count above 4
+#define LIT_BUFSIZE					(1 << 14)
+
+#define MAX_BLOCK_SIZE				0xffff
+
+// Number of bits by which ins_h must be shifted at each input
+// step. It must be such that after MIN_MATCH steps, the oldest
+// byte no longer takes part in the hash key.
+#define HASH_SHIFT					((HASH_BITS + MIN_MATCH - 1) / MIN_MATCH)
+
+// Matches of length 3 are discarded if their distance exceeds TOO_FAR
+#define TOO_FAR						32767
+
+// Number of length codes, not counting the special END_BLOCK code
+#define LENGTH_CODES				29
+
+// Number of codes used to transfer the bit lengths
+#define BL_CODES					19
+
+// Number of literal bytes 0..255
+#define LITERALS					256
+
+// Number of Literal or Length codes, including the END_BLOCK code
+#define L_CODES						(LITERALS + 1 + LENGTH_CODES)
+
+// See definition of array dist_code below
+#define DIST_CODE_LEN				512 
+
+// Maximum heap size
+#define HEAP_SIZE					(2 * L_CODES + 1)
+
+// Index within the heap array of least frequent node in the Huffman tree
+#define SMALLEST					1
+
+// Bit length codes must not exceed MAX_BL_BITS bits
+#define MAX_BL_BITS					7
+
+// End of block literal code
+#define END_BLOCK					256
+
+// Repeat previous bit length 3-6 times (2 bits of repeat count)
+#define REP_3_6						16
+
+// Repeat a zero length 3-10 times  (3 bits of repeat count)
+#define REPZ_3_10					17
+
+// Repeat a zero length 11-138 times  (7 bits of repeat count)
+#define REPZ_11_138					18
+
+// Number of bits used within bi_buf. (bi_buf might be implemented on
+// more than 16 bits on some systems.)
+#define BUF_SIZE					(8 * 2)
+
+// Minimum amount of lookahead, except at the end of the input file.
+// See deflate.c for comments about the MIN_MATCH+1.
+#define MIN_LOOKAHEAD				(MAX_MATCH + MIN_MATCH + 1)
+
+typedef enum 
+{
+    NEED_MORE,									// block not completed, need more input or more output
+    BLOCK_DONE,									// block flush performed
+    FINISH_STARTED,								// finish started, need only more output at next deflate
+    FINISH_DONE									// finish done, accept no more input or output
+} block_state;
+
+// Data structure describing a single value and its code string.
+typedef struct ct_data_s 
+{
+    union 
+	{
+        word  freq;								// frequency count
+        word  code;								// bit string
+    } fc;										
+    union										
+	{											
+        word  dad;								// father node in Huffman tree
+        word  len;								// length of bit string
+    } dl;										
+} ct_data;										
+												
+typedef struct static_tree_desc_s				
+{												
+    const ct_data	*static_tree; 				// static tree or NULL
+    const ulong		*extra_bits;  				// extra bits for each code or NULL
+    ulong			extra_base;	  				// base index for extra_bits
+    ulong			elems;		  				// max number of elements in the tree
+    ulong			max_length;	  				// max bit length for the codes
+} static_tree_desc;
+
+typedef struct tree_desc_s 
+{
+    ct_data 			*dyn_tree;				// the dynamic tree
+    ulong		 		max_code;				// largest code with non zero frequency
+    static_tree_desc	*stat_desc;				// the corresponding static tree
+} tree_desc;
+
+// Main structure which the deflate algorithm works from
+typedef struct deflate_state_s
+{
+    z_stream	*z;								// pointer back to this zlib stream
+    ulong		status;							// as the name implies
+												
+    EFlush		last_flush;						// value of flush param for previous deflate call
+    int 		noheader;						// suppress zlib header and adler32
+
+    byte		pending_buf[MAX_BLOCK_SIZE + 5];// output still pending
+    byte		*pending_out;					// next pending byte to output to the stream
+    ulong 		pending;						// nb of bytes in the pending buffer
+
+    // Sliding window. Input bytes are read into the second half of the window,
+    // and move to the first half later to keep a dictionary of at least wSize
+    // bytes. With this organization, matches are limited to a distance of
+    // wSize-MAX_MATCH bytes, but this ensures that IO is always
+    // performed with a length multiple of the block size. Also, it limits
+    // the window size to 64K, which is quite useful on MSDOS.
+    // To do: use the user input buffer as sliding window.
+    byte		window[WINDOW_SIZE * 2];
+
+    // Link to older string with same hash index. To limit the size of this
+    // array to 64K, this link is maintained only for the last 32K strings.
+    // An index in this array is thus a window index modulo 32K.
+    word		prev[WINDOW_SIZE];
+
+    word		head[HASH_SIZE];				// Heads of the hash chains or NULL.
+
+    ulong		ins_h;							// hash index of string to be inserted
+
+    // Window position at the beginning of the current output block. Gets
+    // negative when the window is moved backwards.
+    int			block_start;
+
+    ulong		match_length;					// length of best match
+    ulong		prev_match;						// previous match
+    ulong		match_available;				// set if previous match exists
+    ulong		strstart;						// start of string to insert
+    ulong		match_start;					// start of matching string
+    ulong		lookahead;						// number of valid bytes ahead in window
+
+    // Length of the best match at previous step. Matches not greater than this
+    // are discarded. This is used in the lazy match evaluation.
+    ulong		prev_length;
+
+    // Attempt to find a better match only when the current match is strictly
+    // smaller than this value. This mechanism is used only for compression	levels >= 4.
+    ulong		max_lazy_match;
+
+    ulong		good_match;						// Use a faster search when the previous match is longer than this
+    ulong		nice_match;						// Stop searching when current match exceeds this
+
+    // To speed up deflation, hash chains are never searched beyond this
+    // length.  A higher limit improves compression ratio but degrades the speed.
+    ulong		max_chain_length;
+
+    ELevel		level;							// compression level (0..9)
+												
+    ct_data		dyn_ltree[HEAP_SIZE];			// literal and length tree
+    ct_data		dyn_dtree[(2 * D_CODES) + 1]; 	// distance tree
+    ct_data		bl_tree[(2 * BL_CODES) + 1];  	// Huffman tree for bit lengths
+
+    tree_desc	l_desc;							// desc. for literal tree
+    tree_desc	d_desc;							// desc. for distance tree
+    tree_desc	bl_desc;						// desc. for bit length tree
+
+    word		bl_count[MAX_WBITS + 1];		// number of codes at each bit length for an optimal tree
+
+    // The sons of heap[n] are heap[2*n] and heap[2*n+1]. heap[0] is not used.
+    // The same heap array is used to build all trees.
+    ulong		heap[(2 * L_CODES) + 1];		// heap used to build the Huffman trees
+    ulong		heap_len;						// number of elements in the heap
+    ulong		heap_max;						// element of largest frequency
+
+    byte		depth[(2 * L_CODES) + 1];		// Depth of each subtree used as tie breaker for trees of equal frequency
+
+    byte		l_buf[LIT_BUFSIZE];				// buffer for literals or lengths
+
+    ulong		last_lit;						// running index in l_buf
+
+    // Buffer for distances. To simplify the code, d_buf and l_buf have
+    // the same number of elements. To use different lengths, an extra flag
+    // array would be necessary.
+    word		d_buf[LIT_BUFSIZE];
+ 
+	ulong		opt_len;						// bit length of current block with optimal trees
+    ulong		static_len;						// bit length of current block with static trees
+    ulong		matches;						// number of string matches in current block
+    ulong		last_eob_len;					// bit length of EOB code for last block
+
+    word		bi_buf;							// Output buffer. bits are inserted starting at the bottom (least significant bits).
+    ulong		bi_valid;						// Number of valid bits in bi_buf.  All bits above the last valid bit are always zero.
+
+	ulong		adler;
+} deflate_state;
+
+// Compression function. Returns the block state after the call.
+typedef block_state (*compress_func) (deflate_state *s, EFlush flush);
+
+typedef struct config_s 
+{
+   word				good_length;				// reduce lazy search above this match length
+   word				max_lazy;					// do not perform lazy search above this match length
+   word				nice_length;				// quit search above this match length
+   word				max_chain;
+   compress_func	func;
+} config;
+
+// end						
\ No newline at end of file
diff --git a/code/zlib32/inflate.cpp b/code/zlib32/inflate.cpp
new file mode 100644
index 0000000..887bb23
--- /dev/null
+++ b/code/zlib32/inflate.cpp
@@ -0,0 +1,1839 @@
+#include "../game/q_shared.h"
+#include "../qcommon/qcommon.h"
+
+#include "zip.h"
+#include "inflate.h"
+
+#ifdef _TIMING
+int		totalInflateTime;
+int		totalInflateCount;
+#endif
+
+// If you use the zlib library in a product, an acknowledgment is welcome
+// in the documentation of your product. If for some reason you cannot
+// include such an acknowledgment, I would appreciate that you keep this
+// copyright string in the executable of your product.
+const char inflate_copyright[] = "Inflate 1.1.3 Copyright 1995-1998 Mark Adler ";
+
+static const char *inflate_error = "OK";
+
+//	int inflate(z_stream *strm);
+//
+//    inflate decompresses as much data as possible, and stops when the input
+//  buffer becomes empty or the output buffer becomes full. It may some
+//  introduce some output latency (reading input without producing any output)
+//  except when forced to flush.
+//
+//  The detailed semantics are as follows. inflate performs one or both of the
+//  following actions:
+//
+//  - Decompress more input starting at next_in and update next_in and avail_in
+//    accordingly. If not all input can be processed (because there is not
+//    enough room in the output buffer), next_in is updated and processing
+//    will resume at this point for the next call of inflate().
+//
+//  - Provide more output starting at next_out and update next_out and avail_out
+//    accordingly.  inflate() provides as much output as possible, until there
+//    is no more input data or no more space in the output buffer (see below
+//    about the flush parameter).
+//
+//  Before the call of inflate(), the application should ensure that at least
+//  one of the actions is possible, by providing more input and/or consuming
+//  more output, and updating the next_* and avail_* values accordingly.
+//  The application can consume the uncompressed output when it wants, for
+//  example when the output buffer is full (avail_out == 0), or after each
+//  call of inflate(). If inflate returns Z_OK and with zero avail_out, it
+//  must be called again after making room in the output buffer because there
+//  might be more output pending.
+//
+//    If the parameter flush is set to Z_SYNC_FLUSH, inflate flushes as much
+//  output as possible to the output buffer. The flushing behavior of inflate is
+//  not specified for values of the flush parameter other than Z_SYNC_FLUSH
+//  and Z_FINISH, but the current implementation actually flushes as much output
+//  as possible anyway.
+//
+//    inflate() should normally be called until it returns Z_STREAM_END or an
+//  error. However if all decompression is to be performed in a single step
+//  (a single call of inflate), the parameter flush should be set to
+//  Z_FINISH. In this case all pending input is processed and all pending
+//  output is flushed; avail_out must be large enough to hold all the
+//  uncompressed data. (The size of the uncompressed data may have been saved
+//  by the compressor for this purpose.) The next operation on this stream must
+//  be inflateEnd to deallocate the decompression state. The use of Z_FINISH
+//  is never required, but can be used to inform inflate that a faster routine
+//  may be used for the single inflate() call.
+//
+//    It sets strm->adler to the adler32 checksum of all output produced
+//  so and returns Z_OK, Z_STREAM_END or
+//  an error code as described below. At the end of the stream, inflate()
+//  checks that its computed adler32 checksum is equal to that saved by the
+//  compressor and returns Z_STREAM_END only if the checksum is correct.
+//
+//    inflate() returns Z_OK if some progress has been made (more input processed
+//  or more output produced), Z_STREAM_END if the end of the compressed data has
+//  been reached and all uncompressed output has been produced, 
+//  Z_DATA_ERROR if the input data was
+//  corrupted (input stream not conforming to the zlib format or incorrect
+//  adler32 checksum), Z_STREAM_ERROR if the stream structure was inconsistent
+//  (for example if next_in or next_out was NULL),
+//  Z_BUF_ERROR if no progress is possible or if there was not
+//  enough room in the output buffer when Z_FINISH is used.
+
+//	int inflateEnd (z_stream *strm);
+//
+//     All dynamically allocated data structures for this stream are freed.
+//   This function discards any unprocessed input and does not flush any
+//   pending output.
+//
+//     inflateEnd returns Z_OK if success, Z_STREAM_ERROR if the stream state
+//   was inconsistent. In the error case, msg may be set but then points to a
+//   static string (which must not be deallocated).
+
+//	EStatus inflateInit(z_stream *strm, EFlush flush, int noWrap = 0);
+//
+//      inflateInit returns Z_OK if success,
+//   Z_STREAM_ERROR if a parameter is invalid.
+//   msg is set to "OK" if there is no error message. inflateInit
+//   does not perform any decompression apart from reading the zlib header if
+//   present: this will be done by inflate(). (So next_in and avail_in may be
+//   modified, but next_out and avail_out are unchanged.)
+
+//   Notes beyond the 1.93a appnote.txt:
+//
+//   1. Distance pointers never point before the beginning of the output
+//      stream.
+//   2. Distance pointers can point back across blocks, up to 32k away.
+//   3. There is an implied maximum of 7 bits for the bit length table and
+//      15 bits for the actual data.
+//   4. If only one code exists, then it is encoded using one bit.  (Zero
+//      would be more efficient, but perhaps a little confusing.)  If two
+//      codes exist, they are coded using one bit each (0 and 1).
+//   5. There is no way of sending zero distance codes--a dummy must be
+//      sent if there are none.  (History: a pre 2.0 version of PKZIP would
+//      store blocks with no distance codes, but this was discovered to be
+//      too harsh a criterion.)  Valid only for 1.93a.  2.04c does allow
+//      zero distance codes, which is sent as one code of zero bits in
+//      length.
+//   6. There are up to 286 literal/length codes.  Code 256 represents the
+//      end-of-block.  Note however that the static length tree defines
+//      288 codes just to fill out the Huffman codes.  Codes 286 and 287
+//      cannot be used though, since there is no length base or extra bits
+//      defined for them.  Similarily, there are up to 30 distance codes.
+//      However, static trees define 32 codes (all 5 bits) to fill out the
+//      Huffman codes, but the last two had better not show up in the data.
+//   7. Unzip can check dynamic Huffman blocks for complete code sets.
+//      The exception is that a single code would not be complete (see #4).
+//   8. The five bits following the block type is really the number of
+//      literal codes sent minus 257.
+//   9. Length codes 8,16,16 are interpreted as 13 length codes of 8 bits
+//      (1+6+6).  Therefore, to output three times the length, you output
+//      three codes (1+1+1), whereas to output four times the same length,
+//      you only need two codes (1+3).  Hmm.
+//  10. In the tree reconstruction algorithm, Code = Code + Increment
+//      only if BitLength(i) is not zero.  (Pretty obvious.)
+//  11. Correction: 4 Bits: # of Bit Length codes - 4     (4 - 19)
+//  12. Note: length code 284 can represent 227-258, but length code 285
+//      really is 258.  The last length deserves its own, short code
+//      since it gets used a lot in very redundant files.  The length
+//      258 is special since 258 - 3 (the min match length) is 255.
+//  13. The literal/length and distance code bit lengths are read as a
+//      single stream of lengths.  It is possible (and advantageous) for
+//      a repeat code (16, 17, or 18) to go across the boundary between
+//      the two sets of lengths.
+
+// And'ing with mask[n] masks the lower n bits
+static const ulong inflate_mask[17] = 
+{
+    0x0000,
+    0x0001, 0x0003, 0x0007, 0x000f, 0x001f, 0x003f, 0x007f, 0x00ff,
+    0x01ff, 0x03ff, 0x07ff, 0x0fff, 0x1fff, 0x3fff, 0x7fff, 0xffff
+};
+
+// Order of the bit length code lengths
+static const ulong border[] = 
+{ 
+	16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15
+};
+
+// Copy lengths for literal codes 257..285 (see note #13 above about 258)
+static const ulong cplens[31] = 
+{ 
+	3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31,
+	35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0
+};
+
+// Extra bits for literal codes 257..285 (112 == invalid)
+static const ulong cplext[31] = 
+{ 
+	0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2,
+	3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, 112, 112
+}; 
+
+// Copy offsets for distance codes 0..29
+static const ulong cpdist[30] = 
+{ 
+	1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193,
+	257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145,
+	8193, 12289, 16385, 24577
+};
+
+static ulong fixed_bl = 9;
+static ulong fixed_bd = 5;
+
+static inflate_huft_t fixed_tl[] = 
+{
+    { 96, 7, 256 }, { 0, 8, 80  }, { 0, 8, 16 }, { 84,  8, 115 },
+    { 82, 7, 31  }, { 0, 8, 112 }, { 0, 8, 48 }, { 0,   9, 192 },
+    { 80, 7, 10  }, { 0, 8, 96  }, { 0, 8, 32 }, { 0,   9, 160 },
+    { 0,  8, 0   }, { 0, 8, 128 }, { 0, 8, 64 }, { 0,   9, 224 },
+    { 80, 7, 6   }, { 0, 8, 88  }, { 0, 8, 24 }, { 0,   9, 144 },
+    { 83, 7, 59  }, { 0, 8, 120 }, { 0, 8, 56 }, { 0,   9, 208 },
+    { 81, 7, 17  }, { 0, 8, 104 }, { 0, 8, 40 }, { 0,   9, 176 },
+    { 0,  8, 8   }, { 0, 8, 136 }, { 0, 8, 72 }, { 0,   9, 240 },
+    { 80, 7, 4   }, { 0, 8, 84  }, { 0, 8, 20 }, { 85,  8, 227 },
+    { 83, 7, 43  }, { 0, 8, 116 }, { 0, 8, 52 }, { 0,   9, 200 },
+    { 81, 7, 13  }, { 0, 8, 100 }, { 0, 8, 36 }, { 0,   9, 168 },
+    { 0,  8, 4   }, { 0, 8, 132 }, { 0, 8, 68 }, { 0,   9, 232 },
+    { 80, 7, 8   }, { 0, 8, 92  }, { 0, 8, 28 }, { 0,   9, 152 },
+    { 84, 7, 83  }, { 0, 8, 124 }, { 0, 8, 60 }, { 0,   9, 216 },
+    { 82, 7, 23  }, { 0, 8, 108 }, { 0, 8, 44 }, { 0,   9, 184 },
+    { 0,  8, 12  }, { 0, 8, 140 }, { 0, 8, 76 }, { 0,   9, 248 },
+    { 80, 7, 3   }, { 0, 8, 82  }, { 0, 8, 18 }, { 85,  8, 163 },
+    { 83, 7, 35  }, { 0, 8, 114 }, { 0, 8, 50 }, { 0,   9, 196 },
+    { 81, 7, 11  }, { 0, 8, 98  }, { 0, 8, 34 }, { 0,   9, 164 },
+    { 0,  8, 2   }, { 0, 8, 130 }, { 0, 8, 66 }, { 0,   9, 228 },
+    { 80, 7, 7   }, { 0, 8, 90  }, { 0, 8, 26 }, { 0,   9, 148 },
+    { 84, 7, 67  }, { 0, 8, 122 }, { 0, 8, 58 }, { 0,   9, 212 },
+    { 82, 7, 19  }, { 0, 8, 106 }, { 0, 8, 42 }, { 0,   9, 180 },
+    { 0,  8, 10  }, { 0, 8, 138 }, { 0, 8, 74 }, { 0,   9, 244 },
+    { 80, 7, 5   }, { 0, 8, 86  }, { 0, 8, 22 }, { 192, 8, 0   }, 
+    { 83, 7, 51  }, { 0, 8, 118 }, { 0, 8, 54 }, { 0,   9, 204 },
+    { 81, 7, 15  }, { 0, 8, 102 }, { 0, 8, 38 }, { 0,   9, 172 },
+    { 0,  8, 6   }, { 0, 8, 134 }, { 0, 8, 70 }, { 0,   9, 236 },
+    { 80, 7, 9   }, { 0, 8, 94  }, { 0, 8, 30 }, { 0,   9, 156 },
+    { 84, 7, 99  }, { 0, 8, 126 }, { 0, 8, 62 }, { 0,   9, 220 },
+    { 82, 7, 27  }, { 0, 8, 110 }, { 0, 8, 46 }, { 0,   9, 188 },
+    { 0,  8, 14  }, { 0, 8, 142 }, { 0, 8, 78 }, { 0,   9, 252 },
+    { 96, 7, 256 }, { 0, 8, 81  }, { 0, 8, 17 }, { 85,  8, 131 },
+    { 82, 7, 31  }, { 0, 8, 113 }, { 0, 8, 49 }, { 0,   9, 194 },
+    { 80, 7, 10  }, { 0, 8, 97  }, { 0, 8, 33 }, { 0,   9, 162 },
+    { 0,  8, 1   }, { 0, 8, 129 }, { 0, 8, 65 }, { 0,   9, 226 },
+    { 80, 7, 6   }, { 0, 8, 89  }, { 0, 8, 25 }, { 0,   9, 146 },
+    { 83, 7, 59  }, { 0, 8, 121 }, { 0, 8, 57 }, { 0,   9, 210 },
+    { 81, 7, 17  }, { 0, 8, 105 }, { 0, 8, 41 }, { 0,   9, 178 },
+    { 0,  8, 9   }, { 0, 8, 137 }, { 0, 8, 73 }, { 0,   9, 242 },
+    { 80, 7, 4   }, { 0, 8, 85  }, { 0, 8, 21 }, { 80,  8, 258 },
+    { 83, 7, 43  }, { 0, 8, 117 }, { 0, 8, 53 }, { 0,   9, 202 },
+    { 81, 7, 13  }, { 0, 8, 101 }, { 0, 8, 37 }, { 0,   9, 170 },
+    { 0,  8, 5   }, { 0, 8, 133 }, { 0, 8, 69 }, { 0,   9, 234 },
+    { 80, 7, 8   }, { 0, 8, 93  }, { 0, 8, 29 }, { 0,   9, 154 },
+    { 84, 7, 83  }, { 0, 8, 125 }, { 0, 8, 61 }, { 0,   9, 218 },
+    { 82, 7, 23  }, { 0, 8, 109 }, { 0, 8, 45 }, { 0,   9, 186 },
+    { 0,  8, 13  }, { 0, 8, 141 }, { 0, 8, 77 }, { 0,   9, 250 },
+    { 80, 7, 3   }, { 0, 8, 83  }, { 0, 8, 19 }, { 85,  8, 195 },
+    { 83, 7, 35  }, { 0, 8, 115 }, { 0, 8, 51 }, { 0,   9, 198 },
+    { 81, 7, 11  }, { 0, 8, 99  }, { 0, 8, 35 }, { 0,   9, 166 },
+    { 0,  8, 3   }, { 0, 8, 131 }, { 0, 8, 67 }, { 0,   9, 230 },
+    { 80, 7, 7   }, { 0, 8, 91  }, { 0, 8, 27 }, { 0,   9, 150 },
+    { 84, 7, 67  }, { 0, 8, 123 }, { 0, 8, 59 }, { 0,   9, 214 },
+    { 82, 7, 19  }, { 0, 8, 107 }, { 0, 8, 43 }, { 0,   9, 182 },
+    { 0,  8, 11  }, { 0, 8, 139 }, { 0, 8, 75 }, { 0,   9, 246 },
+    { 80, 7, 5   }, { 0, 8, 87  }, { 0, 8, 23 }, { 192, 8, 0   }, 
+    { 83, 7, 51  }, { 0, 8, 119 }, { 0, 8, 55 }, { 0,   9, 206 },
+    { 81, 7, 15  }, { 0, 8, 103 }, { 0, 8, 39 }, { 0,   9, 174 },
+    { 0,  8, 7   }, { 0, 8, 135 }, { 0, 8, 71 }, { 0,   9, 238 },
+    { 80, 7, 9   }, { 0, 8, 95  }, { 0, 8, 31 }, { 0,   9, 158 },
+    { 84, 7, 99  }, { 0, 8, 127 }, { 0, 8, 63 }, { 0,   9, 222 },
+    { 82, 7, 27  }, { 0, 8, 111 }, { 0, 8, 47 }, { 0,   9, 190 },
+    { 0,  8, 15  }, { 0, 8, 143 }, { 0, 8, 79 }, { 0,   9, 254 },
+    { 96, 7, 256 }, { 0, 8, 80  }, { 0, 8, 16 }, { 84,  8, 115 },
+    { 82, 7, 31  }, { 0, 8, 112 }, { 0, 8, 48 }, { 0,   9, 193 },
+    { 80, 7, 10  }, { 0, 8, 96  }, { 0, 8, 32 }, { 0,   9, 161 },
+    { 0,  8, 0   }, { 0, 8, 128 }, { 0, 8, 64 }, { 0,   9, 225 },
+    { 80, 7, 6   }, { 0, 8, 88  }, { 0, 8, 24 }, { 0,   9, 145 },
+    { 83, 7, 59  }, { 0, 8, 120 }, { 0, 8, 56 }, { 0,   9, 209 },
+    { 81, 7, 17  }, { 0, 8, 104 }, { 0, 8, 40 }, { 0,   9, 177 },
+    { 0,  8, 8   }, { 0, 8, 136 }, { 0, 8, 72 }, { 0,   9, 241 },
+    { 80, 7, 4   }, { 0, 8, 84  }, { 0, 8, 20 }, { 85,  8, 227 },
+    { 83, 7, 43  }, { 0, 8, 116 }, { 0, 8, 52 }, { 0,   9, 201 },
+    { 81, 7, 13  }, { 0, 8, 100 }, { 0, 8, 36 }, { 0,   9, 169 },
+    { 0,  8, 4   }, { 0, 8, 132 }, { 0, 8, 68 }, { 0,   9, 233 },
+    { 80, 7, 8   }, { 0, 8, 92  }, { 0, 8, 28 }, { 0,   9, 153 },
+    { 84, 7, 83  }, { 0, 8, 124 }, { 0, 8, 60 }, { 0,   9, 217 },
+    { 82, 7, 23  }, { 0, 8, 108 }, { 0, 8, 44 }, { 0,   9, 185 },
+    { 0,  8, 12  }, { 0, 8, 140 }, { 0, 8, 76 }, { 0,   9, 249 },
+    { 80, 7, 3   }, { 0, 8, 82  }, { 0, 8, 18 }, { 85,  8, 163 },
+    { 83, 7, 35  }, { 0, 8, 114 }, { 0, 8, 50 }, { 0,   9, 197 },
+    { 81, 7, 11  }, { 0, 8, 98  }, { 0, 8, 34 }, { 0,   9, 165 },
+    { 0,  8, 2   }, { 0, 8, 130 }, { 0, 8, 66 }, { 0,   9, 229 },
+    { 80, 7, 7   }, { 0, 8, 90  }, { 0, 8, 26 }, { 0,   9, 149 },
+    { 84, 7, 67  }, { 0, 8, 122 }, { 0, 8, 58 }, { 0,   9, 213 },
+    { 82, 7, 19  }, { 0, 8, 106 }, { 0, 8, 42 }, { 0,   9, 181 },
+    { 0,  8, 10  }, { 0, 8, 138 }, { 0, 8, 74 }, { 0,   9, 245 },
+    { 80, 7, 5   }, { 0, 8, 86  }, { 0, 8, 22 }, { 192, 8, 0   }, 
+    { 83, 7, 51  }, { 0, 8, 118 }, { 0, 8, 54 }, { 0,   9, 205 },
+    { 81, 7, 15  }, { 0, 8, 102 }, { 0, 8, 38 }, { 0,   9, 173 },
+    { 0,  8, 6   }, { 0, 8, 134 }, { 0, 8, 70 }, { 0,   9, 237 },
+    { 80, 7, 9   }, { 0, 8, 94  }, { 0, 8, 30 }, { 0,   9, 157 },
+    { 84, 7, 99  }, { 0, 8, 126 }, { 0, 8, 62 }, { 0,   9, 221 },
+    { 82, 7, 27  }, { 0, 8, 110 }, { 0, 8, 46 }, { 0,   9, 189 },
+    { 0,  8, 14  }, { 0, 8, 142 }, { 0, 8, 78 }, { 0,   9, 253 },
+    { 96, 7, 256 }, { 0, 8, 81  }, { 0, 8, 17 }, { 85,  8, 131 },
+    { 82, 7, 31  }, { 0, 8, 113 }, { 0, 8, 49 }, { 0,   9, 195 },
+    { 80, 7, 10  }, { 0, 8, 97  }, { 0, 8, 33 }, { 0,   9, 163 },
+    { 0,  8, 1   }, { 0, 8, 129 }, { 0, 8, 65 }, { 0,   9, 227 },
+    { 80, 7, 6   }, { 0, 8, 89  }, { 0, 8, 25 }, { 0,   9, 147 },
+    { 83, 7, 59  }, { 0, 8, 121 }, { 0, 8, 57 }, { 0,   9, 211 },
+    { 81, 7, 17  }, { 0, 8, 105 }, { 0, 8, 41 }, { 0,   9, 179 },
+    { 0,  8, 9   }, { 0, 8, 137 }, { 0, 8, 73 }, { 0,   9, 243 },
+    { 80, 7, 4   }, { 0, 8, 85  }, { 0, 8, 21 }, { 80,  8, 258 },
+    { 83, 7, 43  }, { 0, 8, 117 }, { 0, 8, 53 }, { 0,   9, 203 },
+    { 81, 7, 13  }, { 0, 8, 101 }, { 0, 8, 37 }, { 0,   9, 171 },
+    { 0,  8, 5   }, { 0, 8, 133 }, { 0, 8, 69 }, { 0,   9, 235 },
+    { 80, 7, 8   }, { 0, 8, 93  }, { 0, 8, 29 }, { 0,   9, 155 },
+    { 84, 7, 83  }, { 0, 8, 125 }, { 0, 8, 61 }, { 0,   9, 219 },
+    { 82, 7, 23  }, { 0, 8, 109 }, { 0, 8, 45 }, { 0,   9, 187 },
+    { 0,  8, 13  }, { 0, 8, 141 }, { 0, 8, 77 }, { 0,   9, 251 },
+    { 80, 7, 3   }, { 0, 8, 83  }, { 0, 8, 19 }, { 85,  8, 195 },
+    { 83, 7, 35  }, { 0, 8, 115 }, { 0, 8, 51 }, { 0,   9, 199 },
+    { 81, 7, 11  }, { 0, 8, 99  }, { 0, 8, 35 }, { 0,   9, 167 },
+    { 0,  8, 3   }, { 0, 8, 131 }, { 0, 8, 67 }, { 0,   9, 231 },
+    { 80, 7, 7   }, { 0, 8, 91  }, { 0, 8, 27 }, { 0,   9, 151 },
+    { 84, 7, 67  }, { 0, 8, 123 }, { 0, 8, 59 }, { 0,   9, 215 },
+    { 82, 7, 19  }, { 0, 8, 107 }, { 0, 8, 43 }, { 0,   9, 183 },
+    { 0,  8, 11  }, { 0, 8, 139 }, { 0, 8, 75 }, { 0,   9, 247 },
+    { 80, 7, 5   }, { 0, 8, 87  }, { 0, 8, 23 }, { 192, 8, 0   }, 
+    { 83, 7, 51  }, { 0, 8, 119 }, { 0, 8, 55 }, { 0,   9, 207 },
+    { 81, 7, 15  }, { 0, 8, 103 }, { 0, 8, 39 }, { 0,   9, 175 },
+    { 0,  8, 7   }, { 0, 8, 135 }, { 0, 8, 71 }, { 0,   9, 239 },
+    { 80, 7, 9   }, { 0, 8, 95  }, { 0, 8, 31 }, { 0,   9, 159 },
+    { 84, 7, 99  }, { 0, 8, 127 }, { 0, 8, 63 }, { 0,   9, 223 },
+    { 82, 7, 27  }, { 0, 8, 111 }, { 0, 8, 47 }, { 0,   9, 191 },
+    { 0,  8, 15  }, { 0, 8, 143 }, { 0, 8, 79 }, { 0,   9, 255 }
+};
+
+static inflate_huft_t fixed_td[] = 
+{
+    { 80, 5, 1  }, { 87, 5, 257  }, { 83, 5, 17  }, { 91,  5, 4097  },
+    { 81, 5, 5  }, { 89, 5, 1025 }, { 85, 5, 65  }, { 93,  5, 16385 },
+    { 80, 5, 3  }, { 88, 5, 513  }, { 84, 5, 33  }, { 92,  5, 8193  },
+    { 82, 5, 9  }, { 90, 5, 2049 }, { 86, 5, 129 }, { 192, 5, 24577 },
+    { 80, 5, 2  }, { 87, 5, 385  }, { 83, 5, 25  }, { 91,  5, 6145  },
+    { 81, 5, 7  }, { 89, 5, 1537 }, { 85, 5, 97  }, { 93,  5, 24577 },
+    { 80, 5, 4  }, { 88, 5, 769  }, { 84, 5, 49  }, { 92,  5, 12289 },
+    { 82, 5, 13 }, { 90, 5, 3073 }, { 86, 5, 193 }, { 192, 5, 24577 }
+};
+
+// ===============================================================================
+// ===============================================================================
+
+static void inflate_blocks_reset(z_stream *z, inflate_blocks_state_t *s)
+{
+	if((s->mode == BTREE) || (s->mode == DTREE))
+	{
+		Z_Free(s->trees.blens);
+	}
+	if(s->mode == CODES)
+	{
+		Z_Free(s->decode.codes);
+	}
+	s->mode = TYPE;
+	s->bitk = 0;
+	s->bitb = 0;
+	s->write = s->window;
+	s->read = s->window;
+	z->istate->adler = 1;
+}
+
+// ===============================================================================
+// ===============================================================================
+
+static int inflate_blocks_free(z_stream *z, inflate_blocks_state_t *s)
+{
+	inflate_blocks_reset(z, s);
+	Z_Free(s->hufts);
+	s->hufts = NULL;
+	Z_Free(s);
+	return(Z_OK);
+}
+
+// ===============================================================================
+// ===============================================================================
+
+static inflate_blocks_state_t *inflate_blocks_new(z_stream *z, check_func check)
+{
+	inflate_blocks_state_t *s;
+
+	s = (inflate_blocks_state_t *)Z_Malloc(sizeof(inflate_blocks_state_t), TAG_INFLATE, qtrue);
+	s->hufts = (inflate_huft_t *)Z_Malloc(sizeof(inflate_huft_t) * MANY, TAG_INFLATE, qtrue);
+	s->end = s->window + WINDOW_SIZE;
+	s->mode = TYPE;
+	inflate_blocks_reset(z, s);
+
+	return(s);
+}
+
+// ===============================================================================
+// copy as much as possible from the sliding window to the output area
+// ===============================================================================
+
+static void inflate_flush_copy(z_stream *z, inflate_blocks_state_t *s, ulong count)
+{
+	if(count > z->avail_out)
+	{
+		count = z->avail_out;
+	}
+	if(count && (z->error == Z_BUF_ERROR))
+	{
+		z->error = Z_OK;
+	}
+
+	// Calculate the checksum if required
+	if(!z->istate->nowrap)
+	{
+		z->istate->adler = adler32(z->istate->adler, s->read, count);
+	}
+
+	// copy as as end of window
+	memcpy(z->next_out, s->read, count);
+
+	// update counters
+	z->avail_out -= count;
+	z->total_out += count;
+	z->next_out += count;
+	s->read += count;
+}
+
+// ===============================================================================
+// ===============================================================================
+
+static void inflate_flush(z_stream *z, inflate_blocks_state_t *s)
+{
+	ulong	count;
+
+	// compute number of bytes to copy as as end of window
+	count = (s->read <= s->write ? s->write : s->end) - s->read;
+
+	inflate_flush_copy(z, s, count);
+
+	// see if more to copy at beginning of window
+	if(s->read == s->end)
+	{
+		// wrap pointers
+		s->read = s->window;
+		if(s->write == s->end)
+		{
+			s->write = s->window;
+		}
+		// compute bytes to copy
+		count = s->write - s->read;
+		inflate_flush_copy(z, s, count);
+	}
+}
+
+// ===============================================================================
+// get bytes and bits
+// ===============================================================================
+
+static bool getbits(z_stream *z, inflate_blocks_state_t *s, ulong bits)								 
+{			
+	while(s->bitk < bits) 							
+	{											
+		if(z->avail_in)
+		{
+			z->error = Z_OK;
+		}
+		else
+		{										
+			inflate_flush(z, s);
+			return(false);
+		}		  
+		z->avail_in--;
+		z->total_in++;
+		s->bitb |= *z->next_in++ << s->bitk;			
+		s->bitk += 8; 	 
+	}		
+	return(true);
+}
+
+// ===============================================================================
+// output bytes
+// ===============================================================================
+
+static ulong needout(z_stream *z, inflate_blocks_state_t *s, ulong bytesToEnd) 
+{ 
+	if(!bytesToEnd)
+	{ 
+		if((s->write == s->end) && (s->read != s->window)) 
+		{ 
+			s->write = s->window;
+			bytesToEnd = s->write < s->read ? s->read - s->write - 1 : s->end - s->write;
+		}
+		if(!bytesToEnd)
+		{
+			inflate_flush(z, s);
+			bytesToEnd = s->write < s->read ? s->read - s->write - 1 : s->end - s->write;
+			if((s->write == s->end) && (s->read != s->window))
+			{
+				s->write = s->window;
+				bytesToEnd = s->write < s->read ? s->read - s->write - 1 : s->end - s->write;
+			}
+			if(!bytesToEnd)
+			{
+				inflate_flush(z, s);
+				return(bytesToEnd);
+			}
+		}
+	}
+	z->error = Z_OK;
+	return(bytesToEnd);
+}
+
+// ===============================================================================
+// Called with number of bytes left to write in window at least 258
+//	 (the maximum string length) and number of input bytes available
+//	 at least ten.	The ten bytes are six bytes for the longest length/
+//	 distance pair plus four bytes for overloading the bit buffer.
+// ===============================================================================
+
+inline byte *qcopy(byte *dst, byte *src, int count)
+{
+	byte 	*retval;
+	_asm
+	{
+		push ecx  
+		push esi
+		push edi
+
+		mov edi, [dst]
+		mov esi, [src]
+		mov ecx, [count]
+		rep movsb
+
+		mov [retval], edi
+		pop edi
+		pop esi
+		pop ecx
+	}
+	return(retval);
+}
+
+inline ulong get_remaining(inflate_blocks_state_t *s)
+{
+	if(s->write < s->read)
+	{
+		return(s->read - s->write - 1);
+	}
+	return(s->end - s->write); 
+}
+
+static EStatus inflate_fast(ulong lengthMask, ulong distMask, inflate_huft_t *lengthTree, inflate_huft_t *distTree, inflate_blocks_state_t *s, z_stream *z)
+{
+	inflate_huft_t	*huft;			// temporary pointer
+	byte			*data;			
+	byte			*src; 			// copy source pointer
+	byte			*dst;			
+	ulong			extraBits;		// extra bits or operation
+	ulong			bytesToEnd;		// bytes to end of window or read pointer
+	ulong			count;			// bytes to copy
+	ulong			dist;			// distance back to copy from
+	ulong			bitb;
+	ulong			bitk;
+	ulong			availin;
+	ulong			morebits;
+	ulong			copymore;
+
+	// load input, output, bit values
+	data = z->next_in;
+	dst = s->write;
+	availin = z->avail_in;
+	bitb = s->bitb;
+	bitk = s->bitk;
+
+	bytesToEnd = get_remaining(s);
+
+	// do until not enough input or output space for fast loop
+	// assume called with bytesToEnd >= 258 && availIn >= 10
+	while((bytesToEnd >= 258) && (availin >= 10))
+	{						   
+		// get literal/length code
+		while(bitk < 20)
+		{
+			bitb |= *data++ << bitk;
+			bitk += 8;
+			availin--;
+		}
+
+		huft = lengthTree + (bitb & lengthMask);
+		if(!huft->Exop)
+		{
+			bitb >>= huft->Bits;
+			bitk -= huft->Bits;
+			*dst++ = (byte)huft->base;
+			bytesToEnd--;
+		}
+		else
+		{
+			extraBits = huft->Exop;
+			morebits = 1;
+			do
+			{
+				bitb >>= huft->Bits; 
+				bitk -= huft->Bits;
+				if(extraBits & 16)
+				{
+					// get extra bits for length
+					extraBits &= 15;
+					count = huft->base + (bitb & inflate_mask[extraBits]);
+					bitb >>= extraBits;
+					bitk -= extraBits;
+					// decode distance base of block to copy
+					while(bitk < 15)
+					{
+						bitb |= *data++ << bitk;
+						bitk += 8;
+						availin--;
+					}
+					huft = distTree + (bitb & distMask);
+					extraBits = huft->Exop;
+	   				copymore = 1;
+					do
+					{
+						bitb >>= huft->Bits;
+						bitk -= huft->Bits;
+						if(extraBits & 16)
+						{
+							// get extra bits to add to distance base
+							extraBits &= 15;
+							while(bitk < extraBits)
+							{
+								bitb |= *data++ << bitk;
+								bitk += 8;
+								availin--;
+							}
+							dist = huft->base + (bitb & inflate_mask[extraBits]);
+							bitb >>= extraBits;
+							bitk -= extraBits;
+
+							// do the copy
+							bytesToEnd -= count;
+							// offset before dest
+							if((dst - s->window) >= dist)	 
+							{								   
+								// just copy
+								src = dst - dist;
+							}
+							// else offset after destination
+							else						
+							{
+								// bytes from offset to end
+								extraBits = dist - (dst - s->window);
+								// pointer to offset
+								src = s->end - extraBits; 		  
+								// if source crosses,					  
+								if(count > extraBits)				  
+								{
+									// copy to end of window
+									dst = qcopy(dst, src, extraBits);
+									// copy rest from start of window
+									count -= extraBits; 				
+									src = s->window;			
+								}
+							}
+							// copy all or what's left
+							dst = qcopy(dst, src, count);
+							copymore = 0;
+						}
+						else
+						{
+							if(!(extraBits & 64))
+							{
+								huft += huft->base + (bitb & inflate_mask[extraBits]);
+								extraBits = huft->Exop;
+							}
+							else
+							{
+								inflate_error = "Inflate data: Invalid distance code";
+								return(Z_DATA_ERROR);
+							}
+						}
+					} while(copymore);
+
+					morebits = 0;
+				}
+				else
+				{
+					if(!(extraBits & 64))
+					{
+						huft += huft->base + (bitb & inflate_mask[extraBits]);
+						extraBits = huft->Exop;
+						if(!extraBits)								   
+						{
+							bitb >>= huft->Bits;
+							bitk -= huft->Bits;
+							*dst++ = (byte)huft->base;
+							bytesToEnd--;
+							morebits = 0;
+						}
+					}
+					else if(extraBits & 32)									 
+					{
+						count = data - z->next_in;
+
+						z->avail_in = availin;
+						z->total_in += count;
+						z->next_in = data;
+
+						s->write = dst;
+
+						count = (bitk >> 3) < count ? bitk >> 3 : count;
+
+						s->bitb = bitb;
+						s->bitk = bitk - (count << 3);
+						z->avail_in += count;
+						z->total_in -= count;
+						z->next_in -= count ;
+						return(Z_STREAM_END);
+					}
+					else
+					{
+						inflate_error = "Inflate data: Invalid literal/length code";
+						return(Z_DATA_ERROR);
+					}
+				}
+			} while(morebits);
+		}
+	}
+
+	// not enough input or output--restore pointers and return
+	count = data - z->next_in;
+
+	z->avail_in = availin;
+	z->total_in += count;
+	z->next_in = data;
+
+	s->write = dst;
+
+	count = (bitk >> 3) < count ? bitk >> 3 : count;
+	s->bitb = bitb;
+	s->bitk = bitk - (count << 3);
+	z->avail_in += count;
+	z->total_in -= count;
+	z->next_in -= count;
+
+	return(Z_OK);
+}
+
+// ===============================================================================
+// ===============================================================================
+
+static void inflate_codes(z_stream *z, inflate_blocks_state_t *s)
+{
+	inflate_huft_t			*huft; 		// temporary pointer
+	ulong					extraBits;	// extra bits or operation
+	ulong					bytesToEnd;	// bytes to end of window or read pointer
+	byte					*src; 		// pointer to copy strings from
+	inflate_codes_state_t	*infCodes;	// codes state
+
+	infCodes = s->decode.codes;
+
+	// copy input/output information to locals
+	bytesToEnd = get_remaining(s);
+
+	// process input and output based on current state
+	while(true)
+	{
+		// waiting for "i:"=input, "o:"=output, "x:"=nothing
+		switch (infCodes->mode)
+		{			  
+		// x: set up for LEN
+		case START:
+			if((bytesToEnd >= 258) && (z->avail_in >= 10))
+			{
+				z->error = inflate_fast(inflate_mask[infCodes->lbits], inflate_mask[infCodes->dbits], infCodes->ltree, infCodes->dtree, s, z);
+				bytesToEnd = get_remaining(s);
+				if(z->error != Z_OK)
+				{
+					infCodes->mode = (z->error == Z_STREAM_END) ? WASH : BADCODE;
+					break;
+				}
+			}
+			infCodes->code.need = infCodes->lbits;
+			infCodes->code.tree = infCodes->ltree;
+			infCodes->mode = LEN;
+		// i: get length/literal/eob next
+		case LEN:			
+			if(!getbits(z, s, infCodes->code.need))
+			{
+				// We could get here because we have run out of input data *or* the stream has ended
+				if(z->status == Z_BUF_ERROR)
+				{
+					z->error = Z_STREAM_END;
+				}
+				return;
+			}
+			huft = infCodes->code.tree + (s->bitb & inflate_mask[infCodes->code.need]);
+			s->bitb >>= huft->Bits;
+			s->bitk -= huft->Bits; 
+			extraBits = huft->Exop;
+			// literal
+			if(!extraBits)				 
+			{
+				infCodes->lit = huft->base;
+				infCodes->mode = LIT;
+				break;
+			}
+			// length
+			if(extraBits & 16) 			  
+			{
+				infCodes->copy.get = extraBits & 15;
+				infCodes->len = huft->base;
+				infCodes->mode = LENEXT;
+				break;
+			}
+			// next table
+			if(!(extraBits & 64))
+			{
+				infCodes->code.need = extraBits;
+				infCodes->code.tree = huft + huft->base;
+				break;
+			}
+			// end of block
+			if(extraBits & 32) 			  
+			{
+				infCodes->mode = WASH;
+				break;
+			}
+			// invalid code
+			infCodes->mode = BADCODE;		  
+			inflate_error = "Inflate data: Invalid literal/length code";
+			z->error = Z_DATA_ERROR;
+			inflate_flush(z, s);
+			return;
+		// i: getting length extra (have base)
+		case LENEXT:		
+			if(!getbits(z, s, infCodes->copy.get))
+			{
+				return;
+			}
+			infCodes->len += s->bitb & inflate_mask[infCodes->copy.get];
+			s->bitb >>= infCodes->copy.get;
+			s->bitk -= infCodes->copy.get;
+			infCodes->code.need = infCodes->dbits;
+			infCodes->code.tree = infCodes->dtree;
+			infCodes->mode = DIST;
+		// i: get distance next
+		case DIST:			
+			if(!getbits(z, s, infCodes->code.need))
+			{
+				return;
+			}
+			huft = infCodes->code.tree + (s->bitb & inflate_mask[infCodes->code.need]);
+			s->bitb >>= huft->Bits;
+			s->bitk -= huft->Bits;
+			extraBits = huft->Exop;
+			// distance
+			if(extraBits & 16) 			  
+			{
+				infCodes->copy.get = extraBits & 15;
+				infCodes->copy.dist = huft->base;
+				infCodes->mode = DISTEXT;
+				break;
+			}
+			// next table
+			if(!(extraBits & 64))
+			{
+				infCodes->code.need = extraBits;
+				infCodes->code.tree = huft + huft->base;
+				break;
+			}
+			// invalid code
+			infCodes->mode = BADCODE;		  
+			inflate_error = "Inflate data: Invalid distance code";
+			z->error = Z_DATA_ERROR;
+			inflate_flush(z, s);
+			return;
+		// i: getting distance extra
+		case DISTEXT:		
+			if(!getbits(z, s, infCodes->copy.get))
+			{
+				return;
+			}
+			infCodes->copy.dist += s->bitb & inflate_mask[infCodes->copy.get];
+			s->bitb >>= infCodes->copy.get;
+			s->bitk -= infCodes->copy.get;
+			infCodes->mode = COPY;
+		// o: copying bytes in window, waiting for space
+		case COPY:			
+			if(s->write - s->window < infCodes->copy.dist)
+			{
+				src = s->end - (infCodes->copy.dist - (s->write - s->window));
+			}
+			else
+			{
+				src = s->write - infCodes->copy.dist;
+			}
+			while(infCodes->len)
+			{
+				bytesToEnd = needout(z, s, bytesToEnd);
+				if(!bytesToEnd)
+				{
+					return;
+				}
+				*s->write++ = (byte)(*src++);
+				bytesToEnd--;
+				if(src == s->end)
+				{
+					src = s->window;
+				}
+				infCodes->len--;
+			}
+			infCodes->mode = START;
+			break;
+		// o: got literal, waiting for output space
+		case LIT:			
+			bytesToEnd = needout(z, s, bytesToEnd);
+			if(!bytesToEnd)
+			{
+				return;
+			}
+			*s->write++ = (byte)infCodes->lit; 
+			bytesToEnd--;
+			infCodes->mode = START;
+			break;
+		// o: got eob, possibly more output
+		case WASH:			
+			// return unused byte, if any
+			if(s->bitk > 7)		  
+			{
+				s->bitk -= 8;
+				z->avail_in++;
+				z->total_in--;
+				// can always return one
+				z->next_in--;			
+			}
+			inflate_flush(z, s);
+			bytesToEnd = get_remaining(s);
+			if(s->read != s->write)
+			{
+				inflate_error = "Inflate data: read != write while in WASH";
+				inflate_flush(z, s);
+				return;
+			}
+			infCodes->mode = END;
+		case END:
+			z->error = Z_STREAM_END;
+			inflate_flush(z, s);
+			return;
+		// x: got error
+		case BADCODE:		
+			z->error = Z_DATA_ERROR;
+			inflate_flush(z, s);
+			return;
+		default:
+			z->error = Z_STREAM_ERROR;
+			inflate_flush(z, s);
+			return;
+		}
+	}
+}
+
+// ===============================================================================
+// ===============================================================================
+
+static inflate_codes_state_t *inflate_codes_new(z_stream *z, ulong bl, ulong bd, inflate_huft_t *lengthTree, inflate_huft_t *distTree)
+{
+	inflate_codes_state_t		*c;
+
+	c = (inflate_codes_state_t *)Z_Malloc(sizeof(inflate_codes_state_t), TAG_INFLATE, qtrue);
+	c->mode = START;
+	c->lbits = (byte)bl;
+	c->dbits = (byte)bd;
+	c->ltree = lengthTree;
+	c->dtree = distTree;
+
+	return(c);
+}
+
+// ===============================================================================
+// Generate Huffman trees for efficient decoding
+
+//	ulong b				// code lengths in bits (all assumed <= BMAX)
+//	ulong n             // number of codes (assumed <= 288)
+//	ulong s             // number of simple-valued codes (0..s-1)
+//	const ulong *d      // list of base values for non-simple codes
+//	const ulong *e      // list of extra bits for non-simple codes
+//	inflate_huft ** t	// result: starting table
+//	ulong *m            // maximum lookup bits, returns actual
+//	inflate_huft *hp    // space for trees
+//	ulong *hn           // hufts used in space
+//	ulong *workspace    // working area: values in order of bit length
+//
+//   Given a list of code lengths and a maximum table size, make a set of
+//   tables to decode that set of codes.  Return Z_OK on success, Z_BUF_ERROR
+//   if the given code set is incomplete (the tables are still built in this
+//   case), Z_DATA_ERROR if the input is invalid (an over-subscribed set of
+//   lengths).
+//
+//   Huffman code decoding is performed using a multi-level table lookup.
+//   The fastest way to decode is to simply build a lookup table whose
+//   size is determined by the longest code.  However, the time it takes
+//   to build this table can also be a factor if the data being decoded
+//   is not very long.  The most common codes are necessarily the
+//   shortest codes, so those codes dominate the decoding time, and hence
+//   the speed.  The idea is you can have a shorter table that decodes the
+//   shorter, more probable codes, and then point to subsidiary tables for
+//   the longer codes.  The time it costs to decode the longer codes is
+//   then traded against the time it takes to make longer tables.
+//
+//   This results of this trade are in the variables lbits and dbits
+//   below.  lbits is the number of bits the first level table for literal/
+//   length codes can decode in one step, and dbits is the same thing for
+//   the distance codes.  Subsequent tables are also less than or equal to
+//   those sizes.  These values may be adjusted either when all of the
+//   codes are shorter than that, in which case the longest code length in
+//   bits is used, or when the shortest code is *longer* than the requested
+//   table size, in which case the length of the shortest code in bits is
+//   used.
+//
+//   There are two different values for the two tables, since they code a
+//   different number of possibilities each.  The literal/length table
+//   codes 286 possible values, or in a flat code, a little over eight
+//   bits.  The distance table codes 30 possible values, or a little less
+//   than five bits, flat.  The optimum values for speed end up being
+//   about one bit more than those, so lbits is 8+1 and dbits is 5+1.
+//   The optimum values may differ though from machine to machine, and
+//   possibly even between compilers.  Your mileage may vary.
+// ===============================================================================
+
+static EStatus huft_build(ulong *b, ulong numCodes, ulong s, const ulong *d, const ulong *e, inflate_huft_t **t, ulong *m, inflate_huft_t *hp, ulong *hn, ulong *workspace)
+{
+	ulong			codeCounter;					// counter for codes of length bitsPerCode
+	ulong			bitLengths[BMAX + 1] = { 0 };	// bit length count table
+	ulong			bitOffsets[BMAX + 1];			// bit offsets, then code stack
+	ulong			f;								// i repeats in table every f entries
+	int 			maxCodeLen;						// maximum code length
+	int 			tableLevel;						// table level
+	ulong			i;								// counter, current code
+	ulong			j;								// counter
+	int 			bitsPerCode;					// number of bits in current code
+	ulong 			bitsPerTable;					// bits per table (returned in m)
+	int 			bitsBeforeTable;				// bits before this table == (bitsPerTable * tableLevel)
+	ulong			*p; 							// pointer into bitLengths[], b[], or workspace[]
+	inflate_huft_t	*q; 							// points to current table
+	inflate_huft_t	r;								// table entry for structure assignment
+	inflate_huft_t	*tableStack[BMAX];				// table stack
+	ulong			*xp;							// pointer into bitOffsets
+	int 			dummyCodes;						// number of dummy codes added
+	ulong			entryCount;						// number of entries in current table
+
+	// Generate counts for each bit length
+	// assume all entries <= BMAX
+	p = b;	
+	i = numCodes;
+	do
+	{
+		bitLengths[*p++]++;					
+	} while(--i);
+
+	// null input--all zero length codes
+	if(bitLengths[0] == numCodes)				  
+	{
+		*t = NULL;
+		*m = 0;
+		return(Z_OK);
+	}
+
+	// Find minimum and maximum length, bound *m by those
+	bitsPerTable = *m;
+	for(j = 1; j <= BMAX; j++)
+	{
+		if(bitLengths[j])
+		{
+			break;
+		}
+	}
+	// minimum code length
+	bitsPerCode = j;						  
+
+	if(bitsPerTable < j)
+	{
+		bitsPerTable = j;
+	}
+	for(i = BMAX; i; i--)
+	{
+		if(bitLengths[i])
+		{
+			break;
+		}
+	}
+	// maximum code length
+	maxCodeLen = i;						  
+
+	if(bitsPerTable > i)
+	{
+		bitsPerTable = i;
+	}
+	*m = bitsPerTable;
+
+	// Adjust last length count to fill out codes, if needed
+	for(dummyCodes = 1 << j; j < i; j++, dummyCodes <<= 1)
+	{
+		dummyCodes -= bitLengths[j];
+		if(dummyCodes < 0)
+		{
+			return(Z_DATA_ERROR);
+		}
+	}
+	dummyCodes -= bitLengths[i];
+	if(dummyCodes < 0)
+	{
+		return(Z_DATA_ERROR);
+	}
+	bitLengths[i] += dummyCodes;
+
+	// Generate starting offsets into the value table for each length
+	bitOffsets[1] = 0;
+	j = 0;
+	p = bitLengths + 1;
+	xp = bitOffsets + 2;
+	// note that i == maxCodeLen from above
+	while(--i) 
+	{			 
+		j += *p++;
+		*xp++ = j;
+	}
+
+	// Make a table of values in order of bit lengths
+	p = b;
+	i = 0;
+	do
+	{
+		j = *p++;
+		if(j)
+		{
+			workspace[bitOffsets[j]++] = i;
+		}
+	} while(++i < numCodes);
+
+	// set numCodes to length of workspace
+	numCodes = bitOffsets[maxCodeLen];					  
+
+	// Generate the Huffman codes and for each, make the table entries
+	bitOffsets[0] = 0;						// first Huffman code is zero
+	i = 0;							
+	p = workspace;							// grab values in bit order
+	tableLevel = -1; 						// no tables yet--level -1
+	bitsBeforeTable = bitsPerTable; 						// bits decoded == (bitsPerTable * tableLevel)
+	bitsBeforeTable = -bitsBeforeTable;
+	tableStack[0] = NULL;	// just to keep compilers happy
+	q = NULL;		// ditto
+	entryCount = 0;							// ditto
+
+	// go through the bit lengths (bitsPerCode already is bits in shortest code)
+	for(; bitsPerCode <= maxCodeLen; bitsPerCode++)
+	{
+		codeCounter = bitLengths[bitsPerCode];
+		while(codeCounter--)
+		{
+			// here i is the Huffman code of length bitsPerCode bits for value *p
+			// make tables up to required level
+			while(bitsPerCode > bitsBeforeTable + bitsPerTable)
+			{
+				tableLevel++;
+				bitsBeforeTable += bitsPerTable; 			// previous table always bitsPerTable bits
+
+				// compute minimum size table less than or equal to bitsPerTable bits
+				entryCount = maxCodeLen - bitsBeforeTable;
+				entryCount = entryCount > bitsPerTable ? bitsPerTable : entryCount;				// table size upper limit
+				j = bitsPerCode - bitsBeforeTable;
+				f = 1 << j;
+				if(f > codeCounter + 1)							// try a bitsPerCode-bitsBeforeTable bit table
+				{										// too few codes for bitsPerCode-bitsBeforeTable bit table
+					f -= codeCounter + 1; 						// deduct codes from patterns left
+					xp = bitLengths + bitsPerCode;
+					if(j < entryCount)
+					{
+						while(++j < entryCount) 					// try smaller tables up to entryCount bits
+						{
+							f <<= 1;
+							if(f <= *++xp)
+							{
+								break;					// enough codes to use up j bits
+							}
+							f -= *xp;					// else deduct codes from patterns
+						}
+					}
+				}
+				entryCount = 1 << j; 							// table entries for j-bit table
+
+				// allocate new table
+				if(*hn + entryCount > MANY) 						// (note: doesn't matter for fixed)
+				{
+					return(Z_DATA_ERROR);				// not enough memory
+				}
+				q = hp + *hn;
+				tableStack[tableLevel] = q;
+				*hn += entryCount;
+
+				// connect to last table, if there is one
+				if(tableLevel)
+				{
+					bitOffsets[tableLevel] = i;							// save pattern for backing up
+					r.Bits = (byte)bitsPerTable;   	 					// bits to dump before this table
+					r.Exop = (byte)j;									// bits in this table
+					j = i >> (bitsBeforeTable - bitsPerTable);
+					r.base = q - tableStack[tableLevel - 1] - j; // offset to this table
+					tableStack[tableLevel - 1][j] = r;					// connect to last table
+				}
+				else						   
+				{
+					*t = q; 							// first table is returned result
+				}
+			}
+
+			// set up table entry in r
+			r.Bits = (byte)(bitsPerCode - bitsBeforeTable);
+			if(p >= workspace + numCodes)
+			{
+				r.Exop = 128 + 64;						// out of values--invalid code
+			}
+			else if(*p < s)
+			{
+				r.Exop = (byte)(*p < 256 ? 0 : 32 + 64);		// 256 is end-of-block
+				r.base = *p++;							// simple code is just the value
+			}
+			else
+			{
+				r.Exop = (byte)(e[*p - s] + 16 + 64);		 	// non-simple--look up in lists
+				r.base = d[*p++ - s];
+			}
+
+			// fill code-like entries with r
+			f = 1 << (bitsPerCode - bitsBeforeTable);
+			for(j = i >> bitsBeforeTable; j < entryCount; j += f)
+			{
+				q[j] = r;
+			}
+
+			// backwards increment the bitsPerCode-bit code i
+			for(j = 1 << (bitsPerCode - 1); i & j; j >>= 1)
+			{
+				i ^= j;
+			}
+			i ^= j;
+
+			// backup over finished tables
+			while((i & ((1 << bitsBeforeTable) - 1)) != bitOffsets[tableLevel])
+			{
+				tableLevel--;									// don't need to update q
+				bitsBeforeTable -= bitsPerTable;
+			}
+		}
+	}
+
+	// Return Z_BUF_ERROR if we were given an incomplete table
+	if(dummyCodes && (maxCodeLen != 1))
+	{
+		return(Z_BUF_ERROR);
+	}
+	return(Z_OK);
+}
+
+// ===============================================================================
+// ulong *c 				19 code lengths
+// ulong *bb				bits tree desired/actual depth
+// inflate_huft **tb		bits tree result
+// inflate_huft *hp 		space for trees
+// ===============================================================================
+
+static void inflate_trees_bits(z_stream *z, ulong *c, ulong *bb, inflate_huft_t **tb, inflate_huft_t *hp)
+{
+	ulong	hn = 0;				// hufts used in space
+	ulong	workspace[19];		// work area for huft_build
+
+	z->error = huft_build(c, 19, 19, NULL, NULL, tb, bb, hp, &hn, workspace);
+	if(z->error == Z_DATA_ERROR)
+	{
+		inflate_error = "Inflate data: Oversubscribed dynamic bit lengths tree";
+	}
+	else if((z->error == Z_BUF_ERROR) || !*bb)
+	{
+		inflate_error = "Inflate data: Incomplete dynamic bit lengths tree";
+		z->error = Z_DATA_ERROR;
+	}
+}
+
+// ===============================================================================
+// ulong *c 				// that many (total) code lengths
+// ulong *bl				// literal desired/actual bit depth
+// ulong *bd				// distance desired/actual bit depth
+// inflate_huft **tl		// literal/length tree result
+// inflate_huft **td		// distance tree result
+// inflate_huft *hp 		// space for trees
+// ===============================================================================
+
+static void inflate_trees_dynamic(z_stream *z, ulong numLiteral, ulong numDist, ulong *c, ulong *bl, ulong *bd, inflate_huft_t **tl, inflate_huft_t **td, inflate_huft_t *hp)
+{
+	ulong		hn = 0;				// hufts used in space
+	ulong		workspace[288]; 	// work area for huft_build
+
+	// build literal/length tree
+	z->error = huft_build(c, numLiteral, 257, cplens, cplext, tl, bl, hp, &hn, workspace);
+	if(z->error != Z_OK || !*bl)
+	{
+		inflate_error = "Inflate data: Erroneous literal/length tree";
+		z->error = Z_DATA_ERROR;
+		return;
+	}
+	// build distance tree
+	z->error = huft_build(c + numLiteral, numDist, 0, cpdist, extra_dbits, td, bd, hp, &hn, workspace);
+	if((z->error != Z_OK) || (!*bd && numLiteral > 257))
+	{
+		inflate_error = "Inflate data: Erroneous distance tree";
+		z->error = Z_DATA_ERROR;
+		return;
+	}
+}
+
+// ===============================================================================
+// ulong *bl				// literal desired/actual bit depth
+// ulong *bd				// distance desired/actual bit depth
+// inflate_huft **tl		// literal/length tree result
+// inflate_huft **td		// distance tree result
+// ===============================================================================
+
+// Fixme: Calculate dynamically
+
+static void inflate_trees_fixed(z_stream *z, ulong *bl, ulong *bd, inflate_huft_t **tl, inflate_huft_t **td)
+{
+	*bl = fixed_bl;
+	*bd = fixed_bd;
+	*tl = fixed_tl;
+	*td = fixed_td;
+	z->error = Z_OK;
+}
+
+// ===============================================================================
+// ===============================================================================
+
+static void inflate_blocks(inflate_blocks_state_t *s, z_stream *z)
+{
+	ulong					t;				// temporary storage
+	ulong					bytesToEnd;		// bytes to end of window or read pointer
+	ulong					bl, bd;
+	inflate_huft_t			*lengthTree = NULL;
+	inflate_huft_t			*distTree = NULL;
+	inflate_codes_state_t	*c;
+
+	// copy input/output information to locals (UPDATE macro restores)
+	bytesToEnd = s->write < s->read ? s->read - s->write - 1 : s->end - s->write; 
+
+	// process input based on current state
+	while(true)
+	{
+		switch (s->mode)
+		{
+		case TYPE:
+			if(!getbits(z, s, 3))
+			{
+				return;
+			}
+			t = s->bitb & 7;
+			s->last = !!(t & 1);
+
+			switch (t >> 1)
+			{
+			case STORED_BLOCK:
+				s->bitb >>= 3;
+				s->bitk -= 3;
+				t = s->bitk & 7;				// go to byte boundary
+				s->bitb >>= t;
+				s->bitk -= t;
+				s->mode = LENS; 				// get length of stored block
+				break;
+			case STATIC_TREES:
+				inflate_trees_fixed(z, &bl, &bd, &lengthTree, &distTree);
+				s->decode.codes = inflate_codes_new(z, bl, bd, lengthTree, distTree);
+				s->bitb >>= 3;
+				s->bitk -= 3;
+				s->mode = CODES;
+				break;
+			case DYN_TREES:
+				s->bitb >>= 3;
+				s->bitk -= 3;
+				s->mode = TABLE;
+				break;
+			case MODE_ILLEGAL:
+				s->bitb >>= 3;
+				s->bitk -= 3;
+				s->mode = BAD;
+				inflate_error = "Inflate data: Invalid block type";
+				z->error = Z_DATA_ERROR;
+				inflate_flush(z, s);
+				return;
+			}
+			break;
+		case LENS:
+			if(!getbits(z, s, 32))
+			{
+				return;
+			}
+			if(((~s->bitb) >> 16) != (s->bitb & 0xffff))
+			{
+				s->mode = BAD;
+				inflate_error = "Inflate data: Invalid stored block lengths";
+				z->error = Z_DATA_ERROR;
+				inflate_flush(z, s);
+				return;
+			}
+			s->left = s->bitb & 0xffff;
+			s->bitb = 0;
+			s->bitk = 0;								// dump bits
+			s->mode = s->left ? STORED : (s->last ? DRY : TYPE);
+			break;
+		case STORED:
+			if(!z->avail_in)
+			{
+				inflate_flush(z, s);
+				return;
+			}
+			bytesToEnd = needout(z, s, bytesToEnd);
+			if(!bytesToEnd)
+			{
+				return;
+			}
+			t = s->left;
+			if(t > z->avail_in) 
+			{
+				t = z->avail_in;
+			}
+			if(t > bytesToEnd) 
+			{
+				t = bytesToEnd;
+			}
+			memcpy(s->write, z->next_in, t);
+			z->next_in += t;
+			z->avail_in -= t;
+			z->total_in += t;
+			s->write += t;
+			bytesToEnd -= t;
+			s->left -= t;
+			if(s->left)
+			{
+				break;
+			}
+			s->mode = s->last ? DRY : TYPE;
+			break;
+		case TABLE:
+			if(!getbits(z, s, 14))
+			{
+				return;
+			}
+			t = s->bitb & 0x3fff;
+			s->trees.table = t;
+			if((t & 0x1f) > 29 || ((t >> 5) & 0x1f) > 29)
+			{
+				s->mode = BAD;
+				inflate_error = "Inflate data: Too many length or distance symbols";
+				z->error = Z_DATA_ERROR;
+				inflate_flush(z, s);
+				return;
+			}
+			t = 258 + (t & 0x1f) + ((t >> 5) & 0x1f);
+			s->trees.blens = (ulong *)Z_Malloc(t * sizeof(ulong), TAG_INFLATE, qfalse);
+			s->bitb >>= 14;
+			s->bitk -= 14;
+			s->trees.index = 0;
+			s->mode = BTREE;
+		case BTREE:
+			while(s->trees.index < 4 + (s->trees.table >> 10))
+			{
+				if(!getbits(z, s, 3))
+				{
+					return;
+				}
+				s->trees.blens[border[s->trees.index++]] = s->bitb & 7;
+				s->bitb >>= 3;
+				s->bitk -= 3;
+			}
+			while(s->trees.index < 19)
+			{
+				s->trees.blens[border[s->trees.index++]] = 0;
+			}
+			s->trees.bb = 7;
+			inflate_trees_bits(z, s->trees.blens, &s->trees.bb, &s->trees.tb, s->hufts);
+			if(z->error != Z_OK)
+			{
+				Z_Free(s->trees.blens);
+				s->mode = BAD;
+				inflate_flush(z, s);
+				return;
+			}
+			s->trees.index = 0;
+			s->mode = DTREE;
+		case DTREE:
+			while(t = s->trees.table, s->trees.index < 258 + (t & 0x1f) + ((t >> 5) & 0x1f))
+			{
+				inflate_huft_t *h;
+				ulong i, j, c;
+
+				t = s->trees.bb;
+				if(!getbits(z, s, t))
+				{
+					return;
+				}
+				h = s->trees.tb + (s->bitb & inflate_mask[t]);
+				t = h->Bits;
+				c = h->base;
+				if(c < 16)
+				{
+					s->bitb >>= t;
+					s->bitk -= t;
+					s->trees.blens[s->trees.index++] = c;
+				}
+				else	// c == 16..18
+				{
+					i = (c == 18) ? 7 : c - 14;
+					j = (c == 18) ? 11 : 3;
+					if(!getbits(z, s, t + i))
+					{
+						return;
+					}
+					s->bitb >>= t;
+					s->bitk -= t;
+					j += s->bitb & inflate_mask[i];
+					s->bitb >>= i;
+					s->bitk -= i;
+					i = s->trees.index;
+					t = s->trees.table;
+					if(i + j > 258 + (t & 0x1f) + ((t >> 5) & 0x1f) || (c == 16 && i < 1))
+					{
+						Z_Free(s->trees.blens);
+						s->mode = BAD;
+						inflate_error = "Inflate data: Invalid bit length repeat";
+						z->error = Z_DATA_ERROR;
+						inflate_flush(z, s);
+						return;
+					}
+					c = (c == 16) ? s->trees.blens[i - 1] : 0;
+					do
+					{
+						s->trees.blens[i++] = c;
+					} while(--j);
+					s->trees.index = i;
+				}
+			}
+			s->trees.tb = NULL;
+
+			bl = 9; 					// must be <= 9 for lookahead assumptions
+			bd = 6; 					// must be <= 9 for lookahead assumptions
+			t = s->trees.table;
+			inflate_trees_dynamic(z, 257 + (t & 0x1f), 1 + ((t >> 5) & 0x1f), s->trees.blens, &bl, &bd, &lengthTree, &distTree, s->hufts);
+			Z_Free(s->trees.blens);
+			if(z->error != Z_OK)
+			{
+				s->mode = BAD;
+				inflate_flush(z, s);
+				return;
+			}
+			c = inflate_codes_new(z, bl, bd, lengthTree, distTree);
+			s->decode.codes = c;
+			s->mode = CODES;
+		case CODES:
+			inflate_codes(z, s);
+			if(z->error != Z_STREAM_END)
+			{
+				inflate_flush(z, s);
+				return;
+			}
+			z->error = Z_OK;
+			Z_Free(s->decode.codes);
+			bytesToEnd = s->write < s->read ? s->read - s->write - 1 : s->end - s->write; 
+			if(!s->last)
+			{
+				s->mode = TYPE;
+				break;
+			}
+			s->mode = DRY;
+		case DRY:
+			inflate_flush(z, s);
+			bytesToEnd = s->write < s->read ? s->read - s->write - 1 : s->end - s->write;
+			if(s->read != s->write)
+			{
+				inflate_error = "Inflate data: read != write in DRY";
+				inflate_flush(z, s);
+				return;
+			}
+			s->mode = DONE;
+		case DONE:
+			z->error = Z_STREAM_END;
+			inflate_flush(z, s);
+			return;
+		case BAD:
+		default:
+			z->error = Z_DATA_ERROR;
+			inflate_flush(z, s);
+			return;
+		}
+	}
+}
+
+// -------------------------------------------------------------------------------------------------
+// Controlling routines
+// -------------------------------------------------------------------------------------------------
+
+EStatus inflateEnd(z_stream *z)
+{
+	assert(z);
+
+	if(z->istate->blocks)
+	{
+		inflate_blocks_free(z, z->istate->blocks);
+		z->istate->blocks = NULL;
+	}
+	if(z->istate)
+	{
+		Z_Free(z->istate);
+		z->istate = NULL;
+	}
+	return(Z_OK);
+}
+
+// ===============================================================================
+// ===============================================================================
+
+EStatus inflateInit(z_stream *z, EFlush flush, int noWrap)
+{
+	// initialize state
+	assert(z);
+
+	inflate_error = "OK";
+
+	z->istate = (inflate_state *)Z_Malloc(sizeof(inflate_state), TAG_INFLATE, qtrue);
+	z->istate->blocks = NULL;
+
+	// handle nowrap option (no zlib header or check)
+	z->istate->nowrap = noWrap;
+	z->istate->wbits = MAX_WBITS;
+
+	// create inflate_blocks state
+	z->istate->blocks = inflate_blocks_new(z, NULL);
+
+	z->status = Z_OK;
+	if(flush == Z_FINISH)
+	{
+		z->status = Z_BUF_ERROR;
+	}
+
+	// reset state
+	z->istate->mode = imMETHOD;
+	if(z->istate->nowrap)
+	{
+		z->istate->mode = imBLOCKS;
+	}
+	inflate_blocks_reset(z, z->istate->blocks);
+	return(Z_OK);
+}
+
+// ===============================================================================
+// ===============================================================================
+
+EStatus inflate(z_stream *z)
+{
+	ulong		b;
+
+	// Sanity check data
+	assert(z);
+	assert(z->istate);
+
+	while(true)
+	{
+		switch (z->istate->mode)
+		{
+		case imMETHOD:
+			if(!z->avail_in)
+			{
+				return(z->status);
+			}
+			z->istate->method = *z->next_in++;
+			z->avail_in--;
+			z->total_in++;
+			if((z->istate->method & 0xf) != ZF_DEFLATED)
+			{
+				z->istate->mode = imBAD;
+				inflate_error = "Inflate data: Unknown compression method";
+				return(Z_DATA_ERROR);
+			}
+			if((z->istate->method >> 4) + 8 > z->istate->wbits)
+			{
+				z->istate->mode = imBAD;
+				inflate_error = "Inflate data: Invalid window size";
+				return(Z_DATA_ERROR);
+			}
+			z->istate->mode = imFLAG;
+			break;
+		case imFLAG:
+			if(!z->avail_in)
+			{
+				return(z->status);
+			}
+			b = *z->next_in++;
+			z->avail_in--;
+			z->total_in++;
+			if(((z->istate->method << 8) + b) % 31)
+			{
+				z->istate->mode = imBAD;
+				inflate_error = "Inflate data: Incorrect header check";
+				return(Z_DATA_ERROR);
+			}
+			z->istate->mode = imBLOCKS;
+			break;
+		case imBLOCKS:
+			inflate_blocks(z->istate->blocks, z);
+			
+			// Make sure everything processed ok
+			if(z->error == Z_DATA_ERROR)
+			{
+				z->istate->mode = imBAD;
+				return(Z_DATA_ERROR);
+			}
+
+			if(z->error != Z_STREAM_END)
+			{
+				return(z->status);
+			}
+			z->istate->calcadler = z->istate->adler;
+			inflate_blocks_reset(z, z->istate->blocks);
+			if(z->istate->nowrap)
+			{
+				z->istate->mode = imDONE;
+				break;
+			}
+			z->istate->mode = imCHECK4;
+			break;
+		case imCHECK4:
+			if(!z->avail_in)
+			{
+				return(z->status);
+			}
+			z->istate->adler = *z->next_in++ << 24;
+			z->avail_in--;
+			z->total_in++;
+			z->istate->mode = imCHECK3;
+			break;
+		case imCHECK3:
+			if(!z->avail_in)
+			{
+				return(z->status);
+			}
+			z->istate->adler += *z->next_in++ << 16;
+			z->avail_in--;
+			z->total_in++;
+			z->istate->mode = imCHECK2;
+			break;
+		case imCHECK2:
+			if(!z->avail_in)
+			{
+				return(z->status);
+			}
+			z->istate->adler += *z->next_in++ << 8;
+			z->avail_in--;
+			z->total_in++;
+			z->istate->mode = imCHECK1;
+			break;
+		case imCHECK1:
+			if(!z->avail_in)
+			{
+				return(z->status);
+			}
+			z->istate->adler += *z->next_in++;
+			z->avail_in--;
+			z->total_in++;
+
+			if(z->istate->calcadler != z->istate->adler)
+			{
+				inflate_error = "Inflate data: Failed Adler checksum";
+				z->istate->mode = imBAD;
+				break;
+			}
+			z->istate->mode = imDONE;
+			break;
+		case imDONE:
+			return(Z_STREAM_END);
+		case imBAD:
+			return(Z_DATA_ERROR);
+		default:
+			return(Z_STREAM_ERROR);
+		}
+	}
+	assert(0);
+	return(Z_OK);
+}
+
+// ===============================================================================
+// ===============================================================================
+
+const char *inflateError(void)
+{
+	return(inflate_error);
+}
+
+// ===============================================================================
+// External calls
+// ===============================================================================
+
+bool InflateFile(byte *src, ulong compressedSize, byte *dst, ulong uncompressedSize, int noWrap)
+{
+	z_stream	z = { 0 };
+
+	inflateInit(&z, Z_FINISH, noWrap);
+
+	z.next_in = src;
+	z.avail_in = compressedSize;
+	z.next_out = dst;
+	z.avail_out = uncompressedSize;
+
+#ifdef _TIMING
+	int temp = timeGetTime();
+#endif
+	if(inflate(&z) != Z_STREAM_END)
+	{
+		inflate_error = "Inflate data: Stream did not end";
+		inflateEnd(&z);
+		return(false);
+	}
+#ifdef _TIMING
+	totalInflateTime += timeGetTime() - temp;
+	totalInflateCount++;
+#endif
+
+	if(z.avail_in)
+	{
+		inflate_error = "Inflate data: Remaining input data at stream end";
+		inflateEnd(&z);
+		return(false);
+	}
+	if(z.avail_out)
+	{
+		inflate_error = "Inflate data: Remaining output space at stream end";
+		inflateEnd(&z);
+		return(false);
+	}
+	if(z.total_in != compressedSize)
+	{
+		inflate_error = "Inflate data: Number of processed bytes != compressed size";
+		inflateEnd(&z);
+		return(false);
+	}
+	if(z.total_out != uncompressedSize)
+	{
+		inflate_error = "Inflate data: Number of bytes output != uncompressed size";
+		inflateEnd(&z);
+		return(false);
+	}
+	inflateEnd(&z);
+	return(true);
+}
+
+// end
diff --git a/code/zlib32/inflate.h b/code/zlib32/inflate.h
new file mode 100644
index 0000000..550244d
--- /dev/null
+++ b/code/zlib32/inflate.h
@@ -0,0 +1,145 @@
+// Maximum size of dynamic tree.  The maximum found in a long but non-
+// exhaustive search was 1004 huft structures (850 for length/literals
+// and 154 for distances, the latter actually the result of an
+// exhaustive search).  The actual maximum is not known, but the
+// value below is more than safe.
+
+#define MANY					1440
+
+// maximum bit length of any code (if BMAX needs to be larger than 16, then h and x[] should be ulong.)
+#define BMAX					15
+
+typedef ulong (*check_func) (ulong check, const byte *buf, ulong len);
+
+typedef enum 
+{
+	TYPE,		// get type bits (3, including end bit)
+	LENS,		// get lengths for stored
+	STORED,		// processing stored block
+	TABLE,		// get table lengths
+	BTREE,		// get bit lengths tree for a dynamic block
+	DTREE,		// get length, distance trees for a dynamic block
+	CODES,		// processing fixed or dynamic block
+	DRY,		// output remaining window bytes
+	DONE,		// finished last block, done
+	BAD			// got a data error--stuck here
+} inflate_block_mode;
+
+// waiting for "i:"=input, "o:"=output, "x:"=nothing
+typedef enum 
+{        
+	START,		// x: set up for LEN
+	LEN,		// i: get length/literal/eob next
+	LENEXT,		// i: getting length extra (have base)
+	DIST,		// i: get distance next
+	DISTEXT,	// i: getting distance extra
+	COPY,		// o: copying bytes in window, waiting for space
+	LIT,		// o: got literal, waiting for output space
+	WASH,		// o: got eob, possibly still output waiting
+	END,		// x: got eob and all data flushed
+	BADCODE		// x: got error
+} inflate_codes_mode;
+
+typedef enum 
+{
+	imMETHOD,	// waiting for method byte
+	imFLAG,		// waiting for flag byte
+	imBLOCKS,	// decompressing blocks
+	imCHECK4,	// four check bytes to go
+	imCHECK3,	// three check bytes to go
+	imCHECK2,	// two check bytes to go
+	imCHECK1,	// one check byte to go
+	imDONE,		// finished check, done
+	imBAD		// got an error--stay here
+} inflate_mode;
+
+typedef struct inflate_huft_s 
+{
+	byte	Exop;							// number of extra bits or operation
+	byte	Bits;							// number of bits in this code or subcode
+	ulong	base;							// literal, length base, distance base, or table offset
+} inflate_huft_t;
+
+// inflate codes private state
+typedef struct inflate_codes_state_s 
+{
+	inflate_codes_mode	mode;				// current inflate_codes mode
+											
+	// mode dependent information			
+	ulong len;								
+	union									
+	{										
+		struct								
+		{									
+			inflate_huft_t	*tree;			// pointer into tree
+			ulong			need;			// bits needed
+		} code;								// if LEN or DIST, where in tree
+		ulong			lit;				// if LIT, literal
+		struct								
+		{									
+			ulong			get;			// bits to get for extra
+			ulong			dist;			// distance back to copy from
+		} copy;								// if EXT or COPY, where and how much
+	};										// submode
+											
+	// mode independent information			
+	byte			lbits;					// ltree bits decoded per branch
+	byte			dbits;					// dtree bits decoder per branch
+	inflate_huft_t	*ltree;					// literal/length/eob tree
+	inflate_huft_t	*dtree;					// distance tree
+} inflate_codes_state_t;
+
+// inflate blocks semi-private state
+typedef struct inflate_blocks_state_s 
+{
+	// mode
+	inflate_block_mode		mode;			// current inflate_block mode
+
+	// mode dependent information
+	union
+	{
+		ulong		left;					// if STORED, bytes left to copy
+		struct								
+		{									
+			ulong			table;			// table lengths (14 bits)
+			ulong			index;			// index into blens (or border)
+			ulong			*blens;			// bit lengths of codes
+			ulong			bb;				// bit length tree depth
+			inflate_huft_t	*tb;			// bit length decoding tree
+		} trees;							// if DTREE, decoding info for trees
+		struct 
+		{
+			inflate_codes_state_t *codes;
+		} decode;							// if CODES, current state
+	};										// submode
+	bool			last;					// true if this block is the last block
+											
+	// mode independent information			
+	ulong			bitk;					// bits in bit buffer
+	ulong			bitb;					// bit buffer
+	inflate_huft_t	*hufts;					// single malloc for tree space
+	byte			window[WINDOW_SIZE];	// sliding window
+	byte			*end;					// one byte after sliding window
+	byte			*read;					// window read pointer
+	byte			*write;					// window write pointer
+	ulong			check;					// check on output
+} inflate_blocks_state_t;
+
+// inflate private state
+typedef struct inflate_state_s 
+{
+	inflate_mode			mode;	  		// current inflate mode
+											
+	ulong					method;			// if FLAGS, method byte
+											
+	// mode independent information			
+	int						nowrap;			// flag for no wrapper
+	ulong					wbits;			// log2(window size)  (8..15, defaults to 15)
+	inflate_blocks_state_t	*blocks;		// current inflate_blocks state
+
+	ulong					adler;
+	ulong					calcadler;
+} inflate_state;
+
+
+// end
diff --git a/code/zlib32/vssver.scc b/code/zlib32/vssver.scc
new file mode 100644
index 0000000..4cf098d
Binary files /dev/null and b/code/zlib32/vssver.scc differ
diff --git a/code/zlib32/zip.h b/code/zlib32/zip.h
new file mode 100644
index 0000000..1a9fd2d
--- /dev/null
+++ b/code/zlib32/zip.h
@@ -0,0 +1,195 @@
+//
+// zlib.h -- interface of the 'zlib' general purpose compression library
+//  version 1.1.3, July 9th, 1998
+//
+//  Copyright (C) 1995-1998 Jean-loup Gailly and Mark Adler
+//
+//  This software is provided 'as-is', without any express or implied
+//  warranty.  In no event will the authors be held liable for any damages
+//  arising from the use of this software.
+//
+//  Permission is granted to anyone to use this software for any purpose,
+//  including commercial applications, and to alter it and redistribute it
+//  freely, subject to the following restrictions:
+//
+//  1. The origin of this software must not be misrepresented; you must not
+//     claim that you wrote the original software. If you use this software
+//     in a product, an acknowledgment in the product documentation would be
+//     appreciated but is not required.
+//  2. Altered source versions must be plainly marked as such, and must not be
+//     misrepresented as being the original software.
+//  3. This notice may not be removed or altered from any source distribution.
+//
+//  Jean-loup Gailly        Mark Adler
+//  jloup@gzip.org          madler@alumni.caltech.edu
+//
+//  The data format used by the zlib library is described by RFCs (Request for
+//  Comments) 1950 to 1952 in the files ftp://ds.internic.net/rfc/rfc1950.txt
+//  (zlib format), rfc1951.txt (deflate format) and rfc1952.txt (gzip format).
+//
+
+//     The 'zlib' compression library provides in-memory compression and
+//  decompression functions, including integrity checks of the uncompressed
+//  data.  This version of the library supports only one compression method
+//  (deflation) but other algorithms will be added later and will have the same
+//  stream interface.
+//
+//     Compression can be done in a single step if the buffers are large
+//  enough (for example if an input file is mmap'ed), or can be done by
+//  repeated calls of the compression function.  In the latter case, the
+//  application must provide more input and/or consume the output
+//  (providing more output space) before each call.
+//
+//     The library does not install any signal handler. The decoder checks
+//  the consistency of the compressed data, so the library should never
+//  crash even in case of corrupted input.
+
+// This particular implementation has been heavily modified by jscott@ravensoft.com
+// to increase inflate/deflate speeds on 32 bit machines.
+
+// for more info about .ZIP format, see 
+//    ftp://ftp.cdrom.com/pub/infozip/doc/appnote-970311-iz.zip
+// PkWare has also a specification at :
+//    ftp://ftp.pkware.com/probdesc.zip
+
+// ========================================================================================
+// External calls and defines required for the zlib
+// ========================================================================================
+
+// The deflate compression method
+#define ZF_STORED					0
+#define ZF_DEFLATED					8
+
+// Compression levels
+typedef enum
+{ 
+	Z_STORE_COMPRESSION,
+	Z_FAST_COMPRESSION_LOW,
+	Z_FAST_COMPRESSION,
+	Z_FAST_COMPRESSION_HIGH,
+	Z_SLOW_COMPRESSION_LOWEST,
+	Z_SLOW_COMPRESSION_LOW,
+	Z_DEFAULT_COMPRESSION,
+	Z_SLOW_COMPRESSION_HIGH,
+	Z_SLOW_COMPRESSION_HIGHEST,
+	Z_MAX_COMPRESSION,
+} ELevel;
+
+// Allowed flush values
+typedef enum
+{
+	Z_NEED_MORE = -1,					// Special case when finishing up the stream 
+	Z_NO_FLUSH,
+	Z_SYNC_FLUSH,						// Sync up the stream ready for another call
+	Z_FINISH							// Finish up the stream
+} EFlush;
+
+// Return codes for the compression/decompression functions. Negative
+// values are errors, positive values are used for special but normal events.
+typedef enum
+{
+	Z_STREAM_ERROR = -3,				// Basic error from failed sanity checks
+	Z_BUF_ERROR,						// Not enough input or output
+	Z_DATA_ERROR,						// Invalid data in the stream
+	Z_OK,								
+	Z_STREAM_END						// End of stream
+} EStatus;
+
+// Maximum value for windowBits in deflateInit and inflateInit.
+// The memory requirements for inflate are (in bytes) 1 << windowBits
+// that is, 32K for windowBits=15 (default value) plus a few kilobytes
+// for small objects.
+#define MAX_WBITS				15					// 32K LZ77 window
+#define WINDOW_SIZE				(1 << MAX_WBITS)
+#define	BIG_WINDOW_SIZE			(WINDOW_SIZE << 1)
+#define WINDOW_MASK				(WINDOW_SIZE - 1)
+
+// The three kinds of block type
+#define STORED_BLOCK			0
+#define STATIC_TREES			1
+#define DYN_TREES				2
+#define MODE_ILLEGAL			3
+
+// The minimum and maximum match lengths
+#define MIN_MATCH				3
+#define MAX_MATCH				258
+
+// number of distance codes
+#define D_CODES					30
+
+extern const ulong extra_dbits[D_CODES];
+
+// Structure to be used by external applications
+
+//  The application must update next_in and avail_in when avail_in has
+//  dropped to zero. It must update next_out and avail_out when avail_out
+//  has dropped to zero. All other fields are set by the
+//  compression library and must not be updated by the application.
+
+typedef struct z_stream_s 
+{
+	byte			*next_in;			// next input unsigned char
+	ulong			avail_in;			// number of unsigned chars available at next_in
+	ulong			total_in;			// total number of bytes processed so far
+										  
+	byte			*next_out;			// next output unsigned char should be put there
+	ulong			avail_out;			// remaining free space at next_out
+	ulong			total_out;			// total number of bytes output
+						  
+	EStatus			status;
+	EStatus			error;				// error code
+
+	struct inflate_state_s	*istate;	// not visible by applications
+	struct deflate_state_s	*dstate;	// not visible by applications
+
+	ulong			quality;
+} z_stream;
+
+//     Update a running crc with the bytes buf[0..len-1] and return the updated
+//   crc. If buf is NULL, this function returns the required initial value
+//   for the crc. Pre- and post-conditioning (one's complement) is performed
+//   within this function so it shouldn't be done by the application.
+//   Usage example:
+//
+//     ulong crc = crc32(0L, NULL, 0);
+//
+//     while (read_buffer(buffer, length) != EOF) {
+//       crc = crc32(crc, buffer, length);
+//     }
+//     if (crc != original_crc) error();
+
+ulong crc32(ulong crc, const byte *buf, ulong len);
+
+//     Update a running Adler-32 checksum with the bytes buf[0..len-1] and
+//   return the updated checksum. If buf is NULL, this function returns
+//   the required initial value for the checksum.
+//   An Adler-32 checksum is almost as reliable as a CRC32 but can be computed
+//   much faster. Usage example:
+//
+//     ulong adler = adler32(0L, NULL, 0);
+//
+//     while (read_buffer(buffer, length) != EOF) {
+//       adler = adler32(adler, buffer, length);
+//     }
+//     if (adler != original_adler) error();
+
+ulong adler32(ulong adler, const byte *buf, ulong len);
+
+// External calls to the deflate code
+EStatus deflateInit(z_stream *strm, ELevel level, int noWrap = 0);
+EStatus deflateCopy(z_stream *dest, z_stream *source);
+EStatus deflate(z_stream *strm, EFlush flush);
+EStatus deflateEnd(z_stream *strm);
+const char *deflateError(void);
+
+// External calls to the deflate code
+EStatus inflateInit(z_stream *strm, EFlush flush, int noWrap = 0);
+EStatus inflate(z_stream *z);
+EStatus inflateEnd(z_stream *strm);
+const char *inflateError(void);
+
+// External calls to the zipfile code
+bool InflateFile(byte *src, ulong compressedSize, byte *dst, ulong uncompressedSize, int noWrap = 0);
+bool DeflateFile(byte *src, ulong uncompressedSize, byte *dst, ulong maxCompressedSize, ulong *compressedSize, ELevel level, int noWrap = 0);
+
+// end
diff --git a/code/zlib32/zipcommon.cpp b/code/zlib32/zipcommon.cpp
new file mode 100644
index 0000000..77f56cd
--- /dev/null
+++ b/code/zlib32/zipcommon.cpp
@@ -0,0 +1,117 @@
+// -----------------------------------------------------------------------------------------------
+// Table of CRC-32's of all single-byte values (made by make_crc_table)
+// -----------------------------------------------------------------------------------------------
+
+static const unsigned long crc_table[256] = 
+{
+  0x00000000L, 0x77073096L, 0xee0e612cL, 0x990951baL, 0x076dc419L,
+  0x706af48fL, 0xe963a535L, 0x9e6495a3L, 0x0edb8832L, 0x79dcb8a4L,
+  0xe0d5e91eL, 0x97d2d988L, 0x09b64c2bL, 0x7eb17cbdL, 0xe7b82d07L,
+  0x90bf1d91L, 0x1db71064L, 0x6ab020f2L, 0xf3b97148L, 0x84be41deL,
+  0x1adad47dL, 0x6ddde4ebL, 0xf4d4b551L, 0x83d385c7L, 0x136c9856L,
+  0x646ba8c0L, 0xfd62f97aL, 0x8a65c9ecL, 0x14015c4fL, 0x63066cd9L,
+  0xfa0f3d63L, 0x8d080df5L, 0x3b6e20c8L, 0x4c69105eL, 0xd56041e4L,
+  0xa2677172L, 0x3c03e4d1L, 0x4b04d447L, 0xd20d85fdL, 0xa50ab56bL,
+  0x35b5a8faL, 0x42b2986cL, 0xdbbbc9d6L, 0xacbcf940L, 0x32d86ce3L,
+  0x45df5c75L, 0xdcd60dcfL, 0xabd13d59L, 0x26d930acL, 0x51de003aL,
+  0xc8d75180L, 0xbfd06116L, 0x21b4f4b5L, 0x56b3c423L, 0xcfba9599L,
+  0xb8bda50fL, 0x2802b89eL, 0x5f058808L, 0xc60cd9b2L, 0xb10be924L,
+  0x2f6f7c87L, 0x58684c11L, 0xc1611dabL, 0xb6662d3dL, 0x76dc4190L,
+  0x01db7106L, 0x98d220bcL, 0xefd5102aL, 0x71b18589L, 0x06b6b51fL,
+  0x9fbfe4a5L, 0xe8b8d433L, 0x7807c9a2L, 0x0f00f934L, 0x9609a88eL,
+  0xe10e9818L, 0x7f6a0dbbL, 0x086d3d2dL, 0x91646c97L, 0xe6635c01L,
+  0x6b6b51f4L, 0x1c6c6162L, 0x856530d8L, 0xf262004eL, 0x6c0695edL,
+  0x1b01a57bL, 0x8208f4c1L, 0xf50fc457L, 0x65b0d9c6L, 0x12b7e950L,
+  0x8bbeb8eaL, 0xfcb9887cL, 0x62dd1ddfL, 0x15da2d49L, 0x8cd37cf3L,
+  0xfbd44c65L, 0x4db26158L, 0x3ab551ceL, 0xa3bc0074L, 0xd4bb30e2L,
+  0x4adfa541L, 0x3dd895d7L, 0xa4d1c46dL, 0xd3d6f4fbL, 0x4369e96aL,
+  0x346ed9fcL, 0xad678846L, 0xda60b8d0L, 0x44042d73L, 0x33031de5L,
+  0xaa0a4c5fL, 0xdd0d7cc9L, 0x5005713cL, 0x270241aaL, 0xbe0b1010L,
+  0xc90c2086L, 0x5768b525L, 0x206f85b3L, 0xb966d409L, 0xce61e49fL,
+  0x5edef90eL, 0x29d9c998L, 0xb0d09822L, 0xc7d7a8b4L, 0x59b33d17L,
+  0x2eb40d81L, 0xb7bd5c3bL, 0xc0ba6cadL, 0xedb88320L, 0x9abfb3b6L,
+  0x03b6e20cL, 0x74b1d29aL, 0xead54739L, 0x9dd277afL, 0x04db2615L,
+  0x73dc1683L, 0xe3630b12L, 0x94643b84L, 0x0d6d6a3eL, 0x7a6a5aa8L,
+  0xe40ecf0bL, 0x9309ff9dL, 0x0a00ae27L, 0x7d079eb1L, 0xf00f9344L,
+  0x8708a3d2L, 0x1e01f268L, 0x6906c2feL, 0xf762575dL, 0x806567cbL,
+  0x196c3671L, 0x6e6b06e7L, 0xfed41b76L, 0x89d32be0L, 0x10da7a5aL,
+  0x67dd4accL, 0xf9b9df6fL, 0x8ebeeff9L, 0x17b7be43L, 0x60b08ed5L,
+  0xd6d6a3e8L, 0xa1d1937eL, 0x38d8c2c4L, 0x4fdff252L, 0xd1bb67f1L,
+  0xa6bc5767L, 0x3fb506ddL, 0x48b2364bL, 0xd80d2bdaL, 0xaf0a1b4cL,
+  0x36034af6L, 0x41047a60L, 0xdf60efc3L, 0xa867df55L, 0x316e8eefL,
+  0x4669be79L, 0xcb61b38cL, 0xbc66831aL, 0x256fd2a0L, 0x5268e236L,
+  0xcc0c7795L, 0xbb0b4703L, 0x220216b9L, 0x5505262fL, 0xc5ba3bbeL,
+  0xb2bd0b28L, 0x2bb45a92L, 0x5cb36a04L, 0xc2d7ffa7L, 0xb5d0cf31L,
+  0x2cd99e8bL, 0x5bdeae1dL, 0x9b64c2b0L, 0xec63f226L, 0x756aa39cL,
+  0x026d930aL, 0x9c0906a9L, 0xeb0e363fL, 0x72076785L, 0x05005713L,
+  0x95bf4a82L, 0xe2b87a14L, 0x7bb12baeL, 0x0cb61b38L, 0x92d28e9bL,
+  0xe5d5be0dL, 0x7cdcefb7L, 0x0bdbdf21L, 0x86d3d2d4L, 0xf1d4e242L,
+  0x68ddb3f8L, 0x1fda836eL, 0x81be16cdL, 0xf6b9265bL, 0x6fb077e1L,
+  0x18b74777L, 0x88085ae6L, 0xff0f6a70L, 0x66063bcaL, 0x11010b5cL,
+  0x8f659effL, 0xf862ae69L, 0x616bffd3L, 0x166ccf45L, 0xa00ae278L,
+  0xd70dd2eeL, 0x4e048354L, 0x3903b3c2L, 0xa7672661L, 0xd06016f7L,
+  0x4969474dL, 0x3e6e77dbL, 0xaed16a4aL, 0xd9d65adcL, 0x40df0b66L,
+  0x37d83bf0L, 0xa9bcae53L, 0xdebb9ec5L, 0x47b2cf7fL, 0x30b5ffe9L,
+  0xbdbdf21cL, 0xcabac28aL, 0x53b39330L, 0x24b4a3a6L, 0xbad03605L,
+  0xcdd70693L, 0x54de5729L, 0x23d967bfL, 0xb3667a2eL, 0xc4614ab8L,
+  0x5d681b02L, 0x2a6f2b94L, 0xb40bbe37L, 0xc30c8ea1L, 0x5a05df1bL,
+  0x2d02ef8dL
+};
+
+// -----------------------------------------------------------------------------------------------
+// Calculate 32 bit CRC checksum for len bytes
+// -----------------------------------------------------------------------------------------------
+
+unsigned long crc32(unsigned long crc, const unsigned char *buf, unsigned long len)
+{
+	if(!buf)
+	{
+		return(0);
+	}
+	crc = crc ^ 0xffffffff;
+	while(len--)
+	{
+		crc = crc_table[((int)crc ^ (*buf++)) & 0xff] ^ (crc >> 8);
+	}
+    return(crc ^ 0xffffffff);
+}
+
+// -----------------------------------------------------------------------------------------------
+// Calculate 32 bit Adler checksum (quicker than CRC)
+// -----------------------------------------------------------------------------------------------
+
+// largest prime smaller than 65536
+#define BASE		65521
+// NMAX is the largest n such that 255n(n+1)/2 + (n+1)(BASE-1) <= 2^32-1
+#define NMAX		5552
+
+unsigned long adler32(unsigned long adler, const unsigned char *buf, unsigned long len)
+{
+    unsigned long	s1;
+    unsigned long	s2;
+    int		k;
+
+    if(!buf) 
+	{
+		return(1);
+	}
+	s1 = adler & 0xffff;        
+	s2 = (adler >> 16) & 0xffff;
+
+    while (len > 0) 
+	{
+        k = len < NMAX ? len : NMAX;
+        len -= k;
+
+        while (k--) 
+		{
+			s1 += *buf++;
+			s2 += s1;
+		}
+        s1 %= BASE;
+        s2 %= BASE;
+    }
+    return (s2 << 16) | s1;
+}
+
+// end
\ No newline at end of file
diff --git a/codemp/ALut.lib b/codemp/ALut.lib
new file mode 100644
index 0000000..67cde9f
Binary files /dev/null and b/codemp/ALut.lib differ
diff --git a/codemp/CommandLine.txt b/codemp/CommandLine.txt
new file mode 100644
index 0000000..d0c79e7
--- /dev/null
+++ b/codemp/CommandLine.txt
@@ -0,0 +1,3 @@
+JKA Multiplayer, select all build types, set these command line parms:
+
++set fs_cdpath w:\game +set r_fullscreen 0 +set fs_copyfiles 0 +set vm_ui 0 +set vm_cgame 0 +set vm_game 0 +set sv_pure 0
diff --git a/codemp/Debug/HA312W32.DLL b/codemp/Debug/HA312W32.DLL
new file mode 100644
index 0000000..2b1ea82
Binary files /dev/null and b/codemp/Debug/HA312W32.DLL differ
diff --git a/codemp/Debug/SHW32.DLL b/codemp/Debug/SHW32.DLL
new file mode 100644
index 0000000..42b2f67
Binary files /dev/null and b/codemp/Debug/SHW32.DLL differ
diff --git a/codemp/Debug/vssver.scc b/codemp/Debug/vssver.scc
new file mode 100644
index 0000000..796ec67
Binary files /dev/null and b/codemp/Debug/vssver.scc differ
diff --git a/codemp/EaxMan.dll b/codemp/EaxMan.dll
new file mode 100644
index 0000000..651cbfe
Binary files /dev/null and b/codemp/EaxMan.dll differ
diff --git a/codemp/JKA_mp.sln b/codemp/JKA_mp.sln
new file mode 100644
index 0000000..d784d34
--- /dev/null
+++ b/codemp/JKA_mp.sln
@@ -0,0 +1,176 @@
+Microsoft Visual Studio Solution File, Format Version 7.00
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "JK2cgame", "cgame\JK2_cgame.vcproj", "{4DC69D68-9DB8-4DEB-AC63-481153B1F41D}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "JK2game", "game\JK2_game.vcproj", "{5B587283-8429-4F8B-AECA-C09BF364B617}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "WinDed", "WinDed.vcproj", "{149BAC28-9F08-4C08-BD4E-02D01A0DAD1F}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "botlib", "botlib\botlib.vcproj", "{07CCC82A-B905-4384-8AC5-E8A8E352B14C}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "exe", "jk2mp.vcproj", "{36D7BB4B-5943-4477-AD6A-7B96CC0AB71A}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "ui", "ui\ui.vcproj", "{2DDA2041-6A68-4754-B342-14039CC91695}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "x_botlib", "x_botlib\x_botlib.vcproj", "{ACB93D0D-F6CB-480B-9B20-CE6C5EDC13BD}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "x_exe", "x_exe\x_exe.vcproj", "{EEDF772D-5D2B-4C0F-B5C8-0A5828917847}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "x_jk2cgame", "x_jk2cgame\x_jk2cgame.vcproj", "{C79C9037-8F32-4833-A276-96B2FB96CCA5}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "x_jk2game", "x_jk2game\x_jk2game.vcproj", "{A0451C0A-0B2F-400A-BBB1-98F517FAB30B}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "x_ui", "x_ui\x_ui.vcproj", "{613EA919-780E-416D-90A9-67D3EB27F899}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "goblib", "goblib\goblib.vcproj", "{0959DD50-BCBA-4551-9617-E6FD4DF85298}"
+EndProject
+Global
+	GlobalSection(SourceCodeControl) = preSolution
+		SccNumberOfProjects = 6
+		SccProjectUniqueName0 = cgame\\JK2_cgame.vcproj
+		SccProjectName0 = \u0022$/jedi/codemp/cgame\u0022,\u0020ICAAAAAA
+		SccLocalPath0 = cgame
+		SccProvider0 = MSSCCI:Microsoft\u0020Visual\u0020SourceSafe
+		CanCheckoutShared = true
+		SccProjectUniqueName1 = game\\JK2_game.vcproj
+		SccProjectName1 = \u0022$/jedi/codemp/game\u0022,\u0020EGAAAAAA
+		SccLocalPath1 = game
+		SccProvider1 = MSSCCI:Microsoft\u0020Visual\u0020SourceSafe
+		CanCheckoutShared = true
+		SccProjectUniqueName2 = WinDed.vcproj
+		SccProjectName2 = \u0022$/jedi/codemp\u0022,\u0020CAAAAAAA
+		SccLocalPath2 = .
+		SccProvider2 = MSSCCI:Microsoft\u0020Visual\u0020SourceSafe
+		CanCheckoutShared = true
+		SccProjectUniqueName3 = botlib\\botlib.vcproj
+		SccProjectName3 = \u0022$/jedi/codemp/botlib\u0022,\u0020EAAAAAAA
+		SccLocalPath3 = botlib
+		SccProvider3 = MSSCCI:Microsoft\u0020Visual\u0020SourceSafe
+		CanCheckoutShared = true
+		SccProjectUniqueName4 = jk2mp.vcproj
+		SccProjectName4 = \u0022$/jedi/codemp\u0022,\u0020CAAAAAAA
+		SccLocalPath4 = .
+		SccProvider4 = MSSCCI:Microsoft\u0020Visual\u0020SourceSafe
+		CanCheckoutShared = true
+		SccProjectUniqueName5 = ui\\ui.vcproj
+		SccProjectName5 = \u0022$/jedi/codemp/ui\u0022,\u0020YSAAAAAA
+		SccLocalPath5 = ui
+		SccProvider5 = MSSCCI:Microsoft\u0020Visual\u0020SourceSafe
+		CanCheckoutShared = true
+	EndGlobalSection
+	GlobalSection(SolutionConfiguration) = preSolution
+		ConfigName.0 = Debug
+		ConfigName.1 = Debug(SH)
+		ConfigName.2 = Final
+		ConfigName.3 = Release
+	EndGlobalSection
+	GlobalSection(ProjectDependencies) = postSolution
+		{36D7BB4B-5943-4477-AD6A-7B96CC0AB71A}.0 = {5B587283-8429-4F8B-AECA-C09BF364B617}
+		{36D7BB4B-5943-4477-AD6A-7B96CC0AB71A}.1 = {4DC69D68-9DB8-4DEB-AC63-481153B1F41D}
+		{36D7BB4B-5943-4477-AD6A-7B96CC0AB71A}.2 = {2DDA2041-6A68-4754-B342-14039CC91695}
+		{36D7BB4B-5943-4477-AD6A-7B96CC0AB71A}.3 = {07CCC82A-B905-4384-8AC5-E8A8E352B14C}
+		{EEDF772D-5D2B-4C0F-B5C8-0A5828917847}.0 = {0959DD50-BCBA-4551-9617-E6FD4DF85298}
+		{EEDF772D-5D2B-4C0F-B5C8-0A5828917847}.1 = {ACB93D0D-F6CB-480B-9B20-CE6C5EDC13BD}
+		{EEDF772D-5D2B-4C0F-B5C8-0A5828917847}.2 = {C79C9037-8F32-4833-A276-96B2FB96CCA5}
+		{EEDF772D-5D2B-4C0F-B5C8-0A5828917847}.3 = {A0451C0A-0B2F-400A-BBB1-98F517FAB30B}
+		{EEDF772D-5D2B-4C0F-B5C8-0A5828917847}.4 = {613EA919-780E-416D-90A9-67D3EB27F899}
+	EndGlobalSection
+	GlobalSection(ProjectConfiguration) = postSolution
+		{4DC69D68-9DB8-4DEB-AC63-481153B1F41D}.Debug.ActiveCfg = Debug|Win32
+		{4DC69D68-9DB8-4DEB-AC63-481153B1F41D}.Debug.Build.0 = Debug|Win32
+		{4DC69D68-9DB8-4DEB-AC63-481153B1F41D}.Debug(SH).ActiveCfg = Debug(SH)|Win32
+		{4DC69D68-9DB8-4DEB-AC63-481153B1F41D}.Debug(SH).Build.0 = Debug(SH)|Win32
+		{4DC69D68-9DB8-4DEB-AC63-481153B1F41D}.Final.ActiveCfg = Final|Win32
+		{4DC69D68-9DB8-4DEB-AC63-481153B1F41D}.Final.Build.0 = Final|Win32
+		{4DC69D68-9DB8-4DEB-AC63-481153B1F41D}.Release.ActiveCfg = Release|Win32
+		{4DC69D68-9DB8-4DEB-AC63-481153B1F41D}.Release.Build.0 = Release|Win32
+		{5B587283-8429-4F8B-AECA-C09BF364B617}.Debug.ActiveCfg = Debug|Win32
+		{5B587283-8429-4F8B-AECA-C09BF364B617}.Debug.Build.0 = Debug|Win32
+		{5B587283-8429-4F8B-AECA-C09BF364B617}.Debug(SH).ActiveCfg = Debug(SH)|Win32
+		{5B587283-8429-4F8B-AECA-C09BF364B617}.Debug(SH).Build.0 = Debug(SH)|Win32
+		{5B587283-8429-4F8B-AECA-C09BF364B617}.Final.ActiveCfg = Final|Win32
+		{5B587283-8429-4F8B-AECA-C09BF364B617}.Final.Build.0 = Final|Win32
+		{5B587283-8429-4F8B-AECA-C09BF364B617}.Release.ActiveCfg = Release|Win32
+		{5B587283-8429-4F8B-AECA-C09BF364B617}.Release.Build.0 = Release|Win32
+		{149BAC28-9F08-4C08-BD4E-02D01A0DAD1F}.Debug.ActiveCfg = Debug|Win32
+		{149BAC28-9F08-4C08-BD4E-02D01A0DAD1F}.Debug(SH).ActiveCfg = Debug|Win32
+		{149BAC28-9F08-4C08-BD4E-02D01A0DAD1F}.Final.ActiveCfg = Debug|Win32
+		{149BAC28-9F08-4C08-BD4E-02D01A0DAD1F}.Release.ActiveCfg = Release|Win32
+		{07CCC82A-B905-4384-8AC5-E8A8E352B14C}.Debug.ActiveCfg = Debug|Win32
+		{07CCC82A-B905-4384-8AC5-E8A8E352B14C}.Debug.Build.0 = Debug|Win32
+		{07CCC82A-B905-4384-8AC5-E8A8E352B14C}.Debug(SH).ActiveCfg = Debug(SH)|Win32
+		{07CCC82A-B905-4384-8AC5-E8A8E352B14C}.Debug(SH).Build.0 = Debug(SH)|Win32
+		{07CCC82A-B905-4384-8AC5-E8A8E352B14C}.Final.ActiveCfg = Final|Win32
+		{07CCC82A-B905-4384-8AC5-E8A8E352B14C}.Final.Build.0 = Final|Win32
+		{07CCC82A-B905-4384-8AC5-E8A8E352B14C}.Release.ActiveCfg = Release|Win32
+		{07CCC82A-B905-4384-8AC5-E8A8E352B14C}.Release.Build.0 = Release|Win32
+		{36D7BB4B-5943-4477-AD6A-7B96CC0AB71A}.Debug.ActiveCfg = Debug|Win32
+		{36D7BB4B-5943-4477-AD6A-7B96CC0AB71A}.Debug.Build.0 = Debug|Win32
+		{36D7BB4B-5943-4477-AD6A-7B96CC0AB71A}.Debug(SH).ActiveCfg = Debug(SH)|Win32
+		{36D7BB4B-5943-4477-AD6A-7B96CC0AB71A}.Debug(SH).Build.0 = Debug(SH)|Win32
+		{36D7BB4B-5943-4477-AD6A-7B96CC0AB71A}.Final.ActiveCfg = Final|Win32
+		{36D7BB4B-5943-4477-AD6A-7B96CC0AB71A}.Final.Build.0 = Final|Win32
+		{36D7BB4B-5943-4477-AD6A-7B96CC0AB71A}.Release.ActiveCfg = Release|Win32
+		{36D7BB4B-5943-4477-AD6A-7B96CC0AB71A}.Release.Build.0 = Release|Win32
+		{2DDA2041-6A68-4754-B342-14039CC91695}.Debug.ActiveCfg = Debug|Win32
+		{2DDA2041-6A68-4754-B342-14039CC91695}.Debug.Build.0 = Debug|Win32
+		{2DDA2041-6A68-4754-B342-14039CC91695}.Debug(SH).ActiveCfg = Debug(SH)|Win32
+		{2DDA2041-6A68-4754-B342-14039CC91695}.Debug(SH).Build.0 = Debug(SH)|Win32
+		{2DDA2041-6A68-4754-B342-14039CC91695}.Final.ActiveCfg = Final|Win32
+		{2DDA2041-6A68-4754-B342-14039CC91695}.Final.Build.0 = Final|Win32
+		{2DDA2041-6A68-4754-B342-14039CC91695}.Release.ActiveCfg = Release|Win32
+		{2DDA2041-6A68-4754-B342-14039CC91695}.Release.Build.0 = Release|Win32
+		{ACB93D0D-F6CB-480B-9B20-CE6C5EDC13BD}.Debug.ActiveCfg = Debug|Xbox
+		{ACB93D0D-F6CB-480B-9B20-CE6C5EDC13BD}.Debug.Build.0 = Debug|Xbox
+		{ACB93D0D-F6CB-480B-9B20-CE6C5EDC13BD}.Debug(SH).ActiveCfg = Debug|Xbox
+		{ACB93D0D-F6CB-480B-9B20-CE6C5EDC13BD}.Final.ActiveCfg = Release|Xbox
+		{ACB93D0D-F6CB-480B-9B20-CE6C5EDC13BD}.Final.Build.0 = Release|Xbox
+		{ACB93D0D-F6CB-480B-9B20-CE6C5EDC13BD}.Release.ActiveCfg = Release|Xbox
+		{ACB93D0D-F6CB-480B-9B20-CE6C5EDC13BD}.Release.Build.0 = Release|Xbox
+		{EEDF772D-5D2B-4C0F-B5C8-0A5828917847}.Debug.ActiveCfg = Debug|Xbox
+		{EEDF772D-5D2B-4C0F-B5C8-0A5828917847}.Debug.Build.0 = Debug|Xbox
+		{EEDF772D-5D2B-4C0F-B5C8-0A5828917847}.Debug(SH).ActiveCfg = Debug|Xbox
+		{EEDF772D-5D2B-4C0F-B5C8-0A5828917847}.Final.ActiveCfg = Release|Xbox
+		{EEDF772D-5D2B-4C0F-B5C8-0A5828917847}.Final.Build.0 = Release|Xbox
+		{EEDF772D-5D2B-4C0F-B5C8-0A5828917847}.Release.ActiveCfg = Release|Xbox
+		{EEDF772D-5D2B-4C0F-B5C8-0A5828917847}.Release.Build.0 = Release|Xbox
+		{C79C9037-8F32-4833-A276-96B2FB96CCA5}.Debug.ActiveCfg = Debug|Xbox
+		{C79C9037-8F32-4833-A276-96B2FB96CCA5}.Debug.Build.0 = Debug|Xbox
+		{C79C9037-8F32-4833-A276-96B2FB96CCA5}.Debug(SH).ActiveCfg = Debug|Xbox
+		{C79C9037-8F32-4833-A276-96B2FB96CCA5}.Final.ActiveCfg = Release|Xbox
+		{C79C9037-8F32-4833-A276-96B2FB96CCA5}.Final.Build.0 = Release|Xbox
+		{C79C9037-8F32-4833-A276-96B2FB96CCA5}.Release.ActiveCfg = Release|Xbox
+		{C79C9037-8F32-4833-A276-96B2FB96CCA5}.Release.Build.0 = Release|Xbox
+		{A0451C0A-0B2F-400A-BBB1-98F517FAB30B}.Debug.ActiveCfg = Debug|Xbox
+		{A0451C0A-0B2F-400A-BBB1-98F517FAB30B}.Debug.Build.0 = Debug|Xbox
+		{A0451C0A-0B2F-400A-BBB1-98F517FAB30B}.Debug(SH).ActiveCfg = Debug|Xbox
+		{A0451C0A-0B2F-400A-BBB1-98F517FAB30B}.Final.ActiveCfg = Release|Xbox
+		{A0451C0A-0B2F-400A-BBB1-98F517FAB30B}.Final.Build.0 = Release|Xbox
+		{A0451C0A-0B2F-400A-BBB1-98F517FAB30B}.Release.ActiveCfg = Release|Xbox
+		{A0451C0A-0B2F-400A-BBB1-98F517FAB30B}.Release.Build.0 = Release|Xbox
+		{613EA919-780E-416D-90A9-67D3EB27F899}.Debug.ActiveCfg = Debug|Xbox
+		{613EA919-780E-416D-90A9-67D3EB27F899}.Debug.Build.0 = Debug|Xbox
+		{613EA919-780E-416D-90A9-67D3EB27F899}.Debug(SH).ActiveCfg = Debug|Xbox
+		{613EA919-780E-416D-90A9-67D3EB27F899}.Final.ActiveCfg = Release|Xbox
+		{613EA919-780E-416D-90A9-67D3EB27F899}.Final.Build.0 = Release|Xbox
+		{613EA919-780E-416D-90A9-67D3EB27F899}.Release.ActiveCfg = Release|Xbox
+		{613EA919-780E-416D-90A9-67D3EB27F899}.Release.Build.0 = Release|Xbox
+		{0959DD50-BCBA-4551-9617-E6FD4DF85298}.Debug.ActiveCfg = Debug|Xbox
+		{0959DD50-BCBA-4551-9617-E6FD4DF85298}.Debug.Build.0 = Debug|Xbox
+		{0959DD50-BCBA-4551-9617-E6FD4DF85298}.Debug(SH).ActiveCfg = Debug|Xbox
+		{0959DD50-BCBA-4551-9617-E6FD4DF85298}.Final.ActiveCfg = Release|Xbox
+		{0959DD50-BCBA-4551-9617-E6FD4DF85298}.Final.Build.0 = Release|Xbox
+		{0959DD50-BCBA-4551-9617-E6FD4DF85298}.Release.ActiveCfg = Release|Xbox
+		{0959DD50-BCBA-4551-9617-E6FD4DF85298}.Release.Build.0 = Release|Xbox
+	EndGlobalSection
+	GlobalSection(SolutionItems) = postSolution
+		Item:1 = CommandLine.txt
+		Item:2 = install.bat
+		Item:3 = VU.bat
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+	EndGlobalSection
+	GlobalSection(ExtensibilityAddIns) = postSolution
+	EndGlobalSection
+	GlobalSection(DevPartner) = postSolution
+	EndGlobalSection
+EndGlobal
diff --git a/codemp/JKA_mp.vssscc b/codemp/JKA_mp.vssscc
new file mode 100644
index 0000000..794f014
--- /dev/null
+++ b/codemp/JKA_mp.vssscc
@@ -0,0 +1,10 @@
+""
+{
+"FILE_VERSION" = "9237"
+"ENLISTMENT_CHOICE" = "NEVER"
+"PROJECT_FILE_RELATIVE_PATH" = ""
+"NUMBER_OF_EXCLUDED_FILES" = "0"
+"ORIGINAL_PROJECT_FILE_PATH" = ""
+"NUMBER_OF_NESTED_PROJECTS" = "0"
+"SOURCE_CONTROL_SETTINGS_PROVIDER" = "PROJECT"
+}
diff --git a/codemp/OpenAL32.dll b/codemp/OpenAL32.dll
new file mode 100644
index 0000000..1b2c553
Binary files /dev/null and b/codemp/OpenAL32.dll differ
diff --git a/codemp/OpenAL32.lib b/codemp/OpenAL32.lib
new file mode 100644
index 0000000..86de420
Binary files /dev/null and b/codemp/OpenAL32.lib differ
diff --git a/codemp/RMG/RM_Area.cpp b/codemp/RMG/RM_Area.cpp
new file mode 100644
index 0000000..ae4d536
--- /dev/null
+++ b/codemp/RMG/RM_Area.cpp
@@ -0,0 +1,478 @@
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+/************************************************************************************************
+ *
+ *	Copyright (C) 2001-2002 Raven Software
+ *
+ *  RM_Area.cpp
+ *
+ ************************************************************************************************/
+
+#include "RM_Headers.h"
+
+#ifdef _WIN32
+#pragma optimize("p", on)
+#endif
+
+/************************************************************************************************
+ * CRMArea::CRMArea
+ *	constructor
+ *
+ * inputs:
+ *  none
+ *
+ * return:
+ *	none
+ *
+ ************************************************************************************************/
+CRMArea::CRMArea ( 
+	float	spacingRadius,
+	float	paddingSize,
+	float	confineRadius,
+	vec3_t	confineOrigin,
+	vec3_t	lookAtOrigin,
+	bool	flatten,
+	int		symmetric
+	) 
+{
+	mMoveCount		= 0;
+	mAngle			= 0;
+	mCollision		= true;
+	mConfineRadius	= confineRadius;
+	mPaddingSize    = paddingSize;
+	mSpacingRadius  = spacingRadius;
+	mFlatten		= flatten;
+	mLookAt			= true;
+	mLockOrigin		= false;
+	mSymmetric		= symmetric;
+	mRadius			= spacingRadius;
+
+	VectorCopy ( confineOrigin, mConfineOrigin );
+	VectorCopy ( lookAtOrigin, mLookAtOrigin );
+}
+
+/************************************************************************************************
+ * CRMArea::LookAt
+ *	Angle the area towards the given point
+ *
+ * inputs:
+ *  lookat - the origin to look at
+ *
+ * return:
+ *	the angle in radians that was calculated
+ *
+ ************************************************************************************************/
+float CRMArea::LookAt ( vec3_t lookat )
+{
+	if (mLookAt)
+	{	// this area orients itself towards a point
+		vec3_t a;
+
+		VectorCopy ( lookat, mLookAtOrigin );
+		VectorSubtract ( lookat, mOrigin, a );
+
+		mAngle = atan2 ( a[1], a[0] );
+	}
+
+	return mAngle;
+}
+
+/************************************************************************************************
+ * CRMArea::Mirror
+ *	Mirrors the area to the other side of the map.  This includes mirroring the confine origin
+ *  and lookat origin
+ *
+ * inputs:
+ *  none
+ *
+ * return:
+ *	none
+ *
+ ************************************************************************************************/
+void CRMArea::Mirror ( void )
+{
+	mOrigin[0] = -mOrigin[0];
+	mOrigin[1] = -mOrigin[1];
+
+	mConfineOrigin[0] = -mConfineOrigin[0];
+	mConfineOrigin[1] = -mConfineOrigin[1];
+
+	mLookAtOrigin[0] = -mLookAtOrigin[0];
+	mLookAtOrigin[1] = -mLookAtOrigin[1];
+}
+
+/************************************************************************************************
+ * CRMAreaManager::CRMAreaManager
+ *	constructor
+ *
+ * inputs:
+ *  none
+ *
+ * return:
+ *	none
+ *
+ ************************************************************************************************/
+CRMAreaManager::CRMAreaManager ( const vec3_t mins, const vec3_t maxs)
+{
+	VectorCopy ( mins, mMins );
+	VectorCopy ( maxs, mMaxs );
+
+	mWidth  = mMaxs[0] - mMins[0];
+	mHeight = mMaxs[1] - mMins[1];
+}
+
+/************************************************************************************************
+ * CRMAreaManager::~CRMAreaManager
+ *	Removes all managed areas
+ *
+ * inputs:
+ *  none
+ *
+ * return:
+ *	none
+ *
+ ************************************************************************************************/
+CRMAreaManager::~CRMAreaManager ( )
+{
+	int i;
+
+	for ( i = mAreas.size() - 1; i >=0; i -- )
+	{
+		delete mAreas[i];
+	}
+
+	mAreas.clear();
+}
+
+/************************************************************************************************
+ * CRMAreaManager::MoveArea
+ *	Moves an area within the area manager thus shifting any other areas as needed
+ *
+ * inputs:
+ *  area   - area to be moved
+ *  origin - new origin to attempt to move to
+ *
+ * return:
+ *	none
+ *
+ ************************************************************************************************/
+void CRMAreaManager::MoveArea ( CRMArea* movedArea, vec3_t origin)
+{
+	int	index;
+	int size;
+
+	// Increment the addcount (this is for infinite protection)
+	movedArea->AddMoveCount ();
+	
+	// Infinite recursion prevention
+	if ( movedArea->GetMoveCount() > 250 )
+	{
+//		assert ( 0 );
+		movedArea->EnableCollision ( false );
+		return;
+	}
+
+	// First set the area's origin, This may cause it to be in collision with
+	// another area but that will get fixed later
+	movedArea->SetOrigin ( origin );
+
+	// when symmetric we want to ensure that no instances end up on the "other" side of the imaginary diaganol that cuts the map in two
+	// mSymmetric tells us which side of the map is legal
+	if ( movedArea->GetSymmetric ( ) )
+	{
+		const vec3pair_t& bounds = TheRandomMissionManager->GetLandScape()->GetBounds();
+		
+		vec3_t point;
+		vec3_t dir;
+		vec3_t tang;
+		bool   push;
+		float  len;
+
+		VectorSubtract( movedArea->GetOrigin(), bounds[0], point );
+		VectorSubtract( bounds[1], bounds[0], dir );
+		VectorNormalize(dir);	
+
+		dir[2] = 0;
+		point[2] = 0;
+		VectorMA( bounds[0], DotProduct(point, dir), dir, tang );
+		VectorSubtract ( movedArea->GetOrigin(), tang, dir );
+
+		dir[2] = 0;
+		push   = false;
+		len    = VectorNormalize(dir);
+
+		if ( len < movedArea->GetRadius ( ) )
+		{
+			if ( movedArea->GetLockOrigin ( ) )
+			{
+				movedArea->EnableCollision ( false );
+				return;
+			}
+
+			VectorMA ( point, (movedArea->GetSpacingRadius() - len) + TheRandomMissionManager->GetLandScape()->irand(10,movedArea->GetSpacingRadius()), dir, point );
+			origin[0] = point[0] + bounds[0][0];
+			origin[1] = point[1] + bounds[0][1];
+			movedArea->SetOrigin ( origin );
+		}
+
+		switch ( movedArea->GetSymmetric ( ) )
+		{
+			case SYMMETRY_TOPLEFT:
+				if ( origin[1] > origin[0] )
+				{
+					movedArea->Mirror ( );
+				}
+				break;
+
+			case SYMMETRY_BOTTOMRIGHT:
+				if ( origin[1] < origin[0] )
+				{ 
+					movedArea->Mirror ( );
+				}
+
+				break;
+
+			default:
+				// unknown symmetry type
+				assert ( 0 );
+				break;
+		}
+	}
+
+	// Confine to area unless we are being pushed back by the same guy who pushed us last time (infinite loop)
+	if ( movedArea->GetConfineRadius() )
+	{
+		if ( movedArea->GetMoveCount() < 25 )
+		{
+			vec3_t cdiff;
+			float  cdist;
+
+			VectorSubtract ( movedArea->GetOrigin(), movedArea->GetConfineOrigin(), cdiff );
+			cdiff[2] = 0;
+			cdist = VectorLength ( cdiff );
+
+			if ( cdist + movedArea->GetSpacingRadius() > movedArea->GetConfineRadius() )
+			{
+				cdist = movedArea->GetConfineRadius() - movedArea->GetSpacingRadius();
+				VectorNormalize ( cdiff );
+		
+				VectorMA ( movedArea->GetConfineOrigin(), cdist, cdiff, movedArea->GetOrigin());
+			}	
+		}
+		else
+		{
+			index = 0;
+		}
+	}
+
+	// See if it fell off the world in the x direction
+	if ( movedArea->GetOrigin()[0] + movedArea->GetSpacingRadius() > mMaxs[0] )
+		movedArea->GetOrigin()[0] = mMaxs[0] - movedArea->GetSpacingRadius() - (TheRandomMissionManager->GetLandScape()->irand(10,200));
+	else if ( movedArea->GetOrigin()[0] - movedArea->GetSpacingRadius() < mMins[0] )
+		movedArea->GetOrigin()[0] = mMins[0] + movedArea->GetSpacingRadius() + (TheRandomMissionManager->GetLandScape()->irand(10,200));
+
+	// See if it fell off the world in the y direction
+	if ( movedArea->GetOrigin()[1] + movedArea->GetSpacingRadius() > mMaxs[1] )
+		movedArea->GetOrigin()[1] = mMaxs[1] - movedArea->GetSpacingRadius() - (TheRandomMissionManager->GetLandScape()->irand(10,200));
+	else if ( movedArea->GetOrigin()[1] - movedArea->GetSpacingRadius() < mMins[1] )
+		movedArea->GetOrigin()[1] = mMins[1] + movedArea->GetSpacingRadius() + (TheRandomMissionManager->GetLandScape()->irand(10,200));
+
+	// Look at what we need to look at
+	movedArea->LookAt ( movedArea->GetLookAtOrigin() );
+	
+	// Dont collide against things that have no collision
+//	if ( !movedArea->IsCollisionEnabled ( ) )
+//	{
+//		return;
+//	}
+
+	// See if its colliding
+	for(index = 0, size = mAreas.size(); index < size; index ++ )
+	{
+		CRMArea	*area = mAreas[index];
+		vec3_t	diff;
+		vec3_t	newOrigin;
+		float	dist;
+		float	targetdist;
+
+		// Skip the one that was moved in the first place
+		if ( area == movedArea )
+		{
+			continue;
+		}
+
+		if ( area->GetLockOrigin ( ) && movedArea->GetLockOrigin( ) )
+		{
+			continue;
+		}
+
+		// Dont collide against things that have no collision
+		if ( !area->IsCollisionEnabled ( ) )
+		{
+			continue;
+		}
+
+		// Grab the distance between the two
+		// only want the horizontal distance -- dmv
+		//dist		= Distance ( movedArea->GetOrigin ( ), area->GetOrigin ( ));
+		vec3_t	maOrigin;
+		vec3_t	aOrigin;
+		VectorCopy(movedArea->GetOrigin(), maOrigin);
+		VectorCopy(area->GetOrigin(), aOrigin);
+		maOrigin[2] = aOrigin[2] = 0;
+		dist		= Distance ( maOrigin, aOrigin );
+		targetdist  = movedArea->GetSpacingRadius() + area->GetSpacingRadius() + maximum(movedArea->GetPaddingSize(),area->GetPaddingSize());
+
+		if ( dist == 0 )
+		{
+			area->GetOrigin()[0] += (50 * (float)(TheRandomMissionManager->GetLandScape()->irand(0,99))/100.0f);
+			area->GetOrigin()[1] += (50 * (float)(TheRandomMissionManager->GetLandScape()->irand(0,99))/100.0f);
+
+			VectorCopy(area->GetOrigin(), aOrigin);
+			aOrigin[2] = 0;
+
+			dist = Distance ( maOrigin, aOrigin );
+		}
+
+		// Are they are enough apart?
+		if ( dist >= targetdist )
+		{
+			continue;	
+		}
+
+		// Dont move a step if locked
+		if ( area->GetLockOrigin ( ) )
+		{
+			MoveArea ( area, area->GetOrigin ( ) );			
+			continue;
+		}
+
+		// we got a collision, move the guy we hit
+		VectorSubtract ( area->GetOrigin(), movedArea->GetOrigin(), diff );
+		diff[2] = 0;
+		VectorNormalize ( diff );
+
+		// Push by the difference in the distance and no-collide radius
+		VectorMA ( area->GetOrigin(), targetdist - dist + 1 , diff, newOrigin );
+
+		// Move the area now
+		MoveArea ( area, newOrigin );
+	}
+}
+
+/************************************************************************************************
+ * CRMAreaManager::CreateArea
+ *	Creates an area and adds it to the list of managed areas
+ *
+ * inputs:
+ *  none
+ *
+ * return:
+ *	a pointer to the newly added area class
+ *
+ ************************************************************************************************/
+CRMArea* CRMAreaManager::CreateArea ( 
+	vec3_t	origin, 
+	float	spacingRadius,
+	int		spacingLine,
+	float	paddingSize,
+	float	confineRadius,
+	vec3_t	confineOrigin,
+	vec3_t	lookAtOrigin,
+	bool	flatten,
+	bool	collide,
+	bool	lockorigin,
+	int		symmetric
+	)
+{
+	CRMArea* area = new CRMArea ( spacingRadius, paddingSize, confineRadius, confineOrigin, lookAtOrigin, flatten, symmetric );
+
+	if ( lockorigin || spacingLine )
+	{
+		area->LockOrigin ( );
+	}
+
+	if (origin[0] != lookAtOrigin[0] || origin[1] != lookAtOrigin[1])
+		area->EnableLookAt(true);
+
+	// First add the area to the list
+	mAreas.push_back ( area );
+
+	area->EnableCollision(collide);
+
+	// Set the real radius which is used for center line detection
+	if ( spacingLine )
+	{
+		area->SetRadius ( spacingRadius + (spacingLine - 1) * spacingRadius );
+	}
+
+	// Now move the area around
+	MoveArea ( area, origin );
+
+	if ( (origin[0] != lookAtOrigin[0] || origin[1] != lookAtOrigin[1]) )
+	{
+		int i;
+		vec3_t	 linedir;
+		vec3_t	 dir;
+		vec3_t   up = {0,0,1};
+
+		VectorSubtract ( lookAtOrigin, origin, dir );
+		VectorNormalize ( dir );
+		dir[2] = 0;
+		CrossProduct ( dir, up, linedir );
+
+		for ( i = 0; i < spacingLine - 1; i ++ )
+		{
+			CRMArea* linearea;
+			vec3_t	 lineorigin;
+
+			linearea = new CRMArea ( spacingRadius, paddingSize, 0, vec3_origin, vec3_origin, false, symmetric );
+			linearea->LockOrigin ( );
+			linearea->EnableCollision(collide);
+
+			VectorMA ( origin, spacingRadius + (spacingRadius * 2 * i), linedir, lineorigin );
+			mAreas.push_back ( linearea );				
+			MoveArea ( linearea, lineorigin );
+
+			linearea = new CRMArea ( spacingRadius, paddingSize, 0, vec3_origin, vec3_origin, false, symmetric );
+			linearea->LockOrigin ( );
+			linearea->EnableCollision(collide);
+
+			VectorMA ( origin, -spacingRadius - (spacingRadius * 2 * i), linedir, lineorigin );
+			mAreas.push_back ( linearea );				
+			MoveArea ( linearea, lineorigin );
+		}
+	}
+
+	// Return it for convienience
+	return area;
+}
+
+/************************************************************************************************
+ * CRMAreaManager::EnumArea
+ *	Allows for enumeration through the area list. If an invalid index is given then NULL will
+ *  be returned;
+ *
+ * inputs:
+ *  index - current enumeration index
+ *
+ * return:
+ *	requested area class pointer or NULL if the index was invalid
+ *
+ ************************************************************************************************/
+CRMArea* CRMAreaManager::EnumArea ( const int index )
+{
+	// This isnt an assertion case because there is no size method for
+	// the area manager so the areas are enumerated until NULL is returned.
+	if ( index < 0 || index >= mAreas.size ( ) )
+	{
+		return NULL;
+	}
+
+	return mAreas[index];
+}
+
+#ifdef _WIN32
+#pragma optimize("p", off)
+#endif
diff --git a/codemp/RMG/RM_Area.h b/codemp/RMG/RM_Area.h
new file mode 100644
index 0000000..b731f47
--- /dev/null
+++ b/codemp/RMG/RM_Area.h
@@ -0,0 +1,99 @@
+/************************************************************************************************
+ *
+ *	Copyright (C) 2001-2002 Raven Software
+ *
+ *  RM_Area.h
+ *
+ ************************************************************************************************/
+
+#pragma once
+#if !defined(RM_AREA_H_INC)
+#define RM_AREA_H_INC
+
+#ifdef DEBUG_LINKING
+	#pragma message("...including RM_Area.h")
+#endif
+
+class CRMArea
+{
+private:
+
+	float		mPaddingSize;
+	float		mSpacingRadius;
+	float		mConfineRadius;
+	float		mRadius;
+	float		mAngle;
+	int			mMoveCount;
+	vec3_t		mOrigin;
+	vec3_t		mConfineOrigin;
+	vec3_t		mLookAtOrigin;
+	bool		mCollision;
+	bool		mFlatten;
+	bool		mLookAt;
+	bool		mLockOrigin;
+	int			mSymmetric;
+
+public:
+
+	CRMArea ( float spacing, float padding, float confine, vec3_t confineOrigin, vec3_t lookAtOrigin, bool flatten = true, int symmetric = 0 );
+
+	void	Mirror ( void );
+
+	void	SetOrigin(vec3_t origin) { VectorCopy ( origin, mOrigin ); }
+	void	SetAngle(float angle)	 { mAngle = angle; }
+	void	SetSymmetric(int sym)    { mSymmetric = sym; }
+
+	void	EnableCollision(bool e)	 { mCollision = e; }
+	void	EnableLookAt(bool la) {mLookAt = la; }
+
+	float	LookAt(vec3_t lookat);
+	void	LockOrigin( void )	{ mLockOrigin = true; }
+
+	void	AddMoveCount()		{ mMoveCount++; }
+	void	ClearMoveCount()	{ mMoveCount=0; }
+
+	float	GetPaddingSize()	{ return mPaddingSize; }
+	float	GetSpacingRadius()	{ return mSpacingRadius; }
+	float	GetRadius()			{ return mRadius; }
+	float	GetConfineRadius()	{ return mConfineRadius; }
+	float	GetAngle()			{ return mAngle; }
+	int		GetMoveCount()		{ return mMoveCount; }
+	vec_t*	GetOrigin()			{ return mOrigin; }
+	vec_t*	GetConfineOrigin()	{ return mConfineOrigin; }
+	vec_t*	GetLookAtOrigin()	{ return mLookAtOrigin; }
+	bool	GetLookAt()			{ return mLookAt;}
+	bool	GetLockOrigin()		{ return mLockOrigin; }
+	int		GetSymmetric()		{ return mSymmetric; }
+
+	void	SetRadius(float r)	{ mRadius = r; }
+
+	bool	IsCollisionEnabled(){ return mCollision; }
+	bool	IsFlattened		  (){ return mFlatten; }
+};
+
+typedef vector<CRMArea*>			rmAreaVector_t;
+
+class CRMAreaManager
+{
+private:
+
+	rmAreaVector_t	mAreas;
+	vec3_t			mMins;
+	vec3_t			mMaxs;
+	float			mWidth;
+	float			mHeight;
+
+public:
+	
+	CRMAreaManager ( const vec3_t mins, const vec3_t maxs );
+	~CRMAreaManager ( );
+
+	CRMArea*	CreateArea		( vec3_t origin, float spacing, int spacingline, float padding, float confine, vec3_t confineOrigin, vec3_t lookAtOrigin, bool flatten=true, bool collide=true, bool lockorigin=false, int symmetric=0);
+	void		MoveArea		( CRMArea* area, vec3_t origin);
+	CRMArea*	EnumArea		( const int index );
+
+//	void		CreateMap		( void );
+};
+
+#endif
+
diff --git a/codemp/RMG/RM_Headers.h b/codemp/RMG/RM_Headers.h
new file mode 100644
index 0000000..8b960b7
--- /dev/null
+++ b/codemp/RMG/RM_Headers.h
@@ -0,0 +1,73 @@
+#pragma once
+#if !defined(RM_HEADERS_H_INC)
+#define RM_HEADERS_H_INC
+
+#ifdef DEBUG_LINKING
+	#pragma message("...including RM_Headers.h")
+#endif
+
+#pragma warning (push, 3)
+#include <vector>
+#include <list>
+#pragma warning (pop)
+
+using namespace std;
+
+#if !defined(GENERICPARSER2_H_INC)
+#include "../qcommon/GenericParser2.h"
+#endif
+
+#if !defined(CM_LOCAL_H_INC)
+#include "../qcommon/cm_local.h"
+#endif
+
+#include "../client/client.h"
+
+#define MAX_INSTANCE_TRIES			5
+
+// on a symmetric map which corner is the first node
+typedef enum
+{
+	SYMMETRY_NONE,
+	SYMMETRY_TOPLEFT,
+	SYMMETRY_BOTTOMRIGHT
+
+} symmetry_t;
+
+#if !defined(CM_TERRAINMAP_H_INC)
+	#include "../qcommon/cm_terrainmap.h"
+#endif
+
+#if !defined(RM_AREA_H_INC)
+	#include "RM_Area.h"
+#endif
+
+#if !defined(RM_PATH_H_INC)
+	#include "RM_Path.h"
+#endif
+
+#if !defined(RM_OBJECTIVE_H_INC)
+	#include "RM_Objective.h"
+#endif
+
+#if !defined(RM_INSTANCEFILE_H_INC)
+	#include "RM_InstanceFile.h"
+#endif
+
+#if !defined(RM_INSTANCE_H_INC)
+	#include "RM_Instance.h"
+#endif
+
+#if !defined(RM_MISSION_H_INC)
+	#include "RM_Mission.h"
+#endif
+
+#if !defined(RM_MANAGER_H_INC)
+	#include "RM_Manager.h"
+#endif
+
+#if !defined(RM_TERRAIN_H_INC)
+	#include "RM_Terrain.h"
+#endif
+
+#endif
diff --git a/codemp/RMG/RM_Instance.cpp b/codemp/RMG/RM_Instance.cpp
new file mode 100644
index 0000000..0d698dc
--- /dev/null
+++ b/codemp/RMG/RM_Instance.cpp
@@ -0,0 +1,195 @@
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+#include "RM_Headers.h"
+#include "../qcommon/cm_terrainmap.h"
+
+/************************************************************************************************
+ * CRMInstance::CRMInstance
+ *	constructs a instnace object using the given parser group
+ *
+ * inputs:
+ *  instance:  parser group containing information about the instance
+ *
+ * return:
+ *	none
+ *
+ ************************************************************************************************/
+CRMInstance::CRMInstance ( CGPGroup *instGroup, CRMInstanceFile& instFile )
+{
+	mObjective		= NULL;
+	mSpacingRadius	= 0;
+	mFlattenRadius	= 0;
+	mFilter[0]		= mTeamFilter[0] = 0;
+	mArea			= NULL;
+	mAutomapSymbol  = 0;
+	mEntityID       = 0;
+	mSide			= 0;
+	mMirror			= 0;
+	mFlattenHeight	= 66;
+	mSpacingLine	= 0;
+	mSurfaceSprites = true;
+	mLockOrigin		= false;
+}
+
+/************************************************************************************************
+ * CRMInstance::PreSpawn
+ *	Prepares the instance for spawning by flattening the ground under it
+ *
+ * inputs:
+ *  landscape: landscape the instance will be spawned on
+ *
+ * return:
+ *	true: spawn preparation successful
+ *  false: spawn preparation failed
+ *
+ ************************************************************************************************/
+bool CRMInstance::PreSpawn ( CRandomTerrain* terrain, qboolean IsServer )
+{
+	vec3_t		origin;
+	CArea		area;
+
+	VectorCopy(GetOrigin(), origin);
+
+	if (mMirror)
+	{
+		origin[0] = TheRandomMissionManager->GetLandScape()->GetBounds()[0][0] + TheRandomMissionManager->GetLandScape()->GetBounds()[1][0] - origin[0];
+		origin[1] = TheRandomMissionManager->GetLandScape()->GetBounds()[0][1] + TheRandomMissionManager->GetLandScape()->GetBounds()[1][1] - origin[1];
+	}
+
+	const vec3_t&	  terxelSize = terrain->GetLandScape()->GetTerxelSize ( );
+	const vec3pair_t& bounds     = terrain->GetLandScape()->GetBounds();
+
+	// Align the instance to the center of a terxel
+	origin[0] = bounds[0][0] + (int)((origin[0] - bounds[0][0] + terxelSize[0] / 2) / terxelSize[0]) * terxelSize[0];
+	origin[1] = bounds[0][1] + (int)((origin[1] - bounds[0][1] + terxelSize[1] / 2) / terxelSize[1]) * terxelSize[1];
+
+
+	// This is BAD - By copying the mirrored origin back into the instance, you've now mirrored the original instance
+	// so when anything from this point on looks at the instance they'll be looking at a mirrored version but will be expecting the original
+	// so later in the spawn functions the instance will be re-mirrored, because it thinks the mInstances have not been changed
+//	VectorCopy(origin, GetOrigin());
+
+	// Flatten the area below the instance 
+	if ( GetFlattenRadius() )
+	{	
+		area.Init( origin, GetFlattenRadius(), 0.0f, AT_NONE, 0, 0 );
+		terrain->GetLandScape()->FlattenArea( &area, mFlattenHeight | (mSurfaceSprites?0:0x80), false, true, true );
+	}
+
+	return true;
+}
+
+/************************************************************************************************
+ * CRMInstance::PostSpawn
+ *	Finishes the spawn by linking any objectives into the world that are associated with it
+ *
+ * inputs:
+ *  landscape: landscape the instance was spawned on
+ *
+ * return:
+ *	true: post spawn successfull
+ *  false: post spawn failed
+ *
+ ************************************************************************************************/
+bool CRMInstance::PostSpawn ( CRandomTerrain* terrain, qboolean IsServer )
+{
+	if ( mObjective )
+	{
+		return mObjective->Link ( );
+	}
+
+	return true;
+}
+
+void CRMInstance::DrawAutomapSymbol()
+{
+	TheRandomMissionManager->AddAutomapSymbol ( GetAutomapSymbol(), GetOrigin(), GetSide ( ) );
+/*
+	// draw proper symbol on map for instance
+	switch (GetAutomapSymbol())
+	{
+		default:
+		case AUTOMAP_NONE:
+			if (HasObjective())
+				CM_TM_AddObjective(GetOrigin()[0], GetOrigin()[1], GetSide());
+			break;
+		case AUTOMAP_BLD:
+			CM_TM_AddBuilding(GetOrigin()[0], GetOrigin()[1], GetSide());
+			if (HasObjective())
+				CM_TM_AddObjective(GetOrigin()[0], GetOrigin()[1], GetSide());
+			break;
+		case AUTOMAP_OBJ:
+			CM_TM_AddObjective(GetOrigin()[0], GetOrigin()[1], GetSide());
+			break;
+		case AUTOMAP_START:
+			CM_TM_AddStart(GetOrigin()[0], GetOrigin()[1], GetSide());
+			break;
+		case AUTOMAP_END:
+			CM_TM_AddEnd(GetOrigin()[0], GetOrigin()[1], GetSide());
+			break;
+		case AUTOMAP_ENEMY:
+			if (HasObjective())
+				CM_TM_AddObjective(GetOrigin()[0], GetOrigin()[1]);
+			if (1 == Cvar_VariableIntegerValue("rmg_automapshowall"))
+				CM_TM_AddNPC(GetOrigin()[0], GetOrigin()[1], false);
+			break;
+		case AUTOMAP_FRIEND:
+			if (HasObjective())
+				CM_TM_AddObjective(GetOrigin()[0], GetOrigin()[1]);
+			if (1 == Cvar_VariableIntegerValue("rmg_automapshowall"))
+				CM_TM_AddNPC(GetOrigin()[0], GetOrigin()[1], true);
+			break;
+		case AUTOMAP_WALL:
+			CM_TM_AddWallRect(GetOrigin()[0], GetOrigin()[1], GetSide());
+			break;
+	}
+*/
+}
+
+/************************************************************************************************
+ * CRMInstance::Preview
+ *	Renderings debug information about the instance
+ *
+ * inputs:																   
+ *  none
+ *
+ * return:
+ *	none
+ *
+ ************************************************************************************************/
+void CRMInstance::Preview ( const vec3_t from )
+{
+/*	CEntity				*tent;
+
+	// Add a cylindar for the whole settlement
+	tent = G_TempEntity( GetOrigin(), EV_DEBUG_CYLINDER );
+	VectorCopy( GetOrigin(), tent->s.origin2 );
+	tent->s.pos.trBase[2] += 40;
+	tent->s.origin2[2] += 50;
+	tent->s.time = 1050 + ((int)(GetSpacingRadius())<<16);
+	tent->s.time2 = GetPreviewColor ( );
+	G_AddTempEntity(tent);
+
+	// Origin line
+	tent = G_TempEntity( GetOrigin ( ), EV_DEBUG_LINE );
+	VectorCopy( GetOrigin(), tent->s.origin2 );
+	tent->s.origin2[2] += 400;
+	tent->s.time = 1050;
+	tent->s.weapon = 10;
+	tent->s.time2 = (255<<24) + (255<<16) + (255<<8) + 255;
+	G_AddTempEntity(tent);
+
+	if ( GetFlattenRadius ( ) )
+	{
+		// Add a cylindar for the whole settlement
+		tent = G_TempEntity( GetOrigin(), EV_DEBUG_CYLINDER );
+		VectorCopy( GetOrigin(), tent->s.origin2 );
+		tent->s.pos.trBase[2] += 40;
+		tent->s.origin2[2] += 50;
+		tent->s.time = 1050 + ((int)(GetFlattenRadius ( ))<<16);
+		tent->s.time2 = (255<<24) + (80<<16) +(80<<8) + 80;
+		G_AddTempEntity(tent);
+	}
+*/
+}
diff --git a/codemp/RMG/RM_Instance.h b/codemp/RMG/RM_Instance.h
new file mode 100644
index 0000000..3ed3fdf
--- /dev/null
+++ b/codemp/RMG/RM_Instance.h
@@ -0,0 +1,122 @@
+#pragma once
+#if !defined(RM_INSTANCE_H_INC)
+#define RM_INSTANCE_H_INC
+
+#ifdef DEBUG_LINKING
+	#pragma message("...including RM_Instance.h")
+#endif
+
+#if !defined(CM_LANDSCAPE_H_INC)
+#include "../qcommon/cm_landscape.h"
+#endif
+
+enum
+{
+	AUTOMAP_NONE = 0,
+	AUTOMAP_BLD  = 1,
+	AUTOMAP_OBJ  = 2,
+	AUTOMAP_START= 3,
+	AUTOMAP_END  = 4,
+	AUTOMAP_ENEMY= 5,
+	AUTOMAP_FRIEND=6,
+	AUTOMAP_WALL=7
+};
+
+class CRMInstance
+{
+protected:
+	char			mFilter[MAX_QPATH];			// filter of entities inside of this
+	char			mTeamFilter[MAX_QPATH];		// team specific filter
+
+	vec3pair_t		mBounds;		// Bounding box for instance itself
+
+	CRMArea*		mArea;			// Position of the instance
+
+	CRMObjective*	mObjective;		// Objective associated with this instance
+
+	// optional instance specific strings for objective
+	string			mMessage;		// message outputed when objective is completed
+	string			mDescription;	// description of objective
+	string			mInfo;			// more info for objective
+
+	float			mSpacingRadius;	// Radius to space instances with
+	float			mFlattenRadius;	// Radius to flatten under instances
+
+	int				mSpacingLine;	// Line of spacing radius's, forces locket
+	bool			mLockOrigin;	// Origin cant move
+
+	bool			mSurfaceSprites; // allow surface sprites under instance?
+
+	int				mAutomapSymbol; // show which symbol on automap 0=none
+
+	int				mEntityID;		// id of entity spawned
+	int				mSide;			// blue or red side
+	int				mMirror;		// mirror origin, angle
+
+	int				mFlattenHeight;	// height to flatten land
+
+public:
+	
+	CRMInstance ( CGPGroup* instance, CRMInstanceFile& instFile);
+
+	virtual ~CRMInstance ( ) { }
+
+	virtual bool		IsValid				( )	{ return true; }
+
+	virtual bool		PreSpawn			( CRandomTerrain* terrain, qboolean IsServer );
+	virtual bool		Spawn				( CRandomTerrain* terrain, qboolean IsServer ) { return false; }
+	virtual bool		PostSpawn			( CRandomTerrain* terrain, qboolean IsServer );
+
+	virtual void		Preview				( const vec3_t from );
+
+	virtual void		SetArea				( CRMAreaManager* amanager, CRMArea* area ) { mArea = area; }
+	virtual void		SetFilter			( const char *filter ) { strcpy(mFilter, filter); }
+	virtual void		SetTeamFilter		( const char *teamFilter ) { strcpy(mTeamFilter, teamFilter); }
+	void				SetObjective		( CRMObjective* obj ) { mObjective = obj; }
+	CRMObjective*		GetObjective		(void) {return mObjective;}
+	bool				HasObjective		() {return mObjective != NULL;}
+	int					GetAutomapSymbol	() {return mAutomapSymbol;}
+	void				DrawAutomapSymbol	();
+	const char*			GetMessage(void)	{ return mMessage.c_str(); }
+	const char*			GetDescription(void){ return mDescription.c_str(); }
+	const char*			GetInfo(void)		{ return mInfo.c_str(); }
+	void				SetMessage(const char* msg) { mMessage = msg; }
+	void				SetDescription(const char* desc) { mDescription = desc; }
+	void				SetInfo(const char* info) { mInfo = info; }
+	void				SetSide(int side)	{mSide = side;}
+	int					GetSide				( ) {return mSide;}
+
+	// NOTE: should consider making SetMirror also set all other variables that need flipping
+	// like the origin and Side, etc... Otherwise an Instance may have had it's origin flipped
+	// but then later will have mMirror set to false, but the origin is still flipped. So any functions
+	// that look at the instance later will see mMirror set to false, but not realize the origin has ALREADY been flipped
+	virtual void  		SetMirror(int mirror)	{ mMirror = mirror;}
+	int					GetMirror			( ) { return mMirror;}
+
+	virtual bool		GetSurfaceSprites	( )		{ return mSurfaceSprites; }
+
+	virtual bool		GetLockOrigin		( )		{ return mLockOrigin; }
+	virtual int			GetSpacingLine		( )		{ return mSpacingLine; }
+
+	virtual int			GetPreviewColor		( )		{ return 0; }
+	virtual float		GetSpacingRadius	( )		{ return mSpacingRadius; }
+	virtual float		GetFlattenRadius	( )		{ return mFlattenRadius; }
+	const char			*GetFilter			( )		{ return mFilter; }
+	const char			*GetTeamFilter		( )		{ return mTeamFilter; }
+	
+	CRMArea&			GetArea				( )		{ return *mArea; }
+	vec_t*				GetOrigin			( ) 	{return mArea->GetOrigin(); }
+	float				GetAngle			( )		{return mArea->GetAngle();}
+	void				SetAngle(float ang )		{ mArea->SetAngle(ang);}
+	const vec3pair_t&	GetBounds(void) const		{ return(mBounds); }
+
+	void				SetFlattenHeight	( int height ) { mFlattenHeight = height; }
+	int					GetFlattenHeight	( void )	   { return mFlattenHeight; }
+
+	void				SetSpacingRadius	(float spacing) { mSpacingRadius = spacing; }
+};
+
+typedef list<CRMInstance*>::iterator	rmInstanceIter_t;
+typedef list<CRMInstance*>				rmInstanceList_t;
+
+#endif
diff --git a/codemp/RMG/RM_InstanceFile.cpp b/codemp/RMG/RM_InstanceFile.cpp
new file mode 100644
index 0000000..66fd0af
--- /dev/null
+++ b/codemp/RMG/RM_InstanceFile.cpp
@@ -0,0 +1,201 @@
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+/************************************************************************************************
+ *
+ * RM_InstanceFile.cpp
+ *
+ * implements the CRMInstanceFile class.  This class provides functionality to load
+ * and create instances from an instance file.  First call Open to open the instance file and
+ * then use CreateInstance to create new instances.  When finished call Close to cleanup.
+ *
+ ************************************************************************************************/
+
+#include "RM_Headers.h"
+
+//#include "rm_instance_npc.h"
+#include "RM_Instance_BSP.h"
+#include "RM_Instance_Random.h"
+#include "RM_Instance_Group.h"
+#include "RM_Instance_Void.h"
+
+/************************************************************************************************
+ * CRMInstanceFile::CRMInstanceFile
+ *	constructor
+ *
+ * inputs:
+ *  none
+ *
+ * return:
+ *	none
+ *
+ ************************************************************************************************/
+CRMInstanceFile::CRMInstanceFile ( )
+{
+	mInstances = NULL;
+}
+
+/************************************************************************************************
+ * CRMInstanceFile::~CRMInstanceFile
+ *	Destroys the instance file by freeing the parser
+ *
+ * inputs:
+ *  none
+ *
+ * return:
+ *	none
+ *
+ ************************************************************************************************/
+CRMInstanceFile::~CRMInstanceFile ( )
+{
+	Close ( );
+}
+
+/************************************************************************************************
+ * CRMInstanceFile::Open
+ *	Opens the given instance file and prepares it for use in instance creation
+ *
+ * inputs:
+ *  instance: Name of instance to open.  Note that the root path will be automatically
+ *			  added and shouldnt be included in the given name
+ *
+ * return:
+ *	true: instance file successfully loaded 
+ *  false: instance file could not be loaded for some reason
+ *
+ ************************************************************************************************/
+bool CRMInstanceFile::Open ( const char* instance )
+{
+	char		instanceDef[MAX_QPATH];
+	CGPGroup	*basegroup;
+
+	// Build the filename
+	Com_sprintf(instanceDef, MAX_QPATH, "ext_data/rmg/%s.instance", instance );
+
+#ifndef FINAL_BUILD
+	// Debug message
+	Com_Printf("CM_Terrain: Loading and parsing instanceDef %s.....\n", instance);
+#endif
+
+	// Parse the text file using the generic parser
+	if(!Com_ParseTextFile(instanceDef, mParser ))
+	{
+		Com_sprintf(instanceDef, MAX_QPATH, "ext_data/arioche/%s.instance", instance );
+		if(!Com_ParseTextFile(instanceDef, mParser ))
+		{
+			Com_Printf(va("CM_Terrain: Could not open instance file '%s'\n", instanceDef));
+			return false;
+		}
+	}
+
+	// The whole file....
+	basegroup = mParser.GetBaseParseGroup();
+
+	// The root { } struct
+	mInstances = basegroup->GetSubGroups();
+
+	// The "instances" { } structure
+	mInstances = mInstances->GetSubGroups ( );
+
+	return true;
+}
+
+/************************************************************************************************
+ * CRMInstanceFile::Close
+ *	Closes an open instance file
+ *
+ * inputs:
+ *  none
+ *
+ * return:
+ *	none
+ *
+ ************************************************************************************************/
+void CRMInstanceFile::Close ( void )
+{
+	// If not open then dont close  it
+	if ( NULL == mInstances )
+	{
+		return;
+	}
+	mParser.Clean();
+		
+	mInstances = NULL;
+}
+
+/************************************************************************************************
+ * CRMInstanceFile::CreateInstance
+ *	Creates an instance (to be freed by caller) using the given instance name.
+ *
+ * inputs:
+ *  name: Name of the instance to read from the instance file
+ *
+ * return:
+ *	NULL: instance could not be read from the instance file
+ *  NON-NULL: instance created and returned for further use
+ *
+ ************************************************************************************************/
+CRMInstance* CRMInstanceFile::CreateInstance ( const char* name )
+{
+	static int instanceID = 0;
+
+	CGPGroup*		group;
+	CRMInstance*	instance;
+
+	// Make sure we were loaded
+	assert ( mInstances );
+
+	// Search through the instances for the one with the given name
+	for ( group = mInstances; group; group = group->GetNext ( ) )
+	{
+		// Skip it if the name doesnt match
+		if ( stricmp ( name, group->FindPairValue ( "name", "" ) ) )
+		{
+			continue;
+		}
+		
+		// Handle the various forms of instance types
+		if ( !stricmp ( group->GetName ( ), "bsp" ) )
+		{
+			instance = new CRMBSPInstance ( group, *this );
+		}
+		else if ( !stricmp ( group->GetName ( ), "npc" ) )
+		{
+//			instance = new CRMNPCInstance ( group, *this );
+			continue;
+		}
+		else if ( !stricmp ( group->GetName ( ), "group" ) )
+		{
+			instance = new CRMGroupInstance ( group, *this );
+		}
+		else if ( !stricmp ( group->GetName ( ), "random" ) )
+		{
+			instance = new CRMRandomInstance ( group, *this );
+		}
+		else if ( !stricmp ( group->GetName ( ), "void" ) )
+		{
+			instance = new CRMVoidInstance ( group, *this );
+		}
+		else
+		{
+			continue;
+		}
+
+		// If the instance isnt valid after being created then delete it
+		if ( !instance->IsValid ( ) )
+		{
+			delete instance;
+			return NULL;
+		}
+
+		// The instance was successfully created so return it
+		return instance;
+	}
+
+#ifndef FINAL_BUILD
+	// The instance wasnt found in the file so report it
+	Com_Printf(va("WARNING:  Instance '%s' was not found in the active instance file\n", name ));
+#endif
+
+	return NULL;
+}
diff --git a/codemp/RMG/RM_InstanceFile.h b/codemp/RMG/RM_InstanceFile.h
new file mode 100644
index 0000000..729722e
--- /dev/null
+++ b/codemp/RMG/RM_InstanceFile.h
@@ -0,0 +1,28 @@
+#pragma once
+#if !defined(RM_INSTANCEFILE_H_INC)
+#define RM_INSTANCEFILE_H_INC
+
+#ifdef DEBUG_LINKING
+	#pragma message("...including RM_InstanceFile.h")
+#endif
+
+class CRMInstance;
+
+class CRMInstanceFile
+{
+public:
+
+	CRMInstanceFile ( );
+	~CRMInstanceFile ( );
+
+	bool			Open			( const char* instance );
+	void			Close			( void );
+	CRMInstance*	CreateInstance	( const char* name );
+
+protected:
+
+	CGenericParser2		mParser;
+	CGPGroup*			mInstances;
+};
+
+#endif
\ No newline at end of file
diff --git a/codemp/RMG/RM_Instance_BSP.cpp b/codemp/RMG/RM_Instance_BSP.cpp
new file mode 100644
index 0000000..f5a91d7
--- /dev/null
+++ b/codemp/RMG/RM_Instance_BSP.cpp
@@ -0,0 +1,282 @@
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+/************************************************************************************************
+ *
+ * RM_Instance_BSP.cpp
+ *
+ * Implements the CRMBSPInstance class.  This class is reponsible for parsing a 
+ * bsp instance as well as spawning it into a landscape.
+ *
+ ************************************************************************************************/
+
+#include "../qcommon/cm_local.h"
+#include "../server/server.h"
+#include "RM_Headers.h"
+
+#include "RM_Instance_BSP.h"
+
+
+/************************************************************************************************
+ * CRMBSPInstance::CRMBSPInstance
+ *	constructs a building instance object using the given parser group
+ *
+ * inputs:
+ *  instance:  parser group containing information about the building instance
+ *
+ * return:
+ *	none
+ *
+ ************************************************************************************************/
+CRMBSPInstance::CRMBSPInstance(CGPGroup *instGroup, CRMInstanceFile& instFile)  : CRMInstance ( instGroup, instFile )
+{
+	strcpy(mBsp, instGroup->FindPairValue("file", ""));
+
+	mAngleVariance	= DEG2RAD(atof(instGroup->FindPairValue("anglevariance", "0")));
+	mBaseAngle		= DEG2RAD(atof(instGroup->FindPairValue("baseangle", "0")));
+	mAngleDiff		= DEG2RAD(atof(instGroup->FindPairValue("anglediff", "0")));
+	mSpacingRadius	= atof( instGroup->FindPairValue ( "spacing", "100" ) );
+	mSpacingLine	= atoi( instGroup->FindPairValue ( "spacingline", "0" ) );
+	mSurfaceSprites = (!Q_stricmp ( instGroup->FindPairValue ( "surfacesprites", "no" ), "yes")) ? true : false;
+	mLockOrigin     = (!Q_stricmp ( instGroup->FindPairValue ( "lockorigin", "no" ), "yes")) ? true : false;
+	mFlattenRadius	= atof( instGroup->FindPairValue ( "flatten", "0" ) );
+	mHoleRadius		= atof( instGroup->FindPairValue ( "hole", "0" ) );
+
+	const char * automapSymName = instGroup->FindPairValue ( "automap_symbol", "building" );
+	if (0 == Q_stricmp(automapSymName, "none"))	   	mAutomapSymbol = AUTOMAP_NONE ;
+	else if (0 == Q_stricmp(automapSymName, "building"))  	mAutomapSymbol = AUTOMAP_BLD  ;
+	else if (0 == Q_stricmp(automapSymName, "objective")) 	mAutomapSymbol = AUTOMAP_OBJ  ;
+	else if (0 == Q_stricmp(automapSymName, "start"))	   	mAutomapSymbol = AUTOMAP_START;
+	else if (0 == Q_stricmp(automapSymName, "end"))	   	mAutomapSymbol = AUTOMAP_END  ;
+	else if (0 == Q_stricmp(automapSymName, "enemy"))	   	mAutomapSymbol = AUTOMAP_ENEMY;
+	else if (0 == Q_stricmp(automapSymName, "friend"))	   	mAutomapSymbol = AUTOMAP_FRIEND;
+	else if (0 == Q_stricmp(automapSymName, "wall"))	   	mAutomapSymbol = AUTOMAP_WALL;
+	else mAutomapSymbol	= atoi( automapSymName );
+
+	// optional instance objective strings
+	SetMessage(instGroup->FindPairValue("objective_message",""));
+	SetDescription(instGroup->FindPairValue("objective_description",""));
+	SetInfo(instGroup->FindPairValue("objective_info",""));
+
+	mBounds[0][0] = 0;
+	mBounds[0][1] = 0;
+	mBounds[1][0] = 0;
+	mBounds[1][1] = 0;
+
+	mBaseAngle += (TheRandomMissionManager->GetLandScape()->irand(0,mAngleVariance) - mAngleVariance/2);
+}
+
+/************************************************************************************************
+ * CRMBSPInstance::Spawn
+ *	spawns a bsp into the world using the previously aquired origin
+ *
+ * inputs:
+ *  none
+ *
+ * return:
+ *	none
+ *
+ ************************************************************************************************/
+bool CRMBSPInstance::Spawn ( CRandomTerrain* terrain, qboolean IsServer)
+{
+#ifndef PRE_RELEASE_DEMO
+//	TEntity*	ent;
+	float		yaw;
+	char		temp[10000];
+	char		*savePtr;
+	vec3_t		origin;
+	vec3_t		notmirrored;
+	float	water_level = terrain->GetLandScape()->GetWaterHeight();
+
+	const vec3_t&	  terxelSize = terrain->GetLandScape()->GetTerxelSize ( );
+	const vec3pair_t& bounds     = terrain->GetLandScape()->GetBounds();
+
+	// If this entity somehow lost its collision flag then boot it
+	if ( !GetArea().IsCollisionEnabled ( ) )
+	{
+		return false;
+	}
+
+	// copy out the unmirrored version
+	VectorCopy(GetOrigin(), notmirrored);
+
+	// we want to mirror it before determining the Z value just in case the landscape isn't perfectly mirrored
+	if (mMirror)
+	{
+		GetOrigin()[0] = TheRandomMissionManager->GetLandScape()->GetBounds()[0][0] + TheRandomMissionManager->GetLandScape()->GetBounds()[1][0] - GetOrigin()[0];
+		GetOrigin()[1] = TheRandomMissionManager->GetLandScape()->GetBounds()[0][1] + TheRandomMissionManager->GetLandScape()->GetBounds()[1][1] - GetOrigin()[1];
+	}
+
+	// Align the instance to the center of a terxel
+	GetOrigin ( )[0] = bounds[0][0] + (int)((GetOrigin ( )[0] - bounds[0][0] + terxelSize[0] / 2) / terxelSize[0]) * terxelSize[0];
+	GetOrigin ( )[1] = bounds[0][1] + (int)((GetOrigin ( )[1] - bounds[0][1] + terxelSize[1] / 2) / terxelSize[1]) * terxelSize[1];
+
+	// Make sure the bsp is resting on the ground, not below or above it
+	// NOTE: This check is basically saying "is this instance not a bridge", because when instances are created they are all
+	// placed above the world's Z boundary, EXCEPT FOR BRIDGES. So this call to GetWorldHeight will move all other instances down to
+	// ground level except bridges 
+	if ( GetOrigin()[2] > terrain->GetBounds()[1][2] )
+	{
+		if( GetFlattenRadius() )
+		{
+			terrain->GetLandScape()->GetWorldHeight ( GetOrigin(), GetBounds ( ), false );
+			GetOrigin()[2] += 5;
+		}
+		else if (IsServer)
+		{	// if this instance does not flatten the ground around it, do a trace to more accurately determine its Z value
+			trace_t		tr;
+			vec3_t		end;
+			vec3_t		start;
+
+			VectorCopy(GetOrigin(), end);
+			VectorCopy(GetOrigin(), start);
+			// start the trace below the top height of the landscape
+			start[2] = TheRandomMissionManager->GetLandScape()->GetBounds()[1][2] - 1;
+			// end the trace at the bottom of the world
+			end[2] = MIN_WORLD_COORD;
+	
+			Com_Memset ( &tr, 0, sizeof ( tr ) );
+			SV_Trace( &tr, start, vec3_origin, vec3_origin, end, -1, CONTENTS_TERRAIN|CONTENTS_SOLID, qfalse, 0, 10 );
+
+			if( !(tr.contents & CONTENTS_TERRAIN) || (tr.fraction == 1.0) )
+			{
+				if ( 0 )
+				assert(0); // this should never happen
+
+				// restore the unmirrored origin
+				VectorCopy( notmirrored, GetOrigin() );
+				// don't spawn
+				return false;
+			}
+			// assign the Z-value to wherever it hit the terrain	
+			GetOrigin()[2] = tr.endpos[2];
+			// lower it a little, otherwise the bottom of the instance might be exposed if on some weird sloped terrain
+			GetOrigin()[2] -= 16; // FIXME: would it be better to use a number related to the instance itself like 1/5 it's height or something...
+		}
+
+	}
+	else
+	{
+		terrain->GetLandScape()->GetWorldHeight ( GetOrigin(), GetBounds ( ), true );
+	}
+	
+	// save away the origin
+	VectorCopy(GetOrigin(), origin);
+	// make sure not to spawn if in water
+	if (!HasObjective() && GetOrigin()[2] < water_level)
+		return false;
+	// restore the origin
+	VectorCopy(origin, GetOrigin());
+
+	if (mMirror)
+	{	// change blue things to red for symmetric maps
+		if (strlen(mFilter) > 0)
+		{
+			char * blue = strstr(mFilter,"blue");
+			if (blue)
+			{
+				blue[0] = (char) 0;
+				strcat(mFilter, "red");
+				SetSide(SIDE_RED);
+			}
+		}
+		if (strlen(mTeamFilter) > 0)
+		{
+			char * blue = strstr(mTeamFilter,"blue");
+			if (blue)
+			{
+				strcpy(mTeamFilter, "red");
+				SetSide(SIDE_RED);
+			}
+		}
+		yaw = RAD2DEG(mArea->GetAngle() + mBaseAngle) + 180;
+	}
+	else
+	{
+		yaw = RAD2DEG(mArea->GetAngle() + mBaseAngle);
+	}
+
+/*
+	if( TheRandomMissionManager->GetMission()->GetSymmetric() )
+	{
+		vec3_t	diagonal;
+		vec3_t	lineToPoint;
+		vec3_t	mins;
+		vec3_t	maxs;
+		vec3_t	point;
+		vec3_t	vProj;
+		vec3_t	vec;
+		float	distance;
+
+		VectorCopy( TheRandomMissionManager->GetLandScape()->GetBounds()[1], maxs );
+		VectorCopy( TheRandomMissionManager->GetLandScape()->GetBounds()[0], mins );
+		VectorCopy( GetOrigin(), point );
+		mins[2] = maxs[2] = point[2] = 0;
+		VectorSubtract( point, mins, lineToPoint );
+		VectorSubtract( maxs, mins, diagonal);
+
+
+		VectorNormalize(diagonal);	
+		VectorMA( mins, DotProduct(lineToPoint, diagonal), diagonal, vProj);
+		VectorSubtract(point, vProj, vec );
+		distance = VectorLength(vec);
+
+		// if an instance is too close to the imaginary diagonal that cuts the world in half, don't spawn it
+		// otherwise you can get overlapping instances
+		if( distance < GetSpacingRadius() )
+		{
+#ifdef _DEBUG
+			mAutomapSymbol = AUTOMAP_END;
+#endif
+			if( !HasObjective() )
+			{
+				return false;
+			}
+		}
+	}
+*/
+
+	// Spawn in the bsp model
+	sprintf(temp, 
+		"{\n"
+		"\"classname\"   \"misc_bsp\"\n"
+		"\"bspmodel\"    \"%s\"\n"
+		"\"origin\"      \"%f %f %f\"\n"
+		"\"angles\"      \"0 %f 0\"\n"
+		"\"filter\"      \"%s\"\n"
+		"\"teamfilter\"  \"%s\"\n"
+		"\"spacing\"	 \"%d\"\n"
+		"\"flatten\"	 \"%d\"\n"
+		"}\n",
+		mBsp,
+		GetOrigin()[0], GetOrigin()[1], GetOrigin()[2],
+		AngleNormalize360(yaw),
+		mFilter,
+		mTeamFilter,
+		(int)GetSpacingRadius(),
+		(int)GetFlattenRadius()
+		);
+
+	if (IsServer)
+	{	// only allow for true spawning on the server
+		savePtr = sv.entityParsePoint;
+		sv.entityParsePoint = temp;
+		VM_Call( gvm, GAME_SPAWN_RMG_ENTITY );
+		sv.entityParsePoint = savePtr;
+	}
+
+	DrawAutomapSymbol();
+
+	Com_DPrintf( "RMG:  Building '%s' spawned at (%f %f %f)\n", mBsp, GetOrigin()[0], GetOrigin()[1], GetOrigin()[2] );
+	// now restore the instances un-mirrored origin
+	// NOTE: all this origin flipping, setting the side etc... should be done when mMirror is set
+	// because right after this function is called, mMirror is set to 0 but all the instance data is STILL MIRRORED -- not good
+	VectorCopy(notmirrored, GetOrigin());
+
+#endif  // PRE_RELEASE_DEMO
+	
+	return true;
+}
+
+
+
diff --git a/codemp/RMG/RM_Instance_BSP.h b/codemp/RMG/RM_Instance_BSP.h
new file mode 100644
index 0000000..b1c4be3
--- /dev/null
+++ b/codemp/RMG/RM_Instance_BSP.h
@@ -0,0 +1,35 @@
+#pragma once
+#if !defined(RM_INSTANCE_BSP_H_INC)
+#define RM_INSTANCE_BSP_H_INC
+
+#ifdef DEBUG_LINKING
+	#pragma message("...including RM_Instance_BSP.h")
+#endif
+
+class CRMBSPInstance : public CRMInstance
+{
+private:
+
+	char		mBsp[MAX_QPATH];
+	float		mAngleVariance;
+	float		mBaseAngle;
+	float		mAngleDiff;
+
+	float		mHoleRadius;
+
+public:
+
+	CRMBSPInstance	 ( CGPGroup *instance, CRMInstanceFile& instFile );
+
+	virtual int			GetPreviewColor		( )		{ return (255<<24)+255; }
+
+	virtual float		GetHoleRadius		( ) { return mHoleRadius; }
+
+	virtual bool		Spawn				( CRandomTerrain* terrain, qboolean IsServer );
+
+	const char*			GetModelName	 (void) const { return(mBsp); }
+	float				GetAngleDiff	 (void) const { return(mAngleDiff); }
+	bool				GetAngularType	 (void) const { return(mAngleDiff != 0.0f); }
+};
+
+#endif
\ No newline at end of file
diff --git a/codemp/RMG/RM_Instance_Group.cpp b/codemp/RMG/RM_Instance_Group.cpp
new file mode 100644
index 0000000..79124f2
--- /dev/null
+++ b/codemp/RMG/RM_Instance_Group.cpp
@@ -0,0 +1,344 @@
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+/************************************************************************************************
+ *
+ * RM_Instance_Group.cpp
+ *
+ * Implements the CRMGroupInstance class.  This class is reponsible for parsing a 
+ * group instance as well as spawning it into a landscape.
+ *
+ ************************************************************************************************/
+
+#include "RM_Headers.h"
+
+#include "RM_Instance_Group.h"
+
+/************************************************************************************************
+ * CRMGroupInstance::CRMGroupInstance
+ *	constructur
+ *
+ * inputs:
+ *  settlementID:  ID of the settlement being created 
+ *
+ * return:
+ *	none
+ *
+ ************************************************************************************************/
+CRMGroupInstance::CRMGroupInstance ( CGPGroup *instGroup, CRMInstanceFile& instFile ) 
+	:  CRMInstance ( instGroup, instFile )
+{
+	// Grab the padding and confine radius
+	mPaddingSize   = atof ( instGroup->FindPairValue ( "padding", va("%i", TheRandomMissionManager->GetMission()->GetDefaultPadding() ) ) );
+	mConfineRadius = atof ( instGroup->FindPairValue ( "confine", "0" ) );
+
+	const char * automapSymName = instGroup->FindPairValue ( "automap_symbol", "none" );
+	if (0 == Q_stricmp(automapSymName, "none"))	   	mAutomapSymbol = AUTOMAP_NONE ;
+	else if (0 == Q_stricmp(automapSymName, "building"))  	mAutomapSymbol = AUTOMAP_BLD  ;
+	else if (0 == Q_stricmp(automapSymName, "objective")) 	mAutomapSymbol = AUTOMAP_OBJ  ;
+	else if (0 == Q_stricmp(automapSymName, "start"))	   	mAutomapSymbol = AUTOMAP_START;
+	else if (0 == Q_stricmp(automapSymName, "end"))	   	mAutomapSymbol = AUTOMAP_END  ;
+	else if (0 == Q_stricmp(automapSymName, "enemy"))	   	mAutomapSymbol = AUTOMAP_ENEMY;
+	else if (0 == Q_stricmp(automapSymName, "friend"))	   	mAutomapSymbol = AUTOMAP_FRIEND;
+	else mAutomapSymbol	= atoi( automapSymName );
+
+	// optional instance objective strings
+	SetMessage(instGroup->FindPairValue("objective_message",""));
+	SetDescription(instGroup->FindPairValue("objective_description",""));
+	SetInfo(instGroup->FindPairValue("objective_info",""));
+
+	// Iterate through the sub groups to determine the instances which make up the group
+	instGroup = instGroup->GetSubGroups ( );
+
+	while ( instGroup )
+	{
+		CRMInstance* instance;
+		const char*  name;
+		int			 mincount;
+		int			 maxcount;
+		int			 count;
+		float		 minrange;
+		float		 maxrange;
+
+		// Make sure only instances are specified as sub groups
+		assert ( 0 == stricmp ( instGroup->GetName ( ), "instance" ) );
+
+		// Grab the name
+		name     = instGroup->FindPairValue ( "name", "" );
+
+		// Grab the range information
+		minrange = atof(instGroup->FindPairValue ( "minrange", "0" ) );
+		maxrange = atof(instGroup->FindPairValue ( "maxrange", "0" ) );
+
+		// Grab the count information and randomly generate a count value
+		mincount = atoi(instGroup->FindPairValue ( "mincount", "1" ) );
+		maxcount = atoi(instGroup->FindPairValue ( "maxcount", "1" ) );
+		count	 = mincount;
+
+		if ( maxcount > mincount )
+		{
+			count += (TheRandomMissionManager->GetLandScape()->irand(0, maxcount-mincount));
+		}
+
+		// For each count create and add the instance
+		for ( ; count ; count -- )
+		{
+			// Create the instance
+			instance = instFile.CreateInstance ( name );
+
+			// Skip this instance if it couldnt be created for some reason.  The CreateInstance
+			// method will report an error so no need to do so here.
+			if ( NULL == instance )
+			{
+				continue;
+			}
+
+			// Set the min and max range for the instance
+			instance->SetFilter(mFilter);
+			instance->SetTeamFilter(mTeamFilter);
+
+			// Add the instance to the list
+			mInstances.push_back ( instance );
+		}
+
+		// Next sub group
+		instGroup = instGroup->GetNext ( );
+	}
+}
+
+/************************************************************************************************
+ * CRMGroupInstance::~CRMGroupInstance
+ *	Removes all buildings and inhabitants
+ *
+ * inputs:
+ *  none
+ *
+ * return:
+ *	none
+ *
+ ************************************************************************************************/
+CRMGroupInstance::~CRMGroupInstance(void)
+{
+	// Cleanup
+	RemoveInstances ( );
+}
+
+/************************************************************************************************
+ * CRMGroupInstance::SetFilter
+ *	Sets a filter used to exclude instances
+ *
+ * inputs:
+ *  filter: filter name
+ *
+ * return:
+ *	none
+ *
+ ************************************************************************************************/
+void CRMGroupInstance::SetFilter( const char *filter )
+{
+	rmInstanceIter_t it;
+
+	CRMInstance::SetFilter(filter);
+	for(it = mInstances.begin(); it != mInstances.end(); it++)
+	{
+		(*it)->SetFilter(filter);
+	}
+}
+
+/************************************************************************************************
+ * CRMGroupInstance::SetTeamFilter
+ *	Sets the filter used to exclude team based instances
+ *
+ * inputs:
+ *  teamFilter: filter name
+ *
+ * return:
+ *	none
+ *
+ ************************************************************************************************/
+void CRMGroupInstance::SetTeamFilter( const char *teamFilter )
+{
+	rmInstanceIter_t it;
+
+	CRMInstance::SetTeamFilter(teamFilter);
+	for(it = mInstances.begin(); it != mInstances.end(); it++)
+	{
+		(*it)->SetTeamFilter(teamFilter);
+	}
+}
+
+/************************************************************************************************
+ * CRMGroupInstance::SetMirror
+ *	Sets the flag to mirror an instance on map
+ *
+ * inputs:
+ *  mirror 
+ *
+ * return:
+ *	none
+ *
+ ************************************************************************************************/
+void CRMGroupInstance::SetMirror(int mirror)
+{ 
+	rmInstanceIter_t it;
+
+	CRMInstance::SetMirror(mirror);
+	for(it = mInstances.begin(); it != mInstances.end(); it++)
+	{
+		(*it)->SetMirror(mirror);
+	}
+}
+
+
+/************************************************************************************************
+ * CRMGroupInstance::RemoveInstances
+ *	Removes all instances associated with the group
+ *
+ * inputs:
+ *  none
+ *
+ * return:
+ *	none
+ *
+ ************************************************************************************************/
+void CRMGroupInstance::RemoveInstances ( )
+{
+	rmInstanceIter_t it;
+
+	for(it = mInstances.begin(); it != mInstances.end(); it++)
+	{
+		delete *it;
+	}
+
+	mInstances.clear();
+}
+
+/************************************************************************************************
+ * CRMGroupInstance::PreSpawn
+ *	Prepares the group for spawning by 
+ *
+ * inputs:
+ *  landscape: landscape to calculate the position within
+ *  instance: instance to calculate the position for
+ *
+ * return:
+ *	none
+ *
+ ************************************************************************************************/
+bool CRMGroupInstance::PreSpawn ( CRandomTerrain* terrain, qboolean IsServer )
+{
+	rmInstanceIter_t it;
+
+	for(it = mInstances.begin(); it != mInstances.end(); it++ )
+	{
+		CRMInstance* instance = *it;
+
+		instance->SetFlattenHeight ( mFlattenHeight );
+
+		// Add the instance to the landscape now
+		instance->PreSpawn ( terrain, IsServer );		
+	}
+
+	return CRMInstance::PreSpawn ( terrain, IsServer );
+}
+
+/************************************************************************************************
+ * CRMGroupInstance::Spawn
+ *	Adds the group instance to the given landscape using the specified origin.  All sub instances
+ *  will be added to the landscape within their min and max range from the origin.
+ *
+ * inputs:
+ *  landscape: landscape to add the instance group to
+ *  origin: origin of the instance group
+ *
+ * return:
+ *	none
+ *
+ ************************************************************************************************/
+bool CRMGroupInstance::Spawn ( CRandomTerrain* terrain, qboolean IsServer )
+{
+	rmInstanceIter_t it;
+
+	// Spawn all the instances associated with this group
+	for(it = mInstances.begin(); it != mInstances.end(); it++)
+	{
+		CRMInstance* instance = *it;
+		instance->SetSide(GetSide()); // which side owns it?
+
+		// Add the instance to the landscape now
+		instance->Spawn ( terrain, IsServer );
+	}
+
+	DrawAutomapSymbol();
+
+	return true;
+}
+
+/************************************************************************************************
+ * CRMGroupInstance::Preview
+ *	Renders debug information for the instance
+ *
+ * inputs:
+ *  from: point to render the preview from
+ *
+ * return:
+ *	none
+ *
+ ************************************************************************************************/
+void CRMGroupInstance::Preview ( const vec3_t from )
+{
+	rmInstanceIter_t it;
+
+	CRMInstance::Preview ( from );
+	
+	// Render all the instances
+	for(it = mInstances.begin(); it != mInstances.end(); it++)
+	{
+		CRMInstance* instance = *it;
+
+		instance->Preview ( from );
+	}
+}
+
+/************************************************************************************************
+ * CRMGroupInstance::SetArea
+ *	Overidden to make sure the groups area doesnt eat up any room.  The collision on the
+ *  groups area will be turned off
+ *
+ * inputs:
+ *  area: area to set
+ *
+ * return:
+ *	none
+ *
+ ************************************************************************************************/
+void CRMGroupInstance::SetArea ( CRMAreaManager* amanager, CRMArea* area )
+{
+	rmInstanceIter_t it;
+
+	bool collide = area->IsCollisionEnabled ( );
+
+	// Disable collision
+	area->EnableCollision ( false );
+
+	// Do what really needs to get done
+	CRMInstance::SetArea ( amanager, area );
+
+	// Prepare for spawn by calculating all the positions of the sub instances
+	// and flattening the ground below them.
+	for(it = mInstances.begin(); it != mInstances.end(); it++ )
+	{
+		CRMInstance  *instance = *it;
+		CRMArea		 *newarea;
+		vec3_t		 origin;
+
+		// Drop it in the center of the group for now
+		origin[0] = GetOrigin()[0];
+		origin[1] = GetOrigin()[1];
+		origin[2] = 2500;
+
+		// Set the area of position
+		newarea = amanager->CreateArea ( origin, instance->GetSpacingRadius(), instance->GetSpacingLine(), mPaddingSize, mConfineRadius, GetOrigin(), GetOrigin(), instance->GetFlattenRadius()?true:false, collide, instance->GetLockOrigin(), area->GetSymmetric ( ) );
+		instance->SetArea ( amanager, newarea );
+	}
+}
diff --git a/codemp/RMG/RM_Instance_Group.h b/codemp/RMG/RM_Instance_Group.h
new file mode 100644
index 0000000..50b89c7
--- /dev/null
+++ b/codemp/RMG/RM_Instance_Group.h
@@ -0,0 +1,41 @@
+#pragma once
+#if !defined(RM_INSTANCE_GROUP_H_INC)
+#define RM_INSTANCE_GROUP_H_INC
+
+#ifdef DEBUG_LINKING
+	#pragma message("...including RM_Instance_Group.h")
+#endif
+
+class CRMGroupInstance : public CRMInstance
+{
+protected:
+
+	rmInstanceList_t	mInstances;
+	float				mConfineRadius;
+	float				mPaddingSize;
+
+public:
+
+	CRMGroupInstance( CGPGroup* instGroup, CRMInstanceFile& instFile);
+	~CRMGroupInstance();
+
+	virtual bool		PreSpawn			( CRandomTerrain* terrain, qboolean IsServer );
+	virtual bool		Spawn				( CRandomTerrain* terrain, qboolean IsServer );
+
+	virtual void		Preview				( const vec3_t from );
+
+	virtual void		SetFilter			( const char *filter );
+	virtual void		SetTeamFilter		( const char *teamFilter );
+	virtual void		SetArea				( CRMAreaManager* amanager, CRMArea* area );
+
+	virtual int			GetPreviewColor		( )		{ return (255<<24)+(255<<8); }
+	virtual float		GetSpacingRadius	( )		{ return 0; }
+	virtual float		GetFlattenRadius	( )		{ return 0; }
+	virtual void  		SetMirror(int mirror);
+
+protected:
+
+	void	RemoveInstances	 ( );
+};
+
+#endif
\ No newline at end of file
diff --git a/codemp/RMG/RM_Instance_Random.cpp b/codemp/RMG/RM_Instance_Random.cpp
new file mode 100644
index 0000000..1012c8a
--- /dev/null
+++ b/codemp/RMG/RM_Instance_Random.cpp
@@ -0,0 +1,188 @@
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+/************************************************************************************************
+ *
+ * RM_Instance_Random.cpp
+ *
+ * Implements the CRMRandomInstance class.  This class is reponsible for parsing a 
+ * random instance as well as spawning it into a landscape.
+ *
+ ************************************************************************************************/
+
+#include "RM_Headers.h"
+
+#include "RM_Instance_Random.h"
+
+/************************************************************************************************
+ * CRMRandomInstance::CRMRandomInstance
+ *	constructs a random instance by choosing one of the sub instances and creating it
+ *
+ * inputs:
+ *  instGroup:  parser group containing infromation about this instance
+ *  instFile:   reference to an open instance file for creating sub instances
+ *
+ * return:
+ *	none
+ *
+ ************************************************************************************************/
+CRMRandomInstance::CRMRandomInstance ( CGPGroup *instGroup, CRMInstanceFile& instFile ) 
+	: CRMInstance ( instGroup, instFile )
+{
+	CGPGroup* group;
+	CGPGroup* groups[MAX_RANDOM_INSTANCES];
+	int		  numGroups;
+
+	// Build a list of the groups one can be chosen
+	for ( numGroups = 0, group = instGroup->GetSubGroups ( ); 
+		  group; 
+		  group = group->GetNext ( ) )
+	{
+		// If this isnt an instance group then skip it
+		if ( stricmp ( group->GetName ( ), "instance" ) )
+		{
+			continue;
+		}
+
+		int multiplier = atoi(group->FindPairValue ( "multiplier", "1" ));
+		for ( ; multiplier > 0 && numGroups < MAX_RANDOM_INSTANCES; multiplier -- )
+		{ 
+			groups[numGroups++] = group;
+		}
+	}
+
+	// No groups, no instance
+	if ( !numGroups )
+	{
+		// Initialize this now
+		mInstance = NULL;
+
+		Com_Printf ( "WARNING: No sub instances specified for random instance '%s'\n", group->FindPairValue ( "name", "unknown" ) );
+		return;
+	}
+
+	// Now choose a group to parse	
+	instGroup = groups[TheRandomMissionManager->GetLandScape()->irand(0,numGroups-1)];
+
+	// Create the child instance now.  If the instance create fails then the
+	// IsValid routine will return false and this instance wont be added
+	mInstance = instFile.CreateInstance ( instGroup->FindPairValue ( "name", "" ) );
+	mInstance->SetFilter(mFilter);
+	mInstance->SetTeamFilter(mTeamFilter);
+
+	mAutomapSymbol = mInstance->GetAutomapSymbol();
+
+	SetMessage(mInstance->GetMessage());
+	SetDescription(mInstance->GetDescription());
+	SetInfo(mInstance->GetInfo());
+}
+
+/************************************************************************************************
+ * CRMRandomInstance::~CRMRandomInstance
+ *	Deletes the sub instance
+ *
+ * inputs:
+ *  none
+ *
+ * return:
+ *	none
+ *
+ ************************************************************************************************/
+CRMRandomInstance::~CRMRandomInstance(void)
+{
+	if ( mInstance )
+	{
+		delete mInstance;
+	}
+}
+
+void CRMRandomInstance::SetMirror(int mirror)
+{ 
+	CRMInstance::SetMirror(mirror);
+	if (mInstance)
+	{
+		mInstance->SetMirror(mirror);
+	}
+}
+
+void CRMRandomInstance::SetFilter( const char *filter )
+{
+	CRMInstance::SetFilter(filter);
+	if (mInstance)
+	{
+		mInstance->SetFilter(filter);
+	}
+}
+
+void CRMRandomInstance::SetTeamFilter( const char *teamFilter )
+{
+	CRMInstance::SetTeamFilter(teamFilter);
+	if (mInstance)
+	{
+		mInstance->SetTeamFilter(teamFilter);
+	}
+}
+
+/************************************************************************************************
+ * CRMRandomInstance::PreSpawn
+ *	Prepares for the spawn of the random instance
+ *
+ * inputs:
+ *  landscape: landscape object this instance will be spawned on
+ *
+ * return:
+ *	true: preparation successful
+ *  false: preparation failed
+ *
+ ************************************************************************************************/
+bool CRMRandomInstance::PreSpawn ( CRandomTerrain* terrain, qboolean IsServer )
+{
+	assert ( mInstance );
+
+	mInstance->SetFlattenHeight ( GetFlattenHeight( ) );
+
+	return mInstance->PreSpawn ( terrain, IsServer );
+}
+
+/************************************************************************************************
+ * CRMRandomInstance::Spawn
+ *	Spawns the instance onto the landscape
+ *
+ * inputs:
+ *  landscape: landscape object this instance will be spawned on
+ *
+ * return:
+ *	true: spawn successful
+ *  false: spawn failed
+ *
+ ************************************************************************************************/
+bool CRMRandomInstance::Spawn ( CRandomTerrain* terrain, qboolean IsServer )
+{
+	mInstance->SetObjective(GetObjective());
+	mInstance->SetSide(GetSide());
+
+	if ( !mInstance->Spawn ( terrain, IsServer ) )
+	{
+		return false;
+	}
+
+	return true;
+}
+
+/************************************************************************************************
+ * CRMRandomInstance::SetArea
+ *	Forwards the given area off to the internal instance
+ *
+ * inputs:
+ *  area: area to be set
+ *
+ * return:
+ *	none
+ *
+ ************************************************************************************************/
+void CRMRandomInstance::SetArea ( CRMAreaManager* amanager, CRMArea* area )
+{
+	CRMInstance::SetArea ( amanager, area );
+
+	mInstance->SetArea ( amanager, mArea );
+}
diff --git a/codemp/RMG/RM_Instance_Random.h b/codemp/RMG/RM_Instance_Random.h
new file mode 100644
index 0000000..20bdad9
--- /dev/null
+++ b/codemp/RMG/RM_Instance_Random.h
@@ -0,0 +1,40 @@
+#pragma once
+#if !defined(RM_INSTANCE_RANDOM_H_INC)
+#define RM_INSTANCE_RANDOM_H_INC
+
+#ifdef DEBUG_LINKING
+	#pragma message("...including RM_Instance_Random.h")
+#endif
+
+#define	MAX_RANDOM_INSTANCES		64
+
+class CRMRandomInstance : public CRMInstance
+{
+protected:
+
+	CRMInstance*	mInstance;
+
+public:
+
+	CRMRandomInstance ( CGPGroup* instGroup, CRMInstanceFile& instFile );
+	~CRMRandomInstance ( );
+
+	virtual bool		IsValid				( )	{ return mInstance==NULL?false:true; }
+
+	virtual int			GetPreviewColor		( )		{ return mInstance->GetPreviewColor ( ); }
+
+	virtual float		GetSpacingRadius	( )		{ return mInstance->GetSpacingRadius ( ); }
+	virtual int			GetSpacingLine		( )		{ return mInstance->GetSpacingLine ( ); }
+	virtual float		GetFlattenRadius	( )		{ return mInstance->GetFlattenRadius ( ); }
+	virtual bool		GetLockOrigin		( )		{ return mInstance->GetLockOrigin ( ); }
+
+	virtual void		SetFilter			( const char *filter );
+	virtual void		SetTeamFilter		( const char *teamFilter );
+	virtual void		SetArea				( CRMAreaManager* amanager, CRMArea* area );
+	virtual void  		SetMirror			(int mirror);
+
+	virtual bool		PreSpawn			( CRandomTerrain* terrain, qboolean IsServer );
+	virtual bool		Spawn				( CRandomTerrain* terrain, qboolean IsServer );
+};
+
+#endif
\ No newline at end of file
diff --git a/codemp/RMG/RM_Instance_Void.cpp b/codemp/RMG/RM_Instance_Void.cpp
new file mode 100644
index 0000000..9cf11e6
--- /dev/null
+++ b/codemp/RMG/RM_Instance_Void.cpp
@@ -0,0 +1,54 @@
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+/************************************************************************************************
+ *
+ * RM_Instance_Void.cpp
+ *
+ * Implements the CRMVoidInstance class.  This class just adds a void into the 
+ * area manager to help space things out.
+ *
+ ************************************************************************************************/
+
+#include "RM_Headers.h"
+
+#include "RM_Instance_Void.h"
+
+/************************************************************************************************
+ * CRMVoidInstance::CRMVoidInstance
+ *	constructs a void instance 
+ *
+ * inputs:
+ *  instGroup:  parser group containing infromation about this instance
+ *  instFile:   reference to an open instance file for creating sub instances
+ *
+ * return:
+ *	none
+ *
+ ************************************************************************************************/
+CRMVoidInstance::CRMVoidInstance ( CGPGroup *instGroup, CRMInstanceFile& instFile ) 
+	: CRMInstance ( instGroup, instFile )
+{
+	mSpacingRadius = atof( instGroup->FindPairValue ( "spacing", "0" ) );
+	mFlattenRadius = atof( instGroup->FindPairValue ( "flatten", "0" ) );
+}
+
+/************************************************************************************************
+ * CRMVoidInstance::SetArea
+ *	Overidden to make sure the void area doesnt continually.  
+ *
+ * inputs:
+ *  area: area to set
+ *
+ * return:
+ *	none
+ *
+ ************************************************************************************************/
+void CRMVoidInstance::SetArea ( CRMAreaManager* amanager, CRMArea* area )
+{
+	// Disable collision
+	area->EnableCollision ( false );
+
+	// Do what really needs to get done
+	CRMInstance::SetArea ( amanager, area );
+}
diff --git a/codemp/RMG/RM_Instance_Void.h b/codemp/RMG/RM_Instance_Void.h
new file mode 100644
index 0000000..a437d89
--- /dev/null
+++ b/codemp/RMG/RM_Instance_Void.h
@@ -0,0 +1,18 @@
+#pragma once
+#if !defined(RM_INSTANCE_VOID_H_INC)
+#define RM_INSTANCE_VOID_H_INC
+
+#ifdef DEBUG_LINKING
+	#pragma message("...including RM_Instance_Void.h")
+#endif
+
+class CRMVoidInstance : public CRMInstance
+{
+public:
+
+	CRMVoidInstance ( CGPGroup* instGroup, CRMInstanceFile& instFile );
+
+	virtual void		SetArea		( CRMAreaManager* amanager, CRMArea* area );
+};
+
+#endif
\ No newline at end of file
diff --git a/codemp/RMG/RM_Manager.cpp b/codemp/RMG/RM_Manager.cpp
new file mode 100644
index 0000000..5928626
--- /dev/null
+++ b/codemp/RMG/RM_Manager.cpp
@@ -0,0 +1,474 @@
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+/************************************************************************************************
+ *
+ * RM_Manager.cpp
+ *
+ * Implements the CRMManager class.  The CRMManager class manages the arioche system.
+ *
+ ************************************************************************************************/
+
+#include "RM_Headers.h"
+#include "../server/server.h"
+#include "../qcommon/qcommon.h"
+
+CRMObjective *CRMManager::mCurObjective=0;
+
+/************************************************************************************************
+ * TheRandomMissionManager
+ *	Pointer to only active CRMManager class
+ *
+ ************************************************************************************************/
+CRMManager *TheRandomMissionManager;
+
+/************************************************************************************************
+ * CRMManager::CRMManager
+ *	constructor
+ *
+ * inputs:
+ *
+ * return:
+ *
+ ************************************************************************************************/
+CRMManager::CRMManager(void)
+{
+	mLandScape = NULL;
+	mTerrain   = NULL;
+	mMission = NULL;
+	mCurPriority = 1;
+	mUseTimeLimit = false;
+	mAutomapSymbolCount = 0;
+}
+
+/************************************************************************************************
+ * CRMManager::~CRMManager
+ *	destructor
+ *
+ * inputs:
+ *
+ * return:
+ *
+ ************************************************************************************************/
+CRMManager::~CRMManager(void)
+{
+#ifndef FINAL_BUILD
+	Com_Printf ("... Shutting down TheRandomMissionManager\n");
+#endif
+#ifndef DEDICATED
+	CM_TM_Free();
+#endif
+	if (mMission)
+	{
+		delete mMission;
+		mMission = NULL;
+	}
+}
+
+/************************************************************************************************
+ * CRMManager::SetLandscape
+ *	Sets the landscape and terrain object used to load a mission
+ *
+ * inputs:
+ *	landscape - landscape object
+ *
+ * return:
+ *	none
+ *
+ ************************************************************************************************/
+void CRMManager::SetLandScape(CCMLandScape *landscape)
+{
+	mLandScape = landscape;
+	mTerrain = landscape->GetRandomTerrain();
+}
+
+/************************************************************************************************
+ * CRMManager::LoadMission
+ *	Loads the mission using the mission name stored in the ar_mission cvar
+ *
+ * inputs:
+ *	none
+ *
+ * return:
+ *	none
+ *
+ ************************************************************************************************/
+bool CRMManager::LoadMission ( qboolean IsServer )
+{
+#ifndef PRE_RELEASE_DEMO
+	char	instances[MAX_QPATH];
+	char	mission[MAX_QPATH];
+	char	course[MAX_QPATH];
+	char	map[MAX_QPATH];
+	char	temp[MAX_QPATH];
+
+#ifndef FINAL_BUILD
+	Com_Printf ("--------- Random Mission Manager ---------\n\n");
+	Com_Printf ("RMG version : 1.01\n\n");
+#endif
+
+	if (!mTerrain)
+	{
+		return false;
+	}
+
+	// Grab the arioche variables
+	Cvar_VariableStringBuffer("rmg_usetimelimit", temp, MAX_QPATH);
+	if (Q_stricmp(temp, "yes") == 0)
+	{
+		mUseTimeLimit = true;
+	}
+	Cvar_VariableStringBuffer("rmg_instances", instances, MAX_QPATH);
+	Cvar_VariableStringBuffer("RMG_mission", temp, MAX_QPATH);
+	Cvar_VariableStringBuffer("rmg_map", map, MAX_QPATH);
+	sprintf(mission, "%s_%s", temp, map);
+	Cvar_VariableStringBuffer("rmg_course", course, MAX_QPATH);
+
+	// dump existing mission, if any
+	if (mMission)
+	{
+		delete mMission;
+		mMission = NULL;
+	}
+
+	// Create a new mission file	
+	mMission = new CRMMission ( mTerrain );
+
+	if ( IsServer )
+	{
+		// Load the mission using the arioche variables
+		if ( !mMission->Load ( mission, instances, course ) )
+		{
+			return false;
+		}
+	
+		// set the names of the teams 
+		CGenericParser2		parser;
+		CGPGroup*			root;
+
+		Cvar_VariableStringBuffer("RMG_terrain", temp, MAX_QPATH);
+
+		// Create the parser for the mission file
+		if(Com_ParseTextFile(va("ext_data/rmg/%s.teams", temp), parser))
+		{
+			root = parser.GetBaseParseGroup()->GetSubGroups();
+			if (0 == stricmp(root->GetName(), "teams"))
+			{
+				/*
+				SV_SetConfigstring( CS_GAMETYPE_REDTEAM, root->FindPairValue ( "red", "marine" ));
+				SV_SetConfigstring( CS_GAMETYPE_BLUETEAM, root->FindPairValue ( "blue", "thug" ));
+				*/
+				//rwwFIXMEFIXME: Do we care about this?
+			}
+			parser.Clean();
+		}
+	}
+
+	// Must have a valid landscape before we can spawn the mission
+	assert ( mLandScape );
+
+#ifndef FINAL_BUILD
+	Com_Printf ("------------------------------------------\n");
+#endif
+
+	return true;
+#else
+	return false;
+#endif // PRE_RELEASE_DEMO
+}
+
+/************************************************************************************************
+ * CRMManager::IsMissionComplete
+ *	Determines whether or not all the arioche objectives have been met
+ *
+ * inputs:
+ *  none
+ *
+ * return:
+ *	true: all objectives have been completed
+ *  false: one or more of the objectives has not been met
+ *
+ ************************************************************************************************/
+bool CRMManager::IsMissionComplete(void)
+{
+	if ( NULL == mMission->GetCurrentObjective ( ) )
+	{
+		return true;
+	}
+
+	return false;
+}
+
+/************************************************************************************************
+ * CRMManager::HasTimeExpired
+ *	Determines whether or not the time limit (if one) has expired
+ *
+ * inputs:
+ *  none
+ *
+ * return:
+ *	true: time limit has expired
+ *  false: time limit has not expired
+ *
+ ************************************************************************************************/
+bool CRMManager::HasTimeExpired(void)
+{
+/*	if (mMission->GetTimeLimit() == 0 || !mUseTimeLimit)
+	{	// no time limit set
+		return false;
+	}
+
+	if (mMission->GetTimeLimit() * 1000 * 60 > level.time - level.startTime)
+	{	// we are still under our time limit
+		return false;
+	}
+
+	// over our time limit!
+	return true;*/
+
+	return false;
+}
+
+/************************************************************************************************
+ * CRMManager::UpdateStatisticCvars
+ *	Updates the statistic cvars with data from the game
+ *
+ * inputs:
+ *  none
+ *
+ * return:
+ *	none
+ *
+ ************************************************************************************************/
+void CRMManager::UpdateStatisticCvars ( void )
+{
+/*	// No player set then nothing more to do
+	if ( mPlayer )
+	{
+		float accuracy;
+
+		// Calculate the accuracy
+		accuracy  = (float)mPlayer->client->ps.persistant[PERS_SHOTS_HIT];
+		accuracy /= (float)mPlayer->client->ps.persistant[PERS_SHOTS];
+		accuracy *= 100.0f;
+		
+		// set the accuracy cvar
+		gi.Cvar_Set ( "ar_pl_accuracy", va("%d%%",(int)accuracy) );
+
+		// Set the # of kills cvar
+		gi.Cvar_Set ( "ar_kills", va("%d", mPlayer->client->ps.persistant[PERS_SCORE] ) );
+
+		int hours;
+		int mins;
+		int seconds;
+		int tens;
+		int millisec = (level.time - level.startTime);
+
+		seconds = millisec / 1000;
+		hours = seconds / (60 * 60);
+		seconds -= (hours * 60 * 60);
+		mins = seconds / 60;		
+		seconds -= mins * 60;
+		tens = seconds / 10;
+		seconds -= tens * 10;
+
+		gi.Cvar_Set ( "ar_duration", va("%dhr %dmin %dsec", hours, mins, seconds ) );
+
+		WpnID wpnID = TheWpnSysMgr().GetFavoriteWeapon ( );
+		gi.Cvar_Set ( "ar_fav_wp", CWeaponSystem::GetWpnName ( wpnID ) );
+
+		// show difficulty
+		char difficulty[MAX_QPATH];
+		gi.Cvar_VariableStringBuffer("g_skill", difficulty, MAX_QPATH);
+		strupr(difficulty);
+		gi.Cvar_Set ( "ar_diff", va("&GENERIC_%s&",difficulty) );
+
+		// compute rank
+		float compositeRank = 1;
+		int rankMax = 3;  // max rank less 1
+		float timeRank = mUseTimeLimit ? (1.0f - (mins / (float)mMission->GetTimeLimit())) : 0;
+		float killRank = mPlayer->client->ps.persistant[PERS_SCORE] / (float)GetCharacterManager().GetAllSize();
+		killRank = (killRank > 0) ? killRank : 1.0f; 
+		float accuRank = (accuracy > 0) ? accuracy*0.01f : 1.0f;	
+		float weapRank = 1.0f - CWeaponSystem::GetRank(wpnID);
+
+		compositeRank = ((timeRank + killRank + accuRank + weapRank) / 3.0f) * rankMax + 1;
+		
+		if (compositeRank > 4)
+			compositeRank = 4;
+
+		gi.Cvar_Set ( "ar_rank", va("&RMG_RANK%d&",((int)compositeRank)) );
+	}*/
+}
+
+/************************************************************************************************
+ * CRMManager::CompleteMission
+ *	Does end-of-mission stuff (pause game, end screen, return to menu)
+ *    <Description>                                                                             *
+ * Input                                                                                        *
+ *    <Variable>: <Description>                                                                 *
+ * Output / Return                                                                              *
+ *    <Variable>: <Description>                                                                 *
+ ************************************************************************************************/
+void CRMManager::CompleteMission(void)
+{
+	UpdateStatisticCvars ( );
+
+	mMission->CompleteMission();
+}
+
+/************************************************************************************************
+ * CRMManager::FailedMission
+ *	Does end-of-mission stuff (pause game, end screen, return to menu)
+ *    <Description>                                                                             *
+ * Input                                                                                        *
+ *    TimeExpired: indicates if the reason failed was because of time
+ * Output / Return                                                                              *
+ *    <Variable>: <Description>                                                                 *
+ ************************************************************************************************/
+void CRMManager::FailedMission(bool TimeExpired)
+{
+	UpdateStatisticCvars ( );
+
+	mMission->FailedMission(TimeExpired);
+}
+
+/************************************************************************************************
+ * CRMManager::CompleteObjective
+ *	Marks the given objective as completed
+ *
+ * inputs:
+ *  obj:  objective to set as completed
+ *
+ * return:
+ *	none
+ *
+ ************************************************************************************************/
+void CRMManager::CompleteObjective ( CRMObjective *obj )
+{
+	assert ( obj );
+
+	mMission->CompleteObjective ( obj );
+}
+
+/************************************************************************************************
+ * CRMManager::Preview
+ *	previews the random mission genration information
+ *
+ * inputs:
+ *  from:  origin being previed from
+ *
+ * return:
+ *	none
+ *
+ ************************************************************************************************/
+void CRMManager::Preview ( const vec3_t from )
+{
+	// Dont bother if we havent reached our timer yet
+/*	if ( level.time < mPreviewTimer )
+	{
+		return;
+	}
+
+	// Let the mission do all the previewing
+	mMission->Preview ( from );
+
+	// Another second
+	mPreviewTimer = level.time + 1000;*/
+}
+
+/************************************************************************************************
+ * CRMManager::Preview
+ *	previews the random mission genration information
+ *
+ * inputs:
+ *  from:  origin being previed from
+ *
+ * return:
+ *	none
+ *
+ ************************************************************************************************/
+bool CRMManager::SpawnMission ( qboolean IsServer )
+{
+	// Spawn the mission
+	mMission->Spawn ( mTerrain, IsServer );
+
+	return true;
+}
+
+
+void CRMManager::AddAutomapSymbol ( int type, vec3_t origin, int side )
+{
+	if ( !type )
+	{
+		return;
+	}
+
+	mAutomapSymbols[mAutomapSymbolCount].mType = type;
+	mAutomapSymbols[mAutomapSymbolCount].mSide = side;
+	VectorCopy ( origin, mAutomapSymbols[mAutomapSymbolCount].mOrigin );
+	mAutomapSymbolCount++;
+}
+
+int CRMManager::GetAutomapSymbolCount ( void )
+{
+	return mAutomapSymbolCount;
+}
+
+rmAutomapSymbol_t* CRMManager::GetAutomapSymbol ( int index )
+{
+	return &mAutomapSymbols[index];
+}
+
+/*
+void CRMManager::WriteAutomapSymbols ( msg_t* msg )
+{
+	rmAutomapSymbolIter_t it;
+
+	MSG_WriteShort ( msg, (unsigned long)mAutomapSymbols.size() );
+
+	for(it = mAutomapSymbols.begin(); it != mAutomapSymbols.end(); it++)
+	{
+		CRMAutomapSymbol* symbol = (CRMAutomapSymbol*) *it;
+
+		MSG_WriteByte ( msg, (unsigned char) symbol->mType );
+		MSG_WriteByte ( msg, (unsigned char) symbol->mSide );
+		MSG_WriteLong ( msg, (long) symbol->mOrigin[0] );
+		MSG_WriteLong ( msg, (long) symbol->mOrigin[1] );
+	}	
+}
+*/
+
+void CRMManager::ProcessAutomapSymbols ( int count, rmAutomapSymbol_t* symbols )
+{
+#ifndef DEDICATED
+	int i;
+
+	for ( i = 0; i < count; i ++ )
+	{
+		// draw proper symbol on map for instance
+		switch (symbols[i].mType)
+		{
+			case AUTOMAP_BLD:
+				CM_TM_AddBuilding(symbols[i].mOrigin[0], symbols[i].mOrigin[1], symbols[i].mSide );
+				break;
+			case AUTOMAP_OBJ:
+				CM_TM_AddObjective(symbols[i].mOrigin[0], symbols[i].mOrigin[1], symbols[i].mSide );
+				break;
+			case AUTOMAP_START:
+				CM_TM_AddStart(symbols[i].mOrigin[0], symbols[i].mOrigin[1], symbols[i].mSide );
+				break;
+			case AUTOMAP_END:
+				CM_TM_AddEnd(symbols[i].mOrigin[0], symbols[i].mOrigin[1], symbols[i].mSide );
+				break;
+			case AUTOMAP_ENEMY:
+				break;
+			case AUTOMAP_FRIEND:
+				break;
+			case AUTOMAP_WALL:
+				CM_TM_AddWallRect(symbols[i].mOrigin[0], symbols[i].mOrigin[1], symbols[i].mSide );
+				break;
+		}
+	}
+#endif
+}
diff --git a/codemp/RMG/RM_Manager.h b/codemp/RMG/RM_Manager.h
new file mode 100644
index 0000000..b959788
--- /dev/null
+++ b/codemp/RMG/RM_Manager.h
@@ -0,0 +1,63 @@
+#pragma once
+#if !defined(RM_MANAGER_H_INC)
+#define RM_MANAGER_H_INC
+
+#if !defined(CM_LANDSCAPE_H_INC)
+#include "../qcommon/cm_landscape.h"
+#endif
+
+class CRMManager
+{
+private:
+
+	CRMMission*				mMission;
+	CCMLandScape*			mLandScape;
+	CRandomTerrain*			mTerrain;
+	int						mPreviewTimer;
+	int						mCurPriority;
+	bool					mUseTimeLimit;
+
+	rmAutomapSymbol_t		mAutomapSymbols[MAX_AUTOMAP_SYMBOLS];
+	int						mAutomapSymbolCount;
+
+	void			UpdateStatisticCvars ( void );
+
+public:
+
+	// Constructors
+	CRMManager (void);
+	~CRMManager (void);
+
+	bool			LoadMission		( qboolean IsServer );
+	bool			SpawnMission	( qboolean IsServer );
+
+	// Accessors
+	void			SetLandScape	(CCMLandScape *landscape);
+	void			SetCurPriority	(int priority) { mCurPriority = priority; }
+
+	CRandomTerrain*	GetTerrain		(void)	{ return mTerrain; }
+	CCMLandScape*	GetLandScape	(void)	{ return mLandScape; }
+	CRMMission*		GetMission		(void)  { return mMission; }
+	int				GetCurPriority	(void) { return mCurPriority; }
+
+	void				AddAutomapSymbol ( int type, vec3_t origin, int side );
+	int					GetAutomapSymbolCount ( void );
+	rmAutomapSymbol_t*	GetAutomapSymbol ( int index );
+	static void			ProcessAutomapSymbols ( int count, rmAutomapSymbol_t* symbols );
+
+	void			Preview			( const vec3_t from );
+
+	bool			IsMissionComplete		(void);
+	bool			HasTimeExpired			(void);
+	void			CompleteObjective		( CRMObjective *obj );
+	void			CompleteMission			(void);
+	void			FailedMission			(bool TimeExpired);
+
+	// eek
+	static CRMObjective	*mCurObjective;
+};
+
+extern CRMManager*	TheRandomMissionManager;
+
+
+#endif // RANDOMMISSION_H_INC
\ No newline at end of file
diff --git a/codemp/RMG/RM_Mission.cpp b/codemp/RMG/RM_Mission.cpp
new file mode 100644
index 0000000..2f1cee0
--- /dev/null
+++ b/codemp/RMG/RM_Mission.cpp
@@ -0,0 +1,1940 @@
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+/************************************************************************************************
+ *
+ * RM_Mission.cpp
+ *
+ * implements the CRMMission class.  The CRMMission class loads and manages an arioche mission
+ *
+ ************************************************************************************************/
+
+#include "RM_Headers.h"
+
+#define ARIOCHE_CLIPBRUSH_SIZE	300
+#define	CVAR_OBJECTIVE	0
+
+/************************************************************************************************
+ * CRMMission::CRMMission
+ *	constructor
+ *
+ * inputs:
+ *  none
+ *
+ * return:
+ *	none
+ *
+ ************************************************************************************************/
+CRMMission::CRMMission ( CRandomTerrain* landscape )
+{
+	mCurrentObjective		= NULL;
+	mValidPaths				= false;
+	mValidRivers			= false;
+	mValidNodes				= false;
+	mValidWeapons			= false;
+	mValidAmmo				= false;
+	mValidObjectives		= false;
+	mValidInstances			= false;
+	mTimeLimit				= 0;
+	mMaxInstancePosition	= 1;
+	mAccuracyMultiplier		= 1.0f;
+	mHealthMultiplier		= 1.0f;
+	mPickupHealth			= 1.0f;
+	mPickupArmor			= 1.0f;
+	mPickupAmmo				= 1.0f;
+	mPickupWeapon			= 1.0f;
+	mPickupEquipment		= 1.0f;
+	
+	mDefaultPadding = 0;
+	mSymmetric = SYMMETRY_NONE;
+
+//	mCheckedEnts.clear();
+
+	mLandScape = landscape;
+
+	// cut down the possible area that is 'legal' for area manager to use by 20%
+	vec3_t land_min, land_max;
+
+	land_min[0] = mLandScape->GetBounds ( )[0][0] + (mLandScape->GetBounds ( )[1][0]-mLandScape->GetBounds ( )[0][0]) * 0.1f;
+	land_min[1] = mLandScape->GetBounds ( )[0][1] + (mLandScape->GetBounds ( )[1][1]-mLandScape->GetBounds ( )[0][1]) * 0.1f;
+	land_min[2] = mLandScape->GetBounds ( )[0][2] + (mLandScape->GetBounds ( )[1][2]-mLandScape->GetBounds ( )[0][2]) * 0.1f;
+
+	land_max[0] = mLandScape->GetBounds ( )[1][0] - (mLandScape->GetBounds ( )[1][0]-mLandScape->GetBounds ( )[0][0]) * 0.1f;
+	land_max[1] = mLandScape->GetBounds ( )[1][1] - (mLandScape->GetBounds ( )[1][1]-mLandScape->GetBounds ( )[0][1]) * 0.1f;
+	land_max[2] = mLandScape->GetBounds ( )[1][2] - (mLandScape->GetBounds ( )[1][2]-mLandScape->GetBounds ( )[0][2]) * 0.1f;
+
+	// Create a new area manager for the landscape
+	mAreaManager = new CRMAreaManager ( land_min,
+										land_max );
+
+	// Create a new path manager
+	mPathManager = new CRMPathManager ( mLandScape );
+}
+
+/************************************************************************************************
+ * CRMMission::~CRMMission
+ *	destructor
+ *
+ * inputs:
+ *  none
+ *
+ * return:
+ *	none
+ *
+ ************************************************************************************************/
+CRMMission::~CRMMission ( )
+{
+	rmObjectiveIter_t	oit;
+	rmInstanceIter_t	iit;
+
+//	mCheckedEnts.clear();
+
+	// Cleanup the objectives
+	for (oit = mObjectives.begin(); oit != mObjectives.end(); oit++)
+	{
+		delete (*oit);
+	}
+
+	// Cleanup the instances
+	for (iit = mInstances.begin(); iit != mInstances.end(); iit++)
+	{
+		delete (*iit);
+	}
+
+	if (mPathManager)
+	{
+		delete mPathManager;
+		mPathManager = 0;
+	}
+
+	if (mAreaManager)
+	{
+		delete mAreaManager;
+		mAreaManager = 0;
+	}
+}
+
+/************************************************************************************************
+ * CRMMission::FindObjective
+ *	searches through the missions objectives for the one with the given name
+ *
+ * inputs:
+ *  name: name of objective to find
+ *
+ * return:
+ *	objective: objective matching the given name or NULL if it couldnt be found
+ *
+ ************************************************************************************************/
+CRMObjective* CRMMission::FindObjective ( const char* name )
+{
+	rmObjectiveIter_t it;
+
+	for (it = mObjectives.begin(); it != mObjectives.end(); it++)
+	{
+		// Does it match?
+		if (!stricmp ((*it)->GetName(), name ))
+		{
+			return (*it);
+		}
+	}
+
+	// Not found
+	return NULL;
+}
+
+void	CRMMission::MirrorPos(vec3_t pos)
+{
+	pos[0] = 1.0f - pos[0];
+	pos[1] = 1.0f - pos[1];
+}
+
+/************************************************************************************************
+ * CRMMission::ParseOrigin
+ *	parses an origin block which includes linking to a node and absolute origins
+ *
+ * inputs:
+ *  group: parser group containing the node or origin 
+ *
+ * return:
+ *	true: parsed successfully
+ *  false: failed to parse
+ *
+ ************************************************************************************************/
+bool CRMMission::ParseOrigin ( CGPGroup* originGroup, vec3_t origin, vec3_t lookat, int* flattenHeight )
+{
+	const char*	szNodeName;
+	vec3_t		mins;
+	vec3_t		maxs;
+
+	if ( flattenHeight )
+	{
+		*flattenHeight = 66;
+	}
+	
+	// If no group was given then use 0,0,0
+	if ( NULL == originGroup )
+	{
+		VectorCopy ( vec3_origin, origin );
+		return false;
+	}
+
+	// See if attaching to a named node
+	szNodeName = originGroup->FindPairValue ( "node", "" );
+	if ( *szNodeName )
+	{
+		CRMNode*	node;
+		// Find the node being attached to
+		node = mPathManager->FindNodeByName ( szNodeName );
+		if ( node )
+		{
+			if ( flattenHeight )
+			{
+				if ( node->GetFlattenHeight ( ) == -1 )
+				{
+					node->SetFlattenHeight ( 40 + mLandScape->irand(0,40) );
+				}
+
+				*flattenHeight = node->GetFlattenHeight ( );
+			}
+
+			VectorCopy(node->GetPos(), origin);
+
+			VectorCopy ( origin, lookat );
+
+			int dir;
+			int rnd_offset = mLandScape->irand(0, DIR_MAX-1);
+			for (dir=0; dir<DIR_MAX; dir++)
+			{
+				int d = (dir + rnd_offset) % DIR_MAX;
+				if (node->PathExist(d))
+				{
+					vec4_t tmp_pt, tmp_dir;
+					int pathID = node->GetPath(d);
+					mLandScape->GetPathInfo(pathID, .1, tmp_pt, tmp_dir );
+					lookat[0] = tmp_pt[0];
+					lookat[1] = tmp_pt[1];
+					lookat[2] = 0;
+					return true;
+				}
+			}
+			return true;
+		}
+	}
+
+	mins[0] = atof( originGroup->FindPairValue ( "left", ".1" ) );
+	mins[1] = atof( originGroup->FindPairValue ( "top", ".1" ) );
+	maxs[0] = atof( originGroup->FindPairValue ( "right", ".9" ) );
+	maxs[1] = atof( originGroup->FindPairValue ( "bottom", ".9" ) );
+
+	lookat[0] = origin[0] = mLandScape->flrand(mins[0],maxs[0]);
+	lookat[1] = origin[1] = mLandScape->flrand(mins[1],maxs[1]);
+	lookat[2] = origin[2] = 0;
+
+	return true;
+}
+
+/************************************************************************************************
+ * CRMMission::ParseNodes
+ *	parses all the named nodes in the file
+ *
+ * inputs:
+ *  group: parser group containing the named nodes
+ *
+ * return:
+ *	true:  parsed successfully
+ *  false: failed to parse
+ *
+ ************************************************************************************************/
+bool CRMMission::ParseNodes ( CGPGroup* group )
+{
+	// If NULL that means this particular difficulty level has no named nodes
+	if ( NULL == group || mValidNodes)
+	{
+		return true;
+	}
+
+	// how many nodes spaced over map?
+	int			x_cells;
+	int			y_cells;
+
+	x_cells = atoi ( group->FindPairValue ( "x_cells", "3" ) );
+	y_cells = atoi ( group->FindPairValue ( "y_cells", "3" ) );
+
+	mPathManager->CreateArray(x_cells, y_cells);
+
+	// Loop through all the nodes and generate each as specified
+	for ( group = group->GetSubGroups(); 
+		  group; 
+		  group=group->GetNext() )
+	{
+		int min_depth = atof( group->FindPairValue ( "min_depth", "0" ) );
+		int max_depth = atof( group->FindPairValue ( "max_depth", "5" ) );
+		int min_paths = atoi( group->FindPairValue ( "min_paths", "1" ) );
+		int max_paths = atoi( group->FindPairValue ( "max_paths", "1" ) );		
+
+		mPathManager->CreateLocation( group->GetName(), min_depth, max_depth, min_paths, max_paths );
+	}
+
+	mValidNodes = true;
+	return true;
+}
+
+/************************************************************************************************
+ * CRMMission::ParsePaths
+ *	parses all path styles in the file and then generates paths
+ *
+ * inputs:
+ *  group: parser group containing the list of path styles
+ *
+ * return:
+ *	true:  parsed successfully
+ *  false: failed to parse
+ *
+ ************************************************************************************************/
+bool CRMMission::ParsePaths ( CGPGroup* group )
+{
+	// If NULL that means this particular difficulty level has no paths
+	if ( NULL == group || mValidPaths)
+	{
+		return true;
+	}
+
+	// path style info
+	float		depth;
+	float		deviation;
+	float		breadth;
+	float		minwidth;
+	float		maxwidth;
+	int			points;
+
+	points    = atoi ( group->FindPairValue ( "points", "10" ) );
+	depth     = atof ( group->FindPairValue ( "depth", ".31" ) );
+	deviation = atof ( group->FindPairValue ( "deviation", ".025" ) );
+	breadth   = atof ( group->FindPairValue ( "breadth", "5" ) );
+	minwidth  = atof ( group->FindPairValue ( "minwidth", ".03" ) );
+	maxwidth  = atof ( group->FindPairValue ( "maxwidth", ".05" ) );
+
+	mPathManager->SetPathStyle( points, minwidth, maxwidth, depth, deviation, breadth);
+
+	if (!mValidPaths)
+	{	// we must create paths
+		mPathManager->GeneratePaths( mSymmetric );
+		mValidPaths = true;
+	}
+
+	return true;
+}
+
+/************************************************************************************************
+ * CRMMission::ParseRivers
+ *	parses all river styles in the file and then generates rivers
+ *
+ * inputs:
+ *  group: parser group containing the list of path styles
+ *
+ * return:
+ *	true:  parsed successfully
+ *  false: failed to parse
+ *
+ ************************************************************************************************/
+bool CRMMission::ParseRivers ( CGPGroup* group )
+{
+	// If NULL that means this particular difficulty level has no rivers
+	if ( NULL == group || mValidRivers)
+	{
+		return true;
+	}
+
+	// river style info
+	int			maxdepth;
+	float		beddepth;
+	float		deviation;
+	float		breadth;
+	float		minwidth;
+	float		maxwidth;
+	int			points;
+	string		bridge_name;
+
+	maxdepth  = atoi ( group->FindPairValue ( "maxpathdepth", "5" ) );
+	points    = atoi ( group->FindPairValue ( "points", "10" ) );
+	beddepth  = atof ( group->FindPairValue ( "depth", "1" ) );
+	deviation = atof ( group->FindPairValue ( "deviation", ".03" ) );
+	breadth   = atof ( group->FindPairValue ( "breadth", "7" ) );
+	minwidth  = atof ( group->FindPairValue ( "minwidth", ".01" ) );
+	maxwidth  = atof ( group->FindPairValue ( "maxwidth", ".03" ) );
+	bridge_name= group->FindPairValue ( "bridge", "" ) ;
+
+	mPathManager->SetRiverStyle( maxdepth, points, minwidth, maxwidth, beddepth, deviation, breadth, bridge_name);
+
+	if (!mValidRivers && 
+		beddepth < 1)						// use a depth of 1 if we don't want any rivers
+	{	// we must create rivers
+		mPathManager->GenerateRivers();
+		mValidRivers = true;
+	}
+
+	return true;
+}
+
+void CRMMission::PlaceBridges()
+{
+	if (!mValidRivers || strlen(mPathManager->GetBridgeName()) < 1)
+		return;
+
+	int		max_bridges = 0;
+	int		path;
+	float	t;
+	float	river_depth = mLandScape->GetLandScape()->GetWaterHeight();
+	vec3_t	pos, lastpos;
+	vec3pair_t bounds;
+	VectorSet(bounds[0], 0,0,0);
+	VectorSet(bounds[1], 0,0,0);
+
+	// walk along paths looking for dips
+	for (path = 0; path < mPathManager->GetPathCount(); path++)
+	{
+		vec4_t tmp_pt, tmp_dir;
+		bool	new_water = true;
+
+		mLandScape->GetPathInfo(path, 0, tmp_pt, tmp_dir );
+		lastpos[0] = mLandScape->GetBounds ( )[0][0] + (mLandScape->GetBounds ( )[1][0]-mLandScape->GetBounds ( )[0][0]) * tmp_pt[0];
+		lastpos[1] = mLandScape->GetBounds ( )[0][1] + (mLandScape->GetBounds ( )[1][1]-mLandScape->GetBounds ( )[0][1]) * tmp_pt[1];
+		lastpos[2] = mLandScape->GetBounds ( )[0][2] + (mLandScape->GetBounds ( )[1][2]-mLandScape->GetBounds ( )[0][2]) * tmp_pt[2];
+		mLandScape->GetLandScape()->GetWorldHeight ( lastpos, bounds, true );
+
+		const float delta = 0.05f;
+		for (t= delta; t < 1.0f; t += delta)
+		{
+			mLandScape->GetPathInfo(path, t, tmp_pt, tmp_dir );
+			pos[0] = mLandScape->GetBounds ( )[0][0] + (mLandScape->GetBounds ( )[1][0]-mLandScape->GetBounds ( )[0][0]) * tmp_pt[0];
+			pos[1] = mLandScape->GetBounds ( )[0][1] + (mLandScape->GetBounds ( )[1][1]-mLandScape->GetBounds ( )[0][1]) * tmp_pt[1];
+			pos[2] = mLandScape->GetBounds ( )[0][2] + (mLandScape->GetBounds ( )[1][2]-mLandScape->GetBounds ( )[0][2]) * tmp_pt[2];
+			mLandScape->GetLandScape()->GetWorldHeight ( pos, bounds, true );
+
+			if (new_water && 
+				lastpos[2] < river_depth && 
+				pos[2] < river_depth && 
+				pos[2] > lastpos[2])
+			{	// add a bridge
+				if (max_bridges < 3)
+				{
+					CRMArea*		area;
+					CRMInstance*	instance;
+
+					max_bridges++;
+
+					// create a single bridge
+					lastpos[2] = mLandScape->GetBounds ( )[0][2] + (mLandScape->GetBounds ( )[1][2]-mLandScape->GetBounds ( )[0][2]) * mPathManager->GetPathDepth();
+					instance = mInstanceFile.CreateInstance ( mPathManager->GetBridgeName() );
+
+					if ( NULL != instance )
+					{	// Set the area 
+						area = mAreaManager->CreateArea ( lastpos, instance->GetSpacingRadius(), instance->GetSpacingLine(), GetDefaultPadding(), 0, vec3_origin, pos, instance->GetFlattenRadius()?true:false, false, instance->GetLockOrigin() );
+						area->EnableLookAt(false);
+
+						instance->SetArea ( mAreaManager, area );
+						mInstances.push_back ( instance );
+						new_water = false;
+					}
+				}
+			}
+			else if (pos[2] > river_depth)
+			{	// hit land again
+				new_water = true;
+			}
+			VectorCopy ( pos, lastpos );
+		}
+	}
+}
+
+void CRMMission::PlaceWallInstance(CRMInstance*	instance, float xpos, float ypos, float zpos, int x, int y, float angle)
+{
+	if (NULL == instance)
+		return;
+
+	float spacing = instance->GetSpacingRadius();
+	CRMArea*		area;
+	vec3_t			origin;
+
+	origin[0] = xpos + spacing * x;
+	origin[1] = ypos + spacing * y;
+	origin[2] = zpos;
+
+	// Set the area of position
+	area = mAreaManager->CreateArea ( origin, (spacing / 2.1f), 0, GetDefaultPadding(), 0, vec3_origin, origin, instance->GetFlattenRadius()?true:false, false, instance->GetLockOrigin() );
+	area->EnableLookAt(false);
+	area->SetAngle(angle);
+	instance->SetArea ( mAreaManager, area );
+
+	mInstances.push_back ( instance );
+}
+
+
+/************************************************************************************************
+ * CRMMission::ParseWallRect
+ *	creates instances for walled rectangle at this node (fence)
+ *
+ * inputs:
+ *  group: parser group containing the wall rect info
+ *
+ * return:
+ *	true:  parsed successfully
+ *  false: failed to parse
+ *
+ ************************************************************************************************/
+bool CRMMission::ParseWallRect(CGPGroup* group , int side)
+{
+#ifndef PRE_RELEASE_DEMO
+	CGPGroup* wallGroup = group->FindSubGroup ( "wallrect" ) ;
+
+	// If NULL that means this particular instance has no wall rect
+	if ( NULL == group || NULL == wallGroup)
+	{
+		return true;
+	}
+
+	const char* wallName = wallGroup->FindPairValue ( "wall_instance", "" );
+	const char* cornerName = wallGroup->FindPairValue ( "corner_instance", "" );
+	const char* towerName = wallGroup->FindPairValue ( "tower_instance", "" );
+	const char* gateName = wallGroup->FindPairValue ( "gate_instance", "" );
+	const char* ripName = wallGroup->FindPairValue ( "rip_instance", "" );
+
+	if ( NULL != wallName )
+	{
+		int xcount = atoi( wallGroup->FindPairValue ( "xcount", "0" ) );
+		int ycount = atoi( wallGroup->FindPairValue ( "ycount", "0" ) );
+
+		int gateCount = atoi( wallGroup->FindPairValue ( "gate_count", "1" ) );
+		int gateMin = atoi( wallGroup->FindPairValue ( "gate_min", "0" ) );
+		int gateMax = atoi( wallGroup->FindPairValue ( "gate_max", "0" ) );
+
+		int ripCount = atoi( wallGroup->FindPairValue ( "rip_count", "0" ) );
+		int ripMin = atoi( wallGroup->FindPairValue ( "rip_min", "0" ) );
+		int ripMax = atoi( wallGroup->FindPairValue ( "rip_max", "0" ) );
+
+		int towerCount = atoi( wallGroup->FindPairValue ( "tower_count", "0" ) );
+		int towerMin = atoi( wallGroup->FindPairValue ( "tower_min", "0" ) );
+		int towerMax = atoi( wallGroup->FindPairValue ( "tower_max", "0" ) );
+
+		if (gateMin != gateMax)
+			gateCount = mLandScape->irand(gateMin,gateMax);
+
+		if (ripMin != ripMax)
+			ripCount = mLandScape->irand(ripMin,ripMax);
+
+		if (towerMin != towerMax)
+			towerCount = mLandScape->irand(towerMin,towerMax);
+
+		if (NULL == gateName)
+			gateCount = 0;
+
+		if (NULL == towerName)
+			towerCount = 0;
+
+		if (NULL == ripName)
+			ripCount = 0;
+
+		const char*		nodename;
+		CGPGroup* originGroup = group->FindSubGroup ( "origin" );
+		if (originGroup)
+		{
+			nodename = originGroup->FindPairValue ( "node", "" );
+			if (*nodename)
+			{
+				CRMNode*	node;
+				// Find the node being attached to
+				node = mPathManager->FindNodeByName ( nodename );
+				if ( node )
+				{
+					CRMInstance*	instance;
+					int x,y;
+					int halfx = xcount/2;
+					int halfy = ycount/2;
+					float xpos = mLandScape->GetBounds ( )[0][0] + (mLandScape->GetBounds ( )[1][0]-mLandScape->GetBounds ( )[0][0]) * node->GetPos()[0];
+					float ypos = mLandScape->GetBounds ( )[0][1] + (mLandScape->GetBounds ( )[1][1]-mLandScape->GetBounds ( )[0][1]) * node->GetPos()[1];
+					float zpos = mLandScape->GetBounds ( )[1][2] + 100;
+					float angle = 0;
+					int  lastGate = 0;
+					int  lastRip = 0;
+
+					// corners
+					x = -halfx;
+					y = -halfy;
+					if (towerCount > 3 || 
+  					    (towerCount > 0 && mLandScape->irand(1,2) == 1) )
+					{
+						towerCount--;
+						instance = mInstanceFile.CreateInstance ( towerName );
+					}
+					else
+						instance = mInstanceFile.CreateInstance ( cornerName );
+					angle = DEG2RAD(90);
+					instance->SetSide(side);
+					PlaceWallInstance(instance, xpos, ypos, zpos, x, y, angle);
+
+					x = halfx;
+					y = -halfy;
+					if (towerCount > 3 || 
+  					    (towerCount > 0 && mLandScape->irand(1,2) == 1) )
+					{
+						towerCount--;
+						instance = mInstanceFile.CreateInstance ( towerName );
+					}
+					else
+						instance = mInstanceFile.CreateInstance ( cornerName );
+					angle = DEG2RAD(180);
+					instance->SetSide(side);
+					PlaceWallInstance(instance, xpos, ypos, zpos, x, y, angle);
+
+					x = halfx;
+					y = halfy;
+					if (towerCount > 3 || 
+  					    (towerCount > 0 && mLandScape->irand(1,2) == 1) )
+					{
+						towerCount--;
+						instance = mInstanceFile.CreateInstance ( towerName );
+					}
+					else
+						instance = mInstanceFile.CreateInstance ( cornerName );
+					angle = DEG2RAD(270);
+					instance->SetSide(side);
+					PlaceWallInstance(instance, xpos, ypos, zpos, x, y, angle);
+
+					x = -halfx;
+					y = halfy;
+					if (towerCount > 3 || 
+  					    (towerCount > 0 && mLandScape->irand(1,2) == 1) )
+					{
+						towerCount--;
+						instance = mInstanceFile.CreateInstance ( towerName );
+					}
+					else
+						instance = mInstanceFile.CreateInstance ( cornerName );
+					angle = DEG2RAD(0);
+					instance->SetSide(side);
+					PlaceWallInstance(instance, xpos, ypos, zpos, x, y, angle);
+
+					// walls
+					angle = DEG2RAD(0);
+					for (x = -halfx+1; x <= halfx-1; x++)
+					{
+						if (lastGate<1 && gateCount > 0 && mLandScape->irand(1,(halfx+halfy)/gateCount) == 1)
+						{	// gate
+							gateCount--;
+							lastGate = 3;
+							instance = mInstanceFile.CreateInstance ( gateName );
+						}
+						else if (lastRip<1 && ripCount > 0 && mLandScape->irand(1,(halfx+halfy)/ripCount) == 1)
+						{	// damaged fence
+							ripCount--;
+							lastRip = 3;
+							instance = mInstanceFile.CreateInstance ( ripName );
+						}
+						else
+						{   // just a wall
+							instance = mInstanceFile.CreateInstance ( wallName );
+							lastRip--;
+							lastGate--;
+						}
+						instance->SetSide(side);
+						PlaceWallInstance(instance, xpos, ypos, zpos, x, -halfy, angle);
+					}
+					for (x = -halfx+1; x <= halfx-1; x++)
+					{
+						if (lastGate<1 && gateCount > 0 && mLandScape->irand(1,(halfx+halfy)/gateCount) == 1)
+						{	// gate
+							gateCount--;
+							lastGate = 3;
+							instance = mInstanceFile.CreateInstance ( gateName );
+						}
+						else if (lastRip<1 && ripCount > 0 && mLandScape->irand(1,(halfx+halfy)/ripCount) == 1)
+						{	// damaged fence
+							ripCount--;
+							lastRip = 3;
+							instance = mInstanceFile.CreateInstance ( ripName );
+						}
+						else
+						{   // just a wall
+							instance = mInstanceFile.CreateInstance ( wallName );
+							lastRip--;
+							lastGate--;
+						}
+						instance->SetSide(side);
+						PlaceWallInstance(instance, xpos, ypos, zpos, x, halfy, angle);
+					}
+
+					angle = DEG2RAD(90);
+					for (y = -halfy+1; y <= halfy-1; y++)
+					{
+						if (lastGate<1 && gateCount > 0 && mLandScape->irand(1,(halfx+halfy)/gateCount) == 1)
+						{	// gate
+							gateCount--;
+							lastGate = 3;
+							instance = mInstanceFile.CreateInstance ( gateName );
+						}
+						else if (lastRip<1 && ripCount > 0 && mLandScape->irand(1,(halfx+halfy)/ripCount) == 1)
+						{	// damaged fence
+							ripCount--;
+							lastRip = 3;
+							instance = mInstanceFile.CreateInstance ( ripName );
+						}
+						else
+						{   // just a wall
+							instance = mInstanceFile.CreateInstance ( wallName );
+							lastRip--;
+							lastGate--;
+						}
+						instance->SetSide(side);
+						PlaceWallInstance(instance, xpos, ypos, zpos, -halfx, y, angle);
+					}
+					for (y = -halfy+1; y <= halfy-1; y++)
+					{
+						if (lastGate<1 && gateCount > 0 && mLandScape->irand(1,(halfx+halfy)/gateCount) == 1)
+						{	// gate
+							gateCount--;
+							lastGate = 3;
+							instance = mInstanceFile.CreateInstance ( gateName );
+						}
+						else if (lastRip<1 && ripCount > 0 && mLandScape->irand(1,(halfx+halfy)/ripCount) == 1)
+						{	// damaged fence
+							ripCount--;
+							lastRip = 3;
+							instance = mInstanceFile.CreateInstance ( ripName );
+						}
+						else
+						{   // just a wall
+							instance = mInstanceFile.CreateInstance ( wallName );
+							lastRip--;
+							lastGate--;
+						}
+						instance->SetSide(side);
+						PlaceWallInstance(instance, xpos, ypos, zpos, halfx, y, angle);
+					}
+				}
+			}
+		}
+	}			
+	else
+		return false;
+#endif // #ifndef PRE_RELEASE_DEMO
+
+	return true;
+}
+
+
+/************************************************************************************************
+ * CRMMission::ParseInstancesOnPath
+ *	creates instances on path between nodes
+ *
+ * inputs:
+ *  group: parser group containing the defenses, other instances on the path between nodes
+ *
+ * return:
+ *	true:  parsed successfully
+ *  false: failed to parse
+ *
+ ************************************************************************************************/
+bool CRMMission::ParseInstancesOnPath ( CGPGroup* group )
+{
+#ifndef PRE_RELEASE_DEMO
+	CGPGroup* defenseGroup;
+	for ( defenseGroup = group->GetSubGroups(); 
+		  defenseGroup; 
+		  defenseGroup=defenseGroup->GetNext() )
+	if (stricmp ( defenseGroup->GetName ( ), "defenses" )==0 ||
+		stricmp ( defenseGroup->GetName(), "instanceonpath")==0)
+	{
+		const char* defName = defenseGroup->FindPairValue ( "instance", "" );
+		if ( *defName )
+		{
+			float	minpos;
+			float	maxpos;
+			int		mincount;
+			int		maxcount;
+
+			// how far along path does this get placed?
+			minpos = atof( defenseGroup->FindPairValue ( "minposition", "0.5" ) );
+			maxpos = atof( defenseGroup->FindPairValue ( "maxposition", "0.5" ) );
+			mincount = atoi( defenseGroup->FindPairValue ( "mincount", "1" ) );
+			maxcount = atoi( defenseGroup->FindPairValue ( "maxcount", "1" ) );
+
+			const char*		nodename;
+			CGPGroup* originGroup = group->FindSubGroup ( "origin" );
+			if (originGroup)
+			{
+				nodename = originGroup->FindPairValue ( "node", "" );
+				if (*nodename)
+				{
+					CRMNode*	node;
+					// Find the node being attached to
+					node = mPathManager->FindNodeByName ( nodename );
+					if ( node )
+					{
+						int dir;
+						// look at each connection from this node to others, if there is a path, create a defense
+						for (dir=0; dir<DIR_MAX; dir++)
+						{
+							if (node->PathExist(dir))
+							{	// path leads out of this node
+								CRMArea*		area;
+								CRMInstance*	instance;
+								float			spacing;
+								vec3_t			origin;
+								vec3_t			lookat;
+								vec4_t			tmp_pt, tmp_dir;
+								int				n,num_insts = mLandScape->irand(mincount,maxcount);
+								int				pathID = node->GetPath(dir);
+
+								if (0 == num_insts)
+									continue;
+
+								float posdelta = (maxpos - minpos) / num_insts;
+
+								for (n=0; n<num_insts; n++)
+								{
+
+									instance = mInstanceFile.CreateInstance ( defName );
+									// Failed to create, not good
+									if ( NULL == instance )
+									{
+										continue; 
+									}
+									// If a spacing radius was specified then override the one thats
+									// in the instance
+									spacing = atof( defenseGroup->FindPairValue ( "spacing", "0" ) );
+									if ( spacing )
+									{
+										instance->SetSpacingRadius ( spacing );
+									}
+
+									instance->SetFilter(group->FindPairValue("filter", ""));
+									instance->SetTeamFilter(group->FindPairValue("teamfilter", ""));
+
+									if (strstr(instance->GetTeamFilter(),"red"))
+										instance->SetSide(SIDE_RED);
+									else if (strstr(instance->GetTeamFilter(),"blue"))
+										instance->SetSide(SIDE_BLUE);
+
+									float pos_along_path = mLandScape->flrand(minpos + posdelta*n, minpos + posdelta*(n+1));
+									float look_along_path = atof( defenseGroup->FindPairValue ( "pathalign", "1" ) ) ;
+									mLandScape->GetPathInfo (pathID, pos_along_path, tmp_pt, tmp_dir );
+									origin[0] = tmp_pt[0];
+									origin[1] = tmp_pt[1];
+
+									mLandScape->GetPathInfo (pathID, look_along_path, tmp_dir, tmp_pt );
+									lookat[0] = tmp_pt[0];
+									lookat[1] = tmp_pt[1];
+
+									origin[0] = mLandScape->GetBounds ( )[0][0] + (mLandScape->GetBounds ( )[1][0]-mLandScape->GetBounds ( )[0][0]) * origin[0];
+									origin[1] = mLandScape->GetBounds ( )[0][1] + (mLandScape->GetBounds ( )[1][1]-mLandScape->GetBounds ( )[0][1]) * origin[1];
+									origin[2] = mLandScape->GetBounds ( )[0][2] ;
+
+									// look at a point along the path at this location
+									lookat[0] = mLandScape->GetBounds ( )[0][0] + (mLandScape->GetBounds ( )[1][0]-mLandScape->GetBounds ( )[0][0]) * lookat[0];
+									lookat[1] = mLandScape->GetBounds ( )[0][1] + (mLandScape->GetBounds ( )[1][1]-mLandScape->GetBounds ( )[0][1]) * lookat[1];
+									lookat[2] = 0;
+
+									// Fixed height?  (used for bridges)
+									if ( !atoi(group->FindPairValue ( "nodrop", "0" )) )
+									{
+										origin[2] = mLandScape->GetBounds ( )[1][2] + 100;
+									}
+					
+									// Set the area of position
+									area = mAreaManager->CreateArea ( origin, instance->GetSpacingRadius(), instance->GetSpacingLine(), GetDefaultPadding(), 0, origin, lookat, instance->GetFlattenRadius()?true:false, true, instance->GetLockOrigin(), mSymmetric );
+									area->EnableLookAt(false);
+
+									if ( node->GetFlattenHeight ( ) == -1 )
+									{
+										node->SetFlattenHeight ( 66 + mLandScape->irand(0,40) );
+									}
+									instance->SetFlattenHeight ( node->GetFlattenHeight ( ) );
+
+									instance->SetArea ( mAreaManager, area );
+
+									mInstances.push_back ( instance );
+								}
+							}
+						}
+					}
+				}
+			}
+			else
+				return false;
+		}			
+		else
+			return false;
+
+	}
+#endif // #ifndef PRE_RELEASE_DEMO
+
+	return true;
+}
+
+/************************************************************************************************
+ * CRMMission::ParseInstance
+ *	Parses an individual instance
+ *
+ * inputs:
+ *  group: parser group containing the list of instances
+ *
+ * return:
+ *	true: instances parsed successfully
+ *  false: instances failed to parse
+ *
+ ************************************************************************************************/
+bool CRMMission::ParseInstance ( CGPGroup* group )
+{
+	CRMArea*		area;
+	CRMInstance*	instance;
+	float			spacing;
+	vec3_t			origin;
+	vec3_t			lookat;
+	int				flattenHeight;
+
+	// create fences / walls 
+
+	// Create the instance using the instance file helper class
+	instance = mInstanceFile.CreateInstance ( group->GetName ( ) );
+
+	// Failed to create, not good
+	if ( NULL == instance )
+	{
+		return false;
+	}
+
+	// If a spacing radius was specified then override the one thats
+	// in the instance
+	spacing = atof( group->FindPairValue ( "spacing", "0" ) );
+	if ( spacing )
+	{
+		instance->SetSpacingRadius ( spacing );
+	}
+
+	instance->SetFilter(group->FindPairValue("filter", ""));
+	instance->SetTeamFilter(group->FindPairValue("teamfilter", ""));
+
+	if (strstr(instance->GetTeamFilter(),"red"))
+		instance->SetSide( SIDE_RED);
+	else if (strstr(instance->GetTeamFilter(),"blue"))
+		instance->SetSide( SIDE_BLUE );
+
+//	ParseWallRect(group, instance->GetSide());
+
+	// Get its origin now
+	ParseOrigin ( group->FindSubGroup ( "origin" ), origin, lookat, &flattenHeight );
+	origin[0] = mLandScape->GetBounds ( )[0][0] + (mLandScape->GetBounds ( )[1][0]-mLandScape->GetBounds ( )[0][0]) * origin[0];
+	origin[1] = mLandScape->GetBounds ( )[0][1] + (mLandScape->GetBounds ( )[1][1]-mLandScape->GetBounds ( )[0][1]) * origin[1];
+	origin[2] = mLandScape->GetBounds ( )[0][2] + (mLandScape->GetBounds ( )[1][2]-mLandScape->GetBounds ( )[0][2]) * origin[2];
+
+	lookat[0] = mLandScape->GetBounds ( )[0][0] + (mLandScape->GetBounds ( )[1][0]-mLandScape->GetBounds ( )[0][0]) * lookat[0];
+	lookat[1] = mLandScape->GetBounds ( )[0][1] + (mLandScape->GetBounds ( )[1][1]-mLandScape->GetBounds ( )[0][1]) * lookat[1];
+	lookat[2] = mLandScape->GetBounds ( )[0][2] + (mLandScape->GetBounds ( )[1][2]-mLandScape->GetBounds ( )[0][2]) * lookat[2];
+
+	// Fixed height?  (used for bridges)
+	if ( !atoi(group->FindPairValue ( "nodrop", "0" )) )
+	{
+		origin[2] = mLandScape->GetBounds ( )[1][2] + 100;
+	}
+
+	// Set the area of position
+	area = mAreaManager->CreateArea ( origin, instance->GetSpacingRadius(), instance->GetSpacingLine(), GetDefaultPadding(), 0, vec3_origin, lookat, instance->GetFlattenRadius()?true:false, true, instance->GetLockOrigin(), mSymmetric );
+	instance->SetArea ( mAreaManager, area );
+	instance->SetFlattenHeight ( flattenHeight );
+
+	mInstances.push_back ( instance );
+
+	// create defenses?
+	ParseInstancesOnPath(group );
+
+	return true;
+}
+
+
+/************************************************************************************************
+ * CRMMission::ParseInstances
+ *	parses all instances within the mission and populates the instance list
+ *
+ * inputs:
+ *  group: parser group containing the list of instances
+ *
+ * return:
+ *	true: instances parsed successfully
+ *  false: instances failed to parse
+ *
+ ************************************************************************************************/
+bool CRMMission::ParseInstances ( CGPGroup* group )
+{
+#ifndef PRE_RELEASE_DEMO
+	// If NULL that means this particular difficulty level has no instances
+	if ( NULL == group )
+	{
+		return true;
+	}
+
+	// Loop through all the instances in the mission and add each 
+	// to the master list of instances
+	for ( group = group->GetSubGroups(); 
+		  group; 
+		  group=group->GetNext() )
+	{
+		ParseInstance ( group );
+	}
+#endif // #ifndef PRE_RELEASE_DEMO
+
+	return true;
+}
+
+/************************************************************************************************
+ * CRMMission::ParseObjectives
+ *	parses all objectives within the mission and populates the objective list
+ *
+ * inputs:
+ *  group: parser group containing the list of objectives
+ *
+ * return:
+ *	true: objectives parsed successfully
+ *  false: objectives failed to parse
+ *
+ ************************************************************************************************/
+bool CRMMission::ParseObjectives ( CGPGroup* group )
+{
+	// If NULL that means this particular difficulty level has no objectives
+	if ( NULL == group )
+	{
+		return true;
+	}
+
+	// Loop through all the objectives in the mission and add each
+	// to the master list of objectives
+	for ( group = group->GetSubGroups(); 
+		  group; 
+		  group=group->GetNext() )
+	{
+		CRMObjective* objective;
+
+		// Create the new objective
+		objective = new CRMObjective ( group );
+
+		mObjectives.push_back ( objective );
+	}
+
+	mValidObjectives = true;
+	
+	return true;
+}
+
+/************************************************************************************************
+ * CRMMission::ParseAmmo
+ *	parses the given ammo list and sets the necessary ammo cvars to grant those 
+ *  weapons to the players
+ *
+ * inputs:
+ *  ammos: parser group containing the ammo list
+ *
+ * return:
+ *	true: ammo parsed successfully
+ *  false: ammo failed to parse
+ *
+ ************************************************************************************************/
+bool CRMMission::ParseAmmo ( CGPGroup* ammos )
+{
+/*	CGPValue* ammo;
+
+	// No weapons, no success
+	if ( NULL == ammos )
+	{
+		return false;
+	}
+
+	if (0 == gi.Cvar_VariableIntegerValue("ar_wpnselect"))
+	{
+		// Make sure the ammo cvars are all reset so ammo from the last map or 
+		// another difficulty level wont carry over
+		CWeaponSystem::ClearAmmoCvars (TheWpnSysHelper());
+
+		ammo = ammos->GetPairs ( );
+
+		// Loop through the weapons listed and grant them to the player
+		while ( ammo )
+		{	
+			// Grab the weapons ID
+			AmmoID id = CWeaponSystem::GetAmmoID ( ammo->GetName ( ) );
+
+			// Now set the weapon cvar with the given data
+			TheWpnSysHelper().CvarSet ( CWeaponSystem::GetAmmoCvar ( id ), ammo->GetTopValue ( ), CVAR_AMMO );	
+
+			// Move on to the next weapon
+			ammo = (CGPValue*)ammo->GetNext();
+		}
+	}
+*/
+	mValidAmmo = true;
+
+	return true;
+}
+
+/************************************************************************************************
+ * CRMMission::ParseWeapons
+ *	parses the given weapon list and sets the necessary weapon cvars to grant those 
+ *  weapons to the players
+ *
+ * inputs:
+ *  weapons: parser group containing the weapons list
+ *
+ * return:
+ *	true: weapons parsed successfully
+ *  false: weapons failed to parse
+ *
+ ************************************************************************************************/
+bool CRMMission::ParseWeapons ( CGPGroup* weapons )
+{
+/*	CGPValue*	weapon;
+	WpnID		id;
+
+	// No weapons, no success
+	if ( NULL == weapons )
+	{
+		return false;
+	}
+
+	if (0 == gi.Cvar_VariableIntegerValue("ar_wpnselect"))
+	{
+		// Make sure the weapon cvars are all reset so weapons from the last map or 
+		// another difficulty level wont carry over
+		CWeaponSystem::ClearWpnCvars (TheWpnSysHelper());
+
+		id     = NULL_WpnID;
+		weapon = weapons->GetPairs ( );
+
+		// Loop through the weapons listed and grant them to the player
+		while ( weapon )
+		{	
+			// Grab the weapons ID
+			id = CWeaponSystem::GetWpnID ( weapon->GetName ( ) );
+
+			// Now set the weapon cvar with the given data
+			TheWpnSysHelper().CvarSet ( CWeaponSystem::GetWpnCvar ( id ), weapon->GetTopValue ( ) );	
+
+			// Move on to the next weapon
+			weapon = (CGPValue*)weapon->GetNext();
+		}
+
+		// If we found at least one weapon then ready the last one in the list
+		if ( NULL_WpnID != id )
+		{
+			TheWpnSysHelper().CvarSet("wp_righthand", va("%i/%i/0/0",id,CWeaponSystem::GetClipSize ( id )), CVAR_MISC );
+		}
+	}
+*/
+	mValidWeapons = true;
+
+	return true;
+}
+
+/************************************************************************************************
+ * CRMMission::ParseOutfit
+ *	parses the outfit (weapons and ammo)
+ *
+ * inputs:
+ *  outfit: parser group containing the outfit
+ *
+ * return:
+ *	true: weapons and ammo parsed successfully
+ *  false: failed to parse
+ *
+ ************************************************************************************************/
+bool CRMMission::ParseOutfit ( CGPGroup* outfit )
+{
+	if ( NULL == outfit )
+	{
+		return false;
+	}
+
+/*	// Its ok to fail parsing weapons as long as weapons have
+	// already been parsed at some point
+	if ( !ParseWeapons ( ParseRandom ( outfit->FindSubGroup ( "weapons" ) ) ) )
+	{
+		if ( !mValidWeapons )
+		{
+			return false;
+		}
+	}
+
+	// Its ok to fail parsing ammo as long as ammo have
+	// already been parsed at some point
+	if ( !ParseAmmo ( ParseRandom ( outfit->FindSubGroup ( "ammo" ) ) ) )
+	{
+		if ( !mValidAmmo)
+		{
+			return false;
+		}
+	}
+*/
+	return true;
+}
+
+/************************************************************************************************
+ * CRMMission::ParseRandom
+ *	selects a random sub group with from all within this one
+ *
+ * inputs:
+ *  random: parser group containing the various subgroups
+ *
+ * return:
+ *	true:  parsed successfuly
+ *  false: failed to parse
+ *
+ ************************************************************************************************/
+CGPGroup* CRMMission::ParseRandom ( CGPGroup* randomGroup )
+{
+	if (NULL == randomGroup)
+		return NULL;
+
+	CGPGroup* group;
+	CGPGroup* groups[MAX_RANDOM_CHOICES];
+	int		  numGroups;
+
+	// Build a list of the groups one can be chosen
+	for ( numGroups = 0, group = randomGroup->GetSubGroups ( ); 
+		  group; 
+		  group = group->GetNext ( ) )
+	{
+		if ( stricmp ( group->GetName ( ), "random_choice" ) )
+		{
+			continue;
+		}
+
+		int weight = atoi ( group->FindPairValue ( "random_weight", "1" ) );
+		while (weight-- > 0)
+			groups[numGroups++] = group;
+		assert (numGroups <= MAX_RANDOM_CHOICES);
+	}
+
+	// No groups!
+	if ( !numGroups )
+	{
+		return randomGroup;
+	}
+
+	// Now choose a group to parse
+	return groups[mLandScape->irand(0,numGroups-1)];
+}
+
+/************************************************************************************************
+ * CRMMission::ParseDifficulty
+ *	parses the given difficulty and populates the mission with its data
+ *
+ * inputs:
+ *  difficulty: parser group containing the difficulties info
+ *
+ * return:
+ *	true: difficulty parsed successfully
+ *  false: difficulty failed to parse
+ *
+ ************************************************************************************************/
+bool CRMMission::ParseDifficulty ( CGPGroup* difficulty  )
+{
+	// If a null difficulty then stop the recursion.  Make sure to
+	// return true here so the parsing doesnt fail
+	if ( NULL == difficulty )
+	{
+		return true;
+	}
+	// is map supposed to be symmetric?
+	mSymmetric = (symmetry_t)atoi(difficulty->GetParent()->FindPairValue ( "symmetric", "0" ));
+	mBackUpPath = atoi(difficulty->GetParent()->FindPairValue ( "backuppath", "0" ));
+	if( mSymmetric )
+	{// pick between the 2 starting corners -- yes this is a hack
+		mSymmetric = SYMMETRY_TOPLEFT;
+		if( TheRandomMissionManager->GetLandScape()->irand(0, 1) )
+		{
+			mSymmetric = SYMMETRY_BOTTOMRIGHT;
+		}
+	}
+	
+	mDefaultPadding = atoi(difficulty->GetParent()->FindPairValue ( "padding", "0" ));
+		
+	// Parse the nodes
+	if ( !ParseNodes (  ParseRandom ( difficulty->FindSubGroup ( "nodes" ) ) ) )
+	{
+		return false;
+	}
+
+	// Parse the paths
+	if ( !ParsePaths (  ParseRandom ( difficulty->FindSubGroup ( "paths" ) ) ) )
+	{
+		return false;
+	}
+
+	// Parse the rivers 
+	if ( !ParseRivers (  ParseRandom ( difficulty->FindSubGroup ( "rivers" ) ) ) )
+	{
+		return false;
+	}
+
+	// Handle inherited properties
+	if ( !ParseDifficulty ( difficulty->GetParent ( )->FindSubGroup ( difficulty->FindPairValue ( "inherit", "" ) ) ) )
+	{
+		return false;
+	}
+
+/*
+	// parse the player's outfit (weapons and ammo)
+	if ( !ParseOutfit( ParseRandom ( difficulty->FindSubGroup ( "outfit" ) ) ) )
+	{
+		// Its ok to fail parsing weapons as long as weapons have
+		// already been parsed at some point
+		if ( !ParseWeapons ( ParseRandom ( difficulty->FindSubGroup ( "weapons" ) ) ) )
+		{
+			if ( !mValidWeapons )
+			{
+				return false;
+			}
+		}
+
+		// Its ok to fail parsing ammo as long as ammo have
+		// already been parsed at some point
+		if ( !ParseAmmo ( ParseRandom ( difficulty->FindSubGroup ( "ammo" ) ) ) )
+		{
+			if ( !mValidAmmo)
+			{
+				return false;
+			}
+		}
+	}
+
+	// Its ok to fail parsing objectives as long as objectives have
+	// already been parsed at some point
+	if ( !ParseObjectives ( ParseRandom ( difficulty->FindSubGroup ( "objectives" ) ) ) )
+	{
+		if ( !mValidObjectives )
+		{
+			return false;
+		}
+	}
+*/
+
+	// Set the cvars with the available values
+	Cvar_Set ( "mi_health", difficulty->FindPairValue ( "health", "100" ) );
+	Cvar_Set ( "mi_armor", difficulty->FindPairValue ( "armor", "0" ) );
+
+	// Parse out the timelimit
+	mTimeLimit = atol(difficulty->FindPairValue("timelimit", "0"));
+
+	// NPC multipliers
+	mAccuracyMultiplier = atof(difficulty->FindPairValue("npcaccuracy", "1"));
+	mHealthMultiplier = atof(difficulty->FindPairValue("npchealth", "1"));
+
+	// keep only some of RMG pickups 1 = 100%
+	mPickupHealth = atof(difficulty->FindPairValue("pickup_health", "1"));
+	mPickupArmor = atof(difficulty->FindPairValue("pickup_armor", "1"));
+	mPickupAmmo = atof(difficulty->FindPairValue("pickup_ammo", "1"));
+	mPickupWeapon = atof(difficulty->FindPairValue("pickup_weapon", "1"));
+	mPickupEquipment = atof(difficulty->FindPairValue("pickup_equipment", "1"));
+
+	// Its ok to fail parsing instances as long as instances have
+	// already been parsed at some point
+	if ( !ParseInstances ( ParseRandom ( difficulty->FindSubGroup ( "instances" ) ) ) )
+	{
+		if ( !mValidInstances )
+		{
+			return false;
+		}
+	}
+
+	return true;
+}
+
+/************************************************************************************************
+ * CRMMission::Load
+ *	Loads the given mission using the given difficulty level
+ *
+ * inputs:
+ *  name: Name of the mission to load (should only be the name rather than the full path)
+ *  difficulty: difficulty level to load
+ *
+ * return:
+ *	true: mission successfully loaded
+ *  false: mission failed to load
+ *
+ ************************************************************************************************/
+bool CRMMission::Load ( const char* mission, const char* instances, const char* difficulty )
+{
+	CGenericParser2		parser;
+	CGPGroup*			root;
+
+	// Create the parser for the mission file
+	if(!Com_ParseTextFile(va("ext_data/rmg/%s.mission", mission), parser))
+	{
+		if(!Com_ParseTextFile(va("ext_data/arioche/%s.mission", mission), parser))
+		{
+			Com_Printf("ERROR: Failed to open mission file '%s'\n", mission);
+			return false;
+		}
+	}
+	
+	// Grab the root parser groop and make sure its mission, otherwise this
+	// isnt a valid mission file
+	root = parser.GetBaseParseGroup()->GetSubGroups();
+	if(stricmp(root->GetName(), "mission"))
+	{
+		Com_Printf("ERROR: '%s' is not a valid mission file\n", mission );
+		parser.Clean();
+		return false;
+	}
+	
+	// Grab the mission description and set the cvar for it
+	mDescription = root->FindPairValue ( "description", "<MISSION DESCRIPTION MISSING>" );
+//	Cvar_Set("ar_obj_main0",mDescription.c_str(), CVAR_OBJECTIVE);
+//	Cvar_Set("ar_obj_maincom0", "&OBJECTIVES_INPROGRESS&", CVAR_OBJECTIVE);
+//	Cvar_SetValue ("ar_cur_objective", 0, CVAR_OBJECTIVE);
+
+	string mInfo = root->FindPairValue ( "info", "<MISSION ADDITIONAL INFO MISSING>" );
+//	Cvar_Set("ar_obj_info0",mInfo.c_str(), CVAR_OBJECTIVE);
+
+	mExitScreen = root->FindPairValue ( "exitScreen", "<EXIT SCREEN MISSING>" );
+	mTimeExpiredScreen = root->FindPairValue ( "TimeExpiredScreen", "<TIME EXPIRED SCREEN MISSING>" );
+	
+	// Open the instance file for the specified instances
+	if ( !mInstanceFile.Open ( instances) )
+	{
+		Com_Printf ( "ERROR: Could not open instance file '%s'\n", instances );
+		return false;
+	}
+
+	// Start at one and readjust each time we see and instance
+	// with a higher value
+	mMaxInstancePosition = 1;
+
+	// Now parse the specified difficulty level
+	if ( !ParseDifficulty ( root->FindSubGroup ( difficulty ) ) )
+	{
+		return false;
+	}
+
+	// Generate the terrain now
+	mLandScape->Generate(mSymmetric);
+
+	// Cleanup
+	parser.Clean();
+
+	return true;
+}
+
+/************************************************************************************************
+ * CRMMission::Spawn
+ *	Spawns all of the instances for the entire mission onto the given landscape
+ *
+ * inputs:
+ *  landscape: landscape to spawn instances on
+ *
+ * return:
+ *	true: instances spawned successfully
+ *  false: instances failed to spawn
+ *
+ ***********************************************************************************************/
+
+bool CRMMission::Spawn ( CRandomTerrain* terrain, qboolean IsServer )
+{
+#ifndef PRE_RELEASE_DEMO
+	rmInstanceIter_t	it;
+	int					areaIndex;
+	CRMArea*			area;
+
+	if ( IsServer )
+	{
+		// Prespawn all instances, this is mainly for flattening
+		for(it = mInstances.begin(); it != mInstances.end(); it++)
+		{
+			CRMInstance* instance = *it;
+
+			// Pre-Spawn
+			instance->PreSpawn ( terrain, IsServer );
+
+			if (mSymmetric)
+			{
+				instance->SetMirror(1);
+				instance->PreSpawn ( terrain, IsServer );
+				instance->SetMirror(0);
+			}
+		}
+
+		mLandScape->Smooth ( );
+
+		// place bridges
+		PlaceBridges();
+	}
+#ifndef DEDICATED
+	else
+	{
+		memcpy ( mLandScape->GetLandScape()->GetHeightMap ( ), clc.rmgHeightMap, mLandScape->GetLandScape()->GetRealArea ( ) );
+		memcpy ( mLandScape->GetLandScape()->GetFlattenMap ( ), clc.rmgFlattenMap, mLandScape->GetLandScape()->GetRealArea ( ) );
+		mLandScape->GetLandScape()->rand_seed ( clc.rmgSeed );
+	}
+#endif
+
+	mLandScape->GetLandScape()->UpdatePatches();
+
+	if ( IsServer )
+	{
+		// Spawn all instances
+		for(it = mInstances.begin(); it != mInstances.end(); it++)
+		{
+			CRMInstance* instance = *it;
+
+			// Spawn
+			instance->Spawn ( terrain, IsServer );
+			instance->PostSpawn ( terrain, IsServer );
+
+			if (mSymmetric)
+			{	// spawn the mirror version
+				instance->SetMirror(1);
+				instance->Spawn ( terrain, IsServer );
+				instance->PostSpawn ( terrain, IsServer );
+				instance->SetMirror(0);
+			}
+		}
+	}
+
+	// create automap
+	if (!com_dedicated->integer)
+	{		
+#ifndef DEDICATED
+		CM_TM_Create(mLandScape->GetLandScape());
+
+		if ( IsServer )
+		{
+			CRMManager::ProcessAutomapSymbols ( TheRandomMissionManager->GetAutomapSymbolCount(), TheRandomMissionManager->GetAutomapSymbol(0) );
+		}
+		else
+		{
+			CRMManager::ProcessAutomapSymbols ( clc.rmgAutomapSymbolCount, clc.rmgAutomapSymbols );
+		}
+#endif
+	}
+
+#ifndef FINAL_BUILD
+	// make sure to write out after the mirror happens so red side is displayed on map
+	if (1 == Cvar_VariableIntegerValue("rmg_saveautomap"))
+	{	// write out automap for test purposes
+		char seed[MAX_QPATH];
+		char terrainName[MAX_QPATH];
+		char missionName[MAX_QPATH];
+		Cvar_VariableStringBuffer("RMG_seed", seed, MAX_QPATH);
+		Cvar_VariableStringBuffer("RMG_terrain", terrainName, MAX_QPATH);
+		Cvar_VariableStringBuffer("RMG_mission", missionName, MAX_QPATH);
+
+#ifndef DEDICATED
+		for(it = mInstances.begin(); it != mInstances.end(); it++)
+		{
+			(*it)->DrawAutomapSymbol();
+		}
+		//gi.CM_TM_SaveImageToDisk(terrainName, missionName, seed);
+		CM_TM_SaveImageToDisk(terrainName, missionName, seed);
+#endif
+		Com_Error (ERR_DROP, "RMG Automap written.");
+		return false;
+	}
+#endif
+
+//	// draw player start on automap
+//	CEntity	*spot = NULL;
+//	spot = entitySystem->GetEntityFromClassname( spot, "info_player_start");
+//	if (spot)
+//	{
+//		gi.CM_TM_AddStart(spot->GetOrigin()[0], spot->GetOrigin()[1]);
+//	}
+
+	// Spawn NPC triggers now
+//	SpawnNPCTriggers ( mLandScape );
+
+	// Restory all the NPC's accuracies to the template accuracies times the
+	// multiplier
+//	INPCEnt::RestoreTemplate ( mAccuracyMultiplier, mHealthMultiplier );
+
+	if ( IsServer )
+	{
+		// Little trick to set the current objective to the first in the list
+		CompleteObjective ( NULL );
+
+		// Iterate through the areas and add each to the landscapes list, this is sorta hacky
+		// but bridges the game / common gap
+		for ( areaIndex = 0; NULL != (area = mAreaManager->EnumArea ( areaIndex )); areaIndex ++ )
+		{
+			// Dont bother adding it to the list if collision isnt enabled
+			if ( !area->IsCollisionEnabled() )
+			{
+				continue;
+			}
+
+			CArea* newarea = new CArea ( );
+			newarea->Init ( area->GetOrigin(), area->GetSpacingRadius (), 0, area->IsFlattened()?AT_FLAT:AT_NONE );
+			mLandScape->GetLandScape()->SaveArea( newarea );
+
+			if (mSymmetric)
+			{
+				CArea* newarea = new CArea ( );
+				newarea->Init ( area->GetOrigin(), area->GetSpacingRadius (), 0, area->IsFlattened()?AT_FLAT:AT_NONE );
+				newarea->GetPosition()[0] = mLandScape->GetBounds ( )[0][0]+mLandScape->GetBounds ( )[1][0]-newarea->GetPosition()[0];
+				newarea->GetPosition()[1] = mLandScape->GetBounds ( )[0][1]+mLandScape->GetBounds ( )[1][1]-newarea->GetPosition()[1];
+				mLandScape->GetLandScape()->SaveArea( newarea );
+			}
+		}
+
+		mInstanceFile.Close ( );
+	}
+#endif // PRE_RELEASE_DEMO
+
+	return true;
+}
+
+/************************************************************************************************
+ * CRMMission::CompleteMission
+ *	Pauses the game, plays an end screen after a brief delay, which then returns the player to
+ * the RMG menu.
+ *                                                                             *
+ * Input                                                                                        *
+ *    <Variable>: <Description>                                                                 *
+ * Output / Return                                                                              *
+ *    <Variable>: <Description>                                                                 *
+ ************************************************************************************************/
+ void CRMMission::CompleteMission(void)
+ {
+	Cvar_Set ("cl_paused", "1");
+
+//	AddText(va("killserver; menu %s\n", mExitScreen.c_str()));
+	return;
+ }
+
+/************************************************************************************************
+ * CRMMission::FailedMission
+ *	Pauses the game, plays an end screen after a brief delay, which then returns the player to
+ * the RMG menu.
+ *                                                                             *
+ * Input                                                                                        *
+ *    TimeExpired: indicates if the reason failed was because of time
+ * Output / Return                                                                              *
+ *    <Variable>: <Description>                                                                 *
+ ************************************************************************************************/
+ void CRMMission::FailedMission(bool TimeExpired)
+ {
+	Cvar_Set ("cl_paused", "1");
+
+	if (TimeExpired)
+	{
+//		AddText(va("killserver; menu %s\n", mTimeExpiredScreen.c_str()));
+	}
+	return;
+ }
+
+/************************************************************************************************
+ * CRMMission::CompleteObjective
+ *	Completes the given objective and advances the current objective accordingly
+ *
+ * inputs:
+ *  objective: the objetive to mark complete
+ *
+ * return:
+ *	none
+ *
+ ************************************************************************************************/
+void CRMMission::CompleteObjective ( CRMObjective* objective )
+{
+	rmObjectiveIter_t it;
+
+	// Set the object as completed
+	if ( objective )
+	{
+		objective->Complete ( true );
+
+		// Set the completed text for the objective
+//		gi.Cvar_Set( va("ar_obj_subcom0_%i", objective->GetOrderIndex ( )), "&OBJECTIVES_COMPLETE&", CVAR_OBJECTIVE) ;
+
+/*		CEntity *tent = G_TempEntity( vec3_origin, EV_SUB_PRINT );
+		tent->s.time2 = gi.SP_GetStringID ( objective->GetMessage ( ) );	
+		tent->r.svFlags |= SVF_BROADCAST;
+		G_AddTempEntity(tent);
+
+		if (objective->CompleteSoundID())
+			G_SoundBroadcast( tent, objective->CompleteSoundID());
+*/
+	}
+
+	mCurrentObjective = NULL;
+
+	// Find the next objective
+	for (it = mObjectives.begin(); it != mObjectives.end(); it++)
+	{
+		objective = (*it);
+
+		// Skip completed objectives
+		if ( objective->IsCompleted ( ) )
+		{
+			continue;
+		}
+
+		// Find the objective with the lowest priority
+		if ( mCurrentObjective && objective->GetPriority ( ) > mCurrentObjective->GetPriority ( ) )
+		{
+			continue;
+		}
+
+		// Found one
+		mCurrentObjective = objective;
+	}	
+
+	if ( NULL != mCurrentObjective )
+	{
+//		Cvar_SetValue ("ar_cur_objective", mCurrentObjective->GetOrderIndex ( ), CVAR_OBJECTIVE);
+
+		mCurrentObjective->Activate ( );
+	}
+	else
+	{
+		// Set the completed text for the objective
+//		Cvar_Set( "ar_obj_maincom0", "&OBJECTIVES_COMPLETE&", CVAR_OBJECTIVE) ;
+	}
+}
+
+/************************************************************************************************
+ * CRMMission::Preview
+ *	Previews the instances within the mission
+ *
+ * inputs:
+ *  from: the origin which the mission is being previewed from
+ *
+ * return:
+ *	none
+ *
+ ************************************************************************************************/
+void CRMMission::Preview ( const vec3_t from )
+{
+	rmInstanceIter_t	it;
+
+	// Look for settlements close to the player and put up some debug stuff
+	for(it = mInstances.begin(); it != mInstances.end(); it++)
+	{
+		CRMInstance* instance = *it;
+
+		vec3_t a;
+		vec3_t b;
+
+		VectorCopy ( from, a );
+		VectorCopy ( instance->GetOrigin(), b );
+
+		a[2] = 0;
+		b[2] = 0;
+
+		// Skip stuff thats too far away
+		if ( Distance ( a, b) > 2000 )
+		{
+			continue;
+		}
+
+		instance->Preview ( from );
+	}
+}
+
+/************************************************************************************************
+ * CRMMission::PurgeTrigger
+ *	Purge the trigger and all its targets
+ *
+ * inputs:
+ *  trigger: trigger to purge
+ *
+ * return:
+ *	none
+ *
+ ************************************************************************************************/
+/*void CRMMission::PurgeTrigger ( CEntity* trigger )
+{
+	CEntity* target;
+	
+	// Purge all targets
+	target = entitySystem->GetEntityFromTargetName ( NULL, trigger->GetTarget ( ) );
+	while ( target )
+	{
+		PurgeTrigger ( target );
+
+		target = entitySystem->GetEntityFromTargetName ( target, trigger->GetTarget ( ) );
+	}
+
+	// Get rid of the purge trigger
+	entitySystem->RemoveEntityWithServer ( trigger );
+	entitySystem->RemoveEntity ( trigger );
+}
+*/
+/************************************************************************************************
+ * CRMMission::PurgeUnlinkedTriggers
+ *	Searches the entitySystem form a random arioche trigger that matches the objective name
+ *
+ * inputs:
+ *  none
+ *
+ * return:
+ *	trigger: a random trigger or NULL if one couldnt be found
+ *
+ ************************************************************************************************/
+/*void CRMMission::PurgeUnlinkedTriggers ( )
+{
+	CTriggerAriocheObjective*	search;
+
+	// Start at the first match of the classname
+	search = (CTriggerAriocheObjective*) entitySystem->GetEntityFromClassname ( NULL, "trigger_arioche_objective" );
+
+	// Continue on as long as there are triggers
+	while ( search ) 
+	{
+		CTriggerAriocheObjective* purge = search;
+
+		// move on to the next trigger before deleting the entity 
+		// just in case there are some state issues with the search
+		search = (CTriggerAriocheObjective*) entitySystem->GetEntityFromClassname ( search, "trigger_arioche_objective" );
+
+		// Dont purge linked triggers
+		if ( purge->GetObjective ( ) )
+		{
+			continue;
+		}
+
+		// Purge the trigger and all its targets
+		PurgeTrigger ( purge );
+	}
+}
+*/
+/************************************************************************************************
+ * CRMMission::SpawnNPCTriggers
+ *	Spawn triggers across the map which will activate sleeping NPCs
+ *
+ * inputs:
+ *  landscape: landscape to spawn the triggers relative to
+ *
+ * return:
+ *	trigger: a random trigger or NULL if one couldnt be found
+ *
+ ************************************************************************************************/
+/*void CRMMission::SpawnNPCTriggers ( CCMLandScape* landscape )
+{
+	CEntity* ent;
+	int		 i;
+	int		 count;
+	float	 section;
+
+	// Determine how many NPC sections there are in the map
+	count   = (landscape->GetBounds()[1][0] - landscape->GetBounds()[0][0]) / 5000.0f;
+	section = (landscape->GetBounds()[1][0] - landscape->GetBounds()[0][0]) / count;
+
+	// Drop a trigger down at each NPC section interval except for the first and last.
+	for ( i = 1; i < count - 1; i ++ )
+	{
+		vec3_t mins;
+		vec3_t maxs;
+		vec3_t origin;
+
+		VectorCopy ( landscape->GetBounds()[0], mins );
+		VectorCopy ( landscape->GetBounds()[1], maxs );
+
+		// Set up the mins and maxs for the trigger
+		mins[0] = mins[0] + (section * i) - 100;
+		maxs[0] = mins[0] + 100;
+		maxs[2] = maxs[2] + 100;
+		mins[2] = mins[2] - 100;
+
+		origin[0] = (maxs[0]-mins[0])/2 + mins[0];
+		origin[1] = (maxs[1]-mins[1])/2 + mins[1];
+		origin[2] = (maxs[2]-mins[2])/2 + mins[2];
+
+		spawnSystem->ClearSpawnFields();
+		spawnSystem->AddSpawnField("classname", "trigger_arioche_npcspawner" );
+		spawnSystem->AddSpawnField("origin", va("%f %f %f",origin[0],origin[1],origin[2]) );
+		spawnSystem->AddSpawnField("target", va("rmg_npc_%i", i + 1) );
+
+		// Spawn the inhabitant, if it fails then fail
+		ent = entitySystem->SpawnItem("trigger_arioche_npcspawner");
+		if ( !ent )
+		{
+			continue;
+		}
+
+		// Fail if we cant register the entity
+		if ( -1 == entitySystem->RegisterEntityWithServer( ent ) )
+		{
+			entitySystem->RemoveEntity ( ent );
+			continue;
+		}
+
+		// Normalize the mins and maxs for the X axis since they arent
+		// absolute mins and maxs
+		mins[0] = -100;
+		maxs[0] = 100;
+
+		// Adjust the absmin and absmax for the trigger now
+		VectorCopy ( mins, ent->r.mins[0] );
+		VectorCopy ( maxs, ent->r.maxs[0] );
+
+		Com_DPrintf( "NPC Trigger spawned at '%f %f %f' for targets 'rmg_npc_%i'\n", origin[0], origin[1], origin[2], i + 1 );
+
+		// Set the "ONLY_ONCE" spawn flag
+		ent->AddSpawnflags ( 2 );
+
+#ifdef _GAME
+		// initial linking
+		gi.SV_LinkEntity( ent ); 
+#endif	
+	}
+
+	AttachNPCTriggers ( landscape );
+}
+*/
+
+/************************************************************************************************
+ * CRMMission::AttachNPCTriggers
+ *	Attaches npc triggers to all unattached npcs
+ *
+ * inputs:
+ *  landscape: landscape triggers were spawned on
+ *
+ * return:
+ *	trigger: a random trigger or NULL if one couldnt be found
+ *
+ ************************************************************************************************/
+/*void CRMMission::AttachNPCTriggers ( CCMLandScape* landscape )
+{
+	TNPCList	npcList;
+	TNPCFinder	npcFinder;
+	CNPC*		theNPC = 0;
+	int			npcsegment;
+
+	GetCharacterManager().GetCharacterList(npcList);
+
+	// Loop through all npcs and reset their accuracy
+	for( npcFinder = npcList.begin(); npcFinder != npcList.end(); npcFinder++)
+	{		
+		theNPC = (CNPC*) INPCEnt::GetEntity(*npcFinder);
+		if(!theNPC)
+		{
+			continue;
+		}
+
+		npcsegment = (theNPC->r.currentOrigin[0] - landscape->GetMins()[0]) / 5000.0f;		
+
+		// All npcs in segment 0 and 1 are immediately spawned, all others wait for the
+		// trigger
+		if ( npcsegment > 1 )
+		{
+			entitySystem->RemoveFromTargetNameMap(theNPC);	
+			theNPC->SetTargetName ( va("rmg_npc_%i", npcsegment ) );
+			entitySystem->AddToTargetNameMap(theNPC);
+
+			// Start the NPC in the off position
+			theNPC->SetSpawnflags(1);
+			theNPC->r.contents	= 0;
+			theNPC->r.svFlags	|= SVF_NOCLIENT;
+			theNPC->s.eFlags	|= EF_NODRAW;				
+		}
+	}
+}
+*/
+
+
diff --git a/codemp/RMG/RM_Mission.h b/codemp/RMG/RM_Mission.h
new file mode 100644
index 0000000..d618ab1
--- /dev/null
+++ b/codemp/RMG/RM_Mission.h
@@ -0,0 +1,129 @@
+#pragma once
+#if !defined(RM_MISSION_H_INC)
+#define RM_MISSION_H_INC
+
+#ifdef DEBUG_LINKING
+	#pragma message("...including RM_Mission.h")
+#endif
+
+// maximum random choices
+#define MAX_RANDOM_CHOICES 100
+
+typedef vector<int> 	rmIntVector_t;
+
+
+class CRMMission
+{
+private:
+
+	rmObjectiveList_t		mObjectives;
+	rmInstanceList_t		mInstances;
+
+	CRMInstanceFile			mInstanceFile;
+	CRMObjective*			mCurrentObjective;
+
+	bool					mValidNodes;
+	bool					mValidPaths;
+	bool					mValidRivers;
+	bool					mValidWeapons;
+	bool					mValidAmmo;
+	bool					mValidObjectives;
+	bool					mValidInstances;
+
+	int						mTimeLimit;
+	int						mMaxInstancePosition;
+
+	// npc multipliers
+	float					mAccuracyMultiplier;
+	float					mHealthMultiplier;
+
+	// % chance that RMG pickup is actually spawned
+	float					mPickupHealth;
+	float					mPickupArmor;
+	float					mPickupAmmo;
+	float					mPickupWeapon;
+	float					mPickupEquipment;
+
+	string					mDescription;
+	string					mExitScreen;
+	string					mTimeExpiredScreen;
+
+	// symmetric landscape style
+	symmetry_t				mSymmetric;
+
+	// if set to 1 in the mission file, adds an extra connecting path in symmetric maps
+	// to ensure both sides actually do connect
+	int						mBackUpPath;
+
+	int						mDefaultPadding;
+
+	CRMAreaManager*			mAreaManager;
+
+	CRMPathManager*			mPathManager;
+
+	CRandomTerrain*			mLandScape;
+
+public:	
+
+	CRMMission ( CRandomTerrain* );
+	~CRMMission ( );
+
+	bool			Load					( const char* name, const char* instances, const char* difficulty );
+	bool			Spawn					( CRandomTerrain* terrain, qboolean IsServer );
+
+	void			Preview					( const vec3_t from );									
+										
+	CRMObjective*	FindObjective			( const char* name );
+	CRMObjective*	GetCurrentObjective		( ) { return mCurrentObjective; }
+	
+	void			CompleteMission			(void);
+	void			FailedMission			(bool TimeExpired);
+	void			CompleteObjective		( CRMObjective* ojective );
+
+	int				GetTimeLimit			(void)	{ return mTimeLimit; }
+	int				GetMaxInstancePosition	(void)  { return mMaxInstancePosition; }
+	const char*		GetDescription			(void)  { return mDescription.c_str(); }
+	const char*		GetExitScreen			(void)  { return mExitScreen.c_str(); }
+	int				GetSymmetric			(void)  { return mSymmetric; }
+	int				GetBackUpPath			(void)  { return mBackUpPath; }
+	int				GetDefaultPadding		(void)  { return mDefaultPadding; }
+
+//	void			CreateMap				( void );
+
+	bool			DenyPickupHealth	() {return mLandScape->flrand(0.0f,1.0f) > mPickupHealth;}
+	bool			DenyPickupArmor		() {return mLandScape->flrand(0.0f,1.0f) > mPickupArmor;}
+	bool			DenyPickupAmmo		() {return mLandScape->flrand(0.0f,1.0f) > mPickupAmmo;}
+	bool			DenyPickupWeapon	() {return mLandScape->flrand(0.0f,1.0f) > mPickupWeapon;}
+	bool			DenyPickupEquipment	() {return mLandScape->flrand(0.0f,1.0f) > mPickupEquipment;}
+
+private:
+					
+//	void			PurgeUnlinkedTriggers	( );
+//	void			PurgeTrigger			( CEntity* trigger );
+
+	void			MirrorPos				(vec3_t pos);
+	CGPGroup*		ParseRandom				( CGPGroup* random );
+	bool			ParseOrigin				( CGPGroup* originGroup, vec3_t origin, vec3_t lookat, int* flattenHeight );
+	bool			ParseNodes				( CGPGroup* group );
+	bool			ParsePaths				( CGPGroup *paths);					
+	bool			ParseRivers				( CGPGroup *rivers);
+	void			PlaceBridges			();
+	void			PlaceWallInstance(CRMInstance*	instance, float xpos, float ypos, float zpos, int x, int y, float angle);
+
+
+	bool			ParseDifficulty			( CGPGroup* difficulty );
+	bool			ParseWeapons			( CGPGroup* weapons );
+	bool			ParseAmmo				( CGPGroup* ammo );
+	bool			ParseOutfit				( CGPGroup* outfit );
+	bool			ParseObjectives			( CGPGroup* objectives );
+	bool			ParseInstance			( CGPGroup* instance );
+	bool			ParseInstances			( CGPGroup* instances );
+	bool			ParseInstancesOnPath	( CGPGroup* group );
+	bool			ParseWallRect			( CGPGroup* group, int side);
+
+//	void			SpawnNPCTriggers		( CCMLandScape* landscape );
+//	void			AttachNPCTriggers		( CCMLandScape* landscape );
+};
+
+
+#endif
diff --git a/codemp/RMG/RM_Objective.cpp b/codemp/RMG/RM_Objective.cpp
new file mode 100644
index 0000000..1eb2ec4
--- /dev/null
+++ b/codemp/RMG/RM_Objective.cpp
@@ -0,0 +1,135 @@
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+/************************************************************************************************
+ *
+ * RM_Objective.cpp
+ *
+ * Implements the CRMObjective class.  This class is reponsible for parsing an objective 
+ * from the mission file as well as linking the objective into the world.
+ *
+ ************************************************************************************************/
+
+#include "RM_Headers.h"
+
+/************************************************************************************************
+ * CRMObjective::CRMObjective
+ *	Constructs a random mission objective and fills in the default properties
+ *
+ * inputs:
+ *  none
+ *
+ * return:
+ *	none
+ *
+ ************************************************************************************************/
+CRMObjective::CRMObjective ( CGPGroup* group )
+{	
+	SetPriority(atoi(group->FindPairValue("priority", "0")));
+	SetMessage( group->FindPairValue("message",va("Objective %i Completed", GetPriority()) ) );
+	SetDescription(group->FindPairValue("description",va("Objective %i", GetPriority()) ) );
+	SetInfo(group->FindPairValue("info",va("Info %i", GetPriority()) ) );
+	SetTrigger(group->FindPairValue("trigger",""));
+	SetName(group->GetName());
+	
+/*	const char * soundPath = group->FindPairValue("completed_sound", "" ); 
+	if (soundPath)
+		mCompleteSoundID = G_SoundIndex(soundPath); 
+*/
+
+	mCompleted  = false;
+	mOrderIndex = -1;
+
+	// If no priority was specified for this objective then its active by default.
+	if ( GetPriority ( ) )
+	{
+		mActive	= false;
+	}
+	else
+	{
+		mActive = true;
+	}
+}
+
+/************************************************************************************************
+ * CRMObjective::FindRandomTrigger
+ *	Searches the entitySystem form a random arioche trigger that matches the objective name
+ *
+ * inputs:
+ *  none
+ *
+ * return:
+ *	trigger: a random trigger or NULL if one couldnt be found
+ *
+ ************************************************************************************************/
+/*CTriggerAriocheObjective* CRMObjective::FindRandomTrigger ( )
+{	
+	CEntity*	search;
+	CEntity*	triggers[20];
+	int			numTriggers;
+
+	// Start off the first trigger
+	numTriggers = 0;
+	search      = entitySystem->GetEntityFromClassname ( NULL, "trigger_arioche_objective" );
+
+	// Make a list of triggers
+	while ( numTriggers < 20 && search )
+	{
+		CTriggerAriocheObjective* trigger = (CTriggerAriocheObjective*) search;
+
+		// Move on to the next trigger
+		search = entitySystem->GetEntityFromClassname ( search, "trigger_arioche_objective" );
+
+		// See if this trigger is already in use
+		if ( trigger->GetObjective ( ) )
+		{
+			continue;
+		}
+
+		// If the objective names dont match then ignore this trigger
+		if ( stricmp ( trigger->GetObjectiveName ( ), GetTrigger() ) )
+		{
+			continue;
+		}
+	
+		// Add the trigger to the list
+		triggers[numTriggers++] = trigger;
+	}
+
+	// If no matching triggers then just return NULL
+	if ( 0 == numTriggers )
+	{
+		return NULL;
+	}
+
+	// Return a random choice from the trigger list
+	return (CTriggerAriocheObjective*)triggers[TheRandomMissionManager->GetLandScape()->irand(0,numTriggers-1)];
+}
+*/
+/************************************************************************************************
+ * CRMObjective::Link
+ *	Links the objective into the world using the current state of the world to determine
+ *  where it should link
+ *
+ * inputs:
+ *  none
+ *
+ * return:
+ *	true: objective successfully linked
+ *  false: objective failed to link
+ *
+ ************************************************************************************************/
+bool CRMObjective::Link ( )
+{
+/*	CTriggerAriocheObjective* trigger;
+
+	// Look for a random trigger to associate this objective to.
+	trigger = FindRandomTrigger ( );
+	if ( NULL != trigger )
+	{
+		trigger->SetObjective ( this );
+	}
+*/	
+	return true;
+}
+
diff --git a/codemp/RMG/RM_Objective.h b/codemp/RMG/RM_Objective.h
new file mode 100644
index 0000000..96368a9
--- /dev/null
+++ b/codemp/RMG/RM_Objective.h
@@ -0,0 +1,65 @@
+#pragma once
+#if !defined(RM_OBJECTIVE_H_INC)
+#define RM_OBJECTIVE_H_INC
+
+#ifdef DEBUG_LINKING
+	#pragma message("...including RM_Objective.h")
+#endif
+
+class CRMObjective
+{
+protected:
+
+	bool		mCompleted;		// Is objective completed?
+	bool		mActive;		// set to false if the objective requires another objective to be met first
+	int			mPriority;		// sequence in which objectives need to be completed
+	int			mOrderIndex;	// objective index in ui
+	int			mCompleteSoundID; // sound for when objective is finished
+	string		mMessage;		// message outputed when objective is completed
+	string		mDescription;	// description of objective
+	string		mInfo;			// more info for objective
+	string		mName;			// name of objective
+	string		mTrigger;		// trigger associated with objective
+
+public:
+	
+	CRMObjective(CGPGroup *group);
+	~CRMObjective(void) {}
+
+	bool			Link			(void);
+
+	bool			IsCompleted		(void) const { return mCompleted; }
+	bool			IsActive		(void) const { return mActive; }
+
+	void			Activate		(void)		 { mActive = true; }
+	void			Complete		(bool comp)  { mCompleted = comp;}
+
+	// Get methods
+	int				GetPriority(void){return mPriority;}
+	int				GetOrderIndex(void) { return mOrderIndex; }
+	const char*		GetMessage(void) { return mMessage.c_str(); }
+	const char*		GetDescription(void) { return mDescription.c_str(); }
+	const char*		GetInfo(void) { return mInfo.c_str(); }
+	const char*		GetName(void) { return mName.c_str(); }
+	const char*		GetTrigger(void) { return mTrigger.c_str(); }
+	int				CompleteSoundID() { return mCompleteSoundID; };
+
+	// Set methods
+	void			SetPriority(int priority){mPriority = priority;}
+	void			SetOrderIndex(int order) { mOrderIndex = order; }
+	void			SetMessage(const char* msg) { mMessage = msg; }
+	void			SetDescription(const char* desc) { mDescription = desc; }
+	void			SetInfo(const char* info) { mInfo = info; }
+	void			SetName(const char* name) { mName = name; }
+	void			SetTrigger(const char* name) { mTrigger = name; }
+
+private:
+
+//	CTriggerAriocheObjective*		FindRandomTrigger		( );
+};
+
+typedef list<CRMObjective *>::iterator	rmObjectiveIter_t;
+typedef list<CRMObjective *>			rmObjectiveList_t;
+
+
+#endif
\ No newline at end of file
diff --git a/codemp/RMG/RM_Path.cpp b/codemp/RMG/RM_Path.cpp
new file mode 100644
index 0000000..5c2da7a
--- /dev/null
+++ b/codemp/RMG/RM_Path.cpp
@@ -0,0 +1,723 @@
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+/************************************************************************************************
+ *
+ *	Copyright (C) 2001-2002 Raven Software
+ *
+ *  RM_Path.cpp
+ *
+ ************************************************************************************************/
+
+#include "RM_Headers.h"
+
+#define max(a,b)    (((a) > (b)) ? (a) : (b))
+
+/************************************************************************************************
+ * CRMNode::CRMNode
+ *	constructor
+ *
+ * inputs:
+ *  none
+ *
+ * return:
+ *	none
+ *
+ ************************************************************************************************/
+CRMNode::CRMNode ( )
+{
+	int i;
+
+	mFlattenHeight = -1;
+
+	mPos[0] = 0;
+	mPos[1] = 0;
+	mPos[2] = 0;
+
+	// no paths
+	for (i = 0; i < DIR_MAX; i++)
+		mPathID[i] = -1;
+
+	mAreaPointPlaced = false;
+}
+
+
+/************************************************************************************************
+ * CRMPathManager::CRMPathManager
+ *	constructor
+ *
+ * inputs:
+ *  none
+ *
+ * return:
+ *	none
+ *
+ ************************************************************************************************/
+CRMPathManager::CRMPathManager ( CRandomTerrain* terrain )
+: mXNodes(0), mYNodes(0), mPathCount(0), mRiverCount(0), mMaxDepth(0), mDepth(0),
+  mPathPoints(10), mPathMinWidth(0.02f), mPathMaxWidth(0.04f), mPathDepth(0.3f), mPathDeviation(0.03f), mPathBreadth(5),
+  mRiverDepth(5), mRiverPoints(10), mRiverMinWidth(0.01f), mRiverMaxWidth(0.02f), mRiverBedDepth(1), mRiverDeviation(0.01f), mRiverBreadth(7),
+  mTerrain(terrain), mCrossed(false)
+{
+}
+
+CRMPathManager::~CRMPathManager ( )
+{
+	int i,j;
+
+	for ( i = mLocations.size() - 1; i >=0; i-- )
+	{
+		if (mLocations[i])
+			delete mLocations[i];
+	}
+	mLocations.clear();
+
+	for ( j = mNodes.size() - 1; j >=0; j-- )
+	{
+		if (mNodes[j])
+			delete mNodes[j];
+	}
+	mNodes.clear();
+}
+
+void CRMPathManager::CreateLocation ( const char* name, const int min_depth, int max_depth, const int min_paths, int max_paths )
+{
+	int i;
+
+	// sanity checks -- dmv
+	if( max_paths < min_paths )
+	{
+		Com_Printf("[CreateLocation()] ERROR : max_paths < min_paths :: set max_paths = min_paths\n" );
+		max_paths = min_paths;
+	}
+	if( max_depth < min_depth )
+	{
+		Com_Printf("[CreateLocation()] ERROR : max_depth < min_depth :: set max_depth = min_depth\n" );
+		max_depth = min_depth;
+	}
+
+	for (i = mLocations.size()-1; i>=0; --i)
+		if ( !stricmp ( name, mLocations[i]->GetName ( ) ) )
+		{
+			mLocations[i]->SetMinDepth(min_depth);
+			mLocations[i]->SetMaxDepth(max_depth);
+			mLocations[i]->SetMinPaths(min_paths);
+			mLocations[i]->SetMaxPaths(max_paths);
+			return;
+		}
+
+	CRMLoc* pLoc= new CRMLoc(name, min_depth, max_depth, min_paths, max_paths); 
+	mLocations.push_back(pLoc); 
+	mMaxDepth =  max(mMaxDepth, max_depth);
+}
+
+void CRMPathManager::ClearCells(int x_nodes, int y_nodes)
+{
+	int x,y;
+
+	// clear cell array - used for generating paths
+	CRMCell empty;
+	for (x=0; x < x_nodes * y_nodes; x++)
+	{
+		if (x >= mCells.size())
+			mCells.push_back(empty);
+		else
+			mCells[x] = empty;
+	}
+
+	// set borders of world
+	for (y = 0; y < y_nodes; y++)
+	{
+		mCells[y * x_nodes].SetBorder(DIR_W );
+		mCells[y * x_nodes].SetBorder(DIR_SW );
+		mCells[y * x_nodes].SetBorder(DIR_NW );
+		mCells[y * x_nodes + x_nodes-1].SetBorder( DIR_E );
+		mCells[y * x_nodes + x_nodes-1].SetBorder( DIR_NE );
+		mCells[y * x_nodes + x_nodes-1].SetBorder( DIR_SE );
+	}
+
+	for (x = 0; x < x_nodes; x++)
+	{
+		mCells[x].SetBorder( DIR_N );
+		mCells[x].SetBorder( DIR_NE );
+		mCells[x].SetBorder( DIR_NW );
+		mCells[(y_nodes-1) * x_nodes + x].SetBorder( DIR_S );
+		mCells[(y_nodes-1) * x_nodes + x].SetBorder( DIR_SE );
+		mCells[(y_nodes-1) * x_nodes + x].SetBorder( DIR_SW );
+	}
+}
+
+/************************************************************************************************
+ * CRMPathManager::CreateArray
+ *	Create array of nodes that are spaced over the landscape.
+ *	Create array of cells, which is used to determine how nodes are connected.
+ *
+ * inputs:
+ *  x_nodes, y_nodes - how many nodes in each dimension to layout
+ *
+ * return:
+ *	true if the node array was created, false if we have a problem
+ *
+ ************************************************************************************************/
+bool CRMPathManager::CreateArray(const int x_nodes, const int y_nodes)
+{
+	mXNodes = x_nodes;
+	mYNodes = y_nodes;
+
+	// fill node array with positions that are spaced over the landscape
+	int x,y;
+
+	// dump existing nodes
+	for ( x = mNodes.size() - 1; x >=0; x-- )
+	{
+		if (mNodes[x])
+			delete mNodes[x];
+	}
+	mNodes.clear();
+	mNodes.resize(mXNodes * mYNodes, NULL);
+
+	// add a small amount of random jitter to spots chosen
+	float x_rnd = 0.2f / (mXNodes+1);
+	float y_rnd = 0.2f / (mYNodes+1);
+
+	for (x = 0; x < mXNodes; x++)
+	{
+		float cell_x = (x + 1.0f) / (mXNodes+1);
+//		float cell_x = (x + 2.0f) / (mXNodes+3);
+
+		for (y = 0; y < mYNodes; y++)
+		{
+			vec3_t pos;
+			CRMNode * pnode = new CRMNode();
+			mNodes[x + y*mXNodes] = pnode;
+
+			float cell_y = (y + 1.0f) / (mYNodes+1);
+//			float cell_y = (y + 2.0f) / (mYNodes+3);
+
+			pos[0] = TheRandomMissionManager->GetLandScape()->flrand(cell_x - x_rnd, cell_x + x_rnd);
+			pos[1] = TheRandomMissionManager->GetLandScape()->flrand(cell_y - y_rnd, cell_y + y_rnd);
+			pos[2] = 0;
+			 
+			SetNodePos(x, y, pos);
+		}
+	}
+
+	ClearCells(mXNodes, mYNodes);
+
+	return true;
+}
+
+// neighbor offsets - easy way to turn a direction into the array position for a neighboring cell or node
+int CRMPathManager::neighbor_x[DIR_MAX] = { 0, 1, 1, 1, 0,-1,-1,-1};
+int CRMPathManager::neighbor_y[DIR_MAX] = {-1,-1, 0, 1, 1, 1, 0,-1};
+
+/************************************************************************************************
+ * CRMPathManager::PlaceLocation
+ * This method is used to determine if a named location should be placed at this node.
+ *
+ * inputs:
+ *  c_x, c_y - cell to examine
+ *
+ * return:
+ *	none
+ *
+ ************************************************************************************************/
+void CRMPathManager::PlaceLocation(const int c_x, const int c_y)
+{
+	if ( !Node(c_x,c_y)->IsLocation() )
+	{	// not currently a location
+
+		// how many paths lead to this cell?
+		int count_paths = 0;
+		int i;
+
+		for (i = 0; i<DIR_MAX; i++)
+			if (Node(c_x,c_y)->PathExist(i))
+				count_paths++;
+
+		int deepest_depth = -1;
+		int deepest_loc = -1;
+		for (i = mLocations.size()-1; i>=0; --i)
+		{
+			if (!mLocations[i]->Placed() &&					// node has not been placed
+				 mLocations[i]->MinDepth() <= mDepth &&		// our current depth is in the proper range
+				 mLocations[i]->MaxDepth() >= mDepth &&
+				 mLocations[i]->MinPaths() <= count_paths && // our path count is in the proper range
+				 mLocations[i]->MaxPaths() >= count_paths &&
+				 mLocations[i]->MaxDepth() > deepest_depth)	// and this is the deepest location of the ones that match
+			{
+				deepest_loc = i;
+				deepest_depth = mLocations[i]->MaxDepth();
+			}
+		}
+
+		if (deepest_loc >= 0 && deepest_loc < mLocations.size())
+		{	// found a location to place at this node / cell
+			const char * name = mLocations[deepest_loc]->GetName();
+			Node(c_x,c_y)->SetName(name);
+			mLocations[deepest_loc]->SetPlaced(true);
+
+			// need a new max depth
+			int max_depth = -1;
+			for (i = mLocations.size()-1; i>=0; --i)
+			{
+				// figure out new max depth based on the max depth of unplaced locations
+				if (!mLocations[i]->Placed() &&	   			// node has not been placed
+					 mLocations[i]->MaxDepth() > max_depth)	// and this is the deepest 
+				{
+					max_depth = mLocations[i]->MaxDepth();
+				}
+			}
+			mMaxDepth = max_depth;
+		}
+	}
+}
+
+/************************************************************************************************
+ * CRMPathManager::PathVisit
+ * This method is called recursively to create a network of nodes connected with paths.
+ *
+ * inputs:
+ *  c_x, c_y - cell to visit
+ *
+ * return:
+ *	none
+ *
+ ************************************************************************************************/
+void CRMPathManager::PathVisit(const int c_x, const int c_y)
+{
+	// does this cell have any neighbors with all walls intact?
+	int i,off;
+	
+	// look at neighbors in random order
+	off = TheRandomMissionManager->GetLandScape()->irand(DIR_FIRST, DIR_MAX-1);
+
+	++mDepth;	// track our depth of recursion
+
+	for (i = DIR_FIRST; i<DIR_MAX && mDepth <= mMaxDepth; i++)
+	{
+		int d = (i + off) % DIR_MAX;
+		if ( !Cell(c_x, c_y).Border(d) )
+		{	// we can move this way, since no border
+			int new_c_x = c_x + neighbor_x[d];
+			int new_c_y = c_y + neighbor_y[d];
+			if (Cell(new_c_x,new_c_y).Wall() == DIR_ALL)
+			{	// we have a new cell that has not been visited!
+				int new_dir;
+				// d is the direction relative to the current cell
+				// new_dir is the direction relative to the next cell (N becomes S, NE becomes SW, etc...)
+				if( d < HALF_DIR_MAX )
+				{
+					new_dir = d + HALF_DIR_MAX;
+				}
+				else
+				{
+					new_dir = d - HALF_DIR_MAX;
+				}
+	
+				// knock down walls
+				Cell(c_x,c_y).RemoveWall(d);
+				Cell(new_c_x,new_c_y).RemoveWall(new_dir); //DIR_MAX - d);
+
+				// set path id
+				Node(c_x, c_y)->SetPath(d, mPathCount);
+				Node(new_c_x, new_c_y)->SetPath(new_dir, mPathCount); //DIR_MAX - d, mPathCount);
+
+				// create path between cells
+				mTerrain->CreatePath( mPathCount++,
+									-1,
+									0,
+									mPathPoints,
+									GetNodePos(c_x,c_y)[0],
+									GetNodePos(c_x,c_y)[1],
+									GetNodePos(new_c_x,new_c_y)[0],
+									GetNodePos(new_c_x,new_c_y)[1],
+									mPathMinWidth,
+									mPathMaxWidth,
+									mPathDepth,
+									mPathDeviation,
+									mPathBreadth );
+
+				// flatten a small spot
+				CArea		area;
+				float flat_radius = mPathMaxWidth * 
+					fabs(TheRandomMissionManager->GetLandScape()->GetBounds()[1][0] - TheRandomMissionManager->GetLandScape()->GetBounds()[0][0]);
+				area.Init( GetNodePos(c_x,c_y), flat_radius, 0.0f, AT_NONE, 0, 0 );
+				TheRandomMissionManager->GetLandScape()->FlattenArea(&area, 255 * mPathDepth, false, true, true );
+
+				// recurse
+				PathVisit(new_c_x, new_c_y);
+			}
+		}
+	}
+	
+	--mDepth;
+
+	// NOTE: *whoop* hack alert, the first time this is reached, it should be the very last placed node.
+	if( !mCrossed && TheRandomMissionManager->GetMission()->GetSymmetric() &&
+		TheRandomMissionManager->GetMission()->GetBackUpPath() )
+	{	
+		mCrossed = true; 
+	
+		int directionSet[3][3] = {DIR_NW,DIR_W,DIR_SW,DIR_N,-1,DIR_S,DIR_NE,DIR_E,DIR_SE};
+		int	ncx	= (mXNodes-1)-c_x;
+		int	ncy	= (mYNodes-1)-c_y;
+
+		int x_delta = ncx - c_x;
+		int y_delta = ncy - c_y;
+
+		if( x_delta < -1 )
+		{
+			x_delta = -1;
+		}
+		else if( x_delta > 1 )
+		{
+			x_delta = 1;
+		}
+
+		if( y_delta < -1 )
+		{
+			y_delta = -1;
+		}
+		else if( y_delta > 1 )
+		{
+			y_delta = 1;
+		}
+		
+		// make sure the mirror is actually in a different position than then un-mirrored node
+		if( x_delta || y_delta )
+		{
+
+			int d = directionSet[x_delta][y_delta];
+			int new_dir;
+			// d is the direction relative to the current cell
+			// new_dir is the direction relative to the next cell (N becomes S, NE becomes SW, etc...)
+			if( d < HALF_DIR_MAX )
+			{
+				new_dir = d + HALF_DIR_MAX;
+			}
+			else
+			{
+				new_dir = d - HALF_DIR_MAX;
+			}
+
+			//NOTE: Knocking down these walls will cause instances to be created on this new artificial path
+			// Since this path could span more than just the normal 1 cell, these walls being knocked down are not exactly correct... but get the job done
+
+			// knock down walls
+			Cell(c_x,c_y).RemoveWall(d);
+			Cell(ncx,ncy).RemoveWall(new_dir); //DIR_MAX - d);
+
+			// set path id
+			Node(c_x, c_y)->SetPath(d, mPathCount);
+			Node(ncx, ncy)->SetPath(new_dir, mPathCount); //DIR_MAX - d, mPathCount);
+		
+			// create an artificial path that crosses over to connect the symmetric and non-symmetric map parts
+			mTerrain->CreatePath( mPathCount++,
+								-1,
+								0,
+								mPathPoints,
+								GetNodePos(c_x,c_y)[0],
+								GetNodePos(c_x,c_y)[1],
+								GetNodePos(ncx,ncy)[0],
+								GetNodePos(ncx,ncy)[1],
+								mPathMinWidth,
+								mPathMaxWidth,
+								mPathDepth,
+								mPathDeviation,
+								mPathBreadth );
+		
+		}
+	}
+
+	PlaceLocation(c_x, c_y);
+}
+
+
+/************************************************************************************************
+ * CRMPathManager::FindNodeByName
+ *	Finds the managed node with the matching case-insensivity name
+ *
+ * inputs:
+ *  name - name of the node to find
+ *
+ * return:
+ *	a pointer to the found node or NULL if the node couldn't be found
+ *
+ ************************************************************************************************/
+CRMNode* CRMPathManager::FindNodeByName ( const char* name )
+{
+	int		 j;
+
+	for ( j = mNodes.size() - 1; j >=0; j-- )
+	{
+		if ( !stricmp ( name, mNodes[j]->GetName ( ) ) )
+			return mNodes[j];
+	}
+	return NULL;
+}
+
+
+/************************************************************************************************
+ * CRMPathManager::SetPathStyle
+ *	sets style for all paths
+ *
+ * inputs:
+ *  settings for paths that are created
+ *
+ * return:
+ *	none
+ *
+ ************************************************************************************************/
+void CRMPathManager::SetPathStyle ( 
+	const int	points,
+	const float	minwidth,
+	const float	maxwidth,
+	const float	depth,
+	const float	deviation,
+	const float	breadth
+	)
+{
+	// save path style
+	mPathPoints   = points  ;
+	mPathMinWidth = minwidth;
+	mPathMaxWidth = maxwidth;
+	mPathDepth    = depth   ;
+	mPathDeviation= deviation;
+	mPathBreadth  = breadth ;
+}
+
+/************************************************************************************************
+ * CRMPathManager::SetRiverStyle
+ *	sets style for all rivers
+ *
+ * inputs:
+ *  settings for river paths that are created
+ *
+ * return:
+ *	none
+ *
+ ************************************************************************************************/
+void CRMPathManager::SetRiverStyle (const int   depth,
+									const int	points,
+									const float minwidth,
+									const float maxwidth,
+									const float beddepth, 
+									const float deviation, 
+									const float breadth,
+									string bridge_name)
+{
+	// save river style
+	mRiverDepth    = depth;
+	mRiverPoints   = points  ;
+	mRiverMinWidth = minwidth;
+	mRiverMaxWidth = maxwidth;
+	mRiverBedDepth = beddepth   ;
+	mRiverDeviation= deviation;
+	mRiverBreadth  = breadth ;
+	mRiverBridge   = bridge_name;
+}
+
+vec3_t&	CRMPathManager::GetRiverPos( const int x, const int y ) 
+{ 
+	mRiverPos[0] = (float)(x + 1.0f) / (float)(mXNodes+2);
+	mRiverPos[1] = (float)(y + 1.0f) / (float)(mYNodes+2);
+	return mRiverPos; 
+}
+
+void CRMPathManager::RiverVisit(const int c_x, const int c_y)
+{
+	// does this cell have any neighbors with all walls intact?
+	int i,off;
+
+	// look at neighbors in random order
+	off = TheRandomMissionManager->GetLandScape()->irand(DIR_FIRST, DIR_MAX-1);
+
+	++mDepth;	// track our depth of recursion
+
+	for (i = DIR_FIRST; i<DIR_MAX && mDepth <= mMaxDepth; i+=2)
+	{
+		int d = (i + off) % DIR_MAX;
+		if ( !Cell(c_x, c_y).Border(d) )
+		{	// we can move this way, since no border
+			int new_c_x = c_x + neighbor_x[d];
+			int new_c_y = c_y + neighbor_y[d];
+			if (RiverCell(new_c_x,new_c_y).Wall() == DIR_ALL)
+			{	// we have a new cell that has not been visited!
+
+				int new_dir;
+				// d is the direction relative to the current cell
+				// new_dir is the direction relative to the next cell (N becomes S, NE becomes SW, etc...)
+				if( d < HALF_DIR_MAX )
+				{
+					new_dir = d + HALF_DIR_MAX;
+				}
+				else
+				{
+					new_dir = d - HALF_DIR_MAX;
+				}
+				// knock down walls
+				RiverCell(c_x,c_y).RemoveWall(d);
+				RiverCell(new_c_x,new_c_y).RemoveWall(new_dir); //DIR_MAX - d);
+
+				// create river between cells
+				mTerrain->CreatePath ( mPathCount++,
+									-1,
+									0,
+									mRiverPoints,
+									GetRiverPos(c_x,c_y)[0],
+									GetRiverPos(c_x,c_y)[1],
+									GetRiverPos(new_c_x,new_c_y)[0],
+									GetRiverPos(new_c_x,new_c_y)[1],
+									mRiverMinWidth,
+									mRiverMaxWidth,
+									mRiverBedDepth,
+									mRiverDeviation,
+									mRiverBreadth );
+
+				// flatten a small spot
+				CArea		area;
+				float flat_radius = mRiverMinWidth * 
+					fabs(TheRandomMissionManager->GetLandScape()->GetBounds()[1][0] - TheRandomMissionManager->GetLandScape()->GetBounds()[0][0]);
+				area.Init( GetRiverPos(c_x,c_y), flat_radius, 0.0f, AT_NONE, 0, 0 );
+				TheRandomMissionManager->GetLandScape()->FlattenArea (&area, 255 * mRiverBedDepth, false, true, true );
+
+				// recurse
+				RiverVisit(new_c_x, new_c_y);
+			}
+		}
+	}
+	
+//	--mDepth;
+}
+
+/************************************************************************************************
+ * CRMPathManager::GenerateRivers
+ *	Creates a river which intersects the main path
+ *
+ * inputs:
+ *  none
+ *
+ * return:
+ *	none
+ *
+ ************************************************************************************************/
+void CRMPathManager::GenerateRivers ()
+{
+	if (mRiverBedDepth == 1)
+		// no rivers
+		return;
+
+	mMaxDepth = mRiverDepth;
+	mDepth = 0;
+
+	int cell_x = 0;
+	int cell_y = 0;
+
+	// choose starting cell along an edge
+	int edge = TheRandomMissionManager->GetLandScape()->irand(0, 7);
+	switch ( edge )
+	{
+		case 0:
+			cell_x = mXNodes / 2; cell_y = 0;
+			break;
+		case 1:
+			cell_x = mXNodes; cell_y = 0;
+			break;
+		case 2:
+			cell_x = mXNodes; cell_y = mYNodes / 2;
+			break;
+		case 3:
+			cell_x = mXNodes; cell_y = mYNodes;
+			break;
+		case 4:
+			cell_x = mXNodes / 2; cell_y = mYNodes;
+			break;
+		case 5:
+			cell_x = 0; cell_y = mYNodes;
+			break;
+		case 6:
+			cell_x = 0; cell_y = mYNodes / 2;
+			break;
+		case 7:
+			cell_x = 0; cell_y = 0;
+			break;
+	}
+
+	ClearCells(mXNodes+1, mYNodes+1);
+
+	mRiverCount = mPathCount;
+
+	// visit the first cell
+	RiverVisit(cell_x,cell_y);
+
+	mRiverCount = mPathCount - mRiverCount;
+
+	return;
+}
+
+/************************************************************************************************
+ * CRMPathManager::GeneratePaths
+ *	Creates all paths 
+ *
+ * inputs:
+ *  none
+ *
+ * return:
+ *	none
+ *
+ ************************************************************************************************/
+void CRMPathManager::GeneratePaths ( symmetry_t symmetric )
+{
+	int cell_x = 0;
+	int cell_y = 0;
+
+	switch ( symmetric )
+	{
+		case SYMMETRY_TOPLEFT:
+			cell_x = mXNodes-1;
+			cell_y = 0;
+			break;
+
+		case SYMMETRY_BOTTOMRIGHT:
+			cell_x = 0;
+			cell_y = mYNodes-1;
+			break;
+
+		default:
+		case SYMMETRY_NONE:
+			// choose starting cell along an edge
+			switch ( TheRandomMissionManager->GetLandScape()->irand(0, 7) )
+			{
+				case 0:
+					cell_x = mXNodes / 2;
+					break;
+				case 1:
+					cell_x = mXNodes-1;
+					break;
+				case 2:
+					cell_x = mXNodes-1; cell_y = mYNodes / 2;
+					break;
+				case 3:
+					cell_x = mXNodes-1; cell_y = mYNodes-1;
+					break;
+				case 4:
+					cell_x = mXNodes / 2; cell_y = mYNodes-1;
+					break;
+				case 5:
+					cell_y = mYNodes-1;
+					break;
+				case 6:
+					cell_y = mYNodes / 2;
+					break;
+				default:
+				case 7:
+					break;
+			}
+			break;
+	}
+
+	// visit the first cell
+	PathVisit(cell_x,cell_y);
+}
+
diff --git a/codemp/RMG/RM_Path.h b/codemp/RMG/RM_Path.h
new file mode 100644
index 0000000..cb7ed4e
--- /dev/null
+++ b/codemp/RMG/RM_Path.h
@@ -0,0 +1,223 @@
+/************************************************************************************************
+ *
+ *	Copyright (C) 2001-2002 Raven Software
+ *
+ *  RM_Path.h
+ *
+ ************************************************************************************************/
+
+#pragma once
+#if !defined(RM_PATH_H_INC)
+#define RM_PATH_H_INC
+
+#ifdef DEBUG_LINKING
+	#pragma message("...including RM_Path.h")
+#endif
+
+#if !defined(CM_RANDOMTERRAIN_H_INC)
+#include "../qcommon/cm_randomterrain.h"
+#endif
+
+class CRMPathManager;
+
+// directions you can proceed from cells 
+enum ERMDir
+{
+	DIR_FIRST= 0,
+	DIR_N	= 0,
+	DIR_NE,
+	DIR_E ,
+	DIR_SE,
+	DIR_S ,
+	DIR_SW,
+	DIR_W ,
+	DIR_NW,
+	DIR_MAX,
+	DIR_ALL = 255
+};
+
+#define	HALF_DIR_MAX (DIR_MAX/2)
+
+class CRMNode
+{
+private:
+
+	string			mName;					// name of node - "" if not used yet
+	vec3_t			mPos;					// where node is
+	int				mPathID[DIR_MAX]; 		// path id's that lead from this node
+	bool			mAreaPointPlaced;		// false if no area point here yet.
+
+	int				mFlattenHeight;
+
+public:
+
+	CRMNode ( );
+
+	bool		IsLocation() {return strlen(mName.c_str())>0;};
+	const char*	GetName	 ( ) { return mName.c_str(); }
+	vec3_t&		GetPos	 ( ) { return mPos; }
+	const float PathExist( const int dir) { return (mPathID[dir % DIR_MAX] != -1); };
+	const float GetPath  ( const int dir) { return mPathID[dir % DIR_MAX]; };
+	bool		AreaPoint() {return mAreaPointPlaced;};
+
+	void		SetName ( const char* name ) { mName = name; }
+	void		SetPos ( const vec3_t& v ) { VectorCopy ( v, mPos ); }
+	void		SetPath( const int dir, const int id) { mPathID[dir % DIR_MAX] = id; };
+	void		SetAreaPoint(bool ap) {mAreaPointPlaced = ap;};
+
+	void		SetFlattenHeight(int flattenHeight) {mFlattenHeight = flattenHeight; }
+	int			GetFlattenHeight() {return mFlattenHeight; }
+};
+
+typedef vector<CRMNode*>	 	rmNodeVector_t;
+
+// named spots on the map, should be placed into nodes
+class CRMLoc
+{
+private:
+
+	string			mName;		// name of location
+	int				mMinDepth;
+	int				mMaxDepth;
+	int				mMinPaths;
+	int				mMaxPaths;
+	bool			mPlaced;	// location has been placed at a node
+
+public:
+	CRMLoc (const char *name, const int min_depth, const int max_depth, const int min_paths =1, const int max_paths=1 ) 
+		: mMinDepth(min_depth), mMaxDepth(max_depth), mPlaced(false), mMinPaths(min_paths), mMaxPaths(max_paths)
+	{ mName = name; };
+
+	const char*	GetName	 ( ) { return mName.c_str(); }
+	void		SetName ( const char* name ) { mName = name; }
+	
+	int			MinDepth() {return mMinDepth;};
+	void		SetMinDepth(const int deep) {mMinDepth = deep;};
+
+	int			MaxDepth() {return mMaxDepth;};
+	void		SetMaxDepth(const int deep) {mMaxDepth = deep;};
+	
+	int			MinPaths() {return mMinPaths;};
+	void		SetMinPaths(const int paths) {mMinPaths = paths;};
+
+	int			MaxPaths() {return mMaxPaths;};
+	void		SetMaxPaths(const int paths) {mMaxPaths = paths;};
+	
+	bool		Placed() { return mPlaced; };
+	void		SetPlaced(bool p) { mPlaced = p;};
+};
+
+typedef vector<CRMLoc*> 	rmLocVector_t;
+
+
+// cells are used for figuring out node connections / paths
+struct CRMCell
+{
+private:
+	int		border;
+	int		wall;
+
+public:
+	CRMCell() { border = 0; wall = DIR_ALL; };
+
+	int		Border() {return border;};
+	int		Wall() {return wall;};
+	bool	Border(const int dir) { return (border & (1<<dir))!=0; };
+	bool	Wall(const int dir) { return (wall & (1<<dir))!=0; };
+	void	SetBorder(const int dir) { border |= (1<<dir); };
+	void	SetWall(const int dir) { wall |= (1<<dir); };
+	void	RemoveWall(const int dir) { wall &= ~(1<<dir); };
+};
+
+typedef vector<CRMCell>			rmCellVector_t;
+
+
+class CRMPathManager
+{
+public:
+	int				mXNodes;	// number of nodes in the x dimension
+	int				mYNodes;	// number of nodes in the y dimension
+
+private:
+	rmLocVector_t	mLocations; // location, named spots to be placed at nodes
+	rmNodeVector_t	mNodes;		// nodes, spots on map that *may* be connected by paths
+	rmCellVector_t	mCells;		// array of cells for doing path generation
+
+	int				mPathCount;
+	int				mRiverCount;
+	int				mMaxDepth;	// deepest any location wants to be
+	int				mDepth;		// current depth
+
+	bool			mCrossed;  // used to indicate if paths crossed the imaginary diagonal that cuts symmetric maps in half
+
+	// path style
+	int				mPathPoints;
+	float			mPathMinWidth;
+	float			mPathMaxWidth;
+	float			mPathDepth;
+	float			mPathDeviation;
+	float			mPathBreadth;
+
+	// river style
+	int				mRiverDepth;
+	int				mRiverPoints;
+	float			mRiverMinWidth;
+	float			mRiverMaxWidth;
+	float			mRiverBedDepth;
+	float			mRiverDeviation;
+	float			mRiverBreadth;
+	string			mRiverBridge;
+	vec3_t			mRiverPos;
+
+	static int neighbor_x[DIR_MAX];
+	static int neighbor_y[DIR_MAX];
+
+	CRandomTerrain*	mTerrain;
+
+public:
+	CRMPathManager ( CRandomTerrain* terrain );
+	~CRMPathManager ( );
+
+	void		ClearCells		(int x_nodes, int y_nodes);
+	bool		CreateArray		( const int x_nodes, const int y_nodes );
+
+	CRMNode*	FindNodeByName	( const char* name );
+	CRMNode*	Node			( const int x, const int y ) {return mNodes[x + y*mXNodes];};
+
+	void		CreateLocation	( const char* name, const int min_depth, int max_depth, const int min_paths =1, int max_paths =1 );
+
+	vec3_t&		GetNodePos		( const int x, const int y ) { return mNodes[x + y*mXNodes]->GetPos(); };
+	void		SetNodePos		( const int x, const int y, const vec3_t& pos) { mNodes[x + y*mXNodes]->SetPos(pos); };
+	int			GetPathCount	() {return mPathCount;};
+	int			GetRiverCount	() {return mRiverCount;};
+	float		GetRiverDepth	() {return mRiverBedDepth;};
+	float		GetPathDepth	() {return mPathDepth;};
+	const char *GetBridgeName	() {return 	mRiverBridge.c_str();};
+	vec3_t&		GetRiverPos		( const int x, const int y );
+
+	CRMCell&	Cell			( const int x, const int y ) {return mCells[x + y*mXNodes];};
+	CRMCell&	RiverCell  		( const int x, const int y ) {return mCells[x + y*(mXNodes+1)];};
+	void		PlaceLocation	( const int x, const int y );
+	void		PathVisit		( const int x, const int y );
+	void		RiverVisit		( const int x, const int y );
+	void		SetPathStyle	( const int	points = 10,
+								  const float minwidth = 0.01f, 
+								  const float maxwidth = 0.05f,	
+								  const float depth = 0.3f, 
+								  const float deviation = 0.2f, 
+								  const float breadth = 5);
+
+	void		SetRiverStyle	( const int depth = 5,
+								  const int	points = 10,
+								  const	float minwidth = 0.01,
+								  const	float maxwidth = 0.03,
+								  const float beddepth = 0.0f, 
+								  const float deviation = 0.25f, 
+								  const float breadth = 7,
+								  string bridge_name = "");
+
+	void		GeneratePaths	( symmetry_t symmetric = SYMMETRY_NONE );
+	void		GenerateRivers  ( );
+};
+
+#endif
\ No newline at end of file
diff --git a/codemp/RMG/RM_Terrain.cpp b/codemp/RMG/RM_Terrain.cpp
new file mode 100644
index 0000000..a00c70c
--- /dev/null
+++ b/codemp/RMG/RM_Terrain.cpp
@@ -0,0 +1,517 @@
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+#include "../qcommon/cm_local.h"
+#include "../cgame/tr_types.h"
+#include "RM_Headers.h"
+
+//#include "../qcommon/q_imath.h"
+
+#pragma optimize("", off)
+
+void R_LoadDataImage	( const char *name, byte **pic, int *width, int *height);
+void R_InvertImage		( byte *data, int width, int height, int depth);
+void R_Resample			( byte *source, int swidth, int sheight, byte *dest, int dwidth, int dheight, int components);
+void RE_GetModelBounds	(refEntity_t *refEnt, vec3_t bounds1, vec3_t bounds2);
+
+static CRMLandScape		*rm_landscape;
+static CCMLandScape		*origin_land;
+
+CRMLandScape::CRMLandScape(void)
+{
+	common = NULL;
+	mDensityMap = NULL;
+}
+
+CRMLandScape::~CRMLandScape(void)
+{
+	if(mDensityMap)
+	{
+		Z_Free(mDensityMap);
+		mDensityMap = NULL;
+	}
+}
+
+void CCGHeightDetails::AddModel(const CRandomModel *hd)
+{
+	if(mNumModels < MAX_RANDOM_MODELS)
+	{
+		mTotalFrequency += hd->GetFrequency();
+		mModels[mNumModels++] = *hd;
+	}
+}
+
+void CRMLandScape::AddModel(const int height, int maxheight, const CRandomModel *hd)
+{
+	int		i;
+
+	if(maxheight > HEIGHT_RESOLUTION)
+	{
+		maxheight = HEIGHT_RESOLUTION;
+	}
+
+	for(i = height; hd->GetModel() && (i < maxheight); i++)
+	{
+		mHeightDetails[i].AddModel(hd);
+	}
+}
+
+void CRMLandScape::LoadMiscentDef(const char *td)
+{
+	char				miscentDef[MAX_QPATH];
+	CGenericParser2		parse;
+	CGPGroup			*basegroup, *classes, *items, *model;
+	CGPValue			*pair;
+
+	Com_sprintf(miscentDef, MAX_QPATH, "ext_data/RMG/%s.miscents", Info_ValueForKey(td, "miscentDef"));
+	Com_DPrintf("CG_Terrain: Loading and parsing miscentDef %s.....\n", Info_ValueForKey(td, "miscentDef"));
+
+	if(!Com_ParseTextFile(miscentDef, parse))
+	{
+		Com_sprintf(miscentDef, MAX_QPATH, "ext_data/arioche/%s.miscents", Info_ValueForKey(td, "miscentDef"));
+		if(!Com_ParseTextFile(miscentDef, parse))
+		{
+			Com_Printf("Could not open %s\n", miscentDef);
+			return;
+		}
+	}
+	// The whole file....
+	basegroup = parse.GetBaseParseGroup();
+
+	// The root { } struct
+	classes = basegroup->GetSubGroups();
+	while(classes)
+	{
+		items = classes->GetSubGroups();
+		while(items)
+		{
+			if(!stricmp(items->GetName(), "miscent"))
+			{
+				int			height, maxheight;
+
+				// Height must exist - the rest are optional
+				height = atol(items->FindPairValue("height", "0"));
+				maxheight = atol(items->FindPairValue("maxheight", "255"));
+
+				model = items->GetSubGroups();
+				while(model)
+				{
+					if(!stricmp(model->GetName(), "model"))
+					{
+						CRandomModel	hd;
+
+						// Set defaults
+						hd.SetModel("");
+						hd.SetFrequency(1.0f);
+						hd.SetMinScale(1.0f);
+						hd.SetMaxScale(1.0f);
+
+						pair = model->GetPairs();
+						while(pair)
+						{
+							if(!stricmp(pair->GetName(), "name"))
+							{
+								hd.SetModel(pair->GetTopValue());
+							}
+							else if(!stricmp(pair->GetName(), "frequency"))
+							{
+								hd.SetFrequency((float)atof(pair->GetTopValue()));
+							}
+							else if(!stricmp(pair->GetName(), "minscale"))
+							{
+								hd.SetMinScale((float)atof(pair->GetTopValue()));
+							}
+							else if(!stricmp(pair->GetName(), "maxscale"))
+							{
+								hd.SetMaxScale((float)atof(pair->GetTopValue()));
+							}
+							pair = (CGPValue *)pair->GetNext();
+						}
+						AddModel(height, maxheight, &hd);
+					}
+ 					model = (CGPGroup *)model->GetNext();
+				}
+			}
+			items = (CGPGroup *)items->GetNext();
+		}
+		classes = (CGPGroup *)classes->GetNext();
+	}
+	Com_ParseTextFileDestroy(parse);
+}
+
+void CG_Decrease(byte *work, float lerp, int *info)
+{
+	int		val;
+
+	val = *work - origin_land->irand(2, 5);
+	*work = (byte)Com_Clampi(1, 255, val);
+}
+
+void CRMLandScape::CreateRandomDensityMap(byte *density, int width, int height, int seed)
+{
+//	int			i, border, inc;
+	int			x, y, count;
+//	byte		*work, *work2;
+	CArea		*area;
+	vec3_t		derxelSize, pos;
+	ivec3_t		dmappos;
+	byte		*hm_map = common->GetHeightMap();
+	int			hm_width = common->GetRealWidth();
+	int			hm_height = common->GetRealHeight();
+	int			xpos, ypos, dx, dy;
+	byte		*densityPos = density;
+	bool		foundUneven;
+
+	// Init to linear spread
+	memset(density, 0, width * height);
+
+/*	// Make more prevalent towards the edges
+	border = Com_Clamp(6, 12, (width + height) >> 4);
+
+	for(i = 0; i < border; i++)
+	{
+		inc = (border - i + 1) * 9;
+
+		// Top line
+		work = density + i + (i * width);
+		for(x = i; x < width - i; x++, work++)
+		{
+			*work += (byte)common->irand(inc >> 1, inc);
+		}
+
+		// Left and right edges
+		work = density + i + ((i + 1) * width);
+		work2 = density + (width - i) + ((i + 1) * width);
+		for(y = i + 1; y < height - i - 2; y++, work += width, work2 += width)
+		{
+			*work += (byte)common->irand(inc >> 1, inc);
+			*work2 += (byte)common->irand(inc >> 1, inc);
+		}
+
+		// Bottom line
+		work = density + i + ((height - i - 1) * width);
+		for(x = i; x < width - i; x++, work++)
+		{
+			*work += (byte)common->irand(inc >> 1, inc);
+		}
+	}
+*/
+	count = 0;
+
+	for(y=0;y<height;y++)
+	{
+		for(x=0;x<width;x++,densityPos++)
+		{
+			xpos = (x * hm_width / width);
+			ypos = (y * hm_height / height);
+			ypos = hm_height - ypos - 1;
+
+			if (hm_map[ypos*hm_width + xpos] < 150)
+			{
+				continue;
+			}
+
+			foundUneven = false;
+			for(dx=-4;(dx<=4 && !foundUneven);dx++)
+			{
+				for(dy=-4;(dy<=4 && !foundUneven);dy++)
+				{
+					if (dx == 0 && dy == 0)
+					{
+						continue;
+					}
+					if ((xpos+dx) >= 0 && (xpos+dx) < hm_width && (ypos+dy) >= 0 && (ypos+dy) < hm_height)
+					{
+						if (hm_map[(ypos+dy)*hm_width + (xpos+dx)] < 190)
+						{
+							*densityPos = 205;
+							count++;
+							foundUneven = true;
+						}
+					}
+				}
+			}
+		}
+	}
+
+/*	FILE	*FH;
+
+	FH = fopen("c:\o.raw", "wb");
+	fwrite(hm_map, 1, common->GetRealWidth() * common->GetRealHeight(), FH);
+	fclose(FH);
+
+	FH = fopen("c:\d.raw", "wb");
+	fwrite(density, 1, width*height, FH);
+	fclose(FH);
+*/
+	// Reduce severely for any settlements/buildings/objectives
+	VectorScale(common->GetSize(), 1.0f / width, derxelSize);
+
+	origin_land = common;
+	area = common->GetFirstArea();
+	while(area)
+	{
+		// Skip group types since they encompass to much open area
+		if ( area->GetType ( ) == AT_GROUP )
+		{
+			area = common->GetNextArea();
+			continue;
+		}
+
+		VectorSubtract(area->GetPosition(), common->GetMins(), pos);
+		VectorInverseScaleVector(pos, derxelSize, dmappos);
+		// Damn upside down gensurf
+		dmappos[1] = height - dmappos[1];
+
+		count = ceilf(area->GetRadius() / derxelSize[1]);
+
+		while(count > 0)
+		{
+			CM_CircularIterate(density, width, height, dmappos[0], dmappos[1], 0, count, NULL, CG_Decrease);
+			count--;
+		}
+		area = common->GetNextArea();
+	}
+}
+
+void CRMLandScape::LoadDensityMap(const char *td)
+{
+	char		densityMap[MAX_QPATH];
+	byte		*imageData;
+	int			iWidth, iHeight, seed;
+	char 		*ptr;
+
+	// Fill in with default values
+	mDensityMap = (byte *)Z_Malloc(common->GetBlockCount(), TAG_TERRAIN);
+	memset(mDensityMap, 128, common->GetBlockCount());
+
+	// Load in density map (if any)
+	Com_sprintf(densityMap, MAX_QPATH, "%s", Info_ValueForKey(td, "densityMap"));
+	if(strlen(densityMap))
+	{
+		Com_DPrintf("CG_Terrain: Loading density map %s.....\n", densityMap);
+#ifdef DEDICATED
+		imageData = NULL;
+#else
+		R_LoadDataImage(densityMap, &imageData, &iWidth, &iHeight);
+		if(imageData)
+		{
+			if(strstr(densityMap, "density_"))
+			{
+				seed = strtoul(Info_ValueForKey(td, "seed"),&ptr,10);
+				CreateRandomDensityMap(imageData, iWidth, iHeight, seed);
+			}
+			R_Resample(imageData, iWidth, iHeight, mDensityMap, common->GetBlockWidth(), common->GetBlockHeight(), 1);
+			R_InvertImage(mDensityMap, common->GetBlockWidth(), common->GetBlockHeight(), 1);
+			Z_Free(imageData);
+		}
+#endif
+	}
+}
+
+CRandomModel *CCGHeightDetails::GetRandomModel(CCMLandScape *land)
+{
+	int		seek, i;
+
+	seek = land->irand(0, mTotalFrequency);
+	for(i = 0; i < mNumModels; i++)
+	{
+		seek -= mModels[i].GetFrequency();
+		if(seek <= 0)
+		{
+			return(mModels + i);
+		}
+	}
+	assert(0);
+	return(NULL);
+}
+#ifndef DEDICATED
+void CRMLandScape::Sprinkle(CCMPatch *patch, CCGHeightDetails *hd, int level)
+{
+	int				i, count, px, py;
+	float			density;
+	vec3_t			origin, scale, angles, bounds[2];
+	refEntity_t		refEnt;
+	CRandomModel	*rm;
+	CArea			area;
+//	int				areaTypes[] = { AT_BSP, AT_OBJECTIVE };
+	TCGMiscEnt		*data = (TCGMiscEnt *)cl.mSharedMemory;
+	TCGTrace		*td = (TCGTrace *)cl.mSharedMemory;
+
+//	memset(&refEnt, 0, sizeof(refEntity_t));
+
+	px = patch->GetHeightMapX() / common->GetTerxels();
+	py = patch->GetHeightMapY() / common->GetTerxels();
+	// Get a number -5.3f to 5.3f
+	density = (mDensityMap[px + (common->GetBlockWidth() * py)] - 128) / 24.0f;
+	// ..and multiply that into the count
+	count = Round(common->GetPatchScalarSize() * hd->GetAverageFrequency() * powf(2.0f, density) * 0.001);
+
+	for(i = 0; i < count; i++)
+	{
+		if(!common->irand(0, 10))
+		{
+			vec3_t temp;
+			float  average;
+
+			rm = hd->GetRandomModel(common);
+
+			refEnt.hModel = re.RegisterModel(rm->GetModelName());
+			refEnt.frame = 0;
+			RE_GetModelBounds(&refEnt, bounds[0], bounds[1]);
+
+			// Calculate the scale using some magic to help ensure that the
+			// scales are never too different from eachother.  Otherwise you
+			// could get an entity that is really small on one axis but huge 
+			// on another.
+			temp[0] = common->flrand(rm->GetMinScale(), rm->GetMaxScale());
+			temp[1] = common->flrand(rm->GetMinScale(), rm->GetMaxScale());
+			temp[2] = common->flrand(rm->GetMinScale(), rm->GetMaxScale());
+
+			// Average of the three random numbers and divide that by two
+			average = ( ( temp[0] + temp[1] + temp[2] ) / 3) / 2;
+
+			// Add in half of the other two numbers and then subtract half the average to prevent.
+			// any number from going beyond the range. If all three numbers were the same then
+			// they would remain unchanged after this calculation.
+			scale[0] = temp[0] + (temp[1]+temp[2]) / 2 - average;
+			scale[1] = temp[1] + (temp[0]+temp[2]) / 2 - average;
+			scale[2] = temp[2] + (temp[0]+temp[1]) / 2 - average;
+
+			angles[0] = 0.0f;
+			angles[1] = common->flrand(-M_PI, M_PI);
+			angles[2] = 0.0f;
+
+			VectorCopy(patch->GetMins(), origin);
+			origin[0] += common->flrand(0.0f, common->GetPatchWidth());
+			origin[1] += common->flrand(0.0f, common->GetPatchHeight());
+			// Get above world height
+			float slope = common->GetWorldHeight(origin, bounds, true);
+
+			if (slope > 1.33)
+			{	// spot has too steep of a slope
+				continue;
+			}
+			if(origin[2] < common->GetWaterHeight())
+			{
+				continue;
+			}
+			// very that we aren't dropped too low
+			if (origin[2] < common->CalcWorldHeight(level))
+			{
+				continue;
+			}
+
+			// Hack-ariffic, don't allow them to drop below the big player clip brush.
+			if (origin[2] < 1280 )
+			{
+				continue;
+			}
+			// FIXME: shouldn't be using a hard-coded 1280 number, only allow to spawn if inside player clip brush? 
+	//		if( !(CONTENTS_PLAYERCLIP & VM_Call( cgvm, CG_POINT_CONTENTS )) )
+	//		{
+	//			continue;
+	//		}
+			// Simple radius check for buildings
+/*			area.Init(origin, VectorLength(bounds[0]));
+			if(common->AreaCollision(&area, areaTypes, sizeof(areaTypes) / sizeof(int)))
+			{
+				continue;
+			}*/
+			// Make sure there is no architecture around - doesn't work for ents though =(
+
+			memset(td, sizeof(*td), 0);
+			VectorCopy(origin, td->mStart);
+			VectorCopy(bounds[0], td->mMins);
+			VectorCopy(bounds[1], td->mMaxs);
+			VectorCopy(origin, td->mEnd);
+			td->mSkipNumber = -1;
+			td->mMask = MASK_PLAYERSOLID;
+
+			VM_Call( cgvm, CG_TRACE );
+			if(td->mResult.surfaceFlags & SURF_NOMISCENTS)
+			{
+				continue;
+			}
+			if(td->mResult.startsolid)
+			{
+//				continue;
+			}
+			// Get minimum height of area
+			common->GetWorldHeight(origin, bounds, false);
+			// Account for relative origin
+			origin[2] -= bounds[0][2] * scale[2];
+			origin[2] -= common->flrand(2.0, (bounds[1][2] - bounds[0][2]) / 4);
+			
+			// Spawn the client model
+			strcpy(data->mModel, rm->GetModelName());
+			VectorCopy(origin, data->mOrigin);
+			VectorCopy(angles, data->mAngles);
+			VectorCopy(scale, data->mScale);
+			VM_Call( cgvm, CG_MISC_ENT);
+			mModelCount++;
+		}
+	}
+}
+#endif // !DEDICATED
+
+void CRMLandScape::SpawnPatchModels(CCMPatch *patch)
+{
+#ifndef DEDICATED
+	int					i;
+	CCGHeightDetails	*hd;
+
+//	Rand_Init(10);
+	for(i = 0; i < 4; i++)
+	{
+		hd = mHeightDetails + patch->GetHeight(i);
+		if(hd->GetNumModels())
+		{
+			Sprinkle(patch, hd, patch->GetHeight(i));
+		}
+	}
+#endif // !DEDICATED
+}
+
+void SpawnPatchModelsWrapper(CCMPatch *patch, void *userdata)
+{
+	CRMLandScape *landscape = (CRMLandScape *)userdata;
+	landscape->SpawnPatchModels(patch);
+}
+
+void RM_CreateRandomModels(int terrainId, const char *terrainInfo)
+{
+	CRMLandScape	*landscape;
+
+	landscape = rm_landscape = new CRMLandScape;
+	landscape->SetCommon(cmg.landScape);
+
+	Com_DPrintf("CG_Terrain: Creating random models.....\n");
+	landscape->LoadMiscentDef(terrainInfo);
+	landscape->LoadDensityMap(terrainInfo);
+	landscape->ClearModelCount();
+	CM_TerrainPatchIterate(landscape->GetCommon(), SpawnPatchModelsWrapper, landscape);
+
+	Com_DPrintf(".....%d random client models spawned\n", landscape->GetModelCount());
+}
+
+void RM_InitTerrain(void)
+{
+	rm_landscape = NULL;
+}
+
+void RM_ShutdownTerrain(void)
+{
+	CRMLandScape 	*landscape;
+
+	landscape = rm_landscape;
+	if(landscape)
+	{
+		delete landscape;
+		rm_landscape = NULL;
+	}
+}
+
+// end
+
+#pragma optimize("", on)
diff --git a/codemp/RMG/RM_Terrain.h b/codemp/RMG/RM_Terrain.h
new file mode 100644
index 0000000..820d2e3
--- /dev/null
+++ b/codemp/RMG/RM_Terrain.h
@@ -0,0 +1,97 @@
+#pragma once
+#if !defined(RM_TERRAIN_H_INC)
+#define RM_TERRAIN_H_INC
+
+#define MAX_RANDOM_MODELS		8
+
+class CRandomModel
+{
+private:
+	char		mModelName[MAX_QPATH];
+	float		mFrequency;
+	float		mMinScale;
+	float		mMaxScale;
+public:
+	CRandomModel(void) { }
+	~CRandomModel(void) { }
+
+	// Accessors 
+	const bool GetModel( void ) const { return(!!strlen(mModelName)); }
+	const char *GetModelName( void ) const { return(mModelName); }
+	void SetModel(const char *name) { Com_sprintf(mModelName, MAX_QPATH, "%s.md3", name); }
+	const float GetFrequency(void) const { return(mFrequency); }
+	void SetFrequency(const float freq) { mFrequency = freq; }
+	const float GetMinScale(void) const { return(mMinScale); }
+	void SetMinScale(const float minscale) { mMinScale = minscale; }
+	const float GetMaxScale(void) const { return(mMaxScale); }
+	void SetMaxScale(const float maxscale) { mMaxScale = maxscale; }
+};
+
+class CCGHeightDetails
+{
+private:
+	int				mNumModels;
+	int				mTotalFrequency;
+	CRandomModel	mModels[MAX_RANDOM_MODELS];
+public:
+	// Constructors
+	CCGHeightDetails( void ) { memset(this, 0, sizeof(*this)); }
+	~CCGHeightDetails( void ) { }
+
+	// Accessors
+	const int GetNumModels(void) const { return(mNumModels); }
+	const int GetAverageFrequency(void) const { return(mTotalFrequency / mNumModels); }
+
+	// Prototypes
+	void AddModel(const CRandomModel *hd);
+	CRandomModel *GetRandomModel(CCMLandScape *land);
+};
+
+class CCGPatch
+{
+private:
+	class CCMLandScape	*owner;
+	class CCGLandScape	*localowner;
+	CCMPatch			*common;
+public:
+};
+
+class CRMLandScape
+{
+private:
+	CCMLandScape			*common;
+
+	byte					*mDensityMap;							// Data image of model densities
+	int						mModelCount;							// Count of spawned client models
+	CCGHeightDetails		mHeightDetails[HEIGHT_RESOLUTION];		// Array of info specific to height
+
+public:
+	CRMLandScape(void);
+	~CRMLandScape(void);
+
+	// Accessors
+	void SetCommon(CCMLandScape *landscape) { common = landscape; }
+	const CCMLandScape *GetCommon( void ) const { return(common); }
+	const thandle_t GetCommonId( void ) const { return(common->GetTerrainId()); }
+	const int GetTerxels(void) const { return(common->GetTerxels()); }
+	const int GetRealWidth(void) const { return(common->GetRealWidth()); }
+	const float GetPatchScalarSize(void) const { return(common->GetPatchScalarSize()); }
+	const CCGHeightDetails *GetHeightDetail(int height) const { return(mHeightDetails + height); }
+	void ClearModelCount(void) { mModelCount = 0; }
+	const int GetModelCount(void) const { return(mModelCount); }
+
+	// Prototypes
+	void SetShaders(const int height, const qhandle_t shader);
+	void AddModel(const int height, int maxheight, const CRandomModel *hd);
+	void LoadMiscentDef(const char *td);
+	void LoadDensityMap(const char *td);
+	void SpawnPatchModels(CCMPatch *patch);
+	void Sprinkle(CCMPatch *patch, CCGHeightDetails *hd, int level);
+	void CreateRandomDensityMap(byte *imageData, int width, int height, int seed);
+};
+
+void RM_CreateRandomModels(int terrainId, const char *terrainInfo);
+void RM_InitTerrain(void);
+void RM_ShutdownTerrain(void);
+
+#endif // RM_TERRAIN_H_INC
diff --git a/codemp/RMG/vssver.scc b/codemp/RMG/vssver.scc
new file mode 100644
index 0000000..993f7cb
Binary files /dev/null and b/codemp/RMG/vssver.scc differ
diff --git a/codemp/Ratl/bits_vs.h b/codemp/Ratl/bits_vs.h
new file mode 100644
index 0000000..61ef28e
--- /dev/null
+++ b/codemp/Ratl/bits_vs.h
@@ -0,0 +1,218 @@
+////////////////////////////////////////////////////////////////////////////////////////
+// RAVEN STANDARD TEMPLATE LIBRARY
+//  (c) 2002 Activision
+//
+//
+// Bit Field
+// ---------
+// The bits class is a bit field of any length which supports all the 
+// standard bitwize operations in addition to some operators for adding & removing 
+// individual bits by their integer indicies and a string conversion method.
+//
+//
+//
+// NOTES:
+// - The SIZE template variable determines how many BITS are available in this template,
+// not how much memory (number of ints) were used to store it.
+//
+//
+////////////////////////////////////////////////////////////////////////////////////////
+#if !defined(RATL_BITS_INC)
+#define RATL_BITS_INC
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Includes
+////////////////////////////////////////////////////////////////////////////////////////
+#if !defined(RATL_COMMON_INC)
+	#include "ratl_common.h"
+#endif
+namespace ratl
+{
+	
+////////////////////////////////////////////////////////////////////////////////////////
+// The Bit Field Class
+////////////////////////////////////////////////////////////////////////////////////////
+template <int	SZ>
+class bits_vs : public bits_base<SZ>
+{
+	////////////////////////////////////////////////////////////////////////////////////
+	// Call This Function To Set All Bits Beyond SIZE to Zero
+    ////////////////////////////////////////////////////////////////////////////////////
+    void	clear_trailing_bits()
+	{
+		for (int i=SIZE; i<ARRAY_SIZE*BITS_INT_SIZE; i++)
+		{
+			mV[i>>BITS_SHIFT] &= ~(1<<(i&BITS_AND));
+		}
+	}
+	
+public:
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Capacity Enum
+    ////////////////////////////////////////////////////////////////////////////////////
+	enum	
+	{
+		SIZE			= SZ,
+		CAPACITY		= SZ,
+	};
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Standard Constructor
+	////////////////////////////////////////////////////////////////////////////////////
+	bits_vs(bool init=true,bool initValue=false) : bits_base<SZ>(init,initValue)
+	{
+	}
+	////////////////////////////////////////////////////////////////////////////////////
+	// Copy Constructor
+	////////////////////////////////////////////////////////////////////////////////////
+	bits_vs(const bits_vs &B)
+	{
+		mem::cpy(mV, B.mV,BYTE_SIZE);
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// String Constructor (Format: "100010100101")
+	////////////////////////////////////////////////////////////////////////////////////
+	bits_vs(const char* Str)
+	{
+		clear();
+
+		for (int b=0; b<SIZE; b++)
+		{
+			if (!Str[b])
+			{
+				return;			// Reached The End Of The String
+			}
+			if (Str[b]=='1')
+			{
+				set_bit(b);		// Found A True Bit
+			}
+		}
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////////
+	// Checks If There Are Any Values At All In This Bit Field (Same as operator !())
+	////////////////////////////////////////////////////////////////////////////////////////
+	bool		empty() const
+	{
+		for (int i=0; i<ARRAY_SIZE; i++)
+		{
+			if (mV[i])
+			{
+				return false;
+			}
+		}
+		return true;
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////////
+	// Get The Number Of Bits Represented Here
+	////////////////////////////////////////////////////////////////////////////////////////
+	int			size()	const
+	{
+		return SIZE;
+	}	
+
+	////////////////////////////////////////////////////////////////////////////////////////
+	// Execute A Bitwise Flip On All The Bits
+	////////////////////////////////////////////////////////////////////////////////////////
+	void		invert()
+	{
+		for (int i=0; i<ARRAY_SIZE; i++)
+		{
+			mV[i] = ~mV[i];
+		}
+		clear_trailing_bits();
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////////
+	// Execute A Bitwise Flip On All The Bits
+	////////////////////////////////////////////////////////////////////////////////////////
+	void		operator~()
+	{
+		invert();
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////////
+	// Query 
+	////////////////////////////////////////////////////////////////////////////////////////
+	bool		get_bit(const int i) const
+	{
+		// If you hit this assert, then you are trying 
+		// to query a bit that goes beyond the number
+		// of bits this object can hold.
+		//--------------------------------------------
+		assert(i>=0 && i < SIZE);
+		return ( (mV[i>>BITS_SHIFT] & (1<<(i&BITS_AND)))!=0 );
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////////
+	// Checks If There Are Any Values At All In This Bit Field
+	////////////////////////////////////////////////////////////////////////////////////////
+	bool		operator!() const
+	{
+		return empty();
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////////
+	// Equality Operator
+	////////////////////////////////////////////////////////////////////////////////////////
+	bool		operator==(const bits_vs &B) const
+	{
+		return (mem::eql(mV, B.mV,BYTE_SIZE));
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////////
+	// InEquality Operator
+	////////////////////////////////////////////////////////////////////////////////////////
+	bool		operator!=(const bits_vs &B) const
+	{
+		return !(operator==(B));
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////////
+	// Or In From Another Bits Object
+	////////////////////////////////////////////////////////////////////////////////////////
+	void		operator|=(const bits_vs &B)
+	{
+		for (int i=0; i<ARRAY_SIZE; i++)
+		{
+			mV[i] |= B.mV[i];
+		}
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////////
+	// And In From Another Bits Object
+	////////////////////////////////////////////////////////////////////////////////////////
+	void		operator&=(const bits_vs &B)
+	{
+		for (int i=0; i<ARRAY_SIZE; i++)
+		{
+			mV[i] &= B.mV[i];
+		}
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////////
+	// xor In From Another Bits Object
+	////////////////////////////////////////////////////////////////////////////////////////
+	void		operator^=(const bits_vs &B)
+	{
+		for (int i=0; i<ARRAY_SIZE; i++)
+		{
+			mV[i] ^= B.mV[i];
+		}
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////////
+	// Assignment Operator
+	////////////////////////////////////////////////////////////////////////////////////////
+	void		operator=(const bits_vs &B)
+	{
+		mem::cpy(mV, B.mV,BYTE_SIZE);
+	}
+
+};
+
+}
+#endif
diff --git a/codemp/Ratl/ratl_common.h b/codemp/Ratl/ratl_common.h
new file mode 100644
index 0000000..f4f59b0
--- /dev/null
+++ b/codemp/Ratl/ratl_common.h
@@ -0,0 +1,1180 @@
+////////////////////////////////////////////////////////////////////////////////////////
+// RAVEN STANDARD TEMPLATE LIBRARY
+//  (c) 2002 Activision
+//
+//
+// Common
+// ------
+// The raven libraries contain a number of common defines, enums, and typedefs which
+// need to be accessed by all templates.  Each of these is included here.
+//
+// Also included is a safeguarded assert file for all the asserts in RTL.
+//
+// This file is included in EVERY TEMPLATE, so it should be very light in order to 
+// reduce compile times.
+//
+//
+// Format
+// ------
+// In order to simplify code and provide readability, the template library has some
+// standard formats.  Any new templates or functions should adhere to these formats:
+//
+// - All memory is statically allocated, usually by parameter SIZE
+// - All classes provide an enum which defines constant variables, including CAPACITY
+// - All classes which moniter the number of items allocated provide the following functions:
+//     size()   - the number of objects
+//     empty()  - does the container have zero objects
+//     full()   - does the container have any room left for more objects
+//     clear()  - remove all objects
+//
+//
+// - Functions are defined in the following order:
+//     Capacity
+//     Constructors  (copy, from string, etc...)
+//     Range		 (size(), empty(), full(), clear(), etc...)
+//     Access        (operator[], front(), back(), etc...)
+//     Modification  (add(), remove(), push(), pop(), etc...)
+//     Iteration     (begin(), end(), insert(), erase(), find(), etc...)
+//
+//
+// NOTES:
+//
+//
+//
+////////////////////////////////////////////////////////////////////////////////////////
+#if !defined(RATL_COMMON_INC)
+#define RATL_COMMON_INC
+
+////////////////////////////////////////////////////////////////////////////////////////
+// In VC++, Don't Bother With These Warnings
+////////////////////////////////////////////////////////////////////////////////////////
+#if defined(_MSC_VER) && !defined(__MWERKS__)
+	#pragma warning ( disable : 4786 )			// Truncated to 255 characters warning
+	#pragma warning ( disable : 4284 )			// nevamind what this is
+	#pragma warning ( disable : 4100 )			// unreferenced formal parameter
+	#pragma warning ( disable : 4512 )			// unable to generate default operator=
+	#pragma warning ( disable : 4130 )			// logical operation on address of string constant
+	#pragma warning ( disable : 4127 )			// conditional expression is constant
+#endif
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Includes
+////////////////////////////////////////////////////////////////////////////////////////
+#if !defined(ASSERT_H_INC)
+#include <assert.h>
+#define ASSERT_H_INC
+#endif
+
+#if !defined(STRING_H_INC)
+#include <string.h>
+#define STRING_H_INC
+#endif
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Forward Dec.
+////////////////////////////////////////////////////////////////////////////////////////
+class hfile;
+
+
+
+// I don't know why this needs to be in the global namespace, but it does
+class TRatlNew;
+inline void *operator new(size_t,TRatlNew *where)
+{
+	return where;
+}
+
+inline void operator delete(void *, TRatlNew *)
+{
+	return; 
+}
+
+namespace ratl
+{
+
+
+
+#ifdef _DEBUG
+extern int HandleSaltValue; //this is used in debug for global uniqueness of handles
+extern int FoolTheOptimizer; //this is used to make sure certain things aren't optimized out
+#endif
+
+////////////////////////////////////////////////////////////////////////////////////////
+// All Raven Template Library Internal Memory Operations
+//
+// This is mostly for future use.  For now, they only provide a simple interface with
+// a couple extra functions (eql and clr).
+////////////////////////////////////////////////////////////////////////////////////////
+namespace	mem
+{
+////////////////////////////////////////////////////////////////////////////////////////
+// The Align Struct Is The Root Memory Structure for Inheritance and Object Semantics
+//
+// In most cases, we just want a simple int.  However, sometimes we need to use an
+// unsigned character array
+//
+////////////////////////////////////////////////////////////////////////////////////////
+#if defined(_MSC_VER) && !defined(__MWERKS__)
+	struct alignStruct
+	{
+		int space;
+	};
+#else
+	struct alignStruct
+	{
+		unsigned char space[16];
+	} __attribute__ ((aligned(16)));
+#endif 
+
+	inline void*	cpy( void *dest, const void *src, size_t count )
+	{
+		return memcpy(dest, src, count);
+	}
+	inline void*	set( void *dest, int c, size_t count )
+	{
+		return memset(dest, c, count);
+	}
+	inline int		cmp( const void *buf1, const void *buf2, size_t count )
+	{
+		return memcmp( buf1, buf2, count );
+	}
+	inline bool	eql( const void *buf1, const void *buf2, size_t count )
+	{
+		return (memcmp( buf1, buf2, count )==0);
+	}
+	inline void*	zero( void *dest, size_t count )
+	{
+		return memset(dest, 0, count);
+	}
+
+	template<class T>
+	inline 	void	cpy( T *dest, const T *src)
+	{
+		cpy(dest, src, sizeof(T));
+	}
+	template<class T>
+	inline 	void	set(T *dest, int c)
+	{
+		set(dest, c, sizeof(T));
+	}
+
+	template<class T>
+	inline 	void	swap(T *s1, T *s2)
+	{
+		unsigned char temp[sizeof(T)];
+		cpy((T *)temp,s1);
+		cpy(s1,s2);
+		cpy(s2,(T *)temp);
+	}
+
+	template<class T>
+	inline 	int		cmp( const T *buf1, const T *buf2)
+	{
+		return cmp( buf1, buf2, sizeof(T) );
+	}
+
+	template<class T>
+	inline 	bool	eql( const T *buf1, const T *buf2)
+	{
+		return cmp( buf1, buf2,sizeof(T))==0;
+	}
+
+	template<class T>
+	inline 	void	zero( T *dest )
+	{
+		return set(dest, 0, sizeof(T));
+	}
+}
+
+namespace str
+{
+	inline int		len(const char *src)
+	{
+		return strlen(src);
+	}
+
+	inline void	cpy(char *dest,const char *src)
+	{
+		strcpy(dest,src);
+	}
+
+	inline void	ncpy(char *dest,const char *src,int destBufferLen)
+	{
+		strncpy(dest,src,destBufferLen);
+	}
+
+	inline void	cat(char *dest,const char *src)
+	{
+		strcat(dest,src);
+	}
+
+	inline void	ncat(char *dest,const char *src,int destBufferLen)
+	{
+		ncpy(dest+len(dest),src,destBufferLen-len(dest));
+	}
+
+	inline int		cmp(const char *s1,const char *s2)
+	{
+		return strcmp(s1,s2);
+	}
+	inline bool	eql(const char *s1,const char *s2)
+	{
+		return !strcmp(s1,s2);
+	}
+	inline int		icmp(const char *s1,const char *s2)
+	{
+		return stricmp(s1,s2);
+	}
+	inline int		cmpi(const char *s1,const char *s2)
+	{
+		return stricmp(s1,s2);
+	}
+	inline bool	ieql(const char *s1,const char *s2)
+	{
+		return !stricmp(s1,s2);
+	}
+	inline bool	eqli(const char *s1,const char *s2)
+	{
+		return !stricmp(s1,s2);
+	}
+
+	inline char	*tok(char *s,const char *gap)
+	{
+		return strtok(s,gap);
+	}
+
+	void	to_upper(char *dest);
+	void	to_lower(char *dest);
+	void	printf(char *dest,const char *formatS, ...);
+}
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// The Raven Template Library Compile Assert
+//
+// If, during compile time the stuff under (condition) is zero, this code will not
+// compile.
+////////////////////////////////////////////////////////////////////////////////////////
+template<int condition>
+class	compile_assert
+{
+#ifdef _DEBUG
+	int	junk[(1 - (2 * !condition))];		// Look At Where This Was Being Compiled
+public:
+	compile_assert()
+	{
+		assert(condition);
+		junk[0]=FoolTheOptimizer++;
+	}
+	int operator()()
+	{
+		assert(condition);
+		FoolTheOptimizer++;
+		return junk[0];
+	}
+#else
+public:
+	int operator()()
+	{
+		return 1;
+	}
+#endif;
+};
+
+
+
+
+
+	
+////////////////////////////////////////////////////////////////////////////////////////
+// The Raven Template Library Base Class
+//
+// This is the base class for all the Raven Template Library container classes like
+// vector_vs and pool_vs.  
+//
+// This class might be a good place to put memory profile code in the future.
+//
+////////////////////////////////////////////////////////////////////////////////////////
+class	ratl_base
+{
+public:
+#ifndef _XBOX
+	void	save(hfile& file);
+	void	load(hfile& file);
+#endif
+
+	void	ProfilePrint(const char * format, ...);
+
+public:
+	static	void*	OutputPrint;
+};
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// this is a simplified version of bits_vs
+////////////////////////////////////////////////////////////////////////////////////////
+template <int	SZ>
+class bits_base
+{
+protected:
+	enum
+	{
+		BITS_SHIFT		= 5,									// 5.  Such A Nice Number
+		BITS_INT_SIZE	= 32,									// Size Of A Single Word
+		BITS_AND		= (BITS_INT_SIZE - 1),					// Used For And Operation
+		ARRAY_SIZE		= ((SZ + BITS_AND)/(BITS_INT_SIZE)),	// Num Words Used
+		BYTE_SIZE		= (ARRAY_SIZE*sizeof(unsigned int)),	// Num Bytes Used
+	};
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Data
+	////////////////////////////////////////////////////////////////////////////////////
+	unsigned int						mV[ARRAY_SIZE];
+public:
+	enum	
+	{
+		SIZE			= SZ,
+		CAPACITY		= SZ,
+	};
+
+	bits_base(bool init=true,bool initValue=false)
+	{
+		if (init)
+		{
+			if (initValue)
+			{
+				set();
+			}
+			else
+			{
+				clear();
+			}
+		}
+	}
+	void clear()
+	{
+		mem::zero(&mV,BYTE_SIZE);
+	}
+	void		set()
+	{
+		mem::set(&mV, 0xff,BYTE_SIZE);
+	}
+
+	void set_bit(const int i)
+	{
+		assert(i>=0 && i < SIZE);
+		mV[i>>BITS_SHIFT] |=  (1<<(i&BITS_AND));
+	}
+	void clear_bit(const int i)
+	{
+		assert(i>=0 && i < SIZE);
+		mV[i>>BITS_SHIFT] &= ~(1<<(i&BITS_AND));
+	}
+	void mark_bit(const int i, bool set)
+	{
+		assert(i>=0 && i < SIZE);
+		if (set)
+		{
+			mV[i>>BITS_SHIFT] |=  (1<<(i&BITS_AND));
+		}
+		else
+		{
+			mV[i>>BITS_SHIFT] &= ~(1<<(i&BITS_AND));
+		}
+	}
+	bool operator[](const int i) const
+	{
+		assert(i>=0 && i < SIZE);
+		return (mV[i>>BITS_SHIFT] & (1<<(i&BITS_AND)))!=0;
+	}
+	int	next_bit(int start=0,bool onBit=true) const
+	{
+		assert(start>=0&&start<=SIZE);  //we have to accept start==size for the way the loops are done
+		if (start>=SIZE)
+		{
+			return SIZE;			// Did Not Find
+		}
+		// Get The Word Which Contains The Start Bit & Mask Out Everything Before The Start Bit
+		//--------------------------------------------------------------------------------------
+		unsigned int	v = mV[start>>BITS_SHIFT];
+		if (!onBit)
+		{
+			v= (~v);
+		}
+		v >>= (start&31);
+
+
+		// Search For The First Non Zero Word In The Array
+		//-------------------------------------------------
+		while(!v)
+		{
+			start = (start & (~(BITS_INT_SIZE-1))) + BITS_INT_SIZE;
+			if (start>=SIZE)
+			{
+				return SIZE;			// Did Not Find
+			}
+			v = mV[start>>BITS_SHIFT];
+			if (!onBit)
+			{
+				v= (~v);
+			}
+		}
+
+
+		// So, We've Found A Non Zero Word, So Start Masking Against Parts To Skip Over Bits
+		//-----------------------------------------------------------------------------------
+		if (!(v&0xffff))
+		{
+			start+=16;
+			v>>=16;
+		}
+		if (!(v&0xff))
+		{
+			start+=8;
+			v>>=8;
+		}
+		if (!(v&0xf))
+		{
+			start+=4;
+			v>>=4;
+		}
+
+		// Time To Search Each Bit
+		//-------------------------
+		while(!(v&1))
+		{
+			start++;
+			v>>=1;
+		}
+		if (start>=SIZE)
+		{
+			return SIZE;
+		}
+		return start;
+	}
+};
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Raven Standard Compare Class
+////////////////////////////////////////////////////////////////////////////////////////
+struct ratl_compare
+{
+	float	mCost;
+	int		mHandle;
+
+	bool	operator<(const ratl_compare& t) const	
+	{
+		return (mCost<t.mCost);
+	}
+};
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// this is used to keep track of the constuction state for things that are always constucted
+////////////////////////////////////////////////////////////////////////////////////////
+class bits_true
+{
+public:
+
+	void clear()
+	{
+	}
+	void set()
+	{
+	}
+	void set_bit(const int i)
+	{
+	}
+	void clear_bit(const int i)
+	{
+	}
+	bool operator[](const int i) const
+	{
+		return true;
+	}
+	int	next_bit(int start=0,bool onBit=true) const
+	{
+		assert(onBit); ///I didn't want to add the sz template arg, you could though
+		return start;
+	}
+};
+
+
+namespace storage
+{
+	template<class T,int SIZE>
+	struct value_semantics
+	{
+		enum	
+		{
+			CAPACITY		= SIZE,
+		};
+		typedef T TAlign;		// this is any type that has the right alignment
+		typedef T TValue;		// this is the actual thing the user uses
+		typedef T TStorage;		// this is what we make our array of
+
+		typedef bits_true TConstructed;
+		typedef TStorage TArray[SIZE];
+
+
+		enum 
+		{
+			NEEDS_CONSTRUCT=0,
+			TOTAL_SIZE=sizeof(TStorage),
+			VALUE_SIZE=sizeof(TStorage),
+		};
+		static void construct(TStorage *)
+		{
+
+		}
+		static void construct(TStorage *me,const TValue &v)
+		{
+			*me=v;
+		}
+		static void destruct(TStorage *)
+		{
+
+		}
+		static TRatlNew *raw(TStorage *me)
+		{
+			return (TRatlNew *)me;
+		}
+		static T * ptr(TStorage *me)
+		{
+			return me;
+		}
+		static const T * ptr(const TStorage *me)
+		{
+			return me;
+		}
+		static T & ref(TStorage *me)
+		{
+			return *me;
+		}
+		static const T & ref(const TStorage *me)
+		{
+			return *me;
+		}
+		static T *raw_array(TStorage *me)
+		{
+			return me;
+		}
+		static const T *raw_array(const TStorage *me)
+		{
+			return me;
+		}
+		static void swap(TStorage *s1,TStorage *s2)
+		{
+			mem::swap(ptr(s1),ptr(s2));
+		}
+		static int pointer_to_index(const void *s1,const void *s2)
+		{
+			return ((TStorage *)s1)-((TStorage *)s2);
+		}
+	};
+	template<class T,int SIZE>
+	struct object_semantics
+	{
+		enum	
+		{
+			CAPACITY		= SIZE,
+		};
+		typedef mem::alignStruct TAlign;		// this is any type that has the right alignment
+		typedef T TValue;				// this is the actual thing the user uses
+
+		typedef bits_base<SIZE> TConstructed;
+
+		struct TStorage
+		{
+			TAlign mMemory[((sizeof(T) + sizeof(TAlign) -1 )/sizeof(TAlign))];
+		};
+		typedef TStorage TArray[SIZE];
+
+		enum 
+		{
+			NEEDS_CONSTRUCT=1,
+			TOTAL_SIZE=sizeof(TStorage),
+			VALUE_SIZE=sizeof(TStorage),
+		};
+
+		static void construct(TStorage *me)
+		{
+			new(raw(me)) TValue();						
+		}
+		static void construct(TStorage *me,const TValue &v)
+		{
+			new(raw(me)) TValue(v);									
+		}
+		static void destruct(TStorage *me)
+		{
+			ptr(me)->~T();				
+		}
+		static TRatlNew *raw(TStorage *me)
+		{
+			return (TRatlNew *)me;
+		}
+		static T * ptr(TStorage *me)
+		{
+			return (T *)me;
+		}
+		static const T * ptr(const TStorage *me)
+		{
+			return (const T *)me;
+		}
+		static T & ref(TStorage *me)
+		{
+			return *(T *)me;
+		}
+		static const T & ref(const TStorage *me)
+		{
+			return *(const T *)me;
+		}
+		static void swap(TStorage *s1,TStorage *s2)
+		{
+			TValue temp(ref(s1));
+			ref(s1)=ref(s2);
+			ref(s2)=temp;
+		}
+		static int pointer_to_index(const void *s1,const void *s2)
+		{
+			return ((TStorage *)s1)-((TStorage *)s2);
+		}	
+	};
+	template<class T,int SIZE,int MAX_CLASS_SIZE>
+	struct virtual_semantics
+	{
+		enum	
+		{
+			CAPACITY		= SIZE,
+		};
+		typedef mem::alignStruct TAlign;		// this is any type that has the right alignment
+		typedef T TValue;				// this is the actual thing the user uses
+
+		typedef bits_base<SIZE> TConstructed;
+
+		struct TStorage
+		{
+			TAlign mMemory[((MAX_CLASS_SIZE + sizeof(TAlign) -1 )/sizeof(TAlign))];
+		};
+		typedef TStorage TArray[SIZE];
+
+		enum 
+		{
+			NEEDS_CONSTRUCT=1,
+			TOTAL_SIZE=sizeof(TStorage),
+			VALUE_SIZE=MAX_CLASS_SIZE,
+		};
+
+		static void construct(TStorage *me)
+		{
+			new(raw(me)) TValue();						
+		}
+		static void destruct(TStorage *me)
+		{
+			ptr(me)->~T();				
+		}
+		static TRatlNew *raw(TStorage *me)
+		{
+			return (TRatlNew *)me;
+		}
+		static T * ptr(TStorage *me)
+		{
+			return (T *)me;
+		}
+		static const T * ptr(const TStorage *me)
+		{
+			return (const T *)me;
+		}
+		static T & ref(TStorage *me)
+		{
+			return *(T *)me;
+		}
+		static const T & ref(const TStorage *me)
+		{
+			return *(const T *)me;
+		}
+		// this is a bit suspicious, we are forced to do a memory swap, and for a class, that, say
+		// stores a pointer to itself, it won't work right
+		static void swap(TStorage *s1,TStorage *s2)
+		{
+			mem::swap(s1,s2);
+		}
+		static int pointer_to_index(const void *s1,const void *s2)
+		{
+			return ((TStorage *)s1)-((TStorage *)s2);
+		}	
+		template<class CAST_TO>
+		static CAST_TO *verify_alloc(CAST_TO *p)
+		{
+#ifdef _DEBUG
+			assert(p);
+			assert(dynamic_cast<const T *>(p));
+			T *ptr=p; // if this doesn't compile, you are trying to alloc something that is not derived from base
+			assert(dynamic_cast<const CAST_TO *>(ptr));
+			int i=VALUE_SIZE;
+			int k=MAX_CLASS_SIZE;
+			int j=sizeof(CAST_TO);
+			compile_assert<sizeof(CAST_TO)<=MAX_CLASS_SIZE>();
+			assert(sizeof(CAST_TO)<=MAX_CLASS_SIZE);
+#endif
+			return p;
+		}
+	};
+
+	// The below versions are for nodes
+
+	template<class T,int SIZE,class NODE>
+	struct value_semantics_node
+	{
+		enum	
+		{
+			CAPACITY		= SIZE,
+		};
+		struct SNode
+		{
+			NODE	nodeData;
+			T		value;
+		};
+		typedef SNode		TAlign;		// this is any type that has the right alignment
+		typedef T			TValue;		// this is the actual thing the user uses
+		typedef SNode		TStorage;		// this is what we make our array of
+
+		typedef bits_true TConstructed;
+		typedef TStorage TArray[SIZE];
+
+		enum 
+		{
+			NEEDS_CONSTRUCT=0,
+			TOTAL_SIZE=sizeof(TStorage),
+			VALUE_SIZE=sizeof(TValue),
+		};
+		static void construct(TStorage *)
+		{
+
+		}
+		static void construct(TStorage *me,const TValue &v)
+		{
+			me->value=v;
+		}
+		static void destruct(TStorage *)
+		{
+
+		}
+		static TRatlNew *raw(TStorage *me)
+		{
+			return (TRatlNew *)&me->value;
+		}
+		static T * ptr(TStorage *me)
+		{
+			return &me->value;
+		}
+		static const T * ptr(const TStorage *me)
+		{
+			return &me->value;
+		}
+		static T & ref(TStorage *me)
+		{
+			return me->value;
+		}
+		static const T & ref(const TStorage *me)
+		{
+			return me->value;
+		}
+		// this ugly unsafe cast-hack is a backhanded way of getting the node data from the value data
+		// this is so node support does not need to be added to the primitive containers
+		static NODE & node(TValue &v)
+		{
+			return *(NODE *)((unsigned char *)(&v)+int(&((TStorage *)0)->nodeData)-int(&((TStorage *)0)->value));
+		}
+		static const NODE & node(const TValue &v)
+		{
+			return *(const NODE *)((unsigned char *)(&v)+int(&((TStorage *)0)->nodeData)-int(&((TStorage *)0)->value));
+		}
+		static void swap(TStorage *s1,TStorage *s2)
+		{
+			mem::swap(&s1->value,&s2->value);
+		}
+		// this is hideous
+		static int pointer_to_index(const void *s1,const void *s2)
+		{
+			return 
+				((TStorage *)(((unsigned char *)s1)-int(&((TStorage *)0)->value))) - 
+				((TStorage *)(((unsigned char *)s2)-int(&((TStorage *)0)->value)));
+		}	
+	};
+
+	template<class T,int SIZE,class NODE>
+	struct object_semantics_node
+	{
+		enum	
+		{
+			CAPACITY		= SIZE,
+		};
+		typedef mem::alignStruct TAlign;		// this is any type that has the right alignment
+		typedef T			TValue;		// this is the actual thing the user uses
+
+		typedef bits_base<SIZE> TConstructed;
+
+		struct TValueStorage
+		{
+			TAlign mMemory[((sizeof(T) + sizeof(TAlign) -1 )/sizeof(TAlign))];
+		};
+		struct SNode
+		{
+			NODE				nodeData;
+			TValueStorage		value;
+		};
+		typedef SNode		TStorage;		// this is what we make our array of
+		typedef TStorage TArray[SIZE];
+
+
+		enum 
+		{
+			NEEDS_CONSTRUCT=0,
+			TOTAL_SIZE=sizeof(TStorage),
+			VALUE_SIZE=sizeof(TValueStorage),
+		};
+
+		static void construct(TStorage *me)
+		{
+			new(raw(me)) TValue();						
+		}
+		static void construct(TStorage *me,const TValue &v)
+		{
+			new(raw(me)) TValue(v);									
+		}
+		static void destruct(TStorage *me)
+		{
+			ptr(me)->~T();				
+		}
+		static TRatlNew *raw(TStorage *me)
+		{
+			return (TRatlNew *)&me->value;
+		}
+		static T * ptr(TStorage *me)
+		{
+			return (T *)&me->value;
+		}
+		static const T * ptr(const TStorage *me)
+		{
+			return (const T *)&me->value;
+		}
+		static T & ref(TStorage *me)
+		{
+			return *(T *)&me->value;
+		}
+		static const T & ref(const TStorage *me)
+		{
+			return *(const T *)&me->value;
+		}
+		static NODE & node(TStorage *me)
+		{
+			return me->nodeData;
+		}
+		static const NODE & node(const TStorage *me)
+		{
+			return me->nodeData;
+		}
+		// this ugly unsafe cast-hack is a backhanded way of getting the node data from the value data
+		// this is so node support does not need to be added to the primitive containers
+		static NODE & node(TValue &v)
+		{
+			return *(NODE *)((unsigned char *)(&v)+int(&((TStorage *)0)->nodeData)-int(&((TStorage *)0)->value));
+		}
+		static const NODE & node(const TValue &v)
+		{
+			return *(const NODE *)((unsigned char *)(&v)+int(&((TStorage *)0)->nodeData)-int(&((TStorage *)0)->value));
+		}
+		static void swap(TStorage *s1,TStorage *s2)
+		{
+			TValue temp(ref(s1));
+			ref(s1)=ref(s2);
+			ref(s2)=temp;
+		}
+		// this is hideous
+		static int pointer_to_index(const void *s1,const void *s2)
+		{
+			return 
+				((TStorage *)(((unsigned char *)s1)-int(&((TStorage *)0)->value))) - 
+				((TStorage *)(((unsigned char *)s2)-int(&((TStorage *)0)->value)));
+		}	
+	};
+	template<class T,int SIZE,int MAX_CLASS_SIZE,class NODE>
+	struct virtual_semantics_node
+	{
+		enum	
+		{
+			CAPACITY		= SIZE,
+		};
+		typedef mem::alignStruct TAlign;		// this is any type that has the right alignment
+		typedef T TValue;				// this is the actual thing the user uses
+
+		typedef bits_base<SIZE> TConstructed;
+
+		struct TValueStorage
+		{
+			TAlign mMemory[((MAX_CLASS_SIZE + sizeof(TAlign) -1 )/sizeof(TAlign))];
+		};
+		struct SNode
+		{
+			NODE				nodeData;
+			TValueStorage		value;
+		};
+		typedef SNode		TStorage;		// this is what we make our array of
+		typedef TStorage TArray[SIZE];
+
+		enum 
+		{
+			NEEDS_CONSTRUCT=1,
+			TOTAL_SIZE=sizeof(TStorage),
+			VALUE_SIZE=sizeof(TValueStorage),
+		};
+
+		static void construct(TStorage *me)
+		{
+			new(raw(me)) TValue();						
+		}
+		static void destruct(TStorage *me)
+		{
+			ptr(me)->~T();				
+		}
+		static TRatlNew *raw(TStorage *me)
+		{
+			return (TRatlNew *)&me->value;
+		}
+		static T * ptr(TStorage *me)
+		{
+			return (T *)&me->value;
+		}
+		static const T * ptr(const TStorage *me)
+		{
+			return (const T *)&me->value;
+		}
+		static T & ref(TStorage *me)
+		{
+			return *(T *)&me->value;
+		}
+		static const T & ref(const TStorage *me)
+		{
+			return *(const T *)&me->value;
+		}
+		static NODE & node(TStorage *me)
+		{
+			return me->nodeData;
+		}
+		static const NODE & node(const TStorage *me)
+		{
+			return me->nodeData;
+		}
+		// this ugly unsafe cast-hack is a backhanded way of getting the node data from the value data
+		// this is so node support does not need to be added to the primitive containers
+		static NODE & node(TValue &v)
+		{
+			return *(NODE *)((unsigned char *)(&v)+int(&((TStorage *)0)->nodeData)-int(&((TStorage *)0)->value));
+		}
+		static const NODE & node(const TValue &v)
+		{
+			return *(const NODE *)((unsigned char *)(&v)+int(&((TStorage *)0)->nodeData)-int(&((TStorage *)0)->value));
+		}
+		// this is a bit suspicious, we are forced to do a memory swap, and for a class, that, say
+		// stores a pointer to itself, it won't work right
+		static void swap(TStorage *s1,TStorage *s2)
+		{
+			mem::swap(&s1->value,&s2->value);
+		}
+		// this is hideous
+		static int pointer_to_index(const void *s1,const void *s2)
+		{
+			return 
+				((TStorage *)(((unsigned char *)s1)-int(&((TStorage *)0)->value))) - 
+				((TStorage *)(((unsigned char *)s2)-int(&((TStorage *)0)->value)));
+		}	
+		template<class CAST_TO>
+		static CAST_TO *verify_alloc(CAST_TO *p)
+		{
+#ifdef _DEBUG
+			assert(p);
+			assert(dynamic_cast<const T *>(p));
+			T *ptr=p; // if this doesn't compile, you are trying to alloc something that is not derived from base
+			assert(dynamic_cast<const CAST_TO *>(ptr));
+			int i=VALUE_SIZE;
+			int k=MAX_CLASS_SIZE;
+			int j=sizeof(CAST_TO);
+			compile_assert<sizeof(CAST_TO)<=MAX_CLASS_SIZE>();
+			assert(sizeof(CAST_TO)<=MAX_CLASS_SIZE);
+#endif
+			return p;
+		}
+	};
+
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// The Array Base Class, used for most containers
+////////////////////////////////////////////////////////////////////////////////////////
+template<class T>
+class array_base : public ratl_base
+{
+public:
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Capacity Enum
+    ////////////////////////////////////////////////////////////////////////////////////
+ 	enum 
+	{
+		CAPACITY	= T::CAPACITY,
+		SIZE		= T::CAPACITY,
+	};
+	////////////////////////////////////////////////////////////////////////////////////
+	// Data
+	////////////////////////////////////////////////////////////////////////////////////
+	typedef typename T					TStorageTraits;
+	typedef typename T::TArray			TTArray;
+	typedef typename T::TValue			TTValue;
+	typedef typename T::TConstructed	TTConstructed;
+
+private:
+	TTArray				mArray;
+	TTConstructed		mConstructed;
+
+public:
+
+	array_base()
+	{
+	}
+
+	~array_base()
+	{
+		clear();
+	}
+
+	void clear()
+	{
+		if (T::NEEDS_CONSTRUCT)
+		{
+			int i=mConstructed.next_bit();
+			while (i<SIZE)
+			{
+				T::destruct(mArray+i);
+				i=mConstructed.next_bit(i+1);
+			}
+			mConstructed.clear();
+		}
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Access Operator
+	////////////////////////////////////////////////////////////////////////////////////
+	TTValue&			operator[](int index)
+	{
+		assert(index>=0 && index<SIZE);
+		assert(mConstructed[index]);
+		return T::ref(mArray+index);
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Const Access Operator
+	////////////////////////////////////////////////////////////////////////////////////
+	const TTValue&	operator[](int index) const
+	{
+		assert(index>=0 && index<SIZE);
+		assert(mConstructed[index]);
+		return T::ref(mArray+index);
+	}
+
+	void construct(int i)
+	{
+		if (T::NEEDS_CONSTRUCT)
+		{
+			assert(!mConstructed[i]);
+			T::construct(mArray+i);
+			mConstructed.set_bit(i);
+		}
+	}
+	void construct(int i, const TTValue &v)
+	{
+		assert(i>=0 && i<SIZE);
+		T::construct(mArray+i,v);
+		if (T::NEEDS_CONSTRUCT)
+		{
+			assert(!mConstructed[i]);
+			mConstructed.set_bit(i);
+		}
+	}
+	void fill(const TTValue &v)
+	{
+		clear();
+		int i;
+		for (i=0;i<SIZE;i++)
+		{
+			T::construct(mArray+i,v);
+		}
+		if (T::NEEDS_CONSTRUCT)
+		{
+			mConstructed.set();
+		}
+	}
+	void swap(int i,int j)
+	{
+		assert(i>=0 && i<SIZE);
+		assert(j>=0 && j<SIZE);
+		assert(i!=j);
+		assert(mConstructed[i]);
+		assert(mConstructed[j]);
+		T::swap(mArray+i,mArray+j);
+	}
+
+	TRatlNew	*alloc_raw(int i)
+	{
+		assert(i>=0 && i<SIZE);
+		if (T::NEEDS_CONSTRUCT)
+		{
+			assert(!mConstructed[i]);
+			mConstructed.set_bit(i);
+		}
+		return T::raw(mArray+i);
+	}
+	void	destruct(int i)
+	{
+		assert(i>=0 && i<SIZE);
+		assert(mConstructed[i]);
+		if (T::NEEDS_CONSTRUCT)
+		{
+			T::destruct(mArray+i);
+			mConstructed.clear_bit(i);
+		}
+	}
+	int pointer_to_index(const TTValue *me) const
+	{
+		int index=T::pointer_to_index(me,mArray);
+		assert(index>=0 && index<SIZE);
+		assert(mConstructed[index]);
+		return index;
+	}
+	int pointer_to_index(const TRatlNew *me) const
+	{
+		int index=T::pointer_to_index(me,mArray);
+		assert(index>=0 && index<SIZE);
+		assert(mConstructed[index]);
+		return index;
+	}
+	typename T::TValue *raw_array()
+	{
+		return T::raw_array(mArray);
+	}
+	const typename T::TValue *raw_array() const
+	{
+		return T::raw_array(mArray);
+	}
+	template<class CAST_TO>
+	CAST_TO *verify_alloc(CAST_TO *p) const
+	{
+		return T::verify_alloc(p);
+	}
+
+};
+
+}
+#endif
\ No newline at end of file
diff --git a/codemp/Ratl/vector_vs.h b/codemp/Ratl/vector_vs.h
new file mode 100644
index 0000000..ad8bb05
--- /dev/null
+++ b/codemp/Ratl/vector_vs.h
@@ -0,0 +1,757 @@
+////////////////////////////////////////////////////////////////////////////////////////
+// RAVEN STANDARD TEMPLATE LIBRARY
+//  (c) 2002 Activision
+//
+//
+// Vector
+// ------
+// The vector class is a simple addition to the array.  It supports some useful additions
+// like sort and binary search, as well as keeping track of the number of objects
+// contained within.
+//
+//
+//
+//
+//
+// NOTES:
+//
+//
+////////////////////////////////////////////////////////////////////////////////////////
+#if !defined(RATL_VECTOR_VS_INC)
+#define RATL_VECTOR_VS_INC
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Includes
+////////////////////////////////////////////////////////////////////////////////////////
+#if !defined(RATL_COMMON_INC)
+	#include "ratl_common.h"
+#endif
+namespace ratl
+{
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// The Vector Class
+////////////////////////////////////////////////////////////////////////////////////////
+template<class T>
+class vector_base : public ratl_base
+{
+public:
+	typedef typename T TStorageTraits;
+	typedef typename T::TValue TTValue;
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Capacity Enum
+    ////////////////////////////////////////////////////////////////////////////////////
+ 	enum 
+	{
+		CAPACITY		= T::CAPACITY
+	};
+private:
+	array_base<TStorageTraits>		mArray;			// The Memory
+	int								mSize;
+public:
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Constructor
+    ////////////////////////////////////////////////////////////////////////////////////
+	vector_base()
+	{
+		mSize = 0;
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Copy Constructor
+	////////////////////////////////////////////////////////////////////////////////////
+	vector_base(const vector_base &B)
+	{
+		for (int i=0; i<B.size(); i++)
+		{
+			mArray[i] = B.mArray[i];
+		}
+		mSize = val.mSize;
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// How Many Objects Can Be Added?
+    ////////////////////////////////////////////////////////////////////////////////////
+	int				capacity() const
+	{
+		assert(mSize>=0&&mSize<=CAPACITY);
+		return (CAPACITY);
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// How Many Objects Have Been Added To This Vector?
+    ////////////////////////////////////////////////////////////////////////////////////
+	int				size() const
+	{
+		assert(mSize>=0&&mSize<=CAPACITY);
+		return (mSize);
+	}
+    
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Have Any Objects Have Been Added To This Vector?
+    ////////////////////////////////////////////////////////////////////////////////////
+	bool			empty() const
+	{
+		assert(mSize>=0&&mSize<=CAPACITY);
+		return (!mSize);
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Have Any Objects Have Been Added To This Vector?
+    ////////////////////////////////////////////////////////////////////////////////////
+	bool			full() const
+	{
+		assert(mSize>=0&&mSize<=CAPACITY);
+		return (mSize==CAPACITY);
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Clear Out Entire Array
+	////////////////////////////////////////////////////////////////////////////////////
+	void			clear()
+	{
+		mArray.clear();
+		mSize = 0;
+	}
+	// Constant Access Operator
+	////////////////////////////////////////////////////////////////////////////////////
+	const TTValue&		operator[](int index) const
+	{
+		assert(index>=0&&index<mSize);
+		return mArray[index];
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Access Operator
+	////////////////////////////////////////////////////////////////////////////////////
+	TTValue&				operator[](int index)
+	{
+		assert(index>=0&&index<mSize);
+		return mArray[index];
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Access To The Raw Array Pointer
+	////////////////////////////////////////////////////////////////////////////////////
+	TTValue *				raw_array()
+	{
+		  // this (intentionally) won't compile for anything except value semantics
+			// could be done with object semantics, but I would want to assert that all objects are contructed
+		  return T::raw_array(mArray);
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Access To The Raw Array Pointer
+	////////////////////////////////////////////////////////////////////////////////////
+	const TTValue*				raw_array() const
+	{
+		  // this (intentionally) won't compile for anything except value semantics
+			// could be done with object semantics, but I would want to assert that all objects are contructed
+		  return T::raw_array(mArray);
+	}
+
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Assignment Operator
+	////////////////////////////////////////////////////////////////////////////////////
+	vector_base&		operator=(const vector_base& val)
+	{
+		for (int i=0; i<val.size(); i++)
+		{
+			mArray[i] = val.mArray[i];
+		}
+		mSize = val.mSize;
+		return *this;
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Add
+	////////////////////////////////////////////////////////////////////////////////////
+	TTValue &				push_back()
+	{
+		assert(mSize>=0&&mSize<CAPACITY);
+		mArray.construct(mSize);
+		mSize++;
+		return (mArray[mSize-1]);
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Add (And Set)
+	////////////////////////////////////////////////////////////////////////////////////
+	void			push_back(const TTValue& value)
+	{
+		assert(mSize>=0&&mSize<CAPACITY);
+		mArray.construct(mSize,value);
+		mSize++;
+	}
+	
+	////////////////////////////////////////////////////////////////////////////////////
+	// Add raw
+	////////////////////////////////////////////////////////////////////////////////////
+	TRatlNew *			push_back_raw()
+	{
+		assert(mSize>=0&&mSize<CAPACITY);
+		mSize++;
+		return mArray.alloc_raw(mSize-1);
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Remove
+	////////////////////////////////////////////////////////////////////////////////////
+	void			pop_back()
+	{
+		assert(mSize>0);
+		mSize--;
+		mArray.destruct(mSize);
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Resizes The Array.  If New Elements Are Needed, It Uses The (value) Param
+	////////////////////////////////////////////////////////////////////////////////////
+	void			resize(int nSize, const TTValue& value)
+	{
+		int i;
+		for (i=(mSize-1); i>=nSize; i--)
+		{
+			mArray.destruct(i);
+			mSize--;
+		}
+		for (i=mSize; i<nSize; i++)
+		{
+			mArray.construct(i,value);
+		}
+		mSize = nSize;
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Resizes The Array.  If New Elements Are Needed, It Uses The (value) Param
+	////////////////////////////////////////////////////////////////////////////////////
+	void			resize(int nSize)
+	{
+		int i;
+		for (i=mSize-1; i>=nSize; i--)
+		{
+			mArray.destruct(i);
+			mSize--;
+		}
+		for (i=mSize; i<nSize; i++)
+		{
+			mArray.construct(i);
+		}
+		mSize = nSize;
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Swap the values at two locations
+	////////////////////////////////////////////////////////////////////////////////////
+	void swap(int i,int j)
+	{
+		assert(i<mSize && j<mSize);
+		mArray.swap(i, j);
+	}
+
+
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Erase An Iterator Location... NOTE: THIS DOES NOT PRESERVE ORDER IN THE VECTOR!!
+	////////////////////////////////////////////////////////////////////////////////////
+	void erase_swap(int Index)
+	{
+		assert(Index>=0 && Index<mSize);
+		if (Index != mSize - 1)
+		{
+			mArray.swap(Index, mSize - 1);
+		}
+		pop_back();
+	}
+
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Binary Search
+	////////////////////////////////////////////////////////////////////////////////////
+	int				find_index(const TTValue& value) const
+	{
+		int base = 0;
+		int head = mSize-1;
+
+		while (1)
+		{
+			int searchAt = (base+head)/2;
+
+			if (base == head && searchAt == head)
+			{
+				break;
+			}
+
+			if (value < mArray[searchAt])
+			{
+				head = searchAt-1;
+			}
+			else if (mArray[searchAt] < value)
+			{
+				base = searchAt;
+			}
+			else
+			{
+				return searchAt;
+			}
+			if (head < base)
+			{
+				break;
+			}
+		}
+
+		return mSize; //not found!
+	}
+
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Heap Sort
+	//
+	// This sort algorithm has all the advantages of merge sort in terms of guarenteeing
+	// O(n log n) worst case, as well as all the advantages of quick sort in that it is
+	// "in place" and requires no additional storage.
+	//
+	////////////////////////////////////////////////////////////////////////////////////
+	void			sort()
+	{
+		// Temporary Data
+		//----------------
+		int	HeapSize;	// How Large The Heap Is (Grows In PHASE 1, Shrinks In PHASE 2)
+		int	Pos;		// The Location We Are AT During "re-heapify" Loops
+		int	Compare;	// The Location We Are Comparing AGAINST During "re-heapify" Loops
+
+
+
+
+		// PHASE 1, CONSTRUCT THE HEAP										  O(n log n)
+		//===============================================================================
+		for (HeapSize=1; HeapSize<mSize; HeapSize++)
+		{
+			// We Now Have An Element At Heap Size Which Is Not In It's Correct Place
+			//------------------------------------------------------------------------
+			Pos		= HeapSize;
+			Compare	= parent(Pos);
+			while (mArray[Compare]<mArray[Pos])
+			{
+				// Swap The Compare Element With The Pos Element
+				//-----------------------------------------------
+				mArray.swap(Compare, Pos);
+
+				// Move Pos To The Current Compare, And Recalc Compare
+				//------------------------------------------------------
+				Pos		= Compare;
+				Compare = parent(Pos);
+			}
+		}
+
+	
+
+
+		// PHASE 2, POP OFF THE TOP OF THE HEAP ONE AT A TIME (AND FIX)       O(n log n)
+		//===============================================================================
+		for (HeapSize=(mSize-1); HeapSize>0; HeapSize--)
+		{
+			// Swap The End And Front Of The "Heap" Half Of The Array
+			//--------------------------------------------------------
+			mArray.swap(0, HeapSize);
+
+			// We Now Have A Bogus Element At The Root, So Fix The Heap
+			//----------------------------------------------------------
+			Pos		= 0;
+			Compare = largest_child(Pos, HeapSize);
+			while (mArray[Pos]<mArray[Compare])
+			{
+				// Swap The Compare Element With The Pos Element
+				//-----------------------------------------------
+				mArray.swap(Compare, Pos);
+
+				// Move Pos To The Current Compare, And Recalc Compare
+				//------------------------------------------------------
+				Pos		= Compare;
+				Compare	= largest_child(Pos, HeapSize);
+			}
+		}
+	}
+
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// THIS IS A QUICK VALIDATION OF A SORTED LIST
+	////////////////////////////////////////////////////////////////////////////////////
+#ifdef _DEBUG
+	void			sort_validate() const
+	{
+		for (int a=0; a<(mSize-1); a++)
+		{
+			assert(mArray[a] < mArray[a+1]);
+		}
+	}
+#endif
+
+private:
+	////////////////////////////////////////////////////////////////////////////////////
+	// For Heap Sort
+	// Returns The Location Of Node (i)'s Parent Node (The Parent Node Of Zero Is Zero)
+	////////////////////////////////////////////////////////////////////////////////////
+	static int			parent(int i)				
+	{
+		return ((i-1)/2);
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// For Heap Sort
+	// Returns The Location Of Node (i)'s Left Child (The Child Of A Leaf Is The Leaf)
+	////////////////////////////////////////////////////////////////////////////////////
+	static int			left(int i)	
+	{
+		return ((2*i)+1);
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// For Heap Sort
+	// Returns The Location Of Node (i)'s Right Child (The Child Of A Leaf Is The Leaf)
+	////////////////////////////////////////////////////////////////////////////////////
+	static int			right(int i)
+	{
+		return ((2*i)+2);
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// For Heap Sort
+	// Returns The Location Of Largest Child Of Node (i)
+	////////////////////////////////////////////////////////////////////////////////////
+	int			largest_child(int i, int Size) const
+	{
+		if (left(i)<Size)
+		{
+			if (right(i)<Size)
+			{
+				return ( (mArray[right(i)] < mArray[left(i)]) ? (left(i)) : (right(i)) );
+			}
+			return left(i);	// Node i only has a left child, so by default it is the biggest
+		}
+		return i;		// Node i is a leaf, so just return it
+	}
+
+public:
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Iterator
+    ////////////////////////////////////////////////////////////////////////////////////
+	class const_iterator;
+	class iterator
+	{
+		friend class vector_base<T>;
+		friend class const_iterator;
+		// Data
+		//------
+		int						mLoc;
+		vector_base<T>*			mOwner;
+
+	public:
+		// Constructors
+		//--------------
+		iterator()						: mOwner(0), mLoc(0)
+		{}
+		iterator(vector_base<T>* p, int t)	: mOwner(p), mLoc(t)
+		{}
+
+		iterator(const iterator &t)		: mOwner(t.mOwner), mLoc(t.mLoc)
+		{}
+
+		// Assignment Operator
+		//---------------------
+		void		operator= (const iterator &t)
+		{
+			mOwner	= t.mOwner;	
+			mLoc	= t.mLoc;
+		}
+
+
+		// Equality Operators
+		//--------------------
+		bool		operator!=(const iterator &t)	const
+		{
+			return (mLoc!=t.mLoc  || mOwner!=t.mOwner);
+		}
+		bool		operator==(const iterator &t)	const				
+		{
+			return (mLoc==t.mLoc && mOwner==t.mOwner);
+		}
+
+		// DeReference Operator
+		//----------------------
+		TTValue&			operator* ()	const			
+		{
+			assert(mLoc>=0 && mLoc<mOwner->mSize);
+			return (mOwner->mArray[mLoc]);
+		}
+		// DeReference Operator
+		//----------------------
+		TTValue&			value()	const			
+		{
+			assert(mLoc>=0 && mLoc<mOwner->mSize);
+			return (mOwner->mArray[mLoc]);
+		}
+
+		// DeReference Operator
+		//----------------------
+		TTValue*			operator-> ()	const			
+		{
+			assert(mLoc>=0 && mLoc<mOwner->mSize);
+			return (&mOwner->mArray[mLoc]);
+		}
+
+		// Inc Operator
+		//--------------
+		iterator	operator++(int) //postfix
+		{
+			assert(mLoc>=0 && mLoc<mOwner->mSize);
+			iterator old(*this);
+			mLoc ++;
+			return old;
+		}
+
+		// Inc Operator
+		//--------------
+		iterator	operator++()
+		{
+			assert(mLoc>=0 && mLoc<mOwner->mSize);
+			mLoc ++;
+			return *this;
+		}
+
+	};
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Constant Iterator
+    ////////////////////////////////////////////////////////////////////////////////////
+	class const_iterator
+	{
+		friend class vector_base<T>;
+
+		int							mLoc;
+		const vector_base<T>*		mOwner;
+
+	public:
+		// Constructors
+		//--------------
+		const_iterator()							: mOwner(0), mLoc(0)
+		{}
+		const_iterator(const vector_base<T>* p, int t)	: mOwner(p), mLoc(t)
+		{}
+		const_iterator(const const_iterator &t)		: mOwner(t.mOwner), mLoc(t.mLoc)
+		{}
+		const_iterator(const iterator &t)			: mOwner(t.mOwner), mLoc(t.mLoc)
+		{}
+
+		// Assignment Operator
+		//---------------------
+		void		operator= (const const_iterator &t)
+		{
+			mOwner	= t.mOwner;	
+			mLoc	= t.mLoc;
+		}
+		// Assignment Operator
+		//---------------------
+		void		operator= (const iterator &t)
+		{
+			mOwner	= t.mOwner;	
+			mLoc	= t.mLoc;
+		}
+
+
+
+		// Equality Operators
+		//--------------------
+		bool		operator!=(const iterator &t)		const
+		{
+			return (mLoc!=t.mLoc  || mOwner!=t.mOwner);
+		}
+		bool		operator==(const iterator &t)		const				
+		{
+			return (mLoc==t.mLoc && mOwner==t.mOwner);
+		}
+
+		// Equality Operators
+		//--------------------
+		bool		operator!=(const const_iterator &t)		const
+		{
+			return (mLoc!=t.mLoc || mOwner!=t.mOwner);
+		}
+		bool		operator==(const const_iterator &t)		const				
+		{
+			return (mLoc==t.mLoc  && mOwner==t.mOwner);
+		}
+
+		// DeReference Operator
+		//----------------------
+		const TTValue&			operator* ()		const
+		{
+			assert(mLoc>=0 && mLoc<mOwner->mSize);
+			return (mOwner->mArray[mLoc]);
+		}
+
+		// DeReference Operator
+		//----------------------
+		const TTValue&			value()		const
+		{
+			assert(mLoc>=0 && mLoc<mOwner->mSize);
+			return (mOwner->mArray[mLoc]);
+		}
+
+		// DeReference Operator
+		//----------------------
+		const TTValue*			operator-> ()		const
+		{
+			assert(mLoc>=0 && mLoc<mOwner->mSize);
+			return (&mOwner->mArray[mLoc]);
+		}
+
+		// Inc Operator
+		//--------------
+		const_iterator operator++(int)
+		{
+			assert(mLoc>=0 && mLoc<mOwner->mSize);
+			const_iterator old(*this);
+			mLoc ++;
+			return old;
+		}
+
+		// Inc Operator
+		//--------------
+		const_iterator operator++()
+		{
+			assert(mLoc>=0 && mLoc<mOwner->mSize);
+			mLoc ++;
+			return *this;
+		}
+
+
+	};
+	friend class				iterator;
+	friend class				const_iterator;
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Iterator Begin (Starts At Address 0)
+    ////////////////////////////////////////////////////////////////////////////////////
+	iterator	begin()
+	{
+		return iterator(this, 0);
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Iterator End (Set To Address mSize)
+    ////////////////////////////////////////////////////////////////////////////////////
+	iterator	end()
+	{
+		return iterator(this, mSize);
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Iterator Begin (Starts At Address 0)
+    ////////////////////////////////////////////////////////////////////////////////////
+	const_iterator	begin() const
+	{
+		return const_iterator(this, 0);
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Iterator End (Set To Address mSize)
+    ////////////////////////////////////////////////////////////////////////////////////
+	const_iterator	end() const
+	{
+		return const_iterator(this, mSize);
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Iterator Find (If Fails To Find, Returns iterator end()
+	////////////////////////////////////////////////////////////////////////////////////
+	iterator	find(const TTValue& value)
+	{
+		int		index = find_index(value);		// Call Find By Index
+		if (index<mSize)
+		{
+			return iterator(this, index);		// Found It, Return An Iterator To Index
+		}
+		return end();							// Return "end" Iterator If Not Found
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Iterator Find (If Fails To Find, Returns iterator end()
+	////////////////////////////////////////////////////////////////////////////////////
+	const_iterator	find(const TTValue& value) const
+	{
+		int		index = find_index(value);		// Call Find By Index
+		if (index<mSize)
+		{
+			return const_iterator(this, index);		// Found It, Return An Iterator To Index
+		}
+		return end();							// Return "end" Iterator If Not Found
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Erase An Iterator Location... NOTE: THIS DOES NOT PRESERVE ORDER IN THE VECTOR!!
+	////////////////////////////////////////////////////////////////////////////////////
+	iterator erase_swap(const iterator &it)
+	{
+		assert(it.mLoc>=0 && it.mLoc<it.mOwner->mSize);
+		if (it.mLoc != mSize - 1)
+		{
+			mArray.swap(it.mLoc, mSize - 1);
+		}
+		pop_back();
+		return it;
+	}
+	template<class CAST_TO>
+	CAST_TO *verify_alloc(CAST_TO *p) const
+	{
+		return mArray.verify_alloc(p);
+	}
+};
+
+template<class T, int ARG_CAPACITY>
+class vector_vs : public vector_base<storage::value_semantics<T,ARG_CAPACITY> >
+{
+public:
+	typedef typename storage::value_semantics<T,ARG_CAPACITY> TStorageTraits;
+	typedef typename TStorageTraits::TValue TTValue;
+ 	enum 
+	{
+		CAPACITY		= ARG_CAPACITY
+	};
+	vector_vs() {}
+};
+
+template<class T, int ARG_CAPACITY>
+class vector_os : public vector_base<storage::object_semantics<T,ARG_CAPACITY> >
+{
+public:
+	typedef typename storage::object_semantics<T,ARG_CAPACITY> TStorageTraits;
+	typedef typename TStorageTraits::TValue TTValue;
+ 	enum 
+	{
+		CAPACITY		= ARG_CAPACITY
+	};
+	vector_os() {}
+};
+
+template<class T, int ARG_CAPACITY, int ARG_MAX_CLASS_SIZE>
+class vector_is : public vector_base<storage::virtual_semantics<T,ARG_CAPACITY,ARG_MAX_CLASS_SIZE> >
+{
+public:
+	typedef typename storage::virtual_semantics<T,ARG_CAPACITY,ARG_MAX_CLASS_SIZE> TStorageTraits;
+	typedef typename TStorageTraits::TValue TTValue;
+ 	enum 
+	{
+		CAPACITY		= ARG_CAPACITY,
+		MAX_CLASS_SIZE	= ARG_MAX_CLASS_SIZE
+	};
+	vector_is() {}
+};
+
+}
+#endif
diff --git a/codemp/Ratl/vssver.scc b/codemp/Ratl/vssver.scc
new file mode 100644
index 0000000..1139239
Binary files /dev/null and b/codemp/Ratl/vssver.scc differ
diff --git a/codemp/Ravl/CVec.h b/codemp/Ravl/CVec.h
new file mode 100644
index 0000000..4deb525
--- /dev/null
+++ b/codemp/Ravl/CVec.h
@@ -0,0 +1,1002 @@
+////////////////////////////////////////////////////////////////////////////////////////
+// RAVEN STANDARD TEMPLATE LIBRARY
+//  (c) 2002 Activision
+//
+//
+// Vector Library
+// --------------
+// The base implimention of the Raven Vector object attempts to solve a number of
+// high level problems as efficiently as possible.  Where ever feasible, functions have
+// been included in the .h file so the compiler can inline them.
+// 
+// The vectors define the following operations:
+//  - Construction
+//  - Initialization
+//  - Member Access
+//  - Equality / Inequality Operators
+//  - Arithimitic Operators
+//  - Length & Distance
+//  - Normalization (Standard, Safe, Angular)
+//  - Dot & Cross Product
+//  - Perpendicular Vector
+//  - Truncation
+//  - Min & Max Element Analisis
+//  - Interpolation
+//  - Angle / Vector Conversion
+//  - Translation & Rotation
+//  - Point and Line Intersection Tests
+//  - Left / Right Line Test
+//  - String Operations
+//  - Debug Routines
+//  - "Standard" Vectors As Static Memebers
+//
+// As necessary, some projects may #define special faster versions of these routines to
+// make better use of native hardware / software implimentations.
+//
+//
+//
+//
+// NOTES:
+// 05/29/02 - CREATED
+// 05/30/02 - RotatePoint() is currently unimplimented.  Waiting for Matrix Library
+//
+//
+////////////////////////////////////////////////////////////////////////////////////////
+#if !defined(RAVL_VEC_INC)
+#define RAVL_VEC_INC
+//namespace ravl
+//{
+
+
+template <class T> T	Min(const T& a, const T& b)	{return (a<b)?(a):(b);}
+template <class T> T	Max(const T& a, const T& b)	{return (b<a)?(a):(b);}
+
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Defines
+////////////////////////////////////////////////////////////////////////////////////////
+#define		RAVL_VEC_UDF					(1.234567E-10f)						// Undefined Vector Value (for debugging)
+#define		RAVL_VEC_PI						(3.1415926535f)						// Pi
+#define		RAVL_VEC_DEGTORADCONST			(0.0174532925f)						// (RAVL_VEC_PI / 180.0f)
+#define		RAVL_VEC_RADTODEGCONST			(57.295779514f)						// (180.0f / RAVL_VEC_PI)
+#define		RAVL_VEC_DEGTORAD( a )			( (a) * RAVL_VEC_DEGTORADCONST )	// Quick Macro For Degrees -> Radians
+#define		RAVL_VEC_RADTODEG( a )			( (a) * RAVL_VEC_RADTODEGCONST )	// Quick Macro For Radians -> Degrees
+
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Enums And Typedefs
+////////////////////////////////////////////////////////////////////////////////////////
+enum	ESide
+{
+	Side_None	= 0,
+	Side_Left	= 1,
+	Side_Right	= 2,
+	Side_In		= 3, 
+	Side_Out	= 4,
+	Side_AllIn	= 5
+};
+
+
+
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// The 4 Dimensional Vector
+////////////////////////////////////////////////////////////////////////////////////////
+class CVec4
+{
+public:
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Constructors
+    ////////////////////////////////////////////////////////////////////////////////////
+#ifndef _DEBUG
+	CVec4()																	{}
+#else
+	CVec4()																	{v[0]=v[1]=v[2]=v[3]=RAVL_VEC_UDF;}		// DEBUG INITIALIZATION
+#endif	
+	CVec4(const float val)													{v[0]=val;		v[1]=val;		v[2]=val;		v[3]=val;}
+	CVec4(const float x,const float y,const float z, const float r)			{v[0]=x;		v[1]=y;			v[2]=z;			v[3]=r;}
+	CVec4(const CVec4& t)													{v[0]=t.v[0];	v[1]=t.v[1];	v[2]=t.v[2];	v[3]=t.v[3];}
+	CVec4(const float *t)													{v[0]=t[0];		v[1]=t[1];		v[2]=t[2];		v[3]=t[3];}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Initializers
+    ////////////////////////////////////////////////////////////////////////////////////
+	void Set(const float t)													{v[0]=t;		v[1]=t;			v[2]=t;			v[3]=t;}
+	void Set(const float *t)												{v[0]=t[0];		v[1]=t[1];		v[2]=t[2];		v[3]=t[3];}
+	void Set(const float x,const float y,const float z, const float r)		{v[0]=x;		v[1]=y;			v[2]=z;			v[3]=r;}
+	void Clear()															{v[0]=0;		v[1]=0;			v[2]=0;			v[3]=0;}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Member Accessors
+    ////////////////////////////////////////////////////////////////////////////////////
+	const float& operator[](int i) const 									{return v[i];}
+	float& operator[](int i)												{return v[i];}
+	float& pitch()															{return v[0];}
+	float& yaw()															{return v[1];}
+	float& roll()															{return v[2];}
+	float& radius()															{return v[3];}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Equality / Inequality Operators
+    ////////////////////////////////////////////////////////////////////////////////////
+	bool operator!  () const												{return	!(v[0]         && v[1]         && v[2]         && v[3]        );}
+	bool operator== (const CVec4& t) const									{return	 (v[0]==t.v[0] && v[1]==t.v[1] && v[2]==t.v[2] && v[3]==t.v[3]);}
+	bool operator!= (const CVec4& t) const									{return !(v[0]==t.v[0] && v[1]==t.v[1] && v[2]==t.v[2] && v[3]==t.v[3]);}
+	bool operator<  (const CVec4& t) const									{return	 (v[0]< t.v[0] && v[1]< t.v[1] && v[2]< t.v[2] && v[3]< t.v[3]);}
+	bool operator>  (const CVec4& t) const									{return	 (v[0]> t.v[0] && v[1]> t.v[1] && v[2]> t.v[2] && v[3]> t.v[3]);}
+	bool operator<= (const CVec4& t) const									{return	 (v[0]<=t.v[0] && v[1]<=t.v[1] && v[2]<=t.v[2] && v[3]<=t.v[3]);}
+	bool operator>= (const CVec4& t) const									{return	 (v[0]>=t.v[0] && v[1]>=t.v[1] && v[2]>=t.v[2] && v[3]>=t.v[3]);}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Basic Arithimitic Operators
+    ////////////////////////////////////////////////////////////////////////////////////
+	const CVec4 &operator=  (const float d)									{v[0]=d;		v[1]=d;			v[2]=d;			v[3]=d;		 return *this;}
+	const CVec4 &operator=  (const CVec4& t)								{v[0]=t.v[0];	v[1]=t.v[1];	v[2]=t.v[2];	v[3]=t.v[3]; return *this;}
+
+	const CVec4 &operator+= (const float d)									{v[0]+=d;		v[1]+=d;		v[2]+=d;		v[3]+=d;	 return *this;}
+	const CVec4 &operator+= (const CVec4& t)								{v[0]+=t.v[0];	v[1]+=t.v[1];	v[2]+=t.v[2];	v[3]+=t.v[3];return *this;}
+
+	const CVec4 &operator-= (const float d)									{v[0]-=d;		v[1]-=d;		v[2]-=d; 		v[3]-=d;	 return *this;}
+	const CVec4 &operator-= (const CVec4& t)								{v[0]-=t.v[0];	v[1]-=t.v[1];	v[2]-=t.v[2];	v[3]-=t.v[3];return *this;}
+
+	const CVec4 &operator*= (const float d)									{v[0]*=d;		v[1]*=d;		v[2]*=d;		v[3]*=d;	 return *this;}
+	const CVec4 &operator*= (const CVec4& t)								{v[0]*=t.v[0];	v[1]*=t.v[1];	v[2]*=t.v[2];	v[3]*=t.v[3];return *this;}
+
+	const CVec4 &operator/= (const float d)									{v[0]/=d;		v[1]/=d;		v[2]/=d;		v[3]/=d;	 return *this;}
+	const CVec4 &operator/= (const CVec4& t)								{v[0]/=t.v[0];	v[1]/=t.v[1];	v[2]/=t.v[2];	v[3]/=t.v[3];return *this;}
+
+	inline CVec4 operator+ (const CVec4 &t) const							{return CVec4(v[0]+t.v[0], v[1]+t.v[1], v[2]+t.v[2], v[3]+t.v[3]);}
+	inline CVec4 operator- (const CVec4 &t) const							{return CVec4(v[0]-t.v[0], v[1]-t.v[1], v[2]-t.v[2], v[3]-t.v[3]);}
+	inline CVec4 operator* (const CVec4 &t) const							{return CVec4(v[0]*t.v[0], v[1]*t.v[1], v[2]*t.v[2], v[3]*t.v[3]);}
+	inline CVec4 operator/ (const CVec4 &t) const							{return CVec4(v[0]/t.v[0], v[1]/t.v[1], v[2]/t.v[2], v[3]/t.v[3]);}
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Length And Distance Calculations
+    ////////////////////////////////////////////////////////////////////////////////////
+	float	Len() const;
+	float	Len2() const													{return (v[0]*v[0]+v[1]*v[1]+v[2]*v[2]+v[3]*v[3]);}
+
+	float	Dist(const CVec4& t) const;
+	float	Dist2(const CVec4& t) const										{return ((t.v[0]-v[0])*(t.v[0]-v[0]) + (t.v[1]-v[1])*(t.v[1]-v[1]) + (t.v[2]-v[2])*(t.v[2]-v[2]) + (t.v[3]-v[3])*(t.v[3]-v[3]) );}
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Normalization
+    ////////////////////////////////////////////////////////////////////////////////////
+	float	Norm();
+	float	SafeNorm();
+	void	AngleNorm();
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Dot, Cross & Perpendicular Vector
+    ////////////////////////////////////////////////////////////////////////////////////
+	float	Dot(const CVec4& t) const										{return (v[0]*t.v[0] + v[1]*t.v[1] + v[2]*t.v[2] + v[3]*t.v[3]);}
+	void	Cross(const CVec4& t)
+	{
+		CVec4 temp(*this);
+		v[0] = (temp.v[1]*t.v[2]) - (temp.v[2]*t.v[1]);
+		v[1] = (temp.v[2]*t.v[0]) - (temp.v[0]*t.v[2]);
+		v[2] = (temp.v[0]*t.v[1]) - (temp.v[1]*t.v[0]);
+		v[3] = 0;
+	}
+	void	Perp();
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Truncation & Element Analysis
+    ////////////////////////////////////////////////////////////////////////////////////
+	void	Min(const CVec4& t)
+	{
+		if (t.v[0]<v[0])			v[0]=t.v[0];	
+		if (t.v[1]<v[1])			v[1]=t.v[1];	
+		if (t.v[2]<v[2])			v[2]=t.v[2];	
+		if (t.v[3]<v[3])			v[3]=t.v[3];	
+	}
+	void	Max(const CVec4& t)
+	{
+		if (t.v[0]>v[0])			v[0]=t.v[0];	
+		if (t.v[1]>v[1])			v[1]=t.v[1];	
+		if (t.v[2]>v[2])			v[2]=t.v[2];	
+		if (t.v[3]>v[3])			v[3]=t.v[3];	
+	}
+	float	MaxElement() const
+	{
+			return v[MaxElementIndex()];	
+	}
+	int		MaxElementIndex() const;
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Interpolation
+    ////////////////////////////////////////////////////////////////////////////////////
+	void	Interp(const CVec4 &v1, const CVec4 &v2, const float t)
+	{
+		(*this)=v1;
+		(*this)-=v2;
+		(*this)*=t;
+		(*this)+=v2;
+	}
+	void	ScaleAdd(const CVec4& t, const float scale)
+	{
+		v[0] += (scale * t.v[0]);
+		v[1] += (scale * t.v[1]);
+		v[2] += (scale * t.v[2]);
+		v[3] += (scale * t.v[3]);
+	}
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Conversion Angle To Vector (Angle In Degrees)
+    ////////////////////////////////////////////////////////////////////////////////////
+	void	VecToAng();
+	void	AngToVec();
+	void	AngToVec(CVec4& Right, CVec4& Up);
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Conversion Angle To Vector (Angle In Radians)
+    ////////////////////////////////////////////////////////////////////////////////////
+	void	VecToAngRad();
+	void	AngToVecRad();
+	void	AngToVecRad(CVec4& Right, CVec4& Up);
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Conversion Between Radians And Degrees
+    ////////////////////////////////////////////////////////////////////////////////////
+	void	ToRadians();
+	void	ToDegrees();
+
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Project
+	//
+	// Standard projection function.  Take the (this) and project it onto the vector
+	// (U).  Imagine drawing a line perpendicular to U from the endpoint of the (this)
+	// Vector.  That then becomes the new vector.
+	//
+	// The value returned is the scale of the new vector with respect to the one passed
+	// to the function.  If the scale is less than (1.0) then the new vector is shorter 
+	// than (U).  If the scale is negative, then the vector is going in the opposite 
+	// direction of (U).
+	//
+	//               _  (U)
+	//               /|
+	//             /                                        _ (this)
+	//           /                      RESULTS->           /|
+	//         /                                          /
+	//       /    __\ (this)                            /
+	//     /___---  /                                 /
+	//
+    ////////////////////////////////////////////////////////////////////////////////////
+	float	Project(const CVec4 &U)
+	{
+		float	Scale = (Dot(U) / U.Len2());	// Find the scale of this vector on U
+		(*this)=U;								// Copy U onto this vector
+		(*this)*=Scale;							// Use the previously calculated scale to get the right length.
+		return Scale;
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Project To Line
+	//
+	// This function takes two other points in space as the start and end of a line
+	// segment and projects the (this) point onto the line defined by (Start)->(Stop)
+	//
+	// RETURN VALUES:
+	//   (-INF, 0.0)  : (this) landed on the line before (Start)
+	//   (0.0, 1.0)   : (this) landed in the line segment between (Start) and (Stop)
+	//   (1.0, INF)   : (this) landed on the line beyond (End)
+	//
+	//             (Stop)
+	//               /
+	//             /
+	//           o _
+	//         /  |\
+	//       /     (this)
+	//     / 
+	// (Start)
+	//
+    ////////////////////////////////////////////////////////////////////////////////////
+	float	ProjectToLine(const CVec4 &Start, const CVec4 &Stop)
+	{
+		(*this) -= Start;
+		float	Scale = Project(Stop - Start);
+		(*this) += Start;
+		return Scale;
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+    // Project To Line Seg 
+	//
+	// Same As Project To Line, Except It Will Clamp To Start And Stop
+	////////////////////////////////////////////////////////////////////////////////////
+	float	ProjectToLineSeg(const CVec4 &Start, const CVec4 &Stop)
+	{
+		float Scale = ProjectToLine(Start, Stop);
+		if (Scale<0.0f)
+		{
+			(*this) = Start;
+		}
+		else if (Scale>1.0f)
+		{
+			(*this) = Stop;
+		}
+		return Scale;
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Distance To Line
+	//
+	// Uses project to line and than calculates distance to the new point
+	////////////////////////////////////////////////////////////////////////////////////
+	float	DistToLine(const CVec4 &Start, const CVec4 &Stop) const
+	{
+		CVec4	P(*this);
+		P.ProjectToLineSeg(Start, Stop);
+
+		return Dist(P);
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Distance To Line
+	//
+	// Uses project to line and than calculates distance to the new point
+	////////////////////////////////////////////////////////////////////////////////////
+	float	DistToLine2(const CVec4 &Start, const CVec4 &Stop) const
+	{
+		CVec4	P(*this);
+		P.ProjectToLineSeg(Start, Stop);
+
+		return Dist2(P);
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Translation & Rotation (2D)
+    ////////////////////////////////////////////////////////////////////////////////////
+	void	RotatePoint(const CVec4 &Angle, const CVec4 &Origin);
+	void	Reposition(const CVec4 &Translation, float RotationDegrees=0.0);
+
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Area Of The Parallel Pipid (2D)
+	//
+	// Given two more points, this function calculates the area of the parallel pipid
+	// formed.
+	//
+	// Note: This function CAN return a negative "area" if (this) is above or right of
+	// (A) and (B)...  We do not take the abs because the sign of the "area" is needed
+	// for the left right test (see below)
+	//
+	//
+	//               ___---( ... )
+	//        (A)---/        /
+	//        /             /
+	//       /             /
+	//      /             /
+	//     /      ___---(B)
+	//  (this)---/
+	//
+    ////////////////////////////////////////////////////////////////////////////////////
+	float	AreaParallelPipid(const CVec4 &A, const CVec4 &B) const
+	{
+		return ((A.v[0]*B.v[1] - A.v[1]*B.v[0]) + 
+			    (B.v[0]*  v[1] -   v[0]*B.v[1]) + 
+				(  v[0]*A.v[1] - A.v[0]*  v[1]));
+	}
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Area Of The Triangle (2D)
+	//
+	// Given two more points, this function calculates the area of the triangle formed.
+	//
+	//        (A)
+	//        /  \__
+	//       /      \__
+	//      /          \_
+	//     /      ___---(B)
+	//  (this)---/
+	//
+    ////////////////////////////////////////////////////////////////////////////////////
+	float	AreaTriange(const CVec4 &A, const CVec4 &B) const
+	{
+		return (AreaParallelPipid(A, B) * 0.5f);
+	}
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// The Left Right Test (2D)
+	//
+	// Given a line segment (Start->End) and a tolerance for *right on*, this function
+	// evaluates which side the point is of the line.  (Side_Left in this example)
+	//
+	//
+	//
+	//          (this)        ___---/(End)
+	//                 ___---/
+	//          ___---/
+	//  (Start)/
+	//  
+    ////////////////////////////////////////////////////////////////////////////////////
+	ESide	LRTest(const CVec4 &Start, const CVec4 &End, float Tolerance=0.0) const
+	{	
+		float Area = AreaParallelPipid(Start, End);
+		if (Area>Tolerance)
+		{
+			return Side_Left;
+		}
+		if (Area<(Tolerance*-1))
+		{
+			return Side_Right;
+		}
+		return Side_None;
+
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Point In Circumscribed Circle  (True/False)
+	//
+	//  Returns true if the given point is within the circumscribed
+	//  circle of the given ABC Triangle:
+	//         _____  
+	//        /   B \
+	//      /   /   \ \
+	//     |  /      \ |
+	//     |A---------C|
+	//      \    Pt   /
+	//       \_______/
+	//  
+	////////////////////////////////////////////////////////////////////////////////////
+	bool	PtInCircle(const CVec4 &A, const CVec4 &B, const CVec4 &C) const;
+
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Point In Standard Circle  (True/False)
+	//
+	//  Returns true if the given point is within the Circle
+	//         _____  
+	//        /     \
+	//      /         \
+	//     |   Circle  |
+	//     |           |
+	//      \    Pt   /
+	//       \_______/
+	//  
+	////////////////////////////////////////////////////////////////////////////////////
+	bool	PtInCircle(const CVec4 &Circle, float Radius) const;
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Line Intersects Circle  (True/False)
+	//
+	//  r	- Radius Of The Circle
+	//  A	- Start Of Line Segment
+	//  B	- End Of Line Segment
+	//
+	//  P	- Projected Position Of Origin Onto Line AB
+	//
+	//
+	//            (Stop)
+	//              /
+	//            /
+	//         (P)
+	//        /   \      \
+	//      /   (this)-r->|
+	//    /              /
+	// (Start)
+	//
+	////////////////////////////////////////////////////////////////////////////////////
+	bool	LineInCircle(const CVec4 &Start, const CVec4 &Stop, float Radius);
+	bool	LineInCircle(const CVec4 &Start, const CVec4 &Stop, float Radius, CVec4 &PointOnLine);
+
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// String Operations
+    ////////////////////////////////////////////////////////////////////////////////////
+	void	FromStr(const char *s);
+	void	ToStr(char* s) const;
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Debug Routines
+    ////////////////////////////////////////////////////////////////////////////////////
+#ifdef _DEBUG
+	bool	IsFinite();
+	bool	IsInitialized();
+#endif
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Data
+    ////////////////////////////////////////////////////////////////////////////////////
+private:
+	float v[4];
+
+
+public:
+	static const CVec4 mX;
+	static const CVec4 mY;
+	static const CVec4 mZ;
+	static const CVec4 mW;
+	static const CVec4 mZero;
+};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// The 3 Dimensional Vector
+////////////////////////////////////////////////////////////////////////////////////////
+class CVec3
+{
+public:
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Constructors
+    ////////////////////////////////////////////////////////////////////////////////////
+#ifndef _DEBUG
+	CVec3()																	{}
+#else
+	CVec3()																	{v[0]=v[1]=v[2]=RAVL_VEC_UDF;}		// DEBUG INITIALIZATION
+#endif	
+	CVec3(const float val)													{v[0]=val;		v[1]=val;		v[2]=val;	}
+	CVec3(const float x,const float y,const float z)						{v[0]=x;		v[1]=y;			v[2]=z;		}
+	CVec3(const CVec3& t)													{v[0]=t.v[0];	v[1]=t.v[1];	v[2]=t.v[2];}
+	CVec3(const float *t)													{v[0]=t[0];		v[1]=t[1];		v[2]=t[2];	}
+
+	float	x()		const													{return v[0];}
+	float	y()		const													{return v[1];}
+	float	z()		const													{return v[2];}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Initializers
+    ////////////////////////////////////////////////////////////////////////////////////
+	void Set(const float t)													{v[0]=t;		v[1]=t;			v[2]=t;		}
+	void Set(const float *t)												{v[0]=t[0];		v[1]=t[1];		v[2]=t[2];	}
+	void Set(const float x,const float y,const float z)						{v[0]=x;		v[1]=y;			v[2]=z;		}
+	void Clear()															{v[0]=0;		v[1]=0;			v[2]=0;		}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Member Accessors
+    ////////////////////////////////////////////////////////////////////////////////////
+	const float& operator[](int i) const 									{return v[i];}
+	float& operator[](int i)												{return v[i];}
+	float& pitch()															{return v[0];}
+	float& yaw()															{return v[1];}
+	float& roll()															{return v[2];}
+	float& radius()															{return v[3];}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Equality / Inequality Operators
+    ////////////////////////////////////////////////////////////////////////////////////
+	bool operator!  () const												{return	!(v[0]         && v[1]         && v[2]        );}
+	bool operator== (const CVec3& t) const									{return	 (v[0]==t.v[0] && v[1]==t.v[1] && v[2]==t.v[2]);}
+	bool operator!= (const CVec3& t) const									{return !(v[0]==t.v[0] && v[1]==t.v[1] && v[2]==t.v[2]);}
+	bool operator<  (const CVec3& t) const									{return	 (v[0]< t.v[0] && v[1]< t.v[1] && v[2]< t.v[2]);}
+	bool operator>  (const CVec3& t) const									{return	 (v[0]> t.v[0] && v[1]> t.v[1] && v[2]> t.v[2]);}
+	bool operator<= (const CVec3& t) const									{return	 (v[0]<=t.v[0] && v[1]<=t.v[1] && v[2]<=t.v[2]);}
+	bool operator>= (const CVec3& t) const									{return	 (v[0]>=t.v[0] && v[1]>=t.v[1] && v[2]>=t.v[2]);}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Basic Arithimitic Operators
+    ////////////////////////////////////////////////////////////////////////////////////
+	const CVec3 &operator=  (const float d)									{v[0]=d;		v[1]=d;			v[2]=d;		 return *this;}
+	const CVec3 &operator=  (const CVec3& t)								{v[0]=t.v[0];	v[1]=t.v[1];	v[2]=t.v[2]; return *this;}
+
+	const CVec3 &operator+= (const float d)									{v[0]+=d;		v[1]+=d;		v[2]+=d;	 return *this;}
+	const CVec3 &operator+= (const CVec3& t)								{v[0]+=t.v[0];	v[1]+=t.v[1];	v[2]+=t.v[2];return *this;}
+
+	const CVec3 &operator-= (const float d)									{v[0]-=d;		v[1]-=d;		v[2]-=d; 	 return *this;}
+	const CVec3 &operator-= (const CVec3& t)								{v[0]-=t.v[0];	v[1]-=t.v[1];	v[2]-=t.v[2];return *this;}
+
+	const CVec3 &operator*= (const float d)									{v[0]*=d;		v[1]*=d;		v[2]*=d;	 return *this;}
+	const CVec3 &operator*= (const CVec3& t)								{v[0]*=t.v[0];	v[1]*=t.v[1];	v[2]*=t.v[2];return *this;}
+
+	const CVec3 &operator/= (const float d)									{v[0]/=d;		v[1]/=d;		v[2]/=d;	 return *this;}
+	const CVec3 &operator/= (const CVec3& t)								{v[0]/=t.v[0];	v[1]/=t.v[1];	v[2]/=t.v[2];return *this;}
+
+	inline CVec3 operator+ (const CVec3 &t) const							{return CVec3(v[0]+t.v[0], v[1]+t.v[1], v[2]+t.v[2]);}
+	inline CVec3 operator- (const CVec3 &t) const							{return CVec3(v[0]-t.v[0], v[1]-t.v[1], v[2]-t.v[2]);}
+	inline CVec3 operator* (const CVec3 &t) const							{return CVec3(v[0]*t.v[0], v[1]*t.v[1], v[2]*t.v[2]);}
+	inline CVec3 operator/ (const CVec3 &t) const							{return CVec3(v[0]/t.v[0], v[1]/t.v[1], v[2]/t.v[2]);}
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Length And Distance Calculations
+    ////////////////////////////////////////////////////////////////////////////////////
+	float	Len() const;
+	float	Len2() const													{return (v[0]*v[0]+v[1]*v[1]+v[2]*v[2]);}
+
+	float	Dist(const CVec3& t) const;
+	float	Dist2(const CVec3& t) const										{return ((t.v[0]-v[0])*(t.v[0]-v[0]) + (t.v[1]-v[1])*(t.v[1]-v[1]) + (t.v[2]-v[2])*(t.v[2]-v[2]));}
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Normalization
+    ////////////////////////////////////////////////////////////////////////////////////
+	float	Norm();
+	float	SafeNorm();
+	void	AngleNorm();
+	float	Truncate(float maxlen);
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Dot, Cross & Perpendicular Vector
+    ////////////////////////////////////////////////////////////////////////////////////
+	float	Dot(const CVec3& t) const										{return (v[0]*t.v[0] + v[1]*t.v[1] + v[2]*t.v[2]);}
+	void	Cross(const CVec3& t)
+	{
+		CVec3 temp(*this);
+		v[0] = (temp.v[1]*t.v[2]) - (temp.v[2]*t.v[1]);
+		v[1] = (temp.v[2]*t.v[0]) - (temp.v[0]*t.v[2]);
+		v[2] = (temp.v[0]*t.v[1]) - (temp.v[1]*t.v[0]);
+	}
+	void	Perp();
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Truncation & Element Analysis
+    ////////////////////////////////////////////////////////////////////////////////////
+	void	Min(const CVec3& t)
+	{
+		if (t.v[0]<v[0])			v[0]=t.v[0];	
+		if (t.v[1]<v[1])			v[1]=t.v[1];	
+		if (t.v[2]<v[2])			v[2]=t.v[2];	
+	}
+	void	Max(const CVec3& t)
+	{
+		if (t.v[0]>v[0])			v[0]=t.v[0];	
+		if (t.v[1]>v[1])			v[1]=t.v[1];	
+		if (t.v[2]>v[2])			v[2]=t.v[2];	
+	}
+	float	MaxElement() const
+	{
+			return v[MaxElementIndex()];	
+	}
+	int		MaxElementIndex() const;
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Interpolation
+    ////////////////////////////////////////////////////////////////////////////////////
+	void	Interp(const CVec3 &v1, const CVec3 &v2, const float t)
+	{
+		(*this)=v1;
+		(*this)-=v2;
+		(*this)*=t;
+		(*this)+=v2;
+	}
+	void	ScaleAdd(const CVec3& t, const float scale)
+	{
+		v[0] += (scale * t.v[0]);
+		v[1] += (scale * t.v[1]);
+		v[2] += (scale * t.v[2]);
+	}
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Conversion Angle To Vector (Angle In Degrees)
+    ////////////////////////////////////////////////////////////////////////////////////
+	void	VecToAng();
+	void	AngToVec();
+	void	AngToVec(CVec3& Right, CVec3& Up);
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Conversion Angle To Vector (Angle In Radians)
+    ////////////////////////////////////////////////////////////////////////////////////
+	void	VecToAngRad();
+	void	AngToVecRad();
+	void	AngToVecRad(CVec3& Right, CVec3& Up);
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Conversion Between Radians And Degrees
+    ////////////////////////////////////////////////////////////////////////////////////
+	void	ToRadians();
+	void	ToDegrees();
+
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Project
+	//
+	// Standard projection function.  Take the (this) and project it onto the vector
+	// (U).  Imagine drawing a line perpendicular to U from the endpoint of the (this)
+	// Vector.  That then becomes the new vector.
+	//
+	// The value returned is the scale of the new vector with respect to the one passed
+	// to the function.  If the scale is less than (1.0) then the new vector is shorter 
+	// than (U).  If the scale is negative, then the vector is going in the opposite 
+	// direction of (U).
+	//
+	//               _  (U)
+	//               /|
+	//             /                                        _ (this)
+	//           /                      RESULTS->           /|
+	//         /                                          /
+	//       /    __\ (this)                            /
+	//     /___---  /                                 /
+	//
+    ////////////////////////////////////////////////////////////////////////////////////
+	float	Project(const CVec3 &U)
+	{
+		float	Scale = (Dot(U) / U.Len2());	// Find the scale of this vector on U
+		(*this)=U;								// Copy U onto this vector
+		(*this)*=Scale;							// Use the previously calculated scale to get the right length.
+		return Scale;
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Project To Line
+	//
+	// This function takes two other points in space as the start and end of a line
+	// segment and projects the (this) point onto the line defined by (Start)->(Stop)
+	//
+	// RETURN VALUES:
+	//   (-INF, 0.0)  : (this) landed on the line before (Start)
+	//   (0.0, 1.0)   : (this) landed in the line segment between (Start) and (Stop)
+	//   (1.0, INF)   : (this) landed on the line beyond (End)
+	//
+	//             (Stop)
+	//               /
+	//             /
+	//           o _
+	//         /  |\
+	//       /     (this)
+	//     / 
+	// (Start)
+	//
+    ////////////////////////////////////////////////////////////////////////////////////
+	float	ProjectToLine(const CVec3 &Start, const CVec3 &Stop)
+	{
+		(*this) -= Start;
+		float	Scale = Project(Stop - Start);
+		(*this) += Start;
+		return Scale;
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+    // Project To Line Seg 
+	//
+	// Same As Project To Line, Except It Will Clamp To Start And Stop
+	////////////////////////////////////////////////////////////////////////////////////
+	float	ProjectToLineSeg(const CVec3 &Start, const CVec3 &Stop)
+	{
+		float Scale = ProjectToLine(Start, Stop);
+		if (Scale<0.0f)
+		{
+			(*this) = Start;
+		}
+		else if (Scale>1.0f)
+		{
+			(*this) = Stop;
+		}
+		return Scale;
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Distance To Line
+	//
+	// Uses project to line and than calculates distance to the new point
+	////////////////////////////////////////////////////////////////////////////////////
+	float	DistToLine(const CVec3 &Start, const CVec3 &Stop) const
+	{
+		CVec3	P(*this);
+		P.ProjectToLineSeg(Start, Stop);
+
+		return Dist(P);
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Distance To Line
+	//
+	// Uses project to line and than calculates distance to the new point
+	////////////////////////////////////////////////////////////////////////////////////
+	float	DistToLine2(const CVec3 &Start, const CVec3 &Stop) const
+	{
+		CVec3	P(*this);
+		P.ProjectToLineSeg(Start, Stop);
+
+		return Dist2(P);
+	}
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Translation & Rotation (2D)
+    ////////////////////////////////////////////////////////////////////////////////////
+	void	RotatePoint(const CVec3 &Angle, const CVec3 &Origin);
+	void	Reposition(const CVec3 &Translation, float RotationDegrees=0.0);
+
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Area Of The Parallel Pipid (2D)
+	//
+	// Given two more points, this function calculates the area of the parallel pipid
+	// formed.
+	//
+	// Note: This function CAN return a negative "area" if (this) is above or right of
+	// (A) and (B)...  We do not take the abs because the sign of the "area" is needed
+	// for the left right test (see below)
+	//
+	//
+	//               ___---( ... )
+	//        (A)---/        /
+	//        /             /
+	//       /             /
+	//      /             /
+	//     /      ___---(B)
+	//  (this)---/
+	//
+    ////////////////////////////////////////////////////////////////////////////////////
+	float	AreaParallelPipid(const CVec3 &A, const CVec3 &B) const
+	{
+		return ((A.v[0]*B.v[1] - A.v[1]*B.v[0]) + 
+			    (B.v[0]*  v[1] -   v[0]*B.v[1]) + 
+				(  v[0]*A.v[1] - A.v[0]*  v[1]));
+	}
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Area Of The Triangle (2D)
+	//
+	// Given two more points, this function calculates the area of the triangle formed.
+	//
+	//        (A)
+	//        /  \__
+	//       /      \__
+	//      /          \_
+	//     /      ___---(B)
+	//  (this)---/
+	//
+    ////////////////////////////////////////////////////////////////////////////////////
+	float	AreaTriange(const CVec3 &A, const CVec3 &B) const
+	{
+		return (AreaParallelPipid(A, B) * 0.5f);
+	}
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// The Left Right Test (2D)
+	//
+	// Given a line segment (Start->End) and a tolerance for *right on*, this function
+	// evaluates which side the point is of the line.  (Side_Left in this example)
+	//
+	//
+	//
+	//          (this)        ___---/(End)
+	//                 ___---/
+	//          ___---/
+	//  (Start)/
+	//  
+    ////////////////////////////////////////////////////////////////////////////////////
+	ESide	LRTest(const CVec3 &Start, const CVec3 &End, float Tolerance=0.0) const
+	{	
+		float Area = AreaParallelPipid(Start, End);
+		if (Area>Tolerance)
+		{
+			return Side_Left;
+		}
+		if (Area<(Tolerance*-1))
+		{
+			return Side_Right;
+		}
+		return Side_None;
+
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Point In Circumscribed Circle  (True/False)
+	//
+	//  Returns true if the given point is within the circumscribed
+	//  circle of the given ABC Triangle:
+	//         _____  
+	//        /   B \
+	//      /   /   \ \
+	//     |  /      \ |
+	//     |A---------C|
+	//      \    Pt   /
+	//       \_______/
+	//  
+	////////////////////////////////////////////////////////////////////////////////////
+	bool	PtInCircle(const CVec3 &A, const CVec3 &B, const CVec3 &C) const;
+
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Point In Standard Circle  (True/False)
+	//
+	//  Returns true if the given point is within the Circle
+	//         _____  
+	//        /     \
+	//      /         \
+	//     |   Circle  |
+	//     |           |
+	//      \    Pt   /
+	//       \_______/
+	//  
+	////////////////////////////////////////////////////////////////////////////////////
+	bool	PtInCircle(const CVec3 &Circle, float Radius) const;
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Line Intersects Circle  (True/False)
+	//
+	//  r	- Radius Of The Circle
+	//  A	- Start Of Line Segment
+	//  B	- End Of Line Segment
+	//
+	//  P	- Projected Position Of Origin Onto Line AB
+	//
+	//
+	//            (Stop)
+	//              /
+	//            /
+	//         (P)
+	//        /   \      \
+	//      /   (this)-r->|
+	//    /              /
+	// (Start)
+	//
+	////////////////////////////////////////////////////////////////////////////////////
+	bool	LineInCircle(const CVec3 &Start, const CVec3 &Stop, float Radius);
+	bool	LineInCircle(const CVec3 &Start, const CVec3 &Stop, float Radius, CVec3 &PointOnLine);
+
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// String Operations
+    ////////////////////////////////////////////////////////////////////////////////////
+	void	FromStr(const char *s);
+	void	ToStr(char* s) const;
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Debug Routines
+    ////////////////////////////////////////////////////////////////////////////////////
+#ifdef _DEBUG
+	bool	IsFinite();
+	bool	IsInitialized();
+#endif
+
+
+    ////////////////////////////////////////////////////////////////////////////////////
+	// Data
+    ////////////////////////////////////////////////////////////////////////////////////
+
+public:
+	float v[3];	
+	static const CVec3 mX;
+	static const CVec3 mY;
+	static const CVec3 mZ;
+	static const CVec3 mZero;
+};
+
+
+
+//};
+#endif
\ No newline at end of file
diff --git a/codemp/Ravl/vssver.scc b/codemp/Ravl/vssver.scc
new file mode 100644
index 0000000..e1f2b8f
Binary files /dev/null and b/codemp/Ravl/vssver.scc differ
diff --git a/codemp/Splines/Splines.dsp b/codemp/Splines/Splines.dsp
new file mode 100644
index 0000000..e8c2789
--- /dev/null
+++ b/codemp/Splines/Splines.dsp
@@ -0,0 +1,156 @@
+# Microsoft Developer Studio Project File - Name="Splines" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Static Library" 0x0104
+
+CFG=Splines - Win32 Debug
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE 
+!MESSAGE NMAKE /f "Splines.mak".
+!MESSAGE 
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "Splines.mak" CFG="Splines - Win32 Debug"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "Splines - Win32 Release" (based on "Win32 (x86) Static Library")
+!MESSAGE "Splines - Win32 Debug" (based on "Win32 (x86) Static Library")
+!MESSAGE 
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""$/General/code/Splines", GAAAAAAA"
+# PROP Scc_LocalPath "."
+CPP=cl.exe
+RSC=rc.exe
+
+!IF  "$(CFG)" == "Splines - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_MBCS" /D "_LIB" /YX /FD /c
+# ADD CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_MBCS" /D "_LIB" /YX /FD /c
+# ADD BASE RSC /l 0x409 /d "NDEBUG"
+# ADD RSC /l 0x409 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo
+
+!ELSEIF  "$(CFG)" == "Splines - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "Debug"
+# PROP Intermediate_Dir "Debug"
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_MBCS" /D "_LIB" /YX /FD /GZ /c
+# ADD CPP /nologo /MTd /W3 /Gm /GR /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_MBCS" /D "_LIB" /FR /YX /FD /GZ /c
+# ADD BASE RSC /l 0x409 /d "_DEBUG"
+# ADD RSC /l 0x409 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo
+
+!ENDIF 
+
+# Begin Target
+
+# Name "Splines - Win32 Release"
+# Name "Splines - Win32 Debug"
+# Begin Group "Source Files"
+
+# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
+# Begin Source File
+
+SOURCE=.\math_angles.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\math_matrix.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\math_quaternion.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\math_vector.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\q_parse.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\q_shared.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\splines.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\util_str.cpp
+# End Source File
+# End Group
+# Begin Group "Header Files"
+
+# PROP Default_Filter "h;hpp;hxx;hm;inl"
+# Begin Source File
+
+SOURCE=.\math_angles.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\math_matrix.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\math_quaternion.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\math_vector.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\q_shared.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\splines.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\util_list.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\util_str.h
+# End Source File
+# End Group
+# End Target
+# End Project
diff --git a/codemp/Splines/math_angles.cpp b/codemp/Splines/math_angles.cpp
new file mode 100644
index 0000000..5da1510
--- /dev/null
+++ b/codemp/Splines/math_angles.cpp
@@ -0,0 +1,129 @@
+#include "q_shared.h"
+#include <float.h>
+
+angles_t ang_zero( 0.0f, 0.0f, 0.0f );
+
+void toAngles( mat3_t &src, angles_t &dst ) {
+	double		theta;
+	double		cp;
+	double		sp;
+
+	sp = src[ 0 ][ 2 ];
+
+	// cap off our sin value so that we don't get any NANs
+	if ( sp > 1.0 ) {
+		sp = 1.0;
+	} else if ( sp < -1.0 ) {
+		sp = -1.0;
+	}
+
+	theta = -asin( sp );
+	cp = cos( theta );
+
+	if ( cp > 8192 * FLT_EPSILON ) {
+		dst.pitch	= theta * 180 / M_PI;
+		dst.yaw		= atan2( src[ 0 ][ 1 ], src[ 0 ][ 0 ] ) * 180 / M_PI;
+		dst.roll	= atan2( src[ 1 ][ 2 ], src[ 2 ][ 2 ] ) * 180 / M_PI;
+	} else {
+		dst.pitch	= theta * 180 / M_PI;
+		dst.yaw		= -atan2( src[ 1 ][ 0 ], src[ 1 ][ 1 ] ) * 180 / M_PI;
+		dst.roll	= 0;
+	}
+}
+
+void toAngles( quat_t &src, angles_t &dst ) {
+	mat3_t temp;
+
+	toMatrix( src, temp );
+	toAngles( temp, dst );
+}
+
+void toAngles( idVec3_t &src, angles_t &dst ) {
+	dst.pitch	= src[ 0 ];
+	dst.yaw		= src[ 1 ];
+	dst.roll	= src[ 2 ];
+}
+
+void angles_t::toVectors( idVec3_t *forward, idVec3_t *right, idVec3_t *up ) {
+	float			angle;
+	static float	sr, sp, sy, cr, cp, cy; // static to help MS compiler fp bugs
+	
+	angle = yaw * ( M_PI * 2 / 360 );
+	sy = sin( angle );
+	cy = cos( angle );
+
+	angle = pitch * ( M_PI * 2 / 360 );
+	sp = sin( angle );
+	cp = cos( angle );
+
+	angle = roll * ( M_PI * 2 / 360 );
+	sr = sin( angle );
+	cr = cos( angle );
+
+	if ( forward ) {
+		forward->set( cp * cy, cp * sy, -sp );
+	}
+
+	if ( right ) {
+		right->set( -sr * sp * cy + cr * sy, -sr * sp * sy + -cr * cy, -sr * cp );
+	}
+
+	if ( up ) {
+		up->set( cr * sp * cy + -sr * -sy, cr * sp * sy + -sr * cy, cr * cp );
+	}
+}
+
+idVec3_t angles_t::toForward( void ) {
+	float			angle;
+	static float	sp, sy, cp, cy; // static to help MS compiler fp bugs
+	
+	angle = yaw * ( M_PI * 2 / 360 );
+	sy = sin( angle );
+	cy = cos( angle );
+
+	angle = pitch * ( M_PI * 2 / 360 );
+	sp = sin( angle );
+	cp = cos( angle );
+
+	return idVec3_t( cp * cy, cp * sy, -sp );
+}
+
+/*
+=================
+Normalize360
+
+returns angles normalized to the range [0 <= angle < 360]
+=================
+*/
+angles_t& angles_t::Normalize360( void ) {
+	pitch	= (360.0 / 65536) * ( ( int )( pitch	* ( 65536 / 360.0 ) ) & 65535 );
+	yaw		= (360.0 / 65536) * ( ( int )( yaw		* ( 65536 / 360.0 ) ) & 65535 );
+	roll	= (360.0 / 65536) * ( ( int )( roll		* ( 65536 / 360.0 ) ) & 65535 );
+
+	return *this;
+}
+
+
+/*
+=================
+Normalize180
+
+returns angles normalized to the range [-180 < angle <= 180]
+=================
+*/
+angles_t& angles_t::Normalize180( void ) {
+	Normalize360();
+
+	if ( pitch > 180.0 ) {
+		pitch -= 360.0;
+	}
+	
+	if ( yaw > 180.0 ) {
+		yaw  -= 360.0;
+	}
+
+	if ( roll > 180.0 ) {
+		roll -= 360.0;
+	}
+	return *this;
+}
diff --git a/codemp/Splines/math_angles.h b/codemp/Splines/math_angles.h
new file mode 100644
index 0000000..fdf1bfa
--- /dev/null
+++ b/codemp/Splines/math_angles.h
@@ -0,0 +1,174 @@
+#ifndef __MATH_ANGLES_H__
+#define __MATH_ANGLES_H__
+
+#include <stdlib.h>
+#include <assert.h>
+
+#include "math_vector.h"
+
+class mat3_t;
+class quat_t;
+class idVec3_t;
+typedef idVec3_t &vec3_p;
+
+class angles_t {
+public:
+	float			pitch;
+	float			yaw;
+	float			roll;
+
+					angles_t();
+					angles_t( float pitch, float yaw, float roll );
+					angles_t( const idVec3_t &vec );
+
+	friend void		toAngles( idVec3_t &src, angles_t &dst );
+	friend void		toAngles( quat_t &src, angles_t &dst );
+	friend void		toAngles( mat3_t &src, angles_t &dst );
+
+					operator vec3_p();
+
+	float			operator[]( int index ) const;
+	float&			operator[]( int index );
+
+	void 			set( float pitch, float yaw, float roll );
+
+	void			operator=( angles_t const &a );
+	void			operator=( idVec3_t const &a );
+
+	friend angles_t	operator+( const angles_t &a, const angles_t &b );
+	angles_t		&operator+=( angles_t const &a );
+	angles_t		&operator+=( idVec3_t const &a );
+
+	friend angles_t	operator-( angles_t &a, angles_t &b );
+	angles_t		&operator-=( angles_t &a );
+
+	friend angles_t	operator*( const angles_t &a, float b );
+	friend angles_t	operator*( float a, const angles_t &b );
+	angles_t		&operator*=( float a );
+
+	friend int		operator==(	angles_t &a, angles_t &b );
+					
+	friend int		operator!=(	angles_t &a, angles_t &b );
+
+	void			toVectors( idVec3_t *forward, idVec3_t *right = NULL, idVec3_t *up = NULL );
+	idVec3_t			toForward( void );
+
+	angles_t		&Zero( void );
+
+	angles_t		&Normalize360( void );
+	angles_t		&Normalize180( void );
+};
+
+extern angles_t ang_zero;
+
+inline angles_t::angles_t() {}
+
+inline angles_t::angles_t( float pitch, float yaw, float roll ) {
+	this->pitch = pitch;
+	this->yaw	= yaw;
+	this->roll	= roll;
+}
+
+inline angles_t::angles_t( const idVec3_t &vec ) {
+	this->pitch = vec.x;
+	this->yaw	= vec.y;
+	this->roll	= vec.z;
+}
+
+inline float angles_t::operator[]( int index ) const {
+	assert( ( index >= 0 ) && ( index < 3 ) );
+	return ( &pitch )[ index ];
+}
+
+inline float& angles_t::operator[]( int index ) {
+	assert( ( index >= 0 ) && ( index < 3 ) );
+	return ( &pitch )[ index ];
+}
+
+inline angles_t::operator vec3_p( void ) {
+	return *( idVec3_t * )&pitch;
+}
+
+inline void angles_t::set( float pitch, float yaw, float roll ) {
+	this->pitch = pitch;
+	this->yaw	= yaw;
+	this->roll	= roll;
+}
+
+inline void angles_t::operator=( angles_t const &a ) {
+	pitch	= a.pitch;
+	yaw		= a.yaw;
+	roll	= a.roll;
+}
+
+inline void angles_t::operator=( idVec3_t const &a ) {
+	pitch	= a[ 0 ];
+	yaw		= a[ 1 ];
+	roll	= a[ 2 ];
+}
+
+inline angles_t operator+( const angles_t &a, const angles_t &b ) {
+	return angles_t( a.pitch + b.pitch, a.yaw + b.yaw, a.roll + b.roll );
+}
+
+inline angles_t& angles_t::operator+=( angles_t const &a ) {
+	pitch	+= a.pitch;
+	yaw		+= a.yaw;
+	roll	+= a.roll;
+
+	return *this;
+}
+
+inline angles_t& angles_t::operator+=( idVec3_t const &a ) {
+	pitch	+= a.x;
+	yaw	+= a.y;
+	roll	+= a.z;
+
+	return *this;
+}
+
+inline angles_t operator-( angles_t &a, angles_t &b ) {
+	return angles_t( a.pitch - b.pitch, a.yaw - b.yaw, a.roll - b.roll );
+}
+
+inline angles_t& angles_t::operator-=( angles_t &a ) {
+	pitch	-= a.pitch;
+	yaw		-= a.yaw;
+	roll	-= a.roll;
+
+	return *this;
+}
+
+inline angles_t operator*( const angles_t &a, float b ) {
+	return angles_t( a.pitch * b, a.yaw * b, a.roll * b );
+}
+
+inline angles_t operator*( float a, const angles_t &b ) {
+	return angles_t( a * b.pitch, a * b.yaw, a * b.roll );
+}
+
+inline angles_t& angles_t::operator*=( float a ) {
+	pitch	*= a;
+	yaw		*= a;
+	roll	*= a;
+
+	return *this;
+}
+
+inline int operator==( angles_t &a, angles_t &b ) {
+	return ( ( a.pitch == b.pitch ) && ( a.yaw == b.yaw ) && ( a.roll == b.roll ) );
+}
+
+inline int operator!=( angles_t &a, angles_t &b ) {
+	return ( ( a.pitch != b.pitch ) || ( a.yaw != b.yaw ) || ( a.roll != b.roll ) );
+}
+
+inline angles_t& angles_t::Zero( void ) {
+	pitch	= 0.0f;
+	yaw		= 0.0f;
+	roll	= 0.0f;
+
+	return *this;
+}
+
+#endif /* !__MATH_ANGLES_H__ */
diff --git a/codemp/Splines/math_matrix.cpp b/codemp/Splines/math_matrix.cpp
new file mode 100644
index 0000000..b02b6ac
--- /dev/null
+++ b/codemp/Splines/math_matrix.cpp
@@ -0,0 +1,113 @@
+#include "q_shared.h"
+
+mat3_t mat3_default( idVec3_t( 1, 0, 0 ), idVec3_t( 0, 1, 0 ), idVec3_t( 0, 0, 1 ) );
+
+void toMatrix( quat_t const &src, mat3_t &dst ) {
+	float	wx, wy, wz;
+	float	xx, yy, yz;
+	float	xy, xz, zz;
+	float	x2, y2, z2;
+
+	x2 = src.x + src.x;
+	y2 = src.y + src.y;
+	z2 = src.z + src.z;
+
+	xx = src.x * x2;
+	xy = src.x * y2;
+	xz = src.x * z2;
+
+	yy = src.y * y2;
+	yz = src.y * z2;
+	zz = src.z * z2;
+
+	wx = src.w * x2;
+	wy = src.w * y2;
+	wz = src.w * z2;
+
+	dst[ 0 ][ 0 ] = 1.0f - ( yy + zz );
+	dst[ 0 ][ 1 ] = xy - wz;
+	dst[ 0 ][ 2 ] = xz + wy;
+
+	dst[ 1 ][ 0 ] = xy + wz;
+	dst[ 1 ][ 1 ] = 1.0f - ( xx + zz );
+	dst[ 1 ][ 2 ] = yz - wx;
+
+	dst[ 2 ][ 0 ] = xz - wy;
+	dst[ 2 ][ 1 ] = yz + wx;
+	dst[ 2 ][ 2 ] = 1.0f - ( xx + yy );
+}
+
+void toMatrix( angles_t const &src, mat3_t &dst ) {
+	float			angle;
+	static float	sr, sp, sy, cr, cp, cy; // static to help MS compiler fp bugs
+		
+	angle = src.yaw * ( M_PI * 2.0f / 360.0f );
+	sy = sin( angle );
+	cy = cos( angle );
+
+	angle = src.pitch * ( M_PI * 2.0f / 360.0f );
+	sp = sin( angle );
+	cp = cos( angle );
+
+	angle = src.roll * ( M_PI * 2.0f / 360.0f );
+	sr = sin( angle );
+	cr = cos( angle );
+
+	dst[ 0 ].set( cp * cy, cp * sy, -sp );
+	dst[ 1 ].set( sr * sp * cy + cr * -sy, sr * sp * sy + cr * cy, sr * cp );
+	dst[ 2 ].set( cr * sp * cy + -sr * -sy, cr * sp * sy + -sr * cy, cr * cp );
+}
+
+void toMatrix( idVec3_t const &src, mat3_t &dst ) {
+        angles_t sup = src;
+        toMatrix(sup, dst);
+}
+
+void mat3_t::ProjectVector( const idVec3_t &src, idVec3_t &dst ) const {
+	dst.x = src * mat[ 0 ];
+	dst.y = src * mat[ 1 ];
+	dst.z = src * mat[ 2 ];
+}
+
+void mat3_t::UnprojectVector( const idVec3_t &src, idVec3_t &dst ) const {
+	dst = mat[ 0 ] * src.x + mat[ 1 ] * src.y + mat[ 2 ] * src.z;
+}
+
+void mat3_t::Transpose( mat3_t &matrix ) {
+	int	i;
+	int	j;
+   
+	for( i = 0; i < 3; i++ ) {
+		for( j = 0; j < 3; j++ ) {
+			matrix[ i ][ j ] = mat[ j ][ i ];
+        }
+	}
+}
+
+void mat3_t::Transpose( void ) {
+	float	temp;
+	int		i;
+	int		j;
+   
+	for( i = 0; i < 3; i++ ) {
+		for( j = i + 1; j < 3; j++ ) {
+			temp = mat[ i ][ j ];
+			mat[ i ][ j ] = mat[ j ][ i ];
+			mat[ j ][ i ] = temp;
+        }
+	}
+}
+
+mat3_t mat3_t::Inverse( void ) const {
+	mat3_t inv( *this );
+
+	inv.Transpose();
+
+	return inv;
+}
+
+void mat3_t::Clear( void ) {
+	mat[0].set( 1, 0, 0 );
+	mat[1].set( 0, 1, 0 );
+	mat[2].set( 0, 0, 1 );
+}
diff --git a/codemp/Splines/math_matrix.h b/codemp/Splines/math_matrix.h
new file mode 100644
index 0000000..38a077d
--- /dev/null
+++ b/codemp/Splines/math_matrix.h
@@ -0,0 +1,202 @@
+#ifndef __MATH_MATRIX_H__
+#define __MATH_MATRIX_H__
+
+#include <string.h>
+#include "math_vector.h"
+
+#ifndef ID_INLINE
+#ifdef _WIN32
+#define ID_INLINE __inline 
+#else
+#define ID_INLINE inline
+#endif
+#endif
+
+class quat_t;
+class angles_t;
+
+class mat3_t {
+public:
+	idVec3_t			mat[ 3 ];
+
+					mat3_t();
+					mat3_t( float src[ 3 ][ 3 ] );
+					mat3_t( idVec3_t const &x, idVec3_t const &y, idVec3_t const &z );
+					mat3_t( const float xx, const float xy, const float xz, const float yx, const float yy, const float yz, const float zx, const float zy, const float zz );
+
+	friend void		toMatrix( quat_t const &src, mat3_t &dst );
+	friend void		toMatrix( angles_t const &src, mat3_t &dst );
+	friend void		toMatrix( idVec3_t const &src, mat3_t &dst );
+
+	idVec3_t			operator[]( int index ) const;
+	idVec3_t			&operator[]( int index );
+
+	idVec3_t			operator*( const idVec3_t &vec ) const;
+	mat3_t			operator*( const mat3_t &a ) const;
+	mat3_t			operator*( float a ) const;
+	mat3_t			operator+( mat3_t const &a ) const;
+	mat3_t			operator-( mat3_t const &a ) const;
+
+	friend idVec3_t	operator*( const idVec3_t &vec, const mat3_t &mat );
+	friend mat3_t	operator*( float a, mat3_t const &b );
+
+	mat3_t			&operator*=( float a );
+	mat3_t			&operator+=( mat3_t const &a );
+	mat3_t			&operator-=( mat3_t const &a );
+
+	void			Clear( void );
+
+	void			ProjectVector( const idVec3_t &src, idVec3_t &dst ) const;
+	void			UnprojectVector( const idVec3_t &src, idVec3_t &dst ) const;
+
+	void			OrthoNormalize( void );
+	void			Transpose( mat3_t &matrix );
+	void			Transpose( void );
+	mat3_t			Inverse( void ) const;
+	void			Identity( void );
+
+	friend void		InverseMultiply( const mat3_t &inv, const mat3_t &b, mat3_t &dst );
+	friend mat3_t	SkewSymmetric( idVec3_t const &src );
+};
+
+ID_INLINE mat3_t::mat3_t() {
+}
+
+ID_INLINE mat3_t::mat3_t( float src[ 3 ][ 3 ] ) {
+	memcpy( mat, src, sizeof( src ) );
+}
+
+ID_INLINE mat3_t::mat3_t( idVec3_t const &x, idVec3_t const &y, idVec3_t const &z ) {
+	mat[ 0 ].x = x.x; mat[ 0 ].y = x.y; mat[ 0 ].z = x.z;
+	mat[ 1 ].x = y.x; mat[ 1 ].y = y.y; mat[ 1 ].z = y.z;
+	mat[ 2 ].x = z.x; mat[ 2 ].y = z.y; mat[ 2 ].z = z.z;
+}
+
+ID_INLINE mat3_t::mat3_t( const float xx, const float xy, const float xz, const float yx, const float yy, const float yz, const float zx, const float zy, const float zz ) {
+	mat[ 0 ].x = xx; mat[ 0 ].y = xy; mat[ 0 ].z = xz;
+	mat[ 1 ].x = yx; mat[ 1 ].y = yy; mat[ 1 ].z = yz;
+	mat[ 2 ].x = zx; mat[ 2 ].y = zy; mat[ 2 ].z = zz;
+}
+
+ID_INLINE idVec3_t mat3_t::operator[]( int index ) const {
+	assert( ( index >= 0 ) && ( index < 3 ) );
+	return mat[ index ];
+}
+
+ID_INLINE idVec3_t& mat3_t::operator[]( int index ) {
+	assert( ( index >= 0 ) && ( index < 3 ) );
+	return mat[ index ];
+}
+
+ID_INLINE idVec3_t mat3_t::operator*( const idVec3_t &vec ) const {
+	return idVec3_t( 
+		mat[ 0 ].x * vec.x + mat[ 1 ].x * vec.y + mat[ 2 ].x * vec.z,
+		mat[ 0 ].y * vec.x + mat[ 1 ].y * vec.y + mat[ 2 ].y * vec.z,
+		mat[ 0 ].z * vec.x + mat[ 1 ].z * vec.y + mat[ 2 ].z * vec.z );
+}
+
+ID_INLINE mat3_t mat3_t::operator*( const mat3_t &a ) const {
+	return mat3_t( 
+		mat[0].x * a[0].x + mat[0].y * a[1].x + mat[0].z * a[2].x,
+		mat[0].x * a[0].y + mat[0].y * a[1].y + mat[0].z * a[2].y,
+		mat[0].x * a[0].z + mat[0].y * a[1].z + mat[0].z * a[2].z,
+		mat[1].x * a[0].x + mat[1].y * a[1].x + mat[1].z * a[2].x,
+		mat[1].x * a[0].y + mat[1].y * a[1].y + mat[1].z * a[2].y,
+		mat[1].x * a[0].z + mat[1].y * a[1].z + mat[1].z * a[2].z,
+		mat[2].x * a[0].x + mat[2].y * a[1].x + mat[2].z * a[2].x,
+		mat[2].x * a[0].y + mat[2].y * a[1].y + mat[2].z * a[2].y,
+		mat[2].x * a[0].z + mat[2].y * a[1].z + mat[2].z * a[2].z );
+}
+
+ID_INLINE mat3_t mat3_t::operator*( float a ) const {
+	return mat3_t( 
+		mat[0].x * a, mat[0].y * a, mat[0].z * a, 
+		mat[1].x * a, mat[1].y * a, mat[1].z * a, 
+		mat[2].x * a, mat[2].y * a, mat[2].z * a );
+}
+
+ID_INLINE mat3_t mat3_t::operator+( mat3_t const &a ) const {
+	return mat3_t( 
+		mat[0].x + a[0].x, mat[0].y + a[0].y, mat[0].z + a[0].z, 
+		mat[1].x + a[1].x, mat[1].y + a[1].y, mat[1].z + a[1].z, 
+		mat[2].x + a[2].x, mat[2].y + a[2].y, mat[2].z + a[2].z );
+}
+    
+ID_INLINE mat3_t mat3_t::operator-( mat3_t const &a ) const {
+	return mat3_t( 
+		mat[0].x - a[0].x, mat[0].y - a[0].y, mat[0].z - a[0].z, 
+		mat[1].x - a[1].x, mat[1].y - a[1].y, mat[1].z - a[1].z, 
+		mat[2].x - a[2].x, mat[2].y - a[2].y, mat[2].z - a[2].z );
+}
+
+ID_INLINE idVec3_t operator*( const idVec3_t &vec, const mat3_t &mat ) {
+	return idVec3_t( 
+		mat[ 0 ].x * vec.x + mat[ 1 ].x * vec.y + mat[ 2 ].x * vec.z,
+		mat[ 0 ].y * vec.x + mat[ 1 ].y * vec.y + mat[ 2 ].y * vec.z,
+		mat[ 0 ].z * vec.x + mat[ 1 ].z * vec.y + mat[ 2 ].z * vec.z );
+}
+
+ID_INLINE mat3_t operator*( float a, mat3_t const &b ) {
+	return mat3_t( 
+		b[0].x * a, b[0].y * a, b[0].z * a, 
+		b[1].x * a, b[1].y * a, b[1].z * a, 
+		b[2].x * a, b[2].y * a, b[2].z * a );
+}
+
+ID_INLINE mat3_t &mat3_t::operator*=( float a ) {
+	mat[0].x *= a; mat[0].y *= a; mat[0].z *= a;
+	mat[1].x *= a; mat[1].y *= a; mat[1].z *= a; 
+	mat[2].x *= a; mat[2].y *= a; mat[2].z *= a;
+
+    return *this;
+}
+
+ID_INLINE mat3_t &mat3_t::operator+=( mat3_t const &a ) {
+	mat[0].x += a[0].x; mat[0].y += a[0].y; mat[0].z += a[0].z;
+	mat[1].x += a[1].x; mat[1].y += a[1].y; mat[1].z += a[1].z;
+	mat[2].x += a[2].x; mat[2].y += a[2].y; mat[2].z += a[2].z;
+
+    return *this;
+}
+
+ID_INLINE mat3_t &mat3_t::operator-=( mat3_t const &a ) {
+	mat[0].x -= a[0].x; mat[0].y -= a[0].y; mat[0].z -= a[0].z;
+	mat[1].x -= a[1].x; mat[1].y -= a[1].y; mat[1].z -= a[1].z;
+	mat[2].x -= a[2].x; mat[2].y -= a[2].y; mat[2].z -= a[2].z;
+
+    return *this;
+}
+
+ID_INLINE void mat3_t::OrthoNormalize( void ) {
+	mat[ 0 ].Normalize();
+	mat[ 2 ].Cross( mat[ 0 ], mat[ 1 ] );
+	mat[ 2 ].Normalize();
+	mat[ 1 ].Cross( mat[ 2 ], mat[ 0 ] );
+	mat[ 1 ].Normalize();
+}
+
+ID_INLINE void mat3_t::Identity( void ) {
+	mat[ 0 ].x = 1.f; mat[ 0 ].y = 0.f; mat[ 0 ].z = 0.f;
+	mat[ 1 ].x = 0.f; mat[ 1 ].y = 1.f; mat[ 1 ].z = 0.f;
+	mat[ 2 ].x = 0.f; mat[ 2 ].y = 0.f; mat[ 2 ].z = 1.f;
+}
+
+ID_INLINE void InverseMultiply( const mat3_t &inv, const mat3_t &b, mat3_t &dst ) {
+	dst[0].x = inv[0].x * b[0].x + inv[1].x * b[1].x + inv[2].x * b[2].x;
+	dst[0].y = inv[0].x * b[0].y + inv[1].x * b[1].y + inv[2].x * b[2].y;
+	dst[0].z = inv[0].x * b[0].z + inv[1].x * b[1].z + inv[2].x * b[2].z;
+	dst[1].x = inv[0].y * b[0].x + inv[1].y * b[1].x + inv[2].y * b[2].x;
+	dst[1].y = inv[0].y * b[0].y + inv[1].y * b[1].y + inv[2].y * b[2].y;
+	dst[1].z = inv[0].y * b[0].z + inv[1].y * b[1].z + inv[2].y * b[2].z;
+	dst[2].x = inv[0].z * b[0].x + inv[1].z * b[1].x + inv[2].z * b[2].x;
+	dst[2].y = inv[0].z * b[0].y + inv[1].z * b[1].y + inv[2].z * b[2].y;
+	dst[2].z = inv[0].z * b[0].z + inv[1].z * b[1].z + inv[2].z * b[2].z;
+}
+
+ID_INLINE mat3_t SkewSymmetric( idVec3_t const &src ) {
+	return mat3_t( 0.0f, -src.z,  src.y, src.z,   0.0f, -src.x, -src.y,  src.x,   0.0f );
+}
+
+extern mat3_t mat3_default;
+
+#endif /* !__MATH_MATRIX_H__ */
diff --git a/codemp/Splines/math_quaternion.cpp b/codemp/Splines/math_quaternion.cpp
new file mode 100644
index 0000000..6e27eca
--- /dev/null
+++ b/codemp/Splines/math_quaternion.cpp
@@ -0,0 +1,57 @@
+#include "math_quaternion.h"
+#include "math_matrix.h"
+
+void toQuat( idVec3_t &src, quat_t &dst ) {
+	dst.x = src.x;
+	dst.y = src.y;
+	dst.z = src.z;
+	dst.w = 0.0f;
+}
+
+void toQuat( angles_t &src, quat_t &dst ) {
+	mat3_t temp;
+
+	toMatrix( src, temp );
+	toQuat( temp, dst );
+}
+
+void toQuat( mat3_t &src, quat_t &dst ) {
+	float		trace;
+	float		s;
+	int     	i;
+	int			j;
+	int			k;
+
+	static int 	next[ 3 ] = { 1, 2, 0 };
+
+	trace = src[ 0 ][ 0 ] + src[ 1 ][ 1 ] + src[ 2 ][ 2 ];
+	if ( trace > 0.0f ) {
+		s = ( float )sqrt( trace + 1.0f );
+		dst.w = s * 0.5f;
+		s = 0.5f / s;
+    
+		dst.x = ( src[ 2 ][ 1 ] - src[ 1 ][ 2 ] ) * s;
+		dst.y = ( src[ 0 ][ 2 ] - src[ 2 ][ 0 ] ) * s;
+		dst.z = ( src[ 1 ][ 0 ] - src[ 0 ][ 1 ] ) * s;
+	} else {
+		i = 0;
+		if ( src[ 1 ][ 1 ] > src[ 0 ][ 0 ] ) {
+			i = 1;
+		}
+		if ( src[ 2 ][ 2 ] > src[ i ][ i ] ) {
+			i = 2;
+		}
+
+		j = next[ i ];  
+		k = next[ j ];
+    
+		s = ( float )sqrt( ( src[ i ][ i ] - ( src[ j ][ j ] + src[ k ][ k ] ) ) + 1.0f );
+		dst[ i ] = s * 0.5f;
+    
+		s = 0.5f / s;
+    
+		dst.w		= ( src[ k ][ j ] - src[ j ][ k ] ) * s;
+		dst[ j ]	= ( src[ j ][ i ] + src[ i ][ j ] ) * s;
+		dst[ k ]	= ( src[ k ][ i ] + src[ i ][ k ] ) * s;
+	}
+}
diff --git a/codemp/Splines/math_quaternion.h b/codemp/Splines/math_quaternion.h
new file mode 100644
index 0000000..4792ba7
--- /dev/null
+++ b/codemp/Splines/math_quaternion.h
@@ -0,0 +1,169 @@
+#ifndef __MATH_QUATERNION_H__
+#define __MATH_QUATERNION_H__
+
+#include <assert.h>
+#include <math.h>
+
+class idVec3_t;
+class angles_t;
+class mat3_t;
+
+class quat_t {
+public:
+	float			x;
+	float			y;
+	float			z;
+	float			w;
+
+					quat_t();
+					quat_t( float x, float y, float z, float w );
+
+	friend void		toQuat( idVec3_t &src, quat_t &dst );
+	friend void		toQuat( angles_t &src, quat_t &dst );
+	friend void		toQuat( mat3_t &src, quat_t &dst );
+
+	float			*vec4( void );
+			
+	float			operator[]( int index ) const;
+	float			&operator[]( int index );
+
+	void 			set( float x, float y, float z, float w );
+
+	void			operator=( quat_t a );
+
+	friend quat_t	operator+( quat_t a, quat_t b );
+	quat_t			&operator+=( quat_t a );
+
+	friend quat_t	operator-( quat_t a, quat_t b );
+	quat_t			&operator-=( quat_t a );
+
+	friend quat_t	operator*( quat_t a, float b );
+	friend quat_t	operator*( float a, quat_t b );
+	quat_t			&operator*=( float a );
+
+	friend int		operator==(	quat_t a, quat_t b );
+	friend int		operator!=(	quat_t a, quat_t b );
+
+	float			Length( void );
+	quat_t			&Normalize( void );
+
+	quat_t			operator-();
+};
+
+inline quat_t::quat_t() {
+}
+
+inline quat_t::quat_t( float x, float y, float z, float w ) {
+	this->x = x;
+	this->y = y;
+	this->z = z;
+	this->w = w;
+}
+
+inline float *quat_t::vec4( void ) {
+	return &x;
+}
+
+inline float quat_t::operator[]( int index ) const {
+	assert( ( index >= 0 ) && ( index < 4 ) );
+	return ( &x )[ index ];
+}
+
+inline float& quat_t::operator[]( int index ) {
+	assert( ( index >= 0 ) && ( index < 4 ) );
+	return ( &x )[ index ];
+}
+
+inline void quat_t::set( float x, float y, float z, float w ) {
+	this->x = x;
+	this->y = y;
+	this->z = z;
+	this->w = w;
+}
+
+inline void quat_t::operator=( quat_t a ) {
+	x = a.x;
+	y = a.y;
+	z = a.z;
+	w = a.w;
+}
+
+inline quat_t operator+( quat_t a, quat_t b ) {
+	return quat_t( a.x + b.x, a.y + b.y, a.z + b.z, a.w + b.w );
+}
+
+inline quat_t& quat_t::operator+=( quat_t a ) {
+	x += a.x;
+	y += a.y;
+	z += a.z;
+	w += a.w;
+
+	return *this;
+}
+
+inline quat_t operator-( quat_t a, quat_t b ) {
+	return quat_t( a.x - b.x, a.y - b.y, a.z - b.z, a.w - b.w );
+}
+
+inline quat_t& quat_t::operator-=( quat_t a ) {
+	x -= a.x;
+	y -= a.y;
+	z -= a.z;
+	w -= a.w;
+
+	return *this;
+}
+
+inline quat_t operator*( quat_t a, float b ) {
+	return quat_t( a.x * b, a.y * b, a.z * b, a.w * b );
+}
+
+inline quat_t operator*( float a, quat_t b ) {
+	return b * a;
+}
+
+inline quat_t& quat_t::operator*=( float a ) {
+	x *= a;
+	y *= a;
+	z *= a;
+	w *= a;
+
+	return *this;
+}
+
+inline int operator==( quat_t a, quat_t b ) {
+	return ( ( a.x == b.x ) && ( a.y == b.y ) && ( a.z == b.z ) && ( a.w == b.w ) );
+}
+
+inline int operator!=( quat_t a, quat_t b ) {
+	return ( ( a.x != b.x ) || ( a.y != b.y ) || ( a.z != b.z ) && ( a.w != b.w ) );
+}
+
+inline float quat_t::Length( void ) {
+	float length;
+	
+	length = x * x + y * y + z * z + w * w;
+	return ( float )sqrt( length );
+}
+
+inline quat_t& quat_t::Normalize( void ) {
+	float length;
+	float ilength;
+
+	length = this->Length();
+	if ( length ) {
+		ilength = 1 / length;
+		x *= ilength;
+		y *= ilength;
+		z *= ilength;
+		w *= ilength;
+	}
+		
+	return *this;
+}
+
+inline quat_t quat_t::operator-() {
+	return quat_t( -x, -y, -z, -w );
+}
+
+#endif /* !__MATH_QUATERNION_H__ */
diff --git a/codemp/Splines/math_vector.cpp b/codemp/Splines/math_vector.cpp
new file mode 100644
index 0000000..8c3b1bb
--- /dev/null
+++ b/codemp/Splines/math_vector.cpp
@@ -0,0 +1,123 @@
+//#include "../game/q_shared.h"
+#include "math_vector.h"
+#include <assert.h>
+#include <math.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <string.h>
+#include <stdlib.h>
+#include <time.h>
+#include <ctype.h>
+
+#define M_PI		3.14159265358979323846	// matches value in gcc v2 math.h
+
+#define LERP_DELTA 1e-6
+
+idVec3_t vec_zero( 0.0f, 0.0f, 0.0f );
+
+Bounds	boundsZero;
+
+float idVec3_t::toYaw( void ) {
+	float yaw;
+	
+	if ( ( y == 0 ) && ( x == 0 ) ) {
+		yaw = 0;
+	} else {
+		yaw = atan2( y, x ) * 180 / M_PI;
+		if ( yaw < 0 ) {
+			yaw += 360;
+		}
+	}
+
+	return yaw;
+}
+
+float idVec3_t::toPitch( void ) {
+	float	forward;
+	float	pitch;
+	
+	if ( ( x == 0 ) && ( y == 0 ) ) {
+		if ( z > 0 ) {
+			pitch = 90;
+		} else {
+			pitch = 270;
+		}
+	} else {
+		forward = ( float )idSqrt( x * x + y * y );
+		pitch = atan2( z, forward ) * 180 / M_PI;
+		if ( pitch < 0 ) {
+			pitch += 360;
+		}
+	}
+
+	return pitch;
+}
+
+/*
+angles_t idVec3_t::toAngles( void ) {
+	float forward;
+	float yaw;
+	float pitch;
+	
+	if ( ( x == 0 ) && ( y == 0 ) ) {
+		yaw = 0;
+		if ( z > 0 ) {
+			pitch = 90;
+		} else {
+			pitch = 270;
+		}
+	} else {
+		yaw = atan2( y, x ) * 180 / M_PI;
+		if ( yaw < 0 ) {
+			yaw += 360;
+		}
+
+		forward = ( float )idSqrt( x * x + y * y );
+		pitch = atan2( z, forward ) * 180 / M_PI;
+		if ( pitch < 0 ) {
+			pitch += 360;
+		}
+	}
+
+	return angles_t( -pitch, yaw, 0 );
+}
+*/
+
+idVec3_t LerpVector( idVec3_t &w1, idVec3_t &w2, const float t ) {
+	float omega, cosom, sinom, scale0, scale1;
+
+	cosom = w1 * w2;
+	if ( ( 1.0 - cosom ) > LERP_DELTA ) {
+		omega = acos( cosom );
+		sinom = sin( omega );
+		scale0 = sin( ( 1.0 - t ) * omega ) / sinom;
+		scale1 = sin( t * omega ) / sinom;
+	} else {
+		scale0 = 1.0 - t;
+		scale1 = t;
+	}
+
+	return ( w1 * scale0 + w2 * scale1 );
+}
+
+/*
+=============
+idVec3_t::string
+
+This is just a convenience function
+for printing vectors
+=============
+*/
+char *idVec3_t::string( void ) {
+	static	int		index = 0;
+	static	char	str[ 8 ][ 36 ];
+	char	*s;
+
+	// use an array so that multiple toString's won't collide
+	s = str[ index ];
+	index = (index + 1)&7;
+
+	sprintf( s, "%.2f %.2f %.2f", x, y, z );
+
+	return s;
+}
diff --git a/codemp/Splines/math_vector.h b/codemp/Splines/math_vector.h
new file mode 100644
index 0000000..0350de1
--- /dev/null
+++ b/codemp/Splines/math_vector.h
@@ -0,0 +1,553 @@
+#ifndef __MATH_VECTOR_H__
+#define __MATH_VECTOR_H__
+
+#if defined(_WIN32)
+#pragma warning(disable : 4244)
+#endif
+
+#include <math.h>
+#include <assert.h>
+
+//#define DotProduct(a,b)			((a)[0]*(b)[0]+(a)[1]*(b)[1]+(a)[2]*(b)[2])
+//#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 VectorCopy(a,b)			((b).x=(a).x,(b).y=(a).y,(b).z=(a).z])
+
+//#define	VectorScale(v, s, o)	((o)[0]=(v)[0]*(s),(o)[1]=(v)[1]*(s),(o)[2]=(v)[2]*(s))
+#define	__VectorMA(v, s, b, o)	((o)[0]=(v)[0]+(b)[0]*(s),(o)[1]=(v)[1]+(b)[1]*(s),(o)[2]=(v)[2]+(b)[2]*(s))
+//#define CrossProduct(a,b,c)		((c)[0]=(a)[1]*(b)[2]-(a)[2]*(b)[1],(c)[1]=(a)[2]*(b)[0]-(a)[0]*(b)[2],(c)[2]=(a)[0]*(b)[1]-(a)[1]*(b)[0])
+
+#define DotProduct4(x,y)		((x)[0]*(y)[0]+(x)[1]*(y)[1]+(x)[2]*(y)[2]+(x)[3]*(y)[3])
+#define VectorSubtract4(a,b,c)	((c)[0]=(a)[0]-(b)[0],(c)[1]=(a)[1]-(b)[1],(c)[2]=(a)[2]-(b)[2],(c)[3]=(a)[3]-(b)[3])
+#define VectorAdd4(a,b,c)		((c)[0]=(a)[0]+(b)[0],(c)[1]=(a)[1]+(b)[1],(c)[2]=(a)[2]+(b)[2],(c)[3]=(a)[3]+(b)[3])
+#define VectorCopy4(a,b)		((b)[0]=(a)[0],(b)[1]=(a)[1],(b)[2]=(a)[2],(b)[3]=(a)[3])
+#define	VectorScale4(v, s, o)	((o)[0]=(v)[0]*(s),(o)[1]=(v)[1]*(s),(o)[2]=(v)[2]*(s),(o)[3]=(v)[3]*(s))
+#define	VectorMA4(v, s, b, o)	((o)[0]=(v)[0]+(b)[0]*(s),(o)[1]=(v)[1]+(b)[1]*(s),(o)[2]=(v)[2]+(b)[2]*(s),(o)[3]=(v)[3]+(b)[3]*(s))
+
+
+//#define VectorClear(a)			((a)[0]=(a)[1]=(a)[2]=0)
+#define VectorNegate(a,b)		((b)[0]=-(a)[0],(b)[1]=-(a)[1],(b)[2]=-(a)[2])
+//#define VectorSet(v, x, y, z)	((v)[0]=(x), (v)[1]=(y), (v)[2]=(z))
+#define Vector4Copy(a,b)		((b)[0]=(a)[0],(b)[1]=(a)[1],(b)[2]=(a)[2],(b)[3]=(a)[3])
+
+#define	SnapVector(v) {v[0]=(int)v[0];v[1]=(int)v[1];v[2]=(int)v[2];}
+
+
+//#include "util_heap.h"
+
+#ifndef EQUAL_EPSILON
+#define EQUAL_EPSILON	0.001
+#endif
+
+float Q_fabs( float f );
+
+#ifndef ID_INLINE
+#ifdef _WIN32
+#define ID_INLINE __inline 
+#else
+#define ID_INLINE inline
+#endif
+#endif
+
+// if this is defined, vec3 will take four elements, which may allow
+// easier SIMD optimizations
+//#define	FAT_VEC3
+//#ifdef __ppc__
+//#pragma align(16)
+//#endif
+
+class angles_t;
+#ifdef __ppc__
+// Vanilla PPC code, but since PPC has a reciprocal square root estimate instruction, 
+// runs *much* faster than calling sqrt(). We'll use two Newton-Raphson 
+// refinement steps to get bunch more precision in the 1/sqrt() value for very little cost. 
+// We'll then multiply 1/sqrt times the original value to get the sqrt. 
+// This is about 12.4 times faster than sqrt() and according to my testing (not exhaustive) 
+// it returns fairly accurate results (error below 1.0e-5 up to 100000.0 in 0.1 increments). 
+
+static inline float idSqrt(float x) {
+    const float half = 0.5;
+    const float one = 1.0;
+    float B, y0, y1;
+
+    // This'll NaN if it hits frsqrte. Handle both +0.0 and -0.0
+    if (fabs(x) == 0.0)
+        return x;
+    B = x;
+    
+#ifdef __GNUC__
+    asm("frsqrte %0,%1" : "=f" (y0) : "f" (B));
+#else
+    y0 = __frsqrte(B);
+#endif
+    /* First refinement step */
+    
+    y1 = y0 + half*y0*(one - B*y0*y0);
+    
+    /* Second refinement step -- copy the output of the last step to the input of this step */
+    
+    y0 = y1;
+    y1 = y0 + half*y0*(one - B*y0*y0);
+    
+    /* Get sqrt(x) from x * 1/sqrt(x) */
+    return x * y1;
+}
+#else
+static inline double idSqrt(double x) {
+    return sqrt(x);
+}
+#endif
+
+
+//class idVec3_t  : public idHeap<idVec3_t> {
+class idVec3_t {
+public:	
+#ifndef	FAT_VEC3
+	    float x,y,z;
+#else
+	    float x,y,z,dist;
+#endif
+
+#ifndef	FAT_VEC3
+					idVec3_t() {};
+#else
+					idVec3_t() {dist = 0.0f;};
+#endif
+					idVec3_t( const float x, const float y, const float z );
+
+					operator float *();
+
+	float			operator[]( const int index ) const;
+	float			&operator[]( const int index );
+
+	void 			set( const float x, const float y, const float z );
+
+	idVec3_t			operator-() const;
+
+	idVec3_t			&operator=( const idVec3_t &a );
+
+	float			operator*( const idVec3_t &a ) const;
+	idVec3_t			operator*( const float a ) const;
+	friend idVec3_t	operator*( float a, idVec3_t b );
+
+	idVec3_t			operator+( const idVec3_t &a ) const;
+	idVec3_t			operator-( const idVec3_t &a ) const;
+	
+	idVec3_t			&operator+=( const idVec3_t &a );
+	idVec3_t			&operator-=( const idVec3_t &a );
+	idVec3_t			&operator*=( const float a );
+
+	int				operator==(	const idVec3_t &a ) const;
+	int				operator!=(	const idVec3_t &a ) const;
+
+	idVec3_t			Cross( const idVec3_t &a ) const;
+	idVec3_t			&Cross( const idVec3_t &a, const idVec3_t &b );
+
+	float			Length( void ) const;
+	float			Normalize( void );
+
+	void			Zero( void );
+	void			Snap( void );
+	void			SnapTowards( const idVec3_t &to );
+
+	float			toYaw( void );
+	float			toPitch( void );
+	angles_t		toAngles( void );
+	friend idVec3_t	LerpVector( const idVec3_t &w1, const idVec3_t &w2, const float t );
+
+	char			*string( void );
+};
+
+extern idVec3_t vec_zero;
+
+ID_INLINE idVec3_t::idVec3_t( const float x, const float y, const float z ) {
+	this->x = x;
+	this->y = y;
+	this->z = z;
+#ifdef	FAT_VEC3
+	this->dist = 0.0f;
+#endif
+}
+
+ID_INLINE float idVec3_t::operator[]( const int index ) const {
+	return ( &x )[ index ];
+}
+
+ID_INLINE float &idVec3_t::operator[]( const int index ) {
+	return ( &x )[ index ];
+}
+
+ID_INLINE idVec3_t::operator float *( void ) {
+	return &x;
+}
+
+ID_INLINE idVec3_t idVec3_t::operator-() const {
+	return idVec3_t( -x, -y, -z );
+}
+	
+ID_INLINE idVec3_t &idVec3_t::operator=( const idVec3_t &a ) { 
+	x = a.x;
+	y = a.y;
+	z = a.z;
+	
+	return *this;
+}
+
+ID_INLINE void idVec3_t::set( const float x, const float y, const float z ) {
+	this->x = x;
+	this->y = y;
+	this->z = z;
+}
+
+ID_INLINE idVec3_t idVec3_t::operator-( const idVec3_t &a ) const {
+	return idVec3_t( x - a.x, y - a.y, z - a.z );
+}
+
+ID_INLINE float idVec3_t::operator*( const idVec3_t &a ) const {
+	return x * a.x + y * a.y + z * a.z;
+}
+
+ID_INLINE idVec3_t idVec3_t::operator*( const float a ) const {
+	return idVec3_t( x * a, y * a, z * a );
+}
+
+ID_INLINE idVec3_t operator*( const float a, const idVec3_t b ) {
+	return idVec3_t( b.x * a, b.y * a, b.z * a );
+}
+
+ID_INLINE idVec3_t idVec3_t::operator+( const idVec3_t &a ) const {
+	return idVec3_t( x + a.x, y + a.y, z + a.z );
+}
+
+ID_INLINE idVec3_t &idVec3_t::operator+=( const idVec3_t &a ) {
+	x += a.x;
+	y += a.y;
+	z += a.z;
+
+	return *this;
+}
+
+ID_INLINE idVec3_t &idVec3_t::operator-=( const idVec3_t &a ) {
+	x -= a.x;
+	y -= a.y;
+	z -= a.z;
+
+	return *this;
+}
+
+ID_INLINE idVec3_t &idVec3_t::operator*=( const float a ) {
+	x *= a;
+	y *= a;
+	z *= a;
+
+	return *this;
+}
+
+ID_INLINE int idVec3_t::operator==( const idVec3_t &a ) const {
+	if ( Q_fabs( x - a.x ) > EQUAL_EPSILON ) {
+		return false;
+	}
+			
+	if ( Q_fabs( y - a.y ) > EQUAL_EPSILON ) {
+		return false;
+	}
+
+	if ( Q_fabs( z - a.z ) > EQUAL_EPSILON ) {
+		return false;
+	}
+
+	return true;
+}
+
+ID_INLINE int idVec3_t::operator!=( const idVec3_t &a ) const {
+	if ( Q_fabs( x - a.x ) > EQUAL_EPSILON ) {
+		return true;
+	}
+			
+	if ( Q_fabs( y - a.y ) > EQUAL_EPSILON ) {
+		return true;
+	}
+
+	if ( Q_fabs( z - a.z ) > EQUAL_EPSILON ) {
+		return true;
+	}
+
+	return false;
+}
+
+ID_INLINE idVec3_t idVec3_t::Cross( const idVec3_t &a ) const {
+	return idVec3_t( y * a.z - z * a.y, z * a.x - x * a.z, x * a.y - y * a.x );
+}
+
+ID_INLINE idVec3_t &idVec3_t::Cross( const idVec3_t &a, const idVec3_t &b ) {
+	x = a.y * b.z - a.z * b.y;
+	y = a.z * b.x - a.x * b.z;
+	z = a.x * b.y - a.y * b.x;
+
+	return *this;
+}
+
+ID_INLINE float idVec3_t::Length( void ) const {
+	float length;
+	
+	length = x * x + y * y + z * z;
+	return ( float )idSqrt( length );
+}
+
+ID_INLINE float idVec3_t::Normalize( void ) {
+	float length;
+	float ilength;
+
+	length = this->Length();
+	if ( length ) {
+		ilength = 1.0f / length;
+		x *= ilength;
+		y *= ilength;
+		z *= ilength;
+	}
+		
+	return length;
+}
+
+ID_INLINE void idVec3_t::Zero( void ) {
+	x = 0.0f;
+	y = 0.0f;
+	z = 0.0f;
+}
+
+ID_INLINE void idVec3_t::Snap( void ) {
+	x = float( int( x ) );
+	y = float( int( y ) );
+	z = float( int( z ) );
+}
+
+/*
+======================
+SnapTowards
+
+Round a vector to integers for more efficient network
+transmission, but make sure that it rounds towards a given point
+rather than blindly truncating.  This prevents it from truncating 
+into a wall.
+======================
+*/
+ID_INLINE void idVec3_t::SnapTowards( const idVec3_t &to ) {
+	if ( to.x <= x ) {
+		x = float( int( x ) );
+	} else {
+		x = float( int( x ) + 1 );
+	}
+
+	if ( to.y <= y ) {
+		y = float( int( y ) );
+	} else {
+		y = float( int( y ) + 1 );
+	}
+
+	if ( to.z <= z ) {
+		z = float( int( z ) );
+	} else {
+		z = float( int( z ) + 1 );
+	}
+}
+
+//===============================================================
+
+class Bounds {
+public:
+	idVec3_t	b[2];
+
+			Bounds();
+			Bounds( const idVec3_t &mins, const idVec3_t &maxs );
+
+	void	Clear();
+	void	Zero();
+	float	Radius();		// radius from origin, not from center
+	idVec3_t	Center();
+	void	AddPoint( const idVec3_t &v );
+	void	AddBounds( const Bounds &bb );
+	bool	IsCleared();
+	bool	ContainsPoint( const idVec3_t &p );
+	bool	IntersectsBounds( const Bounds &b2 );	// touching is NOT intersecting
+};
+
+extern Bounds	boundsZero;
+
+ID_INLINE Bounds::Bounds(){
+}
+
+ID_INLINE bool Bounds::IsCleared() {
+	return b[0][0] > b[1][0];
+}
+
+ID_INLINE bool Bounds::ContainsPoint( const idVec3_t &p ) {
+	if ( p[0] < b[0][0] || p[1] < b[0][1] || p[2] < b[0][2]
+		|| p[0] > b[1][0] || p[1] > b[1][1] || p[2] > b[1][2] ) {
+		return false;
+	}
+	return true;
+}
+
+ID_INLINE bool Bounds::IntersectsBounds( const Bounds &b2 ) {
+	if ( b2.b[1][0] < b[0][0] || b2.b[1][1] < b[0][1] || b2.b[1][2] < b[0][2]
+		|| b2.b[0][0] > b[1][0] || b2.b[0][1] > b[1][1] || b2.b[0][2] > b[1][2] ) {
+		return false;
+	}
+	return true;
+}
+
+ID_INLINE Bounds::Bounds( const idVec3_t &mins, const idVec3_t &maxs ) {
+	b[0] = mins;
+	b[1] = maxs;
+}
+
+ID_INLINE idVec3_t Bounds::Center() {
+	return idVec3_t( ( b[1][0] + b[0][0] ) * 0.5f, ( b[1][1] + b[0][1] ) * 0.5f, ( b[1][2] + b[0][2] ) * 0.5f );
+}
+
+ID_INLINE void Bounds::Clear() {
+	b[0][0] = b[0][1] = b[0][2] = 99999;
+	b[1][0] = b[1][1] = b[1][2] = -99999;
+}
+
+ID_INLINE void Bounds::Zero() {
+	b[0][0] = b[0][1] = b[0][2] =
+	b[1][0] = b[1][1] = b[1][2] = 0;
+}
+
+ID_INLINE void Bounds::AddPoint( const idVec3_t &v ) {
+	if ( v[0] < b[0][0]) {
+		b[0][0] = v[0];
+	}
+	if ( v[0] > b[1][0]) {
+		b[1][0] = v[0];
+	}
+	if ( v[1] < b[0][1] ) {
+		b[0][1] = v[1];
+	}
+	if ( v[1] > b[1][1]) {
+		b[1][1] = v[1];
+	}
+	if ( v[2] < b[0][2] ) {
+		b[0][2] = v[2];
+	}
+	if ( v[2] > b[1][2]) {
+		b[1][2] = v[2];
+	}
+}
+
+
+ID_INLINE void Bounds::AddBounds( const Bounds &bb ) {
+	if ( bb.b[0][0] < b[0][0]) {
+		b[0][0] = bb.b[0][0];
+	}
+	if ( bb.b[0][1] < b[0][1]) {
+		b[0][1] = bb.b[0][1];
+	}
+	if ( bb.b[0][2] < b[0][2]) {
+		b[0][2] = bb.b[0][2];
+	}
+
+	if ( bb.b[1][0] > b[1][0]) {
+		b[1][0] = bb.b[1][0];
+	}
+	if ( bb.b[1][1] > b[1][1]) {
+		b[1][1] = bb.b[1][1];
+	}
+	if ( bb.b[1][2] > b[1][2]) {
+		b[1][2] = bb.b[1][2];
+	}
+}
+
+ID_INLINE float Bounds::Radius( ) {
+	int		i;
+	float	total;
+	float	a, aa;
+
+	total = 0;
+	for (i=0 ; i<3 ; i++) {
+		a = (float)fabs( b[0][i] );
+		aa = (float)fabs( b[1][i] );
+		if ( aa > a ) {
+			a = aa;
+		}
+		total += a * a;
+	}
+
+	return (float)idSqrt( total );
+}
+
+//===============================================================
+
+
+class idVec2_t {
+public:
+	float			x;
+	float			y;
+
+					operator float *();
+	float			operator[]( int index ) const;
+	float			&operator[]( int index );
+};
+
+ID_INLINE float idVec2_t::operator[]( int index ) const {
+	return ( &x )[ index ];
+}
+
+ID_INLINE float& idVec2_t::operator[]( int index ) {
+	return ( &x )[ index ];
+}
+
+ID_INLINE idVec2_t::operator float *( void ) {
+	return &x;
+}
+
+class vec4_t : public idVec3_t {
+public:
+#ifndef	FAT_VEC3
+	float			dist;
+#endif
+	vec4_t();
+	~vec4_t() {};
+	
+	vec4_t( float x, float y, float z, float dist );
+	float			operator[]( int index ) const;
+	float			&operator[]( int index );
+};
+
+ID_INLINE vec4_t::vec4_t() {}
+ID_INLINE vec4_t::vec4_t( float x, float y, float z, float dist ) {
+	this->x = x;
+	this->y = y;
+	this->z = z;
+	this->dist = dist;
+}
+
+ID_INLINE float vec4_t::operator[]( int index ) const {
+	return ( &x )[ index ];
+}
+
+ID_INLINE float& vec4_t::operator[]( int index ) {
+	return ( &x )[ index ];
+}
+
+
+class idVec5_t : public idVec3_t {
+public:
+	float			s;
+	float			t;
+	float			operator[]( int index ) const;
+	float			&operator[]( int index );
+};
+
+
+ID_INLINE float idVec5_t::operator[]( int index ) const {
+	return ( &x )[ index ];
+}
+
+ID_INLINE float& idVec5_t::operator[]( int index ) {
+	return ( &x )[ index ];
+}
+
+#endif /* !__MATH_VECTOR_H__ */
diff --git a/codemp/Splines/mssccprj.scc b/codemp/Splines/mssccprj.scc
new file mode 100644
index 0000000..ed50979
--- /dev/null
+++ b/codemp/Splines/mssccprj.scc
@@ -0,0 +1,5 @@
+SCC = This is a Source Code Control file
+
+[Splines.dsp]
+SCC_Aux_Path = "\\ravendata1\vss\central_code"
+SCC_Project_Name = "$/jedi/codemp/Splines", CSAAAAAA
diff --git a/codemp/Splines/q_parse.cpp b/codemp/Splines/q_parse.cpp
new file mode 100644
index 0000000..6413d82
--- /dev/null
+++ b/codemp/Splines/q_parse.cpp
@@ -0,0 +1,514 @@
+// q_parse.c -- support for parsing text files
+
+#include "q_shared.h"
+
+/*
+============================================================================
+
+PARSING
+
+============================================================================
+*/
+
+// multiple character punctuation tokens
+static const char *punctuation[] = {
+	"+=", "-=",  "*=",  "/=", "&=", "|=", "++", "--",
+		"&&", "||",  "<=",  ">=", "==", "!=",
+	NULL
+};
+
+typedef struct {
+	char	token[MAX_TOKEN_CHARS];
+	int		lines;
+	qboolean	ungetToken;
+	char	parseFile[MAX_QPATH];
+} parseInfo_t;
+
+#define	MAX_PARSE_INFO	16
+static parseInfo_t	parseInfo[MAX_PARSE_INFO];
+static int			parseInfoNum;
+static parseInfo_t	*pi = &parseInfo[0];
+
+/*
+===================
+Com_BeginParseSession
+===================
+*/
+void Com_BeginParseSession( const char *filename ) {
+	if ( parseInfoNum == MAX_PARSE_INFO - 1 ) {
+		Com_Error( ERR_FATAL, "Com_BeginParseSession: session overflow" );
+	}
+	parseInfoNum++;
+	pi = &parseInfo[parseInfoNum];
+
+	pi->lines = 1;
+	Q_strncpyz( pi->parseFile, filename, sizeof( pi->parseFile ) );
+}
+
+/*
+===================
+Com_EndParseSession
+===================
+*/
+void Com_EndParseSession( void ) {
+	if ( parseInfoNum == 0 ) {
+		Com_Error( ERR_FATAL, "Com_EndParseSession: session underflow" );
+	}
+	parseInfoNum--;
+	pi = &parseInfo[parseInfoNum];
+}
+
+/*
+===================
+Com_GetCurrentParseLine
+===================
+*/
+int Com_GetCurrentParseLine( void ) {
+	return pi->lines;
+}
+
+/*
+===================
+Com_ScriptError
+
+Prints the script name and line number in the message
+===================
+*/
+void Com_ScriptError( const char *msg, ... ) {
+	va_list		argptr;
+	char		string[32000];
+
+	va_start( argptr, msg );
+	vsprintf( string, msg,argptr );
+	va_end( argptr );
+
+	Com_Error( ERR_DROP, "File %s, line %i: %s", pi->parseFile, pi->lines, string );
+}
+
+void Com_ScriptWarning( const char *msg, ... ) {
+	va_list		argptr;
+	char		string[32000];
+
+	va_start( argptr, msg );
+	vsprintf( string, msg,argptr );
+	va_end( argptr );
+
+	Com_Printf( "File %s, line %i: %s", pi->parseFile, pi->lines, string );
+}
+
+
+/*
+===================
+Com_UngetToken
+
+Calling this will make the next Com_Parse return
+the current token instead of advancing the pointer
+===================
+*/
+void Com_UngetToken( void ) {
+	if ( pi->ungetToken ) {
+		Com_ScriptError( "UngetToken called twice" );
+	}
+	pi->ungetToken = qtrue;
+}
+
+
+static const char *SkipWhitespace( const char (*data), qboolean *hasNewLines ) {
+	int c;
+
+	while( (c = *data) <= ' ') {
+		if( !c ) {
+			return NULL;
+		}
+		if( c == '\n' ) {
+			pi->lines++;
+			*hasNewLines = qtrue;
+		}
+		data++;
+	}
+
+	return data;
+}
+
+/*
+==============
+Com_ParseExt
+
+Parse a token out of a string
+Will never return NULL, just empty strings.
+An empty string will only be returned at end of file.
+
+If "allowLineBreaks" is qtrue then an empty
+string will be returned if the next token is
+a newline.
+==============
+*/
+static char *Com_ParseExt( const char *(*data_p), qboolean allowLineBreaks ) {
+	int c = 0, len;
+	qboolean hasNewLines = qfalse;
+	const char *data;
+	const char **punc;
+
+	if ( !data_p ) {
+		Com_Error( ERR_FATAL, "Com_ParseExt: NULL data_p" );
+	}
+
+	data = *data_p;
+	len = 0;
+	pi->token[0] = 0;
+
+	// make sure incoming data is valid
+	if ( !data ) {
+		*data_p = NULL;
+		return pi->token;
+	}
+
+	// skip any leading whitespace
+	while ( 1 ) {
+		// skip whitespace
+		data = SkipWhitespace( data, &hasNewLines );
+		if ( !data ) {
+			*data_p = NULL;
+			return pi->token;
+		}
+		if ( hasNewLines && !allowLineBreaks ) {
+			*data_p = data;
+			return pi->token;
+		}
+
+		c = *data;
+
+		// skip double slash comments
+		if ( c == '/' && data[1] == '/' ) {
+			while (*data && *data != '\n') {
+				data++;
+			}
+			continue;
+		}
+
+		// skip /* */ comments
+		if ( c=='/' && data[1] == '*' ) {
+			while ( *data && ( *data != '*' || data[1] != '/' ) ) {
+				if( *data == '\n' ) {
+					pi->lines++;
+				}
+				data++;
+			}
+			if ( *data ) {
+				data += 2;
+			}
+			continue;
+		}
+
+		// a real token to parse
+		break;
+	}
+
+	// handle quoted strings
+	if ( c == '\"' ) {
+		data++;
+		while( 1 ) {
+			c = *data++;
+			if ( ( c=='\\' ) && ( *data == '\"' ) ) {
+				// allow quoted strings to use \" to indicate the " character
+				data++;
+			} else if ( c=='\"' || !c ) {
+				pi->token[len] = 0;
+				*data_p = ( char * ) data;
+				return pi->token;
+			} else if( *data == '\n' ) {
+				pi->lines++;
+			}
+			if ( len < MAX_TOKEN_CHARS - 1 ) {
+				pi->token[len] = c;
+				len++;
+			}
+		}
+	}
+
+	// check for a number
+	// is this parsing of negative numbers going to cause expression problems
+	if ( ( c >= '0' && c <= '9' ) || ( c == '-' && data[ 1 ] >= '0' && data[ 1 ] <= '9' ) || 
+		( c == '.' && data[ 1 ] >= '0' && data[ 1 ] <= '9' ) ) {
+		do  {
+
+			if (len < MAX_TOKEN_CHARS - 1) {
+				pi->token[len] = c;
+				len++;
+			}
+			data++;
+
+			c = *data;
+		} while ( ( c >= '0' && c <= '9' ) || c == '.' );
+
+		// parse the exponent
+		if ( c == 'e' || c == 'E' ) {
+			if (len < MAX_TOKEN_CHARS - 1) {
+				pi->token[len] = c;
+				len++;
+			}
+			data++;
+			c = *data;
+
+			if ( c == '-' || c == '+' ) {
+				if (len < MAX_TOKEN_CHARS - 1) {
+					pi->token[len] = c;
+					len++;
+				}
+				data++;
+				c = *data;
+			}
+
+			do  {
+				if (len < MAX_TOKEN_CHARS - 1) {
+					pi->token[len] = c;
+					len++;
+				}
+				data++;
+
+				c = *data;
+			} while ( c >= '0' && c <= '9' );
+		}
+
+		if (len == MAX_TOKEN_CHARS) {
+			len = 0;
+		}
+		pi->token[len] = 0;
+
+		*data_p = ( char * ) data;
+		return pi->token;
+   	}
+
+	// check for a regular word
+	// we still allow forward and back slashes in name tokens for pathnames
+	// and also colons for drive letters
+	if ( ( c >= 'a' && c <= 'z' ) || ( c >= 'A' && c <= 'Z' ) || c == '_' || c == '/' || c == '\\' ) {
+		do  {
+			if (len < MAX_TOKEN_CHARS - 1) {
+				pi->token[len] = c;
+				len++;
+			}
+			data++;
+
+			c = *data;
+		} while ( ( c >= 'a' && c <= 'z' ) || ( c >= 'A' && c <= 'Z' ) || c == '_' 
+			|| ( c >= '0' && c <= '9' ) || c == '/' || c == '\\' || c == ':' || c == '.' );
+
+		if (len == MAX_TOKEN_CHARS) {
+			len = 0;
+		}
+		pi->token[len] = 0;
+
+		*data_p = ( char * ) data;
+		return pi->token;
+	}
+
+	// check for multi-character punctuation token
+	for ( punc = punctuation ; *punc ; punc++ ) {
+		int		l;
+		int		j;
+
+		l = strlen( *punc );
+		for ( j = 0 ; j < l ; j++ ) {
+			if ( data[j] != (*punc)[j] ) {
+				break;
+			}
+		}
+		if ( j == l ) {
+			// a valid multi-character punctuation
+			memcpy( pi->token, *punc, l );
+			pi->token[l] = 0;
+			data += l;
+			*data_p = (char *)data;
+			return pi->token;
+		}
+	}
+
+	// single character punctuation
+	pi->token[0] = *data;
+	pi->token[1] = 0;
+	data++;
+	*data_p = (char *)data;
+
+	return pi->token;
+}
+
+/*
+===================
+Com_Parse
+===================
+*/
+const char *Com_Parse( const char *(*data_p) ) {
+	if ( pi->ungetToken ) {
+		pi->ungetToken = qfalse;
+		return pi->token;
+	}
+	return Com_ParseExt( data_p, qtrue );
+}
+
+/*
+===================
+Com_ParseOnLine
+===================
+*/
+const char *Com_ParseOnLine( const char *(*data_p) ) {
+	if ( pi->ungetToken ) {
+		pi->ungetToken = qfalse;
+		return pi->token;
+	}
+	return Com_ParseExt( data_p, qfalse );
+}
+
+
+
+/*
+==================
+Com_MatchToken
+==================
+*/
+void Com_MatchToken( const char *(*buf_p), const char *match, qboolean warning ) {
+	const char	*token;
+
+	token = Com_Parse( buf_p );
+	if ( strcmp( token, match ) ) {
+		if (warning) {
+			Com_ScriptWarning( "MatchToken: %s != %s", token, match );
+		} else {
+			Com_ScriptError( "MatchToken: %s != %s", token, match );
+		}
+	}
+}
+
+
+/*
+=================
+Com_SkipBracedSection
+
+The next token should be an open brace.
+Skips until a matching close brace is found.
+Internal brace depths are properly skipped.
+=================
+*/
+void Com_SkipBracedSection( const char *(*program) ) {
+	const char			*token;
+	int				depth;
+
+	depth = 0;
+	do {
+		token = Com_Parse( program );
+		if( token[1] == 0 ) {
+			if( token[0] == '{' ) {
+				depth++;
+			}
+			else if( token[0] == '}' ) {
+				depth--;
+			}
+		}
+	} while( depth && *program );
+}
+
+/*
+=================
+Com_SkipRestOfLine
+=================
+*/
+void Com_SkipRestOfLine ( const char *(*data) ) {
+	const char	*p;
+	int		c;
+
+	p = *data;
+	while ( (c = *p++) != 0 ) {
+		if ( c == '\n' ) {
+			pi->lines++;
+			break;
+		}
+	}
+
+	*data = p;
+}
+
+/*
+====================
+Com_ParseRestOfLine
+====================
+*/
+const char *Com_ParseRestOfLine( const char *(*data_p) ) {
+	static char	line[MAX_TOKEN_CHARS];
+	const char *token;
+
+	line[0] = 0;
+	while( 1 ) {
+		token = Com_ParseOnLine( data_p );
+		if ( !token[0] ) {
+			break;
+		}
+		if ( line[0] ) {
+			Q_strcat( line, sizeof(line), " " );
+		}
+		Q_strcat( line, sizeof(line), token );
+	}
+
+	return line;
+}
+
+
+float Com_ParseFloat( const char *(*buf_p) ) {
+	const char		*token;
+
+	token = Com_Parse( buf_p );
+	if ( !token[0] ) {
+		return 0;
+	}
+	return atof( token );
+}
+
+int Com_ParseInt( const char *(*buf_p) ) {
+	const char		*token;
+
+	token = Com_Parse( buf_p );
+	if ( !token[0] ) {
+		return 0;
+	}
+	return atoi( token );
+}
+
+
+
+void Com_Parse1DMatrix( const char *(*buf_p), int x, float *m ) {
+	const char	*token;
+	int		i;
+
+	Com_MatchToken( buf_p, "(" );
+
+	for (i = 0 ; i < x ; i++) {
+		token = Com_Parse(buf_p);
+		m[i] = atof(token);
+	}
+
+	Com_MatchToken( buf_p, ")" );
+}
+
+void Com_Parse2DMatrix( const char *(*buf_p), int y, int x, float *m ) {
+	int		i;
+
+	Com_MatchToken( buf_p, "(" );
+
+	for (i = 0 ; i < y ; i++) {
+		Com_Parse1DMatrix (buf_p, x, m + i * x);
+	}
+
+	Com_MatchToken( buf_p, ")" );
+}
+
+void Com_Parse3DMatrix( const char *(*buf_p), int z, int y, int x, float *m ) {
+	int		i;
+
+	Com_MatchToken( buf_p, "(" );
+
+	for (i = 0 ; i < z ; i++) {
+		Com_Parse2DMatrix (buf_p, y, x, m + i * x*y);
+	}
+
+	Com_MatchToken( buf_p, ")" );
+}
+
diff --git a/codemp/Splines/q_shared.cpp b/codemp/Splines/q_shared.cpp
new file mode 100644
index 0000000..f910492
--- /dev/null
+++ b/codemp/Splines/q_shared.cpp
@@ -0,0 +1,955 @@
+// q_shared.c -- stateless support routines that are included in each code dll
+#include "q_shared.h"
+
+/*
+============================================================================
+
+GROWLISTS
+
+============================================================================
+*/
+
+// malloc / free all in one place for debugging
+extern "C" void *Com_Allocate( int bytes );
+extern "C" void Com_Dealloc( void *ptr );
+
+void Com_InitGrowList( growList_t *list, int maxElements ) {
+	list->maxElements = maxElements;
+	list->currentElements = 0;
+	list->elements = (void **)Com_Allocate( list->maxElements * sizeof( void * ) );
+}
+
+int Com_AddToGrowList( growList_t *list, void *data ) {
+	void	**old;
+
+	if ( list->currentElements != list->maxElements ) {
+		list->elements[list->currentElements] = data;
+		return list->currentElements++;
+	}
+
+	// grow, reallocate and move
+	old = list->elements;
+
+	if ( list->maxElements < 0 ) {
+		Com_Error( ERR_FATAL, "Com_AddToGrowList: maxElements = %i", list->maxElements );
+	}
+
+	if ( list->maxElements == 0 ) {
+		// initialize the list to hold 100 elements
+		Com_InitGrowList( list, 100 );
+		return Com_AddToGrowList( list, data );
+	}
+
+	list->maxElements *= 2;
+
+	Com_DPrintf( "Resizing growlist to %i maxElements\n", list->maxElements );
+
+	list->elements = (void **)Com_Allocate( list->maxElements * sizeof( void * ) );
+
+	if ( !list->elements ) {
+		Com_Error( ERR_DROP, "Growlist alloc failed" );
+	}
+
+	memcpy( list->elements, old, list->currentElements * sizeof( void * ) );
+
+	Com_Dealloc( old );
+
+	return Com_AddToGrowList( list, data );
+}
+
+void *Com_GrowListElement( const growList_t *list, int index ) {
+	if ( index < 0 || index >= list->currentElements ) {
+		Com_Error( ERR_DROP, "Com_GrowListElement: %i out of range of %i", 
+			index, list->currentElements );
+	}
+	return list->elements[index];
+}
+
+int Com_IndexForGrowListElement( const growList_t *list, const void *element ) {
+	int		i;
+
+	for ( i = 0 ; i < list->currentElements ; i++ ) {
+		if ( list->elements[i] == element ) {
+			return i;
+		}
+	}
+	return -1;
+}
+
+//============================================================================
+
+
+float Com_Clamp( float min, float max, float value ) {
+	if ( value < min ) {
+		return min;
+	}
+	if ( value > max ) {
+		return max;
+	}
+	return value;
+}
+
+/*
+============
+Com_StringContains
+============
+*/
+const char *Com_StringContains( const char *str1, const char *str2, int casesensitive) {
+	int len, i, j;
+
+	len = strlen(str1) - strlen(str2);
+	for (i = 0; i <= len; i++, str1++) {
+		for (j = 0; str2[j]; j++) {
+			if (casesensitive) {
+				if (str1[j] != str2[j]) {
+					break;
+				}
+			}
+			else {
+				if (toupper(str1[j]) != toupper(str2[j])) {
+					break;
+				}
+			}
+		}
+		if (!str2[j]) {
+			return str1;
+		}
+	}
+	return NULL;
+}
+
+/*
+============
+Com_Filter
+============
+*/
+int Com_Filter( const char *filter, const char *name, int casesensitive)
+{
+	char buf[MAX_TOKEN_CHARS];
+	const char *ptr;
+	int i, found;
+
+	while(*filter) {
+		if (*filter == '*') {
+			filter++;
+			for (i = 0; *filter; i++) {
+				if (*filter == '*' || *filter == '?') break;
+				buf[i] = *filter;
+				filter++;
+			}
+			buf[i] = '\0';
+			if (strlen(buf)) {
+				ptr = Com_StringContains(name, buf, casesensitive);
+				if (!ptr) return qfalse;
+				name = ptr + strlen(buf);
+			}
+		}
+		else if (*filter == '?') {
+			filter++;
+			name++;
+		}
+		else if (*filter == '[' && *(filter+1) == '[') {
+			filter++;
+		}
+		else if (*filter == '[') {
+			filter++;
+			found = qfalse;
+			while(*filter && !found) {
+				if (*filter == ']' && *(filter+1) != ']') break;
+				if (*(filter+1) == '-' && *(filter+2) && (*(filter+2) != ']' || *(filter+3) == ']')) {
+					if (casesensitive) {
+						if (*name >= *filter && *name <= *(filter+2)) found = qtrue;
+					}
+					else {
+						if (toupper(*name) >= toupper(*filter) &&
+							toupper(*name) <= toupper(*(filter+2))) found = qtrue;
+					}
+					filter += 3;
+				}
+				else {
+					if (casesensitive) {
+						if (*filter == *name) found = qtrue;
+					}
+					else {
+						if (toupper(*filter) == toupper(*name)) found = qtrue;
+					}
+					filter++;
+				}
+			}
+			if (!found) return qfalse;
+			while(*filter) {
+				if (*filter == ']' && *(filter+1) != ']') break;
+				filter++;
+			}
+			filter++;
+			name++;
+		}
+		else {
+			if (casesensitive) {
+				if (*filter != *name) return qfalse;
+			}
+			else {
+				if (toupper(*filter) != toupper(*name)) return qfalse;
+			}
+			filter++;
+			name++;
+		}
+	}
+	return qtrue;
+}
+
+
+/*
+================
+Com_HashString
+
+================
+*/
+int Com_HashString( const char *fname ) {
+	int		i;
+	long	hash;
+	char	letter;
+
+	hash = 0;
+	i = 0;
+	while (fname[i] != '\0') {
+		letter = tolower((unsigned char)fname[i]);
+		if (letter =='.') break;				// don't include extension
+		if (letter =='\\') letter = '/';		// damn path names
+		hash+=(long)(letter)*(i+119);
+		i++;
+	}
+	hash &= (FILE_HASH_SIZE-1);
+	return hash;
+}
+
+
+/*
+============
+Com_SkipPath
+============
+*/
+char *Com_SkipPath (char *pathname)
+{
+	char	*last;
+	
+	last = pathname;
+	while (*pathname)
+	{
+		if (*pathname=='/')
+			last = pathname+1;
+		pathname++;
+	}
+	return last;
+}
+
+/*
+============
+Com_StripExtension
+============
+*/
+void Com_StripExtension( const char *in, char *out ) {
+	while ( *in && *in != '.' ) {
+		*out++ = *in++;
+	}
+	*out = 0;
+}
+
+
+/*
+==================
+Com_DefaultExtension
+==================
+*/
+void Com_DefaultExtension (char *path, int maxSize, const char *extension ) {
+	char	oldPath[MAX_QPATH];
+	char    *src;
+
+//
+// if path doesn't have a .EXT, append extension
+// (extension should include the .)
+//
+	src = path + strlen(path) - 1;
+
+	while (*src != '/' && src != path) {
+		if ( *src == '.' ) {
+			return;                 // it has an extension
+		}
+		src--;
+	}
+
+	Q_strncpyz( oldPath, path, sizeof( oldPath ) );
+	Com_sprintf( path, maxSize, "%s%s", oldPath, extension );
+}
+
+/*
+============================================================================
+
+					BYTE ORDER FUNCTIONS
+
+============================================================================
+*/
+
+// can't just use function pointers, or dll linkage can
+// mess up when qcommon is included in multiple places
+static short	(*_BigShort) (short l);
+static short	(*_LittleShort) (short l);
+static int		(*_BigLong) (int l);
+static int		(*_LittleLong) (int l);
+static float	(*_BigFloat) (float l);
+static float	(*_LittleFloat) (float l);
+
+short	BigShort(short l){return _BigShort(l);}
+short	LittleShort(short l) {return _LittleShort(l);}
+int		BigLong (int l) {return _BigLong(l);}
+int		LittleLong (int l) {return _LittleLong(l);}
+float	BigFloat (float l) {return _BigFloat(l);}
+float	LittleFloat (float l) {return _LittleFloat(l);}
+
+short   ShortSwap (short l)
+{
+	byte    b1,b2;
+
+	b1 = l&255;
+	b2 = (l>>8)&255;
+
+	return (b1<<8) + b2;
+}
+
+short	ShortNoSwap (short l)
+{
+	return l;
+}
+
+int    LongSwap (int l)
+{
+	byte    b1,b2,b3,b4;
+
+	b1 = l&255;
+	b2 = (l>>8)&255;
+	b3 = (l>>16)&255;
+	b4 = (l>>24)&255;
+
+	return ((int)b1<<24) + ((int)b2<<16) + ((int)b3<<8) + b4;
+}
+
+int	LongNoSwap (int l)
+{
+	return l;
+}
+
+float FloatSwap (float f)
+{
+	union
+	{
+		float	f;
+		byte	b[4];
+	} dat1, dat2;
+	
+	
+	dat1.f = f;
+	dat2.b[0] = dat1.b[3];
+	dat2.b[1] = dat1.b[2];
+	dat2.b[2] = dat1.b[1];
+	dat2.b[3] = dat1.b[0];
+	return dat2.f;
+}
+
+float FloatNoSwap (float f)
+{
+	return f;
+}
+
+/*
+================
+Swap_Init
+================
+*/
+void Swap_Init (void)
+{
+	byte	swaptest[2] = {1,0};
+
+// set the byte swapping variables in a portable manner	
+	if ( *(short *)swaptest == 1)
+	{
+		_BigShort = ShortSwap;
+		_LittleShort = ShortNoSwap;
+		_BigLong = LongSwap;
+		_LittleLong = LongNoSwap;
+		_BigFloat = FloatSwap;
+		_LittleFloat = FloatNoSwap;
+	}
+	else
+	{
+		_BigShort = ShortNoSwap;
+		_LittleShort = ShortSwap;
+		_BigLong = LongNoSwap;
+		_LittleLong = LongSwap;
+		_BigFloat = FloatNoSwap;
+		_LittleFloat = FloatSwap;
+	}
+
+}
+
+/*
+===============
+Com_ParseInfos
+===============
+*/
+int Com_ParseInfos( const char *buf, int max, char infos[][MAX_INFO_STRING] ) {
+	const char	*token;
+	int		count;
+	char	key[MAX_TOKEN_CHARS];
+
+	count = 0;
+
+	while ( 1 ) {
+		token = Com_Parse( &buf );
+		if ( !token[0] ) {
+			break;
+		}
+		if ( strcmp( token, "{" ) ) {
+			Com_Printf( "Missing { in info file\n" );
+			break;
+		}
+
+		if ( count == max ) {
+			Com_Printf( "Max infos exceeded\n" );
+			break;
+		}
+
+		infos[count][0] = 0;
+		while ( 1 ) {
+			token = Com_Parse( &buf );
+			if ( !token[0] ) {
+				Com_Printf( "Unexpected end of info file\n" );
+				break;
+			}
+			if ( !strcmp( token, "}" ) ) {
+				break;
+			}
+			Q_strncpyz( key, token, sizeof( key ) );
+
+			token = Com_ParseOnLine( &buf );
+			if ( !token[0] ) {
+				token = "<NULL>";
+			}
+			Info_SetValueForKey( infos[count], key, token );
+		}
+		count++;
+	}
+
+	return count;
+}
+
+
+
+/*
+============================================================================
+
+					LIBRARY REPLACEMENT FUNCTIONS
+
+============================================================================
+*/
+
+int Q_isprint( int c )
+{
+	if ( c >= 0x20 && c <= 0x7E )
+		return ( 1 );
+	return ( 0 );
+}
+
+int Q_islower( int c )
+{
+	if (c >= 'a' && c <= 'z')
+		return ( 1 );
+	return ( 0 );
+}
+
+int Q_isupper( int c )
+{
+	if (c >= 'A' && c <= 'Z')
+		return ( 1 );
+	return ( 0 );
+}
+
+int Q_isalpha( int c )
+{
+	if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'))
+		return ( 1 );
+	return ( 0 );
+}
+
+char* Q_strrchr( const char* string, int c )
+{
+	char cc = c;
+	char *s;
+	char *sp=(char *)0;
+
+	s = (char*)string;
+
+	while (*s)
+	{
+		if (*s == cc)
+			sp = s;
+		s++;
+	}
+	if (cc == 0)
+		sp = s;
+
+	return sp;
+}
+
+/*
+=============
+Q_strncpyz
+ 
+Safe strncpy that ensures a trailing zero
+=============
+*/
+void Q_strncpyz( char *dest, const char *src, int destsize ) {
+	if ( !src ) {
+		Com_Error( ERR_FATAL, "Q_strncpyz: NULL src" );
+	}
+	if ( destsize < 1 ) {
+		Com_Error(ERR_FATAL,"Q_strncpyz: destsize < 1" ); 
+	}
+
+	strncpy( dest, src, destsize-1 );
+    dest[destsize-1] = 0;
+}
+                 
+int Q_stricmpn (const char *s1, const char *s2, int n) {
+	int		c1, c2;
+	
+	do {
+		c1 = *s1++;
+		c2 = *s2++;
+
+		if (!n--) {
+			return 0;		// strings are equal until end point
+		}
+		
+		if (c1 != c2) {
+			if (c1 >= 'a' && c1 <= 'z') {
+				c1 -= ('a' - 'A');
+			}
+			if (c2 >= 'a' && c2 <= 'z') {
+				c2 -= ('a' - 'A');
+			}
+			if (c1 != c2) {
+				return c1 < c2 ? -1 : 1;
+			}
+		}
+	} while (c1);
+	
+	return 0;		// strings are equal
+}
+
+int Q_strncmp (const char *s1, const char *s2, int n) {
+	int		c1, c2;
+	
+	do {
+		c1 = *s1++;
+		c2 = *s2++;
+
+		if (!n--) {
+			return 0;		// strings are equal until end point
+		}
+		
+		if (c1 != c2) {
+			return c1 < c2 ? -1 : 1;
+		}
+	} while (c1);
+	
+	return 0;		// strings are equal
+}
+
+int Q_stricmp (const char *s1, const char *s2) {
+	return Q_stricmpn (s1, s2, 99999);
+}
+
+
+char *Q_strlwr( char *s1 ) {
+    char	*s;
+
+    s = s1;
+	while ( *s ) {
+		*s = tolower(*s);
+		s++;
+	}
+    return s1;
+}
+
+char *Q_strupr( char *s1 ) {
+    char	*s;
+
+    s = s1;
+	while ( *s ) {
+		*s = toupper(*s);
+		s++;
+	}
+    return s1;
+}
+
+
+// never goes past bounds or leaves without a terminating 0
+void Q_strcat( char *dest, int size, const char *src ) {
+	int		l1;
+
+	l1 = strlen( dest );
+	if ( l1 >= size ) {
+		Com_Error( ERR_FATAL, "Q_strcat: already overflowed" );
+	}
+	Q_strncpyz( dest + l1, src, size - l1 );
+}
+
+
+int Q_PrintStrlen( const char *string ) {
+	int			len;
+	const char	*p;
+
+	if( !string ) {
+		return 0;
+	}
+
+	len = 0;
+	p = string;
+	while( *p ) {
+		if( Q_IsColorString( p ) ) {
+			p += 2;
+			continue;
+		}
+		p++;
+		len++;
+	}
+
+	return len;
+}
+
+
+char *Q_CleanStr( char *string ) {
+	char*	d;
+	char*	s;
+	int		c;
+
+	s = string;
+	d = string;
+	while ((c = *s) != 0 ) {
+		if ( Q_IsColorString( s ) ) {
+			s++;
+		}		
+		else if ( c >= 0x20 && c <= 0x7E ) {
+			*d++ = c;
+		}
+		s++;
+	}
+	*d = '\0';
+
+	return string;
+}
+
+
+void QDECL Com_sprintf( char *dest, int size, const char *fmt, ...) {
+	int		len;
+	va_list		argptr;
+	char	bigbuffer[32000];	// big, but small enough to fit in PPC stack
+
+	va_start (argptr,fmt);
+	len = vsprintf (bigbuffer,fmt,argptr);
+	va_end (argptr);
+	if ( len >= sizeof( bigbuffer ) ) {
+		Com_Error( ERR_FATAL, "Com_sprintf: overflowed bigbuffer" );
+	}
+	if (len >= size) {
+		Com_Printf ("Com_sprintf: overflow of %i in %i\n", len, size);
+	}
+	Q_strncpyz (dest, bigbuffer, size );
+}
+
+
+/*
+============
+va
+
+does a varargs printf into a temp buffer, so I don't need to have
+varargs versions of all text functions.
+FIXME: make this buffer size safe someday
+============
+*/
+char	* QDECL va( char *format, ... ) {
+	va_list		argptr;
+	static char		string[2][32000];	// in case va is called by nested functions
+	static int		index = 0;
+	char	*buf;
+
+	buf = string[index & 1];
+	index++;
+
+	va_start (argptr, format);
+	vsprintf (buf, format,argptr);
+	va_end (argptr);
+
+	return buf;
+}
+
+
+/*
+=====================================================================
+
+  INFO STRINGS
+
+=====================================================================
+*/
+
+/*
+===============
+Info_ValueForKey
+
+Searches the string for the given
+key and returns the associated value, or an empty string.
+FIXME: overflow check?
+===============
+*/
+char *Info_ValueForKey( const char *s, const char *key ) {
+	char	pkey[MAX_INFO_KEY];
+	static	char value[2][MAX_INFO_VALUE];	// use two buffers so compares
+											// work without stomping on each other
+	static	int	valueindex = 0;
+	char	*o;
+	
+	if ( !s || !key ) {
+		return "";
+	}
+
+	if ( strlen( s ) >= MAX_INFO_STRING ) {
+		Com_Error( ERR_DROP, "Info_ValueForKey: oversize infostring" );
+	}
+
+	valueindex ^= 1;
+	if (*s == '\\')
+		s++;
+	while (1)
+	{
+		o = pkey;
+		while (*s != '\\')
+		{
+			if (!*s)
+				return "";
+			*o++ = *s++;
+		}
+		*o = 0;
+		s++;
+
+		o = value[valueindex];
+
+		while (*s != '\\' && *s)
+		{
+			*o++ = *s++;
+		}
+		*o = 0;
+
+		if (!Q_stricmp (key, pkey) )
+			return value[valueindex];
+
+		if (!*s)
+			break;
+		s++;
+	}
+
+	return "";
+}
+
+
+/*
+===================
+Info_NextPair
+
+Used to itterate through all the key/value pairs in an info string
+===================
+*/
+void Info_NextPair( const char *(*head), char key[MAX_INFO_KEY], char value[MAX_INFO_VALUE] ) {
+	char	*o;
+	const char	*s;
+
+	s = *head;
+
+	if ( *s == '\\' ) {
+		s++;
+	}
+	key[0] = 0;
+	value[0] = 0;
+
+	o = key;
+	while ( *s != '\\' ) {
+		if ( !*s ) {
+			*o = 0;
+			*head = s;
+			return;
+		}
+		*o++ = *s++;
+	}
+	*o = 0;
+	s++;
+
+	o = value;
+	while ( *s != '\\' && *s ) {
+		*o++ = *s++;
+	}
+	*o = 0;
+
+	*head = s;
+}
+
+
+/*
+===================
+Info_RemoveKey
+===================
+*/
+void Info_RemoveKey( char *s, const char *key ) {
+	char	*start;
+	char	pkey[MAX_INFO_KEY];
+	char	value[MAX_INFO_VALUE];
+	char	*o;
+
+	if ( strlen( s ) >= MAX_INFO_STRING ) {
+		Com_Error( ERR_DROP, "Info_RemoveKey: oversize infostring" );
+	}
+
+	if (strchr (key, '\\')) {
+		return;
+	}
+
+	while (1)
+	{
+		start = s;
+		if (*s == '\\')
+			s++;
+		o = pkey;
+		while (*s != '\\')
+		{
+			if (!*s)
+				return;
+			*o++ = *s++;
+		}
+		*o = 0;
+		s++;
+
+		o = value;
+		while (*s != '\\' && *s)
+		{
+			if (!*s)
+				return;
+			*o++ = *s++;
+		}
+		*o = 0;
+
+		if (!strcmp (key, pkey) )
+		{
+			strcpy (start, s);	// remove this part
+			return;
+		}
+
+		if (!*s)
+			return;
+	}
+
+}
+
+
+/*
+==================
+Info_Validate
+
+Some characters are illegal in info strings because they
+can mess up the server's parsing
+==================
+*/
+qboolean Info_Validate( const char *s ) {
+	if ( strchr( s, '\"' ) ) {
+		return qfalse;
+	}
+	if ( strchr( s, ';' ) ) {
+		return qfalse;
+	}
+	return qtrue;
+}
+
+/*
+==================
+Info_SetValueForKey
+
+Changes or adds a key/value pair
+==================
+*/
+void Info_SetValueForKey( char *s, const char *key, const char *value ) {
+	char	newi[MAX_INFO_STRING];
+
+	if ( strlen( s ) >= MAX_INFO_STRING ) {
+		Com_Error( ERR_DROP, "Info_SetValueForKey: oversize infostring" );
+	}
+
+	if (strchr (key, '\\') || strchr (value, '\\'))
+	{
+		Com_Printf ("Can't use keys or values with a \\\n");
+		return;
+	}
+
+	if (strchr (key, ';') || strchr (value, ';'))
+	{
+		Com_Printf ("Can't use keys or values with a semicolon\n");
+		return;
+	}
+
+	if (strchr (key, '\"') || strchr (value, '\"'))
+	{
+		Com_Printf ("Can't use keys or values with a \"\n");
+		return;
+	}
+
+	Info_RemoveKey (s, key);
+	if (!value || !strlen(value))
+		return;
+
+	Com_sprintf (newi, sizeof(newi), "\\%s\\%s", key, value);
+
+	if (strlen(newi) + strlen(s) > MAX_INFO_STRING)
+	{
+		Com_Printf ("Info string length exceeded\n");
+		return;
+	}
+
+	strcat (s, newi);
+}
+
+//====================================================================
+
+
+/*
+===============
+ParseHex
+===============
+*/
+int	ParseHex( const char *text ) {
+	int		value;
+	int		c;
+
+	value = 0;
+	while ( ( c = *text++ ) != 0 ) {
+		if ( c >= '0' && c <= '9' ) {
+			value = value * 16 + c - '0';
+			continue;
+		}
+		if ( c >= 'a' && c <= 'f' ) {
+			value = value * 16 + 10 + c - 'a';
+			continue;
+		}
+		if ( c >= 'A' && c <= 'F' ) {
+			value = value * 16 + 10 + c - 'A';
+			continue;
+		}
+	}
+
+	return value;
+}
diff --git a/codemp/Splines/q_shared.h b/codemp/Splines/q_shared.h
new file mode 100644
index 0000000..39f7d8f
--- /dev/null
+++ b/codemp/Splines/q_shared.h
@@ -0,0 +1,792 @@
+#ifndef __Q_SHARED_H
+#define __Q_SHARED_H
+
+// q_shared.h -- included first by ALL program modules.
+// these are the definitions that have no dependance on
+// central system services, and can be used by any part
+// of the program without any state issues.
+
+// A user mod should never modify this file
+
+// incursion of DOOM code into the Q3A codebase
+//#define	Q3_VERSION		"DOOM 0.01"
+
+// alignment macros for SIMD
+#define	ALIGN_ON
+#define	ALIGN_OFF
+
+#ifdef _WIN32
+
+#pragma warning(disable : 4018)     // signed/unsigned mismatch
+#pragma warning(disable : 4032)
+#pragma warning(disable : 4051)
+#pragma warning(disable : 4057)		// slightly different base types
+#pragma warning(disable : 4100)		// unreferenced formal parameter
+#pragma warning(disable : 4115)
+#pragma warning(disable : 4125)		// decimal digit terminates octal escape sequence
+#pragma warning(disable : 4127)		// conditional expression is constant
+#pragma warning(disable : 4136)
+#pragma warning(disable : 4201)
+#pragma warning(disable : 4214)
+#pragma warning(disable : 4244)
+#pragma warning(disable : 4305)		// truncation from const double to float
+#pragma warning(disable : 4310)		// cast truncates constant value
+#pragma warning(disable : 4514)
+#pragma warning(disable : 4711)		// selected for automatic inline expansion
+#pragma warning(disable : 4220)		// varargs matches remaining parameters
+
+#endif
+
+#include <assert.h>
+#include <math.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <string.h>
+#include <stdlib.h>
+#include <time.h>
+#include <ctype.h>
+#ifdef WIN32				// mac doesn't have malloc.h
+#include <malloc.h>			// for _alloca()
+#endif
+#ifdef _WIN32
+
+//#pragma intrinsic( memset, memcpy )
+
+#endif
+
+
+// this is the define for determining if we have an asm version of a C function
+#if (defined _M_IX86 || defined __i386__) && !defined __sun__  && !defined __LCC__
+#define id386	1
+#else
+#define id386	0
+#endif
+
+// for windows fastcall option
+
+#define	QDECL
+
+//======================= WIN32 DEFINES =================================
+
+#ifdef WIN32
+
+#define	MAC_STATIC
+
+#undef QDECL
+#define	QDECL	__cdecl
+
+// buildstring will be incorporated into the version string
+#ifdef NDEBUG
+#ifdef _M_IX86
+#define	CPUSTRING	"win-x86"
+#elif defined _M_ALPHA
+#define	CPUSTRING	"win-AXP"
+#endif
+#else
+#ifdef _M_IX86
+#define	CPUSTRING	"win-x86-debug"
+#elif defined _M_ALPHA
+#define	CPUSTRING	"win-AXP-debug"
+#endif
+#endif
+
+
+#define	PATH_SEP '\\'
+
+#endif
+
+//======================= MAC OS X SERVER DEFINES =====================
+
+#if defined(__MACH__) && defined(__APPLE__)
+
+#define MAC_STATIC
+
+#ifdef __ppc__
+#define CPUSTRING	"MacOSXS-ppc"
+#elif defined __i386__
+#define CPUSTRING	"MacOSXS-i386"
+#else
+#define CPUSTRING	"MacOSXS-other"
+#endif
+
+#define	PATH_SEP	'/'
+
+#define	GAME_HARD_LINKED
+#define	CGAME_HARD_LINKED
+#define	UI_HARD_LINKED
+#define _alloca alloca
+
+#undef ALIGN_ON
+#undef ALIGN_OFF
+#define	ALIGN_ON		#pragma align(16)
+#define	ALIGN_OFF		#pragma align()
+
+#ifdef __cplusplus
+	extern "C" {
+#endif
+
+void *osxAllocateMemory(long size);
+void osxFreeMemory(void *pointer);
+
+#ifdef __cplusplus
+        }
+#endif
+
+#endif
+
+//======================= MAC DEFINES =================================
+
+#ifdef __MACOS__
+
+#define	MAC_STATIC static
+
+#define	CPUSTRING	"MacOS-PPC"
+
+#define	PATH_SEP ':'
+
+void Sys_PumpEvents( void );
+
+#endif
+
+#ifdef __MRC__
+
+#define	MAC_STATIC
+
+#define	CPUSTRING	"MacOS-PPC"
+
+#define	PATH_SEP ':'
+
+void Sys_PumpEvents( void );
+
+#undef QDECL
+#define	QDECL	__cdecl
+
+#define _alloca alloca
+#endif
+
+//======================= LINUX DEFINES =================================
+
+// the mac compiler can't handle >32k of locals, so we
+// just waste space and make big arrays static...
+#ifdef __linux__
+
+// bk001205 - from Makefile
+#define stricmp strcasecmp
+
+#define	MAC_STATIC // bk: FIXME
+
+#ifdef __i386__
+#define	CPUSTRING	"linux-i386"
+#elif defined __axp__
+#define	CPUSTRING	"linux-alpha"
+#else
+#define	CPUSTRING	"linux-other"
+#endif
+
+#define	PATH_SEP '/'
+
+// bk001205 - try
+#ifdef Q3_STATIC
+#define	GAME_HARD_LINKED
+#define	CGAME_HARD_LINKED
+#define	UI_HARD_LINKED
+#define	BOTLIB_HARD_LINKED
+#endif
+
+#endif
+
+//=============================================================
+
+
+  
+typedef enum {qfalse, qtrue}	qboolean;
+#ifdef _XBOX
+#define	qboolean	int		//don't want strict type checking on the qboolean
+#endif
+
+typedef unsigned char 		byte;
+
+#define	EQUAL_EPSILON	0.001
+
+typedef int		qhandle_t;
+typedef int		sfxHandle_t;
+typedef int		fileHandle_t;
+typedef int		clipHandle_t;
+
+typedef enum {
+	INVALID_JOINT = -1
+} jointHandle_t;
+
+#ifndef NULL
+#define NULL ((void *)0)
+#endif
+
+#define	MAX_QINT			0x7fffffff
+#define	MIN_QINT			(-MAX_QINT-1)
+
+#ifndef max
+#define max( x, y ) ( ( ( x ) > ( y ) ) ? ( x ) : ( y ) )
+#define min( x, y ) ( ( ( x ) < ( y ) ) ? ( x ) : ( y ) )
+#endif
+
+#ifndef sign
+#define sign( f )	( ( f > 0 ) ? 1 : ( ( f < 0 ) ? -1 : 0 ) )
+#endif
+
+// angle indexes
+#define	PITCH				0		// up / down
+#define	YAW					1		// left / right
+#define	ROLL				2		// fall over
+
+// the game guarantees that no string from the network will ever
+// exceed MAX_STRING_CHARS
+#define	MAX_STRING_CHARS	1024	// max length of a string passed to Cmd_TokenizeString
+#define	MAX_STRING_TOKENS	256		// max tokens resulting from Cmd_TokenizeString
+#define	MAX_TOKEN_CHARS		1024	// max length of an individual token
+
+#define	MAX_INFO_STRING		1024
+#define	MAX_INFO_KEY		1024
+#define	MAX_INFO_VALUE		1024
+
+
+#define	MAX_QPATH			64		// max length of a quake game pathname
+#define	MAX_OSPATH			128		// max length of a filesystem pathname
+
+#define	MAX_NAME_LENGTH		32		// max length of a client name
+
+// paramters for command buffer stuffing
+typedef enum {
+	EXEC_NOW,			// don't return until completed, a VM should NEVER use this,
+						// because some commands might cause the VM to be unloaded...
+	EXEC_INSERT,		// insert at current position, but don't run yet
+	EXEC_APPEND			// add to end of the command buffer (normal case)
+} cbufExec_t;
+
+
+//
+// these aren't needed by any of the VMs.  put in another header?
+//
+#define	MAX_MAP_AREA_BYTES		32		// bit vector of area visibility
+
+#undef ERR_FATAL						// malloc.h on unix
+
+// parameters to the main Error routine
+typedef enum {
+	ERR_NONE,
+	ERR_FATAL,					// exit the entire game with a popup window
+	ERR_DROP,					// print to console and disconnect from game
+	ERR_DISCONNECT,				// don't kill server
+	ERR_NEED_CD					// pop up the need-cd dialog
+} errorParm_t;
+
+
+// font rendering values used by ui and cgame
+
+#define PROP_GAP_WIDTH			3
+#define PROP_SPACE_WIDTH		8
+#define PROP_HEIGHT				27
+#define PROP_SMALL_SIZE_SCALE	0.75
+
+#define BLINK_DIVISOR			200
+#define PULSE_DIVISOR			75
+
+#define UI_LEFT			0x00000000	// default
+#define UI_CENTER		0x00000001
+#define UI_RIGHT		0x00000002
+#define UI_FORMATMASK	0x00000007
+#define UI_SMALLFONT	0x00000010
+#define UI_BIGFONT		0x00000020	// default
+#define UI_GIANTFONT	0x00000040
+#define UI_DROPSHADOW	0x00000800
+#define UI_BLINK		0x00001000
+#define UI_INVERSE		0x00002000
+#define UI_PULSE		0x00004000
+
+
+/*
+==============================================================
+
+MATHLIB
+
+==============================================================
+*/
+#ifdef __cplusplus			// so we can include this in C code
+#define	SIDE_FRONT		0
+#define	SIDE_BACK		1
+#define	SIDE_ON			2
+#define	SIDE_CROSS		3
+
+#define	Q_PI	3.14159265358979323846
+#ifndef M_PI
+#define M_PI		3.14159265358979323846	// matches value in gcc v2 math.h
+#endif
+
+#include "math_vector.h"
+#include "math_angles.h"
+#include "math_matrix.h"
+#include "math_quaternion.h"
+
+class idVec3_t;						// for defining vectors
+typedef idVec3_t &vec3_p;				// for passing vectors as function arguments
+typedef const idVec3_t &vec3_c;		// for passing vectors as const function arguments
+									
+class angles_t;						// for defining angle vectors
+typedef angles_t &angles_p;			// for passing angles as function arguments
+typedef const angles_t &angles_c;	// for passing angles as const function arguments
+
+class mat3_t;						// for defining matrices
+typedef mat3_t &mat3_p;				// for passing matrices as function arguments
+typedef const mat3_t &mat3_c;		// for passing matrices as const function arguments
+
+
+
+#define NUMVERTEXNORMALS	162
+extern	idVec3_t	bytedirs[NUMVERTEXNORMALS];
+
+// all drawing is done to a 640*480 virtual screen size
+// and will be automatically scaled to the real resolution
+#define	SCREEN_WIDTH		640
+#define	SCREEN_HEIGHT		480
+
+#define TINYCHAR_WIDTH		(SMALLCHAR_WIDTH)
+#define TINYCHAR_HEIGHT		(SMALLCHAR_HEIGHT/2)
+
+#define SMALLCHAR_WIDTH		8
+#define SMALLCHAR_HEIGHT	16
+
+#define BIGCHAR_WIDTH		16
+#define BIGCHAR_HEIGHT		16
+
+#define	GIANTCHAR_WIDTH		32
+#define	GIANTCHAR_HEIGHT	48
+
+extern	vec4_t		colorBlack;
+extern	vec4_t		colorRed;
+extern	vec4_t		colorGreen;
+extern	vec4_t		colorBlue;
+extern	vec4_t		colorYellow;
+extern	vec4_t		colorMagenta;
+extern	vec4_t		colorCyan;
+extern	vec4_t		colorWhite;
+extern	vec4_t		colorLtGrey;
+extern	vec4_t		colorMdGrey;
+extern	vec4_t		colorDkGrey;
+
+#define Q_COLOR_ESCAPE	'^'
+#define Q_IsColorString(p)	( p && *(p) == Q_COLOR_ESCAPE && *((p)+1) && *((p)+1) != Q_COLOR_ESCAPE )
+
+#define COLOR_BLACK		'0'
+#define COLOR_RED		'1'
+#define COLOR_GREEN		'2'
+#define COLOR_YELLOW	'3'
+#define COLOR_BLUE		'4'
+#define COLOR_CYAN		'5'
+#define COLOR_MAGENTA	'6'
+#define COLOR_WHITE		'7'
+#define ColorIndex(c)	( ( (c) - '0' ) & 7 )
+
+#define S_COLOR_BLACK	"^0"
+#define S_COLOR_RED		"^1"
+#define S_COLOR_GREEN	"^2"
+#define S_COLOR_YELLOW	"^3"
+#define S_COLOR_BLUE	"^4"
+#define S_COLOR_CYAN	"^5"
+#define S_COLOR_MAGENTA	"^6"
+#define S_COLOR_WHITE	"^7"
+
+extern vec4_t	g_color_table[8];
+
+#define	MAKERGB( v, r, g, b ) v[0]=r;v[1]=g;v[2]=b
+#define	MAKERGBA( v, r, g, b, a ) v[0]=r;v[1]=g;v[2]=b;v[3]=a
+
+#define DEG2RAD( a ) ( ( (a) * M_PI ) / 180.0F )
+#define RAD2DEG( a ) ( ( (a) * 180.0f ) / M_PI )
+
+struct cplane_s;
+
+extern	idVec3_t	vec3_origin;
+extern	vec4_t	vec4_origin;
+extern	mat3_t	axisDefault;
+
+#define	nanmask (255<<23)
+
+#define	IS_NAN(x) (((*(int *)&x)&nanmask)==nanmask)
+
+float Q_fabs( float f );
+float Q_rsqrt( float f );		// reciprocal square root
+
+#define SQRTFAST( x ) ( 1.0f / Q_rsqrt( x ) )
+
+signed char ClampChar( int i );
+signed short ClampShort( int i );
+
+// this isn't a real cheap function to call!
+int DirToByte( const idVec3_t &dir );
+void ByteToDir( int b, vec3_p dir );
+
+#define DotProduct(a,b)			((a)[0]*(b)[0]+(a)[1]*(b)[1]+(a)[2]*(b)[2])
+#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 VectorCopy(a,b)			((b).x=(a).x,(b).y=(a).y,(b).z=(a).z])
+
+#define	VectorScale(v, s, o)	((o)[0]=(v)[0]*(s),(o)[1]=(v)[1]*(s),(o)[2]=(v)[2]*(s))
+#define	VectorMA(v, s, b, o)	((o)[0]=(v)[0]+(b)[0]*(s),(o)[1]=(v)[1]+(b)[1]*(s),(o)[2]=(v)[2]+(b)[2]*(s))
+#define CrossProduct(a,b,c)		((c)[0]=(a)[1]*(b)[2]-(a)[2]*(b)[1],(c)[1]=(a)[2]*(b)[0]-(a)[0]*(b)[2],(c)[2]=(a)[0]*(b)[1]-(a)[1]*(b)[0])
+
+#define DotProduct4(x,y)		((x)[0]*(y)[0]+(x)[1]*(y)[1]+(x)[2]*(y)[2]+(x)[3]*(y)[3])
+#define VectorSubtract4(a,b,c)	((c)[0]=(a)[0]-(b)[0],(c)[1]=(a)[1]-(b)[1],(c)[2]=(a)[2]-(b)[2],(c)[3]=(a)[3]-(b)[3])
+#define VectorAdd4(a,b,c)		((c)[0]=(a)[0]+(b)[0],(c)[1]=(a)[1]+(b)[1],(c)[2]=(a)[2]+(b)[2],(c)[3]=(a)[3]+(b)[3])
+#define VectorCopy4(a,b)		((b)[0]=(a)[0],(b)[1]=(a)[1],(b)[2]=(a)[2],(b)[3]=(a)[3])
+#define	VectorScale4(v, s, o)	((o)[0]=(v)[0]*(s),(o)[1]=(v)[1]*(s),(o)[2]=(v)[2]*(s),(o)[3]=(v)[3]*(s))
+#define	VectorMA4(v, s, b, o)	((o)[0]=(v)[0]+(b)[0]*(s),(o)[1]=(v)[1]+(b)[1]*(s),(o)[2]=(v)[2]+(b)[2]*(s),(o)[3]=(v)[3]+(b)[3]*(s))
+
+
+#define VectorClear(a)			((a)[0]=(a)[1]=(a)[2]=0)
+#define VectorNegate(a,b)		((b)[0]=-(a)[0],(b)[1]=-(a)[1],(b)[2]=-(a)[2])
+#define VectorSet(v, x, y, z)	((v)[0]=(x), (v)[1]=(y), (v)[2]=(z))
+#define Vector4Copy(a,b)		((b)[0]=(a)[0],(b)[1]=(a)[1],(b)[2]=(a)[2],(b)[3]=(a)[3])
+
+#define	SnapVector(v) {v[0]=(int)v[0];v[1]=(int)v[1];v[2]=(int)v[2];}
+
+float NormalizeColor( vec3_c in, vec3_p out );
+
+int VectorCompare( vec3_c v1, vec3_c v2 );
+float VectorLength( vec3_c v );
+float Distance( vec3_c p1, vec3_c p2 );
+float DistanceSquared( vec3_c p1, vec3_c p2 );
+float VectorNormalize (vec3_p v);		// returns vector length
+void VectorNormalizeFast(vec3_p v);		// does NOT return vector length, uses rsqrt approximation
+float VectorNormalize2( vec3_c v, vec3_p out );
+void VectorInverse (vec3_p v);
+void VectorRotate( vec3_c in, mat3_c matrix, vec3_p out );
+void VectorPolar(vec3_p v, float radius, float theta, float phi);
+void VectorSnap(vec3_p v);
+void Vector53Copy( const idVec5_t &in, vec3_p out);
+void Vector5Scale( const idVec5_t &v, float scale, idVec5_t &out);
+void Vector5Add( const idVec5_t &va, const idVec5_t &vb, idVec5_t &out);
+void VectorRotate3( vec3_c vIn, vec3_c vRotation, vec3_p out);
+void VectorRotate3Origin(vec3_c vIn, vec3_c vRotation, vec3_c vOrigin, vec3_p out);
+
+
+int Q_log2(int val);
+
+int		Q_rand( int *seed );
+float	Q_random( int *seed );
+float	Q_crandom( int *seed );
+
+#define random()	((rand () & 0x7fff) / ((float)0x7fff))
+#define crandom()	(2.0 * (random() - 0.5))
+
+float Q_rint( float in );
+
+void vectoangles( vec3_c value1, angles_p angles);
+void AnglesToAxis( angles_c angles, mat3_p axis );
+
+void AxisCopy( mat3_c in, mat3_p out );
+qboolean AxisRotated( mat3_c in );			// assumes a non-degenerate axis
+
+int SignbitsForNormal( vec3_c normal );
+int BoxOnPlaneSide( const Bounds &b, struct cplane_s *p );
+
+float	AngleMod(float a);
+float	LerpAngle (float from, float to, float frac);
+float	AngleSubtract( float a1, float a2 );
+void	AnglesSubtract( angles_c v1, angles_c v2, angles_p v3 );
+
+float AngleNormalize360 ( float angle );
+float AngleNormalize180 ( float angle );
+float AngleDelta ( float angle1, float angle2 );
+
+qboolean PlaneFromPoints( vec4_t &plane, vec3_c a, vec3_c b, vec3_c c );
+void ProjectPointOnPlane( vec3_p dst, vec3_c p, vec3_c normal );
+void RotatePointAroundVector( vec3_p dst, vec3_c dir, vec3_c point, float degrees );
+void RotateAroundDirection( mat3_p axis, float yaw );
+void MakeNormalVectors( vec3_c forward, vec3_p right, vec3_p up );
+// perpendicular vector could be replaced by this
+
+int	PlaneTypeForNormal( vec3_c normal );
+
+void MatrixMultiply( mat3_c in1, mat3_c in2, mat3_p out );
+void MatrixInverseMultiply( mat3_c in1, mat3_c in2, mat3_p out );	// in2 is transposed during multiply
+void MatrixTransformVector( vec3_c in, mat3_c matrix, vec3_p out );
+void MatrixProjectVector( vec3_c in, mat3_c matrix, vec3_p out ); // Places the vector into a new coordinate system.
+void AngleVectors( angles_c angles, vec3_p forward, vec3_p right, vec3_p up);
+void PerpendicularVector( vec3_p dst, vec3_c src );
+
+float TriangleArea( vec3_c a, vec3_c b, vec3_c c );
+#endif										// __cplusplus
+
+//=============================================
+
+float Com_Clamp( float min, float max, float value );
+
+#define FILE_HASH_SIZE		1024
+int Com_HashString( const char *fname );
+
+char	*Com_SkipPath( char *pathname );
+
+// it is ok for out == in
+void	Com_StripExtension( const char *in, char *out );
+
+// "extension" should include the dot: ".map"
+void	Com_DefaultExtension( char *path, int maxSize, const char *extension );
+
+int		Com_ParseInfos( const char *buf, int max, char infos[][MAX_INFO_STRING] );
+
+/*
+=====================================================================================
+
+SCRIPT PARSING
+
+=====================================================================================
+*/
+
+// this just controls the comment printing, it doesn't actually load a file
+void Com_BeginParseSession( const char *filename );
+void Com_EndParseSession( void );
+
+int Com_GetCurrentParseLine( void );
+
+// Will never return NULL, just empty strings.
+// An empty string will only be returned at end of file.
+// ParseOnLine will return empty if there isn't another token on this line
+
+// this funny typedef just means a moving pointer into a const char * buffer
+const char *Com_Parse( const char *(*data_p) );
+const char *Com_ParseOnLine( const char *(*data_p) );
+const char *Com_ParseRestOfLine( const char *(*data_p) );
+
+void Com_UngetToken( void );
+
+#ifdef __cplusplus
+void Com_MatchToken( const char *(*buf_p), const char *match, qboolean warning = qfalse );
+#else
+void Com_MatchToken( const char *(*buf_p), const char *match, qboolean warning );
+#endif
+
+void Com_ScriptError( const char *msg, ... );
+void Com_ScriptWarning( const char *msg, ... );
+
+void Com_SkipBracedSection( const char *(*program) );
+void Com_SkipRestOfLine( const char *(*data) );
+
+float Com_ParseFloat( const char *(*buf_p) );
+int	Com_ParseInt( const char *(*buf_p) );
+
+void Com_Parse1DMatrix( const char *(*buf_p), int x, float *m );
+void Com_Parse2DMatrix( const char *(*buf_p), int y, int x, float *m );
+void Com_Parse3DMatrix( const char *(*buf_p), int z, int y, int x, float *m );
+
+//=====================================================================================
+#ifdef __cplusplus
+	extern "C" {
+#endif
+
+void	QDECL Com_sprintf (char *dest, int size, const char *fmt, ...);
+
+
+// mode parm for FS_FOpenFile
+typedef enum {
+	FS_READ,
+	FS_WRITE,
+	FS_APPEND,
+	FS_APPEND_SYNC
+} fsMode_t;
+
+typedef enum {
+	FS_SEEK_CUR,
+	FS_SEEK_END,
+	FS_SEEK_SET
+} fsOrigin_t;
+
+//=============================================
+
+int Q_isprint( int c );
+int Q_islower( int c );
+int Q_isupper( int c );
+int Q_isalpha( int c );
+
+// portable case insensitive compare
+int		Q_stricmp (const char *s1, const char *s2);
+int		Q_strncmp (const char *s1, const char *s2, int n);
+int		Q_stricmpn (const char *s1, const char *s2, int n);
+char	*Q_strlwr( char *s1 );
+char	*Q_strupr( char *s1 );
+char	*Q_strrchr( const char* string, int c );
+
+// buffer size safe library replacements
+void	Q_strncpyz( char *dest, const char *src, int destsize );
+void	Q_strcat( char *dest, int size, const char *src );
+
+// strlen that discounts Quake color sequences
+int Q_PrintStrlen( const char *string );
+// removes color sequences from string
+char *Q_CleanStr( char *string );
+
+int			Com_Filter( const char *filter, const char *name, int casesensitive );
+const char *Com_StringContains( const char *str1, const char *str2, int casesensitive );
+
+
+//=============================================
+
+short	BigShort(short l);
+short	LittleShort(short l);
+int		BigLong (int l);
+int		LittleLong (int l);
+float	BigFloat (float l);
+float	LittleFloat (float l);
+
+void	Swap_Init (void);
+char	* QDECL va(char *format, ...);
+
+#if defined(__cplusplus) && !defined(_XBOX)
+    }
+#endif
+
+
+//=============================================
+#ifdef __cplusplus
+//
+// mapfile parsing
+//
+typedef struct ePair_s {
+	char	*key;
+	char	*value;
+} ePair_t;
+
+typedef struct mapSide_s {
+	char		material[MAX_QPATH];
+	vec4_t		plane;
+	vec4_t		textureVectors[2];
+} mapSide_t;
+
+typedef struct {
+	int			numSides;
+	mapSide_t	**sides;
+} mapBrush_t;
+
+typedef struct {
+	idVec3_t		xyz;
+	float		st[2];
+} patchVertex_t;
+
+typedef struct {
+	char		material[MAX_QPATH];
+	int			width, height;
+	patchVertex_t	*patchVerts;
+} mapPatch_t;
+
+typedef struct {
+	char		modelName[MAX_QPATH];
+	float		matrix[16];
+} mapModel_t;
+
+typedef struct mapPrimitive_s {
+	int				numEpairs;
+	ePair_t			**ePairs;
+
+	// only one of these will be non-NULL
+	mapBrush_t		*brush;
+	mapPatch_t		*patch;
+	mapModel_t		*model;
+} mapPrimitive_t;
+
+typedef struct mapEntity_s {
+	int				numPrimitives;
+	mapPrimitive_t	**primitives;
+
+	int				numEpairs;
+	ePair_t			**ePairs;
+} mapEntity_t;
+
+typedef struct {
+	int				numEntities;
+	mapEntity_t		**entities;
+} mapFile_t;
+
+
+// the order of entities, brushes, and sides will be maintained, the
+// lists won't be swapped on each load or save
+mapFile_t *ParseMapFile( const char *text );
+void FreeMapFile( mapFile_t *mapFile );
+void WriteMapFile( const mapFile_t *mapFile, FILE *f );
+
+// key names are case-insensitive
+const char 	*ValueForMapEntityKey( const mapEntity_t *ent, const char *key );
+float	FloatForMapEntityKey( const mapEntity_t *ent, const char *key );
+qboolean 	GetVectorForMapEntityKey( const mapEntity_t *ent, const char *key, idVec3_t &vec );
+
+typedef struct {
+	idVec3_t		xyz;
+	idVec2_t		st;
+	idVec3_t		normal;
+	idVec3_t		tangents[2];
+	byte		smoothing[4];		// colors for silhouette smoothing
+} drawVert_t;
+
+typedef struct {
+	int			width, height;
+	drawVert_t	*verts;
+} drawVertMesh_t;
+
+// Tesselate a map patch into smoothed, drawable vertexes
+// MaxError of around 4 is reasonable
+drawVertMesh_t *SubdivideMapPatch( const mapPatch_t *patch, float maxError );
+#endif			// __cplusplus
+
+//=========================================
+
+#ifdef __cplusplus
+	extern "C" {
+#endif
+
+void	QDECL Com_Error( int level, const char *error, ... );
+void	QDECL Com_Printf( const char *msg, ... );
+void	QDECL Com_DPrintf( const char *msg, ... );
+
+#if defined(__cplusplus) && !defined(_XBOX)
+	}
+#endif
+
+
+typedef struct {
+	qboolean	frameMemory;
+	int		currentElements;
+	int		maxElements;		// will reallocate and move when exceeded
+	void	**elements;
+} growList_t;
+
+// you don't need to init the growlist if you don't mind it growing and moving
+// the list as it expands
+void		Com_InitGrowList( growList_t *list, int maxElements );
+int			Com_AddToGrowList( growList_t *list, void *data );
+void		*Com_GrowListElement( const growList_t *list, int index );
+int			Com_IndexForGrowListElement( const growList_t *list, const void *element );
+
+
+//
+// key / value info strings
+//
+char *Info_ValueForKey( const char *s, const char *key );
+void Info_RemoveKey( char *s, const char *key );
+void Info_SetValueForKey( char *s, const char *key, const char *value );
+qboolean Info_Validate( const char *s );
+void Info_NextPair( const char *(*s), char key[MAX_INFO_KEY], char value[MAX_INFO_VALUE] );
+
+// get cvar defs, collision defs, etc
+//#include "../shared/interface.h"
+
+// get key code numbers for events
+//#include "../shared/keycodes.h"
+
+#ifdef __cplusplus
+// get the polygon winding functions
+//#include "../shared/windings.h"
+
+// get the flags class
+//#include "../shared/idflags.h"
+#endif	// __cplusplus
+
+#endif	// __Q_SHARED_H
+
diff --git a/codemp/Splines/splines.cpp b/codemp/Splines/splines.cpp
new file mode 100644
index 0000000..bb6c4af
--- /dev/null
+++ b/codemp/Splines/splines.cpp
@@ -0,0 +1,1226 @@
+
+//#include "stdafx.h"
+//#include "qe3.h"
+
+#include "q_shared.h"
+#include "splines.h"
+
+extern "C" {
+int FS_Write( const void *buffer, int len, fileHandle_t h );
+int FS_ReadFile( const char *qpath, void **buffer );
+void FS_FreeFile( void *buffer );
+fileHandle_t FS_FOpenFileWrite( const char *filename );
+void FS_FCloseFile( fileHandle_t f );
+}
+
+float Q_fabs( float f ) {
+	int tmp = * ( int * ) &f;
+	tmp &= 0x7FFFFFFF;
+	return * ( float * ) &tmp;
+}
+
+
+//#include "../shared/windings.h"
+//#include "../qcommon/qcommon.h"
+//#include "../sys/sys_public.h"
+//#include "../game/game_entity.h"
+
+idCameraDef splineList;
+idCameraDef *g_splineList = &splineList;
+
+idVec3_t idSplineList::zero(0,0,0);
+
+void glLabeledPoint(idVec3_t &color, idVec3_t &point, float size, const char *label) {
+	qglColor3fv(color);
+	qglPointSize(size);
+	qglBegin(GL_POINTS);
+	qglVertex3fv(point);
+	qglEnd();
+	idVec3_t v = point;
+	v.x += 1;
+	v.y += 1;
+	v.z += 1;
+	qglRasterPos3fv (v);
+	qglCallLists (strlen(label), GL_UNSIGNED_BYTE, label);
+}
+
+
+void glBox(idVec3_t &color, idVec3_t &point, float size) {
+	idVec3_t mins(point);
+	idVec3_t maxs(point);
+	mins[0] -= size;
+	mins[1] += size;
+	mins[2] -= size;
+	maxs[0] += size;
+	maxs[1] -= size;
+	maxs[2] += size;
+	qglColor3fv(color);
+	qglBegin(GL_LINE_LOOP);
+	qglVertex3f(mins[0],mins[1],mins[2]);
+	qglVertex3f(maxs[0],mins[1],mins[2]);
+	qglVertex3f(maxs[0],maxs[1],mins[2]);
+	qglVertex3f(mins[0],maxs[1],mins[2]);
+	qglEnd();
+	qglBegin(GL_LINE_LOOP);
+	qglVertex3f(mins[0],mins[1],maxs[2]);
+	qglVertex3f(maxs[0],mins[1],maxs[2]);
+	qglVertex3f(maxs[0],maxs[1],maxs[2]);
+	qglVertex3f(mins[0],maxs[1],maxs[2]);
+	qglEnd();
+
+	qglBegin(GL_LINES);
+  	qglVertex3f(mins[0],mins[1],mins[2]);
+	qglVertex3f(mins[0],mins[1],maxs[2]);
+	qglVertex3f(mins[0],maxs[1],maxs[2]);
+	qglVertex3f(mins[0],maxs[1],mins[2]);
+	qglVertex3f(maxs[0],mins[1],mins[2]);
+	qglVertex3f(maxs[0],mins[1],maxs[2]);
+	qglVertex3f(maxs[0],maxs[1],maxs[2]);
+	qglVertex3f(maxs[0],maxs[1],mins[2]);
+	qglEnd();
+
+}
+
+void splineTest() {
+	//g_splineList->load("p:/doom/base/maps/test_base1.camera");
+}
+
+void splineDraw() {
+	//g_splineList->addToRenderer();
+}
+
+
+//extern void D_DebugLine( const idVec3_t &color, const idVec3_t &start, const idVec3_t &end );
+
+void debugLine(idVec3_t &color, float x, float y, float z, float x2, float y2, float z2) {
+	//idVec3_t from(x, y, z);
+	//idVec3_t to(x2, y2, z2);
+	//D_DebugLine(color, from, to);
+}
+
+void idSplineList::addToRenderer() {
+
+	if (controlPoints.Num() == 0) {
+		return;
+	}
+
+	idVec3_t mins, maxs;
+	idVec3_t yellow(1.0, 1.0, 0);
+	idVec3_t white(1.0, 1.0, 1.0);
+        int i;
+        
+	for(i = 0; i < controlPoints.Num(); i++) {
+		VectorCopy(*controlPoints[i], mins);
+		VectorCopy(mins, maxs);
+		mins[0] -= 8;
+		mins[1] += 8;
+		mins[2] -= 8;
+		maxs[0] += 8;
+		maxs[1] -= 8;
+		maxs[2] += 8;
+		debugLine( yellow, mins[0], mins[1], mins[2], maxs[0], mins[1], mins[2]);
+		debugLine( yellow, maxs[0], mins[1], mins[2], maxs[0], maxs[1], mins[2]);
+		debugLine( yellow, maxs[0], maxs[1], mins[2], mins[0], maxs[1], mins[2]);
+		debugLine( yellow, mins[0], maxs[1], mins[2], mins[0], mins[1], mins[2]);
+		
+		debugLine( yellow, mins[0], mins[1], maxs[2], maxs[0], mins[1], maxs[2]);
+		debugLine( yellow, maxs[0], mins[1], maxs[2], maxs[0], maxs[1], maxs[2]);
+		debugLine( yellow, maxs[0], maxs[1], maxs[2], mins[0], maxs[1], maxs[2]);
+		debugLine( yellow, mins[0], maxs[1], maxs[2], mins[0], mins[1], maxs[2]);
+	    
+	}
+
+	int step = 0;
+	idVec3_t step1;
+	for(i = 3; i < controlPoints.Num(); i++) {
+		for (float tension = 0.0f; tension < 1.001f; tension += 0.1f) {
+			float x = 0;
+			float y = 0;
+			float z = 0;
+			for (int j = 0; j < 4; j++) {
+				x += controlPoints[i - (3 - j)]->x * calcSpline(j, tension);
+				y += controlPoints[i - (3 - j)]->y * calcSpline(j, tension);
+				z += controlPoints[i - (3 - j)]->z * calcSpline(j, tension);
+			}
+			if (step == 0) {
+				step1[0] = x;
+				step1[1] = y;
+				step1[2] = z;
+				step = 1;
+			} else {
+				debugLine( white, step1[0], step1[1], step1[2], x, y, z);
+				step = 0;
+			}
+
+		}
+	}
+}
+
+void idSplineList::buildSpline() {
+	//int start = Sys_Milliseconds();
+	clearSpline();
+	for(int i = 3; i < controlPoints.Num(); i++) {
+		for (float tension = 0.0f; tension < 1.001f; tension += granularity) {
+			float x = 0;
+			float y = 0;
+			float z = 0;
+			for (int j = 0; j < 4; j++) {
+				x += controlPoints[i - (3 - j)]->x * calcSpline(j, tension);
+				y += controlPoints[i - (3 - j)]->y * calcSpline(j, tension);
+				z += controlPoints[i - (3 - j)]->z * calcSpline(j, tension);
+			}
+			splinePoints.Append(new idVec3_t(x, y, z));
+		}
+	}
+	dirty = false;
+	//Com_Printf("Spline build took %f seconds\n", (float)(Sys_Milliseconds() - start) / 1000);
+}
+
+
+void idSplineList::draw(bool editMode) {
+	int i;
+	vec4_t yellow(1, 1, 0, 1);
+        
+	if (controlPoints.Num() == 0) {
+		return;
+	}
+
+	if (dirty) {
+		buildSpline();
+	}
+
+
+	qglColor3fv(controlColor);
+	qglPointSize(5);
+	
+	qglBegin(GL_POINTS);
+	for (i = 0; i < controlPoints.Num(); i++) {
+		qglVertex3fv(*controlPoints[i]);
+	}
+	qglEnd();
+	
+	if (editMode) {
+		for(i = 0; i < controlPoints.Num(); i++) {
+			glBox(activeColor, *controlPoints[i], 4);
+		}
+	}
+
+	//Draw the curve
+	qglColor3fv(pathColor);
+	qglBegin(GL_LINE_STRIP);
+	int count = splinePoints.Num();
+	for (i = 0; i < count; i++) {
+		qglVertex3fv(*splinePoints[i]);
+	}
+	qglEnd();
+
+	if (editMode) {
+		qglColor3fv(segmentColor);
+		qglPointSize(3);
+		qglBegin(GL_POINTS);
+		for (i = 0; i < count; i++) {
+			qglVertex3fv(*splinePoints[i]);
+		}
+		qglEnd();
+	}
+	if (count > 0) {
+		//assert(activeSegment >=0 && activeSegment < count);
+		if (activeSegment >=0 && activeSegment < count) {
+			glBox(activeColor, *splinePoints[activeSegment], 6);
+			glBox(yellow, *splinePoints[activeSegment], 8);
+		}
+	}
+
+}
+
+float idSplineList::totalDistance() {
+
+	if (controlPoints.Num() == 0) {
+		return 0.0;
+	}
+
+	if (dirty) {
+		buildSpline();
+	}
+
+	float dist = 0.0;
+	idVec3_t temp;
+	int count = splinePoints.Num();
+	for(int i = 1; i < count; i++) {
+		temp = *splinePoints[i-1];
+		temp -= *splinePoints[i];
+		dist += temp.Length();
+	}
+	return dist;
+}
+
+void idSplineList::initPosition(long bt, long totalTime) {
+
+	if (dirty) {
+		buildSpline();
+	}
+
+	if (splinePoints.Num() == 0) {
+		return;
+	}
+
+	baseTime = bt;
+	time = totalTime;
+
+	// calc distance to travel ( this will soon be broken into time segments )
+	splineTime.Clear();
+	splineTime.Append(bt);
+	double dist = totalDistance();
+	double distSoFar = 0.0;
+	idVec3_t temp;
+	int count = splinePoints.Num();
+	//for(int i = 2; i < count - 1; i++) {
+	for(int i = 1; i < count; i++) {
+		temp = *splinePoints[i-1];
+		temp -= *splinePoints[i];
+		distSoFar += temp.Length();
+		double percent = distSoFar / dist;
+		percent *= totalTime;
+		splineTime.Append(percent + bt);
+	}
+	assert(splineTime.Num() == splinePoints.Num());
+	activeSegment = 0;
+}
+
+
+
+float idSplineList::calcSpline(int step, float tension) {
+	switch(step) {
+		case 0:	return (pow(1 - tension, 3)) / 6;
+		case 1:	return (3 * pow(tension, 3) - 6 * pow(tension, 2) + 4) / 6;
+		case 2:	return (-3 * pow(tension, 3) + 3 * pow(tension, 2) + 3 * tension + 1) / 6;
+		case 3:	return pow(tension, 3) / 6;
+	}
+	return 0.0;
+}
+
+
+
+void idSplineList::updateSelection(const idVec3_t &move) {
+	if (selected) {
+		dirty = true;
+		VectorAdd(*selected, move, *selected);
+	}
+}
+
+
+void idSplineList::setSelectedPoint(idVec3_t *p) {
+	if (p) {
+		p->Snap();
+		for(int i = 0; i < controlPoints.Num(); i++) {
+			if (*p == *controlPoints[i]) {
+				selected = controlPoints[i];
+			}
+		}
+	} else {
+		selected = NULL;
+	}
+}
+
+const idVec3_t *idSplineList::getPosition(long t) {
+	static idVec3_t interpolatedPos;
+	//static long lastTime = -1;
+
+	int count = splineTime.Num();
+	if (count == 0) {
+		return &zero;
+	}
+
+	Com_Printf("Time: %d\n", t);
+	assert(splineTime.Num() == splinePoints.Num());
+
+	while (activeSegment < count) {
+		if (splineTime[activeSegment] >= t) {
+			if (activeSegment > 0 && activeSegment < count - 1) {
+				double timeHi = splineTime[activeSegment + 1];
+				double timeLo = splineTime[activeSegment - 1];
+				double percent = (timeHi - t) / (timeHi - timeLo); 
+				// pick two bounding points
+				idVec3_t v1 = *splinePoints[activeSegment-1];
+				idVec3_t v2 = *splinePoints[activeSegment+1];
+				v2 *= (1.0 - percent);
+				v1 *= percent;
+				v2 += v1;
+				interpolatedPos = v2;
+				return &interpolatedPos;
+			}
+			return splinePoints[activeSegment];
+		} else {
+			activeSegment++;
+		}
+	}
+	return splinePoints[count-1];
+}
+
+void idSplineList::parse(const char *(*text)  ) {
+	const char *token;
+	//Com_MatchToken( text, "{" );
+	do {
+		token = Com_Parse( text );
+	
+		if ( !token[0] ) {
+			break;
+		}
+		if ( !Q_stricmp (token, "}") ) {
+			break;
+		}
+
+		do {
+			// if token is not a brace, it is a key for a key/value pair
+			if ( !token[0] || !Q_stricmp (token, "(") || !Q_stricmp(token, "}")) {
+				break;
+			}
+
+			Com_UngetToken();
+			idStr key = Com_ParseOnLine(text);
+			const char *token = Com_Parse(text);
+			if (Q_stricmp(key.c_str(), "granularity") == 0) {
+				granularity = atof(token);
+			} else if (Q_stricmp(key.c_str(), "name") == 0) {
+				name = token;
+			}
+			token = Com_Parse(text);
+
+		} while (1);
+
+		if ( !Q_stricmp (token, "}") ) {
+			break;
+		}
+
+		Com_UngetToken();
+		// read the control point
+		idVec3_t point;
+		Com_Parse1DMatrix( text, 3, point );
+		addPoint(point.x, point.y, point.z);
+	} while (1);
+ 
+	//Com_UngetToken();
+	//Com_MatchToken( text, "}" );
+	dirty = true;
+}
+
+void idSplineList::write(fileHandle_t file, const char *p) {
+	idStr s = va("\t\t%s {\n", p);
+	FS_Write(s.c_str(), s.length(), file);
+	//s = va("\t\tname %s\n", name.c_str());
+	//FS_Write(s.c_str(), s.length(), file);
+	s = va("\t\t\tgranularity %f\n", granularity);
+	FS_Write(s.c_str(), s.length(), file);
+	int count = controlPoints.Num();
+	for (int i = 0; i < count; i++) {
+		s = va("\t\t\t( %f %f %f )\n", controlPoints[i]->x, controlPoints[i]->y, controlPoints[i]->z);
+		FS_Write(s.c_str(), s.length(), file);
+	}
+	s = "\t\t}\n";
+	FS_Write(s.c_str(), s.length(), file);
+}
+
+
+void idCameraDef::getActiveSegmentInfo(int segment, idVec3_t &origin, idVec3_t &direction, float *fov) {
+#if 0
+	if (!cameraSpline.validTime()) {
+		buildCamera();
+	}
+	double d = (double)segment / numSegments();
+	getCameraInfo(d * totalTime * 1000, origin, direction, fov);
+#endif
+/*
+	if (!cameraSpline.validTime()) {
+		buildCamera();
+	}
+	origin = *cameraSpline.getSegmentPoint(segment);
+	
+
+	idVec3_t temp;
+
+	int numTargets = getTargetSpline()->controlPoints.Num();
+	int count = cameraSpline.splineTime.Num();
+	if (numTargets == 0) {
+		// follow the path
+		if (cameraSpline.getActiveSegment() < count - 1) {
+			temp = *cameraSpline.splinePoints[cameraSpline.getActiveSegment()+1];
+		}
+	} else if (numTargets == 1) {
+		temp = *getTargetSpline()->controlPoints[0];
+	} else {
+		temp = *getTargetSpline()->getSegmentPoint(segment);
+	}
+
+	temp -= origin;
+	temp.Normalize();
+	direction = temp;
+*/
+}
+
+bool idCameraDef::getCameraInfo(long time, idVec3_t &origin, idVec3_t &direction, float *fv) {
+
+
+	if ((time - startTime) / 1000 > totalTime) {
+		return false;
+	}
+
+
+	for (int i = 0; i < events.Num(); i++) {
+		if (time >= startTime + events[i]->getTime() && !events[i]->getTriggered()) {
+			events[i]->setTriggered(true);
+			if (events[i]->getType() == idCameraEvent::EVENT_TARGET) {
+				setActiveTargetByName(events[i]->getParam());
+				getActiveTarget()->start(startTime + events[i]->getTime());
+				//Com_Printf("Triggered event switch to target: %s\n",events[i]->getParam());
+			} else if (events[i]->getType() == idCameraEvent::EVENT_TRIGGER) {
+				//idEntity *ent = NULL;
+				//ent = level.FindTarget( ent, events[i]->getParam());
+				//if (ent) {
+				//	ent->signal( SIG_TRIGGER );
+				//	ent->ProcessEvent( &EV_Activate, world );
+				//}
+			} else if (events[i]->getType() == idCameraEvent::EVENT_FOV) {
+				//*fv = fov = atof(events[i]->getParam());
+			} else if (events[i]->getType() == idCameraEvent::EVENT_STOP) {
+				return false;
+			}
+		}
+	}
+
+	origin = *cameraPosition->getPosition(time);
+	
+	*fv = fov.getFOV(time);
+
+	idVec3_t temp = origin;
+
+	int numTargets = targetPositions.Num();
+	if (numTargets == 0) {
+/*
+		// follow the path
+		if (cameraSpline.getActiveSegment() < count - 1) {
+			temp = *cameraSpline.splinePoints[cameraSpline.getActiveSegment()+1];
+			if (temp == origin) {
+				int index = cameraSpline.getActiveSegment() + 2;
+				while (temp == origin && index < count - 1) {
+					temp = *cameraSpline.splinePoints[index++];
+				}
+			}
+		}
+*/
+	} else {
+		temp = *getActiveTarget()->getPosition(time);
+	}
+	
+	temp -= origin;
+	temp.Normalize();
+	direction = temp;
+
+	return true;
+}
+
+bool idCameraDef::waitEvent(int index) {
+	//for (int i = 0; i < events.Num(); i++) {
+	//	if (events[i]->getSegment() == index && events[i]->getType() == idCameraEvent::EVENT_WAIT) {
+	//		return true;
+	//	}
+    //}
+	return false;
+}
+
+
+#define NUM_CCELERATION_SEGS 10
+#define CELL_AMT 5
+
+void idCameraDef::buildCamera() {
+	int i;
+	//int lastSwitch = 0;
+	idList<float> waits;
+	idList<int> targets;
+
+	totalTime = baseTime;
+	cameraPosition->setTime(totalTime * 1000);
+	// we have a base time layout for the path and the target path
+	// now we need to layer on any wait or speed changes
+	for (i = 0; i < events.Num(); i++) {
+		//idCameraEvent *ev = events[i];
+		events[i]->setTriggered(false);
+		switch (events[i]->getType()) {
+			case idCameraEvent::EVENT_TARGET : {
+				targets.Append(i);
+				break;
+			}
+			case idCameraEvent::EVENT_WAIT : {
+				waits.Append(atof(events[i]->getParam()));
+				cameraPosition->addVelocity(events[i]->getTime(), atof(events[i]->getParam()) * 1000, 0);
+				break;
+			}
+			case idCameraEvent::EVENT_TARGETWAIT : {
+				//targetWaits.Append(i);
+				break;
+			}
+			case idCameraEvent::EVENT_SPEED : {
+/*
+				// take the average delay between up to the next five segments
+				float adjust = atof(events[i]->getParam());
+				int index = events[i]->getSegment();
+				total = 0;
+				count = 0;
+
+				// get total amount of time over the remainder of the segment
+				for (j = index; j < cameraSpline.numSegments() - 1; j++) {
+					total += cameraSpline.getSegmentTime(j + 1) - cameraSpline.getSegmentTime(j);
+					count++;
+				}
+
+				// multiply that by the adjustment
+				double newTotal = total * adjust;
+				// what is the difference.. 
+				newTotal -= total;
+				totalTime += newTotal / 1000;
+
+				// per segment difference
+				newTotal /= count;
+				int additive = newTotal;
+
+				// now propogate that difference out to each segment
+				for (j = index; j < cameraSpline.numSegments(); j++) {
+					cameraSpline.addSegmentTime(j, additive);
+					additive += newTotal;
+				}
+				break;
+*/
+			}
+    default: break; // FIXME: what about other idCameraEvent?
+		}
+	}
+
+
+	for (i = 0; i < waits.Num(); i++) {
+		totalTime += waits[i];
+	}
+
+	// on a new target switch, we need to take time to this point ( since last target switch ) 
+	// and allocate it across the active target, then reset time to this point
+	long timeSoFar = 0;
+	long total = (int)(totalTime * 1000);
+	for (i = 0; i < targets.Num(); i++) {
+		long t;
+		if (i < targets.Num() - 1) {
+			t = events[targets[i+1]]->getTime();
+		} else {
+			t = total - timeSoFar;
+		}
+		// t is how much time to use for this target
+		setActiveTargetByName(events[targets[i]]->getParam());
+		getActiveTarget()->setTime(t);
+		timeSoFar += t;
+	}
+
+	
+}
+
+void idCameraDef::startCamera(long t) {
+	buildCamera();
+	cameraPosition->start(t);
+	//for (int i = 0; i < targetPositions.Num(); i++) {
+	//	targetPositions[i]->
+	//}
+	startTime = t;
+	cameraRunning = true;
+}
+
+
+void idCameraDef::parse(const char *(*text)  ) {
+
+	const char	*token;
+	do {
+		token = Com_Parse( text );
+	
+		if ( !token[0] ) {
+			break;
+		}
+		if ( !Q_stricmp (token, "}") ) {
+			break;
+		}
+
+		if (Q_stricmp(token, "time") == 0) {
+			baseTime = Com_ParseFloat(text);
+		}
+
+		if (Q_stricmp(token, "camera_fixed") == 0) {
+			cameraPosition = new idFixedPosition();
+			cameraPosition->parse(text);
+		}
+
+		if (Q_stricmp(token, "camera_interpolated") == 0) {
+			cameraPosition = new idInterpolatedPosition();
+			cameraPosition->parse(text);
+		}
+
+		if (Q_stricmp(token, "camera_spline") == 0) {
+			cameraPosition = new idSplinePosition();
+			cameraPosition->parse(text);
+		}
+
+		if (Q_stricmp(token, "target_fixed") == 0) {
+			idFixedPosition *pos = new idFixedPosition();
+			pos->parse(text);
+			targetPositions.Append(pos);
+		}
+		
+		if (Q_stricmp(token, "target_interpolated") == 0) {
+			idInterpolatedPosition *pos = new idInterpolatedPosition();
+			pos->parse(text);
+			targetPositions.Append(pos);
+		}
+
+		if (Q_stricmp(token, "target_spline") == 0) {
+			idSplinePosition *pos = new idSplinePosition();
+			pos->parse(text);
+			targetPositions.Append(pos);
+		}
+
+		if (Q_stricmp(token, "fov") == 0) {
+			fov.parse(text);
+		}
+
+		if (Q_stricmp(token, "event") == 0) {
+			idCameraEvent *event = new idCameraEvent();
+			event->parse(text);
+			addEvent(event);
+		}
+
+
+	} while (1);
+
+	Com_UngetToken();
+	Com_MatchToken( text, "}" );
+
+}
+
+qboolean idCameraDef::load(const char *filename) {
+	char *buf;
+	const char *buf_p;
+	//int length = 
+  FS_ReadFile( filename, (void **)&buf );
+	if ( !buf ) {
+		return qfalse;
+	}
+
+	clear();
+	Com_BeginParseSession( filename );
+	buf_p = buf;
+	parse(&buf_p);
+	Com_EndParseSession();
+	FS_FreeFile( buf );
+
+	return qtrue;
+}
+
+void idCameraDef::save(const char *filename) {
+	fileHandle_t file = FS_FOpenFileWrite(filename);
+	if (file) {
+		int i;
+		idStr s = "cameraPathDef { \n"; 
+		FS_Write(s.c_str(), s.length(), file);
+		s = va("\ttime %f\n", baseTime);
+		FS_Write(s.c_str(), s.length(), file);
+
+		cameraPosition->write(file, va("camera_%s",cameraPosition->typeStr()));
+
+		for (i = 0; i < numTargets(); i++) {
+			targetPositions[i]->write(file, va("target_%s", targetPositions[i]->typeStr()));
+		}
+
+		for (i = 0; i < events.Num(); i++) {
+			events[i]->write(file, "event");
+		}
+
+		fov.write(file, "fov");
+
+		s = "}\n";
+		FS_Write(s.c_str(), s.length(), file);
+	}
+	FS_FCloseFile(file);
+}
+
+int idCameraDef::sortEvents(const void *p1, const void *p2) {
+	idCameraEvent *ev1 = (idCameraEvent*)(p1);
+	idCameraEvent *ev2 = (idCameraEvent*)(p2);
+
+	if (ev1->getTime() > ev2->getTime()) {
+		return -1;
+	}
+	if (ev1->getTime() < ev2->getTime()) {
+		return 1;
+	}
+	return 0; 
+}
+
+void idCameraDef::addEvent(idCameraEvent *event) {
+	events.Append(event);
+	//events.Sort(&sortEvents);
+
+}
+void idCameraDef::addEvent(idCameraEvent::eventType t, const char *param, long time) {
+	addEvent(new idCameraEvent(t, param, time));
+	buildCamera();
+}
+
+
+const char *idCameraEvent::eventStr[] = {
+	"NA",
+	"WAIT",
+	"TARGETWAIT",
+	"SPEED",
+	"TARGET",
+	"SNAPTARGET",
+	"FOV",
+	"SCRIPT",
+	"TRIGGER",
+	"STOP"
+};
+
+void idCameraEvent::parse(const char *(*text)  ) {
+	const char *token;
+	Com_MatchToken( text, "{" );
+	do {
+		token = Com_Parse( text );
+	
+		if ( !token[0] ) {
+			break;
+		}
+		if ( !strcmp (token, "}") ) {
+			break;
+		}
+
+		// here we may have to jump over brush epairs ( only used in editor )
+		do {
+			// if token is not a brace, it is a key for a key/value pair
+			if ( !token[0] || !strcmp (token, "(") || !strcmp(token, "}")) {
+				break;
+			}
+
+			Com_UngetToken();
+			idStr key = Com_ParseOnLine(text);
+			const char *token = Com_Parse(text);
+			if (Q_stricmp(key.c_str(), "type") == 0) {
+				type = static_cast<idCameraEvent::eventType>(atoi(token));
+			} else if (Q_stricmp(key.c_str(), "param") == 0) {
+				paramStr = token;
+			} else if (Q_stricmp(key.c_str(), "time") == 0) {
+				time = atoi(token);
+			}
+			token = Com_Parse(text);
+
+		} while (1);
+
+		if ( !strcmp (token, "}") ) {
+			break;
+		}
+
+	} while (1);
+ 
+	Com_UngetToken();
+	Com_MatchToken( text, "}" );
+}
+
+void idCameraEvent::write(fileHandle_t file, const char *name) {
+	idStr s = va("\t%s {\n", name);
+	FS_Write(s.c_str(), s.length(), file);
+	s = va("\t\ttype %d\n", static_cast<int>(type));
+	FS_Write(s.c_str(), s.length(), file);
+	s = va("\t\tparam %s\n", paramStr.c_str());
+	FS_Write(s.c_str(), s.length(), file);
+	s = va("\t\ttime %d\n", time);
+	FS_Write(s.c_str(), s.length(), file);
+	s = "\t}\n";
+	FS_Write(s.c_str(), s.length(), file);
+}
+
+
+const char *idCameraPosition::positionStr[] = {
+	"Fixed",
+	"Interpolated",
+	"Spline",
+};
+
+
+
+const idVec3_t *idInterpolatedPosition::getPosition(long t) { 
+	static idVec3_t interpolatedPos;
+
+	float velocity = getVelocity(t);
+	float timePassed = t - lastTime;
+	lastTime = t;
+
+	// convert to seconds	
+	timePassed /= 1000;
+
+	float distToTravel = timePassed *= velocity;
+
+	idVec3_t temp = startPos;
+	temp -= endPos;
+	float distance = temp.Length();
+
+	distSoFar += distToTravel;
+	float percent = (float)(distSoFar) / distance;
+
+	if (percent > 1.0) {
+		percent = 1.0;
+	} else if (percent < 0.0) {
+		percent = 0.0;
+	}
+
+	// the following line does a straigt calc on percentage of time
+	// float percent = (float)(startTime + time - t) / time;
+
+	idVec3_t v1 = startPos;
+	idVec3_t v2 = endPos;
+	v1 *= (1.0 - percent);
+	v2 *= percent;
+	v1 += v2;
+	interpolatedPos = v1;
+	return &interpolatedPos;
+}
+
+
+void idCameraFOV::parse(const char *(*text)  ) {
+	const char *token;
+	Com_MatchToken( text, "{" );
+	do {
+		token = Com_Parse( text );
+	
+		if ( !token[0] ) {
+			break;
+		}
+		if ( !strcmp (token, "}") ) {
+			break;
+		}
+
+		// here we may have to jump over brush epairs ( only used in editor )
+		do {
+			// if token is not a brace, it is a key for a key/value pair
+			if ( !token[0] || !strcmp (token, "(") || !strcmp(token, "}")) {
+				break;
+			}
+
+			Com_UngetToken();
+			idStr key = Com_ParseOnLine(text);
+			const char *token = Com_Parse(text);
+			if (Q_stricmp(key.c_str(), "fov") == 0) {
+				fov = atof(token);
+			} else if (Q_stricmp(key.c_str(), "startFOV") == 0) {
+				startFOV = atof(token);
+			} else if (Q_stricmp(key.c_str(), "endFOV") == 0) {
+				endFOV = atof(token);
+			} else if (Q_stricmp(key.c_str(), "time") == 0) {
+				time = atoi(token);
+			}
+			token = Com_Parse(text);
+
+		} while (1);
+
+		if ( !strcmp (token, "}") ) {
+			break;
+		}
+
+	} while (1);
+ 
+	Com_UngetToken();
+	Com_MatchToken( text, "}" );
+}
+
+bool idCameraPosition::parseToken(const char *key, const char *(*text)) {
+	const char *token = Com_Parse(text);
+	if (Q_stricmp(key, "time") == 0) {
+		time = atol(token);
+		return true;
+	} else if (Q_stricmp(key, "type") == 0) {
+		type = static_cast<idCameraPosition::positionType>(atoi(token));
+		return true;
+	} else if (Q_stricmp(key, "velocity") == 0) {
+		long t = atol(token);
+		token = Com_Parse(text);
+		long d = atol(token);
+		token = Com_Parse(text);
+		float s = atof(token);
+		addVelocity(t, d, s);
+		return true;
+	} else if (Q_stricmp(key, "baseVelocity") == 0) {
+		baseVelocity = atof(token);
+		return true;
+	} else if (Q_stricmp(key, "name") == 0) {
+		name = token;
+		return true;
+	} else if (Q_stricmp(key, "time") == 0) {
+		time = atoi(token);
+		return true;
+	}
+	Com_UngetToken();
+	return false;
+}
+
+
+
+void idFixedPosition::parse(const char *(*text)  ) {
+	const char *token;
+	Com_MatchToken( text, "{" );
+	do {
+		token = Com_Parse( text );
+	
+		if ( !token[0] ) {
+			break;
+		}
+		if ( !strcmp (token, "}") ) {
+			break;
+		}
+
+		// here we may have to jump over brush epairs ( only used in editor )
+		do {
+			// if token is not a brace, it is a key for a key/value pair
+			if ( !token[0] || !strcmp (token, "(") || !strcmp(token, "}")) {
+				break;
+			}
+
+			Com_UngetToken();
+			idStr key = Com_ParseOnLine(text);
+			
+			const char *token = Com_Parse(text);
+			if (Q_stricmp(key.c_str(), "pos") == 0) {
+				Com_UngetToken();
+				Com_Parse1DMatrix( text, 3, pos );
+			} else {
+				Com_UngetToken();
+				idCameraPosition::parseToken(key.c_str(), text);	
+			}
+			token = Com_Parse(text);
+
+		} while (1);
+
+		if ( !strcmp (token, "}") ) {
+			break;
+		}
+
+	} while (1);
+ 
+	Com_UngetToken();
+	Com_MatchToken( text, "}" );
+}
+
+void idInterpolatedPosition::parse(const char *(*text)  ) {
+	const char *token;
+	Com_MatchToken( text, "{" );
+	do {
+		token = Com_Parse( text );
+	
+		if ( !token[0] ) {
+			break;
+		}
+		if ( !strcmp (token, "}") ) {
+			break;
+		}
+
+		// here we may have to jump over brush epairs ( only used in editor )
+		do {
+			// if token is not a brace, it is a key for a key/value pair
+			if ( !token[0] || !strcmp (token, "(") || !strcmp(token, "}")) {
+				break;
+			}
+
+			Com_UngetToken();
+			idStr key = Com_ParseOnLine(text);
+			
+			const char *token = Com_Parse(text);
+			if (Q_stricmp(key.c_str(), "startPos") == 0) {
+				Com_UngetToken();
+				Com_Parse1DMatrix( text, 3, startPos );
+			} else if (Q_stricmp(key.c_str(), "endPos") == 0) {
+				Com_UngetToken();
+				Com_Parse1DMatrix( text, 3, endPos );
+			} else {
+				Com_UngetToken();
+				idCameraPosition::parseToken(key.c_str(), text);	
+			}
+			token = Com_Parse(text);
+
+		} while (1);
+
+		if ( !strcmp (token, "}") ) {
+			break;
+		}
+
+	} while (1);
+ 
+	Com_UngetToken();
+	Com_MatchToken( text, "}" );
+}
+
+
+void idSplinePosition::parse(const char *(*text)  ) {
+	const char *token;
+	Com_MatchToken( text, "{" );
+	do {
+		token = Com_Parse( text );
+	
+		if ( !token[0] ) {
+			break;
+		}
+		if ( !strcmp (token, "}") ) {
+			break;
+		}
+
+		// here we may have to jump over brush epairs ( only used in editor )
+		do {
+			// if token is not a brace, it is a key for a key/value pair
+			if ( !token[0] || !strcmp (token, "(") || !strcmp(token, "}")) {
+				break;
+			}
+
+			Com_UngetToken();
+			idStr key = Com_ParseOnLine(text);
+			
+			const char *token = Com_Parse(text);
+			if (Q_stricmp(key.c_str(), "target") == 0) {
+				target.parse(text);
+			} else {
+				Com_UngetToken();
+				idCameraPosition::parseToken(key.c_str(), text);	
+			}
+			token = Com_Parse(text);
+
+		} while (1);
+
+		if ( !strcmp (token, "}") ) {
+			break;
+		}
+
+	} while (1);
+ 
+	Com_UngetToken();
+	Com_MatchToken( text, "}" );
+}
+
+
+
+void idCameraFOV::write(fileHandle_t file, const char *p) {
+	idStr s = va("\t%s {\n", p);
+	FS_Write(s.c_str(), s.length(), file);
+	
+	s = va("\t\tfov %f\n", fov);
+	FS_Write(s.c_str(), s.length(), file);
+
+	s = va("\t\tstartFOV %f\n", startFOV);
+	FS_Write(s.c_str(), s.length(), file);
+
+	s = va("\t\tendFOV %f\n", endFOV);
+	FS_Write(s.c_str(), s.length(), file);
+
+	s = va("\t\ttime %i\n", time);
+	FS_Write(s.c_str(), s.length(), file);
+
+	s = "\t}\n";
+	FS_Write(s.c_str(), s.length(), file);
+}
+
+
+void idCameraPosition::write(fileHandle_t file, const char *p) {
+	
+	idStr s = va("\t\ttime %i\n", time);
+	FS_Write(s.c_str(), s.length(), file);
+
+	s = va("\t\ttype %i\n", static_cast<int>(type));
+	FS_Write(s.c_str(), s.length(), file);
+
+	s = va("\t\tname %s\n", name.c_str());
+	FS_Write(s.c_str(), s.length(), file);
+
+	s = va("\t\tbaseVelocity %f\n", baseVelocity);
+	FS_Write(s.c_str(), s.length(), file);
+
+	for (int i = 0; i < velocities.Num(); i++) {
+		s = va("\t\tvelocity %i %i %f\n", velocities[i]->startTime, velocities[i]->time, velocities[i]->speed);
+		FS_Write(s.c_str(), s.length(), file);
+	}
+
+}
+
+void idFixedPosition::write(fileHandle_t file, const char *p) {
+	idStr s = va("\t%s {\n", p);
+	FS_Write(s.c_str(), s.length(), file);
+	idCameraPosition::write(file, p);
+	s = va("\t\tpos ( %f %f %f )\n", pos.x, pos.y, pos.z);
+	FS_Write(s.c_str(), s.length(), file);
+	s = "\t}\n";
+	FS_Write(s.c_str(), s.length(), file);
+}
+
+void idInterpolatedPosition::write(fileHandle_t file, const char *p) {
+	idStr s = va("\t%s {\n", p);
+	FS_Write(s.c_str(), s.length(), file);
+	idCameraPosition::write(file, p);
+	s = va("\t\tstartPos ( %f %f %f )\n", startPos.x, startPos.y, startPos.z);
+	FS_Write(s.c_str(), s.length(), file);
+	s = va("\t\tendPos ( %f %f %f )\n", endPos.x, endPos.y, endPos.z);
+	FS_Write(s.c_str(), s.length(), file);
+	s = "\t}\n";
+	FS_Write(s.c_str(), s.length(), file);
+}
+
+void idSplinePosition::write(fileHandle_t file, const char *p) {
+	idStr s = va("\t%s {\n", p);
+	FS_Write(s.c_str(), s.length(), file);
+	idCameraPosition::write(file, p);
+	target.write(file, "target");
+	s = "\t}\n";
+	FS_Write(s.c_str(), s.length(), file);
+}
+
+void idCameraDef::addTarget(const char *name, idCameraPosition::positionType type) {
+	//const char *text = (name == NULL) ? va("target0%d", numTargets()+1) : name; // TTimo: unused
+	idCameraPosition *pos = newFromType(type);
+	if (pos) {
+		pos->setName(name);
+		targetPositions.Append(pos);
+		activeTarget = numTargets()-1;
+		if (activeTarget == 0) {
+			// first one
+			addEvent(idCameraEvent::EVENT_TARGET, name, 0);
+		}
+	}
+}
+
+
+
+idCameraDef camera;
+
+extern "C" {
+qboolean loadCamera(const char *name) {
+  camera.clear();
+  return static_cast<qboolean>(camera.load(name));
+}
+
+qboolean getCameraInfo(int time, float *origin, float*angles) {
+	idVec3_t dir, org;
+	org[0] = origin[0];
+	org[1] = origin[1];
+	org[2] = origin[2];
+	float fov = 90;
+	if (camera.getCameraInfo(time, org, dir, &fov)) {
+		origin[0] = org[0];
+		origin[1] = org[1];
+		origin[2] = org[2];
+		angles[1] = atan2 (dir[1], dir[0])*180/3.14159;
+		angles[0] = asin (dir[2])*180/3.14159;
+		return qtrue;
+	}
+	return qfalse;
+}
+
+void startCamera(int time) {
+	camera.startCamera(time);
+}
+
+}
+
+
diff --git a/codemp/Splines/splines.h b/codemp/Splines/splines.h
new file mode 100644
index 0000000..5454aff
--- /dev/null
+++ b/codemp/Splines/splines.h
@@ -0,0 +1,1061 @@
+#ifndef __SPLINES_H
+#define __SPLINES_H
+
+extern "C" {
+#ifdef Q3RADIANT
+#include "../qgl.h"
+#else
+#include "../renderer/qgl.h"
+#endif
+}
+#include "util_list.h"
+#include "util_str.h"
+#include "math_vector.h"
+
+typedef int fileHandle_t;
+
+extern void glBox(idVec3_t &color, idVec3_t &point, float size);
+extern void glLabeledPoint(idVec3_t &color, idVec3_t &point, float size, const char *label);
+
+static vec4_t blue(0, 0, 1, 1);
+static vec4_t red(1, 0, 0, 1);
+
+class idPointListInterface {
+public:
+	idPointListInterface() {
+		selectedPoints.Clear();
+	}
+	virtual ~idPointListInterface() {}
+	
+	virtual int numPoints() {
+		return 0;
+	}
+	
+	virtual void addPoint(const float x, const float y, const float z) {}
+	virtual void addPoint(const idVec3_t &v) {}
+	virtual void removePoint(int index) {}
+	virtual idVec3_t *getPoint(int index) { return NULL; }
+	
+	int	selectPointByRay(float ox, float oy, float oz, float dx, float dy, float dz, bool single) {
+		idVec3_t origin(ox, oy, oz);
+		idVec3_t dir(dx, dy, dz);
+		return selectPointByRay(origin, dir, single);
+	}
+
+	int	selectPointByRay(const idVec3_t origin, const idVec3_t direction, bool single) {
+		int		i, besti, count;
+		float	d, bestd;
+		idVec3_t	temp, temp2;
+
+		// find the point closest to the ray
+		besti = -1;
+		bestd = 8;
+		count = numPoints();
+
+		for (i=0; i < count; i++) {
+			temp = *getPoint(i);
+			temp2 = temp;
+			temp -= origin;
+			d = DotProduct(temp, direction);
+			__VectorMA (origin, d, direction, temp);
+			temp2 -= temp;
+			d = temp2.Length();
+			if (d <= bestd) {
+				bestd = d;
+				besti = i;
+			}
+		}
+
+		if (besti >= 0) {
+			selectPoint(besti, single);
+		}
+
+		return besti;
+	}
+
+	int isPointSelected(int index) {
+		int count = selectedPoints.Num();
+		for (int i = 0; i < count; i++) {
+			if (selectedPoints[i] == index) {
+				return i;
+			}
+		}
+		return -1;
+	}
+	
+	int selectPoint(int index, bool single) {
+		if (index >= 0 && index < numPoints()) {
+			if (single) {
+				deselectAll();
+			} else {
+				if (isPointSelected(index) >= 0) {
+					selectedPoints.Remove(index);
+				}
+			}
+			return selectedPoints.Append(index);
+		}
+		return -1;
+	}
+	
+	void selectAll() {
+		selectedPoints.Clear();
+		for (int i = 0; i < numPoints(); i++) {
+			selectedPoints.Append(i);
+		}
+	}
+
+	void deselectAll() {
+		selectedPoints.Clear();
+	}
+
+	int numSelectedPoints();
+    
+	idVec3_t *getSelectedPoint(int index) {
+		assert(index >= 0 && index < numSelectedPoints());
+		return getPoint(selectedPoints[index]);
+	}
+	
+	virtual void updateSelection(float x, float y, float z) {
+		idVec3_t move(x, y, z);
+		updateSelection(move);
+	}
+
+	virtual void updateSelection(const idVec3_t &move) {
+		int count = selectedPoints.Num();
+		for (int i = 0; i < count; i++) {
+			*getPoint(selectedPoints[i]) += move;
+		}
+	}
+
+	void drawSelection() {
+		int count = selectedPoints.Num();
+		for (int i = 0; i < count; i++) {
+			glBox(red, *getPoint(selectedPoints[i]), 4);
+		}
+	}
+
+protected:
+	idList<int> selectedPoints;
+
+};
+
+
+class idSplineList {
+
+public:
+
+	idSplineList() {
+		clear();
+	}
+
+	idSplineList(const char *p) {
+		clear();
+		name = p;
+	};
+
+	~idSplineList() {
+		clear();
+	};
+
+	void clearControl() {
+		for (int i = 0; i < controlPoints.Num(); i++) {
+			delete controlPoints[i];
+		}
+		controlPoints.Clear();
+	}
+
+	void clearSpline() {
+		for (int i = 0; i < splinePoints.Num(); i++) {
+			delete splinePoints[i];
+		}
+		splinePoints.Clear();
+	}
+
+	void parse(const char *(*text));
+	void write(fileHandle_t file, const char *name);
+
+	void clear() {
+		clearControl();
+		clearSpline();
+		splineTime.Clear();
+		selected = NULL;
+		dirty = true;
+		activeSegment = 0;
+		granularity = 0.025;
+		pathColor.set(1.0, 0.5, 0.0);
+		controlColor.set(0.7, 0.0, 1.0);
+		segmentColor.set(0.0, 0.0, 1.0);
+		activeColor.set(1.0, 0.0, 0.0);
+	}
+
+	void initPosition(long startTime, long totalTime);
+	const idVec3_t *getPosition(long time);
+
+
+	void draw(bool editMode);
+	void addToRenderer();
+
+	void setSelectedPoint(idVec3_t *p);
+	idVec3_t *getSelectedPoint() {
+	  return selected;
+	}
+
+	void addPoint(const idVec3_t &v) {
+		controlPoints.Append(new idVec3_t(v));
+		dirty = true;
+	}
+
+	void addPoint(float x, float y, float z) {
+		controlPoints.Append(new idVec3_t(x, y, z));
+		dirty = true;
+	}
+
+	void updateSelection(const idVec3_t &move);
+
+	void startEdit() {
+		editMode = true;
+	}
+		
+	void stopEdit() {
+		editMode = false;
+	}
+
+	void buildSpline();
+
+	void setGranularity(float f) {
+		granularity = f;
+	}
+
+	float getGranularity() {
+		return granularity;
+	}
+
+	int numPoints() {
+		return controlPoints.Num();
+	}
+
+	idVec3_t *getPoint(int index) {
+		assert(index >= 0 && index < controlPoints.Num());
+		return controlPoints[index];
+	}
+
+	idVec3_t *getSegmentPoint(int index) {
+		assert(index >= 0 && index < splinePoints.Num());
+		return splinePoints[index];
+	}
+
+
+	void setSegmentTime(int index, int time) {
+		assert(index >= 0 && index < splinePoints.Num());
+		splineTime[index] = time;
+	}
+
+	double getSegmentTime(int index) {
+		assert(index >= 0 && index < splinePoints.Num());
+		return splineTime[index];
+	}
+	void addSegmentTime(int index, int time) {
+		assert(index >= 0 && index < splinePoints.Num());
+		splineTime[index] += time;
+	}
+
+	float totalDistance();
+
+	static idVec3_t zero;
+
+	int getActiveSegment() {
+		return activeSegment;
+	}
+
+	void setActiveSegment(int i) {
+		//assert(i >= 0 && (splinePoints.Num() > 0 && i < splinePoints.Num()));
+		activeSegment = i;
+	}
+
+	int numSegments() {
+		return splinePoints.Num();
+	}
+
+	void setColors(idVec3_t &path, idVec3_t &segment, idVec3_t &control, idVec3_t &active) {
+		pathColor = path;
+		segmentColor = segment;
+		controlColor = control;
+		activeColor = active;
+	}
+
+	const char *getName() {
+		return name.c_str();
+	}
+
+	void setName(const char *p) {
+		name = p;
+	}
+
+	bool validTime() {
+		if (dirty) {
+			buildSpline();
+		}
+		// gcc doesn't allow static casting away from bools
+		// why?  I've no idea...
+		return (bool)(splineTime.Num() > 0 && splineTime.Num() == splinePoints.Num());
+	}
+
+	void setTime(long t) {
+		time = t;
+	}
+
+	void setBaseTime(long t) {
+		baseTime = t;
+	}
+
+protected:
+	idStr name;
+	float calcSpline(int step, float tension);
+	idList<idVec3_t*> controlPoints;
+	idList<idVec3_t*> splinePoints;
+	idList<double> splineTime;
+	idVec3_t *selected;
+	idVec3_t pathColor, segmentColor, controlColor, activeColor;
+	float granularity;
+	bool editMode;
+	bool dirty;
+	int activeSegment;
+	long baseTime;
+	long time;
+	friend class idCamera;
+};
+
+// time in milliseconds 
+// velocity where 1.0 equal rough walking speed
+struct idVelocity {
+	idVelocity(long start, long duration, float s) {
+		startTime = start;
+		time = duration;
+		speed = s;
+	}
+	long	startTime;
+	long	time;
+	float	speed;
+};
+
+// can either be a look at or origin position for a camera
+// 
+class idCameraPosition : public idPointListInterface {
+public:
+	
+	virtual void clear() {
+		editMode = false;
+		for (int i = 0; i < velocities.Num(); i++) {
+			delete velocities[i];
+			velocities[i] = NULL;
+		}
+		velocities.Clear();
+	}
+
+	idCameraPosition(const char *p) {
+		name = p;
+	}
+
+	idCameraPosition() {
+		time = 0;
+		name = "position";
+	}
+
+	idCameraPosition(long t) {
+		time = t;
+	}
+
+	virtual ~idCameraPosition() {
+		clear();
+	}
+
+	
+	// this can be done with RTTI syntax but i like the derived classes setting a type
+	// makes serialization a bit easier to see
+	//
+	enum positionType {
+		FIXED = 0x00,
+		INTERPOLATED,
+		SPLINE,
+		POSITION_COUNT
+	};
+
+
+	virtual void start(long t) {
+		startTime = t;
+	}
+
+	long getTime() {
+		return time;
+	}
+
+	virtual void setTime(long t) {
+		time = t;
+	}
+
+	float getVelocity(long t) {
+		long check = t - startTime;
+		for (int i = 0; i < velocities.Num(); i++) {
+			if (check >= velocities[i]->startTime && check <= velocities[i]->startTime + velocities[i]->time) {
+				return velocities[i]->speed;
+			}
+		}
+		return baseVelocity;
+	}
+
+	void addVelocity(long start, long duration, float speed) {
+		velocities.Append(new idVelocity(start, duration, speed));
+	}
+
+	virtual const idVec3_t *getPosition(long t) { 
+		assert(true);
+		return NULL;
+	}
+
+	virtual void draw(bool editMode) {};
+
+	virtual void parse(const char *(*text)) {};
+	virtual void write(fileHandle_t file, const char *name);
+	virtual bool parseToken(const char *key, const char *(*text));
+
+	const char *getName() {
+		return name.c_str();
+	}
+
+	void setName(const char *p) {
+		name = p;
+	}
+
+	virtual void startEdit() {
+		editMode = true;
+	}
+
+	virtual void stopEdit() {
+		editMode = false;
+	}
+
+	virtual void draw() {};
+
+	const char *typeStr() {
+		return positionStr[static_cast<int>(type)];
+	}
+
+	void calcVelocity(float distance) {
+		float secs = (float)time / 1000;
+		baseVelocity = distance / secs;
+	}
+
+protected:
+	static const char* positionStr[POSITION_COUNT];
+	long		startTime;
+	long		time;
+	idCameraPosition::positionType type;
+	idStr		name;
+	bool	editMode;
+	idList<idVelocity*> velocities;
+	float		baseVelocity;
+};
+
+class idFixedPosition : public idCameraPosition {
+public:
+
+	void init() {
+		pos.Zero();
+		type = idCameraPosition::FIXED;
+	}
+	
+	idFixedPosition() : idCameraPosition() {
+		init();
+	}
+	
+	idFixedPosition(idVec3_t p) : idCameraPosition() {
+		init();
+		pos = p;
+	}
+
+	virtual void addPoint(const idVec3_t &v) {
+		pos = v;
+	}
+	
+	virtual void addPoint(const float x, const float y, const float z) {
+		pos.set(x, y, z);
+	}
+
+
+	~idFixedPosition() {
+	}
+
+	virtual const idVec3_t *getPosition(long t) { 
+		return &pos;
+	}
+
+	void parse(const char *(*text));
+	void write(fileHandle_t file, const char *name);
+
+	virtual int numPoints() {
+		return 1;
+	}
+
+	virtual idVec3_t *getPoint(int index) {
+		if (index != 0) {
+			assert(true);
+		};
+		return &pos;
+	}
+
+	virtual void draw(bool editMode) {
+		glLabeledPoint(blue, pos, (editMode) ? 5 : 3, "Fixed point");
+	}
+
+protected:
+	idVec3_t pos;
+};
+
+class idInterpolatedPosition : public idCameraPosition {
+public:
+
+	void init() {
+		type = idCameraPosition::INTERPOLATED;
+		first = true;
+		startPos.Zero();
+		endPos.Zero();
+	}
+	
+	idInterpolatedPosition() : idCameraPosition() {
+		init();
+	}
+	
+	idInterpolatedPosition(idVec3_t start, idVec3_t end, long time) : idCameraPosition(time) {
+		init();
+		startPos = start;
+		endPos = end;
+	}
+
+	~idInterpolatedPosition() {
+	}
+
+	virtual const idVec3_t *getPosition(long t);
+
+	void parse(const char *(*text));
+	void write(fileHandle_t file, const char *name);
+
+	virtual int numPoints() {
+		return 2;
+	}
+
+	virtual idVec3_t *getPoint(int index) {
+		assert(index >= 0 && index < 2);
+		if (index == 0) {
+			return &startPos;
+		}
+		return &endPos;
+	}
+
+	virtual void addPoint(const float x, const float y, const float z) {
+		if (first) {
+			startPos.set(x, y, z);
+			first = false;
+		} else {
+			endPos.set(x, y, z);
+			first = true;
+		}
+	}
+
+	virtual void addPoint(const idVec3_t &v) {
+		if (first) {
+			startPos = v;
+			first = false;
+		} else {
+			endPos = v;
+			first = true;
+		}
+	}
+
+	virtual void draw(bool editMode) {
+		glLabeledPoint(blue, startPos, (editMode) ? 5 : 3, "Start interpolated");
+		glLabeledPoint(blue, endPos, (editMode) ? 5 : 3, "End interpolated");
+		qglBegin(GL_LINES);
+		qglVertex3fv(startPos);
+		qglVertex3fv(endPos);
+		qglEnd();
+	}
+
+	virtual void start(long t) {
+		idCameraPosition::start(t);
+		lastTime = startTime;
+		distSoFar = 0.0;
+		idVec3_t temp = startPos;
+		temp -= endPos;
+		calcVelocity(temp.Length());
+	}
+
+protected:
+	bool first;
+	idVec3_t startPos;
+	idVec3_t endPos;
+	long lastTime;
+	float distSoFar;
+};
+
+class idSplinePosition : public idCameraPosition {
+public:
+
+	void init() {
+		type = idCameraPosition::SPLINE;
+	}
+	
+	idSplinePosition() : idCameraPosition() {
+		init();
+	}
+	
+	idSplinePosition(long time) : idCameraPosition(time) {
+		init();
+	}
+
+	~idSplinePosition() {
+	}
+
+	virtual void start(long t) {
+		idCameraPosition::start(t);
+		target.initPosition(t, time);
+		calcVelocity(target.totalDistance());
+	}
+
+	virtual const idVec3_t *getPosition(long t) { 
+		return target.getPosition(t);
+	}
+
+	//virtual const idVec3_t *getPosition(long t) const { 
+
+	void addControlPoint(idVec3_t &v) {
+		target.addPoint(v);
+	}
+
+	void parse(const char *(*text));
+	void write(fileHandle_t file, const char *name);
+
+	virtual int numPoints() {
+		return target.numPoints();
+	}
+
+	virtual idVec3_t *getPoint(int index) {
+		return target.getPoint(index);
+	}
+
+	virtual void addPoint(const idVec3_t &v) {
+		target.addPoint(v);
+	}
+
+	virtual void addPoint(const float x, const float y, const float z) {
+		target.addPoint(x, y, z);
+	}
+
+	virtual void draw(bool editMode) {
+		target.draw(editMode);
+	}
+
+	virtual void updateSelection(const idVec3_t &move) {
+		idCameraPosition::updateSelection(move);
+		target.buildSpline();
+	}
+
+protected:
+	idSplineList target;
+};
+
+class idCameraFOV {
+public:
+	
+	idCameraFOV() {
+		time = 0;
+		fov = 90;
+	}
+
+	idCameraFOV(int v) {
+		time = 0;
+		fov = v;
+	}
+
+	idCameraFOV(int s, int e, long t) {
+		startFOV = s;
+		endFOV = e;
+		time = t;
+	}
+
+
+	~idCameraFOV(){}
+
+	void setFOV(float f) {
+		fov = f;
+	}
+
+	float getFOV(long t) {
+		if (time) {
+			assert(startTime);
+			float percent = t / startTime;
+			float temp = startFOV - endFOV;
+			temp *= percent;
+			fov = startFOV + temp;
+		}
+		return fov;
+	}
+
+	void start(long t) {
+		startTime = t;
+	}
+
+	void parse(const char *(*text));
+	void write(fileHandle_t file, const char *name);
+
+protected:
+	float fov;
+	float startFOV;
+	float endFOV;
+	int startTime;
+	int time;
+};
+
+
+
+
+class idCameraEvent {
+public:
+	enum eventType {
+		EVENT_NA = 0x00,
+		EVENT_WAIT,
+		EVENT_TARGETWAIT,
+		EVENT_SPEED,
+		EVENT_TARGET,
+		EVENT_SNAPTARGET,
+		EVENT_FOV,
+		EVENT_SCRIPT,
+		EVENT_TRIGGER,
+		EVENT_STOP,
+		EVENT_COUNT
+	};
+
+	static const char* eventStr[EVENT_COUNT];
+
+	idCameraEvent() {
+		paramStr = "";
+		type = EVENT_NA;
+		time = 0;
+	}
+
+	idCameraEvent(eventType t, const char *param, long n) {
+		type = t;
+		paramStr = param;
+		time = n;
+	}
+
+	~idCameraEvent() {};
+
+	eventType getType() {
+		return type;
+	}
+
+	const char *typeStr() {
+		return eventStr[static_cast<int>(type)];
+	}
+
+	const char *getParam() {
+		return paramStr.c_str();
+	}
+
+	long getTime() {
+		return time;
+	}
+
+	void setTime(long n) {
+		time = n;
+	}
+
+	void parse(const char *(*text));
+	void write(fileHandle_t file, const char *name);
+
+	void setTriggered(bool b) {
+		triggered = b;
+	}
+
+	bool getTriggered() {
+		return triggered;
+	}
+
+protected:
+	eventType type;
+	idStr paramStr;
+	long time;
+	bool triggered;
+
+};
+
+class idCameraDef {
+public:
+
+	void clear() {
+		currentCameraPosition = 0;
+		cameraRunning = false;
+		lastDirection.Zero();
+		baseTime = 30;
+		activeTarget = 0;
+		name = "camera01";
+		fov.setFOV(90);
+		int i;
+		for (i = 0; i < targetPositions.Num(); i++) {
+			delete targetPositions[i];
+		}
+		for (i = 0; i < events.Num(); i++) {
+			delete events[i];
+		}
+		delete cameraPosition;
+		cameraPosition = NULL;
+		events.Clear();
+		targetPositions.Clear();
+	}
+
+	idCameraPosition *startNewCamera(idCameraPosition::positionType type) {
+		clear();
+		if (type == idCameraPosition::SPLINE) {
+			cameraPosition = new idSplinePosition();
+		} else if (type == idCameraPosition::INTERPOLATED) {
+			cameraPosition = new idInterpolatedPosition();
+		} else {
+			cameraPosition = new idFixedPosition();
+		}
+		return cameraPosition;
+	}
+
+	idCameraDef() {
+		clear();
+	}
+
+	~idCameraDef() {
+		clear();
+	}
+
+	void addEvent(idCameraEvent::eventType t, const char *param, long time);
+
+	void addEvent(idCameraEvent *event);
+
+	static int sortEvents(const void *p1, const void *p2);
+
+	int numEvents() {
+		return events.Num();
+	}
+
+	idCameraEvent *getEvent(int index) {
+		assert(index >= 0 && index < events.Num());
+		return events[index];
+	}
+
+	void parse(const char *(*text));
+	qboolean load(const char *filename);
+	void save(const char *filename);
+
+	void buildCamera();
+
+	//idSplineList *getcameraPosition() {
+	//	return &cameraPosition;
+	//}
+
+	static idCameraPosition *newFromType(idCameraPosition::positionType t) {
+		switch (t) {
+			case idCameraPosition::FIXED : return new idFixedPosition();
+			case idCameraPosition::INTERPOLATED : return new idInterpolatedPosition();
+    case idCameraPosition::SPLINE : return new idSplinePosition();
+    default:
+        break;
+		};
+		return NULL;
+	}
+
+	void addTarget(const char *name, idCameraPosition::positionType type);
+
+	idCameraPosition *getActiveTarget() {
+		if (targetPositions.Num() == 0) {
+			addTarget(NULL, idCameraPosition::FIXED);
+		}
+		return targetPositions[activeTarget];
+	}
+
+	idCameraPosition *getActiveTarget(int index) {
+		if (targetPositions.Num() == 0) {
+			addTarget(NULL, idCameraPosition::FIXED);
+			return targetPositions[0];
+		}
+		return targetPositions[index];
+	}
+
+	int numTargets() {
+		return targetPositions.Num();
+	}
+
+
+	void setActiveTargetByName(const char *name) {
+		for (int i = 0; i < targetPositions.Num(); i++) {
+			if (Q_stricmp(name, targetPositions[i]->getName()) == 0) {
+				setActiveTarget(i);
+				return;
+			}
+		}
+	}
+
+	void setActiveTarget(int index) {
+		assert(index >= 0 && index < targetPositions.Num());
+		activeTarget = index;
+	}
+
+	void setRunning(bool b) {
+		cameraRunning = b;
+	}
+
+	void setBaseTime(float f) {
+		baseTime = f;
+	}
+
+	float getBaseTime() {
+		return baseTime;
+	}
+
+	float getTotalTime() {
+		return totalTime;
+	}
+	
+	void startCamera(long t);
+	void stopCamera() {
+		cameraRunning = true;
+	}
+	void getActiveSegmentInfo(int segment, idVec3_t &origin, idVec3_t &direction, float *fv);
+
+	bool getCameraInfo(long time, idVec3_t &origin, idVec3_t &direction, float *fv);
+	bool getCameraInfo(long time, float *origin, float *direction, float *fv) {
+		idVec3_t org, dir;
+		org[0] = origin[0];
+		org[1] = origin[1];
+		org[2] = origin[2];
+		dir[0] = direction[0];
+		dir[1] = direction[1];
+		dir[2] = direction[2];
+		bool b = getCameraInfo(time, org, dir, fv);
+		origin[0] = org[0];
+		origin[1] = org[1];
+		origin[2] = org[2];
+		direction[0] = dir[0];
+		direction[1] = dir[1];
+		direction[2] = dir[2];
+		return b;
+	}
+
+	void draw(bool editMode) {
+                // gcc doesn't allow casting away from bools
+                // why?  I've no idea...
+		if (cameraPosition) {
+			cameraPosition->draw((bool)((editMode || cameraRunning) && cameraEdit));
+			int count = targetPositions.Num();
+			for (int i = 0; i < count; i++) {
+				targetPositions[i]->draw((bool)((editMode || cameraRunning) && i == activeTarget && !cameraEdit));
+			}
+		}
+	}
+
+/*
+	int numSegments() {
+		if (cameraEdit) {
+			return cameraPosition.numSegments();
+		}
+		return getTargetSpline()->numSegments();
+	}
+
+	int getActiveSegment() {
+		if (cameraEdit) {
+			return cameraPosition.getActiveSegment();
+		}
+		return getTargetSpline()->getActiveSegment();
+	}
+
+	void setActiveSegment(int i) {
+		if (cameraEdit) {
+			cameraPosition.setActiveSegment(i);
+		} else {
+			getTargetSpline()->setActiveSegment(i);
+		}
+	}
+*/
+	int numPoints() {
+		if (cameraEdit) {
+			return cameraPosition->numPoints();
+		}
+		return getActiveTarget()->numPoints();
+	}
+
+	const idVec3_t *getPoint(int index) {
+		if (cameraEdit) {
+			return cameraPosition->getPoint(index);
+		}
+		return getActiveTarget()->getPoint(index);
+	}
+
+	void stopEdit() {
+		editMode = false;
+		if (cameraEdit) {
+			cameraPosition->stopEdit();
+		} else {
+			getActiveTarget()->stopEdit();
+		}
+	}
+
+	void startEdit(bool camera) {
+		cameraEdit = camera;
+		if (camera) {
+			cameraPosition->startEdit();
+			for (int i = 0; i < targetPositions.Num(); i++) {
+				targetPositions[i]->stopEdit();
+			}
+		} else {
+			getActiveTarget()->startEdit();
+			cameraPosition->stopEdit();
+		}
+		editMode = true;
+	}
+
+	bool waitEvent(int index);
+
+	const char *getName() {
+		return name.c_str();
+	}
+
+	void setName(const char *p) {
+		name = p;
+	}
+
+	idCameraPosition *getPositionObj() {
+		if (cameraPosition == NULL) {
+			cameraPosition = new idFixedPosition();
+		}
+		return cameraPosition;
+	}
+
+protected:
+	idStr name;
+	int currentCameraPosition;
+	idVec3_t lastDirection;
+	bool cameraRunning;
+	idCameraPosition *cameraPosition;
+	idList<idCameraPosition*> targetPositions;
+	idList<idCameraEvent*> events;
+	idCameraFOV fov;
+	int activeTarget;
+	float totalTime;
+	float baseTime;
+	long startTime;
+
+	bool cameraEdit;
+	bool editMode;
+};
+
+extern bool g_splineMode;
+
+extern idCameraDef *g_splineList;
+
+
+#endif
diff --git a/codemp/Splines/util_list.h b/codemp/Splines/util_list.h
new file mode 100644
index 0000000..90d162b
--- /dev/null
+++ b/codemp/Splines/util_list.h
@@ -0,0 +1,325 @@
+#ifndef __UTIL_LIST_H__
+#define __UTIL_LIST_H__
+
+#include <stdlib.h>
+#include <assert.h>
+
+template< class type >
+class idList {
+private:
+	int			m_num;
+	int			m_size;
+	int			m_granularity;
+	type		*m_list;
+
+public:
+				idList( int granularity = 16 );
+				~idList<type>();
+	void		Clear( void );
+	int			Num( void );
+	void		SetNum( int num );
+	void		SetGranularity( int granularity );
+	void		Condense( void );
+	int			Size( void );
+	void		Resize( int size );
+	type		operator[]( int index ) const;
+	type		&operator[]( int index );
+	int			Append( type const & obj );
+	int			AddUnique( type const & obj );
+	type		*Find( type const & obj, int *index = NULL );
+	bool		RemoveIndex( int index );
+	bool		Remove( type const & obj );
+	typedef int cmp_t(const void *, const void *);
+	void		Sort( cmp_t *compare );
+};
+
+/*
+================
+idList<type>::idList( int )
+================
+*/
+template< class type >
+inline idList<type>::idList( int granularity ) {
+	assert( granularity > 0 );
+
+	m_list			= NULL;
+	m_granularity	= granularity;
+	Clear();
+}
+
+/*
+================
+idList<type>::~idList<type>
+================
+*/
+template< class type >
+inline idList<type>::~idList() {
+	Clear();
+}
+
+/*
+================
+idList<type>::Clear
+================
+*/
+template< class type >
+inline void idList<type>::Clear( void ) {
+	if ( m_list ) {
+		delete[] m_list;
+	}
+
+	m_list	= NULL;
+	m_num	= 0;
+	m_size	= 0;
+}
+
+/*
+================
+idList<type>::Num
+================
+*/
+template< class type >
+inline int idList<type>::Num( void ) {
+	return m_num;
+}
+
+/*
+================
+idList<type>::SetNum
+================
+*/
+template< class type >
+inline void idList<type>::SetNum( int num ) {
+	assert( num >= 0 );
+	if ( num > m_size ) {
+		// resize it up to the closest level of granularity
+		Resize( ( ( num + m_granularity - 1 ) / m_granularity ) * m_granularity );
+	}
+	m_num = num;
+}
+
+/*
+================
+idList<type>::SetGranularity
+================
+*/
+template< class type >
+inline void idList<type>::SetGranularity( int granularity ) {
+	int newsize;
+
+	assert( granularity > 0 );
+	m_granularity = granularity;
+
+	if ( m_list ) {
+		// resize it to the closest level of granularity
+		newsize = ( ( m_num + m_granularity - 1 ) / m_granularity ) * m_granularity;
+		if ( newsize != m_size ) {
+			Resize( newsize );
+		}
+	}
+}
+
+/*
+================
+idList<type>::Condense
+
+Resizes the array to exactly the number of elements it contains
+================
+*/
+template< class type >
+inline void idList<type>::Condense( void ) {
+	if ( m_list ) {
+		if ( m_num ) {
+			Resize( m_num );
+		} else {
+			Clear();
+		}
+	}
+}
+
+/*
+================
+idList<type>::Size
+================
+*/
+template< class type >
+inline int idList<type>::Size( void ) {
+	return m_size;
+}
+
+/*
+================
+idList<type>::Resize
+================
+*/
+template< class type >
+inline void idList<type>::Resize( int size ) {
+	type	*temp;
+	int		i;
+
+	assert( size > 0 );
+
+	if ( size <= 0 ) {
+		Clear();
+		return;
+	}
+
+	temp	= m_list;
+	m_size	= size;
+	if ( m_size < m_num ) {
+		m_num = m_size;
+	}
+
+	m_list = new type[ m_size ];
+	for( i = 0; i < m_num; i++ ) {
+		m_list[ i ] = temp[ i ];
+	}
+
+	if ( temp ) {
+		delete[] temp;
+	}
+}
+
+/*
+================
+idList<type>::operator[] const
+================
+*/
+template< class type >
+inline type idList<type>::operator[]( int index ) const {
+	assert( index >= 0 );
+	assert( index < m_num );
+
+	return m_list[ index ];
+}
+
+/*
+================
+idList<type>::operator[]
+================
+*/
+template< class type >
+inline type &idList<type>::operator[]( int index ) {
+	assert( index >= 0 );
+	assert( index < m_num );
+
+	return m_list[ index ];
+}
+
+/*
+================
+idList<type>::Append
+================
+*/
+template< class type >
+inline int idList<type>::Append( type const & obj ) {
+	if ( !m_list ) {
+		Resize( m_granularity );
+	}
+
+	if ( m_num == m_size ) {
+		Resize( m_size + m_granularity );
+	}
+
+	m_list[ m_num ] = obj;
+	m_num++;
+
+	return m_num - 1;
+}
+
+/*
+================
+idList<type>::AddUnique
+================
+*/
+template< class type >
+inline int idList<type>::AddUnique( type const & obj ) {
+	int index;
+
+	if ( !Find( obj, &index ) ) {
+		index = Append( obj );
+	}
+
+	return index;
+}
+
+/*
+================
+idList<type>::Find
+================
+*/
+template< class type >
+inline type *idList<type>::Find( type const & obj, int *index ) {
+	int i;
+
+	for( i = 0; i < m_num; i++ ) {
+		if ( m_list[ i ] == obj ) {
+			if ( index ) {
+				*index = i;
+			}
+			return &m_list[ i ];
+		}
+	}
+
+	return NULL;
+}
+
+/*
+================
+idList<type>::RemoveIndex
+================
+*/
+template< class type >
+inline bool idList<type>::RemoveIndex( int index ) {
+	int i;
+
+	if ( !m_list || !m_num ) {
+		return false;
+	}
+
+	assert( index >= 0 );
+	assert( index < m_num );
+
+	if ( ( index < 0 ) || ( index >= m_num ) ) {
+		return false;
+	}
+
+	m_num--;
+	for( i = index; i < m_num; i++ ) {
+		m_list[ i ] = m_list[ i + 1 ];
+	}
+
+	return true;
+}
+
+/*
+================
+idList<type>::Remove
+================
+*/
+template< class type >
+inline bool idList<type>::Remove( type const & obj ) {
+	int index;
+
+	if ( Find( obj, &index ) ) {
+		return RemoveIndex( index );
+	}
+	
+	return false;
+}
+
+/*
+================
+idList<type>::Sort
+================
+*/
+template< class type >
+inline void idList<type>::Sort( cmp_t *compare ) {
+	if ( !m_list ) {
+		return;
+	}
+
+	qsort( ( void * )m_list, ( size_t )m_num, sizeof( type ), compare );
+}
+
+#endif /* !__UTIL_LIST_H__ */
diff --git a/codemp/Splines/util_str.cpp b/codemp/Splines/util_str.cpp
new file mode 100644
index 0000000..f68ce6d
--- /dev/null
+++ b/codemp/Splines/util_str.cpp
@@ -0,0 +1,598 @@
+//need to rewrite this
+
+#include "util_str.h"
+#include <stdlib.h>
+#include <ctype.h>
+#include <stdio.h>
+#include <stdarg.h>
+
+#ifdef _WIN32
+#pragma warning(disable : 4244)     // 'conversion' conversion from 'type1' to 'type2', possible loss of data
+#pragma warning(disable : 4710)     // function 'blah' not inlined
+#endif
+
+static const int STR_ALLOC_GRAN = 20;
+
+char *idStr::tolower
+   (
+   char *s1
+   )
+   
+   {
+   char *s;
+
+   s = s1;
+	while( *s )
+      {
+      *s = ::tolower( *s );
+		s++;
+	   }
+   
+   return s1;
+   }
+
+char *idStr::toupper
+   (
+   char *s1
+   )
+   
+   {
+   char *s;
+
+   s = s1;
+	while( *s )
+      {
+      *s = ::toupper( *s );
+		s++;
+	   }
+   
+   return s1;
+   }
+
+int idStr::icmpn
+   (
+   const char *s1, 
+   const char *s2, 
+   int n
+   )
+   
+   {
+	int c1;
+   int c2;
+	
+	do 
+      {
+		c1 = *s1++;
+		c2 = *s2++;
+
+		if ( !n-- )
+         {
+         // idStrings are equal until end point
+			return 0;
+		   }
+		
+		if ( c1 != c2 )
+         {
+			if ( c1 >= 'a' && c1 <= 'z' )
+            {
+				c1 -= ( 'a' - 'A' );
+			   }
+
+			if ( c2 >= 'a' && c2 <= 'z' )
+            {
+				c2 -= ( 'a' - 'A' );
+			   }
+
+			if ( c1 < c2 )
+            {
+            // strings less than
+				return -1;
+			   }
+         else if ( c1 > c2 ) 
+            {
+            // strings greater than
+            return 1;
+            }
+		   }
+	   } 
+   while( c1 );
+	
+   // strings are equal
+	return 0;
+   }
+
+int idStr::icmp
+   (
+   const char *s1,
+   const char *s2
+   )
+   
+   {
+	int c1;
+   int c2;
+	
+	do 
+      {
+		c1 = *s1++;
+		c2 = *s2++;
+
+		if ( c1 != c2 )
+         {
+			if ( c1 >= 'a' && c1 <= 'z' )
+            {
+				c1 -= ( 'a' - 'A' );
+			   }
+
+			if ( c2 >= 'a' && c2 <= 'z' )
+            {
+				c2 -= ( 'a' - 'A' );
+			   }
+
+			if ( c1 < c2 )
+            {
+            // strings less than
+				return -1;
+			   }
+         else if ( c1 > c2 ) 
+            {
+            // strings greater than
+            return 1;
+            }
+		   }
+	   } 
+   while( c1 );
+	
+   // strings are equal
+	return 0;
+   }
+
+int idStr::cmpn
+   (
+   const char *s1, 
+   const char *s2, 
+   int n
+   )
+   
+   {
+	int c1;
+   int c2;
+	
+	do 
+      {
+		c1 = *s1++;
+		c2 = *s2++;
+
+		if ( !n-- )
+         {
+         // strings are equal until end point
+			return 0;
+		   }
+		
+		if ( c1 < c2 )
+         {
+         // strings less than
+			return -1;
+			}
+      else if ( c1 > c2 ) 
+         {
+         // strings greater than
+         return 1;
+         }
+	   } 
+   while( c1 );
+	
+   // strings are equal
+	return 0;
+   }
+
+int idStr::cmp
+   (
+   const char *s1, 
+   const char *s2
+   )
+   
+   {
+	int c1;
+   int c2;
+	
+	do 
+      {
+		c1 = *s1++;
+		c2 = *s2++;
+
+		if ( c1 < c2 )
+         {
+         // strings less than
+			return -1;
+			}
+      else if ( c1 > c2 ) 
+         {
+         // strings greater than
+         return 1;
+         }
+	   } 
+   while( c1 );
+	
+   // strings are equal
+	return 0;
+   }
+
+/*
+============
+IsNumeric
+
+Checks a string to see if it contains only numerical values.
+============
+*/
+bool idStr::isNumeric
+   (
+   const char *str
+   )
+
+   {
+	int len;
+	int i;
+	bool dot;
+
+	if ( *str == '-' )
+		{
+		str++;
+		}
+
+	dot = false;
+	len = strlen( str );
+	for( i = 0; i < len; i++ )
+		{
+		if ( !isdigit( str[ i ] ) )
+			{
+			if ( ( str[ i ] == '.' ) && !dot )
+				{
+				dot = true;
+				continue;
+				}
+			return false;
+			}
+		}
+
+	return true;
+   }
+
+idStr operator+
+   (
+   const idStr& a,
+   const float b
+   )
+
+   {
+   char text[ 20 ];
+
+	idStr result( a );
+
+   sprintf( text, "%f", b );
+	result.append( text );
+
+	return result;
+   }
+
+idStr operator+
+   (
+   const idStr& a,
+   const int b
+   )
+
+   {
+   char text[ 20 ];
+
+	idStr result( a );
+
+   sprintf( text, "%d", b );
+	result.append( text );
+
+	return result;
+   }
+
+idStr operator+
+   (
+   const idStr& a,
+   const unsigned b
+   )
+
+   {
+   char text[ 20 ];
+
+	idStr result( a );
+
+   sprintf( text, "%u", b );
+	result.append( text );
+
+	return result;
+   }
+
+idStr& idStr::operator+=
+	(
+	const float a
+	)
+
+	{
+   char text[ 20 ];
+
+   sprintf( text, "%f", a );
+	append( text );
+
+   return *this;
+	}
+
+idStr& idStr::operator+=
+	(
+	const int a
+	)
+
+	{
+   char text[ 20 ];
+
+   sprintf( text, "%d", a );
+	append( text );
+
+   return *this;
+	}
+
+idStr& idStr::operator+=
+	(
+	const unsigned a
+	)
+
+	{
+   char text[ 20 ];
+
+   sprintf( text, "%u", a );
+	append( text );
+
+   return *this;
+	}
+
+void idStr::CapLength 
+   (
+   int newlen 
+   )
+
+   {
+   assert ( m_data );
+   
+   if ( length() <= newlen )
+      return;
+
+   EnsureDataWritable ();
+
+   m_data->data[newlen] = 0;
+   m_data->len = newlen;
+   }
+
+void idStr::EnsureDataWritable 
+   (
+   void
+   )
+
+   {
+   assert ( m_data );
+   strdata *olddata;
+   int len;
+
+   if ( !m_data->refcount )
+      return;
+
+   olddata = m_data;
+   len = length();
+
+   m_data = new strdata;
+
+   EnsureAlloced ( len + 1, false );
+   strncpy ( m_data->data, olddata->data, len+1 );
+   m_data->len = len;
+
+   olddata->DelRef ();
+   }
+
+void idStr::EnsureAlloced (int amount, bool keepold) {
+
+	if ( !m_data ) {
+      m_data = new strdata();
+	}
+   
+	// Now, let's make sure it's writable
+	EnsureDataWritable ();
+
+	char *newbuffer;
+	bool wasalloced = ( m_data->alloced != 0 );
+
+	if ( amount < m_data->alloced ) {
+		return;
+	}
+
+	assert ( amount );
+	if ( amount == 1 ) {
+		m_data->alloced = 1;
+	} else {
+		int newsize, mod;
+		mod = amount % STR_ALLOC_GRAN;
+		if ( !mod ) {
+			newsize = amount;
+		} else {
+         newsize = amount + STR_ALLOC_GRAN - mod;
+		}
+		m_data->alloced = newsize;
+	}
+
+	newbuffer = new char[m_data->alloced];
+	if ( wasalloced && keepold ) {
+		strcpy ( newbuffer, m_data->data );
+	}
+
+	if ( m_data->data ) {
+		delete [] m_data->data;
+    }
+	m_data->data = newbuffer;
+}
+
+void idStr::BackSlashesToSlashes
+   (
+   void
+   )
+
+   {
+   int i;
+
+   EnsureDataWritable ();
+
+   for ( i=0; i < m_data->len; i++ )
+      {
+      if ( m_data->data[i] == '\\' )
+         m_data->data[i] = '/';
+      }
+   }
+
+void idStr::snprintf 
+   (
+   char *dst,
+   int size,
+   const char *fmt, 
+   ...
+   )
+
+   {
+   char buffer[0x10000];
+	int		len;
+	va_list		argptr;
+
+	va_start (argptr,fmt);
+	len = vsprintf (buffer,fmt,argptr);
+	va_end (argptr);
+	
+   assert ( len < size );
+
+   strncpy (dst, buffer, size-1);
+   }
+
+#ifdef _WIN32
+#pragma warning(disable : 4189)		// local variable is initialized but not referenced
+#endif
+
+/*
+=================
+TestStringClass
+
+This is a fairly rigorous test of the idStr class's functionality.
+Because of the fairly global and subtle ramifications of a bug occuring
+in this class, it should be run after any changes to the class.
+Add more tests as functionality is changed.  Tests should include
+any possible bounds violation and NULL data tests.
+=================
+*/
+void TestStringClass
+	(
+	void 
+	)
+
+	{
+	char	ch;							// ch == ?
+	idStr	*t;							// t == ?
+	idStr	a;								// a.len == 0, a.data == "\0"
+	idStr	b;								// b.len == 0, b.data == "\0"
+	idStr	c( "test" );				// c.len == 4, c.data == "test\0"
+	idStr	d( c );						// d.len == 4, d.data == "test\0"
+	idStr	e( reinterpret_cast<const char *>(NULL) );					
+                                 // e.len == 0, e.data == "\0"					ASSERT!
+	int	i;								// i == ?
+
+	i = a.length();					// i == 0
+	i = c.length();					// i == 4
+
+    // TTimo: not used
+//	const char *s1 = a.c_str();	// s1 == "\0"
+//	const char *s2 = c.c_str();	// s2 == "test\0"
+
+	t = new idStr();						// t->len == 0, t->data == "\0"
+	delete t;							// t == ?
+
+	b = "test";							// b.len == 4, b.data == "test\0"
+	t = new idStr( "test" );			// t->len == 4, t->data == "test\0"
+	delete t;							// t == ?
+
+	a = c;								// a.len == 4, a.data == "test\0"
+//   a = "";
+   a = NULL;							// a.len == 0, a.data == "\0"					ASSERT!
+	a = c + d;							// a.len == 8, a.data == "testtest\0"
+	a = c + "wow";						// a.len == 7, a.data == "testwow\0"
+	a = c + reinterpret_cast<const char *>(NULL);
+                                 // a.len == 4, a.data == "test\0"			ASSERT!
+	a = "this" + d;					// a.len == 8, a.data == "thistest\0"
+	a = reinterpret_cast<const char *>(NULL) + d;
+                                 // a.len == 4, a.data == "test\0"			ASSERT!
+	a += c;								// a.len == 8, a.data == "testtest\0"
+	a += "wow";							// a.len == 11, a.data == "testtestwow\0"
+	a += reinterpret_cast<const char *>(NULL);
+                                 // a.len == 11, a.data == "testtestwow\0"	ASSERT!
+
+	a = "test";							// a.len == 4, a.data == "test\0"
+	ch = a[ 0 ];						// ch == 't'
+	ch = a[ -1 ];						// ch == 0											ASSERT!
+	ch = a[ 1000 ];					// ch == 0											ASSERT!
+	ch = a[ 0 ];						// ch == 't'
+	ch = a[ 1 ];						// ch == 'e'
+	ch = a[ 2 ];						// ch == 's'
+	ch = a[ 3 ];						// ch == 't'
+	ch = a[ 4 ];						// ch == '\0'										ASSERT!
+	ch = a[ 5 ];						// ch == '\0'										ASSERT!
+
+	a[ 1 ] = 'b';						// a.len == 4, a.data == "tbst\0"
+	a[ -1 ] = 'b';						// a.len == 4, a.data == "tbst\0"			ASSERT!
+	a[ 0 ] = '0';						// a.len == 4, a.data == "0bst\0"
+	a[ 1 ] = '1';						// a.len == 4, a.data == "01st\0"
+	a[ 2 ] = '2';						// a.len == 4, a.data == "012t\0"
+	a[ 3 ] = '3';						// a.len == 4, a.data == "0123\0"
+	a[ 4 ] = '4';						// a.len == 4, a.data == "0123\0"			ASSERT!
+	a[ 5 ] = '5';						// a.len == 4, a.data == "0123\0"			ASSERT!
+	a[ 7 ] = '7';						// a.len == 4, a.data == "0123\0"			ASSERT!
+
+	a = "test";							// a.len == 4, a.data == "test\0"
+	b = "no";							// b.len == 2, b.data == "no\0"
+
+	i = ( a == b );					// i == 0
+	i = ( a == c );					// i == 1
+
+	i = ( a == "blow" );				// i == 0
+	i = ( a == "test" );				// i == 1
+	i = ( a == NULL );				// i == 0											ASSERT!
+
+	i = ( "test" == b );				// i == 0
+	i = ( "test" == a );				// i == 1
+	i = ( NULL == a );				// i == 0											ASSERT!
+
+	i = ( a != b );					// i == 1
+	i = ( a != c );					// i == 0
+
+	i = ( a != "blow" );				// i == 1
+	i = ( a != "test" );				// i == 0
+	i = ( a != NULL );				// i == 1											ASSERT!
+
+	i = ( "test" != b );				// i == 1
+	i = ( "test" != a );				// i == 0
+	i = ( NULL != a );				// i == 1											ASSERT!
+
+   a = "test";                   // a.data == "test"
+   b = a;                        // b.data == "test"
+
+   a = "not";                   // a.data == "not", b.data == "test"
+
+   a = b;                        // a.data == b.data == "test"
+
+   a += b;                       // a.data == "testtest", b.data = "test"
+
+   a = b;
+
+   a[1] = '1';                   // a.data = "t1st", b.data = "test"
+	}
+
+#ifdef _WIN32
+#pragma warning(default : 4189)		// local variable is initialized but not referenced
+#pragma warning(disable : 4514)     // unreferenced inline function has been removed
+#endif
diff --git a/codemp/Splines/util_str.h b/codemp/Splines/util_str.h
new file mode 100644
index 0000000..0a6c00f
--- /dev/null
+++ b/codemp/Splines/util_str.h
@@ -0,0 +1,796 @@
+//need to rewrite this
+
+#ifndef __UTIL_STR_H__
+#define __UTIL_STR_H__
+
+#include <assert.h>
+#include <string.h>
+#include <stdio.h>
+
+#ifdef _WIN32
+#pragma warning(disable : 4710)     // function 'blah' not inlined
+#endif
+
+void TestStringClass ();
+
+class strdata
+   {
+   public:
+      strdata () : len( 0 ), refcount ( 0 ), data ( NULL ), alloced ( 0 ) {}
+      ~strdata () 
+         {
+         if ( data )
+            delete [] data;
+         }
+
+      void AddRef () { refcount++; }
+      bool DelRef () // True if killed
+         {
+         refcount--;
+         if ( refcount < 0 )
+            {
+            delete this;
+            return true;
+            }
+         
+         return false;
+         }
+
+      int len;
+      int refcount;
+      char *data;
+      int alloced;
+   };
+
+class idStr {
+protected:
+	strdata	*m_data;
+	void EnsureAlloced ( int, bool keepold = true );
+	void EnsureDataWritable ();
+
+public:
+	~idStr();
+	idStr();
+	idStr( const char *text );
+	idStr( const idStr& string );
+	idStr( const idStr string, int start, int end );
+	idStr( const char ch );
+	idStr( const int num );
+	idStr( const float num );
+	idStr( const unsigned num );
+	int	length( void ) const;
+	int	allocated( void ) const;
+	const char * c_str( void ) const;
+
+	void		append( const char *text );
+	void		append( const idStr& text );
+	char		operator[]( int index ) const;
+	char&		operator[]( int index );
+
+	void		operator=( const idStr& text );
+	void		operator=( const char *text );
+
+	friend	idStr		operator+( const idStr& a, const idStr& b );
+	friend	idStr		operator+( const idStr& a, const char *b );
+	friend	idStr		operator+( const char *a, const idStr& b );
+
+    friend	idStr		operator+( const idStr& a, const float b );
+    friend	idStr		operator+( const idStr& a, const int b );
+    friend	idStr		operator+( const idStr& a, const unsigned b );
+    friend	idStr		operator+( const idStr& a, const bool b );
+    friend	idStr		operator+( const idStr& a, const char b );
+
+	idStr&		operator+=( const idStr& a );
+	idStr&		operator+=( const char *a );
+	idStr&		operator+=( const float a );
+	idStr&		operator+=( const char a );
+	idStr&		operator+=( const int a );
+	idStr&		operator+=( const unsigned a );
+	idStr&		operator+=( const bool a );
+
+	friend	bool		operator==(	const idStr& a, const idStr& b );
+	friend	bool		operator==(	const idStr& a, const char *b );
+	friend	bool		operator==(	const char *a, const idStr& b );
+
+	friend	bool		operator!=(	const idStr& a, const idStr& b );
+	friend	bool		operator!=(	const idStr& a, const char *b );
+	friend	bool		operator!=(	const char *a, const idStr& b );
+
+	operator const char * () const;
+	operator const char * ();
+
+    int      icmpn( const char *text, int n ) const;
+	int      icmpn( const idStr& text, int n ) const;
+	int      icmp( const char *text ) const;
+	int      icmp( const idStr& text ) const;
+	int      cmpn( const char *text, int n ) const;
+	int      cmpn( const idStr& text, int n ) const;
+	int      cmp( const char *text ) const;
+	int      cmp( const idStr& text ) const;
+
+	void     tolower( void );
+	void     toupper( void );
+
+	static   char     *tolower( char *s1 );
+	static   char     *toupper( char *s1 );
+
+	static   int      icmpn( const char *s1, const char *s2, int n );
+	static   int      icmp( const char *s1, const char *s2 );
+	static   int      cmpn( const char *s1, const char *s2, int n );
+	static   int      cmp( const char *s1, const char *s2 );
+
+	static   void     snprintf ( char *dst, int size, const char *fmt, ... );
+
+	static   bool	   isNumeric( const char *str );
+    bool    isNumeric( void ) const;
+
+	void     CapLength ( int );
+
+	void     BackSlashesToSlashes ();
+
+};
+
+inline idStr::~idStr()
+	{
+   if ( m_data )
+      {
+      m_data->DelRef ();
+      m_data = NULL;
+      }
+	}
+
+inline idStr::idStr() : m_data ( NULL )
+	{
+   EnsureAlloced ( 1 );
+	m_data->data[ 0 ] = 0;
+	}
+
+inline idStr::idStr
+	(
+	const char *text
+   ) : m_data ( NULL )
+
+	{
+   int len;
+
+	assert( text );
+
+	if ( text )
+		{
+      len = strlen( text );
+		EnsureAlloced ( len + 1 );
+		strcpy( m_data->data, text );
+      m_data->len = len;
+		}
+	else
+		{
+      EnsureAlloced ( 1 );
+		m_data->data[ 0 ] = 0;
+		m_data->len = 0;
+		}
+	}
+
+inline idStr::idStr
+	(
+	const idStr& text
+   ) : m_data ( NULL )
+
+	{
+   m_data = text.m_data;
+   m_data->AddRef ();
+   }
+
+inline idStr::idStr
+	(
+	const idStr text, 
+	int start,
+	int end
+   ) : m_data ( NULL )
+
+	{
+	int i;
+   int len;
+
+	if ( end > text.length() )
+		{
+		end = text.length();
+		}
+
+	if ( start > text.length() )
+		{
+		start = text.length();
+		}
+
+	len = end - start;
+	if ( len < 0 )
+		{
+		len = 0;
+		}
+
+   EnsureAlloced ( len + 1 );
+
+	for( i = 0; i < len; i++ )
+		{
+		m_data->data[ i ] = text[ start + i ];
+		}
+
+	m_data->data[ len ] = 0;
+   m_data->len = len;
+	}
+
+inline idStr::idStr
+   (
+   const char ch
+   ) : m_data ( NULL )
+
+   {
+   EnsureAlloced ( 2 );
+
+   m_data->data[ 0 ] = ch;
+   m_data->data[ 1 ] = 0;
+   m_data->len = 1;
+   }
+
+inline idStr::idStr
+   (
+   const float num
+   ) : m_data ( NULL )
+
+   {
+   char text[ 32 ];
+   int len;
+
+   sprintf( text, "%.3f", num );
+   len = strlen( text );
+   EnsureAlloced( len + 1 );
+   strcpy( m_data->data, text );
+   m_data->len = len;
+   }
+
+inline idStr::idStr
+   (
+   const int num
+   ) : m_data ( NULL )
+
+   {
+   char text[ 32 ];
+   int len;
+
+   sprintf( text, "%d", num );
+   len = strlen( text );
+   EnsureAlloced( len + 1 );
+   strcpy( m_data->data, text );
+   m_data->len = len;
+   }
+
+inline idStr::idStr
+   (
+   const unsigned num
+   ) : m_data ( NULL )
+
+   {
+   char text[ 32 ];
+   int len;
+
+   sprintf( text, "%u", num );
+   len = strlen( text );
+   EnsureAlloced( len + 1 );
+   strcpy( m_data->data, text );
+   m_data->len = len;
+   }
+
+inline int idStr::length( void ) const
+	{
+   return ( m_data != NULL ) ? m_data->len : 0;
+	}
+
+inline int idStr::allocated( void ) const
+	{
+   return ( m_data != NULL ) ? m_data->alloced + sizeof( *m_data ) : 0;
+	}
+
+inline const char *idStr::c_str( void ) const
+	{
+	assert( m_data );
+
+	return m_data->data;
+	}
+
+inline void idStr::append
+	(
+	const char *text
+	)
+
+	{
+   int len;
+
+	assert( text );
+
+	if ( text )
+		{
+		len = length() + strlen( text );
+		EnsureAlloced( len + 1 );
+
+      strcat( m_data->data, text );
+      m_data->len = len;
+		}
+	}
+
+inline void idStr::append
+	(
+	const idStr& text
+	)
+
+	{
+   int len;
+
+   len = length() + text.length();
+   EnsureAlloced ( len + 1 );
+
+   strcat ( m_data->data, text.c_str () );
+   m_data->len = len;
+	}
+
+inline char idStr::operator[]( int index ) const
+	{
+   assert ( m_data );
+   
+   if ( !m_data )
+      return 0;
+
+	// don't include the '/0' in the test, because technically, it's out of bounds
+	assert( ( index >= 0 ) && ( index < m_data->len ) );
+
+	// In release mode, give them a null character
+	// don't include the '/0' in the test, because technically, it's out of bounds
+	if ( ( index < 0 ) || ( index >= m_data->len ) )
+		{
+		return 0;
+		}
+
+	return m_data->data[ index ];
+	}
+
+inline char& idStr::operator[]
+	(
+	int index
+	)
+
+	{
+	// Used for result for invalid indices
+	static char dummy = 0;
+   assert ( m_data );
+
+   // We don't know if they'll write to it or not
+   // if it's not a const object
+   EnsureDataWritable ();
+
+   if ( !m_data )
+      return dummy;
+
+	// don't include the '/0' in the test, because technically, it's out of bounds
+	assert( ( index >= 0 ) && ( index < m_data->len ) );
+
+	// In release mode, let them change a safe variable
+	// don't include the '/0' in the test, because technically, it's out of bounds
+	if ( ( index < 0 ) || ( index >= m_data->len ) )
+		{
+		return dummy;
+		}
+
+	return m_data->data[ index ];
+	}
+
+inline void idStr::operator=
+	(
+	const idStr& text
+	)
+
+	{
+   // adding the reference before deleting our current reference prevents
+   // us from deleting our string if we are copying from ourself
+   text.m_data->AddRef();
+   m_data->DelRef();
+   m_data = text.m_data;
+   }
+
+inline void idStr::operator=
+	(
+	const char *text
+	)
+
+	{
+   int len;
+
+	assert( text );
+
+	if ( !text )
+		{
+		// safe behaviour if NULL
+		EnsureAlloced ( 1, false );
+      m_data->data[0] = 0;
+      m_data->len = 0;
+      return;
+		}
+
+   if ( !m_data )
+      {
+      len = strlen ( text );
+      EnsureAlloced( len + 1, false );
+      strcpy ( m_data->data, text );
+      m_data->len = len;
+      return;
+      }
+
+   if ( text == m_data->data )
+      return; // Copying same thing.  Punt.
+
+   // If we alias and I don't do this, I could corrupt other strings...  This 
+   // will get called with EnsureAlloced anyway
+   EnsureDataWritable ();
+
+   // Now we need to check if we're aliasing..
+   if ( text >= m_data->data && text <= m_data->data + m_data->len )
+      {
+      // Great, we're aliasing.  We're copying from inside ourselves.
+      // This means that I don't have to ensure that anything is alloced,
+      // though I'll assert just in case.
+      int diff = text - m_data->data;
+      int i;
+
+      assert ( strlen ( text ) < (unsigned) m_data->len );
+      
+      for ( i = 0; text[i]; i++ )
+         {
+         m_data->data[i] = text[i];
+         }
+
+      m_data->data[i] = 0;
+
+      m_data->len -= diff;
+
+      return;
+      }
+
+	len = strlen( text );
+   EnsureAlloced ( len + 1, false );
+	strcpy( m_data->data, text );
+   m_data->len = len;
+	}
+
+inline idStr operator+
+	(
+	const idStr& a,
+	const idStr& b
+	)
+
+	{
+	idStr result( a );
+
+	result.append( b );
+
+	return result;
+	}
+
+inline idStr operator+
+	(
+	const idStr& a,
+	const char *b
+	)
+
+	{
+	idStr result( a );
+
+	result.append( b );
+
+	return result;
+	}
+
+inline idStr operator+
+	(
+	const char *a,
+	const idStr& b
+	)
+
+	{
+	idStr result( a );
+
+	result.append( b );
+
+	return result;
+	}
+
+inline idStr operator+
+   (
+   const idStr& a,
+   const bool b
+   )
+
+   {
+	idStr result( a );
+
+   result.append( b ? "true" : "false" );
+
+	return result;
+   }
+
+inline idStr operator+
+	(
+   const idStr& a,
+	const char b
+	)
+
+	{
+   char text[ 2 ];
+
+   text[ 0 ] = b;
+   text[ 1 ] = 0;
+
+	return a + text;
+	}
+
+inline idStr& idStr::operator+=
+	(
+	const idStr& a
+	)
+
+	{
+	append( a );
+	return *this;
+	}
+
+inline idStr& idStr::operator+=
+	(
+	const char *a
+	)
+
+	{
+	append( a );
+	return *this;
+	}
+
+inline idStr& idStr::operator+=
+	(
+	const char a
+	)
+
+	{
+   char text[ 2 ];
+
+   text[ 0 ] = a;
+   text[ 1 ] = 0;
+	append( text );
+
+   return *this;
+	}
+
+inline idStr& idStr::operator+=
+	(
+	const bool a
+	)
+
+	{
+   append( a ? "true" : "false" );
+	return *this;
+	}
+
+inline bool operator==
+	(
+	const idStr& a,
+	const idStr& b
+	)
+
+	{
+	return ( !strcmp( a.c_str(), b.c_str() ) );
+	}
+
+inline bool operator==
+	(
+	const idStr& a,
+	const char *b
+	)
+
+	{
+	assert( b );
+	if ( !b )
+		{
+		return false;
+		}
+	return ( !strcmp( a.c_str(), b ) );
+	}
+
+inline bool operator==
+	(
+	const char *a,
+	const idStr& b
+	)
+
+	{
+	assert( a );
+	if ( !a )
+		{
+		return false;
+		}
+	return ( !strcmp( a, b.c_str() ) );
+	}
+
+inline bool operator!=
+	(
+	const idStr& a,
+	const idStr& b
+	)
+
+	{
+	return !( a == b );
+	}
+
+inline bool operator!=
+	(
+	const idStr& a,
+	const char *b
+	)
+
+	{
+	return !( a == b );
+	}
+
+inline bool operator!=
+	(
+	const char *a,
+	const idStr& b
+	)
+
+	{
+	return !( a == b );
+	}
+
+inline int idStr::icmpn
+   (
+   const char *text, 
+   int n
+   ) const
+
+   {
+	assert( m_data );
+	assert( text );
+
+   return idStr::icmpn( m_data->data, text, n );
+   }
+
+inline int idStr::icmpn
+   (
+   const idStr& text, 
+   int n
+   ) const
+
+   {
+	assert( m_data );
+	assert( text.m_data );
+
+   return idStr::icmpn( m_data->data, text.m_data->data, n );
+   }
+
+inline int idStr::icmp
+   (
+   const char *text
+   ) const
+
+   {
+	assert( m_data );
+	assert( text );
+
+   return idStr::icmp( m_data->data, text );
+   }
+
+inline int idStr::icmp
+   (
+   const idStr& text
+   ) const
+
+   {
+	assert( c_str () );
+	assert( text.c_str () );
+
+   return idStr::icmp( c_str () , text.c_str () );
+   }
+
+inline int idStr::cmp
+   (
+   const char *text
+   ) const
+
+   {
+	assert( m_data );
+	assert( text );
+
+   return idStr::cmp( m_data->data, text );
+   }
+
+inline int idStr::cmp
+   (
+   const idStr& text
+   ) const
+
+   {
+	assert( c_str () );
+	assert( text.c_str () );
+
+   return idStr::cmp( c_str () , text.c_str () );
+   }
+
+inline int idStr::cmpn
+   (
+   const char *text, 
+   int n
+   ) const
+
+   {
+	assert( c_str () );
+	assert( text );
+
+   return idStr::cmpn( c_str () , text, n );
+   }
+
+inline int idStr::cmpn
+   (
+   const idStr& text, 
+   int n
+   ) const
+
+   {
+	assert( c_str () );
+	assert( text.c_str ()  );
+
+   return idStr::cmpn( c_str () , text.c_str () , n );
+   }
+
+inline void idStr::tolower
+   (
+   void
+   )
+
+   {
+   assert( m_data );
+
+   EnsureDataWritable ();
+
+   idStr::tolower( m_data->data );
+   }
+
+inline void idStr::toupper
+   (
+   void
+   )
+
+   {
+   assert( m_data );
+
+   EnsureDataWritable ();
+
+   idStr::toupper( m_data->data );
+   }
+
+inline bool idStr::isNumeric
+   (
+   void
+   ) const
+
+   {
+   assert( m_data );
+   return idStr::isNumeric( m_data->data );
+   }
+
+inline idStr::operator const char *() {
+	return c_str();
+}
+
+inline idStr::operator const char *
+   (
+   void
+   ) const
+
+   {
+   return c_str ();
+   }
+
+#endif
\ No newline at end of file
diff --git a/codemp/Splines/vssver.scc b/codemp/Splines/vssver.scc
new file mode 100644
index 0000000..8c927b7
Binary files /dev/null and b/codemp/Splines/vssver.scc differ
diff --git a/codemp/VU.bat b/codemp/VU.bat
new file mode 100644
index 0000000..9e63a90
--- /dev/null
+++ b/codemp/VU.bat
@@ -0,0 +1 @@
+VersionUpdate -ss_ini \\Ravendata1\VSS\central_code\SRCSAFE.INI -ss_prj $/Jedi/CodeMp -header win32/AutoVersion.h -email SW-Everyone -interactive
diff --git a/codemp/WinDed.dsp b/codemp/WinDed.dsp
new file mode 100644
index 0000000..045ad36
--- /dev/null
+++ b/codemp/WinDed.dsp
@@ -0,0 +1,1123 @@
+# Microsoft Developer Studio Project File - Name="WinDed" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Console Application" 0x0103
+
+CFG=WinDed - Win32 Debug
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE 
+!MESSAGE NMAKE /f "WinDed.mak".
+!MESSAGE 
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "WinDed.mak" CFG="WinDed - Win32 Debug"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "WinDed - Win32 Release" (based on "Win32 (x86) Console Application")
+!MESSAGE "WinDed - Win32 Debug" (based on "Win32 (x86) Console Application")
+!MESSAGE 
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""$/jedi/codemp", CAAAAAAA"
+# PROP Scc_LocalPath "."
+CPP=cl.exe
+RSC=rc.exe
+
+!IF  "$(CFG)" == "WinDed - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release/Dedicated"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
+# ADD CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /D "DEDICATED" /D "BOTLIB" /FR /YX /FD /c
+# ADD BASE RSC /l 0x409 /d "NDEBUG"
+# ADD RSC /l 0x409 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib wsock32.lib Winmm.lib /nologo /subsystem:console /machine:I386 /out:"Release/jk2Ded.exe"
+
+!ELSEIF  "$(CFG)" == "WinDed - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "Debug"
+# PROP Intermediate_Dir "Debug/dedicated"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c
+# ADD CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /D "DEDICATED" /D "_JK2" /D "BOTLIB" /FR /FD /GZ /c
+# SUBTRACT CPP /YX
+# ADD BASE RSC /l 0x409 /d "_DEBUG"
+# ADD RSC /l 0x409 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib wsock32.lib Winmm.lib /nologo /subsystem:console /debug /machine:I386 /out:"Debug/jk2Ded.exe" /pdbtype:sept
+
+!ENDIF 
+
+# Begin Target
+
+# Name "WinDed - Win32 Release"
+# Name "WinDed - Win32 Debug"
+# Begin Group "Resource Files"
+
+# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"
+# End Group
+# Begin Group "Common"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=.\qcommon\chash.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\qcommon\cm_draw.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\qcommon\cm_draw.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\qcommon\cm_landscape.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\qcommon\cm_load.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\qcommon\cm_local.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\qcommon\cm_patch.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\qcommon\cm_patch.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\qcommon\cm_polylib.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\qcommon\cm_polylib.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\qcommon\cm_public.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\qcommon\cm_randomterrain.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\qcommon\cm_randomterrain.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\qcommon\cm_shader.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\qcommon\cm_terrain.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\qcommon\cm_terrainmap.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\qcommon\cm_test.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\qcommon\cm_trace.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\qcommon\cmd.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\qcommon\common.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\qcommon\cvar.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\qcommon\disablewarnings.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\qcommon\files.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\qcommon\game_version.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\qcommon\genericparser2.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\qcommon\GenericParser2.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\qcommon\huffman.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\qcommon\md4.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\qcommon\MiniHeap.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\qcommon\msg.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\qcommon\net_chan.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\game\q_math.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\game\q_shared.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\qcommon\qcommon.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\qcommon\qfiles.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\qcommon\RoffSystem.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\qcommon\RoffSystem.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\qcommon\sstring.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\qcommon\strip.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\qcommon\strip.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\qcommon\tags.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\qcommon\timing.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\qcommon\unzip.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\qcommon\unzip.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\qcommon\vm.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\qcommon\vm_interpreted.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\qcommon\vm_local.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\qcommon\vm_x86.cpp
+# End Source File
+# End Group
+# Begin Group "Ghoul2"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=.\ghoul2\G2.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\ghoul2\G2_API.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\ghoul2\G2_bolts.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\ghoul2\G2_bones.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\ghoul2\G2_gore.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\ghoul2\G2_local.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\ghoul2\G2_misc.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\ghoul2\G2_surfaces.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\ghoul2\ghoul2_shared.h
+# End Source File
+# End Group
+# Begin Group "Server"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=.\server\server.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\server\sv_bot.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\server\sv_ccmds.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\server\sv_client.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\server\sv_game.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\server\sv_init.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\server\sv_main.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\server\sv_net_chan.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\server\sv_snapshot.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\server\sv_world.cpp
+# End Source File
+# End Group
+# Begin Group "Null"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=.\null\null_client.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\null\null_glimp.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\null\null_input.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\null\null_renderer.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\null\null_snddma.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\null\win_main.cpp
+# End Source File
+# End Group
+# Begin Group "Renderer"
+
+# PROP Default_Filter ""
+# Begin Group "png"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=.\png\png.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\png\png.h
+# End Source File
+# End Group
+# Begin Source File
+
+SOURCE=.\renderer\matcomp.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\renderer\tr_backend.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\renderer\tr_ghoul2.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\renderer\tr_image.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\renderer\tr_init.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\renderer\tr_main.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\renderer\tr_mesh.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\renderer\tr_model.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\renderer\tr_shader.cpp
+# End Source File
+# End Group
+# Begin Group "Win32"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=.\win32\win_net.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\win32\win_shared.cpp
+# End Source File
+# End Group
+# Begin Group "botlib"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=.\botlib\aasfile.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\botlib\be_aas_bsp.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\botlib\be_aas_bspq3.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\botlib\be_aas_cluster.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\botlib\be_aas_cluster.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\botlib\be_aas_debug.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\botlib\be_aas_debug.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\botlib\be_aas_def.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\botlib\be_aas_entity.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\botlib\be_aas_entity.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\botlib\be_aas_file.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\botlib\be_aas_file.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\botlib\be_aas_funcs.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\botlib\be_aas_main.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\botlib\be_aas_main.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\botlib\be_aas_move.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\botlib\be_aas_move.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\botlib\be_aas_optimize.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\botlib\be_aas_optimize.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\botlib\be_aas_reach.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\botlib\be_aas_reach.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\botlib\be_aas_route.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\botlib\be_aas_route.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\botlib\be_aas_routealt.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\botlib\be_aas_routealt.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\botlib\be_aas_sample.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\botlib\be_aas_sample.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\botlib\be_ai_char.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\botlib\be_ai_chat.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\botlib\be_ai_gen.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\botlib\be_ai_goal.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\botlib\be_ai_move.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\botlib\be_ai_weap.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\botlib\be_ai_weight.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\botlib\be_ai_weight.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\botlib\be_ea.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\botlib\be_interface.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\botlib\be_interface.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\botlib\l_crc.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\botlib\l_crc.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\botlib\l_libvar.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\botlib\l_libvar.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\botlib\l_log.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\botlib\l_log.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\botlib\l_memory.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\botlib\l_memory.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\botlib\l_precomp.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\botlib\l_precomp.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\botlib\l_script.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\botlib\l_script.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\botlib\l_struct.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\botlib\l_struct.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\botlib\l_utils.h
+# End Source File
+# End Group
+# Begin Group "headers"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=.\game\anims.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\game\be_aas.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\game\be_ai_char.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\game\be_ai_chat.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\game\be_ai_gen.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\game\be_ai_goal.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\game\be_ai_move.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\game\be_ai_weap.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\game\be_ea.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\game\bg_public.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\game\bg_weapons.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\game\botlib.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\cgame\cg_public.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\client\client.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\encryption\encryption.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\game\g_public.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\renderer\glext.h
+# End Source File
+# Begin Source File
+
+SOURCE=".\jpeg-6\jconfig.h"
+# End Source File
+# Begin Source File
+
+SOURCE=".\jpeg-6\jerror.h"
+# End Source File
+# Begin Source File
+
+SOURCE=".\jpeg-6\jmorecfg.h"
+# End Source File
+# Begin Source File
+
+SOURCE=".\jpeg-6\jpegint.h"
+# End Source File
+# Begin Source File
+
+SOURCE=".\jpeg-6\jpeglib.h"
+# End Source File
+# Begin Source File
+
+SOURCE=.\ui\keycodes.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\client\keys.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\renderer\matcomp.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\renderer\mdx_format.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\game\q_shared.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\renderer\qgl.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\client\snd_public.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\strings\str_server.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\game\surfaceflags.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\renderer\tr_font.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\renderer\tr_local.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\renderer\tr_public.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\cgame\tr_types.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\ui\ui_public.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\win32\win_local.h
+# End Source File
+# End Group
+# Begin Group "ICARUS"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=.\icarus\blockstream.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\icarus\blockstream.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\icarus\gameinterface.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\icarus\GameInterface.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\icarus\icarus.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\icarus\instance.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\icarus\instance.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\icarus\interface.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\icarus\interface.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\icarus\interpreter.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\icarus\memory.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\icarus\module.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\icarus\q3_interface.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\icarus\Q3_Interface.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\icarus\q3_registers.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\icarus\Q3_Registers.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\icarus\sequence.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\icarus\sequence.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\icarus\sequencer.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\icarus\sequencer.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\icarus\taskmanager.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\icarus\taskmanager.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\icarus\tokenizer.h
+# End Source File
+# End Group
+# Begin Group "RMG"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=.\rmg\rm_area.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\RMG\RM_Area.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\RMG\RM_Headers.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\rmg\rm_instance.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\RMG\RM_Instance.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\rmg\rm_instance_bsp.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\RMG\RM_Instance_BSP.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\rmg\rm_instance_group.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\RMG\RM_Instance_Group.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\rmg\rm_instance_random.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\RMG\RM_Instance_Random.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\rmg\rm_instance_void.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\RMG\RM_Instance_Void.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\rmg\rm_instancefile.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\RMG\RM_InstanceFile.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\rmg\rm_manager.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\RMG\RM_Manager.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\rmg\rm_mission.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\RMG\RM_Mission.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\rmg\rm_objective.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\RMG\RM_Objective.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\rmg\rm_path.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\RMG\RM_Path.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\rmg\rm_terrain.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\RMG\RM_Terrain.h
+# End Source File
+# End Group
+# Begin Group "zlib"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=.\zlib\adler32.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\zlib\crc32.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\zlib\deflate.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\zlib\deflate.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\zlib\infblock.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\zlib\infblock.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\zlib\infcodes.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\zlib\infcodes.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\zlib\inffast.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\zlib\inffast.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\zlib\inffixed.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\zlib\inflate.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\zlib\inftrees.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\zlib\inftrees.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\zlib\infutil.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\zlib\infutil.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\zlib\trees.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\zlib\trees.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\zlib\zconf.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\zlib\zlib.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\zlib\zutil.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\zlib\zutil.h
+# End Source File
+# End Group
+# End Target
+# End Project
diff --git a/codemp/WinDed.vcproj b/codemp/WinDed.vcproj
new file mode 100644
index 0000000..0bde5a3
--- /dev/null
+++ b/codemp/WinDed.vcproj
@@ -0,0 +1,901 @@
+<?xml version="1.0" encoding = "Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="7.00"
+	Name="WinDed"
+	SccProjectName="&quot;$/jedi/codemp&quot;, CAAAAAAA"
+	SccAuxPath=""
+	SccLocalPath="."
+	SccProvider="MSSCCI:SourceOffSite">
+	<Platforms>
+		<Platform
+			Name="Win32"/>
+	</Platforms>
+	<Configurations>
+		<Configuration
+			Name="Release|Win32"
+			OutputDirectory=".\Release"
+			IntermediateDirectory=".\Release/Dedicated"
+			ConfigurationType="1"
+			UseOfMFC="0"
+			ATLMinimizesCRunTimeLibraryUsage="FALSE"
+			CharacterSet="0">
+			<Tool
+				Name="VCCLCompilerTool"
+				GlobalOptimizations="TRUE"
+				InlineFunctionExpansion="2"
+				EnableIntrinsicFunctions="TRUE"
+				ImproveFloatingPointConsistency="FALSE"
+				FavorSizeOrSpeed="1"
+				OptimizeForProcessor="2"
+				OptimizeForWindowsApplication="TRUE"
+				PreprocessorDefinitions="WIN32,NDEBUG,_CONSOLE,DEDICATED,BOTLIB,_WINDOWS"
+				StringPooling="TRUE"
+				RuntimeLibrary="4"
+				BufferSecurityCheck="FALSE"
+				EnableFunctionLevelLinking="TRUE"
+				UsePrecompiledHeader="2"
+				PrecompiledHeaderFile=".\Release/Dedicated/WinDed.pch"
+				AssemblerListingLocation=".\Release/Dedicated/"
+				ObjectFile=".\Release/Dedicated/"
+				ProgramDataBaseFileName=".\Release/Dedicated/"
+				BrowseInformation="1"
+				WarningLevel="3"
+				SuppressStartupBanner="TRUE"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalOptions="/MACHINE:I386"
+				AdditionalDependencies="odbc32.lib odbccp32.lib wsock32.lib Winmm.lib"
+				OutputFile="Release/jampDed.exe"
+				LinkIncremental="1"
+				SuppressStartupBanner="TRUE"
+				ProgramDatabaseFile=".\Release/jk2Ded.pdb"
+				SubSystem="1"
+				OptimizeReferences="2"
+				EnableCOMDATFolding="2"
+				SetChecksum="TRUE"/>
+			<Tool
+				Name="VCMIDLTool"
+				TypeLibraryName=".\Release/WinDed.tlb"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="VCResourceCompilerTool"
+				PreprocessorDefinitions="NDEBUG"
+				Culture="1033"/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"/>
+			<Tool
+				Name="VCWebDeploymentTool"/>
+		</Configuration>
+		<Configuration
+			Name="Debug|Win32"
+			OutputDirectory=".\Debug"
+			IntermediateDirectory=".\Debug/dedicated"
+			ConfigurationType="1"
+			UseOfMFC="0"
+			ATLMinimizesCRunTimeLibraryUsage="FALSE"
+			CharacterSet="0">
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				PreprocessorDefinitions="WIN32,_DEBUG,_CONSOLE,DEDICATED,_JK2,BOTLIB,_WINDOWS"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="5"
+				PrecompiledHeaderFile=".\Debug/dedicated/WinDed.pch"
+				AssemblerListingLocation=".\Debug/dedicated/"
+				ObjectFile=".\Debug/dedicated/"
+				ProgramDataBaseFileName=".\Debug/dedicated/"
+				BrowseInformation="1"
+				WarningLevel="3"
+				SuppressStartupBanner="TRUE"
+				DebugInformationFormat="4"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalOptions="/MACHINE:I386"
+				AdditionalDependencies="odbc32.lib odbccp32.lib wsock32.lib Winmm.lib"
+				OutputFile="Debug/jampDed.exe"
+				LinkIncremental="2"
+				SuppressStartupBanner="TRUE"
+				GenerateDebugInformation="TRUE"
+				ProgramDatabaseFile=".\Debug/jk2Ded.pdb"
+				SubSystem="1"/>
+			<Tool
+				Name="VCMIDLTool"
+				TypeLibraryName=".\Debug/WinDed.tlb"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="VCResourceCompilerTool"
+				PreprocessorDefinitions="_DEBUG"
+				Culture="1033"/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"/>
+			<Tool
+				Name="VCWebDeploymentTool"/>
+		</Configuration>
+	</Configurations>
+	<Files>
+		<Filter
+			Name="Common"
+			Filter="">
+			<File
+				RelativePath=".\qcommon\GenericParser2.h">
+			</File>
+			<File
+				RelativePath=".\qcommon\MiniHeap.h">
+			</File>
+			<File
+				RelativePath=".\qcommon\RoffSystem.cpp">
+			</File>
+			<File
+				RelativePath=".\qcommon\RoffSystem.h">
+			</File>
+			<File
+				RelativePath=".\qcommon\chash.h">
+			</File>
+			<File
+				RelativePath=".\qcommon\cm_draw.cpp">
+			</File>
+			<File
+				RelativePath=".\qcommon\cm_draw.h">
+			</File>
+			<File
+				RelativePath=".\qcommon\cm_landscape.h">
+			</File>
+			<File
+				RelativePath=".\qcommon\cm_load.cpp">
+			</File>
+			<File
+				RelativePath=".\qcommon\cm_local.h">
+			</File>
+			<File
+				RelativePath=".\qcommon\cm_patch.cpp">
+			</File>
+			<File
+				RelativePath=".\qcommon\cm_patch.h">
+			</File>
+			<File
+				RelativePath=".\qcommon\cm_polylib.cpp">
+			</File>
+			<File
+				RelativePath=".\qcommon\cm_polylib.h">
+			</File>
+			<File
+				RelativePath=".\qcommon\cm_public.h">
+			</File>
+			<File
+				RelativePath=".\qcommon\cm_randomterrain.cpp">
+			</File>
+			<File
+				RelativePath=".\qcommon\cm_randomterrain.h">
+			</File>
+			<File
+				RelativePath=".\qcommon\cm_shader.cpp">
+			</File>
+			<File
+				RelativePath=".\qcommon\cm_terrain.cpp">
+			</File>
+			<File
+				RelativePath=".\qcommon\cm_terrainmap.h">
+			</File>
+			<File
+				RelativePath=".\qcommon\cm_test.cpp">
+			</File>
+			<File
+				RelativePath=".\qcommon\cm_trace.cpp">
+			</File>
+			<File
+				RelativePath="qcommon\cmd_common.cpp">
+			</File>
+			<File
+				RelativePath="qcommon\cmd_pc.cpp">
+			</File>
+			<File
+				RelativePath=".\qcommon\common.cpp">
+			</File>
+			<File
+				RelativePath=".\qcommon\cvar.cpp">
+			</File>
+			<File
+				RelativePath=".\qcommon\disablewarnings.h">
+			</File>
+			<File
+				RelativePath="qcommon\files_common.cpp">
+			</File>
+			<File
+				RelativePath="qcommon\files_pc.cpp">
+			</File>
+			<File
+				RelativePath=".\qcommon\game_version.h">
+			</File>
+			<File
+				RelativePath=".\qcommon\genericparser2.cpp">
+			</File>
+			<File
+				RelativePath=".\qcommon\huffman.cpp">
+			</File>
+			<File
+				RelativePath=".\qcommon\md4.cpp">
+			</File>
+			<File
+				RelativePath=".\qcommon\msg.cpp">
+			</File>
+			<File
+				RelativePath=".\qcommon\net_chan.cpp">
+			</File>
+			<File
+				RelativePath="qcommon\q_math.cpp">
+			</File>
+			<File
+				RelativePath="qcommon\q_shared.cpp">
+			</File>
+			<File
+				RelativePath=".\qcommon\qcommon.h">
+			</File>
+			<File
+				RelativePath=".\qcommon\qfiles.h">
+			</File>
+			<File
+				RelativePath=".\qcommon\sstring.h">
+			</File>
+			<File
+				RelativePath="qcommon\stringed_ingame.cpp">
+			</File>
+			<File
+				RelativePath="qcommon\stringed_ingame.h">
+			</File>
+			<File
+				RelativePath="qcommon\stringed_interface.cpp">
+			</File>
+			<File
+				RelativePath="qcommon\stringed_interface.h">
+			</File>
+			<File
+				RelativePath=".\qcommon\tags.h">
+			</File>
+			<File
+				RelativePath=".\qcommon\timing.h">
+			</File>
+			<File
+				RelativePath=".\qcommon\unzip.cpp">
+			</File>
+			<File
+				RelativePath=".\qcommon\unzip.h">
+			</File>
+			<File
+				RelativePath=".\qcommon\vm.cpp">
+			</File>
+			<File
+				RelativePath=".\qcommon\vm_interpreted.cpp">
+			</File>
+			<File
+				RelativePath=".\qcommon\vm_local.h">
+			</File>
+			<File
+				RelativePath=".\qcommon\vm_x86.cpp">
+			</File>
+			<File
+				RelativePath="qcommon\z_memman_pc.cpp">
+			</File>
+		</Filter>
+		<Filter
+			Name="Ghoul2"
+			Filter="">
+			<File
+				RelativePath=".\ghoul2\G2.h">
+			</File>
+			<File
+				RelativePath=".\ghoul2\G2_API.cpp">
+			</File>
+			<File
+				RelativePath=".\ghoul2\G2_bolts.cpp">
+			</File>
+			<File
+				RelativePath=".\ghoul2\G2_bones.cpp">
+			</File>
+			<File
+				RelativePath=".\ghoul2\G2_gore.h">
+			</File>
+			<File
+				RelativePath=".\ghoul2\G2_local.h">
+			</File>
+			<File
+				RelativePath=".\ghoul2\G2_misc.cpp">
+			</File>
+			<File
+				RelativePath=".\ghoul2\G2_surfaces.cpp">
+			</File>
+			<File
+				RelativePath=".\ghoul2\ghoul2_shared.h">
+			</File>
+		</Filter>
+		<Filter
+			Name="Server"
+			Filter="">
+			<File
+				RelativePath=".\server\server.h">
+			</File>
+			<File
+				RelativePath=".\server\sv_bot.cpp">
+			</File>
+			<File
+				RelativePath=".\server\sv_ccmds.cpp">
+			</File>
+			<File
+				RelativePath=".\server\sv_client.cpp">
+			</File>
+			<File
+				RelativePath=".\server\sv_game.cpp">
+			</File>
+			<File
+				RelativePath=".\server\sv_init.cpp">
+			</File>
+			<File
+				RelativePath=".\server\sv_main.cpp">
+			</File>
+			<File
+				RelativePath=".\server\sv_net_chan.cpp">
+			</File>
+			<File
+				RelativePath=".\server\sv_snapshot.cpp">
+			</File>
+			<File
+				RelativePath=".\server\sv_world.cpp">
+			</File>
+			<Filter
+				Name="NPCNav"
+				Filter="">
+				<File
+					RelativePath="server\NPCNav\gameCallbacks.cpp">
+				</File>
+				<File
+					RelativePath="server\NPCNav\navigator.cpp">
+				</File>
+				<File
+					RelativePath="server\NPCNav\navigator.h">
+				</File>
+			</Filter>
+		</Filter>
+		<Filter
+			Name="Null"
+			Filter="">
+			<File
+				RelativePath=".\null\null_client.cpp">
+			</File>
+			<File
+				RelativePath=".\null\null_glimp.cpp">
+			</File>
+			<File
+				RelativePath=".\null\null_input.cpp">
+			</File>
+			<File
+				RelativePath=".\null\null_renderer.cpp">
+			</File>
+			<File
+				RelativePath=".\null\null_snddma.cpp">
+			</File>
+			<File
+				RelativePath=".\null\win_main.cpp">
+			</File>
+		</Filter>
+		<Filter
+			Name="Renderer"
+			Filter="">
+			<File
+				RelativePath=".\renderer\matcomp.c">
+			</File>
+			<File
+				RelativePath=".\renderer\tr_backend.cpp">
+			</File>
+			<File
+				RelativePath=".\renderer\tr_ghoul2.cpp">
+			</File>
+			<File
+				RelativePath=".\renderer\tr_image.cpp">
+			</File>
+			<File
+				RelativePath=".\renderer\tr_init.cpp">
+			</File>
+			<File
+				RelativePath=".\renderer\tr_main.cpp">
+			</File>
+			<File
+				RelativePath=".\renderer\tr_mesh.cpp">
+			</File>
+			<File
+				RelativePath=".\renderer\tr_model.cpp">
+			</File>
+			<File
+				RelativePath=".\renderer\tr_shader.cpp">
+			</File>
+			<Filter
+				Name="png"
+				Filter="">
+				<File
+					RelativePath=".\png\png.cpp">
+				</File>
+				<File
+					RelativePath=".\png\png.h">
+				</File>
+			</Filter>
+		</Filter>
+		<Filter
+			Name="Win32"
+			Filter="">
+			<File
+				RelativePath="win32\WinDed.rc">
+			</File>
+			<File
+				RelativePath=".\win32\win_net.cpp">
+			</File>
+			<File
+				RelativePath=".\win32\win_shared.cpp">
+			</File>
+		</Filter>
+		<Filter
+			Name="botlib"
+			Filter="">
+			<File
+				RelativePath=".\botlib\aasfile.h">
+			</File>
+			<File
+				RelativePath=".\botlib\be_aas_bsp.h">
+			</File>
+			<File
+				RelativePath=".\botlib\be_aas_bspq3.cpp">
+			</File>
+			<File
+				RelativePath=".\botlib\be_aas_cluster.cpp">
+			</File>
+			<File
+				RelativePath=".\botlib\be_aas_cluster.h">
+			</File>
+			<File
+				RelativePath=".\botlib\be_aas_debug.cpp">
+			</File>
+			<File
+				RelativePath=".\botlib\be_aas_debug.h">
+			</File>
+			<File
+				RelativePath=".\botlib\be_aas_def.h">
+			</File>
+			<File
+				RelativePath=".\botlib\be_aas_entity.cpp">
+			</File>
+			<File
+				RelativePath=".\botlib\be_aas_entity.h">
+			</File>
+			<File
+				RelativePath=".\botlib\be_aas_file.cpp">
+			</File>
+			<File
+				RelativePath=".\botlib\be_aas_file.h">
+			</File>
+			<File
+				RelativePath=".\botlib\be_aas_funcs.h">
+			</File>
+			<File
+				RelativePath=".\botlib\be_aas_main.cpp">
+			</File>
+			<File
+				RelativePath=".\botlib\be_aas_main.h">
+			</File>
+			<File
+				RelativePath=".\botlib\be_aas_move.cpp">
+			</File>
+			<File
+				RelativePath=".\botlib\be_aas_move.h">
+			</File>
+			<File
+				RelativePath=".\botlib\be_aas_optimize.cpp">
+			</File>
+			<File
+				RelativePath=".\botlib\be_aas_optimize.h">
+			</File>
+			<File
+				RelativePath=".\botlib\be_aas_reach.cpp">
+			</File>
+			<File
+				RelativePath=".\botlib\be_aas_reach.h">
+			</File>
+			<File
+				RelativePath=".\botlib\be_aas_route.cpp">
+			</File>
+			<File
+				RelativePath=".\botlib\be_aas_route.h">
+			</File>
+			<File
+				RelativePath=".\botlib\be_aas_routealt.cpp">
+			</File>
+			<File
+				RelativePath=".\botlib\be_aas_routealt.h">
+			</File>
+			<File
+				RelativePath=".\botlib\be_aas_sample.cpp">
+			</File>
+			<File
+				RelativePath=".\botlib\be_aas_sample.h">
+			</File>
+			<File
+				RelativePath=".\botlib\be_ai_char.cpp">
+			</File>
+			<File
+				RelativePath=".\botlib\be_ai_chat.cpp">
+			</File>
+			<File
+				RelativePath=".\botlib\be_ai_gen.cpp">
+			</File>
+			<File
+				RelativePath=".\botlib\be_ai_goal.cpp">
+			</File>
+			<File
+				RelativePath=".\botlib\be_ai_move.cpp">
+			</File>
+			<File
+				RelativePath=".\botlib\be_ai_weap.cpp">
+			</File>
+			<File
+				RelativePath=".\botlib\be_ai_weight.cpp">
+			</File>
+			<File
+				RelativePath=".\botlib\be_ai_weight.h">
+			</File>
+			<File
+				RelativePath=".\botlib\be_ea.cpp">
+			</File>
+			<File
+				RelativePath=".\botlib\be_interface.cpp">
+			</File>
+			<File
+				RelativePath=".\botlib\be_interface.h">
+			</File>
+			<File
+				RelativePath=".\botlib\l_crc.cpp">
+			</File>
+			<File
+				RelativePath=".\botlib\l_crc.h">
+			</File>
+			<File
+				RelativePath=".\botlib\l_libvar.cpp">
+			</File>
+			<File
+				RelativePath=".\botlib\l_libvar.h">
+			</File>
+			<File
+				RelativePath=".\botlib\l_log.cpp">
+			</File>
+			<File
+				RelativePath=".\botlib\l_log.h">
+			</File>
+			<File
+				RelativePath=".\botlib\l_memory.cpp">
+			</File>
+			<File
+				RelativePath=".\botlib\l_memory.h">
+			</File>
+			<File
+				RelativePath=".\botlib\l_precomp.cpp">
+			</File>
+			<File
+				RelativePath=".\botlib\l_precomp.h">
+			</File>
+			<File
+				RelativePath=".\botlib\l_script.cpp">
+			</File>
+			<File
+				RelativePath=".\botlib\l_script.h">
+			</File>
+			<File
+				RelativePath=".\botlib\l_struct.cpp">
+			</File>
+			<File
+				RelativePath=".\botlib\l_struct.h">
+			</File>
+			<File
+				RelativePath=".\botlib\l_utils.h">
+			</File>
+		</Filter>
+		<Filter
+			Name="headers"
+			Filter="">
+			<File
+				RelativePath=".\game\anims.h">
+			</File>
+			<File
+				RelativePath=".\game\be_aas.h">
+			</File>
+			<File
+				RelativePath=".\game\be_ai_char.h">
+			</File>
+			<File
+				RelativePath=".\game\be_ai_chat.h">
+			</File>
+			<File
+				RelativePath=".\game\be_ai_gen.h">
+			</File>
+			<File
+				RelativePath=".\game\be_ai_goal.h">
+			</File>
+			<File
+				RelativePath=".\game\be_ai_move.h">
+			</File>
+			<File
+				RelativePath=".\game\be_ai_weap.h">
+			</File>
+			<File
+				RelativePath=".\game\be_ea.h">
+			</File>
+			<File
+				RelativePath=".\game\bg_public.h">
+			</File>
+			<File
+				RelativePath=".\game\bg_weapons.h">
+			</File>
+			<File
+				RelativePath=".\game\botlib.h">
+			</File>
+			<File
+				RelativePath=".\cgame\cg_public.h">
+			</File>
+			<File
+				RelativePath=".\client\client.h">
+			</File>
+			<File
+				RelativePath=".\game\g_public.h">
+			</File>
+			<File
+				RelativePath=".\renderer\glext.h">
+			</File>
+			<File
+				RelativePath=".\jpeg-6\jconfig.h">
+			</File>
+			<File
+				RelativePath=".\jpeg-6\jerror.h">
+			</File>
+			<File
+				RelativePath=".\jpeg-6\jmorecfg.h">
+			</File>
+			<File
+				RelativePath=".\jpeg-6\jpegint.h">
+			</File>
+			<File
+				RelativePath=".\jpeg-6\jpeglib.h">
+			</File>
+			<File
+				RelativePath=".\ui\keycodes.h">
+			</File>
+			<File
+				RelativePath=".\client\keys.h">
+			</File>
+			<File
+				RelativePath=".\renderer\matcomp.h">
+			</File>
+			<File
+				RelativePath=".\renderer\mdx_format.h">
+			</File>
+			<File
+				RelativePath=".\game\q_shared.h">
+			</File>
+			<File
+				RelativePath=".\renderer\qgl.h">
+			</File>
+			<File
+				RelativePath=".\client\snd_public.h">
+			</File>
+			<File
+				RelativePath=".\game\surfaceflags.h">
+			</File>
+			<File
+				RelativePath=".\renderer\tr_font.h">
+			</File>
+			<File
+				RelativePath=".\renderer\tr_local.h">
+			</File>
+			<File
+				RelativePath=".\renderer\tr_public.h">
+			</File>
+			<File
+				RelativePath=".\cgame\tr_types.h">
+			</File>
+			<File
+				RelativePath=".\ui\ui_public.h">
+			</File>
+			<File
+				RelativePath=".\win32\win_local.h">
+			</File>
+		</Filter>
+		<Filter
+			Name="ICARUS"
+			Filter="">
+			<File
+				RelativePath=".\icarus\GameInterface.h">
+			</File>
+			<File
+				RelativePath=".\icarus\Q3_Interface.h">
+			</File>
+			<File
+				RelativePath=".\icarus\Q3_Registers.h">
+			</File>
+			<File
+				RelativePath=".\icarus\blockstream.cpp">
+			</File>
+			<File
+				RelativePath=".\icarus\blockstream.h">
+			</File>
+			<File
+				RelativePath=".\icarus\gameinterface.cpp">
+			</File>
+			<File
+				RelativePath=".\icarus\icarus.h">
+			</File>
+			<File
+				RelativePath=".\icarus\instance.cpp">
+			</File>
+			<File
+				RelativePath=".\icarus\instance.h">
+			</File>
+			<File
+				RelativePath=".\icarus\interface.cpp">
+			</File>
+			<File
+				RelativePath=".\icarus\interface.h">
+			</File>
+			<File
+				RelativePath=".\icarus\interpreter.h">
+			</File>
+			<File
+				RelativePath=".\icarus\memory.cpp">
+			</File>
+			<File
+				RelativePath=".\icarus\module.h">
+			</File>
+			<File
+				RelativePath=".\icarus\q3_interface.cpp">
+			</File>
+			<File
+				RelativePath=".\icarus\q3_registers.cpp">
+			</File>
+			<File
+				RelativePath=".\icarus\sequence.cpp">
+			</File>
+			<File
+				RelativePath=".\icarus\sequence.h">
+			</File>
+			<File
+				RelativePath=".\icarus\sequencer.cpp">
+			</File>
+			<File
+				RelativePath=".\icarus\sequencer.h">
+			</File>
+			<File
+				RelativePath=".\icarus\taskmanager.cpp">
+			</File>
+			<File
+				RelativePath=".\icarus\taskmanager.h">
+			</File>
+			<File
+				RelativePath=".\icarus\tokenizer.h">
+			</File>
+		</Filter>
+		<Filter
+			Name="RMG"
+			Filter="">
+			<File
+				RelativePath=".\RMG\RM_Area.h">
+			</File>
+			<File
+				RelativePath=".\RMG\RM_Headers.h">
+			</File>
+			<File
+				RelativePath=".\RMG\RM_Instance.h">
+			</File>
+			<File
+				RelativePath=".\RMG\RM_InstanceFile.h">
+			</File>
+			<File
+				RelativePath=".\RMG\RM_Instance_BSP.h">
+			</File>
+			<File
+				RelativePath=".\RMG\RM_Instance_Group.h">
+			</File>
+			<File
+				RelativePath=".\RMG\RM_Instance_Random.h">
+			</File>
+			<File
+				RelativePath=".\RMG\RM_Instance_Void.h">
+			</File>
+			<File
+				RelativePath=".\RMG\RM_Manager.h">
+			</File>
+			<File
+				RelativePath=".\RMG\RM_Mission.h">
+			</File>
+			<File
+				RelativePath=".\RMG\RM_Objective.h">
+			</File>
+			<File
+				RelativePath=".\RMG\RM_Path.h">
+			</File>
+			<File
+				RelativePath=".\RMG\RM_Terrain.h">
+			</File>
+			<File
+				RelativePath=".\rmg\rm_area.cpp">
+			</File>
+			<File
+				RelativePath=".\rmg\rm_instance.cpp">
+			</File>
+			<File
+				RelativePath=".\rmg\rm_instance_bsp.cpp">
+			</File>
+			<File
+				RelativePath=".\rmg\rm_instance_group.cpp">
+			</File>
+			<File
+				RelativePath=".\rmg\rm_instance_random.cpp">
+			</File>
+			<File
+				RelativePath=".\rmg\rm_instance_void.cpp">
+			</File>
+			<File
+				RelativePath=".\rmg\rm_instancefile.cpp">
+			</File>
+			<File
+				RelativePath=".\rmg\rm_manager.cpp">
+			</File>
+			<File
+				RelativePath=".\rmg\rm_mission.cpp">
+			</File>
+			<File
+				RelativePath=".\rmg\rm_objective.cpp">
+			</File>
+			<File
+				RelativePath=".\rmg\rm_path.cpp">
+			</File>
+			<File
+				RelativePath=".\rmg\rm_terrain.cpp">
+			</File>
+		</Filter>
+		<Filter
+			Name="zlib32"
+			Filter="">
+			<File
+				RelativePath="zlib32\deflate.cpp">
+			</File>
+			<File
+				RelativePath="zlib32\deflate.h">
+			</File>
+			<File
+				RelativePath="zlib32\inflate.cpp">
+			</File>
+			<File
+				RelativePath="zlib32\inflate.h">
+			</File>
+			<File
+				RelativePath="zlib32\zip.h">
+			</File>
+			<File
+				RelativePath="zlib32\zipcommon.cpp">
+			</File>
+		</Filter>
+		<Filter
+			Name="Resource Files"
+			Filter="ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe">
+		</Filter>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>
diff --git a/codemp/WinDed.vcproj.vspscc b/codemp/WinDed.vcproj.vspscc
new file mode 100644
index 0000000..794f014
--- /dev/null
+++ b/codemp/WinDed.vcproj.vspscc
@@ -0,0 +1,10 @@
+""
+{
+"FILE_VERSION" = "9237"
+"ENLISTMENT_CHOICE" = "NEVER"
+"PROJECT_FILE_RELATIVE_PATH" = ""
+"NUMBER_OF_EXCLUDED_FILES" = "0"
+"ORIGINAL_PROJECT_FILE_PATH" = ""
+"NUMBER_OF_NESTED_PROJECTS" = "0"
+"SOURCE_CONTROL_SETTINGS_PROVIDER" = "PROJECT"
+}
diff --git a/codemp/botlib/aasfile.h b/codemp/botlib/aasfile.h
new file mode 100644
index 0000000..9fddc83
--- /dev/null
+++ b/codemp/botlib/aasfile.h
@@ -0,0 +1,246 @@
+
+
+//NOTE:	int =	default signed
+//				default long
+
+#define AASID						(('S'<<24)+('A'<<16)+('A'<<8)+'E')
+#define AASVERSION_OLD				4
+#define AASVERSION					5
+
+//presence types
+#define PRESENCE_NONE				1
+#define PRESENCE_NORMAL				2
+#define PRESENCE_CROUCH				4
+
+//travel types
+#define MAX_TRAVELTYPES				32
+#define TRAVEL_INVALID				1		//temporary not possible
+#define TRAVEL_WALK					2		//walking
+#define TRAVEL_CROUCH				3		//crouching
+#define TRAVEL_BARRIERJUMP			4		//jumping onto a barrier
+#define TRAVEL_JUMP					5		//jumping
+#define TRAVEL_LADDER				6		//climbing a ladder
+#define TRAVEL_WALKOFFLEDGE			7		//walking of a ledge
+#define TRAVEL_SWIM					8		//swimming
+#define TRAVEL_WATERJUMP			9		//jump out of the water
+#define TRAVEL_TELEPORT				10		//teleportation
+#define TRAVEL_ELEVATOR				11		//travel by elevator
+#define TRAVEL_ROCKETJUMP			12		//rocket jumping required for travel
+#define TRAVEL_BFGJUMP				13		//bfg jumping required for travel
+#define TRAVEL_GRAPPLEHOOK			14		//grappling hook required for travel
+#define TRAVEL_DOUBLEJUMP			15		//double jump
+#define TRAVEL_RAMPJUMP				16		//ramp jump
+#define TRAVEL_STRAFEJUMP			17		//strafe jump
+#define TRAVEL_JUMPPAD				18		//jump pad
+#define TRAVEL_FUNCBOB				19		//func bob
+
+//additional travel flags
+#define TRAVELTYPE_MASK				0xFFFFFF
+#define TRAVELFLAG_NOTTEAM1			(1 << 24)
+#define TRAVELFLAG_NOTTEAM2			(2 << 24)
+
+//face flags
+#define FACE_SOLID					1		//just solid at the other side
+#define FACE_LADDER					2		//ladder
+#define FACE_GROUND					4		//standing on ground when in this face
+#define FACE_GAP					8		//gap in the ground
+#define FACE_LIQUID					16		//face seperating two areas with liquid
+#define FACE_LIQUIDSURFACE			32		//face seperating liquid and air
+#define FACE_BRIDGE					64		//can walk over this face if bridge is closed
+
+//area contents
+#define AREACONTENTS_WATER				1
+#define AREACONTENTS_LAVA				2
+#define AREACONTENTS_SLIME				4
+#define AREACONTENTS_CLUSTERPORTAL		8
+#define AREACONTENTS_TELEPORTAL			16
+#define AREACONTENTS_ROUTEPORTAL		32
+#define AREACONTENTS_TELEPORTER			64
+#define AREACONTENTS_JUMPPAD			128
+#define AREACONTENTS_DONOTENTER			256
+#define	AREACONTENTS_VIEWPORTAL			512
+#define AREACONTENTS_MOVER				1024
+#define AREACONTENTS_NOTTEAM1			2048
+#define AREACONTENTS_NOTTEAM2			4096
+//number of model of the mover inside this area
+#define AREACONTENTS_MODELNUMSHIFT		24
+#define AREACONTENTS_MAXMODELNUM		0xFF
+#define AREACONTENTS_MODELNUM			(AREACONTENTS_MAXMODELNUM << AREACONTENTS_MODELNUMSHIFT)
+
+//area flags
+#define AREA_GROUNDED				1		//bot can stand on the ground
+#define AREA_LADDER					2		//area contains one or more ladder faces
+#define AREA_LIQUID					4		//area contains a liquid
+#define AREA_DISABLED				8		//area is disabled for routing when set
+#define AREA_BRIDGE					16		//area ontop of a bridge
+
+//aas file header lumps
+#define AAS_LUMPS					14
+#define AASLUMP_BBOXES				0
+#define AASLUMP_VERTEXES			1
+#define AASLUMP_PLANES				2
+#define AASLUMP_EDGES				3
+#define AASLUMP_EDGEINDEX			4
+#define AASLUMP_FACES				5
+#define AASLUMP_FACEINDEX			6
+#define AASLUMP_AREAS				7
+#define AASLUMP_AREASETTINGS		8
+#define AASLUMP_REACHABILITY		9
+#define AASLUMP_NODES				10
+#define AASLUMP_PORTALS				11
+#define AASLUMP_PORTALINDEX			12
+#define AASLUMP_CLUSTERS			13
+
+//========== bounding box =========
+
+//bounding box
+typedef struct aas_bbox_s
+{
+	int presencetype;
+	int flags;
+	vec3_t mins, maxs;
+} aas_bbox_t;
+
+//============ settings ===========
+
+//reachability to another area
+typedef struct aas_reachability_s
+{
+	int areanum;						//number of the reachable area
+	int facenum;						//number of the face towards the other area
+	int edgenum;						//number of the edge towards the other area
+	vec3_t start;						//start point of inter area movement
+	vec3_t end;							//end point of inter area movement
+	int traveltype;					//type of travel required to get to the area
+	unsigned short int traveltime;//travel time of the inter area movement
+} aas_reachability_t;
+
+//area settings
+typedef struct aas_areasettings_s
+{
+	//could also add all kind of statistic fields
+	int contents;						//contents of the area
+	int areaflags;						//several area flags
+	int presencetype;					//how a bot can be present in this area
+	int cluster;						//cluster the area belongs to, if negative it's a portal
+	int clusterareanum;				//number of the area in the cluster
+	int numreachableareas;			//number of reachable areas from this one
+	int firstreachablearea;			//first reachable area in the reachable area index
+} aas_areasettings_t;
+
+//cluster portal
+typedef struct aas_portal_s
+{
+	int areanum;						//area that is the actual portal
+	int frontcluster;					//cluster at front of portal
+	int backcluster;					//cluster at back of portal
+	int clusterareanum[2];			//number of the area in the front and back cluster
+} aas_portal_t;
+
+//cluster portal index
+typedef int aas_portalindex_t;
+
+//cluster
+typedef struct aas_cluster_s
+{
+	int numareas;						//number of areas in the cluster
+	int numreachabilityareas;			//number of areas with reachabilities
+	int numportals;						//number of cluster portals
+	int firstportal;					//first cluster portal in the index
+} aas_cluster_t;
+
+//============ 3d definition ============
+
+typedef vec3_t aas_vertex_t;
+
+//just a plane in the third dimension
+typedef struct aas_plane_s
+{
+	vec3_t normal;						//normal vector of the plane
+	float dist;							//distance of the plane (normal vector * distance = point in plane)
+	int type;
+} aas_plane_t;
+
+//edge
+typedef struct aas_edge_s
+{
+	int v[2];							//numbers of the vertexes of this edge
+} aas_edge_t;
+
+//edge index, negative if vertexes are reversed
+typedef int aas_edgeindex_t;
+
+//a face bounds an area, often it will also seperate two areas
+typedef struct aas_face_s
+{
+	int planenum;						//number of the plane this face is in
+	int faceflags;						//face flags (no use to create face settings for just this field)
+	int numedges;						//number of edges in the boundary of the face
+	int firstedge;						//first edge in the edge index
+	int frontarea;						//area at the front of this face
+	int backarea;						//area at the back of this face
+} aas_face_t;
+
+//face index, stores a negative index if backside of face
+typedef int aas_faceindex_t;
+
+//area with a boundary of faces
+typedef struct aas_area_s
+{
+	int areanum;						//number of this area
+	//3d definition
+	int numfaces;						//number of faces used for the boundary of the area
+	int firstface;						//first face in the face index used for the boundary of the area
+	vec3_t mins;						//mins of the area
+	vec3_t maxs;						//maxs of the area
+	vec3_t center;						//'center' of the area
+} aas_area_t;
+
+//nodes of the bsp tree
+typedef struct aas_node_s
+{
+	int planenum;
+	int children[2];					//child nodes of this node, or areas as leaves when negative
+										//when a child is zero it's a solid leaf
+} aas_node_t;
+
+//=========== aas file ===============
+
+//header lump
+typedef struct
+{
+	int fileofs;
+	int filelen;
+} aas_lump_t;
+
+//aas file header
+typedef struct aas_header_s
+{
+	int ident;
+	int version;
+	int bspchecksum;
+	//data entries
+	aas_lump_t lumps[AAS_LUMPS];
+} aas_header_t;
+
+
+//====== additional information ======
+/*
+
+-	when a node child is a solid leaf the node child number is zero
+-	two adjacent areas (sharing a plane at opposite sides) share a face
+	this face is a portal between the areas
+-	when an area uses a face from the faceindex with a positive index
+	then the face plane normal points into the area
+-	the face edges are stored counter clockwise using the edgeindex
+-	two adjacent convex areas (sharing a face) only share One face
+	this is a simple result of the areas being convex
+-	the areas can't have a mixture of ground and gap faces
+	other mixtures of faces in one area are allowed
+-	areas with the AREACONTENTS_CLUSTERPORTAL in the settings have
+	the cluster number set to the negative portal number
+-	edge zero is a dummy
+-	face zero is a dummy
+-	area zero is a dummy
+-	node zero is a dummy
+*/
diff --git a/codemp/botlib/be_aas_bsp.h b/codemp/botlib/be_aas_bsp.h
new file mode 100644
index 0000000..dcc767d
--- /dev/null
+++ b/codemp/botlib/be_aas_bsp.h
@@ -0,0 +1,72 @@
+
+/*****************************************************************************
+ * name:		be_aas_bsp.h
+ *
+ * desc:		AAS
+ *
+ * $Archive: /source/code/botlib/be_aas_bsp.h $
+ * $Author: Mrelusive $ 
+ * $Revision: 2 $
+ * $Modtime: 10/05/99 3:32p $
+ * $Date: 10/05/99 3:42p $
+ *
+ *****************************************************************************/
+
+#ifdef AASINTERN
+//loads the given BSP file
+int AAS_LoadBSPFile(void);
+//dump the loaded BSP data
+void AAS_DumpBSPData(void);
+//unlink the given entity from the bsp tree leaves
+void AAS_UnlinkFromBSPLeaves(bsp_link_t *leaves);
+//link the given entity to the bsp tree leaves of the given model
+bsp_link_t *AAS_BSPLinkEntity(vec3_t absmins,
+										vec3_t absmaxs,
+										int entnum,
+										int modelnum);
+
+//calculates collision with given entity
+qboolean AAS_EntityCollision(int entnum,
+										vec3_t start,
+										vec3_t boxmins,
+										vec3_t boxmaxs,
+										vec3_t end,
+										int contentmask,
+										bsp_trace_t *trace);
+//for debugging
+void AAS_PrintFreeBSPLinks(char *str);
+//
+#endif //AASINTERN
+
+#define MAX_EPAIRKEY		128
+
+//trace through the world
+bsp_trace_t AAS_Trace(	vec3_t start,
+								vec3_t mins,
+								vec3_t maxs,
+								vec3_t end,
+								int passent,
+								int contentmask);
+//returns the contents at the given point
+int AAS_PointContents(vec3_t point);
+//returns true when p2 is in the PVS of p1
+qboolean AAS_inPVS(vec3_t p1, vec3_t p2);
+//returns true when p2 is in the PHS of p1
+qboolean AAS_inPHS(vec3_t p1, vec3_t p2);
+//returns true if the given areas are connected
+qboolean AAS_AreasConnected(int area1, int area2);
+//creates a list with entities totally or partly within the given box
+int AAS_BoxEntities(vec3_t absmins, vec3_t absmaxs, int *list, int maxcount);
+//gets the mins, maxs and origin of a BSP model
+void AAS_BSPModelMinsMaxsOrigin(int modelnum, vec3_t angles, vec3_t mins, vec3_t maxs, vec3_t origin);
+//handle to the next bsp entity
+int AAS_NextBSPEntity(int ent);
+//return the value of the BSP epair key
+int AAS_ValueForBSPEpairKey(int ent, char *key, char *value, int size);
+//get a vector for the BSP epair key
+int AAS_VectorForBSPEpairKey(int ent, char *key, vec3_t v);
+//get a float for the BSP epair key
+int AAS_FloatForBSPEpairKey(int ent, char *key, float *value);
+//get an integer for the BSP epair key
+int AAS_IntForBSPEpairKey(int ent, char *key, int *value);
+
diff --git a/codemp/botlib/be_aas_bspq3.cpp b/codemp/botlib/be_aas_bspq3.cpp
new file mode 100644
index 0000000..cadc12a
--- /dev/null
+++ b/codemp/botlib/be_aas_bspq3.cpp
@@ -0,0 +1,470 @@
+
+/*****************************************************************************
+ * name:		be_aas_bspq3.c
+ *
+ * desc:		BSP, Environment Sampling
+ *
+ * $Archive: /MissionPack/code/botlib/be_aas_bspq3.c $
+ * $Author: Ttimo $ 
+ * $Revision: 5 $
+ * $Modtime: 4/22/01 8:52a $
+ * $Date: 4/22/01 8:52a $
+ *
+ *****************************************************************************/
+
+#include "../game/q_shared.h"
+#include "l_memory.h"
+#include "l_script.h"
+#include "l_precomp.h"
+#include "l_struct.h"
+#include "aasfile.h"
+#include "../game/botlib.h"
+#include "../game/be_aas.h"
+#include "be_aas_funcs.h"
+#include "be_aas_def.h"
+
+extern botlib_import_t botimport;
+
+//#define TRACE_DEBUG
+
+#define ON_EPSILON		0.005
+//#define DEG2RAD( a ) (( a * M_PI ) / 180.0F)
+
+#define MAX_BSPENTITIES		2048
+
+typedef struct rgb_s
+{
+	int red;
+	int green;
+	int blue;
+} rgb_t;
+
+//bsp entity epair
+typedef struct bsp_epair_s
+{
+	char *key;
+	char *value;
+	struct bsp_epair_s *next;
+} bsp_epair_t;
+
+//bsp data entity
+typedef struct bsp_entity_s
+{
+	bsp_epair_t *epairs;
+} bsp_entity_t;
+
+//id Sofware BSP data
+typedef struct bsp_s
+{
+	//true when bsp file is loaded
+	int loaded;
+	//entity data
+	int entdatasize;
+	char *dentdata;
+	//bsp entities
+	int numentities;
+	bsp_entity_t entities[MAX_BSPENTITIES];
+} bsp_t;
+
+//global bsp
+bsp_t bspworld;
+
+
+#ifdef BSP_DEBUG
+typedef struct cname_s
+{
+	int value;
+	char *name;
+} cname_t;
+
+cname_t contentnames[] =
+{
+	{CONTENTS_SOLID,"CONTENTS_SOLID"},
+	{CONTENTS_WINDOW,"CONTENTS_WINDOW"},
+	{CONTENTS_AUX,"CONTENTS_AUX"},
+	{CONTENTS_LAVA,"CONTENTS_LAVA"},
+	{CONTENTS_SLIME,"CONTENTS_SLIME"},
+	{CONTENTS_WATER,"CONTENTS_WATER"},
+	{CONTENTS_MIST,"CONTENTS_MIST"},
+	{LAST_VISIBLE_CONTENTS,"LAST_VISIBLE_CONTENTS"},
+
+	{CONTENTS_AREAPORTAL,"CONTENTS_AREAPORTAL"},
+	{CONTENTS_PLAYERCLIP,"CONTENTS_PLAYERCLIP"},
+	{CONTENTS_MONSTERCLIP,"CONTENTS_MONSTERCLIP"},
+	{CONTENTS_CURRENT_0,"CONTENTS_CURRENT_0"},
+	{CONTENTS_CURRENT_90,"CONTENTS_CURRENT_90"},
+	{CONTENTS_CURRENT_180,"CONTENTS_CURRENT_180"},
+	{CONTENTS_CURRENT_270,"CONTENTS_CURRENT_270"},
+	{CONTENTS_CURRENT_UP,"CONTENTS_CURRENT_UP"},
+	{CONTENTS_CURRENT_DOWN,"CONTENTS_CURRENT_DOWN"},
+	{CONTENTS_ORIGIN,"CONTENTS_ORIGIN"},
+	{CONTENTS_MONSTER,"CONTENTS_MONSTER"},
+	{CONTENTS_DEADMONSTER,"CONTENTS_DEADMONSTER"},
+	{CONTENTS_DETAIL,"CONTENTS_DETAIL"},
+	{CONTENTS_TRANSLUCENT,"CONTENTS_TRANSLUCENT"},
+	{CONTENTS_LADDER,"CONTENTS_LADDER"},
+	{0, 0}
+};
+
+void PrintContents(int contents)
+{
+	int i;
+
+	for (i = 0; contentnames[i].value; i++)
+	{
+		if (contents & contentnames[i].value)
+		{
+			botimport.Print(PRT_MESSAGE, "%s\n", contentnames[i].name);
+		} //end if
+	} //end for
+} //end of the function PrintContents
+
+#endif // BSP_DEBUG
+//===========================================================================
+// traces axial boxes of any size through the world
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+bsp_trace_t AAS_Trace(vec3_t start, vec3_t mins, vec3_t maxs, vec3_t end, int passent, int contentmask)
+{
+	bsp_trace_t bsptrace;
+	botimport.Trace(&bsptrace, start, mins, maxs, end, passent, contentmask);
+	return bsptrace;
+} //end of the function AAS_Trace
+//===========================================================================
+// returns the contents at the given point
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int AAS_PointContents(vec3_t point)
+{
+	return botimport.PointContents(point);
+} //end of the function AAS_PointContents
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+qboolean AAS_EntityCollision(int entnum,
+					vec3_t start, vec3_t boxmins, vec3_t boxmaxs, vec3_t end,
+								int contentmask, bsp_trace_t *trace)
+{
+	bsp_trace_t enttrace;
+
+	botimport.EntityTrace(&enttrace, start, boxmins, boxmaxs, end, entnum, contentmask);
+	if (enttrace.fraction < trace->fraction)
+	{
+		Com_Memcpy(trace, &enttrace, sizeof(bsp_trace_t));
+		return qtrue;
+	} //end if
+	return qfalse;
+} //end of the function AAS_EntityCollision
+//===========================================================================
+// returns true if in Potentially Hearable Set
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+qboolean AAS_inPVS(vec3_t p1, vec3_t p2)
+{
+	return (qboolean)botimport.inPVS(p1, p2);
+} //end of the function AAS_InPVS
+//===========================================================================
+// returns true if in Potentially Visible Set
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+qboolean AAS_inPHS(vec3_t p1, vec3_t p2)
+{
+	return qtrue;
+} //end of the function AAS_inPHS
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void AAS_BSPModelMinsMaxsOrigin(int modelnum, vec3_t angles, vec3_t mins, vec3_t maxs, vec3_t origin)
+{
+	botimport.BSPModelMinsMaxsOrigin(modelnum, angles, mins, maxs, origin);
+} //end of the function AAS_BSPModelMinsMaxs
+//===========================================================================
+// unlinks the entity from all leaves
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void AAS_UnlinkFromBSPLeaves(bsp_link_t *leaves)
+{
+} //end of the function AAS_UnlinkFromBSPLeaves
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+bsp_link_t *AAS_BSPLinkEntity(vec3_t absmins, vec3_t absmaxs, int entnum, int modelnum)
+{
+	return NULL;
+} //end of the function AAS_BSPLinkEntity
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int AAS_BoxEntities(vec3_t absmins, vec3_t absmaxs, int *list, int maxcount)
+{
+	return 0;
+} //end of the function AAS_BoxEntities
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+int AAS_NextBSPEntity(int ent)
+{
+	ent++;
+	if (ent >= 1 && ent < bspworld.numentities) return ent;
+	return 0;
+} //end of the function AAS_NextBSPEntity
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+int AAS_BSPEntityInRange(int ent)
+{
+	if (ent <= 0 || ent >= bspworld.numentities)
+	{
+		botimport.Print(PRT_MESSAGE, "bsp entity out of range\n");
+		return qfalse;
+	} //end if
+	return qtrue;
+} //end of the function AAS_BSPEntityInRange
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+int AAS_ValueForBSPEpairKey(int ent, char *key, char *value, int size)
+{
+	bsp_epair_t *epair;
+
+	value[0] = '\0';
+	if (!AAS_BSPEntityInRange(ent)) return qfalse;
+	for (epair = bspworld.entities[ent].epairs; epair; epair = epair->next)
+	{
+		if (!strcmp(epair->key, key))
+		{
+			strncpy(value, epair->value, size-1);
+			value[size-1] = '\0';
+			return qtrue;
+		} //end if
+	} //end for
+	return qfalse;
+} //end of the function AAS_FindBSPEpair
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int AAS_VectorForBSPEpairKey(int ent, char *key, vec3_t v)
+{
+	char buf[MAX_EPAIRKEY];
+	double v1, v2, v3;
+
+	VectorClear(v);
+	if (!AAS_ValueForBSPEpairKey(ent, key, buf, MAX_EPAIRKEY)) return qfalse;
+	//scanf into doubles, then assign, so it is vec_t size independent
+	v1 = v2 = v3 = 0;
+	sscanf(buf, "%lf %lf %lf", &v1, &v2, &v3);
+	v[0] = v1;
+	v[1] = v2;
+	v[2] = v3;
+	return qtrue;
+} //end of the function AAS_VectorForBSPEpairKey
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int AAS_FloatForBSPEpairKey(int ent, char *key, float *value)
+{
+	char buf[MAX_EPAIRKEY];
+	
+	*value = 0;
+	if (!AAS_ValueForBSPEpairKey(ent, key, buf, MAX_EPAIRKEY)) return qfalse;
+	*value = atof(buf);
+	return qtrue;
+} //end of the function AAS_FloatForBSPEpairKey
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int AAS_IntForBSPEpairKey(int ent, char *key, int *value)
+{
+	char buf[MAX_EPAIRKEY];
+	
+	*value = 0;
+	if (!AAS_ValueForBSPEpairKey(ent, key, buf, MAX_EPAIRKEY)) return qfalse;
+	*value = atoi(buf);
+	return qtrue;
+} //end of the function AAS_IntForBSPEpairKey
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+void AAS_FreeBSPEntities(void)
+{
+	int i;
+	bsp_entity_t *ent;
+	bsp_epair_t *epair, *nextepair;
+
+	for (i = 1; i < bspworld.numentities; i++)
+	{
+		ent = &bspworld.entities[i];
+		for (epair = ent->epairs; epair; epair = nextepair)
+		{
+			nextepair = epair->next;
+			//
+			if (epair->key) FreeMemory(epair->key);
+			if (epair->value) FreeMemory(epair->value);
+			FreeMemory(epair);
+		} //end for
+	} //end for
+	bspworld.numentities = 0;
+} //end of the function AAS_FreeBSPEntities
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+void AAS_ParseBSPEntities(void)
+{
+	script_t *script;
+	token_t token;
+	bsp_entity_t *ent;
+	bsp_epair_t *epair;
+
+	script = LoadScriptMemory(bspworld.dentdata, bspworld.entdatasize, "entdata");
+	SetScriptFlags(script, SCFL_NOSTRINGWHITESPACES|SCFL_NOSTRINGESCAPECHARS);//SCFL_PRIMITIVE);
+
+	bspworld.numentities = 1;
+
+	while(PS_ReadToken(script, &token))
+	{
+		if (strcmp(token.string, "{"))
+		{
+			ScriptError(script, "invalid %s\n", token.string);
+			AAS_FreeBSPEntities();
+			FreeScript(script);
+			return;
+		} //end if
+		if (bspworld.numentities >= MAX_BSPENTITIES)
+		{
+			botimport.Print(PRT_MESSAGE, "too many entities in BSP file\n");
+			break;
+		} //end if
+		ent = &bspworld.entities[bspworld.numentities];
+		bspworld.numentities++;
+		ent->epairs = NULL;
+		while(PS_ReadToken(script, &token))
+		{
+			if (!strcmp(token.string, "}")) break;
+			epair = (bsp_epair_t *) GetClearedHunkMemory(sizeof(bsp_epair_t));
+			epair->next = ent->epairs;
+			ent->epairs = epair;
+			if (token.type != TT_STRING)
+			{
+				ScriptError(script, "invalid %s\n", token.string);
+				AAS_FreeBSPEntities();
+				FreeScript(script);
+				return;
+			} //end if
+			StripDoubleQuotes(token.string);
+			epair->key = (char *) GetHunkMemory(strlen(token.string) + 1);
+			strcpy(epair->key, token.string);
+			if (!PS_ExpectTokenType(script, TT_STRING, 0, &token))
+			{
+				AAS_FreeBSPEntities();
+				FreeScript(script);
+				return;
+			} //end if
+			StripDoubleQuotes(token.string);
+			epair->value = (char *) GetHunkMemory(strlen(token.string) + 1);
+			strcpy(epair->value, token.string);
+		} //end while
+		if (strcmp(token.string, "}"))
+		{
+			ScriptError(script, "missing }\n");
+			AAS_FreeBSPEntities();
+			FreeScript(script);
+			return;
+		} //end if
+	} //end while
+	FreeScript(script);
+} //end of the function AAS_ParseBSPEntities
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int AAS_BSPTraceLight(vec3_t start, vec3_t end, vec3_t endpos, int *red, int *green, int *blue)
+{
+	return 0;
+} //end of the function AAS_BSPTraceLight
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void AAS_DumpBSPData(void)
+{
+	AAS_FreeBSPEntities();
+
+	if (bspworld.dentdata) FreeMemory(bspworld.dentdata);
+	bspworld.dentdata = NULL;
+	bspworld.entdatasize = 0;
+	//
+	bspworld.loaded = qfalse;
+	Com_Memset( &bspworld, 0, sizeof(bspworld) );
+} //end of the function AAS_DumpBSPData
+//===========================================================================
+// load an bsp file
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int AAS_LoadBSPFile(void)
+{
+	AAS_DumpBSPData();
+	bspworld.entdatasize = strlen(botimport.BSPEntityData()) + 1;
+	bspworld.dentdata = (char *) GetClearedHunkMemory(bspworld.entdatasize);
+	Com_Memcpy(bspworld.dentdata, botimport.BSPEntityData(), bspworld.entdatasize);
+	AAS_ParseBSPEntities();
+	bspworld.loaded = qtrue;
+	return BLERR_NOERROR;
+} //end of the function AAS_LoadBSPFile
diff --git a/codemp/botlib/be_aas_cluster.cpp b/codemp/botlib/be_aas_cluster.cpp
new file mode 100644
index 0000000..4e18a0c
--- /dev/null
+++ b/codemp/botlib/be_aas_cluster.cpp
@@ -0,0 +1,1528 @@
+
+/*****************************************************************************
+ * name:		be_aas_cluster.c
+ *
+ * desc:		area clustering
+ *
+ * $Archive: /MissionPack/code/botlib/be_aas_cluster.c $
+ * $Author: Ttimo $ 
+ * $Revision: 10 $
+ * $Modtime: 4/21/01 9:15a $
+ * $Date: 4/21/01 9:15a $
+ *
+ *****************************************************************************/
+
+#include "../game/q_shared.h"
+#include "l_memory.h"
+#include "l_script.h"
+#include "l_precomp.h"
+#include "l_struct.h"
+#include "l_log.h"
+#include "l_memory.h"
+#include "l_libvar.h"
+#include "aasfile.h"
+#include "../game/botlib.h"
+#include "../game/be_aas.h"
+#include "be_aas_funcs.h"
+#include "be_aas_def.h"
+
+extern botlib_import_t botimport;
+
+#define AAS_MAX_PORTALS					65536
+#define AAS_MAX_PORTALINDEXSIZE			65536
+#define AAS_MAX_CLUSTERS				65536
+//
+#define MAX_PORTALAREAS			1024
+
+// do not flood through area faces, only use reachabilities
+int nofaceflood = qtrue;
+
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void AAS_RemoveClusterAreas(void)
+{
+	int i;
+
+	for (i = 1; i < aasworld.numareas; i++)
+	{
+		aasworld.areasettings[i].cluster = 0;
+	} //end for
+} //end of the function AAS_RemoveClusterAreas
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void AAS_ClearCluster(int clusternum)
+{
+	int i;
+
+	for (i = 1; i < aasworld.numareas; i++)
+	{
+		if (aasworld.areasettings[i].cluster == clusternum)
+		{
+			aasworld.areasettings[i].cluster = 0;
+		} //end if
+	} //end for
+} //end of the function AAS_ClearCluster
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void AAS_RemovePortalsClusterReference(int clusternum)
+{
+	int portalnum;
+
+	for (portalnum = 1; portalnum < aasworld.numportals; portalnum++)
+	{
+		if (aasworld.portals[portalnum].frontcluster == clusternum)
+		{
+			aasworld.portals[portalnum].frontcluster = 0;
+		} //end if
+		if (aasworld.portals[portalnum].backcluster == clusternum)
+		{
+			aasworld.portals[portalnum].backcluster = 0;
+		} //end if
+	} //end for
+} //end of the function AAS_RemovePortalsClusterReference
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int AAS_UpdatePortal(int areanum, int clusternum)
+{
+	int portalnum;
+	aas_portal_t *portal;
+	aas_cluster_t *cluster;
+
+	//find the portal of the area
+	for (portalnum = 1; portalnum < aasworld.numportals; portalnum++)
+	{
+		if (aasworld.portals[portalnum].areanum == areanum) break;
+	} //end for
+	//
+	if (portalnum == aasworld.numportals)
+	{
+		AAS_Error("no portal of area %d", areanum);
+		return qtrue;
+	} //end if
+	//
+	portal = &aasworld.portals[portalnum];
+	//if the portal is already fully updated
+	if (portal->frontcluster == clusternum) return qtrue;
+	if (portal->backcluster == clusternum) return qtrue;
+	//if the portal has no front cluster yet
+	if (!portal->frontcluster)
+	{
+		portal->frontcluster = clusternum;
+	} //end if
+	//if the portal has no back cluster yet
+	else if (!portal->backcluster)
+	{
+		portal->backcluster = clusternum;
+	} //end else if
+	else
+	{
+		//remove the cluster portal flag contents
+		aasworld.areasettings[areanum].contents &= ~AREACONTENTS_CLUSTERPORTAL;
+		Log_Write("portal area %d is seperating more than two clusters\r\n", areanum);
+		return qfalse;
+	} //end else
+	if (aasworld.portalindexsize >= AAS_MAX_PORTALINDEXSIZE)
+	{
+		AAS_Error("AAS_MAX_PORTALINDEXSIZE");
+		return qtrue;
+	} //end if
+	//set the area cluster number to the negative portal number
+	aasworld.areasettings[areanum].cluster = -portalnum;
+	//add the portal to the cluster using the portal index
+	cluster = &aasworld.clusters[clusternum];
+	aasworld.portalindex[cluster->firstportal + cluster->numportals] = portalnum;
+	aasworld.portalindexsize++;
+	cluster->numportals++;
+	return qtrue;
+} //end of the function AAS_UpdatePortal
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int AAS_FloodClusterAreas_r(int areanum, int clusternum)
+{
+	aas_area_t *area;
+	aas_face_t *face;
+	int facenum, i;
+
+	//
+	if (areanum <= 0 || areanum >= aasworld.numareas)
+	{
+		AAS_Error("AAS_FloodClusterAreas_r: areanum out of range");
+		return qfalse;
+	} //end if
+	//if the area is already part of a cluster
+	if (aasworld.areasettings[areanum].cluster > 0)
+	{
+		if (aasworld.areasettings[areanum].cluster == clusternum) return qtrue;
+		//
+		//there's a reachability going from one cluster to another only in one direction
+		//
+		AAS_Error("cluster %d touched cluster %d at area %d\r\n",
+				clusternum, aasworld.areasettings[areanum].cluster, areanum);
+		return qfalse;
+	} //end if
+	//don't add the cluster portal areas to the clusters
+	if (aasworld.areasettings[areanum].contents & AREACONTENTS_CLUSTERPORTAL)
+	{
+		return AAS_UpdatePortal(areanum, clusternum);
+	} //end if
+	//set the area cluster number
+	aasworld.areasettings[areanum].cluster = clusternum;
+	aasworld.areasettings[areanum].clusterareanum =
+				aasworld.clusters[clusternum].numareas;
+	//the cluster has an extra area
+	aasworld.clusters[clusternum].numareas++;
+
+	area = &aasworld.areas[areanum];
+	//use area faces to flood into adjacent areas
+	if (!nofaceflood)
+	{
+		for (i = 0; i < area->numfaces; i++)
+		{
+			facenum = abs(aasworld.faceindex[area->firstface + i]);
+			face = &aasworld.faces[facenum];
+			if (face->frontarea == areanum)
+			{
+				if (face->backarea) if (!AAS_FloodClusterAreas_r(face->backarea, clusternum)) return qfalse;
+			} //end if
+			else
+			{
+				if (face->frontarea) if (!AAS_FloodClusterAreas_r(face->frontarea, clusternum)) return qfalse;
+			} //end else
+		} //end for
+	} //end if
+	//use the reachabilities to flood into other areas
+	for (i = 0; i < aasworld.areasettings[areanum].numreachableareas; i++)
+	{
+		if (!aasworld.reachability[
+					aasworld.areasettings[areanum].firstreachablearea + i].areanum)
+		{
+			continue;
+		} //end if
+		if (!AAS_FloodClusterAreas_r(aasworld.reachability[
+				aasworld.areasettings[areanum].firstreachablearea + i].areanum, clusternum)) return qfalse;
+	} //end for
+	return qtrue;
+} //end of the function AAS_FloodClusterAreas_r
+//===========================================================================
+// try to flood from all areas without cluster into areas with a cluster set
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int AAS_FloodClusterAreasUsingReachabilities(int clusternum)
+{
+	int i, j, areanum;
+
+	for (i = 1; i < aasworld.numareas; i++)
+	{
+		//if this area already has a cluster set
+		if (aasworld.areasettings[i].cluster)
+			continue;
+		//if this area is a cluster portal
+		if (aasworld.areasettings[i].contents & AREACONTENTS_CLUSTERPORTAL)
+			continue;
+		//loop over the reachable areas from this area
+		for (j = 0; j < aasworld.areasettings[i].numreachableareas; j++)
+		{
+			//the reachable area
+			areanum = aasworld.reachability[aasworld.areasettings[i].firstreachablearea + j].areanum;
+			//if this area is a cluster portal
+			if (aasworld.areasettings[areanum].contents & AREACONTENTS_CLUSTERPORTAL)
+				continue;
+			//if this area has a cluster set
+			if (aasworld.areasettings[areanum].cluster)
+			{
+				if (!AAS_FloodClusterAreas_r(i, clusternum))
+					return qfalse;
+				i = 0;
+				break;
+			} //end if
+		} //end for
+	} //end for
+	return qtrue;
+} //end of the function AAS_FloodClusterAreasUsingReachabilities
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+void AAS_NumberClusterPortals(int clusternum)
+{
+	int i, portalnum;
+	aas_cluster_t *cluster;
+	aas_portal_t *portal;
+
+	cluster = &aasworld.clusters[clusternum];
+	for (i = 0; i < cluster->numportals; i++)
+	{
+		portalnum = aasworld.portalindex[cluster->firstportal + i];
+		portal = &aasworld.portals[portalnum];
+		if (portal->frontcluster == clusternum)
+		{
+			portal->clusterareanum[0] = cluster->numareas++;
+		} //end if
+		else
+		{
+			portal->clusterareanum[1] = cluster->numareas++;
+		} //end else
+	} //end for
+} //end of the function AAS_NumberClusterPortals
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+void AAS_NumberClusterAreas(int clusternum)
+{
+	int i, portalnum;
+	aas_cluster_t *cluster;
+	aas_portal_t *portal;
+
+	aasworld.clusters[clusternum].numareas = 0;
+	aasworld.clusters[clusternum].numreachabilityareas = 0;
+	//number all areas in this cluster WITH reachabilities
+	for (i = 1; i < aasworld.numareas; i++)
+	{
+		//
+		if (aasworld.areasettings[i].cluster != clusternum) continue;
+		//
+		if (!AAS_AreaReachability(i)) continue;
+		//
+		aasworld.areasettings[i].clusterareanum = aasworld.clusters[clusternum].numareas;
+		//the cluster has an extra area
+		aasworld.clusters[clusternum].numareas++;
+		aasworld.clusters[clusternum].numreachabilityareas++;
+	} //end for
+	//number all portals in this cluster WITH reachabilities
+	cluster = &aasworld.clusters[clusternum];
+	for (i = 0; i < cluster->numportals; i++)
+	{
+		portalnum = aasworld.portalindex[cluster->firstportal + i];
+		portal = &aasworld.portals[portalnum];
+		if (!AAS_AreaReachability(portal->areanum)) continue;
+		if (portal->frontcluster == clusternum)
+		{
+			portal->clusterareanum[0] = cluster->numareas++;
+			aasworld.clusters[clusternum].numreachabilityareas++;
+		} //end if
+		else
+		{
+			portal->clusterareanum[1] = cluster->numareas++;
+			aasworld.clusters[clusternum].numreachabilityareas++;
+		} //end else
+	} //end for
+	//number all areas in this cluster WITHOUT reachabilities
+	for (i = 1; i < aasworld.numareas; i++)
+	{
+		//
+		if (aasworld.areasettings[i].cluster != clusternum) continue;
+		//
+		if (AAS_AreaReachability(i)) continue;
+		//
+		aasworld.areasettings[i].clusterareanum = aasworld.clusters[clusternum].numareas;
+		//the cluster has an extra area
+		aasworld.clusters[clusternum].numareas++;
+	} //end for
+	//number all portals in this cluster WITHOUT reachabilities
+	cluster = &aasworld.clusters[clusternum];
+	for (i = 0; i < cluster->numportals; i++)
+	{
+		portalnum = aasworld.portalindex[cluster->firstportal + i];
+		portal = &aasworld.portals[portalnum];
+		if (AAS_AreaReachability(portal->areanum)) continue;
+		if (portal->frontcluster == clusternum)
+		{
+			portal->clusterareanum[0] = cluster->numareas++;
+		} //end if
+		else
+		{
+			portal->clusterareanum[1] = cluster->numareas++;
+		} //end else
+	} //end for
+} //end of the function AAS_NumberClusterAreas
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+int AAS_FindClusters(void)
+{
+	int i;
+	aas_cluster_t *cluster;
+
+	AAS_RemoveClusterAreas();
+	//
+	for (i = 1; i < aasworld.numareas; i++)
+	{
+		//if the area is already part of a cluster
+		if (aasworld.areasettings[i].cluster)
+			continue;
+		// if not flooding through faces only use areas that have reachabilities
+		if (nofaceflood)
+		{
+			if (!aasworld.areasettings[i].numreachableareas)
+				continue;
+		} //end if
+		//if the area is a cluster portal
+		if (aasworld.areasettings[i].contents & AREACONTENTS_CLUSTERPORTAL)
+			continue;
+		if (aasworld.numclusters >= AAS_MAX_CLUSTERS)
+		{
+			AAS_Error("AAS_MAX_CLUSTERS");
+			return qfalse;
+		} //end if
+		cluster = &aasworld.clusters[aasworld.numclusters];
+		cluster->numareas = 0;
+		cluster->numreachabilityareas = 0;
+		cluster->firstportal = aasworld.portalindexsize;
+		cluster->numportals = 0;
+		//flood the areas in this cluster
+		if (!AAS_FloodClusterAreas_r(i, aasworld.numclusters))
+			return qfalse;
+		if (!AAS_FloodClusterAreasUsingReachabilities(aasworld.numclusters))
+			return qfalse;
+		//number the cluster areas
+		//AAS_NumberClusterPortals(aasworld.numclusters);
+		AAS_NumberClusterAreas(aasworld.numclusters);
+		//Log_Write("cluster %d has %d areas\r\n", aasworld.numclusters, cluster->numareas);
+		aasworld.numclusters++;
+	} //end for
+	return qtrue;
+} //end of the function AAS_FindClusters
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void AAS_CreatePortals(void)
+{
+	int i;
+	aas_portal_t *portal;
+
+	for (i = 1; i < aasworld.numareas; i++)
+	{
+		//if the area is a cluster portal
+		if (aasworld.areasettings[i].contents & AREACONTENTS_CLUSTERPORTAL)
+		{
+			if (aasworld.numportals >= AAS_MAX_PORTALS)
+			{
+				AAS_Error("AAS_MAX_PORTALS");
+				return;
+			} //end if
+			portal = &aasworld.portals[aasworld.numportals];
+			portal->areanum = i;
+			portal->frontcluster = 0;
+			portal->backcluster = 0;
+			aasworld.numportals++;
+		} //end if
+	} //end for
+} //end of the function AAS_CreatePortals
+/*
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int AAS_MapContainsTeleporters(void)
+{
+	bsp_entity_t *entities, *ent;
+	char *classname;
+
+	entities = AAS_ParseBSPEntities();
+
+	for (ent = entities; ent; ent = ent->next)
+	{
+		classname = AAS_ValueForBSPEpairKey(ent, "classname");
+		if (classname && !strcmp(classname, "misc_teleporter"))
+		{
+			AAS_FreeBSPEntities(entities);
+			return qtrue;
+		} //end if
+	} //end for
+	return qfalse;
+} //end of the function AAS_MapContainsTeleporters
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int AAS_NonConvexFaces(aas_face_t *face1, aas_face_t *face2, int side1, int side2)
+{
+	int i, j, edgenum;
+	aas_plane_t *plane1, *plane2;
+	aas_edge_t *edge;
+	
+
+	plane1 = &aasworld.planes[face1->planenum ^ side1];
+	plane2 = &aasworld.planes[face2->planenum ^ side2];
+
+	//check if one of the points of face1 is at the back of the plane of face2
+	for (i = 0; i < face1->numedges; i++)
+	{
+		edgenum = abs(aasworld.edgeindex[face1->firstedge + i]);
+		edge = &aasworld.edges[edgenum];
+		for (j = 0; j < 2; j++)
+		{
+			if (DotProduct(plane2->normal, aasworld.vertexes[edge->v[j]]) -
+							plane2->dist < -0.01) return qtrue;
+		} //end for
+	} //end for
+	for (i = 0; i < face2->numedges; i++)
+	{
+		edgenum = abs(aasworld.edgeindex[face2->firstedge + i]);
+		edge = &aasworld.edges[edgenum];
+		for (j = 0; j < 2; j++)
+		{
+			if (DotProduct(plane1->normal, aasworld.vertexes[edge->v[j]]) -
+							plane1->dist < -0.01) return qtrue;
+		} //end for
+	} //end for
+
+	return qfalse;
+} //end of the function AAS_NonConvexFaces
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+qboolean AAS_CanMergeAreas(int *areanums, int numareas)
+{
+	int i, j, s, face1num, face2num, side1, side2, fn1, fn2;
+	aas_face_t *face1, *face2;
+	aas_area_t *area1, *area2;
+
+	for (i = 0; i < numareas; i++)
+	{
+		area1 = &aasworld.areas[areanums[i]];
+		for (fn1 = 0; fn1 < area1->numfaces; fn1++)
+		{
+			face1num = abs(aasworld.faceindex[area1->firstface + fn1]);
+			face1 = &aasworld.faces[face1num];
+			side1 = face1->frontarea != areanums[i];
+			//check if the face isn't a shared one with one of the other areas
+			for (s = 0; s < numareas; s++)
+			{
+				if (s == i) continue;
+				if (face1->frontarea == s || face1->backarea == s) break;
+			} //end for
+			//if the face was a shared one
+			if (s != numareas) continue;
+			//
+			for (j = 0; j < numareas; j++)
+			{
+				if (j == i) continue;
+				area2 = &aasworld.areas[areanums[j]];
+				for (fn2 = 0; fn2 < area2->numfaces; fn2++)
+				{
+					face2num = abs(aasworld.faceindex[area2->firstface + fn2]);
+					face2 = &aasworld.faces[face2num];
+					side2 = face2->frontarea != areanums[j];
+					//check if the face isn't a shared one with one of the other areas
+					for (s = 0; s < numareas; s++)
+					{
+						if (s == j) continue;
+						if (face2->frontarea == s || face2->backarea == s) break;
+					} //end for
+					//if the face was a shared one
+					if (s != numareas) continue;
+					//
+					if (AAS_NonConvexFaces(face1, face2, side1, side2)) return qfalse;
+				} //end for
+			} //end for
+		} //end for
+	} //end for
+	return qtrue;
+} //end of the function AAS_CanMergeAreas
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+qboolean AAS_NonConvexEdges(aas_edge_t *edge1, aas_edge_t *edge2, int side1, int side2, int planenum)
+{
+	int i;
+	vec3_t edgevec1, edgevec2, normal1, normal2;
+	float dist1, dist2;
+	aas_plane_t *plane;
+
+	plane = &aasworld.planes[planenum];
+	VectorSubtract(aasworld.vertexes[edge1->v[1]], aasworld.vertexes[edge1->v[0]], edgevec1);
+	VectorSubtract(aasworld.vertexes[edge2->v[1]], aasworld.vertexes[edge2->v[0]], edgevec2);
+	if (side1) VectorInverse(edgevec1);
+	if (side2) VectorInverse(edgevec2);
+	//
+	CrossProduct(edgevec1, plane->normal, normal1);
+	dist1 = DotProduct(normal1, aasworld.vertexes[edge1->v[0]]);
+	CrossProduct(edgevec2, plane->normal, normal2);
+	dist2 = DotProduct(normal2, aasworld.vertexes[edge2->v[0]]);
+
+	for (i = 0; i < 2; i++)
+	{
+		if (DotProduct(aasworld.vertexes[edge1->v[i]], normal2) - dist2 < -0.01) return qfalse;
+	} //end for
+	for (i = 0; i < 2; i++)
+	{
+		if (DotProduct(aasworld.vertexes[edge2->v[i]], normal1) - dist1 < -0.01) return qfalse;
+	} //end for
+	return qtrue;
+} //end of the function AAS_NonConvexEdges
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+qboolean AAS_CanMergeFaces(int *facenums, int numfaces, int planenum)
+{
+	int i, j, s, edgenum1, edgenum2, side1, side2, en1, en2, ens;
+	aas_face_t *face1, *face2, *otherface;
+	aas_edge_t *edge1, *edge2;
+
+	for (i = 0; i < numfaces; i++)
+	{
+		face1 = &aasworld.faces[facenums[i]];
+		for (en1 = 0; en1 < face1->numedges; en1++)
+		{
+			edgenum1 = aasworld.edgeindex[face1->firstedge + en1];
+			side1 = (edgenum1 < 0) ^ (face1->planenum != planenum);
+			edgenum1 = abs(edgenum1);
+			edge1 = &aasworld.edges[edgenum1];
+			//check if the edge is shared with another face
+			for (s = 0; s < numfaces; s++)
+			{
+				if (s == i) continue;
+				otherface = &aasworld.faces[facenums[s]];
+				for (ens = 0; ens < otherface->numedges; ens++)
+				{
+					if (edgenum1 == abs(aasworld.edgeindex[otherface->firstedge + ens])) break;
+				} //end for
+				if (ens != otherface->numedges) break;
+			} //end for
+			//if the edge was shared
+			if (s != numfaces) continue;
+			//
+			for (j = 0; j < numfaces; j++)
+			{
+				if (j == i) continue;
+				face2 = &aasworld.faces[facenums[j]];
+				for (en2 = 0; en2 < face2->numedges; en2++)
+				{
+					edgenum2 = aasworld.edgeindex[face2->firstedge + en2];
+					side2 = (edgenum2 < 0) ^ (face2->planenum != planenum);
+					edgenum2 = abs(edgenum2);
+					edge2 = &aasworld.edges[edgenum2];
+					//check if the edge is shared with another face
+					for (s = 0; s < numfaces; s++)
+					{
+						if (s == i) continue;
+						otherface = &aasworld.faces[facenums[s]];
+						for (ens = 0; ens < otherface->numedges; ens++)
+						{
+							if (edgenum2 == abs(aasworld.edgeindex[otherface->firstedge + ens])) break;
+						} //end for
+						if (ens != otherface->numedges) break;
+					} //end for
+					//if the edge was shared
+					if (s != numfaces) continue;
+					//
+					if (AAS_NonConvexEdges(edge1, edge2, side1, side2, planenum)) return qfalse;
+				} //end for
+			} //end for
+		} //end for
+	} //end for
+	return qtrue;
+} //end of the function AAS_CanMergeFaces*/
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void AAS_ConnectedAreas_r(int *areanums, int numareas, int *connectedareas, int curarea)
+{
+	int i, j, otherareanum, facenum;
+	aas_area_t *area;
+	aas_face_t *face;
+
+	connectedareas[curarea] = qtrue;
+	area = &aasworld.areas[areanums[curarea]];
+	for (i = 0; i < area->numfaces; i++)
+	{
+		facenum = abs(aasworld.faceindex[area->firstface + i]);
+		face = &aasworld.faces[facenum];
+		//if the face is solid
+		if (face->faceflags & FACE_SOLID) continue;
+		//get the area at the other side of the face
+		if (face->frontarea != areanums[curarea]) otherareanum = face->frontarea;
+		else otherareanum = face->backarea;
+		//check if the face is leading to one of the other areas
+		for (j = 0; j < numareas; j++)
+		{
+			if (areanums[j] == otherareanum) break;
+		} //end for
+		//if the face isn't leading to one of the other areas
+		if (j == numareas) continue;
+		//if the other area is already connected
+		if (connectedareas[j]) continue;
+		//recursively proceed with the other area
+		AAS_ConnectedAreas_r(areanums, numareas, connectedareas, j);
+	} //end for
+} //end of the function AAS_ConnectedAreas_r
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+qboolean AAS_ConnectedAreas(int *areanums, int numareas)
+{
+	int connectedareas[MAX_PORTALAREAS], i;
+
+	Com_Memset(connectedareas, 0, sizeof(connectedareas));
+	if (numareas < 1) return qfalse;
+	if (numareas == 1) return qtrue;
+	AAS_ConnectedAreas_r(areanums, numareas, connectedareas, 0);
+	for (i = 0; i < numareas; i++)
+	{
+		if (!connectedareas[i]) return qfalse;
+	} //end for
+	return qtrue;
+} //end of the function AAS_ConnectedAreas
+//===========================================================================
+// gets adjacent areas with less presence types recursively
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int AAS_GetAdjacentAreasWithLessPresenceTypes_r(int *areanums, int numareas, int curareanum)
+{
+	int i, j, presencetype, otherpresencetype, otherareanum, facenum;
+	aas_area_t *area;
+	aas_face_t *face;
+
+	areanums[numareas++] = curareanum;
+	area = &aasworld.areas[curareanum];
+	presencetype = aasworld.areasettings[curareanum].presencetype;
+	for (i = 0; i < area->numfaces; i++)
+	{
+		facenum = abs(aasworld.faceindex[area->firstface + i]);
+		face = &aasworld.faces[facenum];
+		//if the face is solid
+		if (face->faceflags & FACE_SOLID) continue;
+		//the area at the other side of the face
+		if (face->frontarea != curareanum) otherareanum = face->frontarea;
+		else otherareanum = face->backarea;
+		//
+		otherpresencetype = aasworld.areasettings[otherareanum].presencetype;
+		//if the other area has less presence types
+		if ((presencetype & ~otherpresencetype) &&
+				!(otherpresencetype & ~presencetype))
+		{
+			//check if the other area isn't already in the list
+			for (j = 0; j < numareas; j++)
+			{
+				if (otherareanum == areanums[j]) break;
+			} //end for
+			//if the other area isn't already in the list
+			if (j == numareas)
+			{
+				if (numareas >= MAX_PORTALAREAS)
+				{
+					AAS_Error("MAX_PORTALAREAS");
+					return numareas;
+				} //end if
+				numareas = AAS_GetAdjacentAreasWithLessPresenceTypes_r(areanums, numareas, otherareanum);
+			} //end if
+		} //end if
+	} //end for
+	return numareas;
+} //end of the function AAS_GetAdjacentAreasWithLessPresenceTypes_r
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int AAS_CheckAreaForPossiblePortals(int areanum)
+{
+	int i, j, k, fen, ben, frontedgenum, backedgenum, facenum;
+	int areanums[MAX_PORTALAREAS], numareas, otherareanum;
+	int numareafrontfaces[MAX_PORTALAREAS], numareabackfaces[MAX_PORTALAREAS];
+	int frontfacenums[MAX_PORTALAREAS], backfacenums[MAX_PORTALAREAS];
+	int numfrontfaces, numbackfaces;
+	int frontareanums[MAX_PORTALAREAS], backareanums[MAX_PORTALAREAS];
+	int numfrontareas, numbackareas;
+	int frontplanenum, backplanenum, faceplanenum;
+	aas_area_t *area;
+	aas_face_t *frontface, *backface, *face;
+
+	//if it isn't already a portal
+	if (aasworld.areasettings[areanum].contents & AREACONTENTS_CLUSTERPORTAL) return 0;
+	//it must be a grounded area
+	if (!(aasworld.areasettings[areanum].areaflags & AREA_GROUNDED)) return 0;
+	//
+	Com_Memset(numareafrontfaces, 0, sizeof(numareafrontfaces));
+	Com_Memset(numareabackfaces, 0, sizeof(numareabackfaces));
+	numareas = numfrontfaces = numbackfaces = 0;
+	numfrontareas = numbackareas = 0;
+	frontplanenum = backplanenum = -1;
+	//add any adjacent areas with less presence types
+	numareas = AAS_GetAdjacentAreasWithLessPresenceTypes_r(areanums, 0, areanum);
+	//
+	for (i = 0; i < numareas; i++)
+	{
+		area = &aasworld.areas[areanums[i]];
+		for (j = 0; j < area->numfaces; j++)
+		{
+			facenum = abs(aasworld.faceindex[area->firstface + j]);
+			face = &aasworld.faces[facenum];
+			//if the face is solid
+			if (face->faceflags & FACE_SOLID) continue;
+			//check if the face is shared with one of the other areas
+			for (k = 0; k < numareas; k++)
+			{
+				if (k == i) continue;
+				if (face->frontarea == areanums[k] || face->backarea == areanums[k]) break;
+			} //end for
+			//if the face is shared
+			if (k != numareas) continue;
+			//the number of the area at the other side of the face
+			if (face->frontarea == areanums[i]) otherareanum = face->backarea;
+			else otherareanum = face->frontarea;
+			//if the other area already is a cluter portal
+			if (aasworld.areasettings[otherareanum].contents & AREACONTENTS_CLUSTERPORTAL) return 0;
+			//number of the plane of the area
+			faceplanenum = face->planenum & ~1;
+			//
+			if (frontplanenum < 0 || faceplanenum == frontplanenum)
+			{
+				frontplanenum = faceplanenum;
+				frontfacenums[numfrontfaces++] = facenum;
+				for (k = 0; k < numfrontareas; k++)
+				{
+					if (frontareanums[k] == otherareanum) break;
+				} //end for
+				if (k == numfrontareas) frontareanums[numfrontareas++] = otherareanum;
+				numareafrontfaces[i]++;
+			} //end if
+			else if (backplanenum < 0 || faceplanenum == backplanenum)
+			{
+				backplanenum = faceplanenum;
+				backfacenums[numbackfaces++] = facenum;
+				for (k = 0; k < numbackareas; k++)
+				{
+					if (backareanums[k] == otherareanum) break;
+				} //end for
+				if (k == numbackareas) backareanums[numbackareas++] = otherareanum;
+				numareabackfaces[i]++;
+			} //end else
+			else
+			{
+				return 0;
+			} //end else
+		} //end for
+	} //end for
+	//every area should have at least one front face and one back face
+	for (i = 0; i < numareas; i++)
+	{
+		if (!numareafrontfaces[i] || !numareabackfaces[i]) return 0;
+	} //end for
+	//the front areas should all be connected
+	if (!AAS_ConnectedAreas(frontareanums, numfrontareas)) return 0;
+	//the back areas should all be connected
+	if (!AAS_ConnectedAreas(backareanums, numbackareas)) return 0;
+	//none of the front faces should have a shared edge with a back face
+	for (i = 0; i < numfrontfaces; i++)
+	{
+		frontface = &aasworld.faces[frontfacenums[i]];
+		for (fen = 0; fen < frontface->numedges; fen++)
+		{
+			frontedgenum = abs(aasworld.edgeindex[frontface->firstedge + fen]);
+			for (j = 0; j < numbackfaces; j++)
+			{
+				backface = &aasworld.faces[backfacenums[j]];
+				for (ben = 0; ben < backface->numedges; ben++)
+				{
+					backedgenum = abs(aasworld.edgeindex[backface->firstedge + ben]);
+					if (frontedgenum == backedgenum) break;
+				} //end for
+				if (ben != backface->numedges) break;
+			} //end for
+			if (j != numbackfaces) break;
+		} //end for
+		if (fen != frontface->numedges) break;
+	} //end for
+	if (i != numfrontfaces) return 0;
+	//set the cluster portal contents
+	for (i = 0; i < numareas; i++)
+	{
+		aasworld.areasettings[areanums[i]].contents |= AREACONTENTS_CLUSTERPORTAL;
+		//this area can be used as a route portal
+		aasworld.areasettings[areanums[i]].contents |= AREACONTENTS_ROUTEPORTAL;
+		Log_Write("possible portal: %d\r\n", areanums[i]);
+	} //end for
+	//
+	return numareas;
+} //end of the function AAS_CheckAreaForPossiblePortals
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void AAS_FindPossiblePortals(void)
+{
+	int i, numpossibleportals;
+
+	numpossibleportals = 0;
+	for (i = 1; i < aasworld.numareas; i++)
+	{
+		numpossibleportals += AAS_CheckAreaForPossiblePortals(i);
+	} //end for
+	botimport.Print(PRT_MESSAGE, "\r%6d possible portal areas\n", numpossibleportals);
+} //end of the function AAS_FindPossiblePortals
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void AAS_RemoveAllPortals(void)
+{
+	int i;
+
+	for (i = 1; i < aasworld.numareas; i++)
+	{
+		aasworld.areasettings[i].contents &= ~AREACONTENTS_CLUSTERPORTAL;
+	} //end for
+} //end of the function AAS_RemoveAllPortals
+
+#if 0
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void AAS_FloodCluster_r(int areanum, int clusternum)
+{
+	int i, otherareanum;
+	aas_face_t *face;
+	aas_area_t *area;
+
+	//set cluster mark
+	aasworld.areasettings[areanum].cluster = clusternum;
+	//if the area is a portal
+	//if (aasworld.areasettings[areanum].contents & AREACONTENTS_CLUSTERPORTAL) return;
+	//
+	area = &aasworld.areas[areanum];
+	//use area faces to flood into adjacent areas
+	for (i = 0; i < area->numfaces; i++)
+	{
+		face = &aasworld.faces[abs(aasworld.faceindex[area->firstface + i])];
+		//
+		if (face->frontarea != areanum) otherareanum = face->frontarea;
+		else otherareanum = face->backarea;
+		//if there's no area at the other side
+		if (!otherareanum) continue;
+		//if the area is a portal
+		if (aasworld.areasettings[otherareanum].contents & AREACONTENTS_CLUSTERPORTAL) continue;
+		//if the area is already marked
+		if (aasworld.areasettings[otherareanum].cluster) continue;
+		//
+		AAS_FloodCluster_r(otherareanum, clusternum);
+	} //end for
+	//use the reachabilities to flood into other areas
+	for (i = 0; i < aasworld.areasettings[areanum].numreachableareas; i++)
+	{
+		otherareanum = aasworld.reachability[
+					aasworld.areasettings[areanum].firstreachablearea + i].areanum;
+		if (!otherareanum)
+		{
+			continue;
+			AAS_Error("reachability %d has zero area\n", aasworld.areasettings[areanum].firstreachablearea + i);
+		} //end if
+		//if the area is a portal
+		if (aasworld.areasettings[otherareanum].contents & AREACONTENTS_CLUSTERPORTAL) continue;
+		//if the area is already marked
+		if (aasworld.areasettings[otherareanum].cluster) continue;
+		//
+		AAS_FloodCluster_r(otherareanum, clusternum);
+	} //end for
+} //end of the function AAS_FloodCluster_r
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void AAS_RemoveTeleporterPortals(void)
+{
+	int i, j, areanum;
+
+	for (i = 1; i < aasworld.numareas; i++)
+	{
+		for (j = 0; j < aasworld.areasettings[i].numreachableareas; j++)
+		{
+			areanum = aasworld.reachability[aasworld.areasettings[i].firstreachablearea + j].areanum;
+			if (aasworld.reachability[aasworld.areasettings[i].firstreachablearea + j].traveltype == TRAVEL_TELEPORT)
+			{
+				aasworld.areasettings[i].contents &= ~AREACONTENTS_CLUSTERPORTAL;
+				aasworld.areasettings[areanum].contents &= ~AREACONTENTS_CLUSTERPORTAL;
+				break;
+			} //end if
+		} //end for
+	} //end for
+} //end of the function AAS_RemoveTeleporterPortals
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void AAS_FloodClusterReachabilities(int clusternum)
+{
+	int i, j, areanum;
+
+	for (i = 1; i < aasworld.numareas; i++)
+	{
+		//if this area already has a cluster set
+		if (aasworld.areasettings[i].cluster) continue;
+		//if this area is a cluster portal
+		if (aasworld.areasettings[i].contents & AREACONTENTS_CLUSTERPORTAL) continue;
+		//loop over the reachable areas from this area
+		for (j = 0; j < aasworld.areasettings[i].numreachableareas; j++)
+		{
+			//the reachable area
+			areanum = aasworld.reachability[aasworld.areasettings[i].firstreachablearea + j].areanum;
+			//if this area is a cluster portal
+			if (aasworld.areasettings[areanum].contents & AREACONTENTS_CLUSTERPORTAL) continue;
+			//if this area has a cluster set
+			if (aasworld.areasettings[areanum].cluster == clusternum)
+			{
+				AAS_FloodCluster_r(i, clusternum);
+				i = 0;
+				break;
+			} //end if
+		} //end for
+	} //end for
+} //end of the function AAS_FloodClusterReachabilities
+
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void AAS_RemoveNotClusterClosingPortals(void)
+{
+	int i, j, k, facenum, otherareanum, nonclosingportals;
+	aas_area_t *area;
+	aas_face_t *face;
+
+	AAS_RemoveTeleporterPortals();
+	//
+	nonclosingportals = 0;
+	for (i = 1; i < aasworld.numareas; i++)
+	{
+		if (!(aasworld.areasettings[i].contents & AREACONTENTS_CLUSTERPORTAL)) continue;
+		//find a non-portal area adjacent to the portal area and flood
+		//the cluster from there
+		area = &aasworld.areas[i];
+		for (j = 0; j < area->numfaces; j++)
+		{
+			facenum = abs(aasworld.faceindex[area->firstface + j]);
+			face = &aasworld.faces[facenum];
+			//
+			if (face->frontarea != i) otherareanum = face->frontarea;
+			else otherareanum = face->backarea;
+			//
+			if (!otherareanum) continue;
+			//
+			if (aasworld.areasettings[otherareanum].contents & AREACONTENTS_CLUSTERPORTAL)
+			{
+				continue;
+			} //end if
+			//reset all cluster fields
+			AAS_RemoveClusterAreas();
+			//
+			AAS_FloodCluster_r(otherareanum, 1);
+			AAS_FloodClusterReachabilities(1);
+			//check if all adjacent non-portal areas have a cluster set
+			for (k = 0; k < area->numfaces; k++)
+			{
+				facenum = abs(aasworld.faceindex[area->firstface + k]);
+				face = &aasworld.faces[facenum];
+				//
+				if (face->frontarea != i) otherareanum = face->frontarea;
+				else otherareanum = face->backarea;
+				//
+				if (!otherareanum) continue;
+				//
+				if (aasworld.areasettings[otherareanum].contents & AREACONTENTS_CLUSTERPORTAL)
+				{
+					continue;
+				} //end if
+				//
+				if (!aasworld.areasettings[otherareanum].cluster) break;
+			} //end for
+			//if all adjacent non-portal areas have a cluster set then the portal
+			//didn't seal a cluster
+			if (k >= area->numfaces)
+			{
+				aasworld.areasettings[i].contents &= ~AREACONTENTS_CLUSTERPORTAL;
+				nonclosingportals++;
+				//recheck all the other portals again
+				i = 0;
+				break;
+			} //end if
+		} //end for
+	} //end for
+	botimport.Print(PRT_MESSAGE, "\r%6d non closing portals removed\n", nonclosingportals);
+} //end of the function AAS_RemoveNotClusterClosingPortals
+
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+
+void AAS_RemoveNotClusterClosingPortals(void)
+{
+	int i, j, facenum, otherareanum, nonclosingportals, numseperatedclusters;
+	aas_area_t *area;
+	aas_face_t *face;
+
+	AAS_RemoveTeleporterPortals();
+	//
+	nonclosingportals = 0;
+	for (i = 1; i < aasworld.numareas; i++)
+	{
+		if (!(aasworld.areasettings[i].contents & AREACONTENTS_CLUSTERPORTAL)) continue;
+		//
+		numseperatedclusters = 0;
+		//reset all cluster fields
+		AAS_RemoveClusterAreas();
+		//find a non-portal area adjacent to the portal area and flood
+		//the cluster from there
+		area = &aasworld.areas[i];
+		for (j = 0; j < area->numfaces; j++)
+		{
+			facenum = abs(aasworld.faceindex[area->firstface + j]);
+			face = &aasworld.faces[facenum];
+			//
+			if (face->frontarea != i) otherareanum = face->frontarea;
+			else otherareanum = face->backarea;
+			//if not solid at the other side of the face
+			if (!otherareanum) continue;
+			//don't flood into other portals
+			if (aasworld.areasettings[otherareanum].contents & AREACONTENTS_CLUSTERPORTAL) continue;
+			//if the area already has a cluster set
+			if (aasworld.areasettings[otherareanum].cluster) continue;
+			//another cluster is seperated by this portal
+			numseperatedclusters++;
+			//flood the cluster
+			AAS_FloodCluster_r(otherareanum, numseperatedclusters);
+			AAS_FloodClusterReachabilities(numseperatedclusters);
+		} //end for
+		//use the reachabilities to flood into other areas
+		for (j = 0; j < aasworld.areasettings[i].numreachableareas; j++)
+		{
+			otherareanum = aasworld.reachability[
+						aasworld.areasettings[i].firstreachablearea + j].areanum;
+			//this should never be qtrue but we check anyway
+			if (!otherareanum) continue;
+			//don't flood into other portals
+			if (aasworld.areasettings[otherareanum].contents & AREACONTENTS_CLUSTERPORTAL) continue;
+			//if the area already has a cluster set
+			if (aasworld.areasettings[otherareanum].cluster) continue;
+			//another cluster is seperated by this portal
+			numseperatedclusters++;
+			//flood the cluster
+			AAS_FloodCluster_r(otherareanum, numseperatedclusters);
+			AAS_FloodClusterReachabilities(numseperatedclusters);
+		} //end for
+		//a portal must seperate no more and no less than 2 clusters
+		if (numseperatedclusters != 2)
+		{
+			aasworld.areasettings[i].contents &= ~AREACONTENTS_CLUSTERPORTAL;
+			nonclosingportals++;
+			//recheck all the other portals again
+			i = 0;
+		} //end if
+	} //end for
+	botimport.Print(PRT_MESSAGE, "\r%6d non closing portals removed\n", nonclosingportals);
+} //end of the function AAS_RemoveNotClusterClosingPortals
+
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+
+void AAS_AddTeleporterPortals(void)
+{
+	int j, area2num, facenum, otherareanum;
+	char *target, *targetname, *classname;
+	bsp_entity_t *entities, *ent, *dest;
+	vec3_t origin, destorigin, mins, maxs, end;
+	vec3_t bbmins, bbmaxs;
+	aas_area_t *area;
+	aas_face_t *face;
+	aas_trace_t trace;
+	aas_link_t *areas, *link;
+
+	entities = AAS_ParseBSPEntities();
+
+	for (ent = entities; ent; ent = ent->next)
+	{
+		classname = AAS_ValueForBSPEpairKey(ent, "classname");
+		if (classname && !strcmp(classname, "misc_teleporter"))
+		{
+			if (!AAS_VectorForBSPEpairKey(ent, "origin", origin))
+			{
+				botimport.Print(PRT_ERROR, "teleporter (%s) without origin\n", target);
+				continue;
+			} //end if
+			//
+			target = AAS_ValueForBSPEpairKey(ent, "target");
+			if (!target)
+			{
+				botimport.Print(PRT_ERROR, "teleporter (%s) without target\n", target);
+				continue;
+			} //end if
+			for (dest = entities; dest; dest = dest->next)
+			{
+				classname = AAS_ValueForBSPEpairKey(dest, "classname");
+				if (classname && !strcmp(classname, "misc_teleporter_dest"))
+				{
+					targetname = AAS_ValueForBSPEpairKey(dest, "targetname");
+					if (targetname && !strcmp(targetname, target))
+					{
+						break;
+					} //end if
+				} //end if
+			} //end for
+			if (!dest)
+			{
+				botimport.Print(PRT_ERROR, "teleporter without destination (%s)\n", target);
+				continue;
+			} //end if
+			if (!AAS_VectorForBSPEpairKey(dest, "origin", destorigin))
+			{
+				botimport.Print(PRT_ERROR, "teleporter destination (%s) without origin\n", target);
+				continue;
+			} //end if
+			destorigin[2] += 24; //just for q2e1m2, the dork has put the telepads in the ground
+			VectorCopy(destorigin, end);
+			end[2] -= 100;
+			trace = AAS_TraceClientBBox(destorigin, end, PRESENCE_CROUCH, -1);
+			if (trace.startsolid)
+			{
+				botimport.Print(PRT_ERROR, "teleporter destination (%s) in solid\n", target);
+				continue;
+			} //end if
+			VectorCopy(trace.endpos, destorigin);
+			area2num = AAS_PointAreaNum(destorigin);
+			//reset all cluster fields
+			for (j = 0; j < aasworld.numareas; j++)
+			{
+				aasworld.areasettings[j].cluster = 0;
+			} //end for
+			//
+			VectorSet(mins, -8, -8, 8);
+			VectorSet(maxs, 8, 8, 24);
+			//
+			AAS_PresenceTypeBoundingBox(PRESENCE_CROUCH, bbmins, bbmaxs);
+			//
+			VectorAdd(origin, mins, mins);
+			VectorAdd(origin, maxs, maxs);
+			//add bounding box size
+			VectorSubtract(mins, bbmaxs, mins);
+			VectorSubtract(maxs, bbmins, maxs);
+			//link an invalid (-1) entity
+			areas = AAS_AASLinkEntity(mins, maxs, -1);
+			//
+			for (link = areas; link; link = link->next_area)
+			{
+				if (!AAS_AreaGrounded(link->areanum)) continue;
+				//add the teleporter portal mark
+				aasworld.areasettings[link->areanum].contents |= AREACONTENTS_CLUSTERPORTAL |
+																			AREACONTENTS_TELEPORTAL;
+			} //end for
+			//
+			for (link = areas; link; link = link->next_area)
+			{
+				if (!AAS_AreaGrounded(link->areanum)) continue;
+				//find a non-portal area adjacent to the portal area and flood
+				//the cluster from there
+				area = &aasworld.areas[link->areanum];
+				for (j = 0; j < area->numfaces; j++)
+				{
+					facenum = abs(aasworld.faceindex[area->firstface + j]);
+					face = &aasworld.faces[facenum];
+					//
+					if (face->frontarea != link->areanum) otherareanum = face->frontarea;
+					else otherareanum = face->backarea;
+					//
+					if (!otherareanum) continue;
+					//
+					if (aasworld.areasettings[otherareanum].contents & AREACONTENTS_CLUSTERPORTAL)
+					{
+						continue;
+					} //end if
+					//
+					AAS_FloodCluster_r(otherareanum, 1);
+				} //end for
+			} //end for
+			//if the teleport destination IS in the same cluster
+			if (aasworld.areasettings[area2num].cluster)
+			{
+				for (link = areas; link; link = link->next_area)
+				{
+					if (!AAS_AreaGrounded(link->areanum)) continue;
+					//add the teleporter portal mark
+					aasworld.areasettings[link->areanum].contents &= ~(AREACONTENTS_CLUSTERPORTAL |
+																				AREACONTENTS_TELEPORTAL);
+				} //end for
+			} //end if
+		} //end if
+	} //end for
+	AAS_FreeBSPEntities(entities);
+} //end of the function AAS_AddTeleporterPortals
+
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void AAS_AddTeleporterPortals(void)
+{
+	int i, j, areanum;
+
+	for (i = 1; i < aasworld.numareas; i++)
+	{
+		for (j = 0; j < aasworld.areasettings[i].numreachableareas; j++)
+		{
+			if (aasworld.reachability[aasworld.areasettings[i].firstreachablearea + j].traveltype != TRAVEL_TELEPORT) continue;
+			areanum = aasworld.reachability[aasworld.areasettings[i].firstreachablearea + j].areanum;
+			aasworld.areasettings[areanum].contents |= AREACONTENTS_CLUSTERPORTAL;
+		} //end for
+	} //end for
+} //end of the function AAS_AddTeleporterPortals
+
+#endif
+
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int AAS_TestPortals(void)
+{
+	int i;
+	aas_portal_t *portal;
+
+	for (i = 1; i < aasworld.numportals; i++)
+	{
+		portal = &aasworld.portals[i];
+		if (!portal->frontcluster)
+		{
+			aasworld.areasettings[portal->areanum].contents &= ~AREACONTENTS_CLUSTERPORTAL;
+			Log_Write("portal area %d has no front cluster\r\n", portal->areanum);
+			return qfalse;
+		} //end if
+		if (!portal->backcluster)
+		{
+			aasworld.areasettings[portal->areanum].contents &= ~AREACONTENTS_CLUSTERPORTAL;
+			Log_Write("portal area %d has no back cluster\r\n", portal->areanum);
+			return qfalse;
+		} //end if
+	} //end for
+	return qtrue;
+} //end of the function
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void AAS_CountForcedClusterPortals(void)
+{
+	int num, i;
+
+	num = 0;
+	for (i = 1; i < aasworld.numareas; i++)
+	{
+		if (aasworld.areasettings[i].contents & AREACONTENTS_CLUSTERPORTAL)
+		{
+			Log_Write("area %d is a forced portal area\r\n", i);
+			num++;
+		} //end if
+	} //end for
+	botimport.Print(PRT_MESSAGE, "%6d forced portal areas\n", num);
+} //end of the function AAS_CountForcedClusterPortals
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+void AAS_CreateViewPortals(void)
+{
+	int i;
+
+	for (i = 1; i < aasworld.numareas; i++)
+	{
+		if (aasworld.areasettings[i].contents & AREACONTENTS_CLUSTERPORTAL)
+		{
+			aasworld.areasettings[i].contents |= AREACONTENTS_VIEWPORTAL;
+		} //end if
+	} //end for
+} //end of the function AAS_CreateViewPortals
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void AAS_SetViewPortalsAsClusterPortals(void)
+{
+	int i;
+
+	for (i = 1; i < aasworld.numareas; i++)
+	{
+		if (aasworld.areasettings[i].contents & AREACONTENTS_VIEWPORTAL)
+		{
+			aasworld.areasettings[i].contents |= AREACONTENTS_CLUSTERPORTAL;
+		} //end if
+	} //end for
+} //end of the function AAS_SetViewPortalsAsClusterPortals
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void AAS_InitClustering(void)
+{
+	int i, removedPortalAreas;
+	int n, total, numreachabilityareas;
+
+	if (!aasworld.loaded) return;
+	//if there are clusters
+	if (aasworld.numclusters >= 1)
+	{
+#ifndef BSPC
+		//if clustering isn't forced
+		if (!((int)LibVarGetValue("forceclustering")) &&
+			!((int)LibVarGetValue("forcereachability"))) return;
+#endif
+	} //end if
+	//set all view portals as cluster portals in case we re-calculate the reachabilities and clusters (with -reach)
+	AAS_SetViewPortalsAsClusterPortals();
+	//count the number of forced cluster portals
+	AAS_CountForcedClusterPortals();
+	//remove all area cluster marks
+	AAS_RemoveClusterAreas();
+	//find possible cluster portals
+	AAS_FindPossiblePortals();
+	//craete portals to for the bot view
+	AAS_CreateViewPortals();
+	//remove all portals that are not closing a cluster
+	//AAS_RemoveNotClusterClosingPortals();
+	//initialize portal memory
+	if (aasworld.portals) FreeMemory(aasworld.portals);
+	aasworld.portals = (aas_portal_t *) GetClearedMemory(AAS_MAX_PORTALS * sizeof(aas_portal_t));
+	//initialize portal index memory
+	if (aasworld.portalindex) FreeMemory(aasworld.portalindex);
+	aasworld.portalindex = (aas_portalindex_t *) GetClearedMemory(AAS_MAX_PORTALINDEXSIZE * sizeof(aas_portalindex_t));
+	//initialize cluster memory
+	if (aasworld.clusters) FreeMemory(aasworld.clusters);
+	aasworld.clusters = (aas_cluster_t *) GetClearedMemory(AAS_MAX_CLUSTERS * sizeof(aas_cluster_t));
+	//
+	removedPortalAreas = 0;
+	botimport.Print(PRT_MESSAGE, "\r%6d removed portal areas", removedPortalAreas);
+	while(1)
+	{
+		botimport.Print(PRT_MESSAGE, "\r%6d", removedPortalAreas);
+		//initialize the number of portals and clusters
+		aasworld.numportals = 1;		//portal 0 is a dummy
+		aasworld.portalindexsize = 0;
+		aasworld.numclusters = 1;		//cluster 0 is a dummy
+		//create the portals from the portal areas
+		AAS_CreatePortals();
+		//
+		removedPortalAreas++;
+		//find the clusters
+		if (!AAS_FindClusters())
+			continue;
+		//test the portals
+		if (!AAS_TestPortals())
+			continue;
+		//
+		break;
+	} //end while
+	botimport.Print(PRT_MESSAGE, "\n");
+	//the AAS file should be saved
+	aasworld.savefile = qtrue;
+	//write the portal areas to the log file
+	for (i = 1; i < aasworld.numportals; i++)
+	{
+		Log_Write("portal %d: area %d\r\n", i, aasworld.portals[i].areanum);
+	} //end for
+	// report cluster info
+	botimport.Print(PRT_MESSAGE, "%6d portals created\n", aasworld.numportals);
+	botimport.Print(PRT_MESSAGE, "%6d clusters created\n", aasworld.numclusters);
+	for (i = 1; i < aasworld.numclusters; i++)
+	{
+		botimport.Print(PRT_MESSAGE, "cluster %d has %d reachability areas\n", i,
+				aasworld.clusters[i].numreachabilityareas);
+	} //end for
+	// report AAS file efficiency
+	numreachabilityareas = 0;
+	total = 0;
+	for (i = 0; i < aasworld.numclusters; i++) {
+		n = aasworld.clusters[i].numreachabilityareas;
+		numreachabilityareas += n;
+		total += n * n;
+	}
+	total += numreachabilityareas * aasworld.numportals;
+	//
+	botimport.Print(PRT_MESSAGE, "%6i total reachability areas\n", numreachabilityareas);
+	botimport.Print(PRT_MESSAGE, "%6i AAS memory/CPU usage (the lower the better)\n", total * 3);
+} //end of the function AAS_InitClustering
diff --git a/codemp/botlib/be_aas_cluster.h b/codemp/botlib/be_aas_cluster.h
new file mode 100644
index 0000000..a83fd69
--- /dev/null
+++ b/codemp/botlib/be_aas_cluster.h
@@ -0,0 +1,21 @@
+
+/*****************************************************************************
+ * name:		be_aas_cluster.h
+ *
+ * desc:		AAS
+ *
+ * $Archive: /source/code/botlib/be_aas_cluster.h $
+ * $Author: Mrelusive $ 
+ * $Revision: 2 $
+ * $Modtime: 10/05/99 3:32p $
+ * $Date: 10/05/99 3:42p $
+ *
+ *****************************************************************************/
+
+#ifdef AASINTERN
+//initialize the AAS clustering
+void AAS_InitClustering(void);
+//
+void AAS_SetViewPortalsAsClusterPortals(void);
+#endif //AASINTERN
+
diff --git a/codemp/botlib/be_aas_debug.cpp b/codemp/botlib/be_aas_debug.cpp
new file mode 100644
index 0000000..0e8a75f
--- /dev/null
+++ b/codemp/botlib/be_aas_debug.cpp
@@ -0,0 +1,760 @@
+
+/*****************************************************************************
+ * name:		be_aas_debug.c
+ *
+ * desc:		AAS debug code
+ *
+ * $Archive: /MissionPack/code/botlib/be_aas_debug.c $
+ * $Author: Ttimo $ 
+ * $Revision: 8 $
+ * $Modtime: 4/22/01 8:52a $
+ * $Date: 4/22/01 8:52a $
+ *
+ *****************************************************************************/
+
+#include "../game/q_shared.h"
+#include "l_memory.h"
+#include "l_script.h"
+#include "l_precomp.h"
+#include "l_struct.h"
+#include "l_libvar.h"
+#include "aasfile.h"
+#include "../game/botlib.h"
+#include "../game/be_aas.h"
+#include "be_interface.h"
+#include "be_aas_funcs.h"
+#include "be_aas_def.h"
+
+#define MAX_DEBUGLINES				1024
+#define MAX_DEBUGPOLYGONS			8192
+
+int debuglines[MAX_DEBUGLINES];
+int debuglinevisible[MAX_DEBUGLINES];
+int numdebuglines;
+
+static int debugpolygons[MAX_DEBUGPOLYGONS];
+
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void AAS_ClearShownPolygons(void)
+{
+	int i;
+//*
+	for (i = 0; i < MAX_DEBUGPOLYGONS; i++)
+	{
+		if (debugpolygons[i]) botimport.DebugPolygonDelete(debugpolygons[i]);
+		debugpolygons[i] = 0;
+	} //end for
+//*/
+/*
+	for (i = 0; i < MAX_DEBUGPOLYGONS; i++)
+	{
+		botimport.DebugPolygonDelete(i);
+		debugpolygons[i] = 0;
+	} //end for
+*/
+} //end of the function AAS_ClearShownPolygons
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void AAS_ShowPolygon(int color, int numpoints, vec3_t *points)
+{
+	int i;
+
+	for (i = 0; i < MAX_DEBUGPOLYGONS; i++)
+	{
+		if (!debugpolygons[i])
+		{
+			debugpolygons[i] = botimport.DebugPolygonCreate(color, numpoints, points);
+			break;
+		} //end if
+	} //end for
+} //end of the function AAS_ShowPolygon
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void AAS_ClearShownDebugLines(void)
+{
+	int i;
+
+	//make all lines invisible
+	for (i = 0; i < MAX_DEBUGLINES; i++)
+	{
+		if (debuglines[i])
+		{
+			//botimport.DebugLineShow(debuglines[i], NULL, NULL, LINECOLOR_NONE);
+			botimport.DebugLineDelete(debuglines[i]);
+			debuglines[i] = 0;
+			debuglinevisible[i] = qfalse;
+		} //end if
+	} //end for
+} //end of the function AAS_ClearShownDebugLines
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void AAS_DebugLine(vec3_t start, vec3_t end, int color)
+{
+	int line;
+
+	for (line = 0; line < MAX_DEBUGLINES; line++)
+	{
+		if (!debuglines[line])
+		{
+			debuglines[line] = botimport.DebugLineCreate();
+			debuglinevisible[line] = qfalse;
+			numdebuglines++;
+		} //end if
+		if (!debuglinevisible[line])
+		{
+			botimport.DebugLineShow(debuglines[line], start, end, color);
+			debuglinevisible[line] = qtrue;
+			return;
+		} //end else
+	} //end for
+} //end of the function AAS_DebugLine
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+void AAS_PermanentLine(vec3_t start, vec3_t end, int color)
+{
+	int line;
+
+	line = botimport.DebugLineCreate();
+	botimport.DebugLineShow(line, start, end, color);
+} //end of the function AAS_PermenentLine
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+void AAS_DrawPermanentCross(vec3_t origin, float size, int color)
+{
+	int i, debugline;
+	vec3_t start, end;
+
+	for (i = 0; i < 3; i++)
+	{
+		VectorCopy(origin, start);
+		start[i] += size;
+		VectorCopy(origin, end);
+		end[i] -= size;
+		AAS_DebugLine(start, end, color);
+		debugline = botimport.DebugLineCreate();
+		botimport.DebugLineShow(debugline, start, end, color);
+	} //end for
+} //end of the function AAS_DrawPermanentCross
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void AAS_DrawPlaneCross(vec3_t point, vec3_t normal, float dist, int type, int color)
+{
+	int n0, n1, n2, j, line, lines[2];
+	vec3_t start1, end1, start2, end2;
+
+	//make a cross in the hit plane at the hit point
+	VectorCopy(point, start1);
+	VectorCopy(point, end1);
+	VectorCopy(point, start2);
+	VectorCopy(point, end2);
+
+	n0 = type % 3;
+	n1 = (type + 1) % 3;
+	n2 = (type + 2) % 3;
+	start1[n1] -= 6;
+	start1[n2] -= 6;
+	end1[n1] += 6;
+	end1[n2] += 6;
+	start2[n1] += 6;
+	start2[n2] -= 6;
+	end2[n1] -= 6;
+	end2[n2] += 6;
+
+	start1[n0] = (dist - (start1[n1] * normal[n1] +
+				start1[n2] * normal[n2])) / normal[n0];
+	end1[n0] = (dist - (end1[n1] * normal[n1] +
+				end1[n2] * normal[n2])) / normal[n0];
+	start2[n0] = (dist - (start2[n1] * normal[n1] +
+				start2[n2] * normal[n2])) / normal[n0];
+	end2[n0] = (dist - (end2[n1] * normal[n1] +
+				end2[n2] * normal[n2])) / normal[n0];
+
+	for (j = 0, line = 0; j < 2 && line < MAX_DEBUGLINES; line++)
+	{
+		if (!debuglines[line])
+		{
+			debuglines[line] = botimport.DebugLineCreate();
+			lines[j++] = debuglines[line];
+			debuglinevisible[line] = qtrue;
+			numdebuglines++;
+		} //end if
+		else if (!debuglinevisible[line])
+		{
+			lines[j++] = debuglines[line];
+			debuglinevisible[line] = qtrue;
+		} //end else
+	} //end for
+	botimport.DebugLineShow(lines[0], start1, end1, color);
+	botimport.DebugLineShow(lines[1], start2, end2, color);
+} //end of the function AAS_DrawPlaneCross
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void AAS_ShowBoundingBox(vec3_t origin, vec3_t mins, vec3_t maxs)
+{
+	vec3_t bboxcorners[8];
+	int lines[3];
+	int i, j, line;
+
+	//upper corners
+	bboxcorners[0][0] = origin[0] + maxs[0];
+	bboxcorners[0][1] = origin[1] + maxs[1];
+	bboxcorners[0][2] = origin[2] + maxs[2];
+	//
+	bboxcorners[1][0] = origin[0] + mins[0];
+	bboxcorners[1][1] = origin[1] + maxs[1];
+	bboxcorners[1][2] = origin[2] + maxs[2];
+	//
+	bboxcorners[2][0] = origin[0] + mins[0];
+	bboxcorners[2][1] = origin[1] + mins[1];
+	bboxcorners[2][2] = origin[2] + maxs[2];
+	//
+	bboxcorners[3][0] = origin[0] + maxs[0];
+	bboxcorners[3][1] = origin[1] + mins[1];
+	bboxcorners[3][2] = origin[2] + maxs[2];
+	//lower corners
+	Com_Memcpy(bboxcorners[4], bboxcorners[0], sizeof(vec3_t) * 4);
+	for (i = 0; i < 4; i++) bboxcorners[4 + i][2] = origin[2] + mins[2];
+	//draw bounding box
+	for (i = 0; i < 4; i++)
+	{
+		for (j = 0, line = 0; j < 3 && line < MAX_DEBUGLINES; line++)
+		{
+			if (!debuglines[line])
+			{
+				debuglines[line] = botimport.DebugLineCreate();
+				lines[j++] = debuglines[line];
+				debuglinevisible[line] = qtrue;
+				numdebuglines++;
+			} //end if
+			else if (!debuglinevisible[line])
+			{
+				lines[j++] = debuglines[line];
+				debuglinevisible[line] = qtrue;
+			} //end else
+		} //end for
+		//top plane
+		botimport.DebugLineShow(lines[0], bboxcorners[i],
+									bboxcorners[(i+1)&3], LINECOLOR_RED);
+		//bottom plane
+		botimport.DebugLineShow(lines[1], bboxcorners[4+i],
+									bboxcorners[4+((i+1)&3)], LINECOLOR_RED);
+		//vertical lines
+		botimport.DebugLineShow(lines[2], bboxcorners[i],
+									bboxcorners[4+i], LINECOLOR_RED);
+	} //end for
+} //end of the function AAS_ShowBoundingBox
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void AAS_ShowFace(int facenum)
+{
+	int i, color, edgenum;
+	aas_edge_t *edge;
+	aas_face_t *face;
+	aas_plane_t *plane;
+	vec3_t start, end;
+
+	color = LINECOLOR_YELLOW;
+	//check if face number is in range
+	if (facenum >= aasworld.numfaces)
+	{
+		botimport.Print(PRT_ERROR, "facenum %d out of range\n", facenum);
+	} //end if
+	face = &aasworld.faces[facenum];
+	//walk through the edges of the face
+	for (i = 0; i < face->numedges; i++)
+	{
+		//edge number
+		edgenum = abs(aasworld.edgeindex[face->firstedge + i]);
+		//check if edge number is in range
+		if (edgenum >= aasworld.numedges)
+		{
+			botimport.Print(PRT_ERROR, "edgenum %d out of range\n", edgenum);
+		} //end if
+		edge = &aasworld.edges[edgenum];
+		if (color == LINECOLOR_RED) color = LINECOLOR_GREEN;
+		else if (color == LINECOLOR_GREEN) color = LINECOLOR_BLUE;
+		else if (color == LINECOLOR_BLUE) color = LINECOLOR_YELLOW;
+		else color = LINECOLOR_RED;
+		AAS_DebugLine(aasworld.vertexes[edge->v[0]],
+										aasworld.vertexes[edge->v[1]],
+										color);
+	} //end for
+	plane = &aasworld.planes[face->planenum];
+	edgenum = abs(aasworld.edgeindex[face->firstedge]);
+	edge = &aasworld.edges[edgenum];
+	VectorCopy(aasworld.vertexes[edge->v[0]], start);
+	VectorMA(start, 20, plane->normal, end);
+	AAS_DebugLine(start, end, LINECOLOR_RED);
+} //end of the function AAS_ShowFace
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void AAS_ShowFacePolygon(int facenum, int color, int flip)
+{
+	int i, edgenum, numpoints;
+	vec3_t points[128];
+	aas_edge_t *edge;
+	aas_face_t *face;
+
+	//check if face number is in range
+	if (facenum >= aasworld.numfaces)
+	{
+		botimport.Print(PRT_ERROR, "facenum %d out of range\n", facenum);
+	} //end if
+	face = &aasworld.faces[facenum];
+	//walk through the edges of the face
+	numpoints = 0;
+	if (flip)
+	{
+		for (i = face->numedges-1; i >= 0; i--)
+		{
+			//edge number
+			edgenum = aasworld.edgeindex[face->firstedge + i];
+			edge = &aasworld.edges[abs(edgenum)];
+			VectorCopy(aasworld.vertexes[edge->v[edgenum < 0]], points[numpoints]);
+			numpoints++;
+		} //end for
+	} //end if
+	else
+	{
+		for (i = 0; i < face->numedges; i++)
+		{
+			//edge number
+			edgenum = aasworld.edgeindex[face->firstedge + i];
+			edge = &aasworld.edges[abs(edgenum)];
+			VectorCopy(aasworld.vertexes[edge->v[edgenum < 0]], points[numpoints]);
+			numpoints++;
+		} //end for
+	} //end else
+	AAS_ShowPolygon(color, numpoints, points);
+} //end of the function AAS_ShowFacePolygon
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void AAS_ShowArea(int areanum, int groundfacesonly)
+{
+	int areaedges[MAX_DEBUGLINES];
+	int numareaedges, i, j, n, color = 0, line;
+	int facenum, edgenum;
+	aas_area_t *area;
+	aas_face_t *face;
+	aas_edge_t *edge;
+
+	//
+	numareaedges = 0;
+	//
+	if (areanum < 0 || areanum >= aasworld.numareas)
+	{
+		botimport.Print(PRT_ERROR, "area %d out of range [0, %d]\n",
+								areanum, aasworld.numareas);
+		return;
+	} //end if
+	//pointer to the convex area
+	area = &aasworld.areas[areanum];
+	//walk through the faces of the area
+	for (i = 0; i < area->numfaces; i++)
+	{
+		facenum = abs(aasworld.faceindex[area->firstface + i]);
+		//check if face number is in range
+		if (facenum >= aasworld.numfaces)
+		{
+			botimport.Print(PRT_ERROR, "facenum %d out of range\n", facenum);
+		} //end if
+		face = &aasworld.faces[facenum];
+		//ground faces only
+		if (groundfacesonly)
+		{
+			if (!(face->faceflags & (FACE_GROUND | FACE_LADDER))) continue;
+		} //end if
+		//walk through the edges of the face
+		for (j = 0; j < face->numedges; j++)
+		{
+			//edge number
+			edgenum = abs(aasworld.edgeindex[face->firstedge + j]);
+			//check if edge number is in range
+			if (edgenum >= aasworld.numedges)
+			{
+				botimport.Print(PRT_ERROR, "edgenum %d out of range\n", edgenum);
+			} //end if
+			//check if the edge is stored already
+			for (n = 0; n < numareaedges; n++)
+			{
+				if (areaedges[n] == edgenum) break;
+			} //end for
+			if (n == numareaedges && numareaedges < MAX_DEBUGLINES)
+			{
+				areaedges[numareaedges++] = edgenum;
+			} //end if
+		} //end for
+		//AAS_ShowFace(facenum);
+	} //end for
+	//draw all the edges
+	for (n = 0; n < numareaedges; n++)
+	{
+		for (line = 0; line < MAX_DEBUGLINES; line++)
+		{
+			if (!debuglines[line])
+			{
+				debuglines[line] = botimport.DebugLineCreate();
+				debuglinevisible[line] = qfalse;
+				numdebuglines++;
+			} //end if
+			if (!debuglinevisible[line])
+			{
+				break;
+			} //end else
+		} //end for
+		if (line >= MAX_DEBUGLINES) return;
+		edge = &aasworld.edges[areaedges[n]];
+		if (color == LINECOLOR_RED) color = LINECOLOR_BLUE;
+		else if (color == LINECOLOR_BLUE) color = LINECOLOR_GREEN;
+		else if (color == LINECOLOR_GREEN) color = LINECOLOR_YELLOW;
+		else color = LINECOLOR_RED;
+		botimport.DebugLineShow(debuglines[line],
+									aasworld.vertexes[edge->v[0]],
+									aasworld.vertexes[edge->v[1]],
+									color);
+		debuglinevisible[line] = qtrue;
+	} //end for*/
+} //end of the function AAS_ShowArea
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void AAS_ShowAreaPolygons(int areanum, int color, int groundfacesonly)
+{
+	int i, facenum;
+	aas_area_t *area;
+	aas_face_t *face;
+
+	//
+	if (areanum < 0 || areanum >= aasworld.numareas)
+	{
+		botimport.Print(PRT_ERROR, "area %d out of range [0, %d]\n",
+								areanum, aasworld.numareas);
+		return;
+	} //end if
+	//pointer to the convex area
+	area = &aasworld.areas[areanum];
+	//walk through the faces of the area
+	for (i = 0; i < area->numfaces; i++)
+	{
+		facenum = abs(aasworld.faceindex[area->firstface + i]);
+		//check if face number is in range
+		if (facenum >= aasworld.numfaces)
+		{
+			botimport.Print(PRT_ERROR, "facenum %d out of range\n", facenum);
+		} //end if
+		face = &aasworld.faces[facenum];
+		//ground faces only
+		if (groundfacesonly)
+		{
+			if (!(face->faceflags & (FACE_GROUND | FACE_LADDER))) continue;
+		} //end if
+		AAS_ShowFacePolygon(facenum, color, face->frontarea != areanum);
+	} //end for
+} //end of the function AAS_ShowAreaPolygons
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void AAS_DrawCross(vec3_t origin, float size, int color)
+{
+	int i;
+	vec3_t start, end;
+
+	for (i = 0; i < 3; i++)
+	{
+		VectorCopy(origin, start);
+		start[i] += size;
+		VectorCopy(origin, end);
+		end[i] -= size;
+		AAS_DebugLine(start, end, color);
+	} //end for
+} //end of the function AAS_DrawCross
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void AAS_PrintTravelType(int traveltype)
+{
+#ifdef DEBUG
+	char *str;
+	//
+	switch(traveltype & TRAVELTYPE_MASK)
+	{
+		case TRAVEL_INVALID: str = "TRAVEL_INVALID"; break;
+		case TRAVEL_WALK: str = "TRAVEL_WALK"; break;
+		case TRAVEL_CROUCH: str = "TRAVEL_CROUCH"; break;
+		case TRAVEL_BARRIERJUMP: str = "TRAVEL_BARRIERJUMP"; break;
+		case TRAVEL_JUMP: str = "TRAVEL_JUMP"; break;
+		case TRAVEL_LADDER: str = "TRAVEL_LADDER"; break;
+		case TRAVEL_WALKOFFLEDGE: str = "TRAVEL_WALKOFFLEDGE"; break;
+		case TRAVEL_SWIM: str = "TRAVEL_SWIM"; break;
+		case TRAVEL_WATERJUMP: str = "TRAVEL_WATERJUMP"; break;
+		case TRAVEL_TELEPORT: str = "TRAVEL_TELEPORT"; break;
+		case TRAVEL_ELEVATOR: str = "TRAVEL_ELEVATOR"; break;
+		case TRAVEL_ROCKETJUMP: str = "TRAVEL_ROCKETJUMP"; break;
+		case TRAVEL_BFGJUMP: str = "TRAVEL_BFGJUMP"; break;
+		case TRAVEL_GRAPPLEHOOK: str = "TRAVEL_GRAPPLEHOOK"; break;
+		case TRAVEL_JUMPPAD: str = "TRAVEL_JUMPPAD"; break;
+		case TRAVEL_FUNCBOB: str = "TRAVEL_FUNCBOB"; break;
+		default: str = "UNKNOWN TRAVEL TYPE"; break;
+	} //end switch
+	botimport.Print(PRT_MESSAGE, "%s", str);
+#endif
+} //end of the function AAS_PrintTravelType
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void AAS_DrawArrow(vec3_t start, vec3_t end, int linecolor, int arrowcolor)
+{
+	vec3_t dir, cross, p1, p2, up = {0, 0, 1};
+	float dot;
+
+	VectorSubtract(end, start, dir);
+	VectorNormalize(dir);
+	dot = DotProduct(dir, up);
+	if (dot > 0.99 || dot < -0.99) VectorSet(cross, 1, 0, 0);
+	else CrossProduct(dir, up, cross);
+
+	VectorMA(end, -6, dir, p1);
+	VectorCopy(p1, p2);
+	VectorMA(p1, 6, cross, p1);
+	VectorMA(p2, -6, cross, p2);
+
+	AAS_DebugLine(start, end, linecolor);
+	AAS_DebugLine(p1, end, arrowcolor);
+	AAS_DebugLine(p2, end, arrowcolor);
+} //end of the function AAS_DrawArrow
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void AAS_ShowReachability(aas_reachability_t *reach)
+{
+	vec3_t dir, cmdmove, velocity;
+	float speed, zvel;
+	aas_clientmove_t move;
+
+	AAS_ShowAreaPolygons(reach->areanum, 5, qtrue);
+	//AAS_ShowArea(reach->areanum, qtrue);
+	AAS_DrawArrow(reach->start, reach->end, LINECOLOR_BLUE, LINECOLOR_YELLOW);
+	//
+	if ((reach->traveltype & TRAVELTYPE_MASK) == TRAVEL_JUMP ||
+		(reach->traveltype & TRAVELTYPE_MASK) == TRAVEL_WALKOFFLEDGE)
+	{
+		AAS_HorizontalVelocityForJump(aassettings.phys_jumpvel, reach->start, reach->end, &speed);
+		//
+		VectorSubtract(reach->end, reach->start, dir);
+		dir[2] = 0;
+		VectorNormalize(dir);
+		//set the velocity
+		VectorScale(dir, speed, velocity);
+		//set the command movement
+		VectorClear(cmdmove);
+		cmdmove[2] = aassettings.phys_jumpvel;
+		//
+		AAS_PredictClientMovement(&move, -1, reach->start, PRESENCE_NORMAL, qtrue,
+									velocity, cmdmove, 3, 30, 0.1f,
+									SE_HITGROUND|SE_ENTERWATER|SE_ENTERSLIME|
+									SE_ENTERLAVA|SE_HITGROUNDDAMAGE, 0, qtrue);
+		//
+		if ((reach->traveltype & TRAVELTYPE_MASK) == TRAVEL_JUMP)
+		{
+			AAS_JumpReachRunStart(reach, dir);
+			AAS_DrawCross(dir, 4, LINECOLOR_BLUE);
+		} //end if
+	} //end if
+	else if ((reach->traveltype & TRAVELTYPE_MASK) == TRAVEL_ROCKETJUMP)
+	{
+		zvel = AAS_RocketJumpZVelocity(reach->start);
+		AAS_HorizontalVelocityForJump(zvel, reach->start, reach->end, &speed);
+		//
+		VectorSubtract(reach->end, reach->start, dir);
+		dir[2] = 0;
+		VectorNormalize(dir);
+		//get command movement
+		VectorScale(dir, speed, cmdmove);
+		VectorSet(velocity, 0, 0, zvel);
+		//
+		AAS_PredictClientMovement(&move, -1, reach->start, PRESENCE_NORMAL, qtrue,
+									velocity, cmdmove, 30, 30, 0.1f,
+									SE_ENTERWATER|SE_ENTERSLIME|
+									SE_ENTERLAVA|SE_HITGROUNDDAMAGE|
+									SE_TOUCHJUMPPAD|SE_HITGROUNDAREA, reach->areanum, qtrue);
+	} //end else if
+	else if ((reach->traveltype & TRAVELTYPE_MASK) == TRAVEL_JUMPPAD)
+	{
+		VectorSet(cmdmove, 0, 0, 0);
+		//
+		VectorSubtract(reach->end, reach->start, dir);
+		dir[2] = 0;
+		VectorNormalize(dir);
+		//set the velocity
+		//NOTE: the edgenum is the horizontal velocity
+		VectorScale(dir, reach->edgenum, velocity);
+		//NOTE: the facenum is the Z velocity
+		velocity[2] = reach->facenum;
+		//
+		AAS_PredictClientMovement(&move, -1, reach->start, PRESENCE_NORMAL, qtrue,
+									velocity, cmdmove, 30, 30, 0.1f,
+									SE_ENTERWATER|SE_ENTERSLIME|
+									SE_ENTERLAVA|SE_HITGROUNDDAMAGE|
+									SE_TOUCHJUMPPAD|SE_HITGROUNDAREA, reach->areanum, qtrue);
+	} //end else if
+} //end of the function AAS_ShowReachability
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void AAS_ShowReachableAreas(int areanum)
+{
+	aas_areasettings_t *settings;
+	static aas_reachability_t reach;
+	static int index, lastareanum;
+	static float lasttime;
+
+	if (areanum != lastareanum)
+	{
+		index = 0;
+		lastareanum = areanum;
+	} //end if
+	settings = &aasworld.areasettings[areanum];
+	//
+	if (!settings->numreachableareas) return;
+	//
+	if (index >= settings->numreachableareas) index = 0;
+	//
+	if (AAS_Time() - lasttime > 1.5)
+	{
+		Com_Memcpy(&reach, &aasworld.reachability[settings->firstreachablearea + index], sizeof(aas_reachability_t));
+		index++;
+		lasttime = AAS_Time();
+		AAS_PrintTravelType(reach.traveltype & TRAVELTYPE_MASK);
+		botimport.Print(PRT_MESSAGE, "\n");
+	} //end if
+	AAS_ShowReachability(&reach);
+} //end of the function ShowReachableAreas
+
+void AAS_FloodAreas_r(int areanum, int cluster, int *done)
+{
+	int nextareanum, i, facenum;
+	aas_area_t *area;
+	aas_face_t *face;
+	aas_areasettings_t *settings;
+	aas_reachability_t *reach;
+
+	AAS_ShowAreaPolygons(areanum, 1, qtrue);
+	//pointer to the convex area
+	area = &aasworld.areas[areanum];
+	settings = &aasworld.areasettings[areanum];
+	//walk through the faces of the area
+	for (i = 0; i < area->numfaces; i++)
+	{
+		facenum = abs(aasworld.faceindex[area->firstface + i]);
+		face = &aasworld.faces[facenum];
+		if (face->frontarea == areanum)
+			nextareanum = face->backarea;
+		else
+			nextareanum = face->frontarea;
+		if (!nextareanum)
+			continue;
+		if (done[nextareanum])
+			continue;
+		done[nextareanum] = qtrue;
+		if (aasworld.areasettings[nextareanum].contents & AREACONTENTS_VIEWPORTAL)
+			continue;
+		if (AAS_AreaCluster(nextareanum) != cluster)
+			continue;
+		AAS_FloodAreas_r(nextareanum, cluster, done);
+	} //end for
+	//
+	for (i = 0; i < settings->numreachableareas; i++)
+	{
+		reach = &aasworld.reachability[settings->firstreachablearea + i];
+		nextareanum = reach->areanum;
+		if (!nextareanum)
+			continue;
+		if (done[nextareanum])
+			continue;
+		done[nextareanum] = qtrue;
+		if (aasworld.areasettings[nextareanum].contents & AREACONTENTS_VIEWPORTAL)
+			continue;
+		if (AAS_AreaCluster(nextareanum) != cluster)
+			continue;
+		/*
+		if ((reach->traveltype & TRAVELTYPE_MASK) == TRAVEL_WALKOFFLEDGE)
+		{
+			AAS_DebugLine(reach->start, reach->end, 1);
+		}
+		*/
+		AAS_FloodAreas_r(nextareanum, cluster, done);
+	}
+}
+
+void AAS_FloodAreas(vec3_t origin)
+{
+	int areanum, cluster, *done;
+
+	done = (int *) GetClearedMemory(aasworld.numareas * sizeof(int));
+	areanum = AAS_PointAreaNum(origin);
+	cluster = AAS_AreaCluster(areanum);
+	AAS_FloodAreas_r(areanum, cluster, done);
+}
diff --git a/codemp/botlib/be_aas_debug.h b/codemp/botlib/be_aas_debug.h
new file mode 100644
index 0000000..fbc65d1
--- /dev/null
+++ b/codemp/botlib/be_aas_debug.h
@@ -0,0 +1,45 @@
+
+/*****************************************************************************
+ * name:		be_aas_debug.h
+ *
+ * desc:		AAS
+ *
+ * $Archive: /source/code/botlib/be_aas_debug.h $
+ * $Author: Mrelusive $ 
+ * $Revision: 2 $
+ * $Modtime: 10/05/99 3:32p $
+ * $Date: 10/05/99 3:42p $
+ *
+ *****************************************************************************/
+
+//clear the shown debug lines
+void AAS_ClearShownDebugLines(void);
+//
+void AAS_ClearShownPolygons(void);
+//show a debug line
+void AAS_DebugLine(vec3_t start, vec3_t end, int color);
+//show a permenent line
+void AAS_PermanentLine(vec3_t start, vec3_t end, int color);
+//show a permanent cross
+void AAS_DrawPermanentCross(vec3_t origin, float size, int color);
+//draw a cross in the plane
+void AAS_DrawPlaneCross(vec3_t point, vec3_t normal, float dist, int type, int color);
+//show a bounding box
+void AAS_ShowBoundingBox(vec3_t origin, vec3_t mins, vec3_t maxs);
+//show a face
+void AAS_ShowFace(int facenum);
+//show an area
+void AAS_ShowArea(int areanum, int groundfacesonly);
+//
+void AAS_ShowAreaPolygons(int areanum, int color, int groundfacesonly);
+//draw a cros
+void AAS_DrawCross(vec3_t origin, float size, int color);
+//print the travel type
+void AAS_PrintTravelType(int traveltype);
+//draw an arrow
+void AAS_DrawArrow(vec3_t start, vec3_t end, int linecolor, int arrowcolor);
+//visualize the given reachability
+void AAS_ShowReachability(struct aas_reachability_s *reach);
+//show the reachable areas from the given area
+void AAS_ShowReachableAreas(int areanum);
+
diff --git a/codemp/botlib/be_aas_def.h b/codemp/botlib/be_aas_def.h
new file mode 100644
index 0000000..a665f72
--- /dev/null
+++ b/codemp/botlib/be_aas_def.h
@@ -0,0 +1,295 @@
+
+/*****************************************************************************
+ * name:		be_aas_def.h
+ *
+ * desc:		AAS
+ *
+ * $Archive: /source/code/botlib/be_aas_def.h $
+ * $Author: osman $ 
+ * $Revision: 1.4 $
+ * $Modtime: 10/05/99 3:32p $
+ * $Date: 2003/03/15 23:43:54 $
+ *
+ *****************************************************************************/
+
+//debugging on
+#define AAS_DEBUG
+
+// these are also in q_shared.h - argh (rjr)
+#ifdef _XBOX
+#define MAX_CLIENTS			16
+#else
+#define MAX_CLIENTS			32
+#endif
+#define MAX_RADAR_ENTITIES	MAX_GENTITIES
+#define	MAX_MODELS			512		// these are sent over the net as 8 bits
+#define	MAX_SOUNDS			256		// so they cannot be blindly increased
+
+// these are also in bg_public.h - argh (rjr)
+#define	CS_SCORES			32
+#define	CS_MODELS			(CS_SCORES+MAX_CLIENTS)
+#define	CS_SOUNDS			(CS_MODELS+MAX_MODELS)
+
+#define DF_AASENTNUMBER(x)		(x - aasworld.entities)
+#define DF_NUMBERAASENT(x)		(&aasworld.entities[x])
+#define DF_AASENTCLIENT(x)		(x - aasworld.entities - 1)
+#define DF_CLIENTAASENT(x)		(&aasworld.entities[x + 1])
+
+#ifndef MAX_PATH
+	#define MAX_PATH				MAX_QPATH
+#endif
+
+//string index (for model, sound and image index)
+typedef struct aas_stringindex_s
+{
+	int numindexes;
+	char **index;
+} aas_stringindex_t;
+
+//structure to link entities to areas and areas to entities
+typedef struct aas_link_s
+{
+	int entnum;
+	int areanum;
+	struct aas_link_s *next_ent, *prev_ent;
+	struct aas_link_s *next_area, *prev_area;
+} aas_link_t;
+
+//structure to link entities to leaves and leaves to entities
+typedef struct bsp_link_s
+{
+	int entnum;
+	int leafnum;
+	struct bsp_link_s *next_ent, *prev_ent;
+	struct bsp_link_s *next_leaf, *prev_leaf;
+} bsp_link_t;
+
+typedef struct bsp_entdata_s
+{
+	vec3_t origin;
+	vec3_t angles;
+	vec3_t absmins;
+	vec3_t absmaxs;
+	int solid;
+	int modelnum;
+} bsp_entdata_t;
+
+//entity
+typedef struct aas_entity_s
+{
+	//entity info
+	aas_entityinfo_t i;
+	//links into the AAS areas
+	aas_link_t *areas;
+	//links into the BSP leaves
+	bsp_link_t *leaves;
+} aas_entity_t;
+
+typedef struct aas_settings_s
+{
+	vec3_t phys_gravitydirection;
+	float phys_friction;
+	float phys_stopspeed;
+	float phys_gravity;
+	float phys_waterfriction;
+	float phys_watergravity;
+	float phys_maxvelocity;
+	float phys_maxwalkvelocity;
+	float phys_maxcrouchvelocity;
+	float phys_maxswimvelocity;
+	float phys_walkaccelerate;
+	float phys_airaccelerate;
+	float phys_swimaccelerate;
+	float phys_maxstep;
+	float phys_maxsteepness;
+	float phys_maxwaterjump;
+	float phys_maxbarrier;
+	float phys_jumpvel;
+	float phys_falldelta5;
+	float phys_falldelta10;
+	float rs_waterjump;
+	float rs_teleport;
+	float rs_barrierjump;
+	float rs_startcrouch;
+	float rs_startgrapple;
+	float rs_startwalkoffledge;
+	float rs_startjump;
+	float rs_rocketjump;
+	float rs_bfgjump;
+	float rs_jumppad;
+	float rs_aircontrolledjumppad;
+	float rs_funcbob;
+	float rs_startelevator;
+	float rs_falldamage5;
+	float rs_falldamage10;
+	float rs_maxfallheight;
+	float rs_maxjumpfallheight;
+} aas_settings_t;
+
+#define CACHETYPE_PORTAL		0
+#define CACHETYPE_AREA			1
+
+//routing cache
+typedef struct aas_routingcache_s
+{
+	byte type;									//portal or area cache
+	float time;									//last time accessed or updated
+	int size;									//size of the routing cache
+	int cluster;								//cluster the cache is for
+	int areanum;								//area the cache is created for
+	vec3_t origin;								//origin within the area
+	float starttraveltime;						//travel time to start with
+	int travelflags;							//combinations of the travel flags
+	struct aas_routingcache_s *prev, *next;
+	struct aas_routingcache_s *time_prev, *time_next;
+	unsigned char *reachabilities;				//reachabilities used for routing
+	unsigned short int traveltimes[1];			//travel time for every area (variable sized)
+} aas_routingcache_t;
+
+//fields for the routing algorithm
+typedef struct aas_routingupdate_s
+{
+	int cluster;
+	int areanum;								//area number of the update
+	vec3_t start;								//start point the area was entered
+	unsigned short int tmptraveltime;			//temporary travel time
+	unsigned short int *areatraveltimes;		//travel times within the area
+	qboolean inlist;							//true if the update is in the list
+	struct aas_routingupdate_s *next;
+	struct aas_routingupdate_s *prev;
+} aas_routingupdate_t;
+
+//reversed reachability link
+typedef struct aas_reversedlink_s
+{
+	int linknum;								//the aas_areareachability_t
+	int areanum;								//reachable from this area
+	struct aas_reversedlink_s *next;			//next link
+} aas_reversedlink_t;
+
+//reversed area reachability
+typedef struct aas_reversedreachability_s
+{
+	int numlinks;
+	aas_reversedlink_t *first;
+} aas_reversedreachability_t;
+
+//areas a reachability goes through
+typedef struct aas_reachabilityareas_s
+{
+	int firstarea, numareas;
+} aas_reachabilityareas_t;
+
+typedef struct aas_s
+{
+	int loaded;									//true when an AAS file is loaded
+	int initialized;							//true when AAS has been initialized
+	int savefile;								//set true when file should be saved
+	int bspchecksum;
+	//current time
+	float time;
+	int numframes;
+	//name of the aas file
+	char filename[MAX_PATH];
+	char mapname[MAX_PATH];
+	//bounding boxes
+	int numbboxes;
+	aas_bbox_t *bboxes;
+	//vertexes
+	int numvertexes;
+	aas_vertex_t *vertexes;
+	//planes
+	int numplanes;
+	aas_plane_t *planes;
+	//edges
+	int numedges;
+	aas_edge_t *edges;
+	//edge index
+	int edgeindexsize;
+	aas_edgeindex_t *edgeindex;
+	//faces
+	int numfaces;
+	aas_face_t *faces;
+	//face index
+	int faceindexsize;
+	aas_faceindex_t *faceindex;
+	//convex areas
+	int numareas;
+	aas_area_t *areas;
+	//convex area settings
+	int numareasettings;
+	aas_areasettings_t *areasettings;
+	//reachablity list
+	int reachabilitysize;
+	aas_reachability_t *reachability;
+	//nodes of the bsp tree
+	int numnodes;
+	aas_node_t *nodes;
+	//cluster portals
+	int numportals;
+	aas_portal_t *portals;
+	//cluster portal index
+	int portalindexsize;
+	aas_portalindex_t *portalindex;
+	//clusters
+	int numclusters;
+	aas_cluster_t *clusters;
+	//
+	int numreachabilityareas;
+	float reachabilitytime;
+	//enities linked in the areas
+	aas_link_t *linkheap;						//heap with link structures
+	int linkheapsize;							//size of the link heap
+	aas_link_t *freelinks;						//first free link
+	aas_link_t **arealinkedentities;			//entities linked into areas
+	//entities
+	int maxentities;
+	int maxclients;
+	aas_entity_t *entities;
+	//string indexes
+	char *configstrings[MAX_CONFIGSTRINGS];
+	int indexessetup;
+	//index to retrieve travel flag for a travel type
+	int travelflagfortype[MAX_TRAVELTYPES];
+	//travel flags for each area based on contents
+	int *areacontentstravelflags;
+	//routing update
+	aas_routingupdate_t *areaupdate;
+	aas_routingupdate_t *portalupdate;
+	//number of routing updates during a frame (reset every frame)
+	int frameroutingupdates;
+	//reversed reachability links
+	aas_reversedreachability_t *reversedreachability;
+	//travel times within the areas
+	unsigned short ***areatraveltimes;
+	//array of size numclusters with cluster cache
+	aas_routingcache_t ***clusterareacache;
+	aas_routingcache_t **portalcache;
+	//cache list sorted on time
+	aas_routingcache_t *oldestcache;		// start of cache list sorted on time
+	aas_routingcache_t *newestcache;		// end of cache list sorted on time
+	//maximum travel time through portal areas
+	int *portalmaxtraveltimes;
+	//areas the reachabilities go through
+	int *reachabilityareaindex;
+	aas_reachabilityareas_t *reachabilityareas;
+} aas_t;
+
+#define AASINTERN
+
+#ifndef BSPCINCLUDE
+
+#include "be_aas_main.h"
+#include "be_aas_entity.h"
+#include "be_aas_sample.h"
+#include "be_aas_cluster.h"
+#include "be_aas_reach.h"
+#include "be_aas_route.h"
+#include "be_aas_routealt.h"
+#include "be_aas_debug.h"
+#include "be_aas_file.h"
+#include "be_aas_optimize.h"
+#include "be_aas_bsp.h"
+#include "be_aas_move.h"
+
+#endif //BSPCINCLUDE
diff --git a/codemp/botlib/be_aas_entity.cpp b/codemp/botlib/be_aas_entity.cpp
new file mode 100644
index 0000000..78edeb0
--- /dev/null
+++ b/codemp/botlib/be_aas_entity.cpp
@@ -0,0 +1,420 @@
+
+/*****************************************************************************
+ * name:		be_aas_entity.c
+ *
+ * desc:		AAS entities
+ *
+ * $Archive: /MissionPack/code/botlib/be_aas_entity.c $
+ * $Author: Zaphod $ 
+ * $Revision: 11 $
+ * $Modtime: 11/22/00 8:50a $
+ * $Date: 11/22/00 8:55a $
+ *
+ *****************************************************************************/
+
+#include "../game/q_shared.h"
+#include "l_memory.h"
+#include "l_script.h"
+#include "l_precomp.h"
+#include "l_struct.h"
+#include "l_utils.h"
+#include "l_log.h"
+#include "aasfile.h"
+#include "../game/botlib.h"
+#include "../game/be_aas.h"
+#include "be_aas_funcs.h"
+#include "be_interface.h"
+#include "be_aas_def.h"
+
+#define MASK_SOLID		CONTENTS_PLAYERCLIP
+
+//FIXME: these might change
+enum {
+	ET_GENERAL,
+	ET_PLAYER,
+	ET_ITEM,
+	ET_MISSILE,
+	ET_MOVER
+};
+
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int AAS_UpdateEntity(int entnum, bot_entitystate_t *state)
+{
+	int relink;
+	aas_entity_t *ent;
+	vec3_t absmins, absmaxs;
+
+	if (!aasworld.loaded)
+	{
+		botimport.Print(PRT_MESSAGE, "AAS_UpdateEntity: not loaded\n");
+		return BLERR_NOAASFILE;
+	} //end if
+
+	ent = &aasworld.entities[entnum];
+
+	if (!state) {
+		//unlink the entity
+		AAS_UnlinkFromAreas(ent->areas);
+		//unlink the entity from the BSP leaves
+		AAS_UnlinkFromBSPLeaves(ent->leaves);
+		//
+		ent->areas = NULL;
+		//
+		ent->leaves = NULL;
+		return BLERR_NOERROR;
+	}
+
+	ent->i.update_time = AAS_Time() - ent->i.ltime;
+	ent->i.type = state->type;
+	ent->i.flags = state->flags;
+	ent->i.ltime = AAS_Time();
+	VectorCopy(ent->i.origin, ent->i.lastvisorigin);
+	VectorCopy(state->old_origin, ent->i.old_origin);
+	ent->i.solid = state->solid;
+	ent->i.groundent = state->groundent;
+	ent->i.modelindex = state->modelindex;
+	ent->i.modelindex2 = state->modelindex2;
+	ent->i.frame = state->frame;
+	ent->i.event = state->event;
+	ent->i.eventParm = state->eventParm;
+	ent->i.powerups = state->powerups;
+	ent->i.weapon = state->weapon;
+	ent->i.legsAnim = state->legsAnim;
+	ent->i.torsoAnim = state->torsoAnim;
+	//number of the entity
+	ent->i.number = entnum;
+	//updated so set valid flag
+	ent->i.valid = qtrue;
+	//link everything the first frame
+	if (aasworld.numframes == 1) relink = qtrue;
+	else relink = qfalse;
+	//
+	if (ent->i.solid == SOLID_BSP)
+	{
+		//if the angles of the model changed
+		if (!VectorCompare(state->angles, ent->i.angles))
+		{
+			VectorCopy(state->angles, ent->i.angles);
+			relink = qtrue;
+		} //end if
+		//get the mins and maxs of the model
+		//FIXME: rotate mins and maxs
+		AAS_BSPModelMinsMaxsOrigin(ent->i.modelindex, ent->i.angles, ent->i.mins, ent->i.maxs, NULL);
+	} //end if
+	else if (ent->i.solid == SOLID_BBOX)
+	{
+		//if the bounding box size changed
+		if (!VectorCompare(state->mins, ent->i.mins) ||
+				!VectorCompare(state->maxs, ent->i.maxs))
+		{
+			VectorCopy(state->mins, ent->i.mins);
+			VectorCopy(state->maxs, ent->i.maxs);
+			relink = qtrue;
+		} //end if
+		VectorCopy(state->angles, ent->i.angles);
+	} //end if
+	//if the origin changed
+	if (!VectorCompare(state->origin, ent->i.origin))
+	{
+		VectorCopy(state->origin, ent->i.origin);
+		relink = qtrue;
+	} //end if
+	//if the entity should be relinked
+	if (relink)
+	{
+		//don't link the world model
+		if (entnum != ENTITYNUM_WORLD)
+		{
+			//absolute mins and maxs
+			VectorAdd(ent->i.mins, ent->i.origin, absmins);
+			VectorAdd(ent->i.maxs, ent->i.origin, absmaxs);
+			//unlink the entity
+			AAS_UnlinkFromAreas(ent->areas);
+			//relink the entity to the AAS areas (use the larges bbox)
+			ent->areas = AAS_LinkEntityClientBBox(absmins, absmaxs, entnum, PRESENCE_NORMAL);
+			//unlink the entity from the BSP leaves
+			AAS_UnlinkFromBSPLeaves(ent->leaves);
+			//link the entity to the world BSP tree
+			ent->leaves = AAS_BSPLinkEntity(absmins, absmaxs, entnum, 0);
+		} //end if
+	} //end if
+	return BLERR_NOERROR;
+} //end of the function AAS_UpdateEntity
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+void AAS_EntityInfo(int entnum, aas_entityinfo_t *info)
+{
+	if (!aasworld.initialized)
+	{
+		botimport.Print(PRT_FATAL, "AAS_EntityInfo: aasworld not initialized\n");
+		Com_Memset(info, 0, sizeof(aas_entityinfo_t));
+		return;
+	} //end if
+
+	if (entnum < 0 || entnum >= aasworld.maxentities)
+	{
+		botimport.Print(PRT_FATAL, "AAS_EntityInfo: entnum %d out of range\n", entnum);
+		Com_Memset(info, 0, sizeof(aas_entityinfo_t));
+		return;
+	} //end if
+
+	Com_Memcpy(info, &aasworld.entities[entnum].i, sizeof(aas_entityinfo_t));
+} //end of the function AAS_EntityInfo
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void AAS_EntityOrigin(int entnum, vec3_t origin)
+{
+	if (entnum < 0 || entnum >= aasworld.maxentities)
+	{
+		botimport.Print(PRT_FATAL, "AAS_EntityOrigin: entnum %d out of range\n", entnum);
+		VectorClear(origin);
+		return;
+	} //end if
+
+	VectorCopy(aasworld.entities[entnum].i.origin, origin);
+} //end of the function AAS_EntityOrigin
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int AAS_EntityModelindex(int entnum)
+{
+	if (entnum < 0 || entnum >= aasworld.maxentities)
+	{
+		botimport.Print(PRT_FATAL, "AAS_EntityModelindex: entnum %d out of range\n", entnum);
+		return 0;
+	} //end if
+	return aasworld.entities[entnum].i.modelindex;
+} //end of the function AAS_EntityModelindex
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int AAS_EntityType(int entnum)
+{
+	if (!aasworld.initialized) return 0;
+
+	if (entnum < 0 || entnum >= aasworld.maxentities)
+	{
+		botimport.Print(PRT_FATAL, "AAS_EntityType: entnum %d out of range\n", entnum);
+		return 0;
+	} //end if
+	return aasworld.entities[entnum].i.type;
+} //end of the AAS_EntityType
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int AAS_EntityModelNum(int entnum)
+{
+	if (!aasworld.initialized) return 0;
+
+	if (entnum < 0 || entnum >= aasworld.maxentities)
+	{
+		botimport.Print(PRT_FATAL, "AAS_EntityModelNum: entnum %d out of range\n", entnum);
+		return 0;
+	} //end if
+	return aasworld.entities[entnum].i.modelindex;
+} //end of the function AAS_EntityModelNum
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int AAS_OriginOfMoverWithModelNum(int modelnum, vec3_t origin)
+{
+	int i;
+	aas_entity_t *ent;
+
+	for (i = 0; i < aasworld.maxentities; i++)
+	{
+		ent = &aasworld.entities[i];
+		if (ent->i.type == ET_MOVER)
+		{
+			if (ent->i.modelindex == modelnum)
+			{
+				VectorCopy(ent->i.origin, origin);
+				return qtrue;
+			} //end if
+		} //end if
+	} //end for
+	return qfalse;
+} //end of the function AAS_OriginOfMoverWithModelNum
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void AAS_EntitySize(int entnum, vec3_t mins, vec3_t maxs)
+{
+	aas_entity_t *ent;
+
+	if (!aasworld.initialized) return;
+
+	if (entnum < 0 || entnum >= aasworld.maxentities)
+	{
+		botimport.Print(PRT_FATAL, "AAS_EntitySize: entnum %d out of range\n", entnum);
+		return;
+	} //end if
+
+	ent = &aasworld.entities[entnum];
+	VectorCopy(ent->i.mins, mins);
+	VectorCopy(ent->i.maxs, maxs);
+} //end of the function AAS_EntitySize
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void AAS_EntityBSPData(int entnum, bsp_entdata_t *entdata)
+{
+	aas_entity_t *ent;
+
+	ent = &aasworld.entities[entnum];
+	VectorCopy(ent->i.origin, entdata->origin);
+	VectorCopy(ent->i.angles, entdata->angles);
+	VectorAdd(ent->i.origin, ent->i.mins, entdata->absmins);
+	VectorAdd(ent->i.origin, ent->i.maxs, entdata->absmaxs);
+	entdata->solid = ent->i.solid;
+	entdata->modelnum = ent->i.modelindex - 1;
+} //end of the function AAS_EntityBSPData
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void AAS_ResetEntityLinks(void)
+{
+	int i;
+	for (i = 0; i < aasworld.maxentities; i++)
+	{
+		aasworld.entities[i].areas = NULL;
+		aasworld.entities[i].leaves = NULL;
+	} //end for
+} //end of the function AAS_ResetEntityLinks
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void AAS_InvalidateEntities(void)
+{
+	int i;
+	for (i = 0; i < aasworld.maxentities; i++)
+	{
+		aasworld.entities[i].i.valid = qfalse;
+		aasworld.entities[i].i.number = i;
+	} //end for
+} //end of the function AAS_InvalidateEntities
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void AAS_UnlinkInvalidEntities(void)
+{
+	int i;
+	aas_entity_t *ent;
+
+	for (i = 0; i < aasworld.maxentities; i++)
+	{
+		ent = &aasworld.entities[i];
+		if (!ent->i.valid)
+		{
+			AAS_UnlinkFromAreas( ent->areas );
+			ent->areas = NULL;
+			AAS_UnlinkFromBSPLeaves( ent->leaves );
+			ent->leaves = NULL;
+		} //end for
+	} //end for
+} //end of the function AAS_UnlinkInvalidEntities
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int AAS_NearestEntity(vec3_t origin, int modelindex)
+{
+	int i, bestentnum;
+	float dist, bestdist;
+	aas_entity_t *ent;
+	vec3_t dir;
+
+	bestentnum = 0;
+	bestdist = 99999;
+	for (i = 0; i < aasworld.maxentities; i++)
+	{
+		ent = &aasworld.entities[i];
+		if (ent->i.modelindex != modelindex) continue;
+		VectorSubtract(ent->i.origin, origin, dir);
+		if (abs(dir[0]) < 40)
+		{
+			if (abs(dir[1]) < 40)
+			{
+				dist = VectorLength(dir);
+				if (dist < bestdist)
+				{
+					bestdist = dist;
+					bestentnum = i;
+				} //end if
+			} //end if
+		} //end if
+	} //end for
+	return bestentnum;
+} //end of the function AAS_NearestEntity
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int AAS_BestReachableEntityArea(int entnum)
+{
+	aas_entity_t *ent;
+
+	ent = &aasworld.entities[entnum];
+	return AAS_BestReachableLinkArea(ent->areas);
+} //end of the function AAS_BestReachableEntityArea
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+int AAS_NextEntity(int entnum)
+{
+	if (!aasworld.loaded) return 0;
+
+	if (entnum < 0) entnum = -1;
+	while(++entnum < aasworld.maxentities)
+	{
+		if (aasworld.entities[entnum].i.valid) return entnum;
+	} //end while
+	return 0;
+} //end of the function AAS_NextEntity
diff --git a/codemp/botlib/be_aas_entity.h b/codemp/botlib/be_aas_entity.h
new file mode 100644
index 0000000..d147391
--- /dev/null
+++ b/codemp/botlib/be_aas_entity.h
@@ -0,0 +1,46 @@
+
+/*****************************************************************************
+ * name:		be_aas_entity.h
+ *
+ * desc:		AAS
+ *
+ * $Archive: /source/code/botlib/be_aas_entity.h $
+ * $Author: Mrelusive $ 
+ * $Revision: 2 $
+ * $Modtime: 10/05/99 3:32p $
+ * $Date: 10/05/99 3:42p $
+ *
+ *****************************************************************************/
+
+#ifdef AASINTERN
+//invalidates all entity infos
+void AAS_InvalidateEntities(void);
+//unlink not updated entities
+void AAS_UnlinkInvalidEntities(void);
+//resets the entity AAS and BSP links (sets areas and leaves pointers to NULL)
+void AAS_ResetEntityLinks(void);
+//updates an entity
+int AAS_UpdateEntity(int ent, bot_entitystate_t *state);
+//gives the entity data used for collision detection
+void AAS_EntityBSPData(int entnum, bsp_entdata_t *entdata);
+#endif //AASINTERN
+
+//returns the size of the entity bounding box in mins and maxs
+void AAS_EntitySize(int entnum, vec3_t mins, vec3_t maxs);
+//returns the BSP model number of the entity
+int AAS_EntityModelNum(int entnum);
+//returns the origin of an entity with the given model number
+int AAS_OriginOfMoverWithModelNum(int modelnum, vec3_t origin);
+//returns the best reachable area the entity is situated in
+int AAS_BestReachableEntityArea(int entnum);
+//returns the info of the given entity
+void AAS_EntityInfo(int entnum, aas_entityinfo_t *info);
+//returns the next entity
+int AAS_NextEntity(int entnum);
+//returns the origin of the entity
+void AAS_EntityOrigin(int entnum, vec3_t origin);
+//returns the entity type
+int AAS_EntityType(int entnum);
+//returns the model index of the entity
+int AAS_EntityModelindex(int entnum);
+
diff --git a/codemp/botlib/be_aas_file.cpp b/codemp/botlib/be_aas_file.cpp
new file mode 100644
index 0000000..5b8a9cc
--- /dev/null
+++ b/codemp/botlib/be_aas_file.cpp
@@ -0,0 +1,565 @@
+
+/*****************************************************************************
+ * name:		be_aas_file.c
+ *
+ * desc:		AAS file loading/writing
+ *
+ * $Archive: /MissionPack/code/botlib/be_aas_file.c $
+ * $Author: Zaphod $ 
+ * $Revision: 5 $
+ * $Modtime: 5/16/01 2:36p $
+ * $Date: 5/16/01 2:41p $
+ *
+ *****************************************************************************/
+
+#include "../game/q_shared.h"
+#include "l_memory.h"
+#include "l_script.h"
+#include "l_precomp.h"
+#include "l_struct.h"
+#include "l_libvar.h"
+#include "l_utils.h"
+#include "aasfile.h"
+#include "../game/botlib.h"
+#include "../game/be_aas.h"
+#include "be_aas_funcs.h"
+#include "be_interface.h"
+#include "be_aas_def.h"
+
+//#define AASFILEDEBUG
+
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void AAS_SwapAASData(void)
+{
+	int i, j;
+	//bounding boxes
+	for (i = 0; i < aasworld.numbboxes; i++)
+	{
+		aasworld.bboxes[i].presencetype = LittleLong(aasworld.bboxes[i].presencetype);
+		aasworld.bboxes[i].flags = LittleLong(aasworld.bboxes[i].flags);
+		for (j = 0; j < 3; j++)
+		{
+			aasworld.bboxes[i].mins[j] = LittleLong(aasworld.bboxes[i].mins[j]);
+			aasworld.bboxes[i].maxs[j] = LittleLong(aasworld.bboxes[i].maxs[j]);
+		} //end for
+	} //end for
+	//vertexes
+	for (i = 0; i < aasworld.numvertexes; i++)
+	{
+		for (j = 0; j < 3; j++)
+			aasworld.vertexes[i][j] = LittleFloat(aasworld.vertexes[i][j]);
+	} //end for
+	//planes
+	for (i = 0; i < aasworld.numplanes; i++)
+	{
+		for (j = 0; j < 3; j++)
+			aasworld.planes[i].normal[j] = LittleFloat(aasworld.planes[i].normal[j]);
+		aasworld.planes[i].dist = LittleFloat(aasworld.planes[i].dist);
+		aasworld.planes[i].type = LittleLong(aasworld.planes[i].type);
+	} //end for
+	//edges
+	for (i = 0; i < aasworld.numedges; i++)
+	{
+		aasworld.edges[i].v[0] = LittleLong(aasworld.edges[i].v[0]);
+		aasworld.edges[i].v[1] = LittleLong(aasworld.edges[i].v[1]);
+	} //end for
+	//edgeindex
+	for (i = 0; i < aasworld.edgeindexsize; i++)
+	{
+		aasworld.edgeindex[i] = LittleLong(aasworld.edgeindex[i]);
+	} //end for
+	//faces
+	for (i = 0; i < aasworld.numfaces; i++)
+	{
+		aasworld.faces[i].planenum = LittleLong(aasworld.faces[i].planenum);
+		aasworld.faces[i].faceflags = LittleLong(aasworld.faces[i].faceflags);
+		aasworld.faces[i].numedges = LittleLong(aasworld.faces[i].numedges);
+		aasworld.faces[i].firstedge = LittleLong(aasworld.faces[i].firstedge);
+		aasworld.faces[i].frontarea = LittleLong(aasworld.faces[i].frontarea);
+		aasworld.faces[i].backarea = LittleLong(aasworld.faces[i].backarea);
+	} //end for
+	//face index
+	for (i = 0; i < aasworld.faceindexsize; i++)
+	{
+		aasworld.faceindex[i] = LittleLong(aasworld.faceindex[i]);
+	} //end for
+	//convex areas
+	for (i = 0; i < aasworld.numareas; i++)
+	{
+		aasworld.areas[i].areanum = LittleLong(aasworld.areas[i].areanum);
+		aasworld.areas[i].numfaces = LittleLong(aasworld.areas[i].numfaces);
+		aasworld.areas[i].firstface = LittleLong(aasworld.areas[i].firstface);
+		for (j = 0; j < 3; j++)
+		{
+			aasworld.areas[i].mins[j] = LittleFloat(aasworld.areas[i].mins[j]);
+			aasworld.areas[i].maxs[j] = LittleFloat(aasworld.areas[i].maxs[j]);
+			aasworld.areas[i].center[j] = LittleFloat(aasworld.areas[i].center[j]);
+		} //end for
+	} //end for
+	//area settings
+	for (i = 0; i < aasworld.numareasettings; i++)
+	{
+		aasworld.areasettings[i].contents = LittleLong(aasworld.areasettings[i].contents);
+		aasworld.areasettings[i].areaflags = LittleLong(aasworld.areasettings[i].areaflags);
+		aasworld.areasettings[i].presencetype = LittleLong(aasworld.areasettings[i].presencetype);
+		aasworld.areasettings[i].cluster = LittleLong(aasworld.areasettings[i].cluster);
+		aasworld.areasettings[i].clusterareanum = LittleLong(aasworld.areasettings[i].clusterareanum);
+		aasworld.areasettings[i].numreachableareas = LittleLong(aasworld.areasettings[i].numreachableareas);
+		aasworld.areasettings[i].firstreachablearea = LittleLong(aasworld.areasettings[i].firstreachablearea);
+	} //end for
+	//area reachability
+	for (i = 0; i < aasworld.reachabilitysize; i++)
+	{
+		aasworld.reachability[i].areanum = LittleLong(aasworld.reachability[i].areanum);
+		aasworld.reachability[i].facenum = LittleLong(aasworld.reachability[i].facenum);
+		aasworld.reachability[i].edgenum = LittleLong(aasworld.reachability[i].edgenum);
+		for (j = 0; j < 3; j++)
+		{
+			aasworld.reachability[i].start[j] = LittleFloat(aasworld.reachability[i].start[j]);
+			aasworld.reachability[i].end[j] = LittleFloat(aasworld.reachability[i].end[j]);
+		} //end for
+		aasworld.reachability[i].traveltype = LittleLong(aasworld.reachability[i].traveltype);
+		aasworld.reachability[i].traveltime = LittleShort(aasworld.reachability[i].traveltime);
+	} //end for
+	//nodes
+	for (i = 0; i < aasworld.numnodes; i++)
+	{
+		aasworld.nodes[i].planenum = LittleLong(aasworld.nodes[i].planenum);
+		aasworld.nodes[i].children[0] = LittleLong(aasworld.nodes[i].children[0]);
+		aasworld.nodes[i].children[1] = LittleLong(aasworld.nodes[i].children[1]);
+	} //end for
+	//cluster portals
+	for (i = 0; i < aasworld.numportals; i++)
+	{
+		aasworld.portals[i].areanum = LittleLong(aasworld.portals[i].areanum);
+		aasworld.portals[i].frontcluster = LittleLong(aasworld.portals[i].frontcluster);
+		aasworld.portals[i].backcluster = LittleLong(aasworld.portals[i].backcluster);
+		aasworld.portals[i].clusterareanum[0] = LittleLong(aasworld.portals[i].clusterareanum[0]);
+		aasworld.portals[i].clusterareanum[1] = LittleLong(aasworld.portals[i].clusterareanum[1]);
+	} //end for
+	//cluster portal index
+	for (i = 0; i < aasworld.portalindexsize; i++)
+	{
+		aasworld.portalindex[i] = LittleLong(aasworld.portalindex[i]);
+	} //end for
+	//cluster
+	for (i = 0; i < aasworld.numclusters; i++)
+	{
+		aasworld.clusters[i].numareas = LittleLong(aasworld.clusters[i].numareas);
+		aasworld.clusters[i].numreachabilityareas = LittleLong(aasworld.clusters[i].numreachabilityareas);
+		aasworld.clusters[i].numportals = LittleLong(aasworld.clusters[i].numportals);
+		aasworld.clusters[i].firstportal = LittleLong(aasworld.clusters[i].firstportal);
+	} //end for
+} //end of the function AAS_SwapAASData
+//===========================================================================
+// dump the current loaded aas file
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void AAS_DumpAASData(void)
+{
+	aasworld.numbboxes = 0;
+	if (aasworld.bboxes) FreeMemory(aasworld.bboxes);
+	aasworld.bboxes = NULL;
+	aasworld.numvertexes = 0;
+	if (aasworld.vertexes) FreeMemory(aasworld.vertexes);
+	aasworld.vertexes = NULL;
+	aasworld.numplanes = 0;
+	if (aasworld.planes) FreeMemory(aasworld.planes);
+	aasworld.planes = NULL;
+	aasworld.numedges = 0;
+	if (aasworld.edges) FreeMemory(aasworld.edges);
+	aasworld.edges = NULL;
+	aasworld.edgeindexsize = 0;
+	if (aasworld.edgeindex) FreeMemory(aasworld.edgeindex);
+	aasworld.edgeindex = NULL;
+	aasworld.numfaces = 0;
+	if (aasworld.faces) FreeMemory(aasworld.faces);
+	aasworld.faces = NULL;
+	aasworld.faceindexsize = 0;
+	if (aasworld.faceindex) FreeMemory(aasworld.faceindex);
+	aasworld.faceindex = NULL;
+	aasworld.numareas = 0;
+	if (aasworld.areas) FreeMemory(aasworld.areas);
+	aasworld.areas = NULL;
+	aasworld.numareasettings = 0;
+	if (aasworld.areasettings) FreeMemory(aasworld.areasettings);
+	aasworld.areasettings = NULL;
+	aasworld.reachabilitysize = 0;
+	if (aasworld.reachability) FreeMemory(aasworld.reachability);
+	aasworld.reachability = NULL;
+	aasworld.numnodes = 0;
+	if (aasworld.nodes) FreeMemory(aasworld.nodes);
+	aasworld.nodes = NULL;
+	aasworld.numportals = 0;
+	if (aasworld.portals) FreeMemory(aasworld.portals);
+	aasworld.portals = NULL;
+	aasworld.numportals = 0;
+	if (aasworld.portalindex) FreeMemory(aasworld.portalindex);
+	aasworld.portalindex = NULL;
+	aasworld.portalindexsize = 0;
+	if (aasworld.clusters) FreeMemory(aasworld.clusters);
+	aasworld.clusters = NULL;
+	aasworld.numclusters = 0;
+	//
+	aasworld.loaded = qfalse;
+	aasworld.initialized = qfalse;
+	aasworld.savefile = qfalse;
+} //end of the function AAS_DumpAASData
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+#ifdef AASFILEDEBUG
+void AAS_FileInfo(void)
+{
+	int i, n, optimized;
+
+	botimport.Print(PRT_MESSAGE, "version = %d\n", AASVERSION);
+	botimport.Print(PRT_MESSAGE, "numvertexes = %d\n", aasworld.numvertexes);
+	botimport.Print(PRT_MESSAGE, "numplanes = %d\n", aasworld.numplanes);
+	botimport.Print(PRT_MESSAGE, "numedges = %d\n", aasworld.numedges);
+	botimport.Print(PRT_MESSAGE, "edgeindexsize = %d\n", aasworld.edgeindexsize);
+	botimport.Print(PRT_MESSAGE, "numfaces = %d\n", aasworld.numfaces);
+	botimport.Print(PRT_MESSAGE, "faceindexsize = %d\n", aasworld.faceindexsize);
+	botimport.Print(PRT_MESSAGE, "numareas = %d\n", aasworld.numareas);
+	botimport.Print(PRT_MESSAGE, "numareasettings = %d\n", aasworld.numareasettings);
+	botimport.Print(PRT_MESSAGE, "reachabilitysize = %d\n", aasworld.reachabilitysize);
+	botimport.Print(PRT_MESSAGE, "numnodes = %d\n", aasworld.numnodes);
+	botimport.Print(PRT_MESSAGE, "numportals = %d\n", aasworld.numportals);
+	botimport.Print(PRT_MESSAGE, "portalindexsize = %d\n", aasworld.portalindexsize);
+	botimport.Print(PRT_MESSAGE, "numclusters = %d\n", aasworld.numclusters);
+	//
+	for (n = 0, i = 0; i < aasworld.numareasettings; i++)
+	{
+		if (aasworld.areasettings[i].areaflags & AREA_GROUNDED) n++;
+	} //end for
+	botimport.Print(PRT_MESSAGE, "num grounded areas = %d\n", n);
+	//
+	botimport.Print(PRT_MESSAGE, "planes size %d bytes\n", aasworld.numplanes * sizeof(aas_plane_t));
+	botimport.Print(PRT_MESSAGE, "areas size %d bytes\n", aasworld.numareas * sizeof(aas_area_t));
+	botimport.Print(PRT_MESSAGE, "areasettings size %d bytes\n", aasworld.numareasettings * sizeof(aas_areasettings_t));
+	botimport.Print(PRT_MESSAGE, "nodes size %d bytes\n", aasworld.numnodes * sizeof(aas_node_t));
+	botimport.Print(PRT_MESSAGE, "reachability size %d bytes\n", aasworld.reachabilitysize * sizeof(aas_reachability_t));
+	botimport.Print(PRT_MESSAGE, "portals size %d bytes\n", aasworld.numportals * sizeof(aas_portal_t));
+	botimport.Print(PRT_MESSAGE, "clusters size %d bytes\n", aasworld.numclusters * sizeof(aas_cluster_t));
+
+	optimized = aasworld.numplanes * sizeof(aas_plane_t) +
+					aasworld.numareas * sizeof(aas_area_t) +
+					aasworld.numareasettings * sizeof(aas_areasettings_t) +
+					aasworld.numnodes * sizeof(aas_node_t) +
+					aasworld.reachabilitysize * sizeof(aas_reachability_t) +
+					aasworld.numportals * sizeof(aas_portal_t) +
+					aasworld.numclusters * sizeof(aas_cluster_t);
+	botimport.Print(PRT_MESSAGE, "optimzed size %d KB\n", optimized >> 10);
+} //end of the function AAS_FileInfo
+#endif //AASFILEDEBUG
+//===========================================================================
+// allocate memory and read a lump of a AAS file
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+char *AAS_LoadAASLump(fileHandle_t fp, int offset, int length, int *lastoffset, int size)
+{
+	char *buf;
+	//
+	if (!length)
+	{
+		//just alloc a dummy
+		return (char *) GetClearedHunkMemory(size+1);
+	} //end if
+	//seek to the data
+	if (offset != *lastoffset)
+	{
+		botimport.Print(PRT_WARNING, "AAS file not sequentially read\n");
+		if (botimport.FS_Seek(fp, offset, FS_SEEK_SET))
+		{
+			AAS_Error("can't seek to aas lump\n");
+			AAS_DumpAASData();
+			botimport.FS_FCloseFile(fp);
+			return 0;
+		} //end if
+	} //end if
+	//allocate memory
+	buf = (char *) GetClearedHunkMemory(length+1);
+	//read the data
+	if (length)
+	{
+		botimport.FS_Read(buf, length, fp );
+		*lastoffset += length;
+	} //end if
+	return buf;
+} //end of the function AAS_LoadAASLump
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+void AAS_DData(unsigned char *data, int size)
+{
+	int i;
+
+	for (i = 0; i < size; i++)
+	{
+		data[i] ^= (unsigned char) i * 119;
+	} //end for
+} //end of the function AAS_DData
+//===========================================================================
+// load an aas file
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+int AAS_LoadAASFile(char *filename)
+{
+	fileHandle_t fp;
+	aas_header_t header;
+	int offset, length, lastoffset;
+
+	botimport.Print(PRT_MESSAGE, "trying to load %s\n", filename);
+	//dump current loaded aas file
+	AAS_DumpAASData();
+	//open the file
+	botimport.FS_FOpenFile( filename, &fp, FS_READ );
+	if (!fp)
+	{
+		AAS_Error("can't open %s\n", filename);
+		return BLERR_CANNOTOPENAASFILE;
+	} //end if
+	//read the header
+	botimport.FS_Read(&header, sizeof(aas_header_t), fp );
+	lastoffset = sizeof(aas_header_t);
+	//check header identification
+	header.ident = LittleLong(header.ident);
+	if (header.ident != AASID)
+	{
+		AAS_Error("%s is not an AAS file\n", filename);
+		botimport.FS_FCloseFile(fp);
+		return BLERR_WRONGAASFILEID;
+	} //end if
+	//check the version
+	header.version = LittleLong(header.version);
+	//
+	if (header.version != AASVERSION_OLD && header.version != AASVERSION)
+	{
+		AAS_Error("aas file %s is version %i, not %i\n", filename, header.version, AASVERSION);
+		botimport.FS_FCloseFile(fp);
+		return BLERR_WRONGAASFILEVERSION;
+	} //end if
+	//
+	if (header.version == AASVERSION)
+	{
+		AAS_DData((unsigned char *) &header + 8, sizeof(aas_header_t) - 8);
+	} //end if
+	//
+	aasworld.bspchecksum = atoi(LibVarGetString( "sv_mapChecksum"));
+	if (LittleLong(header.bspchecksum) != aasworld.bspchecksum)
+	{
+		AAS_Error("aas file %s is out of date\n", filename);
+		botimport.FS_FCloseFile(fp);
+		return BLERR_WRONGAASFILEVERSION;
+	} //end if
+	//load the lumps:
+	//bounding boxes
+	offset = LittleLong(header.lumps[AASLUMP_BBOXES].fileofs);
+	length = LittleLong(header.lumps[AASLUMP_BBOXES].filelen);
+	aasworld.bboxes = (aas_bbox_t *) AAS_LoadAASLump(fp, offset, length, &lastoffset, sizeof(aas_bbox_t));
+	aasworld.numbboxes = length / sizeof(aas_bbox_t);
+	if (aasworld.numbboxes && !aasworld.bboxes) return BLERR_CANNOTREADAASLUMP;
+	//vertexes
+	offset = LittleLong(header.lumps[AASLUMP_VERTEXES].fileofs);
+	length = LittleLong(header.lumps[AASLUMP_VERTEXES].filelen);
+	aasworld.vertexes = (aas_vertex_t *) AAS_LoadAASLump(fp, offset, length, &lastoffset, sizeof(aas_vertex_t));
+	aasworld.numvertexes = length / sizeof(aas_vertex_t);
+	if (aasworld.numvertexes && !aasworld.vertexes) return BLERR_CANNOTREADAASLUMP;
+	//planes
+	offset = LittleLong(header.lumps[AASLUMP_PLANES].fileofs);
+	length = LittleLong(header.lumps[AASLUMP_PLANES].filelen);
+	aasworld.planes = (aas_plane_t *) AAS_LoadAASLump(fp, offset, length, &lastoffset, sizeof(aas_plane_t));
+	aasworld.numplanes = length / sizeof(aas_plane_t);
+	if (aasworld.numplanes && !aasworld.planes) return BLERR_CANNOTREADAASLUMP;
+	//edges
+	offset = LittleLong(header.lumps[AASLUMP_EDGES].fileofs);
+	length = LittleLong(header.lumps[AASLUMP_EDGES].filelen);
+	aasworld.edges = (aas_edge_t *) AAS_LoadAASLump(fp, offset, length, &lastoffset, sizeof(aas_edge_t));
+	aasworld.numedges = length / sizeof(aas_edge_t);
+	if (aasworld.numedges && !aasworld.edges) return BLERR_CANNOTREADAASLUMP;
+	//edgeindex
+	offset = LittleLong(header.lumps[AASLUMP_EDGEINDEX].fileofs);
+	length = LittleLong(header.lumps[AASLUMP_EDGEINDEX].filelen);
+	aasworld.edgeindex = (aas_edgeindex_t *) AAS_LoadAASLump(fp, offset, length, &lastoffset, sizeof(aas_edgeindex_t));
+	aasworld.edgeindexsize = length / sizeof(aas_edgeindex_t);
+	if (aasworld.edgeindexsize && !aasworld.edgeindex) return BLERR_CANNOTREADAASLUMP;
+	//faces
+	offset = LittleLong(header.lumps[AASLUMP_FACES].fileofs);
+	length = LittleLong(header.lumps[AASLUMP_FACES].filelen);
+	aasworld.faces = (aas_face_t *) AAS_LoadAASLump(fp, offset, length, &lastoffset, sizeof(aas_face_t));
+	aasworld.numfaces = length / sizeof(aas_face_t);
+	if (aasworld.numfaces && !aasworld.faces) return BLERR_CANNOTREADAASLUMP;
+	//faceindex
+	offset = LittleLong(header.lumps[AASLUMP_FACEINDEX].fileofs);
+	length = LittleLong(header.lumps[AASLUMP_FACEINDEX].filelen);
+	aasworld.faceindex = (aas_faceindex_t *) AAS_LoadAASLump(fp, offset, length, &lastoffset, sizeof(aas_faceindex_t));
+	aasworld.faceindexsize = length / sizeof(aas_faceindex_t);
+	if (aasworld.faceindexsize && !aasworld.faceindex) return BLERR_CANNOTREADAASLUMP;
+	//convex areas
+	offset = LittleLong(header.lumps[AASLUMP_AREAS].fileofs);
+	length = LittleLong(header.lumps[AASLUMP_AREAS].filelen);
+	aasworld.areas = (aas_area_t *) AAS_LoadAASLump(fp, offset, length, &lastoffset, sizeof(aas_area_t));
+	aasworld.numareas = length / sizeof(aas_area_t);
+	if (aasworld.numareas && !aasworld.areas) return BLERR_CANNOTREADAASLUMP;
+	//area settings
+	offset = LittleLong(header.lumps[AASLUMP_AREASETTINGS].fileofs);
+	length = LittleLong(header.lumps[AASLUMP_AREASETTINGS].filelen);
+	aasworld.areasettings = (aas_areasettings_t *) AAS_LoadAASLump(fp, offset, length, &lastoffset, sizeof(aas_areasettings_t));
+	aasworld.numareasettings = length / sizeof(aas_areasettings_t);
+	if (aasworld.numareasettings && !aasworld.areasettings) return BLERR_CANNOTREADAASLUMP;
+	//reachability list
+	offset = LittleLong(header.lumps[AASLUMP_REACHABILITY].fileofs);
+	length = LittleLong(header.lumps[AASLUMP_REACHABILITY].filelen);
+	aasworld.reachability = (aas_reachability_t *) AAS_LoadAASLump(fp, offset, length, &lastoffset, sizeof(aas_reachability_t));
+	aasworld.reachabilitysize = length / sizeof(aas_reachability_t);
+	if (aasworld.reachabilitysize && !aasworld.reachability) return BLERR_CANNOTREADAASLUMP;
+	//nodes
+	offset = LittleLong(header.lumps[AASLUMP_NODES].fileofs);
+	length = LittleLong(header.lumps[AASLUMP_NODES].filelen);
+	aasworld.nodes = (aas_node_t *) AAS_LoadAASLump(fp, offset, length, &lastoffset, sizeof(aas_node_t));
+	aasworld.numnodes = length / sizeof(aas_node_t);
+	if (aasworld.numnodes && !aasworld.nodes) return BLERR_CANNOTREADAASLUMP;
+	//cluster portals
+	offset = LittleLong(header.lumps[AASLUMP_PORTALS].fileofs);
+	length = LittleLong(header.lumps[AASLUMP_PORTALS].filelen);
+	aasworld.portals = (aas_portal_t *) AAS_LoadAASLump(fp, offset, length, &lastoffset, sizeof(aas_portal_t));
+	aasworld.numportals = length / sizeof(aas_portal_t);
+	if (aasworld.numportals && !aasworld.portals) return BLERR_CANNOTREADAASLUMP;
+	//cluster portal index
+	offset = LittleLong(header.lumps[AASLUMP_PORTALINDEX].fileofs);
+	length = LittleLong(header.lumps[AASLUMP_PORTALINDEX].filelen);
+	aasworld.portalindex = (aas_portalindex_t *) AAS_LoadAASLump(fp, offset, length, &lastoffset, sizeof(aas_portalindex_t));
+	aasworld.portalindexsize = length / sizeof(aas_portalindex_t);
+	if (aasworld.portalindexsize && !aasworld.portalindex) return BLERR_CANNOTREADAASLUMP;
+	//clusters
+	offset = LittleLong(header.lumps[AASLUMP_CLUSTERS].fileofs);
+	length = LittleLong(header.lumps[AASLUMP_CLUSTERS].filelen);
+	aasworld.clusters = (aas_cluster_t *) AAS_LoadAASLump(fp, offset, length, &lastoffset, sizeof(aas_cluster_t));
+	aasworld.numclusters = length / sizeof(aas_cluster_t);
+	if (aasworld.numclusters && !aasworld.clusters) return BLERR_CANNOTREADAASLUMP;
+	//swap everything
+	AAS_SwapAASData();
+	//aas file is loaded
+	aasworld.loaded = qtrue;
+	//close the file
+	botimport.FS_FCloseFile(fp);
+	//
+#ifdef AASFILEDEBUG
+	AAS_FileInfo();
+#endif //AASFILEDEBUG
+	//
+	return BLERR_NOERROR;
+} //end of the function AAS_LoadAASFile
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+static int AAS_WriteAASLump_offset;
+
+int AAS_WriteAASLump(fileHandle_t fp, aas_header_t *h, int lumpnum, void *data, int length)
+{
+	aas_lump_t *lump;
+
+	lump = &h->lumps[lumpnum];
+	
+	lump->fileofs = LittleLong(AAS_WriteAASLump_offset);	//LittleLong(ftell(fp));
+	lump->filelen = LittleLong(length);
+
+	if (length > 0)
+	{
+		botimport.FS_Write(data, length, fp );
+	} //end if
+
+	AAS_WriteAASLump_offset += length;
+
+	return qtrue;
+} //end of the function AAS_WriteAASLump
+//===========================================================================
+// aas data is useless after writing to file because it is byte swapped
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+qboolean AAS_WriteAASFile(char *filename)
+{
+	aas_header_t header;
+	fileHandle_t fp;
+
+	botimport.Print(PRT_MESSAGE, "writing %s\n", filename);
+	//swap the aas data
+	AAS_SwapAASData();
+	//initialize the file header
+	Com_Memset(&header, 0, sizeof(aas_header_t));
+	header.ident = LittleLong(AASID);
+	header.version = LittleLong(AASVERSION);
+	header.bspchecksum = LittleLong(aasworld.bspchecksum);
+	//open a new file
+	botimport.FS_FOpenFile( filename, &fp, FS_WRITE );
+	if (!fp)
+	{
+		botimport.Print(PRT_ERROR, "error opening %s\n", filename);
+		return qfalse;
+	} //end if
+	//write the header
+	botimport.FS_Write(&header, sizeof(aas_header_t), fp);
+	AAS_WriteAASLump_offset = sizeof(aas_header_t);
+	//add the data lumps to the file
+	if (!AAS_WriteAASLump(fp, &header, AASLUMP_BBOXES, aasworld.bboxes,
+		aasworld.numbboxes * sizeof(aas_bbox_t))) return qfalse;
+	if (!AAS_WriteAASLump(fp, &header, AASLUMP_VERTEXES, aasworld.vertexes,
+		aasworld.numvertexes * sizeof(aas_vertex_t))) return qfalse;
+	if (!AAS_WriteAASLump(fp, &header, AASLUMP_PLANES, aasworld.planes,
+		aasworld.numplanes * sizeof(aas_plane_t))) return qfalse;
+	if (!AAS_WriteAASLump(fp, &header, AASLUMP_EDGES, aasworld.edges,
+		aasworld.numedges * sizeof(aas_edge_t))) return qfalse;
+	if (!AAS_WriteAASLump(fp, &header, AASLUMP_EDGEINDEX, aasworld.edgeindex,
+		aasworld.edgeindexsize * sizeof(aas_edgeindex_t))) return qfalse;
+	if (!AAS_WriteAASLump(fp, &header, AASLUMP_FACES, aasworld.faces,
+		aasworld.numfaces * sizeof(aas_face_t))) return qfalse;
+	if (!AAS_WriteAASLump(fp, &header, AASLUMP_FACEINDEX, aasworld.faceindex,
+		aasworld.faceindexsize * sizeof(aas_faceindex_t))) return qfalse;
+	if (!AAS_WriteAASLump(fp, &header, AASLUMP_AREAS, aasworld.areas,
+		aasworld.numareas * sizeof(aas_area_t))) return qfalse;
+	if (!AAS_WriteAASLump(fp, &header, AASLUMP_AREASETTINGS, aasworld.areasettings,
+		aasworld.numareasettings * sizeof(aas_areasettings_t))) return qfalse;
+	if (!AAS_WriteAASLump(fp, &header, AASLUMP_REACHABILITY, aasworld.reachability,
+		aasworld.reachabilitysize * sizeof(aas_reachability_t))) return qfalse;
+	if (!AAS_WriteAASLump(fp, &header, AASLUMP_NODES, aasworld.nodes,
+		aasworld.numnodes * sizeof(aas_node_t))) return qfalse;
+	if (!AAS_WriteAASLump(fp, &header, AASLUMP_PORTALS, aasworld.portals,
+		aasworld.numportals * sizeof(aas_portal_t))) return qfalse;
+	if (!AAS_WriteAASLump(fp, &header, AASLUMP_PORTALINDEX, aasworld.portalindex,
+		aasworld.portalindexsize * sizeof(aas_portalindex_t))) return qfalse;
+	if (!AAS_WriteAASLump(fp, &header, AASLUMP_CLUSTERS, aasworld.clusters,
+		aasworld.numclusters * sizeof(aas_cluster_t))) return qfalse;
+	//rewrite the header with the added lumps
+	botimport.FS_Seek(fp, 0, FS_SEEK_SET);
+	AAS_DData((unsigned char *) &header + 8, sizeof(aas_header_t) - 8);
+	botimport.FS_Write(&header, sizeof(aas_header_t), fp);
+	//close the file
+	botimport.FS_FCloseFile(fp);
+	return qtrue;
+} //end of the function AAS_WriteAASFile
diff --git a/codemp/botlib/be_aas_file.h b/codemp/botlib/be_aas_file.h
new file mode 100644
index 0000000..302c480
--- /dev/null
+++ b/codemp/botlib/be_aas_file.h
@@ -0,0 +1,25 @@
+
+/*****************************************************************************
+ * name:		be_aas_file.h
+ *
+ * desc:		AAS
+ *
+ * $Archive: /source/code/botlib/be_aas_file.h $
+ * $Author: Mrelusive $ 
+ * $Revision: 2 $
+ * $Modtime: 10/05/99 3:32p $
+ * $Date: 10/05/99 3:42p $
+ *
+ *****************************************************************************/
+
+#ifdef AASINTERN
+//loads the AAS file with the given name
+int AAS_LoadAASFile(char *filename);
+//writes an AAS file with the given name
+qboolean AAS_WriteAASFile(char *filename);
+//dumps the loaded AAS data
+void AAS_DumpAASData(void);
+//print AAS file information
+void AAS_FileInfo(void);
+#endif //AASINTERN
+
diff --git a/codemp/botlib/be_aas_funcs.h b/codemp/botlib/be_aas_funcs.h
new file mode 100644
index 0000000..2af40d1
--- /dev/null
+++ b/codemp/botlib/be_aas_funcs.h
@@ -0,0 +1,30 @@
+
+/*****************************************************************************
+ * name:		be_aas_funcs.h
+ *
+ * desc:		AAS
+ *
+ * $Archive: /source/code/botlib/be_aas_funcs.h $
+ * $Author: Mrelusive $ 
+ * $Revision: 2 $
+ * $Modtime: 10/05/99 3:32p $
+ * $Date: 10/05/99 3:42p $
+ *
+ *****************************************************************************/
+
+#ifndef BSPCINCLUDE
+
+#include "be_aas_main.h"
+#include "be_aas_entity.h"
+#include "be_aas_sample.h"
+#include "be_aas_cluster.h"
+#include "be_aas_reach.h"
+#include "be_aas_route.h"
+#include "be_aas_routealt.h"
+#include "be_aas_debug.h"
+#include "be_aas_file.h"
+#include "be_aas_optimize.h"
+#include "be_aas_bsp.h"
+#include "be_aas_move.h"
+
+#endif //BSPCINCLUDE
diff --git a/codemp/botlib/be_aas_main.cpp b/codemp/botlib/be_aas_main.cpp
new file mode 100644
index 0000000..398668f
--- /dev/null
+++ b/codemp/botlib/be_aas_main.cpp
@@ -0,0 +1,412 @@
+
+/*****************************************************************************
+ * name:		be_aas_main.c
+ *
+ * desc:		AAS
+ *
+ * $Archive: /MissionPack/code/botlib/be_aas_main.c $
+ * $Author: Mrelusive $ 
+ * $Revision: 8 $
+ * $Modtime: 11/28/00 7:52a $
+ * $Date: 11/28/00 7:52a $
+ *
+ *****************************************************************************/
+
+#include "../game/q_shared.h"
+#include "l_memory.h"
+#include "l_libvar.h"
+#include "l_utils.h"
+#include "l_script.h"
+#include "l_precomp.h"
+#include "l_struct.h"
+#include "l_log.h"
+#include "aasfile.h"
+#include "../game/botlib.h"
+#include "../game/be_aas.h"
+#include "be_aas_funcs.h"
+#include "be_interface.h"
+#include "be_aas_def.h"
+
+aas_t aasworld;
+
+libvar_t *saveroutingcache;
+
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void QDECL AAS_Error(char *fmt, ...)
+{
+	char str[1024];
+	va_list arglist;
+
+	va_start(arglist, fmt);
+	vsprintf(str, fmt, arglist);
+	va_end(arglist);
+	botimport.Print(PRT_FATAL, str);
+} //end of the function AAS_Error
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+char *AAS_StringFromIndex(char *indexname, char *stringindex[], int numindexes, int index)
+{
+	if (!aasworld.indexessetup)
+	{
+		botimport.Print(PRT_ERROR, "%s: index %d not setup\n", indexname, index);
+		return "";
+	} //end if
+	if (index < 0 || index >= numindexes)
+	{
+		botimport.Print(PRT_ERROR, "%s: index %d out of range\n", indexname, index);
+		return "";
+	} //end if
+	if (!stringindex[index])
+	{
+		if (index)
+		{
+			botimport.Print(PRT_ERROR, "%s: reference to unused index %d\n", indexname, index);
+		} //end if
+		return "";
+	} //end if
+	return stringindex[index];
+} //end of the function AAS_StringFromIndex
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int AAS_IndexFromString(char *indexname, char *stringindex[], int numindexes, char *string)
+{
+	int i;
+	if (!aasworld.indexessetup)
+	{
+		botimport.Print(PRT_ERROR, "%s: index not setup \"%s\"\n", indexname, string);
+		return 0;
+	} //end if
+	for (i = 0; i < numindexes; i++)
+	{
+		if (!stringindex[i]) continue;
+		if (!Q_stricmp(stringindex[i], string)) return i;
+	} //end for
+	return 0;
+} //end of the function AAS_IndexFromString
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+char *AAS_ModelFromIndex(int index)
+{
+	return AAS_StringFromIndex("ModelFromIndex", &aasworld.configstrings[CS_MODELS], MAX_MODELS, index);
+} //end of the function AAS_ModelFromIndex
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int AAS_IndexFromModel(char *modelname)
+{
+	return AAS_IndexFromString("IndexFromModel", &aasworld.configstrings[CS_MODELS], MAX_MODELS, modelname);
+} //end of the function AAS_IndexFromModel
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void AAS_UpdateStringIndexes(int numconfigstrings, char *configstrings[])
+{
+	int i;
+	//set string pointers and copy the strings
+	for (i = 0; i < numconfigstrings; i++)
+	{
+		if (configstrings[i])
+		{
+			//if (aasworld.configstrings[i]) FreeMemory(aasworld.configstrings[i]);
+			aasworld.configstrings[i] = (char *) GetMemory(strlen(configstrings[i]) + 1);
+			strcpy(aasworld.configstrings[i], configstrings[i]);
+		} //end if
+	} //end for
+	aasworld.indexessetup = qtrue;
+} //end of the function AAS_UpdateStringIndexes
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int AAS_Loaded(void)
+{
+	return aasworld.loaded;
+} //end of the function AAS_Loaded
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int AAS_Initialized(void)
+{
+	return aasworld.initialized;
+} //end of the function AAS_Initialized
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void AAS_SetInitialized(void)
+{
+	aasworld.initialized = qtrue;
+	botimport.Print(PRT_MESSAGE, "AAS initialized.\n");
+#ifdef DEBUG
+	//create all the routing cache
+	//AAS_CreateAllRoutingCache();
+	//
+	//AAS_RoutingInfo();
+#endif
+} //end of the function AAS_SetInitialized
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void AAS_ContinueInit(float time)
+{
+	//if no AAS file loaded
+	if (!aasworld.loaded) return;
+	//if AAS is already initialized
+	if (aasworld.initialized) return;
+	//calculate reachability, if not finished return
+	if (AAS_ContinueInitReachability(time)) return;
+	//initialize clustering for the new map
+	AAS_InitClustering();
+	//if reachability has been calculated and an AAS file should be written
+	//or there is a forced data optimization
+	if (aasworld.savefile || ((int)LibVarGetValue("forcewrite")))
+	{
+		//optimize the AAS data
+		if ((int)LibVarValue("aasoptimize", "0")) AAS_Optimize();
+		//save the AAS file
+		if (AAS_WriteAASFile(aasworld.filename))
+		{
+			botimport.Print(PRT_MESSAGE, "%s written succesfully\n", aasworld.filename);
+		} //end if
+		else
+		{
+			botimport.Print(PRT_ERROR, "couldn't write %s\n", aasworld.filename);
+		} //end else
+	} //end if
+	//initialize the routing
+	AAS_InitRouting();
+	//at this point AAS is initialized
+	AAS_SetInitialized();
+} //end of the function AAS_ContinueInit
+//===========================================================================
+// called at the start of every frame
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int AAS_StartFrame(float time)
+{
+	aasworld.time = time;
+	//unlink all entities that were not updated last frame
+	AAS_UnlinkInvalidEntities();
+	//invalidate the entities
+	AAS_InvalidateEntities();
+	//initialize AAS
+	AAS_ContinueInit(time);
+	//
+	aasworld.frameroutingupdates = 0;
+	//
+	if (bot_developer)
+	{
+		if (LibVarGetValue("showcacheupdates"))
+		{
+			AAS_RoutingInfo();
+			LibVarSet("showcacheupdates", "0");
+		} //end if
+		if (LibVarGetValue("showmemoryusage"))
+		{
+			PrintUsedMemorySize();
+			LibVarSet("showmemoryusage", "0");
+		} //end if
+		if (LibVarGetValue("memorydump"))
+		{
+			PrintMemoryLabels();
+			LibVarSet("memorydump", "0");
+		} //end if
+	} //end if
+	//
+	if (saveroutingcache->value)
+	{
+		AAS_WriteRouteCache();
+		LibVarSet("saveroutingcache", "0");
+	} //end if
+	//
+	aasworld.numframes++;
+	return BLERR_NOERROR;
+} //end of the function AAS_StartFrame
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+float AAS_Time(void)
+{
+	return aasworld.time;
+} //end of the function AAS_Time
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+void AAS_ProjectPointOntoVector( vec3_t point, vec3_t vStart, vec3_t vEnd, vec3_t vProj )
+{
+	vec3_t pVec, vec;
+
+	VectorSubtract( point, vStart, pVec );
+	VectorSubtract( vEnd, vStart, vec );
+	VectorNormalize( vec );
+	// project onto the directional vector for this segment
+	VectorMA( vStart, DotProduct( pVec, vec ), vec, vProj );
+} //end of the function AAS_ProjectPointOntoVector
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int AAS_LoadFiles(const char *mapname)
+{
+	int errnum;
+	char aasfile[MAX_PATH];
+//	char bspfile[MAX_PATH];
+
+	strcpy(aasworld.mapname, mapname);
+	//NOTE: first reset the entity links into the AAS areas and BSP leaves
+	// the AAS link heap and BSP link heap are reset after respectively the
+	// AAS file and BSP file are loaded
+	AAS_ResetEntityLinks();
+	// load bsp info
+	AAS_LoadBSPFile();
+
+	//load the aas file
+	Com_sprintf(aasfile, MAX_PATH, "maps/%s.aas", mapname);
+	errnum = AAS_LoadAASFile(aasfile);
+	if (errnum != BLERR_NOERROR)
+		return errnum;
+
+	botimport.Print(PRT_MESSAGE, "loaded %s\n", aasfile);
+	strncpy(aasworld.filename, aasfile, MAX_PATH);
+	return BLERR_NOERROR;
+} //end of the function AAS_LoadFiles
+//===========================================================================
+// called everytime a map changes
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int AAS_LoadMap(const char *mapname)
+{
+	int	errnum;
+
+	//if no mapname is provided then the string indexes are updated
+	if (!mapname)
+	{
+		return 0;
+	} //end if
+	//
+	aasworld.initialized = qfalse;
+	//NOTE: free the routing caches before loading a new map because
+	// to free the caches the old number of areas, number of clusters
+	// and number of areas in a clusters must be available
+	AAS_FreeRoutingCaches();
+	//load the map
+	errnum = AAS_LoadFiles(mapname);
+	if (errnum != BLERR_NOERROR)
+	{
+		aasworld.loaded = qfalse;
+		return errnum;
+	} //end if
+	//
+	AAS_InitSettings();
+	//initialize the AAS link heap for the new map
+	AAS_InitAASLinkHeap();
+	//initialize the AAS linked entities for the new map
+	AAS_InitAASLinkedEntities();
+	//initialize reachability for the new map
+	AAS_InitReachability();
+	//initialize the alternative routing
+	AAS_InitAlternativeRouting();
+	//everything went ok
+	return 0;
+} //end of the function AAS_LoadMap
+//===========================================================================
+// called when the library is first loaded
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int AAS_Setup(void)
+{
+	aasworld.maxclients = (int) LibVarValue("maxclients", "128");
+	aasworld.maxentities = (int) LibVarValue("maxentities", "1024");
+	// as soon as it's set to 1 the routing cache will be saved
+	saveroutingcache = LibVar("saveroutingcache", "0");
+	//allocate memory for the entities
+	if (aasworld.entities) FreeMemory(aasworld.entities);
+	aasworld.entities = (aas_entity_t *) GetClearedHunkMemory(aasworld.maxentities * sizeof(aas_entity_t));
+	//invalidate all the entities
+	AAS_InvalidateEntities();
+	//force some recalculations
+	//LibVarSet("forceclustering", "1");			//force clustering calculation
+	//LibVarSet("forcereachability", "1");		//force reachability calculation
+	aasworld.numframes = 0;
+	return BLERR_NOERROR;
+} //end of the function AAS_Setup
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void AAS_Shutdown(void)
+{
+	AAS_ShutdownAlternativeRouting();
+	//
+	AAS_DumpBSPData();
+	//free routing caches
+	AAS_FreeRoutingCaches();
+	//free aas link heap
+	AAS_FreeAASLinkHeap();
+	//free aas linked entities
+	AAS_FreeAASLinkedEntities();
+	//free the aas data
+	AAS_DumpAASData();
+	//free the entities
+	if (aasworld.entities) FreeMemory(aasworld.entities);
+	//clear the aasworld structure
+	Com_Memset(&aasworld, 0, sizeof(aas_t));
+	//aas has not been initialized
+	aasworld.initialized = qfalse;
+	//NOTE: as soon as a new .bsp file is loaded the .bsp file memory is
+	// freed an reallocated, so there's no need to free that memory here
+	//print shutdown
+//	botimport.Print(PRT_MESSAGE, "AAS shutdown.\n");
+} //end of the function AAS_Shutdown
diff --git a/codemp/botlib/be_aas_main.h b/codemp/botlib/be_aas_main.h
new file mode 100644
index 0000000..76cba60
--- /dev/null
+++ b/codemp/botlib/be_aas_main.h
@@ -0,0 +1,44 @@
+
+/*****************************************************************************
+ * name:		be_aas_main.h
+ *
+ * desc:		AAS
+ *
+ * $Archive: /source/code/botlib/be_aas_main.h $
+ * $Author: Mrelusive $ 
+ * $Revision: 2 $
+ * $Modtime: 10/05/99 3:32p $
+ * $Date: 10/05/99 3:42p $
+ *
+ *****************************************************************************/
+
+#ifdef AASINTERN
+
+extern aas_t aasworld;
+
+//AAS error message
+void QDECL AAS_Error(char *fmt, ...);
+//set AAS initialized
+void AAS_SetInitialized(void);
+//setup AAS with the given number of entities and clients
+int AAS_Setup(void);
+//shutdown AAS
+void AAS_Shutdown(void);
+//start a new map
+int AAS_LoadMap(const char *mapname);
+//start a new time frame
+int AAS_StartFrame(float time);
+#endif //AASINTERN
+
+//returns true if AAS is initialized
+int AAS_Initialized(void);
+//returns true if the AAS file is loaded
+int AAS_Loaded(void);
+//returns the model name from the given index
+char *AAS_ModelFromIndex(int index);
+//returns the index from the given model name
+int AAS_IndexFromModel(char *modelname);
+//returns the current time
+float AAS_Time(void);
+//
+void AAS_ProjectPointOntoVector( vec3_t point, vec3_t vStart, vec3_t vEnd, vec3_t vProj );
diff --git a/codemp/botlib/be_aas_move.cpp b/codemp/botlib/be_aas_move.cpp
new file mode 100644
index 0000000..4598e61
--- /dev/null
+++ b/codemp/botlib/be_aas_move.cpp
@@ -0,0 +1,1084 @@
+
+/*****************************************************************************
+ * name:		be_aas_move.c
+ *
+ * desc:		AAS
+ *
+ * $Archive: /MissionPack/code/botlib/be_aas_move.c $
+ * $Author: Ttimo $ 
+ * $Revision: 9 $
+ * $Modtime: 4/13/01 4:45p $
+ * $Date: 4/13/01 4:45p $
+ *
+ *****************************************************************************/
+
+#include "../game/q_shared.h"
+#include "l_memory.h"
+#include "l_script.h"
+#include "l_precomp.h"
+#include "l_struct.h"
+#include "l_libvar.h"
+#include "aasfile.h"
+#include "../game/botlib.h"
+#include "../game/be_aas.h"
+#include "be_aas_funcs.h"
+#include "be_aas_def.h"
+
+extern botlib_import_t botimport;
+
+aas_settings_t aassettings;
+
+//#define AAS_MOVE_DEBUG
+
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+int AAS_DropToFloor(vec3_t origin, vec3_t mins, vec3_t maxs)
+{
+	vec3_t end;
+	bsp_trace_t trace;
+
+	VectorCopy(origin, end);
+	end[2] -= 100;
+	trace = AAS_Trace(origin, mins, maxs, end, 0, CONTENTS_SOLID);
+	if (trace.startsolid) return qfalse;
+	VectorCopy(trace.endpos, origin);
+	return qtrue;
+} //end of the function AAS_DropToFloor
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+void AAS_InitSettings(void)
+{
+	aassettings.phys_gravitydirection[0]	= 0;
+	aassettings.phys_gravitydirection[1]	= 0;
+	aassettings.phys_gravitydirection[2]	= -1;
+	aassettings.phys_friction				= LibVarValue("phys_friction", "6");
+	aassettings.phys_stopspeed				= LibVarValue("phys_stopspeed", "100");
+	aassettings.phys_gravity				= LibVarValue("phys_gravity", "800");
+	aassettings.phys_waterfriction			= LibVarValue("phys_waterfriction", "1");
+	aassettings.phys_watergravity			= LibVarValue("phys_watergravity", "400");
+	aassettings.phys_maxvelocity			= LibVarValue("phys_maxvelocity", "320");
+	aassettings.phys_maxwalkvelocity		= LibVarValue("phys_maxwalkvelocity", "320");
+	aassettings.phys_maxcrouchvelocity		= LibVarValue("phys_maxcrouchvelocity", "100");
+	aassettings.phys_maxswimvelocity		= LibVarValue("phys_maxswimvelocity", "150");
+	aassettings.phys_walkaccelerate			= LibVarValue("phys_walkaccelerate", "10");
+	aassettings.phys_airaccelerate			= LibVarValue("phys_airaccelerate", "1");
+	aassettings.phys_swimaccelerate			= LibVarValue("phys_swimaccelerate", "4");
+	aassettings.phys_maxstep				= LibVarValue("phys_maxstep", "19");
+	aassettings.phys_maxsteepness			= LibVarValue("phys_maxsteepness", "0.7");
+	aassettings.phys_maxwaterjump			= LibVarValue("phys_maxwaterjump", "18");
+	aassettings.phys_maxbarrier				= LibVarValue("phys_maxbarrier", "33");
+	aassettings.phys_jumpvel				= LibVarValue("phys_jumpvel", "270");
+	aassettings.phys_falldelta5				= LibVarValue("phys_falldelta5", "40");
+	aassettings.phys_falldelta10			= LibVarValue("phys_falldelta10", "60");
+	aassettings.rs_waterjump				= LibVarValue("rs_waterjump", "400");
+	aassettings.rs_teleport					= LibVarValue("rs_teleport", "50");
+	aassettings.rs_barrierjump				= LibVarValue("rs_barrierjump", "100");
+	aassettings.rs_startcrouch				= LibVarValue("rs_startcrouch", "300");
+	aassettings.rs_startgrapple				= LibVarValue("rs_startgrapple", "500");
+	aassettings.rs_startwalkoffledge		= LibVarValue("rs_startwalkoffledge", "70");
+	aassettings.rs_startjump				= LibVarValue("rs_startjump", "300");
+	aassettings.rs_rocketjump				= LibVarValue("rs_rocketjump", "500");
+	aassettings.rs_bfgjump					= LibVarValue("rs_bfgjump", "500");
+	aassettings.rs_jumppad					= LibVarValue("rs_jumppad", "250");
+	aassettings.rs_aircontrolledjumppad		= LibVarValue("rs_aircontrolledjumppad", "300");
+	aassettings.rs_funcbob					= LibVarValue("rs_funcbob", "300");
+	aassettings.rs_startelevator			= LibVarValue("rs_startelevator", "50");
+	aassettings.rs_falldamage5				= LibVarValue("rs_falldamage5", "300");
+	aassettings.rs_falldamage10				= LibVarValue("rs_falldamage10", "500");
+	aassettings.rs_maxfallheight			= LibVarValue("rs_maxfallheight", "0");
+	aassettings.rs_maxjumpfallheight		= LibVarValue("rs_maxjumpfallheight", "450");
+} //end of the function AAS_InitSettings
+//===========================================================================
+// returns qtrue if the bot is against a ladder
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+int AAS_AgainstLadder(vec3_t origin)
+{
+	int areanum, i, facenum, side;
+	vec3_t org;
+	aas_plane_t *plane;
+	aas_face_t *face;
+	aas_area_t *area;
+
+	VectorCopy(origin, org);
+	areanum = AAS_PointAreaNum(org);
+	if (!areanum)
+	{
+		org[0] += 1;
+		areanum = AAS_PointAreaNum(org);
+		if (!areanum)
+		{
+			org[1] += 1;
+			areanum = AAS_PointAreaNum(org);
+			if (!areanum)
+			{
+				org[0] -= 2;
+				areanum = AAS_PointAreaNum(org);
+				if (!areanum)
+				{
+					org[1] -= 2;
+					areanum = AAS_PointAreaNum(org);
+				} //end if
+			} //end if
+		} //end if
+	} //end if
+	//if in solid... wrrr shouldn't happen
+	if (!areanum) return qfalse;
+	//if not in a ladder area
+	if (!(aasworld.areasettings[areanum].areaflags & AREA_LADDER)) return qfalse;
+	//if a crouch only area
+	if (!(aasworld.areasettings[areanum].presencetype & PRESENCE_NORMAL)) return qfalse;
+	//
+	area = &aasworld.areas[areanum];
+	for (i = 0; i < area->numfaces; i++)
+	{
+		facenum = aasworld.faceindex[area->firstface + i];
+		side = facenum < 0;
+		face = &aasworld.faces[abs(facenum)];
+		//if the face isn't a ladder face
+		if (!(face->faceflags & FACE_LADDER)) continue;
+		//get the plane the face is in
+		plane = &aasworld.planes[face->planenum ^ side];
+		//if the origin is pretty close to the plane
+		if (abs(DotProduct(plane->normal, origin) - plane->dist) < 3)
+		{
+			if (AAS_PointInsideFace(abs(facenum), origin, 0.1f)) return qtrue;
+		} //end if
+	} //end for
+	return qfalse;
+} //end of the function AAS_AgainstLadder
+//===========================================================================
+// returns qtrue if the bot is on the ground
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+int AAS_OnGround(vec3_t origin, int presencetype, int passent)
+{
+	aas_trace_t trace;
+	vec3_t end, up = {0, 0, 1};
+	aas_plane_t *plane;
+
+	VectorCopy(origin, end);
+	end[2] -= 10;
+
+	trace = AAS_TraceClientBBox(origin, end, presencetype, passent);
+
+	//if in solid
+	if (trace.startsolid) return qfalse;
+	//if nothing hit at all
+	if (trace.fraction >= 1.0) return qfalse;
+	//if too far from the hit plane
+	if (origin[2] - trace.endpos[2] > 10) return qfalse;
+	//check if the plane isn't too steep
+	plane = AAS_PlaneFromNum(trace.planenum);
+	if (DotProduct(plane->normal, up) < aassettings.phys_maxsteepness) return qfalse;
+	//the bot is on the ground
+	return qtrue;
+} //end of the function AAS_OnGround
+//===========================================================================
+// returns qtrue if a bot at the given position is swimming
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int AAS_Swimming(vec3_t origin)
+{
+	vec3_t testorg;
+
+	VectorCopy(origin, testorg);
+	testorg[2] -= 2;
+	if (AAS_PointContents(testorg) & (CONTENTS_LAVA|CONTENTS_SLIME|CONTENTS_WATER)) return qtrue;
+	return qfalse;
+} //end of the function AAS_Swimming
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+static vec3_t VEC_UP			= {0, -1,  0};
+static vec3_t MOVEDIR_UP		= {0,  0,  1};
+static vec3_t VEC_DOWN		= {0, -2,  0};
+static vec3_t MOVEDIR_DOWN	= {0,  0, -1};
+
+void AAS_SetMovedir(vec3_t angles, vec3_t movedir)
+{
+	if (VectorCompare(angles, VEC_UP))
+	{
+		VectorCopy(MOVEDIR_UP, movedir);
+	} //end if
+	else if (VectorCompare(angles, VEC_DOWN))
+	{
+		VectorCopy(MOVEDIR_DOWN, movedir);
+	} //end else if
+	else
+	{
+		AngleVectors(angles, movedir, NULL, NULL);
+	} //end else
+} //end of the function AAS_SetMovedir
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void AAS_JumpReachRunStart(aas_reachability_t *reach, vec3_t runstart)
+{
+	vec3_t hordir, start, cmdmove;
+	aas_clientmove_t move;
+
+	//
+	hordir[0] = reach->start[0] - reach->end[0];
+	hordir[1] = reach->start[1] - reach->end[1];
+	hordir[2] = 0;
+	VectorNormalize(hordir);
+	//start point
+	VectorCopy(reach->start, start);
+	start[2] += 1;
+	//get command movement
+	VectorScale(hordir, 400, cmdmove);
+	//
+	AAS_PredictClientMovement(&move, -1, start, PRESENCE_NORMAL, qtrue,
+								vec3_origin, cmdmove, 1, 2, 0.1f,
+								SE_ENTERWATER|SE_ENTERSLIME|SE_ENTERLAVA|
+								SE_HITGROUNDDAMAGE|SE_GAP, 0, qfalse);
+	VectorCopy(move.endpos, runstart);
+	//don't enter slime or lava and don't fall from too high
+	if (move.stopevent & (SE_ENTERSLIME|SE_ENTERLAVA|SE_HITGROUNDDAMAGE))
+	{
+		VectorCopy(start, runstart);
+	} //end if
+} //end of the function AAS_JumpReachRunStart
+//===========================================================================
+// returns the Z velocity when rocket jumping at the origin
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+float AAS_WeaponJumpZVelocity(vec3_t origin, float radiusdamage)
+{
+	vec3_t kvel, v, start, end, forward, right, viewangles, dir;
+	float	mass, knockback, points;
+	vec3_t rocketoffset = {8, 8, -8};
+	vec3_t botmins = {-16, -16, -24};
+	vec3_t botmaxs = {16, 16, 32};
+	bsp_trace_t bsptrace;
+
+	//look down (90 degrees)
+	viewangles[PITCH] = 90;
+	viewangles[YAW] = 0;
+	viewangles[ROLL] = 0;
+	//get the start point shooting from
+	VectorCopy(origin, start);
+	start[2] += 8; //view offset Z
+	AngleVectors(viewangles, forward, right, NULL);
+	start[0] += forward[0] * rocketoffset[0] + right[0] * rocketoffset[1];
+	start[1] += forward[1] * rocketoffset[0] + right[1] * rocketoffset[1];
+	start[2] += forward[2] * rocketoffset[0] + right[2] * rocketoffset[1] + rocketoffset[2];
+	//end point of the trace
+	VectorMA(start, 500, forward, end);
+	//trace a line to get the impact point
+	bsptrace = AAS_Trace(start, NULL, NULL, end, 1, CONTENTS_SOLID);
+	//calculate the damage the bot will get from the rocket impact
+	VectorAdd(botmins, botmaxs, v);
+	VectorMA(origin, 0.5, v, v);
+	VectorSubtract(bsptrace.endpos, v, v);
+	//
+	points = radiusdamage - 0.5 * VectorLength(v);
+	if (points < 0) points = 0;
+	//the owner of the rocket gets half the damage
+	points *= 0.5;
+	//mass of the bot (p_client.c: PutClientInServer)
+	mass = 200;
+	//knockback is the same as the damage points
+	knockback = points;
+	//direction of the damage (from trace.endpos to bot origin)
+	VectorSubtract(origin, bsptrace.endpos, dir);
+	VectorNormalize(dir);
+	//damage velocity
+	VectorScale(dir, 1600.0 * (float)knockback / mass, kvel);	//the rocket jump hack...
+	//rocket impact velocity + jump velocity
+	return kvel[2] + aassettings.phys_jumpvel;
+} //end of the function AAS_WeaponJumpZVelocity
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+float AAS_RocketJumpZVelocity(vec3_t origin)
+{
+	//rocket radius damage is 120 (p_weapon.c: Weapon_RocketLauncher_Fire)
+	return AAS_WeaponJumpZVelocity(origin, 120);
+} //end of the function AAS_RocketJumpZVelocity
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+float AAS_BFGJumpZVelocity(vec3_t origin)
+{
+	//bfg radius damage is 1000 (p_weapon.c: weapon_bfg_fire)
+	return AAS_WeaponJumpZVelocity(origin, 120);
+} //end of the function AAS_BFGJumpZVelocity
+//===========================================================================
+// applies ground friction to the given velocity
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+void AAS_Accelerate(vec3_t velocity, float frametime, vec3_t wishdir, float wishspeed, float accel)
+{
+	// q2 style
+	int			i;
+	float		addspeed, accelspeed, currentspeed;
+
+	currentspeed = DotProduct(velocity, wishdir);
+	addspeed = wishspeed - currentspeed;
+	if (addspeed <= 0) {
+		return;
+	}
+	accelspeed = accel*frametime*wishspeed;
+	if (accelspeed > addspeed) {
+		accelspeed = addspeed;
+	}
+	
+	for (i=0 ; i<3 ; i++) {
+		velocity[i] += accelspeed*wishdir[i];	
+	}
+} //end of the function AAS_Accelerate
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+void AAS_AirControl(vec3_t start, vec3_t end, vec3_t velocity, vec3_t cmdmove)
+{
+	vec3_t dir;
+
+	VectorSubtract(end, start, dir);
+} //end of the function AAS_AirControl
+//===========================================================================
+// applies ground friction to the given velocity
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+void AAS_ApplyFriction(vec3_t vel, float friction, float stopspeed,
+													float frametime)
+{
+	float speed, control, newspeed;
+
+	//horizontal speed
+	speed = sqrt(vel[0] * vel[0] + vel[1] * vel[1]);
+	if (speed)
+	{
+		control = speed < stopspeed ? stopspeed : speed;
+		newspeed = speed - frametime * control * friction;
+		if (newspeed < 0) newspeed = 0;
+		newspeed /= speed;
+		vel[0] *= newspeed;
+		vel[1] *= newspeed;
+	} //end if
+} //end of the function AAS_ApplyFriction
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+int AAS_ClipToBBox(aas_trace_t *trace, vec3_t start, vec3_t end, int presencetype, vec3_t mins, vec3_t maxs)
+{
+	int i, j, side;
+	float front, back, frac, planedist;
+	vec3_t bboxmins, bboxmaxs, absmins, absmaxs, dir, mid;
+
+	AAS_PresenceTypeBoundingBox(presencetype, bboxmins, bboxmaxs);
+	VectorSubtract(mins, bboxmaxs, absmins);
+	VectorSubtract(maxs, bboxmins, absmaxs);
+	//
+	VectorCopy(end, trace->endpos);
+	trace->fraction = 1;
+	for (i = 0; i < 3; i++)
+	{
+		if (start[i] < absmins[i] && end[i] < absmins[i]) return qfalse;
+		if (start[i] > absmaxs[i] && end[i] > absmaxs[i]) return qfalse;
+	} //end for
+	//check bounding box collision
+	VectorSubtract(end, start, dir);
+	frac = 1;
+	for (i = 0; i < 3; i++)
+	{
+		//get plane to test collision with for the current axis direction
+		if (dir[i] > 0) planedist = absmins[i];
+		else planedist = absmaxs[i];
+		//calculate collision fraction
+		front = start[i] - planedist;
+		back = end[i] - planedist;
+		frac = front / (front-back);
+		//check if between bounding planes of next axis
+		side = i + 1;
+		if (side > 2) side = 0;
+		mid[side] = start[side] + dir[side] * frac;
+		if (mid[side] > absmins[side] && mid[side] < absmaxs[side])
+		{
+			//check if between bounding planes of next axis
+			side++;
+			if (side > 2) side = 0;
+			mid[side] = start[side] + dir[side] * frac;
+			if (mid[side] > absmins[side] && mid[side] < absmaxs[side])
+			{
+				mid[i] = planedist;
+				break;
+			} //end if
+		} //end if
+	} //end for
+	//if there was a collision
+	if (i != 3)
+	{
+		trace->startsolid = qfalse;
+		trace->fraction = frac;
+		trace->ent = 0;
+		trace->planenum = 0;
+		trace->area = 0;
+		trace->lastarea = 0;
+		//trace endpos
+		for (j = 0; j < 3; j++) trace->endpos[j] = start[j] + dir[j] * frac;
+		return qtrue;
+	} //end if
+	return qfalse;
+} //end of the function AAS_ClipToBBox
+//===========================================================================
+// predicts the movement
+// assumes regular bounding box sizes
+// NOTE: out of water jumping is not included
+// NOTE: grappling hook is not included
+//
+// Parameter:			origin			: origin to start with
+//						presencetype	: presence type to start with
+//						velocity		: velocity to start with
+//						cmdmove			: client command movement
+//						cmdframes		: number of frame cmdmove is valid
+//						maxframes		: maximum number of predicted frames
+//						frametime		: duration of one predicted frame
+//						stopevent		: events that stop the prediction
+//						stopareanum		: stop as soon as entered this area
+// Returns:				aas_clientmove_t
+// Changes Globals:		-
+//===========================================================================
+int AAS_ClientMovementPrediction(struct aas_clientmove_s *move,
+								int entnum, vec3_t origin,
+								int presencetype, int onground,
+								vec3_t velocity, vec3_t cmdmove,
+								int cmdframes,
+								int maxframes, float frametime,
+								int stopevent, int stopareanum,
+								vec3_t mins, vec3_t maxs, int visualize)
+{
+	float phys_friction, phys_stopspeed, phys_gravity, phys_waterfriction;
+	float phys_watergravity;
+	float phys_walkaccelerate, phys_airaccelerate, phys_swimaccelerate;
+	float phys_maxwalkvelocity, phys_maxcrouchvelocity, phys_maxswimvelocity;
+	float phys_maxstep, phys_maxsteepness, phys_jumpvel, friction;
+	float gravity, delta, maxvel, wishspeed, accelerate;
+	//float velchange, newvel;
+	int n, i, j, pc, step, swimming, ax, crouch, event, jump_frame, areanum;
+	int areas[20], numareas;
+	vec3_t points[20];
+	vec3_t org, end, feet, start, stepend, lastorg, wishdir;
+	vec3_t frame_test_vel, old_frame_test_vel, left_test_vel;
+	vec3_t up = {0, 0, 1};
+	aas_plane_t *plane, *plane2;
+	aas_trace_t trace, steptrace;
+	
+	if (frametime <= 0) frametime = 0.1f;
+	//
+	phys_friction = aassettings.phys_friction;
+	phys_stopspeed = aassettings.phys_stopspeed;
+	phys_gravity = aassettings.phys_gravity;
+	phys_waterfriction = aassettings.phys_waterfriction;
+	phys_watergravity = aassettings.phys_watergravity;
+	phys_maxwalkvelocity = aassettings.phys_maxwalkvelocity;// * frametime;
+	phys_maxcrouchvelocity = aassettings.phys_maxcrouchvelocity;// * frametime;
+	phys_maxswimvelocity = aassettings.phys_maxswimvelocity;// * frametime;
+	phys_walkaccelerate = aassettings.phys_walkaccelerate;
+	phys_airaccelerate = aassettings.phys_airaccelerate;
+	phys_swimaccelerate = aassettings.phys_swimaccelerate;
+	phys_maxstep = aassettings.phys_maxstep;
+	phys_maxsteepness = aassettings.phys_maxsteepness;
+	phys_jumpvel = aassettings.phys_jumpvel * frametime;
+	//
+	Com_Memset(move, 0, sizeof(aas_clientmove_t));
+	Com_Memset(&trace, 0, sizeof(aas_trace_t));
+	//start at the current origin
+	VectorCopy(origin, org);
+	org[2] += 0.25;
+	//velocity to test for the first frame
+	VectorScale(velocity, frametime, frame_test_vel);
+	//
+	jump_frame = -1;
+	//predict a maximum of 'maxframes' ahead
+	for (n = 0; n < maxframes; n++)
+	{
+		swimming = AAS_Swimming(org);
+		//get gravity depending on swimming or not
+		gravity = swimming ? phys_watergravity : phys_gravity;
+		//apply gravity at the START of the frame
+		frame_test_vel[2] = frame_test_vel[2] - (gravity * 0.1 * frametime);
+		//if on the ground or swimming
+		if (onground || swimming)
+		{
+			friction = swimming ? phys_friction : phys_waterfriction;
+			//apply friction
+			VectorScale(frame_test_vel, 1/frametime, frame_test_vel);
+			AAS_ApplyFriction(frame_test_vel, friction, phys_stopspeed, frametime);
+			VectorScale(frame_test_vel, frametime, frame_test_vel);
+		} //end if
+		crouch = qfalse;
+		//apply command movement
+		if (n < cmdframes)
+		{
+			ax = 0;
+			maxvel = phys_maxwalkvelocity;
+			accelerate = phys_airaccelerate;
+			VectorCopy(cmdmove, wishdir);
+			if (onground)
+			{
+				if (cmdmove[2] < -300)
+				{
+					crouch = qtrue;
+					maxvel = phys_maxcrouchvelocity;
+				} //end if
+				//if not swimming and upmove is positive then jump
+				if (!swimming && cmdmove[2] > 1)
+				{
+					//jump velocity minus the gravity for one frame + 5 for safety
+					frame_test_vel[2] = phys_jumpvel - (gravity * 0.1 * frametime) + 5;
+					jump_frame = n;
+					//jumping so air accelerate
+					accelerate = phys_airaccelerate;
+				} //end if
+				else
+				{
+					accelerate = phys_walkaccelerate;
+				} //end else
+				ax = 2;
+			} //end if
+			if (swimming)
+			{
+				maxvel = phys_maxswimvelocity;
+				accelerate = phys_swimaccelerate;
+				ax = 3;
+			} //end if
+			else
+			{
+				wishdir[2] = 0;
+			} //end else
+			//
+			wishspeed = VectorNormalize(wishdir);
+			if (wishspeed > maxvel) wishspeed = maxvel;
+			VectorScale(frame_test_vel, 1/frametime, frame_test_vel);
+			AAS_Accelerate(frame_test_vel, frametime, wishdir, wishspeed, accelerate);
+			VectorScale(frame_test_vel, frametime, frame_test_vel);
+			/*
+			for (i = 0; i < ax; i++)
+			{
+				velchange = (cmdmove[i] * frametime) - frame_test_vel[i];
+				if (velchange > phys_maxacceleration) velchange = phys_maxacceleration;
+				else if (velchange < -phys_maxacceleration) velchange = -phys_maxacceleration;
+				newvel = frame_test_vel[i] + velchange;
+				//
+				if (frame_test_vel[i] <= maxvel && newvel > maxvel) frame_test_vel[i] = maxvel;
+				else if (frame_test_vel[i] >= -maxvel && newvel < -maxvel) frame_test_vel[i] = -maxvel;
+				else frame_test_vel[i] = newvel;
+			} //end for
+			*/
+		} //end if
+		if (crouch)
+		{
+			presencetype = PRESENCE_CROUCH;
+		} //end if
+		else if (presencetype == PRESENCE_CROUCH)
+		{
+			if (AAS_PointPresenceType(org) & PRESENCE_NORMAL)
+			{
+				presencetype = PRESENCE_NORMAL;
+			} //end if
+		} //end else
+		//save the current origin
+		VectorCopy(org, lastorg);
+		//move linear during one frame
+		VectorCopy(frame_test_vel, left_test_vel);
+		j = 0;
+		do
+		{
+			VectorAdd(org, left_test_vel, end);
+			//trace a bounding box
+			trace = AAS_TraceClientBBox(org, end, presencetype, entnum);
+			//
+//#ifdef AAS_MOVE_DEBUG
+			if (visualize)
+			{
+				if (trace.startsolid) botimport.Print(PRT_MESSAGE, "PredictMovement: start solid\n");
+				AAS_DebugLine(org, trace.endpos, LINECOLOR_RED);
+			} //end if
+//#endif //AAS_MOVE_DEBUG
+			//
+			if (stopevent & (SE_ENTERAREA|SE_TOUCHJUMPPAD|SE_TOUCHTELEPORTER|SE_TOUCHCLUSTERPORTAL))
+			{
+				numareas = AAS_TraceAreas(org, trace.endpos, areas, points, 20);
+				for (i = 0; i < numareas; i++)
+				{
+					if (stopevent & SE_ENTERAREA)
+					{
+						if (areas[i] == stopareanum)
+						{
+							VectorCopy(points[i], move->endpos);
+							VectorScale(frame_test_vel, 1/frametime, move->velocity);
+							move->endarea = areas[i];
+							move->trace = trace;
+							move->stopevent = SE_ENTERAREA;
+							move->presencetype = presencetype;
+							move->endcontents = 0;
+							move->time = n * frametime;
+							move->frames = n;
+							return qtrue;
+						} //end if
+					} //end if
+					//NOTE: if not the first frame
+					if ((stopevent & SE_TOUCHJUMPPAD) && n)
+					{
+						if (aasworld.areasettings[areas[i]].contents & AREACONTENTS_JUMPPAD)
+						{
+							VectorCopy(points[i], move->endpos);
+							VectorScale(frame_test_vel, 1/frametime, move->velocity);
+							move->endarea = areas[i];
+							move->trace = trace;
+							move->stopevent = SE_TOUCHJUMPPAD;
+							move->presencetype = presencetype;
+							move->endcontents = 0;
+							move->time = n * frametime;
+							move->frames = n;
+							return qtrue;
+						} //end if
+					} //end if
+					if (stopevent & SE_TOUCHTELEPORTER)
+					{
+						if (aasworld.areasettings[areas[i]].contents & AREACONTENTS_TELEPORTER)
+						{
+							VectorCopy(points[i], move->endpos);
+							move->endarea = areas[i];
+							VectorScale(frame_test_vel, 1/frametime, move->velocity);
+							move->trace = trace;
+							move->stopevent = SE_TOUCHTELEPORTER;
+							move->presencetype = presencetype;
+							move->endcontents = 0;
+							move->time = n * frametime;
+							move->frames = n;
+							return qtrue;
+						} //end if
+					} //end if
+					if (stopevent & SE_TOUCHCLUSTERPORTAL)
+					{
+						if (aasworld.areasettings[areas[i]].contents & AREACONTENTS_CLUSTERPORTAL)
+						{
+							VectorCopy(points[i], move->endpos);
+							move->endarea = areas[i];
+							VectorScale(frame_test_vel, 1/frametime, move->velocity);
+							move->trace = trace;
+							move->stopevent = SE_TOUCHCLUSTERPORTAL;
+							move->presencetype = presencetype;
+							move->endcontents = 0;
+							move->time = n * frametime;
+							move->frames = n;
+							return qtrue;
+						} //end if
+					} //end if
+				} //end for
+			} //end if
+			//
+			if (stopevent & SE_HITBOUNDINGBOX)
+			{
+				if (AAS_ClipToBBox(&trace, org, trace.endpos, presencetype, mins, maxs))
+				{
+					VectorCopy(trace.endpos, move->endpos);
+					move->endarea = AAS_PointAreaNum(move->endpos);
+					VectorScale(frame_test_vel, 1/frametime, move->velocity);
+					move->trace = trace;
+					move->stopevent = SE_HITBOUNDINGBOX;
+					move->presencetype = presencetype;
+					move->endcontents = 0;
+					move->time = n * frametime;
+					move->frames = n;
+					return qtrue;
+				} //end if
+			} //end if
+			//move the entity to the trace end point
+			VectorCopy(trace.endpos, org);
+			//if there was a collision
+			if (trace.fraction < 1.0)
+			{
+				//get the plane the bounding box collided with
+				plane = AAS_PlaneFromNum(trace.planenum);
+				//
+				if (stopevent & SE_HITGROUNDAREA)
+				{
+					if (DotProduct(plane->normal, up) > phys_maxsteepness)
+					{
+						VectorCopy(org, start);
+						start[2] += 0.5;
+						if (AAS_PointAreaNum(start) == stopareanum)
+						{
+							VectorCopy(start, move->endpos);
+							move->endarea = stopareanum;
+							VectorScale(frame_test_vel, 1/frametime, move->velocity);
+							move->trace = trace;
+							move->stopevent = SE_HITGROUNDAREA;
+							move->presencetype = presencetype;
+							move->endcontents = 0;
+							move->time = n * frametime;
+							move->frames = n;
+							return qtrue;
+						} //end if
+					} //end if
+				} //end if
+				//assume there's no step
+				step = qfalse;
+				//if it is a vertical plane and the bot didn't jump recently
+				if (plane->normal[2] == 0 && (jump_frame < 0 || n - jump_frame > 2))
+				{
+					//check for a step
+					VectorMA(org, -0.25, plane->normal, start);
+					VectorCopy(start, stepend);
+					start[2] += phys_maxstep;
+					steptrace = AAS_TraceClientBBox(start, stepend, presencetype, entnum);
+					//
+					if (!steptrace.startsolid)
+					{
+						plane2 = AAS_PlaneFromNum(steptrace.planenum);
+						if (DotProduct(plane2->normal, up) > phys_maxsteepness)
+						{
+							VectorSubtract(end, steptrace.endpos, left_test_vel);
+							left_test_vel[2] = 0;
+							frame_test_vel[2] = 0;
+//#ifdef AAS_MOVE_DEBUG
+							if (visualize)
+							{
+								if (steptrace.endpos[2] - org[2] > 0.125)
+								{
+									VectorCopy(org, start);
+									start[2] = steptrace.endpos[2];
+									AAS_DebugLine(org, start, LINECOLOR_BLUE);
+								} //end if
+							} //end if
+//#endif //AAS_MOVE_DEBUG
+							org[2] = steptrace.endpos[2];
+							step = qtrue;
+						} //end if
+					} //end if
+				} //end if
+				//
+				if (!step)
+				{
+					//velocity left to test for this frame is the projection
+					//of the current test velocity into the hit plane 
+					VectorMA(left_test_vel, -DotProduct(left_test_vel, plane->normal),
+										plane->normal, left_test_vel);
+					//store the old velocity for landing check
+					VectorCopy(frame_test_vel, old_frame_test_vel);
+					//test velocity for the next frame is the projection
+					//of the velocity of the current frame into the hit plane 
+					VectorMA(frame_test_vel, -DotProduct(frame_test_vel, plane->normal),
+										plane->normal, frame_test_vel);
+					//check for a landing on an almost horizontal floor
+					if (DotProduct(plane->normal, up) > phys_maxsteepness)
+					{
+						onground = qtrue;
+					} //end if
+					if (stopevent & SE_HITGROUNDDAMAGE)
+					{
+						delta = 0;
+						if (old_frame_test_vel[2] < 0 &&
+								frame_test_vel[2] > old_frame_test_vel[2] &&
+								!onground)
+						{
+							delta = old_frame_test_vel[2];
+						} //end if
+						else if (onground)
+						{
+							delta = frame_test_vel[2] - old_frame_test_vel[2];
+						} //end else
+						if (delta)
+						{
+							delta = delta * 10;
+							delta = delta * delta * 0.0001;
+							if (swimming) delta = 0;
+							// never take falling damage if completely underwater
+							/*
+							if (ent->waterlevel == 3) return;
+							if (ent->waterlevel == 2) delta *= 0.25;
+							if (ent->waterlevel == 1) delta *= 0.5;
+							*/
+							if (delta > 40)
+							{
+								VectorCopy(org, move->endpos);
+								move->endarea = AAS_PointAreaNum(org);
+								VectorCopy(frame_test_vel, move->velocity);
+								move->trace = trace;
+								move->stopevent = SE_HITGROUNDDAMAGE;
+								move->presencetype = presencetype;
+								move->endcontents = 0;
+								move->time = n * frametime;
+								move->frames = n;
+								return qtrue;
+							} //end if
+						} //end if
+					} //end if
+				} //end if
+			} //end if
+			//extra check to prevent endless loop
+			if (++j > 20) return qfalse;
+		//while there is a plane hit
+		} while(trace.fraction < 1.0);
+		//if going down
+		if (frame_test_vel[2] <= 10)
+		{
+			//check for a liquid at the feet of the bot
+			VectorCopy(org, feet);
+			feet[2] -= 22;
+			pc = AAS_PointContents(feet);
+			//get event from pc
+			event = SE_NONE;
+			if (pc & CONTENTS_LAVA) event |= SE_ENTERLAVA;
+			if (pc & CONTENTS_SLIME) event |= SE_ENTERSLIME;
+			if (pc & CONTENTS_WATER) event |= SE_ENTERWATER;
+			//
+			areanum = AAS_PointAreaNum(org);
+			if (aasworld.areasettings[areanum].contents & AREACONTENTS_LAVA)
+				event |= SE_ENTERLAVA;
+			if (aasworld.areasettings[areanum].contents & AREACONTENTS_SLIME)
+				event |= SE_ENTERSLIME;
+			if (aasworld.areasettings[areanum].contents & AREACONTENTS_WATER)
+				event |= SE_ENTERWATER;
+			//if in lava or slime
+			if (event & stopevent)
+			{
+				VectorCopy(org, move->endpos);
+				move->endarea = areanum;
+				VectorScale(frame_test_vel, 1/frametime, move->velocity);
+				move->stopevent = event & stopevent;
+				move->presencetype = presencetype;
+				move->endcontents = pc;
+				move->time = n * frametime;
+				move->frames = n;
+				return qtrue;
+			} //end if
+		} //end if
+		//
+		onground = AAS_OnGround(org, presencetype, entnum);
+		//if onground and on the ground for at least one whole frame
+		if (onground)
+		{
+			if (stopevent & SE_HITGROUND)
+			{
+				VectorCopy(org, move->endpos);
+				move->endarea = AAS_PointAreaNum(org);
+				VectorScale(frame_test_vel, 1/frametime, move->velocity);
+				move->trace = trace;
+				move->stopevent = SE_HITGROUND;
+				move->presencetype = presencetype;
+				move->endcontents = 0;
+				move->time = n * frametime;
+				move->frames = n;
+				return qtrue;
+			} //end if
+		} //end if
+		else if (stopevent & SE_LEAVEGROUND)
+		{
+			VectorCopy(org, move->endpos);
+			move->endarea = AAS_PointAreaNum(org);
+			VectorScale(frame_test_vel, 1/frametime, move->velocity);
+			move->trace = trace;
+			move->stopevent = SE_LEAVEGROUND;
+			move->presencetype = presencetype;
+			move->endcontents = 0;
+			move->time = n * frametime;
+			move->frames = n;
+			return qtrue;
+		} //end else if
+		else if (stopevent & SE_GAP)
+		{
+			aas_trace_t gaptrace;
+
+			VectorCopy(org, start);
+			VectorCopy(start, end);
+			end[2] -= 48 + aassettings.phys_maxbarrier;
+			gaptrace = AAS_TraceClientBBox(start, end, PRESENCE_CROUCH, -1);
+			//if solid is found the bot cannot walk any further and will not fall into a gap
+			if (!gaptrace.startsolid)
+			{
+				//if it is a gap (lower than one step height)
+				if (gaptrace.endpos[2] < org[2] - aassettings.phys_maxstep - 1)
+				{
+					if (!(AAS_PointContents(end) & CONTENTS_WATER))
+					{
+						VectorCopy(lastorg, move->endpos);
+						move->endarea = AAS_PointAreaNum(lastorg);
+						VectorScale(frame_test_vel, 1/frametime, move->velocity);
+						move->trace = trace;
+						move->stopevent = SE_GAP;
+						move->presencetype = presencetype;
+						move->endcontents = 0;
+						move->time = n * frametime;
+						move->frames = n;
+						return qtrue;
+					} //end if
+				} //end if
+			} //end if
+		} //end else if
+	} //end for
+	//
+	VectorCopy(org, move->endpos);
+	move->endarea = AAS_PointAreaNum(org);
+	VectorScale(frame_test_vel, 1/frametime, move->velocity);
+	move->stopevent = SE_NONE;
+	move->presencetype = presencetype;
+	move->endcontents = 0;
+	move->time = n * frametime;
+	move->frames = n;
+	//
+	return qtrue;
+} //end of the function AAS_ClientMovementPrediction
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+int AAS_PredictClientMovement(struct aas_clientmove_s *move,
+								int entnum, vec3_t origin,
+								int presencetype, int onground,
+								vec3_t velocity, vec3_t cmdmove,
+								int cmdframes,
+								int maxframes, float frametime,
+								int stopevent, int stopareanum, int visualize)
+{
+	vec3_t mins, maxs;
+	return AAS_ClientMovementPrediction(move, entnum, origin, presencetype, onground,
+										velocity, cmdmove, cmdframes, maxframes,
+										frametime, stopevent, stopareanum,
+										mins, maxs, visualize);
+} //end of the function AAS_PredictClientMovement
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+int AAS_ClientMovementHitBBox(struct aas_clientmove_s *move,
+								int entnum, vec3_t origin,
+								int presencetype, int onground,
+								vec3_t velocity, vec3_t cmdmove,
+								int cmdframes,
+								int maxframes, float frametime,
+								vec3_t mins, vec3_t maxs, int visualize)
+{
+	return AAS_ClientMovementPrediction(move, entnum, origin, presencetype, onground,
+										velocity, cmdmove, cmdframes, maxframes,
+										frametime, SE_HITBOUNDINGBOX, 0,
+										mins, maxs, visualize);
+} //end of the function AAS_ClientMovementHitBBox
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+void AAS_TestMovementPrediction(int entnum, vec3_t origin, vec3_t dir)
+{
+	vec3_t velocity, cmdmove;
+	aas_clientmove_t move;
+
+	VectorClear(velocity);
+	if (!AAS_Swimming(origin)) dir[2] = 0;
+	VectorNormalize(dir);
+	VectorScale(dir, 400, cmdmove);
+	cmdmove[2] = 224;
+	AAS_ClearShownDebugLines();
+	AAS_PredictClientMovement(&move, entnum, origin, PRESENCE_NORMAL, qtrue,
+									velocity, cmdmove, 13, 13, 0.1f, SE_HITGROUND, 0, qtrue);//SE_LEAVEGROUND);
+	if (move.stopevent & SE_LEAVEGROUND)
+	{
+		botimport.Print(PRT_MESSAGE, "leave ground\n");
+	} //end if
+} //end of the function TestMovementPrediction
+//===========================================================================
+// calculates the horizontal velocity needed to perform a jump from start
+// to end
+//
+// Parameter:			zvel	: z velocity for jump
+//						start	: start position of jump
+//						end		: end position of jump
+//						*speed	: returned speed for jump
+// Returns:				qfalse if too high or too far from start to end
+// Changes Globals:		-
+//===========================================================================
+int AAS_HorizontalVelocityForJump(float zvel, vec3_t start, vec3_t end, float *velocity)
+{
+	float phys_gravity, phys_maxvelocity;
+	float maxjump, height2fall, t, top;
+	vec3_t dir;
+
+	phys_gravity = aassettings.phys_gravity;
+	phys_maxvelocity = aassettings.phys_maxvelocity;
+
+	//maximum height a player can jump with the given initial z velocity
+	maxjump = 0.5 * phys_gravity * (zvel / phys_gravity) * (zvel / phys_gravity);
+	//top of the parabolic jump
+	top = start[2] + maxjump;
+	//height the bot will fall from the top
+	height2fall = top - end[2];
+	//if the goal is to high to jump to
+	if (height2fall < 0)
+	{
+		*velocity = phys_maxvelocity;
+		return 0;
+	} //end if
+	//time a player takes to fall the height
+	t = sqrt(height2fall / (0.5 * phys_gravity));
+  	//direction from start to end
+	VectorSubtract(end, start, dir);
+	//
+	if ( (t + zvel / phys_gravity) == 0.0f ) {
+		*velocity = phys_maxvelocity;
+		return 0;
+	}
+	//calculate horizontal speed
+	*velocity = sqrt(dir[0]*dir[0] + dir[1]*dir[1]) / (t + zvel / phys_gravity);
+	//the horizontal speed must be lower than the max speed
+	if (*velocity > phys_maxvelocity)
+	{
+		*velocity = phys_maxvelocity;
+		return 0;
+	} //end if
+	return 1;
+} //end of the function AAS_HorizontalVelocityForJump
diff --git a/codemp/botlib/be_aas_move.h b/codemp/botlib/be_aas_move.h
new file mode 100644
index 0000000..9e08440
--- /dev/null
+++ b/codemp/botlib/be_aas_move.h
@@ -0,0 +1,54 @@
+
+/*****************************************************************************
+ * name:		be_aas_move.h
+ *
+ * desc:		AAS
+ *
+ * $Archive: /source/code/botlib/be_aas_move.h $
+ * $Author: Mrelusive $ 
+ * $Revision: 2 $
+ * $Modtime: 10/05/99 3:32p $
+ * $Date: 10/05/99 3:42p $
+ *
+ *****************************************************************************/
+
+#ifdef AASINTERN
+extern aas_settings_t aassettings;
+#endif //AASINTERN
+
+//movement prediction
+int AAS_PredictClientMovement(struct aas_clientmove_s *move,
+							int entnum, vec3_t origin,
+							int presencetype, int onground,
+							vec3_t velocity, vec3_t cmdmove,
+							int cmdframes,
+							int maxframes, float frametime,
+							int stopevent, int stopareanum, int visualize);
+//predict movement until bounding box is hit
+int AAS_ClientMovementHitBBox(struct aas_clientmove_s *move,
+								int entnum, vec3_t origin,
+								int presencetype, int onground,
+								vec3_t velocity, vec3_t cmdmove,
+								int cmdframes,
+								int maxframes, float frametime,
+								vec3_t mins, vec3_t maxs, int visualize);
+//returns true if on the ground at the given origin
+int AAS_OnGround(vec3_t origin, int presencetype, int passent);
+//returns true if swimming at the given origin
+int AAS_Swimming(vec3_t origin);
+//returns the jump reachability run start point
+void AAS_JumpReachRunStart(struct aas_reachability_s *reach, vec3_t runstart);
+//returns true if against a ladder at the given origin
+int AAS_AgainstLadder(vec3_t origin);
+//rocket jump Z velocity when rocket-jumping at origin
+float AAS_RocketJumpZVelocity(vec3_t origin);
+//bfg jump Z velocity when bfg-jumping at origin
+float AAS_BFGJumpZVelocity(vec3_t origin);
+//calculates the horizontal velocity needed for a jump and returns true this velocity could be calculated
+int AAS_HorizontalVelocityForJump(float zvel, vec3_t start, vec3_t end, float *velocity);
+//
+void AAS_SetMovedir(vec3_t angles, vec3_t movedir);
+//
+int AAS_DropToFloor(vec3_t origin, vec3_t mins, vec3_t maxs);
+//
+void AAS_InitSettings(void);
diff --git a/codemp/botlib/be_aas_optimize.cpp b/codemp/botlib/be_aas_optimize.cpp
new file mode 100644
index 0000000..7f29ee4
--- /dev/null
+++ b/codemp/botlib/be_aas_optimize.cpp
@@ -0,0 +1,295 @@
+
+/*****************************************************************************
+ * name:		be_aas_optimize.c
+ *
+ * desc:		decreases the .aas file size after the reachabilities have
+ *				been calculated, just dumps all the faces, edges and vertexes
+ *
+ * $Archive: /MissionPack/code/botlib/be_aas_optimize.c $
+ * $Author: Zaphod $ 
+ * $Revision: 5 $
+ * $Modtime: 11/22/00 8:50a $
+ * $Date: 11/22/00 8:55a $
+ *
+ *****************************************************************************/
+
+#include "../game/q_shared.h"
+#include "l_libvar.h"
+#include "l_memory.h"
+#include "l_script.h"
+#include "l_precomp.h"
+#include "l_struct.h"
+#include "aasfile.h"
+#include "../game/botlib.h"
+#include "../game/be_aas.h"
+#include "be_aas_funcs.h"
+#include "be_interface.h"
+#include "be_aas_def.h"
+
+typedef struct optimized_s
+{
+	//vertexes
+	int numvertexes;
+	aas_vertex_t *vertexes;
+	//edges
+	int numedges;
+	aas_edge_t *edges;
+	//edge index
+	int edgeindexsize;
+	aas_edgeindex_t *edgeindex;
+	//faces
+	int numfaces;
+	aas_face_t *faces;
+	//face index
+	int faceindexsize;
+	aas_faceindex_t *faceindex;
+	//convex areas
+	int numareas;
+	aas_area_t *areas;
+	//
+	int *vertexoptimizeindex;
+	int *edgeoptimizeindex;
+	int *faceoptimizeindex;
+} optimized_t;
+
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int AAS_KeepEdge(aas_edge_t *edge)
+{
+	return 1;
+} //end of the function AAS_KeepFace
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int AAS_OptimizeEdge(optimized_t *optimized, int edgenum)
+{
+	int i, optedgenum;
+	aas_edge_t *edge, *optedge;
+
+	edge = &aasworld.edges[abs(edgenum)];
+	if (!AAS_KeepEdge(edge)) return 0;
+
+	optedgenum = optimized->edgeoptimizeindex[abs(edgenum)];
+	if (optedgenum)
+	{
+		//keep the edge reversed sign
+		if (edgenum > 0) return optedgenum;
+		else return -optedgenum;
+	} //end if
+
+	optedge = &optimized->edges[optimized->numedges];
+
+	for (i = 0; i < 2; i++)
+	{
+		if (optimized->vertexoptimizeindex[edge->v[i]])
+		{
+			optedge->v[i] = optimized->vertexoptimizeindex[edge->v[i]];
+		} //end if
+		else
+		{
+			VectorCopy(aasworld.vertexes[edge->v[i]], optimized->vertexes[optimized->numvertexes]);
+			optedge->v[i] = optimized->numvertexes;
+			optimized->vertexoptimizeindex[edge->v[i]] = optimized->numvertexes;
+			optimized->numvertexes++;
+		} //end else
+	} //end for
+	optimized->edgeoptimizeindex[abs(edgenum)] = optimized->numedges;
+	optedgenum = optimized->numedges;
+	optimized->numedges++;
+	//keep the edge reversed sign
+	if (edgenum > 0) return optedgenum;
+	else return -optedgenum;
+} //end of the function AAS_OptimizeEdge
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int AAS_KeepFace(aas_face_t *face)
+{
+	if (!(face->faceflags & FACE_LADDER)) return 0;
+	else return 1;
+} //end of the function AAS_KeepFace
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int AAS_OptimizeFace(optimized_t *optimized, int facenum)
+{
+	int i, edgenum, optedgenum, optfacenum;
+	aas_face_t *face, *optface;
+
+	face = &aasworld.faces[abs(facenum)];
+	if (!AAS_KeepFace(face)) return 0;
+
+	optfacenum = optimized->faceoptimizeindex[abs(facenum)];
+	if (optfacenum)
+	{
+		//keep the face side sign
+		if (facenum > 0) return optfacenum;
+		else return -optfacenum;
+	} //end if
+
+	optface = &optimized->faces[optimized->numfaces];
+	Com_Memcpy(optface, face, sizeof(aas_face_t));
+
+	optface->numedges = 0;
+	optface->firstedge = optimized->edgeindexsize;
+	for (i = 0; i < face->numedges; i++)
+	{
+		edgenum = aasworld.edgeindex[face->firstedge + i];
+		optedgenum = AAS_OptimizeEdge(optimized, edgenum);
+		if (optedgenum)
+		{
+			optimized->edgeindex[optface->firstedge + optface->numedges] = optedgenum;
+			optface->numedges++;
+			optimized->edgeindexsize++;
+		} //end if
+	} //end for
+	optimized->faceoptimizeindex[abs(facenum)] = optimized->numfaces;
+	optfacenum = optimized->numfaces;
+	optimized->numfaces++;
+	//keep the face side sign
+	if (facenum > 0) return optfacenum;
+	else return -optfacenum;
+} //end of the function AAS_OptimizeFace
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void AAS_OptimizeArea(optimized_t *optimized, int areanum)
+{
+	int i, facenum, optfacenum;
+	aas_area_t *area, *optarea;
+
+	area = &aasworld.areas[areanum];
+	optarea = &optimized->areas[areanum];
+	Com_Memcpy(optarea, area, sizeof(aas_area_t));
+
+	optarea->numfaces = 0;
+	optarea->firstface = optimized->faceindexsize;
+	for (i = 0; i < area->numfaces; i++)
+	{
+		facenum = aasworld.faceindex[area->firstface + i];
+		optfacenum = AAS_OptimizeFace(optimized, facenum);
+		if (optfacenum)
+		{
+			optimized->faceindex[optarea->firstface + optarea->numfaces] = optfacenum;
+			optarea->numfaces++;
+			optimized->faceindexsize++;
+		} //end if
+	} //end for
+} //end of the function AAS_OptimizeArea
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void AAS_OptimizeAlloc(optimized_t *optimized)
+{
+	optimized->vertexes = (aas_vertex_t *) GetClearedMemory(aasworld.numvertexes * sizeof(aas_vertex_t));
+	optimized->numvertexes = 0;
+	optimized->edges = (aas_edge_t *) GetClearedMemory(aasworld.numedges * sizeof(aas_edge_t));
+	optimized->numedges = 1; //edge zero is a dummy
+	optimized->edgeindex = (aas_edgeindex_t *) GetClearedMemory(aasworld.edgeindexsize * sizeof(aas_edgeindex_t));
+	optimized->edgeindexsize = 0;
+	optimized->faces = (aas_face_t *) GetClearedMemory(aasworld.numfaces * sizeof(aas_face_t));
+	optimized->numfaces = 1; //face zero is a dummy
+	optimized->faceindex = (aas_faceindex_t *) GetClearedMemory(aasworld.faceindexsize * sizeof(aas_faceindex_t));
+	optimized->faceindexsize = 0;
+	optimized->areas = (aas_area_t *) GetClearedMemory(aasworld.numareas * sizeof(aas_area_t));
+	optimized->numareas = aasworld.numareas;
+	//
+	optimized->vertexoptimizeindex = (int *) GetClearedMemory(aasworld.numvertexes * sizeof(int));
+	optimized->edgeoptimizeindex = (int *) GetClearedMemory(aasworld.numedges * sizeof(int));
+	optimized->faceoptimizeindex = (int *) GetClearedMemory(aasworld.numfaces * sizeof(int));
+} //end of the function AAS_OptimizeAlloc
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void AAS_OptimizeStore(optimized_t *optimized)
+{
+	//store the optimized vertexes
+	if (aasworld.vertexes) FreeMemory(aasworld.vertexes);
+	aasworld.vertexes = optimized->vertexes;
+	aasworld.numvertexes = optimized->numvertexes;
+	//store the optimized edges
+	if (aasworld.edges) FreeMemory(aasworld.edges);
+	aasworld.edges = optimized->edges;
+	aasworld.numedges = optimized->numedges;
+	//store the optimized edge index
+	if (aasworld.edgeindex) FreeMemory(aasworld.edgeindex);
+	aasworld.edgeindex = optimized->edgeindex;
+	aasworld.edgeindexsize = optimized->edgeindexsize;
+	//store the optimized faces
+	if (aasworld.faces) FreeMemory(aasworld.faces);
+	aasworld.faces = optimized->faces;
+	aasworld.numfaces = optimized->numfaces;
+	//store the optimized face index
+	if (aasworld.faceindex) FreeMemory(aasworld.faceindex);
+	aasworld.faceindex = optimized->faceindex;
+	aasworld.faceindexsize = optimized->faceindexsize;
+	//store the optimized areas
+	if (aasworld.areas) FreeMemory(aasworld.areas);
+	aasworld.areas = optimized->areas;
+	aasworld.numareas = optimized->numareas;
+	//free optimize indexes
+	FreeMemory(optimized->vertexoptimizeindex);
+	FreeMemory(optimized->edgeoptimizeindex);
+	FreeMemory(optimized->faceoptimizeindex);
+} //end of the function AAS_OptimizeStore
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void AAS_Optimize(void)
+{
+	int i, sign;
+	optimized_t optimized;
+
+	AAS_OptimizeAlloc(&optimized);
+	for (i = 1; i < aasworld.numareas; i++)
+	{
+		AAS_OptimizeArea(&optimized, i);
+	} //end for
+	//reset the reachability face pointers
+	for (i = 0; i < aasworld.reachabilitysize; i++)
+	{
+		//NOTE: for TRAVEL_ELEVATOR the facenum is the model number of
+		//		the elevator
+		if ((aasworld.reachability[i].traveltype & TRAVELTYPE_MASK) == TRAVEL_ELEVATOR) continue;
+		//NOTE: for TRAVEL_JUMPPAD the facenum is the Z velocity and the edgenum is the hor velocity
+		if ((aasworld.reachability[i].traveltype & TRAVELTYPE_MASK) == TRAVEL_JUMPPAD) continue;
+		//NOTE: for TRAVEL_FUNCBOB the facenum and edgenum contain other coded information
+		if ((aasworld.reachability[i].traveltype & TRAVELTYPE_MASK) == TRAVEL_FUNCBOB) continue;
+		//
+		sign = aasworld.reachability[i].facenum;
+		aasworld.reachability[i].facenum = optimized.faceoptimizeindex[abs(aasworld.reachability[i].facenum)];
+		if (sign < 0) aasworld.reachability[i].facenum = -aasworld.reachability[i].facenum;
+		sign = aasworld.reachability[i].edgenum;
+		aasworld.reachability[i].edgenum = optimized.edgeoptimizeindex[abs(aasworld.reachability[i].edgenum)];
+		if (sign < 0) aasworld.reachability[i].edgenum = -aasworld.reachability[i].edgenum;
+	} //end for
+	//store the optimized AAS data into aasworld
+	AAS_OptimizeStore(&optimized);
+	//print some nice stuff :)
+	botimport.Print(PRT_MESSAGE, "AAS data optimized.\n");
+} //end of the function AAS_Optimize
diff --git a/codemp/botlib/be_aas_optimize.h b/codemp/botlib/be_aas_optimize.h
new file mode 100644
index 0000000..de5d229
--- /dev/null
+++ b/codemp/botlib/be_aas_optimize.h
@@ -0,0 +1,16 @@
+
+/*****************************************************************************
+ * name:		be_aas_optimize.h
+ *
+ * desc:		AAS
+ *
+ * $Archive: /source/code/botlib/be_aas_optimize.h $
+ * $Author: Mrelusive $ 
+ * $Revision: 2 $
+ * $Modtime: 10/05/99 3:32p $
+ * $Date: 10/05/99 3:42p $
+ *
+ *****************************************************************************/
+
+void AAS_Optimize(void);
+
diff --git a/codemp/botlib/be_aas_reach.cpp b/codemp/botlib/be_aas_reach.cpp
new file mode 100644
index 0000000..d7369c1
--- /dev/null
+++ b/codemp/botlib/be_aas_reach.cpp
@@ -0,0 +1,4525 @@
+
+/*****************************************************************************
+ * name:		be_aas_reach.c
+ *
+ * desc:		reachability calculations
+ *
+ * $Archive: /MissionPack/code/botlib/be_aas_reach.c $
+ * $Author: Ttimo $ 
+ * $Revision: 12 $
+ * $Modtime: 4/21/01 9:15a $
+ * $Date: 4/21/01 9:15a $
+ *
+ *****************************************************************************/
+
+#include "../game/q_shared.h"
+#include "l_log.h"
+#include "l_memory.h"
+#include "l_script.h"
+#include "l_libvar.h"
+#include "l_precomp.h"
+#include "l_struct.h"
+#include "aasfile.h"
+#include "../game/botlib.h"
+#include "../game/be_aas.h"
+#include "be_aas_funcs.h"
+#include "be_aas_def.h"
+
+extern int Sys_MilliSeconds(void);
+
+
+extern botlib_import_t botimport;
+
+//#define REACH_DEBUG
+
+//NOTE: all travel times are in hundreth of a second
+//maximum number of reachability links
+#define AAS_MAX_REACHABILITYSIZE			65536
+//number of areas reachability is calculated for each frame
+#define REACHABILITYAREASPERCYCLE			15
+//number of units reachability points are placed inside the areas
+#define INSIDEUNITS							2
+#define INSIDEUNITS_WALKEND					5
+#define INSIDEUNITS_WALKSTART				0.1
+#define INSIDEUNITS_WATERJUMP				15
+//area flag used for weapon jumping
+#define AREA_WEAPONJUMP						8192	//valid area to weapon jump to
+//number of reachabilities of each type
+int reach_swim;			//swim
+int reach_equalfloor;	//walk on floors with equal height
+int reach_step;			//step up
+int reach_walk;			//walk of step
+int reach_barrier;		//jump up to a barrier
+int reach_waterjump;	//jump out of water
+int reach_walkoffledge;	//walk of a ledge
+int reach_jump;			//jump
+int reach_ladder;		//climb or descent a ladder
+int reach_teleport;		//teleport
+int reach_elevator;		//use an elevator
+int reach_funcbob;		//use a func bob
+int reach_grapple;		//grapple hook
+int reach_doublejump;	//double jump
+int reach_rampjump;		//ramp jump
+int reach_strafejump;	//strafe jump (just normal jump but further)
+int reach_rocketjump;	//rocket jump
+int reach_bfgjump;		//bfg jump
+int reach_jumppad;		//jump pads
+//if true grapple reachabilities are skipped
+int calcgrapplereach;
+//linked reachability
+typedef struct aas_lreachability_s
+{
+	int areanum;					//number of the reachable area
+	int facenum;					//number of the face towards the other area
+	int edgenum;					//number of the edge towards the other area
+	vec3_t start;					//start point of inter area movement
+	vec3_t end;						//end point of inter area movement
+	int traveltype;					//type of travel required to get to the area
+	unsigned short int traveltime;	//travel time of the inter area movement
+	//
+	struct aas_lreachability_s *next;
+} aas_lreachability_t;
+//temporary reachabilities
+aas_lreachability_t *reachabilityheap;	//heap with reachabilities
+aas_lreachability_t *nextreachability;	//next free reachability from the heap
+aas_lreachability_t **areareachability;	//reachability links for every area
+int numlreachabilities;
+
+//===========================================================================
+// returns the surface area of the given face
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+float AAS_FaceArea(aas_face_t *face)
+{
+	int i, edgenum, side;
+	float total;
+	vec_t *v;
+	vec3_t d1, d2, cross;
+	aas_edge_t *edge;
+
+	edgenum = aasworld.edgeindex[face->firstedge];
+	side = edgenum < 0;
+	edge = &aasworld.edges[abs(edgenum)];
+	v = aasworld.vertexes[edge->v[side]];
+
+	total = 0;
+	for (i = 1; i < face->numedges - 1; i++)
+	{
+		edgenum = aasworld.edgeindex[face->firstedge + i];
+		side = edgenum < 0;
+		edge = &aasworld.edges[abs(edgenum)];
+		VectorSubtract(aasworld.vertexes[edge->v[side]], v, d1);
+		VectorSubtract(aasworld.vertexes[edge->v[!side]], v, d2);
+		CrossProduct(d1, d2, cross);
+		total += 0.5 * VectorLength(cross);
+	} //end for
+	return total;
+} //end of the function AAS_FaceArea
+//===========================================================================
+// returns the volume of an area
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+float AAS_AreaVolume(int areanum)
+{
+	int i, edgenum, facenum, side;
+	vec_t d, a, volume;
+	vec3_t corner;
+	aas_plane_t *plane;
+	aas_edge_t *edge;
+	aas_face_t *face;
+	aas_area_t *area;
+
+	area = &aasworld.areas[areanum];
+	facenum = aasworld.faceindex[area->firstface];
+	face = &aasworld.faces[abs(facenum)];
+	edgenum = aasworld.edgeindex[face->firstedge];
+	edge = &aasworld.edges[abs(edgenum)];
+	//
+	VectorCopy(aasworld.vertexes[edge->v[0]], corner);
+
+	//make tetrahedrons to all other faces
+	volume = 0;
+	for (i = 0; i < area->numfaces; i++)
+	{
+		facenum = abs(aasworld.faceindex[area->firstface + i]);
+		face = &aasworld.faces[facenum];
+		side = face->backarea != areanum;
+		plane = &aasworld.planes[face->planenum ^ side];
+		d = -(DotProduct (corner, plane->normal) - plane->dist);
+		a = AAS_FaceArea(face);
+		volume += d * a;
+	} //end for
+
+	volume /= 3;
+	return volume;
+} //end of the function AAS_AreaVolume
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int AAS_BestReachableLinkArea(aas_link_t *areas)
+{
+	aas_link_t *link;
+
+	for (link = areas; link; link = link->next_area)
+	{
+		if (AAS_AreaGrounded(link->areanum) || AAS_AreaSwim(link->areanum))
+		{
+			return link->areanum;
+		} //end if
+	} //end for
+	//
+	for (link = areas; link; link = link->next_area)
+	{
+		if (link->areanum) return link->areanum;
+		//FIXME: this is a bad idea when the reachability is not yet
+		// calculated when the level items are loaded
+		if (AAS_AreaReachability(link->areanum))
+			return link->areanum;
+	} //end for
+	return 0;
+} //end of the function AAS_BestReachableLinkArea
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+int AAS_GetJumpPadInfo(int ent, vec3_t areastart, vec3_t absmins, vec3_t absmaxs, vec3_t velocity)
+{
+	int modelnum, ent2;
+	float speed, height, gravity, time, dist, forward;
+	vec3_t origin, angles, teststart, ent2origin;
+	aas_trace_t trace;
+	char model[MAX_EPAIRKEY];
+	char target[MAX_EPAIRKEY], targetname[MAX_EPAIRKEY];
+
+	//
+	AAS_FloatForBSPEpairKey(ent, "speed", &speed);
+	if (!speed) speed = 1000;
+	VectorClear(angles);
+	//get the mins, maxs and origin of the model
+	AAS_ValueForBSPEpairKey(ent, "model", model, MAX_EPAIRKEY);
+	if (model[0]) modelnum = atoi(model+1);
+	else modelnum = 0;
+	AAS_BSPModelMinsMaxsOrigin(modelnum, angles, absmins, absmaxs, origin);
+	VectorAdd(origin, absmins, absmins);
+	VectorAdd(origin, absmaxs, absmaxs);
+	VectorAdd(absmins, absmaxs, origin);
+	VectorScale (origin, 0.5, origin);
+
+	//get the start areas
+	VectorCopy(origin, teststart);
+	teststart[2] += 64;
+	trace = AAS_TraceClientBBox(teststart, origin, PRESENCE_CROUCH, -1);
+	if (trace.startsolid)
+	{
+		botimport.Print(PRT_MESSAGE, "trigger_push start solid\n");
+		VectorCopy(origin, areastart);
+	} //end if
+	else
+	{
+		VectorCopy(trace.endpos, areastart);
+	} //end else
+	areastart[2] += 0.125;
+	//
+	//AAS_DrawPermanentCross(origin, 4, 4);
+	//get the target entity
+	AAS_ValueForBSPEpairKey(ent, "target", target, MAX_EPAIRKEY);
+	for (ent2 = AAS_NextBSPEntity(0); ent2; ent2 = AAS_NextBSPEntity(ent2))
+	{
+		if (!AAS_ValueForBSPEpairKey(ent2, "targetname", targetname, MAX_EPAIRKEY)) continue;
+		if (!strcmp(targetname, target)) break;
+	} //end for
+	if (!ent2)
+	{
+		botimport.Print(PRT_MESSAGE, "trigger_push without target entity %s\n", target);
+		return qfalse;
+	} //end if
+	AAS_VectorForBSPEpairKey(ent2, "origin", ent2origin);
+	//
+	height = ent2origin[2] - origin[2];
+	gravity = aassettings.phys_gravity;
+	time = sqrt( height / ( 0.5 * gravity ) );
+	if (!time)
+	{
+		botimport.Print(PRT_MESSAGE, "trigger_push without time\n");
+		return qfalse;
+	} //end if
+	// set s.origin2 to the push velocity
+	VectorSubtract ( ent2origin, origin, velocity);
+	dist = VectorNormalize( velocity);
+	forward = dist / time;
+	//FIXME: why multiply by 1.1
+	forward *= 1.1f;
+	VectorScale(velocity, forward, velocity);
+	velocity[2] = time * gravity;
+	return qtrue;
+} //end of the function AAS_GetJumpPadInfo
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+int AAS_BestReachableFromJumpPadArea(vec3_t origin, vec3_t mins, vec3_t maxs)
+{
+	int area2num, ent, bot_visualizejumppads, bestareanum;
+	float volume, bestareavolume;
+	vec3_t areastart, cmdmove, bboxmins, bboxmaxs;
+	vec3_t absmins, absmaxs, velocity;
+	aas_clientmove_t move;
+	aas_link_t *areas, *link;
+	char classname[MAX_EPAIRKEY];
+
+#ifdef BSPC
+	bot_visualizejumppads = 0;
+#else
+	bot_visualizejumppads = LibVarValue("bot_visualizejumppads", "0");
+#endif
+	VectorAdd(origin, mins, bboxmins);
+	VectorAdd(origin, maxs, bboxmaxs);
+	for (ent = AAS_NextBSPEntity(0); ent; ent = AAS_NextBSPEntity(ent))
+	{
+		if (!AAS_ValueForBSPEpairKey(ent, "classname", classname, MAX_EPAIRKEY)) continue;
+		if (strcmp(classname, "trigger_push")) continue;
+		//
+		if (!AAS_GetJumpPadInfo(ent, areastart, absmins, absmaxs, velocity)) continue;
+		//get the areas the jump pad brush is in
+		areas = AAS_LinkEntityClientBBox(absmins, absmaxs, -1, PRESENCE_CROUCH);
+		for (link = areas; link; link = link->next_area)
+		{
+			if (AAS_AreaJumpPad(link->areanum)) break;
+		} //end for
+		if (!link)
+		{
+			botimport.Print(PRT_MESSAGE, "trigger_push not in any jump pad area\n");
+			AAS_UnlinkFromAreas(areas);
+			continue;
+		} //end if
+		//
+		//botimport.Print(PRT_MESSAGE, "found a trigger_push with velocity %f %f %f\n", velocity[0], velocity[1], velocity[2]);
+		//
+		VectorSet(cmdmove, 0, 0, 0);
+		Com_Memset(&move, 0, sizeof(aas_clientmove_t));
+		area2num = 0;
+		AAS_ClientMovementHitBBox(&move, -1, areastart, PRESENCE_NORMAL, qfalse,
+								velocity, cmdmove, 0, 30, 0.1f, bboxmins, bboxmaxs, bot_visualizejumppads);
+		if (move.frames < 30)
+		{
+			bestareanum = 0;
+			bestareavolume = 0;
+			for (link = areas; link; link = link->next_area)
+			{
+				if (!AAS_AreaJumpPad(link->areanum)) continue;
+				volume = AAS_AreaVolume(link->areanum);
+				if (volume >= bestareavolume)
+				{
+					bestareanum = link->areanum;
+					bestareavolume = volume;
+				} //end if
+			} //end if
+			AAS_UnlinkFromAreas(areas);
+			return bestareanum;
+		} //end if
+		AAS_UnlinkFromAreas(areas);
+	} //end for
+	return 0;
+} //end of the function AAS_BestReachableFromJumpPadArea
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int AAS_BestReachableArea(vec3_t origin, vec3_t mins, vec3_t maxs, vec3_t goalorigin)
+{
+	int areanum, i, j, k, l;
+	aas_link_t *areas;
+	vec3_t absmins, absmaxs;
+	//vec3_t bbmins, bbmaxs;
+	vec3_t start, end;
+	aas_trace_t trace;
+
+	if (!aasworld.loaded)
+	{
+		botimport.Print(PRT_ERROR, "AAS_BestReachableArea: aas not loaded\n");
+		return 0;
+	} //end if
+	//find a point in an area
+	VectorCopy(origin, start);
+	areanum = AAS_PointAreaNum(start);
+	//while no area found fudge around a little
+	for (i = 0; i < 5 && !areanum; i++)
+	{
+		for (j = 0; j < 5 && !areanum; j++)
+		{
+			for (k = -1; k <= 1 && !areanum; k++)
+			{
+				for (l = -1; l <= 1 && !areanum; l++)
+				{
+					VectorCopy(origin, start);
+					start[0] += (float) j * 4 * k;
+					start[1] += (float) j * 4 * l;
+					start[2] += (float) i * 4;
+					areanum = AAS_PointAreaNum(start);
+				} //end for
+			} //end for
+		} //end for
+	} //end for
+	//if an area was found
+	if (areanum)
+	{
+		//drop client bbox down and try again
+		VectorCopy(start, end);
+		start[2] += 0.25;
+		end[2] -= 50;
+		trace = AAS_TraceClientBBox(start, end, PRESENCE_CROUCH, -1);
+		if (!trace.startsolid)
+		{
+			areanum = AAS_PointAreaNum(trace.endpos);
+			VectorCopy(trace.endpos, goalorigin);
+			//FIXME: cannot enable next line right now because the reachability
+			// does not have to be calculated when the level items are loaded
+			//if the origin is in an area with reachability
+			//if (AAS_AreaReachability(areanum)) return areanum;
+			if (areanum) return areanum;
+		} //end if
+		else
+		{
+			//it can very well happen that the AAS_PointAreaNum function tells that
+			//a point is in an area and that starting a AAS_TraceClientBBox from that
+			//point will return trace.startsolid qtrue
+#if 0
+			if (AAS_PointAreaNum(start))
+			{
+				Log_Write("point %f %f %f in area %d but trace startsolid", start[0], start[1], start[2], areanum);
+				AAS_DrawPermanentCross(start, 4, LINECOLOR_RED);
+			} //end if
+			botimport.Print(PRT_MESSAGE, "AAS_BestReachableArea: start solid\n");
+#endif
+			VectorCopy(start, goalorigin);
+			return areanum;
+		} //end else
+	} //end if
+	//
+	//AAS_PresenceTypeBoundingBox(PRESENCE_CROUCH, bbmins, bbmaxs);
+	//NOTE: the goal origin does not have to be in the goal area
+	// because the bot will have to move towards the item origin anyway
+	VectorCopy(origin, goalorigin);
+	//
+	VectorAdd(origin, mins, absmins);
+	VectorAdd(origin, maxs, absmaxs);
+	//add bounding box size
+	//VectorSubtract(absmins, bbmaxs, absmins);
+	//VectorSubtract(absmaxs, bbmins, absmaxs);
+	//link an invalid (-1) entity
+	areas = AAS_LinkEntityClientBBox(absmins, absmaxs, -1, PRESENCE_CROUCH);
+	//get the reachable link arae
+	areanum = AAS_BestReachableLinkArea(areas);
+	//unlink the invalid entity
+	AAS_UnlinkFromAreas(areas);
+	//
+	return areanum;
+} //end of the function AAS_BestReachableArea
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void AAS_SetupReachabilityHeap(void)
+{
+	int i;
+
+	reachabilityheap = (aas_lreachability_t *) GetClearedMemory(
+						AAS_MAX_REACHABILITYSIZE * sizeof(aas_lreachability_t));
+	for (i = 0; i < AAS_MAX_REACHABILITYSIZE-1; i++)
+	{
+		reachabilityheap[i].next = &reachabilityheap[i+1];
+	} //end for
+	reachabilityheap[AAS_MAX_REACHABILITYSIZE-1].next = NULL;
+	nextreachability = reachabilityheap;
+	numlreachabilities = 0;
+} //end of the function AAS_InitReachabilityHeap
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void AAS_ShutDownReachabilityHeap(void)
+{
+	FreeMemory(reachabilityheap);
+	numlreachabilities = 0;
+} //end of the function AAS_ShutDownReachabilityHeap
+//===========================================================================
+// returns a reachability link
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+aas_lreachability_t *AAS_AllocReachability(void)
+{
+	aas_lreachability_t *r;
+
+	if (!nextreachability) return NULL;
+	//make sure the error message only shows up once
+	if (!nextreachability->next) AAS_Error("AAS_MAX_REACHABILITYSIZE");
+	//
+	r = nextreachability;
+	nextreachability = nextreachability->next;
+	numlreachabilities++;
+	return r;
+} //end of the function AAS_AllocReachability
+//===========================================================================
+// frees a reachability link
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void AAS_FreeReachability(aas_lreachability_t *lreach)
+{
+	Com_Memset(lreach, 0, sizeof(aas_lreachability_t));
+
+	lreach->next = nextreachability;
+	nextreachability = lreach;
+	numlreachabilities--;
+} //end of the function AAS_FreeReachability
+//===========================================================================
+// returns qtrue if the area has reachability links
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int AAS_AreaReachability(int areanum)
+{
+	if (areanum < 0 || areanum >= aasworld.numareas)
+	{
+		AAS_Error("AAS_AreaReachability: areanum %d out of range", areanum);
+		return 0;
+	} //end if
+	return aasworld.areasettings[areanum].numreachableareas;
+} //end of the function AAS_AreaReachability
+//===========================================================================
+// returns the surface area of all ground faces together of the area
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+float AAS_AreaGroundFaceArea(int areanum)
+{
+	int i;
+	float total;
+	aas_area_t *area;
+	aas_face_t *face;
+
+	total = 0;
+	area = &aasworld.areas[areanum];
+	for (i = 0; i < area->numfaces; i++)
+	{
+		face = &aasworld.faces[abs(aasworld.faceindex[area->firstface + i])];
+		if (!(face->faceflags & FACE_GROUND)) continue;
+		//
+		total += AAS_FaceArea(face);
+	} //end for
+	return total;
+} //end of the function AAS_AreaGroundFaceArea
+//===========================================================================
+// returns the center of a face
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void AAS_FaceCenter(int facenum, vec3_t center)
+{
+	int i;
+	float scale;
+	aas_face_t *face;
+	aas_edge_t *edge;
+
+	face = &aasworld.faces[facenum];
+
+	VectorClear(center);
+	for (i = 0; i < face->numedges; i++)
+	{
+		edge = &aasworld.edges[abs(aasworld.edgeindex[face->firstedge + i])];
+		VectorAdd(center, aasworld.vertexes[edge->v[0]], center);
+		VectorAdd(center, aasworld.vertexes[edge->v[1]], center);
+	} //end for
+	scale = 0.5 / face->numedges;
+	VectorScale(center, scale, center);
+} //end of the function AAS_FaceCenter
+//===========================================================================
+// returns the maximum distance a player can fall before being damaged
+// damage = deltavelocity*deltavelocity  * 0.0001
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int AAS_FallDamageDistance(void)
+{
+	float maxzvelocity, gravity, t;
+
+	maxzvelocity = sqrt((float)(30 * 10000));
+	gravity = aassettings.phys_gravity;
+	t = maxzvelocity / gravity;
+	return 0.5 * gravity * t * t;
+} //end of the function AAS_FallDamageDistance
+//===========================================================================
+// distance = 0.5 * gravity * t * t
+// vel = t * gravity
+// damage = vel * vel * 0.0001
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+float AAS_FallDelta(float distance)
+{
+	float t, delta, gravity;
+
+	gravity = aassettings.phys_gravity;
+	t = sqrt(fabs(distance) * 2 / gravity);
+	delta = t * gravity;
+	return delta * delta * 0.0001;
+} //end of the function AAS_FallDelta
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+float AAS_MaxJumpHeight(float phys_jumpvel)
+{
+	float phys_gravity;
+
+	phys_gravity = aassettings.phys_gravity;
+	//maximum height a player can jump with the given initial z velocity
+	return 0.5 * phys_gravity * (phys_jumpvel / phys_gravity) * (phys_jumpvel / phys_gravity);
+} //end of the function MaxJumpHeight
+//===========================================================================
+// returns true if a player can only crouch in the area
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+float AAS_MaxJumpDistance(float phys_jumpvel)
+{
+	float phys_gravity, phys_maxvelocity, t;
+
+	phys_gravity = aassettings.phys_gravity;
+	phys_maxvelocity = aassettings.phys_maxvelocity;
+	//time a player takes to fall the height
+	t = sqrt(aassettings.rs_maxjumpfallheight / (0.5 * phys_gravity));
+   //maximum distance
+	return phys_maxvelocity * (t + phys_jumpvel / phys_gravity);
+} //end of the function AAS_MaxJumpDistance
+//===========================================================================
+// returns true if a player can only crouch in the area
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int AAS_AreaCrouch(int areanum)
+{
+	if (!(aasworld.areasettings[areanum].presencetype & PRESENCE_NORMAL)) return qtrue;
+	else return qfalse;
+} //end of the function AAS_AreaCrouch
+//===========================================================================
+// returns qtrue if it is possible to swim in the area
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int AAS_AreaSwim(int areanum)
+{
+	if (aasworld.areasettings[areanum].areaflags & AREA_LIQUID) return qtrue;
+	else return qfalse;
+} //end of the function AAS_AreaSwim
+//===========================================================================
+// returns qtrue if the area contains a liquid
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int AAS_AreaLiquid(int areanum)
+{
+	if (aasworld.areasettings[areanum].areaflags & AREA_LIQUID) return qtrue;
+	else return qfalse;
+} //end of the function AAS_AreaLiquid
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+int AAS_AreaLava(int areanum)
+{
+	return (aasworld.areasettings[areanum].contents & AREACONTENTS_LAVA);
+} //end of the function AAS_AreaLava
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+int AAS_AreaSlime(int areanum)
+{
+	return (aasworld.areasettings[areanum].contents & AREACONTENTS_SLIME);
+} //end of the function AAS_AreaSlime
+//===========================================================================
+// returns qtrue if the area contains ground faces
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int AAS_AreaGrounded(int areanum)
+{
+	return (aasworld.areasettings[areanum].areaflags & AREA_GROUNDED);
+} //end of the function AAS_AreaGround
+//===========================================================================
+// returns true if the area contains ladder faces
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int AAS_AreaLadder(int areanum)
+{
+	return (aasworld.areasettings[areanum].areaflags & AREA_LADDER);
+} //end of the function AAS_AreaLadder
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int AAS_AreaJumpPad(int areanum)
+{
+	return (aasworld.areasettings[areanum].contents & AREACONTENTS_JUMPPAD);
+} //end of the function AAS_AreaJumpPad
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int AAS_AreaTeleporter(int areanum)
+{
+	return (aasworld.areasettings[areanum].contents & AREACONTENTS_TELEPORTER);
+} //end of the function AAS_AreaTeleporter
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int AAS_AreaClusterPortal(int areanum)
+{
+	return (aasworld.areasettings[areanum].contents & AREACONTENTS_CLUSTERPORTAL);
+} //end of the function AAS_AreaClusterPortal
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int AAS_AreaDoNotEnter(int areanum)
+{
+	return (aasworld.areasettings[areanum].contents & AREACONTENTS_DONOTENTER);
+} //end of the function AAS_AreaDoNotEnter
+//===========================================================================
+// returns the time it takes perform a barrier jump
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+unsigned short int AAS_BarrierJumpTravelTime(void)
+{
+	return aassettings.phys_jumpvel / (aassettings.phys_gravity * 0.1);
+} //end op the function AAS_BarrierJumpTravelTime
+//===========================================================================
+// returns true if there already exists a reachability from area1 to area2
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+qboolean AAS_ReachabilityExists(int area1num, int area2num)
+{
+	aas_lreachability_t *r;
+
+	for (r = areareachability[area1num]; r; r = r->next)
+	{
+		if (r->areanum == area2num) return qtrue;
+	} //end for
+	return qfalse;
+} //end of the function AAS_ReachabilityExists
+//===========================================================================
+// returns true if there is a solid just after the end point when going
+// from start to end
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int AAS_NearbySolidOrGap(vec3_t start, vec3_t end)
+{
+	vec3_t dir, testpoint;
+	int areanum;
+
+	VectorSubtract(end, start, dir);
+	dir[2] = 0;
+	VectorNormalize(dir);
+	VectorMA(end, 48, dir, testpoint);
+
+	areanum = AAS_PointAreaNum(testpoint);
+	if (!areanum)
+	{
+		testpoint[2] += 16;
+		areanum = AAS_PointAreaNum(testpoint);
+		if (!areanum) return qtrue;
+	} //end if
+	VectorMA(end, 64, dir, testpoint);
+	areanum = AAS_PointAreaNum(testpoint);
+	if (areanum)
+	{
+		if (!AAS_AreaSwim(areanum) && !AAS_AreaGrounded(areanum)) return qtrue;
+	} //end if
+	return qfalse;
+} //end of the function AAS_SolidGapTime
+//===========================================================================
+// searches for swim reachabilities between adjacent areas
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int AAS_Reachability_Swim(int area1num, int area2num)
+{
+	int i, j, face1num, face2num, side1;
+	aas_area_t *area1, *area2;
+	aas_areasettings_t *areasettings;
+	aas_lreachability_t *lreach;
+	aas_face_t *face1;
+	aas_plane_t *plane;
+	vec3_t start;
+
+	if (!AAS_AreaSwim(area1num) || !AAS_AreaSwim(area2num)) return qfalse;
+	//if the second area is crouch only
+	if (!(aasworld.areasettings[area2num].presencetype & PRESENCE_NORMAL)) return qfalse;
+
+	area1 = &aasworld.areas[area1num];
+	area2 = &aasworld.areas[area2num];
+
+	//if the areas are not near anough
+	for (i = 0; i < 3; i++)
+	{
+		if (area1->mins[i] > area2->maxs[i] + 10) return qfalse;
+		if (area1->maxs[i] < area2->mins[i] - 10) return qfalse;
+	} //end for
+	//find a shared face and create a reachability link
+	for (i = 0; i < area1->numfaces; i++)
+	{
+		face1num = aasworld.faceindex[area1->firstface + i];
+		side1 = face1num < 0;
+		face1num = abs(face1num);
+		//
+		for (j = 0; j < area2->numfaces; j++)
+		{
+			face2num = abs(aasworld.faceindex[area2->firstface + j]);
+			//
+			if (face1num == face2num)
+			{
+				AAS_FaceCenter(face1num, start);
+				//
+				if (AAS_PointContents(start) & (CONTENTS_LAVA|CONTENTS_SLIME|CONTENTS_WATER))
+				{
+					//
+					face1 = &aasworld.faces[face1num];
+					areasettings = &aasworld.areasettings[area1num];
+					//create a new reachability link
+					lreach = AAS_AllocReachability();
+					if (!lreach) return qfalse;
+					lreach->areanum = area2num;
+					lreach->facenum = face1num;
+					lreach->edgenum = 0;
+					VectorCopy(start, lreach->start);
+					plane = &aasworld.planes[face1->planenum ^ side1];
+					VectorMA(lreach->start, -INSIDEUNITS, plane->normal, lreach->end);
+					lreach->traveltype = TRAVEL_SWIM;
+					lreach->traveltime = 1;
+					//if the volume of the area is rather small
+					if (AAS_AreaVolume(area2num) < 800)
+						lreach->traveltime += 200;
+					//if (!(AAS_PointContents(start) & MASK_WATER)) lreach->traveltime += 500;
+					//link the reachability
+					lreach->next = areareachability[area1num];
+					areareachability[area1num] = lreach;
+					reach_swim++;
+					return qtrue;
+				} //end if
+			} //end if
+		} //end for
+	} //end for
+	return qfalse;
+} //end of the function AAS_Reachability_Swim
+//===========================================================================
+// searches for reachabilities between adjacent areas with equal floor
+// heights
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int AAS_Reachability_EqualFloorHeight(int area1num, int area2num)
+{
+	int i, j, edgenum, edgenum1, edgenum2, foundreach, side;
+	float height, bestheight, length, bestlength;
+	vec3_t dir, start, end, normal, invgravity, gravitydirection = {0, 0, -1};
+	vec3_t edgevec;
+	aas_area_t *area1, *area2;
+	aas_face_t *face1, *face2;
+	aas_edge_t *edge;
+	aas_plane_t *plane2;
+	aas_lreachability_t lr, *lreach;
+
+	if (!AAS_AreaGrounded(area1num) || !AAS_AreaGrounded(area2num)) return qfalse;
+
+	area1 = &aasworld.areas[area1num];
+	area2 = &aasworld.areas[area2num];
+	//if the areas are not near anough in the x-y direction
+	for (i = 0; i < 2; i++)
+	{
+		if (area1->mins[i] > area2->maxs[i] + 10) return qfalse;
+		if (area1->maxs[i] < area2->mins[i] - 10) return qfalse;
+	} //end for
+	//if area 2 is too high above area 1
+	if (area2->mins[2] > area1->maxs[2]) return qfalse;
+	//
+	VectorCopy(gravitydirection, invgravity);
+	VectorInverse(invgravity);
+	//
+	bestheight = 99999;
+	bestlength = 0;
+	foundreach = qfalse;
+	Com_Memset(&lr, 0, sizeof(aas_lreachability_t)); //make the compiler happy
+	//
+	//check if the areas have ground faces with a common edge
+	//if existing use the lowest common edge for a reachability link
+	for (i = 0; i < area1->numfaces; i++)
+	{
+		face1 = &aasworld.faces[abs(aasworld.faceindex[area1->firstface + i])];
+		if (!(face1->faceflags & FACE_GROUND)) continue;
+		//
+		for (j = 0; j < area2->numfaces; j++)
+		{
+			face2 = &aasworld.faces[abs(aasworld.faceindex[area2->firstface + j])];
+			if (!(face2->faceflags & FACE_GROUND)) continue;
+			//if there is a common edge
+			for (edgenum1 = 0; edgenum1 < face1->numedges; edgenum1++)
+			{
+				for (edgenum2 = 0; edgenum2 < face2->numedges; edgenum2++)
+				{
+					if (abs(aasworld.edgeindex[face1->firstedge + edgenum1]) !=
+							abs(aasworld.edgeindex[face2->firstedge + edgenum2]))
+									continue;
+					edgenum = aasworld.edgeindex[face1->firstedge + edgenum1];
+					side = edgenum < 0;
+					edge = &aasworld.edges[abs(edgenum)];
+					//get the length of the edge
+					VectorSubtract(aasworld.vertexes[edge->v[1]],
+								aasworld.vertexes[edge->v[0]], dir);
+					length = VectorLength(dir);
+					//get the start point
+					VectorAdd(aasworld.vertexes[edge->v[0]],
+								aasworld.vertexes[edge->v[1]], start);
+					VectorScale(start, 0.5, start);
+					VectorCopy(start, end);
+					//get the end point several units inside area2
+					//and the start point several units inside area1
+					//NOTE: normal is pointing into area2 because the
+					//face edges are stored counter clockwise
+					VectorSubtract(aasworld.vertexes[edge->v[side]],
+								aasworld.vertexes[edge->v[!side]], edgevec);
+					plane2 = &aasworld.planes[face2->planenum];
+					CrossProduct(edgevec, plane2->normal, normal);
+					VectorNormalize(normal);
+					//
+					//VectorMA(start, -1, normal, start);
+					VectorMA(end, INSIDEUNITS_WALKEND, normal, end);
+					VectorMA(start, INSIDEUNITS_WALKSTART, normal, start);
+					end[2] += 0.125;
+					//
+					height = DotProduct(invgravity, start);
+					//NOTE: if there's nearby solid or a gap area after this area
+					//disabled this crap
+					//if (AAS_NearbySolidOrGap(start, end)) height += 200;
+					//NOTE: disabled because it disables reachabilities to very small areas
+					//if (AAS_PointAreaNum(end) != area2num) continue;
+					//get the longest lowest edge
+					if (height < bestheight ||
+							(height < bestheight + 1 && length > bestlength))
+					{
+						bestheight = height;
+						bestlength = length;
+						//create a new reachability link
+						lr.areanum = area2num;
+						lr.facenum = 0;
+						lr.edgenum = edgenum;
+						VectorCopy(start, lr.start);
+						VectorCopy(end, lr.end);
+						lr.traveltype = TRAVEL_WALK;
+						lr.traveltime = 1;
+						foundreach = qtrue;
+					} //end if
+				} //end for
+			} //end for
+		} //end for
+	} //end for
+	if (foundreach)
+	{
+		//create a new reachability link
+		lreach = AAS_AllocReachability();
+		if (!lreach) return qfalse;
+		lreach->areanum = lr.areanum;
+		lreach->facenum = lr.facenum;
+		lreach->edgenum = lr.edgenum;
+		VectorCopy(lr.start, lreach->start);
+		VectorCopy(lr.end, lreach->end);
+		lreach->traveltype = lr.traveltype;
+		lreach->traveltime = lr.traveltime;
+		lreach->next = areareachability[area1num];
+		areareachability[area1num] = lreach;
+		//if going into a crouch area
+		if (!AAS_AreaCrouch(area1num) && AAS_AreaCrouch(area2num))
+		{
+			lreach->traveltime += aassettings.rs_startcrouch;
+		} //end if
+		/*
+		//NOTE: if there's nearby solid or a gap area after this area
+		if (!AAS_NearbySolidOrGap(lreach->start, lreach->end))
+		{
+			lreach->traveltime += 100;
+		} //end if
+		*/
+		//avoid rather small areas
+		//if (AAS_AreaGroundFaceArea(lreach->areanum) < 500) lreach->traveltime += 100;
+		//
+		reach_equalfloor++;
+		return qtrue;
+	} //end if
+	return qfalse;
+} //end of the function AAS_Reachability_EqualFloorHeight
+//===========================================================================
+// searches step, barrier, waterjump and walk off ledge reachabilities
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int AAS_Reachability_Step_Barrier_WaterJump_WalkOffLedge(int area1num, int area2num)
+{
+	int i, j, k, l, edge1num, edge2num, areas[10], numareas;
+	int ground_bestarea2groundedgenum, ground_foundreach;
+	int water_bestarea2groundedgenum, water_foundreach;
+	int side1, area1swim, faceside1, groundface1num;
+	float dist, dist1, dist2, diff, invgravitydot, ortdot;
+	float x1, x2, x3, x4, y1, y2, y3, y4, tmp, y;
+	float length, ground_bestlength, water_bestlength, ground_bestdist, water_bestdist;
+	vec3_t v1, v2, v3, v4, tmpv, p1area1, p1area2, p2area1, p2area2;
+	vec3_t normal, ort, edgevec, start, end, dir;
+	vec3_t ground_beststart, ground_bestend, ground_bestnormal;
+	vec3_t water_beststart, water_bestend, water_bestnormal;
+	vec3_t invgravity = {0, 0, 1};
+	vec3_t testpoint;
+	aas_plane_t *plane;
+	aas_area_t *area1, *area2;
+	aas_face_t *groundface1, *groundface2, *ground_bestface1, *water_bestface1;
+	aas_edge_t *edge1, *edge2;
+	aas_lreachability_t *lreach;
+	aas_trace_t trace;
+
+	//must be able to walk or swim in the first area
+	if (!AAS_AreaGrounded(area1num) && !AAS_AreaSwim(area1num)) return qfalse;
+	//
+	if (!AAS_AreaGrounded(area2num) && !AAS_AreaSwim(area2num)) return qfalse;
+	//
+	area1 = &aasworld.areas[area1num];
+	area2 = &aasworld.areas[area2num];
+	//if the first area contains a liquid
+	area1swim = AAS_AreaSwim(area1num);
+	//if the areas are not near anough in the x-y direction
+	for (i = 0; i < 2; i++)
+	{
+		if (area1->mins[i] > area2->maxs[i] + 10) return qfalse;
+		if (area1->maxs[i] < area2->mins[i] - 10) return qfalse;
+	} //end for
+	//
+	ground_foundreach = qfalse;
+	ground_bestdist = 99999;
+	ground_bestlength = 0;
+	ground_bestarea2groundedgenum = 0;
+	//
+	water_foundreach = qfalse;
+	water_bestdist = 99999;
+	water_bestlength = 0;
+	water_bestarea2groundedgenum = 0;
+	//
+	for (i = 0; i < area1->numfaces; i++)
+	{
+		groundface1num = aasworld.faceindex[area1->firstface + i];
+		faceside1 = groundface1num < 0;
+		groundface1 = &aasworld.faces[abs(groundface1num)];
+		//if this isn't a ground face
+		if (!(groundface1->faceflags & FACE_GROUND))
+		{
+			//if we can swim in the first area
+			if (area1swim)
+			{
+				//face plane must be more or less horizontal
+				plane = &aasworld.planes[groundface1->planenum ^ (!faceside1)];
+				if (DotProduct(plane->normal, invgravity) < 0.7) continue;
+			} //end if
+			else
+			{
+				//if we can't swim in the area it must be a ground face
+				continue;
+			} //end else
+		} //end if
+		//
+		for (k = 0; k < groundface1->numedges; k++)
+		{
+			edge1num = aasworld.edgeindex[groundface1->firstedge + k];
+			side1 = (edge1num < 0);
+			//NOTE: for water faces we must take the side area 1 is
+			// on into account because the face is shared and doesn't
+			// have to be oriented correctly
+			if (!(groundface1->faceflags & FACE_GROUND)) side1 = (side1 == faceside1);
+			edge1num = abs(edge1num);
+			edge1 = &aasworld.edges[edge1num];
+			//vertexes of the edge
+			VectorCopy(aasworld.vertexes[edge1->v[!side1]], v1);
+			VectorCopy(aasworld.vertexes[edge1->v[side1]], v2);
+			//get a vertical plane through the edge
+			//NOTE: normal is pointing into area 2 because the
+			//face edges are stored counter clockwise
+			VectorSubtract(v2, v1, edgevec);
+			CrossProduct(edgevec, invgravity, normal);
+			VectorNormalize(normal);
+			dist = DotProduct(normal, v1);
+			//check the faces from the second area
+			for (j = 0; j < area2->numfaces; j++)
+			{
+				groundface2 = &aasworld.faces[abs(aasworld.faceindex[area2->firstface + j])];
+				//must be a ground face
+				if (!(groundface2->faceflags & FACE_GROUND)) continue;
+				//check the edges of this ground face
+				for (l = 0; l < groundface2->numedges; l++)
+				{
+					edge2num = abs(aasworld.edgeindex[groundface2->firstedge + l]);
+					edge2 = &aasworld.edges[edge2num];
+					//vertexes of the edge
+					VectorCopy(aasworld.vertexes[edge2->v[0]], v3);
+					VectorCopy(aasworld.vertexes[edge2->v[1]], v4);
+					//check the distance between the two points and the vertical plane
+					//through the edge of area1
+					diff = DotProduct(normal, v3) - dist;
+					if (diff < -0.1 || diff > 0.1) continue;
+					diff = DotProduct(normal, v4) - dist;
+					if (diff < -0.1 || diff > 0.1) continue;
+					//
+					//project the two ground edges into the step side plane
+					//and calculate the shortest distance between the two
+					//edges if they overlap in the direction orthogonal to
+					//the gravity direction
+					CrossProduct(invgravity, normal, ort);
+					invgravitydot = DotProduct(invgravity, invgravity);
+					ortdot = DotProduct(ort, ort);
+					//projection into the step plane
+					//NOTE: since gravity is vertical this is just the z coordinate
+					y1 = v1[2];//DotProduct(v1, invgravity) / invgravitydot;
+					y2 = v2[2];//DotProduct(v2, invgravity) / invgravitydot;
+					y3 = v3[2];//DotProduct(v3, invgravity) / invgravitydot;
+					y4 = v4[2];//DotProduct(v4, invgravity) / invgravitydot;
+					//
+					x1 = DotProduct(v1, ort) / ortdot;
+					x2 = DotProduct(v2, ort) / ortdot;
+					x3 = DotProduct(v3, ort) / ortdot;
+					x4 = DotProduct(v4, ort) / ortdot;
+					//
+					if (x1 > x2)
+					{
+						tmp = x1; x1 = x2; x2 = tmp;
+						tmp = y1; y1 = y2; y2 = tmp;
+						VectorCopy(v1, tmpv); VectorCopy(v2, v1); VectorCopy(tmpv, v2);
+					} //end if
+					if (x3 > x4)
+					{
+						tmp = x3; x3 = x4; x4 = tmp;
+						tmp = y3; y3 = y4; y4 = tmp;
+						VectorCopy(v3, tmpv); VectorCopy(v4, v3); VectorCopy(tmpv, v4);
+					} //end if
+					//if the two projected edge lines have no overlap
+					if (x2 <= x3 || x4 <= x1)
+					{
+//						Log_Write("lines no overlap: from area %d to %d\r\n", area1num, area2num);
+						continue;
+					} //end if
+					//if the two lines fully overlap
+					if ((x1 - 0.5 < x3 && x4 < x2 + 0.5) &&
+							(x3 - 0.5 < x1 && x2 < x4 + 0.5))
+					{
+						dist1 = y3 - y1;
+						dist2 = y4 - y2;
+						VectorCopy(v1, p1area1);
+						VectorCopy(v2, p2area1);
+						VectorCopy(v3, p1area2);
+						VectorCopy(v4, p2area2);
+					} //end if
+					else
+					{
+						//if the points are equal
+						if (x1 > x3 - 0.1 && x1 < x3 + 0.1)
+						{
+							dist1 = y3 - y1;
+							VectorCopy(v1, p1area1);
+							VectorCopy(v3, p1area2);
+						} //end if
+						else if (x1 < x3)
+						{
+							y = y1 + (x3 - x1) * (y2 - y1) / (x2 - x1);
+							dist1 = y3 - y;
+							VectorCopy(v3, p1area1);
+							p1area1[2] = y;
+							VectorCopy(v3, p1area2);
+						} //end if
+						else
+						{
+							y = y3 + (x1 - x3) * (y4 - y3) / (x4 - x3);
+							dist1 = y - y1;
+							VectorCopy(v1, p1area1);
+							VectorCopy(v1, p1area2);
+							p1area2[2] = y;
+						} //end if
+						//if the points are equal
+						if (x2 > x4 - 0.1 && x2 < x4 + 0.1)
+						{
+							dist2 = y4 - y2;
+							VectorCopy(v2, p2area1);
+							VectorCopy(v4, p2area2);
+						} //end if
+						else if (x2 < x4)
+						{
+							y = y3 + (x2 - x3) * (y4 - y3) / (x4 - x3);
+							dist2 = y - y2;
+							VectorCopy(v2, p2area1);
+							VectorCopy(v2, p2area2);
+							p2area2[2] = y;
+						} //end if
+						else
+						{
+							y = y1 + (x4 - x1) * (y2 - y1) / (x2 - x1);
+							dist2 = y4 - y;
+							VectorCopy(v4, p2area1);
+							p2area1[2] = y;
+							VectorCopy(v4, p2area2);
+						} //end else
+					} //end else
+					//if both distances are pretty much equal
+					//then we take the middle of the points
+					if (dist1 > dist2 - 1 && dist1 < dist2 + 1)
+					{
+						dist = dist1;
+						VectorAdd(p1area1, p2area1, start);
+						VectorScale(start, 0.5, start);
+						VectorAdd(p1area2, p2area2, end);
+						VectorScale(end, 0.5, end);
+					} //end if
+					else if (dist1 < dist2)
+					{
+						dist = dist1;
+						VectorCopy(p1area1, start);
+						VectorCopy(p1area2, end);
+					} //end else if
+					else
+					{
+						dist = dist2;
+						VectorCopy(p2area1, start);
+						VectorCopy(p2area2, end);
+					} //end else
+					//get the length of the overlapping part of the edges of the two areas
+					VectorSubtract(p2area2, p1area2, dir);
+					length = VectorLength(dir);
+					//
+					if (groundface1->faceflags & FACE_GROUND)
+					{
+						//if the vertical distance is smaller
+						if (dist < ground_bestdist ||
+								//or the vertical distance is pretty much the same
+								//but the overlapping part of the edges is longer
+								(dist < ground_bestdist + 1 && length > ground_bestlength))
+						{
+							ground_bestdist = dist;
+							ground_bestlength = length;
+							ground_foundreach = qtrue;
+							ground_bestarea2groundedgenum = edge1num;
+							ground_bestface1 = groundface1;
+							//best point towards area1
+							VectorCopy(start, ground_beststart);
+							//normal is pointing into area2
+							VectorCopy(normal, ground_bestnormal);
+							//best point towards area2
+							VectorCopy(end, ground_bestend);
+						} //end if
+					} //end if
+					else
+					{
+						//if the vertical distance is smaller
+						if (dist < water_bestdist ||
+								//or the vertical distance is pretty much the same
+								//but the overlapping part of the edges is longer
+								(dist < water_bestdist + 1 && length > water_bestlength))
+						{
+							water_bestdist = dist;
+							water_bestlength = length;
+							water_foundreach = qtrue;
+							water_bestarea2groundedgenum = edge1num;
+							water_bestface1 = groundface1;
+							//best point towards area1
+							VectorCopy(start, water_beststart);
+							//normal is pointing into area2
+							VectorCopy(normal, water_bestnormal);
+							//best point towards area2
+							VectorCopy(end, water_bestend);
+						} //end if
+					} //end else
+				} //end for
+			} //end for
+		} //end for
+	} //end for
+	//
+	// NOTE: swim reachabilities are already filtered out
+	//
+	// Steps
+	//
+	//        ---------
+	//        |          step height -> TRAVEL_WALK
+	//--------|
+	//
+	//        ---------
+	//~~~~~~~~|          step height and low water -> TRAVEL_WALK
+	//--------|
+	//
+	//~~~~~~~~~~~~~~~~~~
+	//        ---------
+	//        |          step height and low water up to the step -> TRAVEL_WALK
+	//--------|
+	//
+	//check for a step reachability
+	if (ground_foundreach)
+	{
+		//if area2 is higher but lower than the maximum step height
+		//NOTE: ground_bestdist >= 0 also catches equal floor reachabilities
+		if (ground_bestdist >= 0 && ground_bestdist < aassettings.phys_maxstep)
+		{
+			//create walk reachability from area1 to area2
+			lreach = AAS_AllocReachability();
+			if (!lreach) return qfalse;
+			lreach->areanum = area2num;
+			lreach->facenum = 0;
+			lreach->edgenum = ground_bestarea2groundedgenum;
+			VectorMA(ground_beststart, INSIDEUNITS_WALKSTART, ground_bestnormal, lreach->start);
+			VectorMA(ground_bestend, INSIDEUNITS_WALKEND, ground_bestnormal, lreach->end);
+			lreach->traveltype = TRAVEL_WALK;
+			lreach->traveltime = 0;//1;
+			//if going into a crouch area
+			if (!AAS_AreaCrouch(area1num) && AAS_AreaCrouch(area2num))
+			{
+				lreach->traveltime += aassettings.rs_startcrouch;
+			} //end if
+			lreach->next = areareachability[area1num];
+			areareachability[area1num] = lreach;
+			//NOTE: if there's nearby solid or a gap area after this area
+			/*
+			if (!AAS_NearbySolidOrGap(lreach->start, lreach->end))
+			{
+				lreach->traveltime += 100;
+			} //end if
+			*/
+			//avoid rather small areas
+			//if (AAS_AreaGroundFaceArea(lreach->areanum) < 500) lreach->traveltime += 100;
+			//
+			reach_step++;
+			return qtrue;
+		} //end if
+	} //end if
+	//
+	// Water Jumps
+	//
+	//        ---------
+	//        |
+	//~~~~~~~~|
+	//        |
+	//        |          higher than step height and water up to waterjump height -> TRAVEL_WATERJUMP
+	//--------|
+	//
+	//~~~~~~~~~~~~~~~~~~
+	//        ---------
+	//        |
+	//        |
+	//        |
+	//        |          higher than step height and low water up to the step -> TRAVEL_WATERJUMP
+	//--------|
+	//
+	//check for a waterjump reachability
+	if (water_foundreach)
+	{
+		//get a test point a little bit towards area1
+		VectorMA(water_bestend, -INSIDEUNITS, water_bestnormal, testpoint);
+		//go down the maximum waterjump height
+		testpoint[2] -= aassettings.phys_maxwaterjump;
+		//if there IS water the sv_maxwaterjump height below the bestend point
+		if (aasworld.areasettings[AAS_PointAreaNum(testpoint)].areaflags & AREA_LIQUID)
+		{
+			//don't create rediculous water jump reachabilities from areas very far below
+			//the water surface
+			if (water_bestdist < aassettings.phys_maxwaterjump + 24)
+			{
+				//waterjumping from or towards a crouch only area is not possible in Quake2
+				if ((aasworld.areasettings[area1num].presencetype & PRESENCE_NORMAL) &&
+						(aasworld.areasettings[area2num].presencetype & PRESENCE_NORMAL))
+				{
+					//create water jump reachability from area1 to area2
+					lreach = AAS_AllocReachability();
+					if (!lreach) return qfalse;
+					lreach->areanum = area2num;
+					lreach->facenum = 0;
+					lreach->edgenum = water_bestarea2groundedgenum;
+					VectorCopy(water_beststart, lreach->start);
+					VectorMA(water_bestend, INSIDEUNITS_WATERJUMP, water_bestnormal, lreach->end);
+					lreach->traveltype = TRAVEL_WATERJUMP;
+					lreach->traveltime = aassettings.rs_waterjump;
+					lreach->next = areareachability[area1num];
+					areareachability[area1num] = lreach;
+					//we've got another waterjump reachability
+					reach_waterjump++;
+					return qtrue;
+				} //end if
+			} //end if
+		} //end if
+	} //end if
+	//
+	// Barrier Jumps
+	//
+	//        ---------
+	//        |
+	//        |
+	//        |
+	//        |         higher than step height lower than barrier height -> TRAVEL_BARRIERJUMP
+	//--------|
+	//
+	//        ---------
+	//        |
+	//        |
+	//        |
+	//~~~~~~~~|         higher than step height lower than barrier height
+	//--------|         and a thin layer of water in the area to jump from -> TRAVEL_BARRIERJUMP
+	//
+	//check for a barrier jump reachability
+	if (ground_foundreach)
+	{
+		//if area2 is higher but lower than the maximum barrier jump height
+		if (ground_bestdist > 0 && ground_bestdist < aassettings.phys_maxbarrier)
+		{
+			//if no water in area1 or a very thin layer of water on the ground
+			if (!water_foundreach || (ground_bestdist - water_bestdist < 16))
+			{
+				//cannot perform a barrier jump towards or from a crouch area in Quake2
+				if (!AAS_AreaCrouch(area1num) && !AAS_AreaCrouch(area2num))
+				{
+					//create barrier jump reachability from area1 to area2
+					lreach = AAS_AllocReachability();
+					if (!lreach) return qfalse;
+					lreach->areanum = area2num;
+					lreach->facenum = 0;
+					lreach->edgenum = ground_bestarea2groundedgenum;
+					VectorMA(ground_beststart, INSIDEUNITS_WALKSTART, ground_bestnormal, lreach->start);
+					VectorMA(ground_bestend, INSIDEUNITS_WALKEND, ground_bestnormal, lreach->end);
+					lreach->traveltype = TRAVEL_BARRIERJUMP;
+					lreach->traveltime = aassettings.rs_barrierjump;//AAS_BarrierJumpTravelTime();
+					lreach->next = areareachability[area1num];
+					areareachability[area1num] = lreach;
+					//we've got another barrierjump reachability
+					reach_barrier++;
+					return qtrue;
+				} //end if
+			} //end if
+		} //end if
+	} //end if
+	//
+	// Walk and Walk Off Ledge
+	//
+	//--------|
+	//        |          can walk or step back -> TRAVEL_WALK
+	//        ---------
+	//
+	//--------|
+	//        |
+	//        |
+	//        |
+	//        |          cannot walk/step back -> TRAVEL_WALKOFFLEDGE
+	//        ---------
+	//
+	//--------|
+	//        |
+	//        |~~~~~~~~
+	//        |
+	//        |          cannot step back but can waterjump back -> TRAVEL_WALKOFFLEDGE
+	//        ---------  FIXME: create TRAVEL_WALK reach??
+	//
+	//check for a walk or walk off ledge reachability
+	if (ground_foundreach)
+	{
+		if (ground_bestdist < 0)
+		{
+			if (ground_bestdist > -aassettings.phys_maxstep)
+			{
+				//create walk reachability from area1 to area2
+				lreach = AAS_AllocReachability();
+				if (!lreach) return qfalse;
+				lreach->areanum = area2num;
+				lreach->facenum = 0;
+				lreach->edgenum = ground_bestarea2groundedgenum;
+				VectorMA(ground_beststart, INSIDEUNITS_WALKSTART, ground_bestnormal, lreach->start);
+				VectorMA(ground_bestend, INSIDEUNITS_WALKEND, ground_bestnormal, lreach->end);
+				lreach->traveltype = TRAVEL_WALK;
+				lreach->traveltime = 1;
+				lreach->next = areareachability[area1num];
+				areareachability[area1num] = lreach;
+				//we've got another walk reachability
+				reach_walk++;
+				return qtrue;
+			} //end if
+			// if no maximum fall height set or less than the max
+			if (!aassettings.rs_maxfallheight || fabs(ground_bestdist) < aassettings.rs_maxfallheight) {
+				//trace a bounding box vertically to check for solids
+				VectorMA(ground_bestend, INSIDEUNITS, ground_bestnormal, ground_bestend);
+				VectorCopy(ground_bestend, start);
+				start[2] = ground_beststart[2];
+				VectorCopy(ground_bestend, end);
+				end[2] += 4;
+				trace = AAS_TraceClientBBox(start, end, PRESENCE_NORMAL, -1);
+				//if no solids were found
+				if (!trace.startsolid && trace.fraction >= 1.0)
+				{
+					//the trace end point must be in the goal area
+					trace.endpos[2] += 1;
+					if (AAS_PointAreaNum(trace.endpos) == area2num)
+					{
+						//if not going through a cluster portal
+						numareas = AAS_TraceAreas(start, end, areas, NULL, sizeof(areas) / sizeof(int));
+						for (i = 0; i < numareas; i++)
+							if (AAS_AreaClusterPortal(areas[i]))
+								break;
+						if (i >= numareas)
+						{
+							//create a walk off ledge reachability from area1 to area2
+							lreach = AAS_AllocReachability();
+							if (!lreach) return qfalse;
+							lreach->areanum = area2num;
+							lreach->facenum = 0;
+							lreach->edgenum = ground_bestarea2groundedgenum;
+							VectorCopy(ground_beststart, lreach->start);
+							VectorCopy(ground_bestend, lreach->end);
+							lreach->traveltype = TRAVEL_WALKOFFLEDGE;
+							lreach->traveltime = aassettings.rs_startwalkoffledge + fabs(ground_bestdist) * 50 / aassettings.phys_gravity;
+							//if falling from too high and not falling into water
+							if (!AAS_AreaSwim(area2num) && !AAS_AreaJumpPad(area2num))
+							{
+								if (AAS_FallDelta(ground_bestdist) > aassettings.phys_falldelta5)
+								{
+									lreach->traveltime += aassettings.rs_falldamage5;
+								} //end if
+								if (AAS_FallDelta(ground_bestdist) > aassettings.phys_falldelta10)
+								{
+									lreach->traveltime += aassettings.rs_falldamage10;
+								} //end if
+							} //end if
+							lreach->next = areareachability[area1num];
+							areareachability[area1num] = lreach;
+							//
+							reach_walkoffledge++;
+							//NOTE: don't create a weapon (rl, bfg) jump reachability here
+							//because it interferes with other reachabilities
+							//like the ladder reachability
+							return qtrue;
+						} //end if
+					} //end if
+				} //end if
+			} //end if
+		} //end else
+	} //end if
+	return qfalse;
+} //end of the function AAS_Reachability_Step_Barrier_WaterJump_WalkOffLedge
+//===========================================================================
+// returns the distance between the two vectors
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+float VectorDistance(vec3_t v1, vec3_t v2)
+{
+	vec3_t dir;
+
+	VectorSubtract(v2, v1, dir);
+	return VectorLength(dir);
+} //end of the function VectorDistance
+//===========================================================================
+// returns true if the first vector is between the last two vectors
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int VectorBetweenVectors(vec3_t v, vec3_t v1, vec3_t v2)
+{
+	vec3_t dir1, dir2;
+
+	VectorSubtract(v, v1, dir1);
+	VectorSubtract(v, v2, dir2);
+	return (DotProduct(dir1, dir2) <= 0);
+} //end of the function VectorBetweenVectors
+//===========================================================================
+// returns the mid point between the two vectors
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void VectorMiddle(vec3_t v1, vec3_t v2, vec3_t middle)
+{
+	VectorAdd(v1, v2, middle);
+	VectorScale(middle, 0.5, middle);
+} //end of the function VectorMiddle
+//===========================================================================
+// calculate a range of points closest to each other on both edges
+//
+// Parameter:			beststart1		start of the range of points on edge v1-v2
+//						beststart2		end of the range of points  on edge v1-v2
+//						bestend1		start of the range of points on edge v3-v4
+//						bestend2		end of the range of points  on edge v3-v4
+//						bestdist		best distance so far
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+/*
+float AAS_ClosestEdgePoints(vec3_t v1, vec3_t v2, vec3_t v3, vec3_t v4,
+							aas_plane_t *plane1, aas_plane_t *plane2,
+							vec3_t beststart, vec3_t bestend, float bestdist)
+{
+	vec3_t dir1, dir2, p1, p2, p3, p4;
+	float a1, a2, b1, b2, dist;
+	int founddist;
+
+	//edge vectors
+	VectorSubtract(v2, v1, dir1);
+	VectorSubtract(v4, v3, dir2);
+	//get the horizontal directions
+	dir1[2] = 0;
+	dir2[2] = 0;
+	//
+	// p1 = point on an edge vector of area2 closest to v1
+	// p2 = point on an edge vector of area2 closest to v2
+	// p3 = point on an edge vector of area1 closest to v3
+	// p4 = point on an edge vector of area1 closest to v4
+	//
+	if (dir2[0])
+	{
+		a2 = dir2[1] / dir2[0];
+		b2 = v3[1] - a2 * v3[0];
+		//point on the edge vector of area2 closest to v1
+		p1[0] = (DotProduct(v1, dir2) - (a2 * dir2[0] + b2 * dir2[1])) / dir2[0];
+		p1[1] = a2 * p1[0] + b2;
+		//point on the edge vector of area2 closest to v2
+		p2[0] = (DotProduct(v2, dir2) - (a2 * dir2[0] + b2 * dir2[1])) / dir2[0];
+		p2[1] = a2 * p2[0] + b2;
+	} //end if
+	else
+	{
+		//point on the edge vector of area2 closest to v1
+		p1[0] = v3[0];
+		p1[1] = v1[1];
+		//point on the edge vector of area2 closest to v2
+		p2[0] = v3[0];
+		p2[1] = v2[1];
+	} //end else
+	//
+	if (dir1[0])
+	{
+		//
+		a1 = dir1[1] / dir1[0];
+		b1 = v1[1] - a1 * v1[0];
+		//point on the edge vector of area1 closest to v3
+		p3[0] = (DotProduct(v3, dir1) - (a1 * dir1[0] + b1 * dir1[1])) / dir1[0];
+		p3[1] = a1 * p3[0] + b1;
+		//point on the edge vector of area1 closest to v4
+		p4[0] = (DotProduct(v4, dir1) - (a1 * dir1[0] + b1 * dir1[1])) / dir1[0];
+		p4[1] = a1 * p4[0] + b1;
+	} //end if
+	else
+	{
+		//point on the edge vector of area1 closest to v3
+		p3[0] = v1[0];
+		p3[1] = v3[1];
+		//point on the edge vector of area1 closest to v4
+		p4[0] = v1[0];
+		p4[1] = v4[1];
+	} //end else
+	//start with zero z-coordinates
+	p1[2] = 0;
+	p2[2] = 0;
+	p3[2] = 0;
+	p4[2] = 0;
+	//calculate the z-coordinates from the ground planes
+	p1[2] = (plane2->dist - DotProduct(plane2->normal, p1)) / plane2->normal[2];
+	p2[2] = (plane2->dist - DotProduct(plane2->normal, p2)) / plane2->normal[2];
+	p3[2] = (plane1->dist - DotProduct(plane1->normal, p3)) / plane1->normal[2];
+	p4[2] = (plane1->dist - DotProduct(plane1->normal, p4)) / plane1->normal[2];
+	//
+	founddist = qfalse;
+	//
+	if (VectorBetweenVectors(p1, v3, v4))
+	{
+		dist = VectorDistance(v1, p1);
+		if (dist > bestdist - 0.5 && dist < bestdist + 0.5)
+		{
+			VectorMiddle(beststart, v1, beststart);
+			VectorMiddle(bestend, p1, bestend);
+		} //end if
+		else if (dist < bestdist)
+		{
+			bestdist = dist;
+			VectorCopy(v1, beststart);
+			VectorCopy(p1, bestend);
+		} //end if
+		founddist = qtrue;
+	} //end if
+	if (VectorBetweenVectors(p2, v3, v4))
+	{
+		dist = VectorDistance(v2, p2);
+		if (dist > bestdist - 0.5 && dist < bestdist + 0.5)
+		{
+			VectorMiddle(beststart, v2, beststart);
+			VectorMiddle(bestend, p2, bestend);
+		} //end if
+		else if (dist < bestdist)
+		{
+			bestdist = dist;
+			VectorCopy(v2, beststart);
+			VectorCopy(p2, bestend);
+		} //end if
+		founddist = qtrue;
+	} //end else if
+	if (VectorBetweenVectors(p3, v1, v2))
+	{
+		dist = VectorDistance(v3, p3);
+		if (dist > bestdist - 0.5 && dist < bestdist + 0.5)
+		{
+			VectorMiddle(beststart, p3, beststart);
+			VectorMiddle(bestend, v3, bestend);
+		} //end if
+		else if (dist < bestdist)
+		{
+			bestdist = dist;
+			VectorCopy(p3, beststart);
+			VectorCopy(v3, bestend);
+		} //end if
+		founddist = qtrue;
+	} //end else if
+	if (VectorBetweenVectors(p4, v1, v2))
+	{
+		dist = VectorDistance(v4, p4);
+		if (dist > bestdist - 0.5 && dist < bestdist + 0.5)
+		{
+			VectorMiddle(beststart, p4, beststart);
+			VectorMiddle(bestend, v4, bestend);
+		} //end if
+		else if (dist < bestdist)
+		{
+			bestdist = dist;
+			VectorCopy(p4, beststart);
+			VectorCopy(v4, bestend);
+		} //end if
+		founddist = qtrue;
+	} //end else if
+	//if no shortest distance was found the shortest distance
+	//is between one of the vertexes of edge1 and one of edge2
+	if (!founddist)
+	{
+		dist = VectorDistance(v1, v3);
+		if (dist < bestdist)
+		{
+			bestdist = dist;
+			VectorCopy(v1, beststart);
+			VectorCopy(v3, bestend);
+		} //end if
+		dist = VectorDistance(v1, v4);
+		if (dist < bestdist)
+		{
+			bestdist = dist;
+			VectorCopy(v1, beststart);
+			VectorCopy(v4, bestend);
+		} //end if
+		dist = VectorDistance(v2, v3);
+		if (dist < bestdist)
+		{
+			bestdist = dist;
+			VectorCopy(v2, beststart);
+			VectorCopy(v3, bestend);
+		} //end if
+		dist = VectorDistance(v2, v4);
+		if (dist < bestdist)
+		{
+			bestdist = dist;
+			VectorCopy(v2, beststart);
+			VectorCopy(v4, bestend);
+		} //end if
+	} //end if
+	return bestdist;
+} //end of the function AAS_ClosestEdgePoints*/
+
+float AAS_ClosestEdgePoints(vec3_t v1, vec3_t v2, vec3_t v3, vec3_t v4,
+							aas_plane_t *plane1, aas_plane_t *plane2,
+							vec3_t beststart1, vec3_t bestend1,
+							vec3_t beststart2, vec3_t bestend2, float bestdist)
+{
+	vec3_t dir1, dir2, p1, p2, p3, p4;
+	float a1, a2, b1, b2, dist, dist1, dist2;
+	int founddist;
+
+	//edge vectors
+	VectorSubtract(v2, v1, dir1);
+	VectorSubtract(v4, v3, dir2);
+	//get the horizontal directions
+	dir1[2] = 0;
+	dir2[2] = 0;
+	//
+	// p1 = point on an edge vector of area2 closest to v1
+	// p2 = point on an edge vector of area2 closest to v2
+	// p3 = point on an edge vector of area1 closest to v3
+	// p4 = point on an edge vector of area1 closest to v4
+	//
+	if (dir2[0])
+	{
+		a2 = dir2[1] / dir2[0];
+		b2 = v3[1] - a2 * v3[0];
+		//point on the edge vector of area2 closest to v1
+		p1[0] = (DotProduct(v1, dir2) - (a2 * dir2[0] + b2 * dir2[1])) / dir2[0];
+		p1[1] = a2 * p1[0] + b2;
+		//point on the edge vector of area2 closest to v2
+		p2[0] = (DotProduct(v2, dir2) - (a2 * dir2[0] + b2 * dir2[1])) / dir2[0];
+		p2[1] = a2 * p2[0] + b2;
+	} //end if
+	else
+	{
+		//point on the edge vector of area2 closest to v1
+		p1[0] = v3[0];
+		p1[1] = v1[1];
+		//point on the edge vector of area2 closest to v2
+		p2[0] = v3[0];
+		p2[1] = v2[1];
+	} //end else
+	//
+	if (dir1[0])
+	{
+		//
+		a1 = dir1[1] / dir1[0];
+		b1 = v1[1] - a1 * v1[0];
+		//point on the edge vector of area1 closest to v3
+		p3[0] = (DotProduct(v3, dir1) - (a1 * dir1[0] + b1 * dir1[1])) / dir1[0];
+		p3[1] = a1 * p3[0] + b1;
+		//point on the edge vector of area1 closest to v4
+		p4[0] = (DotProduct(v4, dir1) - (a1 * dir1[0] + b1 * dir1[1])) / dir1[0];
+		p4[1] = a1 * p4[0] + b1;
+	} //end if
+	else
+	{
+		//point on the edge vector of area1 closest to v3
+		p3[0] = v1[0];
+		p3[1] = v3[1];
+		//point on the edge vector of area1 closest to v4
+		p4[0] = v1[0];
+		p4[1] = v4[1];
+	} //end else
+	//start with zero z-coordinates
+	p1[2] = 0;
+	p2[2] = 0;
+	p3[2] = 0;
+	p4[2] = 0;
+	//calculate the z-coordinates from the ground planes
+	p1[2] = (plane2->dist - DotProduct(plane2->normal, p1)) / plane2->normal[2];
+	p2[2] = (plane2->dist - DotProduct(plane2->normal, p2)) / plane2->normal[2];
+	p3[2] = (plane1->dist - DotProduct(plane1->normal, p3)) / plane1->normal[2];
+	p4[2] = (plane1->dist - DotProduct(plane1->normal, p4)) / plane1->normal[2];
+	//
+	founddist = qfalse;
+	//
+	if (VectorBetweenVectors(p1, v3, v4))
+	{
+		dist = VectorDistance(v1, p1);
+		if (dist > bestdist - 0.5 && dist < bestdist + 0.5)
+		{
+			dist1 = VectorDistance(beststart1, v1);
+			dist2 = VectorDistance(beststart2, v1);
+			if (dist1 > dist2)
+			{
+				if (dist1 > VectorDistance(beststart1, beststart2)) VectorCopy(v1, beststart2);
+			} //end if
+			else
+			{
+				if (dist2 > VectorDistance(beststart1, beststart2)) VectorCopy(v1, beststart1);
+			} //end else
+			dist1 = VectorDistance(bestend1, p1);
+			dist2 = VectorDistance(bestend2, p1);
+			if (dist1 > dist2)
+			{
+				if (dist1 > VectorDistance(bestend1, bestend2)) VectorCopy(p1, bestend2);
+			} //end if
+			else
+			{
+				if (dist2 > VectorDistance(bestend1, bestend2)) VectorCopy(p1, bestend1);
+			} //end else
+		} //end if
+		else if (dist < bestdist)
+		{
+			bestdist = dist;
+			VectorCopy(v1, beststart1);
+			VectorCopy(v1, beststart2);
+			VectorCopy(p1, bestend1);
+			VectorCopy(p1, bestend2);
+		} //end if
+		founddist = qtrue;
+	} //end if
+	if (VectorBetweenVectors(p2, v3, v4))
+	{
+		dist = VectorDistance(v2, p2);
+		if (dist > bestdist - 0.5 && dist < bestdist + 0.5)
+		{
+			dist1 = VectorDistance(beststart1, v2);
+			dist2 = VectorDistance(beststart2, v2);
+			if (dist1 > dist2)
+			{
+				if (dist1 > VectorDistance(beststart1, beststart2)) VectorCopy(v2, beststart2);
+			} //end if
+			else
+			{
+				if (dist2 > VectorDistance(beststart1, beststart2)) VectorCopy(v2, beststart1);
+			} //end else
+			dist1 = VectorDistance(bestend1, p2);
+			dist2 = VectorDistance(bestend2, p2);
+			if (dist1 > dist2)
+			{
+				if (dist1 > VectorDistance(bestend1, bestend2)) VectorCopy(p2, bestend2);
+			} //end if
+			else
+			{
+				if (dist2 > VectorDistance(bestend1, bestend2)) VectorCopy(p2, bestend1);
+			} //end else
+		} //end if
+		else if (dist < bestdist)
+		{
+			bestdist = dist;
+			VectorCopy(v2, beststart1);
+			VectorCopy(v2, beststart2);
+			VectorCopy(p2, bestend1);
+			VectorCopy(p2, bestend2);
+		} //end if
+		founddist = qtrue;
+	} //end else if
+	if (VectorBetweenVectors(p3, v1, v2))
+	{
+		dist = VectorDistance(v3, p3);
+		if (dist > bestdist - 0.5 && dist < bestdist + 0.5)
+		{
+			dist1 = VectorDistance(beststart1, p3);
+			dist2 = VectorDistance(beststart2, p3);
+			if (dist1 > dist2)
+			{
+				if (dist1 > VectorDistance(beststart1, beststart2)) VectorCopy(p3, beststart2);
+			} //end if
+			else
+			{
+				if (dist2 > VectorDistance(beststart1, beststart2)) VectorCopy(p3, beststart1);
+			} //end else
+			dist1 = VectorDistance(bestend1, v3);
+			dist2 = VectorDistance(bestend2, v3);
+			if (dist1 > dist2)
+			{
+				if (dist1 > VectorDistance(bestend1, bestend2)) VectorCopy(v3, bestend2);
+			} //end if
+			else
+			{
+				if (dist2 > VectorDistance(bestend1, bestend2)) VectorCopy(v3, bestend1);
+			} //end else
+		} //end if
+		else if (dist < bestdist)
+		{
+			bestdist = dist;
+			VectorCopy(p3, beststart1);
+			VectorCopy(p3, beststart2);
+			VectorCopy(v3, bestend1);
+			VectorCopy(v3, bestend2);
+		} //end if
+		founddist = qtrue;
+	} //end else if
+	if (VectorBetweenVectors(p4, v1, v2))
+	{
+		dist = VectorDistance(v4, p4);
+		if (dist > bestdist - 0.5 && dist < bestdist + 0.5)
+		{
+			dist1 = VectorDistance(beststart1, p4);
+			dist2 = VectorDistance(beststart2, p4);
+			if (dist1 > dist2)
+			{
+				if (dist1 > VectorDistance(beststart1, beststart2)) VectorCopy(p4, beststart2);
+			} //end if
+			else
+			{
+				if (dist2 > VectorDistance(beststart1, beststart2)) VectorCopy(p4, beststart1);
+			} //end else
+			dist1 = VectorDistance(bestend1, v4);
+			dist2 = VectorDistance(bestend2, v4);
+			if (dist1 > dist2)
+			{
+				if (dist1 > VectorDistance(bestend1, bestend2)) VectorCopy(v4, bestend2);
+			} //end if
+			else
+			{
+				if (dist2 > VectorDistance(bestend1, bestend2)) VectorCopy(v4, bestend1);
+			} //end else
+		} //end if
+		else if (dist < bestdist)
+		{
+			bestdist = dist;
+			VectorCopy(p4, beststart1);
+			VectorCopy(p4, beststart2);
+			VectorCopy(v4, bestend1);
+			VectorCopy(v4, bestend2);
+		} //end if
+		founddist = qtrue;
+	} //end else if
+	//if no shortest distance was found the shortest distance
+	//is between one of the vertexes of edge1 and one of edge2
+	if (!founddist)
+	{
+		dist = VectorDistance(v1, v3);
+		if (dist < bestdist)
+		{
+			bestdist = dist;
+			VectorCopy(v1, beststart1);
+			VectorCopy(v1, beststart2);
+			VectorCopy(v3, bestend1);
+			VectorCopy(v3, bestend2);
+		} //end if
+		dist = VectorDistance(v1, v4);
+		if (dist < bestdist)
+		{
+			bestdist = dist;
+			VectorCopy(v1, beststart1);
+			VectorCopy(v1, beststart2);
+			VectorCopy(v4, bestend1);
+			VectorCopy(v4, bestend2);
+		} //end if
+		dist = VectorDistance(v2, v3);
+		if (dist < bestdist)
+		{
+			bestdist = dist;
+			VectorCopy(v2, beststart1);
+			VectorCopy(v2, beststart2);
+			VectorCopy(v3, bestend1);
+			VectorCopy(v3, bestend2);
+		} //end if
+		dist = VectorDistance(v2, v4);
+		if (dist < bestdist)
+		{
+			bestdist = dist;
+			VectorCopy(v2, beststart1);
+			VectorCopy(v2, beststart2);
+			VectorCopy(v4, bestend1);
+			VectorCopy(v4, bestend2);
+		} //end if
+	} //end if
+	return bestdist;
+} //end of the function AAS_ClosestEdgePoints
+//===========================================================================
+// creates possible jump reachabilities between the areas
+//
+// The two closest points on the ground of the areas are calculated
+// One of the points will be on an edge of a ground face of area1 and
+// one on an edge of a ground face of area2.
+// If there is a range of closest points the point in the middle of this range
+// is selected.
+// Between these two points there must be one or more gaps.
+// If the gaps exist a potential jump is predicted.
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int AAS_Reachability_Jump(int area1num, int area2num)
+{
+	int i, j, k, l, face1num, face2num, edge1num, edge2num, traveltype;
+	int stopevent, areas[10], numareas;
+	float phys_jumpvel, maxjumpdistance, maxjumpheight, height, bestdist, speed;
+	vec_t *v1, *v2, *v3, *v4;
+	vec3_t beststart, beststart2, bestend, bestend2;
+	vec3_t teststart, testend, dir, velocity, cmdmove, up = {0, 0, 1}, sidewards;
+	aas_area_t *area1, *area2;
+	aas_face_t *face1, *face2;
+	aas_edge_t *edge1, *edge2;
+	aas_plane_t *plane1, *plane2, *plane;
+	aas_trace_t trace;
+	aas_clientmove_t move;
+	aas_lreachability_t *lreach;
+
+	if (!AAS_AreaGrounded(area1num) || !AAS_AreaGrounded(area2num)) return qfalse;
+	//cannot jump from or to a crouch area
+	if (AAS_AreaCrouch(area1num) || AAS_AreaCrouch(area2num)) return qfalse;
+	//
+	area1 = &aasworld.areas[area1num];
+	area2 = &aasworld.areas[area2num];
+	//
+	phys_jumpvel = aassettings.phys_jumpvel;
+	//maximum distance a player can jump
+	maxjumpdistance = 2 * AAS_MaxJumpDistance(phys_jumpvel);
+	//maximum height a player can jump with the given initial z velocity
+	maxjumpheight = AAS_MaxJumpHeight(phys_jumpvel);
+
+	//if the areas are not near anough in the x-y direction
+	for (i = 0; i < 2; i++)
+	{
+		if (area1->mins[i] > area2->maxs[i] + maxjumpdistance) return qfalse;
+		if (area1->maxs[i] < area2->mins[i] - maxjumpdistance) return qfalse;
+	} //end for
+	//if area2 is way to high to jump up to
+	if (area2->mins[2] > area1->maxs[2] + maxjumpheight) return qfalse;
+	//
+	bestdist = 999999;
+	//
+	for (i = 0; i < area1->numfaces; i++)
+	{
+		face1num = aasworld.faceindex[area1->firstface + i];
+		face1 = &aasworld.faces[abs(face1num)];
+		//if not a ground face
+		if (!(face1->faceflags & FACE_GROUND)) continue;
+		//
+		for (j = 0; j < area2->numfaces; j++)
+		{
+			face2num = aasworld.faceindex[area2->firstface + j];
+			face2 = &aasworld.faces[abs(face2num)];
+			//if not a ground face
+			if (!(face2->faceflags & FACE_GROUND)) continue;
+			//
+			for (k = 0; k < face1->numedges; k++)
+			{
+				edge1num = abs(aasworld.edgeindex[face1->firstedge + k]);
+				edge1 = &aasworld.edges[edge1num];
+				for (l = 0; l < face2->numedges; l++)
+				{
+					edge2num = abs(aasworld.edgeindex[face2->firstedge + l]);
+					edge2 = &aasworld.edges[edge2num];
+					//calculate the minimum distance between the two edges
+					v1 = aasworld.vertexes[edge1->v[0]];
+					v2 = aasworld.vertexes[edge1->v[1]];
+					v3 = aasworld.vertexes[edge2->v[0]];
+					v4 = aasworld.vertexes[edge2->v[1]];
+					//get the ground planes
+					plane1 = &aasworld.planes[face1->planenum];
+					plane2 = &aasworld.planes[face2->planenum];
+					//
+					bestdist = AAS_ClosestEdgePoints(v1, v2, v3, v4, plane1, plane2,
+														beststart, bestend,
+														beststart2, bestend2, bestdist);
+				} //end for
+			} //end for
+		} //end for
+	} //end for
+	VectorMiddle(beststart, beststart2, beststart);
+	VectorMiddle(bestend, bestend2, bestend);
+	if (bestdist > 4 && bestdist < maxjumpdistance)
+	{
+//		Log_Write("shortest distance between %d and %d is %f\r\n", area1num, area2num, bestdist);
+		// if very close and almost no height difference then the bot can walk
+		if (bestdist <= 48 && fabs(beststart[2] - bestend[2]) < 8)
+		{
+			speed = 400;
+			traveltype = TRAVEL_WALKOFFLEDGE;
+		} //end if
+		else if (AAS_HorizontalVelocityForJump(0, beststart, bestend, &speed))
+		{
+			//FIXME: why multiply with 1.2???
+			speed *= 1.2f;
+			traveltype = TRAVEL_WALKOFFLEDGE;
+		} //end else if
+		else
+		{
+			//get the horizontal speed for the jump, if it isn't possible to calculate this
+			//speed (the jump is not possible) then there's no jump reachability created
+			if (!AAS_HorizontalVelocityForJump(phys_jumpvel, beststart, bestend, &speed))
+				return qfalse;
+			speed *= 1.05f;
+			traveltype = TRAVEL_JUMP;
+			//
+			//NOTE: test if the horizontal distance isn't too small
+			VectorSubtract(bestend, beststart, dir);
+			dir[2] = 0;
+			if (VectorLength(dir) < 10)
+				return qfalse;
+		} //end if
+		//
+		VectorSubtract(bestend, beststart, dir);
+		VectorNormalize(dir);
+		VectorMA(beststart, 1, dir, teststart);
+		//
+		VectorCopy(teststart, testend);
+		testend[2] -= 100;
+		trace = AAS_TraceClientBBox(teststart, testend, PRESENCE_NORMAL, -1);
+		//
+		if (trace.startsolid)
+			return qfalse;
+		if (trace.fraction < 1)
+		{
+			plane = &aasworld.planes[trace.planenum];
+			// if the bot can stand on the surface
+			if (DotProduct(plane->normal, up) >= 0.7)
+			{
+				// if no lava or slime below
+				if (!(AAS_PointContents(trace.endpos) & (CONTENTS_LAVA|CONTENTS_SLIME)))
+				{
+					if (teststart[2] - trace.endpos[2] <= aassettings.phys_maxbarrier)
+						return qfalse;
+				} //end if
+			} //end if
+		} //end if
+		//
+		VectorMA(bestend, -1, dir, teststart);
+		//
+		VectorCopy(teststart, testend);
+		testend[2] -= 100;
+		trace = AAS_TraceClientBBox(teststart, testend, PRESENCE_NORMAL, -1);
+		//
+		if (trace.startsolid)
+			return qfalse;
+		if (trace.fraction < 1)
+		{
+			plane = &aasworld.planes[trace.planenum];
+			// if the bot can stand on the surface
+			if (DotProduct(plane->normal, up) >= 0.7)
+			{
+				// if no lava or slime below
+				if (!(AAS_PointContents(trace.endpos) & (CONTENTS_LAVA|CONTENTS_SLIME)))
+				{
+					if (teststart[2] - trace.endpos[2] <= aassettings.phys_maxbarrier)
+						return qfalse;
+				} //end if
+			} //end if
+		} //end if
+		//
+		// get command movement
+		VectorClear(cmdmove);
+		if ((traveltype & TRAVELTYPE_MASK) == TRAVEL_JUMP)
+			cmdmove[2] = aassettings.phys_jumpvel;
+		else
+			cmdmove[2] = 0;
+		//
+		VectorSubtract(bestend, beststart, dir);
+		dir[2] = 0;
+		VectorNormalize(dir);
+		CrossProduct(dir, up, sidewards);
+		//
+		stopevent = SE_HITGROUND|SE_ENTERWATER|SE_ENTERSLIME|SE_ENTERLAVA|SE_HITGROUNDDAMAGE;
+		if (!AAS_AreaClusterPortal(area1num) && !AAS_AreaClusterPortal(area2num))
+			stopevent |= SE_TOUCHCLUSTERPORTAL;
+		//
+		for (i = 0; i < 3; i++)
+		{
+			//
+			if (i == 1)
+				VectorAdd(testend, sidewards, testend);
+			else if (i == 2)
+				VectorSubtract(bestend, sidewards, testend);
+			else
+				VectorCopy(bestend, testend);
+			VectorSubtract(testend, beststart, dir);
+			dir[2] = 0;
+			VectorNormalize(dir);
+			VectorScale(dir, speed, velocity);
+			//
+			AAS_PredictClientMovement(&move, -1, beststart, PRESENCE_NORMAL, qtrue,
+										velocity, cmdmove, 3, 30, 0.1f,
+										stopevent, 0, qfalse);
+			// if prediction time wasn't enough to fully predict the movement
+			if (move.frames >= 30)
+				return qfalse;
+			// don't enter slime or lava and don't fall from too high
+			if (move.stopevent & (SE_ENTERSLIME|SE_ENTERLAVA))
+				return qfalse;
+			// never jump or fall through a cluster portal
+			if (move.stopevent & SE_TOUCHCLUSTERPORTAL)
+				return qfalse;
+			//the end position should be in area2, also test a little bit back
+			//because the predicted jump could have rushed through the area
+			VectorMA(move.endpos, -64, dir, teststart);
+			teststart[2] += 1;
+			numareas = AAS_TraceAreas(move.endpos, teststart, areas, NULL, sizeof(areas) / sizeof(int));
+			for (j = 0; j < numareas; j++)
+			{
+				if (areas[j] == area2num)
+					break;
+			} //end for
+			if (j < numareas)
+				break;
+		}
+		if (i >= 3)
+			return qfalse;
+		//
+#ifdef REACH_DEBUG
+		//create the reachability
+		Log_Write("jump reachability between %d and %d\r\n", area1num, area2num);
+#endif //REACH_DEBUG
+		//create a new reachability link
+		lreach = AAS_AllocReachability();
+		if (!lreach) return qfalse;
+		lreach->areanum = area2num;
+		lreach->facenum = 0;
+		lreach->edgenum = 0;
+		VectorCopy(beststart, lreach->start);
+		VectorCopy(bestend, lreach->end);
+		lreach->traveltype = traveltype;
+
+		VectorSubtract(bestend, beststart, dir);
+		height = dir[2];
+		dir[2] = 0;
+		if ((traveltype & TRAVELTYPE_MASK) == TRAVEL_WALKOFFLEDGE && height > VectorLength(dir))
+		{
+			lreach->traveltime = aassettings.rs_startwalkoffledge + height * 50 / aassettings.phys_gravity;
+		}
+		else
+		{
+			lreach->traveltime = aassettings.rs_startjump + VectorDistance(bestend, beststart) * 240 / aassettings.phys_maxwalkvelocity;
+		} //end if
+		//
+		if (!AAS_AreaJumpPad(area2num))
+		{
+			if (AAS_FallDelta(beststart[2] - bestend[2]) > aassettings.phys_falldelta5)
+			{
+				lreach->traveltime += aassettings.rs_falldamage5;
+			} //end if
+			else if (AAS_FallDelta(beststart[2] - bestend[2]) > aassettings.phys_falldelta10)
+			{
+				lreach->traveltime += aassettings.rs_falldamage10;
+			} //end if
+		} //end if
+		lreach->next = areareachability[area1num];
+		areareachability[area1num] = lreach;
+		//
+		if ((traveltype & TRAVELTYPE_MASK) == TRAVEL_JUMP)
+			reach_jump++;
+		else
+			reach_walkoffledge++;
+	} //end if
+	return qfalse;
+} //end of the function AAS_Reachability_Jump
+//===========================================================================
+// create a possible ladder reachability from area1 to area2
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int AAS_Reachability_Ladder(int area1num, int area2num)
+{
+	int i, j, k, l, edge1num, edge2num, sharededgenum, lowestedgenum;
+	int face1num, face2num, ladderface1num, ladderface2num;
+	int ladderface1vertical, ladderface2vertical, firstv;
+	float face1area, face2area, bestface1area, bestface2area;
+	float phys_jumpvel, maxjumpheight;
+	vec3_t area1point, area2point, v1, v2, up = {0, 0, 1};
+	vec3_t mid, lowestpoint, start, end, sharededgevec, dir;
+	aas_area_t *area1, *area2;
+	aas_face_t *face1, *face2, *ladderface1, *ladderface2;
+	aas_plane_t *plane1, *plane2;
+	aas_edge_t *sharededge, *edge1;
+	aas_lreachability_t *lreach;
+	aas_trace_t trace;
+
+	if (!AAS_AreaLadder(area1num) || !AAS_AreaLadder(area2num)) return qfalse;
+	//
+	phys_jumpvel = aassettings.phys_jumpvel;
+	//maximum height a player can jump with the given initial z velocity
+	maxjumpheight = AAS_MaxJumpHeight(phys_jumpvel);
+
+	area1 = &aasworld.areas[area1num];
+	area2 = &aasworld.areas[area2num];
+	//
+	ladderface1 = NULL;
+	ladderface2 = NULL;
+	ladderface1num = 0; //make compiler happy
+	ladderface2num = 0; //make compiler happy
+	bestface1area = -9999;
+	bestface2area = -9999;
+	sharededgenum = 0; //make compiler happy
+	lowestedgenum = 0; //make compiler happy
+	//
+	for (i = 0; i < area1->numfaces; i++)
+	{
+		face1num = aasworld.faceindex[area1->firstface + i];
+		face1 = &aasworld.faces[abs(face1num)];
+		//if not a ladder face
+		if (!(face1->faceflags & FACE_LADDER)) continue;
+		//
+		for (j = 0; j < area2->numfaces; j++)
+		{
+			face2num = aasworld.faceindex[area2->firstface + j];
+			face2 = &aasworld.faces[abs(face2num)];
+			//if not a ladder face
+			if (!(face2->faceflags & FACE_LADDER)) continue;
+			//check if the faces share an edge
+			for (k = 0; k < face1->numedges; k++)
+			{
+				edge1num = aasworld.edgeindex[face1->firstedge + k];
+				for (l = 0; l < face2->numedges; l++)
+				{
+					edge2num = aasworld.edgeindex[face2->firstedge + l];
+					if (abs(edge1num) == abs(edge2num))
+					{
+						//get the face with the largest area
+						face1area = AAS_FaceArea(face1);
+						face2area = AAS_FaceArea(face2);
+						if (face1area > bestface1area && face2area > bestface2area)
+						{
+							bestface1area = face1area;
+							bestface2area = face2area;
+							ladderface1 = face1;
+							ladderface2 = face2;
+							ladderface1num = face1num;
+							ladderface2num = face2num;
+							sharededgenum = edge1num;
+						} //end if
+						break;
+					} //end if
+				} //end for
+				if (l != face2->numedges) break;
+			} //end for
+		} //end for
+	} //end for
+	//
+	if (ladderface1 && ladderface2)
+	{
+		//get the middle of the shared edge
+		sharededge = &aasworld.edges[abs(sharededgenum)];
+		firstv = sharededgenum < 0;
+		//
+		VectorCopy(aasworld.vertexes[sharededge->v[firstv]], v1);
+		VectorCopy(aasworld.vertexes[sharededge->v[!firstv]], v2);
+		VectorAdd(v1, v2, area1point);
+		VectorScale(area1point, 0.5, area1point);
+		VectorCopy(area1point, area2point);
+		//
+		//if the face plane in area 1 is pretty much vertical
+		plane1 = &aasworld.planes[ladderface1->planenum ^ (ladderface1num < 0)];
+		plane2 = &aasworld.planes[ladderface2->planenum ^ (ladderface2num < 0)];
+		//
+		//get the points really into the areas
+		VectorSubtract(v2, v1, sharededgevec);
+		CrossProduct(plane1->normal, sharededgevec, dir);
+		VectorNormalize(dir);
+		//NOTE: 32 because that's larger than 16 (bot bbox x,y)
+		VectorMA(area1point, -32, dir, area1point);
+		VectorMA(area2point, 32, dir, area2point);
+		//
+		ladderface1vertical = abs(DotProduct(plane1->normal, up)) < 0.1;
+		ladderface2vertical = abs(DotProduct(plane2->normal, up)) < 0.1;
+		//there's only reachability between vertical ladder faces
+		if (!ladderface1vertical && !ladderface2vertical) return qfalse;
+		//if both vertical ladder faces
+		if (ladderface1vertical && ladderface2vertical
+					//and the ladder faces do not make a sharp corner
+					&& DotProduct(plane1->normal, plane2->normal) > 0.7
+					//and the shared edge is not too vertical
+					&& abs(DotProduct(sharededgevec, up)) < 0.7)
+		{
+			//create a new reachability link
+			lreach = AAS_AllocReachability();
+			if (!lreach) return qfalse;
+			lreach->areanum = area2num;
+			lreach->facenum = ladderface1num;
+			lreach->edgenum = abs(sharededgenum);
+			VectorCopy(area1point, lreach->start);
+			//VectorCopy(area2point, lreach->end);
+			VectorMA(area2point, -3, plane1->normal, lreach->end);
+			lreach->traveltype = TRAVEL_LADDER;
+			lreach->traveltime = 10;
+			lreach->next = areareachability[area1num];
+			areareachability[area1num] = lreach;
+			//
+			reach_ladder++;
+			//create a new reachability link
+			lreach = AAS_AllocReachability();
+			if (!lreach) return qfalse;
+			lreach->areanum = area1num;
+			lreach->facenum = ladderface2num;
+			lreach->edgenum = abs(sharededgenum);
+			VectorCopy(area2point, lreach->start);
+			//VectorCopy(area1point, lreach->end);
+			VectorMA(area1point, -3, plane1->normal, lreach->end);
+			lreach->traveltype = TRAVEL_LADDER;
+			lreach->traveltime = 10;
+			lreach->next = areareachability[area2num];
+			areareachability[area2num] = lreach;
+			//
+			reach_ladder++;
+			//
+			return qtrue;
+		} //end if
+		//if the second ladder face is also a ground face
+		//create ladder end (just ladder) reachability and
+		//walk off a ladder (ledge) reachability
+		if (ladderface1vertical && (ladderface2->faceflags & FACE_GROUND))
+		{
+			//create a new reachability link
+			lreach = AAS_AllocReachability();
+			if (!lreach) return qfalse;
+			lreach->areanum = area2num;
+			lreach->facenum = ladderface1num;
+			lreach->edgenum = abs(sharededgenum);
+			VectorCopy(area1point, lreach->start);
+			VectorCopy(area2point, lreach->end);
+			lreach->end[2] += 16;
+			VectorMA(lreach->end, -15, plane1->normal, lreach->end);
+			lreach->traveltype = TRAVEL_LADDER;
+			lreach->traveltime = 10;
+			lreach->next = areareachability[area1num];
+			areareachability[area1num] = lreach;
+			//
+			reach_ladder++;
+			//create a new reachability link
+			lreach = AAS_AllocReachability();
+			if (!lreach) return qfalse;
+			lreach->areanum = area1num;
+			lreach->facenum = ladderface2num;
+			lreach->edgenum = abs(sharededgenum);
+			VectorCopy(area2point, lreach->start);
+			VectorCopy(area1point, lreach->end);
+			lreach->traveltype = TRAVEL_WALKOFFLEDGE;
+			lreach->traveltime = 10;
+			lreach->next = areareachability[area2num];
+			areareachability[area2num] = lreach;
+			//
+			reach_walkoffledge++;
+			//
+			return qtrue;
+		} //end if
+		//
+		if (ladderface1vertical)
+		{
+			//find lowest edge of the ladder face
+			lowestpoint[2] = 99999;
+			for (i = 0; i < ladderface1->numedges; i++)
+			{
+				edge1num = abs(aasworld.edgeindex[ladderface1->firstedge + i]);
+				edge1 = &aasworld.edges[edge1num];
+				//
+				VectorCopy(aasworld.vertexes[edge1->v[0]], v1);
+				VectorCopy(aasworld.vertexes[edge1->v[1]], v2);
+				//
+				VectorAdd(v1, v2, mid);
+				VectorScale(mid, 0.5, mid);
+				//
+				if (mid[2] < lowestpoint[2])
+				{
+					VectorCopy(mid, lowestpoint);
+					lowestedgenum = edge1num;
+				} //end if
+			} //end for
+			//
+			plane1 = &aasworld.planes[ladderface1->planenum];
+			//trace down in the middle of this edge
+			VectorMA(lowestpoint, 5, plane1->normal, start);
+			VectorCopy(start, end);
+			start[2] += 5;
+			end[2] -= 100;
+			//trace without entity collision
+			trace = AAS_TraceClientBBox(start, end, PRESENCE_NORMAL, -1);
+			//
+			//
+#ifdef REACH_DEBUG
+			if (trace.startsolid)
+			{
+				Log_Write("trace from area %d started in solid\r\n", area1num);
+			} //end if
+#endif //REACH_DEBUG
+			//
+			trace.endpos[2] += 1;
+			area2num = AAS_PointAreaNum(trace.endpos);
+			//
+			area2 = &aasworld.areas[area2num];
+			for (i = 0; i < area2->numfaces; i++)
+			{
+				face2num = aasworld.faceindex[area2->firstface + i];
+				face2 = &aasworld.faces[abs(face2num)];
+				//
+				if (face2->faceflags & FACE_LADDER)
+				{
+					plane2 = &aasworld.planes[face2->planenum];
+					if (abs(DotProduct(plane2->normal, up)) < 0.1) break;
+				} //end if
+			} //end for
+			//if from another area without vertical ladder faces
+			if (i >= area2->numfaces && area2num != area1num &&
+						//the reachabilities shouldn't exist already
+						!AAS_ReachabilityExists(area1num, area2num) &&
+						!AAS_ReachabilityExists(area2num, area1num))
+			{
+				//if the height is jumpable
+				if (start[2] - trace.endpos[2] < maxjumpheight)
+				{
+					//create a new reachability link
+					lreach = AAS_AllocReachability();
+					if (!lreach) return qfalse;
+					lreach->areanum = area2num;
+					lreach->facenum = ladderface1num;
+					lreach->edgenum = lowestedgenum;
+					VectorCopy(lowestpoint, lreach->start);
+					VectorCopy(trace.endpos, lreach->end);
+					lreach->traveltype = TRAVEL_LADDER;
+					lreach->traveltime = 10;
+					lreach->next = areareachability[area1num];
+					areareachability[area1num] = lreach;
+					//
+					reach_ladder++;
+					//create a new reachability link
+					lreach = AAS_AllocReachability();
+					if (!lreach) return qfalse;
+					lreach->areanum = area1num;
+					lreach->facenum = ladderface1num;
+					lreach->edgenum = lowestedgenum;
+					VectorCopy(trace.endpos, lreach->start);
+					//get the end point a little bit into the ladder
+					VectorMA(lowestpoint, -5, plane1->normal, lreach->end);
+					//get the end point a little higher
+					lreach->end[2] += 10;
+					lreach->traveltype = TRAVEL_JUMP;
+					lreach->traveltime = 10;
+					lreach->next = areareachability[area2num];
+					areareachability[area2num] = lreach;
+					//
+					reach_jump++;	
+					//
+					return qtrue;
+#ifdef REACH_DEBUG
+					Log_Write("jump up to ladder reach between %d and %d\r\n", area2num, area1num);
+#endif //REACH_DEBUG
+				} //end if
+#ifdef REACH_DEBUG
+				else Log_Write("jump too high between area %d and %d\r\n", area2num, area1num);
+#endif //REACH_DEBUG
+			} //end if
+			/*//if slime or lava below the ladder
+			//try jump reachability from far towards the ladder
+			if (aasworld.areasettings[area2num].contents & (AREACONTENTS_SLIME
+													| AREACONTENTS_LAVA))
+			{
+				for (i = 20; i <= 120; i += 20)
+				{
+					//trace down in the middle of this edge
+					VectorMA(lowestpoint, i, plane1->normal, start);
+					VectorCopy(start, end);
+					start[2] += 5;
+					end[2] -= 100;
+					//trace without entity collision
+					trace = AAS_TraceClientBBox(start, end, PRESENCE_NORMAL, -1);
+					//
+					if (trace.startsolid) break;
+					trace.endpos[2] += 1;
+					area2num = AAS_PointAreaNum(trace.endpos);
+					if (area2num == area1num) continue;
+					//
+					if (start[2] - trace.endpos[2] > maxjumpheight) continue;
+					if (aasworld.areasettings[area2num].contents & (AREACONTENTS_SLIME
+												| AREACONTENTS_LAVA)) continue;
+					//
+					//create a new reachability link
+					lreach = AAS_AllocReachability();
+					if (!lreach) return qfalse;
+					lreach->areanum = area1num;
+					lreach->facenum = ladderface1num;
+					lreach->edgenum = lowestedgenum;
+					VectorCopy(trace.endpos, lreach->start);
+					VectorCopy(lowestpoint, lreach->end);
+					lreach->end[2] += 5;
+					lreach->traveltype = TRAVEL_JUMP;
+					lreach->traveltime = 10;
+					lreach->next = areareachability[area2num];
+					areareachability[area2num] = lreach;
+					//
+					reach_jump++;
+					//
+					Log_Write("jump far to ladder reach between %d and %d\r\n", area2num, area1num);
+					//
+					break;
+				} //end for
+			} //end if*/
+		} //end if
+	} //end if
+	return qfalse;
+} //end of the function AAS_Reachability_Ladder
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+int AAS_TravelFlagsForTeam(int ent)
+{
+	int notteam;
+
+	if (!AAS_IntForBSPEpairKey(ent, "bot_notteam", &notteam))
+		return 0;
+	if (notteam == 1)
+		return TRAVELFLAG_NOTTEAM1;
+	if (notteam == 2)
+		return TRAVELFLAG_NOTTEAM2;
+	return 0;
+} //end of the function AAS_TravelFlagsForTeam
+//===========================================================================
+// create possible teleporter reachabilities
+// this is very game dependent.... :(
+//
+// classname = trigger_multiple or trigger_teleport
+// target = "t1"
+//
+// classname = target_teleporter
+// targetname = "t1"
+// target = "t2"
+//
+// classname = misc_teleporter_dest
+// targetname = "t2"
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void AAS_Reachability_Teleport(void)
+{
+	int area1num, area2num;
+	char target[MAX_EPAIRKEY], targetname[MAX_EPAIRKEY];
+	char classname[MAX_EPAIRKEY], model[MAX_EPAIRKEY];
+	int ent, dest;
+	float angle;
+	vec3_t origin, destorigin, mins, maxs, end, angles;
+	vec3_t mid, velocity, cmdmove;
+	aas_lreachability_t *lreach;
+	aas_clientmove_t move;
+	aas_trace_t trace;
+	aas_link_t *areas, *link;
+
+	for (ent = AAS_NextBSPEntity(0); ent; ent = AAS_NextBSPEntity(ent))
+	{
+		if (!AAS_ValueForBSPEpairKey(ent, "classname", classname, MAX_EPAIRKEY)) continue;
+		if (!strcmp(classname, "trigger_multiple"))
+		{
+			AAS_ValueForBSPEpairKey(ent, "model", model, MAX_EPAIRKEY);
+//#ifdef REACH_DEBUG
+			botimport.Print(PRT_MESSAGE, "trigger_multiple model = \"%s\"\n", model);
+//#endif REACH_DEBUG
+			VectorClear(angles);
+			AAS_BSPModelMinsMaxsOrigin(atoi(model+1), angles, mins, maxs, origin);
+			//
+			if (!AAS_ValueForBSPEpairKey(ent, "target", target, MAX_EPAIRKEY))
+			{
+				botimport.Print(PRT_ERROR, "trigger_multiple at %1.0f %1.0f %1.0f without target\n",
+									origin[0], origin[1], origin[2]);
+				continue;
+			} //end if
+			for (dest = AAS_NextBSPEntity(0); dest; dest = AAS_NextBSPEntity(dest))
+			{
+				if (!AAS_ValueForBSPEpairKey(dest, "classname", classname, MAX_EPAIRKEY)) continue;
+				if (!strcmp(classname, "target_teleporter"))
+				{
+					if (!AAS_ValueForBSPEpairKey(dest, "targetname", targetname, MAX_EPAIRKEY)) continue;
+					if (!strcmp(targetname, target))
+					{
+						break;
+					} //end if
+				} //end if
+			} //end for
+			if (!dest)
+			{
+				continue;
+			} //end if
+			if (!AAS_ValueForBSPEpairKey(dest, "target", target, MAX_EPAIRKEY))
+			{
+				botimport.Print(PRT_ERROR, "target_teleporter without target\n");
+				continue;
+			} //end if
+		} //end else
+		else if (!strcmp(classname, "trigger_teleport"))
+		{
+			AAS_ValueForBSPEpairKey(ent, "model", model, MAX_EPAIRKEY);
+//#ifdef REACH_DEBUG
+			botimport.Print(PRT_MESSAGE, "trigger_teleport model = \"%s\"\n", model);
+//#endif REACH_DEBUG
+			VectorClear(angles);
+			AAS_BSPModelMinsMaxsOrigin(atoi(model+1), angles, mins, maxs, origin);
+			//
+			if (!AAS_ValueForBSPEpairKey(ent, "target", target, MAX_EPAIRKEY))
+			{
+				botimport.Print(PRT_ERROR, "trigger_teleport at %1.0f %1.0f %1.0f without target\n",
+									origin[0], origin[1], origin[2]);
+				continue;
+			} //end if
+		} //end if
+		else
+		{
+			continue;
+		} //end else
+		//
+		for (dest = AAS_NextBSPEntity(0); dest; dest = AAS_NextBSPEntity(dest))
+		{
+			//classname should be misc_teleporter_dest
+			//but I've also seen target_position and actually any
+			//entity could be used... burp
+			if (AAS_ValueForBSPEpairKey(dest, "targetname", targetname, MAX_EPAIRKEY))
+			{
+				if (!strcmp(targetname, target))
+				{
+					break;
+				} //end if
+			} //end if
+		} //end for
+		if (!dest)
+		{
+			botimport.Print(PRT_ERROR, "teleporter without misc_teleporter_dest (%s)\n", target);
+			continue;
+		} //end if
+		if (!AAS_VectorForBSPEpairKey(dest, "origin", destorigin))
+		{
+			botimport.Print(PRT_ERROR, "teleporter destination (%s) without origin\n", target);
+			continue;
+		} //end if
+		//
+		area2num = AAS_PointAreaNum(destorigin);
+		//if not teleported into a teleporter or into a jumppad
+		if (!AAS_AreaTeleporter(area2num) && !AAS_AreaJumpPad(area2num))
+		{
+			VectorCopy(destorigin, end);
+			end[2] -= 64;
+			trace = AAS_TraceClientBBox(destorigin, end, PRESENCE_CROUCH, -1);
+			if (trace.startsolid)
+			{
+				botimport.Print(PRT_ERROR, "teleporter destination (%s) in solid\n", target);
+				continue;
+			} //end if
+			area2num = AAS_PointAreaNum(trace.endpos);
+			//
+			/*
+			if (!AAS_AreaTeleporter(area2num) &&
+				!AAS_AreaJumpPad(area2num) &&
+				!AAS_AreaGrounded(area2num))
+			{
+				VectorCopy(trace.endpos, destorigin);
+			}
+			else*/
+			{
+				//predict where you'll end up
+				AAS_FloatForBSPEpairKey(dest, "angle", &angle);
+				if (angle)
+				{
+					VectorSet(angles, 0, angle, 0);
+					AngleVectors(angles, velocity, NULL, NULL);
+					VectorScale(velocity, 400, velocity);
+				} //end if
+				else
+				{
+					VectorClear(velocity);
+				} //end else
+				VectorClear(cmdmove);
+				AAS_PredictClientMovement(&move, -1, destorigin, PRESENCE_NORMAL, qfalse,
+										velocity, cmdmove, 0, 30, 0.1f,
+										SE_HITGROUND|SE_ENTERWATER|SE_ENTERSLIME|
+										SE_ENTERLAVA|SE_HITGROUNDDAMAGE|SE_TOUCHJUMPPAD|SE_TOUCHTELEPORTER, 0, qfalse); //qtrue);
+				area2num = AAS_PointAreaNum(move.endpos);
+				if (move.stopevent & (SE_ENTERSLIME|SE_ENTERLAVA))
+				{
+					botimport.Print(PRT_WARNING, "teleported into slime or lava at dest %s\n", target);
+				} //end if
+				VectorCopy(move.endpos, destorigin);
+			} //end else
+		} //end if
+		//
+		//botimport.Print(PRT_MESSAGE, "teleporter brush origin at %f %f %f\n", origin[0], origin[1], origin[2]);
+		//botimport.Print(PRT_MESSAGE, "teleporter brush mins = %f %f %f\n", mins[0], mins[1], mins[2]);
+		//botimport.Print(PRT_MESSAGE, "teleporter brush maxs = %f %f %f\n", maxs[0], maxs[1], maxs[2]);
+		VectorAdd(origin, mins, mins);
+		VectorAdd(origin, maxs, maxs);
+		//
+		VectorAdd(mins, maxs, mid);
+		VectorScale(mid, 0.5, mid);
+		//link an invalid (-1) entity
+		areas = AAS_LinkEntityClientBBox(mins, maxs, -1, PRESENCE_CROUCH);
+		if (!areas) botimport.Print(PRT_MESSAGE, "trigger_multiple not in any area\n");
+		//
+		for (link = areas; link; link = link->next_area)
+		{
+			//if (!AAS_AreaGrounded(link->areanum)) continue;
+			if (!AAS_AreaTeleporter(link->areanum)) continue;
+			//
+			area1num = link->areanum;
+			//create a new reachability link
+			lreach = AAS_AllocReachability();
+			if (!lreach) break;
+			lreach->areanum = area2num;
+			lreach->facenum = 0;
+			lreach->edgenum = 0;
+			VectorCopy(mid, lreach->start);
+			VectorCopy(destorigin, lreach->end);
+			lreach->traveltype = TRAVEL_TELEPORT;
+			lreach->traveltype |= AAS_TravelFlagsForTeam(ent);
+			lreach->traveltime = aassettings.rs_teleport;
+			lreach->next = areareachability[area1num];
+			areareachability[area1num] = lreach;
+			//
+			reach_teleport++;
+		} //end for
+		//unlink the invalid entity
+		AAS_UnlinkFromAreas(areas);
+	} //end for
+} //end of the function AAS_Reachability_Teleport
+//===========================================================================
+// create possible elevator (func_plat) reachabilities
+// this is very game dependent.... :(
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+void AAS_Reachability_Elevator(void)
+{
+	int area1num, area2num, modelnum, i, j, k, l, n, p;
+	float lip, height, speed;
+	char model[MAX_EPAIRKEY], classname[MAX_EPAIRKEY];
+	int ent;
+	vec3_t mins, maxs, origin, angles = {0, 0, 0};
+	vec3_t pos1, pos2, mids, platbottom, plattop;
+	vec3_t bottomorg, toporg, start, end, dir;
+	vec_t xvals[8], yvals[8], xvals_top[8], yvals_top[8];
+	aas_lreachability_t *lreach;
+	aas_trace_t trace;
+
+#ifdef REACH_DEBUG
+	Log_Write("AAS_Reachability_Elevator\r\n");
+#endif //REACH_DEBUG
+	for (ent = AAS_NextBSPEntity(0); ent; ent = AAS_NextBSPEntity(ent))
+	{
+		if (!AAS_ValueForBSPEpairKey(ent, "classname", classname, MAX_EPAIRKEY)) continue;
+		if (!strcmp(classname, "func_plat"))
+		{
+#ifdef REACH_DEBUG
+			Log_Write("found func plat\r\n");
+#endif //REACH_DEBUG
+			if (!AAS_ValueForBSPEpairKey(ent, "model", model, MAX_EPAIRKEY))
+			{
+				botimport.Print(PRT_ERROR, "func_plat without model\n");
+				continue;
+			} //end if
+			//get the model number, and skip the leading *
+			modelnum = atoi(model+1);
+			if (modelnum <= 0)
+			{
+				botimport.Print(PRT_ERROR, "func_plat with invalid model number\n");
+				continue;
+			} //end if
+			//get the mins, maxs and origin of the model
+			//NOTE: the origin is usually (0,0,0) and the mins and maxs
+			//      are the absolute mins and maxs
+			AAS_BSPModelMinsMaxsOrigin(modelnum, angles, mins, maxs, origin);
+			//
+			AAS_VectorForBSPEpairKey(ent, "origin", origin);
+			//pos1 is the top position, pos2 is the bottom
+			VectorCopy(origin, pos1);
+			VectorCopy(origin, pos2);
+			//get the lip of the plat
+			AAS_FloatForBSPEpairKey(ent, "lip", &lip);
+			if (!lip) lip = 8;
+			//get the movement height of the plat
+			AAS_FloatForBSPEpairKey(ent, "height", &height);
+			if (!height) height = (maxs[2] - mins[2]) - lip;
+			//get the speed of the plat
+			AAS_FloatForBSPEpairKey(ent, "speed", &speed);
+			if (!speed) speed = 200;
+			//get bottom position below pos1
+			pos2[2] -= height;
+			//
+			//get a point just above the plat in the bottom position
+			VectorAdd(mins, maxs, mids);
+			VectorMA(pos2, 0.5, mids, platbottom);
+			platbottom[2] = maxs[2] - (pos1[2] - pos2[2]) + 2;
+			//get a point just above the plat in the top position
+			VectorAdd(mins, maxs, mids);
+			VectorMA(pos2, 0.5, mids, plattop);
+			plattop[2] = maxs[2] + 2;
+			//
+			/*if (!area1num)
+			{
+				Log_Write("no grounded area near plat bottom\r\n");
+				continue;
+			} //end if*/
+			//get the mins and maxs a little larger
+			for (i = 0; i < 3; i++)
+			{
+				mins[i] -= 1;
+				maxs[i] += 1;
+			} //end for
+			//
+			//botimport.Print(PRT_MESSAGE, "platbottom[2] = %1.1f plattop[2] = %1.1f\n", platbottom[2], plattop[2]);
+			//
+			VectorAdd(mins, maxs, mids);
+			VectorScale(mids, 0.5, mids);
+			//
+			xvals[0] = mins[0]; xvals[1] = mids[0]; xvals[2] = maxs[0]; xvals[3] = mids[0];
+			yvals[0] = mids[1]; yvals[1] = maxs[1]; yvals[2] = mids[1]; yvals[3] = mins[1];
+			//
+			xvals[4] = mins[0]; xvals[5] = maxs[0]; xvals[6] = maxs[0]; xvals[7] = mins[0];
+			yvals[4] = maxs[1]; yvals[5] = maxs[1]; yvals[6] = mins[1]; yvals[7] = mins[1];
+			//find adjacent areas around the bottom of the plat
+			for (i = 0; i < 9; i++)
+			{
+				if (i < 8) //check at the sides of the plat
+				{
+					bottomorg[0] = origin[0] + xvals[i];
+					bottomorg[1] = origin[1] + yvals[i];
+					bottomorg[2] = platbottom[2] + 16;
+					//get a grounded or swim area near the plat in the bottom position
+					area1num = AAS_PointAreaNum(bottomorg);
+					for (k = 0; k < 16; k++)
+					{
+						if (area1num)
+						{
+							if (AAS_AreaGrounded(area1num) || AAS_AreaSwim(area1num)) break;
+						} //end if
+						bottomorg[2] += 4;
+						area1num = AAS_PointAreaNum(bottomorg);
+					} //end if
+					//if in solid
+					if (k >= 16)
+					{
+						continue;
+					} //end if
+				} //end if
+				else //at the middle of the plat
+				{
+					VectorCopy(plattop, bottomorg);
+					bottomorg[2] += 24;
+					area1num = AAS_PointAreaNum(bottomorg);
+					if (!area1num) continue;
+					VectorCopy(platbottom, bottomorg);
+					bottomorg[2] += 24;
+				} //end else
+				//look at adjacent areas around the top of the plat
+				//make larger steps to outside the plat everytime
+				for (n = 0; n < 3; n++)
+				{
+					for (k = 0; k < 3; k++)
+					{
+						mins[k] -= 4;
+						maxs[k] += 4;
+					} //end for
+					xvals_top[0] = mins[0]; xvals_top[1] = mids[0]; xvals_top[2] = maxs[0]; xvals_top[3] = mids[0];
+					yvals_top[0] = mids[1]; yvals_top[1] = maxs[1]; yvals_top[2] = mids[1]; yvals_top[3] = mins[1];
+					//
+					xvals_top[4] = mins[0]; xvals_top[5] = maxs[0]; xvals_top[6] = maxs[0]; xvals_top[7] = mins[0];
+					yvals_top[4] = maxs[1]; yvals_top[5] = maxs[1]; yvals_top[6] = mins[1]; yvals_top[7] = mins[1];
+					//
+					for (j = 0; j < 8; j++)
+					{
+						toporg[0] = origin[0] + xvals_top[j];
+						toporg[1] = origin[1] + yvals_top[j];
+						toporg[2] = plattop[2] + 16;
+						//get a grounded or swim area near the plat in the top position
+						area2num = AAS_PointAreaNum(toporg);
+						for (l = 0; l < 16; l++)
+						{
+							if (area2num)
+							{
+								if (AAS_AreaGrounded(area2num) || AAS_AreaSwim(area2num))
+								{
+									VectorCopy(plattop, start);
+									start[2] += 32;
+									VectorCopy(toporg, end);
+									end[2] += 1;
+									trace = AAS_TraceClientBBox(start, end, PRESENCE_CROUCH, -1);
+									if (trace.fraction >= 1) break;
+								} //end if
+							} //end if
+							toporg[2] += 4;
+							area2num = AAS_PointAreaNum(toporg);
+						} //end if
+						//if in solid
+						if (l >= 16) continue;
+						//never create a reachability in the same area
+						if (area2num == area1num) continue;
+						//if the area isn't grounded
+						if (!AAS_AreaGrounded(area2num)) continue;
+						//if there already exists reachability between the areas
+						if (AAS_ReachabilityExists(area1num, area2num)) continue;
+						//if the reachability start is within the elevator bounding box
+						VectorSubtract(bottomorg, platbottom, dir);
+						VectorNormalize(dir);
+						dir[0] = bottomorg[0] + 24 * dir[0];
+						dir[1] = bottomorg[1] + 24 * dir[1];
+						dir[2] = bottomorg[2];
+						//
+						for (p = 0; p < 3; p++)
+							if (dir[p] < origin[p] + mins[p] || dir[p] > origin[p] + maxs[p]) break;
+						if (p >= 3) continue;
+						//create a new reachability link
+						lreach = AAS_AllocReachability();
+						if (!lreach) continue;
+						lreach->areanum = area2num;
+						//the facenum is the model number
+						lreach->facenum = modelnum;
+						//the edgenum is the height
+						lreach->edgenum = (int) height;
+						//
+						VectorCopy(dir, lreach->start);
+						VectorCopy(toporg, lreach->end);
+						lreach->traveltype = TRAVEL_ELEVATOR;
+						lreach->traveltype |= AAS_TravelFlagsForTeam(ent);
+						lreach->traveltime = aassettings.rs_startelevator + height * 100 / speed;
+						lreach->next = areareachability[area1num];
+						areareachability[area1num] = lreach;
+						//don't go any further to the outside
+						n = 9999;
+						//
+#ifdef REACH_DEBUG
+						Log_Write("elevator reach from %d to %d\r\n", area1num, area2num);
+#endif //REACH_DEBUG
+						//
+						reach_elevator++;
+					} //end for
+				} //end for
+			} //end for
+		} //end if
+	} //end for
+} //end of the function AAS_Reachability_Elevator
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+aas_lreachability_t *AAS_FindFaceReachabilities(vec3_t *facepoints, int numpoints, aas_plane_t *plane, int towardsface)
+{
+	int i, j, k, l;
+	int facenum, edgenum, bestfacenum;
+	float *v1, *v2, *v3, *v4;
+	float bestdist, speed, hordist, dist;
+	vec3_t beststart, beststart2, bestend, bestend2, tmp, hordir, testpoint;
+	aas_lreachability_t *lreach, *lreachabilities;
+	aas_area_t *area;
+	aas_face_t *face;
+	aas_edge_t *edge;
+	aas_plane_t *faceplane, *bestfaceplane;
+
+	//
+	lreachabilities = NULL;
+	bestfacenum = 0;
+	bestfaceplane = NULL;
+	//
+	for (i = 1; i < aasworld.numareas; i++)
+	{
+		area = &aasworld.areas[i];
+		// get the shortest distance between one of the func_bob start edges and
+		// one of the face edges of area1
+		bestdist = 999999;
+		for (j = 0; j < area->numfaces; j++)
+		{
+			facenum = aasworld.faceindex[area->firstface + j];
+			face = &aasworld.faces[abs(facenum)];
+			//if not a ground face
+			if (!(face->faceflags & FACE_GROUND)) continue;
+			//get the ground planes
+			faceplane = &aasworld.planes[face->planenum];
+			//
+			for (k = 0; k < face->numedges; k++)
+			{
+				edgenum = abs(aasworld.edgeindex[face->firstedge + k]);
+				edge = &aasworld.edges[edgenum];
+				//calculate the minimum distance between the two edges
+				v1 = aasworld.vertexes[edge->v[0]];
+				v2 = aasworld.vertexes[edge->v[1]];
+				//
+				for (l = 0; l < numpoints; l++)
+				{
+					v3 = facepoints[l];
+					v4 = facepoints[(l+1) % numpoints];
+					dist = AAS_ClosestEdgePoints(v1, v2, v3, v4, faceplane, plane,
+													beststart, bestend,
+													beststart2, bestend2, bestdist);
+					if (dist < bestdist)
+					{
+						bestfacenum = facenum;
+						bestfaceplane = faceplane;
+						bestdist = dist;
+					} //end if
+				} //end for
+			} //end for
+		} //end for
+		//
+		if (bestdist > 192) continue;
+		//
+		VectorMiddle(beststart, beststart2, beststart);
+		VectorMiddle(bestend, bestend2, bestend);
+		//
+		if (!towardsface)
+		{
+			VectorCopy(beststart, tmp);
+			VectorCopy(bestend, beststart);
+			VectorCopy(tmp, bestend);
+		} //end if
+		//
+		VectorSubtract(bestend, beststart, hordir);
+		hordir[2] = 0;
+		hordist = VectorLength(hordir);
+		//
+		if (hordist > 2 * AAS_MaxJumpDistance(aassettings.phys_jumpvel)) continue;
+		//the end point should not be significantly higher than the start point
+		if (bestend[2] - 32 > beststart[2]) continue;
+		//don't fall down too far
+		if (bestend[2] < beststart[2] - 128) continue;
+		//the distance should not be too far
+		if (hordist > 32)
+		{
+			//check for walk off ledge
+			if (!AAS_HorizontalVelocityForJump(0, beststart, bestend, &speed)) continue;
+		} //end if
+		//
+		beststart[2] += 1;
+		bestend[2] += 1;
+		//
+		if (towardsface) VectorCopy(bestend, testpoint);
+		else VectorCopy(beststart, testpoint);
+		testpoint[2] = 0;
+		testpoint[2] = (bestfaceplane->dist - DotProduct(bestfaceplane->normal, testpoint)) / bestfaceplane->normal[2];
+		//
+		if (!AAS_PointInsideFace(bestfacenum, testpoint, 0.1f))
+		{
+			//if the faces are not overlapping then only go down
+			if (bestend[2] - 16 > beststart[2]) continue;
+		} //end if
+		lreach = AAS_AllocReachability();
+		if (!lreach) return lreachabilities;
+		lreach->areanum = i;
+		lreach->facenum = 0;
+		lreach->edgenum = 0;
+		VectorCopy(beststart, lreach->start);
+		VectorCopy(bestend, lreach->end);
+		lreach->traveltype = 0;
+		lreach->traveltime = 0;
+		lreach->next = lreachabilities;
+		lreachabilities = lreach;
+#ifndef BSPC
+		if (towardsface) AAS_PermanentLine(lreach->start, lreach->end, 1);
+		else AAS_PermanentLine(lreach->start, lreach->end, 2);
+#endif
+	} //end for
+	return lreachabilities;
+} //end of the function AAS_FindFaceReachabilities
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+void AAS_Reachability_FuncBobbing(void)
+{
+	int ent, spawnflags, modelnum, axis;
+	int i, numareas, areas[10];
+	char classname[MAX_EPAIRKEY], model[MAX_EPAIRKEY];
+	vec3_t origin, move_end, move_start, move_start_top, move_end_top;
+	vec3_t mins, maxs, angles = {0, 0, 0};
+	vec3_t start_edgeverts[4], end_edgeverts[4], mid;
+	vec3_t org, start, end, dir, points[10];
+	float height;
+	aas_plane_t start_plane, end_plane;
+	aas_lreachability_t *startreach, *endreach, *nextstartreach, *nextendreach, *lreach;
+	aas_lreachability_t *firststartreach, *firstendreach;
+
+	for (ent = AAS_NextBSPEntity(0); ent; ent = AAS_NextBSPEntity(ent))
+	{
+		if (!AAS_ValueForBSPEpairKey(ent, "classname", classname, MAX_EPAIRKEY)) continue;
+		if (strcmp(classname, "func_bobbing")) continue;
+		AAS_FloatForBSPEpairKey(ent, "height", &height);
+		if (!height) height = 32;
+		//
+		if (!AAS_ValueForBSPEpairKey(ent, "model", model, MAX_EPAIRKEY))
+		{
+			botimport.Print(PRT_ERROR, "func_bobbing without model\n");
+			continue;
+		} //end if
+		//get the model number, and skip the leading *
+		modelnum = atoi(model+1);
+		if (modelnum <= 0)
+		{
+			botimport.Print(PRT_ERROR, "func_bobbing with invalid model number\n");
+			continue;
+		} //end if
+		//if the entity has an origin set then use it
+		if (!AAS_VectorForBSPEpairKey(ent, "origin", origin))
+			VectorSet(origin, 0, 0, 0);
+		//
+		AAS_BSPModelMinsMaxsOrigin(modelnum, angles, mins, maxs, NULL);
+		//
+		VectorAdd(mins, origin, mins);
+		VectorAdd(maxs, origin, maxs);
+		//
+		VectorAdd(mins, maxs, mid);
+		VectorScale(mid, 0.5, mid);
+		VectorCopy(mid, origin);
+		//
+		VectorCopy(origin, move_end);
+		VectorCopy(origin, move_start);
+		//
+		AAS_IntForBSPEpairKey(ent, "spawnflags", &spawnflags);
+		// set the axis of bobbing
+		if (spawnflags & 1) axis = 0;
+		else if (spawnflags & 2) axis = 1;
+		else axis = 2;
+		//
+		move_start[axis] -= height;
+		move_end[axis] += height;
+		//
+		Log_Write("funcbob model %d, start = {%1.1f, %1.1f, %1.1f} end = {%1.1f, %1.1f, %1.1f}\n",
+					modelnum, move_start[0], move_start[1], move_start[2], move_end[0], move_end[1], move_end[2]);
+		//
+#ifndef BSPC
+		/*
+		AAS_DrawPermanentCross(move_start, 4, 1);
+		AAS_DrawPermanentCross(move_end, 4, 2);
+		*/
+#endif
+		//
+		for (i = 0; i < 4; i++)
+		{
+			VectorCopy(move_start, start_edgeverts[i]);
+			start_edgeverts[i][2] += maxs[2] - mid[2]; //+ bbox maxs z
+			start_edgeverts[i][2] += 24;	//+ player origin to ground dist
+		} //end for
+		start_edgeverts[0][0] += maxs[0] - mid[0];
+		start_edgeverts[0][1] += maxs[1] - mid[1];
+		start_edgeverts[1][0] += maxs[0] - mid[0];
+		start_edgeverts[1][1] += mins[1] - mid[1];
+		start_edgeverts[2][0] += mins[0] - mid[0];
+		start_edgeverts[2][1] += mins[1] - mid[1];
+		start_edgeverts[3][0] += mins[0] - mid[0];
+		start_edgeverts[3][1] += maxs[1] - mid[1];
+		//
+		start_plane.dist = start_edgeverts[0][2];
+		VectorSet(start_plane.normal, 0, 0, 1);
+		//
+		for (i = 0; i < 4; i++)
+		{
+			VectorCopy(move_end, end_edgeverts[i]);
+			end_edgeverts[i][2] += maxs[2] - mid[2]; //+ bbox maxs z
+			end_edgeverts[i][2] += 24;	//+ player origin to ground dist
+		} //end for
+		end_edgeverts[0][0] += maxs[0] - mid[0];
+		end_edgeverts[0][1] += maxs[1] - mid[1];
+		end_edgeverts[1][0] += maxs[0] - mid[0];
+		end_edgeverts[1][1] += mins[1] - mid[1];
+		end_edgeverts[2][0] += mins[0] - mid[0];
+		end_edgeverts[2][1] += mins[1] - mid[1];
+		end_edgeverts[3][0] += mins[0] - mid[0];
+		end_edgeverts[3][1] += maxs[1] - mid[1];
+		//
+		end_plane.dist = end_edgeverts[0][2];
+		VectorSet(end_plane.normal, 0, 0, 1);
+		//
+#ifndef BSPC
+#if 0
+		for (i = 0; i < 4; i++)
+		{
+			AAS_PermanentLine(start_edgeverts[i], start_edgeverts[(i+1)%4], 1);
+			AAS_PermanentLine(end_edgeverts[i], end_edgeverts[(i+1)%4], 1);
+		} //end for
+#endif
+#endif
+		VectorCopy(move_start, move_start_top);
+		move_start_top[2] += maxs[2] - mid[2] + 24; //+ bbox maxs z
+		VectorCopy(move_end, move_end_top);
+		move_end_top[2] += maxs[2] - mid[2] + 24; //+ bbox maxs z
+		//
+		if (!AAS_PointAreaNum(move_start_top)) continue;
+		if (!AAS_PointAreaNum(move_end_top)) continue;
+		//
+		for (i = 0; i < 2; i++)
+		{
+			firststartreach = firstendreach = NULL;
+			//
+			if (i == 0)
+			{
+				firststartreach = AAS_FindFaceReachabilities(start_edgeverts, 4, &start_plane, qtrue);
+				firstendreach = AAS_FindFaceReachabilities(end_edgeverts, 4, &end_plane, qfalse);
+			} //end if
+			else
+			{
+				firststartreach = AAS_FindFaceReachabilities(end_edgeverts, 4, &end_plane, qtrue);
+				firstendreach = AAS_FindFaceReachabilities(start_edgeverts, 4, &start_plane, qfalse);
+			} //end else
+			//
+			//create reachabilities from start to end
+			for (startreach = firststartreach; startreach; startreach = nextstartreach)
+			{
+				nextstartreach = startreach->next;
+				//
+				//trace = AAS_TraceClientBBox(startreach->start, move_start_top, PRESENCE_NORMAL, -1);
+				//if (trace.fraction < 1) continue;
+				//
+				for (endreach = firstendreach; endreach; endreach = nextendreach)
+				{
+					nextendreach = endreach->next;
+					//
+					//trace = AAS_TraceClientBBox(endreach->end, move_end_top, PRESENCE_NORMAL, -1);
+					//if (trace.fraction < 1) continue;
+					//
+					Log_Write("funcbob reach from area %d to %d\n", startreach->areanum, endreach->areanum);
+					//
+					//
+					if (i == 0) VectorCopy(move_start_top, org);
+					else VectorCopy(move_end_top, org);
+					VectorSubtract(startreach->start, org, dir);
+					dir[2] = 0;
+					VectorNormalize(dir);
+					VectorCopy(startreach->start, start);
+					VectorMA(startreach->start, 1, dir, start);
+					start[2] += 1;
+					VectorMA(startreach->start, 16, dir, end);
+					end[2] += 1;
+					//
+					numareas = AAS_TraceAreas(start, end, areas, points, 10);
+					if (numareas <= 0) continue;
+					if (numareas > 1) VectorCopy(points[1], startreach->start);
+					else VectorCopy(end, startreach->start);
+					//
+					if (!AAS_PointAreaNum(startreach->start)) continue;
+					if (!AAS_PointAreaNum(endreach->end)) continue;
+					//
+					lreach = AAS_AllocReachability();
+					lreach->areanum = endreach->areanum;
+					if (i == 0) lreach->edgenum = ((int)move_start[axis] << 16) | ((int) move_end[axis] & 0x0000ffff);
+					else lreach->edgenum = ((int)move_end[axis] << 16) | ((int) move_start[axis] & 0x0000ffff);
+					lreach->facenum = (spawnflags << 16) | modelnum;
+					VectorCopy(startreach->start, lreach->start);
+					VectorCopy(endreach->end, lreach->end);
+#ifndef BSPC
+//					AAS_DrawArrow(lreach->start, lreach->end, LINECOLOR_BLUE, LINECOLOR_YELLOW);
+//					AAS_PermanentLine(lreach->start, lreach->end, 1);
+#endif
+					lreach->traveltype = TRAVEL_FUNCBOB;
+					lreach->traveltype |= AAS_TravelFlagsForTeam(ent);
+					lreach->traveltime = aassettings.rs_funcbob;
+					reach_funcbob++;
+					lreach->next = areareachability[startreach->areanum];
+					areareachability[startreach->areanum] = lreach;
+					//
+				} //end for
+			} //end for
+			for (startreach = firststartreach; startreach; startreach = nextstartreach)
+			{
+				nextstartreach = startreach->next;
+				AAS_FreeReachability(startreach);
+			} //end for
+			for (endreach = firstendreach; endreach; endreach = nextendreach)
+			{
+				nextendreach = endreach->next;
+				AAS_FreeReachability(endreach);
+			} //end for
+			//only go up with func_bobbing entities that go up and down
+			if (!(spawnflags & 1) && !(spawnflags & 2)) break;
+		} //end for
+	} //end for
+} //end of the function AAS_Reachability_FuncBobbing
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+void AAS_Reachability_JumpPad(void)
+{
+	int face2num, i, ret, area2num, visualize, ent, bot_visualizejumppads;
+	//int modelnum, ent2;
+	//float dist, time, height, gravity, forward;
+	float speed, zvel, hordist;
+	aas_face_t *face2;
+	aas_area_t *area2;
+	aas_lreachability_t *lreach;
+	vec3_t areastart, facecenter, dir, cmdmove;
+	vec3_t velocity, absmins, absmaxs;
+	//vec3_t origin, ent2origin, angles, teststart;
+	aas_clientmove_t move;
+	//aas_trace_t trace;
+	aas_link_t *areas, *link;
+	//char target[MAX_EPAIRKEY], targetname[MAX_EPAIRKEY], model[MAX_EPAIRKEY];
+	char classname[MAX_EPAIRKEY];
+
+#ifdef BSPC
+	bot_visualizejumppads = 0;
+#else
+	bot_visualizejumppads = LibVarValue("bot_visualizejumppads", "0");
+#endif
+	for (ent = AAS_NextBSPEntity(0); ent; ent = AAS_NextBSPEntity(ent))
+	{
+		if (!AAS_ValueForBSPEpairKey(ent, "classname", classname, MAX_EPAIRKEY)) continue;
+		if (strcmp(classname, "trigger_push")) continue;
+		//
+		if (!AAS_GetJumpPadInfo(ent, areastart, absmins, absmaxs, velocity)) continue;
+		/*
+		//
+		AAS_FloatForBSPEpairKey(ent, "speed", &speed);
+		if (!speed) speed = 1000;
+//		AAS_VectorForBSPEpairKey(ent, "angles", angles);
+//		AAS_SetMovedir(angles, velocity);
+//		VectorScale(velocity, speed, velocity);
+		VectorClear(angles);
+		//get the mins, maxs and origin of the model
+		AAS_ValueForBSPEpairKey(ent, "model", model, MAX_EPAIRKEY);
+		if (model[0]) modelnum = atoi(model+1);
+		else modelnum = 0;
+		AAS_BSPModelMinsMaxsOrigin(modelnum, angles, absmins, absmaxs, origin);
+		VectorAdd(origin, absmins, absmins);
+		VectorAdd(origin, absmaxs, absmaxs);
+		//
+#ifdef REACH_DEBUG
+		botimport.Print(PRT_MESSAGE, "absmins = %f %f %f\n", absmins[0], absmins[1], absmins[2]);
+		botimport.Print(PRT_MESSAGE, "absmaxs = %f %f %f\n", absmaxs[0], absmaxs[1], absmaxs[2]);
+#endif REACH_DEBUG
+		VectorAdd(absmins, absmaxs, origin);
+		VectorScale (origin, 0.5, origin);
+
+		//get the start areas
+		VectorCopy(origin, teststart);
+		teststart[2] += 64;
+		trace = AAS_TraceClientBBox(teststart, origin, PRESENCE_CROUCH, -1);
+		if (trace.startsolid)
+		{
+			botimport.Print(PRT_MESSAGE, "trigger_push start solid\n");
+			VectorCopy(origin, areastart);
+		} //end if
+		else
+		{
+			VectorCopy(trace.endpos, areastart);
+		} //end else
+		areastart[2] += 0.125;
+		//
+		//AAS_DrawPermanentCross(origin, 4, 4);
+		//get the target entity
+		AAS_ValueForBSPEpairKey(ent, "target", target, MAX_EPAIRKEY);
+		for (ent2 = AAS_NextBSPEntity(0); ent2; ent2 = AAS_NextBSPEntity(ent2))
+		{
+			if (!AAS_ValueForBSPEpairKey(ent2, "targetname", targetname, MAX_EPAIRKEY)) continue;
+			if (!strcmp(targetname, target)) break;
+		} //end for
+		if (!ent2)
+		{
+			botimport.Print(PRT_MESSAGE, "trigger_push without target entity %s\n", target);
+			continue;
+		} //end if
+		AAS_VectorForBSPEpairKey(ent2, "origin", ent2origin);
+		//
+		height = ent2origin[2] - origin[2];
+		gravity = aassettings.sv_gravity;
+		time = sqrt( height / ( 0.5 * gravity ) );
+		if (!time)
+		{
+			botimport.Print(PRT_MESSAGE, "trigger_push without time\n");
+			continue;
+		} //end if
+		// set s.origin2 to the push velocity
+		VectorSubtract ( ent2origin, origin, velocity);
+		dist = VectorNormalize( velocity);
+		forward = dist / time;
+		//FIXME: why multiply by 1.1
+		forward *= 1.1;
+		VectorScale(velocity, forward, velocity);
+		velocity[2] = time * gravity;
+		*/
+		//get the areas the jump pad brush is in
+		areas = AAS_LinkEntityClientBBox(absmins, absmaxs, -1, PRESENCE_CROUCH);
+		/*
+		for (link = areas; link; link = link->next_area)
+		{
+			if (link->areanum == 563)
+			{
+				ret = qfalse;
+			}
+		}
+        */
+		for (link = areas; link; link = link->next_area)
+		{
+			if (AAS_AreaJumpPad(link->areanum)) break;
+		} //end for
+		if (!link)
+		{
+			botimport.Print(PRT_MESSAGE, "trigger_push not in any jump pad area\n");
+			AAS_UnlinkFromAreas(areas);
+			continue;
+		} //end if
+		//
+		botimport.Print(PRT_MESSAGE, "found a trigger_push with velocity %f %f %f\n", velocity[0], velocity[1], velocity[2]);
+		//if there is a horizontal velocity check for a reachability without air control
+		if (velocity[0] || velocity[1])
+		{
+			VectorSet(cmdmove, 0, 0, 0);
+			//VectorCopy(velocity, cmdmove);
+			//cmdmove[2] = 0;
+			Com_Memset(&move, 0, sizeof(aas_clientmove_t));
+			area2num = 0;
+			for (i = 0; i < 20; i++)
+			{
+				AAS_PredictClientMovement(&move, -1, areastart, PRESENCE_NORMAL, qfalse,
+										velocity, cmdmove, 0, 30, 0.1f,
+										SE_HITGROUND|SE_ENTERWATER|SE_ENTERSLIME|
+										SE_ENTERLAVA|SE_HITGROUNDDAMAGE|SE_TOUCHJUMPPAD|SE_TOUCHTELEPORTER, 0, bot_visualizejumppads);
+				area2num = move.endarea;
+				for (link = areas; link; link = link->next_area)
+				{
+					if (!AAS_AreaJumpPad(link->areanum)) continue;
+					if (link->areanum == area2num) break;
+				} //end if
+				if (!link) break;
+				VectorCopy(move.endpos, areastart);
+				VectorCopy(move.velocity, velocity);
+			} //end for
+			if (area2num && i < 20)
+			{
+				for (link = areas; link; link = link->next_area)
+				{
+					if (!AAS_AreaJumpPad(link->areanum)) continue;
+					if (AAS_ReachabilityExists(link->areanum, area2num)) continue;
+					//create a rocket or bfg jump reachability from area1 to area2
+					lreach = AAS_AllocReachability();
+					if (!lreach)
+					{
+						AAS_UnlinkFromAreas(areas);
+						return;
+					} //end if
+					lreach->areanum = area2num;
+					//NOTE: the facenum is the Z velocity
+					lreach->facenum = velocity[2];
+					//NOTE: the edgenum is the horizontal velocity
+					lreach->edgenum = sqrt(velocity[0] * velocity[0] + velocity[1] * velocity[1]);
+					VectorCopy(areastart, lreach->start);
+					VectorCopy(move.endpos, lreach->end);
+					lreach->traveltype = TRAVEL_JUMPPAD;
+					lreach->traveltype |= AAS_TravelFlagsForTeam(ent);
+					lreach->traveltime = aassettings.rs_jumppad;
+					lreach->next = areareachability[link->areanum];
+					areareachability[link->areanum] = lreach;
+					//
+					reach_jumppad++;
+				} //end for
+			} //end if
+		} //end if
+		//
+		if (fabs(velocity[0]) > 100 || fabs(velocity[1]) > 100) continue;
+		//check for areas we can reach with air control
+		for (area2num = 1; area2num < aasworld.numareas; area2num++)
+		{
+			visualize = qfalse;
+			/*
+			if (area2num == 3568)
+			{
+				for (link = areas; link; link = link->next_area)
+				{
+					if (link->areanum == 3380)
+					{
+						visualize = qtrue;
+						botimport.Print(PRT_MESSAGE, "bah\n");
+					} //end if
+				} //end for
+			} //end if*/
+			//never try to go back to one of the original jumppad areas
+			//and don't create reachabilities if they already exist
+			for (link = areas; link; link = link->next_area)
+			{
+				if (AAS_ReachabilityExists(link->areanum, area2num)) break;
+				if (AAS_AreaJumpPad(link->areanum))
+				{
+					if (link->areanum == area2num) break;
+				} //end if
+			} //end if
+			if (link) continue;
+			//
+			area2 = &aasworld.areas[area2num];
+			for (i = 0; i < area2->numfaces; i++)
+			{
+				face2num = aasworld.faceindex[area2->firstface + i];
+				face2 = &aasworld.faces[abs(face2num)];
+				//if it is not a ground face
+				if (!(face2->faceflags & FACE_GROUND)) continue;
+				//get the center of the face
+				AAS_FaceCenter(face2num, facecenter);
+				//only go higher up
+				if (facecenter[2] < areastart[2]) continue;
+				//get the jumppad jump z velocity
+				zvel = velocity[2];
+				//get the horizontal speed for the jump, if it isn't possible to calculate this
+				//speed
+				ret = AAS_HorizontalVelocityForJump(zvel, areastart, facecenter, &speed);
+				if (ret && speed < 150)
+				{
+					//direction towards the face center
+					VectorSubtract(facecenter, areastart, dir);
+					dir[2] = 0;
+					hordist = VectorNormalize(dir);
+					//if (hordist < 1.6 * facecenter[2] - areastart[2])
+					{
+						//get command movement
+						VectorScale(dir, speed, cmdmove);
+						//
+						AAS_PredictClientMovement(&move, -1, areastart, PRESENCE_NORMAL, qfalse,
+													velocity, cmdmove, 30, 30, 0.1f,
+													SE_ENTERWATER|SE_ENTERSLIME|
+													SE_ENTERLAVA|SE_HITGROUNDDAMAGE|
+													SE_TOUCHJUMPPAD|SE_TOUCHTELEPORTER|SE_HITGROUNDAREA, area2num, visualize);
+						//if prediction time wasn't enough to fully predict the movement
+						//don't enter slime or lava and don't fall from too high
+						if (move.frames < 30 && 
+								!(move.stopevent & (SE_ENTERSLIME|SE_ENTERLAVA|SE_HITGROUNDDAMAGE))
+								&& (move.stopevent & (SE_HITGROUNDAREA|SE_TOUCHJUMPPAD|SE_TOUCHTELEPORTER)))
+						{
+							//never go back to the same jumppad
+							for (link = areas; link; link = link->next_area)
+							{
+								if (link->areanum == move.endarea) break;
+							}
+							if (!link)
+							{
+								for (link = areas; link; link = link->next_area)
+								{
+									if (!AAS_AreaJumpPad(link->areanum)) continue;
+									if (AAS_ReachabilityExists(link->areanum, area2num)) continue;
+									//create a jumppad reachability from area1 to area2
+									lreach = AAS_AllocReachability();
+									if (!lreach)
+									{
+										AAS_UnlinkFromAreas(areas);
+										return;
+									} //end if
+									lreach->areanum = move.endarea;
+									//NOTE: the facenum is the Z velocity
+									lreach->facenum = velocity[2];
+									//NOTE: the edgenum is the horizontal velocity
+									lreach->edgenum = sqrt(cmdmove[0] * cmdmove[0] + cmdmove[1] * cmdmove[1]);
+									VectorCopy(areastart, lreach->start);
+									VectorCopy(facecenter, lreach->end);
+									lreach->traveltype = TRAVEL_JUMPPAD;
+									lreach->traveltype |= AAS_TravelFlagsForTeam(ent);
+									lreach->traveltime = aassettings.rs_aircontrolledjumppad;
+									lreach->next = areareachability[link->areanum];
+									areareachability[link->areanum] = lreach;
+									//
+									reach_jumppad++;
+								} //end for
+							}
+						} //end if
+					} //end if
+				} //end for
+			} //end for
+		} //end for
+		AAS_UnlinkFromAreas(areas);
+	} //end for
+} //end of the function AAS_Reachability_JumpPad
+//===========================================================================
+// never point at ground faces
+// always a higher and pretty far area
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int AAS_Reachability_Grapple(int area1num, int area2num)
+{
+	int face2num, i, j, areanum, numareas, areas[20];
+	float mingrappleangle, z, hordist;
+	bsp_trace_t bsptrace;
+	aas_trace_t trace;
+	aas_face_t *face2;
+	aas_area_t *area1, *area2;
+	aas_lreachability_t *lreach;
+	vec3_t areastart, facecenter, start, end, dir, down = {0, 0, -1};
+	vec_t *v;
+
+	//only grapple when on the ground or swimming
+	if (!AAS_AreaGrounded(area1num) && !AAS_AreaSwim(area1num)) return qfalse;
+	//don't grapple from a crouch area
+	if (!(AAS_AreaPresenceType(area1num) & PRESENCE_NORMAL)) return qfalse;
+	//NOTE: disabled area swim it doesn't work right
+	if (AAS_AreaSwim(area1num)) return qfalse;
+	//
+	area1 = &aasworld.areas[area1num];
+	area2 = &aasworld.areas[area2num];
+	//don't grapple towards way lower areas
+	if (area2->maxs[2] < area1->mins[2]) return qfalse;
+	//
+	VectorCopy(aasworld.areas[area1num].center, start);
+	//if not a swim area
+	if (!AAS_AreaSwim(area1num))
+	{
+		if (!AAS_PointAreaNum(start)) Log_Write("area %d center %f %f %f in solid?\r\n", area1num,
+								start[0], start[1], start[2]);
+		VectorCopy(start, end);
+		end[2] -= 1000;
+		trace = AAS_TraceClientBBox(start, end, PRESENCE_CROUCH, -1);
+		if (trace.startsolid) return qfalse;
+		VectorCopy(trace.endpos, areastart);
+	} //end if
+	else
+	{
+		if (!(AAS_PointContents(start) & (CONTENTS_LAVA|CONTENTS_SLIME|CONTENTS_WATER))) return qfalse;
+	} //end else
+	//
+	//start is now the start point
+	//
+	for (i = 0; i < area2->numfaces; i++)
+	{
+		face2num = aasworld.faceindex[area2->firstface + i];
+		face2 = &aasworld.faces[abs(face2num)];
+		//if it is not a solid face
+		if (!(face2->faceflags & FACE_SOLID)) continue;
+		//direction towards the first vertex of the face
+		v = aasworld.vertexes[aasworld.edges[abs(aasworld.edgeindex[face2->firstedge])].v[0]];
+		VectorSubtract(v, areastart, dir);
+		//if the face plane is facing away
+		if (DotProduct(aasworld.planes[face2->planenum].normal, dir) > 0) continue;
+		//get the center of the face
+		AAS_FaceCenter(face2num, facecenter);
+		//only go higher up with the grapple
+		if (facecenter[2] < areastart[2] + 64) continue;
+		//only use vertical faces or downward facing faces
+		if (DotProduct(aasworld.planes[face2->planenum].normal, down) < 0) continue;
+		//direction towards the face center
+		VectorSubtract(facecenter, areastart, dir);
+		//
+		z = dir[2];
+		dir[2] = 0;
+		hordist = VectorLength(dir);
+		if (!hordist) continue;
+		//if too far
+		if (hordist > 2000) continue;
+		//check the minimal angle of the movement
+		mingrappleangle = 15; //15 degrees
+		if (z / hordist < tan(2 * M_PI * mingrappleangle / 360)) continue;
+		//
+		VectorCopy(facecenter, start);
+		VectorMA(facecenter, -500, aasworld.planes[face2->planenum].normal, end);
+		//
+		bsptrace = AAS_Trace(start, NULL, NULL, end, 0, CONTENTS_SOLID);
+		//the grapple won't stick to the sky and the grapple point should be near the AAS wall
+		if ((bsptrace.surface.flags & SURF_SKY) || (bsptrace.fraction * 500 > 32)) continue;
+		//trace a full bounding box from the area center on the ground to
+		//the center of the face
+		VectorSubtract(facecenter, areastart, dir);
+		VectorNormalize(dir);
+		VectorMA(areastart, 4, dir, start);
+		VectorCopy(bsptrace.endpos, end);
+		trace = AAS_TraceClientBBox(start, end, PRESENCE_NORMAL, -1);
+		VectorSubtract(trace.endpos, facecenter, dir);
+		if (VectorLength(dir) > 24) continue;
+		//
+		VectorCopy(trace.endpos, start);
+		VectorCopy(trace.endpos, end);
+		end[2] -= AAS_FallDamageDistance();
+		trace = AAS_TraceClientBBox(start, end, PRESENCE_NORMAL, -1);
+		if (trace.fraction >= 1) continue;
+		//area to end in
+		areanum = AAS_PointAreaNum(trace.endpos);
+		//if not in lava or slime
+		if (aasworld.areasettings[areanum].contents & (AREACONTENTS_SLIME|AREACONTENTS_LAVA))
+		{
+			continue;
+		} //end if
+		//do not go the the source area
+		if (areanum == area1num) continue;
+		//don't create reachabilities if they already exist
+		if (AAS_ReachabilityExists(area1num, areanum)) continue;
+		//only end in areas we can stand
+		if (!AAS_AreaGrounded(areanum)) continue;
+		//never go through cluster portals!!
+		numareas = AAS_TraceAreas(areastart, bsptrace.endpos, areas, NULL, 20);
+		if (numareas >= 20) continue;
+		for (j = 0; j < numareas; j++)
+		{
+			if (aasworld.areasettings[areas[j]].contents & AREACONTENTS_CLUSTERPORTAL) break;
+		} //end for
+		if (j < numareas) continue;
+		//create a new reachability link
+		lreach = AAS_AllocReachability();
+		if (!lreach) return qfalse;
+		lreach->areanum = areanum;
+		lreach->facenum = face2num;
+		lreach->edgenum = 0;
+		VectorCopy(areastart, lreach->start);
+		//VectorCopy(facecenter, lreach->end);
+		VectorCopy(bsptrace.endpos, lreach->end);
+		lreach->traveltype = TRAVEL_GRAPPLEHOOK;
+		VectorSubtract(lreach->end, lreach->start, dir);
+		lreach->traveltime = aassettings.rs_startgrapple + VectorLength(dir) * 0.25;
+		lreach->next = areareachability[area1num];
+		areareachability[area1num] = lreach;
+		//
+		reach_grapple++;
+	} //end for
+	//
+	return qfalse;
+} //end of the function AAS_Reachability_Grapple
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void AAS_SetWeaponJumpAreaFlags(void)
+{
+	int ent, i;
+	vec3_t mins = {-15, -15, -15}, maxs = {15, 15, 15};
+	vec3_t origin;
+	int areanum, weaponjumpareas, spawnflags;
+	char classname[MAX_EPAIRKEY];
+
+	weaponjumpareas = 0;
+	for (ent = AAS_NextBSPEntity(0); ent; ent = AAS_NextBSPEntity(ent))
+	{
+		if (!AAS_ValueForBSPEpairKey(ent, "classname", classname, MAX_EPAIRKEY)) continue;
+		if (
+			!strcmp(classname, "item_armor_body") ||
+			!strcmp(classname, "item_health") ||
+			!strcmp(classname, "weapon_disruptor") ||
+			!strcmp(classname, "weapon_repeater") ||
+			!strcmp(classname, "weapon_demp2") ||
+			!strcmp(classname, "weapon_flechette") ||
+			!strcmp(classname, "weapon_rocket_launcher"))
+		{
+			if (AAS_VectorForBSPEpairKey(ent, "origin", origin))
+			{
+				spawnflags = 0;
+				AAS_IntForBSPEpairKey(ent, "spawnflags", &spawnflags);
+				//if not a stationary item
+				if (!(spawnflags & 1))
+				{
+					if (!AAS_DropToFloor(origin, mins, maxs))
+					{
+						botimport.Print(PRT_MESSAGE, "%s in solid at (%1.1f %1.1f %1.1f)\n",
+														classname, origin[0], origin[1], origin[2]);
+					} //end if
+				} //end if
+				//areanum = AAS_PointAreaNum(origin);
+				areanum = AAS_BestReachableArea(origin, mins, maxs, origin);
+				//the bot may rocket jump towards this area
+				aasworld.areasettings[areanum].areaflags |= AREA_WEAPONJUMP;
+				//
+				//if (!AAS_AreaGrounded(areanum))
+				//	botimport.Print(PRT_MESSAGE, "area not grounded\n");
+				//
+				weaponjumpareas++;
+			} //end if
+		} //end if
+	} //end for
+	for (i = 1; i < aasworld.numareas; i++)
+	{
+		if (aasworld.areasettings[i].contents & AREACONTENTS_JUMPPAD)
+		{
+			aasworld.areasettings[i].areaflags |= AREA_WEAPONJUMP;
+			weaponjumpareas++;
+		} //end if
+	} //end for
+	botimport.Print(PRT_MESSAGE, "%d weapon jump areas\n", weaponjumpareas);
+} //end of the function AAS_SetWeaponJumpAreaFlags
+//===========================================================================
+// create a possible weapon jump reachability from area1 to area2
+//
+// check if there's a cool item in the second area
+// check if area1 is lower than area2
+// check if the bot can rocketjump from area1 to area2
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int AAS_Reachability_WeaponJump(int area1num, int area2num)
+{
+	int face2num, i, n, ret, visualize;
+	float speed, zvel, hordist;
+	aas_face_t *face2;
+	aas_area_t *area1, *area2;
+	aas_lreachability_t *lreach;
+	vec3_t areastart, facecenter, start, end, dir, cmdmove;// teststart;
+	vec3_t velocity;
+	aas_clientmove_t move;
+	aas_trace_t trace;
+
+	visualize = qfalse;
+//	if (area1num == 4436 && area2num == 4318)
+//	{
+//		visualize = qtrue;
+//	}
+	if (!AAS_AreaGrounded(area1num) || AAS_AreaSwim(area1num)) return qfalse;
+	if (!AAS_AreaGrounded(area2num)) return qfalse;
+	//NOTE: only weapon jump towards areas with an interesting item in it??
+	if (!(aasworld.areasettings[area2num].areaflags & AREA_WEAPONJUMP)) return qfalse;
+	//
+	area1 = &aasworld.areas[area1num];
+	area2 = &aasworld.areas[area2num];
+	//don't weapon jump towards way lower areas
+	if (area2->maxs[2] < area1->mins[2]) return qfalse;
+	//
+	VectorCopy(aasworld.areas[area1num].center, start);
+	//if not a swim area
+	if (!AAS_PointAreaNum(start)) Log_Write("area %d center %f %f %f in solid?\r\n", area1num,
+							start[0], start[1], start[2]);
+	VectorCopy(start, end);
+	end[2] -= 1000;
+	trace = AAS_TraceClientBBox(start, end, PRESENCE_CROUCH, -1);
+	if (trace.startsolid) return qfalse;
+	VectorCopy(trace.endpos, areastart);
+	//
+	//areastart is now the start point
+	//
+	for (i = 0; i < area2->numfaces; i++)
+	{
+		face2num = aasworld.faceindex[area2->firstface + i];
+		face2 = &aasworld.faces[abs(face2num)];
+		//if it is not a solid face
+		if (!(face2->faceflags & FACE_GROUND)) continue;
+		//get the center of the face
+		AAS_FaceCenter(face2num, facecenter);
+		//only go higher up with weapon jumps
+		if (facecenter[2] < areastart[2] + 64) continue;
+		//NOTE: set to 2 to allow bfg jump reachabilities
+		for (n = 0; n < 1/*2*/; n++)
+		{
+			//get the rocket jump z velocity
+			if (n) zvel = AAS_BFGJumpZVelocity(areastart);
+			else zvel = AAS_RocketJumpZVelocity(areastart);
+			//get the horizontal speed for the jump, if it isn't possible to calculate this
+			//speed (the jump is not possible) then there's no jump reachability created
+			ret = AAS_HorizontalVelocityForJump(zvel, areastart, facecenter, &speed);
+			if (ret && speed < 300)
+			{
+				//direction towards the face center
+				VectorSubtract(facecenter, areastart, dir);
+				dir[2] = 0;
+				hordist = VectorNormalize(dir);
+				//if (hordist < 1.6 * (facecenter[2] - areastart[2]))
+				{
+					//get command movement
+					VectorScale(dir, speed, cmdmove);
+					VectorSet(velocity, 0, 0, zvel);
+					/*
+					//get command movement
+					VectorScale(dir, speed, velocity);
+					velocity[2] = zvel;
+					VectorSet(cmdmove, 0, 0, 0);
+					*/
+					//
+					AAS_PredictClientMovement(&move, -1, areastart, PRESENCE_NORMAL, qtrue,
+												velocity, cmdmove, 30, 30, 0.1f,
+												SE_ENTERWATER|SE_ENTERSLIME|
+												SE_ENTERLAVA|SE_HITGROUNDDAMAGE|
+												SE_TOUCHJUMPPAD|SE_HITGROUND|SE_HITGROUNDAREA, area2num, visualize);
+					//if prediction time wasn't enough to fully predict the movement
+					//don't enter slime or lava and don't fall from too high
+					if (move.frames < 30 && 
+							!(move.stopevent & (SE_ENTERSLIME|SE_ENTERLAVA|SE_HITGROUNDDAMAGE))
+								&& (move.stopevent & (SE_HITGROUNDAREA|SE_TOUCHJUMPPAD)))
+					{
+						//create a rocket or bfg jump reachability from area1 to area2
+						lreach = AAS_AllocReachability();
+						if (!lreach) return qfalse;
+						lreach->areanum = area2num;
+						lreach->facenum = 0;
+						lreach->edgenum = 0;
+						VectorCopy(areastart, lreach->start);
+						VectorCopy(facecenter, lreach->end);
+						if (n)
+						{
+							lreach->traveltype = TRAVEL_BFGJUMP;
+							lreach->traveltime = aassettings.rs_bfgjump;
+						} //end if
+						else
+						{
+							lreach->traveltype = TRAVEL_ROCKETJUMP;
+							lreach->traveltime = aassettings.rs_rocketjump;
+						} //end else
+						lreach->next = areareachability[area1num];
+						areareachability[area1num] = lreach;
+						//
+						reach_rocketjump++;
+						return qtrue;
+					} //end if
+				} //end if
+			} //end if
+		} //end for
+	} //end for
+	//
+	return qfalse;
+} //end of the function AAS_Reachability_WeaponJump
+//===========================================================================
+// calculates additional walk off ledge reachabilities for the given area
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void AAS_Reachability_WalkOffLedge(int areanum)
+{
+	int i, j, k, l, m, n, p, areas[10], numareas;
+	int face1num, face2num, face3num, edge1num, edge2num, edge3num;
+	int otherareanum, gap, reachareanum, side;
+	aas_area_t *area, *area2;
+	aas_face_t *face1, *face2, *face3;
+	aas_edge_t *edge;
+	aas_plane_t *plane;
+	vec_t *v1, *v2;
+	vec3_t sharededgevec, mid, dir, testend;
+	aas_lreachability_t *lreach;
+	aas_trace_t trace;
+
+	if (!AAS_AreaGrounded(areanum) || AAS_AreaSwim(areanum)) return;
+	//
+	area = &aasworld.areas[areanum];
+	//
+	for (i = 0; i < area->numfaces; i++)
+	{
+		face1num = aasworld.faceindex[area->firstface + i];
+		face1 = &aasworld.faces[abs(face1num)];
+		//face 1 must be a ground face
+		if (!(face1->faceflags & FACE_GROUND)) continue;
+		//go through all the edges of this ground face
+		for (k = 0; k < face1->numedges; k++)
+		{
+			edge1num = aasworld.edgeindex[face1->firstedge + k];
+			//find another not ground face using this same edge
+			for (j = 0; j < area->numfaces; j++)
+			{
+				face2num = aasworld.faceindex[area->firstface + j];
+				face2 = &aasworld.faces[abs(face2num)];
+				//face 2 may not be a ground face
+				if (face2->faceflags & FACE_GROUND) continue;
+				//compare all the edges
+				for (l = 0; l < face2->numedges; l++)
+				{
+					edge2num = aasworld.edgeindex[face2->firstedge + l];
+					if (abs(edge1num) == abs(edge2num))
+					{
+						//get the area at the other side of the face
+						if (face2->frontarea == areanum) otherareanum = face2->backarea;
+						else otherareanum = face2->frontarea;
+						//
+						area2 = &aasworld.areas[otherareanum];
+						//if the other area is grounded!
+						if (aasworld.areasettings[otherareanum].areaflags & AREA_GROUNDED)
+						{
+							//check for a possible gap
+							gap = qfalse;
+							for (n = 0; n < area2->numfaces; n++)
+							{
+								face3num = aasworld.faceindex[area2->firstface + n];
+								//may not be the shared face of the two areas
+								if (abs(face3num) == abs(face2num)) continue;
+								//
+								face3 = &aasworld.faces[abs(face3num)];
+								//find an edge shared by all three faces
+								for (m = 0; m < face3->numedges; m++)
+								{
+									edge3num = aasworld.edgeindex[face3->firstedge + m];
+									//but the edge should be shared by all three faces
+									if (abs(edge3num) == abs(edge1num))
+									{
+										if (!(face3->faceflags & FACE_SOLID))
+										{
+											gap = qtrue;
+											break;
+										} //end if
+										//
+										if (face3->faceflags & FACE_GROUND)
+										{
+											gap = qfalse;
+											break;
+										} //end if
+										//FIXME: there are more situations to be handled
+										gap = qtrue;
+										break;
+									} //end if
+								} //end for
+								if (m < face3->numedges) break;
+							} //end for
+							if (!gap) break;
+						} //end if
+						//check for a walk off ledge reachability
+						edge = &aasworld.edges[abs(edge1num)];
+						side = edge1num < 0;
+						//
+						v1 = aasworld.vertexes[edge->v[side]];
+						v2 = aasworld.vertexes[edge->v[!side]];
+						//
+						plane = &aasworld.planes[face1->planenum];
+						//get the points really into the areas
+						VectorSubtract(v2, v1, sharededgevec);
+						CrossProduct(plane->normal, sharededgevec, dir);
+						VectorNormalize(dir);
+						//
+						VectorAdd(v1, v2, mid);
+						VectorScale(mid, 0.5, mid);
+						VectorMA(mid, 8, dir, mid);
+						//
+						VectorCopy(mid, testend);
+						testend[2] -= 1000;
+						trace = AAS_TraceClientBBox(mid, testend, PRESENCE_CROUCH, -1);
+						//
+						if (trace.startsolid)
+						{
+							//Log_Write("area %d: trace.startsolid\r\n", areanum);
+							break;
+						} //end if
+						reachareanum = AAS_PointAreaNum(trace.endpos);
+						if (reachareanum == areanum)
+						{
+							//Log_Write("area %d: same area\r\n", areanum);
+							break;
+						} //end if
+						if (AAS_ReachabilityExists(areanum, reachareanum))
+						{
+							//Log_Write("area %d: reachability already exists\r\n", areanum);
+							break;
+						} //end if
+						if (!AAS_AreaGrounded(reachareanum) && !AAS_AreaSwim(reachareanum))
+						{
+							//Log_Write("area %d, reach area %d: not grounded and not swim\r\n", areanum, reachareanum);
+							break;
+						} //end if
+						//
+						if (aasworld.areasettings[reachareanum].contents & (AREACONTENTS_SLIME
+																						| AREACONTENTS_LAVA))
+						{
+							//Log_Write("area %d, reach area %d: lava or slime\r\n", areanum, reachareanum);
+							break;
+						} //end if
+						//if not going through a cluster portal
+						numareas = AAS_TraceAreas(mid, testend, areas, NULL, sizeof(areas) / sizeof(int));
+						for (p = 0; p < numareas; p++)
+							if (AAS_AreaClusterPortal(areas[p]))
+								break;
+						if (p < numareas)
+							break;
+						// if a maximum fall height is set and the bot would fall down further
+						if (aassettings.rs_maxfallheight && fabs(mid[2] - trace.endpos[2]) > aassettings.rs_maxfallheight)
+							break;
+						//
+						lreach = AAS_AllocReachability();
+						if (!lreach) break;
+						lreach->areanum = reachareanum;
+						lreach->facenum = 0;
+						lreach->edgenum = edge1num;
+						VectorCopy(mid, lreach->start);
+						VectorCopy(trace.endpos, lreach->end);
+						lreach->traveltype = TRAVEL_WALKOFFLEDGE;
+						lreach->traveltime = aassettings.rs_startwalkoffledge + fabs(mid[2] - trace.endpos[2]) * 50 / aassettings.phys_gravity;
+						if (!AAS_AreaSwim(reachareanum) && !AAS_AreaJumpPad(reachareanum))
+						{
+							if (AAS_FallDelta(mid[2] - trace.endpos[2]) > aassettings.phys_falldelta5)
+							{
+								lreach->traveltime += aassettings.rs_falldamage5;
+							} //end if
+							else if (AAS_FallDelta(mid[2] - trace.endpos[2]) > aassettings.phys_falldelta10)
+							{
+								lreach->traveltime += aassettings.rs_falldamage10;
+							} //end if
+						} //end if
+						lreach->next = areareachability[areanum];
+						areareachability[areanum] = lreach;
+						//we've got another walk off ledge reachability
+						reach_walkoffledge++;
+					} //end if
+				} //end for
+			} //end for
+		} //end for
+	} //end for
+} //end of the function AAS_Reachability_WalkOffLedge
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void AAS_StoreReachability(void)
+{
+	int i;
+	aas_areasettings_t *areasettings;
+	aas_lreachability_t *lreach;
+	aas_reachability_t *reach;
+
+	if (aasworld.reachability) FreeMemory(aasworld.reachability);
+	aasworld.reachability = (aas_reachability_t *) GetClearedMemory((numlreachabilities + 10) * sizeof(aas_reachability_t));
+	aasworld.reachabilitysize = 1;
+	for (i = 0; i < aasworld.numareas; i++)
+	{
+		areasettings = &aasworld.areasettings[i];
+		areasettings->firstreachablearea = aasworld.reachabilitysize;
+		areasettings->numreachableareas = 0;
+		for (lreach = areareachability[i]; lreach; lreach = lreach->next)
+		{
+			reach = &aasworld.reachability[areasettings->firstreachablearea +
+													areasettings->numreachableareas];
+			reach->areanum = lreach->areanum;
+			reach->facenum = lreach->facenum;
+			reach->edgenum = lreach->edgenum;
+			VectorCopy(lreach->start, reach->start);
+			VectorCopy(lreach->end, reach->end);
+			reach->traveltype = lreach->traveltype;
+			reach->traveltime = lreach->traveltime;
+			//
+			areasettings->numreachableareas++;
+		} //end for
+		aasworld.reachabilitysize += areasettings->numreachableareas;
+	} //end for
+} //end of the function AAS_StoreReachability
+//===========================================================================
+//
+// TRAVEL_WALK					100%	equal floor height + steps
+// TRAVEL_CROUCH				100%
+// TRAVEL_BARRIERJUMP			100%
+// TRAVEL_JUMP					 80%
+// TRAVEL_LADDER				100%	+ fall down from ladder + jump up to ladder
+// TRAVEL_WALKOFFLEDGE			 90%	walk off very steep walls?
+// TRAVEL_SWIM					100%
+// TRAVEL_WATERJUMP				100%
+// TRAVEL_TELEPORT				100%
+// TRAVEL_ELEVATOR				100%
+// TRAVEL_GRAPPLEHOOK			100%
+// TRAVEL_DOUBLEJUMP			  0%
+// TRAVEL_RAMPJUMP				  0%
+// TRAVEL_STRAFEJUMP			  0%
+// TRAVEL_ROCKETJUMP			100%	(currently limited towards areas with items)
+// TRAVEL_BFGJUMP				  0%	(currently disabled)
+// TRAVEL_JUMPPAD				100%
+// TRAVEL_FUNCBOB				100%
+//
+// Parameter:			-
+// Returns:				true if NOT finished
+// Changes Globals:		-
+//===========================================================================
+int AAS_ContinueInitReachability(float time)
+{
+	int i, j, todo, start_time;
+	static float framereachability, reachability_delay;
+	static int lastpercentage;
+
+	if (!aasworld.loaded) return qfalse;
+	//if reachability is calculated for all areas
+	if (aasworld.numreachabilityareas >= aasworld.numareas + 2) return qfalse;
+	//if starting with area 1 (area 0 is a dummy)
+	if (aasworld.numreachabilityareas == 1)
+	{
+		botimport.Print(PRT_MESSAGE, "calculating reachability...\n");
+		lastpercentage = 0;
+		framereachability = 2000;
+		reachability_delay = 1000;
+	} //end if
+	//number of areas to calculate reachability for this cycle
+	todo = aasworld.numreachabilityareas + (int) framereachability;
+	start_time = Sys_MilliSeconds();
+	//loop over the areas
+	for (i = aasworld.numreachabilityareas; i < aasworld.numareas && i < todo; i++)
+	{
+		aasworld.numreachabilityareas++;
+		//only create jumppad reachabilities from jumppad areas
+		if (aasworld.areasettings[i].contents & AREACONTENTS_JUMPPAD)
+		{
+			continue;
+		} //end if
+		//loop over the areas
+		for (j = 1; j < aasworld.numareas; j++)
+		{
+			if (i == j) continue;
+			//never create reachabilities from teleporter or jumppad areas to regular areas
+			if (aasworld.areasettings[i].contents & (AREACONTENTS_TELEPORTER|AREACONTENTS_JUMPPAD))
+			{
+				if (!(aasworld.areasettings[j].contents & (AREACONTENTS_TELEPORTER|AREACONTENTS_JUMPPAD)))
+				{
+					continue;
+				} //end if
+			} //end if
+			//if there already is a reachability link from area i to j
+			if (AAS_ReachabilityExists(i, j)) continue;
+			//check for a swim reachability
+			if (AAS_Reachability_Swim(i, j)) continue;
+			//check for a simple walk on equal floor height reachability
+			if (AAS_Reachability_EqualFloorHeight(i, j)) continue;
+			//check for step, barrier, waterjump and walk off ledge reachabilities
+			if (AAS_Reachability_Step_Barrier_WaterJump_WalkOffLedge(i, j)) continue;
+			//check for ladder reachabilities
+			if (AAS_Reachability_Ladder(i, j)) continue;
+			//check for a jump reachability
+			if (AAS_Reachability_Jump(i, j)) continue;
+		} //end for
+		//never create these reachabilities from teleporter or jumppad areas
+		if (aasworld.areasettings[i].contents & (AREACONTENTS_TELEPORTER|AREACONTENTS_JUMPPAD))
+		{
+			continue;
+		} //end if
+		//loop over the areas
+		for (j = 1; j < aasworld.numareas; j++)
+		{
+			if (i == j) continue;
+			//
+			if (AAS_ReachabilityExists(i, j)) continue;
+			//check for a grapple hook reachability
+			if (calcgrapplereach) AAS_Reachability_Grapple(i, j);
+			//check for a weapon jump reachability
+			AAS_Reachability_WeaponJump(i, j);
+		} //end for
+		//if the calculation took more time than the max reachability delay
+		if (Sys_MilliSeconds() - start_time > (int) reachability_delay) break;
+		//
+		if (aasworld.numreachabilityareas * 1000 / aasworld.numareas > lastpercentage) break;
+	} //end for
+	//
+	if (aasworld.numreachabilityareas == aasworld.numareas)
+	{
+		botimport.Print(PRT_MESSAGE, "\r%6.1f%%", (float) 100.0);
+		botimport.Print(PRT_MESSAGE, "\nplease wait while storing reachability...\n");
+		aasworld.numreachabilityareas++;
+	} //end if
+	//if this is the last step in the reachability calculations
+	else if (aasworld.numreachabilityareas == aasworld.numareas + 1)
+	{
+		//create additional walk off ledge reachabilities for every area
+		for (i = 1; i < aasworld.numareas; i++)
+		{
+			//only create jumppad reachabilities from jumppad areas
+			if (aasworld.areasettings[i].contents & AREACONTENTS_JUMPPAD)
+			{
+				continue;
+			} //end if
+			AAS_Reachability_WalkOffLedge(i);
+		} //end for
+		//create jump pad reachabilities
+		AAS_Reachability_JumpPad();
+		//create teleporter reachabilities
+		AAS_Reachability_Teleport();
+		//create elevator (func_plat) reachabilities
+		AAS_Reachability_Elevator();
+		//create func_bobbing reachabilities
+		AAS_Reachability_FuncBobbing();
+		//
+#ifdef DEBUG
+		botimport.Print(PRT_MESSAGE, "%6d reach swim\n", reach_swim);
+		botimport.Print(PRT_MESSAGE, "%6d reach equal floor\n", reach_equalfloor);
+		botimport.Print(PRT_MESSAGE, "%6d reach step\n", reach_step);
+		botimport.Print(PRT_MESSAGE, "%6d reach barrier\n", reach_barrier);
+		botimport.Print(PRT_MESSAGE, "%6d reach waterjump\n", reach_waterjump);
+		botimport.Print(PRT_MESSAGE, "%6d reach walkoffledge\n", reach_walkoffledge);
+		botimport.Print(PRT_MESSAGE, "%6d reach jump\n", reach_jump);
+		botimport.Print(PRT_MESSAGE, "%6d reach ladder\n", reach_ladder);
+		botimport.Print(PRT_MESSAGE, "%6d reach walk\n", reach_walk);
+		botimport.Print(PRT_MESSAGE, "%6d reach teleport\n", reach_teleport);
+		botimport.Print(PRT_MESSAGE, "%6d reach funcbob\n", reach_funcbob);
+		botimport.Print(PRT_MESSAGE, "%6d reach elevator\n", reach_elevator);
+		botimport.Print(PRT_MESSAGE, "%6d reach grapple\n", reach_grapple);
+		botimport.Print(PRT_MESSAGE, "%6d reach rocketjump\n", reach_rocketjump);
+		botimport.Print(PRT_MESSAGE, "%6d reach jumppad\n", reach_jumppad);
+#endif
+		//*/
+		//store all the reachabilities
+		AAS_StoreReachability();
+		//free the reachability link heap
+		AAS_ShutDownReachabilityHeap();
+		//
+		FreeMemory(areareachability);
+		//
+		aasworld.numreachabilityareas++;
+		//
+		botimport.Print(PRT_MESSAGE, "calculating clusters...\n");
+	} //end if
+	else
+	{
+		lastpercentage = aasworld.numreachabilityareas * 1000 / aasworld.numareas;
+		botimport.Print(PRT_MESSAGE, "\r%6.1f%%", (float) lastpercentage / 10);
+	} //end else
+	//not yet finished
+	return qtrue;
+} //end of the function AAS_ContinueInitReachability
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void AAS_InitReachability(void)
+{
+	if (!aasworld.loaded) return;
+
+	if (aasworld.reachabilitysize)
+	{
+#ifndef BSPC
+		if (!((int)LibVarGetValue("forcereachability")))
+		{
+			aasworld.numreachabilityareas = aasworld.numareas + 2;
+			return;
+		} //end if
+#else
+		aasworld.numreachabilityareas = aasworld.numareas + 2;
+		return;
+#endif //BSPC
+	} //end if
+#ifndef BSPC
+	calcgrapplereach = LibVarGetValue("grapplereach");
+#endif
+	aasworld.savefile = qtrue;
+	//start with area 1 because area zero is a dummy
+	aasworld.numreachabilityareas = 1;
+	////aasworld.numreachabilityareas = aasworld.numareas + 1;		//only calculate entity reachabilities
+	//setup the heap with reachability links
+	AAS_SetupReachabilityHeap();
+	//allocate area reachability link array
+	areareachability = (aas_lreachability_t **) GetClearedMemory(
+									aasworld.numareas * sizeof(aas_lreachability_t *));
+	//
+	AAS_SetWeaponJumpAreaFlags();
+} //end of the function AAS_InitReachable
diff --git a/codemp/botlib/be_aas_reach.h b/codemp/botlib/be_aas_reach.h
new file mode 100644
index 0000000..bbe1f35
--- /dev/null
+++ b/codemp/botlib/be_aas_reach.h
@@ -0,0 +1,51 @@
+
+/*****************************************************************************
+ * name:		be_aas_reach.h
+ *
+ * desc:		AAS
+ *
+ * $Archive: /source/code/botlib/be_aas_reach.h $
+ * $Author: Mrelusive $ 
+ * $Revision: 2 $
+ * $Modtime: 10/05/99 3:32p $
+ * $Date: 10/05/99 3:42p $
+ *
+ *****************************************************************************/
+
+#ifdef AASINTERN
+//initialize calculating the reachabilities
+void AAS_InitReachability(void);
+//continue calculating the reachabilities
+int AAS_ContinueInitReachability(float time);
+//
+int AAS_BestReachableLinkArea(aas_link_t *areas);
+#endif //AASINTERN
+
+//returns true if the are has reachabilities to other areas
+int AAS_AreaReachability(int areanum);
+//returns the best reachable area and goal origin for a bounding box at the given origin
+int AAS_BestReachableArea(vec3_t origin, vec3_t mins, vec3_t maxs, vec3_t goalorigin);
+//returns the best jumppad area from which the bbox at origin is reachable
+int AAS_BestReachableFromJumpPadArea(vec3_t origin, vec3_t mins, vec3_t maxs);
+//returns the next reachability using the given model
+int AAS_NextModelReachability(int num, int modelnum);
+//returns the total area of the ground faces of the given area
+float AAS_AreaGroundFaceArea(int areanum);
+//returns true if the area is crouch only
+int AAS_AreaCrouch(int areanum);
+//returns true if a player can swim in this area
+int AAS_AreaSwim(int areanum);
+//returns true if the area is filled with a liquid
+int AAS_AreaLiquid(int areanum);
+//returns true if the area contains lava
+int AAS_AreaLava(int areanum);
+//returns true if the area contains slime
+int AAS_AreaSlime(int areanum);
+//returns true if the area has one or more ground faces
+int AAS_AreaGrounded(int areanum);
+//returns true if the area has one or more ladder faces
+int AAS_AreaLadder(int areanum);
+//returns true if the area is a jump pad
+int AAS_AreaJumpPad(int areanum);
+//returns true if the area is donotenter
+int AAS_AreaDoNotEnter(int areanum);
diff --git a/codemp/botlib/be_aas_route.cpp b/codemp/botlib/be_aas_route.cpp
new file mode 100644
index 0000000..5b27a7b
--- /dev/null
+++ b/codemp/botlib/be_aas_route.cpp
@@ -0,0 +1,2192 @@
+
+/*****************************************************************************
+ * name:		be_aas_route.c
+ *
+ * desc:		AAS
+ *
+ * $Archive: /MissionPack/code/botlib/be_aas_route.c $
+ * $Author: Mrelusive $ 
+ * $Revision: 18 $
+ * $Modtime: 12/01/00 1:11p $
+ * $Date: 12/01/00 1:11p $
+ *
+ *****************************************************************************/
+
+#include "../game/q_shared.h"
+#include "l_utils.h"
+#include "l_memory.h"
+#include "l_log.h"
+#include "l_crc.h"
+#include "l_libvar.h"
+#include "l_script.h"
+#include "l_precomp.h"
+#include "l_struct.h"
+#include "aasfile.h"
+#include "../game/botlib.h"
+#include "../game/be_aas.h"
+#include "be_aas_funcs.h"
+#include "be_interface.h"
+#include "be_aas_def.h"
+
+#define ROUTING_DEBUG
+
+//travel time in hundreths of a second = distance * 100 / speed
+#define DISTANCEFACTOR_CROUCH		1.3f		//crouch speed = 100
+#define DISTANCEFACTOR_SWIM			1		//should be 0.66, swim speed = 150
+#define DISTANCEFACTOR_WALK			0.33f	//walk speed = 300
+
+//cache refresh time
+#define CACHE_REFRESHTIME		15.0f	//15 seconds refresh time
+
+//maximum number of routing updates each frame
+#define MAX_FRAMEROUTINGUPDATES		10
+
+
+/*
+
+  area routing cache:
+  stores the distances within one cluster to a specific goal area
+  this goal area is in this same cluster and could be a cluster portal
+  for every cluster there's a list with routing cache for every area
+  in that cluster (including the portals of that cluster)
+  area cache stores aasworld.clusters[?].numreachabilityareas travel times
+
+  portal routing cache:
+  stores the distances of all portals to a specific goal area
+  this goal area could be in any cluster and could also be a cluster portal
+  for every area (aasworld.numareas) the portal cache stores
+  aasworld.numportals travel times
+
+*/
+
+#ifdef ROUTING_DEBUG
+int numareacacheupdates;
+int numportalcacheupdates;
+#endif //ROUTING_DEBUG
+
+int routingcachesize;
+int max_routingcachesize;
+
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+#ifdef ROUTING_DEBUG
+void AAS_RoutingInfo(void)
+{
+	botimport.Print(PRT_MESSAGE, "%d area cache updates\n", numareacacheupdates);
+	botimport.Print(PRT_MESSAGE, "%d portal cache updates\n", numportalcacheupdates);
+	botimport.Print(PRT_MESSAGE, "%d bytes routing cache\n", routingcachesize);
+} //end of the function AAS_RoutingInfo
+#endif //ROUTING_DEBUG
+//===========================================================================
+// returns the number of the area in the cluster
+// assumes the given area is in the given cluster or a portal of the cluster
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+__inline int AAS_ClusterAreaNum(int cluster, int areanum)
+{
+	int side, areacluster;
+
+	areacluster = aasworld.areasettings[areanum].cluster;
+	if (areacluster > 0) return aasworld.areasettings[areanum].clusterareanum;
+	else
+	{
+/*#ifdef ROUTING_DEBUG
+		if (aasworld.portals[-areacluster].frontcluster != cluster &&
+				aasworld.portals[-areacluster].backcluster != cluster)
+		{
+			botimport.Print(PRT_ERROR, "portal %d: does not belong to cluster %d\n"
+											, -areacluster, cluster);
+		} //end if
+#endif //ROUTING_DEBUG*/
+		side = aasworld.portals[-areacluster].frontcluster != cluster;
+		return aasworld.portals[-areacluster].clusterareanum[side];
+	} //end else
+} //end of the function AAS_ClusterAreaNum
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+void AAS_InitTravelFlagFromType(void)
+{
+	int i;
+
+	for (i = 0; i < MAX_TRAVELTYPES; i++)
+	{
+		aasworld.travelflagfortype[i] = TFL_INVALID;
+	} //end for
+	aasworld.travelflagfortype[TRAVEL_INVALID] = TFL_INVALID;
+	aasworld.travelflagfortype[TRAVEL_WALK] = TFL_WALK;
+	aasworld.travelflagfortype[TRAVEL_CROUCH] = TFL_CROUCH;
+	aasworld.travelflagfortype[TRAVEL_BARRIERJUMP] = TFL_BARRIERJUMP;
+	aasworld.travelflagfortype[TRAVEL_JUMP] = TFL_JUMP;
+	aasworld.travelflagfortype[TRAVEL_LADDER] = TFL_LADDER;
+	aasworld.travelflagfortype[TRAVEL_WALKOFFLEDGE] = TFL_WALKOFFLEDGE;
+	aasworld.travelflagfortype[TRAVEL_SWIM] = TFL_SWIM;
+	aasworld.travelflagfortype[TRAVEL_WATERJUMP] = TFL_WATERJUMP;
+	aasworld.travelflagfortype[TRAVEL_TELEPORT] = TFL_TELEPORT;
+	aasworld.travelflagfortype[TRAVEL_ELEVATOR] = TFL_ELEVATOR;
+	aasworld.travelflagfortype[TRAVEL_ROCKETJUMP] = TFL_ROCKETJUMP;
+	aasworld.travelflagfortype[TRAVEL_BFGJUMP] = TFL_BFGJUMP;
+	aasworld.travelflagfortype[TRAVEL_GRAPPLEHOOK] = TFL_GRAPPLEHOOK;
+	aasworld.travelflagfortype[TRAVEL_DOUBLEJUMP] = TFL_DOUBLEJUMP;
+	aasworld.travelflagfortype[TRAVEL_RAMPJUMP] = TFL_RAMPJUMP;
+	aasworld.travelflagfortype[TRAVEL_STRAFEJUMP] = TFL_STRAFEJUMP;
+	aasworld.travelflagfortype[TRAVEL_JUMPPAD] = TFL_JUMPPAD;
+	aasworld.travelflagfortype[TRAVEL_FUNCBOB] = TFL_FUNCBOB;
+} //end of the function AAS_InitTravelFlagFromType
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+__inline int AAS_TravelFlagForType_inline(int traveltype)
+{
+	int tfl;
+
+	tfl = 0;
+	if (tfl & TRAVELFLAG_NOTTEAM1)
+		tfl |= TFL_NOTTEAM1;
+	if (tfl & TRAVELFLAG_NOTTEAM2)
+		tfl |= TFL_NOTTEAM2;
+	traveltype &= TRAVELTYPE_MASK;
+	if (traveltype < 0 || traveltype >= MAX_TRAVELTYPES)
+		return TFL_INVALID;
+	tfl |= aasworld.travelflagfortype[traveltype];
+	return tfl;
+} //end of the function AAS_TravelFlagForType_inline
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+int AAS_TravelFlagForType(int traveltype)
+{
+	return AAS_TravelFlagForType_inline(traveltype);
+} //end of the function AAS_TravelFlagForType_inline
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+void AAS_UnlinkCache(aas_routingcache_t *cache)
+{
+	if (cache->time_next) cache->time_next->time_prev = cache->time_prev;
+	else aasworld.newestcache = cache->time_prev;
+	if (cache->time_prev) cache->time_prev->time_next = cache->time_next;
+	else aasworld.oldestcache = cache->time_next;
+	cache->time_next = NULL;
+	cache->time_prev = NULL;
+} //end of the function AAS_UnlinkCache
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+void AAS_LinkCache(aas_routingcache_t *cache)
+{
+	if (aasworld.newestcache)
+	{
+		aasworld.newestcache->time_next = cache;
+		cache->time_prev = aasworld.newestcache;
+	} //end if
+	else
+	{
+		aasworld.oldestcache = cache;
+		cache->time_prev = NULL;
+	} //end else
+	cache->time_next = NULL;
+	aasworld.newestcache = cache;
+} //end of the function AAS_LinkCache
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+void AAS_FreeRoutingCache(aas_routingcache_t *cache)
+{
+	AAS_UnlinkCache(cache);
+	routingcachesize -= cache->size;
+	FreeMemory(cache);
+} //end of the function AAS_FreeRoutingCache
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+void AAS_RemoveRoutingCacheInCluster( int clusternum )
+{
+	int i;
+	aas_routingcache_t *cache, *nextcache;
+	aas_cluster_t *cluster;
+
+	if (!aasworld.clusterareacache)
+		return;
+	cluster = &aasworld.clusters[clusternum];
+	for (i = 0; i < cluster->numareas; i++)
+	{
+		for (cache = aasworld.clusterareacache[clusternum][i]; cache; cache = nextcache)
+		{
+			nextcache = cache->next;
+			AAS_FreeRoutingCache(cache);
+		} //end for
+		aasworld.clusterareacache[clusternum][i] = NULL;
+	} //end for
+} //end of the function AAS_RemoveRoutingCacheInCluster
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+void AAS_RemoveRoutingCacheUsingArea( int areanum )
+{
+	int i, clusternum;
+	aas_routingcache_t *cache, *nextcache;
+
+	clusternum = aasworld.areasettings[areanum].cluster;
+	if (clusternum > 0)
+	{
+		//remove all the cache in the cluster the area is in
+		AAS_RemoveRoutingCacheInCluster( clusternum );
+	} //end if
+	else
+	{
+		// if this is a portal remove all cache in both the front and back cluster
+		AAS_RemoveRoutingCacheInCluster( aasworld.portals[-clusternum].frontcluster );
+		AAS_RemoveRoutingCacheInCluster( aasworld.portals[-clusternum].backcluster );
+	} //end else
+	// remove all portal cache
+	for (i = 0; i < aasworld.numareas; i++)
+	{
+		//refresh portal cache
+		for (cache = aasworld.portalcache[i]; cache; cache = nextcache)
+		{
+			nextcache = cache->next;
+			AAS_FreeRoutingCache(cache);
+		} //end for
+		aasworld.portalcache[i] = NULL;
+	} //end for
+} //end of the function AAS_RemoveRoutingCacheUsingArea
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+int AAS_EnableRoutingArea(int areanum, int enable)
+{
+	int flags;
+
+	if (areanum <= 0 || areanum >= aasworld.numareas)
+	{
+		if (bot_developer)
+		{
+			botimport.Print(PRT_ERROR, "AAS_EnableRoutingArea: areanum %d out of range\n", areanum);
+		} //end if
+		return 0;
+	} //end if
+	flags = aasworld.areasettings[areanum].areaflags & AREA_DISABLED;
+	if (enable < 0)
+		return !flags;
+
+	if (enable)
+		aasworld.areasettings[areanum].areaflags &= ~AREA_DISABLED;
+	else
+		aasworld.areasettings[areanum].areaflags |= AREA_DISABLED;
+	// if the status of the area changed
+	if ( (flags & AREA_DISABLED) != (aasworld.areasettings[areanum].areaflags & AREA_DISABLED) )
+	{
+		//remove all routing cache involving this area
+		AAS_RemoveRoutingCacheUsingArea( areanum );
+	} //end if
+	return !flags;
+} //end of the function AAS_EnableRoutingArea
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+__inline float AAS_RoutingTime(void)
+{
+	return AAS_Time();
+} //end of the function AAS_RoutingTime
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int AAS_GetAreaContentsTravelFlags(int areanum)
+{
+	int contents, tfl;
+
+	contents = aasworld.areasettings[areanum].contents;
+	tfl = 0;
+	if (contents & AREACONTENTS_WATER)
+		tfl |= TFL_WATER;
+	else if (contents & AREACONTENTS_SLIME)
+		tfl |= TFL_SLIME;
+	else if (contents & AREACONTENTS_LAVA)
+		tfl |= TFL_LAVA;
+	else
+		tfl |= TFL_AIR;
+	if (contents & AREACONTENTS_DONOTENTER)
+		tfl |= TFL_DONOTENTER;
+	if (contents & AREACONTENTS_NOTTEAM1)
+		tfl |= TFL_NOTTEAM1;
+	if (contents & AREACONTENTS_NOTTEAM2)
+		tfl |= TFL_NOTTEAM2;
+	if (aasworld.areasettings[areanum].areaflags & AREA_BRIDGE)
+		tfl |= TFL_BRIDGE;
+	return tfl;
+} //end of the function AAS_GetAreaContentsTravelFlags
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+__inline int AAS_AreaContentsTravelFlags_inline(int areanum)
+{
+	return aasworld.areacontentstravelflags[areanum];
+} //end of the function AAS_AreaContentsTravelFlags
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+int AAS_AreaContentsTravelFlags(int areanum)
+{
+	return aasworld.areacontentstravelflags[areanum];
+} //end of the function AAS_AreaContentsTravelFlags
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+void AAS_InitAreaContentsTravelFlags(void)
+{
+	int i;
+
+	if (aasworld.areacontentstravelflags) FreeMemory(aasworld.areacontentstravelflags);
+	aasworld.areacontentstravelflags = (int *) GetClearedMemory(aasworld.numareas * sizeof(int));
+	//
+	for (i = 0; i < aasworld.numareas; i++) {
+		aasworld.areacontentstravelflags[i] = AAS_GetAreaContentsTravelFlags(i);
+	}
+} //end of the function AAS_InitAreaContentsTravelFlags
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+void AAS_CreateReversedReachability(void)
+{
+	int i, n;
+	aas_reversedlink_t *revlink;
+	aas_reachability_t *reach;
+	aas_areasettings_t *settings;
+	char *ptr;
+#ifdef DEBUG
+	int starttime;
+
+	starttime = Sys_MilliSeconds();
+#endif
+	//free reversed links that have already been created
+	if (aasworld.reversedreachability) FreeMemory(aasworld.reversedreachability);
+	//allocate memory for the reversed reachability links
+	ptr = (char *) GetClearedMemory(aasworld.numareas * sizeof(aas_reversedreachability_t) +
+							aasworld.reachabilitysize * sizeof(aas_reversedlink_t));
+	//
+	aasworld.reversedreachability = (aas_reversedreachability_t *) ptr;
+	//pointer to the memory for the reversed links
+	ptr += aasworld.numareas * sizeof(aas_reversedreachability_t);
+	//check all reachabilities of all areas
+	for (i = 1; i < aasworld.numareas; i++)
+	{
+		//settings of the area
+		settings = &aasworld.areasettings[i];
+		//
+		if (settings->numreachableareas >= 128)
+			botimport.Print(PRT_WARNING, "area %d has more than 128 reachabilities\n", i);
+		//create reversed links for the reachabilities
+		for (n = 0; n < settings->numreachableareas && n < 128; n++)
+		{
+			//reachability link
+			reach = &aasworld.reachability[settings->firstreachablearea + n];
+			//
+			revlink = (aas_reversedlink_t *) ptr;
+			ptr += sizeof(aas_reversedlink_t);
+			//
+			revlink->areanum = i;
+			revlink->linknum = settings->firstreachablearea + n;
+			revlink->next = aasworld.reversedreachability[reach->areanum].first;
+			aasworld.reversedreachability[reach->areanum].first = revlink;
+			aasworld.reversedreachability[reach->areanum].numlinks++;
+		} //end for
+	} //end for
+#ifdef DEBUG
+	botimport.Print(PRT_MESSAGE, "reversed reachability %d msec\n", Sys_MilliSeconds() - starttime);
+#endif
+} //end of the function AAS_CreateReversedReachability
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+unsigned short int AAS_AreaTravelTime(int areanum, vec3_t start, vec3_t end)
+{
+	int intdist;
+	float dist;
+	vec3_t dir;
+
+	VectorSubtract(start, end, dir);
+	dist = VectorLength(dir);
+	//if crouch only area
+	if (AAS_AreaCrouch(areanum)) dist *= DISTANCEFACTOR_CROUCH;
+	//if swim area
+	else if (AAS_AreaSwim(areanum)) dist *= DISTANCEFACTOR_SWIM;
+	//normal walk area
+	else dist *= DISTANCEFACTOR_WALK;
+	//
+	intdist = (int) dist;
+	//make sure the distance isn't zero
+	if (intdist <= 0) intdist = 1;
+	return intdist;
+} //end of the function AAS_AreaTravelTime
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+void AAS_CalculateAreaTravelTimes(void)
+{
+	int i, l, n, size;
+	char *ptr;
+	vec3_t end;
+	aas_reversedreachability_t *revreach;
+	aas_reversedlink_t *revlink;
+	aas_reachability_t *reach;
+	aas_areasettings_t *settings;
+	int starttime;
+
+	starttime = Sys_MilliSeconds();
+	//if there are still area travel times, free the memory
+	if (aasworld.areatraveltimes) FreeMemory(aasworld.areatraveltimes);
+	//get the total size of all the area travel times
+	size = aasworld.numareas * sizeof(unsigned short **);
+	for (i = 0; i < aasworld.numareas; i++)
+	{
+		revreach = &aasworld.reversedreachability[i];
+		//settings of the area
+		settings = &aasworld.areasettings[i];
+		//
+		size += settings->numreachableareas * sizeof(unsigned short *);
+		//
+		size += settings->numreachableareas * revreach->numlinks * sizeof(unsigned short);
+	} //end for
+	//allocate memory for the area travel times
+	ptr = (char *) GetClearedMemory(size);
+	aasworld.areatraveltimes = (unsigned short ***) ptr;
+	ptr += aasworld.numareas * sizeof(unsigned short **);
+	//calcluate the travel times for all the areas
+	for (i = 0; i < aasworld.numareas; i++)
+	{
+		//reversed reachabilities of this area
+		revreach = &aasworld.reversedreachability[i];
+		//settings of the area
+		settings = &aasworld.areasettings[i];
+		//
+		aasworld.areatraveltimes[i] = (unsigned short **) ptr;
+		ptr += settings->numreachableareas * sizeof(unsigned short *);
+		//
+		for (l = 0; l < settings->numreachableareas; l++)
+		{
+			aasworld.areatraveltimes[i][l] = (unsigned short *) ptr;
+			ptr += revreach->numlinks * sizeof(unsigned short);
+			//reachability link
+			reach = &aasworld.reachability[settings->firstreachablearea + l];
+			//
+			for (n = 0, revlink = revreach->first; revlink; revlink = revlink->next, n++)
+			{
+				VectorCopy(aasworld.reachability[revlink->linknum].end, end);
+				//
+				aasworld.areatraveltimes[i][l][n] = AAS_AreaTravelTime(i, end, reach->start);
+			} //end for
+		} //end for
+	} //end for
+#ifdef DEBUG
+	botimport.Print(PRT_MESSAGE, "area travel times %d msec\n", Sys_MilliSeconds() - starttime);
+#endif
+} //end of the function AAS_CalculateAreaTravelTimes
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+int AAS_PortalMaxTravelTime(int portalnum)
+{
+	int l, n, t, maxt;
+	aas_portal_t *portal;
+	aas_reversedreachability_t *revreach;
+	aas_reversedlink_t *revlink;
+	aas_areasettings_t *settings;
+
+	portal = &aasworld.portals[portalnum];
+	//reversed reachabilities of this portal area
+	revreach = &aasworld.reversedreachability[portal->areanum];
+	//settings of the portal area
+	settings = &aasworld.areasettings[portal->areanum];
+	//
+	maxt = 0;
+	for (l = 0; l < settings->numreachableareas; l++)
+	{
+		for (n = 0, revlink = revreach->first; revlink; revlink = revlink->next, n++)
+		{
+			t = aasworld.areatraveltimes[portal->areanum][l][n];
+			if (t > maxt)
+			{
+				maxt = t;
+			} //end if
+		} //end for
+	} //end for
+	return maxt;
+} //end of the function AAS_PortalMaxTravelTime
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+void AAS_InitPortalMaxTravelTimes(void)
+{
+	int i;
+
+	if (aasworld.portalmaxtraveltimes) FreeMemory(aasworld.portalmaxtraveltimes);
+
+	aasworld.portalmaxtraveltimes = (int *) GetClearedMemory(aasworld.numportals * sizeof(int));
+
+	for (i = 0; i < aasworld.numportals; i++)
+	{
+		aasworld.portalmaxtraveltimes[i] = AAS_PortalMaxTravelTime(i);
+		//botimport.Print(PRT_MESSAGE, "portal %d max tt = %d\n", i, aasworld.portalmaxtraveltimes[i]);
+	} //end for
+} //end of the function AAS_InitPortalMaxTravelTimes
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+/*
+int AAS_FreeOldestCache(void)
+{
+	int i, j, bestcluster, bestarea, freed;
+	float besttime;
+	aas_routingcache_t *cache, *bestcache;
+
+	freed = qfalse;
+	besttime = 999999999;
+	bestcache = NULL;
+	bestcluster = 0;
+	bestarea = 0;
+	//refresh cluster cache
+	for (i = 0; i < aasworld.numclusters; i++)
+	{
+		for (j = 0; j < aasworld.clusters[i].numareas; j++)
+		{
+			for (cache = aasworld.clusterareacache[i][j]; cache; cache = cache->next)
+			{
+				//never remove cache leading towards a portal
+				if (aasworld.areasettings[cache->areanum].cluster < 0) continue;
+				//if this cache is older than the cache we found so far
+				if (cache->time < besttime)
+				{
+					bestcache = cache;
+					bestcluster = i;
+					bestarea = j;
+					besttime = cache->time;
+				} //end if
+			} //end for
+		} //end for
+	} //end for
+	if (bestcache)
+	{
+		cache = bestcache;
+		if (cache->prev) cache->prev->next = cache->next;
+		else aasworld.clusterareacache[bestcluster][bestarea] = cache->next;
+		if (cache->next) cache->next->prev = cache->prev;
+		AAS_FreeRoutingCache(cache);
+		freed = qtrue;
+	} //end if
+	besttime = 999999999;
+	bestcache = NULL;
+	bestarea = 0;
+	for (i = 0; i < aasworld.numareas; i++)
+	{
+		//refresh portal cache
+		for (cache = aasworld.portalcache[i]; cache; cache = cache->next)
+		{
+			if (cache->time < besttime)
+			{
+				bestcache = cache;
+				bestarea = i;
+				besttime = cache->time;
+			} //end if
+		} //end for
+	} //end for
+	if (bestcache)
+	{
+		cache = bestcache;
+		if (cache->prev) cache->prev->next = cache->next;
+		else aasworld.portalcache[bestarea] = cache->next;
+		if (cache->next) cache->next->prev = cache->prev;
+		AAS_FreeRoutingCache(cache);
+		freed = qtrue;
+	} //end if
+	return freed;
+} //end of the function AAS_FreeOldestCache
+*/
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+int AAS_FreeOldestCache(void)
+{
+	int clusterareanum;
+	aas_routingcache_t *cache;
+
+	for (cache = aasworld.oldestcache; cache; cache = cache->time_next) {
+		// never free area cache leading towards a portal
+		if (cache->type == CACHETYPE_AREA && aasworld.areasettings[cache->areanum].cluster < 0) {
+			continue;
+		}
+		break;
+	}
+	if (cache) {
+		// unlink the cache
+		if (cache->type == CACHETYPE_AREA) {
+			//number of the area in the cluster
+			clusterareanum = AAS_ClusterAreaNum(cache->cluster, cache->areanum);
+			// unlink from cluster area cache
+			if (cache->prev) cache->prev->next = cache->next;
+			else aasworld.clusterareacache[cache->cluster][clusterareanum] = cache->next;
+			if (cache->next) cache->next->prev = cache->prev;
+		}
+		else {
+			// unlink from portal cache
+			if (cache->prev) cache->prev->next = cache->next;
+			else aasworld.portalcache[cache->areanum] = cache->next;
+			if (cache->next) cache->next->prev = cache->prev;
+		}
+		AAS_FreeRoutingCache(cache);
+		return qtrue;
+	}
+	return qfalse;
+} //end of the function AAS_FreeOldestCache
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+aas_routingcache_t *AAS_AllocRoutingCache(int numtraveltimes)
+{
+	aas_routingcache_t *cache;
+	int size;
+
+	//
+	size = sizeof(aas_routingcache_t)
+						+ numtraveltimes * sizeof(unsigned short int)
+						+ numtraveltimes * sizeof(unsigned char);
+	//
+	routingcachesize += size;
+	//
+	cache = (aas_routingcache_t *) GetClearedMemory(size);
+	cache->reachabilities = (unsigned char *) cache + sizeof(aas_routingcache_t)
+								+ numtraveltimes * sizeof(unsigned short int);
+	cache->size = size;
+	return cache;
+} //end of the function AAS_AllocRoutingCache
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+void AAS_FreeAllClusterAreaCache(void)
+{
+	int i, j;
+	aas_routingcache_t *cache, *nextcache;
+	aas_cluster_t *cluster;
+
+	//free all cluster cache if existing
+	if (!aasworld.clusterareacache) return;
+	//free caches
+	for (i = 0; i < aasworld.numclusters; i++)
+	{
+		cluster = &aasworld.clusters[i];
+		for (j = 0; j < cluster->numareas; j++)
+		{
+			for (cache = aasworld.clusterareacache[i][j]; cache; cache = nextcache)
+			{
+				nextcache = cache->next;
+				AAS_FreeRoutingCache(cache);
+			} //end for
+			aasworld.clusterareacache[i][j] = NULL;
+		} //end for
+	} //end for
+	//free the cluster cache array
+	FreeMemory(aasworld.clusterareacache);
+	aasworld.clusterareacache = NULL;
+} //end of the function AAS_FreeAllClusterAreaCache
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+void AAS_InitClusterAreaCache(void)
+{
+	int i, size;
+	char *ptr;
+
+	//
+	for (size = 0, i = 0; i < aasworld.numclusters; i++)
+	{
+		size += aasworld.clusters[i].numareas;
+	} //end for
+	//two dimensional array with pointers for every cluster to routing cache
+	//for every area in that cluster
+	ptr = (char *) GetClearedMemory(
+				aasworld.numclusters * sizeof(aas_routingcache_t **) +
+				size * sizeof(aas_routingcache_t *));
+	aasworld.clusterareacache = (aas_routingcache_t ***) ptr;
+	ptr += aasworld.numclusters * sizeof(aas_routingcache_t **);
+	for (i = 0; i < aasworld.numclusters; i++)
+	{
+		aasworld.clusterareacache[i] = (aas_routingcache_t **) ptr;
+		ptr += aasworld.clusters[i].numareas * sizeof(aas_routingcache_t *);
+	} //end for
+} //end of the function AAS_InitClusterAreaCache
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+void AAS_FreeAllPortalCache(void)
+{
+	int i;
+	aas_routingcache_t *cache, *nextcache;
+
+	//free all portal cache if existing
+	if (!aasworld.portalcache) return;
+	//free portal caches
+	for (i = 0; i < aasworld.numareas; i++)
+	{
+		for (cache = aasworld.portalcache[i]; cache; cache = nextcache)
+		{
+			nextcache = cache->next;
+			AAS_FreeRoutingCache(cache);
+		} //end for
+		aasworld.portalcache[i] = NULL;
+	} //end for
+	FreeMemory(aasworld.portalcache);
+	aasworld.portalcache = NULL;
+} //end of the function AAS_FreeAllPortalCache
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void AAS_InitPortalCache(void)
+{
+	//
+	aasworld.portalcache = (aas_routingcache_t **) GetClearedMemory(
+								aasworld.numareas * sizeof(aas_routingcache_t *));
+} //end of the function AAS_InitPortalCache
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void AAS_InitRoutingUpdate(void)
+{
+	int i, maxreachabilityareas;
+
+	//free routing update fields if already existing
+	if (aasworld.areaupdate) FreeMemory(aasworld.areaupdate);
+	//
+	maxreachabilityareas = 0;
+	for (i = 0; i < aasworld.numclusters; i++)
+	{
+		if (aasworld.clusters[i].numreachabilityareas > maxreachabilityareas)
+		{
+			maxreachabilityareas = aasworld.clusters[i].numreachabilityareas;
+		} //end if
+	} //end for
+	//allocate memory for the routing update fields
+	aasworld.areaupdate = (aas_routingupdate_t *) GetClearedMemory(
+									maxreachabilityareas * sizeof(aas_routingupdate_t));
+	//
+	if (aasworld.portalupdate) FreeMemory(aasworld.portalupdate);
+	//allocate memory for the portal update fields
+	aasworld.portalupdate = (aas_routingupdate_t *) GetClearedMemory(
+									(aasworld.numportals+1) * sizeof(aas_routingupdate_t));
+} //end of the function AAS_InitRoutingUpdate
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+void AAS_CreateAllRoutingCache(void)
+{
+	int i, j, t;
+
+	aasworld.initialized = qtrue;
+	botimport.Print(PRT_MESSAGE, "AAS_CreateAllRoutingCache\n");
+	for (i = 1; i < aasworld.numareas; i++)
+	{
+		if (!AAS_AreaReachability(i)) continue;
+		for (j = 1; j < aasworld.numareas; j++)
+		{
+			if (i == j) continue;
+			if (!AAS_AreaReachability(j)) continue;
+			t = AAS_AreaTravelTimeToGoalArea(i, aasworld.areas[i].center, j, TFL_DEFAULT);
+			//Log_Write("traveltime from %d to %d is %d", i, j, t);
+		} //end for
+	} //end for
+	aasworld.initialized = qfalse;
+} //end of the function AAS_CreateAllRoutingCache
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+
+//the route cache header
+//this header is followed by numportalcache + numareacache aas_routingcache_t
+//structures that store routing cache
+typedef struct routecacheheader_s
+{
+	int ident;
+	int version;
+	int numareas;
+	int numclusters;
+	int areacrc;
+	int clustercrc;
+	int numportalcache;
+	int numareacache;
+} routecacheheader_t;
+
+#define RCID						(('C'<<24)+('R'<<16)+('E'<<8)+'M')
+#define RCVERSION					2
+
+//void AAS_DecompressVis(byte *in, int numareas, byte *decompressed);
+//int AAS_CompressVis(byte *vis, int numareas, byte *dest);
+
+void AAS_WriteRouteCache(void)
+{
+	int i, j, numportalcache, numareacache, totalsize;
+	aas_routingcache_t *cache;
+	aas_cluster_t *cluster;
+	fileHandle_t fp;
+	char filename[MAX_QPATH];
+	routecacheheader_t routecacheheader;
+
+	numportalcache = 0;
+	for (i = 0; i < aasworld.numareas; i++)
+	{
+		for (cache = aasworld.portalcache[i]; cache; cache = cache->next)
+		{
+			numportalcache++;
+		} //end for
+	} //end for
+	numareacache = 0;
+	for (i = 0; i < aasworld.numclusters; i++)
+	{
+		cluster = &aasworld.clusters[i];
+		for (j = 0; j < cluster->numareas; j++)
+		{
+			for (cache = aasworld.clusterareacache[i][j]; cache; cache = cache->next)
+			{
+				numareacache++;
+			} //end for
+		} //end for
+	} //end for
+	// open the file for writing
+	Com_sprintf(filename, MAX_QPATH, "maps/%s.rcd", aasworld.mapname);
+	botimport.FS_FOpenFile( filename, &fp, FS_WRITE );
+	if (!fp)
+	{
+		AAS_Error("Unable to open file: %s\n", filename);
+		return;
+	} //end if
+	//create the header
+	routecacheheader.ident = RCID;
+	routecacheheader.version = RCVERSION;
+	routecacheheader.numareas = aasworld.numareas;
+	routecacheheader.numclusters = aasworld.numclusters;
+	routecacheheader.areacrc = CRC_ProcessString( (unsigned char *)aasworld.areas, sizeof(aas_area_t) * aasworld.numareas );
+	routecacheheader.clustercrc = CRC_ProcessString( (unsigned char *)aasworld.clusters, sizeof(aas_cluster_t) * aasworld.numclusters );
+	routecacheheader.numportalcache = numportalcache;
+	routecacheheader.numareacache = numareacache;
+	//write the header
+	botimport.FS_Write(&routecacheheader, sizeof(routecacheheader_t), fp);
+	//
+	totalsize = 0;
+	//write all the cache
+	for (i = 0; i < aasworld.numareas; i++)
+	{
+		for (cache = aasworld.portalcache[i]; cache; cache = cache->next)
+		{
+			botimport.FS_Write(cache, cache->size, fp);
+			totalsize += cache->size;
+		} //end for
+	} //end for
+	for (i = 0; i < aasworld.numclusters; i++)
+	{
+		cluster = &aasworld.clusters[i];
+		for (j = 0; j < cluster->numareas; j++)
+		{
+			for (cache = aasworld.clusterareacache[i][j]; cache; cache = cache->next)
+			{
+				botimport.FS_Write(cache, cache->size, fp);
+				totalsize += cache->size;
+			} //end for
+		} //end for
+	} //end for
+	// write the visareas
+	/*
+	for (i = 0; i < aasworld.numareas; i++)
+	{
+		if (!aasworld.areavisibility[i]) {
+			size = 0;
+			botimport.FS_Write(&size, sizeof(int), fp);
+			continue;
+		}
+		AAS_DecompressVis( aasworld.areavisibility[i], aasworld.numareas, aasworld.decompressedvis );
+		size = AAS_CompressVis( aasworld.decompressedvis, aasworld.numareas, aasworld.decompressedvis );
+		botimport.FS_Write(&size, sizeof(int), fp);
+		botimport.FS_Write(aasworld.decompressedvis, size, fp);
+	}
+	*/
+	//
+	botimport.FS_FCloseFile(fp);
+	botimport.Print(PRT_MESSAGE, "\nroute cache written to %s\n", filename);
+	botimport.Print(PRT_MESSAGE, "written %d bytes of routing cache\n", totalsize);
+} //end of the function AAS_WriteRouteCache
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+aas_routingcache_t *AAS_ReadCache(fileHandle_t fp)
+{
+	int size;
+	aas_routingcache_t *cache;
+
+	botimport.FS_Read(&size, sizeof(size), fp);
+	cache = (aas_routingcache_t *) GetMemory(size);
+	cache->size = size;
+	botimport.FS_Read((unsigned char *)cache + sizeof(size), size - sizeof(size), fp);
+	cache->reachabilities = (unsigned char *) cache + sizeof(aas_routingcache_t) - sizeof(unsigned short) +
+		(size - sizeof(aas_routingcache_t) + sizeof(unsigned short)) / 3 * 2;
+	return cache;
+} //end of the function AAS_ReadCache
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+int AAS_ReadRouteCache(void)
+{
+	int i, clusterareanum;//, size;
+	fileHandle_t fp;
+	char filename[MAX_QPATH];
+	routecacheheader_t routecacheheader;
+	aas_routingcache_t *cache;
+
+	Com_sprintf(filename, MAX_QPATH, "maps/%s.rcd", aasworld.mapname);
+	botimport.FS_FOpenFile( filename, &fp, FS_READ );
+	if (!fp)
+	{
+		return qfalse;
+	} //end if
+	botimport.FS_Read(&routecacheheader, sizeof(routecacheheader_t), fp );
+	if (routecacheheader.ident != RCID)
+	{
+		AAS_Error("%s is not a route cache dump\n");
+		return qfalse;
+	} //end if
+	if (routecacheheader.version != RCVERSION)
+	{
+		AAS_Error("route cache dump has wrong version %d, should be %d", routecacheheader.version, RCVERSION);
+		return qfalse;
+	} //end if
+	if (routecacheheader.numareas != aasworld.numareas)
+	{
+		//AAS_Error("route cache dump has wrong number of areas\n");
+		return qfalse;
+	} //end if
+	if (routecacheheader.numclusters != aasworld.numclusters)
+	{
+		//AAS_Error("route cache dump has wrong number of clusters\n");
+		return qfalse;
+	} //end if
+	if (routecacheheader.areacrc !=
+		CRC_ProcessString( (unsigned char *)aasworld.areas, sizeof(aas_area_t) * aasworld.numareas ))
+	{
+		//AAS_Error("route cache dump area CRC incorrect\n");
+		return qfalse;
+	} //end if
+	if (routecacheheader.clustercrc !=
+		CRC_ProcessString( (unsigned char *)aasworld.clusters, sizeof(aas_cluster_t) * aasworld.numclusters ))
+	{
+		//AAS_Error("route cache dump cluster CRC incorrect\n");
+		return qfalse;
+	} //end if
+	//read all the portal cache
+	for (i = 0; i < routecacheheader.numportalcache; i++)
+	{
+		cache = AAS_ReadCache(fp);
+		cache->next = aasworld.portalcache[cache->areanum];
+		cache->prev = NULL;
+		if (aasworld.portalcache[cache->areanum])
+			aasworld.portalcache[cache->areanum]->prev = cache;
+		aasworld.portalcache[cache->areanum] = cache;
+	} //end for
+	//read all the cluster area cache
+	for (i = 0; i < routecacheheader.numareacache; i++)
+	{
+		cache = AAS_ReadCache(fp);
+		clusterareanum = AAS_ClusterAreaNum(cache->cluster, cache->areanum);
+		cache->next = aasworld.clusterareacache[cache->cluster][clusterareanum];
+		cache->prev = NULL;
+		if (aasworld.clusterareacache[cache->cluster][clusterareanum])
+			aasworld.clusterareacache[cache->cluster][clusterareanum]->prev = cache;
+		aasworld.clusterareacache[cache->cluster][clusterareanum] = cache;
+	} //end for
+	// read the visareas
+	/*
+	aasworld.areavisibility = (byte **) GetClearedMemory(aasworld.numareas * sizeof(byte *));
+	aasworld.decompressedvis = (byte *) GetClearedMemory(aasworld.numareas * sizeof(byte));
+	for (i = 0; i < aasworld.numareas; i++)
+	{
+		botimport.FS_Read(&size, sizeof(size), fp );
+		if (size) {
+			aasworld.areavisibility[i] = (byte *) GetMemory(size);
+			botimport.FS_Read(aasworld.areavisibility[i], size, fp );
+		}
+	}
+	*/
+	//
+	botimport.FS_FCloseFile(fp);
+	return qtrue;
+} //end of the function AAS_ReadRouteCache
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+#define MAX_REACHABILITYPASSAREAS		32
+
+void AAS_InitReachabilityAreas(void)
+{
+	int i, j, numareas, areas[MAX_REACHABILITYPASSAREAS];
+	int numreachareas;
+	aas_reachability_t *reach;
+	vec3_t start, end;
+
+	if (aasworld.reachabilityareas)
+		FreeMemory(aasworld.reachabilityareas);
+	if (aasworld.reachabilityareaindex)
+		FreeMemory(aasworld.reachabilityareaindex);
+
+	aasworld.reachabilityareas = (aas_reachabilityareas_t *)
+				GetClearedMemory(aasworld.reachabilitysize * sizeof(aas_reachabilityareas_t));
+	aasworld.reachabilityareaindex = (int *)
+				GetClearedMemory(aasworld.reachabilitysize * MAX_REACHABILITYPASSAREAS * sizeof(int));
+	numreachareas = 0;
+	for (i = 0; i < aasworld.reachabilitysize; i++)
+	{
+		reach = &aasworld.reachability[i];
+		numareas = 0;
+		switch(reach->traveltype & TRAVELTYPE_MASK)
+		{
+			//trace areas from start to end
+			case TRAVEL_BARRIERJUMP:
+			case TRAVEL_WATERJUMP:
+				VectorCopy(reach->start, end);
+				end[2] = reach->end[2];
+				numareas = AAS_TraceAreas(reach->start, end, areas, NULL, MAX_REACHABILITYPASSAREAS);
+				break;
+			case TRAVEL_WALKOFFLEDGE:
+				VectorCopy(reach->end, start);
+				start[2] = reach->start[2];
+				numareas = AAS_TraceAreas(start, reach->end, areas, NULL, MAX_REACHABILITYPASSAREAS);
+				break;
+			case TRAVEL_GRAPPLEHOOK:
+				numareas = AAS_TraceAreas(reach->start, reach->end, areas, NULL, MAX_REACHABILITYPASSAREAS);
+				break;
+
+			//trace arch
+			case TRAVEL_JUMP: break;
+			case TRAVEL_ROCKETJUMP: break;
+			case TRAVEL_BFGJUMP: break;
+			case TRAVEL_JUMPPAD: break;
+
+			//trace from reach->start to entity center, along entity movement
+			//and from entity center to reach->end
+			case TRAVEL_ELEVATOR: break;
+			case TRAVEL_FUNCBOB: break;
+
+			//no areas in between
+			case TRAVEL_WALK: break;
+			case TRAVEL_CROUCH: break;
+			case TRAVEL_LADDER: break;
+			case TRAVEL_SWIM: break;
+			case TRAVEL_TELEPORT: break;
+			default: break;
+		} //end switch
+		aasworld.reachabilityareas[i].firstarea = numreachareas;
+		aasworld.reachabilityareas[i].numareas = numareas;
+		for (j = 0; j < numareas; j++)
+		{
+			aasworld.reachabilityareaindex[numreachareas++] = areas[j];
+		} //end for
+	} //end for
+} //end of the function AAS_InitReachabilityAreas
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+void AAS_InitRouting(void)
+{
+	AAS_InitTravelFlagFromType();
+	//
+	AAS_InitAreaContentsTravelFlags();
+	//initialize the routing update fields
+	AAS_InitRoutingUpdate();
+	//create reversed reachability links used by the routing update algorithm
+	AAS_CreateReversedReachability();
+	//initialize the cluster cache
+	AAS_InitClusterAreaCache();
+	//initialize portal cache
+	AAS_InitPortalCache();
+	//initialize the area travel times
+	AAS_CalculateAreaTravelTimes();
+	//calculate the maximum travel times through portals
+	AAS_InitPortalMaxTravelTimes();
+	//get the areas reachabilities go through
+	AAS_InitReachabilityAreas();
+	//
+#ifdef ROUTING_DEBUG
+	numareacacheupdates = 0;
+	numportalcacheupdates = 0;
+#endif //ROUTING_DEBUG
+	//
+	routingcachesize = 0;
+	max_routingcachesize = 1024 * (int) LibVarValue("max_routingcache", "4096");
+	// read any routing cache if available
+	AAS_ReadRouteCache();
+} //end of the function AAS_InitRouting
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+void AAS_FreeRoutingCaches(void)
+{
+	// free all the existing cluster area cache
+	AAS_FreeAllClusterAreaCache();
+	// free all the existing portal cache
+	AAS_FreeAllPortalCache();
+	// free cached travel times within areas
+	if (aasworld.areatraveltimes) FreeMemory(aasworld.areatraveltimes);
+	aasworld.areatraveltimes = NULL;
+	// free cached maximum travel time through cluster portals
+	if (aasworld.portalmaxtraveltimes) FreeMemory(aasworld.portalmaxtraveltimes);
+	aasworld.portalmaxtraveltimes = NULL;
+	// free reversed reachability links
+	if (aasworld.reversedreachability) FreeMemory(aasworld.reversedreachability);
+	aasworld.reversedreachability = NULL;
+	// free routing algorithm memory
+	if (aasworld.areaupdate) FreeMemory(aasworld.areaupdate);
+	aasworld.areaupdate = NULL;
+	if (aasworld.portalupdate) FreeMemory(aasworld.portalupdate);
+	aasworld.portalupdate = NULL;
+	// free lists with areas the reachabilities go through
+	if (aasworld.reachabilityareas) FreeMemory(aasworld.reachabilityareas);
+	aasworld.reachabilityareas = NULL;
+	// free the reachability area index
+	if (aasworld.reachabilityareaindex) FreeMemory(aasworld.reachabilityareaindex);
+	aasworld.reachabilityareaindex = NULL;
+	// free area contents travel flags look up table
+	if (aasworld.areacontentstravelflags) FreeMemory(aasworld.areacontentstravelflags);
+	aasworld.areacontentstravelflags = NULL;
+} //end of the function AAS_FreeRoutingCaches
+//===========================================================================
+// update the given routing cache
+//
+// Parameter:			areacache		: routing cache to update
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+void AAS_UpdateAreaRoutingCache(aas_routingcache_t *areacache)
+{
+	int i, nextareanum, cluster, badtravelflags, clusterareanum, linknum;
+	int numreachabilityareas;
+	unsigned short int t, startareatraveltimes[128]; //NOTE: not more than 128 reachabilities per area allowed
+	aas_routingupdate_t *updateliststart, *updatelistend, *curupdate, *nextupdate;
+	aas_reachability_t *reach;
+	aas_reversedreachability_t *revreach;
+	aas_reversedlink_t *revlink;
+
+#ifdef ROUTING_DEBUG
+	numareacacheupdates++;
+#endif //ROUTING_DEBUG
+	//number of reachability areas within this cluster
+	numreachabilityareas = aasworld.clusters[areacache->cluster].numreachabilityareas;
+	//
+	aasworld.frameroutingupdates++;
+	//clear the routing update fields
+//	Com_Memset(aasworld.areaupdate, 0, aasworld.numareas * sizeof(aas_routingupdate_t));
+	//
+	badtravelflags = ~areacache->travelflags;
+	//
+	clusterareanum = AAS_ClusterAreaNum(areacache->cluster, areacache->areanum);
+	if (clusterareanum >= numreachabilityareas) return;
+	//
+	Com_Memset(startareatraveltimes, 0, sizeof(startareatraveltimes));
+	//
+	curupdate = &aasworld.areaupdate[clusterareanum];
+	curupdate->areanum = areacache->areanum;
+	//VectorCopy(areacache->origin, curupdate->start);
+	curupdate->areatraveltimes = startareatraveltimes;
+	curupdate->tmptraveltime = areacache->starttraveltime;
+	//
+	areacache->traveltimes[clusterareanum] = areacache->starttraveltime;
+	//put the area to start with in the current read list
+	curupdate->next = NULL;
+	curupdate->prev = NULL;
+	updateliststart = curupdate;
+	updatelistend = curupdate;
+	//while there are updates in the current list
+	while (updateliststart)
+	{
+		curupdate = updateliststart;
+		//
+		if (curupdate->next) curupdate->next->prev = NULL;
+		else updatelistend = NULL;
+		updateliststart = curupdate->next;
+		//
+		curupdate->inlist = qfalse;
+		//check all reversed reachability links
+		revreach = &aasworld.reversedreachability[curupdate->areanum];
+		//
+		for (i = 0, revlink = revreach->first; revlink; revlink = revlink->next, i++)
+		{
+			linknum = revlink->linknum;
+			reach = &aasworld.reachability[linknum];
+			//if there is used an undesired travel type
+			if (AAS_TravelFlagForType_inline(reach->traveltype) & badtravelflags) continue;
+			//if not allowed to enter the next area
+			if (aasworld.areasettings[reach->areanum].areaflags & AREA_DISABLED) continue;
+			//if the next area has a not allowed travel flag
+			if (AAS_AreaContentsTravelFlags_inline(reach->areanum) & badtravelflags) continue;
+			//number of the area the reversed reachability leads to
+			nextareanum = revlink->areanum;
+			//get the cluster number of the area
+			cluster = aasworld.areasettings[nextareanum].cluster;
+			//don't leave the cluster
+			if (cluster > 0 && cluster != areacache->cluster) continue;
+			//get the number of the area in the cluster
+			clusterareanum = AAS_ClusterAreaNum(areacache->cluster, nextareanum);
+			if (clusterareanum >= numreachabilityareas) continue;
+			//time already travelled plus the traveltime through
+			//the current area plus the travel time from the reachability
+			t = curupdate->tmptraveltime +
+						//AAS_AreaTravelTime(curupdate->areanum, curupdate->start, reach->end) +
+						curupdate->areatraveltimes[i] +
+							reach->traveltime;
+			//
+			if (!areacache->traveltimes[clusterareanum] ||
+					areacache->traveltimes[clusterareanum] > t)
+			{
+				areacache->traveltimes[clusterareanum] = t;
+				areacache->reachabilities[clusterareanum] = linknum - aasworld.areasettings[nextareanum].firstreachablearea;
+				nextupdate = &aasworld.areaupdate[clusterareanum];
+				nextupdate->areanum = nextareanum;
+				nextupdate->tmptraveltime = t;
+				//VectorCopy(reach->start, nextupdate->start);
+				nextupdate->areatraveltimes = aasworld.areatraveltimes[nextareanum][linknum -
+													aasworld.areasettings[nextareanum].firstreachablearea];
+				if (!nextupdate->inlist)
+				{
+					// we add the update to the end of the list
+					// we could also use a B+ tree to have a real sorted list
+					// on travel time which makes for faster routing updates
+					nextupdate->next = NULL;
+					nextupdate->prev = updatelistend;
+					if (updatelistend) updatelistend->next = nextupdate;
+					else updateliststart = nextupdate;
+					updatelistend = nextupdate;
+					nextupdate->inlist = qtrue;
+				} //end if
+			} //end if
+		} //end for
+	} //end while
+} //end of the function AAS_UpdateAreaRoutingCache
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+aas_routingcache_t *AAS_GetAreaRoutingCache(int clusternum, int areanum, int travelflags)
+{
+	int clusterareanum;
+	aas_routingcache_t *cache, *clustercache;
+
+	//number of the area in the cluster
+	clusterareanum = AAS_ClusterAreaNum(clusternum, areanum);
+	//pointer to the cache for the area in the cluster
+	clustercache = aasworld.clusterareacache[clusternum][clusterareanum];
+	//find the cache without undesired travel flags
+	for (cache = clustercache; cache; cache = cache->next)
+	{
+		//if there aren't used any undesired travel types for the cache
+		if (cache->travelflags == travelflags) break;
+	} //end for
+	//if there was no cache
+	if (!cache)
+	{
+		cache = AAS_AllocRoutingCache(aasworld.clusters[clusternum].numreachabilityareas);
+		cache->cluster = clusternum;
+		cache->areanum = areanum;
+		VectorCopy(aasworld.areas[areanum].center, cache->origin);
+		cache->starttraveltime = 1;
+		cache->travelflags = travelflags;
+		cache->prev = NULL;
+		cache->next = clustercache;
+		if (clustercache) clustercache->prev = cache;
+		aasworld.clusterareacache[clusternum][clusterareanum] = cache;
+		AAS_UpdateAreaRoutingCache(cache);
+	} //end if
+	else
+	{
+		AAS_UnlinkCache(cache);
+	} //end else
+	//the cache has been accessed
+	cache->time = AAS_RoutingTime();
+	cache->type = CACHETYPE_AREA;
+	AAS_LinkCache(cache);
+	return cache;
+} //end of the function AAS_GetAreaRoutingCache
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+void AAS_UpdatePortalRoutingCache(aas_routingcache_t *portalcache)
+{
+	int i, portalnum, clusterareanum, clusternum;
+	unsigned short int t;
+	aas_portal_t *portal;
+	aas_cluster_t *cluster;
+	aas_routingcache_t *cache;
+	aas_routingupdate_t *updateliststart, *updatelistend, *curupdate, *nextupdate;
+
+#ifdef ROUTING_DEBUG
+	numportalcacheupdates++;
+#endif //ROUTING_DEBUG
+	//clear the routing update fields
+//	Com_Memset(aasworld.portalupdate, 0, (aasworld.numportals+1) * sizeof(aas_routingupdate_t));
+	//
+	curupdate = &aasworld.portalupdate[aasworld.numportals];
+	curupdate->cluster = portalcache->cluster;
+	curupdate->areanum = portalcache->areanum;
+	curupdate->tmptraveltime = portalcache->starttraveltime;
+	//if the start area is a cluster portal, store the travel time for that portal
+	clusternum = aasworld.areasettings[portalcache->areanum].cluster;
+	if (clusternum < 0)
+	{
+		portalcache->traveltimes[-clusternum] = portalcache->starttraveltime;
+	} //end if
+	//put the area to start with in the current read list
+	curupdate->next = NULL;
+	curupdate->prev = NULL;
+	updateliststart = curupdate;
+	updatelistend = curupdate;
+	//while there are updates in the current list
+	while (updateliststart)
+	{
+		curupdate = updateliststart;
+		//remove the current update from the list
+		if (curupdate->next) curupdate->next->prev = NULL;
+		else updatelistend = NULL;
+		updateliststart = curupdate->next;
+		//current update is removed from the list
+		curupdate->inlist = qfalse;
+		//
+		cluster = &aasworld.clusters[curupdate->cluster];
+		//
+		cache = AAS_GetAreaRoutingCache(curupdate->cluster,
+								curupdate->areanum, portalcache->travelflags);
+		//take all portals of the cluster
+		for (i = 0; i < cluster->numportals; i++)
+		{
+			portalnum = aasworld.portalindex[cluster->firstportal + i];
+			portal = &aasworld.portals[portalnum];
+			//if this is the portal of the current update continue
+			if (portal->areanum == curupdate->areanum) continue;
+			//
+			clusterareanum = AAS_ClusterAreaNum(curupdate->cluster, portal->areanum);
+			if (clusterareanum >= cluster->numreachabilityareas) continue;
+			//
+			t = cache->traveltimes[clusterareanum];
+			if (!t) continue;
+			t += curupdate->tmptraveltime;
+			//
+			if (!portalcache->traveltimes[portalnum] ||
+					portalcache->traveltimes[portalnum] > t)
+			{
+				portalcache->traveltimes[portalnum] = t;
+				nextupdate = &aasworld.portalupdate[portalnum];
+				if (portal->frontcluster == curupdate->cluster)
+				{
+					nextupdate->cluster = portal->backcluster;
+				} //end if
+				else
+				{
+					nextupdate->cluster = portal->frontcluster;
+				} //end else
+				nextupdate->areanum = portal->areanum;
+				//add travel time through the actual portal area for the next update
+				nextupdate->tmptraveltime = t + aasworld.portalmaxtraveltimes[portalnum];
+				if (!nextupdate->inlist)
+				{
+					// we add the update to the end of the list
+					// we could also use a B+ tree to have a real sorted list
+					// on travel time which makes for faster routing updates
+					nextupdate->next = NULL;
+					nextupdate->prev = updatelistend;
+					if (updatelistend) updatelistend->next = nextupdate;
+					else updateliststart = nextupdate;
+					updatelistend = nextupdate;
+					nextupdate->inlist = qtrue;
+				} //end if
+			} //end if
+		} //end for
+	} //end while
+} //end of the function AAS_UpdatePortalRoutingCache
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+aas_routingcache_t *AAS_GetPortalRoutingCache(int clusternum, int areanum, int travelflags)
+{
+	aas_routingcache_t *cache;
+
+	//find the cached portal routing if existing
+	for (cache = aasworld.portalcache[areanum]; cache; cache = cache->next)
+	{
+		if (cache->travelflags == travelflags) break;
+	} //end for
+	//if the portal routing isn't cached
+	if (!cache)
+	{
+		cache = AAS_AllocRoutingCache(aasworld.numportals);
+		cache->cluster = clusternum;
+		cache->areanum = areanum;
+		VectorCopy(aasworld.areas[areanum].center, cache->origin);
+		cache->starttraveltime = 1;
+		cache->travelflags = travelflags;
+		//add the cache to the cache list
+		cache->prev = NULL;
+		cache->next = aasworld.portalcache[areanum];
+		if (aasworld.portalcache[areanum]) aasworld.portalcache[areanum]->prev = cache;
+		aasworld.portalcache[areanum] = cache;
+		//update the cache
+		AAS_UpdatePortalRoutingCache(cache);
+	} //end if
+	else
+	{
+		AAS_UnlinkCache(cache);
+	} //end else
+	//the cache has been accessed
+	cache->time = AAS_RoutingTime();
+	cache->type = CACHETYPE_PORTAL;
+	AAS_LinkCache(cache);
+	return cache;
+} //end of the function AAS_GetPortalRoutingCache
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+int AAS_AreaRouteToGoalArea(int areanum, vec3_t origin, int goalareanum, int travelflags, int *traveltime, int *reachnum)
+{
+	int clusternum, goalclusternum, portalnum, i, clusterareanum, bestreachnum;
+	unsigned short int t, besttime;
+	aas_portal_t *portal;
+	aas_cluster_t *cluster;
+	aas_routingcache_t *areacache, *portalcache;
+	aas_reachability_t *reach;
+
+	if (!aasworld.initialized) return qfalse;
+
+	if (areanum == goalareanum)
+	{
+		*traveltime = 1;
+		*reachnum = 0;
+		return qtrue;
+	}
+	//
+	if (areanum <= 0 || areanum >= aasworld.numareas)
+	{
+		if (bot_developer)
+		{
+			botimport.Print(PRT_ERROR, "AAS_AreaTravelTimeToGoalArea: areanum %d out of range\n", areanum);
+		} //end if
+		return qfalse;
+	} //end if
+	if (goalareanum <= 0 || goalareanum >= aasworld.numareas)
+	{
+		if (bot_developer)
+		{
+			botimport.Print(PRT_ERROR, "AAS_AreaTravelTimeToGoalArea: goalareanum %d out of range\n", goalareanum);
+		} //end if
+		return qfalse;
+	} //end if
+	// make sure the routing cache doesn't grow to large
+	while(AvailableMemory() < 1 * 1024 * 1024) {
+		if (!AAS_FreeOldestCache()) break;
+	}
+	//
+	if (AAS_AreaDoNotEnter(areanum) || AAS_AreaDoNotEnter(goalareanum))
+	{
+		travelflags |= TFL_DONOTENTER;
+	} //end if
+	//NOTE: the number of routing updates is limited per frame
+	/*
+	if (aasworld.frameroutingupdates > MAX_FRAMEROUTINGUPDATES)
+	{
+#ifdef DEBUG
+		//Log_Write("WARNING: AAS_AreaTravelTimeToGoalArea: frame routing updates overflowed");
+#endif
+		return 0;
+	} //end if
+	*/
+	//
+	clusternum = aasworld.areasettings[areanum].cluster;
+	goalclusternum = aasworld.areasettings[goalareanum].cluster;
+	//check if the area is a portal of the goal area cluster
+	if (clusternum < 0 && goalclusternum > 0)
+	{
+		portal = &aasworld.portals[-clusternum];
+		if (portal->frontcluster == goalclusternum ||
+				portal->backcluster == goalclusternum)
+		{
+			clusternum = goalclusternum;
+		} //end if
+	} //end if
+	//check if the goalarea is a portal of the area cluster
+	else if (clusternum > 0 && goalclusternum < 0)
+	{
+		portal = &aasworld.portals[-goalclusternum];
+		if (portal->frontcluster == clusternum ||
+				portal->backcluster == clusternum)
+		{
+			goalclusternum = clusternum;
+		} //end if
+	} //end if
+	//if both areas are in the same cluster
+	//NOTE: there might be a shorter route via another cluster!!! but we don't care
+	if (clusternum > 0 && goalclusternum > 0 && clusternum == goalclusternum)
+	{
+		//
+		areacache = AAS_GetAreaRoutingCache(clusternum, goalareanum, travelflags);
+		//the number of the area in the cluster
+		clusterareanum = AAS_ClusterAreaNum(clusternum, areanum);
+		//the cluster the area is in
+		cluster = &aasworld.clusters[clusternum];
+		//if the area is NOT a reachability area
+		if (clusterareanum >= cluster->numreachabilityareas) return 0;
+		//if it is possible to travel to the goal area through this cluster
+		if (areacache->traveltimes[clusterareanum] != 0)
+		{
+			*reachnum = aasworld.areasettings[areanum].firstreachablearea +
+							areacache->reachabilities[clusterareanum];
+			if (!origin) {
+				*traveltime = areacache->traveltimes[clusterareanum];
+				return qtrue;
+			}
+			reach = &aasworld.reachability[*reachnum];
+			*traveltime = areacache->traveltimes[clusterareanum] +
+							AAS_AreaTravelTime(areanum, origin, reach->start);
+			//
+			return qtrue;
+		} //end if
+	} //end if
+	//
+	clusternum = aasworld.areasettings[areanum].cluster;
+	goalclusternum = aasworld.areasettings[goalareanum].cluster;
+	//if the goal area is a portal
+	if (goalclusternum < 0)
+	{
+		//just assume the goal area is part of the front cluster
+		portal = &aasworld.portals[-goalclusternum];
+		goalclusternum = portal->frontcluster;
+	} //end if
+	//get the portal routing cache
+	portalcache = AAS_GetPortalRoutingCache(goalclusternum, goalareanum, travelflags);
+	//if the area is a cluster portal, read directly from the portal cache
+	if (clusternum < 0)
+	{
+		*traveltime = portalcache->traveltimes[-clusternum];
+		*reachnum = aasworld.areasettings[areanum].firstreachablearea +
+						portalcache->reachabilities[-clusternum];
+		return qtrue;
+	} //end if
+	//
+	besttime = 0;
+	bestreachnum = -1;
+	//the cluster the area is in
+	cluster = &aasworld.clusters[clusternum];
+	//find the portal of the area cluster leading towards the goal area
+	for (i = 0; i < cluster->numportals; i++)
+	{
+		portalnum = aasworld.portalindex[cluster->firstportal + i];
+		//if the goal area isn't reachable from the portal
+		if (!portalcache->traveltimes[portalnum]) continue;
+		//
+		portal = &aasworld.portals[portalnum];
+		//get the cache of the portal area
+		areacache = AAS_GetAreaRoutingCache(clusternum, portal->areanum, travelflags);
+		//current area inside the current cluster
+		clusterareanum = AAS_ClusterAreaNum(clusternum, areanum);
+		//if the area is NOT a reachability area
+		if (clusterareanum >= cluster->numreachabilityareas) continue;
+		//if the portal is NOT reachable from this area
+		if (!areacache->traveltimes[clusterareanum]) continue;
+		//total travel time is the travel time the portal area is from
+		//the goal area plus the travel time towards the portal area
+		t = portalcache->traveltimes[portalnum] + areacache->traveltimes[clusterareanum];
+		//FIXME: add the exact travel time through the actual portal area
+		//NOTE: for now we just add the largest travel time through the portal area
+		//		because we can't directly calculate the exact travel time
+		//		to be more specific we don't know which reachability was used to travel
+		//		into the portal area
+		t += aasworld.portalmaxtraveltimes[portalnum];
+		//
+		if (origin)
+		{
+			*reachnum = aasworld.areasettings[areanum].firstreachablearea +
+							areacache->reachabilities[clusterareanum];
+			reach = aasworld.reachability + *reachnum;
+			t += AAS_AreaTravelTime(areanum, origin, reach->start);
+		} //end if
+		//if the time is better than the one already found
+		if (!besttime || t < besttime)
+		{
+			bestreachnum = *reachnum;
+			besttime = t;
+		} //end if
+	} //end for
+	if (bestreachnum < 0) {
+		return qfalse;
+	}
+	*reachnum = bestreachnum;
+	*traveltime = besttime;
+	return qtrue;
+} //end of the function AAS_AreaRouteToGoalArea
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+int AAS_AreaTravelTimeToGoalArea(int areanum, vec3_t origin, int goalareanum, int travelflags)
+{
+	int traveltime, reachnum;
+
+	if (AAS_AreaRouteToGoalArea(areanum, origin, goalareanum, travelflags, &traveltime, &reachnum))
+	{
+		return traveltime;
+	}
+	return 0;
+} //end of the function AAS_AreaTravelTimeToGoalArea
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+int AAS_AreaReachabilityToGoalArea(int areanum, vec3_t origin, int goalareanum, int travelflags)
+{
+	int traveltime, reachnum;
+
+	if (AAS_AreaRouteToGoalArea(areanum, origin, goalareanum, travelflags, &traveltime, &reachnum))
+	{
+		return reachnum;
+	}
+	return 0;
+} //end of the function AAS_AreaReachabilityToGoalArea
+//===========================================================================
+// predict the route and stop on one of the stop events
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+int AAS_PredictRoute(struct aas_predictroute_s *route, int areanum, vec3_t origin,
+							int goalareanum, int travelflags, int maxareas, int maxtime,
+							int stopevent, int stopcontents, int stoptfl, int stopareanum)
+{
+	int curareanum, reachnum, i, j, testareanum;
+	vec3_t curorigin;
+	aas_reachability_t *reach;
+	aas_reachabilityareas_t *reachareas;
+
+	//init output
+	route->stopevent = RSE_NONE;
+	route->endarea = goalareanum;
+	route->endcontents = 0;
+	route->endtravelflags = 0;
+	VectorCopy(origin, route->endpos);
+	route->time = 0;
+
+	curareanum = areanum;
+	VectorCopy(origin, curorigin);
+
+	for (i = 0; curareanum != goalareanum && (!maxareas || i < maxareas) && i < aasworld.numareas; i++)
+	{
+		reachnum = AAS_AreaReachabilityToGoalArea(curareanum, curorigin, goalareanum, travelflags);
+		if (!reachnum)
+		{
+			route->stopevent = RSE_NOROUTE;
+			return qfalse;
+		} //end if
+		reach = &aasworld.reachability[reachnum];
+		//
+		if (stopevent & RSE_USETRAVELTYPE)
+		{
+			if (AAS_TravelFlagForType_inline(reach->traveltype) & stoptfl)
+			{
+				route->stopevent = RSE_USETRAVELTYPE;
+				route->endarea = curareanum;
+				route->endcontents = aasworld.areasettings[curareanum].contents;
+				route->endtravelflags = AAS_TravelFlagForType_inline(reach->traveltype);
+				VectorCopy(reach->start, route->endpos);
+				return qtrue;
+			} //end if
+			if (AAS_AreaContentsTravelFlags_inline(reach->areanum) & stoptfl)
+			{
+				route->stopevent = RSE_USETRAVELTYPE;
+				route->endarea = reach->areanum;
+				route->endcontents = aasworld.areasettings[reach->areanum].contents;
+				route->endtravelflags = AAS_AreaContentsTravelFlags_inline(reach->areanum);
+				VectorCopy(reach->end, route->endpos);
+				route->time += AAS_AreaTravelTime(areanum, origin, reach->start);
+				route->time += reach->traveltime;
+				return qtrue;
+			} //end if
+		} //end if
+		reachareas = &aasworld.reachabilityareas[reachnum];
+		for (j = 0; j < reachareas->numareas + 1; j++)
+		{
+			if (j >= reachareas->numareas)
+				testareanum = reach->areanum;
+			else
+				testareanum = aasworld.reachabilityareaindex[reachareas->firstarea + j];
+			if (stopevent & RSE_ENTERCONTENTS)
+			{
+				if (aasworld.areasettings[testareanum].contents & stopcontents)
+				{
+					route->stopevent = RSE_ENTERCONTENTS;
+					route->endarea = testareanum;
+					route->endcontents = aasworld.areasettings[testareanum].contents;
+					VectorCopy(reach->end, route->endpos);
+					route->time += AAS_AreaTravelTime(areanum, origin, reach->start);
+					route->time += reach->traveltime;
+					return qtrue;
+				} //end if
+			} //end if
+			if (stopevent & RSE_ENTERAREA)
+			{
+				if (testareanum == stopareanum)
+				{
+					route->stopevent = RSE_ENTERAREA;
+					route->endarea = testareanum;
+					route->endcontents = aasworld.areasettings[testareanum].contents;
+					VectorCopy(reach->start, route->endpos);
+					return qtrue;
+				} //end if
+			} //end if
+		} //end for
+
+		route->time += AAS_AreaTravelTime(areanum, origin, reach->start);
+		route->time += reach->traveltime;
+		route->endarea = reach->areanum;
+		route->endcontents = aasworld.areasettings[reach->areanum].contents;
+		route->endtravelflags = AAS_TravelFlagForType_inline(reach->traveltype);
+		VectorCopy(reach->end, route->endpos);
+		//
+		curareanum = reach->areanum;
+		VectorCopy(reach->end, curorigin);
+		//
+		if (maxtime && route->time > maxtime)
+			break;
+	} //end while
+	if (curareanum != goalareanum)
+		return qfalse;
+	return qtrue;
+} //end of the function AAS_PredictRoute
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+int AAS_BridgeWalkable(int areanum)
+{
+	return qfalse;
+} //end of the function AAS_BridgeWalkable
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+void AAS_ReachabilityFromNum(int num, struct aas_reachability_s *reach)
+{
+	if (!aasworld.initialized)
+	{
+		Com_Memset(reach, 0, sizeof(aas_reachability_t));
+		return;
+	} //end if
+	if (num < 0 || num >= aasworld.reachabilitysize)
+	{
+		Com_Memset(reach, 0, sizeof(aas_reachability_t));
+		return;
+	} //end if
+	Com_Memcpy(reach, &aasworld.reachability[num], sizeof(aas_reachability_t));;
+} //end of the function AAS_ReachabilityFromNum
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+int AAS_NextAreaReachability(int areanum, int reachnum)
+{
+	aas_areasettings_t *settings;
+
+	if (!aasworld.initialized) return 0;
+
+	if (areanum <= 0 || areanum >= aasworld.numareas)
+	{
+		botimport.Print(PRT_ERROR, "AAS_NextAreaReachability: areanum %d out of range\n", areanum);
+		return 0;
+	} //end if
+
+	settings = &aasworld.areasettings[areanum];
+	if (!reachnum)
+	{
+		return settings->firstreachablearea;
+	} //end if
+	if (reachnum < settings->firstreachablearea)
+	{
+		botimport.Print(PRT_FATAL, "AAS_NextAreaReachability: reachnum < settings->firstreachableara");
+		return 0;
+	} //end if
+	reachnum++;
+	if (reachnum >= settings->firstreachablearea + settings->numreachableareas)
+	{
+		return 0;
+	} //end if
+	return reachnum;
+} //end of the function AAS_NextAreaReachability
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+int AAS_NextModelReachability(int num, int modelnum)
+{
+	int i;
+
+	if (num <= 0) num = 1;
+	else if (num >= aasworld.reachabilitysize) return 0;
+	else num++;
+	//
+	for (i = num; i < aasworld.reachabilitysize; i++)
+	{
+		if ((aasworld.reachability[i].traveltype & TRAVELTYPE_MASK) == TRAVEL_ELEVATOR)
+		{
+			if (aasworld.reachability[i].facenum == modelnum) return i;
+		} //end if
+		else if ((aasworld.reachability[i].traveltype & TRAVELTYPE_MASK) == TRAVEL_FUNCBOB)
+		{
+			if ((aasworld.reachability[i].facenum & 0x0000FFFF) == modelnum) return i;
+		} //end if
+	} //end for
+	return 0;
+} //end of the function AAS_NextModelReachability
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+int AAS_RandomGoalArea(int areanum, int travelflags, int *goalareanum, vec3_t goalorigin)
+{
+	int i, n, t;
+	vec3_t start, end;
+	aas_trace_t trace;
+
+	//if the area has no reachabilities
+	if (!AAS_AreaReachability(areanum)) return qfalse;
+	//
+	n = aasworld.numareas * random();
+	for (i = 0; i < aasworld.numareas; i++)
+	{
+		if (n <= 0) n = 1;
+		if (n >= aasworld.numareas) n = 1;
+		if (AAS_AreaReachability(n))
+		{
+			t = AAS_AreaTravelTimeToGoalArea(areanum, aasworld.areas[areanum].center, n, travelflags);
+			//if the goal is reachable
+			if (t > 0)
+			{
+				if (AAS_AreaSwim(n))
+				{
+					*goalareanum = n;
+					VectorCopy(aasworld.areas[n].center, goalorigin);
+					//botimport.Print(PRT_MESSAGE, "found random goal area %d\n", *goalareanum);
+					return qtrue;
+				} //end if
+				VectorCopy(aasworld.areas[n].center, start);
+				if (!AAS_PointAreaNum(start))
+					Log_Write("area %d center %f %f %f in solid?", n, start[0], start[1], start[2]);
+				VectorCopy(start, end);
+				end[2] -= 300;
+				trace = AAS_TraceClientBBox(start, end, PRESENCE_CROUCH, -1);
+				if (!trace.startsolid && trace.fraction < 1 && AAS_PointAreaNum(trace.endpos) == n)
+				{
+					if (AAS_AreaGroundFaceArea(n) > 300)
+					{
+						*goalareanum = n;
+						VectorCopy(trace.endpos, goalorigin);
+						//botimport.Print(PRT_MESSAGE, "found random goal area %d\n", *goalareanum);
+						return qtrue;
+					} //end if
+				} //end if
+			} //end if
+		} //end if
+		n++;
+	} //end for
+	return qfalse;
+} //end of the function AAS_RandomGoalArea
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+int AAS_AreaVisible(int srcarea, int destarea)
+{
+	return qfalse;
+} //end of the function AAS_AreaVisible
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+float DistancePointToLine(vec3_t v1, vec3_t v2, vec3_t point)
+{
+	vec3_t vec, p2;
+
+	AAS_ProjectPointOntoVector(point, v1, v2, p2);
+	VectorSubtract(point, p2, vec);
+	return VectorLength(vec);
+} //end of the function DistancePointToLine
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+int AAS_NearestHideArea(int srcnum, vec3_t origin, int areanum, int enemynum, vec3_t enemyorigin, int enemyareanum, int travelflags)
+{
+	int i, j, nextareanum, badtravelflags, numreach, bestarea;
+	unsigned short int t, besttraveltime;
+	static unsigned short int *hidetraveltimes;
+	aas_routingupdate_t *updateliststart, *updatelistend, *curupdate, *nextupdate;
+	aas_reachability_t *reach;
+	float dist1, dist2;
+	vec3_t v1, v2, p;
+	qboolean startVisible;
+
+	//
+	if (!hidetraveltimes)
+	{
+		hidetraveltimes = (unsigned short int *) GetClearedMemory(aasworld.numareas * sizeof(unsigned short int));
+	} //end if
+	else
+	{
+		Com_Memset(hidetraveltimes, 0, aasworld.numareas * sizeof(unsigned short int));
+	} //end else
+	besttraveltime = 0;
+	bestarea = 0;
+	//assume visible
+	startVisible = qtrue;
+	//
+	badtravelflags = ~travelflags;
+	//
+	curupdate = &aasworld.areaupdate[areanum];
+	curupdate->areanum = areanum;
+	VectorCopy(origin, curupdate->start);
+	curupdate->areatraveltimes = aasworld.areatraveltimes[areanum][0];
+	curupdate->tmptraveltime = 0;
+	//put the area to start with in the current read list
+	curupdate->next = NULL;
+	curupdate->prev = NULL;
+	updateliststart = curupdate;
+	updatelistend = curupdate;
+	//while there are updates in the list
+	while (updateliststart)
+	{
+		curupdate = updateliststart;
+		//
+		if (curupdate->next) curupdate->next->prev = NULL;
+		else updatelistend = NULL;
+		updateliststart = curupdate->next;
+		//
+		curupdate->inlist = qfalse;
+		//check all reversed reachability links
+		numreach = aasworld.areasettings[curupdate->areanum].numreachableareas;
+		reach = &aasworld.reachability[aasworld.areasettings[curupdate->areanum].firstreachablearea];
+		//
+		for (i = 0; i < numreach; i++, reach++)
+		{
+			//if an undesired travel type is used
+			if (AAS_TravelFlagForType_inline(reach->traveltype) & badtravelflags) continue;
+			//
+			if (AAS_AreaContentsTravelFlags_inline(reach->areanum) & badtravelflags) continue;
+			//number of the area the reachability leads to
+			nextareanum = reach->areanum;
+			// if this moves us into the enemies area, skip it
+			if (nextareanum == enemyareanum) continue;
+			//time already travelled plus the traveltime through
+			//the current area plus the travel time from the reachability
+			t = curupdate->tmptraveltime +
+						AAS_AreaTravelTime(curupdate->areanum, curupdate->start, reach->start) +
+							reach->traveltime;
+
+			//avoid going near the enemy
+			AAS_ProjectPointOntoVector(enemyorigin, curupdate->start, reach->end, p);
+			for (j = 0; j < 3; j++)
+				if ((p[j] > curupdate->start[j] && p[j] > reach->end[j]) ||
+					(p[j] < curupdate->start[j] && p[j] < reach->end[j]))
+					break;
+			if (j < 3)
+			{
+				VectorSubtract(enemyorigin, reach->end, v2);
+			} //end if
+			else
+			{
+				VectorSubtract(enemyorigin, p, v2);
+			} //end else
+			dist2 = VectorLength(v2);
+			//never go through the enemy
+			if (dist2 < 40) continue;
+			//
+			VectorSubtract(enemyorigin, curupdate->start, v1);
+			dist1 = VectorLength(v1);
+			//
+			if (dist2 < dist1)
+			{
+				t += (dist1 - dist2) * 10;
+			}
+			// if we weren't visible when starting, make sure we don't move into their view
+			if (!startVisible && AAS_AreaVisible(enemyareanum, nextareanum)) {
+				continue;
+			}
+			//
+			if (besttraveltime && t >= besttraveltime) continue;
+			//
+			if (!hidetraveltimes[nextareanum] ||
+					hidetraveltimes[nextareanum] > t)
+			{
+				//if the nextarea is not visible from the enemy area
+				if (!AAS_AreaVisible(enemyareanum, nextareanum))
+				{
+					besttraveltime = t;
+					bestarea = nextareanum;
+				} //end if
+				hidetraveltimes[nextareanum] = t;
+				nextupdate = &aasworld.areaupdate[nextareanum];
+				nextupdate->areanum = nextareanum;
+				nextupdate->tmptraveltime = t;
+				//remember where we entered this area
+				VectorCopy(reach->end, nextupdate->start);
+				//if this update is not in the list yet
+				if (!nextupdate->inlist)
+				{
+					//add the new update to the end of the list
+					nextupdate->next = NULL;
+					nextupdate->prev = updatelistend;
+					if (updatelistend) updatelistend->next = nextupdate;
+					else updateliststart = nextupdate;
+					updatelistend = nextupdate;
+					nextupdate->inlist = qtrue;
+				} //end if
+			} //end if
+		} //end for
+	} //end while
+	return bestarea;
+} //end of the function AAS_NearestHideArea
diff --git a/codemp/botlib/be_aas_route.h b/codemp/botlib/be_aas_route.h
new file mode 100644
index 0000000..bb5143d
--- /dev/null
+++ b/codemp/botlib/be_aas_route.h
@@ -0,0 +1,50 @@
+
+/*****************************************************************************
+ * name:		be_aas_route.h
+ *
+ * desc:		AAS
+ *
+ * $Archive: /source/code/botlib/be_aas_route.h $
+ * $Author: Mrelusive $ 
+ * $Revision: 2 $
+ * $Modtime: 10/05/99 3:32p $
+ * $Date: 10/05/99 3:42p $
+ *
+ *****************************************************************************/
+
+#ifdef AASINTERN
+//initialize the AAS routing
+void AAS_InitRouting(void);
+//free the AAS routing caches
+void AAS_FreeRoutingCaches(void);
+//returns the travel time from start to end in the given area
+unsigned short int AAS_AreaTravelTime(int areanum, vec3_t start, vec3_t end);
+//
+void AAS_CreateAllRoutingCache(void);
+void AAS_WriteRouteCache(void);
+//
+void AAS_RoutingInfo(void);
+#endif //AASINTERN
+
+//returns the travel flag for the given travel type
+int AAS_TravelFlagForType(int traveltype);
+//return the travel flag(s) for traveling through this area
+int AAS_AreaContentsTravelFlags(int areanum);
+//returns the index of the next reachability for the given area
+int AAS_NextAreaReachability(int areanum, int reachnum);
+//returns the reachability with the given index
+void AAS_ReachabilityFromNum(int num, struct aas_reachability_s *reach);
+//returns a random goal area and goal origin
+int AAS_RandomGoalArea(int areanum, int travelflags, int *goalareanum, vec3_t goalorigin);
+//enable or disable an area for routing
+int AAS_EnableRoutingArea(int areanum, int enable);
+//returns the travel time within the given area from start to end
+unsigned short int AAS_AreaTravelTime(int areanum, vec3_t start, vec3_t end);
+//returns the travel time from the area to the goal area using the given travel flags
+int AAS_AreaTravelTimeToGoalArea(int areanum, vec3_t origin, int goalareanum, int travelflags);
+//predict a route up to a stop event
+int AAS_PredictRoute(struct aas_predictroute_s *route, int areanum, vec3_t origin,
+							int goalareanum, int travelflags, int maxareas, int maxtime,
+							int stopevent, int stopcontents, int stoptfl, int stopareanum);
+
+
diff --git a/codemp/botlib/be_aas_routealt.cpp b/codemp/botlib/be_aas_routealt.cpp
new file mode 100644
index 0000000..1c92aae
--- /dev/null
+++ b/codemp/botlib/be_aas_routealt.cpp
@@ -0,0 +1,223 @@
+
+/*****************************************************************************
+ * name:		be_aas_routealt.c
+ *
+ * desc:		AAS
+ *
+ * $Archive: /MissionPack/code/botlib/be_aas_routealt.c $
+ * $Author: Zaphod $ 
+ * $Revision: 5 $
+ * $Modtime: 11/22/00 8:47a $
+ * $Date: 11/22/00 8:55a $
+ *
+ *****************************************************************************/
+
+#include "../game/q_shared.h"
+#include "l_utils.h"
+#include "l_memory.h"
+#include "l_log.h"
+#include "l_script.h"
+#include "l_precomp.h"
+#include "l_struct.h"
+#include "aasfile.h"
+#include "../game/botlib.h"
+#include "../game/be_aas.h"
+#include "be_aas_funcs.h"
+#include "be_interface.h"
+#include "be_aas_def.h"
+
+#define ENABLE_ALTROUTING
+//#define ALTROUTE_DEBUG
+
+typedef struct midrangearea_s
+{
+	int valid;
+	unsigned short starttime;
+	unsigned short goaltime;
+} midrangearea_t;
+
+midrangearea_t *midrangeareas;
+int *clusterareas;
+int numclusterareas;
+
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void AAS_AltRoutingFloodCluster_r(int areanum)
+{
+	int i, otherareanum;
+	aas_area_t *area;
+	aas_face_t *face;
+
+	//add the current area to the areas of the current cluster
+	clusterareas[numclusterareas] = areanum;
+	numclusterareas++;
+	//remove the area from the mid range areas
+	midrangeareas[areanum].valid = qfalse;
+	//flood to other areas through the faces of this area
+	area = &aasworld.areas[areanum];
+	for (i = 0; i < area->numfaces; i++)
+	{
+		face = &aasworld.faces[abs(aasworld.faceindex[area->firstface + i])];
+		//get the area at the other side of the face
+		if (face->frontarea == areanum) otherareanum = face->backarea;
+		else otherareanum = face->frontarea;
+		//if there is an area at the other side of this face
+		if (!otherareanum) continue;
+		//if the other area is not a midrange area
+		if (!midrangeareas[otherareanum].valid) continue;
+		//
+		AAS_AltRoutingFloodCluster_r(otherareanum);
+	} //end for
+} //end of the function AAS_AltRoutingFloodCluster_r
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int AAS_AlternativeRouteGoals(vec3_t start, int startareanum, vec3_t goal, int goalareanum, int travelflags,
+										 aas_altroutegoal_t *altroutegoals, int maxaltroutegoals,
+										 int type)
+{
+#ifndef ENABLE_ALTROUTING
+	return 0;
+#else
+	int i, j, bestareanum;
+	int numaltroutegoals, nummidrangeareas;
+	int starttime, goaltime, goaltraveltime;
+	float dist, bestdist;
+	vec3_t mid, dir;
+#ifdef ALTROUTE_DEBUG
+	int startmillisecs;
+
+	startmillisecs = Sys_MilliSeconds();
+#endif
+
+	if (!startareanum || !goalareanum)
+		return 0;
+	//travel time towards the goal area
+	goaltraveltime = AAS_AreaTravelTimeToGoalArea(startareanum, start, goalareanum, travelflags);
+	//clear the midrange areas
+	Com_Memset(midrangeareas, 0, aasworld.numareas * sizeof(midrangearea_t));
+	numaltroutegoals = 0;
+	//
+	nummidrangeareas = 0;
+	//
+	for (i = 1; i < aasworld.numareas; i++)
+	{
+		//
+		if (!(type & ALTROUTEGOAL_ALL))
+		{
+			if (!(type & ALTROUTEGOAL_CLUSTERPORTALS && (aasworld.areasettings[i].contents & AREACONTENTS_CLUSTERPORTAL)))
+			{
+				if (!(type & ALTROUTEGOAL_VIEWPORTALS && (aasworld.areasettings[i].contents & AREACONTENTS_VIEWPORTAL)))
+				{
+					continue;
+				} //end if
+			} //end if
+		} //end if
+		//if the area has no reachabilities
+		if (!AAS_AreaReachability(i)) continue;
+		//tavel time from the area to the start area
+		starttime = AAS_AreaTravelTimeToGoalArea(startareanum, start, i, travelflags);
+		if (!starttime) continue;
+		//if the travel time from the start to the area is greater than the shortest goal travel time
+		if (starttime > (float) 1.1 * goaltraveltime) continue;
+		//travel time from the area to the goal area
+		goaltime = AAS_AreaTravelTimeToGoalArea(i, NULL, goalareanum, travelflags);
+		if (!goaltime) continue;
+		//if the travel time from the area to the goal is greater than the shortest goal travel time
+		if (goaltime > (float) 0.8 * goaltraveltime) continue;
+		//this is a mid range area
+		midrangeareas[i].valid = qtrue;
+		midrangeareas[i].starttime = starttime;
+		midrangeareas[i].goaltime = goaltime;
+		Log_Write("%d midrange area %d", nummidrangeareas, i);
+		nummidrangeareas++;
+	} //end for
+	//
+	for (i = 1; i < aasworld.numareas; i++)
+	{
+		if (!midrangeareas[i].valid) continue;
+		//get the areas in one cluster
+		numclusterareas = 0;
+		AAS_AltRoutingFloodCluster_r(i);
+		//now we've got a cluster with areas through which an alternative route could go
+		//get the 'center' of the cluster
+		VectorClear(mid);
+		for (j = 0; j < numclusterareas; j++)
+		{
+			VectorAdd(mid, aasworld.areas[clusterareas[j]].center, mid);
+		} //end for
+		VectorScale(mid, 1.0 / numclusterareas, mid);
+		//get the area closest to the center of the cluster
+		bestdist = 999999;
+		bestareanum = 0;
+		for (j = 0; j < numclusterareas; j++)
+		{
+			VectorSubtract(mid, aasworld.areas[clusterareas[j]].center, dir);
+			dist = VectorLength(dir);
+			if (dist < bestdist)
+			{
+				bestdist = dist;
+				bestareanum = clusterareas[j];
+			} //end if
+		} //end for
+		//now we've got an area for an alternative route
+		//FIXME: add alternative goal origin
+		VectorCopy(aasworld.areas[bestareanum].center, altroutegoals[numaltroutegoals].origin);
+		altroutegoals[numaltroutegoals].areanum = bestareanum;
+		altroutegoals[numaltroutegoals].starttraveltime = midrangeareas[bestareanum].starttime;
+		altroutegoals[numaltroutegoals].goaltraveltime = midrangeareas[bestareanum].goaltime;
+		altroutegoals[numaltroutegoals].extratraveltime =
+					(midrangeareas[bestareanum].starttime + midrangeareas[bestareanum].goaltime) -
+								goaltraveltime;
+		numaltroutegoals++;
+		//
+#ifdef ALTROUTE_DEBUG
+		AAS_ShowAreaPolygons(bestareanum, 1, qtrue);
+#endif
+		//don't return more than the maximum alternative route goals
+		if (numaltroutegoals >= maxaltroutegoals) break;
+	} //end for
+#ifdef ALTROUTE_DEBUG
+	botimport.Print(PRT_MESSAGE, "alternative route goals in %d msec\n", Sys_MilliSeconds() - startmillisecs);
+#endif
+	return numaltroutegoals;
+#endif
+} //end of the function AAS_AlternativeRouteGoals
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void AAS_InitAlternativeRouting(void)
+{
+#ifdef ENABLE_ALTROUTING
+	if (midrangeareas) FreeMemory(midrangeareas);
+	midrangeareas = (midrangearea_t *) GetMemory(aasworld.numareas * sizeof(midrangearea_t));
+	if (clusterareas) FreeMemory(clusterareas);
+	clusterareas = (int *) GetMemory(aasworld.numareas * sizeof(int));
+#endif
+} //end of the function AAS_InitAlternativeRouting
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void AAS_ShutdownAlternativeRouting(void)
+{
+#ifdef ENABLE_ALTROUTING
+	if (midrangeareas) FreeMemory(midrangeareas);
+	midrangeareas = NULL;
+	if (clusterareas) FreeMemory(clusterareas);
+	clusterareas = NULL;
+	numclusterareas = 0;
+#endif
+} //end of the function AAS_ShutdownAlternativeRouting
diff --git a/codemp/botlib/be_aas_routealt.h b/codemp/botlib/be_aas_routealt.h
new file mode 100644
index 0000000..b2fb8bd
--- /dev/null
+++ b/codemp/botlib/be_aas_routealt.h
@@ -0,0 +1,23 @@
+
+/*****************************************************************************
+ * name:		be_aas_routealt.h
+ *
+ * desc:		AAS
+ *
+ * $Archive: /source/code/botlib/be_aas_routealt.h $
+ * $Author: Mrelusive $ 
+ * $Revision: 2 $
+ * $Modtime: 10/05/99 3:32p $
+ * $Date: 10/05/99 3:42p $
+ *
+ *****************************************************************************/
+
+#ifdef AASINTERN
+void AAS_InitAlternativeRouting(void);
+void AAS_ShutdownAlternativeRouting(void);
+#endif //AASINTERN
+
+
+int AAS_AlternativeRouteGoals(vec3_t start, int startareanum, vec3_t goal, int goalareanum, int travelflags,
+										aas_altroutegoal_t *altroutegoals, int maxaltroutegoals,
+										int type);
diff --git a/codemp/botlib/be_aas_sample.cpp b/codemp/botlib/be_aas_sample.cpp
new file mode 100644
index 0000000..f03813c
--- /dev/null
+++ b/codemp/botlib/be_aas_sample.cpp
@@ -0,0 +1,1377 @@
+
+/*****************************************************************************
+ * name:		be_aas_sample.c
+ *
+ * desc:		AAS environment sampling
+ *
+ * $Archive: /MissionPack/code/botlib/be_aas_sample.c $
+ * $Author: Ttimo $ 
+ * $Revision: 13 $
+ * $Modtime: 4/13/01 4:45p $
+ * $Date: 4/13/01 4:45p $
+ *
+ *****************************************************************************/
+
+#include "../game/q_shared.h"
+#include "l_memory.h"
+#include "l_script.h"
+#include "l_precomp.h"
+#include "l_struct.h"
+#ifndef BSPC
+#include "l_libvar.h"
+#endif
+#include "aasfile.h"
+#include "../game/botlib.h"
+#include "../game/be_aas.h"
+#include "be_interface.h"
+#include "be_aas_funcs.h"
+#include "be_aas_def.h"
+
+extern botlib_import_t botimport;
+
+//#define AAS_SAMPLE_DEBUG
+
+#define BBOX_NORMAL_EPSILON		0.001
+
+#define ON_EPSILON					0 //0.0005
+
+#define TRACEPLANE_EPSILON			0.125
+
+typedef struct aas_tracestack_s
+{
+	vec3_t start;		//start point of the piece of line to trace
+	vec3_t end;			//end point of the piece of line to trace
+	int planenum;		//last plane used as splitter
+	int nodenum;		//node found after splitting with planenum
+} aas_tracestack_t;
+
+int numaaslinks;
+
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void AAS_PresenceTypeBoundingBox(int presencetype, vec3_t mins, vec3_t maxs)
+{
+	int index;
+	//bounding box size for each presence type
+	vec3_t boxmins[3] = {{0, 0, 0}, {-15, -15, -24}, {-15, -15, -24}};
+	vec3_t boxmaxs[3] = {{0, 0, 0}, { 15,  15,  32}, { 15,  15,   8}};
+
+	if (presencetype == PRESENCE_NORMAL) index = 1;
+	else if (presencetype == PRESENCE_CROUCH) index = 2;
+	else
+	{
+		botimport.Print(PRT_FATAL, "AAS_PresenceTypeBoundingBox: unknown presence type\n");
+		index = 2;
+	} //end if
+	VectorCopy(boxmins[index], mins);
+	VectorCopy(boxmaxs[index], maxs);
+} //end of the function AAS_PresenceTypeBoundingBox
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void AAS_InitAASLinkHeap(void)
+{
+	int i, max_aaslinks;
+
+	max_aaslinks = aasworld.linkheapsize;
+	//if there's no link heap present
+	if (!aasworld.linkheap)
+	{
+#ifdef BSPC
+		max_aaslinks = 6144;
+#else
+		max_aaslinks = (int) LibVarValue("max_aaslinks", "6144");
+#endif
+		if (max_aaslinks < 0) max_aaslinks = 0;
+		aasworld.linkheapsize = max_aaslinks;
+		aasworld.linkheap = (aas_link_t *) GetHunkMemory(max_aaslinks * sizeof(aas_link_t));
+	} //end if
+	//link the links on the heap
+	aasworld.linkheap[0].prev_ent = NULL;
+	aasworld.linkheap[0].next_ent = &aasworld.linkheap[1];
+	for (i = 1; i < max_aaslinks-1; i++)
+	{
+		aasworld.linkheap[i].prev_ent = &aasworld.linkheap[i - 1];
+		aasworld.linkheap[i].next_ent = &aasworld.linkheap[i + 1];
+	} //end for
+	aasworld.linkheap[max_aaslinks-1].prev_ent = &aasworld.linkheap[max_aaslinks-2];
+	aasworld.linkheap[max_aaslinks-1].next_ent = NULL;
+	//pointer to the first free link
+	aasworld.freelinks = &aasworld.linkheap[0];
+	//
+	numaaslinks = max_aaslinks;
+} //end of the function AAS_InitAASLinkHeap
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void AAS_FreeAASLinkHeap(void)
+{
+	if (aasworld.linkheap) FreeMemory(aasworld.linkheap);
+	aasworld.linkheap = NULL;
+	aasworld.linkheapsize = 0;
+} //end of the function AAS_FreeAASLinkHeap
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+aas_link_t *AAS_AllocAASLink(void)
+{
+	aas_link_t *link;
+
+	link = aasworld.freelinks;
+	if (!link)
+	{
+#ifndef BSPC
+		if (bot_developer)
+#endif
+		{
+			botimport.Print(PRT_FATAL, "empty aas link heap\n");
+		} //end if
+		return NULL;
+	} //end if
+	if (aasworld.freelinks) aasworld.freelinks = aasworld.freelinks->next_ent;
+	if (aasworld.freelinks) aasworld.freelinks->prev_ent = NULL;
+	numaaslinks--;
+	return link;
+} //end of the function AAS_AllocAASLink
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void AAS_DeAllocAASLink(aas_link_t *link)
+{
+	if (aasworld.freelinks) aasworld.freelinks->prev_ent = link;
+	link->prev_ent = NULL;
+	link->next_ent = aasworld.freelinks;
+	link->prev_area = NULL;
+	link->next_area = NULL;
+	aasworld.freelinks = link;
+	numaaslinks++;
+} //end of the function AAS_DeAllocAASLink
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void AAS_InitAASLinkedEntities(void)
+{
+	if (!aasworld.loaded) return;
+	if (aasworld.arealinkedentities) FreeMemory(aasworld.arealinkedentities);
+	aasworld.arealinkedentities = (aas_link_t **) GetClearedHunkMemory(
+						aasworld.numareas * sizeof(aas_link_t *));
+} //end of the function AAS_InitAASLinkedEntities
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void AAS_FreeAASLinkedEntities(void)
+{
+	if (aasworld.arealinkedentities) FreeMemory(aasworld.arealinkedentities);
+	aasworld.arealinkedentities = NULL;
+} //end of the function AAS_InitAASLinkedEntities
+//===========================================================================
+// returns the AAS area the point is in
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int AAS_PointAreaNum(vec3_t point)
+{
+	int nodenum;
+	vec_t	dist;
+	aas_node_t *node;
+	aas_plane_t *plane;
+
+	if (!aasworld.loaded)
+	{
+		botimport.Print(PRT_ERROR, "AAS_PointAreaNum: aas not loaded\n");
+		return 0;
+	} //end if
+
+	//start with node 1 because node zero is a dummy used for solid leafs
+	nodenum = 1;
+	while (nodenum > 0)
+	{
+//		botimport.Print(PRT_MESSAGE, "[%d]", nodenum);
+#ifdef AAS_SAMPLE_DEBUG
+		if (nodenum >= aasworld.numnodes)
+		{
+			botimport.Print(PRT_ERROR, "nodenum = %d >= aasworld.numnodes = %d\n", nodenum, aasworld.numnodes);
+			return 0;
+		} //end if
+#endif //AAS_SAMPLE_DEBUG
+		node = &aasworld.nodes[nodenum];
+#ifdef AAS_SAMPLE_DEBUG
+		if (node->planenum < 0 || node->planenum >= aasworld.numplanes)
+		{
+			botimport.Print(PRT_ERROR, "node->planenum = %d >= aasworld.numplanes = %d\n", node->planenum, aasworld.numplanes);
+			return 0;
+		} //end if
+#endif //AAS_SAMPLE_DEBUG
+		plane = &aasworld.planes[node->planenum];
+		dist = DotProduct(point, plane->normal) - plane->dist;
+		if (dist > 0) nodenum = node->children[0];
+		else nodenum = node->children[1];
+	} //end while
+	if (!nodenum)
+	{
+#ifdef AAS_SAMPLE_DEBUG
+		botimport.Print(PRT_MESSAGE, "in solid\n");
+#endif //AAS_SAMPLE_DEBUG
+		return 0;
+	} //end if
+	return -nodenum;
+} //end of the function AAS_PointAreaNum
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+int AAS_PointReachabilityAreaIndex( vec3_t origin )
+{
+	int areanum, cluster, i, index;
+
+	if (!aasworld.initialized)
+		return 0;
+
+	if ( !origin )
+	{
+		index = 0;
+		for (i = 0; i < aasworld.numclusters; i++)
+		{
+			index += aasworld.clusters[i].numreachabilityareas;
+		} //end for
+		return index;
+	} //end if
+
+	areanum = AAS_PointAreaNum( origin );
+	if ( !areanum || !AAS_AreaReachability(areanum) )
+		return 0;
+	cluster = aasworld.areasettings[areanum].cluster;
+	areanum = aasworld.areasettings[areanum].clusterareanum;
+	if (cluster < 0)
+	{
+		cluster = aasworld.portals[-cluster].frontcluster;
+		areanum = aasworld.portals[-cluster].clusterareanum[0];
+	} //end if
+
+	index = 0;
+	for (i = 0; i < cluster; i++)
+	{
+		index += aasworld.clusters[i].numreachabilityareas;
+	} //end for
+	index += areanum;
+	return index;
+} //end of the function AAS_PointReachabilityAreaIndex
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int AAS_AreaCluster(int areanum)
+{
+	if (areanum <= 0 || areanum >= aasworld.numareas)
+	{
+		botimport.Print(PRT_ERROR, "AAS_AreaCluster: invalid area number\n");
+		return 0;
+	} //end if
+	return aasworld.areasettings[areanum].cluster;
+} //end of the function AAS_AreaCluster
+//===========================================================================
+// returns the presence types of the given area
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int AAS_AreaPresenceType(int areanum)
+{
+	if (!aasworld.loaded) return 0;
+	if (areanum <= 0 || areanum >= aasworld.numareas)
+	{
+		botimport.Print(PRT_ERROR, "AAS_AreaPresenceType: invalid area number\n");
+		return 0;
+	} //end if
+	return aasworld.areasettings[areanum].presencetype;
+} //end of the function AAS_AreaPresenceType
+//===========================================================================
+// returns the presence type at the given point
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int AAS_PointPresenceType(vec3_t point)
+{
+	int areanum;
+
+	if (!aasworld.loaded) return 0;
+
+	areanum = AAS_PointAreaNum(point);
+	if (!areanum) return PRESENCE_NONE;
+	return aasworld.areasettings[areanum].presencetype;
+} //end of the function AAS_PointPresenceType
+//===========================================================================
+// calculates the minimum distance between the origin of the box and the
+// given plane when both will collide on the given side of the plane
+//
+// normal	=	normal vector of plane to calculate distance from
+// mins		=	minimums of box relative to origin
+// maxs		=	maximums of box relative to origin
+// side		=	side of the plane we want to calculate the distance from
+//					0 normal vector side
+//					1 not normal vector side
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+vec_t AAS_BoxOriginDistanceFromPlane(vec3_t normal, vec3_t mins, vec3_t maxs, int side)
+{
+	vec3_t v1, v2;
+	int i;
+
+	//swap maxs and mins when on the other side of the plane
+	if (side)
+	{
+		//get a point of the box that would be one of the first
+		//to collide with the plane
+		for (i = 0; i < 3; i++)
+		{
+			if (normal[i] > BBOX_NORMAL_EPSILON) v1[i] = maxs[i];
+			else if (normal[i] < -BBOX_NORMAL_EPSILON) v1[i] = mins[i];
+			else v1[i] = 0;
+		} //end for
+	} //end if
+	else
+	{
+		//get a point of the box that would be one of the first
+		//to collide with the plane
+		for (i = 0; i < 3; i++)
+		{
+			if (normal[i] > BBOX_NORMAL_EPSILON) v1[i] = mins[i];
+			else if (normal[i] < -BBOX_NORMAL_EPSILON) v1[i] = maxs[i];
+			else v1[i] = 0;
+		} //end for
+	} //end else
+	//
+	VectorCopy(normal, v2);
+	VectorInverse(v2);
+//	VectorNegate(normal, v2);
+	return DotProduct(v1, v2);
+} //end of the function AAS_BoxOriginDistanceFromPlane
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+qboolean AAS_AreaEntityCollision(int areanum, vec3_t start, vec3_t end,
+										int presencetype, int passent, aas_trace_t *trace)
+{
+	int collision;
+	vec3_t boxmins, boxmaxs;
+	aas_link_t *link;
+	bsp_trace_t bsptrace;
+
+	AAS_PresenceTypeBoundingBox(presencetype, boxmins, boxmaxs);
+
+	Com_Memset(&bsptrace, 0, sizeof(bsp_trace_t)); //make compiler happy
+	//assume no collision
+	bsptrace.fraction = 1;
+	collision = qfalse;
+	for (link = aasworld.arealinkedentities[areanum]; link; link = link->next_ent)
+	{
+		//ignore the pass entity
+		if (link->entnum == passent) continue;
+		//
+		if (AAS_EntityCollision(link->entnum, start, boxmins, boxmaxs, end,
+												CONTENTS_SOLID|CONTENTS_PLAYERCLIP, &bsptrace))
+		{
+			collision = qtrue;
+		} //end if
+	} //end for
+	if (collision)
+	{
+		trace->startsolid = bsptrace.startsolid;
+		trace->ent = bsptrace.ent;
+		VectorCopy(bsptrace.endpos, trace->endpos);
+		trace->area = 0;
+		trace->planenum = 0;
+		return qtrue;
+	} //end if
+	return qfalse;
+} //end of the function AAS_AreaEntityCollision
+//===========================================================================
+// recursive subdivision of the line by the BSP tree.
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+aas_trace_t AAS_TraceClientBBox(vec3_t start, vec3_t end, int presencetype,
+																				int passent)
+{
+	int side, nodenum, tmpplanenum;
+	float front, back, frac;
+	vec3_t cur_start, cur_end, cur_mid, v1, v2;
+	aas_tracestack_t tracestack[127];
+	aas_tracestack_t *tstack_p;
+	aas_node_t *aasnode;
+	aas_plane_t *plane;
+	aas_trace_t trace;
+
+	//clear the trace structure
+	Com_Memset(&trace, 0, sizeof(aas_trace_t));
+
+	if (!aasworld.loaded) return trace;
+	
+	tstack_p = tracestack;
+	//we start with the whole line on the stack
+	VectorCopy(start, tstack_p->start);
+	VectorCopy(end, tstack_p->end);
+	tstack_p->planenum = 0;
+	//start with node 1 because node zero is a dummy for a solid leaf
+	tstack_p->nodenum = 1;		//starting at the root of the tree
+	tstack_p++;
+	
+	while (1)
+	{
+		//pop up the stack
+		tstack_p--;
+		//if the trace stack is empty (ended up with a piece of the
+		//line to be traced in an area)
+		if (tstack_p < tracestack)
+		{
+			tstack_p++;
+			//nothing was hit
+			trace.startsolid = qfalse;
+			trace.fraction = 1.0;
+			//endpos is the end of the line
+			VectorCopy(end, trace.endpos);
+			//nothing hit
+			trace.ent = 0;
+			trace.area = 0;
+			trace.planenum = 0;
+			return trace;
+		} //end if
+		//number of the current node to test the line against
+		nodenum = tstack_p->nodenum;
+		//if it is an area
+		if (nodenum < 0)
+		{
+#ifdef AAS_SAMPLE_DEBUG
+			if (-nodenum > aasworld.numareasettings)
+			{
+				botimport.Print(PRT_ERROR, "AAS_TraceBoundingBox: -nodenum out of range\n");
+				return trace;
+			} //end if
+#endif //AAS_SAMPLE_DEBUG
+			//botimport.Print(PRT_MESSAGE, "areanum = %d, must be %d\n", -nodenum, AAS_PointAreaNum(start));
+			//if can't enter the area because it hasn't got the right presence type
+			if (!(aasworld.areasettings[-nodenum].presencetype & presencetype))
+			{
+				//if the start point is still the initial start point
+				//NOTE: no need for epsilons because the points will be
+				//exactly the same when they're both the start point
+				if (tstack_p->start[0] == start[0] &&
+						tstack_p->start[1] == start[1] &&
+						tstack_p->start[2] == start[2])
+				{
+					trace.startsolid = qtrue;
+					trace.fraction = 0.0;
+					VectorClear(v1);
+				} //end if
+				else
+				{
+					trace.startsolid = qfalse;
+					VectorSubtract(end, start, v1);
+					VectorSubtract(tstack_p->start, start, v2);
+					trace.fraction = VectorLength(v2) / VectorNormalize(v1);
+					VectorMA(tstack_p->start, -0.125, v1, tstack_p->start);
+				} //end else
+				VectorCopy(tstack_p->start, trace.endpos);
+				trace.ent = 0;
+				trace.area = -nodenum;
+//				VectorSubtract(end, start, v1);
+				trace.planenum = tstack_p->planenum;
+				//always take the plane with normal facing towards the trace start
+				plane = &aasworld.planes[trace.planenum];
+				if (DotProduct(v1, plane->normal) > 0) trace.planenum ^= 1;
+				return trace;
+			} //end if
+			else
+			{
+				if (passent >= 0)
+				{
+					if (AAS_AreaEntityCollision(-nodenum, tstack_p->start,
+													tstack_p->end, presencetype, passent,
+													&trace))
+					{
+						if (!trace.startsolid)
+						{
+							VectorSubtract(end, start, v1);
+							VectorSubtract(trace.endpos, start, v2);
+							trace.fraction = VectorLength(v2) / VectorLength(v1);
+						} //end if
+						return trace;
+					} //end if
+				} //end if
+			} //end else
+			trace.lastarea = -nodenum;
+			continue;
+		} //end if
+		//if it is a solid leaf
+		if (!nodenum)
+		{
+			//if the start point is still the initial start point
+			//NOTE: no need for epsilons because the points will be
+			//exactly the same when they're both the start point
+			if (tstack_p->start[0] == start[0] &&
+					tstack_p->start[1] == start[1] &&
+					tstack_p->start[2] == start[2])
+			{
+				trace.startsolid = qtrue;
+				trace.fraction = 0.0;
+				VectorClear(v1);
+			} //end if
+			else
+			{
+				trace.startsolid = qfalse;
+				VectorSubtract(end, start, v1);
+				VectorSubtract(tstack_p->start, start, v2);
+				trace.fraction = VectorLength(v2) / VectorNormalize(v1);
+				VectorMA(tstack_p->start, -0.125, v1, tstack_p->start);
+			} //end else
+			VectorCopy(tstack_p->start, trace.endpos);
+			trace.ent = 0;
+			trace.area = 0;	//hit solid leaf
+//			VectorSubtract(end, start, v1);
+			trace.planenum = tstack_p->planenum;
+			//always take the plane with normal facing towards the trace start
+			plane = &aasworld.planes[trace.planenum];
+			if (DotProduct(v1, plane->normal) > 0) trace.planenum ^= 1;
+			return trace;
+		} //end if
+#ifdef AAS_SAMPLE_DEBUG
+		if (nodenum > aasworld.numnodes)
+		{
+			botimport.Print(PRT_ERROR, "AAS_TraceBoundingBox: nodenum out of range\n");
+			return trace;
+		} //end if
+#endif //AAS_SAMPLE_DEBUG
+		//the node to test against
+		aasnode = &aasworld.nodes[nodenum];
+		//start point of current line to test against node
+		VectorCopy(tstack_p->start, cur_start);
+		//end point of the current line to test against node
+		VectorCopy(tstack_p->end, cur_end);
+		//the current node plane
+		plane = &aasworld.planes[aasnode->planenum];
+
+//		switch(plane->type)
+		{/*FIXME: wtf doesn't this work? obviously the axial node planes aren't always facing positive!!!
+			//check for axial planes
+			case PLANE_X:
+			{
+				front = cur_start[0] - plane->dist;
+				back = cur_end[0] - plane->dist;
+				break;
+			} //end case
+			case PLANE_Y:
+			{
+				front = cur_start[1] - plane->dist;
+				back = cur_end[1] - plane->dist;
+				break;
+			} //end case
+			case PLANE_Z:
+			{
+				front = cur_start[2] - plane->dist;
+				back = cur_end[2] - plane->dist;
+				break;
+			} //end case*/
+//			default: //gee it's not an axial plane
+			{
+				front = DotProduct(cur_start, plane->normal) - plane->dist;
+				back = DotProduct(cur_end, plane->normal) - plane->dist;
+//				break;
+			} //end default
+		} //end switch
+		// bk010221 - old location of FPE hack and divide by zero expression
+		//if the whole to be traced line is totally at the front of this node
+		//only go down the tree with the front child
+		if ((front >= -ON_EPSILON && back >= -ON_EPSILON))
+		{
+			//keep the current start and end point on the stack
+			//and go down the tree with the front child
+			tstack_p->nodenum = aasnode->children[0];
+			tstack_p++;
+			if (tstack_p >= &tracestack[127])
+			{
+				botimport.Print(PRT_ERROR, "AAS_TraceBoundingBox: stack overflow\n");
+				return trace;
+			} //end if
+		} //end if
+		//if the whole to be traced line is totally at the back of this node
+		//only go down the tree with the back child
+		else if ((front < ON_EPSILON && back < ON_EPSILON))
+		{
+			//keep the current start and end point on the stack
+			//and go down the tree with the back child
+			tstack_p->nodenum = aasnode->children[1];
+			tstack_p++;
+			if (tstack_p >= &tracestack[127])
+			{
+				botimport.Print(PRT_ERROR, "AAS_TraceBoundingBox: stack overflow\n");
+				return trace;
+			} //end if
+		} //end if
+		//go down the tree both at the front and back of the node
+		else
+		{
+			tmpplanenum = tstack_p->planenum;
+			// bk010221 - new location of divide by zero (see above)
+			if ( front == back ) front -= 0.001f; // bk0101022 - hack/FPE 
+                	//calculate the hitpoint with the node (split point of the line)
+			//put the crosspoint TRACEPLANE_EPSILON pixels on the near side
+			if (front < 0) frac = (front + TRACEPLANE_EPSILON)/(front-back);
+			else frac = (front - TRACEPLANE_EPSILON)/(front-back); // bk010221
+			//
+			if (frac < 0)
+				frac = 0.001f; //0
+			else if (frac > 1)
+				frac = 0.999f; //1
+			//frac = front / (front-back);
+			//
+			cur_mid[0] = cur_start[0] + (cur_end[0] - cur_start[0]) * frac;
+			cur_mid[1] = cur_start[1] + (cur_end[1] - cur_start[1]) * frac;
+			cur_mid[2] = cur_start[2] + (cur_end[2] - cur_start[2]) * frac;
+
+//			AAS_DrawPlaneCross(cur_mid, plane->normal, plane->dist, plane->type, LINECOLOR_RED);
+			//side the front part of the line is on
+			side = front < 0;
+			//first put the end part of the line on the stack (back side)
+			VectorCopy(cur_mid, tstack_p->start);
+			//not necesary to store because still on stack
+			//VectorCopy(cur_end, tstack_p->end);
+			tstack_p->planenum = aasnode->planenum;
+			tstack_p->nodenum = aasnode->children[!side];
+			tstack_p++;
+			if (tstack_p >= &tracestack[127])
+			{
+				botimport.Print(PRT_ERROR, "AAS_TraceBoundingBox: stack overflow\n");
+				return trace;
+			} //end if
+			//now put the part near the start of the line on the stack so we will
+			//continue with thats part first. This way we'll find the first
+			//hit of the bbox
+			VectorCopy(cur_start, tstack_p->start);
+			VectorCopy(cur_mid, tstack_p->end);
+			tstack_p->planenum = tmpplanenum;
+			tstack_p->nodenum = aasnode->children[side];
+			tstack_p++;
+			if (tstack_p >= &tracestack[127])
+			{
+				botimport.Print(PRT_ERROR, "AAS_TraceBoundingBox: stack overflow\n");
+				return trace;
+			} //end if
+		} //end else
+	} //end while
+//	return trace;
+} //end of the function AAS_TraceClientBBox
+//===========================================================================
+// recursive subdivision of the line by the BSP tree.
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int AAS_TraceAreas(vec3_t start, vec3_t end, int *areas, vec3_t *points, int maxareas)
+{
+	int side, nodenum, tmpplanenum;
+	int numareas;
+	float front, back, frac;
+	vec3_t cur_start, cur_end, cur_mid;
+	aas_tracestack_t tracestack[127];
+	aas_tracestack_t *tstack_p;
+	aas_node_t *aasnode;
+	aas_plane_t *plane;
+
+	numareas = 0;
+	areas[0] = 0;
+	if (!aasworld.loaded) return numareas;
+
+	tstack_p = tracestack;
+	//we start with the whole line on the stack
+	VectorCopy(start, tstack_p->start);
+	VectorCopy(end, tstack_p->end);
+	tstack_p->planenum = 0;
+	//start with node 1 because node zero is a dummy for a solid leaf
+	tstack_p->nodenum = 1;		//starting at the root of the tree
+	tstack_p++;
+
+	while (1)
+	{
+		//pop up the stack
+		tstack_p--;
+		//if the trace stack is empty (ended up with a piece of the
+		//line to be traced in an area)
+		if (tstack_p < tracestack)
+		{
+			return numareas;
+		} //end if
+		//number of the current node to test the line against
+		nodenum = tstack_p->nodenum;
+		//if it is an area
+		if (nodenum < 0)
+		{
+#ifdef AAS_SAMPLE_DEBUG
+			if (-nodenum > aasworld.numareasettings)
+			{
+				botimport.Print(PRT_ERROR, "AAS_TraceAreas: -nodenum = %d out of range\n", -nodenum);
+				return numareas;
+			} //end if
+#endif //AAS_SAMPLE_DEBUG
+			//botimport.Print(PRT_MESSAGE, "areanum = %d, must be %d\n", -nodenum, AAS_PointAreaNum(start));
+			areas[numareas] = -nodenum;
+			if (points) VectorCopy(tstack_p->start, points[numareas]);
+			numareas++;
+			if (numareas >= maxareas) return numareas;
+			continue;
+		} //end if
+		//if it is a solid leaf
+		if (!nodenum)
+		{
+			continue;
+		} //end if
+#ifdef AAS_SAMPLE_DEBUG
+		if (nodenum > aasworld.numnodes)
+		{
+			botimport.Print(PRT_ERROR, "AAS_TraceAreas: nodenum out of range\n");
+			return numareas;
+		} //end if
+#endif //AAS_SAMPLE_DEBUG
+		//the node to test against
+		aasnode = &aasworld.nodes[nodenum];
+		//start point of current line to test against node
+		VectorCopy(tstack_p->start, cur_start);
+		//end point of the current line to test against node
+		VectorCopy(tstack_p->end, cur_end);
+		//the current node plane
+		plane = &aasworld.planes[aasnode->planenum];
+
+//		switch(plane->type)
+		{/*FIXME: wtf doesn't this work? obviously the node planes aren't always facing positive!!!
+			//check for axial planes
+			case PLANE_X:
+			{
+				front = cur_start[0] - plane->dist;
+				back = cur_end[0] - plane->dist;
+				break;
+			} //end case
+			case PLANE_Y:
+			{
+				front = cur_start[1] - plane->dist;
+				back = cur_end[1] - plane->dist;
+				break;
+			} //end case
+			case PLANE_Z:
+			{
+				front = cur_start[2] - plane->dist;
+				back = cur_end[2] - plane->dist;
+				break;
+			} //end case*/
+//			default: //gee it's not an axial plane
+			{
+				front = DotProduct(cur_start, plane->normal) - plane->dist;
+				back = DotProduct(cur_end, plane->normal) - plane->dist;
+//				break;
+			} //end default
+		} //end switch
+
+		//if the whole to be traced line is totally at the front of this node
+		//only go down the tree with the front child
+		if (front > 0 && back > 0)
+		{
+			//keep the current start and end point on the stack
+			//and go down the tree with the front child
+			tstack_p->nodenum = aasnode->children[0];
+			tstack_p++;
+			if (tstack_p >= &tracestack[127])
+			{
+				botimport.Print(PRT_ERROR, "AAS_TraceAreas: stack overflow\n");
+				return numareas;
+			} //end if
+		} //end if
+		//if the whole to be traced line is totally at the back of this node
+		//only go down the tree with the back child
+		else if (front <= 0 && back <= 0)
+		{
+			//keep the current start and end point on the stack
+			//and go down the tree with the back child
+			tstack_p->nodenum = aasnode->children[1];
+			tstack_p++;
+			if (tstack_p >= &tracestack[127])
+			{
+				botimport.Print(PRT_ERROR, "AAS_TraceAreas: stack overflow\n");
+				return numareas;
+			} //end if
+		} //end if
+		//go down the tree both at the front and back of the node
+		else
+		{
+			tmpplanenum = tstack_p->planenum;
+			//calculate the hitpoint with the node (split point of the line)
+			//put the crosspoint TRACEPLANE_EPSILON pixels on the near side
+			if (front < 0) frac = (front)/(front-back);
+			else frac = (front)/(front-back);
+			if (frac < 0) frac = 0;
+			else if (frac > 1) frac = 1;
+			//frac = front / (front-back);
+			//
+			cur_mid[0] = cur_start[0] + (cur_end[0] - cur_start[0]) * frac;
+			cur_mid[1] = cur_start[1] + (cur_end[1] - cur_start[1]) * frac;
+			cur_mid[2] = cur_start[2] + (cur_end[2] - cur_start[2]) * frac;
+
+//			AAS_DrawPlaneCross(cur_mid, plane->normal, plane->dist, plane->type, LINECOLOR_RED);
+			//side the front part of the line is on
+			side = front < 0;
+			//first put the end part of the line on the stack (back side)
+			VectorCopy(cur_mid, tstack_p->start);
+			//not necesary to store because still on stack
+			//VectorCopy(cur_end, tstack_p->end);
+			tstack_p->planenum = aasnode->planenum;
+			tstack_p->nodenum = aasnode->children[!side];
+			tstack_p++;
+			if (tstack_p >= &tracestack[127])
+			{
+				botimport.Print(PRT_ERROR, "AAS_TraceAreas: stack overflow\n");
+				return numareas;
+			} //end if
+			//now put the part near the start of the line on the stack so we will
+			//continue with thats part first. This way we'll find the first
+			//hit of the bbox
+			VectorCopy(cur_start, tstack_p->start);
+			VectorCopy(cur_mid, tstack_p->end);
+			tstack_p->planenum = tmpplanenum;
+			tstack_p->nodenum = aasnode->children[side];
+			tstack_p++;
+			if (tstack_p >= &tracestack[127])
+			{
+				botimport.Print(PRT_ERROR, "AAS_TraceAreas: stack overflow\n");
+				return numareas;
+			} //end if
+		} //end else
+	} //end while
+//	return numareas;
+} //end of the function AAS_TraceAreas
+//===========================================================================
+// a simple cross product
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+// void AAS_OrthogonalToVectors(vec3_t v1, vec3_t v2, vec3_t res)
+#define AAS_OrthogonalToVectors(v1, v2, res) \
+	(res)[0] = ((v1)[1] * (v2)[2]) - ((v1)[2] * (v2)[1]);\
+	(res)[1] = ((v1)[2] * (v2)[0]) - ((v1)[0] * (v2)[2]);\
+	(res)[2] = ((v1)[0] * (v2)[1]) - ((v1)[1] * (v2)[0]);
+//===========================================================================
+// tests if the given point is within the face boundaries
+//
+// Parameter:				face		: face to test if the point is in it
+//								pnormal	: normal of the plane to use for the face
+//								point		: point to test if inside face boundaries
+// Returns:					qtrue if the point is within the face boundaries
+// Changes Globals:		-
+//===========================================================================
+qboolean AAS_InsideFace(aas_face_t *face, vec3_t pnormal, vec3_t point, float epsilon)
+{
+	int i, firstvertex, edgenum;
+	vec3_t v0;
+	vec3_t edgevec, pointvec, sepnormal;
+	aas_edge_t *edge;
+#ifdef AAS_SAMPLE_DEBUG
+	int lastvertex = 0;
+#endif //AAS_SAMPLE_DEBUG
+
+	if (!aasworld.loaded) return qfalse;
+
+	for (i = 0; i < face->numedges; i++)
+	{
+		edgenum = aasworld.edgeindex[face->firstedge + i];
+		edge = &aasworld.edges[abs(edgenum)];
+		//get the first vertex of the edge
+		firstvertex = edgenum < 0;
+		VectorCopy(aasworld.vertexes[edge->v[firstvertex]], v0);
+		//edge vector
+		VectorSubtract(aasworld.vertexes[edge->v[!firstvertex]], v0, edgevec);
+		//
+#ifdef AAS_SAMPLE_DEBUG
+		if (lastvertex && lastvertex != edge->v[firstvertex])
+		{
+			botimport.Print(PRT_MESSAGE, "winding not counter clockwise\n");
+		} //end if
+		lastvertex = edge->v[!firstvertex];
+#endif //AAS_SAMPLE_DEBUG
+		//vector from first edge point to point possible in face
+		VectorSubtract(point, v0, pointvec);
+		//get a vector pointing inside the face orthogonal to both the
+		//edge vector and the normal vector of the plane the face is in
+		//this vector defines a plane through the origin (first vertex of
+		//edge) and through both the edge vector and the normal vector
+		//of the plane
+		AAS_OrthogonalToVectors(edgevec, pnormal, sepnormal);
+		//check on wich side of the above plane the point is
+		//this is done by checking the sign of the dot product of the
+		//vector orthogonal vector from above and the vector from the
+		//origin (first vertex of edge) to the point 
+		//if the dotproduct is smaller than zero the point is outside the face
+		if (DotProduct(pointvec, sepnormal) < -epsilon) return qfalse;
+	} //end for
+	return qtrue;
+} //end of the function AAS_InsideFace
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+qboolean AAS_PointInsideFace(int facenum, vec3_t point, float epsilon)
+{
+	int i, firstvertex, edgenum;
+	vec_t *v1, *v2;
+	vec3_t edgevec, pointvec, sepnormal;
+	aas_edge_t *edge;
+	aas_plane_t *plane;
+	aas_face_t *face;
+
+	if (!aasworld.loaded) return qfalse;
+
+	face = &aasworld.faces[facenum];
+	plane = &aasworld.planes[face->planenum];
+	//
+	for (i = 0; i < face->numedges; i++)
+	{
+		edgenum = aasworld.edgeindex[face->firstedge + i];
+		edge = &aasworld.edges[abs(edgenum)];
+		//get the first vertex of the edge
+		firstvertex = edgenum < 0;
+		v1 = aasworld.vertexes[edge->v[firstvertex]];
+		v2 = aasworld.vertexes[edge->v[!firstvertex]];
+		//edge vector
+		VectorSubtract(v2, v1, edgevec);
+		//vector from first edge point to point possible in face
+		VectorSubtract(point, v1, pointvec);
+		//
+		CrossProduct(edgevec, plane->normal, sepnormal);
+		//
+		if (DotProduct(pointvec, sepnormal) < -epsilon) return qfalse;
+	} //end for
+	return qtrue;
+} //end of the function AAS_PointInsideFace
+//===========================================================================
+// returns the ground face the given point is above in the given area
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+aas_face_t *AAS_AreaGroundFace(int areanum, vec3_t point)
+{
+	int i, facenum;
+	vec3_t up = {0, 0, 1};
+	vec3_t normal;
+	aas_area_t *area;
+	aas_face_t *face;
+
+	if (!aasworld.loaded) return NULL;
+
+	area = &aasworld.areas[areanum];
+	for (i = 0; i < area->numfaces; i++)
+	{
+		facenum = aasworld.faceindex[area->firstface + i];
+		face = &aasworld.faces[abs(facenum)];
+		//if this is a ground face
+		if (face->faceflags & FACE_GROUND)
+		{
+			//get the up or down normal
+			if (aasworld.planes[face->planenum].normal[2] < 0) VectorNegate(up, normal);
+			else VectorCopy(up, normal);
+			//check if the point is in the face
+			if (AAS_InsideFace(face, normal, point, 0.01f)) return face;
+		} //end if
+	} //end for
+	return NULL;
+} //end of the function AAS_AreaGroundFace
+//===========================================================================
+// returns the face the trace end position is situated in
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void AAS_FacePlane(int facenum, vec3_t normal, float *dist)
+{
+	aas_plane_t *plane;
+
+	plane = &aasworld.planes[aasworld.faces[facenum].planenum];
+	VectorCopy(plane->normal, normal);
+	*dist = plane->dist;
+} //end of the function AAS_FacePlane
+//===========================================================================
+// returns the face the trace end position is situated in
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+aas_face_t *AAS_TraceEndFace(aas_trace_t *trace)
+{
+	int i, facenum;
+	aas_area_t *area;
+	aas_face_t *face, *firstface = NULL;
+
+	if (!aasworld.loaded) return NULL;
+
+	//if started in solid no face was hit
+	if (trace->startsolid) return NULL;
+	//trace->lastarea is the last area the trace was in
+	area = &aasworld.areas[trace->lastarea];
+	//check which face the trace.endpos was in
+	for (i = 0; i < area->numfaces; i++)
+	{
+		facenum = aasworld.faceindex[area->firstface + i];
+		face = &aasworld.faces[abs(facenum)];
+		//if the face is in the same plane as the trace end point
+		if ((face->planenum & ~1) == (trace->planenum & ~1))
+		{
+			//firstface is used for optimization, if theres only one
+			//face in the plane then it has to be the good one
+			//if there are more faces in the same plane then always
+			//check the one with the fewest edges first
+/*			if (firstface)
+			{
+				if (firstface->numedges < face->numedges)
+				{
+					if (AAS_InsideFace(firstface,
+						aasworld.planes[face->planenum].normal, trace->endpos))
+					{
+						return firstface;
+					} //end if
+					firstface = face;
+				} //end if
+				else
+				{
+					if (AAS_InsideFace(face,
+						aasworld.planes[face->planenum].normal, trace->endpos))
+					{
+						return face;
+					} //end if
+				} //end else
+			} //end if
+			else
+			{
+				firstface = face;
+			} //end else*/
+			if (AAS_InsideFace(face,
+						aasworld.planes[face->planenum].normal, trace->endpos, 0.01f)) return face;
+		} //end if
+	} //end for
+	return firstface;
+} //end of the function AAS_TraceEndFace
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int AAS_BoxOnPlaneSide2(vec3_t absmins, vec3_t absmaxs, aas_plane_t *p)
+{
+	int i, sides;
+	float dist1, dist2;
+	vec3_t corners[2];
+
+	for (i = 0; i < 3; i++)
+	{
+		if (p->normal[i] < 0)
+		{
+			corners[0][i] = absmins[i];
+			corners[1][i] = absmaxs[i];
+		} //end if
+		else
+		{
+			corners[1][i] = absmins[i];
+			corners[0][i] = absmaxs[i];
+		} //end else
+	} //end for
+	dist1 = DotProduct(p->normal, corners[0]) - p->dist;
+	dist2 = DotProduct(p->normal, corners[1]) - p->dist;
+	sides = 0;
+	if (dist1 >= 0) sides = 1;
+	if (dist2 < 0) sides |= 2;
+
+	return sides;
+} //end of the function AAS_BoxOnPlaneSide2
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+//int AAS_BoxOnPlaneSide(vec3_t absmins, vec3_t absmaxs, aas_plane_t *p)
+#define AAS_BoxOnPlaneSide(absmins, absmaxs, p) (\
+	( (p)->type < 3) ?\
+	(\
+		( (p)->dist <= (absmins)[(p)->type]) ?\
+		(\
+			1\
+		)\
+		:\
+		(\
+			( (p)->dist >= (absmaxs)[(p)->type]) ?\
+			(\
+				2\
+			)\
+			:\
+			(\
+				3\
+			)\
+		)\
+	)\
+	:\
+	(\
+		AAS_BoxOnPlaneSide2((absmins), (absmaxs), (p))\
+	)\
+) //end of the function AAS_BoxOnPlaneSide
+//===========================================================================
+// remove the links to this entity from all areas
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void AAS_UnlinkFromAreas(aas_link_t *areas)
+{
+	aas_link_t *link, *nextlink;
+
+	for (link = areas; link; link = nextlink)
+	{
+		//next area the entity is linked in
+		nextlink = link->next_area;
+		//remove the entity from the linked list of this area
+		if (link->prev_ent) link->prev_ent->next_ent = link->next_ent;
+		else aasworld.arealinkedentities[link->areanum] = link->next_ent;
+		if (link->next_ent) link->next_ent->prev_ent = link->prev_ent;
+		//deallocate the link structure
+		AAS_DeAllocAASLink(link);
+	} //end for
+} //end of the function AAS_UnlinkFromAreas
+//===========================================================================
+// link the entity to the areas the bounding box is totally or partly
+// situated in. This is done with recursion down the tree using the
+// bounding box to test for plane sides
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+
+typedef struct
+{
+	int nodenum;		//node found after splitting
+} aas_linkstack_t;
+
+aas_link_t *AAS_AASLinkEntity(vec3_t absmins, vec3_t absmaxs, int entnum)
+{
+	int side, nodenum;
+	aas_linkstack_t linkstack[128];
+	aas_linkstack_t *lstack_p;
+	aas_node_t *aasnode;
+	aas_plane_t *plane;
+	aas_link_t *link, *areas;
+
+	if (!aasworld.loaded)
+	{
+		botimport.Print(PRT_ERROR, "AAS_LinkEntity: aas not loaded\n");
+		return NULL;
+	} //end if
+
+	areas = NULL;
+	//
+	lstack_p = linkstack;
+	//we start with the whole line on the stack
+	//start with node 1 because node zero is a dummy used for solid leafs
+	lstack_p->nodenum = 1;		//starting at the root of the tree
+	lstack_p++;
+	
+	while (1)
+	{
+		//pop up the stack
+		lstack_p--;
+		//if the trace stack is empty (ended up with a piece of the
+		//line to be traced in an area)
+		if (lstack_p < linkstack) break;
+		//number of the current node to test the line against
+		nodenum = lstack_p->nodenum;
+		//if it is an area
+		if (nodenum < 0)
+		{
+			//NOTE: the entity might have already been linked into this area
+			// because several node children can point to the same area
+			for (link = aasworld.arealinkedentities[-nodenum]; link; link = link->next_ent)
+			{
+				if (link->entnum == entnum) break;
+			} //end for
+			if (link) continue;
+			//
+			link = AAS_AllocAASLink();
+			if (!link) return areas;
+			link->entnum = entnum;
+			link->areanum = -nodenum;
+			//put the link into the double linked area list of the entity
+			link->prev_area = NULL;
+			link->next_area = areas;
+			if (areas) areas->prev_area = link;
+			areas = link;
+			//put the link into the double linked entity list of the area
+			link->prev_ent = NULL;
+			link->next_ent = aasworld.arealinkedentities[-nodenum];
+			if (aasworld.arealinkedentities[-nodenum])
+					aasworld.arealinkedentities[-nodenum]->prev_ent = link;
+			aasworld.arealinkedentities[-nodenum] = link;
+			//
+			continue;
+		} //end if
+		//if solid leaf
+		if (!nodenum) continue;
+		//the node to test against
+		aasnode = &aasworld.nodes[nodenum];
+		//the current node plane
+		plane = &aasworld.planes[aasnode->planenum];
+		//get the side(s) the box is situated relative to the plane
+		side = AAS_BoxOnPlaneSide2(absmins, absmaxs, plane);
+		//if on the front side of the node
+		if (side & 1)
+		{
+			lstack_p->nodenum = aasnode->children[0];
+			lstack_p++;
+		} //end if
+		if (lstack_p >= &linkstack[127])
+		{
+			botimport.Print(PRT_ERROR, "AAS_LinkEntity: stack overflow\n");
+			break;
+		} //end if
+		//if on the back side of the node
+		if (side & 2)
+		{
+			lstack_p->nodenum = aasnode->children[1];
+			lstack_p++;
+		} //end if
+		if (lstack_p >= &linkstack[127])
+		{
+			botimport.Print(PRT_ERROR, "AAS_LinkEntity: stack overflow\n");
+			break;
+		} //end if
+	} //end while
+	return areas;
+} //end of the function AAS_AASLinkEntity
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+aas_link_t *AAS_LinkEntityClientBBox(vec3_t absmins, vec3_t absmaxs, int entnum, int presencetype)
+{
+	vec3_t mins, maxs;
+	vec3_t newabsmins, newabsmaxs;
+
+	AAS_PresenceTypeBoundingBox(presencetype, mins, maxs);
+	VectorSubtract(absmins, maxs, newabsmins);
+	VectorSubtract(absmaxs, mins, newabsmaxs);
+	//relink the entity
+	return AAS_AASLinkEntity(newabsmins, newabsmaxs, entnum);
+} //end of the function AAS_LinkEntityClientBBox
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int AAS_BBoxAreas(vec3_t absmins, vec3_t absmaxs, int *areas, int maxareas)
+{
+	aas_link_t *linkedareas, *link;
+	int num;
+
+	linkedareas = AAS_AASLinkEntity(absmins, absmaxs, -1);
+	num = 0;
+	for (link = linkedareas; link; link = link->next_area)
+	{
+		areas[num] = link->areanum;
+		num++;
+		if (num >= maxareas)
+			break;
+	} //end for
+	AAS_UnlinkFromAreas(linkedareas);
+	return num;
+} //end of the function AAS_BBoxAreas
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int AAS_AreaInfo( int areanum, aas_areainfo_t *info )
+{
+	aas_areasettings_t *settings;
+	if (!info)
+		return 0;
+	if (areanum <= 0 || areanum >= aasworld.numareas)
+	{
+		botimport.Print(PRT_ERROR, "AAS_AreaInfo: areanum %d out of range\n", areanum);
+		return 0;
+	} //end if
+	settings = &aasworld.areasettings[areanum];
+	info->cluster = settings->cluster;
+	info->contents = settings->contents;
+	info->flags = settings->areaflags;
+	info->presencetype = settings->presencetype;
+	VectorCopy(aasworld.areas[areanum].mins, info->mins);
+	VectorCopy(aasworld.areas[areanum].maxs, info->maxs);
+	VectorCopy(aasworld.areas[areanum].center, info->center);
+	return sizeof(aas_areainfo_t);
+} //end of the function AAS_AreaInfo
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+aas_plane_t *AAS_PlaneFromNum(int planenum)
+{
+	if (!aasworld.loaded) return 0;
+
+	return &aasworld.planes[planenum];
+} //end of the function AAS_PlaneFromNum
diff --git a/codemp/botlib/be_aas_sample.h b/codemp/botlib/be_aas_sample.h
new file mode 100644
index 0000000..77b6d30
--- /dev/null
+++ b/codemp/botlib/be_aas_sample.h
@@ -0,0 +1,52 @@
+
+/*****************************************************************************
+ * name:		be_aas_sample.h
+ *
+ * desc:		AAS
+ *
+ * $Archive: /source/code/botlib/be_aas_sample.h $
+ * $Author: Mrelusive $ 
+ * $Revision: 2 $
+ * $Modtime: 10/05/99 3:32p $
+ * $Date: 10/05/99 3:42p $
+ *
+ *****************************************************************************/
+
+#ifdef AASINTERN
+void AAS_InitAASLinkHeap(void);
+void AAS_InitAASLinkedEntities(void);
+void AAS_FreeAASLinkHeap(void);
+void AAS_FreeAASLinkedEntities(void);
+aas_face_t *AAS_AreaGroundFace(int areanum, vec3_t point);
+aas_face_t *AAS_TraceEndFace(aas_trace_t *trace);
+aas_plane_t *AAS_PlaneFromNum(int planenum);
+aas_link_t *AAS_AASLinkEntity(vec3_t absmins, vec3_t absmaxs, int entnum);
+aas_link_t *AAS_LinkEntityClientBBox(vec3_t absmins, vec3_t absmaxs, int entnum, int presencetype);
+qboolean AAS_PointInsideFace(int facenum, vec3_t point, float epsilon);
+qboolean AAS_InsideFace(aas_face_t *face, vec3_t pnormal, vec3_t point, float epsilon);
+void AAS_UnlinkFromAreas(aas_link_t *areas);
+#endif //AASINTERN
+
+//returns the mins and maxs of the bounding box for the given presence type
+void AAS_PresenceTypeBoundingBox(int presencetype, vec3_t mins, vec3_t maxs);
+//returns the cluster the area is in (negative portal number if the area is a portal)
+int AAS_AreaCluster(int areanum);
+//returns the presence type(s) of the area
+int AAS_AreaPresenceType(int areanum);
+//returns the presence type(s) at the given point
+int AAS_PointPresenceType(vec3_t point);
+//returns the result of the trace of a client bbox
+aas_trace_t AAS_TraceClientBBox(vec3_t start, vec3_t end, int presencetype, int passent);
+//stores the areas the trace went through and returns the number of passed areas
+int AAS_TraceAreas(vec3_t start, vec3_t end, int *areas, vec3_t *points, int maxareas);
+//returns the areas the bounding box is in
+int AAS_BBoxAreas(vec3_t absmins, vec3_t absmaxs, int *areas, int maxareas);
+//return area information
+int AAS_AreaInfo( int areanum, aas_areainfo_t *info );
+//returns the area the point is in
+int AAS_PointAreaNum(vec3_t point);
+//
+int AAS_PointReachabilityAreaIndex( vec3_t point );
+//returns the plane the given face is in
+void AAS_FacePlane(int facenum, vec3_t normal, float *dist);
+
diff --git a/codemp/botlib/be_ai_char.cpp b/codemp/botlib/be_ai_char.cpp
new file mode 100644
index 0000000..8c0870d
--- /dev/null
+++ b/codemp/botlib/be_ai_char.cpp
@@ -0,0 +1,773 @@
+
+/*****************************************************************************
+ * name:		be_ai_char.c
+ *
+ * desc:		bot characters
+ *
+ * $Archive: /MissionPack/code/botlib/be_ai_char.c $
+ * $Author: Ttimo $ 
+ * $Revision: 6 $
+ * $Modtime: 4/22/01 8:52a $
+ * $Date: 4/22/01 8:52a $
+ *
+ *****************************************************************************/
+
+#include "../game/q_shared.h"
+#include "l_log.h"
+#include "l_memory.h"
+#include "l_utils.h"
+#include "l_script.h"
+#include "l_precomp.h"
+#include "l_struct.h"
+#include "l_libvar.h"
+#include "aasfile.h"
+#include "../game/botlib.h"
+#include "../game/be_aas.h"
+#include "be_aas_funcs.h"
+#include "be_interface.h"
+#include "../game/be_ai_char.h"
+
+#define MAX_CHARACTERISTICS		80
+
+#define CT_INTEGER				1
+#define CT_FLOAT				2
+#define CT_STRING				3
+
+#define DEFAULT_CHARACTER		"bots/default_c.c"
+
+//characteristic value
+union cvalue
+{
+	int integer;
+	float _float;
+	char *string;
+};
+//a characteristic
+typedef struct bot_characteristic_s
+{
+	char type;						//characteristic type
+	union cvalue value;				//characteristic value
+} bot_characteristic_t;
+
+//a bot character
+typedef struct bot_character_s
+{
+	char filename[MAX_QPATH];
+	float skill;
+	bot_characteristic_t c[1];		//variable sized
+} bot_character_t;
+
+bot_character_t *botcharacters[MAX_CLIENTS + 1];
+
+//========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//========================================================================
+bot_character_t *BotCharacterFromHandle(int handle)
+{
+	if (handle <= 0 || handle > MAX_CLIENTS)
+	{
+		botimport.Print(PRT_FATAL, "character handle %d out of range\n", handle);
+		return NULL;
+	} //end if
+	if (!botcharacters[handle])
+	{
+		botimport.Print(PRT_FATAL, "invalid character %d\n", handle);
+		return NULL;
+	} //end if
+	return botcharacters[handle];
+} //end of the function BotCharacterFromHandle
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+void BotDumpCharacter(bot_character_t *ch)
+{
+	int i;
+
+	Log_Write("%s", ch->filename);
+	Log_Write("skill %d\n", ch->skill);
+	Log_Write("{\n");
+	for (i = 0; i < MAX_CHARACTERISTICS; i++)
+	{
+		switch(ch->c[i].type)
+		{
+			case CT_INTEGER: Log_Write(" %4d %d\n", i, ch->c[i].value.integer); break;
+			case CT_FLOAT: Log_Write(" %4d %f\n", i, ch->c[i].value._float); break;
+			case CT_STRING: Log_Write(" %4d %s\n", i, ch->c[i].value.string); break;
+		} //end case
+	} //end for
+	Log_Write("}\n");
+} //end of the function BotDumpCharacter
+//========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//========================================================================
+void BotFreeCharacterStrings(bot_character_t *ch)
+{
+	int i;
+
+	for (i = 0; i < MAX_CHARACTERISTICS; i++)
+	{
+		if (ch->c[i].type == CT_STRING)
+		{
+			FreeMemory(ch->c[i].value.string);
+		} //end if
+	} //end for
+} //end of the function BotFreeCharacterStrings
+//========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//========================================================================
+void BotFreeCharacter2(int handle)
+{
+	if (handle <= 0 || handle > MAX_CLIENTS)
+	{
+		botimport.Print(PRT_FATAL, "character handle %d out of range\n", handle);
+		return;
+	} //end if
+	if (!botcharacters[handle])
+	{
+		botimport.Print(PRT_FATAL, "invalid character %d\n", handle);
+		return;
+	} //end if
+	BotFreeCharacterStrings(botcharacters[handle]);
+	FreeMemory(botcharacters[handle]);
+	botcharacters[handle] = NULL;
+} //end of the function BotFreeCharacter2
+//========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//========================================================================
+void BotFreeCharacter(int handle)
+{
+	if (!LibVarGetValue("bot_reloadcharacters")) return;
+	BotFreeCharacter2(handle);
+} //end of the function BotFreeCharacter
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+void BotDefaultCharacteristics(bot_character_t *ch, bot_character_t *defaultch)
+{
+	int i;
+
+	for (i = 0; i < MAX_CHARACTERISTICS; i++)
+	{
+		if (ch->c[i].type) continue;
+		//
+		if (defaultch->c[i].type == CT_FLOAT)
+		{
+			ch->c[i].type = CT_FLOAT;
+			ch->c[i].value._float = defaultch->c[i].value._float;
+		} //end if
+		else if (defaultch->c[i].type == CT_INTEGER)
+		{
+			ch->c[i].type = CT_INTEGER;
+			ch->c[i].value.integer = defaultch->c[i].value.integer;
+		} //end else if
+		else if (defaultch->c[i].type == CT_STRING)
+		{
+			ch->c[i].type = CT_STRING;
+			ch->c[i].value.string = (char *) GetMemory(strlen(defaultch->c[i].value.string)+1);
+			strcpy(ch->c[i].value.string, defaultch->c[i].value.string);
+		} //end else if
+	} //end for
+} //end of the function BotDefaultCharacteristics
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+bot_character_t *BotLoadCharacterFromFile(char *charfile, int skill)
+{
+	int indent, index, foundcharacter;
+	bot_character_t *ch;
+	source_t *source;
+	token_t token;
+
+	foundcharacter = qfalse;
+	//a bot character is parsed in two phases
+	PC_SetBaseFolder(BOTFILESBASEFOLDER);
+	source = LoadSourceFile(charfile);
+	if (!source)
+	{
+		botimport.Print(PRT_ERROR, "counldn't load %s\n", charfile);
+		return NULL;
+	} //end if
+	ch = (bot_character_t *) GetClearedMemory(sizeof(bot_character_t) +
+					MAX_CHARACTERISTICS * sizeof(bot_characteristic_t));
+	strcpy(ch->filename, charfile);
+	while(PC_ReadToken(source, &token))
+	{
+		if (!strcmp(token.string, "skill"))
+		{
+			if (!PC_ExpectTokenType(source, TT_NUMBER, 0, &token))
+			{
+				FreeSource(source);
+				BotFreeCharacterStrings(ch);
+				FreeMemory(ch);
+				return NULL;
+			} //end if
+			if (!PC_ExpectTokenString(source, "{"))
+			{
+				FreeSource(source);
+				BotFreeCharacterStrings(ch);
+				FreeMemory(ch);
+				return NULL;
+			} //end if
+			//if it's the correct skill
+			if (skill < 0 || token.intvalue == skill)
+			{
+				foundcharacter = qtrue;
+				ch->skill = token.intvalue;
+				while(PC_ExpectAnyToken(source, &token))
+				{
+					if (!strcmp(token.string, "}")) break;
+					if (token.type != TT_NUMBER || !(token.subtype & TT_INTEGER))
+					{
+						SourceError(source, "expected integer index, found %s\n", token.string);
+						FreeSource(source);
+						BotFreeCharacterStrings(ch);
+						FreeMemory(ch);
+						return NULL;
+					} //end if
+					index = token.intvalue;
+					if (index < 0 || index > MAX_CHARACTERISTICS)
+					{
+						SourceError(source, "characteristic index out of range [0, %d]\n", MAX_CHARACTERISTICS);
+						FreeSource(source);
+						BotFreeCharacterStrings(ch);
+						FreeMemory(ch);
+						return NULL;
+					} //end if
+					if (ch->c[index].type)
+					{
+						SourceError(source, "characteristic %d already initialized\n", index);
+						FreeSource(source);
+						BotFreeCharacterStrings(ch);
+						FreeMemory(ch);
+						return NULL;
+					} //end if
+					if (!PC_ExpectAnyToken(source, &token))
+					{
+						FreeSource(source);
+						BotFreeCharacterStrings(ch);
+						FreeMemory(ch);
+						return NULL;
+					} //end if
+					if (token.type == TT_NUMBER)
+					{
+						if (token.subtype & TT_FLOAT)
+						{
+							ch->c[index].value._float = token.floatvalue;
+							ch->c[index].type = CT_FLOAT;
+						} //end if
+						else
+						{
+							ch->c[index].value.integer = token.intvalue;
+							ch->c[index].type = CT_INTEGER;
+						} //end else
+					} //end if
+					else if (token.type == TT_STRING)
+					{
+						StripDoubleQuotes(token.string);
+						ch->c[index].value.string = (char *)GetMemory(strlen(token.string)+1);
+						strcpy(ch->c[index].value.string, token.string);
+						ch->c[index].type = CT_STRING;
+					} //end else if
+					else
+					{
+						SourceError(source, "expected integer, float or string, found %s\n", token.string);
+						FreeSource(source);
+						BotFreeCharacterStrings(ch);
+						FreeMemory(ch);
+						return NULL;
+					} //end else
+				} //end if
+				break;
+			} //end if
+			else
+			{
+				indent = 1;
+				while(indent)
+				{
+					if (!PC_ExpectAnyToken(source, &token))
+					{
+						FreeSource(source);
+						BotFreeCharacterStrings(ch);
+						FreeMemory(ch);
+						return NULL;
+					} //end if
+					if (!strcmp(token.string, "{")) indent++;
+					else if (!strcmp(token.string, "}")) indent--;
+				} //end while
+			} //end else
+		} //end if
+		else
+		{
+			SourceError(source, "unknown definition %s\n", token.string);
+			FreeSource(source);
+			BotFreeCharacterStrings(ch);
+			FreeMemory(ch);
+			return NULL;
+		} //end else
+	} //end while
+	FreeSource(source);
+	//
+	if (!foundcharacter)
+	{
+		BotFreeCharacterStrings(ch);
+		FreeMemory(ch);
+		return NULL;
+	} //end if
+	return ch;
+} //end of the function BotLoadCharacterFromFile
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+int BotFindCachedCharacter(char *charfile, float skill)
+{
+	int handle;
+
+	for (handle = 1; handle <= MAX_CLIENTS; handle++)
+	{
+		if ( !botcharacters[handle] ) continue;
+		if ( strcmp( botcharacters[handle]->filename, charfile ) == 0 &&
+			(skill < 0 || fabs(botcharacters[handle]->skill - skill) < 0.01) )
+		{
+			return handle;
+		} //end if
+	} //end for
+	return 0;
+} //end of the function BotFindCachedCharacter
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+int BotLoadCachedCharacter(char *charfile, float skill, int reload)
+{
+	int handle, cachedhandle, intskill;
+	bot_character_t *ch = NULL;
+#ifdef DEBUG
+	int starttime;
+
+	starttime = Sys_MilliSeconds();
+#endif //DEBUG
+
+	//find a free spot for a character
+	for (handle = 1; handle <= MAX_CLIENTS; handle++)
+	{
+		if (!botcharacters[handle]) break;
+	} //end for
+	if (handle > MAX_CLIENTS) return 0;
+	//try to load a cached character with the given skill
+	if (!reload)
+	{
+		cachedhandle = BotFindCachedCharacter(charfile, skill);
+		if (cachedhandle)
+		{
+			botimport.Print(PRT_MESSAGE, "loaded cached skill %f from %s\n", skill, charfile);
+			return cachedhandle;
+		} //end if
+	} //end else
+	//
+	intskill = (int) (skill + 0.5);
+	//try to load the character with the given skill
+	ch = BotLoadCharacterFromFile(charfile, intskill);
+	if (ch)
+	{
+		botcharacters[handle] = ch;
+		//
+		botimport.Print(PRT_MESSAGE, "loaded skill %d from %s\n", intskill, charfile);
+#ifdef DEBUG
+		if (bot_developer)
+		{
+			botimport.Print(PRT_MESSAGE, "skill %d loaded in %d msec from %s\n", intskill, Sys_MilliSeconds() - starttime, charfile);
+		} //end if
+#endif //DEBUG
+		return handle;
+	} //end if
+	//
+	botimport.Print(PRT_WARNING, "couldn't find skill %d in %s\n", intskill, charfile);
+	//
+	if (!reload)
+	{
+		//try to load a cached default character with the given skill
+		cachedhandle = BotFindCachedCharacter(DEFAULT_CHARACTER, skill);
+		if (cachedhandle)
+		{
+			botimport.Print(PRT_MESSAGE, "loaded cached default skill %d from %s\n", intskill, charfile);
+			return cachedhandle;
+		} //end if
+	} //end if
+	//try to load the default character with the given skill
+	ch = BotLoadCharacterFromFile(DEFAULT_CHARACTER, intskill);
+	if (ch)
+	{
+		botcharacters[handle] = ch;
+		botimport.Print(PRT_MESSAGE, "loaded default skill %d from %s\n", intskill, charfile);
+		return handle;
+	} //end if
+	//
+	if (!reload)
+	{
+		//try to load a cached character with any skill
+		cachedhandle = BotFindCachedCharacter(charfile, -1);
+		if (cachedhandle)
+		{
+			botimport.Print(PRT_MESSAGE, "loaded cached skill %f from %s\n", botcharacters[cachedhandle]->skill, charfile);
+			return cachedhandle;
+		} //end if
+	} //end if
+	//try to load a character with any skill
+	ch = BotLoadCharacterFromFile(charfile, -1);
+	if (ch)
+	{
+		botcharacters[handle] = ch;
+		botimport.Print(PRT_MESSAGE, "loaded skill %f from %s\n", ch->skill, charfile);
+		return handle;
+	} //end if
+	//
+	if (!reload)
+	{
+		//try to load a cached character with any skill
+		cachedhandle = BotFindCachedCharacter(DEFAULT_CHARACTER, -1);
+		if (cachedhandle)
+		{
+			botimport.Print(PRT_MESSAGE, "loaded cached default skill %f from %s\n", botcharacters[cachedhandle]->skill, charfile);
+			return cachedhandle;
+		} //end if
+	} //end if
+	//try to load a character with any skill
+	ch = BotLoadCharacterFromFile(DEFAULT_CHARACTER, -1);
+	if (ch)
+	{
+		botcharacters[handle] = ch;
+		botimport.Print(PRT_MESSAGE, "loaded default skill %f from %s\n", ch->skill, charfile);
+		return handle;
+	} //end if
+	//
+	botimport.Print(PRT_WARNING, "couldn't load any skill from %s\n", charfile);
+	//couldn't load any character
+	return 0;
+} //end of the function BotLoadCachedCharacter
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+int BotLoadCharacterSkill(char *charfile, float skill)
+{
+	int ch, defaultch;
+
+	defaultch = BotLoadCachedCharacter(DEFAULT_CHARACTER, skill, qfalse);
+	ch = BotLoadCachedCharacter(charfile, skill, LibVarGetValue("bot_reloadcharacters"));
+
+	if (defaultch && ch)
+	{
+		BotDefaultCharacteristics(botcharacters[ch], botcharacters[defaultch]);
+	} //end if
+
+	return ch;
+} //end of the function BotLoadCharacterSkill
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+int BotInterpolateCharacters(int handle1, int handle2, float desiredskill)
+{
+	bot_character_t *ch1, *ch2, *out;
+	int i, handle;
+	float scale;
+
+	ch1 = BotCharacterFromHandle(handle1);
+	ch2 = BotCharacterFromHandle(handle2);
+	if (!ch1 || !ch2)
+		return 0;
+	//find a free spot for a character
+	for (handle = 1; handle <= MAX_CLIENTS; handle++)
+	{
+		if (!botcharacters[handle]) break;
+	} //end for
+	if (handle > MAX_CLIENTS) return 0;
+	out = (bot_character_t *) GetClearedMemory(sizeof(bot_character_t) +
+					MAX_CHARACTERISTICS * sizeof(bot_characteristic_t));
+	out->skill = desiredskill;
+	strcpy(out->filename, ch1->filename);
+	botcharacters[handle] = out;
+
+	scale = (float) (desiredskill - ch1->skill) / (ch2->skill - ch1->skill);
+	for (i = 0; i < MAX_CHARACTERISTICS; i++)
+	{
+		//
+		if (ch1->c[i].type == CT_FLOAT && ch2->c[i].type == CT_FLOAT)
+		{
+			out->c[i].type = CT_FLOAT;
+			out->c[i].value._float = ch1->c[i].value._float +
+								(ch2->c[i].value._float - ch1->c[i].value._float) * scale;
+		} //end if
+		else if (ch1->c[i].type == CT_INTEGER)
+		{
+			out->c[i].type = CT_INTEGER;
+			out->c[i].value.integer = ch1->c[i].value.integer;
+		} //end else if
+		else if (ch1->c[i].type == CT_STRING)
+		{
+			out->c[i].type = CT_STRING;
+			out->c[i].value.string = (char *) GetMemory(strlen(ch1->c[i].value.string)+1);
+			strcpy(out->c[i].value.string, ch1->c[i].value.string);
+		} //end else if
+	} //end for
+	return handle;
+} //end of the function BotInterpolateCharacters
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+int BotLoadCharacter(char *charfile, float skill)
+{
+	int firstskill, secondskill, handle;
+
+	//make sure the skill is in the valid range
+	if (skill < 1.0) skill = 1.0;
+	else if (skill > 5.0) skill = 5.0;
+	//skill 1, 4 and 5 should be available in the character files
+	if (skill == 1.0 || skill == 4.0 || skill == 5.0)
+	{
+		return BotLoadCharacterSkill(charfile, skill);
+	} //end if
+	//check if there's a cached skill
+	handle = BotFindCachedCharacter(charfile, skill);
+	if (handle)
+	{
+		botimport.Print(PRT_MESSAGE, "loaded cached skill %f from %s\n", skill, charfile);
+		return handle;
+	} //end if
+	if (skill < 4.0)
+	{
+		//load skill 1 and 4
+		firstskill = BotLoadCharacterSkill(charfile, 1);
+		if (!firstskill) return 0;
+		secondskill = BotLoadCharacterSkill(charfile, 4);
+		if (!secondskill) return firstskill;
+	} //end if
+	else
+	{
+		//load skill 4 and 5
+		firstskill = BotLoadCharacterSkill(charfile, 4);
+		if (!firstskill) return 0;
+		secondskill = BotLoadCharacterSkill(charfile, 5);
+		if (!secondskill) return firstskill;
+	} //end else
+	//interpolate between the two skills
+	handle = BotInterpolateCharacters(firstskill, secondskill, skill);
+	if (!handle) return 0;
+	//write the character to the log file
+	BotDumpCharacter(botcharacters[handle]);
+	//
+	return handle;
+} //end of the function BotLoadCharacter
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+int CheckCharacteristicIndex(int character, int index)
+{
+	bot_character_t *ch;
+
+	ch = BotCharacterFromHandle(character);
+	if (!ch) return qfalse;
+	if (index < 0 || index >= MAX_CHARACTERISTICS)
+	{
+		botimport.Print(PRT_ERROR, "characteristic %d does not exist\n", index);
+		return qfalse;
+	} //end if
+	if (!ch->c[index].type)
+	{
+		botimport.Print(PRT_ERROR, "characteristic %d is not initialized\n", index);
+		return qfalse;
+	} //end if
+	return qtrue;
+} //end of the function CheckCharacteristicIndex
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+float Characteristic_Float(int character, int index)
+{
+	bot_character_t *ch;
+
+	ch = BotCharacterFromHandle(character);
+	if (!ch) return 0;
+	//check if the index is in range
+	if (!CheckCharacteristicIndex(character, index)) return 0;
+	//an integer will be converted to a float
+	if (ch->c[index].type == CT_INTEGER)
+	{
+		return (float) ch->c[index].value.integer;
+	} //end if
+	//floats are just returned
+	else if (ch->c[index].type == CT_FLOAT)
+	{
+		return ch->c[index].value._float;
+	} //end else if
+	//cannot convert a string pointer to a float
+	else
+	{
+		botimport.Print(PRT_ERROR, "characteristic %d is not a float\n", index);
+		return 0;
+	} //end else if
+//	return 0;
+} //end of the function Characteristic_Float
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+float Characteristic_BFloat(int character, int index, float min, float max)
+{
+	float value;
+	bot_character_t *ch;
+
+	ch = BotCharacterFromHandle(character);
+	if (!ch) return 0;
+	if (min > max)
+	{
+		botimport.Print(PRT_ERROR, "cannot bound characteristic %d between %f and %f\n", index, min, max);
+		return 0;
+	} //end if
+	value = Characteristic_Float(character, index);
+	if (value < min) return min;
+	if (value > max) return max;
+	return value;
+} //end of the function Characteristic_BFloat
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+int Characteristic_Integer(int character, int index)
+{
+	bot_character_t *ch;
+
+	ch = BotCharacterFromHandle(character);
+	if (!ch) return 0;
+	//check if the index is in range
+	if (!CheckCharacteristicIndex(character, index)) return 0;
+	//an integer will just be returned
+	if (ch->c[index].type == CT_INTEGER)
+	{
+		return ch->c[index].value.integer;
+	} //end if
+	//floats are casted to integers
+	else if (ch->c[index].type == CT_FLOAT)
+	{
+		return (int) ch->c[index].value._float;
+	} //end else if
+	else
+	{
+		botimport.Print(PRT_ERROR, "characteristic %d is not a integer\n", index);
+		return 0;
+	} //end else if
+//	return 0;
+} //end of the function Characteristic_Integer
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+int Characteristic_BInteger(int character, int index, int min, int max)
+{
+	int value;
+	bot_character_t *ch;
+
+	ch = BotCharacterFromHandle(character);
+	if (!ch) return 0;
+	if (min > max)
+	{
+		botimport.Print(PRT_ERROR, "cannot bound characteristic %d between %d and %d\n", index, min, max);
+		return 0;
+	} //end if
+	value = Characteristic_Integer(character, index);
+	if (value < min) return min;
+	if (value > max) return max;
+	return value;
+} //end of the function Characteristic_BInteger
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+void Characteristic_String(int character, int index, char *buf, int size)
+{
+	bot_character_t *ch;
+
+	ch = BotCharacterFromHandle(character);
+	if (!ch) return;
+	//check if the index is in range
+	if (!CheckCharacteristicIndex(character, index)) return;
+	//an integer will be converted to a float
+	if (ch->c[index].type == CT_STRING)
+	{
+		strncpy(buf, ch->c[index].value.string, size-1);
+		buf[size-1] = '\0';
+		return;
+	} //end if
+	else
+	{
+		botimport.Print(PRT_ERROR, "characteristic %d is not a string\n", index);
+		return;
+	} //end else if
+	return;
+} //end of the function Characteristic_String
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+void BotShutdownCharacters(void)
+{
+	int handle;
+
+	for (handle = 1; handle <= MAX_CLIENTS; handle++)
+	{
+		if (botcharacters[handle])
+		{
+			BotFreeCharacter2(handle);
+		} //end if
+	} //end for
+} //end of the function BotShutdownCharacters
+
diff --git a/codemp/botlib/be_ai_chat.cpp b/codemp/botlib/be_ai_chat.cpp
new file mode 100644
index 0000000..9dcf56f
--- /dev/null
+++ b/codemp/botlib/be_ai_chat.cpp
@@ -0,0 +1,3000 @@
+
+/*****************************************************************************
+ * name:		be_ai_chat.c
+ *
+ * desc:		bot chat AI
+ *
+ * $Archive: /MissionPack/code/botlib/be_ai_chat.c $
+ * $Author: Ttimo $ 
+ * $Revision: 12 $
+ * $Modtime: 4/13/01 4:45p $
+ * $Date: 4/13/01 4:45p $
+ *
+ *****************************************************************************/
+
+#include "../game/q_shared.h"
+#include "l_memory.h"
+#include "l_libvar.h"
+#include "l_script.h"
+#include "l_precomp.h"
+#include "l_struct.h"
+#include "l_utils.h"
+#include "l_log.h"
+#include "aasfile.h"
+#include "../game/botlib.h"
+#include "../game/be_aas.h"
+#include "be_aas_funcs.h"
+#include "be_interface.h"
+#include "../game/be_ea.h"
+#include "../game/be_ai_chat.h"
+
+
+//escape character
+#define ESCAPE_CHAR				0x01	//'_'
+//
+// "hi ", people, " ", 0, " entered the game"
+//becomes:
+// "hi _rpeople_ _v0_ entered the game"
+//
+
+//match piece types
+#define MT_VARIABLE					1		//variable match piece
+#define MT_STRING					2		//string match piece
+//reply chat key flags
+#define RCKFL_AND					1		//key must be present
+#define RCKFL_NOT					2		//key must be absent
+#define RCKFL_NAME					4		//name of bot must be present
+#define RCKFL_STRING				8		//key is a string
+#define RCKFL_VARIABLES				16		//key is a match template
+#define RCKFL_BOTNAMES				32		//key is a series of botnames
+#define RCKFL_GENDERFEMALE			64		//bot must be female
+#define RCKFL_GENDERMALE			128		//bot must be male
+#define RCKFL_GENDERLESS			256		//bot must be genderless
+//time to ignore a chat message after using it
+#define CHATMESSAGE_RECENTTIME	20
+
+//the actuall chat messages
+typedef struct bot_chatmessage_s
+{
+	char *chatmessage;					//chat message string
+	float time;							//last time used
+	struct bot_chatmessage_s *next;		//next chat message in a list
+} bot_chatmessage_t;
+//bot chat type with chat lines
+typedef struct bot_chattype_s
+{
+	char name[MAX_CHATTYPE_NAME];
+	int numchatmessages;
+	bot_chatmessage_t *firstchatmessage;
+	struct bot_chattype_s *next;
+} bot_chattype_t;
+//bot chat lines
+typedef struct bot_chat_s
+{
+	bot_chattype_t *types;
+} bot_chat_t;
+
+//random string
+typedef struct bot_randomstring_s
+{
+	char *string;
+	struct bot_randomstring_s *next;
+} bot_randomstring_t;
+//list with random strings
+typedef struct bot_randomlist_s
+{
+	char *string;
+	int numstrings;
+	bot_randomstring_t *firstrandomstring;
+	struct bot_randomlist_s *next;
+} bot_randomlist_t;
+
+//synonym
+typedef struct bot_synonym_s
+{
+	char *string;
+	float weight;
+	struct bot_synonym_s *next;
+} bot_synonym_t;
+//list with synonyms
+typedef struct bot_synonymlist_s
+{
+	unsigned long int context;
+	float totalweight;
+	bot_synonym_t *firstsynonym;
+	struct bot_synonymlist_s *next;
+} bot_synonymlist_t;
+
+//fixed match string
+typedef struct bot_matchstring_s
+{
+	char *string;
+	struct bot_matchstring_s *next;
+} bot_matchstring_t;
+
+//piece of a match template
+typedef struct bot_matchpiece_s
+{
+	int type;
+	bot_matchstring_t *firststring;
+	int variable;
+	struct bot_matchpiece_s *next;
+} bot_matchpiece_t;
+//match template
+typedef struct bot_matchtemplate_s
+{
+	unsigned long int context;
+	int type;
+	int subtype;
+	bot_matchpiece_t *first;
+	struct bot_matchtemplate_s *next;
+} bot_matchtemplate_t;
+
+//reply chat key
+typedef struct bot_replychatkey_s
+{
+	int flags;
+	char *string;
+	bot_matchpiece_t *match;
+	struct bot_replychatkey_s *next;
+} bot_replychatkey_t;
+//reply chat
+typedef struct bot_replychat_s
+{
+	bot_replychatkey_t *keys;
+	float priority;
+	int numchatmessages;
+	bot_chatmessage_t *firstchatmessage;
+	struct bot_replychat_s *next;
+} bot_replychat_t;
+
+//string list
+typedef struct bot_stringlist_s
+{
+	char *string;
+	struct bot_stringlist_s *next;
+} bot_stringlist_t;
+
+//chat state of a bot
+typedef struct bot_chatstate_s
+{
+	int gender;											//0=it, 1=female, 2=male
+	int client;											//client number
+	char name[32];										//name of the bot
+	char chatmessage[MAX_MESSAGE_SIZE];
+	int handle;
+	//the console messages visible to the bot
+	bot_consolemessage_t *firstmessage;			//first message is the first typed message
+	bot_consolemessage_t *lastmessage;			//last message is the last typed message, bottom of console
+	//number of console messages stored in the state
+	int numconsolemessages;
+	//the bot chat lines
+	bot_chat_t *chat;
+} bot_chatstate_t;
+
+typedef struct {
+	bot_chat_t	*chat;
+	char		filename[MAX_QPATH];
+	char		chatname[MAX_QPATH];
+} bot_ichatdata_t;
+
+bot_ichatdata_t	*ichatdata[MAX_CLIENTS];
+
+bot_chatstate_t *botchatstates[MAX_CLIENTS+1];
+//console message heap
+bot_consolemessage_t *consolemessageheap = NULL;
+bot_consolemessage_t *freeconsolemessages = NULL;
+//list with match strings
+bot_matchtemplate_t *matchtemplates = NULL;
+//list with synonyms
+bot_synonymlist_t *synonyms = NULL;
+//list with random strings
+bot_randomlist_t *randomstrings = NULL;
+//reply chats
+bot_replychat_t *replychats = NULL;
+
+//========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//========================================================================
+bot_chatstate_t *BotChatStateFromHandle(int handle)
+{
+	if (handle <= 0 || handle > MAX_CLIENTS)
+	{
+		botimport.Print(PRT_FATAL, "chat state handle %d out of range\n", handle);
+		return NULL;
+	} //end if
+	if (!botchatstates[handle])
+	{
+		botimport.Print(PRT_FATAL, "invalid chat state %d\n", handle);
+		return NULL;
+	} //end if
+	return botchatstates[handle];
+} //end of the function BotChatStateFromHandle
+//===========================================================================
+// initialize the heap with unused console messages
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void InitConsoleMessageHeap(void)
+{
+	int i, max_messages;
+
+	if (consolemessageheap) FreeMemory(consolemessageheap);
+	//
+	max_messages = (int) LibVarValue("max_messages", "1024");
+	consolemessageheap = (bot_consolemessage_t *) GetClearedHunkMemory(max_messages *
+												sizeof(bot_consolemessage_t));
+	consolemessageheap[0].prev = NULL;
+	consolemessageheap[0].next = &consolemessageheap[1];
+	for (i = 1; i < max_messages-1; i++)
+	{
+		consolemessageheap[i].prev = &consolemessageheap[i - 1];
+		consolemessageheap[i].next = &consolemessageheap[i + 1];
+	} //end for
+	consolemessageheap[max_messages-1].prev = &consolemessageheap[max_messages-2];
+	consolemessageheap[max_messages-1].next = NULL;
+	//pointer to the free console messages
+	freeconsolemessages = consolemessageheap;
+} //end of the function InitConsoleMessageHeap
+//===========================================================================
+// allocate one console message from the heap
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+bot_consolemessage_t *AllocConsoleMessage(void)
+{
+	bot_consolemessage_t *message;
+	message = freeconsolemessages;
+	if (freeconsolemessages) freeconsolemessages = freeconsolemessages->next;
+	if (freeconsolemessages) freeconsolemessages->prev = NULL;
+	return message;
+} //end of the function AllocConsoleMessage
+//===========================================================================
+// deallocate one console message from the heap
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void FreeConsoleMessage(bot_consolemessage_t *message)
+{
+	if (freeconsolemessages) freeconsolemessages->prev = message;
+	message->prev = NULL;
+	message->next = freeconsolemessages;
+	freeconsolemessages = message;
+} //end of the function FreeConsoleMessage
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void BotRemoveConsoleMessage(int chatstate, int handle)
+{
+	bot_consolemessage_t *m, *nextm;
+	bot_chatstate_t *cs;
+
+	cs = BotChatStateFromHandle(chatstate);
+	if (!cs) return;
+
+	for (m = cs->firstmessage; m; m = nextm)
+	{
+		nextm = m->next;
+		if (m->handle == handle)
+		{
+			if (m->next) m->next->prev = m->prev;
+			else cs->lastmessage = m->prev;
+			if (m->prev) m->prev->next = m->next;
+			else cs->firstmessage = m->next;
+
+			FreeConsoleMessage(m);
+			cs->numconsolemessages--;
+			break;
+		} //end if
+	} //end for
+} //end of the function BotRemoveConsoleMessage
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void BotQueueConsoleMessage(int chatstate, int type, char *message)
+{
+	bot_consolemessage_t *m;
+	bot_chatstate_t *cs;
+
+	cs = BotChatStateFromHandle(chatstate);
+	if (!cs) return;
+
+	m = AllocConsoleMessage();
+	if (!m)
+	{
+		botimport.Print(PRT_ERROR, "empty console message heap\n");
+		return;
+	} //end if
+	cs->handle++;
+	if (cs->handle <= 0 || cs->handle > 8192) cs->handle = 1;
+	m->handle = cs->handle;
+	m->time = AAS_Time();
+	m->type = type;
+	strncpy(m->message, message, MAX_MESSAGE_SIZE);
+	m->next = NULL;
+	if (cs->lastmessage)
+	{
+		cs->lastmessage->next = m;
+		m->prev = cs->lastmessage;
+		cs->lastmessage = m;
+	} //end if
+	else
+	{
+		cs->lastmessage = m;
+		cs->firstmessage = m;
+		m->prev = NULL;
+	} //end if
+	cs->numconsolemessages++;
+} //end of the function BotQueueConsoleMessage
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int BotNextConsoleMessage(int chatstate, bot_consolemessage_t *cm)
+{
+	bot_chatstate_t *cs;
+
+	cs = BotChatStateFromHandle(chatstate);
+	if (!cs) return 0;
+	if (cs->firstmessage)
+	{
+		Com_Memcpy(cm, cs->firstmessage, sizeof(bot_consolemessage_t));
+		cm->next = cm->prev = NULL;
+		return cm->handle;
+	} //end if
+	return 0;
+} //end of the function BotConsoleMessage
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int BotNumConsoleMessages(int chatstate)
+{
+	bot_chatstate_t *cs;
+
+	cs = BotChatStateFromHandle(chatstate);
+	if (!cs) return 0;
+	return cs->numconsolemessages;
+} //end of the function BotNumConsoleMessages
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int IsWhiteSpace(char c)
+{
+	if ((c >= 'a' && c <= 'z')
+		|| (c >= 'A' && c <= 'Z')
+		|| (c >= '0' && c <= '9')
+		|| c == '(' || c == ')'
+		|| c == '?' || c == ':'
+		|| c == '\''|| c == '/'
+		|| c == ',' || c == '.'
+		|| c == '['	|| c == ']'
+		|| c == '-' || c == '_'
+		|| c == '+' || c == '=') return qfalse;
+	return qtrue;
+} //end of the function IsWhiteSpace
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+void BotRemoveTildes(char *message)
+{
+	int i;
+
+	//remove all tildes from the chat message
+	for (i = 0; message[i]; i++)
+	{
+		if (message[i] == '~')
+		{
+			memmove(&message[i], &message[i+1], strlen(&message[i+1])+1);
+		} //end if
+	} //end for
+} //end of the function BotRemoveTildes
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void UnifyWhiteSpaces(char *string)
+{
+	char *ptr, *oldptr;
+
+	for (ptr = oldptr = string; *ptr; oldptr = ptr)
+	{
+		while(*ptr && IsWhiteSpace(*ptr)) ptr++;
+		if (ptr > oldptr)
+		{
+			//if not at the start and not at the end of the string
+			//write only one space
+			if (oldptr > string && *ptr) *oldptr++ = ' ';
+			//remove all other white spaces
+			if (ptr > oldptr) memmove(oldptr, ptr, strlen(ptr)+1);
+		} //end if
+		while(*ptr && !IsWhiteSpace(*ptr)) ptr++;
+	} //end while
+} //end of the function UnifyWhiteSpaces
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int StringContains(char *str1, char *str2, int casesensitive)
+{
+	int len, i, j, index;
+
+	if (str1 == NULL || str2 == NULL) return -1;
+
+	len = strlen(str1) - strlen(str2);
+	index = 0;
+	for (i = 0; i <= len; i++, str1++, index++)
+	{
+		for (j = 0; str2[j]; j++)
+		{
+			if (casesensitive)
+			{
+				if (str1[j] != str2[j]) break;
+			} //end if
+			else
+			{
+				if (toupper(str1[j]) != toupper(str2[j])) break;
+			} //end else
+		} //end for
+		if (!str2[j]) return index;
+	} //end for
+	return -1;
+} //end of the function StringContains
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+char *StringContainsWord(char *str1, char *str2, int casesensitive)
+{
+	int len, i, j;
+
+	len = strlen(str1) - strlen(str2);
+	for (i = 0; i <= len; i++, str1++)
+	{
+		//if not at the start of the string
+		if (i)
+		{
+			//skip to the start of the next word
+			while(*str1 && *str1 != ' ' && *str1 != '.' && *str1 != ',' && *str1 != '!') str1++;
+			if (!*str1) break;
+			str1++;
+		} //end for
+		//compare the word
+		for (j = 0; str2[j]; j++)
+		{
+			if (casesensitive)
+			{
+				if (str1[j] != str2[j]) break;
+			} //end if
+			else
+			{
+				if (toupper(str1[j]) != toupper(str2[j])) break;
+			} //end else
+		} //end for
+		//if there was a word match
+		if (!str2[j])
+		{
+			//if the first string has an end of word
+			if (!str1[j] || str1[j] == ' ' || str1[j] == '.' || str1[j] == ',' || str1[j] == '!') return str1;
+		} //end if
+	} //end for
+	return NULL;
+} //end of the function StringContainsWord
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void StringReplaceWords(char *string, char *synonym, char *replacement)
+{
+	char *str, *str2;
+
+	//find the synonym in the string
+	str = StringContainsWord(string, synonym, qfalse);
+	//if the synonym occured in the string
+	while(str)
+	{
+		//if the synonym isn't part of the replacement which is already in the string
+		//usefull for abreviations
+		str2 = StringContainsWord(string, replacement, qfalse);
+		while(str2)
+		{
+			if (str2 <= str && str < str2 + strlen(replacement)) break;
+			str2 = StringContainsWord(str2+1, replacement, qfalse);
+		} //end while
+		if (!str2)
+		{
+			memmove(str + strlen(replacement), str+strlen(synonym), strlen(str+strlen(synonym))+1);
+			//append the synonum replacement
+			Com_Memcpy(str, replacement, strlen(replacement));
+		} //end if
+		//find the next synonym in the string
+		str = StringContainsWord(str+strlen(replacement), synonym, qfalse);
+	} //end if
+} //end of the function StringReplaceWords
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void BotDumpSynonymList(bot_synonymlist_t *synlist)
+{
+	FILE *fp;
+	bot_synonymlist_t *syn;
+	bot_synonym_t *synonym;
+
+	fp = Log_FilePointer();
+	if (!fp) return;
+	for (syn = synlist; syn; syn = syn->next)
+	{
+	        fprintf(fp, "%ld : [", syn->context);
+		for (synonym = syn->firstsynonym; synonym; synonym = synonym->next)
+		{
+			fprintf(fp, "(\"%s\", %1.2f)", synonym->string, synonym->weight);
+			if (synonym->next) fprintf(fp, ", ");
+		} //end for
+		fprintf(fp, "]\n");
+	} //end for
+} //end of the function BotDumpSynonymList
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+bot_synonymlist_t *BotLoadSynonyms(char *filename)
+{
+	int pass, size, contextlevel, numsynonyms;
+	unsigned long int context, contextstack[32];
+	char *ptr = NULL;
+	source_t *source;
+	token_t token;
+	bot_synonymlist_t *synlist, *lastsyn, *syn;
+	bot_synonym_t *synonym, *lastsynonym;
+
+	size = 0;
+	synlist = NULL; //make compiler happy
+	syn = NULL; //make compiler happy
+	synonym = NULL; //make compiler happy
+	//the synonyms are parsed in two phases
+	for (pass = 0; pass < 2; pass++)
+	{
+		//
+		if (pass && size) ptr = (char *) GetClearedHunkMemory(size);
+		//
+		PC_SetBaseFolder(BOTFILESBASEFOLDER);
+		source = LoadSourceFile(filename);
+		if (!source)
+		{
+			botimport.Print(PRT_ERROR, "counldn't load %s\n", filename);
+			return NULL;
+		} //end if
+		//
+		context = 0;
+		contextlevel = 0;
+		synlist = NULL; //list synonyms
+		lastsyn = NULL; //last synonym in the list
+		//
+		while(PC_ReadToken(source, &token))
+		{
+			if (token.type == TT_NUMBER)
+			{
+				context |= token.intvalue;
+				contextstack[contextlevel] = token.intvalue;
+				contextlevel++;
+				if (contextlevel >= 32)
+				{
+					SourceError(source, "more than 32 context levels");
+					FreeSource(source);
+					return NULL;
+				} //end if
+				if (!PC_ExpectTokenString(source, "{"))
+				{
+					FreeSource(source);
+					return NULL;
+				} //end if
+			} //end if
+			else if (token.type == TT_PUNCTUATION)
+			{
+				if (!strcmp(token.string, "}"))
+				{
+					contextlevel--;
+					if (contextlevel < 0)
+					{
+						SourceError(source, "too many }");
+						FreeSource(source);
+						return NULL;
+					} //end if
+					context &= ~contextstack[contextlevel];
+				} //end if
+				else if (!strcmp(token.string, "["))
+				{
+					size += sizeof(bot_synonymlist_t);
+					if (pass)
+					{
+						syn = (bot_synonymlist_t *) ptr;
+						ptr += sizeof(bot_synonymlist_t);
+						syn->context = context;
+						syn->firstsynonym = NULL;
+						syn->next = NULL;
+						if (lastsyn) lastsyn->next = syn;
+						else synlist = syn;
+						lastsyn = syn;
+					} //end if
+					numsynonyms = 0;
+					lastsynonym = NULL;
+					while(1)
+					{
+						if (!PC_ExpectTokenString(source, "(") ||
+							!PC_ExpectTokenType(source, TT_STRING, 0, &token))
+						{
+							FreeSource(source);
+							return NULL;
+						} //end if
+						StripDoubleQuotes(token.string);
+						if (strlen(token.string) <= 0)
+						{
+							SourceError(source, "empty string", token.string);
+							FreeSource(source);
+							return NULL;
+						} //end if
+						size += sizeof(bot_synonym_t) + strlen(token.string) + 1;
+						if (pass)
+						{
+							synonym = (bot_synonym_t *) ptr;
+							ptr += sizeof(bot_synonym_t);
+							synonym->string = ptr;
+							ptr += strlen(token.string) + 1;
+							strcpy(synonym->string, token.string);
+							//
+							if (lastsynonym) lastsynonym->next = synonym;
+							else syn->firstsynonym = synonym;
+							lastsynonym = synonym;
+						} //end if
+						numsynonyms++;
+						if (!PC_ExpectTokenString(source, ",") ||
+							!PC_ExpectTokenType(source, TT_NUMBER, 0, &token) ||
+							!PC_ExpectTokenString(source, ")"))
+						{
+							FreeSource(source);
+							return NULL;
+						} //end if
+						if (pass)
+						{
+							synonym->weight = token.floatvalue;
+							syn->totalweight += synonym->weight;
+						} //end if
+						if (PC_CheckTokenString(source, "]")) break;
+						if (!PC_ExpectTokenString(source, ","))
+						{
+							FreeSource(source);
+							return NULL;
+						} //end if
+					} //end while
+					if (numsynonyms < 2)
+					{
+						SourceError(source, "synonym must have at least two entries\n");
+						FreeSource(source);
+						return NULL;
+					} //end if
+				} //end else
+				else
+				{
+					SourceError(source, "unexpected %s", token.string);
+					FreeSource(source);
+					return NULL;
+				} //end if
+			} //end else if
+		} //end while
+		//
+		FreeSource(source);
+		//
+		if (contextlevel > 0)
+		{
+			SourceError(source, "missing }");
+			return NULL;
+		} //end if
+	} //end for
+	botimport.Print(PRT_MESSAGE, "loaded %s\n", filename);
+	//
+	//BotDumpSynonymList(synlist);
+	//
+	return synlist;
+} //end of the function BotLoadSynonyms
+//===========================================================================
+// replace all the synonyms in the string
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void BotReplaceSynonyms(char *string, unsigned long int context)
+{
+	bot_synonymlist_t *syn;
+	bot_synonym_t *synonym;
+
+	for (syn = synonyms; syn; syn = syn->next)
+	{
+		if (!(syn->context & context)) continue;
+		for (synonym = syn->firstsynonym->next; synonym; synonym = synonym->next)
+		{
+			StringReplaceWords(string, synonym->string, syn->firstsynonym->string);
+		} //end for
+	} //end for
+} //end of the function BotReplaceSynonyms
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void BotReplaceWeightedSynonyms(char *string, unsigned long int context)
+{
+	bot_synonymlist_t *syn;
+	bot_synonym_t *synonym, *replacement;
+	float weight, curweight;
+
+	for (syn = synonyms; syn; syn = syn->next)
+	{
+		if (!(syn->context & context)) continue;
+		//choose a weighted random replacement synonym
+		weight = random() * syn->totalweight;
+		if (!weight) continue;
+		curweight = 0;
+		for (replacement = syn->firstsynonym; replacement; replacement = replacement->next)
+		{
+			curweight += replacement->weight;
+			if (weight < curweight) break;
+		} //end for
+		if (!replacement) continue;
+		//replace all synonyms with the replacement
+		for (synonym = syn->firstsynonym; synonym; synonym = synonym->next)
+		{
+			if (synonym == replacement) continue;
+			StringReplaceWords(string, synonym->string, replacement->string);
+		} //end for
+	} //end for
+} //end of the function BotReplaceWeightedSynonyms
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void BotReplaceReplySynonyms(char *string, unsigned long int context)
+{
+	char *str1, *str2, *replacement;
+	bot_synonymlist_t *syn;
+	bot_synonym_t *synonym;
+
+	for (str1 = string; *str1; )
+	{
+		//go to the start of the next word
+		while(*str1 && *str1 <= ' ') str1++;
+		if (!*str1) break;
+		//
+		for (syn = synonyms; syn; syn = syn->next)
+		{
+			if (!(syn->context & context)) continue;
+			for (synonym = syn->firstsynonym->next; synonym; synonym = synonym->next)
+			{
+				str2 = synonym->string;
+				//if the synonym is not at the front of the string continue
+				str2 = StringContainsWord(str1, synonym->string, qfalse);
+				if (!str2 || str2 != str1) continue;
+				//
+				replacement = syn->firstsynonym->string;
+				//if the replacement IS in front of the string continue
+				str2 = StringContainsWord(str1, replacement, qfalse);
+				if (str2 && str2 == str1) continue;
+				//
+				memmove(str1 + strlen(replacement), str1+strlen(synonym->string),
+							strlen(str1+strlen(synonym->string)) + 1);
+				//append the synonum replacement
+				Com_Memcpy(str1, replacement, strlen(replacement));
+				//
+				break;
+			} //end for
+			//if a synonym has been replaced
+			if (synonym) break;
+		} //end for
+		//skip over this word
+		while(*str1 && *str1 > ' ') str1++;
+		if (!*str1) break;
+	} //end while
+} //end of the function BotReplaceReplySynonyms
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+int BotLoadChatMessage(source_t *source, char *chatmessagestring)
+{
+	char *ptr;
+	token_t token;
+
+	ptr = chatmessagestring;
+	*ptr = 0;
+	//
+	while(1)
+	{
+		if (!PC_ExpectAnyToken(source, &token)) return qfalse;
+		//fixed string
+		if (token.type == TT_STRING)
+		{
+			StripDoubleQuotes(token.string);
+			if (strlen(ptr) + strlen(token.string) + 1 > MAX_MESSAGE_SIZE)
+			{
+				SourceError(source, "chat message too long\n");
+				return qfalse;
+			} //end if
+			strcat(ptr, token.string);
+		} //end else if
+		//variable string
+		else if (token.type == TT_NUMBER && (token.subtype & TT_INTEGER))
+		{
+			if (strlen(ptr) + 7 > MAX_MESSAGE_SIZE)
+			{
+				SourceError(source, "chat message too long\n");
+				return qfalse;
+			} //end if
+			sprintf(&ptr[strlen(ptr)], "%cv%ld%c", ESCAPE_CHAR, token.intvalue, ESCAPE_CHAR);
+		} //end if
+		//random string
+		else if (token.type == TT_NAME)
+		{
+			if (strlen(ptr) + 7 > MAX_MESSAGE_SIZE)
+			{
+				SourceError(source, "chat message too long\n");
+				return qfalse;
+			} //end if
+			sprintf(&ptr[strlen(ptr)], "%cr%s%c", ESCAPE_CHAR, token.string, ESCAPE_CHAR);
+		} //end else if
+		else
+		{
+			SourceError(source, "unknown message component %s\n", token.string);
+			return qfalse;
+		} //end else
+		if (PC_CheckTokenString(source, ";")) break;
+		if (!PC_ExpectTokenString(source, ",")) return qfalse;
+	} //end while
+	//
+	return qtrue;
+} //end of the function BotLoadChatMessage
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void BotDumpRandomStringList(bot_randomlist_t *randomlist)
+{
+	FILE *fp;
+	bot_randomlist_t *random;
+	bot_randomstring_t *rs;
+
+	fp = Log_FilePointer();
+	if (!fp) return;
+	for (random = randomlist; random; random = random->next)
+	{
+		fprintf(fp, "%s = {", random->string);
+		for (rs = random->firstrandomstring; rs; rs = rs->next)
+		{
+			fprintf(fp, "\"%s\"", rs->string);
+			if (rs->next) fprintf(fp, ", ");
+			else fprintf(fp, "}\n");
+		} //end for
+	} //end for
+} //end of the function BotDumpRandomStringList
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+bot_randomlist_t *BotLoadRandomStrings(char *filename)
+{
+	int pass, size;
+	char *ptr = NULL, chatmessagestring[MAX_MESSAGE_SIZE];
+	source_t *source;
+	token_t token;
+	bot_randomlist_t *randomlist, *lastrandom, *random;
+	bot_randomstring_t *randomstring;
+
+#ifdef DEBUG
+	int starttime = Sys_MilliSeconds();
+#endif //DEBUG
+
+	size = 0;
+	randomlist = NULL;
+	random = NULL;
+	//the synonyms are parsed in two phases
+	for (pass = 0; pass < 2; pass++)
+	{
+		//
+		if (pass && size) ptr = (char *) GetClearedHunkMemory(size);
+		//
+		PC_SetBaseFolder(BOTFILESBASEFOLDER);
+		source = LoadSourceFile(filename);
+		if (!source)
+		{
+			botimport.Print(PRT_ERROR, "counldn't load %s\n", filename);
+			return NULL;
+		} //end if
+		//
+		randomlist = NULL; //list
+		lastrandom = NULL; //last
+		//
+		while(PC_ReadToken(source, &token))
+		{
+			if (token.type != TT_NAME)
+			{
+				SourceError(source, "unknown random %s", token.string);
+				FreeSource(source);
+				return NULL;
+			} //end if
+			size += sizeof(bot_randomlist_t) + strlen(token.string) + 1;
+			if (pass)
+			{
+				random = (bot_randomlist_t *) ptr;
+				ptr += sizeof(bot_randomlist_t);
+				random->string = ptr;
+				ptr += strlen(token.string) + 1;
+				strcpy(random->string, token.string);
+				random->firstrandomstring = NULL;
+				random->numstrings = 0;
+				//
+				if (lastrandom) lastrandom->next = random;
+				else randomlist = random;
+				lastrandom = random;
+			} //end if
+			if (!PC_ExpectTokenString(source, "=") ||
+				!PC_ExpectTokenString(source, "{"))
+			{
+				FreeSource(source);
+				return NULL;
+			} //end if
+			while(!PC_CheckTokenString(source, "}"))
+			{
+				if (!BotLoadChatMessage(source, chatmessagestring))
+				{
+					FreeSource(source);
+					return NULL;
+				} //end if
+				size += sizeof(bot_randomstring_t) + strlen(chatmessagestring) + 1;
+				if (pass)
+				{
+					randomstring = (bot_randomstring_t *) ptr;
+					ptr += sizeof(bot_randomstring_t);
+					randomstring->string = ptr;
+					ptr += strlen(chatmessagestring) + 1;
+					strcpy(randomstring->string, chatmessagestring);
+					//
+					random->numstrings++;
+					randomstring->next = random->firstrandomstring;
+					random->firstrandomstring = randomstring;
+				} //end if
+			} //end while
+		} //end while
+		//free the source after one pass
+		FreeSource(source);
+	} //end for
+	botimport.Print(PRT_MESSAGE, "loaded %s\n", filename);
+	//
+#ifdef DEBUG
+	botimport.Print(PRT_MESSAGE, "random strings %d msec\n", Sys_MilliSeconds() - starttime);
+	//BotDumpRandomStringList(randomlist);
+#endif //DEBUG
+	//
+	return randomlist;
+} //end of the function BotLoadRandomStrings
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+char *RandomString(char *name)
+{
+	bot_randomlist_t *random;
+	bot_randomstring_t *rs;
+	int i;
+
+	for (random = randomstrings; random; random = random->next)
+	{
+		if (!strcmp(random->string, name))
+		{
+			i = random() * random->numstrings;
+			for (rs = random->firstrandomstring; rs; rs = rs->next)
+			{
+				if (--i < 0) break;
+			} //end for
+			if (rs)
+			{
+				return rs->string;
+			} //end if
+		} //end for
+	} //end for
+	return NULL;
+} //end of the function RandomString
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void BotDumpMatchTemplates(bot_matchtemplate_t *matches)
+{
+	FILE *fp;
+	bot_matchtemplate_t *mt;
+	bot_matchpiece_t *mp;
+	bot_matchstring_t *ms;
+
+	fp = Log_FilePointer();
+	if (!fp) return;
+	for (mt = matches; mt; mt = mt->next)
+	{
+	        fprintf(fp, "{ " );
+		for (mp = mt->first; mp; mp = mp->next)
+		{
+			if (mp->type == MT_STRING)
+			{
+				for (ms = mp->firststring; ms; ms = ms->next)
+				{
+					fprintf(fp, "\"%s\"", ms->string);
+					if (ms->next) fprintf(fp, "|");
+				} //end for
+			} //end if
+			else if (mp->type == MT_VARIABLE)
+			{
+				fprintf(fp, "%d", mp->variable);
+			} //end else if
+			if (mp->next) fprintf(fp, ", ");
+		} //end for
+		fprintf(fp, " = (%d, %d);}\n", mt->type, mt->subtype);
+	} //end for
+} //end of the function BotDumpMatchTemplates
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void BotFreeMatchPieces(bot_matchpiece_t *matchpieces)
+{
+	bot_matchpiece_t *mp, *nextmp;
+	bot_matchstring_t *ms, *nextms;
+
+	for (mp = matchpieces; mp; mp = nextmp)
+	{
+		nextmp = mp->next;
+		if (mp->type == MT_STRING)
+		{
+			for (ms = mp->firststring; ms; ms = nextms)
+			{
+				nextms = ms->next;
+				FreeMemory(ms);
+			} //end for
+		} //end if
+		FreeMemory(mp);
+	} //end for
+} //end of the function BotFreeMatchPieces
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+bot_matchpiece_t *BotLoadMatchPieces(source_t *source, char *endtoken)
+{
+	int lastwasvariable, emptystring;
+	token_t token;
+	bot_matchpiece_t *matchpiece, *firstpiece, *lastpiece;
+	bot_matchstring_t *matchstring, *lastmatchstring;
+
+	firstpiece = NULL;
+	lastpiece = NULL;
+	//
+	lastwasvariable = qfalse;
+	//
+	while(PC_ReadToken(source, &token))
+	{
+		if (token.type == TT_NUMBER && (token.subtype & TT_INTEGER))
+		{
+			if (token.intvalue < 0 || token.intvalue >= MAX_MATCHVARIABLES)
+			{
+				SourceError(source, "can't have more than %d match variables\n", MAX_MATCHVARIABLES);
+				FreeSource(source);
+				BotFreeMatchPieces(firstpiece);
+				return NULL;
+			} //end if
+			if (lastwasvariable)
+			{
+				SourceError(source, "not allowed to have adjacent variables\n");
+				FreeSource(source);
+				BotFreeMatchPieces(firstpiece);
+				return NULL;
+			} //end if
+			lastwasvariable = qtrue;
+			//
+			matchpiece = (bot_matchpiece_t *) GetClearedHunkMemory(sizeof(bot_matchpiece_t));
+			matchpiece->type = MT_VARIABLE;
+			matchpiece->variable = token.intvalue;
+			matchpiece->next = NULL;
+			if (lastpiece) lastpiece->next = matchpiece;
+			else firstpiece = matchpiece;
+			lastpiece = matchpiece;
+		} //end if
+		else if (token.type == TT_STRING)
+		{
+			//
+			matchpiece = (bot_matchpiece_t *) GetClearedHunkMemory(sizeof(bot_matchpiece_t));
+			matchpiece->firststring = NULL;
+			matchpiece->type = MT_STRING;
+			matchpiece->variable = 0;
+			matchpiece->next = NULL;
+			if (lastpiece) lastpiece->next = matchpiece;
+			else firstpiece = matchpiece;
+			lastpiece = matchpiece;
+			//
+			lastmatchstring = NULL;
+			emptystring = qfalse;
+			//
+			do
+			{
+				if (matchpiece->firststring)
+				{
+					if (!PC_ExpectTokenType(source, TT_STRING, 0, &token))
+					{
+						FreeSource(source);
+						BotFreeMatchPieces(firstpiece);
+						return NULL;
+					} //end if
+				} //end if
+				StripDoubleQuotes(token.string);
+				matchstring = (bot_matchstring_t *) GetClearedHunkMemory(sizeof(bot_matchstring_t) + strlen(token.string) + 1);
+				matchstring->string = (char *) matchstring + sizeof(bot_matchstring_t);
+				strcpy(matchstring->string, token.string);
+				if (!strlen(token.string)) emptystring = qtrue;
+				matchstring->next = NULL;
+				if (lastmatchstring) lastmatchstring->next = matchstring;
+				else matchpiece->firststring = matchstring;
+				lastmatchstring = matchstring;
+			} while(PC_CheckTokenString(source, "|"));
+			//if there was no empty string found
+			if (!emptystring) lastwasvariable = qfalse;
+		} //end if
+		else
+		{
+			SourceError(source, "invalid token %s\n", token.string);
+			FreeSource(source);
+			BotFreeMatchPieces(firstpiece);
+			return NULL;
+		} //end else
+		if (PC_CheckTokenString(source, endtoken)) break;
+		if (!PC_ExpectTokenString(source, ","))
+		{
+			FreeSource(source);
+			BotFreeMatchPieces(firstpiece);
+			return NULL;
+		} //end if
+	} //end while
+	return firstpiece;
+} //end of the function BotLoadMatchPieces
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void BotFreeMatchTemplates(bot_matchtemplate_t *mt)
+{
+	bot_matchtemplate_t *nextmt;
+
+	for (; mt; mt = nextmt)
+	{
+		nextmt = mt->next;
+		BotFreeMatchPieces(mt->first);
+		FreeMemory(mt);
+	} //end for
+} //end of the function BotFreeMatchTemplates
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+bot_matchtemplate_t *BotLoadMatchTemplates(char *matchfile)
+{
+	source_t *source;
+	token_t token;
+	bot_matchtemplate_t *matchtemplate, *matches, *lastmatch;
+	unsigned long int context;
+
+	PC_SetBaseFolder(BOTFILESBASEFOLDER);
+	source = LoadSourceFile(matchfile);
+	if (!source)
+	{
+		botimport.Print(PRT_ERROR, "counldn't load %s\n", matchfile);
+		return NULL;
+	} //end if
+	//
+	matches = NULL; //list with matches
+	lastmatch = NULL; //last match in the list
+
+	while(PC_ReadToken(source, &token))
+	{
+		if (token.type != TT_NUMBER || !(token.subtype & TT_INTEGER))
+		{
+			SourceError(source, "expected integer, found %s\n", token.string);
+			BotFreeMatchTemplates(matches);
+			FreeSource(source);
+			return NULL;
+		} //end if
+		//the context
+		context = token.intvalue;
+		//
+		if (!PC_ExpectTokenString(source, "{"))
+		{
+			BotFreeMatchTemplates(matches);
+			FreeSource(source);
+			return NULL;
+		} //end if
+		//
+		while(PC_ReadToken(source, &token))
+		{
+			if (!strcmp(token.string, "}")) break;
+			//
+			PC_UnreadLastToken(source);
+			//
+			matchtemplate = (bot_matchtemplate_t *) GetClearedHunkMemory(sizeof(bot_matchtemplate_t));
+			matchtemplate->context = context;
+			matchtemplate->next = NULL;
+			//add the match template to the list
+			if (lastmatch) lastmatch->next = matchtemplate;
+			else matches = matchtemplate;
+			lastmatch = matchtemplate;
+			//load the match template
+			matchtemplate->first = BotLoadMatchPieces(source, "=");
+			if (!matchtemplate->first)
+			{
+				BotFreeMatchTemplates(matches);
+				return NULL;
+			} //end if
+			//read the match type
+			if (!PC_ExpectTokenString(source, "(") ||
+				!PC_ExpectTokenType(source, TT_NUMBER, TT_INTEGER, &token))
+			{
+				BotFreeMatchTemplates(matches);
+				FreeSource(source);
+				return NULL;
+			} //end if
+			matchtemplate->type = token.intvalue;
+			//read the match subtype
+			if (!PC_ExpectTokenString(source, ",") ||
+				!PC_ExpectTokenType(source, TT_NUMBER, TT_INTEGER, &token))
+			{
+				BotFreeMatchTemplates(matches);
+				FreeSource(source);
+				return NULL;
+			} //end if
+			matchtemplate->subtype = token.intvalue;
+			//read trailing punctuations
+			if (!PC_ExpectTokenString(source, ")") ||
+				!PC_ExpectTokenString(source, ";"))
+			{
+				BotFreeMatchTemplates(matches);
+				FreeSource(source);
+				return NULL;
+			} //end if
+		} //end while
+	} //end while
+	//free the source
+	FreeSource(source);
+	botimport.Print(PRT_MESSAGE, "loaded %s\n", matchfile);
+	//
+	//BotDumpMatchTemplates(matches);
+	//
+	return matches;
+} //end of the function BotLoadMatchTemplates
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int StringsMatch(bot_matchpiece_t *pieces, bot_match_t *match)
+{
+	int lastvariable, index;
+	char *strptr, *newstrptr;
+	bot_matchpiece_t *mp;
+	bot_matchstring_t *ms;
+
+	//no last variable
+	lastvariable = -1;
+	//pointer to the string to compare the match string with
+	strptr = match->string;
+	//Log_Write("match: %s", strptr);
+	//compare the string with the current match string
+	for (mp = pieces; mp; mp = mp->next)
+	{
+		//if it is a piece of string
+		if (mp->type == MT_STRING)
+		{
+			newstrptr = NULL;
+			for (ms = mp->firststring; ms; ms = ms->next)
+			{
+				if (!strlen(ms->string))
+				{
+					newstrptr = strptr;
+					break;
+				} //end if
+				//Log_Write("MT_STRING: %s", mp->string);
+				index = StringContains(strptr, ms->string, qfalse);
+				if (index >= 0)
+				{
+					newstrptr = strptr + index;
+					if (lastvariable >= 0)
+					{
+						match->variables[lastvariable].length =
+								(newstrptr - match->string) - match->variables[lastvariable].offset;
+								//newstrptr - match->variables[lastvariable].ptr;
+						lastvariable = -1;
+						break;
+					} //end if
+					else if (index == 0)
+					{
+						break;
+					} //end else
+					newstrptr = NULL;
+				} //end if
+			} //end for
+			if (!newstrptr) return qfalse;
+			strptr = newstrptr + strlen(ms->string);
+		} //end if
+		//if it is a variable piece of string
+		else if (mp->type == MT_VARIABLE)
+		{
+			//Log_Write("MT_VARIABLE");
+			match->variables[mp->variable].offset = strptr - match->string;
+			lastvariable = mp->variable;
+		} //end else if
+	} //end for
+	//if a match was found
+	if (!mp && (lastvariable >= 0 || !strlen(strptr)))
+	{
+		//if the last piece was a variable string
+		if (lastvariable >= 0)
+		{
+        		assert( match->variables[lastvariable].offset >= 0 ); // bk001204
+			match->variables[lastvariable].length =
+				strlen(&match->string[ (int) match->variables[lastvariable].offset]);
+		} //end if
+		return qtrue;
+	} //end if
+	return qfalse;
+} //end of the function StringsMatch
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int BotFindMatch(char *str, bot_match_t *match, unsigned long int context)
+{
+	int i;
+	bot_matchtemplate_t *ms;
+
+	strncpy(match->string, str, MAX_MESSAGE_SIZE);
+	//remove any trailing enters
+	while(strlen(match->string) &&
+			match->string[strlen(match->string)-1] == '\n')
+	{
+		match->string[strlen(match->string)-1] = '\0';
+	} //end while
+	//compare the string with all the match strings
+	for (ms = matchtemplates; ms; ms = ms->next)
+	{
+		if (!(ms->context & context)) continue;
+		//reset the match variable offsets
+		for (i = 0; i < MAX_MATCHVARIABLES; i++) match->variables[i].offset = -1;
+		//
+		if (StringsMatch(ms->first, match))
+		{
+			match->type = ms->type;
+			match->subtype = ms->subtype;
+			return qtrue;
+		} //end if
+	} //end for
+	return qfalse;
+} //end of the function BotFindMatch
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void BotMatchVariable(bot_match_t *match, int variable, char *buf, int size)
+{
+	if (variable < 0 || variable >= MAX_MATCHVARIABLES)
+	{
+		botimport.Print(PRT_FATAL, "BotMatchVariable: variable out of range\n");
+		strcpy(buf, "");
+		return;
+	} //end if
+
+	if (match->variables[variable].offset >= 0)
+	{
+		if (match->variables[variable].length < size)
+			size = match->variables[variable].length+1;
+		assert( match->variables[variable].offset >= 0 ); // bk001204
+		strncpy(buf, &match->string[ (int) match->variables[variable].offset], size-1);
+		buf[size-1] = '\0';
+	} //end if
+	else
+	{
+		strcpy(buf, "");
+	} //end else
+	return;
+} //end of the function BotMatchVariable
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+bot_stringlist_t *BotFindStringInList(bot_stringlist_t *list, char *string)
+{
+	bot_stringlist_t *s;
+
+	for (s = list; s; s = s->next)
+	{
+		if (!strcmp(s->string, string)) return s;
+	} //end for
+	return NULL;
+} //end of the function BotFindStringInList
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+bot_stringlist_t *BotCheckChatMessageIntegrety(char *message, bot_stringlist_t *stringlist)
+{
+	int i;
+	char *msgptr;
+	char temp[MAX_MESSAGE_SIZE];
+	bot_stringlist_t *s;
+
+	msgptr = message;
+	//
+	while(*msgptr)
+	{
+		if (*msgptr == ESCAPE_CHAR)
+		{
+			msgptr++;
+			switch(*msgptr)
+			{
+				case 'v': //variable
+				{
+					//step over the 'v'
+					msgptr++;
+					while(*msgptr && *msgptr != ESCAPE_CHAR) msgptr++;
+					//step over the trailing escape char
+					if (*msgptr) msgptr++;
+					break;
+				} //end case
+				case 'r': //random
+				{
+					//step over the 'r'
+					msgptr++;
+					for (i = 0; (*msgptr && *msgptr != ESCAPE_CHAR); i++)
+					{
+						temp[i] = *msgptr++;
+					} //end while
+					temp[i] = '\0';
+					//step over the trailing escape char
+					if (*msgptr) msgptr++;
+					//find the random keyword
+					if (!RandomString(temp))
+					{
+						if (!BotFindStringInList(stringlist, temp))
+						{
+							Log_Write("%s = {\"%s\"} //MISSING RANDOM\r\n", temp, temp);
+							s = (struct bot_stringlist_s *)GetClearedMemory(sizeof(bot_stringlist_t) + strlen(temp) + 1);
+							s->string = (char *) s + sizeof(bot_stringlist_t);
+							strcpy(s->string, temp);
+							s->next = stringlist;
+							stringlist = s;
+						} //end if
+					} //end if
+					break;
+				} //end case
+				default:
+				{
+					botimport.Print(PRT_FATAL, "BotCheckChatMessageIntegrety: message \"%s\" invalid escape char\n", message);
+					break;
+				} //end default
+			} //end switch
+		} //end if
+		else
+		{
+			msgptr++;
+		} //end else
+	} //end while
+	return stringlist;
+} //end of the function BotCheckChatMessageIntegrety
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void BotCheckInitialChatIntegrety(bot_chat_t *chat)
+{
+	bot_chattype_t *t;
+	bot_chatmessage_t *cm;
+	bot_stringlist_t *stringlist, *s, *nexts;
+
+	stringlist = NULL;
+	for (t = chat->types; t; t = t->next)
+	{
+		for (cm = t->firstchatmessage; cm; cm = cm->next)
+		{
+			stringlist = BotCheckChatMessageIntegrety(cm->chatmessage, stringlist);
+		} //end for
+	} //end for
+	for (s = stringlist; s; s = nexts)
+	{
+		nexts = s->next;
+		FreeMemory(s);
+	} //end for
+} //end of the function BotCheckInitialChatIntegrety
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void BotCheckReplyChatIntegrety(bot_replychat_t *replychat)
+{
+	bot_replychat_t *rp;
+	bot_chatmessage_t *cm;
+	bot_stringlist_t *stringlist, *s, *nexts;
+
+	stringlist = NULL;
+	for (rp = replychat; rp; rp = rp->next)
+	{
+		for (cm = rp->firstchatmessage; cm; cm = cm->next)
+		{
+			stringlist = BotCheckChatMessageIntegrety(cm->chatmessage, stringlist);
+		} //end for
+	} //end for
+	for (s = stringlist; s; s = nexts)
+	{
+		nexts = s->next;
+		FreeMemory(s);
+	} //end for
+} //end of the function BotCheckReplyChatIntegrety
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void BotDumpReplyChat(bot_replychat_t *replychat)
+{
+	FILE *fp;
+	bot_replychat_t *rp;
+	bot_replychatkey_t *key;
+	bot_chatmessage_t *cm;
+	bot_matchpiece_t *mp;
+
+	fp = Log_FilePointer();
+	if (!fp) return;
+	fprintf(fp, "BotDumpReplyChat:\n");
+	for (rp = replychat; rp; rp = rp->next)
+	{
+		fprintf(fp, "[");
+		for (key = rp->keys; key; key = key->next)
+		{
+			if (key->flags & RCKFL_AND) fprintf(fp, "&");
+			else if (key->flags & RCKFL_NOT) fprintf(fp, "!");
+			//
+			if (key->flags & RCKFL_NAME) fprintf(fp, "name");
+			else if (key->flags & RCKFL_GENDERFEMALE) fprintf(fp, "female");
+			else if (key->flags & RCKFL_GENDERMALE) fprintf(fp, "male");
+			else if (key->flags & RCKFL_GENDERLESS) fprintf(fp, "it");
+			else if (key->flags & RCKFL_VARIABLES)
+			{
+				fprintf(fp, "(");
+				for (mp = key->match; mp; mp = mp->next)
+				{
+					if (mp->type == MT_STRING) fprintf(fp, "\"%s\"", mp->firststring->string);
+					else fprintf(fp, "%d", mp->variable);
+					if (mp->next) fprintf(fp, ", ");
+				} //end for
+				fprintf(fp, ")");
+			} //end if
+			else if (key->flags & RCKFL_STRING)
+			{
+				fprintf(fp, "\"%s\"", key->string);
+			} //end if
+			if (key->next) fprintf(fp, ", ");
+			else fprintf(fp, "] = %1.0f\n", rp->priority);
+		} //end for
+		fprintf(fp, "{\n");
+		for (cm = rp->firstchatmessage; cm; cm = cm->next)
+		{
+			fprintf(fp, "\t\"%s\";\n", cm->chatmessage);
+		} //end for
+		fprintf(fp, "}\n");
+	} //end for
+} //end of the function BotDumpReplyChat
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void BotFreeReplyChat(bot_replychat_t *replychat)
+{
+	bot_replychat_t *rp, *nextrp;
+	bot_replychatkey_t *key, *nextkey;
+	bot_chatmessage_t *cm, *nextcm;
+
+	for (rp = replychat; rp; rp = nextrp)
+	{
+		nextrp = rp->next;
+		for (key = rp->keys; key; key = nextkey)
+		{
+			nextkey = key->next;
+			if (key->match) BotFreeMatchPieces(key->match);
+			if (key->string) FreeMemory(key->string);
+			FreeMemory(key);
+		} //end for
+		for (cm = rp->firstchatmessage; cm; cm = nextcm)
+		{
+			nextcm = cm->next;
+			FreeMemory(cm);
+		} //end for
+		FreeMemory(rp);
+	} //end for
+} //end of the function BotFreeReplyChat
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+void BotCheckValidReplyChatKeySet(source_t *source, bot_replychatkey_t *keys)
+{
+	int allprefixed, hasvariableskey, hasstringkey;
+	bot_matchpiece_t *m;
+	bot_matchstring_t *ms;
+	bot_replychatkey_t *key, *key2;
+
+	//
+	allprefixed = qtrue;
+	hasvariableskey = hasstringkey = qfalse;
+	for (key = keys; key; key = key->next)
+	{
+		if (!(key->flags & (RCKFL_AND|RCKFL_NOT)))
+		{
+			allprefixed = qfalse;
+			if (key->flags & RCKFL_VARIABLES)
+			{
+				for (m = key->match; m; m = m->next)
+				{
+					if (m->type == MT_VARIABLE) hasvariableskey = qtrue;
+				} //end for
+			} //end if
+			else if (key->flags & RCKFL_STRING)
+			{
+				hasstringkey = qtrue;
+			} //end else if
+		} //end if
+		else if ((key->flags & RCKFL_AND) && (key->flags & RCKFL_STRING))
+		{
+			for (key2 = keys; key2; key2 = key2->next)
+			{
+				if (key2 == key) continue;
+				if (key2->flags & RCKFL_NOT) continue;
+				if (key2->flags & RCKFL_VARIABLES)
+				{
+					for (m = key2->match; m; m = m->next)
+					{
+						if (m->type == MT_STRING)
+						{
+							for (ms = m->firststring; ms; ms = ms->next)
+							{
+								if (StringContains(ms->string, key->string, qfalse) != -1)
+								{
+									break;
+								} //end if
+							} //end for
+							if (ms) break;
+						} //end if
+						else if (m->type == MT_VARIABLE)
+						{
+							break;
+						} //end if
+					} //end for
+					if (!m)
+					{
+						SourceWarning(source, "one of the match templates does not "
+										"leave space for the key %s with the & prefix", key->string);
+					} //end if
+				} //end if
+			} //end for
+		} //end else
+		if ((key->flags & RCKFL_NOT) && (key->flags & RCKFL_STRING))
+		{
+			for (key2 = keys; key2; key2 = key2->next)
+			{
+				if (key2 == key) continue;
+				if (key2->flags & RCKFL_NOT) continue;
+				if (key2->flags & RCKFL_STRING)
+				{
+					if (StringContains(key2->string, key->string, qfalse) != -1)
+					{
+						SourceWarning(source, "the key %s with prefix ! is inside the key %s", key->string, key2->string);
+					} //end if
+				} //end if
+				else if (key2->flags & RCKFL_VARIABLES)
+				{
+					for (m = key2->match; m; m = m->next)
+					{
+						if (m->type == MT_STRING)
+						{
+							for (ms = m->firststring; ms; ms = ms->next)
+							{
+								if (StringContains(ms->string, key->string, qfalse) != -1)
+								{
+									SourceWarning(source, "the key %s with prefix ! is inside "
+												"the match template string %s", key->string, ms->string);
+								} //end if
+							} //end for
+						} //end if
+					} //end for
+				} //end else if
+			} //end for
+		} //end if
+	} //end for
+	if (allprefixed) SourceWarning(source, "all keys have a & or ! prefix");
+	if (hasvariableskey && hasstringkey)
+	{
+		SourceWarning(source, "variables from the match template(s) could be "
+								"invalid when outputting one of the chat messages");
+	} //end if
+} //end of the function BotCheckValidReplyChatKeySet
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+bot_replychat_t *BotLoadReplyChat(char *filename)
+{
+	char chatmessagestring[MAX_MESSAGE_SIZE];
+	char namebuffer[MAX_MESSAGE_SIZE];
+	source_t *source;
+	token_t token;
+	bot_chatmessage_t *chatmessage = NULL;
+	bot_replychat_t *replychat, *replychatlist;
+	bot_replychatkey_t *key;
+
+	PC_SetBaseFolder(BOTFILESBASEFOLDER);
+	source = LoadSourceFile(filename);
+	if (!source)
+	{
+		botimport.Print(PRT_ERROR, "counldn't load %s\n", filename);
+		return NULL;
+	} //end if
+	//
+	replychatlist = NULL;
+	//
+	while(PC_ReadToken(source, &token))
+	{
+		if (strcmp(token.string, "["))
+		{
+			SourceError(source, "expected [, found %s", token.string);
+			BotFreeReplyChat(replychatlist);
+			FreeSource(source);
+			return NULL;
+		} //end if
+		//
+		replychat = (struct bot_replychat_s *)GetClearedHunkMemory(sizeof(bot_replychat_t));
+		replychat->keys = NULL;
+		replychat->next = replychatlist;
+		replychatlist = replychat;
+		//read the keys, there must be at least one key
+		do
+		{
+			//allocate a key
+			key = (bot_replychatkey_t *) GetClearedHunkMemory(sizeof(bot_replychatkey_t));
+			key->flags = 0;
+			key->string = NULL;
+			key->match = NULL;
+			key->next = replychat->keys;
+			replychat->keys = key;
+			//check for MUST BE PRESENT and MUST BE ABSENT keys
+			if (PC_CheckTokenString(source, "&")) key->flags |= RCKFL_AND;
+			else if (PC_CheckTokenString(source, "!")) key->flags |= RCKFL_NOT;
+			//special keys
+			if (PC_CheckTokenString(source, "name")) key->flags |= RCKFL_NAME;
+			else if (PC_CheckTokenString(source, "female")) key->flags |= RCKFL_GENDERFEMALE;
+			else if (PC_CheckTokenString(source, "male")) key->flags |= RCKFL_GENDERMALE;
+			else if (PC_CheckTokenString(source, "it")) key->flags |= RCKFL_GENDERLESS;
+			else if (PC_CheckTokenString(source, "(")) //match key
+			{
+				key->flags |= RCKFL_VARIABLES;
+				key->match = BotLoadMatchPieces(source, ")");
+				if (!key->match)
+				{
+					BotFreeReplyChat(replychatlist);
+					return NULL;
+				} //end if
+			} //end else if
+			else if (PC_CheckTokenString(source, "<")) //bot names
+			{
+				key->flags |= RCKFL_BOTNAMES;
+				strcpy(namebuffer, "");
+				do
+				{
+					if (!PC_ExpectTokenType(source, TT_STRING, 0, &token))
+					{
+						BotFreeReplyChat(replychatlist);
+						FreeSource(source);
+						return NULL;
+					} //end if
+					StripDoubleQuotes(token.string);
+					if (strlen(namebuffer)) strcat(namebuffer, "\\");
+					strcat(namebuffer, token.string);
+				} while(PC_CheckTokenString(source, ","));
+				if (!PC_ExpectTokenString(source, ">"))
+				{
+					BotFreeReplyChat(replychatlist);
+					FreeSource(source);
+					return NULL;
+				} //end if
+				key->string = (char *) GetClearedHunkMemory(strlen(namebuffer) + 1);
+				strcpy(key->string, namebuffer);
+			} //end else if
+			else //normal string key
+			{
+				key->flags |= RCKFL_STRING;
+				if (!PC_ExpectTokenType(source, TT_STRING, 0, &token))
+				{
+					BotFreeReplyChat(replychatlist);
+					FreeSource(source);
+					return NULL;
+				} //end if
+				StripDoubleQuotes(token.string);
+				key->string = (char *) GetClearedHunkMemory(strlen(token.string) + 1);
+				strcpy(key->string, token.string);
+			} //end else
+			//
+			PC_CheckTokenString(source, ",");
+		} while(!PC_CheckTokenString(source, "]"));
+		//
+		BotCheckValidReplyChatKeySet(source, replychat->keys);
+		//read the = sign and the priority
+		if (!PC_ExpectTokenString(source, "=") ||
+			!PC_ExpectTokenType(source, TT_NUMBER, 0, &token))
+		{
+			BotFreeReplyChat(replychatlist);
+			FreeSource(source);
+			return NULL;
+		} //end if
+		replychat->priority = token.floatvalue;
+		//read the leading {
+		if (!PC_ExpectTokenString(source, "{"))
+		{
+			BotFreeReplyChat(replychatlist);
+			FreeSource(source);
+			return NULL;
+		} //end if
+		replychat->numchatmessages = 0;
+		//while the trailing } is not found
+		while(!PC_CheckTokenString(source, "}"))
+		{
+			if (!BotLoadChatMessage(source, chatmessagestring))
+			{
+				BotFreeReplyChat(replychatlist);
+				FreeSource(source);
+				return NULL;
+			} //end if
+			chatmessage = (bot_chatmessage_t *) GetClearedHunkMemory(sizeof(bot_chatmessage_t) + strlen(chatmessagestring) + 1);
+			chatmessage->chatmessage = (char *) chatmessage + sizeof(bot_chatmessage_t);
+			strcpy(chatmessage->chatmessage, chatmessagestring);
+			chatmessage->time = -2*CHATMESSAGE_RECENTTIME;
+			chatmessage->next = replychat->firstchatmessage;
+			//add the chat message to the reply chat
+			replychat->firstchatmessage = chatmessage;
+			replychat->numchatmessages++;
+		} //end while
+	} //end while
+	FreeSource(source);
+	botimport.Print(PRT_MESSAGE, "loaded %s\n", filename);
+	//
+	//BotDumpReplyChat(replychatlist);
+	if (bot_developer)
+	{
+		BotCheckReplyChatIntegrety(replychatlist);
+	} //end if
+	//
+	if (!replychatlist) botimport.Print(PRT_MESSAGE, "no rchats\n");
+	//
+	return replychatlist;
+} //end of the function BotLoadReplyChat
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void BotDumpInitialChat(bot_chat_t *chat)
+{
+	bot_chattype_t *t;
+	bot_chatmessage_t *m;
+
+	Log_Write("{");
+	for (t = chat->types; t; t = t->next)
+	{
+		Log_Write(" type \"%s\"", t->name);
+		Log_Write(" {");
+		Log_Write("  numchatmessages = %d", t->numchatmessages);
+		for (m = t->firstchatmessage; m; m = m->next)
+		{
+			Log_Write("  \"%s\"", m->chatmessage);
+		} //end for
+		Log_Write(" }");
+	} //end for
+	Log_Write("}");
+} //end of the function BotDumpInitialChat
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+bot_chat_t *BotLoadInitialChat(char *chatfile, char *chatname)
+{
+	int pass, foundchat, indent, size;
+	char *ptr = NULL;
+	char chatmessagestring[MAX_MESSAGE_SIZE];
+	source_t *source;
+	token_t token;
+	bot_chat_t *chat = NULL;
+	bot_chattype_t *chattype = NULL;
+	bot_chatmessage_t *chatmessage = NULL;
+#ifdef DEBUG
+	int starttime;
+
+	starttime = Sys_MilliSeconds();
+#endif //DEBUG
+	//
+	size = 0;
+	foundchat = qfalse;
+	//a bot chat is parsed in two phases
+	for (pass = 0; pass < 2; pass++)
+	{
+		//allocate memory
+		if (pass && size) ptr = (char *) GetClearedMemory(size);
+		//load the source file
+		PC_SetBaseFolder(BOTFILESBASEFOLDER);
+		source = LoadSourceFile(chatfile);
+		if (!source)
+		{
+			botimport.Print(PRT_ERROR, "counldn't load %s\n", chatfile);
+			return NULL;
+		} //end if
+		//chat structure
+		if (pass)
+		{
+			chat = (bot_chat_t *) ptr;
+			ptr += sizeof(bot_chat_t);
+		} //end if
+		size = sizeof(bot_chat_t);
+		//
+		while(PC_ReadToken(source, &token))
+		{
+			if (!strcmp(token.string, "chat"))
+			{
+				if (!PC_ExpectTokenType(source, TT_STRING, 0, &token))
+				{
+					FreeSource(source);
+					return NULL;
+				} //end if
+				StripDoubleQuotes(token.string);
+				//after the chat name we expect a opening brace
+				if (!PC_ExpectTokenString(source, "{"))
+				{
+					FreeSource(source);
+					return NULL;
+				} //end if
+				//if the chat name is found
+				if (!Q_stricmp(token.string, chatname))
+				{
+					foundchat = qtrue;
+					//read the chat types
+					while(1)
+					{
+						if (!PC_ExpectAnyToken(source, &token))
+						{
+							FreeSource(source);
+							return NULL;
+						} //end if
+						if (!strcmp(token.string, "}")) break;
+						if (strcmp(token.string, "type"))
+						{
+							SourceError(source, "expected type found %s\n", token.string);
+							FreeSource(source);
+							return NULL;
+						} //end if
+						//expect the chat type name
+						if (!PC_ExpectTokenType(source, TT_STRING, 0, &token) ||
+							!PC_ExpectTokenString(source, "{"))
+						{
+							FreeSource(source);
+							return NULL;
+						} //end if
+						StripDoubleQuotes(token.string);
+						if (pass)
+						{
+							chattype = (bot_chattype_t *) ptr;
+							strncpy(chattype->name, token.string, MAX_CHATTYPE_NAME);
+							chattype->firstchatmessage = NULL;
+							//add the chat type to the chat
+							chattype->next = chat->types;
+							chat->types = chattype;
+							//
+							ptr += sizeof(bot_chattype_t);
+						} //end if
+						size += sizeof(bot_chattype_t);
+						//read the chat messages
+						while(!PC_CheckTokenString(source, "}"))
+						{
+							if (!BotLoadChatMessage(source, chatmessagestring))
+							{
+								FreeSource(source);
+								return NULL;
+							} //end if
+							if (pass)
+							{
+								chatmessage = (bot_chatmessage_t *) ptr;
+								chatmessage->time = -2*CHATMESSAGE_RECENTTIME;
+								//put the chat message in the list
+								chatmessage->next = chattype->firstchatmessage;
+								chattype->firstchatmessage = chatmessage;
+								//store the chat message
+								ptr += sizeof(bot_chatmessage_t);
+								chatmessage->chatmessage = ptr;
+								strcpy(chatmessage->chatmessage, chatmessagestring);
+								ptr += strlen(chatmessagestring) + 1;
+								//the number of chat messages increased
+								chattype->numchatmessages++;
+							} //end if
+							size += sizeof(bot_chatmessage_t) + strlen(chatmessagestring) + 1;
+						} //end if
+					} //end while
+				} //end if
+				else //skip the bot chat
+				{
+					indent = 1;
+					while(indent)
+					{
+						if (!PC_ExpectAnyToken(source, &token))
+						{
+							FreeSource(source);
+							return NULL;
+						} //end if
+						if (!strcmp(token.string, "{")) indent++;
+						else if (!strcmp(token.string, "}")) indent--;
+					} //end while
+				} //end else
+			} //end if
+			else
+			{
+				SourceError(source, "unknown definition %s\n", token.string);
+				FreeSource(source);
+				return NULL;
+			} //end else
+		} //end while
+		//free the source
+		FreeSource(source);
+		//if the requested character is not found
+		if (!foundchat)
+		{
+			botimport.Print(PRT_ERROR, "couldn't find chat %s in %s\n", chatname, chatfile);
+			return NULL;
+		} //end if
+	} //end for
+	//
+	botimport.Print(PRT_MESSAGE, "loaded %s from %s\n", chatname, chatfile);
+	//
+	//BotDumpInitialChat(chat);
+	if (bot_developer)
+	{
+		BotCheckInitialChatIntegrety(chat);
+	} //end if
+#ifdef DEBUG
+	botimport.Print(PRT_MESSAGE, "initial chats loaded in %d msec\n", Sys_MilliSeconds() - starttime);
+#endif //DEBUG
+	//character was read succesfully
+	return chat;
+} //end of the function BotLoadInitialChat
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+void BotFreeChatFile(int chatstate)
+{
+	bot_chatstate_t *cs;
+
+	cs = BotChatStateFromHandle(chatstate);
+	if (!cs) return;
+	if (cs->chat) FreeMemory(cs->chat);
+	cs->chat = NULL;
+} //end of the function BotFreeChatFile
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int BotLoadChatFile(int chatstate, char *chatfile, char *chatname)
+{
+	bot_chatstate_t *cs;
+	int n, avail = 0;
+
+	cs = BotChatStateFromHandle(chatstate);
+	if (!cs) return BLERR_CANNOTLOADICHAT;
+	BotFreeChatFile(chatstate);
+
+	if (!LibVarGetValue("bot_reloadcharacters"))
+	{
+		avail = -1;
+		for( n = 0; n < MAX_CLIENTS; n++ ) {
+			if( !ichatdata[n] ) {
+				if( avail == -1 ) {
+					avail = n;
+				}
+				continue;
+			}
+			if( strcmp( chatfile, ichatdata[n]->filename ) != 0 ) { 
+				continue;
+			}
+			if( strcmp( chatname, ichatdata[n]->chatname ) != 0 ) { 
+				continue;
+			}
+			cs->chat = ichatdata[n]->chat;
+		//		botimport.Print( PRT_MESSAGE, "retained %s from %s\n", chatname, chatfile );
+			return BLERR_NOERROR;
+		}
+
+		if( avail == -1 ) {
+			botimport.Print(PRT_FATAL, "ichatdata table full; couldn't load chat %s from %s\n", chatname, chatfile);
+			return BLERR_CANNOTLOADICHAT;
+		}
+	}
+
+	cs->chat = BotLoadInitialChat(chatfile, chatname);
+	if (!cs->chat)
+	{
+		botimport.Print(PRT_FATAL, "couldn't load chat %s from %s\n", chatname, chatfile);
+		return BLERR_CANNOTLOADICHAT;
+	} //end if
+	if (!LibVarGetValue("bot_reloadcharacters"))
+	{
+		ichatdata[avail] = (bot_ichatdata_t *)GetClearedMemory( sizeof(bot_ichatdata_t) );
+		ichatdata[avail]->chat = cs->chat;
+		Q_strncpyz( ichatdata[avail]->chatname, chatname, sizeof(ichatdata[avail]->chatname) );
+		Q_strncpyz( ichatdata[avail]->filename, chatfile, sizeof(ichatdata[avail]->filename) );
+	} //end if
+
+	return BLERR_NOERROR;
+} //end of the function BotLoadChatFile
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+int BotExpandChatMessage(char *outmessage, char *message, unsigned long mcontext,
+							 bot_match_t *match, unsigned long vcontext, int reply)
+{
+	int num, len, i, expansion;
+	char *outputbuf, *ptr, *msgptr;
+	char temp[MAX_MESSAGE_SIZE];
+
+	expansion = qfalse;
+	msgptr = message;
+	outputbuf = outmessage;
+	len = 0;
+	//
+	while(*msgptr)
+	{
+		if (*msgptr == ESCAPE_CHAR)
+		{
+			msgptr++;
+			switch(*msgptr)
+			{
+				case 'v': //variable
+				{
+					msgptr++;
+					num = 0;
+					while(*msgptr && *msgptr != ESCAPE_CHAR)
+					{
+						num = num * 10 + (*msgptr++) - '0';
+					} //end while
+					//step over the trailing escape char
+					if (*msgptr) msgptr++;
+					if (num > MAX_MATCHVARIABLES)
+					{
+						botimport.Print(PRT_ERROR, "BotConstructChat: message %s variable %d out of range\n", message, num);
+						return qfalse;
+					} //end if
+					if (match->variables[num].offset >= 0)
+					{
+					        assert( match->variables[num].offset >= 0 ); // bk001204
+						ptr = &match->string[ (int) match->variables[num].offset];
+						for (i = 0; i < match->variables[num].length; i++)
+						{
+							temp[i] = ptr[i];
+						} //end for
+						temp[i] = 0;
+						//if it's a reply message
+						if (reply)
+						{
+							//replace the reply synonyms in the variables
+							BotReplaceReplySynonyms(temp, vcontext);
+						} //end if
+						else 
+						{
+							//replace synonyms in the variable context
+							BotReplaceSynonyms(temp, vcontext);
+						} //end else
+						//
+						if (len + strlen(temp) >= MAX_MESSAGE_SIZE)
+						{
+							botimport.Print(PRT_ERROR, "BotConstructChat: message %s too long\n", message);
+							return qfalse;
+						} //end if
+						strcpy(&outputbuf[len], temp);
+						len += strlen(temp);
+					} //end if
+					break;
+				} //end case
+				case 'r': //random
+				{
+					msgptr++;
+					for (i = 0; (*msgptr && *msgptr != ESCAPE_CHAR); i++)
+					{
+						temp[i] = *msgptr++;
+					} //end while
+					temp[i] = '\0';
+					//step over the trailing escape char
+					if (*msgptr) msgptr++;
+					//find the random keyword
+					ptr = RandomString(temp);
+					if (!ptr)
+					{
+						botimport.Print(PRT_ERROR, "BotConstructChat: unknown random string %s\n", temp);
+						return qfalse;
+					} //end if
+					if (len + strlen(ptr) >= MAX_MESSAGE_SIZE)
+					{
+						botimport.Print(PRT_ERROR, "BotConstructChat: message \"%s\" too long\n", message);
+						return qfalse;
+					} //end if
+					strcpy(&outputbuf[len], ptr);
+					len += strlen(ptr);
+					expansion = qtrue;
+					break;
+				} //end case
+				default:
+				{
+					botimport.Print(PRT_FATAL, "BotConstructChat: message \"%s\" invalid escape char\n", message);
+					break;
+				} //end default
+			} //end switch
+		} //end if
+		else
+		{
+			outputbuf[len++] = *msgptr++;
+			if (len >= MAX_MESSAGE_SIZE)
+			{
+				botimport.Print(PRT_ERROR, "BotConstructChat: message \"%s\" too long\n", message);
+				break;
+			} //end if
+		} //end else
+	} //end while
+	outputbuf[len] = '\0';
+	//replace synonyms weighted in the message context
+	BotReplaceWeightedSynonyms(outputbuf, mcontext);
+	//return true if a random was expanded
+	return expansion;
+} //end of the function BotExpandChatMessage
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+void BotConstructChatMessage(bot_chatstate_t *chatstate, char *message, unsigned long mcontext,
+							 bot_match_t *match, unsigned long vcontext, int reply)
+{
+	int i;
+	char srcmessage[MAX_MESSAGE_SIZE];
+
+	strcpy(srcmessage, message);
+	for (i = 0; i < 10; i++)
+	{
+		if (!BotExpandChatMessage(chatstate->chatmessage, srcmessage, mcontext, match, vcontext, reply))
+		{
+			break;
+		} //end if
+		strcpy(srcmessage, chatstate->chatmessage);
+	} //end for
+	if (i >= 10)
+	{
+		botimport.Print(PRT_WARNING, "too many expansions in chat message\n");
+		botimport.Print(PRT_WARNING, "%s\n", chatstate->chatmessage);
+	} //end if
+} //end of the function BotConstructChatMessage
+//===========================================================================
+// randomly chooses one of the chat message of the given type
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+char *BotChooseInitialChatMessage(bot_chatstate_t *cs, char *type)
+{
+	int n, numchatmessages;
+	float besttime;
+	bot_chattype_t *t;
+	bot_chatmessage_t *m, *bestchatmessage;
+	bot_chat_t *chat;
+
+	chat = cs->chat;
+	for (t = chat->types; t; t = t->next)
+	{
+		if (!Q_stricmp(t->name, type))
+		{
+			numchatmessages = 0;
+			for (m = t->firstchatmessage; m; m = m->next)
+			{
+				if (m->time > AAS_Time()) continue;
+				numchatmessages++;
+			} //end if
+			//if all chat messages have been used recently
+			if (numchatmessages <= 0)
+			{
+				besttime = 0;
+				bestchatmessage = NULL;
+				for (m = t->firstchatmessage; m; m = m->next)
+				{
+					if (!besttime || m->time < besttime)
+					{
+						bestchatmessage = m;
+						besttime = m->time;
+					} //end if
+				} //end for
+				if (bestchatmessage) return bestchatmessage->chatmessage;
+			} //end if
+			else //choose a chat message randomly
+			{
+				n = random() * numchatmessages;
+				for (m = t->firstchatmessage; m; m = m->next)
+				{
+					if (m->time > AAS_Time()) continue;
+					if (--n < 0)
+					{
+						m->time = AAS_Time() + CHATMESSAGE_RECENTTIME;
+						return m->chatmessage;
+					} //end if
+				} //end for
+			} //end else
+			return NULL;
+		} //end if
+	} //end for
+	return NULL;
+} //end of the function BotChooseInitialChatMessage
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int BotNumInitialChats(int chatstate, char *type)
+{
+	bot_chatstate_t *cs;
+	bot_chattype_t *t;
+
+	cs = BotChatStateFromHandle(chatstate);
+	if (!cs) return 0;
+
+	for (t = cs->chat->types; t; t = t->next)
+	{
+		if (!Q_stricmp(t->name, type))
+		{
+			if (LibVarGetValue("bot_testichat")) {
+				botimport.Print(PRT_MESSAGE, "%s has %d chat lines\n", type, t->numchatmessages);
+				botimport.Print(PRT_MESSAGE, "-------------------\n");
+			}
+			return t->numchatmessages;
+		} //end if
+	} //end for
+	return 0;
+} //end of the function BotNumInitialChats
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void BotInitialChat(int chatstate, char *type, int mcontext, char *var0, char *var1, char *var2, char *var3, char *var4, char *var5, char *var6, char *var7)
+{
+	char *message;
+	int index;
+	bot_match_t match;
+	bot_chatstate_t *cs;
+
+	cs = BotChatStateFromHandle(chatstate);
+	if (!cs) return;
+	//if no chat file is loaded
+	if (!cs->chat) return;
+	//choose a chat message randomly of the given type
+	message = BotChooseInitialChatMessage(cs, type);
+	//if there's no message of the given type
+	if (!message)
+	{
+#ifdef DEBUG
+		botimport.Print(PRT_MESSAGE, "no chat messages of type %s\n", type);
+#endif //DEBUG
+		return;
+	} //end if
+	//
+	Com_Memset(&match, 0, sizeof(match));
+	index = 0;
+	if( var0 ) {
+		strcat(match.string, var0);
+		match.variables[0].offset = index;
+		match.variables[0].length = strlen(var0);
+		index += strlen(var0);
+	}
+	if( var1 ) {
+		strcat(match.string, var1);
+		match.variables[1].offset = index;
+		match.variables[1].length = strlen(var1);
+		index += strlen(var1);
+	}
+	if( var2 ) {
+		strcat(match.string, var2);
+		match.variables[2].offset = index;
+		match.variables[2].length = strlen(var2);
+		index += strlen(var2);
+	}
+	if( var3 ) {
+		strcat(match.string, var3);
+		match.variables[3].offset = index;
+		match.variables[3].length = strlen(var3);
+		index += strlen(var3);
+	}
+	if( var4 ) {
+		strcat(match.string, var4);
+		match.variables[4].offset = index;
+		match.variables[4].length = strlen(var4);
+		index += strlen(var4);
+	}
+	if( var5 ) {
+		strcat(match.string, var5);
+		match.variables[5].offset = index;
+		match.variables[5].length = strlen(var5);
+		index += strlen(var5);
+	}
+	if( var6 ) {
+		strcat(match.string, var6);
+		match.variables[6].offset = index;
+		match.variables[6].length = strlen(var6);
+		index += strlen(var6);
+	}
+	if( var7 ) {
+		strcat(match.string, var7);
+		match.variables[7].offset = index;
+		match.variables[7].length = strlen(var7);
+		index += strlen(var7);
+	}
+ 	//
+	BotConstructChatMessage(cs, message, mcontext, &match, 0, qfalse);
+} //end of the function BotInitialChat
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void BotPrintReplyChatKeys(bot_replychat_t *replychat)
+{
+	bot_replychatkey_t *key;
+	bot_matchpiece_t *mp;
+
+	botimport.Print(PRT_MESSAGE, "[");
+	for (key = replychat->keys; key; key = key->next)
+	{
+		if (key->flags & RCKFL_AND) botimport.Print(PRT_MESSAGE, "&");
+		else if (key->flags & RCKFL_NOT) botimport.Print(PRT_MESSAGE, "!");
+		//
+		if (key->flags & RCKFL_NAME) botimport.Print(PRT_MESSAGE, "name");
+		else if (key->flags & RCKFL_GENDERFEMALE) botimport.Print(PRT_MESSAGE, "female");
+		else if (key->flags & RCKFL_GENDERMALE) botimport.Print(PRT_MESSAGE, "male");
+		else if (key->flags & RCKFL_GENDERLESS) botimport.Print(PRT_MESSAGE, "it");
+		else if (key->flags & RCKFL_VARIABLES)
+		{
+			botimport.Print(PRT_MESSAGE, "(");
+			for (mp = key->match; mp; mp = mp->next)
+			{
+				if (mp->type == MT_STRING) botimport.Print(PRT_MESSAGE, "\"%s\"", mp->firststring->string);
+				else botimport.Print(PRT_MESSAGE, "%d", mp->variable);
+				if (mp->next) botimport.Print(PRT_MESSAGE, ", ");
+			} //end for
+			botimport.Print(PRT_MESSAGE, ")");
+		} //end if
+		else if (key->flags & RCKFL_STRING)
+		{
+			botimport.Print(PRT_MESSAGE, "\"%s\"", key->string);
+		} //end if
+		if (key->next) botimport.Print(PRT_MESSAGE, ", ");
+		else botimport.Print(PRT_MESSAGE, "] = %1.0f\n", replychat->priority);
+	} //end for
+	botimport.Print(PRT_MESSAGE, "{\n");
+} //end of the function BotPrintReplyChatKeys
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int BotReplyChat(int chatstate, char *message, int mcontext, int vcontext, char *var0, char *var1, char *var2, char *var3, char *var4, char *var5, char *var6, char *var7)
+{
+	bot_replychat_t *rchat, *bestrchat;
+	bot_replychatkey_t *key;
+	bot_chatmessage_t *m, *bestchatmessage;
+	bot_match_t match, bestmatch;
+	int bestpriority, num, found, res, numchatmessages, index;
+	bot_chatstate_t *cs;
+
+	cs = BotChatStateFromHandle(chatstate);
+	if (!cs) return qfalse;
+	Com_Memset(&match, 0, sizeof(bot_match_t));
+	strcpy(match.string, message);
+	bestpriority = -1;
+	bestchatmessage = NULL;
+	bestrchat = NULL;
+	//go through all the reply chats
+	for (rchat = replychats; rchat; rchat = rchat->next)
+	{
+		found = qfalse;
+		for (key = rchat->keys; key; key = key->next)
+		{
+			res = qfalse;
+			//get the match result
+			if (key->flags & RCKFL_NAME) res = (StringContains(message, cs->name, qfalse) != -1);
+			else if (key->flags & RCKFL_BOTNAMES) res = (StringContains(key->string, cs->name, qfalse) != -1);
+			else if (key->flags & RCKFL_GENDERFEMALE) res = (cs->gender == CHAT_GENDERFEMALE);
+			else if (key->flags & RCKFL_GENDERMALE) res = (cs->gender == CHAT_GENDERMALE);
+			else if (key->flags & RCKFL_GENDERLESS) res = (cs->gender == CHAT_GENDERLESS);
+			else if (key->flags & RCKFL_VARIABLES) res = StringsMatch(key->match, &match);
+			else if (key->flags & RCKFL_STRING) res = (StringContainsWord(message, key->string, qfalse) != NULL);
+			//if the key must be present
+			if (key->flags & RCKFL_AND)
+			{
+				if (!res)
+				{
+					found = qfalse;
+					break;
+				} //end if
+			} //end else if
+			//if the key must be absent
+			else if (key->flags & RCKFL_NOT)
+			{
+				if (res)
+				{
+					found = qfalse;
+					break;
+				} //end if
+			} //end if
+			else if (res)
+			{
+				found = qtrue;
+			} //end else
+		} //end for
+		//
+		if (found)
+		{
+			if (rchat->priority > bestpriority)
+			{
+				numchatmessages = 0;
+				for (m = rchat->firstchatmessage; m; m = m->next)
+				{
+					if (m->time > AAS_Time()) continue;
+					numchatmessages++;
+				} //end if
+				num = random() * numchatmessages;
+				for (m = rchat->firstchatmessage; m; m = m->next)
+				{
+					if (--num < 0) break;
+					if (m->time > AAS_Time()) continue;
+				} //end for
+				//if the reply chat has a message
+				if (m)
+				{
+					Com_Memcpy(&bestmatch, &match, sizeof(bot_match_t));
+					bestchatmessage = m;
+					bestrchat = rchat;
+					bestpriority = rchat->priority;
+				} //end if
+			} //end if
+		} //end if
+	} //end for
+	if (bestchatmessage)
+	{
+		index = strlen(bestmatch.string);
+		if( var0 ) {
+			strcat(bestmatch.string, var0);
+			bestmatch.variables[0].offset = index;
+			bestmatch.variables[0].length = strlen(var0);
+			index += strlen(var0);
+		}
+		if( var1 ) {
+			strcat(bestmatch.string, var1);
+			bestmatch.variables[1].offset = index;
+			bestmatch.variables[1].length = strlen(var1);
+			index += strlen(var1);
+		}
+		if( var2 ) {
+			strcat(bestmatch.string, var2);
+			bestmatch.variables[2].offset = index;
+			bestmatch.variables[2].length = strlen(var2);
+			index += strlen(var2);
+		}
+		if( var3 ) {
+			strcat(bestmatch.string, var3);
+			bestmatch.variables[3].offset = index;
+			bestmatch.variables[3].length = strlen(var3);
+			index += strlen(var3);
+		}
+		if( var4 ) {
+			strcat(bestmatch.string, var4);
+			bestmatch.variables[4].offset = index;
+			bestmatch.variables[4].length = strlen(var4);
+			index += strlen(var4);
+		}
+		if( var5 ) {
+			strcat(bestmatch.string, var5);
+			bestmatch.variables[5].offset = index;
+			bestmatch.variables[5].length = strlen(var5);
+			index += strlen(var5);
+		}
+		if( var6 ) {
+			strcat(bestmatch.string, var6);
+			bestmatch.variables[6].offset = index;
+			bestmatch.variables[6].length = strlen(var6);
+			index += strlen(var6);
+		}
+		if( var7 ) {
+			strcat(bestmatch.string, var7);
+			bestmatch.variables[7].offset = index;
+			bestmatch.variables[7].length = strlen(var7);
+			index += strlen(var7);
+		}
+		if (LibVarGetValue("bot_testrchat"))
+		{
+			for (m = bestrchat->firstchatmessage; m; m = m->next)
+			{
+				BotConstructChatMessage(cs, m->chatmessage, mcontext, &bestmatch, vcontext, qtrue);
+				BotRemoveTildes(cs->chatmessage);
+				botimport.Print(PRT_MESSAGE, "%s\n", cs->chatmessage);
+			} //end if
+		} //end if
+		else
+		{
+			bestchatmessage->time = AAS_Time() + CHATMESSAGE_RECENTTIME;
+			BotConstructChatMessage(cs, bestchatmessage->chatmessage, mcontext, &bestmatch, vcontext, qtrue);
+		} //end else
+		return qtrue;
+	} //end if
+	return qfalse;
+} //end of the function BotReplyChat
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int BotChatLength(int chatstate)
+{
+	bot_chatstate_t *cs;
+
+	cs = BotChatStateFromHandle(chatstate);
+	if (!cs) return 0;
+	return strlen(cs->chatmessage);
+} //end of the function BotChatLength
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+void BotEnterChat(int chatstate, int clientto, int sendto)
+{
+	bot_chatstate_t *cs;
+
+	cs = BotChatStateFromHandle(chatstate);
+	if (!cs) return;
+
+	if (strlen(cs->chatmessage))
+	{
+		BotRemoveTildes(cs->chatmessage);
+		if (LibVarGetValue("bot_testichat")) {
+			botimport.Print(PRT_MESSAGE, "%s\n", cs->chatmessage);
+		}
+		else {
+			switch(sendto) {
+				case CHAT_TEAM:
+					EA_Command(cs->client, va("say_team %s", cs->chatmessage));
+					break;
+				case CHAT_TELL:
+					EA_Command(cs->client, va("tell %d %s", clientto, cs->chatmessage));
+					break;
+				default: //CHAT_ALL
+					EA_Command(cs->client, va("say %s", cs->chatmessage));
+					break;
+			}
+		}
+		//clear the chat message from the state
+		strcpy(cs->chatmessage, "");
+	} //end if
+} //end of the function BotEnterChat
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+void BotGetChatMessage(int chatstate, char *buf, int size)
+{
+	bot_chatstate_t *cs;
+
+	cs = BotChatStateFromHandle(chatstate);
+	if (!cs) return;
+
+	BotRemoveTildes(cs->chatmessage);
+	strncpy(buf, cs->chatmessage, size-1);
+	buf[size-1] = '\0';
+	//clear the chat message from the state
+	strcpy(cs->chatmessage, "");
+} //end of the function BotGetChatMessage
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+void BotSetChatGender(int chatstate, int gender)
+{
+	bot_chatstate_t *cs;
+
+	cs = BotChatStateFromHandle(chatstate);
+	if (!cs) return;
+	switch(gender)
+	{
+		case CHAT_GENDERFEMALE: cs->gender = CHAT_GENDERFEMALE; break;
+		case CHAT_GENDERMALE: cs->gender = CHAT_GENDERMALE; break;
+		default: cs->gender = CHAT_GENDERLESS; break;
+	} //end switch
+} //end of the function BotSetChatGender
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void BotSetChatName(int chatstate, char *name, int client)
+{
+	bot_chatstate_t *cs;
+
+	cs = BotChatStateFromHandle(chatstate);
+	if (!cs) return;
+	cs->client = client;
+	Com_Memset(cs->name, 0, sizeof(cs->name));
+	strncpy(cs->name, name, sizeof(cs->name));
+	cs->name[sizeof(cs->name)-1] = '\0';
+} //end of the function BotSetChatName
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void BotResetChatAI(void)
+{
+	bot_replychat_t *rchat;
+	bot_chatmessage_t *m;
+
+	for (rchat = replychats; rchat; rchat = rchat->next)
+	{
+		for (m = rchat->firstchatmessage; m; m = m->next)
+		{
+			m->time = 0;
+		} //end for
+	} //end for
+} //end of the function BotResetChatAI
+//========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//========================================================================
+int BotAllocChatState(void)
+{
+	int i;
+
+	for (i = 1; i <= MAX_CLIENTS; i++)
+	{
+		if (!botchatstates[i])
+		{
+			botchatstates[i] = (struct bot_chatstate_s *)GetClearedMemory(sizeof(bot_chatstate_t));
+			return i;
+		} //end if
+	} //end for
+	return 0;
+} //end of the function BotAllocChatState
+//========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//========================================================================
+void BotFreeChatState(int handle)
+{
+	bot_chatstate_t *cs;
+	bot_consolemessage_t m;
+	int h;
+
+	if (handle <= 0 || handle > MAX_CLIENTS)
+	{
+		botimport.Print(PRT_FATAL, "chat state handle %d out of range\n", handle);
+		return;
+	} //end if
+	if (!botchatstates[handle])
+	{
+		botimport.Print(PRT_FATAL, "invalid chat state %d\n", handle);
+		return;
+	} //end if
+	cs = botchatstates[handle];
+	if (LibVarGetValue("bot_reloadcharacters"))
+	{
+		BotFreeChatFile(handle);
+	} //end if
+	//free all the console messages left in the chat state
+	for (h = BotNextConsoleMessage(handle, &m); h; h = BotNextConsoleMessage(handle, &m))
+	{
+		//remove the console message
+		BotRemoveConsoleMessage(handle, h);
+	} //end for
+	FreeMemory(botchatstates[handle]);
+	botchatstates[handle] = NULL;
+} //end of the function BotFreeChatState
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int BotSetupChatAI(void)
+{
+	char *file;
+
+#ifdef DEBUG
+	int starttime = Sys_MilliSeconds();
+#endif //DEBUG
+
+	file = LibVarString("synfile", "syn.c");
+	synonyms = BotLoadSynonyms(file);
+	file = LibVarString("rndfile", "rnd.c");
+	randomstrings = BotLoadRandomStrings(file);
+	file = LibVarString("matchfile", "match.c");
+	matchtemplates = BotLoadMatchTemplates(file);
+	//
+	if (!LibVarValue("nochat", "0"))
+	{
+		file = LibVarString("rchatfile", "rchat.c");
+		replychats = BotLoadReplyChat(file);
+	} //end if
+
+	InitConsoleMessageHeap();
+
+#ifdef DEBUG
+	botimport.Print(PRT_MESSAGE, "setup chat AI %d msec\n", Sys_MilliSeconds() - starttime);
+#endif //DEBUG
+	return BLERR_NOERROR;
+} //end of the function BotSetupChatAI
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void BotShutdownChatAI(void)
+{
+	int i;
+
+	//free all remaining chat states
+	for(i = 0; i < MAX_CLIENTS; i++)
+	{
+		if (botchatstates[i])
+		{
+			BotFreeChatState(i);
+		} //end if
+	} //end for
+	//free all cached chats
+	for(i = 0; i < MAX_CLIENTS; i++)
+	{
+		if (ichatdata[i])
+		{
+			FreeMemory(ichatdata[i]->chat);
+			FreeMemory(ichatdata[i]);
+			ichatdata[i] = NULL;
+		} //end if
+	} //end for
+	if (consolemessageheap) FreeMemory(consolemessageheap);
+	consolemessageheap = NULL;
+	if (matchtemplates) BotFreeMatchTemplates(matchtemplates);
+	matchtemplates = NULL;
+	if (randomstrings) FreeMemory(randomstrings);
+	randomstrings = NULL;
+	if (synonyms) FreeMemory(synonyms);
+	synonyms = NULL;
+	if (replychats) BotFreeReplyChat(replychats);
+	replychats = NULL;
+} //end of the function BotShutdownChatAI
diff --git a/codemp/botlib/be_ai_gen.cpp b/codemp/botlib/be_ai_gen.cpp
new file mode 100644
index 0000000..679a08b
--- /dev/null
+++ b/codemp/botlib/be_ai_gen.cpp
@@ -0,0 +1,117 @@
+
+/*****************************************************************************
+ * name:		be_ai_gen.c
+ *
+ * desc:		genetic selection
+ *
+ * $Archive: /MissionPack/code/botlib/be_ai_gen.c $
+ * $Author: Zaphod $ 
+ * $Revision: 3 $
+ * $Modtime: 11/22/00 8:50a $
+ * $Date: 11/22/00 8:55a $
+ *
+ *****************************************************************************/
+
+#include "../game/q_shared.h"
+#include "l_memory.h"
+#include "l_log.h"
+#include "l_utils.h"
+#include "l_script.h"
+#include "l_precomp.h"
+#include "l_struct.h"
+#include "aasfile.h"
+#include "../game/botlib.h"
+#include "../game/be_aas.h"
+#include "be_aas_funcs.h"
+#include "be_interface.h"
+#include "../game/be_ai_gen.h"
+
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+int GeneticSelection(int numranks, float *rankings)
+{
+	float sum, select;
+	int i, index;
+
+	sum = 0;
+	for (i = 0; i < numranks; i++)
+	{
+		if (rankings[i] < 0) continue;
+		sum += rankings[i];
+	} //end for
+	if (sum > 0)
+	{
+		//select a bot where the ones with the higest rankings have
+		//the highest chance of being selected
+		select = random() * sum;
+		for (i = 0; i < numranks; i++)
+		{
+			if (rankings[i] < 0) continue;
+			sum -= rankings[i];
+			if (sum <= 0) return i;
+		} //end for
+	} //end if
+	//select a bot randomly
+	index = random() * numranks;
+	for (i = 0; i < numranks; i++)
+	{
+		if (rankings[index] >= 0) return index;
+		index = (index + 1) % numranks;
+	} //end for
+	return 0;
+} //end of the function GeneticSelection
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+int GeneticParentsAndChildSelection(int numranks, float *ranks, int *parent1, int *parent2, int *child)
+{
+	float rankings[256], max;
+	int i;
+
+	if (numranks > 256)
+	{
+		botimport.Print(PRT_WARNING, "GeneticParentsAndChildSelection: too many bots\n");
+		*parent1 = *parent2 = *child = 0;
+		return qfalse;
+	} //end if
+	for (max = 0, i = 0; i < numranks; i++)
+	{
+		if (ranks[i] < 0) continue;
+		max++;
+	} //end for
+	if (max < 3)
+	{
+		botimport.Print(PRT_WARNING, "GeneticParentsAndChildSelection: too few valid bots\n");
+		*parent1 = *parent2 = *child = 0;
+		return qfalse;
+	} //end if
+	Com_Memcpy(rankings, ranks, sizeof(float) * numranks);
+	//select first parent
+	*parent1 = GeneticSelection(numranks, rankings);
+	rankings[*parent1] = -1;
+	//select second parent
+	*parent2 = GeneticSelection(numranks, rankings);
+	rankings[*parent2] = -1;
+	//reverse the rankings
+	max = 0;
+	for (i = 0; i < numranks; i++)
+	{
+		if (rankings[i] < 0) continue;
+		if (rankings[i] > max) max = rankings[i];
+	} //end for
+	for (i = 0; i < numranks; i++)
+	{
+		if (rankings[i] < 0) continue;
+		rankings[i] = max - rankings[i];
+	} //end for
+	//select child
+	*child = GeneticSelection(numranks, rankings);
+	return qtrue;
+} //end of the function GeneticParentsAndChildSelection
diff --git a/codemp/botlib/be_ai_goal.cpp b/codemp/botlib/be_ai_goal.cpp
new file mode 100644
index 0000000..03d9d3e
--- /dev/null
+++ b/codemp/botlib/be_ai_goal.cpp
@@ -0,0 +1,1805 @@
+
+/*****************************************************************************
+ * name:		be_ai_goal.c
+ *
+ * desc:		goal AI
+ *
+ * $Archive: /MissionPack/code/botlib/be_ai_goal.c $
+ * $Author: Ttimo $ 
+ * $Revision: 14 $
+ * $Modtime: 4/13/01 4:45p $
+ * $Date: 4/13/01 4:45p $
+ *
+ *****************************************************************************/
+
+#include "../game/q_shared.h"
+#include "l_utils.h"
+#include "l_libvar.h"
+#include "l_memory.h"
+#include "l_log.h"
+#include "l_script.h"
+#include "l_precomp.h"
+#include "l_struct.h"
+#include "aasfile.h"
+#include "../game/botlib.h"
+#include "../game/be_aas.h"
+#include "be_aas_funcs.h"
+#include "be_interface.h"
+#include "be_ai_weight.h"
+#include "../game/be_ai_goal.h"
+#include "../game/be_ai_move.h"
+
+//#define DEBUG_AI_GOAL
+#ifdef RANDOMIZE
+#define UNDECIDEDFUZZY
+#endif //RANDOMIZE
+#define DROPPEDWEIGHT
+//minimum avoid goal time
+#define AVOID_MINIMUM_TIME		10
+//default avoid goal time
+#define AVOID_DEFAULT_TIME		30
+//avoid dropped goal time
+#define AVOID_DROPPED_TIME		10
+//
+#define TRAVELTIME_SCALE		0.01
+//item flags
+#define IFL_NOTFREE				1		//not in free for all
+#define IFL_NOTTEAM				2		//not in team play
+#define IFL_NOTSINGLE			4		//not in single player
+#define IFL_NOTBOT				8		//bot should never go for this
+#define IFL_ROAM				16		//bot roam goal
+
+//location in the map "target_location"
+typedef struct maplocation_s
+{
+	vec3_t origin;
+	int areanum;
+	char name[MAX_EPAIRKEY];
+	struct maplocation_s *next;
+} maplocation_t;
+
+//camp spots "info_camp"
+typedef struct campspot_s
+{
+	vec3_t origin;
+	int areanum;
+	char name[MAX_EPAIRKEY];
+	float range;
+	float weight;
+	float wait;
+	float random;
+	struct campspot_s *next;
+} campspot_t;
+
+//FIXME: these are game specific
+typedef enum {
+	GT_FFA,				// free for all
+	GT_HOLOCRON,		// holocron match
+	GT_JEDIMASTER,		// jedi master
+	GT_DUEL,		// one on one tournament
+	GT_POWERDUEL,
+	GT_SINGLE_PLAYER,	// single player tournament
+
+	//-- team games go after this --
+
+	GT_TEAM,			// team deathmatch
+	GT_SIEGE,			// siege
+	GT_CTF,				// capture the flag
+	GT_CTY,
+	GT_MAX_GAME_TYPE
+};
+typedef int gametype_t;
+
+typedef struct levelitem_s
+{
+	int number;							//number of the level item
+	int iteminfo;						//index into the item info
+	int flags;							//item flags
+	float weight;						//fixed roam weight
+	vec3_t origin;						//origin of the item
+	int goalareanum;					//area the item is in
+	vec3_t goalorigin;					//goal origin within the area
+	int entitynum;						//entity number
+	float timeout;						//item is removed after this time
+	struct levelitem_s *prev, *next;
+} levelitem_t;
+
+typedef struct iteminfo_s
+{
+	char classname[32];					//classname of the item
+	char name[MAX_STRINGFIELD];			//name of the item
+	char model[MAX_STRINGFIELD];		//model of the item
+	int modelindex;						//model index
+	int type;							//item type
+	int index;							//index in the inventory
+	float respawntime;					//respawn time
+	vec3_t mins;						//mins of the item
+	vec3_t maxs;						//maxs of the item
+	int number;							//number of the item info
+} iteminfo_t;
+
+#define ITEMINFO_OFS(x)	(int)&(((iteminfo_t *)0)->x)
+
+fielddef_t iteminfo_fields[] =
+{
+{"name", ITEMINFO_OFS(name), FT_STRING},
+{"model", ITEMINFO_OFS(model), FT_STRING},
+{"modelindex", ITEMINFO_OFS(modelindex), FT_INT},
+{"type", ITEMINFO_OFS(type), FT_INT},
+{"index", ITEMINFO_OFS(index), FT_INT},
+{"respawntime", ITEMINFO_OFS(respawntime), FT_FLOAT},
+{"mins", ITEMINFO_OFS(mins), FT_FLOAT|FT_ARRAY, 3},
+{"maxs", ITEMINFO_OFS(maxs), FT_FLOAT|FT_ARRAY, 3},
+{0, 0, 0}
+};
+
+structdef_t iteminfo_struct =
+{
+	sizeof(iteminfo_t), iteminfo_fields
+};
+
+typedef struct itemconfig_s
+{
+	int numiteminfo;
+	iteminfo_t *iteminfo;
+} itemconfig_t;
+
+//goal state
+typedef struct bot_goalstate_s
+{
+	struct weightconfig_s *itemweightconfig;	//weight config
+	int *itemweightindex;						//index from item to weight
+	//
+	int client;									//client using this goal state
+	int lastreachabilityarea;					//last area with reachabilities the bot was in
+	//
+	bot_goal_t goalstack[MAX_GOALSTACK];		//goal stack
+	int goalstacktop;							//the top of the goal stack
+	//
+	int avoidgoals[MAX_AVOIDGOALS];				//goals to avoid
+	float avoidgoaltimes[MAX_AVOIDGOALS];		//times to avoid the goals
+} bot_goalstate_t;
+
+bot_goalstate_t *botgoalstates[MAX_CLIENTS + 1]; // bk001206 - FIXME: init?
+//item configuration
+itemconfig_t *itemconfig = NULL; // bk001206 - init
+//level items
+levelitem_t *levelitemheap = NULL; // bk001206 - init
+levelitem_t *freelevelitems = NULL; // bk001206 - init
+levelitem_t *levelitems = NULL; // bk001206 - init
+int numlevelitems = 0;
+//map locations
+maplocation_t *maplocations = NULL; // bk001206 - init
+//camp spots
+campspot_t *campspots = NULL; // bk001206 - init
+//the game type
+int g_gametype = 0; // bk001206 - init
+//additional dropped item weight
+libvar_t *droppedweight = NULL; // bk001206 - init
+
+//========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//========================================================================
+bot_goalstate_t *BotGoalStateFromHandle(int handle)
+{
+	if (handle <= 0 || handle > MAX_CLIENTS)
+	{
+		botimport.Print(PRT_FATAL, "goal state handle %d out of range\n", handle);
+		return NULL;
+	} //end if
+	if (!botgoalstates[handle])
+	{
+		botimport.Print(PRT_FATAL, "invalid goal state %d\n", handle);
+		return NULL;
+	} //end if
+	return botgoalstates[handle];
+} //end of the function BotGoalStateFromHandle
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void BotInterbreedGoalFuzzyLogic(int parent1, int parent2, int child)
+{
+	bot_goalstate_t *p1, *p2, *c;
+
+	p1 = BotGoalStateFromHandle(parent1);
+	p2 = BotGoalStateFromHandle(parent2);
+	c = BotGoalStateFromHandle(child);
+
+	InterbreedWeightConfigs(p1->itemweightconfig, p2->itemweightconfig,
+									c->itemweightconfig);
+} //end of the function BotInterbreedingGoalFuzzyLogic
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void BotSaveGoalFuzzyLogic(int goalstate, char *filename)
+{
+	bot_goalstate_t *gs;
+
+	gs = BotGoalStateFromHandle(goalstate);
+
+	//WriteWeightConfig(filename, gs->itemweightconfig);
+} //end of the function BotSaveGoalFuzzyLogic
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void BotMutateGoalFuzzyLogic(int goalstate, float range)
+{
+	bot_goalstate_t *gs;
+
+	gs = BotGoalStateFromHandle(goalstate);
+
+	EvolveWeightConfig(gs->itemweightconfig);
+} //end of the function BotMutateGoalFuzzyLogic
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+itemconfig_t *LoadItemConfig(char *filename)
+{
+	int max_iteminfo;
+	token_t token;
+	char path[MAX_PATH];
+	source_t *source;
+	itemconfig_t *ic;
+	iteminfo_t *ii;
+
+	max_iteminfo = (int) LibVarValue("max_iteminfo", "256");
+	if (max_iteminfo < 0)
+	{
+		botimport.Print(PRT_ERROR, "max_iteminfo = %d\n", max_iteminfo);
+		max_iteminfo = 256;
+		LibVarSet( "max_iteminfo", "256" );
+	}
+
+	strncpy( path, filename, MAX_PATH );
+	PC_SetBaseFolder(BOTFILESBASEFOLDER);
+	source = LoadSourceFile( path );
+	if( !source ) {
+		botimport.Print( PRT_ERROR, "counldn't load %s\n", path );
+		return NULL;
+	} //end if
+	//initialize item config
+	ic = (itemconfig_t *) GetClearedHunkMemory(sizeof(itemconfig_t) +
+														max_iteminfo * sizeof(iteminfo_t));
+	ic->iteminfo = (iteminfo_t *) ((char *) ic + sizeof(itemconfig_t));
+	ic->numiteminfo = 0;
+	//parse the item config file
+	while(PC_ReadToken(source, &token))
+	{
+		if (!strcmp(token.string, "iteminfo"))
+		{
+			if (ic->numiteminfo >= max_iteminfo)
+			{
+				SourceError(source, "more than %d item info defined\n", max_iteminfo);
+				FreeMemory(ic);
+				FreeSource(source);
+				return NULL;
+			} //end if
+			ii = &ic->iteminfo[ic->numiteminfo];
+			Com_Memset(ii, 0, sizeof(iteminfo_t));
+			if (!PC_ExpectTokenType(source, TT_STRING, 0, &token))
+			{
+				FreeMemory(ic);
+				FreeMemory(source);
+				return NULL;
+			} //end if
+			StripDoubleQuotes(token.string);
+			strncpy(ii->classname, token.string, sizeof(ii->classname)-1);
+			if (!ReadStructure(source, &iteminfo_struct, (char *) ii))
+			{
+				FreeMemory(ic);
+				FreeSource(source);
+				return NULL;
+			} //end if
+			ii->number = ic->numiteminfo;
+			ic->numiteminfo++;
+		} //end if
+		else
+		{
+			SourceError(source, "unknown definition %s\n", token.string);
+			FreeMemory(ic);
+			FreeSource(source);
+			return NULL;
+		} //end else
+	} //end while
+	FreeSource(source);
+	//
+	if (!ic->numiteminfo) botimport.Print(PRT_WARNING, "no item info loaded\n");
+	botimport.Print(PRT_MESSAGE, "loaded %s\n", path);
+	return ic;
+} //end of the function LoadItemConfig
+//===========================================================================
+// index to find the weight function of an iteminfo
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int *ItemWeightIndex(weightconfig_t *iwc, itemconfig_t *ic)
+{
+	int *index, i;
+
+	//initialize item weight index
+	index = (int *) GetClearedMemory(sizeof(int) * ic->numiteminfo);
+
+	for (i = 0; i < ic->numiteminfo; i++)
+	{
+		index[i] = FindFuzzyWeight(iwc, ic->iteminfo[i].classname);
+		if (index[i] < 0)
+		{
+			Log_Write("item info %d \"%s\" has no fuzzy weight\r\n", i, ic->iteminfo[i].classname);
+		} //end if
+	} //end for
+	return index;
+} //end of the function ItemWeightIndex
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void InitLevelItemHeap(void)
+{
+	int i, max_levelitems;
+
+	if (levelitemheap) FreeMemory(levelitemheap);
+
+	max_levelitems = (int) LibVarValue("max_levelitems", "256");
+	levelitemheap = (levelitem_t *) GetClearedMemory(max_levelitems * sizeof(levelitem_t));
+
+	for (i = 0; i < max_levelitems-1; i++)
+	{
+		levelitemheap[i].next = &levelitemheap[i + 1];
+	} //end for
+	levelitemheap[max_levelitems-1].next = NULL;
+	//
+	freelevelitems = levelitemheap;
+} //end of the function InitLevelItemHeap
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+levelitem_t *AllocLevelItem(void)
+{
+	levelitem_t *li;
+
+	li = freelevelitems;
+	if (!li)
+	{
+		botimport.Print(PRT_FATAL, "out of level items\n");
+		return NULL;
+	} //end if
+	//
+	freelevelitems = freelevelitems->next;
+	Com_Memset(li, 0, sizeof(levelitem_t));
+	return li;
+} //end of the function AllocLevelItem
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void FreeLevelItem(levelitem_t *li)
+{
+	li->next = freelevelitems;
+	freelevelitems = li;
+} //end of the function FreeLevelItem
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void AddLevelItemToList(levelitem_t *li)
+{
+	if (levelitems) levelitems->prev = li;
+	li->prev = NULL;
+	li->next = levelitems;
+	levelitems = li;
+} //end of the function AddLevelItemToList
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void RemoveLevelItemFromList(levelitem_t *li)
+{
+	if (li->prev) li->prev->next = li->next;
+	else levelitems = li->next;
+	if (li->next) li->next->prev = li->prev;
+} //end of the function RemoveLevelItemFromList
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+void BotFreeInfoEntities(void)
+{
+	maplocation_t *ml, *nextml;
+	campspot_t *cs, *nextcs;
+
+	for (ml = maplocations; ml; ml = nextml)
+	{
+		nextml = ml->next;
+		FreeMemory(ml);
+	} //end for
+	maplocations = NULL;
+	for (cs = campspots; cs; cs = nextcs)
+	{
+		nextcs = cs->next;
+		FreeMemory(cs);
+	} //end for
+	campspots = NULL;
+} //end of the function BotFreeInfoEntities
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+void BotInitInfoEntities(void)
+{
+	char classname[MAX_EPAIRKEY];
+	maplocation_t *ml;
+	campspot_t *cs;
+	int ent, numlocations, numcampspots;
+
+	BotFreeInfoEntities();
+	//
+	numlocations = 0;
+	numcampspots = 0;
+	for (ent = AAS_NextBSPEntity(0); ent; ent = AAS_NextBSPEntity(ent))
+	{
+		if (!AAS_ValueForBSPEpairKey(ent, "classname", classname, MAX_EPAIRKEY)) continue;
+
+		//map locations
+		if (!strcmp(classname, "target_location"))
+		{
+			ml = (maplocation_t *) GetClearedMemory(sizeof(maplocation_t));
+			AAS_VectorForBSPEpairKey(ent, "origin", ml->origin);
+			AAS_ValueForBSPEpairKey(ent, "message", ml->name, sizeof(ml->name));
+			ml->areanum = AAS_PointAreaNum(ml->origin);
+			ml->next = maplocations;
+			maplocations = ml;
+			numlocations++;
+		} //end if
+		//camp spots
+		else if (!strcmp(classname, "info_camp"))
+		{
+			cs = (campspot_t *) GetClearedMemory(sizeof(campspot_t));
+			AAS_VectorForBSPEpairKey(ent, "origin", cs->origin);
+			//cs->origin[2] += 16;
+			AAS_ValueForBSPEpairKey(ent, "message", cs->name, sizeof(cs->name));
+			AAS_FloatForBSPEpairKey(ent, "range", &cs->range);
+			AAS_FloatForBSPEpairKey(ent, "weight", &cs->weight);
+			AAS_FloatForBSPEpairKey(ent, "wait", &cs->wait);
+			AAS_FloatForBSPEpairKey(ent, "random", &cs->random);
+			cs->areanum = AAS_PointAreaNum(cs->origin);
+			if (!cs->areanum)
+			{
+				botimport.Print(PRT_MESSAGE, "camp spot at %1.1f %1.1f %1.1f in solid\n", cs->origin[0], cs->origin[1], cs->origin[2]);
+				FreeMemory(cs);
+				continue;
+			} //end if
+			cs->next = campspots;
+			campspots = cs;
+			//AAS_DrawPermanentCross(cs->origin, 4, LINECOLOR_YELLOW);
+			numcampspots++;
+		} //end else if
+	} //end for
+	if (bot_developer)
+	{
+		botimport.Print(PRT_MESSAGE, "%d map locations\n", numlocations);
+		botimport.Print(PRT_MESSAGE, "%d camp spots\n", numcampspots);
+	} //end if
+} //end of the function BotInitInfoEntities
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+void BotInitLevelItems(void)
+{
+	int i, spawnflags, value;
+	char classname[MAX_EPAIRKEY];
+	vec3_t origin, end;
+	int ent, goalareanum;
+	itemconfig_t *ic;
+	levelitem_t *li;
+	bsp_trace_t trace;
+
+	//initialize the map locations and camp spots
+	BotInitInfoEntities();
+
+	//initialize the level item heap
+	InitLevelItemHeap();
+	levelitems = NULL;
+	numlevelitems = 0;
+	//
+	ic = itemconfig;
+	if (!ic) return;
+
+	//if there's no AAS file loaded
+	if (!AAS_Loaded()) return;
+
+	//update the modelindexes of the item info
+	for (i = 0; i < ic->numiteminfo; i++)
+	{
+		//ic->iteminfo[i].modelindex = AAS_IndexFromModel(ic->iteminfo[i].model);
+		if (!ic->iteminfo[i].modelindex)
+		{
+			Log_Write("item %s has modelindex 0", ic->iteminfo[i].classname);
+		} //end if
+	} //end for
+
+	for (ent = AAS_NextBSPEntity(0); ent; ent = AAS_NextBSPEntity(ent))
+	{
+		if (!AAS_ValueForBSPEpairKey(ent, "classname", classname, MAX_EPAIRKEY)) continue;
+		//
+		spawnflags = 0;
+		AAS_IntForBSPEpairKey(ent, "spawnflags", &spawnflags);
+		//
+		for (i = 0; i < ic->numiteminfo; i++)
+		{
+			if (!strcmp(classname, ic->iteminfo[i].classname)) break;
+		} //end for
+		if (i >= ic->numiteminfo)
+		{
+			Log_Write("entity %s unknown item\r\n", classname);
+			continue;
+		} //end if
+		//get the origin of the item
+		if (!AAS_VectorForBSPEpairKey(ent, "origin", origin))
+		{
+			botimport.Print(PRT_ERROR, "item %s without origin\n", classname);
+			continue;
+		} //end else
+		//
+		goalareanum = 0;
+		//if it is a floating item
+		if (spawnflags & 1)
+		{
+			//if the item is not floating in water
+			if (!(AAS_PointContents(origin) & CONTENTS_WATER))
+			{
+				VectorCopy(origin, end);
+				end[2] -= 32;
+				trace = AAS_Trace(origin, ic->iteminfo[i].mins, ic->iteminfo[i].maxs, end, -1, CONTENTS_SOLID|CONTENTS_PLAYERCLIP);
+				//if the item not near the ground
+				if (trace.fraction >= 1)
+				{
+					//if the item is not reachable from a jumppad
+					goalareanum = AAS_BestReachableFromJumpPadArea(origin, ic->iteminfo[i].mins, ic->iteminfo[i].maxs);
+					Log_Write("item %s reachable from jumppad area %d\r\n", ic->iteminfo[i].classname, goalareanum);
+					//botimport.Print(PRT_MESSAGE, "item %s reachable from jumppad area %d\r\n", ic->iteminfo[i].classname, goalareanum);
+					if (!goalareanum) continue;
+				} //end if
+			} //end if
+		} //end if
+
+		li = AllocLevelItem();
+		if (!li) return;
+		//
+		li->number = ++numlevelitems;
+		li->timeout = 0;
+		li->entitynum = 0;
+		//
+		li->flags = 0;
+		AAS_IntForBSPEpairKey(ent, "notfree", &value);
+		if (value) li->flags |= IFL_NOTFREE;
+		AAS_IntForBSPEpairKey(ent, "notteam", &value);
+		if (value) li->flags |= IFL_NOTTEAM;
+		AAS_IntForBSPEpairKey(ent, "notsingle", &value);
+		if (value) li->flags |= IFL_NOTSINGLE;
+		AAS_IntForBSPEpairKey(ent, "notbot", &value);
+		if (value) li->flags |= IFL_NOTBOT;
+		if (!strcmp(classname, "item_botroam"))
+		{
+			li->flags |= IFL_ROAM;
+			AAS_FloatForBSPEpairKey(ent, "weight", &li->weight);
+		} //end if
+		//if not a stationary item
+		if (!(spawnflags & 1))
+		{
+			if (!AAS_DropToFloor(origin, ic->iteminfo[i].mins, ic->iteminfo[i].maxs))
+			{
+				botimport.Print(PRT_MESSAGE, "%s in solid at (%1.1f %1.1f %1.1f)\n",
+												classname, origin[0], origin[1], origin[2]);
+			} //end if
+		} //end if
+		//item info of the level item
+		li->iteminfo = i;
+		//origin of the item
+		VectorCopy(origin, li->origin);
+		//
+		if (goalareanum)
+		{
+			li->goalareanum = goalareanum;
+			VectorCopy(origin, li->goalorigin);
+		} //end if
+		else
+		{
+			//get the item goal area and goal origin
+			li->goalareanum = AAS_BestReachableArea(origin,
+							ic->iteminfo[i].mins, ic->iteminfo[i].maxs,
+							li->goalorigin);
+			if (!li->goalareanum)
+			{
+				botimport.Print(PRT_MESSAGE, "%s not reachable for bots at (%1.1f %1.1f %1.1f)\n",
+												classname, origin[0], origin[1], origin[2]);
+			} //end if
+		} //end else
+		//
+		AddLevelItemToList(li);
+	} //end for
+	botimport.Print(PRT_MESSAGE, "found %d level items\n", numlevelitems);
+} //end of the function BotInitLevelItems
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void BotGoalName(int number, char *name, int size)
+{
+	levelitem_t *li;
+
+	if (!itemconfig) return;
+	//
+	for (li = levelitems; li; li = li->next)
+	{
+		if (li->number == number)
+		{
+			strncpy(name, itemconfig->iteminfo[li->iteminfo].name, size-1);
+			name[size-1] = '\0';
+			return;
+		} //end for
+	} //end for
+	strcpy(name, "");
+	return;
+} //end of the function BotGoalName
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void BotResetAvoidGoals(int goalstate)
+{
+	bot_goalstate_t *gs;
+
+	gs = BotGoalStateFromHandle(goalstate);
+	if (!gs) return;
+	Com_Memset(gs->avoidgoals, 0, MAX_AVOIDGOALS * sizeof(int));
+	Com_Memset(gs->avoidgoaltimes, 0, MAX_AVOIDGOALS * sizeof(float));
+} //end of the function BotResetAvoidGoals
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void BotDumpAvoidGoals(int goalstate)
+{
+	int i;
+	bot_goalstate_t *gs;
+	char name[32];
+
+	gs = BotGoalStateFromHandle(goalstate);
+	if (!gs) return;
+	for (i = 0; i < MAX_AVOIDGOALS; i++)
+	{
+		if (gs->avoidgoaltimes[i] >= AAS_Time())
+		{
+			BotGoalName(gs->avoidgoals[i], name, 32);
+			Log_Write("avoid goal %s, number %d for %f seconds", name,
+				gs->avoidgoals[i], gs->avoidgoaltimes[i] - AAS_Time());
+		} //end if
+	} //end for
+} //end of the function BotDumpAvoidGoals
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void BotAddToAvoidGoals(bot_goalstate_t *gs, int number, float avoidtime)
+{
+	int i;
+
+	for (i = 0; i < MAX_AVOIDGOALS; i++)
+	{
+		//if the avoid goal is already stored
+		if (gs->avoidgoals[i] == number)
+		{
+			gs->avoidgoals[i] = number;
+			gs->avoidgoaltimes[i] = AAS_Time() + avoidtime;
+			return;
+		} //end if
+	} //end for
+
+	for (i = 0; i < MAX_AVOIDGOALS; i++)
+	{
+		//if this avoid goal has expired
+		if (gs->avoidgoaltimes[i] < AAS_Time())
+		{
+			gs->avoidgoals[i] = number;
+			gs->avoidgoaltimes[i] = AAS_Time() + avoidtime;
+			return;
+		} //end if
+	} //end for
+} //end of the function BotAddToAvoidGoals
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+void BotRemoveFromAvoidGoals(int goalstate, int number)
+{
+	int i;
+	bot_goalstate_t *gs;
+
+	gs = BotGoalStateFromHandle(goalstate);
+	if (!gs) return;
+	//don't use the goals the bot wants to avoid
+	for (i = 0; i < MAX_AVOIDGOALS; i++)
+	{
+		if (gs->avoidgoals[i] == number && gs->avoidgoaltimes[i] >= AAS_Time())
+		{
+			gs->avoidgoaltimes[i] = 0;
+			return;
+		} //end if
+	} //end for
+} //end of the function BotRemoveFromAvoidGoals
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+float BotAvoidGoalTime(int goalstate, int number)
+{
+	int i;
+	bot_goalstate_t *gs;
+
+	gs = BotGoalStateFromHandle(goalstate);
+	if (!gs) return 0;
+	//don't use the goals the bot wants to avoid
+	for (i = 0; i < MAX_AVOIDGOALS; i++)
+	{
+		if (gs->avoidgoals[i] == number && gs->avoidgoaltimes[i] >= AAS_Time())
+		{
+			return gs->avoidgoaltimes[i] - AAS_Time();
+		} //end if
+	} //end for
+	return 0;
+} //end of the function BotAvoidGoalTime
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+void BotSetAvoidGoalTime(int goalstate, int number, float avoidtime)
+{
+	bot_goalstate_t *gs;
+	levelitem_t *li;
+
+	gs = BotGoalStateFromHandle(goalstate);
+	if (!gs)
+		return;
+	if (avoidtime < 0)
+	{
+		if (!itemconfig)
+			return;
+		//
+		for (li = levelitems; li; li = li->next)
+		{
+			if (li->number == number)
+			{
+				avoidtime = itemconfig->iteminfo[li->iteminfo].respawntime;
+				if (!avoidtime)
+					avoidtime = AVOID_DEFAULT_TIME;
+				if (avoidtime < AVOID_MINIMUM_TIME)
+					avoidtime = AVOID_MINIMUM_TIME;
+				BotAddToAvoidGoals(gs, number, avoidtime);
+				return;
+			} //end for
+		} //end for
+		return;
+	} //end if
+	else
+	{
+		BotAddToAvoidGoals(gs, number, avoidtime);
+	} //end else
+} //end of the function BotSetAvoidGoalTime
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+int BotGetLevelItemGoal(int index, char *name, bot_goal_t *goal)
+{
+	levelitem_t *li;
+
+	if (!itemconfig) return -1;
+	li = levelitems;
+	if (index >= 0)
+	{
+		for (; li; li = li->next)
+		{
+			if (li->number == index)
+			{
+				li = li->next;
+				break;
+			} //end if
+		} //end for
+	} //end for
+	for (; li; li = li->next)
+	{
+		//
+		if (g_gametype == GT_SINGLE_PLAYER) {
+			if (li->flags & IFL_NOTSINGLE) continue;
+		}
+		else if (g_gametype >= GT_TEAM) {
+			if (li->flags & IFL_NOTTEAM) continue;
+		}
+		else {
+			if (li->flags & IFL_NOTFREE) continue;
+		}
+		if (li->flags & IFL_NOTBOT) continue;
+		//
+		if (!Q_stricmp(name, itemconfig->iteminfo[li->iteminfo].name))
+		{
+			goal->areanum = li->goalareanum;
+			VectorCopy(li->goalorigin, goal->origin);
+			goal->entitynum = li->entitynum;
+			VectorCopy(itemconfig->iteminfo[li->iteminfo].mins, goal->mins);
+			VectorCopy(itemconfig->iteminfo[li->iteminfo].maxs, goal->maxs);
+			goal->number = li->number;
+			goal->flags = GFL_ITEM;
+			if (li->timeout) goal->flags |= GFL_DROPPED;
+			//botimport.Print(PRT_MESSAGE, "found li %s\n", itemconfig->iteminfo[li->iteminfo].name);
+			return li->number;
+		} //end if
+	} //end for
+	return -1;
+} //end of the function BotGetLevelItemGoal
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+int BotGetMapLocationGoal(char *name, bot_goal_t *goal)
+{
+	maplocation_t *ml;
+	vec3_t mins = {-8, -8, -8}, maxs = {8, 8, 8};
+
+	for (ml = maplocations; ml; ml = ml->next)
+	{
+		if (!Q_stricmp(ml->name, name))
+		{
+			goal->areanum = ml->areanum;
+			VectorCopy(ml->origin, goal->origin);
+			goal->entitynum = 0;
+			VectorCopy(mins, goal->mins);
+			VectorCopy(maxs, goal->maxs);
+			return qtrue;
+		} //end if
+	} //end for
+	return qfalse;
+} //end of the function BotGetMapLocationGoal
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+int BotGetNextCampSpotGoal(int num, bot_goal_t *goal)
+{
+	int i;
+	campspot_t *cs;
+	vec3_t mins = {-8, -8, -8}, maxs = {8, 8, 8};
+
+	if (num < 0) num = 0;
+	i = num;
+	for (cs = campspots; cs; cs = cs->next)
+	{
+		if (--i < 0)
+		{
+			goal->areanum = cs->areanum;
+			VectorCopy(cs->origin, goal->origin);
+			goal->entitynum = 0;
+			VectorCopy(mins, goal->mins);
+			VectorCopy(maxs, goal->maxs);
+			return num+1;
+		} //end if
+	} //end for
+	return 0;
+} //end of the function BotGetNextCampSpotGoal
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+void BotFindEntityForLevelItem(levelitem_t *li)
+{
+	int ent, modelindex;
+	itemconfig_t *ic;
+	aas_entityinfo_t entinfo;
+	vec3_t dir;
+
+	ic = itemconfig;
+	if (!itemconfig) return;
+	for (ent = AAS_NextEntity(0); ent; ent = AAS_NextEntity(ent))
+	{
+		//get the model index of the entity
+		modelindex = AAS_EntityModelindex(ent);
+		//
+		if (!modelindex) continue;
+		//get info about the entity
+		AAS_EntityInfo(ent, &entinfo);
+		//if the entity is still moving
+		if (entinfo.origin[0] != entinfo.lastvisorigin[0] ||
+				entinfo.origin[1] != entinfo.lastvisorigin[1] ||
+				entinfo.origin[2] != entinfo.lastvisorigin[2]) continue;
+		//
+		if (ic->iteminfo[li->iteminfo].modelindex == modelindex)
+		{
+			//check if the entity is very close
+			VectorSubtract(li->origin, entinfo.origin, dir);
+			if (VectorLength(dir) < 30)
+			{
+				//found an entity for this level item
+				li->entitynum = ent;
+			} //end if
+		} //end if
+	} //end for
+} //end of the function BotFindEntityForLevelItem
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+
+//NOTE: enum entityType_t in bg_public.h
+#define ET_ITEM			2
+
+void BotUpdateEntityItems(void)
+{
+	int ent, i, modelindex;
+	vec3_t dir;
+	levelitem_t *li, *nextli;
+	aas_entityinfo_t entinfo;
+	itemconfig_t *ic;
+
+	//timeout current entity items if necessary
+	for (li = levelitems; li; li = nextli)
+	{
+		nextli = li->next;
+		//if it is a item that will time out
+		if (li->timeout)
+		{
+			//timeout the item
+			if (li->timeout < AAS_Time())
+			{
+				RemoveLevelItemFromList(li);
+				FreeLevelItem(li);
+			} //end if
+		} //end if
+	} //end for
+	//find new entity items
+	ic = itemconfig;
+	if (!itemconfig) return;
+	//
+	for (ent = AAS_NextEntity(0); ent; ent = AAS_NextEntity(ent))
+	{
+		if (AAS_EntityType(ent) != ET_ITEM) continue;
+		//get the model index of the entity
+		modelindex = AAS_EntityModelindex(ent);
+		//
+		if (!modelindex) continue;
+		//get info about the entity
+		AAS_EntityInfo(ent, &entinfo);
+		//FIXME: don't do this
+		//skip all floating items for now
+		//if (entinfo.groundent != ENTITYNUM_WORLD) continue;
+		//if the entity is still moving
+		if (entinfo.origin[0] != entinfo.lastvisorigin[0] ||
+				entinfo.origin[1] != entinfo.lastvisorigin[1] ||
+				entinfo.origin[2] != entinfo.lastvisorigin[2]) continue;
+		//check if the entity is already stored as a level item
+		for (li = levelitems; li; li = li->next)
+		{
+			//if the level item is linked to an entity
+			if (li->entitynum && li->entitynum == ent)
+			{
+				//the entity is re-used if the models are different
+				if (ic->iteminfo[li->iteminfo].modelindex != modelindex)
+				{
+					//remove this level item
+					RemoveLevelItemFromList(li);
+					FreeLevelItem(li);
+					li = NULL;
+					break;
+				} //end if
+				else
+				{
+					if (entinfo.origin[0] != li->origin[0] ||
+						entinfo.origin[1] != li->origin[1] ||
+						entinfo.origin[2] != li->origin[2])
+					{
+						VectorCopy(entinfo.origin, li->origin);
+						//also update the goal area number
+						li->goalareanum = AAS_BestReachableArea(li->origin,
+										ic->iteminfo[li->iteminfo].mins, ic->iteminfo[li->iteminfo].maxs,
+										li->goalorigin);
+					} //end if
+					break;
+				} //end else
+			} //end if
+		} //end for
+		if (li) continue;
+		//try to link the entity to a level item
+		for (li = levelitems; li; li = li->next)
+		{
+			//if this level item is already linked
+			if (li->entitynum) continue;
+			//
+			if (g_gametype == GT_SINGLE_PLAYER) {
+				if (li->flags & IFL_NOTSINGLE) continue;
+			}
+			else if (g_gametype >= GT_TEAM) {
+				if (li->flags & IFL_NOTTEAM) continue;
+			}
+			else {
+				if (li->flags & IFL_NOTFREE) continue;
+			}
+			//if the model of the level item and the entity are the same
+			if (ic->iteminfo[li->iteminfo].modelindex == modelindex)
+			{
+				//check if the entity is very close
+				VectorSubtract(li->origin, entinfo.origin, dir);
+				if (VectorLength(dir) < 30)
+				{
+					//found an entity for this level item
+					li->entitynum = ent;
+					//if the origin is different
+					if (entinfo.origin[0] != li->origin[0] ||
+						entinfo.origin[1] != li->origin[1] ||
+						entinfo.origin[2] != li->origin[2])
+					{
+						//update the level item origin
+						VectorCopy(entinfo.origin, li->origin);
+						//also update the goal area number
+						li->goalareanum = AAS_BestReachableArea(li->origin,
+										ic->iteminfo[li->iteminfo].mins, ic->iteminfo[li->iteminfo].maxs,
+										li->goalorigin);
+					} //end if
+#ifdef DEBUG
+					Log_Write("linked item %s to an entity", ic->iteminfo[li->iteminfo].classname);
+#endif //DEBUG
+					break;
+				} //end if
+			} //end else
+		} //end for
+		if (li) continue;
+		//check if the model is from a known item
+		for (i = 0; i < ic->numiteminfo; i++)
+		{
+			if (ic->iteminfo[i].modelindex == modelindex)
+			{
+				break;
+			} //end if
+		} //end for
+		//if the model is not from a known item
+		if (i >= ic->numiteminfo) continue;
+		//allocate a new level item
+		li = AllocLevelItem();
+		//
+		if (!li) continue;
+		//entity number of the level item
+		li->entitynum = ent;
+		//number for the level item
+		li->number = numlevelitems + ent;
+		//set the item info index for the level item
+		li->iteminfo = i;
+		//origin of the item
+		VectorCopy(entinfo.origin, li->origin);
+		//get the item goal area and goal origin
+		li->goalareanum = AAS_BestReachableArea(li->origin,
+									ic->iteminfo[i].mins, ic->iteminfo[i].maxs,
+									li->goalorigin);
+		//never go for items dropped into jumppads
+		if (AAS_AreaJumpPad(li->goalareanum))
+		{
+			FreeLevelItem(li);
+			continue;
+		} //end if
+		//time this item out after 30 seconds
+		//dropped items disappear after 30 seconds
+		li->timeout = AAS_Time() + 30;
+		//add the level item to the list
+		AddLevelItemToList(li);
+		//botimport.Print(PRT_MESSAGE, "found new level item %s\n", ic->iteminfo[i].classname);
+	} //end for
+	/*
+	for (li = levelitems; li; li = li->next)
+	{
+		if (!li->entitynum)
+		{
+			BotFindEntityForLevelItem(li);
+		} //end if
+	} //end for*/
+} //end of the function BotUpdateEntityItems
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void BotDumpGoalStack(int goalstate)
+{
+	int i;
+	bot_goalstate_t *gs;
+	char name[32];
+
+	gs = BotGoalStateFromHandle(goalstate);
+	if (!gs) return;
+	for (i = 1; i <= gs->goalstacktop; i++)
+	{
+		BotGoalName(gs->goalstack[i].number, name, 32);
+		Log_Write("%d: %s", i, name);
+	} //end for
+} //end of the function BotDumpGoalStack
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void BotPushGoal(int goalstate, bot_goal_t *goal)
+{
+	bot_goalstate_t *gs;
+
+	gs = BotGoalStateFromHandle(goalstate);
+	if (!gs) return;
+	if (gs->goalstacktop >= MAX_GOALSTACK-1)
+	{
+		botimport.Print(PRT_ERROR, "goal heap overflow\n");
+		BotDumpGoalStack(goalstate);
+		return;
+	} //end if
+	gs->goalstacktop++;
+	Com_Memcpy(&gs->goalstack[gs->goalstacktop], goal, sizeof(bot_goal_t));
+} //end of the function BotPushGoal
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void BotPopGoal(int goalstate)
+{
+	bot_goalstate_t *gs;
+
+	gs = BotGoalStateFromHandle(goalstate);
+	if (!gs) return;
+	if (gs->goalstacktop > 0) gs->goalstacktop--;
+} //end of the function BotPopGoal
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void BotEmptyGoalStack(int goalstate)
+{
+	bot_goalstate_t *gs;
+
+	gs = BotGoalStateFromHandle(goalstate);
+	if (!gs) return;
+	gs->goalstacktop = 0;
+} //end of the function BotEmptyGoalStack
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int BotGetTopGoal(int goalstate, bot_goal_t *goal)
+{
+	bot_goalstate_t *gs;
+
+	gs = BotGoalStateFromHandle(goalstate);
+	if (!gs) return qfalse;
+	if (!gs->goalstacktop) return qfalse;
+	Com_Memcpy(goal, &gs->goalstack[gs->goalstacktop], sizeof(bot_goal_t));
+	return qtrue;
+} //end of the function BotGetTopGoal
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int BotGetSecondGoal(int goalstate, bot_goal_t *goal)
+{
+	bot_goalstate_t *gs;
+
+	gs = BotGoalStateFromHandle(goalstate);
+	if (!gs) return qfalse;
+	if (gs->goalstacktop <= 1) return qfalse;
+	Com_Memcpy(goal, &gs->goalstack[gs->goalstacktop-1], sizeof(bot_goal_t));
+	return qtrue;
+} //end of the function BotGetSecondGoal
+//===========================================================================
+// pops a new long term goal on the goal stack in the goalstate
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int BotChooseLTGItem(int goalstate, vec3_t origin, int *inventory, int travelflags)
+{
+	int areanum, t, weightnum;
+	float weight, bestweight, avoidtime;
+	iteminfo_t *iteminfo;
+	itemconfig_t *ic;
+	levelitem_t *li, *bestitem;
+	bot_goal_t goal;
+	bot_goalstate_t *gs;
+
+	gs = BotGoalStateFromHandle(goalstate);
+	if (!gs)
+		return qfalse;
+	if (!gs->itemweightconfig)
+		return qfalse;
+	//get the area the bot is in
+	areanum = BotReachabilityArea(origin, gs->client);
+	//if the bot is in solid or if the area the bot is in has no reachability links
+	if (!areanum || !AAS_AreaReachability(areanum))
+	{
+		//use the last valid area the bot was in
+		areanum = gs->lastreachabilityarea;
+	} //end if
+	//remember the last area with reachabilities the bot was in
+	gs->lastreachabilityarea = areanum;
+	//if still in solid
+	if (!areanum)
+		return qfalse;
+	//the item configuration
+	ic = itemconfig;
+	if (!itemconfig)
+		return qfalse;
+	//best weight and item so far
+	bestweight = 0;
+	bestitem = NULL;
+	Com_Memset(&goal, 0, sizeof(bot_goal_t));
+	//go through the items in the level
+	for (li = levelitems; li; li = li->next)
+	{
+		if (g_gametype == GT_SINGLE_PLAYER) {
+			if (li->flags & IFL_NOTSINGLE)
+				continue;
+		}
+		else if (g_gametype >= GT_TEAM) {
+			if (li->flags & IFL_NOTTEAM)
+				continue;
+		}
+		else {
+			if (li->flags & IFL_NOTFREE)
+				continue;
+		}
+		if (li->flags & IFL_NOTBOT)
+			continue;
+		//if the item is not in a possible goal area
+		if (!li->goalareanum)
+			continue;
+		//FIXME: is this a good thing? added this for items that never spawned into the game (f.i. CTF flags in obelisk)
+		if (!li->entitynum && !(li->flags & IFL_ROAM))
+			continue;
+		//get the fuzzy weight function for this item
+		iteminfo = &ic->iteminfo[li->iteminfo];
+		weightnum = gs->itemweightindex[iteminfo->number];
+		if (weightnum < 0)
+			continue;
+
+#ifdef UNDECIDEDFUZZY
+		weight = FuzzyWeightUndecided(inventory, gs->itemweightconfig, weightnum);
+#else
+		weight = FuzzyWeight(inventory, gs->itemweightconfig, weightnum);
+#endif //UNDECIDEDFUZZY
+#ifdef DROPPEDWEIGHT
+		//HACK: to make dropped items more attractive
+		if (li->timeout)
+			weight += droppedweight->value;
+#endif //DROPPEDWEIGHT
+		//use weight scale for item_botroam
+		if (li->flags & IFL_ROAM) weight *= li->weight;
+		//
+		if (weight > 0)
+		{
+			//get the travel time towards the goal area
+			t = AAS_AreaTravelTimeToGoalArea(areanum, origin, li->goalareanum, travelflags);
+			//if the goal is reachable
+			if (t > 0)
+			{
+				//if this item won't respawn before we get there
+				avoidtime = BotAvoidGoalTime(goalstate, li->number);
+				if (avoidtime - t * 0.009 > 0)
+					continue;
+				//
+				weight /= (float) t * TRAVELTIME_SCALE;
+				//
+				if (weight > bestweight)
+				{
+					bestweight = weight;
+					bestitem = li;
+				} //end if
+			} //end if
+		} //end if
+	} //end for
+	//if no goal item found
+	if (!bestitem)
+	{
+		/*
+		//if not in lava or slime
+		if (!AAS_AreaLava(areanum) && !AAS_AreaSlime(areanum))
+		{
+			if (AAS_RandomGoalArea(areanum, travelflags, &goal.areanum, goal.origin))
+			{
+				VectorSet(goal.mins, -15, -15, -15);
+				VectorSet(goal.maxs, 15, 15, 15);
+				goal.entitynum = 0;
+				goal.number = 0;
+				goal.flags = GFL_ROAM;
+				goal.iteminfo = 0;
+				//push the goal on the stack
+				BotPushGoal(goalstate, &goal);
+				//
+#ifdef DEBUG
+				botimport.Print(PRT_MESSAGE, "chosen roam goal area %d\n", goal.areanum);
+#endif //DEBUG
+				return qtrue;
+			} //end if
+		} //end if
+		*/
+		return qfalse;
+	} //end if
+	//create a bot goal for this item
+	iteminfo = &ic->iteminfo[bestitem->iteminfo];
+	VectorCopy(bestitem->goalorigin, goal.origin);
+	VectorCopy(iteminfo->mins, goal.mins);
+	VectorCopy(iteminfo->maxs, goal.maxs);
+	goal.areanum = bestitem->goalareanum;
+	goal.entitynum = bestitem->entitynum;
+	goal.number = bestitem->number;
+	goal.flags = GFL_ITEM;
+	if (bestitem->timeout)
+		goal.flags |= GFL_DROPPED;
+	if (bestitem->flags & IFL_ROAM)
+		goal.flags |= GFL_ROAM;
+	goal.iteminfo = bestitem->iteminfo;
+	//if it's a dropped item
+	if (bestitem->timeout)
+	{
+		avoidtime = AVOID_DROPPED_TIME;
+	} //end if
+	else
+	{
+		avoidtime = iteminfo->respawntime;
+		if (!avoidtime)
+			avoidtime = AVOID_DEFAULT_TIME;
+		if (avoidtime < AVOID_MINIMUM_TIME)
+			avoidtime = AVOID_MINIMUM_TIME;
+	} //end else
+	//add the chosen goal to the goals to avoid for a while
+	BotAddToAvoidGoals(gs, bestitem->number, avoidtime);
+	//push the goal on the stack
+	BotPushGoal(goalstate, &goal);
+	//
+	return qtrue;
+} //end of the function BotChooseLTGItem
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int BotChooseNBGItem(int goalstate, vec3_t origin, int *inventory, int travelflags,
+														bot_goal_t *ltg, float maxtime)
+{
+	int areanum, t, weightnum, ltg_time;
+	float weight, bestweight, avoidtime;
+	iteminfo_t *iteminfo;
+	itemconfig_t *ic;
+	levelitem_t *li, *bestitem;
+	bot_goal_t goal;
+	bot_goalstate_t *gs;
+
+	gs = BotGoalStateFromHandle(goalstate);
+	if (!gs)
+		return qfalse;
+	if (!gs->itemweightconfig)
+		return qfalse;
+	//get the area the bot is in
+	areanum = BotReachabilityArea(origin, gs->client);
+	//if the bot is in solid or if the area the bot is in has no reachability links
+	if (!areanum || !AAS_AreaReachability(areanum))
+	{
+		//use the last valid area the bot was in
+		areanum = gs->lastreachabilityarea;
+	} //end if
+	//remember the last area with reachabilities the bot was in
+	gs->lastreachabilityarea = areanum;
+	//if still in solid
+	if (!areanum)
+		return qfalse;
+	//
+	if (ltg) ltg_time = AAS_AreaTravelTimeToGoalArea(areanum, origin, ltg->areanum, travelflags);
+	else ltg_time = 99999;
+	//the item configuration
+	ic = itemconfig;
+	if (!itemconfig)
+		return qfalse;
+	//best weight and item so far
+	bestweight = 0;
+	bestitem = NULL;
+	Com_Memset(&goal, 0, sizeof(bot_goal_t));
+	//go through the items in the level
+	for (li = levelitems; li; li = li->next)
+	{
+		if (g_gametype == GT_SINGLE_PLAYER) {
+			if (li->flags & IFL_NOTSINGLE)
+				continue;
+		}
+		else if (g_gametype >= GT_TEAM) {
+			if (li->flags & IFL_NOTTEAM)
+				continue;
+		}
+		else {
+			if (li->flags & IFL_NOTFREE)
+				continue;
+		}
+		if (li->flags & IFL_NOTBOT)
+			continue;
+		//if the item is in a possible goal area
+		if (!li->goalareanum)
+			continue;
+		//FIXME: is this a good thing? added this for items that never spawned into the game (f.i. CTF flags in obelisk)
+		if (!li->entitynum && !(li->flags & IFL_ROAM))
+			continue;
+		//get the fuzzy weight function for this item
+		iteminfo = &ic->iteminfo[li->iteminfo];
+		weightnum = gs->itemweightindex[iteminfo->number];
+		if (weightnum < 0)
+			continue;
+		//
+#ifdef UNDECIDEDFUZZY
+		weight = FuzzyWeightUndecided(inventory, gs->itemweightconfig, weightnum);
+#else
+		weight = FuzzyWeight(inventory, gs->itemweightconfig, weightnum);
+#endif //UNDECIDEDFUZZY
+#ifdef DROPPEDWEIGHT
+		//HACK: to make dropped items more attractive
+		if (li->timeout)
+			weight += droppedweight->value;
+#endif //DROPPEDWEIGHT
+		//use weight scale for item_botroam
+		if (li->flags & IFL_ROAM) weight *= li->weight;
+		//
+		if (weight > 0)
+		{
+			//get the travel time towards the goal area
+			t = AAS_AreaTravelTimeToGoalArea(areanum, origin, li->goalareanum, travelflags);
+			//if the goal is reachable
+			if (t > 0 && t < maxtime)
+			{
+				//if this item won't respawn before we get there
+				avoidtime = BotAvoidGoalTime(goalstate, li->number);
+				if (avoidtime - t * 0.009 > 0)
+					continue;
+				//
+				weight /= (float) t * TRAVELTIME_SCALE;
+				//
+				if (weight > bestweight)
+				{
+					t = 0;
+					if (ltg && !li->timeout)
+					{
+						//get the travel time from the goal to the long term goal
+						t = AAS_AreaTravelTimeToGoalArea(li->goalareanum, li->goalorigin, ltg->areanum, travelflags);
+					} //end if
+					//if the travel back is possible and doesn't take too long
+					if (t <= ltg_time)
+					{
+						bestweight = weight;
+						bestitem = li;
+					} //end if
+				} //end if
+			} //end if
+		} //end if
+	} //end for
+	//if no goal item found
+	if (!bestitem)
+		return qfalse;
+	//create a bot goal for this item
+	iteminfo = &ic->iteminfo[bestitem->iteminfo];
+	VectorCopy(bestitem->goalorigin, goal.origin);
+	VectorCopy(iteminfo->mins, goal.mins);
+	VectorCopy(iteminfo->maxs, goal.maxs);
+	goal.areanum = bestitem->goalareanum;
+	goal.entitynum = bestitem->entitynum;
+	goal.number = bestitem->number;
+	goal.flags = GFL_ITEM;
+	if (bestitem->timeout)
+		goal.flags |= GFL_DROPPED;
+	if (bestitem->flags & IFL_ROAM)
+		goal.flags |= GFL_ROAM;
+	goal.iteminfo = bestitem->iteminfo;
+	//if it's a dropped item
+	if (bestitem->timeout)
+	{
+		avoidtime = AVOID_DROPPED_TIME;
+	} //end if
+	else
+	{
+		avoidtime = iteminfo->respawntime;
+		if (!avoidtime)
+			avoidtime = AVOID_DEFAULT_TIME;
+		if (avoidtime < AVOID_MINIMUM_TIME)
+			avoidtime = AVOID_MINIMUM_TIME;
+	} //end else
+	//add the chosen goal to the goals to avoid for a while
+	BotAddToAvoidGoals(gs, bestitem->number, avoidtime);
+	//push the goal on the stack
+	BotPushGoal(goalstate, &goal);
+	//
+	return qtrue;
+} //end of the function BotChooseNBGItem
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int BotTouchingGoal(vec3_t origin, bot_goal_t *goal)
+{
+	int i;
+	vec3_t boxmins, boxmaxs;
+	vec3_t absmins, absmaxs;
+	vec3_t safety_maxs = {0, 0, 0}; //{4, 4, 10};
+	vec3_t safety_mins = {0, 0, 0}; //{-4, -4, 0};
+
+	AAS_PresenceTypeBoundingBox(PRESENCE_NORMAL, boxmins, boxmaxs);
+	VectorSubtract(goal->mins, boxmaxs, absmins);
+	VectorSubtract(goal->maxs, boxmins, absmaxs);
+	VectorAdd(absmins, goal->origin, absmins);
+	VectorAdd(absmaxs, goal->origin, absmaxs);
+	//make the box a little smaller for safety
+	VectorSubtract(absmaxs, safety_maxs, absmaxs);
+	VectorSubtract(absmins, safety_mins, absmins);
+
+	for (i = 0; i < 3; i++)
+	{
+		if (origin[i] < absmins[i] || origin[i] > absmaxs[i]) return qfalse;
+	} //end for
+	return qtrue;
+} //end of the function BotTouchingGoal
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int BotItemGoalInVisButNotVisible(int viewer, vec3_t eye, vec3_t viewangles, bot_goal_t *goal)
+{
+	aas_entityinfo_t entinfo;
+	bsp_trace_t trace;
+	vec3_t middle;
+
+	if (!(goal->flags & GFL_ITEM)) return qfalse;
+	//
+	VectorAdd(goal->mins, goal->mins, middle);
+	VectorScale(middle, 0.5, middle);
+	VectorAdd(goal->origin, middle, middle);
+	//
+	trace = AAS_Trace(eye, NULL, NULL, middle, viewer, CONTENTS_SOLID);
+	//if the goal middle point is visible
+	if (trace.fraction >= 1)
+	{
+		//the goal entity number doesn't have to be valid
+		//just assume it's valid
+		if (goal->entitynum <= 0)
+			return qfalse;
+		//
+		//if the entity data isn't valid
+		AAS_EntityInfo(goal->entitynum, &entinfo);
+		//NOTE: for some wacko reason entities are sometimes
+		// not updated
+		//if (!entinfo.valid) return qtrue;
+		if (entinfo.ltime < AAS_Time() - 0.5)
+			return qtrue;
+	} //end if
+	return qfalse;
+} //end of the function BotItemGoalInVisButNotVisible
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void BotResetGoalState(int goalstate)
+{
+	bot_goalstate_t *gs;
+
+	gs = BotGoalStateFromHandle(goalstate);
+	if (!gs) return;
+	Com_Memset(gs->goalstack, 0, MAX_GOALSTACK * sizeof(bot_goal_t));
+	gs->goalstacktop = 0;
+	BotResetAvoidGoals(goalstate);
+} //end of the function BotResetGoalState
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int BotLoadItemWeights(int goalstate, char *filename)
+{
+	bot_goalstate_t *gs;
+
+	gs = BotGoalStateFromHandle(goalstate);
+	if (!gs) return BLERR_CANNOTLOADITEMWEIGHTS;
+	//load the weight configuration
+	gs->itemweightconfig = ReadWeightConfig(filename);
+	if (!gs->itemweightconfig)
+	{
+		botimport.Print(PRT_FATAL, "couldn't load weights\n");
+		return BLERR_CANNOTLOADITEMWEIGHTS;
+	} //end if
+	//if there's no item configuration
+	if (!itemconfig) return BLERR_CANNOTLOADITEMWEIGHTS;
+	//create the item weight index
+	gs->itemweightindex = ItemWeightIndex(gs->itemweightconfig, itemconfig);
+	//everything went ok
+	return BLERR_NOERROR;
+} //end of the function BotLoadItemWeights
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void BotFreeItemWeights(int goalstate)
+{
+	bot_goalstate_t *gs;
+
+	gs = BotGoalStateFromHandle(goalstate);
+	if (!gs) return;
+	if (gs->itemweightconfig) FreeWeightConfig(gs->itemweightconfig);
+	if (gs->itemweightindex) FreeMemory(gs->itemweightindex);
+} //end of the function BotFreeItemWeights
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int BotAllocGoalState(int client)
+{
+	int i;
+
+	for (i = 1; i <= MAX_CLIENTS; i++)
+	{
+		if (!botgoalstates[i])
+		{
+			botgoalstates[i] = (struct bot_goalstate_s *)GetClearedMemory(sizeof(bot_goalstate_t));
+			botgoalstates[i]->client = client;
+			return i;
+		} //end if
+	} //end for
+	return 0;
+} //end of the function BotAllocGoalState
+//========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//========================================================================
+void BotFreeGoalState(int handle)
+{
+	if (handle <= 0 || handle > MAX_CLIENTS)
+	{
+		botimport.Print(PRT_FATAL, "goal state handle %d out of range\n", handle);
+		return;
+	} //end if
+	if (!botgoalstates[handle])
+	{
+		botimport.Print(PRT_FATAL, "invalid goal state handle %d\n", handle);
+		return;
+	} //end if
+	BotFreeItemWeights(handle);
+	FreeMemory(botgoalstates[handle]);
+	botgoalstates[handle] = NULL;
+} //end of the function BotFreeGoalState
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int BotSetupGoalAI(void)
+{
+	char *filename;
+
+	//check if teamplay is on
+	g_gametype = LibVarValue("g_gametype", "0");
+	//item configuration file
+	filename = LibVarString("itemconfig", "items.c");
+	//load the item configuration
+	itemconfig = LoadItemConfig(filename);
+	if (!itemconfig)
+	{
+		botimport.Print(PRT_FATAL, "couldn't load item config\n");
+		return BLERR_CANNOTLOADITEMCONFIG;
+	} //end if
+	//
+	droppedweight = LibVar("droppedweight", "1000");
+	//everything went ok
+	return BLERR_NOERROR;
+} //end of the function BotSetupGoalAI
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+void BotShutdownGoalAI(void)
+{
+	int i;
+
+	if (itemconfig) FreeMemory(itemconfig);
+	itemconfig = NULL;
+	if (levelitemheap) FreeMemory(levelitemheap);
+	levelitemheap = NULL;
+	freelevelitems = NULL;
+	levelitems = NULL;
+	numlevelitems = 0;
+
+	BotFreeInfoEntities();
+
+	for (i = 1; i <= MAX_CLIENTS; i++)
+	{
+		if (botgoalstates[i])
+		{
+			BotFreeGoalState(i);
+		} //end if
+	} //end for
+} //end of the function BotShutdownGoalAI
diff --git a/codemp/botlib/be_ai_move.cpp b/codemp/botlib/be_ai_move.cpp
new file mode 100644
index 0000000..114cdef
--- /dev/null
+++ b/codemp/botlib/be_ai_move.cpp
@@ -0,0 +1,3593 @@
+
+/*****************************************************************************
+ * name:		be_ai_move.c
+ *
+ * desc:		bot movement AI
+ *
+ * $Archive: /MissionPack/code/botlib/be_ai_move.c $
+ * $Author: Ttimo $ 
+ * $Revision: 14 $
+ * $Modtime: 4/22/01 8:52a $
+ * $Date: 4/22/01 8:52a $
+ *
+ *****************************************************************************/
+
+#include "../game/q_shared.h"
+#include "l_memory.h"
+#include "l_libvar.h"
+#include "l_utils.h"
+#include "l_script.h"
+#include "l_precomp.h"
+#include "l_struct.h"
+#include "aasfile.h"
+#include "../game/botlib.h"
+#include "../game/be_aas.h"
+#include "be_aas_funcs.h"
+#include "be_interface.h"
+
+#include "../game/be_ea.h"
+#include "../game/be_ai_goal.h"
+#include "../game/be_ai_move.h"
+
+
+//#define DEBUG_AI_MOVE
+//#define DEBUG_ELEVATOR
+//#define DEBUG_GRAPPLE
+
+// bk001204 - redundant bot_avoidspot_t, see ../game/be_ai_move.h
+
+//movement state
+//NOTE: the moveflags MFL_ONGROUND, MFL_TELEPORTED, MFL_WATERJUMP and
+//		MFL_GRAPPLEPULL must be set outside the movement code
+typedef struct bot_movestate_s
+{
+	//input vars (all set outside the movement code)
+	vec3_t origin;								//origin of the bot
+	vec3_t velocity;							//velocity of the bot
+	vec3_t viewoffset;							//view offset
+	int entitynum;								//entity number of the bot
+	int client;									//client number of the bot
+	float thinktime;							//time the bot thinks
+	int presencetype;							//presencetype of the bot
+	vec3_t viewangles;							//view angles of the bot
+	//state vars
+	int areanum;								//area the bot is in
+	int lastareanum;							//last area the bot was in
+	int lastgoalareanum;						//last goal area number
+	int lastreachnum;							//last reachability number
+	vec3_t lastorigin;							//origin previous cycle
+	int reachareanum;							//area number of the reachabilty
+	int moveflags;								//movement flags
+	int jumpreach;								//set when jumped
+	float grapplevisible_time;					//last time the grapple was visible
+	float lastgrappledist;						//last distance to the grapple end
+	float reachability_time;					//time to use current reachability
+	int avoidreach[MAX_AVOIDREACH];				//reachabilities to avoid
+	float avoidreachtimes[MAX_AVOIDREACH];		//times to avoid the reachabilities
+	int avoidreachtries[MAX_AVOIDREACH];		//number of tries before avoiding
+	//
+	bot_avoidspot_t avoidspots[MAX_AVOIDSPOTS];	//spots to avoid
+	int numavoidspots;
+} bot_movestate_t;
+
+//used to avoid reachability links for some time after being used
+#define AVOIDREACH
+#define AVOIDREACH_TIME			6		//avoid links for 6 seconds after use
+#define AVOIDREACH_TRIES		4
+//prediction times
+#define PREDICTIONTIME_JUMP	3		//in seconds
+#define PREDICTIONTIME_MOVE	2		//in seconds
+//weapon indexes for weapon jumping
+#define WEAPONINDEX_ROCKET_LAUNCHER		5
+#define WEAPONINDEX_BFG					9
+
+#define MODELTYPE_FUNC_PLAT		1
+#define MODELTYPE_FUNC_BOB		2
+#define MODELTYPE_FUNC_DOOR		3
+#define MODELTYPE_FUNC_STATIC	4
+
+libvar_t *sv_maxstep;
+libvar_t *sv_maxbarrier;
+libvar_t *sv_gravity;
+libvar_t *weapindex_rocketlauncher;
+libvar_t *weapindex_bfg10k;
+libvar_t *weapindex_grapple;
+libvar_t *entitytypemissile;
+libvar_t *offhandgrapple;
+libvar_t *cmd_grappleoff;
+libvar_t *cmd_grappleon;
+//type of model, func_plat or func_bobbing
+int modeltypes[MAX_MODELS];
+
+bot_movestate_t *botmovestates[MAX_CLIENTS+1];
+
+//========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//========================================================================
+int BotAllocMoveState(void)
+{
+	int i;
+
+	for (i = 1; i <= MAX_CLIENTS; i++)
+	{
+		if (!botmovestates[i])
+		{
+			botmovestates[i] = (struct bot_movestate_s *)GetClearedMemory(sizeof(bot_movestate_t));
+			return i;
+		} //end if
+	} //end for
+	return 0;
+} //end of the function BotAllocMoveState
+//========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//========================================================================
+void BotFreeMoveState(int handle)
+{
+	if (handle <= 0 || handle > MAX_CLIENTS)
+	{
+		botimport.Print(PRT_FATAL, "move state handle %d out of range\n", handle);
+		return;
+	} //end if
+	if (!botmovestates[handle])
+	{
+		botimport.Print(PRT_FATAL, "invalid move state %d\n", handle);
+		return;
+	} //end if
+	FreeMemory(botmovestates[handle]);
+	botmovestates[handle] = NULL;
+} //end of the function BotFreeMoveState
+//========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//========================================================================
+bot_movestate_t *BotMoveStateFromHandle(int handle)
+{
+	if (handle <= 0 || handle > MAX_CLIENTS)
+	{
+		botimport.Print(PRT_FATAL, "move state handle %d out of range\n", handle);
+		return NULL;
+	} //end if
+	if (!botmovestates[handle])
+	{
+		botimport.Print(PRT_FATAL, "invalid move state %d\n", handle);
+		return NULL;
+	} //end if
+	return botmovestates[handle];
+} //end of the function BotMoveStateFromHandle
+//========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//========================================================================
+void BotInitMoveState(int handle, bot_initmove_t *initmove)
+{
+	bot_movestate_t *ms;
+
+	ms = BotMoveStateFromHandle(handle);
+	if (!ms) return;
+	VectorCopy(initmove->origin, ms->origin);
+	VectorCopy(initmove->velocity, ms->velocity);
+	VectorCopy(initmove->viewoffset, ms->viewoffset);
+	ms->entitynum = initmove->entitynum;
+	ms->client = initmove->client;
+	ms->thinktime = initmove->thinktime;
+	ms->presencetype = initmove->presencetype;
+	VectorCopy(initmove->viewangles, ms->viewangles);
+	//
+	ms->moveflags &= ~MFL_ONGROUND;
+	if (initmove->or_moveflags & MFL_ONGROUND) ms->moveflags |= MFL_ONGROUND;
+	ms->moveflags &= ~MFL_TELEPORTED;	
+	if (initmove->or_moveflags & MFL_TELEPORTED) ms->moveflags |= MFL_TELEPORTED;
+	ms->moveflags &= ~MFL_WATERJUMP;
+	if (initmove->or_moveflags & MFL_WATERJUMP) ms->moveflags |= MFL_WATERJUMP;
+	ms->moveflags &= ~MFL_WALK;
+	if (initmove->or_moveflags & MFL_WALK) ms->moveflags |= MFL_WALK;
+	ms->moveflags &= ~MFL_GRAPPLEPULL;
+	if (initmove->or_moveflags & MFL_GRAPPLEPULL) ms->moveflags |= MFL_GRAPPLEPULL;
+} //end of the function BotInitMoveState
+//========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//========================================================================
+float AngleDiff(float ang1, float ang2)
+{
+	float diff;
+
+	diff = ang1 - ang2;
+	if (ang1 > ang2)
+	{
+		if (diff > 180.0) diff -= 360.0;
+	} //end if
+	else
+	{
+		if (diff < -180.0) diff += 360.0;
+	} //end else
+	return diff;
+} //end of the function AngleDiff
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+int BotFuzzyPointReachabilityArea(vec3_t origin)
+{
+	int firstareanum, j, x, y, z;
+	int areas[10], numareas, areanum, bestareanum;
+	float dist, bestdist;
+	vec3_t points[10], v, end;
+
+	firstareanum = 0;
+	areanum = AAS_PointAreaNum(origin);
+	if (areanum)
+	{
+		firstareanum = areanum;
+		if (AAS_AreaReachability(areanum)) return areanum;
+	} //end if
+	VectorCopy(origin, end);
+	end[2] += 4;
+	numareas = AAS_TraceAreas(origin, end, areas, points, 10);
+	for (j = 0; j < numareas; j++)
+	{
+		if (AAS_AreaReachability(areas[j])) return areas[j];
+	} //end for
+	bestdist = 999999;
+	bestareanum = 0;
+	for (z = 1; z >= -1; z -= 1)
+	{
+		for (x = 1; x >= -1; x -= 1)
+		{
+			for (y = 1; y >= -1; y -= 1)
+			{
+				VectorCopy(origin, end);
+				end[0] += x * 8;
+				end[1] += y * 8;
+				end[2] += z * 12;
+				numareas = AAS_TraceAreas(origin, end, areas, points, 10);
+				for (j = 0; j < numareas; j++)
+				{
+					if (AAS_AreaReachability(areas[j]))
+					{
+						VectorSubtract(points[j], origin, v);
+						dist = VectorLength(v);
+						if (dist < bestdist)
+						{
+							bestareanum = areas[j];
+							bestdist = dist;
+						} //end if
+					} //end if
+					if (!firstareanum) firstareanum = areas[j];
+				} //end for
+			} //end for
+		} //end for
+		if (bestareanum) return bestareanum;
+	} //end for
+	return firstareanum;
+} //end of the function BotFuzzyPointReachabilityArea
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+int BotReachabilityArea(vec3_t origin, int client)
+{
+	int modelnum, modeltype, reachnum, areanum;
+	aas_reachability_t reach;
+	vec3_t org, end, mins, maxs, up = {0, 0, 1};
+	bsp_trace_t bsptrace;
+	aas_trace_t trace;
+
+	//check if the bot is standing on something
+	AAS_PresenceTypeBoundingBox(PRESENCE_CROUCH, mins, maxs);
+	VectorMA(origin, -3, up, end);
+	bsptrace = AAS_Trace(origin, mins, maxs, end, client, CONTENTS_SOLID|CONTENTS_PLAYERCLIP);
+	if (!bsptrace.startsolid && bsptrace.fraction < 1 && bsptrace.ent != ENTITYNUM_NONE)
+	{
+		//if standing on the world the bot should be in a valid area
+		if (bsptrace.ent == ENTITYNUM_WORLD)
+		{
+			return BotFuzzyPointReachabilityArea(origin);
+		} //end if
+
+		modelnum = AAS_EntityModelindex(bsptrace.ent);
+		modeltype = modeltypes[modelnum];
+
+		//if standing on a func_plat or func_bobbing then the bot is assumed to be
+		//in the area the reachability points to
+		if (modeltype == MODELTYPE_FUNC_PLAT || modeltype == MODELTYPE_FUNC_BOB)
+		{
+			reachnum = AAS_NextModelReachability(0, modelnum);
+			if (reachnum)
+			{
+				AAS_ReachabilityFromNum(reachnum, &reach);
+				return reach.areanum;
+			} //end if
+		} //end else if
+
+		//if the bot is swimming the bot should be in a valid area
+		if (AAS_Swimming(origin))
+		{
+			return BotFuzzyPointReachabilityArea(origin);
+		} //end if
+		//
+		areanum = BotFuzzyPointReachabilityArea(origin);
+		//if the bot is in an area with reachabilities
+		if (areanum && AAS_AreaReachability(areanum)) return areanum;
+		//trace down till the ground is hit because the bot is standing on some other entity
+		VectorCopy(origin, org);
+		VectorCopy(org, end);
+		end[2] -= 800;
+		trace = AAS_TraceClientBBox(org, end, PRESENCE_CROUCH, -1);
+		if (!trace.startsolid)
+		{
+			VectorCopy(trace.endpos, org);
+		} //end if
+		//
+		return BotFuzzyPointReachabilityArea(org);
+	} //end if
+	//
+	return BotFuzzyPointReachabilityArea(origin);
+} //end of the function BotReachabilityArea
+//===========================================================================
+// returns the reachability area the bot is in
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+/*
+int BotReachabilityArea(vec3_t origin, int testground)
+{
+	int firstareanum, i, j, x, y, z;
+	int areas[10], numareas, areanum, bestareanum;
+	float dist, bestdist;
+	vec3_t org, end, points[10], v;
+	aas_trace_t trace;
+
+	firstareanum = 0;
+	for (i = 0; i < 2; i++)
+	{
+		VectorCopy(origin, org);
+		//if test at the ground (used when bot is standing on an entity)
+		if (i > 0)
+		{
+			VectorCopy(origin, end);
+			end[2] -= 800;
+			trace = AAS_TraceClientBBox(origin, end, PRESENCE_CROUCH, -1);
+			if (!trace.startsolid)
+			{
+				VectorCopy(trace.endpos, org);
+			} //end if
+		} //end if
+
+		firstareanum = 0;
+		areanum = AAS_PointAreaNum(org);
+		if (areanum)
+		{
+			firstareanum = areanum;
+			if (AAS_AreaReachability(areanum)) return areanum;
+		} //end if
+		bestdist = 999999;
+		bestareanum = 0;
+		for (z = 1; z >= -1; z -= 1)
+		{
+			for (x = 1; x >= -1; x -= 1)
+			{
+				for (y = 1; y >= -1; y -= 1)
+				{
+					VectorCopy(org, end);
+					end[0] += x * 8;
+					end[1] += y * 8;
+					end[2] += z * 12;
+					numareas = AAS_TraceAreas(org, end, areas, points, 10);
+					for (j = 0; j < numareas; j++)
+					{
+						if (AAS_AreaReachability(areas[j]))
+						{
+							VectorSubtract(points[j], org, v);
+							dist = VectorLength(v);
+							if (dist < bestdist)
+							{
+								bestareanum = areas[j];
+								bestdist = dist;
+							} //end if
+						} //end if
+					} //end for
+				} //end for
+			} //end for
+			if (bestareanum) return bestareanum;
+		} //end for
+		if (!testground) break;
+	} //end for
+//#ifdef DEBUG
+	//botimport.Print(PRT_MESSAGE, "no reachability area\n");
+//#endif //DEBUG
+	return firstareanum;
+} //end of the function BotReachabilityArea*/
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+int BotOnMover(vec3_t origin, int entnum, aas_reachability_t *reach)
+{
+	int i, modelnum;
+	vec3_t mins, maxs, modelorigin, org, end;
+	vec3_t angles = {0, 0, 0};
+	vec3_t boxmins = {-16, -16, -8}, boxmaxs = {16, 16, 8};
+	bsp_trace_t trace;
+
+	modelnum = reach->facenum & 0x0000FFFF;
+	//get some bsp model info
+	AAS_BSPModelMinsMaxsOrigin(modelnum, angles, mins, maxs, NULL);
+	//
+	if (!AAS_OriginOfMoverWithModelNum(modelnum, modelorigin))
+	{
+		botimport.Print(PRT_MESSAGE, "no entity with model %d\n", modelnum);
+		return qfalse;
+	} //end if
+	//
+	for (i = 0; i < 2; i++)
+	{
+		if (origin[i] > modelorigin[i] + maxs[i] + 16) return qfalse;
+		if (origin[i] < modelorigin[i] + mins[i] - 16) return qfalse;
+	} //end for
+	//
+	VectorCopy(origin, org);
+	org[2] += 24;
+	VectorCopy(origin, end);
+	end[2] -= 48;
+	//
+	trace = AAS_Trace(org, boxmins, boxmaxs, end, entnum, CONTENTS_SOLID|CONTENTS_PLAYERCLIP);
+	if (!trace.startsolid && !trace.allsolid)
+	{
+		//NOTE: the reachability face number is the model number of the elevator
+		if (trace.ent != ENTITYNUM_NONE && AAS_EntityModelNum(trace.ent) == modelnum)
+		{
+			return qtrue;
+		} //end if
+	} //end if
+	return qfalse;
+} //end of the function BotOnMover
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+int MoverDown(aas_reachability_t *reach)
+{
+	int modelnum;
+	vec3_t mins, maxs, origin;
+	vec3_t angles = {0, 0, 0};
+
+	modelnum = reach->facenum & 0x0000FFFF;
+	//get some bsp model info
+	AAS_BSPModelMinsMaxsOrigin(modelnum, angles, mins, maxs, origin);
+	//
+	if (!AAS_OriginOfMoverWithModelNum(modelnum, origin))
+	{
+		botimport.Print(PRT_MESSAGE, "no entity with model %d\n", modelnum);
+		return qfalse;
+	} //end if
+	//if the top of the plat is below the reachability start point
+	if (origin[2] + maxs[2] < reach->start[2]) return qtrue;
+	return qfalse;
+} //end of the function MoverDown
+//========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//========================================================================
+void BotSetBrushModelTypes(void)
+{
+	int ent, modelnum;
+	char classname[MAX_EPAIRKEY], model[MAX_EPAIRKEY];
+
+	Com_Memset(modeltypes, 0, MAX_MODELS * sizeof(int));
+	//
+	for (ent = AAS_NextBSPEntity(0); ent; ent = AAS_NextBSPEntity(ent))
+	{
+		if (!AAS_ValueForBSPEpairKey(ent, "classname", classname, MAX_EPAIRKEY)) continue;
+		if (!AAS_ValueForBSPEpairKey(ent, "model", model, MAX_EPAIRKEY)) continue;
+		if (model[0]) modelnum = atoi(model+1);
+		else modelnum = 0;
+
+		if (modelnum < 0 || modelnum > MAX_MODELS)
+		{
+			botimport.Print(PRT_MESSAGE, "entity %s model number out of range\n", classname);
+			continue;
+		} //end if
+
+		if (!Q_stricmp(classname, "func_bobbing"))
+			modeltypes[modelnum] = MODELTYPE_FUNC_BOB;
+		else if (!Q_stricmp(classname, "func_plat"))
+			modeltypes[modelnum] = MODELTYPE_FUNC_PLAT;
+		else if (!Q_stricmp(classname, "func_door"))
+			modeltypes[modelnum] = MODELTYPE_FUNC_DOOR;
+		else if (!Q_stricmp(classname, "func_static"))
+			modeltypes[modelnum] = MODELTYPE_FUNC_STATIC;
+	} //end for
+} //end of the function BotSetBrushModelTypes
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+int BotOnTopOfEntity(bot_movestate_t *ms)
+{
+	vec3_t mins, maxs, end, up = {0, 0, 1};
+	bsp_trace_t trace;
+
+	AAS_PresenceTypeBoundingBox(ms->presencetype, mins, maxs);
+	VectorMA(ms->origin, -3, up, end);
+	trace = AAS_Trace(ms->origin, mins, maxs, end, ms->entitynum, CONTENTS_SOLID|CONTENTS_PLAYERCLIP);
+	if (!trace.startsolid && (trace.ent != ENTITYNUM_WORLD && trace.ent != ENTITYNUM_NONE) )
+	{
+		return trace.ent;
+	} //end if
+	return -1;
+} //end of the function BotOnTopOfEntity
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+int BotValidTravel(vec3_t origin, aas_reachability_t *reach, int travelflags)
+{
+	//if the reachability uses an unwanted travel type
+	if (AAS_TravelFlagForType(reach->traveltype) & ~travelflags) return qfalse;
+	//don't go into areas with bad travel types
+	if (AAS_AreaContentsTravelFlags(reach->areanum) & ~travelflags) return qfalse;
+	return qtrue;
+} //end of the function BotValidTravel
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void BotAddToAvoidReach(bot_movestate_t *ms, int number, float avoidtime)
+{
+	int i;
+
+	for (i = 0; i < MAX_AVOIDREACH; i++)
+	{
+		if (ms->avoidreach[i] == number)
+		{
+			if (ms->avoidreachtimes[i] > AAS_Time()) ms->avoidreachtries[i]++;
+			else ms->avoidreachtries[i] = 1;
+			ms->avoidreachtimes[i] = AAS_Time() + avoidtime;
+			return;
+		} //end if
+	} //end for
+	//add the reachability to the reachabilities to avoid for a while
+	for (i = 0; i < MAX_AVOIDREACH; i++)
+	{
+		if (ms->avoidreachtimes[i] < AAS_Time())
+		{
+			ms->avoidreach[i] = number;
+			ms->avoidreachtimes[i] = AAS_Time() + avoidtime;
+			ms->avoidreachtries[i] = 1;
+			return;
+		} //end if
+	} //end for
+} //end of the function BotAddToAvoidReach
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+float DistanceFromLineSquared(vec3_t p, vec3_t lp1, vec3_t lp2)
+{
+	vec3_t proj, dir;
+	int j;
+
+	AAS_ProjectPointOntoVector(p, lp1, lp2, proj);
+	for (j = 0; j < 3; j++)
+		if ((proj[j] > lp1[j] && proj[j] > lp2[j]) ||
+			(proj[j] < lp1[j] && proj[j] < lp2[j]))
+			break;
+	if (j < 3) {
+		if (fabs(proj[j] - lp1[j]) < fabs(proj[j] - lp2[j]))
+			VectorSubtract(p, lp1, dir);
+		else
+			VectorSubtract(p, lp2, dir);
+		return VectorLengthSquared(dir);
+	}
+	VectorSubtract(p, proj, dir);
+	return VectorLengthSquared(dir);
+} //end of the function DistanceFromLineSquared
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+float VectorDistanceSquared(vec3_t p1, vec3_t p2)
+{
+	vec3_t dir;
+	VectorSubtract(p2, p1, dir);
+	return VectorLengthSquared(dir);
+} //end of the function VectorDistanceSquared
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+int BotAvoidSpots(vec3_t origin, aas_reachability_t *reach, bot_avoidspot_t *avoidspots, int numavoidspots)
+{
+	int checkbetween, i, type;
+	float squareddist, squaredradius;
+
+	switch(reach->traveltype & TRAVELTYPE_MASK)
+	{
+		case TRAVEL_WALK: checkbetween = qtrue; break;
+		case TRAVEL_CROUCH: checkbetween = qtrue; break;
+		case TRAVEL_BARRIERJUMP: checkbetween = qtrue; break;
+		case TRAVEL_LADDER: checkbetween = qtrue; break;
+		case TRAVEL_WALKOFFLEDGE: checkbetween = qfalse; break;
+		case TRAVEL_JUMP: checkbetween = qfalse; break;
+		case TRAVEL_SWIM: checkbetween = qtrue; break;
+		case TRAVEL_WATERJUMP: checkbetween = qtrue; break;
+		case TRAVEL_TELEPORT: checkbetween = qfalse; break;
+		case TRAVEL_ELEVATOR: checkbetween = qfalse; break;
+		case TRAVEL_GRAPPLEHOOK: checkbetween = qfalse; break;
+		case TRAVEL_ROCKETJUMP: checkbetween = qfalse; break;
+		case TRAVEL_BFGJUMP: checkbetween = qfalse; break;
+		case TRAVEL_JUMPPAD: checkbetween = qfalse; break;
+		case TRAVEL_FUNCBOB: checkbetween = qfalse; break;
+		default: checkbetween = qtrue; break;
+	} //end switch
+
+	type = AVOID_CLEAR;
+	for (i = 0; i < numavoidspots; i++)
+	{
+		squaredradius = Square(avoidspots[i].radius);
+		squareddist = DistanceFromLineSquared(avoidspots[i].origin, origin, reach->start);
+		// if moving towards the avoid spot
+		if (squareddist < squaredradius &&
+			VectorDistanceSquared(avoidspots[i].origin, origin) > squareddist)
+		{
+			type = avoidspots[i].type;
+		} //end if
+		else if (checkbetween) {
+			squareddist = DistanceFromLineSquared(avoidspots[i].origin, reach->start, reach->end);
+			// if moving towards the avoid spot
+			if (squareddist < squaredradius &&
+				VectorDistanceSquared(avoidspots[i].origin, reach->start) > squareddist)
+			{
+				type = avoidspots[i].type;
+			} //end if
+		} //end if
+		else
+		{
+			VectorDistanceSquared(avoidspots[i].origin, reach->end);
+			// if the reachability leads closer to the avoid spot
+			if (squareddist < squaredradius && 
+				VectorDistanceSquared(avoidspots[i].origin, reach->start) > squareddist)
+			{
+				type = avoidspots[i].type;
+			} //end if
+		} //end else
+		if (type == AVOID_ALWAYS)
+			return type;
+	} //end for
+	return type;
+} //end of the function BotAvoidSpots
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+void BotAddAvoidSpot(int movestate, vec3_t origin, float radius, int type)
+{
+	bot_movestate_t *ms;
+
+	ms = BotMoveStateFromHandle(movestate);
+	if (!ms) return;
+	if (type == AVOID_CLEAR)
+	{
+		ms->numavoidspots = 0;
+		return;
+	} //end if
+
+	if (ms->numavoidspots >= MAX_AVOIDSPOTS)
+		return;
+	VectorCopy(origin, ms->avoidspots[ms->numavoidspots].origin);
+	ms->avoidspots[ms->numavoidspots].radius = radius;
+	ms->avoidspots[ms->numavoidspots].type = type;
+	ms->numavoidspots++;
+} //end of the function BotAddAvoidSpot
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+int BotGetReachabilityToGoal(vec3_t origin, int areanum,
+									  int lastgoalareanum, int lastareanum,
+									  int *avoidreach, float *avoidreachtimes, int *avoidreachtries,
+									  bot_goal_t *goal, int travelflags, int movetravelflags,
+									  struct bot_avoidspot_s *avoidspots, int numavoidspots, int *flags)
+{
+	int i, t, besttime, bestreachnum, reachnum;
+	aas_reachability_t reach;
+
+	//if not in a valid area
+	if (!areanum) return 0;
+	//
+	if (AAS_AreaDoNotEnter(areanum) || AAS_AreaDoNotEnter(goal->areanum))
+	{
+		travelflags |= TFL_DONOTENTER;
+		movetravelflags |= TFL_DONOTENTER;
+	} //end if
+	//use the routing to find the next area to go to
+	besttime = 0;
+	bestreachnum = 0;
+	//
+	for (reachnum = AAS_NextAreaReachability(areanum, 0); reachnum;
+		reachnum = AAS_NextAreaReachability(areanum, reachnum))
+	{
+#ifdef AVOIDREACH
+		//check if it isn't an reachability to avoid
+		for (i = 0; i < MAX_AVOIDREACH; i++)
+		{
+			if (avoidreach[i] == reachnum && avoidreachtimes[i] >= AAS_Time()) break;
+		} //end for
+		if (i != MAX_AVOIDREACH && avoidreachtries[i] > AVOIDREACH_TRIES)
+		{
+#ifdef DEBUG
+			if (bot_developer)
+			{
+				botimport.Print(PRT_MESSAGE, "avoiding reachability %d\n", avoidreach[i]);
+			} //end if
+#endif //DEBUG
+			continue;
+		} //end if
+#endif //AVOIDREACH
+		//get the reachability from the number
+		AAS_ReachabilityFromNum(reachnum, &reach);
+		//NOTE: do not go back to the previous area if the goal didn't change
+		//NOTE: is this actually avoidance of local routing minima between two areas???
+		if (lastgoalareanum == goal->areanum && reach.areanum == lastareanum) continue;
+		//if (AAS_AreaContentsTravelFlags(reach.areanum) & ~travelflags) continue;
+		//if the travel isn't valid
+		if (!BotValidTravel(origin, &reach, movetravelflags)) continue;
+		//get the travel time
+		t = AAS_AreaTravelTimeToGoalArea(reach.areanum, reach.end, goal->areanum, travelflags);
+		//if the goal area isn't reachable from the reachable area
+		if (!t) continue;
+		//if the bot should not use this reachability to avoid bad spots
+		if (BotAvoidSpots(origin, &reach, avoidspots, numavoidspots)) {
+			if (flags) {
+				*flags |= MOVERESULT_BLOCKEDBYAVOIDSPOT;
+			}
+			continue;
+		}
+		//add the travel time towards the area
+		t += reach.traveltime;// + AAS_AreaTravelTime(areanum, origin, reach.start);
+		//if the travel time is better than the ones already found
+		if (!besttime || t < besttime)
+		{
+			besttime = t;
+			bestreachnum = reachnum;
+		} //end if
+	} //end for
+	//
+	return bestreachnum;
+} //end of the function BotGetReachabilityToGoal
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int BotAddToTarget(vec3_t start, vec3_t end, float maxdist, float *dist, vec3_t target)
+{
+	vec3_t dir;
+	float curdist;
+
+	VectorSubtract(end, start, dir);
+	curdist = VectorNormalize(dir);
+	if (*dist + curdist < maxdist)
+	{
+		VectorCopy(end, target);
+		*dist += curdist;
+		return qfalse;
+	} //end if
+	else
+	{
+		VectorMA(start, maxdist - *dist, dir, target);
+		*dist = maxdist;
+		return qtrue;
+	} //end else
+} //end of the function BotAddToTarget
+
+int BotMovementViewTarget(int movestate, bot_goal_t *goal, int travelflags, float lookahead, vec3_t target)
+{
+	aas_reachability_t reach;
+	int reachnum, lastareanum;
+	bot_movestate_t *ms;
+	vec3_t end;
+	float dist;
+
+	ms = BotMoveStateFromHandle(movestate);
+	if (!ms) return qfalse;
+	reachnum = 0;
+	//if the bot has no goal or no last reachability
+	if (!ms->lastreachnum || !goal) return qfalse;
+
+	reachnum = ms->lastreachnum;
+	VectorCopy(ms->origin, end);
+	lastareanum = ms->lastareanum;
+	dist = 0;
+	while(reachnum && dist < lookahead)
+	{
+		AAS_ReachabilityFromNum(reachnum, &reach);
+		if (BotAddToTarget(end, reach.start, lookahead, &dist, target)) return qtrue;
+		//never look beyond teleporters
+		if ((reach.traveltype & TRAVELTYPE_MASK) == TRAVEL_TELEPORT) return qtrue;
+		//never look beyond the weapon jump point
+		if ((reach.traveltype & TRAVELTYPE_MASK) == TRAVEL_ROCKETJUMP) return qtrue;
+		if ((reach.traveltype & TRAVELTYPE_MASK) == TRAVEL_BFGJUMP) return qtrue;
+		//don't add jump pad distances
+		if ((reach.traveltype & TRAVELTYPE_MASK) != TRAVEL_JUMPPAD &&
+			(reach.traveltype & TRAVELTYPE_MASK) != TRAVEL_ELEVATOR &&
+			(reach.traveltype & TRAVELTYPE_MASK) != TRAVEL_FUNCBOB)
+		{
+			if (BotAddToTarget(reach.start, reach.end, lookahead, &dist, target)) return qtrue;
+		} //end if
+		reachnum = BotGetReachabilityToGoal(reach.end, reach.areanum,
+						ms->lastgoalareanum, lastareanum,
+							ms->avoidreach, ms->avoidreachtimes, ms->avoidreachtries,
+									goal, travelflags, travelflags, NULL, 0, NULL);
+		VectorCopy(reach.end, end);
+		lastareanum = reach.areanum;
+		if (lastareanum == goal->areanum)
+		{
+			BotAddToTarget(reach.end, goal->origin, lookahead, &dist, target);
+			return qtrue;
+		} //end if
+	} //end while
+	//
+	return qfalse;
+} //end of the function BotMovementViewTarget
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+int BotVisible(int ent, vec3_t eye, vec3_t target)
+{
+	bsp_trace_t trace;
+
+	trace = AAS_Trace(eye, NULL, NULL, target, ent, CONTENTS_SOLID|CONTENTS_PLAYERCLIP);
+	if (trace.fraction >= 1) return qtrue;
+	return qfalse;
+} //end of the function BotVisible
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+int BotPredictVisiblePosition(vec3_t origin, int areanum, bot_goal_t *goal, int travelflags, vec3_t target)
+{
+	aas_reachability_t reach;
+	int reachnum, lastgoalareanum, lastareanum, i;
+	int avoidreach[MAX_AVOIDREACH];
+	float avoidreachtimes[MAX_AVOIDREACH];
+	int avoidreachtries[MAX_AVOIDREACH];
+	vec3_t end;
+
+	//if the bot has no goal or no last reachability
+	if (!goal) return qfalse;
+	//if the areanum is not valid
+	if (!areanum) return qfalse;
+	//if the goal areanum is not valid
+	if (!goal->areanum) return qfalse;
+
+	Com_Memset(avoidreach, 0, MAX_AVOIDREACH * sizeof(int));
+	lastgoalareanum = goal->areanum;
+	lastareanum = areanum;
+	VectorCopy(origin, end);
+	//only do 20 hops
+	for (i = 0; i < 20 && (areanum != goal->areanum); i++)
+	{
+		//
+		reachnum = BotGetReachabilityToGoal(end, areanum,
+						lastgoalareanum, lastareanum,
+							avoidreach, avoidreachtimes, avoidreachtries,
+									goal, travelflags, travelflags, NULL, 0, NULL);
+		if (!reachnum) return qfalse;
+		AAS_ReachabilityFromNum(reachnum, &reach);
+		//
+		if (BotVisible(goal->entitynum, goal->origin, reach.start))
+		{
+			VectorCopy(reach.start, target);
+			return qtrue;
+		} //end if
+		//
+		if (BotVisible(goal->entitynum, goal->origin, reach.end))
+		{
+			VectorCopy(reach.end, target);
+			return qtrue;
+		} //end if
+		//
+		if (reach.areanum == goal->areanum)
+		{
+			VectorCopy(reach.end, target);
+			return qtrue;
+		} //end if
+		//
+		lastareanum = areanum;
+		areanum = reach.areanum;
+		VectorCopy(reach.end, end);
+		//
+	} //end while
+	//
+	return qfalse;
+} //end of the function BotPredictVisiblePosition
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+void MoverBottomCenter(aas_reachability_t *reach, vec3_t bottomcenter)
+{
+	int modelnum;
+	vec3_t mins, maxs, origin, mids;
+	vec3_t angles = {0, 0, 0};
+
+	modelnum = reach->facenum & 0x0000FFFF;
+	//get some bsp model info
+	AAS_BSPModelMinsMaxsOrigin(modelnum, angles, mins, maxs, origin);
+	//
+	if (!AAS_OriginOfMoverWithModelNum(modelnum, origin))
+	{
+		botimport.Print(PRT_MESSAGE, "no entity with model %d\n", modelnum);
+	} //end if
+	//get a point just above the plat in the bottom position
+	VectorAdd(mins, maxs, mids);
+	VectorMA(origin, 0.5, mids, bottomcenter);
+	bottomcenter[2] = reach->start[2];
+} //end of the function MoverBottomCenter
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+float BotGapDistance(vec3_t origin, vec3_t hordir, int entnum)
+{
+	float dist, startz;
+	vec3_t start, end;
+	aas_trace_t trace;
+
+	//do gap checking
+	startz = origin[2];
+	//this enables walking down stairs more fluidly
+	{
+		VectorCopy(origin, start);
+		VectorCopy(origin, end);
+		end[2] -= 60;
+		trace = AAS_TraceClientBBox(start, end, PRESENCE_CROUCH, entnum);
+		if (trace.fraction >= 1) return 1;
+		startz = trace.endpos[2] + 1;
+	}
+	//
+	for (dist = 8; dist <= 100; dist += 8)
+	{
+		VectorMA(origin, dist, hordir, start);
+		start[2] = startz + 24;
+		VectorCopy(start, end);
+		end[2] -= 48 + sv_maxbarrier->value;
+		trace = AAS_TraceClientBBox(start, end, PRESENCE_CROUCH, entnum);
+		//if solid is found the bot can't walk any further and fall into a gap
+		if (!trace.startsolid)
+		{
+			//if it is a gap
+			if (trace.endpos[2] < startz - sv_maxstep->value - 8)
+			{
+				VectorCopy(trace.endpos, end);
+				end[2] -= 20;
+				if (AAS_PointContents(end) & CONTENTS_WATER) break;
+				//if a gap is found slow down
+				//botimport.Print(PRT_MESSAGE, "gap at %f\n", dist);
+				return dist;
+			} //end if
+			startz = trace.endpos[2];
+		} //end if
+	} //end for
+	return 0;
+} //end of the function BotGapDistance
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+int BotCheckBarrierJump(bot_movestate_t *ms, vec3_t dir, float speed)
+{
+	vec3_t start, hordir, end;
+	aas_trace_t trace;
+
+	VectorCopy(ms->origin, end);
+	end[2] += sv_maxbarrier->value;
+	//trace right up
+	trace = AAS_TraceClientBBox(ms->origin, end, PRESENCE_NORMAL, ms->entitynum);
+	//this shouldn't happen... but we check anyway
+	if (trace.startsolid) return qfalse;
+	//if very low ceiling it isn't possible to jump up to a barrier
+	if (trace.endpos[2] - ms->origin[2] < sv_maxstep->value) return qfalse;
+	//
+	hordir[0] = dir[0];
+	hordir[1] = dir[1];
+	hordir[2] = 0;
+	VectorNormalize(hordir);
+	VectorMA(ms->origin, ms->thinktime * speed * 0.5, hordir, end);
+	VectorCopy(trace.endpos, start);
+	end[2] = trace.endpos[2];
+	//trace from previous trace end pos horizontally in the move direction
+	trace = AAS_TraceClientBBox(start, end, PRESENCE_NORMAL, ms->entitynum);
+	//again this shouldn't happen
+	if (trace.startsolid) return qfalse;
+	//
+	VectorCopy(trace.endpos, start);
+	VectorCopy(trace.endpos, end);
+	end[2] = ms->origin[2];
+	//trace down from the previous trace end pos
+	trace = AAS_TraceClientBBox(start, end, PRESENCE_NORMAL, ms->entitynum);
+	//if solid
+	if (trace.startsolid) return qfalse;
+	//if no obstacle at all
+	if (trace.fraction >= 1.0) return qfalse;
+	//if less than the maximum step height
+	if (trace.endpos[2] - ms->origin[2] < sv_maxstep->value) return qfalse;
+	//
+	EA_Jump(ms->client);
+	EA_Move(ms->client, hordir, speed);
+	ms->moveflags |= MFL_BARRIERJUMP;
+	//there is a barrier
+	return qtrue;
+} //end of the function BotCheckBarrierJump
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+int BotSwimInDirection(bot_movestate_t *ms, vec3_t dir, float speed, int type)
+{
+	vec3_t normdir;
+
+	VectorCopy(dir, normdir);
+	VectorNormalize(normdir);
+	EA_Move(ms->client, normdir, speed);
+	return qtrue;
+} //end of the function BotSwimInDirection
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+int BotWalkInDirection(bot_movestate_t *ms, vec3_t dir, float speed, int type)
+{
+	vec3_t hordir, cmdmove, velocity, tmpdir, origin;
+	int presencetype, maxframes, cmdframes, stopevent;
+	aas_clientmove_t move;
+	float dist;
+
+	if (AAS_OnGround(ms->origin, ms->presencetype, ms->entitynum)) ms->moveflags |= MFL_ONGROUND;
+	//if the bot is on the ground
+	if (ms->moveflags & MFL_ONGROUND)
+	{
+		//if there is a barrier the bot can jump on
+		if (BotCheckBarrierJump(ms, dir, speed)) return qtrue;
+		//remove barrier jump flag
+		ms->moveflags &= ~MFL_BARRIERJUMP;
+		//get the presence type for the movement
+		if ((type & MOVE_CROUCH) && !(type & MOVE_JUMP)) presencetype = PRESENCE_CROUCH;
+		else presencetype = PRESENCE_NORMAL;
+		//horizontal direction
+		hordir[0] = dir[0];
+		hordir[1] = dir[1];
+		hordir[2] = 0;
+		VectorNormalize(hordir);
+		//if the bot is not supposed to jump
+		if (!(type & MOVE_JUMP))
+		{
+			//if there is a gap, try to jump over it
+			if (BotGapDistance(ms->origin, hordir, ms->entitynum) > 0) type |= MOVE_JUMP;
+		} //end if
+		//get command movement
+		VectorScale(hordir, speed, cmdmove);
+		VectorCopy(ms->velocity, velocity);
+		//
+		if (type & MOVE_JUMP)
+		{
+			//botimport.Print(PRT_MESSAGE, "trying jump\n");
+			cmdmove[2] = 400;
+			maxframes = PREDICTIONTIME_JUMP / 0.1;
+			cmdframes = 1;
+			stopevent = SE_HITGROUND|SE_HITGROUNDDAMAGE|
+						SE_ENTERWATER|SE_ENTERSLIME|SE_ENTERLAVA;
+		} //end if
+		else
+		{
+			maxframes = 2;
+			cmdframes = 2;
+			stopevent = SE_HITGROUNDDAMAGE|
+						SE_ENTERWATER|SE_ENTERSLIME|SE_ENTERLAVA;
+		} //end else
+		//AAS_ClearShownDebugLines();
+		//
+		VectorCopy(ms->origin, origin);
+		origin[2] += 0.5;
+		AAS_PredictClientMovement(&move, ms->entitynum, origin, presencetype, qtrue,
+									velocity, cmdmove, cmdframes, maxframes, 0.1f,
+									stopevent, 0, qfalse);//qtrue);
+		//if prediction time wasn't enough to fully predict the movement
+		if (move.frames >= maxframes && (type & MOVE_JUMP))
+		{
+			//botimport.Print(PRT_MESSAGE, "client %d: max prediction frames\n", ms->client);
+			return qfalse;
+		} //end if
+		//don't enter slime or lava and don't fall from too high
+		if (move.stopevent & (SE_ENTERSLIME|SE_ENTERLAVA|SE_HITGROUNDDAMAGE))
+		{
+			//botimport.Print(PRT_MESSAGE, "client %d: would be hurt ", ms->client);
+			//if (move.stopevent & SE_ENTERSLIME) botimport.Print(PRT_MESSAGE, "slime\n");
+			//if (move.stopevent & SE_ENTERLAVA) botimport.Print(PRT_MESSAGE, "lava\n");
+			//if (move.stopevent & SE_HITGROUNDDAMAGE) botimport.Print(PRT_MESSAGE, "hitground\n");
+			return qfalse;
+		} //end if
+		//if ground was hit
+		if (move.stopevent & SE_HITGROUND)
+		{
+			//check for nearby gap
+			VectorNormalize2(move.velocity, tmpdir);
+			dist = BotGapDistance(move.endpos, tmpdir, ms->entitynum);
+			if (dist > 0) return qfalse;
+			//
+			dist = BotGapDistance(move.endpos, hordir, ms->entitynum);
+			if (dist > 0) return qfalse;
+		} //end if
+		//get horizontal movement
+		tmpdir[0] = move.endpos[0] - ms->origin[0];
+		tmpdir[1] = move.endpos[1] - ms->origin[1];
+		tmpdir[2] = 0;
+		//
+		//AAS_DrawCross(move.endpos, 4, LINECOLOR_BLUE);
+		//the bot is blocked by something
+		if (VectorLength(tmpdir) < speed * ms->thinktime * 0.5) return qfalse;
+		//perform the movement
+		if (type & MOVE_JUMP) EA_Jump(ms->client);
+		if (type & MOVE_CROUCH) EA_Crouch(ms->client);
+		EA_Move(ms->client, hordir, speed);
+		//movement was succesfull
+		return qtrue;
+	} //end if
+	else
+	{
+		if (ms->moveflags & MFL_BARRIERJUMP)
+		{
+			//if near the top or going down
+			if (ms->velocity[2] < 50)
+			{
+				EA_Move(ms->client, dir, speed);
+			} //end if
+		} //end if
+		//FIXME: do air control to avoid hazards
+		return qtrue;
+	} //end else
+} //end of the function BotWalkInDirection
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+int BotMoveInDirection(int movestate, vec3_t dir, float speed, int type)
+{
+	bot_movestate_t *ms;
+
+	ms = BotMoveStateFromHandle(movestate);
+	if (!ms) return qfalse;
+	//if swimming
+	if (AAS_Swimming(ms->origin))
+	{
+		return BotSwimInDirection(ms, dir, speed, type);
+	} //end if
+	else
+	{
+		return BotWalkInDirection(ms, dir, speed, type);
+	} //end else
+} //end of the function BotMoveInDirection
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+int Intersection(vec2_t p1, vec2_t p2, vec2_t p3, vec2_t p4, vec2_t out)
+{
+   float x1, dx1, dy1, x2, dx2, dy2, d;
+
+   dx1 = p2[0] - p1[0];
+   dy1 = p2[1] - p1[1];
+   dx2 = p4[0] - p3[0];
+   dy2 = p4[1] - p3[1];
+
+   d = dy1 * dx2 - dx1 * dy2;
+   if (d != 0)
+   {
+      x1 = p1[1] * dx1 - p1[0] * dy1;
+      x2 = p3[1] * dx2 - p3[0] * dy2;
+      out[0] = (int) ((dx1 * x2 - dx2 * x1) / d);
+      out[1] = (int) ((dy1 * x2 - dy2 * x1) / d);
+		return qtrue;
+   } //end if
+   else
+   {
+      return qfalse;
+   } //end else
+} //end of the function Intersection
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+void BotCheckBlocked(bot_movestate_t *ms, vec3_t dir, int checkbottom, bot_moveresult_t *result)
+{
+	vec3_t mins, maxs, end, up = {0, 0, 1};
+	bsp_trace_t trace;
+
+	//test for entities obstructing the bot's path
+	AAS_PresenceTypeBoundingBox(ms->presencetype, mins, maxs);
+	//
+	if (fabs(DotProduct(dir, up)) < 0.7)
+	{
+		mins[2] += sv_maxstep->value; //if the bot can step on
+		maxs[2] -= 10; //a little lower to avoid low ceiling
+	} //end if
+	VectorMA(ms->origin, 3, dir, end);
+	trace = AAS_Trace(ms->origin, mins, maxs, end, ms->entitynum, CONTENTS_SOLID|CONTENTS_PLAYERCLIP|CONTENTS_BODY);
+	//if not started in solid and not hitting the world entity
+	if (!trace.startsolid && (trace.ent != ENTITYNUM_WORLD && trace.ent != ENTITYNUM_NONE) )
+	{
+		result->blocked = qtrue;
+		result->blockentity = trace.ent;
+#ifdef DEBUG
+		//botimport.Print(PRT_MESSAGE, "%d: BotCheckBlocked: I'm blocked\n", ms->client);
+#endif //DEBUG
+	} //end if
+	//if not in an area with reachability
+	else if (checkbottom && !AAS_AreaReachability(ms->areanum))
+	{
+		//check if the bot is standing on something
+		AAS_PresenceTypeBoundingBox(ms->presencetype, mins, maxs);
+		VectorMA(ms->origin, -3, up, end);
+		trace = AAS_Trace(ms->origin, mins, maxs, end, ms->entitynum, CONTENTS_SOLID|CONTENTS_PLAYERCLIP);
+		if (!trace.startsolid && (trace.ent != ENTITYNUM_WORLD && trace.ent != ENTITYNUM_NONE) )
+		{
+			result->blocked = qtrue;
+			result->blockentity = trace.ent;
+			result->flags |= MOVERESULT_ONTOPOFOBSTACLE;
+#ifdef DEBUG
+			//botimport.Print(PRT_MESSAGE, "%d: BotCheckBlocked: I'm blocked\n", ms->client);
+#endif //DEBUG
+		} //end if
+	} //end else
+} //end of the function BotCheckBlocked
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+void BotClearMoveResult(bot_moveresult_t *moveresult)
+{
+	moveresult->failure = qfalse;
+	moveresult->type = 0;
+	moveresult->blocked = qfalse;
+	moveresult->blockentity = 0;
+	moveresult->traveltype = 0;
+	moveresult->flags = 0;
+} //end of the function BotClearMoveResult
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+bot_moveresult_t BotTravel_Walk(bot_movestate_t *ms, aas_reachability_t *reach)
+{
+	float dist, speed;
+	vec3_t hordir;
+	bot_moveresult_t result;
+
+	BotClearMoveResult(&result);
+	//first walk straight to the reachability start
+	hordir[0] = reach->start[0] - ms->origin[0];
+	hordir[1] = reach->start[1] - ms->origin[1];
+	hordir[2] = 0;
+	dist = VectorNormalize(hordir);
+	//
+	BotCheckBlocked(ms, hordir, qtrue, &result);
+	//
+	if (dist < 10)
+	{
+		//walk straight to the reachability end
+		hordir[0] = reach->end[0] - ms->origin[0];
+		hordir[1] = reach->end[1] - ms->origin[1];
+		hordir[2] = 0;
+		dist = VectorNormalize(hordir);
+	} //end if
+	//if going towards a crouch area
+	if (!(AAS_AreaPresenceType(reach->areanum) & PRESENCE_NORMAL))
+	{
+		//if pretty close to the reachable area
+		if (dist < 20) EA_Crouch(ms->client);
+	} //end if
+	//
+	dist = BotGapDistance(ms->origin, hordir, ms->entitynum);
+	//
+	if (ms->moveflags & MFL_WALK)
+	{
+		if (dist > 0) speed = 200 - (180 - 1 * dist);
+		else speed = 200;
+		EA_Walk(ms->client);
+	} //end if
+	else
+	{
+		if (dist > 0) speed = 400 - (360 - 2 * dist);
+		else speed = 400;
+	} //end else
+	//elemantary action move in direction
+	EA_Move(ms->client, hordir, speed);
+	VectorCopy(hordir, result.movedir);
+	//
+	return result;
+} //end of the function BotTravel_Walk
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+bot_moveresult_t BotFinishTravel_Walk(bot_movestate_t *ms, aas_reachability_t *reach)
+{
+	vec3_t hordir;
+	float dist, speed;
+	bot_moveresult_t result;
+
+	BotClearMoveResult(&result);
+	//if not on the ground and changed areas... don't walk back!!
+	//(doesn't seem to help)
+	/*
+	ms->areanum = BotFuzzyPointReachabilityArea(ms->origin);
+	if (ms->areanum == reach->areanum)
+	{
+#ifdef DEBUG
+		botimport.Print(PRT_MESSAGE, "BotFinishTravel_Walk: already in reach area\n");
+#endif //DEBUG
+		return result;
+	} //end if*/
+	//go straight to the reachability end
+	hordir[0] = reach->end[0] - ms->origin[0];
+	hordir[1] = reach->end[1] - ms->origin[1];
+	hordir[2] = 0;
+	dist = VectorNormalize(hordir);
+	//
+	if (dist > 100) dist = 100;
+	speed = 400 - (400 - 3 * dist);
+	//
+	EA_Move(ms->client, hordir, speed);
+	VectorCopy(hordir, result.movedir);
+	//
+	return result;
+} //end of the function BotFinishTravel_Walk
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+bot_moveresult_t BotTravel_Crouch(bot_movestate_t *ms, aas_reachability_t *reach)
+{
+	float speed;
+	vec3_t hordir;
+	bot_moveresult_t result;
+
+	BotClearMoveResult(&result);
+	//
+	speed = 400;
+	//walk straight to reachability end
+	hordir[0] = reach->end[0] - ms->origin[0];
+	hordir[1] = reach->end[1] - ms->origin[1];
+	hordir[2] = 0;
+	VectorNormalize(hordir);
+	//
+	BotCheckBlocked(ms, hordir, qtrue, &result);
+	//elemantary actions
+	EA_Crouch(ms->client);
+	EA_Move(ms->client, hordir, speed);
+	//
+	VectorCopy(hordir, result.movedir);
+	//
+	return result;
+} //end of the function BotTravel_Crouch
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+bot_moveresult_t BotTravel_BarrierJump(bot_movestate_t *ms, aas_reachability_t *reach)
+{
+	float dist, speed;
+	vec3_t hordir;
+	bot_moveresult_t result;
+
+	BotClearMoveResult(&result);
+	//walk straight to reachability start
+	hordir[0] = reach->start[0] - ms->origin[0];
+	hordir[1] = reach->start[1] - ms->origin[1];
+	hordir[2] = 0;
+	dist = VectorNormalize(hordir);
+	//
+	BotCheckBlocked(ms, hordir, qtrue, &result);
+	//if pretty close to the barrier
+	if (dist < 9)
+	{
+		EA_Jump(ms->client);
+	} //end if
+	else
+	{
+		if (dist > 60) dist = 60;
+		speed = 360 - (360 - 6 * dist);
+		EA_Move(ms->client, hordir, speed);
+	} //end else
+	VectorCopy(hordir, result.movedir);
+	//
+	return result;
+} //end of the function BotTravel_BarrierJump
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+bot_moveresult_t BotFinishTravel_BarrierJump(bot_movestate_t *ms, aas_reachability_t *reach)
+{
+	float dist;
+	vec3_t hordir;
+	bot_moveresult_t result;
+
+	BotClearMoveResult(&result);
+	//if near the top or going down
+	if (ms->velocity[2] < 250)
+	{
+		hordir[0] = reach->end[0] - ms->origin[0];
+		hordir[1] = reach->end[1] - ms->origin[1];
+		hordir[2] = 0;
+		dist = VectorNormalize(hordir);
+		//
+		BotCheckBlocked(ms, hordir, qtrue, &result);
+		//
+		EA_Move(ms->client, hordir, 400);
+		VectorCopy(hordir, result.movedir);
+	} //end if
+	//
+	return result;
+} //end of the function BotFinishTravel_BarrierJump
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+bot_moveresult_t BotTravel_Swim(bot_movestate_t *ms, aas_reachability_t *reach)
+{
+	vec3_t dir;
+	bot_moveresult_t result;
+
+	BotClearMoveResult(&result);
+	//swim straight to reachability end
+	VectorSubtract(reach->start, ms->origin, dir);
+	VectorNormalize(dir);
+	//
+	BotCheckBlocked(ms, dir, qtrue, &result);
+	//elemantary actions
+	EA_Move(ms->client, dir, 400);
+	//
+	VectorCopy(dir, result.movedir);
+	Vector2Angles(dir, result.ideal_viewangles);
+	result.flags |= MOVERESULT_SWIMVIEW;
+	//
+	return result;
+} //end of the function BotTravel_Swim
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+bot_moveresult_t BotTravel_WaterJump(bot_movestate_t *ms, aas_reachability_t *reach)
+{
+	vec3_t dir, hordir;
+	float dist;
+	bot_moveresult_t result;
+
+	BotClearMoveResult(&result);
+	//swim straight to reachability end
+	VectorSubtract(reach->end, ms->origin, dir);
+	VectorCopy(dir, hordir);
+	hordir[2] = 0;
+	dir[2] += 15 + crandom() * 40;
+	//botimport.Print(PRT_MESSAGE, "BotTravel_WaterJump: dir[2] = %f\n", dir[2]);
+	VectorNormalize(dir);
+	dist = VectorNormalize(hordir);
+	//elemantary actions
+	//EA_Move(ms->client, dir, 400);
+	EA_MoveForward(ms->client);
+	//move up if close to the actual out of water jump spot
+	if (dist < 40) EA_MoveUp(ms->client);
+	//set the ideal view angles
+	Vector2Angles(dir, result.ideal_viewangles);
+	result.flags |= MOVERESULT_MOVEMENTVIEW;
+	//
+	VectorCopy(dir, result.movedir);
+	//
+	return result;
+} //end of the function BotTravel_WaterJump
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+bot_moveresult_t BotFinishTravel_WaterJump(bot_movestate_t *ms, aas_reachability_t *reach)
+{
+	vec3_t dir, pnt;
+	float dist;
+	bot_moveresult_t result;
+
+	//botimport.Print(PRT_MESSAGE, "BotFinishTravel_WaterJump\n");
+	BotClearMoveResult(&result);
+	//if waterjumping there's nothing to do
+	if (ms->moveflags & MFL_WATERJUMP) return result;
+	//if not touching any water anymore don't do anything
+	//otherwise the bot sometimes keeps jumping?
+	VectorCopy(ms->origin, pnt);
+	pnt[2] -= 32;	//extra for q2dm4 near red armor/mega health
+	if (!(AAS_PointContents(pnt) & (CONTENTS_LAVA|CONTENTS_SLIME|CONTENTS_WATER))) return result;
+	//swim straight to reachability end
+	VectorSubtract(reach->end, ms->origin, dir);
+	dir[0] += crandom() * 10;
+	dir[1] += crandom() * 10;
+	dir[2] += 70 + crandom() * 10;
+	dist = VectorNormalize(dir);
+	//elemantary actions
+	EA_Move(ms->client, dir, 400);
+	//set the ideal view angles
+	Vector2Angles(dir, result.ideal_viewangles);
+	result.flags |= MOVERESULT_MOVEMENTVIEW;
+	//
+	VectorCopy(dir, result.movedir);
+	//
+	return result;
+} //end of the function BotFinishTravel_WaterJump
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+bot_moveresult_t BotTravel_WalkOffLedge(bot_movestate_t *ms, aas_reachability_t *reach)
+{
+	vec3_t hordir, dir;
+	float dist, speed, reachhordist;
+	bot_moveresult_t result;
+
+	BotClearMoveResult(&result);
+	//check if the bot is blocked by anything
+	VectorSubtract(reach->start, ms->origin, dir);
+	VectorNormalize(dir);
+	BotCheckBlocked(ms, dir, qtrue, &result);
+	//if the reachability start and end are practially above each other
+	VectorSubtract(reach->end, reach->start, dir);
+	dir[2] = 0;
+	reachhordist = VectorLength(dir);
+	//walk straight to the reachability start
+	hordir[0] = reach->start[0] - ms->origin[0];
+	hordir[1] = reach->start[1] - ms->origin[1];
+	hordir[2] = 0;
+	dist = VectorNormalize(hordir);
+	//if pretty close to the start focus on the reachability end
+	if (dist < 48)
+	{
+		hordir[0] = reach->end[0] - ms->origin[0];
+		hordir[1] = reach->end[1] - ms->origin[1];
+		hordir[2] = 0;
+		VectorNormalize(hordir);
+		//
+		if (reachhordist < 20)
+		{
+			speed = 100;
+		} //end if
+		else if (!AAS_HorizontalVelocityForJump(0, reach->start, reach->end, &speed))
+		{
+			speed = 400;
+		} //end if
+	} //end if
+	else
+	{
+		if (reachhordist < 20)
+		{
+			if (dist > 64) dist = 64;
+			speed = 400 - (256 - 4 * dist);
+		} //end if
+		else
+		{
+			speed = 400;
+		} //end else
+	} //end else
+	//
+	BotCheckBlocked(ms, hordir, qtrue, &result);
+	//elemantary action
+	EA_Move(ms->client, hordir, speed);
+	VectorCopy(hordir, result.movedir);
+	//
+	return result;
+} //end of the function BotTravel_WalkOffLedge
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+int BotAirControl(vec3_t origin, vec3_t velocity, vec3_t goal, vec3_t dir, float *speed)
+{
+	vec3_t org, vel;
+	float dist;
+	int i;
+
+	VectorCopy(origin, org);
+	VectorScale(velocity, 0.1, vel);
+	for (i = 0; i < 50; i++)
+	{
+		vel[2] -= sv_gravity->value * 0.01;
+		//if going down and next position would be below the goal
+		if (vel[2] < 0 && org[2] + vel[2] < goal[2])
+		{
+			VectorScale(vel, (goal[2] - org[2]) / vel[2], vel);
+			VectorAdd(org, vel, org);
+			VectorSubtract(goal, org, dir);
+			dist = VectorNormalize(dir);
+			if (dist > 32) dist = 32;
+			*speed = 400 - (400 - 13 * dist);
+			return qtrue;
+		} //end if
+		else
+		{
+			VectorAdd(org, vel, org);
+		} //end else
+	} //end for
+	VectorSet(dir, 0, 0, 0);
+	*speed = 400;
+	return qfalse;
+} //end of the function BotAirControl
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+bot_moveresult_t BotFinishTravel_WalkOffLedge(bot_movestate_t *ms, aas_reachability_t *reach)
+{
+	vec3_t dir, hordir, end, v;
+	float dist, speed;
+	bot_moveresult_t result;
+
+	BotClearMoveResult(&result);
+	//
+	VectorSubtract(reach->end, ms->origin, dir);
+	BotCheckBlocked(ms, dir, qtrue, &result);
+	//
+	VectorSubtract(reach->end, ms->origin, v);
+	v[2] = 0;
+	dist = VectorNormalize(v);
+	if (dist > 16) VectorMA(reach->end, 16, v, end);
+	else VectorCopy(reach->end, end);
+	//
+	if (!BotAirControl(ms->origin, ms->velocity, end, hordir, &speed))
+	{
+		//go straight to the reachability end
+		VectorCopy(dir, hordir);
+		hordir[2] = 0;
+		//
+		dist = VectorNormalize(hordir);
+		speed = 400;
+	} //end if
+	//
+	EA_Move(ms->client, hordir, speed);
+	VectorCopy(hordir, result.movedir);
+	//
+	return result;
+} //end of the function BotFinishTravel_WalkOffLedge
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+/*
+bot_moveresult_t BotTravel_Jump(bot_movestate_t *ms, aas_reachability_t *reach)
+{
+	vec3_t hordir;
+	float dist, gapdist, speed, horspeed, sv_jumpvel;
+	bot_moveresult_t result;
+
+	BotClearMoveResult(&result);
+	//
+	sv_jumpvel = botlibglobals.sv_jumpvel->value;
+	//walk straight to the reachability start
+	hordir[0] = reach->start[0] - ms->origin[0];
+	hordir[1] = reach->start[1] - ms->origin[1];
+	hordir[2] = 0;
+	dist = VectorNormalize(hordir);
+	//
+	speed = 350;
+	//
+	gapdist = BotGapDistance(ms, hordir, ms->entitynum);
+	//if pretty close to the start focus on the reachability end
+	if (dist < 50 || (gapdist && gapdist < 50))
+	{
+		//NOTE: using max speed (400) works best
+		//if (AAS_HorizontalVelocityForJump(sv_jumpvel, ms->origin, reach->end, &horspeed))
+		//{
+		//	speed = horspeed * 400 / botlibglobals.sv_maxwalkvelocity->value;
+		//} //end if
+		hordir[0] = reach->end[0] - ms->origin[0];
+		hordir[1] = reach->end[1] - ms->origin[1];
+		VectorNormalize(hordir);
+		//elemantary action jump
+		EA_Jump(ms->client);
+		//
+		ms->jumpreach = ms->lastreachnum;
+		speed = 600;
+	} //end if
+	else
+	{
+		if (AAS_HorizontalVelocityForJump(sv_jumpvel, reach->start, reach->end, &horspeed))
+		{
+			speed = horspeed * 400 / botlibglobals.sv_maxwalkvelocity->value;
+		} //end if
+	} //end else
+	//elemantary action
+	EA_Move(ms->client, hordir, speed);
+	VectorCopy(hordir, result.movedir);
+	//
+	return result;
+} //end of the function BotTravel_Jump*/
+/*
+bot_moveresult_t BotTravel_Jump(bot_movestate_t *ms, aas_reachability_t *reach)
+{
+	vec3_t hordir, dir1, dir2, mins, maxs, start, end;
+	float dist1, dist2, speed;
+	bot_moveresult_t result;
+	bsp_trace_t trace;
+
+	BotClearMoveResult(&result);
+	//
+	hordir[0] = reach->start[0] - reach->end[0];
+	hordir[1] = reach->start[1] - reach->end[1];
+	hordir[2] = 0;
+	VectorNormalize(hordir);
+	//
+	VectorCopy(reach->start, start);
+	start[2] += 1;
+	//minus back the bouding box size plus 16
+	VectorMA(reach->start, 80, hordir, end);
+	//
+	AAS_PresenceTypeBoundingBox(PRESENCE_NORMAL, mins, maxs);
+	//check for solids
+	trace = AAS_Trace(start, mins, maxs, end, ms->entitynum, MASK_PLAYERSOLID);
+	if (trace.startsolid) VectorCopy(start, trace.endpos);
+	//check for a gap
+	for (dist1 = 0; dist1 < 80; dist1 += 10)
+	{
+		VectorMA(start, dist1+10, hordir, end);
+		end[2] += 1;
+		if (AAS_PointAreaNum(end) != ms->reachareanum) break;
+	} //end for
+	if (dist1 < 80) VectorMA(reach->start, dist1, hordir, trace.endpos);
+//	dist1 = BotGapDistance(start, hordir, ms->entitynum);
+//	if (dist1 && dist1 <= trace.fraction * 80) VectorMA(reach->start, dist1-20, hordir, trace.endpos);
+	//
+	VectorSubtract(ms->origin, reach->start, dir1);
+	dir1[2] = 0;
+	dist1 = VectorNormalize(dir1);
+	VectorSubtract(ms->origin, trace.endpos, dir2);
+	dir2[2] = 0;
+	dist2 = VectorNormalize(dir2);
+	//if just before the reachability start
+	if (DotProduct(dir1, dir2) < -0.8 || dist2 < 5)
+	{
+		//botimport.Print(PRT_MESSAGE, "between jump start and run to point\n");
+		hordir[0] = reach->end[0] - ms->origin[0];
+		hordir[1] = reach->end[1] - ms->origin[1];
+		hordir[2] = 0;
+		VectorNormalize(hordir);
+		//elemantary action jump
+		if (dist1 < 24) EA_Jump(ms->client);
+		else if (dist1 < 32) EA_DelayedJump(ms->client);
+		EA_Move(ms->client, hordir, 600);
+		//
+		ms->jumpreach = ms->lastreachnum;
+	} //end if
+	else
+	{
+		//botimport.Print(PRT_MESSAGE, "going towards run to point\n");
+		hordir[0] = trace.endpos[0] - ms->origin[0];
+		hordir[1] = trace.endpos[1] - ms->origin[1];
+		hordir[2] = 0;
+		VectorNormalize(hordir);
+		//
+		if (dist2 > 80) dist2 = 80;
+		speed = 400 - (400 - 5 * dist2);
+		EA_Move(ms->client, hordir, speed);
+	} //end else
+	VectorCopy(hordir, result.movedir);
+	//
+	return result;
+} //end of the function BotTravel_Jump*/
+//*
+bot_moveresult_t BotTravel_Jump(bot_movestate_t *ms, aas_reachability_t *reach)
+{
+	vec3_t hordir, dir1, dir2, start, end, runstart;
+//	vec3_t runstart, dir1, dir2, hordir;
+	float dist1, dist2, speed;
+	bot_moveresult_t result;
+
+	BotClearMoveResult(&result);
+	//
+	AAS_JumpReachRunStart(reach, runstart);
+	//*
+	hordir[0] = runstart[0] - reach->start[0];
+	hordir[1] = runstart[1] - reach->start[1];
+	hordir[2] = 0;
+	VectorNormalize(hordir);
+	//
+	VectorCopy(reach->start, start);
+	start[2] += 1;
+	VectorMA(reach->start, 80, hordir, runstart);
+	//check for a gap
+	for (dist1 = 0; dist1 < 80; dist1 += 10)
+	{
+		VectorMA(start, dist1+10, hordir, end);
+		end[2] += 1;
+		if (AAS_PointAreaNum(end) != ms->reachareanum) break;
+	} //end for
+	if (dist1 < 80) VectorMA(reach->start, dist1, hordir, runstart);
+	//
+	VectorSubtract(ms->origin, reach->start, dir1);
+	dir1[2] = 0;
+	dist1 = VectorNormalize(dir1);
+	VectorSubtract(ms->origin, runstart, dir2);
+	dir2[2] = 0;
+	dist2 = VectorNormalize(dir2);
+	//if just before the reachability start
+	if (DotProduct(dir1, dir2) < -0.8 || dist2 < 5)
+	{
+//		botimport.Print(PRT_MESSAGE, "between jump start and run start point\n");
+		hordir[0] = reach->end[0] - ms->origin[0];
+		hordir[1] = reach->end[1] - ms->origin[1];
+		hordir[2] = 0;
+		VectorNormalize(hordir);
+		//elemantary action jump
+		if (dist1 < 24) EA_Jump(ms->client);
+		else if (dist1 < 32) EA_DelayedJump(ms->client);
+		EA_Move(ms->client, hordir, 600);
+		//
+		ms->jumpreach = ms->lastreachnum;
+	} //end if
+	else
+	{
+//		botimport.Print(PRT_MESSAGE, "going towards run start point\n");
+		hordir[0] = runstart[0] - ms->origin[0];
+		hordir[1] = runstart[1] - ms->origin[1];
+		hordir[2] = 0;
+		VectorNormalize(hordir);
+		//
+		if (dist2 > 80) dist2 = 80;
+		speed = 400 - (400 - 5 * dist2);
+		EA_Move(ms->client, hordir, speed);
+	} //end else
+	VectorCopy(hordir, result.movedir);
+	//
+	return result;
+} //end of the function BotTravel_Jump*/
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+bot_moveresult_t BotFinishTravel_Jump(bot_movestate_t *ms, aas_reachability_t *reach)
+{
+	vec3_t hordir, hordir2;
+	float speed, dist;
+	bot_moveresult_t result;
+
+	BotClearMoveResult(&result);
+	//if not jumped yet
+	if (!ms->jumpreach) return result;
+	//go straight to the reachability end
+	hordir[0] = reach->end[0] - ms->origin[0];
+	hordir[1] = reach->end[1] - ms->origin[1];
+	hordir[2] = 0;
+	dist = VectorNormalize(hordir);
+	//
+	hordir2[0] = reach->end[0] - reach->start[0];
+	hordir2[1] = reach->end[1] - reach->start[1];
+	hordir2[2] = 0;
+	VectorNormalize(hordir2);
+	//
+	if (DotProduct(hordir, hordir2) < -0.5 && dist < 24) return result;
+	//always use max speed when traveling through the air
+	speed = 800;
+	//
+	EA_Move(ms->client, hordir, speed);
+	VectorCopy(hordir, result.movedir);
+	//
+	return result;
+} //end of the function BotFinishTravel_Jump
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+bot_moveresult_t BotTravel_Ladder(bot_movestate_t *ms, aas_reachability_t *reach)
+{
+	//float dist, speed;
+	vec3_t dir, viewdir;//, hordir;
+	vec3_t origin = {0, 0, 0};
+//	vec3_t up = {0, 0, 1};
+	bot_moveresult_t result;
+
+	BotClearMoveResult(&result);
+	//
+//	if ((ms->moveflags & MFL_AGAINSTLADDER))
+		//NOTE: not a good idea for ladders starting in water
+		// || !(ms->moveflags & MFL_ONGROUND))
+	{
+		//botimport.Print(PRT_MESSAGE, "against ladder or not on ground\n");
+		VectorSubtract(reach->end, ms->origin, dir);
+		VectorNormalize(dir);
+		//set the ideal view angles, facing the ladder up or down
+		viewdir[0] = dir[0];
+		viewdir[1] = dir[1];
+		viewdir[2] = 3 * dir[2];
+		Vector2Angles(viewdir, result.ideal_viewangles);
+		//elemantary action
+		EA_Move(ms->client, origin, 0);
+		EA_MoveForward(ms->client);
+		//set movement view flag so the AI can see the view is focussed
+		result.flags |= MOVERESULT_MOVEMENTVIEW;
+	} //end if
+/*	else
+	{
+		//botimport.Print(PRT_MESSAGE, "moving towards ladder\n");
+		VectorSubtract(reach->end, ms->origin, dir);
+		//make sure the horizontal movement is large anough
+		VectorCopy(dir, hordir);
+		hordir[2] = 0;
+		dist = VectorNormalize(hordir);
+		//
+		dir[0] = hordir[0];
+		dir[1] = hordir[1];
+		if (dir[2] > 0) dir[2] = 1;
+		else dir[2] = -1;
+		if (dist > 50) dist = 50;
+		speed = 400 - (200 - 4 * dist);
+		EA_Move(ms->client, dir, speed);
+	} //end else*/
+	//save the movement direction
+	VectorCopy(dir, result.movedir);
+	//
+	return result;
+} //end of the function BotTravel_Ladder
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+bot_moveresult_t BotTravel_Teleport(bot_movestate_t *ms, aas_reachability_t *reach)
+{
+	vec3_t hordir;
+	float dist;
+	bot_moveresult_t result;
+
+	BotClearMoveResult(&result);
+	//if the bot is being teleported
+	if (ms->moveflags & MFL_TELEPORTED) return result;
+
+	//walk straight to center of the teleporter
+	VectorSubtract(reach->start, ms->origin, hordir);
+	if (!(ms->moveflags & MFL_SWIMMING)) hordir[2] = 0;
+	dist = VectorNormalize(hordir);
+	//
+	BotCheckBlocked(ms, hordir, qtrue, &result);
+
+	if (dist < 30) EA_Move(ms->client, hordir, 200);
+	else EA_Move(ms->client, hordir, 400);
+
+	if (ms->moveflags & MFL_SWIMMING) result.flags |= MOVERESULT_SWIMVIEW;
+
+	VectorCopy(hordir, result.movedir);
+	return result;
+} //end of the function BotTravel_Teleport
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+bot_moveresult_t BotTravel_Elevator(bot_movestate_t *ms, aas_reachability_t *reach)
+{
+	vec3_t dir, dir1, dir2, hordir, bottomcenter;
+	float dist, dist1, dist2, speed;
+	bot_moveresult_t result;
+
+	BotClearMoveResult(&result);
+	//if standing on the plat
+	if (BotOnMover(ms->origin, ms->entitynum, reach))
+	{
+#ifdef DEBUG_ELEVATOR
+		botimport.Print(PRT_MESSAGE, "bot on elevator\n");
+#endif //DEBUG_ELEVATOR
+		//if vertically not too far from the end point
+		if (abs(ms->origin[2] - reach->end[2]) < sv_maxbarrier->value)
+		{
+#ifdef DEBUG_ELEVATOR
+			botimport.Print(PRT_MESSAGE, "bot moving to end\n");
+#endif //DEBUG_ELEVATOR
+			//move to the end point
+			VectorSubtract(reach->end, ms->origin, hordir);
+			hordir[2] = 0;
+			VectorNormalize(hordir);
+			if (!BotCheckBarrierJump(ms, hordir, 100))
+			{
+				EA_Move(ms->client, hordir, 400);
+			} //end if
+			VectorCopy(hordir, result.movedir);
+		} //end else
+		//if not really close to the center of the elevator
+		else
+		{
+			MoverBottomCenter(reach, bottomcenter);
+			VectorSubtract(bottomcenter, ms->origin, hordir);
+			hordir[2] = 0;
+			dist = VectorNormalize(hordir);
+			//
+			if (dist > 10)
+			{
+#ifdef DEBUG_ELEVATOR
+				botimport.Print(PRT_MESSAGE, "bot moving to center\n");
+#endif //DEBUG_ELEVATOR
+				//move to the center of the plat
+				if (dist > 100) dist = 100;
+				speed = 400 - (400 - 4 * dist);
+				//
+				EA_Move(ms->client, hordir, speed);
+				VectorCopy(hordir, result.movedir);
+			} //end if
+		} //end else
+	} //end if
+	else
+	{
+#ifdef DEBUG_ELEVATOR
+		botimport.Print(PRT_MESSAGE, "bot not on elevator\n");
+#endif //DEBUG_ELEVATOR
+		//if very near the reachability end
+		VectorSubtract(reach->end, ms->origin, dir);
+		dist = VectorLength(dir);
+		if (dist < 64)
+		{
+			if (dist > 60) dist = 60;
+			speed = 360 - (360 - 6 * dist);
+			//
+			if ((ms->moveflags & MFL_SWIMMING) || !BotCheckBarrierJump(ms, dir, 50))
+			{
+				if (speed > 5) EA_Move(ms->client, dir, speed);
+			} //end if
+			VectorCopy(dir, result.movedir);
+			//
+			if (ms->moveflags & MFL_SWIMMING) result.flags |= MOVERESULT_SWIMVIEW;
+			//stop using this reachability
+			ms->reachability_time = 0;
+			return result;
+		} //end if
+		//get direction and distance to reachability start
+		VectorSubtract(reach->start, ms->origin, dir1);
+		if (!(ms->moveflags & MFL_SWIMMING)) dir1[2] = 0;
+		dist1 = VectorNormalize(dir1);
+		//if the elevator isn't down
+		if (!MoverDown(reach))
+		{
+#ifdef DEBUG_ELEVATOR
+			botimport.Print(PRT_MESSAGE, "elevator not down\n");
+#endif //DEBUG_ELEVATOR
+			dist = dist1;
+			VectorCopy(dir1, dir);
+			//
+			BotCheckBlocked(ms, dir, qfalse, &result);
+			//
+			if (dist > 60) dist = 60;
+			speed = 360 - (360 - 6 * dist);
+			//
+			if (!(ms->moveflags & MFL_SWIMMING) && !BotCheckBarrierJump(ms, dir, 50))
+			{
+				if (speed > 5) EA_Move(ms->client, dir, speed);
+			} //end if
+			VectorCopy(dir, result.movedir);
+			//
+			if (ms->moveflags & MFL_SWIMMING) result.flags |= MOVERESULT_SWIMVIEW;
+			//this isn't a failure... just wait till the elevator comes down
+			result.type = RESULTTYPE_ELEVATORUP;
+			result.flags |= MOVERESULT_WAITING;
+			return result;
+		} //end if
+		//get direction and distance to elevator bottom center
+		MoverBottomCenter(reach, bottomcenter);
+		VectorSubtract(bottomcenter, ms->origin, dir2);
+		if (!(ms->moveflags & MFL_SWIMMING)) dir2[2] = 0;
+		dist2 = VectorNormalize(dir2);
+		//if very close to the reachability start or
+		//closer to the elevator center or
+		//between reachability start and elevator center
+		if (dist1 < 20 || dist2 < dist1 || DotProduct(dir1, dir2) < 0)
+		{
+#ifdef DEBUG_ELEVATOR
+			botimport.Print(PRT_MESSAGE, "bot moving to center\n");
+#endif //DEBUG_ELEVATOR
+			dist = dist2;
+			VectorCopy(dir2, dir);
+		} //end if
+		else //closer to the reachability start
+		{
+#ifdef DEBUG_ELEVATOR
+			botimport.Print(PRT_MESSAGE, "bot moving to start\n");
+#endif //DEBUG_ELEVATOR
+			dist = dist1;
+			VectorCopy(dir1, dir);
+		} //end else
+		//
+		BotCheckBlocked(ms, dir, qfalse, &result);
+		//
+		if (dist > 60) dist = 60;
+		speed = 400 - (400 - 6 * dist);
+		//
+		if (!(ms->moveflags & MFL_SWIMMING) && !BotCheckBarrierJump(ms, dir, 50))
+		{
+			EA_Move(ms->client, dir, speed);
+		} //end if
+		VectorCopy(dir, result.movedir);
+		//
+		if (ms->moveflags & MFL_SWIMMING) result.flags |= MOVERESULT_SWIMVIEW;
+	} //end else
+	return result;
+} //end of the function BotTravel_Elevator
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+bot_moveresult_t BotFinishTravel_Elevator(bot_movestate_t *ms, aas_reachability_t *reach)
+{
+	vec3_t bottomcenter, bottomdir, topdir;
+	bot_moveresult_t result;
+
+	BotClearMoveResult(&result);
+	//
+	MoverBottomCenter(reach, bottomcenter);
+	VectorSubtract(bottomcenter, ms->origin, bottomdir);
+	//
+	VectorSubtract(reach->end, ms->origin, topdir);
+	//
+	if (fabs(bottomdir[2]) < fabs(topdir[2]))
+	{
+		VectorNormalize(bottomdir);
+		EA_Move(ms->client, bottomdir, 300);
+	} //end if
+	else
+	{
+		VectorNormalize(topdir);
+		EA_Move(ms->client, topdir, 300);
+	} //end else
+	return result;
+} //end of the function BotFinishTravel_Elevator
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+void BotFuncBobStartEnd(aas_reachability_t *reach, vec3_t start, vec3_t end, vec3_t origin)
+{
+	int spawnflags, modelnum;
+	vec3_t mins, maxs, mid, angles = {0, 0, 0};
+	int num0, num1;
+
+	modelnum = reach->facenum & 0x0000FFFF;
+	if (!AAS_OriginOfMoverWithModelNum(modelnum, origin))
+	{
+		botimport.Print(PRT_MESSAGE, "BotFuncBobStartEnd: no entity with model %d\n", modelnum);
+		VectorSet(start, 0, 0, 0);
+		VectorSet(end, 0, 0, 0);
+		return;
+	} //end if
+	AAS_BSPModelMinsMaxsOrigin(modelnum, angles, mins, maxs, NULL);
+	VectorAdd(mins, maxs, mid);
+	VectorScale(mid, 0.5, mid);
+	VectorCopy(mid, start);
+	VectorCopy(mid, end);
+	spawnflags = reach->facenum >> 16;
+	num0 = reach->edgenum >> 16;
+	if (num0 > 0x00007FFF) num0 |= 0xFFFF0000;
+	num1 = reach->edgenum & 0x0000FFFF;
+	if (num1 > 0x00007FFF) num1 |= 0xFFFF0000;
+	if (spawnflags & 1)
+	{
+		start[0] = num0;
+		end[0] = num1;
+		//
+		origin[0] += mid[0];
+		origin[1] = mid[1];
+		origin[2] = mid[2];
+	} //end if
+	else if (spawnflags & 2)
+	{
+		start[1] = num0;
+		end[1] = num1;
+		//
+		origin[0] = mid[0];
+		origin[1] += mid[1];
+		origin[2] = mid[2];
+	} //end else if
+	else
+	{
+		start[2] = num0;
+		end[2] = num1;
+		//
+		origin[0] = mid[0];
+		origin[1] = mid[1];
+		origin[2] += mid[2];
+	} //end else
+} //end of the function BotFuncBobStartEnd
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+bot_moveresult_t BotTravel_FuncBobbing(bot_movestate_t *ms, aas_reachability_t *reach)
+{
+	vec3_t dir, dir1, dir2, hordir, bottomcenter, bob_start, bob_end, bob_origin;
+	float dist, dist1, dist2, speed;
+	bot_moveresult_t result;
+
+	BotClearMoveResult(&result);
+	//
+	BotFuncBobStartEnd(reach, bob_start, bob_end, bob_origin);
+	//if standing ontop of the func_bobbing
+	if (BotOnMover(ms->origin, ms->entitynum, reach))
+	{
+#ifdef DEBUG_FUNCBOB
+		botimport.Print(PRT_MESSAGE, "bot on func_bobbing\n");
+#endif
+		//if near end point of reachability
+		VectorSubtract(bob_origin, bob_end, dir);
+		if (VectorLength(dir) < 24)
+		{
+#ifdef DEBUG_FUNCBOB
+			botimport.Print(PRT_MESSAGE, "bot moving to reachability end\n");
+#endif
+			//move to the end point
+			VectorSubtract(reach->end, ms->origin, hordir);
+			hordir[2] = 0;
+			VectorNormalize(hordir);
+			if (!BotCheckBarrierJump(ms, hordir, 100))
+			{
+				EA_Move(ms->client, hordir, 400);
+			} //end if
+			VectorCopy(hordir, result.movedir);
+		} //end else
+		//if not really close to the center of the elevator
+		else
+		{
+			MoverBottomCenter(reach, bottomcenter);
+			VectorSubtract(bottomcenter, ms->origin, hordir);
+			hordir[2] = 0;
+			dist = VectorNormalize(hordir);
+			//
+			if (dist > 10)
+			{
+#ifdef DEBUG_FUNCBOB
+				botimport.Print(PRT_MESSAGE, "bot moving to func_bobbing center\n");
+#endif
+				//move to the center of the plat
+				if (dist > 100) dist = 100;
+				speed = 400 - (400 - 4 * dist);
+				//
+				EA_Move(ms->client, hordir, speed);
+				VectorCopy(hordir, result.movedir);
+			} //end if
+		} //end else
+	} //end if
+	else
+	{
+#ifdef DEBUG_FUNCBOB
+		botimport.Print(PRT_MESSAGE, "bot not ontop of func_bobbing\n");
+#endif
+		//if very near the reachability end
+		VectorSubtract(reach->end, ms->origin, dir);
+		dist = VectorLength(dir);
+		if (dist < 64)
+		{
+#ifdef DEBUG_FUNCBOB
+			botimport.Print(PRT_MESSAGE, "bot moving to end\n");
+#endif
+			if (dist > 60) dist = 60;
+			speed = 360 - (360 - 6 * dist);
+			//if swimming or no barrier jump
+			if ((ms->moveflags & MFL_SWIMMING) || !BotCheckBarrierJump(ms, dir, 50))
+			{
+				if (speed > 5) EA_Move(ms->client, dir, speed);
+			} //end if
+			VectorCopy(dir, result.movedir);
+			//
+			if (ms->moveflags & MFL_SWIMMING) result.flags |= MOVERESULT_SWIMVIEW;
+			//stop using this reachability
+			ms->reachability_time = 0;
+			return result;
+		} //end if
+		//get direction and distance to reachability start
+		VectorSubtract(reach->start, ms->origin, dir1);
+		if (!(ms->moveflags & MFL_SWIMMING)) dir1[2] = 0;
+		dist1 = VectorNormalize(dir1);
+		//if func_bobbing is Not it's start position
+		VectorSubtract(bob_origin, bob_start, dir);
+		if (VectorLength(dir) > 16)
+		{
+#ifdef DEBUG_FUNCBOB
+			botimport.Print(PRT_MESSAGE, "func_bobbing not at start\n");
+#endif
+			dist = dist1;
+			VectorCopy(dir1, dir);
+			//
+			BotCheckBlocked(ms, dir, qfalse, &result);
+			//
+			if (dist > 60) dist = 60;
+			speed = 360 - (360 - 6 * dist);
+			//
+			if (!(ms->moveflags & MFL_SWIMMING) && !BotCheckBarrierJump(ms, dir, 50))
+			{
+				if (speed > 5) EA_Move(ms->client, dir, speed);
+			} //end if
+			VectorCopy(dir, result.movedir);
+			//
+			if (ms->moveflags & MFL_SWIMMING) result.flags |= MOVERESULT_SWIMVIEW;
+			//this isn't a failure... just wait till the func_bobbing arrives
+			result.type = RESULTTYPE_WAITFORFUNCBOBBING;
+			result.flags |= MOVERESULT_WAITING;
+			return result;
+		} //end if
+		//get direction and distance to func_bob bottom center
+		MoverBottomCenter(reach, bottomcenter);
+		VectorSubtract(bottomcenter, ms->origin, dir2);
+		if (!(ms->moveflags & MFL_SWIMMING)) dir2[2] = 0;
+		dist2 = VectorNormalize(dir2);
+		//if very close to the reachability start or
+		//closer to the elevator center or
+		//between reachability start and func_bobbing center
+		if (dist1 < 20 || dist2 < dist1 || DotProduct(dir1, dir2) < 0)
+		{
+#ifdef DEBUG_FUNCBOB
+			botimport.Print(PRT_MESSAGE, "bot moving to func_bobbing center\n");
+#endif
+			dist = dist2;
+			VectorCopy(dir2, dir);
+		} //end if
+		else //closer to the reachability start
+		{
+#ifdef DEBUG_FUNCBOB
+			botimport.Print(PRT_MESSAGE, "bot moving to reachability start\n");
+#endif
+			dist = dist1;
+			VectorCopy(dir1, dir);
+		} //end else
+		//
+		BotCheckBlocked(ms, dir, qfalse, &result);
+		//
+		if (dist > 60) dist = 60;
+		speed = 400 - (400 - 6 * dist);
+		//
+		if (!(ms->moveflags & MFL_SWIMMING) && !BotCheckBarrierJump(ms, dir, 50))
+		{
+			EA_Move(ms->client, dir, speed);
+		} //end if
+		VectorCopy(dir, result.movedir);
+		//
+		if (ms->moveflags & MFL_SWIMMING) result.flags |= MOVERESULT_SWIMVIEW;
+	} //end else
+	return result;
+} //end of the function BotTravel_FuncBobbing
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+bot_moveresult_t BotFinishTravel_FuncBobbing(bot_movestate_t *ms, aas_reachability_t *reach)
+{
+	vec3_t bob_origin, bob_start, bob_end, dir, hordir, bottomcenter;
+	bot_moveresult_t result;
+	float dist, speed;
+
+	BotClearMoveResult(&result);
+	//
+	BotFuncBobStartEnd(reach, bob_start, bob_end, bob_origin);
+	//
+	VectorSubtract(bob_origin, bob_end, dir);
+	dist = VectorLength(dir);
+	//if the func_bobbing is near the end
+	if (dist < 16)
+	{
+		VectorSubtract(reach->end, ms->origin, hordir);
+		if (!(ms->moveflags & MFL_SWIMMING)) hordir[2] = 0;
+		dist = VectorNormalize(hordir);
+		//
+		if (dist > 60) dist = 60;
+		speed = 360 - (360 - 6 * dist);
+		//
+		if (speed > 5) EA_Move(ms->client, dir, speed);
+		VectorCopy(dir, result.movedir);
+		//
+		if (ms->moveflags & MFL_SWIMMING) result.flags |= MOVERESULT_SWIMVIEW;
+	} //end if
+	else
+	{
+		MoverBottomCenter(reach, bottomcenter);
+		VectorSubtract(bottomcenter, ms->origin, hordir);
+		if (!(ms->moveflags & MFL_SWIMMING)) hordir[2] = 0;
+		dist = VectorNormalize(hordir);
+		//
+		if (dist > 5)
+		{
+			//move to the center of the plat
+			if (dist > 100) dist = 100;
+			speed = 400 - (400 - 4 * dist);
+			//
+			EA_Move(ms->client, hordir, speed);
+			VectorCopy(hordir, result.movedir);
+		} //end if
+	} //end else
+	return result;
+} //end of the function BotFinishTravel_FuncBobbing
+//===========================================================================
+// 0  no valid grapple hook visible
+// 1  the grapple hook is still flying
+// 2  the grapple hooked into a wall
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int GrappleState(bot_movestate_t *ms, aas_reachability_t *reach)
+{
+	int i;
+	aas_entityinfo_t entinfo;
+
+	//if the grapple hook is pulling
+	if (ms->moveflags & MFL_GRAPPLEPULL)
+		return 2;
+	//check for a visible grapple missile entity
+	//or visible grapple entity
+	for (i = AAS_NextEntity(0); i; i = AAS_NextEntity(i))
+	{
+		if (AAS_EntityType(i) == (int) entitytypemissile->value)
+		{
+			AAS_EntityInfo(i, &entinfo);
+			if (entinfo.weapon == (int) weapindex_grapple->value)
+			{
+				return 1;
+			} //end if
+		} //end if
+	} //end for
+	//no valid grapple at all
+	return 0;
+} //end of the function GrappleState
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void BotResetGrapple(bot_movestate_t *ms)
+{
+	aas_reachability_t reach;
+
+	AAS_ReachabilityFromNum(ms->lastreachnum, &reach);
+	//if not using the grapple hook reachability anymore
+	if ((reach.traveltype & TRAVELTYPE_MASK) != TRAVEL_GRAPPLEHOOK)
+	{
+		if ((ms->moveflags & MFL_ACTIVEGRAPPLE) || ms->grapplevisible_time)
+		{
+			if (offhandgrapple->value)
+				EA_Command(ms->client, cmd_grappleoff->string);
+			ms->moveflags &= ~MFL_ACTIVEGRAPPLE;
+			ms->grapplevisible_time = 0;
+#ifdef DEBUG_GRAPPLE
+			botimport.Print(PRT_MESSAGE, "reset grapple\n");
+#endif //DEBUG_GRAPPLE
+		} //end if
+	} //end if
+} //end of the function BotResetGrapple
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+bot_moveresult_t BotTravel_Grapple(bot_movestate_t *ms, aas_reachability_t *reach)
+{
+	bot_moveresult_t result;
+	float dist, speed;
+	vec3_t dir, viewdir, org;
+	int state, areanum;
+	bsp_trace_t trace;
+
+#ifdef DEBUG_GRAPPLE
+	static int debugline;
+	if (!debugline) debugline = botimport.DebugLineCreate();
+	botimport.DebugLineShow(debugline, reach->start, reach->end, LINECOLOR_BLUE);
+#endif //DEBUG_GRAPPLE
+
+	BotClearMoveResult(&result);
+	//
+	if (ms->moveflags & MFL_GRAPPLERESET)
+	{
+		if (offhandgrapple->value)
+			EA_Command(ms->client, cmd_grappleoff->string);
+		ms->moveflags &= ~MFL_ACTIVEGRAPPLE;
+		return result;
+	} //end if
+	//
+	if (!(int) offhandgrapple->value)
+	{
+		result.weapon = weapindex_grapple->value;
+		result.flags |= MOVERESULT_MOVEMENTWEAPON;
+	} //end if
+	//
+	if (ms->moveflags & MFL_ACTIVEGRAPPLE)
+	{
+#ifdef DEBUG_GRAPPLE
+		botimport.Print(PRT_MESSAGE, "BotTravel_Grapple: active grapple\n");
+#endif //DEBUG_GRAPPLE
+		//
+		state = GrappleState(ms, reach);
+		//
+		VectorSubtract(reach->end, ms->origin, dir);
+		dir[2] = 0;
+		dist = VectorLength(dir);
+		//if very close to the grapple end or the grappled is hooked and
+		//the bot doesn't get any closer
+		if (state && dist < 48)
+		{
+			if (ms->lastgrappledist - dist < 1)
+			{
+#ifdef DEBUG_GRAPPLE
+				botimport.Print(PRT_ERROR, "grapple normal end\n");
+#endif //DEBUG_GRAPPLE
+				if (offhandgrapple->value)
+					EA_Command(ms->client, cmd_grappleoff->string);
+				ms->moveflags &= ~MFL_ACTIVEGRAPPLE;
+				ms->moveflags |= MFL_GRAPPLERESET;
+				ms->reachability_time = 0;	//end the reachability
+				return result;
+			} //end if
+		} //end if
+		//if no valid grapple at all, or the grapple hooked and the bot
+		//isn't moving anymore
+		else if (!state || (state == 2 && dist > ms->lastgrappledist - 2))
+		{
+			if (ms->grapplevisible_time < AAS_Time() - 0.4)
+			{
+#ifdef DEBUG_GRAPPLE
+				botimport.Print(PRT_ERROR, "grapple not visible\n");
+#endif //DEBUG_GRAPPLE
+				if (offhandgrapple->value)
+					EA_Command(ms->client, cmd_grappleoff->string);
+				ms->moveflags &= ~MFL_ACTIVEGRAPPLE;
+				ms->moveflags |= MFL_GRAPPLERESET;
+				ms->reachability_time = 0;	//end the reachability
+				return result;
+			} //end if
+		} //end if
+		else
+		{
+			ms->grapplevisible_time = AAS_Time();
+		} //end else
+		//
+		if (!(int) offhandgrapple->value)
+		{
+			EA_Attack(ms->client);
+		} //end if
+		//remember the current grapple distance
+		ms->lastgrappledist = dist;
+	} //end if
+	else
+	{
+#ifdef DEBUG_GRAPPLE
+		botimport.Print(PRT_MESSAGE, "BotTravel_Grapple: inactive grapple\n");
+#endif //DEBUG_GRAPPLE
+		//
+		ms->grapplevisible_time = AAS_Time();
+		//
+		VectorSubtract(reach->start, ms->origin, dir);
+		if (!(ms->moveflags & MFL_SWIMMING)) dir[2] = 0;
+		VectorAdd(ms->origin, ms->viewoffset, org);
+		VectorSubtract(reach->end, org, viewdir);
+		//
+		dist = VectorNormalize(dir);
+		Vector2Angles(viewdir, result.ideal_viewangles);
+		result.flags |= MOVERESULT_MOVEMENTVIEW;
+		//
+		if (dist < 5 &&
+			fabs(AngleDiff(result.ideal_viewangles[0], ms->viewangles[0])) < 2 &&
+			fabs(AngleDiff(result.ideal_viewangles[1], ms->viewangles[1])) < 2)
+		{
+#ifdef DEBUG_GRAPPLE
+			botimport.Print(PRT_MESSAGE, "BotTravel_Grapple: activating grapple\n");
+#endif //DEBUG_GRAPPLE
+			//check if the grapple missile path is clear
+			VectorAdd(ms->origin, ms->viewoffset, org);
+			trace = AAS_Trace(org, NULL, NULL, reach->end, ms->entitynum, CONTENTS_SOLID);
+			VectorSubtract(reach->end, trace.endpos, dir);
+			if (VectorLength(dir) > 16)
+			{
+				result.failure = qtrue;
+				return result;
+			} //end if
+			//activate the grapple
+			if (offhandgrapple->value)
+			{
+				EA_Command(ms->client, cmd_grappleon->string);
+			} //end if
+			else
+			{
+				EA_Attack(ms->client);
+			} //end else
+			ms->moveflags |= MFL_ACTIVEGRAPPLE;
+			ms->lastgrappledist = 999999;
+		} //end if
+		else
+		{
+			if (dist < 70) speed = 300 - (300 - 4 * dist);
+			else speed = 400;
+			//
+			BotCheckBlocked(ms, dir, qtrue, &result);
+			//elemantary action move in direction
+			EA_Move(ms->client, dir, speed);
+			VectorCopy(dir, result.movedir);
+		} //end else
+		//if in another area before actually grappling
+		areanum = AAS_PointAreaNum(ms->origin);
+		if (areanum && areanum != ms->reachareanum) ms->reachability_time = 0;
+	} //end else
+	return result;
+} //end of the function BotTravel_Grapple
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:			-
+//===========================================================================
+bot_moveresult_t BotTravel_RocketJump(bot_movestate_t *ms, aas_reachability_t *reach)
+{
+	vec3_t hordir;
+	float dist, speed;
+	bot_moveresult_t result;
+
+	//botimport.Print(PRT_MESSAGE, "BotTravel_RocketJump: bah\n");
+	BotClearMoveResult(&result);
+	//
+	hordir[0] = reach->start[0] - ms->origin[0];
+	hordir[1] = reach->start[1] - ms->origin[1];
+	hordir[2] = 0;
+	//
+	dist = VectorNormalize(hordir);
+	//look in the movement direction
+	Vector2Angles(hordir, result.ideal_viewangles);
+	//look straight down
+	result.ideal_viewangles[PITCH] = 90;
+	//
+	if (dist < 5 &&
+			fabs(AngleDiff(result.ideal_viewangles[0], ms->viewangles[0])) < 5 &&
+			fabs(AngleDiff(result.ideal_viewangles[1], ms->viewangles[1])) < 5)
+	{
+		//botimport.Print(PRT_MESSAGE, "between jump start and run start point\n");
+		hordir[0] = reach->end[0] - ms->origin[0];
+		hordir[1] = reach->end[1] - ms->origin[1];
+		hordir[2] = 0;
+		VectorNormalize(hordir);
+		//elemantary action jump
+		EA_Jump(ms->client);
+		EA_Attack(ms->client);
+		EA_Move(ms->client, hordir, 800);
+		//
+		ms->jumpreach = ms->lastreachnum;
+	} //end if
+	else
+	{
+		if (dist > 80) dist = 80;
+		speed = 400 - (400 - 5 * dist);
+		EA_Move(ms->client, hordir, speed);
+	} //end else
+	//look in the movement direction
+	Vector2Angles(hordir, result.ideal_viewangles);
+	//look straight down
+	result.ideal_viewangles[PITCH] = 90;
+	//set the view angles directly
+	EA_View(ms->client, result.ideal_viewangles);
+	//view is important for the movment
+	result.flags |= MOVERESULT_MOVEMENTVIEWSET;
+	//select the rocket launcher
+	EA_SelectWeapon(ms->client, (int) weapindex_rocketlauncher->value);
+	//weapon is used for movement
+	result.weapon = (int) weapindex_rocketlauncher->value;
+	result.flags |= MOVERESULT_MOVEMENTWEAPON;
+	//
+	VectorCopy(hordir, result.movedir);
+	//
+	return result;
+} //end of the function BotTravel_RocketJump
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+bot_moveresult_t BotTravel_BFGJump(bot_movestate_t *ms, aas_reachability_t *reach)
+{
+	vec3_t hordir;
+	float dist, speed;
+	bot_moveresult_t result;
+
+	//botimport.Print(PRT_MESSAGE, "BotTravel_BFGJump: bah\n");
+	BotClearMoveResult(&result);
+	//
+	hordir[0] = reach->start[0] - ms->origin[0];
+	hordir[1] = reach->start[1] - ms->origin[1];
+	hordir[2] = 0;
+	//
+	dist = VectorNormalize(hordir);
+	//
+	if (dist < 5 &&
+			fabs(AngleDiff(result.ideal_viewangles[0], ms->viewangles[0])) < 5 &&
+			fabs(AngleDiff(result.ideal_viewangles[1], ms->viewangles[1])) < 5)
+	{
+		//botimport.Print(PRT_MESSAGE, "between jump start and run start point\n");
+		hordir[0] = reach->end[0] - ms->origin[0];
+		hordir[1] = reach->end[1] - ms->origin[1];
+		hordir[2] = 0;
+		VectorNormalize(hordir);
+		//elemantary action jump
+		EA_Jump(ms->client);
+		EA_Attack(ms->client);
+		EA_Move(ms->client, hordir, 800);
+		//
+		ms->jumpreach = ms->lastreachnum;
+	} //end if
+	else
+	{
+		if (dist > 80) dist = 80;
+		speed = 400 - (400 - 5 * dist);
+		EA_Move(ms->client, hordir, speed);
+	} //end else
+	//look in the movement direction
+	Vector2Angles(hordir, result.ideal_viewangles);
+	//look straight down
+	result.ideal_viewangles[PITCH] = 90;
+	//set the view angles directly
+	EA_View(ms->client, result.ideal_viewangles);
+	//view is important for the movment
+	result.flags |= MOVERESULT_MOVEMENTVIEWSET;
+	//select the rocket launcher
+	EA_SelectWeapon(ms->client, (int) weapindex_bfg10k->value);
+	//weapon is used for movement
+	result.weapon = (int) weapindex_bfg10k->value;
+	result.flags |= MOVERESULT_MOVEMENTWEAPON;
+	//
+	VectorCopy(hordir, result.movedir);
+	//
+	return result;
+} //end of the function BotTravel_BFGJump
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+bot_moveresult_t BotFinishTravel_WeaponJump(bot_movestate_t *ms, aas_reachability_t *reach)
+{
+	vec3_t hordir;
+	float speed;
+	bot_moveresult_t result;
+
+	BotClearMoveResult(&result);
+	//if not jumped yet
+	if (!ms->jumpreach) return result;
+	/*
+	//go straight to the reachability end
+	hordir[0] = reach->end[0] - ms->origin[0];
+	hordir[1] = reach->end[1] - ms->origin[1];
+	hordir[2] = 0;
+	VectorNormalize(hordir);
+	//always use max speed when traveling through the air
+	EA_Move(ms->client, hordir, 800);
+	VectorCopy(hordir, result.movedir);
+	*/
+	//
+	if (!BotAirControl(ms->origin, ms->velocity, reach->end, hordir, &speed))
+	{
+		//go straight to the reachability end
+		VectorSubtract(reach->end, ms->origin, hordir);
+		hordir[2] = 0;
+		VectorNormalize(hordir);
+		speed = 400;
+	} //end if
+	//
+	EA_Move(ms->client, hordir, speed);
+	VectorCopy(hordir, result.movedir);
+	//
+	return result;
+} //end of the function BotFinishTravel_WeaponJump
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+bot_moveresult_t BotTravel_JumpPad(bot_movestate_t *ms, aas_reachability_t *reach)
+{
+	float dist, speed;
+	vec3_t hordir;
+	bot_moveresult_t result;
+
+	BotClearMoveResult(&result);
+	//first walk straight to the reachability start
+	hordir[0] = reach->start[0] - ms->origin[0];
+	hordir[1] = reach->start[1] - ms->origin[1];
+	hordir[2] = 0;
+	dist = VectorNormalize(hordir);
+	//
+	BotCheckBlocked(ms, hordir, qtrue, &result);
+	speed = 400;
+	//elemantary action move in direction
+	EA_Move(ms->client, hordir, speed);
+	VectorCopy(hordir, result.movedir);
+	//
+	return result;
+} //end of the function BotTravel_JumpPad
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+bot_moveresult_t BotFinishTravel_JumpPad(bot_movestate_t *ms, aas_reachability_t *reach)
+{
+	float speed;
+	vec3_t hordir;
+	bot_moveresult_t result;
+
+	BotClearMoveResult(&result);
+	if (!BotAirControl(ms->origin, ms->velocity, reach->end, hordir, &speed))
+	{
+		hordir[0] = reach->end[0] - ms->origin[0];
+		hordir[1] = reach->end[1] - ms->origin[1];
+		hordir[2] = 0;
+		VectorNormalize(hordir);
+		speed = 400;
+	} //end if
+	BotCheckBlocked(ms, hordir, qtrue, &result);
+	//elemantary action move in direction
+	EA_Move(ms->client, hordir, speed);
+	VectorCopy(hordir, result.movedir);
+	//
+	return result;
+} //end of the function BotFinishTravel_JumpPad
+//===========================================================================
+// time before the reachability times out
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int BotReachabilityTime(aas_reachability_t *reach)
+{
+	switch(reach->traveltype & TRAVELTYPE_MASK)
+	{
+		case TRAVEL_WALK: return 5;
+		case TRAVEL_CROUCH: return 5;
+		case TRAVEL_BARRIERJUMP: return 5;
+		case TRAVEL_LADDER: return 6;
+		case TRAVEL_WALKOFFLEDGE: return 5;
+		case TRAVEL_JUMP: return 5;
+		case TRAVEL_SWIM: return 5;
+		case TRAVEL_WATERJUMP: return 5;
+		case TRAVEL_TELEPORT: return 5;
+		case TRAVEL_ELEVATOR: return 10;
+		case TRAVEL_GRAPPLEHOOK: return 8;
+		case TRAVEL_ROCKETJUMP: return 6;
+		case TRAVEL_BFGJUMP: return 6;
+		case TRAVEL_JUMPPAD: return 10;
+		case TRAVEL_FUNCBOB: return 10;
+		default:
+		{
+			botimport.Print(PRT_ERROR, "travel type %d not implemented yet\n", reach->traveltype);
+			return 8;
+		} //end case
+	} //end switch
+} //end of the function BotReachabilityTime
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+bot_moveresult_t BotMoveInGoalArea(bot_movestate_t *ms, bot_goal_t *goal)
+{
+	bot_moveresult_t result;
+	vec3_t dir;
+	float dist, speed;
+
+#ifdef DEBUG
+	//botimport.Print(PRT_MESSAGE, "%s: moving straight to goal\n", ClientName(ms->entitynum-1));
+	//AAS_ClearShownDebugLines();
+	//AAS_DebugLine(ms->origin, goal->origin, LINECOLOR_RED);
+#endif //DEBUG
+	BotClearMoveResult(&result);
+	//walk straight to the goal origin
+	dir[0] = goal->origin[0] - ms->origin[0];
+	dir[1] = goal->origin[1] - ms->origin[1];
+	if (ms->moveflags & MFL_SWIMMING)
+	{
+		dir[2] = goal->origin[2] - ms->origin[2];
+		result.traveltype = TRAVEL_SWIM;
+	} //end if
+	else
+	{
+		dir[2] = 0;
+		result.traveltype = TRAVEL_WALK;
+	} //endif
+	//
+	dist = VectorNormalize(dir);
+	if (dist > 100) dist = 100;
+	speed = 400 - (400 - 4 * dist);
+	if (speed < 10) speed = 0;
+	//
+	BotCheckBlocked(ms, dir, qtrue, &result);
+	//elemantary action move in direction
+	EA_Move(ms->client, dir, speed);
+	VectorCopy(dir, result.movedir);
+	//
+	if (ms->moveflags & MFL_SWIMMING)
+	{
+		Vector2Angles(dir, result.ideal_viewangles);
+		result.flags |= MOVERESULT_SWIMVIEW;
+	} //end if
+	//if (!debugline) debugline = botimport.DebugLineCreate();
+	//botimport.DebugLineShow(debugline, ms->origin, goal->origin, LINECOLOR_BLUE);
+	//
+	ms->lastreachnum = 0;
+	ms->lastareanum = 0;
+	ms->lastgoalareanum = goal->areanum;
+	VectorCopy(ms->origin, ms->lastorigin);
+	//
+	return result;
+} //end of the function BotMoveInGoalArea
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void BotMoveToGoal(bot_moveresult_t *result, int movestate, bot_goal_t *goal, int travelflags)
+{
+	int reachnum, lastreachnum, foundjumppad, ent, resultflags;
+	aas_reachability_t reach, lastreach;
+	bot_movestate_t *ms;
+	//vec3_t mins, maxs, up = {0, 0, 1};
+	//bsp_trace_t trace;
+	//static int debugline;
+
+
+	BotClearMoveResult(result);
+	//
+	ms = BotMoveStateFromHandle(movestate);
+	if (!ms) return;
+	//reset the grapple before testing if the bot has a valid goal
+	//because the bot could loose all it's goals when stuck to a wall
+	BotResetGrapple(ms);
+	//
+	if (!goal)
+	{
+#ifdef DEBUG
+		botimport.Print(PRT_MESSAGE, "client %d: movetogoal -> no goal\n", ms->client);
+#endif //DEBUG
+		result->failure = qtrue;
+		return;
+	} //end if
+	//botimport.Print(PRT_MESSAGE, "numavoidreach = %d\n", ms->numavoidreach);
+	//remove some of the move flags
+	ms->moveflags &= ~(MFL_SWIMMING|MFL_AGAINSTLADDER);
+	//set some of the move flags
+	//NOTE: the MFL_ONGROUND flag is also set in the higher AI
+	if (AAS_OnGround(ms->origin, ms->presencetype, ms->entitynum)) ms->moveflags |= MFL_ONGROUND;
+	//
+	if (ms->moveflags & MFL_ONGROUND)
+	{
+		int modeltype, modelnum;
+
+		ent = BotOnTopOfEntity(ms);
+
+		if (ent != -1)
+		{
+			modelnum = AAS_EntityModelindex(ent);
+			if (modelnum >= 0 && modelnum < MAX_MODELS)
+			{
+				modeltype = modeltypes[modelnum];
+
+				if (modeltype == MODELTYPE_FUNC_PLAT)
+				{
+					AAS_ReachabilityFromNum(ms->lastreachnum, &reach);
+					//if the bot is Not using the elevator
+					if ((reach.traveltype & TRAVELTYPE_MASK) != TRAVEL_ELEVATOR ||
+						//NOTE: the face number is the plat model number
+						(reach.facenum & 0x0000FFFF) != modelnum)
+					{
+						reachnum = AAS_NextModelReachability(0, modelnum);
+						if (reachnum)
+						{
+							//botimport.Print(PRT_MESSAGE, "client %d: accidentally ended up on func_plat\n", ms->client);
+							AAS_ReachabilityFromNum(reachnum, &reach);
+							ms->lastreachnum = reachnum;
+							ms->reachability_time = AAS_Time() + BotReachabilityTime(&reach);
+						} //end if
+						else
+						{
+							if (bot_developer)
+							{
+								botimport.Print(PRT_MESSAGE, "client %d: on func_plat without reachability\n", ms->client);
+							} //end if
+							result->blocked = qtrue;
+							result->blockentity = ent;
+							result->flags |= MOVERESULT_ONTOPOFOBSTACLE;
+							return;
+						} //end else
+					} //end if
+					result->flags |= MOVERESULT_ONTOPOF_ELEVATOR;
+				} //end if
+				else if (modeltype == MODELTYPE_FUNC_BOB)
+				{
+					AAS_ReachabilityFromNum(ms->lastreachnum, &reach);
+					//if the bot is Not using the func bobbing
+					if ((reach.traveltype & TRAVELTYPE_MASK) != TRAVEL_FUNCBOB ||
+						//NOTE: the face number is the func_bobbing model number
+						(reach.facenum & 0x0000FFFF) != modelnum)
+					{
+						reachnum = AAS_NextModelReachability(0, modelnum);
+						if (reachnum)
+						{
+							//botimport.Print(PRT_MESSAGE, "client %d: accidentally ended up on func_bobbing\n", ms->client);
+							AAS_ReachabilityFromNum(reachnum, &reach);
+							ms->lastreachnum = reachnum;
+							ms->reachability_time = AAS_Time() + BotReachabilityTime(&reach);
+						} //end if
+						else
+						{
+							if (bot_developer)
+							{
+								botimport.Print(PRT_MESSAGE, "client %d: on func_bobbing without reachability\n", ms->client);
+							} //end if
+							result->blocked = qtrue;
+							result->blockentity = ent;
+							result->flags |= MOVERESULT_ONTOPOFOBSTACLE;
+							return;
+						} //end else
+					} //end if
+					result->flags |= MOVERESULT_ONTOPOF_FUNCBOB;
+				} //end if
+				else if (modeltype == MODELTYPE_FUNC_STATIC || modeltype == MODELTYPE_FUNC_DOOR)
+				{
+					// check if ontop of a door bridge ?
+					ms->areanum = BotFuzzyPointReachabilityArea(ms->origin);
+					// if not in a reachability area
+					if (!AAS_AreaReachability(ms->areanum))
+					{
+						result->blocked = qtrue;
+						result->blockentity = ent;
+						result->flags |= MOVERESULT_ONTOPOFOBSTACLE;
+						return;
+					} //end if
+				} //end else if
+				else
+				{
+					result->blocked = qtrue;
+					result->blockentity = ent;
+					result->flags |= MOVERESULT_ONTOPOFOBSTACLE;
+					return;
+				} //end else
+			} //end if
+		} //end if
+	} //end if
+	//if swimming
+	if (AAS_Swimming(ms->origin)) ms->moveflags |= MFL_SWIMMING;
+	//if against a ladder
+	if (AAS_AgainstLadder(ms->origin)) ms->moveflags |= MFL_AGAINSTLADDER;
+	//if the bot is on the ground, swimming or against a ladder
+	if (ms->moveflags & (MFL_ONGROUND|MFL_SWIMMING|MFL_AGAINSTLADDER))
+	{
+		//botimport.Print(PRT_MESSAGE, "%s: onground, swimming or against ladder\n", ClientName(ms->entitynum-1));
+		//
+		AAS_ReachabilityFromNum(ms->lastreachnum, &lastreach);
+		//reachability area the bot is in
+		//ms->areanum = BotReachabilityArea(ms->origin, ((lastreach.traveltype & TRAVELTYPE_MASK) != TRAVEL_ELEVATOR));
+		ms->areanum = BotFuzzyPointReachabilityArea(ms->origin);
+		//
+		if ( !ms->areanum )
+		{
+			result->failure = qtrue;
+			result->blocked = qtrue;
+			result->blockentity = 0;
+			result->type = RESULTTYPE_INSOLIDAREA;
+			return;
+		} //end if
+		//if the bot is in the goal area
+		if (ms->areanum == goal->areanum)
+		{
+			*result = BotMoveInGoalArea(ms, goal);
+			return;
+		} //end if
+		//assume we can use the reachability from the last frame
+		reachnum = ms->lastreachnum;
+		//if there is a last reachability
+		if (reachnum)
+		{
+			AAS_ReachabilityFromNum(reachnum, &reach);
+			//check if the reachability is still valid
+			if (!(AAS_TravelFlagForType(reach.traveltype) & travelflags))
+			{
+				reachnum = 0;
+			} //end if
+			//special grapple hook case
+			else if ((reach.traveltype & TRAVELTYPE_MASK) == TRAVEL_GRAPPLEHOOK)
+			{
+				if (ms->reachability_time < AAS_Time() ||
+					(ms->moveflags & MFL_GRAPPLERESET))
+				{
+					reachnum = 0;
+				} //end if
+			} //end if
+			//special elevator case
+			else if ((reach.traveltype & TRAVELTYPE_MASK) == TRAVEL_ELEVATOR ||
+				(reach.traveltype & TRAVELTYPE_MASK) == TRAVEL_FUNCBOB)
+			{
+				if ((result->flags & MOVERESULT_ONTOPOF_FUNCBOB) ||
+					(result->flags & MOVERESULT_ONTOPOF_FUNCBOB))
+				{
+					ms->reachability_time = AAS_Time() + 5;
+				} //end if
+				//if the bot was going for an elevator and reached the reachability area
+				if (ms->areanum == reach.areanum ||
+					ms->reachability_time < AAS_Time())
+				{
+					reachnum = 0;
+				} //end if
+			} //end if
+			else
+			{
+#ifdef DEBUG
+				if (bot_developer)
+				{
+					if (ms->reachability_time < AAS_Time())
+					{
+						botimport.Print(PRT_MESSAGE, "client %d: reachability timeout in ", ms->client);
+						AAS_PrintTravelType(reach.traveltype & TRAVELTYPE_MASK);
+						botimport.Print(PRT_MESSAGE, "\n");
+					} //end if
+					/*
+					if (ms->lastareanum != ms->areanum)
+					{
+						botimport.Print(PRT_MESSAGE, "changed from area %d to %d\n", ms->lastareanum, ms->areanum);
+					} //end if*/
+				} //end if
+#endif //DEBUG
+				//if the goal area changed or the reachability timed out
+				//or the area changed
+				if (ms->lastgoalareanum != goal->areanum ||
+						ms->reachability_time < AAS_Time() ||
+						ms->lastareanum != ms->areanum)
+				{
+					reachnum = 0;
+					//botimport.Print(PRT_MESSAGE, "area change or timeout\n");
+				} //end else if
+			} //end else
+		} //end if
+		resultflags = 0;
+		//if the bot needs a new reachability
+		if (!reachnum)
+		{
+			//if the area has no reachability links
+			if (!AAS_AreaReachability(ms->areanum))
+			{
+#ifdef DEBUG
+				if (bot_developer)
+				{
+					botimport.Print(PRT_MESSAGE, "area %d no reachability\n", ms->areanum);
+				} //end if
+#endif //DEBUG
+			} //end if
+			//get a new reachability leading towards the goal
+			reachnum = BotGetReachabilityToGoal(ms->origin, ms->areanum,
+								ms->lastgoalareanum, ms->lastareanum,
+											ms->avoidreach, ms->avoidreachtimes, ms->avoidreachtries,
+														goal, travelflags, travelflags,
+																ms->avoidspots, ms->numavoidspots, &resultflags);
+			//the area number the reachability starts in
+			ms->reachareanum = ms->areanum;
+			//reset some state variables
+			ms->jumpreach = 0;						//for TRAVEL_JUMP
+			ms->moveflags &= ~MFL_GRAPPLERESET;	//for TRAVEL_GRAPPLEHOOK
+			//if there is a reachability to the goal
+			if (reachnum)
+			{
+				AAS_ReachabilityFromNum(reachnum, &reach);
+				//set a timeout for this reachability
+				ms->reachability_time = AAS_Time() + BotReachabilityTime(&reach);
+				//
+#ifdef AVOIDREACH
+				//add the reachability to the reachabilities to avoid for a while
+				BotAddToAvoidReach(ms, reachnum, AVOIDREACH_TIME);
+#endif //AVOIDREACH
+			} //end if
+#ifdef DEBUG
+			
+			else if (bot_developer)
+			{
+				botimport.Print(PRT_MESSAGE, "goal not reachable\n");
+				Com_Memset(&reach, 0, sizeof(aas_reachability_t)); //make compiler happy
+			} //end else
+			if (bot_developer)
+			{
+				//if still going for the same goal
+				if (ms->lastgoalareanum == goal->areanum)
+				{
+					if (ms->lastareanum == reach.areanum)
+					{
+						botimport.Print(PRT_MESSAGE, "same goal, going back to previous area\n");
+					} //end if
+				} //end if
+			} //end if
+#endif //DEBUG
+		} //end else
+		//
+		ms->lastreachnum = reachnum;
+		ms->lastgoalareanum = goal->areanum;
+		ms->lastareanum = ms->areanum;
+		//if the bot has a reachability
+		if (reachnum)
+		{
+			//get the reachability from the number
+			AAS_ReachabilityFromNum(reachnum, &reach);
+			result->traveltype = reach.traveltype;
+			//
+#ifdef DEBUG_AI_MOVE
+			AAS_ClearShownDebugLines();
+			AAS_PrintTravelType(reach.traveltype & TRAVELTYPE_MASK);
+			AAS_ShowReachability(&reach);
+#endif //DEBUG_AI_MOVE
+			//
+#ifdef DEBUG
+			//botimport.Print(PRT_MESSAGE, "client %d: ", ms->client);
+			//AAS_PrintTravelType(reach.traveltype);
+			//botimport.Print(PRT_MESSAGE, "\n");
+#endif //DEBUG
+			switch(reach.traveltype & TRAVELTYPE_MASK)
+			{
+				case TRAVEL_WALK: *result = BotTravel_Walk(ms, &reach); break;
+				case TRAVEL_CROUCH: *result = BotTravel_Crouch(ms, &reach); break;
+				case TRAVEL_BARRIERJUMP: *result = BotTravel_BarrierJump(ms, &reach); break;
+				case TRAVEL_LADDER: *result = BotTravel_Ladder(ms, &reach); break;
+				case TRAVEL_WALKOFFLEDGE: *result = BotTravel_WalkOffLedge(ms, &reach); break;
+				case TRAVEL_JUMP: *result = BotTravel_Jump(ms, &reach); break;
+				case TRAVEL_SWIM: *result = BotTravel_Swim(ms, &reach); break;
+				case TRAVEL_WATERJUMP: *result = BotTravel_WaterJump(ms, &reach); break;
+				case TRAVEL_TELEPORT: *result = BotTravel_Teleport(ms, &reach); break;
+				case TRAVEL_ELEVATOR: *result = BotTravel_Elevator(ms, &reach); break;
+				case TRAVEL_GRAPPLEHOOK: *result = BotTravel_Grapple(ms, &reach); break;
+				case TRAVEL_ROCKETJUMP: *result = BotTravel_RocketJump(ms, &reach); break;
+				case TRAVEL_BFGJUMP: *result = BotTravel_BFGJump(ms, &reach); break;
+				case TRAVEL_JUMPPAD: *result = BotTravel_JumpPad(ms, &reach); break;
+				case TRAVEL_FUNCBOB: *result = BotTravel_FuncBobbing(ms, &reach); break;
+				default:
+				{
+					botimport.Print(PRT_FATAL, "travel type %d not implemented yet\n", (reach.traveltype & TRAVELTYPE_MASK));
+					break;
+				} //end case
+			} //end switch
+			result->traveltype = reach.traveltype;
+			result->flags |= resultflags;
+		} //end if
+		else
+		{
+			result->failure = qtrue;
+			result->flags |= resultflags;
+			Com_Memset(&reach, 0, sizeof(aas_reachability_t));
+		} //end else
+#ifdef DEBUG
+		if (bot_developer)
+		{
+			if (result->failure)
+			{
+				botimport.Print(PRT_MESSAGE, "client %d: movement failure in ", ms->client);
+				AAS_PrintTravelType(reach.traveltype & TRAVELTYPE_MASK);
+				botimport.Print(PRT_MESSAGE, "\n");
+			} //end if
+		} //end if
+#endif //DEBUG
+	} //end if
+	else
+	{
+		int i, numareas, areas[16];
+		vec3_t end;
+
+		//special handling of jump pads when the bot uses a jump pad without knowing it
+		foundjumppad = qfalse;
+		VectorMA(ms->origin, -2 * ms->thinktime, ms->velocity, end);
+		numareas = AAS_TraceAreas(ms->origin, end, areas, NULL, 16);
+		for (i = numareas-1; i >= 0; i--)
+		{
+			if (AAS_AreaJumpPad(areas[i]))
+			{
+				//botimport.Print(PRT_MESSAGE, "client %d used a jumppad without knowing, area %d\n", ms->client, areas[i]);
+				foundjumppad = qtrue;
+				lastreachnum = BotGetReachabilityToGoal(end, areas[i],
+							ms->lastgoalareanum, ms->lastareanum,
+							ms->avoidreach, ms->avoidreachtimes, ms->avoidreachtries,
+							goal, travelflags, TFL_JUMPPAD, ms->avoidspots, ms->numavoidspots, NULL);
+				if (lastreachnum)
+				{
+					ms->lastreachnum = lastreachnum;
+					ms->lastareanum = areas[i];
+					//botimport.Print(PRT_MESSAGE, "found jumppad reachability\n");
+					break;
+				} //end if
+				else
+				{
+					for (lastreachnum = AAS_NextAreaReachability(areas[i], 0); lastreachnum;
+						lastreachnum = AAS_NextAreaReachability(areas[i], lastreachnum))
+					{
+						//get the reachability from the number
+						AAS_ReachabilityFromNum(lastreachnum, &reach);
+						if ((reach.traveltype & TRAVELTYPE_MASK) == TRAVEL_JUMPPAD)
+						{
+							ms->lastreachnum = lastreachnum;
+							ms->lastareanum = areas[i];
+							//botimport.Print(PRT_MESSAGE, "found jumppad reachability hard!!\n");
+							break;
+						} //end if
+					} //end for
+					if (lastreachnum) break;
+				} //end else
+			} //end if
+		} //end for
+		if (bot_developer)
+		{
+			//if a jumppad is found with the trace but no reachability is found
+			if (foundjumppad && !ms->lastreachnum)
+			{
+				botimport.Print(PRT_MESSAGE, "client %d didn't find jumppad reachability\n", ms->client);
+			} //end if
+		} //end if
+		//
+		if (ms->lastreachnum)
+		{
+			//botimport.Print(PRT_MESSAGE, "%s: NOT onground, swimming or against ladder\n", ClientName(ms->entitynum-1));
+			AAS_ReachabilityFromNum(ms->lastreachnum, &reach);
+			result->traveltype = reach.traveltype;
+#ifdef DEBUG
+			//botimport.Print(PRT_MESSAGE, "client %d finish: ", ms->client);
+			//AAS_PrintTravelType(reach.traveltype & TRAVELTYPE_MASK);
+			//botimport.Print(PRT_MESSAGE, "\n");
+#endif //DEBUG
+			//
+			switch(reach.traveltype & TRAVELTYPE_MASK)
+			{
+				case TRAVEL_WALK: *result = BotTravel_Walk(ms, &reach); break;//BotFinishTravel_Walk(ms, &reach); break;
+				case TRAVEL_CROUCH: /*do nothing*/ break;
+				case TRAVEL_BARRIERJUMP: *result = BotFinishTravel_BarrierJump(ms, &reach); break;
+				case TRAVEL_LADDER: *result = BotTravel_Ladder(ms, &reach); break;
+				case TRAVEL_WALKOFFLEDGE: *result = BotFinishTravel_WalkOffLedge(ms, &reach); break;
+				case TRAVEL_JUMP: *result = BotFinishTravel_Jump(ms, &reach); break;
+				case TRAVEL_SWIM: *result = BotTravel_Swim(ms, &reach); break;
+				case TRAVEL_WATERJUMP: *result = BotFinishTravel_WaterJump(ms, &reach); break;
+				case TRAVEL_TELEPORT: /*do nothing*/ break;
+				case TRAVEL_ELEVATOR: *result = BotFinishTravel_Elevator(ms, &reach); break;
+				case TRAVEL_GRAPPLEHOOK: *result = BotTravel_Grapple(ms, &reach); break;
+				case TRAVEL_ROCKETJUMP:
+				case TRAVEL_BFGJUMP: *result = BotFinishTravel_WeaponJump(ms, &reach); break;
+				case TRAVEL_JUMPPAD: *result = BotFinishTravel_JumpPad(ms, &reach); break;
+				case TRAVEL_FUNCBOB: *result = BotFinishTravel_FuncBobbing(ms, &reach); break;
+				default:
+				{
+					botimport.Print(PRT_FATAL, "(last) travel type %d not implemented yet\n", (reach.traveltype & TRAVELTYPE_MASK));
+					break;
+				} //end case
+			} //end switch
+			result->traveltype = reach.traveltype;
+#ifdef DEBUG
+			if (bot_developer)
+			{
+				if (result->failure)
+				{
+					botimport.Print(PRT_MESSAGE, "client %d: movement failure in finish ", ms->client);
+					AAS_PrintTravelType(reach.traveltype & TRAVELTYPE_MASK);
+					botimport.Print(PRT_MESSAGE, "\n");
+				} //end if
+			} //end if
+#endif //DEBUG
+		} //end if
+	} //end else
+	//FIXME: is it right to do this here?
+	if (result->blocked) ms->reachability_time -= 10 * ms->thinktime;
+	//copy the last origin
+	VectorCopy(ms->origin, ms->lastorigin);
+	//return the movement result
+	return;
+} //end of the function BotMoveToGoal
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void BotResetAvoidReach(int movestate)
+{
+	bot_movestate_t *ms;
+
+	ms = BotMoveStateFromHandle(movestate);
+	if (!ms) return;
+	Com_Memset(ms->avoidreach, 0, MAX_AVOIDREACH * sizeof(int));
+	Com_Memset(ms->avoidreachtimes, 0, MAX_AVOIDREACH * sizeof(float));
+	Com_Memset(ms->avoidreachtries, 0, MAX_AVOIDREACH * sizeof(int));
+} //end of the function BotResetAvoidReach
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void BotResetLastAvoidReach(int movestate)
+{
+	int i, latest;
+	float latesttime;
+	bot_movestate_t *ms;
+
+	ms = BotMoveStateFromHandle(movestate);
+	if (!ms) return;
+	latesttime = 0;
+	latest = 0;
+	for (i = 0; i < MAX_AVOIDREACH; i++)
+	{
+		if (ms->avoidreachtimes[i] > latesttime)
+		{
+			latesttime = ms->avoidreachtimes[i];
+			latest = i;
+		} //end if
+	} //end for
+	if (latesttime)
+	{
+		ms->avoidreachtimes[latest] = 0;
+		if (ms->avoidreachtries[i] > 0) ms->avoidreachtries[latest]--;
+	} //end if
+} //end of the function BotResetLastAvoidReach
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+void BotResetMoveState(int movestate)
+{
+	bot_movestate_t *ms;
+
+	ms = BotMoveStateFromHandle(movestate);
+	if (!ms) return;
+	Com_Memset(ms, 0, sizeof(bot_movestate_t));
+} //end of the function BotResetMoveState
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+int BotSetupMoveAI(void)
+{
+	BotSetBrushModelTypes();
+	sv_maxstep = LibVar("sv_step", "18");
+	sv_maxbarrier = LibVar("sv_maxbarrier", "32");
+	sv_gravity = LibVar("sv_gravity", "800");
+	weapindex_rocketlauncher = LibVar("weapindex_rocketlauncher", "5");
+	weapindex_bfg10k = LibVar("weapindex_bfg10k", "9");
+	weapindex_grapple = LibVar("weapindex_grapple", "10");
+	entitytypemissile = LibVar("entitytypemissile", "3");
+	offhandgrapple = LibVar("offhandgrapple", "0");
+	cmd_grappleon = LibVar("cmd_grappleon", "grappleon");
+	cmd_grappleoff = LibVar("cmd_grappleoff", "grappleoff");
+	return BLERR_NOERROR;
+} //end of the function BotSetupMoveAI
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+void BotShutdownMoveAI(void)
+{
+	int i;
+
+	for (i = 1; i <= MAX_CLIENTS; i++)
+	{
+		if (botmovestates[i])
+		{
+			FreeMemory(botmovestates[i]);
+			botmovestates[i] = NULL;
+		} //end if
+	} //end for
+} //end of the function BotShutdownMoveAI
+
+
diff --git a/codemp/botlib/be_ai_weap.cpp b/codemp/botlib/be_ai_weap.cpp
new file mode 100644
index 0000000..b8da40a
--- /dev/null
+++ b/codemp/botlib/be_ai_weap.cpp
@@ -0,0 +1,526 @@
+
+/*****************************************************************************
+ * name:		be_ai_weap.c
+ *
+ * desc:		weapon AI
+ *
+ * $Archive: /MissionPack/code/botlib/be_ai_weap.c $
+ * $Author: Ttimo $ 
+ * $Revision: 6 $
+ * $Modtime: 4/13/01 4:45p $
+ * $Date: 4/13/01 4:45p $
+ *
+ *****************************************************************************/
+
+#include "../game/q_shared.h"
+#include "l_libvar.h"
+#include "l_log.h"
+#include "l_memory.h"
+#include "l_utils.h"
+#include "l_script.h"
+#include "l_precomp.h"
+#include "l_struct.h"
+#include "aasfile.h"
+#include "../game/botlib.h"
+#include "../game/be_aas.h"
+#include "be_aas_funcs.h"
+#include "be_interface.h"
+#include "be_ai_weight.h"		//fuzzy weights
+#include "../game/be_ai_weap.h"
+
+//#define DEBUG_AI_WEAP
+
+//structure field offsets
+#define WEAPON_OFS(x) (int)&(((weaponinfo_t *)0)->x)
+#define PROJECTILE_OFS(x) (int)&(((projectileinfo_t *)0)->x)
+
+//weapon definition // bk001212 - static
+static fielddef_t weaponinfo_fields[] =
+{
+{"number", WEAPON_OFS(number), FT_INT},						//weapon number
+{"name", WEAPON_OFS(name), FT_STRING},							//name of the weapon
+{"level", WEAPON_OFS(level), FT_INT},
+{"model", WEAPON_OFS(model), FT_STRING},						//model of the weapon
+{"weaponindex", WEAPON_OFS(weaponindex), FT_INT},			//index of weapon in inventory
+{"flags", WEAPON_OFS(flags), FT_INT},							//special flags
+{"projectile", WEAPON_OFS(projectile), FT_STRING},			//projectile used by the weapon
+{"numprojectiles", WEAPON_OFS(numprojectiles), FT_INT},	//number of projectiles
+{"hspread", WEAPON_OFS(hspread), FT_FLOAT},					//horizontal spread of projectiles (degrees from middle)
+{"vspread", WEAPON_OFS(vspread), FT_FLOAT},					//vertical spread of projectiles (degrees from middle)
+{"speed", WEAPON_OFS(speed), FT_FLOAT},						//speed of the projectile (0 = instant hit)
+{"acceleration", WEAPON_OFS(acceleration), FT_FLOAT},		//"acceleration" * time (in seconds) + "speed" = projectile speed
+{"recoil", WEAPON_OFS(recoil), FT_FLOAT|FT_ARRAY, 3},		//amount of recoil the player gets from the weapon
+{"offset", WEAPON_OFS(offset), FT_FLOAT|FT_ARRAY, 3},		//projectile start offset relative to eye and view angles
+{"angleoffset", WEAPON_OFS(angleoffset), FT_FLOAT|FT_ARRAY, 3},//offset of the shoot angles relative to the view angles
+{"extrazvelocity", WEAPON_OFS(extrazvelocity), FT_FLOAT},//extra z velocity the projectile gets
+{"ammoamount", WEAPON_OFS(ammoamount), FT_INT},				//ammo amount used per shot
+{"ammoindex", WEAPON_OFS(ammoindex), FT_INT},				//index of ammo in inventory
+{"activate", WEAPON_OFS(activate), FT_FLOAT},				//time it takes to select the weapon
+{"reload", WEAPON_OFS(reload), FT_FLOAT},						//time it takes to reload the weapon
+{"spinup", WEAPON_OFS(spinup), FT_FLOAT},						//time it takes before first shot
+{"spindown", WEAPON_OFS(spindown), FT_FLOAT},				//time it takes before weapon stops firing
+{NULL, 0, 0, 0}
+};
+
+//projectile definition
+static fielddef_t projectileinfo_fields[] =
+{
+{"name", PROJECTILE_OFS(name), FT_STRING},					//name of the projectile
+{"model", WEAPON_OFS(model), FT_STRING},						//model of the projectile
+{"flags", PROJECTILE_OFS(flags), FT_INT},						//special flags
+{"gravity", PROJECTILE_OFS(gravity), FT_FLOAT},				//amount of gravity applied to the projectile [0,1]
+{"damage", PROJECTILE_OFS(damage), FT_INT},					//damage of the projectile
+{"radius", PROJECTILE_OFS(radius), FT_FLOAT},				//radius of damage
+{"visdamage", PROJECTILE_OFS(visdamage), FT_INT},			//damage of the projectile to visible entities
+{"damagetype", PROJECTILE_OFS(damagetype), FT_INT},		//type of damage (combination of the DAMAGETYPE_? flags)
+{"healthinc", PROJECTILE_OFS(healthinc), FT_INT},			//health increase the owner gets
+{"push", PROJECTILE_OFS(push), FT_FLOAT},						//amount a player is pushed away from the projectile impact
+{"detonation", PROJECTILE_OFS(detonation), FT_FLOAT},		//time before projectile explodes after fire pressed
+{"bounce", PROJECTILE_OFS(bounce), FT_FLOAT},				//amount the projectile bounces
+{"bouncefric", PROJECTILE_OFS(bouncefric), FT_FLOAT}, 	//amount the bounce decreases per bounce
+{"bouncestop", PROJECTILE_OFS(bouncestop), FT_FLOAT},		//minimum bounce value before bouncing stops
+//recurive projectile definition??
+{NULL, 0, 0, 0}
+};
+
+static structdef_t weaponinfo_struct =
+{
+	sizeof(weaponinfo_t), weaponinfo_fields
+};
+static structdef_t projectileinfo_struct =
+{
+	sizeof(projectileinfo_t), projectileinfo_fields
+};
+
+//weapon configuration: set of weapons with projectiles
+typedef struct weaponconfig_s
+{
+	int numweapons;
+	int numprojectiles;
+	projectileinfo_t *projectileinfo;
+	weaponinfo_t *weaponinfo;
+} weaponconfig_t;
+
+//the bot weapon state
+typedef struct bot_weaponstate_s
+{
+	struct weightconfig_s *weaponweightconfig;		//weapon weight configuration
+	int *weaponweightindex;							//weapon weight index
+} bot_weaponstate_t;
+
+static bot_weaponstate_t *botweaponstates[MAX_CLIENTS+1];
+static weaponconfig_t *weaponconfig;
+
+//========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//========================================================================
+int BotValidWeaponNumber(int weaponnum)
+{
+	if (weaponnum <= 0 || weaponnum > weaponconfig->numweapons)
+	{
+		botimport.Print(PRT_ERROR, "weapon number out of range\n");
+		return qfalse;
+	} //end if
+	return qtrue;
+} //end of the function BotValidWeaponNumber
+//========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//========================================================================
+bot_weaponstate_t *BotWeaponStateFromHandle(int handle)
+{
+	if (handle <= 0 || handle > MAX_CLIENTS)
+	{
+		botimport.Print(PRT_FATAL, "move state handle %d out of range\n", handle);
+		return NULL;
+	} //end if
+	if (!botweaponstates[handle])
+	{
+		botimport.Print(PRT_FATAL, "invalid move state %d\n", handle);
+		return NULL;
+	} //end if
+	return botweaponstates[handle];
+} //end of the function BotWeaponStateFromHandle
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+#ifdef DEBUG_AI_WEAP
+void DumpWeaponConfig(weaponconfig_t *wc)
+{
+	FILE *fp;
+	int i;
+
+	fp = Log_FileStruct();
+	if (!fp) return;
+	for (i = 0; i < wc->numprojectiles; i++)
+	{
+		WriteStructure(fp, &projectileinfo_struct, (char *) &wc->projectileinfo[i]);
+		Log_Flush();
+	} //end for
+	for (i = 0; i < wc->numweapons; i++)
+	{
+		WriteStructure(fp, &weaponinfo_struct, (char *) &wc->weaponinfo[i]);
+		Log_Flush();
+	} //end for
+} //end of the function DumpWeaponConfig
+#endif //DEBUG_AI_WEAP
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+weaponconfig_t *LoadWeaponConfig(char *filename)
+{
+	int max_weaponinfo, max_projectileinfo;
+	token_t token;
+	char path[MAX_PATH];
+	int i, j;
+	source_t *source;
+	weaponconfig_t *wc;
+	weaponinfo_t weaponinfo;
+
+	max_weaponinfo = (int) LibVarValue("max_weaponinfo", "32");
+	if (max_weaponinfo < 0)
+	{
+		botimport.Print(PRT_ERROR, "max_weaponinfo = %d\n", max_weaponinfo);
+		max_weaponinfo = 32;
+		LibVarSet("max_weaponinfo", "32");
+	} //end if
+	max_projectileinfo = (int) LibVarValue("max_projectileinfo", "32");
+	if (max_projectileinfo < 0)
+	{
+		botimport.Print(PRT_ERROR, "max_projectileinfo = %d\n", max_projectileinfo);
+		max_projectileinfo = 32;
+		LibVarSet("max_projectileinfo", "32");
+	} //end if
+	strncpy(path, filename, MAX_PATH);
+	PC_SetBaseFolder(BOTFILESBASEFOLDER);
+	source = LoadSourceFile(path);
+	if (!source)
+	{
+		botimport.Print(PRT_ERROR, "counldn't load %s\n", path);
+		return NULL;
+	} //end if
+	//initialize weapon config
+	wc = (weaponconfig_t *) GetClearedHunkMemory(sizeof(weaponconfig_t) +
+										max_weaponinfo * sizeof(weaponinfo_t) +
+										max_projectileinfo * sizeof(projectileinfo_t));
+	wc->weaponinfo = (weaponinfo_t *) ((char *) wc + sizeof(weaponconfig_t));
+	wc->projectileinfo = (projectileinfo_t *) ((char *) wc->weaponinfo +
+										max_weaponinfo * sizeof(weaponinfo_t));
+	wc->numweapons = max_weaponinfo;
+	wc->numprojectiles = 0;
+	//parse the source file
+	while(PC_ReadToken(source, &token))
+	{
+		if (!strcmp(token.string, "weaponinfo"))
+		{
+			Com_Memset(&weaponinfo, 0, sizeof(weaponinfo_t));
+			if (!ReadStructure(source, &weaponinfo_struct, (char *) &weaponinfo))
+			{
+				FreeMemory(wc);
+				FreeSource(source);
+				return NULL;
+			} //end if
+			if (weaponinfo.number < 0 || weaponinfo.number >= max_weaponinfo)
+			{
+				botimport.Print(PRT_ERROR, "weapon info number %d out of range in %s\n", weaponinfo.number, path);
+				FreeMemory(wc);
+				FreeSource(source);
+				return NULL;
+			} //end if
+			Com_Memcpy(&wc->weaponinfo[weaponinfo.number], &weaponinfo, sizeof(weaponinfo_t));
+			wc->weaponinfo[weaponinfo.number].valid = qtrue;
+		} //end if
+		else if (!strcmp(token.string, "projectileinfo"))
+		{
+			if (wc->numprojectiles >= max_projectileinfo)
+			{
+				botimport.Print(PRT_ERROR, "more than %d projectiles defined in %s\n", max_projectileinfo, path);
+				FreeMemory(wc);
+				FreeSource(source);
+				return NULL;
+			} //end if
+			Com_Memset(&wc->projectileinfo[wc->numprojectiles], 0, sizeof(projectileinfo_t));
+			if (!ReadStructure(source, &projectileinfo_struct, (char *) &wc->projectileinfo[wc->numprojectiles]))
+			{
+				FreeMemory(wc);
+				FreeSource(source);
+				return NULL;
+			} //end if
+			wc->numprojectiles++;
+		} //end if
+		else
+		{
+			botimport.Print(PRT_ERROR, "unknown definition %s in %s\n", token.string, path);
+			FreeMemory(wc);
+			FreeSource(source);
+			return NULL;
+		} //end else
+	} //end while
+	FreeSource(source);
+	//fix up weapons
+	for (i = 0; i < wc->numweapons; i++)
+	{
+		if (!wc->weaponinfo[i].valid) continue;
+		if (!wc->weaponinfo[i].name[0])
+		{
+			botimport.Print(PRT_ERROR, "weapon %d has no name in %s\n", i, path);
+			FreeMemory(wc);
+			return NULL;
+		} //end if
+		if (!wc->weaponinfo[i].projectile[0])
+		{
+			botimport.Print(PRT_ERROR, "weapon %s has no projectile in %s\n", wc->weaponinfo[i].name, path);
+			FreeMemory(wc);
+			return NULL;
+		} //end if
+		//find the projectile info and copy it to the weapon info
+		for (j = 0; j < wc->numprojectiles; j++)
+		{
+			if (!strcmp(wc->projectileinfo[j].name, wc->weaponinfo[i].projectile))
+			{
+				Com_Memcpy(&wc->weaponinfo[i].proj, &wc->projectileinfo[j], sizeof(projectileinfo_t));
+				break;
+			} //end if
+		} //end for
+		if (j == wc->numprojectiles)
+		{
+			botimport.Print(PRT_ERROR, "weapon %s uses undefined projectile in %s\n", wc->weaponinfo[i].name, path);
+			FreeMemory(wc);
+			return NULL;
+		} //end if
+	} //end for
+	if (!wc->numweapons) botimport.Print(PRT_WARNING, "no weapon info loaded\n");
+	botimport.Print(PRT_MESSAGE, "loaded %s\n", path);
+	return wc;
+} //end of the function LoadWeaponConfig
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int *WeaponWeightIndex(weightconfig_t *wwc, weaponconfig_t *wc)
+{
+	int *index, i;
+
+	//initialize item weight index
+	index = (int *) GetClearedMemory(sizeof(int) * wc->numweapons);
+
+	for (i = 0; i < wc->numweapons; i++)
+	{
+		index[i] = FindFuzzyWeight(wwc, wc->weaponinfo[i].name);
+	} //end for
+	return index;
+} //end of the function WeaponWeightIndex
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void BotFreeWeaponWeights(int weaponstate)
+{
+	bot_weaponstate_t *ws;
+
+	ws = BotWeaponStateFromHandle(weaponstate);
+	if (!ws) return;
+	if (ws->weaponweightconfig) FreeWeightConfig(ws->weaponweightconfig);
+	if (ws->weaponweightindex) FreeMemory(ws->weaponweightindex);
+} //end of the function BotFreeWeaponWeights
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int BotLoadWeaponWeights(int weaponstate, char *filename)
+{
+	bot_weaponstate_t *ws;
+
+	ws = BotWeaponStateFromHandle(weaponstate);
+	if (!ws) return BLERR_CANNOTLOADWEAPONWEIGHTS;
+	BotFreeWeaponWeights(weaponstate);
+	//
+	ws->weaponweightconfig = ReadWeightConfig(filename);
+	if (!ws->weaponweightconfig)
+	{
+		botimport.Print(PRT_FATAL, "couldn't load weapon config %s\n", filename);
+		return BLERR_CANNOTLOADWEAPONWEIGHTS;
+	} //end if
+	if (!weaponconfig) return BLERR_CANNOTLOADWEAPONCONFIG;
+	ws->weaponweightindex = WeaponWeightIndex(ws->weaponweightconfig, weaponconfig);
+	return BLERR_NOERROR;
+} //end of the function BotLoadWeaponWeights
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void BotGetWeaponInfo(int weaponstate, int weapon, weaponinfo_t *weaponinfo)
+{
+	bot_weaponstate_t *ws;
+
+	if (!BotValidWeaponNumber(weapon)) return;
+	ws = BotWeaponStateFromHandle(weaponstate);
+	if (!ws) return;
+	if (!weaponconfig) return;
+	Com_Memcpy(weaponinfo, &weaponconfig->weaponinfo[weapon], sizeof(weaponinfo_t));
+} //end of the function BotGetWeaponInfo
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int BotChooseBestFightWeapon(int weaponstate, int *inventory)
+{
+	int i, index, bestweapon;
+	float weight, bestweight;
+	weaponconfig_t *wc;
+	bot_weaponstate_t *ws;
+
+	ws = BotWeaponStateFromHandle(weaponstate);
+	if (!ws) return 0;
+	wc = weaponconfig;
+	if (!weaponconfig) return 0;
+
+	//if the bot has no weapon weight configuration
+	if (!ws->weaponweightconfig) return 0;
+
+	bestweight = 0;
+	bestweapon = 0;
+	for (i = 0; i < wc->numweapons; i++)
+	{
+		if (!wc->weaponinfo[i].valid) continue;
+		index = ws->weaponweightindex[i];
+		if (index < 0) continue;
+		weight = FuzzyWeight(inventory, ws->weaponweightconfig, index);
+		if (weight > bestweight)
+		{
+			bestweight = weight;
+			bestweapon = i;
+		} //end if
+	} //end for
+	return bestweapon;
+} //end of the function BotChooseBestFightWeapon
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void BotResetWeaponState(int weaponstate)
+{
+	struct weightconfig_s *weaponweightconfig;
+	int *weaponweightindex;
+	bot_weaponstate_t *ws;
+
+	ws = BotWeaponStateFromHandle(weaponstate);
+	if (!ws) return;
+	weaponweightconfig = ws->weaponweightconfig;
+	weaponweightindex = ws->weaponweightindex;
+
+	//Com_Memset(ws, 0, sizeof(bot_weaponstate_t));
+	ws->weaponweightconfig = weaponweightconfig;
+	ws->weaponweightindex = weaponweightindex;
+} //end of the function BotResetWeaponState
+//========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//========================================================================
+int BotAllocWeaponState(void)
+{
+	int i;
+
+	for (i = 1; i <= MAX_CLIENTS; i++)
+	{
+		if (!botweaponstates[i])
+		{
+			botweaponstates[i] = (struct bot_weaponstate_s *)GetClearedMemory(sizeof(bot_weaponstate_t));
+			return i;
+		} //end if
+	} //end for
+	return 0;
+} //end of the function BotAllocWeaponState
+//========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//========================================================================
+void BotFreeWeaponState(int handle)
+{
+	if (handle <= 0 || handle > MAX_CLIENTS)
+	{
+		botimport.Print(PRT_FATAL, "move state handle %d out of range\n", handle);
+		return;
+	} //end if
+	if (!botweaponstates[handle])
+	{
+		botimport.Print(PRT_FATAL, "invalid move state %d\n", handle);
+		return;
+	} //end if
+	BotFreeWeaponWeights(handle);
+	FreeMemory(botweaponstates[handle]);
+	botweaponstates[handle] = NULL;
+} //end of the function BotFreeWeaponState
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int BotSetupWeaponAI(void)
+{
+	char *file;
+
+	file = LibVarString("weaponconfig", "weapons.c");
+	weaponconfig = LoadWeaponConfig(file);
+	if (!weaponconfig)
+	{
+		botimport.Print(PRT_FATAL, "couldn't load the weapon config\n");
+		return BLERR_CANNOTLOADWEAPONCONFIG;
+	} //end if
+
+#ifdef DEBUG_AI_WEAP
+	DumpWeaponConfig(weaponconfig);
+#endif //DEBUG_AI_WEAP
+	//
+	return BLERR_NOERROR;
+} //end of the function BotSetupWeaponAI
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void BotShutdownWeaponAI(void)
+{
+	int i;
+
+	if (weaponconfig) FreeMemory(weaponconfig);
+	weaponconfig = NULL;
+
+	for (i = 1; i <= MAX_CLIENTS; i++)
+	{
+		if (botweaponstates[i])
+		{
+			BotFreeWeaponState(i);
+		} //end if
+	} //end for
+} //end of the function BotShutdownWeaponAI
+
diff --git a/codemp/botlib/be_ai_weight.cpp b/codemp/botlib/be_ai_weight.cpp
new file mode 100644
index 0000000..d1c1c48
--- /dev/null
+++ b/codemp/botlib/be_ai_weight.cpp
@@ -0,0 +1,895 @@
+
+/*****************************************************************************
+ * name:		be_ai_weight.c
+ *
+ * desc:		fuzzy logic
+ *
+ * $Archive: /MissionPack/code/botlib/be_ai_weight.c $
+ * $Author: Mrelusive $ 
+ * $Revision: 3 $
+ * $Modtime: 8/06/00 5:25p $
+ * $Date: 8/06/00 11:07p $
+ *
+ *****************************************************************************/
+
+#include "../game/q_shared.h"
+#include "l_memory.h"
+#include "l_log.h"
+#include "l_utils.h"
+#include "l_script.h"
+#include "l_precomp.h"
+#include "l_struct.h"
+#include "l_libvar.h"
+#include "aasfile.h"
+#include "../game/botlib.h"
+#include "../game/be_aas.h"
+#include "be_aas_funcs.h"
+#include "be_interface.h"
+#include "be_ai_weight.h"
+
+#define MAX_INVENTORYVALUE			999999
+#define EVALUATERECURSIVELY
+
+#define MAX_WEIGHT_FILES			128
+weightconfig_t	*weightFileList[MAX_WEIGHT_FILES];
+
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int ReadValue(source_t *source, float *value)
+{
+	token_t token;
+
+	if (!PC_ExpectAnyToken(source, &token)) return qfalse;
+	if (!strcmp(token.string, "-"))
+	{
+		SourceWarning(source, "negative value set to zero\n");
+		if (!PC_ExpectTokenType(source, TT_NUMBER, 0, &token)) return qfalse;
+	} //end if
+	if (token.type != TT_NUMBER)
+	{
+		SourceError(source, "invalid return value %s\n", token.string);
+		return qfalse;
+	} //end if
+	*value = token.floatvalue;
+	return qtrue;
+} //end of the function ReadValue
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int ReadFuzzyWeight(source_t *source, fuzzyseperator_t *fs)
+{
+	if (PC_CheckTokenString(source, "balance"))
+	{
+		fs->type = WT_BALANCE;
+		if (!PC_ExpectTokenString(source, "(")) return qfalse;
+		if (!ReadValue(source, &fs->weight)) return qfalse;
+		if (!PC_ExpectTokenString(source, ",")) return qfalse;
+		if (!ReadValue(source, &fs->minweight)) return qfalse;
+		if (!PC_ExpectTokenString(source, ",")) return qfalse;
+		if (!ReadValue(source, &fs->maxweight)) return qfalse;
+		if (!PC_ExpectTokenString(source, ")")) return qfalse;
+	} //end if
+	else
+	{
+		fs->type = 0;
+		if (!ReadValue(source, &fs->weight)) return qfalse;
+		fs->minweight = fs->weight;
+		fs->maxweight = fs->weight;
+	} //end if
+	if (!PC_ExpectTokenString(source, ";")) return qfalse;
+	return qtrue;
+} //end of the function ReadFuzzyWeight
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void FreeFuzzySeperators_r(fuzzyseperator_t *fs)
+{
+	if (!fs) return;
+	if (fs->child) FreeFuzzySeperators_r(fs->child);
+	if (fs->next) FreeFuzzySeperators_r(fs->next);
+	FreeMemory(fs);
+} //end of the function FreeFuzzySeperators
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+void FreeWeightConfig2(weightconfig_t *config)
+{
+	int i;
+
+	for (i = 0; i < config->numweights; i++)
+	{
+		FreeFuzzySeperators_r(config->weights[i].firstseperator);
+		if (config->weights[i].name) FreeMemory(config->weights[i].name);
+	} //end for
+	FreeMemory(config);
+} //end of the function FreeWeightConfig2
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+void FreeWeightConfig(weightconfig_t *config)
+{
+	if (!LibVarGetValue("bot_reloadcharacters")) return;
+	FreeWeightConfig2(config);
+} //end of the function FreeWeightConfig
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+fuzzyseperator_t *ReadFuzzySeperators_r(source_t *source)
+{
+	int newindent, index, def, founddefault;
+	token_t token;
+	fuzzyseperator_t *fs, *lastfs, *firstfs;
+
+	founddefault = qfalse;
+	firstfs = NULL;
+	lastfs = NULL;
+	if (!PC_ExpectTokenString(source, "(")) return NULL;
+	if (!PC_ExpectTokenType(source, TT_NUMBER, TT_INTEGER, &token)) return NULL;
+	index = token.intvalue;
+	if (!PC_ExpectTokenString(source, ")")) return NULL;
+	if (!PC_ExpectTokenString(source, "{")) return NULL;
+	if (!PC_ExpectAnyToken(source, &token)) return NULL;
+	do
+	{
+		def = !strcmp(token.string, "default");
+		if (def || !strcmp(token.string, "case"))
+		{
+			fs = (fuzzyseperator_t *) GetClearedMemory(sizeof(fuzzyseperator_t));
+			fs->index = index;
+			if (lastfs) lastfs->next = fs;
+			else firstfs = fs;
+			lastfs = fs;
+			if (def)
+			{
+				if (founddefault)
+				{
+					SourceError(source, "switch already has a default\n");
+					FreeFuzzySeperators_r(firstfs);
+					return NULL;
+				} //end if
+				fs->value = MAX_INVENTORYVALUE;
+				founddefault = qtrue;
+			} //end if
+			else
+			{
+				if (!PC_ExpectTokenType(source, TT_NUMBER, TT_INTEGER, &token))
+				{
+					FreeFuzzySeperators_r(firstfs);
+					return NULL;
+				} //end if
+				fs->value = token.intvalue;
+			} //end else
+			if (!PC_ExpectTokenString(source, ":") || !PC_ExpectAnyToken(source, &token))
+			{
+				FreeFuzzySeperators_r(firstfs);
+				return NULL;
+			} //end if
+			newindent = qfalse;
+			if (!strcmp(token.string, "{"))
+			{
+				newindent = qtrue;
+				if (!PC_ExpectAnyToken(source, &token))
+				{
+					FreeFuzzySeperators_r(firstfs);
+					return NULL;
+				} //end if
+			} //end if
+			if (!strcmp(token.string, "return"))
+			{
+				if (!ReadFuzzyWeight(source, fs))
+				{
+					FreeFuzzySeperators_r(firstfs);
+					return NULL;
+				} //end if
+			} //end if
+			else if (!strcmp(token.string, "switch"))
+			{
+				fs->child = ReadFuzzySeperators_r(source);
+				if (!fs->child)
+				{
+					FreeFuzzySeperators_r(firstfs);
+					return NULL;
+				} //end if
+			} //end else if
+			else
+			{
+				SourceError(source, "invalid name %s\n", token.string);
+				return NULL;
+			} //end else
+			if (newindent)
+			{
+				if (!PC_ExpectTokenString(source, "}"))
+				{
+					FreeFuzzySeperators_r(firstfs);
+					return NULL;
+				} //end if
+			} //end if
+		} //end if
+		else
+		{
+			FreeFuzzySeperators_r(firstfs);
+			SourceError(source, "invalid name %s\n", token.string);
+			return NULL;
+		} //end else
+		if (!PC_ExpectAnyToken(source, &token))
+		{
+			FreeFuzzySeperators_r(firstfs);
+			return NULL;
+		} //end if
+	} while(strcmp(token.string, "}"));
+	//
+	if (!founddefault)
+	{
+		SourceWarning(source, "switch without default\n");
+		fs = (fuzzyseperator_t *) GetClearedMemory(sizeof(fuzzyseperator_t));
+		fs->index = index;
+		fs->value = MAX_INVENTORYVALUE;
+		fs->weight = 0;
+		fs->next = NULL;
+		fs->child = NULL;
+		if (lastfs) lastfs->next = fs;
+		else firstfs = fs;
+		lastfs = fs;
+	} //end if
+	//
+	return firstfs;
+} //end of the function ReadFuzzySeperators_r
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+weightconfig_t *ReadWeightConfig(char *filename)
+{
+	int newindent, avail = 0, n;
+	token_t token;
+	source_t *source;
+	fuzzyseperator_t *fs;
+	weightconfig_t *config = NULL;
+#ifdef DEBUG
+	int starttime;
+
+	starttime = Sys_MilliSeconds();
+#endif //DEBUG
+
+	if (!LibVarGetValue("bot_reloadcharacters"))
+	{
+		avail = -1;
+		for( n = 0; n < MAX_WEIGHT_FILES; n++ )
+		{
+			config = weightFileList[n];
+			if( !config )
+			{
+				if( avail == -1 )
+				{
+					avail = n;
+				} //end if
+				continue;
+			} //end if
+			if( strcmp( filename, config->filename ) == 0 )
+			{
+				//botimport.Print( PRT_MESSAGE, "retained %s\n", filename );
+				return config;
+			} //end if
+		} //end for
+
+		if( avail == -1 )
+		{
+			botimport.Print( PRT_ERROR, "weightFileList was full trying to load %s\n", filename );
+			return NULL;
+		} //end if
+	} //end if
+
+	PC_SetBaseFolder(BOTFILESBASEFOLDER);
+	source = LoadSourceFile(filename);
+	if (!source)
+	{
+		botimport.Print(PRT_ERROR, "counldn't load %s\n", filename);
+		return NULL;
+	} //end if
+	//
+	config = (weightconfig_t *) GetClearedMemory(sizeof(weightconfig_t));
+	config->numweights = 0;
+	Q_strncpyz( config->filename, filename, sizeof(config->filename) );
+	//parse the item config file
+	while(PC_ReadToken(source, &token))
+	{
+		if (!strcmp(token.string, "weight"))
+		{
+			if (config->numweights >= MAX_WEIGHTS)
+			{
+				SourceWarning(source, "too many fuzzy weights\n");
+				break;
+			} //end if
+			if (!PC_ExpectTokenType(source, TT_STRING, 0, &token))
+			{
+				FreeWeightConfig(config);
+				FreeSource(source);
+				return NULL;
+			} //end if
+			StripDoubleQuotes(token.string);
+			config->weights[config->numweights].name = (char *) GetClearedMemory(strlen(token.string) + 1);
+			strcpy(config->weights[config->numweights].name, token.string);
+			if (!PC_ExpectAnyToken(source, &token))
+			{
+				FreeWeightConfig(config);
+				FreeSource(source);
+				return NULL;
+			} //end if
+			newindent = qfalse;
+			if (!strcmp(token.string, "{"))
+			{
+				newindent = qtrue;
+				if (!PC_ExpectAnyToken(source, &token))
+				{
+					FreeWeightConfig(config);
+					FreeSource(source);
+					return NULL;
+				} //end if
+			} //end if
+			if (!strcmp(token.string, "switch"))
+			{
+				fs = ReadFuzzySeperators_r(source);
+				if (!fs)
+				{
+					FreeWeightConfig(config);
+					FreeSource(source);
+					return NULL;
+				} //end if
+				config->weights[config->numweights].firstseperator = fs;
+			} //end if
+			else if (!strcmp(token.string, "return"))
+			{
+				fs = (fuzzyseperator_t *) GetClearedMemory(sizeof(fuzzyseperator_t));
+				fs->index = 0;
+				fs->value = MAX_INVENTORYVALUE;
+				fs->next = NULL;
+				fs->child = NULL;
+				if (!ReadFuzzyWeight(source, fs))
+				{
+					FreeMemory(fs);
+					FreeWeightConfig(config);
+					FreeSource(source);
+					return NULL;
+				} //end if
+				config->weights[config->numweights].firstseperator = fs;
+			} //end else if
+			else
+			{
+				SourceError(source, "invalid name %s\n", token.string);
+				FreeWeightConfig(config);
+				FreeSource(source);
+				return NULL;
+			} //end else
+			if (newindent)
+			{
+				if (!PC_ExpectTokenString(source, "}"))
+				{
+					FreeWeightConfig(config);
+					FreeSource(source);
+					return NULL;
+				} //end if
+			} //end if
+			config->numweights++;
+		} //end if
+		else
+		{
+			SourceError(source, "invalid name %s\n", token.string);
+			FreeWeightConfig(config);
+			FreeSource(source);
+			return NULL;
+		} //end else
+	} //end while
+	//free the source at the end of a pass
+	FreeSource(source);
+	//if the file was located in a pak file
+	botimport.Print(PRT_MESSAGE, "loaded %s\n", filename);
+#ifdef DEBUG
+	if (bot_developer)
+	{
+		botimport.Print(PRT_MESSAGE, "weights loaded in %d msec\n", Sys_MilliSeconds() - starttime);
+	} //end if
+#endif //DEBUG
+	//
+	if (!LibVarGetValue("bot_reloadcharacters"))
+	{
+		weightFileList[avail] = config;
+	} //end if
+	//
+	return config;
+} //end of the function ReadWeightConfig
+#if 0
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+qboolean WriteFuzzyWeight(FILE *fp, fuzzyseperator_t *fs)
+{
+	if (fs->type == WT_BALANCE)
+	{
+		if (fprintf(fp, " return balance(") < 0) return qfalse;
+		if (!WriteFloat(fp, fs->weight)) return qfalse;
+		if (fprintf(fp, ",") < 0) return qfalse;
+		if (!WriteFloat(fp, fs->minweight)) return qfalse;
+		if (fprintf(fp, ",") < 0) return qfalse;
+		if (!WriteFloat(fp, fs->maxweight)) return qfalse;
+		if (fprintf(fp, ");\n") < 0) return qfalse;
+	} //end if
+	else
+	{
+		if (fprintf(fp, " return ") < 0) return qfalse;
+		if (!WriteFloat(fp, fs->weight)) return qfalse;
+		if (fprintf(fp, ";\n") < 0) return qfalse;
+	} //end else
+	return qtrue;
+} //end of the function WriteFuzzyWeight
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+qboolean WriteFuzzySeperators_r(FILE *fp, fuzzyseperator_t *fs, int indent)
+{
+	if (!WriteIndent(fp, indent)) return qfalse;
+	if (fprintf(fp, "switch(%d)\n", fs->index) < 0) return qfalse;
+	if (!WriteIndent(fp, indent)) return qfalse;
+	if (fprintf(fp, "{\n") < 0) return qfalse;
+	indent++;
+	do
+	{
+		if (!WriteIndent(fp, indent)) return qfalse;
+		if (fs->next)
+		{
+			if (fprintf(fp, "case %d:", fs->value) < 0) return qfalse;
+		} //end if
+		else
+		{
+			if (fprintf(fp, "default:") < 0) return qfalse;
+		} //end else
+		if (fs->child)
+		{
+			if (fprintf(fp, "\n") < 0) return qfalse;
+			if (!WriteIndent(fp, indent)) return qfalse;
+			if (fprintf(fp, "{\n") < 0) return qfalse;
+			if (!WriteFuzzySeperators_r(fp, fs->child, indent + 1)) return qfalse;
+			if (!WriteIndent(fp, indent)) return qfalse;
+			if (fs->next)
+			{
+				if (fprintf(fp, "} //end case\n") < 0) return qfalse;
+			} //end if
+			else
+			{
+				if (fprintf(fp, "} //end default\n") < 0) return qfalse;
+			} //end else
+		} //end if
+		else
+		{
+			if (!WriteFuzzyWeight(fp, fs)) return qfalse;
+		} //end else
+		fs = fs->next;
+	} while(fs);
+	indent--;
+	if (!WriteIndent(fp, indent)) return qfalse;
+	if (fprintf(fp, "} //end switch\n") < 0) return qfalse;
+	return qtrue;
+} //end of the function WriteItemFuzzyWeights_r
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+qboolean WriteWeightConfig(char *filename, weightconfig_t *config)
+{
+	int i;
+	FILE *fp;
+	weight_t *ifw;
+
+	fp = fopen(filename, "wb");
+	if (!fp) return qfalse;
+
+	for (i = 0; i < config->numweights; i++)
+	{
+		ifw = &config->weights[i];
+		if (fprintf(fp, "\nweight \"%s\"\n", ifw->name) < 0) return qfalse;
+		if (fprintf(fp, "{\n") < 0) return qfalse;
+		if (ifw->firstseperator->index > 0)
+		{
+			if (!WriteFuzzySeperators_r(fp, ifw->firstseperator, 1)) return qfalse;
+		} //end if
+		else
+		{
+			if (!WriteIndent(fp, 1)) return qfalse;
+			if (!WriteFuzzyWeight(fp, ifw->firstseperator)) return qfalse;
+		} //end else
+		if (fprintf(fp, "} //end weight\n") < 0) return qfalse;
+	} //end for
+	fclose(fp);
+	return qtrue;
+} //end of the function WriteWeightConfig
+#endif
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int FindFuzzyWeight(weightconfig_t *wc, char *name)
+{
+	int i;
+
+	for (i = 0; i < wc->numweights; i++)
+	{
+		if (!strcmp(wc->weights[i].name, name))
+		{
+			return i;
+		} //end if
+	} //end if
+	return -1;
+} //end of the function FindFuzzyWeight
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+float FuzzyWeight_r(int *inventory, fuzzyseperator_t *fs)
+{
+	float scale, w1, w2;
+
+	if (inventory[fs->index] < fs->value)
+	{
+		if (fs->child) return FuzzyWeight_r(inventory, fs->child);
+		else return fs->weight;
+	} //end if
+	else if (fs->next)
+	{
+		if (inventory[fs->index] < fs->next->value)
+		{
+			//first weight
+			if (fs->child) w1 = FuzzyWeight_r(inventory, fs->child);
+			else w1 = fs->weight;
+			//second weight
+			if (fs->next->child) w2 = FuzzyWeight_r(inventory, fs->next->child);
+			else w2 = fs->next->weight;
+			//the scale factor
+			scale = (inventory[fs->index] - fs->value) / (fs->next->value - fs->value);
+			//scale between the two weights
+			return scale * w1 + (1 - scale) * w2;
+		} //end if
+		return FuzzyWeight_r(inventory, fs->next);
+	} //end else if
+	return fs->weight;
+} //end of the function FuzzyWeight_r
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+float FuzzyWeightUndecided_r(int *inventory, fuzzyseperator_t *fs)
+{
+	float scale, w1, w2;
+
+	if (inventory[fs->index] < fs->value)
+	{
+		if (fs->child) return FuzzyWeightUndecided_r(inventory, fs->child);
+		else return fs->minweight + random() * (fs->maxweight - fs->minweight);
+	} //end if
+	else if (fs->next)
+	{
+		if (inventory[fs->index] < fs->next->value)
+		{
+			//first weight
+			if (fs->child) w1 = FuzzyWeightUndecided_r(inventory, fs->child);
+			else w1 = fs->minweight + random() * (fs->maxweight - fs->minweight);
+			//second weight
+			if (fs->next->child) w2 = FuzzyWeight_r(inventory, fs->next->child);
+			else w2 = fs->next->minweight + random() * (fs->next->maxweight - fs->next->minweight);
+			//the scale factor
+			scale = (inventory[fs->index] - fs->value) / (fs->next->value - fs->value);
+			//scale between the two weights
+			return scale * w1 + (1 - scale) * w2;
+		} //end if
+		return FuzzyWeightUndecided_r(inventory, fs->next);
+	} //end else if
+	return fs->weight;
+} //end of the function FuzzyWeightUndecided_r
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+float FuzzyWeight(int *inventory, weightconfig_t *wc, int weightnum)
+{
+#ifdef EVALUATERECURSIVELY
+	return FuzzyWeight_r(inventory, wc->weights[weightnum].firstseperator);
+#else
+	fuzzyseperator_t *s;
+
+	s = wc->weights[weightnum].firstseperator;
+	if (!s) return 0;
+	while(1)
+	{
+		if (inventory[s->index] < s->value)
+		{
+			if (s->child) s = s->child;
+			else return s->weight;
+		} //end if
+		else
+		{
+			if (s->next) s = s->next;
+			else return s->weight;
+		} //end else
+	} //end if
+	return 0;
+#endif
+} //end of the function FuzzyWeight
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+float FuzzyWeightUndecided(int *inventory, weightconfig_t *wc, int weightnum)
+{
+#ifdef EVALUATERECURSIVELY
+	return FuzzyWeightUndecided_r(inventory, wc->weights[weightnum].firstseperator);
+#else
+	fuzzyseperator_t *s;
+
+	s = wc->weights[weightnum].firstseperator;
+	if (!s) return 0;
+	while(1)
+	{
+		if (inventory[s->index] < s->value)
+		{
+			if (s->child) s = s->child;
+			else return s->minweight + random() * (s->maxweight - s->minweight);
+		} //end if
+		else
+		{
+			if (s->next) s = s->next;
+			else return s->minweight + random() * (s->maxweight - s->minweight);
+		} //end else
+	} //end if
+	return 0;
+#endif
+} //end of the function FuzzyWeightUndecided
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void EvolveFuzzySeperator_r(fuzzyseperator_t *fs)
+{
+	if (fs->child)
+	{
+		EvolveFuzzySeperator_r(fs->child);
+	} //end if
+	else if (fs->type == WT_BALANCE)
+	{
+		//every once in a while an evolution leap occurs, mutation
+		if (random() < 0.01) fs->weight += crandom() * (fs->maxweight - fs->minweight);
+		else fs->weight += crandom() * (fs->maxweight - fs->minweight) * 0.5;
+		//modify bounds if necesary because of mutation
+		if (fs->weight < fs->minweight) fs->minweight = fs->weight;
+		else if (fs->weight > fs->maxweight) fs->maxweight = fs->weight;
+	} //end else if
+	if (fs->next) EvolveFuzzySeperator_r(fs->next);
+} //end of the function EvolveFuzzySeperator_r
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void EvolveWeightConfig(weightconfig_t *config)
+{
+	int i;
+
+	for (i = 0; i < config->numweights; i++)
+	{
+		EvolveFuzzySeperator_r(config->weights[i].firstseperator);
+	} //end for
+} //end of the function EvolveWeightConfig
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void ScaleFuzzySeperator_r(fuzzyseperator_t *fs, float scale)
+{
+	if (fs->child)
+	{
+		ScaleFuzzySeperator_r(fs->child, scale);
+	} //end if
+	else if (fs->type == WT_BALANCE)
+	{
+		//
+		fs->weight = (fs->maxweight + fs->minweight) * scale;
+		//get the weight between bounds
+		if (fs->weight < fs->minweight) fs->weight = fs->minweight;
+		else if (fs->weight > fs->maxweight) fs->weight = fs->maxweight;
+	} //end else if
+	if (fs->next) ScaleFuzzySeperator_r(fs->next, scale);
+} //end of the function ScaleFuzzySeperator_r
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void ScaleWeight(weightconfig_t *config, char *name, float scale)
+{
+	int i;
+
+	if (scale < 0) scale = 0;
+	else if (scale > 1) scale = 1;
+	for (i = 0; i < config->numweights; i++)
+	{
+		if (!strcmp(name, config->weights[i].name))
+		{
+			ScaleFuzzySeperator_r(config->weights[i].firstseperator, scale);
+			break;
+		} //end if
+	} //end for
+} //end of the function ScaleWeight
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void ScaleFuzzySeperatorBalanceRange_r(fuzzyseperator_t *fs, float scale)
+{
+	if (fs->child)
+	{
+		ScaleFuzzySeperatorBalanceRange_r(fs->child, scale);
+	} //end if
+	else if (fs->type == WT_BALANCE)
+	{
+		float mid = (fs->minweight + fs->maxweight) * 0.5;
+		//get the weight between bounds
+		fs->maxweight = mid + (fs->maxweight - mid) * scale;
+		fs->minweight = mid + (fs->minweight - mid) * scale;
+		if (fs->maxweight < fs->minweight)
+		{
+			fs->maxweight = fs->minweight;
+		} //end if
+	} //end else if
+	if (fs->next) ScaleFuzzySeperatorBalanceRange_r(fs->next, scale);
+} //end of the function ScaleFuzzySeperatorBalanceRange_r
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void ScaleFuzzyBalanceRange(weightconfig_t *config, float scale)
+{
+	int i;
+
+	if (scale < 0) scale = 0;
+	else if (scale > 100) scale = 100;
+	for (i = 0; i < config->numweights; i++)
+	{
+		ScaleFuzzySeperatorBalanceRange_r(config->weights[i].firstseperator, scale);
+	} //end for
+} //end of the function ScaleFuzzyBalanceRange
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int InterbreedFuzzySeperator_r(fuzzyseperator_t *fs1, fuzzyseperator_t *fs2,
+								fuzzyseperator_t *fsout)
+{
+	if (fs1->child)
+	{
+		if (!fs2->child || !fsout->child)
+		{
+			botimport.Print(PRT_ERROR, "cannot interbreed weight configs, unequal child\n");
+			return qfalse;
+		} //end if
+		if (!InterbreedFuzzySeperator_r(fs2->child, fs2->child, fsout->child))
+		{
+			return qfalse;
+		} //end if
+	} //end if
+	else if (fs1->type == WT_BALANCE)
+	{
+		if (fs2->type != WT_BALANCE || fsout->type != WT_BALANCE)
+		{
+			botimport.Print(PRT_ERROR, "cannot interbreed weight configs, unequal balance\n");
+			return qfalse;
+		} //end if
+		fsout->weight = (fs1->weight + fs2->weight) / 2;
+		if (fsout->weight > fsout->maxweight) fsout->maxweight = fsout->weight;
+		if (fsout->weight > fsout->minweight) fsout->minweight = fsout->weight;
+	} //end else if
+	if (fs1->next)
+	{
+		if (!fs2->next || !fsout->next)
+		{
+			botimport.Print(PRT_ERROR, "cannot interbreed weight configs, unequal next\n");
+			return qfalse;
+		} //end if
+		if (!InterbreedFuzzySeperator_r(fs1->next, fs2->next, fsout->next))
+		{
+			return qfalse;
+		} //end if
+	} //end if
+	return qtrue;
+} //end of the function InterbreedFuzzySeperator_r
+//===========================================================================
+// config1 and config2 are interbreeded and stored in configout
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void InterbreedWeightConfigs(weightconfig_t *config1, weightconfig_t *config2,
+								weightconfig_t *configout)
+{
+	int i;
+
+	if (config1->numweights != config2->numweights ||
+		config1->numweights != configout->numweights)
+	{
+		botimport.Print(PRT_ERROR, "cannot interbreed weight configs, unequal numweights\n");
+		return;
+	} //end if
+	for (i = 0; i < config1->numweights; i++)
+	{
+		InterbreedFuzzySeperator_r(config1->weights[i].firstseperator,
+									config2->weights[i].firstseperator,
+									configout->weights[i].firstseperator);
+	} //end for
+} //end of the function InterbreedWeightConfigs
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+void BotShutdownWeights(void)
+{
+	int i;
+
+	for( i = 0; i < MAX_WEIGHT_FILES; i++ )
+	{
+		if (weightFileList[i])
+		{
+			FreeWeightConfig2(weightFileList[i]);
+			weightFileList[i] = NULL;
+		} //end if
+	} //end for
+} //end of the function BotShutdownWeights
diff --git a/codemp/botlib/be_ai_weight.h b/codemp/botlib/be_ai_weight.h
new file mode 100644
index 0000000..bfa63fe
--- /dev/null
+++ b/codemp/botlib/be_ai_weight.h
@@ -0,0 +1,66 @@
+
+/*****************************************************************************
+ * name:		be_ai_weight.h
+ *
+ * desc:		fuzzy weights
+ *
+ * $Archive: /source/code/botlib/be_ai_weight.h $
+ * $Author: Mrelusive $ 
+ * $Revision: 2 $
+ * $Modtime: 10/05/99 3:32p $
+ * $Date: 10/05/99 3:42p $
+ *
+ *****************************************************************************/
+
+#define WT_BALANCE			1
+#define MAX_WEIGHTS			128
+
+//fuzzy seperator
+typedef struct fuzzyseperator_s
+{
+	int index;
+	int value;
+	int type;
+	float weight;
+	float minweight;
+	float maxweight;
+	struct fuzzyseperator_s *child;
+	struct fuzzyseperator_s *next;
+} fuzzyseperator_t;
+
+//fuzzy weight
+typedef struct weight_s
+{
+	char *name;
+	struct fuzzyseperator_s *firstseperator;
+} weight_t;
+
+//weight configuration
+typedef struct weightconfig_s
+{
+	int numweights;
+	weight_t weights[MAX_WEIGHTS];
+	char		filename[MAX_QPATH];
+} weightconfig_t;
+
+//reads a weight configuration
+weightconfig_t *ReadWeightConfig(char *filename);
+//free a weight configuration
+void FreeWeightConfig(weightconfig_t *config);
+//writes a weight configuration, returns true if successfull
+qboolean WriteWeightConfig(char *filename, weightconfig_t *config);
+//find the fuzzy weight with the given name
+int FindFuzzyWeight(weightconfig_t *wc, char *name);
+//returns the fuzzy weight for the given inventory and weight
+float FuzzyWeight(int *inventory, weightconfig_t *wc, int weightnum);
+float FuzzyWeightUndecided(int *inventory, weightconfig_t *wc, int weightnum);
+//scales the weight with the given name
+void ScaleWeight(weightconfig_t *config, char *name, float scale);
+//scale the balance range
+void ScaleBalanceRange(weightconfig_t *config, float scale);
+//evolves the weight configuration
+void EvolveWeightConfig(weightconfig_t *config);
+//interbreed the weight configurations and stores the interbreeded one in configout
+void InterbreedWeightConfigs(weightconfig_t *config1, weightconfig_t *config2, weightconfig_t *configout);
+//frees cached weight configurations
+void BotShutdownWeights(void);
diff --git a/codemp/botlib/be_ea.cpp b/codemp/botlib/be_ea.cpp
new file mode 100644
index 0000000..38237f2
--- /dev/null
+++ b/codemp/botlib/be_ea.cpp
@@ -0,0 +1,519 @@
+
+/*****************************************************************************
+ * name:		be_ea.c
+ *
+ * desc:		elementary actions
+ *
+ * $Archive: /MissionPack/code/botlib/be_ea.c $
+ * $Author: Zaphod $ 
+ * $Revision: 5 $
+ * $Modtime: 11/22/00 8:50a $
+ * $Date: 11/22/00 8:55a $
+ *
+ *****************************************************************************/
+
+#include "../game/q_shared.h"
+#include "l_memory.h"
+#include "l_script.h"
+#include "l_precomp.h"
+#include "l_struct.h"
+#include "../game/botlib.h"
+#include "be_interface.h"
+
+#define MAX_USERMOVE				400
+#define MAX_COMMANDARGUMENTS		10
+#define ACTION_JUMPEDLASTFRAME		0x0800000//128
+
+bot_input_t *botinputs;
+
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void EA_Say(int client, char *str)
+{
+	botimport.BotClientCommand(client, va("say %s", str) );
+} //end of the function EA_Say
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void EA_SayTeam(int client, char *str)
+{
+	botimport.BotClientCommand(client, va("say_team %s", str));
+} //end of the function EA_SayTeam
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void EA_Tell(int client, int clientto, char *str)
+{
+	botimport.BotClientCommand(client, va("tell %d, %s", clientto, str));
+} //end of the function EA_SayTeam
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void EA_UseItem(int client, char *it)
+{
+	botimport.BotClientCommand(client, va("use %s", it));
+} //end of the function EA_UseItem
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void EA_DropItem(int client, char *it)
+{
+	botimport.BotClientCommand(client, va("drop %s", it));
+} //end of the function EA_DropItem
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void EA_UseInv(int client, char *inv)
+{
+	botimport.BotClientCommand(client, va("invuse %s", inv));
+} //end of the function EA_UseInv
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+void EA_DropInv(int client, char *inv)
+{
+	botimport.BotClientCommand(client, va("invdrop %s", inv));
+} //end of the function EA_DropInv
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+void EA_Gesture(int client)
+{
+	bot_input_t *bi;
+
+	bi = &botinputs[client];
+
+	bi->actionflags |= ACTION_GESTURE;
+} //end of the function EA_Gesture
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void EA_Command(int client, char *command)
+{
+	botimport.BotClientCommand(client, command);
+} //end of the function EA_Command
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+void EA_SelectWeapon(int client, int weapon)
+{
+	bot_input_t *bi;
+
+	bi = &botinputs[client];
+
+	bi->weapon = weapon;
+} //end of the function EA_SelectWeapon
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+void EA_Attack(int client)
+{
+	bot_input_t *bi;
+
+	bi = &botinputs[client];
+
+	bi->actionflags |= ACTION_ATTACK;
+} //end of the function EA_Attack
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+void EA_Alt_Attack(int client)
+{
+	bot_input_t *bi;
+
+	bi = &botinputs[client];
+
+	bi->actionflags |= ACTION_ALT_ATTACK;
+} //end of the function EA_Alt_Attack
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+void EA_ForcePower(int client)
+{
+	bot_input_t *bi;
+
+	bi = &botinputs[client];
+
+	bi->actionflags |= ACTION_FORCEPOWER;
+} //end of the function EA_ForcePower
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+void EA_Talk(int client)
+{
+	bot_input_t *bi;
+
+	bi = &botinputs[client];
+
+	bi->actionflags |= ACTION_TALK;
+} //end of the function EA_Talk
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+void EA_Use(int client)
+{
+	bot_input_t *bi;
+
+	bi = &botinputs[client];
+
+	bi->actionflags |= ACTION_USE;
+} //end of the function EA_Use
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+void EA_Respawn(int client)
+{
+	bot_input_t *bi;
+
+	bi = &botinputs[client];
+
+	bi->actionflags |= ACTION_RESPAWN;
+} //end of the function EA_Respawn
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+void EA_Jump(int client)
+{
+	bot_input_t *bi;
+
+	bi = &botinputs[client];
+
+	if (bi->actionflags & ACTION_JUMPEDLASTFRAME)
+	{
+		bi->actionflags &= ~ACTION_JUMP;
+	} //end if
+	else
+	{
+		bi->actionflags |= ACTION_JUMP;
+	} //end if
+} //end of the function EA_Jump
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+void EA_DelayedJump(int client)
+{
+	bot_input_t *bi;
+
+	bi = &botinputs[client];
+
+	if (bi->actionflags & ACTION_JUMPEDLASTFRAME)
+	{
+		bi->actionflags &= ~ACTION_DELAYEDJUMP;
+	} //end if
+	else
+	{
+		bi->actionflags |= ACTION_DELAYEDJUMP;
+	} //end if
+} //end of the function EA_DelayedJump
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+void EA_Crouch(int client)
+{
+	bot_input_t *bi;
+
+	bi = &botinputs[client];
+
+	bi->actionflags |= ACTION_CROUCH;
+} //end of the function EA_Crouch
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+void EA_Walk(int client)
+{
+	bot_input_t *bi;
+
+	bi = &botinputs[client];
+
+	bi->actionflags |= ACTION_WALK;
+} //end of the function EA_Walk
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+void EA_Action(int client, int action)
+{
+	bot_input_t *bi;
+
+	bi = &botinputs[client];
+
+	bi->actionflags |= action;
+} //end of function EA_Action
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+void EA_MoveUp(int client)
+{
+	bot_input_t *bi;
+
+	bi = &botinputs[client];
+
+	bi->actionflags |= ACTION_MOVEUP;
+} //end of the function EA_MoveUp
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+void EA_MoveDown(int client)
+{
+	bot_input_t *bi;
+
+	bi = &botinputs[client];
+
+	bi->actionflags |= ACTION_MOVEDOWN;
+} //end of the function EA_MoveDown
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+void EA_MoveForward(int client)
+{
+	bot_input_t *bi;
+
+	bi = &botinputs[client];
+
+	bi->actionflags |= ACTION_MOVEFORWARD;
+} //end of the function EA_MoveForward
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+void EA_MoveBack(int client)
+{
+	bot_input_t *bi;
+
+	bi = &botinputs[client];
+
+	bi->actionflags |= ACTION_MOVEBACK;
+} //end of the function EA_MoveBack
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+void EA_MoveLeft(int client)
+{
+	bot_input_t *bi;
+
+	bi = &botinputs[client];
+
+	bi->actionflags |= ACTION_MOVELEFT;
+} //end of the function EA_MoveLeft
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+void EA_MoveRight(int client)
+{
+	bot_input_t *bi;
+
+	bi = &botinputs[client];
+
+	bi->actionflags |= ACTION_MOVERIGHT;
+} //end of the function EA_MoveRight
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+void EA_Move(int client, vec3_t dir, float speed)
+{
+	bot_input_t *bi;
+
+	bi = &botinputs[client];
+
+	VectorCopy(dir, bi->dir);
+	//cap speed
+	if (speed > MAX_USERMOVE) speed = MAX_USERMOVE;
+	else if (speed < -MAX_USERMOVE) speed = -MAX_USERMOVE;
+	bi->speed = speed;
+} //end of the function EA_Move
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+void EA_View(int client, vec3_t viewangles)
+{
+	bot_input_t *bi;
+
+	bi = &botinputs[client];
+
+	VectorCopy(viewangles, bi->viewangles);
+} //end of the function EA_View
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+void EA_EndRegular(int client, float thinktime)
+{
+/*
+	bot_input_t *bi;
+	int jumped = qfalse;
+
+	bi = &botinputs[client];
+
+	bi->actionflags &= ~ACTION_JUMPEDLASTFRAME;
+
+	bi->thinktime = thinktime;
+	botimport.BotInput(client, bi);
+
+	bi->thinktime = 0;
+	VectorClear(bi->dir);
+	bi->speed = 0;
+	jumped = bi->actionflags & ACTION_JUMP;
+	bi->actionflags = 0;
+	if (jumped) bi->actionflags |= ACTION_JUMPEDLASTFRAME;
+*/
+} //end of the function EA_EndRegular
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+void EA_GetInput(int client, float thinktime, bot_input_t *input)
+{
+	bot_input_t *bi;
+//	int jumped = qfalse;
+
+	bi = &botinputs[client];
+
+//	bi->actionflags &= ~ACTION_JUMPEDLASTFRAME;
+
+	bi->thinktime = thinktime;
+	Com_Memcpy(input, bi, sizeof(bot_input_t));
+
+	/*
+	bi->thinktime = 0;
+	VectorClear(bi->dir);
+	bi->speed = 0;
+	jumped = bi->actionflags & ACTION_JUMP;
+	bi->actionflags = 0;
+	if (jumped) bi->actionflags |= ACTION_JUMPEDLASTFRAME;
+	*/
+} //end of the function EA_GetInput
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+void EA_ResetInput(int client)
+{
+	bot_input_t *bi;
+	int jumped = qfalse;
+
+	bi = &botinputs[client];
+	bi->actionflags &= ~ACTION_JUMPEDLASTFRAME;
+
+	bi->thinktime = 0;
+	VectorClear(bi->dir);
+	bi->speed = 0;
+	jumped = bi->actionflags & ACTION_JUMP;
+	bi->actionflags = 0;
+	if (jumped) bi->actionflags |= ACTION_JUMPEDLASTFRAME;
+} //end of the function EA_ResetInput
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+int EA_Setup(void)
+{
+	//initialize the bot inputs
+	botinputs = (bot_input_t *) GetClearedHunkMemory(
+									botlibglobals.maxclients * sizeof(bot_input_t));
+	return BLERR_NOERROR;
+} //end of the function EA_Setup
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+void EA_Shutdown(void)
+{
+	FreeMemory(botinputs);
+	botinputs = NULL;
+} //end of the function EA_Shutdown
diff --git a/codemp/botlib/be_interface.cpp b/codemp/botlib/be_interface.cpp
new file mode 100644
index 0000000..dc84b8c
--- /dev/null
+++ b/codemp/botlib/be_interface.cpp
@@ -0,0 +1,869 @@
+
+/*****************************************************************************
+ * name:		be_interface.c // bk010221 - FIXME - DEAD code elimination
+ *
+ * desc:		bot library interface
+ *
+ * $Archive: /MissionPack/code/botlib/be_interface.c $
+ * $Author: Zaphod $ 
+ * $Revision: 16 $
+ * $Modtime: 5/16/01 2:36p $
+ * $Date: 5/16/01 2:41p $
+ *
+ *****************************************************************************/
+
+#include "../game/q_shared.h"
+#include "l_memory.h"
+#include "l_log.h"
+#include "l_libvar.h"
+#include "l_script.h"
+#include "l_precomp.h"
+#include "l_struct.h"
+#include "aasfile.h"
+#include "../game/botlib.h"
+#include "../game/be_aas.h"
+#include "be_aas_funcs.h"
+#include "be_aas_def.h"
+#include "be_interface.h"
+
+#include "../game/be_ea.h"
+#include "be_ai_weight.h"
+#include "../game/be_ai_goal.h"
+#include "../game/be_ai_move.h"
+#include "../game/be_ai_weap.h"
+#include "../game/be_ai_chat.h"
+#include "../game/be_ai_char.h"
+#include "../game/be_ai_gen.h"
+
+//library globals in a structure
+botlib_globals_t botlibglobals;
+
+botlib_export_t be_botlib_export;
+botlib_import_t botimport;
+//
+int bot_developer;
+//qtrue if the library is setup
+int botlibsetup = qfalse;
+
+//===========================================================================
+//
+// several functions used by the exported functions
+//
+//===========================================================================
+
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int Sys_MilliSeconds(void)
+{
+	return clock() * 1000 / CLOCKS_PER_SEC;
+} //end of the function Sys_MilliSeconds
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+qboolean ValidClientNumber(int num, char *str)
+{
+	if (num < 0 || num > botlibglobals.maxclients)
+	{
+		//weird: the disabled stuff results in a crash
+		botimport.Print(PRT_ERROR, "%s: invalid client number %d, [0, %d]\n",
+										str, num, botlibglobals.maxclients);
+		return qfalse;
+	} //end if
+	return qtrue;
+} //end of the function BotValidateClientNumber
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+qboolean ValidEntityNumber(int num, char *str)
+{
+	if (num < 0 || num > botlibglobals.maxentities)
+	{
+		botimport.Print(PRT_ERROR, "%s: invalid entity number %d, [0, %d]\n",
+										str, num, botlibglobals.maxentities);
+		return qfalse;
+	} //end if
+	return qtrue;
+} //end of the function BotValidateClientNumber
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+qboolean BotLibSetup(char *str)
+{
+	if (!botlibglobals.botlibsetup)
+	{
+		botimport.Print(PRT_ERROR, "%s: bot library used before being setup\n", str);
+		return qfalse;
+	} //end if
+	return qtrue;
+} //end of the function BotLibSetup
+
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int Export_BotLibSetup(void)
+{
+	int		errnum;
+	
+	bot_developer = LibVarGetValue("bot_developer");
+  memset( &botlibglobals, 0, sizeof(botlibglobals) ); // bk001207 - init
+	//initialize byte swapping (litte endian etc.)
+//	Swap_Init();
+	Log_Open("botlib.log");
+	//
+//	botimport.Print(PRT_MESSAGE, "------- BotLib Initialization -------\n");
+	//
+	botlibglobals.maxclients = (int) LibVarValue("maxclients", "128");
+	botlibglobals.maxentities = (int) LibVarValue("maxentities", "1024");
+
+	errnum = AAS_Setup();			//be_aas_main.c
+	if (errnum != BLERR_NOERROR) return errnum;
+	errnum = EA_Setup();			//be_ea.c
+	if (errnum != BLERR_NOERROR) return errnum;
+	/*
+	errnum = BotSetupWeaponAI();	//be_ai_weap.c
+	if (errnum != BLERR_NOERROR)return errnum;
+	errnum = BotSetupGoalAI();		//be_ai_goal.c
+	if (errnum != BLERR_NOERROR) return errnum;
+	errnum = BotSetupChatAI();		//be_ai_chat.c
+	if (errnum != BLERR_NOERROR) return errnum;
+	errnum = BotSetupMoveAI();		//be_ai_move.c
+	if (errnum != BLERR_NOERROR) return errnum;
+	*/
+	botlibsetup = qtrue;
+	botlibglobals.botlibsetup = qtrue;
+
+	return BLERR_NOERROR;
+} //end of the function Export_BotLibSetup
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int Export_BotLibShutdown(void)
+{
+	if (!BotLibSetup("BotLibShutdown")) return BLERR_LIBRARYNOTSETUP;
+#ifndef DEMO
+	//DumpFileCRCs();
+#endif //DEMO
+	//
+	BotShutdownChatAI();		//be_ai_chat.c
+	BotShutdownMoveAI();		//be_ai_move.c
+	BotShutdownGoalAI();		//be_ai_goal.c
+	BotShutdownWeaponAI();		//be_ai_weap.c
+	BotShutdownWeights();		//be_ai_weight.c
+	BotShutdownCharacters();	//be_ai_char.c
+	//shud down aas
+	AAS_Shutdown();
+	//shut down bot elemantary actions
+	EA_Shutdown();
+	//free all libvars
+	LibVarDeAllocAll();
+	//remove all global defines from the pre compiler
+	PC_RemoveAllGlobalDefines();
+
+	//dump all allocated memory
+//	DumpMemory();
+#ifdef DEBUG
+	PrintMemoryLabels();
+#endif
+	//shut down library log file
+	Log_Shutdown();
+	//
+	botlibsetup = qfalse;
+	botlibglobals.botlibsetup = qfalse;
+	// print any files still open
+	PC_CheckOpenSourceHandles();
+	//
+	return BLERR_NOERROR;
+} //end of the function Export_BotLibShutdown
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int Export_BotLibVarSet(char *var_name, char *value)
+{
+	LibVarSet(var_name, value);
+	return BLERR_NOERROR;
+} //end of the function Export_BotLibVarSet
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int Export_BotLibVarGet(char *var_name, char *value, int size)
+{
+	char *varvalue;
+
+	varvalue = LibVarGetString(var_name);
+	strncpy(value, varvalue, size-1);
+	value[size-1] = '\0';
+	return BLERR_NOERROR;
+} //end of the function Export_BotLibVarGet
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int Export_BotLibStartFrame(float time)
+{
+	if (!BotLibSetup("BotStartFrame")) return BLERR_LIBRARYNOTSETUP;
+	return AAS_StartFrame(time);
+} //end of the function Export_BotLibStartFrame
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int Export_BotLibLoadMap(const char *mapname)
+{
+#ifdef DEBUG
+	int starttime = Sys_MilliSeconds();
+#endif
+	int errnum;
+
+	if (!BotLibSetup("BotLoadMap")) return BLERR_LIBRARYNOTSETUP;
+	//
+	botimport.Print(PRT_MESSAGE, "------------ Map Loading ------------\n");
+	//startup AAS for the current map, model and sound index
+	errnum = AAS_LoadMap(mapname);
+	if (errnum != BLERR_NOERROR) return errnum;
+	//initialize the items in the level
+	BotInitLevelItems();		//be_ai_goal.h
+	BotSetBrushModelTypes();	//be_ai_move.h
+	//
+	botimport.Print(PRT_MESSAGE, "-------------------------------------\n");
+#ifdef DEBUG
+	botimport.Print(PRT_MESSAGE, "map loaded in %d msec\n", Sys_MilliSeconds() - starttime);
+#endif
+	//
+	return BLERR_NOERROR;
+} //end of the function Export_BotLibLoadMap
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int Export_BotLibUpdateEntity(int ent, bot_entitystate_t *state)
+{
+	if (!BotLibSetup("BotUpdateEntity")) return BLERR_LIBRARYNOTSETUP;
+	if (!ValidEntityNumber(ent, "BotUpdateEntity")) return BLERR_INVALIDENTITYNUMBER;
+
+	return AAS_UpdateEntity(ent, state);
+} //end of the function Export_BotLibUpdateEntity
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void AAS_TestMovementPrediction(int entnum, vec3_t origin, vec3_t dir);
+void ElevatorBottomCenter(aas_reachability_t *reach, vec3_t bottomcenter);
+int BotGetReachabilityToGoal(vec3_t origin, int areanum,
+									  int lastgoalareanum, int lastareanum,
+									  int *avoidreach, float *avoidreachtimes, int *avoidreachtries,
+									  bot_goal_t *goal, int travelflags, int movetravelflags,
+									  struct bot_avoidspot_s *avoidspots, int numavoidspots, int *flags);
+
+int AAS_PointLight(vec3_t origin, int *red, int *green, int *blue);
+
+int AAS_TraceAreas(vec3_t start, vec3_t end, int *areas, vec3_t *points, int maxareas);
+
+int AAS_Reachability_WeaponJump(int area1num, int area2num);
+
+int BotFuzzyPointReachabilityArea(vec3_t origin);
+
+float BotGapDistance(vec3_t origin, vec3_t hordir, int entnum);
+
+void AAS_FloodAreas(vec3_t origin);
+
+int BotExportTest(int parm0, char *parm1, vec3_t parm2, vec3_t parm3)
+{
+
+//	return AAS_PointLight(parm2, NULL, NULL, NULL);
+
+#ifdef DEBUG
+	static int area = -1;
+	static int line[2];
+	int newarea, i, highlightarea, flood;
+//	int reachnum;
+	vec3_t eye, forward, right, end, origin;
+//	vec3_t bottomcenter;
+//	aas_trace_t trace;
+//	aas_face_t *face;
+//	aas_entity_t *ent;
+//	bsp_trace_t bsptrace;
+//	aas_reachability_t reach;
+//	bot_goal_t goal;
+
+	// clock_t start_time, end_time;
+	vec3_t mins = {-16, -16, -24};
+	vec3_t maxs = {16, 16, 32};
+
+//	int areas[10], numareas;
+
+
+	//return 0;
+
+	if (!aasworld.loaded) return 0;
+
+	/*
+	if (parm0 & 1)
+	{
+		AAS_ClearShownPolygons();
+		AAS_FloodAreas(parm2);
+	} //end if
+	return 0;
+	*/
+	for (i = 0; i < 2; i++) if (!line[i]) line[i] = botimport.DebugLineCreate();
+
+//	AAS_ClearShownDebugLines();
+
+	//if (AAS_AgainstLadder(parm2)) botimport.Print(PRT_MESSAGE, "against ladder\n");
+	//BotOnGround(parm2, PRESENCE_NORMAL, 1, &newarea, &newarea);
+	//botimport.Print(PRT_MESSAGE, "%f %f %f\n", parm2[0], parm2[1], parm2[2]);
+	//*
+	highlightarea = LibVarGetValue("bot_highlightarea");
+	if (highlightarea > 0)
+	{
+		newarea = highlightarea;
+	} //end if
+	else
+	{
+		VectorCopy(parm2, origin);
+		origin[2] += 0.5;
+		//newarea = AAS_PointAreaNum(origin);
+		newarea = BotFuzzyPointReachabilityArea(origin);
+	} //end else
+
+	botimport.Print(PRT_MESSAGE, "\rtravel time to goal (%d) = %d  ", botlibglobals.goalareanum,
+		AAS_AreaTravelTimeToGoalArea(newarea, origin, botlibglobals.goalareanum, TFL_DEFAULT));
+	//newarea = BotReachabilityArea(origin, qtrue);
+	if (newarea != area)
+	{
+		botimport.Print(PRT_MESSAGE, "origin = %f, %f, %f\n", origin[0], origin[1], origin[2]);
+		area = newarea;
+		botimport.Print(PRT_MESSAGE, "new area %d, cluster %d, presence type %d\n",
+					area, AAS_AreaCluster(area), AAS_PointPresenceType(origin));
+		botimport.Print(PRT_MESSAGE, "area contents: ");
+		if (aasworld.areasettings[area].contents & AREACONTENTS_WATER)
+		{
+			botimport.Print(PRT_MESSAGE, "water &");
+		} //end if
+		if (aasworld.areasettings[area].contents & AREACONTENTS_LAVA)
+		{
+			botimport.Print(PRT_MESSAGE, "lava &");
+		} //end if
+		if (aasworld.areasettings[area].contents & AREACONTENTS_SLIME)
+		{
+			botimport.Print(PRT_MESSAGE, "slime &");
+		} //end if
+		if (aasworld.areasettings[area].contents & AREACONTENTS_JUMPPAD)
+		{
+			botimport.Print(PRT_MESSAGE, "jump pad &");
+		} //end if
+		if (aasworld.areasettings[area].contents & AREACONTENTS_CLUSTERPORTAL)
+		{
+			botimport.Print(PRT_MESSAGE, "cluster portal &");
+		} //end if
+		if (aasworld.areasettings[area].contents & AREACONTENTS_VIEWPORTAL)
+		{
+			botimport.Print(PRT_MESSAGE, "view portal &");
+		} //end if
+		if (aasworld.areasettings[area].contents & AREACONTENTS_DONOTENTER)
+		{
+			botimport.Print(PRT_MESSAGE, "do not enter &");
+		} //end if
+		if (aasworld.areasettings[area].contents & AREACONTENTS_MOVER)
+		{
+			botimport.Print(PRT_MESSAGE, "mover &");
+		} //end if
+		if (!aasworld.areasettings[area].contents)
+		{
+			botimport.Print(PRT_MESSAGE, "empty");
+		} //end if
+		botimport.Print(PRT_MESSAGE, "\n");
+		botimport.Print(PRT_MESSAGE, "travel time to goal (%d) = %d\n", botlibglobals.goalareanum,
+					AAS_AreaTravelTimeToGoalArea(newarea, origin, botlibglobals.goalareanum, TFL_DEFAULT|TFL_ROCKETJUMP));
+		/*
+		VectorCopy(origin, end);
+		end[2] += 5;
+		numareas = AAS_TraceAreas(origin, end, areas, NULL, 10);
+		AAS_TraceClientBBox(origin, end, PRESENCE_CROUCH, -1);
+		botimport.Print(PRT_MESSAGE, "num areas = %d, area = %d\n", numareas, areas[0]);
+		*/
+		/*
+		botlibglobals.goalareanum = newarea;
+		VectorCopy(parm2, botlibglobals.goalorigin);
+		botimport.Print(PRT_MESSAGE, "new goal %2.1f %2.1f %2.1f area %d\n",
+								origin[0], origin[1], origin[2], newarea);
+		*/
+	} //end if
+	//*
+	flood = LibVarGetValue("bot_flood");
+	if (parm0 & 1)
+	{
+		if (flood)
+		{
+			AAS_ClearShownPolygons();
+			AAS_ClearShownDebugLines();
+			AAS_FloodAreas(parm2);
+		}
+		else
+		{
+			botlibglobals.goalareanum = newarea;
+			VectorCopy(parm2, botlibglobals.goalorigin);
+			botimport.Print(PRT_MESSAGE, "new goal %2.1f %2.1f %2.1f area %d\n",
+									origin[0], origin[1], origin[2], newarea);
+		}
+	} //end if*/
+	if (flood)
+		return 0;
+//	if (parm0 & BUTTON_USE)
+//	{
+//		botlibglobals.runai = !botlibglobals.runai;
+//		if (botlibglobals.runai) botimport.Print(PRT_MESSAGE, "started AI\n");
+//		else botimport.Print(PRT_MESSAGE, "stopped AI\n");
+		//* /
+		/*
+		goal.areanum = botlibglobals.goalareanum;
+		reachnum = BotGetReachabilityToGoal(parm2, newarea, 1,
+										ms.avoidreach, ms.avoidreachtimes,
+										&goal, TFL_DEFAULT);
+		if (!reachnum)
+		{
+			botimport.Print(PRT_MESSAGE, "goal not reachable\n");
+		} //end if
+		else
+		{
+			AAS_ReachabilityFromNum(reachnum, &reach);
+			AAS_ClearShownDebugLines();
+			AAS_ShowArea(area, qtrue);
+			AAS_ShowArea(reach.areanum, qtrue);
+			AAS_DrawCross(reach.start, 6, LINECOLOR_BLUE);
+			AAS_DrawCross(reach.end, 6, LINECOLOR_RED);
+			//
+			if ((reach.traveltype & TRAVELTYPE_MASK) == TRAVEL_ELEVATOR)
+			{
+				ElevatorBottomCenter(&reach, bottomcenter);
+				AAS_DrawCross(bottomcenter, 10, LINECOLOR_GREEN);
+			} //end if
+		} //end else*/
+//		botimport.Print(PRT_MESSAGE, "travel time to goal = %d\n",
+//					AAS_AreaTravelTimeToGoalArea(area, origin, botlibglobals.goalareanum, TFL_DEFAULT));
+//		botimport.Print(PRT_MESSAGE, "test rj from 703 to 716\n");
+//		AAS_Reachability_WeaponJump(703, 716);
+//	} //end if*/
+
+/*	face = AAS_AreaGroundFace(newarea, parm2);
+	if (face)
+	{
+		AAS_ShowFace(face - aasworld.faces);
+	} //end if*/
+	/*
+	AAS_ClearShownDebugLines();
+	AAS_ShowArea(newarea, parm0 & BUTTON_USE);
+	AAS_ShowReachableAreas(area);
+	*/
+	AAS_ClearShownPolygons();
+	AAS_ClearShownDebugLines();
+	AAS_ShowAreaPolygons(newarea, 1, parm0 & 4);
+	if (parm0 & 2) AAS_ShowReachableAreas(area);
+	else
+	{
+		static int lastgoalareanum, lastareanum;
+		static int avoidreach[MAX_AVOIDREACH];
+		static float avoidreachtimes[MAX_AVOIDREACH];
+		static int avoidreachtries[MAX_AVOIDREACH];
+		int reachnum, resultFlags;
+		bot_goal_t goal;
+		aas_reachability_t reach;
+
+		/*
+		goal.areanum = botlibglobals.goalareanum;
+		VectorCopy(botlibglobals.goalorigin, goal.origin);
+		reachnum = BotGetReachabilityToGoal(origin, newarea,
+									  lastgoalareanum, lastareanum,
+									  avoidreach, avoidreachtimes, avoidreachtries,
+									  &goal, TFL_DEFAULT|TFL_FUNCBOB|TFL_ROCKETJUMP, TFL_DEFAULT|TFL_FUNCBOB|TFL_ROCKETJUMP,
+									  NULL, 0, &resultFlags);
+		AAS_ReachabilityFromNum(reachnum, &reach);
+		AAS_ShowReachability(&reach);
+		*/
+		int curarea;
+		vec3_t curorigin;
+
+		goal.areanum = botlibglobals.goalareanum;
+		VectorCopy(botlibglobals.goalorigin, goal.origin);
+		VectorCopy(origin, curorigin);
+		curarea = newarea;
+		for ( i = 0; i < 100; i++ ) {
+			if ( curarea == goal.areanum ) {
+				break;
+			}
+			reachnum = BotGetReachabilityToGoal(curorigin, curarea,
+										  lastgoalareanum, lastareanum,
+										  avoidreach, avoidreachtimes, avoidreachtries,
+										  &goal, TFL_DEFAULT|TFL_FUNCBOB|TFL_ROCKETJUMP, TFL_DEFAULT|TFL_FUNCBOB|TFL_ROCKETJUMP,
+										  NULL, 0, &resultFlags);
+			AAS_ReachabilityFromNum(reachnum, &reach);
+			AAS_ShowReachability(&reach);
+			VectorCopy(reach.end, origin);
+			lastareanum = curarea;
+			curarea = reach.areanum;
+		}
+	} //end else
+	VectorClear(forward);
+	//BotGapDistance(origin, forward, 0);
+	/*
+	if (parm0 & BUTTON_USE)
+	{
+		botimport.Print(PRT_MESSAGE, "test rj from 703 to 716\n");
+		AAS_Reachability_WeaponJump(703, 716);
+	} //end if*/
+
+	AngleVectors(parm3, forward, right, NULL);
+	//get the eye 16 units to the right of the origin
+	VectorMA(parm2, 8, right, eye);
+	//get the eye 24 units up
+	eye[2] += 24;
+	//get the end point for the line to be traced
+	VectorMA(eye, 800, forward, end);
+
+//	AAS_TestMovementPrediction(1, parm2, forward);
+/*
+    //trace the line to find the hit point
+	trace = AAS_TraceClientBBox(eye, end, PRESENCE_NORMAL, 1);
+	if (!line[0]) line[0] = botimport.DebugLineCreate();
+	botimport.DebugLineShow(line[0], eye, trace.endpos, LINECOLOR_BLUE);
+	//
+	AAS_ClearShownDebugLines();
+	if (trace.ent)
+	{
+		ent = &aasworld.entities[trace.ent];
+		AAS_ShowBoundingBox(ent->origin, ent->mins, ent->maxs);
+	} //end if
+*/
+
+/*
+	start_time = clock();
+	for (i = 0; i < 2000; i++)
+	{
+		AAS_Trace2(eye, mins, maxs, end, 1, MASK_PLAYERSOLID);
+//		AAS_TraceClientBBox(eye, end, PRESENCE_NORMAL, 1);
+	} //end for
+	end_time = clock();
+	botimport.Print(PRT_MESSAGE, "me %lu clocks, %lu CLOCKS_PER_SEC\n", end_time - start_time, CLOCKS_PER_SEC);
+	start_time = clock();
+	for (i = 0; i < 2000; i++)
+	{
+		AAS_Trace(eye, mins, maxs, end, 1, MASK_PLAYERSOLID);
+	} //end for
+	end_time = clock();
+	botimport.Print(PRT_MESSAGE, "id %lu clocks, %lu CLOCKS_PER_SEC\n", end_time - start_time, CLOCKS_PER_SEC);
+*/
+
+    // TTimo: nested comments are BAD for gcc -Werror, use #if 0 instead..
+#if 0
+	AAS_ClearShownDebugLines();
+	//bsptrace = AAS_Trace(eye, NULL, NULL, end, 1, MASK_PLAYERSOLID);
+	bsptrace = AAS_Trace(eye, mins, maxs, end, 1, MASK_PLAYERSOLID);
+	if (!line[0]) line[0] = botimport.DebugLineCreate();
+	botimport.DebugLineShow(line[0], eye, bsptrace.endpos, LINECOLOR_YELLOW);
+	if (bsptrace.fraction < 1.0)
+	{
+		face = AAS_TraceEndFace(&trace);
+		if (face)
+		{
+			AAS_ShowFace(face - aasworld.faces);
+		} //end if
+		
+		AAS_DrawPlaneCross(bsptrace.endpos,
+									bsptrace.plane.normal,
+									bsptrace.plane.dist + bsptrace.exp_dist,
+									bsptrace.plane.type, LINECOLOR_GREEN);
+		if (trace.ent)
+		{
+			ent = &aasworld.entities[trace.ent];
+			AAS_ShowBoundingBox(ent->origin, ent->mins, ent->maxs);
+		} //end if
+	} //end if
+	//bsptrace = AAS_Trace2(eye, NULL, NULL, end, 1, MASK_PLAYERSOLID);
+	bsptrace = AAS_Trace2(eye, mins, maxs, end, 1, MASK_PLAYERSOLID);
+	botimport.DebugLineShow(line[1], eye, bsptrace.endpos, LINECOLOR_BLUE);
+	if (bsptrace.fraction < 1.0)
+	{
+		AAS_DrawPlaneCross(bsptrace.endpos,
+									bsptrace.plane.normal,
+									bsptrace.plane.dist,// + bsptrace.exp_dist,
+									bsptrace.plane.type, LINECOLOR_RED);
+		if (bsptrace.ent)
+		{
+			ent = &aasworld.entities[bsptrace.ent];
+			AAS_ShowBoundingBox(ent->origin, ent->mins, ent->maxs);
+		} //end if
+	} //end if
+#endif
+#endif
+	return 0;
+} //end of the function BotExportTest
+
+
+/*
+============
+Init_AAS_Export
+============
+*/
+static void Init_AAS_Export( aas_export_t *aas ) {
+	//--------------------------------------------
+	// be_aas_entity.c
+	//--------------------------------------------
+	aas->AAS_EntityInfo = AAS_EntityInfo;
+	//--------------------------------------------
+	// be_aas_main.c
+	//--------------------------------------------
+	aas->AAS_Initialized = AAS_Initialized;
+	aas->AAS_PresenceTypeBoundingBox = AAS_PresenceTypeBoundingBox;
+	aas->AAS_Time = AAS_Time;
+	//--------------------------------------------
+	// be_aas_sample.c
+	//--------------------------------------------
+	aas->AAS_PointAreaNum = AAS_PointAreaNum;
+	aas->AAS_PointReachabilityAreaIndex = AAS_PointReachabilityAreaIndex;
+	aas->AAS_TraceAreas = AAS_TraceAreas;
+	aas->AAS_BBoxAreas = AAS_BBoxAreas;
+	aas->AAS_AreaInfo = AAS_AreaInfo;
+	//--------------------------------------------
+	// be_aas_bspq3.c
+	//--------------------------------------------
+	aas->AAS_PointContents = AAS_PointContents;
+	aas->AAS_NextBSPEntity = AAS_NextBSPEntity;
+	aas->AAS_ValueForBSPEpairKey = AAS_ValueForBSPEpairKey;
+	aas->AAS_VectorForBSPEpairKey = AAS_VectorForBSPEpairKey;
+	aas->AAS_FloatForBSPEpairKey = AAS_FloatForBSPEpairKey;
+	aas->AAS_IntForBSPEpairKey = AAS_IntForBSPEpairKey;
+	//--------------------------------------------
+	// be_aas_reach.c
+	//--------------------------------------------
+	aas->AAS_AreaReachability = AAS_AreaReachability;
+	//--------------------------------------------
+	// be_aas_route.c
+	//--------------------------------------------
+	aas->AAS_AreaTravelTimeToGoalArea = AAS_AreaTravelTimeToGoalArea;
+	aas->AAS_EnableRoutingArea = AAS_EnableRoutingArea;
+	aas->AAS_PredictRoute = AAS_PredictRoute;
+	//--------------------------------------------
+	// be_aas_altroute.c
+	//--------------------------------------------
+	aas->AAS_AlternativeRouteGoals = AAS_AlternativeRouteGoals;
+	//--------------------------------------------
+	// be_aas_move.c
+	//--------------------------------------------
+	aas->AAS_Swimming = AAS_Swimming;
+	aas->AAS_PredictClientMovement = AAS_PredictClientMovement;
+}
+
+  
+/*
+============
+Init_EA_Export
+============
+*/
+static void Init_EA_Export( ea_export_t *ea ) {
+	//ClientCommand elementary actions
+	ea->EA_Command = EA_Command;
+	ea->EA_Say = EA_Say;
+	ea->EA_SayTeam = EA_SayTeam;
+
+	ea->EA_Action = EA_Action;
+	ea->EA_Gesture = EA_Gesture;
+	ea->EA_Talk = EA_Talk;
+	ea->EA_Attack = EA_Attack;
+	ea->EA_Alt_Attack = EA_Alt_Attack;
+	ea->EA_ForcePower = EA_ForcePower;
+	ea->EA_Use = EA_Use;
+	ea->EA_Respawn = EA_Respawn;
+	ea->EA_Crouch = EA_Crouch;
+	ea->EA_MoveUp = EA_MoveUp;
+	ea->EA_MoveDown = EA_MoveDown;
+	ea->EA_MoveForward = EA_MoveForward;
+	ea->EA_MoveBack = EA_MoveBack;
+	ea->EA_MoveLeft = EA_MoveLeft;
+	ea->EA_MoveRight = EA_MoveRight;
+
+	ea->EA_SelectWeapon = EA_SelectWeapon;
+	ea->EA_Jump = EA_Jump;
+	ea->EA_DelayedJump = EA_DelayedJump;
+	ea->EA_Move = EA_Move;
+	ea->EA_View = EA_View;
+	ea->EA_GetInput = EA_GetInput;
+	ea->EA_EndRegular = EA_EndRegular;
+	ea->EA_ResetInput = EA_ResetInput;
+}
+
+
+/*
+============
+Init_AI_Export
+============
+*/
+static void Init_AI_Export( ai_export_t *ai ) {
+	//-----------------------------------
+	// be_ai_char.h
+	//-----------------------------------
+	ai->BotLoadCharacter = BotLoadCharacter;
+	ai->BotFreeCharacter = BotFreeCharacter;
+	ai->Characteristic_Float = Characteristic_Float;
+	ai->Characteristic_BFloat = Characteristic_BFloat;
+	ai->Characteristic_Integer = Characteristic_Integer;
+	ai->Characteristic_BInteger = Characteristic_BInteger;
+	ai->Characteristic_String = Characteristic_String;
+	//-----------------------------------
+	// be_ai_chat.h
+	//-----------------------------------
+	ai->BotAllocChatState = BotAllocChatState;
+	ai->BotFreeChatState = BotFreeChatState;
+	ai->BotQueueConsoleMessage = BotQueueConsoleMessage;
+	ai->BotRemoveConsoleMessage = BotRemoveConsoleMessage;
+	ai->BotNextConsoleMessage = BotNextConsoleMessage;
+	ai->BotNumConsoleMessages = BotNumConsoleMessages;
+	ai->BotInitialChat = BotInitialChat;
+	ai->BotNumInitialChats = BotNumInitialChats;
+	ai->BotReplyChat = BotReplyChat;
+	ai->BotChatLength = BotChatLength;
+	ai->BotEnterChat = BotEnterChat;
+	ai->BotGetChatMessage = BotGetChatMessage;
+	ai->StringContains = StringContains;
+	ai->BotFindMatch = BotFindMatch;
+	ai->BotMatchVariable = BotMatchVariable;
+	ai->UnifyWhiteSpaces = UnifyWhiteSpaces;
+	ai->BotReplaceSynonyms = BotReplaceSynonyms;
+	ai->BotLoadChatFile = BotLoadChatFile;
+	ai->BotSetChatGender = BotSetChatGender;
+	ai->BotSetChatName = BotSetChatName;
+	//-----------------------------------
+	// be_ai_goal.h
+	//-----------------------------------
+	ai->BotResetGoalState = BotResetGoalState;
+	ai->BotResetAvoidGoals = BotResetAvoidGoals;
+	ai->BotRemoveFromAvoidGoals = BotRemoveFromAvoidGoals;
+	ai->BotPushGoal = BotPushGoal;
+	ai->BotPopGoal = BotPopGoal;
+	ai->BotEmptyGoalStack = BotEmptyGoalStack;
+	ai->BotDumpAvoidGoals = BotDumpAvoidGoals;
+	ai->BotDumpGoalStack = BotDumpGoalStack;
+	ai->BotGoalName = BotGoalName;
+	ai->BotGetTopGoal = BotGetTopGoal;
+	ai->BotGetSecondGoal = BotGetSecondGoal;
+	ai->BotChooseLTGItem = BotChooseLTGItem;
+	ai->BotChooseNBGItem = BotChooseNBGItem;
+	ai->BotTouchingGoal = BotTouchingGoal;
+	ai->BotItemGoalInVisButNotVisible = BotItemGoalInVisButNotVisible;
+	ai->BotGetLevelItemGoal = BotGetLevelItemGoal;
+	ai->BotGetNextCampSpotGoal = BotGetNextCampSpotGoal;
+	ai->BotGetMapLocationGoal = BotGetMapLocationGoal;
+	ai->BotAvoidGoalTime = BotAvoidGoalTime;
+	ai->BotSetAvoidGoalTime = BotSetAvoidGoalTime;
+	ai->BotInitLevelItems = BotInitLevelItems;
+	ai->BotUpdateEntityItems = BotUpdateEntityItems;
+	ai->BotLoadItemWeights = BotLoadItemWeights;
+	ai->BotFreeItemWeights = BotFreeItemWeights;
+	ai->BotInterbreedGoalFuzzyLogic = BotInterbreedGoalFuzzyLogic;
+	ai->BotSaveGoalFuzzyLogic = BotSaveGoalFuzzyLogic;
+	ai->BotMutateGoalFuzzyLogic = BotMutateGoalFuzzyLogic;
+	ai->BotAllocGoalState = BotAllocGoalState;
+	ai->BotFreeGoalState = BotFreeGoalState;
+	//-----------------------------------
+	// be_ai_move.h
+	//-----------------------------------
+	ai->BotResetMoveState = BotResetMoveState;
+	ai->BotMoveToGoal = BotMoveToGoal;
+	ai->BotMoveInDirection = BotMoveInDirection;
+	ai->BotResetAvoidReach = BotResetAvoidReach;
+	ai->BotResetLastAvoidReach = BotResetLastAvoidReach;
+	ai->BotReachabilityArea = BotReachabilityArea;
+	ai->BotMovementViewTarget = BotMovementViewTarget;
+	ai->BotPredictVisiblePosition = BotPredictVisiblePosition;
+	ai->BotAllocMoveState = BotAllocMoveState;
+	ai->BotFreeMoveState = BotFreeMoveState;
+	ai->BotInitMoveState = BotInitMoveState;
+	ai->BotAddAvoidSpot = BotAddAvoidSpot;
+	//-----------------------------------
+	// be_ai_weap.h
+	//-----------------------------------
+	ai->BotChooseBestFightWeapon = BotChooseBestFightWeapon;
+	ai->BotGetWeaponInfo = BotGetWeaponInfo;
+	ai->BotLoadWeaponWeights = BotLoadWeaponWeights;
+	ai->BotAllocWeaponState = BotAllocWeaponState;
+	ai->BotFreeWeaponState = BotFreeWeaponState;
+	ai->BotResetWeaponState = BotResetWeaponState;
+	//-----------------------------------
+	// be_ai_gen.h
+	//-----------------------------------
+	ai->GeneticParentsAndChildSelection = GeneticParentsAndChildSelection;
+}
+
+
+/*
+============
+GetBotLibAPI
+============
+*/
+botlib_export_t *GetBotLibAPI(int apiVersion, botlib_import_t *import) {
+	assert(import);   // bk001129 - this wasn't set for base/
+  botimport = *import;
+  assert(botimport.Print);   // bk001129 - pars pro toto
+
+	Com_Memset( &be_botlib_export, 0, sizeof( be_botlib_export ) );
+
+	if ( apiVersion != BOTLIB_API_VERSION ) {
+		botimport.Print( PRT_ERROR, "Mismatched BOTLIB_API_VERSION: expected %i, got %i\n", BOTLIB_API_VERSION, apiVersion );
+		return NULL;
+	}
+
+	Init_AAS_Export(&be_botlib_export.aas);
+	Init_EA_Export(&be_botlib_export.ea);
+	Init_AI_Export(&be_botlib_export.ai);
+
+	be_botlib_export.BotLibSetup = Export_BotLibSetup;
+	be_botlib_export.BotLibShutdown = Export_BotLibShutdown;
+	be_botlib_export.BotLibVarSet = Export_BotLibVarSet;
+	be_botlib_export.BotLibVarGet = Export_BotLibVarGet;
+
+	be_botlib_export.PC_AddGlobalDefine = PC_AddGlobalDefine;
+	be_botlib_export.PC_LoadSourceHandle = PC_LoadSourceHandle;
+	be_botlib_export.PC_FreeSourceHandle = PC_FreeSourceHandle;
+	be_botlib_export.PC_ReadTokenHandle = PC_ReadTokenHandle;
+	be_botlib_export.PC_SourceFileAndLine = PC_SourceFileAndLine;
+	be_botlib_export.PC_LoadGlobalDefines = PC_LoadGlobalDefines;
+	be_botlib_export.PC_RemoveAllGlobalDefines = PC_RemoveAllGlobalDefines;
+
+	be_botlib_export.BotLibStartFrame = Export_BotLibStartFrame;
+	be_botlib_export.BotLibLoadMap = Export_BotLibLoadMap;
+	be_botlib_export.BotLibUpdateEntity = Export_BotLibUpdateEntity;
+	be_botlib_export.Test = BotExportTest;
+
+	return &be_botlib_export;
+}
diff --git a/codemp/botlib/be_interface.h b/codemp/botlib/be_interface.h
new file mode 100644
index 0000000..902c3d5
--- /dev/null
+++ b/codemp/botlib/be_interface.h
@@ -0,0 +1,40 @@
+
+/*****************************************************************************
+ * name:		be_interface.h
+ *
+ * desc:		botlib interface
+ *
+ * $Archive: /source/code/botlib/be_interface.h $
+ * $Author: Mrelusive $ 
+ * $Revision: 2 $
+ * $Modtime: 10/05/99 3:32p $
+ * $Date: 10/05/99 3:42p $
+ *
+ *****************************************************************************/
+
+//#define DEBUG			//debug code
+#define RANDOMIZE		//randomize bot behaviour
+
+//FIXME: get rid of this global structure
+typedef struct botlib_globals_s
+{
+	int botlibsetup;						//true when the bot library has been setup
+	int maxentities;						//maximum number of entities
+	int maxclients;							//maximum number of clients
+	float time;								//the global time
+#ifdef DEBUG
+	qboolean debug;							//true if debug is on
+	int goalareanum;
+	vec3_t goalorigin;
+	int runai;
+#endif
+} botlib_globals_t;
+
+
+extern botlib_globals_t botlibglobals;
+extern botlib_import_t botimport;
+extern int bot_developer;					//true if developer is on
+
+//
+int Sys_MilliSeconds(void);
+
diff --git a/codemp/botlib/botlib.vcproj b/codemp/botlib/botlib.vcproj
new file mode 100644
index 0000000..567dc0f
--- /dev/null
+++ b/codemp/botlib/botlib.vcproj
@@ -0,0 +1,434 @@
+<?xml version="1.0" encoding = "Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="7.00"
+	Name="botlib"
+	SccProjectName="&quot;$/jedi/codemp/botlib&quot;, EAAAAAAA"
+	SccAuxPath=""
+	SccLocalPath="."
+	SccProvider="MSSCCI:Microsoft Visual SourceSafe">
+	<Platforms>
+		<Platform
+			Name="Win32"/>
+	</Platforms>
+	<Configurations>
+		<Configuration
+			Name="Final|Win32"
+			OutputDirectory=".\../Final"
+			IntermediateDirectory=".\../Final/botlib"
+			ConfigurationType="4"
+			UseOfMFC="0"
+			ATLMinimizesCRunTimeLibraryUsage="FALSE"
+			CharacterSet="0"
+			WholeProgramOptimization="TRUE">
+			<Tool
+				Name="VCCLCompilerTool"
+				InlineFunctionExpansion="1"
+				OptimizeForProcessor="2"
+				AdditionalIncludeDirectories="../game"
+				PreprocessorDefinitions="NDEBUG,_LIB,BOTLIB,WIN32,_JK2,FINAL_BUILD"
+				StringPooling="TRUE"
+				RuntimeLibrary="4"
+				BufferSecurityCheck="FALSE"
+				EnableFunctionLevelLinking="TRUE"
+				UsePrecompiledHeader="0"
+				PrecompiledHeaderThrough=""
+				PrecompiledHeaderFile=".\../Final/botlib/botlib.pch"
+				AssemblerListingLocation=".\../Final/botlib/"
+				ObjectFile=".\../Final/botlib/"
+				ProgramDataBaseFileName=".\../Final/botlib/"
+				WarningLevel="4"
+				SuppressStartupBanner="TRUE"
+				CompileAs="0"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLibrarianTool"
+				OutputFile=".\../Final\botlib.lib"
+				SuppressStartupBanner="TRUE"/>
+			<Tool
+				Name="VCMIDLTool"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="VCResourceCompilerTool"
+				PreprocessorDefinitions="NDebug"
+				Culture="1033"/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"/>
+		</Configuration>
+		<Configuration
+			Name="Debug|Win32"
+			OutputDirectory=".\../Debug"
+			IntermediateDirectory=".\../Debug/botlib"
+			ConfigurationType="4"
+			UseOfMFC="0"
+			ATLMinimizesCRunTimeLibraryUsage="FALSE"
+			CharacterSet="0">
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				OptimizeForProcessor="2"
+				AdditionalIncludeDirectories="../game"
+				PreprocessorDefinitions="_DEBUG,DEBUG,WIN32,_LIB,BOTLIB,_JK2"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="5"
+				EnableFunctionLevelLinking="TRUE"
+				UsePrecompiledHeader="2"
+				PrecompiledHeaderThrough=""
+				PrecompiledHeaderFile=".\../Debug/botlib/botlib.pch"
+				AssemblerListingLocation=".\../Debug/botlib/"
+				ObjectFile=".\../Debug/botlib/"
+				ProgramDataBaseFileName=".\../Debug/botlib/"
+				BrowseInformation="1"
+				WarningLevel="3"
+				SuppressStartupBanner="TRUE"
+				DebugInformationFormat="4"
+				CompileAs="0"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLibrarianTool"
+				OutputFile=".\../Debug\botlib.lib"
+				SuppressStartupBanner="TRUE"/>
+			<Tool
+				Name="VCMIDLTool"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="VCResourceCompilerTool"
+				PreprocessorDefinitions="_Debug"
+				Culture="1033"/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			OutputDirectory=".\../Release"
+			IntermediateDirectory=".\../Release/botlib"
+			ConfigurationType="4"
+			UseOfMFC="0"
+			ATLMinimizesCRunTimeLibraryUsage="FALSE"
+			CharacterSet="0">
+			<Tool
+				Name="VCCLCompilerTool"
+				InlineFunctionExpansion="1"
+				OptimizeForProcessor="2"
+				AdditionalIncludeDirectories="../game"
+				PreprocessorDefinitions="NDEBUG,WIN32,_LIB,BOTLIB,_JK2"
+				StringPooling="TRUE"
+				MinimalRebuild="TRUE"
+				RuntimeLibrary="4"
+				EnableFunctionLevelLinking="TRUE"
+				UsePrecompiledHeader="2"
+				PrecompiledHeaderThrough=""
+				PrecompiledHeaderFile=".\../Release/botlib/botlib.pch"
+				AssemblerListingLocation=".\../Release/botlib/"
+				ObjectFile=".\../Release/botlib/"
+				ProgramDataBaseFileName=".\../Release/botlib/"
+				WarningLevel="4"
+				SuppressStartupBanner="TRUE"
+				DebugInformationFormat="3"
+				CompileAs="0"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLibrarianTool"
+				OutputFile=".\../Release\botlib.lib"
+				SuppressStartupBanner="TRUE"/>
+			<Tool
+				Name="VCMIDLTool"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="VCResourceCompilerTool"
+				PreprocessorDefinitions="NDebug"
+				Culture="1033"/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"/>
+		</Configuration>
+		<Configuration
+			Name="Debug(SH)|Win32"
+			OutputDirectory="Debug(SH)"
+			IntermediateDirectory="Debug(SH)"
+			ConfigurationType="4"
+			UseOfMFC="0"
+			ATLMinimizesCRunTimeLibraryUsage="FALSE"
+			CharacterSet="0">
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				OptimizeForProcessor="2"
+				AdditionalIncludeDirectories="../game"
+				PreprocessorDefinitions="_DEBUG,DEBUG,WIN32,_LIB,BOTLIB,_JK2"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="5"
+				EnableFunctionLevelLinking="TRUE"
+				UsePrecompiledHeader="2"
+				PrecompiledHeaderThrough=""
+				PrecompiledHeaderFile=".\../Debug/botlib/botlib.pch"
+				AssemblerListingLocation=".\../Debug/botlib/"
+				ObjectFile=".\../Debug/botlib/"
+				ProgramDataBaseFileName=".\../Debug/botlib/"
+				BrowseInformation="1"
+				WarningLevel="3"
+				SuppressStartupBanner="TRUE"
+				DebugInformationFormat="4"
+				CompileAs="0"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLibrarianTool"
+				OutputFile=".\../Debug\botlib.lib"
+				SuppressStartupBanner="TRUE"/>
+			<Tool
+				Name="VCMIDLTool"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="VCResourceCompilerTool"
+				PreprocessorDefinitions="_Debug"
+				Culture="1033"/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"/>
+		</Configuration>
+	</Configurations>
+	<Files>
+		<Filter
+			Name="Source Files"
+			Filter="cpp;c;cxx;rc;def;r;odl;idl;hpj;bat">
+			<File
+				RelativePath=".\be_aas_bspq3.cpp">
+			</File>
+			<File
+				RelativePath=".\be_aas_cluster.cpp">
+			</File>
+			<File
+				RelativePath=".\be_aas_debug.cpp">
+			</File>
+			<File
+				RelativePath=".\be_aas_entity.cpp">
+			</File>
+			<File
+				RelativePath=".\be_aas_file.cpp">
+			</File>
+			<File
+				RelativePath=".\be_aas_main.cpp">
+			</File>
+			<File
+				RelativePath=".\be_aas_move.cpp">
+			</File>
+			<File
+				RelativePath=".\be_aas_optimize.cpp">
+			</File>
+			<File
+				RelativePath=".\be_aas_reach.cpp">
+			</File>
+			<File
+				RelativePath=".\be_aas_route.cpp">
+			</File>
+			<File
+				RelativePath=".\be_aas_routealt.cpp">
+			</File>
+			<File
+				RelativePath=".\be_aas_sample.cpp">
+			</File>
+			<File
+				RelativePath=".\be_ai_char.cpp">
+			</File>
+			<File
+				RelativePath=".\be_ai_chat.cpp">
+			</File>
+			<File
+				RelativePath=".\be_ai_gen.cpp">
+			</File>
+			<File
+				RelativePath=".\be_ai_goal.cpp">
+			</File>
+			<File
+				RelativePath=".\be_ai_move.cpp">
+			</File>
+			<File
+				RelativePath=".\be_ai_weap.cpp">
+			</File>
+			<File
+				RelativePath=".\be_ai_weight.cpp">
+			</File>
+			<File
+				RelativePath=".\be_ea.cpp">
+			</File>
+			<File
+				RelativePath=".\be_interface.cpp">
+			</File>
+			<File
+				RelativePath=".\l_crc.cpp">
+			</File>
+			<File
+				RelativePath=".\l_libvar.cpp">
+			</File>
+			<File
+				RelativePath=".\l_log.cpp">
+			</File>
+			<File
+				RelativePath=".\l_memory.cpp">
+			</File>
+			<File
+				RelativePath=".\l_precomp.cpp">
+			</File>
+			<File
+				RelativePath=".\l_script.cpp">
+			</File>
+			<File
+				RelativePath=".\l_struct.cpp">
+			</File>
+		</Filter>
+		<Filter
+			Name="Header Files"
+			Filter="h;hpp;hxx;hm;inl">
+			<File
+				RelativePath=".\aasfile.h">
+			</File>
+			<File
+				RelativePath="..\game\be_aas.h">
+			</File>
+			<File
+				RelativePath=".\be_aas_bsp.h">
+			</File>
+			<File
+				RelativePath=".\be_aas_cluster.h">
+			</File>
+			<File
+				RelativePath=".\be_aas_debug.h">
+			</File>
+			<File
+				RelativePath=".\be_aas_def.h">
+			</File>
+			<File
+				RelativePath=".\be_aas_entity.h">
+			</File>
+			<File
+				RelativePath=".\be_aas_file.h">
+			</File>
+			<File
+				RelativePath=".\be_aas_funcs.h">
+			</File>
+			<File
+				RelativePath=".\be_aas_main.h">
+			</File>
+			<File
+				RelativePath=".\be_aas_move.h">
+			</File>
+			<File
+				RelativePath=".\be_aas_optimize.h">
+			</File>
+			<File
+				RelativePath=".\be_aas_reach.h">
+			</File>
+			<File
+				RelativePath=".\be_aas_route.h">
+			</File>
+			<File
+				RelativePath=".\be_aas_routealt.h">
+			</File>
+			<File
+				RelativePath=".\be_aas_sample.h">
+			</File>
+			<File
+				RelativePath="..\game\be_ai_char.h">
+			</File>
+			<File
+				RelativePath="..\game\be_ai_chat.h">
+			</File>
+			<File
+				RelativePath="..\game\be_ai_gen.h">
+			</File>
+			<File
+				RelativePath="..\game\be_ai_goal.h">
+			</File>
+			<File
+				RelativePath="..\game\be_ai_move.h">
+			</File>
+			<File
+				RelativePath="..\game\be_ai_weap.h">
+			</File>
+			<File
+				RelativePath=".\be_ai_weight.h">
+			</File>
+			<File
+				RelativePath="..\game\be_ea.h">
+			</File>
+			<File
+				RelativePath=".\be_interface.h">
+			</File>
+			<File
+				RelativePath="..\game\botlib.h">
+			</File>
+			<File
+				RelativePath="..\qcommon\cm_public.h">
+			</File>
+			<File
+				RelativePath="..\qcommon\disablewarnings.h">
+			</File>
+			<File
+				RelativePath=".\l_crc.h">
+			</File>
+			<File
+				RelativePath=".\l_libvar.h">
+			</File>
+			<File
+				RelativePath=".\l_log.h">
+			</File>
+			<File
+				RelativePath=".\l_memory.h">
+			</File>
+			<File
+				RelativePath=".\l_precomp.h">
+			</File>
+			<File
+				RelativePath=".\l_script.h">
+			</File>
+			<File
+				RelativePath=".\l_struct.h">
+			</File>
+			<File
+				RelativePath=".\l_utils.h">
+			</File>
+			<File
+				RelativePath="..\game\q_shared.h">
+			</File>
+			<File
+				RelativePath="..\qcommon\qcommon.h">
+			</File>
+			<File
+				RelativePath="..\qcommon\qfiles.h">
+			</File>
+			<File
+				RelativePath="..\server\server.h">
+			</File>
+			<File
+				RelativePath="..\game\surfaceflags.h">
+			</File>
+			<File
+				RelativePath="..\qcommon\tags.h">
+			</File>
+		</Filter>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>
diff --git a/codemp/botlib/botlib.vcproj.vspscc b/codemp/botlib/botlib.vcproj.vspscc
new file mode 100644
index 0000000..794f014
--- /dev/null
+++ b/codemp/botlib/botlib.vcproj.vspscc
@@ -0,0 +1,10 @@
+""
+{
+"FILE_VERSION" = "9237"
+"ENLISTMENT_CHOICE" = "NEVER"
+"PROJECT_FILE_RELATIVE_PATH" = ""
+"NUMBER_OF_EXCLUDED_FILES" = "0"
+"ORIGINAL_PROJECT_FILE_PATH" = ""
+"NUMBER_OF_NESTED_PROJECTS" = "0"
+"SOURCE_CONTROL_SETTINGS_PROVIDER" = "PROJECT"
+}
diff --git a/codemp/botlib/l_crc.cpp b/codemp/botlib/l_crc.cpp
new file mode 100644
index 0000000..9a16233
--- /dev/null
+++ b/codemp/botlib/l_crc.cpp
@@ -0,0 +1,134 @@
+
+/*****************************************************************************
+ * name:		l_crc.c
+ *
+ * desc:		CRC calculation
+ *
+ * $Archive: /MissionPack/CODE/botlib/l_crc.c $
+ * $Author: Raduffy $ 
+ * $Revision: 1 $
+ * $Modtime: 12/20/99 8:42p $
+ * $Date: 3/08/00 11:28a $
+ *
+ *****************************************************************************/
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "../game/q_shared.h"
+#include "../game/botlib.h"
+#include "be_interface.h"			//for botimport.Print
+
+
+// FIXME: byte swap?
+
+// this is a 16 bit, non-reflected CRC using the polynomial 0x1021
+// and the initial and final xor values shown below...  in other words, the
+// CCITT standard CRC used by XMODEM
+
+#define CRC_INIT_VALUE	0xffff
+#define CRC_XOR_VALUE	0x0000
+
+unsigned short crctable[257] =
+{
+	0x0000,	0x1021,	0x2042,	0x3063,	0x4084,	0x50a5,	0x60c6,	0x70e7,
+	0x8108,	0x9129,	0xa14a,	0xb16b,	0xc18c,	0xd1ad,	0xe1ce,	0xf1ef,
+	0x1231,	0x0210,	0x3273,	0x2252,	0x52b5,	0x4294,	0x72f7,	0x62d6,
+	0x9339,	0x8318,	0xb37b,	0xa35a,	0xd3bd,	0xc39c,	0xf3ff,	0xe3de,
+	0x2462,	0x3443,	0x0420,	0x1401,	0x64e6,	0x74c7,	0x44a4,	0x5485,
+	0xa56a,	0xb54b,	0x8528,	0x9509,	0xe5ee,	0xf5cf,	0xc5ac,	0xd58d,
+	0x3653,	0x2672,	0x1611,	0x0630,	0x76d7,	0x66f6,	0x5695,	0x46b4,
+	0xb75b,	0xa77a,	0x9719,	0x8738,	0xf7df,	0xe7fe,	0xd79d,	0xc7bc,
+	0x48c4,	0x58e5,	0x6886,	0x78a7,	0x0840,	0x1861,	0x2802,	0x3823,
+	0xc9cc,	0xd9ed,	0xe98e,	0xf9af,	0x8948,	0x9969,	0xa90a,	0xb92b,
+	0x5af5,	0x4ad4,	0x7ab7,	0x6a96,	0x1a71,	0x0a50,	0x3a33,	0x2a12,
+	0xdbfd,	0xcbdc,	0xfbbf,	0xeb9e,	0x9b79,	0x8b58,	0xbb3b,	0xab1a,
+	0x6ca6,	0x7c87,	0x4ce4,	0x5cc5,	0x2c22,	0x3c03,	0x0c60,	0x1c41,
+	0xedae,	0xfd8f,	0xcdec,	0xddcd,	0xad2a,	0xbd0b,	0x8d68,	0x9d49,
+	0x7e97,	0x6eb6,	0x5ed5,	0x4ef4,	0x3e13,	0x2e32,	0x1e51,	0x0e70,
+	0xff9f,	0xefbe,	0xdfdd,	0xcffc,	0xbf1b,	0xaf3a,	0x9f59,	0x8f78,
+	0x9188,	0x81a9,	0xb1ca,	0xa1eb,	0xd10c,	0xc12d,	0xf14e,	0xe16f,
+	0x1080,	0x00a1,	0x30c2,	0x20e3,	0x5004,	0x4025,	0x7046,	0x6067,
+	0x83b9,	0x9398,	0xa3fb,	0xb3da,	0xc33d,	0xd31c,	0xe37f,	0xf35e,
+	0x02b1,	0x1290,	0x22f3,	0x32d2,	0x4235,	0x5214,	0x6277,	0x7256,
+	0xb5ea,	0xa5cb,	0x95a8,	0x8589,	0xf56e,	0xe54f,	0xd52c,	0xc50d,
+	0x34e2,	0x24c3,	0x14a0,	0x0481,	0x7466,	0x6447,	0x5424,	0x4405,
+	0xa7db,	0xb7fa,	0x8799,	0x97b8,	0xe75f,	0xf77e,	0xc71d,	0xd73c,
+	0x26d3,	0x36f2,	0x0691,	0x16b0,	0x6657,	0x7676,	0x4615,	0x5634,
+	0xd94c,	0xc96d,	0xf90e,	0xe92f,	0x99c8,	0x89e9,	0xb98a,	0xa9ab,
+	0x5844,	0x4865,	0x7806,	0x6827,	0x18c0,	0x08e1,	0x3882,	0x28a3,
+	0xcb7d,	0xdb5c,	0xeb3f,	0xfb1e,	0x8bf9,	0x9bd8,	0xabbb,	0xbb9a,
+	0x4a75,	0x5a54,	0x6a37,	0x7a16,	0x0af1,	0x1ad0,	0x2ab3,	0x3a92,
+	0xfd2e,	0xed0f,	0xdd6c,	0xcd4d,	0xbdaa,	0xad8b,	0x9de8,	0x8dc9,
+	0x7c26,	0x6c07,	0x5c64,	0x4c45,	0x3ca2,	0x2c83,	0x1ce0,	0x0cc1,
+	0xef1f,	0xff3e,	0xcf5d,	0xdf7c,	0xaf9b,	0xbfba,	0x8fd9,	0x9ff8,
+	0x6e17,	0x7e36,	0x4e55,	0x5e74,	0x2e93,	0x3eb2,	0x0ed1,	0x1ef0
+};
+
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void CRC_Init(unsigned short *crcvalue)
+{
+	*crcvalue = CRC_INIT_VALUE;
+} //end of the function CRC_Init
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void CRC_ProcessByte(unsigned short *crcvalue, byte data)
+{
+	*crcvalue = (*crcvalue << 8) ^ crctable[(*crcvalue >> 8) ^ data];
+} //end of the function CRC_ProcessByte
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+unsigned short CRC_Value(unsigned short crcvalue)
+{
+	return crcvalue ^ CRC_XOR_VALUE;
+} //end of the function CRC_Value
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+unsigned short CRC_ProcessString(unsigned char *data, int length)
+{
+	unsigned short crcvalue;
+	int i, ind;
+
+	CRC_Init(&crcvalue);
+
+	for (i = 0; i < length; i++)
+	{
+		ind = (crcvalue >> 8) ^ data[i];
+		if (ind < 0 || ind > 256) ind = 0;
+		crcvalue = (crcvalue << 8) ^ crctable[ind];
+	} //end for
+	return CRC_Value(crcvalue);
+} //end of the function CRC_ProcessString
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void CRC_ContinueProcessString(unsigned short *crc, char *data, int length)
+{
+	int i;
+
+	for (i = 0; i < length; i++)
+	{
+		*crc = (*crc << 8) ^ crctable[(*crc >> 8) ^ data[i]];
+	} //end for
+} //end of the function CRC_ProcessString
diff --git a/codemp/botlib/l_crc.h b/codemp/botlib/l_crc.h
new file mode 100644
index 0000000..2503dee
--- /dev/null
+++ b/codemp/botlib/l_crc.h
@@ -0,0 +1,16 @@
+//===========================================================================
+//
+// Name:				l_crc.h
+// Function:		for CRC checks
+// Programmer:		Mr Elusive (MrElusive@demigod.demon.nl)
+// Last update:	1997-12-31
+// Tab Size:		3
+//===========================================================================
+
+typedef unsigned short crc_t;
+
+void CRC_Init(unsigned short *crcvalue);
+void CRC_ProcessByte(unsigned short *crcvalue, byte data);
+unsigned short CRC_Value(unsigned short crcvalue);
+unsigned short CRC_ProcessString(unsigned char *data, int length);
+void CRC_ContinueProcessString(unsigned short *crc, char *data, int length);
diff --git a/codemp/botlib/l_libvar.cpp b/codemp/botlib/l_libvar.cpp
new file mode 100644
index 0000000..2e707fb
--- /dev/null
+++ b/codemp/botlib/l_libvar.cpp
@@ -0,0 +1,277 @@
+
+/*****************************************************************************
+ * name:		l_libvar.c
+ *
+ * desc:		bot library variables
+ *
+ * $Archive: /MissionPack/code/botlib/l_libvar.c $
+ * $Author: Zaphod $ 
+ * $Revision: 2 $
+ * $Modtime: 11/21/00 11:33a $
+ * $Date: 11/21/00 11:49a $
+ *
+ *****************************************************************************/
+
+#include "../game/q_shared.h"
+#include "l_memory.h"
+#include "l_libvar.h"
+
+//list with library variables
+libvar_t *libvarlist;
+
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+float LibVarStringValue(char *string)
+{
+	int dotfound = 0;
+	float value = 0;
+
+	while(*string)
+	{
+		if (*string < '0' || *string > '9')
+		{
+			if (dotfound || *string != '.')
+			{
+				return 0;
+			} //end if
+			else
+			{
+				dotfound = 10;
+				string++;
+			} //end if
+		} //end if
+		if (dotfound)
+		{
+			value = value + (float) (*string - '0') / (float) dotfound;
+			dotfound *= 10;
+		} //end if
+		else
+		{
+			value = value * 10.0 + (float) (*string - '0');
+		} //end else
+		string++;
+	} //end while
+	return value;
+} //end of the function LibVarStringValue
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+libvar_t *LibVarAlloc(char *var_name)
+{
+	libvar_t *v;
+
+	v = (libvar_t *) GetMemory(sizeof(libvar_t) + strlen(var_name) + 1);
+	Com_Memset(v, 0, sizeof(libvar_t));
+	v->name = (char *) v + sizeof(libvar_t);
+	strcpy(v->name, var_name);
+	//add the variable in the list
+	v->next = libvarlist;
+	libvarlist = v;
+	return v;
+} //end of the function LibVarAlloc
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void LibVarDeAlloc(libvar_t *v)
+{
+	if (v->string) FreeMemory(v->string);
+	FreeMemory(v);
+} //end of the function LibVarDeAlloc
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void LibVarDeAllocAll(void)
+{
+	libvar_t *v;
+
+	for (v = libvarlist; v; v = libvarlist)
+	{
+		libvarlist = libvarlist->next;
+		LibVarDeAlloc(v);
+	} //end for
+	libvarlist = NULL;
+} //end of the function LibVarDeAllocAll
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+libvar_t *LibVarGet(char *var_name)
+{
+	libvar_t *v;
+
+	for (v = libvarlist; v; v = v->next)
+	{
+		if (!Q_stricmp(v->name, var_name))
+		{
+			return v;
+		} //end if
+	} //end for
+	return NULL;
+} //end of the function LibVarGet
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+char *LibVarGetString(char *var_name)
+{
+	libvar_t *v;
+
+	v = LibVarGet(var_name);
+	if (v)
+	{
+		return v->string;
+	} //end if
+	else
+	{
+		return "";
+	} //end else
+} //end of the function LibVarGetString
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+float LibVarGetValue(char *var_name)
+{
+	libvar_t *v;
+
+	v = LibVarGet(var_name);
+	if (v)
+	{
+		return v->value;
+	} //end if
+	else
+	{
+		return 0;
+	} //end else
+} //end of the function LibVarGetValue
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+libvar_t *LibVar(char *var_name, char *value)
+{
+	libvar_t *v;
+	v = LibVarGet(var_name);
+	if (v) return v;
+	//create new variable
+	v = LibVarAlloc(var_name);
+	//variable string
+	v->string = (char *) GetMemory(strlen(value) + 1);
+	strcpy(v->string, value);
+	//the value
+	v->value = LibVarStringValue(v->string);
+	//variable is modified
+	v->modified = qtrue;
+	//
+	return v;
+} //end of the function LibVar
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+char *LibVarString(char *var_name, char *value)
+{
+	libvar_t *v;
+
+	v = LibVar(var_name, value);
+	return v->string;
+} //end of the function LibVarString
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+float LibVarValue(char *var_name, char *value)
+{
+	libvar_t *v;
+
+	v = LibVar(var_name, value);
+	return v->value;
+} //end of the function LibVarValue
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void LibVarSet(char *var_name, char *value)
+{
+	libvar_t *v;
+
+	v = LibVarGet(var_name);
+	if (v)
+	{
+		FreeMemory(v->string);
+	} //end if
+	else
+	{
+		v = LibVarAlloc(var_name);
+	} //end else
+	//variable string
+	v->string = (char *) GetMemory(strlen(value) + 1);
+	strcpy(v->string, value);
+	//the value
+	v->value = LibVarStringValue(v->string);
+	//variable is modified
+	v->modified = qtrue;
+} //end of the function LibVarSet
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+qboolean LibVarChanged(char *var_name)
+{
+	libvar_t *v;
+
+	v = LibVarGet(var_name);
+	if (v)
+	{
+		return v->modified;
+	} //end if
+	else
+	{
+		return qfalse;
+	} //end else
+} //end of the function LibVarChanged
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void LibVarSetNotModified(char *var_name)
+{
+	libvar_t *v;
+
+	v = LibVarGet(var_name);
+	if (v)
+	{
+		v->modified = qfalse;
+	} //end if
+} //end of the function LibVarSetNotModified
diff --git a/codemp/botlib/l_libvar.h b/codemp/botlib/l_libvar.h
new file mode 100644
index 0000000..5144508
--- /dev/null
+++ b/codemp/botlib/l_libvar.h
@@ -0,0 +1,46 @@
+
+/*****************************************************************************
+ * name:		l_libvar.h
+ *
+ * desc:		botlib vars
+ *
+ * $Archive: /source/code/botlib/l_libvar.h $
+ * $Author: Mrelusive $ 
+ * $Revision: 2 $
+ * $Modtime: 10/05/99 3:32p $
+ * $Date: 10/05/99 3:42p $
+ *
+ *****************************************************************************/
+
+//library variable
+typedef struct libvar_s
+{
+	char		*name;
+	char		*string;
+	int		flags;
+	qboolean	modified;	// set each time the cvar is changed
+	float		value;
+	struct	libvar_s *next;
+} libvar_t;
+
+//removes all library variables
+void LibVarDeAllocAll(void);
+//gets the library variable with the given name
+libvar_t *LibVarGet(char *var_name);
+//gets the string of the library variable with the given name
+char *LibVarGetString(char *var_name);
+//gets the value of the library variable with the given name
+float LibVarGetValue(char *var_name);
+//creates the library variable if not existing already and returns it
+libvar_t *LibVar(char *var_name, char *value);
+//creates the library variable if not existing already and returns the value
+float LibVarValue(char *var_name, char *value);
+//creates the library variable if not existing already and returns the value string
+char *LibVarString(char *var_name, char *value);
+//sets the library variable
+void LibVarSet(char *var_name, char *value);
+//returns true if the library variable has been modified
+qboolean LibVarChanged(char *var_name);
+//sets the library variable to unmodified
+void LibVarSetNotModified(char *var_name);
+
diff --git a/codemp/botlib/l_log.cpp b/codemp/botlib/l_log.cpp
new file mode 100644
index 0000000..8d20fbc
--- /dev/null
+++ b/codemp/botlib/l_log.cpp
@@ -0,0 +1,152 @@
+
+/*****************************************************************************
+ * name:		l_log.c
+ *
+ * desc:		log file
+ *
+ * $Archive: /MissionPack/CODE/botlib/l_log.c $
+ * $Author: Raduffy $ 
+ * $Revision: 1 $
+ * $Modtime: 12/20/99 8:43p $
+ * $Date: 3/08/00 11:28a $
+ *
+ *****************************************************************************/
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "../game/q_shared.h"
+#include "../game/botlib.h"
+#include "be_interface.h"			//for botimport.Print
+#include "l_libvar.h"
+
+#define MAX_LOGFILENAMESIZE		1024
+
+typedef struct logfile_s
+{
+	char filename[MAX_LOGFILENAMESIZE];
+	FILE *fp;
+	int numwrites;
+} logfile_t;
+
+static logfile_t logfile;
+
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void Log_Open(char *filename)
+{
+	if (!LibVarValue("log", "0")) return;
+	if (!filename || !strlen(filename))
+	{
+		botimport.Print(PRT_MESSAGE, "openlog <filename>\n");
+		return;
+	} //end if
+	if (logfile.fp)
+	{
+		botimport.Print(PRT_ERROR, "log file %s is already opened\n", logfile.filename);
+		return;
+	} //end if
+	logfile.fp = fopen(filename, "wb");
+	if (!logfile.fp)
+	{
+		botimport.Print(PRT_ERROR, "can't open the log file %s\n", filename);
+		return;
+	} //end if
+	strncpy(logfile.filename, filename, MAX_LOGFILENAMESIZE);
+	botimport.Print(PRT_MESSAGE, "Opened log %s\n", logfile.filename);
+} //end of the function Log_Create
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void Log_Close(void)
+{
+	if (!logfile.fp) return;
+	if (fclose(logfile.fp))
+	{
+		botimport.Print(PRT_ERROR, "can't close log file %s\n", logfile.filename);
+		return;
+	} //end if
+	logfile.fp = NULL;
+	botimport.Print(PRT_MESSAGE, "Closed log %s\n", logfile.filename);
+} //end of the function Log_Close
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void Log_Shutdown(void)
+{
+	if (logfile.fp) Log_Close();
+} //end of the function Log_Shutdown
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void QDECL Log_Write(char *fmt, ...)
+{
+	va_list ap;
+
+	if (!logfile.fp) return;
+	va_start(ap, fmt);
+	vfprintf(logfile.fp, fmt, ap);
+	va_end(ap);
+	//fprintf(logfile.fp, "\r\n");
+	fflush(logfile.fp);
+} //end of the function Log_Write
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void QDECL Log_WriteTimeStamped(char *fmt, ...)
+{
+	va_list ap;
+
+	if (!logfile.fp) return;
+	fprintf(logfile.fp, "%d   %02d:%02d:%02d:%02d   ",
+					logfile.numwrites,
+					(int) (botlibglobals.time / 60 / 60),
+					(int) (botlibglobals.time / 60),
+					(int) (botlibglobals.time),
+					(int) ((int) (botlibglobals.time * 100)) -
+							((int) botlibglobals.time) * 100);
+	va_start(ap, fmt);
+	vfprintf(logfile.fp, fmt, ap);
+	va_end(ap);
+	fprintf(logfile.fp, "\r\n");
+	logfile.numwrites++;
+	fflush(logfile.fp);
+} //end of the function Log_Write
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+FILE *Log_FilePointer(void)
+{
+	return logfile.fp;
+} //end of the function Log_FilePointer
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void Log_Flush(void)
+{
+	if (logfile.fp) fflush(logfile.fp);
+} //end of the function Log_Flush
+
diff --git a/codemp/botlib/l_log.h b/codemp/botlib/l_log.h
new file mode 100644
index 0000000..349bb71
--- /dev/null
+++ b/codemp/botlib/l_log.h
@@ -0,0 +1,29 @@
+
+/*****************************************************************************
+ * name:		l_log.h
+ *
+ * desc:		log file
+ *
+ * $Archive: /source/code/botlib/l_log.h $
+ * $Author: Mrelusive $ 
+ * $Revision: 2 $
+ * $Modtime: 10/05/99 3:32p $
+ * $Date: 10/05/99 3:42p $
+ *
+ *****************************************************************************/
+
+//open a log file
+void Log_Open(char *filename);
+//close the current log file
+void Log_Close(void);
+//close log file if present
+void Log_Shutdown(void);
+//write to the current opened log file
+void QDECL Log_Write(char *fmt, ...);
+//write to the current opened log file with a time stamp
+void QDECL Log_WriteTimeStamped(char *fmt, ...);
+//returns a pointer to the log file
+FILE *Log_FilePointer(void);
+//flush log file
+void Log_Flush(void);
+
diff --git a/codemp/botlib/l_memory.cpp b/codemp/botlib/l_memory.cpp
new file mode 100644
index 0000000..c56d893
--- /dev/null
+++ b/codemp/botlib/l_memory.cpp
@@ -0,0 +1,446 @@
+
+/*****************************************************************************
+ * name:		l_memory.c
+ *
+ * desc:		memory allocation
+ *
+ * $Archive: /MissionPack/code/botlib/l_memory.c $
+ * $Author: Ttimo $ 
+ * $Revision: 6 $
+ * $Modtime: 4/22/01 8:52a $
+ * $Date: 4/22/01 8:52a $
+ *
+ *****************************************************************************/
+
+#include "../game/q_shared.h"
+#include "../game/botlib.h"
+#include "l_log.h"
+#include "be_interface.h"
+
+//#define MEMDEBUG
+//#define MEMORYMANEGER
+
+#define MEM_ID		0x12345678l
+#define HUNK_ID		0x87654321l
+
+int allocatedmemory;
+int totalmemorysize;
+int numblocks;
+
+#ifdef MEMORYMANEGER
+
+typedef struct memoryblock_s
+{
+	unsigned long int id;
+	void *ptr;
+	int size;
+#ifdef MEMDEBUG
+	char *label;
+	char *file;
+	int line;
+#endif //MEMDEBUG
+	struct memoryblock_s *prev, *next;
+} memoryblock_t;
+
+memoryblock_t *memory;
+
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+void LinkMemoryBlock(memoryblock_t *block)
+{
+	block->prev = NULL;
+	block->next = memory;
+	if (memory) memory->prev = block;
+	memory = block;
+} //end of the function LinkMemoryBlock
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+void UnlinkMemoryBlock(memoryblock_t *block)
+{
+	if (block->prev) block->prev->next = block->next;
+	else memory = block->next;
+	if (block->next) block->next->prev = block->prev;
+} //end of the function UnlinkMemoryBlock
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+#ifdef MEMDEBUG
+void *GetMemoryDebug(unsigned long size, char *label, char *file, int line)
+#else
+void *GetMemory(unsigned long size)
+#endif //MEMDEBUG
+{
+	void *ptr;
+	memoryblock_t *block;
+  assert(botimport.GetMemory); // bk001129 - was NULL'ed
+	ptr = botimport.GetMemory(size + sizeof(memoryblock_t));
+	block = (memoryblock_t *) ptr;
+	block->id = MEM_ID;
+	block->ptr = (char *) ptr + sizeof(memoryblock_t);
+	block->size = size + sizeof(memoryblock_t);
+#ifdef MEMDEBUG
+	block->label = label;
+	block->file = file;
+	block->line = line;
+#endif //MEMDEBUG
+	LinkMemoryBlock(block);
+	allocatedmemory += block->size;
+	totalmemorysize += block->size + sizeof(memoryblock_t);
+	numblocks++;
+	return block->ptr;
+} //end of the function GetMemoryDebug
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+#ifdef MEMDEBUG
+void *GetClearedMemoryDebug(unsigned long size, char *label, char *file, int line)
+#else
+void *GetClearedMemory(unsigned long size)
+#endif //MEMDEBUG
+{
+	void *ptr;
+#ifdef MEMDEBUG
+	ptr = GetMemoryDebug(size, label, file, line);
+#else
+	ptr = GetMemory(size);
+#endif //MEMDEBUG
+	Com_Memset(ptr, 0, size);
+	return ptr;
+} //end of the function GetClearedMemory
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+#ifdef MEMDEBUG
+void *GetHunkMemoryDebug(unsigned long size, char *label, char *file, int line)
+#else
+void *GetHunkMemory(unsigned long size)
+#endif //MEMDEBUG
+{
+	void *ptr;
+	memoryblock_t *block;
+
+	ptr = botimport.HunkAlloc(size + sizeof(memoryblock_t));
+	block = (memoryblock_t *) ptr;
+	block->id = HUNK_ID;
+	block->ptr = (char *) ptr + sizeof(memoryblock_t);
+	block->size = size + sizeof(memoryblock_t);
+#ifdef MEMDEBUG
+	block->label = label;
+	block->file = file;
+	block->line = line;
+#endif //MEMDEBUG
+	LinkMemoryBlock(block);
+	allocatedmemory += block->size;
+	totalmemorysize += block->size + sizeof(memoryblock_t);
+	numblocks++;
+	return block->ptr;
+} //end of the function GetHunkMemoryDebug
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+#ifdef MEMDEBUG
+void *GetClearedHunkMemoryDebug(unsigned long size, char *label, char *file, int line)
+#else
+void *GetClearedHunkMemory(unsigned long size)
+#endif //MEMDEBUG
+{
+	void *ptr;
+#ifdef MEMDEBUG
+	ptr = GetHunkMemoryDebug(size, label, file, line);
+#else
+	ptr = GetHunkMemory(size);
+#endif //MEMDEBUG
+	Com_Memset(ptr, 0, size);
+	return ptr;
+} //end of the function GetClearedHunkMemory
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+memoryblock_t *BlockFromPointer(void *ptr, char *str)
+{
+	memoryblock_t *block;
+
+	if (!ptr)
+	{
+#ifdef MEMDEBUG
+		//char *crash = (char *) NULL;
+		//crash[0] = 1;
+		botimport.Print(PRT_FATAL, "%s: NULL pointer\n", str);
+#endif // MEMDEBUG
+		return NULL;
+	} //end if
+	block = (memoryblock_t *) ((char *) ptr - sizeof(memoryblock_t));
+	if (block->id != MEM_ID && block->id != HUNK_ID)
+	{
+		botimport.Print(PRT_FATAL, "%s: invalid memory block\n", str);
+		return NULL;
+	} //end if
+	if (block->ptr != ptr)
+	{
+		botimport.Print(PRT_FATAL, "%s: memory block pointer invalid\n", str);
+		return NULL;
+	} //end if
+	return block;
+} //end of the function BlockFromPointer
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+void FreeMemory(void *ptr)
+{
+	memoryblock_t *block;
+
+	block = BlockFromPointer(ptr, "FreeMemory");
+	if (!block) return;
+	UnlinkMemoryBlock(block);
+	allocatedmemory -= block->size;
+	totalmemorysize -= block->size + sizeof(memoryblock_t);
+	numblocks--;
+	//
+	if (block->id == MEM_ID)
+	{
+		botimport.FreeMemory(block);
+	} //end if
+} //end of the function FreeMemory
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+int AvailableMemory(void)
+{
+	return botimport.AvailableMemory();
+} //end of the function AvailableMemory
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+int MemoryByteSize(void *ptr)
+{
+	memoryblock_t *block;
+
+	block = BlockFromPointer(ptr, "MemoryByteSize");
+	if (!block) return 0;
+	return block->size;
+} //end of the function MemoryByteSize
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+void PrintUsedMemorySize(void)
+{
+	botimport.Print(PRT_MESSAGE, "total allocated memory: %d KB\n", allocatedmemory >> 10);
+	botimport.Print(PRT_MESSAGE, "total botlib memory: %d KB\n", totalmemorysize >> 10);
+	botimport.Print(PRT_MESSAGE, "total memory blocks: %d\n", numblocks);
+} //end of the function PrintUsedMemorySize
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+void PrintMemoryLabels(void)
+{
+	memoryblock_t *block;
+	int i;
+
+	PrintUsedMemorySize();
+	i = 0;
+	Log_Write("============= Botlib memory log ==============\r\n");
+	Log_Write("\r\n");
+	for (block = memory; block; block = block->next)
+	{
+#ifdef MEMDEBUG
+		if (block->id == HUNK_ID)
+		{
+			Log_Write("%6d, hunk %p, %8d: %24s line %6d: %s\r\n", i, block->ptr, block->size, block->file, block->line, block->label);
+		} //end if
+		else
+		{
+			Log_Write("%6d,      %p, %8d: %24s line %6d: %s\r\n", i, block->ptr, block->size, block->file, block->line, block->label);
+		} //end else
+#endif //MEMDEBUG
+		i++;
+	} //end for
+} //end of the function PrintMemoryLabels
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+void DumpMemory(void)
+{
+	memoryblock_t *block;
+
+	for (block = memory; block; block = memory)
+	{
+		FreeMemory(block->ptr);
+	} //end for
+	totalmemorysize = 0;
+	allocatedmemory = 0;
+} //end of the function DumpMemory
+
+#else
+
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+#ifdef MEMDEBUG
+void *GetMemoryDebug(unsigned long size, char *label, char *file, int line)
+#else
+void *GetMemory(unsigned long size)
+#endif //MEMDEBUG
+{
+	void *ptr;
+	unsigned long int *memid;
+
+	ptr = botimport.GetMemory(size + sizeof(unsigned long int));
+	if (!ptr) return NULL;
+	memid = (unsigned long int *) ptr;
+	*memid = MEM_ID;
+	return (unsigned long int *) ((char *) ptr + sizeof(unsigned long int));
+} //end of the function GetMemory
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+#ifdef MEMDEBUG
+void *GetClearedMemoryDebug(unsigned long size, char *label, char *file, int line)
+#else
+void *GetClearedMemory(unsigned long size)
+#endif //MEMDEBUG
+{
+	void *ptr;
+#ifdef MEMDEBUG
+	ptr = GetMemoryDebug(size, label, file, line);
+#else
+	ptr = GetMemory(size);
+#endif //MEMDEBUG
+	Com_Memset(ptr, 0, size);
+	return ptr;
+} //end of the function GetClearedMemory
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+#ifdef MEMDEBUG
+void *GetHunkMemoryDebug(unsigned long size, char *label, char *file, int line)
+#else
+void *GetHunkMemory(unsigned long size)
+#endif //MEMDEBUG
+{
+	void *ptr;
+	unsigned long int *memid;
+
+	ptr = botimport.HunkAlloc(size + sizeof(unsigned long int));
+	if (!ptr) return NULL;
+	memid = (unsigned long int *) ptr;
+	*memid = HUNK_ID;
+	return (unsigned long int *) ((char *) ptr + sizeof(unsigned long int));
+} //end of the function GetHunkMemory
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+#ifdef MEMDEBUG
+void *GetClearedHunkMemoryDebug(unsigned long size, char *label, char *file, int line)
+#else
+void *GetClearedHunkMemory(unsigned long size)
+#endif //MEMDEBUG
+{
+	void *ptr;
+#ifdef MEMDEBUG
+	ptr = GetHunkMemoryDebug(size, label, file, line);
+#else
+	ptr = GetHunkMemory(size);
+#endif //MEMDEBUG
+	Com_Memset(ptr, 0, size);
+	return ptr;
+} //end of the function GetClearedHunkMemory
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+void FreeMemory(void *ptr)
+{
+	unsigned long int *memid;
+
+	memid = (unsigned long int *) ((char *) ptr - sizeof(unsigned long int));
+
+	if (*memid == MEM_ID)
+	{
+		botimport.FreeMemory(memid);
+	} //end if
+} //end of the function FreeMemory
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+int AvailableMemory(void)
+{
+	return botimport.AvailableMemory();
+} //end of the function AvailableMemory
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+void PrintUsedMemorySize(void)
+{
+} //end of the function PrintUsedMemorySize
+//===========================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//===========================================================================
+void PrintMemoryLabels(void)
+{
+} //end of the function PrintMemoryLabels
+
+#endif
diff --git a/codemp/botlib/l_memory.h b/codemp/botlib/l_memory.h
new file mode 100644
index 0000000..c84965a
--- /dev/null
+++ b/codemp/botlib/l_memory.h
@@ -0,0 +1,59 @@
+
+/*****************************************************************************
+ * name:		l_memory.h
+ *
+ * desc:		memory management
+ *
+ * $Archive: /source/code/botlib/l_memory.h $
+ * $Author: Mrelusive $ 
+ * $Revision: 2 $
+ * $Modtime: 10/05/99 3:32p $
+ * $Date: 10/05/99 3:42p $
+ *
+ *****************************************************************************/
+
+//#define MEMDEBUG
+
+#ifdef MEMDEBUG
+#define GetMemory(size)				GetMemoryDebug(size, #size, __FILE__, __LINE__);
+#define GetClearedMemory(size)		GetClearedMemoryDebug(size, #size, __FILE__, __LINE__);
+//allocate a memory block of the given size
+void *GetMemoryDebug(unsigned long size, char *label, char *file, int line);
+//allocate a memory block of the given size and clear it
+void *GetClearedMemoryDebug(unsigned long size, char *label, char *file, int line);
+//
+#define GetHunkMemory(size)			GetHunkMemoryDebug(size, #size, __FILE__, __LINE__);
+#define GetClearedHunkMemory(size)	GetClearedHunkMemoryDebug(size, #size, __FILE__, __LINE__);
+//allocate a memory block of the given size
+void *GetHunkMemoryDebug(unsigned long size, char *label, char *file, int line);
+//allocate a memory block of the given size and clear it
+void *GetClearedHunkMemoryDebug(unsigned long size, char *label, char *file, int line);
+#else
+//allocate a memory block of the given size
+void *GetMemory(unsigned long size);
+//allocate a memory block of the given size and clear it
+void *GetClearedMemory(unsigned long size);
+//
+#ifdef BSPC
+#define GetHunkMemory GetMemory
+#define GetClearedHunkMemory GetClearedMemory
+#else
+//allocate a memory block of the given size
+void *GetHunkMemory(unsigned long size);
+//allocate a memory block of the given size and clear it
+void *GetClearedHunkMemory(unsigned long size);
+#endif
+#endif
+
+//free the given memory block
+void FreeMemory(void *ptr);
+//returns the amount available memory
+int AvailableMemory(void);
+//prints the total used memory size
+void PrintUsedMemorySize(void);
+//print all memory blocks with label
+void PrintMemoryLabels(void);
+//returns the size of the memory block in bytes
+int MemoryByteSize(void *ptr);
+//free all allocated memory
+void DumpMemory(void);
diff --git a/codemp/botlib/l_precomp.cpp b/codemp/botlib/l_precomp.cpp
new file mode 100644
index 0000000..64bb052
--- /dev/null
+++ b/codemp/botlib/l_precomp.cpp
@@ -0,0 +1,3324 @@
+// Copyright (C) 1999-2000 Id Software, Inc.
+//
+
+/*****************************************************************************
+ * name:		l_precomp.c
+ *
+ * desc:		pre compiler
+ *
+ * $Archive: /MissionPack/code/botlib/l_precomp.c $
+ * $Author: Ttimo $ 
+ * $Revision: 20 $
+ * $Modtime: 5/15/01 4:10a $
+ * $Date: 5/15/01 4:10a $
+ *
+ *****************************************************************************/
+
+//Notes:			fix: PC_StringizeTokens
+
+//#define SCREWUP
+//#define BOTLIB
+//#define QUAKE
+//#define QUAKEC
+//#define MEQCC
+
+#ifdef SCREWUP
+#include <stdio.h>
+#include <stdlib.h>
+#include <limits.h>
+#include <string.h>
+#include <stdarg.h>
+#include <time.h>
+#include "l_memory.h"
+#include "l_script.h"
+#include "l_precomp.h"
+
+typedef enum {qfalse, qtrue}	qboolean;
+#endif //SCREWUP
+
+#ifdef BOTLIB
+#include "../game/q_shared.h"
+#include "../game/botlib.h"
+#include "be_interface.h"
+#include "l_memory.h"
+#include "l_script.h"
+#include "l_precomp.h"
+#include "l_log.h"
+#endif //BOTLIB
+
+#ifdef MEQCC
+#include "qcc.h"
+#include "time.h"   //time & ctime
+#include "math.h"   //fabs
+#include "l_memory.h"
+#include "l_script.h"
+#include "l_precomp.h"
+#include "l_log.h"
+
+#define qtrue	true
+#define qfalse	false
+#endif //MEQCC
+
+#ifdef BSPC
+//include files for usage in the BSP Converter
+#include "../bspc/qbsp.h"
+#include "../bspc/l_log.h"
+#include "../bspc/l_mem.h"
+#include "l_precomp.h"
+
+#define qtrue	true
+#define qfalse	false
+#define Q_stricmp	stricmp
+
+#endif //BSPC
+
+#if defined(QUAKE) && !defined(BSPC)
+#include "l_utils.h"
+#endif //QUAKE
+
+//#define DEBUG_EVAL
+
+#define MAX_DEFINEPARMS			128
+
+#define DEFINEHASHING			1
+
+//directive name with parse function
+typedef struct directive_s
+{
+	char *name;
+	int (*func)(source_t *source);
+} directive_t;
+
+#define DEFINEHASHSIZE		1024
+
+#define TOKEN_HEAP_SIZE		4096
+
+int numtokens;
+/*
+int tokenheapinitialized;				//true when the token heap is initialized
+token_t token_heap[TOKEN_HEAP_SIZE];	//heap with tokens
+token_t *freetokens;					//free tokens from the heap
+*/
+
+//list with global defines added to every source loaded
+#if DEFINEHASHING
+define_t	**globaldefines = NULL;
+#else
+define_t	*globaldefines = NULL;
+#endif
+qboolean	addGlobalDefine = qfalse;
+
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+void QDECL SourceError(source_t *source, char *str, ...)
+{
+	char text[1024];
+	va_list ap;
+
+	va_start(ap, str);
+	vsprintf(text, str, ap);
+	va_end(ap);
+#ifdef BOTLIB
+	botimport.Print(PRT_ERROR, "file %s, line %d: %s\n", source->scriptstack->filename, source->scriptstack->line, text);
+#endif	//BOTLIB
+#ifdef MEQCC
+	printf("error: file %s, line %d: %s\n", source->scriptstack->filename, source->scriptstack->line, text);
+#endif //MEQCC
+#ifdef BSPC
+	Log_Print("error: file %s, line %d: %s\n", source->scriptstack->filename, source->scriptstack->line, text);
+#endif //BSPC
+} //end of the function SourceError
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void QDECL SourceWarning(source_t *source, char *str, ...)
+{
+	char text[1024];
+	va_list ap;
+
+	va_start(ap, str);
+	vsprintf(text, str, ap);
+	va_end(ap);
+#ifdef BOTLIB
+	botimport.Print(PRT_WARNING, "file %s, line %d: %s\n", source->scriptstack->filename, source->scriptstack->line, text);
+#endif //BOTLIB
+#ifdef MEQCC
+	printf("warning: file %s, line %d: %s\n", source->scriptstack->filename, source->scriptstack->line, text);
+#endif //MEQCC
+#ifdef BSPC
+	Log_Print("warning: file %s, line %d: %s\n", source->scriptstack->filename, source->scriptstack->line, text);
+#endif //BSPC
+} //end of the function ScriptWarning
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+void PC_PushIndent(source_t *source, int type, int skip)
+{
+	indent_t *indent;
+
+	indent = (indent_t *) GetMemory(sizeof(indent_t));
+	indent->type = type;
+	indent->script = source->scriptstack;
+	indent->skip = (skip != 0);
+	source->skip += indent->skip;
+	indent->next = source->indentstack;
+	source->indentstack = indent;
+} //end of the function PC_PushIndent
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+void PC_PopIndent(source_t *source, int *type, int *skip)
+{
+	indent_t *indent;
+
+	*type = 0;
+	*skip = 0;
+
+	indent = source->indentstack;
+	if (!indent) return;
+
+	//must be an indent from the current script
+	if (source->indentstack->script != source->scriptstack) return;
+
+	*type = indent->type;
+	*skip = indent->skip;
+	source->indentstack = source->indentstack->next;
+	source->skip -= indent->skip;
+	FreeMemory(indent);
+} //end of the function PC_PopIndent
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+void PC_PushScript(source_t *source, script_t *script)
+{
+	script_t *s;
+
+	for (s = source->scriptstack; s; s = s->next)
+	{
+		if (!Q_stricmp(s->filename, script->filename))
+		{
+			SourceError(source, "%s recursively included", script->filename);
+			return;
+		} //end if
+	} //end for
+	//push the script on the script stack
+	script->next = source->scriptstack;
+	source->scriptstack = script;
+} //end of the function PC_PushScript
+//============================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//============================================================================
+void PC_InitTokenHeap(void)
+{
+	/*
+	int i;
+
+	if (tokenheapinitialized) return;
+	freetokens = NULL;
+	for (i = 0; i < TOKEN_HEAP_SIZE; i++)
+	{
+		token_heap[i].next = freetokens;
+		freetokens = &token_heap[i];
+	} //end for
+	tokenheapinitialized = qtrue;
+	*/
+} //end of the function PC_InitTokenHeap
+//============================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//============================================================================
+token_t *PC_CopyToken(token_t *token)
+{
+	token_t *t;
+
+//	t = (token_t *) malloc(sizeof(token_t));
+	t = (token_t *) GetMemory(sizeof(token_t));
+//	t = freetokens;
+	if (!t)
+	{
+#ifdef BSPC
+		Error("out of token space\n");
+#else
+		Com_Error(ERR_FATAL, "out of token space\n");
+#endif
+		return NULL;
+	} //end if
+//	freetokens = freetokens->next;
+	Com_Memcpy(t, token, sizeof(token_t));
+	t->next = NULL;
+	numtokens++;
+	return t;
+} //end of the function PC_CopyToken
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+void PC_FreeToken(token_t *token)
+{
+	//free(token);
+	FreeMemory(token);
+//	token->next = freetokens;
+//	freetokens = token;
+	numtokens--;
+} //end of the function PC_FreeToken
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+int PC_ReadSourceToken(source_t *source, token_t *token)
+{
+	token_t *t;
+	script_t *script;
+	int type, skip;
+
+	//if there's no token already available
+	while(!source->tokens)
+	{
+		//if there's a token to read from the script
+		if (PS_ReadToken(source->scriptstack, token)) return qtrue;
+		//if at the end of the script
+		if (EndOfScript(source->scriptstack))
+		{
+			//remove all indents of the script
+			while(source->indentstack &&
+					source->indentstack->script == source->scriptstack)
+			{
+				SourceWarning(source, "missing #endif");
+				PC_PopIndent(source, &type, &skip);
+			} //end if
+		} //end if
+		//if this was the initial script
+		if (!source->scriptstack->next) return qfalse;
+		//remove the script and return to the last one
+		script = source->scriptstack;
+		source->scriptstack = source->scriptstack->next;
+		FreeScript(script);
+	} //end while
+	//copy the already available token
+	Com_Memcpy(token, source->tokens, sizeof(token_t));
+	//free the read token
+	t = source->tokens;
+	source->tokens = source->tokens->next;
+	PC_FreeToken(t);
+	return qtrue;
+} //end of the function PC_ReadSourceToken
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+int PC_UnreadSourceToken(source_t *source, token_t *token)
+{
+	token_t *t;
+
+	t = PC_CopyToken(token);
+	t->next = source->tokens;
+	source->tokens = t;
+	return qtrue;
+} //end of the function PC_UnreadSourceToken
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+int PC_ReadDefineParms(source_t *source, define_t *define, token_t **parms, int maxparms)
+{
+	token_t token, *t, *last;
+	int i, done, lastcomma, numparms, indent;
+
+	if (!PC_ReadSourceToken(source, &token))
+	{
+		SourceError(source, "define %s missing parms", define->name);
+		return qfalse;
+	} //end if
+	//
+	if (define->numparms > maxparms)
+	{
+		SourceError(source, "define with more than %d parameters", maxparms);
+		return qfalse;
+	} //end if
+	//
+	for (i = 0; i < define->numparms; i++) parms[i] = NULL;
+	//if no leading "("
+	if (strcmp(token.string, "("))
+	{
+		PC_UnreadSourceToken(source, &token);
+		SourceError(source, "define %s missing parms", define->name);
+		return qfalse;
+	} //end if
+	//read the define parameters
+	for (done = 0, numparms = 0, indent = 0; !done;)
+	{
+		if (numparms >= maxparms)
+		{
+			SourceError(source, "define %s with too many parms", define->name);
+			return qfalse;
+		} //end if
+		if (numparms >= define->numparms)
+		{
+			SourceWarning(source, "define %s has too many parms", define->name);
+			return qfalse;
+		} //end if
+		parms[numparms] = NULL;
+		lastcomma = 1;
+		last = NULL;
+		while(!done)
+		{
+			//
+			if (!PC_ReadSourceToken(source, &token))
+			{
+				SourceError(source, "define %s incomplete", define->name);
+				return qfalse;
+			} //end if
+			//
+			if (!strcmp(token.string, ","))
+			{
+				if (indent <= 0)
+				{
+					if (lastcomma) SourceWarning(source, "too many comma's");
+					lastcomma = 1;
+					break;
+				} //end if
+			} //end if
+			lastcomma = 0;
+			//
+			if (!strcmp(token.string, "("))
+			{
+				indent++;
+				continue;
+			} //end if
+			else if (!strcmp(token.string, ")"))
+			{
+				if (--indent <= 0)
+				{
+					if (!parms[define->numparms-1])
+					{
+						SourceWarning(source, "too few define parms");
+					} //end if
+					done = 1;
+					break;
+				} //end if
+			} //end if
+			//
+			if (numparms < define->numparms)
+			{
+				//
+				t = PC_CopyToken(&token);
+				t->next = NULL;
+				if (last) last->next = t;
+				else parms[numparms] = t;
+				last = t;
+			} //end if
+		} //end while
+		numparms++;
+	} //end for
+	return qtrue;
+} //end of the function PC_ReadDefineParms
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+int PC_StringizeTokens(token_t *tokens, token_t *token)
+{
+	token_t *t;
+
+	token->type = TT_STRING;
+	token->whitespace_p = NULL;
+	token->endwhitespace_p = NULL;
+	token->string[0] = '\0';
+	strcat(token->string, "\"");
+	for (t = tokens; t; t = t->next)
+	{
+		strncat(token->string, t->string, MAX_TOKEN - strlen(token->string));
+	} //end for
+	strncat(token->string, "\"", MAX_TOKEN - strlen(token->string));
+	return qtrue;
+} //end of the function PC_StringizeTokens
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+int PC_MergeTokens(token_t *t1, token_t *t2)
+{
+	//merging of a name with a name or number
+	if (t1->type == TT_NAME && (t2->type == TT_NAME || t2->type == TT_NUMBER))
+	{
+		strcat(t1->string, t2->string);
+		return qtrue;
+	} //end if
+	//merging of two strings
+	if (t1->type == TT_STRING && t2->type == TT_STRING)
+	{
+		//remove trailing double quote
+		t1->string[strlen(t1->string)-1] = '\0';
+		//concat without leading double quote
+		strcat(t1->string, &t2->string[1]);
+		return qtrue;
+	} //end if
+	//FIXME: merging of two number of the same sub type
+	return qfalse;
+} //end of the function PC_MergeTokens
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+/*
+void PC_PrintDefine(define_t *define)
+{
+	printf("define->name = %s\n", define->name);
+	printf("define->flags = %d\n", define->flags);
+	printf("define->builtin = %d\n", define->builtin);
+	printf("define->numparms = %d\n", define->numparms);
+//	token_t *parms;					//define parameters
+//	token_t *tokens;					//macro tokens (possibly containing parm tokens)
+//	struct define_s *next;			//next defined macro in a list
+} //end of the function PC_PrintDefine*/
+#if DEFINEHASHING
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+void PC_PrintDefineHashTable(define_t **definehash)
+{
+	int i;
+	define_t *d;
+
+	for (i = 0; i < DEFINEHASHSIZE; i++)
+	{
+		Log_Write("%4d:", i);
+		for (d = definehash[i]; d; d = d->hashnext)
+		{
+			Log_Write(" %s", d->name);
+		} //end for
+		Log_Write("\n");
+	} //end for
+} //end of the function PC_PrintDefineHashTable
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+//char primes[16] = {1, 3, 5, 7, 11, 13, 17, 19, 23, 27, 29, 31, 37, 41, 43, 47};
+
+int PC_NameHash(char *name)
+{
+	int register hash, i;
+
+	hash = 0;
+	for (i = 0; name[i] != '\0'; i++)
+	{
+		hash += name[i] * (119 + i);
+		//hash += (name[i] << 7) + i;
+		//hash += (name[i] << (i&15));
+	} //end while
+	hash = (hash ^ (hash >> 10) ^ (hash >> 20)) & (DEFINEHASHSIZE-1);
+	return hash;
+} //end of the function PC_NameHash
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+void PC_AddDefineToHash(define_t *define, define_t **definehash)
+{
+	int hash;
+
+
+	if ( addGlobalDefine )
+	{
+		definehash = globaldefines;
+		define->flags |= DEFINE_GLOBAL;
+	}
+
+	hash = PC_NameHash(define->name);
+	define->hashnext = definehash[hash];
+	definehash[hash] = define;
+
+	if ( addGlobalDefine )
+	{
+		define->globalnext = define->hashnext;
+	}
+} //end of the function PC_AddDefineToHash
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+define_t *PC_FindHashedDefine(define_t **definehash, char *name)
+{
+	define_t *d;
+	int hash;
+
+	hash = PC_NameHash(name);
+	for (d = definehash[hash]; d; d = d->hashnext)
+	{
+		if (!strcmp(d->name, name)) return d;
+	} //end for
+	return NULL;
+} //end of the function PC_FindHashedDefine
+#endif //DEFINEHASHING
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+define_t *PC_FindDefine(define_t *defines, char *name)
+{
+	define_t *d;
+
+	for (d = defines; d; d = d->next)
+	{
+		if (!strcmp(d->name, name)) return d;
+	} //end for
+	return NULL;
+} //end of the function PC_FindDefine
+//============================================================================
+//
+// Parameter:				-
+// Returns:					number of the parm
+//								if no parm found with the given name -1 is returned
+// Changes Globals:		-
+//============================================================================
+int PC_FindDefineParm(define_t *define, char *name)
+{
+	token_t *p;
+	int i;
+
+	i = 0;
+	for (p = define->parms; p; p = p->next)
+	{
+		if (!strcmp(p->string, name)) return i;
+		i++;
+	} //end for
+	return -1;
+} //end of the function PC_FindDefineParm
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+void PC_FreeDefine(define_t *define)
+{
+	token_t *t, *next;
+
+	//free the define parameters
+	for (t = define->parms; t; t = next)
+	{
+		next = t->next;
+		PC_FreeToken(t);
+	} //end for
+	//free the define tokens
+	for (t = define->tokens; t; t = next)
+	{
+		next = t->next;
+		PC_FreeToken(t);
+	} //end for
+	//free the define
+	FreeMemory(define);
+} //end of the function PC_FreeDefine
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+void PC_AddBuiltinDefines(source_t *source)
+{
+	int i;
+	define_t *define;
+	struct builtin
+	{
+		char *string;
+		int mBuiltin;
+	} builtin[] = { // bk001204 - brackets
+		{ "__LINE__",	BUILTIN_LINE },
+		{ "__FILE__",	BUILTIN_FILE },
+		{ "__DATE__",	BUILTIN_DATE },
+		{ "__TIME__",	BUILTIN_TIME },
+//		{ "__STDC__", BUILTIN_STDC },
+		{ NULL, 0 }
+	};
+
+	for (i = 0; builtin[i].string; i++)
+	{
+		define = (define_t *) GetMemory(sizeof(define_t) + strlen(builtin[i].string) + 1);
+		Com_Memset(define, 0, sizeof(define_t));
+		define->name = (char *) define + sizeof(define_t);
+		strcpy(define->name, builtin[i].string);
+		define->flags |= DEFINE_FIXED;
+		define->builtin = builtin[i].mBuiltin;
+		//add the define to the source
+#if DEFINEHASHING
+		PC_AddDefineToHash(define, source->definehash);
+#else
+		define->next = source->defines;
+		source->defines = define;
+#endif //DEFINEHASHING
+	} //end for
+} //end of the function PC_AddBuiltinDefines
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+int PC_ExpandBuiltinDefine(source_t *source, token_t *deftoken, define_t *define,
+										token_t **firsttoken, token_t **lasttoken)
+{
+	token_t *token;
+	unsigned long t;	//	time_t t; //to prevent LCC warning
+	char *curtime;
+
+	token = PC_CopyToken(deftoken);
+	switch(define->builtin)
+	{
+		case BUILTIN_LINE:
+		{
+			sprintf(token->string, "%d", deftoken->line);
+#ifdef NUMBERVALUE
+			token->intvalue = deftoken->line;
+			token->floatvalue = deftoken->line;
+#endif //NUMBERVALUE
+			token->type = TT_NUMBER;
+			token->subtype = TT_DECIMAL | TT_INTEGER;
+			*firsttoken = token;
+			*lasttoken = token;
+			break;
+		} //end case
+		case BUILTIN_FILE:
+		{
+			strcpy(token->string, source->scriptstack->filename);
+			token->type = TT_NAME;
+			token->subtype = strlen(token->string);
+			*firsttoken = token;
+			*lasttoken = token;
+			break;
+		} //end case
+		case BUILTIN_DATE:
+		{
+			t = time(NULL);
+			curtime = ctime((const long *)&t);
+			strcpy(token->string, "\"");
+			strncat(token->string, curtime+4, 7);
+			strncat(token->string+7, curtime+20, 4);
+			strcat(token->string, "\"");
+			free(curtime);
+			token->type = TT_NAME;
+			token->subtype = strlen(token->string);
+			*firsttoken = token;
+			*lasttoken = token;
+			break;
+		} //end case
+		case BUILTIN_TIME:
+		{
+			t = time(NULL);
+			curtime = ctime((const long *)&t);
+			strcpy(token->string, "\"");
+			strncat(token->string, curtime+11, 8);
+			strcat(token->string, "\"");
+			free(curtime);
+			token->type = TT_NAME;
+			token->subtype = strlen(token->string);
+			*firsttoken = token;
+			*lasttoken = token;
+			break;
+		} //end case
+		case BUILTIN_STDC:
+		default:
+		{
+			*firsttoken = NULL;
+			*lasttoken = NULL;
+			break;
+		} //end case
+	} //end switch
+	return qtrue;
+} //end of the function PC_ExpandBuiltinDefine
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+int PC_ExpandDefine(source_t *source, token_t *deftoken, define_t *define,
+										token_t **firsttoken, token_t **lasttoken)
+{
+	token_t *parms[MAX_DEFINEPARMS], *dt, *pt, *t;
+	token_t *t1, *t2, *first, *last, *nextpt, token;
+	int parmnum, i;
+
+	//if it is a builtin define
+	if (define->builtin)
+	{
+		return PC_ExpandBuiltinDefine(source, deftoken, define, firsttoken, lasttoken);
+	} //end if
+	//if the define has parameters
+	if (define->numparms)
+	{
+		if (!PC_ReadDefineParms(source, define, parms, MAX_DEFINEPARMS)) return qfalse;
+#ifdef DEBUG_EVAL
+		for (i = 0; i < define->numparms; i++)
+		{
+			Log_Write("define parms %d:", i);
+			for (pt = parms[i]; pt; pt = pt->next)
+			{
+				Log_Write("%s", pt->string);
+			} //end for
+		} //end for
+#endif //DEBUG_EVAL
+	} //end if
+	//empty list at first
+	first = NULL;
+	last = NULL;
+	//create a list with tokens of the expanded define
+	for (dt = define->tokens; dt; dt = dt->next)
+	{
+		parmnum = -1;
+		//if the token is a name, it could be a define parameter
+		if (dt->type == TT_NAME)
+		{
+			parmnum = PC_FindDefineParm(define, dt->string);
+		} //end if
+		//if it is a define parameter
+		if (parmnum >= 0)
+		{
+			for (pt = parms[parmnum]; pt; pt = pt->next)
+			{
+				t = PC_CopyToken(pt);
+				//add the token to the list
+				t->next = NULL;
+				if (last) last->next = t;
+				else first = t;
+				last = t;
+			} //end for
+		} //end if
+		else
+		{
+			//if stringizing operator
+			if (dt->string[0] == '#' && dt->string[1] == '\0')
+			{
+				//the stringizing operator must be followed by a define parameter
+				if (dt->next) parmnum = PC_FindDefineParm(define, dt->next->string);
+				else parmnum = -1;
+				//
+				if (parmnum >= 0)
+				{
+					//step over the stringizing operator
+					dt = dt->next;
+					//stringize the define parameter tokens
+					if (!PC_StringizeTokens(parms[parmnum], &token))
+					{
+						SourceError(source, "can't stringize tokens");
+						return qfalse;
+					} //end if
+					t = PC_CopyToken(&token);
+				} //end if
+				else
+				{
+					SourceWarning(source, "stringizing operator without define parameter");
+					continue;
+				} //end if
+			} //end if
+			else
+			{
+				t = PC_CopyToken(dt);
+			} //end else
+			//add the token to the list
+			t->next = NULL;
+			if (last) last->next = t;
+			else first = t;
+			last = t;
+		} //end else
+	} //end for
+	//check for the merging operator
+	for (t = first; t; )
+	{
+		if (t->next)
+		{
+			//if the merging operator
+			if (t->next->string[0] == '#' && t->next->string[1] == '#')
+			{
+				t1 = t;
+				t2 = t->next->next;
+				if (t2)
+				{
+					if (!PC_MergeTokens(t1, t2))
+					{
+						SourceError(source, "can't merge %s with %s", t1->string, t2->string);
+						return qfalse;
+					} //end if
+					PC_FreeToken(t1->next);
+					t1->next = t2->next;
+					if (t2 == last) last = t1;
+					PC_FreeToken(t2);
+					continue;
+				} //end if
+			} //end if
+		} //end if
+		t = t->next;
+	} //end for
+	//store the first and last token of the list
+	*firsttoken = first;
+	*lasttoken = last;
+	//free all the parameter tokens
+	for (i = 0; i < define->numparms; i++)
+	{
+		for (pt = parms[i]; pt; pt = nextpt)
+		{
+			nextpt = pt->next;
+			PC_FreeToken(pt);
+		} //end for
+	} //end for
+	//
+	return qtrue;
+} //end of the function PC_ExpandDefine
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+int PC_ExpandDefineIntoSource(source_t *source, token_t *deftoken, define_t *define)
+{
+	token_t *firsttoken, *lasttoken;
+
+	if (!PC_ExpandDefine(source, deftoken, define, &firsttoken, &lasttoken)) return qfalse;
+
+	if (firsttoken && lasttoken)
+	{
+		lasttoken->next = source->tokens;
+		source->tokens = firsttoken;
+		return qtrue;
+	} //end if
+	return qfalse;
+} //end of the function PC_ExpandDefineIntoSource
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+void PC_ConvertPath(char *path)
+{
+	char *ptr;
+
+	//remove double path seperators
+	for (ptr = path; *ptr;)
+	{
+		if ((*ptr == '\\' || *ptr == '/') &&
+				(*(ptr+1) == '\\' || *(ptr+1) == '/'))
+		{
+			strcpy(ptr, ptr+1);
+		} //end if
+		else
+		{
+			ptr++;
+		} //end else
+	} //end while
+	//set OS dependent path seperators
+	for (ptr = path; *ptr;)
+	{
+		if (*ptr == '/' || *ptr == '\\') *ptr = PATHSEPERATOR_CHAR;
+		ptr++;
+	} //end while
+} //end of the function PC_ConvertPath
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+int PC_Directive_include(source_t *source)
+{
+	script_t *script;
+	token_t token;
+	char path[MAX_PATH];
+#ifdef QUAKE
+	foundfile_t file;
+#endif //QUAKE
+
+	if (source->skip > 0) return qtrue;
+	//
+	if (!PC_ReadSourceToken(source, &token))
+	{
+		SourceError(source, "#include without file name");
+		return qfalse;
+	} //end if
+	if (token.linescrossed > 0)
+	{
+		SourceError(source, "#include without file name");
+		return qfalse;
+	} //end if
+	if (token.type == TT_STRING)
+	{
+		StripDoubleQuotes(token.string);
+		PC_ConvertPath(token.string);
+		script = LoadScriptFile(token.string);
+		if (!script)
+		{
+			strcpy(path, source->includepath);
+			strcat(path, token.string);
+			script = LoadScriptFile(path);
+		} //end if
+	} //end if
+	else if (token.type == TT_PUNCTUATION && *token.string == '<')
+	{
+		strcpy(path, source->includepath);
+		while(PC_ReadSourceToken(source, &token))
+		{
+			if (token.linescrossed > 0)
+			{
+				PC_UnreadSourceToken(source, &token);
+				break;
+			} //end if
+			if (token.type == TT_PUNCTUATION && *token.string == '>') break;
+			strncat(path, token.string, MAX_PATH);
+		} //end while
+		if (*token.string != '>')
+		{
+			SourceWarning(source, "#include missing trailing >");
+		} //end if
+		if (!strlen(path))
+		{
+			SourceError(source, "#include without file name between < >");
+			return qfalse;
+		} //end if
+		PC_ConvertPath(path);
+		script = LoadScriptFile(path);
+	} //end if
+	else
+	{
+		SourceError(source, "#include without file name");
+		return qfalse;
+	} //end else
+#ifdef QUAKE
+	if (!script)
+	{
+		Com_Memset(&file, 0, sizeof(foundfile_t));
+		script = LoadScriptFile(path);
+		if (script) strncpy(script->filename, path, MAX_PATH);
+	} //end if
+#endif //QUAKE
+	if (!script)
+	{
+#ifdef SCREWUP
+		SourceWarning(source, "file %s not found", path);
+		return qtrue;
+#else
+		SourceError(source, "file %s not found", path);
+		return qfalse;
+#endif //SCREWUP
+	} //end if
+	PC_PushScript(source, script);
+	return qtrue;
+} //end of the function PC_Directive_include
+//============================================================================
+// reads a token from the current line, continues reading on the next
+// line only if a backslash '\' is encountered.
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+int PC_ReadLine(source_t *source, token_t *token)
+{
+	int crossline;
+
+	crossline = 0;
+	do
+	{
+		if (!PC_ReadSourceToken(source, token)) return qfalse;
+		
+		if (token->linescrossed > crossline)
+		{
+			PC_UnreadSourceToken(source, token);
+			return qfalse;
+		} //end if
+		crossline = 1;
+	} while(!strcmp(token->string, "\\"));
+	return qtrue;
+} //end of the function PC_ReadLine
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+int PC_WhiteSpaceBeforeToken(token_t *token)
+{
+	return token->endwhitespace_p - token->whitespace_p > 0;
+} //end of the function PC_WhiteSpaceBeforeToken
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+void PC_ClearTokenWhiteSpace(token_t *token)
+{
+	token->whitespace_p = NULL;
+	token->endwhitespace_p = NULL;
+	token->linescrossed = 0;
+} //end of the function PC_ClearTokenWhiteSpace
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+int PC_Directive_undef(source_t *source)
+{
+	token_t token;
+	define_t *define, *lastdefine;
+	int hash;
+
+	if (source->skip > 0) return qtrue;
+	//
+	if (!PC_ReadLine(source, &token))
+	{
+		SourceError(source, "undef without name");
+		return qfalse;
+	} //end if
+	if (token.type != TT_NAME)
+	{
+		PC_UnreadSourceToken(source, &token);
+		SourceError(source, "expected name, found %s", token.string);
+		return qfalse;
+	} //end if
+#if DEFINEHASHING
+
+	hash = PC_NameHash(token.string);
+	for (lastdefine = NULL, define = source->definehash[hash]; define; define = define->hashnext)
+	{
+		if (!strcmp(define->name, token.string))
+		{
+			if (define->flags & DEFINE_FIXED)
+			{
+				SourceWarning(source, "can't undef %s", token.string);
+			} //end if			
+			else
+			{
+				if (lastdefine) lastdefine->hashnext = define->hashnext;
+				else source->definehash[hash] = define->hashnext;
+
+				if ( !(define->flags & DEFINE_GLOBAL ) )
+				{
+					PC_FreeDefine(define);
+				}
+			} //end else
+			break;
+		} //end if
+		lastdefine = define;
+	} //end for
+#else //DEFINEHASHING
+	for (lastdefine = NULL, define = source->defines; define; define = define->next)
+	{
+		if (!strcmp(define->name, token.string))
+		{
+			if (define->flags & DEFINE_FIXED)
+			{
+				SourceWarning(source, "can't undef %s", token.string);
+			} //end if
+			else
+			{
+				if (lastdefine) lastdefine->next = define->next;
+				else source->defines = define->next;
+				PC_FreeDefine(define);
+			} //end else
+			break;
+		} //end if
+		lastdefine = define;
+	} //end for
+#endif //DEFINEHASHING
+	return qtrue;
+} //end of the function PC_Directive_undef
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+int PC_Directive_define(source_t *source)
+{
+	token_t token, *t, *last;
+	define_t *define;
+
+	if (source->skip > 0) return qtrue;
+	//
+	if (!PC_ReadLine(source, &token))
+	{
+		SourceError(source, "#define without name");
+		return qfalse;
+	} //end if
+	if (token.type != TT_NAME)
+	{
+		PC_UnreadSourceToken(source, &token);
+		SourceError(source, "expected name after #define, found %s", token.string);
+		return qfalse;
+	} //end if
+	//check if the define already exists
+#if DEFINEHASHING
+	define = PC_FindHashedDefine(source->definehash, token.string);
+#else
+	define = PC_FindDefine(source->defines, token.string);
+#endif //DEFINEHASHING
+	if (define)
+	{
+		if (define->flags & DEFINE_FIXED)
+		{
+			SourceError(source, "can't redefine %s", token.string);
+			return qfalse;
+		} //end if
+		SourceWarning(source, "redefinition of %s", token.string);
+		//unread the define name before executing the #undef directive
+		PC_UnreadSourceToken(source, &token);
+		if (!PC_Directive_undef(source)) return qfalse;
+		//if the define was not removed (define->flags & DEFINE_FIXED)
+#if DEFINEHASHING
+		define = PC_FindHashedDefine(source->definehash, token.string);
+#else
+		define = PC_FindDefine(source->defines, token.string);
+#endif //DEFINEHASHING
+	} //end if
+	//allocate define
+	define = (define_t *) GetMemory(sizeof(define_t) + strlen(token.string) + 1);
+	Com_Memset(define, 0, sizeof(define_t));
+	define->name = (char *) define + sizeof(define_t);
+	strcpy(define->name, token.string);
+	//add the define to the source
+#if DEFINEHASHING
+	PC_AddDefineToHash(define, source->definehash);
+#else //DEFINEHASHING
+	define->next = source->defines;
+	source->defines = define;
+#endif //DEFINEHASHING
+	//if nothing is defined, just return
+	if (!PC_ReadLine(source, &token)) return qtrue;
+	//if it is a define with parameters
+	if (!PC_WhiteSpaceBeforeToken(&token) && !strcmp(token.string, "("))
+	{
+		//read the define parameters
+		last = NULL;
+		if (!PC_CheckTokenString(source, ")"))
+		{
+			while(1)
+			{
+				if (!PC_ReadLine(source, &token))
+				{
+					SourceError(source, "expected define parameter");
+					return qfalse;
+				} //end if
+				//if it isn't a name
+				if (token.type != TT_NAME)
+				{
+					SourceError(source, "invalid define parameter");
+					return qfalse;
+				} //end if
+				//
+				if (PC_FindDefineParm(define, token.string) >= 0)
+				{
+					SourceError(source, "two the same define parameters");
+					return qfalse;
+				} //end if
+				//add the define parm
+				t = PC_CopyToken(&token);
+				PC_ClearTokenWhiteSpace(t);
+				t->next = NULL;
+				if (last) last->next = t;
+				else define->parms = t;
+				last = t;
+				define->numparms++;
+				//read next token
+				if (!PC_ReadLine(source, &token))
+				{
+					SourceError(source, "define parameters not terminated");
+					return qfalse;
+				} //end if
+				//
+				if (!strcmp(token.string, ")")) break;
+				//then it must be a comma
+				if (strcmp(token.string, ","))
+				{
+					SourceError(source, "define not terminated");
+					return qfalse;
+				} //end if
+			} //end while
+		} //end if
+		if (!PC_ReadLine(source, &token)) return qtrue;
+	} //end if
+	//read the defined stuff
+	last = NULL;
+	do
+	{
+		t = PC_CopyToken(&token);
+		if (t->type == TT_NAME && !strcmp(t->string, define->name))
+		{
+			SourceError(source, "recursive define (removed recursion)");
+			continue;
+		} //end if
+		PC_ClearTokenWhiteSpace(t);
+		t->next = NULL;
+		if (last) last->next = t;
+		else define->tokens = t;
+		last = t;
+	} while(PC_ReadLine(source, &token));
+	//
+	if (last)
+	{
+		//check for merge operators at the beginning or end
+		if (!strcmp(define->tokens->string, "##") ||
+				!strcmp(last->string, "##"))
+		{
+			SourceError(source, "define with misplaced ##");
+			return qfalse;
+		} //end if
+	} //end if
+	return qtrue;
+} //end of the function PC_Directive_define
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+define_t *PC_DefineFromString(char *string)
+{
+	script_t *script;
+	source_t src;
+	token_t *t;
+	int res, i;
+	define_t *def;
+
+	PC_InitTokenHeap();
+
+	script = LoadScriptMemory(string, strlen(string), "*extern");
+	//create a new source
+	Com_Memset(&src, 0, sizeof(source_t));
+	strncpy(src.filename, "*extern", MAX_PATH);
+	src.scriptstack = script;
+#if DEFINEHASHING
+	src.definehash = (struct define_s **)GetClearedMemory(DEFINEHASHSIZE * sizeof(define_t *));
+#endif //DEFINEHASHING
+	//create a define from the source
+	res = PC_Directive_define(&src);
+	//free any tokens if left
+	for (t = src.tokens; t; t = src.tokens)
+	{
+		src.tokens = src.tokens->next;
+		PC_FreeToken(t);
+	} //end for
+#ifdef DEFINEHASHING
+	def = NULL;
+	for (i = 0; i < DEFINEHASHSIZE; i++)
+	{
+		if (src.definehash[i])
+		{
+			def = src.definehash[i];
+			break;
+		} //end if
+	} //end for
+#else
+	def = src.defines;
+#endif //DEFINEHASHING
+	//
+#if DEFINEHASHING
+	FreeMemory(src.definehash);
+#endif //DEFINEHASHING
+	//
+	FreeScript(script);
+	//if the define was created succesfully
+	if (res > 0) return def;
+	//free the define is created
+	if (src.defines) PC_FreeDefine(def);
+	//
+	return NULL;
+} //end of the function PC_DefineFromString
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+int PC_AddDefine(source_t *source, char *string)
+{
+	define_t *define;
+
+	if ( addGlobalDefine )
+	{
+		return PC_AddGlobalDefine ( string );
+	}
+
+	define = PC_DefineFromString(string);
+	if (!define) return qfalse;
+#if DEFINEHASHING
+	PC_AddDefineToHash(define, source->definehash);
+#else //DEFINEHASHING
+	define->next = source->defines;
+	source->defines = define;
+#endif //DEFINEHASHING
+	return qtrue;
+} //end of the function PC_AddDefine
+//============================================================================
+// add a globals define that will be added to all opened sources
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+int PC_AddGlobalDefine(char *string)
+{
+#if !DEFINEHASHING
+	define_t *define;
+
+	define = PC_DefineFromString(string);
+	if (!define) return qfalse;
+	define->next = globaldefines;
+	globaldefines = define;
+#endif
+	return qtrue;
+} //end of the function PC_AddGlobalDefine
+//============================================================================
+// remove the given global define
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+int PC_RemoveGlobalDefine(char *name)
+{
+#if !DEFINEHASHING
+	define_t *define;
+
+	define = PC_FindDefine(globaldefines, name);
+	if (define)
+	{
+		PC_FreeDefine(define);
+		return qtrue;
+	} //end if
+#endif
+	return qfalse;
+} //end of the function PC_RemoveGlobalDefine
+//============================================================================
+// remove all globals defines
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+void PC_RemoveAllGlobalDefines(void)
+{
+	define_t *define;
+
+#if DEFINEHASHING
+	int i;
+	if ( globaldefines )
+	{
+		for (i = 0; i < DEFINEHASHSIZE; i++)
+		{
+			while(globaldefines[i])
+			{
+				define = globaldefines[i];
+				globaldefines[i] = globaldefines[i]->globalnext;
+				PC_FreeDefine(define);
+			} 
+		} 
+	}
+#else //DEFINEHASHING
+	for (define = globaldefines; define; define = globaldefines)
+	{
+		globaldefines = globaldefines->next;
+		PC_FreeDefine(define);
+	} //end for
+#endif
+} //end of the function PC_RemoveAllGlobalDefines
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+define_t *PC_CopyDefine(source_t *source, define_t *define)
+{
+	define_t *newdefine;
+	token_t *token, *newtoken, *lasttoken;
+
+	newdefine = (define_t *) GetMemory(sizeof(define_t) + strlen(define->name) + 1);
+	//copy the define name
+	newdefine->name = (char *) newdefine + sizeof(define_t);
+	strcpy(newdefine->name, define->name);
+	newdefine->flags = define->flags;
+	newdefine->builtin = define->builtin;
+	newdefine->numparms = define->numparms;
+	//the define is not linked
+	newdefine->next = NULL;
+	newdefine->hashnext = NULL;
+	//copy the define tokens
+	newdefine->tokens = NULL;
+	for (lasttoken = NULL, token = define->tokens; token; token = token->next)
+	{
+		newtoken = PC_CopyToken(token);
+		newtoken->next = NULL;
+		if (lasttoken) lasttoken->next = newtoken;
+		else newdefine->tokens = newtoken;
+		lasttoken = newtoken;
+	} //end for
+	//copy the define parameters
+	newdefine->parms = NULL;
+	for (lasttoken = NULL, token = define->parms; token; token = token->next)
+	{
+		newtoken = PC_CopyToken(token);
+		newtoken->next = NULL;
+		if (lasttoken) lasttoken->next = newtoken;
+		else newdefine->parms = newtoken;
+		lasttoken = newtoken;
+	} //end for
+	return newdefine;
+} //end of the function PC_CopyDefine
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+void PC_AddGlobalDefinesToSource(source_t *source)
+{
+	define_t *define;
+
+#if DEFINEHASHING
+	int i;
+	for (i = 0; i < DEFINEHASHSIZE; i++)
+	{
+		define = globaldefines[i];
+		while(define)
+		{
+			define->hashnext = NULL;
+			PC_AddDefineToHash(define, source->definehash);
+
+			define = define->globalnext;
+		} 
+	} 
+#else //DEFINEHASHING
+	define_t* newdefine;
+	for (define = globaldefines; define; define = define->next)
+	{
+		newdefine = PC_CopyDefine(source, define);
+
+
+
+		newdefine->next = source->defines;
+		source->defines = newdefine;
+	}
+#endif
+} //end of the function PC_AddGlobalDefinesToSource
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+int PC_Directive_if_def(source_t *source, int type)
+{
+	token_t token;
+	define_t *d;
+	int skip;
+
+	if (!PC_ReadLine(source, &token))
+	{
+		SourceError(source, "#ifdef without name");
+		return qfalse;
+	} //end if
+	if (token.type != TT_NAME)
+	{
+		PC_UnreadSourceToken(source, &token);
+		SourceError(source, "expected name after #ifdef, found %s", token.string);
+		return qfalse;
+	} //end if
+#if DEFINEHASHING
+	d = PC_FindHashedDefine(source->definehash, token.string);
+#else
+	d = PC_FindDefine(source->defines, token.string);
+#endif //DEFINEHASHING
+	skip = (type == INDENT_IFDEF) == (d == NULL);
+	PC_PushIndent(source, type, skip);
+	return qtrue;
+} //end of the function PC_Directiveif_def
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+int PC_Directive_ifdef(source_t *source)
+{
+	return PC_Directive_if_def(source, INDENT_IFDEF);
+} //end of the function PC_Directive_ifdef
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+int PC_Directive_ifndef(source_t *source)
+{
+	return PC_Directive_if_def(source, INDENT_IFNDEF);
+} //end of the function PC_Directive_ifndef
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+int PC_Directive_else(source_t *source)
+{
+	int type, skip;
+
+	PC_PopIndent(source, &type, &skip);
+	if (!type)
+	{
+		SourceError(source, "misplaced #else");
+		return qfalse;
+	} //end if
+	if (type == INDENT_ELSE)
+	{
+		SourceError(source, "#else after #else");
+		return qfalse;
+	} //end if
+	PC_PushIndent(source, INDENT_ELSE, !skip);
+	return qtrue;
+} //end of the function PC_Directive_else
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+int PC_Directive_endif(source_t *source)
+{
+	int type, skip;
+
+	PC_PopIndent(source, &type, &skip);
+	if (!type)
+	{
+		SourceError(source, "misplaced #endif");
+		return qfalse;
+	} //end if
+	return qtrue;
+} //end of the function PC_Directive_endif
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+typedef struct operator_s
+{
+	int mOperator;
+	int priority;
+	int parentheses;
+	struct operator_s *prev, *next;
+} operator_t;
+
+typedef struct value_s
+{
+	signed long int intvalue;
+	double floatvalue;
+	int parentheses;
+	struct value_s *prev, *next;
+} value_t;
+
+int PC_OperatorPriority(int op)
+{
+	switch(op)
+	{
+		case P_MUL: return 15;
+		case P_DIV: return 15;
+		case P_MOD: return 15;
+		case P_ADD: return 14;
+		case P_SUB: return 14;
+
+		case P_LOGIC_AND: return 7;
+		case P_LOGIC_OR: return 6;
+		case P_LOGIC_GEQ: return 12;
+		case P_LOGIC_LEQ: return 12;
+		case P_LOGIC_EQ: return 11;
+		case P_LOGIC_UNEQ: return 11;
+
+		case P_LOGIC_NOT: return 16;
+		case P_LOGIC_GREATER: return 12;
+		case P_LOGIC_LESS: return 12;
+
+		case P_RSHIFT: return 13;
+		case P_LSHIFT: return 13;
+
+		case P_BIN_AND: return 10;
+		case P_BIN_OR: return 8;
+		case P_BIN_XOR: return 9;
+		case P_BIN_NOT: return 16;
+
+		case P_COLON: return 5;
+		case P_QUESTIONMARK: return 5;
+	} //end switch
+	return qfalse;
+} //end of the function PC_OperatorPriority
+
+//#define AllocValue()			GetClearedMemory(sizeof(value_t));
+//#define FreeValue(val)		FreeMemory(val)
+//#define AllocOperator(op)		op = (operator_t *) GetClearedMemory(sizeof(operator_t));
+//#define FreeOperator(op)		FreeMemory(op);
+
+#define MAX_VALUES		64
+#define MAX_OPERATORS	64
+#define AllocValue(val)									\
+	if (numvalues >= MAX_VALUES) {						\
+		SourceError(source, "out of value space\n");		\
+		error = 1;										\
+		break;											\
+	}													\
+	else												\
+		val = &value_heap[numvalues++];
+#define FreeValue(val)
+//
+#define AllocOperator(op)								\
+	if (numoperators >= MAX_OPERATORS) {				\
+		SourceError(source, "out of operator space\n");	\
+		error = 1;										\
+		break;											\
+	}													\
+	else												\
+		op = &operator_heap[numoperators++];
+#define FreeOperator(op)
+
+int PC_EvaluateTokens(source_t *source, token_t *tokens, signed long int *intvalue,
+																	double *floatvalue, int integer)
+{
+	operator_t *o, *firstoperator, *lastoperator;
+	value_t *v, *firstvalue, *lastvalue, *v1, *v2;
+	token_t *t;
+	int brace = 0;
+	int parentheses = 0;
+	int error = 0;
+	int lastwasvalue = 0;
+	int negativevalue = 0;
+	int questmarkintvalue = 0;
+	double questmarkfloatvalue = 0;
+	int gotquestmarkvalue = qfalse;
+	int lastoperatortype = 0;
+	//
+	operator_t operator_heap[MAX_OPERATORS];
+	int numoperators = 0;
+	value_t value_heap[MAX_VALUES];
+	int numvalues = 0;
+
+	firstoperator = lastoperator = NULL;
+	firstvalue = lastvalue = NULL;
+	if (intvalue) *intvalue = 0;
+	if (floatvalue) *floatvalue = 0;
+	for (t = tokens; t; t = t->next)
+	{
+		switch(t->type)
+		{
+			case TT_NAME:
+			{
+				if (lastwasvalue || negativevalue)
+				{
+					SourceError(source, "syntax error in #if/#elif");
+					error = 1;
+					break;
+				} //end if
+				if (strcmp(t->string, "defined"))
+				{
+					SourceError(source, "undefined name %s in #if/#elif", t->string);
+					error = 1;
+					break;
+				} //end if
+				t = t->next;
+				if (!strcmp(t->string, "("))
+				{
+					brace = qtrue;
+					t = t->next;
+				} //end if
+				if (!t || t->type != TT_NAME)
+				{
+					SourceError(source, "defined without name in #if/#elif");
+					error = 1;
+					break;
+				} //end if
+				//v = (value_t *) GetClearedMemory(sizeof(value_t));
+				AllocValue(v);
+#if DEFINEHASHING
+				if (PC_FindHashedDefine(source->definehash, t->string))
+#else			
+				if (PC_FindDefine(source->defines, t->string))
+#endif //DEFINEHASHING
+				{
+					v->intvalue = 1;
+					v->floatvalue = 1;
+				} //end if
+				else
+				{
+					v->intvalue = 0;
+					v->floatvalue = 0;
+				} //end else
+				v->parentheses = parentheses;
+				v->next = NULL;
+				v->prev = lastvalue;
+				if (lastvalue) lastvalue->next = v;
+				else firstvalue = v;
+				lastvalue = v;
+				if (brace)
+				{
+					t = t->next;
+					if (!t || strcmp(t->string, ")"))
+					{
+						SourceError(source, "defined without ) in #if/#elif");
+						error = 1;
+						break;
+					} //end if
+				} //end if
+				brace = qfalse;
+				// defined() creates a value
+				lastwasvalue = 1;
+				break;
+			} //end case
+			case TT_NUMBER:
+			{
+				if (lastwasvalue)
+				{
+					SourceError(source, "syntax error in #if/#elif");
+					error = 1;
+					break;
+				} //end if
+				//v = (value_t *) GetClearedMemory(sizeof(value_t));
+				AllocValue(v);
+				if (negativevalue)
+				{
+					v->intvalue = - (signed int) t->intvalue;
+					v->floatvalue = - t->floatvalue;
+				} //end if
+				else
+				{
+					v->intvalue = t->intvalue;
+					v->floatvalue = t->floatvalue;
+				} //end else
+				v->parentheses = parentheses;
+				v->next = NULL;
+				v->prev = lastvalue;
+				if (lastvalue) lastvalue->next = v;
+				else firstvalue = v;
+				lastvalue = v;
+				//last token was a value
+				lastwasvalue = 1;
+				//
+				negativevalue = 0;
+				break;
+			} //end case
+			case TT_PUNCTUATION:
+			{
+				if (negativevalue)
+				{
+					SourceError(source, "misplaced minus sign in #if/#elif");
+					error = 1;
+					break;
+				} //end if
+				if (t->subtype == P_PARENTHESESOPEN)
+				{
+					parentheses++;
+					break;
+				} //end if
+				else if (t->subtype == P_PARENTHESESCLOSE)
+				{
+					parentheses--;
+					if (parentheses < 0)
+					{
+						SourceError(source, "too many ) in #if/#elsif");
+						error = 1;
+					} //end if
+					break;
+				} //end else if
+				//check for invalid operators on floating point values
+				if (!integer)
+				{
+					if (t->subtype == P_BIN_NOT || t->subtype == P_MOD ||
+						t->subtype == P_RSHIFT || t->subtype == P_LSHIFT ||
+						t->subtype == P_BIN_AND || t->subtype == P_BIN_OR ||
+						t->subtype == P_BIN_XOR)
+					{
+						SourceError(source, "illigal operator %s on floating point operands\n", t->string);
+						error = 1;
+						break;
+					} //end if
+				} //end if
+				switch(t->subtype)
+				{
+					case P_LOGIC_NOT:
+					case P_BIN_NOT:
+					{
+						if (lastwasvalue)
+						{
+							SourceError(source, "! or ~ after value in #if/#elif");
+							error = 1;
+							break;
+						} //end if
+						break;
+					} //end case
+					case P_INC:
+					case P_DEC:
+					{
+						SourceError(source, "++ or -- used in #if/#elif");
+						break;
+					} //end case
+					case P_SUB:
+					{
+						if (!lastwasvalue)
+						{
+							negativevalue = 1;
+							break;
+						} //end if
+					} //end case
+					
+					case P_MUL:
+					case P_DIV:
+					case P_MOD:
+					case P_ADD:
+
+					case P_LOGIC_AND:
+					case P_LOGIC_OR:
+					case P_LOGIC_GEQ:
+					case P_LOGIC_LEQ:
+					case P_LOGIC_EQ:
+					case P_LOGIC_UNEQ:
+
+					case P_LOGIC_GREATER:
+					case P_LOGIC_LESS:
+
+					case P_RSHIFT:
+					case P_LSHIFT:
+
+					case P_BIN_AND:
+					case P_BIN_OR:
+					case P_BIN_XOR:
+
+					case P_COLON:
+					case P_QUESTIONMARK:
+					{
+						if (!lastwasvalue)
+						{
+							SourceError(source, "operator %s after operator in #if/#elif", t->string);
+							error = 1;
+							break;
+						} //end if
+						break;
+					} //end case
+					default:
+					{
+						SourceError(source, "invalid operator %s in #if/#elif", t->string);
+						error = 1;
+						break;
+					} //end default
+				} //end switch
+				if (!error && !negativevalue)
+				{
+					//o = (operator_t *) GetClearedMemory(sizeof(operator_t));
+					AllocOperator(o);
+					o->mOperator = t->subtype;
+					o->priority = PC_OperatorPriority(t->subtype);
+					o->parentheses = parentheses;
+					o->next = NULL;
+					o->prev = lastoperator;
+					if (lastoperator) lastoperator->next = o;
+					else firstoperator = o;
+					lastoperator = o;
+					lastwasvalue = 0;
+				} //end if
+				break;
+			} //end case
+			default:
+			{
+				SourceError(source, "unknown %s in #if/#elif", t->string);
+				error = 1;
+				break;
+			} //end default
+		} //end switch
+		if (error) break;
+	} //end for
+	if (!error)
+	{
+		if (!lastwasvalue)
+		{
+			SourceError(source, "trailing operator in #if/#elif");
+			error = 1;
+		} //end if
+		else if (parentheses)
+		{
+			SourceError(source, "too many ( in #if/#elif");
+			error = 1;
+		} //end else if
+	} //end if
+	//
+	gotquestmarkvalue = qfalse;
+	questmarkintvalue = 0;
+	questmarkfloatvalue = 0;
+	//while there are operators
+	while(!error && firstoperator)
+	{
+		v = firstvalue;
+		for (o = firstoperator; o->next; o = o->next)
+		{
+			//if the current operator is nested deeper in parentheses
+			//than the next operator
+			if (o->parentheses > o->next->parentheses) break;
+			//if the current and next operator are nested equally deep in parentheses
+			if (o->parentheses == o->next->parentheses)
+			{
+				//if the priority of the current operator is equal or higher
+				//than the priority of the next operator
+				if (o->priority >= o->next->priority) break;
+			} //end if
+			//if the arity of the operator isn't equal to 1
+			if (o->mOperator != P_LOGIC_NOT
+					&& o->mOperator != P_BIN_NOT) v = v->next;
+			//if there's no value or no next value
+			if (!v)
+			{
+				SourceError(source, "mising values in #if/#elif");
+				error = 1;
+				break;
+			} //end if
+		} //end for
+		if (error) break;
+		v1 = v;
+		v2 = v->next;
+#ifdef DEBUG_EVAL
+		if (integer)
+		{
+			Log_Write("operator %s, value1 = %d", PunctuationFromNum(source->scriptstack, o->mOperator), v1->intvalue);
+			if (v2) Log_Write("value2 = %d", v2->intvalue);
+		} //end if
+		else
+		{
+			Log_Write("operator %s, value1 = %f", PunctuationFromNum(source->scriptstack, o->mOperator), v1->floatvalue);
+			if (v2) Log_Write("value2 = %f", v2->floatvalue);
+		} //end else
+#endif //DEBUG_EVAL
+		switch(o->mOperator)
+		{
+			case P_LOGIC_NOT:		v1->intvalue = !v1->intvalue;
+									v1->floatvalue = !v1->floatvalue; break;
+			case P_BIN_NOT:			v1->intvalue = ~v1->intvalue;
+									break;
+			case P_MUL:				v1->intvalue *= v2->intvalue;
+									v1->floatvalue *= v2->floatvalue; break;
+			case P_DIV:				if (!v2->intvalue || !v2->floatvalue)
+									{
+										SourceError(source, "divide by zero in #if/#elif\n");
+										error = 1;
+										break;
+									}
+									v1->intvalue /= v2->intvalue;
+									v1->floatvalue /= v2->floatvalue; break;
+			case P_MOD:				if (!v2->intvalue)
+									{
+										SourceError(source, "divide by zero in #if/#elif\n");
+										error = 1;
+										break;
+									}
+									v1->intvalue %= v2->intvalue; break;
+			case P_ADD:				v1->intvalue += v2->intvalue;
+									v1->floatvalue += v2->floatvalue; break;
+			case P_SUB:				v1->intvalue -= v2->intvalue;
+									v1->floatvalue -= v2->floatvalue; break;
+			case P_LOGIC_AND:		v1->intvalue = v1->intvalue && v2->intvalue;
+									v1->floatvalue = v1->floatvalue && v2->floatvalue; break;
+			case P_LOGIC_OR:		v1->intvalue = v1->intvalue || v2->intvalue;
+									v1->floatvalue = v1->floatvalue || v2->floatvalue; break;
+			case P_LOGIC_GEQ:		v1->intvalue = v1->intvalue >= v2->intvalue;
+									v1->floatvalue = v1->floatvalue >= v2->floatvalue; break;
+			case P_LOGIC_LEQ:		v1->intvalue = v1->intvalue <= v2->intvalue;
+									v1->floatvalue = v1->floatvalue <= v2->floatvalue; break;
+			case P_LOGIC_EQ:		v1->intvalue = v1->intvalue == v2->intvalue;
+									v1->floatvalue = v1->floatvalue == v2->floatvalue; break;
+			case P_LOGIC_UNEQ:		v1->intvalue = v1->intvalue != v2->intvalue;
+									v1->floatvalue = v1->floatvalue != v2->floatvalue; break;
+			case P_LOGIC_GREATER:	v1->intvalue = v1->intvalue > v2->intvalue;
+									v1->floatvalue = v1->floatvalue > v2->floatvalue; break;
+			case P_LOGIC_LESS:		v1->intvalue = v1->intvalue < v2->intvalue;
+									v1->floatvalue = v1->floatvalue < v2->floatvalue; break;
+			case P_RSHIFT:			v1->intvalue >>= v2->intvalue;
+									break;
+			case P_LSHIFT:			v1->intvalue <<= v2->intvalue;
+									break;
+			case P_BIN_AND:			v1->intvalue &= v2->intvalue;
+									break;
+			case P_BIN_OR:			v1->intvalue |= v2->intvalue;
+									break;
+			case P_BIN_XOR:			v1->intvalue ^= v2->intvalue;
+									break;
+			case P_COLON:
+			{
+				if (!gotquestmarkvalue)
+				{
+					SourceError(source, ": without ? in #if/#elif");
+					error = 1;
+					break;
+				} //end if
+				if (integer)
+				{
+					if (!questmarkintvalue) v1->intvalue = v2->intvalue;
+				} //end if
+				else
+				{
+					if (!questmarkfloatvalue) v1->floatvalue = v2->floatvalue;
+				} //end else
+				gotquestmarkvalue = qfalse;
+				break;
+			} //end case
+			case P_QUESTIONMARK:
+			{
+				if (gotquestmarkvalue)
+				{
+					SourceError(source, "? after ? in #if/#elif");
+					error = 1;
+					break;
+				} //end if
+				questmarkintvalue = v1->intvalue;
+				questmarkfloatvalue = v1->floatvalue;
+				gotquestmarkvalue = qtrue;
+				break;
+			} //end if
+		} //end switch
+#ifdef DEBUG_EVAL
+		if (integer) Log_Write("result value = %d", v1->intvalue);
+		else Log_Write("result value = %f", v1->floatvalue);
+#endif //DEBUG_EVAL
+		if (error) break;
+		lastoperatortype = o->mOperator;
+		//if not an operator with arity 1
+		if (o->mOperator != P_LOGIC_NOT
+				&& o->mOperator != P_BIN_NOT)
+		{
+			//remove the second value if not question mark operator
+			if (o->mOperator != P_QUESTIONMARK) v = v->next;
+			//
+			if (v->prev) v->prev->next = v->next;
+			else firstvalue = v->next;
+			if (v->next) v->next->prev = v->prev;
+			else lastvalue = v->prev;
+			//FreeMemory(v);
+			FreeValue(v);
+		} //end if
+		//remove the operator
+		if (o->prev) o->prev->next = o->next;
+		else firstoperator = o->next;
+		if (o->next) o->next->prev = o->prev;
+		else lastoperator = o->prev;
+		//FreeMemory(o);
+		FreeOperator(o);
+	} //end while
+	if (firstvalue)
+	{
+		if (intvalue) *intvalue = firstvalue->intvalue;
+		if (floatvalue) *floatvalue = firstvalue->floatvalue;
+	} //end if
+	for (o = firstoperator; o; o = lastoperator)
+	{
+		lastoperator = o->next;
+		//FreeMemory(o);
+		FreeOperator(o);
+	} //end for
+	for (v = firstvalue; v; v = lastvalue)
+	{
+		lastvalue = v->next;
+		//FreeMemory(v);
+		FreeValue(v);
+	} //end for
+	if (!error) return qtrue;
+	if (intvalue) *intvalue = 0;
+	if (floatvalue) *floatvalue = 0;
+	return qfalse;
+} //end of the function PC_EvaluateTokens
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+int PC_Evaluate(source_t *source, signed long int *intvalue,
+												double *floatvalue, int integer)
+{
+	token_t token, *firsttoken, *lasttoken;
+	token_t *t, *nexttoken;
+	define_t *define;
+	int defined = qfalse;
+
+	if (intvalue) *intvalue = 0;
+	if (floatvalue) *floatvalue = 0;
+	//
+	if (!PC_ReadLine(source, &token))
+	{
+		SourceError(source, "no value after #if/#elif");
+		return qfalse;
+	} //end if
+	firsttoken = NULL;
+	lasttoken = NULL;
+	do
+	{
+		//if the token is a name
+		if (token.type == TT_NAME)
+		{
+			if (defined)
+			{
+				defined = qfalse;
+				t = PC_CopyToken(&token);
+				t->next = NULL;
+				if (lasttoken) lasttoken->next = t;
+				else firsttoken = t;
+				lasttoken = t;
+			} //end if
+			else if (!strcmp(token.string, "defined"))
+			{
+				defined = qtrue;
+				t = PC_CopyToken(&token);
+				t->next = NULL;
+				if (lasttoken) lasttoken->next = t;
+				else firsttoken = t;
+				lasttoken = t;
+			} //end if
+			else
+			{
+				//then it must be a define
+#if DEFINEHASHING
+				define = PC_FindHashedDefine(source->definehash, token.string);
+#else
+				define = PC_FindDefine(source->defines, token.string);
+#endif //DEFINEHASHING
+				if (!define)
+				{
+					SourceError(source, "can't evaluate %s, not defined", token.string);
+					return qfalse;
+				} //end if
+				if (!PC_ExpandDefineIntoSource(source, &token, define)) return qfalse;
+			} //end else
+		} //end if
+		//if the token is a number or a punctuation
+		else if (token.type == TT_NUMBER || token.type == TT_PUNCTUATION)
+		{
+			t = PC_CopyToken(&token);
+			t->next = NULL;
+			if (lasttoken) lasttoken->next = t;
+			else firsttoken = t;
+			lasttoken = t;
+		} //end else
+		else //can't evaluate the token
+		{
+			SourceError(source, "can't evaluate %s", token.string);
+			return qfalse;
+		} //end else
+	} while(PC_ReadLine(source, &token));
+	//
+	if (!PC_EvaluateTokens(source, firsttoken, intvalue, floatvalue, integer)) return qfalse;
+	//
+#ifdef DEBUG_EVAL
+	Log_Write("eval:");
+#endif //DEBUG_EVAL
+	for (t = firsttoken; t; t = nexttoken)
+	{
+#ifdef DEBUG_EVAL
+		Log_Write(" %s", t->string);
+#endif //DEBUG_EVAL
+		nexttoken = t->next;
+		PC_FreeToken(t);
+	} //end for
+#ifdef DEBUG_EVAL
+	if (integer) Log_Write("eval result: %d", *intvalue);
+	else Log_Write("eval result: %f", *floatvalue);
+#endif //DEBUG_EVAL
+	//
+	return qtrue;
+} //end of the function PC_Evaluate
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+int PC_DollarEvaluate(source_t *source, signed long int *intvalue,
+												double *floatvalue, int integer)
+{
+	int indent, defined = qfalse;
+	token_t token, *firsttoken, *lasttoken;
+	token_t *t, *nexttoken;
+	define_t *define;
+
+	if (intvalue) *intvalue = 0;
+	if (floatvalue) *floatvalue = 0;
+	//
+	if (!PC_ReadSourceToken(source, &token))
+	{
+		SourceError(source, "no leading ( after $evalint/$evalfloat");
+		return qfalse;
+	} //end if
+	if (!PC_ReadSourceToken(source, &token))
+	{
+		SourceError(source, "nothing to evaluate");
+		return qfalse;
+	} //end if
+	indent = 1;
+	firsttoken = NULL;
+	lasttoken = NULL;
+	do
+	{
+		//if the token is a name
+		if (token.type == TT_NAME)
+		{
+			if (defined)
+			{
+				defined = qfalse;
+				t = PC_CopyToken(&token);
+				t->next = NULL;
+				if (lasttoken) lasttoken->next = t;
+				else firsttoken = t;
+				lasttoken = t;
+			} //end if
+			else if (!strcmp(token.string, "defined"))
+			{
+				defined = qtrue;
+				t = PC_CopyToken(&token);
+				t->next = NULL;
+				if (lasttoken) lasttoken->next = t;
+				else firsttoken = t;
+				lasttoken = t;
+			} //end if
+			else
+			{
+				//then it must be a define
+#if DEFINEHASHING
+				define = PC_FindHashedDefine(source->definehash, token.string);
+#else
+				define = PC_FindDefine(source->defines, token.string);
+#endif //DEFINEHASHING
+				if (!define)
+				{
+					SourceError(source, "can't evaluate %s, not defined", token.string);
+					return qfalse;
+				} //end if
+				if (!PC_ExpandDefineIntoSource(source, &token, define)) return qfalse;
+			} //end else
+		} //end if
+		//if the token is a number or a punctuation
+		else if (token.type == TT_NUMBER || token.type == TT_PUNCTUATION)
+		{
+			if (*token.string == '(') indent++;
+			else if (*token.string == ')') indent--;
+			if (indent <= 0) break;
+			t = PC_CopyToken(&token);
+			t->next = NULL;
+			if (lasttoken) lasttoken->next = t;
+			else firsttoken = t;
+			lasttoken = t;
+		} //end else
+		else //can't evaluate the token
+		{
+			SourceError(source, "can't evaluate %s", token.string);
+			return qfalse;
+		} //end else
+	} while(PC_ReadSourceToken(source, &token));
+	//
+	if (!PC_EvaluateTokens(source, firsttoken, intvalue, floatvalue, integer)) return qfalse;
+	//
+#ifdef DEBUG_EVAL
+	Log_Write("$eval:");
+#endif //DEBUG_EVAL
+	for (t = firsttoken; t; t = nexttoken)
+	{
+#ifdef DEBUG_EVAL
+		Log_Write(" %s", t->string);
+#endif //DEBUG_EVAL
+		nexttoken = t->next;
+		PC_FreeToken(t);
+	} //end for
+#ifdef DEBUG_EVAL
+	if (integer) Log_Write("$eval result: %d", *intvalue);
+	else Log_Write("$eval result: %f", *floatvalue);
+#endif //DEBUG_EVAL
+	//
+	return qtrue;
+} //end of the function PC_DollarEvaluate
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+int PC_Directive_elif(source_t *source)
+{
+	signed long int value;
+	int type, skip;
+
+	PC_PopIndent(source, &type, &skip);
+	if (!type || type == INDENT_ELSE)
+	{
+		SourceError(source, "misplaced #elif");
+		return qfalse;
+	} //end if
+	if (!PC_Evaluate(source, &value, NULL, qtrue)) return qfalse;
+	skip = (value == 0);
+	PC_PushIndent(source, INDENT_ELIF, skip);
+	return qtrue;
+} //end of the function PC_Directive_elif
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+int PC_Directive_if(source_t *source)
+{
+	signed long int value;
+	int skip;
+
+	if (!PC_Evaluate(source, &value, NULL, qtrue)) return qfalse;
+	skip = (value == 0);
+	PC_PushIndent(source, INDENT_IF, skip);
+	return qtrue;
+} //end of the function PC_Directive
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+int PC_Directive_line(source_t *source)
+{
+	SourceError(source, "#line directive not supported");
+	return qfalse;
+} //end of the function PC_Directive_line
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+int PC_Directive_error(source_t *source)
+{
+	token_t token;
+
+	strcpy(token.string, "");
+	PC_ReadSourceToken(source, &token);
+	SourceError(source, "#error directive: %s", token.string);
+	return qfalse;
+} //end of the function PC_Directive_error
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+int PC_Directive_pragma(source_t *source)
+{
+	token_t token;
+
+	SourceWarning(source, "#pragma directive not supported");
+	while(PC_ReadLine(source, &token)) ;
+	return qtrue;
+} //end of the function PC_Directive_pragma
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+void UnreadSignToken(source_t *source)
+{
+	token_t token;
+
+	token.line = source->scriptstack->line;
+	token.whitespace_p = source->scriptstack->script_p;
+	token.endwhitespace_p = source->scriptstack->script_p;
+	token.linescrossed = 0;
+	strcpy(token.string, "-");
+	token.type = TT_PUNCTUATION;
+	token.subtype = P_SUB;
+	PC_UnreadSourceToken(source, &token);
+} //end of the function UnreadSignToken
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+int PC_Directive_eval(source_t *source)
+{
+	signed long int value;
+	token_t token;
+
+	if (!PC_Evaluate(source, &value, NULL, qtrue)) return qfalse;
+	//
+	token.line = source->scriptstack->line;
+	token.whitespace_p = source->scriptstack->script_p;
+	token.endwhitespace_p = source->scriptstack->script_p;
+	token.linescrossed = 0;
+	sprintf(token.string, "%d", abs(value));
+	token.type = TT_NUMBER;
+	token.subtype = TT_INTEGER|TT_LONG|TT_DECIMAL;
+	PC_UnreadSourceToken(source, &token);
+	if (value < 0) UnreadSignToken(source);
+	return qtrue;
+} //end of the function PC_Directive_eval
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+int PC_Directive_evalfloat(source_t *source)
+{
+	double value;
+	token_t token;
+
+	if (!PC_Evaluate(source, NULL, &value, qfalse)) return qfalse;
+	token.line = source->scriptstack->line;
+	token.whitespace_p = source->scriptstack->script_p;
+	token.endwhitespace_p = source->scriptstack->script_p;
+	token.linescrossed = 0;
+	sprintf(token.string, "%1.2f", fabs(value));
+	token.type = TT_NUMBER;
+	token.subtype = TT_FLOAT|TT_LONG|TT_DECIMAL;
+	PC_UnreadSourceToken(source, &token);
+	if (value < 0) UnreadSignToken(source);
+	return qtrue;
+} //end of the function PC_Directive_evalfloat
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+directive_t directives[20] =
+{
+	{"if", PC_Directive_if},
+	{"ifdef", PC_Directive_ifdef},
+	{"ifndef", PC_Directive_ifndef},
+	{"elif", PC_Directive_elif},
+	{"else", PC_Directive_else},
+	{"endif", PC_Directive_endif},
+	{"include", PC_Directive_include},
+	{"define", PC_Directive_define},
+	{"undef", PC_Directive_undef},
+	{"line", PC_Directive_line},
+	{"error", PC_Directive_error},
+	{"pragma", PC_Directive_pragma},
+	{"eval", PC_Directive_eval},
+	{"evalfloat", PC_Directive_evalfloat},
+	{NULL, NULL}
+};
+
+int PC_ReadDirective(source_t *source)
+{
+	token_t token;
+	int i;
+
+	//read the directive name
+	if (!PC_ReadSourceToken(source, &token))
+	{
+		SourceError(source, "found # without name");
+		return qfalse;
+	} //end if
+	//directive name must be on the same line
+	if (token.linescrossed > 0)
+	{
+		PC_UnreadSourceToken(source, &token);
+		SourceError(source, "found # at end of line");
+		return qfalse;
+	} //end if
+	//if if is a name
+	if (token.type == TT_NAME)
+	{
+		//find the precompiler directive
+		for (i = 0; directives[i].name; i++)
+		{
+			if (!strcmp(directives[i].name, token.string))
+			{
+				return directives[i].func(source);
+			} //end if
+		} //end for
+	} //end if
+	SourceError(source, "unknown precompiler directive %s", token.string);
+	return qfalse;
+} //end of the function PC_ReadDirective
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+int PC_DollarDirective_evalint(source_t *source)
+{
+	signed long int value;
+	token_t token;
+
+	if (!PC_DollarEvaluate(source, &value, NULL, qtrue)) return qfalse;
+	//
+	token.line = source->scriptstack->line;
+	token.whitespace_p = source->scriptstack->script_p;
+	token.endwhitespace_p = source->scriptstack->script_p;
+	token.linescrossed = 0;
+	sprintf(token.string, "%d", abs(value));
+	token.type = TT_NUMBER;
+	token.subtype = TT_INTEGER|TT_LONG|TT_DECIMAL;
+#ifdef NUMBERVALUE
+	token.intvalue = value;
+	token.floatvalue = value;
+#endif //NUMBERVALUE
+	PC_UnreadSourceToken(source, &token);
+	if (value < 0) UnreadSignToken(source);
+	return qtrue;
+} //end of the function PC_DollarDirective_evalint
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+int PC_DollarDirective_evalfloat(source_t *source)
+{
+	double value;
+	token_t token;
+
+	if (!PC_DollarEvaluate(source, NULL, &value, qfalse)) return qfalse;
+	token.line = source->scriptstack->line;
+	token.whitespace_p = source->scriptstack->script_p;
+	token.endwhitespace_p = source->scriptstack->script_p;
+	token.linescrossed = 0;
+	sprintf(token.string, "%1.2f", fabs(value));
+	token.type = TT_NUMBER;
+	token.subtype = TT_FLOAT|TT_LONG|TT_DECIMAL;
+#ifdef NUMBERVALUE
+	token.intvalue = (unsigned long) value;
+	token.floatvalue = value;
+#endif //NUMBERVALUE
+	PC_UnreadSourceToken(source, &token);
+	if (value < 0) UnreadSignToken(source);
+	return qtrue;
+} //end of the function PC_DollarDirective_evalfloat
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+directive_t dollardirectives[20] =
+{
+	{"evalint", PC_DollarDirective_evalint},
+	{"evalfloat", PC_DollarDirective_evalfloat},
+	{NULL, NULL}
+};
+
+int PC_ReadDollarDirective(source_t *source)
+{
+	token_t token;
+	int i;
+
+	//read the directive name
+	if (!PC_ReadSourceToken(source, &token))
+	{
+		SourceError(source, "found $ without name");
+		return qfalse;
+	} //end if
+	//directive name must be on the same line
+	if (token.linescrossed > 0)
+	{
+		PC_UnreadSourceToken(source, &token);
+		SourceError(source, "found $ at end of line");
+		return qfalse;
+	} //end if
+	//if if is a name
+	if (token.type == TT_NAME)
+	{
+		//find the precompiler directive
+		for (i = 0; dollardirectives[i].name; i++)
+		{
+			if (!strcmp(dollardirectives[i].name, token.string))
+			{
+				return dollardirectives[i].func(source);
+			} //end if
+		} //end for
+	} //end if
+	PC_UnreadSourceToken(source, &token);
+	SourceError(source, "unknown precompiler directive %s", token.string);
+	return qfalse;
+} //end of the function PC_ReadDirective
+
+#ifdef QUAKEC
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+int BuiltinFunction(source_t *source)
+{
+	token_t token;
+
+	if (!PC_ReadSourceToken(source, &token)) return qfalse;
+	if (token.type == TT_NUMBER)
+	{
+		PC_UnreadSourceToken(source, &token);
+		return qtrue;
+	} //end if
+	else
+	{
+		PC_UnreadSourceToken(source, &token);
+		return qfalse;
+	} //end else
+} //end of the function BuiltinFunction
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+int QuakeCMacro(source_t *source)
+{
+	int i;
+	token_t token;
+
+	if (!PC_ReadSourceToken(source, &token)) return qtrue;
+	if (token.type != TT_NAME)
+	{
+		PC_UnreadSourceToken(source, &token);
+		return qtrue;
+	} //end if
+	//find the precompiler directive
+	for (i = 0; dollardirectives[i].name; i++)
+	{
+		if (!strcmp(dollardirectives[i].name, token.string))
+		{
+			PC_UnreadSourceToken(source, &token);
+			return qfalse;
+		} //end if
+	} //end for
+	PC_UnreadSourceToken(source, &token);
+	return qtrue;
+} //end of the function QuakeCMacro
+#endif //QUAKEC
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+int PC_ReadToken(source_t *source, token_t *token)
+{
+	define_t *define;
+
+	while(1)
+	{
+		if (!PC_ReadSourceToken(source, token)) return qfalse;
+		//check for precompiler directives
+		if (token->type == TT_PUNCTUATION && *token->string == '@')	// It is a StringEd key
+		{
+			char *holdString,holdString2[MAX_TOKEN];
+
+			PC_ReadSourceToken(source, token);
+			holdString = &token->string[1];
+			Com_Memcpy( holdString2, token->string, sizeof(token->string));
+			Com_Memcpy( holdString, holdString2, sizeof(token->string));
+			token->string[0] = '@';
+			return qtrue;
+		}
+
+		if (token->type == TT_PUNCTUATION && *token->string == '#')
+		{
+#ifdef QUAKEC
+			if (!BuiltinFunction(source))
+#endif //QUAKC
+			{
+				//read the precompiler directive
+				if (!PC_ReadDirective(source)) return qfalse;
+				continue;
+			} //end if
+		} //end if
+		if (token->type == TT_PUNCTUATION && *token->string == '$')
+		{
+#ifdef QUAKEC
+			if (!QuakeCMacro(source))
+#endif //QUAKEC
+			{
+				//read the precompiler directive
+				if (!PC_ReadDollarDirective(source)) return qfalse;
+				continue;
+			} //end if
+		} //end if
+		// recursively concatenate strings that are behind each other still resolving defines
+		if (token->type == TT_STRING)
+		{
+			token_t newtoken;
+			if (PC_ReadToken(source, &newtoken))
+			{
+				if (newtoken.type == TT_STRING)
+				{
+					token->string[strlen(token->string)-1] = '\0';
+					if (strlen(token->string) + strlen(newtoken.string+1) + 1 >= MAX_TOKEN)
+					{
+						SourceError(source, "string longer than MAX_TOKEN %d\n", MAX_TOKEN);
+						return qfalse;
+					}
+					strcat(token->string, newtoken.string+1);
+				}
+				else
+				{
+					PC_UnreadToken(source, &newtoken);
+				}
+			}
+		} //end if
+		//if skipping source because of conditional compilation
+		if (source->skip) continue;
+		//if the token is a name
+		if (token->type == TT_NAME)
+		{
+			//check if the name is a define macro
+#if DEFINEHASHING
+			define = PC_FindHashedDefine(source->definehash, token->string);
+#else
+			define = PC_FindDefine(source->defines, token->string);
+#endif //DEFINEHASHING
+			//if it is a define macro
+			if (define)
+			{
+				//expand the defined macro
+				if (!PC_ExpandDefineIntoSource(source, token, define)) return qfalse;
+				continue;
+			} //end if
+		} //end if
+		//copy token for unreading
+		Com_Memcpy(&source->token, token, sizeof(token_t));
+		//found a token
+		return qtrue;
+	} //end while
+} //end of the function PC_ReadToken
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+int PC_ExpectTokenString(source_t *source, char *string)
+{
+	token_t token;
+
+	if (!PC_ReadToken(source, &token))
+	{
+		SourceError(source, "couldn't find expected %s", string);
+		return qfalse;
+	} //end if
+
+	if (strcmp(token.string, string))
+	{
+		SourceError(source, "expected %s, found %s", string, token.string);
+		return qfalse;
+	} //end if
+	return qtrue;
+} //end of the function PC_ExpectTokenString
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+int PC_ExpectTokenType(source_t *source, int type, int subtype, token_t *token)
+{
+	char str[MAX_TOKEN];
+
+	if (!PC_ReadToken(source, token))
+	{
+		SourceError(source, "couldn't read expected token");
+		return qfalse;
+	} //end if
+
+	if (token->type != type)
+	{
+		strcpy(str, "");
+		if (type == TT_STRING) strcpy(str, "string");
+		if (type == TT_LITERAL) strcpy(str, "literal");
+		if (type == TT_NUMBER) strcpy(str, "number");
+		if (type == TT_NAME) strcpy(str, "name");
+		if (type == TT_PUNCTUATION) strcpy(str, "punctuation");
+		SourceError(source, "expected a %s, found %s", str, token->string);
+		return qfalse;
+	} //end if
+	if (token->type == TT_NUMBER)
+	{
+		if ((token->subtype & subtype) != subtype)
+		{
+			if (subtype & TT_DECIMAL) strcpy(str, "decimal");
+			if (subtype & TT_HEX) strcpy(str, "hex");
+			if (subtype & TT_OCTAL) strcpy(str, "octal");
+			if (subtype & TT_BINARY) strcpy(str, "binary");
+			if (subtype & TT_LONG) strcat(str, " long");
+			if (subtype & TT_UNSIGNED) strcat(str, " unsigned");
+			if (subtype & TT_FLOAT) strcat(str, " float");
+			if (subtype & TT_INTEGER) strcat(str, " integer");
+			SourceError(source, "expected %s, found %s", str, token->string);
+			return qfalse;
+		} //end if
+	} //end if
+	else if (token->type == TT_PUNCTUATION)
+	{
+		if (token->subtype != subtype)
+		{
+			SourceError(source, "found %s", token->string);
+			return qfalse;
+		} //end if
+	} //end else if
+	return qtrue;
+} //end of the function PC_ExpectTokenType
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+int PC_ExpectAnyToken(source_t *source, token_t *token)
+{
+	if (!PC_ReadToken(source, token))
+	{
+		SourceError(source, "couldn't read expected token");
+		return qfalse;
+	} //end if
+	else
+	{
+		return qtrue;
+	} //end else
+} //end of the function PC_ExpectAnyToken
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+int PC_CheckTokenString(source_t *source, char *string)
+{
+	token_t tok;
+
+	if (!PC_ReadToken(source, &tok)) return qfalse;
+	//if the token is available
+	if (!strcmp(tok.string, string)) return qtrue;
+	//
+	PC_UnreadSourceToken(source, &tok);
+	return qfalse;
+} //end of the function PC_CheckTokenString
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+int PC_CheckTokenType(source_t *source, int type, int subtype, token_t *token)
+{
+	token_t tok;
+
+	if (!PC_ReadToken(source, &tok)) return qfalse;
+	//if the type matches
+	if (tok.type == type &&
+			(tok.subtype & subtype) == subtype)
+	{
+		Com_Memcpy(token, &tok, sizeof(token_t));
+		return qtrue;
+	} //end if
+	//
+	PC_UnreadSourceToken(source, &tok);
+	return qfalse;
+} //end of the function PC_CheckTokenType
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+int PC_SkipUntilString(source_t *source, char *string)
+{
+	token_t token;
+
+	while(PC_ReadToken(source, &token))
+	{
+		if (!strcmp(token.string, string)) return qtrue;
+	} //end while
+	return qfalse;
+} //end of the function PC_SkipUntilString
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+void PC_UnreadLastToken(source_t *source)
+{
+	PC_UnreadSourceToken(source, &source->token);
+} //end of the function PC_UnreadLastToken
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+void PC_UnreadToken(source_t *source, token_t *token)
+{
+	PC_UnreadSourceToken(source, token);
+} //end of the function PC_UnreadToken
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+void PC_SetIncludePath(source_t *source, char *path)
+{
+	strncpy(source->includepath, path, MAX_PATH);
+	//add trailing path seperator
+	if (source->includepath[strlen(source->includepath)-1] != '\\' &&
+		source->includepath[strlen(source->includepath)-1] != '/')
+	{
+		strcat(source->includepath, PATHSEPERATOR_STR);
+	} //end if
+} //end of the function PC_SetIncludePath
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+void PC_SetPunctuations(source_t *source, punctuation_t *p)
+{
+	source->punctuations = p;
+} //end of the function PC_SetPunctuations
+//============================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//============================================================================
+source_t *LoadSourceFile(const char *filename)
+{
+	source_t *source;
+	script_t *script;
+
+	PC_InitTokenHeap();
+
+#if DEFINEHASHING
+	if ( !globaldefines )
+	{
+		globaldefines = (struct define_s **)GetClearedMemory(DEFINEHASHSIZE * sizeof(define_t *));
+	}
+#endif
+
+	script = LoadScriptFile(filename);
+	if (!script) return NULL;
+
+	script->next = NULL;
+
+	source = (source_t *) GetMemory(sizeof(source_t));
+	Com_Memset(source, 0, sizeof(source_t));
+
+	strncpy(source->filename, filename, MAX_PATH);
+	source->scriptstack = script;
+	source->tokens = NULL;
+	source->defines = NULL;
+	source->indentstack = NULL;
+	source->skip = 0;
+
+#if DEFINEHASHING
+	source->definehash = (struct define_s **)GetClearedMemory(DEFINEHASHSIZE * sizeof(define_t *));
+#endif //DEFINEHASHING
+	PC_AddGlobalDefinesToSource(source);
+	return source;
+} //end of the function LoadSourceFile
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+source_t *LoadSourceMemory(char *ptr, int length, char *name)
+{
+	source_t *source;
+	script_t *script;
+
+	PC_InitTokenHeap();
+
+	script = LoadScriptMemory(ptr, length, name);
+	if (!script) return NULL;
+	script->next = NULL;
+
+	source = (source_t *) GetMemory(sizeof(source_t));
+	Com_Memset(source, 0, sizeof(source_t));
+
+	strncpy(source->filename, name, MAX_PATH);
+	source->scriptstack = script;
+	source->tokens = NULL;
+	source->defines = NULL;
+	source->indentstack = NULL;
+	source->skip = 0;
+
+#if DEFINEHASHING
+	source->definehash = (struct define_s **)GetClearedMemory(DEFINEHASHSIZE * sizeof(define_t *));
+#endif //DEFINEHASHING
+	PC_AddGlobalDefinesToSource(source);
+	return source;
+} //end of the function LoadSourceMemory
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+void FreeSource(source_t *source)
+{
+	script_t *script;
+	token_t *token;
+	define_t *define;
+	indent_t *indent;
+	define_t *nextdefine;
+	int i;
+
+	//PC_PrintDefineHashTable(source->definehash);
+	//free all the scripts
+	while(source->scriptstack)
+	{
+		script = source->scriptstack;
+		source->scriptstack = source->scriptstack->next;
+		FreeScript(script);
+	} //end for
+	//free all the tokens
+	while(source->tokens)
+	{
+		token = source->tokens;
+		source->tokens = source->tokens->next;
+		PC_FreeToken(token);
+	} //end for
+#if DEFINEHASHING
+	for (i = 0; i < DEFINEHASHSIZE; i++)
+	{
+		define = source->definehash[i];
+		while(define)
+		{
+			nextdefine = define->hashnext; 			
+
+			if ( !(define->flags & DEFINE_GLOBAL) )
+			{
+				PC_FreeDefine(define);
+			}
+
+			define = nextdefine;
+		} //end while
+
+		source->definehash[i] = NULL;
+	} //end for
+#else //DEFINEHASHING
+	//free all defines
+	while(source->defines)
+	{
+		define = source->defines;
+		source->defines = source->defines->next;
+		PC_FreeDefine(define);
+	} //end for
+#endif //DEFINEHASHING
+	//free all indents
+	while(source->indentstack)
+	{
+		indent = source->indentstack;
+		source->indentstack = source->indentstack->next;
+		FreeMemory(indent);
+	} //end for
+#if DEFINEHASHING
+	//
+	if (source->definehash) FreeMemory(source->definehash);
+#endif //DEFINEHASHING
+	//free the source itself
+	FreeMemory(source);
+} //end of the function FreeSource
+//============================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//============================================================================
+
+#define MAX_SOURCEFILES		64
+
+source_t *sourceFiles[MAX_SOURCEFILES];
+
+int PC_LoadSourceHandle(const char *filename)
+{
+	source_t *source;
+	int i;
+
+	for (i = 1; i < MAX_SOURCEFILES; i++)
+	{
+		if (!sourceFiles[i])
+			break;
+	} //end for
+	if (i >= MAX_SOURCEFILES)
+		return 0;
+	PS_SetBaseFolder("");
+	source = LoadSourceFile(filename);
+	if (!source)
+		return 0;
+	sourceFiles[i] = source;
+	return i;
+} //end of the function PC_LoadSourceHandle
+//============================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//============================================================================
+int PC_FreeSourceHandle(int handle)
+{
+	if (handle < 1 || handle >= MAX_SOURCEFILES)
+		return qfalse;
+	if (!sourceFiles[handle])
+		return qfalse;
+
+	FreeSource(sourceFiles[handle]);
+	sourceFiles[handle] = NULL;
+	return qtrue;
+} //end of the function PC_FreeSourceHandle
+
+int PC_LoadGlobalDefines ( const char* filename )
+{
+	int		handle;
+	token_t token;
+
+	handle = PC_LoadSourceHandle ( filename );
+	if ( handle < 1 )
+		return qfalse;
+
+	addGlobalDefine = qtrue;
+
+	// Read all the token files which will add the defines globally
+	while ( PC_ReadToken(sourceFiles[handle], &token) );
+
+	addGlobalDefine = qfalse;
+
+	PC_FreeSourceHandle ( handle );
+
+	return qtrue;
+}
+
+//============================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//============================================================================
+int PC_ReadTokenHandle(int handle, pc_token_t *pc_token)
+{
+	token_t token;
+	int ret;
+
+	if (handle < 1 || handle >= MAX_SOURCEFILES)
+		return 0;
+	if (!sourceFiles[handle])
+		return 0;
+
+	ret = PC_ReadToken(sourceFiles[handle], &token);
+	strcpy(pc_token->string, token.string);
+	pc_token->type = token.type;
+	pc_token->subtype = token.subtype;
+	pc_token->intvalue = token.intvalue;
+	pc_token->floatvalue = token.floatvalue;
+	if ((pc_token->type == TT_STRING) && (pc_token->string[0]!='@'))
+		StripDoubleQuotes(pc_token->string);
+
+	return ret;
+} //end of the function PC_ReadTokenHandle
+//============================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//============================================================================
+int PC_SourceFileAndLine(int handle, char *filename, int *line)
+{
+	if (handle < 1 || handle >= MAX_SOURCEFILES)
+		return qfalse;
+	if (!sourceFiles[handle])
+		return qfalse;
+
+	strcpy(filename, sourceFiles[handle]->filename);
+	if (sourceFiles[handle]->scriptstack)
+		*line = sourceFiles[handle]->scriptstack->line;
+	else
+		*line = 0;
+	return qtrue;
+} //end of the function PC_SourceFileAndLine
+//============================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//============================================================================
+void PC_SetBaseFolder(char *path)
+{
+	PS_SetBaseFolder(path);
+} //end of the function PC_SetBaseFolder
+//============================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//============================================================================
+void PC_CheckOpenSourceHandles(void)
+{
+	int i;
+
+	for (i = 1; i < MAX_SOURCEFILES; i++)
+	{
+		if (sourceFiles[i])
+		{
+#ifdef BOTLIB
+			botimport.Print(PRT_ERROR, "file %s still open in precompiler\n", sourceFiles[i]->scriptstack->filename);
+#endif	//BOTLIB
+		} //end if
+	} //end for
+} //end of the function PC_CheckOpenSourceHandles
+
diff --git a/codemp/botlib/l_precomp.h b/codemp/botlib/l_precomp.h
new file mode 100644
index 0000000..34a0aed
--- /dev/null
+++ b/codemp/botlib/l_precomp.h
@@ -0,0 +1,168 @@
+
+/*****************************************************************************
+ * name:		l_precomp.h
+ *
+ * desc:		pre compiler
+ *
+ * $Archive: /source/code/botlib/l_precomp.h $
+ * $Author: Mrelusive $ 
+ * $Revision: 2 $
+ * $Modtime: 10/05/99 3:32p $
+ * $Date: 10/05/99 3:42p $
+ *
+ *****************************************************************************/
+
+#ifndef MAX_PATH
+	#define MAX_PATH			MAX_QPATH
+#endif
+
+#ifndef PATH_SEPERATORSTR
+	#if defined(WIN32)|defined(_WIN32)|defined(__NT__)|defined(__WINDOWS__)|defined(__WINDOWS_386__)
+		#define PATHSEPERATOR_STR		"\\"
+	#else
+		#define PATHSEPERATOR_STR		"/"
+	#endif
+#endif
+#ifndef PATH_SEPERATORCHAR
+	#if defined(WIN32)|defined(_WIN32)|defined(__NT__)|defined(__WINDOWS__)|defined(__WINDOWS_386__)
+		#define PATHSEPERATOR_CHAR		'\\'
+	#else
+		#define PATHSEPERATOR_CHAR		'/'
+	#endif
+#endif
+
+#if defined(BSPC) && !defined(QDECL)
+#define QDECL
+#endif
+
+
+#define DEFINE_FIXED			0x0001
+#define	DEFINE_GLOBAL			0x0002
+
+#define BUILTIN_LINE			1
+#define BUILTIN_FILE			2
+#define BUILTIN_DATE			3
+#define BUILTIN_TIME			4
+#define BUILTIN_STDC			5
+
+#define INDENT_IF				0x0001
+#define INDENT_ELSE				0x0002
+#define INDENT_ELIF				0x0004
+#define INDENT_IFDEF			0x0008
+#define INDENT_IFNDEF			0x0010
+
+//macro definitions
+typedef struct define_s
+{
+	char *name;							//define name
+	int flags;							//define flags
+	int builtin;						// > 0 if builtin define
+	int numparms;						//number of define parameters
+	token_t *parms;						//define parameters
+	token_t *tokens;					//macro tokens (possibly containing parm tokens)
+	struct define_s *next;				//next defined macro in a list
+	struct define_s *hashnext;			//next define in the hash chain
+	struct define_s *globalnext;		//used to link up the globald defines
+} define_t;
+
+//indents
+//used for conditional compilation directives:
+//#if, #else, #elif, #ifdef, #ifndef
+typedef struct indent_s
+{
+	int type;								//indent type
+	int skip;								//true if skipping current indent
+	script_t *script;						//script the indent was in
+	struct indent_s *next;					//next indent on the indent stack
+} indent_t;
+
+//source file
+typedef struct source_s
+{
+	char filename[1024];					//file name of the script
+	char includepath[1024];					//path to include files
+	punctuation_t *punctuations;			//punctuations to use
+	script_t *scriptstack;					//stack with scripts of the source
+	token_t *tokens;						//tokens to read first
+	define_t *defines;						//list with macro definitions
+	define_t **definehash;					//hash chain with defines
+	indent_t *indentstack;					//stack with indents
+	int skip;								// > 0 if skipping conditional code
+	token_t token;							//last read token
+} source_t;
+
+
+//read a token from the source
+int PC_ReadToken(source_t *source, token_t *token);
+//expect a certain token
+int PC_ExpectTokenString(source_t *source, char *string);
+//expect a certain token type
+int PC_ExpectTokenType(source_t *source, int type, int subtype, token_t *token);
+//expect a token
+int PC_ExpectAnyToken(source_t *source, token_t *token);
+//returns true when the token is available
+int PC_CheckTokenString(source_t *source, char *string);
+//returns true an reads the token when a token with the given type is available
+int PC_CheckTokenType(source_t *source, int type, int subtype, token_t *token);
+//skip tokens until the given token string is read
+int PC_SkipUntilString(source_t *source, char *string);
+//unread the last token read from the script
+void PC_UnreadLastToken(source_t *source);
+//unread the given token
+void PC_UnreadToken(source_t *source, token_t *token);
+//read a token only if on the same line, lines are concatenated with a slash
+int PC_ReadLine(source_t *source, token_t *token);
+//returns true if there was a white space in front of the token
+int PC_WhiteSpaceBeforeToken(token_t *token);
+//add a define to the source
+int PC_AddDefine(source_t *source, char *string);
+//add a globals define that will be added to all opened sources
+int PC_AddGlobalDefine(char *string);
+//remove the given global define
+int PC_RemoveGlobalDefine(char *name);
+//remove all globals defines
+void PC_RemoveAllGlobalDefines(void);
+//add builtin defines
+void PC_AddBuiltinDefines(source_t *source);
+//set the source include path
+void PC_SetIncludePath(source_t *source, char *path);
+//set the punction set
+void PC_SetPunctuations(source_t *source, punctuation_t *p);
+//set the base folder to load files from
+void PC_SetBaseFolder(char *path);
+//load a source file
+source_t *LoadSourceFile(const char *filename);
+//load a source from memory
+source_t *LoadSourceMemory(char *ptr, int length, char *name);
+//free the given source
+void FreeSource(source_t *source);
+//print a source error
+void QDECL SourceError(source_t *source, char *str, ...);
+//print a source warning
+void QDECL SourceWarning(source_t *source, char *str, ...);
+
+#ifdef BSPC
+// some of BSPC source does include game/q_shared.h and some does not
+// we define pc_token_s pc_token_t if needed (yes, it's ugly)
+#ifndef __Q_SHARED_H
+#define MAX_TOKENLENGTH		1024
+typedef struct pc_token_s
+{
+	int type;
+	int subtype;
+	int intvalue;
+	float floatvalue;
+	char string[MAX_TOKENLENGTH];
+} pc_token_t;
+#endif //!_Q_SHARED_H
+#endif //BSPC
+
+//
+int PC_LoadSourceHandle(const char *filename);
+int PC_FreeSourceHandle(int handle);
+int PC_ReadTokenHandle(int handle, pc_token_t *pc_token);
+int PC_SourceFileAndLine(int handle, char *filename, int *line);
+void PC_CheckOpenSourceHandles(void);
+int PC_LoadGlobalDefines ( const char* filename );
+void PC_RemoveAllGlobalDefines ( void );
+
diff --git a/codemp/botlib/l_script.cpp b/codemp/botlib/l_script.cpp
new file mode 100644
index 0000000..1daea25
--- /dev/null
+++ b/codemp/botlib/l_script.cpp
@@ -0,0 +1,1418 @@
+
+/*****************************************************************************
+ * name:		l_script.c
+ *
+ * desc:		lexicographical parser
+ *
+ * $Archive: /MissionPack/code/botlib/l_script.c $
+ * $Author: Ttimo $ 
+ * $Revision: 9 $
+ * $Modtime: 4/13/01 4:45p $
+ * $Date: 4/13/01 4:45p $
+ *
+ *****************************************************************************/
+
+//#define SCREWUP
+//#define BOTLIB
+//#define MEQCC
+//#define BSPC
+
+#ifdef SCREWUP
+#include <stdio.h>
+#include <stdlib.h>
+#include <limits.h>
+#include <string.h>
+#include <stdarg.h>
+#include "l_memory.h"
+#include "l_script.h"
+
+typedef enum {qfalse, qtrue}	qboolean;
+
+#endif //SCREWUP
+
+#ifdef BOTLIB
+//include files for usage in the bot library
+#include "../game/q_shared.h"
+#include "../game/botlib.h"
+#include "be_interface.h"
+#include "l_script.h"
+#include "l_memory.h"
+#include "l_log.h"
+#include "l_libvar.h"
+#endif //BOTLIB
+
+#ifdef MEQCC
+//include files for usage in MrElusive's QuakeC Compiler
+#include "qcc.h"
+#include "l_script.h"
+#include "l_memory.h"
+#include "l_log.h"
+
+#define qtrue	true
+#define qfalse	false
+#endif //MEQCC
+
+#ifdef BSPC
+//include files for usage in the BSP Converter
+#include "../bspc/qbsp.h"
+#include "../bspc/l_log.h"
+#include "../bspc/l_mem.h"
+
+#define qtrue	true
+#define qfalse	false
+#endif //BSPC
+
+
+#define PUNCTABLE
+
+//longer punctuations first
+punctuation_t default_punctuations[] =
+{
+	//binary operators
+	{">>=",P_RSHIFT_ASSIGN, NULL},
+	{"<<=",P_LSHIFT_ASSIGN, NULL},
+	//
+	{"...",P_PARMS, NULL},
+	//define merge operator
+	{"##",P_PRECOMPMERGE, NULL},
+	//logic operators
+	{"&&",P_LOGIC_AND, NULL},
+	{"||",P_LOGIC_OR, NULL},
+	{">=",P_LOGIC_GEQ, NULL},
+	{"<=",P_LOGIC_LEQ, NULL},
+	{"==",P_LOGIC_EQ, NULL},
+	{"!=",P_LOGIC_UNEQ, NULL},
+	//arithmatic operators
+	{"*=",P_MUL_ASSIGN, NULL},
+	{"/=",P_DIV_ASSIGN, NULL},
+	{"%=",P_MOD_ASSIGN, NULL},
+	{"+=",P_ADD_ASSIGN, NULL},
+	{"-=",P_SUB_ASSIGN, NULL},
+	{"++",P_INC, NULL},
+	{"--",P_DEC, NULL},
+	//binary operators
+	{"&=",P_BIN_AND_ASSIGN, NULL},
+	{"|=",P_BIN_OR_ASSIGN, NULL},
+	{"^=",P_BIN_XOR_ASSIGN, NULL},
+	{">>",P_RSHIFT, NULL},
+	{"<<",P_LSHIFT, NULL},
+	//reference operators
+	{"->",P_POINTERREF, NULL},
+	//C++
+	{"::",P_CPP1, NULL},
+	{".*",P_CPP2, NULL},
+	//arithmatic operators
+	{"*",P_MUL, NULL},
+	{"/",P_DIV, NULL},
+	{"%",P_MOD, NULL},
+	{"+",P_ADD, NULL},
+	{"-",P_SUB, NULL},
+	{"=",P_ASSIGN, NULL},
+	//binary operators
+	{"&",P_BIN_AND, NULL},
+	{"|",P_BIN_OR, NULL},
+	{"^",P_BIN_XOR, NULL},
+	{"~",P_BIN_NOT, NULL},
+	//logic operators
+	{"!",P_LOGIC_NOT, NULL},
+	{">",P_LOGIC_GREATER, NULL},
+	{"<",P_LOGIC_LESS, NULL},
+	//reference operator
+	{".",P_REF, NULL},
+	//seperators
+	{",",P_COMMA, NULL},
+	{";",P_SEMICOLON, NULL},
+	//label indication
+	{":",P_COLON, NULL},
+	//if statement
+	{"?",P_QUESTIONMARK, NULL},
+	//embracements
+	{"(",P_PARENTHESESOPEN, NULL},
+	{")",P_PARENTHESESCLOSE, NULL},
+	{"{",P_BRACEOPEN, NULL},
+	{"}",P_BRACECLOSE, NULL},
+	{"[",P_SQBRACKETOPEN, NULL},
+	{"]",P_SQBRACKETCLOSE, NULL},
+	//
+	{"\\",P_BACKSLASH, NULL},
+	//precompiler operator
+	{"#",P_PRECOMP, NULL},
+#ifdef DOLLAR
+	{"$",P_DOLLAR, NULL},
+#endif //DOLLAR
+	// StringEd key
+	{"@",P_ATSIGN, NULL},
+	{NULL, 0}
+};
+
+#ifdef BSPC
+char basefolder[MAX_PATH];
+#else
+char basefolder[MAX_QPATH];
+#endif
+
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void PS_CreatePunctuationTable(script_t *script, punctuation_t *punctuations)
+{
+	int i;
+	punctuation_t *p, *lastp, *newp;
+
+	//get memory for the table
+	if (!script->punctuationtable) script->punctuationtable = (punctuation_t **)
+												GetMemory(256 * sizeof(punctuation_t *));
+	Com_Memset(script->punctuationtable, 0, 256 * sizeof(punctuation_t *));
+	//add the punctuations in the list to the punctuation table
+	for (i = 0; punctuations[i].p; i++)
+	{
+		newp = &punctuations[i];
+		lastp = NULL;
+		//sort the punctuations in this table entry on length (longer punctuations first)
+		for (p = script->punctuationtable[(unsigned int) newp->p[0]]; p; p = p->next)
+		{
+			if (strlen(p->p) < strlen(newp->p))
+			{
+				newp->next = p;
+				if (lastp) lastp->next = newp;
+				else script->punctuationtable[(unsigned int) newp->p[0]] = newp;
+				break;
+			} //end if
+			lastp = p;
+		} //end for
+		if (!p)
+		{
+			newp->next = NULL;
+			if (lastp) lastp->next = newp;
+			else script->punctuationtable[(unsigned int) newp->p[0]] = newp;
+		} //end if
+	} //end for
+} //end of the function PS_CreatePunctuationTable
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+char *PunctuationFromNum(script_t *script, int num)
+{
+	int i;
+
+	for (i = 0; script->punctuations[i].p; i++)
+	{
+		if (script->punctuations[i].n == num) return script->punctuations[i].p;
+	} //end for
+	return "unkown punctuation";
+} //end of the function PunctuationFromNum
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void QDECL ScriptError(script_t *script, char *str, ...)
+{
+	char text[1024];
+	va_list ap;
+
+	if (script->flags & SCFL_NOERRORS) return;
+
+	va_start(ap, str);
+	vsprintf(text, str, ap);
+	va_end(ap);
+#ifdef BOTLIB
+	botimport.Print(PRT_ERROR, "file %s, line %d: %s\n", script->filename, script->line, text);
+#endif //BOTLIB
+#ifdef MEQCC
+	printf("error: file %s, line %d: %s\n", script->filename, script->line, text);
+#endif //MEQCC
+#ifdef BSPC
+	Log_Print("error: file %s, line %d: %s\n", script->filename, script->line, text);
+#endif //BSPC
+} //end of the function ScriptError
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void QDECL ScriptWarning(script_t *script, char *str, ...)
+{
+	char text[1024];
+	va_list ap;
+
+	if (script->flags & SCFL_NOWARNINGS) return;
+
+	va_start(ap, str);
+	vsprintf(text, str, ap);
+	va_end(ap);
+#ifdef BOTLIB
+	botimport.Print(PRT_WARNING, "file %s, line %d: %s\n", script->filename, script->line, text);
+#endif //BOTLIB
+#ifdef MEQCC
+	printf("warning: file %s, line %d: %s\n", script->filename, script->line, text);
+#endif //MEQCC
+#ifdef BSPC
+	Log_Print("warning: file %s, line %d: %s\n", script->filename, script->line, text);
+#endif //BSPC
+} //end of the function ScriptWarning
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+void SetScriptPunctuations(script_t *script, punctuation_t *p)
+{
+#ifdef PUNCTABLE
+	if (p) PS_CreatePunctuationTable(script, p);
+	else  PS_CreatePunctuationTable(script, default_punctuations);
+#endif //PUNCTABLE
+	if (p) script->punctuations = p;
+	else script->punctuations = default_punctuations;
+} //end of the function SetScriptPunctuations
+//============================================================================
+// Reads spaces, tabs, C-like comments etc.
+// When a newline character is found the scripts line counter is increased.
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+int PS_ReadWhiteSpace(script_t *script)
+{
+	while(1)
+	{
+		//skip white space
+		while(*script->script_p <= ' ')
+		{
+			if (!*script->script_p) return 0;
+			if (*script->script_p == '\n') script->line++;
+			script->script_p++;
+		} //end while
+		//skip comments
+		if (*script->script_p == '/')
+		{
+			//comments //
+			if (*(script->script_p+1) == '/')
+			{
+				script->script_p++;
+				do
+				{
+					script->script_p++;
+					if (!*script->script_p) return 0;
+				} //end do
+				while(*script->script_p != '\n');
+				script->line++;
+				script->script_p++;
+				if (!*script->script_p) return 0;
+				continue;
+			} //end if
+			//comments /* */
+			else if (*(script->script_p+1) == '*')
+			{
+				script->script_p++;
+				do
+				{
+					script->script_p++;
+					if (!*script->script_p) return 0;
+					if (*script->script_p == '\n') script->line++;
+				} //end do
+				while(!(*script->script_p == '*' && *(script->script_p+1) == '/'));
+				script->script_p++;
+				if (!*script->script_p) return 0;
+				script->script_p++;
+				if (!*script->script_p) return 0;
+				continue;
+			} //end if
+		} //end if
+		break;
+	} //end while
+	return 1;
+} //end of the function PS_ReadWhiteSpace
+//============================================================================
+// Reads an escape character.
+//
+// Parameter:				script		: script to read from
+//								ch				: place to store the read escape character
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+int PS_ReadEscapeCharacter(script_t *script, char *ch)
+{
+	int c, val, i;
+
+	//step over the leading '\\'
+	script->script_p++;
+	//determine the escape character
+	switch(*script->script_p)
+	{
+		case '\\': c = '\\'; break;
+		case 'n': c = '\n'; break;
+		case 'r': c = '\r'; break;
+		case 't': c = '\t'; break;
+		case 'v': c = '\v'; break;
+		case 'b': c = '\b'; break;
+		case 'f': c = '\f'; break;
+		case 'a': c = '\a'; break;
+		case '\'': c = '\''; break;
+		case '\"': c = '\"'; break;
+		case '\?': c = '\?'; break;
+		case 'x':
+		{
+			script->script_p++;
+			for (i = 0, val = 0; ; i++, script->script_p++)
+			{
+				c = *script->script_p;
+				if (c >= '0' && c <= '9') c = c - '0';
+				else if (c >= 'A' && c <= 'Z') c = c - 'A' + 10;
+				else if (c >= 'a' && c <= 'z') c = c - 'a' + 10;
+				else break;
+				val = (val << 4) + c;
+			} //end for
+			script->script_p--;
+			if (val > 0xFF)
+			{
+				ScriptWarning(script, "too large value in escape character");
+				val = 0xFF;
+			} //end if
+			c = val;
+			break;
+		} //end case
+		default: //NOTE: decimal ASCII code, NOT octal
+		{
+			if (*script->script_p < '0' || *script->script_p > '9') ScriptError(script, "unknown escape char");
+			for (i = 0, val = 0; ; i++, script->script_p++)
+			{
+				c = *script->script_p;
+				if (c >= '0' && c <= '9') c = c - '0';
+				else break;
+				val = val * 10 + c;
+			} //end for
+			script->script_p--;
+			if (val > 0xFF)
+			{
+				ScriptWarning(script, "too large value in escape character");
+				val = 0xFF;
+			} //end if
+			c = val;
+			break;
+		} //end default
+	} //end switch
+	//step over the escape character or the last digit of the number
+	script->script_p++;
+	//store the escape character
+	*ch = c;
+	//succesfully read escape character
+	return 1;
+} //end of the function PS_ReadEscapeCharacter
+//============================================================================
+// Reads C-like string. Escape characters are interpretted.
+// Quotes are included with the string.
+// Reads two strings with a white space between them as one string.
+//
+// Parameter:				script		: script to read from
+//								token			: buffer to store the string
+// Returns:					qtrue when a string was read succesfully
+// Changes Globals:		-
+//============================================================================
+int PS_ReadString(script_t *script, token_t *token, int quote)
+{
+	int len, tmpline;
+	char *tmpscript_p;
+
+	if (quote == '\"') token->type = TT_STRING;
+	else token->type = TT_LITERAL;
+
+	len = 0;
+	//leading quote
+	token->string[len++] = *script->script_p++;
+	//
+	while(1)
+	{
+		//minus 2 because trailing double quote and zero have to be appended
+		if (len >= MAX_TOKEN - 2)
+		{
+			ScriptError(script, "string longer than MAX_TOKEN = %d", MAX_TOKEN);
+			return 0;
+		} //end if
+		//if there is an escape character and
+		//if escape characters inside a string are allowed
+		if (*script->script_p == '\\' && !(script->flags & SCFL_NOSTRINGESCAPECHARS))
+		{
+			if (!PS_ReadEscapeCharacter(script, &token->string[len]))
+			{
+				token->string[len] = 0;
+				return 0;
+			} //end if
+			len++;
+		} //end if
+		//if a trailing quote
+		else if (*script->script_p == quote)
+		{
+			//step over the double quote
+			script->script_p++;
+			//if white spaces in a string are not allowed
+			if (script->flags & SCFL_NOSTRINGWHITESPACES) break;
+			//
+			tmpscript_p = script->script_p;
+			tmpline = script->line;
+			//read unusefull stuff between possible two following strings
+			if (!PS_ReadWhiteSpace(script))
+			{
+				script->script_p = tmpscript_p;
+				script->line = tmpline;
+				break;
+			} //end if
+			//if there's no leading double qoute
+			if (*script->script_p != quote)
+			{
+				script->script_p = tmpscript_p;
+				script->line = tmpline;
+				break;
+			} //end if
+			//step over the new leading double quote
+			script->script_p++;
+		} //end if
+		else
+		{
+			if (*script->script_p == '\0')
+			{
+				token->string[len] = 0;
+				ScriptError(script, "missing trailing quote");
+				return 0;
+			} //end if
+	      if (*script->script_p == '\n')
+			{
+				token->string[len] = 0;
+				ScriptError(script, "newline inside string %s", token->string);
+				return 0;
+			} //end if
+			token->string[len++] = *script->script_p++;
+		} //end else
+	} //end while
+	//trailing quote
+	token->string[len++] = quote;
+	//end string with a zero
+	token->string[len] = '\0';
+	//the sub type is the length of the string
+	token->subtype = len;
+	return 1;
+} //end of the function PS_ReadString
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+int PS_ReadName(script_t *script, token_t *token)
+{
+	int len = 0;
+	char c;
+
+	token->type = TT_NAME;
+	do
+	{
+		token->string[len++] = *script->script_p++;
+		if (len >= MAX_TOKEN)
+		{
+			ScriptError(script, "name longer than MAX_TOKEN = %d", MAX_TOKEN);
+			return 0;
+		} //end if
+		c = *script->script_p;
+   } while ((c >= 'a' && c <= 'z') ||
+				(c >= 'A' && c <= 'Z') ||
+				(c >= '0' && c <= '9') ||
+				c == '_');
+	token->string[len] = '\0';
+	//the sub type is the length of the name
+	token->subtype = len;
+	return 1;
+} //end of the function PS_ReadName
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+void NumberValue(char *string, int subtype, unsigned long int *intvalue,
+															long double *floatvalue)
+{
+	unsigned long int dotfound = 0;
+
+	*intvalue = 0;
+	*floatvalue = 0;
+	//floating point number
+	if (subtype & TT_FLOAT)
+	{
+		while(*string)
+		{
+			if (*string == '.')
+			{
+				if (dotfound) return;
+				dotfound = 10;
+				string++;
+			} //end if
+			if (dotfound)
+			{
+				*floatvalue = *floatvalue + (long double) (*string - '0') /
+																	(long double) dotfound;
+				dotfound *= 10;
+			} //end if
+			else
+			{
+				*floatvalue = *floatvalue * 10.0 + (long double) (*string - '0');
+			} //end else
+			string++;
+		} //end while
+		*intvalue = (unsigned long) *floatvalue;
+	} //end if
+	else if (subtype & TT_DECIMAL)
+	{
+		while(*string) *intvalue = *intvalue * 10 + (*string++ - '0');
+		*floatvalue = *intvalue;
+	} //end else if
+	else if (subtype & TT_HEX)
+	{
+		//step over the leading 0x or 0X
+		string += 2;
+		while(*string)
+		{
+			*intvalue <<= 4;
+			if (*string >= 'a' && *string <= 'f') *intvalue += *string - 'a' + 10;
+			else if (*string >= 'A' && *string <= 'F') *intvalue += *string - 'A' + 10;
+			else *intvalue += *string - '0';
+			string++;
+		} //end while
+		*floatvalue = *intvalue;
+	} //end else if
+	else if (subtype & TT_OCTAL)
+	{
+		//step over the first zero
+		string += 1;
+		while(*string) *intvalue = (*intvalue << 3) + (*string++ - '0');
+		*floatvalue = *intvalue;
+	} //end else if
+	else if (subtype & TT_BINARY)
+	{
+		//step over the leading 0b or 0B
+		string += 2;
+		while(*string) *intvalue = (*intvalue << 1) + (*string++ - '0');
+		*floatvalue = *intvalue;
+	} //end else if
+} //end of the function NumberValue
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+int PS_ReadNumber(script_t *script, token_t *token)
+{
+	int len = 0, i;
+	int octal, dot;
+	char c;
+//	unsigned long int intvalue = 0;
+//	long double floatvalue = 0;
+
+	token->type = TT_NUMBER;
+	//check for a hexadecimal number
+	if (*script->script_p == '0' &&
+		(*(script->script_p + 1) == 'x' ||
+		*(script->script_p + 1) == 'X'))
+	{
+		token->string[len++] = *script->script_p++;
+		token->string[len++] = *script->script_p++;
+		c = *script->script_p;
+		//hexadecimal
+		while((c >= '0' && c <= '9') ||
+					(c >= 'a' && c <= 'f') ||
+					(c >= 'A' && c <= 'A'))
+		{
+			token->string[len++] = *script->script_p++;
+			if (len >= MAX_TOKEN)
+			{
+				ScriptError(script, "hexadecimal number longer than MAX_TOKEN = %d", MAX_TOKEN);
+				return 0;
+			} //end if
+			c = *script->script_p;
+		} //end while
+		token->subtype |= TT_HEX;
+	} //end if
+#ifdef BINARYNUMBERS
+	//check for a binary number
+	else if (*script->script_p == '0' &&
+		(*(script->script_p + 1) == 'b' ||
+		*(script->script_p + 1) == 'B'))
+	{
+		token->string[len++] = *script->script_p++;
+		token->string[len++] = *script->script_p++;
+		c = *script->script_p;
+		//binary
+		while(c == '0' || c == '1')
+		{
+			token->string[len++] = *script->script_p++;
+			if (len >= MAX_TOKEN)
+			{
+				ScriptError(script, "binary number longer than MAX_TOKEN = %d", MAX_TOKEN);
+				return 0;
+			} //end if
+			c = *script->script_p;
+		} //end while
+		token->subtype |= TT_BINARY;
+	} //end if
+#endif //BINARYNUMBERS
+	else //decimal or octal integer or floating point number
+	{
+		octal = qfalse;
+		dot = qfalse;
+		if (*script->script_p == '0') octal = qtrue;
+		while(1)
+		{
+			c = *script->script_p;
+			if (c == '.') dot = qtrue;
+			else if (c == '8' || c == '9') octal = qfalse;
+			else if (c < '0' || c > '9') break;
+			token->string[len++] = *script->script_p++;
+			if (len >= MAX_TOKEN - 1)
+			{
+				ScriptError(script, "number longer than MAX_TOKEN = %d", MAX_TOKEN);
+				return 0;
+			} //end if
+		} //end while
+		if (octal) token->subtype |= TT_OCTAL;
+		else token->subtype |= TT_DECIMAL;
+		if (dot) token->subtype |= TT_FLOAT;
+	} //end else
+	for (i = 0; i < 2; i++)
+	{
+		c = *script->script_p;
+		//check for a LONG number
+		if ( (c == 'l' || c == 'L') // bk001204 - brackets 
+		     && !(token->subtype & TT_LONG))
+		{
+			script->script_p++;
+			token->subtype |= TT_LONG;
+		} //end if
+		//check for an UNSIGNED number
+		else if ( (c == 'u' || c == 'U') // bk001204 - brackets 
+			  && !(token->subtype & (TT_UNSIGNED | TT_FLOAT)))
+		{
+			script->script_p++;
+			token->subtype |= TT_UNSIGNED;
+		} //end if
+	} //end for
+	token->string[len] = '\0';
+#ifdef NUMBERVALUE
+	NumberValue(token->string, token->subtype, &token->intvalue, &token->floatvalue);
+#endif //NUMBERVALUE
+	if (!(token->subtype & TT_FLOAT)) token->subtype |= TT_INTEGER;
+	return 1;
+} //end of the function PS_ReadNumber
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+int PS_ReadLiteral(script_t *script, token_t *token)
+{
+	token->type = TT_LITERAL;
+	//first quote
+	token->string[0] = *script->script_p++;
+	//check for end of file
+	if (!*script->script_p)
+	{
+		ScriptError(script, "end of file before trailing \'");
+		return 0;
+	} //end if
+	//if it is an escape character
+	if (*script->script_p == '\\')
+	{
+		if (!PS_ReadEscapeCharacter(script, &token->string[1])) return 0;
+	} //end if
+	else
+	{
+		token->string[1] = *script->script_p++;
+	} //end else
+	//check for trailing quote
+	if (*script->script_p != '\'')
+	{
+		ScriptWarning(script, "too many characters in literal, ignored");
+		while(*script->script_p &&
+				*script->script_p != '\'' &&
+				*script->script_p != '\n')
+		{
+			script->script_p++;
+		} //end while
+		if (*script->script_p == '\'') script->script_p++;
+	} //end if
+	//store the trailing quote
+	token->string[2] = *script->script_p++;
+	//store trailing zero to end the string
+	token->string[3] = '\0';
+	//the sub type is the integer literal value
+	token->subtype = token->string[1];
+	//
+	return 1;
+} //end of the function PS_ReadLiteral
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+int PS_ReadPunctuation(script_t *script, token_t *token)
+{
+	int len;
+	char *p;
+	punctuation_t *punc;
+
+#ifdef PUNCTABLE
+	for (punc = script->punctuationtable[(unsigned int)*script->script_p]; punc; punc = punc->next)
+	{
+#else
+	int i;
+
+	for (i = 0; script->punctuations[i].p; i++)
+	{
+		punc = &script->punctuations[i];
+#endif //PUNCTABLE
+		p = punc->p;
+		len = strlen(p);
+		//if the script contains at least as much characters as the punctuation
+		if (script->script_p + len <= script->end_p)
+		{
+			//if the script contains the punctuation
+			if (!strncmp(script->script_p, p, len))
+			{
+				strncpy(token->string, p, MAX_TOKEN);
+				script->script_p += len;
+				token->type = TT_PUNCTUATION;
+				//sub type is the number of the punctuation
+				token->subtype = punc->n;
+				return 1;
+			} //end if
+		} //end if
+	} //end for
+	return 0;
+} //end of the function PS_ReadPunctuation
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+int PS_ReadPrimitive(script_t *script, token_t *token)
+{
+	int len;
+
+	len = 0;
+	while(*script->script_p > ' ' && *script->script_p != ';')
+	{
+		if (len >= MAX_TOKEN)
+		{
+			ScriptError(script, "primitive token longer than MAX_TOKEN = %d", MAX_TOKEN);
+			return 0;
+		} //end if
+		token->string[len++] = *script->script_p++;
+	} //end while
+	token->string[len] = 0;
+	//copy the token into the script structure
+	Com_Memcpy(&script->token, token, sizeof(token_t));
+	//primitive reading successfull
+	return 1;
+} //end of the function PS_ReadPrimitive
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+int PS_ReadToken(script_t *script, token_t *token)
+{
+	//if there is a token available (from UnreadToken)
+	if (script->tokenavailable)
+	{
+		script->tokenavailable = 0;
+		Com_Memcpy(token, &script->token, sizeof(token_t));
+		return 1;
+	} //end if
+	//save script pointer
+	script->lastscript_p = script->script_p;
+	//save line counter
+	script->lastline = script->line;
+	//clear the token stuff
+	Com_Memset(token, 0, sizeof(token_t));
+	//start of the white space
+	script->whitespace_p = script->script_p;
+	token->whitespace_p = script->script_p;
+	//read unusefull stuff
+	if (!PS_ReadWhiteSpace(script)) return 0;
+	//end of the white space
+	script->endwhitespace_p = script->script_p;
+	token->endwhitespace_p = script->script_p;
+	//line the token is on
+	token->line = script->line;
+	//number of lines crossed before token
+	token->linescrossed = script->line - script->lastline;
+	//if there is a leading double quote
+	if (*script->script_p == '\"')
+	{
+		if (!PS_ReadString(script, token, '\"')) return 0;
+	} //end if
+	//if an literal
+	else if (*script->script_p == '\'')
+	{
+		//if (!PS_ReadLiteral(script, token)) return 0;
+		if (!PS_ReadString(script, token, '\'')) return 0;
+	} //end if
+	//if there is a number
+	else if ((*script->script_p >= '0' && *script->script_p <= '9') ||
+				(*script->script_p == '.' &&
+				(*(script->script_p + 1) >= '0' && *(script->script_p + 1) <= '9')))
+	{
+		if (!PS_ReadNumber(script, token)) return 0;
+	} //end if
+	//if this is a primitive script
+	else if (script->flags & SCFL_PRIMITIVE)
+	{
+		return PS_ReadPrimitive(script, token);
+	} //end else if
+	//if there is a name
+	else if ((*script->script_p >= 'a' && *script->script_p <= 'z') ||
+		(*script->script_p >= 'A' && *script->script_p <= 'Z') ||
+		*script->script_p == '_' || *script->script_p == '@')
+	{
+		if (!PS_ReadName(script, token)) return 0;
+	} //end if
+	//check for punctuations
+	else if (!PS_ReadPunctuation(script, token))
+	{
+		ScriptError(script, "can't read token");
+		return 0;
+	} //end if
+	//copy the token into the script structure
+	Com_Memcpy(&script->token, token, sizeof(token_t));
+	//succesfully read a token
+	return 1;
+} //end of the function PS_ReadToken
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+int PS_ExpectTokenString(script_t *script, char *string)
+{
+	token_t token;
+
+	if (!PS_ReadToken(script, &token))
+	{
+		ScriptError(script, "couldn't find expected %s", string);
+		return 0;
+	} //end if
+
+	if (strcmp(token.string, string))
+	{
+		ScriptError(script, "expected %s, found %s", string, token.string);
+		return 0;
+	} //end if
+	return 1;
+} //end of the function PS_ExpectToken
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+int PS_ExpectTokenType(script_t *script, int type, int subtype, token_t *token)
+{
+	char str[MAX_TOKEN];
+
+	if (!PS_ReadToken(script, token))
+	{
+		ScriptError(script, "couldn't read expected token");
+		return 0;
+	} //end if
+
+	if (token->type != type)
+	{
+		if (type == TT_STRING) strcpy(str, "string");
+		if (type == TT_LITERAL) strcpy(str, "literal");
+		if (type == TT_NUMBER) strcpy(str, "number");
+		if (type == TT_NAME) strcpy(str, "name");
+		if (type == TT_PUNCTUATION) strcpy(str, "punctuation");
+		ScriptError(script, "expected a %s, found %s", str, token->string);
+		return 0;
+	} //end if
+	if (token->type == TT_NUMBER)
+	{
+		if ((token->subtype & subtype) != subtype)
+		{
+			if (subtype & TT_DECIMAL) strcpy(str, "decimal");
+			if (subtype & TT_HEX) strcpy(str, "hex");
+			if (subtype & TT_OCTAL) strcpy(str, "octal");
+			if (subtype & TT_BINARY) strcpy(str, "binary");
+			if (subtype & TT_LONG) strcat(str, " long");
+			if (subtype & TT_UNSIGNED) strcat(str, " unsigned");
+			if (subtype & TT_FLOAT) strcat(str, " float");
+			if (subtype & TT_INTEGER) strcat(str, " integer");
+			ScriptError(script, "expected %s, found %s", str, token->string);
+			return 0;
+		} //end if
+	} //end if
+	else if (token->type == TT_PUNCTUATION)
+	{
+		if (subtype < 0)
+		{
+			ScriptError(script, "BUG: wrong punctuation subtype");
+			return 0;
+		} //end if
+		if (token->subtype != subtype)
+		{
+			ScriptError(script, "expected %s, found %s",
+							script->punctuations[subtype], token->string);
+			return 0;
+		} //end if
+	} //end else if
+	return 1;
+} //end of the function PS_ExpectTokenType
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+int PS_ExpectAnyToken(script_t *script, token_t *token)
+{
+	if (!PS_ReadToken(script, token))
+	{
+		ScriptError(script, "couldn't read expected token");
+		return 0;
+	} //end if
+	else
+	{
+		return 1;
+	} //end else
+} //end of the function PS_ExpectAnyToken
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+int PS_CheckTokenString(script_t *script, char *string)
+{
+	token_t tok;
+
+	if (!PS_ReadToken(script, &tok)) return 0;
+	//if the token is available
+	if (!strcmp(tok.string, string)) return 1;
+	//token not available
+	script->script_p = script->lastscript_p;
+	return 0;
+} //end of the function PS_CheckTokenString
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+int PS_CheckTokenType(script_t *script, int type, int subtype, token_t *token)
+{
+	token_t tok;
+
+	if (!PS_ReadToken(script, &tok)) return 0;
+	//if the type matches
+	if (tok.type == type &&
+			(tok.subtype & subtype) == subtype)
+	{
+		Com_Memcpy(token, &tok, sizeof(token_t));
+		return 1;
+	} //end if
+	//token is not available
+	script->script_p = script->lastscript_p;
+	return 0;
+} //end of the function PS_CheckTokenType
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+int PS_SkipUntilString(script_t *script, char *string)
+{
+	token_t token;
+
+	while(PS_ReadToken(script, &token))
+	{
+		if (!strcmp(token.string, string)) return 1;
+	} //end while
+	return 0;
+} //end of the function PS_SkipUntilString
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+void PS_UnreadLastToken(script_t *script)
+{
+	script->tokenavailable = 1;
+} //end of the function UnreadLastToken
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+void PS_UnreadToken(script_t *script, token_t *token)
+{
+	Com_Memcpy(&script->token, token, sizeof(token_t));
+	script->tokenavailable = 1;
+} //end of the function UnreadToken
+//============================================================================
+// returns the next character of the read white space, returns NULL if none
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+char PS_NextWhiteSpaceChar(script_t *script)
+{
+	if (script->whitespace_p != script->endwhitespace_p)
+	{
+		return *script->whitespace_p++;
+	} //end if
+	else
+	{
+		return 0;
+	} //end else
+} //end of the function PS_NextWhiteSpaceChar
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+void StripDoubleQuotes(char *string)
+{
+	if (*string == '\"')
+	{
+		strcpy(string, string+1);
+	} //end if
+	if (string[strlen(string)-1] == '\"')
+	{
+		string[strlen(string)-1] = '\0';
+	} //end if
+} //end of the function StripDoubleQuotes
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+void StripSingleQuotes(char *string)
+{
+	if (*string == '\'')
+	{
+		strcpy(string, string+1);
+	} //end if
+	if (string[strlen(string)-1] == '\'')
+	{
+		string[strlen(string)-1] = '\0';
+	} //end if
+} //end of the function StripSingleQuotes
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+long double ReadSignedFloat(script_t *script)
+{
+	token_t token;
+	long double sign = 1;
+
+	PS_ExpectAnyToken(script, &token);
+	if (!strcmp(token.string, "-"))
+	{
+		sign = -1;
+		PS_ExpectTokenType(script, TT_NUMBER, 0, &token);
+	} //end if
+	else if (token.type != TT_NUMBER)
+	{
+		ScriptError(script, "expected float value, found %s\n", token.string);
+	} //end else if
+	return sign * token.floatvalue;
+} //end of the function ReadSignedFloat
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+signed long int ReadSignedInt(script_t *script)
+{
+	token_t token;
+	signed long int sign = 1;
+
+	PS_ExpectAnyToken(script, &token);
+	if (!strcmp(token.string, "-"))
+	{
+		sign = -1;
+		PS_ExpectTokenType(script, TT_NUMBER, TT_INTEGER, &token);
+	} //end if
+	else if (token.type != TT_NUMBER || token.subtype == TT_FLOAT)
+	{
+		ScriptError(script, "expected integer value, found %s\n", token.string);
+	} //end else if
+	return sign * token.intvalue;
+} //end of the function ReadSignedInt
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+void SetScriptFlags(script_t *script, int flags)
+{
+	script->flags = flags;
+} //end of the function SetScriptFlags
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+int GetScriptFlags(script_t *script)
+{
+	return script->flags;
+} //end of the function GetScriptFlags
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+void ResetScript(script_t *script)
+{
+	//pointer in script buffer
+	script->script_p = script->buffer;
+	//pointer in script buffer before reading token
+	script->lastscript_p = script->buffer;
+	//begin of white space
+	script->whitespace_p = NULL;
+	//end of white space
+	script->endwhitespace_p = NULL;
+	//set if there's a token available in script->token
+	script->tokenavailable = 0;
+	//
+	script->line = 1;
+	script->lastline = 1;
+	//clear the saved token
+	Com_Memset(&script->token, 0, sizeof(token_t));
+} //end of the function ResetScript
+//============================================================================
+// returns true if at the end of the script
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+int EndOfScript(script_t *script)
+{
+	return script->script_p >= script->end_p;
+} //end of the function EndOfScript
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+int NumLinesCrossed(script_t *script)
+{
+	return script->line - script->lastline;
+} //end of the function NumLinesCrossed
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+int ScriptSkipTo(script_t *script, char *value)
+{
+	int len;
+	char firstchar;
+
+	firstchar = *value;
+	len = strlen(value);
+	do
+	{
+		if (!PS_ReadWhiteSpace(script)) return 0;
+		if (*script->script_p == firstchar)
+		{
+			if (!strncmp(script->script_p, value, len))
+			{
+				return 1;
+			} //end if
+		} //end if
+		script->script_p++;
+	} while(1);
+} //end of the function ScriptSkipTo
+#ifndef BOTLIB
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+int FileLength(FILE *fp)
+{
+	int pos;
+	int end;
+
+	pos = ftell(fp);
+	fseek(fp, 0, SEEK_END);
+	end = ftell(fp);
+	fseek(fp, pos, SEEK_SET);
+
+	return end;
+} //end of the function FileLength
+#endif
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+script_t *LoadScriptFile(const char *filename)
+{
+#ifdef BOTLIB
+	fileHandle_t fp;
+	char pathname[MAX_QPATH];
+#else
+	FILE *fp;
+#endif
+	int length;
+	void *buffer;
+	script_t *script;
+
+#ifdef BOTLIB
+	if (strlen(basefolder))
+		Com_sprintf(pathname, sizeof(pathname), "%s/%s", basefolder, filename);
+	else
+		Com_sprintf(pathname, sizeof(pathname), "%s", filename);
+	length = botimport.FS_FOpenFile( pathname, &fp, FS_READ );
+	if (!fp) return NULL;
+#else
+	fp = fopen(filename, "rb");
+	if (!fp) return NULL;
+
+	length = FileLength(fp);
+#endif
+
+	buffer = GetClearedMemory(sizeof(script_t) + length + 1);
+	script = (script_t *) buffer;
+	Com_Memset(script, 0, sizeof(script_t));
+	strcpy(script->filename, filename);
+	script->buffer = (char *) buffer + sizeof(script_t);
+	script->buffer[length] = 0;
+	script->length = length;
+	//pointer in script buffer
+	script->script_p = script->buffer;
+	//pointer in script buffer before reading token
+	script->lastscript_p = script->buffer;
+	//pointer to end of script buffer
+	script->end_p = &script->buffer[length];
+	//set if there's a token available in script->token
+	script->tokenavailable = 0;
+	//
+	script->line = 1;
+	script->lastline = 1;
+	//
+	SetScriptPunctuations(script, NULL);
+	//
+#ifdef BOTLIB
+	botimport.FS_Read(script->buffer, length, fp);
+	botimport.FS_FCloseFile(fp);
+#else
+	if (fread(script->buffer, length, 1, fp) != 1)
+	{
+		FreeMemory(buffer);
+		script = NULL;
+	} //end if
+	fclose(fp);
+#endif
+	//
+	script->length = COM_Compress(script->buffer);
+
+	return script;
+} //end of the function LoadScriptFile
+//============================================================================
+//
+// Parameter:			-
+// Returns:				-
+// Changes Globals:		-
+//============================================================================
+script_t *LoadScriptMemory(char *ptr, int length, char *name)
+{
+	void *buffer;
+	script_t *script;
+
+	buffer = GetClearedMemory(sizeof(script_t) + length + 1);
+	script = (script_t *) buffer;
+	Com_Memset(script, 0, sizeof(script_t));
+	strcpy(script->filename, name);
+	script->buffer = (char *) buffer + sizeof(script_t);
+	script->buffer[length] = 0;
+	script->length = length;
+	//pointer in script buffer
+	script->script_p = script->buffer;
+	//pointer in script buffer before reading token
+	script->lastscript_p = script->buffer;
+	//pointer to end of script buffer
+	script->end_p = &script->buffer[length];
+	//set if there's a token available in script->token
+	script->tokenavailable = 0;
+	//
+	script->line = 1;
+	script->lastline = 1;
+	//
+	SetScriptPunctuations(script, NULL);
+	//
+	Com_Memcpy(script->buffer, ptr, length);
+	//
+	return script;
+} //end of the function LoadScriptMemory
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+void FreeScript(script_t *script)
+{
+#ifdef PUNCTABLE
+	if (script->punctuationtable) FreeMemory(script->punctuationtable);
+#endif //PUNCTABLE
+	FreeMemory(script);
+} //end of the function FreeScript
+//============================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//============================================================================
+void PS_SetBaseFolder(char *path)
+{
+#ifdef BSPC
+	sprintf(basefolder, path);
+#else
+	Com_sprintf(basefolder, sizeof(basefolder), path);
+#endif
+} //end of the function PS_SetBaseFolder
diff --git a/codemp/botlib/l_script.h b/codemp/botlib/l_script.h
new file mode 100644
index 0000000..68768f5
--- /dev/null
+++ b/codemp/botlib/l_script.h
@@ -0,0 +1,232 @@
+
+/*****************************************************************************
+ * name:		l_script.h
+ *
+ * desc:		lexicographical parser
+ *
+ * $Archive: /source/code/botlib/l_script.h $
+ * $Author: Mrelusive $ 
+ * $Revision: 2 $
+ * $Modtime: 10/05/99 3:32p $
+ * $Date: 10/05/99 3:42p $
+ *
+ *****************************************************************************/
+
+//undef if binary numbers of the form 0b... or 0B... are not allowed
+#define BINARYNUMBERS
+//undef if not using the token.intvalue and token.floatvalue
+#define NUMBERVALUE
+//use dollar sign also as punctuation
+#define DOLLAR
+
+//maximum token length
+#define MAX_TOKEN					1024
+
+#if defined(BSPC) && !defined(QDECL)
+#define QDECL
+#endif
+
+
+//script flags
+#define SCFL_NOERRORS				0x0001
+#define SCFL_NOWARNINGS				0x0002
+#define SCFL_NOSTRINGWHITESPACES	0x0004
+#define SCFL_NOSTRINGESCAPECHARS	0x0008
+#define SCFL_PRIMITIVE				0x0010
+#define SCFL_NOBINARYNUMBERS		0x0020
+#define SCFL_NONUMBERVALUES		0x0040
+
+//token types
+#define TT_STRING						1			// string
+#define TT_LITERAL					2			// literal
+#define TT_NUMBER						3			// number
+#define TT_NAME						4			// name
+#define TT_PUNCTUATION				5			// punctuation
+
+//string sub type
+//---------------
+//		the length of the string
+//literal sub type
+//----------------
+//		the ASCII code of the literal
+//number sub type
+//---------------
+#define TT_DECIMAL					0x0008	// decimal number
+#define TT_HEX							0x0100	// hexadecimal number
+#define TT_OCTAL						0x0200	// octal number
+#ifdef BINARYNUMBERS
+#define TT_BINARY						0x0400	// binary number
+#endif //BINARYNUMBERS
+#define TT_FLOAT						0x0800	// floating point number
+#define TT_INTEGER					0x1000	// integer number
+#define TT_LONG						0x2000	// long number
+#define TT_UNSIGNED					0x4000	// unsigned number
+//punctuation sub type
+//--------------------
+#define P_RSHIFT_ASSIGN				1
+#define P_LSHIFT_ASSIGN				2
+#define P_PARMS						3
+#define P_PRECOMPMERGE				4
+
+#define P_LOGIC_AND					5
+#define P_LOGIC_OR					6
+#define P_LOGIC_GEQ					7
+#define P_LOGIC_LEQ					8
+#define P_LOGIC_EQ					9
+#define P_LOGIC_UNEQ					10
+
+#define P_MUL_ASSIGN					11
+#define P_DIV_ASSIGN					12
+#define P_MOD_ASSIGN					13
+#define P_ADD_ASSIGN					14
+#define P_SUB_ASSIGN					15
+#define P_INC							16
+#define P_DEC							17
+
+#define P_BIN_AND_ASSIGN			18
+#define P_BIN_OR_ASSIGN				19
+#define P_BIN_XOR_ASSIGN			20
+#define P_RSHIFT						21
+#define P_LSHIFT						22
+
+#define P_POINTERREF					23
+#define P_CPP1							24
+#define P_CPP2							25
+#define P_MUL							26
+#define P_DIV							27
+#define P_MOD							28
+#define P_ADD							29
+#define P_SUB							30
+#define P_ASSIGN						31
+
+#define P_BIN_AND						32
+#define P_BIN_OR						33
+#define P_BIN_XOR						34
+#define P_BIN_NOT						35
+
+#define P_LOGIC_NOT					36
+#define P_LOGIC_GREATER				37
+#define P_LOGIC_LESS					38
+
+#define P_REF							39
+#define P_COMMA						40
+#define P_SEMICOLON					41
+#define P_COLON						42
+#define P_QUESTIONMARK				43
+
+#define P_PARENTHESESOPEN			44
+#define P_PARENTHESESCLOSE			45
+#define P_BRACEOPEN					46
+#define P_BRACECLOSE					47
+#define P_SQBRACKETOPEN				48
+#define P_SQBRACKETCLOSE			49
+#define P_BACKSLASH					50
+
+#define P_PRECOMP						51
+#define P_DOLLAR						52
+#define	P_ATSIGN						53
+//name sub type
+//-------------
+//		the length of the name
+
+//punctuation
+typedef struct punctuation_s
+{
+	char *p;						//punctuation character(s)
+	int n;							//punctuation indication
+	struct punctuation_s *next;		//next punctuation
+} punctuation_t;
+
+//token
+typedef struct token_s
+{
+	char string[MAX_TOKEN];			//available token
+	int type;						//last read token type
+	int subtype;					//last read token sub type
+#ifdef NUMBERVALUE
+	unsigned long int intvalue;	//integer value
+	long double floatvalue;			//floating point value
+#endif //NUMBERVALUE
+	char *whitespace_p;				//start of white space before token
+	char *endwhitespace_p;			//start of white space before token
+	int line;						//line the token was on
+	int linescrossed;				//lines crossed in white space
+	struct token_s *next;			//next token in chain
+} token_t;
+
+//script file
+typedef struct script_s
+{
+	char filename[1024];			//file name of the script
+	char *buffer;					//buffer containing the script
+	char *script_p;					//current pointer in the script
+	char *end_p;					//pointer to the end of the script
+	char *lastscript_p;				//script pointer before reading token
+	char *whitespace_p;				//begin of the white space
+	char *endwhitespace_p;			//end of the white space
+	int length;						//length of the script in bytes
+	int line;						//current line in script
+	int lastline;					//line before reading token
+	int tokenavailable;				//set by UnreadLastToken
+	int flags;						//several script flags
+	punctuation_t *punctuations;	//the punctuations used in the script
+	punctuation_t **punctuationtable;
+	token_t token;					//available token
+	struct script_s *next;			//next script in a chain
+} script_t;
+
+//read a token from the script
+int PS_ReadToken(script_t *script, token_t *token);
+//expect a certain token
+int PS_ExpectTokenString(script_t *script, char *string);
+//expect a certain token type
+int PS_ExpectTokenType(script_t *script, int type, int subtype, token_t *token);
+//expect a token
+int PS_ExpectAnyToken(script_t *script, token_t *token);
+//returns true when the token is available
+int PS_CheckTokenString(script_t *script, char *string);
+//returns true an reads the token when a token with the given type is available
+int PS_CheckTokenType(script_t *script, int type, int subtype, token_t *token);
+//skip tokens until the given token string is read
+int PS_SkipUntilString(script_t *script, char *string);
+//unread the last token read from the script
+void PS_UnreadLastToken(script_t *script);
+//unread the given token
+void PS_UnreadToken(script_t *script, token_t *token);
+//returns the next character of the read white space, returns NULL if none
+char PS_NextWhiteSpaceChar(script_t *script);
+//remove any leading and trailing double quotes from the token
+void StripDoubleQuotes(char *string);
+//remove any leading and trailing single quotes from the token
+void StripSingleQuotes(char *string);
+//read a possible signed integer
+signed long int ReadSignedInt(script_t *script);
+//read a possible signed floating point number
+long double ReadSignedFloat(script_t *script);
+//set an array with punctuations, NULL restores default C/C++ set
+void SetScriptPunctuations(script_t *script, punctuation_t *p);
+//set script flags
+void SetScriptFlags(script_t *script, int flags);
+//get script flags
+int GetScriptFlags(script_t *script);
+//reset a script
+void ResetScript(script_t *script);
+//returns true if at the end of the script
+int EndOfScript(script_t *script);
+//returns a pointer to the punctuation with the given number
+char *PunctuationFromNum(script_t *script, int num);
+//load a script from the given file at the given offset with the given length
+script_t *LoadScriptFile(const char *filename);
+//load a script from the given memory with the given length
+script_t *LoadScriptMemory(char *ptr, int length, char *name);
+//free a script
+void FreeScript(script_t *script);
+//set the base folder to load files from
+void PS_SetBaseFolder(char *path);
+//print a script error with filename and line number
+void QDECL ScriptError(script_t *script, char *str, ...);
+//print a script warning with filename and line number
+void QDECL ScriptWarning(script_t *script, char *str, ...);
+
+
+
diff --git a/codemp/botlib/l_struct.cpp b/codemp/botlib/l_struct.cpp
new file mode 100644
index 0000000..fb442e9
--- /dev/null
+++ b/codemp/botlib/l_struct.cpp
@@ -0,0 +1,445 @@
+
+/*****************************************************************************
+ * name:		l_struct.c
+ *
+ * desc:		structure reading / writing
+ *
+ * $Archive: /MissionPack/CODE/botlib/l_struct.c $
+ * $Author: Raduffy $ 
+ * $Revision: 1 $
+ * $Modtime: 12/20/99 8:43p $
+ * $Date: 3/08/00 11:28a $
+ *
+ *****************************************************************************/
+
+#ifdef BOTLIB
+#include "../game/q_shared.h"
+#include "../game/botlib.h"				//for the include of be_interface.h
+#include "l_script.h"
+#include "l_precomp.h"
+#include "l_struct.h"
+#include "l_utils.h"
+#include "be_interface.h"
+#endif //BOTLIB
+
+#ifdef BSPC
+//include files for usage in the BSP Converter
+#include "../bspc/qbsp.h"
+#include "../bspc/l_log.h"
+#include "../bspc/l_mem.h"
+#include "l_precomp.h"
+#include "l_struct.h"
+
+#define qtrue	true
+#define qfalse	false
+#endif //BSPC
+
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+fielddef_t *FindField(fielddef_t *defs, char *name)
+{
+	int i;
+
+	for (i = 0; defs[i].name; i++)
+	{
+		if (!strcmp(defs[i].name, name)) return &defs[i];
+	} //end for
+	return NULL;
+} //end of the function FindField
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+qboolean ReadNumber(source_t *source, fielddef_t *fd, void *p)
+{
+	token_t token;
+	int negative = qfalse;
+	long int intval, intmin = 0, intmax = 0;
+	double floatval;
+
+	if (!PC_ExpectAnyToken(source, &token)) return (qboolean)0;
+
+	//check for minus sign
+	if (token.type == TT_PUNCTUATION)
+	{
+		if (fd->type & FT_UNSIGNED)
+		{
+			SourceError(source, "expected unsigned value, found %s", token.string);
+			return (qboolean)0;
+		} //end if
+		//if not a minus sign
+		if (strcmp(token.string, "-"))
+		{
+			SourceError(source, "unexpected punctuation %s", token.string);
+			return (qboolean)0;
+		} //end if
+		negative = qtrue;
+		//read the number
+		if (!PC_ExpectAnyToken(source, &token)) return (qboolean)0;
+	} //end if
+	//check if it is a number
+	if (token.type != TT_NUMBER)
+	{
+		SourceError(source, "expected number, found %s", token.string);
+		return (qboolean)0;
+	} //end if
+	//check for a float value
+	if (token.subtype & TT_FLOAT)
+	{
+		if ((fd->type & FT_TYPE) != FT_FLOAT)
+		{
+			SourceError(source, "unexpected float");
+			return (qboolean)0;
+		} //end if
+		floatval = token.floatvalue;
+		if (negative) floatval = -floatval;
+		if (fd->type & FT_BOUNDED)
+		{
+			if (floatval < fd->floatmin || floatval > fd->floatmax)
+			{
+				SourceError(source, "float out of range [%f, %f]", fd->floatmin, fd->floatmax);
+				return (qboolean)0;
+			} //end if
+		} //end if
+		*(float *) p = (float) floatval;
+		return (qboolean)1;
+	} //end if
+	//
+	intval = token.intvalue;
+	if (negative) intval = -intval;
+	//check bounds
+	if ((fd->type & FT_TYPE) == FT_CHAR)
+	{
+		if (fd->type & FT_UNSIGNED) {intmin = 0; intmax = 255;}
+		else {intmin = -128; intmax = 127;}
+	} //end if
+	if ((fd->type & FT_TYPE) == FT_INT)
+	{
+		if (fd->type & FT_UNSIGNED) {intmin = 0; intmax = 65535;}
+		else {intmin = -32768; intmax = 32767;}
+	} //end else if
+	if ((fd->type & FT_TYPE) == FT_CHAR || (fd->type & FT_TYPE) == FT_INT)
+	{
+		if (fd->type & FT_BOUNDED)
+		{
+			intmin = Maximum(intmin, fd->floatmin);
+			intmax = Minimum(intmax, fd->floatmax);
+		} //end if
+		if (intval < intmin || intval > intmax)
+		{
+			SourceError(source, "value %d out of range [%d, %d]", intval, intmin, intmax);
+			return (qboolean)0;
+		} //end if
+	} //end if
+	else if ((fd->type & FT_TYPE) == FT_FLOAT)
+	{
+		if (fd->type & FT_BOUNDED)
+		{
+			if (intval < fd->floatmin || intval > fd->floatmax)
+			{
+				SourceError(source, "value %d out of range [%f, %f]", intval, fd->floatmin, fd->floatmax);
+				return (qboolean)0;
+			} //end if
+		} //end if
+	} //end else if
+	//store the value
+	if ((fd->type & FT_TYPE) == FT_CHAR)
+	{
+		if (fd->type & FT_UNSIGNED) *(unsigned char *) p = (unsigned char) intval;
+		else *(char *) p = (char) intval;
+	} //end if
+	else if ((fd->type & FT_TYPE) == FT_INT)
+	{
+		if (fd->type & FT_UNSIGNED) *(unsigned int *) p = (unsigned int) intval;
+		else *(int *) p = (int) intval;
+	} //end else
+	else if ((fd->type & FT_TYPE) == FT_FLOAT)
+	{
+		*(float *) p = (float) intval;
+	} //end else
+	return (qboolean)1;
+} //end of the function ReadNumber
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+qboolean ReadChar(source_t *source, fielddef_t *fd, void *p)
+{
+	token_t token;
+
+	if (!PC_ExpectAnyToken(source, &token)) return (qboolean)0;
+
+	//take literals into account
+	if (token.type == TT_LITERAL)
+	{
+		StripSingleQuotes(token.string);
+		*(char *) p = token.string[0];
+	} //end if
+	else
+	{
+		PC_UnreadLastToken(source);
+		if (!ReadNumber(source, fd, p)) return (qboolean)0;
+	} //end if
+	return (qboolean)1;
+} //end of the function ReadChar
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int ReadString(source_t *source, fielddef_t *fd, void *p)
+{
+	token_t token;
+
+	if (!PC_ExpectTokenType(source, TT_STRING, 0, &token)) return 0;
+	//remove the double quotes
+	StripDoubleQuotes(token.string);
+	//copy the string
+	strncpy((char *) p, token.string, MAX_STRINGFIELD);
+	//make sure the string is closed with a zero
+	((char *)p)[MAX_STRINGFIELD-1] = '\0';
+	//
+	return 1;
+} //end of the function ReadString
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int ReadStructure(source_t *source, structdef_t *def, char *structure)
+{
+	token_t token;
+	fielddef_t *fd;
+	void *p;
+	int num;
+
+	if (!PC_ExpectTokenString(source, "{")) return 0;
+	while(1)
+	{
+		if (!PC_ExpectAnyToken(source, &token)) return qfalse;
+		//if end of structure
+		if (!strcmp(token.string, "}")) break;
+		//find the field with the name
+		fd = FindField(def->fields, token.string);
+		if (!fd)
+		{
+			SourceError(source, "unknown structure field %s", token.string);
+			return qfalse;
+		} //end if
+		if (fd->type & FT_ARRAY)
+		{
+			num = fd->maxarray;
+			if (!PC_ExpectTokenString(source, "{")) return qfalse;
+		} //end if
+		else
+		{
+			num = 1;
+		} //end else
+		p = (void *)(structure + fd->offset);
+		while (num-- > 0)
+		{
+			if (fd->type & FT_ARRAY)
+			{
+				if (PC_CheckTokenString(source, "}")) break;
+			} //end if
+			switch(fd->type & FT_TYPE)
+			{
+				case FT_CHAR:
+				{
+					if (!ReadChar(source, fd, p)) return qfalse;
+					p = (char *) p + sizeof(char);
+					break;
+				} //end case
+				case FT_INT:
+				{
+					if (!ReadNumber(source, fd, p)) return qfalse;
+					p = (char *) p + sizeof(int);
+					break;
+				} //end case
+				case FT_FLOAT:
+				{
+					if (!ReadNumber(source, fd, p)) return qfalse;
+					p = (char *) p + sizeof(float);
+					break;
+				} //end case
+				case FT_STRING:
+				{
+					if (!ReadString(source, fd, p)) return qfalse;
+					p = (char *) p + MAX_STRINGFIELD;
+					break;
+				} //end case
+				case FT_STRUCT:
+				{
+					if (!fd->substruct)
+					{
+						SourceError(source, "BUG: no sub structure defined");
+						return qfalse;
+					} //end if
+					ReadStructure(source, fd->substruct, (char *) p);
+					p = (char *) p + fd->substruct->size;
+					break;
+				} //end case
+			} //end switch
+			if (fd->type & FT_ARRAY)
+			{
+				if (!PC_ExpectAnyToken(source, &token)) return qfalse;
+				if (!strcmp(token.string, "}")) break;
+				if (strcmp(token.string, ","))
+				{
+					SourceError(source, "expected a comma, found %s", token.string);
+					return qfalse;
+				} //end if
+			} //end if
+		} //end while
+	} //end while
+	return qtrue;
+} //end of the function ReadStructure
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int WriteIndent(FILE *fp, int indent)
+{
+	while(indent-- > 0)
+	{
+		if (fprintf(fp, "\t") < 0) return qfalse;
+	} //end while
+	return qtrue;
+} //end of the function WriteIndent
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int WriteFloat(FILE *fp, float value)
+{
+	char buf[128];
+	int l;
+
+	sprintf(buf, "%f", value);
+	l = strlen(buf);
+	//strip any trailing zeros
+	while(l-- > 1)
+	{
+		if (buf[l] != '0' && buf[l] != '.') break;
+		if (buf[l] == '.')
+		{
+			buf[l] = 0;
+			break;
+		} //end if
+		buf[l] = 0;
+	} //end while
+	//write the float to file
+	if (fprintf(fp, "%s", buf) < 0) return 0;
+	return 1;
+} //end of the function WriteFloat
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int WriteStructWithIndent(FILE *fp, structdef_t *def, char *structure, int indent)
+{
+	int i, num;
+	void *p;
+	fielddef_t *fd;
+
+	if (!WriteIndent(fp, indent)) return qfalse;
+	if (fprintf(fp, "{\r\n") < 0) return qfalse;
+
+	indent++;
+	for (i = 0; def->fields[i].name; i++)
+	{
+		fd = &def->fields[i];
+		if (!WriteIndent(fp, indent)) return qfalse;
+		if (fprintf(fp, "%s\t", fd->name) < 0) return qfalse;
+		p = (void *)(structure + fd->offset);
+		if (fd->type & FT_ARRAY)
+		{
+			num = fd->maxarray;
+			if (fprintf(fp, "{") < 0) return qfalse;
+		} //end if
+		else
+		{
+			num = 1;
+		} //end else
+		while(num-- > 0)
+		{
+			switch(fd->type & FT_TYPE)
+			{
+				case FT_CHAR:
+				{
+					if (fprintf(fp, "%d", *(char *) p) < 0) return qfalse;
+					p = (char *) p + sizeof(char);
+					break;
+				} //end case
+				case FT_INT:
+				{
+					if (fprintf(fp, "%d", *(int *) p) < 0) return qfalse;
+					p = (char *) p + sizeof(int);
+					break;
+				} //end case
+				case FT_FLOAT:
+				{
+					if (!WriteFloat(fp, *(float *)p)) return qfalse;
+					p = (char *) p + sizeof(float);
+					break;
+				} //end case
+				case FT_STRING:
+				{
+					if (fprintf(fp, "\"%s\"", (char *) p) < 0) return qfalse;
+					p = (char *) p + MAX_STRINGFIELD;
+					break;
+				} //end case
+				case FT_STRUCT:
+				{
+					if (!WriteStructWithIndent(fp, fd->substruct, structure, indent)) return qfalse;
+					p = (char *) p + fd->substruct->size;
+					break;
+				} //end case
+			} //end switch
+			if (fd->type & FT_ARRAY)
+			{
+				if (num > 0)
+				{
+					if (fprintf(fp, ",") < 0) return qfalse;
+				} //end if
+				else
+				{
+					if (fprintf(fp, "}") < 0) return qfalse;
+				} //end else
+			} //end if
+		} //end while
+		if (fprintf(fp, "\r\n") < 0) return qfalse;
+	} //end for
+	indent--;
+
+	if (!WriteIndent(fp, indent)) return qfalse;
+	if (fprintf(fp, "}\r\n") < 0) return qfalse;
+	return qtrue;
+} //end of the function WriteStructWithIndent
+//===========================================================================
+//
+// Parameter:				-
+// Returns:					-
+// Changes Globals:		-
+//===========================================================================
+int WriteStructure(FILE *fp, structdef_t *def, char *structure)
+{
+	return WriteStructWithIndent(fp, def, structure, 0);
+} //end of the function WriteStructure
+
diff --git a/codemp/botlib/l_struct.h b/codemp/botlib/l_struct.h
new file mode 100644
index 0000000..658793d
--- /dev/null
+++ b/codemp/botlib/l_struct.h
@@ -0,0 +1,58 @@
+
+/*****************************************************************************
+ * name:		l_struct.h
+ *
+ * desc:		structure reading/writing
+ *
+ * $Archive: /source/code/botlib/l_struct.h $
+ * $Author: Mrelusive $ 
+ * $Revision: 2 $
+ * $Modtime: 10/05/99 3:32p $
+ * $Date: 10/05/99 3:42p $
+ *
+ *****************************************************************************/
+
+
+#define MAX_STRINGFIELD				80
+//field types
+#define FT_CHAR						1			// char
+#define FT_INT							2			// int
+#define FT_FLOAT						3			// float
+#define FT_STRING						4			// char [MAX_STRINGFIELD]
+#define FT_STRUCT						6			// struct (sub structure)
+//type only mask
+#define FT_TYPE						0x00FF	// only type, clear subtype
+//sub types
+#define FT_ARRAY						0x0100	// array of type
+#define FT_BOUNDED					0x0200	// bounded value
+#define FT_UNSIGNED					0x0400
+
+//structure field definition
+typedef struct fielddef_s
+{
+	char *name;										//name of the field
+	int offset;										//offset in the structure
+	int type;										//type of the field
+	//type specific fields
+	int maxarray;									//maximum array size
+	float floatmin, floatmax;					//float min and max
+	struct structdef_s *substruct;			//sub structure
+} fielddef_t;
+
+//structure definition
+typedef struct structdef_s
+{
+	int size;
+	fielddef_t *fields;
+} structdef_t;
+
+//read a structure from a script
+int ReadStructure(source_t *source, structdef_t *def, char *structure);
+//write a structure to a file
+int WriteStructure(FILE *fp, structdef_t *def, char *structure);
+//writes indents
+int WriteIndent(FILE *fp, int indent);
+//writes a float without traling zeros
+int WriteFloat(FILE *fp, float value);
+
+
diff --git a/codemp/botlib/l_utils.h b/codemp/botlib/l_utils.h
new file mode 100644
index 0000000..d7819f1
--- /dev/null
+++ b/codemp/botlib/l_utils.h
@@ -0,0 +1,18 @@
+
+/*****************************************************************************
+ * name:		l_util.h
+ *
+ * desc:		utils
+ *
+ * $Archive: /source/code/botlib/l_util.h $
+ * $Author: Mrelusive $ 
+ * $Revision: 2 $
+ * $Modtime: 10/05/99 3:32p $
+ * $Date: 10/05/99 3:42p $
+ *
+ *****************************************************************************/
+
+#define Vector2Angles(v,a)		vectoangles(v,a)
+#define MAX_PATH				MAX_QPATH
+#define Maximum(x,y)			(x > y ? x : y)
+#define Minimum(x,y)			(x < y ? x : y)
diff --git a/codemp/botlib/mssccprj.scc b/codemp/botlib/mssccprj.scc
new file mode 100644
index 0000000..ddd41c1
--- /dev/null
+++ b/codemp/botlib/mssccprj.scc
@@ -0,0 +1,5 @@
+SCC = This is a Source Code Control file
+
+[botlib.vcproj]
+SCC_Aux_Path = "\\ravendata1\vss\central_code"
+SCC_Project_Name = "$/jedi/codemp/botlib", EAAAAAAA
diff --git a/codemp/botlib/vssver.scc b/codemp/botlib/vssver.scc
new file mode 100644
index 0000000..6b5dbb0
Binary files /dev/null and b/codemp/botlib/vssver.scc differ
diff --git a/codemp/buildvms.bat b/codemp/buildvms.bat
new file mode 100644
index 0000000..00d402b
--- /dev/null
+++ b/codemp/buildvms.bat
@@ -0,0 +1,8 @@
+set include=
+cd game
+call game
+cd ..\cgame
+call cgame
+cd ..\ui
+call ui
+cd ..
diff --git a/codemp/cgame/JK2_cgame.def b/codemp/cgame/JK2_cgame.def
new file mode 100644
index 0000000..01861ba
--- /dev/null
+++ b/codemp/cgame/JK2_cgame.def
@@ -0,0 +1,3 @@
+EXPORTS
+	vmMain
+	dllEntry
diff --git a/codemp/cgame/JK2_cgame.vcproj b/codemp/cgame/JK2_cgame.vcproj
new file mode 100644
index 0000000..c9db9c2
--- /dev/null
+++ b/codemp/cgame/JK2_cgame.vcproj
@@ -0,0 +1,563 @@
+<?xml version="1.0" encoding = "Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="7.00"
+	Name="JK2cgame"
+	SccProjectName="&quot;$/jedi/codemp/cgame&quot;, ICAAAAAA"
+	SccAuxPath=""
+	SccLocalPath="."
+	SccProvider="MSSCCI:Microsoft Visual SourceSafe">
+	<Platforms>
+		<Platform
+			Name="Win32"/>
+	</Platforms>
+	<Configurations>
+		<Configuration
+			Name="Release|Win32"
+			OutputDirectory=".\../Release"
+			IntermediateDirectory=".\../Release/JK2cgame"
+			ConfigurationType="2"
+			UseOfMFC="0"
+			ATLMinimizesCRunTimeLibraryUsage="FALSE">
+			<Tool
+				Name="VCCLCompilerTool"
+				GlobalOptimizations="TRUE"
+				InlineFunctionExpansion="2"
+				EnableIntrinsicFunctions="TRUE"
+				ImproveFloatingPointConsistency="TRUE"
+				FavorSizeOrSpeed="1"
+				OptimizeForProcessor="2"
+				OptimizeForWindowsApplication="TRUE"
+				AdditionalIncludeDirectories="..,./../game"
+				PreprocessorDefinitions="NDEBUG;WIN32;_WINDOWS;MISSIONPACK;_JK2;CGAME"
+				StringPooling="TRUE"
+				MinimalRebuild="TRUE"
+				RuntimeLibrary="4"
+				BufferSecurityCheck="FALSE"
+				EnableFunctionLevelLinking="TRUE"
+				UsePrecompiledHeader="2"
+				PrecompiledHeaderFile=".\../Release/JK2cgame/JK2_cgame.pch"
+				AssemblerListingLocation=".\../Release/JK2cgame/"
+				ObjectFile=".\../Release/JK2cgame/"
+				ProgramDataBaseFileName=".\../Release/JK2cgame/"
+				WarningLevel="4"
+				SuppressStartupBanner="TRUE"
+				DebugInformationFormat="3"
+				CompileAs="0"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalOptions="/MACHINE:I386"
+				AdditionalDependencies="odbc32.lib odbccp32.lib"
+				OutputFile="../Release/cgamex86.dll"
+				LinkIncremental="1"
+				SuppressStartupBanner="TRUE"
+				ModuleDefinitionFile=".\JK2_cgame.def"
+				GenerateDebugInformation="TRUE"
+				ProgramDatabaseFile=".\../Release/cgamex86.pdb"
+				GenerateMapFile="TRUE"
+				MapFileName="../Release/cgamex86.map"
+				SubSystem="2"
+				OptimizeReferences="2"
+				EnableCOMDATFolding="2"
+				SetChecksum="TRUE"
+				BaseAddress="0x30000000"
+				ImportLibrary=".\../Release/cgamex86.lib"/>
+			<Tool
+				Name="VCMIDLTool"
+				PreprocessorDefinitions="NDebug"
+				MkTypLibCompatible="TRUE"
+				SuppressStartupBanner="TRUE"
+				TargetEnvironment="1"
+				TypeLibraryName=".\../Release/JK2_cgame.tlb"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="VCResourceCompilerTool"
+				PreprocessorDefinitions="NDebug"
+				Culture="1033"/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"/>
+			<Tool
+				Name="VCWebDeploymentTool"/>
+		</Configuration>
+		<Configuration
+			Name="Final|Win32"
+			OutputDirectory=".\../Final"
+			IntermediateDirectory=".\../Final/JK2cgame"
+			ConfigurationType="2"
+			UseOfMFC="0"
+			ATLMinimizesCRunTimeLibraryUsage="FALSE">
+			<Tool
+				Name="VCCLCompilerTool"
+				GlobalOptimizations="TRUE"
+				InlineFunctionExpansion="2"
+				EnableIntrinsicFunctions="TRUE"
+				ImproveFloatingPointConsistency="TRUE"
+				FavorSizeOrSpeed="1"
+				OptimizeForProcessor="2"
+				OptimizeForWindowsApplication="TRUE"
+				AdditionalIncludeDirectories="..,./../game"
+				PreprocessorDefinitions="NDEBUG;_WINDOWS;MISSIONPACK;WIN32;CGAME;_JK2;FINAL_BUILD"
+				StringPooling="TRUE"
+				RuntimeLibrary="4"
+				BufferSecurityCheck="FALSE"
+				EnableFunctionLevelLinking="TRUE"
+				UsePrecompiledHeader="2"
+				PrecompiledHeaderFile=".\../Final/JK2cgame/JK2_cgame.pch"
+				AssemblerListingLocation=".\../Final/JK2cgame/"
+				ObjectFile=".\../Final/JK2cgame/"
+				ProgramDataBaseFileName=".\../Final/JK2cgame/"
+				WarningLevel="4"
+				SuppressStartupBanner="TRUE"
+				CompileAs="0"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalOptions="/MACHINE:I386"
+				AdditionalDependencies="odbc32.lib odbccp32.lib"
+				OutputFile="../Final/cgamex86.dll"
+				LinkIncremental="1"
+				SuppressStartupBanner="TRUE"
+				ModuleDefinitionFile=".\JK2_cgame.def"
+				ProgramDatabaseFile=""
+				GenerateMapFile="TRUE"
+				MapFileName=".\../Final/cgamex86.map"
+				SubSystem="2"
+				OptimizeReferences="2"
+				EnableCOMDATFolding="2"
+				SetChecksum="TRUE"
+				BaseAddress="0x30000000"
+				ImportLibrary=".\../Final/cgamex86.lib"/>
+			<Tool
+				Name="VCMIDLTool"
+				PreprocessorDefinitions="NDebug"
+				MkTypLibCompatible="TRUE"
+				SuppressStartupBanner="TRUE"
+				TargetEnvironment="1"
+				TypeLibraryName=".\../Final/JK2_cgame.tlb"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="VCResourceCompilerTool"
+				PreprocessorDefinitions="NDebug"
+				Culture="1033"/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"/>
+			<Tool
+				Name="VCWebDeploymentTool"/>
+		</Configuration>
+		<Configuration
+			Name="Debug|Win32"
+			OutputDirectory=".\../Debug"
+			IntermediateDirectory=".\../Debug/JK2cgame"
+			ConfigurationType="2"
+			UseOfMFC="0"
+			ATLMinimizesCRunTimeLibraryUsage="FALSE">
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				OptimizeForProcessor="2"
+				AdditionalIncludeDirectories="..,./../game"
+				PreprocessorDefinitions="_DEBUG;WIN32;_WINDOWS;MISSIONPACK;CGAME;_JK2"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="5"
+				UsePrecompiledHeader="2"
+				PrecompiledHeaderFile=".\../Debug/JK2cgame/JK2_cgame.pch"
+				AssemblerListingLocation=".\../Debug/JK2cgame/"
+				ObjectFile=".\../Debug/JK2cgame/"
+				ProgramDataBaseFileName=".\../Debug/JK2cgame/"
+				BrowseInformation="1"
+				WarningLevel="3"
+				SuppressStartupBanner="TRUE"
+				DebugInformationFormat="4"
+				CompileAs="0"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalOptions="/MACHINE:I386"
+				AdditionalDependencies="odbc32.lib odbccp32.lib"
+				OutputFile="..\Debug\cgamex86.dll"
+				LinkIncremental="2"
+				SuppressStartupBanner="TRUE"
+				ModuleDefinitionFile=".\JK2_cgame.def"
+				GenerateDebugInformation="TRUE"
+				ProgramDatabaseFile=".\../Debug/cgamex86.pdb"
+				GenerateMapFile="TRUE"
+				MapFileName=".\../Debug/cgamex86.map"
+				SubSystem="2"
+				BaseAddress="0x30000000"
+				ImportLibrary=".\../Debug/cgamex86.lib"/>
+			<Tool
+				Name="VCMIDLTool"
+				PreprocessorDefinitions="_Debug"
+				MkTypLibCompatible="TRUE"
+				SuppressStartupBanner="TRUE"
+				TargetEnvironment="1"
+				TypeLibraryName=".\../Debug/JK2_cgame.tlb"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="VCResourceCompilerTool"
+				PreprocessorDefinitions="_Debug"
+				Culture="1033"/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"/>
+			<Tool
+				Name="VCWebDeploymentTool"/>
+		</Configuration>
+		<Configuration
+			Name="Debug(SH)|Win32"
+			OutputDirectory="Debug(SH)"
+			IntermediateDirectory="Debug(SH)"
+			ConfigurationType="2"
+			UseOfMFC="0"
+			ATLMinimizesCRunTimeLibraryUsage="FALSE">
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				OptimizeForProcessor="2"
+				AdditionalIncludeDirectories="..,./../game"
+				PreprocessorDefinitions="_DEBUG;WIN32;_WINDOWS;MISSIONPACK;CGAME;_JK2;JK2AWARDS"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="5"
+				UsePrecompiledHeader="2"
+				PrecompiledHeaderFile=".\../Debug/JK2cgame/JK2_cgame.pch"
+				AssemblerListingLocation=".\../Debug/JK2cgame/"
+				ObjectFile=".\../Debug/JK2cgame/"
+				ProgramDataBaseFileName=".\../Debug/JK2cgame/"
+				BrowseInformation="1"
+				WarningLevel="3"
+				SuppressStartupBanner="TRUE"
+				DebugInformationFormat="4"
+				CompileAs="0"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalOptions="/MACHINE:I386"
+				AdditionalDependencies="odbc32.lib odbccp32.lib"
+				OutputFile="..\Debug\cgamex86.dll"
+				LinkIncremental="2"
+				SuppressStartupBanner="TRUE"
+				ModuleDefinitionFile=".\JK2_cgame.def"
+				GenerateDebugInformation="TRUE"
+				ProgramDatabaseFile=".\../Debug/cgamex86.pdb"
+				GenerateMapFile="TRUE"
+				MapFileName=".\../Debug/JK2cgame/cgamex86.map"
+				SubSystem="2"
+				BaseAddress="0x30000000"
+				ImportLibrary=".\../Debug/cgamex86.lib"/>
+			<Tool
+				Name="VCMIDLTool"
+				PreprocessorDefinitions="_Debug"
+				MkTypLibCompatible="TRUE"
+				SuppressStartupBanner="TRUE"
+				TargetEnvironment="1"
+				TypeLibraryName=".\../Debug/JK2_cgame.tlb"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="VCResourceCompilerTool"
+				PreprocessorDefinitions="_Debug"
+				Culture="1033"/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"/>
+			<Tool
+				Name="VCWebDeploymentTool"/>
+		</Configuration>
+	</Configurations>
+	<Files>
+		<Filter
+			Name="Source Files"
+			Filter="c">
+			<File
+				RelativePath="..\game\AnimalNPC.c">
+			</File>
+			<File
+				RelativePath="..\game\FighterNPC.c">
+			</File>
+			<File
+				RelativePath="..\game\SpeederNPC.c">
+			</File>
+			<File
+				RelativePath="..\game\WalkerNPC.c">
+			</File>
+			<File
+				RelativePath="..\game\bg_g2_utils.c">
+			</File>
+			<File
+				RelativePath="..\game\bg_lib.c">
+				<FileConfiguration
+					Name="Release|Win32"
+					ExcludedFromBuild="TRUE">
+					<Tool
+						Name="VCCLCompilerTool"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Final|Win32"
+					ExcludedFromBuild="TRUE">
+					<Tool
+						Name="VCCLCompilerTool"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32"
+					ExcludedFromBuild="TRUE">
+					<Tool
+						Name="VCCLCompilerTool"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32"
+					ExcludedFromBuild="TRUE">
+					<Tool
+						Name="VCCLCompilerTool"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\bg_misc.c">
+			</File>
+			<File
+				RelativePath="..\game\bg_panimate.c">
+			</File>
+			<File
+				RelativePath="..\game\bg_pmove.c">
+			</File>
+			<File
+				RelativePath="..\game\bg_saber.c">
+			</File>
+			<File
+				RelativePath="..\game\bg_saberLoad.c">
+			</File>
+			<File
+				RelativePath="..\game\bg_saga.c">
+			</File>
+			<File
+				RelativePath="..\game\bg_slidemove.c">
+			</File>
+			<File
+				RelativePath="..\game\bg_vehicleLoad.c">
+			</File>
+			<File
+				RelativePath="..\game\bg_weapons.c">
+			</File>
+			<File
+				RelativePath=".\cg_consolecmds.c">
+			</File>
+			<File
+				RelativePath=".\cg_draw.c">
+			</File>
+			<File
+				RelativePath=".\cg_drawtools.c">
+			</File>
+			<File
+				RelativePath=".\cg_effects.c">
+			</File>
+			<File
+				RelativePath=".\cg_ents.c">
+			</File>
+			<File
+				RelativePath=".\cg_event.c">
+			</File>
+			<File
+				RelativePath=".\cg_info.c">
+			</File>
+			<File
+				RelativePath=".\cg_light.c">
+			</File>
+			<File
+				RelativePath=".\cg_localents.c">
+			</File>
+			<File
+				RelativePath=".\cg_main.c">
+			</File>
+			<File
+				RelativePath=".\cg_marks.c">
+			</File>
+			<File
+				RelativePath=".\cg_newDraw.c">
+			</File>
+			<File
+				RelativePath=".\cg_players.c">
+			</File>
+			<File
+				RelativePath=".\cg_playerstate.c">
+			</File>
+			<File
+				RelativePath=".\cg_predict.c">
+			</File>
+			<File
+				RelativePath=".\cg_saga.c">
+			</File>
+			<File
+				RelativePath=".\cg_scoreboard.c">
+			</File>
+			<File
+				RelativePath=".\cg_servercmds.c">
+			</File>
+			<File
+				RelativePath=".\cg_snapshot.c">
+			</File>
+			<File
+				RelativePath=".\cg_strap.c">
+			</File>
+			<File
+				RelativePath=".\cg_syscalls.c">
+			</File>
+			<File
+				RelativePath=".\cg_turret.c">
+			</File>
+			<File
+				RelativePath=".\cg_view.c">
+			</File>
+			<File
+				RelativePath=".\cg_weaponinit.c">
+			</File>
+			<File
+				RelativePath=".\cg_weapons.c">
+			</File>
+			<File
+				RelativePath=".\fx_blaster.c">
+			</File>
+			<File
+				RelativePath=".\fx_bowcaster.c">
+			</File>
+			<File
+				RelativePath=".\fx_bryarpistol.c">
+			</File>
+			<File
+				RelativePath=".\fx_demp2.c">
+			</File>
+			<File
+				RelativePath=".\fx_disruptor.c">
+			</File>
+			<File
+				RelativePath=".\fx_flechette.c">
+			</File>
+			<File
+				RelativePath=".\fx_force.c">
+			</File>
+			<File
+				RelativePath=".\fx_heavyrepeater.c">
+			</File>
+			<File
+				RelativePath=".\fx_rocketlauncher.c">
+			</File>
+			<File
+				RelativePath="..\game\q_math.c">
+			</File>
+			<File
+				RelativePath="..\game\q_shared.c">
+			</File>
+			<File
+				RelativePath="..\ui\ui_shared.c">
+			</File>
+		</Filter>
+		<Filter
+			Name="Header Files"
+			Filter="h">
+			<File
+				RelativePath="..\ghoul2\G2.h">
+			</File>
+			<File
+				RelativePath=".\JK2_cgame.def">
+			</File>
+			<File
+				RelativePath="..\game\anims.h">
+			</File>
+			<File
+				RelativePath=".\animtable.h">
+			</File>
+			<File
+				RelativePath="..\game\bg_local.h">
+			</File>
+			<File
+				RelativePath="..\game\bg_public.h">
+			</File>
+			<File
+				RelativePath="..\game\bg_saga.h">
+			</File>
+			<File
+				RelativePath="..\game\bg_strap.h">
+			</File>
+			<File
+				RelativePath="..\game\bg_weapons.h">
+			</File>
+			<File
+				RelativePath=".\cg_lights.h">
+			</File>
+			<File
+				RelativePath=".\cg_local.h">
+			</File>
+			<File
+				RelativePath=".\cg_public.h">
+			</File>
+			<File
+				RelativePath="..\qcommon\disablewarnings.h">
+			</File>
+			<File
+				RelativePath=".\fx_local.h">
+			</File>
+			<File
+				RelativePath="holocronicons.h">
+			</File>
+			<File
+				RelativePath="..\ui\keycodes.h">
+			</File>
+			<File
+				RelativePath="..\..\ui\menudef.h">
+			</File>
+			<File
+				RelativePath="..\game\q_shared.h">
+			</File>
+			<File
+				RelativePath="..\qcommon\qfiles.h">
+			</File>
+			<File
+				RelativePath="..\game\surfaceflags.h">
+			</File>
+			<File
+				RelativePath="..\qcommon\tags.h">
+			</File>
+			<File
+				RelativePath=".\tr_types.h">
+			</File>
+			<File
+				RelativePath="..\ui\ui_shared.h">
+			</File>
+		</Filter>
+		<Filter
+			Name="win32"
+			Filter="">
+			<File
+				RelativePath="..\win32\JK2cgame.rc">
+			</File>
+		</Filter>
+		<File
+			RelativePath=".\cgame.bat">
+		</File>
+		<File
+			RelativePath=".\cgame.q3asm">
+		</File>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>
diff --git a/codemp/cgame/JK2_cgame.vcproj.vspscc b/codemp/cgame/JK2_cgame.vcproj.vspscc
new file mode 100644
index 0000000..794f014
--- /dev/null
+++ b/codemp/cgame/JK2_cgame.vcproj.vspscc
@@ -0,0 +1,10 @@
+""
+{
+"FILE_VERSION" = "9237"
+"ENLISTMENT_CHOICE" = "NEVER"
+"PROJECT_FILE_RELATIVE_PATH" = ""
+"NUMBER_OF_EXCLUDED_FILES" = "0"
+"ORIGINAL_PROJECT_FILE_PATH" = ""
+"NUMBER_OF_NESTED_PROJECTS" = "0"
+"SOURCE_CONTROL_SETTINGS_PROVIDER" = "PROJECT"
+}
diff --git a/codemp/cgame/animtable.h b/codemp/cgame/animtable.h
new file mode 100644
index 0000000..84bfc55
--- /dev/null
+++ b/codemp/cgame/animtable.h
@@ -0,0 +1,1792 @@
+// special file included only by cg_players.cpp & ui_players.cpp
+//
+// moved it from the original header file for PCH reasons...
+//
+
+#if defined(_XBOX) && !defined(_JK2EXE) && !defined(_UI)	// Linker only wants one copy
+extern stringID_table_t animTable[MAX_ANIMATIONS+1];
+#else
+stringID_table_t animTable [MAX_ANIMATIONS+1] =
+{
+	//=================================================
+	//HEAD ANIMS
+	//=================================================
+	//# #sep Head-only anims
+	ENUM2STRING(FACE_TALK0),			//# silent
+	ENUM2STRING(FACE_TALK1),			//# quiet
+	ENUM2STRING(FACE_TALK2),			//# semi-quiet
+	ENUM2STRING(FACE_TALK3),			//# semi-loud
+	ENUM2STRING(FACE_TALK4),			//# loud
+	ENUM2STRING(FACE_ALERT),				//# 
+	ENUM2STRING(FACE_SMILE),				//# 
+	ENUM2STRING(FACE_FROWN),				//# 
+	ENUM2STRING(FACE_DEAD),				//# 
+
+	//=================================================
+	//ANIMS IN WHICH UPPER AND LOWER OBJECTS ARE IN MD3
+	//=================================================
+	//# #sep ENUM2STRING(BOTH_ DEATHS
+	ENUM2STRING(BOTH_DEATH1),		//# First Death anim
+	ENUM2STRING(BOTH_DEATH2),			//# Second Death anim
+	ENUM2STRING(BOTH_DEATH3),			//# Third Death anim
+	ENUM2STRING(BOTH_DEATH4),			//# Fourth Death anim
+	ENUM2STRING(BOTH_DEATH5),			//# Fifth Death anim
+	ENUM2STRING(BOTH_DEATH6),			//# Sixth Death anim
+	ENUM2STRING(BOTH_DEATH7),			//# Seventh Death anim
+	ENUM2STRING(BOTH_DEATH8),			//# 
+	ENUM2STRING(BOTH_DEATH9),			//# 
+	ENUM2STRING(BOTH_DEATH10),			//# 
+	ENUM2STRING(BOTH_DEATH11),			//#
+	ENUM2STRING(BOTH_DEATH12),			//# 
+	ENUM2STRING(BOTH_DEATH13),			//# 
+	ENUM2STRING(BOTH_DEATH14),			//# 
+	ENUM2STRING(BOTH_DEATH15),			//# 
+	ENUM2STRING(BOTH_DEATH16),			//# 
+	ENUM2STRING(BOTH_DEATH17),			//# 
+	ENUM2STRING(BOTH_DEATH18),			//# 
+	ENUM2STRING(BOTH_DEATH19),			//# 
+	ENUM2STRING(BOTH_DEATH20),			//# 
+	ENUM2STRING(BOTH_DEATH21),			//# 
+	ENUM2STRING(BOTH_DEATH22),			//# 
+	ENUM2STRING(BOTH_DEATH23),			//# 
+	ENUM2STRING(BOTH_DEATH24),			//# 
+	ENUM2STRING(BOTH_DEATH25),			//# 
+
+	ENUM2STRING(BOTH_DEATHFORWARD1),		//# First Death in which they get thrown forward
+	ENUM2STRING(BOTH_DEATHFORWARD2),		//# Second Death in which they get thrown forward
+	ENUM2STRING(BOTH_DEATHFORWARD3),		//# Tavion's falling in cin# 23
+	ENUM2STRING(BOTH_DEATHBACKWARD1),	//# First Death in which they get thrown backward
+	ENUM2STRING(BOTH_DEATHBACKWARD2),	//# Second Death in which they get thrown backward
+
+	ENUM2STRING(BOTH_DEATH1IDLE),		//# Idle while close to death
+	ENUM2STRING(BOTH_LYINGDEATH1),		//# Death to play when killed lying down
+	ENUM2STRING(BOTH_STUMBLEDEATH1),		//# Stumble forward and fall face first death
+	ENUM2STRING(BOTH_FALLDEATH1),		//# Fall forward off a high cliff and splat death - start
+	ENUM2STRING(BOTH_FALLDEATH1INAIR),	//# Fall forward off a high cliff and splat death - loop
+	ENUM2STRING(BOTH_FALLDEATH1LAND),	//# Fall forward off a high cliff and splat death - hit bottom
+	ENUM2STRING(BOTH_DEATH_ROLL),		//# Death anim from a roll
+	ENUM2STRING(BOTH_DEATH_FLIP),		//# Death anim from a flip
+	ENUM2STRING(BOTH_DEATH_SPIN_90_R),	//# Death anim when facing 90 degrees right
+	ENUM2STRING(BOTH_DEATH_SPIN_90_L),	//# Death anim when facing 90 degrees left
+	ENUM2STRING(BOTH_DEATH_SPIN_180),	//# Death anim when facing backwards
+	ENUM2STRING(BOTH_DEATH_LYING_UP),	//# Death anim when lying on back
+	ENUM2STRING(BOTH_DEATH_LYING_DN),	//# Death anim when lying on front
+	ENUM2STRING(BOTH_DEATH_FALLING_DN),	//# Death anim when falling on face
+	ENUM2STRING(BOTH_DEATH_FALLING_UP),	//# Death anim when falling on back
+	ENUM2STRING(BOTH_DEATH_CROUCHED),	//# Death anim when crouched
+	//# #sep ENUM2STRING(BOTH_ DEAD POSES # Should be last frame of corresponding previous anims
+	ENUM2STRING(BOTH_DEAD1),				//# First Death finished pose
+	ENUM2STRING(BOTH_DEAD2),				//# Second Death finished pose
+	ENUM2STRING(BOTH_DEAD3),				//# Third Death finished pose
+	ENUM2STRING(BOTH_DEAD4),				//# Fourth Death finished pose
+	ENUM2STRING(BOTH_DEAD5),				//# Fifth Death finished pose
+	ENUM2STRING(BOTH_DEAD6),				//# Sixth Death finished pose
+	ENUM2STRING(BOTH_DEAD7),				//# Seventh Death finished pose
+	ENUM2STRING(BOTH_DEAD8),				//# 
+	ENUM2STRING(BOTH_DEAD9),				//# 
+	ENUM2STRING(BOTH_DEAD10),			//# 
+	ENUM2STRING(BOTH_DEAD11),			//#
+	ENUM2STRING(BOTH_DEAD12),			//# 
+	ENUM2STRING(BOTH_DEAD13),			//# 
+	ENUM2STRING(BOTH_DEAD14),			//# 
+	ENUM2STRING(BOTH_DEAD15),			//# 
+	ENUM2STRING(BOTH_DEAD16),			//# 
+	ENUM2STRING(BOTH_DEAD17),			//# 
+	ENUM2STRING(BOTH_DEAD18),			//# 
+	ENUM2STRING(BOTH_DEAD19),			//# 
+	ENUM2STRING(BOTH_DEAD20),			//# 
+	ENUM2STRING(BOTH_DEAD21),			//# 
+	ENUM2STRING(BOTH_DEAD22),			//# 
+	ENUM2STRING(BOTH_DEAD23),			//# 
+	ENUM2STRING(BOTH_DEAD24),			//# 
+	ENUM2STRING(BOTH_DEAD25),			//# 
+	ENUM2STRING(BOTH_DEADFORWARD1),		//# First thrown forward death finished pose
+	ENUM2STRING(BOTH_DEADFORWARD2),		//# Second thrown forward death finished pose
+	ENUM2STRING(BOTH_DEADBACKWARD1),		//# First thrown backward death finished pose
+	ENUM2STRING(BOTH_DEADBACKWARD2),		//# Second thrown backward death finished pose
+	ENUM2STRING(BOTH_LYINGDEAD1),		//# Killed lying down death finished pose
+	ENUM2STRING(BOTH_STUMBLEDEAD1),		//# Stumble forward death finished pose
+	ENUM2STRING(BOTH_FALLDEAD1LAND),		//# Fall forward and splat death finished pose
+	//# #sep ENUM2STRING(BOTH_ DEAD TWITCH/FLOP # React to being shot from death poses
+	ENUM2STRING(BOTH_DEADFLOP1),		//# React to being shot from First Death finished pose
+	ENUM2STRING(BOTH_DEADFLOP2),		//# React to being shot from Second Death finished pose
+	ENUM2STRING(BOTH_DISMEMBER_HEAD1),	//#
+	ENUM2STRING(BOTH_DISMEMBER_TORSO1),	//#
+	ENUM2STRING(BOTH_DISMEMBER_LLEG),	//#
+	ENUM2STRING(BOTH_DISMEMBER_RLEG),	//#
+	ENUM2STRING(BOTH_DISMEMBER_RARM),	//#
+	ENUM2STRING(BOTH_DISMEMBER_LARM),	//#
+	//# #sep ENUM2STRING(BOTH_ PAINS
+	ENUM2STRING(BOTH_PAIN1),				//# First take pain anim
+	ENUM2STRING(BOTH_PAIN2),				//# Second take pain anim
+	ENUM2STRING(BOTH_PAIN3),				//# Third take pain anim
+	ENUM2STRING(BOTH_PAIN4),				//# Fourth take pain anim
+	ENUM2STRING(BOTH_PAIN5),				//# Fifth take pain anim - from behind
+	ENUM2STRING(BOTH_PAIN6),				//# Sixth take pain anim - from behind
+	ENUM2STRING(BOTH_PAIN7),				//# Seventh take pain anim - from behind
+	ENUM2STRING(BOTH_PAIN8),				//# Eigth take pain anim - from behind
+	ENUM2STRING(BOTH_PAIN9),				//# 
+	ENUM2STRING(BOTH_PAIN10),			//# 
+	ENUM2STRING(BOTH_PAIN11),			//# 
+	ENUM2STRING(BOTH_PAIN12),			//# 
+	ENUM2STRING(BOTH_PAIN13),			//# 
+	ENUM2STRING(BOTH_PAIN14),			//# 
+	ENUM2STRING(BOTH_PAIN15),			//# 
+	ENUM2STRING(BOTH_PAIN16),			//# 
+	ENUM2STRING(BOTH_PAIN17),			//# 
+	ENUM2STRING(BOTH_PAIN18),			//# 
+
+	//# #sep ENUM2STRING(BOTH_ ATTACKS
+	ENUM2STRING(BOTH_ATTACK1),			//# Attack with stun baton
+	ENUM2STRING(BOTH_ATTACK2),			//# Attack with one-handed pistol
+	ENUM2STRING(BOTH_ATTACK3),			//# Attack with blaster rifle
+	ENUM2STRING(BOTH_ATTACK4),			//# Attack with disruptor
+	ENUM2STRING(BOTH_ATTACK5),			//# Another Rancor Attack
+	ENUM2STRING(BOTH_ATTACK6),			//# Yet Another Rancor Attack
+	ENUM2STRING(BOTH_ATTACK7),			//# Yet Another Rancor Attack
+	ENUM2STRING(BOTH_ATTACK10),			//# Attack with thermal det
+	ENUM2STRING(BOTH_ATTACK11),			//# "Attack" with tripmine and detpack
+	ENUM2STRING(BOTH_MELEE1),			//# First melee attack
+	ENUM2STRING(BOTH_MELEE2),			//# Second melee attack
+	ENUM2STRING(BOTH_THERMAL_READY),	//# pull back with thermal
+	ENUM2STRING(BOTH_THERMAL_THROW),	//# throw thermal
+	//* #sep ENUM2STRING(BOTH_ SABER ANIMS
+	//Saber attack anims - power level 1
+	ENUM2STRING(BOTH_A1_T__B_),	//# Fast weak vertical attack top to bottom
+	ENUM2STRING(BOTH_A1__L__R),	//# Fast weak horizontal attack left to right
+	ENUM2STRING(BOTH_A1__R__L),	//# Fast weak horizontal attack right to left
+	ENUM2STRING(BOTH_A1_TL_BR),	//# Fast weak diagonal attack top left to botom right
+	ENUM2STRING(BOTH_A1_BR_TL),	//# Fast weak diagonal attack top left to botom right
+	ENUM2STRING(BOTH_A1_BL_TR),	//# Fast weak diagonal attack bottom left to top right
+	ENUM2STRING(BOTH_A1_TR_BL),	//# Fast weak diagonal attack bottom left to right
+	//Saber Arc and Spin Transitions
+	ENUM2STRING(BOTH_T1_BR__R),	//# Fast arc bottom right to right
+	ENUM2STRING(BOTH_T1_BR_TL),	//# Fast weak spin bottom right to top left
+	ENUM2STRING(BOTH_T1_BR__L),	//# Fast weak spin bottom right to left
+	ENUM2STRING(BOTH_T1_BR_BL),	//# Fast weak spin bottom right to bottom left
+	ENUM2STRING(BOTH_T1__R_TR),	//# Fast arc right to top right
+	ENUM2STRING(BOTH_T1__R_TL),	//# Fast arc right to top left
+	ENUM2STRING(BOTH_T1__R__L),	//# Fast weak spin right to left
+	ENUM2STRING(BOTH_T1__R_BL),	//# Fast weak spin right to bottom left
+	ENUM2STRING(BOTH_T1_TR_BR),	//# Fast arc top right to bottom right
+	ENUM2STRING(BOTH_T1_TR_TL),	//# Fast arc top right to top left
+	ENUM2STRING(BOTH_T1_TR__L),	//# Fast arc top right to left
+	ENUM2STRING(BOTH_T1_TR_BL),	//# Fast weak spin top right to bottom left
+	ENUM2STRING(BOTH_T1_T__BR),	//# Fast arc top to bottom right
+	ENUM2STRING(BOTH_T1_T___R),	//# Fast arc top to right
+	ENUM2STRING(BOTH_T1_T__TR),	//# Fast arc top to top right
+	ENUM2STRING(BOTH_T1_T__TL),	//# Fast arc top to top left
+	ENUM2STRING(BOTH_T1_T___L),	//# Fast arc top to left
+	ENUM2STRING(BOTH_T1_T__BL),	//# Fast arc top to bottom left
+	ENUM2STRING(BOTH_T1_TL_BR),	//# Fast weak spin top left to bottom right
+	ENUM2STRING(BOTH_T1_TL_BL),	//# Fast arc top left to bottom left
+	ENUM2STRING(BOTH_T1__L_BR),	//# Fast weak spin left to bottom right
+	ENUM2STRING(BOTH_T1__L__R),	//# Fast weak spin left to right
+	ENUM2STRING(BOTH_T1__L_TL),	//# Fast arc left to top left
+	ENUM2STRING(BOTH_T1_BL_BR),	//# Fast weak spin bottom left to bottom right
+	ENUM2STRING(BOTH_T1_BL__R),	//# Fast weak spin bottom left to right
+	ENUM2STRING(BOTH_T1_BL_TR),	//# Fast weak spin bottom left to top right
+	ENUM2STRING(BOTH_T1_BL__L),	//# Fast arc bottom left to left
+	//Saber Arc Transitions that use existing animations played backwards
+	ENUM2STRING(BOTH_T1_BR_TR),	//# Fast arc bottom right to top right		(use: ENUM2STRING(BOTH_T1_TR_BR)
+	ENUM2STRING(BOTH_T1_BR_T_),	//# Fast arc bottom right to top			(use: ENUM2STRING(BOTH_T1_T__BR)
+	ENUM2STRING(BOTH_T1__R_BR),	//# Fast arc right to bottom right			(use: ENUM2STRING(BOTH_T1_BR__R)
+	ENUM2STRING(BOTH_T1__R_T_),	//# Fast ar right to top				(use: ENUM2STRING(BOTH_T1_T___R)
+	ENUM2STRING(BOTH_T1_TR__R),	//# Fast arc top right to right			(use: ENUM2STRING(BOTH_T1__R_TR)
+	ENUM2STRING(BOTH_T1_TR_T_),	//# Fast arc top right to top				(use: ENUM2STRING(BOTH_T1_T__TR)
+	ENUM2STRING(BOTH_T1_TL__R),	//# Fast arc top left to right			(use: ENUM2STRING(BOTH_T1__R_TL)
+	ENUM2STRING(BOTH_T1_TL_TR),	//# Fast arc top left to top right			(use: ENUM2STRING(BOTH_T1_TR_TL)
+	ENUM2STRING(BOTH_T1_TL_T_),	//# Fast arc top left to top				(use: ENUM2STRING(BOTH_T1_T__TL)
+	ENUM2STRING(BOTH_T1_TL__L),	//# Fast arc top left to left				(use: ENUM2STRING(BOTH_T1__L_TL)
+	ENUM2STRING(BOTH_T1__L_TR),	//# Fast arc left to top right			(use: ENUM2STRING(BOTH_T1_TR__L)
+	ENUM2STRING(BOTH_T1__L_T_),	//# Fast arc left to top				(use: ENUM2STRING(BOTH_T1_T___L)
+	ENUM2STRING(BOTH_T1__L_BL),	//# Fast arc left to bottom left			(use: ENUM2STRING(BOTH_T1_BL__L)
+	ENUM2STRING(BOTH_T1_BL_T_),	//# Fast arc bottom left to top			(use: ENUM2STRING(BOTH_T1_T__BL)
+	ENUM2STRING(BOTH_T1_BL_TL),	//# Fast arc bottom left to top left		(use: ENUM2STRING(BOTH_T1_TL_BL)
+	//Saber Attack Start Transitions
+	ENUM2STRING(BOTH_S1_S1_T_),	//# Fast plain transition from stance1 to top-to-bottom Fast weak attack
+	ENUM2STRING(BOTH_S1_S1__L),	//# Fast plain transition from stance1 to left-to-right Fast weak attack
+	ENUM2STRING(BOTH_S1_S1__R),	//# Fast plain transition from stance1 to right-to-left Fast weak attack
+	ENUM2STRING(BOTH_S1_S1_TL),	//# Fast plain transition from stance1 to top-left-to-bottom-right Fast weak attack
+	ENUM2STRING(BOTH_S1_S1_BR),	//# Fast plain transition from stance1 to bottom-right-to-top-left Fast weak attack
+	ENUM2STRING(BOTH_S1_S1_BL),	//# Fast plain transition from stance1 to bottom-left-to-top-right Fast weak attack
+	ENUM2STRING(BOTH_S1_S1_TR),	//# Fast plain transition from stance1 to top-right-to-bottom-left Fast weak attack
+	//Saber Attack Return Transitions
+	ENUM2STRING(BOTH_R1_B__S1),	//# Fast plain transition from top-to-bottom Fast weak attack to stance1
+	ENUM2STRING(BOTH_R1__L_S1),	//# Fast plain transition from left-to-right Fast weak attack to stance1
+	ENUM2STRING(BOTH_R1__R_S1),	//# Fast plain transition from right-to-left Fast weak attack to stance1
+	ENUM2STRING(BOTH_R1_TL_S1),	//# Fast plain transition from top-left-to-bottom-right Fast weak attack to stance1
+	ENUM2STRING(BOTH_R1_BR_S1),	//# Fast plain transition from bottom-right-to-top-left Fast weak attack to stance1
+	ENUM2STRING(BOTH_R1_BL_S1),	//# Fast plain transition from bottom-left-to-top-right Fast weak attack to stance1
+	ENUM2STRING(BOTH_R1_TR_S1),	//# Fast plain transition from top-right-to-bottom-left Fast weak attack
+	//Saber Attack Bounces (first 4 frames of an attack), played backwards)
+	ENUM2STRING(BOTH_B1_BR___),	//# Bounce-back if attack from BR is blocked
+	ENUM2STRING(BOTH_B1__R___),	//# Bounce-back if attack from R is blocked
+	ENUM2STRING(BOTH_B1_TR___),	//# Bounce-back if attack from TR is blocked
+	ENUM2STRING(BOTH_B1_T____),	//# Bounce-back if attack from T is blocked
+	ENUM2STRING(BOTH_B1_TL___),	//# Bounce-back if attack from TL is blocked
+	ENUM2STRING(BOTH_B1__L___),	//# Bounce-back if attack from L is blocked
+	ENUM2STRING(BOTH_B1_BL___),	//# Bounce-back if attack from BL is blocked
+	//Saber Attack Deflections (last 4 frames of an attack)
+	ENUM2STRING(BOTH_D1_BR___),	//# Deflection toward BR
+	ENUM2STRING(BOTH_D1__R___),	//# Deflection toward R
+	ENUM2STRING(BOTH_D1_TR___),	//# Deflection toward TR
+	ENUM2STRING(BOTH_D1_TL___),	//# Deflection toward TL
+	ENUM2STRING(BOTH_D1__L___),	//# Deflection toward L
+	ENUM2STRING(BOTH_D1_BL___),	//# Deflection toward BL
+	ENUM2STRING(BOTH_D1_B____),	//# Deflection toward B
+	//Saber attack anims - power level 2
+	ENUM2STRING(BOTH_A2_T__B_),	//# Fast weak vertical attack top to bottom
+	ENUM2STRING(BOTH_A2__L__R),	//# Fast weak horizontal attack left to right
+	ENUM2STRING(BOTH_A2__R__L),	//# Fast weak horizontal attack right to left
+	ENUM2STRING(BOTH_A2_TL_BR),	//# Fast weak diagonal attack top left to botom right
+	ENUM2STRING(BOTH_A2_BR_TL),	//# Fast weak diagonal attack top left to botom right
+	ENUM2STRING(BOTH_A2_BL_TR),	//# Fast weak diagonal attack bottom left to top right
+	ENUM2STRING(BOTH_A2_TR_BL),	//# Fast weak diagonal attack bottom left to right
+	//Saber Arc and Spin Transitions
+	ENUM2STRING(BOTH_T2_BR__R),	//# Fast arc bottom right to right
+	ENUM2STRING(BOTH_T2_BR_TL),	//# Fast weak spin bottom right to top left
+	ENUM2STRING(BOTH_T2_BR__L),	//# Fast weak spin bottom right to left
+	ENUM2STRING(BOTH_T2_BR_BL),	//# Fast weak spin bottom right to bottom left
+	ENUM2STRING(BOTH_T2__R_TR),	//# Fast arc right to top right
+	ENUM2STRING(BOTH_T2__R_TL),	//# Fast arc right to top left
+	ENUM2STRING(BOTH_T2__R__L),	//# Fast weak spin right to left
+	ENUM2STRING(BOTH_T2__R_BL),	//# Fast weak spin right to bottom left
+	ENUM2STRING(BOTH_T2_TR_BR),	//# Fast arc top right to bottom right
+	ENUM2STRING(BOTH_T2_TR_TL),	//# Fast arc top right to top left
+	ENUM2STRING(BOTH_T2_TR__L),	//# Fast arc top right to left
+	ENUM2STRING(BOTH_T2_TR_BL),	//# Fast weak spin top right to bottom left
+	ENUM2STRING(BOTH_T2_T__BR),	//# Fast arc top to bottom right
+	ENUM2STRING(BOTH_T2_T___R),	//# Fast arc top to right
+	ENUM2STRING(BOTH_T2_T__TR),	//# Fast arc top to top right
+	ENUM2STRING(BOTH_T2_T__TL),	//# Fast arc top to top left
+	ENUM2STRING(BOTH_T2_T___L),	//# Fast arc top to left
+	ENUM2STRING(BOTH_T2_T__BL),	//# Fast arc top to bottom left
+	ENUM2STRING(BOTH_T2_TL_BR),	//# Fast weak spin top left to bottom right
+	ENUM2STRING(BOTH_T2_TL_BL),	//# Fast arc top left to bottom left
+	ENUM2STRING(BOTH_T2__L_BR),	//# Fast weak spin left to bottom right
+	ENUM2STRING(BOTH_T2__L__R),	//# Fast weak spin left to right
+	ENUM2STRING(BOTH_T2__L_TL),	//# Fast arc left to top left
+	ENUM2STRING(BOTH_T2_BL_BR),	//# Fast weak spin bottom left to bottom right
+	ENUM2STRING(BOTH_T2_BL__R),	//# Fast weak spin bottom left to right
+	ENUM2STRING(BOTH_T2_BL_TR),	//# Fast weak spin bottom left to top right
+	ENUM2STRING(BOTH_T2_BL__L),	//# Fast arc bottom left to left
+	//Saber Arc Transitions that use existing animations played backwards
+	ENUM2STRING(BOTH_T2_BR_TR),	//# Fast arc bottom right to top right		(use: ENUM2STRING(BOTH_T2_TR_BR)
+	ENUM2STRING(BOTH_T2_BR_T_),	//# Fast arc bottom right to top			(use: ENUM2STRING(BOTH_T2_T__BR)
+	ENUM2STRING(BOTH_T2__R_BR),	//# Fast arc right to bottom right			(use: ENUM2STRING(BOTH_T2_BR__R)
+	ENUM2STRING(BOTH_T2__R_T_),	//# Fast ar right to top				(use: ENUM2STRING(BOTH_T2_T___R)
+	ENUM2STRING(BOTH_T2_TR__R),	//# Fast arc top right to right			(use: ENUM2STRING(BOTH_T2__R_TR)
+	ENUM2STRING(BOTH_T2_TR_T_),	//# Fast arc top right to top				(use: ENUM2STRING(BOTH_T2_T__TR)
+	ENUM2STRING(BOTH_T2_TL__R),	//# Fast arc top left to right			(use: ENUM2STRING(BOTH_T2__R_TL)
+	ENUM2STRING(BOTH_T2_TL_TR),	//# Fast arc top left to top right			(use: ENUM2STRING(BOTH_T2_TR_TL)
+	ENUM2STRING(BOTH_T2_TL_T_),	//# Fast arc top left to top				(use: ENUM2STRING(BOTH_T2_T__TL)
+	ENUM2STRING(BOTH_T2_TL__L),	//# Fast arc top left to left				(use: ENUM2STRING(BOTH_T2__L_TL)
+	ENUM2STRING(BOTH_T2__L_TR),	//# Fast arc left to top right			(use: ENUM2STRING(BOTH_T2_TR__L)
+	ENUM2STRING(BOTH_T2__L_T_),	//# Fast arc left to top				(use: ENUM2STRING(BOTH_T2_T___L)
+	ENUM2STRING(BOTH_T2__L_BL),	//# Fast arc left to bottom left			(use: ENUM2STRING(BOTH_T2_BL__L)
+	ENUM2STRING(BOTH_T2_BL_T_),	//# Fast arc bottom left to top			(use: ENUM2STRING(BOTH_T2_T__BL)
+	ENUM2STRING(BOTH_T2_BL_TL),	//# Fast arc bottom left to top left		(use: ENUM2STRING(BOTH_T2_TL_BL)
+	//Saber Attack Start Transitions
+	ENUM2STRING(BOTH_S2_S1_T_),	//# Fast plain transition from stance1 to top-to-bottom Fast weak attack
+	ENUM2STRING(BOTH_S2_S1__L),	//# Fast plain transition from stance1 to left-to-right Fast weak attack
+	ENUM2STRING(BOTH_S2_S1__R),	//# Fast plain transition from stance1 to right-to-left Fast weak attack
+	ENUM2STRING(BOTH_S2_S1_TL),	//# Fast plain transition from stance1 to top-left-to-bottom-right Fast weak attack
+	ENUM2STRING(BOTH_S2_S1_BR),	//# Fast plain transition from stance1 to bottom-right-to-top-left Fast weak attack
+	ENUM2STRING(BOTH_S2_S1_BL),	//# Fast plain transition from stance1 to bottom-left-to-top-right Fast weak attack
+	ENUM2STRING(BOTH_S2_S1_TR),	//# Fast plain transition from stance1 to top-right-to-bottom-left Fast weak attack
+	//Saber Attack Return Transitions
+	ENUM2STRING(BOTH_R2_B__S1),	//# Fast plain transition from top-to-bottom Fast weak attack to stance1
+	ENUM2STRING(BOTH_R2__L_S1),	//# Fast plain transition from left-to-right Fast weak attack to stance1
+	ENUM2STRING(BOTH_R2__R_S1),	//# Fast plain transition from right-to-left Fast weak attack to stance1
+	ENUM2STRING(BOTH_R2_TL_S1),	//# Fast plain transition from top-left-to-bottom-right Fast weak attack to stance1
+	ENUM2STRING(BOTH_R2_BR_S1),	//# Fast plain transition from bottom-right-to-top-left Fast weak attack to stance1
+	ENUM2STRING(BOTH_R2_BL_S1),	//# Fast plain transition from bottom-left-to-top-right Fast weak attack to stance1
+	ENUM2STRING(BOTH_R2_TR_S1),	//# Fast plain transition from top-right-to-bottom-left Fast weak attack
+	//Saber Attack Bounces (first 4 frames of an attack), played backwards)
+	ENUM2STRING(BOTH_B2_BR___),	//# Bounce-back if attack from BR is blocked
+	ENUM2STRING(BOTH_B2__R___),	//# Bounce-back if attack from R is blocked
+	ENUM2STRING(BOTH_B2_TR___),	//# Bounce-back if attack from TR is blocked
+	ENUM2STRING(BOTH_B2_T____),	//# Bounce-back if attack from T is blocked
+	ENUM2STRING(BOTH_B2_TL___),	//# Bounce-back if attack from TL is blocked
+	ENUM2STRING(BOTH_B2__L___),	//# Bounce-back if attack from L is blocked
+	ENUM2STRING(BOTH_B2_BL___),	//# Bounce-back if attack from BL is blocked
+	//Saber Attack Deflections (last 4 frames of an attack)
+	ENUM2STRING(BOTH_D2_BR___),	//# Deflection toward BR
+	ENUM2STRING(BOTH_D2__R___),	//# Deflection toward R
+	ENUM2STRING(BOTH_D2_TR___),	//# Deflection toward TR
+	ENUM2STRING(BOTH_D2_TL___),	//# Deflection toward TL
+	ENUM2STRING(BOTH_D2__L___),	//# Deflection toward L
+	ENUM2STRING(BOTH_D2_BL___),	//# Deflection toward BL
+	ENUM2STRING(BOTH_D2_B____),	//# Deflection toward B
+	//Saber attack anims - power level 3
+	ENUM2STRING(BOTH_A3_T__B_),	//# Fast weak vertical attack top to bottom
+	ENUM2STRING(BOTH_A3__L__R),	//# Fast weak horizontal attack left to right
+	ENUM2STRING(BOTH_A3__R__L),	//# Fast weak horizontal attack right to left
+	ENUM2STRING(BOTH_A3_TL_BR),	//# Fast weak diagonal attack top left to botom right
+	ENUM2STRING(BOTH_A3_BR_TL),	//# Fast weak diagonal attack top left to botom right
+	ENUM2STRING(BOTH_A3_BL_TR),	//# Fast weak diagonal attack bottom left to top right
+	ENUM2STRING(BOTH_A3_TR_BL),	//# Fast weak diagonal attack bottom left to right
+	//Saber Arc and Spin Transitions
+	ENUM2STRING(BOTH_T3_BR__R),	//# Fast arc bottom right to right
+	ENUM2STRING(BOTH_T3_BR_TL),	//# Fast weak spin bottom right to top left
+	ENUM2STRING(BOTH_T3_BR__L),	//# Fast weak spin bottom right to left
+	ENUM2STRING(BOTH_T3_BR_BL),	//# Fast weak spin bottom right to bottom left
+	ENUM2STRING(BOTH_T3__R_TR),	//# Fast arc right to top right
+	ENUM2STRING(BOTH_T3__R_TL),	//# Fast arc right to top left
+	ENUM2STRING(BOTH_T3__R__L),	//# Fast weak spin right to left
+	ENUM2STRING(BOTH_T3__R_BL),	//# Fast weak spin right to bottom left
+	ENUM2STRING(BOTH_T3_TR_BR),	//# Fast arc top right to bottom right
+	ENUM2STRING(BOTH_T3_TR_TL),	//# Fast arc top right to top left
+	ENUM2STRING(BOTH_T3_TR__L),	//# Fast arc top right to left
+	ENUM2STRING(BOTH_T3_TR_BL),	//# Fast weak spin top right to bottom left
+	ENUM2STRING(BOTH_T3_T__BR),	//# Fast arc top to bottom right
+	ENUM2STRING(BOTH_T3_T___R),	//# Fast arc top to right
+	ENUM2STRING(BOTH_T3_T__TR),	//# Fast arc top to top right
+	ENUM2STRING(BOTH_T3_T__TL),	//# Fast arc top to top left
+	ENUM2STRING(BOTH_T3_T___L),	//# Fast arc top to left
+	ENUM2STRING(BOTH_T3_T__BL),	//# Fast arc top to bottom left
+	ENUM2STRING(BOTH_T3_TL_BR),	//# Fast weak spin top left to bottom right
+	ENUM2STRING(BOTH_T3_TL_BL),	//# Fast arc top left to bottom left
+	ENUM2STRING(BOTH_T3__L_BR),	//# Fast weak spin left to bottom right
+	ENUM2STRING(BOTH_T3__L__R),	//# Fast weak spin left to right
+	ENUM2STRING(BOTH_T3__L_TL),	//# Fast arc left to top left
+	ENUM2STRING(BOTH_T3_BL_BR),	//# Fast weak spin bottom left to bottom right
+	ENUM2STRING(BOTH_T3_BL__R),	//# Fast weak spin bottom left to right
+	ENUM2STRING(BOTH_T3_BL_TR),	//# Fast weak spin bottom left to top right
+	ENUM2STRING(BOTH_T3_BL__L),	//# Fast arc bottom left to left
+	//Saber Arc Transitions that use existing animations played backwards
+	ENUM2STRING(BOTH_T3_BR_TR),	//# Fast arc bottom right to top right		(use: ENUM2STRING(BOTH_T3_TR_BR)
+	ENUM2STRING(BOTH_T3_BR_T_),	//# Fast arc bottom right to top			(use: ENUM2STRING(BOTH_T3_T__BR)
+	ENUM2STRING(BOTH_T3__R_BR),	//# Fast arc right to bottom right			(use: ENUM2STRING(BOTH_T3_BR__R)
+	ENUM2STRING(BOTH_T3__R_T_),	//# Fast ar right to top				(use: ENUM2STRING(BOTH_T3_T___R)
+	ENUM2STRING(BOTH_T3_TR__R),	//# Fast arc top right to right			(use: ENUM2STRING(BOTH_T3__R_TR)
+	ENUM2STRING(BOTH_T3_TR_T_),	//# Fast arc top right to top				(use: ENUM2STRING(BOTH_T3_T__TR)
+	ENUM2STRING(BOTH_T3_TL__R),	//# Fast arc top left to right			(use: ENUM2STRING(BOTH_T3__R_TL)
+	ENUM2STRING(BOTH_T3_TL_TR),	//# Fast arc top left to top right			(use: ENUM2STRING(BOTH_T3_TR_TL)
+	ENUM2STRING(BOTH_T3_TL_T_),	//# Fast arc top left to top				(use: ENUM2STRING(BOTH_T3_T__TL)
+	ENUM2STRING(BOTH_T3_TL__L),	//# Fast arc top left to left				(use: ENUM2STRING(BOTH_T3__L_TL)
+	ENUM2STRING(BOTH_T3__L_TR),	//# Fast arc left to top right			(use: ENUM2STRING(BOTH_T3_TR__L)
+	ENUM2STRING(BOTH_T3__L_T_),	//# Fast arc left to top				(use: ENUM2STRING(BOTH_T3_T___L)
+	ENUM2STRING(BOTH_T3__L_BL),	//# Fast arc left to bottom left			(use: ENUM2STRING(BOTH_T3_BL__L)
+	ENUM2STRING(BOTH_T3_BL_T_),	//# Fast arc bottom left to top			(use: ENUM2STRING(BOTH_T3_T__BL)
+	ENUM2STRING(BOTH_T3_BL_TL),	//# Fast arc bottom left to top left		(use: ENUM2STRING(BOTH_T3_TL_BL)
+	//Saber Attack Start Transitions
+	ENUM2STRING(BOTH_S3_S1_T_),	//# Fast plain transition from stance1 to top-to-bottom Fast weak attack
+	ENUM2STRING(BOTH_S3_S1__L),	//# Fast plain transition from stance1 to left-to-right Fast weak attack
+	ENUM2STRING(BOTH_S3_S1__R),	//# Fast plain transition from stance1 to right-to-left Fast weak attack
+	ENUM2STRING(BOTH_S3_S1_TL),	//# Fast plain transition from stance1 to top-left-to-bottom-right Fast weak attack
+	ENUM2STRING(BOTH_S3_S1_BR),	//# Fast plain transition from stance1 to bottom-right-to-top-left Fast weak attack
+	ENUM2STRING(BOTH_S3_S1_BL),	//# Fast plain transition from stance1 to bottom-left-to-top-right Fast weak attack
+	ENUM2STRING(BOTH_S3_S1_TR),	//# Fast plain transition from stance1 to top-right-to-bottom-left Fast weak attack
+	//Saber Attack Return Transitions
+	ENUM2STRING(BOTH_R3_B__S1),	//# Fast plain transition from top-to-bottom Fast weak attack to stance1
+	ENUM2STRING(BOTH_R3__L_S1),	//# Fast plain transition from left-to-right Fast weak attack to stance1
+	ENUM2STRING(BOTH_R3__R_S1),	//# Fast plain transition from right-to-left Fast weak attack to stance1
+	ENUM2STRING(BOTH_R3_TL_S1),	//# Fast plain transition from top-left-to-bottom-right Fast weak attack to stance1
+	ENUM2STRING(BOTH_R3_BR_S1),	//# Fast plain transition from bottom-right-to-top-left Fast weak attack to stance1
+	ENUM2STRING(BOTH_R3_BL_S1),	//# Fast plain transition from bottom-left-to-top-right Fast weak attack to stance1
+	ENUM2STRING(BOTH_R3_TR_S1),	//# Fast plain transition from top-right-to-bottom-left Fast weak attack
+	//Saber Attack Bounces (first 4 frames of an attack), played backwards)
+	ENUM2STRING(BOTH_B3_BR___),	//# Bounce-back if attack from BR is blocked
+	ENUM2STRING(BOTH_B3__R___),	//# Bounce-back if attack from R is blocked
+	ENUM2STRING(BOTH_B3_TR___),	//# Bounce-back if attack from TR is blocked
+	ENUM2STRING(BOTH_B3_T____),	//# Bounce-back if attack from T is blocked
+	ENUM2STRING(BOTH_B3_TL___),	//# Bounce-back if attack from TL is blocked
+	ENUM2STRING(BOTH_B3__L___),	//# Bounce-back if attack from L is blocked
+	ENUM2STRING(BOTH_B3_BL___),	//# Bounce-back if attack from BL is blocked
+	//Saber Attack Deflections (last 4 frames of an attack)
+	ENUM2STRING(BOTH_D3_BR___),	//# Deflection toward BR
+	ENUM2STRING(BOTH_D3__R___),	//# Deflection toward R
+	ENUM2STRING(BOTH_D3_TR___),	//# Deflection toward TR
+	ENUM2STRING(BOTH_D3_TL___),	//# Deflection toward TL
+	ENUM2STRING(BOTH_D3__L___),	//# Deflection toward L
+	ENUM2STRING(BOTH_D3_BL___),	//# Deflection toward BL
+	ENUM2STRING(BOTH_D3_B____),	//# Deflection toward B
+	//Saber attack anims - power level 4 - Desann's
+	ENUM2STRING(BOTH_A4_T__B_),	//# Fast weak vertical attack top to bottom
+	ENUM2STRING(BOTH_A4__L__R),	//# Fast weak horizontal attack left to right
+	ENUM2STRING(BOTH_A4__R__L),	//# Fast weak horizontal attack right to left
+	ENUM2STRING(BOTH_A4_TL_BR),	//# Fast weak diagonal attack top left to botom right
+	ENUM2STRING(BOTH_A4_BR_TL),	//# Fast weak diagonal attack top left to botom right
+	ENUM2STRING(BOTH_A4_BL_TR),	//# Fast weak diagonal attack bottom left to top right
+	ENUM2STRING(BOTH_A4_TR_BL),	//# Fast weak diagonal attack bottom left to right
+	//Saber Arc and Spin Transitions
+	ENUM2STRING(BOTH_T4_BR__R),	//# Fast arc bottom right to right
+	ENUM2STRING(BOTH_T4_BR_TL),	//# Fast weak spin bottom right to top left
+	ENUM2STRING(BOTH_T4_BR__L),	//# Fast weak spin bottom right to left
+	ENUM2STRING(BOTH_T4_BR_BL),	//# Fast weak spin bottom right to bottom left
+	ENUM2STRING(BOTH_T4__R_TR),	//# Fast arc right to top right
+	ENUM2STRING(BOTH_T4__R_TL),	//# Fast arc right to top left
+	ENUM2STRING(BOTH_T4__R__L),	//# Fast weak spin right to left
+	ENUM2STRING(BOTH_T4__R_BL),	//# Fast weak spin right to bottom left
+	ENUM2STRING(BOTH_T4_TR_BR),	//# Fast arc top right to bottom right
+	ENUM2STRING(BOTH_T4_TR_TL),	//# Fast arc top right to top left
+	ENUM2STRING(BOTH_T4_TR__L),	//# Fast arc top right to left
+	ENUM2STRING(BOTH_T4_TR_BL),	//# Fast weak spin top right to bottom left
+	ENUM2STRING(BOTH_T4_T__BR),	//# Fast arc top to bottom right
+	ENUM2STRING(BOTH_T4_T___R),	//# Fast arc top to right
+	ENUM2STRING(BOTH_T4_T__TR),	//# Fast arc top to top right
+	ENUM2STRING(BOTH_T4_T__TL),	//# Fast arc top to top left
+	ENUM2STRING(BOTH_T4_T___L),	//# Fast arc top to left
+	ENUM2STRING(BOTH_T4_T__BL),	//# Fast arc top to bottom left
+	ENUM2STRING(BOTH_T4_TL_BR),	//# Fast weak spin top left to bottom right
+	ENUM2STRING(BOTH_T4_TL_BL),	//# Fast arc top left to bottom left
+	ENUM2STRING(BOTH_T4__L_BR),	//# Fast weak spin left to bottom right
+	ENUM2STRING(BOTH_T4__L__R),	//# Fast weak spin left to right
+	ENUM2STRING(BOTH_T4__L_TL),	//# Fast arc left to top left
+	ENUM2STRING(BOTH_T4_BL_BR),	//# Fast weak spin bottom left to bottom right
+	ENUM2STRING(BOTH_T4_BL__R),	//# Fast weak spin bottom left to right
+	ENUM2STRING(BOTH_T4_BL_TR),	//# Fast weak spin bottom left to top right
+	ENUM2STRING(BOTH_T4_BL__L),	//# Fast arc bottom left to left
+	//Saber Arc Transitions that use existing animations played backwards
+	ENUM2STRING(BOTH_T4_BR_TR),	//# Fast arc bottom right to top right		(use: ENUM2STRING(BOTH_T4_TR_BR)
+	ENUM2STRING(BOTH_T4_BR_T_),	//# Fast arc bottom right to top			(use: ENUM2STRING(BOTH_T4_T__BR)
+	ENUM2STRING(BOTH_T4__R_BR),	//# Fast arc right to bottom right			(use: ENUM2STRING(BOTH_T4_BR__R)
+	ENUM2STRING(BOTH_T4__R_T_),	//# Fast ar right to top				(use: ENUM2STRING(BOTH_T4_T___R)
+	ENUM2STRING(BOTH_T4_TR__R),	//# Fast arc top right to right			(use: ENUM2STRING(BOTH_T4__R_TR)
+	ENUM2STRING(BOTH_T4_TR_T_),	//# Fast arc top right to top				(use: ENUM2STRING(BOTH_T4_T__TR)
+	ENUM2STRING(BOTH_T4_TL__R),	//# Fast arc top left to right			(use: ENUM2STRING(BOTH_T4__R_TL)
+	ENUM2STRING(BOTH_T4_TL_TR),	//# Fast arc top left to top right			(use: ENUM2STRING(BOTH_T4_TR_TL)
+	ENUM2STRING(BOTH_T4_TL_T_),	//# Fast arc top left to top				(use: ENUM2STRING(BOTH_T4_T__TL)
+	ENUM2STRING(BOTH_T4_TL__L),	//# Fast arc top left to left				(use: ENUM2STRING(BOTH_T4__L_TL)
+	ENUM2STRING(BOTH_T4__L_TR),	//# Fast arc left to top right			(use: ENUM2STRING(BOTH_T4_TR__L)
+	ENUM2STRING(BOTH_T4__L_T_),	//# Fast arc left to top				(use: ENUM2STRING(BOTH_T4_T___L)
+	ENUM2STRING(BOTH_T4__L_BL),	//# Fast arc left to bottom left			(use: ENUM2STRING(BOTH_T4_BL__L)
+	ENUM2STRING(BOTH_T4_BL_T_),	//# Fast arc bottom left to top			(use: ENUM2STRING(BOTH_T4_T__BL)
+	ENUM2STRING(BOTH_T4_BL_TL),	//# Fast arc bottom left to top left		(use: ENUM2STRING(BOTH_T4_TL_BL)
+	//Saber Attack Start Transitions
+	ENUM2STRING(BOTH_S4_S1_T_),	//# Fast plain transition from stance1 to top-to-bottom Fast weak attack
+	ENUM2STRING(BOTH_S4_S1__L),	//# Fast plain transition from stance1 to left-to-right Fast weak attack
+	ENUM2STRING(BOTH_S4_S1__R),	//# Fast plain transition from stance1 to right-to-left Fast weak attack
+	ENUM2STRING(BOTH_S4_S1_TL),	//# Fast plain transition from stance1 to top-left-to-bottom-right Fast weak attack
+	ENUM2STRING(BOTH_S4_S1_BR),	//# Fast plain transition from stance1 to bottom-right-to-top-left Fast weak attack
+	ENUM2STRING(BOTH_S4_S1_BL),	//# Fast plain transition from stance1 to bottom-left-to-top-right Fast weak attack
+	ENUM2STRING(BOTH_S4_S1_TR),	//# Fast plain transition from stance1 to top-right-to-bottom-left Fast weak attack
+	//Saber Attack Return Transitions
+	ENUM2STRING(BOTH_R4_B__S1),	//# Fast plain transition from top-to-bottom Fast weak attack to stance1
+	ENUM2STRING(BOTH_R4__L_S1),	//# Fast plain transition from left-to-right Fast weak attack to stance1
+	ENUM2STRING(BOTH_R4__R_S1),	//# Fast plain transition from right-to-left Fast weak attack to stance1
+	ENUM2STRING(BOTH_R4_TL_S1),	//# Fast plain transition from top-left-to-bottom-right Fast weak attack to stance1
+	ENUM2STRING(BOTH_R4_BR_S1),	//# Fast plain transition from bottom-right-to-top-left Fast weak attack to stance1
+	ENUM2STRING(BOTH_R4_BL_S1),	//# Fast plain transition from bottom-left-to-top-right Fast weak attack to stance1
+	ENUM2STRING(BOTH_R4_TR_S1),	//# Fast plain transition from top-right-to-bottom-left Fast weak attack
+	//Saber Attack Bounces (first 4 frames of an attack), played backwards)
+	ENUM2STRING(BOTH_B4_BR___),	//# Bounce-back if attack from BR is blocked
+	ENUM2STRING(BOTH_B4__R___),	//# Bounce-back if attack from R is blocked
+	ENUM2STRING(BOTH_B4_TR___),	//# Bounce-back if attack from TR is blocked
+	ENUM2STRING(BOTH_B4_T____),	//# Bounce-back if attack from T is blocked
+	ENUM2STRING(BOTH_B4_TL___),	//# Bounce-back if attack from TL is blocked
+	ENUM2STRING(BOTH_B4__L___),	//# Bounce-back if attack from L is blocked
+	ENUM2STRING(BOTH_B4_BL___),	//# Bounce-back if attack from BL is blocked
+	//Saber Attack Deflections (last 4 frames of an attack)
+	ENUM2STRING(BOTH_D4_BR___),	//# Deflection toward BR
+	ENUM2STRING(BOTH_D4__R___),	//# Deflection toward R
+	ENUM2STRING(BOTH_D4_TR___),	//# Deflection toward TR
+	ENUM2STRING(BOTH_D4_TL___),	//# Deflection toward TL
+	ENUM2STRING(BOTH_D4__L___),	//# Deflection toward L
+	ENUM2STRING(BOTH_D4_BL___),	//# Deflection toward BL
+	ENUM2STRING(BOTH_D4_B____),	//# Deflection toward B
+	//Saber attack anims - power level 5 - Tavion's
+	ENUM2STRING(BOTH_A5_T__B_),	//# Fast weak vertical attack top to bottom
+	ENUM2STRING(BOTH_A5__L__R),	//# Fast weak horizontal attack left to right
+	ENUM2STRING(BOTH_A5__R__L),	//# Fast weak horizontal attack right to left
+	ENUM2STRING(BOTH_A5_TL_BR),	//# Fast weak diagonal attack top left to botom right
+	ENUM2STRING(BOTH_A5_BR_TL),	//# Fast weak diagonal attack top left to botom right
+	ENUM2STRING(BOTH_A5_BL_TR),	//# Fast weak diagonal attack bottom left to top right
+	ENUM2STRING(BOTH_A5_TR_BL),	//# Fast weak diagonal attack bottom left to right
+	//Saber Arc and Spin Transitions
+	ENUM2STRING(BOTH_T5_BR__R),	//# Fast arc bottom right to right
+	ENUM2STRING(BOTH_T5_BR_TL),	//# Fast weak spin bottom right to top left
+	ENUM2STRING(BOTH_T5_BR__L),	//# Fast weak spin bottom right to left
+	ENUM2STRING(BOTH_T5_BR_BL),	//# Fast weak spin bottom right to bottom left
+	ENUM2STRING(BOTH_T5__R_TR),	//# Fast arc right to top right
+	ENUM2STRING(BOTH_T5__R_TL),	//# Fast arc right to top left
+	ENUM2STRING(BOTH_T5__R__L),	//# Fast weak spin right to left
+	ENUM2STRING(BOTH_T5__R_BL),	//# Fast weak spin right to bottom left
+	ENUM2STRING(BOTH_T5_TR_BR),	//# Fast arc top right to bottom right
+	ENUM2STRING(BOTH_T5_TR_TL),	//# Fast arc top right to top left
+	ENUM2STRING(BOTH_T5_TR__L),	//# Fast arc top right to left
+	ENUM2STRING(BOTH_T5_TR_BL),	//# Fast weak spin top right to bottom left
+	ENUM2STRING(BOTH_T5_T__BR),	//# Fast arc top to bottom right
+	ENUM2STRING(BOTH_T5_T___R),	//# Fast arc top to right
+	ENUM2STRING(BOTH_T5_T__TR),	//# Fast arc top to top right
+	ENUM2STRING(BOTH_T5_T__TL),	//# Fast arc top to top left
+	ENUM2STRING(BOTH_T5_T___L),	//# Fast arc top to left
+	ENUM2STRING(BOTH_T5_T__BL),	//# Fast arc top to bottom left
+	ENUM2STRING(BOTH_T5_TL_BR),	//# Fast weak spin top left to bottom right
+	ENUM2STRING(BOTH_T5_TL_BL),	//# Fast arc top left to bottom left
+	ENUM2STRING(BOTH_T5__L_BR),	//# Fast weak spin left to bottom right
+	ENUM2STRING(BOTH_T5__L__R),	//# Fast weak spin left to right
+	ENUM2STRING(BOTH_T5__L_TL),	//# Fast arc left to top left
+	ENUM2STRING(BOTH_T5_BL_BR),	//# Fast weak spin bottom left to bottom right
+	ENUM2STRING(BOTH_T5_BL__R),	//# Fast weak spin bottom left to right
+	ENUM2STRING(BOTH_T5_BL_TR),	//# Fast weak spin bottom left to top right
+	ENUM2STRING(BOTH_T5_BL__L),	//# Fast arc bottom left to left
+	//Saber Arc Transitions that use existing animations played backwards
+	ENUM2STRING(BOTH_T5_BR_TR),	//# Fast arc bottom right to top right		(use: ENUM2STRING(BOTH_T5_TR_BR)
+	ENUM2STRING(BOTH_T5_BR_T_),	//# Fast arc bottom right to top			(use: ENUM2STRING(BOTH_T5_T__BR)
+	ENUM2STRING(BOTH_T5__R_BR),	//# Fast arc right to bottom right			(use: ENUM2STRING(BOTH_T5_BR__R)
+	ENUM2STRING(BOTH_T5__R_T_),	//# Fast ar right to top				(use: ENUM2STRING(BOTH_T5_T___R)
+	ENUM2STRING(BOTH_T5_TR__R),	//# Fast arc top right to right			(use: ENUM2STRING(BOTH_T5__R_TR)
+	ENUM2STRING(BOTH_T5_TR_T_),	//# Fast arc top right to top				(use: ENUM2STRING(BOTH_T5_T__TR)
+	ENUM2STRING(BOTH_T5_TL__R),	//# Fast arc top left to right			(use: ENUM2STRING(BOTH_T5__R_TL)
+	ENUM2STRING(BOTH_T5_TL_TR),	//# Fast arc top left to top right			(use: ENUM2STRING(BOTH_T5_TR_TL)
+	ENUM2STRING(BOTH_T5_TL_T_),	//# Fast arc top left to top				(use: ENUM2STRING(BOTH_T5_T__TL)
+	ENUM2STRING(BOTH_T5_TL__L),	//# Fast arc top left to left				(use: ENUM2STRING(BOTH_T5__L_TL)
+	ENUM2STRING(BOTH_T5__L_TR),	//# Fast arc left to top right			(use: ENUM2STRING(BOTH_T5_TR__L)
+	ENUM2STRING(BOTH_T5__L_T_),	//# Fast arc left to top				(use: ENUM2STRING(BOTH_T5_T___L)
+	ENUM2STRING(BOTH_T5__L_BL),	//# Fast arc left to bottom left			(use: ENUM2STRING(BOTH_T5_BL__L)
+	ENUM2STRING(BOTH_T5_BL_T_),	//# Fast arc bottom left to top			(use: ENUM2STRING(BOTH_T5_T__BL)
+	ENUM2STRING(BOTH_T5_BL_TL),	//# Fast arc bottom left to top left		(use: ENUM2STRING(BOTH_T5_TL_BL)
+	//Saber Attack Start Transitions
+	ENUM2STRING(BOTH_S5_S1_T_),	//# Fast plain transition from stance1 to top-to-bottom Fast weak attack
+	ENUM2STRING(BOTH_S5_S1__L),	//# Fast plain transition from stance1 to left-to-right Fast weak attack
+	ENUM2STRING(BOTH_S5_S1__R),	//# Fast plain transition from stance1 to right-to-left Fast weak attack
+	ENUM2STRING(BOTH_S5_S1_TL),	//# Fast plain transition from stance1 to top-left-to-bottom-right Fast weak attack
+	ENUM2STRING(BOTH_S5_S1_BR),	//# Fast plain transition from stance1 to bottom-right-to-top-left Fast weak attack
+	ENUM2STRING(BOTH_S5_S1_BL),	//# Fast plain transition from stance1 to bottom-left-to-top-right Fast weak attack
+	ENUM2STRING(BOTH_S5_S1_TR),	//# Fast plain transition from stance1 to top-right-to-bottom-left Fast weak attack
+	//Saber Attack Return Transitions
+	ENUM2STRING(BOTH_R5_B__S1),	//# Fast plain transition from top-to-bottom Fast weak attack to stance1
+	ENUM2STRING(BOTH_R5__L_S1),	//# Fast plain transition from left-to-right Fast weak attack to stance1
+	ENUM2STRING(BOTH_R5__R_S1),	//# Fast plain transition from right-to-left Fast weak attack to stance1
+	ENUM2STRING(BOTH_R5_TL_S1),	//# Fast plain transition from top-left-to-bottom-right Fast weak attack to stance1
+	ENUM2STRING(BOTH_R5_BR_S1),	//# Fast plain transition from bottom-right-to-top-left Fast weak attack to stance1
+	ENUM2STRING(BOTH_R5_BL_S1),	//# Fast plain transition from bottom-left-to-top-right Fast weak attack to stance1
+	ENUM2STRING(BOTH_R5_TR_S1),	//# Fast plain transition from top-right-to-bottom-left Fast weak attack
+	//Saber Attack Bounces (first 4 frames of an attack), played backwards)
+	ENUM2STRING(BOTH_B5_BR___),	//# Bounce-back if attack from BR is blocked
+	ENUM2STRING(BOTH_B5__R___),	//# Bounce-back if attack from R is blocked
+	ENUM2STRING(BOTH_B5_TR___),	//# Bounce-back if attack from TR is blocked
+	ENUM2STRING(BOTH_B5_T____),	//# Bounce-back if attack from T is blocked
+	ENUM2STRING(BOTH_B5_TL___),	//# Bounce-back if attack from TL is blocked
+	ENUM2STRING(BOTH_B5__L___),	//# Bounce-back if attack from L is blocked
+	ENUM2STRING(BOTH_B5_BL___),	//# Bounce-back if attack from BL is blocked
+	//Saber Attack Deflections (last 4 frames of an attack)
+	ENUM2STRING(BOTH_D5_BR___),	//# Deflection toward BR
+	ENUM2STRING(BOTH_D5__R___),	//# Deflection toward R
+	ENUM2STRING(BOTH_D5_TR___),	//# Deflection toward TR
+	ENUM2STRING(BOTH_D5_TL___),	//# Deflection toward TL
+	ENUM2STRING(BOTH_D5__L___),	//# Deflection toward L
+	ENUM2STRING(BOTH_D5_BL___),	//# Deflection toward BL
+	ENUM2STRING(BOTH_D5_B____),	//# Deflection toward B
+	//Saber attack anims - power level 6
+	ENUM2STRING(BOTH_A6_T__B_),	//# Fast weak vertical attack top to bottom
+	ENUM2STRING(BOTH_A6__L__R),	//# Fast weak horizontal attack left to right
+	ENUM2STRING(BOTH_A6__R__L),	//# Fast weak horizontal attack right to left
+	ENUM2STRING(BOTH_A6_TL_BR),	//# Fast weak diagonal attack top left to botom right
+	ENUM2STRING(BOTH_A6_BR_TL),	//# Fast weak diagonal attack top left to botom right
+	ENUM2STRING(BOTH_A6_BL_TR),	//# Fast weak diagonal attack bottom left to top right
+	ENUM2STRING(BOTH_A6_TR_BL),	//# Fast weak diagonal attack bottom left to right
+	//Saber Arc and Spin Transitions
+	ENUM2STRING(BOTH_T6_BR__R),	//# Fast arc bottom right to right
+	ENUM2STRING(BOTH_T6_BR_TL),	//# Fast weak spin bottom right to top left
+	ENUM2STRING(BOTH_T6_BR__L),	//# Fast weak spin bottom right to left
+	ENUM2STRING(BOTH_T6_BR_BL),	//# Fast weak spin bottom right to bottom left
+	ENUM2STRING(BOTH_T6__R_TR),	//# Fast arc right to top right
+	ENUM2STRING(BOTH_T6__R_TL),	//# Fast arc right to top left
+	ENUM2STRING(BOTH_T6__R__L),	//# Fast weak spin right to left
+	ENUM2STRING(BOTH_T6__R_BL),	//# Fast weak spin right to bottom left
+	ENUM2STRING(BOTH_T6_TR_BR),	//# Fast arc top right to bottom right
+	ENUM2STRING(BOTH_T6_TR_TL),	//# Fast arc top right to top left
+	ENUM2STRING(BOTH_T6_TR__L),	//# Fast arc top right to left
+	ENUM2STRING(BOTH_T6_TR_BL),	//# Fast weak spin top right to bottom left
+	ENUM2STRING(BOTH_T6_T__BR),	//# Fast arc top to bottom right
+	ENUM2STRING(BOTH_T6_T___R),	//# Fast arc top to right
+	ENUM2STRING(BOTH_T6_T__TR),	//# Fast arc top to top right
+	ENUM2STRING(BOTH_T6_T__TL),	//# Fast arc top to top left
+	ENUM2STRING(BOTH_T6_T___L),	//# Fast arc top to left
+	ENUM2STRING(BOTH_T6_T__BL),	//# Fast arc top to bottom left
+	ENUM2STRING(BOTH_T6_TL_BR),	//# Fast weak spin top left to bottom right
+	ENUM2STRING(BOTH_T6_TL_BL),	//# Fast arc top left to bottom left
+	ENUM2STRING(BOTH_T6__L_BR),	//# Fast weak spin left to bottom right
+	ENUM2STRING(BOTH_T6__L__R),	//# Fast weak spin left to right
+	ENUM2STRING(BOTH_T6__L_TL),	//# Fast arc left to top left
+	ENUM2STRING(BOTH_T6_BL_BR),	//# Fast weak spin bottom left to bottom right
+	ENUM2STRING(BOTH_T6_BL__R),	//# Fast weak spin bottom left to right
+	ENUM2STRING(BOTH_T6_BL_TR),	//# Fast weak spin bottom left to top right
+	ENUM2STRING(BOTH_T6_BL__L),	//# Fast arc bottom left to left
+	//Saber Arc Transitions that use existing animations played backwards
+	ENUM2STRING(BOTH_T6_BR_TR),	//# Fast arc bottom right to top right		(use: ENUM2STRING(BOTH_T6_TR_BR)
+	ENUM2STRING(BOTH_T6_BR_T_),	//# Fast arc bottom right to top			(use: ENUM2STRING(BOTH_T6_T__BR)
+	ENUM2STRING(BOTH_T6__R_BR),	//# Fast arc right to bottom right			(use: ENUM2STRING(BOTH_T6_BR__R)
+	ENUM2STRING(BOTH_T6__R_T_),	//# Fast ar right to top				(use: ENUM2STRING(BOTH_T6_T___R)
+	ENUM2STRING(BOTH_T6_TR__R),	//# Fast arc top right to right			(use: ENUM2STRING(BOTH_T6__R_TR)
+	ENUM2STRING(BOTH_T6_TR_T_),	//# Fast arc top right to top				(use: ENUM2STRING(BOTH_T6_T__TR)
+	ENUM2STRING(BOTH_T6_TL__R),	//# Fast arc top left to right			(use: ENUM2STRING(BOTH_T6__R_TL)
+	ENUM2STRING(BOTH_T6_TL_TR),	//# Fast arc top left to top right			(use: ENUM2STRING(BOTH_T6_TR_TL)
+	ENUM2STRING(BOTH_T6_TL_T_),	//# Fast arc top left to top				(use: ENUM2STRING(BOTH_T6_T__TL)
+	ENUM2STRING(BOTH_T6_TL__L),	//# Fast arc top left to left				(use: ENUM2STRING(BOTH_T6__L_TL)
+	ENUM2STRING(BOTH_T6__L_TR),	//# Fast arc left to top right			(use: ENUM2STRING(BOTH_T6_TR__L)
+	ENUM2STRING(BOTH_T6__L_T_),	//# Fast arc left to top				(use: ENUM2STRING(BOTH_T6_T___L)
+	ENUM2STRING(BOTH_T6__L_BL),	//# Fast arc left to bottom left			(use: ENUM2STRING(BOTH_T6_BL__L)
+	ENUM2STRING(BOTH_T6_BL_T_),	//# Fast arc bottom left to top			(use: ENUM2STRING(BOTH_T6_T__BL)
+	ENUM2STRING(BOTH_T6_BL_TL),	//# Fast arc bottom left to top left		(use: ENUM2STRING(BOTH_T6_TL_BL)
+	//Saber Attack Start Transitions
+	ENUM2STRING(BOTH_S6_S6_T_),	//# Fast plain transition from stance1 to top-to-bottom Fast weak attack
+	ENUM2STRING(BOTH_S6_S6__L),	//# Fast plain transition from stance1 to left-to-right Fast weak attack
+	ENUM2STRING(BOTH_S6_S6__R),	//# Fast plain transition from stance1 to right-to-left Fast weak attack
+	ENUM2STRING(BOTH_S6_S6_TL),	//# Fast plain transition from stance1 to top-left-to-bottom-right Fast weak attack
+	ENUM2STRING(BOTH_S6_S6_BR),	//# Fast plain transition from stance1 to bottom-right-to-top-left Fast weak attack
+	ENUM2STRING(BOTH_S6_S6_BL),	//# Fast plain transition from stance1 to bottom-left-to-top-right Fast weak attack
+	ENUM2STRING(BOTH_S6_S6_TR),	//# Fast plain transition from stance1 to top-right-to-bottom-left Fast weak attack
+	//Saber Attack Return Transitions
+	ENUM2STRING(BOTH_R6_B__S6),	//# Fast plain transition from top-to-bottom Fast weak attack to stance1
+	ENUM2STRING(BOTH_R6__L_S6),	//# Fast plain transition from left-to-right Fast weak attack to stance1
+	ENUM2STRING(BOTH_R6__R_S6),	//# Fast plain transition from right-to-left Fast weak attack to stance1
+	ENUM2STRING(BOTH_R6_TL_S6),	//# Fast plain transition from top-left-to-bottom-right Fast weak attack to stance1
+	ENUM2STRING(BOTH_R6_BR_S6),	//# Fast plain transition from bottom-right-to-top-left Fast weak attack to stance1
+	ENUM2STRING(BOTH_R6_BL_S6),	//# Fast plain transition from bottom-left-to-top-right Fast weak attack to stance1
+	ENUM2STRING(BOTH_R6_TR_S6),	//# Fast plain transition from top-right-to-bottom-left Fast weak attack
+	//Saber Attack Bounces (first 4 frames of an attack), played backwards)
+	ENUM2STRING(BOTH_B6_BR___),	//# Bounce-back if attack from BR is blocked
+	ENUM2STRING(BOTH_B6__R___),	//# Bounce-back if attack from R is blocked
+	ENUM2STRING(BOTH_B6_TR___),	//# Bounce-back if attack from TR is blocked
+	ENUM2STRING(BOTH_B6_T____),	//# Bounce-back if attack from T is blocked
+	ENUM2STRING(BOTH_B6_TL___),	//# Bounce-back if attack from TL is blocked
+	ENUM2STRING(BOTH_B6__L___),	//# Bounce-back if attack from L is blocked
+	ENUM2STRING(BOTH_B6_BL___),	//# Bounce-back if attack from BL is blocked
+	//Saber Attack Deflections (last 4 frames of an attack)
+	ENUM2STRING(BOTH_D6_BR___),	//# Deflection toward BR
+	ENUM2STRING(BOTH_D6__R___),	//# Deflection toward R
+	ENUM2STRING(BOTH_D6_TR___),	//# Deflection toward TR
+	ENUM2STRING(BOTH_D6_TL___),	//# Deflection toward TL
+	ENUM2STRING(BOTH_D6__L___),	//# Deflection toward L
+	ENUM2STRING(BOTH_D6_BL___),	//# Deflection toward BL
+	ENUM2STRING(BOTH_D6_B____),	//# Deflection toward B
+	//Saber attack anims - power level 7
+	ENUM2STRING(BOTH_A7_T__B_),	//# Fast weak vertical attack top to bottom
+	ENUM2STRING(BOTH_A7__L__R),	//# Fast weak horizontal attack left to right
+	ENUM2STRING(BOTH_A7__R__L),	//# Fast weak horizontal attack right to left
+	ENUM2STRING(BOTH_A7_TL_BR),	//# Fast weak diagonal attack top left to botom right
+	ENUM2STRING(BOTH_A7_BR_TL),	//# Fast weak diagonal attack top left to botom right
+	ENUM2STRING(BOTH_A7_BL_TR),	//# Fast weak diagonal attack bottom left to top right
+	ENUM2STRING(BOTH_A7_TR_BL),	//# Fast weak diagonal attack bottom left to right
+	//Saber Arc and Spin Transitions
+	ENUM2STRING(BOTH_T7_BR__R),	//# Fast arc bottom right to right
+	ENUM2STRING(BOTH_T7_BR_TL),	//# Fast weak spin bottom right to top left
+	ENUM2STRING(BOTH_T7_BR__L),	//# Fast weak spin bottom right to left
+	ENUM2STRING(BOTH_T7_BR_BL),	//# Fast weak spin bottom right to bottom left
+	ENUM2STRING(BOTH_T7__R_TR),	//# Fast arc right to top right
+	ENUM2STRING(BOTH_T7__R_TL),	//# Fast arc right to top left
+	ENUM2STRING(BOTH_T7__R__L),	//# Fast weak spin right to left
+	ENUM2STRING(BOTH_T7__R_BL),	//# Fast weak spin right to bottom left
+	ENUM2STRING(BOTH_T7_TR_BR),	//# Fast arc top right to bottom right
+	ENUM2STRING(BOTH_T7_TR_TL),	//# Fast arc top right to top left
+	ENUM2STRING(BOTH_T7_TR__L),	//# Fast arc top right to left
+	ENUM2STRING(BOTH_T7_TR_BL),	//# Fast weak spin top right to bottom left
+	ENUM2STRING(BOTH_T7_T__BR),	//# Fast arc top to bottom right
+	ENUM2STRING(BOTH_T7_T___R),	//# Fast arc top to right
+	ENUM2STRING(BOTH_T7_T__TR),	//# Fast arc top to top right
+	ENUM2STRING(BOTH_T7_T__TL),	//# Fast arc top to top left
+	ENUM2STRING(BOTH_T7_T___L),	//# Fast arc top to left
+	ENUM2STRING(BOTH_T7_T__BL),	//# Fast arc top to bottom left
+	ENUM2STRING(BOTH_T7_TL_BR),	//# Fast weak spin top left to bottom right
+	ENUM2STRING(BOTH_T7_TL_BL),	//# Fast arc top left to bottom left
+	ENUM2STRING(BOTH_T7__L_BR),	//# Fast weak spin left to bottom right
+	ENUM2STRING(BOTH_T7__L__R),	//# Fast weak spin left to right
+	ENUM2STRING(BOTH_T7__L_TL),	//# Fast arc left to top left
+	ENUM2STRING(BOTH_T7_BL_BR),	//# Fast weak spin bottom left to bottom right
+	ENUM2STRING(BOTH_T7_BL__R),	//# Fast weak spin bottom left to right
+	ENUM2STRING(BOTH_T7_BL_TR),	//# Fast weak spin bottom left to top right
+	ENUM2STRING(BOTH_T7_BL__L),	//# Fast arc bottom left to left
+	//Saber Arc Transitions that use existing animations played backwards
+	ENUM2STRING(BOTH_T7_BR_TR),	//# Fast arc bottom right to top right		(use: ENUM2STRING(BOTH_T7_TR_BR)
+	ENUM2STRING(BOTH_T7_BR_T_),	//# Fast arc bottom right to top			(use: ENUM2STRING(BOTH_T7_T__BR)
+	ENUM2STRING(BOTH_T7__R_BR),	//# Fast arc right to bottom right			(use: ENUM2STRING(BOTH_T7_BR__R)
+	ENUM2STRING(BOTH_T7__R_T_),	//# Fast ar right to top				(use: ENUM2STRING(BOTH_T7_T___R)
+	ENUM2STRING(BOTH_T7_TR__R),	//# Fast arc top right to right			(use: ENUM2STRING(BOTH_T7__R_TR)
+	ENUM2STRING(BOTH_T7_TR_T_),	//# Fast arc top right to top				(use: ENUM2STRING(BOTH_T7_T__TR)
+	ENUM2STRING(BOTH_T7_TL__R),	//# Fast arc top left to right			(use: ENUM2STRING(BOTH_T7__R_TL)
+	ENUM2STRING(BOTH_T7_TL_TR),	//# Fast arc top left to top right			(use: ENUM2STRING(BOTH_T7_TR_TL)
+	ENUM2STRING(BOTH_T7_TL_T_),	//# Fast arc top left to top				(use: ENUM2STRING(BOTH_T7_T__TL)
+	ENUM2STRING(BOTH_T7_TL__L),	//# Fast arc top left to left				(use: ENUM2STRING(BOTH_T7__L_TL)
+	ENUM2STRING(BOTH_T7__L_TR),	//# Fast arc left to top right			(use: ENUM2STRING(BOTH_T7_TR__L)
+	ENUM2STRING(BOTH_T7__L_T_),	//# Fast arc left to top				(use: ENUM2STRING(BOTH_T7_T___L)
+	ENUM2STRING(BOTH_T7__L_BL),	//# Fast arc left to bottom left			(use: ENUM2STRING(BOTH_T7_BL__L)
+	ENUM2STRING(BOTH_T7_BL_T_),	//# Fast arc bottom left to top			(use: ENUM2STRING(BOTH_T7_T__BL)
+	ENUM2STRING(BOTH_T7_BL_TL),	//# Fast arc bottom left to top left		(use: ENUM2STRING(BOTH_T7_TL_BL)
+	//Saber Attack Start Transitions
+	ENUM2STRING(BOTH_S7_S7_T_),	//# Fast plain transition from stance1 to top-to-bottom Fast weak attack
+	ENUM2STRING(BOTH_S7_S7__L),	//# Fast plain transition from stance1 to left-to-right Fast weak attack
+	ENUM2STRING(BOTH_S7_S7__R),	//# Fast plain transition from stance1 to right-to-left Fast weak attack
+	ENUM2STRING(BOTH_S7_S7_TL),	//# Fast plain transition from stance1 to top-left-to-bottom-right Fast weak attack
+	ENUM2STRING(BOTH_S7_S7_BR),	//# Fast plain transition from stance1 to bottom-right-to-top-left Fast weak attack
+	ENUM2STRING(BOTH_S7_S7_BL),	//# Fast plain transition from stance1 to bottom-left-to-top-right Fast weak attack
+	ENUM2STRING(BOTH_S7_S7_TR),	//# Fast plain transition from stance1 to top-right-to-bottom-left Fast weak attack
+	//Saber Attack Return Transitions
+	ENUM2STRING(BOTH_R7_B__S7),	//# Fast plain transition from top-to-bottom Fast weak attack to stance1
+	ENUM2STRING(BOTH_R7__L_S7),	//# Fast plain transition from left-to-right Fast weak attack to stance1
+	ENUM2STRING(BOTH_R7__R_S7),	//# Fast plain transition from right-to-left Fast weak attack to stance1
+	ENUM2STRING(BOTH_R7_TL_S7),	//# Fast plain transition from top-left-to-bottom-right Fast weak attack to stance1
+	ENUM2STRING(BOTH_R7_BR_S7),	//# Fast plain transition from bottom-right-to-top-left Fast weak attack to stance1
+	ENUM2STRING(BOTH_R7_BL_S7),	//# Fast plain transition from bottom-left-to-top-right Fast weak attack to stance1
+	ENUM2STRING(BOTH_R7_TR_S7),	//# Fast plain transition from top-right-to-bottom-left Fast weak attack
+	//Saber Attack Bounces (first 4 frames of an attack), played backwards)
+	ENUM2STRING(BOTH_B7_BR___),	//# Bounce-back if attack from BR is blocked
+	ENUM2STRING(BOTH_B7__R___),	//# Bounce-back if attack from R is blocked
+	ENUM2STRING(BOTH_B7_TR___),	//# Bounce-back if attack from TR is blocked
+	ENUM2STRING(BOTH_B7_T____),	//# Bounce-back if attack from T is blocked
+	ENUM2STRING(BOTH_B7_TL___),	//# Bounce-back if attack from TL is blocked
+	ENUM2STRING(BOTH_B7__L___),	//# Bounce-back if attack from L is blocked
+	ENUM2STRING(BOTH_B7_BL___),	//# Bounce-back if attack from BL is blocked
+	//Saber Attack Deflections (last 4 frames of an attack)
+	ENUM2STRING(BOTH_D7_BR___),	//# Deflection toward BR
+	ENUM2STRING(BOTH_D7__R___),	//# Deflection toward R
+	ENUM2STRING(BOTH_D7_TR___),	//# Deflection toward TR
+	ENUM2STRING(BOTH_D7_TL___),	//# Deflection toward TL
+	ENUM2STRING(BOTH_D7__L___),	//# Deflection toward L
+	ENUM2STRING(BOTH_D7_BL___),	//# Deflection toward BL
+	ENUM2STRING(BOTH_D7_B____),	//# Deflection toward B
+	//Saber parry anims
+	ENUM2STRING(BOTH_P1_S1_T_),	//# Block shot/saber top
+	ENUM2STRING(BOTH_P1_S1_TR),	//# Block shot/saber top right
+	ENUM2STRING(BOTH_P1_S1_TL),	//# Block shot/saber top left
+	ENUM2STRING(BOTH_P1_S1_BL),	//# Block shot/saber bottom left
+	ENUM2STRING(BOTH_P1_S1_BR),	//# Block shot/saber bottom right
+	//Saber knockaway
+	ENUM2STRING(BOTH_K1_S1_T_),	//# knockaway saber top
+	ENUM2STRING(BOTH_K1_S1_TR),	//# knockaway saber top right
+	ENUM2STRING(BOTH_K1_S1_TL),	//# knockaway saber top left
+	ENUM2STRING(BOTH_K1_S1_BL),	//# knockaway saber bottom left
+	ENUM2STRING(BOTH_K1_S1_B_),	//# knockaway saber bottom
+	ENUM2STRING(BOTH_K1_S1_BR),	//# knockaway saber bottom right
+	//Saber attack knocked away
+	ENUM2STRING(BOTH_V1_BR_S1),	//# BR attack knocked away
+	ENUM2STRING(BOTH_V1__R_S1),	//# R attack knocked away
+	ENUM2STRING(BOTH_V1_TR_S1),	//# TR attack knocked away
+	ENUM2STRING(BOTH_V1_T__S1),	//# T attack knocked away
+	ENUM2STRING(BOTH_V1_TL_S1),	//# TL attack knocked away
+	ENUM2STRING(BOTH_V1__L_S1),	//# L attack knocked away
+	ENUM2STRING(BOTH_V1_BL_S1),	//# BL attack knocked away
+	ENUM2STRING(BOTH_V1_B__S1),	//# B attack knocked away
+	//Saber parry broken
+	ENUM2STRING(BOTH_H1_S1_T_),	//# saber knocked down from top parry
+	ENUM2STRING(BOTH_H1_S1_TR),	//# saber knocked down-left from TR parry
+	ENUM2STRING(BOTH_H1_S1_TL),	//# saber knocked down-right from TL parry
+	ENUM2STRING(BOTH_H1_S1_BL),	//# saber knocked up-right from BL parry
+	ENUM2STRING(BOTH_H1_S1_B_),	//# saber knocked up over head from ready?
+	ENUM2STRING(BOTH_H1_S1_BR),	//# saber knocked up-left from BR parry
+	//Dual Sabers parry anims
+	ENUM2STRING(BOTH_P6_S6_T_),	//# Block shot/saber top
+	ENUM2STRING(BOTH_P6_S6_TR),	//# Block shot/saber top right
+	ENUM2STRING(BOTH_P6_S6_TL),	//# Block shot/saber top left
+	ENUM2STRING(BOTH_P6_S6_BL),	//# Block shot/saber bottom left
+	ENUM2STRING(BOTH_P6_S6_BR),	//# Block shot/saber bottom right
+	//Dual Sabers knockaway
+	ENUM2STRING(BOTH_K6_S6_T_),	//# knockaway saber top
+	ENUM2STRING(BOTH_K6_S6_TR),	//# knockaway saber top right
+	ENUM2STRING(BOTH_K6_S6_TL),	//# knockaway saber top left
+	ENUM2STRING(BOTH_K6_S6_BL),	//# knockaway saber bottom left
+	ENUM2STRING(BOTH_K6_S6_B_),	//# knockaway saber bottom
+	ENUM2STRING(BOTH_K6_S6_BR),	//# knockaway saber bottom right
+	//Dual Sabers attack knocked away
+	ENUM2STRING(BOTH_V6_BR_S6),	//# BR attack knocked away
+	ENUM2STRING(BOTH_V6__R_S6),	//# R attack knocked away
+	ENUM2STRING(BOTH_V6_TR_S6),	//# TR attack knocked away
+	ENUM2STRING(BOTH_V6_T__S6),	//# T attack knocked away
+	ENUM2STRING(BOTH_V6_TL_S6),	//# TL attack knocked away
+	ENUM2STRING(BOTH_V6__L_S6),	//# L attack knocked away
+	ENUM2STRING(BOTH_V6_BL_S6),	//# BL attack knocked away
+	ENUM2STRING(BOTH_V6_B__S6),	//# B attack knocked away
+	//Dual Sabers parry broken
+	ENUM2STRING(BOTH_H6_S6_T_),	//# saber knocked down from top parry
+	ENUM2STRING(BOTH_H6_S6_TR),	//# saber knocked down-left from TR parry
+	ENUM2STRING(BOTH_H6_S6_TL),	//# saber knocked down-right from TL parry
+	ENUM2STRING(BOTH_H6_S6_BL),	//# saber knocked up-right from BL parry
+	ENUM2STRING(BOTH_H6_S6_B_),	//# saber knocked up over head from ready?
+	ENUM2STRING(BOTH_H6_S6_BR),	//# saber knocked up-left from BR parry
+	//SaberStaff parry anims
+	ENUM2STRING(BOTH_P7_S7_T_),	//# Block shot/saber top
+	ENUM2STRING(BOTH_P7_S7_TR),	//# Block shot/saber top right
+	ENUM2STRING(BOTH_P7_S7_TL),	//# Block shot/saber top left
+	ENUM2STRING(BOTH_P7_S7_BL),	//# Block shot/saber bottom left
+	ENUM2STRING(BOTH_P7_S7_BR),	//# Block shot/saber bottom right
+	//SaberStaff knockaway
+	ENUM2STRING(BOTH_K7_S7_T_),	//# knockaway saber top
+	ENUM2STRING(BOTH_K7_S7_TR),	//# knockaway saber top right
+	ENUM2STRING(BOTH_K7_S7_TL),	//# knockaway saber top left
+	ENUM2STRING(BOTH_K7_S7_BL),	//# knockaway saber bottom left
+	ENUM2STRING(BOTH_K7_S7_B_),	//# knockaway saber bottom
+	ENUM2STRING(BOTH_K7_S7_BR),	//# knockaway saber bottom right
+	//SaberStaff attack knocked away
+	ENUM2STRING(BOTH_V7_BR_S7),	//# BR attack knocked away
+	ENUM2STRING(BOTH_V7__R_S7),	//# R attack knocked away
+	ENUM2STRING(BOTH_V7_TR_S7),	//# TR attack knocked away
+	ENUM2STRING(BOTH_V7_T__S7),	//# T attack knocked away
+	ENUM2STRING(BOTH_V7_TL_S7),	//# TL attack knocked away
+	ENUM2STRING(BOTH_V7__L_S7),	//# L attack knocked away
+	ENUM2STRING(BOTH_V7_BL_S7),	//# BL attack knocked away
+	ENUM2STRING(BOTH_V7_B__S7),	//# B attack knocked away
+	//SaberStaff parry broken
+	ENUM2STRING(BOTH_H7_S7_T_),	//# saber knocked down from top parry
+	ENUM2STRING(BOTH_H7_S7_TR),	//# saber knocked down-left from TR parry
+	ENUM2STRING(BOTH_H7_S7_TL),	//# saber knocked down-right from TL parry
+	ENUM2STRING(BOTH_H7_S7_BL),	//# saber knocked up-right from BL parry
+	ENUM2STRING(BOTH_H7_S7_B_),	//# saber knocked up over head from ready?
+	ENUM2STRING(BOTH_H7_S7_BR),	//# saber knocked up-left from BR parry
+	//Sabers locked anims
+	//* #sep BOTH_ SABER LOCKED ANIMS
+	//BOTH_(DL, S, ST)_(DL, S, ST)_(T, S)_(L, B, SB)_1(_W, _L)
+//===Single locks==================================================================
+//SINGLE vs. DUAL
+	//side locks - I'm using a single and they're using dual
+	ENUM2STRING(BOTH_LK_S_DL_S_B_1_L),	//normal break I lost
+	ENUM2STRING(BOTH_LK_S_DL_S_B_1_W),	//normal break I won
+	ENUM2STRING(BOTH_LK_S_DL_S_L_1),		//lock if I'm using single vs. a dual
+	ENUM2STRING(BOTH_LK_S_DL_S_SB_1_L),	//super break I lost
+	ENUM2STRING(BOTH_LK_S_DL_S_SB_1_W),	//super break I won
+	//top locks
+	ENUM2STRING(BOTH_LK_S_DL_T_B_1_L),	//normal break I lost
+	ENUM2STRING(BOTH_LK_S_DL_T_B_1_W),	//normal break I won
+	ENUM2STRING(BOTH_LK_S_DL_T_L_1),		//lock if I'm using single vs. a dual
+	ENUM2STRING(BOTH_LK_S_DL_T_SB_1_L),	//super break I lost
+	ENUM2STRING(BOTH_LK_S_DL_T_SB_1_W),	//super break I won
+//SINGLE vs. STAFF
+	//side locks
+	ENUM2STRING(BOTH_LK_S_ST_S_B_1_L),	//normal break I lost
+	ENUM2STRING(BOTH_LK_S_ST_S_B_1_W),	//normal break I won
+	ENUM2STRING(BOTH_LK_S_ST_S_L_1),		//lock if I'm using single vs. a staff
+	ENUM2STRING(BOTH_LK_S_ST_S_SB_1_L),	//super break I lost
+	ENUM2STRING(BOTH_LK_S_ST_S_SB_1_W),	//super break I won
+	//top locks
+	ENUM2STRING(BOTH_LK_S_ST_T_B_1_L),	//normal break I lost
+	ENUM2STRING(BOTH_LK_S_ST_T_B_1_W),	//normal break I won
+	ENUM2STRING(BOTH_LK_S_ST_T_L_1),		//lock if I'm using single vs. a staff
+	ENUM2STRING(BOTH_LK_S_ST_T_SB_1_L),	//super break I lost
+	ENUM2STRING(BOTH_LK_S_ST_T_SB_1_W),	//super break I won
+//SINGLE vs. SINGLE
+	//side locks
+	ENUM2STRING(BOTH_LK_S_S_S_B_1_L),	//normal break I lost
+	ENUM2STRING(BOTH_LK_S_S_S_B_1_W),	//normal break I won
+	ENUM2STRING(BOTH_LK_S_S_S_L_1),		//lock if I'm using single vs. a single and I initiated
+	ENUM2STRING(BOTH_LK_S_S_S_SB_1_L),	//super break I lost
+	ENUM2STRING(BOTH_LK_S_S_S_SB_1_W),	//super break I won
+	//top locks
+	ENUM2STRING(BOTH_LK_S_S_T_B_1_L),	//normal break I lost
+	ENUM2STRING(BOTH_LK_S_S_T_B_1_W),	//normal break I won
+	ENUM2STRING(BOTH_LK_S_S_T_L_1),		//lock if I'm using single vs. a single and I initiated
+	ENUM2STRING(BOTH_LK_S_S_T_SB_1_L),	//super break I lost
+	ENUM2STRING(BOTH_LK_S_S_T_SB_1_W),	//super break I won
+//===Dual Saber locks==================================================================
+//DUAL vs. DUAL	
+	//side locks
+	ENUM2STRING(BOTH_LK_DL_DL_S_B_1_L),	//normal break I lost
+	ENUM2STRING(BOTH_LK_DL_DL_S_B_1_W),	//normal break I won
+	ENUM2STRING(BOTH_LK_DL_DL_S_L_1),	//lock if I'm using dual vs. dual and I initiated
+	ENUM2STRING(BOTH_LK_DL_DL_S_SB_1_L),	//super break I lost
+	ENUM2STRING(BOTH_LK_DL_DL_S_SB_1_W),	//super break I won
+	//top locks
+	ENUM2STRING(BOTH_LK_DL_DL_T_B_1_L),	//normal break I lost
+	ENUM2STRING(BOTH_LK_DL_DL_T_B_1_W),	//normal break I won
+	ENUM2STRING(BOTH_LK_DL_DL_T_L_1),	//lock if I'm using dual vs. dual and I initiated
+	ENUM2STRING(BOTH_LK_DL_DL_T_SB_1_L),	//super break I lost
+	ENUM2STRING(BOTH_LK_DL_DL_T_SB_1_W),	//super break I won
+//DUAL vs. STAFF
+	//side locks
+	ENUM2STRING(BOTH_LK_DL_ST_S_B_1_L),	//normal break I lost
+	ENUM2STRING(BOTH_LK_DL_ST_S_B_1_W),	//normal break I won
+	ENUM2STRING(BOTH_LK_DL_ST_S_L_1),	//lock if I'm using dual vs. a staff
+	ENUM2STRING(BOTH_LK_DL_ST_S_SB_1_L),	//super break I lost
+	ENUM2STRING(BOTH_LK_DL_ST_S_SB_1_W),	//super break I won
+	//top locks
+	ENUM2STRING(BOTH_LK_DL_ST_T_B_1_L),	//normal break I lost
+	ENUM2STRING(BOTH_LK_DL_ST_T_B_1_W),	//normal break I won
+	ENUM2STRING(BOTH_LK_DL_ST_T_L_1),	//lock if I'm using dual vs. a staff
+	ENUM2STRING(BOTH_LK_DL_ST_T_SB_1_L),	//super break I lost
+	ENUM2STRING(BOTH_LK_DL_ST_T_SB_1_W),	//super break I won
+//DUAL vs. SINGLE
+	//side locks
+	ENUM2STRING(BOTH_LK_DL_S_S_B_1_L),	//normal break I lost
+	ENUM2STRING(BOTH_LK_DL_S_S_B_1_W),	//normal break I won
+	ENUM2STRING(BOTH_LK_DL_S_S_L_1),		//lock if I'm using dual vs. a single
+	ENUM2STRING(BOTH_LK_DL_S_S_SB_1_L),	//super break I lost
+	ENUM2STRING(BOTH_LK_DL_S_S_SB_1_W),	//super break I won
+	//top locks
+	ENUM2STRING(BOTH_LK_DL_S_T_B_1_L),	//normal break I lost
+	ENUM2STRING(BOTH_LK_DL_S_T_B_1_W),	//normal break I won
+	ENUM2STRING(BOTH_LK_DL_S_T_L_1),		//lock if I'm using dual vs. a single
+	ENUM2STRING(BOTH_LK_DL_S_T_SB_1_L),	//super break I lost
+	ENUM2STRING(BOTH_LK_DL_S_T_SB_1_W),	//super break I won
+//===Saber Staff locks==================================================================
+//STAFF vs. DUAL
+	//side locks
+	ENUM2STRING(BOTH_LK_ST_DL_S_B_1_L),	//normal break I lost
+	ENUM2STRING(BOTH_LK_ST_DL_S_B_1_W),	//normal break I won
+	ENUM2STRING(BOTH_LK_ST_DL_S_L_1),	//lock if I'm using staff vs. dual
+	ENUM2STRING(BOTH_LK_ST_DL_S_SB_1_L),	//super break I lost
+	ENUM2STRING(BOTH_LK_ST_DL_S_SB_1_W),	//super break I won
+	//top locks
+	ENUM2STRING(BOTH_LK_ST_DL_T_B_1_L),	//normal break I lost
+	ENUM2STRING(BOTH_LK_ST_DL_T_B_1_W),	//normal break I won
+	ENUM2STRING(BOTH_LK_ST_DL_T_L_1),	//lock if I'm using staff vs. dual
+	ENUM2STRING(BOTH_LK_ST_DL_T_SB_1_L),	//super break I lost
+	ENUM2STRING(BOTH_LK_ST_DL_T_SB_1_W),	//super break I won
+//STAFF vs. STAFF
+	//side locks
+	ENUM2STRING(BOTH_LK_ST_ST_S_B_1_L),	//normal break I lost
+	ENUM2STRING(BOTH_LK_ST_ST_S_B_1_W),	//normal break I won
+	ENUM2STRING(BOTH_LK_ST_ST_S_L_1),	//lock if I'm using staff vs. a staff and I initiated
+	ENUM2STRING(BOTH_LK_ST_ST_S_SB_1_L),	//super break I lost
+	ENUM2STRING(BOTH_LK_ST_ST_S_SB_1_W),	//super break I won
+	//top locks
+	ENUM2STRING(BOTH_LK_ST_ST_T_B_1_L),	//normal break I lost
+	ENUM2STRING(BOTH_LK_ST_ST_T_B_1_W),	//normal break I won
+	ENUM2STRING(BOTH_LK_ST_ST_T_L_1),	//lock if I'm using staff vs. a staff and I initiated
+	ENUM2STRING(BOTH_LK_ST_ST_T_SB_1_L),	//super break I lost
+	ENUM2STRING(BOTH_LK_ST_ST_T_SB_1_W),	//super break I won
+//STAFF vs. SINGLE
+	//side locks
+	ENUM2STRING(BOTH_LK_ST_S_S_B_1_L),	//normal break I lost
+	ENUM2STRING(BOTH_LK_ST_S_S_B_1_W),	//normal break I won
+	ENUM2STRING(BOTH_LK_ST_S_S_L_1),		//lock if I'm using staff vs. a single
+	ENUM2STRING(BOTH_LK_ST_S_S_SB_1_L),	//super break I lost
+	ENUM2STRING(BOTH_LK_ST_S_S_SB_1_W),	//super break I won
+	//top locks
+	ENUM2STRING(BOTH_LK_ST_S_T_B_1_L),	//normal break I lost
+	ENUM2STRING(BOTH_LK_ST_S_T_B_1_W),	//normal break I won
+	ENUM2STRING(BOTH_LK_ST_S_T_L_1),		//lock if I'm using staff vs. a single
+	ENUM2STRING(BOTH_LK_ST_S_T_SB_1_L),	//super break I lost
+	ENUM2STRING(BOTH_LK_ST_S_T_SB_1_W),	//super break I won
+//Special cases for same saber style vs. each other (won't fit in nice 5-anim size lists above)
+	ENUM2STRING(BOTH_LK_S_S_S_L_2),		//lock if I'm using single vs. a single and other intitiated
+	ENUM2STRING(BOTH_LK_S_S_T_L_2),		//lock if I'm using single vs. a single and other initiated
+	ENUM2STRING(BOTH_LK_DL_DL_S_L_2),	//lock if I'm using dual vs. dual and other initiated
+	ENUM2STRING(BOTH_LK_DL_DL_T_L_2),	//lock if I'm using dual vs. dual and other initiated
+	ENUM2STRING(BOTH_LK_ST_ST_S_L_2),	//lock if I'm using staff vs. a staff and other initiated
+	ENUM2STRING(BOTH_LK_ST_ST_T_L_2),	//lock if I'm using staff vs. a staff and other initiated
+//===End Saber locks==================================================================
+	ENUM2STRING(BOTH_BF2RETURN),	//#
+	ENUM2STRING(BOTH_BF2BREAK),	//#
+	ENUM2STRING(BOTH_BF2LOCK),	//#
+	ENUM2STRING(BOTH_BF1RETURN),	//#
+	ENUM2STRING(BOTH_BF1BREAK),	//#
+	ENUM2STRING(BOTH_BF1LOCK),	//#
+	ENUM2STRING(BOTH_CWCIRCLE_R2__R_S1),	//#
+	ENUM2STRING(BOTH_CCWCIRCLE_R2__L_S1),	//#
+	ENUM2STRING(BOTH_CWCIRCLE_A2__L__R),	//#
+	ENUM2STRING(BOTH_CCWCIRCLE_A2__R__L),	//#
+	ENUM2STRING(BOTH_CWCIRCLEBREAK),	//#
+	ENUM2STRING(BOTH_CCWCIRCLEBREAK),	//#
+	ENUM2STRING(BOTH_CWCIRCLELOCK),	//#
+	ENUM2STRING(BOTH_CCWCIRCLELOCK),	//#
+	//other saber anims/attacks
+	ENUM2STRING(BOTH_SABERFAST_STANCE),
+	ENUM2STRING(BOTH_SABERSLOW_STANCE),
+	ENUM2STRING(BOTH_SABERDUAL_STANCE),
+	ENUM2STRING(BOTH_SABERSTAFF_STANCE),
+	ENUM2STRING(BOTH_A2_STABBACK1),		//# Stab saber backward
+	ENUM2STRING(BOTH_ATTACK_BACK),		//# Swing around backwards and attack
+	ENUM2STRING(BOTH_JUMPFLIPSLASHDOWN1),//#
+	ENUM2STRING(BOTH_JUMPFLIPSTABDOWN),//#
+	ENUM2STRING(BOTH_FORCELEAP2_T__B_),//#
+	ENUM2STRING(BOTH_LUNGE2_B__T_),//#
+	ENUM2STRING(BOTH_CROUCHATTACKBACK1),//#
+	//New specials for JKA:
+	ENUM2STRING(BOTH_JUMPATTACK6),//#
+	ENUM2STRING(BOTH_JUMPATTACK7),//#
+	ENUM2STRING(BOTH_SPINATTACK6),//#
+	ENUM2STRING(BOTH_SPINATTACK7),//#
+	ENUM2STRING(BOTH_S1_S6),//#	From stand1 to saberdual stance - turning on your dual sabers
+	ENUM2STRING(BOTH_S6_S1),//#	From dualstaff stance to stand1 - turning off your dual sabers
+	ENUM2STRING(BOTH_S1_S7),//#	From stand1 to saberstaff stance - turning on your saberstaff
+	ENUM2STRING(BOTH_S7_S1),//#	From saberstaff stance to stand1 - turning off your saberstaff
+	ENUM2STRING(BOTH_FORCELONGLEAP_START),
+	ENUM2STRING(BOTH_FORCELONGLEAP_ATTACK),
+	ENUM2STRING(BOTH_FORCELONGLEAP_LAND),
+	ENUM2STRING(BOTH_FORCEWALLRUNFLIP_START),
+	ENUM2STRING(BOTH_FORCEWALLRUNFLIP_END),
+	ENUM2STRING(BOTH_FORCEWALLRUNFLIP_ALT),
+	ENUM2STRING(BOTH_FORCEWALLREBOUND_FORWARD),
+	ENUM2STRING(BOTH_FORCEWALLREBOUND_LEFT),
+	ENUM2STRING(BOTH_FORCEWALLREBOUND_BACK),
+	ENUM2STRING(BOTH_FORCEWALLREBOUND_RIGHT),
+	ENUM2STRING(BOTH_FORCEWALLHOLD_FORWARD),
+	ENUM2STRING(BOTH_FORCEWALLHOLD_LEFT),
+	ENUM2STRING(BOTH_FORCEWALLHOLD_BACK),
+	ENUM2STRING(BOTH_FORCEWALLHOLD_RIGHT),
+	ENUM2STRING(BOTH_FORCEWALLRELEASE_FORWARD),
+	ENUM2STRING(BOTH_FORCEWALLRELEASE_LEFT),
+	ENUM2STRING(BOTH_FORCEWALLRELEASE_BACK),
+	ENUM2STRING(BOTH_FORCEWALLRELEASE_RIGHT),
+	ENUM2STRING(BOTH_A7_KICK_F),
+	ENUM2STRING(BOTH_A7_KICK_B),
+	ENUM2STRING(BOTH_A7_KICK_R),
+	ENUM2STRING(BOTH_A7_KICK_L),
+	ENUM2STRING(BOTH_A7_KICK_S),
+	ENUM2STRING(BOTH_A7_KICK_BF),
+	ENUM2STRING(BOTH_A7_KICK_BF_STOP),
+	ENUM2STRING(BOTH_A7_KICK_RL),
+	ENUM2STRING(BOTH_A7_KICK_F_AIR),
+	ENUM2STRING(BOTH_A7_KICK_B_AIR),
+	ENUM2STRING(BOTH_A7_KICK_R_AIR),
+	ENUM2STRING(BOTH_A7_KICK_L_AIR),
+	ENUM2STRING(BOTH_FLIP_ATTACK7),
+	ENUM2STRING(BOTH_FLIP_HOLD7),
+	ENUM2STRING(BOTH_FLIP_LAND),
+	ENUM2STRING(BOTH_PULL_IMPALE_STAB),
+	ENUM2STRING(BOTH_PULL_IMPALE_SWING),
+	ENUM2STRING(BOTH_PULLED_INAIR_B),
+	ENUM2STRING(BOTH_PULLED_INAIR_F),
+	ENUM2STRING(BOTH_STABDOWN),
+	ENUM2STRING(BOTH_STABDOWN_STAFF),
+	ENUM2STRING(BOTH_STABDOWN_DUAL),
+	ENUM2STRING(BOTH_A6_SABERPROTECT),
+	ENUM2STRING(BOTH_A7_SOULCAL),
+	ENUM2STRING(BOTH_A1_SPECIAL),
+	ENUM2STRING(BOTH_A2_SPECIAL),
+	ENUM2STRING(BOTH_A3_SPECIAL),
+	ENUM2STRING(BOTH_ROLL_STAB),
+
+	//# #sep ENUM2STRING(BOTH_ STANDING
+	ENUM2STRING(BOTH_STAND1),			//# Standing idle, no weapon, hands down
+	ENUM2STRING(BOTH_STAND1IDLE1),		//# Random standing idle
+	ENUM2STRING(BOTH_STAND2),			//# Standing idle with a saber
+	ENUM2STRING(BOTH_STAND2IDLE1),		//# Random standing idle
+	ENUM2STRING(BOTH_STAND2IDLE2),
+	ENUM2STRING(BOTH_STAND3),			//# Standing idle with 2-handed weapon
+	ENUM2STRING(BOTH_STAND3IDLE1),		//# Random standing idle
+	ENUM2STRING(BOTH_STAND4),			//# hands clasp behind back
+	ENUM2STRING(BOTH_STAND5),			//# standing idle, no weapon, hand down, back straight
+	ENUM2STRING(BOTH_STAND5IDLE1),		//# Random standing idle
+	ENUM2STRING(BOTH_STAND6),			//# one handed), gun at side), relaxed stand
+	ENUM2STRING(BOTH_STAND8),			//# both hands on hips (male)
+	ENUM2STRING(BOTH_STAND1TO2),			//# Transition from stand1 to stand2
+	ENUM2STRING(BOTH_STAND2TO1),			//# Transition from stand2 to stand1
+	ENUM2STRING(BOTH_STAND2TO4),			//# Transition from stand2 to stand4
+	ENUM2STRING(BOTH_STAND4TO2),			//# Transition from stand4 to stand2
+	ENUM2STRING(BOTH_STAND4TOATTACK2),	//# relaxed stand to 1-handed pistol ready
+	ENUM2STRING(BOTH_STANDUP2),			//# Luke standing up from his meditation platform (cin # 37)
+	ENUM2STRING(BOTH_STAND5TOSIT3),		//# transition from stand 5 to sit 3
+	ENUM2STRING(BOTH_STAND1TOSTAND5),	//# Transition from stand1 to stand5
+	ENUM2STRING(BOTH_STAND5TOSTAND1),	//# Transition from stand5 to stand1
+	ENUM2STRING(BOTH_STAND5TOAIM),		//# Transition of Kye aiming his gun at Desann (cin #9) 
+	ENUM2STRING(BOTH_STAND5STARTLEDLOOKLEFT),	//# Kyle turning to watch the bridge drop (cin #9) 
+	ENUM2STRING(BOTH_STARTLEDLOOKLEFTTOSTAND5),	//# Kyle returning to stand 5 from watching the bridge drop (cin #9) 
+	ENUM2STRING(BOTH_STAND5TOSTAND8),	//# Transition from stand5 to stand8
+	ENUM2STRING(BOTH_STAND7TOSTAND8),	//# Tavion putting hands on back of chair (cin #11)
+	ENUM2STRING(BOTH_STAND8TOSTAND5),	//# Transition from stand8 to stand5
+	ENUM2STRING(BOTH_STAND9),			//# Kyle's standing idle, no weapon, hands down
+	ENUM2STRING(BOTH_STAND9IDLE1),		//# Kyle's random standing idle
+	ENUM2STRING(BOTH_STAND5SHIFTWEIGHT),	//# Weightshift from stand5 to side and back to stand5
+	ENUM2STRING(BOTH_STAND5SHIFTWEIGHTSTART),	//# From stand5 to side
+	ENUM2STRING(BOTH_STAND5SHIFTWEIGHTSTOP),		//# From side to stand5
+	ENUM2STRING(BOTH_STAND5TURNLEFTSTART),		//# Start turning left from stand5
+	ENUM2STRING(BOTH_STAND5TURNLEFTSTOP),		//# Stop turning left from stand5
+	ENUM2STRING(BOTH_STAND5TURNRIGHTSTART),		//# Start turning right from stand5
+	ENUM2STRING(BOTH_STAND5TURNRIGHTSTOP),		//# Stop turning right from stand5
+	ENUM2STRING(BOTH_STAND5LOOK180LEFTSTART),	//# Start looking over left shoulder (cin #17)
+	ENUM2STRING(BOTH_STAND5LOOK180LEFTSTOP),	//# Stop looking over left shoulder (cin #17)
+
+	ENUM2STRING(BOTH_CONSOLE1START),	//# typing at a console
+	ENUM2STRING(BOTH_CONSOLE1),			//# typing at a console
+	ENUM2STRING(BOTH_CONSOLE1STOP),		//# typing at a console
+	ENUM2STRING(BOTH_CONSOLE2START),	//# typing at a console with comm link in hand (cin #5) 
+	ENUM2STRING(BOTH_CONSOLE2),			//# typing at a console with comm link in hand (cin #5) 
+	ENUM2STRING(BOTH_CONSOLE2STOP),		//# typing at a console with comm link in hand (cin #5) 
+	ENUM2STRING(BOTH_CONSOLE2HOLDCOMSTART),	//# lean in to type at console while holding comm link in hand (cin #5) 
+	ENUM2STRING(BOTH_CONSOLE2HOLDCOMSTOP),	//# lean away after typing at console while holding comm link in hand (cin #5) 
+
+	ENUM2STRING(BOTH_GUARD_LOOKAROUND1),	//# Cradling weapon and looking around
+	ENUM2STRING(BOTH_GUARD_IDLE1),		//# Cradling weapon and standing
+	ENUM2STRING(BOTH_GESTURE1),			//# Generic gesture), non-specific
+	ENUM2STRING(BOTH_GESTURE2),			//# Generic gesture), non-specific
+	ENUM2STRING(BOTH_WALK1TALKCOMM1),	//# Talking into coom link while walking
+	ENUM2STRING(BOTH_TALK1),			//# Generic talk anim
+	ENUM2STRING(BOTH_TALK2),			//# Generic talk anim
+	ENUM2STRING(BOTH_TALKCOMM1START),	//# Start talking into a comm link
+	ENUM2STRING(BOTH_TALKCOMM1),		//# Talking into a comm link
+	ENUM2STRING(BOTH_TALKCOMM1STOP),	//# Stop talking into a comm link
+	ENUM2STRING(BOTH_TALKGESTURE1),		//# Generic talk anim
+
+	ENUM2STRING(BOTH_HEADTILTLSTART),		//# Head tilt to left
+	ENUM2STRING(BOTH_HEADTILTLSTOP),		//# Head tilt to left
+	ENUM2STRING(BOTH_HEADTILTRSTART),		//# Head tilt to right
+	ENUM2STRING(BOTH_HEADTILTRSTOP),		//# Head tilt to right
+	ENUM2STRING(BOTH_HEADNOD),				//# Head shake YES
+	ENUM2STRING(BOTH_HEADSHAKE),			//# Head shake NO
+	ENUM2STRING(BOTH_SIT2HEADTILTLSTART),	//# Head tilt to left from seated position 2
+	ENUM2STRING(BOTH_SIT2HEADTILTLSTOP),	//# Head tilt to left from seated position 2
+
+	ENUM2STRING(BOTH_REACH1START),		//# Monmothma reaching for crystal
+	ENUM2STRING(BOTH_REACH1STOP),		//# Monmothma reaching for crystal
+
+	ENUM2STRING(BOTH_COME_ON1),				//# Jan gesturing to Kyle (cin #32a)
+	ENUM2STRING(BOTH_STEADYSELF1),			//# Jan trying to keep footing (cin #32a) Kyle (cin#5)
+	ENUM2STRING(BOTH_STEADYSELF1END),		//# Return hands to side from STEADSELF1 Kyle (cin#5)
+	ENUM2STRING(BOTH_SILENCEGESTURE1),		//# Luke silencing Kyle with a raised hand (cin #37)
+	ENUM2STRING(BOTH_REACHFORSABER1),		//# Luke holding hand out for Kyle's saber (cin #37)
+	ENUM2STRING(BOTH_SABERKILLER1),			//# Tavion about to strike Jan with saber (cin #9)
+	ENUM2STRING(BOTH_SABERKILLEE1),			//# Jan about to be struck by Tavion with saber (cin #9)
+	ENUM2STRING(BOTH_HUGGER1),				//# Kyle hugging Jan (cin #29)
+	ENUM2STRING(BOTH_HUGGERSTOP1),			//# Kyle stop hugging Jan but don't let her go (cin #29)
+	ENUM2STRING(BOTH_HUGGEE1),				//# Jan being hugged (cin #29)
+	ENUM2STRING(BOTH_HUGGEESTOP1),			//# Jan stop being hugged but don't let go (cin #29)
+
+	ENUM2STRING(BOTH_SABERTHROW1START),		//# Desann throwing his light saber (cin #26)
+	ENUM2STRING(BOTH_SABERTHROW1STOP),		//# Desann throwing his light saber (cin #26)
+	ENUM2STRING(BOTH_SABERTHROW2START),		//# Kyle throwing his light saber (cin #32)
+	ENUM2STRING(BOTH_SABERTHROW2STOP),		//# Kyle throwing his light saber (cin #32)
+
+	//# #sep ENUM2STRING(BOTH_ SITTING/CROUCHING
+	ENUM2STRING(BOTH_SIT1),				//# Normal chair sit.
+	ENUM2STRING(BOTH_SIT2),				//# Lotus position.
+	ENUM2STRING(BOTH_SIT3),				//# Sitting in tired position), elbows on knees
+
+	ENUM2STRING(BOTH_SIT2TOSTAND5),		//# Transition from sit 2 to stand 5
+	ENUM2STRING(BOTH_STAND5TOSIT2),		//# Transition from stand 5 to sit 2
+	ENUM2STRING(BOTH_SIT2TOSIT4),		//# Trans from sit2 to sit4 (cin #12) Luke leaning back from lotus position.
+	ENUM2STRING(BOTH_SIT3TOSTAND5),		//# transition from sit 3 to stand 5
+
+	ENUM2STRING(BOTH_CROUCH1),			//# Transition from standing to crouch
+	ENUM2STRING(BOTH_CROUCH1IDLE),		//# Crouching idle
+	ENUM2STRING(BOTH_CROUCH1WALK),		//# Walking while crouched
+	ENUM2STRING(BOTH_CROUCH1WALKBACK),	//# Walking while crouched
+	ENUM2STRING(BOTH_UNCROUCH1),			//# Transition from crouch to standing
+	ENUM2STRING(BOTH_CROUCH2TOSTAND1),	//# going from crouch2 to stand1
+	ENUM2STRING(BOTH_CROUCH3),			//# Desann crouching down to Kyle (cin 9)
+	ENUM2STRING(BOTH_UNCROUCH3),			//# Desann uncrouching down to Kyle (cin 9)
+	ENUM2STRING(BOTH_CROUCH4),			//# Slower version of crouch1 for cinematics
+	ENUM2STRING(BOTH_UNCROUCH4),		//# Slower version of uncrouch1 for cinematics
+
+	ENUM2STRING(BOTH_GUNSIT1),			//# sitting on an emplaced gun.
+
+	// Swoop Vehicle animations.
+	//* #sep BOTH_ SWOOP ANIMS
+	ENUM2STRING(BOTH_VS_MOUNT_L),			//# Mount from left		
+	ENUM2STRING(BOTH_VS_DISMOUNT_L),		//# Dismount to left		
+	ENUM2STRING(BOTH_VS_MOUNT_R),			//# Mount from  right (symmetry)		
+	ENUM2STRING(BOTH_VS_DISMOUNT_R),		//# Dismount to  right (symmetry)		
+
+	ENUM2STRING(BOTH_VS_MOUNTJUMP_L),		//#
+	ENUM2STRING(BOTH_VS_MOUNTTHROW),		//# Land on an occupied vehicle & throw off current pilot
+	ENUM2STRING(BOTH_VS_MOUNTTHROW_L),		//# Land on an occupied vehicle & throw off current pilot
+	ENUM2STRING(BOTH_VS_MOUNTTHROW_R),		//# Land on an occupied vehicle & throw off current pilot
+	ENUM2STRING(BOTH_VS_MOUNTTHROWEE),		//# Current pilot getting thrown off by another guy
+				
+	ENUM2STRING(BOTH_VS_LOOKLEFT),			//# Turn & Look behind and to the left (no weapon)		
+	ENUM2STRING(BOTH_VS_LOOKRIGHT),			//# Turn & Look behind and to the right (no weapon)		
+
+	ENUM2STRING(BOTH_VS_TURBO),				//# Hit The Turbo Button
+
+	ENUM2STRING(BOTH_VS_REV),				//# Player looks back as swoop reverses		
+
+	ENUM2STRING(BOTH_VS_AIR),				//# Player stands up when swoop is airborn		
+	ENUM2STRING(BOTH_VS_AIR_G),				//# "" with Gun
+	ENUM2STRING(BOTH_VS_AIR_SL),			//# "" with Saber Left
+	ENUM2STRING(BOTH_VS_AIR_SR),			//# "" with Saber Right
+
+	ENUM2STRING(BOTH_VS_LAND),				//# Player bounces down when swoop lands		
+	ENUM2STRING(BOTH_VS_LAND_G),			//#  "" with Gun
+	ENUM2STRING(BOTH_VS_LAND_SL),			//#  "" with Saber Left
+	ENUM2STRING(BOTH_VS_LAND_SR),			//#  "" with Saber Right
+
+	ENUM2STRING(BOTH_VS_IDLE),				//# Sit
+	ENUM2STRING(BOTH_VS_IDLE_G),			//# Sit (gun)
+	ENUM2STRING(BOTH_VS_IDLE_SL),			//# Sit (saber left)		
+	ENUM2STRING(BOTH_VS_IDLE_SR),			//# Sit (saber right)		
+
+	ENUM2STRING(BOTH_VS_LEANL),				//# Lean left
+	ENUM2STRING(BOTH_VS_LEANL_G),			//# Lean left (gun)		
+	ENUM2STRING(BOTH_VS_LEANL_SL),			//# Lean left (saber left)		
+	ENUM2STRING(BOTH_VS_LEANL_SR),			//# Lean left (saber right)		
+
+	ENUM2STRING(BOTH_VS_LEANR),				//# Lean right		
+	ENUM2STRING(BOTH_VS_LEANR_G),			//# Lean right (gun)		
+	ENUM2STRING(BOTH_VS_LEANR_SL),			//# Lean right (saber left)		
+	ENUM2STRING(BOTH_VS_LEANR_SR),			//# Lean right (saber right)		
+				
+	ENUM2STRING(BOTH_VS_ATL_S),				//# Attack left with saber		
+	ENUM2STRING(BOTH_VS_ATR_S),				//# Attack right with saber		
+	ENUM2STRING(BOTH_VS_ATR_TO_L_S),		//# Attack toss saber from right to left hand
+	ENUM2STRING(BOTH_VS_ATL_TO_R_S),		//# Attack toss saber from left to right hand
+	ENUM2STRING(BOTH_VS_ATR_G),				//# Attack right with gun (90)		
+	ENUM2STRING(BOTH_VS_ATL_G),				//# Attack left with gun (90)		
+	ENUM2STRING(BOTH_VS_ATF_G),				//# Attack forward with gun		
+
+	ENUM2STRING(BOTH_VS_PAIN1),				//# Pain		
+
+	// Added 12/04/02 by Aurelio.
+	//* #sep BOTH_ TAUNTAUN ANIMS
+	ENUM2STRING(BOTH_VT_MOUNT_L),			//# Mount from left	
+	ENUM2STRING(BOTH_VT_MOUNT_R),			//# Mount from right	
+	ENUM2STRING(BOTH_VT_MOUNT_B),			//# Mount from air, behind
+	ENUM2STRING(BOTH_VT_DISMOUNT),			//# Dismount for tauntaun
+	ENUM2STRING(BOTH_VT_DISMOUNT_L),		//# Dismount to tauntauns left	
+	ENUM2STRING(BOTH_VT_DISMOUNT_R),		//# Dismount to tauntauns right (symmetry)	
+
+	ENUM2STRING(BOTH_VT_WALK_FWD),			//# Walk forward	
+	ENUM2STRING(BOTH_VT_WALK_REV),			//# Walk backward	
+	ENUM2STRING(BOTH_VT_WALK_FWD_L),		//# walk lean left
+	ENUM2STRING(BOTH_VT_WALK_FWD_R),		//# walk lean right
+	ENUM2STRING(BOTH_VT_RUN_FWD),			//# Run forward	
+	ENUM2STRING(BOTH_VT_RUN_REV),			//# Look backwards while running (not weapon specific)	
+	ENUM2STRING(BOTH_VT_RUN_FWD_L),			//# run lean left
+	ENUM2STRING(BOTH_VT_RUN_FWD_R),			//# run lean right
+
+	ENUM2STRING(BOTH_VT_SLIDEF),			//# Tauntaun slides forward with abrupt stop	
+	ENUM2STRING(BOTH_VT_AIR),				//# Tauntaun jump	
+	ENUM2STRING(BOTH_VT_ATB),				//# Tauntaun tail swipe	
+	ENUM2STRING(BOTH_VT_PAIN1),				//# Pain	
+	ENUM2STRING(BOTH_VT_DEATH1),			//# Die	
+	ENUM2STRING(BOTH_VT_STAND),				//# Stand still and breath	
+	ENUM2STRING(BOTH_VT_BUCK),				//# Tauntaun bucking loop animation	
+
+	ENUM2STRING(BOTH_VT_LAND),				//# Player bounces down when tauntaun lands	
+	ENUM2STRING(BOTH_VT_TURBO),				//# Hit The Turbo Button
+	ENUM2STRING(BOTH_VT_IDLE_SL),			//# Sit (saber left)		
+	ENUM2STRING(BOTH_VT_IDLE_SR),			//# Sit (saber right)		
+	ENUM2STRING(BOTH_VT_IDLE),				//# Sit with no weapon selected	
+	ENUM2STRING(BOTH_VT_IDLE1),				//# Sit with no weapon selected	
+	ENUM2STRING(BOTH_VT_IDLE_S),			//# Sit with saber selected	
+	ENUM2STRING(BOTH_VT_IDLE_G),			//# Sit with gun selected	
+	ENUM2STRING(BOTH_VT_IDLE_T),			//# Sit with thermal grenade selected
+
+	ENUM2STRING(BOTH_VT_ATL_S),				//# Attack left with saber	
+	ENUM2STRING(BOTH_VT_ATR_S),				//# Attack right with saber	
+	ENUM2STRING(BOTH_VT_ATR_TO_L_S),		//# Attack toss saber from right to left hand
+	ENUM2STRING(BOTH_VT_ATL_TO_R_S),		//# Attack toss saber from left to right hand
+	ENUM2STRING(BOTH_VT_ATR_G),				//# Attack right with gun (90)	
+	ENUM2STRING(BOTH_VT_ATL_G),				//# Attack left with gun (90)	
+	ENUM2STRING(BOTH_VT_ATF_G),				//# Attack forward with gun	
+
+
+	// Added 2/26/02 by Aurelio.
+	//* #sep BOTH_ FIGHTER ANIMS
+	ENUM2STRING( BOTH_GEARS_OPEN ),
+	ENUM2STRING( BOTH_GEARS_CLOSE ),
+	ENUM2STRING( BOTH_WINGS_OPEN ),
+	ENUM2STRING( BOTH_WINGS_CLOSE ),
+
+	///////////////////////////////////
+
+	ENUM2STRING(BOTH_DEATH14_UNGRIP),	//# Desann's end death (cin #35)
+	ENUM2STRING(BOTH_DEATH14_SITUP),	//# Tavion sitting up after having been thrown (cin #23)
+	ENUM2STRING(BOTH_KNEES1),			//# Tavion on her knees
+	ENUM2STRING(BOTH_KNEES2),			//# Tavion on her knees looking down
+	ENUM2STRING(BOTH_KNEES2TO1),		//# Transition of KNEES2 to KNEES1
+
+	//# #sep ENUM2STRING(BOTH_ MOVING
+	ENUM2STRING(BOTH_WALK1),				//# Normal walk
+	ENUM2STRING(BOTH_WALK2),				//# Normal walk
+	ENUM2STRING(BOTH_WALK_STAFF),		//# Walk with saberstaff turned on
+	ENUM2STRING(BOTH_WALKBACK_STAFF),	//# Walk backwards with saberstaff turned on
+	ENUM2STRING(BOTH_WALK_DUAL),			//# Walk with dual turned on
+	ENUM2STRING(BOTH_WALKBACK_DUAL),		//# Walk backwards with dual turned on
+	ENUM2STRING(BOTH_WALK5),				//# Tavion taunting Kyle (cin 22)
+	ENUM2STRING(BOTH_WALK6),				//# Slow walk for Luke (cin 12)
+	ENUM2STRING(BOTH_WALK7),				//# Fast walk
+	ENUM2STRING(BOTH_RUN1),				//# Full run
+	ENUM2STRING(BOTH_RUN1START),			//# Start into full run1
+	ENUM2STRING(BOTH_RUN1STOP),			//# Stop from full run1
+	ENUM2STRING(BOTH_RUN2),				//# Full run
+	ENUM2STRING(BOTH_RUN1TORUN2),		//# Wampa run anim transition
+	ENUM2STRING(BOTH_RUN2TORUN1),		//# Wampa run anim transition
+	ENUM2STRING(BOTH_RUN4),				//# Jawa run
+	ENUM2STRING(BOTH_RUN_STAFF),			//# Run with saberstaff turned on
+	ENUM2STRING(BOTH_RUNBACK_STAFF),		//# Run backwards with saberstaff turned on
+	ENUM2STRING(BOTH_RUN_DUAL),			//# Run with dual turned on
+	ENUM2STRING(BOTH_RUNBACK_DUAL),		//# Run backwards with dual turned on
+	ENUM2STRING(BOTH_STRAFE_LEFT1),		//# Sidestep left), should loop
+	ENUM2STRING(BOTH_STRAFE_RIGHT1),		//# Sidestep right), should loop
+	ENUM2STRING(BOTH_RUNSTRAFE_LEFT1),	//# Sidestep left), should loop
+	ENUM2STRING(BOTH_RUNSTRAFE_RIGHT1),	//# Sidestep right), should loop
+	ENUM2STRING(BOTH_TURN_LEFT1),		//# Turn left), should loop
+	ENUM2STRING(BOTH_TURN_RIGHT1),		//# Turn right), should loop
+	ENUM2STRING(BOTH_TURNSTAND1),		//# Turn from STAND1 position
+	ENUM2STRING(BOTH_TURNSTAND2),		//# Turn from STAND2 position
+	ENUM2STRING(BOTH_TURNSTAND3),		//# Turn from STAND3 position
+	ENUM2STRING(BOTH_TURNSTAND4),		//# Turn from STAND4 position
+	ENUM2STRING(BOTH_TURNSTAND5),		//# Turn from STAND5 position
+	ENUM2STRING(BOTH_TURNCROUCH1),		//# Turn from CROUCH1 position
+
+	ENUM2STRING(BOTH_WALKBACK1),			//# Walk1 backwards
+	ENUM2STRING(BOTH_WALKBACK2),			//# Walk2 backwards
+	ENUM2STRING(BOTH_RUNBACK1),			//# Run1 backwards
+	ENUM2STRING(BOTH_RUNBACK2),			//# Run1 backwards
+	
+	//# #sep BOTH_ JUMPING
+	ENUM2STRING(BOTH_JUMP1),				//# Jump - wind-up and leave ground
+	ENUM2STRING(BOTH_INAIR1),			//# In air loop (from jump)
+	ENUM2STRING(BOTH_LAND1),				//# Landing (from in air loop)
+	ENUM2STRING(BOTH_LAND2),				//# Landing Hard (from a great height)
+
+	ENUM2STRING(BOTH_JUMPBACK1),			//# Jump backwards - wind-up and leave ground
+	ENUM2STRING(BOTH_INAIRBACK1),		//# In air loop (from jump back)
+	ENUM2STRING(BOTH_LANDBACK1),			//# Landing backwards(from in air loop)
+
+	ENUM2STRING(BOTH_JUMPLEFT1),			//# Jump left - wind-up and leave ground
+	ENUM2STRING(BOTH_INAIRLEFT1),		//# In air loop (from jump left)
+	ENUM2STRING(BOTH_LANDLEFT1),			//# Landing left(from in air loop)
+
+	ENUM2STRING(BOTH_JUMPRIGHT1),		//# Jump right - wind-up and leave ground
+	ENUM2STRING(BOTH_INAIRRIGHT1),		//# In air loop (from jump right)
+	ENUM2STRING(BOTH_LANDRIGHT1),		//# Landing right(from in air loop)
+
+	ENUM2STRING(BOTH_FORCEJUMP1),				//# Jump - wind-up and leave ground
+	ENUM2STRING(BOTH_FORCEINAIR1),			//# In air loop (from jump)
+	ENUM2STRING(BOTH_FORCELAND1),				//# Landing (from in air loop)
+
+	ENUM2STRING(BOTH_FORCEJUMPBACK1),			//# Jump backwards - wind-up and leave ground
+	ENUM2STRING(BOTH_FORCEINAIRBACK1),		//# In air loop (from jump back)
+	ENUM2STRING(BOTH_FORCELANDBACK1),			//# Landing backwards(from in air loop)
+
+	ENUM2STRING(BOTH_FORCEJUMPLEFT1),			//# Jump left - wind-up and leave ground
+	ENUM2STRING(BOTH_FORCEINAIRLEFT1),		//# In air loop (from jump left)
+	ENUM2STRING(BOTH_FORCELANDLEFT1),			//# Landing left(from in air loop)
+
+	ENUM2STRING(BOTH_FORCEJUMPRIGHT1),		//# Jump right - wind-up and leave ground
+	ENUM2STRING(BOTH_FORCEINAIRRIGHT1),		//# In air loop (from jump right)
+	ENUM2STRING(BOTH_FORCELANDRIGHT1),		//# Landing right(from in air loop)
+	//# #sep BOTH_ ACROBATICS
+	ENUM2STRING(BOTH_FLIP_F),			//# Flip forward
+	ENUM2STRING(BOTH_FLIP_B),			//# Flip backwards
+	ENUM2STRING(BOTH_FLIP_L),			//# Flip left
+	ENUM2STRING(BOTH_FLIP_R),			//# Flip right
+
+	ENUM2STRING(BOTH_ROLL_F),			//# Roll forward
+	ENUM2STRING(BOTH_ROLL_B),			//# Roll backward
+	ENUM2STRING(BOTH_ROLL_L),			//# Roll left
+	ENUM2STRING(BOTH_ROLL_R),			//# Roll right
+
+	ENUM2STRING(BOTH_HOP_F),				//# quickstep forward
+	ENUM2STRING(BOTH_HOP_B),				//# quickstep backwards
+	ENUM2STRING(BOTH_HOP_L),				//# quickstep left
+	ENUM2STRING(BOTH_HOP_R),				//# quickstep right
+
+	ENUM2STRING(BOTH_DODGE_FL),			//# lean-dodge forward left
+	ENUM2STRING(BOTH_DODGE_FR),			//# lean-dodge forward right
+	ENUM2STRING(BOTH_DODGE_BL),			//# lean-dodge backwards left
+	ENUM2STRING(BOTH_DODGE_BR),			//# lean-dodge backwards right
+	ENUM2STRING(BOTH_DODGE_L),			//# lean-dodge left
+	ENUM2STRING(BOTH_DODGE_R),			//# lean-dodge right
+	ENUM2STRING(BOTH_DODGE_HOLD_FL),			//# lean-dodge pose forward left
+	ENUM2STRING(BOTH_DODGE_HOLD_FR),			//# lean-dodge pose forward right
+	ENUM2STRING(BOTH_DODGE_HOLD_BL),			//# lean-dodge pose backwards left
+	ENUM2STRING(BOTH_DODGE_HOLD_BR),			//# lean-dodge pose backwards right
+	ENUM2STRING(BOTH_DODGE_HOLD_L),			//# lean-dodge pose left
+	ENUM2STRING(BOTH_DODGE_HOLD_R),			//# lean-dodge pose right
+
+	//MP taunt anims
+	ENUM2STRING(BOTH_ENGAGETAUNT),
+	ENUM2STRING(BOTH_BOW),
+	ENUM2STRING(BOTH_MEDITATE),
+	ENUM2STRING(BOTH_MEDITATE_END),
+	ENUM2STRING(BOTH_SHOWOFF_FAST),
+	ENUM2STRING(BOTH_SHOWOFF_MEDIUM),
+	ENUM2STRING(BOTH_SHOWOFF_STRONG),
+	ENUM2STRING(BOTH_SHOWOFF_DUAL),
+	ENUM2STRING(BOTH_SHOWOFF_STAFF),
+	ENUM2STRING(BOTH_VICTORY_FAST),
+	ENUM2STRING(BOTH_VICTORY_MEDIUM),
+	ENUM2STRING(BOTH_VICTORY_STRONG),
+	ENUM2STRING(BOTH_VICTORY_DUAL),
+	ENUM2STRING(BOTH_VICTORY_STAFF),
+	//other saber/acro anims
+	ENUM2STRING(BOTH_ARIAL_LEFT),		//# 
+	ENUM2STRING(BOTH_ARIAL_RIGHT),		//# 
+	ENUM2STRING(BOTH_CARTWHEEL_LEFT),	//# 
+	ENUM2STRING(BOTH_CARTWHEEL_RIGHT),	//# 
+	ENUM2STRING(BOTH_FLIP_LEFT),			//# 
+	ENUM2STRING(BOTH_FLIP_BACK1),		//# 
+	ENUM2STRING(BOTH_FLIP_BACK2),		//# 
+	ENUM2STRING(BOTH_FLIP_BACK3),		//# 
+	ENUM2STRING(BOTH_BUTTERFLY_LEFT),	//# 
+	ENUM2STRING(BOTH_BUTTERFLY_RIGHT),	//# 
+	ENUM2STRING(BOTH_WALL_RUN_RIGHT),	//# 
+	ENUM2STRING(BOTH_WALL_RUN_RIGHT_FLIP),//#
+	ENUM2STRING(BOTH_WALL_RUN_RIGHT_STOP),//# 
+	ENUM2STRING(BOTH_WALL_RUN_LEFT),		//# 
+	ENUM2STRING(BOTH_WALL_RUN_LEFT_FLIP),//#
+	ENUM2STRING(BOTH_WALL_RUN_LEFT_STOP),//# 
+	ENUM2STRING(BOTH_WALL_FLIP_RIGHT),	//# 
+	ENUM2STRING(BOTH_WALL_FLIP_LEFT),	//# 
+	ENUM2STRING(BOTH_KNOCKDOWN1),		//# knocked backwards
+	ENUM2STRING(BOTH_KNOCKDOWN2),		//# knocked backwards hard
+	ENUM2STRING(BOTH_KNOCKDOWN3),		//#	knocked forwards
+	ENUM2STRING(BOTH_KNOCKDOWN4),		//# knocked backwards from crouch
+	ENUM2STRING(BOTH_KNOCKDOWN5),		//# dupe of 3 - will be removed
+	ENUM2STRING(BOTH_GETUP1),			//#
+	ENUM2STRING(BOTH_GETUP2),			//#
+	ENUM2STRING(BOTH_GETUP3),			//#
+	ENUM2STRING(BOTH_GETUP4),			//#
+	ENUM2STRING(BOTH_GETUP5),			//#
+	ENUM2STRING(BOTH_GETUP_CROUCH_F1),	//#
+	ENUM2STRING(BOTH_GETUP_CROUCH_B1),	//#
+	ENUM2STRING(BOTH_FORCE_GETUP_F1),	//#
+	ENUM2STRING(BOTH_FORCE_GETUP_F2),	//#
+	ENUM2STRING(BOTH_FORCE_GETUP_B1),	//#
+	ENUM2STRING(BOTH_FORCE_GETUP_B2),	//#
+	ENUM2STRING(BOTH_FORCE_GETUP_B3),	//#
+	ENUM2STRING(BOTH_FORCE_GETUP_B4),	//#
+	ENUM2STRING(BOTH_FORCE_GETUP_B5),	//#
+	ENUM2STRING(BOTH_FORCE_GETUP_B6),	//#
+	ENUM2STRING(BOTH_GETUP_BROLL_B),	//#
+	ENUM2STRING(BOTH_GETUP_BROLL_F),	//#
+	ENUM2STRING(BOTH_GETUP_BROLL_L),	//#
+	ENUM2STRING(BOTH_GETUP_BROLL_R),	//#
+	ENUM2STRING(BOTH_GETUP_FROLL_B),	//#
+	ENUM2STRING(BOTH_GETUP_FROLL_F),	//#
+	ENUM2STRING(BOTH_GETUP_FROLL_L),	//#
+	ENUM2STRING(BOTH_GETUP_FROLL_R),	//#
+	ENUM2STRING(BOTH_WALL_FLIP_BACK1),	//#
+	ENUM2STRING(BOTH_WALL_FLIP_BACK2),	//#
+	ENUM2STRING(BOTH_SPIN1),				//#
+	ENUM2STRING(BOTH_CEILING_CLING),		//# clinging to ceiling
+	ENUM2STRING(BOTH_CEILING_DROP),		//# dropping from ceiling cling
+
+	//TESTING
+	ENUM2STRING(BOTH_FJSS_TR_BL),		//# jump spin slash tr to bl
+	ENUM2STRING(BOTH_FJSS_TL_BR),		//# jump spin slash bl to tr
+	ENUM2STRING(BOTH_RIGHTHANDCHOPPEDOFF),//#
+	ENUM2STRING(BOTH_DEFLECTSLASH__R__L_FIN),//#
+	ENUM2STRING(BOTH_BASHED1),//#
+	ENUM2STRING(BOTH_ARIAL_F1),//#
+	ENUM2STRING(BOTH_BUTTERFLY_FR1),//#
+	ENUM2STRING(BOTH_BUTTERFLY_FL1),//#
+
+	//NEW SABER/JEDI/FORCE ANIMS
+	ENUM2STRING(BOTH_BACK_FLIP_UP),	//# back flip up Bonus Animation!!!!	
+	ENUM2STRING(BOTH_LOSE_SABER),	//# player losing saber (pulled from hand by force pull 4 - Kyle?)
+	ENUM2STRING(BOTH_STAFF_TAUNT),	//# taunt saberstaff			
+	ENUM2STRING(BOTH_DUAL_TAUNT),		//# taunt dual
+	ENUM2STRING(BOTH_A6_FB),				//# dual attack front/back		
+	ENUM2STRING(BOTH_A6_LR),				//# dual attack left/right
+	ENUM2STRING(BOTH_A7_HILT),			//# saber knock (alt + stand still)
+	//Alora			
+	ENUM2STRING(BOTH_ALORA_SPIN),		//#jump spin attack	death ballet	
+	ENUM2STRING(BOTH_ALORA_FLIP_1),		//# gymnast move 1		
+	ENUM2STRING(BOTH_ALORA_FLIP_2),		//# gymnast move 2		
+	ENUM2STRING(BOTH_ALORA_FLIP_3),		//# gymnast move3		
+	ENUM2STRING(BOTH_ALORA_FLIP_B),		//# gymnast move back		
+	ENUM2STRING(BOTH_ALORA_SPIN_THROW),	//# dual saber throw		
+	ENUM2STRING(BOTH_ALORA_SPIN_SLASH),	//# spin slash	special bonus animation!! :)	
+	ENUM2STRING(BOTH_ALORA_TAUNT),		//# special taunt
+	//Rosh (Kothos battle)			
+	ENUM2STRING(BOTH_ROSH_PAIN),	//# hurt animation (exhausted)		
+	ENUM2STRING(BOTH_ROSH_HEAL),	//# healed/rejuvenated		
+	//Tavion			
+	ENUM2STRING(BOTH_TAVION_SCEPTERGROUND), //# stabbing ground with sith sword shoots electricity everywhere
+	ENUM2STRING(BOTH_TAVION_SWORDPOWER),//# Tavion doing the He-Man(tm) thing
+	ENUM2STRING(BOTH_SCEPTER_START),	//#Point scepter and attack start
+	ENUM2STRING(BOTH_SCEPTER_HOLD),	//#Point scepter and attack hold
+	ENUM2STRING(BOTH_SCEPTER_STOP),	//#Point scepter and attack stop
+	//Kyle Boss			
+	ENUM2STRING(BOTH_KYLE_GRAB),		//# grab
+	ENUM2STRING(BOTH_KYLE_MISS),		//# miss
+	ENUM2STRING(BOTH_KYLE_PA_1),		//# hold 1
+	ENUM2STRING(BOTH_PLAYER_PA_1),	//# player getting held 1
+	ENUM2STRING(BOTH_KYLE_PA_2),		//# hold 2
+	ENUM2STRING(BOTH_PLAYER_PA_2),	//# player getting held 2
+	ENUM2STRING(BOTH_PLAYER_PA_FLY),	//# player getting knocked back from punch at end of hold 1
+	ENUM2STRING(BOTH_KYLE_PA_3),		//# hold 3
+	ENUM2STRING(BOTH_PLAYER_PA_3),	//# player getting held 3
+	ENUM2STRING(BOTH_PLAYER_PA_3_FLY),//# player getting thrown at end of hold 3
+	//Rancor
+	ENUM2STRING(BOTH_BUCK_RIDER),	//# Rancor bucks when someone is on him
+	//WAMPA Grabbing enemy
+	ENUM2STRING(BOTH_HOLD_START),	//#
+	ENUM2STRING(BOTH_HOLD_MISS),	//#
+	ENUM2STRING(BOTH_HOLD_IDLE),	//#
+	ENUM2STRING(BOTH_HOLD_END),	//#
+	ENUM2STRING(BOTH_HOLD_ATTACK),	//#
+	ENUM2STRING(BOTH_HOLD_SNIFF),	//# Sniff the guy you're holding
+	ENUM2STRING(BOTH_HOLD_DROP),		//# just drop 'em
+	//BEING GRABBED BY WAMPA
+	ENUM2STRING(BOTH_GRABBED),	//#
+	ENUM2STRING(BOTH_RELEASED),	//#
+	ENUM2STRING(BOTH_HANG_IDLE),	//#
+	ENUM2STRING(BOTH_HANG_ATTACK),	//#
+	ENUM2STRING(BOTH_HANG_PAIN),	//#
+
+	//# #sep BOTH_ MISC MOVEMENT
+	ENUM2STRING(BOTH_HIT1),				//# Kyle hit by crate in cin #9
+	ENUM2STRING(BOTH_LADDER_UP1),		//# Climbing up a ladder with rungs at 16 unit intervals
+	ENUM2STRING(BOTH_LADDER_DWN1),		//# Climbing down a ladder with rungs at 16 unit intervals
+	ENUM2STRING(BOTH_LADDER_IDLE),		//#	Just sitting on the ladder
+
+	//# #sep ENUM2STRING(BOTH_ FLYING IDLE
+	ENUM2STRING(BOTH_FLY_SHIELDED),		//# For sentry droid, shields in
+
+	//# #sep BOTH_ SWIMMING
+	ENUM2STRING(BOTH_SWIM_IDLE1),		//# Swimming Idle 1
+	ENUM2STRING(BOTH_SWIMFORWARD),		//# Swim forward loop
+	ENUM2STRING(BOTH_SWIMBACKWARD),		//# Swim backward loop
+	
+	//# #sep ENUM2STRING(BOTH_ LYING
+	ENUM2STRING(BOTH_SLEEP1),			//# laying on back-rknee up-rhand on torso
+	ENUM2STRING(BOTH_SLEEP6START),		//# Kyle leaning back to sleep (cin 20)
+	ENUM2STRING(BOTH_SLEEP6STOP),		//# Kyle waking up and shaking his head (cin 21)
+	ENUM2STRING(BOTH_SLEEP1GETUP),		//# alarmed and getting up out of sleep1 pose to stand
+	ENUM2STRING(BOTH_SLEEP1GETUP2),		//# 
+
+	ENUM2STRING(BOTH_CHOKE1START),		//# tavion in force grip choke
+	ENUM2STRING(BOTH_CHOKE1STARTHOLD),		//# loop of tavion in force grip choke
+	ENUM2STRING(BOTH_CHOKE1),			//# tavion in force grip choke
+
+	ENUM2STRING(BOTH_CHOKE2),			//# tavion recovering from force grip choke
+	ENUM2STRING(BOTH_CHOKE3),			//# left-handed choke (for people still holding a weapon)
+
+	//# #sep ENUM2STRING(BOTH_ HUNTER-SEEKER BOT-SPECIFIC
+	ENUM2STRING(BOTH_POWERUP1),			//# Wakes up
+
+	ENUM2STRING(BOTH_TURNON),			//# Protocol Droid wakes up
+	ENUM2STRING(BOTH_TURNOFF),			//# Protocol Droid shuts off
+	ENUM2STRING(BOTH_BUTTON1),			//# Single button push with right hand
+	ENUM2STRING(BOTH_BUTTON2),			//# Single button push with left finger
+	ENUM2STRING(BOTH_BUTTON_HOLD),		//# Single button hold with left hand
+	ENUM2STRING(BOTH_BUTTON_RELEASE),	//# Single button release with left hand
+
+	//# JEDI-SPECIFIC
+	//# #sep BOTH_ FORCE ANIMS
+	ENUM2STRING(BOTH_RESISTPUSH),			//# plant yourself to resist force push/pulls.
+	ENUM2STRING(BOTH_FORCEPUSH),			//# Use off-hand to do force power.
+	ENUM2STRING(BOTH_FORCEPULL),			//# Use off-hand to do force power.
+	ENUM2STRING(BOTH_MINDTRICK1),			//# Use off-hand to do mind trick
+	ENUM2STRING(BOTH_MINDTRICK2),			//# Use off-hand to do distraction
+	ENUM2STRING(BOTH_FORCELIGHTNING),		//# Use off-hand to do lightning
+	ENUM2STRING(BOTH_FORCELIGHTNING_START),	//# Use off-hand to do lightning - start
+	ENUM2STRING(BOTH_FORCELIGHTNING_HOLD),	//# Use off-hand to do lightning - hold
+	ENUM2STRING(BOTH_FORCELIGHTNING_RELEASE),//# Use off-hand to do lightning - release
+	ENUM2STRING(BOTH_FORCEHEAL_START),		//# Healing meditation pose start
+	ENUM2STRING(BOTH_FORCEHEAL_STOP),		//# Healing meditation pose end
+	ENUM2STRING(BOTH_FORCEHEAL_QUICK),		//# Healing meditation gesture
+	ENUM2STRING(BOTH_SABERPULL),			//# Use off-hand to do force power.
+	ENUM2STRING(BOTH_FORCEGRIP1),			//# force-gripping (no anim?)
+	ENUM2STRING(BOTH_FORCEGRIP3),			//# force-gripping (right-hand)
+	ENUM2STRING(BOTH_FORCEGRIP3THROW),		//# throwing while force-gripping (right hand)
+	ENUM2STRING(BOTH_FORCEGRIP_HOLD),	//# Use off-hand to do grip - hold
+	ENUM2STRING(BOTH_FORCEGRIP_RELEASE),//# Use off-hand to do grip - release
+	ENUM2STRING(BOTH_TOSS1),				//# throwing to left after force gripping
+	ENUM2STRING(BOTH_TOSS2),				//# throwing to right after force gripping
+	//NEW force anims for JKA:
+	ENUM2STRING(BOTH_FORCE_RAGE),
+	ENUM2STRING(BOTH_FORCE_2HANDEDLIGHTNING),
+	ENUM2STRING(BOTH_FORCE_2HANDEDLIGHTNING_START),
+	ENUM2STRING(BOTH_FORCE_2HANDEDLIGHTNING_HOLD),
+	ENUM2STRING(BOTH_FORCE_2HANDEDLIGHTNING_RELEASE),
+	ENUM2STRING(BOTH_FORCE_DRAIN),
+	ENUM2STRING(BOTH_FORCE_DRAIN_START),
+	ENUM2STRING(BOTH_FORCE_DRAIN_HOLD),
+	ENUM2STRING(BOTH_FORCE_DRAIN_RELEASE),
+	ENUM2STRING(BOTH_FORCE_DRAIN_GRAB_START),
+	ENUM2STRING(BOTH_FORCE_DRAIN_GRAB_HOLD),
+	ENUM2STRING(BOTH_FORCE_DRAIN_GRAB_END),
+	ENUM2STRING(BOTH_FORCE_DRAIN_GRABBED),
+	ENUM2STRING(BOTH_FORCE_ABSORB),
+	ENUM2STRING(BOTH_FORCE_ABSORB_START),
+	ENUM2STRING(BOTH_FORCE_ABSORB_END),
+	ENUM2STRING(BOTH_FORCE_PROTECT),
+	ENUM2STRING(BOTH_FORCE_PROTECT_FAST),
+
+	ENUM2STRING(BOTH_WIND),
+
+	ENUM2STRING(BOTH_STAND_TO_KNEEL),
+	ENUM2STRING(BOTH_KNEEL_TO_STAND),
+
+	ENUM2STRING(BOTH_TUSKENATTACK1),
+	ENUM2STRING(BOTH_TUSKENATTACK2),
+	ENUM2STRING(BOTH_TUSKENATTACK3),
+	ENUM2STRING(BOTH_TUSKENLUNGE1),
+	ENUM2STRING(BOTH_TUSKENTAUNT1),
+
+	ENUM2STRING(BOTH_COWER1_START),		//# cower start
+	ENUM2STRING(BOTH_COWER1),			//# cower loop
+	ENUM2STRING(BOTH_COWER1_STOP),		//# cower stop
+	ENUM2STRING(BOTH_SONICPAIN_START),
+	ENUM2STRING(BOTH_SONICPAIN_HOLD),
+	ENUM2STRING(BOTH_SONICPAIN_END),
+
+	//new anim slots per Jarrod's request
+	ENUM2STRING(BOTH_STAND10),
+	ENUM2STRING(BOTH_STAND10_TALK1),
+	ENUM2STRING(BOTH_STAND10_TALK2),
+	ENUM2STRING(BOTH_STAND10TOSTAND1),
+
+	ENUM2STRING(BOTH_STAND1_TALK1),
+	ENUM2STRING(BOTH_STAND1_TALK2),
+	ENUM2STRING(BOTH_STAND1_TALK3),
+
+	ENUM2STRING(BOTH_SIT4),
+	ENUM2STRING(BOTH_SIT5),
+	ENUM2STRING(BOTH_SIT5_TALK1),
+	ENUM2STRING(BOTH_SIT5_TALK2),
+	ENUM2STRING(BOTH_SIT5_TALK3),
+
+	ENUM2STRING(BOTH_SIT6),
+	ENUM2STRING(BOTH_SIT7),
+	//=================================================
+	//ANIMS IN WHICH ONLY THE UPPER OBJECTS ARE IN MD3
+	//=================================================
+	//# #sep ENUM2STRING(TORSO_ WEAPON-RELATED
+	ENUM2STRING(TORSO_DROPWEAP1),		//# Put weapon away
+	ENUM2STRING(TORSO_DROPWEAP4),		//# Put weapon away
+	ENUM2STRING(TORSO_RAISEWEAP1),		//# Draw Weapon
+	ENUM2STRING(TORSO_RAISEWEAP4),		//# Draw Weapon
+	ENUM2STRING(TORSO_WEAPONREADY1),		//# Ready to fire stun baton
+	ENUM2STRING(TORSO_WEAPONREADY2),		//# Ready to fire one-handed blaster pistol
+	ENUM2STRING(TORSO_WEAPONREADY3),		//# Ready to fire blaster rifle
+	ENUM2STRING(TORSO_WEAPONREADY4),		//# Ready to fire sniper rifle
+	ENUM2STRING(TORSO_WEAPONREADY10),	//# Ready to fire thermal det
+	ENUM2STRING(TORSO_WEAPONIDLE2),		//# Holding one-handed blaster
+	ENUM2STRING(TORSO_WEAPONIDLE3),		//# Holding blaster rifle
+	ENUM2STRING(TORSO_WEAPONIDLE4),		//# Holding sniper rifle
+	ENUM2STRING(TORSO_WEAPONIDLE10),		//# Holding thermal det
+
+	//# #sep ENUM2STRING(TORSO_ USING NON-WEAPON OBJECTS
+
+	//# #sep ENUM2STRING(TORSO_ MISC
+	ENUM2STRING(TORSO_SURRENDER_START),	//# arms up
+	ENUM2STRING(TORSO_SURRENDER_STOP),	//# arms back down
+	ENUM2STRING(TORSO_CHOKING1),			//# TEMP
+
+	ENUM2STRING(TORSO_HANDSIGNAL1),
+	ENUM2STRING(TORSO_HANDSIGNAL2),
+	ENUM2STRING(TORSO_HANDSIGNAL3),
+	ENUM2STRING(TORSO_HANDSIGNAL4),
+	ENUM2STRING(TORSO_HANDSIGNAL5),
+
+	//=================================================
+	//ANIMS IN WHICH ONLY THE LOWER OBJECTS ARE IN MD3
+	//=================================================
+	//# #sep Legs-only anims
+	ENUM2STRING(LEGS_TURN1),				//# What legs do when you turn your lower body to match your upper body facing
+	ENUM2STRING(LEGS_TURN2),				//# Leg turning from stand2
+	ENUM2STRING(LEGS_LEAN_LEFT1),		//# Lean left
+	ENUM2STRING(LEGS_LEAN_RIGHT1),		//# Lean Right
+	ENUM2STRING(LEGS_CHOKING1),			//# TEMP
+	ENUM2STRING(LEGS_LEFTUP1),			//# On a slope with left foot 4 higher than right
+	ENUM2STRING(LEGS_LEFTUP2),			//# On a slope with left foot 8 higher than right
+	ENUM2STRING(LEGS_LEFTUP3),			//# On a slope with left foot 12 higher than right
+	ENUM2STRING(LEGS_LEFTUP4),			//# On a slope with left foot 16 higher than right
+	ENUM2STRING(LEGS_LEFTUP5),			//# On a slope with left foot 20 higher than right
+	ENUM2STRING(LEGS_RIGHTUP1),			//# On a slope with RIGHT foot 4 higher than left
+	ENUM2STRING(LEGS_RIGHTUP2),			//# On a slope with RIGHT foot 8 higher than left
+	ENUM2STRING(LEGS_RIGHTUP3),			//# On a slope with RIGHT foot 12 higher than left
+	ENUM2STRING(LEGS_RIGHTUP4),			//# On a slope with RIGHT foot 16 higher than left
+	ENUM2STRING(LEGS_RIGHTUP5),			//# On a slope with RIGHT foot 20 higher than left
+	ENUM2STRING(LEGS_S1_LUP1),
+	ENUM2STRING(LEGS_S1_LUP2),
+	ENUM2STRING(LEGS_S1_LUP3),
+	ENUM2STRING(LEGS_S1_LUP4),
+	ENUM2STRING(LEGS_S1_LUP5),
+	ENUM2STRING(LEGS_S1_RUP1),
+	ENUM2STRING(LEGS_S1_RUP2),
+	ENUM2STRING(LEGS_S1_RUP3),
+	ENUM2STRING(LEGS_S1_RUP4),
+	ENUM2STRING(LEGS_S1_RUP5),
+	ENUM2STRING(LEGS_S3_LUP1),
+	ENUM2STRING(LEGS_S3_LUP2),
+	ENUM2STRING(LEGS_S3_LUP3),
+	ENUM2STRING(LEGS_S3_LUP4),
+	ENUM2STRING(LEGS_S3_LUP5),
+	ENUM2STRING(LEGS_S3_RUP1),
+	ENUM2STRING(LEGS_S3_RUP2),
+	ENUM2STRING(LEGS_S3_RUP3),
+	ENUM2STRING(LEGS_S3_RUP4),
+	ENUM2STRING(LEGS_S3_RUP5),
+	ENUM2STRING(LEGS_S4_LUP1),
+	ENUM2STRING(LEGS_S4_LUP2),
+	ENUM2STRING(LEGS_S4_LUP3),
+	ENUM2STRING(LEGS_S4_LUP4),
+	ENUM2STRING(LEGS_S4_LUP5),
+	ENUM2STRING(LEGS_S4_RUP1),
+	ENUM2STRING(LEGS_S4_RUP2),
+	ENUM2STRING(LEGS_S4_RUP3),
+	ENUM2STRING(LEGS_S4_RUP4),
+	ENUM2STRING(LEGS_S4_RUP5),
+	ENUM2STRING(LEGS_S5_LUP1),
+	ENUM2STRING(LEGS_S5_LUP2),
+	ENUM2STRING(LEGS_S5_LUP3),
+	ENUM2STRING(LEGS_S5_LUP4),
+	ENUM2STRING(LEGS_S5_LUP5),
+	ENUM2STRING(LEGS_S5_RUP1),
+	ENUM2STRING(LEGS_S5_RUP2),
+	ENUM2STRING(LEGS_S5_RUP3),
+	ENUM2STRING(LEGS_S5_RUP4),
+	ENUM2STRING(LEGS_S5_RUP5),
+	ENUM2STRING(LEGS_S6_LUP1),
+	ENUM2STRING(LEGS_S6_LUP2),
+	ENUM2STRING(LEGS_S6_LUP3),
+	ENUM2STRING(LEGS_S6_LUP4),
+	ENUM2STRING(LEGS_S6_LUP5),
+	ENUM2STRING(LEGS_S6_RUP1),
+	ENUM2STRING(LEGS_S6_RUP2),
+	ENUM2STRING(LEGS_S6_RUP3),
+	ENUM2STRING(LEGS_S6_RUP4),
+	ENUM2STRING(LEGS_S6_RUP5),
+	ENUM2STRING(LEGS_S7_LUP1),
+	ENUM2STRING(LEGS_S7_LUP2),
+	ENUM2STRING(LEGS_S7_LUP3),
+	ENUM2STRING(LEGS_S7_LUP4),
+	ENUM2STRING(LEGS_S7_LUP5),
+	ENUM2STRING(LEGS_S7_RUP1),
+	ENUM2STRING(LEGS_S7_RUP2),
+	ENUM2STRING(LEGS_S7_RUP3),
+	ENUM2STRING(LEGS_S7_RUP4),
+	ENUM2STRING(LEGS_S7_RUP5),
+
+	//New anim as per Jarrod's request
+	ENUM2STRING(LEGS_TURN180),
+
+	//======================================================
+	//cinematic anims
+	//======================================================
+	//# #sep BOTH_ CINEMATIC-ONLY
+	ENUM2STRING(BOTH_CIN_1),		//# Level specific cinematic 1
+	ENUM2STRING(BOTH_CIN_2),		//# Level specific cinematic 2
+	ENUM2STRING(BOTH_CIN_3),		//# Level specific cinematic 3
+	ENUM2STRING(BOTH_CIN_4),		//# Level specific cinematic 4
+	ENUM2STRING(BOTH_CIN_5),		//# Level specific cinematic 5
+	ENUM2STRING(BOTH_CIN_6),		//# Level specific cinematic 6
+	ENUM2STRING(BOTH_CIN_7),		//# Level specific cinematic 7
+	ENUM2STRING(BOTH_CIN_8),		//# Level specific cinematic 8
+	ENUM2STRING(BOTH_CIN_9),		//# Level specific cinematic 9
+	ENUM2STRING(BOTH_CIN_10),		//# Level specific cinematic 10
+	ENUM2STRING(BOTH_CIN_11),		//# Level specific cinematic 11
+	ENUM2STRING(BOTH_CIN_12),		//# Level specific cinematic 12
+	ENUM2STRING(BOTH_CIN_13),		//# Level specific cinematic 13
+	ENUM2STRING(BOTH_CIN_14),		//# Level specific cinematic 14
+	ENUM2STRING(BOTH_CIN_15),		//# Level specific cinematic 15
+	ENUM2STRING(BOTH_CIN_16),		//# Level specific cinematic 16
+	ENUM2STRING(BOTH_CIN_17),		//# Level specific cinematic 17
+	ENUM2STRING(BOTH_CIN_18),		//# Level specific cinematic 18
+	ENUM2STRING(BOTH_CIN_19),		//# Level specific cinematic 19
+	ENUM2STRING(BOTH_CIN_20),		//# Level specific cinematic 20
+	ENUM2STRING(BOTH_CIN_21),		//# Level specific cinematic 21
+	ENUM2STRING(BOTH_CIN_22),		//# Level specific cinematic 22
+	ENUM2STRING(BOTH_CIN_23),		//# Level specific cinematic 23
+	ENUM2STRING(BOTH_CIN_24),		//# Level specific cinematic 24
+	ENUM2STRING(BOTH_CIN_25),		//# Level specific cinematic 25
+
+	ENUM2STRING(BOTH_CIN_26),		//# Level specific cinematic
+	ENUM2STRING(BOTH_CIN_27),		//# Level specific cinematic
+	ENUM2STRING(BOTH_CIN_28),		//# Level specific cinematic
+	ENUM2STRING(BOTH_CIN_29),		//# Level specific cinematic
+	ENUM2STRING(BOTH_CIN_30),		//# Level specific cinematic
+	ENUM2STRING(BOTH_CIN_31),		//# Level specific cinematic
+	ENUM2STRING(BOTH_CIN_32),		//# Level specific cinematic
+	ENUM2STRING(BOTH_CIN_33),		//# Level specific cinematic
+	ENUM2STRING(BOTH_CIN_34),		//# Level specific cinematic
+	ENUM2STRING(BOTH_CIN_35),		//# Level specific cinematic
+	ENUM2STRING(BOTH_CIN_36),		//# Level specific cinematic
+	ENUM2STRING(BOTH_CIN_37),		//# Level specific cinematic
+	ENUM2STRING(BOTH_CIN_38),		//# Level specific cinematic
+	ENUM2STRING(BOTH_CIN_39),		//# Level specific cinematic
+	ENUM2STRING(BOTH_CIN_40),		//# Level specific cinematic
+	ENUM2STRING(BOTH_CIN_41),		//# Level specific cinematic
+	ENUM2STRING(BOTH_CIN_42),		//# Level specific cinematic
+	ENUM2STRING(BOTH_CIN_43),		//# Level specific cinematic
+	ENUM2STRING(BOTH_CIN_44),		//# Level specific cinematic
+	ENUM2STRING(BOTH_CIN_45),		//# Level specific cinematic
+	ENUM2STRING(BOTH_CIN_46),		//# Level specific cinematic
+	ENUM2STRING(BOTH_CIN_47),		//# Level specific cinematic
+	ENUM2STRING(BOTH_CIN_48),		//# Level specific cinematic
+	ENUM2STRING(BOTH_CIN_49),		//# Level specific cinematic
+	ENUM2STRING(BOTH_CIN_50),		//# Level specific cinematic
+										
+	//must be terminated
+	NULL,-1
+};
+#endif	// _XBOX / _UI
diff --git a/codemp/cgame/asm2mak.cfg b/codemp/cgame/asm2mak.cfg
new file mode 100644
index 0000000..343aa91
--- /dev/null
+++ b/codemp/cgame/asm2mak.cfg
@@ -0,0 +1,36 @@
+;Do not add whitespaces outside the value quotes or change the formatting. The parser is sensitive.
+cgame:
+{
+ReleaseFolder="../Release/JK2cgame"
+CompileFlags="-DQ3_VM -DMISSIONPACK -DCGAME -D_FINAL -S -Wf-target=bytecode -Wf-g -I..\game  -I..\cgame -I..\ui"
+SysMaker="cg_public.h cg_syscalls.c vm/cg_syscalls.asm"
+StripPrepend="vm/"
+CompileFolder="vm"
+SkipFile="cg_syscalls"
+OverridePath="bg_lib,../game/bg_lib"
+OverridePath="bg_misc,../game/bg_misc"
+OverridePath="bg_panimate,../game/bg_panimate"
+OverridePath="bg_pmove,../game/bg_pmove"
+OverridePath="bg_saber,../game/bg_saber"
+OverridePath="bg_saberLoad,../game/bg_saberLoad"
+OverridePath="bg_saga,../game/bg_saga"
+OverridePath="bg_slidemove,../game/bg_slidemove"
+OverridePath="bg_vehicleLoad,../game/bg_vehicleLoad"
+OverridePath="bg_weapons,../game/bg_weapons"
+OverridePath="q_math,../game/q_math"
+OverridePath="q_shared,../game/q_shared"
+OverridePath="ui_shared,../ui/ui_shared"
+OverrideDep="bg_lib,../game/bg_lib.c"
+OverrideDep="bg_misc,../Release/JK2game/bg_misc.obj"
+OverrideDep="bg_panimate,../Release/JK2game/bg_panimate.obj"
+OverrideDep="bg_pmove,../Release/JK2game/bg_pmove.obj"
+OverrideDep="bg_saber,../Release/JK2game/bg_saber.obj"
+OverrideDep="bg_saberLoad,../Release/JK2game/bg_saberLoad.obj"
+OverrideDep="bg_saga,../Release/JK2game/bg_saga.obj"
+OverrideDep="bg_slidemove,../Release/JK2game/bg_slidemove.obj"
+OverrideDep="bg_vehicleLoad,../Release/JK2game/bg_vehicleLoad.obj"
+OverrideDep="bg_weapons,../Release/JK2game/bg_weapons.obj"
+OverrideDep="q_math,../Release/JK2game/q_math.obj"
+OverrideDep="q_shared,../Release/JK2game/q_shared.obj"
+OverrideDep="ui_shared,../Release/ui/ui_shared.obj"
+}
diff --git a/codemp/cgame/cg_consolecmds.c b/codemp/cgame/cg_consolecmds.c
new file mode 100644
index 0000000..c063cdf
--- /dev/null
+++ b/codemp/cgame/cg_consolecmds.c
@@ -0,0 +1,391 @@
+// Copyright (C) 1999-2000 Id Software, Inc.
+//
+// cg_consolecmds.c -- text commands typed in at the local console, or
+// executed by a key binding
+
+#include "cg_local.h"
+#include "../ui/ui_shared.h"
+#include "bg_saga.h"
+extern menuDef_t *menuScoreboard;
+
+
+
+void CG_TargetCommand_f( void ) {
+	int		targetNum;
+	char	test[4];
+
+	targetNum = CG_CrosshairPlayer();
+	if (!targetNum ) {
+		return;
+	}
+
+	trap_Argv( 1, test, 4 );
+	trap_SendConsoleCommand( va( "gc %i %i", targetNum, atoi( test ) ) );
+}
+
+
+
+/*
+=================
+CG_SizeUp_f
+
+Keybinding command
+=================
+*/
+static void CG_SizeUp_f (void) {
+	trap_Cvar_Set("cg_viewsize", va("%i",(int)(cg_viewsize.integer+10)));
+}
+
+
+/*
+=================
+CG_SizeDown_f
+
+Keybinding command
+=================
+*/
+static void CG_SizeDown_f (void) {
+	trap_Cvar_Set("cg_viewsize", va("%i",(int)(cg_viewsize.integer-10)));
+}
+
+
+/*
+=============
+CG_Viewpos_f
+
+Debugging command to print the current position
+=============
+*/
+static void CG_Viewpos_f (void) {
+	CG_Printf ("%s (%i %i %i) : %i\n", cgs.mapname, (int)cg.refdef.vieworg[0],
+		(int)cg.refdef.vieworg[1], (int)cg.refdef.vieworg[2], 
+		(int)cg.refdef.viewangles[YAW]);
+}
+
+
+static void CG_ScoresDown_f( void ) {
+
+	CG_BuildSpectatorString();
+	if ( cg.scoresRequestTime + 2000 < cg.time ) {
+		// the scores are more than two seconds out of data,
+		// so request new ones
+		cg.scoresRequestTime = cg.time;
+		trap_SendClientCommand( "score" );
+
+		// leave the current scores up if they were already
+		// displayed, but if this is the first hit, clear them out
+		if ( !cg.showScores ) {
+			cg.showScores = qtrue;
+			cg.numScores = 0;
+		}
+	} else {
+		// show the cached contents even if they just pressed if it
+		// is within two seconds
+		cg.showScores = qtrue;
+	}
+}
+
+static void CG_ScoresUp_f( void ) {
+	if ( cg.showScores ) {
+		cg.showScores = qfalse;
+		cg.scoreFadeTime = cg.time;
+	}
+}
+
+extern menuDef_t *menuScoreboard;
+void Menu_Reset();			// FIXME: add to right include file
+
+static void CG_scrollScoresDown_f( void) {
+	if (menuScoreboard && cg.scoreBoardShowing) {
+		Menu_ScrollFeeder(menuScoreboard, FEEDER_SCOREBOARD, qtrue);
+		Menu_ScrollFeeder(menuScoreboard, FEEDER_REDTEAM_LIST, qtrue);
+		Menu_ScrollFeeder(menuScoreboard, FEEDER_BLUETEAM_LIST, qtrue);
+	}
+}
+
+
+static void CG_scrollScoresUp_f( void) {
+	if (menuScoreboard && cg.scoreBoardShowing) {
+		Menu_ScrollFeeder(menuScoreboard, FEEDER_SCOREBOARD, qfalse);
+		Menu_ScrollFeeder(menuScoreboard, FEEDER_REDTEAM_LIST, qfalse);
+		Menu_ScrollFeeder(menuScoreboard, FEEDER_BLUETEAM_LIST, qfalse);
+	}
+}
+
+
+static void CG_spWin_f( void) {
+	trap_Cvar_Set("cg_cameraOrbit", "2");
+	trap_Cvar_Set("cg_cameraOrbitDelay", "35");
+	trap_Cvar_Set("cg_thirdPerson", "1");
+	trap_Cvar_Set("cg_thirdPersonAngle", "0");
+	trap_Cvar_Set("cg_thirdPersonRange", "100");
+	CG_AddBufferedSound(cgs.media.winnerSound);
+	//trap_S_StartLocalSound(cgs.media.winnerSound, CHAN_ANNOUNCER);
+	CG_CenterPrint(CG_GetStringEdString("MP_INGAME", "YOU_WIN"), SCREEN_HEIGHT * .30, 0);
+}
+
+static void CG_spLose_f( void) {
+	trap_Cvar_Set("cg_cameraOrbit", "2");
+	trap_Cvar_Set("cg_cameraOrbitDelay", "35");
+	trap_Cvar_Set("cg_thirdPerson", "1");
+	trap_Cvar_Set("cg_thirdPersonAngle", "0");
+	trap_Cvar_Set("cg_thirdPersonRange", "100");
+	CG_AddBufferedSound(cgs.media.loserSound);
+	//trap_S_StartLocalSound(cgs.media.loserSound, CHAN_ANNOUNCER);
+	CG_CenterPrint(CG_GetStringEdString("MP_INGAME", "YOU_LOSE"), SCREEN_HEIGHT * .30, 0);
+}
+
+
+static void CG_TellTarget_f( void ) {
+	int		clientNum;
+	char	command[128];
+	char	message[128];
+
+	clientNum = CG_CrosshairPlayer();
+	if ( clientNum == -1 ) {
+		return;
+	}
+
+	trap_Args( message, 128 );
+	Com_sprintf( command, 128, "tell %i %s", clientNum, message );
+	trap_SendClientCommand( command );
+}
+
+static void CG_TellAttacker_f( void ) {
+	int		clientNum;
+	char	command[128];
+	char	message[128];
+
+	clientNum = CG_LastAttacker();
+	if ( clientNum == -1 ) {
+		return;
+	}
+
+	trap_Args( message, 128 );
+	Com_sprintf( command, 128, "tell %i %s", clientNum, message );
+	trap_SendClientCommand( command );
+}
+
+
+/*
+==================
+CG_StartOrbit_f
+==================
+*/
+
+static void CG_StartOrbit_f( void ) {
+	char var[MAX_TOKEN_CHARS];
+
+	trap_Cvar_VariableStringBuffer( "developer", var, sizeof( var ) );
+	if ( !atoi(var) ) {
+		return;
+	}
+	if (cg_cameraOrbit.value != 0) {
+		trap_Cvar_Set ("cg_cameraOrbit", "0");
+		trap_Cvar_Set("cg_thirdPerson", "0");
+	} else {
+		trap_Cvar_Set("cg_cameraOrbit", "5");
+		trap_Cvar_Set("cg_thirdPerson", "1");
+		trap_Cvar_Set("cg_thirdPersonAngle", "0");
+		trap_Cvar_Set("cg_thirdPersonRange", "100");
+	}
+}
+
+void CG_SiegeBriefingDisplay(int team, int dontshow);
+static void CG_SiegeBriefing_f(void)
+{
+	int team;
+
+	if (cgs.gametype != GT_SIEGE)
+	{ //Cannot be displayed unless in this gametype
+		return;
+	}
+
+	team = cg.predictedPlayerState.persistant[PERS_TEAM];
+
+	if (team != SIEGETEAM_TEAM1 &&
+		team != SIEGETEAM_TEAM2)
+	{ //cannot be displayed if not on a valid team
+		return;
+	}
+
+	CG_SiegeBriefingDisplay(team, 0);
+}
+
+static void CG_SiegeCvarUpdate_f(void)
+{
+	int team;
+
+	if (cgs.gametype != GT_SIEGE)
+	{ //Cannot be displayed unless in this gametype
+		return;
+	}
+
+	team = cg.predictedPlayerState.persistant[PERS_TEAM];
+
+	if (team != SIEGETEAM_TEAM1 &&
+		team != SIEGETEAM_TEAM2)
+	{ //cannot be displayed if not on a valid team
+		return;
+	}
+
+	CG_SiegeBriefingDisplay(team, 1);
+}
+static void CG_SiegeCompleteCvarUpdate_f(void)
+{
+
+	if (cgs.gametype != GT_SIEGE)
+	{ //Cannot be displayed unless in this gametype
+		return;
+	}
+
+	// Set up cvars for both teams
+	CG_SiegeBriefingDisplay(SIEGETEAM_TEAM1, 1);
+	CG_SiegeBriefingDisplay(SIEGETEAM_TEAM2, 1);
+}
+/*
+static void CG_Camera_f( void ) {
+	char name[1024];
+	trap_Argv( 1, name, sizeof(name));
+	if (trap_loadCamera(name)) {
+		cg.cameraMode = qtrue;
+		trap_startCamera(cg.time);
+	} else {
+		CG_Printf ("Unable to load camera %s\n",name);
+	}
+}
+*/
+
+
+typedef struct {
+	char	*cmd;
+	void	(*function)(void);
+} consoleCommand_t;
+
+static consoleCommand_t	commands[] = {
+	{ "testgun", CG_TestGun_f },
+	{ "testmodel", CG_TestModel_f },
+	{ "nextframe", CG_TestModelNextFrame_f },
+	{ "prevframe", CG_TestModelPrevFrame_f },
+	{ "nextskin", CG_TestModelNextSkin_f },
+	{ "prevskin", CG_TestModelPrevSkin_f },
+	{ "viewpos", CG_Viewpos_f },
+	{ "+scores", CG_ScoresDown_f },
+	{ "-scores", CG_ScoresUp_f },
+	{ "sizeup", CG_SizeUp_f },
+	{ "sizedown", CG_SizeDown_f },
+	{ "weapnext", CG_NextWeapon_f },
+	{ "weapprev", CG_PrevWeapon_f },
+	{ "weapon", CG_Weapon_f },
+	{ "weaponclean", CG_WeaponClean_f },
+	{ "tell_target", CG_TellTarget_f },
+	{ "tell_attacker", CG_TellAttacker_f },
+	{ "tcmd", CG_TargetCommand_f },
+	{ "spWin", CG_spWin_f },
+	{ "spLose", CG_spLose_f },
+	{ "scoresDown", CG_scrollScoresDown_f },
+	{ "scoresUp", CG_scrollScoresUp_f },
+	{ "startOrbit", CG_StartOrbit_f },
+	//{ "camera", CG_Camera_f },
+	{ "loaddeferred", CG_LoadDeferredPlayers },
+	{ "invnext", CG_NextInventory_f },
+	{ "invprev", CG_PrevInventory_f },
+	{ "forcenext", CG_NextForcePower_f },
+	{ "forceprev", CG_PrevForcePower_f },
+	{ "briefing", CG_SiegeBriefing_f },
+	{ "siegeCvarUpdate", CG_SiegeCvarUpdate_f },
+	{ "siegeCompleteCvarUpdate", CG_SiegeCompleteCvarUpdate_f },
+};
+
+
+/*
+=================
+CG_ConsoleCommand
+
+The string has been tokenized and can be retrieved with
+Cmd_Argc() / Cmd_Argv()
+=================
+*/
+qboolean CG_ConsoleCommand( void ) {
+	const char	*cmd;
+	int		i;
+
+	cmd = CG_Argv(0);
+
+	for ( i = 0 ; i < sizeof( commands ) / sizeof( commands[0] ) ; i++ ) {
+		if ( !Q_stricmp( cmd, commands[i].cmd ) ) {
+			commands[i].function();
+			return qtrue;
+		}
+	}
+
+	return qfalse;
+}
+
+
+/*
+=================
+CG_InitConsoleCommands
+
+Let the client system know about all of our commands
+so it can perform tab completion
+=================
+*/
+void CG_InitConsoleCommands( void ) {
+	int		i;
+
+	for ( i = 0 ; i < sizeof( commands ) / sizeof( commands[0] ) ; i++ ) {
+		trap_AddCommand( commands[i].cmd );
+	}
+
+	//
+	// the game server will interpret these commands, which will be automatically
+	// forwarded to the server after they are not recognized locally
+	//
+	trap_AddCommand ("forcechanged");
+	trap_AddCommand ("sv_invnext");
+	trap_AddCommand ("sv_invprev");
+	trap_AddCommand ("sv_forcenext");
+	trap_AddCommand ("sv_forceprev");
+	trap_AddCommand ("sv_saberswitch");
+	trap_AddCommand ("engage_duel");
+	trap_AddCommand ("force_heal");
+	trap_AddCommand ("force_speed");
+	trap_AddCommand ("force_throw");
+	trap_AddCommand ("force_pull");
+	trap_AddCommand ("force_distract");
+	trap_AddCommand ("force_rage");
+	trap_AddCommand ("force_protect");
+	trap_AddCommand ("force_absorb");
+	trap_AddCommand ("force_healother");
+	trap_AddCommand ("force_forcepowerother");
+	trap_AddCommand ("force_seeing");
+	trap_AddCommand ("use_seeker");
+	trap_AddCommand ("use_field");
+	trap_AddCommand ("use_bacta");
+	trap_AddCommand ("use_electrobinoculars");
+	trap_AddCommand ("zoom");
+	trap_AddCommand ("use_sentry");
+	trap_AddCommand ("bot_order");
+	trap_AddCommand ("saberAttackCycle");
+	trap_AddCommand ("kill");
+	trap_AddCommand ("say");
+	trap_AddCommand ("say_team");
+	trap_AddCommand ("tell");
+	trap_AddCommand ("give");
+	trap_AddCommand ("god");
+	trap_AddCommand ("notarget");
+	trap_AddCommand ("noclip");
+	trap_AddCommand ("team");
+	trap_AddCommand ("follow");
+	trap_AddCommand ("levelshot");
+	trap_AddCommand ("addbot");
+	trap_AddCommand ("setviewpos");
+	trap_AddCommand ("callvote");
+	trap_AddCommand ("vote");
+	trap_AddCommand ("callteamvote");
+	trap_AddCommand ("teamvote");
+	trap_AddCommand ("stats");
+	trap_AddCommand ("teamtask");
+	trap_AddCommand ("loaddefered");	// spelled wrong, but not changing for demo
+}
diff --git a/codemp/cgame/cg_draw.c b/codemp/cgame/cg_draw.c
new file mode 100644
index 0000000..8986c27
--- /dev/null
+++ b/codemp/cgame/cg_draw.c
@@ -0,0 +1,8468 @@
+// Copyright (C) 1999-2000 Id Software, Inc.
+//
+// cg_draw.c -- draw all of the graphical elements during
+// active (after loading) gameplay
+
+#include "cg_local.h"
+
+#include "bg_saga.h"
+
+#include "../ui/ui_shared.h"
+#include "../ui/ui_public.h"
+
+extern float CG_RadiusForCent( centity_t *cent );
+qboolean CG_WorldCoordToScreenCoordFloat(vec3_t worldCoord, float *x, float *y);
+qboolean CG_CalcMuzzlePoint( int entityNum, vec3_t muzzle );
+static void CG_DrawSiegeTimer(int timeRemaining, qboolean isMyTeam);
+static void CG_DrawSiegeDeathTimer( int timeRemaining );
+// nmckenzie: DUEL_HEALTH
+void CG_DrawDuelistHealth ( float x, float y, float w, float h, int duelist );
+
+// used for scoreboard
+extern displayContextDef_t cgDC;
+menuDef_t *menuScoreboard = NULL;
+vec4_t	bluehudtint = {0.5, 0.5, 1.0, 1.0};
+vec4_t	redhudtint = {1.0, 0.5, 0.5, 1.0};
+float	*hudTintColor;
+
+int sortedTeamPlayers[TEAM_MAXOVERLAY];
+int	numSortedTeamPlayers;
+
+int lastvalidlockdif;
+
+extern float zoomFov; //this has to be global client-side
+
+char systemChat[256];
+char teamChat1[256];
+char teamChat2[256];
+
+// The time at which you died and the time it will take for you to rejoin game.
+int cg_siegeDeathTime = 0;
+
+#define MAX_HUD_TICS 4
+const char *armorTicName[MAX_HUD_TICS] = 
+{
+"armor_tic1", 
+"armor_tic2", 
+"armor_tic3", 
+"armor_tic4", 
+};
+
+const char *healthTicName[MAX_HUD_TICS] = 
+{
+"health_tic1", 
+"health_tic2", 
+"health_tic3", 
+"health_tic4", 
+};
+
+const char *forceTicName[MAX_HUD_TICS] = 
+{
+"force_tic1", 
+"force_tic2", 
+"force_tic3", 
+"force_tic4", 
+};
+
+const char *ammoTicName[MAX_HUD_TICS] = 
+{
+"ammo_tic1", 
+"ammo_tic2", 
+"ammo_tic3", 
+"ammo_tic4", 
+};
+
+char *showPowersName[] = 
+{
+	"HEAL2",//FP_HEAL
+	"JUMP2",//FP_LEVITATION
+	"SPEED2",//FP_SPEED
+	"PUSH2",//FP_PUSH
+	"PULL2",//FP_PULL
+	"MINDTRICK2",//FP_TELEPTAHY
+	"GRIP2",//FP_GRIP
+	"LIGHTNING2",//FP_LIGHTNING
+	"DARK_RAGE2",//FP_RAGE
+	"PROTECT2",//FP_PROTECT
+	"ABSORB2",//FP_ABSORB
+	"TEAM_HEAL2",//FP_TEAM_HEAL
+	"TEAM_REPLENISH2",//FP_TEAM_FORCE
+	"DRAIN2",//FP_DRAIN
+	"SEEING2",//FP_SEE
+	"SABER_OFFENSE2",//FP_SABER_OFFENSE
+	"SABER_DEFENSE2",//FP_SABER_DEFENSE
+	"SABER_THROW2",//FP_SABERTHROW
+	NULL
+};
+
+//Called from UI shared code. For now we'll just redirect to the normal anim load function.
+#include "../namespace_begin.h"
+
+
+int UI_ParseAnimationFile(const char *filename, animation_t *animset, qboolean isHumanoid) 
+{
+	return BG_ParseAnimationFile(filename, animset, isHumanoid);
+}
+
+int MenuFontToHandle(int iMenuFont)
+{
+	switch (iMenuFont)
+	{
+		case FONT_SMALL:	return cgDC.Assets.qhSmallFont;
+		case FONT_SMALL2:	return cgDC.Assets.qhSmall2Font;
+		case FONT_MEDIUM:	return cgDC.Assets.qhMediumFont;
+		case FONT_LARGE:	return cgDC.Assets.qhMediumFont;//cgDC.Assets.qhBigFont;
+			//fixme? Big fonr isn't registered...?
+	}
+
+	return cgDC.Assets.qhMediumFont;
+}
+
+#include "../namespace_end.h"
+
+int CG_Text_Width(const char *text, float scale, int iMenuFont) 
+{
+	int iFontIndex = MenuFontToHandle(iMenuFont);
+
+	return trap_R_Font_StrLenPixels(text, iFontIndex, scale);
+}
+
+int CG_Text_Height(const char *text, float scale, int iMenuFont) 
+{
+	int iFontIndex = MenuFontToHandle(iMenuFont);
+
+	return trap_R_Font_HeightPixels(iFontIndex, scale);
+}
+
+#include "../qcommon/qfiles.h"	// for STYLE_BLINK etc
+void CG_Text_Paint(float x, float y, float scale, vec4_t color, const char *text, float adjust, int limit, int style, int iMenuFont) 
+{
+	int iStyleOR = 0;
+	int iFontIndex = MenuFontToHandle(iMenuFont);
+	
+	switch (style)
+	{
+	case  ITEM_TEXTSTYLE_NORMAL:			iStyleOR = 0;break;					// JK2 normal text
+	case  ITEM_TEXTSTYLE_BLINK:				iStyleOR = STYLE_BLINK;break;		// JK2 fast blinking
+	case  ITEM_TEXTSTYLE_PULSE:				iStyleOR = STYLE_BLINK;break;		// JK2 slow pulsing
+	case  ITEM_TEXTSTYLE_SHADOWED:			iStyleOR = (int)STYLE_DROPSHADOW;break;	// JK2 drop shadow ( need a color for this )
+	case  ITEM_TEXTSTYLE_OUTLINED:			iStyleOR = (int)STYLE_DROPSHADOW;break;	// JK2 drop shadow ( need a color for this )
+	case  ITEM_TEXTSTYLE_OUTLINESHADOWED:	iStyleOR = (int)STYLE_DROPSHADOW;break;	// JK2 drop shadow ( need a color for this )
+	case  ITEM_TEXTSTYLE_SHADOWEDMORE:		iStyleOR = (int)STYLE_DROPSHADOW;break;	// JK2 drop shadow ( need a color for this )
+	}
+
+	trap_R_Font_DrawString(	x,		// int ox
+							y,		// int oy
+							text,	// const char *text
+							color,	// paletteRGBA_c c
+							iStyleOR | iFontIndex,	// const int iFontHandle
+							!limit?-1:limit,		// iCharLimit (-1 = none)
+							scale	// const float scale = 1.0f
+							);
+}
+
+/*
+qboolean CG_WorldCoordToScreenCoord(vec3_t worldCoord, int *x, int *y)
+
+  Take any world coord and convert it to a 2D virtual 640x480 screen coord
+*/
+/*
+qboolean CG_WorldCoordToScreenCoordFloat(vec3_t worldCoord, float *x, float *y)
+{
+	int	xcenter, ycenter;
+	vec3_t	local, transformed;
+
+//	xcenter = cg.refdef.width / 2;//gives screen coords adjusted for resolution
+//	ycenter = cg.refdef.height / 2;//gives screen coords adjusted for resolution
+	
+	//NOTE: did it this way because most draw functions expect virtual 640x480 coords
+	//	and adjust them for current resolution
+	xcenter = 640 / 2;//gives screen coords in virtual 640x480, to be adjusted when drawn
+	ycenter = 480 / 2;//gives screen coords in virtual 640x480, to be adjusted when drawn
+
+	VectorSubtract (worldCoord, cg.refdef.vieworg, local);
+
+	transformed[0] = DotProduct(local,vright);
+	transformed[1] = DotProduct(local,vup);
+	transformed[2] = DotProduct(local,vfwd);		
+
+	// Make sure Z is not negative.
+	if(transformed[2] < 0.01)
+	{
+		return qfalse;
+	}
+	// Simple convert to screen coords.
+	float xzi = xcenter / transformed[2] * (90.0/cg.refdef.fov_x);
+	float yzi = ycenter / transformed[2] * (90.0/cg.refdef.fov_y);
+
+	*x = xcenter + xzi * transformed[0];
+	*y = ycenter - yzi * transformed[1];
+
+	return qtrue;
+}
+
+qboolean CG_WorldCoordToScreenCoord( vec3_t worldCoord, int *x, int *y )
+{
+	float	xF, yF;
+	qboolean retVal = CG_WorldCoordToScreenCoordFloat( worldCoord, &xF, &yF );
+	*x = (int)xF;
+	*y = (int)yF;
+	return retVal;
+}
+*/
+
+/*
+================
+CG_DrawZoomMask
+
+================
+*/
+static void CG_DrawZoomMask( void )
+{
+	vec4_t		color1;
+	float		level;
+	static qboolean	flip = qtrue;
+
+//	int ammo = cg_entities[0].gent->client->ps.ammo[weaponData[cent->currentState.weapon].ammoIndex];
+	float cx, cy;
+//	int val[5];
+	float max, fi;
+
+	// Check for Binocular specific zooming since we'll want to render different bits in each case
+	if ( cg.predictedPlayerState.zoomMode == 2 )
+	{
+		int val, i;
+		float off;
+
+		// zoom level
+		level = (float)(80.0f - cg.predictedPlayerState.zoomFov) / 80.0f;
+
+		// ...so we'll clamp it
+		if ( level < 0.0f )
+		{
+			level = 0.0f;
+		}
+		else if ( level > 1.0f )
+		{
+			level = 1.0f;
+		}
+
+		// Using a magic number to convert the zoom level to scale amount
+		level *= 162.0f;
+
+		// draw blue tinted distortion mask, trying to make it as small as is necessary to fill in the viewable area
+		trap_R_SetColor( colorTable[CT_WHITE] );
+		CG_DrawPic( 34, 48, 570, 362, cgs.media.binocularStatic );
+	
+		// Black out the area behind the numbers
+		trap_R_SetColor( colorTable[CT_BLACK]);
+		CG_DrawPic( 212, 367, 200, 40, cgs.media.whiteShader );
+
+		// Numbers should be kind of greenish
+		color1[0] = 0.2f;
+		color1[1] = 0.4f;
+		color1[2] = 0.2f;
+		color1[3] = 0.3f;
+		trap_R_SetColor( color1 );
+
+		// Draw scrolling numbers, use intervals 10 units apart--sorry, this section of code is just kind of hacked
+		//	up with a bunch of magic numbers.....
+		val = ((int)((cg.refdef.viewangles[YAW] + 180) / 10)) * 10;
+		off = (cg.refdef.viewangles[YAW] + 180) - val;
+
+		for ( i = -10; i < 30; i += 10 )
+		{
+			val -= 10;
+
+			if ( val < 0 )
+			{
+				val += 360;
+			}
+
+			// we only want to draw the very far left one some of the time, if it's too far to the left it will
+			//	poke outside the mask.
+			if (( off > 3.0f && i == -10 ) || i > -10 )
+			{
+				// draw the value, but add 200 just to bump the range up...arbitrary, so change it if you like
+				CG_DrawNumField( 155 + i * 10 + off * 10, 374, 3, val + 200, 24, 14, NUM_FONT_CHUNKY, qtrue );
+				CG_DrawPic( 245 + (i-1) * 10 + off * 10, 376, 6, 6, cgs.media.whiteShader );
+			}
+		}
+
+		CG_DrawPic( 212, 367, 200, 28, cgs.media.binocularOverlay );
+
+		color1[0] = sin( cg.time * 0.01f ) * 0.5f + 0.5f;
+		color1[0] = color1[0] * color1[0];
+		color1[1] = color1[0];
+		color1[2] = color1[0];
+		color1[3] = 1.0f;
+
+		trap_R_SetColor( color1 );
+
+		CG_DrawPic( 82, 94, 16, 16, cgs.media.binocularCircle );
+
+		// Flickery color
+		color1[0] = 0.7f + crandom() * 0.1f;
+		color1[1] = 0.8f + crandom() * 0.1f;
+		color1[2] = 0.7f + crandom() * 0.1f;
+		color1[3] = 1.0f;
+		trap_R_SetColor( color1 );
+	
+		CG_DrawPic( 0, 0, 640, 480, cgs.media.binocularMask );
+
+		CG_DrawPic( 4, 282 - level, 16, 16, cgs.media.binocularArrow );
+
+		// The top triangle bit randomly flips 
+		if ( flip )
+		{
+			CG_DrawPic( 330, 60, -26, -30, cgs.media.binocularTri );
+		}
+		else
+		{
+			CG_DrawPic( 307, 40, 26, 30, cgs.media.binocularTri );
+		}
+
+		if ( random() > 0.98f && ( cg.time & 1024 ))
+		{
+			flip = !flip;
+		}
+	}
+	else if ( cg.predictedPlayerState.zoomMode)
+	{
+		// disruptor zoom mode
+		level = (float)(50.0f - zoomFov) / 50.0f;//(float)(80.0f - zoomFov) / 80.0f;
+
+		// ...so we'll clamp it
+		if ( level < 0.0f )
+		{
+			level = 0.0f;
+		}
+		else if ( level > 1.0f )
+		{
+			level = 1.0f;
+		}
+
+		// Using a magic number to convert the zoom level to a rotation amount that correlates more or less with the zoom artwork. 
+		level *= 103.0f;
+
+		// Draw target mask
+		trap_R_SetColor( colorTable[CT_WHITE] );
+		CG_DrawPic( 0, 0, 640, 480, cgs.media.disruptorMask );
+
+		// apparently 99.0f is the full zoom level
+		if ( level >= 99 )
+		{
+			// Fully zoomed, so make the rotating insert pulse
+			color1[0] = 1.0f; 
+			color1[1] = 1.0f;
+			color1[2] = 1.0f;
+			color1[3] = 0.7f + sin( cg.time * 0.01f ) * 0.3f;
+
+			trap_R_SetColor( color1 );
+		}
+
+		// Draw rotating insert
+		CG_DrawRotatePic2( 320, 240, 640, 480, -level, cgs.media.disruptorInsert );
+
+		// Increase the light levels under the center of the target
+//		CG_DrawPic( 198, 118, 246, 246, cgs.media.disruptorLight );
+
+		// weirdness.....converting ammo to a base five number scale just to be geeky.
+/*		val[0] = ammo % 5;
+		val[1] = (ammo / 5) % 5;
+		val[2] = (ammo / 25) % 5;
+		val[3] = (ammo / 125) % 5;
+		val[4] = (ammo / 625) % 5;
+		
+		color1[0] = 0.2f;
+		color1[1] = 0.55f + crandom() * 0.1f;
+		color1[2] = 0.5f + crandom() * 0.1f;
+		color1[3] = 1.0f;
+		trap_R_SetColor( color1 );
+
+		for ( int t = 0; t < 5; t++ )
+		{
+			cx = 320 + sin( (t*10+45)/57.296f ) * 192;
+			cy = 240 + cos( (t*10+45)/57.296f ) * 192;
+
+			CG_DrawRotatePic2( cx, cy, 24, 38, 45 - t * 10, trap_R_RegisterShader( va("gfx/2d/char%d",val[4-t] )));
+		}
+*/
+		//max = ( cg_entities[0].gent->health / 100.0f );
+
+		
+		if ( (cg.snap->ps.eFlags & EF_DOUBLE_AMMO) )
+		{
+			max = cg.snap->ps.ammo[weaponData[WP_DISRUPTOR].ammoIndex] / ((float)ammoData[weaponData[WP_DISRUPTOR].ammoIndex].max*2.0f);
+		}
+		else
+		{
+			max = cg.snap->ps.ammo[weaponData[WP_DISRUPTOR].ammoIndex] / (float)ammoData[weaponData[WP_DISRUPTOR].ammoIndex].max;
+		}
+		if ( max > 1.0f )
+		{
+			max = 1.0f;
+		}
+
+		color1[0] = (1.0f - max) * 2.0f; 
+		color1[1] = max * 1.5f;
+		color1[2] = 0.0f;
+		color1[3] = 1.0f;
+
+		// If we are low on health, make us flash
+		if ( max < 0.15f && ( cg.time & 512 ))
+		{
+			VectorClear( color1 );
+		}
+
+		if ( color1[0] > 1.0f )
+		{
+			color1[0] = 1.0f;
+		}
+
+		if ( color1[1] > 1.0f )
+		{
+			color1[1] = 1.0f;
+		}
+
+		trap_R_SetColor( color1 );
+
+		max *= 58.0f;
+
+		for (fi = 18.5f; fi <= 18.5f + max; fi+= 3 ) // going from 15 to 45 degrees, with 5 degree increments
+		{
+			cx = 320 + sin( (fi+90.0f)/57.296f ) * 190;
+			cy = 240 + cos( (fi+90.0f)/57.296f ) * 190;
+
+			CG_DrawRotatePic2( cx, cy, 12, 24, 90 - fi, cgs.media.disruptorInsertTick );
+		}
+
+		if ( cg.predictedPlayerState.weaponstate == WEAPON_CHARGING_ALT )
+		{
+			trap_R_SetColor( colorTable[CT_WHITE] );
+
+			// draw the charge level
+			max = ( cg.time - cg.predictedPlayerState.weaponChargeTime ) / ( 50.0f * 30.0f ); // bad hardcodedness 50 is disruptor charge unit and 30 is max charge units allowed.
+
+			if ( max > 1.0f )
+			{
+				max = 1.0f;
+			}
+
+			trap_R_DrawStretchPic(257, 435, 134*max, 34, 0, 0, max, 1, cgs.media.disruptorChargeShader);
+		}
+//		trap_R_SetColor( colorTable[CT_WHITE] );
+//		CG_DrawPic( 0, 0, 640, 480, cgs.media.disruptorMask );
+
+	}
+}
+
+
+/*
+================
+CG_Draw3DModel
+
+================
+*/
+void CG_Draw3DModel( float x, float y, float w, float h, qhandle_t model, void *ghoul2, int g2radius, qhandle_t skin, vec3_t origin, vec3_t angles ) {
+	refdef_t		refdef;
+	refEntity_t		ent;
+
+	if ( !cg_draw3dIcons.integer || !cg_drawIcons.integer ) {
+		return;
+	}
+
+	memset( &refdef, 0, sizeof( refdef ) );
+
+	memset( &ent, 0, sizeof( ent ) );
+	AnglesToAxis( angles, ent.axis );
+	VectorCopy( origin, ent.origin );
+	ent.hModel = model;
+	ent.ghoul2 = ghoul2;
+	ent.radius = g2radius;
+	ent.customSkin = skin;
+	ent.renderfx = RF_NOSHADOW;		// no stencil shadows
+
+	refdef.rdflags = RDF_NOWORLDMODEL;
+
+	AxisClear( refdef.viewaxis );
+
+	refdef.fov_x = 30;
+	refdef.fov_y = 30;
+
+	refdef.x = x;
+	refdef.y = y;
+	refdef.width = w;
+	refdef.height = h;
+
+	refdef.time = cg.time;
+
+	trap_R_ClearScene();
+	trap_R_AddRefEntityToScene( &ent );
+	trap_R_RenderScene( &refdef );
+}
+
+/*
+================
+CG_DrawHead
+
+Used for both the status bar and the scoreboard
+================
+*/
+void CG_DrawHead( float x, float y, float w, float h, int clientNum, vec3_t headAngles ) 
+{
+	clientInfo_t	*ci;
+
+	if (clientNum >= MAX_CLIENTS)
+	{ //npc?
+		return;
+	}
+
+	ci = &cgs.clientinfo[ clientNum ];
+
+	CG_DrawPic( x, y, w, h, ci->modelIcon );
+
+	// if they are deferred, draw a cross out
+	if ( ci->deferred ) 
+	{
+		CG_DrawPic( x, y, w, h, cgs.media.deferShader );
+	}
+}
+
+/*
+================
+CG_DrawFlagModel
+
+Used for both the status bar and the scoreboard
+================
+*/
+void CG_DrawFlagModel( float x, float y, float w, float h, int team, qboolean force2D ) {
+	qhandle_t		cm;
+	float			len;
+	vec3_t			origin, angles;
+	vec3_t			mins, maxs;
+	qhandle_t		handle;
+
+	if ( !force2D && cg_draw3dIcons.integer ) {
+
+		VectorClear( angles );
+
+		cm = cgs.media.redFlagModel;
+
+		// offset the origin y and z to center the flag
+		trap_R_ModelBounds( cm, mins, maxs );
+
+		origin[2] = -0.5 * ( mins[2] + maxs[2] );
+		origin[1] = 0.5 * ( mins[1] + maxs[1] );
+
+		// calculate distance so the flag nearly fills the box
+		// assume heads are taller than wide
+		len = 0.5 * ( maxs[2] - mins[2] );		
+		origin[0] = len / 0.268;	// len / tan( fov/2 )
+
+		angles[YAW] = 60 * sin( cg.time / 2000.0 );;
+
+		if( team == TEAM_RED ) {
+			handle = cgs.media.redFlagModel;
+		} else if( team == TEAM_BLUE ) {
+			handle = cgs.media.blueFlagModel;
+		} else if( team == TEAM_FREE ) {
+			handle = 0;//cgs.media.neutralFlagModel;
+		} else {
+			return;
+		}
+		CG_Draw3DModel( x, y, w, h, handle, NULL, 0, 0, origin, angles );
+	} else if ( cg_drawIcons.integer ) {
+		gitem_t *item;
+
+		if( team == TEAM_RED ) {
+			item = BG_FindItemForPowerup( PW_REDFLAG );
+		} else if( team == TEAM_BLUE ) {
+			item = BG_FindItemForPowerup( PW_BLUEFLAG );
+		} else if( team == TEAM_FREE ) {
+			item = BG_FindItemForPowerup( PW_NEUTRALFLAG );
+		} else {
+			return;
+		}
+		if (item) {
+		  CG_DrawPic( x, y, w, h, cg_items[ ITEM_INDEX(item) ].icon );
+		}
+	}
+}
+
+/*
+================
+DrawAmmo
+================
+*/
+void DrawAmmo()
+{
+	int x, y;
+
+	x = SCREEN_WIDTH-80;
+	y = SCREEN_HEIGHT-80;
+
+}
+
+
+
+/*
+================
+CG_DrawHealth
+================
+*/
+void CG_DrawHealth( menuDef_t *menuHUD )
+{
+	vec4_t			calcColor;
+	playerState_t	*ps;
+	int				healthAmt;
+	int				i,currValue,inc;
+	itemDef_t		*focusItem;
+	float percent;
+
+	// Can we find the menu?
+	if (!menuHUD)
+	{
+		return;
+	}
+
+	ps = &cg.snap->ps;
+
+	// What's the health?
+	healthAmt = ps->stats[STAT_HEALTH];
+	if (healthAmt > ps->stats[STAT_MAX_HEALTH])
+	{
+		healthAmt = ps->stats[STAT_MAX_HEALTH];
+	}
+
+
+	inc = (float) ps->stats[STAT_MAX_HEALTH] / MAX_HUD_TICS;
+	currValue = healthAmt;
+
+	// Print the health tics, fading out the one which is partial health
+	for (i=(MAX_HUD_TICS-1);i>=0;i--)
+	{
+		focusItem = Menu_FindItemByName(menuHUD, healthTicName[i]);
+
+		if (!focusItem)	// This is bad
+		{
+			continue;
+		}
+
+		memcpy(calcColor, hudTintColor, sizeof(vec4_t));
+
+		if (currValue <= 0)	// don't show tic
+		{
+			break;
+		}
+		else if (currValue < inc)	// partial tic (alpha it out)
+		{
+			percent = (float) currValue / inc;
+			calcColor[3] *= percent;		// Fade it out
+		}
+
+		trap_R_SetColor( calcColor);
+
+		CG_DrawPic( 
+			focusItem->window.rect.x,
+			focusItem->window.rect.y,
+			focusItem->window.rect.w, 
+			focusItem->window.rect.h, 
+			focusItem->window.background
+			);
+
+		currValue -= inc;
+	}
+
+	// Print the mueric amount
+	focusItem = Menu_FindItemByName(menuHUD, "healthamount");
+	if (focusItem)
+	{
+		// Print health amount
+		trap_R_SetColor( focusItem->window.foreColor );	
+
+		CG_DrawNumField (
+			focusItem->window.rect.x, 
+			focusItem->window.rect.y, 
+			3, 
+			ps->stats[STAT_HEALTH], 
+			focusItem->window.rect.w, 
+			focusItem->window.rect.h, 
+			NUM_FONT_SMALL,
+			qfalse);
+	}
+
+}
+
+/*
+================
+CG_DrawArmor
+================
+*/
+void CG_DrawArmor( menuDef_t *menuHUD )
+{
+	vec4_t			calcColor;
+	playerState_t	*ps;
+	int				armor, maxArmor;
+	itemDef_t		*focusItem;
+	float			percent,quarterArmor;
+	int				i,currValue,inc;
+
+	//ps = &cg.snap->ps;
+	ps = &cg.predictedPlayerState;
+
+	// Can we find the menu?
+	if (!menuHUD)
+	{
+		return;
+	}
+
+	armor = ps->stats[STAT_ARMOR];
+	maxArmor = ps->stats[STAT_MAX_HEALTH];
+
+	if (armor> maxArmor)
+	{
+		armor = maxArmor;
+	}
+
+	currValue = armor;
+	inc = (float) maxArmor / MAX_HUD_TICS;
+
+	memcpy(calcColor, hudTintColor, sizeof(vec4_t));
+	for (i=(MAX_HUD_TICS-1);i>=0;i--)
+	{
+		focusItem = Menu_FindItemByName(menuHUD, armorTicName[i]);
+
+		if (!focusItem)	// This is bad
+		{
+			continue;
+		}
+
+		memcpy(calcColor, hudTintColor, sizeof(vec4_t));
+
+		if (currValue <= 0)	// don't show tic
+		{
+			break;
+		}
+		else if (currValue < inc)	// partial tic (alpha it out)
+		{
+			percent = (float) currValue / inc;
+			calcColor[3] *= percent;
+		}
+
+		trap_R_SetColor( calcColor);
+
+		if ((i==(MAX_HUD_TICS-1)) && (currValue < inc))
+		{
+			if (cg.HUDArmorFlag)
+			{
+				CG_DrawPic( 
+					focusItem->window.rect.x,
+					focusItem->window.rect.y,
+					focusItem->window.rect.w, 
+					focusItem->window.rect.h, 
+					focusItem->window.background
+					);
+			}
+		}
+		else 
+		{
+				CG_DrawPic( 
+					focusItem->window.rect.x,
+					focusItem->window.rect.y,
+					focusItem->window.rect.w, 
+					focusItem->window.rect.h, 
+					focusItem->window.background
+					);
+		}
+
+		currValue -= inc;
+	}
+
+	focusItem = Menu_FindItemByName(menuHUD, "armoramount");
+
+	if (focusItem)
+	{
+		// Print armor amount
+		trap_R_SetColor( focusItem->window.foreColor );	
+
+		CG_DrawNumField (
+			focusItem->window.rect.x, 
+			focusItem->window.rect.y, 
+			3, 
+			armor, 
+			focusItem->window.rect.w, 
+			focusItem->window.rect.h, 
+			NUM_FONT_SMALL,
+			qfalse);
+	}
+
+	// If armor is low, flash a graphic to warn the player
+	if (armor)	// Is there armor? Draw the HUD Armor TIC
+	{
+		quarterArmor = (float) (ps->stats[STAT_MAX_HEALTH] / 4.0f);
+
+		// Make tic flash if armor is at 25% of full armor
+		if (ps->stats[STAT_ARMOR] < quarterArmor)		// Do whatever the flash timer says
+		{
+			if (cg.HUDTickFlashTime < cg.time)			// Flip at the same time
+			{
+				cg.HUDTickFlashTime = cg.time + 400;
+				if (cg.HUDArmorFlag)
+				{
+					cg.HUDArmorFlag = qfalse;
+				}
+				else
+				{
+					cg.HUDArmorFlag = qtrue;
+				}
+			}
+		}
+		else
+		{
+			cg.HUDArmorFlag=qtrue;
+		}
+	}
+	else						// No armor? Don't show it.
+	{
+		cg.HUDArmorFlag=qfalse;
+	}
+
+}
+
+/*
+================
+CG_DrawSaberStyle
+
+If the weapon is a light saber (which needs no ammo) then draw a graphic showing
+the saber style (fast, medium, strong)
+================
+*/
+static void CG_DrawSaberStyle( centity_t *cent, menuDef_t *menuHUD)
+{
+	itemDef_t		*focusItem;
+
+	if (!cent->currentState.weapon ) // We don't have a weapon right now
+	{
+		return;
+	}
+
+	if ( cent->currentState.weapon != WP_SABER )
+	{
+		return;
+	}
+
+	// Can we find the menu?
+	if (!menuHUD)
+	{
+		return;
+	}
+
+
+	// draw the current saber style in this window
+	switch ( cg.predictedPlayerState.fd.saberDrawAnimLevel )
+	{
+	case 1://FORCE_LEVEL_1:
+	case 5://FORCE_LEVEL_5://Tavion
+
+		focusItem = Menu_FindItemByName(menuHUD, "saberstyle_fast");
+
+		if (focusItem)
+		{
+			trap_R_SetColor( hudTintColor );
+
+			CG_DrawPic( 
+				focusItem->window.rect.x,
+				focusItem->window.rect.y,
+				focusItem->window.rect.w, 
+				focusItem->window.rect.h, 
+				focusItem->window.background
+				);
+		}
+
+		break;
+	case 2://FORCE_LEVEL_2:
+	case 6://SS_DUAL
+	case 7://SS_STAFF
+		focusItem = Menu_FindItemByName(menuHUD, "saberstyle_medium");
+
+		if (focusItem)
+		{
+			trap_R_SetColor( hudTintColor );
+
+			CG_DrawPic( 
+				focusItem->window.rect.x,
+				focusItem->window.rect.y,
+				focusItem->window.rect.w, 
+				focusItem->window.rect.h, 
+				focusItem->window.background
+				);
+		}
+		break;
+	case 3://FORCE_LEVEL_3:
+	case 4://FORCE_LEVEL_4://Desann
+		focusItem = Menu_FindItemByName(menuHUD, "saberstyle_strong");
+
+		if (focusItem)
+		{
+			trap_R_SetColor( hudTintColor );
+
+			CG_DrawPic( 
+				focusItem->window.rect.x,
+				focusItem->window.rect.y,
+				focusItem->window.rect.w, 
+				focusItem->window.rect.h, 
+				focusItem->window.background
+				);
+		}
+		break;
+	}
+
+}
+
+/*
+================
+CG_DrawAmmo
+================
+*/
+static void CG_DrawAmmo( centity_t	*cent,menuDef_t *menuHUD)
+{
+	playerState_t	*ps;
+	int				i;
+	vec4_t			calcColor;
+	float			value,inc = 0.0f,percent;
+	itemDef_t		*focusItem;
+
+	ps = &cg.snap->ps;
+
+	// Can we find the menu?
+	if (!menuHUD)
+	{
+		return;
+	}
+
+	if (!cent->currentState.weapon ) // We don't have a weapon right now
+	{
+		return;
+	}
+
+	value = ps->ammo[weaponData[cent->currentState.weapon].ammoIndex];
+	if (value < 0)	// No ammo
+	{
+		return;
+	}
+
+	focusItem = Menu_FindItemByName(menuHUD, "ammoamount");
+	trap_R_SetColor( hudTintColor );
+
+	if (weaponData[cent->currentState.weapon].energyPerShot == 0 &&
+		weaponData[cent->currentState.weapon].altEnergyPerShot == 0)
+	{ //just draw "infinite"
+		inc = 8 / MAX_HUD_TICS;
+		value = 8;
+
+		focusItem = Menu_FindItemByName(menuHUD, "ammoinfinite");
+		trap_R_SetColor( hudTintColor );
+		if (focusItem)
+		{
+			UI_DrawProportionalString(focusItem->window.rect.x, focusItem->window.rect.y, "--", NUM_FONT_SMALL, focusItem->window.foreColor);
+		}
+	}
+	else
+	{
+		focusItem = Menu_FindItemByName(menuHUD, "ammoamount");
+		trap_R_SetColor( hudTintColor );
+		if (focusItem)
+		{
+
+			if ( (cent->currentState.eFlags & EF_DOUBLE_AMMO) )
+			{
+				inc = (float) (ammoData[weaponData[cent->currentState.weapon].ammoIndex].max*2.0f) / MAX_HUD_TICS;
+			}
+			else
+			{
+				inc = (float) ammoData[weaponData[cent->currentState.weapon].ammoIndex].max / MAX_HUD_TICS;
+			}
+			value =ps->ammo[weaponData[cent->currentState.weapon].ammoIndex];
+
+			CG_DrawNumField (
+				focusItem->window.rect.x, 
+				focusItem->window.rect.y, 
+				3, 
+				value, 
+				focusItem->window.rect.w, 
+				focusItem->window.rect.h, 
+				NUM_FONT_SMALL,
+				qfalse);
+		}
+	}
+
+	// Draw tics
+	for (i=MAX_HUD_TICS-1;i>=0;i--)
+	{
+		focusItem = Menu_FindItemByName(menuHUD, ammoTicName[i]);
+
+		if (!focusItem)
+		{
+			continue;
+		}
+
+		memcpy(calcColor, hudTintColor, sizeof(vec4_t));
+
+		if ( value <= 0 )	// done
+		{
+			break;
+		}
+		else if (value < inc)	// partial tic
+		{
+			percent = value / inc;
+			calcColor[3] = percent;
+		}
+
+		trap_R_SetColor( calcColor);
+
+		CG_DrawPic( 
+			focusItem->window.rect.x,
+			focusItem->window.rect.y,
+			focusItem->window.rect.w, 
+			focusItem->window.rect.h, 
+			focusItem->window.background
+			);
+
+		value -= inc;
+	}
+
+}
+
+/*
+================
+CG_DrawForcePower
+================
+*/
+void CG_DrawForcePower( menuDef_t *menuHUD )
+{
+	int				i;
+	vec4_t			calcColor;
+	float			value,inc,percent;
+	itemDef_t		*focusItem;
+	const int		maxForcePower = 100;
+	qboolean	flash=qfalse;
+
+	// Can we find the menu?
+	if (!menuHUD)
+	{
+		return;
+	}
+
+	// Make the hud flash by setting forceHUDTotalFlashTime above cg.time
+	if (cg.forceHUDTotalFlashTime > cg.time )
+	{
+		flash = qtrue;
+		if (cg.forceHUDNextFlashTime < cg.time)	
+		{
+			cg.forceHUDNextFlashTime = cg.time + 400;
+			trap_S_StartSound (NULL, 0, CHAN_LOCAL, cgs.media.noforceSound );
+
+			if (cg.forceHUDActive)
+			{
+				cg.forceHUDActive = qfalse;
+			}
+			else
+			{
+				cg.forceHUDActive = qtrue;
+			}
+
+		}
+	}
+	else	// turn HUD back on if it had just finished flashing time.
+	{
+		cg.forceHUDNextFlashTime = 0;
+		cg.forceHUDActive = qtrue;
+	}
+
+//	if (!cg.forceHUDActive)
+//	{
+//		return;
+//	}
+
+	inc = (float)  maxForcePower / MAX_HUD_TICS;
+	value = cg.snap->ps.fd.forcePower;
+
+	for (i=MAX_HUD_TICS-1;i>=0;i--)
+	{
+		focusItem = Menu_FindItemByName(menuHUD, forceTicName[i]);
+
+		if (!focusItem)
+		{
+			continue;
+		}
+
+//		memcpy(calcColor, hudTintColor, sizeof(vec4_t));
+
+		if ( value <= 0 )	// done
+		{
+			break;
+		}
+		else if (value < inc)	// partial tic
+		{
+			if (flash)
+			{
+				memcpy(calcColor,  colorTable[CT_RED], sizeof(vec4_t));
+			}
+			else 
+			{
+				memcpy(calcColor,  colorTable[CT_WHITE], sizeof(vec4_t));
+			}
+
+			percent = value / inc;
+			calcColor[3] = percent;
+		}
+		else
+		{
+			if (flash)
+			{
+				memcpy(calcColor,  colorTable[CT_RED], sizeof(vec4_t));
+			}
+			else 
+			{
+				memcpy(calcColor,  colorTable[CT_WHITE], sizeof(vec4_t));
+			}
+		}
+
+		trap_R_SetColor( calcColor);
+
+		CG_DrawPic( 
+			focusItem->window.rect.x,
+			focusItem->window.rect.y,
+			focusItem->window.rect.w, 
+			focusItem->window.rect.h, 
+			focusItem->window.background
+			);
+
+		value -= inc;
+	}
+
+	focusItem = Menu_FindItemByName(menuHUD, "forceamount");
+
+	if (focusItem)
+	{
+		// Print force amount
+		trap_R_SetColor( focusItem->window.foreColor );	
+
+		CG_DrawNumField (
+			focusItem->window.rect.x, 
+			focusItem->window.rect.y, 
+			3, 
+			cg.snap->ps.fd.forcePower, 
+			focusItem->window.rect.w, 
+			focusItem->window.rect.h, 
+			NUM_FONT_SMALL,
+			qfalse);
+	}
+}
+
+/*
+================
+CG_DrawHUD
+================
+*/
+void CG_DrawHUD(centity_t	*cent)
+{
+	menuDef_t	*menuHUD = NULL;
+	itemDef_t	*focusItem = NULL;
+	const char *scoreStr = NULL;
+	int	scoreBias;
+	char scoreBiasStr[16];
+
+	if (cg_hudFiles.integer)
+	{
+		int x = 0;
+		int y = SCREEN_HEIGHT-80;
+		char ammoString[64];
+		int weapX = x;
+
+		UI_DrawProportionalString( x+16, y+40, va( "%i", cg.snap->ps.stats[STAT_HEALTH] ),
+			UI_SMALLFONT|UI_DROPSHADOW, colorTable[CT_HUD_RED] );
+
+		UI_DrawProportionalString( x+18+14, y+40+14, va( "%i", cg.snap->ps.stats[STAT_ARMOR] ),
+			UI_SMALLFONT|UI_DROPSHADOW, colorTable[CT_HUD_GREEN] );
+
+		if (cg.snap->ps.weapon == WP_SABER)
+		{
+			if (cg.snap->ps.fd.saberDrawAnimLevel == SS_DUAL)
+			{
+				Com_sprintf(ammoString, sizeof(ammoString), "AKIMBO");
+				weapX += 16;
+			}
+			else if (cg.snap->ps.fd.saberDrawAnimLevel == SS_STAFF)
+			{
+				Com_sprintf(ammoString, sizeof(ammoString), "STAFF");
+				weapX += 16;
+			}
+			else if (cg.snap->ps.fd.saberDrawAnimLevel == FORCE_LEVEL_3)
+			{
+				Com_sprintf(ammoString, sizeof(ammoString), "STRONG");
+				weapX += 16;
+			}
+			else if (cg.snap->ps.fd.saberDrawAnimLevel == FORCE_LEVEL_2)
+			{
+				Com_sprintf(ammoString, sizeof(ammoString), "MEDIUM");
+				weapX += 16;
+			}
+			else
+			{
+				Com_sprintf(ammoString, sizeof(ammoString), "FAST");
+			}
+		}
+		else
+		{
+			Com_sprintf(ammoString, sizeof(ammoString), "%i", cg.snap->ps.ammo[weaponData[cent->currentState.weapon].ammoIndex]);
+		}
+		
+		UI_DrawProportionalString( SCREEN_WIDTH-(weapX+16+32), y+40, va( "%s", ammoString ),
+			UI_SMALLFONT|UI_DROPSHADOW, colorTable[CT_HUD_ORANGE] );
+
+		UI_DrawProportionalString( SCREEN_WIDTH-(x+18+14+32), y+40+14, va( "%i", cg.snap->ps.fd.forcePower),
+			UI_SMALLFONT|UI_DROPSHADOW, colorTable[CT_ICON_BLUE] );
+
+		return;
+	}
+
+	if (cgs.gametype >= GT_TEAM && cgs.gametype != GT_SIEGE)
+	{	// tint the hud items based on team
+		if (cg.snap->ps.persistant[PERS_TEAM] == TEAM_RED )
+			hudTintColor = redhudtint;
+		else if (cg.snap->ps.persistant[PERS_TEAM] == TEAM_BLUE )
+			hudTintColor = bluehudtint;
+		else // If we're not on a team for whatever reason, leave things as they are.
+			hudTintColor = colorTable[CT_WHITE];
+	}
+	else
+	{	// tint the hud items white (dont' tint)
+		hudTintColor = colorTable[CT_WHITE];
+	}
+
+	// Draw the left HUD 
+	menuHUD = Menus_FindByName("lefthud");
+	if (menuHUD)
+	{
+		itemDef_t *focusItem;
+
+		// Print scanline
+		focusItem = Menu_FindItemByName(menuHUD, "scanline");
+		if (focusItem)
+		{
+			trap_R_SetColor( hudTintColor );	
+			CG_DrawPic( 
+				focusItem->window.rect.x, 
+				focusItem->window.rect.y, 
+				focusItem->window.rect.w, 
+				focusItem->window.rect.h, 
+				focusItem->window.background 
+				);			
+		}
+
+		// Print frame
+		focusItem = Menu_FindItemByName(menuHUD, "frame");
+		if (focusItem)
+		{
+			trap_R_SetColor( hudTintColor );	
+			CG_DrawPic( 
+				focusItem->window.rect.x, 
+				focusItem->window.rect.y, 
+				focusItem->window.rect.w, 
+				focusItem->window.rect.h, 
+				focusItem->window.background 
+				);			
+		}
+
+		if (cg.predictedPlayerState.pm_type != PM_SPECTATOR)
+		{
+			CG_DrawArmor(menuHUD);
+			CG_DrawHealth(menuHUD);
+		}
+	}
+	else
+	{ 
+		//CG_Error("CG_ChatBox_ArrayInsert: unable to locate HUD menu file ");
+	}
+
+	//scoreStr = va("Score: %i", cgs.clientinfo[cg.snap->ps.clientNum].score);
+	if ( cgs.gametype == GT_DUEL )
+	{//A duel that requires more than one kill to knock the current enemy back to the queue
+		//show current kills out of how many needed
+		scoreStr = va("%s: %i/%i", CG_GetStringEdString("MP_INGAME", "SCORE"), cg.snap->ps.persistant[PERS_SCORE], cgs.fraglimit);
+	}
+	else if (0 && cgs.gametype < GT_TEAM )
+	{	// This is a teamless mode, draw the score bias.
+		scoreBias = cg.snap->ps.persistant[PERS_SCORE] - cgs.scores1;
+		if (scoreBias == 0)
+		{	// We are the leader!
+			if (cgs.scores2 <= 0)
+			{	// Nobody to be ahead of yet.
+				Com_sprintf(scoreBiasStr, sizeof(scoreBiasStr), "");
+			}
+			else
+			{
+				scoreBias = cg.snap->ps.persistant[PERS_SCORE] - cgs.scores2;
+				if (scoreBias == 0)
+				{
+					Com_sprintf(scoreBiasStr, sizeof(scoreBiasStr), " (Tie)");
+				}
+				else
+				{
+					Com_sprintf(scoreBiasStr, sizeof(scoreBiasStr), " (+%d)", scoreBias);
+				}
+			}
+		}
+		else // if (scoreBias < 0)
+		{	// We are behind!
+			Com_sprintf(scoreBiasStr, sizeof(scoreBiasStr), " (%d)", scoreBias);
+		}
+		scoreStr = va("%s: %i%s", CG_GetStringEdString("MP_INGAME", "SCORE"), cg.snap->ps.persistant[PERS_SCORE], scoreBiasStr);
+	}
+	else
+	{	// Don't draw a bias.
+		scoreStr = va("%s: %i", CG_GetStringEdString("MP_INGAME", "SCORE"), cg.snap->ps.persistant[PERS_SCORE]);
+	}
+
+	menuHUD = Menus_FindByName("righthud");
+
+	if (menuHUD)
+	{
+		if (cgs.gametype != GT_POWERDUEL)
+		{
+			focusItem = Menu_FindItemByName(menuHUD, "score_line");
+			if (focusItem)
+			{
+				UI_DrawScaledProportionalString(
+					focusItem->window.rect.x, 
+					focusItem->window.rect.y, 
+					scoreStr, 
+					UI_RIGHT|UI_DROPSHADOW, 
+					focusItem->window.foreColor, 
+					0.7);
+			}
+		}
+
+		// Print scanline
+		focusItem = Menu_FindItemByName(menuHUD, "scanline");
+		if (focusItem)
+		{
+			trap_R_SetColor( hudTintColor );	
+			CG_DrawPic( 
+				focusItem->window.rect.x, 
+				focusItem->window.rect.y, 
+				focusItem->window.rect.w, 
+				focusItem->window.rect.h, 
+				focusItem->window.background 
+				);			
+		}
+
+		focusItem = Menu_FindItemByName(menuHUD, "frame");
+		if (focusItem)
+		{
+			trap_R_SetColor( hudTintColor );	
+			CG_DrawPic( 
+				focusItem->window.rect.x, 
+				focusItem->window.rect.y, 
+				focusItem->window.rect.w, 
+				focusItem->window.rect.h, 
+				focusItem->window.background 
+				);			
+		}
+
+		CG_DrawForcePower(menuHUD);
+
+		// Draw ammo tics or saber style
+		if ( cent->currentState.weapon == WP_SABER )
+		{
+			CG_DrawSaberStyle(cent,menuHUD);
+		}
+		else
+		{
+			CG_DrawAmmo(cent,menuHUD);
+		}
+	}
+	else
+	{ 
+		//CG_Error("CG_ChatBox_ArrayInsert: unable to locate HUD menu file ");
+	}
+}
+
+#define MAX_SHOWPOWERS NUM_FORCE_POWERS
+
+qboolean ForcePower_Valid(int i)
+{
+	if (i == FP_LEVITATION ||
+		i == FP_SABER_OFFENSE ||
+		i == FP_SABER_DEFENSE ||
+		i == FP_SABERTHROW)
+	{
+		return qfalse;
+	}
+
+	if (cg.snap->ps.fd.forcePowersKnown & (1 << i))
+	{
+		return qtrue;
+	}
+	
+	return qfalse;
+}
+
+/*
+===================
+CG_DrawForceSelect
+===================
+*/
+#ifdef _XBOX
+extern bool CL_ExtendSelectTime(void);
+#endif
+void CG_DrawForceSelect( void ) 
+{
+	int		i;
+	int		count;
+	int		smallIconSize,bigIconSize;
+	int		holdX,x,y,x2,y2,pad,length;
+	int		sideLeftIconCnt,sideRightIconCnt;
+	int		sideMax,holdCount,iconCnt;
+	int		yOffset = 0;
+
+
+	x2 = 0;
+	y2 = 0;
+
+	// don't display if dead
+	if ( cg.snap->ps.stats[STAT_HEALTH] <= 0 ) 
+	{
+		return;
+	}
+
+	if ((cg.forceSelectTime+WEAPON_SELECT_TIME)<cg.time)	// Time is up for the HUD to display
+	{
+		cg.forceSelect = cg.snap->ps.fd.forcePowerSelected;
+		return;
+	}
+
+	if (!cg.snap->ps.fd.forcePowersKnown)
+	{
+		return;
+	}
+
+#ifdef _XBOX
+	if(CL_ExtendSelectTime()) {
+		cg.forceSelectTime = cg.time;
+	}
+	yOffset = -50;
+#endif
+
+	// count the number of powers owned
+	count = 0;
+
+	for (i=0;i < NUM_FORCE_POWERS;++i)
+	{
+		if (ForcePower_Valid(i))
+		{
+			count++;
+		}
+	}
+
+	if (count == 0)	// If no force powers, don't display
+	{
+		return;
+	}
+
+	sideMax = 3;	// Max number of icons on the side
+
+	// Calculate how many icons will appear to either side of the center one
+	holdCount = count - 1;	// -1 for the center icon
+	if (holdCount == 0)			// No icons to either side
+	{
+		sideLeftIconCnt = 0;
+		sideRightIconCnt = 0;
+	}
+	else if (count > (2*sideMax))	// Go to the max on each side
+	{
+		sideLeftIconCnt = sideMax;
+		sideRightIconCnt = sideMax;
+	}
+	else							// Less than max, so do the calc
+	{
+		sideLeftIconCnt = holdCount/2;
+		sideRightIconCnt = holdCount - sideLeftIconCnt;
+	}
+
+	smallIconSize = 30;
+	bigIconSize = 60;
+	pad = 12;
+
+	x = 320;
+	y = 425;
+
+	// Background
+	length = (sideLeftIconCnt * smallIconSize) + (sideLeftIconCnt*pad) +
+			bigIconSize + (sideRightIconCnt * smallIconSize) + (sideRightIconCnt*pad) + 12;
+	
+	i = BG_ProperForceIndex(cg.forceSelect) - 1;
+	if (i < 0)
+	{
+		i = MAX_SHOWPOWERS;
+	}
+
+	trap_R_SetColor(NULL);
+	// Work backwards from current icon
+	holdX = x - ((bigIconSize/2) + pad + smallIconSize);
+	for (iconCnt=1;iconCnt<(sideLeftIconCnt+1);i--)
+	{
+		if (i < 0)
+		{
+			i = MAX_SHOWPOWERS;
+		}
+
+		if (!ForcePower_Valid(forcePowerSorted[i]))	// Does he have this power?
+		{
+			continue;
+		}
+
+		++iconCnt;					// Good icon
+
+		if (cgs.media.forcePowerIcons[forcePowerSorted[i]])
+		{
+			CG_DrawPic( holdX, y + yOffset, smallIconSize, smallIconSize, cgs.media.forcePowerIcons[forcePowerSorted[i]] ); 
+			holdX -= (smallIconSize+pad);
+		}
+	}
+
+	if (ForcePower_Valid(cg.forceSelect))
+	{
+		// Current Center Icon
+		if (cgs.media.forcePowerIcons[cg.forceSelect])
+		{
+			CG_DrawPic( x-(bigIconSize/2), (y-((bigIconSize-smallIconSize)/2)) + yOffset, bigIconSize, bigIconSize, cgs.media.forcePowerIcons[cg.forceSelect] ); //only cache the icon for display
+		}
+	}
+
+	i = BG_ProperForceIndex(cg.forceSelect) + 1;
+	if (i>MAX_SHOWPOWERS)
+	{
+		i = 0;
+	}
+
+	// Work forwards from current icon
+	holdX = x + (bigIconSize/2) + pad;
+	for (iconCnt=1;iconCnt<(sideRightIconCnt+1);i++)
+	{
+		if (i>MAX_SHOWPOWERS)
+		{
+			i = 0;
+		}
+
+		if (!ForcePower_Valid(forcePowerSorted[i]))	// Does he have this power?
+		{
+			continue;
+		}
+
+		++iconCnt;					// Good icon
+
+		if (cgs.media.forcePowerIcons[forcePowerSorted[i]])
+		{
+			CG_DrawPic( holdX, y + yOffset, smallIconSize, smallIconSize, cgs.media.forcePowerIcons[forcePowerSorted[i]] ); //only cache the icon for display
+			holdX += (smallIconSize+pad);
+		}
+	}
+
+	if ( showPowersName[cg.forceSelect] ) 
+	{
+		UI_DrawProportionalString(320, y + 30 + yOffset, CG_GetStringEdString("SP_INGAME", showPowersName[cg.forceSelect]), UI_CENTER | UI_SMALLFONT, colorTable[CT_ICON_BLUE]);
+	}
+}
+
+/*
+===================
+CG_DrawInventorySelect
+===================
+*/
+void CG_DrawInvenSelect( void ) 
+{
+	int				i;
+	int				sideMax,holdCount,iconCnt;
+	int				smallIconSize,bigIconSize;
+	int				sideLeftIconCnt,sideRightIconCnt;
+	int				count;
+	int				holdX,x,y,y2,pad;
+	int				height;
+	float			addX;
+
+	// don't display if dead
+	if ( cg.snap->ps.stats[STAT_HEALTH] <= 0 ) 
+	{
+		return;
+	}
+
+	if ((cg.invenSelectTime+WEAPON_SELECT_TIME)<cg.time)	// Time is up for the HUD to display
+	{
+		return;
+	}
+
+	if (!cg.snap->ps.stats[STAT_HOLDABLE_ITEM] || !cg.snap->ps.stats[STAT_HOLDABLE_ITEMS])
+	{
+		return;
+	}
+
+#ifdef _XBOX
+	if(CL_ExtendSelectTime()) {
+		cg.invenSelectTime = cg.time;
+	}
+#endif
+
+	if (cg.itemSelect == -1)
+	{
+		cg.itemSelect = bg_itemlist[cg.snap->ps.stats[STAT_HOLDABLE_ITEM]].giTag;
+	}
+
+//const int bits = cg.snap->ps.stats[ STAT_ITEMS ];
+
+	// count the number of items owned
+	count = 0;
+	for ( i = 0 ; i < HI_NUM_HOLDABLE ; i++ ) 
+	{
+		if (/*CG_InventorySelectable(i) && inv_icons[i]*/
+			(cg.snap->ps.stats[STAT_HOLDABLE_ITEMS] & (1 << i)) ) 
+		{
+			count++;
+		}
+	}
+
+	if (!count)
+	{
+		y2 = 0; //err?
+		UI_DrawProportionalString(320, y2 + 22, "EMPTY INVENTORY", UI_CENTER | UI_SMALLFONT, colorTable[CT_ICON_BLUE]);
+		return;
+	}
+
+	sideMax = 3;	// Max number of icons on the side
+
+	// Calculate how many icons will appear to either side of the center one
+	holdCount = count - 1;	// -1 for the center icon
+	if (holdCount == 0)			// No icons to either side
+	{
+		sideLeftIconCnt = 0;
+		sideRightIconCnt = 0;
+	}
+	else if (count > (2*sideMax))	// Go to the max on each side
+	{
+		sideLeftIconCnt = sideMax;
+		sideRightIconCnt = sideMax;
+	}
+	else							// Less than max, so do the calc
+	{
+		sideLeftIconCnt = holdCount/2;
+		sideRightIconCnt = holdCount - sideLeftIconCnt;
+	}
+
+	i = cg.itemSelect - 1;
+	if (i<0)
+	{
+		i = HI_NUM_HOLDABLE-1;
+	}
+
+	smallIconSize = 40;
+	bigIconSize = 80;
+	pad = 16;
+
+	x = 320;
+	y = 410;
+
+	// Left side ICONS
+	// Work backwards from current icon
+	holdX = x - ((bigIconSize/2) + pad + smallIconSize);
+	height = smallIconSize * cg.iconHUDPercent;
+	addX = (float) smallIconSize * .75;
+
+	for (iconCnt=0;iconCnt<sideLeftIconCnt;i--)
+	{
+		if (i<0)
+		{
+			i = HI_NUM_HOLDABLE-1;
+		}
+
+		if ( !(cg.snap->ps.stats[STAT_HOLDABLE_ITEMS] & (1 << i)) || i == cg.itemSelect )
+		{
+			continue;
+		}
+
+		++iconCnt;					// Good icon
+
+		if (!BG_IsItemSelectable(&cg.predictedPlayerState, i))
+		{
+			continue;
+		}
+
+		if (cgs.media.invenIcons[i])
+		{
+			trap_R_SetColor(NULL);
+			CG_DrawPic( holdX, y+10, smallIconSize, smallIconSize, cgs.media.invenIcons[i] );
+
+			trap_R_SetColor(colorTable[CT_ICON_BLUE]);
+			/*CG_DrawNumField (holdX + addX, y + smallIconSize, 2, cg.snap->ps.inventory[i], 6, 12, 
+				NUM_FONT_SMALL,qfalse);
+				*/
+
+			holdX -= (smallIconSize+pad);
+		}
+	}
+
+	// Current Center Icon
+	height = bigIconSize * cg.iconHUDPercent;
+	if (cgs.media.invenIcons[cg.itemSelect] && BG_IsItemSelectable(&cg.predictedPlayerState, cg.itemSelect))
+	{
+		int itemNdex;
+		trap_R_SetColor(NULL);
+		CG_DrawPic( x-(bigIconSize/2), (y-((bigIconSize-smallIconSize)/2))+10, bigIconSize, bigIconSize, cgs.media.invenIcons[cg.itemSelect] );
+		addX = (float) bigIconSize * .75;
+		trap_R_SetColor(colorTable[CT_ICON_BLUE]);
+		/*CG_DrawNumField ((x-(bigIconSize/2)) + addX, y, 2, cg.snap->ps.inventory[cg.inventorySelect], 6, 12, 
+			NUM_FONT_SMALL,qfalse);*/
+
+		itemNdex = BG_GetItemIndexByTag(cg.itemSelect, IT_HOLDABLE);
+		if (bg_itemlist[itemNdex].classname)
+		{
+			vec4_t	textColor = { .312f, .75f, .621f, 1.0f };
+			char	text[1024];
+			char	upperKey[1024];
+
+			strcpy(upperKey, bg_itemlist[itemNdex].classname);
+			
+			if ( trap_SP_GetStringTextString( va("SP_INGAME_%s",Q_strupr(upperKey)), text, sizeof( text )))
+			{
+				UI_DrawProportionalString(320, y+45, text, UI_CENTER | UI_SMALLFONT, textColor);
+			}
+			else
+			{
+				UI_DrawProportionalString(320, y+45, bg_itemlist[itemNdex].classname, UI_CENTER | UI_SMALLFONT, textColor);
+			}
+		}
+	}
+
+	i = cg.itemSelect + 1;
+	if (i> HI_NUM_HOLDABLE-1)
+	{
+		i = 0;
+	}
+
+	// Right side ICONS
+	// Work forwards from current icon
+	holdX = x + (bigIconSize/2) + pad;
+	height = smallIconSize * cg.iconHUDPercent;
+	addX = (float) smallIconSize * .75;
+	for (iconCnt=0;iconCnt<sideRightIconCnt;i++)
+	{
+		if (i> HI_NUM_HOLDABLE-1)
+		{
+			i = 0;
+		}
+
+		if ( !(cg.snap->ps.stats[STAT_HOLDABLE_ITEMS] & (1 << i)) || i == cg.itemSelect )
+		{
+			continue;
+		}
+
+		++iconCnt;					// Good icon
+
+		if (!BG_IsItemSelectable(&cg.predictedPlayerState, i))
+		{
+			continue;
+		}
+
+		if (cgs.media.invenIcons[i])
+		{
+			trap_R_SetColor(NULL);
+			CG_DrawPic( holdX, y+10, smallIconSize, smallIconSize, cgs.media.invenIcons[i] );
+
+			trap_R_SetColor(colorTable[CT_ICON_BLUE]);
+			/*CG_DrawNumField (holdX + addX, y + smallIconSize, 2, cg.snap->ps.inventory[i], 6, 12, 
+				NUM_FONT_SMALL,qfalse);*/
+
+			holdX += (smallIconSize+pad);
+		}
+	}
+}
+
+int cg_targVeh = ENTITYNUM_NONE;
+int cg_targVehLastTime = 0;
+qboolean CG_CheckTargetVehicle( centity_t **pTargetVeh, float *alpha )
+{
+	int targetNum = ENTITYNUM_NONE;
+	centity_t	*targetVeh = NULL;
+	
+	if ( !pTargetVeh || !alpha )
+	{//hey, where are my pointers?
+		return qfalse;
+	}
+
+	*alpha = 1.0f;
+
+	if ( cg.predictedPlayerState.rocketLockIndex < ENTITYNUM_WORLD )
+	{
+		targetNum = cg.predictedPlayerState.rocketLockIndex;
+	}
+    else if ( cg.crosshairClientNum < ENTITYNUM_WORLD )
+	{
+		targetNum = cg.crosshairClientNum;
+	}
+
+	if ( targetNum < MAX_CLIENTS )
+	{//real client
+		if ( cg_entities[targetNum].currentState.m_iVehicleNum >= MAX_CLIENTS )
+		{//in a vehicle
+			targetNum = cg_entities[targetNum].currentState.m_iVehicleNum;
+		}
+	}
+    if ( targetNum < ENTITYNUM_WORLD 
+		&& targetNum >= MAX_CLIENTS )
+	{
+		centity_t *targetVeh = &cg_entities[targetNum];
+		if ( targetVeh->currentState.NPC_class == CLASS_VEHICLE 
+			&& targetVeh->m_pVehicle
+			&& targetVeh->m_pVehicle->m_pVehicleInfo
+			&& targetVeh->m_pVehicle->m_pVehicleInfo->type == VH_FIGHTER )
+		{//it's a vehicle
+			cg_targVeh = targetNum;
+			cg_targVehLastTime = cg.time;
+			*alpha = 1.0f;
+		}
+		else
+		{
+			targetVeh = NULL;
+		}
+	}
+	if ( !targetVeh )
+	{
+		if ( cg_targVehLastTime && cg.time - cg_targVehLastTime < 3000 )
+		{
+			targetVeh = &cg_entities[cg_targVeh];;
+			if ( cg.time-cg_targVehLastTime < 1000 )
+			{//stay at full alpha for 1 sec after lose them from crosshair
+				*alpha = 1.0f;
+			}
+			else
+			{//fade out over 2 secs
+				*alpha = 1.0f-((cg.time-cg_targVehLastTime-1000)/2000.0f);
+			}
+		}
+	}
+	if ( targetVeh )
+	{
+		*pTargetVeh = targetVeh;
+		return qtrue;
+	}
+	return qfalse;
+}
+
+#define MAX_VHUD_SHIELD_TICS 12
+#define MAX_VHUD_SPEED_TICS 5
+#define MAX_VHUD_ARMOR_TICS 5
+#define MAX_VHUD_AMMO_TICS 5
+
+float CG_DrawVehicleShields( const menuDef_t	*menuHUD, const centity_t *veh )
+{
+	int				i;
+	char			itemName[64];
+	float			inc, currValue,maxShields;
+	vec4_t			calcColor;
+	itemDef_t		*item;
+	float			percShields;
+
+	item = Menu_FindItemByName((menuDef_t	*) menuHUD, "armorbackground");
+
+	if (item)
+	{
+		trap_R_SetColor( item->window.foreColor );
+		CG_DrawPic( 
+			item->window.rect.x, 
+			item->window.rect.y, 
+			item->window.rect.w, 
+			item->window.rect.h, 
+			item->window.background );
+	}
+
+	maxShields = veh->m_pVehicle->m_pVehicleInfo->shields;
+	currValue = cg.predictedVehicleState.stats[STAT_ARMOR];
+	percShields = (float)currValue/(float)maxShields;
+	// Print all the tics of the shield graphic
+	// Look at the amount of health left and show only as much of the graphic as there is health.
+	// Use alpha to fade out partial section of health
+	inc = (float) maxShields / MAX_VHUD_ARMOR_TICS;
+	for (i=1;i<=MAX_VHUD_ARMOR_TICS;i++)
+	{
+		sprintf( itemName, "armor_tic%d",	i );
+
+		item = Menu_FindItemByName((menuDef_t *) menuHUD, itemName);
+
+		if (!item)
+		{
+			continue;
+		}
+
+		memcpy(calcColor, item->window.foreColor, sizeof(vec4_t));
+
+		if (currValue <= 0)	// don't show tic
+		{
+			break;
+		}
+		else if (currValue < inc)	// partial tic (alpha it out)
+		{
+			float percent = currValue / inc;
+			calcColor[3] *= percent;		// Fade it out
+		}
+
+		trap_R_SetColor( calcColor);
+
+		CG_DrawPic( 
+			item->window.rect.x, 
+			item->window.rect.y, 
+			item->window.rect.w, 
+			item->window.rect.h, 
+			item->window.background );
+
+		currValue -= inc;
+	}
+
+	return percShields;
+}
+
+int cg_vehicleAmmoWarning = 0;
+int cg_vehicleAmmoWarningTime = 0;
+void CG_DrawVehicleAmmo( const menuDef_t *menuHUD, const centity_t *veh )
+{
+	int i;
+	char itemName[64];
+	float inc, currValue,maxAmmo;
+	vec4_t	calcColor;
+	itemDef_t	*item;
+
+	item = Menu_FindItemByName((menuDef_t *) menuHUD, "ammobackground");
+
+	if (item)
+	{
+		trap_R_SetColor( item->window.foreColor );
+		CG_DrawPic( 
+			item->window.rect.x, 
+			item->window.rect.y, 
+			item->window.rect.w, 
+			item->window.rect.h, 
+			item->window.background );
+	}
+
+	maxAmmo = veh->m_pVehicle->m_pVehicleInfo->weapon[0].ammoMax;
+	currValue = cg.predictedVehicleState.ammo[0];
+	
+	inc = (float) maxAmmo / MAX_VHUD_AMMO_TICS;
+	for (i=1;i<=MAX_VHUD_AMMO_TICS;i++)
+	{
+		sprintf( itemName, "ammo_tic%d",	i );
+
+		item = Menu_FindItemByName((menuDef_t *)menuHUD, itemName);
+
+		if (!item)
+		{
+			continue;
+		}
+
+		if ( cg_vehicleAmmoWarningTime > cg.time 
+			&& cg_vehicleAmmoWarning == 0 )
+		{
+			memcpy(calcColor, g_color_table[ColorIndex(COLOR_RED)], sizeof(vec4_t));
+			calcColor[3] = sin(cg.time*0.005)*0.5f+0.5f;
+		}
+		else
+		{
+			memcpy(calcColor, item->window.foreColor, sizeof(vec4_t));
+
+			if (currValue <= 0)	// don't show tic
+			{
+				break;
+			}
+			else if (currValue < inc)	// partial tic (alpha it out)
+			{
+				float percent = currValue / inc;
+				calcColor[3] *= percent;		// Fade it out
+			}
+		}
+
+		trap_R_SetColor( calcColor);
+
+		CG_DrawPic( 
+			item->window.rect.x, 
+			item->window.rect.y, 
+			item->window.rect.w, 
+			item->window.rect.h, 
+			item->window.background );
+
+		currValue -= inc;
+	}
+}
+
+
+void CG_DrawVehicleAmmoUpper( const menuDef_t *menuHUD, const centity_t *veh )
+{
+	int			i;
+	char		itemName[64];
+	float		inc, currValue,maxAmmo;
+	vec4_t		calcColor;
+	itemDef_t	*item;
+
+	item = Menu_FindItemByName((menuDef_t *)menuHUD, "ammoupperbackground");
+
+	if (item)
+	{
+		trap_R_SetColor( item->window.foreColor );
+		CG_DrawPic( 
+			item->window.rect.x, 
+			item->window.rect.y, 
+			item->window.rect.w, 
+			item->window.rect.h, 
+			item->window.background );
+	}
+
+	maxAmmo = veh->m_pVehicle->m_pVehicleInfo->weapon[0].ammoMax;
+	currValue = cg.predictedVehicleState.ammo[0];
+
+	inc = (float) maxAmmo / MAX_VHUD_AMMO_TICS;
+	for (i=1;i<MAX_VHUD_AMMO_TICS;i++)
+	{
+		sprintf( itemName, "ammoupper_tic%d",	i );
+
+		item = Menu_FindItemByName((menuDef_t *)menuHUD, itemName);
+
+		if (!item)
+		{
+			continue;
+		}
+
+		if ( cg_vehicleAmmoWarningTime > cg.time 
+			&& cg_vehicleAmmoWarning == 0 )
+		{
+			memcpy(calcColor, g_color_table[ColorIndex(COLOR_RED)], sizeof(vec4_t));
+			calcColor[3] = sin(cg.time*0.005)*0.5f+0.5f;
+		}
+		else
+		{
+			memcpy(calcColor, item->window.foreColor, sizeof(vec4_t));
+
+			if (currValue <= 0)	// don't show tic
+			{
+				break;
+			}
+			else if (currValue < inc)	// partial tic (alpha it out)
+			{
+				float percent = currValue / inc;
+				calcColor[3] *= percent;		// Fade it out
+			}
+		}
+
+		trap_R_SetColor( calcColor);
+
+		CG_DrawPic( 
+			item->window.rect.x, 
+			item->window.rect.y, 
+			item->window.rect.w, 
+			item->window.rect.h, 
+			item->window.background );
+
+		currValue -= inc;
+	}
+}
+
+
+void CG_DrawVehicleAmmoLower( const menuDef_t *menuHUD, const centity_t *veh )
+{
+	int				i;
+	char			itemName[64];
+	float			inc, currValue,maxAmmo;
+	vec4_t			calcColor;
+	itemDef_t		*item;
+
+
+	item = Menu_FindItemByName((menuDef_t *)menuHUD, "ammolowerbackground");
+
+	if (item)
+	{
+		trap_R_SetColor( item->window.foreColor );
+		CG_DrawPic( 
+			item->window.rect.x, 
+			item->window.rect.y, 
+			item->window.rect.w, 
+			item->window.rect.h, 
+			item->window.background );
+	}
+
+	maxAmmo = veh->m_pVehicle->m_pVehicleInfo->weapon[1].ammoMax;
+	currValue = cg.predictedVehicleState.ammo[1];
+
+	inc = (float) maxAmmo / MAX_VHUD_AMMO_TICS;
+	for (i=1;i<MAX_VHUD_AMMO_TICS;i++)
+	{
+		sprintf( itemName, "ammolower_tic%d",	i );
+
+		item = Menu_FindItemByName((menuDef_t *)menuHUD, itemName);
+
+		if (!item)
+		{
+			continue;
+		}
+
+		if ( cg_vehicleAmmoWarningTime > cg.time 
+			&& cg_vehicleAmmoWarning == 1 )
+		{
+			memcpy(calcColor, g_color_table[ColorIndex(COLOR_RED)], sizeof(vec4_t));
+			calcColor[3] = sin(cg.time*0.005)*0.5f+0.5f;
+		}
+		else
+		{
+			memcpy(calcColor, item->window.foreColor, sizeof(vec4_t));
+
+			if (currValue <= 0)	// don't show tic
+			{
+				break;
+			}
+			else if (currValue < inc)	// partial tic (alpha it out)
+			{
+				float percent = currValue / inc;
+				calcColor[3] *= percent;		// Fade it out
+			}
+		}
+
+		trap_R_SetColor( calcColor);
+
+		CG_DrawPic( 
+			item->window.rect.x, 
+			item->window.rect.y, 
+			item->window.rect.w, 
+			item->window.rect.h, 
+			item->window.background );
+
+		currValue -= inc;
+	}
+}
+
+// The HUD.menu file has the graphic print with a negative height, so it will print from the bottom up.
+void CG_DrawVehicleTurboRecharge( const menuDef_t	*menuHUD, const centity_t *veh )
+{
+	itemDef_t	*item;
+	int			height;
+
+	item = Menu_FindItemByName( (menuDef_t	*) menuHUD, "turborecharge");
+
+	if (item)
+	{
+		float percent=0.0f;
+		int diff = ( cg.time - veh->m_pVehicle->m_iTurboTime );
+
+		height = item->window.rect.h;
+
+		if (diff > veh->m_pVehicle->m_pVehicleInfo->turboRecharge)
+		{
+			percent = 1.0f;
+			trap_R_SetColor( colorTable[CT_GREEN] );
+		}
+		else 
+		{
+			percent = (float) diff / veh->m_pVehicle->m_pVehicleInfo->turboRecharge;
+			if (percent < 0.0f)
+			{
+				percent = 0.0f;
+			}
+			trap_R_SetColor( colorTable[CT_RED] );
+		}
+
+		height *= percent;
+
+		CG_DrawPic( 
+			item->window.rect.x, 
+			item->window.rect.y, 
+			item->window.rect.w, 
+			height, 
+			cgs.media.whiteShader);	
+	}
+}
+
+qboolean cg_drawLink = qfalse;
+void CG_DrawVehicleWeaponsLinked( const menuDef_t	*menuHUD, const centity_t *veh )
+{
+	qboolean drawLink = qfalse;
+	if ( veh->m_pVehicle
+		&& veh->m_pVehicle->m_pVehicleInfo
+		&& (veh->m_pVehicle->m_pVehicleInfo->weapon[0].linkable == 2|| veh->m_pVehicle->m_pVehicleInfo->weapon[1].linkable == 2) )
+	{//weapon is always linked
+		drawLink = qtrue;
+	}
+	else
+	{
+//MP way:
+		//must get sent over network
+		if ( cg.predictedVehicleState.vehWeaponsLinked )
+		{
+			drawLink = qtrue;
+		}
+//NOTE: below is SP way
+/*
+		//just cheat it
+		if ( veh->gent->m_pVehicle->weaponStatus[0].linked
+			|| veh->gent->m_pVehicle->weaponStatus[1].linked )
+		{
+			drawLink = qtrue;
+		}
+*/
+	}
+
+	if ( cg_drawLink != drawLink )
+	{//state changed, play sound
+		cg_drawLink = drawLink;
+		trap_S_StartSound (NULL, cg.predictedPlayerState.clientNum, CHAN_LOCAL, trap_S_RegisterSound( "sound/vehicles/common/linkweaps.wav" ) );
+	}
+
+	if ( drawLink )
+	{
+		itemDef_t	*item;
+
+		item = Menu_FindItemByName( (menuDef_t	*) menuHUD, "weaponslinked");
+
+		if (item)
+		{
+			trap_R_SetColor( colorTable[CT_CYAN] );
+
+				CG_DrawPic( 
+				item->window.rect.x, 
+				item->window.rect.y, 
+				item->window.rect.w, 
+				item->window.rect.h, 
+				cgs.media.whiteShader);	
+		}
+	}
+}
+
+void CG_DrawVehicleSpeed( const menuDef_t	*menuHUD, const centity_t *veh )
+{
+	int i;
+	char itemName[64];
+	float inc, currValue,maxSpeed;
+	vec4_t		calcColor;
+	itemDef_t	*item;
+
+	item = Menu_FindItemByName((menuDef_t *) menuHUD, "speedbackground");
+
+	if (item)
+	{
+		trap_R_SetColor( item->window.foreColor );
+		CG_DrawPic( 
+			item->window.rect.x, 
+			item->window.rect.y, 
+			item->window.rect.w, 
+			item->window.rect.h, 
+			item->window.background );
+	}
+
+	maxSpeed = veh->m_pVehicle->m_pVehicleInfo->speedMax;
+	currValue = cg.predictedVehicleState.speed;
+
+
+	// Print all the tics of the shield graphic
+	// Look at the amount of health left and show only as much of the graphic as there is health.
+	// Use alpha to fade out partial section of health
+	inc = (float) maxSpeed / MAX_VHUD_SPEED_TICS;
+	for (i=1;i<=MAX_VHUD_SPEED_TICS;i++)
+	{
+		sprintf( itemName, "speed_tic%d",	i );
+
+		item = Menu_FindItemByName((menuDef_t *)menuHUD, itemName);
+
+		if (!item)
+		{
+			continue;
+		}
+
+		if ( cg.time > veh->m_pVehicle->m_iTurboTime )
+		{
+			memcpy(calcColor, item->window.foreColor, sizeof(vec4_t));
+		}
+		else	// In turbo mode
+		{
+			if (cg.VHUDFlashTime < cg.time)	
+			{
+				cg.VHUDFlashTime = cg.time + 200;
+				if (cg.VHUDTurboFlag)
+				{
+					cg.VHUDTurboFlag = qfalse;
+				}
+				else
+				{
+					cg.VHUDTurboFlag = qtrue;
+				}
+			}
+
+			if (cg.VHUDTurboFlag)
+			{
+				memcpy(calcColor, colorTable[CT_LTRED1], sizeof(vec4_t));
+			}
+			else
+			{
+				memcpy(calcColor, item->window.foreColor, sizeof(vec4_t));
+			}  
+		}
+
+
+		if (currValue <= 0)	// don't show tic
+		{
+			break;
+		}
+		else if (currValue < inc)	// partial tic (alpha it out)
+		{
+			float percent = currValue / inc;
+			calcColor[3] *= percent;		// Fade it out
+		}
+
+		trap_R_SetColor( calcColor);
+
+		CG_DrawPic( 
+			item->window.rect.x, 
+			item->window.rect.y, 
+			item->window.rect.w, 
+			item->window.rect.h, 
+			item->window.background );
+
+		currValue -= inc;
+	}
+}
+
+void CG_DrawVehicleArmor( const menuDef_t *menuHUD, const centity_t *veh )
+{
+	int			i;
+	vec4_t		calcColor;
+	char		itemName[64];
+	float		inc, currValue,maxArmor;
+	itemDef_t	*item;
+
+	maxArmor = veh->m_pVehicle->m_pVehicleInfo->armor;
+	currValue = cg.predictedVehicleState.stats[STAT_HEALTH];
+
+	item = Menu_FindItemByName( (menuDef_t	*) menuHUD, "shieldbackground");
+
+	if (item)
+	{
+		trap_R_SetColor( item->window.foreColor );
+		CG_DrawPic( 
+			item->window.rect.x, 
+			item->window.rect.y, 
+			item->window.rect.w, 
+			item->window.rect.h, 
+			item->window.background );
+	}
+
+
+	// Print all the tics of the shield graphic
+	// Look at the amount of health left and show only as much of the graphic as there is health.
+	// Use alpha to fade out partial section of health
+	inc = (float) maxArmor / MAX_VHUD_SHIELD_TICS;
+	for (i=1;i <= MAX_VHUD_SHIELD_TICS;i++)
+	{
+		sprintf( itemName, "shield_tic%d",	i );
+
+		item = Menu_FindItemByName((menuDef_t	*) menuHUD, itemName);
+
+		if (!item)
+		{
+			continue;
+		}
+
+
+		memcpy(calcColor, item->window.foreColor, sizeof(vec4_t));
+
+		if (currValue <= 0)	// don't show tic
+		{
+			break;
+		}
+		else if (currValue < inc)	// partial tic (alpha it out)
+		{
+			float percent = currValue / inc;
+			calcColor[3] *= percent;		// Fade it out
+		}
+
+		trap_R_SetColor( calcColor);
+
+		CG_DrawPic( 
+			item->window.rect.x, 
+			item->window.rect.y, 
+			item->window.rect.w, 
+			item->window.rect.h, 
+			item->window.background );
+
+		currValue -= inc;
+	}
+}
+
+enum
+{
+	VEH_DAMAGE_FRONT=0,
+	VEH_DAMAGE_BACK,
+	VEH_DAMAGE_LEFT,
+	VEH_DAMAGE_RIGHT,
+};
+
+typedef struct 
+{
+	char	*itemName;
+	short	heavyDamage;
+	short	lightDamage;
+} veh_damage_t;
+
+veh_damage_t vehDamageData[4] = 
+{
+"vehicle_front",SHIPSURF_DAMAGE_FRONT_HEAVY,SHIPSURF_DAMAGE_FRONT_LIGHT,
+"vehicle_back",SHIPSURF_DAMAGE_BACK_HEAVY,SHIPSURF_DAMAGE_BACK_LIGHT,
+"vehicle_left",SHIPSURF_DAMAGE_LEFT_HEAVY,SHIPSURF_DAMAGE_LEFT_LIGHT,
+"vehicle_right",SHIPSURF_DAMAGE_RIGHT_HEAVY,SHIPSURF_DAMAGE_RIGHT_LIGHT,
+};
+
+// Draw health graphic for given part of vehicle
+void CG_DrawVehicleDamage(const centity_t *veh,int brokenLimbs,const menuDef_t	*menuHUD,float alpha,int index)
+{
+	itemDef_t		*item;
+	int				colorI;
+	vec4_t			color;
+	int				graphicHandle=0;
+
+	item = Menu_FindItemByName((menuDef_t *)menuHUD, vehDamageData[index].itemName);
+	if (item)
+	{
+		if (brokenLimbs & (1<<vehDamageData[index].heavyDamage))
+		{
+			colorI = CT_RED;
+			if (brokenLimbs & (1<<vehDamageData[index].lightDamage))
+			{
+				colorI = CT_DKGREY;
+			}
+		}
+		else if (brokenLimbs & (1<<vehDamageData[index].lightDamage))
+		{
+			colorI = CT_YELLOW;
+		}
+		else
+		{
+			colorI = CT_GREEN;
+		}
+
+		VectorCopy4 ( colorTable[colorI], color );
+		color[3] = alpha;
+		trap_R_SetColor( color );
+
+		switch ( index )
+		{
+			case VEH_DAMAGE_FRONT :
+				graphicHandle = veh->m_pVehicle->m_pVehicleInfo->iconFrontHandle;
+				break;
+			case VEH_DAMAGE_BACK :
+				graphicHandle = veh->m_pVehicle->m_pVehicleInfo->iconBackHandle;
+				break;
+			case VEH_DAMAGE_LEFT :
+				graphicHandle = veh->m_pVehicle->m_pVehicleInfo->iconLeftHandle;
+				break;
+			case VEH_DAMAGE_RIGHT :
+				graphicHandle = veh->m_pVehicle->m_pVehicleInfo->iconRightHandle;
+				break;
+		}
+
+		if (graphicHandle)
+		{
+			CG_DrawPic( 
+				item->window.rect.x, 
+				item->window.rect.y, 
+				item->window.rect.w, 
+				item->window.rect.h, 
+				graphicHandle );
+		}
+	}
+}
+
+
+// Used on both damage indicators :  player vehicle and the vehicle the player is locked on 
+void CG_DrawVehicleDamageHUD(const centity_t *veh,int brokenLimbs,float percShields,char *menuName, float alpha)
+{
+	menuDef_t		*menuHUD;
+	itemDef_t		*item;
+	vec4_t			color;
+
+	menuHUD = Menus_FindByName(menuName);
+
+	if ( !menuHUD )
+	{
+		return;
+	}
+
+	item = Menu_FindItemByName(menuHUD, "background");
+	if (item)
+	{
+		if (veh->m_pVehicle->m_pVehicleInfo->dmgIndicBackgroundHandle)
+		{
+			if ( veh->damageTime > cg.time )
+			{//ship shields currently taking damage
+				//NOTE: cent->damageAngle can be accessed to get the direction from the ship origin to the impact point (in 3-D space)
+				float perc = 1.0f - ((veh->damageTime - cg.time) / 2000.0f/*MIN_SHIELD_TIME*/);
+				if ( perc < 0.0f )
+				{
+					perc = 0.0f;
+				}
+				else if ( perc > 1.0f )
+				{
+					perc = 1.0f;
+				}
+				color[0] = item->window.foreColor[0];//flash red
+				color[1] = item->window.foreColor[1]*perc;//fade other colors back in over time
+				color[2] = item->window.foreColor[2]*perc;//fade other colors back in over time
+				color[3] = item->window.foreColor[3];//always normal alpha
+				trap_R_SetColor( color );
+			}
+			else
+			{
+				trap_R_SetColor( item->window.foreColor );
+			}
+
+			CG_DrawPic( 
+				item->window.rect.x, 
+				item->window.rect.y, 
+				item->window.rect.w, 
+				item->window.rect.h, 
+				veh->m_pVehicle->m_pVehicleInfo->dmgIndicBackgroundHandle );
+		}
+	}
+
+	item = Menu_FindItemByName(menuHUD, "outer_frame");
+	if (item)
+	{
+		if (veh->m_pVehicle->m_pVehicleInfo->dmgIndicFrameHandle)
+		{
+			trap_R_SetColor( item->window.foreColor );
+			CG_DrawPic( 
+				item->window.rect.x, 
+				item->window.rect.y, 
+				item->window.rect.w, 
+				item->window.rect.h, 
+				veh->m_pVehicle->m_pVehicleInfo->dmgIndicFrameHandle );
+		}
+	}
+
+	item = Menu_FindItemByName(menuHUD, "shields");
+	if (item)
+	{
+		if (veh->m_pVehicle->m_pVehicleInfo->dmgIndicShieldHandle)
+		{
+			VectorCopy4 ( colorTable[CT_HUD_GREEN], color );
+			color[3] = percShields;
+			trap_R_SetColor( color );
+			CG_DrawPic( 
+				item->window.rect.x, 
+				item->window.rect.y, 
+				item->window.rect.w, 
+				item->window.rect.h, 
+				veh->m_pVehicle->m_pVehicleInfo->dmgIndicShieldHandle );
+		}
+	}
+
+	//TODO: if we check nextState.brokenLimbs & prevState.brokenLimbs, we can tell when a damage flag has been added and flash that part of the ship
+	//FIXME: when ship explodes, either stop drawing ship or draw all parts black
+	CG_DrawVehicleDamage(veh,brokenLimbs,menuHUD,alpha,VEH_DAMAGE_FRONT);
+	CG_DrawVehicleDamage(veh,brokenLimbs,menuHUD,alpha,VEH_DAMAGE_BACK);
+	CG_DrawVehicleDamage(veh,brokenLimbs,menuHUD,alpha,VEH_DAMAGE_LEFT);
+	CG_DrawVehicleDamage(veh,brokenLimbs,menuHUD,alpha,VEH_DAMAGE_RIGHT);
+}
+
+qboolean CG_DrawVehicleHud( const centity_t *cent )
+{
+	itemDef_t		*item;
+	menuDef_t		*menuHUD;
+	playerState_t	*ps;
+	centity_t		*veh;
+	float			shieldPerc,alpha;
+	
+	menuHUD = Menus_FindByName("swoopvehiclehud");
+	if (!menuHUD)
+	{
+		return qtrue;	// Draw player HUD
+	}
+
+	ps = &cg.predictedPlayerState;
+
+	if (!ps || !(ps->m_iVehicleNum))
+	{
+		return qtrue;	// Draw player HUD
+	}
+	veh = &cg_entities[ps->m_iVehicleNum];
+
+	if ( !veh )
+	{
+		return qtrue;	// Draw player HUD
+	}
+
+	CG_DrawVehicleTurboRecharge( menuHUD, veh );
+	CG_DrawVehicleWeaponsLinked( menuHUD, veh );
+
+	item = Menu_FindItemByName(menuHUD, "leftframe");
+
+	// Draw frame
+	if (item)
+	{
+		trap_R_SetColor( item->window.foreColor );
+		CG_DrawPic( 
+			item->window.rect.x, 
+			item->window.rect.y, 
+			item->window.rect.w, 
+			item->window.rect.h, 
+			item->window.background );
+	}
+
+	item = Menu_FindItemByName(menuHUD, "rightframe");
+
+	if (item)
+	{
+		trap_R_SetColor( item->window.foreColor );
+		CG_DrawPic( 
+			item->window.rect.x, 
+			item->window.rect.y, 
+			item->window.rect.w, 
+			item->window.rect.h, 
+			item->window.background );
+	}
+
+
+	CG_DrawVehicleArmor( menuHUD, veh );
+
+	// Get animal hud for speed
+//	if (veh->m_pVehicle->m_pVehicleInfo->type == VH_ANIMAL)
+//	{
+//		menuHUD = Menus_FindByName("tauntaunhud");
+//	}
+	
+
+	CG_DrawVehicleSpeed( menuHUD, veh );
+
+	// Revert to swoophud
+//	if (veh->m_pVehicle->m_pVehicleInfo->type == VH_ANIMAL)
+//	{
+//		menuHUD = Menus_FindByName("swoopvehiclehud");
+//	}
+
+//	if (veh->m_pVehicle->m_pVehicleInfo->type == VH_ANIMAL)
+//	{
+		shieldPerc = CG_DrawVehicleShields( menuHUD, veh );
+//	}
+
+	if (veh->m_pVehicle->m_pVehicleInfo->weapon[0].ID && !veh->m_pVehicle->m_pVehicleInfo->weapon[1].ID)
+	{
+		CG_DrawVehicleAmmo( menuHUD, veh );
+	}
+	else if (veh->m_pVehicle->m_pVehicleInfo->weapon[0].ID && veh->m_pVehicle->m_pVehicleInfo->weapon[1].ID)
+	{
+		CG_DrawVehicleAmmoUpper( menuHUD, veh );
+		CG_DrawVehicleAmmoLower( menuHUD, veh );
+	}
+
+	// If he's hidden, he must be in a vehicle
+	if (veh->m_pVehicle->m_pVehicleInfo->hideRider)
+	{
+		CG_DrawVehicleDamageHUD(veh,cg.predictedVehicleState.brokenLimbs,shieldPerc,"vehicledamagehud",1.0f);
+
+		// Has he targeted an enemy?
+		if (CG_CheckTargetVehicle( &veh, &alpha ))
+		{
+			CG_DrawVehicleDamageHUD(veh,veh->currentState.brokenLimbs,((float)veh->currentState.activeForcePass/10.0f),"enemyvehicledamagehud",alpha);
+		}
+
+		return qfalse;	// Don't draw player HUD
+	}
+
+	return qtrue;	// Draw player HUD
+
+}
+
+/*
+================
+CG_DrawStats
+
+================
+*/
+static void CG_DrawStats( void ) 
+{
+	centity_t		*cent;
+	playerState_t	*ps;
+	qboolean		drawHUD = qtrue;
+/*	playerState_t	*ps;
+	vec3_t			angles;
+//	vec3_t		origin;
+
+	if ( cg_drawStatus.integer == 0 ) {
+		return;
+	}
+*/
+	cent = &cg_entities[cg.snap->ps.clientNum];
+/*	ps = &cg.snap->ps;
+
+	VectorClear( angles );
+
+	// Do start
+	if (!cg.interfaceStartupDone)
+	{
+		CG_InterfaceStartup();
+	}
+
+	cgi_UI_MenuPaintAll();*/
+
+	if ( cent )
+	{
+		ps = &cg.predictedPlayerState;
+
+		if ( (ps->m_iVehicleNum ) )	// In a vehicle???
+		{
+			drawHUD = CG_DrawVehicleHud( cent );
+		}
+	}
+
+	if (drawHUD)
+	{
+		CG_DrawHUD(cent);
+	}
+
+	/*CG_DrawArmor(cent);
+	CG_DrawHealth(cent);
+	CG_DrawAmmo(cent);
+
+	CG_DrawTalk(cent);*/
+}
+
+/*
+===================
+CG_DrawPickupItem
+===================
+*/
+static void CG_DrawPickupItem( void ) {
+	int		value;
+	float	*fadeColor;
+
+	value = cg.itemPickup;
+	if ( value && cg_items[ value ].icon != -1 ) 
+	{
+		fadeColor = CG_FadeColor( cg.itemPickupTime, 3000 );
+		if ( fadeColor ) 
+		{
+			CG_RegisterItemVisuals( value );
+			trap_R_SetColor( fadeColor );
+			CG_DrawPic( 573, 320, ICON_SIZE, ICON_SIZE, cg_items[ value ].icon );
+			trap_R_SetColor( NULL );
+		}
+	}
+}
+
+/*
+================
+CG_DrawTeamBackground
+
+================
+*/
+void CG_DrawTeamBackground( int x, int y, int w, int h, float alpha, int team )
+{
+	vec4_t		hcolor;
+
+	hcolor[3] = alpha;
+	if ( team == TEAM_RED ) {
+		hcolor[0] = 1;
+		hcolor[1] = .2f;
+		hcolor[2] = .2f;
+	} else if ( team == TEAM_BLUE ) {
+		hcolor[0] = .2f;
+		hcolor[1] = .2f;
+		hcolor[2] = 1;
+	} else {
+		return;
+	}
+//	trap_R_SetColor( hcolor );
+
+	CG_FillRect ( x, y, w, h, hcolor );
+//	CG_DrawPic( x, y, w, h, cgs.media.teamStatusBar );
+	trap_R_SetColor( NULL );
+}
+
+
+/*
+===========================================================================================
+
+  UPPER RIGHT CORNER
+
+===========================================================================================
+*/
+
+/*
+================
+CG_DrawMiniScoreboard
+================
+*/
+static float CG_DrawMiniScoreboard ( float y ) 
+{
+	char temp[MAX_QPATH];
+	int xOffset = 0;
+
+#ifdef _XBOX
+	xOffset = -40;
+#endif
+
+	if ( !cg_drawScores.integer )
+	{
+		return y;
+	}
+
+	if (cgs.gametype == GT_SIEGE)
+	{ //don't bother with this in siege
+		return y;
+	}
+
+	if ( cgs.gametype >= GT_TEAM )
+	{
+		strcpy ( temp, va("%s: ", CG_GetStringEdString("MP_INGAME", "RED")));
+		Q_strcat ( temp, MAX_QPATH, cgs.scores1==SCORE_NOT_PRESENT?"-":(va("%i",cgs.scores1)) );
+		Q_strcat ( temp, MAX_QPATH, va(" %s: ", CG_GetStringEdString("MP_INGAME", "BLUE")) );
+		Q_strcat ( temp, MAX_QPATH, cgs.scores2==SCORE_NOT_PRESENT?"-":(va("%i",cgs.scores2)) );
+
+		CG_Text_Paint( 630 - CG_Text_Width ( temp, 0.7f, FONT_MEDIUM ) + xOffset, y, 0.7f, colorWhite, temp, 0, 0, ITEM_TEXTSTYLE_SHADOWEDMORE, FONT_MEDIUM );
+		y += 15;
+	}
+	else
+	{
+		/*
+		strcpy ( temp, "1st: " );
+		Q_strcat ( temp, MAX_QPATH, cgs.scores1==SCORE_NOT_PRESENT?"-":(va("%i",cgs.scores1)) );
+		
+		Q_strcat ( temp, MAX_QPATH, " 2nd: " );
+		Q_strcat ( temp, MAX_QPATH, cgs.scores2==SCORE_NOT_PRESENT?"-":(va("%i",cgs.scores2)) );
+		
+		CG_Text_Paint( 630 - CG_Text_Width ( temp, 0.7f, FONT_SMALL ), y, 0.7f, colorWhite, temp, 0, 0, ITEM_TEXTSTYLE_SHADOWEDMORE, FONT_MEDIUM );
+		y += 15;
+		*/
+		//rww - no longer doing this. Since the attacker now shows who is first, we print the score there.
+	}		
+	
+
+	return y;
+}
+
+/*
+================
+CG_DrawEnemyInfo
+================
+*/
+static float CG_DrawEnemyInfo ( float y ) 
+{
+	float		size;
+	int			clientNum;
+	const char	*title;
+	clientInfo_t	*ci;
+	int xOffset = 0;
+
+	if (!cg.snap)
+	{
+		return y;
+	}
+
+#ifdef _XBOX
+	xOffset = -40;
+#endif
+
+	if ( !cg_drawEnemyInfo.integer ) 
+	{
+		return y;
+	}
+
+	if ( cg.predictedPlayerState.stats[STAT_HEALTH] <= 0 ) 
+	{
+		return y;
+	}
+	
+	if (cgs.gametype == GT_POWERDUEL)
+	{ //just get out of here then
+		return y;
+	}
+
+	if ( cgs.gametype == GT_JEDIMASTER )
+	{
+		//title = "Jedi Master";
+		title = CG_GetStringEdString("MP_INGAME", "MASTERY7");
+		clientNum = cgs.jediMaster;
+
+		if ( clientNum < 0 )
+		{
+			//return y;
+//			title = "Get Saber!";
+			title = CG_GetStringEdString("MP_INGAME", "GET_SABER");
+
+
+			size = ICON_SIZE * 1.25;
+			y += 5;
+
+			CG_DrawPic( 640 - size - 12 + xOffset, y, size, size, cgs.media.weaponIcons[WP_SABER] );
+
+			y += size;
+
+			/*
+			CG_Text_Paint( 630 - CG_Text_Width ( ci->name, 0.7f, FONT_MEDIUM ), y, 0.7f, colorWhite, ci->name, 0, 0, 0, FONT_MEDIUM );
+			y += 15;
+			*/
+
+			CG_Text_Paint( 630 - CG_Text_Width ( title, 0.7f, FONT_MEDIUM ) + xOffset, y, 0.7f, colorWhite, title, 0, 0, 0, FONT_MEDIUM );
+
+			return y + BIGCHAR_HEIGHT + 2;
+		}
+	}
+	else if ( cg.snap->ps.duelInProgress )
+	{
+//		title = "Dueling";
+		title = CG_GetStringEdString("MP_INGAME", "DUELING");
+		clientNum = cg.snap->ps.duelIndex;
+	}
+	else if ( cgs.gametype == GT_DUEL && cgs.clientinfo[cg.snap->ps.clientNum].team != TEAM_SPECTATOR)
+	{
+		title = CG_GetStringEdString("MP_INGAME", "DUELING");
+		if (cg.snap->ps.clientNum == cgs.duelist1)
+		{
+			clientNum = cgs.duelist2; //if power duel, should actually draw both duelists 2 and 3 I guess
+		}
+		else if (cg.snap->ps.clientNum == cgs.duelist2)
+		{
+			clientNum = cgs.duelist1;
+		}
+		else if (cg.snap->ps.clientNum == cgs.duelist3)
+		{
+			clientNum = cgs.duelist1;
+		}
+		else
+		{
+			return y;
+		}
+	}
+	else
+	{
+		/*
+		title = "Attacker";
+		clientNum = cg.predictedPlayerState.persistant[PERS_ATTACKER];
+
+		if ( clientNum < 0 || clientNum >= MAX_CLIENTS || clientNum == cg.snap->ps.clientNum ) 
+		{
+			return y;
+		}
+
+		if ( cg.time - cg.attackerTime > ATTACKER_HEAD_TIME ) 
+		{
+			cg.attackerTime = 0;
+			return y;
+		}
+		*/
+		//As of current, we don't want to draw the attacker. Instead, draw whoever is in first place.
+		if (cgs.duelWinner < 0 || cgs.duelWinner >= MAX_CLIENTS)
+		{
+			return y;
+		}
+
+
+		title = va("%s: %i",CG_GetStringEdString("MP_INGAME", "LEADER"), cgs.scores1);
+
+		/*
+		if (cgs.scores1 == 1)
+		{
+			title = va("%i kill", cgs.scores1);
+		}
+		else
+		{
+			title = va("%i kills", cgs.scores1);
+		}
+		*/
+		clientNum = cgs.duelWinner;
+	}
+
+	ci = &cgs.clientinfo[ clientNum ];
+
+	if ( !ci )
+	{
+		return y;
+	}
+
+	size = ICON_SIZE * 1.25;
+	y += 5;
+
+	if ( ci->modelIcon )
+	{
+		CG_DrawPic( 640 - size - 5 + xOffset, y, size, size, ci->modelIcon );
+	}
+
+	y += size;
+
+//	CG_Text_Paint( 630 - CG_Text_Width ( ci->name, 0.7f, FONT_MEDIUM ) + xOffset, y, 0.7f, colorWhite, ci->name, 0, 0, 0, FONT_MEDIUM );
+	CG_Text_Paint( 630 - CG_Text_Width ( ci->name, 1.0f, FONT_SMALL2 ) + xOffset, y, 1.0f, colorWhite, ci->name, 0, 0, 0, FONT_SMALL2 );
+
+	y += 15;
+//	CG_Text_Paint( 630 - CG_Text_Width ( title, 0.7f, FONT_MEDIUM ) + xOffset, y, 0.7f, colorWhite, title, 0, 0, 0, FONT_MEDIUM );
+	CG_Text_Paint( 630 - CG_Text_Width ( title, 1.0f, FONT_SMALL2 ) + xOffset, y, 1.0f, colorWhite, title, 0, 0, 0, FONT_SMALL2 );
+
+	if ( (cgs.gametype == GT_DUEL || cgs.gametype == GT_POWERDUEL) && cgs.clientinfo[cg.snap->ps.clientNum].team != TEAM_SPECTATOR)
+	{//also print their score
+		char text[1024];
+		y += 15;
+		Com_sprintf(text, sizeof(text), "%i/%i", cgs.clientinfo[clientNum].score, cgs.fraglimit );
+		CG_Text_Paint( 630 - CG_Text_Width ( text, 0.7f, FONT_MEDIUM ) + xOffset, y, 0.7f, colorWhite, text, 0, 0, 0, FONT_MEDIUM );
+	}
+
+// nmckenzie: DUEL_HEALTH - fixme - need checks and such here.  And this is coded to duelist 1 right now, which is wrongly.
+	if ( cgs.showDuelHealths >= 2)
+	{
+		y += 15;
+		if ( cgs.duelist1 == clientNum )
+		{
+			CG_DrawDuelistHealth ( 640 - size - 5 + xOffset, y, 64, 8, 1 );
+		}
+		else if ( cgs.duelist2 == clientNum )
+		{
+			CG_DrawDuelistHealth ( 640 - size - 5 + xOffset, y, 64, 8, 2 );
+		}
+	}
+
+	return y + BIGCHAR_HEIGHT + 2;
+}
+
+/*
+==================
+CG_DrawSnapshot
+==================
+*/
+static float CG_DrawSnapshot( float y ) {
+	char		*s;
+	int			w;
+	int			xOffset = 0;
+
+#ifdef _XBOX
+	xOffset = -40;
+#endif
+
+	s = va( "time:%i snap:%i cmd:%i", cg.snap->serverTime, 
+		cg.latestSnapshotNum, cgs.serverCommandSequence );
+	w = CG_DrawStrlen( s ) * BIGCHAR_WIDTH;
+
+	CG_DrawBigString( 635 - w + xOffset, y + 2, s, 1.0F);
+
+	return y + BIGCHAR_HEIGHT + 4;
+}
+
+/*
+==================
+CG_DrawFPS
+==================
+*/
+#define	FPS_FRAMES	16
+static float CG_DrawFPS( float y ) {
+	char		*s;
+	int			w;
+	static unsigned short previousTimes[FPS_FRAMES];
+	static unsigned short index;
+	static int	previous, lastupdate;
+	int		t, i, fps, total;
+	unsigned short frameTime;
+#ifdef _XBOX
+	const int		xOffset = -40;
+#else
+	const int		xOffset = 0;
+#endif
+
+
+	// don't use serverTime, because that will be drifting to
+	// correct for internet lag changes, timescales, timedemos, etc
+	t = trap_Milliseconds();
+	frameTime = t - previous;
+	previous = t;
+	if (t - lastupdate > 50)	//don't sample faster than this
+	{
+		lastupdate = t;
+		previousTimes[index % FPS_FRAMES] = frameTime;
+		index++;
+	}
+	// average multiple frames together to smooth changes out a bit
+	total = 0;
+	for ( i = 0 ; i < FPS_FRAMES ; i++ ) {
+		total += previousTimes[i];
+	}
+	if ( !total ) {
+		total = 1;
+	}
+	fps = 1000 * FPS_FRAMES / total;
+
+	s = va( "%ifps", fps );
+	w = CG_DrawStrlen( s ) * BIGCHAR_WIDTH;
+
+	CG_DrawBigString( 635 - w + xOffset, y + 2, s, 1.0F);
+
+	return y + BIGCHAR_HEIGHT + 4;
+}
+
+// nmckenzie: DUEL_HEALTH
+#define MAX_HEALTH_FOR_IFACE	100
+void CG_DrawHealthBarRough (float x, float y, int width, int height, float ratio, const float *color1, const float *color2)
+{
+	float midpoint, remainder;
+	float color3[4] = {1, 0, 0, .7f};
+
+	midpoint = width * ratio - 1;
+	remainder = width - midpoint;
+	color3[0] = color1[0] * 0.5f;
+
+	assert(!(height%4));//this won't line up otherwise.
+	CG_DrawRect(x + 1,			y + height/2-1,  midpoint,	1,	   height/4+1,  color1);	// creme-y filling.
+	CG_DrawRect(x + midpoint,	y + height/2-1,  remainder,	1,	   height/4+1,  color3);	// used-up-ness.
+	CG_DrawRect(x,				y,				 width,		height, 1,			color2);	// hard crispy shell
+}
+
+void CG_DrawDuelistHealth ( float x, float y, float w, float h, int duelist )
+{
+	float	duelHealthColor[4] = {1, 0, 0, 0.7f};
+	float	healthSrc = 0.0f;
+	float	ratio;
+
+	if ( duelist == 1 )
+	{
+		healthSrc = cgs.duelist1health;
+	}
+	else if (duelist == 2 )
+	{
+		healthSrc = cgs.duelist2health;
+	}
+
+	ratio = healthSrc / MAX_HEALTH_FOR_IFACE;
+	if ( ratio > 1.0f )
+	{
+		ratio = 1.0f;
+	}
+	if ( ratio < 0.0f )
+	{
+		ratio = 0.0f;
+	}
+	duelHealthColor[0] = (ratio * 0.2f) + 0.5f;
+
+	CG_DrawHealthBarRough (x, y, w, h, ratio, duelHealthColor, colorTable[CT_WHITE]);	// new art for this?  I'm not crazy about how this looks.
+}
+
+/*
+=====================
+CG_DrawRadar
+=====================
+*/
+//#define RADAR_RANGE				2500
+float	cg_radarRange = 2500.0f;
+
+#define RADAR_RADIUS			60
+#define RADAR_X					(580 - RADAR_RADIUS)
+//#define RADAR_Y					10 //dynamic based on passed Y val
+#define RADAR_CHAT_DURATION		6000
+static int radarLockSoundDebounceTime = 0;
+static int impactSoundDebounceTime = 0;
+#define	RADAR_MISSILE_RANGE					3000.0f
+#define	RADAR_ASTEROID_RANGE				10000.0f
+#define	RADAR_MIN_ASTEROID_SURF_WARN_DIST	1200.0f
+
+float CG_DrawRadar ( float y )
+{
+	vec4_t			color;
+	vec4_t			teamColor;
+	float			arrow_w;
+	float			arrow_h;
+	clientInfo_t	*cl;
+	clientInfo_t	*local;
+	int				i;
+	float			arrowBaseScale;
+	float			zScale;
+	int				xOffset = 0;
+
+	if (!cg.snap)
+	{
+		return y;
+	}
+
+#ifdef _XBOX
+	xOffset = -40;
+#endif
+
+	// Make sure the radar should be showing
+	if ( cg.snap->ps.stats[STAT_HEALTH] <= 0 )
+	{
+		return y;
+	}
+
+	if ( (cg.predictedPlayerState.pm_flags & PMF_FOLLOW) || cg.predictedPlayerState.persistant[PERS_TEAM] == TEAM_SPECTATOR )
+	{
+		return y;
+	}
+
+	local = &cgs.clientinfo[ cg.snap->ps.clientNum ];
+	if ( !local->infoValid )
+	{
+		return y;
+	}
+
+	// Draw the radar background image
+	color[0] = color[1] = color[2] = 1.0f;
+	color[3] = 0.6f;
+	trap_R_SetColor ( color );
+	CG_DrawPic( RADAR_X + xOffset, y, RADAR_RADIUS*2, RADAR_RADIUS*2, cgs.media.radarShader );
+
+	//Always green for your own team.
+	VectorCopy ( g_color_table[ColorIndex(COLOR_GREEN)], teamColor );
+	teamColor[3] = 1.0f;
+
+	// Draw all of the radar entities.  Draw them backwards so players are drawn last
+	for ( i = cg.radarEntityCount -1 ; i >= 0 ; i-- ) 
+	{	
+		vec3_t		dirLook;	
+		vec3_t		dirPlayer;
+		float		angleLook;
+		float		anglePlayer;
+		float		angle;
+		float		distance, actualDist;
+		centity_t*	cent;
+
+		cent = &cg_entities[cg.radarEntities[i]];
+
+		// Get the distances first
+		VectorSubtract ( cg.predictedPlayerState.origin, cent->lerpOrigin, dirPlayer );		
+		dirPlayer[2] = 0;
+		actualDist = distance = VectorNormalize ( dirPlayer );
+
+		if ( distance > cg_radarRange * 0.8f) 
+		{
+			if ( (cent->currentState.eFlags & EF_RADAROBJECT)//still want to draw the direction
+				|| ( cent->currentState.eType==ET_NPC//FIXME: draw last, with players...
+					&& cent->currentState.NPC_class == CLASS_VEHICLE 
+					&& cent->currentState.speed > 0 ) )//always draw vehicles
+			{ 
+				distance = cg_radarRange*0.8f;
+			}
+			else
+			{
+				continue;
+			}
+		}
+
+		distance  = distance / cg_radarRange;
+		distance *= RADAR_RADIUS;
+
+		AngleVectors ( cg.predictedPlayerState.viewangles, dirLook, NULL, NULL );
+
+		dirLook[2] = 0;
+		anglePlayer = atan2(dirPlayer[0],dirPlayer[1]);		
+		VectorNormalize ( dirLook );
+		angleLook = atan2(dirLook[0],dirLook[1]);
+		angle = angleLook - anglePlayer;
+
+		switch ( cent->currentState.eType )
+		{
+			default:
+				{
+					float  x;
+					float  ly;
+					qhandle_t shader;
+					vec4_t    color;
+
+					x = (float)RADAR_X + (float)RADAR_RADIUS + (float)sin (angle) * distance;
+					ly = y + (float)RADAR_RADIUS + (float)cos (angle) * distance;
+
+					arrowBaseScale = 9.0f;
+					shader = 0;
+					zScale = 1.0f;
+
+					//we want to scale the thing up/down based on the relative Z (up/down) positioning
+					if (cent->lerpOrigin[2] > cg.predictedPlayerState.origin[2])
+					{ //higher, scale up (between 16 and 24)
+						float dif = (cent->lerpOrigin[2] - cg.predictedPlayerState.origin[2]);
+						
+						//max out to 1.5x scale at 512 units above local player's height
+						dif /= 1024.0f;
+						if (dif > 0.5f)
+						{
+							dif = 0.5f;
+						}
+						zScale += dif;
+					}
+					else if (cent->lerpOrigin[2] < cg.predictedPlayerState.origin[2])
+					{ //lower, scale down (between 16 and 8)
+						float dif = (cg.predictedPlayerState.origin[2] - cent->lerpOrigin[2]);
+
+						//half scale at 512 units below local player's height
+						dif /= 1024.0f;
+						if (dif > 0.5f)
+						{
+							dif = 0.5f;
+						}
+						zScale -= dif;
+					}
+
+					arrowBaseScale *= zScale;
+
+					if (cent->currentState.brokenLimbs)
+					{ //slightly misleading to use this value, but don't want to add more to entstate.
+						//any ent with brokenLimbs non-0 and on radar is an objective ent.
+						//brokenLimbs is literal team value.
+						char objState[1024];
+						int complete;
+
+						//we only want to draw it if the objective for it is not complete.
+						//frame represents objective num.
+						trap_Cvar_VariableStringBuffer(va("team%i_objective%i", cent->currentState.brokenLimbs, cent->currentState.frame), objState, 1024);
+
+						complete = atoi(objState);
+
+						if (!complete)
+						{
+						
+							// generic enemy index specifies a shader to use for the radar entity.
+							if ( cent->currentState.genericenemyindex )
+							{
+								color[0] = color[1] = color[2] = color[3] = 1.0f;
+								shader = cgs.gameIcons[cent->currentState.genericenemyindex];
+							}
+							else
+							{
+								if (cg.snap &&
+									cent->currentState.brokenLimbs == cg.snap->ps.persistant[PERS_TEAM])
+								{
+									VectorCopy ( g_color_table[ColorIndex(COLOR_RED)], color );
+								}
+								else
+								{
+									VectorCopy ( g_color_table[ColorIndex(COLOR_GREEN)], color );
+								}
+
+								shader = cgs.media.siegeItemShader;
+							}
+						}
+					}
+					else
+					{
+						color[0] = color[1] = color[2] = color[3] = 1.0f;
+						
+						// generic enemy index specifies a shader to use for the radar entity.
+						if ( cent->currentState.genericenemyindex )
+						{
+							shader = cgs.gameIcons[cent->currentState.genericenemyindex];
+						}
+						else
+						{
+							shader = cgs.media.siegeItemShader;
+						}
+					
+					}
+
+					if ( shader )
+					{
+						// Pulse the alpha if time2 is set.  time2 gets set when the entity takes pain
+						if ( (cent->currentState.time2 && cg.time - cent->currentState.time2 < 5000) ||
+							(cent->currentState.time2 == 0xFFFFFFFF) )
+						{								
+							if ( (cg.time / 200) & 1 )
+							{
+								color[3] = 0.1f + 0.9f * (float) (cg.time % 200) / 200.0f;
+							}
+							else
+							{
+								color[3] = 1.0f - 0.9f * (float) (cg.time % 200) / 200.0f;
+							}					
+						}
+
+						trap_R_SetColor ( color );
+						CG_DrawPic ( x - 4 + xOffset, ly - 4, arrowBaseScale, arrowBaseScale, shader );
+					}
+				}
+				break;
+
+			case ET_NPC://FIXME: draw last, with players...
+				if ( cent->currentState.NPC_class == CLASS_VEHICLE 
+					&& cent->currentState.speed > 0 )
+				{
+					if ( cent->m_pVehicle && cent->m_pVehicle->m_pVehicleInfo->radarIconHandle )
+					{
+						float  x;
+						float  ly;
+			
+						x = (float)RADAR_X + (float)RADAR_RADIUS + (float)sin (angle) * distance;
+						ly = y + (float)RADAR_RADIUS + (float)cos (angle) * distance;
+
+						arrowBaseScale = 9.0f;
+						zScale = 1.0f;
+
+						//we want to scale the thing up/down based on the relative Z (up/down) positioning
+						if (cent->lerpOrigin[2] > cg.predictedPlayerState.origin[2])
+						{ //higher, scale up (between 16 and 24)
+							float dif = (cent->lerpOrigin[2] - cg.predictedPlayerState.origin[2]);
+							
+							//max out to 1.5x scale at 512 units above local player's height
+							dif /= 4096.0f;
+							if (dif > 0.5f)
+							{
+								dif = 0.5f;
+							}
+							zScale += dif;
+						}
+						else if (cent->lerpOrigin[2] < cg.predictedPlayerState.origin[2])
+						{ //lower, scale down (between 16 and 8)
+							float dif = (cg.predictedPlayerState.origin[2] - cent->lerpOrigin[2]);
+
+							//half scale at 512 units below local player's height
+							dif /= 4096.0f;
+							if (dif > 0.5f)
+							{
+								dif = 0.5f;
+							}
+							zScale -= dif;
+						}
+
+						arrowBaseScale *= zScale;
+
+						if ( cent->currentState.m_iVehicleNum //vehicle has a driver
+							&& cgs.clientinfo[ cent->currentState.m_iVehicleNum-1 ].infoValid )
+						{
+							if ( cgs.clientinfo[ cent->currentState.m_iVehicleNum-1 ].team == local->team )
+							{
+								trap_R_SetColor ( teamColor );
+							}
+							else
+							{
+								trap_R_SetColor ( g_color_table[ColorIndex(COLOR_RED)] );
+							}
+						}
+						else
+						{
+							trap_R_SetColor ( NULL );
+						}
+						CG_DrawPic ( x - 4 + xOffset, ly - 4, arrowBaseScale, arrowBaseScale, cent->m_pVehicle->m_pVehicleInfo->radarIconHandle );
+					}
+				}
+				break; //maybe do something?
+
+			case ET_MOVER:
+				if ( cent->currentState.speed//the mover's size, actually
+					&& actualDist < (cent->currentState.speed+RADAR_ASTEROID_RANGE)
+					&& cg.predictedPlayerState.m_iVehicleNum )
+				{//a mover that's close to me and I'm in a vehicle
+					qboolean mayImpact = qfalse;
+					float surfaceDist = (actualDist-cent->currentState.speed);
+					if ( surfaceDist < 0.0f )
+					{
+						surfaceDist = 0.0f;
+					}
+					if ( surfaceDist < RADAR_MIN_ASTEROID_SURF_WARN_DIST )
+					{//always warn!
+						mayImpact = qtrue;
+					}
+					else
+					{//not close enough to always warn, yet, so check its direction
+						vec3_t	asteroidPos, myPos, moveDir;
+						int		predictTime, timeStep = 500;
+						float	newDist;
+						for ( predictTime = timeStep; predictTime < 5000; predictTime+=timeStep )
+						{
+							//asteroid dir, speed, size, + my dir & speed...
+							BG_EvaluateTrajectory( &cent->currentState.pos, cg.time+predictTime, asteroidPos );
+							//FIXME: I don't think it's calcing "myPos" correctly
+							AngleVectors( cg.predictedVehicleState.viewangles, moveDir, NULL, NULL );
+							VectorMA( cg.predictedVehicleState.origin, cg.predictedVehicleState.speed*predictTime/1000.0f, moveDir, myPos );
+							newDist = Distance( myPos, asteroidPos );
+							if ( (newDist-cent->currentState.speed) <= RADAR_MIN_ASTEROID_SURF_WARN_DIST )//200.0f )
+							{//heading for an impact within the next 5 seconds
+								mayImpact = qtrue;
+								break;
+							}
+						}
+					}
+					if ( mayImpact )
+					{//possible collision
+						vec4_t	asteroidColor = {0.5f,0.5f,0.5f,1.0f};
+						float  x;
+						float  ly;
+						float asteroidScale = (cent->currentState.speed/2000.0f);//average asteroid radius?
+						if ( actualDist > RADAR_ASTEROID_RANGE )
+						{
+							actualDist = RADAR_ASTEROID_RANGE;
+						}
+						distance = (actualDist/RADAR_ASTEROID_RANGE)*RADAR_RADIUS;
+
+						x = (float)RADAR_X + (float)RADAR_RADIUS + (float)sin (angle) * distance;
+						ly = y + (float)RADAR_RADIUS + (float)cos (angle) * distance;
+						
+						if ( asteroidScale > 3.0f )
+						{
+							asteroidScale = 3.0f;
+						}
+						else if ( asteroidScale < 0.2f )
+						{
+							asteroidScale = 0.2f;
+						}
+						arrowBaseScale = (9.0f*asteroidScale);
+						if ( impactSoundDebounceTime < cg.time )
+						{
+							vec3_t	soundOrg;
+							if ( surfaceDist > RADAR_ASTEROID_RANGE*0.66f )
+							{
+								impactSoundDebounceTime = cg.time + 1000;
+							}
+							else if ( surfaceDist > RADAR_ASTEROID_RANGE/3.0f )
+							{
+								impactSoundDebounceTime = cg.time + 400;
+							}
+							else 
+							{
+								impactSoundDebounceTime = cg.time + 100;
+							}
+							VectorMA( cg.refdef.vieworg, -500.0f*(surfaceDist/RADAR_ASTEROID_RANGE), dirPlayer, soundOrg );
+							trap_S_StartSound( soundOrg, ENTITYNUM_WORLD, CHAN_AUTO, trap_S_RegisterSound( "sound/vehicles/common/impactalarm.wav" ) );
+						}
+						//brighten it the closer it is
+						if ( surfaceDist > RADAR_ASTEROID_RANGE*0.66f )
+						{
+							asteroidColor[0] = asteroidColor[1] = asteroidColor[2] = 0.7f;
+						}
+						else if ( surfaceDist > RADAR_ASTEROID_RANGE/3.0f )
+						{
+							asteroidColor[0] = asteroidColor[1] = asteroidColor[2] = 0.85f;
+						}
+						else 
+						{
+							asteroidColor[0] = asteroidColor[1] = asteroidColor[2] = 1.0f;
+						}
+						//alpha out the longer it's been since it was considered dangerous
+						if ( (cg.time-impactSoundDebounceTime) > 100 )
+						{
+							asteroidColor[3] = (float)((cg.time-impactSoundDebounceTime)-100)/900.0f;
+						}
+
+						trap_R_SetColor ( asteroidColor );
+						CG_DrawPic ( x - 4 + xOffset, ly - 4, arrowBaseScale, arrowBaseScale, trap_R_RegisterShaderNoMip( "gfx/menus/radar/asteroid" ) );
+					}
+				}
+				break;
+
+			case ET_MISSILE:
+				if ( //cent->currentState.weapon == WP_ROCKET_LAUNCHER &&//a rocket
+					cent->currentState.owner > MAX_CLIENTS //belongs to an NPC
+					&& cg_entities[cent->currentState.owner].currentState.NPC_class == CLASS_VEHICLE )
+				{//a rocket belonging to an NPC, FIXME: only tracking rockets!
+					float  x;
+					float  ly;
+		
+					x = (float)RADAR_X + (float)RADAR_RADIUS + (float)sin (angle) * distance;
+					ly = y + (float)RADAR_RADIUS + (float)cos (angle) * distance;
+
+					arrowBaseScale = 3.0f;
+					if ( cg.predictedPlayerState.m_iVehicleNum )
+					{//I'm in a vehicle
+						//if it's targetting me, then play an alarm sound if I'm in a vehicle
+						if ( cent->currentState.otherEntityNum == cg.predictedPlayerState.clientNum || cent->currentState.otherEntityNum == cg.predictedPlayerState.m_iVehicleNum )
+						{
+							if ( radarLockSoundDebounceTime < cg.time )
+							{
+								vec3_t	soundOrg;
+								int		alarmSound;
+								if ( actualDist > RADAR_MISSILE_RANGE * 0.66f )
+								{
+									radarLockSoundDebounceTime = cg.time + 1000;
+									arrowBaseScale = 3.0f;
+									alarmSound = trap_S_RegisterSound( "sound/vehicles/common/lockalarm1.wav" );
+								}
+								else if ( actualDist > RADAR_MISSILE_RANGE/3.0f )
+								{
+									radarLockSoundDebounceTime = cg.time + 500;
+									arrowBaseScale = 6.0f;
+									alarmSound = trap_S_RegisterSound( "sound/vehicles/common/lockalarm2.wav" );
+								}
+								else
+								{
+									radarLockSoundDebounceTime = cg.time + 250;
+									arrowBaseScale = 9.0f;
+									alarmSound = trap_S_RegisterSound( "sound/vehicles/common/lockalarm3.wav" );
+								}
+								if ( actualDist > RADAR_MISSILE_RANGE )
+								{
+									actualDist = RADAR_MISSILE_RANGE;
+								}
+								VectorMA( cg.refdef.vieworg, -500.0f*(actualDist/RADAR_MISSILE_RANGE), dirPlayer, soundOrg );
+								trap_S_StartSound( soundOrg, ENTITYNUM_WORLD, CHAN_AUTO, alarmSound );
+							}
+						}
+					}
+					zScale = 1.0f;
+
+					//we want to scale the thing up/down based on the relative Z (up/down) positioning
+					if (cent->lerpOrigin[2] > cg.predictedPlayerState.origin[2])
+					{ //higher, scale up (between 16 and 24)
+						float dif = (cent->lerpOrigin[2] - cg.predictedPlayerState.origin[2]);
+						
+						//max out to 1.5x scale at 512 units above local player's height
+						dif /= 1024.0f;
+						if (dif > 0.5f)
+						{
+							dif = 0.5f;
+						}
+						zScale += dif;
+					}
+					else if (cent->lerpOrigin[2] < cg.predictedPlayerState.origin[2])
+					{ //lower, scale down (between 16 and 8)
+						float dif = (cg.predictedPlayerState.origin[2] - cent->lerpOrigin[2]);
+
+						//half scale at 512 units below local player's height
+						dif /= 1024.0f;
+						if (dif > 0.5f)
+						{
+							dif = 0.5f;
+						}
+						zScale -= dif;
+					}
+
+					arrowBaseScale *= zScale;
+
+					if ( cent->currentState.owner >= MAX_CLIENTS//missile owned by an NPC
+						&& cg_entities[cent->currentState.owner].currentState.NPC_class == CLASS_VEHICLE//NPC is a vehicle
+						&& cg_entities[cent->currentState.owner].currentState.m_iVehicleNum <= MAX_CLIENTS//Vehicle has a player driver
+						&& cgs.clientinfo[cg_entities[cent->currentState.owner].currentState.m_iVehicleNum-1].infoValid ) //player driver is valid
+					{
+						cl = &cgs.clientinfo[cg_entities[cent->currentState.owner].currentState.m_iVehicleNum-1];
+						if ( cl->team == local->team )
+						{
+							trap_R_SetColor ( teamColor );
+						}
+						else
+						{
+							trap_R_SetColor ( g_color_table[ColorIndex(COLOR_RED)] );
+						}
+					}
+					else
+					{
+						trap_R_SetColor ( NULL );
+					}
+					CG_DrawPic ( x - 4 + xOffset, ly - 4, arrowBaseScale, arrowBaseScale, cgs.media.mAutomapRocketIcon );
+				}
+				break;
+
+			case ET_PLAYER:
+			{
+				vec4_t color;
+
+				cl = &cgs.clientinfo[ cent->currentState.number ];
+
+				// not valid then dont draw it
+				if ( !cl->infoValid ) 
+				{	
+					continue;
+				}
+
+				VectorCopy4 ( teamColor, color );
+
+				arrowBaseScale = 16.0f;
+				zScale = 1.0f;
+
+				// Pulse the radar icon after a voice message
+				if ( cent->vChatTime + 2000 > cg.time )
+				{
+					float f = (cent->vChatTime + 2000 - cg.time) / 3000.0f;
+					arrowBaseScale = 16.0f + 4.0f * f;
+					color[0] = teamColor[0] + (1.0f - teamColor[0]) * f;
+					color[1] = teamColor[1] + (1.0f - teamColor[1]) * f;
+					color[2] = teamColor[2] + (1.0f - teamColor[2]) * f;
+				}
+
+				trap_R_SetColor ( color );
+
+				//we want to scale the thing up/down based on the relative Z (up/down) positioning
+				if (cent->lerpOrigin[2] > cg.predictedPlayerState.origin[2])
+				{ //higher, scale up (between 16 and 32)
+					float dif = (cent->lerpOrigin[2] - cg.predictedPlayerState.origin[2]);
+					
+					//max out to 2x scale at 1024 units above local player's height
+					dif /= 1024.0f;
+					if (dif > 1.0f)
+					{
+						dif = 1.0f;
+					}
+					zScale += dif;
+				}
+                else if (cent->lerpOrigin[2] < cg.predictedPlayerState.origin[2])
+				{ //lower, scale down (between 16 and 8)
+					float dif = (cg.predictedPlayerState.origin[2] - cent->lerpOrigin[2]);
+
+					//half scale at 512 units below local player's height
+					dif /= 1024.0f;
+					if (dif > 0.5f)
+					{
+						dif = 0.5f;
+					}
+					zScale -= dif;
+				}
+
+				arrowBaseScale *= zScale;
+
+				arrow_w = arrowBaseScale * RADAR_RADIUS / 128;
+				arrow_h = arrowBaseScale * RADAR_RADIUS / 128;
+
+				CG_DrawRotatePic2( RADAR_X + RADAR_RADIUS + sin (angle) * distance + xOffset,
+								   y + RADAR_RADIUS + cos (angle) * distance, 
+								   arrow_w, arrow_h, 
+								   (360 - cent->lerpAngles[YAW]) + cg.predictedPlayerState.viewangles[YAW], cgs.media.mAutomapPlayerIcon );
+				break;
+			}
+		}
+	}
+
+	arrowBaseScale = 16.0f;
+
+	arrow_w = arrowBaseScale * RADAR_RADIUS / 128;
+	arrow_h = arrowBaseScale * RADAR_RADIUS / 128;
+
+	trap_R_SetColor ( colorWhite );
+	CG_DrawRotatePic2( RADAR_X + RADAR_RADIUS + xOffset, y + RADAR_RADIUS, arrow_w, arrow_h, 
+					   0, cgs.media.mAutomapPlayerIcon );
+
+	return y+(RADAR_RADIUS*2);
+}
+
+/*
+=================
+CG_DrawTimer
+=================
+*/
+static float CG_DrawTimer( float y ) {
+	char		*s;
+	int			w;
+	int			mins, seconds, tens;
+	int			msec;
+	int			xOffset = 0;
+
+#ifdef _XBOX
+	xOffset = -40;
+#endif
+
+	msec = cg.time - cgs.levelStartTime;
+
+	seconds = msec / 1000;
+	mins = seconds / 60;
+	seconds -= mins * 60;
+	tens = seconds / 10;
+	seconds -= tens * 10;
+
+	s = va( "%i:%i%i", mins, tens, seconds );
+	w = CG_DrawStrlen( s ) * BIGCHAR_WIDTH;
+
+	CG_DrawBigString( 635 - w + xOffset, y + 2, s, 1.0F);
+
+	return y + BIGCHAR_HEIGHT + 4;
+}
+
+
+/*
+=================
+CG_DrawTeamOverlay
+=================
+*/
+extern const char *CG_GetLocationString(const char *loc); //cg_main.c
+static float CG_DrawTeamOverlay( float y, qboolean right, qboolean upper ) {
+	int x, w, h, xx;
+	int i, j, len;
+	const char *p;
+	vec4_t		hcolor;
+	int pwidth, lwidth;
+	int plyrs;
+	char st[16];
+	clientInfo_t *ci;
+	gitem_t	*item;
+	int ret_y, count;
+	int xOffset = 0;
+
+#ifdef _XBOX
+	xOffset = -40;
+#endif
+
+	if ( !cg_drawTeamOverlay.integer ) {
+		return y;
+	}
+
+	if ( cg.snap->ps.persistant[PERS_TEAM] != TEAM_RED && cg.snap->ps.persistant[PERS_TEAM] != TEAM_BLUE ) {
+		return y; // Not on any team
+	}
+
+	plyrs = 0;
+
+	// max player name width
+	pwidth = 0;
+	count = (numSortedTeamPlayers > 8) ? 8 : numSortedTeamPlayers;
+	for (i = 0; i < count; i++) {
+		ci = cgs.clientinfo + sortedTeamPlayers[i];
+		if ( ci->infoValid && ci->team == cg.snap->ps.persistant[PERS_TEAM]) {
+			plyrs++;
+			len = CG_DrawStrlen(ci->name);
+			if (len > pwidth)
+				pwidth = len;
+		}
+	}
+
+	if (!plyrs)
+		return y;
+
+	if (pwidth > TEAM_OVERLAY_MAXNAME_WIDTH)
+		pwidth = TEAM_OVERLAY_MAXNAME_WIDTH;
+
+	// max location name width
+	lwidth = 0;
+	for (i = 1; i < MAX_LOCATIONS; i++) {
+		p = CG_GetLocationString(CG_ConfigString(CS_LOCATIONS+i));
+		if (p && *p) {
+			len = CG_DrawStrlen(p);
+			if (len > lwidth)
+				lwidth = len;
+		}
+	}
+
+	if (lwidth > TEAM_OVERLAY_MAXLOCATION_WIDTH)
+		lwidth = TEAM_OVERLAY_MAXLOCATION_WIDTH;
+
+	w = (pwidth + lwidth + 4 + 7) * TINYCHAR_WIDTH;
+
+	if ( right )
+		x = 640 - w;
+	else
+		x = 0;
+
+	h = plyrs * TINYCHAR_HEIGHT;
+
+	if ( upper ) {
+		ret_y = y + h;
+	} else {
+		y -= h;
+		ret_y = y;
+	}
+
+	if ( cg.snap->ps.persistant[PERS_TEAM] == TEAM_RED ) {
+		hcolor[0] = 1.0f;
+		hcolor[1] = 0.0f;
+		hcolor[2] = 0.0f;
+		hcolor[3] = 0.33f;
+	} else { // if ( cg.snap->ps.persistant[PERS_TEAM] == TEAM_BLUE )
+		hcolor[0] = 0.0f;
+		hcolor[1] = 0.0f;
+		hcolor[2] = 1.0f;
+		hcolor[3] = 0.33f;
+	}
+	trap_R_SetColor( hcolor );
+	CG_DrawPic( x + xOffset, y, w, h, cgs.media.teamStatusBar );
+	trap_R_SetColor( NULL );
+
+	for (i = 0; i < count; i++) {
+		ci = cgs.clientinfo + sortedTeamPlayers[i];
+		if ( ci->infoValid && ci->team == cg.snap->ps.persistant[PERS_TEAM]) {
+
+			hcolor[0] = hcolor[1] = hcolor[2] = hcolor[3] = 1.0;
+
+			xx = x + TINYCHAR_WIDTH;
+
+			CG_DrawStringExt( xx + xOffset, y,
+				ci->name, hcolor, qfalse, qfalse,
+				TINYCHAR_WIDTH, TINYCHAR_HEIGHT, TEAM_OVERLAY_MAXNAME_WIDTH);
+
+			if (lwidth) {
+				p = CG_GetLocationString(CG_ConfigString(CS_LOCATIONS+ci->location));
+				if (!p || !*p)
+					p = "unknown";
+				len = CG_DrawStrlen(p);
+				if (len > lwidth)
+					len = lwidth;
+
+//				xx = x + TINYCHAR_WIDTH * 2 + TINYCHAR_WIDTH * pwidth + 
+//					((lwidth/2 - len/2) * TINYCHAR_WIDTH);
+				xx = x + TINYCHAR_WIDTH * 2 + TINYCHAR_WIDTH * pwidth;
+				CG_DrawStringExt( xx + xOffset, y,
+					p, hcolor, qfalse, qfalse, TINYCHAR_WIDTH, TINYCHAR_HEIGHT,
+					TEAM_OVERLAY_MAXLOCATION_WIDTH);
+			}
+
+			CG_GetColorForHealth( ci->health, ci->armor, hcolor );
+
+			Com_sprintf (st, sizeof(st), "%3i %3i", ci->health,	ci->armor);
+
+			xx = x + TINYCHAR_WIDTH * 3 + 
+				TINYCHAR_WIDTH * pwidth + TINYCHAR_WIDTH * lwidth;
+
+			CG_DrawStringExt( xx + xOffset, y,
+				st, hcolor, qfalse, qfalse,
+				TINYCHAR_WIDTH, TINYCHAR_HEIGHT, 0 );
+
+			// draw weapon icon
+			xx += TINYCHAR_WIDTH * 3;
+
+			if ( cg_weapons[ci->curWeapon].weaponIcon ) {
+				CG_DrawPic( xx + xOffset, y, TINYCHAR_WIDTH, TINYCHAR_HEIGHT, 
+					cg_weapons[ci->curWeapon].weaponIcon );
+			} else {
+				CG_DrawPic( xx + xOffset, y, TINYCHAR_WIDTH, TINYCHAR_HEIGHT, 
+					cgs.media.deferShader );
+			}
+
+			// Draw powerup icons
+			if (right) {
+				xx = x;
+			} else {
+				xx = x + w - TINYCHAR_WIDTH;
+			}
+			for (j = 0; j <= PW_NUM_POWERUPS; j++) {
+				if (ci->powerups & (1 << j)) {
+
+					item = BG_FindItemForPowerup( j );
+
+					if (item) {
+						CG_DrawPic( xx + xOffset, y, TINYCHAR_WIDTH, TINYCHAR_HEIGHT, 
+						trap_R_RegisterShader( item->icon ) );
+						if (right) {
+							xx -= TINYCHAR_WIDTH;
+						} else {
+							xx += TINYCHAR_WIDTH;
+						}
+					}
+				}
+			}
+
+			y += TINYCHAR_HEIGHT;
+		}
+	}
+
+	return ret_y;
+//#endif
+}
+
+
+static void CG_DrawPowerupIcons(int y)
+{
+	int j;
+	int ico_size = 64;
+	//int y = ico_size/2;
+	int xOffset = 0;
+	gitem_t	*item;
+
+#ifdef _XBOX
+	xOffset = -40;
+#endif
+
+	if (!cg.snap)
+	{
+		return;
+	}
+
+	y += 16;
+
+	for (j = 0; j <= PW_NUM_POWERUPS; j++)
+	{
+		if (cg.snap->ps.powerups[j] > cg.time)
+		{
+			int secondsleft = (cg.snap->ps.powerups[j] - cg.time)/1000;
+
+			item = BG_FindItemForPowerup( j );
+
+			if (item)
+			{
+				int icoShader = 0;
+				if (cgs.gametype == GT_CTY && (j == PW_REDFLAG || j == PW_BLUEFLAG))
+				{
+					if (j == PW_REDFLAG)
+					{
+						icoShader = trap_R_RegisterShaderNoMip( "gfx/hud/mpi_rflag_ys" );
+					}
+					else
+					{
+						icoShader = trap_R_RegisterShaderNoMip( "gfx/hud/mpi_bflag_ys" );
+					}
+				}
+				else
+				{
+					icoShader = trap_R_RegisterShader( item->icon );
+				}
+
+				CG_DrawPic( (640-(ico_size*1.1)) + xOffset, y, ico_size, ico_size, icoShader );
+	
+				y += ico_size;
+
+				if (j != PW_REDFLAG && j != PW_BLUEFLAG && secondsleft < 999)
+				{
+					UI_DrawProportionalString((640-(ico_size*1.1))+(ico_size/2) + xOffset, y-8, va("%i", secondsleft), UI_CENTER | UI_BIGFONT | UI_DROPSHADOW, colorTable[CT_WHITE]);
+				}
+
+				y += (ico_size/3);
+			}
+		}
+	}
+}
+
+
+/*
+=====================
+CG_DrawUpperRight
+
+=====================
+*/
+static void CG_DrawUpperRight( void ) {
+	float	y;
+
+#ifdef _XBOX
+	y = 50;
+#else
+	y = 0;
+#endif
+
+	trap_R_SetColor( colorTable[CT_WHITE] );
+
+	if ( cgs.gametype >= GT_TEAM && cg_drawTeamOverlay.integer == 1 ) {
+		y = CG_DrawTeamOverlay( y, qtrue, qtrue );
+	} 
+	if ( cg_drawSnapshot.integer ) {
+		y = CG_DrawSnapshot( y );
+	}
+
+	if ( cg_drawFPS.integer ) {
+		y = CG_DrawFPS( y );
+	}
+	if ( cg_drawTimer.integer ) {
+		y = CG_DrawTimer( y );
+	}
+
+	if ( ( cgs.gametype >= GT_TEAM || cg.predictedPlayerState.m_iVehicleNum )
+		&& cg_drawRadar.integer )
+	{//draw Radar in Siege mode or when in a vehicle of any kind
+		y = CG_DrawRadar ( y );
+	}
+
+	y = CG_DrawEnemyInfo ( y );
+
+	y = CG_DrawMiniScoreboard ( y );
+
+	CG_DrawPowerupIcons(y);
+}
+
+/*
+===================
+CG_DrawReward
+===================
+*/
+#ifdef JK2AWARDS
+static void CG_DrawReward( void ) { 
+	float	*color;
+	int		i, count;
+	float	x, y;
+	char	buf[32];
+
+	if ( !cg_drawRewards.integer ) {
+		return;
+	}
+
+	color = CG_FadeColor( cg.rewardTime, REWARD_TIME );
+	if ( !color ) {
+		if (cg.rewardStack > 0) {
+			for(i = 0; i < cg.rewardStack; i++) {
+				cg.rewardSound[i] = cg.rewardSound[i+1];
+				cg.rewardShader[i] = cg.rewardShader[i+1];
+				cg.rewardCount[i] = cg.rewardCount[i+1];
+			}
+			cg.rewardTime = cg.time;
+			cg.rewardStack--;
+			color = CG_FadeColor( cg.rewardTime, REWARD_TIME );
+			trap_S_StartLocalSound(cg.rewardSound[0], CHAN_ANNOUNCER);
+		} else {
+			return;
+		}
+	}
+
+	trap_R_SetColor( color );
+
+	/*
+	count = cg.rewardCount[0]/10;				// number of big rewards to draw
+
+	if (count) {
+		y = 4;
+		x = 320 - count * ICON_SIZE;
+		for ( i = 0 ; i < count ; i++ ) {
+			CG_DrawPic( x, y, (ICON_SIZE*2)-4, (ICON_SIZE*2)-4, cg.rewardShader[0] );
+			x += (ICON_SIZE*2);
+		}
+	}
+
+	count = cg.rewardCount[0] - count*10;		// number of small rewards to draw
+	*/
+
+	if ( cg.rewardCount[0] >= 10 ) {
+		y = 56;
+		x = 320 - ICON_SIZE/2;
+		CG_DrawPic( x, y, ICON_SIZE-4, ICON_SIZE-4, cg.rewardShader[0] );
+		Com_sprintf(buf, sizeof(buf), "%d", cg.rewardCount[0]);
+		x = ( SCREEN_WIDTH - SMALLCHAR_WIDTH * CG_DrawStrlen( buf ) ) / 2;
+		CG_DrawStringExt( x, y+ICON_SIZE, buf, color, qfalse, qtrue,
+								SMALLCHAR_WIDTH, SMALLCHAR_HEIGHT, 0 );
+	}
+	else {
+
+		count = cg.rewardCount[0];
+
+		y = 56;
+		x = 320 - count * ICON_SIZE/2;
+		for ( i = 0 ; i < count ; i++ ) {
+			CG_DrawPic( x, y, ICON_SIZE-4, ICON_SIZE-4, cg.rewardShader[0] );
+			x += ICON_SIZE;
+		}
+	}
+	trap_R_SetColor( NULL );
+}
+#endif
+
+
+/*
+===============================================================================
+
+LAGOMETER
+
+===============================================================================
+*/
+
+#define	LAG_SAMPLES		128
+
+
+typedef struct {
+	int		frameSamples[LAG_SAMPLES];
+	int		frameCount;
+	int		snapshotFlags[LAG_SAMPLES];
+	int		snapshotSamples[LAG_SAMPLES];
+	int		snapshotCount;
+} lagometer_t;
+
+lagometer_t		lagometer;
+
+/*
+==============
+CG_AddLagometerFrameInfo
+
+Adds the current interpolate / extrapolate bar for this frame
+==============
+*/
+void CG_AddLagometerFrameInfo( void ) {
+	int			offset;
+
+	offset = cg.time - cg.latestSnapshotTime;
+	lagometer.frameSamples[ lagometer.frameCount & ( LAG_SAMPLES - 1) ] = offset;
+	lagometer.frameCount++;
+}
+
+/*
+==============
+CG_AddLagometerSnapshotInfo
+
+Each time a snapshot is received, log its ping time and
+the number of snapshots that were dropped before it.
+
+Pass NULL for a dropped packet.
+==============
+*/
+void CG_AddLagometerSnapshotInfo( snapshot_t *snap ) {
+	// dropped packet
+	if ( !snap ) {
+		lagometer.snapshotSamples[ lagometer.snapshotCount & ( LAG_SAMPLES - 1) ] = -1;
+		lagometer.snapshotCount++;
+		return;
+	}
+
+	// add this snapshot's info
+	lagometer.snapshotSamples[ lagometer.snapshotCount & ( LAG_SAMPLES - 1) ] = snap->ping;
+	lagometer.snapshotFlags[ lagometer.snapshotCount & ( LAG_SAMPLES - 1) ] = snap->snapFlags;
+	lagometer.snapshotCount++;
+}
+
+/*
+==============
+CG_DrawDisconnect
+
+Should we draw something differnet for long lag vs no packets?
+==============
+*/
+static void CG_DrawDisconnect( void ) {
+	float		x, y;
+	int			cmdNum;
+	usercmd_t	cmd;
+	const char		*s;
+	int			w;  // bk010215 - FIXME char message[1024];
+
+	if (cg.mMapChange)
+	{			
+		s = CG_GetStringEdString("MP_INGAME", "SERVER_CHANGING_MAPS");	// s = "Server Changing Maps";			
+		w = CG_DrawStrlen( s ) * BIGCHAR_WIDTH;
+		CG_DrawBigString( 320 - w/2, 100, s, 1.0F);
+
+		s = CG_GetStringEdString("MP_INGAME", "PLEASE_WAIT");	// s = "Please wait...";
+		w = CG_DrawStrlen( s ) * BIGCHAR_WIDTH;
+		CG_DrawBigString( 320 - w/2, 200, s, 1.0F);
+		return;
+	}
+
+	// draw the phone jack if we are completely past our buffers
+	cmdNum = trap_GetCurrentCmdNumber() - CMD_BACKUP + 1;
+	trap_GetUserCmd( cmdNum, &cmd );
+	if ( cmd.serverTime <= cg.snap->ps.commandTime
+		|| cmd.serverTime > cg.time ) {	// special check for map_restart // bk 0102165 - FIXME
+		return;
+	}
+
+	// also add text in center of screen
+	s = CG_GetStringEdString("MP_INGAME", "CONNECTION_INTERRUPTED"); // s = "Connection Interrupted"; // bk 010215 - FIXME
+	w = CG_DrawStrlen( s ) * BIGCHAR_WIDTH;
+	CG_DrawBigString( 320 - w/2, 100, s, 1.0F);
+
+	// blink the icon
+	if ( ( cg.time >> 9 ) & 1 ) {
+		return;
+	}
+
+	x = 640 - 48;
+	y = 480 - 48;
+
+	CG_DrawPic( x, y, 48, 48, trap_R_RegisterShader("gfx/2d/net.tga" ) );
+}
+
+
+#define	MAX_LAGOMETER_PING	900
+#define	MAX_LAGOMETER_RANGE	300
+
+/*
+==============
+CG_DrawLagometer
+==============
+*/
+static void CG_DrawLagometer( void ) {
+	int		a, x, y, i;
+	float	v;
+	float	ax, ay, aw, ah, mid, range;
+	int		color;
+	float	vscale;
+
+	if ( !cg_lagometer.integer || cgs.localServer ) {
+		CG_DrawDisconnect();
+		return;
+	}
+
+	//
+	// draw the graph
+	//
+	x = 640 - 48;
+	y = 480 - 144;
+
+	trap_R_SetColor( NULL );
+	CG_DrawPic( x, y, 48, 48, cgs.media.lagometerShader );
+
+	ax = x;
+	ay = y;
+	aw = 48;
+	ah = 48;
+
+	color = -1;
+	range = ah / 3;
+	mid = ay + range;
+
+	vscale = range / MAX_LAGOMETER_RANGE;
+
+	// draw the frame interpoalte / extrapolate graph
+	for ( a = 0 ; a < aw ; a++ ) {
+		i = ( lagometer.frameCount - 1 - a ) & (LAG_SAMPLES - 1);
+		v = lagometer.frameSamples[i];
+		v *= vscale;
+		if ( v > 0 ) {
+			if ( color != 1 ) {
+				color = 1;
+				trap_R_SetColor( g_color_table[ColorIndex(COLOR_YELLOW)] );
+			}
+			if ( v > range ) {
+				v = range;
+			}
+			trap_R_DrawStretchPic ( ax + aw - a, mid - v, 1, v, 0, 0, 0, 0, cgs.media.whiteShader );
+		} else if ( v < 0 ) {
+			if ( color != 2 ) {
+				color = 2;
+				trap_R_SetColor( g_color_table[ColorIndex(COLOR_BLUE)] );
+			}
+			v = -v;
+			if ( v > range ) {
+				v = range;
+			}
+			trap_R_DrawStretchPic( ax + aw - a, mid, 1, v, 0, 0, 0, 0, cgs.media.whiteShader );
+		}
+	}
+
+	// draw the snapshot latency / drop graph
+	range = ah / 2;
+	vscale = range / MAX_LAGOMETER_PING;
+
+	for ( a = 0 ; a < aw ; a++ ) {
+		i = ( lagometer.snapshotCount - 1 - a ) & (LAG_SAMPLES - 1);
+		v = lagometer.snapshotSamples[i];
+		if ( v > 0 ) {
+			if ( lagometer.snapshotFlags[i] & SNAPFLAG_RATE_DELAYED ) {
+				if ( color != 5 ) {
+					color = 5;	// YELLOW for rate delay
+					trap_R_SetColor( g_color_table[ColorIndex(COLOR_YELLOW)] );
+				}
+			} else {
+				if ( color != 3 ) {
+					color = 3;
+					trap_R_SetColor( g_color_table[ColorIndex(COLOR_GREEN)] );
+				}
+			}
+			v = v * vscale;
+			if ( v > range ) {
+				v = range;
+			}
+			trap_R_DrawStretchPic( ax + aw - a, ay + ah - v, 1, v, 0, 0, 0, 0, cgs.media.whiteShader );
+		} else if ( v < 0 ) {
+			if ( color != 4 ) {
+				color = 4;		// RED for dropped snapshots
+				trap_R_SetColor( g_color_table[ColorIndex(COLOR_RED)] );
+			}
+			trap_R_DrawStretchPic( ax + aw - a, ay + ah - range, 1, range, 0, 0, 0, 0, cgs.media.whiteShader );
+		}
+	}
+
+	trap_R_SetColor( NULL );
+
+	if ( cg_nopredict.integer || cg_synchronousClients.integer ) {
+		CG_DrawBigString( ax, ay, "snc", 1.0 );
+	}
+
+	CG_DrawDisconnect();
+}
+
+void CG_DrawSiegeMessage( const char *str, int objectiveScreen )
+{
+//	if (!( trap_Key_GetCatcher() & KEYCATCH_UI ))
+	{
+		trap_OpenUIMenu(UIMENU_CLOSEALL);
+		trap_Cvar_Set("cg_siegeMessage", str);
+		if (objectiveScreen)
+		{
+			trap_OpenUIMenu(UIMENU_SIEGEOBJECTIVES);
+		}
+		else
+		{
+			trap_OpenUIMenu(UIMENU_SIEGEMESSAGE);
+		}
+	}
+}
+
+void CG_DrawSiegeMessageNonMenu( const char *str )
+{
+	char	text[1024];
+	if (str[0]=='@')
+	{	
+		trap_SP_GetStringTextString(str+1, text, sizeof(text));
+		str = text;
+	}
+	CG_CenterPrint(str, SCREEN_HEIGHT * 0.30, BIGCHAR_WIDTH);
+}
+
+/*
+===============================================================================
+
+CENTER PRINTING
+
+===============================================================================
+*/
+
+
+/*
+==============
+CG_CenterPrint
+
+Called for important messages that should stay in the center of the screen
+for a few moments
+==============
+*/
+void CG_CenterPrint( const char *str, int y, int charWidth ) {
+	char	*s;
+
+	Q_strncpyz( cg.centerPrint, str, sizeof(cg.centerPrint) );
+
+	cg.centerPrintTime = cg.time;
+	cg.centerPrintY = y;
+	cg.centerPrintCharWidth = charWidth;
+
+	// count the number of lines for centering
+	cg.centerPrintLines = 1;
+	s = cg.centerPrint;
+	while( *s ) {
+		if (*s == '\n')
+			cg.centerPrintLines++;
+		s++;
+	}
+}
+
+
+/*
+===================
+CG_DrawCenterString
+===================
+*/
+static void CG_DrawCenterString( void ) {
+	char	*start;
+	int		l;
+	int		x, y, w;
+	int h;
+	float	*color;
+	const float scale = 1.0; //0.5
+
+	if ( !cg.centerPrintTime ) {
+		return;
+	}
+
+	color = CG_FadeColor( cg.centerPrintTime, 1000 * cg_centertime.value );
+	if ( !color ) {
+		return;
+	}
+
+	trap_R_SetColor( color );
+
+	start = cg.centerPrint;
+
+	y = cg.centerPrintY - cg.centerPrintLines * BIGCHAR_HEIGHT / 2;
+
+	while ( 1 ) {
+		char linebuffer[1024];
+
+		for ( l = 0; l < 50; l++ ) {
+			if ( !start[l] || start[l] == '\n' ) {
+				break;
+			}
+			linebuffer[l] = start[l];
+		}
+		linebuffer[l] = 0;
+
+		w = CG_Text_Width(linebuffer, scale, FONT_MEDIUM);
+		h = CG_Text_Height(linebuffer, scale, FONT_MEDIUM);
+		x = (SCREEN_WIDTH - w) / 2;
+		CG_Text_Paint(x, y + h, scale, color, linebuffer, 0, 0, ITEM_TEXTSTYLE_SHADOWEDMORE, FONT_MEDIUM);
+		y += h + 6;
+
+		while ( *start && ( *start != '\n' ) ) {
+			start++;
+		}
+		if ( !*start ) {
+			break;
+		}
+		start++;
+	}
+
+	trap_R_SetColor( NULL );
+}
+
+
+
+/*
+================================================================================
+
+CROSSHAIR
+
+================================================================================
+*/
+
+#define HEALTH_WIDTH		50.0f
+#define HEALTH_HEIGHT		5.0f
+
+//see if we can draw some extra info on this guy based on our class
+void CG_DrawSiegeInfo(centity_t *cent, float chX, float chY, float chW, float chH)
+{
+	siegeExtended_t *se = &cg_siegeExtendedData[cent->currentState.number];
+	clientInfo_t *ci;
+	const char *configstring, *v;
+	siegeClass_t *siegeClass;
+	vec4_t aColor;
+	vec4_t bColor;
+	vec4_t cColor;
+	float x;
+	float y;
+	float percent;
+	int ammoMax;
+
+	assert(cent->currentState.number < MAX_CLIENTS);
+
+	if (se->lastUpdated > cg.time)
+	{ //strange, shouldn't happen
+		return;
+	}
+	
+	if ((cg.time - se->lastUpdated) > 10000)
+	{ //if you haven't received a status update on this guy in 10 seconds, forget about it
+		return;
+	}
+
+	if (cent->currentState.eFlags & EF_DEAD)
+	{ //he's dead, don't display info on him
+		return;
+	}
+
+	if (cent->currentState.weapon != se->weapon)
+	{ //data is invalidated until it syncs back again
+		return;
+	}
+
+	ci = &cgs.clientinfo[cent->currentState.number];
+	if (ci->team != cg.predictedPlayerState.persistant[PERS_TEAM])
+	{ //not on the same team
+		return;
+	}
+
+	configstring = CG_ConfigString( cg.predictedPlayerState.clientNum + CS_PLAYERS );
+	v = Info_ValueForKey( configstring, "siegeclass" );
+
+	if (!v || !v[0])
+	{ //don't have siege class in info?
+		return;
+	}
+
+	siegeClass = BG_SiegeFindClassByName(v);
+
+	if (!siegeClass)
+	{ //invalid
+		return;
+	}
+
+    if (!(siegeClass->classflags & (1<<CFL_STATVIEWER)))
+	{ //doesn't really have the ability to see others' stats
+		return;
+	}
+
+	x = chX+((chW/2)-(HEALTH_WIDTH/2));
+	y = (chY+chH) + 8.0f;
+	percent = ((float)se->health/(float)se->maxhealth)*HEALTH_WIDTH;
+
+	//color of the bar
+	aColor[0] = 0.0f;
+	aColor[1] = 1.0f;
+	aColor[2] = 0.0f;
+	aColor[3] = 0.4f;
+
+	//color of the border
+	bColor[0] = 0.0f;
+	bColor[1] = 0.0f;
+	bColor[2] = 0.0f;
+	bColor[3] = 0.3f;
+
+	//color of greyed out "missing health"
+	cColor[0] = 0.5f;
+	cColor[1] = 0.5f;
+	cColor[2] = 0.5f;
+	cColor[3] = 0.4f;
+
+	//draw the background (black)
+	CG_DrawRect(x, y, HEALTH_WIDTH, HEALTH_HEIGHT, 1.0f, colorTable[CT_BLACK]);
+
+	//now draw the part to show how much health there is in the color specified
+	CG_FillRect(x+1.0f, y+1.0f, percent-1.0f, HEALTH_HEIGHT-1.0f, aColor);
+
+	//then draw the other part greyed out
+	CG_FillRect(x+percent, y+1.0f, HEALTH_WIDTH-percent-1.0f, HEALTH_HEIGHT-1.0f, cColor);
+
+
+	//now draw his ammo
+	ammoMax = ammoData[weaponData[cent->currentState.weapon].ammoIndex].max;
+	if ( (cent->currentState.eFlags & EF_DOUBLE_AMMO) )
+	{
+		ammoMax *= 2;
+	}
+
+	x = chX+((chW/2)-(HEALTH_WIDTH/2));
+	y = (chY+chH) + HEALTH_HEIGHT + 10.0f;
+
+	if (!weaponData[cent->currentState.weapon].energyPerShot &&
+		!weaponData[cent->currentState.weapon].altEnergyPerShot)
+	{ //a weapon that takes no ammo, so show full
+		percent = HEALTH_WIDTH;
+	}
+	else
+	{
+		percent = ((float)se->ammo/(float)ammoMax)*HEALTH_WIDTH;
+	}
+
+	//color of the bar
+	aColor[0] = 1.0f;
+	aColor[1] = 1.0f;
+	aColor[2] = 0.0f;
+	aColor[3] = 0.4f;
+
+	//color of the border
+	bColor[0] = 0.0f;
+	bColor[1] = 0.0f;
+	bColor[2] = 0.0f;
+	bColor[3] = 0.3f;
+
+	//color of greyed out "missing health"
+	cColor[0] = 0.5f;
+	cColor[1] = 0.5f;
+	cColor[2] = 0.5f;
+	cColor[3] = 0.4f;
+
+	//draw the background (black)
+	CG_DrawRect(x, y, HEALTH_WIDTH, HEALTH_HEIGHT, 1.0f, colorTable[CT_BLACK]);
+
+	//now draw the part to show how much health there is in the color specified
+	CG_FillRect(x+1.0f, y+1.0f, percent-1.0f, HEALTH_HEIGHT-1.0f, aColor);
+
+	//then draw the other part greyed out
+	CG_FillRect(x+percent, y+1.0f, HEALTH_WIDTH-percent-1.0f, HEALTH_HEIGHT-1.0f, cColor);
+}
+
+//draw the health bar based on current "health" and maxhealth
+void CG_DrawHealthBar(centity_t *cent, float chX, float chY, float chW, float chH)
+{
+	vec4_t aColor;
+	vec4_t bColor;
+	vec4_t cColor;
+	float x = chX+((chW/2)-(HEALTH_WIDTH/2));
+	float y = (chY+chH) + 8.0f;
+	float percent = ((float)cent->currentState.health/(float)cent->currentState.maxhealth)*HEALTH_WIDTH;
+	if (percent <= 0)
+	{
+		return;
+	}
+
+	//color of the bar
+	if (!cent->currentState.teamowner || cgs.gametype < GT_TEAM)
+	{ //not owned by a team or teamplay
+		aColor[0] = 1.0f;
+		aColor[1] = 1.0f;
+		aColor[2] = 0.0f;
+		aColor[3] = 0.4f;
+	}
+	else if (cent->currentState.teamowner == cg.predictedPlayerState.persistant[PERS_TEAM])
+	{ //owned by my team
+		aColor[0] = 0.0f;
+		aColor[1] = 1.0f;
+		aColor[2] = 0.0f;
+		aColor[3] = 0.4f;
+	}
+	else
+	{ //hostile
+		aColor[0] = 1.0f;
+		aColor[1] = 0.0f;
+		aColor[2] = 0.0f;
+		aColor[3] = 0.4f;
+	}
+
+	//color of the border
+	bColor[0] = 0.0f;
+	bColor[1] = 0.0f;
+	bColor[2] = 0.0f;
+	bColor[3] = 0.3f;
+
+	//color of greyed out "missing health"
+	cColor[0] = 0.5f;
+	cColor[1] = 0.5f;
+	cColor[2] = 0.5f;
+	cColor[3] = 0.4f;
+
+	//draw the background (black)
+	CG_DrawRect(x, y, HEALTH_WIDTH, HEALTH_HEIGHT, 1.0f, colorTable[CT_BLACK]);
+
+	//now draw the part to show how much health there is in the color specified
+	CG_FillRect(x+1.0f, y+1.0f, percent-1.0f, HEALTH_HEIGHT-1.0f, aColor);
+
+	//then draw the other part greyed out
+	CG_FillRect(x+percent, y+1.0f, HEALTH_WIDTH-percent-1.0f, HEALTH_HEIGHT-1.0f, cColor);
+}
+
+//same routine (at least for now), draw progress of a "hack" or whatever
+void CG_DrawHaqrBar(float chX, float chY, float chW, float chH)
+{
+	vec4_t aColor;
+	vec4_t bColor;
+	vec4_t cColor;
+	float x = chX+((chW/2)-(HEALTH_WIDTH/2));
+	float y = (chY+chH) + 8.0f;
+	float percent = (((float)cg.predictedPlayerState.hackingTime-(float)cg.time)/(float)cg.predictedPlayerState.hackingBaseTime)*HEALTH_WIDTH;
+
+	if (percent > HEALTH_WIDTH ||
+		percent < 1.0f)
+	{
+		return;
+	}
+
+	//color of the bar
+	aColor[0] = 1.0f;
+	aColor[1] = 1.0f;
+	aColor[2] = 0.0f;
+	aColor[3] = 0.4f;
+
+	//color of the border
+	bColor[0] = 0.0f;
+	bColor[1] = 0.0f;
+	bColor[2] = 0.0f;
+	bColor[3] = 0.3f;
+
+	//color of greyed out done area
+	cColor[0] = 0.5f;
+	cColor[1] = 0.5f;
+	cColor[2] = 0.5f;
+	cColor[3] = 0.1f;
+
+	//draw the background (black)
+	CG_DrawRect(x, y, HEALTH_WIDTH, HEALTH_HEIGHT, 1.0f, colorTable[CT_BLACK]);
+
+	//now draw the part to show how much health there is in the color specified
+	CG_FillRect(x+1.0f, y+1.0f, percent-1.0f, HEALTH_HEIGHT-1.0f, aColor);
+
+	//then draw the other part greyed out
+	CG_FillRect(x+percent, y+1.0f, HEALTH_WIDTH-percent-1.0f, HEALTH_HEIGHT-1.0f, cColor);
+
+	//draw the hacker icon
+	CG_DrawPic(x, y-HEALTH_WIDTH, HEALTH_WIDTH, HEALTH_WIDTH, cgs.media.hackerIconShader);
+}
+
+//generic timing bar
+int cg_genericTimerBar = 0;
+int cg_genericTimerDur = 0;
+vec4_t cg_genericTimerColor;
+#define CGTIMERBAR_H			50.0f
+#define CGTIMERBAR_W			10.0f
+#define CGTIMERBAR_X			(SCREEN_WIDTH-CGTIMERBAR_W-120.0f)
+#define CGTIMERBAR_Y			(SCREEN_HEIGHT-CGTIMERBAR_H-20.0f)
+void CG_DrawGenericTimerBar(void)
+{
+	vec4_t aColor;
+	vec4_t bColor;
+	vec4_t cColor;
+	float x = CGTIMERBAR_X;
+	float y = CGTIMERBAR_Y;
+	float percent = ((float)(cg_genericTimerBar-cg.time)/(float)cg_genericTimerDur)*CGTIMERBAR_H;
+
+	if (percent > CGTIMERBAR_H)
+	{
+		return;
+	}
+
+	if (percent < 0.1f)
+	{
+		percent = 0.1f;
+	}
+
+	//color of the bar
+	aColor[0] = cg_genericTimerColor[0];
+	aColor[1] = cg_genericTimerColor[1];
+	aColor[2] = cg_genericTimerColor[2];
+	aColor[3] = cg_genericTimerColor[3];
+
+	//color of the border
+	bColor[0] = 0.0f;
+	bColor[1] = 0.0f;
+	bColor[2] = 0.0f;
+	bColor[3] = 0.3f;
+
+	//color of greyed out "missing fuel"
+	cColor[0] = 0.5f;
+	cColor[1] = 0.5f;
+	cColor[2] = 0.5f;
+	cColor[3] = 0.1f;
+
+	//draw the background (black)
+	CG_DrawRect(x, y, CGTIMERBAR_W, CGTIMERBAR_H, 1.0f, colorTable[CT_BLACK]);
+
+	//now draw the part to show how much health there is in the color specified
+	CG_FillRect(x+1.0f, y+1.0f+(CGTIMERBAR_H-percent), CGTIMERBAR_W-2.0f, CGTIMERBAR_H-1.0f-(CGTIMERBAR_H-percent), aColor);
+
+	//then draw the other part greyed out
+	CG_FillRect(x+1.0f, y+1.0f, CGTIMERBAR_W-2.0f, CGTIMERBAR_H-percent, cColor);
+}
+
+/*
+=================
+CG_DrawCrosshair
+=================
+*/
+
+#ifdef _XBOX
+int cg_crossHairStatus = 0;
+#endif
+
+float cg_crosshairPrevPosX = 0;
+float cg_crosshairPrevPosY = 0;
+#define CRAZY_CROSSHAIR_MAX_ERROR_X	(100.0f*640.0f/480.0f)
+#define CRAZY_CROSSHAIR_MAX_ERROR_Y	(100.0f)
+void CG_LerpCrosshairPos( float *x, float *y )
+{
+	if ( cg_crosshairPrevPosX )
+	{//blend from old pos
+		float maxMove = 30.0f * ((float)cg.frametime/500.0f) * 640.0f/480.0f;
+		float xDiff = (*x - cg_crosshairPrevPosX);
+		if ( fabs(xDiff) > CRAZY_CROSSHAIR_MAX_ERROR_X )
+		{
+			maxMove = CRAZY_CROSSHAIR_MAX_ERROR_X;
+		}
+		if ( xDiff > maxMove )
+		{
+			*x = cg_crosshairPrevPosX + maxMove;
+		}
+		else if ( xDiff < -maxMove )
+		{
+			*x = cg_crosshairPrevPosX - maxMove;
+		}
+	}
+	cg_crosshairPrevPosX = *x;
+
+	if ( cg_crosshairPrevPosY )
+	{//blend from old pos
+		float maxMove = 30.0f * ((float)cg.frametime/500.0f);
+		float yDiff = (*y - cg_crosshairPrevPosY);
+		if ( fabs(yDiff) > CRAZY_CROSSHAIR_MAX_ERROR_Y )
+		{
+			maxMove = CRAZY_CROSSHAIR_MAX_ERROR_X;
+		}
+		if ( yDiff > maxMove )
+		{
+			*y = cg_crosshairPrevPosY + maxMove;
+		}
+		else if ( yDiff < -maxMove )
+		{
+			*y = cg_crosshairPrevPosY - maxMove;
+		}
+	}
+	cg_crosshairPrevPosY = *y;
+}
+
+vec3_t cg_crosshairPos={0,0,0};
+static void CG_DrawCrosshair( vec3_t worldPoint, int chEntValid ) {
+	float		w, h;
+	qhandle_t	hShader = 0;
+	float		f;
+	float		x, y;
+	qboolean	corona = qfalse;
+	vec4_t		ecolor = {0,0,0,0};
+	centity_t	*crossEnt = NULL;
+	float		chX, chY;
+
+#ifdef _XBOX
+	cg_crossHairStatus = 0;
+#endif
+
+	if ( worldPoint )
+	{
+		VectorCopy( worldPoint, cg_crosshairPos );
+	}
+
+	if ( !cg_drawCrosshair.integer ) 
+	{
+		return;
+	}
+
+	if (cg.snap->ps.fallingToDeath)
+	{
+		return;
+	}
+
+	if ( cg.predictedPlayerState.zoomMode != 0 )
+	{//not while scoped
+		return;
+	}
+
+	if ( cg_crosshairHealth.integer )
+	{
+		vec4_t		hcolor;
+
+		CG_ColorForHealth( hcolor );
+		trap_R_SetColor( hcolor );
+	}
+	else
+	{
+		//set color based on what kind of ent is under crosshair
+		if ( cg.crosshairClientNum >= ENTITYNUM_WORLD )
+		{
+			trap_R_SetColor( NULL );
+		}
+		//rwwFIXMEFIXME: Write this a different way, it's getting a bit too sloppy looking
+		else if (chEntValid &&
+			(cg_entities[cg.crosshairClientNum].currentState.number < MAX_CLIENTS ||
+			cg_entities[cg.crosshairClientNum].currentState.eType == ET_NPC ||
+			cg_entities[cg.crosshairClientNum].currentState.shouldtarget ||
+			cg_entities[cg.crosshairClientNum].currentState.health || //always show ents with health data under crosshair
+			(cg_entities[cg.crosshairClientNum].currentState.eType == ET_MOVER && cg_entities[cg.crosshairClientNum].currentState.bolt1 && cg.predictedPlayerState.weapon == WP_SABER) ||
+			(cg_entities[cg.crosshairClientNum].currentState.eType == ET_MOVER && cg_entities[cg.crosshairClientNum].currentState.teamowner)))
+		{
+			crossEnt = &cg_entities[cg.crosshairClientNum];
+
+			if ( crossEnt->currentState.powerups & (1 <<PW_CLOAKED) )
+			{ //don't show up for cloaked guys
+				ecolor[0] = 1.0;//R
+				ecolor[1] = 1.0;//G
+				ecolor[2] = 1.0;//B
+			}
+			else if ( crossEnt->currentState.number < MAX_CLIENTS )
+			{
+				if (cgs.gametype >= GT_TEAM &&
+					cgs.clientinfo[crossEnt->currentState.number].team == cgs.clientinfo[cg.snap->ps.clientNum].team )
+				{
+					//Allies are green
+					ecolor[0] = 0.0;//R
+					ecolor[1] = 1.0;//G
+					ecolor[2] = 0.0;//B
+				}
+				else
+				{
+					if (cgs.gametype == GT_POWERDUEL &&
+						cgs.clientinfo[crossEnt->currentState.number].duelTeam == cgs.clientinfo[cg.snap->ps.clientNum].duelTeam)
+					{ //on the same duel team in powerduel, so he's a friend
+						ecolor[0] = 0.0;//R
+						ecolor[1] = 1.0;//G
+						ecolor[2] = 0.0;//B
+					}
+					else
+					{ //Enemies are red
+						ecolor[0] = 1.0;//R
+						ecolor[1] = 0.0;//G
+						ecolor[2] = 0.0;//B
+#ifdef _XBOX
+						cg_crossHairStatus = 1;
+#endif
+					}
+				}
+
+				if (cg.snap->ps.duelInProgress)
+				{
+					if (crossEnt->currentState.number != cg.snap->ps.duelIndex)
+					{ //grey out crosshair for everyone but your foe if you're in a duel
+						ecolor[0] = 0.4;
+						ecolor[1] = 0.4;
+						ecolor[2] = 0.4;
+					}
+				}
+				else if (crossEnt->currentState.bolt1)
+				{ //this fellow is in a duel. We just checked if we were in a duel above, so
+				  //this means we aren't and he is. Which of course means our crosshair greys out over him.
+					ecolor[0] = 0.4;
+					ecolor[1] = 0.4;
+					ecolor[2] = 0.4;
+				}
+			}
+			else if (crossEnt->currentState.shouldtarget || crossEnt->currentState.eType == ET_NPC)
+			{
+				//VectorCopy( crossEnt->startRGBA, ecolor );
+				if ( !ecolor[0] && !ecolor[1] && !ecolor[2] )
+				{
+					// We really don't want black, so set it to yellow
+					ecolor[0] = 1.0F;//R
+					ecolor[1] = 0.8F;//G
+					ecolor[2] = 0.3F;//B
+				}
+
+				if (crossEnt->currentState.eType == ET_NPC)
+				{
+					int plTeam;
+					if (cgs.gametype == GT_SIEGE)
+					{
+						plTeam = cg.predictedPlayerState.persistant[PERS_TEAM];
+					}
+					else
+					{
+						plTeam = NPCTEAM_PLAYER;
+					}
+
+					if ( crossEnt->currentState.powerups & (1 <<PW_CLOAKED) )
+					{
+						ecolor[0] = 1.0;//R
+						ecolor[1] = 1.0;//G
+						ecolor[2] = 1.0;//B
+					}
+					else if ( !crossEnt->currentState.teamowner )
+					{ //not on a team
+						if (!crossEnt->currentState.teamowner ||
+							crossEnt->currentState.NPC_class == CLASS_VEHICLE)
+						{ //neutral
+							if (crossEnt->currentState.owner < MAX_CLIENTS)
+							{ //base color on who is pilotting this thing
+								clientInfo_t *ci = &cgs.clientinfo[crossEnt->currentState.owner];
+
+								if (cgs.gametype >= GT_TEAM && ci->team == cg.predictedPlayerState.persistant[PERS_TEAM])
+								{ //friendly
+									ecolor[0] = 0.0;//R
+									ecolor[1] = 1.0;//G
+									ecolor[2] = 0.0;//B
+								}
+								else
+								{ //hostile
+									ecolor[0] = 1.0;//R
+									ecolor[1] = 0.0;//G
+									ecolor[2] = 0.0;//B
+#ifdef _XBOX
+									cg_crossHairStatus = 1;
+#endif
+								}
+							}
+							else
+							{ //unmanned
+								ecolor[0] = 1.0;//R
+								ecolor[1] = 1.0;//G
+								ecolor[2] = 0.0;//B
+							}
+						}
+						else
+						{
+							ecolor[0] = 1.0;//R
+							ecolor[1] = 0.0;//G
+							ecolor[2] = 0.0;//B
+#ifdef _XBOX
+							cg_crossHairStatus = 1;
+#endif
+						}
+					}
+					else if ( crossEnt->currentState.teamowner != plTeam )
+					{// on enemy team
+						ecolor[0] = 1.0;//R
+						ecolor[1] = 0.0;//G
+						ecolor[2] = 0.0;//B
+#ifdef _XBOX
+						cg_crossHairStatus = 1;
+#endif
+					}
+					else
+					{ //a friend
+						ecolor[0] = 0.0;//R
+						ecolor[1] = 1.0;//G
+						ecolor[2] = 0.0;//B
+					}
+				}
+				else if ( crossEnt->currentState.teamowner == TEAM_RED
+					|| crossEnt->currentState.teamowner == TEAM_BLUE )
+				{
+					if (cgs.gametype < GT_TEAM)
+					{ //not teamplay, just neutral then
+						ecolor[0] = 1.0;//R
+						ecolor[1] = 1.0;//G
+						ecolor[2] = 0.0;//B
+					}
+					else if ( crossEnt->currentState.teamowner != cgs.clientinfo[cg.snap->ps.clientNum].team )
+					{ //on the enemy team
+						ecolor[0] = 1.0;//R
+						ecolor[1] = 0.0;//G
+						ecolor[2] = 0.0;//B
+#ifdef _XBOX
+						cg_crossHairStatus = 1;
+#endif
+					}
+					else
+					{ //on my team
+						ecolor[0] = 0.0;//R
+						ecolor[1] = 1.0;//G
+						ecolor[2] = 0.0;//B
+					}
+				}
+				else if (crossEnt->currentState.owner == cg.snap->ps.clientNum ||
+					(cgs.gametype >= GT_TEAM && crossEnt->currentState.teamowner == cgs.clientinfo[cg.snap->ps.clientNum].team))
+				{
+					ecolor[0] = 0.0;//R
+					ecolor[1] = 1.0;//G
+					ecolor[2] = 0.0;//B
+				}
+				else if (crossEnt->currentState.teamowner == 16 ||
+					(cgs.gametype >= GT_TEAM && crossEnt->currentState.teamowner && crossEnt->currentState.teamowner != cgs.clientinfo[cg.snap->ps.clientNum].team))
+				{
+					ecolor[0] = 1.0;//R
+					ecolor[1] = 0.0;//G
+					ecolor[2] = 0.0;//B
+#ifdef _XBOX
+					cg_crossHairStatus = 1;
+#endif
+				}
+			}
+			else if (crossEnt->currentState.eType == ET_MOVER && crossEnt->currentState.bolt1 && cg.predictedPlayerState.weapon == WP_SABER)
+			{ //can push/pull this mover. Only show it if we're using the saber.
+				ecolor[0] = 0.2f;
+				ecolor[1] = 0.5f;
+				ecolor[2] = 1.0f;
+
+				corona = qtrue;
+			}
+			else if (crossEnt->currentState.eType == ET_MOVER && crossEnt->currentState.teamowner)
+			{ //a team owns this - if it's my team green, if not red, if not teamplay then yellow
+				if (cgs.gametype < GT_TEAM)
+				{
+					ecolor[0] = 1.0;//R
+					ecolor[1] = 1.0;//G
+					ecolor[2] = 0.0;//B
+				}
+                else if (cg.predictedPlayerState.persistant[PERS_TEAM] != crossEnt->currentState.teamowner)
+				{ //not my team
+					ecolor[0] = 1.0;//R
+					ecolor[1] = 0.0;//G
+					ecolor[2] = 0.0;//B
+#ifdef _XBOX
+					cg_crossHairStatus = 1;
+#endif
+				}
+				else
+				{ //my team
+					ecolor[0] = 0.0;//R
+					ecolor[1] = 1.0;//G
+					ecolor[2] = 0.0;//B
+				}
+			}
+			else if (crossEnt->currentState.health)
+			{
+				if (!crossEnt->currentState.teamowner || cgs.gametype < GT_TEAM)
+				{ //not owned by a team or teamplay
+					ecolor[0] = 1.0f;
+					ecolor[1] = 1.0f;
+					ecolor[2] = 0.0f;
+				}
+				else if (crossEnt->currentState.teamowner == cg.predictedPlayerState.persistant[PERS_TEAM])
+				{ //owned by my team
+					ecolor[0] = 0.0f;
+					ecolor[1] = 1.0f;
+					ecolor[2] = 0.0f;
+				}
+				else
+				{ //hostile
+					ecolor[0] = 1.0f;
+					ecolor[1] = 0.0f;
+					ecolor[2] = 0.0f;
+#ifdef _XBOX
+					cg_crossHairStatus = 1;
+#endif
+				}
+			}
+
+			ecolor[3] = 1.0;
+
+			trap_R_SetColor( ecolor );
+		}
+	}
+
+	if ( cg.predictedPlayerState.m_iVehicleNum )
+	{//I'm in a vehicle
+		centity_t *vehCent = &cg_entities[cg.predictedPlayerState.m_iVehicleNum];
+	    if ( vehCent 
+			&& vehCent->m_pVehicle 
+			&& vehCent->m_pVehicle->m_pVehicleInfo 
+			&& vehCent->m_pVehicle->m_pVehicleInfo->crosshairShaderHandle )
+		{
+			hShader = vehCent->m_pVehicle->m_pVehicleInfo->crosshairShaderHandle;
+		}
+		//bigger by default
+		w = cg_crosshairSize.value*2.0f;
+		h = w;
+	}
+	else
+	{
+		w = h = cg_crosshairSize.value;
+	}
+
+	// pulse the size of the crosshair when picking up items
+	f = cg.time - cg.itemPickupBlendTime;
+	if ( f > 0 && f < ITEM_BLOB_TIME ) {
+		f /= ITEM_BLOB_TIME;
+		w *= ( 1 + f );
+		h *= ( 1 + f );
+	}
+
+	if ( worldPoint && VectorLength( worldPoint ) )
+	{
+		if ( !CG_WorldCoordToScreenCoordFloat( worldPoint, &x, &y ) )
+		{//off screen, don't draw it
+			return;
+		}
+		//CG_LerpCrosshairPos( &x, &y );
+		x -= 320;
+		y -= 240;
+	}
+	else
+	{
+		x = cg_crosshairX.integer;
+		y = cg_crosshairY.integer;
+	}
+
+	if ( !hShader )
+	{
+		hShader = cgs.media.crosshairShader[ cg_drawCrosshair.integer % NUM_CROSSHAIRS ];
+	}
+
+	chX = x + cg.refdef.x + 0.5 * (640 - w);
+	chY = y + cg.refdef.y + 0.5 * (480 - h);
+	trap_R_DrawStretchPic( chX, chY, w, h, 0, 0, 1, 1, hShader );
+
+	//draw a health bar directly under the crosshair if we're looking at something
+	//that takes damage
+	if (crossEnt &&
+		crossEnt->currentState.maxhealth)
+	{
+		CG_DrawHealthBar(crossEnt, chX, chY, w, h);
+		chY += HEALTH_HEIGHT*2;
+	}
+	else if (crossEnt && crossEnt->currentState.number < MAX_CLIENTS)
+	{
+		if (cgs.gametype == GT_SIEGE)
+		{
+			CG_DrawSiegeInfo(crossEnt, chX, chY, w, h);
+			chY += HEALTH_HEIGHT*4;
+		}
+		if (cg.crosshairVehNum && cg.time == cg.crosshairVehTime)
+		{ //it was in the crosshair this frame
+			centity_t *hisVeh = &cg_entities[cg.crosshairVehNum];
+
+			if (hisVeh->currentState.eType == ET_NPC &&
+				hisVeh->currentState.NPC_class == CLASS_VEHICLE &&
+				hisVeh->currentState.maxhealth &&
+				hisVeh->m_pVehicle)
+			{ //draw the health for this vehicle
+				CG_DrawHealthBar(hisVeh, chX, chY, w, h);
+				chY += HEALTH_HEIGHT*2;
+			}
+		}
+	}
+
+	if (cg.predictedPlayerState.hackingTime)
+	{ //hacking something
+		CG_DrawHaqrBar(chX, chY, w, h);
+	}
+
+	if (cg_genericTimerBar > cg.time)
+	{ //draw generic timing bar, can be used for whatever
+		CG_DrawGenericTimerBar();
+	}
+
+	if ( corona ) // drawing extra bits
+	{
+		ecolor[3] = 0.5f;
+		ecolor[0] = ecolor[1] = ecolor[2] = (1 - ecolor[3]) * ( sin( cg.time * 0.001f ) * 0.08f + 0.35f ); // don't draw full color
+		ecolor[3] = 1.0f;
+
+		trap_R_SetColor( ecolor );
+
+		w *= 2.0f;
+		h *= 2.0f;
+
+		trap_R_DrawStretchPic( x + cg.refdef.x + 0.5 * (640 - w), 
+			y + cg.refdef.y + 0.5 * (480 - h), 
+			w, h, 0, 0, 1, 1, cgs.media.forceCoronaShader );
+	}
+}
+
+qboolean CG_WorldCoordToScreenCoordFloat(vec3_t worldCoord, float *x, float *y)
+{
+	float	xcenter, ycenter;
+	vec3_t	local, transformed;
+	vec3_t	vfwd;
+	vec3_t	vright;
+	vec3_t	vup;
+	float xzi;
+	float yzi;
+
+//	xcenter = cg.refdef.width / 2;//gives screen coords adjusted for resolution
+//	ycenter = cg.refdef.height / 2;//gives screen coords adjusted for resolution
+	
+	//NOTE: did it this way because most draw functions expect virtual 640x480 coords
+	//	and adjust them for current resolution
+	xcenter = 640.0f / 2.0f;//gives screen coords in virtual 640x480, to be adjusted when drawn
+	ycenter = 480.0f / 2.0f;//gives screen coords in virtual 640x480, to be adjusted when drawn
+
+	AngleVectors (cg.refdef.viewangles, vfwd, vright, vup);
+
+	VectorSubtract (worldCoord, cg.refdef.vieworg, local);
+
+	transformed[0] = DotProduct(local,vright);
+	transformed[1] = DotProduct(local,vup);
+	transformed[2] = DotProduct(local,vfwd);		
+
+	// Make sure Z is not negative.
+	if(transformed[2] < 0.01f)
+	{
+		return qfalse;
+	}
+
+	xzi = xcenter / transformed[2] * (96.0f/cg.refdef.fov_x);
+	yzi = ycenter / transformed[2] * (102.0f/cg.refdef.fov_y);
+
+	*x = xcenter + xzi * transformed[0];
+	*y = ycenter - yzi * transformed[1];
+
+	return qtrue;
+}
+
+qboolean CG_WorldCoordToScreenCoord( vec3_t worldCoord, int *x, int *y )
+{
+	float	xF, yF;
+	qboolean retVal = CG_WorldCoordToScreenCoordFloat( worldCoord, &xF, &yF );
+	*x = (int)xF;
+	*y = (int)yF;
+	return retVal;
+}
+
+/*
+====================
+CG_SaberClashFlare
+====================
+*/
+int cg_saberFlashTime = 0;
+vec3_t cg_saberFlashPos = {0, 0, 0};
+void CG_SaberClashFlare( void ) 
+{
+	int				t, maxTime = 150;
+	vec3_t dif;
+	vec3_t color;
+	int x,y;
+	float v, len;
+	trace_t tr;
+
+	t = cg.time - cg_saberFlashTime;
+
+	if ( t <= 0 || t >= maxTime ) 
+	{
+		return;
+	}
+
+	// Don't do clashes for things that are behind us
+	VectorSubtract( cg_saberFlashPos, cg.refdef.vieworg, dif );
+
+	if ( DotProduct( dif, cg.refdef.viewaxis[0] ) < 0.2 )
+	{
+		return;
+	}
+
+	CG_Trace( &tr, cg.refdef.vieworg, NULL, NULL, cg_saberFlashPos, -1, CONTENTS_SOLID );
+
+	if ( tr.fraction < 1.0f )
+	{
+		return;
+	}
+
+	len = VectorNormalize( dif );
+
+	// clamp to a known range
+	/*
+	if ( len > 800 )
+	{
+		len = 800;
+	}
+	*/
+	if ( len > 1200 )
+	{
+		return;
+	}
+
+	v = ( 1.0f - ((float)t / maxTime )) * ((1.0f - ( len / 800.0f )) * 2.0f + 0.35f);
+	if (v < 0.001f)
+	{
+		v = 0.001f;
+	}
+
+	CG_WorldCoordToScreenCoord( cg_saberFlashPos, &x, &y );
+
+	VectorSet( color, 0.8f, 0.8f, 0.8f );
+	trap_R_SetColor( color );
+
+	CG_DrawPic( x - ( v * 300 ), y - ( v * 300 ),
+				v * 600, v * 600,
+				trap_R_RegisterShader( "gfx/effects/saberFlare" ));
+}
+
+void CG_BracketEntity( centity_t *cent, float radius )
+{
+	trace_t tr;
+	vec3_t dif;
+	float	len, size, lineLength, lineWidth;
+	float	x,	y;
+	clientInfo_t *local;
+
+	VectorSubtract( cent->lerpOrigin, cg.refdef.vieworg, dif );
+	len = VectorNormalize( dif );
+
+	if ( cg.crosshairClientNum != cent->currentState.clientNum
+		&& (!cg.snap||cg.snap->ps.rocketLockIndex!= cent->currentState.clientNum) )
+	{//if they're the entity you're locking onto or under your crosshair, always draw bracket
+		//Hmm... for now, if they're closer than 2000, don't bracket?
+		if ( len < 2000.0f )
+		{
+			return;
+		}
+
+		CG_Trace( &tr, cg.refdef.vieworg, NULL, NULL, cent->lerpOrigin, -1, CONTENTS_OPAQUE );
+
+		//don't bracket if can't see them
+		if ( tr.fraction < 1.0f )
+		{
+			return;
+		}
+	}
+
+	if ( !CG_WorldCoordToScreenCoordFloat(cent->lerpOrigin, &x, &y) )
+	{//off-screen, don't draw it
+		return;
+	}
+
+	//just to see if it's centered
+	//CG_DrawPic( x-2, y-2, 4, 4, cgs.media.whiteShader );
+
+	local = &cgs.clientinfo[cg.snap->ps.clientNum];
+	if ( cent->currentState.m_iVehicleNum //vehicle has a driver
+		&& cgs.clientinfo[ cent->currentState.m_iVehicleNum-1 ].infoValid )
+	{
+		if ( cgs.clientinfo[ cent->currentState.m_iVehicleNum-1 ].team == local->team )
+		{
+			trap_R_SetColor ( g_color_table[ColorIndex(COLOR_GREEN)] );
+		}
+		else
+		{
+			trap_R_SetColor ( g_color_table[ColorIndex(COLOR_RED)] );
+		}
+	}
+	else if ( cent->currentState.teamowner )
+	{
+		if ( cent->currentState.teamowner != cg.predictedPlayerState.persistant[PERS_TEAM] )
+		{// on enemy team
+			trap_R_SetColor ( g_color_table[ColorIndex(COLOR_RED)] );
+		}
+		else
+		{ //a friend
+			trap_R_SetColor ( g_color_table[ColorIndex(COLOR_GREEN)] );
+		}
+	}
+	else
+	{//FIXME: if we want to ever bracket anything besides vehicles (like siege objectives we want to blow up), we should handle the coloring here
+		trap_R_SetColor ( NULL );
+	}
+	
+	if ( len <= 1.0f )
+	{//super-close, max out at 400 times radius (which is HUGE)
+		size = radius*400.0f;
+	}
+	else
+	{//scale by dist
+		size = radius*(400.0f/len);
+	}
+
+	if ( size < 1.0f )
+	{
+		size = 1.0f;
+	}
+	
+	//length scales with dist
+	lineLength = (size*0.1f);
+	if ( lineLength < 0.5f )
+	{//always visible
+		lineLength = 0.5f;
+	}
+	//always visible width
+	lineWidth = 1.0f;
+
+	x -= (size*0.5f);
+	y -= (size*0.5f);
+
+	/*
+	if ( x >= 0 && x <= 640
+		&& y >= 0 && y <= 480 )
+	*/
+	{//brackets would be drawn on the screen, so draw them
+	//upper left corner
+		//horz
+        CG_DrawPic( x, y, lineLength, lineWidth, cgs.media.whiteShader );
+		//vert
+        CG_DrawPic( x, y, lineWidth, lineLength, cgs.media.whiteShader );
+	//upper right corner
+		//horz
+        CG_DrawPic( x+size-lineLength, y, lineLength, lineWidth, cgs.media.whiteShader );
+		//vert
+        CG_DrawPic( x+size-lineWidth, y, lineWidth, lineLength, cgs.media.whiteShader );
+	//lower left corner
+		//horz
+        CG_DrawPic( x, y+size-lineWidth, lineLength, lineWidth, cgs.media.whiteShader );
+		//vert
+        CG_DrawPic( x, y+size-lineLength, lineWidth, lineLength, cgs.media.whiteShader );
+	//lower right corner
+		//horz
+        CG_DrawPic( x+size-lineLength, y+size-lineWidth, lineLength, lineWidth, cgs.media.whiteShader );
+		//vert
+        CG_DrawPic( x+size-lineWidth, y+size-lineLength, lineWidth, lineLength, cgs.media.whiteShader );
+	}
+}
+
+qboolean CG_InFighter( void )
+{
+	if ( cg.predictedPlayerState.m_iVehicleNum )
+	{//I'm in a vehicle
+		centity_t *vehCent = &cg_entities[cg.predictedPlayerState.m_iVehicleNum];
+	    if ( vehCent 
+			&& vehCent->m_pVehicle 
+			&& vehCent->m_pVehicle->m_pVehicleInfo
+			&& vehCent->m_pVehicle->m_pVehicleInfo->type == VH_FIGHTER )
+		{//I'm in a fighter
+			return qtrue;
+		}
+	}
+	return qfalse;
+}
+
+qboolean CG_InATST( void )
+{
+	if ( cg.predictedPlayerState.m_iVehicleNum )
+	{//I'm in a vehicle
+		centity_t *vehCent = &cg_entities[cg.predictedPlayerState.m_iVehicleNum];
+	    if ( vehCent 
+			&& vehCent->m_pVehicle 
+			&& vehCent->m_pVehicle->m_pVehicleInfo
+			&& vehCent->m_pVehicle->m_pVehicleInfo->type == VH_WALKER )
+		{//I'm in an atst
+			return qtrue;
+		}
+	}
+	return qfalse;
+}
+
+void CG_DrawBracketedEntities( void )
+{
+	int i;
+	for ( i = 0; i < cg.bracketedEntityCount; i++ ) 
+	{	
+		centity_t *cent = &cg_entities[cg.bracketedEntities[i]];
+		CG_BracketEntity( cent, CG_RadiusForCent( cent ) );
+	}
+}
+
+//--------------------------------------------------------------
+static void CG_DrawHolocronIcons(void)
+//--------------------------------------------------------------
+{
+	int icon_size = 40;
+	int i = 0;
+	int startx = 10;
+	int starty = 10;//SCREEN_HEIGHT - icon_size*3;
+
+	int endx = icon_size;
+	int endy = icon_size;
+
+	if (cg.snap->ps.zoomMode)
+	{ //don't display over zoom mask
+		return;
+	}
+
+	if (cgs.clientinfo[cg.snap->ps.clientNum].team == TEAM_SPECTATOR)
+	{
+		return;
+	}
+
+	while (i < NUM_FORCE_POWERS)
+	{
+		if (cg.snap->ps.holocronBits & (1 << forcePowerSorted[i]))
+		{
+			CG_DrawPic( startx, starty, endx, endy, cgs.media.forcePowerIcons[forcePowerSorted[i]]);
+			starty += (icon_size+2); //+2 for spacing
+			if ((starty+icon_size) >= SCREEN_HEIGHT-80)
+			{
+				starty = 10;//SCREEN_HEIGHT - icon_size*3;
+				startx += (icon_size+2);
+			}
+		}
+
+		i++;
+	}
+}
+
+static qboolean CG_IsDurationPower(int power)
+{
+	if (power == FP_HEAL ||
+		power == FP_SPEED ||
+		power == FP_TELEPATHY ||
+		power == FP_RAGE ||
+		power == FP_PROTECT ||
+		power == FP_ABSORB ||
+		power == FP_SEE)
+	{
+		return qtrue;
+	}
+
+	return qfalse;
+}
+
+//--------------------------------------------------------------
+static void CG_DrawActivePowers(void)
+//--------------------------------------------------------------
+{
+	int icon_size = 40;
+	int i = 0;
+	int startx = icon_size*2+16;
+	int starty = SCREEN_HEIGHT - icon_size*2;
+
+	int endx = icon_size;
+	int endy = icon_size;
+
+	if (cg.snap->ps.zoomMode)
+	{ //don't display over zoom mask
+		return;
+	}
+
+	if (cgs.clientinfo[cg.snap->ps.clientNum].team == TEAM_SPECTATOR)
+	{
+		return;
+	}
+
+	while (i < NUM_FORCE_POWERS)
+	{
+		if ((cg.snap->ps.fd.forcePowersActive & (1 << forcePowerSorted[i])) &&
+			CG_IsDurationPower(forcePowerSorted[i]))
+		{
+			CG_DrawPic( startx, starty, endx, endy, cgs.media.forcePowerIcons[forcePowerSorted[i]]);
+			startx += (icon_size+2); //+2 for spacing
+			if ((startx+icon_size) >= SCREEN_WIDTH-80)
+			{
+				startx = icon_size*2+16;
+				starty += (icon_size+2);
+			}
+		}
+
+		i++;
+	}
+
+	//additionally, draw an icon force force rage recovery
+	if (cg.snap->ps.fd.forceRageRecoveryTime > cg.time)
+	{
+		CG_DrawPic( startx, starty, endx, endy, cgs.media.rageRecShader);
+	}
+}
+
+//--------------------------------------------------------------
+static void CG_DrawRocketLocking( int lockEntNum, int lockTime )
+//--------------------------------------------------------------
+{
+	int		cx, cy;
+	vec3_t	org;
+	static	int oldDif = 0;
+	centity_t *cent = &cg_entities[lockEntNum];
+	vec4_t color={0.0f,0.0f,0.0f,0.0f};
+	float lockTimeInterval = ((cgs.gametype==GT_SIEGE)?2400.0f:1200.0f)/16.0f;
+	//FIXME: if in a vehicle, use the vehicle's lockOnTime...
+	int dif = (cg.time - cg.snap->ps.rocketLockTime)/lockTimeInterval;
+	int i;
+
+	if (!cg.snap->ps.rocketLockTime)
+	{
+		return;
+	}
+
+	if (cgs.clientinfo[cg.snap->ps.clientNum].team == TEAM_SPECTATOR)
+	{
+		return;
+	}
+
+	if ( cg.snap->ps.m_iVehicleNum )
+	{//driving a vehicle
+		centity_t *veh = &cg_entities[cg.snap->ps.m_iVehicleNum];
+		if ( veh->m_pVehicle )
+		{
+			vehWeaponInfo_t *vehWeapon = NULL;
+			if ( cg.predictedVehicleState.weaponstate == WEAPON_CHARGING_ALT )
+			{
+				if ( veh->m_pVehicle->m_pVehicleInfo->weapon[1].ID > VEH_WEAPON_BASE 
+					&& veh->m_pVehicle->m_pVehicleInfo->weapon[1].ID < MAX_VEH_WEAPONS )
+				{
+					vehWeapon = &g_vehWeaponInfo[veh->m_pVehicle->m_pVehicleInfo->weapon[1].ID];
+				}
+			}
+			else
+			{
+				if ( veh->m_pVehicle->m_pVehicleInfo->weapon[0].ID > VEH_WEAPON_BASE 
+					&& veh->m_pVehicle->m_pVehicleInfo->weapon[0].ID < MAX_VEH_WEAPONS )
+				{
+					vehWeapon = &g_vehWeaponInfo[veh->m_pVehicle->m_pVehicleInfo->weapon[0].ID];
+				}
+			}
+			if ( vehWeapon != NULL )
+			{//we are trying to lock on with a valid vehicle weapon, so use *its* locktime, not the hard-coded one
+				if ( !vehWeapon->iLockOnTime )
+				{//instant lock-on
+					dif = 10.0f;
+				}
+				else
+				{//use the custom vehicle lockOnTime
+					lockTimeInterval = (vehWeapon->iLockOnTime/16.0f);
+					dif = (cg.time - cg.snap->ps.rocketLockTime)/lockTimeInterval;
+				}
+			}
+		}
+	}
+	//We can't check to see in pmove if players are on the same team, so we resort
+	//to just not drawing the lock if a teammate is the locked on ent
+	if (cg.snap->ps.rocketLockIndex >= 0 &&
+		cg.snap->ps.rocketLockIndex < ENTITYNUM_NONE)
+	{
+		clientInfo_t *ci = NULL;
+
+		if (cg.snap->ps.rocketLockIndex < MAX_CLIENTS)
+		{
+			ci = &cgs.clientinfo[cg.snap->ps.rocketLockIndex];
+		}
+		else
+		{
+			ci = cg_entities[cg.snap->ps.rocketLockIndex].npcClient;
+		}
+
+		if (ci)
+		{
+			if (ci->team == cgs.clientinfo[cg.snap->ps.clientNum].team)
+			{
+				if (cgs.gametype >= GT_TEAM)
+				{
+					return;
+				}
+			}
+			else if (cgs.gametype >= GT_TEAM)
+			{
+				centity_t *hitEnt = &cg_entities[cg.snap->ps.rocketLockIndex];
+				if (hitEnt->currentState.eType == ET_NPC &&
+					hitEnt->currentState.NPC_class == CLASS_VEHICLE &&
+					hitEnt->currentState.owner < ENTITYNUM_WORLD)
+				{ //this is a vehicle, if it has a pilot and that pilot is on my team, then...
+					if (hitEnt->currentState.owner < MAX_CLIENTS)
+					{
+						ci = &cgs.clientinfo[hitEnt->currentState.owner];
+					}
+					else
+					{
+						ci = cg_entities[hitEnt->currentState.owner].npcClient;
+					}
+					if (ci && ci->team == cgs.clientinfo[cg.snap->ps.clientNum].team)
+					{
+						return;
+					}
+				}
+			}
+		}
+	}
+
+	if (cg.snap->ps.rocketLockTime != -1)
+	{
+		lastvalidlockdif = dif;
+	}
+	else
+	{
+		dif = lastvalidlockdif;
+	}
+
+	if ( !cent )
+	{
+		return;
+	}
+
+	VectorCopy( cent->lerpOrigin, org );
+
+	if ( CG_WorldCoordToScreenCoord( org, &cx, &cy ))
+	{
+		// we care about distance from enemy to eye, so this is good enough
+		float sz = Distance( cent->lerpOrigin, cg.refdef.vieworg ) / 1024.0f; 
+		
+		if ( sz > 1.0f )
+		{
+			sz = 1.0f;
+		}
+		else if ( sz < 0.0f )
+		{
+			sz = 0.0f;
+		}
+
+		sz = (1.0f - sz) * (1.0f - sz) * 32 + 6;
+
+		cy += sz * 0.5f;
+		
+		if ( dif < 0 )
+		{
+			oldDif = 0;
+			return;
+		}
+		else if ( dif > 8 )
+		{
+			dif = 8;
+		}
+
+		// do sounds
+		if ( oldDif != dif )
+		{
+			if ( dif == 8 )
+			{
+				if ( cg.snap->ps.m_iVehicleNum )
+				{
+					trap_S_StartSound( org, 0, CHAN_AUTO, trap_S_RegisterSound( "sound/vehicles/weapons/common/lock.wav" ));
+				}
+				else
+				{
+					trap_S_StartSound( org, 0, CHAN_AUTO, trap_S_RegisterSound( "sound/weapons/rocket/lock.wav" ));
+				}
+			}
+			else
+			{
+				if ( cg.snap->ps.m_iVehicleNum )
+				{
+					trap_S_StartSound( org, 0, CHAN_AUTO, trap_S_RegisterSound( "sound/vehicles/weapons/common/tick.wav" ));
+				}
+				else
+				{
+					trap_S_StartSound( org, 0, CHAN_AUTO, trap_S_RegisterSound( "sound/weapons/rocket/tick.wav" ));
+				}
+			}
+		}
+
+		oldDif = dif;
+
+		for ( i = 0; i < dif; i++ )
+		{
+			color[0] = 1.0f;
+			color[1] = 0.0f;
+			color[2] = 0.0f;
+			color[3] = 0.1f * i + 0.2f;
+
+			trap_R_SetColor( color );
+
+			// our slices are offset by about 45 degrees.
+			CG_DrawRotatePic( cx - sz, cy - sz, sz, sz, i * 45.0f, trap_R_RegisterShaderNoMip( "gfx/2d/wedge" ));
+		}
+
+		// we are locked and loaded baby
+		if ( dif == 8 )
+		{
+			color[0] = color[1] = color[2] = sin( cg.time * 0.05f ) * 0.5f + 0.5f;
+			color[3] = 1.0f; // this art is additive, so the alpha value does nothing
+
+			trap_R_SetColor( color );
+
+			CG_DrawPic( cx - sz, cy - sz * 2, sz * 2, sz * 2, trap_R_RegisterShaderNoMip( "gfx/2d/lock" ));
+		}
+	}
+}
+
+extern void CG_CalcVehMuzzle(Vehicle_t *pVeh, centity_t *ent, int muzzleNum);
+qboolean CG_CalcVehicleMuzzlePoint( int entityNum, vec3_t start, vec3_t d_f, vec3_t d_rt, vec3_t d_up)
+{
+	centity_t *vehCent = &cg_entities[entityNum];
+	if ( vehCent->m_pVehicle && vehCent->m_pVehicle->m_pVehicleInfo->type == VH_WALKER )
+	{//draw from barrels
+		VectorCopy( vehCent->lerpOrigin, start );
+		start[2] += vehCent->m_pVehicle->m_pVehicleInfo->height-DEFAULT_MINS_2-48;
+		AngleVectors( vehCent->lerpAngles, d_f, d_rt, d_up );
+		/*
+		mdxaBone_t		boltMatrix;
+		int				bolt;
+		vec3_t			yawOnlyAngles;
+		
+		VectorSet( yawOnlyAngles, 0, vehCent->lerpAngles[YAW], 0 );
+
+		bolt = trap_G2API_AddBolt( vehCent->ghoul2, 0, "*flash1");
+		trap_G2API_GetBoltMatrix( vehCent->ghoul2, 0, bolt, &boltMatrix, 
+									yawOnlyAngles, vehCent->lerpOrigin, cg.time, 
+									NULL, vehCent->modelScale );
+
+		// work the matrix axis stuff into the original axis and origins used.
+		BG_GiveMeVectorFromMatrix( &boltMatrix, ORIGIN, start );
+		BG_GiveMeVectorFromMatrix( &boltMatrix, POSITIVE_X, d_f );
+		VectorClear( d_rt );//don't really need this, do we?
+		VectorClear( d_up );//don't really need this, do we?
+		*/
+	}
+	else
+	{
+		//check to see if we're a turret gunner on this vehicle
+		if ( cg.predictedPlayerState.generic1 )//as a passenger
+		{//passenger in a vehicle
+			if ( vehCent->m_pVehicle
+				&& vehCent->m_pVehicle->m_pVehicleInfo 
+				&& vehCent->m_pVehicle->m_pVehicleInfo->maxPassengers )
+			{//a vehicle capable of carrying passengers
+				int turretNum;
+				for ( turretNum = 0; turretNum < MAX_VEHICLE_TURRETS; turretNum++ )
+				{
+					if ( vehCent->m_pVehicle->m_pVehicleInfo->turret[turretNum].iAmmoMax )
+					{// valid turret
+						if ( vehCent->m_pVehicle->m_pVehicleInfo->turret[turretNum].passengerNum == cg.predictedPlayerState.generic1 )
+						{//I control this turret
+							//Go through all muzzles, average their positions and directions and use the result for crosshair trace
+							int vehMuzzle, numMuzzles = 0;
+							vec3_t	muzzlesAvgPos={0},muzzlesAvgDir={0};
+							int	i;
+
+							for ( i = 0; i < MAX_VEHICLE_TURRET_MUZZLES; i++ )
+							{
+								vehMuzzle = vehCent->m_pVehicle->m_pVehicleInfo->turret[turretNum].iMuzzle[i];
+								if ( vehMuzzle )
+								{
+									vehMuzzle -= 1;
+									CG_CalcVehMuzzle( vehCent->m_pVehicle, vehCent, vehMuzzle );
+									VectorAdd( muzzlesAvgPos, vehCent->m_pVehicle->m_vMuzzlePos[vehMuzzle], muzzlesAvgPos );
+									VectorAdd( muzzlesAvgDir, vehCent->m_pVehicle->m_vMuzzleDir[vehMuzzle], muzzlesAvgDir );
+									numMuzzles++;
+								}
+								if ( numMuzzles )
+								{
+									VectorScale( muzzlesAvgPos, 1.0f/(float)numMuzzles, start );
+									VectorScale( muzzlesAvgDir, 1.0f/(float)numMuzzles, d_f );
+									VectorClear( d_rt );
+									VectorClear( d_up );
+									return qtrue;
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+		VectorCopy( vehCent->lerpOrigin, start );
+		AngleVectors( vehCent->lerpAngles, d_f, d_rt, d_up );
+	}
+	return qfalse;
+}
+
+//calc the muzzle point from the e-web itself
+void CG_CalcEWebMuzzlePoint(centity_t *cent, vec3_t start, vec3_t d_f, vec3_t d_rt, vec3_t d_up)
+{
+	int bolt = trap_G2API_AddBolt(cent->ghoul2, 0, "*cannonflash");
+
+	assert(bolt != -1);
+
+	if (bolt != -1)
+	{
+		mdxaBone_t boltMatrix;
+
+		trap_G2API_GetBoltMatrix_NoRecNoRot(cent->ghoul2, 0, bolt, &boltMatrix, cent->lerpAngles, cent->lerpOrigin, cg.time, NULL, cent->modelScale);
+		BG_GiveMeVectorFromMatrix(&boltMatrix, ORIGIN, start);
+		BG_GiveMeVectorFromMatrix(&boltMatrix, NEGATIVE_X, d_f);
+
+		//these things start the shot a little inside the bbox to assure not starting in something solid
+		VectorMA(start, -16.0f, d_f, start);
+
+		//I guess
+		VectorClear( d_rt );//don't really need this, do we?
+		VectorClear( d_up );//don't really need this, do we?
+	}
+}
+
+/*
+=================
+CG_`Entity
+=================
+*/
+#define MAX_XHAIR_DIST_ACCURACY	20000.0f
+static void CG_ScanForCrosshairEntity( void ) {
+	trace_t		trace;
+	vec3_t		start, end;
+	int			content;
+	int			ignore;
+	qboolean	bVehCheckTraceFromCamPos = qfalse;
+
+	ignore = cg.predictedPlayerState.clientNum;
+
+	if ( cg_dynamicCrosshair.integer )
+	{
+		vec3_t d_f, d_rt, d_up;
+		/*
+		if ( cg.snap->ps.weapon == WP_NONE || 
+			cg.snap->ps.weapon == WP_SABER || 
+			cg.snap->ps.weapon == WP_STUN_BATON)
+		{
+			VectorCopy( cg.refdef.vieworg, start );
+			AngleVectors( cg.refdef.viewangles, d_f, d_rt, d_up );
+		}
+		else
+		*/
+		//For now we still want to draw the crosshair in relation to the player's world coordinates
+		//even if we have a melee weapon/no weapon.
+		if ( cg.predictedPlayerState.m_iVehicleNum && (cg.predictedPlayerState.eFlags&EF_NODRAW) )
+		{//we're *inside* a vehicle
+			//do the vehicle's crosshair instead
+			centity_t *veh = &cg_entities[cg.predictedPlayerState.m_iVehicleNum];
+			qboolean gunner = qfalse;
+
+			//if (veh->currentState.owner == cg.predictedPlayerState.clientNum)
+			{ //the pilot
+				ignore = cg.predictedPlayerState.m_iVehicleNum;
+				gunner = CG_CalcVehicleMuzzlePoint(cg.predictedPlayerState.m_iVehicleNum, start, d_f, d_rt, d_up);
+			}
+			/*
+			else
+			{ //a passenger
+				ignore = cg.predictedPlayerState.m_iVehicleNum;
+				VectorCopy( veh->lerpOrigin, start );
+				AngleVectors( veh->lerpAngles, d_f, d_rt, d_up );
+				VectorMA(start, 32.0f, d_f, start); //super hack
+			}
+			*/
+			if ( veh->m_pVehicle 
+				&& veh->m_pVehicle->m_pVehicleInfo 
+				&& veh->m_pVehicle->m_pVehicleInfo->type == VH_FIGHTER 
+				&& cg.distanceCull > MAX_XHAIR_DIST_ACCURACY 
+				&& !gunner )
+			{	
+				//NOTE: on huge maps, the crosshair gets inaccurate at close range, 
+				//		so we'll do an extra G2 trace from the cg.refdef.vieworg
+				//		to see if we hit anything closer and auto-aim at it if so
+				bVehCheckTraceFromCamPos = qtrue;
+			}
+		}
+		else if (cg.snap && cg.snap->ps.weapon == WP_EMPLACED_GUN && cg.snap->ps.emplacedIndex &&
+			cg_entities[cg.snap->ps.emplacedIndex].ghoul2 && cg_entities[cg.snap->ps.emplacedIndex].currentState.weapon == WP_NONE)
+		{ //locked into our e-web, calc the muzzle from it
+			CG_CalcEWebMuzzlePoint(&cg_entities[cg.snap->ps.emplacedIndex], start, d_f, d_rt, d_up);
+		}
+		else
+		{
+			if (cg.snap && cg.snap->ps.weapon == WP_EMPLACED_GUN && cg.snap->ps.emplacedIndex)
+			{
+				vec3_t pitchConstraint;
+
+				ignore = cg.snap->ps.emplacedIndex;
+
+				VectorCopy(cg.refdef.viewangles, pitchConstraint);
+
+				if (cg.renderingThirdPerson)
+				{
+					VectorCopy(cg.predictedPlayerState.viewangles, pitchConstraint);
+				}
+				else
+				{
+					VectorCopy(cg.refdef.viewangles, pitchConstraint);
+				}
+
+				if (pitchConstraint[PITCH] > 40)
+				{
+					pitchConstraint[PITCH] = 40;
+				}
+
+				AngleVectors( pitchConstraint, d_f, d_rt, d_up );
+			}
+			else
+			{
+				vec3_t pitchConstraint;
+
+				if (cg.renderingThirdPerson)
+				{
+					VectorCopy(cg.predictedPlayerState.viewangles, pitchConstraint);
+				}
+				else
+				{
+					VectorCopy(cg.refdef.viewangles, pitchConstraint);
+				}
+
+				AngleVectors( pitchConstraint, d_f, d_rt, d_up );
+			}
+			CG_CalcMuzzlePoint(cg.snap->ps.clientNum, start);
+		}
+
+		VectorMA( start, cg.distanceCull, d_f, end );
+	}
+	else
+	{
+		VectorCopy( cg.refdef.vieworg, start );
+		VectorMA( start, 131072, cg.refdef.viewaxis[0], end );
+	}
+
+	if ( cg_dynamicCrosshair.integer && cg_dynamicCrosshairPrecision.integer )
+	{ //then do a trace with ghoul2 models in mind
+		CG_G2Trace( &trace, start, vec3_origin, vec3_origin, end, 
+			ignore, CONTENTS_SOLID|CONTENTS_BODY );
+		if ( bVehCheckTraceFromCamPos )
+		{
+			//NOTE: this MUST stay up to date with the method used in WP_VehCheckTraceFromCamPos
+			centity_t *veh = &cg_entities[cg.predictedPlayerState.m_iVehicleNum];
+			trace_t	extraTrace;
+			vec3_t	viewDir2End, extraEnd;
+			float	minAutoAimDist = Distance( veh->lerpOrigin, cg.refdef.vieworg ) + (veh->m_pVehicle->m_pVehicleInfo->length/2.0f) + 200.0f;
+
+			VectorSubtract( end, cg.refdef.vieworg, viewDir2End );
+			VectorNormalize( viewDir2End );
+			VectorMA( cg.refdef.vieworg, MAX_XHAIR_DIST_ACCURACY, viewDir2End, extraEnd );
+			CG_G2Trace( &extraTrace, cg.refdef.vieworg, vec3_origin, vec3_origin, extraEnd, 
+				ignore, CONTENTS_SOLID|CONTENTS_BODY );
+			if ( !extraTrace.allsolid
+				&& !extraTrace.startsolid )
+			{
+				if ( extraTrace.fraction < 1.0f )
+				{
+					if ( (extraTrace.fraction*MAX_XHAIR_DIST_ACCURACY) > minAutoAimDist )
+					{
+						if ( ((extraTrace.fraction*MAX_XHAIR_DIST_ACCURACY)-Distance( veh->lerpOrigin, cg.refdef.vieworg )) < (trace.fraction*cg.distanceCull) )
+						{//this trace hit *something* that's closer than the thing the main trace hit, so use this result instead
+							memcpy( &trace, &extraTrace, sizeof( trace_t ) );
+						}
+					}
+				}
+			}
+		}
+	}
+	else
+	{
+		CG_Trace( &trace, start, vec3_origin, vec3_origin, end, 
+			ignore, CONTENTS_SOLID|CONTENTS_BODY );
+	}
+
+	if (trace.entityNum < MAX_CLIENTS)
+	{
+		if (CG_IsMindTricked(cg_entities[trace.entityNum].currentState.trickedentindex,
+			cg_entities[trace.entityNum].currentState.trickedentindex2,
+			cg_entities[trace.entityNum].currentState.trickedentindex3,
+			cg_entities[trace.entityNum].currentState.trickedentindex4,
+			cg.snap->ps.clientNum))
+		{
+			if (cg.crosshairClientNum == trace.entityNum)
+			{
+				cg.crosshairClientNum = ENTITYNUM_NONE;
+				cg.crosshairClientTime = 0;
+			}
+
+			CG_DrawCrosshair(trace.endpos, 0);
+
+			return; //this entity is mind-tricking the current client, so don't render it
+		}
+	}
+
+	if (cg.snap->ps.persistant[PERS_TEAM] != TEAM_SPECTATOR)
+	{
+		if (trace.entityNum < /*MAX_CLIENTS*/ENTITYNUM_WORLD)
+		{
+			cg.crosshairClientNum = trace.entityNum;
+			cg.crosshairClientTime = cg.time;
+
+			if (cg.crosshairClientNum < ENTITYNUM_WORLD)
+			{
+				centity_t *veh = &cg_entities[cg.crosshairClientNum];
+
+				if (veh->currentState.eType == ET_NPC &&
+					veh->currentState.NPC_class == CLASS_VEHICLE &&
+					veh->currentState.owner < MAX_CLIENTS)
+				{ //draw the name of the pilot then
+					cg.crosshairClientNum = veh->currentState.owner;
+					cg.crosshairVehNum = veh->currentState.number;
+					cg.crosshairVehTime = cg.time;
+				}
+			}
+
+			CG_DrawCrosshair(trace.endpos, 1);
+		}
+		else
+		{
+			CG_DrawCrosshair(trace.endpos, 0);
+		}
+	}
+
+//	if ( trace.entityNum >= MAX_CLIENTS ) {
+//		return;
+//	}
+
+	// if the player is in fog, don't show it
+	content = trap_CM_PointContents( trace.endpos, 0 );
+	if ( content & CONTENTS_FOG ) {
+		return;
+	}
+
+	// update the fade timer
+	cg.crosshairClientNum = trace.entityNum;
+	cg.crosshairClientTime = cg.time;
+}
+
+void CG_SanitizeString( char *in, char *out )
+{
+	int i = 0;
+	int r = 0;
+
+	while (in[i])
+	{
+		if (i >= 128-1)
+		{ //the ui truncates the name here..
+			break;
+		}
+
+		if (in[i] == '^')
+		{
+			if (in[i+1] >= 48 && //'0'
+				in[i+1] <= 57) //'9'
+			{ //only skip it if there's a number after it for the color
+				i += 2;
+				continue;
+			}
+			else
+			{ //just skip the ^
+				i++;
+				continue;
+			}
+		}
+
+		if (in[i] < 32)
+		{
+			i++;
+			continue;
+		}
+
+		out[r] = in[i];
+		r++;
+		i++;
+	}
+	out[r] = 0;
+}
+
+/*
+=====================
+CG_DrawCrosshairNames
+=====================
+*/
+static void CG_DrawCrosshairNames( void ) {
+	float		*color;
+	vec4_t		tcolor;
+	char		*name;
+	char		sanitized[1024];
+	int			baseColor;
+	qboolean	isVeh = qfalse;
+
+	if ( !cg_drawCrosshair.integer ) {
+		return;
+	}
+
+	// scan the known entities to see if the crosshair is sighted on one
+	CG_ScanForCrosshairEntity();
+
+	if ( !cg_drawCrosshairNames.integer ) {
+		return;
+	}
+	//rww - still do the trace, our dynamic crosshair depends on it
+
+	if (cg.crosshairClientNum < ENTITYNUM_WORLD)
+	{
+		centity_t *veh = &cg_entities[cg.crosshairClientNum];
+
+		if (veh->currentState.eType == ET_NPC &&
+			veh->currentState.NPC_class == CLASS_VEHICLE &&
+			veh->currentState.owner < MAX_CLIENTS)
+		{ //draw the name of the pilot then
+			cg.crosshairClientNum = veh->currentState.owner;
+			cg.crosshairVehNum = veh->currentState.number;
+			cg.crosshairVehTime = cg.time;
+			isVeh = qtrue; //so we know we're drawing the pilot's name
+		}
+	}
+
+	if (cg.crosshairClientNum >= MAX_CLIENTS)
+	{
+		return;
+	}
+
+	if (cg_entities[cg.crosshairClientNum].currentState.powerups & (1 << PW_CLOAKED))
+	{
+		return;
+	}
+
+	// draw the name of the player being looked at
+	color = CG_FadeColor( cg.crosshairClientTime, 1000 );
+	if ( !color ) {
+		trap_R_SetColor( NULL );
+		return;
+	}
+
+	name = cgs.clientinfo[ cg.crosshairClientNum ].name;
+
+	if (cgs.gametype >= GT_TEAM)
+	{
+		//if (cgs.gametype == GT_SIEGE)
+		if (1)
+		{ //instead of team-based we'll make it oriented based on which team we're on
+			if (cgs.clientinfo[cg.crosshairClientNum].team == cg.predictedPlayerState.persistant[PERS_TEAM])
+			{
+				baseColor = CT_GREEN;
+			}
+			else
+			{
+				baseColor = CT_RED;
+			}
+		}
+		else
+		{
+			if (cgs.clientinfo[cg.crosshairClientNum].team == TEAM_RED)
+			{
+				baseColor = CT_RED;
+			}
+			else
+			{
+				baseColor = CT_BLUE;
+			}
+		}
+	}
+	else
+	{
+		//baseColor = CT_WHITE;
+		if (cgs.gametype == GT_POWERDUEL &&
+			cgs.clientinfo[cg.snap->ps.clientNum].team != TEAM_SPECTATOR &&
+			cgs.clientinfo[cg.crosshairClientNum].duelTeam == cgs.clientinfo[cg.predictedPlayerState.clientNum].duelTeam)
+		{ //on the same duel team in powerduel, so he's a friend
+			baseColor = CT_GREEN;
+		}
+		else
+		{
+			baseColor = CT_RED; //just make it red in nonteam modes since everyone is hostile and crosshair will be red on them too
+		}
+	}
+
+	if (cg.snap->ps.duelInProgress)
+	{
+		if (cg.crosshairClientNum != cg.snap->ps.duelIndex)
+		{ //grey out crosshair for everyone but your foe if you're in a duel
+			baseColor = CT_BLACK;
+		}
+	}
+	else if (cg_entities[cg.crosshairClientNum].currentState.bolt1)
+	{ //this fellow is in a duel. We just checked if we were in a duel above, so
+	  //this means we aren't and he is. Which of course means our crosshair greys out over him.
+		baseColor = CT_BLACK;
+	}
+
+	tcolor[0] = colorTable[baseColor][0];
+	tcolor[1] = colorTable[baseColor][1];
+	tcolor[2] = colorTable[baseColor][2];
+	tcolor[3] = color[3]*0.5f;
+
+	CG_SanitizeString(name, sanitized);
+
+	if (isVeh)
+	{
+		char str[MAX_STRING_CHARS];
+		Com_sprintf(str, MAX_STRING_CHARS, "%s (pilot)", sanitized);
+		UI_DrawProportionalString(320, 170, str, UI_CENTER, tcolor);
+	}
+	else
+	{
+		UI_DrawProportionalString(320, 170, sanitized, UI_CENTER, tcolor);
+	}
+
+	trap_R_SetColor( NULL );
+}
+
+
+//==============================================================================
+
+/*
+=================
+CG_DrawSpectator
+=================
+*/
+static void CG_DrawSpectator(void) 
+{	
+	const char* s;
+
+	s = CG_GetStringEdString("MP_INGAME", "SPECTATOR");
+	if ((cgs.gametype == GT_DUEL || cgs.gametype == GT_POWERDUEL) &&
+		cgs.duelist1 != -1 &&
+		cgs.duelist2 != -1)
+	{
+		char text[1024];
+		int size = 64;
+
+		if (cgs.gametype == GT_POWERDUEL && cgs.duelist3 != -1)
+		{
+			Com_sprintf(text, sizeof(text), "%s^7 %s %s^7 %s %s", cgs.clientinfo[cgs.duelist1].name, CG_GetStringEdString("MP_INGAME", "SPECHUD_VERSUS"), cgs.clientinfo[cgs.duelist2].name, CG_GetStringEdString("MP_INGAME", "AND"), cgs.clientinfo[cgs.duelist3].name);
+		}
+		else
+		{
+			Com_sprintf(text, sizeof(text), "%s^7 %s %s", cgs.clientinfo[cgs.duelist1].name, CG_GetStringEdString("MP_INGAME", "SPECHUD_VERSUS"), cgs.clientinfo[cgs.duelist2].name);
+		}
+		CG_Text_Paint ( 320 - CG_Text_Width ( text, 1.0f, 3 ) / 2, 420, 1.0f, colorWhite, text, 0, 0, 0, 3 );
+
+		trap_R_SetColor( colorTable[CT_WHITE] );
+		if ( cgs.clientinfo[cgs.duelist1].modelIcon )
+		{
+			CG_DrawPic( 10, SCREEN_HEIGHT-(size*1.5), size, size, cgs.clientinfo[cgs.duelist1].modelIcon );
+		}
+		if ( cgs.clientinfo[cgs.duelist2].modelIcon )
+		{
+			CG_DrawPic( SCREEN_WIDTH-size-10, SCREEN_HEIGHT-(size*1.5), size, size, cgs.clientinfo[cgs.duelist2].modelIcon );
+		}
+
+// nmckenzie: DUEL_HEALTH
+		if (cgs.gametype == GT_DUEL)
+		{
+			if ( cgs.showDuelHealths >= 1)
+			{	// draw the healths on the two guys - how does this interact with power duel, though?
+				CG_DrawDuelistHealth ( 10, SCREEN_HEIGHT-(size*1.5) - 12, 64, 8, 1 );
+				CG_DrawDuelistHealth ( SCREEN_WIDTH-size-10, SCREEN_HEIGHT-(size*1.5) - 12, 64, 8, 2 );
+			}
+		}
+
+		if (cgs.gametype != GT_POWERDUEL)
+		{
+			Com_sprintf(text, sizeof(text), "%i/%i", cgs.clientinfo[cgs.duelist1].score, cgs.fraglimit );
+			CG_Text_Paint( 42 - CG_Text_Width( text, 1.0f, 2 ) / 2, SCREEN_HEIGHT-(size*1.5) + 64, 1.0f, colorWhite, text, 0, 0, 0, 2 );
+
+			Com_sprintf(text, sizeof(text), "%i/%i", cgs.clientinfo[cgs.duelist2].score, cgs.fraglimit );
+			CG_Text_Paint( SCREEN_WIDTH-size+22 - CG_Text_Width( text, 1.0f, 2 ) / 2, SCREEN_HEIGHT-(size*1.5) + 64, 1.0f, colorWhite, text, 0, 0, 0, 2 );
+		}
+
+		if (cgs.gametype == GT_POWERDUEL && cgs.duelist3 != -1)
+		{
+			if ( cgs.clientinfo[cgs.duelist3].modelIcon )
+			{
+				CG_DrawPic( SCREEN_WIDTH-size-10, SCREEN_HEIGHT-(size*2.8), size, size, cgs.clientinfo[cgs.duelist3].modelIcon );
+			}
+		}
+	}
+	else
+	{
+		CG_Text_Paint ( 320 - CG_Text_Width ( s, 1.0f, 3 ) / 2, 420, 1.0f, colorWhite, s, 0, 0, 0, 3 );
+	}
+
+	if ( cgs.gametype == GT_DUEL || cgs.gametype == GT_POWERDUEL ) 
+	{
+		s = CG_GetStringEdString("MP_INGAME", "WAITING_TO_PLAY");	// "waiting to play";
+		CG_Text_Paint ( 320 - CG_Text_Width ( s, 1.0f, 3 ) / 2, 440, 1.0f, colorWhite, s, 0, 0, 0, 3 );
+	}
+	else //if ( cgs.gametype >= GT_TEAM ) 
+	{
+		//s = "press ESC and use the JOIN menu to play";
+		s = CG_GetStringEdString("MP_INGAME", "SPEC_CHOOSEJOIN");
+		CG_Text_Paint ( 320 - CG_Text_Width ( s, 1.0f, 3 ) / 2, 440, 1.0f, colorWhite, s, 0, 0, 0, 3 );
+	}
+}
+
+/*
+=================
+CG_DrawVote
+=================
+*/
+static void CG_DrawVote(void) {
+	const char	*s;
+	int		sec;
+	char							sYes[20];
+	char							sNo[20];
+	char							sVote[20];
+	char							sCmd[100];
+	const char*						sParm = 0;
+
+	if ( !cgs.voteTime ) {
+		return;
+	}
+
+	// play a talk beep whenever it is modified
+	if ( cgs.voteModified ) {
+		cgs.voteModified = qfalse;
+//		trap_S_StartLocalSound( cgs.media.talkSound, CHAN_LOCAL_SOUND );
+	}
+
+	sec = ( VOTE_TIME - ( cg.time - cgs.voteTime ) ) / 1000;
+	if ( sec < 0 ) {
+		sec = 0;
+	}
+
+	if (strncmp(cgs.voteString, "map_restart", 11)==0)
+	{
+		trap_SP_GetStringTextString("MENUS_RESTART_MAP", sCmd, sizeof(sCmd) );
+	}
+	else if (strncmp(cgs.voteString, "vstr nextmap", 12)==0)
+	{
+		trap_SP_GetStringTextString("MENUS_NEXT_MAP", sCmd, sizeof(sCmd) );
+	}
+	else if (strncmp(cgs.voteString, "g_doWarmup", 10)==0)
+	{
+		trap_SP_GetStringTextString("MENUS_WARMUP", sCmd, sizeof(sCmd) );
+	}
+	else if (strncmp(cgs.voteString, "g_gametype", 10)==0)
+	{
+		trap_SP_GetStringTextString("MENUS_GAME_TYPE", sCmd, sizeof(sCmd) );
+		if      ( stricmp("Free For All", cgs.voteString+11)==0 ) 
+		{
+			sParm = CG_GetStringEdString("MENUS", "FREE_FOR_ALL");
+		}
+		else if ( stricmp("Duel", cgs.voteString+11)==0 ) 
+		{
+			sParm = CG_GetStringEdString("MENUS", "DUEL");
+		}
+		else if ( stricmp("Holocron FFA", cgs.voteString+11)==0  ) 
+		{
+			sParm = CG_GetStringEdString("MENUS", "HOLOCRON_FFA");
+		}
+		else if ( stricmp("Power Duel", cgs.voteString+11)==0  ) 
+		{
+			sParm = CG_GetStringEdString("MENUS", "POWERDUEL");
+		}
+		else if ( stricmp("Team FFA", cgs.voteString+11)==0  ) 
+		{
+			sParm = CG_GetStringEdString("MENUS", "TEAM_FFA");
+		}
+		else if ( stricmp("Siege", cgs.voteString+11)==0  ) 
+		{
+			sParm = CG_GetStringEdString("MENUS", "SIEGE");
+		}
+		else if ( stricmp("Capture the Flag", cgs.voteString+11)==0  ) 
+		{
+			sParm = CG_GetStringEdString("MENUS", "CAPTURE_THE_FLAG");
+		}
+		else if ( stricmp("Capture the Ysalamiri", cgs.voteString+11)==0  ) 
+		{
+			sParm = CG_GetStringEdString("MENUS", "CAPTURE_THE_YSALIMARI");
+		} 
+	}
+	else if (strncmp(cgs.voteString, "map", 3)==0)
+	{
+		trap_SP_GetStringTextString("MENUS_NEW_MAP", sCmd, sizeof(sCmd) );
+		sParm = cgs.voteString+4;
+	}
+	else if (strncmp(cgs.voteString, "kick", 4)==0)
+	{
+		trap_SP_GetStringTextString("MENUS_KICK_PLAYER", sCmd, sizeof(sCmd) );
+		sParm = cgs.voteString+5;
+	}
+
+
+
+	trap_SP_GetStringTextString("MENUS_VOTE", sVote, sizeof(sVote) );
+	trap_SP_GetStringTextString("MENUS_YES", sYes, sizeof(sYes) );
+	trap_SP_GetStringTextString("MENUS_NO",  sNo,  sizeof(sNo) );
+
+	if (sParm && sParm[0])
+	{
+		s = va("%s(%i):<%s %s> %s:%i %s:%i", sVote, sec, sCmd, sParm, sYes, cgs.voteYes, sNo, cgs.voteNo);
+	}
+	else
+	{
+		s = va("%s(%i):<%s> %s:%i %s:%i",    sVote, sec, sCmd,        sYes, cgs.voteYes, sNo, cgs.voteNo);
+	}
+	CG_DrawSmallString( 4, 58, s, 1.0F );
+	s = CG_GetStringEdString("MP_INGAME", "OR_PRESS_ESC_THEN_CLICK_VOTE");	//	s = "or press ESC then click Vote";
+	CG_DrawSmallString( 4, 58 + SMALLCHAR_HEIGHT + 2, s, 1.0F );
+}
+
+/*
+=================
+CG_DrawTeamVote
+=================
+*/
+static void CG_DrawTeamVote(void) {
+	char	*s;
+	int		sec, cs_offset;
+
+	if ( cgs.clientinfo->team == TEAM_RED )
+		cs_offset = 0;
+	else if ( cgs.clientinfo->team == TEAM_BLUE )
+		cs_offset = 1;
+	else
+		return;
+
+	if ( !cgs.teamVoteTime[cs_offset] ) {
+		return;
+	}
+
+	// play a talk beep whenever it is modified
+	if ( cgs.teamVoteModified[cs_offset] ) {
+		cgs.teamVoteModified[cs_offset] = qfalse;
+//		trap_S_StartLocalSound( cgs.media.talkSound, CHAN_LOCAL_SOUND );
+	}
+
+	sec = ( VOTE_TIME - ( cg.time - cgs.teamVoteTime[cs_offset] ) ) / 1000;
+	if ( sec < 0 ) {
+		sec = 0;
+	}
+	if (strstr(cgs.teamVoteString[cs_offset], "leader"))
+	{
+		int i = 0;
+
+		while (cgs.teamVoteString[cs_offset][i] && cgs.teamVoteString[cs_offset][i] != ' ')
+		{
+			i++;
+		}
+
+		if (cgs.teamVoteString[cs_offset][i] == ' ')
+		{
+			int voteIndex = 0;
+			char voteIndexStr[256];
+
+			i++;
+
+			while (cgs.teamVoteString[cs_offset][i])
+			{
+				voteIndexStr[voteIndex] = cgs.teamVoteString[cs_offset][i];
+				voteIndex++;
+				i++;
+			}
+			voteIndexStr[voteIndex] = 0;
+
+			voteIndex = atoi(voteIndexStr);
+
+			s = va("TEAMVOTE(%i):(Make %s the new team leader) yes:%i no:%i", sec, cgs.clientinfo[voteIndex].name,
+									cgs.teamVoteYes[cs_offset], cgs.teamVoteNo[cs_offset] );
+		}
+		else
+		{
+			s = va("TEAMVOTE(%i):%s yes:%i no:%i", sec, cgs.teamVoteString[cs_offset],
+									cgs.teamVoteYes[cs_offset], cgs.teamVoteNo[cs_offset] );
+		}
+	}
+	else
+	{
+		s = va("TEAMVOTE(%i):%s yes:%i no:%i", sec, cgs.teamVoteString[cs_offset],
+								cgs.teamVoteYes[cs_offset], cgs.teamVoteNo[cs_offset] );
+	}
+	CG_DrawSmallString( 4, 90, s, 1.0F );
+}
+
+static qboolean CG_DrawScoreboard() {
+	return CG_DrawOldScoreboard();
+#if 0
+	static qboolean firstTime = qtrue;
+	float fade, *fadeColor;
+
+	if (menuScoreboard) {
+		menuScoreboard->window.flags &= ~WINDOW_FORCED;
+	}
+	if (cg_paused.integer) {
+		cg.deferredPlayerLoading = 0;
+		firstTime = qtrue;
+		return qfalse;
+	}
+
+	// should never happen in Team Arena
+	if (cgs.gametype == GT_SINGLE_PLAYER && cg.predictedPlayerState.pm_type == PM_INTERMISSION ) {
+		cg.deferredPlayerLoading = 0;
+		firstTime = qtrue;
+		return qfalse;
+	}
+
+	// don't draw scoreboard during death while warmup up
+	if ( cg.warmup && !cg.showScores ) {
+		return qfalse;
+	}
+
+	if ( cg.showScores || cg.predictedPlayerState.pm_type == PM_DEAD || cg.predictedPlayerState.pm_type == PM_INTERMISSION ) {
+		fade = 1.0;
+		fadeColor = colorWhite;
+	} else {
+		fadeColor = CG_FadeColor( cg.scoreFadeTime, FADE_TIME );
+		if ( !fadeColor ) {
+			// next time scoreboard comes up, don't print killer
+			cg.deferredPlayerLoading = 0;
+			cg.killerName[0] = 0;
+			firstTime = qtrue;
+			return qfalse;
+		}
+		fade = *fadeColor;
+	}																					  
+
+
+	if (menuScoreboard == NULL) {
+		if ( cgs.gametype >= GT_TEAM ) {
+			menuScoreboard = Menus_FindByName("teamscore_menu");
+		} else {
+			menuScoreboard = Menus_FindByName("score_menu");
+		}
+	}
+
+	if (menuScoreboard) {
+		if (firstTime) {
+			CG_SetScoreSelection(menuScoreboard);
+			firstTime = qfalse;
+		}
+		Menu_Paint(menuScoreboard, qtrue);
+	}
+
+	// load any models that have been deferred
+	if ( ++cg.deferredPlayerLoading > 10 ) {
+		CG_LoadDeferredPlayers();
+	}
+
+	return qtrue;
+#endif
+}
+
+/*
+=================
+CG_DrawIntermission
+=================
+*/
+static void CG_DrawIntermission( void ) {
+//	int key;
+	//if (cg_singlePlayer.integer) {
+	//	CG_DrawCenterString();
+	//	return;
+	//}
+	cg.scoreFadeTime = cg.time;
+	cg.scoreBoardShowing = CG_DrawScoreboard();
+}
+
+/*
+=================
+CG_DrawFollow
+=================
+*/
+static qboolean CG_DrawFollow( void ) 
+{
+	const char	*s;
+
+	if ( !(cg.snap->ps.pm_flags & PMF_FOLLOW) ) 
+	{
+		return qfalse;
+	}
+
+//	s = "following";
+	if (cgs.gametype == GT_POWERDUEL)
+	{
+		clientInfo_t *ci = &cgs.clientinfo[ cg.snap->ps.clientNum ];
+
+		if (ci->duelTeam == DUELTEAM_LONE)
+		{
+			s = CG_GetStringEdString("MP_INGAME", "FOLLOWINGLONE");
+		}
+		else if (ci->duelTeam == DUELTEAM_DOUBLE)
+		{
+			s = CG_GetStringEdString("MP_INGAME", "FOLLOWINGDOUBLE");
+		}
+		else
+		{
+			s = CG_GetStringEdString("MP_INGAME", "FOLLOWING");
+		}
+	}
+	else
+	{
+		s = CG_GetStringEdString("MP_INGAME", "FOLLOWING");
+	}
+
+	CG_Text_Paint ( 320 - CG_Text_Width ( s, 1.0f, FONT_MEDIUM ) / 2, 60, 1.0f, colorWhite, s, 0, 0, 0, FONT_MEDIUM );
+
+	s = cgs.clientinfo[ cg.snap->ps.clientNum ].name;
+	CG_Text_Paint ( 320 - CG_Text_Width ( s, 2.0f, FONT_MEDIUM ) / 2, 80, 2.0f, colorWhite, s, 0, 0, 0, FONT_MEDIUM );
+
+	return qtrue;
+}
+
+#if 0
+static void CG_DrawTemporaryStats()
+{ //placeholder for testing (draws ammo and force power)
+	char s[512];
+
+	if (!cg.snap)
+	{
+		return;
+	}
+
+	sprintf(s, "Force: %i", cg.snap->ps.fd.forcePower);
+
+	CG_DrawBigString(SCREEN_WIDTH-164, SCREEN_HEIGHT-dmgIndicSize, s, 1.0f);
+
+	sprintf(s, "Ammo: %i", cg.snap->ps.ammo[weaponData[cg.snap->ps.weapon].ammoIndex]);
+
+	CG_DrawBigString(SCREEN_WIDTH-164, SCREEN_HEIGHT-112, s, 1.0f);
+
+	sprintf(s, "Health: %i", cg.snap->ps.stats[STAT_HEALTH]);
+
+	CG_DrawBigString(8, SCREEN_HEIGHT-dmgIndicSize, s, 1.0f);
+
+	sprintf(s, "Armor: %i", cg.snap->ps.stats[STAT_ARMOR]);
+
+	CG_DrawBigString(8, SCREEN_HEIGHT-112, s, 1.0f);
+}
+#endif
+
+/*
+=================
+CG_DrawAmmoWarning
+=================
+*/
+static void CG_DrawAmmoWarning( void ) {
+#if 0
+	const char	*s;
+	int			w;
+
+	if (!cg_drawStatus.integer)
+	{
+		return;
+	}
+
+	if ( cg_drawAmmoWarning.integer == 0 ) {
+		return;
+	}
+
+	if ( !cg.lowAmmoWarning ) {
+		return;
+	}
+
+	if ( cg.lowAmmoWarning == 2 ) {
+		s = "OUT OF AMMO";
+	} else {
+		s = "LOW AMMO WARNING";
+	}
+	w = CG_DrawStrlen( s ) * BIGCHAR_WIDTH;
+	CG_DrawBigString(320 - w / 2, 64, s, 1.0F);
+#endif
+}
+
+
+
+/*
+=================
+CG_DrawWarmup
+=================
+*/
+static void CG_DrawWarmup( void ) {
+	int			w;
+	int			sec;
+	int			i;
+	float scale;
+	int			cw;
+	const char	*s;
+
+	sec = cg.warmup;
+	if ( !sec ) {
+		return;
+	}
+
+	if ( sec < 0 ) {
+//		s = "Waiting for players";		
+		s = CG_GetStringEdString("MP_INGAME", "WAITING_FOR_PLAYERS");
+		w = CG_DrawStrlen( s ) * BIGCHAR_WIDTH;
+		CG_DrawBigString(320 - w / 2, 24, s, 1.0F);
+		cg.warmupCount = 0;
+		return;
+	}
+
+	if (cgs.gametype == GT_DUEL || cgs.gametype == GT_POWERDUEL)
+	{
+		// find the two active players
+		clientInfo_t	*ci1, *ci2, *ci3;
+
+		ci1 = NULL;
+		ci2 = NULL;
+		ci3 = NULL;
+
+		if (cgs.gametype == GT_POWERDUEL)
+		{
+			if (cgs.duelist1 != -1)
+			{
+				ci1 = &cgs.clientinfo[cgs.duelist1];
+			}
+			if (cgs.duelist2 != -1)
+			{
+				ci2 = &cgs.clientinfo[cgs.duelist2];
+			}
+			if (cgs.duelist3 != -1)
+			{
+				ci3 = &cgs.clientinfo[cgs.duelist3];
+			}
+		}
+		else
+		{
+			for ( i = 0 ; i < cgs.maxclients ; i++ ) {
+				if ( cgs.clientinfo[i].infoValid && cgs.clientinfo[i].team == TEAM_FREE ) {
+					if ( !ci1 ) {
+						ci1 = &cgs.clientinfo[i];
+					} else {
+						ci2 = &cgs.clientinfo[i];
+					}
+				}
+			}
+		}
+		if ( ci1 && ci2 )
+		{
+			if (ci3)
+			{
+				s = va( "%s vs %s and %s", ci1->name, ci2->name, ci3->name );
+			}
+			else
+			{
+				s = va( "%s vs %s", ci1->name, ci2->name );
+			}
+			w = CG_Text_Width(s, 0.6f, FONT_MEDIUM);
+			CG_Text_Paint(320 - w / 2, 60, 0.6f, colorWhite, s, 0, 0, ITEM_TEXTSTYLE_SHADOWEDMORE,FONT_MEDIUM);
+		}
+	} else {
+		if ( cgs.gametype == GT_FFA ) {
+			s = CG_GetStringEdString("MENUS", "FREE_FOR_ALL");//"Free For All";
+		} else if ( cgs.gametype == GT_HOLOCRON ) {
+			s = CG_GetStringEdString("MENUS", "HOLOCRON_FFA");//"Holocron FFA";
+		} else if ( cgs.gametype == GT_JEDIMASTER ) {
+			s = CG_GetStringEdString("MENUS", "POWERDUEL");//"Jedi Master";??
+		} else if ( cgs.gametype == GT_TEAM ) {
+			s = CG_GetStringEdString("MENUS", "TEAM_FFA");//"Team FFA";
+		} else if ( cgs.gametype == GT_SIEGE ) {
+			s = CG_GetStringEdString("MENUS", "SIEGE");//"Siege";
+		} else if ( cgs.gametype == GT_CTF ) {
+			s = CG_GetStringEdString("MENUS", "CAPTURE_THE_FLAG");//"Capture the Flag";
+		} else if ( cgs.gametype == GT_CTY ) {
+			s = CG_GetStringEdString("MENUS", "CAPTURE_THE_YSALIMARI");//"Capture the Ysalamiri";
+		} else {
+			s = "";
+		}
+		w = CG_Text_Width(s, 1.5f, FONT_MEDIUM);
+		CG_Text_Paint(320 - w / 2, 90, 1.5f, colorWhite, s, 0, 0, ITEM_TEXTSTYLE_SHADOWEDMORE,FONT_MEDIUM);
+	}
+
+	sec = ( sec - cg.time ) / 1000;
+	if ( sec < 0 ) {
+		cg.warmup = 0;
+		sec = 0;
+	}
+//	s = va( "Starts in: %i", sec + 1 );
+	s = va( "%s: %i",CG_GetStringEdString("MP_INGAME", "STARTS_IN"), sec + 1 );
+	if ( sec != cg.warmupCount ) {
+		cg.warmupCount = sec;
+
+		if (cgs.gametype != GT_SIEGE)
+		{
+			switch ( sec ) {
+			case 0:
+				trap_S_StartLocalSound( cgs.media.count1Sound, CHAN_ANNOUNCER );
+				break;
+			case 1:
+				trap_S_StartLocalSound( cgs.media.count2Sound, CHAN_ANNOUNCER );
+				break;
+			case 2:
+				trap_S_StartLocalSound( cgs.media.count3Sound, CHAN_ANNOUNCER );
+				break;
+			default:
+				break;
+			}
+		}
+	}
+	scale = 0.45f;
+	switch ( cg.warmupCount ) {
+	case 0:
+		cw = 28;
+		scale = 1.25f;
+		break;
+	case 1:
+		cw = 24;
+		scale = 1.15f;
+		break;
+	case 2:
+		cw = 20;
+		scale = 1.05f;
+		break;
+	default:
+		cw = 16;
+		scale = 0.9f;
+		break;
+	}
+
+	w = CG_Text_Width(s, scale, FONT_MEDIUM);
+	CG_Text_Paint(320 - w / 2, 125, scale, colorWhite, s, 0, 0, ITEM_TEXTSTYLE_SHADOWEDMORE, FONT_MEDIUM);
+}
+
+//==================================================================================
+/* 
+=================
+CG_DrawTimedMenus
+=================
+*/
+void CG_DrawTimedMenus() {
+	if (cg.voiceTime) {
+		int t = cg.time - cg.voiceTime;
+		if ( t > 2500 ) {
+			Menus_CloseByName("voiceMenu");
+			trap_Cvar_Set("cl_conXOffset", "0");
+			cg.voiceTime = 0;
+		}
+	}
+}
+
+void CG_DrawFlagStatus()
+{
+	int myFlagTakenShader = 0;
+	int theirFlagShader = 0;
+	int team = 0;
+	int startDrawPos = 2;
+	int ico_size = 32;
+
+	if (!cg.snap)
+	{
+		return;
+	}
+
+	if (cgs.gametype != GT_CTF && cgs.gametype != GT_CTY)
+	{
+		return;
+	}
+
+	team = cg.snap->ps.persistant[PERS_TEAM];
+
+	if (cgs.gametype == GT_CTY)
+	{
+		if (team == TEAM_RED)
+		{
+			myFlagTakenShader = trap_R_RegisterShaderNoMip( "gfx/hud/mpi_rflag_x" );
+			theirFlagShader = trap_R_RegisterShaderNoMip( "gfx/hud/mpi_bflag_ys" );
+		}
+		else
+		{
+			myFlagTakenShader = trap_R_RegisterShaderNoMip( "gfx/hud/mpi_bflag_x" );
+			theirFlagShader = trap_R_RegisterShaderNoMip( "gfx/hud/mpi_rflag_ys" );
+		}
+	}
+	else
+	{
+		if (team == TEAM_RED)
+		{
+			myFlagTakenShader = trap_R_RegisterShaderNoMip( "gfx/hud/mpi_rflag_x" );
+			theirFlagShader = trap_R_RegisterShaderNoMip( "gfx/hud/mpi_bflag" );
+		}
+		else
+		{
+			myFlagTakenShader = trap_R_RegisterShaderNoMip( "gfx/hud/mpi_bflag_x" );
+			theirFlagShader = trap_R_RegisterShaderNoMip( "gfx/hud/mpi_rflag" );
+		}
+	}
+
+	if (CG_YourTeamHasFlag())
+	{
+		//CG_DrawPic( startDrawPos, 330, ico_size, ico_size, theirFlagShader );
+		CG_DrawPic( 2, 330-startDrawPos, ico_size, ico_size, theirFlagShader );
+		startDrawPos += ico_size+2;
+	}
+
+	if (CG_OtherTeamHasFlag())
+	{
+		//CG_DrawPic( startDrawPos, 330, ico_size, ico_size, myFlagTakenShader );
+		CG_DrawPic( 2, 330-startDrawPos, ico_size, ico_size, myFlagTakenShader );
+	}
+}
+
+//draw meter showing jetpack fuel when it's not full
+#define JPFUELBAR_H			100.0f
+#define JPFUELBAR_W			20.0f
+#define JPFUELBAR_X			(SCREEN_WIDTH-JPFUELBAR_W-8.0f)
+#define JPFUELBAR_Y			260.0f
+void CG_DrawJetpackFuel(void)
+{
+	vec4_t aColor;
+	vec4_t bColor;
+	vec4_t cColor;
+	float x = JPFUELBAR_X;
+	float y = JPFUELBAR_Y;
+	float percent = ((float)cg.snap->ps.jetpackFuel/100.0f)*JPFUELBAR_H;
+
+	if (percent > JPFUELBAR_H)
+	{
+		return;
+	}
+
+	if (percent < 0.1f)
+	{
+		percent = 0.1f;
+	}
+
+	//color of the bar
+	aColor[0] = 0.5f;
+	aColor[1] = 0.0f;
+	aColor[2] = 0.0f;
+	aColor[3] = 0.8f;
+
+	//color of the border
+	bColor[0] = 0.0f;
+	bColor[1] = 0.0f;
+	bColor[2] = 0.0f;
+	bColor[3] = 0.3f;
+
+	//color of greyed out "missing fuel"
+	cColor[0] = 0.5f;
+	cColor[1] = 0.5f;
+	cColor[2] = 0.5f;
+	cColor[3] = 0.1f;
+
+	//draw the background (black)
+	CG_DrawRect(x, y, JPFUELBAR_W, JPFUELBAR_H, 1.0f, colorTable[CT_BLACK]);
+
+	//now draw the part to show how much health there is in the color specified
+	CG_FillRect(x+1.0f, y+1.0f+(JPFUELBAR_H-percent), JPFUELBAR_W-1.0f, JPFUELBAR_H-1.0f-(JPFUELBAR_H-percent), aColor);
+
+	//then draw the other part greyed out
+	CG_FillRect(x+1.0f, y+1.0f, JPFUELBAR_W-1.0f, JPFUELBAR_H-percent, cColor);
+}
+
+//draw meter showing e-web health when it is in use
+#define EWEBHEALTH_H			100.0f
+#define EWEBHEALTH_W			20.0f
+#define EWEBHEALTH_X			(SCREEN_WIDTH-EWEBHEALTH_W-8.0f)
+#define EWEBHEALTH_Y			290.0f
+void CG_DrawEWebHealth(void)
+{
+	vec4_t aColor;
+	vec4_t bColor;
+	vec4_t cColor;
+	float x = EWEBHEALTH_X;
+	float y = EWEBHEALTH_Y;
+	centity_t *eweb = &cg_entities[cg.predictedPlayerState.emplacedIndex];
+	float percent = ((float)eweb->currentState.health/eweb->currentState.maxhealth)*EWEBHEALTH_H;
+
+	if (percent > EWEBHEALTH_H)
+	{
+		return;
+	}
+
+	if (percent < 0.1f)
+	{
+		percent = 0.1f;
+	}
+
+	//kind of hacky, need to pass a coordinate in here
+	if (cg.snap->ps.jetpackFuel < 100)
+	{
+		x -= (JPFUELBAR_W+8.0f);
+	}
+	if (cg.snap->ps.cloakFuel < 100)
+	{
+		x -= (JPFUELBAR_W+8.0f);
+	}
+
+	//color of the bar
+	aColor[0] = 0.5f;
+	aColor[1] = 0.0f;
+	aColor[2] = 0.0f;
+	aColor[3] = 0.8f;
+
+	//color of the border
+	bColor[0] = 0.0f;
+	bColor[1] = 0.0f;
+	bColor[2] = 0.0f;
+	bColor[3] = 0.3f;
+
+	//color of greyed out "missing fuel"
+	cColor[0] = 0.5f;
+	cColor[1] = 0.5f;
+	cColor[2] = 0.5f;
+	cColor[3] = 0.1f;
+
+	//draw the background (black)
+	CG_DrawRect(x, y, EWEBHEALTH_W, EWEBHEALTH_H, 1.0f, colorTable[CT_BLACK]);
+
+	//now draw the part to show how much health there is in the color specified
+	CG_FillRect(x+1.0f, y+1.0f+(EWEBHEALTH_H-percent), EWEBHEALTH_W-1.0f, EWEBHEALTH_H-1.0f-(EWEBHEALTH_H-percent), aColor);
+
+	//then draw the other part greyed out
+	CG_FillRect(x+1.0f, y+1.0f, EWEBHEALTH_W-1.0f, EWEBHEALTH_H-percent, cColor);
+}
+
+//draw meter showing cloak fuel when it's not full
+#define CLFUELBAR_H			100.0f
+#define CLFUELBAR_W			20.0f
+#define CLFUELBAR_X			(SCREEN_WIDTH-CLFUELBAR_W-8.0f)
+#define CLFUELBAR_Y			260.0f
+void CG_DrawCloakFuel(void)
+{
+	vec4_t aColor;
+	vec4_t bColor;
+	vec4_t cColor;
+	float x = CLFUELBAR_X;
+	float y = CLFUELBAR_Y;
+	float percent = ((float)cg.snap->ps.cloakFuel/100.0f)*CLFUELBAR_H;
+
+	if (percent > CLFUELBAR_H)
+	{
+		return;
+	}
+
+	if ( cg.snap->ps.jetpackFuel < 100 )
+	{//if drawing jetpack fuel bar too, then move this over...?
+		x -= (JPFUELBAR_W+8.0f);
+	}
+
+	if (percent < 0.1f)
+	{
+		percent = 0.1f;
+	}
+
+	//color of the bar
+	aColor[0] = 0.0f;
+	aColor[1] = 0.0f;
+	aColor[2] = 0.6f;
+	aColor[3] = 0.8f;
+
+	//color of the border
+	bColor[0] = 0.0f;
+	bColor[1] = 0.0f;
+	bColor[2] = 0.0f;
+	bColor[3] = 0.3f;
+
+	//color of greyed out "missing fuel"
+	cColor[0] = 0.1f;
+	cColor[1] = 0.1f;
+	cColor[2] = 0.3f;
+	cColor[3] = 0.1f;
+
+	//draw the background (black)
+	CG_DrawRect(x, y, CLFUELBAR_W, CLFUELBAR_H, 1.0f, colorTable[CT_BLACK]);
+
+	//now draw the part to show how much fuel there is in the color specified
+	CG_FillRect(x+1.0f, y+1.0f+(CLFUELBAR_H-percent), CLFUELBAR_W-1.0f, CLFUELBAR_H-1.0f-(CLFUELBAR_H-percent), aColor);
+
+	//then draw the other part greyed out
+	CG_FillRect(x+1.0f, y+1.0f, CLFUELBAR_W-1.0f, CLFUELBAR_H-percent, cColor);
+}
+
+int cgRageTime = 0;
+int cgRageFadeTime = 0;
+float cgRageFadeVal = 0;
+
+int cgRageRecTime = 0;
+int cgRageRecFadeTime = 0;
+float cgRageRecFadeVal = 0;
+
+int cgAbsorbTime = 0;
+int cgAbsorbFadeTime = 0;
+float cgAbsorbFadeVal = 0;
+
+int cgProtectTime = 0;
+int cgProtectFadeTime = 0;
+float cgProtectFadeVal = 0;
+
+int cgYsalTime = 0;
+int cgYsalFadeTime = 0;
+float cgYsalFadeVal = 0;
+
+qboolean gCGHasFallVector = qfalse;
+vec3_t gCGFallVector;
+
+/*
+=================
+CG_Draw2D
+=================
+*/
+extern int cgSiegeRoundState;
+extern int cgSiegeRoundTime;
+
+extern int team1Timed;
+extern int team2Timed;
+
+int cg_beatingSiegeTime = 0;
+
+int cgSiegeRoundBeganTime = 0;
+int cgSiegeRoundCountTime = 0;
+
+static void CG_DrawSiegeTimer(int timeRemaining, qboolean isMyTeam)
+{ //rwwFIXMEFIXME: Make someone make assets and use them.
+  //this function is pretty much totally placeholder.
+//	int x = 0;
+//	int y = SCREEN_HEIGHT-160;
+	int fColor = 0;
+	int minutes = 0;
+	int seconds = 0;
+	char timeStr[1024];
+	menuDef_t	*menuHUD = NULL;
+	itemDef_t	*item = NULL;
+
+	menuHUD = Menus_FindByName("mp_timer");
+	if (!menuHUD)
+	{
+		return;
+	}
+
+	item = Menu_FindItemByName(menuHUD, "frame");
+
+	if (item)
+	{
+		trap_R_SetColor( item->window.foreColor );
+		CG_DrawPic( 
+			item->window.rect.x, 
+			item->window.rect.y, 
+			item->window.rect.w, 
+			item->window.rect.h, 
+			item->window.background );
+	}
+
+	seconds = timeRemaining;
+
+	while (seconds >= 60)
+	{
+		minutes++;
+		seconds -= 60;
+	}
+
+	strcpy(timeStr, va( "%i:%02i", minutes, seconds ));
+
+	if (isMyTeam)
+	{
+		fColor = CT_HUD_RED;
+	}
+	else
+	{
+		fColor = CT_HUD_GREEN;
+	}
+
+//	trap_Cvar_Set("ui_siegeTimer", timeStr);
+
+//	UI_DrawProportionalString( x+16, y+40, timeStr,
+//		UI_SMALLFONT|UI_DROPSHADOW, colorTable[fColor] );
+
+	item = Menu_FindItemByName(menuHUD, "timer");
+	if (item)
+	{
+		UI_DrawProportionalString( 
+			item->window.rect.x, 
+			item->window.rect.y, 
+			timeStr,
+			UI_SMALLFONT|UI_DROPSHADOW, 
+			colorTable[fColor] );
+	}
+
+}
+
+static void CG_DrawSiegeDeathTimer( int timeRemaining )
+{
+	int minutes = 0;
+	int seconds = 0;
+	char timeStr[1024];
+	menuDef_t	*menuHUD = NULL;
+	itemDef_t	*item = NULL;
+
+	menuHUD = Menus_FindByName("mp_timer");
+	if (!menuHUD)
+	{
+		return;
+	}
+
+	item = Menu_FindItemByName(menuHUD, "frame");
+
+	if (item)
+	{
+		trap_R_SetColor( item->window.foreColor );
+		CG_DrawPic( 
+			item->window.rect.x, 
+			item->window.rect.y, 
+			item->window.rect.w, 
+			item->window.rect.h, 
+			item->window.background );
+	}
+
+	seconds = timeRemaining;
+
+	while (seconds >= 60)
+	{
+		minutes++;
+		seconds -= 60;
+	}
+
+	if (seconds < 10)
+	{
+		strcpy(timeStr, va( "%i:0%i", minutes, seconds ));
+	}
+	else
+	{
+		strcpy(timeStr, va( "%i:%i", minutes, seconds ));
+	}
+
+	item = Menu_FindItemByName(menuHUD, "deathtimer");
+	if (item)
+	{
+		UI_DrawProportionalString( 
+			item->window.rect.x, 
+			item->window.rect.y, 
+			timeStr,
+			UI_SMALLFONT|UI_DROPSHADOW, 
+			item->window.foreColor );
+	}
+	
+}
+
+int cgSiegeEntityRender = 0;
+
+static void CG_DrawSiegeHUDItem(void)
+{
+	void *g2;
+	qhandle_t handle;
+	vec3_t origin, angles;
+	vec3_t mins, maxs;
+	float len;
+	centity_t *cent = &cg_entities[cgSiegeEntityRender];
+
+	if (cent->ghoul2)
+	{
+		g2 = cent->ghoul2;
+		handle = 0;
+	}
+	else
+	{
+		handle = cgs.gameModels[cent->currentState.modelindex];
+		g2 = NULL;
+	}
+
+	if (handle)
+	{
+		trap_R_ModelBounds( handle, mins, maxs );
+	}
+	else
+	{
+		VectorSet(mins, -16, -16, -20);
+		VectorSet(maxs, 16, 16, 32);
+	}
+
+	origin[2] = -0.5 * ( mins[2] + maxs[2] );
+	origin[1] = 0.5 * ( mins[1] + maxs[1] );
+	len = 0.5 * ( maxs[2] - mins[2] );		
+	origin[0] = len / 0.268;
+
+	VectorClear(angles);
+	angles[YAW] = cg.autoAngles[YAW];
+
+	CG_Draw3DModel( 8, 8, 64, 64, handle, g2, cent->currentState.g2radius, 0, origin, angles );
+
+	cgSiegeEntityRender = 0; //reset for next frame
+}
+
+/*====================================
+chatbox functionality -rww
+====================================*/
+#define	CHATBOX_CUTOFF_LEN	550
+#define	CHATBOX_FONT_HEIGHT	20
+
+//utility func, insert a string into a string at the specified
+//place (assuming this will not overflow the buffer)
+void CG_ChatBox_StrInsert(char *buffer, int place, char *str)
+{
+	int insLen = strlen(str);
+	int i = strlen(buffer);
+	int k = 0;
+
+	buffer[i+insLen+1] = 0; //terminate the string at its new length
+	while (i >= place)
+	{
+		buffer[i+insLen] = buffer[i];
+		i--;
+	}
+
+	i++;
+	while (k < insLen)
+	{
+		buffer[i] = str[k];
+		i++;
+		k++;
+	}
+}
+
+//add chatbox string
+void CG_ChatBox_AddString(char *chatStr)
+{
+	chatBoxItem_t *chat = &cg.chatItems[cg.chatItemActive];
+	float chatLen;
+
+	if (cg_chatBox.integer<=0)
+	{ //don't bother then.
+		return;
+	}
+
+	memset(chat, 0, sizeof(chatBoxItem_t));
+
+	if (strlen(chatStr) > sizeof(chat->string))
+	{ //too long, terminate at proper len.
+		chatStr[sizeof(chat->string)-1] = 0;
+	}
+
+	strcpy(chat->string, chatStr);
+	chat->time = cg.time + cg_chatBox.integer;
+
+	chat->lines = 1;
+
+	chatLen = CG_Text_Width(chat->string, 1.0f, FONT_SMALL);
+	if (chatLen > CHATBOX_CUTOFF_LEN)
+	{ //we have to break it into segments...
+        int i = 0;
+		int lastLinePt = 0;
+		char s[2];
+
+		chatLen = 0;
+		while (chat->string[i])
+		{
+			s[0] = chat->string[i];
+			s[1] = 0;
+			chatLen += CG_Text_Width(s, 0.65f, FONT_SMALL);
+
+			if (chatLen >= CHATBOX_CUTOFF_LEN)
+			{
+				int j = i;
+				while (j > 0 && j > lastLinePt)
+				{
+					if (chat->string[j] == ' ')
+					{
+						break;
+					}
+					j--;
+				}
+				if (chat->string[j] == ' ')
+				{
+					i = j;
+				}
+
+                chat->lines++;
+				CG_ChatBox_StrInsert(chat->string, i, "\n");
+				i++;
+				chatLen = 0;
+				lastLinePt = i+1;
+			}
+			i++;
+		}
+	}
+
+	cg.chatItemActive++;
+	if (cg.chatItemActive >= MAX_CHATBOX_ITEMS)
+	{
+		cg.chatItemActive = 0;
+	}
+}
+
+//insert item into array (rearranging the array if necessary)
+void CG_ChatBox_ArrayInsert(chatBoxItem_t **array, int insPoint, int maxNum, chatBoxItem_t *item)
+{
+    if (array[insPoint])
+	{ //recursively call, to move everything up to the top
+		if (insPoint+1 >= maxNum)
+		{
+			CG_Error("CG_ChatBox_ArrayInsert: Exceeded array size");
+		}
+		CG_ChatBox_ArrayInsert(array, insPoint+1, maxNum, array[insPoint]);
+	}
+
+	//now that we have moved anything that would be in this slot up, insert what we want into the slot
+	array[insPoint] = item;
+}
+
+//go through all the chat strings and draw them if they are not yet expired
+static CGAME_INLINE void CG_ChatBox_DrawStrings(void)
+{
+	chatBoxItem_t *drawThese[MAX_CHATBOX_ITEMS];
+	int numToDraw = 0;
+	int linesToDraw = 0;
+	int i = 0;
+	int x = 30;
+	int y = cg.scoreBoardShowing ? 475 : cg_chatBoxHeight.integer;
+	float fontScale = 0.65f;
+
+	if (!cg_chatBox.integer)
+	{
+		return;
+	}
+
+	memset(drawThese, 0, sizeof(drawThese));
+
+	while (i < MAX_CHATBOX_ITEMS)
+	{
+		if (cg.chatItems[i].time >= cg.time)
+		{
+			int check = numToDraw;
+			int insertionPoint = numToDraw;
+
+			while (check >= 0)
+			{
+				if (drawThese[check] &&
+					cg.chatItems[i].time < drawThese[check]->time)
+				{ //insert here
+					insertionPoint = check;
+				}
+				check--;
+			}
+			CG_ChatBox_ArrayInsert(drawThese, insertionPoint, MAX_CHATBOX_ITEMS, &cg.chatItems[i]);
+			numToDraw++;
+			linesToDraw += cg.chatItems[i].lines;
+		}
+		i++;
+	}
+
+	if (!numToDraw)
+	{ //nothing, then, just get out of here now.
+		return;
+	}
+
+	//move initial point up so we draw bottom-up (visually)
+	y -= (CHATBOX_FONT_HEIGHT*fontScale)*linesToDraw;
+
+	//we have the items we want to draw, just quickly loop through them now
+	i = 0;
+	while (i < numToDraw)
+	{
+		CG_Text_Paint(x, y, fontScale, colorWhite, drawThese[i]->string, 0, 0, ITEM_TEXTSTYLE_OUTLINED, FONT_SMALL );
+		y += ((CHATBOX_FONT_HEIGHT*fontScale)*drawThese[i]->lines);
+		i++;
+	}
+}
+
+static void CG_Draw2DScreenTints( void )
+{
+	float			rageTime, rageRecTime, absorbTime, protectTime, ysalTime;
+	vec4_t			hcolor;
+	if (cgs.clientinfo[cg.snap->ps.clientNum].team != TEAM_SPECTATOR)
+	{
+		if (cg.snap->ps.fd.forcePowersActive & (1 << FP_RAGE))
+		{
+			if (!cgRageTime)
+			{
+				cgRageTime = cg.time;
+			}
+			
+			rageTime = (float)(cg.time - cgRageTime);
+			
+			rageTime /= 9000;
+			
+			if (rageTime < 0)
+			{
+				rageTime = 0;
+			}
+			if (rageTime > 0.15)
+			{
+				rageTime = 0.15;
+			}
+			
+			hcolor[3] = rageTime;
+			hcolor[0] = 0.7;
+			hcolor[1] = 0;
+			hcolor[2] = 0;
+			
+			if (!cg.renderingThirdPerson)
+			{
+				CG_DrawRect(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH*SCREEN_HEIGHT, hcolor);
+			}
+			
+			cgRageFadeTime = 0;
+			cgRageFadeVal = 0;
+		}
+		else if (cgRageTime)
+		{
+			if (!cgRageFadeTime)
+			{
+				cgRageFadeTime = cg.time;
+				cgRageFadeVal = 0.15;
+			}
+			
+			rageTime = cgRageFadeVal;
+			
+			cgRageFadeVal -= (cg.time - cgRageFadeTime)*0.000005;
+			
+			if (rageTime < 0)
+			{
+				rageTime = 0;
+			}
+			if (rageTime > 0.15)
+			{
+				rageTime = 0.15;
+			}
+			
+			if (cg.snap->ps.fd.forceRageRecoveryTime > cg.time)
+			{
+				float checkRageRecTime = rageTime;
+				
+				if (checkRageRecTime < 0.15)
+				{
+					checkRageRecTime = 0.15;
+				}
+				
+				hcolor[3] = checkRageRecTime;
+				hcolor[0] = rageTime*4;
+				if (hcolor[0] < 0.2)
+				{
+					hcolor[0] = 0.2;
+				}
+				hcolor[1] = 0.2;
+				hcolor[2] = 0.2;
+			}
+			else
+			{
+				hcolor[3] = rageTime;
+				hcolor[0] = 0.7;
+				hcolor[1] = 0;
+				hcolor[2] = 0;
+			}
+			
+			if (!cg.renderingThirdPerson && rageTime)
+			{
+				CG_DrawRect(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH*SCREEN_HEIGHT, hcolor);
+			}
+			else
+			{
+				if (cg.snap->ps.fd.forceRageRecoveryTime > cg.time)
+				{
+					hcolor[3] = 0.15;
+					hcolor[0] = 0.2;
+					hcolor[1] = 0.2;
+					hcolor[2] = 0.2;
+					CG_DrawRect(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH*SCREEN_HEIGHT, hcolor);
+				}
+				cgRageTime = 0;
+			}
+		}
+		else if (cg.snap->ps.fd.forceRageRecoveryTime > cg.time)
+		{
+			if (!cgRageRecTime)
+			{
+				cgRageRecTime = cg.time;
+			}
+			
+			rageRecTime = (float)(cg.time - cgRageRecTime);
+			
+			rageRecTime /= 9000;
+			
+			if (rageRecTime < 0.15)//0)
+			{
+				rageRecTime = 0.15;//0;
+			}
+			if (rageRecTime > 0.15)
+			{
+				rageRecTime = 0.15;
+			}
+			
+			hcolor[3] = rageRecTime;
+			hcolor[0] = 0.2;
+			hcolor[1] = 0.2;
+			hcolor[2] = 0.2;
+			
+			if (!cg.renderingThirdPerson)
+			{
+				CG_DrawRect(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH*SCREEN_HEIGHT, hcolor);
+			}
+			
+			cgRageRecFadeTime = 0;
+			cgRageRecFadeVal = 0;
+		}
+		else if (cgRageRecTime)
+		{
+			if (!cgRageRecFadeTime)
+			{
+				cgRageRecFadeTime = cg.time;
+				cgRageRecFadeVal = 0.15;
+			}
+			
+			rageRecTime = cgRageRecFadeVal;
+			
+			cgRageRecFadeVal -= (cg.time - cgRageRecFadeTime)*0.000005;
+			
+			if (rageRecTime < 0)
+			{
+				rageRecTime = 0;
+			}
+			if (rageRecTime > 0.15)
+			{
+				rageRecTime = 0.15;
+			}
+			
+			hcolor[3] = rageRecTime;
+			hcolor[0] = 0.2;
+			hcolor[1] = 0.2;
+			hcolor[2] = 0.2;
+			
+			if (!cg.renderingThirdPerson && rageRecTime)
+			{
+				CG_DrawRect(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH*SCREEN_HEIGHT, hcolor);
+			}
+			else
+			{
+				cgRageRecTime = 0;
+			}
+		}
+		
+		if (cg.snap->ps.fd.forcePowersActive & (1 << FP_ABSORB))
+		{
+			if (!cgAbsorbTime)
+			{
+				cgAbsorbTime = cg.time;
+			}
+			
+			absorbTime = (float)(cg.time - cgAbsorbTime);
+			
+			absorbTime /= 9000;
+			
+			if (absorbTime < 0)
+			{
+				absorbTime = 0;
+			}
+			if (absorbTime > 0.15)
+			{
+				absorbTime = 0.15;
+			}
+			
+			hcolor[3] = absorbTime/2;
+			hcolor[0] = 0;
+			hcolor[1] = 0;
+			hcolor[2] = 0.7;
+			
+			if (!cg.renderingThirdPerson)
+			{
+				CG_DrawRect(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH*SCREEN_HEIGHT, hcolor);
+			}
+			
+			cgAbsorbFadeTime = 0;
+			cgAbsorbFadeVal = 0;
+		}
+		else if (cgAbsorbTime)
+		{
+			if (!cgAbsorbFadeTime)
+			{
+				cgAbsorbFadeTime = cg.time;
+				cgAbsorbFadeVal = 0.15;
+			}
+			
+			absorbTime = cgAbsorbFadeVal;
+			
+			cgAbsorbFadeVal -= (cg.time - cgAbsorbFadeTime)*0.000005;
+			
+			if (absorbTime < 0)
+			{
+				absorbTime = 0;
+			}
+			if (absorbTime > 0.15)
+			{
+				absorbTime = 0.15;
+			}
+			
+			hcolor[3] = absorbTime/2;
+			hcolor[0] = 0;
+			hcolor[1] = 0;
+			hcolor[2] = 0.7;
+			
+			if (!cg.renderingThirdPerson && absorbTime)
+			{
+				CG_DrawRect(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH*SCREEN_HEIGHT, hcolor);
+			}
+			else
+			{
+				cgAbsorbTime = 0;
+			}
+		}
+		
+		if (cg.snap->ps.fd.forcePowersActive & (1 << FP_PROTECT))
+		{
+			if (!cgProtectTime)
+			{
+				cgProtectTime = cg.time;
+			}
+			
+			protectTime = (float)(cg.time - cgProtectTime);
+			
+			protectTime /= 9000;
+			
+			if (protectTime < 0)
+			{
+				protectTime = 0;
+			}
+			if (protectTime > 0.15)
+			{
+				protectTime = 0.15;
+			}
+			
+			hcolor[3] = protectTime/2;
+			hcolor[0] = 0;
+			hcolor[1] = 0.7;
+			hcolor[2] = 0;
+			
+			if (!cg.renderingThirdPerson)
+			{
+				CG_DrawRect(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH*SCREEN_HEIGHT, hcolor);
+			}
+			
+			cgProtectFadeTime = 0;
+			cgProtectFadeVal = 0;
+		}
+		else if (cgProtectTime)
+		{
+			if (!cgProtectFadeTime)
+			{
+				cgProtectFadeTime = cg.time;
+				cgProtectFadeVal = 0.15;
+			}
+			
+			protectTime = cgProtectFadeVal;
+			
+			cgProtectFadeVal -= (cg.time - cgProtectFadeTime)*0.000005;
+			
+			if (protectTime < 0)
+			{
+				protectTime = 0;
+			}
+			if (protectTime > 0.15)
+			{
+				protectTime = 0.15;
+			}
+			
+			hcolor[3] = protectTime/2;
+			hcolor[0] = 0;
+			hcolor[1] = 0.7;
+			hcolor[2] = 0;
+			
+			if (!cg.renderingThirdPerson && protectTime)
+			{
+				CG_DrawRect(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH*SCREEN_HEIGHT, hcolor);
+			}
+			else
+			{
+				cgProtectTime = 0;
+			}
+		}
+		
+		if (cg.snap->ps.rocketLockIndex != ENTITYNUM_NONE && (cg.time - cg.snap->ps.rocketLockTime) > 0)
+		{
+			CG_DrawRocketLocking( cg.snap->ps.rocketLockIndex, cg.snap->ps.rocketLockTime );
+		}
+		
+		if (BG_HasYsalamiri(cgs.gametype, &cg.snap->ps))
+		{
+			if (!cgYsalTime)
+			{
+				cgYsalTime = cg.time;
+			}
+			
+			ysalTime = (float)(cg.time - cgYsalTime);
+			
+			ysalTime /= 9000;
+			
+			if (ysalTime < 0)
+			{
+				ysalTime = 0;
+			}
+			if (ysalTime > 0.15)
+			{
+				ysalTime = 0.15;
+			}
+			
+			hcolor[3] = ysalTime/2;
+			hcolor[0] = 0.7;
+			hcolor[1] = 0.7;
+			hcolor[2] = 0;
+			
+			if (!cg.renderingThirdPerson)
+			{
+				CG_DrawRect(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH*SCREEN_HEIGHT, hcolor);
+			}
+			
+			cgYsalFadeTime = 0;
+			cgYsalFadeVal = 0;
+		}
+		else if (cgYsalTime)
+		{
+			if (!cgYsalFadeTime)
+			{
+				cgYsalFadeTime = cg.time;
+				cgYsalFadeVal = 0.15;
+			}
+			
+			ysalTime = cgYsalFadeVal;
+			
+			cgYsalFadeVal -= (cg.time - cgYsalFadeTime)*0.000005;
+			
+			if (ysalTime < 0)
+			{
+				ysalTime = 0;
+			}
+			if (ysalTime > 0.15)
+			{
+				ysalTime = 0.15;
+			}
+			
+			hcolor[3] = ysalTime/2;
+			hcolor[0] = 0.7;
+			hcolor[1] = 0.7;
+			hcolor[2] = 0;
+			
+			if (!cg.renderingThirdPerson && ysalTime)
+			{
+				CG_DrawRect(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH*SCREEN_HEIGHT, hcolor);
+			}
+			else
+			{
+				cgYsalTime = 0;
+			}
+		}
+	}
+
+	if ( (cg.refdef.viewContents&CONTENTS_LAVA) )
+	{//tint screen red
+		float phase = cg.time / 1000.0 * WAVE_FREQUENCY * M_PI * 2;
+		hcolor[3] = 0.5 + (0.15f*sin( phase ));
+		hcolor[0] = 0.7f;
+		hcolor[1] = 0;
+		hcolor[2] = 0;
+		
+		CG_DrawRect( 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH*SCREEN_HEIGHT, hcolor  );
+	}
+	else if ( (cg.refdef.viewContents&CONTENTS_SLIME) )
+	{//tint screen green
+		float phase = cg.time / 1000.0 * WAVE_FREQUENCY * M_PI * 2;
+		hcolor[3] = 0.4 + (0.1f*sin( phase ));
+		hcolor[0] = 0;
+		hcolor[1] = 0.7f;
+		hcolor[2] = 0;
+		
+		CG_DrawRect( 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH*SCREEN_HEIGHT, hcolor  );
+	}
+	else if ( (cg.refdef.viewContents&CONTENTS_WATER) )
+	{//tint screen light blue -- FIXME: don't do this if CONTENTS_FOG? (in case someone *does* make a water shader with fog in it?)
+		float phase = cg.time / 1000.0 * WAVE_FREQUENCY * M_PI * 2;
+		hcolor[3] = 0.3 + (0.05f*sin( phase ));
+		hcolor[0] = 0;
+		hcolor[1] = 0.2f;
+		hcolor[2] = 0.8;
+		
+		CG_DrawRect( 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH*SCREEN_HEIGHT, hcolor  );
+	}
+}
+
+static void CG_Draw2D( void ) {
+	float			inTime = cg.invenSelectTime+WEAPON_SELECT_TIME;
+	float			wpTime = cg.weaponSelectTime+WEAPON_SELECT_TIME;
+	float			fallTime; 
+	float			bestTime;
+	int				drawSelect = 0;
+
+	// if we are taking a levelshot for the menu, don't draw anything
+	if ( cg.levelShot ) {
+		return;
+	}
+
+	if (cgs.clientinfo[cg.snap->ps.clientNum].team == TEAM_SPECTATOR)
+	{
+		cgRageTime = 0;
+		cgRageFadeTime = 0;
+		cgRageFadeVal = 0;
+
+		cgRageRecTime = 0;
+		cgRageRecFadeTime = 0;
+		cgRageRecFadeVal = 0;
+
+		cgAbsorbTime = 0;
+		cgAbsorbFadeTime = 0;
+		cgAbsorbFadeVal = 0;
+
+		cgProtectTime = 0;
+		cgProtectFadeTime = 0;
+		cgProtectFadeVal = 0;
+
+		cgYsalTime = 0;
+		cgYsalFadeTime = 0;
+		cgYsalFadeVal = 0;
+	}
+
+	if ( cg_draw2D.integer == 0 ) {
+		return;
+	}
+
+	if ( cg.snap->ps.pm_type == PM_INTERMISSION ) {
+		CG_DrawIntermission();
+		CG_ChatBox_DrawStrings();
+		return;
+	}
+
+	CG_Draw2DScreenTints();
+
+	if (cg.snap->ps.rocketLockIndex != ENTITYNUM_NONE && (cg.time - cg.snap->ps.rocketLockTime) > 0)
+	{
+		CG_DrawRocketLocking( cg.snap->ps.rocketLockIndex, cg.snap->ps.rocketLockTime );
+	}
+
+	if (cg.snap->ps.holocronBits)
+	{
+		CG_DrawHolocronIcons();
+	}
+	if (cg.snap->ps.fd.forcePowersActive || cg.snap->ps.fd.forceRageRecoveryTime > cg.time)
+	{
+		CG_DrawActivePowers();
+	}
+
+	if (cg.snap->ps.jetpackFuel < 100)
+	{ //draw it as long as it isn't full
+        CG_DrawJetpackFuel();        
+	}
+	if (cg.snap->ps.cloakFuel < 100)
+	{ //draw it as long as it isn't full
+		CG_DrawCloakFuel();
+	}
+	if (cg.predictedPlayerState.emplacedIndex > 0)
+	{
+		centity_t *eweb = &cg_entities[cg.predictedPlayerState.emplacedIndex];
+
+		if (eweb->currentState.weapon == WP_NONE)
+		{ //using an e-web, draw its health
+			CG_DrawEWebHealth();
+		}
+	}
+
+	// Draw this before the text so that any text won't get clipped off
+	CG_DrawZoomMask();
+
+/*
+	if (cg.cameraMode) {
+		return;
+	}
+*/
+	if ( cg.snap->ps.persistant[PERS_TEAM] == TEAM_SPECTATOR ) {
+		CG_DrawSpectator();
+		CG_DrawCrosshair(NULL, 0);
+		CG_DrawCrosshairNames();
+		CG_SaberClashFlare();
+	} else {
+		// don't draw any status if dead or the scoreboard is being explicitly shown
+		if ( !cg.showScores && cg.snap->ps.stats[STAT_HEALTH] > 0 ) {
+
+			if ( /*cg_drawStatus.integer*/0 ) {
+				//Reenable if stats are drawn with menu system again
+				Menu_PaintAll();
+				CG_DrawTimedMenus();
+			}
+      
+			//CG_DrawTemporaryStats();
+
+			CG_DrawAmmoWarning();
+
+			CG_DrawCrosshairNames();
+
+			if (cg_drawStatus.integer)
+			{
+				CG_DrawIconBackground();
+			}
+
+			if (inTime > wpTime)
+			{
+				drawSelect = 1;
+				bestTime = cg.invenSelectTime;
+			}
+			else //only draw the most recent since they're drawn in the same place
+			{
+				drawSelect = 2;
+				bestTime = cg.weaponSelectTime;
+			}
+
+			if (cg.forceSelectTime > bestTime)
+			{
+				drawSelect = 3;
+			}
+
+			switch(drawSelect)
+			{
+			case 1:
+				CG_DrawInvenSelect();
+				break;
+			case 2:
+				CG_DrawWeaponSelect();
+				break;
+			case 3:
+				CG_DrawForceSelect();
+				break;
+			default:
+				break;
+			}
+
+			if (cg_drawStatus.integer)
+			{
+				//Powerups now done with upperright stuff
+				//CG_DrawPowerupIcons();
+
+				CG_DrawFlagStatus();
+			}
+
+			CG_SaberClashFlare();
+
+			if (cg_drawStatus.integer)
+			{
+				CG_DrawStats();
+			}
+
+			CG_DrawPickupItem();
+			//Do we want to use this system again at some point?
+			//CG_DrawReward();
+		}
+    
+	}
+
+	if (cg.snap->ps.fallingToDeath)
+	{
+		vec4_t	hcolor;
+
+		fallTime = (float)(cg.time - cg.snap->ps.fallingToDeath);
+
+		fallTime /= (FALL_FADE_TIME/2);
+
+		if (fallTime < 0)
+		{
+			fallTime = 0;
+		}
+		if (fallTime > 1)
+		{
+			fallTime = 1;
+		}
+
+		hcolor[3] = fallTime;
+		hcolor[0] = 0;
+		hcolor[1] = 0;
+		hcolor[2] = 0;
+
+		CG_DrawRect(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH*SCREEN_HEIGHT, hcolor);
+
+		if (!gCGHasFallVector)
+		{
+			VectorCopy(cg.snap->ps.origin, gCGFallVector);
+			gCGHasFallVector = qtrue;
+		}
+	}
+	else
+	{
+		if (gCGHasFallVector)
+		{
+			gCGHasFallVector = qfalse;
+			VectorClear(gCGFallVector);
+		}
+	}
+
+	CG_DrawVote();
+	CG_DrawTeamVote();
+
+	CG_DrawLagometer();
+	
+
+	if (!cg_paused.integer) {
+		CG_DrawBracketedEntities();
+		CG_DrawUpperRight();
+	}
+
+	if ( !CG_DrawFollow() ) {
+		CG_DrawWarmup();
+	}
+
+	if (cgSiegeRoundState)
+	{
+		char pStr[1024];
+		int rTime = 0;
+
+		//cgSiegeRoundBeganTime = 0;
+
+		switch (cgSiegeRoundState)
+		{
+		case 1:
+			CG_CenterPrint(CG_GetStringEdString("MP_INGAME", "WAITING_FOR_PLAYERS"), SCREEN_HEIGHT * 0.30, BIGCHAR_WIDTH);
+			break;
+		case 2:
+			rTime = (SIEGE_ROUND_BEGIN_TIME - (cg.time - cgSiegeRoundTime));
+		
+			if (rTime < 0)
+			{
+				rTime = 0;
+			}
+			if (rTime > SIEGE_ROUND_BEGIN_TIME)
+			{
+				rTime = SIEGE_ROUND_BEGIN_TIME;
+			}
+
+			rTime /= 1000;
+
+			rTime += 1;
+
+			if (rTime < 1)
+			{
+				rTime = 1;
+			}
+
+			if (rTime <= 3 && rTime != cgSiegeRoundCountTime)
+			{
+				cgSiegeRoundCountTime = rTime;
+
+				switch (rTime)
+				{
+				case 1:
+					trap_S_StartLocalSound( cgs.media.count1Sound, CHAN_ANNOUNCER );
+					break;
+				case 2:
+					trap_S_StartLocalSound( cgs.media.count2Sound, CHAN_ANNOUNCER );
+					break;
+				case 3:
+					trap_S_StartLocalSound( cgs.media.count3Sound, CHAN_ANNOUNCER );
+					break;
+				default:
+					break;
+				}
+			}
+
+			strcpy(pStr, va("%s %i...", CG_GetStringEdString("MP_INGAME", "ROUNDBEGINSIN"), rTime));
+			CG_CenterPrint(pStr, SCREEN_HEIGHT * 0.30, BIGCHAR_WIDTH);
+			//same
+			break;
+		default:
+			break;
+		}
+
+		cgSiegeEntityRender = 0;
+	}
+	else if (cgSiegeRoundTime)
+	{
+		CG_CenterPrint("", SCREEN_HEIGHT * 0.30, BIGCHAR_WIDTH);
+		cgSiegeRoundTime = 0;
+
+		//cgSiegeRoundBeganTime = cg.time;
+		cgSiegeEntityRender = 0;
+	}
+	else if (cgSiegeRoundBeganTime)
+	{ //Draw how much time is left in the round based on local info.
+		int timedTeam = TEAM_FREE;
+		int timedValue = 0;
+
+		if (cgSiegeEntityRender)
+		{ //render the objective item model since this client has it
+			CG_DrawSiegeHUDItem();
+		}
+
+		if (team1Timed)
+		{
+			timedTeam = TEAM_RED; //team 1
+			if (cg_beatingSiegeTime)
+			{
+				timedValue = cg_beatingSiegeTime;
+			}
+			else
+			{
+				timedValue = team1Timed;
+			}
+		}
+		else if (team2Timed)
+		{
+			timedTeam = TEAM_BLUE; //team 2
+			if (cg_beatingSiegeTime)
+			{
+				timedValue = cg_beatingSiegeTime;
+			}
+			else
+			{
+				timedValue = team2Timed;
+			}
+		}
+
+		if (timedTeam != TEAM_FREE)
+		{ //one of the teams has a timer
+			int timeRemaining;
+			qboolean isMyTeam = qfalse;
+
+			if (cgs.siegeTeamSwitch && !cg_beatingSiegeTime)
+			{ //in switchy mode but not beating a time, so count up.
+				timeRemaining = (cg.time-cgSiegeRoundBeganTime);
+				if (timeRemaining < 0)
+				{
+					timeRemaining = 0;
+				}
+			}
+			else
+			{
+				timeRemaining = (((cgSiegeRoundBeganTime)+timedValue) - cg.time);
+			}
+
+			if (timeRemaining > timedValue)
+			{
+				timeRemaining = timedValue;
+			}
+			else if (timeRemaining < 0)
+			{
+				timeRemaining = 0;
+			}
+
+			if (timeRemaining)
+			{
+				timeRemaining /= 1000;
+			}
+
+			if (cg.predictedPlayerState.persistant[PERS_TEAM] == timedTeam)
+			{ //the team that's timed is the one this client is on
+				isMyTeam = qtrue;
+			}
+
+			CG_DrawSiegeTimer(timeRemaining, isMyTeam);
+		}
+	}
+	else
+	{
+		cgSiegeEntityRender = 0;
+	}
+
+	if ( cg_siegeDeathTime )
+	{
+		int timeRemaining = ( cg_siegeDeathTime - cg.time );
+
+		if ( timeRemaining < 0 )
+		{
+			timeRemaining = 0;
+			cg_siegeDeathTime = 0;
+		}
+
+		if ( timeRemaining )
+		{
+			timeRemaining /= 1000;
+		}
+
+		CG_DrawSiegeDeathTimer( timeRemaining );
+	}
+
+	// don't draw center string if scoreboard is up
+	cg.scoreBoardShowing = CG_DrawScoreboard();
+	if ( !cg.scoreBoardShowing) {
+		CG_DrawCenterString();
+	}
+	
+	// always draw chat
+	CG_ChatBox_DrawStrings();
+}
+
+
+static void CG_DrawTourneyScoreboard() {
+}
+
+/*
+=====================
+CG_DrawActive
+
+Perform all drawing needed to completely fill the screen
+=====================
+*/
+void CG_DrawActive( stereoFrame_t stereoView ) {
+	float		separation;
+	vec3_t		baseOrg;
+
+	// optionally draw the info screen instead
+	if ( !cg.snap ) {
+		CG_DrawInformation();
+		return;
+	}
+
+	// optionally draw the tournement scoreboard instead
+	if ( cg.snap->ps.persistant[PERS_TEAM] == TEAM_SPECTATOR &&
+		( cg.snap->ps.pm_flags & PMF_SCOREBOARD ) ) {
+		CG_DrawTourneyScoreboard();
+		return;
+	}
+
+	switch ( stereoView ) {
+	case STEREO_CENTER:
+		separation = 0;
+		break;
+	case STEREO_LEFT:
+		separation = -cg_stereoSeparation.value / 2;
+		break;
+	case STEREO_RIGHT:
+		separation = cg_stereoSeparation.value / 2;
+		break;
+	default:
+		separation = 0;
+		CG_Error( "CG_DrawActive: Undefined stereoView" );
+	}
+
+
+	// clear around the rendered view if sized down
+	CG_TileClear();
+
+	// offset vieworg appropriately if we're doing stereo separation
+	VectorCopy( cg.refdef.vieworg, baseOrg );
+	if ( separation != 0 ) {
+		VectorMA( cg.refdef.vieworg, -separation, cg.refdef.viewaxis[1], cg.refdef.vieworg );
+	}
+
+	cg.refdef.rdflags |= RDF_DRAWSKYBOX;
+
+	// draw 3D view
+	trap_R_RenderScene( &cg.refdef );
+
+	// restore original viewpoint if running stereo
+	if ( separation != 0 ) {
+		VectorCopy( baseOrg, cg.refdef.vieworg );
+	}
+
+	// draw status bar and other floating elements
+ 	CG_Draw2D();
+}
+
+
+
diff --git a/codemp/cgame/cg_drawtools.c b/codemp/cgame/cg_drawtools.c
new file mode 100644
index 0000000..dfd1769
--- /dev/null
+++ b/codemp/cgame/cg_drawtools.c
@@ -0,0 +1,690 @@
+/*
+// this line must stay at top so the whole PCH thing works...
+#include "cg_headers.h"
+
+//#include "cg_local.h"
+#include "cg_media.h"
+#include "cg_text.h"
+*/
+
+// Copyright (C) 1999-2000 Id Software, Inc.
+//
+// cg_drawtools.c -- helper functions called by cg_draw, cg_scoreboard, cg_info, etc
+#include "cg_local.h"
+#include "../game/q_shared.h"
+
+
+/*
+================
+UI_DrawRect
+
+Coordinates are 640*480 virtual values
+=================
+*/
+void CG_DrawRect( float x, float y, float width, float height, float size, const float *color ) {
+	trap_R_SetColor( color );
+	
+	CG_DrawTopBottom(x, y, width, height, size);
+	CG_DrawSides(x, y, width, height, size);
+	
+	trap_R_SetColor( NULL );
+}
+
+
+
+/*
+=================
+CG_GetColorForHealth
+=================
+*/
+void CG_GetColorForHealth( int health, int armor, vec4_t hcolor ) {
+	int		count;
+	int		max;
+
+	// calculate the total points of damage that can
+	// be sustained at the current health / armor level
+	if ( health <= 0 ) {
+		VectorClear( hcolor );	// black
+		hcolor[3] = 1;
+		return;
+	}
+	count = armor;
+	max = health * ARMOR_PROTECTION / ( 1.0 - ARMOR_PROTECTION );
+	if ( max < count ) {
+		count = max;
+	}
+	health += count;
+
+	// set the color based on health
+	hcolor[0] = 1.0;
+	hcolor[3] = 1.0;
+	if ( health >= 100 ) {
+		hcolor[2] = 1.0;
+	} else if ( health < 66 ) {
+		hcolor[2] = 0;
+	} else {
+		hcolor[2] = ( health - 66 ) / 33.0;
+	}
+
+	if ( health > 60 ) {
+		hcolor[1] = 1.0;
+	} else if ( health < 30 ) {
+		hcolor[1] = 0;
+	} else {
+		hcolor[1] = ( health - 30 ) / 30.0;
+	}
+}
+
+/*
+================
+CG_DrawSides
+
+Coords are virtual 640x480
+================
+*/
+void CG_DrawSides(float x, float y, float w, float h, float size) {
+	size *= cgs.screenXScale;
+	trap_R_DrawStretchPic( x, y, size, h, 0, 0, 0, 0, cgs.media.whiteShader );
+	trap_R_DrawStretchPic( x + w - size, y, size, h, 0, 0, 0, 0, cgs.media.whiteShader );
+}
+
+void CG_DrawTopBottom(float x, float y, float w, float h, float size) {
+	size *= cgs.screenYScale;
+	trap_R_DrawStretchPic( x, y, w, size, 0, 0, 0, 0, cgs.media.whiteShader );
+	trap_R_DrawStretchPic( x, y + h - size, w, size, 0, 0, 0, 0, cgs.media.whiteShader );
+}
+
+/*
+-------------------------
+CGC_FillRect2
+real coords
+-------------------------
+*/
+void CG_FillRect2( float x, float y, float width, float height, const float *color ) {
+	trap_R_SetColor( color );
+	trap_R_DrawStretchPic( x, y, width, height, 0, 0, 0, 0, cgs.media.whiteShader);
+	trap_R_SetColor( NULL );
+}
+
+/*
+================
+CG_FillRect
+
+Coordinates are 640*480 virtual values
+=================
+*/
+void CG_FillRect( float x, float y, float width, float height, const float *color ) {
+	trap_R_SetColor( color );
+
+	trap_R_DrawStretchPic( x, y, width, height, 0, 0, 0, 0, cgs.media.whiteShader);
+
+	trap_R_SetColor( NULL );
+}
+
+
+/*
+================
+CG_DrawPic
+
+Coordinates are 640*480 virtual values
+A width of 0 will draw with the original image width
+=================
+*/
+void CG_DrawPic( float x, float y, float width, float height, qhandle_t hShader ) {
+	trap_R_DrawStretchPic( x, y, width, height, 0, 0, 1, 1, hShader );
+}
+
+/*
+================
+CG_DrawRotatePic
+
+Coordinates are 640*480 virtual values
+A width of 0 will draw with the original image width
+rotates around the upper right corner of the passed in point
+=================
+*/
+void CG_DrawRotatePic( float x, float y, float width, float height,float angle, qhandle_t hShader ) {
+	trap_R_DrawRotatePic( x, y, width, height, 0, 0, 1, 1, angle, hShader );
+}
+
+/*
+================
+CG_DrawRotatePic2
+
+Coordinates are 640*480 virtual values
+A width of 0 will draw with the original image width
+Actually rotates around the center point of the passed in coordinates
+=================
+*/
+void CG_DrawRotatePic2( float x, float y, float width, float height,float angle, qhandle_t hShader ) {
+	trap_R_DrawRotatePic2( x, y, width, height, 0, 0, 1, 1, angle, hShader );
+}
+
+/*
+===============
+CG_DrawChar
+
+Coordinates and size in 640*480 virtual screen size
+===============
+*/
+void CG_DrawChar( int x, int y, int width, int height, int ch ) {
+	int row, col;
+	float frow, fcol;
+	float size;
+	float	ax, ay, aw, ah;
+	float size2;
+
+	ch &= 255;
+
+	if ( ch == ' ' ) {
+		return;
+	}
+
+	ax = x;
+	ay = y;
+	aw = width;
+	ah = height;
+
+	row = ch>>4;
+	col = ch&15;
+
+	frow = row*0.0625;
+	fcol = col*0.0625;
+	size = 0.03125;
+	size2 = 0.0625;
+
+	trap_R_DrawStretchPic( ax, ay, aw, ah, fcol, frow, fcol + size, frow + size2, 
+		cgs.media.charsetShader );
+
+}
+
+/*
+==================
+CG_DrawStringExt
+
+Draws a multi-colored string with a drop shadow, optionally forcing
+to a fixed color.
+
+Coordinates are at 640 by 480 virtual resolution
+==================
+*/
+#include "../../ui/menudef.h"	// for "ITEM_TEXTSTYLE_SHADOWED"
+void CG_DrawStringExt( int x, int y, const char *string, const float *setColor, 
+		qboolean forceColor, qboolean shadow, int charWidth, int charHeight, int maxChars )
+{
+	if (trap_Language_IsAsian())
+	{
+		// hack-a-doodle-do (post-release quick fix code)...
+		//
+		vec4_t color;
+		memcpy(color,setColor, sizeof(color));	// de-const it
+		CG_Text_Paint(x, y, 1.0f,	// float scale, 
+						color,		// vec4_t color, 
+						string,		// const char *text, 
+						0.0f,		// float adjust, 
+						0,			// int limit, 
+						shadow ? ITEM_TEXTSTYLE_SHADOWED : 0,	// int style, 
+						FONT_MEDIUM		// iMenuFont
+						) ;
+	}
+	else
+	{
+		vec4_t		color;
+		const char	*s;
+		int			xx;
+
+		// draw the drop shadow
+		if (shadow) {
+			color[0] = color[1] = color[2] = 0;
+			color[3] = setColor[3];
+			trap_R_SetColor( color );
+			s = string;
+			xx = x;
+			while ( *s ) {
+				if ( Q_IsColorString( s ) ) {
+					s += 2;
+					continue;
+				}
+				CG_DrawChar( xx + 2, y + 2, charWidth, charHeight, *s );
+				xx += charWidth;
+				s++;
+			}
+		}
+
+		// draw the colored text
+		s = string;
+		xx = x;
+		trap_R_SetColor( setColor );
+		while ( *s ) {
+			if ( Q_IsColorString( s ) ) {
+				if ( !forceColor ) {
+					memcpy( color, g_color_table[ColorIndex(*(s+1))], sizeof( color ) );
+					color[3] = setColor[3];
+					trap_R_SetColor( color );
+				}
+				s += 2;
+				continue;
+			}
+			CG_DrawChar( xx, y, charWidth, charHeight, *s );
+			xx += charWidth;
+			s++;
+		}
+		trap_R_SetColor( NULL );
+	}
+}
+
+void CG_DrawBigString( int x, int y, const char *s, float alpha ) {
+	float	color[4];
+
+	color[0] = color[1] = color[2] = 1.0;
+	color[3] = alpha;
+	CG_DrawStringExt( x, y, s, color, qfalse, qtrue, BIGCHAR_WIDTH, BIGCHAR_HEIGHT, 0 );
+}
+
+void CG_DrawBigStringColor( int x, int y, const char *s, vec4_t color ) {
+	CG_DrawStringExt( x, y, s, color, qtrue, qtrue, BIGCHAR_WIDTH, BIGCHAR_HEIGHT, 0 );
+}
+
+void CG_DrawSmallString( int x, int y, const char *s, float alpha ) {
+	float	color[4];
+
+	color[0] = color[1] = color[2] = 1.0;
+	color[3] = alpha;
+	CG_DrawStringExt( x, y, s, color, qfalse, qfalse, SMALLCHAR_WIDTH, SMALLCHAR_HEIGHT, 0 );
+}
+
+void CG_DrawSmallStringColor( int x, int y, const char *s, vec4_t color ) {
+	CG_DrawStringExt( x, y, s, color, qtrue, qfalse, SMALLCHAR_WIDTH, SMALLCHAR_HEIGHT, 0 );
+}
+
+/*
+=================
+CG_DrawStrlen
+
+Returns character count, skiping color escape codes
+=================
+*/
+int CG_DrawStrlen( const char *str ) {
+	const char *s = str;
+	int count = 0;
+
+	while ( *s ) {
+		if ( Q_IsColorString( s ) ) {
+			s += 2;
+		} else {
+			count++;
+			s++;
+		}
+	}
+
+	return count;
+}
+
+/*
+=============
+CG_TileClearBox
+
+This repeats a 64*64 tile graphic to fill the screen around a sized down
+refresh window.
+=============
+*/
+static void CG_TileClearBox( int x, int y, int w, int h, qhandle_t hShader ) {
+	float	s1, t1, s2, t2;
+
+	s1 = x/64.0;
+	t1 = y/64.0;
+	s2 = (x+w)/64.0;
+	t2 = (y+h)/64.0;
+	trap_R_DrawStretchPic( x, y, w, h, s1, t1, s2, t2, hShader );
+}
+
+
+
+/*
+==============
+CG_TileClear
+
+Clear around a sized down screen
+==============
+*/
+void CG_TileClear( void ) {
+	int		top, bottom, left, right;
+	int		w, h;
+
+	w = cgs.glconfig.vidWidth;
+	h = cgs.glconfig.vidHeight;
+
+	if ( cg.refdef.x == 0 && cg.refdef.y == 0 && 
+		cg.refdef.width == w && cg.refdef.height == h ) {
+		return;		// full screen rendering
+	}
+
+	top = cg.refdef.y;
+	bottom = top + cg.refdef.height-1;
+	left = cg.refdef.x;
+	right = left + cg.refdef.width-1;
+
+	// clear above view screen
+	CG_TileClearBox( 0, 0, w, top, cgs.media.backTileShader );
+
+	// clear below view screen
+	CG_TileClearBox( 0, bottom, w, h - bottom, cgs.media.backTileShader );
+
+	// clear left of view screen
+	CG_TileClearBox( 0, top, left, bottom - top + 1, cgs.media.backTileShader );
+
+	// clear right of view screen
+	CG_TileClearBox( right, top, w - right, bottom - top + 1, cgs.media.backTileShader );
+}
+
+
+
+/*
+================
+CG_FadeColor
+================
+*/
+float *CG_FadeColor( int startMsec, int totalMsec ) {
+	static vec4_t		color;
+	int			t;
+
+	if ( startMsec == 0 ) {
+		return NULL;
+	}
+
+	t = cg.time - startMsec;
+
+	if ( t >= totalMsec ) {
+		return NULL;
+	}
+
+	// fade out
+	if ( totalMsec - t < FADE_TIME ) {
+		color[3] = ( totalMsec - t ) * 1.0/FADE_TIME;
+	} else {
+		color[3] = 1.0;
+	}
+	color[0] = color[1] = color[2] = 1;
+
+	return color;
+}
+
+
+/*
+=================
+CG_ColorForHealth
+=================
+*/
+void CG_ColorForGivenHealth( vec4_t hcolor, int health ) 
+{
+	// set the color based on health
+	hcolor[0] = 1.0;
+	if ( health >= 100 ) 
+	{
+		hcolor[2] = 1.0;
+	} 
+	else if ( health < 66 ) 
+	{
+		hcolor[2] = 0;
+	} 
+	else 
+	{
+		hcolor[2] = ( health - 66 ) / 33.0;
+	}
+
+	if ( health > 60 ) 
+	{
+		hcolor[1] = 1.0;
+	} 
+	else if ( health < 30 ) 
+	{
+		hcolor[1] = 0;
+	} 
+	else 
+	{
+		hcolor[1] = ( health - 30 ) / 30.0;
+	}
+}
+
+/*
+=================
+CG_ColorForHealth
+=================
+*/
+void CG_ColorForHealth( vec4_t hcolor ) 
+{
+	int		health;
+	int		count;
+	int		max;
+
+	// calculate the total points of damage that can
+	// be sustained at the current health / armor level
+	health = cg.snap->ps.stats[STAT_HEALTH];
+
+	if ( health <= 0 ) 
+	{
+		VectorClear( hcolor );	// black
+		hcolor[3] = 1;
+		return;
+	}
+
+	count = cg.snap->ps.stats[STAT_ARMOR];
+	max = health * ARMOR_PROTECTION / ( 1.0 - ARMOR_PROTECTION );
+	if ( max < count ) 
+	{
+		count = max;
+	}
+	health += count;
+
+	hcolor[3] = 1.0;
+	CG_ColorForGivenHealth( hcolor, health );
+}
+
+/*
+==============
+CG_DrawNumField
+
+Take x,y positions as if 640 x 480 and scales them to the proper resolution
+
+==============
+*/
+void CG_DrawNumField (int x, int y, int width, int value,int charWidth,int charHeight,int style,qboolean zeroFill) 
+{
+	char	num[16], *ptr;
+	int		l;
+	int		frame;
+	int		xWidth;
+	int		i = 0;
+
+	if (width < 1) {
+		return;
+	}
+
+	// draw number string
+	if (width > 5) {
+		width = 5;
+	}
+
+	switch ( width ) {
+	case 1:
+		value = value > 9 ? 9 : value;
+		value = value < 0 ? 0 : value;
+		break;
+	case 2:
+		value = value > 99 ? 99 : value;
+		value = value < -9 ? -9 : value;
+		break;
+	case 3:
+		value = value > 999 ? 999 : value;
+		value = value < -99 ? -99 : value;
+		break;
+	case 4:
+		value = value > 9999 ? 9999 : value;
+		value = value < -999 ? -999 : value;
+		break;
+	}
+
+	Com_sprintf (num, sizeof(num), "%i", value);
+	l = strlen(num);
+	if (l > width)
+		l = width;
+
+	// FIXME: Might need to do something different for the chunky font??
+	switch(style)
+	{
+	case NUM_FONT_SMALL:
+		xWidth = charWidth;
+		break;
+	case NUM_FONT_CHUNKY:
+		xWidth = (charWidth/1.2f) + 2;
+		break;
+	default:
+	case NUM_FONT_BIG:
+		xWidth = (charWidth/2) + 7;//(charWidth/6);
+		break;
+	}
+
+	if ( zeroFill )
+	{
+		for (i = 0; i < (width - l); i++ )
+		{
+			switch(style)
+			{
+			case NUM_FONT_SMALL:
+				CG_DrawPic( x,y, charWidth, charHeight, cgs.media.smallnumberShaders[0] );
+				break;
+			case NUM_FONT_CHUNKY:
+				CG_DrawPic( x,y, charWidth, charHeight, cgs.media.chunkyNumberShaders[0] );
+				break;
+			default:
+			case NUM_FONT_BIG:
+				CG_DrawPic( x,y, charWidth, charHeight, cgs.media.numberShaders[0] );
+				break;
+			}
+			x += 2 + (xWidth);
+		}
+	}
+	else
+	{
+		x += 2 + (xWidth)*(width - l);
+	}
+
+	ptr = num;
+	while (*ptr && l)
+	{
+		if (*ptr == '-')
+			frame = STAT_MINUS;
+		else
+			frame = *ptr -'0';
+
+		switch(style)
+		{
+		case NUM_FONT_SMALL:
+			CG_DrawPic( x,y, charWidth, charHeight, cgs.media.smallnumberShaders[frame] );
+			x++;	// For a one line gap
+			break;
+		case NUM_FONT_CHUNKY:
+			CG_DrawPic( x,y, charWidth, charHeight, cgs.media.chunkyNumberShaders[frame] );
+			break;
+		default:
+		case NUM_FONT_BIG:
+			CG_DrawPic( x,y, charWidth, charHeight, cgs.media.numberShaders[frame] );
+			break;
+		}
+
+		x += (xWidth);
+		ptr++;
+		l--;
+	}
+
+}
+
+#include "../ui/ui_shared.h"	// for some text style junk
+void UI_DrawProportionalString( int x, int y, const char* str, int style, vec4_t color ) 
+{
+	// having all these different style defines (1 for UI, one for CG, and now one for the re->font stuff) 
+	//	is dumb, but for now...
+	//
+	int iStyle = 0;
+	int iMenuFont = (style & UI_SMALLFONT) ? FONT_SMALL : FONT_MEDIUM;
+
+	switch (style & (UI_LEFT|UI_CENTER|UI_RIGHT))
+	{
+		default:
+		case UI_LEFT:
+		{
+			// nada...
+		}
+		break;
+
+		case UI_CENTER:
+		{
+			x -= CG_Text_Width(str, 1.0, iMenuFont) / 2;
+		}
+		break;
+
+		case UI_RIGHT:
+		{
+			x -= CG_Text_Width(str, 1.0, iMenuFont) / 2;
+		}
+		break;
+	}
+
+	if (style & UI_DROPSHADOW)
+	{
+		iStyle = ITEM_TEXTSTYLE_SHADOWED;
+	}
+	else
+	if ( style & (UI_BLINK|UI_PULSE) )
+	{
+		iStyle = ITEM_TEXTSTYLE_BLINK;
+	}
+
+	CG_Text_Paint(x, y, 1.0, color, str, 0, 0, iStyle, iMenuFont);
+}
+
+void UI_DrawScaledProportionalString( int x, int y, const char* str, int style, vec4_t color, float scale) 
+{
+	// having all these different style defines (1 for UI, one for CG, and now one for the re->font stuff) 
+	//	is dumb, but for now...
+	//
+	int iStyle = 0;
+
+	switch (style & (UI_LEFT|UI_CENTER|UI_RIGHT))
+	{
+		default:
+		case UI_LEFT:
+		{
+			// nada...
+		}
+		break;
+
+		case UI_CENTER:
+		{
+			x -= CG_Text_Width(str, scale, FONT_MEDIUM) / 2;
+		}
+		break;
+
+		case UI_RIGHT:
+		{
+			x -= CG_Text_Width(str, scale, FONT_MEDIUM) / 2;
+		}
+		break;
+	}
+
+	if (style & UI_DROPSHADOW)
+	{
+		iStyle = ITEM_TEXTSTYLE_SHADOWED;
+	}
+	else
+	if ( style & (UI_BLINK|UI_PULSE) )
+	{
+		iStyle = ITEM_TEXTSTYLE_BLINK;
+	}
+
+	CG_Text_Paint(x, y, scale, color, str, 0, 0, iStyle, FONT_MEDIUM);
+}
+
+
+
+
diff --git a/codemp/cgame/cg_effects.c b/codemp/cgame/cg_effects.c
new file mode 100644
index 0000000..1fef6a1
--- /dev/null
+++ b/codemp/cgame/cg_effects.c
@@ -0,0 +1,1546 @@
+// Copyright (C) 1999-2000 Id Software, Inc.
+//
+// cg_effects.c -- these functions generate localentities, usually as a result
+// of event processing
+
+#include "cg_local.h"
+
+/*
+==================
+CG_BubbleTrail
+
+Bullets shot underwater
+==================
+*/
+void CG_BubbleTrail( vec3_t start, vec3_t end, float spacing ) {
+	vec3_t		move;
+	vec3_t		vec;
+	float		len;
+	int			i;
+
+	if ( cg_noProjectileTrail.integer ) {
+		return;
+	}
+
+	VectorCopy (start, move);
+	VectorSubtract (end, start, vec);
+	len = VectorNormalize (vec);
+
+	// advance a random amount first
+	i = rand() % (int)spacing;
+	VectorMA( move, i, vec, move );
+
+	VectorScale (vec, spacing, vec);
+
+	for ( ; i < len; i += spacing ) {
+		localEntity_t	*le;
+		refEntity_t		*re;
+
+		le = CG_AllocLocalEntity();
+		le->leFlags = LEF_PUFF_DONT_SCALE;
+		le->leType = LE_MOVE_SCALE_FADE;
+		le->startTime = cg.time;
+		le->endTime = cg.time + 1000 + random() * 250;
+		le->lifeRate = 1.0 / ( le->endTime - le->startTime );
+
+		re = &le->refEntity;
+		re->shaderTime = cg.time / 1000.0f;
+
+		re->reType = RT_SPRITE;
+		re->rotation = 0;
+		re->radius = 3;
+		re->customShader = 0;//cgs.media.waterBubbleShader;
+		re->shaderRGBA[0] = 0xff;
+		re->shaderRGBA[1] = 0xff;
+		re->shaderRGBA[2] = 0xff;
+		re->shaderRGBA[3] = 0xff;
+
+		le->color[3] = 1.0;
+
+		le->pos.trType = TR_LINEAR;
+		le->pos.trTime = cg.time;
+		VectorCopy( move, le->pos.trBase );
+		le->pos.trDelta[0] = crandom()*5;
+		le->pos.trDelta[1] = crandom()*5;
+		le->pos.trDelta[2] = crandom()*5 + 6;
+
+		VectorAdd (move, vec, move);
+	}
+}
+
+/*
+=====================
+CG_SmokePuff
+
+Adds a smoke puff or blood trail localEntity.
+=====================
+*/
+localEntity_t *CG_SmokePuff( const vec3_t p, const vec3_t vel, 
+				   float radius,
+				   float r, float g, float b, float a,
+				   float duration,
+				   int startTime,
+				   int fadeInTime,
+				   int leFlags,
+				   qhandle_t hShader ) {
+	static int	seed = 0x92;
+	localEntity_t	*le;
+	refEntity_t		*re;
+//	int fadeInTime = startTime + duration / 2;
+
+	le = CG_AllocLocalEntity();
+	le->leFlags = leFlags;
+	le->radius = radius;
+
+	re = &le->refEntity;
+	re->rotation = Q_random( &seed ) * 360;
+	re->radius = radius;
+	re->shaderTime = startTime / 1000.0f;
+
+	le->leType = LE_MOVE_SCALE_FADE;
+	le->startTime = startTime;
+	le->fadeInTime = fadeInTime;
+	le->endTime = startTime + duration;
+	if ( fadeInTime > startTime ) {
+		le->lifeRate = 1.0 / ( le->endTime - le->fadeInTime );
+	}
+	else {
+		le->lifeRate = 1.0 / ( le->endTime - le->startTime );
+	}
+	le->color[0] = r;
+	le->color[1] = g; 
+	le->color[2] = b;
+	le->color[3] = a;
+
+
+	le->pos.trType = TR_LINEAR;
+	le->pos.trTime = startTime;
+	VectorCopy( vel, le->pos.trDelta );
+	VectorCopy( p, le->pos.trBase );
+
+	VectorCopy( p, re->origin );
+	re->customShader = hShader;
+
+	re->shaderRGBA[0] = le->color[0] * 0xff;
+	re->shaderRGBA[1] = le->color[1] * 0xff;
+	re->shaderRGBA[2] = le->color[2] * 0xff;
+	re->shaderRGBA[3] = 0xff;
+
+	re->reType = RT_SPRITE;
+	re->radius = le->radius;
+
+	return le;
+}
+
+int CGDEBUG_SaberColor( int saberColor )
+{
+	switch( (int)(saberColor) )
+	{
+		case SABER_RED:
+			return 0x000000ff;
+			break;
+		case SABER_ORANGE:
+			return 0x000088ff;
+			break;
+		case SABER_YELLOW:
+			return 0x0000ffff;
+			break;
+		case SABER_GREEN:
+			return 0x0000ff00;
+			break;
+		case SABER_BLUE:
+			return 0x00ff0000;
+			break;
+		case SABER_PURPLE:
+			return 0x00ff00ff;
+			break;
+		default:
+			return saberColor;
+			break;
+	}
+}
+
+void CG_TestLine( vec3_t start, vec3_t end, int time, unsigned int color, int radius) {
+	localEntity_t	*le;
+	refEntity_t		*re;
+
+	le = CG_AllocLocalEntity();
+	le->leType = LE_LINE;
+	le->startTime = cg.time;
+	le->endTime = cg.time + time;
+	le->lifeRate = 1.0 / ( le->endTime - le->startTime );
+
+	re = &le->refEntity;
+	VectorCopy( start, re->origin );
+	VectorCopy( end, re->oldorigin);
+	re->shaderTime = cg.time / 1000.0f;
+
+	re->reType = RT_LINE;
+	re->radius = 0.5*radius;
+	re->customShader = cgs.media.whiteShader; //trap_R_RegisterShaderNoMip("textures/colombia/canvas_doublesided");
+
+	re->shaderTexCoord[0] = re->shaderTexCoord[1] = 1.0f;
+
+	if (color==0)
+	{
+		re->shaderRGBA[0] = re->shaderRGBA[1] = re->shaderRGBA[2] = re->shaderRGBA[3] = 0xff;
+	}
+	else
+	{
+		color = CGDEBUG_SaberColor( color );
+		re->shaderRGBA[0] = color & 0xff;
+		color >>= 8;
+		re->shaderRGBA[1] = color & 0xff;
+		color >>= 8;
+		re->shaderRGBA[2] = color & 0xff;
+//		color >>= 8;
+//		re->shaderRGBA[3] = color & 0xff;
+		re->shaderRGBA[3] = 0xff;
+	}
+
+	le->color[3] = 1.0;
+
+	//re->renderfx |= RF_DEPTHHACK;
+}
+
+/*
+==================
+CG_ThrowChunk
+==================
+*/
+void CG_ThrowChunk( vec3_t origin, vec3_t velocity, qhandle_t hModel, int optionalSound, int startalpha ) {
+	localEntity_t	*le;
+	refEntity_t		*re;
+
+	le = CG_AllocLocalEntity();
+	re = &le->refEntity;
+
+	le->leType = LE_FRAGMENT;
+	le->startTime = cg.time;
+	le->endTime = le->startTime + 5000 + random() * 3000;
+
+	VectorCopy( origin, re->origin );
+	AxisCopy( axisDefault, re->axis );
+	re->hModel = hModel;
+
+	le->pos.trType = TR_GRAVITY;
+	le->angles.trType = TR_GRAVITY;
+	VectorCopy( origin, le->pos.trBase );
+	VectorCopy( velocity, le->pos.trDelta );
+	VectorSet(le->angles.trBase, 20, 20, 20);
+	VectorCopy( velocity, le->angles.trDelta );
+	le->pos.trTime = cg.time;
+	le->angles.trTime = cg.time;
+
+	le->leFlags = LEF_TUMBLE;
+
+	le->angles.trBase[YAW] = 180;
+
+	le->bounceFactor = 0.3f;
+	le->bounceSound = optionalSound;
+
+	le->forceAlpha = startalpha;
+}
+
+//----------------------------
+//
+// Breaking Glass Technology
+//
+//----------------------------
+
+// Since we have shared verts when we tesselate the glass sheet, it helps to have a 
+//	random offset table set up up front.
+
+static float offX[20][20],
+			offZ[20][20];
+
+#define	FX_ALPHA_NONLINEAR	0x00000004
+#define FX_APPLY_PHYSICS	0x02000000
+#define FX_USE_ALPHA		0x08000000
+
+static void CG_DoGlassQuad( vec3_t p[4], vec2_t uv[4], qboolean stick, int time, vec3_t dmgDir )
+{
+	float	bounce;
+	vec3_t	rotDelta;
+	vec3_t	vel, accel;
+	vec3_t	rgb1;
+	addpolyArgStruct_t apArgs;
+	int		i, i_2;
+
+	VectorSet( vel, crandom() * 12, crandom() * 12, -1 );
+
+	if ( !stick )
+	{
+		// We aren't a motion delayed chunk, so let us move quickly
+		VectorMA( vel, 0.3f, dmgDir, vel );
+	}
+
+	// Set up acceleration due to gravity, 800 is standard QuakeIII gravity, so let's use something close
+	VectorSet( accel, 0.0f, 0.0f, -(600.0f + random() * 100.0f ) );
+
+	// We are using an additive shader, so let's set the RGB low so we look more like transparent glass
+//	VectorSet( rgb1, 0.1f, 0.1f, 0.1f );
+	VectorSet( rgb1, 1.0f, 1.0f, 1.0f );
+
+	// Being glass, we don't want to bounce much
+	bounce = random() * 0.2f + 0.15f;
+
+	// Set up our random rotate, we only do PITCH and YAW, not ROLL.  This is something like degrees per second
+	VectorSet( rotDelta, crandom() * 40.0f, crandom() * 40.0f, 0.0f );
+
+	//In an ideal world, this might actually work.
+	/*
+	CPoly *pol = FX_AddPoly(p, uv, 4,			// verts, ST, vertCount
+			vel, accel,				// motion
+			0.15f, 0.0f, 85.0f,		// alpha start, alpha end, alpha parm ( begin alpha fade when 85% of life is complete )
+			rgb1, rgb1, 0.0f,		// rgb start, rgb end, rgb parm ( not used )
+			rotDelta, bounce, time,	// rotation amount, bounce, and time to delay motion for ( zero if no delay );
+			6000,					// life
+			cgi_R_RegisterShader( "gfx/misc/test_crackle" ), 
+			FX_APPLY_PHYSICS | FX_ALPHA_NONLINEAR | FX_USE_ALPHA );
+
+	if ( random() > 0.95f && pol )
+	{
+		pol->AddFlags( FX_IMPACT_RUNS_FX | FX_KILL_ON_IMPACT );
+		pol->SetImpactFxID( theFxScheduler.RegisterEffect( "glass_impact" ));
+	}
+	*/
+
+	//rww - this is dirty.
+
+	i = 0;
+	i_2 = 0;
+
+	while (i < 4)
+	{
+		while (i_2 < 3)
+		{
+			apArgs.p[i][i_2] = p[i][i_2];
+
+			i_2++;
+		}
+
+		i_2 = 0;
+		i++;
+	}
+
+	i = 0;
+	i_2 = 0;
+
+	while (i < 4)
+	{
+		while (i_2 < 2)
+		{
+			apArgs.ev[i][i_2] = uv[i][i_2];
+
+			i_2++;
+		}
+
+		i_2 = 0;
+		i++;
+	}
+
+	apArgs.numVerts = 4;
+	VectorCopy(vel, apArgs.vel);
+	VectorCopy(accel, apArgs.accel);
+
+	apArgs.alpha1 = 0.15f;
+	apArgs.alpha2 = 0.0f;
+	apArgs.alphaParm = 85.0f;
+
+	VectorCopy(rgb1, apArgs.rgb1);
+	VectorCopy(rgb1, apArgs.rgb2);
+
+	apArgs.rgbParm = 0.0f;
+
+	VectorCopy(rotDelta, apArgs.rotationDelta);
+
+	apArgs.bounce = bounce;
+	apArgs.motionDelay = time;
+	apArgs.killTime = 6000;
+	apArgs.shader = cgs.media.glassShardShader;
+	apArgs.flags = (FX_APPLY_PHYSICS | FX_ALPHA_NONLINEAR | FX_USE_ALPHA);
+
+	trap_FX_AddPoly(&apArgs);
+}
+
+static void CG_CalcBiLerp( vec3_t verts[4], vec3_t subVerts[4], vec2_t uv[4] )
+{
+	vec3_t	temp;
+
+	// Nasty crap
+	VectorScale( verts[0],	1.0f - uv[0][0],	subVerts[0] );
+	VectorMA( subVerts[0],	uv[0][0],			verts[1], subVerts[0] );
+	VectorScale( subVerts[0], 1.0f - uv[0][1],	temp );
+	VectorScale( verts[3],	1.0f - uv[0][0],	subVerts[0] );
+	VectorMA( subVerts[0],	uv[0][0],			verts[2], subVerts[0] );
+	VectorMA( temp,			uv[0][1],			subVerts[0], subVerts[0] );
+
+	VectorScale( verts[0],	1.0f - uv[1][0],	subVerts[1] );
+	VectorMA( subVerts[1],	uv[1][0],			verts[1], subVerts[1] );
+	VectorScale( subVerts[1], 1.0f - uv[1][1],	temp );
+	VectorScale( verts[3],	1.0f - uv[1][0],	subVerts[1] );
+	VectorMA( subVerts[1],	uv[1][0],			verts[2], subVerts[1] );
+	VectorMA( temp,			uv[1][1],			subVerts[1], subVerts[1] );
+
+	VectorScale( verts[0],	1.0f - uv[2][0],	subVerts[2] );
+	VectorMA( subVerts[2],	uv[2][0],			verts[1], subVerts[2] );
+	VectorScale( subVerts[2], 1.0f - uv[2][1],		temp );
+	VectorScale( verts[3],	1.0f - uv[2][0],	subVerts[2] );
+	VectorMA( subVerts[2],	uv[2][0],			verts[2], subVerts[2] );
+	VectorMA( temp,			uv[2][1],			subVerts[2], subVerts[2] );
+
+	VectorScale( verts[0],	1.0f - uv[3][0],	subVerts[3] );
+	VectorMA( subVerts[3],	uv[3][0],			verts[1], subVerts[3] );
+	VectorScale( subVerts[3], 1.0f - uv[3][1],	temp );
+	VectorScale( verts[3],	1.0f - uv[3][0],	subVerts[3] );
+	VectorMA( subVerts[3],	uv[3][0],			verts[2], subVerts[3] );
+	VectorMA( temp,			uv[3][1],			subVerts[3], subVerts[3] );
+}
+// bilinear
+//f(p',q') = (1 - y) × {[(1 - x) × f(p,q)] + [x × f(p,q+1)]} + y × {[(1 - x) × f(p+1,q)] + [x × f(p+1,q+1)]}. 
+
+
+static void CG_CalcHeightWidth( vec3_t verts[4], float *height, float *width )
+{
+	vec3_t	dir1, dir2, cross;
+
+	VectorSubtract( verts[3], verts[0], dir1 ); // v
+	VectorSubtract( verts[1], verts[0], dir2 ); // p-a
+	CrossProduct( dir1, dir2, cross );
+	*width = VectorNormalize( cross ) / VectorNormalize( dir1 ); // v 
+	VectorSubtract( verts[2], verts[0], dir2 ); // p-a
+	CrossProduct( dir1, dir2, cross );
+	*width += VectorNormalize( cross ) / VectorNormalize( dir1 ); // v 
+	*width *= 0.5f;
+
+	VectorSubtract( verts[1], verts[0], dir1 ); // v
+	VectorSubtract( verts[2], verts[0], dir2 ); // p-a
+	CrossProduct( dir1, dir2, cross );
+	*height = VectorNormalize( cross ) / VectorNormalize( dir1 ); // v 
+	VectorSubtract( verts[3], verts[0], dir2 ); // p-a
+	CrossProduct( dir1, dir2, cross );
+	*height += VectorNormalize( cross ) / VectorNormalize( dir1 ); // v 
+	*height *= 0.5f;
+}
+//Consider a line in 3D with position vector "a" and direction vector "v" and 
+// let "p" be the position vector of an arbitrary point in 3D
+//dist = len( crossprod(p-a,v) ) / len(v); 
+
+void CG_InitGlass( void )
+{
+	int i, t;
+
+	// Build a table first, so that we can do a more unpredictable crack scheme
+	//	do it once, up front to save a bit of time.
+	for ( i = 0; i < 20; i++ )
+	{
+		for ( t = 0; t < 20; t++ )
+		{
+			offX[t][i] = crandom() * 0.03f;
+			offZ[i][t] = crandom() * 0.03f;
+		}
+	}
+}
+
+void Vector2Set(vec2_t a,float b,float c)
+{
+	a[0] = b;
+	a[1] = c;
+}
+
+#define TIME_DECAY_SLOW		0.1f
+#define TIME_DECAY_MED		0.04f
+#define TIME_DECAY_FAST		0.009f
+
+void CG_DoGlass( vec3_t verts[4], vec3_t normal, vec3_t dmgPt, vec3_t dmgDir, float dmgRadius, int maxShards )
+{
+	int			i, t;
+	int			mxHeight, mxWidth;
+	float		height, width;
+	float		stepWidth, stepHeight;
+	float		timeDecay;
+	float		x, z;
+	float		xx, zz;
+	float		dif;
+	int			time = 0;
+	int			glassShards = 0;
+	qboolean	stick = qtrue;
+	vec3_t		subVerts[4];
+	vec2_t		biPoints[4];
+
+	// To do a smarter tesselation, we should figure out the relative height and width of the brush face,
+	//	then use this to pick a lod value from 1-3 in each axis.  This will give us 1-9 lod levels, which will
+	//	hopefully be sufficient.
+	CG_CalcHeightWidth( verts, &height, &width );
+
+	trap_S_StartSound( dmgPt, -1, CHAN_AUTO, trap_S_RegisterSound("sound/effects/glassbreak1.wav"));
+
+	// Pick "LOD" for height
+	if ( height < 100 )
+	{
+		stepHeight = 0.2f;
+		mxHeight = 5;
+		timeDecay = TIME_DECAY_SLOW;
+	}
+	else if ( height > 220 )
+	{
+		stepHeight = 0.05f;
+		mxHeight = 20;
+		timeDecay = TIME_DECAY_FAST;
+	}
+	else
+	{
+		stepHeight = 0.1f;
+		mxHeight = 10;
+		timeDecay = TIME_DECAY_MED;
+	}
+
+	// Pick "LOD" for width
+	/*
+	if ( width < 100 )
+	{
+		stepWidth = 0.2f;
+		mxWidth = 5;
+		timeDecay = ( timeDecay + TIME_DECAY_SLOW ) * 0.5f;
+	}
+	else if ( width > 220 )
+	{
+		stepWidth = 0.05f;
+		mxWidth = 20;
+		timeDecay = ( timeDecay + TIME_DECAY_FAST ) * 0.5f;
+	}
+	else
+	{
+		stepWidth = 0.1f;
+		mxWidth = 10;
+		timeDecay = ( timeDecay + TIME_DECAY_MED ) * 0.5f;
+	}
+	*/
+
+	//Attempt to scale the glass directly to the size of the window
+
+	stepWidth = (0.25f - (width*0.0002)); //(width*0.0005));
+	mxWidth = width*0.2;
+	timeDecay = ( timeDecay + TIME_DECAY_FAST ) * 0.5f;
+
+	if (stepWidth < 0.01f)
+	{
+		stepWidth = 0.01f;
+	}
+	if (mxWidth < 5)
+	{
+		mxWidth = 5;
+	}
+
+	for ( z = 0.0f, i = 0; z < 1.0f; z += stepHeight, i++ )
+	{
+		for ( x = 0.0f, t = 0; x < 1.0f; x += stepWidth, t++ )
+		{
+			// This is nasty..
+			if ( t > 0 && t < mxWidth )
+			{
+				xx = x - offX[i][t];
+			}
+			else
+			{
+				xx = x;
+			}
+
+			if ( i > 0 && i < mxHeight )
+			{
+				zz = z - offZ[t][i];
+			}
+			else
+			{
+				zz = z;
+			}
+
+			Vector2Set( biPoints[0], xx, zz );
+
+			if ( t + 1 > 0 && t + 1 < mxWidth )
+			{
+				xx = x - offX[i][t + 1];
+			}
+			else
+			{
+				xx = x;
+			}
+
+			if ( i > 0 && i < mxHeight )
+			{
+				zz = z - offZ[t + 1][i];
+			}
+			else
+			{
+				zz = z;
+			}
+
+			Vector2Set( biPoints[1], xx + stepWidth, zz );
+
+			if ( t + 1 > 0 && t + 1 < mxWidth )
+			{
+				xx = x - offX[i + 1][t + 1];
+			}
+			else
+			{
+				xx = x;
+			}
+
+			if ( i + 1 > 0 && i + 1 < mxHeight )
+			{
+				zz = z - offZ[t + 1][i + 1];
+			}
+			else
+			{
+				zz = z;
+			}
+
+			Vector2Set( biPoints[2], xx + stepWidth, zz + stepHeight);
+
+			if ( t > 0 && t < mxWidth )
+			{
+				xx = x - offX[i + 1][t];
+			}
+			else
+			{
+				xx = x;
+			}
+
+			if ( i + 1 > 0 && i + 1 < mxHeight )
+			{
+				zz = z - offZ[t][i + 1];
+			}
+			else
+			{
+				zz = z;
+			}
+
+			Vector2Set( biPoints[3], xx, zz + stepHeight );
+
+			CG_CalcBiLerp( verts, subVerts, biPoints );
+			
+			dif = DistanceSquared( subVerts[0], dmgPt ) * timeDecay - random() * 32;
+			
+			// If we decrease dif, we are increasing the impact area, making it more likely to blow out large holes
+			dif -= dmgRadius * dmgRadius;
+
+			if ( dif > 1 )
+			{
+				stick = qtrue;
+				time = dif + random() * 200;
+			}
+			else
+			{
+				stick = qfalse;
+				time = 0;
+			}
+
+			CG_DoGlassQuad( subVerts, biPoints, stick, time, dmgDir );
+			glassShards++;
+
+			if (maxShards && glassShards >= maxShards)
+			{
+				return;
+			}
+		}
+	}
+}
+
+/*
+==================
+CG_GlassShatter
+Break glass with fancy method
+==================
+*/
+void CG_GlassShatter(int entnum, vec3_t dmgPt, vec3_t dmgDir, float dmgRadius, int maxShards)
+{
+	vec3_t		verts[4], normal;
+
+	if (cgs.inlineDrawModel[cg_entities[entnum].currentState.modelindex])
+	{
+		trap_R_GetBModelVerts(cgs.inlineDrawModel[cg_entities[entnum].currentState.modelindex], verts, normal);
+		CG_DoGlass(verts, normal, dmgPt, dmgDir, dmgRadius, maxShards);
+	}
+	//otherwise something awful has happened.
+}
+
+/*
+==================
+CG_GlassShatter_Old
+Throws glass shards from within a given bounding box in the world
+==================
+*/
+void CG_GlassShatter_Old(int entnum, vec3_t org, vec3_t mins, vec3_t maxs)
+{
+	vec3_t velocity, a, shardorg, dif, difx;
+	float windowmass;
+	float shardsthrow = 0;
+	char chunkname[256];
+
+	trap_S_StartSound(org, entnum, CHAN_BODY, trap_S_RegisterSound("sound/effects/glassbreak1.wav"));
+
+	VectorSubtract(maxs, mins, a);
+
+	windowmass = VectorLength(a); //should give us some idea of how big the chunk of glass is
+
+	while (shardsthrow < windowmass)
+	{
+		velocity[0] = crandom()*150;
+		velocity[1] = crandom()*150;
+		velocity[2] = 150 + crandom()*75;
+
+		Com_sprintf(chunkname, sizeof(chunkname), "models/chunks/glass/glchunks_%i.md3", Q_irand(1, 6));
+		VectorCopy(org, shardorg);
+	
+		dif[0] = (maxs[0]-mins[0])/2;
+		dif[1] = (maxs[1]-mins[1])/2;
+		dif[2] = (maxs[2]-mins[2])/2;
+
+		if (dif[0] < 2)
+		{
+			dif[0] = 2;
+		}
+		if (dif[1] < 2)
+		{
+			dif[1] = 2;
+		}
+		if (dif[2] < 2)
+		{
+			dif[2] = 2;
+		}
+
+		difx[0] = Q_irand(1, (dif[0]*0.9)*2);
+		difx[1] = Q_irand(1, (dif[1]*0.9)*2);
+		difx[2] = Q_irand(1, (dif[2]*0.9)*2);
+
+		if (difx[0] > dif[0])
+		{
+			shardorg[0] += difx[0]-(dif[0]);
+		}
+		else
+		{
+			shardorg[0] -= difx[0];
+		}
+		if (difx[1] > dif[1])
+		{
+			shardorg[1] += difx[1]-(dif[1]);
+		}
+		else
+		{
+			shardorg[1] -= difx[1];
+		}
+		if (difx[2] > dif[2])
+		{
+			shardorg[2] += difx[2]-(dif[2]);
+		}
+		else
+		{
+			shardorg[2] -= difx[2];
+		}
+
+		//CG_TestLine(org, shardorg, 5000, 0x0000ff, 3);
+
+		CG_ThrowChunk( shardorg, velocity, trap_R_RegisterModel( chunkname ), 0, 254 );
+
+		shardsthrow += 10;
+	}
+}
+
+/*
+==================
+CG_CreateDebris
+Throws specified debris from within a given bounding box in the world
+==================
+*/
+#define DEBRIS_SPECIALCASE_ROCK			-1
+#define DEBRIS_SPECIALCASE_CHUNKS		-2
+#define DEBRIS_SPECIALCASE_WOOD			-3
+#define DEBRIS_SPECIALCASE_GLASS		-4
+
+#define NUM_DEBRIS_MODELS_GLASS				8
+#define NUM_DEBRIS_MODELS_WOOD				8
+#define NUM_DEBRIS_MODELS_CHUNKS			3
+#define NUM_DEBRIS_MODELS_ROCKS				4 //12
+
+int dbModels_Glass[NUM_DEBRIS_MODELS_GLASS];
+int dbModels_Wood[NUM_DEBRIS_MODELS_WOOD];
+int dbModels_Chunks[NUM_DEBRIS_MODELS_CHUNKS];
+int dbModels_Rocks[NUM_DEBRIS_MODELS_ROCKS];
+
+void CG_CreateDebris(int entnum, vec3_t org, vec3_t mins, vec3_t maxs, int debrissound, int debrismodel)
+{
+	vec3_t velocity, a, shardorg, dif, difx;
+	float windowmass;
+	float shardsthrow = 0;
+	int omodel = debrismodel;
+
+	if (omodel == DEBRIS_SPECIALCASE_GLASS && !dbModels_Glass[0])
+	{ //glass no longer exists, using it for metal.
+		dbModels_Glass[0] = trap_R_RegisterModel("models/chunks/metal/metal1_1.md3");
+		dbModels_Glass[1] = trap_R_RegisterModel("models/chunks/metal/metal1_2.md3");
+		dbModels_Glass[2] = trap_R_RegisterModel("models/chunks/metal/metal1_3.md3");
+		dbModels_Glass[3] = trap_R_RegisterModel("models/chunks/metal/metal1_4.md3");
+		dbModels_Glass[4] = trap_R_RegisterModel("models/chunks/metal/metal2_1.md3");
+		dbModels_Glass[5] = trap_R_RegisterModel("models/chunks/metal/metal2_2.md3");
+		dbModels_Glass[6] = trap_R_RegisterModel("models/chunks/metal/metal2_3.md3");
+		dbModels_Glass[7] = trap_R_RegisterModel("models/chunks/metal/metal2_4.md3");
+	}
+	if (omodel == DEBRIS_SPECIALCASE_WOOD && !dbModels_Wood[0])
+	{
+		dbModels_Wood[0] = trap_R_RegisterModel("models/chunks/crate/crate1_1.md3");
+		dbModels_Wood[1] = trap_R_RegisterModel("models/chunks/crate/crate1_2.md3");
+		dbModels_Wood[2] = trap_R_RegisterModel("models/chunks/crate/crate1_3.md3");
+		dbModels_Wood[3] = trap_R_RegisterModel("models/chunks/crate/crate1_4.md3");
+		dbModels_Wood[4] = trap_R_RegisterModel("models/chunks/crate/crate2_1.md3");
+		dbModels_Wood[5] = trap_R_RegisterModel("models/chunks/crate/crate2_2.md3");
+		dbModels_Wood[6] = trap_R_RegisterModel("models/chunks/crate/crate2_3.md3");
+		dbModels_Wood[7] = trap_R_RegisterModel("models/chunks/crate/crate2_4.md3");
+	}
+	if (omodel == DEBRIS_SPECIALCASE_CHUNKS && !dbModels_Chunks[0])
+	{
+		dbModels_Chunks[0] = trap_R_RegisterModel("models/chunks/generic/chunks_1.md3");
+		dbModels_Chunks[1] = trap_R_RegisterModel("models/chunks/generic/chunks_2.md3");
+	}
+	if (omodel == DEBRIS_SPECIALCASE_ROCK && !dbModels_Rocks[0])
+	{
+		dbModels_Rocks[0] = trap_R_RegisterModel("models/chunks/rock/rock1_1.md3");
+		dbModels_Rocks[1] = trap_R_RegisterModel("models/chunks/rock/rock1_2.md3");
+		dbModels_Rocks[2] = trap_R_RegisterModel("models/chunks/rock/rock1_3.md3");
+		dbModels_Rocks[3] = trap_R_RegisterModel("models/chunks/rock/rock1_4.md3");
+		/*
+		dbModels_Rocks[4] = trap_R_RegisterModel("models/chunks/rock/rock2_1.md3");
+		dbModels_Rocks[5] = trap_R_RegisterModel("models/chunks/rock/rock2_2.md3");
+		dbModels_Rocks[6] = trap_R_RegisterModel("models/chunks/rock/rock2_3.md3");
+		dbModels_Rocks[7] = trap_R_RegisterModel("models/chunks/rock/rock2_4.md3");
+		dbModels_Rocks[8] = trap_R_RegisterModel("models/chunks/rock/rock3_1.md3");
+		dbModels_Rocks[9] = trap_R_RegisterModel("models/chunks/rock/rock3_2.md3");
+		dbModels_Rocks[10] = trap_R_RegisterModel("models/chunks/rock/rock3_3.md3");
+		dbModels_Rocks[11] = trap_R_RegisterModel("models/chunks/rock/rock3_4.md3");
+		*/
+	}
+
+	VectorSubtract(maxs, mins, a);
+
+	windowmass = VectorLength(a); //should give us some idea of how big the chunk of glass is
+
+	while (shardsthrow < windowmass)
+	{
+		velocity[0] = crandom()*150;
+		velocity[1] = crandom()*150;
+		velocity[2] = 150 + crandom()*75;
+
+		if (omodel == DEBRIS_SPECIALCASE_GLASS)
+		{
+			debrismodel = dbModels_Glass[Q_irand(0, NUM_DEBRIS_MODELS_GLASS-1)];
+		}
+		else if (omodel == DEBRIS_SPECIALCASE_WOOD)
+		{
+			debrismodel = dbModels_Wood[Q_irand(0, NUM_DEBRIS_MODELS_WOOD-1)];
+		}
+		else if (omodel == DEBRIS_SPECIALCASE_CHUNKS)
+		{
+			debrismodel = dbModels_Chunks[Q_irand(0, NUM_DEBRIS_MODELS_CHUNKS-1)];
+		}
+		else if (omodel == DEBRIS_SPECIALCASE_ROCK)
+		{
+			debrismodel = dbModels_Rocks[Q_irand(0, NUM_DEBRIS_MODELS_ROCKS-1)];
+		}
+
+		VectorCopy(org, shardorg);
+	
+		dif[0] = (maxs[0]-mins[0])/2;
+		dif[1] = (maxs[1]-mins[1])/2;
+		dif[2] = (maxs[2]-mins[2])/2;
+
+		if (dif[0] < 2)
+		{
+			dif[0] = 2;
+		}
+		if (dif[1] < 2)
+		{
+			dif[1] = 2;
+		}
+		if (dif[2] < 2)
+		{
+			dif[2] = 2;
+		}
+
+		difx[0] = Q_irand(1, (dif[0]*0.9)*2);
+		difx[1] = Q_irand(1, (dif[1]*0.9)*2);
+		difx[2] = Q_irand(1, (dif[2]*0.9)*2);
+
+		if (difx[0] > dif[0])
+		{
+			shardorg[0] += difx[0]-(dif[0]);
+		}
+		else
+		{
+			shardorg[0] -= difx[0];
+		}
+		if (difx[1] > dif[1])
+		{
+			shardorg[1] += difx[1]-(dif[1]);
+		}
+		else
+		{
+			shardorg[1] -= difx[1];
+		}
+		if (difx[2] > dif[2])
+		{
+			shardorg[2] += difx[2]-(dif[2]);
+		}
+		else
+		{
+			shardorg[2] -= difx[2];
+		}
+
+		//CG_TestLine(org, shardorg, 5000, 0x0000ff, 3);
+
+		CG_ThrowChunk( shardorg, velocity, debrismodel, debrissound, 0 );
+
+		shardsthrow += 10;
+	}
+}
+
+//==========================================================
+//SP-style chunks
+//==========================================================
+
+/*
+-------------------------
+CG_ExplosionEffects
+
+Used to find the player and shake the camera if close enough
+intensity ranges from 1 (minor tremble) to 16 (major quake)
+-------------------------
+*/
+
+void CG_ExplosionEffects( vec3_t origin, float intensity, int radius, int time )
+{
+	//FIXME: When exactly is the vieworg calculated in relation to the rest of the frame?s
+
+	vec3_t	dir;
+	float	dist, intensityScale;
+	float	realIntensity;
+
+	VectorSubtract( cg.refdef.vieworg, origin, dir );
+	dist = VectorNormalize( dir );
+
+	//Use the dir to add kick to the explosion
+
+	if ( dist > radius )
+		return;
+
+	intensityScale = 1 - ( dist / (float) radius );
+	realIntensity = intensity * intensityScale;
+
+	CGCam_Shake( realIntensity, time );
+}
+
+/*
+-------------------------
+CG_MiscModelExplosion
+
+Adds an explosion to a misc model breakables
+-------------------------
+*/
+
+void CG_MiscModelExplosion( vec3_t mins, vec3_t maxs, int size, material_t chunkType )
+{
+	int		ct = 13;
+	float	r;
+	vec3_t	org, mid, dir;
+	char	*effect = NULL, *effect2 = NULL;
+	int		eID1, eID2 = 0;
+	int		i;
+
+	VectorAdd( mins, maxs, mid );
+	VectorScale( mid, 0.5f, mid );
+
+	switch( chunkType )
+	{
+	case MAT_GLASS:
+		effect = "chunks/glassbreak";
+		ct = 5;
+		break;
+	case MAT_GLASS_METAL:
+		effect = "chunks/glassbreak";
+		effect2 = "chunks/metalexplode";
+		ct = 5;
+		break;
+	case MAT_ELECTRICAL:
+	case MAT_ELEC_METAL:
+		effect = "chunks/sparkexplode";
+		ct = 5;
+		break;
+	case MAT_METAL:
+	case MAT_METAL2:
+	case MAT_METAL3:
+	case MAT_CRATE1:
+	case MAT_CRATE2:
+		effect = "chunks/metalexplode";
+		ct = 2;
+		break;
+	case MAT_GRATE1:
+		effect = "chunks/grateexplode";
+		ct = 8;
+		break;
+	case MAT_ROPE:
+		ct = 20;
+		effect = "chunks/ropebreak";
+		break;
+	case MAT_WHITE_METAL: //not sure what this crap is really supposed to be..
+	case MAT_DRK_STONE:
+	case MAT_LT_STONE:
+	case MAT_GREY_STONE:
+	case MAT_SNOWY_ROCK:
+		switch( size )
+		{
+		case 2:
+			effect = "chunks/rockbreaklg";
+			break;
+		case 1:
+		default:
+			effect = "chunks/rockbreakmed";
+			break;
+		}
+	}
+
+	if ( !effect )
+	{
+		return;
+	}
+
+	ct += 7 * size;
+
+	// FIXME: real precache .. VERify that these need to be here...don't think they would because the effects should be registered in g_breakable
+	//rww - No they don't.. indexed effects gameside get precached on load clientside, as server objects are setup before client asset load time.
+	//However, we need to index them, so..
+	eID1 = trap_FX_RegisterEffect( effect );
+
+	if ( effect2 && effect2[0] )
+	{
+		// FIXME: real precache
+		eID2 = trap_FX_RegisterEffect( effect2 );
+	}
+
+	// spawn chunk roughly in the bbox of the thing..
+	for ( i = 0; i < ct; i++ )
+	{
+		int j;
+		for( j = 0; j < 3; j++ )
+		{
+			r = random() * 0.8f + 0.1f;
+			org[j] = ( r * mins[j] + ( 1 - r ) * maxs[j] );
+		}
+
+		// shoot effect away from center
+		VectorSubtract( org, mid, dir );
+		VectorNormalize( dir );
+
+		if ( effect2 && effect2[0] && ( rand() & 1 ))
+		{
+			trap_FX_PlayEffectID( eID2, org, dir, -1, -1 );
+		}
+		else
+		{
+			trap_FX_PlayEffectID( eID1, org, dir, -1, -1 );
+		}
+	}
+}
+
+/*
+-------------------------
+CG_Chunks
+
+Fun chunk spewer
+-------------------------
+*/
+
+void CG_Chunks( int owner, vec3_t origin, const vec3_t normal, const vec3_t mins, const vec3_t maxs, 
+						float speed, int numChunks, material_t chunkType, int customChunk, float baseScale )
+{
+	localEntity_t	*le;
+	refEntity_t		*re;
+	vec3_t			dir;
+	int				i, j, k;
+	int				chunkModel = 0;
+	leBounceSoundType_t	bounce = LEBS_NONE;
+	float			r, speedMod = 1.0f;
+	qboolean		chunk = qfalse;
+
+	if ( chunkType == MAT_NONE )
+	{
+		// Well, we should do nothing
+		return;
+	}
+
+	// Set up our chunk sound info...breaking sounds are done here so they are done once on breaking..some return instantly because the chunks are done with effects instead of models
+	switch( chunkType )
+	{
+	case MAT_GLASS:
+		trap_S_StartSound( NULL, owner, CHAN_BODY, cgs.media.glassChunkSound );
+		return;
+		break;
+	case MAT_GRATE1:
+		trap_S_StartSound( NULL, owner, CHAN_BODY, cgs.media.grateSound );
+		return;
+		break;
+	case MAT_ELECTRICAL:// (sparks)
+		trap_S_StartSound( NULL, owner, CHAN_BODY, trap_S_RegisterSound (va("sound/ambience/spark%d.wav", Q_irand(1, 6))) );
+		return;
+		break;
+	case MAT_DRK_STONE:
+	case MAT_LT_STONE:
+	case MAT_GREY_STONE:
+	case MAT_WHITE_METAL:  // not quite sure what this stuff is supposed to be...it's for Stu
+	case MAT_SNOWY_ROCK:
+		trap_S_StartSound( NULL, owner, CHAN_BODY, cgs.media.rockBreakSound );
+		bounce = LEBS_ROCK;
+		speedMod = 0.5f; // rock blows up less
+		break;
+	case MAT_GLASS_METAL:
+		trap_S_StartSound( NULL, owner, CHAN_BODY, cgs.media.glassChunkSound ); // FIXME: should probably have a custom sound
+		bounce = LEBS_METAL;
+		break;
+	case MAT_CRATE1:
+	case MAT_CRATE2:
+		trap_S_StartSound( NULL, owner, CHAN_BODY, cgs.media.crateBreakSound[Q_irand(0,1)] );
+		break;
+	case MAT_METAL:
+	case MAT_METAL2:
+	case MAT_METAL3:
+	case MAT_ELEC_METAL:// FIXME: maybe have its own sound?
+		trap_S_StartSound( NULL, owner, CHAN_BODY, cgs.media.chunkSound );
+		bounce = LEBS_METAL;
+		speedMod = 0.8f; // metal blows up a bit more
+		break;
+	case MAT_ROPE:
+//		trap_S_StartSound( NULL, owner, CHAN_BODY, cgi_S_RegisterSound( "" ));  FIXME:  needs a sound
+		return;
+		break;
+	}
+
+	if ( baseScale <= 0.0f )
+	{
+		baseScale = 1.0f;
+	}
+
+	// Chunks
+	for( i = 0; i < numChunks; i++ )
+	{
+		if ( customChunk > 0 )
+		{
+			// Try to use a custom chunk.
+			if ( cgs.gameModels[customChunk] )
+			{
+				chunk = qtrue;
+				chunkModel = cgs.gameModels[customChunk];
+			}
+		}
+
+		if ( !chunk )
+		{
+			// No custom chunk.  Pick a random chunk type at run-time so we don't get the same chunks
+			switch( chunkType )
+			{
+			case MAT_METAL2: //bluegrey
+				chunkModel = cgs.media.chunkModels[CHUNK_METAL2][Q_irand(0, 3)];
+				break;
+			case MAT_GREY_STONE://gray
+				chunkModel = cgs.media.chunkModels[CHUNK_ROCK1][Q_irand(0, 3)];
+				break;
+			case MAT_LT_STONE: //tan
+				chunkModel = cgs.media.chunkModels[CHUNK_ROCK2][Q_irand(0, 3)];
+				break;
+			case MAT_DRK_STONE://brown
+				chunkModel = cgs.media.chunkModels[CHUNK_ROCK3][Q_irand(0, 3)];
+				break;
+			case MAT_SNOWY_ROCK://gray & brown
+				if ( Q_irand( 0, 1 ) )
+				{
+					chunkModel = cgs.media.chunkModels[CHUNK_ROCK1][Q_irand(0, 3)];
+				}
+				else
+				{
+					chunkModel = cgs.media.chunkModels[CHUNK_ROCK3][Q_irand(0, 3)];
+				}
+				break;
+			case MAT_WHITE_METAL:
+				chunkModel = cgs.media.chunkModels[CHUNK_WHITE_METAL][Q_irand(0, 3)];
+				break;
+			case MAT_CRATE1://yellow multi-colored crate chunks
+				chunkModel = cgs.media.chunkModels[CHUNK_CRATE1][Q_irand(0, 3)];
+				break;
+			case MAT_CRATE2://red multi-colored crate chunks
+				chunkModel = cgs.media.chunkModels[CHUNK_CRATE2][Q_irand(0, 3)];
+				break;
+			case MAT_ELEC_METAL:
+			case MAT_GLASS_METAL:
+			case MAT_METAL://grey
+				chunkModel = cgs.media.chunkModels[CHUNK_METAL1][Q_irand(0, 3)];
+				break;
+			case MAT_METAL3:
+				if ( rand() & 1 )
+				{
+					chunkModel = cgs.media.chunkModels[CHUNK_METAL1][Q_irand(0, 3)];
+				}
+				else
+				{
+					chunkModel = cgs.media.chunkModels[CHUNK_METAL2][Q_irand(0, 3)];
+				}
+				break;
+			}
+		}
+
+		// It wouldn't look good to throw a bunch of RGB axis models...so make sure we have something to work with.
+		if ( chunkModel )
+		{
+			le = CG_AllocLocalEntity();
+			re = &le->refEntity;
+
+			re->hModel = chunkModel;
+			le->leType = LE_FRAGMENT;
+			le->endTime = cg.time + 1300 + random() * 900;
+
+			// spawn chunk roughly in the bbox of the thing...bias towards center in case thing blowing up doesn't complete fill its bbox.
+			for( j = 0; j < 3; j++ )
+			{
+				r = random() * 0.8f + 0.1f;
+				re->origin[j] = ( r * mins[j] + ( 1 - r ) * maxs[j] );
+			}
+			VectorCopy( re->origin, le->pos.trBase );
+
+			// Move out from center of thing, otherwise you can end up things moving across the brush in an undesirable direction.  Visually looks wrong
+			VectorSubtract( re->origin, origin, dir );
+			VectorNormalize( dir );
+			VectorScale( dir, flrand( speed * 0.5f, speed * 1.25f ) * speedMod, le->pos.trDelta );
+
+			// Angular Velocity
+			VectorSet( le->angles.trBase, random() * 360, random() * 360, random() * 360 );
+
+			le->angles.trDelta[0] = crandom();
+			le->angles.trDelta[1] = crandom();
+			le->angles.trDelta[2] = 0; // don't do roll
+
+			VectorScale( le->angles.trDelta, random() * 600.0f + 200.0f, le->angles.trDelta );
+
+			le->pos.trType = TR_GRAVITY;
+			le->angles.trType = TR_LINEAR;
+			le->pos.trTime = le->angles.trTime = cg.time;
+			le->bounceFactor = 0.2f + random() * 0.2f;
+			le->leFlags |= LEF_TUMBLE;
+			//le->ownerGentNum = owner;
+			le->leBounceSoundType = bounce; 
+
+			// Make sure that we have the desired start size set
+			le->radius = flrand( baseScale * 0.75f, baseScale * 1.25f );
+			re->nonNormalizedAxes = qtrue;
+			AxisCopy( axisDefault, re->axis ); // could do an angles to axis, but this is cheaper and works ok
+			for( k = 0; k < 3; k++ )
+			{
+				re->modelScale[k] = le->radius;
+			}
+			ScaleModelAxis(re);
+			/*
+			for( k = 0; k < 3; k++ )
+			{
+				VectorScale( re->axis[k], le->radius, re->axis[k] );
+			}
+			*/
+		}
+	}
+}
+
+/*
+==================
+CG_ScorePlum
+==================
+*/
+void CG_ScorePlum( int client, vec3_t org, int score ) {
+	localEntity_t	*le;
+	refEntity_t		*re;
+	vec3_t			angles;
+	static vec3_t lastPos;
+
+	// only visualize for the client that scored
+	if (client != cg.predictedPlayerState.clientNum || cg_scorePlum.integer == 0) {
+		return;
+	}
+
+	le = CG_AllocLocalEntity();
+	le->leFlags = 0;
+	le->leType = LE_SCOREPLUM;
+	le->startTime = cg.time;
+	le->endTime = cg.time + 4000;
+	le->lifeRate = 1.0 / ( le->endTime - le->startTime );
+
+	
+	le->color[0] = le->color[1] = le->color[2] = le->color[3] = 1.0;
+	le->radius = score;
+	
+	VectorCopy( org, le->pos.trBase );
+	if (org[2] >= lastPos[2] - 20 && org[2] <= lastPos[2] + 20) {
+		le->pos.trBase[2] -= 20;
+	}
+
+	//CG_Printf( "Plum origin %i %i %i -- %i\n", (int)org[0], (int)org[1], (int)org[2], (int)Distance(org, lastPos));
+	VectorCopy(org, lastPos);
+
+
+	re = &le->refEntity;
+
+	re->reType = RT_SPRITE;
+	re->radius = 16;
+
+	VectorClear(angles);
+	AnglesToAxis( angles, re->axis );
+}
+
+/*
+====================
+CG_MakeExplosion
+====================
+*/
+localEntity_t *CG_MakeExplosion( vec3_t origin, vec3_t dir, 
+								qhandle_t hModel, int numFrames, qhandle_t shader,
+								int msec, qboolean isSprite, float scale, int flags )
+{
+	float			ang = 0;
+	localEntity_t	*ex;
+	int				offset;
+	vec3_t			tmpVec, newOrigin;
+
+	if ( msec <= 0 ) {
+		CG_Error( "CG_MakeExplosion: msec = %i", msec );
+	}
+
+	// skew the time a bit so they aren't all in sync
+	offset = rand() & 63;
+
+	ex = CG_AllocLocalEntity();
+	if ( isSprite ) {
+		ex->leType = LE_SPRITE_EXPLOSION; 
+		ex->refEntity.rotation = rand() % 360;
+		ex->radius = scale;
+		VectorScale( dir, 16, tmpVec );
+		VectorAdd( tmpVec, origin, newOrigin );
+	} else {
+		ex->leType = LE_EXPLOSION;
+		VectorCopy( origin, newOrigin );
+
+		// set axis with random rotate when necessary
+		if ( !dir )
+		{
+			AxisClear( ex->refEntity.axis );
+		}
+		else
+		{
+			if ( !(flags & LEF_NO_RANDOM_ROTATE) )
+				ang = rand() % 360;
+			VectorCopy( dir, ex->refEntity.axis[0] );
+			RotateAroundDirection( ex->refEntity.axis, ang );
+		}
+	}
+
+	ex->startTime = cg.time - offset;
+	ex->endTime = ex->startTime + msec;
+	
+	// bias the time so all shader effects start correctly
+	ex->refEntity.shaderTime = ex->startTime / 1000.0f;
+
+	ex->refEntity.hModel = hModel;
+	ex->refEntity.customShader = shader;
+	ex->lifeRate = (float)numFrames / msec;
+	ex->leFlags = flags;
+
+	//Scale the explosion
+	if (scale != 1) {
+		ex->refEntity.nonNormalizedAxes = qtrue;
+
+		VectorScale( ex->refEntity.axis[0], scale, ex->refEntity.axis[0] );
+		VectorScale( ex->refEntity.axis[1], scale, ex->refEntity.axis[1] );
+		VectorScale( ex->refEntity.axis[2], scale, ex->refEntity.axis[2] );
+	}
+	// set origin
+	VectorCopy ( newOrigin, ex->refEntity.origin);
+	VectorCopy ( newOrigin, ex->refEntity.oldorigin );
+
+	ex->color[0] = ex->color[1] = ex->color[2] = 1.0;
+
+	return ex;
+}
+
+
+/*
+-------------------------
+CG_SurfaceExplosion
+
+Adds an explosion to a surface
+-------------------------
+*/
+
+#define NUM_SPARKS		12
+#define NUM_PUFFS		1
+#define NUM_EXPLOSIONS	4
+
+void CG_SurfaceExplosion( vec3_t origin, vec3_t normal, float radius, float shake_speed, qboolean smoke )
+{
+	localEntity_t	*le;
+	//FXTrail			*particle;
+	vec3_t			direction, new_org;
+	vec3_t			velocity		= { 0, 0, 0 };
+	vec3_t			temp_org, temp_vel;
+	float			scale, dscale;
+	int				i, numSparks;
+
+	//Sparks
+	numSparks = 16 + (random() * 16.0f);
+	
+	for ( i = 0; i < numSparks; i++ )
+	{	
+		scale = 0.25f + (random() * 2.0f);
+		dscale = -scale*0.5;
+
+/*		particle = FX_AddTrail( origin,
+								NULL,
+								NULL,
+								32.0f,
+								-64.0f,
+								scale,
+								-scale,
+								1.0f,
+								0.0f,
+								0.25f,
+								4000.0f,
+								cgs.media.sparkShader,
+								rand() & FXF_BOUNCE);
+		if ( particle == NULL )
+			return;
+
+		FXE_Spray( normal, 500, 150, 1.0f, 768 + (rand() & 255), (FXPrimitive *) particle );*/
+	}
+
+	//Smoke
+	//Move this out a little from the impact surface
+	VectorMA( origin, 4, normal, new_org );
+	VectorSet( velocity, 0.0f, 0.0f, 16.0f );
+
+	for ( i = 0; i < 4; i++ )
+	{
+		VectorSet( temp_org, new_org[0] + (crandom() * 16.0f), new_org[1] + (crandom() * 16.0f), new_org[2] + (random() * 4.0f) );
+		VectorSet( temp_vel, velocity[0] + (crandom() * 8.0f), velocity[1] + (crandom() * 8.0f), velocity[2] + (crandom() * 8.0f) );
+
+/*		FX_AddSprite(	temp_org,
+						temp_vel, 
+						NULL, 
+						64.0f + (random() * 32.0f), 
+						16.0f, 
+						1.0f, 
+						0.0f,
+						20.0f + (crandom() * 90.0f),
+						0.5f,
+						1500.0f, 
+						cgs.media.smokeShader, FXF_USE_ALPHA_CHAN );*/
+	}
+
+	//Core of the explosion
+
+	//Orient the explosions to face the camera
+	VectorSubtract( cg.refdef.vieworg, origin, direction );
+	VectorNormalize( direction );
+
+	//Tag the last one with a light
+	le = CG_MakeExplosion( origin, direction, cgs.media.explosionModel, 6, cgs.media.surfaceExplosionShader, 500, qfalse, radius * 0.02f + (random() * 0.3f), 0);
+	le->light = 150;
+	VectorSet( le->lightColor, 0.9f, 0.8f, 0.5f );
+
+	for ( i = 0; i < NUM_EXPLOSIONS-1; i ++)
+	{
+		VectorSet( new_org, (origin[0] + (16 + (crandom() * 8))*crandom()), (origin[1] + (16 + (crandom() * 8))*crandom()), (origin[2] + (16 + (crandom() * 8))*crandom()) );
+		le = CG_MakeExplosion( new_org, direction, cgs.media.explosionModel, 6, cgs.media.surfaceExplosionShader, 300 + (rand() & 99), qfalse, radius * 0.05f + (crandom() *0.3f), 0);
+	}
+
+	//Shake the camera
+	CG_ExplosionEffects( origin, shake_speed, 350, 750 );
+
+	// The level designers wanted to be able to turn the smoke spawners off.  The rationale is that they
+	//	want to blow up catwalks and such that fall down...when that happens, it shouldn't really leave a mark
+	//	and a smoke spewer at the explosion point...
+	if ( smoke )
+	{
+		VectorMA( origin, -8, normal, temp_org );
+//		FX_AddSpawner( temp_org, normal, NULL, NULL, 100, random()*25.0f, 5000.0f, (void *) CG_SmokeSpawn );
+
+		//Impact mark
+		//FIXME: Replace mark
+		//CG_ImpactMark( cgs.media.burnMarkShader, origin, normal, random()*360, 1,1,1,1, qfalse, 8, qfalse );
+	}
+}
+
+/*
+=================
+CG_Bleed
+
+This is the spurt of blood when a character gets hit
+=================
+*/
+void CG_Bleed( vec3_t origin, int entityNum ) {
+	localEntity_t	*ex;
+
+	if ( !cg_blood.integer ) {
+		return;
+	}
+
+	ex = CG_AllocLocalEntity();
+	ex->leType = LE_EXPLOSION;
+
+	ex->startTime = cg.time;
+	ex->endTime = ex->startTime + 500;
+	
+	VectorCopy ( origin, ex->refEntity.origin);
+	ex->refEntity.reType = RT_SPRITE;
+	ex->refEntity.rotation = rand() % 360;
+	ex->refEntity.radius = 24;
+
+	ex->refEntity.customShader = 0;//cgs.media.bloodExplosionShader;
+
+	// don't show player's own blood in view
+	if ( entityNum == cg.snap->ps.clientNum ) {
+		ex->refEntity.renderfx |= RF_THIRD_PERSON;
+	}
+}
+
+
+
+/*
+==================
+CG_LaunchGib
+==================
+*/
+void CG_LaunchGib( vec3_t origin, vec3_t velocity, qhandle_t hModel ) {
+	localEntity_t	*le;
+	refEntity_t		*re;
+
+	le = CG_AllocLocalEntity();
+	re = &le->refEntity;
+
+	le->leType = LE_FRAGMENT;
+	le->startTime = cg.time;
+	le->endTime = le->startTime + 5000 + random() * 3000;
+
+	VectorCopy( origin, re->origin );
+	AxisCopy( axisDefault, re->axis );
+	re->hModel = hModel;
+
+	le->pos.trType = TR_GRAVITY;
+	VectorCopy( origin, le->pos.trBase );
+	VectorCopy( velocity, le->pos.trDelta );
+	le->pos.trTime = cg.time;
+
+	le->bounceFactor = 0.6f;
+
+	le->leBounceSoundType = LEBS_BLOOD;
+	le->leMarkType = LEMT_BLOOD;
+}
diff --git a/codemp/cgame/cg_ents.c b/codemp/cgame/cg_ents.c
new file mode 100644
index 0000000..6ab6049
--- /dev/null
+++ b/codemp/cgame/cg_ents.c
@@ -0,0 +1,3783 @@
+// Copyright (C) 1999-2000 Id Software, Inc.
+//
+// cg_ents.c -- present snapshot entities, happens every single frame
+
+#include "cg_local.h"
+/*
+Ghoul2 Insert Start
+*/
+#include "..\game\q_shared.h"
+#include "..\ghoul2\g2.h"
+/*
+Ghoul2 Insert end
+*/
+
+extern qboolean CG_InFighter( void );
+static void CG_Missile( centity_t *cent );
+
+/*
+======================
+CG_PositionEntityOnTag
+
+Modifies the entities position and axis by the given
+tag location
+======================
+*/
+void CG_PositionEntityOnTag( refEntity_t *entity, const refEntity_t *parent, 
+							qhandle_t parentModel, char *tagName ) {
+	int				i;
+	orientation_t	lerped;
+	
+	// lerp the tag
+	trap_R_LerpTag( &lerped, parentModel, parent->oldframe, parent->frame,
+		1.0 - parent->backlerp, tagName );
+
+	// FIXME: allow origin offsets along tag?
+	VectorCopy( parent->origin, entity->origin );
+	for ( i = 0 ; i < 3 ; i++ ) {
+		VectorMA( entity->origin, lerped.origin[i], parent->axis[i], entity->origin );
+	}
+
+	// had to cast away the const to avoid compiler problems...
+	MatrixMultiply( lerped.axis, ((refEntity_t *)parent)->axis, entity->axis );
+	entity->backlerp = parent->backlerp;
+}
+
+
+/*
+======================
+CG_PositionRotatedEntityOnTag
+
+Modifies the entities position and axis by the given
+tag location
+======================
+*/
+void CG_PositionRotatedEntityOnTag( refEntity_t *entity, const refEntity_t *parent, 
+							qhandle_t parentModel, char *tagName ) {
+	int				i;
+	orientation_t	lerped;
+	vec3_t			tempAxis[3];
+
+//AxisClear( entity->axis );
+	// lerp the tag
+	trap_R_LerpTag( &lerped, parentModel, parent->oldframe, parent->frame,
+		1.0 - parent->backlerp, tagName );
+
+	// FIXME: allow origin offsets along tag?
+	VectorCopy( parent->origin, entity->origin );
+	for ( i = 0 ; i < 3 ; i++ ) {
+		VectorMA( entity->origin, lerped.origin[i], parent->axis[i], entity->origin );
+	}
+
+	// had to cast away the const to avoid compiler problems...
+	MatrixMultiply( entity->axis, lerped.axis, tempAxis );
+	MatrixMultiply( tempAxis, ((refEntity_t *)parent)->axis, entity->axis );
+}
+
+
+
+/*
+==========================================================================
+
+FUNCTIONS CALLED EACH FRAME
+
+==========================================================================
+*/
+
+//only need to use the CG_S_ system when you want a looping sound that isn't going to add itself
+//via trap each frame. Such as ones generated by events.
+/*
+======================
+CG_SetEntitySoundPosition
+
+Also called by event processing code
+======================
+*/
+void CG_SetEntitySoundPosition( centity_t *cent ) {
+	if ( cent->currentState.solid == SOLID_BMODEL )
+	{
+		vec3_t	origin;
+		float	*v;
+
+		v = cgs.inlineModelMidpoints[ cent->currentState.modelindex ];
+		VectorAdd( cent->lerpOrigin, v, origin );
+		trap_S_UpdateEntityPosition( cent->currentState.number, origin );
+	}
+	else
+	{
+		trap_S_UpdateEntityPosition( cent->currentState.number, cent->lerpOrigin );
+	}
+}
+
+/*
+==================
+CG_S_AddLoopingSound
+
+Set the current looping sounds on the entity.
+==================
+*/
+void CG_S_AddLoopingSound(int entityNum, const vec3_t origin, const vec3_t velocity, sfxHandle_t sfx)
+{
+	centity_t *cent = &cg_entities[entityNum];
+	cgLoopSound_t *cSound = NULL;
+	int i = 0;
+	qboolean alreadyPlaying = qfalse;
+
+	//first see if we're already looping this sound handle.
+	while (i < cent->numLoopingSounds)
+	{
+		cSound = &cent->loopingSound[i];
+
+		if (cSound->sfx == sfx)
+		{
+			alreadyPlaying = qtrue;
+			break;
+		}
+	}
+	
+	if (alreadyPlaying && cSound)
+	{ //if this is the case, just update the properties of the looping sound and return.
+		VectorCopy(origin, cSound->origin);
+		VectorCopy(velocity, cSound->velocity);
+	}
+	else if (cent->numLoopingSounds >= MAX_CG_LOOPSOUNDS)
+	{ //Just don't add it then I suppose.
+#ifdef _XBOX	// We decreased this number, so I'd like to know if it gets overflowed
+		Com_Printf( S_COLOR_YELLOW "Warning: MAX_CG_LOOPSOUNDS exceeded!!\n" );
+#endif
+		return;
+	}
+
+	//Add a new looping sound.
+	cSound = &cent->loopingSound[cent->numLoopingSounds];
+
+	cSound->entityNum = entityNum;
+	VectorCopy(origin, cSound->origin);
+	VectorCopy(velocity, cSound->velocity);
+	cSound->sfx = sfx;
+
+	cent->numLoopingSounds++;
+}
+
+/*
+==================
+CG_S_AddLoopingSound
+
+For now just redirect, might eventually do something different.
+==================
+*/
+void CG_S_AddRealLoopingSound(int entityNum, const vec3_t origin, const vec3_t velocity, sfxHandle_t sfx)
+{
+	CG_S_AddLoopingSound(entityNum, origin, velocity, sfx);
+}
+
+/*
+==================
+CG_S_AddLoopingSound
+
+Clear looping sounds.
+==================
+*/
+void CG_S_StopLoopingSound(int entityNum, sfxHandle_t sfx)
+{
+	centity_t *cent = &cg_entities[entityNum];
+	cgLoopSound_t *cSound;
+
+	if (sfx == -1)
+	{ //clear all the looping sounds on the entity
+		cent->numLoopingSounds = 0;
+	}
+	else
+	{ //otherwise, clear only the specified looping sound
+		int i = 0;
+
+		while (i < cent->numLoopingSounds)
+		{
+			cSound = &cent->loopingSound[i];
+
+			if (cSound->sfx == sfx)
+			{ //remove it then
+				int x = i+1;
+
+				while (x < cent->numLoopingSounds)
+				{
+					memcpy(&cent->loopingSound[x-1], &cent->loopingSound[x], sizeof(cent->loopingSound[x]));
+					x++;
+				}
+				cent->numLoopingSounds--;
+			}
+
+			i++;
+		}
+	}
+	//trap_S_StopLoopingSound(entityNum);
+}
+
+/*
+==================
+CG_S_UpdateLoopingSounds
+
+Update any existing looping sounds on the entity.
+==================
+*/
+void CG_S_UpdateLoopingSounds(int entityNum)
+{
+	centity_t *cent = &cg_entities[entityNum];
+	cgLoopSound_t *cSound;
+	vec3_t lerpOrg;
+	float *v;
+	int i = 0;
+
+	if (!cent->numLoopingSounds)
+	{
+		return;
+	}
+
+	if (cent->currentState.eType == ET_MOVER)
+	{
+		v = cgs.inlineModelMidpoints[ cent->currentState.modelindex ];
+		VectorAdd( cent->lerpOrigin, v, lerpOrg );
+	}
+	else
+	{
+		VectorCopy(cent->lerpOrigin, lerpOrg);
+	}
+
+	while (i < cent->numLoopingSounds)
+	{
+		cSound = &cent->loopingSound[i];
+
+		//trap_S_AddLoopingSound(entityNum, cSound->origin, cSound->velocity, cSound->sfx);
+		//I guess just keep using lerpOrigin for now,
+		trap_S_AddLoopingSound(entityNum, lerpOrg, cSound->velocity, cSound->sfx);
+		i++;
+	}
+}
+
+/*
+==================
+CG_EntityEffects
+
+Add continuous entity effects, like local entity emission and lighting
+==================
+*/
+static void CG_EntityEffects( centity_t *cent ) {
+
+	// update sound origins
+	CG_SetEntitySoundPosition( cent );
+
+	// add loop sound
+	if ( cent->currentState.loopSound || (cent->currentState.loopIsSoundset && cent->currentState.number >= MAX_CLIENTS) ) {
+		sfxHandle_t realSoundIndex = -1;
+			
+		if (cent->currentState.loopIsSoundset && cent->currentState.number >= MAX_CLIENTS)
+		{ //If this is so, then first get our soundset from the index, and loopSound actually contains which part of the set to
+		  //use rather than a sound index (BMS_START [0], BMS_MID [1], or BMS_END [2]). Typically loop sounds will be BMS_MID.
+			const char *soundSet;
+			
+			soundSet = CG_ConfigString( CS_AMBIENT_SET + cent->currentState.soundSetIndex );
+
+			if (soundSet && soundSet[0])
+			{
+				realSoundIndex = trap_AS_GetBModelSound(soundSet, cent->currentState.loopSound);
+			}
+		}
+		else
+		{
+			realSoundIndex = cgs.gameSounds[ cent->currentState.loopSound ];
+		}
+
+		//rww - doors and things with looping sounds have a crazy origin (being brush models and all)
+		if (realSoundIndex != -1)
+		{
+			if ( cent->currentState.solid == SOLID_BMODEL )
+			{
+				vec3_t	origin;
+				float	*v;
+
+				v = cgs.inlineModelMidpoints[ cent->currentState.modelindex ];
+				VectorAdd( cent->lerpOrigin, v, origin );
+				trap_S_AddLoopingSound( cent->currentState.number, origin, vec3_origin, 
+					realSoundIndex );
+			}
+			else if (cent->currentState.eType != ET_SPEAKER) {
+				trap_S_AddLoopingSound( cent->currentState.number, cent->lerpOrigin, vec3_origin, 
+					realSoundIndex );
+			} else {
+				trap_S_AddRealLoopingSound( cent->currentState.number, cent->lerpOrigin, vec3_origin, 
+					realSoundIndex );
+			}
+		}
+	}
+
+
+	// constant light glow
+	if ( cent->currentState.constantLight ) {
+		int		cl;
+		int		i, r, g, b;
+
+		cl = cent->currentState.constantLight;
+		r = cl & 255;
+		g = ( cl >> 8 ) & 255;
+		b = ( cl >> 16 ) & 255;
+		i = ( ( cl >> 24 ) & 255 ) * 4;
+		trap_R_AddLightToScene( cent->lerpOrigin, i, r, g, b );
+	}
+
+}
+
+localEntity_t *FX_AddOrientedLine(vec3_t start, vec3_t end, vec3_t normal, float stScale, float scale,
+								  float dscale, float startalpha, float endalpha, float killTime, qhandle_t shader)
+{
+	localEntity_t	*le;
+	
+#ifdef _DEBUG
+	if (!shader)
+	{
+		Com_Printf("FX_AddLine: NULL shader\n");
+	}
+#endif
+
+	le = CG_AllocLocalEntity();
+	le->leType = LE_OLINE;
+
+	le->startTime = cg.time;
+	le->endTime = le->startTime + killTime;
+	le->data.line.width = scale;
+	le->data.line.dwidth = dscale;
+
+	le->alpha = startalpha;
+	le->dalpha = endalpha - startalpha;
+
+	le->refEntity.data.line.stscale = stScale;
+	le->refEntity.data.line.width = scale;
+
+	le->refEntity.customShader = shader;
+
+	// set origin
+	VectorCopy ( start, le->refEntity.origin);
+	VectorCopy ( end, le->refEntity.oldorigin );
+
+	AxisClear(le->refEntity.axis);
+	VectorCopy( normal, le->refEntity.axis[0] );
+	RotateAroundDirection( le->refEntity.axis, 0); // le->refEntity.data.sprite.rotation );	This is roll in quad land
+
+	le->refEntity.shaderRGBA[0] = 0xff;
+	le->refEntity.shaderRGBA[1] = 0xff;
+	le->refEntity.shaderRGBA[2] = 0xff;
+	le->refEntity.shaderRGBA[3] = 0xff;
+
+	le->color[0] = 1.0;
+	le->color[1] = 1.0;
+	le->color[2] = 1.0;
+	le->color[3] = 1.0;
+	le->lifeRate = 1.0 / ( le->endTime - le->startTime );
+
+	return(le);
+}
+
+void FX_DrawPortableShield(centity_t *cent)
+{
+	//rww - this code differs a bit from the draw code in EF, I don't know why I had to do
+	//it this way yet it worked in EF the other way.
+
+	int				xaxis, height, posWidth, negWidth, team;
+	vec3_t			start, end, normal;
+	localEntity_t	*le;
+	qhandle_t		shader;
+	char			buf[1024];
+
+	trap_Cvar_VariableStringBuffer("cl_paused", buf, sizeof(buf));
+
+	if (atoi(buf))
+	{ //rww - fix to keep from rendering repeatedly while HUD menu is up
+		return;
+	}
+
+	if (cent->currentState.eFlags & EF_NODRAW)
+	{
+		return;
+	}
+
+	// decode the data stored in time2
+	xaxis = ((cent->currentState.time2 >> 24) & 1);
+	height = ((cent->currentState.time2 >> 16) & 255);
+	posWidth = ((cent->currentState.time2 >> 8) & 255);
+	negWidth = (cent->currentState.time2 & 255);
+
+	team = (cent->currentState.otherEntityNum2);
+
+	VectorClear(normal);
+
+	VectorCopy(cent->lerpOrigin, start);
+	VectorCopy(cent->lerpOrigin, end);
+
+	if (xaxis) // drawing along x-axis
+	{
+		start[0] -= negWidth;
+		end[0] += posWidth;
+	}
+	else
+	{
+		start[1] -= negWidth;
+		end[1] += posWidth;
+	}
+
+	normal[0] = 1;
+	normal[1] = 1;
+
+	start[2] += height/2;
+	end[2] += height/2;
+
+	if (team == TEAM_RED)
+	{
+		if (cent->currentState.trickedentindex)
+		{
+			shader = trap_R_RegisterShader( "gfx/misc/red_dmgshield" );
+		}
+		else
+		{
+			shader = trap_R_RegisterShader( "gfx/misc/red_portashield" );
+		}
+	}
+	else
+	{
+		if (cent->currentState.trickedentindex)
+		{
+			shader = trap_R_RegisterShader( "gfx/misc/blue_dmgshield" );
+		}
+		else
+		{
+			shader = trap_R_RegisterShader( "gfx/misc/blue_portashield" );
+		}
+	}
+
+	le = FX_AddOrientedLine(start, end, normal, 1.0f, height, 0.0f, 1.0f, 1.0f, 50.0, shader);
+}
+
+/*
+==================
+CG_Special
+==================
+*/
+void CG_Special( centity_t *cent ) {
+	entityState_t		*s1;
+
+	s1 = &cent->currentState;
+
+	if (!s1)
+	{
+		return;
+	}
+
+	// if set to invisible, skip
+	if (!s1->modelindex) {
+		return;
+	}
+
+	if (s1->modelindex == HI_SHIELD) 
+	{	// The portable shield should go through a different rendering function.
+		FX_DrawPortableShield(cent);
+		return;
+	}
+}
+
+/*
+Ghoul2 Insert Start
+*/
+
+// Copy the ghoul2 data into the ref ent correctly
+void CG_SetGhoul2Info( refEntity_t *ent, centity_t *cent)
+{
+
+	ent->ghoul2 = cent->ghoul2;
+	VectorCopy( cent->modelScale, ent->modelScale);
+	ent->radius = cent->radius;
+	VectorCopy (cent->lerpAngles, ent->angles);
+}
+
+
+
+// create 8 new points on screen around a model so we can see it's bounding box
+void CG_CreateBBRefEnts(entityState_t *s1, vec3_t origin )
+{
+/* 
+//g2r
+#if _DEBUG
+	refEntity_t		point[8];
+	int				i;
+	vec3_t			angles = {0,0,0};
+
+	for (i=0; i<8; i++)
+	{
+		memset (&point[i], 0, sizeof(refEntity_t));
+		point[i].reType = RT_SPRITE;
+		point[i].radius = 1;
+		point[i].customShader = trap_R_RegisterShader("textures/tests/circle");
+		point[i].shaderRGBA[0] = 255;
+		point[i].shaderRGBA[1] = 255;
+		point[i].shaderRGBA[2] = 255;
+		point[i].shaderRGBA[3] = 255;
+
+		AnglesToAxis( angles, point[i].axis );
+
+		// now, we need to put the correct origins into each origin from the mins and max's
+		switch(i)
+		{
+		case 0:
+			VectorCopy(s1->mins, point[i].origin);
+   			break;
+		case 1:
+			VectorCopy(s1->mins, point[i].origin);
+			point[i].origin[0] = s1->maxs[0];
+   			break;
+		case 2:
+			VectorCopy(s1->mins, point[i].origin);
+			point[i].origin[1] = s1->maxs[1];
+   			break;
+		case 3:
+			VectorCopy(s1->mins, point[i].origin);
+			point[i].origin[0] = s1->maxs[0];
+			point[i].origin[1] = s1->maxs[1];
+   			break;
+		case 4:
+			VectorCopy(s1->maxs, point[i].origin);
+   			break;
+		case 5:
+			VectorCopy(s1->maxs, point[i].origin);
+			point[i].origin[0] = s1->mins[0];
+   			break;
+		case 6:
+			VectorCopy(s1->maxs, point[i].origin);
+			point[i].origin[1] = s1->mins[1];
+   			break;
+		case 7:
+			VectorCopy(s1->maxs, point[i].origin);
+			point[i].origin[0] = s1->mins[0];
+			point[i].origin[1] = s1->mins[1];
+   			break;
+		}
+
+		// add the original origin to each point and then stuff them out there
+		VectorAdd(point[i].origin, origin, point[i].origin);
+
+		trap_R_AddRefEntityToScene (&point[i]);
+	}
+#endif
+	*/
+}
+
+// write in the axis and stuff
+void G2_BoltToGhoul2Model(centity_t *cent, refEntity_t *ent)
+{
+		// extract the wraith ID from the bolt info
+	int modelNum = cent->boltInfo >> MODEL_SHIFT;
+	int boltNum	= cent->boltInfo >> BOLT_SHIFT;
+	int	entNum = cent->boltInfo >> ENTITY_SHIFT;
+ 	mdxaBone_t 		boltMatrix;
+	
+	modelNum &= MODEL_AND;
+	boltNum &= BOLT_AND;
+	entNum &= ENTITY_AND;
+
+
+	//NOTENOTE I put this here because the cgs.gamemodels array no longer gets initialized.
+	assert(0);		
+
+
+ 	// go away and get me the bolt position for this frame please
+	trap_G2API_GetBoltMatrix(cent->ghoul2, modelNum, boltNum, &boltMatrix, cg_entities[entNum].currentState.angles, cg_entities[entNum].currentState.origin, cg.time, cgs.gameModels, cent->modelScale);
+
+	// set up the axis and origin we need for the actual effect spawning
+ 	ent->origin[0] = boltMatrix.matrix[0][3];
+ 	ent->origin[1] = boltMatrix.matrix[1][3];
+ 	ent->origin[2] = boltMatrix.matrix[2][3];
+
+ 	ent->axis[0][0] = boltMatrix.matrix[0][0];
+ 	ent->axis[0][1] = boltMatrix.matrix[1][0];
+ 	ent->axis[0][2] = boltMatrix.matrix[2][0];
+
+ 	ent->axis[1][0] = boltMatrix.matrix[0][1];
+ 	ent->axis[1][1] = boltMatrix.matrix[1][1];
+ 	ent->axis[1][2] = boltMatrix.matrix[2][1];
+
+ 	ent->axis[2][0] = boltMatrix.matrix[0][2];
+ 	ent->axis[2][1] = boltMatrix.matrix[1][2];
+ 	ent->axis[2][2] = boltMatrix.matrix[2][2];
+}
+
+void ScaleModelAxis(refEntity_t	*ent)
+
+{		// scale the model should we need to
+		if (ent->modelScale[0] && ent->modelScale[0] != 1.0f)
+		{
+			VectorScale( ent->axis[0], ent->modelScale[0] , ent->axis[0] );
+			ent->nonNormalizedAxes = qtrue;
+		}
+		if (ent->modelScale[1] && ent->modelScale[1] != 1.0f)
+		{
+			VectorScale( ent->axis[1], ent->modelScale[1] , ent->axis[1] );
+			ent->nonNormalizedAxes = qtrue;
+		}
+		if (ent->modelScale[2] && ent->modelScale[2] != 1.0f)
+		{
+			VectorScale( ent->axis[2], ent->modelScale[2] , ent->axis[2] );
+			ent->nonNormalizedAxes = qtrue;
+		}
+}
+/*
+Ghoul2 Insert End
+*/
+
+char *forceHolocronModels[] = {
+	"models/map_objects/mp/lt_heal.md3",		//FP_HEAL,
+	"models/map_objects/mp/force_jump.md3",		//FP_LEVITATION,
+	"models/map_objects/mp/force_speed.md3",	//FP_SPEED,
+	"models/map_objects/mp/force_push.md3",		//FP_PUSH,
+	"models/map_objects/mp/force_pull.md3",		//FP_PULL,
+	"models/map_objects/mp/lt_telepathy.md3",	//FP_TELEPATHY,
+	"models/map_objects/mp/dk_grip.md3",		//FP_GRIP,
+	"models/map_objects/mp/dk_lightning.md3",	//FP_LIGHTNING,
+	"models/map_objects/mp/dk_rage.md3",		//FP_RAGE,
+	"models/map_objects/mp/lt_protect.md3",		//FP_PROTECT,
+	"models/map_objects/mp/lt_absorb.md3",		//FP_ABSORB,
+	"models/map_objects/mp/lt_healother.md3",	//FP_TEAM_HEAL,
+	"models/map_objects/mp/dk_powerother.md3",	//FP_TEAM_FORCE,
+	"models/map_objects/mp/dk_drain.md3",		//FP_DRAIN,
+	"models/map_objects/mp/force_sight.md3",	//FP_SEE,
+	"models/map_objects/mp/saber_attack.md3",	//FP_SABER_OFFENSE,
+	"models/map_objects/mp/saber_defend.md3",	//FP_SABER_DEFENSE,
+	"models/map_objects/mp/saber_throw.md3"		//FP_SABERTHROW
+};
+
+void CG_Disintegration(centity_t *cent, refEntity_t *ent)
+{
+	vec3_t tempAng, hitLoc;
+	float tempLength;
+
+	VectorCopy(cent->currentState.origin2, hitLoc);
+
+	VectorSubtract( hitLoc, ent->origin, ent->oldorigin );
+	
+	tempLength = VectorNormalize( ent->oldorigin );
+	vectoangles( ent->oldorigin, tempAng );
+	tempAng[YAW] -= cent->lerpAngles[YAW];
+	AngleVectors( tempAng, ent->oldorigin, NULL, NULL );
+	VectorScale( ent->oldorigin, tempLength, ent->oldorigin );
+
+	ent->endTime = cent->dustTrailTime;
+
+	ent->renderfx |= RF_DISINTEGRATE2;
+	ent->customShader = cgs.media.disruptorShader;
+	trap_R_AddRefEntityToScene( ent );
+
+	ent->renderfx &= ~(RF_DISINTEGRATE2);
+	ent->renderfx |= (RF_DISINTEGRATE1);
+	ent->customShader = 0;
+	trap_R_AddRefEntityToScene( ent );
+
+	if ( cg.time - ent->endTime < 1000 && (cg_timescale.value * cg_timescale.value * random()) > 0.05f )
+	{
+		vec3_t fxOrg, fxDir;
+		mdxaBone_t	boltMatrix;
+		int torsoBolt = trap_G2API_AddBolt(cent->ghoul2, 0, "lower_lumbar");
+
+		VectorSet(fxDir, 0, 1, 0);
+
+		trap_G2API_GetBoltMatrix( cent->ghoul2, 0, torsoBolt, &boltMatrix, cent->lerpAngles, cent->lerpOrigin, cg.time, 
+				cgs.gameModels, cent->modelScale);
+				BG_GiveMeVectorFromMatrix( &boltMatrix, ORIGIN, fxOrg );
+
+		VectorMA( fxOrg, -18, cg.refdef.viewaxis[0], fxOrg );
+		fxOrg[2] += crandom() * 20;
+		trap_FX_PlayEffectID( cgs.effects.mDisruptorDeathSmoke, fxOrg, fxDir, -1, -1 );
+
+		if ( random() > 0.5f )
+		{
+			trap_FX_PlayEffectID( cgs.effects.mDisruptorDeathSmoke, fxOrg, fxDir, -1, -1 );
+		}
+	}
+}
+
+extern int cgSiegeEntityRender;
+static qboolean CG_RenderTimeEntBolt(centity_t *cent)
+{
+	int clientNum = cent->currentState.boltToPlayer-1;
+	centity_t *cl;
+	mdxaBone_t matrix;
+	vec3_t boltOrg, boltAng;
+	int getBolt = -1;
+
+	if (clientNum >= MAX_CLIENTS || clientNum < 0)
+	{
+		assert(0);
+		return qfalse;
+	}
+
+	cl = &cg_entities[clientNum];
+
+	if (!cl->ghoul2)
+	{
+		assert(0);
+		return qfalse;
+	}
+
+	if (clientNum == cg.predictedPlayerState.clientNum &&
+		!cg.renderingThirdPerson)
+	{ //If in first person and you have it then render the thing spinning around on your hud.
+		cgSiegeEntityRender = cent->currentState.number; //set it to render at the end of the frame.
+		return qfalse;
+	}
+
+	getBolt = trap_G2API_AddBolt(cl->ghoul2, 0, "lhand");
+
+	trap_G2API_GetBoltMatrix(cl->ghoul2, 0, getBolt, &matrix, cl->turAngles, cl->lerpOrigin, cg.time, cgs.gameModels, cl->modelScale);
+
+	BG_GiveMeVectorFromMatrix(&matrix, ORIGIN, boltOrg);
+	BG_GiveMeVectorFromMatrix(&matrix, NEGATIVE_Y, boltAng);
+	vectoangles(boltAng, boltAng);
+	boltAng[PITCH] = boltAng[ROLL] = 0;
+
+	VectorCopy(boltOrg, cent->lerpOrigin);
+	VectorCopy(boltAng, cent->lerpAngles);
+
+	return qtrue;
+}
+
+/*
+static void CG_SiegeEntRenderAboveHead(centity_t *cent)
+{
+	int clientNum = cent->currentState.boltToPlayer-1;
+	centity_t *cl;
+	refEntity_t ent;
+	vec3_t renderAngles;
+
+	if (clientNum >= MAX_CLIENTS || clientNum < 0)
+	{
+		assert(0);
+		return;
+	}
+
+	cl = &cg_entities[clientNum];
+
+	memset(&ent, 0, sizeof(ent));
+
+	//Set the angles to the global auto rotating ones, and the origin to slightly above the client
+	VectorCopy(cg.autoAngles, renderAngles);
+	AnglesToAxis( renderAngles, ent.axis );
+	VectorCopy(cl->lerpOrigin, ent.origin);
+	ent.origin[2] += 50;
+
+	//Set the model (ghoul2 or md3/other)
+	if (cent->ghoul2)
+	{
+		ent.ghoul2 = cent->ghoul2;
+		ent.hModel = 0;
+	}
+	else
+	{
+		ent.ghoul2 = NULL;
+		ent.hModel = cgs.gameModels[cent->currentState.modelindex];
+	}
+
+	//Scale it up
+	ent.modelScale[0] = 1.5f;
+	ent.modelScale[1] = 1.5f;
+	ent.modelScale[2] = 1.5f;
+	ScaleModelAxis(&ent);
+
+	//Make it transparent
+	ent.renderfx = RF_FORCE_ENT_ALPHA;
+	ent.shaderRGBA[0] = ent.shaderRGBA[1] = ent.shaderRGBA[2] = 255;
+	ent.shaderRGBA[3] = 100;
+
+	//And finally add it
+	trap_R_AddRefEntityToScene(&ent);
+}
+*/
+
+void CG_AddRadarEnt(centity_t *cent) 
+{
+	if (cg.radarEntityCount == sizeof(cg.radarEntities)/sizeof(cg.radarEntities[0]))
+	{	
+#ifdef _DEBUG
+		Com_Printf("^3Warning: CG_AddRadarEnt full. (%d max)\n", sizeof(cg.radarEntities)/sizeof(cg.radarEntities[0]));
+#endif
+		return;
+	}
+	cg.radarEntities[cg.radarEntityCount++] = cent->currentState.number;
+}
+
+void CG_AddBracketedEnt(centity_t *cent) 
+{
+	if (cg.bracketedEntityCount == sizeof(cg.bracketedEntities)/sizeof(cg.bracketedEntities[0]))
+	{	
+#ifdef _DEBUG
+		Com_Printf("^3Warning: CG_AddBracketedEnt full. (%d max)\n", sizeof(cg.radarEntities)/sizeof(cg.bracketedEntities[0]));
+#endif
+		return;
+	}
+	cg.bracketedEntities[cg.bracketedEntityCount++] = cent->currentState.number;
+}
+/*
+==================
+CG_General
+==================
+*/
+void CG_G2ServerBoneAngles(centity_t *cent);
+
+#include "../namespace_begin.h"
+extern qboolean BG_GetRootSurfNameWithVariant( void *ghoul2, const char *rootSurfName, char *returnSurfName, int returnSize );
+#include "../namespace_end.h"
+
+static void CG_General( centity_t *cent ) {
+	refEntity_t			ent;
+	entityState_t		*s1;
+	float				val;
+	int					beamID;
+	vec3_t				beamOrg;
+	mdxaBone_t			matrix;
+	qboolean			doNotSetModel = qfalse;
+
+	if (cent->currentState.modelGhoul2 == 127)
+	{ //not ready to be drawn or initialized..
+		return;
+	}
+
+	if (cent->ghoul2 && !cent->currentState.modelGhoul2 && cent->currentState.eType != ET_BODY &&
+		cent->currentState.number >= MAX_CLIENTS)
+	{ //this is a bad thing
+		if (trap_G2_HaveWeGhoul2Models(cent->ghoul2))
+		{
+			trap_G2API_CleanGhoul2Models(&(cent->ghoul2));
+		}
+	}
+	
+	if (cent->currentState.eFlags & EF_RADAROBJECT)
+	{
+		CG_AddRadarEnt(cent);
+	}
+	if (cent->currentState.eFlags2 & EF2_BRACKET_ENTITY)
+	{
+		if ( CG_InFighter() )
+		{//only bracken when in a fighter
+			CG_AddBracketedEnt(cent);
+		}
+	}
+	
+	if (cent->currentState.boltToPlayer)
+	{ //Shove it into the player's left hand then.
+		centity_t *pl = &cg_entities[cent->currentState.boltToPlayer-1];
+		if (CG_IsMindTricked(pl->currentState.trickedentindex,
+			pl->currentState.trickedentindex2,
+			pl->currentState.trickedentindex3,
+			pl->currentState.trickedentindex4,
+			cg.predictedPlayerState.clientNum))
+		{ //don't show if this guy is mindtricking
+            return;
+		}
+		if (!CG_RenderTimeEntBolt(cent))
+		{ //If this function returns qfalse we shouldn't render this ent at all.
+			if (cent->currentState.boltToPlayer > 0 &&
+				cent->currentState.boltToPlayer <= MAX_CLIENTS)
+			{
+				VectorCopy(pl->lerpOrigin, cent->lerpOrigin);
+
+				if (cent->currentState.eFlags & EF_CLIENTSMOOTH)
+				{ //if it's set to smooth keep the smoothed lerp origin updated, as we don't want to smooth while bolted.
+					VectorCopy(cent->lerpOrigin, cent->turAngles);
+				}
+			}
+			return;
+		}
+
+		if (cent->currentState.eFlags & EF_CLIENTSMOOTH)
+		{ //if it's set to smooth keep the smoothed lerp origin updated, as we don't want to smooth while bolted.
+			VectorCopy(cent->lerpOrigin, cent->turAngles);
+		}
+
+/* disabled for now
+		if (pl->currentState.number != cg.predictedPlayerState.clientNum)
+		{ //don't render thing above head to self
+			CG_SiegeEntRenderAboveHead(cent);
+		}
+*/
+	}
+	else if (cent->currentState.eFlags & EF_CLIENTSMOOTH)
+	{
+		if (cent->currentState.groundEntityNum >= ENTITYNUM_WORLD)
+		{
+			float smoothFactor = 0.5f*cg_timescale.value;
+			int k = 0;
+			vec3_t posDif;
+
+			//Use origin smoothing since dismembered limbs use ExPhys
+			if (DistanceSquared(cent->turAngles,cent->lerpOrigin)>18000.0f)
+			{
+				VectorCopy(cent->lerpOrigin, cent->turAngles);
+			}
+
+			VectorSubtract(cent->lerpOrigin, cent->turAngles, posDif);
+			
+			for (k=0;k<3;k++)
+			{
+				cent->turAngles[k]=(cent->turAngles[k]+posDif[k]*smoothFactor);
+				cent->lerpOrigin[k]=cent->turAngles[k];
+			}
+		}
+		else
+		{ //if we're sitting on an entity like a moving plat then we don't want to smooth either
+			VectorCopy(cent->lerpOrigin, cent->turAngles);
+		}
+	}
+
+	//rww - now do ragdoll stuff
+	if (cent->ghoul2 &&
+		(cent->currentState.eType == ET_BODY || (cent->currentState.eFlags & EF_RAG)))
+	{
+		if (!(cent->currentState.eFlags & EF_NODRAW) &&
+			!(cent->currentState.eFlags & EF_DISINTEGRATION) &&
+			cent->bodyFadeTime <= cg.time)
+		{
+			vec3_t forcedAngles;
+
+			VectorClear(forcedAngles);
+			forcedAngles[YAW] = cent->lerpAngles[YAW];
+
+			CG_RagDoll(cent, forcedAngles);
+		}
+	}
+	else if (cent->isRagging)
+	{
+		cent->isRagging = qfalse;
+
+		if (cent->ghoul2 && trap_G2_HaveWeGhoul2Models(cent->ghoul2))
+		{ //May not be valid, in the case of a ragged entity being removed and a non-g2 ent filling its slot.
+			trap_G2API_SetRagDoll(cent->ghoul2, NULL); //calling with null parms resets to no ragdoll.
+		}
+	}
+
+	if (cent->currentState.boneOrient && cent->ghoul2)
+	{ //server sent us some bone angles to use
+		CG_G2ServerBoneAngles(cent);
+	}
+
+	if ((cent->currentState.eFlags & EF_G2ANIMATING) && cent->ghoul2)
+	{ //mini-animation routine for general objects that want to play quick ghoul2 anims
+		//obviously lacks much of the functionality contained in player/npc animation.
+		//we actually use torsoAnim as the start frame and legsAnim as the end frame and
+		//always play the anim on the root bone.
+		if (cent->currentState.torsoAnim != cent->pe.torso.animationNumber ||
+			cent->currentState.legsAnim != cent->pe.legs.animationNumber ||
+			cent->currentState.torsoFlip != cent->pe.torso.lastFlip)
+		{
+			trap_G2API_SetBoneAnim(cent->ghoul2, 0, "model_root", cent->currentState.torsoAnim,
+				cent->currentState.legsAnim, (BONE_ANIM_OVERRIDE_FREEZE|BONE_ANIM_BLEND), 1.0f, cg.time, -1, 100);
+
+			cent->pe.torso.animationNumber = cent->currentState.torsoAnim;
+			cent->pe.legs.animationNumber = cent->currentState.legsAnim;
+			cent->pe.torso.lastFlip = cent->currentState.torsoFlip;
+		}
+	}
+
+	memset (&ent, 0, sizeof(ent));
+
+	ent.shaderRGBA[0] = cent->currentState.customRGBA[0];
+	ent.shaderRGBA[1] = cent->currentState.customRGBA[1];
+	ent.shaderRGBA[2] = cent->currentState.customRGBA[2];
+	ent.shaderRGBA[3] = cent->currentState.customRGBA[3];
+
+	if (cent->currentState.modelGhoul2 >= G2_MODELPART_HEAD &&
+		cent->currentState.modelGhoul2 <= G2_MODELPART_RLEG &&
+		/*cent->currentState.modelindex < MAX_CLIENTS &&*/
+		cent->currentState.weapon == G2_MODEL_PART)
+	{ //special case for client limbs
+		centity_t *clEnt;
+		int dismember_settings = cg_dismember.integer;
+		float smoothFactor = 0.5f*cg_timescale.value;
+		int k = 0;
+		vec3_t posDif;
+		
+		doNotSetModel = qtrue;
+
+		if (cent->currentState.modelindex >= 0)
+		{
+			clEnt = &cg_entities[cent->currentState.modelindex];
+		}
+		else
+		{
+			clEnt = &cg_entities[cent->currentState.otherEntityNum2];
+		}
+
+		if (!dismember_settings)
+		{ //This client does not wish to see dismemberment.
+			return;
+		}
+
+		if (dismember_settings < 2 && (cent->currentState.modelGhoul2 == G2_MODELPART_HEAD || cent->currentState.modelGhoul2 == G2_MODELPART_WAIST))
+		{ //dismember settings are not high enough to display decaps and torso slashes
+			return;
+		}
+
+		if (!cent->ghoul2)
+		{
+			const char *limbBone;
+			const char *rotateBone;
+			char	limbName[MAX_QPATH];
+			char	stubName[MAX_QPATH];
+			char	limbCapName[MAX_QPATH];
+			char	stubCapName[MAX_QPATH];
+			char *limbTagName;
+			char *stubTagName;
+			int limb_anim;
+			int newBolt;
+			int limbBit = (1 << (cent->currentState.modelGhoul2-10));
+
+			if (clEnt && (clEnt->torsoBolt & limbBit))
+			{ //already have this limb missing!
+				return;
+			}
+
+
+			if (clEnt && !(clEnt->currentState.eFlags & EF_DEAD))
+			{ //death flag hasn't made it through yet for the limb owner, we cannot create the limb until he's flagged as dead
+				return;
+			}
+
+			if (clEnt && (!BG_InDeathAnim(clEnt->currentState.torsoAnim) || !BG_InDeathAnim(clEnt->pe.torso.animationNumber)))
+			{ //don't make it unless we're in an actual death anim already
+				if (clEnt->currentState.torsoAnim != BOTH_RIGHTHANDCHOPPEDOFF)
+				{ //exception
+					return;
+				}
+			}
+
+			cent->bolt4 = -1;
+			cent->trailTime = 0;
+
+			if (cent->currentState.modelGhoul2 == G2_MODELPART_HEAD)
+			{
+				limbBone = "cervical";
+				rotateBone = "cranium";
+				Q_strncpyz( limbName , "head", sizeof( limbName  ) );
+				Q_strncpyz( limbCapName, "head_cap_torso", sizeof( limbCapName ) );
+				Q_strncpyz( stubCapName, "torso_cap_head", sizeof( stubCapName ) );
+				limbTagName = "*head_cap_torso";
+				stubTagName = "*torso_cap_head";
+				limb_anim = BOTH_DISMEMBER_HEAD1;
+			}
+			else if (cent->currentState.modelGhoul2 == G2_MODELPART_WAIST)
+			{
+				limbBone = "pelvis";
+
+				if (clEnt->localAnimIndex <= 1)
+				{ //humanoid/rtrooper
+					rotateBone = "thoracic";
+				}
+				else
+				{
+					rotateBone = "pelvis";
+				}
+				Q_strncpyz( limbName, "torso", sizeof( limbName ) );
+				Q_strncpyz( limbCapName, "torso_cap_hips", sizeof( limbCapName ) );
+				Q_strncpyz( stubCapName, "hips_cap_torso", sizeof( stubCapName ) );
+				limbTagName = "*torso_cap_hips";
+				stubTagName = "*hips_cap_torso";
+				limb_anim = BOTH_DISMEMBER_TORSO1;
+			}
+			else if (cent->currentState.modelGhoul2 == G2_MODELPART_LARM)
+			{
+				limbBone = "lhumerus";
+				rotateBone = "lradius";
+				BG_GetRootSurfNameWithVariant( clEnt->ghoul2, "l_arm", limbName, sizeof(limbName) );
+				BG_GetRootSurfNameWithVariant( clEnt->ghoul2, "torso", stubName, sizeof(stubName) );
+				Com_sprintf( limbCapName, sizeof( limbCapName ), "%s_cap_torso", limbName );
+				Com_sprintf( stubCapName, sizeof( stubCapName), "%s_cap_l_arm", stubName );
+				limbTagName = "*l_arm_cap_torso";
+				stubTagName = "*torso_cap_l_arm";
+				limb_anim = BOTH_DISMEMBER_LARM;
+			}
+			else if (cent->currentState.modelGhoul2 == G2_MODELPART_RARM)
+			{
+				limbBone = "rhumerus";
+				rotateBone = "rradius";
+				BG_GetRootSurfNameWithVariant( clEnt->ghoul2, "r_arm", limbName, sizeof(limbName) );
+				BG_GetRootSurfNameWithVariant( clEnt->ghoul2, "torso", stubName, sizeof(stubName) );
+				Com_sprintf( limbCapName, sizeof( limbCapName ), "%s_cap_torso", limbName );
+				Com_sprintf( stubCapName, sizeof( stubCapName), "%s_cap_r_arm", stubName );
+				limbTagName = "*r_arm_cap_torso";
+				stubTagName = "*torso_cap_r_arm";
+				limb_anim = BOTH_DISMEMBER_RARM;
+			}
+			else if (cent->currentState.modelGhoul2 == G2_MODELPART_RHAND)
+			{
+				limbBone = "rradiusX";
+				rotateBone = "rhand";
+				BG_GetRootSurfNameWithVariant( clEnt->ghoul2, "r_hand", limbName, sizeof(limbName) );
+				BG_GetRootSurfNameWithVariant( clEnt->ghoul2, "r_arm", stubName, sizeof(stubName) );
+				Com_sprintf( limbCapName, sizeof( limbCapName ), "%s_cap_r_arm", limbName );
+				Com_sprintf( stubCapName, sizeof( stubCapName), "%s_cap_r_hand", stubName );
+				limbTagName = "*r_hand_cap_r_arm";
+				stubTagName = "*r_arm_cap_r_hand";
+				limb_anim = BOTH_DISMEMBER_RARM;
+			}
+			else if (cent->currentState.modelGhoul2 == G2_MODELPART_LLEG)
+			{
+				limbBone = "lfemurYZ";
+				rotateBone = "ltibia";
+				BG_GetRootSurfNameWithVariant( clEnt->ghoul2, "l_leg", limbName, sizeof(limbName) );
+				BG_GetRootSurfNameWithVariant( clEnt->ghoul2, "hips", stubName, sizeof(stubName) );
+				Com_sprintf( limbCapName, sizeof( limbCapName ), "%s_cap_hips", limbName );
+				Com_sprintf( stubCapName, sizeof( stubCapName), "%s_cap_l_leg", stubName );
+				limbTagName = "*l_leg_cap_hips";
+				stubTagName = "*hips_cap_l_leg";
+				limb_anim = BOTH_DISMEMBER_LLEG;
+			}
+			else if (cent->currentState.modelGhoul2 == G2_MODELPART_RLEG)
+			{
+				limbBone = "rfemurYZ";
+				rotateBone = "rtibia";
+				BG_GetRootSurfNameWithVariant( clEnt->ghoul2, "r_leg", limbName, sizeof(limbName) );
+				BG_GetRootSurfNameWithVariant( clEnt->ghoul2, "hips", stubName, sizeof(stubName) );
+				Com_sprintf( limbCapName, sizeof( limbCapName ), "%s_cap_hips", limbName );
+				Com_sprintf( stubCapName, sizeof( stubCapName), "%s_cap_r_leg", stubName );
+				limbTagName = "*r_leg_cap_hips";
+				stubTagName = "*hips_cap_r_leg";
+				limb_anim = BOTH_DISMEMBER_RLEG;
+			}
+			else
+			{//umm... just default to the right leg, I guess (same as on server)
+				limbBone = "rfemurYZ";
+				rotateBone = "rtibia";
+				BG_GetRootSurfNameWithVariant( clEnt->ghoul2, "r_leg", limbName, sizeof(limbName) );
+				BG_GetRootSurfNameWithVariant( clEnt->ghoul2, "hips", stubName, sizeof(stubName) );
+				Com_sprintf( limbCapName, sizeof( limbCapName ), "%s_cap_hips", limbName );
+				Com_sprintf( stubCapName, sizeof( stubCapName), "%s_cap_r_leg", stubName );
+				limbTagName = "*r_leg_cap_hips";
+				stubTagName = "*hips_cap_r_leg";
+				limb_anim = BOTH_DISMEMBER_RLEG;
+			}
+
+			if (clEnt && clEnt->ghoul2)
+			{
+				if (trap_G2API_HasGhoul2ModelOnIndex(&(clEnt->ghoul2), 2))
+				{ //don't want to bother dealing with a second saber on limbs and stuff, just remove the thing
+					trap_G2API_RemoveGhoul2Model(&(clEnt->ghoul2), 2);
+				}
+
+				if (trap_G2API_HasGhoul2ModelOnIndex(&(clEnt->ghoul2), 3))
+				{ //turn off jetpack also I suppose
+					trap_G2API_RemoveGhoul2Model(&(clEnt->ghoul2), 3);
+				}
+
+				if (clEnt->localAnimIndex <= 0)
+				{ //humanoid
+					trap_G2API_SetBoneAngles(clEnt->ghoul2, 0, "model_root", vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, cgs.gameModels, 100, cg.time);
+					trap_G2API_SetBoneAngles(clEnt->ghoul2, 0, "pelvis", vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, cgs.gameModels, 0, cg.time); 
+					trap_G2API_SetBoneAngles(clEnt->ghoul2, 0, "thoracic", vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, cgs.gameModels, 0, cg.time); 
+					trap_G2API_SetBoneAngles(clEnt->ghoul2, 0, "upper_lumbar", vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, cgs.gameModels, 100, cg.time);
+					trap_G2API_SetBoneAngles(clEnt->ghoul2, 0, "lower_lumbar", vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, cgs.gameModels, 100, cg.time);
+					trap_G2API_SetBoneAngles(clEnt->ghoul2, 0, "cranium", vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_Z, NEGATIVE_Y, POSITIVE_X, cgs.gameModels, 100, cg.time);
+				}
+				else
+				{
+					trap_G2API_SetBoneAngles(clEnt->ghoul2, 0, "model_root", vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, cgs.gameModels, 100, cg.time);
+					trap_G2API_SetBoneAngles(clEnt->ghoul2, 0, "pelvis", vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, cgs.gameModels, 0, cg.time); 
+					trap_G2API_SetBoneAngles(clEnt->ghoul2, 0, "upper_lumbar", vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, cgs.gameModels, 100, cg.time);
+					trap_G2API_SetBoneAngles(clEnt->ghoul2, 0, "lower_lumbar", vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, cgs.gameModels, 100, cg.time);
+				}
+
+				trap_G2API_DuplicateGhoul2Instance(clEnt->ghoul2, &cent->ghoul2);
+			}
+
+			if (!cent->ghoul2)
+			{
+				return;
+			}
+
+			newBolt = trap_G2API_AddBolt( cent->ghoul2, 0, limbTagName );
+			if ( newBolt != -1 )
+			{
+				vec3_t boltOrg, boltAng;
+
+				trap_G2API_GetBoltMatrix(cent->ghoul2, 0, newBolt, &matrix, cent->lerpAngles, cent->lerpOrigin, cg.time, cgs.gameModels, cent->modelScale);
+
+				BG_GiveMeVectorFromMatrix(&matrix, ORIGIN, boltOrg);
+				BG_GiveMeVectorFromMatrix(&matrix, NEGATIVE_Y, boltAng);
+
+				trap_FX_PlayEffectID(cgs.effects.mBlasterSmoke, boltOrg, boltAng, -1, -1);
+			}
+
+			cent->bolt4 = newBolt;
+
+			trap_G2API_SetRootSurface(cent->ghoul2, 0, limbName);
+
+			trap_G2API_SetNewOrigin(cent->ghoul2, trap_G2API_AddBolt(cent->ghoul2, 0, rotateBone));
+
+			trap_G2API_SetSurfaceOnOff(cent->ghoul2, limbCapName, 0);
+
+			trap_G2API_SetSurfaceOnOff(clEnt->ghoul2, limbName, 0x00000100);
+			trap_G2API_SetSurfaceOnOff(clEnt->ghoul2, stubCapName, 0);
+
+			newBolt = trap_G2API_AddBolt( clEnt->ghoul2, 0, stubTagName );
+			if ( newBolt != -1 )
+			{
+				vec3_t boltOrg, boltAng;
+
+				trap_G2API_GetBoltMatrix(clEnt->ghoul2, 0, newBolt, &matrix, clEnt->lerpAngles, clEnt->lerpOrigin, cg.time, cgs.gameModels, clEnt->modelScale);
+
+				BG_GiveMeVectorFromMatrix(&matrix, ORIGIN, boltOrg);
+				BG_GiveMeVectorFromMatrix(&matrix, NEGATIVE_Y, boltAng);
+
+				trap_FX_PlayEffectID(cgs.effects.mBlasterSmoke, boltOrg, boltAng, -1, -1);
+			}
+
+			if (cent->currentState.modelGhoul2 == G2_MODELPART_RARM || cent->currentState.modelGhoul2 == G2_MODELPART_RHAND || cent->currentState.modelGhoul2 == G2_MODELPART_WAIST)
+			{ //Cut his weapon holding arm off, so remove the weapon
+				if (trap_G2API_HasGhoul2ModelOnIndex(&(clEnt->ghoul2), 1))
+				{
+					trap_G2API_RemoveGhoul2Model(&(clEnt->ghoul2), 1);
+				}
+			}
+
+			clEnt->torsoBolt |= limbBit; //reinit model after copying limbless one to queue
+			//This causes issues after respawning.. just keep track of limbs cut/made on server or something.
+			/*
+			if (cent->currentState.modelGhoul2 == G2_MODELPART_WAIST)
+			{
+				clEnt->torsoBolt |= (1 << (G2_MODELPART_HEAD-10));
+				clEnt->torsoBolt |= (1 << (G2_MODELPART_RARM-10));
+				clEnt->torsoBolt |= (1 << (G2_MODELPART_LARM-10));
+				clEnt->torsoBolt |= (1 << (G2_MODELPART_RHAND-10));
+			}
+			else if (cent->currentState.modelGhoul2 == G2_MODELPART_RARM)
+			{
+				clEnt->torsoBolt |= (1 << (G2_MODELPART_RHAND-10));
+			}
+			*/
+
+			VectorCopy(cent->lerpOrigin, cent->turAngles);
+		//	return;
+		}
+
+		//Use origin smoothing since dismembered limbs use ExPhys
+		if (DistanceSquared(cent->turAngles,cent->lerpOrigin)>18000.0f)
+		{
+			VectorCopy(cent->lerpOrigin, cent->turAngles);
+		}
+
+		VectorSubtract(cent->lerpOrigin, cent->turAngles, posDif);
+		
+		for (k=0;k<3;k++)
+		{
+			cent->turAngles[k]=(cent->turAngles[k]+posDif[k]*smoothFactor);
+			cent->lerpOrigin[k]=cent->turAngles[k];
+		}
+
+		if (cent->ghoul2 && cent->bolt4 != -1 && cent->trailTime < cg.time)
+		{
+			if ( cent->bolt4 != -1 && 
+				(cent->currentState.pos.trDelta[0] || cent->currentState.pos.trDelta[1] || cent->currentState.pos.trDelta[2]) )
+			{
+				vec3_t boltOrg, boltAng;
+
+				trap_G2API_GetBoltMatrix(cent->ghoul2, 0, cent->bolt4, &matrix, cent->lerpAngles, cent->lerpOrigin, cg.time, cgs.gameModels, cent->modelScale);
+
+				BG_GiveMeVectorFromMatrix(&matrix, ORIGIN, boltOrg);
+				BG_GiveMeVectorFromMatrix(&matrix, NEGATIVE_Y, boltAng);
+
+				if (!boltAng[0] && !boltAng[1] && !boltAng[2])
+				{
+					boltAng[1] = 1;
+				}
+				trap_FX_PlayEffectID(cgs.effects.mBlasterSmoke, boltOrg, boltAng, -1, -1);
+
+				cent->trailTime = cg.time + 400;
+			}
+		}
+
+		ent.radius = cent->currentState.g2radius;
+		ent.hModel = 0;
+	}
+
+	if (cent->currentState.number >= MAX_CLIENTS &&
+		cent->currentState.activeForcePass == NUM_FORCE_POWERS+1&&
+		cent->currentState.NPC_class != CLASS_VEHICLE )
+	{
+		vec3_t				empAngles;
+		centity_t			*empOwn;
+
+		empOwn = &cg_entities[cent->currentState.emplacedOwner];
+
+		if (cg.snap->ps.clientNum == empOwn->currentState.number &&
+			!cg.renderingThirdPerson)
+		{
+			VectorCopy(cg.refdef.viewangles, empAngles);
+		}
+		else
+		{
+			VectorCopy(empOwn->lerpAngles, empAngles);
+		}
+
+		if (empAngles[PITCH] > 40)
+		{
+			empAngles[PITCH] = 40;
+		}
+		empAngles[YAW] -= cent->currentState.angles[YAW];
+
+		trap_G2API_SetBoneAngles( cent->ghoul2, 0, "Bone02", empAngles, BONE_ANGLES_REPLACE, NEGATIVE_Y, NEGATIVE_X, POSITIVE_Z, NULL, 0, cg.time); 
+	}
+
+	s1 = &cent->currentState;
+
+	// if set to invisible, skip
+	if ((!s1->modelindex) && !(trap_G2_HaveWeGhoul2Models(cent->ghoul2))) 
+	{
+		return;
+	}
+
+	if ( ( s1->eFlags & EF_NODRAW ) ) 
+	{
+		return;
+	}
+
+	// set frame
+	if ( s1->eFlags & EF_SHADER_ANIM )
+	{
+		// Deliberately setting it up so that shader anim will completely override any kind of model animation frame setting.
+		ent.renderfx|=RF_SETANIMINDEX;
+		ent.skinNum = s1->frame;
+	}
+	else
+	{
+		ent.frame = s1->frame;
+	}
+	ent.oldframe = ent.frame;
+	ent.backlerp = 0;
+
+/*
+Ghoul2 Insert Start
+*/
+	CG_SetGhoul2Info(&ent, cent);
+
+/*
+Ghoul2 Insert End
+*/
+	VectorCopy( cent->lerpOrigin, ent.origin);
+	VectorCopy( cent->lerpOrigin, ent.oldorigin);
+
+	if (cent->currentState.modelGhoul2)
+	{ //If the game says this guy uses a ghoul2 model and the g2 instance handle is null, then initialize it
+		if (!cent->ghoul2 && !cent->currentState.bolt1)
+		{
+			char skinName[MAX_QPATH];
+			const char *modelName = CG_ConfigString( CS_MODELS+cent->currentState.modelindex );
+			int l;
+			int skin = 0;
+
+			trap_G2API_InitGhoul2Model(&cent->ghoul2, modelName, 0, 0, 0, 0, 0);
+			if (cent->ghoul2 && trap_G2API_SkinlessModel(cent->ghoul2, 0))
+			{ //well, you'd never want a skinless model, so try to get his skin...
+				Q_strncpyz(skinName, modelName, MAX_QPATH);
+				l = strlen(skinName);
+				while (l > 0 && skinName[l] != '/')
+				{ //parse back to first /
+					l--;
+				}
+				if (skinName[l] == '/')
+				{ //got it
+					l++;
+					skinName[l] = 0;
+					Q_strcat(skinName, MAX_QPATH, "model_default.skin");
+		
+					skin = trap_R_RegisterSkin(skinName);
+				}
+				trap_G2API_SetSkin(cent->ghoul2, 0, skin, skin);
+			}
+		}
+		else if (cent->currentState.bolt1)
+		{
+			TurretClientRun(cent);
+		}
+
+		if (cent->ghoul2)
+		{ //give us a proper radius
+			ent.radius = cent->currentState.g2radius;
+		}
+	}
+
+	if (s1->eType == ET_BODY)
+	{ //bodies should have a radius as well
+		ent.radius = cent->currentState.g2radius;
+
+		if (cent->ghoul2)
+		{ //all bodies should already have a ghoul2 instance. Use it to set the torso/head angles to 0.
+			cent->lerpAngles[PITCH] = 0;
+			cent->lerpAngles[ROLL] = 0;
+			trap_G2API_SetBoneAngles(cent->ghoul2, 0, "pelvis", vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, cgs.gameModels, 0, cg.time); 
+			trap_G2API_SetBoneAngles(cent->ghoul2, 0, "thoracic", vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, cgs.gameModels, 0, cg.time); 
+			trap_G2API_SetBoneAngles(cent->ghoul2, 0, "upper_lumbar", vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, cgs.gameModels, 100, cg.time);
+			trap_G2API_SetBoneAngles(cent->ghoul2, 0, "lower_lumbar", vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, cgs.gameModels, 100, cg.time);
+			trap_G2API_SetBoneAngles(cent->ghoul2, 0, "cranium", vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_Z, NEGATIVE_Y, POSITIVE_X, cgs.gameModels, 100, cg.time);
+		}
+	}
+
+	if (s1->eType == ET_HOLOCRON && s1->modelindex < -100)
+	{ //special render, it's a holocron
+		//Using actual models now:
+		ent.hModel = trap_R_RegisterModel(forceHolocronModels[s1->modelindex+128]);
+
+		//Rotate them
+		VectorCopy( cg.autoAngles, cent->lerpAngles );
+		AxisCopy( cg.autoAxis, ent.axis );
+	}
+	else if (!doNotSetModel)
+	{
+		ent.hModel = cgs.gameModels[s1->modelindex];
+	}
+
+	// player model
+	if (s1->number == cg.snap->ps.clientNum) {
+		ent.renderfx |= RF_THIRD_PERSON;	// only draw from mirrors
+	}
+
+	// convert angles to axis
+	AnglesToAxis( cent->lerpAngles, ent.axis );
+
+	if (cent->currentState.iModelScale)
+	{ //if the server says we have a custom scale then set it now.
+		cent->modelScale[0] = cent->modelScale[1] = cent->modelScale[2] = cent->currentState.iModelScale/100.0f;
+		VectorCopy(cent->modelScale, ent.modelScale);
+		ScaleModelAxis(&ent);
+	}
+	else
+	{
+		VectorClear(cent->modelScale);
+	}
+
+	if ( cent->currentState.time > cg.time && cent->currentState.weapon == WP_EMPLACED_GUN )
+	{
+		// make the gun pulse red to warn about it exploding
+		val = (1.0f - (float)(cent->currentState.time - cg.time) / 3200.0f ) * 0.3f;
+
+		ent.customShader = trap_R_RegisterShader( "gfx/effects/turretflashdie" );
+		ent.shaderRGBA[0] = (sin( cg.time * 0.04f ) * val * 0.4f + val) * 255;
+		ent.shaderRGBA[1] = ent.shaderRGBA[2] = 0;
+
+		ent.shaderRGBA[3] = 100;
+		trap_R_AddRefEntityToScene( &ent );
+		ent.customShader = 0;
+	}
+	else if ( cent->currentState.time == -1 && cent->currentState.weapon == WP_EMPLACED_GUN)
+	{
+		ent.customShader = trap_R_RegisterShader( "models/map_objects/imp_mine/turret_chair_dmg.tga" );
+		//trap_R_AddRefEntityToScene( &ent );
+	}
+
+	if ((cent->currentState.eFlags & EF_DISINTEGRATION) && cent->currentState.eType == ET_BODY)
+	{
+		if (!cent->dustTrailTime)
+		{
+			cent->dustTrailTime = cg.time;
+		}
+
+		CG_Disintegration(cent, &ent);
+		return;
+	}
+	else if (cent->currentState.eType == ET_BODY)
+	{
+		if (cent->bodyFadeTime > cg.time)
+		{
+			qboolean lightSide = cent->teamPowerType;
+			vec3_t hitLoc, tempAng;
+			float tempLength;
+			int curTimeDif = ((cg.time + 60000) - cent->bodyFadeTime);
+			int tMult = curTimeDif*0.08;
+
+			ent.renderfx |= RF_FORCE_ENT_ALPHA;
+
+			/*
+			if (!cent->bodyHeight)
+			{
+				cent->bodyHeight = ent.origin[2];
+			}
+			*/
+
+			if (curTimeDif*0.1 > 254)
+			{
+				ent.shaderRGBA[3] = 0;
+			}
+			else
+			{
+				ent.shaderRGBA[3] = (254 - tMult);
+			}
+
+			if (ent.shaderRGBA[3] >= 1)
+			{ //add the transparent body section
+				trap_R_AddRefEntityToScene (&ent);
+			}
+
+			ent.renderfx &= ~RF_FORCE_ENT_ALPHA;
+			ent.renderfx |= RF_RGB_TINT;
+
+			if (tMult > 200)
+			{ //begin the disintegration effect
+				ent.shaderRGBA[3] = 200;
+				if (!cent->dustTrailTime)
+				{
+					cent->dustTrailTime = cg.time;
+					if (lightSide)
+					{
+						trap_S_StartSound ( NULL, cent->currentState.number, CHAN_AUTO, trap_S_RegisterSound("sound/weapons/force/see.wav") );
+					}
+					else
+					{
+						trap_S_StartSound ( NULL, cent->currentState.number, CHAN_AUTO, trap_S_RegisterSound("sound/weapons/force/lightning") );
+					}
+				}
+				ent.endTime = cent->dustTrailTime;
+				ent.renderfx |= RF_DISINTEGRATE2;
+			}
+			else
+			{ //set the alpha on the to-be-disintegrated layer
+				ent.shaderRGBA[3] = tMult;
+				if (ent.shaderRGBA[3] < 1)
+				{
+					ent.shaderRGBA[3] = 1;
+				}
+			}
+			//Set everything up on the disint ref
+			ent.shaderRGBA[0] = ent.shaderRGBA[1] = ent.shaderRGBA[2] = ent.shaderRGBA[3];
+			VectorCopy(cent->lerpOrigin, hitLoc);
+
+			VectorSubtract( hitLoc, ent.origin, ent.oldorigin );
+			
+			tempLength = VectorNormalize( ent.oldorigin );
+			vectoangles( ent.oldorigin, tempAng );
+			tempAng[YAW] -= cent->lerpAngles[YAW];
+			AngleVectors( tempAng, ent.oldorigin, NULL, NULL );
+			VectorScale( ent.oldorigin, tempLength, ent.oldorigin );
+
+			if (lightSide)
+			{ //might be temporary, dunno.
+				ent.customShader = cgs.media.playerShieldDamage;
+			}
+			else
+			{
+				ent.customShader = cgs.media.redSaberGlowShader;
+			}
+
+			//slowly move the glowing part upward, out of the fading body
+			/*
+			cent->bodyHeight += 0.4f;
+			ent.origin[2] = cent->bodyHeight;
+			*/
+
+			trap_R_AddRefEntityToScene( &ent );
+			ent.renderfx &= ~RF_DISINTEGRATE2;
+			ent.customShader = 0;
+
+			if (curTimeDif < 3400)
+			{
+				if (lightSide)
+				{
+					if (curTimeDif < 2200)
+					{ //probably temporary
+						trap_S_StartSound ( NULL, cent->currentState.number, CHAN_AUTO, trap_S_RegisterSound( "sound/weapons/saber/saberhum1.wav" ) );
+					}
+				}
+				else
+				{ //probably temporary as well
+					ent.renderfx |= RF_RGB_TINT;
+					ent.shaderRGBA[0] = 255;
+					ent.shaderRGBA[1] = ent.shaderRGBA[2] = 0;
+					ent.shaderRGBA[3] = 255;
+					if ( rand() & 1 )
+					{
+						ent.customShader = cgs.media.electricBodyShader;	
+					}
+					else
+					{
+						ent.customShader = cgs.media.electricBody2Shader;
+					}
+					if ( random() > 0.9f )
+					{
+						trap_S_StartSound ( NULL, cent->currentState.number, CHAN_AUTO, cgs.media.crackleSound );
+					}
+					trap_R_AddRefEntityToScene( &ent );
+				}
+			}
+
+			return;
+		}
+		else
+		{
+			cent->dustTrailTime = 0;
+		}
+	}
+
+	if (cent->currentState.modelGhoul2 &&
+		!ent.ghoul2 &&
+		!ent.hModel)
+	{
+		return;
+	}
+
+	// add to refresh list
+	trap_R_AddRefEntityToScene (&ent);
+
+	if (cent->bolt3 == 999)
+	{ //this is an in-flight saber being rendered manually
+		vec3_t org;
+		float wv;
+		int i;
+		addspriteArgStruct_t fxSArgs;
+		//refEntity_t sRef;
+		//memcpy( &sRef, &ent, sizeof( sRef ) );
+
+		ent.customShader = cgs.media.solidWhite;
+		ent.renderfx = RF_RGB_TINT;
+		wv = sin( cg.time * 0.003f ) * 0.08f + 0.1f;
+		ent.shaderRGBA[0] = wv * 255;
+		ent.shaderRGBA[1] = wv * 255;
+		ent.shaderRGBA[2] = wv * 0;
+		trap_R_AddRefEntityToScene (&ent);
+
+		for ( i = -4; i < 10; i += 1 )
+		{
+			VectorMA( ent.origin, -i, ent.axis[2], org );
+
+			VectorCopy(org, fxSArgs.origin);
+			VectorClear(fxSArgs.vel);
+			VectorClear(fxSArgs.accel);
+			fxSArgs.scale = 5.5f;
+			fxSArgs.dscale = 5.5f;
+			fxSArgs.sAlpha = wv;
+			fxSArgs.eAlpha = wv;
+			fxSArgs.rotation = 0.0f;
+			fxSArgs.bounce = 0.0f;
+			fxSArgs.life = 1.0f;
+			fxSArgs.shader = cgs.media.yellowDroppedSaberShader;
+			fxSArgs.flags = 0x08000000;
+
+			//trap_FX_AddSprite( org, NULL, NULL, 5.5f, 5.5f, wv, wv, 0.0f, 0.0f, 1.0f, cgs.media.yellowSaberGlowShader, 0x08000000 );
+			trap_FX_AddSprite(&fxSArgs);
+		}
+	}
+	else if (cent->currentState.trickedentindex3)
+	{ //holocron special effects
+		vec3_t org;
+		float wv;
+		addspriteArgStruct_t fxSArgs;
+		//refEntity_t sRef;
+		//memcpy( &sRef, &ent, sizeof( sRef ) );
+
+		ent.customShader = cgs.media.solidWhite;
+		ent.renderfx = RF_RGB_TINT;
+		wv = sin( cg.time * 0.005f ) * 0.08f + 0.1f; //* 0.08f + 0.1f;
+
+		if (cent->currentState.trickedentindex3 == 1)
+		{ //dark
+			ent.shaderRGBA[0] = wv*255;
+			ent.shaderRGBA[1] = 0;
+			ent.shaderRGBA[2] = 0;
+		}
+		else if (cent->currentState.trickedentindex3 == 2)
+		{ //light
+			ent.shaderRGBA[0] = wv*255;
+			ent.shaderRGBA[1] = wv*255;
+			ent.shaderRGBA[2] = wv*255;
+		}
+		else
+		{ //neutral
+			if ((s1->modelindex+128) == FP_SABER_OFFENSE ||
+				(s1->modelindex+128) == FP_SABER_DEFENSE ||
+				(s1->modelindex+128) == FP_SABERTHROW)
+			{ //saber power
+				ent.shaderRGBA[0] = 0;
+				ent.shaderRGBA[1] = wv*255;
+				ent.shaderRGBA[2] = 0;
+			}
+			else
+			{
+				ent.shaderRGBA[0] = 0;
+				ent.shaderRGBA[1] = wv*255;
+				ent.shaderRGBA[2] = wv*255;
+			}
+		}
+
+		ent.modelScale[0] = 1.1;
+		ent.modelScale[1] = 1.1;
+		ent.modelScale[2] = 1.1;
+
+		ent.origin[2] -= 2;
+		ScaleModelAxis(&ent);
+
+		trap_R_AddRefEntityToScene (&ent);
+		
+		VectorMA( ent.origin, 1, ent.axis[2], org );
+
+		org[2] += 18;
+
+		wv = sin( cg.time * 0.002f ) * 0.08f + 0.1f; //* 0.08f + 0.1f;
+
+		VectorCopy(org, fxSArgs.origin);
+		VectorClear(fxSArgs.vel);
+		VectorClear(fxSArgs.accel);
+		fxSArgs.scale = wv*120;//16.0f;
+		fxSArgs.dscale = wv*120;//16.0f;
+		fxSArgs.sAlpha = wv*12;
+		fxSArgs.eAlpha = wv*12;
+		fxSArgs.rotation = 0.0f;
+		fxSArgs.bounce = 0.0f;
+		fxSArgs.life = 1.0f;
+
+		fxSArgs.flags = 0x08000000|0x00000001;
+
+		if (cent->currentState.trickedentindex3 == 1)
+		{ //dark
+			fxSArgs.sAlpha *= 3;
+			fxSArgs.eAlpha *= 3;
+			fxSArgs.shader = cgs.media.redSaberGlowShader;
+			trap_FX_AddSprite(&fxSArgs);
+		}
+		else if (cent->currentState.trickedentindex3 == 2)
+		{ //light
+			fxSArgs.sAlpha *= 1.5;
+			fxSArgs.eAlpha *= 1.5;
+			fxSArgs.shader = cgs.media.redSaberGlowShader;
+			trap_FX_AddSprite(&fxSArgs);
+			fxSArgs.shader = cgs.media.greenSaberGlowShader;
+			trap_FX_AddSprite(&fxSArgs);
+			fxSArgs.shader = cgs.media.blueSaberGlowShader;
+			trap_FX_AddSprite(&fxSArgs);
+		}
+		else
+		{ //neutral
+			if ((s1->modelindex+128) == FP_SABER_OFFENSE ||
+				(s1->modelindex+128) == FP_SABER_DEFENSE ||
+				(s1->modelindex+128) == FP_SABERTHROW)
+			{ //saber power
+				fxSArgs.sAlpha *= 1.5;
+				fxSArgs.eAlpha *= 1.5;
+				fxSArgs.shader = cgs.media.greenSaberGlowShader;
+				trap_FX_AddSprite(&fxSArgs);
+			}
+			else
+			{
+				fxSArgs.sAlpha *= 0.5;
+				fxSArgs.eAlpha *= 0.5;
+				fxSArgs.shader = cgs.media.greenSaberGlowShader;
+				trap_FX_AddSprite(&fxSArgs);
+				fxSArgs.shader = cgs.media.blueSaberGlowShader;
+				trap_FX_AddSprite(&fxSArgs);
+			}
+		}
+	}
+
+	if ( cent->currentState.time == -1 && cent->currentState.weapon == WP_TRIP_MINE && (cent->currentState.eFlags & EF_FIRING) )
+	{ //if force sight is active, render the laser multiple times up to the force sight level to increase visibility
+		if (cent->currentState.bolt2 == 1)
+		{
+			VectorMA( ent.origin, 6.6f, ent.axis[0], beamOrg );// forward
+			beamID = cgs.effects.tripmineGlowFX;
+			trap_FX_PlayEffectID( beamID, beamOrg, cent->currentState.pos.trDelta, -1, -1 );
+		}
+		else
+		{
+			int i = 0;
+
+			VectorMA( ent.origin, 6.6f, ent.axis[0], beamOrg );// forward
+			beamID = cgs.effects.tripmineLaserFX;
+
+			if (cg.snap->ps.fd.forcePowersActive & (1 << FP_SEE))
+			{
+				i = cg.snap->ps.fd.forcePowerLevel[FP_SEE];
+
+				while (i > 0)
+				{
+					trap_FX_PlayEffectID( beamID, beamOrg, cent->currentState.pos.trDelta, -1, -1 );
+					trap_FX_PlayEffectID( beamID, beamOrg, cent->currentState.pos.trDelta, -1, -1 );
+					i--;
+				}
+			}
+
+			trap_FX_PlayEffectID( beamID, beamOrg, cent->currentState.pos.trDelta, -1, -1 );
+		}
+	}
+/*
+Ghoul2 Insert Start
+*/
+
+	if (cg_debugBB.integer)
+	{
+		CG_CreateBBRefEnts(s1, cent->lerpOrigin);
+	}
+/*
+Ghoul2 Insert End
+*/
+}
+
+/*
+==================
+CG_Speaker
+
+Speaker entities can automatically play sounds
+==================
+*/
+static void CG_Speaker( centity_t *cent ) {
+	if (cent->currentState.trickedentindex)
+	{
+		CG_S_StopLoopingSound(cent->currentState.number, -1);
+	}
+
+	if ( ! cent->currentState.clientNum ) {	// FIXME: use something other than clientNum...
+		return;		// not auto triggering
+	}
+
+	if ( cg.time < cent->miscTime ) {
+		return;
+	}
+
+	trap_S_StartSound (NULL, cent->currentState.number, CHAN_ITEM, cgs.gameSounds[cent->currentState.eventParm] );
+
+	//	ent->s.frame = ent->wait * 10;
+	//	ent->s.clientNum = ent->random * 10;
+	cent->miscTime = cg.time + cent->currentState.frame * 100 + cent->currentState.clientNum * 100 * crandom();
+}
+
+qboolean CG_GreyItem(int type, int tag, int plSide)
+{
+	if (type == IT_POWERUP &&
+		(tag == PW_FORCE_ENLIGHTENED_LIGHT || tag == PW_FORCE_ENLIGHTENED_DARK))
+	{
+		if (plSide == FORCE_LIGHTSIDE)
+		{
+			if (tag == PW_FORCE_ENLIGHTENED_DARK)
+			{
+				return qtrue;
+			}
+		}
+		else if (plSide == FORCE_DARKSIDE)
+		{
+			if (tag == PW_FORCE_ENLIGHTENED_LIGHT)
+			{
+				return qtrue;
+			}
+		}
+	}
+
+	return qfalse;
+}
+
+/*
+==================
+CG_Item
+==================
+*/
+static void CG_Item( centity_t *cent ) {
+	refEntity_t		ent;
+	entityState_t	*es;
+	gitem_t			*item;
+	int				msec;
+	float			scale;
+	weaponInfo_t	*wi;
+
+	es = &cent->currentState;
+	if ( es->modelindex >= bg_numItems ) {
+		CG_Error( "Bad item index %i on entity", es->modelindex );
+	}
+
+/*
+Ghoul2 Insert Start
+*/
+
+	if ((es->eFlags & EF_NODRAW) && (es->eFlags & EF_ITEMPLACEHOLDER))
+	{
+		es->eFlags &= ~EF_NODRAW;
+	}
+
+	if ( !es->modelindex ) 
+	{
+		return;
+	}
+
+	item = &bg_itemlist[ es->modelindex ];
+
+	if ((item->giType == IT_WEAPON || item->giType == IT_POWERUP) &&
+		!(cent->currentState.eFlags & EF_DROPPEDWEAPON) &&
+		!cg_simpleItems.integer)
+	{
+		vec3_t uNorm;
+		qboolean doGrey;
+		
+		VectorClear(uNorm);
+
+		uNorm[2] = 1;
+
+		memset( &ent, 0, sizeof( ent ) );
+
+		ent.customShader = 0;
+		VectorCopy(cent->lerpOrigin, ent.origin);
+		VectorCopy( cent->currentState.angles, cent->lerpAngles );
+		AnglesToAxis(cent->lerpAngles, ent.axis);
+		ent.hModel = cgs.media.itemHoloModel;
+
+		doGrey = CG_GreyItem(item->giType, item->giTag, cg.snap->ps.fd.forceSide);
+
+		if (doGrey)
+		{
+			ent.renderfx |= RF_RGB_TINT;
+
+			ent.shaderRGBA[0] = 150;
+			ent.shaderRGBA[1] = 150;
+			ent.shaderRGBA[2] = 150;
+		}
+
+		trap_R_AddRefEntityToScene(&ent);
+
+		if (!doGrey)
+		{
+			trap_FX_PlayEffectID(cgs.effects.itemCone, ent.origin, uNorm, -1, -1);
+		}
+	}
+
+	// if set to invisible, skip
+	if ( ( es->eFlags & EF_NODRAW ) ) 
+	{
+		return;
+	}
+/*
+Ghoul2 Insert End
+*/
+
+	if ( cg_simpleItems.integer && item->giType != IT_TEAM ) {
+		memset( &ent, 0, sizeof( ent ) );
+		ent.reType = RT_SPRITE;
+		VectorCopy( cent->lerpOrigin, ent.origin );
+		ent.radius = 14;
+		ent.customShader = cg_items[es->modelindex].icon;
+		ent.shaderRGBA[0] = 255;
+		ent.shaderRGBA[1] = 255;
+		ent.shaderRGBA[2] = 255;
+
+		ent.origin[2] += 16;
+
+		if (item->giType != IT_POWERUP || item->giTag != PW_FORCE_BOON)
+		{
+			ent.renderfx |= RF_FORCE_ENT_ALPHA;
+		}
+
+		if ( es->eFlags & EF_ITEMPLACEHOLDER )
+		{
+			if (item->giType == IT_POWERUP && item->giTag == PW_FORCE_BOON)
+			{
+				return;
+			}
+			ent.shaderRGBA[0] = 200;
+			ent.shaderRGBA[1] = 200;
+			ent.shaderRGBA[2] = 200;
+			ent.shaderRGBA[3] = 150 + sin(cg.time*0.01)*30;
+		}
+		else
+		{
+			ent.shaderRGBA[3] = 255;
+		}
+
+		if (CG_GreyItem(item->giType, item->giTag, cg.snap->ps.fd.forceSide))
+		{
+			ent.shaderRGBA[0] = 100;
+			ent.shaderRGBA[1] = 100;
+			ent.shaderRGBA[2] = 100;
+
+			ent.shaderRGBA[3] = 200;
+
+			if (item->giTag == PW_FORCE_ENLIGHTENED_LIGHT)
+			{
+				ent.customShader = trap_R_RegisterShader("gfx/misc/mp_light_enlight_disable");
+			}
+			else
+			{
+				ent.customShader = trap_R_RegisterShader("gfx/misc/mp_dark_enlight_disable");
+			}
+		}
+		trap_R_AddRefEntityToScene(&ent);
+		return;
+	}
+
+	if ((item->giType == IT_WEAPON || item->giType == IT_POWERUP) &&
+		!(cent->currentState.eFlags & EF_DROPPEDWEAPON))
+	{
+		cent->lerpOrigin[2] += 16;
+	}
+
+	if ((!(cent->currentState.eFlags & EF_DROPPEDWEAPON) || item->giType == IT_POWERUP) &&
+		(item->giType == IT_WEAPON || item->giType == IT_POWERUP))
+	{
+		// items bob up and down continuously
+		scale = 0.005 + cent->currentState.number * 0.00001;
+		cent->lerpOrigin[2] += 4 + cos( ( cg.time + 1000 ) *  scale ) * 4;
+	}
+	else
+	{
+		if (item->giType == IT_HOLDABLE)
+		{
+			if (item->giTag == HI_SEEKER)
+			{
+				cent->lerpOrigin[2] += 5;
+			}
+			if (item->giTag == HI_SHIELD)
+			{
+				cent->lerpOrigin[2] += 2;
+			}
+			if (item->giTag == HI_BINOCULARS)
+			{
+				cent->lerpOrigin[2] += 2;
+			}
+		}
+		if (item->giType == IT_HEALTH)
+		{
+			cent->lerpOrigin[2] += 2;
+		}
+		if (item->giType == IT_ARMOR)
+		{
+			if (item->quantity == 100)
+			{
+				cent->lerpOrigin[2] += 7;
+			}
+		}
+	}
+
+	memset (&ent, 0, sizeof(ent));
+
+	if ( (!(cent->currentState.eFlags & EF_DROPPEDWEAPON) || item->giType == IT_POWERUP) &&
+		(item->giType == IT_WEAPON || item->giType == IT_POWERUP) )
+	{ //only weapons and powerups rotate now
+		// autorotate at one of two speeds
+		VectorCopy( cg.autoAngles, cent->lerpAngles );
+		AxisCopy( cg.autoAxis, ent.axis );
+	}
+	else
+	{
+		VectorCopy( cent->currentState.angles, cent->lerpAngles );
+		AnglesToAxis(cent->lerpAngles, ent.axis);
+	}
+
+	wi = NULL;
+	// the weapons have their origin where they attatch to player
+	// models, so we need to offset them or they will rotate
+	// eccentricly
+	if (!(cent->currentState.eFlags & EF_DROPPEDWEAPON))
+	{
+		if ( item->giType == IT_WEAPON ) {
+			wi = &cg_weapons[item->giTag];
+			cent->lerpOrigin[0] -= 
+				wi->weaponMidpoint[0] * ent.axis[0][0] +
+				wi->weaponMidpoint[1] * ent.axis[1][0] +
+				wi->weaponMidpoint[2] * ent.axis[2][0];
+			cent->lerpOrigin[1] -= 
+				wi->weaponMidpoint[0] * ent.axis[0][1] +
+				wi->weaponMidpoint[1] * ent.axis[1][1] +
+				wi->weaponMidpoint[2] * ent.axis[2][1];
+			cent->lerpOrigin[2] -= 
+				wi->weaponMidpoint[0] * ent.axis[0][2] +
+				wi->weaponMidpoint[1] * ent.axis[1][2] +
+				wi->weaponMidpoint[2] * ent.axis[2][2];
+
+			cent->lerpOrigin[2] += 8;	// an extra height boost
+		}
+	}
+	else
+	{
+		wi = &cg_weapons[item->giTag];
+
+		switch(item->giTag)
+		{
+		case WP_BLASTER:
+			cent->lerpOrigin[2] -= 12;
+			break;
+		case WP_DISRUPTOR:
+			cent->lerpOrigin[2] -= 13;
+			break;
+		case WP_BOWCASTER:
+			cent->lerpOrigin[2] -= 16;
+			break;
+		case WP_REPEATER:
+			cent->lerpOrigin[2] -= 12;
+			break;
+		case WP_DEMP2:
+			cent->lerpOrigin[2] -= 10;
+			break;
+		case WP_FLECHETTE:
+			cent->lerpOrigin[2] -= 6;
+			break;
+		case WP_ROCKET_LAUNCHER:
+			cent->lerpOrigin[2] -= 11;
+			break;
+		case WP_THERMAL:
+			cent->lerpOrigin[2] -= 12;
+			break;
+		case WP_TRIP_MINE:
+			cent->lerpOrigin[2] -= 16;
+			break;
+		case WP_DET_PACK:
+			cent->lerpOrigin[2] -= 16;
+			break;
+		default:
+			cent->lerpOrigin[2] -= 8;
+			break;
+		}
+	}
+
+	ent.hModel = cg_items[es->modelindex].models[0];
+/*
+Ghoul2 Insert Start
+*/
+	ent.ghoul2 = cg_items[es->modelindex].g2Models[0];
+	ent.radius = cg_items[es->modelindex].radius[0];
+	VectorCopy (cent->lerpAngles, ent.angles);
+/*
+Ghoul2 Insert End
+*/
+	VectorCopy( cent->lerpOrigin, ent.origin);
+	VectorCopy( cent->lerpOrigin, ent.oldorigin);
+
+	ent.nonNormalizedAxes = qfalse;
+
+	// if just respawned, slowly scale up
+	
+	msec = cg.time - cent->miscTime;
+
+	if (CG_GreyItem(item->giType, item->giTag, cg.snap->ps.fd.forceSide))
+	{
+		ent.renderfx |= RF_RGB_TINT;
+
+		ent.shaderRGBA[0] = 150;
+		ent.shaderRGBA[1] = 150;
+		ent.shaderRGBA[2] = 150;
+
+		ent.renderfx |= RF_FORCE_ENT_ALPHA;
+
+		ent.shaderRGBA[3] = 200;
+
+		if (item->giTag == PW_FORCE_ENLIGHTENED_LIGHT)
+		{
+			ent.customShader = trap_R_RegisterShader("gfx/misc/mp_light_enlight_disable");
+		}
+		else
+		{
+			ent.customShader = trap_R_RegisterShader("gfx/misc/mp_dark_enlight_disable");
+		}
+
+		trap_R_AddRefEntityToScene( &ent );
+		return;
+	}
+
+	if ( es->eFlags & EF_ITEMPLACEHOLDER )		// item has been picked up
+	{
+		if ( es->eFlags & EF_DEAD )				// if item had been droped, don't show at all
+			return;
+
+		ent.renderfx |= RF_RGB_TINT;
+		ent.shaderRGBA[0] = 0;
+		ent.shaderRGBA[1] = 200;
+		ent.shaderRGBA[2] = 85;
+		ent.customShader = cgs.media.itemRespawningPlaceholder;
+	}
+
+	// increase the size of the weapons when they are presented as items
+	if ( item->giType == IT_WEAPON ) {
+		VectorScale( ent.axis[0], 1.5, ent.axis[0] );
+		VectorScale( ent.axis[1], 1.5, ent.axis[1] );
+		VectorScale( ent.axis[2], 1.5, ent.axis[2] );
+		ent.nonNormalizedAxes = qtrue;
+		//trap_S_AddLoopingSound( cent->currentState.number, cent->lerpOrigin, vec3_origin, cgs.media.weaponHoverSound );
+	}
+
+	if (!(cent->currentState.eFlags & EF_DROPPEDWEAPON) &&
+		(item->giType == IT_WEAPON || item->giType == IT_POWERUP))
+	{
+		ent.renderfx |= RF_MINLIGHT;
+	}
+
+	if (item->giType != IT_TEAM && msec >= 0 && msec < ITEM_SCALEUP_TIME && !(es->eFlags & EF_ITEMPLACEHOLDER) && !(es->eFlags & EF_DROPPEDWEAPON)) 
+	{	// if just respawned, fade in, but don't do this for flags.
+		float alpha;
+		int a;
+		
+		alpha = (float)msec / ITEM_SCALEUP_TIME;
+		a = alpha * 255.0;
+		if (a <= 0)
+			a=1;
+
+		ent.shaderRGBA[3] = a;
+		if (item->giType != IT_POWERUP || item->giTag != PW_FORCE_BOON)
+		{ //boon model uses a different blending mode for the sprite inside and doesn't look proper with this method
+			ent.renderfx |= RF_FORCE_ENT_ALPHA;
+		}
+		trap_R_AddRefEntityToScene(&ent);
+		
+		ent.renderfx &= ~RF_FORCE_ENT_ALPHA;
+	
+		// Now draw the static shader over it.
+		// Alpha in over half the time, out over half.
+		
+		//alpha = sin(M_PI*alpha);
+		a = alpha * 255.0;
+
+		a = 255 - a;
+
+		if (a <= 0)
+			a=1;
+		if (a > 255)
+			a=255;
+
+		ent.customShader = cgs.media.itemRespawningRezOut;
+
+		/*
+		ent.shaderRGBA[0] = 0;
+		ent.shaderRGBA[1] = a;
+		ent.shaderRGBA[2] = a-100;
+
+		if (ent.shaderRGBA[2] < 0)
+		{
+			ent.shaderRGBA[2] = 0;
+		}
+		*/
+
+		/*
+		ent.shaderRGBA[0] =
+		ent.shaderRGBA[1] =
+		ent.shaderRGBA[2] = a;
+		*/
+
+		ent.renderfx |= RF_RGB_TINT;
+		ent.shaderRGBA[0] = 0;
+		ent.shaderRGBA[1] = 200;
+		ent.shaderRGBA[2] = 85;
+
+		trap_R_AddRefEntityToScene( &ent );
+	}
+	else
+	{	// add to refresh list  -- normal item
+		if (item->giType == IT_TEAM &&
+			(item->giTag == PW_REDFLAG || item->giTag == PW_BLUEFLAG))
+		{
+			ent.modelScale[0] = 0.7;
+			ent.modelScale[1] = 0.7;
+			ent.modelScale[2] = 0.7;
+			ScaleModelAxis(&ent);
+		}
+		trap_R_AddRefEntityToScene(&ent);
+	}
+
+	//rww - As far as I can see, this is useless.
+	/*
+	if ( item->giType == IT_WEAPON && wi->barrelModel ) {
+		refEntity_t	barrel;
+
+		memset( &barrel, 0, sizeof( barrel ) );
+
+		barrel.hModel = wi->barrelModel;
+
+		VectorCopy( ent.lightingOrigin, barrel.lightingOrigin );
+		barrel.shadowPlane = ent.shadowPlane;
+		barrel.renderfx = ent.renderfx;
+
+		barrel.customShader = ent.customShader;
+
+		CG_PositionRotatedEntityOnTag( &barrel, &ent, wi->weaponModel, "tag_barrel" );
+
+		AxisCopy( ent.axis, barrel.axis );
+		barrel.nonNormalizedAxes = ent.nonNormalizedAxes;
+
+		trap_R_AddRefEntityToScene( &barrel );
+	}
+	*/
+
+	// accompanying rings / spheres for powerups
+	if ( !cg_simpleItems.integer ) 
+	{
+		vec3_t spinAngles;
+
+		VectorClear( spinAngles );
+
+		if ( item->giType == IT_HEALTH || item->giType == IT_POWERUP )
+		{
+			if ( ( ent.hModel = cg_items[es->modelindex].models[1] ) != 0 )
+			{
+				if ( item->giType == IT_POWERUP )
+				{
+					ent.origin[2] += 12;
+					spinAngles[1] = ( cg.time & 1023 ) * 360 / -1024.0f;
+				}
+				AnglesToAxis( spinAngles, ent.axis );
+				
+				trap_R_AddRefEntityToScene( &ent );
+			}
+		}
+	}
+}
+
+//============================================================================
+
+void CG_CreateDistortionTrailPart(centity_t *cent, float scale, vec3_t pos)
+{
+	refEntity_t ent;
+	vec3_t ang;
+	float vLen;
+
+	if (!cg_renderToTextureFX.integer)
+	{
+		return;
+	}
+	memset( &ent, 0, sizeof( ent ) );
+
+	VectorCopy( pos, ent.origin );
+
+	VectorSubtract(ent.origin, cg.refdef.vieworg, ent.axis[0]);
+	vLen = VectorLength(ent.axis[0]);
+	if (VectorNormalize(ent.axis[0]) <= 0.1f)
+	{	// Entity is right on vieworg.  quit.
+		return;
+	}
+
+	VectorCopy(cent->lerpAngles, ang);
+	ang[PITCH] += 90.0f;
+	AnglesToAxis(ang, ent.axis);
+
+	//radius must be a power of 2, and is the actual captured texture size
+	if (vLen < 512)
+	{
+		ent.radius = 256;
+	}
+	else if (vLen < 1024)
+	{
+		ent.radius = 128;
+	}
+	else if (vLen < 2048)
+	{
+		ent.radius = 64;
+	}
+	else
+	{
+		ent.radius = 32;
+	}
+
+	ent.modelScale[0] = scale;
+	ent.modelScale[1] = scale;
+	ent.modelScale[2] = scale*16.0f;
+	ScaleModelAxis(&ent);
+
+	ent.hModel = trap_R_RegisterModel("models/weapons2/merr_sonn/trailmodel.md3");
+	ent.customShader = cgs.media.itemRespawningRezOut;//cgs.media.cloakedShader;//cgs.media.halfShieldShader;	
+
+#if 1
+	ent.renderfx = (RF_DISTORTION|RF_FORCE_ENT_ALPHA);
+	ent.shaderRGBA[0] = 255.0f;
+	ent.shaderRGBA[1] = 255.0f;
+	ent.shaderRGBA[2] = 255.0f;
+	ent.shaderRGBA[3] = 100.0f;
+#else //no alpha
+	ent.renderfx = RF_DISTORTION;
+#endif
+
+	trap_R_AddRefEntityToScene( &ent );
+}
+
+//distortion trail effect for rockets -rww
+/*
+static void CG_DistortionTrail( centity_t *cent )
+{
+	vec3_t fwd;
+	vec3_t pos;
+	float overallScale = 4.0f;
+
+	VectorCopy(cent->currentState.pos.trDelta, fwd);
+	VectorNormalize(fwd);
+
+	VectorMA(cent->lerpOrigin, -8.0f*overallScale, fwd, pos);
+	CG_CreateDistortionTrailPart(cent, 0.5f*overallScale, pos);
+	VectorMA(cent->lerpOrigin, -12.0f*overallScale, fwd, pos);
+	CG_CreateDistortionTrailPart(cent, 0.6f*overallScale, pos);
+	VectorMA(cent->lerpOrigin, -16.0f*overallScale, fwd, pos);
+	CG_CreateDistortionTrailPart(cent, 0.7f*overallScale, pos);
+	VectorMA(cent->lerpOrigin, -20.0f*overallScale, fwd, pos);
+	CG_CreateDistortionTrailPart(cent, 0.8f*overallScale, pos);
+	VectorMA(cent->lerpOrigin, -30.0f*overallScale, fwd, pos);
+	CG_CreateDistortionTrailPart(cent, 0.9f*overallScale, pos);
+	VectorMA(cent->lerpOrigin, -40.0f*overallScale, fwd, pos);
+	CG_CreateDistortionTrailPart(cent, 1.0f*overallScale, pos);
+}
+*/
+
+/*
+===============
+CG_Missile
+===============
+*/
+static void CG_Missile( centity_t *cent ) {
+	refEntity_t			ent;
+	entityState_t		*s1;
+	const weaponInfo_t		*weapon;
+//	int	col;
+
+	s1 = &cent->currentState;
+	if ( s1->weapon > WP_NUM_WEAPONS && s1->weapon != G2_MODEL_PART ) {
+		s1->weapon = 0;
+	}
+
+	if (cent->ghoul2 && s1->weapon == G2_MODEL_PART)
+	{
+		weapon = &cg_weapons[WP_SABER];
+	}
+	else
+	{
+		weapon = &cg_weapons[s1->weapon];
+	}
+
+	if (cent->currentState.eFlags & EF_RADAROBJECT)
+	{
+		CG_AddRadarEnt(cent);
+	}
+
+	if (s1->weapon == WP_SABER)
+	{
+		if ((cent->currentState.modelindex != cent->serverSaberHitIndex || !cent->ghoul2) && !(s1->eFlags & EF_NODRAW))
+		{ //no g2, or server changed the model we are using
+			const char *saberModel = CG_ConfigString( CS_MODELS+cent->currentState.modelindex );
+
+			cent->serverSaberHitIndex = cent->currentState.modelindex;
+
+			if (cent->ghoul2)
+			{ //clean if we already have one (because server changed model string index)
+				trap_G2API_CleanGhoul2Models(&(cent->ghoul2));
+				cent->ghoul2 = 0;
+			}
+
+			if (saberModel && saberModel[0])
+			{
+				trap_G2API_InitGhoul2Model(&cent->ghoul2, saberModel, 0, 0, 0, 0, 0);
+			}
+			else
+			{
+				trap_G2API_InitGhoul2Model(&cent->ghoul2, "models/weapons2/saber/saber_w.glm", 0, 0, 0, 0, 0);
+			}
+			return;
+		}
+		else if (s1->eFlags & EF_NODRAW)
+		{
+			return;
+		}
+	}
+
+	if (cent->ghoul2)
+	{ //give us a proper radius
+		ent.radius = cent->currentState.g2radius;
+	}
+
+	// calculate the axis
+	VectorCopy( s1->angles, cent->lerpAngles);
+
+	if ( s1->otherEntityNum2 && s1->weapon != WP_SABER )
+	{//using an over-ridden trail effect!
+		vec3_t forward;
+
+		if ( VectorNormalize2( cent->currentState.pos.trDelta, forward ) == 0.0f )
+		{
+			forward[2] = 1.0f;
+		}
+		if ((s1->eFlags&EF_JETPACK_ACTIVE)//hack so we know we're a vehicle Weapon shot
+			&& (g_vehWeaponInfo[s1->otherEntityNum2].iShotFX
+				|| g_vehWeaponInfo[s1->otherEntityNum2].iModel != NULL_HANDLE) )
+		{ //a vehicle with an override for the weapon trail fx or model
+			trap_FX_PlayEffectID( g_vehWeaponInfo[s1->otherEntityNum2].iShotFX, cent->lerpOrigin, forward, -1, -1 );
+			if ( g_vehWeaponInfo[s1->otherEntityNum2].iLoopSound )
+			{
+				vec3_t	velocity;
+				BG_EvaluateTrajectoryDelta( &cent->currentState.pos, cg.time, velocity );
+				trap_S_AddLoopingSound( cent->currentState.number, cent->lerpOrigin, velocity, g_vehWeaponInfo[s1->otherEntityNum2].iLoopSound );
+			}
+			//add custom model
+			if ( g_vehWeaponInfo[s1->otherEntityNum2].iModel == NULL_HANDLE )
+			{
+				return;
+			}
+		}
+		else
+		{//a regular missile
+			trap_FX_PlayEffectID( cgs.gameEffects[s1->otherEntityNum2], cent->lerpOrigin, forward, -1, -1 );
+			if ( s1->loopSound )
+			{
+				vec3_t	velocity;
+				BG_EvaluateTrajectoryDelta( &cent->currentState.pos, cg.time, velocity );
+				trap_S_AddLoopingSound( cent->currentState.number, cent->lerpOrigin, velocity, s1->loopSound );
+			}
+			//FIXME: if has a custom model, too, then set it and do rest of code below?
+			return;
+		}
+	}
+	else if ( cent->currentState.eFlags & EF_ALT_FIRING )
+	{
+		// add trails
+		if ( weapon->altMissileTrailFunc )  
+		{
+			weapon->altMissileTrailFunc( cent, weapon );
+		}
+
+		// add dynamic light
+		if ( weapon->altMissileDlight ) 
+		{
+			trap_R_AddLightToScene(cent->lerpOrigin, weapon->altMissileDlight, 
+				weapon->altMissileDlightColor[0], weapon->altMissileDlightColor[1], weapon->altMissileDlightColor[2] );
+		}
+
+		// add missile sound
+		if ( weapon->altMissileSound ) {
+			vec3_t	velocity;
+
+			BG_EvaluateTrajectoryDelta( &cent->currentState.pos, cg.time, velocity );
+
+			trap_S_AddLoopingSound( cent->currentState.number, cent->lerpOrigin, velocity, weapon->altMissileSound );
+		}
+
+		//Don't draw something without a model
+		if ( weapon->altMissileModel == NULL_HANDLE )
+			return;
+	}
+	else
+	{
+		// add trails
+		if ( weapon->missileTrailFunc )  
+		{
+			weapon->missileTrailFunc( cent, weapon );
+		}
+
+		// add dynamic light
+		if ( weapon->missileDlight ) 
+		{
+			trap_R_AddLightToScene(cent->lerpOrigin, weapon->missileDlight, 
+				weapon->missileDlightColor[0], weapon->missileDlightColor[1], weapon->missileDlightColor[2] );
+		}
+
+		// add missile sound
+		if ( weapon->missileSound ) 
+		{
+			vec3_t	velocity;
+
+			BG_EvaluateTrajectoryDelta( &cent->currentState.pos, cg.time, velocity );
+
+			trap_S_AddLoopingSound( cent->currentState.number, cent->lerpOrigin, velocity, weapon->missileSound );
+		}
+
+		//Don't draw something without a model
+		if ( weapon->missileModel == NULL_HANDLE && s1->weapon != WP_SABER && s1->weapon != G2_MODEL_PART ) //saber uses ghoul2 model, doesn't matter
+			return;
+	}
+
+	// create the render entity
+	memset (&ent, 0, sizeof(ent));
+	VectorCopy( cent->lerpOrigin, ent.origin);
+	VectorCopy( cent->lerpOrigin, ent.oldorigin);
+/*
+Ghoul2 Insert Start
+*/
+	CG_SetGhoul2Info(&ent, cent);  
+
+/*
+Ghoul2 Insert End
+*/
+
+	// flicker between two skins
+	ent.skinNum = cg.clientFrame & 1;
+	ent.renderfx = /*weapon->missileRenderfx | */RF_NOSHADOW;
+
+	if ( !(s1->eFlags&EF_JETPACK_ACTIVE) )
+	{
+		if (s1->weapon != WP_SABER && s1->weapon != G2_MODEL_PART)
+		{
+			//if ( cent->currentState.eFlags | EF_ALT_FIRING )
+			//rww - why was this like this?
+			if ( cent->currentState.eFlags & EF_ALT_FIRING )
+			{
+				ent.hModel = weapon->altMissileModel;
+			}
+			else
+			{
+				ent.hModel = weapon->missileModel;
+			}
+		}
+	}
+	//add custom model
+	else
+	{
+		if ( g_vehWeaponInfo[s1->otherEntityNum2].iModel != NULL_HANDLE )
+		{
+			ent.hModel = g_vehWeaponInfo[s1->otherEntityNum2].iModel;
+		}
+		else
+		{//wtf?  how did we get here?
+			return;
+		}
+	}
+
+	// spin as it moves
+	if ( s1->apos.trType != TR_INTERPOLATE )
+	{
+		// convert direction of travel into axis
+		if ( VectorNormalize2( s1->pos.trDelta, ent.axis[0] ) == 0 ) {
+			ent.axis[0][2] = 1;
+		}
+
+		// spin as it moves
+		if ( s1->pos.trType != TR_STATIONARY ) 
+		{
+			if ( s1->eFlags & EF_MISSILE_STICK )
+			{
+				RotateAroundDirection( ent.axis, cg.time * 0.5f );//Did this so regular missiles don't get broken
+			}
+			else
+			{
+				RotateAroundDirection( ent.axis, cg.time * 0.25f );//JFM:FLOAT FIX
+			}
+		} 
+		else 
+		{
+			if ( s1->eFlags & EF_MISSILE_STICK )
+			{
+				RotateAroundDirection( ent.axis, (float)s1->pos.trTime * 0.5f );
+			}
+			else
+			{
+				RotateAroundDirection( ent.axis, (float)s1->time );
+			}
+		}
+	}
+	else
+	{
+		AnglesToAxis( cent->lerpAngles, ent.axis );
+	}
+
+	if (s1->weapon == WP_SABER)
+	{
+		ent.radius = s1->g2radius;
+	}
+
+	// add to refresh list, possibly with quad glow
+	CG_AddRefEntityWithPowerups( &ent, s1, TEAM_FREE );
+
+	if (s1->weapon == WP_SABER && cgs.gametype == GT_JEDIMASTER)
+	{ //in jedimaster always make the saber glow when on the ground
+		vec3_t org;
+		float wv;
+		int i;
+		addspriteArgStruct_t fxSArgs;
+		//refEntity_t sRef;
+		//memcpy( &sRef, &ent, sizeof( sRef ) );
+
+		ent.customShader = cgs.media.solidWhite;
+		ent.renderfx = RF_RGB_TINT;
+		wv = sin( cg.time * 0.003f ) * 0.08f + 0.1f;
+		ent.shaderRGBA[0] = wv * 255;
+		ent.shaderRGBA[1] = wv * 255;
+		ent.shaderRGBA[2] = wv * 0;
+		trap_R_AddRefEntityToScene (&ent);
+
+		for ( i = -4; i < 10; i += 1 )
+		{
+			VectorMA( ent.origin, -i, ent.axis[2], org );
+
+			VectorCopy(org, fxSArgs.origin);
+			VectorClear(fxSArgs.vel);
+			VectorClear(fxSArgs.accel);
+			fxSArgs.scale = 5.5f;
+			fxSArgs.dscale = 5.5f;
+			fxSArgs.sAlpha = wv;
+			fxSArgs.eAlpha = wv;
+			fxSArgs.rotation = 0.0f;
+			fxSArgs.bounce = 0.0f;
+			fxSArgs.life = 1.0f;
+			fxSArgs.shader = cgs.media.yellowDroppedSaberShader;
+			fxSArgs.flags = 0x08000000;
+
+			//trap_FX_AddSprite( org, NULL, NULL, 5.5f, 5.5f, wv, wv, 0.0f, 0.0f, 1.0f, cgs.media.yellowSaberGlowShader, 0x08000000 );
+			trap_FX_AddSprite(&fxSArgs);
+		}
+
+		if (cgs.gametype == GT_JEDIMASTER)
+		{
+			ent.shaderRGBA[0] = 255;
+			ent.shaderRGBA[1] = 255;
+			ent.shaderRGBA[2] = 0;
+
+			ent.renderfx |= RF_DEPTHHACK;
+			ent.customShader = cgs.media.forceSightBubble;
+		
+			trap_R_AddRefEntityToScene( &ent );
+		}
+	}
+
+	if ( s1->eFlags & EF_FIRING )
+	{//special code for adding the beam to the attached tripwire mine
+		vec3_t	beamOrg;
+
+		VectorMA( ent.origin, 8, ent.axis[0], beamOrg );// forward
+		trap_FX_PlayEffectID( cgs.effects.mTripMineLaster, beamOrg, ent.axis[0], -1, -1 );
+	}
+}
+
+int	CG_BMS_START = 0;
+int	CG_BMS_MID = 1;
+int	CG_BMS_END = 2;
+
+/*
+-------------------------
+CG_PlayDoorLoopSound
+-------------------------
+*/
+
+void CG_PlayDoorLoopSound( centity_t *cent )
+{
+	sfxHandle_t	sfx;
+	const char *soundSet;
+	vec3_t	origin;
+	float	*v;
+
+	if ( !cent->currentState.soundSetIndex )
+	{
+		return;
+	}
+
+	soundSet = CG_ConfigString( CS_AMBIENT_SET + cent->currentState.soundSetIndex );
+
+	if (!soundSet || !soundSet[0])
+	{
+		return;
+	}
+
+	sfx = trap_AS_GetBModelSound( soundSet, CG_BMS_MID );
+
+	if ( sfx == -1 )
+	{
+		return;
+	}
+
+	if (cent->currentState.eType == ET_MOVER) //shouldn't be in here otherwise, but just in case.
+	{
+		v = cgs.inlineModelMidpoints[ cent->currentState.modelindex ];
+		VectorAdd( cent->lerpOrigin, v, origin );
+	}
+	else
+	{
+		VectorCopy(cent->lerpOrigin, origin);
+	}
+
+	//ent->s.loopSound = sfx;
+	CG_S_AddRealLoopingSound(cent->currentState.number, origin, vec3_origin, sfx);
+}
+
+/*
+-------------------------
+CG_PlayDoorSound
+-------------------------
+*/
+
+void CG_PlayDoorSound( centity_t *cent, int type )
+{
+	sfxHandle_t	sfx;
+	const char *soundSet;
+
+	if ( !cent->currentState.soundSetIndex )
+	{
+		return;
+	}
+
+	soundSet = CG_ConfigString( CS_AMBIENT_SET + cent->currentState.soundSetIndex );
+
+	if (!soundSet || !soundSet[0])
+	{
+		return;
+	}
+
+	sfx = trap_AS_GetBModelSound( soundSet, type );
+
+	if ( sfx == -1 )
+	{
+		return;
+	}
+
+	trap_S_StartSound( NULL, cent->currentState.number, CHAN_AUTO, sfx );
+}
+
+/*
+===============
+CG_Mover
+===============
+*/
+static void CG_Mover( centity_t *cent ) {
+	refEntity_t			ent;
+	entityState_t		*s1;
+
+	s1 = &cent->currentState;
+
+	// create the render entity
+	memset (&ent, 0, sizeof(ent));
+
+	if ( (cent->currentState.eFlags2&EF2_HYPERSPACE) )
+	{//I'm the hyperspace brush
+		qboolean drawMe = qfalse;
+		if ( cg.predictedPlayerState.m_iVehicleNum
+			&& cg.predictedVehicleState.hyperSpaceTime
+			&& (cg.time-cg.predictedVehicleState.hyperSpaceTime) < HYPERSPACE_TIME
+			&& (cg.time-cg.predictedVehicleState.hyperSpaceTime) > 1000 )
+		{
+			if ( (cg.predictedVehicleState.eFlags2&EF2_HYPERSPACE) )
+			{//actually hyperspacing now
+				float timeFrac = ((float)(cg.time-cg.predictedVehicleState.hyperSpaceTime-1000))/(HYPERSPACE_TIME-1000);
+				if ( timeFrac < (HYPERSPACE_TELEPORT_FRAC+0.1f) )
+				{//still in hyperspace or just popped out
+					const float	alpha = timeFrac<0.5f?timeFrac/0.5f:1.0f;
+					drawMe = qtrue;
+					VectorMA( cg.refdef.vieworg, 1000.0f+((1.0f-timeFrac)*1000.0f), cg.refdef.viewaxis[0], cent->lerpOrigin );
+					VectorSet( cent->lerpAngles, cg.refdef.viewangles[PITCH], cg.refdef.viewangles[YAW]-90.0f, 0 );//cos( ( cg.time + 1000 ) *  scale ) * 4 );
+					ent.shaderRGBA[0] = ent.shaderRGBA[1] = ent.shaderRGBA[2] = 255;
+					ent.shaderRGBA[3] = alpha*255;
+				}
+			}
+		}
+		if ( !drawMe )
+		{//else, never draw
+			return;
+		}
+	}
+
+	if (cent->currentState.eFlags & EF_RADAROBJECT)
+	{
+		CG_AddRadarEnt(cent);
+	}
+
+	VectorCopy( cent->lerpOrigin, ent.origin);
+	VectorCopy( cent->lerpOrigin, ent.oldorigin);
+	AnglesToAxis( cent->lerpAngles, ent.axis );
+
+	ent.renderfx = RF_NOSHADOW;
+/*
+Ghoul2 Insert Start
+*/
+
+	CG_SetGhoul2Info(&ent, cent);  
+/*
+Ghoul2 Insert End
+*/
+	// flicker between two skins (FIXME?)
+	ent.skinNum = ( cg.time >> 6 ) & 1;
+
+	// get the model, either as a bmodel or a modelindex
+	if ( s1->solid == SOLID_BMODEL ) 
+	{
+		ent.hModel = cgs.inlineDrawModel[s1->modelindex];
+	} 
+	else 
+	{
+		ent.hModel = cgs.gameModels[s1->modelindex];
+	}
+
+	if ( s1->eFlags & EF_SHADER_ANIM )
+	{
+		ent.renderfx|=RF_SETANIMINDEX;
+		ent.skinNum = s1->frame;
+		//ent.shaderTime = cg.time*0.001f - s1->frame/s1->time;//NOTE: s1->time is number of frames
+	}
+
+	// add to refresh list
+	trap_R_AddRefEntityToScene(&ent);
+
+	// add the secondary model
+	if ( s1->modelindex2 ) 
+	{
+		ent.skinNum = 0;
+		ent.hModel = cgs.gameModels[s1->modelindex2];
+		if (s1->iModelScale)
+		{ //custom model2 scale
+			ent.modelScale[0] = ent.modelScale[1] = ent.modelScale[2] = s1->iModelScale/100.0f;
+			ScaleModelAxis(&ent);
+		}
+		trap_R_AddRefEntityToScene(&ent);
+	}
+
+}
+
+/*
+===============
+CG_Beam
+
+Also called as an event
+===============
+*/
+void CG_Beam( centity_t *cent ) {
+	refEntity_t			ent;
+	entityState_t		*s1;
+
+	s1 = &cent->currentState;
+
+	// create the render entity
+	memset (&ent, 0, sizeof(ent));
+	VectorCopy( s1->pos.trBase, ent.origin );
+	VectorCopy( s1->origin2, ent.oldorigin );
+	AxisClear( ent.axis );
+	ent.reType = RT_BEAM;
+
+	ent.renderfx = RF_NOSHADOW;
+/*
+Ghoul2 Insert Start
+*/
+	CG_SetGhoul2Info(&ent, cent);  
+
+/*
+Ghoul2 Insert End
+*/
+	// add to refresh list
+	trap_R_AddRefEntityToScene(&ent);
+}
+
+
+/*
+===============
+CG_Portal
+===============
+*/
+static void CG_Portal( centity_t *cent ) {
+	refEntity_t			ent;
+	entityState_t		*s1;
+
+	s1 = &cent->currentState;
+
+	// create the render entity
+	memset (&ent, 0, sizeof(ent));
+	VectorCopy( cent->lerpOrigin, ent.origin );
+	VectorCopy( s1->origin2, ent.oldorigin );
+	ByteToDir( s1->eventParm, ent.axis[0] );
+	PerpendicularVector( ent.axis[1], ent.axis[0] );
+
+	// negating this tends to get the directions like they want
+	// we really should have a camera roll value
+	VectorSubtract( vec3_origin, ent.axis[1], ent.axis[1] );
+
+	CrossProduct( ent.axis[0], ent.axis[1], ent.axis[2] );
+	ent.reType = RT_PORTALSURFACE;
+	ent.oldframe = s1->powerups;
+	ent.frame = s1->frame;		// rotation speed
+	ent.skinNum = s1->clientNum/256.0 * 360;	// roll offset
+/*
+Ghoul2 Insert Start
+*/
+	CG_SetGhoul2Info(&ent, cent);  
+/*
+Ghoul2 Insert End
+*/
+	// add to refresh list
+	trap_R_AddRefEntityToScene(&ent);
+}
+
+
+/*
+=========================
+CG_AdjustPositionForMover
+
+Also called by client movement prediction code
+=========================
+*/
+void CG_AdjustPositionForMover( const vec3_t in, int moverNum, int fromTime, int toTime, vec3_t out ) {
+	centity_t	*cent;
+	vec3_t	oldOrigin, origin, deltaOrigin;
+	vec3_t	oldAngles, angles, deltaAngles;
+
+	if ( moverNum <= 0 || moverNum >= ENTITYNUM_MAX_NORMAL ) {
+		VectorCopy( in, out );
+		return;
+	}
+
+	cent = &cg_entities[ moverNum ];
+	if ( cent->currentState.eType != ET_MOVER ) {
+		VectorCopy( in, out );
+		return;
+	}
+
+	BG_EvaluateTrajectory( &cent->currentState.pos, fromTime, oldOrigin );
+	BG_EvaluateTrajectory( &cent->currentState.apos, fromTime, oldAngles );
+
+	BG_EvaluateTrajectory( &cent->currentState.pos, toTime, origin );
+	BG_EvaluateTrajectory( &cent->currentState.apos, toTime, angles );
+
+	VectorSubtract( origin, oldOrigin, deltaOrigin );
+	VectorSubtract( angles, oldAngles, deltaAngles );
+
+	VectorAdd( in, deltaOrigin, out );
+
+	// FIXME: origin change when on a rotating object
+}
+
+/*
+=============================
+CG_InterpolateEntityPosition
+=============================
+*/
+static void CG_InterpolateEntityPosition( centity_t *cent ) {
+	vec3_t		current, next;
+	float		f;
+
+	// it would be an internal error to find an entity that interpolates without
+	// a snapshot ahead of the current one
+	if ( cg.nextSnap == NULL ) {
+		CG_Error( "CG_InterpoateEntityPosition: cg.nextSnap == NULL" );
+	}
+
+	f = cg.frameInterpolation;
+
+	// this will linearize a sine or parabolic curve, but it is important
+	// to not extrapolate player positions if more recent data is available
+	BG_EvaluateTrajectory( &cent->currentState.pos, cg.snap->serverTime, current );
+	BG_EvaluateTrajectory( &cent->nextState.pos, cg.nextSnap->serverTime, next );
+
+	cent->lerpOrigin[0] = current[0] + f * ( next[0] - current[0] );
+	cent->lerpOrigin[1] = current[1] + f * ( next[1] - current[1] );
+	cent->lerpOrigin[2] = current[2] + f * ( next[2] - current[2] );
+
+	BG_EvaluateTrajectory( &cent->currentState.apos, cg.snap->serverTime, current );
+	BG_EvaluateTrajectory( &cent->nextState.apos, cg.nextSnap->serverTime, next );
+
+	cent->lerpAngles[0] = LerpAngle( current[0], next[0], f );
+	cent->lerpAngles[1] = LerpAngle( current[1], next[1], f );
+	cent->lerpAngles[2] = LerpAngle( current[2], next[2], f );
+}
+
+/*
+===============
+CG_CalcEntityLerpPositions
+
+===============
+*/
+void CG_CalcEntityLerpPositions( centity_t *cent ) {
+	qboolean goAway = qfalse;
+
+	// if this player does not want to see extrapolated players
+	if ( !cg_smoothClients.integer ) {
+		// make sure the clients use TR_INTERPOLATE
+		if ( cent->currentState.number < MAX_CLIENTS ) {
+			cent->currentState.pos.trType = TR_INTERPOLATE;
+			cent->nextState.pos.trType = TR_INTERPOLATE;
+		}
+	}
+
+	if (cg.predictedPlayerState.m_iVehicleNum &&
+		cg.predictedPlayerState.m_iVehicleNum == cent->currentState.number &&
+		cent->currentState.eType == ET_NPC && cent->currentState.NPC_class == CLASS_VEHICLE)
+	{ //special case for vehicle we are riding
+		centity_t *veh = &cg_entities[cg.predictedPlayerState.m_iVehicleNum];
+
+		if (veh->currentState.owner == cg.predictedPlayerState.clientNum)
+		{ //only do this if the vehicle is pilotted by this client and predicting properly
+			BG_EvaluateTrajectory( &cent->currentState.pos, cg.time, cent->lerpOrigin );
+			BG_EvaluateTrajectory( &cent->currentState.apos, cg.time, cent->lerpAngles );
+			return;
+		}
+	}
+
+	if ( cent->interpolate && cent->currentState.pos.trType == TR_INTERPOLATE ) {
+		CG_InterpolateEntityPosition( cent );
+		return;
+	}
+
+	// first see if we can interpolate between two snaps for
+	// linear extrapolated clients
+	if ( cent->interpolate && cent->currentState.pos.trType == TR_LINEAR_STOP &&
+											cent->currentState.number < MAX_CLIENTS) {
+		CG_InterpolateEntityPosition( cent );
+		goAway = qtrue;
+	}
+	else if (cent->interpolate &&
+		cent->currentState.eType == ET_NPC && cent->currentState.NPC_class == CLASS_VEHICLE)
+	{
+		CG_InterpolateEntityPosition( cent );
+		goAway = qtrue;
+	}
+	else
+	{
+		// just use the current frame and evaluate as best we can
+		BG_EvaluateTrajectory( &cent->currentState.pos, cg.time, cent->lerpOrigin );
+		BG_EvaluateTrajectory( &cent->currentState.apos, cg.time, cent->lerpAngles );
+	}
+
+#if 0
+	if (cent->hasRagOffset && cent->ragOffsetTime < cg.time)
+	{ //take all of the offsets from last frame and normalize the total direction and add it in
+		vec3_t slideDir;
+		vec3_t preOffset;
+		vec3_t addedOffset;
+		vec3_t	playerMins = {-15, -15, DEFAULT_MINS_2};
+		vec3_t	playerMaxs = {15, 15, DEFAULT_MAXS_2};
+		trace_t tr;
+
+		//VectorSubtract(cent->lerpOrigin, callData->bonePos, slideDir);
+		VectorCopy(cent->ragOffsets, slideDir);
+		VectorNormalize(slideDir);
+
+		//Store it in case we want to go back
+		VectorCopy(cent->lerpOriginOffset, preOffset);
+
+		//just add a little at a time
+		VectorMA(cent->lerpOriginOffset, 0.4f, slideDir, cent->lerpOriginOffset);
+
+		if (VectorLength(cent->lerpOriginOffset) > 10.0f)
+		{ //don't go too far away
+			VectorCopy(preOffset, cent->lerpOriginOffset);
+		}
+		else
+		{
+			//Let's trace there to make sure we can make it
+			VectorAdd(cent->lerpOrigin, cent->lerpOriginOffset, addedOffset);
+			CG_Trace(&tr, cent->lerpOrigin, playerMins, playerMaxs, addedOffset, cent->currentState.number, MASK_PLAYERSOLID);
+
+			if (tr.startsolid || tr.allsolid || tr.fraction != 1.0f)
+			{ //can't get there
+				VectorCopy(preOffset, cent->lerpOriginOffset);
+			}
+			else
+			{
+				/*
+				if (cent->lerpOriginOffset[2] > 4.0f)
+				{ //don't go too far off the ground
+					cent->lerpOriginOffset[2] = 4.0f;
+				}
+				*/
+				//I guess I just don't want this happening.
+				cent->lerpOriginOffset[2] = 0.0f;
+			}
+		}
+
+		//done with this bit
+		cent->hasRagOffset = qfalse;
+		VectorClear(cent->ragOffsets);
+		cent->ragOffsetTime = cg.time + 50;
+	}
+
+	//See if we should add in the offset for ragdoll
+	if (cent->isRagging && ((cent->currentState.eFlags & EF_DEAD) || (cent->currentState.eFlags & EF_RAG)))
+	{
+		VectorAdd(cent->lerpOrigin, cent->lerpOriginOffset, cent->lerpOrigin);
+	}
+#endif
+
+	if (goAway)
+	{
+		return;
+	}
+
+	// adjust for riding a mover if it wasn't rolled into the predicted
+	// player state
+	if ( cent->currentState.number != cg.predictedPlayerState.clientNum ) {
+		CG_AdjustPositionForMover( cent->lerpOrigin, cent->currentState.groundEntityNum, 
+		cg.snap->serverTime, cg.time, cent->lerpOrigin );
+	}
+}
+
+/*
+===============
+CG_TeamBase
+===============
+*/
+static void CG_TeamBase( centity_t *cent ) {
+	refEntity_t model;
+	if ( cgs.gametype == GT_CTF || cgs.gametype == GT_CTY ) {
+		// show the flag base
+		memset(&model, 0, sizeof(model));
+		model.reType = RT_MODEL;
+		VectorCopy( cent->lerpOrigin, model.lightingOrigin );
+		VectorCopy( cent->lerpOrigin, model.origin );
+		AnglesToAxis( cent->currentState.angles, model.axis );
+		if ( cent->currentState.modelindex == TEAM_RED ) {
+			model.hModel = cgs.media.redFlagBaseModel;
+		}
+		else if ( cent->currentState.modelindex == TEAM_BLUE ) {
+			model.hModel = cgs.media.blueFlagBaseModel;
+		}
+		else {
+			model.hModel = cgs.media.neutralFlagBaseModel;
+		}
+
+		if (cent->currentState.eType != ET_NPC)
+		{ //do not do this for g2animents
+			trap_R_AddRefEntityToScene( &model );
+		}
+	}
+}
+
+void CG_G2Animated( centity_t *cent );
+
+static void CG_FX( centity_t *cent ) 
+{
+	vec3_t			fxDir;
+	int				efxIndex = 0;
+	entityState_t	*s1;
+	const char		*s;
+
+	if (cent->miscTime > cg.time)
+	{
+		return;
+	}
+
+	s1 = &cent->currentState;
+
+	if (!s1)
+	{
+		return;
+	}
+
+	if (s1->modelindex2 == FX_STATE_OFF)
+	{	// fx not active
+		return;
+	}
+
+	if (s1->modelindex2 < FX_STATE_ONE_SHOT_LIMIT)
+	{	// fx is single shot
+		if (cent->muzzleFlashTime == s1->modelindex2)
+		{
+			return;
+		}
+
+		cent->muzzleFlashTime = s1->modelindex2;
+	}
+
+	cent->miscTime = cg.time + s1->speed + random() * s1->time;
+
+	AngleVectors(s1->angles, fxDir, 0, 0);
+	
+	if (!fxDir[0] && !fxDir[1] && !fxDir[2])
+	{
+		fxDir[1] = 1;
+	}
+
+	if ( cgs.gameEffects[ s1->modelindex ] )
+	{
+		efxIndex = cgs.gameEffects[s1->modelindex];
+	}
+	else
+	{
+		s = CG_ConfigString( CS_EFFECTS + s1->modelindex );
+		if (s && s[0])
+		{
+			efxIndex = trap_FX_RegisterEffect(s);
+			cgs.gameEffects[s1->modelindex] = efxIndex;
+		}
+	}
+
+	if (efxIndex)
+	{
+		if (s1->isPortalEnt)
+		{
+			trap_FX_PlayPortalEffectID(efxIndex, cent->lerpOrigin, fxDir, -1, -1 );
+		}
+		else
+		{
+			trap_FX_PlayEffectID(efxIndex, cent->lerpOrigin, fxDir, -1, -1 );
+		}
+	}
+
+
+}
+
+
+/*
+===============
+CG_AddCEntity
+
+===============
+*/
+static void CG_AddCEntity( centity_t *cent ) {
+	// event-only entities will have been dealt with already
+	if ( cent->currentState.eType >= ET_EVENTS ) {
+		return;
+	}
+
+	if (cg.predictedPlayerState.pm_type == PM_INTERMISSION)
+	{ //don't render anything then
+		if (cent->currentState.eType == ET_GENERAL ||
+			cent->currentState.eType == ET_PLAYER ||
+			cent->currentState.eType == ET_NPC ||
+			cent->currentState.eType == ET_INVISIBLE)
+		{
+			return;
+		}
+	}
+
+	// calculate the current origin
+	CG_CalcEntityLerpPositions( cent );
+
+	// add automatic effects
+	CG_EntityEffects( cent );
+/*
+Ghoul2 Insert Start
+*/
+
+	// add local sound set if any
+	if ( cent->currentState.soundSetIndex && cent->currentState.eType != ET_MOVER )
+	{
+		const char *soundSet = CG_ConfigString( CS_AMBIENT_SET + cent->currentState.soundSetIndex );
+
+		if (soundSet && soundSet[0])
+		{
+			trap_S_AddLocalSet(soundSet, cg.refdef.vieworg, cent->lerpOrigin, cent->currentState.number, cg.time);
+		}
+	}
+/*
+Ghoul2 Insert End
+*/
+	switch ( cent->currentState.eType ) {
+	default:
+		CG_Error( "Bad entity type: %i\n", cent->currentState.eType );
+		break;
+
+	case ET_FX:
+		CG_FX( cent );
+		break;
+
+	case ET_INVISIBLE:
+	case ET_PUSH_TRIGGER:
+	case ET_TELEPORT_TRIGGER:
+	case ET_TERRAIN:
+		break;
+	case ET_GENERAL:
+		CG_General( cent );
+		break;
+	case ET_PLAYER:
+		CG_Player( cent );
+		break;
+	case ET_ITEM:
+		CG_Item( cent );
+		break;
+	case ET_MISSILE:
+		CG_Missile( cent );
+		break;
+	case ET_SPECIAL:
+		CG_Special( cent );
+		break;
+	case ET_HOLOCRON:
+		CG_General( cent );
+		break;
+	case ET_MOVER:
+		CG_Mover( cent );
+		break;
+	case ET_BEAM:
+		CG_Beam( cent );
+		break;
+	case ET_PORTAL:
+		CG_Portal( cent );
+		break;
+	case ET_SPEAKER:
+		CG_Speaker( cent );
+		break;
+	case ET_NPC: //An entity that wants to be able to use ghoul2 humanoid (and other) anims. Like a player, but not.
+		CG_G2Animated( cent );
+		break;
+	case ET_TEAM:
+		CG_TeamBase( cent );
+		break;
+	case ET_BODY:
+		CG_General( cent );
+		break;
+	}
+}
+
+void CG_ManualEntityRender(centity_t *cent)
+{
+	CG_AddCEntity(cent);
+}
+
+/*
+===============
+CG_AddPacketEntities
+
+===============
+*/
+void CG_AddPacketEntities( qboolean isPortal ) {
+	int					num;
+	centity_t			*cent;
+	playerState_t		*ps;
+
+	if (isPortal)
+	{
+		for ( num = 0 ; num < cg.snap->numEntities ; num++ )
+		{
+			cent = &cg_entities[ cg.snap->entities[ num ].number ];
+
+			if (cent->currentState.isPortalEnt)
+			{
+				CG_AddCEntity( cent );
+			}
+		}
+		return;
+	}
+
+	// set cg.frameInterpolation
+	if ( cg.nextSnap ) {
+		int		delta;
+
+		delta = (cg.nextSnap->serverTime - cg.snap->serverTime);
+		if ( delta == 0 ) {
+			cg.frameInterpolation = 0;
+		} else {
+			cg.frameInterpolation = (float)( cg.time - cg.snap->serverTime ) / delta;
+		}
+	} else {
+		cg.frameInterpolation = 0;	// actually, it should never be used, because 
+									// no entities should be marked as interpolating
+	}
+
+	// the auto-rotating items will all have the same axis
+	cg.autoAngles[0] = 0;
+	cg.autoAngles[1] = ( cg.time & 2047 ) * 360 / 2048.0;
+	cg.autoAngles[2] = 0;
+
+	cg.autoAnglesFast[0] = 0;
+	cg.autoAnglesFast[1] = ( cg.time & 1023 ) * 360 / 1024.0f;
+	cg.autoAnglesFast[2] = 0;
+
+	AnglesToAxis( cg.autoAngles, cg.autoAxis );
+	AnglesToAxis( cg.autoAnglesFast, cg.autoAxisFast );
+
+	// Reset radar entities
+	cg.radarEntityCount = 0;
+	cg.bracketedEntityCount = 0;
+
+	// generate and add the entity from the playerstate
+	ps = &cg.predictedPlayerState;
+
+	CG_CheckPlayerG2Weapons(ps, &cg_entities[cg.predictedPlayerState.clientNum]);
+	BG_PlayerStateToEntityState( ps, &cg_entities[cg.predictedPlayerState.clientNum].currentState, qfalse );
+	
+	if (cg.predictedPlayerState.m_iVehicleNum)
+	{ //add the vehicle I'm riding first
+		//BG_PlayerStateToEntityState( &cg.predictedVehicleState, &cg_entities[cg.predictedPlayerState.m_iVehicleNum].currentState, qfalse );
+		//cg_entities[cg.predictedPlayerState.m_iVehicleNum].currentState.eType = ET_NPC;
+		centity_t *veh = &cg_entities[cg.predictedPlayerState.m_iVehicleNum];
+
+		if (veh->currentState.owner == cg.predictedPlayerState.clientNum)
+		{
+			BG_PlayerStateToEntityState( &cg.predictedVehicleState, &veh->currentState, qfalse );
+			veh->currentState.eType = ET_NPC;
+
+			veh->currentState.pos.trType = TR_INTERPOLATE;
+		}
+        CG_AddCEntity(veh);
+		veh->bodyHeight = cg.time; //indicate we have already been added
+	}
+
+	CG_AddCEntity( &cg_entities[cg.predictedPlayerState.clientNum] );
+
+	/*
+	// lerp the non-predicted value for lightning gun origins
+	CG_CalcEntityLerpPositions( &cg_entities[ cg.snap->ps.clientNum ] );
+	*/
+	//No longer have to do this.
+
+	// add each entity sent over by the server
+	for ( num = 0 ; num < cg.snap->numEntities ; num++ ) {
+		// Don't re-add ents that have been predicted.
+		if (cg.snap->entities[ num ].number != cg.snap->ps.clientNum)
+		{
+			cent = &cg_entities[ cg.snap->entities[ num ].number ];
+			if (cent->currentState.eType == ET_PLAYER &&
+				cent->currentState.m_iVehicleNum)
+			{ //add his veh first
+				int j = 0;
+
+				while (j < cg.snap->numEntities)
+				{
+					if (cg.snap->entities[j].number == cent->currentState.m_iVehicleNum)
+					{
+						centity_t *veh = &cg_entities[cg.snap->entities[j].number];
+
+						CG_AddCEntity(veh);
+						veh->bodyHeight = cg.time; //indicate we have already been added
+						break;
+					}
+
+					j++;
+				}
+			}
+			else if (cent->currentState.eType == ET_NPC &&
+				cent->currentState.m_iVehicleNum &&
+				cent->bodyHeight == cg.time)
+			{ //never add a vehicle with a pilot, his pilot entity will get him added first.
+				//if we were to add the vehicle after the pilot, the pilot's bolt would lag a frame behind.
+				continue;
+			}
+			CG_AddCEntity( cent );
+		}
+	}
+
+	for(num=0;num<cg_numpermanents;num++)
+	{
+		cent = cg_permanents[num];
+		if (cent->currentValid)
+		{
+			CG_AddCEntity( cent );
+		}
+	}
+}
+
+void CG_ROFF_NotetrackCallback( centity_t *cent, const char *notetrack)
+{
+	int i = 0, r = 0, objectID = 0, anglesGathered = 0, posoffsetGathered = 0;
+	char type[256];
+	char argument[512];
+	char addlArg[512];
+	char errMsg[256];
+	char t[64];
+	int addlArgs = 0;
+	vec3_t parsedAngles, parsedOffset, useAngles, useOrigin, forward, right, up;
+
+	if (!cent || !notetrack)
+	{
+		return;
+	}
+
+	//notetrack = "effect effects/explosion1.efx 0+0+64 0-0-1";
+
+	while (notetrack[i] && notetrack[i] != ' ')
+	{
+		type[i] = notetrack[i];
+		i++;
+	}
+
+	type[i] = '\0';
+
+	if (notetrack[i] != ' ')
+	{ //didn't pass in a valid notetrack type, or forgot the argument for it
+		return;
+	}
+
+	i++;
+
+	while (notetrack[i] && notetrack[i] != ' ')
+	{
+		argument[r] = notetrack[i];
+		r++;
+		i++;
+	}
+	argument[r] = '\0';
+
+	if (!r)
+	{
+		return;
+	}
+
+	if (notetrack[i] == ' ')
+	{ //additional arguments...
+		addlArgs = 1;
+
+		i++;
+		r = 0;
+		while (notetrack[i])
+		{
+			addlArg[r] = notetrack[i];
+			r++;
+			i++;
+		}
+		addlArg[r] = '\0';
+	}
+
+	if (strcmp(type, "effect") == 0)
+	{
+		if (!addlArgs)
+		{
+			//sprintf(errMsg, "Offset position argument for 'effect' type is invalid.");
+			//goto functionend;
+			VectorClear(parsedOffset);
+			goto defaultoffsetposition;
+		}
+
+		i = 0;
+
+		while (posoffsetGathered < 3)
+		{
+			r = 0;
+			while (addlArg[i] && addlArg[i] != '+' && addlArg[i] != ' ')
+			{
+				t[r] = addlArg[i];
+				r++;
+				i++;
+			}
+			t[r] = '\0';
+			i++;
+			if (!r)
+			{ //failure..
+				//sprintf(errMsg, "Offset position argument for 'effect' type is invalid.");
+				//goto functionend;
+				VectorClear(parsedOffset);
+				i = 0;
+				goto defaultoffsetposition;
+			}
+			parsedOffset[posoffsetGathered] = atof(t);
+			posoffsetGathered++;
+		}
+
+		if (posoffsetGathered < 3)
+		{
+			Com_sprintf(errMsg, sizeof(errMsg), "Offset position argument for 'effect' type is invalid.");
+			goto functionend;
+		}
+
+		i--;
+
+		if (addlArg[i] != ' ')
+		{
+			addlArgs = 0;
+		}
+
+defaultoffsetposition:
+
+		objectID = trap_FX_RegisterEffect(argument);
+
+		if (objectID)
+		{
+			if (addlArgs)
+			{ //if there is an additional argument for an effect it is expected to be XANGLE-YANGLE-ZANGLE
+				i++;
+				while (anglesGathered < 3)
+				{
+					r = 0;
+					while (addlArg[i] && addlArg[i] != '-')
+					{
+						t[r] = addlArg[i];
+						r++;
+						i++;
+					}
+					t[r] = '\0';
+					i++;
+
+					if (!r)
+					{ //failed to get a new part of the vector
+						anglesGathered = 0;
+						break;
+					}
+
+					parsedAngles[anglesGathered] = atof(t);
+					anglesGathered++;
+				}
+
+				if (anglesGathered)
+				{
+					VectorCopy(parsedAngles, useAngles);
+				}
+				else
+				{ //failed to parse angles from the extra argument provided..
+					VectorCopy(cent->lerpAngles, useAngles);
+				}
+			}
+			else
+			{ //if no constant angles, play in direction entity is facing
+				VectorCopy(cent->lerpAngles, useAngles);
+			}
+
+			AngleVectors(useAngles, forward, right, up);
+
+			VectorCopy(cent->lerpOrigin, useOrigin);
+
+			//forward
+			useOrigin[0] += forward[0]*parsedOffset[0];
+			useOrigin[1] += forward[1]*parsedOffset[0];
+			useOrigin[2] += forward[2]*parsedOffset[0];
+
+			//right
+			useOrigin[0] += right[0]*parsedOffset[1];
+			useOrigin[1] += right[1]*parsedOffset[1];
+			useOrigin[2] += right[2]*parsedOffset[1];
+
+			//up
+			useOrigin[0] += up[0]*parsedOffset[2];
+			useOrigin[1] += up[1]*parsedOffset[2];
+			useOrigin[2] += up[2]*parsedOffset[2];
+
+			trap_FX_PlayEffectID(objectID, useOrigin, useAngles, -1, -1);
+		}
+	}
+	else if (strcmp(type, "sound") == 0)
+	{
+		objectID = trap_S_RegisterSound(argument);
+		trap_S_StartSound(cent->lerpOrigin, cent->currentState.number, CHAN_BODY, objectID);
+	}
+	else if (strcmp(type, "loop") == 0)
+	{ //handled server-side
+		return;
+	}
+	//else if ...
+	else
+	{
+		if (type[0])
+		{
+			Com_Printf("^3Warning: \"%s\" is an invalid ROFF notetrack function\n", type);
+		}
+		else
+		{
+			Com_Printf("^3Warning: Notetrack is missing function and/or arguments\n");
+		}
+	}
+
+	return;
+
+functionend:
+	Com_Printf("^3Type-specific notetrack error: %s\n", errMsg);
+	return;
+}
+
+void CG_Cube( vec3_t mins, vec3_t maxs, vec3_t color, float alpha ) 
+{
+	vec3_t	rot={0,0,0};
+	int		vec[3];
+	int		axis, i;
+	addpolyArgStruct_t apArgs;
+
+	memset (&apArgs, 0, sizeof(apArgs));
+
+	for ( axis = 0, vec[0] = 0, vec[1] = 1, vec[2] = 2; axis < 3; axis++, vec[0]++, vec[1]++, vec[2]++ )
+	{
+		for ( i = 0; i < 3; i++ )
+		{
+			if ( vec[i] > 2 )
+			{
+				vec[i] = 0;
+			}
+		}
+
+		apArgs.p[0][vec[1]] = mins[vec[1]];
+		apArgs.p[0][vec[2]] = mins[vec[2]];
+
+		apArgs.p[1][vec[1]] = mins[vec[1]];
+		apArgs.p[1][vec[2]] = maxs[vec[2]];
+
+		apArgs.p[2][vec[1]] = maxs[vec[1]];
+		apArgs.p[2][vec[2]] = maxs[vec[2]];
+		
+		apArgs.p[3][vec[1]] = maxs[vec[1]];
+		apArgs.p[3][vec[2]] = mins[vec[2]];
+
+		//- face
+		apArgs.p[0][vec[0]] = apArgs.p[1][vec[0]] = apArgs.p[2][vec[0]] = apArgs.p[3][vec[0]] = mins[vec[0]];
+
+		apArgs.numVerts = 4;
+		apArgs.alpha1 = apArgs.alpha2 = alpha;
+		VectorCopy( color, apArgs.rgb1 );
+		VectorCopy( color, apArgs.rgb2 );
+		VectorCopy( rot, apArgs.rotationDelta );
+		apArgs.killTime = cg.frametime;
+		apArgs.shader = cgs.media.solidWhite;
+
+		trap_FX_AddPoly( &apArgs );
+
+		//+ face
+		apArgs.p[0][vec[0]] = apArgs.p[1][vec[0]] = apArgs.p[2][vec[0]] = apArgs.p[3][vec[0]] = maxs[vec[0]];
+
+		trap_FX_AddPoly( &apArgs );
+	}
+}
diff --git a/codemp/cgame/cg_event.c b/codemp/cgame/cg_event.c
new file mode 100644
index 0000000..feeff94
--- /dev/null
+++ b/codemp/cgame/cg_event.c
@@ -0,0 +1,3432 @@
+// Copyright (C) 1999-2000 Id Software, Inc.
+//
+// cg_event.c -- handle entity events at snapshot or playerstate transitions
+
+#include "cg_local.h"
+#include "fx_local.h"
+#include "../ui/ui_shared.h"
+#include "../ui/ui_public.h"
+
+// for the voice chats
+#include "../../ui/menudef.h"
+
+#include "../ghoul2/G2.h"
+//==========================================================================
+
+extern qboolean CG_VehicleWeaponImpact( centity_t *cent );
+extern qboolean CG_InFighter( void );
+extern qboolean CG_InATST( void );
+extern int cg_saberFlashTime;
+extern vec3_t cg_saberFlashPos;
+extern char *showPowersName[];
+
+extern int cg_siegeDeathTime;
+extern int cg_siegeDeathDelay;
+extern int cg_vehicleAmmoWarning;
+extern int cg_vehicleAmmoWarningTime;
+
+//I know, not siege, but...
+typedef enum
+{
+	TAUNT_TAUNT = 0,
+	TAUNT_BOW,
+	TAUNT_MEDITATE,
+	TAUNT_FLOURISH,
+	TAUNT_GLOAT
+};
+/*
+===================
+CG_PlaceString
+
+Also called by scoreboard drawing
+===================
+*/
+const char	*CG_PlaceString( int rank ) {
+	static char	str[64];
+	char	*s, *t;
+	// number extenstions, eg 1st, 2nd, 3rd, 4th etc.
+	// note that the rules are different for french, but by changing the required strip strings they seem to work
+	char sST[10];
+	char sND[10];
+	char sRD[10];
+	char sTH[10];
+	char sTiedFor[64];	// german is much longer, super safe...
+
+	trap_SP_GetStringTextString("MP_INGAME_NUMBER_ST",sST, sizeof(sST) );
+	trap_SP_GetStringTextString("MP_INGAME_NUMBER_ND",sND, sizeof(sND) );
+	trap_SP_GetStringTextString("MP_INGAME_NUMBER_RD",sRD, sizeof(sRD) );
+	trap_SP_GetStringTextString("MP_INGAME_NUMBER_TH",sTH, sizeof(sTH) );
+	trap_SP_GetStringTextString("MP_INGAME_TIED_FOR" ,sTiedFor,sizeof(sTiedFor) );
+	strcat(sTiedFor," ");	// save worrying about translators adding spaces or not
+
+	if ( rank & RANK_TIED_FLAG ) {
+		rank &= ~RANK_TIED_FLAG;
+		t = sTiedFor;//"Tied for ";
+	} else {
+		t = "";
+	}
+
+	if ( rank == 1 ) {
+		s = va("1%s",sST);//S_COLOR_BLUE "1st" S_COLOR_WHITE;		// draw in blue
+	} else if ( rank == 2 ) {
+		s = va("2%s",sND);//S_COLOR_RED "2nd" S_COLOR_WHITE;		// draw in red
+	} else if ( rank == 3 ) {
+		s = va("3%s",sRD);//S_COLOR_YELLOW "3rd" S_COLOR_WHITE;		// draw in yellow
+	} else if ( rank == 11 ) {
+		s = va("11%s",sTH);
+	} else if ( rank == 12 ) {
+		s = va("12%s",sTH);
+	} else if ( rank == 13 ) {
+		s = va("13%s",sTH);
+	} else if ( rank % 10 == 1 ) {
+		s = va("%i%s", rank,sST);
+	} else if ( rank % 10 == 2 ) {
+		s = va("%i%s", rank,sND);
+	} else if ( rank % 10 == 3 ) {
+		s = va("%i%s", rank,sRD);
+	} else {
+		s = va("%i%s", rank,sTH);
+	}
+
+	Com_sprintf( str, sizeof( str ), "%s%s", t, s );
+	return str;
+}
+
+qboolean CG_ThereIsAMaster(void);
+
+/*
+=============
+CG_Obituary
+=============
+*/
+static void CG_Obituary( entityState_t *ent ) {
+	int			mod;
+	int			target, attacker;
+	char		*message;
+	const char	*targetInfo;
+	const char	*attackerInfo;
+	char		targetName[32];
+	char		attackerName[32];
+	gender_t	gender;
+	clientInfo_t	*ci;
+
+
+	target = ent->otherEntityNum;
+	attacker = ent->otherEntityNum2;
+	mod = ent->eventParm;
+
+	if ( target < 0 || target >= MAX_CLIENTS ) {
+		CG_Error( "CG_Obituary: target out of range" );
+	}
+	ci = &cgs.clientinfo[target];
+
+	if ( attacker < 0 || attacker >= MAX_CLIENTS ) {
+		attacker = ENTITYNUM_WORLD;
+		attackerInfo = NULL;
+	} else {
+		attackerInfo = CG_ConfigString( CS_PLAYERS + attacker );
+	}
+
+	targetInfo = CG_ConfigString( CS_PLAYERS + target );
+	if ( !targetInfo ) {
+		return;
+	}
+	Q_strncpyz( targetName, Info_ValueForKey( targetInfo, "n" ), sizeof(targetName) - 2);
+	strcat( targetName, S_COLOR_WHITE );
+
+	// check for single client messages
+
+	switch( mod ) {
+	case MOD_SUICIDE:
+	case MOD_FALLING:
+	case MOD_CRUSH:
+	case MOD_WATER:
+	case MOD_SLIME:
+	case MOD_LAVA:
+	case MOD_TRIGGER_HURT:
+		message = "DIED_GENERIC";
+		break;
+	case MOD_TARGET_LASER:
+		message = "DIED_LASER";
+		break;
+	default:
+		message = NULL;
+		break;
+	}
+
+	// Attacker killed themselves.  Ridicule them for it.
+	if (attacker == target) {
+		gender = ci->gender;
+		switch (mod) {
+		case MOD_BRYAR_PISTOL:
+		case MOD_BRYAR_PISTOL_ALT:
+		case MOD_BLASTER:
+		case MOD_TURBLAST:
+		case MOD_DISRUPTOR:
+		case MOD_DISRUPTOR_SPLASH:
+		case MOD_DISRUPTOR_SNIPER:
+		case MOD_BOWCASTER:
+		case MOD_REPEATER:
+		case MOD_REPEATER_ALT:
+		case MOD_FLECHETTE:
+			if ( gender == GENDER_FEMALE )
+				message = "SUICIDE_SHOT_FEMALE";
+			else if ( gender == GENDER_NEUTER )
+				message = "SUICIDE_SHOT_GENDERLESS";
+			else
+				message = "SUICIDE_SHOT_MALE";
+			break;
+		case MOD_REPEATER_ALT_SPLASH:
+		case MOD_FLECHETTE_ALT_SPLASH:
+		case MOD_ROCKET:
+		case MOD_ROCKET_SPLASH:
+		case MOD_ROCKET_HOMING:
+		case MOD_ROCKET_HOMING_SPLASH:
+		case MOD_THERMAL:
+		case MOD_THERMAL_SPLASH:
+		case MOD_TRIP_MINE_SPLASH:
+		case MOD_TIMED_MINE_SPLASH:
+		case MOD_DET_PACK_SPLASH:
+		case MOD_VEHICLE:
+		case MOD_CONC:
+		case MOD_CONC_ALT:
+			if ( gender == GENDER_FEMALE )
+				message = "SUICIDE_EXPLOSIVES_FEMALE";
+			else if ( gender == GENDER_NEUTER )
+				message = "SUICIDE_EXPLOSIVES_GENDERLESS";
+			else
+				message = "SUICIDE_EXPLOSIVES_MALE";
+			break;
+		case MOD_DEMP2:
+			if ( gender == GENDER_FEMALE )
+				message = "SUICIDE_ELECTROCUTED_FEMALE";
+			else if ( gender == GENDER_NEUTER )
+				message = "SUICIDE_ELECTROCUTED_GENDERLESS";
+			else
+				message = "SUICIDE_ELECTROCUTED_MALE";
+			break;
+		case MOD_FALLING:
+			if ( gender == GENDER_FEMALE )
+				message = "SUICIDE_FALLDEATH_FEMALE";
+			else if ( gender == GENDER_NEUTER )
+				message = "SUICIDE_FALLDEATH_GENDERLESS";
+			else
+				message = "SUICIDE_FALLDEATH_MALE";
+			break;
+		default:
+			if ( gender == GENDER_FEMALE )
+				message = "SUICIDE_GENERICDEATH_FEMALE";
+			else if ( gender == GENDER_NEUTER )
+				message = "SUICIDE_GENERICDEATH_GENDERLESS";
+			else
+				message = "SUICIDE_GENERICDEATH_MALE";
+			break;
+		}
+	}
+
+	if (target != attacker && target < MAX_CLIENTS && attacker < MAX_CLIENTS)
+	{
+		goto clientkilled;
+	}
+
+	if (message) {
+		gender = ci->gender;
+
+		if (!message[0])
+		{
+			if ( gender == GENDER_FEMALE )
+				message = "SUICIDE_GENERICDEATH_FEMALE";
+			else if ( gender == GENDER_NEUTER )
+				message = "SUICIDE_GENERICDEATH_GENDERLESS";
+			else
+				message = "SUICIDE_GENERICDEATH_MALE";
+		}
+		message = (char *)CG_GetStringEdString("MP_INGAME", message);
+
+		CG_Printf( "%s %s\n", targetName, message);
+		return;
+	}
+
+clientkilled:
+
+	// check for kill messages from the current clientNum
+	if ( attacker == cg.snap->ps.clientNum ) {
+		char	*s;
+
+		if ( cgs.gametype < GT_TEAM && cgs.gametype != GT_DUEL && cgs.gametype != GT_POWERDUEL ) {
+			if (cgs.gametype == GT_JEDIMASTER &&
+				attacker < MAX_CLIENTS &&
+				!ent->isJediMaster &&
+				!cg.snap->ps.isJediMaster &&
+				CG_ThereIsAMaster())
+			{
+				char part1[512];
+				char part2[512];
+				trap_SP_GetStringTextString("MP_INGAME_KILLED_MESSAGE", part1, sizeof(part1));
+				trap_SP_GetStringTextString("MP_INGAME_JMKILLED_NOTJM", part2, sizeof(part2));
+				s = va("%s %s\n%s\n", part1, targetName, part2);
+			}
+			else if (cgs.gametype == GT_JEDIMASTER &&
+				attacker < MAX_CLIENTS &&
+				!ent->isJediMaster &&
+				!cg.snap->ps.isJediMaster)
+			{ //no JM, saber must be out
+				char part1[512];
+				trap_SP_GetStringTextString("MP_INGAME_KILLED_MESSAGE", part1, sizeof(part1));
+				/*
+				kmsg1 = "for 0 points.\nGo for the saber!";
+				strcpy(part2, kmsg1);
+
+				s = va("%s %s %s\n", part1, targetName, part2);
+				*/
+				s = va("%s %s\n", part1, targetName);
+			}
+			else if (cgs.gametype == GT_POWERDUEL)
+			{
+				s = "";
+			}
+			else
+			{
+				char sPlaceWith[256];
+				char sKilledStr[256];
+				trap_SP_GetStringTextString("MP_INGAME_PLACE_WITH",     sPlaceWith, sizeof(sPlaceWith));
+				trap_SP_GetStringTextString("MP_INGAME_KILLED_MESSAGE", sKilledStr, sizeof(sKilledStr));
+
+				s = va("%s %s.\n%s %s %i.", sKilledStr, targetName, 
+					CG_PlaceString( cg.snap->ps.persistant[PERS_RANK] + 1 ), 
+					sPlaceWith,
+					cg.snap->ps.persistant[PERS_SCORE] );
+			}
+		} else {
+			char sKilledStr[256];
+			trap_SP_GetStringTextString("MP_INGAME_KILLED_MESSAGE", sKilledStr, sizeof(sKilledStr));
+			s = va("%s %s", sKilledStr, targetName );
+		}
+		//if (!(cg_singlePlayerActive.integer && cg_cameraOrbit.integer)) {
+			CG_CenterPrint( s, SCREEN_HEIGHT * 0.30, BIGCHAR_WIDTH );
+		//} 
+		// print the text message as well
+	}
+
+	// check for double client messages
+	if ( !attackerInfo ) {
+		attacker = ENTITYNUM_WORLD;
+		strcpy( attackerName, "noname" );
+	} else {
+		Q_strncpyz( attackerName, Info_ValueForKey( attackerInfo, "n" ), sizeof(attackerName) - 2);
+		strcat( attackerName, S_COLOR_WHITE );
+		// check for kill messages about the current clientNum
+		if ( target == cg.snap->ps.clientNum ) {
+			Q_strncpyz( cg.killerName, attackerName, sizeof( cg.killerName ) );
+		}
+	}
+
+	if ( attacker != ENTITYNUM_WORLD ) {
+		switch (mod) {
+		case MOD_STUN_BATON:
+			message = "KILLED_STUN";
+			break;
+		case MOD_MELEE:
+			message = "KILLED_MELEE";
+			break;
+		case MOD_SABER:
+			message = "KILLED_SABER";
+			break;
+		case MOD_BRYAR_PISTOL:
+		case MOD_BRYAR_PISTOL_ALT:
+			message = "KILLED_BRYAR";
+			break;
+		case MOD_BLASTER:
+			message = "KILLED_BLASTER";
+			break;
+		case MOD_TURBLAST:
+			message = "KILLED_BLASTER";
+			break;
+		case MOD_DISRUPTOR:
+		case MOD_DISRUPTOR_SPLASH:
+			message = "KILLED_DISRUPTOR";
+			break;
+		case MOD_DISRUPTOR_SNIPER:
+			message = "KILLED_DISRUPTORSNIPE";
+			break;
+		case MOD_BOWCASTER:
+			message = "KILLED_BOWCASTER";
+			break;
+		case MOD_REPEATER:
+			message = "KILLED_REPEATER";
+			break;
+		case MOD_REPEATER_ALT:
+		case MOD_REPEATER_ALT_SPLASH:
+			message = "KILLED_REPEATERALT";
+			break;
+		case MOD_DEMP2:
+		case MOD_DEMP2_ALT:
+			message = "KILLED_DEMP2";
+			break;
+		case MOD_FLECHETTE:
+			message = "KILLED_FLECHETTE";
+			break;
+		case MOD_FLECHETTE_ALT_SPLASH:
+			message = "KILLED_FLECHETTE_MINE";
+			break;
+		case MOD_ROCKET:
+		case MOD_ROCKET_SPLASH:
+			message = "KILLED_ROCKET";
+			break;
+		case MOD_ROCKET_HOMING:
+		case MOD_ROCKET_HOMING_SPLASH:
+			message = "KILLED_ROCKET_HOMING";
+			break;
+		case MOD_THERMAL:
+		case MOD_THERMAL_SPLASH:
+			message = "KILLED_THERMAL";
+			break;
+		case MOD_TRIP_MINE_SPLASH:
+			message = "KILLED_TRIPMINE";
+			break;
+		case MOD_TIMED_MINE_SPLASH:
+			message = "KILLED_TRIPMINE_TIMED";
+			break;
+		case MOD_DET_PACK_SPLASH:
+			message = "KILLED_DETPACK";
+			break;
+		case MOD_VEHICLE:
+		case MOD_CONC:
+		case MOD_CONC_ALT:
+			message = "KILLED_GENERIC";
+			break;
+		case MOD_FORCE_DARK:
+			message = "KILLED_DARKFORCE";
+			break;
+		case MOD_SENTRY:
+			message = "KILLED_SENTRY";
+			break;
+		case MOD_TELEFRAG:
+			message = "KILLED_TELEFRAG";
+			break;
+		case MOD_CRUSH:
+			message = "KILLED_GENERIC";//"KILLED_FORCETOSS";
+			break;
+		case MOD_FALLING:
+			message = "KILLED_FORCETOSS";
+			break;
+		case MOD_TRIGGER_HURT:
+			message = "KILLED_GENERIC";//"KILLED_FORCETOSS";
+			break;
+		default:
+			message = "KILLED_GENERIC";
+			break;
+		}
+
+		if (message) {
+			message = (char *)CG_GetStringEdString("MP_INGAME", message);
+
+			CG_Printf( "%s %s %s\n", 
+				targetName, message, attackerName);
+			return;
+		}
+	}
+
+	// we don't know what it was
+	CG_Printf( "%s %s\n", targetName, (char *)CG_GetStringEdString("MP_INGAME", "DIED_GENERIC") );
+}
+
+//==========================================================================
+
+void CG_ToggleBinoculars(centity_t *cent, int forceZoom)
+{
+	if (cent->currentState.number != cg.snap->ps.clientNum)
+	{
+		return;
+	}
+
+	if (cg.snap->ps.weaponstate != WEAPON_READY)
+	{ //So we can't fool it and reactivate while switching to the saber or something.
+		return;
+	}
+
+	/*
+	if (cg.snap->ps.weapon == WP_SABER)
+	{ //No.
+		return;
+	}
+	*/
+
+	if (forceZoom)
+	{
+		if (forceZoom == 2)
+		{
+			cg.snap->ps.zoomMode = 0;
+		}
+		else if (forceZoom == 1)
+		{
+			cg.snap->ps.zoomMode = 2;
+		}
+	}
+
+	if (cg.snap->ps.zoomMode == 0)
+	{
+		trap_S_StartSound( NULL, cg.snap->ps.clientNum, CHAN_AUTO, cgs.media.zoomStart );
+	}
+	else if (cg.snap->ps.zoomMode == 2)
+	{
+		trap_S_StartSound( NULL, cg.snap->ps.clientNum, CHAN_AUTO, cgs.media.zoomEnd );
+	}
+}
+
+//set the local timing bar
+extern int cg_genericTimerBar;
+extern int cg_genericTimerDur;
+extern vec4_t cg_genericTimerColor;
+void CG_LocalTimingBar(int startTime, int duration)
+{
+    cg_genericTimerBar = startTime + duration;
+	cg_genericTimerDur = duration;
+
+	cg_genericTimerColor[0] = 1.0f;
+	cg_genericTimerColor[1] = 1.0f;
+	cg_genericTimerColor[2] = 0.0f;
+	cg_genericTimerColor[3] = 1.0f;
+}
+
+/*
+===============
+CG_UseItem
+===============
+*/
+static void CG_UseItem( centity_t *cent ) {
+	clientInfo_t *ci;
+	int			itemNum, clientNum;
+	gitem_t		*item;
+	entityState_t *es;
+
+	es = &cent->currentState;
+	
+	itemNum = (es->event & ~EV_EVENT_BITS) - EV_USE_ITEM0;
+	if ( itemNum < 0 || itemNum > HI_NUM_HOLDABLE ) {
+		itemNum = 0;
+	}
+
+	// print a message if the local player
+	if ( es->number == cg.snap->ps.clientNum ) {
+		if ( !itemNum ) {
+			//CG_CenterPrint( "No item to use", SCREEN_HEIGHT * 0.30, BIGCHAR_WIDTH );
+		} else {
+			item = BG_FindItemForHoldable( itemNum );
+		}
+	}
+
+	switch ( itemNum ) {
+	default:
+	case HI_NONE:
+		//trap_S_StartSound (NULL, es->number, CHAN_BODY, cgs.media.useNothingSound );
+		break;
+
+	case HI_BINOCULARS:
+		CG_ToggleBinoculars(cent, es->eventParm);
+		break;
+
+	case HI_SEEKER:
+		trap_S_StartSound (NULL, es->number, CHAN_AUTO, cgs.media.deploySeeker );
+		break;
+
+	case HI_SHIELD:
+	case HI_SENTRY_GUN:
+		break;
+
+//	case HI_MEDKIT:
+	case HI_MEDPAC:
+	case HI_MEDPAC_BIG:
+		clientNum = cent->currentState.clientNum;
+		if ( clientNum >= 0 && clientNum < MAX_CLIENTS ) {
+			ci = &cgs.clientinfo[ clientNum ];
+			ci->medkitUsageTime = cg.time;
+		}
+		//Different sound for big bacta?
+		trap_S_StartSound (NULL, es->number, CHAN_AUTO, cgs.media.medkitSound );
+		break;
+	case HI_JETPACK:
+		break; //Do something?
+	case HI_HEALTHDISP:
+		//CG_LocalTimingBar(cg.time, TOSS_DEBOUNCE_TIME);
+		break;
+	case HI_AMMODISP:
+		//CG_LocalTimingBar(cg.time, TOSS_DEBOUNCE_TIME);
+		break;
+	case HI_EWEB:
+		break;
+	case HI_CLOAK:
+		break; //Do something?
+	}
+
+	if (cg.snap && cg.snap->ps.clientNum == cent->currentState.number && itemNum != HI_BINOCULARS &&
+		itemNum != HI_JETPACK && itemNum != HI_HEALTHDISP && itemNum != HI_AMMODISP && itemNum != HI_CLOAK && itemNum != HI_EWEB)
+	{ //if not using binoculars/jetpack/dispensers/cloak, we just used that item up, so switch
+		BG_CycleInven(&cg.snap->ps, 1);
+		cg.itemSelect = -1; //update the client-side selection display
+	}
+}
+
+
+/*
+================
+CG_ItemPickup
+
+A new item was picked up this frame
+================
+*/
+static void CG_ItemPickup( int itemNum ) {
+	cg.itemPickup = itemNum;
+	cg.itemPickupTime = cg.time;
+	cg.itemPickupBlendTime = cg.time;
+	// see if it should be the grabbed weapon
+	if ( cg.snap && bg_itemlist[itemNum].giType == IT_WEAPON ) {
+
+		// 0 == no switching
+		// 1 == automatically switch to best SAFE weapon
+		// 2 == automatically switch to best weapon, safe or otherwise
+		// 3 == if not saber, automatically switch to best weapon, safe or otherwise
+
+		if (0 == cg_autoswitch.integer)
+		{
+			// don't switch
+		}
+		else if ( cg_autoswitch.integer == 1)
+		{ //only autoselect if not explosive ("safe")
+			if (bg_itemlist[itemNum].giTag != WP_TRIP_MINE &&
+				bg_itemlist[itemNum].giTag != WP_DET_PACK &&
+				bg_itemlist[itemNum].giTag != WP_THERMAL &&
+				bg_itemlist[itemNum].giTag != WP_ROCKET_LAUNCHER &&
+				bg_itemlist[itemNum].giTag > cg.snap->ps.weapon &&
+				cg.snap->ps.weapon != WP_SABER)
+			{
+				if (!cg.snap->ps.emplacedIndex)
+				{
+					cg.weaponSelectTime = cg.time;
+				}
+				cg.weaponSelect = bg_itemlist[itemNum].giTag;
+			}
+		}
+		else if ( cg_autoswitch.integer == 2)
+		{ //autoselect if better
+			if (bg_itemlist[itemNum].giTag > cg.snap->ps.weapon &&
+				cg.snap->ps.weapon != WP_SABER)
+			{
+				if (!cg.snap->ps.emplacedIndex)
+				{
+					cg.weaponSelectTime = cg.time;
+				}
+				cg.weaponSelect = bg_itemlist[itemNum].giTag;
+			}
+		}
+		/*
+		else if ( cg_autoswitch.integer == 3)
+		{ //autoselect if better and not using the saber as a weapon
+			if (bg_itemlist[itemNum].giTag > cg.snap->ps.weapon &&
+				cg.snap->ps.weapon != WP_SABER)
+			{
+				if (!cg.snap->ps.emplacedIndex)
+				{
+					cg.weaponSelectTime = cg.time;
+				}
+				cg.weaponSelect = bg_itemlist[itemNum].giTag;
+			}
+		}
+		*/
+		//No longer required - just not switching ever if using saber
+	}
+
+	//rww - print pickup messages
+	if (bg_itemlist[itemNum].classname && bg_itemlist[itemNum].classname[0] &&
+		(bg_itemlist[itemNum].giType != IT_TEAM || (bg_itemlist[itemNum].giTag != PW_REDFLAG && bg_itemlist[itemNum].giTag != PW_BLUEFLAG)) )
+	{ //don't print messages for flags, they have their own pickup event broadcasts
+		char	text[1024];
+		char	upperKey[1024];
+
+		strcpy(upperKey, bg_itemlist[itemNum].classname);
+
+		if ( trap_SP_GetStringTextString( va("SP_INGAME_%s",Q_strupr(upperKey)), text, sizeof( text )))
+		{
+			Com_Printf("%s %s\n", CG_GetStringEdString("MP_INGAME", "PICKUPLINE"), text);
+		}
+		else
+		{
+			Com_Printf("%s %s\n", CG_GetStringEdString("MP_INGAME", "PICKUPLINE"), bg_itemlist[itemNum].classname);
+		}
+	}
+}
+
+
+/*
+================
+CG_PainEvent
+
+Also called by playerstate transition
+================
+*/
+void CG_PainEvent( centity_t *cent, int health ) {
+	char	*snd;
+
+	// don't do more than two pain sounds a second
+	if ( cg.time - cent->pe.painTime < 500 ) {
+		return;
+	}
+
+	if ( health < 25 ) {
+		snd = "*pain25.wav";
+	} else if ( health < 50 ) {
+		snd = "*pain50.wav";
+	} else if ( health < 75 ) {
+		snd = "*pain75.wav";
+	} else {
+		snd = "*pain100.wav";
+	}
+	trap_S_StartSound( NULL, cent->currentState.number, CHAN_VOICE, 
+		CG_CustomSound( cent->currentState.number, snd ) );
+
+	// save pain time for programitic twitch animation
+	cent->pe.painTime = cg.time;
+	cent->pe.painDirection	^= 1;
+}
+
+extern qboolean BG_GetRootSurfNameWithVariant( void *ghoul2, const char *rootSurfName, char *returnSurfName, int returnSize );
+void CG_ReattachLimb(centity_t *source)
+{
+	clientInfo_t *ci = NULL;
+	
+	if ( source->currentState.number >= MAX_CLIENTS )
+	{
+		ci = source->npcClient;
+	}
+	else
+	{
+		ci = &cgs.clientinfo[source->currentState.number];
+	}
+	if ( ci )
+	{//re-apply the skin
+		if ( ci->torsoSkin > 0 )
+		{
+			trap_G2API_SetSkin(source->ghoul2,0,ci->torsoSkin,ci->torsoSkin);
+		}
+	}
+		
+	/*
+	char *limbName;
+	char *stubCapName;
+	int i = G2_MODELPART_HEAD;
+
+	//rww NOTE: Assumes G2_MODELPART_HEAD is first and G2_MODELPART_RLEG is last
+	while (i <= G2_MODELPART_RLEG)
+	{
+		if (source->torsoBolt & (1 << (i-10)))
+		{
+			switch (i)
+			{
+			case G2_MODELPART_HEAD:
+				limbName = "head";
+				stubCapName = "torso_cap_head";
+				break;
+			case G2_MODELPART_WAIST:
+				limbName = "torso";
+				stubCapName = "hips_cap_torso";
+				break;
+			case G2_MODELPART_LARM:
+				limbName = "l_arm";
+				stubCapName = "torso_cap_l_arm";
+				break;
+			case G2_MODELPART_RARM:
+				limbName = "r_arm";
+				stubCapName = "torso_cap_r_arm";
+				break;
+			case G2_MODELPART_RHAND:
+				limbName = "r_hand";
+				stubCapName = "r_arm_cap_r_hand";
+				break;
+			case G2_MODELPART_LLEG:
+				limbName = "l_leg";
+				stubCapName = "hips_cap_l_leg";
+				break;
+			case G2_MODELPART_RLEG:
+				limbName = "r_leg";
+				stubCapName = "hips_cap_r_leg";
+				break;
+			default:
+				source->torsoBolt = 0;
+				source->ghoul2weapon = NULL;
+				return;
+			}
+
+			trap_G2API_SetSurfaceOnOff(source->ghoul2, limbName, 0);
+			trap_G2API_SetSurfaceOnOff(source->ghoul2, stubCapName, 0x00000100);
+		}
+		i++;
+	}
+	*/
+	source->torsoBolt = 0;
+
+	source->ghoul2weapon = NULL;
+}
+
+const char *CG_TeamName(int team)
+{
+	if (team==TEAM_RED)
+		return "RED";
+	else if (team==TEAM_BLUE)
+		return "BLUE";
+	else if (team==TEAM_SPECTATOR)
+		return "SPECTATOR";
+	return "FREE";
+}
+
+void CG_PrintCTFMessage(clientInfo_t *ci, const char *teamName, int ctfMessage)
+{
+	char printMsg[1024];
+	char *refName = NULL;
+	const char *psStringEDString = NULL;
+
+	switch (ctfMessage)
+	{
+	case CTFMESSAGE_FRAGGED_FLAG_CARRIER:
+		refName = "FRAGGED_FLAG_CARRIER";
+		break;
+	case CTFMESSAGE_FLAG_RETURNED:
+		refName = "FLAG_RETURNED";
+		break;
+	case CTFMESSAGE_PLAYER_RETURNED_FLAG:
+		refName = "PLAYER_RETURNED_FLAG";
+		break;
+	case CTFMESSAGE_PLAYER_CAPTURED_FLAG:
+		refName = "PLAYER_CAPTURED_FLAG";
+		break;
+	case CTFMESSAGE_PLAYER_GOT_FLAG:
+		refName = "PLAYER_GOT_FLAG";
+		break;
+	default:
+		return;
+	}
+
+	psStringEDString = CG_GetStringEdString("MP_INGAME", refName);
+
+	if (!psStringEDString || !psStringEDString[0])
+	{
+		return;
+	}
+
+	if (teamName && teamName[0])
+	{
+		const char *f = strstr(psStringEDString, "%s");
+
+		if (f)
+		{
+			int strLen = 0;
+			int i = 0;
+
+			if (ci)
+			{
+				Com_sprintf(printMsg, sizeof(printMsg), "%s ", ci->name);
+				strLen = strlen(printMsg);
+			}
+
+			while (psStringEDString[i] && i < 512)
+			{
+				if (psStringEDString[i] == '%' &&
+					psStringEDString[i+1] == 's')
+				{
+					printMsg[strLen] = '\0';
+					Q_strcat(printMsg, sizeof(printMsg), teamName);
+					strLen = strlen(printMsg);
+
+					i++;
+				}
+				else
+				{
+					printMsg[strLen] = psStringEDString[i];
+					strLen++;
+				}
+
+				i++;
+			}
+
+			printMsg[strLen] = '\0';
+
+			goto doPrint;
+		}
+	}
+
+	if (ci)
+	{
+		Com_sprintf(printMsg, sizeof(printMsg), "%s %s", ci->name, psStringEDString);
+	}
+	else
+	{
+		Com_sprintf(printMsg, sizeof(printMsg), "%s", psStringEDString);
+	}
+
+doPrint:
+	Com_Printf("%s\n", printMsg);
+}
+
+void CG_GetCTFMessageEvent(entityState_t *es)
+{
+	int clIndex = es->trickedentindex;
+	int teamIndex = es->trickedentindex2;
+	clientInfo_t *ci = NULL;
+	const char *teamName = NULL;
+
+	if (clIndex < MAX_CLIENTS)
+	{
+		ci = &cgs.clientinfo[clIndex];
+	}
+
+	if (teamIndex < 50)
+	{
+		teamName = CG_TeamName(teamIndex);
+	}
+
+	if (!ci)
+	{
+		return;
+	}
+
+	CG_PrintCTFMessage(ci, teamName, es->eventParm);
+}
+
+#include "../namespace_begin.h"
+qboolean BG_InKnockDownOnly( int anim );
+#include "../namespace_end.h"
+
+//JLFRUMBLE
+#ifdef _XBOX
+extern void FF_XboxDamage(int damage, float xpos);
+#endif
+
+void DoFall(centity_t *cent, entityState_t *es, int clientNum)
+{
+	int delta = es->eventParm;
+
+	if (cent->currentState.eFlags & EF_DEAD)
+	{ //corpses crack into the ground ^_^
+		if (delta > 25)
+		{
+			trap_S_StartSound (NULL, es->number, CHAN_AUTO, cgs.media.fallSound );
+		}
+		else
+		{
+			trap_S_StartSound (NULL, es->number, CHAN_AUTO, trap_S_RegisterSound( "sound/movers/objects/objectHit.wav" ) );
+		}
+	}
+	else if (BG_InKnockDownOnly(es->legsAnim))
+	{
+		if (delta > 14)
+		{
+			trap_S_StartSound (NULL, es->number, CHAN_AUTO, cgs.media.fallSound );
+		}
+		else
+		{
+			trap_S_StartSound (NULL, es->number, CHAN_AUTO, trap_S_RegisterSound( "sound/movers/objects/objectHit.wav" ) );
+		}
+	}
+	else if (delta > 50)
+	{
+		trap_S_StartSound (NULL, es->number, CHAN_AUTO, cgs.media.fallSound );
+		trap_S_StartSound( NULL, cent->currentState.number, CHAN_VOICE, 
+			CG_CustomSound( cent->currentState.number, "*land1.wav" ) );
+		cent->pe.painTime = cg.time;	// don't play a pain sound right after this
+	}
+	else if (delta > 44)
+	{
+		trap_S_StartSound (NULL, es->number, CHAN_AUTO, cgs.media.fallSound );
+		trap_S_StartSound( NULL, cent->currentState.number, CHAN_VOICE, 
+			CG_CustomSound( cent->currentState.number, "*land1.wav" ) );
+		cent->pe.painTime = cg.time;	// don't play a pain sound right after this
+	}
+	else
+	{
+		trap_S_StartSound (NULL, es->number, CHAN_AUTO, cgs.media.landSound );
+	}
+	
+	if ( clientNum == cg.predictedPlayerState.clientNum )
+	{
+		// smooth landing z changes
+		cg.landChange = -delta;
+		if (cg.landChange > 32)
+		{
+			cg.landChange = 32;
+		}
+		if (cg.landChange < -32)
+		{
+			cg.landChange = -32;
+		}
+		cg.landTime = cg.time;
+	}
+//JLFRUMBLE
+#ifdef _XBOX
+	if ( cent->playerState)
+	{
+
+		if (BG_InKnockDownOnly(es->legsAnim))
+		{
+			if (delta > 14)
+			{
+				FF_XboxDamage(20, 0);
+			}
+			else
+			{
+				FF_XboxDamage(14, 0);
+			}
+			return;
+		}
+		if ( delta > 50)
+			FF_XboxDamage(50, 0);
+		else 
+			FF_XboxDamage(delta, 0);
+/*		else if (delta > 44)
+			FF_XboxDamage(44, 0);
+		else 
+			FF_XboxDamage(20, 0);
+*/
+	}
+#endif
+
+
+
+}
+
+int CG_InClientBitflags(entityState_t *ent, int client)
+{
+	int checkIn;
+	int sub = 0;
+
+	if (client > 47)
+	{
+		checkIn = ent->trickedentindex4;
+		sub = 48;
+	}
+	else if (client > 31)
+	{
+		checkIn = ent->trickedentindex3;
+		sub = 32;
+	}
+	else if (client > 15)
+	{
+		checkIn = ent->trickedentindex2;
+		sub = 16;
+	}
+	else
+	{
+		checkIn = ent->trickedentindex;
+	}
+
+	if (checkIn & (1 << (client-sub)))
+	{
+		return 1;
+	}
+	
+	return 0;
+}
+
+void CG_PlayDoorLoopSound( centity_t *cent );
+void CG_PlayDoorSound( centity_t *cent, int type );
+
+void CG_TryPlayCustomSound( vec3_t origin, int entityNum, int channel, const char *soundName )
+{
+	sfxHandle_t cSound = CG_CustomSound(entityNum, soundName);
+
+	if (cSound <= 0)
+	{
+		return;
+	}
+
+	trap_S_StartSound(origin, entityNum, channel, cSound);
+}
+
+void CG_G2MarkEvent(entityState_t *es)
+{
+	//es->origin should be the hit location of the projectile,
+	//whereas es->origin2 is the predicted position of the
+	//projectile. (based on the trajectory upon impact) -rww
+	centity_t *pOwner = &cg_entities[es->otherEntityNum];
+	vec3_t startPoint;
+	float	size = 0.0f;
+	qhandle_t shader = 0;
+
+	if (!pOwner->ghoul2)
+	{ //can't do anything then...
+		return;
+	}
+
+	//es->eventParm being non-0 means to do a special trace check
+	//first. This will give us an impact right at the surface to
+	//project the mark on. Typically this is used for radius
+	//explosions and such, where the source position could be
+	//way outside of model space.
+	if (es->eventParm)
+	{
+		trace_t tr;
+		int ignore = ENTITYNUM_NONE;
+
+		CG_G2Trace(&tr, es->origin, NULL, NULL, es->origin2, ignore, MASK_PLAYERSOLID);
+
+		if (tr.entityNum != es->otherEntityNum)
+		{ //try again if we hit an ent but not the one we wanted.
+			//CG_TestLine(es->origin, es->origin2, 2000, 0x0000ff, 1);
+			if (tr.entityNum < ENTITYNUM_WORLD)
+			{
+				ignore = tr.entityNum;
+				CG_G2Trace(&tr, es->origin, NULL, NULL, es->origin2, ignore, MASK_PLAYERSOLID);
+				if (tr.entityNum != es->otherEntityNum)
+				{ //try extending the trace a bit.. or not
+					/*
+					vec3_t v;
+
+					VectorSubtract(es->origin2, es->origin, v);
+					VectorScale(v, 64.0f, v);
+					VectorAdd(es->origin2, v, es->origin2);
+
+					CG_G2Trace(&tr, es->origin, NULL, NULL, es->origin2, ignore, MASK_PLAYERSOLID);
+					if (tr.entityNum != es->otherEntityNum)
+					{
+						return;
+					}
+					*/
+					//didn't manage to collide with the desired person. No mark will be placed then.
+					return;
+				}
+			}
+		}
+
+		//otherwise we now have a valid starting point.
+		VectorCopy(tr.endpos, startPoint);
+	}
+	else
+	{
+		VectorCopy(es->origin, startPoint);
+	}
+
+	if ( (es->eFlags&EF_JETPACK_ACTIVE) )
+	{// a vehicle weapon, make it a larger size mark
+		//OR base this on the size of the thing you hit?
+		if ( g_vehWeaponInfo[es->otherEntityNum2].fG2MarkSize )
+		{
+			size = flrand( 0.6f, 1.4f )*g_vehWeaponInfo[es->otherEntityNum2].fG2MarkSize;
+		}
+		else
+		{	
+			size = flrand( 32.0f, 72.0f );
+		}
+		//specify mark shader in vehWeapon file
+		if ( g_vehWeaponInfo[es->otherEntityNum2].iG2MarkShaderHandle )
+		{//have one we want to use instead of defaults
+			shader = g_vehWeaponInfo[es->otherEntityNum2].iG2MarkShaderHandle;
+		}
+	}
+	switch(es->weapon)
+	{
+	case WP_BRYAR_PISTOL:
+	case WP_CONCUSSION:
+	case WP_BRYAR_OLD:
+	case WP_BLASTER:
+	case WP_DISRUPTOR:
+	case WP_BOWCASTER:
+	case WP_REPEATER:
+	case WP_TURRET:
+		if ( !size )
+		{
+			size = 4.0f;
+		}
+		if ( !shader )
+		{
+			shader = cgs.media.bdecal_bodyburn1;
+		}
+		CG_AddGhoul2Mark(shader, size, 
+			startPoint, es->origin2, es->owner, pOwner->lerpOrigin,
+			pOwner->lerpAngles[YAW], pOwner->ghoul2,
+			pOwner->modelScale, Q_irand(10000, 20000));
+		break;
+	case WP_ROCKET_LAUNCHER:
+	case WP_THERMAL:
+		if ( !size )
+		{
+			size = 24.0f;
+		}
+		if ( !shader )
+		{
+			shader = cgs.media.bdecal_burn1;
+		}
+		CG_AddGhoul2Mark(shader, size, 
+			startPoint, es->origin2, es->owner, pOwner->lerpOrigin,
+			pOwner->lerpAngles[YAW], pOwner->ghoul2,
+			pOwner->modelScale, Q_irand(10000, 20000));
+		break;
+		/*
+	case WP_FLECHETTE:
+		CG_AddGhoul2Mark(cgs.media.bdecal_bodyburn1, flrand(0.5f, 1.0f), 
+			startPoint, es->origin2, es->owner, pOwner->lerpOrigin,
+			pOwner->lerpAngles[YAW], pOwner->ghoul2,
+			pOwner->modelScale);
+		break;
+		*/
+		//Issues with small scale?
+	default:
+		break;
+	}
+}
+
+void CG_CalcVehMuzzle(Vehicle_t *pVeh, centity_t *ent, int muzzleNum)
+{
+	mdxaBone_t boltMatrix;
+	vec3_t	vehAngles;
+
+	assert(pVeh);
+
+	if (pVeh->m_iMuzzleTime[muzzleNum] == cg.time)
+	{ //already done for this frame, don't need to do it again
+		return;
+	}
+	//Uh... how about we set this, hunh...?  :)
+	pVeh->m_iMuzzleTime[muzzleNum] = cg.time;
+
+	VectorCopy( ent->lerpAngles, vehAngles );
+	if ( pVeh->m_pVehicleInfo )
+	{
+		if (pVeh->m_pVehicleInfo->type == VH_ANIMAL
+			 ||pVeh->m_pVehicleInfo->type == VH_WALKER)
+		{
+			vehAngles[PITCH] = vehAngles[ROLL] = 0.0f;
+		}
+		else if (pVeh->m_pVehicleInfo->type == VH_SPEEDER)
+		{
+			vehAngles[PITCH] = 0.0f;
+		}
+	}
+	trap_G2API_GetBoltMatrix_NoRecNoRot(ent->ghoul2, 0, pVeh->m_iMuzzleTag[muzzleNum], &boltMatrix, vehAngles,
+		ent->lerpOrigin, cg.time, NULL, ent->modelScale);
+	BG_GiveMeVectorFromMatrix(&boltMatrix, ORIGIN, pVeh->m_vMuzzlePos[muzzleNum]);
+	BG_GiveMeVectorFromMatrix(&boltMatrix, NEGATIVE_Y, pVeh->m_vMuzzleDir[muzzleNum]);
+}
+
+//corresponds to G_VehMuzzleFireFX -rww
+void CG_VehMuzzleFireFX(centity_t *veh, entityState_t *broadcaster)
+{
+	Vehicle_t *pVeh = veh->m_pVehicle;
+	int curMuz = 0, muzFX = 0;
+
+	if (!pVeh || !veh->ghoul2)
+	{
+		return;
+	}
+
+	for ( curMuz = 0; curMuz < MAX_VEHICLE_MUZZLES; curMuz++ )
+	{//go through all muzzles and 
+		if ( pVeh->m_iMuzzleTag[curMuz] != -1//valid muzzle bolt
+			&& (broadcaster->trickedentindex&(1<<curMuz)) )//fired
+		{//this muzzle fired
+			muzFX = 0;
+			if ( pVeh->m_pVehicleInfo->weapMuzzle[curMuz] == 0 )
+			{//no weaopon for this muzzle?  check turrets
+				int i, j;
+				for ( i = 0; i < MAX_VEHICLE_TURRETS; i++ )
+				{
+					for ( j = 0; j < MAX_VEHICLE_TURRETS; j++ )
+					{
+						if ( pVeh->m_pVehicleInfo->turret[i].iMuzzle[j]-1 == curMuz )
+						{//this muzzle belongs to this turret
+							muzFX = g_vehWeaponInfo[pVeh->m_pVehicleInfo->turret[i].iWeapon].iMuzzleFX;
+							break;
+						}
+					}
+				}
+			}
+			else
+			{
+				muzFX = g_vehWeaponInfo[pVeh->m_pVehicleInfo->weapMuzzle[curMuz]].iMuzzleFX;
+			}
+			if ( muzFX )
+			{
+				//CG_CalcVehMuzzle(pVeh, veh, curMuz);
+				//trap_FX_PlayEffectID(muzFX, pVeh->m_vMuzzlePos[curMuz], pVeh->m_vMuzzleDir[curMuz], -1, -1);
+				trap_FX_PlayBoltedEffectID(muzFX, veh->currentState.origin, veh->ghoul2, pVeh->m_iMuzzleTag[curMuz], veh->currentState.number, 0, 0, qtrue);
+			}
+		}
+	}
+}
+
+const char	*cg_stringEdVoiceChatTable[MAX_CUSTOM_SIEGE_SOUNDS] = 
+{
+	"VC_ATT",//"*att_attack",
+	"VC_ATT_PRIMARY",//"*att_primary",
+	"VC_ATT_SECONDARY",//"*att_second",
+	"VC_DEF_GUNS",//"*def_guns",
+	"VC_DEF_POSITION",//"*def_position",
+	"VC_DEF_PRIMARY",//"*def_primary",
+	"VC_DEF_SECONDARY",//"*def_second",
+	"VC_REPLY_COMING",//"*reply_coming",
+	"VC_REPLY_GO",//"*reply_go",
+	"VC_REPLY_NO",//"*reply_no",
+	"VC_REPLY_STAY",//"*reply_stay",
+	"VC_REPLY_YES",//"*reply_yes",
+	"VC_REQ_ASSIST",//"*req_assist",
+	"VC_REQ_DEMO",//"*req_demo",
+	"VC_REQ_HVY",//"*req_hvy",
+	"VC_REQ_MEDIC",//"*req_medic",
+	"VC_REQ_SUPPLY",//"*req_sup",
+	"VC_REQ_TECH",//"*req_tech",
+	"VC_SPOT_AIR",//"*spot_air",
+	"VC_SPOT_DEF",//"*spot_defenses",
+	"VC_SPOT_EMPLACED",//"*spot_emplaced",
+	"VC_SPOT_SNIPER",//"*spot_sniper",
+	"VC_SPOT_TROOP",//"*spot_troops",
+	"VC_TAC_COVER",//"*tac_cover",
+	"VC_TAC_FALLBACK",//"*tac_fallback",
+	"VC_TAC_FOLLOW",//"*tac_follow",
+	"VC_TAC_HOLD",//"*tac_hold",
+	"VC_TAC_SPLIT",//"*tac_split",
+	"VC_TAC_TOGETHER",//"*tac_together",
+	NULL
+};
+
+//stupid way of figuring out what string to use for voice chats
+const char *CG_GetStringForVoiceSound(const char *s)
+{
+	int i = 0;
+	while (i < MAX_CUSTOM_SIEGE_SOUNDS)
+	{
+		if (bg_customSiegeSoundNames[i] &&
+			!Q_stricmp(bg_customSiegeSoundNames[i], s))
+		{ //get the matching reference name
+			assert(cg_stringEdVoiceChatTable[i]);
+			return CG_GetStringEdString("MENUS", (char *)cg_stringEdVoiceChatTable[i]);
+		}
+		i++;
+	}
+
+	return "voice chat";
+}
+
+/*
+==============
+CG_EntityEvent
+
+An entity has an event value
+also called by CG_CheckPlayerstateEvents
+==============
+*/
+#define	DEBUGNAME(x) if(cg_debugEvents.integer){CG_Printf(x"\n");}
+extern void CG_ChatBox_AddString(char *chatStr); //cg_draw.c
+void CG_EntityEvent( centity_t *cent, vec3_t position ) {
+	entityState_t	*es;
+	int				event;
+	vec3_t			dir;
+	const char		*s;
+	int				clientNum;
+	clientInfo_t	*ci;
+	int				eID = 0;
+	int				isnd = 0;
+	centity_t		*cl_ent;
+
+	es = &cent->currentState;
+	event = es->event & ~EV_EVENT_BITS;
+
+	if ( cg_debugEvents.integer ) {
+		CG_Printf( "ent:%3i  event:%3i ", es->number, event );
+	}
+
+	if ( !event ) {
+		DEBUGNAME("ZEROEVENT");
+		return;
+	}
+
+	clientNum = es->clientNum;
+	if ( clientNum < 0 || clientNum >= MAX_CLIENTS ) {
+		clientNum = 0;
+	}
+
+	if (es->eType == ET_NPC)
+	{
+		clientNum = es->number;
+
+		if (!cent->npcClient)
+		{
+			CG_CreateNPCClient(&cent->npcClient); //allocate memory for it
+
+			if (!cent->npcClient)
+			{
+				assert(0);
+				return;
+			}
+
+			memset(cent->npcClient, 0, sizeof(clientInfo_t));
+			cent->npcClient->ghoul2Model = NULL;
+		}
+
+		ci = cent->npcClient;
+
+		assert(ci);
+	}
+	else
+	{
+		ci = &cgs.clientinfo[ clientNum ];
+	}
+
+	switch ( event ) {
+	//
+	// movement generated events
+	//
+	case EV_CLIENTJOIN:
+		DEBUGNAME("EV_CLIENTJOIN");
+
+		//Slight hack to force a local reinit of client entity on join.
+		cl_ent = &cg_entities[es->eventParm];
+
+		if (cl_ent)
+		{
+			//cl_ent->torsoBolt = 0;
+			cl_ent->bolt1 = 0;
+			cl_ent->bolt2 = 0;
+			cl_ent->bolt3 = 0;
+			cl_ent->bolt4 = 0;
+			cl_ent->bodyHeight = 0;//SABER_LENGTH_MAX;
+			//cl_ent->saberExtendTime = 0;
+			cl_ent->boltInfo = 0;
+			cl_ent->frame_minus1_refreshed = 0;
+			cl_ent->frame_minus2_refreshed = 0;
+			cl_ent->frame_hold_time = 0;
+			cl_ent->frame_hold_refreshed = 0;
+			cl_ent->trickAlpha = 0;
+			cl_ent->trickAlphaTime = 0;
+			cl_ent->ghoul2weapon = NULL;
+			cl_ent->weapon = WP_NONE;
+			cl_ent->teamPowerEffectTime = 0;
+			cl_ent->teamPowerType = 0;
+			cl_ent->numLoopingSounds = 0;
+			//cl_ent->localAnimIndex = 0;
+		}
+		break;
+
+	case EV_FOOTSTEP:
+		DEBUGNAME("EV_FOOTSTEP");
+		if (cg_footsteps.integer) {
+			footstep_t	soundType;
+			switch( es->eventParm )
+			{
+			case MATERIAL_MUD:
+				soundType = FOOTSTEP_MUDWALK;
+				break;
+			case MATERIAL_DIRT:			
+				soundType = FOOTSTEP_DIRTWALK;
+				break;
+			case MATERIAL_SAND:			
+				soundType = FOOTSTEP_SANDWALK;
+				break;
+			case MATERIAL_SNOW:			
+				soundType = FOOTSTEP_SNOWWALK;
+				break;
+			case MATERIAL_SHORTGRASS:		
+			case MATERIAL_LONGGRASS:		
+				soundType = FOOTSTEP_GRASSWALK;
+				break;
+			case MATERIAL_SOLIDMETAL:		
+				soundType = FOOTSTEP_METALWALK;
+				break;
+			case MATERIAL_HOLLOWMETAL:	
+				soundType = FOOTSTEP_PIPEWALK;
+				break;
+			case MATERIAL_GRAVEL:
+				soundType = FOOTSTEP_GRAVELWALK;
+				break;
+			case MATERIAL_CARPET:
+			case MATERIAL_FABRIC:
+			case MATERIAL_CANVAS:
+			case MATERIAL_RUBBER:
+			case MATERIAL_PLASTIC:
+				soundType = FOOTSTEP_RUGWALK;
+				break;
+			case MATERIAL_SOLIDWOOD:
+			case MATERIAL_HOLLOWWOOD:
+				soundType = FOOTSTEP_WOODWALK;
+				break;
+
+			default:
+				soundType = FOOTSTEP_STONEWALK;
+				break;
+			}
+
+			trap_S_StartSound (NULL, es->number, CHAN_BODY, cgs.media.footsteps[ soundType ][rand()&3] );
+		}
+		break;
+	case EV_FOOTSTEP_METAL:
+		DEBUGNAME("EV_FOOTSTEP_METAL");
+		if (cg_footsteps.integer) {
+			trap_S_StartSound (NULL, es->number, CHAN_BODY, 
+				cgs.media.footsteps[ FOOTSTEP_METALWALK ][rand()&3] );
+		}
+		break;
+	case EV_FOOTSPLASH:
+		DEBUGNAME("EV_FOOTSPLASH");
+		if (cg_footsteps.integer) {
+			trap_S_StartSound (NULL, es->number, CHAN_BODY, 
+				cgs.media.footsteps[ FOOTSTEP_SPLASH ][rand()&3] );
+		}
+		break;
+	case EV_FOOTWADE:
+		DEBUGNAME("EV_FOOTWADE");
+		if (cg_footsteps.integer) {
+			trap_S_StartSound (NULL, es->number, CHAN_BODY, 
+				cgs.media.footsteps[ FOOTSTEP_SPLASH ][rand()&3] );
+		}
+		break;
+	case EV_SWIM:
+		DEBUGNAME("EV_SWIM");
+		if (cg_footsteps.integer) {
+			trap_S_StartSound (NULL, es->number, CHAN_BODY, 
+				cgs.media.footsteps[ FOOTSTEP_SPLASH ][rand()&3] );
+		}
+		break;
+
+
+	case EV_FALL:
+		DEBUGNAME("EV_FALL");
+		if (es->number == cg.snap->ps.clientNum && cg.snap->ps.fallingToDeath)
+		{
+			break;
+		}
+		DoFall(cent, es, clientNum);
+		break;
+	case EV_STEP_4:
+	case EV_STEP_8:
+	case EV_STEP_12:
+	case EV_STEP_16:		// smooth out step up transitions
+		DEBUGNAME("EV_STEP");
+	{
+		float	oldStep;
+		int		delta;
+		int		step;
+
+		if ( clientNum != cg.predictedPlayerState.clientNum ) {
+			break;
+		}
+		// if we are interpolating, we don't need to smooth steps
+		if ( cg.demoPlayback || (cg.snap->ps.pm_flags & PMF_FOLLOW) ||
+			cg_nopredict.integer || cg_synchronousClients.integer ) {
+			break;
+		}
+		// check for stepping up before a previous step is completed
+		delta = cg.time - cg.stepTime;
+		if (delta < STEP_TIME) {
+			oldStep = cg.stepChange * (STEP_TIME - delta) / STEP_TIME;
+		} else {
+			oldStep = 0;
+		}
+
+		// add this amount
+		step = 4 * (event - EV_STEP_4 + 1 );
+		cg.stepChange = oldStep + step;
+		if ( cg.stepChange > MAX_STEP_CHANGE ) {
+			cg.stepChange = MAX_STEP_CHANGE;
+		}
+		cg.stepTime = cg.time;
+		break;
+	}
+
+	case EV_JUMP_PAD:
+		DEBUGNAME("EV_JUMP_PAD");
+		break;
+
+	case EV_GHOUL2_MARK:
+		DEBUGNAME("EV_GHOUL2_MARK");
+
+		if (cg_ghoul2Marks.integer)
+		{ //Can we put a burn mark on him?
+			CG_G2MarkEvent(es);
+		}
+		break;
+
+	case EV_GLOBAL_DUEL:
+		DEBUGNAME("EV_GLOBAL_DUEL");
+		//used for beginning of power duels
+		//if (cg.predictedPlayerState.persistant[PERS_TEAM] != TEAM_SPECTATOR)
+		if (es->otherEntityNum == cg.predictedPlayerState.clientNum ||
+			es->otherEntityNum2 == cg.predictedPlayerState.clientNum ||
+			es->groundEntityNum == cg.predictedPlayerState.clientNum)
+		{
+			CG_CenterPrint( CG_GetStringEdString("MP_SVGAME", "BEGIN_DUEL"), 120, GIANTCHAR_WIDTH*2 );				
+			trap_S_StartLocalSound( cgs.media.countFightSound, CHAN_ANNOUNCER );
+		}
+		break;
+
+	case EV_PRIVATE_DUEL:
+		DEBUGNAME("EV_PRIVATE_DUEL");
+
+		if (cg.snap->ps.clientNum != es->number)
+		{
+			break;
+		}
+
+		if (es->eventParm)
+		{ //starting the duel
+			if (es->eventParm == 2)
+			{
+				CG_CenterPrint( CG_GetStringEdString("MP_SVGAME", "BEGIN_DUEL"), 120, GIANTCHAR_WIDTH*2 );				
+				trap_S_StartLocalSound( cgs.media.countFightSound, CHAN_ANNOUNCER );
+			}
+			else
+			{
+				trap_S_StartBackgroundTrack( "music/mp/duel.mp3", "music/mp/duel.mp3", qfalse );
+			}
+		}
+		else
+		{ //ending the duel
+			CG_StartMusic(qtrue);
+		}
+		break;
+
+	case EV_JUMP:
+		DEBUGNAME("EV_JUMP");
+		if (cg_jumpSounds.integer)
+		{
+			trap_S_StartSound (NULL, es->number, CHAN_VOICE, CG_CustomSound( es->number, "*jump1.wav" ) );
+		}
+		break;
+	case EV_ROLL:
+		DEBUGNAME("EV_ROLL");
+		if (es->number == cg.snap->ps.clientNum && cg.snap->ps.fallingToDeath)
+		{
+			break;
+		}
+		if (es->eventParm)
+		{ //fall-roll-in-one event
+			DoFall(cent, es, clientNum);
+		}
+
+		trap_S_StartSound (NULL, es->number, CHAN_VOICE, CG_CustomSound( es->number, "*jump1.wav" ) );
+		trap_S_StartSound( NULL, es->number, CHAN_BODY, cgs.media.rollSound  );
+
+		//FIXME: need some sort of body impact on ground sound and maybe kick up some dust?
+		break;
+
+	case EV_TAUNT:
+		DEBUGNAME("EV_TAUNT");
+		{
+			int soundIndex = 0;
+			if ( cgs.gametype != GT_DUEL
+				&& cgs.gametype != GT_POWERDUEL
+				&& es->eventParm == TAUNT_TAUNT )
+			{//normal taunt
+				soundIndex = CG_CustomSound( es->number, "*taunt.wav" );
+			}
+			else
+			{
+				switch ( es->eventParm )
+				{
+				case TAUNT_TAUNT:
+				default:
+					if ( Q_irand( 0, 1 ) )
+					{
+						soundIndex = CG_CustomSound( es->number, va("*anger%d.wav", Q_irand(1,3)) );
+					}
+					else
+					{
+						soundIndex = CG_CustomSound( es->number, va("*taunt%d.wav", Q_irand(1,3)) );
+						if ( !soundIndex )
+						{
+							soundIndex = CG_CustomSound( es->number, va("*anger%d.wav", Q_irand(1,3)) );
+						}
+					}
+					break;
+				case TAUNT_BOW:
+					//soundIndex = CG_CustomSound( es->number, va("*respect%d.wav", Q_irand(1,3)) );
+					break;
+				case TAUNT_MEDITATE:
+					//soundIndex = CG_CustomSound( es->number, va("*meditate%d.wav", Q_irand(1,3)) );
+					break;
+				case TAUNT_FLOURISH:
+					if ( Q_irand( 0, 1 ) )
+					{
+						soundIndex = CG_CustomSound( es->number, va("*deflect%d.wav", Q_irand(1,3)) );
+						if ( !soundIndex )
+						{
+							soundIndex = CG_CustomSound( es->number, va("*gloat%d.wav", Q_irand(1,3)) );
+							if ( !soundIndex )
+							{
+								soundIndex = CG_CustomSound( es->number, va("*anger%d.wav", Q_irand(1,3)) );
+							}
+						}
+					}
+					else
+					{
+						soundIndex = CG_CustomSound( es->number, va("*gloat%d.wav", Q_irand(1,3)) );
+						if ( !soundIndex )
+						{
+							soundIndex = CG_CustomSound( es->number, va("*deflect%d.wav", Q_irand(1,3)) );
+							if ( !soundIndex )
+							{
+								soundIndex = CG_CustomSound( es->number, va("*anger%d.wav", Q_irand(1,3)) );
+							}
+						}
+					}
+					break;
+				case TAUNT_GLOAT:
+					soundIndex = CG_CustomSound( es->number, va("*victory%d.wav", Q_irand(1,3)) );
+					break;
+				}
+			}
+			if ( !soundIndex )
+			{
+				soundIndex = CG_CustomSound( es->number, "*taunt.wav" );
+			}
+			if ( soundIndex )
+			{
+				trap_S_StartSound (NULL, es->number, CHAN_VOICE, soundIndex );
+			}
+		}
+		break;
+
+		//Begin NPC sounds
+	case EV_ANGER1:	//Say when acquire an enemy when didn't have one before
+	case EV_ANGER2:
+	case EV_ANGER3:
+		DEBUGNAME("EV_ANGERx");
+		CG_TryPlayCustomSound( NULL, es->number, CHAN_VOICE, va("*anger%i.wav", event - EV_ANGER1 + 1) );
+		break;
+
+	case EV_VICTORY1:	//Say when killed an enemy
+	case EV_VICTORY2:
+	case EV_VICTORY3:
+		DEBUGNAME("EV_VICTORYx");
+		CG_TryPlayCustomSound( NULL, es->number, CHAN_VOICE, va("*victory%i.wav", event - EV_VICTORY1 + 1) );
+		break;
+
+	case EV_CONFUSE1:	//Say when confused
+	case EV_CONFUSE2:
+	case EV_CONFUSE3:
+		DEBUGNAME("EV_CONFUSEDx");
+		CG_TryPlayCustomSound( NULL, es->number, CHAN_VOICE, va("*confuse%i.wav", event - EV_CONFUSE1 + 1) );
+		break;
+
+	case EV_PUSHED1:	//Say when pushed
+	case EV_PUSHED2:
+	case EV_PUSHED3:
+		DEBUGNAME("EV_PUSHEDx");
+		CG_TryPlayCustomSound( NULL, es->number, CHAN_VOICE, va("*pushed%i.wav", event - EV_PUSHED1 + 1) );
+		break;
+
+	case EV_CHOKE1:	//Say when choking
+	case EV_CHOKE2:
+	case EV_CHOKE3:
+		DEBUGNAME("EV_CHOKEx");
+		CG_TryPlayCustomSound( NULL, es->number, CHAN_VOICE, va("*choke%i.wav", event - EV_CHOKE1 + 1) );
+		break;
+
+	case EV_FFWARN:	//Warn ally to stop shooting you
+		DEBUGNAME("EV_FFWARN");
+		CG_TryPlayCustomSound( NULL, es->number, CHAN_VOICE, "*ffwarn.wav" );
+		break;
+
+	case EV_FFTURN:	//Turn on ally after being shot by them
+		DEBUGNAME("EV_FFTURN");
+		CG_TryPlayCustomSound( NULL, es->number, CHAN_VOICE, "*ffturn.wav" );
+		break;
+
+	//extra sounds for ST
+	case EV_CHASE1:
+	case EV_CHASE2:
+	case EV_CHASE3:
+		DEBUGNAME("EV_CHASEx");
+		CG_TryPlayCustomSound( NULL, es->number, CHAN_VOICE, va("*chase%i.wav", event - EV_CHASE1 + 1) );
+		break;
+	case EV_COVER1:
+	case EV_COVER2:
+	case EV_COVER3:
+	case EV_COVER4:
+	case EV_COVER5:
+		DEBUGNAME("EV_COVERx");
+		CG_TryPlayCustomSound( NULL, es->number, CHAN_VOICE, va("*cover%i.wav", event - EV_COVER1 + 1) );
+		break;
+	case EV_DETECTED1:
+	case EV_DETECTED2:
+	case EV_DETECTED3:
+	case EV_DETECTED4:
+	case EV_DETECTED5:
+		DEBUGNAME("EV_DETECTEDx");
+		CG_TryPlayCustomSound( NULL, es->number, CHAN_VOICE, va("*detected%i.wav", event - EV_DETECTED1 + 1) );
+		break;
+	case EV_GIVEUP1:
+	case EV_GIVEUP2:
+	case EV_GIVEUP3:
+	case EV_GIVEUP4:
+		DEBUGNAME("EV_GIVEUPx");
+		CG_TryPlayCustomSound( NULL, es->number, CHAN_VOICE, va("*giveup%i.wav", event - EV_GIVEUP1 + 1) );
+		break;
+	case EV_LOOK1:
+	case EV_LOOK2:
+		DEBUGNAME("EV_LOOKx");
+		CG_TryPlayCustomSound( NULL, es->number, CHAN_VOICE, va("*look%i.wav", event - EV_LOOK1 + 1) );
+		break;
+	case EV_LOST1:
+		DEBUGNAME("EV_LOST1");
+		CG_TryPlayCustomSound( NULL, es->number, CHAN_VOICE, "*lost1.wav" );
+		break;
+	case EV_OUTFLANK1:
+	case EV_OUTFLANK2:
+		DEBUGNAME("EV_OUTFLANKx");
+		CG_TryPlayCustomSound( NULL, es->number, CHAN_VOICE, va("*outflank%i.wav", event - EV_OUTFLANK1 + 1) );
+		break;
+	case EV_ESCAPING1:
+	case EV_ESCAPING2:
+	case EV_ESCAPING3:
+		DEBUGNAME("EV_ESCAPINGx");
+		CG_TryPlayCustomSound( NULL, es->number, CHAN_VOICE, va("*escaping%i.wav", event - EV_ESCAPING1 + 1) );
+		break;
+	case EV_SIGHT1:
+	case EV_SIGHT2:
+	case EV_SIGHT3:
+		DEBUGNAME("EV_SIGHTx");
+		CG_TryPlayCustomSound( NULL, es->number, CHAN_VOICE, va("*sight%i.wav", event - EV_SIGHT1 + 1) );
+		break;
+	case EV_SOUND1:
+	case EV_SOUND2:
+	case EV_SOUND3:
+		DEBUGNAME("EV_SOUNDx");
+		CG_TryPlayCustomSound( NULL, es->number, CHAN_VOICE, va("*sound%i.wav", event - EV_SOUND1 + 1) );
+		break;
+	case EV_SUSPICIOUS1:
+	case EV_SUSPICIOUS2:
+	case EV_SUSPICIOUS3:
+	case EV_SUSPICIOUS4:
+	case EV_SUSPICIOUS5:
+		DEBUGNAME("EV_SUSPICIOUSx");
+		CG_TryPlayCustomSound( NULL, es->number, CHAN_VOICE, va("*suspicious%i.wav", event - EV_SUSPICIOUS1 + 1) );
+		break;
+	//extra sounds for Jedi
+	case EV_COMBAT1:
+	case EV_COMBAT2:
+	case EV_COMBAT3:
+		DEBUGNAME("EV_COMBATx");
+		CG_TryPlayCustomSound( NULL, es->number, CHAN_VOICE, va("*combat%i.wav", event - EV_COMBAT1 + 1) );
+		break;
+	case EV_JDETECTED1:
+	case EV_JDETECTED2:
+	case EV_JDETECTED3:
+		DEBUGNAME("EV_JDETECTEDx");
+		CG_TryPlayCustomSound( NULL, es->number, CHAN_VOICE, va("*jdetected%i.wav", event - EV_JDETECTED1 + 1) );
+		break;
+	case EV_TAUNT1:
+	case EV_TAUNT2:
+	case EV_TAUNT3:
+		DEBUGNAME("EV_TAUNTx");
+		CG_TryPlayCustomSound( NULL, es->number, CHAN_VOICE, va("*taunt%i.wav", event - EV_TAUNT1 + 1) );
+		break;
+	case EV_JCHASE1:
+	case EV_JCHASE2:
+	case EV_JCHASE3:
+		DEBUGNAME("EV_JCHASEx");
+		CG_TryPlayCustomSound( NULL, es->number, CHAN_VOICE, va("*jchase%i.wav", event - EV_JCHASE1 + 1) );
+		break;
+	case EV_JLOST1:
+	case EV_JLOST2:
+	case EV_JLOST3:
+		DEBUGNAME("EV_JLOSTx");
+		CG_TryPlayCustomSound( NULL, es->number, CHAN_VOICE, va("*jlost%i.wav", event - EV_JLOST1 + 1) );
+		break;
+	case EV_DEFLECT1:
+	case EV_DEFLECT2:
+	case EV_DEFLECT3:
+		DEBUGNAME("EV_DEFLECTx");
+		CG_TryPlayCustomSound( NULL, es->number, CHAN_VOICE, va("*deflect%i.wav", event - EV_DEFLECT1 + 1) );
+		break;
+	case EV_GLOAT1:
+	case EV_GLOAT2:
+	case EV_GLOAT3:
+		DEBUGNAME("EV_GLOATx");
+		CG_TryPlayCustomSound( NULL, es->number, CHAN_VOICE, va("*gloat%i.wav", event - EV_GLOAT1 + 1) );
+		break;
+	case EV_PUSHFAIL:
+		DEBUGNAME("EV_PUSHFAIL");
+		CG_TryPlayCustomSound( NULL, es->number, CHAN_VOICE, "*pushfail.wav" );
+		break;
+		//End NPC sounds
+
+	case EV_SIEGESPEC:
+		DEBUGNAME("EV_SIEGESPEC");
+		if ( es->owner == cg.predictedPlayerState.clientNum )
+		{
+			cg_siegeDeathTime = es->time;
+		}
+
+		break;
+		
+	case EV_WATER_TOUCH:
+		DEBUGNAME("EV_WATER_TOUCH");
+		trap_S_StartSound (NULL, es->number, CHAN_AUTO, cgs.media.watrInSound );
+		break;
+	case EV_WATER_LEAVE:
+		DEBUGNAME("EV_WATER_LEAVE");
+		trap_S_StartSound (NULL, es->number, CHAN_AUTO, cgs.media.watrOutSound );
+		break;
+	case EV_WATER_UNDER:
+		DEBUGNAME("EV_WATER_UNDER");
+		trap_S_StartSound (NULL, es->number, CHAN_AUTO, cgs.media.watrUnSound );
+		break;
+	case EV_WATER_CLEAR:
+		DEBUGNAME("EV_WATER_CLEAR");
+		trap_S_StartSound (NULL, es->number, CHAN_AUTO, CG_CustomSound( es->number, "*gasp.wav" ) );
+		break;
+
+	case EV_ITEM_PICKUP:
+		DEBUGNAME("EV_ITEM_PICKUP");
+		{
+			gitem_t	*item;
+			int		index;
+			qboolean	newindex = qfalse;
+
+			index = cg_entities[es->eventParm].currentState.modelindex;		// player predicted
+
+			if (index < 1 && cg_entities[es->eventParm].currentState.isJediMaster)
+			{ //a holocron most likely
+				index = cg_entities[es->eventParm].currentState.trickedentindex4;
+				trap_S_StartSound (NULL, es->number, CHAN_AUTO,	cgs.media.holocronPickup );
+								
+				if (es->number == cg.snap->ps.clientNum && showPowersName[index])
+				{
+					const char *strText = CG_GetStringEdString("MP_INGAME", "PICKUPLINE");
+
+					//Com_Printf("%s %s\n", strText, showPowersName[index]);
+					CG_CenterPrint( va("%s %s\n", strText, CG_GetStringEdString("SP_INGAME",showPowersName[index])), SCREEN_HEIGHT * 0.30, BIGCHAR_WIDTH );
+				}
+
+				//Show the player their force selection bar in case picking the holocron up changed the current selection
+				if (index != FP_SABER_OFFENSE && index != FP_SABER_DEFENSE && index != FP_SABERTHROW &&
+					index != FP_LEVITATION &&
+					es->number == cg.snap->ps.clientNum &&
+					(index == cg.snap->ps.fd.forcePowerSelected || !(cg.snap->ps.fd.forcePowersActive & (1 << cg.snap->ps.fd.forcePowerSelected))))
+				{
+					if (cg.forceSelect != index)
+					{
+						cg.forceSelect = index;
+						newindex = qtrue;
+					}
+				}
+
+				if (es->number == cg.snap->ps.clientNum && newindex)
+				{
+					if (cg.forceSelectTime < cg.time)
+					{
+						cg.forceSelectTime = cg.time;
+					}
+				}
+
+				break;
+			}
+
+			if (cg_entities[es->eventParm].weapon >= cg.time)
+			{ //rww - an unfortunately necessary hack to prevent double item pickups
+				break;
+			}
+
+			//Hopefully even if this entity is somehow removed and replaced with, say, another
+			//item, this time will have expired by the time that item needs to be picked up.
+			//Of course, it's quite possible this will fail miserably, so if you've got a better
+			//solution then please do use it.
+			cg_entities[es->eventParm].weapon = cg.time+500;
+
+			if ( index < 1 || index >= bg_numItems ) {
+				break;
+			}
+			item = &bg_itemlist[ index ];
+
+			if ( /*item->giType != IT_POWERUP && */item->giType != IT_TEAM) {
+				if (item->pickup_sound && item->pickup_sound[0])
+				{
+					trap_S_StartSound (NULL, es->number, CHAN_AUTO,	trap_S_RegisterSound( item->pickup_sound ) );
+				}
+			}
+
+			// show icon and name on status bar
+			if ( es->number == cg.snap->ps.clientNum ) {
+				CG_ItemPickup( index );
+			}
+		}
+		break;
+
+	case EV_GLOBAL_ITEM_PICKUP:
+		DEBUGNAME("EV_GLOBAL_ITEM_PICKUP");
+		{
+			gitem_t	*item;
+			int		index;
+
+			index = es->eventParm;		// player predicted
+
+			if ( index < 1 || index >= bg_numItems ) {
+				break;
+			}
+			item = &bg_itemlist[ index ];
+			// powerup pickups are global
+			if( item->pickup_sound && item->pickup_sound[0] ) {
+				trap_S_StartSound (NULL, cg.snap->ps.clientNum, CHAN_AUTO, trap_S_RegisterSound( item->pickup_sound) );
+			}
+
+			// show icon and name on status bar
+			if ( es->number == cg.snap->ps.clientNum ) {
+				CG_ItemPickup( index );
+			}
+		}
+		break;
+
+	case EV_VEH_FIRE:
+		DEBUGNAME("EV_VEH_FIRE");
+		{
+			centity_t *veh = &cg_entities[es->owner];
+			CG_VehMuzzleFireFX(veh, es);
+		}
+		break;
+
+	//
+	// weapon events
+	//
+	case EV_NOAMMO:
+		DEBUGNAME("EV_NOAMMO");
+//		trap_S_StartSound (NULL, es->number, CHAN_AUTO, cgs.media.noAmmoSound );
+		if ( es->number == cg.snap->ps.clientNum )
+		{
+			if ( CG_InFighter() || CG_InATST() || cg.snap->ps.weapon == WP_NONE )
+			{//just letting us know our vehicle is out of ammo
+				//FIXME: flash something on HUD or give some message so we know we have no ammo
+				centity_t *localCent = &cg_entities[cg.snap->ps.clientNum];
+				if ( localCent->m_pVehicle 
+					&& localCent->m_pVehicle->m_pVehicleInfo
+					&& localCent->m_pVehicle->m_pVehicleInfo->weapon[es->eventParm].soundNoAmmo )
+				{//play the "no Ammo" sound for this weapon
+					trap_S_StartSound (NULL, cg.snap->ps.clientNum, CHAN_AUTO, localCent->m_pVehicle->m_pVehicleInfo->weapon[es->eventParm].soundNoAmmo );
+				}
+				else
+				{//play the default "no ammo" sound
+					trap_S_StartSound (NULL, cg.snap->ps.clientNum, CHAN_AUTO, cgs.media.noAmmoSound );
+				}
+				//flash the HUD so they associate the sound with the visual indicator that they don't have enough ammo
+				if ( cg_vehicleAmmoWarningTime < cg.time
+					|| cg_vehicleAmmoWarning != es->eventParm )
+				{//if there's already one going, don't interrupt it (unless they tried to fire another weapon that's out of ammo)
+					cg_vehicleAmmoWarning = es->eventParm;
+					cg_vehicleAmmoWarningTime = cg.time+500;
+				}
+			}
+			else if ( cg.snap->ps.weapon == WP_SABER )
+			{
+				cg.forceHUDTotalFlashTime = cg.time + 1000;
+			}
+			else
+			{
+				int weap = 0;
+
+				if (es->eventParm && es->eventParm < WP_NUM_WEAPONS)
+				{
+					cg.snap->ps.stats[STAT_WEAPONS] &= ~(1 << es->eventParm);
+					weap = cg.snap->ps.weapon;
+				}
+				else if (es->eventParm)
+				{
+					weap = (es->eventParm-WP_NUM_WEAPONS);
+				}
+				CG_OutOfAmmoChange(weap);
+			}
+		}
+		break;
+	case EV_CHANGE_WEAPON:
+		DEBUGNAME("EV_CHANGE_WEAPON");
+		{
+			int weapon = es->eventParm;
+			weaponInfo_t *weaponInfo;
+			
+			assert(weapon >= 0 && weapon < MAX_WEAPONS);
+
+			weaponInfo = &cg_weapons[weapon];
+
+			assert(weaponInfo);
+
+			if (weaponInfo->selectSound)
+			{
+				trap_S_StartSound (NULL, es->number, CHAN_AUTO, weaponInfo->selectSound );
+			}
+			else if (weapon != WP_SABER)
+			{ //not sure what SP is doing for this but I don't want a select sound for saber (it has the saber-turn-on)
+				trap_S_StartSound (NULL, es->number, CHAN_AUTO, cgs.media.selectSound );
+			}
+		}
+		break;
+	case EV_FIRE_WEAPON:
+		DEBUGNAME("EV_FIRE_WEAPON");
+		if (cent->currentState.number >= MAX_CLIENTS && cent->currentState.eType != ET_NPC)
+		{ //special case for turret firing
+			vec3_t gunpoint, gunangle;
+			mdxaBone_t matrix;
+
+			weaponInfo_t *weaponInfo = &cg_weapons[WP_TURRET];
+
+			if ( !weaponInfo->registered )
+			{
+				CG_RegisterWeapon(WP_TURRET);
+			}
+
+			if (cent->ghoul2)
+			{
+				if (!cent->bolt1)
+				{
+					cent->bolt1 = trap_G2API_AddBolt(cent->ghoul2, 0, "*flash01");
+				}
+				if (!cent->bolt2)
+				{
+					cent->bolt2 = trap_G2API_AddBolt(cent->ghoul2, 0, "*flash02");
+				}
+				trap_G2API_SetBoneAnim(cent->ghoul2, 0, "Bone02", 1, 4, BONE_ANIM_OVERRIDE_FREEZE|BONE_ANIM_BLEND,
+					1.0f, cg.time, -1, 300);
+			}
+			else
+			{
+				break;
+			}
+
+			if (cent->currentState.eventParm)
+			{
+				trap_G2API_GetBoltMatrix(cent->ghoul2, 0, cent->bolt2, &matrix, cent->currentState.angles, cent->currentState.origin, cg.time, cgs.gameModels, cent->modelScale);
+			}
+			else
+			{
+				trap_G2API_GetBoltMatrix(cent->ghoul2, 0, cent->bolt1, &matrix, cent->currentState.angles, cent->currentState.origin, cg.time, cgs.gameModels, cent->modelScale);
+			}
+
+			gunpoint[0] = matrix.matrix[0][3];
+			gunpoint[1] = matrix.matrix[1][3];
+			gunpoint[2] = matrix.matrix[2][3];
+
+			gunangle[0] = -matrix.matrix[0][0];
+			gunangle[1] = -matrix.matrix[1][0];
+			gunangle[2] = -matrix.matrix[2][0];
+
+			trap_FX_PlayEffectID(cgs.effects.mEmplacedMuzzleFlash, gunpoint, gunangle, -1, -1);
+		}
+		else if (cent->currentState.weapon != WP_EMPLACED_GUN || cent->currentState.eType == ET_NPC)
+		{
+			if (cent->currentState.eType == ET_NPC &&
+				cent->currentState.NPC_class == CLASS_VEHICLE &&
+				cent->m_pVehicle)
+			{ //vehicles do nothing for clientside weapon fire events.. at least for now.
+				break;
+			}
+			CG_FireWeapon( cent, qfalse );
+		}
+		break;
+
+	case EV_ALT_FIRE:
+		DEBUGNAME("EV_ALT_FIRE");
+
+		if (cent->currentState.weapon == WP_EMPLACED_GUN)
+		{ //don't do anything for emplaced stuff
+			break;
+		}
+
+		if (cent->currentState.eType == ET_NPC &&
+			cent->currentState.NPC_class == CLASS_VEHICLE &&
+			cent->m_pVehicle)
+		{ //vehicles do nothing for clientside weapon fire events.. at least for now.
+			break;
+		}
+
+		CG_FireWeapon( cent, qtrue );
+
+		//if you just exploded your detpacks and you have no ammo left for them, autoswitch
+		if ( cg.snap->ps.clientNum == cent->currentState.number &&
+			cg.snap->ps.weapon == WP_DET_PACK )
+		{
+			if (cg.snap->ps.ammo[weaponData[WP_DET_PACK].ammoIndex] == 0) 
+			{
+				CG_OutOfAmmoChange(WP_DET_PACK);
+			}
+		}
+
+		break;
+
+	case EV_SABER_ATTACK:
+		DEBUGNAME("EV_SABER_ATTACK");
+		trap_S_StartSound(es->pos.trBase, es->number, CHAN_WEAPON, trap_S_RegisterSound(va("sound/weapons/saber/saberhup%i.wav", Q_irand(1, 8))));
+		break;
+
+	case EV_SABER_HIT:
+		DEBUGNAME("EV_SABER_HIT");
+		if (es->eventParm == 16)
+		{ //Make lots of sparks, something special happened
+			vec3_t fxDir;
+			VectorCopy(es->angles, fxDir);
+			if (!fxDir[0] && !fxDir[1] && !fxDir[2])
+			{
+				fxDir[1] = 1;
+			}
+			trap_S_StartSound(es->origin, es->number, CHAN_AUTO, trap_S_RegisterSound(va("sound/weapons/saber/saberhit%i.wav", Q_irand(1, 3))));
+			trap_FX_PlayEffectID( cgs.effects.mSaberBloodSparks, es->origin, fxDir, -1, -1 );
+			trap_FX_PlayEffectID( cgs.effects.mSaberBloodSparks, es->origin, fxDir, -1, -1 );
+			trap_FX_PlayEffectID( cgs.effects.mSaberBloodSparks, es->origin, fxDir, -1, -1 );
+			trap_FX_PlayEffectID( cgs.effects.mSaberBloodSparks, es->origin, fxDir, -1, -1 );
+			trap_FX_PlayEffectID( cgs.effects.mSaberBloodSparks, es->origin, fxDir, -1, -1 );
+			trap_FX_PlayEffectID( cgs.effects.mSaberBloodSparks, es->origin, fxDir, -1, -1 );
+		}
+		else if (es->eventParm)
+		{ //hit a person
+			vec3_t fxDir;
+			VectorCopy(es->angles, fxDir);
+			if (!fxDir[0] && !fxDir[1] && !fxDir[2])
+			{
+				fxDir[1] = 1;
+			}
+			trap_S_StartSound(es->origin, es->number, CHAN_AUTO, trap_S_RegisterSound(va("sound/weapons/saber/saberhit%i.wav", Q_irand(1, 3))));
+			if ( es->eventParm == 3 )
+			{	// moderate or big hits.
+				trap_FX_PlayEffectID( cgs.effects.mSaberBloodSparksSmall, es->origin, fxDir, -1, -1 );
+			}
+			else if ( es->eventParm == 2 )
+			{	// this is for really big hits.
+				trap_FX_PlayEffectID( cgs.effects.mSaberBloodSparksMid, es->origin, fxDir, -1, -1 );
+			}
+			else
+			{	// this should really just be done in the effect itself, no?
+				trap_FX_PlayEffectID( cgs.effects.mSaberBloodSparks, es->origin, fxDir, -1, -1 );
+				trap_FX_PlayEffectID( cgs.effects.mSaberBloodSparks, es->origin, fxDir, -1, -1 );
+				trap_FX_PlayEffectID( cgs.effects.mSaberBloodSparks, es->origin, fxDir, -1, -1 );
+			}
+		}
+		else
+		{ //hit something else
+			vec3_t fxDir;
+			VectorCopy(es->angles, fxDir);
+			if (!fxDir[0] && !fxDir[1] && !fxDir[2])
+			{
+				fxDir[1] = 1;
+			}
+			//old jk2mp method
+			/*
+			trap_S_StartSound(es->origin, es->number, CHAN_AUTO, trap_S_RegisterSound("sound/weapons/saber/saberhit.wav"));
+			trap_FX_PlayEffectID( trap_FX_RegisterEffect("saber/spark.efx"), es->origin, fxDir, -1, -1 );
+			*/
+
+			trap_FX_PlayEffectID( cgs.effects.mSaberCut, es->origin, fxDir, -1, -1 );
+		}
+
+		//rww - this means we have the number of the ent being hit and the ent that owns the saber doing
+		//the hit. This being the case, we can store these indecies and the current time in order to do
+		//some visual tricks on the client between frames to make it look like we're actually continuing
+		//to hit between server frames.
+		if (es->otherEntityNum != ENTITYNUM_NONE && es->otherEntityNum2 != ENTITYNUM_NONE)
+		{
+			centity_t *saberOwner;
+
+			saberOwner = &cg_entities[es->otherEntityNum2];
+
+			saberOwner->serverSaberHitIndex = es->otherEntityNum;
+			saberOwner->serverSaberHitTime = cg.time;
+
+			if (es->eventParm)
+			{
+				saberOwner->serverSaberFleshImpact = qtrue;
+			}
+			else
+			{
+				saberOwner->serverSaberFleshImpact = qfalse;
+			}
+		}
+		break;
+
+	case EV_SABER_BLOCK:
+		DEBUGNAME("EV_SABER_BLOCK");
+
+		if (es->eventParm)
+		{ //saber block
+			qboolean cullPass = qfalse;
+
+			if (cg.mInRMG)
+			{
+				trace_t tr;
+				vec3_t vecSub;
+
+				VectorSubtract(cg.refdef.vieworg, es->origin, vecSub);
+
+				if (VectorLength(vecSub) < 5000)
+				{
+					CG_Trace(&tr, cg.refdef.vieworg, NULL, NULL, es->origin, ENTITYNUM_NONE, CONTENTS_TERRAIN|CONTENTS_SOLID);
+
+					if (tr.fraction == 1.0 || tr.entityNum < MAX_CLIENTS)
+					{
+						cullPass = qtrue;
+					}
+				}
+			}
+			else
+			{
+				cullPass = qtrue;
+			}
+
+			if (cullPass)
+			{
+				vec3_t fxDir;
+
+				VectorCopy(es->angles, fxDir);
+				if (!fxDir[0] && !fxDir[1] && !fxDir[2])
+				{
+					fxDir[1] = 1;
+				}
+				trap_S_StartSound(es->origin, es->number, CHAN_AUTO, trap_S_RegisterSound(va( "sound/weapons/saber/saberblock%d.wav", Q_irand(1, 9) )));
+				trap_FX_PlayEffectID( cgs.effects.mSaberBlock, es->origin, fxDir, -1, -1 );
+
+				cg_saberFlashTime = cg.time-50;
+				VectorCopy( es->origin, cg_saberFlashPos );
+			}
+		}
+		else
+		{ //projectile block
+			vec3_t fxDir;
+			VectorCopy(es->angles, fxDir);
+			if (!fxDir[0] && !fxDir[1] && !fxDir[2])
+			{
+				fxDir[1] = 1;
+			}
+			trap_FX_PlayEffectID(cgs.effects.mBlasterDeflect, es->origin, fxDir, -1, -1);
+		}
+		break;
+
+	case EV_SABER_CLASHFLARE:
+		DEBUGNAME("EV_SABER_CLASHFLARE");
+		{
+			qboolean cullPass = qfalse;
+
+			if (cg.mInRMG)
+			{
+				trace_t tr;
+				vec3_t vecSub;
+
+				VectorSubtract(cg.refdef.vieworg, es->origin, vecSub);
+
+				if (VectorLength(vecSub) < 5000)
+				{
+					CG_Trace(&tr, cg.refdef.vieworg, NULL, NULL, es->origin, ENTITYNUM_NONE, CONTENTS_TERRAIN|CONTENTS_SOLID);
+
+					if (tr.fraction == 1.0 || tr.entityNum < MAX_CLIENTS)
+					{
+						cullPass = qtrue;
+					}
+				}
+			}
+			else
+			{
+				cullPass = qtrue;
+			}
+
+			if (cullPass)
+			{
+				cg_saberFlashTime = cg.time-50;
+				VectorCopy( es->origin, cg_saberFlashPos );
+			}
+			trap_S_StartSound ( es->origin, -1, CHAN_WEAPON, trap_S_RegisterSound( va("sound/weapons/saber/saberhitwall%i", Q_irand(1, 3)) ) );
+		}
+		break;
+
+	case EV_SABER_UNHOLSTER:
+		DEBUGNAME("EV_SABER_UNHOLSTER");
+		{
+			clientInfo_t *ci = NULL;
+
+			if (es->eType == ET_NPC)
+			{
+				ci = cg_entities[es->number].npcClient;
+			}
+			else if (es->number < MAX_CLIENTS)
+			{
+				ci = &cgs.clientinfo[es->number];
+			}
+
+			if (ci)
+			{
+				if (ci->saber[0].soundOn)
+				{
+					trap_S_StartSound (NULL, es->number, CHAN_AUTO, ci->saber[0].soundOn );
+				}
+				if (ci->saber[1].soundOn)
+				{
+					trap_S_StartSound (NULL, es->number, CHAN_AUTO, ci->saber[1].soundOn );
+				}
+			}
+		}
+		break;
+
+	case EV_BECOME_JEDIMASTER:
+		DEBUGNAME("EV_SABER_UNHOLSTER");
+		{
+			trace_t tr;
+			vec3_t playerMins = {-15, -15, DEFAULT_MINS_2+8};
+			vec3_t playerMaxs = {15, 15, DEFAULT_MAXS_2};
+			vec3_t ang, pos, dpos;
+
+			VectorClear(ang);
+			ang[ROLL] = 1;
+
+			VectorCopy(position, dpos);
+			dpos[2] -= 4096;
+
+			CG_Trace(&tr, position, playerMins, playerMaxs, dpos, es->number, MASK_SOLID);
+			VectorCopy(tr.endpos, pos);
+			
+			if (tr.fraction == 1)
+			{
+				break;
+			}
+			trap_FX_PlayEffectID(cgs.effects.mJediSpawn, pos, ang, -1, -1);
+
+			trap_S_StartSound (NULL, es->number, CHAN_AUTO, trap_S_RegisterSound( "sound/weapons/saber/saberon.wav" ) );
+
+			if (cg.snap->ps.clientNum == es->number)
+			{
+				trap_S_StartLocalSound(cgs.media.happyMusic, CHAN_LOCAL);
+				CGCam_SetMusicMult(0.3, 5000);
+			}
+		}
+		break;
+
+	case EV_DISRUPTOR_MAIN_SHOT:
+		DEBUGNAME("EV_DISRUPTOR_MAIN_SHOT");
+		if (cent->currentState.eventParm != cg.snap->ps.clientNum ||
+			cg.renderingThirdPerson)
+		{ //h4q3ry
+			CG_GetClientWeaponMuzzleBoltPoint(cent->currentState.eventParm, cent->currentState.origin2);
+		}
+		else
+		{
+			if (cg.lastFPFlashPoint[0] ||cg.lastFPFlashPoint[1] || cg.lastFPFlashPoint[2])
+			{ //get the position of the muzzle flash for the first person weapon model from the last frame
+				VectorCopy(cg.lastFPFlashPoint, cent->currentState.origin2);
+			}
+		}
+		FX_DisruptorMainShot( cent->currentState.origin2, cent->lerpOrigin ); 
+		break;
+
+	case EV_DISRUPTOR_SNIPER_SHOT:
+		DEBUGNAME("EV_DISRUPTOR_SNIPER_SHOT");
+		if (cent->currentState.eventParm != cg.snap->ps.clientNum ||
+			cg.renderingThirdPerson)
+		{ //h4q3ry
+			CG_GetClientWeaponMuzzleBoltPoint(cent->currentState.eventParm, cent->currentState.origin2);
+		}
+		else
+		{
+			if (cg.lastFPFlashPoint[0] ||cg.lastFPFlashPoint[1] || cg.lastFPFlashPoint[2])
+			{ //get the position of the muzzle flash for the first person weapon model from the last frame
+				VectorCopy(cg.lastFPFlashPoint, cent->currentState.origin2);
+			}
+		}
+		FX_DisruptorAltShot( cent->currentState.origin2, cent->lerpOrigin, cent->currentState.shouldtarget );
+		break;
+
+	case EV_DISRUPTOR_SNIPER_MISS:
+		DEBUGNAME("EV_DISRUPTOR_SNIPER_MISS");
+		ByteToDir( es->eventParm, dir );
+		if (es->weapon)
+		{ //primary
+			FX_DisruptorHitWall( cent->lerpOrigin, dir );
+		}
+		else
+		{ //secondary
+			FX_DisruptorAltMiss( cent->lerpOrigin, dir );
+		}
+		break;
+
+	case EV_DISRUPTOR_HIT:
+		DEBUGNAME("EV_DISRUPTOR_HIT");
+		ByteToDir( es->eventParm, dir );
+		if (es->weapon)
+		{ //client
+			FX_DisruptorHitPlayer( cent->lerpOrigin, dir, qtrue );
+		}
+		else
+		{ //non-client
+			FX_DisruptorHitWall( cent->lerpOrigin, dir );
+		}
+		break;
+
+	case EV_DISRUPTOR_ZOOMSOUND:
+		DEBUGNAME("EV_DISRUPTOR_ZOOMSOUND");
+		if (es->number == cg.snap->ps.clientNum)
+		{
+			if (cg.snap->ps.zoomMode)
+			{
+				trap_S_StartLocalSound(trap_S_RegisterSound("sound/weapons/disruptor/zoomstart.wav"), CHAN_AUTO);
+			}
+			else
+			{
+				trap_S_StartLocalSound(trap_S_RegisterSound("sound/weapons/disruptor/zoomend.wav"), CHAN_AUTO);
+			}
+		}
+		break;
+	case EV_PREDEFSOUND:
+		DEBUGNAME("EV_PREDEFSOUND");
+		{
+			int sID = -1;
+
+			switch (es->eventParm)
+			{
+			case PDSOUND_PROTECTHIT:
+				sID = trap_S_RegisterSound("sound/weapons/force/protecthit.mp3");
+				break;
+			case PDSOUND_PROTECT:
+				sID = trap_S_RegisterSound("sound/weapons/force/protect.mp3");
+				break;
+			case PDSOUND_ABSORBHIT:
+				sID = trap_S_RegisterSound("sound/weapons/force/absorbhit.mp3");
+				if (es->trickedentindex >= 0 && es->trickedentindex < MAX_CLIENTS)
+				{
+					int clnum = es->trickedentindex;
+
+					cg_entities[clnum].teamPowerEffectTime = cg.time + 1000;
+					cg_entities[clnum].teamPowerType = 3;
+				}
+				break;
+			case PDSOUND_ABSORB:
+				sID = trap_S_RegisterSound("sound/weapons/force/absorb.mp3");
+				break;
+			case PDSOUND_FORCEJUMP:
+				sID = trap_S_RegisterSound("sound/weapons/force/jump.mp3");
+				break;
+			case PDSOUND_FORCEGRIP:
+				sID = trap_S_RegisterSound("sound/weapons/force/grip.mp3");
+				break;
+			default:
+				break;
+			}
+
+			if (sID != 1)
+			{
+				trap_S_StartSound(es->origin, es->number, CHAN_AUTO, sID);
+			}
+		}
+		break;
+
+	case EV_TEAM_POWER:
+		DEBUGNAME("EV_TEAM_POWER");
+		{
+			int clnum = 0;
+
+			while (clnum < MAX_CLIENTS)
+			{
+				if (CG_InClientBitflags(es, clnum))
+				{
+					if (es->eventParm == 1)
+					{ //eventParm 1 is heal
+						trap_S_StartSound (NULL, clnum, CHAN_AUTO, cgs.media.teamHealSound );
+						cg_entities[clnum].teamPowerEffectTime = cg.time + 1000;
+						cg_entities[clnum].teamPowerType = 1;
+					}
+					else
+					{ //eventParm 2 is force regen
+						trap_S_StartSound (NULL, clnum, CHAN_AUTO, cgs.media.teamRegenSound );
+						cg_entities[clnum].teamPowerEffectTime = cg.time + 1000;
+						cg_entities[clnum].teamPowerType = 0;
+					}
+				}
+				clnum++;
+			}
+		}
+		break;
+
+	case EV_SCREENSHAKE:
+		DEBUGNAME("EV_SCREENSHAKE");
+		if (!es->modelindex || cg.predictedPlayerState.clientNum == es->modelindex-1)
+		{
+			CGCam_Shake(es->angles[0], es->time);
+		}
+		break;
+	case EV_LOCALTIMER:
+		DEBUGNAME("EV_LOCALTIMER");
+		if (es->owner == cg.predictedPlayerState.clientNum)
+		{
+			CG_LocalTimingBar(es->time, es->time2);
+		}
+		break;
+	case EV_USE_ITEM0:
+		DEBUGNAME("EV_USE_ITEM0");
+		CG_UseItem( cent );
+		break;
+	case EV_USE_ITEM1:
+		DEBUGNAME("EV_USE_ITEM1");
+		CG_UseItem( cent );
+		break;
+	case EV_USE_ITEM2:
+		DEBUGNAME("EV_USE_ITEM2");
+		CG_UseItem( cent );
+		break;
+	case EV_USE_ITEM3:
+		DEBUGNAME("EV_USE_ITEM3");
+		CG_UseItem( cent );
+		break;
+	case EV_USE_ITEM4:
+		DEBUGNAME("EV_USE_ITEM4");
+		CG_UseItem( cent );
+		break;
+	case EV_USE_ITEM5:
+		DEBUGNAME("EV_USE_ITEM5");
+		CG_UseItem( cent );
+		break;
+	case EV_USE_ITEM6:
+		DEBUGNAME("EV_USE_ITEM6");
+		CG_UseItem( cent );
+		break;
+	case EV_USE_ITEM7:
+		DEBUGNAME("EV_USE_ITEM7");
+		CG_UseItem( cent );
+		break;
+	case EV_USE_ITEM8:
+		DEBUGNAME("EV_USE_ITEM8");
+		CG_UseItem( cent );
+		break;
+	case EV_USE_ITEM9:
+		DEBUGNAME("EV_USE_ITEM9");
+		CG_UseItem( cent );
+		break;
+	case EV_USE_ITEM10:
+		DEBUGNAME("EV_USE_ITEM10");
+		CG_UseItem( cent );
+		break;
+	case EV_USE_ITEM11:
+		DEBUGNAME("EV_USE_ITEM11");
+		CG_UseItem( cent );
+		break;
+	case EV_USE_ITEM12:
+		DEBUGNAME("EV_USE_ITEM12");
+		CG_UseItem( cent );
+		break;
+	case EV_USE_ITEM13:
+		DEBUGNAME("EV_USE_ITEM13");
+		CG_UseItem( cent );
+		break;
+	case EV_USE_ITEM14:
+		DEBUGNAME("EV_USE_ITEM14");
+		CG_UseItem( cent );
+		break;
+
+	case EV_ITEMUSEFAIL:
+		DEBUGNAME("EV_ITEMUSEFAIL");
+		if (cg.snap->ps.clientNum == es->number)
+		{
+			char *psStringEDRef = NULL;
+
+			switch(es->eventParm)
+			{
+			case SENTRY_NOROOM:
+				psStringEDRef = (char *)CG_GetStringEdString("MP_INGAME", "SENTRY_NOROOM");
+				break;
+			case SENTRY_ALREADYPLACED:
+				psStringEDRef = (char *)CG_GetStringEdString("MP_INGAME", "SENTRY_ALREADYPLACED");
+				break;
+			case SHIELD_NOROOM:
+				psStringEDRef = (char *)CG_GetStringEdString("MP_INGAME", "SHIELD_NOROOM");
+				break;
+			case SEEKER_ALREADYDEPLOYED:
+				psStringEDRef = (char *)CG_GetStringEdString("MP_INGAME", "SEEKER_ALREADYDEPLOYED");
+				break;
+			default:
+				break;
+			}
+
+			if (!psStringEDRef)
+			{
+				break;
+			}
+
+			Com_Printf("%s\n", psStringEDRef);
+		}
+		break;
+
+	//=================================================================
+
+	//
+	// other events
+	//
+	case EV_PLAYER_TELEPORT_IN:
+		DEBUGNAME("EV_PLAYER_TELEPORT_IN");
+		{
+			trace_t tr;
+			vec3_t playerMins = {-15, -15, DEFAULT_MINS_2+8};
+			vec3_t playerMaxs = {15, 15, DEFAULT_MAXS_2};
+			vec3_t ang, pos, dpos;
+
+			VectorClear(ang);
+			ang[ROLL] = 1;
+
+			VectorCopy(position, dpos);
+			dpos[2] -= 4096;
+
+			CG_Trace(&tr, position, playerMins, playerMaxs, dpos, es->number, MASK_SOLID);
+			VectorCopy(tr.endpos, pos);
+			
+			trap_S_StartSound (NULL, es->number, CHAN_AUTO, cgs.media.teleInSound );
+
+			if (tr.fraction == 1)
+			{
+				break;
+			}
+			trap_FX_PlayEffectID(cgs.effects.mSpawn, pos, ang, -1, -1);
+		}
+		break;
+
+	case EV_PLAYER_TELEPORT_OUT:
+		DEBUGNAME("EV_PLAYER_TELEPORT_OUT");
+		{
+			trace_t tr;
+			vec3_t playerMins = {-15, -15, DEFAULT_MINS_2+8};
+			vec3_t playerMaxs = {15, 15, DEFAULT_MAXS_2};
+			vec3_t ang, pos, dpos;
+
+			VectorClear(ang);
+			ang[ROLL] = 1;
+
+			VectorCopy(position, dpos);
+			dpos[2] -= 4096;
+
+			CG_Trace(&tr, position, playerMins, playerMaxs, dpos, es->number, MASK_SOLID);
+			VectorCopy(tr.endpos, pos);
+
+			trap_S_StartSound (NULL, es->number, CHAN_AUTO, cgs.media.teleOutSound );
+
+			if (tr.fraction == 1)
+			{
+				break;
+			}
+			trap_FX_PlayEffectID(cgs.effects.mSpawn, pos, ang, -1, -1);
+		}
+		break;
+
+	case EV_ITEM_POP:
+		DEBUGNAME("EV_ITEM_POP");
+		trap_S_StartSound (NULL, es->number, CHAN_AUTO, cgs.media.respawnSound );
+		break;
+	case EV_ITEM_RESPAWN:
+		DEBUGNAME("EV_ITEM_RESPAWN");
+		cent->miscTime = cg.time;	// scale up from this
+		trap_S_StartSound (NULL, es->number, CHAN_AUTO, cgs.media.respawnSound );
+		break;
+
+	case EV_GRENADE_BOUNCE:
+		DEBUGNAME("EV_GRENADE_BOUNCE");
+		//Do something here?
+		break;
+
+	case EV_SCOREPLUM:
+		DEBUGNAME("EV_SCOREPLUM");
+		CG_ScorePlum( cent->currentState.otherEntityNum, cent->lerpOrigin, cent->currentState.time );
+		break;
+
+	case EV_CTFMESSAGE:
+		DEBUGNAME("EV_CTFMESSAGE");
+		CG_GetCTFMessageEvent(es);
+		break;
+
+	case EV_BODYFADE:
+		if (es->eType != ET_BODY)
+		{
+			assert(!"EV_BODYFADE event from a non-corpse");
+			break;
+		}
+		
+		if (cent->ghoul2 && trap_G2_HaveWeGhoul2Models(cent->ghoul2))
+		{
+			//turn the inside of the face off, to avoid showing the mouth when we start alpha fading the corpse
+			trap_G2API_SetSurfaceOnOff( cent->ghoul2, "head_eyes_mouth", 0x00000002/*G2SURFACEFLAG_OFF*/ );
+		}
+
+		cent->bodyFadeTime = cg.time + 60000;
+		break;
+
+	//
+	// siege gameplay events
+	//
+	case EV_SIEGE_ROUNDOVER:
+		DEBUGNAME("EV_SIEGE_ROUNDOVER");
+		CG_SiegeRoundOver(&cg_entities[cent->currentState.weapon], cent->currentState.eventParm);
+		break;
+	case EV_SIEGE_OBJECTIVECOMPLETE:
+		DEBUGNAME("EV_SIEGE_OBJECTIVECOMPLETE");
+		CG_SiegeObjectiveCompleted(&cg_entities[cent->currentState.weapon], cent->currentState.eventParm, cent->currentState.trickedentindex);
+		break;
+
+	case EV_DESTROY_GHOUL2_INSTANCE:
+		DEBUGNAME("EV_DESTROY_GHOUL2_INSTANCE");
+		if (cg_entities[es->eventParm].ghoul2 && trap_G2_HaveWeGhoul2Models(cg_entities[es->eventParm].ghoul2))
+		{
+			if (es->eventParm < MAX_CLIENTS)
+			{ //You try to do very bad thing!
+#ifdef _DEBUG
+				Com_Printf("WARNING: Tried to kill a client ghoul2 instance with a server event!\n");
+#endif
+				break;
+			}
+			trap_G2API_CleanGhoul2Models(&(cg_entities[es->eventParm].ghoul2));
+		}
+		break;
+
+	case EV_DESTROY_WEAPON_MODEL:
+		DEBUGNAME("EV_DESTROY_WEAPON_MODEL");
+		if (cg_entities[es->eventParm].ghoul2 && trap_G2_HaveWeGhoul2Models(cg_entities[es->eventParm].ghoul2) &&
+			trap_G2API_HasGhoul2ModelOnIndex(&(cg_entities[es->eventParm].ghoul2), 1))
+		{
+			trap_G2API_RemoveGhoul2Model(&(cg_entities[es->eventParm].ghoul2), 1);
+		}
+		break;
+
+	case EV_GIVE_NEW_RANK:
+		DEBUGNAME("EV_GIVE_NEW_RANK");
+		if (es->trickedentindex == cg.snap->ps.clientNum)
+		{
+			trap_Cvar_Set("ui_rankChange", va("%i", es->eventParm));
+
+			trap_Cvar_Set("ui_myteam", va("%i", es->bolt2));
+
+			if (!( trap_Key_GetCatcher() & KEYCATCH_UI ) && !es->bolt1)
+			{
+				trap_OpenUIMenu(UIMENU_PLAYERCONFIG);
+			}
+		}
+		break;
+
+	case EV_SET_FREE_SABER:
+		DEBUGNAME("EV_SET_FREE_SABER");
+
+		trap_Cvar_Set("ui_freeSaber", va("%i", es->eventParm));
+		break;
+
+	case EV_SET_FORCE_DISABLE:
+		DEBUGNAME("EV_SET_FORCE_DISABLE");
+
+		trap_Cvar_Set("ui_forcePowerDisable", va("%i", es->eventParm));
+		break;
+
+	//
+	// missile impacts
+	//
+	case EV_CONC_ALT_IMPACT:
+		DEBUGNAME("EV_CONC_ALT_IMPACT");
+		{
+			float dist;
+			float shotDist = VectorNormalize(es->angles);
+			vec3_t spot;
+
+			for (dist = 0.0f; dist < shotDist; dist += 64.0f)
+			{ //one effect would be.. a whole lot better
+				VectorMA( es->origin2, dist, es->angles, spot );
+                trap_FX_PlayEffectID(cgs.effects.mConcussionAltRing, spot, es->angles2, -1, -1);
+			}
+
+			ByteToDir( es->eventParm, dir );
+			CG_MissileHitWall(WP_CONCUSSION, es->owner, position, dir, IMPACTSOUND_DEFAULT, qtrue, 0);
+
+			FX_ConcAltShot(es->origin2, spot);
+
+			//steal the bezier effect from the disruptor
+			FX_DisruptorAltMiss(position, dir);
+		}
+		break;
+
+	case EV_MISSILE_STICK:
+		DEBUGNAME("EV_MISSILE_STICK");
+//		trap_S_StartSound (NULL, es->number, CHAN_AUTO, cgs.media.missileStick );
+		break;
+
+	case EV_MISSILE_HIT:
+		DEBUGNAME("EV_MISSILE_HIT");
+		ByteToDir( es->eventParm, dir );
+		if ( es->emplacedOwner )
+		{//hack: this is an index to a custom effect to use
+			trap_FX_PlayEffectID(cgs.gameEffects[es->emplacedOwner], position, dir, -1, -1);
+		}
+		else if ( CG_VehicleWeaponImpact( cent ) )
+		{//a vehicle missile that uses an overridden impact effect...
+		}
+		else if (cent->currentState.eFlags & EF_ALT_FIRING)
+		{
+			CG_MissileHitPlayer( es->weapon, position, dir, es->otherEntityNum, qtrue);
+		}
+		else
+		{
+			CG_MissileHitPlayer( es->weapon, position, dir, es->otherEntityNum, qfalse);
+		}
+
+		if (cg_ghoul2Marks.integer &&
+			es->trickedentindex)
+		{ //flag to place a ghoul2 mark
+			CG_G2MarkEvent(es);
+		}
+		break;
+
+	case EV_MISSILE_MISS:
+		DEBUGNAME("EV_MISSILE_MISS");
+		ByteToDir( es->eventParm, dir );
+		if ( es->emplacedOwner )
+		{//hack: this is an index to a custom effect to use
+			trap_FX_PlayEffectID(cgs.gameEffects[es->emplacedOwner], position, dir, -1, -1);
+		}
+		else if ( CG_VehicleWeaponImpact( cent ) )
+		{//a vehicle missile that used an overridden impact effect...
+		}
+		else if (cent->currentState.eFlags & EF_ALT_FIRING)
+		{
+			CG_MissileHitWall(es->weapon, 0, position, dir, IMPACTSOUND_DEFAULT, qtrue, es->generic1);
+		}
+		else
+		{
+			CG_MissileHitWall(es->weapon, 0, position, dir, IMPACTSOUND_DEFAULT, qfalse, 0);
+		}
+
+		if (cg_ghoul2Marks.integer &&
+			es->trickedentindex)
+		{ //flag to place a ghoul2 mark
+			CG_G2MarkEvent(es);
+		}
+		break;
+
+	case EV_MISSILE_MISS_METAL:
+		DEBUGNAME("EV_MISSILE_MISS_METAL");
+		ByteToDir( es->eventParm, dir );
+		if ( es->emplacedOwner )
+		{//hack: this is an index to a custom effect to use
+			trap_FX_PlayEffectID(cgs.gameEffects[es->emplacedOwner], position, dir, -1, -1);
+		}
+		else if ( CG_VehicleWeaponImpact( cent ) )
+		{//a vehicle missile that used an overridden impact effect...
+		}
+		else if (cent->currentState.eFlags & EF_ALT_FIRING)
+		{
+			CG_MissileHitWall(es->weapon, 0, position, dir, IMPACTSOUND_METAL, qtrue, es->generic1);
+		}
+		else
+		{
+			CG_MissileHitWall(es->weapon, 0, position, dir, IMPACTSOUND_METAL, qfalse, 0);
+		}
+		break;
+
+	case EV_PLAY_EFFECT:
+		DEBUGNAME("EV_PLAY_EFFECT");
+		switch(es->eventParm)
+		{ //it isn't a hack, it's ingenuity!
+		case EFFECT_SMOKE:
+			eID = cgs.effects.mEmplacedDeadSmoke;
+			break;
+		case EFFECT_EXPLOSION:
+			eID = cgs.effects.mEmplacedExplode;
+			break;
+		case EFFECT_EXPLOSION_PAS:
+			eID = cgs.effects.mTurretExplode;
+			break;
+		case EFFECT_SPARK_EXPLOSION:
+			eID = cgs.effects.mSparkExplosion;
+			break;
+		case EFFECT_EXPLOSION_TRIPMINE:
+			eID = cgs.effects.mTripmineExplosion;
+			break;
+		case EFFECT_EXPLOSION_DETPACK:
+			eID = cgs.effects.mDetpackExplosion;
+			break;
+		case EFFECT_EXPLOSION_FLECHETTE:
+			eID = cgs.effects.mFlechetteAltBlow;
+			break;
+		case EFFECT_STUNHIT:
+			eID = cgs.effects.mStunBatonFleshImpact;
+			break;
+		case EFFECT_EXPLOSION_DEMP2ALT:
+			FX_DEMP2_AltDetonate( cent->lerpOrigin, es->weapon );
+			eID = cgs.effects.mAltDetonate;
+			break;
+		case EFFECT_EXPLOSION_TURRET:
+			eID = cgs.effects.mTurretExplode;
+			break;
+		case EFFECT_SPARKS:
+			eID = cgs.effects.mSparksExplodeNoSound;
+			break;
+		case EFFECT_WATER_SPLASH:
+			eID = cgs.effects.waterSplash;
+			break;
+		case EFFECT_ACID_SPLASH:
+			eID = cgs.effects.acidSplash;
+			break;
+		case EFFECT_LAVA_SPLASH:
+			eID = cgs.effects.lavaSplash;
+			break;
+		case EFFECT_LANDING_MUD:
+			eID = cgs.effects.landingMud;
+			break;
+		case EFFECT_LANDING_SAND:
+			eID = cgs.effects.landingSand;
+			break;
+		case EFFECT_LANDING_DIRT:
+			eID = cgs.effects.landingDirt;
+			break;
+		case EFFECT_LANDING_SNOW:
+			eID = cgs.effects.landingSnow;
+			break;
+		case EFFECT_LANDING_GRAVEL:
+			eID = cgs.effects.landingGravel;
+			break;
+		default:
+			eID = -1;
+			break;
+		}
+
+		if (eID != -1)
+		{
+			vec3_t fxDir;
+
+			VectorCopy(es->angles, fxDir);
+
+			if (!fxDir[0] && !fxDir[1] && !fxDir[2])
+			{
+				fxDir[1] = 1;
+			}
+
+			trap_FX_PlayEffectID(eID, es->origin, fxDir, -1, -1);
+		}
+		break;
+
+	case EV_PLAY_EFFECT_ID:
+	case EV_PLAY_PORTAL_EFFECT_ID:
+		DEBUGNAME("EV_PLAY_EFFECT_ID");
+		{
+			vec3_t fxDir;
+			qboolean portalEffect = qfalse;
+			int efxIndex = 0;
+
+			if (event == EV_PLAY_PORTAL_EFFECT_ID)
+			{ //This effect should only be played inside sky portals.
+				portalEffect = qtrue;
+			}
+
+			AngleVectors(es->angles, fxDir, 0, 0);
+			
+			if (!fxDir[0] && !fxDir[1] && !fxDir[2])
+			{
+				fxDir[1] = 1;
+			}
+
+			if ( cgs.gameEffects[ es->eventParm ] )
+			{
+				efxIndex = cgs.gameEffects[es->eventParm];
+			}
+			else
+			{
+				s = CG_ConfigString( CS_EFFECTS + es->eventParm );
+				if (s && s[0])
+				{
+					efxIndex = trap_FX_RegisterEffect(s);
+				}
+			}
+
+			if (efxIndex)
+			{
+				if (portalEffect)
+				{
+					trap_FX_PlayPortalEffectID(efxIndex, position, fxDir, -1, -1 );
+				}
+				else
+				{
+					trap_FX_PlayEffectID(efxIndex, position, fxDir, -1, -1 );
+				}
+			}
+		}
+		break;
+
+	case EV_PLAYDOORSOUND:
+		CG_PlayDoorSound(cent, es->eventParm);
+		break;
+	case EV_PLAYDOORLOOPSOUND:
+		CG_PlayDoorLoopSound(cent);
+		break;
+	case EV_BMODEL_SOUND:
+		DEBUGNAME("EV_BMODEL_SOUND");
+		{
+			sfxHandle_t sfx;
+			const char *soundSet;
+			
+			soundSet = CG_ConfigString( CS_AMBIENT_SET + es->soundSetIndex );
+
+			if (!soundSet || !soundSet[0])
+			{
+				break;
+			}
+
+			sfx = trap_AS_GetBModelSound(soundSet, es->eventParm);
+
+			if (sfx == -1)
+			{
+				break;
+			}
+
+			trap_S_StartSound( NULL, es->number, CHAN_AUTO, sfx );
+		}
+		break;
+
+
+	case EV_MUTE_SOUND:
+		DEBUGNAME("EV_MUTE_SOUND");
+		if (cg_entities[es->trickedentindex2].currentState.eFlags & EF_SOUNDTRACKER)
+		{
+			cg_entities[es->trickedentindex2].currentState.eFlags -= EF_SOUNDTRACKER;
+		}
+		trap_S_MuteSound(es->trickedentindex2, es->trickedentindex);
+		CG_S_StopLoopingSound(es->trickedentindex2, -1);
+		break;
+
+	case EV_VOICECMD_SOUND:
+		DEBUGNAME("EV_VOICECMD_SOUND");
+		if (es->groundEntityNum >= MAX_CLIENTS)
+		{ //don't ever use this unless it is being used on a real client
+			break;
+		}
+		{
+			sfxHandle_t sfx = cgs.gameSounds[ es->eventParm ];
+			clientInfo_t *ci = &cgs.clientinfo[es->groundEntityNum];
+			centity_t *vChatEnt = &cg_entities[es->groundEntityNum];
+			char descr[1024];
+
+			strcpy(descr, CG_GetStringForVoiceSound(CG_ConfigString( CS_SOUNDS + es->eventParm )));
+
+			if (!sfx)
+			{
+				s = CG_ConfigString( CS_SOUNDS + es->eventParm );
+				sfx = CG_CustomSound( es->groundEntityNum, s );
+			}
+
+			if (sfx)
+			{
+				if (es->groundEntityNum != cg.predictedPlayerState.clientNum)
+				{ //play on the head as well to simulate hearing in radio and in world
+					if (ci->team == cg.predictedPlayerState.persistant[PERS_TEAM])
+					{ //don't hear it if this person is on the other team, but they can still
+						//hear it in the world spot.
+						trap_S_StartSound (NULL, cg.snap->ps.clientNum, CHAN_MENU1, sfx);
+					}
+				}
+				if (ci->team == cg.predictedPlayerState.persistant[PERS_TEAM])
+				{ //add to the chat box
+					//hear it in the world spot.
+					char vchatstr[1024];
+					strcpy(vchatstr, va("<%s: %s>\n", ci->name, descr));
+					CG_Printf(vchatstr);
+					CG_ChatBox_AddString(vchatstr);
+				}
+
+				//and play in world for everyone
+				trap_S_StartSound (NULL, es->groundEntityNum, CHAN_VOICE, sfx);
+				vChatEnt->vChatTime = cg.time + 1000;
+			}
+		}
+		break;
+
+	case EV_GENERAL_SOUND:
+		DEBUGNAME("EV_GENERAL_SOUND");
+		if (es->saberEntityNum == TRACK_CHANNEL_2 || es->saberEntityNum == TRACK_CHANNEL_3 ||
+			es->saberEntityNum == TRACK_CHANNEL_5)
+		{ //channels 2 and 3 are for speed and rage, 5 for sight
+			if ( cgs.gameSounds[ es->eventParm ] )
+			{
+				CG_S_AddRealLoopingSound(es->number, es->pos.trBase, vec3_origin, cgs.gameSounds[ es->eventParm ] );
+			}
+		}
+		else
+		{
+			if ( cgs.gameSounds[ es->eventParm ] ) {
+				trap_S_StartSound (NULL, es->number, es->saberEntityNum, cgs.gameSounds[ es->eventParm ] );
+			} else {
+				s = CG_ConfigString( CS_SOUNDS + es->eventParm );
+				trap_S_StartSound (NULL, es->number, es->saberEntityNum, CG_CustomSound( es->number, s ) );
+			}
+		}
+		break;
+
+	case EV_GLOBAL_SOUND:	// play from the player's head so it never diminishes
+		DEBUGNAME("EV_GLOBAL_SOUND");
+		if ( cgs.gameSounds[ es->eventParm ] ) {
+			trap_S_StartSound (NULL, cg.snap->ps.clientNum, CHAN_MENU1, cgs.gameSounds[ es->eventParm ] );
+		} else {
+			s = CG_ConfigString( CS_SOUNDS + es->eventParm );
+			trap_S_StartSound (NULL, cg.snap->ps.clientNum, CHAN_MENU1, CG_CustomSound( es->number, s ) );
+		}
+		break;
+
+	case EV_GLOBAL_TEAM_SOUND:	// play from the player's head so it never diminishes
+		{
+			DEBUGNAME("EV_GLOBAL_TEAM_SOUND");
+			switch( es->eventParm ) {
+				case GTS_RED_CAPTURE: // CTF: red team captured the blue flag, 1FCTF: red team captured the neutral flag
+					//CG_AddBufferedSound( cgs.media.redScoredSound );
+					break;
+				case GTS_BLUE_CAPTURE: // CTF: blue team captured the red flag, 1FCTF: blue team captured the neutral flag
+					//CG_AddBufferedSound( cgs.media.blueScoredSound );
+					break;
+				case GTS_RED_RETURN: // CTF: blue flag returned, 1FCTF: never used
+					if (cgs.gametype == GT_CTY)
+					{
+						CG_AddBufferedSound( cgs.media.blueYsalReturnedSound );
+					}
+					else
+					{
+						CG_AddBufferedSound( cgs.media.blueFlagReturnedSound );
+					}
+					break;
+				case GTS_BLUE_RETURN: // CTF red flag returned, 1FCTF: neutral flag returned
+					if (cgs.gametype == GT_CTY)
+					{
+						CG_AddBufferedSound( cgs.media.redYsalReturnedSound );
+					}
+					else
+					{
+						CG_AddBufferedSound( cgs.media.redFlagReturnedSound );
+					}
+					break;
+
+				case GTS_RED_TAKEN: // CTF: red team took blue flag, 1FCTF: blue team took the neutral flag
+					// if this player picked up the flag then a sound is played in CG_CheckLocalSounds
+					if (cgs.gametype == GT_CTY)
+					{
+						CG_AddBufferedSound( cgs.media.redTookYsalSound );
+					}
+					else
+					{
+					 	CG_AddBufferedSound( cgs.media.redTookFlagSound );
+					}
+					break;
+				case GTS_BLUE_TAKEN: // CTF: blue team took the red flag, 1FCTF red team took the neutral flag
+					// if this player picked up the flag then a sound is played in CG_CheckLocalSounds
+					if (cgs.gametype == GT_CTY)
+					{
+						CG_AddBufferedSound( cgs.media.blueTookYsalSound );
+					}
+					else
+					{
+						CG_AddBufferedSound( cgs.media.blueTookFlagSound );
+					}
+					break;
+				case GTS_REDTEAM_SCORED:
+					CG_AddBufferedSound(cgs.media.redScoredSound);
+					break;
+				case GTS_BLUETEAM_SCORED:
+					CG_AddBufferedSound(cgs.media.blueScoredSound);
+					break;
+				case GTS_REDTEAM_TOOK_LEAD:
+					CG_AddBufferedSound(cgs.media.redLeadsSound);
+					break;
+				case GTS_BLUETEAM_TOOK_LEAD:
+					CG_AddBufferedSound(cgs.media.blueLeadsSound);
+					break;
+				case GTS_TEAMS_ARE_TIED:
+					CG_AddBufferedSound( cgs.media.teamsTiedSound );
+					break;
+				default:
+					break;
+			}
+			break;
+		}
+
+	case EV_ENTITY_SOUND:
+		DEBUGNAME("EV_ENTITY_SOUND");
+		//somewhat of a hack - weapon is the caller entity's index, trickedentindex is the proper sound channel
+		if ( cgs.gameSounds[ es->eventParm ] ) {
+			trap_S_StartSound (NULL, es->clientNum, es->trickedentindex, cgs.gameSounds[ es->eventParm ] );
+		} else {
+			s = CG_ConfigString( CS_SOUNDS + es->eventParm );
+			trap_S_StartSound (NULL, es->clientNum, es->trickedentindex, CG_CustomSound( es->clientNum, s ) );
+		}
+		break;
+
+	case EV_PLAY_ROFF:
+		DEBUGNAME("EV_PLAY_ROFF");
+		trap_ROFF_Play(es->weapon, es->eventParm, es->trickedentindex);
+		break;
+
+	case EV_GLASS_SHATTER:
+		DEBUGNAME("EV_GLASS_SHATTER");
+		CG_GlassShatter(es->genericenemyindex, es->origin, es->angles, es->trickedentindex, es->pos.trTime);
+		break;
+
+	case EV_DEBRIS:
+		DEBUGNAME("EV_DEBRIS");
+		CG_Chunks(es->owner, es->origin, es->angles, es->origin2, es->angles2, es->speed,
+			es->eventParm, es->trickedentindex, es->modelindex, es->apos.trBase[0]);
+		break;
+
+	case EV_MISC_MODEL_EXP:
+		DEBUGNAME("EV_MISC_MODEL_EXP");
+		CG_MiscModelExplosion(es->origin2, es->angles2, es->time, es->eventParm);
+		break;
+
+	case EV_PAIN:
+		// local player sounds are triggered in CG_CheckLocalSounds,
+		// so ignore events on the player
+		DEBUGNAME("EV_PAIN");
+
+		if ( !cg_oldPainSounds.integer || (cent->currentState.number != cg.snap->ps.clientNum) )
+		{
+			CG_PainEvent( cent, es->eventParm );
+		}
+		break;
+
+	case EV_DEATH1:
+	case EV_DEATH2:
+	case EV_DEATH3:
+		DEBUGNAME("EV_DEATHx");
+		trap_S_StartSound( NULL, es->number, CHAN_VOICE, 
+				CG_CustomSound( es->number, va("*death%i.wav", event - EV_DEATH1 + 1) ) );
+		if (es->eventParm && es->number == cg.snap->ps.clientNum)
+		{
+			trap_S_StartLocalSound(cgs.media.dramaticFailure, CHAN_LOCAL);
+			CGCam_SetMusicMult(0.3, 5000);
+		}
+		break;
+
+
+	case EV_OBITUARY:
+		DEBUGNAME("EV_OBITUARY");
+		CG_Obituary( es );
+		break;
+
+	//
+	// powerup events
+	//
+	case EV_POWERUP_QUAD:
+		DEBUGNAME("EV_POWERUP_QUAD");
+		if ( es->number == cg.snap->ps.clientNum ) {
+			cg.powerupActive = PW_QUAD;
+			cg.powerupTime = cg.time;
+		}
+		//trap_S_StartSound (NULL, es->number, CHAN_ITEM, cgs.media.quadSound );
+		break;
+	case EV_POWERUP_BATTLESUIT:
+		DEBUGNAME("EV_POWERUP_BATTLESUIT");
+		if ( es->number == cg.snap->ps.clientNum ) {
+			cg.powerupActive = PW_BATTLESUIT;
+			cg.powerupTime = cg.time;
+		}
+		//trap_S_StartSound (NULL, es->number, CHAN_ITEM, cgs.media.protectSound );
+		break;
+
+	case EV_FORCE_DRAINED:
+		DEBUGNAME("EV_FORCE_DRAINED");
+		ByteToDir( es->eventParm, dir );
+		//FX_ForceDrained(position, dir);
+		trap_S_StartSound (NULL, es->owner, CHAN_AUTO, cgs.media.drainSound );
+		cg_entities[es->owner].teamPowerEffectTime = cg.time + 1000;
+		cg_entities[es->owner].teamPowerType = 2;
+		break;
+
+	case EV_GIB_PLAYER:
+		DEBUGNAME("EV_GIB_PLAYER");
+		//trap_S_StartSound( NULL, es->number, CHAN_BODY, cgs.media.gibSound );
+		//CG_GibPlayer( cent->lerpOrigin );
+		break;
+
+	case EV_STARTLOOPINGSOUND:
+		DEBUGNAME("EV_STARTLOOPINGSOUND");
+		if ( cgs.gameSounds[ es->eventParm ] )
+		{
+			isnd = cgs.gameSounds[es->eventParm];
+		}
+		else
+		{
+			s = CG_ConfigString( CS_SOUNDS + es->eventParm );
+			isnd = CG_CustomSound(es->number, s);
+		}
+
+		CG_S_AddRealLoopingSound( es->number, es->pos.trBase, vec3_origin, isnd );
+		es->loopSound = isnd;
+		break;
+
+	case EV_STOPLOOPINGSOUND:
+		DEBUGNAME("EV_STOPLOOPINGSOUND");
+		CG_S_StopLoopingSound( es->number, -1 );
+		es->loopSound = 0;
+		break;
+
+	case EV_WEAPON_CHARGE:
+		DEBUGNAME("EV_WEAPON_CHARGE");
+		assert(es->eventParm > WP_NONE && es->eventParm < WP_NUM_WEAPONS);
+		if (cg_weapons[es->eventParm].chargeSound)
+		{
+			trap_S_StartSound(NULL, es->number, CHAN_WEAPON, cg_weapons[es->eventParm].chargeSound);
+		}
+		else if (es->eventParm == WP_DISRUPTOR)
+		{
+			trap_S_StartSound(NULL, es->number, CHAN_WEAPON, cgs.media.disruptorZoomLoop);
+		}
+		break;
+
+	case EV_WEAPON_CHARGE_ALT:
+		DEBUGNAME("EV_WEAPON_CHARGE_ALT");
+		assert(es->eventParm > WP_NONE && es->eventParm < WP_NUM_WEAPONS);
+		if (cg_weapons[es->eventParm].altChargeSound)
+		{
+			trap_S_StartSound(NULL, es->number, CHAN_WEAPON, cg_weapons[es->eventParm].altChargeSound);
+		}
+		break;
+
+	case EV_SHIELD_HIT:
+		DEBUGNAME("EV_SHIELD_HIT");
+		ByteToDir(es->eventParm, dir);
+		CG_PlayerShieldHit(es->otherEntityNum, dir, es->time2);
+		break;
+
+	case EV_DEBUG_LINE:
+		DEBUGNAME("EV_DEBUG_LINE");
+		CG_Beam( cent );
+		break;
+
+	case EV_TESTLINE:
+		DEBUGNAME("EV_TESTLINE");
+		CG_TestLine(es->origin, es->origin2, es->time2, es->weapon, 1);
+		break;
+
+	default:
+		DEBUGNAME("UNKNOWN");
+		CG_Error( "Unknown event: %i", event );
+		break;
+	}
+
+}
+
+
+/*
+==============
+CG_CheckEvents
+
+==============
+*/
+void CG_CheckEvents( centity_t *cent ) {
+	// check for event-only entities
+	if ( cent->currentState.eType > ET_EVENTS ) {
+		if ( cent->previousEvent ) {
+			return;	// already fired
+		}
+		// if this is a player event set the entity number of the client entity number
+		if ( cent->currentState.eFlags & EF_PLAYER_EVENT ) {
+			cent->currentState.number = cent->currentState.otherEntityNum;
+		}
+
+		cent->previousEvent = 1;
+
+		cent->currentState.event = cent->currentState.eType - ET_EVENTS;
+	} else {
+		// check for events riding with another entity
+		if ( cent->currentState.event == cent->previousEvent ) {
+			return;
+		}
+		cent->previousEvent = cent->currentState.event;
+		if ( ( cent->currentState.event & ~EV_EVENT_BITS ) == 0 ) {
+			return;
+		}
+	}
+
+	// calculate the position at exactly the frame time
+	BG_EvaluateTrajectory( &cent->currentState.pos, cg.snap->serverTime, cent->lerpOrigin );
+	CG_SetEntitySoundPosition( cent );
+
+	CG_EntityEvent( cent, cent->lerpOrigin );
+}
+
diff --git a/codemp/cgame/cg_info.c b/codemp/cgame/cg_info.c
new file mode 100644
index 0000000..f7795c5
--- /dev/null
+++ b/codemp/cgame/cg_info.c
@@ -0,0 +1,461 @@
+// Copyright (C) 1999-2000 Id Software, Inc.
+//
+// cg_info.c -- display information while data is being loading
+
+#include "cg_local.h"
+
+#define MAX_LOADING_PLAYER_ICONS	16
+#define MAX_LOADING_ITEM_ICONS		26
+
+//static int			loadingPlayerIconCount;
+//static qhandle_t	loadingPlayerIcons[MAX_LOADING_PLAYER_ICONS];
+
+void CG_LoadBar(void);
+
+/*
+======================
+CG_LoadingString
+
+======================
+*/
+void CG_LoadingString( const char *s ) {
+	Q_strncpyz( cg.infoScreenText, s, sizeof( cg.infoScreenText ) );
+
+	trap_UpdateScreen();
+}
+
+/*
+===================
+CG_LoadingItem
+===================
+*/
+void CG_LoadingItem( int itemNum ) {
+	gitem_t		*item;
+	char	upperKey[1024];
+
+	item = &bg_itemlist[itemNum];
+
+	if (!item->classname || !item->classname[0])
+	{
+	//	CG_LoadingString( "Unknown item" );
+		return;
+	}
+
+	strcpy(upperKey, item->classname);
+	CG_LoadingString( CG_GetStringEdString("SP_INGAME",Q_strupr(upperKey)) );
+}
+
+/*
+===================
+CG_LoadingClient
+===================
+*/
+void CG_LoadingClient( int clientNum ) {
+	const char		*info;
+	char			personality[MAX_QPATH];
+
+	info = CG_ConfigString( CS_PLAYERS + clientNum );
+
+/*
+	char			model[MAX_QPATH];
+	char			iconName[MAX_QPATH];
+	char			*skin;
+	if ( loadingPlayerIconCount < MAX_LOADING_PLAYER_ICONS ) {
+		Q_strncpyz( model, Info_ValueForKey( info, "model" ), sizeof( model ) );
+		skin = Q_strrchr( model, '/' );
+		if ( skin ) {
+			*skin++ = '\0';
+		} else {
+			skin = "default";
+		}
+
+		Com_sprintf( iconName, MAX_QPATH, "models/players/%s/icon_%s.tga", model, skin );
+		
+		loadingPlayerIcons[loadingPlayerIconCount] = trap_R_RegisterShaderNoMip( iconName );
+		if ( !loadingPlayerIcons[loadingPlayerIconCount] ) {
+			Com_sprintf( iconName, MAX_QPATH, "models/players/characters/%s/icon_%s.tga", model, skin );
+			loadingPlayerIcons[loadingPlayerIconCount] = trap_R_RegisterShaderNoMip( iconName );
+		}
+		if ( !loadingPlayerIcons[loadingPlayerIconCount] ) {
+			Com_sprintf( iconName, MAX_QPATH, "models/players/%s/icon_%s.tga", DEFAULT_MODEL, "default" );
+			loadingPlayerIcons[loadingPlayerIconCount] = trap_R_RegisterShaderNoMip( iconName );
+		}
+		if ( loadingPlayerIcons[loadingPlayerIconCount] ) {
+			loadingPlayerIconCount++;
+		}
+	}
+*/
+	Q_strncpyz( personality, Info_ValueForKey( info, "n" ), sizeof(personality) );
+	Q_CleanStr( personality );
+
+	/*
+	if( cgs.gametype == GT_SINGLE_PLAYER ) {
+		trap_S_RegisterSound( va( "sound/player/announce/%s.wav", personality ));
+	}
+	*/
+
+	CG_LoadingString( personality );
+}
+
+
+/*
+====================
+CG_DrawInformation
+
+Draw all the status / pacifier stuff during level loading
+====================
+overlays UI_DrawConnectScreen
+*/
+#define UI_INFOFONT (UI_BIGFONT)
+void CG_DrawInformation( void ) {
+	const char	*s;
+	const char	*info;
+	const char	*sysInfo;
+	int			y;
+	int			value, valueNOFP;
+	qhandle_t	levelshot;
+	char		buf[1024];
+	int			iPropHeight = 18;	// I know, this is total crap, but as a post release asian-hack....  -Ste
+	
+	info = CG_ConfigString( CS_SERVERINFO );
+	sysInfo = CG_ConfigString( CS_SYSTEMINFO );
+
+	s = Info_ValueForKey( info, "mapname" );
+	levelshot = trap_R_RegisterShaderNoMip( va( "levelshots/%s", s ) );
+	if ( !levelshot ) {
+		levelshot = trap_R_RegisterShaderNoMip( "menu/art/unknownmap_mp" );
+	}
+	trap_R_SetColor( NULL );
+	CG_DrawPic( 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, levelshot );
+
+	CG_LoadBar();
+
+	// draw the icons of things as they are loaded
+//	CG_DrawLoadingIcons();
+
+	// the first 150 rows are reserved for the client connection
+	// screen to write into
+	if ( cg.infoScreenText[0] ) {
+		const char *psLoading = CG_GetStringEdString("MENUS", "LOADING_MAPNAME");
+		UI_DrawProportionalString( 320, 128-32, va(/*"Loading... %s"*/ psLoading, cg.infoScreenText),
+			UI_CENTER|UI_INFOFONT|UI_DROPSHADOW, colorWhite );		
+	} else {
+		const char *psAwaitingSnapshot = CG_GetStringEdString("MENUS", "AWAITING_SNAPSHOT");
+		UI_DrawProportionalString( 320, 128-32, /*"Awaiting snapshot..."*/psAwaitingSnapshot,
+			UI_CENTER|UI_INFOFONT|UI_DROPSHADOW, colorWhite );			
+	}
+
+	// draw info string information
+
+	y = 180-32;
+
+	// don't print server lines if playing a local game
+	trap_Cvar_VariableStringBuffer( "sv_running", buf, sizeof( buf ) );
+	if ( !atoi( buf ) ) {
+		// server hostname
+		Q_strncpyz(buf, Info_ValueForKey( info, "sv_hostname" ), 1024);
+		Q_CleanStr(buf);
+		UI_DrawProportionalString( 320, y, buf,
+			UI_CENTER|UI_INFOFONT|UI_DROPSHADOW, colorWhite );
+		y += iPropHeight;
+
+		// pure server
+		s = Info_ValueForKey( sysInfo, "sv_pure" );
+		if ( s[0] == '1' ) {
+			const char *psPure = CG_GetStringEdString("MP_INGAME", "PURE_SERVER");
+			UI_DrawProportionalString( 320, y, psPure,
+				UI_CENTER|UI_INFOFONT|UI_DROPSHADOW, colorWhite );
+			y += iPropHeight;
+		}
+
+		// server-specific message of the day
+		s = CG_ConfigString( CS_MOTD );
+		if ( s[0] ) {
+			UI_DrawProportionalString( 320, y, s,
+				UI_CENTER|UI_INFOFONT|UI_DROPSHADOW, colorWhite );
+			y += iPropHeight;
+		}
+
+		{	// display global MOTD at bottom (mirrors ui_main UI_DrawConnectScreen
+			char motdString[1024];
+			trap_Cvar_VariableStringBuffer( "cl_motdString", motdString, sizeof( motdString ) );
+
+			if (motdString[0])
+			{
+				UI_DrawProportionalString( 320, 425, motdString,
+					UI_CENTER|UI_INFOFONT|UI_DROPSHADOW, colorWhite );
+			}
+		}
+
+		// some extra space after hostname and motd
+		y += 10;
+	}
+
+	// map-specific message (long map name)
+	s = CG_ConfigString( CS_MESSAGE );
+	if ( s[0] ) {
+		UI_DrawProportionalString( 320, y, s,
+			UI_CENTER|UI_INFOFONT|UI_DROPSHADOW, colorWhite );
+		y += iPropHeight;
+	}
+
+	// cheats warning
+	s = Info_ValueForKey( sysInfo, "sv_cheats" );
+	if ( s[0] == '1' ) {
+		UI_DrawProportionalString( 320, y, CG_GetStringEdString("MP_INGAME", "CHEATSAREENABLED"),
+			UI_CENTER|UI_INFOFONT|UI_DROPSHADOW, colorWhite );
+		y += iPropHeight;
+	}
+
+	// game type
+	switch ( cgs.gametype ) {
+	case GT_FFA:
+			s = CG_GetStringEdString("MENUS", "FREE_FOR_ALL");//"Free For All";
+//		s = "Free For All";
+		break;
+	case GT_HOLOCRON:
+			s = CG_GetStringEdString("MENUS", "HOLOCRON_FFA");//"Holocron FFA";
+//		s = "Holocron FFA";
+		break;
+	case GT_JEDIMASTER:
+			s = CG_GetStringEdString("MENUS", "SAGA");//"Jedi Master";??
+
+//		s = "Jedi Master";
+		break;
+	case GT_SINGLE_PLAYER:
+			s = CG_GetStringEdString("MENUS", "SAGA");//"Team FFA";
+
+		//s = "Single Player";
+		break;
+	case GT_DUEL:
+			s = CG_GetStringEdString("MENUS", "DUEL");//"Team FFA";
+		//s = "Duel";
+		break;
+	case GT_POWERDUEL:
+			s = CG_GetStringEdString("MENUS", "POWERDUEL");//"Team FFA";
+		//s = "Power Duel";
+		break;
+	case GT_TEAM:
+			s = CG_GetStringEdString("MENUS", "TEAM_FFA");//"Team FFA";
+
+		//s = "Team FFA";
+		break;
+	case GT_SIEGE:
+			s = CG_GetStringEdString("MENUS", "SIEGE");//"Siege";
+
+		//s = "Siege";
+		break;
+	case GT_CTF:
+			s = CG_GetStringEdString("MENUS", "CAPTURE_THE_FLAG");//"Capture the Flag";
+
+		//s = "Capture The Flag";
+		break;
+	case GT_CTY:
+			s = CG_GetStringEdString("MENUS", "CAPTURE_THE_YSALIMARI");//"Capture the Ysalamiri";
+
+		//s = "Capture The Ysalamiri";
+		break;
+	default:
+			s = CG_GetStringEdString("MENUS", "SAGA");//"Team FFA";
+
+		//s = "Unknown Gametype";
+		break;
+	}
+	UI_DrawProportionalString( 320, y, s,
+		UI_CENTER|UI_INFOFONT|UI_DROPSHADOW, colorWhite );
+	y += iPropHeight;
+		
+	if (cgs.gametype != GT_SIEGE)
+	{
+		value = atoi( Info_ValueForKey( info, "timelimit" ) );
+		if ( value ) {
+			UI_DrawProportionalString( 320, y, va( "%s %i", CG_GetStringEdString("MP_INGAME", "TIMELIMIT"), value ),
+				UI_CENTER|UI_INFOFONT|UI_DROPSHADOW, colorWhite );
+			y += iPropHeight;
+		}
+
+		if (cgs.gametype < GT_CTF ) {
+			value = atoi( Info_ValueForKey( info, "fraglimit" ) );
+			if ( value ) {
+				UI_DrawProportionalString( 320, y, va( "%s %i", CG_GetStringEdString("MP_INGAME", "FRAGLIMIT"), value ),
+					UI_CENTER|UI_INFOFONT|UI_DROPSHADOW, colorWhite );
+				y += iPropHeight;
+			}
+
+			if (cgs.gametype == GT_DUEL || cgs.gametype == GT_POWERDUEL)
+			{
+				value = atoi( Info_ValueForKey( info, "duel_fraglimit" ) );
+				if ( value ) {
+					UI_DrawProportionalString( 320, y, va( "%s %i", CG_GetStringEdString("MP_INGAME", "WINLIMIT"), value ),
+						UI_CENTER|UI_INFOFONT|UI_DROPSHADOW, colorWhite );
+					y += iPropHeight;
+				}
+			}
+		}
+	}
+
+	if (cgs.gametype >= GT_CTF) {
+		value = atoi( Info_ValueForKey( info, "capturelimit" ) );
+		if ( value ) {
+			UI_DrawProportionalString( 320, y, va( "%s %i", CG_GetStringEdString("MP_INGAME", "CAPTURELIMIT"), value ),
+				UI_CENTER|UI_INFOFONT|UI_DROPSHADOW, colorWhite );
+			y += iPropHeight;
+		}
+	}
+
+	if (cgs.gametype >= GT_TEAM)
+	{
+		value = atoi( Info_ValueForKey( info, "g_forceBasedTeams" ) );
+		if ( value ) {
+			UI_DrawProportionalString( 320, y, CG_GetStringEdString("MP_INGAME", "FORCEBASEDTEAMS"),
+				UI_CENTER|UI_INFOFONT|UI_DROPSHADOW, colorWhite );
+			y += iPropHeight;
+		}
+	}
+
+    if (cgs.gametype != GT_SIEGE)
+	{
+		valueNOFP = atoi( Info_ValueForKey( info, "g_forcePowerDisable" ) );
+
+		value = atoi( Info_ValueForKey( info, "g_maxForceRank" ) );
+		if ( value && !valueNOFP ) {
+			char fmStr[1024]; 
+
+			trap_SP_GetStringTextString("MP_INGAME_MAXFORCERANK",fmStr, sizeof(fmStr));
+
+			UI_DrawProportionalString( 320, y, va( "%s %s", fmStr, CG_GetStringEdString("MP_INGAME", forceMasteryLevels[value]) ),
+				UI_CENTER|UI_INFOFONT|UI_DROPSHADOW, colorWhite );
+			y += iPropHeight;
+		}
+		else if (!valueNOFP)
+		{
+			char fmStr[1024];
+			trap_SP_GetStringTextString("MP_INGAME_MAXFORCERANK",fmStr, sizeof(fmStr));
+
+			UI_DrawProportionalString( 320, y, va( "%s %s", fmStr, (char *)CG_GetStringEdString("MP_INGAME", forceMasteryLevels[7]) ),
+				UI_CENTER|UI_INFOFONT|UI_DROPSHADOW, colorWhite );
+			y += iPropHeight;
+		}
+
+		if (cgs.gametype == GT_DUEL || cgs.gametype == GT_POWERDUEL)
+		{
+			value = atoi( Info_ValueForKey( info, "g_duelWeaponDisable" ) );
+		}
+		else
+		{
+			value = atoi( Info_ValueForKey( info, "g_weaponDisable" ) );
+		}
+		if ( cgs.gametype != GT_JEDIMASTER && value ) {
+			UI_DrawProportionalString( 320, y, va( "%s", (char *)CG_GetStringEdString("MP_INGAME", "SABERONLYSET") ),
+				UI_CENTER|UI_INFOFONT|UI_DROPSHADOW, colorWhite );
+			y += iPropHeight;
+		}
+
+		if ( valueNOFP ) {
+			UI_DrawProportionalString( 320, y, va( "%s", (char *)CG_GetStringEdString("MP_INGAME", "NOFPSET") ),
+				UI_CENTER|UI_INFOFONT|UI_DROPSHADOW, colorWhite );
+			y += iPropHeight;
+		}
+	}
+
+	// Display the rules based on type
+		y += iPropHeight;
+	switch ( cgs.gametype ) {
+	case GT_FFA:					
+		UI_DrawProportionalString( 320, y, va( "%s", (char *)CG_GetStringEdString("MP_INGAME", "RULES_FFA_1")),
+			UI_CENTER|UI_INFOFONT|UI_DROPSHADOW, colorWhite );
+		y += iPropHeight;
+		break;
+	case GT_HOLOCRON:
+		UI_DrawProportionalString( 320, y, va( "%s", (char *)CG_GetStringEdString("MP_INGAME", "RULES_HOLO_1")),
+			UI_CENTER|UI_INFOFONT|UI_DROPSHADOW, colorWhite );
+		y += iPropHeight;
+		UI_DrawProportionalString( 320, y, va( "%s", (char *)CG_GetStringEdString("MP_INGAME", "RULES_HOLO_2")),
+			UI_CENTER|UI_INFOFONT|UI_DROPSHADOW, colorWhite );
+		y += iPropHeight;
+		break;
+	case GT_JEDIMASTER:
+		UI_DrawProportionalString( 320, y, va( "%s", (char *)CG_GetStringEdString("MP_INGAME", "RULES_JEDI_1")),
+			UI_CENTER|UI_INFOFONT|UI_DROPSHADOW, colorWhite );
+		y += iPropHeight;
+		UI_DrawProportionalString( 320, y, va( "%s", (char *)CG_GetStringEdString("MP_INGAME", "RULES_JEDI_2")),
+			UI_CENTER|UI_INFOFONT|UI_DROPSHADOW, colorWhite );
+		y += iPropHeight;
+		break;
+	case GT_SINGLE_PLAYER:
+		break;
+	case GT_DUEL:
+		UI_DrawProportionalString( 320, y, va( "%s", (char *)CG_GetStringEdString("MP_INGAME", "RULES_DUEL_1")),
+			UI_CENTER|UI_INFOFONT|UI_DROPSHADOW, colorWhite );
+		y += iPropHeight;
+		UI_DrawProportionalString( 320, y, va( "%s", (char *)CG_GetStringEdString("MP_INGAME", "RULES_DUEL_2")),
+			UI_CENTER|UI_INFOFONT|UI_DROPSHADOW, colorWhite );
+		y += iPropHeight;
+		break;
+	case GT_POWERDUEL:
+		UI_DrawProportionalString( 320, y, va( "%s", (char *)CG_GetStringEdString("MP_INGAME", "RULES_POWERDUEL_1")),
+			UI_CENTER|UI_INFOFONT|UI_DROPSHADOW, colorWhite );
+		y += iPropHeight;
+		UI_DrawProportionalString( 320, y, va( "%s", (char *)CG_GetStringEdString("MP_INGAME", "RULES_POWERDUEL_2")),
+			UI_CENTER|UI_INFOFONT|UI_DROPSHADOW, colorWhite );
+		y += iPropHeight;
+		break;
+	case GT_TEAM:
+		UI_DrawProportionalString( 320, y, va( "%s", (char *)CG_GetStringEdString("MP_INGAME", "RULES_TEAM_1")),
+			UI_CENTER|UI_INFOFONT|UI_DROPSHADOW, colorWhite );
+		y += iPropHeight;
+		UI_DrawProportionalString( 320, y, va( "%s", (char *)CG_GetStringEdString("MP_INGAME", "RULES_TEAM_2")),
+			UI_CENTER|UI_INFOFONT|UI_DROPSHADOW, colorWhite );
+		y += iPropHeight;
+		break;
+	case GT_SIEGE:
+		break;
+	case GT_CTF:
+		UI_DrawProportionalString( 320, y, va( "%s", (char *)CG_GetStringEdString("MP_INGAME", "RULES_CTF_1")),
+			UI_CENTER|UI_INFOFONT|UI_DROPSHADOW, colorWhite );
+		y += iPropHeight;
+		UI_DrawProportionalString( 320, y, va( "%s", (char *)CG_GetStringEdString("MP_INGAME", "RULES_CTF_2")),
+			UI_CENTER|UI_INFOFONT|UI_DROPSHADOW, colorWhite );
+		y += iPropHeight;
+		break;
+	case GT_CTY:
+		UI_DrawProportionalString( 320, y, va( "%s", (char *)CG_GetStringEdString("MP_INGAME", "RULES_CTY_1")),
+			UI_CENTER|UI_INFOFONT|UI_DROPSHADOW, colorWhite );
+		y += iPropHeight;
+		UI_DrawProportionalString( 320, y, va( "%s", (char *)CG_GetStringEdString("MP_INGAME", "RULES_CTY_2")),
+			UI_CENTER|UI_INFOFONT|UI_DROPSHADOW, colorWhite );
+		y += iPropHeight;
+		break;
+	default:
+		break;
+	}
+}
+
+/*
+===================
+CG_LoadBar
+===================
+*/
+void CG_LoadBar(void)
+{
+	const int numticks = 9, tickwidth = 40, tickheight = 8;
+	const int tickpadx = 20, tickpady = 12;
+	const int capwidth = 8;
+	const int barwidth = numticks*tickwidth+tickpadx*2+capwidth*2, barleft = ((640-barwidth)/2);
+	const int barheight = tickheight + tickpady*2, bartop = 480-barheight;
+	const int capleft = barleft+tickpadx, tickleft = capleft+capwidth, ticktop = bartop+tickpady;
+
+	trap_R_SetColor( colorWhite );
+	// Draw background
+	CG_DrawPic(barleft, bartop, barwidth, barheight, cgs.media.loadBarLEDSurround);
+
+	// Draw left cap (backwards)
+	CG_DrawPic(tickleft, ticktop, -capwidth, tickheight, cgs.media.loadBarLEDCap);
+
+	// Draw bar
+	CG_DrawPic(tickleft, ticktop, tickwidth*cg.loadLCARSStage, tickheight, cgs.media.loadBarLED);
+
+	// Draw right cap
+	CG_DrawPic(tickleft+tickwidth*cg.loadLCARSStage, ticktop, capwidth, tickheight, cgs.media.loadBarLEDCap);
+}
+
diff --git a/codemp/cgame/cg_light.c b/codemp/cgame/cg_light.c
new file mode 100644
index 0000000..41917a5
--- /dev/null
+++ b/codemp/cgame/cg_light.c
@@ -0,0 +1,85 @@
+#include "cg_local.h"
+
+#if !defined(CG_LIGHTS_H_INC)
+	#include "cg_lights.h"
+#endif
+
+static	clightstyle_t	cl_lightstyle[MAX_LIGHT_STYLES];
+static	int				lastofs;
+
+/*
+================
+FX_ClearLightStyles
+================
+*/
+void CG_ClearLightStyles (void)
+{
+	int	i;
+
+	memset (cl_lightstyle, 0, sizeof(cl_lightstyle));
+	lastofs = -1;
+
+	for(i=0;i<MAX_LIGHT_STYLES*3;i++)
+	{
+		CG_SetLightstyle (i);
+	}
+}
+
+/*
+================
+FX_RunLightStyles
+================
+*/
+void CG_RunLightStyles (void)
+{
+	int		ofs;
+	int		i;
+	clightstyle_t	*ls;
+
+	ofs = cg.time / 50;
+//	if (ofs == lastofs)
+//		return;
+	lastofs = ofs;
+
+	for (i=0,ls=cl_lightstyle ; i<MAX_LIGHT_STYLES ; i++, ls++)
+	{
+		if (!ls->length)
+		{
+			ls->value[0] = ls->value[1] = ls->value[2] = ls->value[3] = 255;
+		}
+		else if (ls->length == 1)
+		{
+			ls->value[0] = ls->map[0][0];
+			ls->value[1] = ls->map[0][1];
+			ls->value[2] = ls->map[0][2];
+			ls->value[3] = 255; //ls->map[0][3];
+		}
+		else
+		{
+			ls->value[0] = ls->map[ofs%ls->length][0];
+			ls->value[1] = ls->map[ofs%ls->length][1];
+			ls->value[2] = ls->map[ofs%ls->length][2];
+			ls->value[3] = 255; //ls->map[ofs%ls->length][3];
+		}
+		trap_R_SetLightStyle(i, *(int*)ls->value);
+	}
+}
+
+void CG_SetLightstyle (int i)
+{
+	const char	*s;
+	int			j, k;
+
+	s = CG_ConfigString( i+CS_LIGHT_STYLES );
+	j = strlen (s);
+	if (j >= MAX_QPATH)
+	{
+		Com_Error (ERR_DROP, "svc_lightstyle length=%i", j);
+	}
+
+	cl_lightstyle[(i/3)].length = j;
+	for (k=0 ; k<j ; k++)
+	{
+		cl_lightstyle[(i/3)].map[k][(i%3)] = (float)(s[k]-'a')/(float)('z'-'a') * 255.0;
+	}
+}
diff --git a/codemp/cgame/cg_lights.h b/codemp/cgame/cg_lights.h
new file mode 100644
index 0000000..aa7e18c
--- /dev/null
+++ b/codemp/cgame/cg_lights.h
@@ -0,0 +1,16 @@
+#pragma once
+#if !defined(CG_LIGHTS_H_INC)
+#define CG_LIGHTS_H_INC
+
+typedef struct
+{
+	int				length;
+	color4ub_t		value;
+	color4ub_t		map[MAX_QPATH];
+} clightstyle_t;
+
+void	CG_ClearLightStyles (void);
+void	CG_RunLightStyles (void);
+void	CG_SetLightstyle (int i);
+
+#endif // CG_LIGHTS_H_INC
diff --git a/codemp/cgame/cg_local.h b/codemp/cgame/cg_local.h
new file mode 100644
index 0000000..9085783
--- /dev/null
+++ b/codemp/cgame/cg_local.h
@@ -0,0 +1,2611 @@
+// Copyright (C) 1999-2000 Id Software, Inc.
+//
+#include "../game/q_shared.h"
+#include "tr_types.h"
+#include "../game/bg_public.h"
+#include "cg_public.h"
+
+// The entire cgame module is unloaded and reloaded on each level change,
+// so there is NO persistant data between levels on the client side.
+// If you absolutely need something stored, it can either be kept
+// by the server in the server stored userinfos, or stashed in a cvar.
+
+#ifndef __LCC__
+#define CGAME_INLINE ID_INLINE
+#else
+#define CGAME_INLINE //none
+#endif
+
+#define NULL_HANDLE			((qhandle_t) 0)
+#define NULL_SOUND			((sfxHandle_t) 0)
+#define NULL_FX				((fxHandle_t) 0)
+
+#define	POWERUP_BLINKS		5
+
+#define	POWERUP_BLINK_TIME	1000
+#define	FADE_TIME			200
+#define	PULSE_TIME			200
+#define	DAMAGE_DEFLECT_TIME	100
+#define	DAMAGE_RETURN_TIME	400
+#define DAMAGE_TIME			500
+#define	LAND_DEFLECT_TIME	150
+#define	LAND_RETURN_TIME	300
+#define	STEP_TIME			200
+#define	DUCK_TIME			100
+#define	PAIN_TWITCH_TIME	200
+#define	WEAPON_SELECT_TIME	1400
+#define	ITEM_SCALEUP_TIME	1000
+
+// Zoom vars
+#define	ZOOM_TIME			150		// not currently used?
+#define MAX_ZOOM_FOV		3.0f
+#define ZOOM_IN_TIME		1500.0f	
+#define ZOOM_OUT_TIME		100.0f
+#define ZOOM_START_PERCENT	0.3f	
+
+#define	ITEM_BLOB_TIME		200
+#define	MUZZLE_FLASH_TIME	20
+#define	SINK_TIME			1000		// time for fragments to sink into ground before going away
+#define	ATTACKER_HEAD_TIME	10000
+#define	REWARD_TIME			3000
+
+#define	PULSE_SCALE			1.5			// amount to scale up the icons when activating
+
+#define	MAX_STEP_CHANGE		32
+
+#define	MAX_VERTS_ON_POLY	10
+#define	MAX_MARK_POLYS		256
+
+#define STAT_MINUS			10	// num frame for '-' stats digit
+
+#define	ICON_SIZE			48
+#define	CHAR_WIDTH			32
+#define	CHAR_HEIGHT			48
+#define	TEXT_ICON_SPACE		4
+
+// very large characters
+#define	GIANT_WIDTH			32
+#define	GIANT_HEIGHT		48
+
+#define NUM_FONT_BIG	1
+#define NUM_FONT_SMALL	2
+#define NUM_FONT_CHUNKY	3
+
+#define	NUM_CROSSHAIRS		9
+
+#define TEAM_OVERLAY_MAXNAME_WIDTH	32
+#define TEAM_OVERLAY_MAXLOCATION_WIDTH	64
+
+#define	WAVE_AMPLITUDE	1
+#define	WAVE_FREQUENCY	0.4
+
+#define	DEFAULT_MODEL			"kyle"
+
+#define DEFAULT_FORCEPOWERS		"5-1-000000000000000000"
+//"rank-side-heal.lev.speed.push.pull.tele.grip.lightning.rage.protect.absorb.teamheal.teamforce.drain.see"
+
+#define DEFAULT_REDTEAM_NAME		"Empire"
+#define DEFAULT_BLUETEAM_NAME		"Rebellion"
+
+typedef enum {
+	FOOTSTEP_STONEWALK,
+	FOOTSTEP_STONERUN,
+	FOOTSTEP_METALWALK,
+	FOOTSTEP_METALRUN,
+	FOOTSTEP_PIPEWALK,
+	FOOTSTEP_PIPERUN,
+	FOOTSTEP_SPLASH,
+	FOOTSTEP_WADE,
+	FOOTSTEP_SWIM,
+	FOOTSTEP_SNOWWALK,
+	FOOTSTEP_SNOWRUN,
+	FOOTSTEP_SANDWALK,
+	FOOTSTEP_SANDRUN,
+	FOOTSTEP_GRASSWALK,
+	FOOTSTEP_GRASSRUN,
+	FOOTSTEP_DIRTWALK,
+	FOOTSTEP_DIRTRUN,
+	FOOTSTEP_MUDWALK,
+	FOOTSTEP_MUDRUN,
+	FOOTSTEP_GRAVELWALK,
+	FOOTSTEP_GRAVELRUN,
+	FOOTSTEP_RUGWALK,
+	FOOTSTEP_RUGRUN,
+	FOOTSTEP_WOODWALK,
+	FOOTSTEP_WOODRUN,
+
+	FOOTSTEP_TOTAL
+} footstep_t;
+
+typedef enum {
+	IMPACTSOUND_DEFAULT,
+	IMPACTSOUND_METAL,
+	IMPACTSOUND_FLESH
+} impactSound_t;
+
+//=================================================
+
+// player entities need to track more information
+// than any other type of entity.
+
+// note that not every player entity is a client entity,
+// because corpses after respawn are outside the normal
+// client numbering range
+
+// when changing animation, set animationTime to frameTime + lerping time
+// The current lerp will finish out, then it will lerp to the new animation
+typedef struct {
+	int			oldFrame;
+	int			oldFrameTime;		// time when ->oldFrame was exactly on
+
+	int			frame;
+	int			frameTime;			// time when ->frame will be exactly on
+
+	float		backlerp;
+
+	qboolean	lastFlip; //if does not match torsoFlip/legsFlip, restart the anim.
+
+	int			lastForcedFrame;
+
+	float		yawAngle;
+	qboolean	yawing;
+	float		pitchAngle;
+	qboolean	pitching;
+
+	float		yawSwingDif;
+
+	int			animationNumber;
+	animation_t	*animation;
+	int			animationTime;		// time when the first frame of the animation will be exact
+
+	float		animationSpeed;		// scale the animation speed
+	float		animationTorsoSpeed;
+
+	qboolean	torsoYawing;
+} lerpFrame_t;
+
+
+typedef struct {
+	lerpFrame_t		legs, torso, flag;
+	int				painTime;
+	int				painDirection;	// flip from 0 to 1
+	int				lightningFiring;
+
+	// machinegun spinning
+	float			barrelAngle;
+	int				barrelTime;
+	qboolean		barrelSpinning;
+} playerEntity_t;
+
+//=================================================
+
+// each client has an associated clientInfo_t
+// that contains media references necessary to present the
+// client model and other color coded effects
+// this is regenerated each time a client's configstring changes,
+// usually as a result of a userinfo (name, model, etc) change
+#define	MAX_CUSTOM_COMBAT_SOUNDS	40
+#define	MAX_CUSTOM_EXTRA_SOUNDS	40
+#define	MAX_CUSTOM_JEDI_SOUNDS	40
+//#define MAX_CUSTOM_SIEGE_SOUNDS..defined in bg_public.h
+#define MAX_CUSTOM_DUEL_SOUNDS	40
+
+#define	MAX_CUSTOM_SOUNDS	40 //rww - Note that for now these must all be the same, because of the way I am
+							   //cycling through them and comparing for custom sounds.
+
+typedef struct {
+	qboolean		infoValid;
+
+	float			colorOverride[3];
+
+	saberInfo_t		saber[MAX_SABERS];
+	void			*ghoul2Weapons[MAX_SABERS];
+
+	char			saberName[64];
+	char			saber2Name[64];
+
+	char			name[MAX_QPATH];
+	team_t			team;
+
+	int				duelTeam;
+
+	int				botSkill;		// 0 = not bot, 1-5 = bot
+
+	int				frame;
+
+	vec3_t			color1;
+	vec3_t			color2;
+
+	int				icolor1;
+	int				icolor2;
+
+	int				score;			// updated by score servercmds
+	int				location;		// location index for team mode
+	int				health;			// you only get this info about your teammates
+	int				armor;
+	int				curWeapon;
+
+	int				handicap;
+	int				wins, losses;	// in tourney mode
+
+	int				teamTask;		// task in teamplay (offence/defence)
+	qboolean		teamLeader;		// true when this is a team leader
+
+	int				powerups;		// so can display quad/flag status
+
+	int				medkitUsageTime;
+
+	int				breathPuffTime;
+
+	// when clientinfo is changed, the loading of models/skins/sounds
+	// can be deferred until you are dead, to prevent hitches in
+	// gameplay
+	char			modelName[MAX_QPATH];
+	char			skinName[MAX_QPATH];
+//	char			headModelName[MAX_QPATH];
+//	char			headSkinName[MAX_QPATH];
+	char			forcePowers[MAX_QPATH];
+	char			redTeam[MAX_TEAMNAME];
+	char			blueTeam[MAX_TEAMNAME];
+
+	char			teamName[MAX_TEAMNAME];
+
+	int				corrTime;
+
+	vec3_t			lastHeadAngles;
+	int				lookTime;
+
+	int				brokenLimbs;
+
+	qboolean		deferred;
+
+	qboolean		newAnims;		// true if using the new mission pack animations
+	qboolean		fixedlegs;		// true if legs yaw is always the same as torso yaw
+	qboolean		fixedtorso;		// true if torso never changes yaw
+
+	vec3_t			headOffset;		// move head in icon views
+	//footstep_t		footsteps;
+	gender_t		gender;			// from model
+
+	qhandle_t		legsModel;
+	qhandle_t		legsSkin;
+
+	qhandle_t		torsoModel;
+	qhandle_t		torsoSkin;
+
+	//qhandle_t		headModel;
+	//qhandle_t		headSkin;
+
+	void			*ghoul2Model;
+	
+	qhandle_t		modelIcon;
+
+	qhandle_t		bolt_rhand;
+	qhandle_t		bolt_lhand;
+
+	qhandle_t		bolt_head;
+
+	qhandle_t		bolt_motion;
+
+	qhandle_t		bolt_llumbar;
+
+	int				siegeIndex;
+	int				siegeDesiredTeam;
+
+	sfxHandle_t		sounds[MAX_CUSTOM_SOUNDS];
+	sfxHandle_t		combatSounds[MAX_CUSTOM_COMBAT_SOUNDS];
+	sfxHandle_t		extraSounds[MAX_CUSTOM_EXTRA_SOUNDS];
+	sfxHandle_t		jediSounds[MAX_CUSTOM_JEDI_SOUNDS];
+	sfxHandle_t		siegeSounds[MAX_CUSTOM_SIEGE_SOUNDS];
+	sfxHandle_t		duelSounds[MAX_CUSTOM_DUEL_SOUNDS];
+
+	int				legsAnim;
+	int				torsoAnim;
+
+	float		facial_blink;		// time before next blink. If a minus value, we are in blink mode
+	float		facial_frown;		// time before next frown. If a minus value, we are in frown mode
+	float		facial_aux;			// time before next aux. If a minus value, we are in aux mode
+
+	int			superSmoothTime; //do crazy amount of smoothing
+
+#ifdef _XBOX
+	int			friendshipStatus;
+#endif
+	
+} clientInfo_t;
+
+//rww - cheap looping sound struct
+#ifdef _XBOX
+#define MAX_CG_LOOPSOUNDS 2
+#else
+#define MAX_CG_LOOPSOUNDS 8
+#endif
+
+typedef struct cgLoopSound_s {
+	int entityNum;
+	vec3_t origin;
+	vec3_t velocity;
+	sfxHandle_t sfx;
+} cgLoopSound_t;
+
+// centity_t have a direct corespondence with gentity_t in the game, but
+// only the entityState_t is directly communicated to the cgame
+typedef struct centity_s {
+	// This comment below is correct, but now m_pVehicle is the first thing in bg shared entity, so it goes first. - AReis
+	//rww - entstate must be first, to correspond with the bg shared entity structure
+	entityState_t	currentState;	// from cg.frame
+	playerState_t	*playerState;	//ptr to playerstate if applicable (for bg ents)
+	Vehicle_t		*m_pVehicle; //vehicle data
+	void			*ghoul2; //g2 instance
+	int				localAnimIndex; //index locally (game/cgame) to anim data for this skel
+	vec3_t			modelScale; //needed for g2 collision
+
+	//from here up must be unified with bgEntity_t -rww
+
+	entityState_t	nextState;		// from cg.nextFrame, if available
+	qboolean		interpolate;	// true if next is valid to interpolate to
+	qboolean		currentValid;	// true if cg.frame holds this entity
+
+	int				muzzleFlashTime;	// move to playerEntity?
+	int				previousEvent;
+//	int				teleportFlag;
+
+	int				trailTime;		// so missile trails can handle dropped initial packets
+	int				dustTrailTime;
+	int				miscTime;
+
+	vec3_t			damageAngles;
+	int				damageTime;
+
+	int				snapShotTime;	// last time this entity was found in a snapshot
+
+	playerEntity_t	pe;
+
+//	int				errorTime;		// decay the error from this time
+//	vec3_t			errorOrigin;
+//	vec3_t			errorAngles;
+	
+//	qboolean		extrapolated;	// false if origin / angles is an interpolation
+//	vec3_t			rawOrigin;
+	vec3_t			rawAngles;
+
+	vec3_t			beamEnd;
+
+	// exact interpolated position of entity on this frame
+	vec3_t			lerpOrigin;
+	vec3_t			lerpAngles;
+
+#if 0
+	//add up bone offsets until next client frame before adding them in
+	qboolean		hasRagOffset;
+	vec3_t			ragOffsets;
+	int				ragOffsetTime;
+#endif
+
+	vec3_t			ragLastOrigin;
+	int				ragLastOriginTime;
+
+	qboolean		noLumbar; //if true only do anims and things on model_root instead of lower_lumbar, this will be the case for some NPCs.
+	qboolean		noFace;
+
+	//For keeping track of the current surface status in relation to the entitystate surface fields.
+	int				npcLocalSurfOn;
+	int				npcLocalSurfOff;
+
+	int				eventAnimIndex;
+
+	clientInfo_t	*npcClient; //dynamically allocated - always free it, and never stomp over it.
+
+	int				weapon;
+
+	void			*ghoul2weapon; //rww - pointer to ghoul2 instance of the current 3rd person weapon
+
+	float			radius;
+	int				boltInfo;
+
+	//sometimes used as a bolt index, but these values are also used as generic values for clientside entities
+	//at times
+	int				bolt1;
+	int				bolt2;
+	int				bolt3;
+	int				bolt4;
+
+	float			bodyHeight;
+
+	int				torsoBolt;
+	
+	vec3_t			turAngles;
+
+	vec3_t			frame_minus1;
+	vec3_t			frame_minus2;
+
+	int				frame_minus1_refreshed;
+	int				frame_minus2_refreshed;
+
+	void			*frame_hold; //pointer to a ghoul2 instance
+
+	int				frame_hold_time;
+	int				frame_hold_refreshed;
+
+	void			*grip_arm; //pointer to a ghoul2 instance
+
+	int				trickAlpha;
+	int				trickAlphaTime;
+
+	int				teamPowerEffectTime;
+	qboolean		teamPowerType; //0 regen, 1 heal, 2 drain, 3 absorb
+
+	qboolean		isRagging;
+	qboolean		ownerRagging;
+	int				overridingBones;
+
+	int				bodyFadeTime;
+	vec3_t			pushEffectOrigin;
+
+	cgLoopSound_t	loopingSound[MAX_CG_LOOPSOUNDS];
+	int				numLoopingSounds;
+
+	int				serverSaberHitIndex;
+	int				serverSaberHitTime;
+	qboolean		serverSaberFleshImpact; //true if flesh, false if anything else.
+
+	qboolean		ikStatus;
+
+	qboolean		saberWasInFlight;
+
+	float			smoothYaw;
+
+	int				uncloaking;
+	qboolean		cloaked;
+
+	int				vChatTime;
+} centity_t;
+
+
+//======================================================================
+
+// local entities are created as a result of events or predicted actions,
+// and live independently from all server transmitted entities
+
+typedef struct markPoly_s {
+	struct markPoly_s	*prevMark, *nextMark;
+	int			time;
+	qhandle_t	markShader;
+	qboolean	alphaFade;		// fade alpha instead of rgb
+	float		color[4];
+	poly_t		poly;
+	polyVert_t	verts[MAX_VERTS_ON_POLY];
+} markPoly_t;
+
+
+typedef enum {
+	LE_MARK,
+	LE_EXPLOSION,
+	LE_SPRITE_EXPLOSION,
+	LE_FADE_SCALE_MODEL, // currently only for Demp2 shock sphere
+	LE_FRAGMENT,
+	LE_PUFF,
+	LE_MOVE_SCALE_FADE,
+	LE_FALL_SCALE_FADE,
+	LE_FADE_RGB,
+	LE_SCALE_FADE,
+	LE_SCOREPLUM,
+	LE_OLINE,
+	LE_SHOWREFENTITY,
+	LE_LINE
+} leType_t;
+
+typedef enum {
+	LEF_PUFF_DONT_SCALE = 0x0001,			// do not scale size over time
+	LEF_TUMBLE			= 0x0002,			// tumble over time, used for ejecting shells
+	LEF_FADE_RGB		= 0x0004,			// explicitly fade
+	LEF_NO_RANDOM_ROTATE= 0x0008			// MakeExplosion adds random rotate which could be bad in some cases
+} leFlag_t;
+
+typedef enum {
+	LEMT_NONE,
+	LEMT_BURN,
+	LEMT_BLOOD
+} leMarkType_t;			// fragment local entities can leave marks on walls
+
+typedef enum {
+	LEBS_NONE,
+	LEBS_BLOOD,
+	LEBS_BRASS,
+	LEBS_METAL,
+	LEBS_ROCK
+} leBounceSoundType_t;	// fragment local entities can make sounds on impacts
+
+typedef struct localEntity_s {
+	struct localEntity_s	*prev, *next;
+	leType_t		leType;
+	int				leFlags;
+
+	int				startTime;
+	int				endTime;
+	int				fadeInTime;
+
+	float			lifeRate;			// 1.0 / (endTime - startTime)
+
+	trajectory_t	pos;
+	trajectory_t	angles;
+
+	float			bounceFactor;		// 0.0 = no bounce, 1.0 = perfect
+	int				bounceSound;		// optional sound index to play upon bounce
+
+	float			alpha;
+	float			dalpha;
+
+	int				forceAlpha;
+
+	float			color[4];
+
+	float			radius;
+
+	float			light;
+	vec3_t			lightColor;
+
+	leMarkType_t		leMarkType;		// mark to leave on fragment impact
+	leBounceSoundType_t	leBounceSoundType;
+
+	union {
+		struct {
+			float radius;
+			float dradius;
+			vec3_t startRGB;
+			vec3_t dRGB;
+		} sprite;
+		struct {
+			float width;
+			float dwidth;
+			float length;
+			float dlength;
+			vec3_t startRGB;
+			vec3_t dRGB;
+		} trail;
+		struct {
+			float width;
+			float dwidth;
+			// Below are bezier specific.
+			vec3_t			control1;				// initial position of control points
+			vec3_t			control2;
+			vec3_t			control1_velocity;		// initial velocity of control points
+			vec3_t			control2_velocity;
+			vec3_t			control1_acceleration;	// constant acceleration of control points
+			vec3_t			control2_acceleration;
+		} line;
+		struct {
+			float width;
+			float dwidth;
+			float width2;
+			float dwidth2;
+			vec3_t startRGB;
+			vec3_t dRGB;
+		} line2;
+		struct {
+			float width;
+			float dwidth;
+			float width2;
+			float dwidth2;
+			float height;
+			float dheight;
+		} cylinder;
+		struct {
+			float width;
+			float dwidth;
+		} electricity;
+		struct
+		{
+			// fight the power! open and close brackets in the same column!
+			float radius;
+			float dradius;
+			qboolean (*thinkFn)(struct localEntity_s *le);
+			vec3_t	dir;	// magnitude is 1, but this is oldpos - newpos right before the
+							//particle is sent to the renderer
+			// may want to add something like particle::localEntity_s *le (for the particle's think fn)
+		} particle;
+		struct
+		{
+			qboolean	dontDie;
+			vec3_t		dir;
+			float		variance;
+			int			delay;
+			int			nextthink;
+			qboolean	(*thinkFn)(struct localEntity_s *le);
+			int			data1;
+			int			data2;
+		} spawner;
+		struct
+		{
+			float radius;
+		} fragment;
+	} data;
+
+	refEntity_t		refEntity;		
+} localEntity_t;
+
+//======================================================================
+
+
+typedef struct {
+	int				client;
+	int				score;
+	int				ping;
+	int				time;
+	int				scoreFlags;
+	int				powerUps;
+	int				accuracy;
+	int				impressiveCount;
+	int				excellentCount;
+	int				guantletCount;
+	int				defendCount;
+	int				assistCount;
+	int				captures;
+	qboolean	perfect;
+	int				team;
+} score_t;
+
+
+// each WP_* weapon enum has an associated weaponInfo_t
+// that contains media references necessary to present the
+// weapon and its effects
+typedef struct weaponInfo_s {
+	qboolean		registered;
+	gitem_t			*item;
+
+	qhandle_t		handsModel;			// the hands don't actually draw, they just position the weapon
+	qhandle_t		weaponModel;		// this is the pickup model
+	qhandle_t		viewModel;			// this is the in-view model used by the player
+	qhandle_t		barrelModel;
+	qhandle_t		flashModel;
+
+	vec3_t			weaponMidpoint;		// so it will rotate centered instead of by tag
+
+	float			flashDlight;
+	vec3_t			flashDlightColor;
+
+	qhandle_t		weaponIcon;
+	qhandle_t		ammoIcon;
+
+	qhandle_t		ammoModel;
+
+	sfxHandle_t		flashSound[4];		// fast firing weapons randomly choose
+	sfxHandle_t		firingSound;
+	sfxHandle_t		chargeSound;
+	fxHandle_t		muzzleEffect;
+	qhandle_t		missileModel;
+	sfxHandle_t		missileSound;
+	void			(*missileTrailFunc)( centity_t *, const struct weaponInfo_s *wi );
+	float			missileDlight;
+	vec3_t			missileDlightColor;
+	int				missileRenderfx;
+	sfxHandle_t		missileHitSound;
+
+	sfxHandle_t		altFlashSound[4];
+	sfxHandle_t		altFiringSound;
+	sfxHandle_t		altChargeSound;
+	fxHandle_t		altMuzzleEffect;
+	qhandle_t		altMissileModel;
+	sfxHandle_t		altMissileSound;
+	void			(*altMissileTrailFunc)( centity_t *, const struct weaponInfo_s *wi );
+	float			altMissileDlight;
+	vec3_t			altMissileDlightColor;
+	int				altMissileRenderfx;
+	sfxHandle_t		altMissileHitSound;
+
+	sfxHandle_t		selectSound;
+
+	sfxHandle_t		readySound;
+	float			trailRadius;
+	float			wiTrailTime;
+
+} weaponInfo_t;
+
+
+// each IT_* item has an associated itemInfo_t
+// that constains media references necessary to present the
+// item and its effects
+typedef struct {
+	qboolean		registered;
+	qhandle_t		models[MAX_ITEM_MODELS];
+	qhandle_t		icon;
+/*
+Ghoul2 Insert Start
+*/
+	void			*g2Models[MAX_ITEM_MODELS];
+	float			radius[MAX_ITEM_MODELS];
+/*
+Ghoul2 Insert End
+*/
+} itemInfo_t;
+
+
+typedef struct {
+	int				itemNum;
+} powerupInfo_t;
+
+
+#define MAX_SKULLTRAIL		10
+
+typedef struct {
+	vec3_t positions[MAX_SKULLTRAIL];
+	int numpositions;
+} skulltrail_t;
+
+
+#define MAX_REWARDSTACK		10
+#define MAX_SOUNDBUFFER		20
+
+//======================================================================
+
+// all cg.stepTime, cg.duckTime, cg.landTime, etc are set to cg.time when the action
+// occurs, and they will have visible effects for #define STEP_TIME or whatever msec after
+
+#define MAX_PREDICTED_EVENTS	16
+
+
+#define	MAX_CHATBOX_ITEMS		5
+typedef struct chatBoxItem_s
+{
+	char	string[MAX_SAY_TEXT];
+	int		time;
+	int		lines;
+} chatBoxItem_t;
+
+typedef struct {
+	int			clientFrame;		// incremented each frame
+
+	int			clientNum;
+	
+	qboolean	demoPlayback;
+	qboolean	levelShot;			// taking a level menu screenshot
+	int			deferredPlayerLoading;
+	qboolean	loading;			// don't defer players at initial startup
+	qboolean	intermissionStarted;	// don't play voice rewards, because game will end shortly
+
+	// there are only one or two snapshot_t that are relevent at a time
+	int			latestSnapshotNum;	// the number of snapshots the client system has received
+	int			latestSnapshotTime;	// the time from latestSnapshotNum, so we don't need to read the snapshot yet
+
+	snapshot_t	*snap;				// cg.snap->serverTime <= cg.time
+	snapshot_t	*nextSnap;			// cg.nextSnap->serverTime > cg.time, or NULL
+//	snapshot_t	activeSnapshots[2];
+
+	float		frameInterpolation;	// (float)( cg.time - cg.frame->serverTime ) / (cg.nextFrame->serverTime - cg.frame->serverTime)
+
+	qboolean	mMapChange;
+
+	qboolean	thisFrameTeleport;
+	qboolean	nextFrameTeleport;
+
+	int			frametime;		// cg.time - cg.oldTime
+
+	int			time;			// this is the time value that the client
+								// is rendering at.
+	int			oldTime;		// time at last frame, used for missile trails and prediction checking
+
+	int			physicsTime;	// either cg.snap->time or cg.nextSnap->time
+
+	int			timelimitWarnings;	// 5 min, 1 min, overtime
+	int			fraglimitWarnings;
+
+	qboolean	mapRestart;			// set on a map restart to set back the weapon
+
+	qboolean	mInRMG; //rwwRMG - added
+	qboolean	mRMGWeather; //rwwRMG - added
+
+	qboolean	renderingThirdPerson;		// during deaths, chasecams, etc
+
+	// prediction state
+	qboolean	hyperspace;				// true if prediction has hit a trigger_teleport
+	playerState_t	predictedPlayerState;
+	playerState_t	predictedVehicleState;
+	
+	//centity_t		predictedPlayerEntity;
+	//rww - I removed this and made it use cg_entities[clnum] directly.
+
+	qboolean	validPPS;				// clear until the first call to CG_PredictPlayerState
+	int			predictedErrorTime;
+	vec3_t		predictedError;
+
+	int			eventSequence;
+	int			predictableEvents[MAX_PREDICTED_EVENTS];
+
+	float		stepChange;				// for stair up smoothing
+	int			stepTime;
+
+	float		duckChange;				// for duck viewheight smoothing
+	int			duckTime;
+
+	float		landChange;				// for landing hard
+	int			landTime;
+
+	// input state sent to server
+	int			weaponSelect;
+
+	int			forceSelect;
+	int			itemSelect;
+
+	// auto rotating items
+	vec3_t		autoAngles;
+	vec3_t		autoAxis[3];
+	vec3_t		autoAnglesFast;
+	vec3_t		autoAxisFast[3];
+
+	// view rendering
+	refdef_t	refdef;
+
+#ifdef _XBOX
+	qboolean widescreen;
+#endif
+
+	// zoom key
+	qboolean	zoomed;
+	int			zoomTime;
+	float		zoomSensitivity;
+
+	// information screen text during loading
+	char		infoScreenText[MAX_STRING_CHARS];
+
+	// scoreboard
+	int			scoresRequestTime;
+	int			numScores;
+	int			selectedScore;
+	int			teamScores[2];
+	score_t		scores[MAX_CLIENTS];
+	qboolean	showScores;
+	qboolean	scoreBoardShowing;
+	int			scoreFadeTime;
+	char		killerName[MAX_NAME_LENGTH];
+	char			spectatorList[MAX_STRING_CHARS];		// list of names
+	int				spectatorLen;												// length of list
+	float			spectatorWidth;											// width in device units
+	int				spectatorTime;											// next time to offset
+	int				spectatorPaintX;										// current paint x
+	int				spectatorPaintX2;										// current paint x
+	int				spectatorOffset;										// current offset from start
+	int				spectatorPaintLen; 									// current offset from start
+
+	// skull trails
+	skulltrail_t	skulltrails[MAX_CLIENTS];
+
+	// centerprinting
+	int			centerPrintTime;
+	int			centerPrintCharWidth;
+	int			centerPrintY;
+	char		centerPrint[1024];
+	int			centerPrintLines;
+
+	// low ammo warning state
+	int			lowAmmoWarning;		// 1 = low, 2 = empty
+
+	// kill timers for carnage reward
+	int			lastKillTime;
+
+	// crosshair client ID
+	int			crosshairClientNum;
+	int			crosshairClientTime;
+
+	int			crosshairVehNum;
+	int			crosshairVehTime;
+
+	// powerup active flashing
+	int			powerupActive;
+	int			powerupTime;
+
+	// attacking player
+	int			attackerTime;
+	int			voiceTime;
+
+	// reward medals
+	int			rewardStack;
+	int			rewardTime;
+	int			rewardCount[MAX_REWARDSTACK];
+	qhandle_t	rewardShader[MAX_REWARDSTACK];
+	qhandle_t	rewardSound[MAX_REWARDSTACK];
+
+	// sound buffer mainly for announcer sounds
+	int			soundBufferIn;
+	int			soundBufferOut;
+	int			soundTime;
+	qhandle_t	soundBuffer[MAX_SOUNDBUFFER];
+
+	// for voice chat buffer
+	int			voiceChatTime;
+	int			voiceChatBufferIn;
+	int			voiceChatBufferOut;
+
+	// warmup countdown
+	int			warmup;
+	int			warmupCount;
+
+	//==========================
+
+	int			itemPickup;
+	int			itemPickupTime;
+	int			itemPickupBlendTime;	// the pulse around the crosshair is timed seperately
+
+	int			weaponSelectTime;
+	int			weaponAnimation;
+	int			weaponAnimationTime;
+
+	// blend blobs
+	float		damageTime;
+	float		damageX, damageY, damageValue;
+
+	// status bar head
+	float		headYaw;
+	float		headEndPitch;
+	float		headEndYaw;
+	int			headEndTime;
+	float		headStartPitch;
+	float		headStartYaw;
+	int			headStartTime;
+
+	// view movement
+	float		v_dmg_time;
+	float		v_dmg_pitch;
+	float		v_dmg_roll;
+
+	vec3_t		kick_angles;	// weapon kicks
+	int			kick_time;
+	vec3_t		kick_origin;
+
+	// temp working variables for player view
+	float		bobfracsin;
+	int			bobcycle;
+	float		xyspeed;
+	int     nextOrbitTime;
+
+	//qboolean cameraMode;		// if rendering from a loaded camera
+	int			loadLCARSStage;
+
+	int			forceHUDTotalFlashTime;
+	int			forceHUDNextFlashTime;
+	qboolean	forceHUDActive;				// Flag to show force hud is off/on
+
+	// development tool
+	refEntity_t		testModelEntity;
+	char			testModelName[MAX_QPATH];
+	qboolean		testGun;
+
+	int			VHUDFlashTime;
+	qboolean	VHUDTurboFlag;
+
+	// HUD stuff
+	float			HUDTickFlashTime;
+	qboolean		HUDArmorFlag;
+	qboolean		HUDHealthFlag;
+	qboolean		iconHUDActive;
+	float			iconHUDPercent;
+	float			iconSelectTime;
+	float			invenSelectTime;
+	float			forceSelectTime;
+
+	vec3_t			lastFPFlashPoint;
+
+/*
+Ghoul2 Insert Start
+*/
+	int				testModel;
+	// had to be moved so we wouldn't wipe these out with the memset - these have STL in them and shouldn't be cleared that way
+	snapshot_t	activeSnapshots[2];
+/*
+Ghoul2 Insert End
+*/
+
+	char				sharedBuffer[MAX_CG_SHARED_BUFFER_SIZE];
+
+	short				radarEntityCount;
+	short				radarEntities[MAX_CLIENTS+16];
+
+	short				bracketedEntityCount;
+	short				bracketedEntities[MAX_CLIENTS+16];
+
+	float				distanceCull;
+
+	chatBoxItem_t		chatItems[MAX_CHATBOX_ITEMS];
+	int					chatItemActive;
+	
+#if 0
+	int					snapshotTimeoutTime;
+#endif
+	
+} cg_t;
+
+#define MAX_TICS	14
+
+typedef struct forceTicPos_s
+{
+	int				x;
+	int				y;
+	int				width;
+	int				height;
+	char			*file;
+	qhandle_t		tic;
+} forceTicPos_t;
+extern forceTicPos_t forceTicPos[];
+extern forceTicPos_t ammoTicPos[];
+
+typedef struct cgscreffects_s
+{
+	float		FOV;
+	float		FOV2;
+
+	float		shake_intensity;
+	int			shake_duration;
+	int			shake_start;
+
+	float		music_volume_multiplier;
+	int			music_volume_time;
+	qboolean	music_volume_set;
+} cgscreffects_t;
+
+extern cgscreffects_t cgScreenEffects;
+
+void CGCam_Shake( float intensity, int duration );
+void CGCam_SetMusicMult( float multiplier, int duration );
+
+typedef enum 
+{
+	CHUNK_METAL1 = 0,
+	CHUNK_METAL2,
+	CHUNK_ROCK1,
+	CHUNK_ROCK2,
+	CHUNK_ROCK3,
+	CHUNK_CRATE1,
+	CHUNK_CRATE2,
+	CHUNK_WHITE_METAL,
+	NUM_CHUNK_TYPES
+};
+#define NUM_CHUNK_MODELS	4
+
+// all of the model, shader, and sound references that are
+// loaded at gamestate time are stored in cgMedia_t
+// Other media that can be tied to clients, weapons, or items are
+// stored in the clientInfo_t, itemInfo_t, weaponInfo_t, and powerupInfo_t
+typedef struct {
+	qhandle_t	charsetShader;
+	qhandle_t	whiteShader;
+
+	qhandle_t	loadBarLED;
+	qhandle_t	loadBarLEDCap;
+	qhandle_t	loadBarLEDSurround;
+
+	qhandle_t	bryarFrontFlash;
+	qhandle_t	greenFrontFlash;
+	qhandle_t	lightningFlash;
+
+	qhandle_t	itemHoloModel;
+	qhandle_t	redFlagModel;
+	qhandle_t	blueFlagModel;
+
+	qhandle_t	flagPoleModel;
+	qhandle_t	flagFlapModel;
+
+	qhandle_t	redFlagBaseModel;
+	qhandle_t	blueFlagBaseModel;
+	qhandle_t	neutralFlagBaseModel;
+
+	qhandle_t	teamStatusBar;
+
+	qhandle_t	deferShader;
+
+	qhandle_t	radarShader;
+	qhandle_t	siegeItemShader;
+	qhandle_t	mAutomapPlayerIcon;
+	qhandle_t	mAutomapRocketIcon;
+
+	qhandle_t	wireframeAutomapFrame_left;
+	qhandle_t	wireframeAutomapFrame_right;
+	qhandle_t	wireframeAutomapFrame_top;
+	qhandle_t	wireframeAutomapFrame_bottom;
+
+//Chunks
+	qhandle_t	chunkModels[NUM_CHUNK_TYPES][4];
+	sfxHandle_t	chunkSound;
+	sfxHandle_t	grateSound;
+	sfxHandle_t	rockBreakSound;
+	sfxHandle_t	rockBounceSound[2];
+	sfxHandle_t	metalBounceSound[2];
+	sfxHandle_t	glassChunkSound;
+	sfxHandle_t	crateBreakSound[2];
+
+	qhandle_t	hackerIconShader;
+
+	// Saber shaders
+	//-----------------------------
+	qhandle_t	forceCoronaShader;
+
+	qhandle_t	redSaberGlowShader;
+	qhandle_t	redSaberCoreShader;
+	qhandle_t	orangeSaberGlowShader;
+	qhandle_t	orangeSaberCoreShader;
+	qhandle_t	yellowSaberGlowShader;
+	qhandle_t	yellowSaberCoreShader;
+	qhandle_t	greenSaberGlowShader;
+	qhandle_t	greenSaberCoreShader;
+	qhandle_t	blueSaberGlowShader;
+	qhandle_t	blueSaberCoreShader;
+	qhandle_t	purpleSaberGlowShader;
+	qhandle_t	purpleSaberCoreShader;
+	qhandle_t	saberBlurShader;
+
+	qhandle_t	yellowDroppedSaberShader;
+
+	qhandle_t	rivetMarkShader;
+
+	qhandle_t	teamRedShader;
+	qhandle_t	teamBlueShader;
+
+	qhandle_t	powerDuelAllyShader;
+
+	qhandle_t	balloonShader;
+	qhandle_t	vchatShader;
+	qhandle_t	connectionShader;
+
+	qhandle_t	crosshairShader[NUM_CROSSHAIRS];
+	qhandle_t	lagometerShader;
+	qhandle_t	backTileShader;
+
+	qhandle_t	numberShaders[11];
+	qhandle_t	smallnumberShaders[11];
+	qhandle_t	chunkyNumberShaders[11];
+
+	qhandle_t	electricBodyShader;
+	qhandle_t	electricBody2Shader;
+
+	qhandle_t	fsrMarkShader;
+	qhandle_t	fslMarkShader;
+	qhandle_t	fshrMarkShader;
+	qhandle_t	fshlMarkShader;
+
+	qhandle_t	refractionShader;
+
+	qhandle_t	cloakedShader;
+
+	qhandle_t	boltShader;
+
+	qhandle_t	shadowMarkShader;
+
+	//glass shard shader
+	qhandle_t	glassShardShader;
+
+	// wall mark shaders
+	qhandle_t	wakeMarkShader;
+
+	// Pain view shader
+	qhandle_t	viewPainShader;
+	qhandle_t	viewPainShader_Shields;
+	qhandle_t	viewPainShader_ShieldsAndHealth;
+
+	qhandle_t	itemRespawningPlaceholder;
+	qhandle_t	itemRespawningRezOut;
+
+	qhandle_t	playerShieldDamage;
+	qhandle_t	protectShader;
+	qhandle_t	forceSightBubble;
+	qhandle_t	forceShell;
+	qhandle_t	sightShell;
+
+	// Disruptor zoom graphics
+	qhandle_t	disruptorMask;
+	qhandle_t	disruptorInsert;
+	qhandle_t	disruptorLight;
+	qhandle_t	disruptorInsertTick;
+	qhandle_t	disruptorChargeShader;
+
+	// Binocular graphics
+	qhandle_t	binocularCircle;
+	qhandle_t	binocularMask;
+	qhandle_t	binocularArrow;
+	qhandle_t	binocularTri;
+	qhandle_t	binocularStatic;
+	qhandle_t	binocularOverlay;
+
+	// weapon effect models
+	qhandle_t	lightningExplosionModel;
+
+	// explosion assets
+	qhandle_t	explosionModel;
+	qhandle_t	surfaceExplosionShader;
+
+	qhandle_t	disruptorShader;
+
+	qhandle_t	solidWhite;
+
+	qhandle_t	heartShader;
+
+	// All the player shells
+	qhandle_t	ysaliredShader;
+	qhandle_t	ysaliblueShader;
+	qhandle_t	ysalimariShader;
+	qhandle_t	boonShader;
+	qhandle_t	endarkenmentShader;
+	qhandle_t	enlightenmentShader;
+	qhandle_t	invulnerabilityShader;
+
+#ifdef JK2AWARDS
+	// medals shown during gameplay
+	qhandle_t	medalImpressive;
+	qhandle_t	medalExcellent;
+	qhandle_t	medalGauntlet;
+	qhandle_t	medalDefend;
+	qhandle_t	medalAssist;
+	qhandle_t	medalCapture;
+#endif
+
+	// sounds
+	sfxHandle_t	selectSound;
+	sfxHandle_t	footsteps[FOOTSTEP_TOTAL][4];
+
+	sfxHandle_t	winnerSound;
+	sfxHandle_t	loserSound;
+
+	sfxHandle_t crackleSound;
+
+	sfxHandle_t	grenadeBounce1;
+	sfxHandle_t	grenadeBounce2;
+
+	sfxHandle_t teamHealSound;
+	sfxHandle_t teamRegenSound;
+
+	sfxHandle_t	teleInSound;
+	sfxHandle_t	teleOutSound;
+	sfxHandle_t	respawnSound;
+	sfxHandle_t talkSound;
+	sfxHandle_t landSound;
+	sfxHandle_t fallSound;
+
+	sfxHandle_t oneMinuteSound;
+	sfxHandle_t fiveMinuteSound;
+
+	sfxHandle_t threeFragSound;
+	sfxHandle_t twoFragSound;
+	sfxHandle_t oneFragSound;
+
+#ifdef JK2AWARDS
+	sfxHandle_t impressiveSound;
+	sfxHandle_t excellentSound;
+	sfxHandle_t deniedSound;
+	sfxHandle_t humiliationSound;
+	sfxHandle_t defendSound;
+#endif
+
+	/*
+	sfxHandle_t takenLeadSound;
+	sfxHandle_t tiedLeadSound;
+	sfxHandle_t lostLeadSound;
+	*/
+
+	sfxHandle_t rollSound;
+
+	sfxHandle_t watrInSound;
+	sfxHandle_t watrOutSound;
+	sfxHandle_t watrUnSound;
+
+	sfxHandle_t noforceSound;
+
+	sfxHandle_t deploySeeker;
+	sfxHandle_t medkitSound;
+
+	// teamplay sounds
+#ifdef JK2AWARDS
+	sfxHandle_t captureAwardSound;
+#endif
+	sfxHandle_t redScoredSound;
+	sfxHandle_t blueScoredSound;
+	sfxHandle_t redLeadsSound;
+	sfxHandle_t blueLeadsSound;
+	sfxHandle_t teamsTiedSound;
+
+	sfxHandle_t redFlagReturnedSound;
+	sfxHandle_t blueFlagReturnedSound;
+	sfxHandle_t	redTookFlagSound;
+	sfxHandle_t blueTookFlagSound;
+
+	sfxHandle_t redYsalReturnedSound;
+	sfxHandle_t blueYsalReturnedSound;
+	sfxHandle_t	redTookYsalSound;
+	sfxHandle_t blueTookYsalSound;
+
+	sfxHandle_t	drainSound;
+
+	//music blips
+	sfxHandle_t	happyMusic;
+	sfxHandle_t dramaticFailure;
+
+	// tournament sounds
+	sfxHandle_t	count3Sound;
+	sfxHandle_t	count2Sound;
+	sfxHandle_t	count1Sound;
+	sfxHandle_t	countFightSound;
+
+	// new stuff
+	qhandle_t patrolShader;
+	qhandle_t assaultShader;
+	qhandle_t campShader;
+	qhandle_t followShader;
+	qhandle_t defendShader;
+	qhandle_t teamLeaderShader;
+	qhandle_t retrieveShader;
+	qhandle_t escortShader;
+	qhandle_t flagShaders[3];
+
+	qhandle_t halfShieldModel;
+	qhandle_t halfShieldShader;
+
+	qhandle_t demp2Shell;
+	qhandle_t demp2ShellShader;
+
+	qhandle_t cursor;
+	qhandle_t selectCursor;
+	qhandle_t sizeCursor;
+
+	//weapon icons
+	qhandle_t weaponIcons[WP_NUM_WEAPONS];
+	qhandle_t weaponIcons_NA[WP_NUM_WEAPONS];
+
+	//holdable inventory item icons
+	qhandle_t invenIcons[HI_NUM_HOLDABLE];
+
+	//force power icons
+	qhandle_t forcePowerIcons[NUM_FORCE_POWERS];
+
+	qhandle_t rageRecShader;
+
+	//other HUD parts
+	int			currentBackground;
+	qhandle_t	weaponIconBackground;
+	qhandle_t	forceIconBackground;
+	qhandle_t	inventoryIconBackground;
+
+	sfxHandle_t	holocronPickup;
+
+	// Zoom
+	sfxHandle_t	zoomStart;
+	sfxHandle_t	zoomLoop;
+	sfxHandle_t	zoomEnd;
+	sfxHandle_t	disruptorZoomLoop;
+
+	qhandle_t	bdecal_bodyburn1;
+	qhandle_t	bdecal_saberglow;
+	qhandle_t	bdecal_burn1;
+	qhandle_t	mSaberDamageGlow;
+
+	// For vehicles only now
+	sfxHandle_t	noAmmoSound;
+
+} cgMedia_t;
+
+
+// Stored FX handles
+//--------------------
+typedef struct
+{
+	//concussion
+	fxHandle_t	concussionShotEffect;
+	fxHandle_t	concussionImpactEffect;
+
+	// BRYAR PISTOL
+	fxHandle_t	bryarShotEffect;
+	fxHandle_t	bryarPowerupShotEffect;
+	fxHandle_t	bryarWallImpactEffect;
+	fxHandle_t	bryarWallImpactEffect2;
+	fxHandle_t	bryarWallImpactEffect3;
+	fxHandle_t	bryarFleshImpactEffect;
+	fxHandle_t	bryarDroidImpactEffect;
+
+	// BLASTER
+	fxHandle_t  blasterShotEffect;
+	fxHandle_t  blasterWallImpactEffect;
+	fxHandle_t  blasterFleshImpactEffect;
+	fxHandle_t  blasterDroidImpactEffect;
+
+	// DISRUPTOR
+	fxHandle_t  disruptorRingsEffect;
+	fxHandle_t  disruptorProjectileEffect;
+	fxHandle_t  disruptorWallImpactEffect;	
+	fxHandle_t  disruptorFleshImpactEffect;	
+	fxHandle_t  disruptorAltMissEffect;	
+	fxHandle_t  disruptorAltHitEffect;	
+
+	// BOWCASTER
+	fxHandle_t	bowcasterShotEffect;
+	fxHandle_t	bowcasterImpactEffect;
+
+	// REPEATER
+	fxHandle_t  repeaterProjectileEffect;
+	fxHandle_t  repeaterAltProjectileEffect;
+	fxHandle_t  repeaterWallImpactEffect;	
+	fxHandle_t  repeaterFleshImpactEffect;
+	fxHandle_t  repeaterAltWallImpactEffect;
+
+	// DEMP2
+	fxHandle_t  demp2ProjectileEffect;
+	fxHandle_t  demp2WallImpactEffect;
+	fxHandle_t  demp2FleshImpactEffect;
+
+	// FLECHETTE
+	fxHandle_t	flechetteShotEffect;
+	fxHandle_t	flechetteAltShotEffect;
+	fxHandle_t	flechetteWallImpactEffect;
+	fxHandle_t	flechetteFleshImpactEffect;
+
+	// ROCKET
+	fxHandle_t  rocketShotEffect;
+	fxHandle_t  rocketExplosionEffect;
+
+	// THERMAL
+	fxHandle_t	thermalExplosionEffect;
+	fxHandle_t	thermalShockwaveEffect;
+
+	// TRIPMINE
+	fxHandle_t	tripmineLaserFX;
+	fxHandle_t	tripmineGlowFX;
+
+	//FORCE
+	fxHandle_t forceLightning;
+	fxHandle_t forceLightningWide;
+
+	fxHandle_t forceDrain;
+	fxHandle_t forceDrainWide;
+	fxHandle_t forceDrained;
+
+	//TURRET
+	fxHandle_t turretShotEffect;
+
+	//Whatever
+	fxHandle_t itemCone;
+
+	fxHandle_t	mSparks;
+	fxHandle_t	mSaberCut;
+	fxHandle_t	mTurretMuzzleFlash;
+	fxHandle_t	mSaberBlock;
+	fxHandle_t	mSaberBloodSparks;
+	fxHandle_t	mSaberBloodSparksSmall;
+	fxHandle_t	mSaberBloodSparksMid;
+	fxHandle_t	mSpawn;
+	fxHandle_t	mJediSpawn;
+	fxHandle_t	mBlasterDeflect;
+	fxHandle_t	mBlasterSmoke;
+	fxHandle_t	mForceConfustionOld;
+	fxHandle_t	mDisruptorDeathSmoke;
+	fxHandle_t	mSparkExplosion;
+	fxHandle_t	mTurretExplode;
+	fxHandle_t	mEmplacedExplode;
+	fxHandle_t	mEmplacedDeadSmoke;
+	fxHandle_t	mTripmineExplosion;
+	fxHandle_t	mDetpackExplosion;
+	fxHandle_t	mFlechetteAltBlow;
+	fxHandle_t	mStunBatonFleshImpact;
+	fxHandle_t	mAltDetonate;
+	fxHandle_t	mSparksExplodeNoSound;
+	fxHandle_t	mTripMineLaster;
+	fxHandle_t	mEmplacedMuzzleFlash;
+	fxHandle_t	mConcussionAltRing;
+	fxHandle_t	mHyperspaceStars;
+	fxHandle_t	mBlackSmoke;
+	fxHandle_t	mShipDestDestroyed;
+	fxHandle_t	mShipDestBurning;
+	fxHandle_t	mBobaJet;
+
+	//footstep effects
+	fxHandle_t footstepMud;
+	fxHandle_t footstepSand;
+	fxHandle_t footstepSnow;
+	fxHandle_t footstepGravel;
+	//landing effects
+	fxHandle_t landingMud;
+	fxHandle_t landingSand;
+	fxHandle_t landingDirt;
+	fxHandle_t landingSnow;
+	fxHandle_t landingGravel;
+	//splashes
+	fxHandle_t waterSplash;
+	fxHandle_t lavaSplash;
+	fxHandle_t acidSplash;
+} cgEffects_t;
+
+
+// The client game static (cgs) structure hold everything
+// loaded or calculated from the gamestate.  It will NOT
+// be cleared when a tournement restart is done, allowing
+// all clients to begin playing instantly
+typedef struct {
+	gameState_t		gameState;			// gamestate from server
+	glconfig_t		glconfig;			// rendering configuration
+	float			screenXScale;		// derived from glconfig
+	float			screenYScale;
+	float			screenXBias;
+
+	int				serverCommandSequence;	// reliable command stream counter
+	int				processedSnapshotNum;// the number of snapshots cgame has requested
+
+	qboolean		localServer;		// detected on startup by checking sv_running
+
+	// parsed from serverinfo
+	int				siegeTeamSwitch;
+	int				showDuelHealths;
+	gametype_t		gametype;
+	int				debugMelee;
+	int				stepSlideFix;
+	int				noSpecMove;
+	int				dmflags;
+	int				teamflags;
+	int				fraglimit;
+	int				duel_fraglimit;
+	int				capturelimit;
+	int				timelimit;
+	int				maxclients;
+	qboolean		needpass;
+	qboolean		jediVmerc;
+	int				wDisable;
+	int				fDisable;
+
+	char			mapname[MAX_QPATH];
+	char			redTeam[MAX_QPATH];
+	char			blueTeam[MAX_QPATH];
+
+	int				voteTime;
+	int				voteYes;
+	int				voteNo;
+	qboolean		voteModified;			// beep whenever changed
+	char			voteString[MAX_STRING_TOKENS];
+
+	int				teamVoteTime[2];
+	int				teamVoteYes[2];
+	int				teamVoteNo[2];
+	qboolean		teamVoteModified[2];	// beep whenever changed
+	char			teamVoteString[2][MAX_STRING_TOKENS];
+
+	int				levelStartTime;
+
+	int				scores1, scores2;		// from configstrings
+	int				jediMaster;
+	int				duelWinner;
+	int				duelist1;
+	int				duelist2;
+	int				duelist3;
+// nmckenzie: DUEL_HEALTH.  hmm.
+	int				duelist1health;
+	int				duelist2health;
+	int				duelist3health;
+
+	int				redflag, blueflag;		// flag status from configstrings
+	int				flagStatus;
+
+	qboolean  newHud;
+
+	//
+	// locally derived information from gamestate
+	//
+	qhandle_t		gameModels[MAX_MODELS];
+	sfxHandle_t		gameSounds[MAX_SOUNDS];
+	fxHandle_t		gameEffects[MAX_FX];
+	qhandle_t		gameIcons[MAX_ICONS];
+
+	int				numInlineModels;
+	qhandle_t		inlineDrawModel[MAX_MODELS];
+	vec3_t			inlineModelMidpoints[MAX_MODELS];
+
+	clientInfo_t	clientinfo[MAX_CLIENTS];
+
+	int cursorX;
+	int cursorY;
+	qboolean eventHandling;
+	qboolean mouseCaptured;
+	qboolean sizingHud;
+	void *capturedItem;
+	qhandle_t activeCursor;
+
+	// media
+	cgMedia_t		media;
+
+	// effects
+	cgEffects_t		effects;
+
+} cgs_t;
+
+typedef struct siegeExtended_s
+{
+	int			health;
+	int			maxhealth;
+	int			ammo;
+	int			weapon;
+	int			lastUpdated;
+} siegeExtended_t;
+
+//keep an entry available for each client
+extern siegeExtended_t cg_siegeExtendedData[MAX_CLIENTS];
+
+//==============================================================================
+
+extern	cgs_t			cgs;
+extern	cg_t			cg;
+extern	centity_t		cg_entities[MAX_GENTITIES];
+
+extern	centity_t		*cg_permanents[MAX_GENTITIES];
+extern	int				cg_numpermanents;
+
+extern	weaponInfo_t	cg_weapons[MAX_WEAPONS];
+extern	itemInfo_t		cg_items[MAX_ITEMS];
+extern	markPoly_t		cg_markPolys[MAX_MARK_POLYS];
+
+extern	vmCvar_t		cg_centertime;
+extern	vmCvar_t		cg_runpitch;
+extern	vmCvar_t		cg_runroll;
+extern	vmCvar_t		cg_bobup;
+extern	vmCvar_t		cg_bobpitch;
+extern	vmCvar_t		cg_bobroll;
+//extern	vmCvar_t		cg_swingSpeed;
+extern	vmCvar_t		cg_shadows;
+extern	vmCvar_t		cg_renderToTextureFX;
+extern	vmCvar_t		cg_drawTimer;
+extern	vmCvar_t		cg_drawFPS;
+extern	vmCvar_t		cg_drawSnapshot;
+extern	vmCvar_t		cg_draw3dIcons;
+extern	vmCvar_t		cg_drawIcons;
+extern	vmCvar_t		cg_drawAmmoWarning;
+extern	vmCvar_t		cg_drawCrosshair;
+extern	vmCvar_t		cg_drawCrosshairNames;
+extern	vmCvar_t		cg_drawRadar;
+extern	vmCvar_t		cg_drawAutomap;
+extern	vmCvar_t		cg_drawScores;
+extern	vmCvar_t		cg_dynamicCrosshair;
+extern	vmCvar_t		cg_dynamicCrosshairPrecision;
+extern	vmCvar_t		cg_drawRewards;
+extern	vmCvar_t		cg_drawTeamOverlay;
+extern	vmCvar_t		cg_teamOverlayUserinfo;
+extern	vmCvar_t		cg_crosshairX;
+extern	vmCvar_t		cg_crosshairY;
+extern	vmCvar_t		cg_crosshairSize;
+extern	vmCvar_t		cg_crosshairHealth;
+extern	vmCvar_t		cg_drawStatus;
+extern	vmCvar_t		cg_draw2D;
+extern	vmCvar_t		cg_animSpeed;
+extern	vmCvar_t		cg_debugAnim;
+extern	vmCvar_t		cg_debugPosition;
+extern	vmCvar_t		cg_debugEvents;
+extern	vmCvar_t		cg_errorDecay;
+extern	vmCvar_t		cg_nopredict;
+extern	vmCvar_t		cg_noPlayerAnims;
+extern	vmCvar_t		cg_showmiss;
+extern	vmCvar_t		cg_showVehMiss;
+extern	vmCvar_t		cg_footsteps;
+extern	vmCvar_t		cg_addMarks;
+extern	vmCvar_t		cg_gun_frame;
+extern	vmCvar_t		cg_gun_x;
+extern	vmCvar_t		cg_gun_y;
+extern	vmCvar_t		cg_gun_z;
+extern	vmCvar_t		cg_drawGun;
+extern	vmCvar_t		cg_viewsize;
+extern	vmCvar_t		cg_autoswitch;
+extern	vmCvar_t		cg_ignore;
+extern	vmCvar_t		cg_simpleItems;
+extern	vmCvar_t		cg_fov;
+extern	vmCvar_t		cg_zoomFov;
+
+extern	vmCvar_t		cg_swingAngles;
+
+extern	vmCvar_t		cg_oldPainSounds;
+
+extern	vmCvar_t		cg_ragDoll;
+
+extern	vmCvar_t		cg_jumpSounds;
+
+extern	vmCvar_t		cg_autoMap;
+extern	vmCvar_t		cg_autoMapX;
+extern	vmCvar_t		cg_autoMapY;
+extern	vmCvar_t		cg_autoMapW;
+extern	vmCvar_t		cg_autoMapH;
+
+extern	vmCvar_t		bg_fighterAltControl;
+
+extern	vmCvar_t		cg_chatBox;
+extern	vmCvar_t		cg_chatBoxHeight;
+
+extern	vmCvar_t		cg_saberModelTraceEffect;
+
+extern	vmCvar_t		cg_saberClientVisualCompensation;
+
+extern	vmCvar_t		cg_g2TraceLod;
+
+extern	vmCvar_t		cg_fpls;
+
+extern	vmCvar_t		cg_ghoul2Marks;
+
+extern	vmCvar_t		cg_saberDynamicMarks;
+extern	vmCvar_t		cg_saberDynamicMarkTime;
+
+extern	vmCvar_t		cg_saberContact;
+extern	vmCvar_t		cg_saberTrail;
+
+extern	vmCvar_t		cg_duelHeadAngles;
+
+extern	vmCvar_t		cg_speedTrail;
+extern	vmCvar_t		cg_auraShell;
+
+extern	vmCvar_t		cg_repeaterOrb;
+
+extern	vmCvar_t		cg_animBlend;
+
+extern	vmCvar_t		cg_dismember;
+
+extern	vmCvar_t		cg_thirdPersonSpecialCam;
+
+extern	vmCvar_t		cg_thirdPerson;
+extern	vmCvar_t		cg_thirdPersonRange;
+extern	vmCvar_t		cg_thirdPersonAngle;
+extern	vmCvar_t		cg_thirdPersonPitchOffset;
+extern	vmCvar_t		cg_thirdPersonVertOffset;
+extern	vmCvar_t		cg_thirdPersonCameraDamp;
+extern	vmCvar_t		cg_thirdPersonTargetDamp;
+
+extern	vmCvar_t		cg_thirdPersonAlpha;
+extern	vmCvar_t		cg_thirdPersonHorzOffset;
+
+extern	vmCvar_t		cg_stereoSeparation;
+extern	vmCvar_t		cg_lagometer;
+extern	vmCvar_t		cg_drawEnemyInfo;
+extern	vmCvar_t		cg_synchronousClients;
+extern	vmCvar_t		cg_stats;
+extern	vmCvar_t 		cg_forceModel;
+extern	vmCvar_t 		cg_buildScript;
+extern	vmCvar_t		cg_paused;
+extern	vmCvar_t		cg_blood;
+extern	vmCvar_t		cg_predictItems;
+extern	vmCvar_t		cg_deferPlayers;
+extern	vmCvar_t		cg_drawFriend;
+extern	vmCvar_t		cg_teamChatsOnly;
+extern	vmCvar_t		cg_noVoiceChats;
+extern	vmCvar_t		cg_noVoiceText;
+extern  vmCvar_t		cg_scorePlum;
+extern	vmCvar_t		cg_hudFiles;
+extern	vmCvar_t		cg_smoothClients;
+
+#include "../namespace_begin.h"
+extern	vmCvar_t		pmove_fixed;
+extern	vmCvar_t		pmove_msec;
+#include "../namespace_end.h"
+
+//extern	vmCvar_t		cg_pmove_fixed;
+extern	vmCvar_t		cg_cameraOrbit;
+extern	vmCvar_t		cg_cameraOrbitDelay;
+extern	vmCvar_t		cg_timescaleFadeEnd;
+extern	vmCvar_t		cg_timescaleFadeSpeed;
+extern	vmCvar_t		cg_timescale;
+extern	vmCvar_t		cg_cameraMode;
+extern  vmCvar_t		cg_smallFont;
+extern  vmCvar_t		cg_bigFont;
+extern	vmCvar_t		cg_noTaunt;
+extern	vmCvar_t		cg_noProjectileTrail;
+extern	vmCvar_t		cg_trueLightning;
+
+extern	vmCvar_t		cg_redTeamName;
+extern	vmCvar_t		cg_blueTeamName;
+extern	vmCvar_t		cg_currentSelectedPlayer;
+extern	vmCvar_t		cg_currentSelectedPlayerName;
+extern	vmCvar_t		cg_singlePlayer;
+extern	vmCvar_t		cg_enableDust;
+extern	vmCvar_t		cg_enableBreath;
+extern	vmCvar_t		cg_singlePlayerActive;
+extern  vmCvar_t		cg_recordSPDemo;
+extern  vmCvar_t		cg_recordSPDemoName;
+
+extern	vmCvar_t		ui_myteam;
+extern  vmCvar_t		cg_snapshotTimeout;
+/*
+Ghoul2 Insert Start
+*/
+
+extern	vmCvar_t		cg_debugBB;
+
+/*
+Ghoul2 Insert End
+*/
+
+//
+// cg_main.c
+//
+void CG_DrawMiscEnts(void);
+
+const char *CG_ConfigString( int index );
+const char *CG_Argv( int arg );
+
+void QDECL CG_Printf( const char *msg, ... );
+void QDECL CG_Error( const char *msg, ... );
+
+void CG_StartMusic( qboolean bForceStart );
+
+void CG_UpdateCvars( void );
+
+int CG_CrosshairPlayer( void );
+int CG_LastAttacker( void );
+void CG_LoadMenus(const char *menuFile);
+void CG_KeyEvent(int key, qboolean down);
+void CG_MouseEvent(int x, int y);
+void CG_EventHandling(int type);
+void CG_RankRunFrame( void );
+void CG_SetScoreSelection(void *menu);
+void CG_BuildSpectatorString(void);
+void CG_NextInventory_f(void);
+void CG_PrevInventory_f(void);
+void CG_NextForcePower_f(void);
+void CG_PrevForcePower_f(void);
+
+//
+// cg_view.c
+//
+void CG_TestModel_f (void);
+void CG_TestGun_f (void);
+void CG_TestModelNextFrame_f (void);
+void CG_TestModelPrevFrame_f (void);
+void CG_TestModelNextSkin_f (void);
+void CG_TestModelPrevSkin_f (void);
+void CG_ZoomDown_f( void );
+void CG_ZoomUp_f( void );
+void CG_AddBufferedSound( sfxHandle_t sfx);
+
+void CG_DrawActiveFrame( int serverTime, stereoFrame_t stereoView, qboolean demoPlayback );
+/*
+Ghoul2 Insert Start
+*/
+
+void CG_TestG2Model_f (void);
+void CG_TestModelSurfaceOnOff_f(void);
+void CG_ListModelSurfaces_f (void);
+void CG_ListModelBones_f (void);
+void CG_TestModelSetAnglespre_f(void);
+void CG_TestModelSetAnglespost_f(void);
+void CG_TestModelAnimate_f(void);
+/*
+Ghoul2 Insert End
+*/
+
+//
+// cg_drawtools.c
+//
+void CG_FillRect( float x, float y, float width, float height, const float *color );
+void CG_DrawPic( float x, float y, float width, float height, qhandle_t hShader );
+void CG_DrawRotatePic( float x, float y, float width, float height,float angle, qhandle_t hShader );
+void CG_DrawRotatePic2( float x, float y, float width, float height,float angle, qhandle_t hShader );
+void CG_DrawString( float x, float y, const char *string, 
+				   float charWidth, float charHeight, const float *modulate );
+
+void CG_DrawNumField (int x, int y, int width, int value,int charWidth,int charHeight,int style,qboolean zeroFill);
+
+void CG_DrawStringExt( int x, int y, const char *string, const float *setColor, 
+		qboolean forceColor, qboolean shadow, int charWidth, int charHeight, int maxChars );
+void CG_DrawBigString( int x, int y, const char *s, float alpha );
+void CG_DrawBigStringColor( int x, int y, const char *s, vec4_t color );
+void CG_DrawSmallString( int x, int y, const char *s, float alpha );
+void CG_DrawSmallStringColor( int x, int y, const char *s, vec4_t color );
+
+int CG_DrawStrlen( const char *str );
+
+float	*CG_FadeColor( int startMsec, int totalMsec );
+float *CG_TeamColor( int team );
+void CG_TileClear( void );
+void CG_ColorForHealth( vec4_t hcolor );
+void CG_GetColorForHealth( int health, int armor, vec4_t hcolor );
+
+void UI_DrawProportionalString( int x, int y, const char* str, int style, vec4_t color );
+void UI_DrawScaledProportionalString( int x, int y, const char* str, int style, vec4_t color, float scale);
+void CG_DrawRect( float x, float y, float width, float height, float size, const float *color );
+void CG_DrawSides(float x, float y, float w, float h, float size);
+void CG_DrawTopBottom(float x, float y, float w, float h, float size);
+
+//
+// cg_draw.c, cg_newDraw.c
+//
+extern	int sortedTeamPlayers[TEAM_MAXOVERLAY];
+extern	int	numSortedTeamPlayers;
+extern  char systemChat[256];
+
+void CG_AddLagometerFrameInfo( void );
+void CG_AddLagometerSnapshotInfo( snapshot_t *snap );
+void CG_CenterPrint( const char *str, int y, int charWidth );
+void CG_DrawHead( float x, float y, float w, float h, int clientNum, vec3_t headAngles );
+void CG_DrawActive( stereoFrame_t stereoView );
+void CG_DrawFlagModel( float x, float y, float w, float h, int team, qboolean force2D );
+void CG_DrawTeamBackground( int x, int y, int w, int h, float alpha, int team );
+void CG_OwnerDraw(float x, float y, float w, float h, float text_x, float text_y, int ownerDraw, int ownerDrawFlags, int align, float special, float scale, vec4_t color, qhandle_t shader, int textStyle,int font);
+void CG_Text_Paint(float x, float y, float scale, vec4_t color, const char *text, float adjust, int limit, int style, int iMenuFont);
+int CG_Text_Width(const char *text, float scale, int iMenuFont);
+int CG_Text_Height(const char *text, float scale, int iMenuFont);
+float CG_GetValue(int ownerDraw);
+qboolean CG_OwnerDrawVisible(int flags);
+void CG_RunMenuScript(char **args);
+qboolean CG_DeferMenuScript(char **args);
+void CG_ShowResponseHead(void);
+void CG_GetTeamColor(vec4_t *color);
+const char *CG_GetGameStatusText(void);
+const char *CG_GetKillerText(void);
+void CG_Draw3DModel( float x, float y, float w, float h, qhandle_t model, void *ghoul2, int g2radius, qhandle_t skin, vec3_t origin, vec3_t angles );
+void CG_Text_PaintChar(float x, float y, float width, float height, float scale, float s, float t, float s2, float t2, qhandle_t hShader);
+const char *CG_GameTypeString(void);
+qboolean CG_YourTeamHasFlag(void);
+qboolean CG_OtherTeamHasFlag(void);
+qhandle_t CG_StatusHandle(int task);
+
+
+
+//
+// cg_player.c
+//
+qboolean CG_RagDoll(centity_t *cent, vec3_t forcedAngles);
+qboolean CG_G2TraceCollide(trace_t *tr, const vec3_t mins, const vec3_t maxs, const vec3_t lastValidStart, const vec3_t lastValidEnd);
+void CG_AddGhoul2Mark(int shader, float size, vec3_t start, vec3_t end, int entnum,
+					  vec3_t entposition, float entangle, void *ghoul2, vec3_t scale, int lifeTime);
+
+void CG_CreateNPCClient(clientInfo_t **ci);
+void CG_DestroyNPCClient(clientInfo_t **ci);
+
+void CG_Player( centity_t *cent );
+void CG_ResetPlayerEntity( centity_t *cent );
+void CG_AddRefEntityWithPowerups( refEntity_t *ent, entityState_t *state, int team );
+void CG_NewClientInfo( int clientNum, qboolean entitiesInitialized );
+sfxHandle_t	CG_CustomSound( int clientNum, const char *soundName );
+void CG_PlayerShieldHit(int entitynum, vec3_t angles, int amount);
+
+
+//
+// cg_predict.c
+//
+void CG_BuildSolidList( void );
+int	CG_PointContents( const vec3_t point, int passEntityNum );
+void CG_Trace( trace_t *result, const vec3_t start, const vec3_t mins, const vec3_t maxs, const vec3_t end, 
+					 int skipNumber, int mask );
+void CG_G2Trace( trace_t *result, const vec3_t start, const vec3_t mins, const vec3_t maxs, const vec3_t end, 
+					 int skipNumber, int mask );
+void CG_PredictPlayerState( void );
+void CG_LoadDeferredPlayers( void );
+
+
+//
+// cg_events.c
+//
+void CG_CheckEvents( centity_t *cent );
+const char	*CG_PlaceString( int rank );
+void CG_EntityEvent( centity_t *cent, vec3_t position );
+void CG_PainEvent( centity_t *cent, int health );
+void CG_ReattachLimb(centity_t *source);
+
+
+//
+// cg_ents.c
+//
+
+void CG_S_AddLoopingSound(int entityNum, const vec3_t origin, const vec3_t velocity, sfxHandle_t sfx);
+void CG_S_AddRealLoopingSound(int entityNum, const vec3_t origin, const vec3_t velocity, sfxHandle_t sfx);
+void CG_S_StopLoopingSound(int entityNum, sfxHandle_t sfx);
+void CG_S_UpdateLoopingSounds(int entityNum);
+
+void CG_SetEntitySoundPosition( centity_t *cent );
+void CG_AddPacketEntities( qboolean isPortal );
+void CG_ManualEntityRender(centity_t *cent);
+void CG_Beam( centity_t *cent );
+void CG_AdjustPositionForMover( const vec3_t in, int moverNum, int fromTime, int toTime, vec3_t out );
+
+void CG_PositionEntityOnTag( refEntity_t *entity, const refEntity_t *parent, 
+							qhandle_t parentModel, char *tagName );
+void CG_PositionRotatedEntityOnTag( refEntity_t *entity, const refEntity_t *parent, 
+							qhandle_t parentModel, char *tagName );
+
+/*
+Ghoul2 Insert Start
+*/
+void ScaleModelAxis(refEntity_t	*ent);
+/*
+Ghoul2 Insert End
+*/
+
+//
+// cg_turret.c
+//
+void TurretClientRun(centity_t *ent);
+
+//
+// cg_weapons.c
+//
+void CG_GetClientWeaponMuzzleBoltPoint(int clIndex, vec3_t to);
+
+void CG_NextWeapon_f( void );
+void CG_PrevWeapon_f( void );
+void CG_Weapon_f( void );
+void CG_WeaponClean_f( void );
+
+void CG_RegisterWeapon( int weaponNum);
+void CG_RegisterItemVisuals( int itemNum );
+
+void CG_FireWeapon( centity_t *cent, qboolean alt_fire );
+void CG_MissileHitWall(int weapon, int clientNum, vec3_t origin, vec3_t dir, impactSound_t soundType, qboolean alt_fire, int charge);
+void CG_MissileHitPlayer( int weapon, vec3_t origin, vec3_t dir, int entityNum, qboolean alt_fire);
+
+void CG_AddViewWeapon (playerState_t *ps);
+void CG_AddPlayerWeapon( refEntity_t *parent, playerState_t *ps, centity_t *cent, int team, vec3_t newAngles, qboolean thirdPerson );
+void CG_DrawWeaponSelect( void );
+void CG_DrawIconBackground(void);
+
+void CG_OutOfAmmoChange( int oldWeapon );	// should this be in pmove?
+
+//
+// cg_marks.c
+//
+void	CG_InitMarkPolys( void );
+void	CG_AddMarks( void );
+void	CG_ImpactMark( qhandle_t markShader, 
+				    const vec3_t origin, const vec3_t dir, 
+					float orientation, 
+				    float r, float g, float b, float a, 
+					qboolean alphaFade, 
+					float radius, qboolean temporary );
+
+//
+// cg_localents.c
+//
+void	CG_InitLocalEntities( void );
+localEntity_t	*CG_AllocLocalEntity( void );
+void	CG_AddLocalEntities( void );
+
+//
+// cg_effects.c
+//
+localEntity_t *CG_SmokePuff( const vec3_t p, 
+				   const vec3_t vel, 
+				   float radius,
+				   float r, float g, float b, float a,
+				   float duration,
+				   int startTime,
+				   int fadeInTime,
+				   int leFlags,
+				   qhandle_t hShader );
+void CG_BubbleTrail( vec3_t start, vec3_t end, float spacing );
+void CG_GlassShatter(int entnum, vec3_t dmgPt, vec3_t dmgDir, float dmgRadius, int maxShards);
+void CG_ScorePlum( int client, vec3_t org, int score );
+
+void CG_Chunks( int owner, vec3_t origin, const vec3_t normal, const vec3_t mins, const vec3_t maxs, 
+						float speed, int numChunks, material_t chunkType, int customChunk, float baseScale );
+void CG_MiscModelExplosion( vec3_t mins, vec3_t maxs, int size, material_t chunkType );
+
+void CG_Bleed( vec3_t origin, int entityNum );
+
+localEntity_t *CG_MakeExplosion( vec3_t origin, vec3_t dir, 
+								qhandle_t hModel, int numframes, qhandle_t shader, int msec,
+								qboolean isSprite, float scale, int flags );// Overloaded in single player
+
+void CG_SurfaceExplosion( vec3_t origin, vec3_t normal, float radius, float shake_speed, qboolean smoke );
+
+void CG_TestLine( vec3_t start, vec3_t end, int time, unsigned int color, int radius);
+
+void CG_InitGlass( void );
+
+//
+// cg_snapshot.c
+//
+void CG_ProcessSnapshots( void );
+
+//
+// cg_info.c
+//
+void CG_LoadingString( const char *s );
+void CG_LoadingItem( int itemNum );
+void CG_LoadingClient( int clientNum );
+void CG_DrawInformation( void );
+
+//
+// cg_scoreboard.c
+//
+qboolean CG_DrawOldScoreboard( void );
+void CG_DrawOldTourneyScoreboard( void );
+
+//
+// cg_consolecmds.c
+//
+qboolean CG_ConsoleCommand( void );
+void CG_InitConsoleCommands( void );
+
+//
+// cg_servercmds.c
+//
+void CG_ExecuteNewServerCommands( int latestSequence );
+void CG_ParseServerinfo( void );
+void CG_SetConfigValues( void );
+void CG_ShaderStateChanged(void);
+
+//
+// cg_playerstate.c
+//
+int CG_IsMindTricked(int trickIndex1, int trickIndex2, int trickIndex3, int trickIndex4, int client);
+void CG_Respawn( void );
+void CG_TransitionPlayerState( playerState_t *ps, playerState_t *ops );
+void CG_CheckChangedPredictableEvents( playerState_t *ps );
+
+
+//
+// cg_siege.c
+//
+void CG_InitSiegeMode(void);
+void CG_SiegeRoundOver(centity_t *ent, int won);
+void CG_SiegeObjectiveCompleted(centity_t *ent, int won, int objectivenum);
+
+
+
+//===============================================
+
+//
+// system traps
+// These functions are how the cgame communicates with the main game system
+//
+
+#include "../namespace_begin.h"
+
+// print message on the local console
+void		trap_Print( const char *fmt );
+
+// abort the game
+void		trap_Error( const char *fmt );
+
+// milliseconds should only be used for performance tuning, never
+// for anything game related.  Get time from the CG_DrawActiveFrame parameter
+int			trap_Milliseconds( void );
+
+//rww - precision timer funcs... -ALWAYS- call end after start with supplied ptr, or you'll get a nasty memory leak.
+//not that you should be using these outside of debug anyway.. because you shouldn't be. So don't.
+void		trap_PrecisionTimer_Start(void **theNewTimer);
+int			trap_PrecisionTimer_End(void *theTimer);
+
+// console variable interaction
+void		trap_Cvar_Register( vmCvar_t *vmCvar, const char *varName, const char *defaultValue, int flags );
+void		trap_Cvar_Update( vmCvar_t *vmCvar );
+void		trap_Cvar_Set( const char *var_name, const char *value );
+void		trap_Cvar_VariableStringBuffer( const char *var_name, char *buffer, int bufsize );
+int			trap_Cvar_GetHiddenVarValue(const char *name);
+
+// ServerCommand and ConsoleCommand parameter access
+int			trap_Argc( void );
+void		trap_Argv( int n, char *buffer, int bufferLength );
+void		trap_Args( char *buffer, int bufferLength );
+
+// filesystem access
+// returns length of file
+int			trap_FS_FOpenFile( const char *qpath, fileHandle_t *f, fsMode_t mode );
+void		trap_FS_Read( void *buffer, int len, fileHandle_t f );
+void		trap_FS_Write( const void *buffer, int len, fileHandle_t f );
+void		trap_FS_FCloseFile( fileHandle_t f );
+int			trap_FS_GetFileList(  const char *path, const char *extension, char *listbuf, int bufsize );
+
+// add commands to the local console as if they were typed in
+// for map changing, etc.  The command is not executed immediately,
+// but will be executed in order the next time console commands
+// are processed
+void		trap_SendConsoleCommand( const char *text );
+
+// register a command name so the console can perform command completion.
+// FIXME: replace this with a normal console command "defineCommand"?
+void		trap_AddCommand( const char *cmdName );
+
+// send a string to the server over the network
+void		trap_SendClientCommand( const char *s );
+
+// force a screen update, only used during gamestate load
+void		trap_UpdateScreen( void );
+
+// model collision
+void		trap_CM_LoadMap( const char *mapname, qboolean SubBSP );
+int			trap_CM_NumInlineModels( void );
+clipHandle_t trap_CM_InlineModel( int index );		// 0 = world, 1+ = bmodels
+clipHandle_t trap_CM_TempBoxModel( const vec3_t mins, const vec3_t maxs );
+int			trap_CM_PointContents( const vec3_t p, clipHandle_t model );
+int			trap_CM_TransformedPointContents( const vec3_t p, clipHandle_t model, const vec3_t origin, const vec3_t angles );
+void		trap_CM_BoxTrace( trace_t *results, const vec3_t start, const vec3_t end,
+					  const vec3_t mins, const vec3_t maxs,
+					  clipHandle_t model, int brushmask );
+void		trap_CM_TransformedBoxTrace( trace_t *results, const vec3_t start, const vec3_t end,
+					  const vec3_t mins, const vec3_t maxs,
+					  clipHandle_t model, int brushmask,
+					  const vec3_t origin, const vec3_t angles );
+
+// Returns the projection of a polygon onto the solid brushes in the world
+int			trap_CM_MarkFragments( int numPoints, const vec3_t *points, 
+			const vec3_t projection,
+			int maxPoints, vec3_t pointBuffer,
+			int maxFragments, markFragment_t *fragmentBuffer );
+
+// normal sounds will have their volume dynamically changed as their entity
+// moves and the listener moves
+int			trap_S_GetVoiceVolume( int entityNum );
+void		trap_S_MuteSound( int entityNum, int entchannel );
+void		trap_S_StartSound( vec3_t origin, int entityNum, int entchannel, sfxHandle_t sfx );
+void		trap_S_StopLoopingSound(int entnum);
+
+// a local sound is always played full volume
+void		trap_S_StartLocalSound( sfxHandle_t sfx, int channelNum );
+void		trap_S_ClearLoopingSounds( void );
+void		trap_S_AddLoopingSound( int entityNum, const vec3_t origin, const vec3_t velocity, sfxHandle_t sfx );
+void		trap_S_AddRealLoopingSound( int entityNum, const vec3_t origin, const vec3_t velocity, sfxHandle_t sfx );
+void		trap_S_UpdateEntityPosition( int entityNum, const vec3_t origin );
+
+// repatialize recalculates the volumes of sound as they should be heard by the
+// given entityNum and position
+void		trap_S_Respatialize( int entityNum, const vec3_t origin, vec3_t axis[3], int inwater );
+void		trap_S_ShutUp(qboolean shutUpFactor);
+sfxHandle_t	trap_S_RegisterSound( const char *sample);		// returns buzz if not found
+void		trap_S_StartBackgroundTrack( const char *intro, const char *loop, qboolean bReturnWithoutStarting);	// empty name stops music
+void	trap_S_StopBackgroundTrack( void );
+
+void		trap_S_UpdateAmbientSet( const char *name, vec3_t origin );
+void		trap_AS_ParseSets( void );
+void		trap_AS_AddPrecacheEntry( const char *name );
+int			trap_S_AddLocalSet( const char *name, vec3_t listener_origin, vec3_t origin, int entID, int time );
+sfxHandle_t	trap_AS_GetBModelSound( const char *name, int stage );
+
+void		trap_R_LoadWorldMap( const char *mapname );
+
+// all media should be registered during level startup to prevent
+// hitches during gameplay
+qhandle_t	trap_R_RegisterModel( const char *name );			// returns rgb axis if not found
+qhandle_t	trap_R_RegisterSkin( const char *name );			// returns all white if not found
+qhandle_t	trap_R_RegisterShader( const char *name );			// returns all white if not found
+qhandle_t	trap_R_RegisterShaderNoMip( const char *name );			// returns all white if not found
+qhandle_t	trap_R_RegisterFont( const char *name );
+int			trap_R_Font_StrLenPixels(const char *text, const int iFontIndex, const float scale);
+int			trap_R_Font_StrLenChars(const char *text);
+int			trap_R_Font_HeightPixels(const int iFontIndex, const float scale);
+void		trap_R_Font_DrawString(int ox, int oy, const char *text, const float *rgba, const int setIndex, int iCharLimit, const float scale);
+qboolean	trap_Language_IsAsian(void);
+qboolean	trap_Language_UsesSpaces(void);
+unsigned	trap_AnyLanguage_ReadCharFromString( const char *psText, int *piAdvanceCount, qboolean *pbIsTrailingPunctuation/* = NULL*/ );
+
+
+// a scene is built up by calls to R_ClearScene and the various R_Add functions.
+// Nothing is drawn until R_RenderScene is called.
+void		trap_R_ClearScene( void );
+void		trap_R_ClearDecals ( void );
+void		trap_R_AddRefEntityToScene( const refEntity_t *re );
+
+// polys are intended for simple wall marks, not really for doing
+// significant construction
+void		trap_R_AddPolyToScene( qhandle_t hShader , int numVerts, const polyVert_t *verts );
+void		trap_R_AddPolysToScene( qhandle_t hShader , int numVerts, const polyVert_t *verts, int numPolys );
+void		trap_R_AddDecalToScene ( qhandle_t shader, const vec3_t origin, const vec3_t dir, float orientation, float r, float g, float b, float a, qboolean alphaFade, float radius, qboolean temporary );
+void		trap_R_AddLightToScene( const vec3_t org, float intensity, float r, float g, float b );
+int			trap_R_LightForPoint( vec3_t point, vec3_t ambientLight, vec3_t directedLight, vec3_t lightDir );
+void		trap_R_RenderScene( const refdef_t *fd );
+void		trap_R_SetColor( const float *rgba );	// NULL = 1,1,1,1
+void		trap_R_DrawStretchPic( float x, float y, float w, float h, 
+			float s1, float t1, float s2, float t2, qhandle_t hShader );
+void		trap_R_ModelBounds( clipHandle_t model, vec3_t mins, vec3_t maxs );
+int			trap_R_LerpTag( orientation_t *tag, clipHandle_t mod, int startFrame, int endFrame, 
+					   float frac, const char *tagName );
+// Does weird, barely controllable rotation behaviour
+void	trap_R_DrawRotatePic( float x, float y, float w, float h, 
+			float s1, float t1, float s2, float t2,float a, qhandle_t hShader );
+// rotates image around exact center point of passed in coords
+void	trap_R_DrawRotatePic2( float x, float y, float w, float h, 
+			float s1, float t1, float s2, float t2,float a, qhandle_t hShader );
+
+void		trap_R_SetRangeFog(float range);
+
+void		trap_R_SetRefractProp(float alpha, float stretch, qboolean prepost, qboolean negate);
+
+void		trap_R_RemapShader( const char *oldShader, const char *newShader, const char *timeOffset );
+
+void		trap_R_GetLightStyle(int style, color4ub_t color);
+void		trap_R_SetLightStyle(int style, int color);
+
+void		trap_R_GetBModelVerts(int bmodelIndex, vec3_t *verts, vec3_t normal );
+
+void		trap_R_GetDistanceCull(float *f);
+
+void		trap_R_GetRealRes(int *w, int *h); //get screen resolution -rww
+void		trap_R_AutomapElevAdj(float newHeight); //automap elevation setting -rww
+qboolean	trap_R_InitWireframeAutomap(void); //initialize automap -rww
+
+
+void	trap_FX_AddLine( const vec3_t start, const vec3_t end, float size1, float size2, float sizeParm,
+									float alpha1, float alpha2, float alphaParm,
+									const vec3_t sRGB, const vec3_t eRGB, float rgbParm,
+									int killTime, qhandle_t shader, int flags);
+
+// The glconfig_t will not change during the life of a cgame.
+// If it needs to change, the entire cgame will be restarted, because
+// all the qhandle_t are then invalid.
+void		trap_GetGlconfig( glconfig_t *glconfig );
+
+// the gamestate should be grabbed at startup, and whenever a
+// configstring changes
+void		trap_GetGameState( gameState_t *gamestate );
+
+// cgame will poll each frame to see if a newer snapshot has arrived
+// that it is interested in.  The time is returned seperately so that
+// snapshot latency can be calculated.
+void		trap_GetCurrentSnapshotNumber( int *snapshotNumber, int *serverTime );
+
+// a snapshot get can fail if the snapshot (or the entties it holds) is so
+// old that it has fallen out of the client system queue
+qboolean	trap_GetSnapshot( int snapshotNumber, snapshot_t *snapshot );
+
+
+qboolean	trap_GetDefaultState(int entityIndex, entityState_t *state );
+
+// retrieve a text command from the server stream
+// the current snapshot will hold the number of the most recent command
+// qfalse can be returned if the client system handled the command
+// argc() / argv() can be used to examine the parameters of the command
+qboolean	trap_GetServerCommand( int serverCommandNumber );
+
+// returns the most recent command number that can be passed to GetUserCmd
+// this will always be at least one higher than the number in the current
+// snapshot, and it may be quite a few higher if it is a fast computer on
+// a lagged connection
+int			trap_GetCurrentCmdNumber( void );	
+
+qboolean	trap_GetUserCmd( int cmdNumber, usercmd_t *ucmd );
+
+// used for the weapon select and zoom
+void		trap_SetUserCmdValue( int stateValue, float sensitivityScale, float mPitchOverride, float mYawOverride, float mSensitivityOverride, int fpSel, int invenSel, qboolean fighterControls );
+
+void		trap_SetClientForceAngle(int time, vec3_t angle);
+void		trap_SetClientTurnExtent(float turnAdd, float turnSub, int turnTime);
+
+void trap_OpenUIMenu(int menuID);
+
+// aids for VM testing
+void		testPrintInt( char *string, int i );
+void		testPrintFloat( char *string, float f );
+
+int			trap_MemoryRemaining( void );
+qboolean	trap_Key_IsDown( int keynum );
+int			trap_Key_GetCatcher( void );
+void		trap_Key_SetCatcher( int catcher );
+int			trap_Key_GetKey( const char *binding );
+
+void		BG_CycleInven(playerState_t *ps, int direction);
+int			BG_ProperForceIndex(int power);
+void		BG_CycleForce(playerState_t *ps, int direction);
+
+#include "../namespace_end.h"
+
+
+typedef enum {
+  SYSTEM_PRINT,
+  CHAT_PRINT,
+  TEAMCHAT_PRINT
+} q3print_t; // bk001201 - warning: useless keyword or type name in empty declaration
+
+#include "../namespace_begin.h"
+
+int trap_CIN_PlayCinematic( const char *arg0, int xpos, int ypos, int width, int height, int bits);
+e_status trap_CIN_StopCinematic(int handle);
+e_status trap_CIN_RunCinematic (int handle);
+void trap_CIN_DrawCinematic (int handle);
+void trap_CIN_SetExtents (int handle, int x, int y, int w, int h);
+
+void trap_SnapVector( float *v );
+
+qboolean	trap_loadCamera(const char *name);
+void		trap_startCamera(int time);
+qboolean	trap_getCameraInfo(int time, vec3_t *origin, vec3_t *angles);
+
+qboolean	trap_GetEntityToken( char *buffer, int bufferSize );
+qboolean	trap_R_inPVS( const vec3_t p1, const vec3_t p2, byte *mask );
+
+int			trap_FX_InitSystem			( refdef_t* );
+void		trap_FX_SetRefDef			( refdef_t* refdef );
+int			trap_FX_RegisterEffect		( const char *file);
+void		trap_FX_PlayEffect			( const char *file, vec3_t org, vec3_t fwd, int vol, int rad );		// builds arbitrary perp. right vector, does a cross product to define up
+void		trap_FX_PlayEntityEffect	( const char *file, vec3_t org, vec3_t axis[3], const int boltInfo, const int entNum, int vol, int rad );
+void		trap_FX_PlayEffectID		( int id, vec3_t org, vec3_t fwd, int vol, int rad );		// builds arbitrary perp. right vector, does a cross product to define up
+void		trap_FX_PlayPortalEffectID	( int id, vec3_t org, vec3_t fwd, int vol, int rad );		// builds arbitrary perp. right vector, does a cross product to define up
+void		trap_FX_PlayEntityEffectID	( int id, vec3_t org, vec3_t axis[3], const int boltInfo, const int pGhoul2, int vol, int rad );
+void		trap_FX_PlayBoltedEffectID	( int id, vec3_t org, void *pGhoul2, const int boltNum, const int entNum, const int modelNum, int iLooptime, qboolean isRelative );
+void		trap_FX_AddScheduledEffects	( qboolean skyPortal );
+void		trap_FX_Draw2DEffects		( float screenXScale, float screenYScale );
+qboolean	trap_FX_FreeSystem			( void );
+void		trap_FX_AdjustTime			( int time );
+void		trap_FX_Reset				( void );
+
+//rww - additional funcs for adding custom incode stuff
+void trap_FX_AddPoly( addpolyArgStruct_t *p );
+void trap_FX_AddBezier( addbezierArgStruct_t *p );
+void trap_FX_AddPrimitive( effectTrailArgStruct_t *p );
+void trap_FX_AddSprite( addspriteArgStruct_t *p );
+void trap_FX_AddElectricity( addElectricityArgStruct_t *p );
+
+//void trap_SP_Print(const unsigned ID, byte *Data);
+int trap_SP_GetStringTextString(const char *text, char *buffer, int bufferLength);
+
+void		trap_CG_RegisterSharedMemory(char *memory);
+
+int			trap_CM_RegisterTerrain(const char *config);
+void		trap_RMG_Init(int terrainID, const char *terrainInfo);
+void		trap_RE_InitRendererTerrain( const char *info );
+void		trap_R_WeatherContentsOverride( int contents );
+void		trap_R_WorldEffectCommand(const char *cmd);
+void		trap_WE_AddWeatherZone( const vec3_t mins, const vec3_t maxs );
+
+qboolean	trap_ROFF_Clean( void );
+void		trap_ROFF_UpdateEntities( void );
+	int			trap_ROFF_Cache( char *file );
+qboolean	trap_ROFF_Play( int entID, int roffID, qboolean doTranslation );
+qboolean	trap_ROFF_Purge_Ent( int entID );
+
+//rww - dynamic vm memory allocation!
+void	trap_TrueMalloc(void **ptr, int size);
+void	trap_TrueFree(void **ptr);
+
+#include "../namespace_end.h"
+
+void	CG_ClearParticles (void);
+void	CG_AddParticles (void);
+void	CG_ParticleSnow (qhandle_t pshader, vec3_t origin, vec3_t origin2, int turb, float range, int snum);
+void	CG_ParticleSmoke (qhandle_t pshader, centity_t *cent);
+void	CG_AddParticleShrapnel (localEntity_t *le);
+void	CG_ParticleSnowFlurry (qhandle_t pshader, centity_t *cent);
+void	CG_ParticleBulletDebris (vec3_t	org, vec3_t vel, int duration);
+void	CG_ParticleSparks (vec3_t org, vec3_t vel, int duration, float x, float y, float speed);
+void	CG_ParticleDust (centity_t *cent, vec3_t origin, vec3_t dir);
+void	CG_ParticleMisc (qhandle_t pshader, vec3_t origin, int size, int duration, float alpha);
+void	CG_ParticleExplosion (char *animStr, vec3_t origin, vec3_t vel, int duration, int sizeStart, int sizeEnd);
+const char *CG_GetStringEdString(char *refSection, char *refName);
+extern qboolean		initparticles;
+int CG_NewParticleArea ( int num );
+
+void FX_TurretProjectileThink(  centity_t *cent, const struct weaponInfo_s *weapon );
+void FX_TurretHitWall( vec3_t origin, vec3_t normal );
+void FX_TurretHitPlayer( vec3_t origin, vec3_t normal, qboolean humanoid );
+
+void FX_ConcussionHitWall( vec3_t origin, vec3_t normal );
+void FX_ConcussionHitPlayer( vec3_t origin, vec3_t normal, qboolean humanoid );
+void FX_ConcussionProjectileThink(  centity_t *cent, const struct weaponInfo_s *weapon );
+void FX_ConcAltShot( vec3_t start, vec3_t end );
+
+//-----------------------------
+// Effects related prototypes
+//-----------------------------
+
+// Environmental effects 
+void CG_Spark( vec3_t origin, vec3_t dir );
+
+// Weapon prototypes
+void FX_BryarHitWall( vec3_t origin, vec3_t normal );
+void FX_BryarAltHitWall( vec3_t origin, vec3_t normal, int power );
+void FX_BryarHitPlayer( vec3_t origin, vec3_t normal, qboolean humanoid );
+void FX_BryarAltHitPlayer( vec3_t origin, vec3_t normal, qboolean humanoid );
+
+void FX_BlasterProjectileThink( centity_t *cent, const struct weaponInfo_s *weapon );
+void FX_BlasterAltFireThink( centity_t *cent, const struct weaponInfo_s *weapon );
+void FX_BlasterWeaponHitWall( vec3_t origin, vec3_t normal );
+void FX_BlasterWeaponHitPlayer( vec3_t origin, vec3_t normal, qboolean humanoid );
+
+
+void FX_ForceDrained(vec3_t origin, vec3_t dir);
+
+
+//-----------------------------
+// Effects related prototypes
+//-----------------------------
+
+// Environmental effects 
+void CG_Spark( vec3_t origin, vec3_t dir );
+
+// Weapon prototypes
+void FX_BryarHitWall( vec3_t origin, vec3_t normal );
+void FX_BryarAltHitWall( vec3_t origin, vec3_t normal, int power );
+void FX_BryarHitPlayer( vec3_t origin, vec3_t normal, qboolean humanoid );
+void FX_BryarAltHitPlayer( vec3_t origin, vec3_t normal, qboolean humanoid );
+
+void FX_BlasterProjectileThink( centity_t *cent, const struct weaponInfo_s *weapon );
+void FX_BlasterAltFireThink( centity_t *cent, const struct weaponInfo_s *weapon );
+void FX_BlasterWeaponHitWall( vec3_t origin, vec3_t normal );
+void FX_BlasterWeaponHitPlayer( vec3_t origin, vec3_t normal, qboolean humanoid );
+
+#include "../namespace_begin.h"
+
+void		trap_G2API_CollisionDetect		( CollisionRecord_t *collRecMap, void* ghoul2, const vec3_t angles, const vec3_t position,int frameNumber, int entNum, const vec3_t rayStart, const vec3_t rayEnd, const vec3_t scale, int traceFlags, int useLod, float fRadius );
+
+/*
+Ghoul2 Insert Start
+*/
+// CG specific API access
+void		trap_G2_ListModelSurfaces(void *ghlInfo);
+void		trap_G2_ListModelBones(void *ghlInfo, int frame);
+void		trap_G2_SetGhoul2ModelIndexes(void *ghoul2, qhandle_t *modelList, qhandle_t *skinList);
+qboolean	trap_G2_HaveWeGhoul2Models(void *ghoul2);
+qboolean	trap_G2API_GetBoltMatrix(void *ghoul2, const int modelIndex, const int boltIndex, mdxaBone_t *matrix,
+								const vec3_t angles, const vec3_t position, const int frameNum, qhandle_t *modelList, vec3_t scale);
+qboolean	trap_G2API_GetBoltMatrix_NoReconstruct(void *ghoul2, const int modelIndex, const int boltIndex, mdxaBone_t *matrix,
+								const vec3_t angles, const vec3_t position, const int frameNum, qhandle_t *modelList, vec3_t scale);
+qboolean	trap_G2API_GetBoltMatrix_NoRecNoRot(void *ghoul2, const int modelIndex, const int boltIndex, mdxaBone_t *matrix,
+								const vec3_t angles, const vec3_t position, const int frameNum, qhandle_t *modelList, vec3_t scale);
+int			trap_G2API_InitGhoul2Model(void **ghoul2Ptr, const char *fileName, int modelIndex, qhandle_t customSkin,
+						  qhandle_t customShader, int modelFlags, int lodBias);
+qboolean	trap_G2API_SetSkin(void *ghoul2, int modelIndex, qhandle_t customSkin, qhandle_t renderSkin);
+
+int			trap_G2API_CopyGhoul2Instance(void *g2From, void *g2To, int modelIndex);
+void		trap_G2API_CopySpecificGhoul2Model(void *g2From, int modelFrom, void *g2To, int modelTo);
+void		trap_G2API_DuplicateGhoul2Instance(void *g2From, void **g2To);
+qboolean	trap_G2API_HasGhoul2ModelOnIndex(void *ghlInfo, int modelIndex);
+qboolean	trap_G2API_RemoveGhoul2Model(void *ghlInfo, int modelIndex);
+
+qboolean	trap_G2API_SkinlessModel(void *ghlInfo, int modelIndex);
+
+//rww - for adding gore (or whatever) shaders to the g2 model
+int			trap_G2API_GetNumGoreMarks(void *ghlInfo, int modelIndex);
+void		trap_G2API_AddSkinGore(void *ghlInfo,SSkinGoreData *gore);
+void		trap_G2API_ClearSkinGore ( void* ghlInfo );
+
+int			trap_G2API_Ghoul2Size ( void* ghlInfo );
+
+int			trap_G2API_AddBolt(void *ghoul2, int modelIndex, const char *boneName);
+void		trap_G2API_SetBoltInfo(void *ghoul2, int modelIndex, int boltInfo);
+qboolean	trap_G2API_AttachEnt(int *boltInfo, void *ghlInfoTo, int toBoltIndex, int entNum, int toModelNum);
+
+void		trap_G2API_CleanGhoul2Models(void **ghoul2Ptr);
+qboolean	trap_G2API_SetBoneAngles(void *ghoul2, int modelIndex, const char *boneName, const vec3_t angles, const int flags,
+								const int up, const int right, const int forward, qhandle_t *modelList,
+								int blendTime , int currentTime );
+void		trap_G2API_GetGLAName(void *ghoul2, int modelIndex, char *fillBuf);
+qboolean	trap_G2API_SetBoneAnim(void *ghoul2, const int modelIndex, const char *boneName, const int startFrame, const int endFrame,
+							  const int flags, const float animSpeed, const int currentTime, const float setFrame , const int blendTime );
+qboolean	trap_G2API_GetBoneAnim(void *ghoul2, const char *boneName, const int currentTime, float *currentFrame, int *startFrame,
+								int *endFrame, int *flags, float *animSpeed, int *modelList, const int modelIndex);
+qboolean	trap_G2API_GetBoneFrame(void *ghoul2, const char *boneName, const int currentTime, float *currentFrame, int *modelList, const int modelIndex);
+
+qboolean	trap_G2API_SetRootSurface(void *ghoul2, const int modelIndex, const char *surfaceName);
+qboolean	trap_G2API_SetSurfaceOnOff(void *ghoul2, const char *surfaceName, const int flags);
+qboolean	trap_G2API_SetNewOrigin(void *ghoul2, const int boltIndex);
+qboolean	trap_G2API_DoesBoneExist(void *ghoul2, int modelIndex, const char *boneName);
+int			trap_G2API_GetSurfaceRenderStatus(void *ghoul2, const int modelIndex, const char *surfaceName);
+
+int			trap_G2API_GetTime(void);
+void		trap_G2API_SetTime(int time, int clock);
+
+void		trap_G2API_AbsurdSmoothing(void *ghoul2, qboolean status);
+
+void		trap_G2API_SetRagDoll(void *ghoul2, sharedRagDollParams_t *params);
+void		trap_G2API_AnimateG2Models(void *ghoul2, int time, sharedRagDollUpdateParams_t *params);
+
+//additional ragdoll options -rww
+qboolean	trap_G2API_RagPCJConstraint(void *ghoul2, const char *boneName, vec3_t min, vec3_t max); //override default pcj bonee constraints
+qboolean	trap_G2API_RagPCJGradientSpeed(void *ghoul2, const char *boneName, const float speed); //override the default gradient movespeed for a pcj bone
+qboolean	trap_G2API_RagEffectorGoal(void *ghoul2, const char *boneName, vec3_t pos); //override an effector bone's goal position (world coordinates)
+qboolean	trap_G2API_GetRagBonePos(void *ghoul2, const char *boneName, vec3_t pos, vec3_t entAngles, vec3_t entPos, vec3_t entScale); //current position of said bone is put into pos (world coordinates)
+qboolean	trap_G2API_RagEffectorKick(void *ghoul2, const char *boneName, vec3_t velocity); //add velocity to a rag bone
+qboolean	trap_G2API_RagForceSolve(void *ghoul2, qboolean force); //make sure we are actively performing solve/settle routines, if desired
+
+qboolean	trap_G2API_SetBoneIKState(void *ghoul2, int time, const char *boneName, int ikState, sharedSetBoneIKStateParams_t *params);
+qboolean	trap_G2API_IKMove(void *ghoul2, int time, sharedIKMoveParams_t *params);
+
+//for removing bones so they no longer have their own seperate animation hierarchy. Or whatever reason you may have. -rww
+qboolean	trap_G2API_RemoveBone(void *ghoul2, const char *boneName, int modelIndex);
+
+void		trap_G2API_AttachInstanceToEntNum(void *ghoul2, int entityNum, qboolean server);
+void		trap_G2API_ClearAttachedInstance(int entityNum);
+void		trap_G2API_CleanEntAttachments(void);
+qboolean	trap_G2API_OverrideServer(void *serverInstance);
+
+void		trap_G2API_GetSurfaceName(void *ghoul2, int surfNumber, int modelIndex, char *fillBuf);
+
+#include "../namespace_end.h"
+
+void		CG_Init_CG(void);
+void		CG_Init_CGents(void);
+
+
+void CG_SetGhoul2Info( refEntity_t *ent, centity_t *cent);
+void CG_CreateBBRefEnts(entityState_t *s1, vec3_t origin );
+
+void CG_InitG2Weapons(void);
+void CG_ShutDownG2Weapons(void);
+void CG_CopyG2WeaponInstance(centity_t *cent, int weaponNum, void *toGhoul2);
+void *CG_G2WeaponInstance(centity_t *cent, int weapon);
+void CG_CheckPlayerG2Weapons(playerState_t *ps, centity_t *cent);
+
+void CG_SetSiegeTimerCvar( int msec );
+
+/*
+Ghoul2 Insert End
+*/
diff --git a/codemp/cgame/cg_localents.c b/codemp/cgame/cg_localents.c
new file mode 100644
index 0000000..602063d
--- /dev/null
+++ b/codemp/cgame/cg_localents.c
@@ -0,0 +1,869 @@
+// Copyright (C) 1999-2000 Id Software, Inc.
+//
+
+// cg_localents.c -- every frame, generate renderer commands for locally
+// processed entities, like smoke puffs, gibs, shells, etc.
+
+#include "cg_local.h"
+
+#define	MAX_LOCAL_ENTITIES	512
+localEntity_t	cg_localEntities[MAX_LOCAL_ENTITIES];
+localEntity_t	cg_activeLocalEntities;		// double linked list
+localEntity_t	*cg_freeLocalEntities;		// single linked list
+
+/*
+===================
+CG_InitLocalEntities
+
+This is called at startup and for tournement restarts
+===================
+*/
+void	CG_InitLocalEntities( void ) {
+	int		i;
+
+	memset( cg_localEntities, 0, sizeof( cg_localEntities ) );
+	cg_activeLocalEntities.next = &cg_activeLocalEntities;
+	cg_activeLocalEntities.prev = &cg_activeLocalEntities;
+	cg_freeLocalEntities = cg_localEntities;
+	for ( i = 0 ; i < MAX_LOCAL_ENTITIES - 1 ; i++ ) {
+		cg_localEntities[i].next = &cg_localEntities[i+1];
+	}
+}
+
+
+/*
+==================
+CG_FreeLocalEntity
+==================
+*/
+void CG_FreeLocalEntity( localEntity_t *le ) {
+	if ( !le->prev ) {
+		CG_Error( "CG_FreeLocalEntity: not active" );
+	}
+
+	// remove from the doubly linked active list
+	le->prev->next = le->next;
+	le->next->prev = le->prev;
+
+	// the free list is only singly linked
+	le->next = cg_freeLocalEntities;
+	cg_freeLocalEntities = le;
+}
+
+/*
+===================
+CG_AllocLocalEntity
+
+Will allways succeed, even if it requires freeing an old active entity
+===================
+*/
+localEntity_t	*CG_AllocLocalEntity( void ) {
+	localEntity_t	*le;
+
+	if ( !cg_freeLocalEntities ) {
+		// no free entities, so free the one at the end of the chain
+		// remove the oldest active entity
+		CG_FreeLocalEntity( cg_activeLocalEntities.prev );
+	}
+
+	le = cg_freeLocalEntities;
+	cg_freeLocalEntities = cg_freeLocalEntities->next;
+
+	memset( le, 0, sizeof( *le ) );
+
+	// link into the active list
+	le->next = cg_activeLocalEntities.next;
+	le->prev = &cg_activeLocalEntities;
+	cg_activeLocalEntities.next->prev = le;
+	cg_activeLocalEntities.next = le;
+	return le;
+}
+
+
+/*
+====================================================================================
+
+FRAGMENT PROCESSING
+
+A fragment localentity interacts with the environment in some way (hitting walls),
+or generates more localentities along a trail.
+
+====================================================================================
+*/
+
+/*
+================
+CG_BloodTrail
+
+Leave expanding blood puffs behind gibs
+================
+*/
+void CG_BloodTrail( localEntity_t *le ) {
+	int		t;
+	int		t2;
+	int		step;
+	vec3_t	newOrigin;
+	localEntity_t	*blood;
+
+	step = 150;
+	t = step * ( (cg.time - cg.frametime + step ) / step );
+	t2 = step * ( cg.time / step );
+
+	for ( ; t <= t2; t += step ) {
+		BG_EvaluateTrajectory( &le->pos, t, newOrigin );
+
+		blood = CG_SmokePuff( newOrigin, vec3_origin, 
+					  20,		// radius
+					  1, 1, 1, 1,	// color
+					  2000,		// trailTime
+					  t,		// startTime
+					  0,		// fadeInTime
+					  0,		// flags
+					  /*cgs.media.bloodTrailShader*/0 );
+		// use the optimized version
+		blood->leType = LE_FALL_SCALE_FADE;
+		// drop a total of 40 units over its lifetime
+		blood->pos.trDelta[2] = 40;
+	}
+}
+
+
+/*
+================
+CG_FragmentBounceMark
+================
+*/
+void CG_FragmentBounceMark( localEntity_t *le, trace_t *trace ) {
+	int			radius;
+
+	if ( le->leMarkType == LEMT_BLOOD ) {
+
+		radius = 16 + (rand()&31);
+//		CG_ImpactMark( cgs.media.bloodMarkShader, trace->endpos, trace->plane.normal, random()*360,
+//			1,1,1,1, qtrue, radius, qfalse );
+	} else if ( le->leMarkType == LEMT_BURN ) {
+
+		radius = 8 + (rand()&15);
+//		CG_ImpactMark( cgs.media.burnMarkShader, trace->endpos, trace->plane.normal, random()*360,
+//			1,1,1,1, qtrue, radius, qfalse );
+	}
+
+
+	// don't allow a fragment to make multiple marks, or they
+	// pile up while settling
+	le->leMarkType = LEMT_NONE;
+}
+
+/*
+================
+CG_FragmentBounceSound
+================
+*/
+void CG_FragmentBounceSound( localEntity_t *le, trace_t *trace ) {
+	// half the fragments will make a bounce sounds
+	if ( rand() & 1 ) 
+	{
+		sfxHandle_t	s = 0;
+
+		switch( le->leBounceSoundType )
+		{
+		case LEBS_ROCK:
+			s = cgs.media.rockBounceSound[Q_irand(0,1)];
+			break;
+		case LEBS_METAL:
+			s = cgs.media.metalBounceSound[Q_irand(0,1)];// FIXME: make sure that this sound is registered properly...might still be rock bounce sound....
+			break;
+		default:
+			return;
+		}
+
+		if ( s )
+		{
+			trap_S_StartSound( trace->endpos, ENTITYNUM_WORLD, CHAN_AUTO, s );
+		}
+
+		// bouncers only make the sound once...
+		// FIXME: arbitrary...change if it bugs you
+		le->leBounceSoundType = LEBS_NONE;
+	} 
+	else if ( rand() & 1 )
+	{
+		// we may end up bouncing again, but each bounce reduces the chance of playing the sound again or they may make a lot of noise when they settle
+		// FIXME: maybe just always do this??
+		le->leBounceSoundType = LEBS_NONE;
+	}
+}
+
+
+/*
+================
+CG_ReflectVelocity
+================
+*/
+void CG_ReflectVelocity( localEntity_t *le, trace_t *trace ) {
+	vec3_t	velocity;
+	float	dot;
+	int		hitTime;
+
+	// reflect the velocity on the trace plane
+	hitTime = cg.time - cg.frametime + cg.frametime * trace->fraction;
+	BG_EvaluateTrajectoryDelta( &le->pos, hitTime, velocity );
+	dot = DotProduct( velocity, trace->plane.normal );
+	VectorMA( velocity, -2*dot, trace->plane.normal, le->pos.trDelta );
+
+	VectorScale( le->pos.trDelta, le->bounceFactor, le->pos.trDelta );
+
+	VectorCopy( trace->endpos, le->pos.trBase );
+	le->pos.trTime = cg.time;
+
+	// check for stop, making sure that even on low FPS systems it doesn't bobble
+	if ( trace->allsolid || 
+		( trace->plane.normal[2] > 0 && 
+		( le->pos.trDelta[2] < 40 || le->pos.trDelta[2] < -cg.frametime * le->pos.trDelta[2] ) ) ) {
+		le->pos.trType = TR_STATIONARY;
+	} else {
+
+	}
+}
+
+/*
+================
+CG_AddFragment
+================
+*/
+void CG_AddFragment( localEntity_t *le ) {
+	vec3_t	newOrigin;
+	trace_t	trace;
+
+	if (le->forceAlpha)
+	{
+		le->refEntity.renderfx |= RF_FORCE_ENT_ALPHA;
+		le->refEntity.shaderRGBA[3] = le->forceAlpha;
+	}
+
+	if ( le->pos.trType == TR_STATIONARY ) {
+		// sink into the ground if near the removal time
+		int		t;
+		float	t_e;
+		
+		t = le->endTime - cg.time;
+		if ( t < (SINK_TIME*2) ) {
+			le->refEntity.renderfx |= RF_FORCE_ENT_ALPHA;
+			t_e = (float)((float)(le->endTime - cg.time)/(SINK_TIME*2));
+			t_e = (int)((t_e)*255);
+
+			if (t_e > 255)
+			{
+				t_e = 255;
+			}
+			if (t_e < 1)
+			{
+				t_e = 1;
+			}
+
+			if (le->refEntity.shaderRGBA[3] && t_e > le->refEntity.shaderRGBA[3])
+			{
+				t_e = le->refEntity.shaderRGBA[3];
+			}
+
+			le->refEntity.shaderRGBA[3] = t_e;
+
+			trap_R_AddRefEntityToScene( &le->refEntity );
+		} else {
+			trap_R_AddRefEntityToScene( &le->refEntity );
+		}
+
+		return;
+	}
+
+	// calculate new position
+	BG_EvaluateTrajectory( &le->pos, cg.time, newOrigin );
+
+	// trace a line from previous position to new position
+	CG_Trace( &trace, le->refEntity.origin, NULL, NULL, newOrigin, -1, CONTENTS_SOLID );
+	if ( trace.fraction == 1.0 ) {
+		// still in free fall
+		VectorCopy( newOrigin, le->refEntity.origin );
+
+		if ( le->leFlags & LEF_TUMBLE ) {
+			vec3_t angles;
+
+			BG_EvaluateTrajectory( &le->angles, cg.time, angles );
+			AnglesToAxis( angles, le->refEntity.axis );
+			ScaleModelAxis(&le->refEntity);
+		}
+
+		trap_R_AddRefEntityToScene( &le->refEntity );
+
+		// add a blood trail
+		if ( le->leBounceSoundType == LEBS_BLOOD ) {
+			CG_BloodTrail( le );
+		}
+
+		return;
+	}
+
+	// if it is in a nodrop zone, remove it
+	// this keeps gibs from waiting at the bottom of pits of death
+	// and floating levels
+	if ( trap_CM_PointContents( trace.endpos, 0 ) & CONTENTS_NODROP ) {
+		CG_FreeLocalEntity( le );
+		return;
+	}
+
+	if (!trace.startsolid)
+	{
+		// leave a mark
+		CG_FragmentBounceMark( le, &trace );
+
+		// do a bouncy sound
+		CG_FragmentBounceSound( le, &trace );
+
+		if (le->bounceSound)
+		{ //specified bounce sound (debris)
+			trap_S_StartSound(le->pos.trBase, ENTITYNUM_WORLD, CHAN_AUTO, le->bounceSound);
+		}
+
+		// reflect the velocity on the trace plane
+		CG_ReflectVelocity( le, &trace );
+
+		trap_R_AddRefEntityToScene( &le->refEntity );
+	}
+}
+
+/*
+=====================================================================
+
+TRIVIAL LOCAL ENTITIES
+
+These only do simple scaling or modulation before passing to the renderer
+=====================================================================
+*/
+
+/*
+====================
+CG_AddFadeRGB
+====================
+*/
+void CG_AddFadeRGB( localEntity_t *le ) {
+	refEntity_t *re;
+	float c;
+
+	re = &le->refEntity;
+
+	c = ( le->endTime - cg.time ) * le->lifeRate;
+	c *= 0xff;
+
+	re->shaderRGBA[0] = le->color[0] * c;
+	re->shaderRGBA[1] = le->color[1] * c;
+	re->shaderRGBA[2] = le->color[2] * c;
+	re->shaderRGBA[3] = le->color[3] * c;
+
+	trap_R_AddRefEntityToScene( re );
+}
+
+static void CG_AddFadeScaleModel( localEntity_t *le )
+{
+	refEntity_t	*ent = &le->refEntity;
+
+	float frac = ( cg.time - le->startTime )/((float)( le->endTime - le->startTime ));
+
+	frac *= frac * frac; // yes, this is completely ridiculous...but it causes the shell to grow slowly then "explode" at the end
+
+	ent->nonNormalizedAxes = qtrue;
+
+	AxisCopy( axisDefault, ent->axis );
+
+	VectorScale( ent->axis[0], le->radius * frac, ent->axis[0] );
+	VectorScale( ent->axis[1], le->radius * frac, ent->axis[1] );
+	VectorScale( ent->axis[2], le->radius * 0.5f * frac, ent->axis[2] );
+
+	frac = 1.0f - frac;
+
+	ent->shaderRGBA[0] = le->color[0] * frac;
+	ent->shaderRGBA[1] = le->color[1] * frac;
+	ent->shaderRGBA[2] = le->color[2] * frac;
+	ent->shaderRGBA[3] = le->color[3] * frac;
+
+	// add the entity
+	trap_R_AddRefEntityToScene( ent );
+}
+
+/*
+==================
+CG_AddMoveScaleFade
+==================
+*/
+static void CG_AddMoveScaleFade( localEntity_t *le ) {
+	refEntity_t	*re;
+	float		c;
+	vec3_t		delta;
+	float		len;
+
+	re = &le->refEntity;
+
+	if ( le->fadeInTime > le->startTime && cg.time < le->fadeInTime ) {
+		// fade / grow time
+		c = 1.0 - (float) ( le->fadeInTime - cg.time ) / ( le->fadeInTime - le->startTime );
+	}
+	else {
+		// fade / grow time
+		c = ( le->endTime - cg.time ) * le->lifeRate;
+	}
+
+	re->shaderRGBA[3] = 0xff * c * le->color[3];
+
+	if ( !( le->leFlags & LEF_PUFF_DONT_SCALE ) ) {
+		re->radius = le->radius * ( 1.0 - c ) + 8;
+	}
+
+	BG_EvaluateTrajectory( &le->pos, cg.time, re->origin );
+
+	// if the view would be "inside" the sprite, kill the sprite
+	// so it doesn't add too much overdraw
+	VectorSubtract( re->origin, cg.refdef.vieworg, delta );
+	len = VectorLength( delta );
+	if ( len < le->radius ) {
+		CG_FreeLocalEntity( le );
+		return;
+	}
+
+	trap_R_AddRefEntityToScene( re );
+}
+
+/*
+==================
+CG_AddPuff
+==================
+*/
+static void CG_AddPuff( localEntity_t *le ) {
+	refEntity_t	*re;
+	float		c;
+	vec3_t		delta;
+	float		len;
+
+	re = &le->refEntity;
+
+	// fade / grow time
+	c = ( le->endTime - cg.time ) / (float)( le->endTime - le->startTime );
+
+	re->shaderRGBA[0] = le->color[0] * c;
+	re->shaderRGBA[1] = le->color[1] * c;
+	re->shaderRGBA[2] = le->color[2] * c;
+
+	if ( !( le->leFlags & LEF_PUFF_DONT_SCALE ) ) {
+		re->radius = le->radius * ( 1.0 - c ) + 8;
+	}
+
+	BG_EvaluateTrajectory( &le->pos, cg.time, re->origin );
+
+	// if the view would be "inside" the sprite, kill the sprite
+	// so it doesn't add too much overdraw
+	VectorSubtract( re->origin, cg.refdef.vieworg, delta );
+	len = VectorLength( delta );
+	if ( len < le->radius ) {
+		CG_FreeLocalEntity( le );
+		return;
+	}
+
+	trap_R_AddRefEntityToScene( re );
+}
+
+/*
+===================
+CG_AddScaleFade
+
+For rocket smokes that hang in place, fade out, and are
+removed if the view passes through them.
+There are often many of these, so it needs to be simple.
+===================
+*/
+static void CG_AddScaleFade( localEntity_t *le ) {
+	refEntity_t	*re;
+	float		c;
+	vec3_t		delta;
+	float		len;
+
+	re = &le->refEntity;
+
+	// fade / grow time
+	c = ( le->endTime - cg.time ) * le->lifeRate;
+
+	re->shaderRGBA[3] = 0xff * c * le->color[3];
+	re->radius = le->radius * ( 1.0 - c ) + 8;
+
+	// if the view would be "inside" the sprite, kill the sprite
+	// so it doesn't add too much overdraw
+	VectorSubtract( re->origin, cg.refdef.vieworg, delta );
+	len = VectorLength( delta );
+	if ( len < le->radius ) {
+		CG_FreeLocalEntity( le );
+		return;
+	}
+
+	trap_R_AddRefEntityToScene( re );
+}
+
+
+/*
+=================
+CG_AddFallScaleFade
+
+This is just an optimized CG_AddMoveScaleFade
+For blood mists that drift down, fade out, and are
+removed if the view passes through them.
+There are often 100+ of these, so it needs to be simple.
+=================
+*/
+static void CG_AddFallScaleFade( localEntity_t *le ) {
+	refEntity_t	*re;
+	float		c;
+	vec3_t		delta;
+	float		len;
+
+	re = &le->refEntity;
+
+	// fade time
+	c = ( le->endTime - cg.time ) * le->lifeRate;
+
+	re->shaderRGBA[3] = 0xff * c * le->color[3];
+
+	re->origin[2] = le->pos.trBase[2] - ( 1.0 - c ) * le->pos.trDelta[2];
+
+	re->radius = le->radius * ( 1.0 - c ) + 16;
+
+	// if the view would be "inside" the sprite, kill the sprite
+	// so it doesn't add too much overdraw
+	VectorSubtract( re->origin, cg.refdef.vieworg, delta );
+	len = VectorLength( delta );
+	if ( len < le->radius ) {
+		CG_FreeLocalEntity( le );
+		return;
+	}
+
+	trap_R_AddRefEntityToScene( re );
+}
+
+
+
+/*
+================
+CG_AddExplosion
+================
+*/
+static void CG_AddExplosion( localEntity_t *ex ) {
+	refEntity_t	*ent;
+
+	ent = &ex->refEntity;
+
+	// add the entity
+	trap_R_AddRefEntityToScene(ent);
+
+	// add the dlight
+	if ( ex->light ) {
+		float		light;
+
+		light = (float)( cg.time - ex->startTime ) / ( ex->endTime - ex->startTime );
+		if ( light < 0.5 ) {
+			light = 1.0;
+		} else {
+			light = 1.0 - ( light - 0.5 ) * 2;
+		}
+		light = ex->light * light;
+		trap_R_AddLightToScene(ent->origin, light, ex->lightColor[0], ex->lightColor[1], ex->lightColor[2] );
+	}
+}
+
+/*
+================
+CG_AddSpriteExplosion
+================
+*/
+static void CG_AddSpriteExplosion( localEntity_t *le ) {
+	refEntity_t	re;
+	float c;
+
+	re = le->refEntity;
+
+	c = ( le->endTime - cg.time ) / ( float ) ( le->endTime - le->startTime );
+	if ( c > 1 ) {
+		c = 1.0;	// can happen during connection problems
+	}
+
+	re.shaderRGBA[0] = 0xff;
+	re.shaderRGBA[1] = 0xff;
+	re.shaderRGBA[2] = 0xff;
+	re.shaderRGBA[3] = 0xff * c * 0.33;
+
+	re.reType = RT_SPRITE;
+	re.radius = 42 * ( 1.0 - c ) + 30;
+
+	trap_R_AddRefEntityToScene( &re );
+
+	// add the dlight
+	if ( le->light ) {
+		float		light;
+
+		light = (float)( cg.time - le->startTime ) / ( le->endTime - le->startTime );
+		if ( light < 0.5 ) {
+			light = 1.0;
+		} else {
+			light = 1.0 - ( light - 0.5 ) * 2;
+		}
+		light = le->light * light;
+		trap_R_AddLightToScene(re.origin, light, le->lightColor[0], le->lightColor[1], le->lightColor[2] );
+	}
+}
+
+
+/*
+===================
+CG_AddRefEntity
+===================
+*/
+void CG_AddRefEntity( localEntity_t *le ) {
+	if (le->endTime < cg.time) {
+		CG_FreeLocalEntity( le );
+		return;
+	}
+	trap_R_AddRefEntityToScene( &le->refEntity );
+}
+
+/*
+===================
+CG_AddScorePlum
+===================
+*/
+#define NUMBER_SIZE		8
+
+void CG_AddScorePlum( localEntity_t *le ) {
+	refEntity_t	*re;
+	vec3_t		origin, delta, dir, vec, up = {0, 0, 1};
+	float		c, len;
+	int			i, score, digits[10], numdigits, negative;
+
+	re = &le->refEntity;
+
+	c = ( le->endTime - cg.time ) * le->lifeRate;
+
+	score = le->radius;
+	if (score < 0) {
+		re->shaderRGBA[0] = 0xff;
+		re->shaderRGBA[1] = 0x11;
+		re->shaderRGBA[2] = 0x11;
+	}
+	else {
+		re->shaderRGBA[0] = 0xff;
+		re->shaderRGBA[1] = 0xff;
+		re->shaderRGBA[2] = 0xff;
+		if (score >= 50) {
+			re->shaderRGBA[1] = 0;
+		} else if (score >= 20) {
+			re->shaderRGBA[0] = re->shaderRGBA[1] = 0;
+		} else if (score >= 10) {
+			re->shaderRGBA[2] = 0;
+		} else if (score >= 2) {
+			re->shaderRGBA[0] = re->shaderRGBA[2] = 0;
+		}
+
+	}
+	if (c < 0.25)
+		re->shaderRGBA[3] = 0xff * 4 * c;
+	else
+		re->shaderRGBA[3] = 0xff;
+
+	re->radius = NUMBER_SIZE / 2;
+
+	VectorCopy(le->pos.trBase, origin);
+	origin[2] += 110 - c * 100;
+
+	VectorSubtract(cg.refdef.vieworg, origin, dir);
+	CrossProduct(dir, up, vec);
+	VectorNormalize(vec);
+
+	VectorMA(origin, -10 + 20 * sin(c * 2 * M_PI), vec, origin);
+
+	// if the view would be "inside" the sprite, kill the sprite
+	// so it doesn't add too much overdraw
+	VectorSubtract( origin, cg.refdef.vieworg, delta );
+	len = VectorLength( delta );
+	if ( len < 20 ) {
+		CG_FreeLocalEntity( le );
+		return;
+	}
+
+	negative = qfalse;
+	if (score < 0) {
+		negative = qtrue;
+		score = -score;
+	}
+
+	for (numdigits = 0; !(numdigits && !score); numdigits++) {
+		digits[numdigits] = score % 10;
+		score = score / 10;
+	}
+
+	if (negative) {
+		digits[numdigits] = 10;
+		numdigits++;
+	}
+
+	for (i = 0; i < numdigits; i++) {
+		VectorMA(origin, (float) (((float) numdigits / 2) - i) * NUMBER_SIZE, vec, re->origin);
+		re->customShader = cgs.media.numberShaders[digits[numdigits-1-i]];
+		trap_R_AddRefEntityToScene( re );
+	}
+}
+
+/*
+===================
+CG_AddOLine
+
+For forcefields/other rectangular things
+===================
+*/
+void CG_AddOLine( localEntity_t *le )
+{
+	refEntity_t	*re;
+	float		frac, alpha;
+
+	re = &le->refEntity;
+
+	frac = (cg.time - le->startTime) / ( float ) ( le->endTime - le->startTime );
+	if ( frac > 1 ) 
+		frac = 1.0;	// can happen during connection problems
+	else if (frac < 0)
+		frac = 0.0;
+
+	// Use the liferate to set the scale over time.
+	re->data.line.width = le->data.line.width + (le->data.line.dwidth * frac);
+	if (re->data.line.width <= 0)
+	{
+		CG_FreeLocalEntity( le );
+		return;
+	}
+
+	// We will assume here that we want additive transparency effects.
+	alpha = le->alpha + (le->dalpha * frac);
+	re->shaderRGBA[0] = 0xff * alpha;
+	re->shaderRGBA[1] = 0xff * alpha;
+	re->shaderRGBA[2] = 0xff * alpha;
+	re->shaderRGBA[3] = 0xff * alpha;	// Yes, we could apply c to this too, but fading the color is better for lines.
+
+	re->shaderTexCoord[0] = 1;
+	re->shaderTexCoord[1] = 1;
+
+	re->rotation = 90;
+
+	re->reType = RT_ORIENTEDLINE;
+
+	trap_R_AddRefEntityToScene( re );
+}
+
+/*
+===================
+CG_AddLine
+
+for beams and the like.
+===================
+*/
+void CG_AddLine( localEntity_t *le )
+{
+	refEntity_t	*re;
+
+	re = &le->refEntity;
+
+	re->reType = RT_LINE;
+
+	trap_R_AddRefEntityToScene( re );
+}
+
+//==============================================================================
+
+/*
+===================
+CG_AddLocalEntities
+
+===================
+*/
+void CG_AddLocalEntities( void ) {
+	localEntity_t	*le, *next;
+
+	// walk the list backwards, so any new local entities generated
+	// (trails, marks, etc) will be present this frame
+	le = cg_activeLocalEntities.prev;
+	for ( ; le != &cg_activeLocalEntities ; le = next ) {
+		// grab next now, so if the local entity is freed we
+		// still have it
+		next = le->prev;
+
+		if ( cg.time >= le->endTime ) {
+			CG_FreeLocalEntity( le );
+			continue;
+		}
+		switch ( le->leType ) {
+		default:
+			CG_Error( "Bad leType: %i", le->leType );
+			break;
+
+		case LE_MARK:
+			break;
+
+		case LE_SPRITE_EXPLOSION:
+			CG_AddSpriteExplosion( le );
+			break;
+
+		case LE_EXPLOSION:
+			CG_AddExplosion( le );
+			break;
+
+		case LE_FADE_SCALE_MODEL:
+			CG_AddFadeScaleModel( le );
+			break;
+
+		case LE_FRAGMENT:			// gibs and brass
+			CG_AddFragment( le );
+			break;
+
+		case LE_PUFF:
+			CG_AddPuff( le );
+			break;
+
+		case LE_MOVE_SCALE_FADE:		// water bubbles
+			CG_AddMoveScaleFade( le );
+			break;
+
+		case LE_FADE_RGB:				// teleporters, railtrails
+			CG_AddFadeRGB( le );
+			break;
+
+		case LE_FALL_SCALE_FADE: // gib blood trails
+			CG_AddFallScaleFade( le );
+			break;
+
+		case LE_SCALE_FADE:		// rocket trails
+			CG_AddScaleFade( le );
+			break;
+
+		case LE_SCOREPLUM:
+			CG_AddScorePlum( le );
+			break;
+
+		case LE_OLINE:
+			CG_AddOLine( le );
+			break;
+
+		case LE_SHOWREFENTITY:
+			CG_AddRefEntity( le );
+			break;
+
+		case LE_LINE:					// oriented lines for FX
+			CG_AddLine( le );
+			break;
+		}
+	}
+}
+
+
+
+
diff --git a/codemp/cgame/cg_main.c b/codemp/cgame/cg_main.c
new file mode 100644
index 0000000..74cd368
--- /dev/null
+++ b/codemp/cgame/cg_main.c
@@ -0,0 +1,4160 @@
+// Copyright (C) 1999-2000 Id Software, Inc.
+//
+// cg_main.c -- initialization and primary entry point for cgame
+#include "cg_local.h"
+
+#include "../ui/ui_shared.h"
+// display context for new ui stuff
+displayContextDef_t cgDC;
+
+#if !defined(CL_LIGHT_H_INC)
+	#include "cg_lights.h"
+#endif
+
+extern int cgSiegeRoundState;
+extern int cgSiegeRoundTime;
+/*
+Ghoul2 Insert Start
+*/
+void CG_InitItems(void);
+/*
+Ghoul2 Insert End
+*/
+
+void CG_InitJetpackGhoul2(void);
+void CG_CleanJetpackGhoul2(void);
+
+vec4_t colorTable[CT_MAX] = 
+{
+{0, 0, 0, 0},			// CT_NONE
+{0, 0, 0, 1},			// CT_BLACK
+{1, 0, 0, 1},			// CT_RED
+{0, 1, 0, 1},			// CT_GREEN
+{0, 0, 1, 1},			// CT_BLUE
+{1, 1, 0, 1},			// CT_YELLOW
+{1, 0, 1, 1},			// CT_MAGENTA
+{0, 1, 1, 1},			// CT_CYAN
+{1, 1, 1, 1},			// CT_WHITE
+{0.75f, 0.75f, 0.75f, 1},	// CT_LTGREY
+{0.50f, 0.50f, 0.50f, 1},	// CT_MDGREY
+{0.25f, 0.25f, 0.25f, 1},	// CT_DKGREY
+{0.15f, 0.15f, 0.15f, 1},	// CT_DKGREY2
+
+{0.810f, 0.530f, 0.0f,  1},	// CT_VLTORANGE -- needs values
+{0.810f, 0.530f, 0.0f,  1},	// CT_LTORANGE
+{0.610f, 0.330f, 0.0f,  1},	// CT_DKORANGE
+{0.402f, 0.265f, 0.0f,  1},	// CT_VDKORANGE
+
+{0.503f, 0.375f, 0.996f, 1},	// CT_VLTBLUE1
+{0.367f, 0.261f, 0.722f, 1},	// CT_LTBLUE1
+{0.199f, 0.0f,   0.398f, 1},	// CT_DKBLUE1
+{0.160f, 0.117f, 0.324f, 1},	// CT_VDKBLUE1
+
+{0.300f, 0.628f, 0.816f, 1},	// CT_VLTBLUE2 -- needs values
+{0.300f, 0.628f, 0.816f, 1},	// CT_LTBLUE2
+{0.191f, 0.289f, 0.457f, 1},	// CT_DKBLUE2
+{0.125f, 0.250f, 0.324f, 1},	// CT_VDKBLUE2
+
+{0.796f, 0.398f, 0.199f, 1},	// CT_VLTBROWN1 -- needs values
+{0.796f, 0.398f, 0.199f, 1},	// CT_LTBROWN1
+{0.558f, 0.207f, 0.027f, 1},	// CT_DKBROWN1
+{0.328f, 0.125f, 0.035f, 1},	// CT_VDKBROWN1
+
+{0.996f, 0.796f, 0.398f, 1},	// CT_VLTGOLD1 -- needs values
+{0.996f, 0.796f, 0.398f, 1},	// CT_LTGOLD1
+{0.605f, 0.441f, 0.113f, 1},	// CT_DKGOLD1
+{0.386f, 0.308f, 0.148f, 1},	// CT_VDKGOLD1
+
+{0.648f, 0.562f, 0.784f, 1},	// CT_VLTPURPLE1 -- needs values
+{0.648f, 0.562f, 0.784f, 1},	// CT_LTPURPLE1
+{0.437f, 0.335f, 0.597f, 1},	// CT_DKPURPLE1
+{0.308f, 0.269f, 0.375f, 1},	// CT_VDKPURPLE1
+
+{0.816f, 0.531f, 0.710f, 1},	// CT_VLTPURPLE2 -- needs values
+{0.816f, 0.531f, 0.710f, 1},	// CT_LTPURPLE2
+{0.566f, 0.269f, 0.457f, 1},	// CT_DKPURPLE2
+{0.343f, 0.226f, 0.316f, 1},	// CT_VDKPURPLE2
+
+{0.929f, 0.597f, 0.929f, 1},	// CT_VLTPURPLE3
+{0.570f, 0.371f, 0.570f, 1},	// CT_LTPURPLE3
+{0.355f, 0.199f, 0.355f, 1},	// CT_DKPURPLE3
+{0.285f, 0.136f, 0.230f, 1},	// CT_VDKPURPLE3
+
+{0.953f, 0.378f, 0.250f, 1},	// CT_VLTRED1
+{0.953f, 0.378f, 0.250f, 1},	// CT_LTRED1
+{0.593f, 0.121f, 0.109f, 1},	// CT_DKRED1
+{0.429f, 0.171f, 0.113f, 1},	// CT_VDKRED1
+{.25f, 0, 0, 1},					// CT_VDKRED
+{.70f, 0, 0, 1},					// CT_DKRED
+	
+{0.717f, 0.902f, 1.0f,   1},		// CT_VLTAQUA
+{0.574f, 0.722f, 0.804f, 1},		// CT_LTAQUA
+{0.287f, 0.361f, 0.402f, 1},		// CT_DKAQUA
+{0.143f, 0.180f, 0.201f, 1},		// CT_VDKAQUA
+
+{0.871f, 0.386f, 0.375f, 1},		// CT_LTPINK
+{0.435f, 0.193f, 0.187f, 1},		// CT_DKPINK
+{	  0,    .5f,    .5f, 1},		// CT_LTCYAN
+{	  0,   .25f,   .25f, 1},		// CT_DKCYAN
+{   .179f, .51f,   .92f, 1},		// CT_LTBLUE3
+{   .199f, .71f,   .92f, 1},		// CT_LTBLUE3
+{   .5f,   .05f,    .4f, 1},		// CT_DKBLUE3
+
+{   0.0f,   .613f,  .097f, 1},		// CT_HUD_GREEN
+{   0.835f, .015f,  .015f, 1},		// CT_HUD_RED
+{	.567f,	.685f,	1.0f,	.75f},	// CT_ICON_BLUE
+{	.515f,	.406f,	.507f,	1},		// CT_NO_AMMO_RED
+{   1.0f,   .658f,  .062f, 1},		// CT_HUD_ORANGE
+
+};
+
+#include "holocronicons.h"
+
+int cgWeatherOverride = 0;
+
+int forceModelModificationCount = -1;
+
+void CG_Init( int serverMessageNum, int serverCommandSequence, int clientNum );
+void CG_Shutdown( void );
+
+void CG_CalcEntityLerpPositions( centity_t *cent );
+void CG_ROFF_NotetrackCallback( centity_t *cent, const char *notetrack);
+
+#include "../namespace_begin.h"
+void UI_CleanupGhoul2(void);
+#include "../namespace_end.h"
+
+static int	C_PointContents(void);
+static void C_GetLerpOrigin(void);
+static void C_GetLerpData(void);
+static void C_Trace(void);
+static void C_G2Trace(void);
+static void C_G2Mark(void);
+static int	CG_RagCallback(int callType);
+static void C_GetBoltPos(void);
+static void C_ImpactMark(void);
+
+#ifdef _XBOX
+#define MAX_MISC_ENTS	500
+#else
+#define MAX_MISC_ENTS	4000
+#endif
+
+//static refEntity_t	*MiscEnts = 0;
+//static float		*Radius = 0;
+static refEntity_t	MiscEnts[MAX_MISC_ENTS]; //statically allocated for now.
+static float		Radius[MAX_MISC_ENTS];
+static float		zOffset[MAX_MISC_ENTS]; //some models need a z offset for culling, because of stupid wrong model origins
+
+static int			NumMiscEnts = 0;
+
+extern autoMapInput_t cg_autoMapInput; //cg_view.c
+extern int cg_autoMapInputTime;
+extern vec3_t cg_autoMapAngle;
+
+void CG_MiscEnt(void);
+
+//do we have any force powers that we would normally need to cycle to?
+qboolean CG_NoUseableForce(void)
+{
+	int i = FP_HEAL;
+	while (i < NUM_FORCE_POWERS)
+	{
+		if (i != FP_SABERTHROW &&
+			i != FP_SABER_OFFENSE &&
+			i != FP_SABER_DEFENSE &&
+			i != FP_LEVITATION)
+		{ //valid selectable power
+			if (cg.predictedPlayerState.fd.forcePowersKnown & (1 << i))
+			{ //we have it
+				return qfalse;
+			}
+		}
+		i++;
+	}
+
+	//no useable force powers, I guess.
+	return qtrue;
+}
+
+/*
+================
+vmMain
+
+This is the only way control passes into the module.
+This must be the very first function compiled into the .q3vm file
+================
+*/
+#include "../namespace_begin.h"
+int vmMain( int command, int arg0, int arg1, int arg2, int arg3, int arg4, int arg5, int arg6, int arg7, int arg8, int arg9, int arg10, int arg11  ) {
+
+	switch ( command ) {
+	case CG_INIT:
+		CG_Init( arg0, arg1, arg2 );
+		return 0;
+	case CG_SHUTDOWN:
+		CG_Shutdown();
+		return 0;
+	case CG_CONSOLE_COMMAND:
+		return CG_ConsoleCommand();
+	case CG_DRAW_ACTIVE_FRAME:
+		CG_DrawActiveFrame( arg0, arg1, arg2 );
+		return 0;
+	case CG_CROSSHAIR_PLAYER:
+		return CG_CrosshairPlayer();
+	case CG_LAST_ATTACKER:
+		return CG_LastAttacker();
+	case CG_KEY_EVENT:
+		CG_KeyEvent(arg0, arg1);
+		return 0;
+	case CG_MOUSE_EVENT:
+		cgDC.cursorx = cgs.cursorX;
+		cgDC.cursory = cgs.cursorY;
+		CG_MouseEvent(arg0, arg1);
+		return 0;
+	case CG_EVENT_HANDLING:
+		CG_EventHandling(arg0);
+		return 0;
+
+	case CG_POINT_CONTENTS:
+		return C_PointContents();
+
+	case CG_GET_LERP_ORIGIN:
+		C_GetLerpOrigin();
+		return 0;
+
+	case CG_GET_LERP_DATA:
+		C_GetLerpData();
+		return 0;
+
+	case CG_GET_GHOUL2:
+		return (int)cg_entities[arg0].ghoul2; //NOTE: This is used by the effect bolting which is actually not used at all.
+											  //I'm fairly sure if you try to use it with vm's it will just give you total
+											  //garbage. In other words, use at your own risk.
+
+	case CG_GET_MODEL_LIST:
+		return (int)cgs.gameModels;
+
+	case CG_CALC_LERP_POSITIONS:
+		CG_CalcEntityLerpPositions( &cg_entities[arg0] );
+		return 0;
+
+	case CG_TRACE:
+		C_Trace();
+		return 0;
+	case CG_GET_SORTED_FORCE_POWER:
+		return forcePowerSorted[arg0];
+	case CG_G2TRACE:
+		C_G2Trace();
+		return 0;
+
+	case CG_G2MARK:
+		C_G2Mark();
+		return 0;
+
+	case CG_RAG_CALLBACK:
+		return CG_RagCallback(arg0);
+
+	case CG_INCOMING_CONSOLE_COMMAND:
+		//rww - let mod authors filter client console messages so they can cut them off if they want.
+		//return 1 if the command is ok. Otherwise, you can set char 0 on the command str to 0 and return
+		//0 to not execute anything, or you can fill conCommand in with something valid and return 0
+		//in order to have that string executed in place. Some example code:
+#if 0
+		{
+			TCGIncomingConsoleCommand	*icc = (TCGIncomingConsoleCommand *)cg.sharedBuffer;
+			if (strstr(icc->conCommand, "wait"))
+			{ //filter out commands contaning wait
+				Com_Printf("You can't use commands containing the string wait with MyMod v1.0\n");
+				icc->conCommand[0] = 0;
+				return 0;
+			}
+			else if (strstr(icc->conCommand, "blah"))
+			{ //any command containing the string "blah" is redirected to "quit"
+				strcpy(icc->conCommand, "quit");
+				return 0;
+			}
+		}
+#endif
+		return 1;
+
+	case CG_GET_USEABLE_FORCE:
+		return CG_NoUseableForce();
+
+	case CG_GET_ORIGIN:
+		VectorCopy(cg_entities[arg0].currentState.pos.trBase, (float *)arg1);
+		return 0;
+
+	case CG_GET_ANGLES:
+		VectorCopy(cg_entities[arg0].currentState.apos.trBase, (float *)arg1);
+		return 0;
+
+	case CG_GET_ORIGIN_TRAJECTORY:
+		return (int)&cg_entities[arg0].nextState.pos;
+
+	case CG_GET_ANGLE_TRAJECTORY:
+		return (int)&cg_entities[arg0].nextState.apos;
+
+	case CG_ROFF_NOTETRACK_CALLBACK:
+		CG_ROFF_NotetrackCallback( &cg_entities[arg0], (const char *)arg1 );
+		return 0;
+
+	case CG_IMPACT_MARK:
+		C_ImpactMark();
+		return 0;
+
+	case CG_MAP_CHANGE:
+		// this trap map be called more than once for a given map change, as the
+		// server is going to attempt to send out multiple broadcasts in hopes that
+		// the client will receive one of them
+		cg.mMapChange = qtrue;
+		return 0;
+
+	case CG_AUTOMAP_INPUT:
+		//special input during automap mode -rww
+		{
+			autoMapInput_t *autoInput = (autoMapInput_t *)cg.sharedBuffer;
+
+			memcpy(&cg_autoMapInput, autoInput, sizeof(autoMapInput_t));
+
+			if (!arg0)
+			{ //if this is non-0, it's actually a one-frame mouse event
+				cg_autoMapInputTime = cg.time + 1000;
+			}
+			else
+			{
+				if (cg_autoMapInput.yaw)
+				{
+					cg_autoMapAngle[YAW] += cg_autoMapInput.yaw;
+				}
+
+				if (cg_autoMapInput.pitch)
+				{
+					cg_autoMapAngle[PITCH] += cg_autoMapInput.pitch;
+				}
+				cg_autoMapInput.yaw = 0.0f;
+				cg_autoMapInput.pitch = 0.0f;
+			}
+		}
+		return 0;
+
+	case CG_MISC_ENT:
+		CG_MiscEnt();
+		return 0;
+
+	default:
+		CG_Error( "vmMain: unknown command %i", command );
+		break;
+	}
+	return -1;
+}
+#include "../namespace_end.h"
+
+static int C_PointContents(void)
+{
+	TCGPointContents	*data = (TCGPointContents *)cg.sharedBuffer;
+
+	return CG_PointContents( data->mPoint, data->mPassEntityNum );
+}
+
+static void C_GetLerpOrigin(void)
+{
+	TCGVectorData		*data = (TCGVectorData *)cg.sharedBuffer;
+
+	VectorCopy(cg_entities[data->mEntityNum].lerpOrigin, data->mPoint);
+}
+
+static void C_GetLerpData(void)
+{//only used by FX system to pass to getboltmat
+	TCGGetBoltData		*data = (TCGGetBoltData *)cg.sharedBuffer;
+
+	VectorCopy(cg_entities[data->mEntityNum].lerpOrigin, data->mOrigin);
+	VectorCopy(cg_entities[data->mEntityNum].modelScale, data->mScale);
+	VectorCopy(cg_entities[data->mEntityNum].lerpAngles, data->mAngles);
+	if (cg_entities[data->mEntityNum].currentState.eType == ET_PLAYER)
+	{ //normal player
+		data->mAngles[PITCH] = 0.0f;
+		data->mAngles[ROLL] = 0.0f;
+	}
+	else if (cg_entities[data->mEntityNum].currentState.eType == ET_NPC)
+	{ //an NPC
+		Vehicle_t *pVeh = cg_entities[data->mEntityNum].m_pVehicle;
+		if (!pVeh)
+		{ //for vehicles, we may or may not want to 0 out pitch and roll
+			data->mAngles[PITCH] = 0.0f;
+			data->mAngles[ROLL] = 0.0f;
+		}
+		else if (pVeh->m_pVehicleInfo->type == VH_SPEEDER)
+		{ //speeder wants no pitch but a roll
+			data->mAngles[PITCH] = 0.0f;
+		}
+		else if (pVeh->m_pVehicleInfo->type != VH_FIGHTER)
+		{ //fighters want all angles
+			data->mAngles[PITCH] = 0.0f;
+			data->mAngles[ROLL] = 0.0f;
+		}
+	}
+}
+
+static void C_Trace(void)
+{
+	TCGTrace	*td = (TCGTrace *)cg.sharedBuffer;
+
+	CG_Trace(&td->mResult, td->mStart, td->mMins, td->mMaxs, td->mEnd, td->mSkipNumber, td->mMask);
+}
+
+static void C_G2Trace(void)
+{
+	TCGTrace	*td = (TCGTrace *)cg.sharedBuffer;
+
+	CG_G2Trace(&td->mResult, td->mStart, td->mMins, td->mMaxs, td->mEnd, td->mSkipNumber, td->mMask);
+}
+
+static void C_G2Mark(void)
+{
+	TCGG2Mark	*td = (TCGG2Mark *)cg.sharedBuffer;
+	trace_t		tr;
+	vec3_t		end;
+
+	VectorMA(td->start, 64, td->dir, end);
+	CG_G2Trace(&tr, td->start, NULL, NULL, end, ENTITYNUM_NONE, MASK_PLAYERSOLID);
+
+	if (tr.entityNum < ENTITYNUM_WORLD &&
+		cg_entities[tr.entityNum].ghoul2)
+	{ //hit someone with a ghoul2 instance, let's project the decal on them then.
+		centity_t *cent = &cg_entities[tr.entityNum];
+
+		//CG_TestLine(tr.endpos, end, 2000, 0x0000ff, 1);
+
+		CG_AddGhoul2Mark(td->shader, td->size, tr.endpos, end, tr.entityNum,
+			cent->lerpOrigin, cent->lerpAngles[YAW], cent->ghoul2, cent->modelScale,
+			Q_irand(2000, 4000));
+		//I'm making fx system decals have a very short lifetime.
+	}
+}
+
+static void CG_DebugBoxLines(vec3_t mins, vec3_t maxs, int duration)
+{
+	vec3_t start;
+	vec3_t end;
+	vec3_t vert;
+
+	float x = maxs[0] - mins[0];
+	float y = maxs[1] - mins[1];
+
+	start[2] = maxs[2];
+	vert[2] = mins[2];
+
+	vert[0] = mins[0];
+	vert[1] = mins[1];
+	start[0] = vert[0];
+	start[1] = vert[1];
+	CG_TestLine(start, vert, duration, 0x00000ff, 1);
+
+	vert[0] = mins[0];
+	vert[1] = maxs[1];
+	start[0] = vert[0];
+	start[1] = vert[1];
+	CG_TestLine(start, vert, duration, 0x00000ff, 1);
+
+	vert[0] = maxs[0];
+	vert[1] = mins[1];
+	start[0] = vert[0];
+	start[1] = vert[1];
+	CG_TestLine(start, vert, duration, 0x00000ff, 1);
+
+	vert[0] = maxs[0];
+	vert[1] = maxs[1];
+	start[0] = vert[0];
+	start[1] = vert[1];
+	CG_TestLine(start, vert, duration, 0x00000ff, 1);
+
+	// top of box
+	VectorCopy(maxs, start);
+	VectorCopy(maxs, end);
+	start[0] -= x;
+	CG_TestLine(start, end, duration, 0x00000ff, 1);
+	end[0] = start[0];
+	end[1] -= y;
+	CG_TestLine(start, end, duration, 0x00000ff, 1);
+	start[1] = end[1];
+	start[0] += x;
+	CG_TestLine(start, end, duration, 0x00000ff, 1);
+	CG_TestLine(start, maxs, duration, 0x00000ff, 1);
+	// bottom of box
+	VectorCopy(mins, start);
+	VectorCopy(mins, end);
+	start[0] += x;
+	CG_TestLine(start, end, duration, 0x00000ff, 1);
+	end[0] = start[0];
+	end[1] += y;
+	CG_TestLine(start, end, duration, 0x00000ff, 1);
+	start[1] = end[1];
+	start[0] -= x;
+	CG_TestLine(start, end, duration, 0x00000ff, 1);
+	CG_TestLine(start, mins, duration, 0x00000ff, 1);
+}
+
+//handle ragdoll callbacks, for events and debugging -rww
+static int CG_RagCallback(int callType)
+{
+	switch(callType)
+	{
+	case RAG_CALLBACK_DEBUGBOX:
+		{
+			ragCallbackDebugBox_t *callData = (ragCallbackDebugBox_t *)cg.sharedBuffer;
+
+			CG_DebugBoxLines(callData->mins, callData->maxs, callData->duration);
+		}
+		break;
+	case RAG_CALLBACK_DEBUGLINE:
+		{
+			ragCallbackDebugLine_t *callData = (ragCallbackDebugLine_t *)cg.sharedBuffer;
+
+			CG_TestLine(callData->start, callData->end, callData->time, callData->color, callData->radius);
+		}
+		break;
+	case RAG_CALLBACK_BONESNAP:
+		{
+			ragCallbackBoneSnap_t *callData = (ragCallbackBoneSnap_t *)cg.sharedBuffer;
+			centity_t *cent = &cg_entities[callData->entNum];
+			int snapSound = trap_S_RegisterSound(va("sound/player/bodyfall_human%i.wav", Q_irand(1, 3)));
+
+			trap_S_StartSound(cent->lerpOrigin, callData->entNum, CHAN_AUTO, snapSound);
+		}
+	case RAG_CALLBACK_BONEIMPACT:
+		break;
+	case RAG_CALLBACK_BONEINSOLID:
+#if 0
+		{
+			ragCallbackBoneInSolid_t *callData = (ragCallbackBoneInSolid_t *)cg.sharedBuffer;
+
+			if (callData->solidCount > 16)
+			{ //don't bother if we're just tapping into solidity, we'll probably recover on our own
+				centity_t *cent = &cg_entities[callData->entNum];
+				vec3_t slideDir;
+
+				VectorSubtract(cent->lerpOrigin, callData->bonePos, slideDir);
+				VectorAdd(cent->ragOffsets, slideDir, cent->ragOffsets);
+
+				cent->hasRagOffset = qtrue;
+			}
+		}
+#endif
+		break;
+	case RAG_CALLBACK_TRACELINE:
+		{
+			ragCallbackTraceLine_t *callData = (ragCallbackTraceLine_t *)cg.sharedBuffer;
+
+			CG_Trace(&callData->tr, callData->start, callData->mins, callData->maxs,
+				callData->end, callData->ignore, callData->mask);
+		}
+		break;
+	default:
+		Com_Error(ERR_DROP, "Invalid callType in CG_RagCallback");
+		break;
+	}
+
+	return 0;
+}
+
+static void C_ImpactMark(void)
+{
+	TCGImpactMark	*data = (TCGImpactMark *)cg.sharedBuffer;
+
+	/*
+	CG_ImpactMark((int)arg0, (const float *)arg1, (const float *)arg2, (float)arg3,
+		(float)arg4, (float)arg5, (float)arg6, (float)arg7, qtrue, (float)arg8, qfalse);
+	*/
+	CG_ImpactMark(data->mHandle, data->mPoint, data->mAngle, data->mRotation,
+		data->mRed, data->mGreen, data->mBlue, data->mAlphaStart, qtrue, data->mSizeStart, qfalse);
+}
+
+void CG_MiscEnt(void)
+{
+	int			modelIndex;
+	refEntity_t	*RefEnt;
+	TCGMiscEnt	*data = (TCGMiscEnt *)cg.sharedBuffer;
+	vec3_t		mins, maxs;
+	float		*radius, *zOff;
+
+	if (NumMiscEnts >= MAX_MISC_ENTS)
+	{
+		return;
+	}
+	
+	radius = &Radius[NumMiscEnts];
+	zOff = &zOffset[NumMiscEnts];
+	RefEnt = &MiscEnts[NumMiscEnts++];
+
+	modelIndex = trap_R_RegisterModel(data->mModel);
+	if (modelIndex == 0)
+	{
+		Com_Error(ERR_DROP, "client_model has invalid model definition");
+		return;
+	}
+
+	*zOff = 0;
+
+	memset(RefEnt, 0, sizeof(refEntity_t));
+	RefEnt->reType = RT_MODEL;
+	RefEnt->hModel = modelIndex;
+	RefEnt->frame = 0;
+	trap_R_ModelBounds(modelIndex, mins, maxs);
+	VectorCopy(data->mScale, RefEnt->modelScale);
+	VectorCopy(data->mOrigin, RefEnt->origin);
+
+	VectorScaleVector(mins, data->mScale, mins);
+	VectorScaleVector(maxs, data->mScale, maxs);
+	*radius = Distance(mins, maxs);
+
+	AnglesToAxis( data->mAngles, RefEnt->axis );
+	ScaleModelAxis(RefEnt);
+}
+
+void CG_DrawMiscEnts(void)
+{
+	int			i;
+	refEntity_t	*RefEnt;
+	float		*radius, *zOff;
+	vec3_t		difference;
+	vec3_t		cullOrigin;
+
+	RefEnt = MiscEnts;
+	radius = Radius;
+	zOff = zOffset;
+	for(i=0;i<NumMiscEnts;i++)
+	{
+		VectorCopy(RefEnt->origin, cullOrigin);
+		cullOrigin[2] += 1.0f;
+
+		if (*zOff)
+		{
+			cullOrigin[2] += *zOff;
+		}
+
+		if (cg.snap && trap_R_inPVS(cg.refdef.vieworg, cullOrigin, cg.snap->areamask))
+		{
+			VectorSubtract(RefEnt->origin, cg.refdef.vieworg, difference);
+			if (VectorLength(difference)-(*radius) <= cg.distanceCull)
+			{
+				trap_R_AddRefEntityToScene(RefEnt);
+			}
+		}
+		RefEnt++;
+		radius++;
+		zOff++;
+	}
+}
+
+/*
+Ghoul2 Insert Start
+*/
+/*
+void CG_ResizeG2Bolt(boltInfo_v *bolt, int newCount)
+{
+	bolt->resize(newCount);
+}
+
+void CG_ResizeG2Surface(surfaceInfo_v *surface, int newCount)
+{
+	surface->resize(newCount);
+}
+
+void CG_ResizeG2Bone(boneInfo_v *bone, int newCount)
+{
+	bone->resize(newCount);
+}
+
+void CG_ResizeG2(CGhoul2Info_v *ghoul2, int newCount)
+{
+	ghoul2->resize(newCount);
+}
+
+void CG_ResizeG2TempBone(mdxaBone_v *tempBone, int newCount)
+{
+	tempBone->resize(newCount);
+}
+*/
+/*
+Ghoul2 Insert End
+*/
+cg_t				cg;
+cgs_t				cgs;
+centity_t			cg_entities[MAX_GENTITIES];
+
+centity_t			*cg_permanents[MAX_GENTITIES]; //rwwRMG - added
+int					cg_numpermanents = 0;
+
+weaponInfo_t		cg_weapons[MAX_WEAPONS];
+itemInfo_t			cg_items[MAX_ITEMS];
+
+
+vmCvar_t	cg_centertime;
+vmCvar_t	cg_runpitch;
+vmCvar_t	cg_runroll;
+vmCvar_t	cg_bobup;
+vmCvar_t	cg_bobpitch;
+vmCvar_t	cg_bobroll;
+//vmCvar_t	cg_swingSpeed;
+vmCvar_t	cg_shadows;
+vmCvar_t	cg_renderToTextureFX;
+vmCvar_t	cg_drawTimer;
+vmCvar_t	cg_drawFPS;
+vmCvar_t	cg_drawSnapshot;
+vmCvar_t	cg_draw3dIcons;
+vmCvar_t	cg_drawIcons;
+vmCvar_t	cg_drawAmmoWarning;
+vmCvar_t	cg_drawCrosshair;
+vmCvar_t	cg_drawCrosshairNames;
+vmCvar_t	cg_drawRadar;
+vmCvar_t	cg_dynamicCrosshair;
+vmCvar_t	cg_dynamicCrosshairPrecision;
+vmCvar_t	cg_drawRewards;
+vmCvar_t	cg_drawScores;
+vmCvar_t	cg_crosshairSize;
+vmCvar_t	cg_crosshairX;
+vmCvar_t	cg_crosshairY;
+vmCvar_t	cg_crosshairHealth;
+vmCvar_t	cg_draw2D;
+vmCvar_t	cg_drawStatus;
+vmCvar_t	cg_animSpeed;
+vmCvar_t	cg_debugAnim;
+vmCvar_t	cg_debugSaber;
+vmCvar_t	cg_debugPosition;
+vmCvar_t	cg_debugEvents;
+vmCvar_t	cg_errorDecay;
+vmCvar_t	cg_nopredict;
+vmCvar_t	cg_noPlayerAnims;
+vmCvar_t	cg_showmiss;
+vmCvar_t	cg_showVehMiss;
+vmCvar_t	cg_footsteps;
+vmCvar_t	cg_addMarks;
+vmCvar_t	cg_viewsize;
+vmCvar_t	cg_drawGun;
+vmCvar_t	cg_gun_frame;
+vmCvar_t	cg_gun_x;
+vmCvar_t	cg_gun_y;
+vmCvar_t	cg_gun_z;
+vmCvar_t	cg_autoswitch;
+vmCvar_t	cg_ignore;
+vmCvar_t	cg_simpleItems;
+vmCvar_t	cg_fov;
+vmCvar_t	cg_zoomFov;
+
+vmCvar_t	cg_swingAngles;
+
+vmCvar_t	cg_oldPainSounds;
+
+vmCvar_t	cg_ragDoll;
+
+vmCvar_t	cg_jumpSounds;
+
+vmCvar_t	cg_autoMap;
+vmCvar_t	cg_autoMapX;
+vmCvar_t	cg_autoMapY;
+vmCvar_t	cg_autoMapW;
+vmCvar_t	cg_autoMapH;
+
+#ifndef _XBOX	// Hmmm. This is also in game. I think this is safe.
+vmCvar_t	bg_fighterAltControl;
+#endif
+
+vmCvar_t	cg_chatBox;
+vmCvar_t	cg_chatBoxHeight;
+
+vmCvar_t	cg_saberModelTraceEffect;
+
+vmCvar_t	cg_saberClientVisualCompensation;
+
+vmCvar_t	cg_g2TraceLod;
+
+vmCvar_t	cg_fpls;
+
+vmCvar_t	cg_ghoul2Marks;
+
+vmCvar_t	cg_saberDynamicMarks;
+vmCvar_t	cg_saberDynamicMarkTime;
+
+vmCvar_t	cg_saberContact;
+vmCvar_t	cg_saberTrail;
+
+vmCvar_t	cg_duelHeadAngles;
+
+vmCvar_t	cg_speedTrail;
+vmCvar_t	cg_auraShell;
+
+vmCvar_t	cg_repeaterOrb;
+
+vmCvar_t	cg_animBlend;
+
+vmCvar_t	cg_dismember;
+
+vmCvar_t	cg_thirdPersonSpecialCam;
+
+vmCvar_t	cg_thirdPerson;
+vmCvar_t	cg_thirdPersonRange;
+vmCvar_t	cg_thirdPersonAngle;
+vmCvar_t	cg_thirdPersonPitchOffset;
+vmCvar_t	cg_thirdPersonVertOffset;
+vmCvar_t	cg_thirdPersonCameraDamp;
+vmCvar_t	cg_thirdPersonTargetDamp;
+
+vmCvar_t	cg_thirdPersonAlpha;
+vmCvar_t	cg_thirdPersonHorzOffset;
+
+vmCvar_t	cg_stereoSeparation;
+vmCvar_t	cg_lagometer;
+vmCvar_t	cg_drawEnemyInfo;
+vmCvar_t	cg_synchronousClients;
+vmCvar_t 	cg_stats;
+vmCvar_t 	cg_buildScript;
+vmCvar_t 	cg_forceModel;
+vmCvar_t	cg_paused;
+vmCvar_t	cg_blood;
+vmCvar_t	cg_predictItems;
+vmCvar_t	cg_deferPlayers;
+vmCvar_t	cg_drawTeamOverlay;
+vmCvar_t	cg_teamOverlayUserinfo;
+vmCvar_t	cg_drawFriend;
+vmCvar_t	cg_teamChatsOnly;
+vmCvar_t	cg_hudFiles;
+vmCvar_t 	cg_scorePlum;
+vmCvar_t 	cg_smoothClients;
+
+#include "../namespace_begin.h"
+vmCvar_t	pmove_fixed;
+//vmCvar_t	cg_pmove_fixed;
+vmCvar_t	pmove_msec;
+// nmckenzie: DUEL_HEALTH
+vmCvar_t	g_showDuelHealths;
+#include "../namespace_end.h"
+
+vmCvar_t	cg_pmove_msec;
+vmCvar_t	cg_cameraMode;
+vmCvar_t	cg_cameraOrbit;
+vmCvar_t	cg_cameraOrbitDelay;
+vmCvar_t	cg_timescaleFadeEnd;
+vmCvar_t	cg_timescaleFadeSpeed;
+vmCvar_t	cg_timescale;
+vmCvar_t	cg_noTaunt;
+vmCvar_t	cg_noProjectileTrail;
+vmCvar_t	cg_trueLightning;
+/*
+Ghoul2 Insert Start
+*/
+vmCvar_t	cg_debugBB;
+/*
+Ghoul2 Insert End
+*/
+vmCvar_t 	cg_redTeamName;
+vmCvar_t 	cg_blueTeamName;
+vmCvar_t	cg_currentSelectedPlayer;
+vmCvar_t	cg_currentSelectedPlayerName;
+vmCvar_t	cg_singlePlayer;
+vmCvar_t	cg_enableDust;
+vmCvar_t	cg_enableBreath;
+vmCvar_t	cg_singlePlayerActive;
+vmCvar_t	cg_recordSPDemo;
+vmCvar_t	cg_recordSPDemoName;
+vmCvar_t	cg_showVehBounds;
+
+vmCvar_t	ui_myteam;
+
+vmCvar_t	cg_snapshotTimeout;
+
+typedef struct {
+	vmCvar_t	*vmCvar;
+	char		*cvarName;
+	char		*defaultString;
+	int			cvarFlags;
+} cvarTable_t;
+
+static cvarTable_t cvarTable[] = { // bk001129
+	{ &cg_ignore, "cg_ignore", "0", 0 },	// used for debugging
+	{ &cg_autoswitch, "cg_autoswitch", "1", CVAR_ARCHIVE },
+	{ &cg_drawGun, "cg_drawGun", "1", CVAR_ARCHIVE },
+	{ &cg_zoomFov, "cg_zoomfov", "40.0", CVAR_ARCHIVE },
+	{ &cg_fov, "cg_fov", "80", CVAR_ARCHIVE },
+	{ &cg_viewsize, "cg_viewsize", "100", CVAR_ARCHIVE },
+	{ &cg_stereoSeparation, "cg_stereoSeparation", "0.4", CVAR_ARCHIVE  },
+	{ &cg_shadows, "cg_shadows", "1", CVAR_ARCHIVE  },
+	{ &cg_renderToTextureFX, "cg_renderToTextureFX", "1", CVAR_ARCHIVE  },
+	{ &cg_draw2D, "cg_draw2D", "1", CVAR_ARCHIVE  },
+	{ &cg_drawStatus, "cg_drawStatus", "1", CVAR_ARCHIVE  },
+	{ &cg_drawTimer, "cg_drawTimer", "0", CVAR_ARCHIVE  },
+	{ &cg_drawFPS, "cg_drawFPS", "0", CVAR_ARCHIVE  },
+	{ &cg_drawSnapshot, "cg_drawSnapshot", "0", CVAR_ARCHIVE  },
+	{ &cg_draw3dIcons, "cg_draw3dIcons", "1", CVAR_ARCHIVE  },
+	{ &cg_drawIcons, "cg_drawIcons", "1", CVAR_ARCHIVE  },
+	{ &cg_drawAmmoWarning, "cg_drawAmmoWarning", "0", CVAR_ARCHIVE  },
+	{ &cg_drawEnemyInfo, "cg_drawEnemyInfo", "1", CVAR_ARCHIVE  },
+	{ &cg_drawCrosshair, "cg_drawCrosshair", "1", CVAR_ARCHIVE },
+	{ &cg_drawCrosshairNames, "cg_drawCrosshairNames", "1", CVAR_ARCHIVE },
+	{ &cg_drawRadar, "cg_drawRadar", "1", CVAR_ARCHIVE },
+	{ &cg_drawScores,		  "cg_drawScores", "1", CVAR_ARCHIVE },
+	{ &cg_dynamicCrosshair, "cg_dynamicCrosshair", "1", CVAR_ARCHIVE },
+	//Enables ghoul2 traces for crosshair traces.. more precise when pointing at others, but slower.
+	//And if the server doesn't have g2 col enabled, it won't match up the same.
+	{ &cg_dynamicCrosshairPrecision, "cg_dynamicCrosshairPrecision", "1", CVAR_ARCHIVE },
+	{ &cg_drawRewards, "cg_drawRewards", "1", CVAR_ARCHIVE },
+	{ &cg_crosshairSize, "cg_crosshairSize", "24", CVAR_ARCHIVE },
+	{ &cg_crosshairHealth, "cg_crosshairHealth", "0", CVAR_ARCHIVE },
+	{ &cg_crosshairX, "cg_crosshairX", "0", CVAR_ARCHIVE },
+	{ &cg_crosshairY, "cg_crosshairY", "0", CVAR_ARCHIVE },
+	{ &cg_simpleItems, "cg_simpleItems", "0", CVAR_ARCHIVE },
+	{ &cg_addMarks, "cg_marks", "1", CVAR_ARCHIVE },
+	{ &cg_lagometer, "cg_lagometer", "0", CVAR_ARCHIVE },
+	{ &cg_gun_x, "cg_gunX", "0", CVAR_CHEAT },
+	{ &cg_gun_y, "cg_gunY", "0", CVAR_CHEAT },
+	{ &cg_gun_z, "cg_gunZ", "0", CVAR_CHEAT },
+	{ &cg_centertime, "cg_centertime", "3", CVAR_CHEAT },
+	{ &cg_runpitch, "cg_runpitch", "0.002", CVAR_ARCHIVE},
+	{ &cg_runroll, "cg_runroll", "0.005", CVAR_ARCHIVE },
+	{ &cg_bobup , "cg_bobup", "0.005", CVAR_ARCHIVE },
+	{ &cg_bobpitch, "cg_bobpitch", "0.002", CVAR_ARCHIVE },
+	{ &cg_bobroll, "cg_bobroll", "0.002", CVAR_ARCHIVE },
+	//{ &cg_swingSpeed, "cg_swingSpeed", "0.3", CVAR_CHEAT },
+	{ &cg_animSpeed, "cg_animspeed", "1", CVAR_CHEAT },
+	{ &cg_debugAnim, "cg_debuganim", "0", CVAR_CHEAT },
+	{ &cg_debugSaber, "cg_debugsaber", "0", CVAR_CHEAT },
+	{ &cg_debugPosition, "cg_debugposition", "0", CVAR_CHEAT },
+	{ &cg_debugEvents, "cg_debugevents", "0", CVAR_CHEAT },
+	{ &cg_errorDecay, "cg_errordecay", "100", 0 },
+	{ &cg_nopredict, "cg_nopredict", "0", 0 },
+	{ &cg_noPlayerAnims, "cg_noplayeranims", "0", CVAR_CHEAT },
+	{ &cg_showmiss, "cg_showmiss", "0", 0 },
+	{ &cg_showVehMiss, "cg_showVehMiss", "0", 0 },
+	{ &cg_footsteps, "cg_footsteps", "3", CVAR_ARCHIVE },
+	{ &cg_swingAngles, "cg_swingAngles", "1", 0 },
+
+	{ &cg_oldPainSounds, "cg_oldPainSounds", "0", 0 },
+
+	{ &cg_ragDoll, "broadsword", "0", 0 },
+
+	{ &cg_jumpSounds, "cg_jumpSounds", "0", 0 },
+
+	{ &cg_autoMap, "r_autoMap", "0", CVAR_ARCHIVE },
+	{ &cg_autoMapX, "r_autoMapX", "496", CVAR_ARCHIVE },
+	{ &cg_autoMapY, "r_autoMapY", "32", CVAR_ARCHIVE },
+	{ &cg_autoMapW, "r_autoMapW", "128", CVAR_ARCHIVE },
+	{ &cg_autoMapH, "r_autoMapH", "128", CVAR_ARCHIVE },
+
+	{ &bg_fighterAltControl, "bg_fighterAltControl", "0", CVAR_SERVERINFO },
+
+	{ &cg_chatBox, "cg_chatBox", "10000", CVAR_ARCHIVE },
+	{ &cg_chatBoxHeight, "cg_chatBoxHeight", "350", CVAR_ARCHIVE },
+
+	{ &cg_saberModelTraceEffect, "cg_saberModelTraceEffect", "0", 0 },
+
+	//allows us to trace between server frames on the client to see if we're visually
+	//hitting the last entity we detected a hit on from the server.
+	{ &cg_saberClientVisualCompensation, "cg_saberClientVisualCompensation", "1", 0 },
+
+	{ &cg_g2TraceLod, "cg_g2TraceLod", "2", 0 },
+
+	{ &cg_fpls, "cg_fpls", "0", 0 },
+
+	{ &cg_ghoul2Marks, "cg_ghoul2Marks", "16", 0 },
+
+	{ &cg_saberDynamicMarks, "cg_saberDynamicMarks", "0", 0 },
+	{ &cg_saberDynamicMarkTime, "cg_saberDynamicMarkTime", "60000", 0 },
+
+	{ &cg_saberContact, "cg_saberContact", "1", 0 },
+	{ &cg_saberTrail, "cg_saberTrail", "1", 0 },
+
+	{ &cg_duelHeadAngles, "cg_duelHeadAngles", "0", 0 },
+
+	{ &cg_speedTrail, "cg_speedTrail", "1", 0 },
+	{ &cg_auraShell, "cg_auraShell", "1", 0 },
+
+	{ &cg_repeaterOrb, "cg_repeaterOrb", "0", 0 },
+
+	{ &cg_animBlend, "cg_animBlend", "1", 0 },
+
+	{ &cg_dismember, "cg_dismember", "0", CVAR_ARCHIVE },
+
+	{ &cg_thirdPersonSpecialCam, "cg_thirdPersonSpecialCam", "0", 0 },
+
+	{ &cg_thirdPerson, "cg_thirdPerson", "0", CVAR_ARCHIVE },
+	{ &cg_thirdPersonRange, "cg_thirdPersonRange", "80", CVAR_CHEAT },
+	{ &cg_thirdPersonAngle, "cg_thirdPersonAngle", "0", CVAR_CHEAT },
+	{ &cg_thirdPersonPitchOffset, "cg_thirdPersonPitchOffset", "0", CVAR_CHEAT },
+	{ &cg_thirdPersonVertOffset, "cg_thirdPersonVertOffset", "16", CVAR_CHEAT },
+	{ &cg_thirdPersonCameraDamp, "cg_thirdPersonCameraDamp", "0.3", 0 },
+	{ &cg_thirdPersonTargetDamp, "cg_thirdPersonTargetDamp", "0.5", CVAR_CHEAT },
+	
+	{ &cg_thirdPersonHorzOffset, "cg_thirdPersonHorzOffset", "0", CVAR_CHEAT },
+	{ &cg_thirdPersonAlpha,	"cg_thirdPersonAlpha",	"1.0", CVAR_CHEAT },
+
+	{ &cg_forceModel, "cg_forceModel", "0", CVAR_ARCHIVE  },
+	{ &cg_predictItems, "cg_predictItems", "1", CVAR_ARCHIVE },
+	{ &cg_deferPlayers, "cg_deferPlayers", "1", CVAR_ARCHIVE },
+	{ &cg_drawTeamOverlay, "cg_drawTeamOverlay", "0", CVAR_ARCHIVE },
+	{ &cg_teamOverlayUserinfo, "teamoverlay", "0", CVAR_ROM | CVAR_USERINFO },
+	{ &cg_stats, "cg_stats", "0", 0 },
+	{ &cg_drawFriend, "cg_drawFriend", "1", CVAR_ARCHIVE },
+	{ &cg_teamChatsOnly, "cg_teamChatsOnly", "0", CVAR_ARCHIVE },
+	// the following variables are created in other parts of the system,
+	// but we also reference them here
+	{ &cg_buildScript, "com_buildScript", "0", 0 },	// force loading of all possible data amd error on failures
+	{ &cg_paused, "cl_paused", "0", CVAR_ROM },
+	{ &cg_blood, "com_blood", "1", CVAR_ARCHIVE },
+	{ &cg_synchronousClients, "g_synchronousClients", "0", 0 },	// communicated by systeminfo
+
+	{ &cg_redTeamName, "g_redteam", DEFAULT_REDTEAM_NAME, CVAR_ARCHIVE | CVAR_SERVERINFO | CVAR_USERINFO },
+	{ &cg_blueTeamName, "g_blueteam", DEFAULT_BLUETEAM_NAME, CVAR_ARCHIVE | CVAR_SERVERINFO | CVAR_USERINFO },
+	{ &cg_currentSelectedPlayer, "cg_currentSelectedPlayer", "0", CVAR_ARCHIVE},
+	{ &cg_currentSelectedPlayerName, "cg_currentSelectedPlayerName", "", CVAR_ARCHIVE},
+	{ &cg_singlePlayer, "ui_singlePlayerActive", "0", CVAR_USERINFO},
+	{ &cg_enableDust, "g_enableDust", "0", 0},
+	{ &cg_enableBreath, "g_enableBreath", "0", 0},
+	{ &cg_singlePlayerActive, "ui_singlePlayerActive", "0", CVAR_USERINFO},
+	{ &cg_recordSPDemo, "ui_recordSPDemo", "0", CVAR_ARCHIVE},
+	{ &cg_recordSPDemoName, "ui_recordSPDemoName", "", CVAR_ARCHIVE},
+
+	{ &cg_cameraOrbit, "cg_cameraOrbit", "0", CVAR_CHEAT},
+	{ &cg_cameraOrbitDelay, "cg_cameraOrbitDelay", "50", CVAR_ARCHIVE},
+	{ &cg_timescaleFadeEnd, "cg_timescaleFadeEnd", "1", 0},
+	{ &cg_timescaleFadeSpeed, "cg_timescaleFadeSpeed", "0", 0},
+	{ &cg_timescale, "timescale", "1", 0},
+	{ &cg_scorePlum, "cg_scorePlums", "1", CVAR_USERINFO | CVAR_ARCHIVE},
+	{ &cg_hudFiles, "cg_hudFiles", "ui/jahud.txt", CVAR_USERINFO | CVAR_ARCHIVE},
+	{ &cg_smoothClients, "cg_smoothClients", "1", CVAR_USERINFO | CVAR_ARCHIVE},
+	{ &cg_cameraMode, "com_cameraMode", "0", CVAR_CHEAT},
+
+	{ &pmove_fixed, "pmove_fixed", "0", 0},
+	{ &pmove_msec, "pmove_msec", "8", 0},
+	{ &cg_noTaunt, "cg_noTaunt", "0", CVAR_ARCHIVE},
+	{ &cg_noProjectileTrail, "cg_noProjectileTrail", "0", CVAR_ARCHIVE},
+	{ &cg_trueLightning, "cg_trueLightning", "0.0", CVAR_ARCHIVE},
+	{ &cg_showVehBounds, "cg_showVehBounds", "0", 0},
+
+	{ &ui_myteam, "ui_myteam", "0", CVAR_ROM|CVAR_INTERNAL},
+	{ &cg_snapshotTimeout, "cg_snapshotTimeout", "10", CVAR_ARCHIVE },
+
+//	{ &cg_pmove_fixed, "cg_pmove_fixed", "0", CVAR_USERINFO | CVAR_ARCHIVE }
+/*
+Ghoul2 Insert Start
+*/
+	{ &cg_debugBB, "debugBB", "0", 0},
+/*
+Ghoul2 Insert End
+*/
+};
+
+static int  cvarTableSize = sizeof( cvarTable ) / sizeof( cvarTable[0] );
+
+/*
+=================
+CG_RegisterCvars
+=================
+*/
+void CG_RegisterCvars( void ) {
+	int			i;
+	cvarTable_t	*cv;
+	char		var[MAX_TOKEN_CHARS];
+
+	for ( i = 0, cv = cvarTable ; i < cvarTableSize ; i++, cv++ ) {
+		trap_Cvar_Register( cv->vmCvar, cv->cvarName,
+			cv->defaultString, cv->cvarFlags );
+	}
+
+	// see if we are also running the server on this machine
+	trap_Cvar_VariableStringBuffer( "sv_running", var, sizeof( var ) );
+	cgs.localServer = atoi( var );
+
+	forceModelModificationCount = cg_forceModel.modificationCount;
+
+	trap_Cvar_Register(NULL, "model", DEFAULT_MODEL, CVAR_USERINFO | CVAR_ARCHIVE );
+	trap_Cvar_Register(NULL, "forcepowers", DEFAULT_FORCEPOWERS, CVAR_USERINFO | CVAR_ARCHIVE );
+
+	// Cvars uses for transferring data between client and server
+	trap_Cvar_Register(NULL, "ui_about_gametype",		"0", CVAR_ROM|CVAR_INTERNAL );
+	trap_Cvar_Register(NULL, "ui_about_fraglimit",		"0", CVAR_ROM|CVAR_INTERNAL );
+	trap_Cvar_Register(NULL, "ui_about_capturelimit",	"0", CVAR_ROM|CVAR_INTERNAL );
+	trap_Cvar_Register(NULL, "ui_about_duellimit",		"0", CVAR_ROM|CVAR_INTERNAL );
+	trap_Cvar_Register(NULL, "ui_about_timelimit",		"0", CVAR_ROM|CVAR_INTERNAL );
+	trap_Cvar_Register(NULL, "ui_about_maxclients",		"0", CVAR_ROM|CVAR_INTERNAL );
+	trap_Cvar_Register(NULL, "ui_about_dmflags",		"0", CVAR_ROM|CVAR_INTERNAL );
+	trap_Cvar_Register(NULL, "ui_about_mapname",		"0", CVAR_ROM|CVAR_INTERNAL );
+	trap_Cvar_Register(NULL, "ui_about_hostname",		"0", CVAR_ROM|CVAR_INTERNAL );
+	trap_Cvar_Register(NULL, "ui_about_needpass",		"0", CVAR_ROM|CVAR_INTERNAL );
+	trap_Cvar_Register(NULL, "ui_about_botminplayers",	"0", CVAR_ROM|CVAR_INTERNAL );
+
+	trap_Cvar_Register(NULL, "ui_tm1_cnt", "0", CVAR_ROM | CVAR_INTERNAL );
+	trap_Cvar_Register(NULL, "ui_tm2_cnt", "0", CVAR_ROM | CVAR_INTERNAL );
+	trap_Cvar_Register(NULL, "ui_tm3_cnt", "0", CVAR_ROM | CVAR_INTERNAL );
+
+	trap_Cvar_Register(NULL, "ui_tm1_c0_cnt", "0", CVAR_ROM | CVAR_INTERNAL );
+	trap_Cvar_Register(NULL, "ui_tm1_c1_cnt", "0", CVAR_ROM | CVAR_INTERNAL );
+	trap_Cvar_Register(NULL, "ui_tm1_c2_cnt", "0", CVAR_ROM | CVAR_INTERNAL );
+	trap_Cvar_Register(NULL, "ui_tm1_c3_cnt", "0", CVAR_ROM | CVAR_INTERNAL );
+	trap_Cvar_Register(NULL, "ui_tm1_c4_cnt", "0", CVAR_ROM | CVAR_INTERNAL );
+	trap_Cvar_Register(NULL, "ui_tm1_c5_cnt", "0", CVAR_ROM | CVAR_INTERNAL );
+
+	trap_Cvar_Register(NULL, "ui_tm2_c0_cnt", "0", CVAR_ROM | CVAR_INTERNAL );
+	trap_Cvar_Register(NULL, "ui_tm2_c1_cnt", "0", CVAR_ROM | CVAR_INTERNAL );
+	trap_Cvar_Register(NULL, "ui_tm2_c2_cnt", "0", CVAR_ROM | CVAR_INTERNAL );
+	trap_Cvar_Register(NULL, "ui_tm2_c3_cnt", "0", CVAR_ROM | CVAR_INTERNAL );
+	trap_Cvar_Register(NULL, "ui_tm2_c4_cnt", "0", CVAR_ROM | CVAR_INTERNAL );
+	trap_Cvar_Register(NULL, "ui_tm2_c5_cnt", "0", CVAR_ROM | CVAR_INTERNAL );
+
+}
+
+/*																																			
+===================
+CG_SetWeatherOverride
+===================
+*/
+#if 0
+void CG_SetWeatherOverride(int contents)
+{
+	if (contents != cgWeatherOverride)
+	{ //only do the trap call if we aren't already set to this
+		trap_R_WeatherContentsOverride(contents);
+	}
+	cgWeatherOverride = contents; //keep track of it
+}
+#endif
+
+/*																																			
+===================
+CG_ForceModelChange
+===================
+*/
+static void CG_ForceModelChange( void ) {
+	int		i;
+
+	for (i=0 ; i<MAX_CLIENTS ; i++) {
+		const char		*clientInfo;
+		void	*oldGhoul2;
+
+		clientInfo = CG_ConfigString( CS_PLAYERS+i );
+		if ( !clientInfo[0] ) {
+			continue;
+		}
+
+		oldGhoul2 = cgs.clientinfo[i].ghoul2Model;
+		CG_NewClientInfo( i, qtrue);
+	}
+}
+
+/*
+=================
+CG_UpdateCvars
+=================
+*/
+void CG_UpdateCvars( void ) {
+	int			i;
+	cvarTable_t	*cv;
+	static int drawTeamOverlayModificationCount = -1;
+
+	for ( i = 0, cv = cvarTable ; i < cvarTableSize ; i++, cv++ ) {
+		trap_Cvar_Update( cv->vmCvar );
+	}
+
+	// check for modications here
+
+	// If team overlay is on, ask for updates from the server.  If its off,
+	// let the server know so we don't receive it
+	if ( drawTeamOverlayModificationCount != cg_drawTeamOverlay.modificationCount ) {
+		drawTeamOverlayModificationCount = cg_drawTeamOverlay.modificationCount;
+
+		if ( cg_drawTeamOverlay.integer > 0 ) {
+			trap_Cvar_Set( "teamoverlay", "1" );
+		} else {
+			trap_Cvar_Set( "teamoverlay", "0" );
+		}
+		// FIXME E3 HACK
+		trap_Cvar_Set( "teamoverlay", "1" );
+	}
+
+	// if force model changed
+	if ( forceModelModificationCount != cg_forceModel.modificationCount ) {
+		forceModelModificationCount = cg_forceModel.modificationCount;
+		CG_ForceModelChange();
+	}
+}
+
+int CG_CrosshairPlayer( void ) {
+	if ( cg.time > ( cg.crosshairClientTime + 1000 ) ) {
+		return -1;
+	}
+
+	if (cg.crosshairClientNum >= MAX_CLIENTS)
+	{
+		return -1;
+	}
+
+	return cg.crosshairClientNum;
+}
+
+int CG_LastAttacker( void ) {
+	if ( !cg.attackerTime ) {
+		return -1;
+	}
+	return cg.snap->ps.persistant[PERS_ATTACKER];
+}
+
+void QDECL CG_Printf( const char *msg, ... ) {
+	va_list		argptr;
+	char		text[1024];
+
+	va_start (argptr, msg);
+	vsprintf (text, msg, argptr);
+	va_end (argptr);
+
+	trap_Print( text );
+}
+
+void QDECL CG_Error( const char *msg, ... ) {
+	va_list		argptr;
+	char		text[1024];
+
+	va_start (argptr, msg);
+	vsprintf (text, msg, argptr);
+	va_end (argptr);
+
+	trap_Error( text );
+}
+
+#ifndef CGAME_HARD_LINKED
+// this is only here so the functions in q_shared.c and bg_*.c can link (FIXME)
+
+void QDECL Com_Error( int level, const char *error, ... ) {
+	va_list		argptr;
+	char		text[1024];
+
+	va_start (argptr, error);
+	vsprintf (text, error, argptr);
+	va_end (argptr);
+
+	CG_Error( "%s", text);
+}
+
+void QDECL Com_Printf( const char *msg, ... ) {
+	va_list		argptr;
+	char		text[1024];
+
+	va_start (argptr, msg);
+	vsprintf (text, msg, argptr);
+	va_end (argptr);
+
+	CG_Printf ("%s", text);
+}
+
+#endif
+
+/*
+================
+CG_Argv
+================
+*/
+const char *CG_Argv( int arg ) {
+	static char	buffer[MAX_STRING_CHARS];
+
+	trap_Argv( arg, buffer, sizeof( buffer ) );
+
+	return buffer;
+}
+
+
+//========================================================================
+
+//so shared code can get the local time depending on the side it's executed on
+#include "../namespace_begin.h"
+int BG_GetTime(void)
+{
+	return cg.time;
+}
+#include "../namespace_end.h"
+
+/*
+=================
+CG_RegisterItemSounds
+
+The server says this item is used on this level
+=================
+*/
+static void CG_RegisterItemSounds( int itemNum ) {
+	gitem_t			*item;
+	char			data[MAX_QPATH];
+	char			*s, *start;
+	int				len;
+
+	item = &bg_itemlist[ itemNum ];
+
+	if( item->pickup_sound ) {
+		trap_S_RegisterSound( item->pickup_sound );
+	}
+
+	// parse the space seperated precache string for other media
+	s = item->sounds;
+	if (!s || !s[0])
+		return;
+
+	while (*s) {
+		start = s;
+		while (*s && *s != ' ') {
+			s++;
+		}
+
+		len = s-start;
+		if (len >= MAX_QPATH || len < 5) {
+			CG_Error( "PrecacheItem: %s has bad precache string", 
+				item->classname);
+			return;
+		}
+		memcpy (data, start, len);
+		data[len] = 0;
+		if ( *s ) {
+			s++;
+		}
+
+		trap_S_RegisterSound( data );
+	}
+
+	// parse the space seperated precache string for other media
+	s = item->precaches;
+	if (!s || !s[0])
+		return;
+
+	while (*s) {
+		start = s;
+		while (*s && *s != ' ') {
+			s++;
+		}
+
+		len = s-start;
+		if (len >= MAX_QPATH || len < 5) {
+			CG_Error( "PrecacheItem: %s has bad precache string", 
+				item->classname);
+			return;
+		}
+		memcpy (data, start, len);
+		data[len] = 0;
+		if ( *s ) {
+			s++;
+		}
+
+		if ( !strcmp(data+len-3, "efx" )) {
+			trap_FX_RegisterEffect( data );
+		}
+	}
+}
+
+static void CG_AS_Register(void)
+{
+	const char *soundName;
+	int i;
+
+//	CG_LoadingString( "ambient sound sets" );
+
+	//Load the ambient sets
+#if 0 //as_preCacheMap was game-side.. that is evil.
+	trap_AS_AddPrecacheEntry( "#clear" );	// ;-)
+	//FIXME: Don't ask... I had to get around a really nasty MS error in the templates with this...
+	namePrecache_m::iterator	pi;
+	STL_ITERATE( pi, as_preCacheMap )
+	{
+		cgi_AS_AddPrecacheEntry( ((*pi).first).c_str() );
+	}
+#else
+	trap_AS_AddPrecacheEntry( "#clear" );
+
+	for ( i = 1 ; i < MAX_AMBIENT_SETS ; i++ ) {
+		soundName = CG_ConfigString( CS_AMBIENT_SET+i );
+		if ( !soundName || !soundName[0] )
+		{
+			break;
+		}
+
+		trap_AS_AddPrecacheEntry(soundName);
+	}
+	soundName = CG_ConfigString( CS_GLOBAL_AMBIENT_SET );
+	if (soundName && soundName[0] && Q_stricmp(soundName, "default"))
+	{ //global soundset
+		trap_AS_AddPrecacheEntry(soundName);
+	}
+#endif
+
+	trap_AS_ParseSets();
+}
+
+//a global weather effect (rain, snow, etc)
+void CG_ParseWeatherEffect(const char *str)
+{
+	char *sptr = (char *)str;
+	sptr++; //pass the '*'
+	trap_R_WorldEffectCommand(sptr);
+}
+
+extern int cgSiegeRoundBeganTime;
+void CG_ParseSiegeState(const char *str)
+{
+	int i = 0;
+	int j = 0;
+//	int prevState = cgSiegeRoundState;
+	char b[1024];
+
+	while (str[i] && str[i] != '|')
+	{
+		b[j] = str[i];
+		i++;
+		j++;
+	}
+	b[j] = 0;
+	cgSiegeRoundState = atoi(b);
+
+	if (str[i] == '|')
+	{
+		j = 0;
+		i++;
+		while (str[i])
+		{
+			b[j] = str[i];
+			i++;
+			j++;
+		}
+		b[j] = 0;
+//		if (cgSiegeRoundState != prevState)
+		{ //it changed
+			cgSiegeRoundTime = atoi(b);
+			if (cgSiegeRoundState == 0 || cgSiegeRoundState == 2)
+			{
+				cgSiegeRoundBeganTime = cgSiegeRoundTime;
+			}
+		}
+	}
+	else
+	{
+	    cgSiegeRoundTime = cg.time;
+	}
+}
+
+/*
+=================
+CG_RegisterSounds
+
+called during a precache command
+=================
+*/
+void CG_PrecacheNPCSounds(const char *str);
+void CG_ParseSiegeObjectiveStatus(const char *str);
+extern int cg_beatingSiegeTime;
+extern int cg_siegeWinTeam;
+static void CG_RegisterSounds( void ) {
+	int		i;
+	char	items[MAX_ITEMS+1];
+	char	name[MAX_QPATH];
+	const char	*soundName;
+
+	CG_AS_Register();
+
+//	CG_LoadingString( "sounds" );
+
+	trap_S_RegisterSound( "sound/weapons/melee/punch1.mp3" );
+	trap_S_RegisterSound( "sound/weapons/melee/punch2.mp3" );
+	trap_S_RegisterSound( "sound/weapons/melee/punch3.mp3" );
+	trap_S_RegisterSound( "sound/weapons/melee/punch4.mp3" );
+	trap_S_RegisterSound("sound/movers/objects/saber_slam");
+
+	trap_S_RegisterSound("sound/player/bodyfall_human1.wav");
+	trap_S_RegisterSound("sound/player/bodyfall_human2.wav");
+	trap_S_RegisterSound("sound/player/bodyfall_human3.wav");
+
+	//test effects
+	trap_FX_RegisterEffect("effects/mp/test_sparks.efx");
+	trap_FX_RegisterEffect("effects/mp/test_wall_impact.efx");
+
+	cgs.media.oneMinuteSound = trap_S_RegisterSound( "sound/chars/protocol/misc/40MOM004" );
+	cgs.media.fiveMinuteSound = trap_S_RegisterSound( "sound/chars/protocol/misc/40MOM005" );
+	cgs.media.oneFragSound = trap_S_RegisterSound( "sound/chars/protocol/misc/40MOM001" );
+	cgs.media.twoFragSound = trap_S_RegisterSound( "sound/chars/protocol/misc/40MOM002" );
+	cgs.media.threeFragSound = trap_S_RegisterSound( "sound/chars/protocol/misc/40MOM003");
+	cgs.media.count3Sound = trap_S_RegisterSound( "sound/chars/protocol/misc/40MOM035" );
+	cgs.media.count2Sound = trap_S_RegisterSound( "sound/chars/protocol/misc/40MOM036" );
+	cgs.media.count1Sound = trap_S_RegisterSound( "sound/chars/protocol/misc/40MOM037" );
+	cgs.media.countFightSound = trap_S_RegisterSound( "sound/chars/protocol/misc/40MOM038" );
+
+	cgs.media.hackerIconShader			= trap_R_RegisterShaderNoMip("gfx/mp/c_icon_tech");
+
+	cgs.media.redSaberGlowShader		= trap_R_RegisterShader( "gfx/effects/sabers/red_glow" );
+	cgs.media.redSaberCoreShader		= trap_R_RegisterShader( "gfx/effects/sabers/red_line" );
+	cgs.media.orangeSaberGlowShader		= trap_R_RegisterShader( "gfx/effects/sabers/orange_glow" );
+	cgs.media.orangeSaberCoreShader		= trap_R_RegisterShader( "gfx/effects/sabers/orange_line" );
+	cgs.media.yellowSaberGlowShader		= trap_R_RegisterShader( "gfx/effects/sabers/yellow_glow" );
+	cgs.media.yellowSaberCoreShader		= trap_R_RegisterShader( "gfx/effects/sabers/yellow_line" );
+	cgs.media.greenSaberGlowShader		= trap_R_RegisterShader( "gfx/effects/sabers/green_glow" );
+	cgs.media.greenSaberCoreShader		= trap_R_RegisterShader( "gfx/effects/sabers/green_line" );
+	cgs.media.blueSaberGlowShader		= trap_R_RegisterShader( "gfx/effects/sabers/blue_glow" );
+	cgs.media.blueSaberCoreShader		= trap_R_RegisterShader( "gfx/effects/sabers/blue_line" );
+	cgs.media.purpleSaberGlowShader		= trap_R_RegisterShader( "gfx/effects/sabers/purple_glow" );
+	cgs.media.purpleSaberCoreShader		= trap_R_RegisterShader( "gfx/effects/sabers/purple_line" );
+	cgs.media.saberBlurShader			= trap_R_RegisterShader( "gfx/effects/sabers/saberBlur" );
+
+	cgs.media.forceCoronaShader			= trap_R_RegisterShaderNoMip( "gfx/hud/force_swirl" );
+
+	cgs.media.yellowDroppedSaberShader	= trap_R_RegisterShader("gfx/effects/yellow_glow");
+
+	cgs.media.rivetMarkShader			= trap_R_RegisterShader( "gfx/damage/rivetmark" );
+
+	trap_R_RegisterShader( "gfx/effects/saberFlare" );
+
+	trap_R_RegisterShader( "powerups/ysalimarishell" );
+	
+	trap_R_RegisterShader( "gfx/effects/forcePush" );
+
+	trap_R_RegisterShader( "gfx/misc/red_dmgshield" );
+	trap_R_RegisterShader( "gfx/misc/red_portashield" );
+	trap_R_RegisterShader( "gfx/misc/blue_dmgshield" );
+	trap_R_RegisterShader( "gfx/misc/blue_portashield" );
+
+	trap_R_RegisterShader( "models/map_objects/imp_mine/turret_chair_dmg.tga" );
+
+	for (i=1 ; i<9 ; i++)
+	{
+		trap_S_RegisterSound(va("sound/weapons/saber/saberhup%i.wav", i));
+	}
+
+	for (i=1 ; i<10 ; i++)
+	{
+		trap_S_RegisterSound(va("sound/weapons/saber/saberblock%i.wav", i));
+	}
+
+	for (i=1 ; i<4 ; i++)
+	{
+		trap_S_RegisterSound(va("sound/weapons/saber/bounce%i.wav", i));
+	}
+
+	trap_S_RegisterSound( "sound/weapons/saber/enemy_saber_on.wav" );
+	trap_S_RegisterSound( "sound/weapons/saber/enemy_saber_off.wav" );
+
+	trap_S_RegisterSound( "sound/weapons/saber/saberhum1.wav" );
+	trap_S_RegisterSound( "sound/weapons/saber/saberon.wav" );
+	trap_S_RegisterSound( "sound/weapons/saber/saberoffquick.wav" );
+	trap_S_RegisterSound( "sound/weapons/saber/saberhitwall1" );
+	trap_S_RegisterSound( "sound/weapons/saber/saberhitwall2" );
+	trap_S_RegisterSound( "sound/weapons/saber/saberhitwall3" );
+	trap_S_RegisterSound("sound/weapons/saber/saberhit.wav");
+	trap_S_RegisterSound("sound/weapons/saber/saberhit1.wav");
+	trap_S_RegisterSound("sound/weapons/saber/saberhit2.wav");
+	trap_S_RegisterSound("sound/weapons/saber/saberhit3.wav");
+
+	trap_S_RegisterSound("sound/weapons/saber/saber_catch.wav");
+
+	cgs.media.teamHealSound = trap_S_RegisterSound("sound/weapons/force/teamheal.wav");
+	cgs.media.teamRegenSound = trap_S_RegisterSound("sound/weapons/force/teamforce.wav");
+
+	trap_S_RegisterSound("sound/weapons/force/heal.wav");
+	trap_S_RegisterSound("sound/weapons/force/speed.wav");
+	trap_S_RegisterSound("sound/weapons/force/see.wav");
+	trap_S_RegisterSound("sound/weapons/force/rage.wav");
+	trap_S_RegisterSound("sound/weapons/force/lightning");
+	trap_S_RegisterSound("sound/weapons/force/lightninghit1");
+	trap_S_RegisterSound("sound/weapons/force/lightninghit2");
+	trap_S_RegisterSound("sound/weapons/force/lightninghit3");
+	trap_S_RegisterSound("sound/weapons/force/drain.wav");
+	trap_S_RegisterSound("sound/weapons/force/jumpbuild.wav");
+	trap_S_RegisterSound("sound/weapons/force/distract.wav");
+	trap_S_RegisterSound("sound/weapons/force/distractstop.wav");
+	trap_S_RegisterSound("sound/weapons/force/pull.wav");
+	trap_S_RegisterSound("sound/weapons/force/push.wav");
+
+	for (i=1 ; i<3 ; i++)
+	{
+		trap_S_RegisterSound(va("sound/weapons/thermal/bounce%i.wav", i));
+	}
+
+	trap_S_RegisterSound("sound/movers/switches/switch2.wav");
+	trap_S_RegisterSound("sound/movers/switches/switch3.wav");
+	trap_S_RegisterSound("sound/ambience/spark5.wav");
+	trap_S_RegisterSound("sound/chars/turret/ping.wav");
+	trap_S_RegisterSound("sound/chars/turret/startup.wav");
+	trap_S_RegisterSound("sound/chars/turret/shutdown.wav");
+	trap_S_RegisterSound("sound/chars/turret/move.wav");
+	trap_S_RegisterSound("sound/player/pickuphealth.wav");
+	trap_S_RegisterSound("sound/player/pickupshield.wav");
+
+	trap_S_RegisterSound("sound/effects/glassbreak1.wav");
+
+	trap_S_RegisterSound( "sound/weapons/rocket/tick.wav" );
+	trap_S_RegisterSound( "sound/weapons/rocket/lock.wav" );
+
+	trap_S_RegisterSound("sound/weapons/force/speedloop.wav");
+
+	trap_S_RegisterSound("sound/weapons/force/protecthit.mp3"); //PDSOUND_PROTECTHIT
+	trap_S_RegisterSound("sound/weapons/force/protect.mp3"); //PDSOUND_PROTECT
+	trap_S_RegisterSound("sound/weapons/force/absorbhit.mp3"); //PDSOUND_ABSORBHIT
+	trap_S_RegisterSound("sound/weapons/force/absorb.mp3"); //PDSOUND_ABSORB
+	trap_S_RegisterSound("sound/weapons/force/jump.mp3"); //PDSOUND_FORCEJUMP
+	trap_S_RegisterSound("sound/weapons/force/grip.mp3"); //PDSOUND_FORCEGRIP
+
+	if ( cgs.gametype >= GT_TEAM || cg_buildScript.integer ) {
+
+#ifdef JK2AWARDS
+		cgs.media.captureAwardSound = trap_S_RegisterSound( "sound/teamplay/flagcapture_yourteam.wav" );
+#endif
+		cgs.media.redLeadsSound = trap_S_RegisterSound( "sound/chars/protocol/misc/40MOM046");
+		cgs.media.blueLeadsSound = trap_S_RegisterSound( "sound/chars/protocol/misc/40MOM045");
+		cgs.media.teamsTiedSound = trap_S_RegisterSound( "sound/chars/protocol/misc/40MOM032" );
+
+		cgs.media.redScoredSound = trap_S_RegisterSound( "sound/chars/protocol/misc/40MOM044");
+		cgs.media.blueScoredSound = trap_S_RegisterSound( "sound/chars/protocol/misc/40MOM043" );
+
+		if ( cgs.gametype == GT_CTF || cg_buildScript.integer ) {
+			cgs.media.redFlagReturnedSound = trap_S_RegisterSound( "sound/chars/protocol/misc/40MOM042" );
+			cgs.media.blueFlagReturnedSound = trap_S_RegisterSound( "sound/chars/protocol/misc/40MOM041" );
+			cgs.media.redTookFlagSound = trap_S_RegisterSound( "sound/chars/protocol/misc/40MOM040" );
+			cgs.media.blueTookFlagSound = trap_S_RegisterSound( "sound/chars/protocol/misc/40MOM039" );
+		}
+		if ( cgs.gametype == GT_CTY /*|| cg_buildScript.integer*/ ) {
+			cgs.media.redYsalReturnedSound = trap_S_RegisterSound( "sound/chars/protocol/misc/40MOM050" );
+			cgs.media.blueYsalReturnedSound = trap_S_RegisterSound( "sound/chars/protocol/misc/40MOM049" );
+			cgs.media.redTookYsalSound = trap_S_RegisterSound( "sound/chars/protocol/misc/40MOM048" );
+			cgs.media.blueTookYsalSound = trap_S_RegisterSound( "sound/chars/protocol/misc/40MOM047" );
+		}
+	}
+
+	cgs.media.drainSound = trap_S_RegisterSound("sound/weapons/force/drained.mp3");
+
+	cgs.media.happyMusic = trap_S_RegisterSound("music/goodsmall.mp3");
+	cgs.media.dramaticFailure = trap_S_RegisterSound("music/badsmall.mp3");
+
+	//PRECACHE ALL MUSIC HERE (don't need to precache normally because it's streamed off the disk)
+	if (cg_buildScript.integer)
+	{
+		trap_S_StartBackgroundTrack( "music/mp/duel.mp3", "music/mp/duel.mp3", qfalse );
+	}
+
+	cg.loadLCARSStage = 1;
+
+	cgs.media.selectSound = trap_S_RegisterSound( "sound/weapons/change.wav" );
+
+	cgs.media.teleInSound = trap_S_RegisterSound( "sound/player/telein.wav" );
+	cgs.media.teleOutSound = trap_S_RegisterSound( "sound/player/teleout.wav" );
+	cgs.media.respawnSound = trap_S_RegisterSound( "sound/items/respawn1.wav" );
+
+	trap_S_RegisterSound( "sound/movers/objects/objectHit.wav" );
+
+	cgs.media.talkSound = trap_S_RegisterSound( "sound/player/talk.wav" );
+	cgs.media.landSound = trap_S_RegisterSound( "sound/player/land1.wav");
+	cgs.media.fallSound = trap_S_RegisterSound( "sound/player/fallsplat.wav");
+
+	cgs.media.crackleSound = trap_S_RegisterSound( "sound/effects/energy_crackle.wav" );
+#ifdef JK2AWARDS
+	cgs.media.impressiveSound = trap_S_RegisterSound( "sound/chars/protocol/misc/40MOM025" );
+	cgs.media.excellentSound = trap_S_RegisterSound( "sound/chars/protocol/misc/40MOM053" );
+	cgs.media.deniedSound = trap_S_RegisterSound( "sound/chars/protocol/misc/40MOM017" );
+	cgs.media.humiliationSound = trap_S_RegisterSound( "sound/chars/protocol/misc/40MOM019" );
+	cgs.media.defendSound = trap_S_RegisterSound( "sound/chars/protocol/misc/40MOM024" );
+#endif
+
+	/*
+	cgs.media.takenLeadSound = trap_S_RegisterSound( "sound/chars/protocol/misc/40MOM051");
+	cgs.media.tiedLeadSound = trap_S_RegisterSound( "sound/chars/protocol/misc/40MOM032");
+	cgs.media.lostLeadSound = trap_S_RegisterSound( "sound/chars/protocol/misc/40MOM052");
+	*/
+
+	cgs.media.rollSound					= trap_S_RegisterSound( "sound/player/roll1.wav");
+
+	cgs.media.noforceSound				= trap_S_RegisterSound( "sound/weapons/force/noforce" );
+
+	cgs.media.watrInSound				= trap_S_RegisterSound( "sound/player/watr_in.wav");
+	cgs.media.watrOutSound				= trap_S_RegisterSound( "sound/player/watr_out.wav");
+	cgs.media.watrUnSound				= trap_S_RegisterSound( "sound/player/watr_un.wav");
+
+	cgs.media.explosionModel			= trap_R_RegisterModel ( "models/map_objects/mp/sphere.md3" );
+	cgs.media.surfaceExplosionShader	= trap_R_RegisterShader( "surfaceExplosion" );
+
+	cgs.media.disruptorShader			= trap_R_RegisterShader( "gfx/effects/burn");
+
+	if (cg_buildScript.integer)
+	{
+		trap_R_RegisterShader( "gfx/effects/turretflashdie" );
+	}
+
+	cgs.media.solidWhite = trap_R_RegisterShader( "gfx/effects/solidWhite_cull" );
+
+	trap_R_RegisterShader("gfx/misc/mp_light_enlight_disable");
+	trap_R_RegisterShader("gfx/misc/mp_dark_enlight_disable");
+
+	trap_R_RegisterModel ( "models/map_objects/mp/sphere.md3" );
+	trap_R_RegisterModel("models/items/remote.md3");
+
+	cgs.media.holocronPickup = trap_S_RegisterSound( "sound/player/holocron.wav" );
+
+	// Zoom
+	cgs.media.zoomStart = trap_S_RegisterSound( "sound/interface/zoomstart.wav" );
+	cgs.media.zoomLoop	= trap_S_RegisterSound( "sound/interface/zoomloop.wav" );
+	cgs.media.zoomEnd	= trap_S_RegisterSound( "sound/interface/zoomend.wav" );
+
+	for (i=0 ; i<4 ; i++) {
+		Com_sprintf (name, sizeof(name), "sound/player/footsteps/stone_step%i.wav", i+1);
+		cgs.media.footsteps[FOOTSTEP_STONEWALK][i] = trap_S_RegisterSound (name);
+		Com_sprintf (name, sizeof(name), "sound/player/footsteps/stone_run%i.wav", i+1);
+		cgs.media.footsteps[FOOTSTEP_STONERUN][i] = trap_S_RegisterSound (name);
+
+		Com_sprintf (name, sizeof(name), "sound/player/footsteps/metal_step%i.wav", i+1);
+		cgs.media.footsteps[FOOTSTEP_METALWALK][i] = trap_S_RegisterSound (name);
+		Com_sprintf (name, sizeof(name), "sound/player/footsteps/metal_run%i.wav", i+1);
+		cgs.media.footsteps[FOOTSTEP_METALRUN][i] = trap_S_RegisterSound (name);
+
+		Com_sprintf (name, sizeof(name), "sound/player/footsteps/pipe_step%i.wav", i+1);
+		cgs.media.footsteps[FOOTSTEP_PIPEWALK][i] = trap_S_RegisterSound (name);
+		Com_sprintf (name, sizeof(name), "sound/player/footsteps/pipe_run%i.wav", i+1);
+		cgs.media.footsteps[FOOTSTEP_PIPERUN][i] = trap_S_RegisterSound (name);
+
+		Com_sprintf (name, sizeof(name), "sound/player/footsteps/water_run%i.wav", i+1);
+		cgs.media.footsteps[FOOTSTEP_SPLASH][i] = trap_S_RegisterSound (name);
+
+		Com_sprintf (name, sizeof(name), "sound/player/footsteps/water_walk%i.wav", i+1);
+		cgs.media.footsteps[FOOTSTEP_WADE][i] = trap_S_RegisterSound (name);
+
+		Com_sprintf (name, sizeof(name), "sound/player/footsteps/water_wade_0%i.wav", i+1);
+		cgs.media.footsteps[FOOTSTEP_SWIM][i] = trap_S_RegisterSound (name);
+
+		Com_sprintf (name, sizeof(name), "sound/player/footsteps/snow_step%i.wav", i+1);
+		cgs.media.footsteps[FOOTSTEP_SNOWWALK][i] = trap_S_RegisterSound (name);
+		Com_sprintf (name, sizeof(name), "sound/player/footsteps/snow_run%i.wav", i+1);
+		cgs.media.footsteps[FOOTSTEP_SNOWRUN][i] = trap_S_RegisterSound (name);
+
+		Com_sprintf (name, sizeof(name), "sound/player/footsteps/sand_walk%i.wav", i+1);
+		cgs.media.footsteps[FOOTSTEP_SANDWALK][i] = trap_S_RegisterSound (name);
+		Com_sprintf (name, sizeof(name), "sound/player/footsteps/sand_run%i.wav", i+1);
+		cgs.media.footsteps[FOOTSTEP_SANDRUN][i] = trap_S_RegisterSound (name);
+
+		Com_sprintf (name, sizeof(name), "sound/player/footsteps/grass_step%i.wav", i+1);
+		cgs.media.footsteps[FOOTSTEP_GRASSWALK][i] = trap_S_RegisterSound (name);
+		Com_sprintf (name, sizeof(name), "sound/player/footsteps/grass_run%i.wav", i+1);
+		cgs.media.footsteps[FOOTSTEP_GRASSRUN][i] = trap_S_RegisterSound (name);
+
+		Com_sprintf (name, sizeof(name), "sound/player/footsteps/dirt_step%i.wav", i+1);
+		cgs.media.footsteps[FOOTSTEP_DIRTWALK][i] = trap_S_RegisterSound (name);
+		Com_sprintf (name, sizeof(name), "sound/player/footsteps/dirt_run%i.wav", i+1);
+		cgs.media.footsteps[FOOTSTEP_DIRTRUN][i] = trap_S_RegisterSound (name);
+
+		Com_sprintf (name, sizeof(name), "sound/player/footsteps/mud_walk%i.wav", i+1);
+		cgs.media.footsteps[FOOTSTEP_MUDWALK][i] = trap_S_RegisterSound (name);
+		Com_sprintf (name, sizeof(name), "sound/player/footsteps/mud_run%i.wav", i+1);
+		cgs.media.footsteps[FOOTSTEP_MUDRUN][i] = trap_S_RegisterSound (name);
+
+		Com_sprintf (name, sizeof(name), "sound/player/footsteps/gravel_walk%i.wav", i+1);
+		cgs.media.footsteps[FOOTSTEP_GRAVELWALK][i] = trap_S_RegisterSound (name);
+		Com_sprintf (name, sizeof(name), "sound/player/footsteps/gravel_run%i.wav", i+1);
+		cgs.media.footsteps[FOOTSTEP_GRAVELRUN][i] = trap_S_RegisterSound (name);
+
+		Com_sprintf (name, sizeof(name), "sound/player/footsteps/rug_step%i.wav", i+1);
+		cgs.media.footsteps[FOOTSTEP_RUGWALK][i] = trap_S_RegisterSound (name);
+		Com_sprintf (name, sizeof(name), "sound/player/footsteps/rug_run%i.wav", i+1);
+		cgs.media.footsteps[FOOTSTEP_RUGRUN][i] = trap_S_RegisterSound (name);
+
+		Com_sprintf (name, sizeof(name), "sound/player/footsteps/wood_walk%i.wav", i+1);
+		cgs.media.footsteps[FOOTSTEP_WOODWALK][i] = trap_S_RegisterSound (name);
+		Com_sprintf (name, sizeof(name), "sound/player/footsteps/wood_run%i.wav", i+1);
+		cgs.media.footsteps[FOOTSTEP_WOODRUN][i] = trap_S_RegisterSound (name);
+	}
+
+	// only register the items that the server says we need
+	strcpy( items, CG_ConfigString( CS_ITEMS ) );
+
+	for ( i = 1 ; i < bg_numItems ; i++ ) {
+		if ( items[ i ] == '1' || cg_buildScript.integer ) {
+			CG_RegisterItemSounds( i );
+		}
+	}
+
+	for ( i = 1 ; i < MAX_SOUNDS ; i++ ) {
+		soundName = CG_ConfigString( CS_SOUNDS+i );
+		if ( !soundName[0] ) {
+			break;
+		}
+		if ( soundName[0] == '*' )
+		{
+			if (soundName[1] == '$')
+			{ //an NPC soundset
+				CG_PrecacheNPCSounds(soundName);
+			}
+			continue;	// custom sound
+		}
+		cgs.gameSounds[i] = trap_S_RegisterSound( soundName );
+	}
+
+	for ( i = 1 ; i < MAX_FX ; i++ ) {
+		soundName = CG_ConfigString( CS_EFFECTS+i );
+		if ( !soundName[0] ) {
+			break;
+		}
+
+		if (soundName[0] == '*')
+		{ //it's a special global weather effect
+			CG_ParseWeatherEffect(soundName);
+			cgs.gameEffects[i] = 0;
+		}
+		else
+		{
+			cgs.gameEffects[i] = trap_FX_RegisterEffect( soundName );
+		}
+	}
+
+	// register all the server specified icons
+	for ( i = 1; i < MAX_ICONS; i ++ )
+	{
+		const char* iconName;
+
+		iconName = CG_ConfigString ( CS_ICONS + i );
+		if ( !iconName[0] )
+		{
+			break;
+		}
+
+		cgs.gameIcons[i] = trap_R_RegisterShaderNoMip ( iconName );
+	}
+
+	soundName = CG_ConfigString(CS_SIEGE_STATE);
+
+	if (soundName[0])
+	{
+		CG_ParseSiegeState(soundName);
+	}
+
+	soundName = CG_ConfigString(CS_SIEGE_WINTEAM);
+
+	if (soundName[0])
+	{
+		cg_siegeWinTeam = atoi(soundName);
+	}
+
+	if (cgs.gametype == GT_SIEGE)
+	{
+		CG_ParseSiegeObjectiveStatus(CG_ConfigString(CS_SIEGE_OBJECTIVES));
+		cg_beatingSiegeTime = atoi(CG_ConfigString(CS_SIEGE_TIMEOVERRIDE));
+		if ( cg_beatingSiegeTime )
+		{
+			CG_SetSiegeTimerCvar ( cg_beatingSiegeTime );
+		}
+	}
+
+	cg.loadLCARSStage = 2;
+
+	// FIXME: only needed with item
+	cgs.media.deploySeeker = trap_S_RegisterSound ("sound/chars/seeker/misc/hiss");
+	cgs.media.medkitSound = trap_S_RegisterSound ("sound/items/use_bacta.wav");
+	
+	cgs.media.winnerSound = trap_S_RegisterSound( "sound/chars/protocol/misc/40MOM006" );
+	cgs.media.loserSound = trap_S_RegisterSound( "sound/chars/protocol/misc/40MOM010" );
+}
+
+
+//-------------------------------------
+// CG_RegisterEffects
+// 
+// Handles precaching all effect files
+//	and any shader, model, or sound
+//	files an effect may use.
+//-------------------------------------
+static void CG_RegisterEffects( void )
+{
+	/*
+	const char	*effectName;
+	int			i;
+
+	for ( i = 1 ; i < MAX_FX ; i++ ) 
+	{
+		effectName = CG_ConfigString( CS_EFFECTS + i );
+
+		if ( !effectName[0] ) 
+		{
+			break;
+		}
+
+		trap_FX_RegisterEffect( effectName );
+	}
+	*/
+	//the above was redundant as it's being done in CG_RegisterSounds
+
+	// Set up the glass effects mini-system.
+	CG_InitGlass();
+
+	//footstep effects
+	cgs.effects.footstepMud = trap_FX_RegisterEffect( "materials/mud" );
+	cgs.effects.footstepSand = trap_FX_RegisterEffect( "materials/sand" );
+	cgs.effects.footstepSnow = trap_FX_RegisterEffect( "materials/snow" );
+	cgs.effects.footstepGravel = trap_FX_RegisterEffect( "materials/gravel" );
+	//landing effects
+	cgs.effects.landingMud = trap_FX_RegisterEffect( "materials/mud_large" );
+	cgs.effects.landingSand = trap_FX_RegisterEffect( "materials/sand_large" );
+	cgs.effects.landingDirt = trap_FX_RegisterEffect( "materials/dirt_large" );
+	cgs.effects.landingSnow = trap_FX_RegisterEffect( "materials/snow_large" );
+	cgs.effects.landingGravel = trap_FX_RegisterEffect( "materials/gravel_large" );
+	//splashes
+	cgs.effects.waterSplash = trap_FX_RegisterEffect( "env/water_impact" );
+	cgs.effects.lavaSplash = trap_FX_RegisterEffect( "env/lava_splash" );
+	cgs.effects.acidSplash = trap_FX_RegisterEffect( "env/acid_splash" );
+}
+
+//===================================================================================
+
+extern char *forceHolocronModels[];
+int CG_HandleAppendedSkin(char *modelName);
+void CG_CacheG2AnimInfo(char *modelName);
+/*
+=================
+CG_RegisterGraphics
+
+This function may execute for a couple of minutes with a slow disk.
+=================
+*/
+static void CG_RegisterGraphics( void ) {
+	int			i;
+	int			breakPoint;
+	char		items[MAX_ITEMS+1];
+	const char	*terrainInfo;
+	int			terrainID;
+
+	static char		*sb_nums[11] = {
+		"gfx/2d/numbers/zero",
+		"gfx/2d/numbers/one",
+		"gfx/2d/numbers/two",
+		"gfx/2d/numbers/three",
+		"gfx/2d/numbers/four",
+		"gfx/2d/numbers/five",
+		"gfx/2d/numbers/six",
+		"gfx/2d/numbers/seven",
+		"gfx/2d/numbers/eight",
+		"gfx/2d/numbers/nine",
+		"gfx/2d/numbers/minus",
+	};
+
+	static char		*sb_t_nums[11] = {
+		"gfx/2d/numbers/t_zero",
+		"gfx/2d/numbers/t_one",
+		"gfx/2d/numbers/t_two",
+		"gfx/2d/numbers/t_three",
+		"gfx/2d/numbers/t_four",
+		"gfx/2d/numbers/t_five",
+		"gfx/2d/numbers/t_six",
+		"gfx/2d/numbers/t_seven",
+		"gfx/2d/numbers/t_eight",
+		"gfx/2d/numbers/t_nine",
+		"gfx/2d/numbers/t_minus",
+	};
+
+	static char		*sb_c_nums[11] = {
+		"gfx/2d/numbers/c_zero",
+		"gfx/2d/numbers/c_one",
+		"gfx/2d/numbers/c_two",
+		"gfx/2d/numbers/c_three",
+		"gfx/2d/numbers/c_four",
+		"gfx/2d/numbers/c_five",
+		"gfx/2d/numbers/c_six",
+		"gfx/2d/numbers/c_seven",
+		"gfx/2d/numbers/c_eight",
+		"gfx/2d/numbers/c_nine",
+		"gfx/2d/numbers/t_minus", //?????
+	};
+
+	// clear any references to old media
+	memset( &cg.refdef, 0, sizeof( cg.refdef ) );
+	trap_R_ClearScene();
+
+	CG_LoadingString( cgs.mapname );        
+
+//#ifndef _XBOX
+	trap_R_LoadWorldMap( cgs.mapname );
+//#endif
+
+	// precache status bar pics
+//	CG_LoadingString( "game media" );
+
+	for ( i=0 ; i<11 ; i++) {
+		cgs.media.numberShaders[i] = trap_R_RegisterShader( sb_nums[i] );
+	}
+
+	cg.loadLCARSStage = 3;
+
+	for ( i=0; i < 11; i++ )
+	{
+		cgs.media.numberShaders[i]			= trap_R_RegisterShaderNoMip( sb_nums[i] );
+		cgs.media.smallnumberShaders[i]		= trap_R_RegisterShaderNoMip( sb_t_nums[i] );
+		cgs.media.chunkyNumberShaders[i]	= trap_R_RegisterShaderNoMip( sb_c_nums[i] );
+	}
+
+	trap_R_RegisterShaderNoMip ( "gfx/mp/pduel_icon_lone" );
+	trap_R_RegisterShaderNoMip ( "gfx/mp/pduel_icon_double" );
+
+	cgs.media.balloonShader = trap_R_RegisterShader( "gfx/mp/chat_icon" );
+	cgs.media.vchatShader = trap_R_RegisterShader( "gfx/mp/vchat_icon" );
+
+	cgs.media.deferShader = trap_R_RegisterShaderNoMip( "gfx/2d/defer.tga" );
+
+	cgs.media.radarShader			= trap_R_RegisterShaderNoMip ( "gfx/menus/radar/radar.png" );
+	cgs.media.siegeItemShader		= trap_R_RegisterShaderNoMip ( "gfx/menus/radar/goalitem" );
+	cgs.media.mAutomapPlayerIcon	= trap_R_RegisterShader( "gfx/menus/radar/arrow_w" );
+	cgs.media.mAutomapRocketIcon	= trap_R_RegisterShader( "gfx/menus/radar/rocket" );
+
+	cgs.media.wireframeAutomapFrame_left = trap_R_RegisterShader( "gfx/mp_automap/mpauto_frame_left" );
+	cgs.media.wireframeAutomapFrame_right = trap_R_RegisterShader( "gfx/mp_automap/mpauto_frame_right" );
+	cgs.media.wireframeAutomapFrame_top = trap_R_RegisterShader( "gfx/mp_automap/mpauto_frame_top" );
+	cgs.media.wireframeAutomapFrame_bottom = trap_R_RegisterShader( "gfx/mp_automap/mpauto_frame_bottom" );
+
+	cgs.media.lagometerShader = trap_R_RegisterShaderNoMip("gfx/2d/lag" );
+	cgs.media.connectionShader = trap_R_RegisterShaderNoMip( "gfx/2d/net" );
+
+	trap_FX_InitSystem(&cg.refdef);
+	CG_RegisterEffects();
+
+	cgs.media.boltShader = trap_R_RegisterShader( "gfx/misc/blueLine" );
+
+	cgs.effects.turretShotEffect = trap_FX_RegisterEffect( "turret/shot" );
+	cgs.effects.mEmplacedDeadSmoke = trap_FX_RegisterEffect("emplaced/dead_smoke.efx");
+	cgs.effects.mEmplacedExplode = trap_FX_RegisterEffect("emplaced/explode.efx");
+	cgs.effects.mTurretExplode = trap_FX_RegisterEffect("turret/explode.efx");
+	cgs.effects.mSparkExplosion = trap_FX_RegisterEffect("sparks/spark_explosion.efx");
+	cgs.effects.mTripmineExplosion = trap_FX_RegisterEffect("tripMine/explosion.efx");
+	cgs.effects.mDetpackExplosion = trap_FX_RegisterEffect("detpack/explosion.efx");
+	cgs.effects.mFlechetteAltBlow = trap_FX_RegisterEffect("flechette/alt_blow.efx");
+	cgs.effects.mStunBatonFleshImpact = trap_FX_RegisterEffect("stunBaton/flesh_impact.efx");
+	cgs.effects.mAltDetonate = trap_FX_RegisterEffect("demp2/altDetonate.efx");
+	cgs.effects.mSparksExplodeNoSound = trap_FX_RegisterEffect("sparks/spark_exp_nosnd");
+	cgs.effects.mTripMineLaster = trap_FX_RegisterEffect("tripMine/laser.efx");
+	cgs.effects.mEmplacedMuzzleFlash = trap_FX_RegisterEffect( "effects/emplaced/muzzle_flash" );
+	cgs.effects.mConcussionAltRing = trap_FX_RegisterEffect("concussion/alt_ring");
+
+	cgs.effects.mHyperspaceStars = trap_FX_RegisterEffect("ships/hyperspace_stars");
+	cgs.effects.mBlackSmoke = trap_FX_RegisterEffect( "volumetric/black_smoke" );
+	cgs.effects.mShipDestDestroyed = trap_FX_RegisterEffect("effects/ships/dest_destroyed.efx");
+	cgs.effects.mShipDestBurning = trap_FX_RegisterEffect("effects/ships/dest_burning.efx");
+	cgs.effects.mBobaJet = trap_FX_RegisterEffect("effects/boba/jet.efx");
+
+
+	cgs.effects.itemCone = trap_FX_RegisterEffect("mp/itemcone.efx");
+	cgs.effects.mTurretMuzzleFlash = trap_FX_RegisterEffect("effects/turret/muzzle_flash.efx");
+	cgs.effects.mSparks = trap_FX_RegisterEffect("sparks/spark_nosnd.efx"); //sparks/spark.efx
+	cgs.effects.mSaberCut = trap_FX_RegisterEffect("saber/saber_cut.efx");
+	cgs.effects.mSaberBlock = trap_FX_RegisterEffect("saber/saber_block.efx");
+	cgs.effects.mSaberBloodSparks = trap_FX_RegisterEffect("saber/blood_sparks_mp.efx");
+	cgs.effects.mSaberBloodSparksSmall = trap_FX_RegisterEffect("saber/blood_sparks_25_mp.efx");
+	cgs.effects.mSaberBloodSparksMid = trap_FX_RegisterEffect("saber/blood_sparks_50_mp.efx");
+	cgs.effects.mSpawn = trap_FX_RegisterEffect("mp/spawn.efx");
+	cgs.effects.mJediSpawn = trap_FX_RegisterEffect("mp/jedispawn.efx");
+	cgs.effects.mBlasterDeflect = trap_FX_RegisterEffect("blaster/deflect.efx");
+	cgs.effects.mBlasterSmoke = trap_FX_RegisterEffect("blaster/smoke_bolton");
+	cgs.effects.mForceConfustionOld = trap_FX_RegisterEffect("force/confusion_old.efx");
+
+	cgs.effects.forceLightning		= trap_FX_RegisterEffect( "effects/force/lightning.efx" );
+	cgs.effects.forceLightningWide	= trap_FX_RegisterEffect( "effects/force/lightningwide.efx" );
+	cgs.effects.forceDrain		= trap_FX_RegisterEffect( "effects/mp/drain.efx" );
+	cgs.effects.forceDrainWide	= trap_FX_RegisterEffect( "effects/mp/drainwide.efx" );
+	cgs.effects.forceDrained	= trap_FX_RegisterEffect( "effects/mp/drainhit.efx");
+
+	cgs.effects.mDisruptorDeathSmoke = trap_FX_RegisterEffect("disruptor/death_smoke");
+
+	for ( i = 0 ; i < NUM_CROSSHAIRS ; i++ ) {
+		cgs.media.crosshairShader[i] = trap_R_RegisterShaderNoMip( va("gfx/2d/crosshair%c", 'a'+i) );
+	}
+
+	cg.loadLCARSStage = 4;
+
+	cgs.media.backTileShader = trap_R_RegisterShader( "gfx/2d/backtile" );
+
+	//precache the fpls skin
+	//trap_R_RegisterSkin("models/players/kyle/model_fpls2.skin");
+
+	cgs.media.itemRespawningPlaceholder = trap_R_RegisterShader("powerups/placeholder");
+	cgs.media.itemRespawningRezOut = trap_R_RegisterShader("powerups/rezout");
+
+	cgs.media.playerShieldDamage = trap_R_RegisterShader("gfx/misc/personalshield");
+	cgs.media.protectShader = trap_R_RegisterShader("gfx/misc/forceprotect");
+	cgs.media.forceSightBubble = trap_R_RegisterShader("gfx/misc/sightbubble");
+	cgs.media.forceShell = trap_R_RegisterShader("powerups/forceshell");
+	cgs.media.sightShell = trap_R_RegisterShader("powerups/sightshell");
+
+	cgs.media.itemHoloModel = trap_R_RegisterModel("models/map_objects/mp/holo.md3");
+
+	if (cgs.gametype == GT_HOLOCRON || cg_buildScript.integer)
+	{
+		for ( i=0; i < NUM_FORCE_POWERS; i++ )
+		{
+			if (forceHolocronModels[i] &&
+				forceHolocronModels[i][0])
+			{
+				trap_R_RegisterModel(forceHolocronModels[i]);
+			}
+		}
+	}
+
+	if ( cgs.gametype == GT_CTF || cgs.gametype == GT_CTY || cg_buildScript.integer ) {
+		if (cg_buildScript.integer)
+		{
+			trap_R_RegisterModel( "models/flags/r_flag.md3" );
+			trap_R_RegisterModel( "models/flags/b_flag.md3" );
+			trap_R_RegisterModel( "models/flags/r_flag_ysal.md3" );
+			trap_R_RegisterModel( "models/flags/b_flag_ysal.md3" );
+		}
+
+		if (cgs.gametype == GT_CTF)
+		{
+			cgs.media.redFlagModel = trap_R_RegisterModel( "models/flags/r_flag.md3" );
+			cgs.media.blueFlagModel = trap_R_RegisterModel( "models/flags/b_flag.md3" );
+		}
+		else
+		{
+			cgs.media.redFlagModel = trap_R_RegisterModel( "models/flags/r_flag_ysal.md3" );
+			cgs.media.blueFlagModel = trap_R_RegisterModel( "models/flags/b_flag_ysal.md3" );
+		}
+
+		trap_R_RegisterShaderNoMip( "gfx/hud/mpi_rflag_x" );
+		trap_R_RegisterShaderNoMip( "gfx/hud/mpi_bflag_x" );
+
+		trap_R_RegisterShaderNoMip( "gfx/hud/mpi_rflag_ys" );
+		trap_R_RegisterShaderNoMip( "gfx/hud/mpi_bflag_ys" );
+
+		trap_R_RegisterShaderNoMip( "gfx/hud/mpi_rflag" );
+		trap_R_RegisterShaderNoMip( "gfx/hud/mpi_bflag" );
+
+		trap_R_RegisterShaderNoMip("gfx/2d/net.tga");
+
+		cgs.media.flagPoleModel = trap_R_RegisterModel( "models/flag2/flagpole.md3" );
+		cgs.media.flagFlapModel = trap_R_RegisterModel( "models/flag2/flagflap3.md3" );
+
+		cgs.media.redFlagBaseModel = trap_R_RegisterModel( "models/mapobjects/flagbase/red_base.md3" );
+		cgs.media.blueFlagBaseModel = trap_R_RegisterModel( "models/mapobjects/flagbase/blue_base.md3" );
+		cgs.media.neutralFlagBaseModel = trap_R_RegisterModel( "models/mapobjects/flagbase/ntrl_base.md3" );
+	}
+
+	if ( cgs.gametype >= GT_TEAM || cg_buildScript.integer ) {
+		cgs.media.teamRedShader = trap_R_RegisterShader( "sprites/team_red" );
+		cgs.media.teamBlueShader = trap_R_RegisterShader( "sprites/team_blue" );
+		//cgs.media.redQuadShader = trap_R_RegisterShader("powerups/blueflag" );
+		cgs.media.teamStatusBar = trap_R_RegisterShader( "gfx/2d/colorbar.tga" );
+	}
+	else if ( cgs.gametype == GT_JEDIMASTER )
+	{
+		cgs.media.teamRedShader = trap_R_RegisterShader( "sprites/team_red" );
+	}
+
+	if (cgs.gametype == GT_POWERDUEL || cg_buildScript.integer)
+	{
+		cgs.media.powerDuelAllyShader = trap_R_RegisterShader("gfx/mp/pduel_icon_double");//trap_R_RegisterShader("gfx/mp/pduel_gameicon_ally");
+	}
+
+	cgs.media.heartShader			= trap_R_RegisterShaderNoMip( "ui/assets/statusbar/selectedhealth.tga" );
+
+	cgs.media.ysaliredShader		= trap_R_RegisterShader( "powerups/ysaliredshell");
+	cgs.media.ysaliblueShader		= trap_R_RegisterShader( "powerups/ysaliblueshell");
+	cgs.media.ysalimariShader		= trap_R_RegisterShader( "powerups/ysalimarishell");
+	cgs.media.boonShader			= trap_R_RegisterShader( "powerups/boonshell");
+	cgs.media.endarkenmentShader	= trap_R_RegisterShader( "powerups/endarkenmentshell");
+	cgs.media.enlightenmentShader	= trap_R_RegisterShader( "powerups/enlightenmentshell");
+	cgs.media.invulnerabilityShader = trap_R_RegisterShader( "powerups/invulnerabilityshell");
+
+#ifdef JK2AWARDS
+	cgs.media.medalImpressive		= trap_R_RegisterShaderNoMip( "medal_impressive" );
+	cgs.media.medalExcellent		= trap_R_RegisterShaderNoMip( "medal_excellent" );
+	cgs.media.medalGauntlet			= trap_R_RegisterShaderNoMip( "medal_gauntlet" );
+	cgs.media.medalDefend			= trap_R_RegisterShaderNoMip( "medal_defend" );
+	cgs.media.medalAssist			= trap_R_RegisterShaderNoMip( "medal_assist" );
+	cgs.media.medalCapture			= trap_R_RegisterShaderNoMip( "medal_capture" );
+#endif
+
+	// Binocular interface
+	cgs.media.binocularCircle		= trap_R_RegisterShader( "gfx/2d/binCircle" );
+	cgs.media.binocularMask			= trap_R_RegisterShader( "gfx/2d/binMask" );
+	cgs.media.binocularArrow		= trap_R_RegisterShader( "gfx/2d/binSideArrow" );
+	cgs.media.binocularTri			= trap_R_RegisterShader( "gfx/2d/binTopTri" );
+	cgs.media.binocularStatic		= trap_R_RegisterShader( "gfx/2d/binocularWindow" );
+	cgs.media.binocularOverlay		= trap_R_RegisterShader( "gfx/2d/binocularNumOverlay" );
+
+	cg.loadLCARSStage = 5;
+
+	// Chunk models
+	//FIXME: jfm:? bother to conditionally load these if an ent has this material type?
+	for ( i = 0; i < NUM_CHUNK_MODELS; i++ )
+	{
+		cgs.media.chunkModels[CHUNK_METAL2][i]	= trap_R_RegisterModel( va( "models/chunks/metal/metal1_%i.md3", i+1 ) ); //_ /switched\ _
+		cgs.media.chunkModels[CHUNK_METAL1][i]	= trap_R_RegisterModel( va( "models/chunks/metal/metal2_%i.md3", i+1 ) ); //  \switched/
+		cgs.media.chunkModels[CHUNK_ROCK1][i]	= trap_R_RegisterModel( va( "models/chunks/rock/rock1_%i.md3", i+1 ) );
+		cgs.media.chunkModels[CHUNK_ROCK2][i]	= trap_R_RegisterModel( va( "models/chunks/rock/rock2_%i.md3", i+1 ) );
+		cgs.media.chunkModels[CHUNK_ROCK3][i]	= trap_R_RegisterModel( va( "models/chunks/rock/rock3_%i.md3", i+1 ) );
+		cgs.media.chunkModels[CHUNK_CRATE1][i]	= trap_R_RegisterModel( va( "models/chunks/crate/crate1_%i.md3", i+1 ) );
+		cgs.media.chunkModels[CHUNK_CRATE2][i]	= trap_R_RegisterModel( va( "models/chunks/crate/crate2_%i.md3", i+1 ) );
+		cgs.media.chunkModels[CHUNK_WHITE_METAL][i]	= trap_R_RegisterModel( va( "models/chunks/metal/wmetal1_%i.md3", i+1 ) );
+	}
+
+	cgs.media.chunkSound			= trap_S_RegisterSound("sound/weapons/explosions/glasslcar");
+	cgs.media.grateSound			= trap_S_RegisterSound( "sound/effects/grate_destroy" );
+	cgs.media.rockBreakSound		= trap_S_RegisterSound("sound/effects/wall_smash");
+	cgs.media.rockBounceSound[0]	= trap_S_RegisterSound("sound/effects/stone_bounce");
+	cgs.media.rockBounceSound[1]	= trap_S_RegisterSound("sound/effects/stone_bounce2");
+	cgs.media.metalBounceSound[0]	= trap_S_RegisterSound("sound/effects/metal_bounce");
+	cgs.media.metalBounceSound[1]	= trap_S_RegisterSound("sound/effects/metal_bounce2");
+	cgs.media.glassChunkSound		= trap_S_RegisterSound("sound/weapons/explosions/glassbreak1");
+	cgs.media.crateBreakSound[0]	= trap_S_RegisterSound("sound/weapons/explosions/crateBust1" );
+	cgs.media.crateBreakSound[1]	= trap_S_RegisterSound("sound/weapons/explosions/crateBust2" );
+
+/*
+Ghoul2 Insert Start
+*/
+	CG_InitItems();
+/*
+Ghoul2 Insert End
+*/
+	memset( cg_weapons, 0, sizeof( cg_weapons ) );
+
+	// only register the items that the server says we need
+	strcpy( items, CG_ConfigString( CS_ITEMS) );
+
+	for ( i = 1 ; i < bg_numItems ; i++ ) {
+		if ( items[ i ] == '1' || cg_buildScript.integer ) {
+			CG_LoadingItem( i );
+			CG_RegisterItemVisuals( i );
+		}
+	}
+
+	cg.loadLCARSStage = 6;
+
+	cgs.media.glassShardShader	= trap_R_RegisterShader( "gfx/misc/test_crackle" );
+
+	// doing one shader just makes it look like a shell.  By using two shaders with different bulge offsets and different texture scales, it has a much more chaotic look
+	cgs.media.electricBodyShader			= trap_R_RegisterShader( "gfx/misc/electric" );
+	cgs.media.electricBody2Shader			= trap_R_RegisterShader( "gfx/misc/fullbodyelectric2" );
+
+	cgs.media.fsrMarkShader					= trap_R_RegisterShader( "footstep_r" );
+	cgs.media.fslMarkShader					= trap_R_RegisterShader( "footstep_l" );
+	cgs.media.fshrMarkShader				= trap_R_RegisterShader( "footstep_heavy_r" );
+	cgs.media.fshlMarkShader				= trap_R_RegisterShader( "footstep_heavy_l" );
+
+	cgs.media.refractionShader				= trap_R_RegisterShader("effects/refraction");
+
+	cgs.media.cloakedShader					= trap_R_RegisterShader( "gfx/effects/cloakedShader" );
+
+	// wall marks
+	cgs.media.shadowMarkShader	= trap_R_RegisterShader( "markShadow" );
+	cgs.media.wakeMarkShader	= trap_R_RegisterShader( "wake" );
+
+	cgs.media.viewPainShader					= trap_R_RegisterShader( "gfx/misc/borgeyeflare" );
+	cgs.media.viewPainShader_Shields			= trap_R_RegisterShader( "gfx/mp/dmgshader_shields" );
+	cgs.media.viewPainShader_ShieldsAndHealth	= trap_R_RegisterShader( "gfx/mp/dmgshader_shieldsandhealth" );
+
+	// register the inline models
+	breakPoint = cgs.numInlineModels = trap_CM_NumInlineModels();
+	for ( i = 1 ; i < cgs.numInlineModels ; i++ ) {
+		char	name[10];
+		vec3_t			mins, maxs;
+		int				j;
+
+		Com_sprintf( name, sizeof(name), "*%i", i );
+		cgs.inlineDrawModel[i] = trap_R_RegisterModel( name );
+		if (!cgs.inlineDrawModel[i])
+		{
+			breakPoint = i;
+			break;
+		}
+
+		trap_R_ModelBounds( cgs.inlineDrawModel[i], mins, maxs );
+		for ( j = 0 ; j < 3 ; j++ ) {
+			cgs.inlineModelMidpoints[i][j] = mins[j] + 0.5 * ( maxs[j] - mins[j] );
+		}
+	}
+
+	cg.loadLCARSStage = 7;
+
+	// register all the server specified models
+	for (i=1 ; i<MAX_MODELS ; i++) {
+		const char		*cModelName;
+		char modelName[MAX_QPATH];
+
+		cModelName = CG_ConfigString( CS_MODELS+i );
+		if ( !cModelName[0] ) {
+			break;
+		}
+
+		strcpy(modelName, cModelName);
+		if (strstr(modelName, ".glm") || modelName[0] == '$')
+		{ //Check to see if it has a custom skin attached.
+			CG_HandleAppendedSkin(modelName);
+			CG_CacheG2AnimInfo(modelName);
+		}
+
+		if (modelName[0] != '$' && modelName[0] != '@')
+		{ //don't register vehicle names and saber names as models.
+			cgs.gameModels[i] = trap_R_RegisterModel( modelName );
+		}
+		else
+		{//FIXME: register here so that stuff gets precached!!!
+			cgs.gameModels[i] = 0;
+		}
+	}
+	cg.loadLCARSStage = 8;
+/*
+Ghoul2 Insert Start
+*/
+
+
+//	CG_LoadingString( "BSP instances" );
+
+	for(i = 1; i < MAX_SUB_BSP; i++)
+	{
+		const char		*bspName = 0;
+		vec3_t			mins, maxs;
+		int				j;
+		int				sub = 0;
+		char			temp[MAX_QPATH];
+
+		bspName = CG_ConfigString( CS_BSP_MODELS+i );
+		if ( !bspName[0] ) 
+		{
+			break;
+		}
+
+		trap_CM_LoadMap( bspName, qtrue );
+		cgs.inlineDrawModel[breakPoint] = trap_R_RegisterModel( bspName );
+		trap_R_ModelBounds( cgs.inlineDrawModel[breakPoint], mins, maxs );
+		for ( j = 0 ; j < 3 ; j++ ) 
+		{
+			cgs.inlineModelMidpoints[breakPoint][j] = mins[j] + 0.5 * ( maxs[j] - mins[j] );
+		}
+		breakPoint++;
+		for(sub=1;sub<MAX_MODELS;sub++)
+		{
+			Com_sprintf(temp, MAX_QPATH, "*%d-%d", i, sub);
+			cgs.inlineDrawModel[breakPoint] = trap_R_RegisterModel( temp );
+			if (!cgs.inlineDrawModel[breakPoint])
+			{
+				break;
+			}
+			trap_R_ModelBounds( cgs.inlineDrawModel[breakPoint], mins, maxs );
+			for ( j = 0 ; j < 3 ; j++ ) 
+			{
+				cgs.inlineModelMidpoints[breakPoint][j] = mins[j] + 0.5 * ( maxs[j] - mins[j] );
+			}
+			breakPoint++;
+		}
+	}
+
+//	CG_LoadingString( "Creating terrain" );
+	for(i = 1; i < MAX_TERRAINS; i++)
+	{
+		terrainInfo = CG_ConfigString( CS_TERRAINS + i );
+		if ( !terrainInfo[0] )
+		{
+			break;
+		}
+
+		terrainID = trap_CM_RegisterTerrain(terrainInfo);
+
+		trap_RMG_Init(terrainID, terrainInfo);
+
+		// Send off the terrainInfo to the renderer
+		trap_RE_InitRendererTerrain( terrainInfo );
+	}
+
+	/*
+	CG_LoadingString("skins");
+	// register all the server specified models
+	for (i=1 ; i<MAX_CHARSKINS ; i++) {
+		const char		*modelName;
+
+		modelName = CG_ConfigString( CS_CHARSKINS+i );
+		if ( !modelName[0] ) {
+			break;
+		}
+		cgs.skins[i] = trap_R_RegisterSkin( modelName );
+	}
+	*/
+	//rww - removed and replaced with CS_G2BONES. For custom skins
+	//the new method is to append a * after an indexed model name and
+	//then append the skin name after that (note that this is only
+	//used for NPCs)
+
+//	CG_LoadingString("weapons");
+
+	CG_InitG2Weapons();
+
+/*
+Ghoul2 Insert End
+*/
+	cg.loadLCARSStage = 9;
+
+
+	// new stuff
+	cgs.media.patrolShader = trap_R_RegisterShaderNoMip("ui/assets/statusbar/patrol.tga");
+	cgs.media.assaultShader = trap_R_RegisterShaderNoMip("ui/assets/statusbar/assault.tga");
+	cgs.media.campShader = trap_R_RegisterShaderNoMip("ui/assets/statusbar/camp.tga");
+	cgs.media.followShader = trap_R_RegisterShaderNoMip("ui/assets/statusbar/follow.tga");
+	cgs.media.defendShader = trap_R_RegisterShaderNoMip("ui/assets/statusbar/defend.tga");
+	cgs.media.teamLeaderShader = trap_R_RegisterShaderNoMip("ui/assets/statusbar/team_leader.tga");
+	cgs.media.retrieveShader = trap_R_RegisterShaderNoMip("ui/assets/statusbar/retrieve.tga");
+	cgs.media.escortShader = trap_R_RegisterShaderNoMip("ui/assets/statusbar/escort.tga");
+	cgs.media.cursor = trap_R_RegisterShaderNoMip( "menu/art/3_cursor2" );
+	cgs.media.sizeCursor = trap_R_RegisterShaderNoMip( "ui/assets/sizecursor.tga" );
+	cgs.media.selectCursor = trap_R_RegisterShaderNoMip( "ui/assets/selectcursor.tga" );
+	cgs.media.flagShaders[0] = trap_R_RegisterShaderNoMip("ui/assets/statusbar/flag_in_base.tga");
+	cgs.media.flagShaders[1] = trap_R_RegisterShaderNoMip("ui/assets/statusbar/flag_capture.tga");
+	cgs.media.flagShaders[2] = trap_R_RegisterShaderNoMip("ui/assets/statusbar/flag_missing.tga");
+
+	cgs.media.halfShieldModel	= trap_R_RegisterModel ( "models/weaphits/testboom.md3" );
+	cgs.media.halfShieldShader	= trap_R_RegisterShader( "halfShieldShell" );
+
+	trap_FX_RegisterEffect("force/force_touch");
+
+	CG_ClearParticles ();
+/*
+	for (i=1; i<MAX_PARTICLES_AREAS; i++)
+	{
+		{
+			int rval;
+
+			rval = CG_NewParticleArea ( CS_PARTICLES + i);
+			if (!rval)
+				break;
+		}
+	}
+*/
+}
+
+
+const char *CG_GetStringEdString(char *refSection, char *refName)
+{
+	static char text[2][1024]={0};	//just incase it's nested
+	static int		index = 0;
+
+	index ^= 1;
+	trap_SP_GetStringTextString(va("%s_%s", refSection, refName), text[index], sizeof(text[0]));
+	return text[index];
+}
+
+int	CG_GetClassCount(team_t team,int siegeClass );
+int CG_GetTeamNonScoreCount(team_t team);
+
+void CG_SiegeCountCvars( void )
+{
+	int classGfx[6];
+
+	trap_Cvar_Set( "ui_tm1_cnt",va("%d",CG_GetTeamNonScoreCount(TEAM_RED )));
+	trap_Cvar_Set( "ui_tm2_cnt",va("%d",CG_GetTeamNonScoreCount(TEAM_BLUE )));
+	trap_Cvar_Set( "ui_tm3_cnt",va("%d",CG_GetTeamNonScoreCount(TEAM_SPECTATOR )));
+	
+	// This is because the only way we can match up classes is by the gfx handle. 
+	classGfx[0] = trap_R_RegisterShaderNoMip("gfx/mp/c_icon_infantry");
+	classGfx[1] = trap_R_RegisterShaderNoMip("gfx/mp/c_icon_heavy_weapons");
+	classGfx[2] = trap_R_RegisterShaderNoMip("gfx/mp/c_icon_demolitionist");
+	classGfx[3] = trap_R_RegisterShaderNoMip("gfx/mp/c_icon_vanguard");
+	classGfx[4] = trap_R_RegisterShaderNoMip("gfx/mp/c_icon_support");
+	classGfx[5] = trap_R_RegisterShaderNoMip("gfx/mp/c_icon_jedi_general");
+
+	trap_Cvar_Set( "ui_tm1_c0_cnt",va("%d",CG_GetClassCount(TEAM_RED,classGfx[0])));
+	trap_Cvar_Set( "ui_tm1_c1_cnt",va("%d",CG_GetClassCount(TEAM_RED,classGfx[1])));
+	trap_Cvar_Set( "ui_tm1_c2_cnt",va("%d",CG_GetClassCount(TEAM_RED,classGfx[2])));
+	trap_Cvar_Set( "ui_tm1_c3_cnt",va("%d",CG_GetClassCount(TEAM_RED,classGfx[3])));
+	trap_Cvar_Set( "ui_tm1_c4_cnt",va("%d",CG_GetClassCount(TEAM_RED,classGfx[4])));
+	trap_Cvar_Set( "ui_tm1_c5_cnt",va("%d",CG_GetClassCount(TEAM_RED,classGfx[5])));
+
+	trap_Cvar_Set( "ui_tm2_c0_cnt",va("%d",CG_GetClassCount(TEAM_BLUE,classGfx[0])));
+	trap_Cvar_Set( "ui_tm2_c1_cnt",va("%d",CG_GetClassCount(TEAM_BLUE,classGfx[1])));
+	trap_Cvar_Set( "ui_tm2_c2_cnt",va("%d",CG_GetClassCount(TEAM_BLUE,classGfx[2])));
+	trap_Cvar_Set( "ui_tm2_c3_cnt",va("%d",CG_GetClassCount(TEAM_BLUE,classGfx[3])));
+	trap_Cvar_Set( "ui_tm2_c4_cnt",va("%d",CG_GetClassCount(TEAM_BLUE,classGfx[4])));
+	trap_Cvar_Set( "ui_tm2_c5_cnt",va("%d",CG_GetClassCount(TEAM_BLUE,classGfx[5])));
+
+}
+
+/*																																			
+=======================
+CG_BuildSpectatorString
+
+=======================
+*/
+void CG_BuildSpectatorString(void) {
+	int i;
+	cg.spectatorList[0] = 0;
+
+	// Count up the number of players per team and per class
+	CG_SiegeCountCvars();
+
+	for (i = 0; i < MAX_CLIENTS; i++) {
+		if (cgs.clientinfo[i].infoValid && cgs.clientinfo[i].team == TEAM_SPECTATOR ) {
+			Q_strcat(cg.spectatorList, sizeof(cg.spectatorList), va("%s     ", cgs.clientinfo[i].name));
+		}
+	}
+	i = strlen(cg.spectatorList);
+	if (i != cg.spectatorLen) {
+		cg.spectatorLen = i;
+		cg.spectatorWidth = -1;
+	}
+}
+
+
+/*																																			
+===================
+CG_RegisterClients
+===================
+*/
+static void CG_RegisterClients( void ) {
+	int		i;
+
+	CG_LoadingClient(cg.clientNum);
+	CG_NewClientInfo(cg.clientNum, qfalse);
+
+	for (i=0 ; i<MAX_CLIENTS ; i++) {
+		const char		*clientInfo;
+
+		if (cg.clientNum == i) {
+			continue;
+		}
+
+		clientInfo = CG_ConfigString( CS_PLAYERS+i );
+		if ( !clientInfo[0]) {
+			continue;
+		}
+		CG_LoadingClient( i );
+		CG_NewClientInfo( i, qfalse);
+	}
+	CG_BuildSpectatorString();
+}
+
+//===========================================================================
+
+/*
+=================
+CG_ConfigString
+=================
+*/
+const char *CG_ConfigString( int index ) {
+	if ( index < 0 || index >= MAX_CONFIGSTRINGS ) {
+		CG_Error( "CG_ConfigString: bad index: %i", index );
+	}
+	return cgs.gameState.stringData + cgs.gameState.stringOffsets[ index ];
+}
+
+//==================================================================
+
+/*
+======================
+CG_StartMusic
+
+======================
+*/
+void CG_StartMusic( qboolean bForceStart ) {
+	char	*s;
+	char	parm1[MAX_QPATH], parm2[MAX_QPATH];
+
+	// start the background music
+	s = (char *)CG_ConfigString( CS_MUSIC );
+	Q_strncpyz( parm1, COM_Parse( (const char **)&s ), sizeof( parm1 ) );
+	Q_strncpyz( parm2, COM_Parse( (const char **)&s ), sizeof( parm2 ) );
+
+	trap_S_StartBackgroundTrack( parm1, parm2, !bForceStart );
+}
+
+#ifndef _XBOX
+char *CG_GetMenuBuffer(const char *filename) {
+	int	len;
+	fileHandle_t	f;
+	static char buf[MAX_MENUFILE];
+
+	len = trap_FS_FOpenFile( filename, &f, FS_READ );
+	if ( !f ) {
+		trap_Print( va( S_COLOR_RED "menu file not found: %s, using default\n", filename ) );
+		return NULL;
+	}
+	if ( len >= MAX_MENUFILE ) {
+		trap_Print( va( S_COLOR_RED "menu file too large: %s is %i, max allowed is %i", filename, len, MAX_MENUFILE ) );
+		trap_FS_FCloseFile( f );
+		return NULL;
+	}
+
+	trap_FS_Read( buf, len, f );
+	buf[len] = 0;
+	trap_FS_FCloseFile( f );
+
+	return buf;
+}
+#endif
+
+//
+// ==============================
+// new hud stuff ( mission pack )
+// ==============================
+//
+qboolean CG_Asset_Parse(int handle) {
+	pc_token_t token;
+
+	if (!trap_PC_ReadToken(handle, &token))
+		return qfalse;
+	if (Q_stricmp(token.string, "{") != 0) {
+		return qfalse;
+	}
+    
+	while ( 1 ) {
+		if (!trap_PC_ReadToken(handle, &token))
+			return qfalse;
+
+		if (Q_stricmp(token.string, "}") == 0) {
+			return qtrue;
+		}
+
+		// font
+		if (Q_stricmp(token.string, "font") == 0) {
+			int pointSize;
+			if (!trap_PC_ReadToken(handle, &token) || !PC_Int_Parse(handle, &pointSize)) {
+				return qfalse;
+			}
+
+//			cgDC.registerFont(token.string, pointSize, &cgDC.Assets.textFont);
+			cgDC.Assets.qhMediumFont = cgDC.RegisterFont(token.string);
+			continue;
+		}
+
+		// smallFont
+		if (Q_stricmp(token.string, "smallFont") == 0) {
+			int pointSize;
+			if (!trap_PC_ReadToken(handle, &token) || !PC_Int_Parse(handle, &pointSize)) {
+				return qfalse;
+			}
+//			cgDC.registerFont(token.string, pointSize, &cgDC.Assets.smallFont);
+			cgDC.Assets.qhSmallFont = cgDC.RegisterFont(token.string);
+			continue;
+		}
+
+		// smallFont
+		if (Q_stricmp(token.string, "small2Font") == 0) {
+			int pointSize;
+			if (!trap_PC_ReadToken(handle, &token) || !PC_Int_Parse(handle, &pointSize)) {
+				return qfalse;
+			}
+//			cgDC.registerFont(token.string, pointSize, &cgDC.Assets.smallFont);
+			cgDC.Assets.qhSmall2Font = cgDC.RegisterFont(token.string);
+			continue;
+		}
+
+		// font
+		if (Q_stricmp(token.string, "bigfont") == 0) {
+			int pointSize;
+			if (!trap_PC_ReadToken(handle, &token) || !PC_Int_Parse(handle, &pointSize)) {
+				return qfalse;
+			}
+//			cgDC.registerFont(token.string, pointSize, &cgDC.Assets.bigFont);
+			cgDC.Assets.qhBigFont = cgDC.RegisterFont(token.string);
+			continue;
+		}
+
+		// gradientbar
+		if (Q_stricmp(token.string, "gradientbar") == 0) {
+			if (!trap_PC_ReadToken(handle, &token)) {
+				return qfalse;
+			}
+			cgDC.Assets.gradientBar = trap_R_RegisterShaderNoMip(token.string);
+			continue;
+		}
+
+		// enterMenuSound
+		if (Q_stricmp(token.string, "menuEnterSound") == 0) {
+			if (!trap_PC_ReadToken(handle, &token)) {
+				return qfalse;
+			}
+			cgDC.Assets.menuEnterSound = trap_S_RegisterSound( token.string );
+			continue;
+		}
+
+		// exitMenuSound
+		if (Q_stricmp(token.string, "menuExitSound") == 0) {
+			if (!trap_PC_ReadToken(handle, &token)) {
+				return qfalse;
+			}
+			cgDC.Assets.menuExitSound = trap_S_RegisterSound( token.string );
+			continue;
+		}
+
+		// itemFocusSound
+		if (Q_stricmp(token.string, "itemFocusSound") == 0) {
+			if (!trap_PC_ReadToken(handle, &token)) {
+				return qfalse;
+			}
+			cgDC.Assets.itemFocusSound = trap_S_RegisterSound( token.string );
+			continue;
+		}
+
+		// menuBuzzSound
+		if (Q_stricmp(token.string, "menuBuzzSound") == 0) {
+			if (!trap_PC_ReadToken(handle, &token)) {
+				return qfalse;
+			}
+			cgDC.Assets.menuBuzzSound = trap_S_RegisterSound( token.string );
+			continue;
+		}
+
+		if (Q_stricmp(token.string, "cursor") == 0) {
+			if (!PC_String_Parse(handle, &cgDC.Assets.cursorStr)) {
+				return qfalse;
+			}
+			cgDC.Assets.cursor = trap_R_RegisterShaderNoMip( cgDC.Assets.cursorStr);
+			continue;
+		}
+
+		if (Q_stricmp(token.string, "fadeClamp") == 0) {
+			if (!PC_Float_Parse(handle, &cgDC.Assets.fadeClamp)) {
+				return qfalse;
+			}
+			continue;
+		}
+
+		if (Q_stricmp(token.string, "fadeCycle") == 0) {
+			if (!PC_Int_Parse(handle, &cgDC.Assets.fadeCycle)) {
+				return qfalse;
+			}
+			continue;
+		}
+
+		if (Q_stricmp(token.string, "fadeAmount") == 0) {
+			if (!PC_Float_Parse(handle, &cgDC.Assets.fadeAmount)) {
+				return qfalse;
+			}
+			continue;
+		}
+
+		if (Q_stricmp(token.string, "shadowX") == 0) {
+			if (!PC_Float_Parse(handle, &cgDC.Assets.shadowX)) {
+				return qfalse;
+			}
+			continue;
+		}
+
+		if (Q_stricmp(token.string, "shadowY") == 0) {
+			if (!PC_Float_Parse(handle, &cgDC.Assets.shadowY)) {
+				return qfalse;
+			}
+			continue;
+		}
+
+		if (Q_stricmp(token.string, "shadowColor") == 0) {
+			if (!PC_Color_Parse(handle, &cgDC.Assets.shadowColor)) {
+				return qfalse;
+			}
+			cgDC.Assets.shadowFadeClamp = cgDC.Assets.shadowColor[3];
+			continue;
+		}
+	}
+	return qfalse; // bk001204 - why not?
+}
+
+void CG_ParseMenu(const char *menuFile) {
+	pc_token_t token;
+	int handle;
+
+	handle = trap_PC_LoadSource(menuFile);
+	if (!handle)
+		handle = trap_PC_LoadSource("ui/testhud.menu");
+	if (!handle)
+		return;
+
+	while ( 1 ) {
+		if (!trap_PC_ReadToken( handle, &token )) {
+			break;
+		}
+
+		//if ( Q_stricmp( token, "{" ) ) {
+		//	Com_Printf( "Missing { in menu file\n" );
+		//	break;
+		//}
+
+		//if ( menuCount == MAX_MENUS ) {
+		//	Com_Printf( "Too many menus!\n" );
+		//	break;
+		//}
+
+		if ( token.string[0] == '}' ) {
+			break;
+		}
+
+		if (Q_stricmp(token.string, "assetGlobalDef") == 0) {
+			if (CG_Asset_Parse(handle)) {
+				continue;
+			} else {
+				break;
+			}
+		}
+
+
+		if (Q_stricmp(token.string, "menudef") == 0) {
+			// start a new menu
+			Menu_New(handle);
+		}
+	}
+	trap_PC_FreeSource(handle);
+}
+
+
+qboolean CG_Load_Menu(const char **p) 
+{
+
+	char *token;
+
+	token = COM_ParseExt((const char **)p, qtrue);
+
+	if (token[0] != '{') {
+		return qfalse;
+	}
+
+	while ( 1 ) {
+
+		token = COM_ParseExt((const char **)p, qtrue);
+    
+		if (Q_stricmp(token, "}") == 0) {
+			return qtrue;
+		}
+
+		if ( !token || token[0] == 0 ) {
+			return qfalse;
+		}
+
+		CG_ParseMenu(token); 
+	}
+	return qfalse;
+}
+
+
+static qboolean CG_OwnerDrawHandleKey(int ownerDraw, int flags, float *special, int key) {
+	return qfalse;
+}
+
+
+static int CG_FeederCount(float feederID) {
+	int i, count;
+	count = 0;
+	if (feederID == FEEDER_REDTEAM_LIST) {
+		for (i = 0; i < cg.numScores; i++) {
+			if (cg.scores[i].team == TEAM_RED) {
+				count++;
+			}
+		}
+	} else if (feederID == FEEDER_BLUETEAM_LIST) {
+		for (i = 0; i < cg.numScores; i++) {
+			if (cg.scores[i].team == TEAM_BLUE) {
+				count++;
+			}
+		}
+	} else if (feederID == FEEDER_SCOREBOARD) {
+		return cg.numScores;
+	}
+	return count;
+}
+
+
+void CG_SetScoreSelection(void *p) {
+	menuDef_t *menu = (menuDef_t*)p;
+	playerState_t *ps = &cg.snap->ps;
+	int i, red, blue;
+	red = blue = 0;
+	for (i = 0; i < cg.numScores; i++) {
+		if (cg.scores[i].team == TEAM_RED) {
+			red++;
+		} else if (cg.scores[i].team == TEAM_BLUE) {
+			blue++;
+		}
+		if (ps->clientNum == cg.scores[i].client) {
+			cg.selectedScore = i;
+		}
+	}
+
+	if (menu == NULL) {
+		// just interested in setting the selected score
+		return;
+	}
+
+	if ( cgs.gametype >= GT_TEAM ) {
+		int feeder = FEEDER_REDTEAM_LIST;
+		i = red;
+		if (cg.scores[cg.selectedScore].team == TEAM_BLUE) {
+			feeder = FEEDER_BLUETEAM_LIST;
+			i = blue;
+		}
+		Menu_SetFeederSelection(menu, feeder, i, NULL);
+	} else {
+		Menu_SetFeederSelection(menu, FEEDER_SCOREBOARD, cg.selectedScore, NULL);
+	}
+}
+
+// FIXME: might need to cache this info
+static clientInfo_t * CG_InfoFromScoreIndex(int index, int team, int *scoreIndex) {
+	int i, count;
+	if ( cgs.gametype >= GT_TEAM ) {
+		count = 0;
+		for (i = 0; i < cg.numScores; i++) {
+			if (cg.scores[i].team == team) {
+				if (count == index) {
+					*scoreIndex = i;
+					return &cgs.clientinfo[cg.scores[i].client];
+				}
+				count++;
+			}
+		}
+	}
+	*scoreIndex = index;
+	return &cgs.clientinfo[ cg.scores[index].client ];
+}
+
+static const char *CG_FeederItemText(float feederID, int index, int column,
+									 qhandle_t *handle1, qhandle_t *handle2, qhandle_t *handle3) {
+	gitem_t *item;
+	int scoreIndex = 0;
+	clientInfo_t *info = NULL;
+	int team = -1;
+	score_t *sp = NULL;
+
+	*handle1 = *handle2 = *handle3 = -1;
+
+	if (feederID == FEEDER_REDTEAM_LIST) {
+		team = TEAM_RED;
+	} else if (feederID == FEEDER_BLUETEAM_LIST) {
+		team = TEAM_BLUE;
+	}
+
+	info = CG_InfoFromScoreIndex(index, team, &scoreIndex);
+	sp = &cg.scores[scoreIndex];
+
+	if (info && info->infoValid) {
+		switch (column) {
+			case 0:
+				if ( info->powerups & ( 1 << PW_NEUTRALFLAG ) ) {
+					item = BG_FindItemForPowerup( PW_NEUTRALFLAG );
+					*handle1 = cg_items[ ITEM_INDEX(item) ].icon;
+				} else if ( info->powerups & ( 1 << PW_REDFLAG ) ) {
+					item = BG_FindItemForPowerup( PW_REDFLAG );
+					*handle1 = cg_items[ ITEM_INDEX(item) ].icon;
+				} else if ( info->powerups & ( 1 << PW_BLUEFLAG ) ) {
+					item = BG_FindItemForPowerup( PW_BLUEFLAG );
+					*handle1 = cg_items[ ITEM_INDEX(item) ].icon;
+				} else {
+					/*	
+					if ( info->botSkill > 0 && info->botSkill <= 5 ) {
+						*handle1 = cgs.media.botSkillShaders[ info->botSkill - 1 ];
+					} else if ( info->handicap < 100 ) {
+					return va("%i", info->handicap );
+					}
+					*/
+				}
+			break;
+			case 1:
+				if (team == -1) {
+					return "";
+				} else {
+					*handle1 = CG_StatusHandle(info->teamTask);
+				}
+		  break;
+			case 2:
+				if ( cg.snap->ps.stats[ STAT_CLIENTS_READY ] & ( 1 << sp->client ) ) {
+					return "Ready";
+				}
+				if (team == -1) {
+					if (cgs.gametype == GT_DUEL || cgs.gametype == GT_POWERDUEL) {
+						return va("%i/%i", info->wins, info->losses);
+					} else if (info->infoValid && info->team == TEAM_SPECTATOR ) {
+						return "Spectator";
+					} else {
+						return "";
+					}
+				} else {
+					if (info->teamLeader) {
+						return "Leader";
+					}
+				}
+			break;
+			case 3:
+				return info->name;
+			break;
+			case 4:
+				return va("%i", info->score);
+			break;
+			case 5:
+				return va("%4i", sp->time);
+			break;
+			case 6:
+				if ( sp->ping == -1 ) {
+					return "connecting";
+				} 
+				return va("%4i", sp->ping);
+			break;
+		}
+	}
+
+	return "";
+}
+
+static qhandle_t CG_FeederItemImage(float feederID, int index) {
+	return 0;
+}
+
+static qboolean CG_FeederSelection(float feederID, int index, itemDef_t *item) {
+	if ( cgs.gametype >= GT_TEAM ) {
+		int i, count;
+		int team = (feederID == FEEDER_REDTEAM_LIST) ? TEAM_RED : TEAM_BLUE;
+		count = 0;
+		for (i = 0; i < cg.numScores; i++) {
+			if (cg.scores[i].team == team) {
+				if (index == count) {
+					cg.selectedScore = i;
+				}
+				count++;
+			}
+		}
+	} else {
+		cg.selectedScore = index;
+	}
+
+	return qtrue;
+}
+
+static float CG_Cvar_Get(const char *cvar) {
+	char buff[128];
+	memset(buff, 0, sizeof(buff));
+	trap_Cvar_VariableStringBuffer(cvar, buff, sizeof(buff));
+	return atof(buff);
+}
+
+void CG_Text_PaintWithCursor(float x, float y, float scale, vec4_t color, const char *text, int cursorPos, char cursor, int limit, int style, int iMenuFont) {
+	CG_Text_Paint(x, y, scale, color, text, 0, limit, style, iMenuFont);
+}
+
+static int CG_OwnerDrawWidth(int ownerDraw, float scale) {
+	switch (ownerDraw) {
+	  case CG_GAME_TYPE:
+			return CG_Text_Width(CG_GameTypeString(), scale, FONT_MEDIUM);
+	  case CG_GAME_STATUS:
+			return CG_Text_Width(CG_GetGameStatusText(), scale, FONT_MEDIUM);
+			break;
+	  case CG_KILLER:
+			return CG_Text_Width(CG_GetKillerText(), scale, FONT_MEDIUM);
+			break;
+	  case CG_RED_NAME:
+			return CG_Text_Width(cg_redTeamName.string, scale, FONT_MEDIUM);
+			break;
+	  case CG_BLUE_NAME:
+			return CG_Text_Width(cg_blueTeamName.string, scale, FONT_MEDIUM);
+			break;
+
+
+	}
+	return 0;
+}
+
+static int CG_PlayCinematic(const char *name, float x, float y, float w, float h) {
+  return trap_CIN_PlayCinematic(name, x, y, w, h, CIN_loop);
+}
+
+static void CG_StopCinematic(int handle) {
+  trap_CIN_StopCinematic(handle);
+}
+
+static void CG_DrawCinematic(int handle, float x, float y, float w, float h) {
+  trap_CIN_SetExtents(handle, x, y, w, h);
+  trap_CIN_DrawCinematic(handle);
+}
+
+static void CG_RunCinematicFrame(int handle) {
+  trap_CIN_RunCinematic(handle);
+}
+
+/*
+=================
+CG_LoadMenus();
+
+=================
+*/
+void CG_LoadMenus(const char *menuFile) 
+{
+	const char	*token;
+	const char	*p;
+	int	len;
+	fileHandle_t	f;
+	static char buf[MAX_MENUDEFFILE];
+
+	len = trap_FS_FOpenFile( menuFile, &f, FS_READ );
+
+	if ( !f ) 
+	{
+		trap_Print( va( S_COLOR_RED "menu file not found: %s, using default\n", menuFile ) );
+
+		len = trap_FS_FOpenFile( "ui/jahud.txt", &f, FS_READ );
+		if (!f) 
+		{
+			trap_Print( va( S_COLOR_RED "default menu file not found: ui/hud.txt, unable to continue!\n", menuFile ) );
+		}
+	}
+
+	if ( len >= MAX_MENUDEFFILE ) 
+	{
+		trap_Print( va( S_COLOR_RED "menu file too large: %s is %i, max allowed is %i", menuFile, len, MAX_MENUDEFFILE ) );
+		trap_FS_FCloseFile( f );
+		return;
+	}
+
+	trap_FS_Read( buf, len, f );
+	buf[len] = 0;
+	trap_FS_FCloseFile( f );
+	
+	p = buf;
+
+	while ( 1 ) 
+	{
+		token = COM_ParseExt( &p, qtrue );
+		if( !token || token[0] == 0 || token[0] == '}') 
+		{
+			break;
+		}
+
+		if ( Q_stricmp( token, "}" ) == 0 ) 
+		{
+			break;
+		}
+
+		if (Q_stricmp(token, "loadmenu") == 0) 
+		{
+			if (CG_Load_Menu(&p)) 
+			{
+				continue;
+			} 
+			else 
+			{
+				break;
+			}
+		}
+	}
+
+	//Com_Printf("UI menu load time = %d milli seconds\n", cgi_Milliseconds() - start);
+}
+
+/*
+=================
+CG_LoadHudMenu();
+
+=================
+*/
+void CG_LoadHudMenu() 
+{
+	const char *hudSet;
+
+	cgDC.registerShaderNoMip = &trap_R_RegisterShaderNoMip;
+	cgDC.setColor = &trap_R_SetColor;
+	cgDC.drawHandlePic = &CG_DrawPic;
+	cgDC.drawStretchPic = &trap_R_DrawStretchPic;
+	cgDC.drawText = &CG_Text_Paint;
+	cgDC.textWidth = &CG_Text_Width;
+	cgDC.textHeight = &CG_Text_Height;
+	cgDC.registerModel = &trap_R_RegisterModel;
+	cgDC.modelBounds = &trap_R_ModelBounds;
+	cgDC.fillRect = &CG_FillRect;
+	cgDC.drawRect = &CG_DrawRect;   
+	cgDC.drawSides = &CG_DrawSides;
+	cgDC.drawTopBottom = &CG_DrawTopBottom;
+	cgDC.clearScene = &trap_R_ClearScene;
+	cgDC.addRefEntityToScene = &trap_R_AddRefEntityToScene;
+	cgDC.renderScene = &trap_R_RenderScene;
+	cgDC.RegisterFont = &trap_R_RegisterFont;
+	cgDC.Font_StrLenPixels = &trap_R_Font_StrLenPixels;
+	cgDC.Font_StrLenChars = &trap_R_Font_StrLenChars;
+	cgDC.Font_HeightPixels = &trap_R_Font_HeightPixels;
+	cgDC.Font_DrawString = &trap_R_Font_DrawString;
+	cgDC.Language_IsAsian = &trap_Language_IsAsian;
+	cgDC.Language_UsesSpaces = &trap_Language_UsesSpaces;
+	cgDC.AnyLanguage_ReadCharFromString = &trap_AnyLanguage_ReadCharFromString;
+	cgDC.ownerDrawItem = &CG_OwnerDraw;
+	cgDC.getValue = &CG_GetValue;
+	cgDC.ownerDrawVisible = &CG_OwnerDrawVisible;
+	cgDC.runScript = &CG_RunMenuScript;
+	cgDC.deferScript = &CG_DeferMenuScript;
+	cgDC.getTeamColor = &CG_GetTeamColor;
+	cgDC.setCVar = trap_Cvar_Set;
+	cgDC.getCVarString = trap_Cvar_VariableStringBuffer;
+	cgDC.getCVarValue = CG_Cvar_Get;
+	cgDC.drawTextWithCursor = &CG_Text_PaintWithCursor;
+	//cgDC.setOverstrikeMode = &trap_Key_SetOverstrikeMode;
+	//cgDC.getOverstrikeMode = &trap_Key_GetOverstrikeMode;
+	cgDC.startLocalSound = &trap_S_StartLocalSound;
+	cgDC.ownerDrawHandleKey = &CG_OwnerDrawHandleKey;
+	cgDC.feederCount = &CG_FeederCount;
+	cgDC.feederItemImage = &CG_FeederItemImage;
+	cgDC.feederItemText = &CG_FeederItemText;
+	cgDC.feederSelection = &CG_FeederSelection;
+	//cgDC.setBinding = &trap_Key_SetBinding;
+	//cgDC.getBindingBuf = &trap_Key_GetBindingBuf;
+	//cgDC.keynumToStringBuf = &trap_Key_KeynumToStringBuf;
+	//cgDC.executeText = &trap_Cmd_ExecuteText;
+	cgDC.Error = &Com_Error; 
+	cgDC.Print = &Com_Printf; 
+	cgDC.ownerDrawWidth = &CG_OwnerDrawWidth;
+	//cgDC.Pause = &CG_Pause;
+	cgDC.registerSound = &trap_S_RegisterSound;
+	cgDC.startBackgroundTrack = &trap_S_StartBackgroundTrack;
+	cgDC.stopBackgroundTrack = &trap_S_StopBackgroundTrack;
+	cgDC.playCinematic = &CG_PlayCinematic;
+	cgDC.stopCinematic = &CG_StopCinematic;
+	cgDC.drawCinematic = &CG_DrawCinematic;
+	cgDC.runCinematicFrame = &CG_RunCinematicFrame;
+	
+	Init_Display(&cgDC);
+
+	Menu_Reset();
+
+	hudSet = cg_hudFiles.string;
+	if (hudSet[0] == '\0') 
+	{
+		hudSet = "ui/jahud.txt";
+	}
+
+	CG_LoadMenus(hudSet);
+
+}
+
+void CG_AssetCache() {
+	//if (Assets.textFont == NULL) {
+	//  trap_R_RegisterFont("fonts/arial.ttf", 72, &Assets.textFont);
+	//}
+	//Assets.background = trap_R_RegisterShaderNoMip( ASSET_BACKGROUND );
+	//Com_Printf("Menu Size: %i bytes\n", sizeof(Menus));
+	cgDC.Assets.gradientBar = trap_R_RegisterShaderNoMip( ASSET_GRADIENTBAR );
+	cgDC.Assets.fxBasePic = trap_R_RegisterShaderNoMip( ART_FX_BASE );
+	cgDC.Assets.fxPic[0] = trap_R_RegisterShaderNoMip( ART_FX_RED );
+	cgDC.Assets.fxPic[1] = trap_R_RegisterShaderNoMip( ART_FX_YELLOW );
+	cgDC.Assets.fxPic[2] = trap_R_RegisterShaderNoMip( ART_FX_GREEN );
+	cgDC.Assets.fxPic[3] = trap_R_RegisterShaderNoMip( ART_FX_TEAL );
+	cgDC.Assets.fxPic[4] = trap_R_RegisterShaderNoMip( ART_FX_BLUE );
+	cgDC.Assets.fxPic[5] = trap_R_RegisterShaderNoMip( ART_FX_CYAN );
+	cgDC.Assets.fxPic[6] = trap_R_RegisterShaderNoMip( ART_FX_WHITE );
+	cgDC.Assets.scrollBar = trap_R_RegisterShaderNoMip( ASSET_SCROLLBAR );
+	cgDC.Assets.scrollBarArrowDown = trap_R_RegisterShaderNoMip( ASSET_SCROLLBAR_ARROWDOWN );
+	cgDC.Assets.scrollBarArrowUp = trap_R_RegisterShaderNoMip( ASSET_SCROLLBAR_ARROWUP );
+	cgDC.Assets.scrollBarArrowLeft = trap_R_RegisterShaderNoMip( ASSET_SCROLLBAR_ARROWLEFT );
+	cgDC.Assets.scrollBarArrowRight = trap_R_RegisterShaderNoMip( ASSET_SCROLLBAR_ARROWRIGHT );
+	cgDC.Assets.scrollBarThumb = trap_R_RegisterShaderNoMip( ASSET_SCROLL_THUMB );
+	cgDC.Assets.sliderBar = trap_R_RegisterShaderNoMip( ASSET_SLIDER_BAR );
+	cgDC.Assets.sliderThumb = trap_R_RegisterShaderNoMip( ASSET_SLIDER_THUMB );
+}
+
+/*
+
+
+/*
+Ghoul2 Insert Start
+*/
+
+// initialise the cg_entities structure - take into account the ghoul2 stl stuff in the active snap shots
+void CG_Init_CG(void)
+{
+#ifdef _XBOX
+	qboolean widescreen = cg.widescreen;
+#endif
+	memset( &cg, 0, sizeof(cg));
+#ifdef _XBOX
+	cg.widescreen = widescreen;
+#endif
+}
+
+#ifdef _XBOX
+void CG_SetWidescreen(qboolean widescreen)
+{
+	cg.widescreen = widescreen;
+}
+#endif
+
+
+// initialise the cg_entities structure - take into account the ghoul2 stl stuff
+void CG_Init_CGents(void)
+{
+	
+	memset(&cg_entities, 0, sizeof(cg_entities));
+}
+
+
+void CG_InitItems(void)
+{
+	memset( cg_items, 0, sizeof( cg_items ) );
+}
+
+void CG_TransitionPermanent(void)
+{
+	centity_t	*cent = cg_entities;
+	int			i;
+
+	cg_numpermanents = 0;
+	for(i=0;i<MAX_GENTITIES;i++,cent++)
+	{
+		if (trap_GetDefaultState(i, &cent->currentState))
+		{
+			cent->nextState = cent->currentState;
+			VectorCopy (cent->currentState.origin, cent->lerpOrigin);
+			VectorCopy (cent->currentState.angles, cent->lerpAngles);
+			cent->currentValid = qtrue;
+
+			cg_permanents[cg_numpermanents++] = cent;
+		}
+	}
+}
+
+
+//this is a 32k custom pool for parsing ents, it can get reset between ent parsing
+//so we don't need a whole lot of memory -rww
+#define MAX_CGSTRPOOL_SIZE		32768
+static int cg_strPoolSize = 0;
+static byte cg_strPool[MAX_CGSTRPOOL_SIZE];
+
+char *CG_StrPool_Alloc(int size)
+{
+	char *giveThemThis;
+
+	if (cg_strPoolSize+size >= MAX_CGSTRPOOL_SIZE)
+	{
+		Com_Error(ERR_DROP, "You exceeded the cgame string pool size. Bad programmer!\n");
+	}
+
+	giveThemThis = (char *) &cg_strPool[cg_strPoolSize];
+	cg_strPoolSize += size;
+
+	//memset it for them, just to be nice.
+	memset(giveThemThis, 0, size);
+
+	return giveThemThis;
+}
+
+void CG_StrPool_Reset(void)
+{
+	cg_strPoolSize = 0;
+}
+
+/*
+=============
+CG_NewString
+
+Builds a copy of the string, translating \n to real linefeeds
+so message texts can be multi-line
+=============
+*/
+char *CG_NewString( const char *string )
+{
+	char	*newb, *new_p;
+	int		i,l;
+	
+	l = strlen(string) + 1;
+
+	newb = CG_StrPool_Alloc( l );
+
+	new_p = newb;
+
+	// turn \n into a real linefeed
+	for ( i=0 ; i< l ; i++ ) {
+		if (string[i] == '\\' && i < l-1) {
+			i++;
+			if (string[i] == 'n') {
+				*new_p++ = '\n';
+			} else {
+				*new_p++ = '\\';
+			}
+		} else {
+			*new_p++ = string[i];
+		}
+	}
+	
+	return newb;
+}
+
+//data to grab our spawn info into
+typedef struct cgSpawnEnt_s
+{
+	char		*classname;
+	vec3_t		origin;
+	vec3_t		angles;
+	float		angle;
+	vec3_t		scale;
+	float		fScale;
+	vec3_t		mins;
+	vec3_t		maxs;
+	char		*model;
+	float		zoffset;
+	int			onlyFogHere;
+	float		fogstart;
+	float		radarrange;
+} cgSpawnEnt_t;
+
+#define	CGFOFS(x) ((int)&(((cgSpawnEnt_t *)0)->x))
+
+//spawn fields for our cgame "entity"
+BG_field_t cg_spawnFields[] =
+{
+	{"classname", CGFOFS(classname), F_LSTRING},
+	{"origin", CGFOFS(origin), F_VECTOR},
+	{"angles", CGFOFS(angles), F_VECTOR},
+	{"angle", CGFOFS(angle), F_FLOAT},
+	{"modelscale", CGFOFS(fScale), F_FLOAT},
+	{"modelscale_vec", CGFOFS(scale), F_VECTOR},
+	{"model", CGFOFS(model), F_LSTRING},
+	{"mins", CGFOFS(mins), F_VECTOR},
+	{"maxs", CGFOFS(maxs), F_VECTOR},
+	{"zoffset", CGFOFS(zoffset), F_FLOAT},
+	{"onlyfoghere", CGFOFS(onlyFogHere), F_INT},
+	{"fogstart", CGFOFS(fogstart), F_FLOAT},
+	{"radarrange", CGFOFS(radarrange), F_FLOAT},
+	{NULL}
+};
+
+static int cg_numSpawnVars;
+static int cg_numSpawnVarChars;
+static char *cg_spawnVars[MAX_SPAWN_VARS][2];
+static char cg_spawnVarChars[MAX_SPAWN_VARS_CHARS];
+
+//get some info from the skyportal ent on the map
+qboolean cg_noFogOutsidePortal = qfalse;
+void CG_CreateSkyPortalFromSpawnEnt(cgSpawnEnt_t *ent)
+{
+	if (ent->onlyFogHere)
+	{ //only globally fog INSIDE the sky portal
+		cg_noFogOutsidePortal = qtrue;
+	}
+}
+
+//create a skybox portal orientation entity. there -should- only
+//be one of these things per level. if there's more than one the
+//next will just stomp over the last. -rww
+qboolean cg_skyOri = qfalse;
+vec3_t cg_skyOriPos;
+float cg_skyOriScale = 0.0f;
+void CG_CreateSkyOriFromSpawnEnt(cgSpawnEnt_t *ent)
+{
+    cg_skyOri = qtrue;
+	VectorCopy(ent->origin, cg_skyOriPos);
+	cg_skyOriScale = ent->fScale;
+}
+
+//get brush box extents, note this does not care about bsp instances.
+void CG_CreateBrushEntData(cgSpawnEnt_t *ent)
+{
+	trap_R_ModelBounds(trap_R_RegisterModel(ent->model), ent->mins, ent->maxs);
+}
+
+void CG_CreateWeatherZoneFromSpawnEnt(cgSpawnEnt_t *ent)
+{
+	CG_CreateBrushEntData(ent);
+	trap_WE_AddWeatherZone(ent->mins, ent->maxs);
+}
+
+//create a new cgame-only model
+void CG_CreateModelFromSpawnEnt(cgSpawnEnt_t *ent)
+{
+	int			modelIndex;
+	refEntity_t	*RefEnt;
+	vec3_t		mins, maxs;
+	float		*radius;
+	float		*zOff;
+
+	if (NumMiscEnts >= MAX_MISC_ENTS)
+	{
+		Com_Error(ERR_DROP, "Too many misc_model_static's on level, ask a programmer to raise the limit (currently %i), or take some out.", MAX_MISC_ENTS);
+		return;
+	}
+	
+	if (!ent || !ent->model || !ent->model[0])
+	{
+		Com_Error(ERR_DROP, "misc_model_static with no model.");
+		return;
+	}
+
+	radius = &Radius[NumMiscEnts];
+	zOff = &zOffset[NumMiscEnts];
+	RefEnt = &MiscEnts[NumMiscEnts++];
+
+	modelIndex = trap_R_RegisterModel(ent->model);
+	if (modelIndex == 0)
+	{
+		Com_Error(ERR_DROP, "misc_model_static failed to load model '%s'",ent->model);
+		return;
+	}
+
+	memset(RefEnt, 0, sizeof(refEntity_t));
+	RefEnt->reType = RT_MODEL;
+	RefEnt->hModel = modelIndex;
+	RefEnt->frame = 0;
+	trap_R_ModelBounds(modelIndex, mins, maxs);
+	VectorCopy(ent->scale, RefEnt->modelScale);
+	if (ent->fScale)
+	{ //use same scale on each axis then
+		RefEnt->modelScale[0] = RefEnt->modelScale[1] = RefEnt->modelScale[2] = ent->fScale;
+	}
+	VectorCopy(ent->origin, RefEnt->origin);
+	VectorCopy(ent->origin, RefEnt->lightingOrigin);
+
+	VectorScaleVector(mins, ent->scale, mins);
+	VectorScaleVector(maxs, ent->scale, maxs);
+	*radius = Distance(mins, maxs);
+	*zOff = ent->zoffset;
+
+	if (ent->angle)
+	{ //only yaw supplied...
+		ent->angles[YAW] = ent->angle;
+	}
+
+	AnglesToAxis( ent->angles, RefEnt->axis );
+	ScaleModelAxis(RefEnt);
+}
+
+/*
+====================
+CG_AddSpawnVarToken
+====================
+*/
+char *CG_AddSpawnVarToken( const char *string )
+{
+	int		l;
+	char	*dest;
+
+	l = strlen( string );
+	if ( cg_numSpawnVarChars + l + 1 > MAX_SPAWN_VARS_CHARS ) {
+		CG_Error( "CG_AddSpawnVarToken: MAX_SPAWN_VARS" );
+	}
+
+	dest = cg_spawnVarChars + cg_numSpawnVarChars;
+	memcpy( dest, string, l+1 );
+
+	cg_numSpawnVarChars += l + 1;
+
+	return dest;
+}
+
+/*
+====================
+CG_ParseSpawnVars
+
+cgame version of G_ParseSpawnVars, for ents that don't really
+need to take up an entity slot (e.g. static models) -rww
+====================
+*/
+qboolean CG_ParseSpawnVars( void )
+{
+	char		keyname[MAX_TOKEN_CHARS];
+	char		com_token[MAX_TOKEN_CHARS];
+
+	cg_numSpawnVars = 0;
+	cg_numSpawnVarChars = 0;
+
+	// parse the opening brace
+	if ( !trap_GetEntityToken( com_token, sizeof( com_token ) ) ) {
+		// end of spawn string
+		return qfalse;
+	}
+	if ( com_token[0] != '{' ) {
+		CG_Error( "CG_ParseSpawnVars: found %s when expecting {",com_token );
+	}
+
+	// go through all the key / value pairs
+	while ( 1 )
+	{	
+		// parse key
+		if ( !trap_GetEntityToken( keyname, sizeof( keyname ) ) )
+		{
+			CG_Error( "CG_ParseSpawnVars: EOF without closing brace" );
+		}
+
+		if ( keyname[0] == '}' )
+		{
+			break;
+		}
+		
+		// parse value	
+		if ( !trap_GetEntityToken( com_token, sizeof( com_token ) ) )
+		{ //this happens on mike's test level, I don't know why. Fixme?
+			//CG_Error( "CG_ParseSpawnVars: EOF without closing brace" );
+			break;
+		}
+
+		if ( com_token[0] == '}' )
+		{
+			CG_Error( "CG_ParseSpawnVars: closing brace without data" );
+		}
+		if ( cg_numSpawnVars == MAX_SPAWN_VARS )
+		{
+			CG_Error( "CG_ParseSpawnVars: MAX_SPAWN_VARS" );
+		}
+		cg_spawnVars[ cg_numSpawnVars ][0] = CG_AddSpawnVarToken( keyname );
+		cg_spawnVars[ cg_numSpawnVars ][1] = CG_AddSpawnVarToken( com_token );
+		cg_numSpawnVars++;
+	}
+
+	return qtrue;
+}
+
+/*
+==============
+CG_SpawnCGameEntFromVars
+
+See if we should do something for this ent cgame-side -rww
+==============
+*/
+#include "../namespace_begin.h"
+void BG_ParseField( BG_field_t *l_fields, const char *key, const char *value, byte *ent );
+#include "../namespace_end.h"
+
+extern float cg_linearFogOverride; //cg_view.c
+extern float cg_radarRange;//cg_draw.c
+void CG_SpawnCGameEntFromVars(void)
+{
+	int i;
+	cgSpawnEnt_t ent;
+
+	memset(&ent, 0, sizeof(cgSpawnEnt_t));
+
+	for (i = 0; i < cg_numSpawnVars; i++)
+	{ //shove all this stuff into our data structure used specifically for getting spawn info
+		BG_ParseField( cg_spawnFields, cg_spawnVars[i][0], cg_spawnVars[i][1], (byte *)&ent );
+	}
+
+	if (ent.classname && ent.classname[0])
+	{ //we'll just stricmp this bastard, since there aren't all that many cgame-only things, and they all have special handling
+		if (!Q_stricmp(ent.classname, "worldspawn"))
+		{ //I'd like some info off this guy
+            if (ent.fogstart)
+			{ //linear fog method
+				cg_linearFogOverride = ent.fogstart;
+			}
+			//get radarRange off of worldspawn
+            if (ent.radarrange)
+			{ //linear fog method
+				cg_radarRange = ent.radarrange;
+			}
+		}
+		else if (!Q_stricmp(ent.classname, "misc_model_static"))
+		{ //we've got us a static model
+            CG_CreateModelFromSpawnEnt(&ent);			
+		}
+		else if (!Q_stricmp(ent.classname, "misc_skyportal_orient"))
+		{ //a sky portal orientation point
+            CG_CreateSkyOriFromSpawnEnt(&ent);            
+		}
+		else if (!Q_stricmp(ent.classname, "misc_skyportal"))
+		{ //might as well parse this thing cgame side for the extra info I want out of it
+			CG_CreateSkyPortalFromSpawnEnt(&ent);            
+		}
+		else if (!Q_stricmp(ent.classname, "misc_weather_zone"))
+		{ //might as well parse this thing cgame side for the extra info I want out of it
+			CG_CreateWeatherZoneFromSpawnEnt(&ent);
+		}
+	}
+
+	//reset the string pool for the next entity, if there is one
+    CG_StrPool_Reset();
+}
+
+/*
+==============
+CG_SpawnCGameOnlyEnts
+
+Parses entity string data for cgame-only entities, that we can throw away on
+the server and never even bother sending. -rww
+==============
+*/
+void CG_SpawnCGameOnlyEnts(void)
+{
+	//make sure it is reset
+	trap_GetEntityToken(NULL, -1);
+
+	if (!CG_ParseSpawnVars())
+	{ //first one is gonna be the world spawn
+		CG_Error("no entities for cgame parse");
+	}
+	else
+	{ //parse the world spawn info we want
+		CG_SpawnCGameEntFromVars();
+	}
+
+	while(CG_ParseSpawnVars())
+	{ //now run through the whole list, and look for things we care about cgame-side
+		CG_SpawnCGameEntFromVars();
+	}		
+}
+
+/*
+Ghoul2 Insert End
+*/
+
+extern playerState_t *cgSendPS[MAX_GENTITIES]; //is not MAX_CLIENTS because NPCs exceed MAX_CLIENTS
+void CG_PmoveClientPointerUpdate();
+
+#include "../namespace_begin.h"
+void WP_SaberLoadParms( void );
+void BG_VehicleLoadParms( void );
+#include "../namespace_end.h"
+
+/*
+=================
+CG_Init
+
+Called after every level change or subsystem restart
+Will perform callbacks to make the loading info screen update.
+=================
+*/
+void CG_Init( int serverMessageNum, int serverCommandSequence, int clientNum )
+{
+	static gitem_t *item;
+	char buf[64];
+	const char	*s;
+	int i = 0;
+
+	BG_InitAnimsets(); //clear it out
+
+	trap_CG_RegisterSharedMemory(cg.sharedBuffer);
+
+	//Load external vehicle data
+	BG_VehicleLoadParms();
+
+	// clear everything
+/*
+Ghoul2 Insert Start
+*/
+
+//	memset( cg_entities, 0, sizeof( cg_entities ) );
+	CG_Init_CGents();
+// this is a No-No now we have stl vector classes in here.
+//	memset( &cg, 0, sizeof( cg ) );
+	CG_Init_CG();
+	CG_InitItems();
+
+	//create the global jetpack instance
+	CG_InitJetpackGhoul2();
+
+	CG_PmoveClientPointerUpdate();
+
+/*
+Ghoul2 Insert End
+*/
+
+	//Load sabers.cfg data
+	WP_SaberLoadParms();
+
+	// this is kinda dumb as well, but I need to pre-load some fonts in order to have the text available
+	//	to say I'm loading the assets.... which includes loading the fonts. So I'll set these up as reasonable
+	//	defaults, then let the menu asset parser (which actually specifies the ingame fonts) load over them
+	//	if desired during parse.  Dunno how legal it is to store in these cgDC things, but it causes no harm
+	//	and even if/when they get overwritten they'll be legalised by the menu asset parser :-)
+//	CG_LoadFonts();
+	cgDC.Assets.qhSmallFont  = trap_R_RegisterFont("ocr_a");
+	cgDC.Assets.qhMediumFont = trap_R_RegisterFont("ergoec");
+	cgDC.Assets.qhBigFont = cgDC.Assets.qhMediumFont;
+
+	memset( &cgs, 0, sizeof( cgs ) );
+	memset( cg_weapons, 0, sizeof(cg_weapons) );
+
+	cg.clientNum = clientNum;
+
+	cgs.processedSnapshotNum = serverMessageNum;
+	cgs.serverCommandSequence = serverCommandSequence;
+
+	cg.loadLCARSStage		= 0;
+
+	cg.itemSelect = -1;
+	cg.forceSelect = -1;
+	
+	// load a few needed things before we do any screen updates
+	cgs.media.charsetShader		= trap_R_RegisterShaderNoMip( "gfx/2d/charsgrid_med" );
+	cgs.media.whiteShader		= trap_R_RegisterShader( "white" );
+
+	cgs.media.loadBarLED		= trap_R_RegisterShaderNoMip( "gfx/hud/load_tick" );
+	cgs.media.loadBarLEDCap		= trap_R_RegisterShaderNoMip( "gfx/hud/load_tick_cap" );
+	cgs.media.loadBarLEDSurround= trap_R_RegisterShaderNoMip( "gfx/hud/mp_levelload" );
+
+	// Force HUD set up
+	cg.forceHUDActive = qtrue;
+	cg.forceHUDTotalFlashTime = 0;
+	cg.forceHUDNextFlashTime = 0;
+
+	i = WP_NONE+1;
+	while (i <= LAST_USEABLE_WEAPON)
+	{
+		item = BG_FindItemForWeapon(i);
+
+		if (item && item->icon && item->icon[0])
+		{
+			cgs.media.weaponIcons[i] = trap_R_RegisterShaderNoMip(item->icon);
+			cgs.media.weaponIcons_NA[i] = trap_R_RegisterShaderNoMip(va("%s_na", item->icon));
+		}
+		else
+		{ //make sure it is zero'd (default shader)
+			cgs.media.weaponIcons[i] = 0;
+			cgs.media.weaponIcons_NA[i] = 0;
+		}
+		i++;
+	}
+	trap_Cvar_VariableStringBuffer("com_buildscript", buf, sizeof(buf));
+	if (atoi(buf))
+	{
+		trap_R_RegisterShaderNoMip("gfx/hud/w_icon_saberstaff");
+		trap_R_RegisterShaderNoMip("gfx/hud/w_icon_duallightsaber");
+	}
+	i = 0;
+
+	// HUD artwork for cycling inventory,weapons and force powers 
+	cgs.media.weaponIconBackground		= trap_R_RegisterShaderNoMip( "gfx/hud/background");
+	cgs.media.forceIconBackground		= trap_R_RegisterShaderNoMip( "gfx/hud/background_f");
+	cgs.media.inventoryIconBackground	= trap_R_RegisterShaderNoMip( "gfx/hud/background_i");
+
+	//rww - precache holdable item icons here
+	while (i < bg_numItems)
+	{
+		if (bg_itemlist[i].giType == IT_HOLDABLE)
+		{
+			if (bg_itemlist[i].icon)
+			{
+				cgs.media.invenIcons[bg_itemlist[i].giTag] = trap_R_RegisterShaderNoMip(bg_itemlist[i].icon);
+			}
+			else
+			{
+				cgs.media.invenIcons[bg_itemlist[i].giTag] = 0;
+			}
+		}
+
+		i++;
+	}
+
+	//rww - precache force power icons here
+	i = 0;
+
+	while (i < NUM_FORCE_POWERS)
+	{
+		cgs.media.forcePowerIcons[i] = trap_R_RegisterShaderNoMip(HolocronIcons[i]);
+
+		i++;
+	}
+	cgs.media.rageRecShader = trap_R_RegisterShaderNoMip("gfx/mp/f_icon_ragerec");
+
+
+	//body decal shaders -rww
+	cgs.media.bdecal_bodyburn1 = trap_R_RegisterShader("gfx/damage/bodyburnmark1");
+	cgs.media.bdecal_saberglow = trap_R_RegisterShader("gfx/damage/saberglowmark");
+	cgs.media.bdecal_burn1 = trap_R_RegisterShader("gfx/damage/bodybigburnmark1");
+	cgs.media.mSaberDamageGlow = trap_R_RegisterShader("gfx/effects/saberDamageGlow");
+
+	CG_RegisterCvars();
+
+	CG_InitConsoleCommands();
+
+	cg.weaponSelect = WP_BRYAR_PISTOL;
+
+	cgs.redflag = cgs.blueflag = -1; // For compatibily, default to unset for
+	cgs.flagStatus = -1;
+	// old servers
+
+	// get the rendering configuration from the client system
+	trap_GetGlconfig( &cgs.glconfig );
+	cgs.screenXScale = cgs.glconfig.vidWidth / 640.0;
+	cgs.screenYScale = cgs.glconfig.vidHeight / 480.0;
+
+	// get the gamestate from the client system
+	trap_GetGameState( &cgs.gameState );
+
+	CG_TransitionPermanent(); //rwwRMG - added
+
+	// check version
+	s = CG_ConfigString( CS_GAME_VERSION );
+	if ( strcmp( s, GAME_VERSION ) ) {
+		CG_Error( "Client/Server game mismatch: %s/%s", GAME_VERSION, s );
+	}
+
+	s = CG_ConfigString( CS_LEVEL_START_TIME );
+	cgs.levelStartTime = atoi( s );
+
+	CG_ParseServerinfo();
+
+	// load the new map
+//	CG_LoadingString( "collision map" );
+
+	trap_CM_LoadMap( cgs.mapname, qfalse );
+
+	String_Init();
+
+	cg.loading = qtrue;		// force players to load instead of defer
+
+	//make sure saber data is loaded before this! (so we can precache the appropriate hilts)
+	CG_InitSiegeMode();
+
+	CG_RegisterSounds();
+
+//	CG_LoadingString( "graphics" );
+
+	CG_RegisterGraphics();
+
+//	CG_LoadingString( "clients" );
+
+	CG_RegisterClients();		// if low on memory, some clients will be deferred
+
+	CG_AssetCache();
+	CG_LoadHudMenu();      // load new hud stuff
+
+	cg.loading = qfalse;	// future players will be deferred
+
+	CG_InitLocalEntities();
+
+	CG_InitMarkPolys();
+
+	// remove the last loading update
+	cg.infoScreenText[0] = 0;
+
+	// Make sure we have update values (scores)
+	CG_SetConfigValues();
+
+	CG_StartMusic(qfalse);
+
+//	CG_LoadingString( "Clearing light styles" );
+	CG_ClearLightStyles();
+
+//	CG_LoadingString( "Creating automap data" );
+	//init automap
+#ifndef _XBOX
+	trap_R_InitWireframeAutomap();
+#endif
+
+	CG_LoadingString( "" );
+
+	CG_ShaderStateChanged();
+
+	trap_S_ClearLoopingSounds();
+
+	trap_R_GetDistanceCull(&cg.distanceCull);
+
+	//now get all the cgame only cents
+	CG_SpawnCGameOnlyEnts();
+}
+
+//makes sure returned string is in localized format
+const char *CG_GetLocationString(const char *loc)
+{
+	static char text[1024]={0};
+
+	if (!loc || loc[0] != '@')
+	{ //just a raw string
+		return loc;
+	}
+
+	trap_SP_GetStringTextString(loc+1, text, sizeof(text));
+	return text;
+}
+
+//clean up all the ghoul2 allocations, the nice and non-hackly way -rww
+void CG_KillCEntityG2(int entNum);
+void CG_DestroyAllGhoul2(void)
+{
+	int i = 0;
+	int j;
+
+//	Com_Printf("... CGameside GHOUL2 Cleanup\n");
+	while (i < MAX_GENTITIES)
+	{ //free all dynamically allocated npc client info structs and ghoul2 instances
+		CG_KillCEntityG2(i);	
+		i++;
+	}
+	
+	//Clean the weapon instances
+	CG_ShutDownG2Weapons();
+
+	i = 0;
+	while (i < MAX_ITEMS)
+	{ //and now for items
+		j = 0;
+		while (j < MAX_ITEM_MODELS)
+		{
+			if (cg_items[i].g2Models[j] && trap_G2_HaveWeGhoul2Models(cg_items[i].g2Models[j]))
+			{
+				trap_G2API_CleanGhoul2Models(&cg_items[i].g2Models[j]);
+				cg_items[i].g2Models[j] = NULL;
+			}
+			j++;
+		}
+		i++;
+	}
+
+	//Clean the global jetpack instance
+	CG_CleanJetpackGhoul2();
+}
+
+/*
+=================
+CG_Shutdown
+
+Called before every level change or subsystem restart
+=================
+*/
+void CG_Shutdown( void ) 
+{
+	BG_ClearAnimsets(); //free all dynamic allocations made through the engine
+
+    CG_DestroyAllGhoul2();
+
+//	Com_Printf("... FX System Cleanup\n");
+	trap_FX_FreeSystem();
+	trap_ROFF_Clean();
+
+	if (cgWeatherOverride)
+	{
+		trap_R_WeatherContentsOverride(0); //rwwRMG - reset it engine-side
+	}
+
+	//reset weather
+	trap_R_WorldEffectCommand("die");
+
+	UI_CleanupGhoul2();
+	//If there was any ghoul2 stuff in our side of the shared ui code, then remove it now.
+
+	// some mods may need to do cleanup work here,
+	// like closing files or archiving session data
+}
+
+/*
+===============
+CG_NextForcePower_f
+===============
+*/
+void CG_NextForcePower_f( void ) 
+{
+	int current;
+	usercmd_t cmd;
+	if ( !cg.snap )
+	{
+		return;
+	}
+
+	if (cg.predictedPlayerState.pm_type == PM_SPECTATOR)
+	{
+		return;
+	}
+
+	current = trap_GetCurrentCmdNumber();
+	trap_GetUserCmd(current, &cmd);
+	if ((cmd.buttons & BUTTON_USE) || CG_NoUseableForce())
+	{
+		CG_NextInventory_f();
+		return;
+	}
+
+	if (cg.snap->ps.pm_flags & PMF_FOLLOW)
+	{
+		return;
+	}
+
+//	BG_CycleForce(&cg.snap->ps, 1);
+	if (cg.forceSelect != -1)
+	{
+		cg.snap->ps.fd.forcePowerSelected = cg.forceSelect;
+	}
+
+	BG_CycleForce(&cg.snap->ps, 1);
+
+	if (cg.snap->ps.fd.forcePowersKnown & (1 << cg.snap->ps.fd.forcePowerSelected))
+	{
+		cg.forceSelect = cg.snap->ps.fd.forcePowerSelected;
+		cg.forceSelectTime = cg.time;
+	}
+}
+
+/*
+===============
+CG_PrevForcePower_f
+===============
+*/
+void CG_PrevForcePower_f( void ) 
+{
+	int current;
+	usercmd_t cmd;
+	if ( !cg.snap )
+	{
+		return;
+	}
+
+	if (cg.predictedPlayerState.pm_type == PM_SPECTATOR)
+	{
+		return;
+	}
+
+	current = trap_GetCurrentCmdNumber();
+	trap_GetUserCmd(current, &cmd);
+	if ((cmd.buttons & BUTTON_USE) || CG_NoUseableForce())
+	{
+		CG_PrevInventory_f();
+		return;
+	}
+
+	if (cg.snap->ps.pm_flags & PMF_FOLLOW)
+	{
+		return;
+	}
+
+//	BG_CycleForce(&cg.snap->ps, -1);
+	if (cg.forceSelect != -1)
+	{
+		cg.snap->ps.fd.forcePowerSelected = cg.forceSelect;
+	}
+
+	BG_CycleForce(&cg.snap->ps, -1);
+
+	if (cg.snap->ps.fd.forcePowersKnown & (1 << cg.snap->ps.fd.forcePowerSelected))
+	{
+		cg.forceSelect = cg.snap->ps.fd.forcePowerSelected;
+		cg.forceSelectTime = cg.time;
+	}
+}
+
+void CG_NextInventory_f(void)
+{
+	if ( !cg.snap )
+	{
+		return;
+	}
+
+	if (cg.snap->ps.pm_flags & PMF_FOLLOW)
+	{
+		return;
+	}
+
+	if (cg.predictedPlayerState.pm_type == PM_SPECTATOR)
+	{
+		return;
+	}
+
+	if (cg.itemSelect != -1)
+	{
+		cg.snap->ps.stats[STAT_HOLDABLE_ITEM] = BG_GetItemIndexByTag(cg.itemSelect, IT_HOLDABLE);
+	}
+	BG_CycleInven(&cg.snap->ps, 1);
+
+	if (cg.snap->ps.stats[STAT_HOLDABLE_ITEM])
+	{
+		cg.itemSelect = bg_itemlist[cg.snap->ps.stats[STAT_HOLDABLE_ITEM]].giTag;
+		cg.invenSelectTime = cg.time;
+	}
+}
+
+void CG_PrevInventory_f(void)
+{
+	if ( !cg.snap )
+	{
+		return;
+	}
+
+	if (cg.snap->ps.pm_flags & PMF_FOLLOW)
+	{
+		return;
+	}
+
+	if (cg.predictedPlayerState.pm_type == PM_SPECTATOR)
+	{
+		return;
+	}
+
+	if (cg.itemSelect != -1)
+	{
+		cg.snap->ps.stats[STAT_HOLDABLE_ITEM] = BG_GetItemIndexByTag(cg.itemSelect, IT_HOLDABLE);
+	}
+	BG_CycleInven(&cg.snap->ps, -1);
+
+	if (cg.snap->ps.stats[STAT_HOLDABLE_ITEM])
+	{
+		cg.itemSelect = bg_itemlist[cg.snap->ps.stats[STAT_HOLDABLE_ITEM]].giTag;
+		cg.invenSelectTime = cg.time;
+	}
+}
diff --git a/codemp/cgame/cg_marks.c b/codemp/cgame/cg_marks.c
new file mode 100644
index 0000000..3e6af97
--- /dev/null
+++ b/codemp/cgame/cg_marks.c
@@ -0,0 +1,2272 @@
+// Copyright (C) 1999-2000 Id Software, Inc.
+//
+// cg_marks.c -- wall marks
+
+#include "cg_local.h"
+
+/*
+===================================================================
+
+MARK POLYS
+
+===================================================================
+*/
+
+
+markPoly_t	cg_activeMarkPolys;			// double linked list
+markPoly_t	*cg_freeMarkPolys;			// single linked list
+markPoly_t	cg_markPolys[MAX_MARK_POLYS];
+static		int	markTotal;
+
+/*
+===================
+CG_InitMarkPolys
+
+This is called at startup and for tournement restarts
+===================
+*/
+void	CG_InitMarkPolys( void ) {
+	int		i;
+
+	memset( cg_markPolys, 0, sizeof(cg_markPolys) );
+
+	cg_activeMarkPolys.nextMark = &cg_activeMarkPolys;
+	cg_activeMarkPolys.prevMark = &cg_activeMarkPolys;
+	cg_freeMarkPolys = cg_markPolys;
+	for ( i = 0 ; i < MAX_MARK_POLYS - 1 ; i++ ) {
+		cg_markPolys[i].nextMark = &cg_markPolys[i+1];
+	}
+}
+
+
+/*
+==================
+CG_FreeMarkPoly
+==================
+*/
+void CG_FreeMarkPoly( markPoly_t *le ) {
+	if ( !le->prevMark ) {
+		CG_Error( "CG_FreeLocalEntity: not active" );
+	}
+
+	// remove from the doubly linked active list
+	le->prevMark->nextMark = le->nextMark;
+	le->nextMark->prevMark = le->prevMark;
+
+	// the free list is only singly linked
+	le->nextMark = cg_freeMarkPolys;
+	cg_freeMarkPolys = le;
+}
+
+/*
+===================
+CG_AllocMark
+
+Will allways succeed, even if it requires freeing an old active mark
+===================
+*/
+markPoly_t	*CG_AllocMark( void ) {
+	markPoly_t	*le;
+	int time;
+
+	if ( !cg_freeMarkPolys ) {
+		// no free entities, so free the one at the end of the chain
+		// remove the oldest active entity
+		time = cg_activeMarkPolys.prevMark->time;
+		while (cg_activeMarkPolys.prevMark && time == cg_activeMarkPolys.prevMark->time) {
+			CG_FreeMarkPoly( cg_activeMarkPolys.prevMark );
+		}
+	}
+
+	le = cg_freeMarkPolys;
+	cg_freeMarkPolys = cg_freeMarkPolys->nextMark;
+
+	memset( le, 0, sizeof( *le ) );
+
+	// link into the active list
+	le->nextMark = cg_activeMarkPolys.nextMark;
+	le->prevMark = &cg_activeMarkPolys;
+	cg_activeMarkPolys.nextMark->prevMark = le;
+	cg_activeMarkPolys.nextMark = le;
+	return le;
+}
+
+
+
+/*
+=================
+CG_ImpactMark
+
+origin should be a point within a unit of the plane
+dir should be the plane normal
+
+temporary marks will not be stored or randomly oriented, but immediately
+passed to the renderer.
+=================
+*/
+#define	MAX_MARK_FRAGMENTS	128
+#define	MAX_MARK_POINTS		384
+
+void CG_ImpactMark( qhandle_t markShader, const vec3_t origin, const vec3_t dir, 
+				   float orientation, float red, float green, float blue, float alpha,
+				   qboolean alphaFade, float radius, qboolean temporary ) {
+	vec3_t			axis[3];
+	float			texCoordScale;
+	vec3_t			originalPoints[4];
+	byte			colors[4];
+	int				i, j;
+	int				numFragments;
+	markFragment_t	markFragments[MAX_MARK_FRAGMENTS], *mf;
+	vec3_t			markPoints[MAX_MARK_POINTS];
+	vec3_t			projection;
+
+	assert(markShader);
+
+	if ( !cg_addMarks.integer ) {
+		return;
+	}
+	else if (cg_addMarks.integer == 2)
+	{
+		trap_R_AddDecalToScene(markShader, origin, dir, orientation, red, green, blue, alpha,
+			alphaFade, radius, temporary);
+		return;
+	}
+
+	if ( radius <= 0 ) {
+		CG_Error( "CG_ImpactMark called with <= 0 radius" );
+	}
+
+	//if ( markTotal >= MAX_MARK_POLYS ) {
+	//	return;
+	//}
+
+	// create the texture axis
+	VectorNormalize2( dir, axis[0] );
+	PerpendicularVector( axis[1], axis[0] );
+	RotatePointAroundVector( axis[2], axis[0], axis[1], orientation );
+	CrossProduct( axis[0], axis[2], axis[1] );
+
+	texCoordScale = 0.5 * 1.0 / radius;
+
+	// create the full polygon
+	for ( i = 0 ; i < 3 ; i++ ) {
+		originalPoints[0][i] = origin[i] - radius * axis[1][i] - radius * axis[2][i];
+		originalPoints[1][i] = origin[i] + radius * axis[1][i] - radius * axis[2][i];
+		originalPoints[2][i] = origin[i] + radius * axis[1][i] + radius * axis[2][i];
+		originalPoints[3][i] = origin[i] - radius * axis[1][i] + radius * axis[2][i];
+	}
+
+	// get the fragments
+	VectorScale( dir, -20, projection );
+	numFragments = trap_CM_MarkFragments( 4, (const vec3_t *) originalPoints,
+					projection, MAX_MARK_POINTS, markPoints[0],
+					MAX_MARK_FRAGMENTS, markFragments );
+
+	colors[0] = red * 255;
+	colors[1] = green * 255;
+	colors[2] = blue * 255;
+	colors[3] = alpha * 255;
+
+	for ( i = 0, mf = markFragments ; i < numFragments ; i++, mf++ ) {
+		polyVert_t	*v;
+		polyVert_t	verts[MAX_VERTS_ON_POLY];
+		markPoly_t	*mark;
+
+		// we have an upper limit on the complexity of polygons
+		// that we store persistantly
+		if ( mf->numPoints > MAX_VERTS_ON_POLY ) {
+			mf->numPoints = MAX_VERTS_ON_POLY;
+		}
+		for ( j = 0, v = verts ; j < mf->numPoints ; j++, v++ ) {
+			vec3_t		delta;
+
+			VectorCopy( markPoints[mf->firstPoint + j], v->xyz );
+
+			VectorSubtract( v->xyz, origin, delta );
+			v->st[0] = 0.5 + DotProduct( delta, axis[1] ) * texCoordScale;
+			v->st[1] = 0.5 + DotProduct( delta, axis[2] ) * texCoordScale;
+			*(int *)v->modulate = *(int *)colors;
+		}
+
+		// if it is a temporary (shadow) mark, add it immediately and forget about it
+		if ( temporary ) {
+			trap_R_AddPolyToScene( markShader, mf->numPoints, verts );
+			continue;
+		}
+
+		// otherwise save it persistantly
+		mark = CG_AllocMark();
+		mark->time = cg.time;
+		mark->alphaFade = alphaFade;
+		mark->markShader = markShader;
+		mark->poly.numVerts = mf->numPoints;
+		mark->color[0] = red;
+		mark->color[1] = green;
+		mark->color[2] = blue;
+		mark->color[3] = alpha;
+		memcpy( mark->verts, verts, mf->numPoints * sizeof( verts[0] ) );
+		markTotal++;
+	}
+}
+
+
+/*
+===============
+CG_AddMarks
+===============
+*/
+#define	MARK_TOTAL_TIME		10000
+#define	MARK_FADE_TIME		1000
+
+void CG_AddMarks( void ) {
+	int			j;
+	markPoly_t	*mp, *next;
+	int			t;
+	int			fade;
+
+	if ( !cg_addMarks.integer ) {
+		return;
+	}
+
+	mp = cg_activeMarkPolys.nextMark;
+	for ( ; mp != &cg_activeMarkPolys ; mp = next ) {
+		// grab next now, so if the local entity is freed we
+		// still have it
+		next = mp->nextMark;
+
+		// see if it is time to completely remove it
+		if ( cg.time > mp->time + MARK_TOTAL_TIME ) {
+			CG_FreeMarkPoly( mp );
+			continue;
+		}
+
+		// fade out the energy bursts
+		//if ( mp->markShader == cgs.media.energyMarkShader ) {
+		if (0) {
+
+			fade = 450 - 450 * ( (cg.time - mp->time ) / 3000.0 );
+			if ( fade < 255 ) {
+				if ( fade < 0 ) {
+					fade = 0;
+				}
+				if ( mp->verts[0].modulate[0] != 0 ) {
+					for ( j = 0 ; j < mp->poly.numVerts ; j++ ) {
+						mp->verts[j].modulate[0] = mp->color[0] * fade;
+						mp->verts[j].modulate[1] = mp->color[1] * fade;
+						mp->verts[j].modulate[2] = mp->color[2] * fade;
+					}
+				}
+			}
+		}
+
+		// fade all marks out with time
+		t = mp->time + MARK_TOTAL_TIME - cg.time;
+		if ( t < MARK_FADE_TIME ) {
+			fade = 255 * t / MARK_FADE_TIME;
+			if ( mp->alphaFade ) {
+				for ( j = 0 ; j < mp->poly.numVerts ; j++ ) {
+					mp->verts[j].modulate[3] = fade;
+				}
+			}
+			else 
+			{
+				float f = (float)t / MARK_FADE_TIME;
+				for ( j = 0 ; j < mp->poly.numVerts ; j++ ) {
+					mp->verts[j].modulate[0] = mp->color[0] * f;
+					mp->verts[j].modulate[1] = mp->color[1] * f;
+					mp->verts[j].modulate[2] = mp->color[2] * f;
+				}
+			}
+		}
+		else
+		{
+			for ( j = 0 ; j < mp->poly.numVerts ; j++ ) {
+				mp->verts[j].modulate[0] = mp->color[0];
+				mp->verts[j].modulate[1] = mp->color[1];
+				mp->verts[j].modulate[2] = mp->color[2];
+			}
+		}
+
+		trap_R_AddPolyToScene( mp->markShader, mp->poly.numVerts, mp->verts );
+	}
+}
+
+// cg_particles.c  
+
+#define BLOODRED	2
+#define EMISIVEFADE	3
+#define GREY75		4
+
+typedef struct particle_s
+{
+	struct particle_s	*next;
+
+	float		time;
+	float		endtime;
+
+	vec3_t		org;
+	vec3_t		vel;
+	vec3_t		accel;
+	int			color;
+	float		colorvel;
+	float		alpha;
+	float		alphavel;
+	int			type;
+	qhandle_t	pshader;
+	
+	float		height;
+	float		width;
+				
+	float		endheight;
+	float		endwidth;
+	
+	float		start;
+	float		end;
+
+	float		startfade;
+	qboolean	rotate;
+	int			snum;
+	
+	qboolean	link;
+
+	// Ridah
+	int			shaderAnim;
+	int			roll;
+
+	int			accumroll;
+
+} cparticle_t;
+
+typedef enum
+{
+	P_NONE,
+	P_WEATHER,
+	P_FLAT,
+	P_SMOKE,
+	P_ROTATE,
+	P_WEATHER_TURBULENT,
+	P_ANIM,	// Ridah
+	P_BAT,
+	P_BLEED,
+	P_FLAT_SCALEUP,
+	P_FLAT_SCALEUP_FADE,
+	P_WEATHER_FLURRY,
+	P_SMOKE_IMPACT,
+	P_BUBBLE,
+	P_BUBBLE_TURBULENT,
+	P_SPRITE
+} particle_type_t;
+
+#define	MAX_SHADER_ANIMS		32
+#define	MAX_SHADER_ANIM_FRAMES	64
+
+static char *shaderAnimNames[MAX_SHADER_ANIMS] = {
+	"explode1",
+	NULL
+};
+static qhandle_t shaderAnims[MAX_SHADER_ANIMS][MAX_SHADER_ANIM_FRAMES];
+static int	shaderAnimCounts[MAX_SHADER_ANIMS] = {
+	23
+};
+static float	shaderAnimSTRatio[MAX_SHADER_ANIMS] = {
+	1.0f
+};
+static int	numShaderAnims;
+// done.
+
+#define		PARTICLE_GRAVITY	40
+#define		MAX_PARTICLES	1024
+
+cparticle_t	*active_particles, *free_particles;
+cparticle_t	particles[MAX_PARTICLES];
+int		cl_numparticles = MAX_PARTICLES;
+
+qboolean		initparticles = qfalse;
+vec3_t			pvforward, pvright, pvup;
+vec3_t			rforward, rright, rup;
+
+float			oldtime;
+
+/*
+===============
+CL_ClearParticles
+===============
+*/
+void CG_ClearParticles (void)
+{
+	int		i;
+
+	memset( particles, 0, sizeof(particles) );
+
+	free_particles = &particles[0];
+	active_particles = NULL;
+
+	for (i=0 ;i<cl_numparticles ; i++)
+	{
+		particles[i].next = &particles[i+1];
+		particles[i].type = 0;
+	}
+	particles[cl_numparticles-1].next = NULL;
+
+	oldtime = cg.time;
+
+	/*
+	// Ridah, init the shaderAnims
+	for (i=0; shaderAnimNames[i]; i++) {
+		int j;
+
+		for (j=0; j<shaderAnimCounts[i]; j++) {
+			shaderAnims[i][j] = trap_R_RegisterShader( va("%s%i", shaderAnimNames[i], j+1) );
+		}
+	}
+	numShaderAnims = i;
+	*/
+	numShaderAnims = 0;
+	// done.
+
+	initparticles = qtrue;
+}
+
+
+/*
+=====================
+CG_AddParticleToScene
+=====================
+*/
+void CG_AddParticleToScene (cparticle_t *p, vec3_t org, float alpha)
+{
+
+	vec3_t		point;
+	polyVert_t	verts[4];
+	float		width;
+	float		height;
+	float		time, time2;
+	float		ratio;
+	float		invratio;
+	vec3_t		color;
+	polyVert_t	TRIverts[3];
+	vec3_t		rright2, rup2;
+
+	if (p->type == P_WEATHER || p->type == P_WEATHER_TURBULENT || p->type == P_WEATHER_FLURRY
+		|| p->type == P_BUBBLE || p->type == P_BUBBLE_TURBULENT)
+	{// create a front facing polygon
+			
+		if (p->type != P_WEATHER_FLURRY)
+		{
+			if (p->type == P_BUBBLE || p->type == P_BUBBLE_TURBULENT)
+			{
+				if (org[2] > p->end)			
+				{	
+					p->time = cg.time;	
+					VectorCopy (org, p->org); // Ridah, fixes rare snow flakes that flicker on the ground
+									
+					p->org[2] = ( p->start + crandom () * 4 );
+					
+					
+					if (p->type == P_BUBBLE_TURBULENT)
+					{
+						p->vel[0] = crandom() * 4;
+						p->vel[1] = crandom() * 4;
+					}
+				
+				}
+			}
+			else
+			{
+				if (org[2] < p->end)			
+				{	
+					p->time = cg.time;	
+					VectorCopy (org, p->org); // Ridah, fixes rare snow flakes that flicker on the ground
+									
+					while (p->org[2] < p->end) 
+					{
+						p->org[2] += (p->start - p->end); 
+					}
+					
+					
+					if (p->type == P_WEATHER_TURBULENT)
+					{
+						p->vel[0] = crandom() * 16;
+						p->vel[1] = crandom() * 16;
+					}
+				
+				}
+			}
+			
+
+			// Rafael snow pvs check
+			if (!p->link)
+				return;
+
+			p->alpha = 1;
+		}
+		
+		// Ridah, had to do this or MAX_POLYS is being exceeded in village1.bsp
+		if (Distance( cg.snap->ps.origin, org ) > 1024) {
+			return;
+		}
+		// done.
+	
+		if (p->type == P_BUBBLE || p->type == P_BUBBLE_TURBULENT)
+		{
+			VectorMA (org, -p->height, pvup, point);	
+			VectorMA (point, -p->width, pvright, point);	
+			VectorCopy (point, verts[0].xyz);	
+			verts[0].st[0] = 0;	
+			verts[0].st[1] = 0;	
+			verts[0].modulate[0] = 255;	
+			verts[0].modulate[1] = 255;	
+			verts[0].modulate[2] = 255;	
+			verts[0].modulate[3] = 255 * p->alpha;	
+
+			VectorMA (org, -p->height, pvup, point);	
+			VectorMA (point, p->width, pvright, point);	
+			VectorCopy (point, verts[1].xyz);	
+			verts[1].st[0] = 0;	
+			verts[1].st[1] = 1;	
+			verts[1].modulate[0] = 255;	
+			verts[1].modulate[1] = 255;	
+			verts[1].modulate[2] = 255;	
+			verts[1].modulate[3] = 255 * p->alpha;	
+
+			VectorMA (org, p->height, pvup, point);	
+			VectorMA (point, p->width, pvright, point);	
+			VectorCopy (point, verts[2].xyz);	
+			verts[2].st[0] = 1;	
+			verts[2].st[1] = 1;	
+			verts[2].modulate[0] = 255;	
+			verts[2].modulate[1] = 255;	
+			verts[2].modulate[2] = 255;	
+			verts[2].modulate[3] = 255 * p->alpha;	
+
+			VectorMA (org, p->height, pvup, point);	
+			VectorMA (point, -p->width, pvright, point);	
+			VectorCopy (point, verts[3].xyz);	
+			verts[3].st[0] = 1;	
+			verts[3].st[1] = 0;	
+			verts[3].modulate[0] = 255;	
+			verts[3].modulate[1] = 255;	
+			verts[3].modulate[2] = 255;	
+			verts[3].modulate[3] = 255 * p->alpha;	
+		}
+		else
+		{
+			VectorMA (org, -p->height, pvup, point);	
+			VectorMA (point, -p->width, pvright, point);	
+			VectorCopy( point, TRIverts[0].xyz );
+			TRIverts[0].st[0] = 1;
+			TRIverts[0].st[1] = 0;
+			TRIverts[0].modulate[0] = 255;
+			TRIverts[0].modulate[1] = 255;
+			TRIverts[0].modulate[2] = 255;
+			TRIverts[0].modulate[3] = 255 * p->alpha;	
+
+			VectorMA (org, p->height, pvup, point);	
+			VectorMA (point, -p->width, pvright, point);	
+			VectorCopy (point, TRIverts[1].xyz);	
+			TRIverts[1].st[0] = 0;
+			TRIverts[1].st[1] = 0;
+			TRIverts[1].modulate[0] = 255;
+			TRIverts[1].modulate[1] = 255;
+			TRIverts[1].modulate[2] = 255;
+			TRIverts[1].modulate[3] = 255 * p->alpha;	
+
+			VectorMA (org, p->height, pvup, point);	
+			VectorMA (point, p->width, pvright, point);	
+			VectorCopy (point, TRIverts[2].xyz);	
+			TRIverts[2].st[0] = 0;
+			TRIverts[2].st[1] = 1;
+			TRIverts[2].modulate[0] = 255;
+			TRIverts[2].modulate[1] = 255;
+			TRIverts[2].modulate[2] = 255;
+			TRIverts[2].modulate[3] = 255 * p->alpha;	
+		}
+	
+	}
+	else if (p->type == P_SPRITE)
+	{
+		vec3_t	rr, ru;
+		vec3_t	rotate_ang;
+
+		VectorSet (color, 1.0, 1.0, 0.5);
+		time = cg.time - p->time;
+		time2 = p->endtime - p->time;
+		ratio = time / time2;
+
+		width = p->width + ( ratio * ( p->endwidth - p->width) );
+		height = p->height + ( ratio * ( p->endheight - p->height) );
+
+		if (p->roll) {
+			vectoangles( cg.refdef.viewaxis[0], rotate_ang );
+			rotate_ang[ROLL] += p->roll;
+			AngleVectors ( rotate_ang, NULL, rr, ru);
+		}
+
+		if (p->roll) {
+			VectorMA (org, -height, ru, point);	
+			VectorMA (point, -width, rr, point);	
+		} else {
+			VectorMA (org, -height, pvup, point);	
+			VectorMA (point, -width, pvright, point);	
+		}
+		VectorCopy (point, verts[0].xyz);	
+		verts[0].st[0] = 0;	
+		verts[0].st[1] = 0;	
+		verts[0].modulate[0] = 255;	
+		verts[0].modulate[1] = 255;	
+		verts[0].modulate[2] = 255;	
+		verts[0].modulate[3] = 255;
+
+		if (p->roll) {
+			VectorMA (point, 2*height, ru, point);	
+		} else {
+			VectorMA (point, 2*height, pvup, point);	
+		}
+		VectorCopy (point, verts[1].xyz);	
+		verts[1].st[0] = 0;	
+		verts[1].st[1] = 1;	
+		verts[1].modulate[0] = 255;	
+		verts[1].modulate[1] = 255;	
+		verts[1].modulate[2] = 255;	
+		verts[1].modulate[3] = 255;	
+
+		if (p->roll) {
+			VectorMA (point, 2*width, rr, point);	
+		} else {
+			VectorMA (point, 2*width, pvright, point);	
+		}
+		VectorCopy (point, verts[2].xyz);	
+		verts[2].st[0] = 1;	
+		verts[2].st[1] = 1;	
+		verts[2].modulate[0] = 255;	
+		verts[2].modulate[1] = 255;	
+		verts[2].modulate[2] = 255;	
+		verts[2].modulate[3] = 255;	
+
+		if (p->roll) {
+			VectorMA (point, -2*height, ru, point);	
+		} else {
+			VectorMA (point, -2*height, pvup, point);	
+		}
+		VectorCopy (point, verts[3].xyz);	
+		verts[3].st[0] = 1;	
+		verts[3].st[1] = 0;	
+		verts[3].modulate[0] = 255;	
+		verts[3].modulate[1] = 255;	
+		verts[3].modulate[2] = 255;	
+		verts[3].modulate[3] = 255;	
+	}
+	else if (p->type == P_SMOKE || p->type == P_SMOKE_IMPACT)
+	{// create a front rotating facing polygon
+
+		if ( p->type == P_SMOKE_IMPACT && Distance( cg.snap->ps.origin, org ) > 1024) {
+			return;
+		}
+
+		if (p->color == BLOODRED)
+			VectorSet (color, 0.22f, 0.0f, 0.0f);
+		else if (p->color == GREY75)
+		{
+			float	len;
+			float	greyit;
+			float	val;
+			len = Distance (cg.snap->ps.origin, org);
+			if (!len)
+				len = 1;
+
+			val = 4096/len;
+			greyit = 0.25 * val;
+			if (greyit > 0.5)
+				greyit = 0.5;
+
+			VectorSet (color, greyit, greyit, greyit);
+		}
+		else
+			VectorSet (color, 1.0, 1.0, 1.0);
+
+		time = cg.time - p->time;
+		time2 = p->endtime - p->time;
+		ratio = time / time2;
+		
+		if (cg.time > p->startfade)
+		{
+			invratio = 1 - ( (cg.time - p->startfade) / (p->endtime - p->startfade) );
+
+			if (p->color == EMISIVEFADE)
+			{
+				float fval;
+				fval = (invratio * invratio);
+				if (fval < 0)
+					fval = 0;
+				VectorSet (color, fval , fval , fval );
+			}
+			invratio *= p->alpha;
+		}
+		else 
+			invratio = 1 * p->alpha;
+
+		if (invratio > 1)
+			invratio = 1;
+	
+		width = p->width + ( ratio * ( p->endwidth - p->width) );
+		height = p->height + ( ratio * ( p->endheight - p->height) );
+
+		if (p->type != P_SMOKE_IMPACT)
+		{
+			vec3_t temp;
+
+			vectoangles (rforward, temp);
+			p->accumroll += p->roll;
+			temp[ROLL] += p->accumroll * 0.1;
+			AngleVectors ( temp, NULL, rright2, rup2);
+		}
+		else
+		{
+			VectorCopy (rright, rright2);
+			VectorCopy (rup, rup2);
+		}
+		
+		if (p->rotate)
+		{
+			VectorMA (org, -height, rup2, point);	
+			VectorMA (point, -width, rright2, point);	
+		}
+		else
+		{
+			VectorMA (org, -p->height, pvup, point);	
+			VectorMA (point, -p->width, pvright, point);	
+		}
+		VectorCopy (point, verts[0].xyz);	
+		verts[0].st[0] = 0;	
+		verts[0].st[1] = 0;	
+		verts[0].modulate[0] = 255 * color[0];	
+		verts[0].modulate[1] = 255 * color[1];	
+		verts[0].modulate[2] = 255 * color[2];	
+		verts[0].modulate[3] = 255 * invratio;	
+
+		if (p->rotate)
+		{
+			VectorMA (org, -height, rup2, point);	
+			VectorMA (point, width, rright2, point);	
+		}
+		else
+		{
+			VectorMA (org, -p->height, pvup, point);	
+			VectorMA (point, p->width, pvright, point);	
+		}
+		VectorCopy (point, verts[1].xyz);	
+		verts[1].st[0] = 0;	
+		verts[1].st[1] = 1;	
+		verts[1].modulate[0] = 255 * color[0];	
+		verts[1].modulate[1] = 255 * color[1];	
+		verts[1].modulate[2] = 255 * color[2];	
+		verts[1].modulate[3] = 255 * invratio;	
+
+		if (p->rotate)
+		{
+			VectorMA (org, height, rup2, point);	
+			VectorMA (point, width, rright2, point);	
+		}
+		else
+		{
+			VectorMA (org, p->height, pvup, point);	
+			VectorMA (point, p->width, pvright, point);	
+		}
+		VectorCopy (point, verts[2].xyz);	
+		verts[2].st[0] = 1;	
+		verts[2].st[1] = 1;	
+		verts[2].modulate[0] = 255 * color[0];	
+		verts[2].modulate[1] = 255 * color[1];	
+		verts[2].modulate[2] = 255 * color[2];	
+		verts[2].modulate[3] = 255 * invratio;	
+
+		if (p->rotate)
+		{
+			VectorMA (org, height, rup2, point);	
+			VectorMA (point, -width, rright2, point);	
+		}
+		else
+		{
+			VectorMA (org, p->height, pvup, point);	
+			VectorMA (point, -p->width, pvright, point);	
+		}
+		VectorCopy (point, verts[3].xyz);	
+		verts[3].st[0] = 1;	
+		verts[3].st[1] = 0;	
+		verts[3].modulate[0] = 255 * color[0];	
+		verts[3].modulate[1] = 255 * color[1];	
+		verts[3].modulate[2] = 255 * color[2];	
+		verts[3].modulate[3] = 255  * invratio;	
+		
+	}
+	else if (p->type == P_BLEED)
+	{
+		vec3_t	rr, ru;
+		vec3_t	rotate_ang;
+		float	alpha;
+
+		alpha = p->alpha;
+		
+		if (p->roll) 
+		{
+			vectoangles( cg.refdef.viewaxis[0], rotate_ang );
+			rotate_ang[ROLL] += p->roll;
+			AngleVectors ( rotate_ang, NULL, rr, ru);
+		}
+		else
+		{
+			VectorCopy (pvup, ru);
+			VectorCopy (pvright, rr);
+		}
+
+		VectorMA (org, -p->height, ru, point);	
+		VectorMA (point, -p->width, rr, point);	
+		VectorCopy (point, verts[0].xyz);	
+		verts[0].st[0] = 0;	
+		verts[0].st[1] = 0;	
+		verts[0].modulate[0] = 111;	
+		verts[0].modulate[1] = 19;	
+		verts[0].modulate[2] = 9;	
+		verts[0].modulate[3] = 255 * alpha;	
+
+		VectorMA (org, -p->height, ru, point);	
+		VectorMA (point, p->width, rr, point);	
+		VectorCopy (point, verts[1].xyz);	
+		verts[1].st[0] = 0;	
+		verts[1].st[1] = 1;	
+		verts[1].modulate[0] = 111;	
+		verts[1].modulate[1] = 19;	
+		verts[1].modulate[2] = 9;	
+		verts[1].modulate[3] = 255 * alpha;	
+
+		VectorMA (org, p->height, ru, point);	
+		VectorMA (point, p->width, rr, point);	
+		VectorCopy (point, verts[2].xyz);	
+		verts[2].st[0] = 1;	
+		verts[2].st[1] = 1;	
+		verts[2].modulate[0] = 111;	
+		verts[2].modulate[1] = 19;	
+		verts[2].modulate[2] = 9;	
+		verts[2].modulate[3] = 255 * alpha;	
+
+		VectorMA (org, p->height, ru, point);	
+		VectorMA (point, -p->width, rr, point);	
+		VectorCopy (point, verts[3].xyz);	
+		verts[3].st[0] = 1;	
+		verts[3].st[1] = 0;	
+		verts[3].modulate[0] = 111;	
+		verts[3].modulate[1] = 19;	
+		verts[3].modulate[2] = 9;	
+		verts[3].modulate[3] = 255 * alpha;	
+
+	}
+	else if (p->type == P_FLAT_SCALEUP)
+	{
+		float width, height;
+		float sinR, cosR;
+
+		if (p->color == BLOODRED)
+			VectorSet (color, 1, 1, 1);
+		else
+			VectorSet (color, 0.5, 0.5, 0.5);
+		
+		time = cg.time - p->time;
+		time2 = p->endtime - p->time;
+		ratio = time / time2;
+
+		width = p->width + ( ratio * ( p->endwidth - p->width) );
+		height = p->height + ( ratio * ( p->endheight - p->height) );
+
+		if (width > p->endwidth)
+			width = p->endwidth;
+
+		if (height > p->endheight)
+			height = p->endheight;
+
+		sinR = height * sin(DEG2RAD(p->roll)) * sqrt(2.0f);
+		cosR = width * cos(DEG2RAD(p->roll)) * sqrt(2.0f);
+
+		VectorCopy (org, verts[0].xyz);	
+		verts[0].xyz[0] -= sinR;
+		verts[0].xyz[1] -= cosR;
+		verts[0].st[0] = 0;	
+		verts[0].st[1] = 0;	
+		verts[0].modulate[0] = 255 * color[0];	
+		verts[0].modulate[1] = 255 * color[1];	
+		verts[0].modulate[2] = 255 * color[2];	
+		verts[0].modulate[3] = 255;	
+
+		VectorCopy (org, verts[1].xyz);	
+		verts[1].xyz[0] -= cosR;	
+		verts[1].xyz[1] += sinR;	
+		verts[1].st[0] = 0;	
+		verts[1].st[1] = 1;	
+		verts[1].modulate[0] = 255 * color[0];	
+		verts[1].modulate[1] = 255 * color[1];	
+		verts[1].modulate[2] = 255 * color[2];	
+		verts[1].modulate[3] = 255;	
+
+		VectorCopy (org, verts[2].xyz);	
+		verts[2].xyz[0] += sinR;	
+		verts[2].xyz[1] += cosR;	
+		verts[2].st[0] = 1;	
+		verts[2].st[1] = 1;	
+		verts[2].modulate[0] = 255 * color[0];	
+		verts[2].modulate[1] = 255 * color[1];	
+		verts[2].modulate[2] = 255 * color[2];	
+		verts[2].modulate[3] = 255;	
+
+		VectorCopy (org, verts[3].xyz);	
+		verts[3].xyz[0] += cosR;	
+		verts[3].xyz[1] -= sinR;	
+		verts[3].st[0] = 1;	
+		verts[3].st[1] = 0;	
+		verts[3].modulate[0] = 255 * color[0];	
+		verts[3].modulate[1] = 255 * color[1];	
+		verts[3].modulate[2] = 255 * color[2];	
+		verts[3].modulate[3] = 255;		
+	}
+	else if (p->type == P_FLAT)
+	{
+
+		VectorCopy (org, verts[0].xyz);	
+		verts[0].xyz[0] -= p->height;	
+		verts[0].xyz[1] -= p->width;	
+		verts[0].st[0] = 0;	
+		verts[0].st[1] = 0;	
+		verts[0].modulate[0] = 255;	
+		verts[0].modulate[1] = 255;	
+		verts[0].modulate[2] = 255;	
+		verts[0].modulate[3] = 255;	
+
+		VectorCopy (org, verts[1].xyz);	
+		verts[1].xyz[0] -= p->height;	
+		verts[1].xyz[1] += p->width;	
+		verts[1].st[0] = 0;	
+		verts[1].st[1] = 1;	
+		verts[1].modulate[0] = 255;	
+		verts[1].modulate[1] = 255;	
+		verts[1].modulate[2] = 255;	
+		verts[1].modulate[3] = 255;	
+
+		VectorCopy (org, verts[2].xyz);	
+		verts[2].xyz[0] += p->height;	
+		verts[2].xyz[1] += p->width;	
+		verts[2].st[0] = 1;	
+		verts[2].st[1] = 1;	
+		verts[2].modulate[0] = 255;	
+		verts[2].modulate[1] = 255;	
+		verts[2].modulate[2] = 255;	
+		verts[2].modulate[3] = 255;	
+
+		VectorCopy (org, verts[3].xyz);	
+		verts[3].xyz[0] += p->height;	
+		verts[3].xyz[1] -= p->width;	
+		verts[3].st[0] = 1;	
+		verts[3].st[1] = 0;	
+		verts[3].modulate[0] = 255;	
+		verts[3].modulate[1] = 255;	
+		verts[3].modulate[2] = 255;	
+		verts[3].modulate[3] = 255;	
+
+	}
+	// Ridah
+	else if (p->type == P_ANIM) {
+		vec3_t	rr, ru;
+		vec3_t	rotate_ang;
+		int i, j;
+
+		time = cg.time - p->time;
+		time2 = p->endtime - p->time;
+		ratio = time / time2;
+		if (ratio >= 1.0f) {
+			ratio = 0.9999f;
+		}
+
+		width = p->width + ( ratio * ( p->endwidth - p->width) );
+		height = p->height + ( ratio * ( p->endheight - p->height) );
+
+		// if we are "inside" this sprite, don't draw
+		if (Distance( cg.snap->ps.origin, org ) < width/1.5) {
+			return;
+		}
+
+		i = p->shaderAnim;
+		j = (int)floor(ratio * shaderAnimCounts[p->shaderAnim]);
+		p->pshader = shaderAnims[i][j];
+
+		if (p->roll) {
+			vectoangles( cg.refdef.viewaxis[0], rotate_ang );
+			rotate_ang[ROLL] += p->roll;
+			AngleVectors ( rotate_ang, NULL, rr, ru);
+		}
+
+		if (p->roll) {
+			VectorMA (org, -height, ru, point);	
+			VectorMA (point, -width, rr, point);	
+		} else {
+			VectorMA (org, -height, pvup, point);	
+			VectorMA (point, -width, pvright, point);	
+		}
+		VectorCopy (point, verts[0].xyz);	
+		verts[0].st[0] = 0;	
+		verts[0].st[1] = 0;	
+		verts[0].modulate[0] = 255;	
+		verts[0].modulate[1] = 255;	
+		verts[0].modulate[2] = 255;	
+		verts[0].modulate[3] = 255;
+
+		if (p->roll) {
+			VectorMA (point, 2*height, ru, point);	
+		} else {
+			VectorMA (point, 2*height, pvup, point);	
+		}
+		VectorCopy (point, verts[1].xyz);	
+		verts[1].st[0] = 0;	
+		verts[1].st[1] = 1;	
+		verts[1].modulate[0] = 255;	
+		verts[1].modulate[1] = 255;	
+		verts[1].modulate[2] = 255;	
+		verts[1].modulate[3] = 255;	
+
+		if (p->roll) {
+			VectorMA (point, 2*width, rr, point);	
+		} else {
+			VectorMA (point, 2*width, pvright, point);	
+		}
+		VectorCopy (point, verts[2].xyz);	
+		verts[2].st[0] = 1;	
+		verts[2].st[1] = 1;	
+		verts[2].modulate[0] = 255;	
+		verts[2].modulate[1] = 255;	
+		verts[2].modulate[2] = 255;	
+		verts[2].modulate[3] = 255;	
+
+		if (p->roll) {
+			VectorMA (point, -2*height, ru, point);	
+		} else {
+			VectorMA (point, -2*height, pvup, point);	
+		}
+		VectorCopy (point, verts[3].xyz);	
+		verts[3].st[0] = 1;	
+		verts[3].st[1] = 0;	
+		verts[3].modulate[0] = 255;	
+		verts[3].modulate[1] = 255;	
+		verts[3].modulate[2] = 255;	
+		verts[3].modulate[3] = 255;	
+	}
+	// done.
+	
+	if (!p->pshader) {
+// (SA) temp commented out for DM
+//		CG_Printf ("CG_AddParticleToScene type %d p->pshader == ZERO\n", p->type);
+		return;
+	}
+
+	if (p->type == P_WEATHER || p->type == P_WEATHER_TURBULENT || p->type == P_WEATHER_FLURRY)
+		trap_R_AddPolyToScene( p->pshader, 3, TRIverts );
+	else
+		trap_R_AddPolyToScene( p->pshader, 4, verts );
+
+}
+
+// Ridah, made this static so it doesn't interfere with other files
+static float roll = 0.0;
+
+/*
+===============
+CG_AddParticles
+===============
+*/
+void CG_AddParticles (void)
+{
+	cparticle_t		*p, *next;
+	float			alpha;
+	float			time, time2;
+	vec3_t			org;
+	int				color;
+	cparticle_t		*active, *tail;
+	int				type;
+	vec3_t			rotate_ang;
+
+	if (!initparticles)
+		CG_ClearParticles ();
+
+	VectorCopy( cg.refdef.viewaxis[0], pvforward );
+	VectorCopy( cg.refdef.viewaxis[1], pvright );
+	VectorCopy( cg.refdef.viewaxis[2], pvup );
+
+	vectoangles( cg.refdef.viewaxis[0], rotate_ang );
+	roll += ((cg.time - oldtime) * 0.1) ;
+	rotate_ang[ROLL] += (roll*0.9);
+	AngleVectors ( rotate_ang, rforward, rright, rup);
+	
+	oldtime = cg.time;
+
+	active = NULL;
+	tail = NULL;
+
+	for (p=active_particles ; p ; p=next)
+	{
+
+		next = p->next;
+
+		time = (cg.time - p->time)*0.001;
+
+		alpha = p->alpha + time*p->alphavel;
+		if (alpha <= 0)
+		{	// faded out
+			p->next = free_particles;
+			free_particles = p;
+			p->type = 0;
+			p->color = 0;
+			p->alpha = 0;
+			continue;
+		}
+
+		if (p->type == P_SMOKE || p->type == P_ANIM || p->type == P_BLEED || p->type == P_SMOKE_IMPACT)
+		{
+			if (cg.time > p->endtime)
+			{
+				p->next = free_particles;
+				free_particles = p;
+				p->type = 0;
+				p->color = 0;
+				p->alpha = 0;
+			
+				continue;
+			}
+
+		}
+
+		if (p->type == P_WEATHER_FLURRY)
+		{
+			if (cg.time > p->endtime)
+			{
+				p->next = free_particles;
+				free_particles = p;
+				p->type = 0;
+				p->color = 0;
+				p->alpha = 0;
+			
+				continue;
+			}
+		}
+
+
+		if (p->type == P_FLAT_SCALEUP_FADE)
+		{
+			if (cg.time > p->endtime)
+			{
+				p->next = free_particles;
+				free_particles = p;
+				p->type = 0;
+				p->color = 0;
+				p->alpha = 0;
+				continue;
+			}
+
+		}
+
+		if ((p->type == P_BAT || p->type == P_SPRITE) && p->endtime < 0) {
+			// temporary sprite
+			CG_AddParticleToScene (p, p->org, alpha);
+			p->next = free_particles;
+			free_particles = p;
+			p->type = 0;
+			p->color = 0;
+			p->alpha = 0;
+			continue;
+		}
+
+		p->next = NULL;
+		if (!tail)
+			active = tail = p;
+		else
+		{
+			tail->next = p;
+			tail = p;
+		}
+
+		if (alpha > 1.0)
+			alpha = 1;
+
+		color = p->color;
+
+		time2 = time*time;
+
+		org[0] = p->org[0] + p->vel[0]*time + p->accel[0]*time2;
+		org[1] = p->org[1] + p->vel[1]*time + p->accel[1]*time2;
+		org[2] = p->org[2] + p->vel[2]*time + p->accel[2]*time2;
+
+		type = p->type;
+
+		CG_AddParticleToScene (p, org, alpha);
+	}
+
+	active_particles = active;
+}
+
+/*
+======================
+CG_AddParticles
+======================
+*/
+void CG_ParticleSnowFlurry (qhandle_t pshader, centity_t *cent)
+{
+	cparticle_t	*p;
+	qboolean turb = qtrue;
+
+	if (!pshader)
+		CG_Printf ("CG_ParticleSnowFlurry pshader == ZERO!\n");
+
+	if (!free_particles)
+		return;
+	p = free_particles;
+	free_particles = p->next;
+	p->next = active_particles;
+	active_particles = p;
+	p->time = cg.time;
+	p->color = 0;
+	p->alpha = 0.90f;
+	p->alphavel = 0;
+
+	p->start = cent->currentState.origin2[0];
+	p->end = cent->currentState.origin2[1];
+	
+	p->endtime = cg.time + cent->currentState.time;
+	p->startfade = cg.time + cent->currentState.time2;
+	
+	p->pshader = pshader;
+	
+	if (rand()%100 > 90)
+	{
+		p->height = 32;
+		p->width = 32;
+		p->alpha = 0.10f;
+	}
+	else
+	{
+		p->height = 1;
+		p->width = 1;
+	}
+
+	p->vel[2] = -20;
+
+	p->type = P_WEATHER_FLURRY;
+	
+	if (turb)
+		p->vel[2] = -10;
+	
+	VectorCopy(cent->currentState.origin, p->org);
+
+	p->org[0] = p->org[0];
+	p->org[1] = p->org[1];
+	p->org[2] = p->org[2];
+
+	p->vel[0] = p->vel[1] = 0;
+	
+	p->accel[0] = p->accel[1] = p->accel[2] = 0;
+
+	p->vel[0] += cent->currentState.angles[0] * 32 + (crandom() * 16);
+	p->vel[1] += cent->currentState.angles[1] * 32 + (crandom() * 16);
+	p->vel[2] += cent->currentState.angles[2];
+
+	if (turb)
+	{
+		p->accel[0] = crandom () * 16;
+		p->accel[1] = crandom () * 16;
+	}
+
+}
+
+void CG_ParticleSnow (qhandle_t pshader, vec3_t origin, vec3_t origin2, int turb, float range, int snum)
+{
+	cparticle_t	*p;
+
+	if (!pshader)
+		CG_Printf ("CG_ParticleSnow pshader == ZERO!\n");
+
+	if (!free_particles)
+		return;
+	p = free_particles;
+	free_particles = p->next;
+	p->next = active_particles;
+	active_particles = p;
+	p->time = cg.time;
+	p->color = 0;
+	p->alpha = 0.40f;
+	p->alphavel = 0;
+	p->start = origin[2];
+	p->end = origin2[2];
+	p->pshader = pshader;
+	p->height = 1;
+	p->width = 1;
+	
+	p->vel[2] = -50;
+
+	if (turb)
+	{
+		p->type = P_WEATHER_TURBULENT;
+		p->vel[2] = -50 * 1.3;
+	}
+	else
+	{
+		p->type = P_WEATHER;
+	}
+	
+	VectorCopy(origin, p->org);
+
+	p->org[0] = p->org[0] + ( crandom() * range);
+	p->org[1] = p->org[1] + ( crandom() * range);
+	p->org[2] = p->org[2] + ( crandom() * (p->start - p->end)); 
+
+	p->vel[0] = p->vel[1] = 0;
+	
+	p->accel[0] = p->accel[1] = p->accel[2] = 0;
+
+	if (turb)
+	{
+		p->vel[0] = crandom() * 16;
+		p->vel[1] = crandom() * 16;
+	}
+
+	// Rafael snow pvs check
+	p->snum = snum;
+	p->link = qtrue;
+
+}
+
+void CG_ParticleBubble (qhandle_t pshader, vec3_t origin, vec3_t origin2, int turb, float range, int snum)
+{
+	cparticle_t	*p;
+	float		randsize;
+
+	if (!pshader)
+		CG_Printf ("CG_ParticleSnow pshader == ZERO!\n");
+
+	if (!free_particles)
+		return;
+	p = free_particles;
+	free_particles = p->next;
+	p->next = active_particles;
+	active_particles = p;
+	p->time = cg.time;
+	p->color = 0;
+	p->alpha = 0.40f;
+	p->alphavel = 0;
+	p->start = origin[2];
+	p->end = origin2[2];
+	p->pshader = pshader;
+	
+	randsize = 1 + (crandom() * 0.5);
+	
+	p->height = randsize;
+	p->width = randsize;
+	
+	p->vel[2] = 50 + ( crandom() * 10 );
+
+	if (turb)
+	{
+		p->type = P_BUBBLE_TURBULENT;
+		p->vel[2] = 50 * 1.3;
+	}
+	else
+	{
+		p->type = P_BUBBLE;
+	}
+	
+	VectorCopy(origin, p->org);
+
+	p->org[0] = p->org[0] + ( crandom() * range);
+	p->org[1] = p->org[1] + ( crandom() * range);
+	p->org[2] = p->org[2] + ( crandom() * (p->start - p->end)); 
+
+	p->vel[0] = p->vel[1] = 0;
+	
+	p->accel[0] = p->accel[1] = p->accel[2] = 0;
+
+	if (turb)
+	{
+		p->vel[0] = crandom() * 4;
+		p->vel[1] = crandom() * 4;
+	}
+
+	// Rafael snow pvs check
+	p->snum = snum;
+	p->link = qtrue;
+
+}
+
+void CG_ParticleSmoke (qhandle_t pshader, centity_t *cent)
+{
+
+	// using cent->density = enttime
+	//		 cent->frame = startfade
+	cparticle_t	*p;
+
+	if (!pshader)
+		CG_Printf ("CG_ParticleSmoke == ZERO!\n");
+
+	if (!free_particles)
+		return;
+	p = free_particles;
+	free_particles = p->next;
+	p->next = active_particles;
+	active_particles = p;
+	p->time = cg.time;
+	
+	p->endtime = cg.time + cent->currentState.time;
+	p->startfade = cg.time + cent->currentState.time2;
+	
+	p->color = 0;
+	p->alpha = 1.0;
+	p->alphavel = 0;
+	p->start = cent->currentState.origin[2];
+	p->end = cent->currentState.origin2[2];
+	p->pshader = pshader;
+	p->rotate = qfalse;
+	p->height = 8;
+	p->width = 8;
+	p->endheight = 32;
+	p->endwidth = 32;
+	p->type = P_SMOKE;
+	
+	VectorCopy(cent->currentState.origin, p->org);
+
+	p->vel[0] = p->vel[1] = 0;
+	p->accel[0] = p->accel[1] = p->accel[2] = 0;
+
+	p->vel[2] = 5;
+
+	if (cent->currentState.frame == 1)// reverse gravity	
+		p->vel[2] *= -1;
+
+	p->roll = 8 + (crandom() * 4);
+}
+
+
+void CG_ParticleBulletDebris (vec3_t org, vec3_t vel, int duration)
+{
+
+	cparticle_t	*p;
+
+	if (!free_particles)
+		return;
+	p = free_particles;
+	free_particles = p->next;
+	p->next = active_particles;
+	active_particles = p;
+	p->time = cg.time;
+	
+	p->endtime = cg.time + duration;
+	p->startfade = cg.time + duration/2;
+	
+	p->color = EMISIVEFADE;
+	p->alpha = 1.0;
+	p->alphavel = 0;
+
+	p->height = 0.5;
+	p->width = 0.5;
+	p->endheight = 0.5;
+	p->endwidth = 0.5;
+
+	p->pshader = 0;//cgs.media.tracerShader;
+
+	p->type = P_SMOKE;
+	
+	VectorCopy(org, p->org);
+
+	p->vel[0] = vel[0];
+	p->vel[1] = vel[1];
+	p->vel[2] = vel[2];
+	p->accel[0] = p->accel[1] = p->accel[2] = 0;
+
+	p->accel[2] = -60;
+	p->vel[2] += -20;
+	
+}
+
+/*
+======================
+CG_ParticleExplosion
+======================
+*/
+
+void CG_ParticleExplosion (char *animStr, vec3_t origin, vec3_t vel, int duration, int sizeStart, int sizeEnd)
+{
+	cparticle_t	*p;
+	int anim;
+
+	if (animStr < (char *)10)
+		CG_Error( "CG_ParticleExplosion: animStr is probably an index rather than a string" );
+
+	// find the animation string
+	for (anim=0; shaderAnimNames[anim]; anim++) {
+		if (!Q_stricmp( animStr, shaderAnimNames[anim] ))
+			break;
+	}
+	if (!shaderAnimNames[anim]) {
+		CG_Error("CG_ParticleExplosion: unknown animation string: %s\n", animStr);
+		return;
+	}
+
+	if (!free_particles)
+		return;
+	p = free_particles;
+	free_particles = p->next;
+	p->next = active_particles;
+	active_particles = p;
+	p->time = cg.time;
+	p->alpha = 0.5;
+	p->alphavel = 0;
+
+	if (duration < 0) {
+		duration *= -1;
+		p->roll = 0;
+	} else {
+		p->roll = crandom()*179;
+	}
+
+	p->shaderAnim = anim;
+
+	p->width = sizeStart;
+	p->height = sizeStart*shaderAnimSTRatio[anim];	// for sprites that are stretch in either direction
+
+	p->endheight = sizeEnd;
+	p->endwidth = sizeEnd*shaderAnimSTRatio[anim];
+
+	p->endtime = cg.time + duration;
+
+	p->type = P_ANIM;
+
+	VectorCopy( origin, p->org );
+	VectorCopy( vel, p->vel );
+	VectorClear( p->accel );
+
+}
+
+// Rafael Shrapnel
+void CG_AddParticleShrapnel (localEntity_t *le)
+{
+	return;
+}
+// done.
+
+int CG_NewParticleArea (int num)
+{
+	// const char *str;
+	char *str;
+	char *token;
+	int type;
+	vec3_t origin, origin2;
+	int		i;
+	float range = 0;
+	int turb;
+	int	numparticles;
+	int	snum;
+	
+	str = (char *) CG_ConfigString (num);
+	if (!str[0])
+		return (0);
+	
+	// returns type 128 64 or 32
+	token = COM_Parse ((const char **)&str);
+	type = atoi (token);
+	
+	if (type == 1)
+		range = 128;
+	else if (type == 2)
+		range = 64;
+	else if (type == 3)
+		range = 32;
+	else if (type == 0)
+		range = 256;
+	else if (type == 4)
+		range = 8;
+	else if (type == 5)
+		range = 16;
+	else if (type == 6)
+		range = 32;
+	else if (type == 7)
+		range = 64;
+
+
+	for (i=0; i<3; i++)
+	{
+		token = COM_Parse ((const char **)&str);
+		origin[i] = atof (token);
+	}
+
+	for (i=0; i<3; i++)
+	{
+		token = COM_Parse ((const char **)&str);
+		origin2[i] = atof (token);
+	}
+		
+	token = COM_Parse ((const char **)&str);
+	numparticles = atoi (token);
+	
+	token = COM_Parse ((const char **)&str);
+	turb = atoi (token);
+
+	token = COM_Parse ((const char **)&str);
+	snum = atoi (token);
+	
+	/*
+	for (i=0; i<numparticles; i++)
+	{
+		if (type >= 4)
+			CG_ParticleBubble (cgs.media.waterBubbleShader, origin, origin2, turb, range, snum);
+		else
+			CG_ParticleSnow (cgs.media.waterBubbleShader, origin, origin2, turb, range, snum);
+	}
+	*/
+
+	return (1);
+}
+
+void	CG_SnowLink (centity_t *cent, qboolean particleOn)
+{
+	cparticle_t		*p, *next;
+	int id;
+
+	id = cent->currentState.frame;
+
+	for (p=active_particles ; p ; p=next)
+	{
+		next = p->next;
+		
+		if (p->type == P_WEATHER || p->type == P_WEATHER_TURBULENT)
+		{
+			if (p->snum == id)
+			{
+				if (particleOn)
+					p->link = qtrue;
+				else
+					p->link = qfalse;
+			}
+		}
+
+	}
+}
+
+void CG_ParticleImpactSmokePuff (qhandle_t pshader, vec3_t origin)
+{
+	cparticle_t	*p;
+
+	if (!pshader)
+		CG_Printf ("CG_ParticleImpactSmokePuff pshader == ZERO!\n");
+
+	if (!free_particles)
+		return;
+	p = free_particles;
+	free_particles = p->next;
+	p->next = active_particles;
+	active_particles = p;
+	p->time = cg.time;
+	p->alpha = 0.25;
+	p->alphavel = 0;
+	p->roll = crandom()*179;
+
+	p->pshader = pshader;
+
+	p->endtime = cg.time + 1000;
+	p->startfade = cg.time + 100;
+
+	p->width = rand()%4 + 8;
+	p->height = rand()%4 + 8;
+
+	p->endheight = p->height *2;
+	p->endwidth = p->width * 2;
+
+	p->endtime = cg.time + 500;
+
+	p->type = P_SMOKE_IMPACT;
+
+	VectorCopy( origin, p->org );
+	VectorSet(p->vel, 0, 0, 20);
+	VectorSet(p->accel, 0, 0, 20);
+
+	p->rotate = qtrue;
+}
+
+void CG_Particle_Bleed (qhandle_t pshader, vec3_t start, vec3_t dir, int fleshEntityNum, int duration)
+{
+	cparticle_t	*p;
+
+	if (!pshader)
+		CG_Printf ("CG_Particle_Bleed pshader == ZERO!\n");
+
+	if (!free_particles)
+		return;
+	p = free_particles;
+	free_particles = p->next;
+	p->next = active_particles;
+	active_particles = p;
+	p->time = cg.time;
+	p->alpha = 1.0;
+	p->alphavel = 0;
+	p->roll = 0;
+
+	p->pshader = pshader;
+
+	p->endtime = cg.time + duration;
+	
+	if (fleshEntityNum)
+		p->startfade = cg.time;
+	else
+		p->startfade = cg.time + 100;
+
+	p->width = 4;
+	p->height = 4;
+
+	p->endheight = 4+rand()%3;
+	p->endwidth = p->endheight;
+
+	p->type = P_SMOKE;
+
+	VectorCopy( start, p->org );
+	p->vel[0] = 0;
+	p->vel[1] = 0;
+	p->vel[2] = -20;
+	VectorClear( p->accel );
+
+	p->rotate = qfalse;
+
+	p->roll = rand()%179;
+	
+	p->color = BLOODRED;
+	p->alpha = 0.75;
+
+}
+
+void CG_Particle_OilParticle (qhandle_t pshader, centity_t *cent)
+{
+	cparticle_t	*p;
+
+	int			time;
+	int			time2;
+	float		ratio;
+
+	float	duration = 1500;
+
+	time = cg.time;
+	time2 = cg.time + cent->currentState.time;
+
+	ratio =(float)1 - ((float)time / (float)time2);
+
+	if (!pshader)
+		CG_Printf ("CG_Particle_OilParticle == ZERO!\n");
+
+	if (!free_particles)
+		return;
+	p = free_particles;
+	free_particles = p->next;
+	p->next = active_particles;
+	active_particles = p;
+	p->time = cg.time;
+	p->alpha = 1.0;
+	p->alphavel = 0;
+	p->roll = 0;
+
+	p->pshader = pshader;
+
+	p->endtime = cg.time + duration;
+	
+	p->startfade = p->endtime;
+
+	p->width = 1;
+	p->height = 3;
+
+	p->endheight = 3;
+	p->endwidth = 1;
+
+	p->type = P_SMOKE;
+
+	VectorCopy(cent->currentState.origin, p->org );	
+	
+	p->vel[0] = (cent->currentState.origin2[0] * (16 * ratio));
+	p->vel[1] = (cent->currentState.origin2[1] * (16 * ratio));
+	p->vel[2] = (cent->currentState.origin2[2]);
+
+	p->snum = 1.0f;
+
+	VectorClear( p->accel );
+
+	p->accel[2] = -20;
+
+	p->rotate = qfalse;
+
+	p->roll = rand()%179;
+	
+	p->alpha = 0.75;
+
+}
+
+
+void CG_Particle_OilSlick (qhandle_t pshader, centity_t *cent)
+{
+	cparticle_t	*p;
+	
+  	if (!pshader)
+		CG_Printf ("CG_Particle_OilSlick == ZERO!\n");
+
+	if (!free_particles)
+		return;
+	p = free_particles;
+	free_particles = p->next;
+	p->next = active_particles;
+	active_particles = p;
+	p->time = cg.time;
+	
+	if (cent->currentState.angles2[2])
+		p->endtime = cg.time + cent->currentState.angles2[2];
+	else
+		p->endtime = cg.time + 60000;
+
+	p->startfade = p->endtime;
+
+	p->alpha = 1.0;
+	p->alphavel = 0;
+	p->roll = 0;
+
+	p->pshader = pshader;
+
+	if (cent->currentState.angles2[0] || cent->currentState.angles2[1])
+	{
+		p->width = cent->currentState.angles2[0];
+		p->height = cent->currentState.angles2[0];
+
+		p->endheight = cent->currentState.angles2[1];
+		p->endwidth = cent->currentState.angles2[1];
+	}
+	else
+	{
+		p->width = 8;
+		p->height = 8;
+
+		p->endheight = 16;
+		p->endwidth = 16;
+	}
+
+	p->type = P_FLAT_SCALEUP;
+
+	p->snum = 1.0;
+
+	VectorCopy(cent->currentState.origin, p->org );
+	
+	p->org[2]+= 0.55 + (crandom() * 0.5);
+
+	p->vel[0] = 0;
+	p->vel[1] = 0;
+	p->vel[2] = 0;
+	VectorClear( p->accel );
+
+	p->rotate = qfalse;
+
+	p->roll = rand()%179;
+	
+	p->alpha = 0.75;
+
+}
+
+void CG_OilSlickRemove (centity_t *cent)
+{
+	cparticle_t		*p, *next;
+	int				id;
+
+	id = 1.0f;
+
+	if (!id)
+		CG_Printf ("CG_OilSlickRevove NULL id\n");
+
+	for (p=active_particles ; p ; p=next)
+	{
+		next = p->next;
+		
+		if (p->type == P_FLAT_SCALEUP)
+		{
+			if (p->snum == id)
+			{
+				p->endtime = cg.time + 100;
+				p->startfade = p->endtime;
+				p->type = P_FLAT_SCALEUP_FADE;
+
+			}
+		}
+
+	}
+}
+
+qboolean ValidBloodPool (vec3_t start)
+{
+#define EXTRUDE_DIST	0.5
+
+	vec3_t	angles;
+	vec3_t	right, up;
+	vec3_t	this_pos, x_pos, center_pos, end_pos;
+	float	x, y;
+	float	fwidth, fheight;
+	trace_t	trace;
+	vec3_t	normal;
+
+	fwidth = 16;
+	fheight = 16;
+
+	VectorSet (normal, 0, 0, 1);
+
+	vectoangles (normal, angles);
+	AngleVectors (angles, NULL, right, up);
+
+	VectorMA (start, EXTRUDE_DIST, normal, center_pos);
+
+	for (x= -fwidth/2; x<fwidth; x+= fwidth)
+	{
+		VectorMA (center_pos, x, right, x_pos);
+
+		for (y= -fheight/2; y<fheight; y+= fheight)
+		{
+			VectorMA (x_pos, y, up, this_pos);
+			VectorMA (this_pos, -EXTRUDE_DIST*2, normal, end_pos);
+			
+			CG_Trace (&trace, this_pos, NULL, NULL, end_pos, -1, CONTENTS_SOLID);
+
+			
+			if (trace.entityNum != ENTITYNUM_WORLD ) // may only land on world
+				return qfalse;
+
+			if (!(!trace.startsolid && trace.fraction < 1))
+				return qfalse;
+		
+		}
+	}
+
+	return qtrue;
+}
+
+void CG_BloodPool (localEntity_t *le, qhandle_t pshader, trace_t *tr)
+{	
+	cparticle_t	*p;
+	qboolean	legit;
+	vec3_t		start;
+	float		rndSize;
+	
+	if (!pshader)
+		CG_Printf ("CG_BloodPool pshader == ZERO!\n");
+
+	if (!free_particles)
+		return;
+	
+	VectorCopy (tr->endpos, start);
+	legit = ValidBloodPool (start);
+
+	if (!legit) 
+		return;
+
+	p = free_particles;
+	free_particles = p->next;
+	p->next = active_particles;
+	active_particles = p;
+	p->time = cg.time;
+	
+	p->endtime = cg.time + 3000;
+	p->startfade = p->endtime;
+
+	p->alpha = 1.0;
+	p->alphavel = 0;
+	p->roll = 0;
+
+	p->pshader = pshader;
+
+	rndSize = 0.4 + random()*0.6;
+
+	p->width = 8*rndSize;
+	p->height = 8*rndSize;
+
+	p->endheight = 16*rndSize;
+	p->endwidth = 16*rndSize;
+	
+	p->type = P_FLAT_SCALEUP;
+
+	VectorCopy(start, p->org );
+	
+	p->vel[0] = 0;
+	p->vel[1] = 0;
+	p->vel[2] = 0;
+	VectorClear( p->accel );
+
+	p->rotate = qfalse;
+
+	p->roll = rand()%179;
+	
+	p->alpha = 0.75;
+	
+	p->color = BLOODRED;
+}
+
+#define NORMALSIZE	16
+#define LARGESIZE	32
+
+void CG_ParticleBloodCloud (centity_t *cent, vec3_t origin, vec3_t dir)
+{
+	float	length;
+	float	dist;
+	float	crittersize;
+	vec3_t	angles, forward;
+	vec3_t	point;
+	cparticle_t	*p;
+	int		i;
+	
+	dist = 0;
+
+	length = VectorLength (dir);
+	vectoangles (dir, angles);
+	AngleVectors (angles, forward, NULL, NULL);
+
+	crittersize = LARGESIZE;
+
+	if (length)
+		dist = length / crittersize;
+
+	if (dist < 1)
+		dist = 1;
+
+	VectorCopy (origin, point);
+
+	for (i=0; i<dist; i++)
+	{
+		VectorMA (point, crittersize, forward, point);	
+		
+		if (!free_particles)
+			return;
+
+		p = free_particles;
+		free_particles = p->next;
+		p->next = active_particles;
+		active_particles = p;
+
+		p->time = cg.time;
+		p->alpha = 1.0;
+		p->alphavel = 0;
+		p->roll = 0;
+
+		p->pshader = 0;//cgs.media.smokePuffShader;
+
+		p->endtime = cg.time + 350 + (crandom() * 100);
+		
+		p->startfade = cg.time;
+		
+		p->width = LARGESIZE;
+		p->height = LARGESIZE;
+		p->endheight = LARGESIZE;
+		p->endwidth = LARGESIZE;
+
+		p->type = P_SMOKE;
+
+		VectorCopy( origin, p->org );
+		
+		p->vel[0] = 0;
+		p->vel[1] = 0;
+		p->vel[2] = -1;
+		
+		VectorClear( p->accel );
+
+		p->rotate = qfalse;
+
+		p->roll = rand()%179;
+		
+		p->color = BLOODRED;
+		
+		p->alpha = 0.75;
+		
+	}
+
+	
+}
+
+void CG_ParticleSparks (vec3_t org, vec3_t vel, int duration, float x, float y, float speed)
+{
+	cparticle_t	*p;
+
+	if (!free_particles)
+		return;
+	p = free_particles;
+	free_particles = p->next;
+	p->next = active_particles;
+	active_particles = p;
+	p->time = cg.time;
+	
+	p->endtime = cg.time + duration;
+	p->startfade = cg.time + duration/2;
+	
+	p->color = EMISIVEFADE;
+	p->alpha = 0.4f;
+	p->alphavel = 0;
+
+	p->height = 0.5;
+	p->width = 0.5;
+	p->endheight = 0.5;
+	p->endwidth = 0.5;
+
+	p->pshader = 0;//cgs.media.tracerShader;
+
+	p->type = P_SMOKE;
+	
+	VectorCopy(org, p->org);
+
+	p->org[0] += (crandom() * x);
+	p->org[1] += (crandom() * y);
+
+	p->vel[0] = vel[0];
+	p->vel[1] = vel[1];
+	p->vel[2] = vel[2];
+
+	p->accel[0] = p->accel[1] = p->accel[2] = 0;
+
+	p->vel[0] += (crandom() * 4);
+	p->vel[1] += (crandom() * 4);
+	p->vel[2] += (20 + (crandom() * 10)) * speed;	
+
+	p->accel[0] = crandom () * 4;
+	p->accel[1] = crandom () * 4;
+	
+}
+
+void CG_ParticleDust (centity_t *cent, vec3_t origin, vec3_t dir)
+{
+	float	length;
+	float	dist;
+	float	crittersize;
+	vec3_t	angles, forward;
+	vec3_t	point;
+	cparticle_t	*p;
+	int		i;
+	
+	dist = 0;
+
+	VectorNegate (dir, dir);
+	length = VectorLength (dir);
+	vectoangles (dir, angles);
+	AngleVectors (angles, forward, NULL, NULL);
+
+	crittersize = LARGESIZE;
+
+	if (length)
+		dist = length / crittersize;
+
+	if (dist < 1)
+		dist = 1;
+
+	VectorCopy (origin, point);
+
+	for (i=0; i<dist; i++)
+	{
+		VectorMA (point, crittersize, forward, point);	
+				
+		if (!free_particles)
+			return;
+
+		p = free_particles;
+		free_particles = p->next;
+		p->next = active_particles;
+		active_particles = p;
+
+		p->time = cg.time;
+		p->alpha = 5.0;
+		p->alphavel = 0;
+		p->roll = 0;
+
+		p->pshader = 0;//cgs.media.smokePuffShader;
+
+		// RF, stay around for long enough to expand and dissipate naturally
+		if (length)
+			p->endtime = cg.time + 4500 + (crandom() * 3500);
+		else
+			p->endtime = cg.time + 750 + (crandom() * 500);
+		
+		p->startfade = cg.time;
+		
+		p->width = LARGESIZE;
+		p->height = LARGESIZE;
+
+		// RF, expand while falling
+		p->endheight = LARGESIZE*3.0;
+		p->endwidth = LARGESIZE*3.0;
+
+		if (!length)
+		{
+			p->width *= 0.2f;
+			p->height *= 0.2f;
+
+			p->endheight = NORMALSIZE;
+			p->endwidth = NORMALSIZE;
+		}
+
+		p->type = P_SMOKE;
+
+		VectorCopy( point, p->org );
+		
+		p->vel[0] = crandom()*6;
+		p->vel[1] = crandom()*6;
+		p->vel[2] = random()*20;
+
+		// RF, add some gravity/randomness
+		p->accel[0] = crandom()*3;
+		p->accel[1] = crandom()*3;
+		p->accel[2] = -PARTICLE_GRAVITY*0.4;
+
+		VectorClear( p->accel );
+
+		p->rotate = qfalse;
+
+		p->roll = rand()%179;
+		
+		p->alpha = 0.75;
+		
+	}
+
+	
+}
+
+void CG_ParticleMisc (qhandle_t pshader, vec3_t origin, int size, int duration, float alpha)
+{
+	cparticle_t	*p;
+
+	if (!pshader)
+		CG_Printf ("CG_ParticleImpactSmokePuff pshader == ZERO!\n");
+
+	if (!free_particles)
+		return;
+
+	p = free_particles;
+	free_particles = p->next;
+	p->next = active_particles;
+	active_particles = p;
+	p->time = cg.time;
+	p->alpha = 1.0;
+	p->alphavel = 0;
+	p->roll = rand()%179;
+
+	p->pshader = pshader;
+
+	if (duration > 0)
+		p->endtime = cg.time + duration;
+	else
+		p->endtime = duration;
+
+	p->startfade = cg.time;
+
+	p->width = size;
+	p->height = size;
+
+	p->endheight = size;
+	p->endwidth = size;
+
+	p->type = P_SPRITE;
+
+	VectorCopy( origin, p->org );
+
+	p->rotate = qfalse;
+}
+
diff --git a/codemp/cgame/cg_media.h b/codemp/cgame/cg_media.h
new file mode 100644
index 0000000..e69de29
diff --git a/codemp/cgame/cg_newDraw.c b/codemp/cgame/cg_newDraw.c
new file mode 100644
index 0000000..4617c6f
--- /dev/null
+++ b/codemp/cgame/cg_newDraw.c
@@ -0,0 +1,899 @@
+#include "cg_local.h"
+#include "../ui/ui_shared.h"
+
+extern displayContextDef_t cgDC;
+
+
+int CG_GetSelectedPlayer() {
+	if (cg_currentSelectedPlayer.integer < 0 || cg_currentSelectedPlayer.integer >= numSortedTeamPlayers) {
+		cg_currentSelectedPlayer.integer = 0;
+	}
+	return cg_currentSelectedPlayer.integer;
+}
+
+qhandle_t CG_StatusHandle(int task) {
+	qhandle_t h = cgs.media.assaultShader;
+	switch (task) {
+		case TEAMTASK_OFFENSE :
+			h = cgs.media.assaultShader;
+			break;
+		case TEAMTASK_DEFENSE :
+			h = cgs.media.defendShader;
+			break;
+		case TEAMTASK_PATROL :
+			h = cgs.media.patrolShader;
+			break;
+		case TEAMTASK_FOLLOW :
+			h = cgs.media.followShader;
+			break;
+		case TEAMTASK_CAMP :
+			h = cgs.media.campShader;
+			break;
+		case TEAMTASK_RETRIEVE :
+			h = cgs.media.retrieveShader; 
+			break;
+		case TEAMTASK_ESCORT :
+			h = cgs.media.escortShader; 
+			break;
+		default : 
+			h = cgs.media.assaultShader;
+			break;
+	}
+	return h;
+}
+
+
+float CG_GetValue(int ownerDraw) {
+	centity_t	*cent;
+ 	clientInfo_t *ci;
+	playerState_t	*ps;
+
+  cent = &cg_entities[cg.snap->ps.clientNum];
+	ps = &cg.snap->ps;
+
+  switch (ownerDraw) {
+  case CG_SELECTEDPLAYER_ARMOR:
+    ci = cgs.clientinfo + sortedTeamPlayers[CG_GetSelectedPlayer()];
+    return ci->armor;
+    break;
+  case CG_SELECTEDPLAYER_HEALTH:
+    ci = cgs.clientinfo + sortedTeamPlayers[CG_GetSelectedPlayer()];
+    return ci->health;
+    break;
+  case CG_PLAYER_ARMOR_VALUE:
+		return ps->stats[STAT_ARMOR];
+    break;
+  case CG_PLAYER_AMMO_VALUE:
+		if ( cent->currentState.weapon ) 
+		{
+			return ps->ammo[weaponData[cent->currentState.weapon].ammoIndex];
+		}
+    break;
+  case CG_PLAYER_SCORE:
+	  return cg.snap->ps.persistant[PERS_SCORE];
+    break;
+  case CG_PLAYER_HEALTH:
+		return ps->stats[STAT_HEALTH];
+    break;
+  case CG_RED_SCORE:
+		return cgs.scores1;
+    break;
+  case CG_BLUE_SCORE:
+		return cgs.scores2;
+    break;
+  case CG_PLAYER_FORCE_VALUE:
+		return ps->fd.forcePower;
+    break;
+  default:
+    break;
+  }
+	return -1;
+}
+
+qboolean CG_OtherTeamHasFlag(void) {
+	if (cgs.gametype == GT_CTF || cgs.gametype == GT_CTY) {
+		int team = cg.snap->ps.persistant[PERS_TEAM];
+		if (team == TEAM_RED && cgs.redflag == FLAG_TAKEN) {
+			return qtrue;
+		} else if (team == TEAM_BLUE && cgs.blueflag == FLAG_TAKEN) {
+			return qtrue;
+		} else {
+			return qfalse;
+		}
+	}
+	return qfalse;
+}
+
+qboolean CG_YourTeamHasFlag(void) {
+	if (cgs.gametype == GT_CTF || cgs.gametype == GT_CTY) {
+		int team = cg.snap->ps.persistant[PERS_TEAM];
+		if (team == TEAM_RED && cgs.blueflag == FLAG_TAKEN) {
+			return qtrue;
+		} else if (team == TEAM_BLUE && cgs.redflag == FLAG_TAKEN) {
+			return qtrue;
+		} else {
+			return qfalse;
+		}
+	}
+	return qfalse;
+}
+
+// THINKABOUTME: should these be exclusive or inclusive.. 
+// 
+qboolean CG_OwnerDrawVisible(int flags) {
+
+	if (flags & CG_SHOW_TEAMINFO) {
+		return (cg_currentSelectedPlayer.integer == numSortedTeamPlayers);
+	}
+
+	if (flags & CG_SHOW_NOTEAMINFO) {
+		return !(cg_currentSelectedPlayer.integer == numSortedTeamPlayers);
+	}
+
+	if (flags & CG_SHOW_OTHERTEAMHASFLAG) {
+		return CG_OtherTeamHasFlag();
+	}
+
+	if (flags & CG_SHOW_YOURTEAMHASENEMYFLAG) {
+		return CG_YourTeamHasFlag();
+	}
+
+	if (flags & (CG_SHOW_BLUE_TEAM_HAS_REDFLAG | CG_SHOW_RED_TEAM_HAS_BLUEFLAG)) {
+		if (flags & CG_SHOW_BLUE_TEAM_HAS_REDFLAG && (cgs.redflag == FLAG_TAKEN || cgs.flagStatus == FLAG_TAKEN_RED)) {
+			return qtrue;
+		} else if (flags & CG_SHOW_RED_TEAM_HAS_BLUEFLAG && (cgs.blueflag == FLAG_TAKEN || cgs.flagStatus == FLAG_TAKEN_BLUE)) {
+			return qtrue;
+		}
+		return qfalse;
+	}
+
+	if (flags & CG_SHOW_ANYTEAMGAME) {
+		if( cgs.gametype >= GT_TEAM) {
+			return qtrue;
+		}
+	}
+
+	if (flags & CG_SHOW_ANYNONTEAMGAME) {
+		if( cgs.gametype < GT_TEAM) {
+			return qtrue;
+		}
+	}
+
+	if (flags & CG_SHOW_CTF) {
+		if( cgs.gametype == GT_CTF || cgs.gametype == GT_CTY ) {
+			return qtrue;
+		}
+	}
+
+	if (flags & CG_SHOW_HEALTHCRITICAL) {
+		if (cg.snap->ps.stats[STAT_HEALTH] < 25) {
+			return qtrue;
+		}
+	}
+
+	if (flags & CG_SHOW_HEALTHOK) {
+		if (cg.snap->ps.stats[STAT_HEALTH] >= 25) {
+			return qtrue;
+		}
+	}
+
+	if (flags & CG_SHOW_SINGLEPLAYER) {
+		if( cgs.gametype == GT_SINGLE_PLAYER ) {
+			return qtrue;
+		}
+	}
+
+	if (flags & CG_SHOW_TOURNAMENT) {
+		if( cgs.gametype == GT_DUEL || cgs.gametype == GT_POWERDUEL ) {
+			return qtrue;
+		}
+	}
+
+	if (flags & CG_SHOW_DURINGINCOMINGVOICE) {
+	}
+
+	if (flags & CG_SHOW_IF_PLAYER_HAS_FLAG) {
+		if (cg.snap->ps.powerups[PW_REDFLAG] || cg.snap->ps.powerups[PW_BLUEFLAG] || cg.snap->ps.powerups[PW_NEUTRALFLAG]) {
+			return qtrue;
+		}
+	}
+	return qfalse;
+}
+
+
+const char *CG_GetKillerText(void) {
+	static const char *s = "";
+	if ( cg.killerName[0] ) {
+		s = va("%s %s", CG_GetStringEdString("MP_INGAME", "KILLEDBY"), cg.killerName );
+	}
+	return s;
+}
+
+
+const char *CG_GetGameStatusText(void) {
+	static const char *s = "";
+	if (cgs.gametype == GT_POWERDUEL)
+	{
+		s = "";
+	}	
+	else if ( cgs.gametype < GT_TEAM)
+	{
+		if (cg.snap->ps.persistant[PERS_TEAM] != TEAM_SPECTATOR ) 
+		{
+			char sPlaceWith[256];
+			trap_SP_GetStringTextString("MP_INGAME_PLACE_WITH", sPlaceWith, sizeof(sPlaceWith));
+
+			s = va("%s %s %i",CG_PlaceString( cg.snap->ps.persistant[PERS_RANK] + 1 ), sPlaceWith, cg.snap->ps.persistant[PERS_SCORE] );
+		}
+	}
+	else
+	{
+		if ( cg.teamScores[0] == cg.teamScores[1] ) {
+			s = va("%s %i", CG_GetStringEdString("MP_INGAME", "TIEDAT"), cg.teamScores[0] );
+		} else if ( cg.teamScores[0] >= cg.teamScores[1] ) {
+			s = va("%s, %i / %i", CG_GetStringEdString("MP_INGAME", "RED_LEADS"), cg.teamScores[0], cg.teamScores[1] );
+		} else {
+			s = va("%s, %i / %i", CG_GetStringEdString("MP_INGAME", "BLUE_LEADS"), cg.teamScores[1], cg.teamScores[0] );
+		}
+	}
+	return s;
+}
+	
+const char *CG_GameTypeString(void) {
+	if ( cgs.gametype == GT_FFA ) {
+		return "Free For All";
+	} else if ( cgs.gametype == GT_HOLOCRON ) {
+		return "Holocron FFA";
+	} else if ( cgs.gametype == GT_JEDIMASTER ) {
+		return "Jedi Master";
+	} else if ( cgs.gametype == GT_TEAM ) {
+		return "Team FFA";
+	} else if ( cgs.gametype == GT_SIEGE ) {
+		return "Siege";
+	} else if ( cgs.gametype == GT_CTF ) {
+		return "Capture the Flag";
+	} else if ( cgs.gametype == GT_CTY ) {
+		return "Capture the Ysalamiri";
+	}
+	return "";
+}
+						 
+#include "../namespace_begin.h"
+extern int MenuFontToHandle(int iMenuFont);
+#include "../namespace_end.h"
+
+// maxX param is initially an X limit, but is also used as feedback. 0 = text was clipped to fit within, else maxX = next pos
+//
+static void CG_Text_Paint_Limit(float *maxX, float x, float y, float scale, vec4_t color, const char* text, float adjust, int limit, int iMenuFont) 
+{
+	qboolean bIsTrailingPunctuation;
+
+	// this is kinda dirty, but...
+	//
+	int iFontIndex = MenuFontToHandle(iMenuFont);
+	
+	//float fMax = *maxX;
+	int iPixelLen = trap_R_Font_StrLenPixels(text, iFontIndex, scale);
+	if (x + iPixelLen > *maxX)
+	{
+		// whole text won't fit, so we need to print just the amount that does...
+		//  Ok, this is slow and tacky, but only called occasionally, and it works...
+		//
+		char sTemp[4096]={0};	// lazy assumption
+		const char *psText = text;
+		char *psOut = &sTemp[0];
+		char *psOutLastGood = psOut;
+		unsigned int uiLetter;
+
+		while (*psText && (x + trap_R_Font_StrLenPixels(sTemp, iFontIndex, scale)<=*maxX) 
+			   && psOut < &sTemp[sizeof(sTemp)-1]	// sanity
+				)
+		{
+			int iAdvanceCount;
+			psOutLastGood = psOut;			
+
+			uiLetter = trap_AnyLanguage_ReadCharFromString(psText, &iAdvanceCount, &bIsTrailingPunctuation);
+			psText += iAdvanceCount;
+
+			if (uiLetter > 255)
+			{
+				*psOut++ = uiLetter>>8;
+				*psOut++ = uiLetter&0xFF;
+			}
+			else
+			{
+				*psOut++ = uiLetter&0xFF;
+			}
+		}
+		*psOutLastGood = '\0';
+
+		*maxX = 0;	// feedback
+		CG_Text_Paint(x, y, scale, color, sTemp, adjust, limit, ITEM_TEXTSTYLE_NORMAL, iMenuFont);
+	}
+	else
+	{
+		// whole text fits fine, so print it all...
+		//
+		*maxX = x + iPixelLen;	// feedback the next position, as the caller expects		
+		CG_Text_Paint(x, y, scale, color, text, adjust, limit, ITEM_TEXTSTYLE_NORMAL, iMenuFont);
+	}
+}
+
+
+
+#define PIC_WIDTH 12
+
+extern const char *CG_GetLocationString(const char *loc); //cg_main.c
+void CG_DrawNewTeamInfo(rectDef_t *rect, float text_x, float text_y, float scale, vec4_t color, qhandle_t shader) {
+	int xx;
+	float y;
+	int i, j, len, count;
+	const char *p;
+	vec4_t		hcolor;
+	float pwidth, lwidth, maxx, leftOver;
+	clientInfo_t *ci;
+	gitem_t	*item;
+	qhandle_t h;
+
+	// max player name width
+	pwidth = 0;
+	count = (numSortedTeamPlayers > 8) ? 8 : numSortedTeamPlayers;
+	for (i = 0; i < count; i++) {
+		ci = cgs.clientinfo + sortedTeamPlayers[i];
+		if ( ci->infoValid && ci->team == cg.snap->ps.persistant[PERS_TEAM]) {
+			len = CG_Text_Width( ci->name, scale, 0);
+			if (len > pwidth)
+				pwidth = len;
+		}
+	}
+
+	// max location name width
+	lwidth = 0;
+	for (i = 1; i < MAX_LOCATIONS; i++) {
+		p = CG_GetLocationString(CG_ConfigString(CS_LOCATIONS+i));
+		if (p && *p) {
+			len = CG_Text_Width(p, scale, 0);
+			if (len > lwidth)
+				lwidth = len;
+		}
+	}
+
+	y = rect->y;
+
+	for (i = 0; i < count; i++) {
+		ci = cgs.clientinfo + sortedTeamPlayers[i];
+		if ( ci->infoValid && ci->team == cg.snap->ps.persistant[PERS_TEAM]) {
+
+			xx = rect->x + 1;
+			for (j = 0; j <= PW_NUM_POWERUPS; j++) {
+				if (ci->powerups & (1 << j)) {
+
+					item = BG_FindItemForPowerup( j );
+
+					if (item) {
+						CG_DrawPic( xx, y, PIC_WIDTH, PIC_WIDTH, trap_R_RegisterShader( item->icon ) );
+						xx += PIC_WIDTH;
+					}
+				}
+			}
+
+			// FIXME: max of 3 powerups shown properly
+			xx = rect->x + (PIC_WIDTH * 3) + 2;
+
+			CG_GetColorForHealth( ci->health, ci->armor, hcolor );
+			trap_R_SetColor(hcolor);
+			CG_DrawPic( xx, y + 1, PIC_WIDTH - 2, PIC_WIDTH - 2, cgs.media.heartShader );
+
+			//Com_sprintf (st, sizeof(st), "%3i %3i", ci->health,	ci->armor);
+			//CG_Text_Paint(xx, y + text_y, scale, hcolor, st, 0, 0); 
+
+			// draw weapon icon
+			xx += PIC_WIDTH + 1;
+
+// weapon used is not that useful, use the space for task
+#if 0
+			if ( cg_weapons[ci->curWeapon].weaponIcon ) {
+				CG_DrawPic( xx, y, PIC_WIDTH, PIC_WIDTH, cg_weapons[ci->curWeapon].weaponIcon );
+			} else {
+				CG_DrawPic( xx, y, PIC_WIDTH, PIC_WIDTH, cgs.media.deferShader );
+			}
+#endif
+
+			trap_R_SetColor(NULL);
+			h = CG_StatusHandle(ci->teamTask);
+
+			if (h) {
+				CG_DrawPic( xx, y, PIC_WIDTH, PIC_WIDTH, h);
+			}
+
+			xx += PIC_WIDTH + 1;
+
+			leftOver = rect->w - xx;
+			maxx = xx + leftOver / 3;
+
+
+
+			CG_Text_Paint_Limit(&maxx, xx, y + text_y, scale, color, ci->name, 0, 0, FONT_MEDIUM); 
+
+			p = CG_GetLocationString(CG_ConfigString(CS_LOCATIONS+ci->location));
+			if (!p || !*p) {
+				p = "unknown";
+			}
+
+			xx += leftOver / 3 + 2;
+			maxx = rect->w - 4;
+
+			CG_Text_Paint_Limit(&maxx, xx, y + text_y, scale, color, p, 0, 0, FONT_MEDIUM); 
+			y += text_y + 2;
+			if ( y + text_y + 2 > rect->y + rect->h ) {
+				break;
+			}
+
+		}
+	}
+}
+
+
+void CG_DrawTeamSpectators(rectDef_t *rect, float scale, vec4_t color, qhandle_t shader) {
+	if (cg.spectatorLen) {
+		float maxX;
+
+		if (cg.spectatorWidth == -1) {
+			cg.spectatorWidth = 0;
+			cg.spectatorPaintX = rect->x + 1;
+			cg.spectatorPaintX2 = -1;
+		}
+
+		if (cg.spectatorOffset > cg.spectatorLen) {
+			cg.spectatorOffset = 0;
+			cg.spectatorPaintX = rect->x + 1;
+			cg.spectatorPaintX2 = -1;
+		}
+
+		if (cg.time > cg.spectatorTime) {
+			cg.spectatorTime = cg.time + 10;
+			if (cg.spectatorPaintX <= rect->x + 2) {
+				if (cg.spectatorOffset < cg.spectatorLen) {
+					cg.spectatorPaintX += CG_Text_Width(&cg.spectatorList[cg.spectatorOffset], scale, 1) - 1;
+					cg.spectatorOffset++;
+				} else {
+					cg.spectatorOffset = 0;
+					if (cg.spectatorPaintX2 >= 0) {
+						cg.spectatorPaintX = cg.spectatorPaintX2;
+					} else {
+						cg.spectatorPaintX = rect->x + rect->w - 2;
+					}
+					cg.spectatorPaintX2 = -1;
+				}
+			} else {
+				cg.spectatorPaintX--;
+				if (cg.spectatorPaintX2 >= 0) {
+					cg.spectatorPaintX2--;
+				}
+			}
+		}
+
+		maxX = rect->x + rect->w - 2;
+		CG_Text_Paint_Limit(&maxX, cg.spectatorPaintX, rect->y + rect->h - 3, scale, color, &cg.spectatorList[cg.spectatorOffset], 0, 0, FONT_MEDIUM); 
+		if (cg.spectatorPaintX2 >= 0) {
+			float maxX2 = rect->x + rect->w - 2;
+			CG_Text_Paint_Limit(&maxX2, cg.spectatorPaintX2, rect->y + rect->h - 3, scale, color, cg.spectatorList, 0, cg.spectatorOffset, FONT_MEDIUM); 
+		}
+		if (cg.spectatorOffset && maxX > 0) {
+			// if we have an offset ( we are skipping the first part of the string ) and we fit the string
+			if (cg.spectatorPaintX2 == -1) {
+						cg.spectatorPaintX2 = rect->x + rect->w - 2;
+			}
+		} else {
+			cg.spectatorPaintX2 = -1;
+		}
+
+	}
+}
+
+
+
+void CG_DrawMedal(int ownerDraw, rectDef_t *rect, float scale, vec4_t color, qhandle_t shader) {
+	score_t *score = &cg.scores[cg.selectedScore];
+	float value = 0;
+	char *text = NULL;
+	color[3] = 0.25;
+
+	switch (ownerDraw) {
+		case CG_ACCURACY:
+			value = score->accuracy;
+			break;
+		case CG_ASSISTS:
+			value = score->assistCount;
+			break;
+		case CG_DEFEND:
+			value = score->defendCount;
+			break;
+		case CG_EXCELLENT:
+			value = score->excellentCount;
+			break;
+		case CG_IMPRESSIVE:
+			value = score->impressiveCount;
+			break;
+		case CG_PERFECT:
+			value = score->perfect;
+			break;
+		case CG_GAUNTLET:
+			value = score->guantletCount;
+			break;
+		case CG_CAPTURES:
+			value = score->captures;
+			break;
+	}
+
+	if (value > 0) {
+		if (ownerDraw != CG_PERFECT) {
+			if (ownerDraw == CG_ACCURACY) {
+				text = va("%i%%", (int)value);
+				if (value > 50) {
+					color[3] = 1.0;
+				}
+			} else {
+				text = va("%i", (int)value);
+				color[3] = 1.0;
+			}
+		} else {
+			if (value) {
+				color[3] = 1.0;
+			}
+			text = "Wow";
+		}
+	}
+
+	trap_R_SetColor(color);
+	CG_DrawPic( rect->x, rect->y, rect->w, rect->h, shader );
+
+	if (text) {
+		color[3] = 1.0;
+		value = CG_Text_Width(text, scale, 0);
+		CG_Text_Paint(rect->x + (rect->w - value) / 2, rect->y + rect->h + 10 , scale, color, text, 0, 0, 0, FONT_MEDIUM); 
+	}
+	trap_R_SetColor(NULL);
+
+}
+
+	
+//
+void CG_OwnerDraw(float x, float y, float w, float h, float text_x, float text_y, int ownerDraw, int ownerDrawFlags, int align, float special, float scale, vec4_t color, qhandle_t shader, int textStyle,int font) {
+
+//Ignore all this, at least for now. May put some stat stuff back in menu files later.
+#if 0
+	rectDef_t rect;
+
+  if ( cg_drawStatus.integer == 0 ) {
+		return;
+	}
+
+	//if (ownerDrawFlags != 0 && !CG_OwnerDrawVisible(ownerDrawFlags)) {
+	//	return;
+	//}
+
+  rect.x = x;
+  rect.y = y;
+  rect.w = w;
+  rect.h = h;
+
+  switch (ownerDraw) {
+  case CG_PLAYER_ARMOR_ICON:
+    CG_DrawPlayerArmorIcon(&rect, ownerDrawFlags & CG_SHOW_2DONLY);
+    break;
+  case CG_PLAYER_ARMOR_ICON2D:
+    CG_DrawPlayerArmorIcon(&rect, qtrue);
+    break;
+  case CG_PLAYER_ARMOR_VALUE:
+    CG_DrawPlayerArmorValue(&rect, scale, color, shader, textStyle);
+    break;
+  case CG_PLAYER_FORCE_VALUE:
+    CG_DrawPlayerForceValue(&rect, scale, color, shader, textStyle);
+	return ;
+  case CG_PLAYER_AMMO_ICON:
+    CG_DrawPlayerAmmoIcon(&rect, ownerDrawFlags & CG_SHOW_2DONLY);
+    break;
+  case CG_PLAYER_AMMO_ICON2D:
+    CG_DrawPlayerAmmoIcon(&rect, qtrue);
+    break;
+  case CG_PLAYER_AMMO_VALUE:
+    CG_DrawPlayerAmmoValue(&rect, scale, color, shader, textStyle);
+    break;
+  case CG_SELECTEDPLAYER_HEAD:
+    CG_DrawSelectedPlayerHead(&rect, ownerDrawFlags & CG_SHOW_2DONLY, qfalse);
+    break;
+  case CG_VOICE_HEAD:
+    CG_DrawSelectedPlayerHead(&rect, ownerDrawFlags & CG_SHOW_2DONLY, qtrue);
+    break;
+  case CG_VOICE_NAME:
+    CG_DrawSelectedPlayerName(&rect, scale, color, qtrue, textStyle);
+    break;
+  case CG_SELECTEDPLAYER_STATUS:
+    CG_DrawSelectedPlayerStatus(&rect);
+    break;
+  case CG_SELECTEDPLAYER_ARMOR:
+    CG_DrawSelectedPlayerArmor(&rect, scale, color, shader, textStyle);
+    break;
+  case CG_SELECTEDPLAYER_HEALTH:
+    CG_DrawSelectedPlayerHealth(&rect, scale, color, shader, textStyle);
+    break;
+  case CG_SELECTEDPLAYER_NAME:
+    CG_DrawSelectedPlayerName(&rect, scale, color, qfalse, textStyle);
+    break;
+  case CG_SELECTEDPLAYER_LOCATION:
+    CG_DrawSelectedPlayerLocation(&rect, scale, color, textStyle);
+    break;
+  case CG_SELECTEDPLAYER_WEAPON:
+    CG_DrawSelectedPlayerWeapon(&rect);
+    break;
+  case CG_SELECTEDPLAYER_POWERUP:
+    CG_DrawSelectedPlayerPowerup(&rect, ownerDrawFlags & CG_SHOW_2DONLY);
+    break;
+  case CG_PLAYER_HEAD:
+    CG_DrawPlayerHead(&rect, ownerDrawFlags & CG_SHOW_2DONLY);
+    break;
+  case CG_PLAYER_ITEM:
+    CG_DrawPlayerItem(&rect, scale, ownerDrawFlags & CG_SHOW_2DONLY);
+    break;
+  case CG_PLAYER_SCORE:
+    CG_DrawPlayerScore(&rect, scale, color, shader, textStyle);
+    break;
+  case CG_PLAYER_HEALTH:
+    CG_DrawPlayerHealth(&rect, scale, color, shader, textStyle);
+    break;
+  case CG_RED_SCORE:
+    CG_DrawRedScore(&rect, scale, color, shader, textStyle);
+    break;
+  case CG_BLUE_SCORE:
+    CG_DrawBlueScore(&rect, scale, color, shader, textStyle);
+    break;
+  case CG_RED_NAME:
+    CG_DrawRedName(&rect, scale, color, textStyle);
+    break;
+  case CG_BLUE_NAME:
+    CG_DrawBlueName(&rect, scale, color, textStyle);
+    break;
+  case CG_BLUE_FLAGHEAD:
+    CG_DrawBlueFlagHead(&rect);
+    break;
+  case CG_BLUE_FLAGSTATUS:
+    CG_DrawBlueFlagStatus(&rect, shader);
+    break;
+  case CG_BLUE_FLAGNAME:
+    CG_DrawBlueFlagName(&rect, scale, color, textStyle);
+    break;
+  case CG_RED_FLAGHEAD:
+    CG_DrawRedFlagHead(&rect);
+    break;
+  case CG_RED_FLAGSTATUS:
+    CG_DrawRedFlagStatus(&rect, shader);
+    break;
+  case CG_RED_FLAGNAME:
+    CG_DrawRedFlagName(&rect, scale, color, textStyle);
+    break;
+  case CG_PLAYER_LOCATION:
+    CG_DrawPlayerLocation(&rect, scale, color, textStyle);
+    break;
+  case CG_TEAM_COLOR:
+    CG_DrawTeamColor(&rect, color);
+    break;
+  case CG_CTF_POWERUP:
+    CG_DrawCTFPowerUp(&rect);
+    break;
+  case CG_AREA_POWERUP:
+		CG_DrawAreaPowerUp(&rect, align, special, scale, color);
+    break;
+  case CG_PLAYER_STATUS:
+    CG_DrawPlayerStatus(&rect);
+    break;
+  case CG_PLAYER_HASFLAG:
+    CG_DrawPlayerHasFlag(&rect, qfalse);
+    break;
+  case CG_PLAYER_HASFLAG2D:
+    CG_DrawPlayerHasFlag(&rect, qtrue);
+    break;
+  case CG_AREA_SYSTEMCHAT:
+    CG_DrawAreaSystemChat(&rect, scale, color, shader);
+    break;
+  case CG_AREA_TEAMCHAT:
+    CG_DrawAreaTeamChat(&rect, scale, color, shader);
+    break;
+  case CG_AREA_CHAT:
+    CG_DrawAreaChat(&rect, scale, color, shader);
+    break;
+  case CG_GAME_TYPE:
+    CG_DrawGameType(&rect, scale, color, shader, textStyle);
+    break;
+  case CG_GAME_STATUS:
+    CG_DrawGameStatus(&rect, scale, color, shader, textStyle);
+		break;
+  case CG_KILLER:
+    CG_DrawKiller(&rect, scale, color, shader, textStyle);
+		break;
+	case CG_ACCURACY:
+	case CG_ASSISTS:
+	case CG_DEFEND:
+	case CG_EXCELLENT:
+	case CG_IMPRESSIVE:
+	case CG_PERFECT:
+	case CG_GAUNTLET:
+	case CG_CAPTURES:
+		CG_DrawMedal(ownerDraw, &rect, scale, color, shader);
+		break;
+  case CG_SPECTATORS:
+		CG_DrawTeamSpectators(&rect, scale, color, shader);
+		break;
+  case CG_TEAMINFO:
+		if (cg_currentSelectedPlayer.integer == numSortedTeamPlayers) {
+			CG_DrawNewTeamInfo(&rect, text_x, text_y, scale, color, shader);
+		}
+		break;
+  case CG_CAPFRAGLIMIT:
+    CG_DrawCapFragLimit(&rect, scale, color, shader, textStyle);
+		break;
+  case CG_1STPLACE:
+    CG_Draw1stPlace(&rect, scale, color, shader, textStyle);
+		break;
+  case CG_2NDPLACE:
+    CG_Draw2ndPlace(&rect, scale, color, shader, textStyle);
+		break;
+  default:
+    break;
+  }
+#endif
+}
+
+void CG_MouseEvent(int x, int y) {
+	int n;
+
+	if ( (cg.predictedPlayerState.pm_type == PM_NORMAL || cg.predictedPlayerState.pm_type == PM_JETPACK || cg.predictedPlayerState.pm_type == PM_FLOAT || cg.predictedPlayerState.pm_type == PM_SPECTATOR) && cg.showScores == qfalse) {
+    trap_Key_SetCatcher(0);
+		return;
+	}
+
+	cgs.cursorX+= x;
+	if (cgs.cursorX < 0)
+		cgs.cursorX = 0;
+	else if (cgs.cursorX > 640)
+		cgs.cursorX = 640;
+
+	cgs.cursorY += y;
+	if (cgs.cursorY < 0)
+		cgs.cursorY = 0;
+	else if (cgs.cursorY > 480)
+		cgs.cursorY = 480;
+
+	n = Display_CursorType(cgs.cursorX, cgs.cursorY);
+	cgs.activeCursor = 0;
+	if (n == CURSOR_ARROW) {
+		cgs.activeCursor = cgs.media.selectCursor;
+	} else if (n == CURSOR_SIZER) {
+		cgs.activeCursor = cgs.media.sizeCursor;
+	}
+
+  if (cgs.capturedItem) {
+	  Display_MouseMove(cgs.capturedItem, x, y);
+  } else {
+	  Display_MouseMove(NULL, cgs.cursorX, cgs.cursorY);
+  }
+
+}
+
+/*
+==================
+CG_HideTeamMenus
+==================
+
+*/
+void CG_HideTeamMenu() {
+  Menus_CloseByName("teamMenu");
+  Menus_CloseByName("getMenu");
+}
+
+/*
+==================
+CG_ShowTeamMenus
+==================
+
+*/
+void CG_ShowTeamMenu() {
+  Menus_OpenByName("teamMenu");
+}
+
+
+
+
+/*
+==================
+CG_EventHandling
+==================
+ type 0 - no event handling
+      1 - team menu
+      2 - hud editor
+
+*/
+void CG_EventHandling(int type) {
+	cgs.eventHandling = type;
+  if (type == CGAME_EVENT_NONE) {
+    CG_HideTeamMenu();
+  } else if (type == CGAME_EVENT_TEAMMENU) {
+    //CG_ShowTeamMenu();
+  } else if (type == CGAME_EVENT_SCOREBOARD) {
+  }
+
+}
+
+
+
+void CG_KeyEvent(int key, qboolean down) {
+
+	if (!down) {
+		return;
+	}
+
+	if ( cg.predictedPlayerState.pm_type == PM_NORMAL || cg.predictedPlayerState.pm_type == PM_JETPACK || cg.predictedPlayerState.pm_type == PM_NORMAL || (cg.predictedPlayerState.pm_type == PM_SPECTATOR && cg.showScores == qfalse)) {
+		CG_EventHandling(CGAME_EVENT_NONE);
+    trap_Key_SetCatcher(0);
+		return;
+	}
+
+  //if (key == trap_Key_GetKey("teamMenu") || !Display_CaptureItem(cgs.cursorX, cgs.cursorY)) {
+    // if we see this then we should always be visible
+  //  CG_EventHandling(CGAME_EVENT_NONE);
+  //  trap_Key_SetCatcher(0);
+  //}
+
+
+
+  Display_HandleKey(key, down, cgs.cursorX, cgs.cursorY);
+
+	if (cgs.capturedItem) {
+		cgs.capturedItem = NULL;
+	}	else {
+		if (key == A_MOUSE2 && down) {
+			cgs.capturedItem = Display_CaptureItem(cgs.cursorX, cgs.cursorY);
+		}
+	}
+}
+
+int CG_ClientNumFromName(const char *p) {
+  int i;
+  for (i = 0; i < cgs.maxclients; i++) {
+    if (cgs.clientinfo[i].infoValid && Q_stricmp(cgs.clientinfo[i].name, p) == 0) {
+      return i;
+    }
+  }
+  return -1;
+}
+
+void CG_ShowResponseHead(void) {
+  Menus_OpenByName("voiceMenu");
+	trap_Cvar_Set("cl_conXOffset", "72");
+	cg.voiceTime = cg.time;
+}
+
+void CG_RunMenuScript(char **args) {
+}
+
+qboolean CG_DeferMenuScript (char **args) 
+{
+	return qfalse;
+}
+
+void CG_GetTeamColor(vec4_t *color) {
+  if (cg.snap->ps.persistant[PERS_TEAM] == TEAM_RED) {
+    (*color)[0] = 1.0f;
+    (*color)[3] = 0.25f;
+    (*color)[1] = (*color)[2] = 0.0f;
+  } else if (cg.snap->ps.persistant[PERS_TEAM] == TEAM_BLUE) {
+    (*color)[0] = (*color)[1] = 0.0f;
+    (*color)[2] = 1.0f;
+    (*color)[3] = 0.25f;
+  } else {
+    (*color)[0] = (*color)[2] = 0.0f;
+    (*color)[1] = 0.17f;
+    (*color)[3] = 0.25f;
+	}
+}
+
diff --git a/codemp/cgame/cg_playeranimate.c b/codemp/cgame/cg_playeranimate.c
new file mode 100644
index 0000000..e69de29
diff --git a/codemp/cgame/cg_players.c b/codemp/cgame/cg_players.c
new file mode 100644
index 0000000..d25f0f8
--- /dev/null
+++ b/codemp/cgame/cg_players.c
@@ -0,0 +1,10948 @@
+// Copyright (C) 1999-2000 Id Software, Inc.
+//
+// cg_players.c -- handle the media and animation for player entities
+#include "cg_local.h"
+#include "..\ghoul2\g2.h"
+#include "bg_saga.h"
+
+extern vmCvar_t	cg_thirdPersonAlpha;
+
+extern int			cgSiegeTeam1PlShader;
+extern int			cgSiegeTeam2PlShader;
+
+extern void CG_AddRadarEnt(centity_t *cent);	//cg_ents.c
+extern void CG_AddBracketedEnt(centity_t *cent);	//cg_ents.c
+extern qboolean CG_InFighter( void );
+
+
+//for g2 surface routines
+#define TURN_ON				0x00000000
+#define TURN_OFF			0x00000100
+
+extern stringID_table_t animTable [MAX_ANIMATIONS+1];
+
+char	*cg_customSoundNames[MAX_CUSTOM_SOUNDS] = {
+	"*death1",
+	"*death2",
+	"*death3",
+	"*jump1",
+	"*pain25",
+	"*pain50",
+	"*pain75",
+	"*pain100",
+	"*falling1",
+	"*choke1",
+	"*choke2",
+	"*choke3",
+	"*gasp",
+	"*land1",
+	"*taunt",
+	NULL
+};
+
+//NPC sounds:
+//Used as a supplement to the basic set for enemies and hazard team
+// (keep numbers in ascending order in order for variant-capping to work)
+const char	*cg_customCombatSoundNames[MAX_CUSTOM_COMBAT_SOUNDS] = 
+{
+	"*anger1",	//Say when acquire an enemy when didn't have one before
+	"*anger2",
+	"*anger3",
+	"*victory1",	//Say when killed an enemy
+	"*victory2",
+	"*victory3",
+	"*confuse1",	//Say when confused
+	"*confuse2",
+	"*confuse3",
+	"*pushed1",	//Say when force-pushed
+	"*pushed2",
+	"*pushed3",
+	"*choke1",
+	"*choke2",
+	"*choke3",
+	"*ffwarn",
+	"*ffturn",
+	NULL
+};
+
+//Used as a supplement to the basic set for stormtroopers
+// (keep numbers in ascending order in order for variant-capping to work)
+const char	*cg_customExtraSoundNames[MAX_CUSTOM_EXTRA_SOUNDS] = 
+{
+	"*chase1",
+	"*chase2",
+	"*chase3",
+	"*cover1",
+	"*cover2",
+	"*cover3",
+	"*cover4",
+	"*cover5",
+	"*detected1",
+	"*detected2",
+	"*detected3",
+	"*detected4",
+	"*detected5",
+	"*lost1",
+	"*outflank1",
+	"*outflank2",
+	"*escaping1",
+	"*escaping2",
+	"*escaping3",
+	"*giveup1",
+	"*giveup2",
+	"*giveup3",
+	"*giveup4",
+	"*look1",
+	"*look2",
+	"*sight1",
+	"*sight2",
+	"*sight3",
+	"*sound1",
+	"*sound2",
+	"*sound3",
+	"*suspicious1",
+	"*suspicious2",
+	"*suspicious3",
+	"*suspicious4",
+	"*suspicious5",
+	NULL
+};
+
+//Used as a supplement to the basic set for jedi
+// (keep numbers in ascending order in order for variant-capping to work)
+const char	*cg_customJediSoundNames[MAX_CUSTOM_JEDI_SOUNDS] = 
+{
+	"*combat1",
+	"*combat2",
+	"*combat3",
+	"*jdetected1",
+	"*jdetected2",
+	"*jdetected3",
+	"*taunt1",
+	"*taunt2",
+	"*taunt3",
+	"*jchase1",
+	"*jchase2",
+	"*jchase3",
+	"*jlost1",
+	"*jlost2",
+	"*jlost3",
+	"*deflect1",
+	"*deflect2",
+	"*deflect3",
+	"*gloat1",
+	"*gloat2",
+	"*gloat3",
+	"*pushfail",
+	NULL
+};
+
+//Used for DUEL taunts
+const char	*cg_customDuelSoundNames[MAX_CUSTOM_DUEL_SOUNDS] = 
+{
+	"*anger1",	//Say when acquire an enemy when didn't have one before
+	"*anger2",
+	"*anger3",
+	"*victory1",	//Say when killed an enemy
+	"*victory2",
+	"*victory3",
+	"*taunt1",
+	"*taunt2",
+	"*taunt3",
+	"*deflect1",
+	"*deflect2",
+	"*deflect3",
+	"*gloat1",
+	"*gloat2",
+	"*gloat3",
+	NULL
+};
+
+void CG_Disintegration(centity_t *cent, refEntity_t *ent);
+
+/*
+================
+CG_CustomSound
+
+================
+*/
+sfxHandle_t	CG_CustomSound( int clientNum, const char *soundName ) {
+	clientInfo_t *ci;
+	int			i;
+	int			numCSounds = 0;
+	int			numCComSounds = 0;
+	int			numCExSounds = 0;
+	int			numCJediSounds = 0;
+	int			numCSiegeSounds = 0;
+	int			numCDuelSounds = 0;
+	char		lSoundName[MAX_QPATH];
+
+	if ( soundName[0] != '*' ) {
+		return trap_S_RegisterSound( soundName );
+	}
+
+	COM_StripExtension(soundName, lSoundName);
+
+	if ( clientNum < 0 )
+	{
+		clientNum = 0;
+	}
+
+	if (clientNum >= MAX_CLIENTS)
+	{
+		ci = cg_entities[clientNum].npcClient;
+	}
+	else
+	{
+		ci = &cgs.clientinfo[ clientNum ];
+	}
+
+	if (!ci)
+	{
+		return 0;
+	}
+
+	for (i = 0; i < MAX_CUSTOM_SOUNDS; i++)
+	{
+		if (!cg_customSoundNames[i])
+		{
+			numCSounds = i;
+			break;
+		}
+	}
+
+	if (clientNum >= MAX_CLIENTS)
+	{ //these are only for npc's
+		for (i = 0; i < MAX_CUSTOM_SOUNDS; i++)
+		{
+			if (!cg_customCombatSoundNames[i])
+			{
+				numCComSounds = i;
+				break;
+			}
+		}
+
+		for (i = 0; i < MAX_CUSTOM_SOUNDS; i++)
+		{
+			if (!cg_customExtraSoundNames[i])
+			{
+				numCExSounds = i;
+				break;
+			}
+		}
+
+		for (i = 0; i < MAX_CUSTOM_SOUNDS; i++)
+		{
+			if (!cg_customJediSoundNames[i])
+			{
+				numCJediSounds = i;
+				break;
+			}
+		}
+	}
+
+    if (cgs.gametype >= GT_TEAM || cg_buildScript.integer)
+	{ //siege only
+		for (i = 0; i < MAX_CUSTOM_SOUNDS; i++)
+		{
+			if (!bg_customSiegeSoundNames[i])
+			{
+				numCSiegeSounds = i;
+				break;
+			}
+		}
+	}
+
+    if (cgs.gametype == GT_DUEL
+		|| cgs.gametype == GT_POWERDUEL
+		|| cg_buildScript.integer)
+	{ //Duel only
+		for (i = 0; i < MAX_CUSTOM_SOUNDS; i++)
+		{
+			if (!cg_customDuelSoundNames[i])
+			{
+				numCDuelSounds = i;
+				break;
+			}
+		}
+	}
+
+	for ( i = 0 ; i < MAX_CUSTOM_SOUNDS ; i++ )
+	{
+		if ( i < numCSounds && !strcmp( lSoundName, cg_customSoundNames[i] ) )
+		{
+			return ci->sounds[i];
+		}
+		else if ( (cgs.gametype >= GT_TEAM || cg_buildScript.integer) && i < numCSiegeSounds && !strcmp( lSoundName, bg_customSiegeSoundNames[i] ) )
+		{ //siege only
+			return ci->siegeSounds[i];
+		}
+		else if ( (cgs.gametype == GT_DUEL || cgs.gametype == GT_POWERDUEL || cg_buildScript.integer) && i < numCDuelSounds && !strcmp( lSoundName, cg_customDuelSoundNames[i] ) )
+		{ //siege only
+			return ci->duelSounds[i];
+		}
+		else if ( clientNum >= MAX_CLIENTS && i < numCComSounds && !strcmp( lSoundName, cg_customCombatSoundNames[i] ) )
+		{ //npc only
+			return ci->combatSounds[i];
+		}
+		else if ( clientNum >= MAX_CLIENTS && i < numCExSounds && !strcmp( lSoundName, cg_customExtraSoundNames[i] ) )
+		{ //npc only
+			return ci->extraSounds[i];
+		}
+		else if ( clientNum >= MAX_CLIENTS && i < numCJediSounds && !strcmp( lSoundName, cg_customJediSoundNames[i] ) )
+		{ //npc only
+			return ci->jediSounds[i];
+		}
+	}
+
+	//CG_Error( "Unknown custom sound: %s", lSoundName );
+#ifndef FINAL_BUILD
+	Com_Printf( "Unknown custom sound: %s", lSoundName );
+#endif
+	return 0;
+}
+
+/*
+=============================================================================
+
+CLIENT INFO
+
+=============================================================================
+*/
+#define MAX_SURF_LIST_SIZE	1024
+qboolean CG_ParseSurfsFile( const char *modelName, const char *skinName, char *surfOff, char *surfOn ) 
+{
+	const char	*text_p;
+	int			len;
+	const char	*token;
+	const char	*value;
+	char		text[20000];
+	char		sfilename[MAX_QPATH];
+	fileHandle_t	f;
+	int			i = 0;
+
+	while (skinName && skinName[i])
+	{
+		if (skinName[i] == '|')
+		{ //this is a multi-part skin, said skins do not support .surf files
+			return qfalse;
+		}
+
+		i++;
+	}
+
+
+	// Load and parse .surf file
+	Com_sprintf( sfilename, sizeof( sfilename ), "models/players/%s/model_%s.surf", modelName, skinName );
+
+	// load the file
+	len = trap_FS_FOpenFile( sfilename, &f, FS_READ );
+	if ( len <= 0 ) 
+	{//no file
+		return qfalse;
+	}
+	if ( len >= sizeof( text ) - 1 ) 
+	{
+		Com_Printf( "File %s too long\n", sfilename );
+		return qfalse;
+	}
+
+	trap_FS_Read( text, len, f );
+	text[len] = 0;
+	trap_FS_FCloseFile( f );
+
+	// parse the text
+	text_p = text;
+
+	memset( (char *)surfOff, 0, sizeof(surfOff) );
+	memset( (char *)surfOn, 0, sizeof(surfOn) );
+
+	// read information for surfOff and surfOn
+	while ( 1 ) 
+	{
+		token = COM_ParseExt( &text_p, qtrue );
+		if ( !token || !token[0] ) 
+		{
+			break;
+		}
+
+		// surfOff
+		if ( !Q_stricmp( token, "surfOff" ) ) 
+		{
+			if ( COM_ParseString( &text_p, &value ) ) 
+			{
+				continue;
+			}
+			if ( surfOff && surfOff[0] )
+			{
+				Q_strcat( surfOff, MAX_SURF_LIST_SIZE, "," );
+				Q_strcat( surfOff, MAX_SURF_LIST_SIZE, value );
+			}
+			else
+			{
+				Q_strncpyz( surfOff, value, MAX_SURF_LIST_SIZE );
+			}
+			continue;
+		}
+		
+		// surfOn
+		if ( !Q_stricmp( token, "surfOn" ) ) 
+		{
+			if ( COM_ParseString( &text_p, &value ) ) 
+			{
+				continue;
+			}
+			if ( surfOn && surfOn[0] )
+			{
+				Q_strcat( surfOn, MAX_SURF_LIST_SIZE, ",");
+				Q_strcat( surfOn, MAX_SURF_LIST_SIZE, value );
+			}
+			else
+			{
+				Q_strncpyz( surfOn, value, MAX_SURF_LIST_SIZE );
+			}
+			continue;
+		}
+	}
+	return qtrue;
+}
+
+/*
+==========================
+CG_RegisterClientModelname
+==========================
+*/
+#include "../namespace_begin.h"
+qboolean BG_IsValidCharacterModel(const char *modelName, const char *skinName);
+qboolean BG_ValidateSkinForTeam( const char *modelName, char *skinName, int team, float *colors );
+#include "../namespace_end.h"
+
+static qboolean CG_RegisterClientModelname( clientInfo_t *ci, const char *modelName, const char *skinName, const char *teamName, int clientNum ) {
+	int handle;
+	char		afilename[MAX_QPATH];
+	char		/**GLAName,*/ *slash;
+	char		GLAName[MAX_QPATH];
+	vec3_t	tempVec = {0,0,0};
+	qboolean badModel = qfalse;
+	char	surfOff[MAX_SURF_LIST_SIZE];
+	char	surfOn[MAX_SURF_LIST_SIZE];
+	int		checkSkin;
+	char	*useSkinName;
+
+retryModel:
+	if (badModel)
+	{
+		if (modelName && modelName[0])
+		{
+			Com_Printf("WARNING: Attempted to load an unsupported multiplayer model %s! (bad or missing bone, or missing animation sequence)\n", modelName);
+		}
+
+		modelName = "kyle";
+		skinName = "default";
+
+		badModel = qfalse;
+	}
+
+	// First things first.  If this is a ghoul2 model, then let's make sure we demolish this first.
+	if (ci->ghoul2Model && trap_G2_HaveWeGhoul2Models(ci->ghoul2Model))
+	{
+		trap_G2API_CleanGhoul2Models(&(ci->ghoul2Model));
+	}
+
+	if (!BG_IsValidCharacterModel(modelName, skinName))
+	{
+		modelName = "kyle";
+		skinName = "default";
+	}
+
+	if ( cgs.gametype >= GT_TEAM && !cgs.jediVmerc && cgs.gametype != GT_SIEGE )
+	{ //We won't force colors for siege.
+		BG_ValidateSkinForTeam( ci->modelName, ci->skinName, ci->team, ci->colorOverride );
+		skinName = ci->skinName;
+	}
+	else
+	{
+		ci->colorOverride[0] = ci->colorOverride[1] = ci->colorOverride[2] = 0.0f;
+	}
+
+	if (strchr(skinName, '|'))
+	{//three part skin
+		useSkinName = va("models/players/%s/|%s", modelName, skinName);
+	}
+	else
+	{
+		useSkinName = va("models/players/%s/model_%s.skin", modelName, skinName);
+	}
+
+	checkSkin = trap_R_RegisterSkin(useSkinName);
+
+	if (checkSkin)
+	{
+		ci->torsoSkin = checkSkin;
+	}
+	else
+	{ //fallback to the default skin
+		ci->torsoSkin = trap_R_RegisterSkin(va("models/players/%s/model_default.skin", modelName, skinName));
+	}
+	Com_sprintf( afilename, sizeof( afilename ), "models/players/%s/model.glm", modelName );
+	handle = trap_G2API_InitGhoul2Model(&ci->ghoul2Model, afilename, 0, ci->torsoSkin, 0, 0, 0);
+
+	if (handle<0)
+	{
+		return qfalse;
+	}
+
+	// The model is now loaded.
+
+	trap_G2API_SetSkin(ci->ghoul2Model, 0, ci->torsoSkin, ci->torsoSkin);
+
+	GLAName[0] = 0;
+
+	trap_G2API_GetGLAName( ci->ghoul2Model, 0, GLAName);
+	if (GLAName[0] != 0)
+	{
+		if (!strstr(GLAName, "players/_humanoid/") /*&&
+			(!strstr(GLAName, "players/rockettrooper/") || cgs.gametype != GT_SIEGE)*/) //only allow rockettrooper in siege
+		{ //Bad!
+			badModel = qtrue;
+			goto retryModel;
+		}
+	}
+
+	if (!BGPAFtextLoaded)
+	{
+		if (GLAName[0] == 0/*GLAName == NULL*/)
+		{
+			badModel = qtrue;
+			goto retryModel;
+		}
+		Q_strncpyz( afilename, GLAName, sizeof( afilename ));
+		slash = Q_strrchr( afilename, '/' );
+		if ( slash )
+		{
+			strcpy(slash, "/animation.cfg");
+		}	// Now afilename holds just the path to the animation.cfg
+		else 
+		{	// Didn't find any slashes, this is a raw filename right in base (whish isn't a good thing)
+			return qfalse;
+		}
+
+		//rww - All player models must use humanoid, no matter what.
+		if (Q_stricmp(afilename, "models/players/_humanoid/animation.cfg") /*&&
+			Q_stricmp(afilename, "models/players/rockettrooper/animation.cfg")*/)
+		{
+			Com_Printf( "Model does not use supported animation config.\n");
+			return qfalse;
+		}
+		else if (BG_ParseAnimationFile("models/players/_humanoid/animation.cfg", bgHumanoidAnimations, qtrue) == -1)
+		{
+			Com_Printf( "Failed to load animation file models/players/_humanoid/animation.cfg\n" );
+			return qfalse;
+		}
+
+		BG_ParseAnimationEvtFile( "models/players/_humanoid/", 0, -1 ); //get the sounds for the humanoid anims
+//		if (cgs.gametype == GT_SIEGE)
+//		{
+//			BG_ParseAnimationEvtFile( "models/players/rockettrooper/", 1, 1 ); //parse rockettrooper too
+//		}
+		//For the time being, we're going to have all real players use the generic humanoid soundset and that's it.
+		//Only npc's will use model-specific soundsets.
+
+	//	BG_ParseAnimationSndFile(va("models/players/%s/", modelName), 0, -1);
+	}
+	else if (!bgAllEvents[0].eventsParsed)
+	{ //make sure the player anim sounds are loaded even if the anims already are
+		BG_ParseAnimationEvtFile( "models/players/_humanoid/", 0, -1 );
+//		if (cgs.gametype == GT_SIEGE)
+//		{
+//			BG_ParseAnimationEvtFile( "models/players/rockettrooper/", 1, 1 );
+//		}
+	}
+
+	if ( CG_ParseSurfsFile( modelName, skinName, surfOff, surfOn ) )
+	{//turn on/off any surfs
+		const char	*token;
+		const char	*p;
+
+		//Now turn on/off any surfaces
+		if ( surfOff && surfOff[0] )
+		{
+			p = surfOff;
+			while ( 1 ) 
+			{
+				token = COM_ParseExt( &p, qtrue );
+				if ( !token[0] ) 
+				{//reached end of list
+					break;
+				}
+				//turn off this surf
+				trap_G2API_SetSurfaceOnOff( ci->ghoul2Model, token, 0x00000002/*G2SURFACEFLAG_OFF*/ );
+			}
+		}
+		if ( surfOn && surfOn[0] )
+		{
+			p = surfOn;
+			while ( 1 )
+			{
+				token = COM_ParseExt( &p, qtrue );
+				if ( !token[0] ) 
+				{//reached end of list
+					break;
+				}
+				//turn on this surf
+				trap_G2API_SetSurfaceOnOff( ci->ghoul2Model, token, 0 );
+			}
+		}
+	}
+
+
+	ci->bolt_rhand = trap_G2API_AddBolt(ci->ghoul2Model, 0, "*r_hand");
+	
+	if (!trap_G2API_SetBoneAnim(ci->ghoul2Model, 0, "model_root", 0, 12, BONE_ANIM_OVERRIDE_LOOP, 1.0f, cg.time, -1, -1))
+	{
+		badModel = qtrue;
+	}
+	
+	if (!trap_G2API_SetBoneAngles(ci->ghoul2Model, 0, "upper_lumbar", tempVec, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, NULL, 0, cg.time))
+	{
+		badModel = qtrue;
+	}
+
+	if (!trap_G2API_SetBoneAngles(ci->ghoul2Model, 0, "cranium", tempVec, BONE_ANGLES_POSTMULT, POSITIVE_Z, NEGATIVE_Y, POSITIVE_X, NULL, 0, cg.time))
+	{
+		badModel = qtrue;
+	}
+
+	ci->bolt_lhand = trap_G2API_AddBolt(ci->ghoul2Model, 0, "*l_hand");
+
+	//rhand must always be first bolt. lhand always second. Whichever you want the
+	//jetpack bolted to must always be third.
+	trap_G2API_AddBolt(ci->ghoul2Model, 0, "*chestg");
+
+	ci->bolt_head = trap_G2API_AddBolt(ci->ghoul2Model, 0, "*head_top");
+	if (ci->bolt_head == -1)
+	{
+		ci->bolt_head = trap_G2API_AddBolt(ci->ghoul2Model, 0, "ceyebrow");
+	}
+
+	ci->bolt_motion = trap_G2API_AddBolt(ci->ghoul2Model, 0, "Motion");
+
+	//We need a lower lumbar bolt for footsteps
+	ci->bolt_llumbar = trap_G2API_AddBolt(ci->ghoul2Model, 0, "lower_lumbar");
+
+	if (ci->bolt_rhand == -1 || ci->bolt_lhand == -1 || ci->bolt_head == -1 || ci->bolt_motion == -1 || ci->bolt_llumbar == -1)
+	{
+		badModel = qtrue;
+	}
+
+	if (badModel)
+	{
+		goto retryModel;
+	}
+
+	if (!Q_stricmp(modelName, "boba_fett"))
+	{ //special case, turn off the jetpack surfs
+		trap_G2API_SetSurfaceOnOff(ci->ghoul2Model, "torso_rjet", TURN_OFF);
+		trap_G2API_SetSurfaceOnOff(ci->ghoul2Model, "torso_cjet", TURN_OFF);
+		trap_G2API_SetSurfaceOnOff(ci->ghoul2Model, "torso_ljet", TURN_OFF);
+	}
+
+//	ent->s.radius = 90;
+
+	if (clientNum != -1)
+	{
+		/*
+		if (cg_entities[clientNum].ghoul2 && trap_G2_HaveWeGhoul2Models(cg_entities[clientNum].ghoul2))
+		{
+			trap_G2API_CleanGhoul2Models(&(cg_entities[clientNum].ghoul2));
+		}
+		trap_G2API_DuplicateGhoul2Instance(ci->ghoul2Model, &cg_entities[clientNum].ghoul2);	
+		*/
+
+		cg_entities[clientNum].ghoul2weapon = NULL;
+	}
+
+	Q_strncpyz (ci->teamName, teamName, sizeof(ci->teamName));
+
+	// Model icon for drawing the portrait on screen
+	ci->modelIcon = trap_R_RegisterShaderNoMip ( va ( "models/players/%s/icon_%s", modelName, skinName ) );
+	if (!ci->modelIcon)
+	{
+        int i = 0;
+		int j;
+		char iconName[1024];
+		strcpy(iconName, "icon_");
+		j = strlen(iconName);
+		while (skinName[i] && skinName[i] != '|' && j < 1024)
+		{
+            iconName[j] = skinName[i];
+			j++;
+			i++;
+		}
+		iconName[j] = 0;
+		if (skinName[i] == '|')
+		{ //looks like it actually may be a custom model skin, let's try getting the icon...
+			ci->modelIcon = trap_R_RegisterShaderNoMip ( va ( "models/players/%s/%s", modelName, iconName ) );
+		}
+	}
+	return qtrue;
+}
+
+/*
+====================
+CG_ColorFromString
+====================
+*/
+static void CG_ColorFromString( const char *v, vec3_t color ) {
+	int val;
+
+	VectorClear( color );
+
+	val = atoi( v );
+
+	if ( val < 1 || val > 7 ) {
+		VectorSet( color, 1, 1, 1 );
+		return;
+	}
+
+	if ( val & 1 ) {
+		color[2] = 1.0f;
+	}
+	if ( val & 2 ) {
+		color[1] = 1.0f;
+	}
+	if ( val & 4 ) {
+		color[0] = 1.0f;
+	}
+}
+
+/*
+====================
+CG_ColorFromInt
+====================
+*/
+static void CG_ColorFromInt( int val, vec3_t color ) {
+	VectorClear( color );
+
+	if ( val < 1 || val > 7 ) {
+		VectorSet( color, 1, 1, 1 );
+		return;
+	}
+
+	if ( val & 1 ) {
+		color[2] = 1.0f;
+	}
+	if ( val & 2 ) {
+		color[1] = 1.0f;
+	}
+	if ( val & 4 ) {
+		color[0] = 1.0f;
+	}
+}
+
+//load anim info
+int CG_G2SkelForModel(void *g2)
+{
+	int animIndex = -1;
+	char GLAName[MAX_QPATH];
+	char *slash;
+
+	GLAName[0] = 0;
+	trap_G2API_GetGLAName(g2, 0, GLAName);
+
+	slash = Q_strrchr( GLAName, '/' );
+	if ( slash )
+	{
+		strcpy(slash, "/animation.cfg");
+
+		animIndex = BG_ParseAnimationFile(GLAName, NULL, qfalse);
+	}
+
+	return animIndex;
+}
+
+//get the appropriate anim events file index
+int CG_G2EvIndexForModel(void *g2, int animIndex)
+{
+	int evtIndex = -1;
+	char GLAName[MAX_QPATH];
+	char *slash;
+
+	if (animIndex == -1)
+	{
+		assert(!"shouldn't happen, bad animIndex");
+		return -1;
+	}
+
+	GLAName[0] = 0;
+	trap_G2API_GetGLAName(g2, 0, GLAName);
+
+	slash = Q_strrchr( GLAName, '/' );
+	if ( slash )
+	{
+		slash++;
+		*slash = 0;
+
+		evtIndex = BG_ParseAnimationEvtFile(GLAName, animIndex, bgNumAnimEvents);
+	}
+
+	return evtIndex;
+}
+
+#define DEFAULT_FEMALE_SOUNDPATH "chars/mp_generic_female/misc"//"chars/tavion/misc"
+#define DEFAULT_MALE_SOUNDPATH "chars/mp_generic_male/misc"//"chars/kyle/misc"
+void CG_LoadCISounds(clientInfo_t *ci, qboolean modelloaded)
+{
+	fileHandle_t f;
+	qboolean	isFemale = qfalse;
+	int			i = 0;
+	int			fLen = 0;
+	const char	*dir;
+	char		soundpath[MAX_QPATH];
+	char		soundName[1024];
+	const char	*s;
+
+	dir = ci->modelName;
+
+	if ( !ci->skinName || !Q_stricmp( "default", ci->skinName ) )
+	{//try default sounds.cfg first
+		fLen = trap_FS_FOpenFile(va("models/players/%s/sounds.cfg", dir), &f, FS_READ);
+		if ( !f ) 
+		{//no?  Look for _default sounds.cfg
+			fLen = trap_FS_FOpenFile(va("models/players/%s/sounds_default.cfg", dir), &f, FS_READ);
+		}
+	}
+	else
+	{//use the .skin associated with this skin
+		fLen = trap_FS_FOpenFile(va("models/players/%s/sounds_%s.cfg", dir, ci->skinName), &f, FS_READ);
+		if ( !f ) 
+		{//fall back to default sounds
+			fLen = trap_FS_FOpenFile(va("models/players/%s/sounds.cfg", dir), &f, FS_READ);
+		}
+	}
+
+	soundpath[0] = 0;
+
+	if (f)
+	{
+		trap_FS_Read(soundpath, fLen, f);
+		soundpath[fLen] = 0;
+
+		i = fLen;
+
+		while (i >= 0 && soundpath[i] != '\n')
+		{
+			if (soundpath[i] == 'f')
+			{
+				isFemale = qtrue;
+				soundpath[i] = 0;
+			}
+
+			i--;
+		}
+
+		i = 0;
+
+		while (soundpath[i] && soundpath[i] != '\r' && soundpath[i] != '\n')
+		{
+			i++;
+		}
+		soundpath[i] = 0;
+
+		trap_FS_FCloseFile(f);
+	}
+
+	if (isFemale)
+	{
+		ci->gender = GENDER_FEMALE;
+	}
+	else
+	{
+		ci->gender = GENDER_MALE;
+	}
+
+	trap_S_ShutUp(qtrue);
+
+	for ( i = 0 ; i < MAX_CUSTOM_SOUNDS ; i++ )
+	{
+		s = cg_customSoundNames[i];
+		if ( !s ) {
+			break;
+		}
+
+		Com_sprintf(soundName, sizeof(soundName), "%s", s+1);
+		COM_StripExtension(soundName, soundName);
+		//strip the extension because we might want .mp3's
+
+		ci->sounds[i] = 0;
+		// if the model didn't load use the sounds of the default model
+		if (soundpath[0])
+		{
+			ci->sounds[i] = trap_S_RegisterSound( va("sound/chars/%s/misc/%s", soundpath, soundName) );
+		}
+		else
+		{
+			if (modelloaded)
+			{
+				ci->sounds[i] = trap_S_RegisterSound( va("sound/chars/%s/misc/%s", dir, soundName) );
+			}
+		}
+
+		if (!ci->sounds[i])
+		{ //failed the load, try one out of the generic path
+			if (isFemale)
+			{
+				ci->sounds[i] = trap_S_RegisterSound( va("sound/%s/%s", DEFAULT_FEMALE_SOUNDPATH, soundName) );
+			}
+			else
+			{
+				ci->sounds[i] = trap_S_RegisterSound( va("sound/%s/%s", DEFAULT_MALE_SOUNDPATH, soundName) );
+			}
+		}
+	}
+
+	if (cgs.gametype >= GT_TEAM || cg_buildScript.integer)
+	{ //load the siege sounds then
+		for ( i = 0 ; i < MAX_CUSTOM_SIEGE_SOUNDS; i++ )
+		{
+			s = bg_customSiegeSoundNames[i];
+			if ( !s )
+			{
+				break;
+			}
+
+			Com_sprintf(soundName, sizeof(soundName), "%s", s+1);
+			COM_StripExtension(soundName, soundName);
+			//strip the extension because we might want .mp3's
+
+			ci->siegeSounds[i] = 0;
+			// if the model didn't load use the sounds of the default model
+			if (soundpath[0])
+			{
+				ci->siegeSounds[i] = trap_S_RegisterSound( va("sound/%s/%s", soundpath, soundName) );
+			}
+			else
+			{
+				if (modelloaded)
+				{
+					ci->siegeSounds[i] = trap_S_RegisterSound( va("sound/chars/%s/misc/%s", dir, soundName) );
+				}
+			}
+
+			if (!ci->siegeSounds[i])
+			{ //failed the load, try one out of the generic path
+				if (isFemale)
+				{
+					ci->siegeSounds[i] = trap_S_RegisterSound( va("sound/%s/%s", DEFAULT_FEMALE_SOUNDPATH, soundName) );
+				}
+				else
+				{
+					ci->siegeSounds[i] = trap_S_RegisterSound( va("sound/%s/%s", DEFAULT_MALE_SOUNDPATH, soundName) );
+				}
+			}
+		}
+	}
+
+	if (cgs.gametype == GT_DUEL
+		||cgs.gametype == GT_POWERDUEL
+		|| cg_buildScript.integer)
+	{ //load the Duel sounds then
+		for ( i = 0 ; i < MAX_CUSTOM_DUEL_SOUNDS; i++ )
+		{
+			s = cg_customDuelSoundNames[i];
+			if ( !s )
+			{
+				break;
+			}
+
+			Com_sprintf(soundName, sizeof(soundName), "%s", s+1);
+			COM_StripExtension(soundName, soundName);
+			//strip the extension because we might want .mp3's
+
+			ci->duelSounds[i] = 0;
+			// if the model didn't load use the sounds of the default model
+			if (soundpath[0])
+			{
+				ci->duelSounds[i] = trap_S_RegisterSound( va("sound/chars/%s/misc/%s", soundpath, soundName) );
+			}
+			else
+			{
+				if (modelloaded)
+				{
+					ci->duelSounds[i] = trap_S_RegisterSound( va("sound/chars/%s/misc/%s", dir, soundName) );
+				}
+			}
+
+			if (!ci->duelSounds[i])
+			{ //failed the load, try one out of the generic path
+				if (isFemale)
+				{
+					ci->duelSounds[i] = trap_S_RegisterSound( va("sound/%s/%s", DEFAULT_FEMALE_SOUNDPATH, soundName) );
+				}
+				else
+				{
+					ci->duelSounds[i] = trap_S_RegisterSound( va("sound/%s/%s", DEFAULT_MALE_SOUNDPATH, soundName) );
+				}
+			}
+		}
+	}
+
+	trap_S_ShutUp(qfalse);
+}
+
+/*
+===================
+CG_LoadClientInfo
+
+Load it now, taking the disk hits.
+This will usually be deferred to a safe time
+===================
+*/
+void CG_LoadClientInfo( clientInfo_t *ci ) {
+	qboolean	modelloaded;
+	int			clientNum;
+	int			i;
+	char		teamname[MAX_QPATH];
+
+	clientNum = ci - cgs.clientinfo;
+
+	if (clientNum < 0 || clientNum >= MAX_CLIENTS)
+	{
+		clientNum = -1;
+	}
+
+	ci->deferred = qfalse;
+
+	/*
+	if (ci->team == TEAM_SPECTATOR)
+	{
+		// reset any existing players and bodies, because they might be in bad
+		// frames for this new model
+		clientNum = ci - cgs.clientinfo;
+		for ( i = 0 ; i < MAX_GENTITIES ; i++ ) {
+			if ( cg_entities[i].currentState.clientNum == clientNum
+				&& cg_entities[i].currentState.eType == ET_PLAYER ) {
+				CG_ResetPlayerEntity( &cg_entities[i] );
+			}
+		}
+
+		if (ci->ghoul2Model && trap_G2_HaveWeGhoul2Models(ci->ghoul2Model))
+		{
+			trap_G2API_CleanGhoul2Models(&ci->ghoul2Model);
+		}
+
+		return;
+	}
+	*/
+
+	teamname[0] = 0;
+	if( cgs.gametype >= GT_TEAM) {
+		if( ci->team == TEAM_BLUE ) {
+			Q_strncpyz(teamname, cg_blueTeamName.string, sizeof(teamname) );
+		} else {
+			Q_strncpyz(teamname, cg_redTeamName.string, sizeof(teamname) );
+		}
+	}
+	if( teamname[0] ) {
+		strcat( teamname, "/" );
+	}
+	modelloaded = qtrue;
+	if (cgs.gametype == GT_SIEGE &&
+		(ci->team == TEAM_SPECTATOR || ci->siegeIndex == -1))
+	{ //yeah.. kind of a hack I guess. Don't care until they are actually ingame with a valid class.
+		if ( !CG_RegisterClientModelname( ci, DEFAULT_MODEL, "default", teamname, -1 ) )
+		{
+			CG_Error( "DEFAULT_MODEL (%s) failed to register", DEFAULT_MODEL );
+		}
+	}
+	else
+	{
+		if ( !CG_RegisterClientModelname( ci, ci->modelName, ci->skinName, teamname, clientNum ) ) {
+			//CG_Error( "CG_RegisterClientModelname( %s, %s, %s, %s %s ) failed", ci->modelName, ci->skinName, ci->headModelName, ci->headSkinName, teamname );
+			//rww - DO NOT error out here! Someone could just type in a nonsense model name and crash everyone's client.
+			//Give it a chance to load default model for this client instead.
+
+			// fall back to default team name
+			if( cgs.gametype >= GT_TEAM) {
+				// keep skin name
+				if( ci->team == TEAM_BLUE ) {
+					Q_strncpyz(teamname, DEFAULT_BLUETEAM_NAME, sizeof(teamname) );
+				} else {
+					Q_strncpyz(teamname, DEFAULT_REDTEAM_NAME, sizeof(teamname) );
+				}
+				if ( !CG_RegisterClientModelname( ci, DEFAULT_MODEL, ci->skinName, teamname, -1 ) ) {
+					CG_Error( "DEFAULT_MODEL / skin (%s/%s) failed to register", DEFAULT_MODEL, ci->skinName );
+				}
+			} else {
+				if ( !CG_RegisterClientModelname( ci, DEFAULT_MODEL, "default", teamname, -1 ) ) {
+					CG_Error( "DEFAULT_MODEL (%s) failed to register", DEFAULT_MODEL );
+				}
+			}
+			modelloaded = qfalse;
+		}
+	}
+
+	if (clientNum != -1)
+	{
+		trap_G2API_ClearAttachedInstance(clientNum);
+	}
+
+	if (clientNum != -1 && ci->ghoul2Model && trap_G2_HaveWeGhoul2Models(ci->ghoul2Model))
+	{
+		if (cg_entities[clientNum].ghoul2 && trap_G2_HaveWeGhoul2Models(cg_entities[clientNum].ghoul2))
+		{
+			trap_G2API_CleanGhoul2Models(&cg_entities[clientNum].ghoul2);
+		}
+		trap_G2API_DuplicateGhoul2Instance(ci->ghoul2Model, &cg_entities[clientNum].ghoul2);
+
+		//Attach the instance to this entity num so we can make use of client-server
+		//shared operations if possible.
+		trap_G2API_AttachInstanceToEntNum(cg_entities[clientNum].ghoul2, clientNum, qfalse);
+
+
+		if (trap_G2API_AddBolt(cg_entities[clientNum].ghoul2, 0, "face") == -1)
+		{ //check now to see if we have this bone for setting anims and such
+			cg_entities[clientNum].noFace = qtrue;
+		}
+
+		cg_entities[clientNum].localAnimIndex = CG_G2SkelForModel(cg_entities[clientNum].ghoul2);
+		cg_entities[clientNum].eventAnimIndex = CG_G2EvIndexForModel(cg_entities[clientNum].ghoul2, cg_entities[clientNum].localAnimIndex);
+	}
+
+	ci->newAnims = qfalse;
+	if ( ci->torsoModel ) {
+		orientation_t tag;
+		// if the torso model has the "tag_flag"
+		if ( trap_R_LerpTag( &tag, ci->torsoModel, 0, 0, 1, "tag_flag" ) ) {
+			ci->newAnims = qtrue;
+		}
+	}
+
+	// sounds
+	if (cgs.gametype == GT_SIEGE &&
+		(ci->team == TEAM_SPECTATOR || ci->siegeIndex == -1))
+	{ //don't need to load sounds
+	}
+	else
+	{
+		CG_LoadCISounds(ci, modelloaded);
+	}
+
+	ci->deferred = qfalse;
+
+	// reset any existing players and bodies, because they might be in bad
+	// frames for this new model
+	clientNum = ci - cgs.clientinfo;
+	for ( i = 0 ; i < MAX_GENTITIES ; i++ ) {
+		if ( cg_entities[i].currentState.clientNum == clientNum
+			&& cg_entities[i].currentState.eType == ET_PLAYER ) {
+			CG_ResetPlayerEntity( &cg_entities[i] );
+		}
+	}
+}
+
+
+//Take care of initializing all the ghoul2 saber stuff based on clientinfo data. -rww
+static void CG_InitG2SaberData(int saberNum, clientInfo_t *ci)
+{
+	trap_G2API_InitGhoul2Model(&ci->ghoul2Weapons[saberNum], ci->saber[saberNum].model, 0, ci->saber[saberNum].skin, 0, 0, 0);
+
+	if (ci->ghoul2Weapons[saberNum])
+	{
+		int k = 0;
+		int tagBolt;
+		char *tagName;
+
+		if (ci->saber[saberNum].skin)
+		{
+			trap_G2API_SetSkin(ci->ghoul2Weapons[saberNum], 0, ci->saber[saberNum].skin, ci->saber[saberNum].skin);
+		}
+
+		trap_G2API_SetBoltInfo(ci->ghoul2Weapons[saberNum], 0, saberNum);
+
+		while (k < ci->saber[saberNum].numBlades)
+		{
+			tagName = va("*blade%i", k+1);
+			tagBolt = trap_G2API_AddBolt(ci->ghoul2Weapons[saberNum], 0, tagName);
+
+			if (tagBolt == -1)
+			{
+				if (k == 0)
+				{ //guess this is an 0ldsk3wl saber
+					tagBolt = trap_G2API_AddBolt(ci->ghoul2Weapons[saberNum], 0, "*flash");
+
+					if (tagBolt == -1)
+					{
+						assert(0);
+					}
+					break;
+				}
+
+				if (tagBolt == -1)
+				{
+					assert(0);
+					break;
+				}
+			}
+
+			k++;
+		}
+	}
+}
+
+
+/*
+======================
+CG_CopyClientInfoModel
+======================
+*/
+static void CG_CopyClientInfoModel( clientInfo_t *from, clientInfo_t *to )
+{
+	VectorCopy( from->headOffset, to->headOffset );
+//	to->footsteps = from->footsteps;
+	to->gender = from->gender;
+
+	to->legsModel = from->legsModel;
+	to->legsSkin = from->legsSkin;
+	to->torsoModel = from->torsoModel;
+	to->torsoSkin = from->torsoSkin;
+	//to->headModel = from->headModel;
+	//to->headSkin = from->headSkin;
+	to->modelIcon = from->modelIcon;
+
+	to->newAnims = from->newAnims;
+
+	//to->ghoul2Model = from->ghoul2Model;
+	//rww - Trying to use the same ghoul2 pointer for two seperate clients == DISASTER
+	assert(to->ghoul2Model != from->ghoul2Model);
+
+	if (to->ghoul2Model && trap_G2_HaveWeGhoul2Models(to->ghoul2Model))
+	{
+		trap_G2API_CleanGhoul2Models(&to->ghoul2Model);
+	}
+	if (from->ghoul2Model && trap_G2_HaveWeGhoul2Models(from->ghoul2Model))
+	{
+		trap_G2API_DuplicateGhoul2Instance(from->ghoul2Model, &to->ghoul2Model);
+	}
+
+	//Don't do this, I guess. Just leave the saber info in the original, so it will be
+	//properly initialized.
+	/*
+	strcpy(to->saberName, from->saberName);
+	strcpy(to->saber2Name, from->saber2Name);
+
+	while (i < MAX_SABERS)
+	{
+		if (to->ghoul2Weapons[i] && trap_G2_HaveWeGhoul2Models(to->ghoul2Weapons[i]))
+		{
+			trap_G2API_CleanGhoul2Models(&to->ghoul2Weapons[i]);
+		}
+
+		WP_SetSaber(to->saber, 0, to->saberName);
+		WP_SetSaber(to->saber, 1, to->saber2Name);
+
+		j = 0;
+
+		while (j < MAX_SABERS)
+		{
+			if (to->saber[j].model[0])
+			{
+				CG_InitG2SaberData(j, to);
+			}
+			j++;
+		}
+		i++;
+	}
+	*/
+
+	to->bolt_head = from->bolt_head;
+	to->bolt_lhand = from->bolt_lhand;
+	to->bolt_rhand = from->bolt_rhand;
+	to->bolt_motion = from->bolt_motion;
+	to->bolt_llumbar = from->bolt_llumbar;
+
+	to->siegeIndex = from->siegeIndex;
+
+	memcpy( to->sounds, from->sounds, sizeof( to->sounds ) );
+	memcpy( to->siegeSounds, from->siegeSounds, sizeof( to->siegeSounds ) );
+	memcpy( to->duelSounds, from->duelSounds, sizeof( to->duelSounds ) );
+}
+
+/*
+======================
+CG_ScanForExistingClientInfo
+======================
+*/
+static qboolean CG_ScanForExistingClientInfo( clientInfo_t *ci, int clientNum ) {
+	int		i;
+	clientInfo_t	*match;
+
+	for ( i = 0 ; i < cgs.maxclients ; i++ ) {
+		match = &cgs.clientinfo[ i ];
+		if ( !match->infoValid ) {
+			continue;
+		}
+		if ( match->deferred ) {
+			continue;
+		}
+		if ( !Q_stricmp( ci->modelName, match->modelName )
+			&& !Q_stricmp( ci->skinName, match->skinName )
+			&& !Q_stricmp( ci->saberName, match->saberName)
+			&& !Q_stricmp( ci->saber2Name, match->saber2Name)
+//			&& !Q_stricmp( ci->headModelName, match->headModelName )
+//			&& !Q_stricmp( ci->headSkinName, match->headSkinName ) 
+			&& !Q_stricmp( ci->blueTeam, match->blueTeam ) 
+			&& !Q_stricmp( ci->redTeam, match->redTeam )
+			&& (cgs.gametype < GT_TEAM || ci->team == match->team) 
+			&& ci->siegeIndex == match->siegeIndex
+			&& match->ghoul2Model
+			&& match->bolt_head) //if the bolts haven't been initialized, this "match" is useless to us
+		{
+			// this clientinfo is identical, so use it's handles
+
+			ci->deferred = qfalse;
+
+			//rww - Filthy hack. If this is actually the info already belonging to us, just reassign the pointer.
+			//Switching instances when not necessary produces small animation glitches.
+			//Actually, before, were we even freeing the instance attached to the old clientinfo before copying
+			//this new clientinfo over it? Could be a nasty leak possibility. (though this should remedy it in theory)
+			if (clientNum == i)
+			{
+				if (match->ghoul2Model && trap_G2_HaveWeGhoul2Models(match->ghoul2Model))
+				{ //The match has a valid instance (if it didn't, we'd probably already be fudged (^_^) at this state)
+					if (ci->ghoul2Model && trap_G2_HaveWeGhoul2Models(ci->ghoul2Model))
+					{ //First kill the copy we have if we have one. (but it should be null)
+						trap_G2API_CleanGhoul2Models(&ci->ghoul2Model);
+					}
+
+					VectorCopy( match->headOffset, ci->headOffset );
+//					ci->footsteps = match->footsteps;
+					ci->gender = match->gender;
+
+					ci->legsModel = match->legsModel;
+					ci->legsSkin = match->legsSkin;
+					ci->torsoModel = match->torsoModel;
+					ci->torsoSkin = match->torsoSkin;
+					ci->modelIcon = match->modelIcon;
+
+					ci->newAnims = match->newAnims;
+
+					ci->bolt_head = match->bolt_head;
+					ci->bolt_lhand = match->bolt_lhand;
+					ci->bolt_rhand = match->bolt_rhand;
+					ci->bolt_motion = match->bolt_motion;
+					ci->bolt_llumbar = match->bolt_llumbar;
+					ci->siegeIndex = match->siegeIndex;
+
+					memcpy( ci->sounds, match->sounds, sizeof( ci->sounds ) );
+					memcpy( ci->siegeSounds, match->siegeSounds, sizeof( ci->siegeSounds ) );
+					memcpy( ci->duelSounds, match->duelSounds, sizeof( ci->duelSounds ) );
+
+					//We can share this pointer, because it already belongs to this client.
+					//The pointer itself and the ghoul2 instance is never actually changed, just passed between
+					//clientinfo structures.
+					ci->ghoul2Model = match->ghoul2Model;
+
+					//Don't need to do this I guess, whenever this function is called the saber stuff should
+					//already be taken care of in the new info.
+					/*
+					while (k < MAX_SABERS)
+					{
+						if (match->ghoul2Weapons[k] && match->ghoul2Weapons[k] != ci->ghoul2Weapons[k])
+						{
+							if (ci->ghoul2Weapons[k])
+							{
+								trap_G2API_CleanGhoul2Models(&ci->ghoul2Weapons[k]);
+							}
+                            ci->ghoul2Weapons[k] = match->ghoul2Weapons[k];
+						}
+						k++;
+					}
+					*/
+				}
+			}
+			else
+			{
+				CG_CopyClientInfoModel( match, ci );
+			}
+
+			return qtrue;
+		}
+	}
+
+	// nothing matches, so defer the load
+	return qfalse;
+}
+
+/*
+======================
+CG_SetDeferredClientInfo
+
+We aren't going to load it now, so grab some other
+client's info to use until we have some spare time.
+======================
+*/
+static void CG_SetDeferredClientInfo( clientInfo_t *ci ) {
+	int		i;
+	clientInfo_t	*match;
+
+	// if someone else is already the same models and skins we
+	// can just load the client info
+	for ( i = 0 ; i < cgs.maxclients ; i++ ) {
+		match = &cgs.clientinfo[ i ];
+		if ( !match->infoValid || match->deferred ) {
+			continue;
+		}
+		if ( Q_stricmp( ci->skinName, match->skinName ) ||
+			 Q_stricmp( ci->modelName, match->modelName ) ||
+//			 Q_stricmp( ci->headModelName, match->headModelName ) ||
+//			 Q_stricmp( ci->headSkinName, match->headSkinName ) ||
+			 (cgs.gametype >= GT_TEAM && ci->team != match->team && ci->team != TEAM_SPECTATOR) ) {
+			continue;
+		}
+
+		 /*
+		if (Q_stricmp(ci->saberName, match->saberName) ||
+			Q_stricmp(ci->saber2Name, match->saber2Name))
+		{
+			continue;
+		}
+		*/
+
+		// just load the real info cause it uses the same models and skins
+		CG_LoadClientInfo( ci );
+		return;
+	}
+
+	// if we are in teamplay, only grab a model if the skin is correct
+	if ( cgs.gametype >= GT_TEAM ) {
+		for ( i = 0 ; i < cgs.maxclients ; i++ ) {
+			match = &cgs.clientinfo[ i ];
+			if ( !match->infoValid || match->deferred ) {
+				continue;
+			}
+			if ( ci->team != TEAM_SPECTATOR &&
+				(Q_stricmp( ci->skinName, match->skinName ) ||
+				 (cgs.gametype >= GT_TEAM && ci->team != match->team)) ) {
+				continue;
+			}
+
+			/*
+			if (Q_stricmp(ci->saberName, match->saberName) ||
+				Q_stricmp(ci->saber2Name, match->saber2Name))
+			{
+				continue;
+			}
+			*/
+
+			ci->deferred = qtrue;
+			CG_CopyClientInfoModel( match, ci );
+			return;
+		}
+		// load the full model, because we don't ever want to show
+		// an improper team skin.  This will cause a hitch for the first
+		// player, when the second enters.  Combat shouldn't be going on
+		// yet, so it shouldn't matter
+		CG_LoadClientInfo( ci );
+		return;
+	}
+
+	// find the first valid clientinfo and grab its stuff
+	for ( i = 0 ; i < cgs.maxclients ; i++ ) {
+		match = &cgs.clientinfo[ i ];
+		if ( !match->infoValid ) {
+			continue;
+		}
+
+		/*
+		if (Q_stricmp(ci->saberName, match->saberName) ||
+			Q_stricmp(ci->saber2Name, match->saber2Name))
+		{
+			continue;
+		}
+		*/
+
+		if (match->deferred)
+		{ //no deferring off of deferred info. Because I said so.
+			continue;
+		}
+
+		ci->deferred = qtrue;
+		CG_CopyClientInfoModel( match, ci );
+		return;
+	}
+
+	// we should never get here...
+	//CG_Printf( "CG_SetDeferredClientInfo: no valid clients!\n" );
+	//Actually it is possible now because of the unique sabers.
+
+	CG_LoadClientInfo( ci );
+}
+
+/*
+======================
+CG_NewClientInfo
+======================
+*/
+#include "../namespace_begin.h"
+void WP_SetSaber( int entNum, saberInfo_t *sabers, int saberNum, const char *saberName );
+#include "../namespace_end.h"
+
+void CG_NewClientInfo( int clientNum, qboolean entitiesInitialized ) {
+	clientInfo_t *ci;
+	clientInfo_t newInfo;
+	const char	*configstring;
+	const char	*v;
+	char		*slash;
+	void *oldGhoul2;
+	void *oldG2Weapons[MAX_SABERS];
+	int i = 0;
+	int k = 0;
+	qboolean saberUpdate[MAX_SABERS];
+
+	ci = &cgs.clientinfo[clientNum];
+
+	oldGhoul2 = ci->ghoul2Model;
+
+	while (k < MAX_SABERS)
+	{
+		oldG2Weapons[k] = ci->ghoul2Weapons[k];
+		k++;
+	}
+
+	configstring = CG_ConfigString( clientNum + CS_PLAYERS );
+	if ( !configstring[0] ) {
+		if (ci->ghoul2Model && trap_G2_HaveWeGhoul2Models(ci->ghoul2Model))
+		{ //clean this stuff up first
+			trap_G2API_CleanGhoul2Models(&ci->ghoul2Model);
+		}
+		k = 0;
+		while (k < MAX_SABERS)
+		{
+			if (ci->ghoul2Weapons[k] && trap_G2_HaveWeGhoul2Models(ci->ghoul2Weapons[k]))
+			{
+				trap_G2API_CleanGhoul2Models(&ci->ghoul2Weapons[k]);
+			}
+			k++;
+		}
+
+		memset( ci, 0, sizeof( *ci ) );
+		return;		// player just left
+	}
+
+	// build into a temp buffer so the defer checks can use
+	// the old value
+	memset( &newInfo, 0, sizeof( newInfo ) );
+
+	// isolate the player's name
+	v = Info_ValueForKey(configstring, "n");
+	Q_strncpyz( newInfo.name, v, sizeof( newInfo.name ) );
+
+	// colors
+	v = Info_ValueForKey( configstring, "c1" );
+	CG_ColorFromString( v, newInfo.color1 );
+
+	newInfo.icolor1 = atoi(v);
+
+	v = Info_ValueForKey( configstring, "c2" );
+	CG_ColorFromString( v, newInfo.color2 );
+
+	newInfo.icolor2 = atoi(v);
+
+	// bot skill
+	v = Info_ValueForKey( configstring, "skill" );
+	newInfo.botSkill = atoi( v );
+
+	// handicap
+	v = Info_ValueForKey( configstring, "hc" );
+	newInfo.handicap = atoi( v );
+
+	// wins
+	v = Info_ValueForKey( configstring, "w" );
+	newInfo.wins = atoi( v );
+
+	// losses
+	v = Info_ValueForKey( configstring, "l" );
+	newInfo.losses = atoi( v );
+
+	// team
+	v = Info_ValueForKey( configstring, "t" );
+	newInfo.team = atoi( v );
+
+//copy team info out to menu
+	if ( clientNum == cg.clientNum)	//this is me
+	{
+		trap_Cvar_Set("ui_team", v);
+	}
+
+	// team task
+	v = Info_ValueForKey( configstring, "tt" );
+	newInfo.teamTask = atoi(v);
+
+	// team leader
+	v = Info_ValueForKey( configstring, "tl" );
+	newInfo.teamLeader = atoi(v);
+
+	v = Info_ValueForKey( configstring, "g_redteam" );
+	Q_strncpyz(newInfo.redTeam, v, MAX_TEAMNAME);
+
+	v = Info_ValueForKey( configstring, "g_blueteam" );
+	Q_strncpyz(newInfo.blueTeam, v, MAX_TEAMNAME);
+
+	// model
+	v = Info_ValueForKey( configstring, "model" );
+	if ( cg_forceModel.integer ) {
+		// forcemodel makes everyone use a single model
+		// to prevent load hitches
+		char modelStr[MAX_QPATH];
+		char *skin;
+
+		trap_Cvar_VariableStringBuffer( "model", modelStr, sizeof( modelStr ) );
+		if ( ( skin = strchr( modelStr, '/' ) ) == NULL) {
+			skin = "default";
+		} else {
+			*skin++ = 0;
+		}
+		Q_strncpyz( newInfo.skinName, skin, sizeof( newInfo.skinName ) );
+		Q_strncpyz( newInfo.modelName, modelStr, sizeof( newInfo.modelName ) );
+
+		if ( cgs.gametype >= GT_TEAM ) {
+			// keep skin name
+			slash = strchr( v, '/' );
+			if ( slash ) {
+				Q_strncpyz( newInfo.skinName, slash + 1, sizeof( newInfo.skinName ) );
+			}
+		}
+	} else {
+		Q_strncpyz( newInfo.modelName, v, sizeof( newInfo.modelName ) );
+
+		slash = strchr( newInfo.modelName, '/' );
+		if ( !slash ) {
+			// modelName didn not include a skin name
+			Q_strncpyz( newInfo.skinName, "default", sizeof( newInfo.skinName ) );
+		} else {
+			Q_strncpyz( newInfo.skinName, slash + 1, sizeof( newInfo.skinName ) );
+			// truncate modelName
+			*slash = 0;
+		}
+	}
+
+	if (cgs.gametype == GT_SIEGE)
+	{ //entries only sent in siege mode
+		//siege desired team
+		v = Info_ValueForKey( configstring, "sdt" );
+		if (v && v[0])
+		{
+            newInfo.siegeDesiredTeam = atoi(v);
+		}
+		else
+		{
+			newInfo.siegeDesiredTeam = 0;
+		}
+
+		//siege classname
+		v = Info_ValueForKey( configstring, "siegeclass" );
+		newInfo.siegeIndex = -1;
+
+		if (v)
+		{
+			siegeClass_t *siegeClass = BG_SiegeFindClassByName(v);
+
+			if (siegeClass)
+			{ //See if this class forces a model, if so, then use it. Same for skin.
+				newInfo.siegeIndex = BG_SiegeFindClassIndexByName(v);
+
+				if (siegeClass->forcedModel[0])
+				{
+					Q_strncpyz( newInfo.modelName, siegeClass->forcedModel, sizeof( newInfo.modelName ) );
+				}
+
+				if (siegeClass->forcedSkin[0])
+				{
+					Q_strncpyz( newInfo.skinName, siegeClass->forcedSkin, sizeof( newInfo.skinName ) );
+				}
+
+				if (siegeClass->hasForcedSaberColor)
+				{
+					newInfo.icolor1 = siegeClass->forcedSaberColor;
+
+					CG_ColorFromInt( newInfo.icolor1, newInfo.color1 );
+				}
+				if (siegeClass->hasForcedSaber2Color)
+				{
+					newInfo.icolor2 = siegeClass->forcedSaber2Color;
+
+					CG_ColorFromInt( newInfo.icolor2, newInfo.color2 );
+				}
+			}
+		}
+	}
+
+	saberUpdate[0] = qfalse;
+	saberUpdate[1] = qfalse;
+
+	//saber being used
+	v = Info_ValueForKey( configstring, "st" );
+
+	if (v && Q_stricmp(v, ci->saberName))
+	{
+		Q_strncpyz( newInfo.saberName, v, 64 );
+		WP_SetSaber(clientNum, newInfo.saber, 0, newInfo.saberName);
+		saberUpdate[0] = qtrue;
+	}
+	else
+	{
+		Q_strncpyz( newInfo.saberName, ci->saberName, 64 );
+		memcpy(&newInfo.saber[0], &ci->saber[0], sizeof(newInfo.saber[0]));
+		newInfo.ghoul2Weapons[0] = ci->ghoul2Weapons[0];
+	}
+
+	v = Info_ValueForKey( configstring, "st2" );
+
+	if (v && Q_stricmp(v, ci->saber2Name))
+	{
+		Q_strncpyz( newInfo.saber2Name, v, 64 );
+		WP_SetSaber(clientNum, newInfo.saber, 1, newInfo.saber2Name);
+		saberUpdate[1] = qtrue;
+	}
+	else
+	{
+		Q_strncpyz( newInfo.saber2Name, ci->saber2Name, 64 );
+		memcpy(&newInfo.saber[1], &ci->saber[1], sizeof(newInfo.saber[1]));
+		newInfo.ghoul2Weapons[1] = ci->ghoul2Weapons[1];
+	}
+
+	if (saberUpdate[0] || saberUpdate[1])
+	{
+		int j = 0;
+
+		while (j < MAX_SABERS)
+		{
+			if (saberUpdate[j])
+			{
+				if (newInfo.saber[j].model[0])
+				{
+					if (oldG2Weapons[j])
+					{ //free the old instance(s)
+						trap_G2API_CleanGhoul2Models(&oldG2Weapons[j]);
+						oldG2Weapons[j] = 0;
+					}
+
+					CG_InitG2SaberData(j, &newInfo);
+				}
+				else
+				{
+					if (oldG2Weapons[j])
+					{ //free the old instance(s)
+						trap_G2API_CleanGhoul2Models(&oldG2Weapons[j]);
+						oldG2Weapons[j] = 0;
+					}
+				}
+
+				cg_entities[clientNum].weapon = 0;
+				cg_entities[clientNum].ghoul2weapon = NULL; //force a refresh
+			}
+			j++;
+		}
+	}
+
+	//Check for any sabers that didn't get set again, if they didn't, then reassign the pointers for the new ci
+	k = 0;
+	while (k < MAX_SABERS)
+	{
+		if (oldG2Weapons[k])
+		{
+			newInfo.ghoul2Weapons[k] = oldG2Weapons[k];
+		}
+		k++;
+	}
+
+	//duel team
+	v = Info_ValueForKey( configstring, "dt" );
+
+	if (v)
+	{
+		newInfo.duelTeam = atoi(v);
+	}
+	else
+	{
+		newInfo.duelTeam = 0;
+	}
+
+	// force powers
+	v = Info_ValueForKey( configstring, "forcepowers" );
+	Q_strncpyz( newInfo.forcePowers, v, sizeof( newInfo.forcePowers ) );
+
+	if (cgs.gametype >= GT_TEAM	&& !cgs.jediVmerc && cgs.gametype != GT_SIEGE )
+	{ //We won't force colors for siege.
+		BG_ValidateSkinForTeam( newInfo.modelName, newInfo.skinName, newInfo.team, newInfo.colorOverride );
+	}
+	else
+	{
+		newInfo.colorOverride[0] = newInfo.colorOverride[1] = newInfo.colorOverride[2] = 0.0f;
+	}
+
+	// scan for an existing clientinfo that matches this modelname
+	// so we can avoid loading checks if possible
+	if ( !CG_ScanForExistingClientInfo( &newInfo, clientNum ) ) {
+		// if we are defering loads, just have it pick the first valid
+		if (cg.snap && cg.snap->ps.clientNum == clientNum)
+		{ //rww - don't defer your own client info ever
+			CG_LoadClientInfo( &newInfo );
+		}
+		else if (  cg_deferPlayers.integer && cgs.gametype != GT_SIEGE && !cg_buildScript.integer && !cg.loading ) {
+			// keep whatever they had if it won't violate team skins
+			CG_SetDeferredClientInfo( &newInfo );
+		} else {
+			CG_LoadClientInfo( &newInfo );
+		}
+	}
+
+	// replace whatever was there with the new one
+	newInfo.infoValid = qtrue;
+	if (ci->ghoul2Model &&
+		ci->ghoul2Model != newInfo.ghoul2Model &&
+		trap_G2_HaveWeGhoul2Models(ci->ghoul2Model))
+	{ //We must kill this instance before we remove our only pointer to it from the cgame.
+	  //Otherwise we will end up with extra instances all over the place, I think.
+		trap_G2API_CleanGhoul2Models(&ci->ghoul2Model);
+	}
+	*ci = newInfo;
+
+	//force a weapon change anyway, for all clients being rendered to the current client
+	while (i < MAX_CLIENTS)
+	{
+		cg_entities[i].ghoul2weapon = NULL;
+		i++;
+	}
+
+	if (clientNum != -1)
+	{ //don't want it using an invalid pointer to share
+		trap_G2API_ClearAttachedInstance(clientNum);
+	}
+
+	// Check if the ghoul2 model changed in any way.  This is safer than assuming we have a legal cent shile loading info.
+	if (entitiesInitialized && ci->ghoul2Model && (oldGhoul2 != ci->ghoul2Model))
+	{	// Copy the new ghoul2 model to the centity.
+		animation_t *anim;
+		centity_t *cent = &cg_entities[clientNum];
+		
+		anim = &bgHumanoidAnimations[ (cg_entities[clientNum].currentState.legsAnim) ];
+
+		if (anim)
+		{
+			int flags = BONE_ANIM_OVERRIDE_FREEZE;
+			int firstFrame = anim->firstFrame;
+			int setFrame = -1;
+			float animSpeed = 50.0f / anim->frameLerp;
+
+			if (anim->loopFrames != -1)
+			{
+				flags = BONE_ANIM_OVERRIDE_LOOP;
+			}
+
+			if (cent->pe.legs.frame >= anim->firstFrame && cent->pe.legs.frame <= (anim->firstFrame + anim->numFrames))
+			{
+				setFrame = cent->pe.legs.frame;
+			}
+
+			//rww - Set the animation again because it just got reset due to the model change
+			trap_G2API_SetBoneAnim(ci->ghoul2Model, 0, "model_root", firstFrame, anim->firstFrame + anim->numFrames, flags, animSpeed, cg.time, setFrame, 150);
+
+			cg_entities[clientNum].currentState.legsAnim = 0;
+		}
+
+		anim = &bgHumanoidAnimations[ (cg_entities[clientNum].currentState.torsoAnim) ];
+
+		if (anim)
+		{
+			int flags = BONE_ANIM_OVERRIDE_FREEZE;
+			int firstFrame = anim->firstFrame;
+			int setFrame = -1;
+			float animSpeed = 50.0f / anim->frameLerp;
+
+			if (anim->loopFrames != -1)
+			{
+				flags = BONE_ANIM_OVERRIDE_LOOP;
+			}
+
+			if (cent->pe.torso.frame >= anim->firstFrame && cent->pe.torso.frame <= (anim->firstFrame + anim->numFrames))
+			{
+				setFrame = cent->pe.torso.frame;
+			}
+
+			//rww - Set the animation again because it just got reset due to the model change
+			trap_G2API_SetBoneAnim(ci->ghoul2Model, 0, "lower_lumbar", firstFrame, anim->firstFrame + anim->numFrames, flags, animSpeed, cg.time, setFrame, 150);
+
+			cg_entities[clientNum].currentState.torsoAnim = 0;
+		}
+
+		if (cg_entities[clientNum].ghoul2 && trap_G2_HaveWeGhoul2Models(cg_entities[clientNum].ghoul2))
+		{
+			trap_G2API_CleanGhoul2Models(&cg_entities[clientNum].ghoul2);
+		}
+		trap_G2API_DuplicateGhoul2Instance(ci->ghoul2Model, &cg_entities[clientNum].ghoul2);
+
+		if (clientNum != -1)
+		{
+			//Attach the instance to this entity num so we can make use of client-server
+			//shared operations if possible.
+			trap_G2API_AttachInstanceToEntNum(cg_entities[clientNum].ghoul2, clientNum, qfalse);
+		}
+
+		if (trap_G2API_AddBolt(cg_entities[clientNum].ghoul2, 0, "face") == -1)
+		{ //check now to see if we have this bone for setting anims and such
+			cg_entities[clientNum].noFace = qtrue;
+		}
+
+		cg_entities[clientNum].localAnimIndex = CG_G2SkelForModel(cg_entities[clientNum].ghoul2);
+		cg_entities[clientNum].eventAnimIndex = CG_G2EvIndexForModel(cg_entities[clientNum].ghoul2, cg_entities[clientNum].localAnimIndex);
+
+		if (cg_entities[clientNum].currentState.number != cg.predictedPlayerState.clientNum &&
+			cg_entities[clientNum].currentState.weapon == WP_SABER)
+		{
+			cg_entities[clientNum].weapon = cg_entities[clientNum].currentState.weapon;
+			if (cg_entities[clientNum].ghoul2 && ci->ghoul2Model)
+			{
+				CG_CopyG2WeaponInstance(&cg_entities[clientNum], cg_entities[clientNum].currentState.weapon, cg_entities[clientNum].ghoul2);
+				cg_entities[clientNum].ghoul2weapon = CG_G2WeaponInstance(&cg_entities[clientNum], cg_entities[clientNum].currentState.weapon);
+			}
+			if (!cg_entities[clientNum].currentState.saberHolstered)
+			{ //if not holstered set length and desired length for both blades to full right now.
+				int j;
+				BG_SI_SetDesiredLength(&ci->saber[0], 0, -1);
+				BG_SI_SetDesiredLength(&ci->saber[1], 0, -1);
+
+				i = 0;
+				while (i < MAX_SABERS)
+				{
+					j = 0;
+					while (j < ci->saber[i].numBlades)
+					{
+						ci->saber[i].blade[j].length = ci->saber[i].blade[j].lengthMax;
+						j++;
+					}
+					i++;
+				}
+			}
+		}
+	}
+}
+
+
+qboolean cgQueueLoad = qfalse;
+/*
+======================
+CG_ActualLoadDeferredPlayers
+
+Called at the beginning of CG_Player if cgQueueLoad is set.
+======================
+*/
+void CG_ActualLoadDeferredPlayers( void )
+{
+	int		i;
+	clientInfo_t	*ci;
+
+	// scan for a deferred player to load
+	for ( i = 0, ci = cgs.clientinfo ; i < cgs.maxclients ; i++, ci++ ) {
+		if ( ci->infoValid && ci->deferred ) {
+			CG_LoadClientInfo( ci );
+//			break;
+		}
+	}
+}
+
+/*
+======================
+CG_LoadDeferredPlayers
+
+Called each frame when a player is dead
+and the scoreboard is up
+so deferred players can be loaded
+======================
+*/
+void CG_LoadDeferredPlayers( void ) {
+	cgQueueLoad = qtrue;
+}
+
+/*
+=============================================================================
+
+PLAYER ANIMATION
+
+=============================================================================
+*/
+
+#define	FOOTSTEP_DISTANCE	32
+static void _PlayerFootStep( const vec3_t origin, 
+								const float orientation, 
+								const float radius, 
+								centity_t *const cent, footstepType_t footStepType ) 
+{
+	vec3_t		end, mins = {-7, -7, 0}, maxs = {7, 7, 2};
+	trace_t		trace;
+	footstep_t	soundType = FOOTSTEP_TOTAL;
+	qboolean	bMark = qfalse;
+	qhandle_t footMarkShader;
+	int			effectID = -1;
+	//float		alpha;
+
+	// send a trace down from the player to the ground
+	VectorCopy( origin, end );
+	end[2] -= FOOTSTEP_DISTANCE;
+
+	trap_CM_BoxTrace( &trace, origin, end, mins, maxs, 0, MASK_PLAYERSOLID );
+
+	// no shadow if too high
+	if ( trace.fraction >= 1.0f ) 
+	{
+		return;
+	}
+
+	//check for foot-steppable surface flag
+	switch( trace.surfaceFlags & MATERIAL_MASK )
+	{
+		case MATERIAL_MUD:
+			bMark = qtrue;
+			if ( footStepType == FOOTSTEP_HEAVY_R || footStepType == FOOTSTEP_HEAVY_L) {
+				soundType = FOOTSTEP_MUDRUN;
+			} else {
+				soundType = FOOTSTEP_MUDWALK;
+			}
+			effectID = cgs.effects.footstepMud;
+			break;
+		case MATERIAL_DIRT:			
+			bMark = qtrue;
+			if ( footStepType == FOOTSTEP_HEAVY_R || footStepType == FOOTSTEP_HEAVY_L) {
+				soundType = FOOTSTEP_DIRTRUN;
+			} else {
+				soundType = FOOTSTEP_DIRTWALK;
+			}
+			effectID = cgs.effects.footstepSand;
+			break;
+		case MATERIAL_SAND:			
+			bMark = qtrue;
+			if ( footStepType == FOOTSTEP_HEAVY_R || footStepType == FOOTSTEP_HEAVY_L) {
+				soundType = FOOTSTEP_SANDRUN;
+			} else {
+				soundType = FOOTSTEP_SANDWALK;
+			}
+			effectID = cgs.effects.footstepSand;
+			break;
+		case MATERIAL_SNOW:			
+			bMark = qtrue;
+			if ( footStepType == FOOTSTEP_HEAVY_R || footStepType == FOOTSTEP_HEAVY_L) {
+				soundType = FOOTSTEP_SNOWRUN;
+			} else {
+				soundType = FOOTSTEP_SNOWWALK;
+			}
+			effectID = cgs.effects.footstepSnow;
+			break;
+		case MATERIAL_SHORTGRASS:		
+		case MATERIAL_LONGGRASS:		
+			if ( footStepType == FOOTSTEP_HEAVY_R || footStepType == FOOTSTEP_HEAVY_L) {
+				soundType = FOOTSTEP_GRASSRUN;
+			} else {
+				soundType = FOOTSTEP_GRASSWALK;
+			}
+			break;
+		case MATERIAL_SOLIDMETAL:		
+			if ( footStepType == FOOTSTEP_HEAVY_R || footStepType == FOOTSTEP_HEAVY_L) {
+				soundType = FOOTSTEP_METALRUN;
+			} else {
+				soundType = FOOTSTEP_METALWALK;
+			}
+			break;
+		case MATERIAL_HOLLOWMETAL:	
+			if ( footStepType == FOOTSTEP_HEAVY_R || footStepType == FOOTSTEP_HEAVY_L) {
+				soundType = FOOTSTEP_PIPERUN;
+			} else {
+				soundType = FOOTSTEP_PIPEWALK;
+			}
+			break;
+		case MATERIAL_GRAVEL:
+			if ( footStepType == FOOTSTEP_HEAVY_R || footStepType == FOOTSTEP_HEAVY_L) {
+				soundType = FOOTSTEP_GRAVELRUN;
+			} else {
+				soundType = FOOTSTEP_GRAVELWALK;
+			}
+			effectID = cgs.effects.footstepGravel;
+			break;
+		case MATERIAL_CARPET:
+		case MATERIAL_FABRIC:
+		case MATERIAL_CANVAS:
+		case MATERIAL_RUBBER:
+		case MATERIAL_PLASTIC:
+			if ( footStepType == FOOTSTEP_HEAVY_R || footStepType == FOOTSTEP_HEAVY_L) {
+				soundType = FOOTSTEP_RUGRUN;
+			} else {
+				soundType = FOOTSTEP_RUGWALK;
+			}
+			break;
+		case MATERIAL_SOLIDWOOD:
+		case MATERIAL_HOLLOWWOOD:
+			if ( footStepType == FOOTSTEP_HEAVY_R || footStepType == FOOTSTEP_HEAVY_L) {
+				soundType = FOOTSTEP_WOODRUN;
+			} else {
+				soundType = FOOTSTEP_WOODWALK;
+			}
+			break;
+
+		default:
+		//fall through
+		case MATERIAL_GLASS:
+		case MATERIAL_WATER:
+		case MATERIAL_FLESH:
+		case MATERIAL_BPGLASS:
+		case MATERIAL_DRYLEAVES:
+		case MATERIAL_GREENLEAVES:
+		case MATERIAL_TILES:		
+		case MATERIAL_PLASTER:
+		case MATERIAL_SHATTERGLASS:
+		case MATERIAL_ARMOR:
+		case MATERIAL_COMPUTER:
+
+		case MATERIAL_CONCRETE:		
+		case MATERIAL_ROCK:			
+		case MATERIAL_ICE:			
+		case MATERIAL_MARBLE:			
+			if ( footStepType == FOOTSTEP_HEAVY_R || footStepType == FOOTSTEP_HEAVY_L) {
+				soundType = FOOTSTEP_STONERUN;
+			} else {
+				soundType = FOOTSTEP_STONEWALK;
+			}
+			break;
+	}
+	if (soundType < FOOTSTEP_TOTAL) 
+	{
+	 	trap_S_StartSound( NULL, cent->currentState.clientNum, CHAN_BODY, cgs.media.footsteps[soundType][rand()&3] );
+	}
+
+	if ( cg_footsteps.integer < 4 )
+	{//debugging - 4 always does footstep effect
+		if ( cg_footsteps.integer < 2 )	//1 for sounds, 2 for effects, 3 for marks
+		{
+			return;
+		}
+	}
+
+	if ( effectID != -1 )
+	{
+		trap_FX_PlayEffectID( effectID, trace.endpos, trace.plane.normal, -1, -1 );
+	}
+
+	if ( cg_footsteps.integer < 4 )
+	{//debugging - 4 always does footstep effect
+		if ( !bMark || cg_footsteps.integer < 3 )	//1 for sounds, 2 for effects, 3 for marks
+		{
+			return;
+		}
+	}
+
+	switch ( footStepType )
+	{
+	case FOOTSTEP_HEAVY_R:
+		footMarkShader = cgs.media.fshrMarkShader;
+		break;
+	case FOOTSTEP_HEAVY_L:
+		footMarkShader = cgs.media.fshlMarkShader;
+		break;
+	case FOOTSTEP_R:
+		footMarkShader = cgs.media.fsrMarkShader;
+		break;
+	default:
+	case FOOTSTEP_L:
+		footMarkShader = cgs.media.fslMarkShader;
+		break;
+	}
+
+	// fade the shadow out with height
+//	alpha = 1.0 - trace.fraction;
+
+	// add the mark as a temporary, so it goes directly to the renderer
+	// without taking a spot in the cg_marks array
+	if (trace.plane.normal[0] || trace.plane.normal[1] || trace.plane.normal[2])
+	{
+		CG_ImpactMark( footMarkShader, trace.endpos, trace.plane.normal, 
+			orientation, 1,1,1, 1.0f, qfalse, radius, qfalse );
+	}
+}
+
+static void CG_PlayerFootsteps( centity_t *cent, footstepType_t footStepType )
+{
+	if ( !cg_footsteps.integer ) 
+	{
+		return;
+	}
+
+	//FIXME: make this a feature of NPCs in the NPCs.cfg? Specify a footstep shader, if any?
+	if ( cent->currentState.NPC_class != CLASS_ATST
+		&& cent->currentState.NPC_class != CLASS_CLAW
+		&& cent->currentState.NPC_class != CLASS_FISH
+		&& cent->currentState.NPC_class != CLASS_FLIER2
+		&& cent->currentState.NPC_class != CLASS_GLIDER
+		&& cent->currentState.NPC_class != CLASS_INTERROGATOR
+		&& cent->currentState.NPC_class != CLASS_MURJJ
+		&& cent->currentState.NPC_class != CLASS_PROBE
+		&& cent->currentState.NPC_class != CLASS_R2D2
+		&& cent->currentState.NPC_class != CLASS_R5D2
+		&& cent->currentState.NPC_class != CLASS_REMOTE
+		&& cent->currentState.NPC_class != CLASS_SEEKER
+		&& cent->currentState.NPC_class != CLASS_SENTRY
+		&& cent->currentState.NPC_class != CLASS_SWAMP )
+	{
+		mdxaBone_t	boltMatrix;
+		vec3_t tempAngles, sideOrigin;
+		int footBolt = -1;
+
+		tempAngles[PITCH]	= 0;
+		tempAngles[YAW]		= cent->pe.legs.yawAngle;
+		tempAngles[ROLL]	= 0;
+
+		switch ( footStepType )
+		{
+		case FOOTSTEP_R:
+		case FOOTSTEP_HEAVY_R:
+			footBolt = trap_G2API_AddBolt(cent->ghoul2, 0, "*r_leg_foot");//cent->gent->footRBolt;
+			break;
+		case FOOTSTEP_L:
+		case FOOTSTEP_HEAVY_L:
+		default:
+			footBolt = trap_G2API_AddBolt(cent->ghoul2, 0, "*l_leg_foot");//cent->gent->footLBolt;
+			break;
+		}
+
+
+		//FIXME: get yaw orientation of the foot and use on decal
+		trap_G2API_GetBoltMatrix( cent->ghoul2, 0, footBolt, &boltMatrix, tempAngles, cent->lerpOrigin, 
+				cg.time, cgs.gameModels, cent->modelScale);
+		BG_GiveMeVectorFromMatrix( &boltMatrix, ORIGIN, sideOrigin );
+		sideOrigin[2] += 15;	//fudge up a bit for coplanar
+		_PlayerFootStep( sideOrigin, cent->pe.legs.yawAngle, 6, cent, footStepType );
+	}
+}
+
+void CG_PlayerAnimEventDo( centity_t *cent, animevent_t *animEvent )
+{
+	soundChannel_t channel = CHAN_AUTO;
+	if ( !cent || !animEvent )
+	{
+		return;
+	}
+
+	switch ( animEvent->eventType )
+	{
+	case AEV_SOUNDCHAN:
+		channel = (soundChannel_t)animEvent->eventData[AED_SOUNDCHANNEL];
+	case AEV_SOUND:
+		{	// are there variations on the sound?
+			const int holdSnd = animEvent->eventData[ AED_SOUNDINDEX_START+Q_irand( 0, animEvent->eventData[AED_SOUND_NUMRANDOMSNDS] ) ];
+			if ( holdSnd > 0 )
+			{
+				trap_S_StartSound( NULL, cent->currentState.number, channel, holdSnd );
+			}
+		}
+		break;
+	case AEV_FOOTSTEP:
+		CG_PlayerFootsteps( cent, (footstepType_t)animEvent->eventData[AED_FOOTSTEP_TYPE] );
+		break;
+	case AEV_EFFECT:
+#if 0 //SP method
+		//add bolt, play effect
+		if ( animEvent->stringData != NULL && cent && cent->gent && cent->gent->ghoul2.size() )
+		{//have a bolt name we want to use
+			animEvent->eventData[AED_BOLTINDEX] = gi.G2API_AddBolt( &cent->gent->ghoul2[cent->gent->playerModel], animEvent->stringData );
+			animEvent->stringData = NULL;//so we don't try to do this again
+		}
+		if ( animEvent->eventData[AED_BOLTINDEX] != -1 )
+		{//have a bolt we want to play the effect on
+			G_PlayEffect( animEvent->eventData[AED_EFFECTINDEX], cent->gent->playerModel, animEvent->eventData[AED_BOLTINDEX], cent->currentState.clientNum );
+		}
+		else
+		{//play at origin?  FIXME: maybe allow a fwd/rt/up offset?
+			theFxScheduler.PlayEffect( animEvent->eventData[AED_EFFECTINDEX], cent->lerpOrigin, qfalse );
+		}
+#else //my method
+		if (animEvent->stringData && animEvent->stringData[0] && cent && cent->ghoul2)
+		{
+			animEvent->eventData[AED_MODELINDEX] = 0;
+			if ( ( Q_stricmpn( "*blade", animEvent->stringData, 6 ) == 0 
+					|| Q_stricmp( "*flash", animEvent->stringData ) == 0 ) )
+			{//must be a weapon, try weapon 0?
+				animEvent->eventData[AED_BOLTINDEX] = trap_G2API_AddBolt( cent->ghoul2, 1, animEvent->stringData );
+				if ( animEvent->eventData[AED_BOLTINDEX] != -1 )
+				{//found it!
+					animEvent->eventData[AED_MODELINDEX] = 1;
+				}
+				else
+				{//hmm, just try on the player model, then?
+					animEvent->eventData[AED_BOLTINDEX] = trap_G2API_AddBolt( cent->ghoul2, 0, animEvent->stringData );
+				}
+			}
+			else
+			{
+				animEvent->eventData[AED_BOLTINDEX] = trap_G2API_AddBolt( cent->ghoul2, 0, animEvent->stringData );
+			}
+			animEvent->stringData[0] = 0;
+		}
+		if ( animEvent->eventData[AED_BOLTINDEX] != -1 )
+		{
+			vec3_t lAngles;
+			vec3_t bPoint, bAngle;
+			mdxaBone_t matrix;
+
+			VectorSet(lAngles, 0, cent->lerpAngles[YAW], 0);
+
+			trap_G2API_GetBoltMatrix(cent->ghoul2, animEvent->eventData[AED_MODELINDEX], animEvent->eventData[AED_BOLTINDEX], &matrix, lAngles,
+				cent->lerpOrigin, cg.time, cgs.gameModels, cent->modelScale);
+			BG_GiveMeVectorFromMatrix(&matrix, ORIGIN, bPoint);
+			VectorSet(bAngle, 0, 1, 0);
+
+			trap_FX_PlayEffectID(animEvent->eventData[AED_EFFECTINDEX], bPoint, bAngle, -1, -1);
+		}
+		else
+		{
+			vec3_t bAngle;
+
+			VectorSet(bAngle, 0, 1, 0);
+			trap_FX_PlayEffectID(animEvent->eventData[AED_EFFECTINDEX], cent->lerpOrigin, bAngle, -1, -1);
+		}
+#endif
+		break;
+	//Would have to keep track of this on server to for these, it's not worth it.
+	case AEV_FIRE:
+	case AEV_MOVE:
+		break;
+		/*
+	case AEV_FIRE:
+		//add fire event
+		if ( animEvent->eventData[AED_FIRE_ALT] )
+		{
+			G_AddEvent( cent->gent, EV_ALT_FIRE, 0 );
+		}
+		else
+		{
+			G_AddEvent( cent->gent, EV_FIRE_WEAPON, 0 );
+		}
+		break;
+	case AEV_MOVE:
+		//make him jump
+		if ( cent && cent->gent && cent->gent->client )
+		{
+			if ( cent->gent->client->ps.groundEntityNum != ENTITYNUM_NONE )
+			{//on something
+				vec3_t	fwd, rt, up, angles = {0, cent->gent->client->ps.viewangles[YAW], 0};
+				AngleVectors( angles, fwd, rt, up );
+				//FIXME: set or add to velocity?
+				VectorScale( fwd, animEvent->eventData[AED_MOVE_FWD], cent->gent->client->ps.velocity );
+				VectorMA( cent->gent->client->ps.velocity, animEvent->eventData[AED_MOVE_RT], rt, cent->gent->client->ps.velocity );
+				VectorMA( cent->gent->client->ps.velocity, animEvent->eventData[AED_MOVE_UP], up, cent->gent->client->ps.velocity );
+				
+				if ( animEvent->eventData[AED_MOVE_UP] > 0 )
+				{//a jump
+					cent->gent->client->ps.pm_flags |= PMF_JUMPING;
+
+					G_AddEvent( cent->gent, EV_JUMP, 0 );
+					//FIXME: if have force jump, do this?  or specify sound in the event data?
+					//cent->gent->client->ps.forceJumpZStart = cent->gent->client->ps.origin[2];//so we don't take damage if we land at same height
+					//G_SoundOnEnt( cent->gent, CHAN_BODY, "sound/weapons/force/jump.wav" );
+				}
+			}
+		}
+		break;
+		*/
+	default:
+		return;
+		break;
+	}
+}
+
+/*
+void CG_PlayerAnimEvents( int animFileIndex, int eventFileIndex, qboolean torso, int oldFrame, int frame, const vec3_t org, int entNum )
+
+play any keyframed sounds - only when start a new frame
+This func is called once for legs and once for torso
+*/
+void CG_PlayerAnimEvents( int animFileIndex, int eventFileIndex, qboolean torso, int oldFrame, int frame, int entNum )
+{
+	int		i;
+	int		firstFrame = 0, lastFrame = 0;
+	qboolean	doEvent = qfalse, inSameAnim = qfalse, loopAnim = qfalse, match = qfalse, animBackward = qfalse;
+	animevent_t *animEvents = NULL;
+	
+	if ( torso )
+	{
+		animEvents = bgAllEvents[eventFileIndex].torsoAnimEvents;
+	}
+	else
+	{
+		animEvents = bgAllEvents[eventFileIndex].legsAnimEvents;
+	}
+	if ( fabs((float)(oldFrame-frame)) > 1 )
+	{//given a range, see if keyFrame falls in that range
+		int oldAnim, anim;
+		if ( torso )
+		{
+			/*
+			if ( cg_reliableAnimSounds.integer > 1 )
+			{//more precise, slower
+				oldAnim = PM_TorsoAnimForFrame( &g_entities[entNum], oldFrame );
+				anim = PM_TorsoAnimForFrame( &g_entities[entNum], frame );
+			}
+			else
+			*/
+			{//less precise, but faster
+				oldAnim = cg_entities[entNum].currentState.torsoAnim;
+				anim = cg_entities[entNum].nextState.torsoAnim;
+			}
+		}
+		else
+		{
+			/*
+			if ( cg_reliableAnimSounds.integer > 1 )
+			{//more precise, slower
+				oldAnim = PM_LegsAnimForFrame( &g_entities[entNum], oldFrame );
+				anim = PM_TorsoAnimForFrame( &g_entities[entNum], frame );
+			}
+			else
+			*/
+			{//less precise, but faster
+				oldAnim = cg_entities[entNum].currentState.legsAnim;
+				anim = cg_entities[entNum].nextState.legsAnim;
+			}
+		}
+		if ( anim != oldAnim )
+		{//not in same anim
+			inSameAnim = qfalse;
+			//FIXME: we *could* see if the oldFrame was *just about* to play the keyframed sound...
+		}
+		else
+		{//still in same anim, check for looping anim
+			animation_t *animation;
+
+			inSameAnim = qtrue;
+			animation = &bgAllAnims[animFileIndex].anims[anim];
+			animBackward = (animation->frameLerp<0);
+			if ( animation->loopFrames != -1 )
+			{//a looping anim!
+				loopAnim = qtrue;
+				firstFrame = animation->firstFrame;
+				lastFrame = animation->firstFrame+animation->numFrames;
+			}
+		}
+	}
+
+	// Check for anim sound
+	for (i=0;i<MAX_ANIM_EVENTS;++i)
+	{
+		if ( animEvents[i].eventType == AEV_NONE )	// No event, end of list
+		{
+			break;
+		}
+
+		match = qfalse;
+		if ( animEvents[i].keyFrame == frame )
+		{//exact match
+			match = qtrue;
+		}
+		else if ( fabs((float)(oldFrame-frame)) > 1 /*&& cg_reliableAnimSounds.integer*/ )
+		{//given a range, see if keyFrame falls in that range
+			if ( inSameAnim )
+			{//if changed anims altogether, sorry, the sound is lost
+				if ( fabs((float)(oldFrame-animEvents[i].keyFrame)) <= 3
+					 || fabs((float)(frame-animEvents[i].keyFrame)) <= 3 )
+				{//must be at least close to the keyframe
+					if ( animBackward )
+					{//animation plays backwards
+						if ( oldFrame > animEvents[i].keyFrame && frame < animEvents[i].keyFrame )
+						{//old to new passed through keyframe
+							match = qtrue;
+						}
+						else if ( loopAnim )
+						{//hmm, didn't pass through it linearally, see if we looped
+							if ( animEvents[i].keyFrame >= firstFrame && animEvents[i].keyFrame < lastFrame )
+							{//keyframe is in this anim
+								if ( oldFrame > animEvents[i].keyFrame 
+									&& frame > oldFrame )
+								{//old to new passed through keyframe
+									match = qtrue;
+								}
+							}
+						}
+					}
+					else
+					{//anim plays forwards
+						if ( oldFrame < animEvents[i].keyFrame && frame > animEvents[i].keyFrame )
+						{//old to new passed through keyframe
+							match = qtrue;
+						}
+						else if ( loopAnim )
+						{//hmm, didn't pass through it linearally, see if we looped
+							if ( animEvents[i].keyFrame >= firstFrame && animEvents[i].keyFrame < lastFrame )
+							{//keyframe is in this anim
+								if ( oldFrame < animEvents[i].keyFrame 
+									&& frame < oldFrame )
+								{//old to new passed through keyframe
+									match = qtrue;
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+		if ( match )
+		{
+			switch ( animEvents[i].eventType )
+			{
+			case AEV_SOUND:
+				// Determine probability of playing sound
+				if (!animEvents[i].eventData[AED_SOUND_PROBABILITY])	// 100% 
+				{
+					doEvent = qtrue;
+				}
+				else if (animEvents[i].eventData[AED_SOUND_PROBABILITY] > Q_irand(0, 99) )
+				{
+					doEvent = qtrue;
+				}
+				break;
+			case AEV_FOOTSTEP:
+				// Determine probability of playing sound
+				if (!animEvents[i].eventData[AED_FOOTSTEP_PROBABILITY])	// 100% 
+				{
+					doEvent = qtrue;
+				}
+				else if (animEvents[i].eventData[AED_FOOTSTEP_PROBABILITY] > Q_irand(0, 99) )
+				{
+					doEvent = qtrue;
+				}
+				break;
+			case AEV_EFFECT:
+				// Determine probability of playing sound
+				if (!animEvents[i].eventData[AED_EFFECT_PROBABILITY])	// 100% 
+				{
+					doEvent = qtrue;
+				}
+				else if (animEvents[i].eventData[AED_EFFECT_PROBABILITY] > Q_irand(0, 99) )
+				{
+					doEvent = qtrue;
+				}
+				break;
+			case AEV_FIRE:
+				// Determine probability of playing sound
+				if (!animEvents[i].eventData[AED_FIRE_PROBABILITY])	// 100% 
+				{
+					doEvent = qtrue;
+				}
+				else if (animEvents[i].eventData[AED_FIRE_PROBABILITY] > Q_irand(0, 99) )
+				{
+					doEvent = qtrue;
+				}
+				break;
+			case AEV_MOVE:
+				doEvent = qtrue;
+				break;
+			default:
+				//doEvent = qfalse;//implicit
+				break;
+			}
+			// do event
+			if ( doEvent )
+			{
+				CG_PlayerAnimEventDo( &cg_entities[entNum], &animEvents[i] );
+			}
+		}
+	}
+}
+
+void CG_TriggerAnimSounds( centity_t *cent )
+{ //this also sets the lerp frames, so I suggest you keep calling it regardless of if you want anim sounds.
+	int		curFrame = 0;
+	float	currentFrame = 0;
+	int		sFileIndex;
+
+	assert(cent->localAnimIndex >= 0);
+
+	sFileIndex = cent->eventAnimIndex;
+
+	if (trap_G2API_GetBoneFrame(cent->ghoul2, "model_root", cg.time, &currentFrame, cgs.gameModels, 0))
+	{
+		// the above may have failed, not sure what to do about it, current frame will be zero in that case
+		curFrame = floor( currentFrame );
+	}
+	if ( curFrame != cent->pe.legs.frame )
+	{
+		CG_PlayerAnimEvents( cent->localAnimIndex, sFileIndex, qfalse, cent->pe.legs.frame, curFrame, cent->currentState.number );
+	}
+	cent->pe.legs.oldFrame = cent->pe.torso.frame;
+	cent->pe.legs.frame = curFrame;
+
+	if (cent->noLumbar)
+	{ //probably a droid or something.
+		cent->pe.torso.oldFrame = cent->pe.legs.oldFrame;
+		cent->pe.torso.frame = cent->pe.legs.frame;
+		return;
+	}
+
+	if (trap_G2API_GetBoneFrame(cent->ghoul2, "lower_lumbar", cg.time, &currentFrame, cgs.gameModels, 0))
+	{
+		curFrame = floor( currentFrame );
+	}
+	if ( curFrame != cent->pe.torso.frame )
+	{
+		CG_PlayerAnimEvents( cent->localAnimIndex, sFileIndex, qtrue, cent->pe.torso.frame, curFrame, cent->currentState.number );
+	}
+	cent->pe.torso.oldFrame = cent->pe.torso.frame;
+	cent->pe.torso.frame = curFrame;	
+	cent->pe.torso.backlerp = 1.0f - (currentFrame - (float)curFrame);	
+}
+
+
+static qboolean CG_FirstAnimFrame(lerpFrame_t *lf, qboolean torsoOnly, float speedScale);
+
+qboolean CG_InRoll( centity_t *cent )
+{
+	switch ( (cent->currentState.legsAnim) )
+	{
+	case BOTH_GETUP_BROLL_B:
+	case BOTH_GETUP_BROLL_F:
+	case BOTH_GETUP_BROLL_L:
+	case BOTH_GETUP_BROLL_R:
+	case BOTH_GETUP_FROLL_B:
+	case BOTH_GETUP_FROLL_F:
+	case BOTH_GETUP_FROLL_L:
+	case BOTH_GETUP_FROLL_R:
+	case BOTH_ROLL_F:
+	case BOTH_ROLL_B:
+	case BOTH_ROLL_R:
+	case BOTH_ROLL_L:
+		if ( cent->pe.legs.animationTime > cg.time )
+		{
+			return qtrue;
+		}
+		break;
+	}
+	return qfalse;
+}
+
+qboolean CG_InRollAnim( centity_t *cent )
+{
+	switch ( (cent->currentState.legsAnim) )
+	{
+	case BOTH_ROLL_F:
+	case BOTH_ROLL_B:
+	case BOTH_ROLL_R:
+	case BOTH_ROLL_L:
+		return qtrue;
+	}
+	return qfalse;
+}
+
+/*
+===============
+CG_SetLerpFrameAnimation
+===============
+*/
+#include "../namespace_begin.h"
+qboolean BG_SaberStanceAnim( int anim );
+qboolean PM_RunningAnim( int anim );
+#include "../namespace_end.h"
+static void CG_SetLerpFrameAnimation( centity_t *cent, clientInfo_t *ci, lerpFrame_t *lf, int newAnimation, float animSpeedMult, qboolean torsoOnly, qboolean flipState) {
+	animation_t	*anim;
+	float animSpeed;
+	int	  flags=BONE_ANIM_OVERRIDE_FREEZE;
+	int oldAnim = -1;
+	int blendTime = 100;
+	float oldSpeed = lf->animationSpeed;
+
+	if (cent->localAnimIndex > 0)
+	{ //rockettroopers can't have broken arms, nor can anything else but humanoids
+		ci->brokenLimbs = cent->currentState.brokenLimbs;
+	}
+
+	oldAnim = lf->animationNumber;
+
+	lf->animationNumber = newAnimation;
+
+	if ( newAnimation < 0 || newAnimation >= MAX_TOTALANIMATIONS ) {
+		CG_Error( "Bad animation number: %i", newAnimation );
+	}
+
+	anim = &bgAllAnims[cent->localAnimIndex].anims[ newAnimation ];
+
+	lf->animation = anim;
+	lf->animationTime = lf->frameTime + abs(anim->frameLerp);
+
+	if (cent->localAnimIndex > 1 &&
+		anim->firstFrame == 0 &&
+		anim->numFrames == 0)
+	{ //We'll allow this for non-humanoids.
+		return;
+	}
+
+	if ( cg_debugAnim.integer && (cg_debugAnim.integer < 0 || cg_debugAnim.integer == cent->currentState.clientNum) ) {
+		if (lf == &cent->pe.legs)
+		{
+			CG_Printf( "%d: %d TORSO Anim: %i, '%s'\n", cg.time, cent->currentState.clientNum, newAnimation, GetStringForID(animTable, newAnimation));
+		}
+		else
+		{
+			CG_Printf( "%d: %d LEGS Anim: %i, '%s'\n", cg.time, cent->currentState.clientNum, newAnimation, GetStringForID(animTable, newAnimation));
+		}
+	}
+
+	if (cent->ghoul2)
+	{
+		qboolean resumeFrame = qfalse;
+		int beginFrame = -1;
+		int firstFrame;
+		int lastFrame;
+#if 0 //disabled for now
+		float unused;
+#endif
+
+		animSpeed = 50.0f / anim->frameLerp;
+		if (lf->animation->loopFrames != -1)
+		{
+			flags = BONE_ANIM_OVERRIDE_LOOP;
+		}
+
+		if (animSpeed < 0)
+		{
+			lastFrame = anim->firstFrame;
+			firstFrame = anim->firstFrame + anim->numFrames;
+		}
+		else
+		{
+			firstFrame = anim->firstFrame;
+			lastFrame = anim->firstFrame + anim->numFrames;
+		}
+
+		if (cg_animBlend.integer)
+		{
+			flags |= BONE_ANIM_BLEND;
+		}
+
+		if (BG_InDeathAnim(newAnimation))
+		{
+			flags &= ~BONE_ANIM_BLEND;
+		}
+		else if ( oldAnim != -1 &&
+			BG_InDeathAnim(oldAnim))
+		{
+			flags &= ~BONE_ANIM_BLEND;
+		}
+
+		if (flags & BONE_ANIM_BLEND)
+		{
+			if (BG_FlippingAnim(newAnimation))
+			{
+				blendTime = 200;
+			}
+			else if ( oldAnim != -1 &&
+				(BG_FlippingAnim(oldAnim)) )
+			{
+				blendTime = 200;
+			}
+		}
+
+		animSpeed *= animSpeedMult;
+
+		BG_SaberStartTransAnim(cent->currentState.fireflag, newAnimation, &animSpeed, cent->currentState.brokenLimbs);
+
+		if (torsoOnly)
+		{
+			if (lf->animationTorsoSpeed != animSpeedMult && newAnimation == oldAnim &&
+				flipState == lf->lastFlip)
+			{ //same animation, but changing speed, so we will want to resume off the frame we're on.
+				resumeFrame = qtrue;
+			}
+			lf->animationTorsoSpeed = animSpeedMult;
+		}
+		else
+		{
+			if (lf->animationSpeed != animSpeedMult && newAnimation == oldAnim &&
+				flipState == lf->lastFlip)
+			{ //same animation, but changing speed, so we will want to resume off the frame we're on.
+				resumeFrame = qtrue;
+			}
+			lf->animationSpeed = animSpeedMult;
+		}
+
+		//vehicles may have torso etc but we only want to animate the root bone
+		if ( cent->currentState.NPC_class == CLASS_VEHICLE )
+		{
+			trap_G2API_SetBoneAnim(cent->ghoul2, 0, "model_root", firstFrame, lastFrame, flags, animSpeed,cg.time, beginFrame, blendTime);
+			return;
+		}
+
+		if (torsoOnly && !cent->noLumbar)
+		{ //rww - The guesswork based on the lerp frame figures is usually BS, so I've resorted to a call to get the frame of the bone directly.
+			float GBAcFrame = 0;
+			if (resumeFrame)
+			{ //we already checked, and this is the same anim, same flip state, but different speed, so we want to resume with the new speed off of the same frame.
+				trap_G2API_GetBoneFrame(cent->ghoul2, "lower_lumbar", cg.time, &GBAcFrame, NULL, 0);
+				beginFrame = GBAcFrame;
+			}
+
+			//even if resuming, also be sure to check if we are running the same frame on the legs. If so, we want to use their frame no matter what.
+			trap_G2API_GetBoneFrame(cent->ghoul2, "model_root", cg.time, &GBAcFrame, NULL, 0);
+
+			if ((cent->currentState.torsoAnim) == (cent->currentState.legsAnim) && GBAcFrame >= anim->firstFrame && GBAcFrame <= (anim->firstFrame + anim->numFrames))
+			{ //if the legs are already running this anim, pick up on the exact same frame to avoid the "wobbly spine" problem.
+				beginFrame = GBAcFrame;
+			}
+
+			if (firstFrame > lastFrame || ci->torsoAnim == newAnimation)
+			{ //don't resume on backwards playing animations.. I guess.
+				beginFrame = -1;
+			}
+
+			trap_G2API_SetBoneAnim(cent->ghoul2, 0, "lower_lumbar", firstFrame, lastFrame, flags, animSpeed,cg.time, beginFrame, blendTime);
+
+			// Update the torso frame with the new animation
+			cent->pe.torso.frame = firstFrame;
+			
+			if (ci)
+			{
+				ci->torsoAnim = newAnimation;
+			}
+		}
+		else
+		{
+			if (resumeFrame)
+			{ //we already checked, and this is the same anim, same flip state, but different speed, so we want to resume with the new speed off of the same frame.
+				float GBAcFrame = 0;
+				trap_G2API_GetBoneFrame(cent->ghoul2, "model_root", cg.time, &GBAcFrame, NULL, 0);
+				beginFrame = GBAcFrame;
+			}
+
+			if ((beginFrame < firstFrame) || (beginFrame > lastFrame))
+			{ //out of range, don't use it then.
+				beginFrame = -1;
+			}
+
+			if (cent->currentState.torsoAnim == cent->currentState.legsAnim &&
+				(ci->legsAnim != newAnimation || oldSpeed != animSpeed))
+			{ //alright, we are starting an anim on the legs, and that same anim is already playing on the toro, so pick up the frame.
+				float GBAcFrame = 0;
+				int oldBeginFrame = beginFrame;
+
+				trap_G2API_GetBoneFrame(cent->ghoul2, "lower_lumbar", cg.time, &GBAcFrame, NULL, 0);
+				beginFrame = GBAcFrame;
+				if ((beginFrame < firstFrame) || (beginFrame > lastFrame))
+				{ //out of range, don't use it then.
+					beginFrame = oldBeginFrame;
+				}
+			}
+
+			trap_G2API_SetBoneAnim(cent->ghoul2, 0, "model_root", firstFrame, lastFrame, flags, animSpeed, cg.time, beginFrame, blendTime);
+
+			if (ci)
+			{
+				ci->legsAnim = newAnimation;
+			}
+		}
+
+		if (cent->localAnimIndex <= 1 && (cent->currentState.torsoAnim) == newAnimation && !cent->noLumbar)
+		{ //make sure we're humanoid before we access the motion bone
+			trap_G2API_SetBoneAnim(cent->ghoul2, 0, "Motion", firstFrame, lastFrame, flags, animSpeed, cg.time, beginFrame, blendTime);
+		}
+
+#if 0 //disabled for now
+		if (cent->localAnimIndex <= 1 && cent->currentState.brokenLimbs &&
+			(cent->currentState.brokenLimbs & (1 << BROKENLIMB_LARM)))
+		{ //broken left arm
+			char *brokenBone = "lhumerus";
+			animation_t *armAnim;
+			int armFirstFrame;
+			int armLastFrame;
+			int armFlags = 0;
+			float armAnimSpeed;
+
+			armAnim = &bgAllAnims[cent->localAnimIndex].anims[ BOTH_DEAD21 ];
+			ci->brokenLimbs = cent->currentState.brokenLimbs;
+
+			armFirstFrame = armAnim->firstFrame;
+			armLastFrame = armAnim->firstFrame+armAnim->numFrames;
+			armAnimSpeed = 50.0f / armAnim->frameLerp;
+			armFlags = BONE_ANIM_OVERRIDE_LOOP;
+
+			if (cg_animBlend.integer)
+			{
+				armFlags |= BONE_ANIM_BLEND;
+			}
+
+			trap_G2API_SetBoneAnim(cent->ghoul2, 0, brokenBone, armFirstFrame, armLastFrame, armFlags, armAnimSpeed, cg.time, -1, blendTime);
+		}
+		else if (cent->localAnimIndex <= 1 && cent->currentState.brokenLimbs &&
+			(cent->currentState.brokenLimbs & (1 << BROKENLIMB_RARM)))
+		{ //broken right arm
+			char *brokenBone = "rhumerus";
+			char *supportBone = "lhumerus";
+
+			ci->brokenLimbs = cent->currentState.brokenLimbs;
+
+			//Only put the arm in a broken pose if the anim is such that we
+			//want to allow it.
+			if ((//cent->currentState.weapon == WP_MELEE ||
+				cent->currentState.weapon != WP_SABER ||
+				BG_SaberStanceAnim(newAnimation) ||
+				PM_RunningAnim(newAnimation)) &&
+				cent->currentState.torsoAnim == newAnimation &&
+				(!ci->saber[1].model[0] || cent->currentState.weapon != WP_SABER))
+			{
+				int armFirstFrame;
+				int armLastFrame;
+				int armFlags = 0;
+				float armAnimSpeed;
+				animation_t *armAnim;
+
+				if (cent->currentState.weapon == WP_MELEE ||
+					cent->currentState.weapon == WP_SABER ||
+					cent->currentState.weapon == WP_BRYAR_PISTOL)
+				{ //don't affect this arm if holding a gun, just make the other arm support it
+					armAnim = &bgAllAnims[cent->localAnimIndex].anims[ BOTH_ATTACK2 ];
+
+					//armFirstFrame = armAnim->firstFrame;
+					armFirstFrame = armAnim->firstFrame+armAnim->numFrames;
+					armLastFrame = armAnim->firstFrame+armAnim->numFrames;
+					armAnimSpeed = 50.0f / armAnim->frameLerp;
+					armFlags = BONE_ANIM_OVERRIDE_LOOP;
+
+					/*
+					if (cg_animBlend.integer)
+					{
+						armFlags |= BONE_ANIM_BLEND;
+					}
+					*/
+					//No blend on the broken arm
+
+					trap_G2API_SetBoneAnim(cent->ghoul2, 0, brokenBone, armFirstFrame, armLastFrame, armFlags, armAnimSpeed, cg.time, -1, 0);
+				}
+				else
+				{ //we want to keep the broken bone updated for some cases
+					trap_G2API_SetBoneAnim(cent->ghoul2, 0, brokenBone, firstFrame, lastFrame, flags, animSpeed, cg.time, beginFrame, blendTime);
+				}
+
+				if (newAnimation != BOTH_MELEE1 &&
+					newAnimation != BOTH_MELEE2 &&
+					(newAnimation == TORSO_WEAPONREADY2 || newAnimation == BOTH_ATTACK2 || cent->currentState.weapon < WP_BRYAR_PISTOL))
+				{
+					//Now set the left arm to "support" the right one
+					armAnim = &bgAllAnims[cent->localAnimIndex].anims[ BOTH_STAND2 ];
+					armFirstFrame = armAnim->firstFrame;
+					armLastFrame = armAnim->firstFrame+armAnim->numFrames;
+					armAnimSpeed = 50.0f / armAnim->frameLerp;
+					armFlags = BONE_ANIM_OVERRIDE_LOOP;
+
+					if (cg_animBlend.integer)
+					{
+						armFlags |= BONE_ANIM_BLEND;
+					}
+
+					trap_G2API_SetBoneAnim(cent->ghoul2, 0, supportBone, armFirstFrame, armLastFrame, armFlags, armAnimSpeed, cg.time, -1, 150);
+				}
+				else
+				{ //we want to keep the support bone updated for some cases
+					trap_G2API_SetBoneAnim(cent->ghoul2, 0, supportBone, firstFrame, lastFrame, flags, animSpeed, cg.time, beginFrame, blendTime);
+				}
+			}
+			else if (cent->currentState.torsoAnim == newAnimation)
+			{ //otherwise, keep it set to the same as the torso
+				trap_G2API_SetBoneAnim(cent->ghoul2, 0, brokenBone, firstFrame, lastFrame, flags, animSpeed, cg.time, beginFrame, blendTime);
+				trap_G2API_SetBoneAnim(cent->ghoul2, 0, supportBone, firstFrame, lastFrame, flags, animSpeed, cg.time, beginFrame, blendTime);
+			}
+		}
+		else if (ci &&
+			(ci->brokenLimbs ||
+			trap_G2API_GetBoneFrame(cent->ghoul2, "lhumerus", cg.time, &unused, cgs.gameModels, 0) ||
+			trap_G2API_GetBoneFrame(cent->ghoul2, "rhumerus", cg.time, &unused, cgs.gameModels, 0)))
+			//rwwFIXMEFIXME: brokenLimbs gets stomped sometimes, but it shouldn't.
+		{ //remove the bone now so it can be set again
+			char *brokenBone = NULL;
+			int broken = 0;
+
+			//Warning: Don't remove bones that you've added as bolts unless you want to invalidate your bolt index
+			//(well, in theory, I haven't actually run into the problem)
+			if (ci->brokenLimbs & (1<<BROKENLIMB_LARM))
+			{
+				brokenBone = "lhumerus";
+				broken |= (1<<BROKENLIMB_LARM);
+			}
+			else if (ci->brokenLimbs & (1<<BROKENLIMB_RARM))
+			{ //can only have one arm broken at once.
+				brokenBone = "rhumerus";
+				broken |= (1<<BROKENLIMB_RARM);
+
+				//want to remove the support bone too then
+				trap_G2API_SetBoneAnim(cent->ghoul2, 0, "lhumerus", 0, 1, 0, 0, cg.time, -1, 0);
+				if (!trap_G2API_RemoveBone(cent->ghoul2, "lhumerus", 0))
+				{
+					assert(0);
+					Com_Printf("WARNING: Failed to remove lhumerus\n");
+				}
+			}
+
+			if (!brokenBone)
+			{
+				trap_G2API_SetBoneAnim(cent->ghoul2, 0, "lhumerus", 0, 1, 0, 0, cg.time, -1, 0);
+				trap_G2API_SetBoneAnim(cent->ghoul2, 0, "rhumerus", 0, 1, 0, 0, cg.time, -1, 0);
+				trap_G2API_RemoveBone(cent->ghoul2, "lhumerus", 0);
+				trap_G2API_RemoveBone(cent->ghoul2, "rhumerus", 0);
+				ci->brokenLimbs = 0;
+			}
+			else
+			{
+				//Set the flags and stuff to 0, so that the remove will succeed
+				trap_G2API_SetBoneAnim(cent->ghoul2, 0, brokenBone, 0, 1, 0, 0, cg.time, -1, 0);
+
+				//Now remove it
+				if (!trap_G2API_RemoveBone(cent->ghoul2, brokenBone, 0))
+				{
+					assert(0);
+					Com_Printf("WARNING: Failed to remove %s\n", brokenBone);
+				}
+				ci->brokenLimbs &= ~broken;
+			}
+		}
+#endif
+	}
+}
+
+
+/*
+===============
+CG_FirstAnimFrame
+
+Returns true if the lerpframe is on its first frame of animation.
+Otherwise false.
+
+This is used to scale an animation into higher-speed without restarting
+the animation before it completes at normal speed, in the case of a looping
+animation (such as the leg running anim).
+===============
+*/
+static qboolean CG_FirstAnimFrame(lerpFrame_t *lf, qboolean torsoOnly, float speedScale)
+{
+	if (torsoOnly)
+	{
+		if (lf->animationTorsoSpeed == speedScale)
+		{
+			return qfalse;
+		}
+	}
+	else
+	{
+		if (lf->animationSpeed == speedScale)
+		{
+			return qfalse;
+		}
+	}
+
+	//I don't care where it is in the anim now, I am going to pick up from the same bone frame.
+/*
+	if (lf->animation->numFrames < 2)
+	{
+		return qtrue;
+	}
+
+	if (lf->animation->firstFrame == lf->frame)
+	{
+		return qtrue;
+	}
+*/
+
+	return qtrue;
+}
+
+/*
+===============
+CG_RunLerpFrame
+
+Sets cg.snap, cg.oldFrame, and cg.backlerp
+cg.time should be between oldFrameTime and frameTime after exit
+===============
+*/
+static void CG_RunLerpFrame( centity_t *cent, clientInfo_t *ci, lerpFrame_t *lf, qboolean flipState, int newAnimation, float speedScale, qboolean torsoOnly) 
+{
+	// debugging tool to get no animations
+	if ( cg_animSpeed.integer == 0 ) {
+		lf->oldFrame = lf->frame = lf->backlerp = 0;
+		return;
+	}
+
+	// see if the animation sequence is switching
+	if (cent->currentState.forceFrame)
+	{
+		if (lf->lastForcedFrame != cent->currentState.forceFrame)
+		{
+			int flags = BONE_ANIM_OVERRIDE_FREEZE|BONE_ANIM_BLEND;
+			float animSpeed = 1.0f;
+			trap_G2API_SetBoneAnim(cent->ghoul2, 0, "lower_lumbar", cent->currentState.forceFrame, cent->currentState.forceFrame+1, flags, animSpeed, cg.time, -1, 150);
+			trap_G2API_SetBoneAnim(cent->ghoul2, 0, "model_root", cent->currentState.forceFrame, cent->currentState.forceFrame+1, flags, animSpeed, cg.time, -1, 150);
+			trap_G2API_SetBoneAnim(cent->ghoul2, 0, "Motion", cent->currentState.forceFrame, cent->currentState.forceFrame+1, flags, animSpeed, cg.time, -1, 150);
+		}
+
+		lf->lastForcedFrame = cent->currentState.forceFrame;
+
+		lf->animationNumber = 0;
+	}
+	else
+	{
+		lf->lastForcedFrame = -1;
+
+		if ( (newAnimation != lf->animationNumber || cent->currentState.brokenLimbs != ci->brokenLimbs || lf->lastFlip != flipState || !lf->animation) || (CG_FirstAnimFrame(lf, torsoOnly, speedScale)) ) 
+		{
+			CG_SetLerpFrameAnimation( cent, ci, lf, newAnimation, speedScale, torsoOnly, flipState);
+		}
+	}
+
+	lf->lastFlip = flipState;
+
+	if ( lf->frameTime > cg.time + 200 ) {
+		lf->frameTime = cg.time;
+	}
+
+	if ( lf->oldFrameTime > cg.time ) {
+		lf->oldFrameTime = cg.time;
+	}
+	
+	// calculate current lerp value
+	if ( lf->frameTime == lf->oldFrameTime ) {
+		lf->backlerp = 0;
+	} else {
+		lf->backlerp = 1.0 - (float)( cg.time - lf->oldFrameTime ) / ( lf->frameTime - lf->oldFrameTime );
+	}
+}
+
+
+/*
+===============
+CG_ClearLerpFrame
+===============
+*/
+static void CG_ClearLerpFrame( centity_t *cent, clientInfo_t *ci, lerpFrame_t *lf, int animationNumber, qboolean torsoOnly) {
+	lf->frameTime = lf->oldFrameTime = cg.time;
+	CG_SetLerpFrameAnimation( cent, ci, lf, animationNumber, 1, torsoOnly, qfalse );
+
+	if ( lf->animation->frameLerp < 0 )
+	{//Plays backwards
+		lf->oldFrame = lf->frame = (lf->animation->firstFrame + lf->animation->numFrames);
+	}
+	else
+	{
+		lf->oldFrame = lf->frame = lf->animation->firstFrame;
+	}
+}
+
+
+/*
+===============
+CG_PlayerAnimation
+===============
+*/
+#include "../namespace_begin.h"
+qboolean PM_WalkingAnim( int anim );
+#include "../namespace_end.h"
+
+static void CG_PlayerAnimation( centity_t *cent, int *legsOld, int *legs, float *legsBackLerp,
+						int *torsoOld, int *torso, float *torsoBackLerp ) {
+	clientInfo_t	*ci;
+	int				clientNum;
+	float			speedScale;
+
+	clientNum = cent->currentState.clientNum;
+
+	if ( cg_noPlayerAnims.integer ) {
+		*legsOld = *legs = *torsoOld = *torso = 0;
+		return;
+	}
+
+	if (!PM_RunningAnim(cent->currentState.legsAnim) &&
+		!PM_WalkingAnim(cent->currentState.legsAnim))
+	{ //if legs are not in a walking/running anim then just animate at standard speed
+		speedScale = 1.0f;
+	}
+	else if (cent->currentState.forcePowersActive & (1 << FP_RAGE))
+	{
+		speedScale = 1.3f;
+	}
+	else if (cent->currentState.forcePowersActive & (1 << FP_SPEED))
+	{
+		speedScale = 1.7f;
+	}
+	else
+	{
+		speedScale = 1.0f;
+	}
+
+	if (cent->currentState.eType == ET_NPC)
+	{
+		ci = cent->npcClient;
+		assert(ci);
+	}
+	else
+	{
+		ci = &cgs.clientinfo[ clientNum ];
+	}
+
+	CG_RunLerpFrame( cent, ci, &cent->pe.legs, cent->currentState.legsFlip, cent->currentState.legsAnim, speedScale, qfalse);
+
+	if (!(cent->currentState.forcePowersActive & (1 << FP_RAGE)))
+	{ //don't affect torso anim speed unless raged
+		speedScale = 1.0f;
+	}
+	else
+	{
+		speedScale = 1.7f;
+	}
+
+	*legsOld = cent->pe.legs.oldFrame;
+	*legs = cent->pe.legs.frame;
+	*legsBackLerp = cent->pe.legs.backlerp;
+
+	// If this is not a vehicle, you may lerm the frame (since vehicles never have a torso anim). -AReis
+	if ( cent->currentState.NPC_class != CLASS_VEHICLE )
+	{	
+		CG_RunLerpFrame( cent, ci, &cent->pe.torso, cent->currentState.torsoFlip, cent->currentState.torsoAnim, speedScale, qtrue );
+
+		*torsoOld = cent->pe.torso.oldFrame;
+		*torso = cent->pe.torso.frame;
+		*torsoBackLerp = cent->pe.torso.backlerp;
+	}
+}
+
+
+
+
+/*
+=============================================================================
+
+PLAYER ANGLES
+
+=============================================================================
+*/
+
+#if 0
+typedef struct boneAngleParms_s {
+	void *ghoul2;
+	int modelIndex;
+	char *boneName;
+	vec3_t angles;
+	int flags;
+	int up;
+	int right;
+	int forward;
+	qhandle_t *modelList;
+	int blendTime;
+	int currentTime;
+
+	qboolean refreshSet;
+} boneAngleParms_t;
+
+boneAngleParms_t cgBoneAnglePostSet;
+#endif
+
+void CG_G2SetBoneAngles(void *ghoul2, int modelIndex, const char *boneName, const vec3_t angles, const int flags,
+								const int up, const int right, const int forward, qhandle_t *modelList,
+								int blendTime , int currentTime )
+{ //we want to hold off on setting the bone angles until the end of the frame, because every time we set
+  //them the entire skeleton has to be reconstructed.
+#if 0
+	//This function should ONLY be called from CG_Player() or a function that is called only within CG_Player().
+	//At the end of the frame we will check to use this information to call SetBoneAngles
+	memset(&cgBoneAnglePostSet, 0, sizeof(cgBoneAnglePostSet));
+	cgBoneAnglePostSet.ghoul2 = ghoul2;
+	cgBoneAnglePostSet.modelIndex = modelIndex;
+	cgBoneAnglePostSet.boneName = (char *)boneName;
+
+	cgBoneAnglePostSet.angles[0] = angles[0];
+	cgBoneAnglePostSet.angles[1] = angles[1];
+	cgBoneAnglePostSet.angles[2] = angles[2];
+
+	cgBoneAnglePostSet.flags = flags;
+	cgBoneAnglePostSet.up = up;
+	cgBoneAnglePostSet.right = right;
+	cgBoneAnglePostSet.forward = forward;
+	cgBoneAnglePostSet.modelList = modelList;
+	cgBoneAnglePostSet.blendTime = blendTime;
+	cgBoneAnglePostSet.currentTime = currentTime;
+
+	cgBoneAnglePostSet.refreshSet = qtrue;
+#endif
+	//We don't want to go with the delayed approach, we want out bolt points and everything to be updated in realtime.
+	//We'll just take the reconstructs and live with them.
+	trap_G2API_SetBoneAngles(ghoul2, modelIndex, boneName, angles, flags, up, right, forward, modelList,
+		blendTime, currentTime);
+}
+
+/*
+================
+CG_Rag_Trace
+
+Variant on CG_Trace. Doesn't trace for ents because ragdoll engine trace code has no entity
+trace access. Maybe correct this sometime, so bmodel col. at least works with ragdoll.
+But I don't want to slow it down..
+================
+*/
+void	CG_Rag_Trace( trace_t *result, const vec3_t start, const vec3_t mins, const vec3_t maxs, const vec3_t end, 
+					 int skipNumber, int mask ) {
+	trap_CM_BoxTrace ( result, start, end, mins, maxs, 0, mask);
+	result->entityNum = result->fraction != 1.0 ? ENTITYNUM_WORLD : ENTITYNUM_NONE;
+}
+
+//#define _RAG_BOLT_TESTING
+
+#ifdef _RAG_BOLT_TESTING
+void CG_TempTestFunction(centity_t *cent, vec3_t forcedAngles)
+{
+	mdxaBone_t boltMatrix;
+	vec3_t tAngles;
+	vec3_t bOrg;
+	vec3_t bDir;
+	vec3_t uOrg;
+
+	VectorSet(tAngles, 0, cent->lerpAngles[YAW], 0);
+
+	trap_G2API_GetBoltMatrix(cent->ghoul2, 1, 0, &boltMatrix, tAngles, cent->lerpOrigin,
+		cg.time, cgs.gameModels, cent->modelScale);
+	BG_GiveMeVectorFromMatrix(&boltMatrix, ORIGIN, bOrg);
+	BG_GiveMeVectorFromMatrix(&boltMatrix, NEGATIVE_Y, bDir);
+
+	VectorMA(bOrg, 40, bDir, uOrg);
+
+	CG_TestLine(bOrg, uOrg, 50, 0x0000ff, 1);
+
+	cent->turAngles[YAW] = forcedAngles[YAW];
+}
+#endif
+
+//list of valid ragdoll effectors
+static const char *cg_effectorStringTable[] =
+{ //commented out the ones I don't want dragging to affect
+//	"thoracic",
+//	"rhand",
+	"lhand",
+	"rtibia",
+	"ltibia",
+	"rtalus",
+	"ltalus",
+//	"rradiusX",
+	"lradiusX",
+	"rfemurX",
+	"lfemurX",
+//	"ceyebrow",
+	NULL //always terminate
+};
+
+//we want to see which way the pelvis is facing to get a relatively oriented base settling frame
+//this is to avoid the arms stretching in opposite directions on the body trying to reach the base
+//pose if the pelvis is flipped opposite of the base pose or something -rww
+static int CG_RagAnimForPositioning(centity_t *cent)
+{
+	int bolt;
+	vec3_t dir;
+	mdxaBone_t matrix;
+
+	assert(cent->ghoul2);
+	bolt = trap_G2API_AddBolt(cent->ghoul2, 0, "pelvis");
+	assert(bolt > -1);
+
+	trap_G2API_GetBoltMatrix(cent->ghoul2, 0, bolt, &matrix, cent->turAngles, cent->lerpOrigin,
+		cg.time, cgs.gameModels, cent->modelScale);
+	BG_GiveMeVectorFromMatrix(&matrix, NEGATIVE_Z, dir);
+
+	if (dir[2] > 0.0f)
+	{ //facing up
+		return BOTH_DEADFLOP2;
+	}
+	else
+	{ //facing down
+		return BOTH_DEADFLOP1;
+	}
+}
+
+//rww - cgame interface for the ragdoll stuff.
+//Returns qtrue if the entity is now in a ragdoll state, otherwise qfalse.
+qboolean CG_RagDoll(centity_t *cent, vec3_t forcedAngles)
+{
+	vec3_t usedOrg;
+	qboolean inSomething = qfalse;
+	int ragAnim;//BOTH_DEAD1; //BOTH_DEATH1;
+
+	if (!cg_ragDoll.integer)
+	{
+		return qfalse;
+	}
+
+	if (cent->localAnimIndex)
+	{ //don't rag non-humanoids
+		return qfalse;
+	}
+
+	VectorCopy(cent->lerpOrigin, usedOrg);
+
+	if (!cent->isRagging)
+	{ //If we're not in a ragdoll state, perform the checks.
+		if (cent->currentState.eFlags & EF_RAG)
+		{ //want to go into it no matter what then
+			inSomething = qtrue;
+		}
+		else if (cent->currentState.groundEntityNum == ENTITYNUM_NONE)
+		{
+			vec3_t cVel;
+
+			VectorCopy(cent->currentState.pos.trDelta, cVel);
+
+			if (VectorNormalize(cVel) > 400)
+			{ //if he's flying through the air at a good enough speed, switch into ragdoll
+				inSomething = qtrue;
+			}
+		}
+
+		if (cent->currentState.eType == ET_BODY)
+		{ //just rag bodies immediately if their own was ragging on respawn
+			if (cent->ownerRagging)
+			{
+				cent->isRagging = qtrue;
+				return qfalse;
+			}
+		}
+
+		if (cg_ragDoll.integer > 1)
+		{
+			inSomething = qtrue;
+		}
+
+		if (!inSomething)
+		{
+			int anim = (cent->currentState.legsAnim);
+			int dur = (bgAllAnims[cent->localAnimIndex].anims[anim].numFrames-1) * fabs((float)(bgAllAnims[cent->localAnimIndex].anims[anim].frameLerp));
+			int i = 0;
+			int boltChecks[5];
+			vec3_t boltPoints[5];
+			vec3_t trStart, trEnd;
+			vec3_t tAng;
+			qboolean deathDone = qfalse;
+			trace_t tr;
+			mdxaBone_t boltMatrix;
+
+			VectorSet( tAng, cent->turAngles[PITCH], cent->turAngles[YAW], cent->turAngles[ROLL] );
+
+			if (cent->pe.legs.animationTime > 50 && (cg.time - cent->pe.legs.animationTime) > dur)
+			{ //Looks like the death anim is done playing
+				deathDone = qtrue;
+			}
+
+			if (deathDone)
+			{ //only trace from the hands if the death anim is already done.
+				boltChecks[0] = trap_G2API_AddBolt(cent->ghoul2, 0, "rhand");
+				boltChecks[1] = trap_G2API_AddBolt(cent->ghoul2, 0, "lhand");
+			}
+			else
+			{ //otherwise start the trace loop at the cranium.
+				i = 2;
+			}
+			boltChecks[2] = trap_G2API_AddBolt(cent->ghoul2, 0, "cranium");
+			//boltChecks[3] = trap_G2API_AddBolt(cent->ghoul2, 0, "rtarsal");
+			//boltChecks[4] = trap_G2API_AddBolt(cent->ghoul2, 0, "ltarsal");
+			boltChecks[3] = trap_G2API_AddBolt(cent->ghoul2, 0, "rtalus");
+			boltChecks[4] = trap_G2API_AddBolt(cent->ghoul2, 0, "ltalus");
+
+			//This may seem bad, but since we have a bone cache now it should manage to not be too disgustingly slow.
+			//Do the head first, because the hands reference it anyway.
+			trap_G2API_GetBoltMatrix(cent->ghoul2, 0, boltChecks[2], &boltMatrix, tAng, cent->lerpOrigin, cg.time, cgs.gameModels, cent->modelScale);
+			BG_GiveMeVectorFromMatrix(&boltMatrix, ORIGIN, boltPoints[2]);
+
+			while (i < 5)
+			{
+				if (i < 2)
+				{ //when doing hands, trace to the head instead of origin
+					trap_G2API_GetBoltMatrix(cent->ghoul2, 0, boltChecks[i], &boltMatrix, tAng, cent->lerpOrigin, cg.time, cgs.gameModels, cent->modelScale);
+					BG_GiveMeVectorFromMatrix(&boltMatrix, ORIGIN, boltPoints[i]);
+					VectorCopy(boltPoints[i], trStart);
+					VectorCopy(boltPoints[2], trEnd);
+				}
+				else
+				{
+					if (i > 2)
+					{ //2 is the head, which already has the bolt point.
+						trap_G2API_GetBoltMatrix(cent->ghoul2, 0, boltChecks[i], &boltMatrix, tAng, cent->lerpOrigin, cg.time, cgs.gameModels, cent->modelScale);
+						BG_GiveMeVectorFromMatrix(&boltMatrix, ORIGIN, boltPoints[i]);
+					}
+					VectorCopy(boltPoints[i], trStart);
+					VectorCopy(cent->lerpOrigin, trEnd);
+				}
+
+				//Now that we have all that sorted out, trace between the two points we desire.
+				CG_Rag_Trace(&tr, trStart, NULL, NULL, trEnd, cent->currentState.number, MASK_SOLID);
+
+				if (tr.fraction != 1.0 || tr.startsolid || tr.allsolid)
+				{ //Hit something or start in solid, so flag it and break.
+					//This is a slight hack, but if we aren't done with the death anim, we don't really want to
+					//go into ragdoll unless our body has a relatively "flat" pitch.
+#if 0
+					vec3_t vSub;
+
+					//Check the pitch from the head to the right foot (should be reasonable)
+					VectorSubtract(boltPoints[2], boltPoints[3], vSub);
+					VectorNormalize(vSub);
+					vectoangles(vSub, vSub);
+
+					if (deathDone || (vSub[PITCH] < 50 && vSub[PITCH] > -50))
+					{
+						inSomething = qtrue;
+					}
+#else
+					inSomething = qtrue;
+#endif
+					break;
+				}
+
+				i++;
+			}
+		}
+
+		if (inSomething)
+		{
+			cent->isRagging = qtrue;
+#if 0
+			VectorClear(cent->lerpOriginOffset);
+#endif
+		}
+	}
+
+	if (cent->isRagging)
+	{ //We're in a ragdoll state, so make the call to keep our positions updated and whatnot.
+		sharedRagDollParams_t tParms;
+		sharedRagDollUpdateParams_t tuParms;
+
+		ragAnim = CG_RagAnimForPositioning(cent);
+
+		if (cent->ikStatus)
+		{ //ik must be reset before ragdoll is started, or you'll get some interesting results.
+			trap_G2API_SetBoneIKState(cent->ghoul2, cg.time, NULL, IKS_NONE, NULL);
+			cent->ikStatus = qfalse;
+		}
+
+		//these will be used as "base" frames for the ragoll settling.
+		tParms.startFrame = bgAllAnims[cent->localAnimIndex].anims[ragAnim].firstFrame;// + bgAllAnims[cent->localAnimIndex].anims[ragAnim].numFrames;
+		tParms.endFrame = bgAllAnims[cent->localAnimIndex].anims[ragAnim].firstFrame + bgAllAnims[cent->localAnimIndex].anims[ragAnim].numFrames;
+#if 0
+		{
+			float animSpeed = 0;
+			int blendTime = 600;
+			int flags = 0;//BONE_ANIM_OVERRIDE_FREEZE;
+
+			if (bgAllAnims[cent->localAnimIndex].anims[ragAnim].loopFrames != -1)
+			{
+				flags = BONE_ANIM_OVERRIDE_LOOP;
+			}
+
+			/*
+			if (cg_animBlend.integer)
+			{
+				flags |= BONE_ANIM_BLEND;
+			}
+			*/
+
+			animSpeed = 50.0f / bgAllAnims[cent->localAnimIndex].anims[ragAnim].frameLerp;
+			trap_G2API_SetBoneAnim(cent->ghoul2, 0, "lower_lumbar", tParms.startFrame, tParms.endFrame, flags, animSpeed,cg.time, -1, blendTime);
+			trap_G2API_SetBoneAnim(cent->ghoul2, 0, "Motion", tParms.startFrame, tParms.endFrame, flags, animSpeed, cg.time, -1, blendTime);
+			trap_G2API_SetBoneAnim(cent->ghoul2, 0, "model_root", tParms.startFrame, tParms.endFrame, flags, animSpeed, cg.time, -1, blendTime);
+		}
+#elif 1 //with my new method of doing things I want it to continue the anim
+		{
+			float currentFrame;
+			int startFrame, endFrame;
+			int flags;
+			float animSpeed;
+
+			if (trap_G2API_GetBoneAnim(cent->ghoul2, "model_root", cg.time, &currentFrame, &startFrame, &endFrame, &flags, &animSpeed, cgs.gameModels, 0))
+			{ //lock the anim on the current frame.
+				int blendTime = 500;
+				animation_t *curAnim = &bgAllAnims[cent->localAnimIndex].anims[cent->currentState.legsAnim];
+
+				if (currentFrame >= (curAnim->firstFrame + curAnim->numFrames-1))
+				{ //this is sort of silly but it works for now.
+					currentFrame = (curAnim->firstFrame + curAnim->numFrames-2);
+				}
+
+				trap_G2API_SetBoneAnim(cent->ghoul2, 0, "lower_lumbar", currentFrame, currentFrame+1, flags, animSpeed,cg.time, currentFrame, blendTime);
+				trap_G2API_SetBoneAnim(cent->ghoul2, 0, "model_root", currentFrame, currentFrame+1, flags, animSpeed, cg.time, currentFrame, blendTime);
+				trap_G2API_SetBoneAnim(cent->ghoul2, 0, "Motion", currentFrame, currentFrame+1, flags, animSpeed, cg.time, currentFrame, blendTime);
+			}
+		}
+#endif
+		CG_G2SetBoneAngles(cent->ghoul2, 0, "upper_lumbar", vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, cgs.gameModels, 0, cg.time);
+		CG_G2SetBoneAngles(cent->ghoul2, 0, "lower_lumbar", vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, cgs.gameModels, 0, cg.time);
+		CG_G2SetBoneAngles(cent->ghoul2, 0, "thoracic", vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, cgs.gameModels, 0, cg.time);
+		CG_G2SetBoneAngles(cent->ghoul2, 0, "cervical", vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, cgs.gameModels, 0, cg.time);
+
+		VectorCopy(forcedAngles, tParms.angles);
+		VectorCopy(usedOrg, tParms.position);
+		VectorCopy(cent->modelScale, tParms.scale);
+		tParms.me = cent->currentState.number;
+
+		tParms.collisionType = 1;
+		tParms.RagPhase = RP_DEATH_COLLISION;
+		tParms.fShotStrength = 4;
+
+		trap_G2API_SetRagDoll(cent->ghoul2, &tParms);
+
+		VectorCopy(forcedAngles, tuParms.angles);
+		VectorCopy(usedOrg, tuParms.position);
+		VectorCopy(cent->modelScale, tuParms.scale);
+		tuParms.me = cent->currentState.number;
+		tuParms.settleFrame = tParms.endFrame-1;
+
+		if (cent->currentState.groundEntityNum != ENTITYNUM_NONE)
+		{
+			VectorClear(tuParms.velocity);
+		}
+		else
+		{
+			VectorScale(cent->currentState.pos.trDelta, 2.0f, tuParms.velocity);
+		}
+
+		trap_G2API_AnimateG2Models(cent->ghoul2, cg.time, &tuParms);
+
+		//So if we try to get a bolt point it's still correct
+		cent->turAngles[YAW] = 
+		cent->lerpAngles[YAW] = 
+		cent->pe.torso.yawAngle = 
+		cent->pe.legs.yawAngle = forcedAngles[YAW];
+
+		if (cent->currentState.ragAttach &&
+			(cent->currentState.eType != ET_NPC || cent->currentState.NPC_class != CLASS_VEHICLE))
+		{
+			centity_t *grabEnt;
+
+			if (cent->currentState.ragAttach == ENTITYNUM_NONE)
+			{ //switch cl 0 and entitynum_none, so we can operate on the "if non-0" concept
+				grabEnt = &cg_entities[0];
+			}
+			else
+			{
+				grabEnt = &cg_entities[cent->currentState.ragAttach];
+			}
+
+			if (grabEnt->ghoul2)
+			{
+				mdxaBone_t matrix;
+				vec3_t bOrg;
+				vec3_t thisHand;
+				vec3_t hands;
+				vec3_t pcjMin, pcjMax;
+				vec3_t pDif;
+				vec3_t thorPoint;
+				float difLen;
+				int thorBolt;
+
+				//Get the person who is holding our hand's hand location
+				trap_G2API_GetBoltMatrix(grabEnt->ghoul2, 0, 0, &matrix, grabEnt->turAngles, grabEnt->lerpOrigin,
+					cg.time, cgs.gameModels, grabEnt->modelScale);
+				BG_GiveMeVectorFromMatrix(&matrix, ORIGIN, bOrg);
+
+				//Get our hand's location
+				trap_G2API_GetBoltMatrix(cent->ghoul2, 0, 0, &matrix, cent->turAngles, cent->lerpOrigin,
+					cg.time, cgs.gameModels, cent->modelScale);
+				BG_GiveMeVectorFromMatrix(&matrix, ORIGIN, thisHand);
+
+				//Get the position of the thoracic bone for hinting its velocity later on
+				thorBolt = trap_G2API_AddBolt(cent->ghoul2, 0, "thoracic");
+				trap_G2API_GetBoltMatrix(cent->ghoul2, 0, thorBolt, &matrix, cent->turAngles, cent->lerpOrigin,
+					cg.time, cgs.gameModels, cent->modelScale);
+				BG_GiveMeVectorFromMatrix(&matrix, ORIGIN, thorPoint);
+
+				VectorSubtract(bOrg, thisHand, hands);
+
+				if (VectorLength(hands) < 3.0f)
+				{
+					trap_G2API_RagForceSolve(cent->ghoul2, qfalse);
+				}
+				else
+				{
+					trap_G2API_RagForceSolve(cent->ghoul2, qtrue);
+				}
+
+				//got the hand pos of him, now we want to make our hand go to it
+				trap_G2API_RagEffectorGoal(cent->ghoul2, "rhand", bOrg);
+				trap_G2API_RagEffectorGoal(cent->ghoul2, "rradius", bOrg);
+				trap_G2API_RagEffectorGoal(cent->ghoul2, "rradiusX", bOrg);
+				trap_G2API_RagEffectorGoal(cent->ghoul2, "rhumerusX", bOrg);
+				trap_G2API_RagEffectorGoal(cent->ghoul2, "rhumerus", bOrg);
+
+				//Make these two solve quickly so we can update decently
+				trap_G2API_RagPCJGradientSpeed(cent->ghoul2, "rhumerus", 1.5f);
+				trap_G2API_RagPCJGradientSpeed(cent->ghoul2, "rradius", 1.5f);
+
+				//Break the constraints on them I suppose
+				VectorSet(pcjMin, -999, -999, -999);
+				VectorSet(pcjMax, 999, 999, 999);
+				trap_G2API_RagPCJConstraint(cent->ghoul2, "rhumerus", pcjMin, pcjMax);
+				trap_G2API_RagPCJConstraint(cent->ghoul2, "rradius", pcjMin, pcjMax);
+
+				cent->overridingBones = cg.time + 2000;
+
+				//hit the thoracic velocity to the hand point
+				VectorSubtract(bOrg, thorPoint, hands);
+				VectorNormalize(hands);
+				VectorScale(hands, 2048.0f, hands);
+				trap_G2API_RagEffectorKick(cent->ghoul2, "thoracic", hands);
+				trap_G2API_RagEffectorKick(cent->ghoul2, "ceyebrow", hands);
+
+				VectorSubtract(cent->ragLastOrigin, cent->lerpOrigin, pDif);
+				VectorCopy(cent->lerpOrigin, cent->ragLastOrigin);
+
+				if (cent->ragLastOriginTime >= cg.time && cent->currentState.groundEntityNum != ENTITYNUM_NONE)
+				{ //make sure it's reasonably updated
+					difLen = VectorLength(pDif);
+					if (difLen > 0.0f)
+					{ //if we're being dragged, then kick all the bones around a bit
+						vec3_t dVel;
+						vec3_t rVel;
+						int i = 0;
+
+						if (difLen < 12.0f)
+						{
+							VectorScale(pDif, 12.0f/difLen, pDif);
+							difLen = 12.0f;
+						}
+
+						while (cg_effectorStringTable[i])
+						{
+							VectorCopy(pDif, dVel);
+							dVel[2] = 0;
+
+							//Factor in a random velocity
+							VectorSet(rVel, flrand(-0.1f, 0.1f), flrand(-0.1f, 0.1f), flrand(0.1f, 0.5));
+							VectorScale(rVel, 8.0f, rVel);
+
+							VectorAdd(dVel, rVel, dVel);
+							VectorScale(dVel, 10.0f, dVel);
+
+							trap_G2API_RagEffectorKick(cent->ghoul2, cg_effectorStringTable[i], dVel);
+
+#if 0
+							{
+								mdxaBone_t bm;
+								vec3_t borg;
+								vec3_t vorg;
+								int b = trap_G2API_AddBolt(cent->ghoul2, 0, cg_effectorStringTable[i]);
+
+								trap_G2API_GetBoltMatrix(cent->ghoul2, 0, b, &bm, cent->turAngles, cent->lerpOrigin, cg.time,
+									cgs.gameModels, cent->modelScale);
+								BG_GiveMeVectorFromMatrix(&bm, ORIGIN, borg);
+
+								VectorMA(borg, 1.0f, dVel, vorg);
+
+								CG_TestLine(borg, vorg, 50, 0x0000ff, 1);
+							}
+#endif
+
+							i++;
+						}
+					}
+				}
+				cent->ragLastOriginTime = cg.time + 1000;
+			}
+		}
+		else if (cent->overridingBones)
+		{ //reset things to their normal rag state
+			vec3_t pcjMin, pcjMax;
+			vec3_t dVel;
+
+			//got the hand pos of him, now we want to make our hand go to it
+			trap_G2API_RagEffectorGoal(cent->ghoul2, "rhand", NULL);
+			trap_G2API_RagEffectorGoal(cent->ghoul2, "rradius", NULL);
+			trap_G2API_RagEffectorGoal(cent->ghoul2, "rradiusX", NULL);
+			trap_G2API_RagEffectorGoal(cent->ghoul2, "rhumerusX", NULL);
+			trap_G2API_RagEffectorGoal(cent->ghoul2, "rhumerus", NULL);
+
+			VectorSet(dVel, 0.0f, 0.0f, -64.0f);
+			trap_G2API_RagEffectorKick(cent->ghoul2, "rhand", dVel);
+
+			trap_G2API_RagPCJGradientSpeed(cent->ghoul2, "rhumerus", 0.0f);
+			trap_G2API_RagPCJGradientSpeed(cent->ghoul2, "rradius", 0.0f);
+
+			VectorSet(pcjMin,-100.0f,-40.0f,-15.0f);
+			VectorSet(pcjMax,-15.0f,80.0f,15.0f);
+			trap_G2API_RagPCJConstraint(cent->ghoul2, "rhumerus", pcjMin, pcjMax);
+
+			VectorSet(pcjMin,-25.0f,-20.0f,-20.0f);
+			VectorSet(pcjMax,90.0f,20.0f,-20.0f);
+			trap_G2API_RagPCJConstraint(cent->ghoul2, "rradius", pcjMin, pcjMax);
+
+			if (cent->overridingBones < cg.time)
+			{
+				trap_G2API_RagForceSolve(cent->ghoul2, qfalse);
+				cent->overridingBones = 0;
+			}
+			else
+			{
+				trap_G2API_RagForceSolve(cent->ghoul2, qtrue);
+			}
+		}
+
+		return qtrue;
+	}
+
+	return qfalse;
+}
+
+//set the bone angles of this client entity based on data from the server -rww
+void CG_G2ServerBoneAngles(centity_t *cent)
+{
+	int i = 0;
+	int bone = cent->currentState.boneIndex1;
+	int flags, up, right, forward;
+	vec3_t boneAngles;
+
+	VectorCopy(cent->currentState.boneAngles1, boneAngles);
+
+	while (i < 4)
+	{ //cycle through the 4 bone index values on the entstate
+		if (bone)
+		{ //if it's non-0 then it could have something in it.
+			const char *boneName = CG_ConfigString(CS_G2BONES+bone);
+
+			if (boneName && boneName[0])
+			{ //got the bone, now set the angles from the corresponding entitystate boneangles value.
+				flags = BONE_ANGLES_POSTMULT;
+
+				//get the orientation out of our bit field
+				forward = (cent->currentState.boneOrient)&7; //3 bits from bit 0
+				right = (cent->currentState.boneOrient>>3)&7; //3 bits from bit 3
+				up = (cent->currentState.boneOrient>>6)&7; //3 bits from bit 6
+
+				trap_G2API_SetBoneAngles(cent->ghoul2, 0, boneName, boneAngles, flags, up, right, forward, cgs.gameModels, 100, cg.time);
+			}
+		}
+
+		switch (i)
+		{
+		case 0:
+			bone = cent->currentState.boneIndex2;
+			VectorCopy(cent->currentState.boneAngles2, boneAngles);
+			break;
+		case 1:
+			bone = cent->currentState.boneIndex3;
+			VectorCopy(cent->currentState.boneAngles3, boneAngles);
+			break;
+		case 2:
+			bone = cent->currentState.boneIndex4;
+			VectorCopy(cent->currentState.boneAngles4, boneAngles);
+			break;
+		default:
+			break;
+		}
+
+		i++;
+	}
+}
+
+/*
+-------------------------
+CG_G2SetHeadBlink
+-------------------------
+*/
+static void CG_G2SetHeadBlink( centity_t *cent, qboolean bStart )
+{
+	vec3_t	desiredAngles;
+	int blendTime = 80;
+	qboolean bWink = qfalse;
+	const int hReye = trap_G2API_AddBolt( cent->ghoul2, 0, "reye" );
+	const int hLeye = trap_G2API_AddBolt( cent->ghoul2, 0, "leye" );
+
+	if (hLeye == -1)
+	{
+		return;
+	}
+
+	VectorClear(desiredAngles);
+
+	if (bStart)
+	{
+		desiredAngles[YAW] = -50;
+		if ( random() > 0.95f )
+		{
+			bWink = qtrue;
+			blendTime /=3;
+		}
+	}
+	trap_G2API_SetBoneAngles( cent->ghoul2, 0, "leye", desiredAngles,
+		BONE_ANGLES_POSTMULT, POSITIVE_Y, POSITIVE_Z, POSITIVE_X, NULL, blendTime, cg.time ); 
+
+	if (hReye == -1)
+	{
+		return;
+	}
+	
+	if (!bWink)
+	{
+		trap_G2API_SetBoneAngles( cent->ghoul2, 0, "reye", desiredAngles,
+			BONE_ANGLES_POSTMULT, POSITIVE_Y, POSITIVE_Z, POSITIVE_X, NULL, blendTime, cg.time ); 
+	}
+}
+
+/*
+-------------------------
+CG_G2SetHeadAnims
+-------------------------
+*/
+static void CG_G2SetHeadAnim( centity_t *cent, int anim )
+{
+	const int blendTime = 50;
+	const animation_t *animations = bgAllAnims[cent->localAnimIndex].anims;
+	int	animFlags = BONE_ANIM_OVERRIDE ;//| BONE_ANIM_BLEND;
+	// animSpeed is 1.0 if the frameLerp (ms/frame) is 50 (20 fps).
+//	float		timeScaleMod = (cg_timescale.value&&gent&&gent->s.clientNum==0&&!player_locked&&!MatrixMode&&gent->client->ps.forcePowersActive&(1<<FP_SPEED))?(1.0/cg_timescale.value):1.0;
+	const float		timeScaleMod = (cg_timescale.value)?(1.0/cg_timescale.value):1.0;
+	float animSpeed = 50.0f / animations[anim].frameLerp * timeScaleMod;
+	int	firstFrame;
+	int	lastFrame;
+
+	if (animations[anim].numFrames <= 0)
+	{
+		return;
+	}
+	if (anim == FACE_DEAD)
+	{
+		animFlags |= BONE_ANIM_OVERRIDE_FREEZE;
+	}
+	// animSpeed is 1.0 if the frameLerp (ms/frame) is 50 (20 fps).
+	if ( animSpeed < 0 )
+	{//play anim backwards
+		
+		lastFrame = animations[anim].firstFrame -1;
+		firstFrame = (animations[anim].numFrames -1) + animations[anim].firstFrame ;
+	}
+	else
+	{
+		firstFrame = animations[anim].firstFrame;
+		lastFrame = (animations[anim].numFrames) + animations[anim].firstFrame;
+	}
+
+	// first decide if we are doing an animation on the head already
+//	int startFrame, endFrame;
+//	const qboolean animatingHead =  gi.G2API_GetAnimRangeIndex(&gent->ghoul2[gent->playerModel], cent->gent->faceBone, &startFrame, &endFrame);
+	
+//	if (!animatingHead || ( animations[anim].firstFrame != startFrame ) )// only set the anim if we aren't going to do the same animation again
+	{
+	//	gi.G2API_SetBoneAnimIndex(&gent->ghoul2[gent->playerModel], cent->gent->faceBone,
+	//		firstFrame, lastFrame, animFlags, animSpeed, cg.time, -1, blendTime);
+		trap_G2API_SetBoneAnim(cent->ghoul2, 0, "face", firstFrame, lastFrame, animFlags, animSpeed,
+			cg.time, -1, blendTime);
+	}
+}
+
+qboolean CG_G2PlayerHeadAnims( centity_t *cent )
+{
+	clientInfo_t *ci = NULL;
+	int anim = -1;
+	int voiceVolume = 0;
+
+	if(cent->localAnimIndex > 1)
+	{ //only do this for humanoids
+		return qfalse;
+	}
+	
+	if (cent->noFace)
+	{	// i don't have a face
+		return qfalse;
+	}
+
+	if (cent->currentState.number < MAX_CLIENTS)
+	{
+		ci = &cgs.clientinfo[cent->currentState.number];
+	}
+	else
+	{
+		ci = cent->npcClient;
+	}
+
+	if (!ci)
+	{
+		return qfalse;
+	}
+
+	if ( cent->currentState.eFlags & EF_DEAD )
+	{//Dead people close their eyes and don't make faces!
+		anim = FACE_DEAD;
+		ci->facial_blink = -1;
+	}
+	else 
+	{
+		if (!ci->facial_blink)
+		{	// set the timers
+			ci->facial_blink = cg.time + flrand(4000.0, 8000.0);
+			ci->facial_frown = cg.time + flrand(6000.0, 10000.0);
+			ci->facial_aux = cg.time + flrand(6000.0, 10000.0);
+		}
+		
+		//are we blinking?
+		if (ci->facial_blink < 0)
+		{	// yes, check if we are we done blinking ?
+			if (-(ci->facial_blink) < cg.time)
+			{	// yes, so reset blink timer
+				ci->facial_blink = cg.time + flrand(4000.0, 8000.0);
+				CG_G2SetHeadBlink( cent, qfalse );	//stop the blink
+			}
+		}
+		else // no we aren't blinking 
+		{	
+			if (ci->facial_blink < cg.time)// but should we start ?
+			{
+				CG_G2SetHeadBlink( cent, qtrue );
+				if (ci->facial_blink == 1)
+				{//requested to stay shut by SET_FACEEYESCLOSED
+					ci->facial_blink = -(cg.time + 99999999.0f);// set blink timer
+				}
+				else
+				{
+					ci->facial_blink = -(cg.time + 300.0f);// set blink timer
+				}
+			} 
+		}
+		
+		voiceVolume = trap_S_GetVoiceVolume(cent->currentState.number);
+
+		if (voiceVolume > 0)	// if we aren't talking, then it will be 0, -1 for talking but paused
+		{
+			anim = FACE_TALK1 + voiceVolume -1;
+		}
+		else if (voiceVolume == 0)	//don't do aux if in a slient part of speech
+		{//not talking
+			if (ci->facial_aux < 0)	// are we auxing ?
+			{	//yes
+				if (-(ci->facial_aux) < cg.time)// are we done auxing ?
+				{	// yes, reset aux timer
+					ci->facial_aux = cg.time + flrand(7000.0, 10000.0);
+				}
+				else
+				{	// not yet, so choose aux
+					anim = FACE_ALERT;
+				}
+			}
+			else // no we aren't auxing 
+			{	// but should we start ?
+				if (ci->facial_aux < cg.time)
+				{//yes
+					anim = FACE_ALERT;
+					// set aux timer
+					ci->facial_aux = -(cg.time + 2000.0);
+				} 
+			}	
+			
+			if (anim != -1)	//we we are auxing, see if we should override with a frown
+			{	
+				if (ci->facial_frown < 0)// are we frowning ?
+				{	// yes, 
+					if (-(ci->facial_frown) < cg.time)//are we done frowning ?
+					{	// yes, reset frown timer
+						ci->facial_frown = cg.time + flrand(7000.0, 10000.0);
+					}
+					else 
+					{	// not yet, so choose frown
+						anim = FACE_FROWN;
+					}
+				}
+				else// no we aren't frowning 
+				{	// but should we start ?
+					if (ci->facial_frown < cg.time)
+					{
+						anim = FACE_FROWN;
+						// set frown timer
+						ci->facial_frown = -(cg.time + 2000.0);
+					}
+				}
+			}
+
+		}//talking
+	}//dead
+	if (anim != -1)
+	{
+		CG_G2SetHeadAnim( cent, anim );
+		return qtrue;
+	}
+	return qfalse;
+}
+
+
+static void CG_G2PlayerAngles( centity_t *cent, vec3_t legs[3], vec3_t legsAngles)
+{
+	clientInfo_t *ci;
+
+	//rww - now do ragdoll stuff
+	if ((cent->currentState.eFlags & EF_DEAD) || (cent->currentState.eFlags & EF_RAG))
+	{
+		vec3_t forcedAngles;
+
+		VectorClear(forcedAngles);
+		forcedAngles[YAW] = cent->lerpAngles[YAW];
+
+		if (CG_RagDoll(cent, forcedAngles))
+		{ //if we managed to go into the rag state, give our ent axis the forced angles and return.
+			AnglesToAxis( forcedAngles, legs );
+			VectorCopy(forcedAngles, legsAngles);
+			return;
+		}
+	}
+	else if (cent->isRagging)
+	{
+		cent->isRagging = qfalse;
+		trap_G2API_SetRagDoll(cent->ghoul2, NULL); //calling with null parms resets to no ragdoll.
+	}
+
+	if (cent->currentState.eType == ET_NPC)
+	{
+		ci = cent->npcClient;
+		assert(ci);
+	}
+	else
+	{
+		ci = &cgs.clientinfo[cent->currentState.number];
+	}
+
+	//rww - Quite possibly the most arguments for a function ever.
+	if (cent->localAnimIndex <= 1)
+	{ //don't do these things on non-humanoids
+		vec3_t lookAngles;
+		entityState_t *emplaced = NULL;
+
+		if (cent->currentState.hasLookTarget)
+		{
+			VectorSubtract(cg_entities[cent->currentState.lookTarget].lerpOrigin, cent->lerpOrigin, lookAngles);
+			vectoangles(lookAngles, lookAngles);
+			ci->lookTime = cg.time + 1000;
+		}
+		else
+		{
+			VectorCopy(cent->lerpAngles, lookAngles);
+		}
+		lookAngles[PITCH] = 0;
+
+		if (cent->currentState.otherEntityNum2)
+		{
+			emplaced = &cg_entities[cent->currentState.otherEntityNum2].currentState;
+		}
+
+		BG_G2PlayerAngles(cent->ghoul2, ci->bolt_motion, &cent->currentState, cg.time,
+			cent->lerpOrigin, cent->lerpAngles, legs, legsAngles, &cent->pe.torso.yawing, &cent->pe.torso.pitching,
+			&cent->pe.legs.yawing, &cent->pe.torso.yawAngle, &cent->pe.torso.pitchAngle, &cent->pe.legs.yawAngle,
+			cg.frametime, cent->turAngles, cent->modelScale, ci->legsAnim, ci->torsoAnim, &ci->corrTime,
+			lookAngles, ci->lastHeadAngles, ci->lookTime, emplaced, &ci->superSmoothTime);
+
+		if (cent->currentState.heldByClient && cent->currentState.heldByClient <= MAX_CLIENTS)
+		{ //then put our arm in this client's hand
+			//is index+1 because index 0 is valid.
+			int heldByIndex = cent->currentState.heldByClient-1;
+			centity_t *other = &cg_entities[heldByIndex];
+
+			if (other && other->ghoul2 && ci->bolt_lhand)
+			{
+				mdxaBone_t boltMatrix;
+				vec3_t boltOrg;
+
+				trap_G2API_GetBoltMatrix(other->ghoul2, 0, ci->bolt_lhand, &boltMatrix, other->turAngles, other->lerpOrigin, cg.time, cgs.gameModels, other->modelScale);
+				BG_GiveMeVectorFromMatrix(&boltMatrix, ORIGIN, boltOrg);
+
+				BG_IK_MoveArm(cent->ghoul2, ci->bolt_lhand, cg.time, &cent->currentState,
+					cent->currentState.torsoAnim/*BOTH_DEAD1*/, boltOrg, &cent->ikStatus, cent->lerpOrigin, cent->lerpAngles, cent->modelScale, 500, qfalse);
+			}
+		}
+		else if (cent->ikStatus)
+		{ //make sure we aren't IKing if we don't have anyone to hold onto us.
+			BG_IK_MoveArm(cent->ghoul2, ci->bolt_lhand, cg.time, &cent->currentState,
+				cent->currentState.torsoAnim/*BOTH_DEAD1*/, vec3_origin, &cent->ikStatus, cent->lerpOrigin, cent->lerpAngles, cent->modelScale, 500, qtrue);
+		}
+	}
+	else if ( cent->m_pVehicle && cent->m_pVehicle->m_pVehicleInfo->type == VH_WALKER )
+	{
+		vec3_t lookAngles;
+
+		VectorCopy(cent->lerpAngles, legsAngles);
+		legsAngles[PITCH] = 0;
+		AnglesToAxis( legsAngles, legs );
+
+		VectorCopy(cent->lerpAngles, lookAngles);
+		lookAngles[YAW] = lookAngles[ROLL] = 0;
+
+		BG_G2ATSTAngles( cent->ghoul2, cg.time, lookAngles );
+	}
+	else
+	{
+		if (cent->currentState.eType == ET_NPC &&
+			cent->currentState.NPC_class == CLASS_VEHICLE &&
+			cent->m_pVehicle &&
+			cent->m_pVehicle->m_pVehicleInfo->type == VH_FIGHTER)
+		{ //fighters actually want to take pitch and roll into account for the axial angles
+			VectorCopy(cent->lerpAngles, legsAngles);
+			AnglesToAxis( legsAngles, legs );
+		}
+		else if (cent->currentState.eType == ET_NPC &&
+			cent->currentState.m_iVehicleNum &&
+			cent->currentState.NPC_class != CLASS_VEHICLE )
+		{ //an NPC bolted to a vehicle should use the full angles
+			VectorCopy(cent->lerpAngles, legsAngles);
+			AnglesToAxis( legsAngles, legs );
+		}
+		else
+		{
+			vec3_t nhAngles;
+
+			if (cent->currentState.eType == ET_NPC &&
+				cent->currentState.NPC_class == CLASS_VEHICLE &&
+				cent->m_pVehicle &&
+				cent->m_pVehicle->m_pVehicleInfo->type == VH_SPEEDER)
+			{ //yeah, a hack, sorry.
+				VectorSet(nhAngles, 0, cent->lerpAngles[YAW], cent->lerpAngles[ROLL]);
+			}
+			else
+			{
+				VectorSet(nhAngles, 0, cent->lerpAngles[YAW], 0);
+			}
+			AnglesToAxis( nhAngles, legs );
+		}
+	}
+
+	//See if we have any bone angles sent from the server
+	CG_G2ServerBoneAngles(cent);
+}
+//==========================================================================
+
+/*
+===============
+CG_TrailItem
+===============
+*/
+#if 0
+static void CG_TrailItem( centity_t *cent, qhandle_t hModel ) {
+	refEntity_t		ent;
+	vec3_t			angles;
+	vec3_t			axis[3];
+
+	VectorCopy( cent->lerpAngles, angles );
+	angles[PITCH] = 0;
+	angles[ROLL] = 0;
+	AnglesToAxis( angles, axis );
+
+	memset( &ent, 0, sizeof( ent ) );
+	VectorMA( cent->lerpOrigin, -16, axis[0], ent.origin );
+	ent.origin[2] += 16;
+	angles[YAW] += 90;
+	AnglesToAxis( angles, ent.axis );
+
+	ent.hModel = hModel;
+	trap_R_AddRefEntityToScene( &ent );
+}
+#endif
+
+
+/*
+===============
+CG_PlayerFlag
+===============
+*/
+static void CG_PlayerFlag( centity_t *cent, qhandle_t hModel ) {
+	refEntity_t		ent;
+	vec3_t			angles;
+	vec3_t			axis[3];
+	vec3_t			boltOrg, tAng, getAng, right;
+	mdxaBone_t		boltMatrix;
+	clientInfo_t	*ci;
+
+	if (cent->currentState.number == cg.snap->ps.clientNum &&
+		!cg.renderingThirdPerson)
+	{
+		return;
+	}
+
+	if (!cent->ghoul2)
+	{
+		return;
+	}
+
+	if (cent->currentState.eType == ET_NPC)
+	{
+		ci = cent->npcClient;
+		assert(ci);
+	}
+	else
+	{
+		ci = &cgs.clientinfo[cent->currentState.number];
+	}
+
+	VectorSet( tAng, cent->turAngles[PITCH], cent->turAngles[YAW], cent->turAngles[ROLL] );
+
+	trap_G2API_GetBoltMatrix(cent->ghoul2, 0, ci->bolt_llumbar, &boltMatrix, tAng, cent->lerpOrigin, cg.time, cgs.gameModels, cent->modelScale);
+	BG_GiveMeVectorFromMatrix(&boltMatrix, ORIGIN, boltOrg);
+
+	BG_GiveMeVectorFromMatrix(&boltMatrix, POSITIVE_X, tAng);
+	vectoangles(tAng, tAng);
+
+	VectorCopy(cent->lerpAngles, angles);
+
+	boltOrg[2] -= 12;
+	VectorSet(getAng, 0, cent->lerpAngles[1], 0);
+	AngleVectors(getAng, 0, right, 0);
+	boltOrg[0] += right[0]*8;
+	boltOrg[1] += right[1]*8;
+	boltOrg[2] += right[2]*8;
+
+	angles[PITCH] = -cent->lerpAngles[PITCH]/2-30;
+	angles[YAW] = tAng[YAW]+270;
+
+	AnglesToAxis(angles, axis);
+
+	memset( &ent, 0, sizeof( ent ) );
+	VectorMA( boltOrg, 24, axis[0], ent.origin );
+
+	angles[ROLL] += 20;
+	AnglesToAxis( angles, ent.axis );
+
+	ent.hModel = hModel;
+
+	ent.modelScale[0] = 0.5;
+	ent.modelScale[1] = 0.5;
+	ent.modelScale[2] = 0.5;
+	ScaleModelAxis(&ent);
+
+	/*
+	if (cent->currentState.number == cg.snap->ps.clientNum)
+	{ //If we're the current client (in third person), render the flag on our back transparently
+		ent.renderfx |= RF_FORCE_ENT_ALPHA;
+		ent.shaderRGBA[3] = 100;
+	}
+	*/
+	//FIXME: Not doing this at the moment because sorting totally messes up
+
+	trap_R_AddRefEntityToScene( &ent );
+}
+
+
+/*
+===============
+CG_PlayerPowerups
+===============
+*/
+static void CG_PlayerPowerups( centity_t *cent, refEntity_t *torso ) {
+	int		powerups;
+	clientInfo_t	*ci;
+
+	powerups = cent->currentState.powerups;
+	if ( !powerups ) {
+		return;
+	}
+
+	// quad gives a dlight
+	if ( powerups & ( 1 << PW_QUAD ) ) {
+		trap_R_AddLightToScene( cent->lerpOrigin, 200 + (rand()&31), 0.2f, 0.2f, 1 );
+	}
+
+	if (cent->currentState.eType == ET_NPC)
+	{
+		ci = cent->npcClient;
+		assert(ci);
+	}
+	else
+	{
+		ci = &cgs.clientinfo[ cent->currentState.clientNum ];
+	}
+	// redflag
+	if ( powerups & ( 1 << PW_REDFLAG ) ) {
+		CG_PlayerFlag( cent, cgs.media.redFlagModel );
+		trap_R_AddLightToScene( cent->lerpOrigin, 200 + (rand()&31), 1.0, 0.2f, 0.2f );
+	}
+
+	// blueflag
+	if ( powerups & ( 1 << PW_BLUEFLAG ) ) {
+		CG_PlayerFlag( cent, cgs.media.blueFlagModel );
+		trap_R_AddLightToScene( cent->lerpOrigin, 200 + (rand()&31), 0.2f, 0.2f, 1.0 );
+	}
+
+	// neutralflag
+	if ( powerups & ( 1 << PW_NEUTRALFLAG ) ) {
+		trap_R_AddLightToScene( cent->lerpOrigin, 200 + (rand()&31), 1.0, 1.0, 1.0 );
+	}
+
+	// haste leaves smoke trails
+	/*
+	if ( powerups & ( 1 << PW_HASTE ) ) {
+		CG_HasteTrail( cent );
+	}
+	*/
+}
+
+
+/*
+===============
+CG_PlayerFloatSprite
+
+Float a sprite over the player's head
+===============
+*/
+static void CG_PlayerFloatSprite( centity_t *cent, qhandle_t shader ) {
+	int				rf;
+	refEntity_t		ent;
+
+	if ( cent->currentState.number == cg.snap->ps.clientNum && !cg.renderingThirdPerson ) {
+		rf = RF_THIRD_PERSON;		// only show in mirrors
+	} else {
+		rf = 0;
+	}
+
+	memset( &ent, 0, sizeof( ent ) );
+	VectorCopy( cent->lerpOrigin, ent.origin );
+	ent.origin[2] += 48;
+	ent.reType = RT_SPRITE;
+	ent.customShader = shader;
+	ent.radius = 10;
+	ent.renderfx = rf;
+	ent.shaderRGBA[0] = 255;
+	ent.shaderRGBA[1] = 255;
+	ent.shaderRGBA[2] = 255;
+	ent.shaderRGBA[3] = 255;
+	trap_R_AddRefEntityToScene( &ent );
+}
+
+
+
+/*
+===============
+CG_PlayerFloatSprite
+
+Same as above but allows custom RGBA values
+===============
+*/
+#if 0
+static void CG_PlayerFloatSpriteRGBA( centity_t *cent, qhandle_t shader, vec4_t rgba ) {
+	int				rf;
+	refEntity_t		ent;
+
+	if ( cent->currentState.number == cg.snap->ps.clientNum && !cg.renderingThirdPerson ) {
+		rf = RF_THIRD_PERSON;		// only show in mirrors
+	} else {
+		rf = 0;
+	}
+
+	memset( &ent, 0, sizeof( ent ) );
+	VectorCopy( cent->lerpOrigin, ent.origin );
+	ent.origin[2] += 48;
+	ent.reType = RT_SPRITE;
+	ent.customShader = shader;
+	ent.radius = 10;
+	ent.renderfx = rf;
+	ent.shaderRGBA[0] = rgba[0];
+	ent.shaderRGBA[1] = rgba[1];
+	ent.shaderRGBA[2] = rgba[2];
+	ent.shaderRGBA[3] = rgba[3];
+	trap_R_AddRefEntityToScene( &ent );
+}
+#endif
+
+
+/*
+===============
+CG_PlayerSprites
+
+Float sprites over the player's head
+===============
+*/
+static void CG_PlayerSprites( centity_t *cent ) {
+//	int		team;
+
+	if (cg.snap &&
+		CG_IsMindTricked(cent->currentState.trickedentindex,
+		cent->currentState.trickedentindex2,
+		cent->currentState.trickedentindex3,
+		cent->currentState.trickedentindex4,
+		cg.snap->ps.clientNum))
+	{
+		return; //this entity is mind-tricking the current client, so don't render it
+	}
+
+	if ( cent->currentState.eFlags & EF_CONNECTION ) {
+		CG_PlayerFloatSprite( cent, cgs.media.connectionShader );
+		return;
+	}
+
+	if (cent->vChatTime > cg.time)
+	{
+		CG_PlayerFloatSprite( cent, cgs.media.vchatShader );
+	}
+	else if ( cent->currentState.eType != ET_NPC && //don't draw talk balloons on NPCs
+		(cent->currentState.eFlags & EF_TALK) )
+	{
+		CG_PlayerFloatSprite( cent, cgs.media.balloonShader );
+		return;
+	}
+}
+
+/*
+===============
+CG_PlayerShadow
+
+Returns the Z component of the surface being shadowed
+
+  should it return a full plane instead of a Z?
+===============
+*/
+#define	SHADOW_DISTANCE		128
+static qboolean CG_PlayerShadow( centity_t *cent, float *shadowPlane ) {
+	vec3_t		end, mins = {-15, -15, 0}, maxs = {15, 15, 2};
+	trace_t		trace;
+	float		alpha;
+	float		radius = 24.0f;
+
+	*shadowPlane = 0;
+
+	if ( cg_shadows.integer == 0 ) {
+		return qfalse;
+	}
+
+	// no shadows when cloaked
+	if ( cent->currentState.powerups & ( 1 << PW_CLOAKED )) 
+	{
+		return qfalse;
+	}
+
+	if (cent->currentState.eFlags & EF_DEAD)
+	{
+		return qfalse;
+	}
+
+	if (CG_IsMindTricked(cent->currentState.trickedentindex,
+		cent->currentState.trickedentindex2,
+		cent->currentState.trickedentindex3,
+		cent->currentState.trickedentindex4,
+		cg.snap->ps.clientNum))
+	{
+		return qfalse; //this entity is mind-tricking the current client, so don't render it
+	}
+
+	if ( cg_shadows.integer == 1 )
+	{//dropshadow
+		if (cent->currentState.m_iVehicleNum &&
+			cent->currentState.NPC_class != CLASS_VEHICLE )
+		{//riding a vehicle, no dropshadow
+			return qfalse;
+		}
+	}
+	// send a trace down from the player to the ground
+	VectorCopy( cent->lerpOrigin, end );
+	if (cg_shadows.integer == 2)
+	{ //stencil
+		end[2] -= 4096.0f;
+
+		trap_CM_BoxTrace( &trace, cent->lerpOrigin, end, mins, maxs, 0, MASK_PLAYERSOLID );
+
+		if ( trace.fraction == 1.0 || trace.startsolid || trace.allsolid )
+		{
+			trace.endpos[2] = cent->lerpOrigin[2]-25.0f;
+		}
+	}
+	else
+	{
+		end[2] -= SHADOW_DISTANCE;
+
+		trap_CM_BoxTrace( &trace, cent->lerpOrigin, end, mins, maxs, 0, MASK_PLAYERSOLID );
+
+		// no shadow if too high
+		if ( trace.fraction == 1.0 || trace.startsolid || trace.allsolid ) {
+			return qfalse;
+		}
+	}
+
+	if (cg_shadows.integer == 2)
+	{ //stencil shadows need plane to be on ground
+		*shadowPlane = trace.endpos[2];
+	}
+	else
+	{
+		*shadowPlane = trace.endpos[2] + 1;
+	}
+
+	if ( cg_shadows.integer != 1 ) {	// no mark for stencil or projection shadows
+		return qtrue;
+	}
+
+	// fade the shadow out with height
+	alpha = 1.0 - trace.fraction;
+
+	// bk0101022 - hack / FPE - bogus planes?
+	//assert( DotProduct( trace.plane.normal, trace.plane.normal ) != 0.0f ) 
+
+	// add the mark as a temporary, so it goes directly to the renderer
+	// without taking a spot in the cg_marks array
+	if ( cent->currentState.NPC_class == CLASS_REMOTE
+		|| cent->currentState.NPC_class == CLASS_SEEKER )
+	{
+		radius = 8.0f;
+	}
+	CG_ImpactMark( cgs.media.shadowMarkShader, trace.endpos, trace.plane.normal, 
+		cent->pe.legs.yawAngle, alpha,alpha,alpha,1, qfalse, radius, qtrue );
+
+	return qtrue;
+}
+
+
+/*
+===============
+CG_PlayerSplash
+
+Draw a mark at the water surface
+===============
+*/
+static void CG_PlayerSplash( centity_t *cent ) {
+	vec3_t		start, end;
+	trace_t		trace;
+	int			contents;
+	polyVert_t	verts[4];
+
+	if ( !cg_shadows.integer ) {
+		return;
+	}
+
+	VectorCopy( cent->lerpOrigin, end );
+	end[2] -= 24;
+
+	// if the feet aren't in liquid, don't make a mark
+	// this won't handle moving water brushes, but they wouldn't draw right anyway...
+	contents = trap_CM_PointContents( end, 0 );
+	if ( !( contents & ( CONTENTS_WATER | CONTENTS_SLIME | CONTENTS_LAVA ) ) ) {
+		return;
+	}
+
+	VectorCopy( cent->lerpOrigin, start );
+	start[2] += 32;
+
+	// if the head isn't out of liquid, don't make a mark
+	contents = trap_CM_PointContents( start, 0 );
+	if ( contents & ( CONTENTS_SOLID | CONTENTS_WATER | CONTENTS_SLIME | CONTENTS_LAVA ) ) {
+		return;
+	}
+
+	// trace down to find the surface
+	trap_CM_BoxTrace( &trace, start, end, NULL, NULL, 0, ( CONTENTS_WATER | CONTENTS_SLIME | CONTENTS_LAVA ) );
+
+	if ( trace.fraction == 1.0 ) {
+		return;
+	}
+
+	// create a mark polygon
+	VectorCopy( trace.endpos, verts[0].xyz );
+	verts[0].xyz[0] -= 32;
+	verts[0].xyz[1] -= 32;
+	verts[0].st[0] = 0;
+	verts[0].st[1] = 0;
+	verts[0].modulate[0] = 255;
+	verts[0].modulate[1] = 255;
+	verts[0].modulate[2] = 255;
+	verts[0].modulate[3] = 255;
+
+	VectorCopy( trace.endpos, verts[1].xyz );
+	verts[1].xyz[0] -= 32;
+	verts[1].xyz[1] += 32;
+	verts[1].st[0] = 0;
+	verts[1].st[1] = 1;
+	verts[1].modulate[0] = 255;
+	verts[1].modulate[1] = 255;
+	verts[1].modulate[2] = 255;
+	verts[1].modulate[3] = 255;
+
+	VectorCopy( trace.endpos, verts[2].xyz );
+	verts[2].xyz[0] += 32;
+	verts[2].xyz[1] += 32;
+	verts[2].st[0] = 1;
+	verts[2].st[1] = 1;
+	verts[2].modulate[0] = 255;
+	verts[2].modulate[1] = 255;
+	verts[2].modulate[2] = 255;
+	verts[2].modulate[3] = 255;
+
+	VectorCopy( trace.endpos, verts[3].xyz );
+	verts[3].xyz[0] += 32;
+	verts[3].xyz[1] -= 32;
+	verts[3].st[0] = 1;
+	verts[3].st[1] = 0;
+	verts[3].modulate[0] = 255;
+	verts[3].modulate[1] = 255;
+	verts[3].modulate[2] = 255;
+	verts[3].modulate[3] = 255;
+
+	trap_R_AddPolyToScene( cgs.media.wakeMarkShader, 4, verts );
+}
+
+#define REFRACT_EFFECT_DURATION		500
+static void CG_ForcePushBlur( vec3_t org, centity_t *cent )
+{
+	if (!cent || !cg_renderToTextureFX.integer)
+	{
+		localEntity_t	*ex;
+
+		ex = CG_AllocLocalEntity();
+		ex->leType = LE_PUFF;
+		ex->refEntity.reType = RT_SPRITE;
+		ex->radius = 2.0f;
+		ex->startTime = cg.time;
+		ex->endTime = ex->startTime + 120;
+		VectorCopy( org, ex->pos.trBase );
+		ex->pos.trTime = cg.time;
+		ex->pos.trType = TR_LINEAR;
+		VectorScale( cg.refdef.viewaxis[1], 55, ex->pos.trDelta );
+			
+		ex->color[0] = 24;
+		ex->color[1] = 32;
+		ex->color[2] = 40;
+		ex->refEntity.customShader = trap_R_RegisterShader( "gfx/effects/forcePush" );
+
+		ex = CG_AllocLocalEntity();
+		ex->leType = LE_PUFF;
+		ex->refEntity.reType = RT_SPRITE;
+		ex->refEntity.rotation = 180.0f;
+		ex->radius = 2.0f;
+		ex->startTime = cg.time;
+		ex->endTime = ex->startTime + 120;
+		VectorCopy( org, ex->pos.trBase );
+		ex->pos.trTime = cg.time;
+		ex->pos.trType = TR_LINEAR;
+		VectorScale( cg.refdef.viewaxis[1], -55, ex->pos.trDelta );
+			
+		ex->color[0] = 24;
+		ex->color[1] = 32;
+		ex->color[2] = 40;
+		ex->refEntity.customShader = trap_R_RegisterShader( "gfx/effects/forcePush" );
+	}
+	else
+	{ //superkewl "refraction" (well sort of) effect -rww
+		refEntity_t ent;
+		vec3_t ang;
+		float scale;
+		float vLen;
+		float alpha;
+		int tDif;
+
+		if (!cent->bodyFadeTime)
+		{ //the duration for the expansion and fade
+			cent->bodyFadeTime = cg.time + REFRACT_EFFECT_DURATION;
+		}
+
+		//closer tDif is to 0, the closer we are to
+		//being "done"
+		tDif = (cent->bodyFadeTime - cg.time);
+
+		if ((REFRACT_EFFECT_DURATION-tDif) < 200)
+		{ //stop following the hand after a little and stay in a fixed spot
+			//save the initial spot of the effect
+			VectorCopy(org, cent->pushEffectOrigin);
+		}
+
+		//scale from 1.0f to 0.1f then hold at 0.1 for the rest of the duration
+		if (cent->currentState.powerups & (1 << PW_PULL))
+		{
+			scale = (float)(REFRACT_EFFECT_DURATION-tDif)*0.003f;
+		}
+		else
+		{
+			scale = (float)(tDif)*0.003f;
+		}
+
+		if (scale > 1.0f)
+		{
+			scale = 1.0f;
+		}
+		else if (scale < 0.2f)
+		{
+			scale = 0.2f;
+		}
+
+		//start alpha at 244, fade to 10
+		alpha = (float)tDif*0.488f;
+
+		if (alpha > 244.0f)
+		{
+			alpha = 244.0f;
+		}
+		else if (alpha < 10.0f)
+		{
+			alpha = 10.0f;
+		}
+
+		memset( &ent, 0, sizeof( ent ) );
+		ent.shaderTime = (cent->bodyFadeTime-REFRACT_EFFECT_DURATION) / 1000.0f;
+
+		VectorCopy( cent->pushEffectOrigin, ent.origin );
+
+		VectorSubtract(ent.origin, cg.refdef.vieworg, ent.axis[0]);
+		vLen = VectorLength(ent.axis[0]);
+		if (vLen <= 0.1f)
+		{	// Entity is right on vieworg.  quit.
+			return;
+		}
+
+		vectoangles(ent.axis[0], ang);
+		ang[ROLL] += 180.0f;
+		AnglesToAxis(ang, ent.axis);
+
+		//radius must be a power of 2, and is the actual captured texture size
+		if (vLen < 128)
+		{
+			ent.radius = 256;
+		}
+		else if (vLen < 256)
+		{
+			ent.radius = 128;
+		}
+		else if (vLen < 512)
+		{
+			ent.radius = 64;
+		}
+		else
+		{
+			ent.radius = 32;
+		}
+
+		VectorScale(ent.axis[0], scale, ent.axis[0]);
+		VectorScale(ent.axis[1], scale, ent.axis[1]);
+		VectorScale(ent.axis[2], scale, ent.axis[2]);
+
+		ent.hModel = cgs.media.halfShieldModel;
+		ent.customShader = cgs.media.refractionShader; //cgs.media.cloakedShader;
+		ent.nonNormalizedAxes = qtrue;
+
+		//make it partially transparent so it blends with the background
+		ent.renderfx = (RF_DISTORTION|RF_FORCE_ENT_ALPHA);
+		ent.shaderRGBA[0] = 255.0f;
+		ent.shaderRGBA[1] = 255.0f;
+		ent.shaderRGBA[2] = 255.0f;
+		ent.shaderRGBA[3] = alpha;
+
+		trap_R_AddRefEntityToScene( &ent );
+	}
+}
+
+static const char *cg_pushBoneNames[] =
+{
+	"cranium",
+	"lower_lumbar",
+	"rhand",
+	"lhand",
+	"ltibia",
+	"rtibia",
+	"lradius",
+	"rradius",
+	NULL
+};
+
+static void CG_ForcePushBodyBlur( centity_t *cent )
+{
+	vec3_t fxOrg;
+	mdxaBone_t	boltMatrix;
+	int bolt;
+	int i;
+
+	if (cent->localAnimIndex > 1)
+	{ //Sorry, the humanoid IS IN ANOTHER CASTLE.
+		return;
+	}
+
+	if (cg.snap &&
+		CG_IsMindTricked(cent->currentState.trickedentindex,
+		cent->currentState.trickedentindex2,
+		cent->currentState.trickedentindex3,
+		cent->currentState.trickedentindex4,
+		cg.snap->ps.clientNum))
+	{
+		return; //this entity is mind-tricking the current client, so don't render it
+	}
+
+	assert(cent->ghoul2);
+
+	for (i = 0; cg_pushBoneNames[i]; i++)
+	{ //go through all the bones we want to put a blur effect on
+		bolt = trap_G2API_AddBolt(cent->ghoul2, 0, cg_pushBoneNames[i]);
+
+		if (bolt == -1)
+		{
+			assert(!"You've got an invalid bone/bolt name in cg_pushBoneNames");
+			continue;
+		}
+
+		trap_G2API_GetBoltMatrix(cent->ghoul2, 0, bolt, &boltMatrix, cent->turAngles, cent->lerpOrigin, cg.time, cgs.gameModels, cent->modelScale);
+		BG_GiveMeVectorFromMatrix(&boltMatrix, ORIGIN, fxOrg);
+
+		//standard effect, don't be refractive (for now)
+		CG_ForcePushBlur(fxOrg, NULL);
+	}
+}
+
+static void CG_ForceGripEffect( vec3_t org )
+{
+	localEntity_t	*ex;
+	float wv = sin( cg.time * 0.004f ) * 0.08f + 0.1f;
+
+	ex = CG_AllocLocalEntity();
+	ex->leType = LE_PUFF;
+	ex->refEntity.reType = RT_SPRITE;
+	ex->radius = 2.0f;
+	ex->startTime = cg.time;
+	ex->endTime = ex->startTime + 120;
+	VectorCopy( org, ex->pos.trBase );
+	ex->pos.trTime = cg.time;
+	ex->pos.trType = TR_LINEAR;
+	VectorScale( cg.refdef.viewaxis[1], 55, ex->pos.trDelta );
+		
+	ex->color[0] = 200+((wv*255));
+	if (ex->color[0] > 255)
+	{
+		ex->color[0] = 255;
+	}
+	ex->color[1] = 0;
+	ex->color[2] = 0;
+	ex->refEntity.customShader = trap_R_RegisterShader( "gfx/effects/forcePush" );
+
+	ex = CG_AllocLocalEntity();
+	ex->leType = LE_PUFF;
+	ex->refEntity.reType = RT_SPRITE;
+	ex->refEntity.rotation = 180.0f;
+	ex->radius = 2.0f;
+	ex->startTime = cg.time;
+	ex->endTime = ex->startTime + 120;
+	VectorCopy( org, ex->pos.trBase );
+	ex->pos.trTime = cg.time;
+	ex->pos.trType = TR_LINEAR;
+	VectorScale( cg.refdef.viewaxis[1], -55, ex->pos.trDelta );
+
+	/*
+	ex->color[0] = 200+((wv*255));
+	if (ex->color[0] > 255)
+	{
+		ex->color[0] = 255;
+	}
+	*/
+	ex->color[0] = 255;
+	ex->color[1] = 255;
+	ex->color[2] = 255;
+	ex->refEntity.customShader = cgs.media.redSaberGlowShader;//trap_R_RegisterShader( "gfx/effects/forcePush" );
+}
+
+
+/*
+===============
+CG_AddRefEntityWithPowerups
+
+Adds a piece with modifications or duplications for powerups
+Also called by CG_Missile for quad rockets, but nobody can tell...
+===============
+*/
+void CG_AddRefEntityWithPowerups( refEntity_t *ent, entityState_t *state, int team ) {
+
+	if (CG_IsMindTricked(state->trickedentindex,
+		state->trickedentindex2,
+		state->trickedentindex3,
+		state->trickedentindex4,
+		cg.snap->ps.clientNum))
+	{
+		return; //this entity is mind-tricking the current client, so don't render it
+	}
+
+	trap_R_AddRefEntityToScene( ent );
+}
+
+#define MAX_SHIELD_TIME	2000.0
+#define MIN_SHIELD_TIME	2000.0
+
+
+void CG_PlayerShieldHit(int entitynum, vec3_t dir, int amount)
+{
+	centity_t *cent;
+	int	time;
+
+	if (entitynum<0 || entitynum >= MAX_ENTITIES)
+	{
+		return;
+	}
+
+	cent = &cg_entities[entitynum];
+
+	if (amount > 100)
+	{
+		time = cg.time + MAX_SHIELD_TIME;		// 2 sec.
+	}
+	else
+	{
+		time = cg.time + 500 + amount*15;
+	}
+
+	if (time > cent->damageTime)
+	{
+		cent->damageTime = time;
+		VectorScale(dir, -1, dir);
+		vectoangles(dir, cent->damageAngles);
+	}
+}
+
+
+void CG_DrawPlayerShield(centity_t *cent, vec3_t origin)
+{
+	refEntity_t ent;
+	int			alpha;
+	float		scale;
+	
+	// Don't draw the shield when the player is dead.
+	if (cent->currentState.eFlags & EF_DEAD)
+	{
+		return;
+	}
+
+	memset( &ent, 0, sizeof( ent ) );
+
+	VectorCopy( origin, ent.origin );
+	ent.origin[2] += 10.0;
+	AnglesToAxis( cent->damageAngles, ent.axis );
+
+	alpha = 255.0 * ((cent->damageTime - cg.time) / MIN_SHIELD_TIME) + random()*16;
+	if (alpha>255)
+		alpha=255;
+
+	// Make it bigger, but tighter if more solid
+	scale = 1.4 - ((float)alpha*(0.4/255.0));		// Range from 1.0 to 1.4
+	VectorScale( ent.axis[0], scale, ent.axis[0] );
+	VectorScale( ent.axis[1], scale, ent.axis[1] );
+	VectorScale( ent.axis[2], scale, ent.axis[2] );
+
+	ent.hModel = cgs.media.halfShieldModel;
+	ent.customShader = cgs.media.halfShieldShader;
+	ent.shaderRGBA[0] = alpha;
+	ent.shaderRGBA[1] = alpha;
+	ent.shaderRGBA[2] = alpha;
+	ent.shaderRGBA[3] = 255;
+	trap_R_AddRefEntityToScene( &ent );
+}
+
+
+void CG_PlayerHitFX(centity_t *cent)
+{
+	// only do the below fx if the cent in question is...uh...me, and it's first person.
+	if (cent->currentState.clientNum != cg.predictedPlayerState.clientNum || cg.renderingThirdPerson)
+	{
+		if (cent->damageTime > cg.time
+			&& cent->currentState.NPC_class != CLASS_VEHICLE )
+		{
+			CG_DrawPlayerShield(cent, cent->lerpOrigin);
+		}
+
+		return;
+	}
+}
+
+
+
+/*
+=================
+CG_LightVerts
+=================
+*/
+int CG_LightVerts( vec3_t normal, int numVerts, polyVert_t *verts )
+{
+	int				i, j;
+	float			incoming;
+	vec3_t			ambientLight;
+	vec3_t			lightDir;
+	vec3_t			directedLight;
+
+	trap_R_LightForPoint( verts[0].xyz, ambientLight, directedLight, lightDir );
+
+	for (i = 0; i < numVerts; i++) {
+		incoming = DotProduct (normal, lightDir);
+		if ( incoming <= 0 ) {
+			verts[i].modulate[0] = ambientLight[0];
+			verts[i].modulate[1] = ambientLight[1];
+			verts[i].modulate[2] = ambientLight[2];
+			verts[i].modulate[3] = 255;
+			continue;
+		} 
+		j = ( ambientLight[0] + incoming * directedLight[0] );
+		if ( j > 255 ) {
+			j = 255;
+		}
+		verts[i].modulate[0] = j;
+
+		j = ( ambientLight[1] + incoming * directedLight[1] );
+		if ( j > 255 ) {
+			j = 255;
+		}
+		verts[i].modulate[1] = j;
+
+		j = ( ambientLight[2] + incoming * directedLight[2] );
+		if ( j > 255 ) {
+			j = 255;
+		}
+		verts[i].modulate[2] = j;
+
+		verts[i].modulate[3] = 255;
+	}
+	return qtrue;
+}
+
+static void CG_RGBForSaberColor( saber_colors_t color, vec3_t rgb )
+{
+	switch( color )
+	{
+		case SABER_RED:
+			VectorSet( rgb, 1.0f, 0.2f, 0.2f );
+			break;
+		case SABER_ORANGE:
+			VectorSet( rgb, 1.0f, 0.5f, 0.1f );
+			break;
+		case SABER_YELLOW:
+			VectorSet( rgb, 1.0f, 1.0f, 0.2f );
+			break;
+		case SABER_GREEN:
+			VectorSet( rgb, 0.2f, 1.0f, 0.2f );
+			break;
+		case SABER_BLUE:
+			VectorSet( rgb, 0.2f, 0.4f, 1.0f );
+			break;
+		case SABER_PURPLE:
+			VectorSet( rgb, 0.9f, 0.2f, 1.0f );
+			break;
+	}
+}
+
+static void CG_DoSaberLight( saberInfo_t *saber )
+{
+	vec3_t		positions[MAX_BLADES*2], mid={0}, rgbs[MAX_BLADES*2], rgb={0};
+	float		lengths[MAX_BLADES*2]={0}, totallength = 0, numpositions = 0, dist, diameter = 0;
+	int			i, j;
+
+	//RGB combine all the colors of the sabers you're using into one averaged color!
+	if ( !saber )
+	{ 
+		return;
+	}
+
+	for ( i = 0; i < saber->numBlades; i++ )
+	{
+		if ( saber->blade[i].length >= 0.5f )
+		{
+			//FIXME: make RGB sabers
+			CG_RGBForSaberColor( saber->blade[i].color, rgbs[i] );
+			lengths[i] = saber->blade[i].length;
+			if ( saber->blade[i].length*2.0f > diameter )
+			{
+				diameter = saber->blade[i].length*2.0f;
+			}
+			totallength += saber->blade[i].length;
+			VectorMA( saber->blade[i].muzzlePoint, saber->blade[i].length, saber->blade[i].muzzleDir, positions[i] );
+			if ( !numpositions )
+			{//first blade, store middle of that as midpoint
+				VectorMA( saber->blade[i].muzzlePoint, saber->blade[i].length*0.5, saber->blade[i].muzzleDir, mid );
+				VectorCopy( rgbs[i], rgb );
+			}
+			numpositions++;
+		}
+	}
+
+	if ( totallength )
+	{//actually have something to do	
+		if ( numpositions == 1 )
+		{//only 1 blade, midpoint is already set (halfway between the start and end of that blade), rgb is already set, so it diameter
+		}
+		else
+		{//multiple blades, calc averages
+			VectorClear( mid );
+			VectorClear( rgb );
+			//now go through all the data and get the average RGB and middle position and the radius
+			for ( i = 0; i < MAX_BLADES*2; i++ )
+			{
+				if ( lengths[i] )
+				{
+					VectorMA( rgb, lengths[i], rgbs[i], rgb );
+					VectorAdd( mid, positions[i], mid );
+				}
+			}
+
+			//get middle rgb
+			VectorScale( rgb, 1/totallength, rgb );//get the average, normalized RGB
+			//get mid position
+			VectorScale( mid, 1/numpositions, mid );
+			//find the farthest distance between the blade tips, this will be our diameter
+			for ( i = 0; i < MAX_BLADES*2; i++ )
+			{
+				if ( lengths[i] )
+				{
+					for ( j = 0; j < MAX_BLADES*2; j++ )
+					{
+						if ( lengths[j] )
+						{
+							dist = Distance( positions[i], positions[j] );
+							if ( dist > diameter )
+							{
+								diameter = dist;
+							}
+						}
+					}
+				}
+			}
+		}
+
+		trap_R_AddLightToScene( mid, diameter + (random()*8.0f), rgb[0], rgb[1], rgb[2] );
+	}
+}
+
+void CG_DoSaber( vec3_t origin, vec3_t dir, float length, float lengthMax, float radius, saber_colors_t color, int rfx, qboolean doLight )
+{
+	vec3_t		mid;
+	qhandle_t	blade = 0, glow = 0;
+	refEntity_t saber;
+	float radiusmult;
+	float radiusRange;
+	float radiusStart;
+
+	if ( length < 0.5f )
+	{
+		// if the thing is so short, just forget even adding me.
+		return;
+	}
+
+	// Find the midpoint of the saber for lighting purposes
+	VectorMA( origin, length * 0.5f, dir, mid );
+
+	switch( color )
+	{
+		case SABER_RED:
+			glow = cgs.media.redSaberGlowShader;
+			blade = cgs.media.redSaberCoreShader;
+			break;
+		case SABER_ORANGE:
+			glow = cgs.media.orangeSaberGlowShader;
+			blade = cgs.media.orangeSaberCoreShader;
+			break;
+		case SABER_YELLOW:
+			glow = cgs.media.yellowSaberGlowShader;
+			blade = cgs.media.yellowSaberCoreShader;
+			break;
+		case SABER_GREEN:
+			glow = cgs.media.greenSaberGlowShader;
+			blade = cgs.media.greenSaberCoreShader;
+			break;
+		case SABER_BLUE:
+			glow = cgs.media.blueSaberGlowShader;
+			blade = cgs.media.blueSaberCoreShader;
+			break;
+		case SABER_PURPLE:
+			glow = cgs.media.purpleSaberGlowShader;
+			blade = cgs.media.purpleSaberCoreShader;
+			break;
+		default:
+			glow = cgs.media.blueSaberGlowShader;
+			blade = cgs.media.blueSaberCoreShader;
+			break;
+	}
+
+	if (doLight)
+	{	// always add a light because sabers cast a nice glow before they slice you in half!!  or something...
+		vec3_t rgb={1,1,1};
+		CG_RGBForSaberColor( color, rgb );
+		trap_R_AddLightToScene( mid, (length*1.4f) + (random()*3.0f), rgb[0], rgb[1], rgb[2] );
+	}
+
+	memset( &saber, 0, sizeof( refEntity_t ));
+
+	// Saber glow is it's own ref type because it uses a ton of sprites, otherwise it would eat up too many
+	//	refEnts to do each glow blob individually
+	saber.saberLength = length;
+
+	// Jeff, I did this because I foolishly wished to have a bright halo as the saber is unleashed.  
+	// It's not quite what I'd hoped tho.  If you have any ideas, go for it!  --Pat
+	if (length < lengthMax)
+	{
+		radiusmult = 1.0 + (2.0 / length);		// Note this creates a curve, and length cannot be < 0.5.
+	}
+	else
+	{
+		radiusmult = 1.0;
+	}
+
+	if (cg_saberTrail.integer == 2 && cg_shadows.integer != 2 && cgs.glconfig.stencilBits >= 4)
+	{ //draw the blade as a post-render so it doesn't get in the cap...
+		rfx |= RF_FORCEPOST;
+	}
+
+	radiusRange = radius * 0.075f;
+	radiusStart = radius-radiusRange;
+
+	saber.radius = (radiusStart + crandom() * radiusRange)*radiusmult;
+	//saber.radius = (2.8f + crandom() * 0.2f)*radiusmult;
+
+	VectorCopy( origin, saber.origin );
+	VectorCopy( dir, saber.axis[0] );
+	saber.reType = RT_SABER_GLOW;
+	saber.customShader = glow;
+	saber.shaderRGBA[0] = saber.shaderRGBA[1] = saber.shaderRGBA[2] = saber.shaderRGBA[3] = 0xff;
+	saber.renderfx = rfx;
+
+	trap_R_AddRefEntityToScene( &saber );
+
+	// Do the hot core
+	VectorMA( origin, length, dir, saber.origin );
+	VectorMA( origin, -1, dir, saber.oldorigin );
+
+
+//	CG_TestLine(saber.origin, saber.oldorigin, 50, 0x000000ff, 3);
+	saber.customShader = blade;
+	saber.reType = RT_LINE;
+	radiusStart = radius/3.0f;
+	saber.radius = (radiusStart + crandom() * radiusRange)*radiusmult;
+//	saber.radius = (1.0 + crandom() * 0.2f)*radiusmult;
+
+	saber.shaderTexCoord[0] = saber.shaderTexCoord[1] = 1.0f;
+	saber.shaderRGBA[0] = saber.shaderRGBA[1] = saber.shaderRGBA[2] = saber.shaderRGBA[3] = 0xff;
+
+	trap_R_AddRefEntityToScene( &saber );
+}
+
+//--------------------------------------------------------------
+// CG_GetTagWorldPosition
+//
+// Can pass in NULL for the axis
+//--------------------------------------------------------------
+void CG_GetTagWorldPosition( refEntity_t *model, char *tag, vec3_t pos, vec3_t axis[3] )
+{
+	orientation_t	orientation;
+	int i = 0;
+
+	// Get the requested tag
+	trap_R_LerpTag( &orientation, model->hModel, model->oldframe, model->frame,
+		1.0f - model->backlerp, tag );
+
+	VectorCopy( model->origin, pos );
+	for ( i = 0 ; i < 3 ; i++ ) 
+	{
+		VectorMA( pos, orientation.origin[i], model->axis[i], pos );
+	}
+
+	if ( axis )
+	{
+		MatrixMultiply( orientation.axis, model->axis, axis );
+	}
+}
+
+#define	MAX_MARK_FRAGMENTS	128
+#define	MAX_MARK_POINTS		384
+extern markPoly_t *CG_AllocMark();
+
+void CG_CreateSaberMarks( vec3_t start, vec3_t end, vec3_t normal )
+{
+//	byte			colors[4];
+	int				i, j;
+	int				numFragments;
+	vec3_t			axis[3], originalPoints[4], mid;
+	vec3_t			markPoints[MAX_MARK_POINTS], projection;
+	polyVert_t		*v, verts[MAX_VERTS_ON_POLY];
+	markPoly_t		*mark;
+	markFragment_t	markFragments[MAX_MARK_FRAGMENTS], *mf;
+
+	float	radius = 0.65f;
+
+	if ( !cg_addMarks.integer ) 
+	{
+		return;
+	}
+
+	VectorSubtract( end, start, axis[1] );
+	VectorNormalize( axis[1] );
+
+	// create the texture axis
+	VectorCopy( normal, axis[0] );
+	CrossProduct( axis[1], axis[0], axis[2] );
+
+	// create the full polygon that we'll project
+	for ( i = 0 ; i < 3 ; i++ ) 
+	{	// stretch a bit more in the direction that we are traveling in...  debateable as to whether this makes things better or worse
+		originalPoints[0][i] = start[i] - radius * axis[1][i] - radius * axis[2][i];
+		originalPoints[1][i] = end[i] + radius * axis[1][i] - radius * axis[2][i];
+		originalPoints[2][i] = end[i] + radius * axis[1][i] + radius * axis[2][i];
+		originalPoints[3][i] = start[i] - radius * axis[1][i] + radius * axis[2][i];
+	}
+
+	VectorScale( normal, -1, projection );
+
+	// get the fragments
+	numFragments = trap_CM_MarkFragments( 4, (const float (*)[3])originalPoints,
+					projection, MAX_MARK_POINTS, markPoints[0], MAX_MARK_FRAGMENTS, markFragments );
+
+	for ( i = 0, mf = markFragments ; i < numFragments ; i++, mf++ ) 
+	{
+		// we have an upper limit on the complexity of polygons that we store persistantly
+		if ( mf->numPoints > MAX_VERTS_ON_POLY ) 
+		{
+			mf->numPoints = MAX_VERTS_ON_POLY;
+		}
+
+		for ( j = 0, v = verts ; j < mf->numPoints ; j++, v++ ) 
+		{
+			vec3_t delta;
+
+			// Set up our texture coords, this may need some work 
+			VectorCopy( markPoints[mf->firstPoint + j], v->xyz );
+			VectorAdd( end, start, mid );
+			VectorScale( mid, 0.5f, mid );
+			VectorSubtract( v->xyz, mid, delta );
+
+			v->st[0] = 0.5 + DotProduct( delta, axis[1] ) * (0.05f + random() * 0.03f); 
+			v->st[1] = 0.5 + DotProduct( delta, axis[2] ) * (0.15f + random() * 0.05f);	
+		}
+
+		if (cg_saberDynamicMarks.integer)
+		{
+			int i = 0;
+			int i_2 = 0;
+			addpolyArgStruct_t apArgs;
+			vec3_t x;
+
+			memset (&apArgs, 0, sizeof(apArgs));
+
+			while (i < 4)
+			{
+				while (i_2 < 3)
+				{
+					apArgs.p[i][i_2] = verts[i].xyz[i_2];
+
+					i_2++;
+				}
+
+				i_2 = 0;
+				i++;
+			}
+
+			i = 0;
+			i_2 = 0;
+
+			while (i < 4)
+			{
+				while (i_2 < 2)
+				{
+					apArgs.ev[i][i_2] = verts[i].st[i_2];
+
+					i_2++;
+				}
+
+				i_2 = 0;
+				i++;
+			}
+
+			//When using addpoly, having a situation like this tends to cause bad results.
+			//(I assume it doesn't like trying to draw a polygon over two planes and extends
+			//the vertex out to some odd value)
+			VectorSubtract(apArgs.p[0], apArgs.p[3], x);
+			if (VectorLength(x) > 3.0f)
+			{
+				return;
+			}
+
+			apArgs.numVerts = mf->numPoints;
+			VectorCopy(vec3_origin, apArgs.vel);
+			VectorCopy(vec3_origin, apArgs.accel);
+
+			apArgs.alpha1 = 1.0f;
+			apArgs.alpha2 = 0.0f;
+			apArgs.alphaParm = 255.0f;
+
+			VectorSet(apArgs.rgb1, 0.0f, 0.0f, 0.0f);
+			VectorSet(apArgs.rgb2, 0.0f, 0.0f, 0.0f);
+
+			apArgs.rgbParm = 0.0f;
+
+			apArgs.bounce = 0;
+			apArgs.motionDelay = 0;
+			apArgs.killTime = cg_saberDynamicMarkTime.integer;
+			apArgs.shader = cgs.media.rivetMarkShader;
+			apArgs.flags = 0x08000000|0x00000004;
+
+			trap_FX_AddPoly(&apArgs);
+
+			apArgs.shader = cgs.media.mSaberDamageGlow;
+			apArgs.rgb1[0] = 215 + random() * 40.0f;
+			apArgs.rgb1[1] = 96 + random() * 32.0f;
+			apArgs.rgb1[2] = apArgs.alphaParm = random()*15.0f;
+
+			apArgs.rgb1[0] /= 255;
+			apArgs.rgb1[1] /= 255;
+			apArgs.rgb1[2] /= 255;
+			VectorCopy(apArgs.rgb1, apArgs.rgb2);
+
+			apArgs.killTime = 100;
+
+			trap_FX_AddPoly(&apArgs);
+		}
+		else
+		{
+			// save it persistantly, do burn first
+			mark = CG_AllocMark();
+			mark->time = cg.time;
+			mark->alphaFade = qtrue;
+			mark->markShader = cgs.media.rivetMarkShader;
+			mark->poly.numVerts = mf->numPoints;
+			mark->color[0] = mark->color[1] = mark->color[2] = mark->color[3] = 255;
+			memcpy( mark->verts, verts, mf->numPoints * sizeof( verts[0] ) );
+
+			// And now do a glow pass
+			// by moving the start time back, we can hack it to fade out way before the burn does
+			mark = CG_AllocMark();
+			mark->time = cg.time - 8500;
+			mark->alphaFade = qfalse;
+			mark->markShader = cgs.media.mSaberDamageGlow;
+			mark->poly.numVerts = mf->numPoints;
+			mark->color[0] = 215 + random() * 40.0f;
+			mark->color[1] = 96 + random() * 32.0f;
+			mark->color[2] = mark->color[3] = random()*15.0f;
+			memcpy( mark->verts, verts, mf->numPoints * sizeof( verts[0] ) );
+		}
+	}
+}
+
+qboolean CG_G2TraceCollide(trace_t *tr, vec3_t const mins, vec3_t const maxs, const vec3_t lastValidStart, const vec3_t lastValidEnd)
+{
+	G2Trace_t		G2Trace;
+	centity_t		*g2Hit;
+	vec3_t			angles;
+	int				tN = 0;
+	float			fRadius = 0.0f;
+
+	if (mins && maxs &&
+		(mins[0] || maxs[0]))
+	{
+		fRadius=(maxs[0]-mins[0])/2.0f;
+	}
+
+	memset (&G2Trace, 0, sizeof(G2Trace));
+
+	while (tN < MAX_G2_COLLISIONS)
+	{
+		G2Trace[tN].mEntityNum = -1;
+		tN++;
+	}
+	g2Hit = &cg_entities[tr->entityNum];
+
+	if (g2Hit && g2Hit->ghoul2)
+	{
+		angles[ROLL] = angles[PITCH] = 0;
+		angles[YAW] = g2Hit->lerpAngles[YAW];
+
+		trap_G2API_CollisionDetect ( G2Trace, g2Hit->ghoul2, angles, g2Hit->lerpOrigin, cg.time, g2Hit->currentState.number, lastValidStart, lastValidEnd, g2Hit->modelScale, 0, cg_g2TraceLod.integer, fRadius );
+
+		if (G2Trace[0].mEntityNum != g2Hit->currentState.number)
+		{
+			tr->fraction = 1.0f;
+			tr->entityNum = ENTITYNUM_NONE;
+			tr->startsolid = 0;
+			tr->allsolid = 0;
+			return qfalse;
+		}
+		else
+		{ //Yay!
+			VectorCopy(G2Trace[0].mCollisionPosition, tr->endpos);
+			VectorCopy(G2Trace[0].mCollisionNormal, tr->plane.normal);
+			return qtrue;
+		}
+	}
+
+	return qfalse;
+}
+
+void CG_G2SaberEffects(vec3_t start, vec3_t end, centity_t *owner)
+{
+	trace_t trace;
+	vec3_t startTr;
+	vec3_t endTr;
+	qboolean backWards = qfalse;
+	qboolean doneWithTraces = qfalse;
+
+	while (!doneWithTraces)
+	{
+		if (!backWards)
+		{
+			VectorCopy(start, startTr);
+			VectorCopy(end, endTr);
+		}
+		else
+		{
+			VectorCopy(end, startTr);
+			VectorCopy(start, endTr);
+		}
+
+		CG_Trace( &trace, startTr, NULL, NULL, endTr, owner->currentState.number, MASK_PLAYERSOLID );
+
+		if (trace.entityNum < MAX_CLIENTS)
+		{ //hit a client..
+			CG_G2TraceCollide(&trace, NULL, NULL, startTr, endTr);
+
+			if (trace.entityNum != ENTITYNUM_NONE)
+			{ //it succeeded with the ghoul2 trace
+				trap_FX_PlayEffectID( cgs.effects.mSaberBloodSparks, trace.endpos, trace.plane.normal, -1, -1 );
+				trap_S_StartSound(trace.endpos, trace.entityNum, CHAN_AUTO, trap_S_RegisterSound(va("sound/weapons/saber/saberhit%i.wav", Q_irand(1, 3))));
+			}
+		}
+
+		if (!backWards)
+		{
+			backWards = qtrue;
+		}
+		else
+		{
+			doneWithTraces = qtrue;
+		}
+	}
+}
+
+#define CG_MAX_SABER_COMP_TIME 400 //last registered saber entity hit must match within this many ms for the client effect to take place.
+
+void CG_AddGhoul2Mark(int shader, float size, vec3_t start, vec3_t end, int entnum,
+					  vec3_t entposition, float entangle, void *ghoul2, vec3_t scale, int lifeTime)
+{
+	SSkinGoreData goreSkin;
+
+	assert(ghoul2);
+
+	memset ( &goreSkin, 0, sizeof(goreSkin) );
+
+	if (trap_G2API_GetNumGoreMarks(ghoul2, 0) >= cg_ghoul2Marks.integer)
+	{ //you've got too many marks already
+		return;
+	}
+
+	goreSkin.growDuration = -1; // default expandy time
+	goreSkin.goreScaleStartFraction = 1.0; // default start scale
+	goreSkin.frontFaces = qtrue;
+	goreSkin.backFaces = qtrue;
+	goreSkin.lifeTime = lifeTime; //last randomly 10-20 seconds
+	/*
+	if (lifeTime)
+	{
+		goreSkin.fadeOutTime = lifeTime*0.1; //default fade duration is relative to lifetime.
+	}
+	goreSkin.fadeRGB = qtrue; //fade on RGB instead of alpha (this depends on the shader really, modify if needed)
+	*/
+	//rwwFIXMEFIXME: fade has sorting issues with other non-fading decals, disabled until fixed
+
+	goreSkin.baseModelOnly = qfalse;
+	
+	goreSkin.currentTime = cg.time;
+	goreSkin.entNum      = entnum;
+	goreSkin.SSize		 = size;
+	goreSkin.TSize		 = size;
+	goreSkin.theta		 = flrand(0.0f,6.28f);
+	goreSkin.shader		 = shader;
+
+	if (!scale[0] && !scale[1] && !scale[2])
+	{
+		VectorSet(goreSkin.scale, 1.0f, 1.0f, 1.0f);
+	}
+	else
+	{
+		VectorCopy(goreSkin.scale, scale);
+	}
+
+	VectorCopy (start, goreSkin.hitLocation);
+
+	VectorSubtract(end, start, goreSkin.rayDirection);
+	if (VectorNormalize(goreSkin.rayDirection)<.1f)
+	{
+		return;
+	}
+
+	VectorCopy ( entposition, goreSkin.position );
+	goreSkin.angles[YAW] = entangle;
+
+	trap_G2API_AddSkinGore(ghoul2, &goreSkin);
+}
+
+void CG_SaberCompWork(vec3_t start, vec3_t end, centity_t *owner)
+{
+	trace_t trace;
+	vec3_t startTr;
+	vec3_t endTr;
+	qboolean backWards = qfalse;
+	qboolean doneWithTraces = qfalse;
+	qboolean doEffect = qfalse;
+
+	if ((cg.time - owner->serverSaberHitTime) > CG_MAX_SABER_COMP_TIME)
+	{
+		return;
+	}
+
+	if (cg.time == owner->serverSaberHitTime)
+	{ //don't want to do it the same frame as the server hit, to avoid burst effect concentrations every x ms.
+		return;
+	}
+
+	while (!doneWithTraces)
+	{
+		if (!backWards)
+		{
+			VectorCopy(start, startTr);
+			VectorCopy(end, endTr);
+		}
+		else
+		{
+			VectorCopy(end, startTr);
+			VectorCopy(start, endTr);
+		}
+
+		CG_Trace( &trace, startTr, NULL, NULL, endTr, owner->currentState.number, MASK_PLAYERSOLID );
+
+		if (trace.entityNum == owner->serverSaberHitIndex)
+		{ //this is the guy the server says we last hit, so continue.
+			if (cg_entities[trace.entityNum].ghoul2)
+			{ //If it has a g2 instance, do the proper ghoul2 checks
+				CG_G2TraceCollide(&trace, NULL, NULL, startTr, endTr);
+
+				if (trace.entityNum != ENTITYNUM_NONE)
+				{ //it succeeded with the ghoul2 trace
+					doEffect = qtrue;
+
+					if (cg_ghoul2Marks.integer)
+					{
+						vec3_t ePos;
+						centity_t *trEnt = &cg_entities[trace.entityNum];
+
+						if (trEnt->ghoul2)
+						{
+							if (trEnt->currentState.eType != ET_NPC ||
+								trEnt->currentState.NPC_class != CLASS_VEHICLE ||
+								!trEnt->m_pVehicle ||
+								trEnt->m_pVehicle->m_pVehicleInfo->type != VH_FIGHTER)
+							{ //don't do on fighters cause they have crazy full axial angles
+								VectorSubtract(endTr, trace.endpos, ePos);
+								VectorNormalize(ePos);
+								VectorMA(trace.endpos, 4.0f, ePos, ePos);
+
+								CG_AddGhoul2Mark(cgs.media.bdecal_saberglow, flrand(3.0f, 4.0f),
+									trace.endpos, ePos, trace.entityNum, trEnt->lerpOrigin, trEnt->lerpAngles[YAW],
+									trEnt->ghoul2, trEnt->modelScale, Q_irand(5000, 10000));
+							}
+						}
+					}
+				}
+			}
+			else
+			{ //otherwise, we're all set.
+				doEffect = qtrue;
+			}
+
+			if (doEffect)
+			{
+				if (!trace.plane.normal[0] && !trace.plane.normal[1] && !trace.plane.normal[2])
+				{ //who cares, just shoot it somewhere.
+					trace.plane.normal[1] = 1;
+				}
+
+				if (owner->serverSaberFleshImpact)
+				{ //do standard player/live ent hit sparks
+					trap_FX_PlayEffectID( cgs.effects.mSaberBloodSparks, trace.endpos, trace.plane.normal, -1, -1 );
+					//trap_S_StartSound(trace.endpos, trace.entityNum, CHAN_AUTO, trap_S_RegisterSound(va("sound/weapons/saber/saberhit%i.wav", Q_irand(1, 3))));
+				}
+				else
+				{ //do the cut effect
+					trap_FX_PlayEffectID( cgs.effects.mSaberCut, trace.endpos, trace.plane.normal, -1, -1 );
+				}
+				doEffect = qfalse;
+			}
+		}
+
+		/*
+		if (!backWards)
+		{
+			backWards = qtrue;
+		}
+		else
+		{
+			doneWithTraces = qtrue;
+		}
+		*/
+		doneWithTraces = qtrue; //disabling backwards tr for now, sometimes it just makes too many effects.
+	}
+}
+
+#define SABER_TRAIL_TIME	40.0f
+#define FX_USE_ALPHA		0x08000000
+
+#include "../namespace_begin.h"
+qboolean BG_SuperBreakWinAnim( int anim );
+#include "../namespace_end.h"
+
+void CG_AddSaberBlade( centity_t *cent, centity_t *scent, refEntity_t *saber, int renderfx, int modelIndex, int saberNum, int bladeNum, vec3_t origin, vec3_t angles, qboolean fromSaber, qboolean dontDraw)
+{
+	vec3_t	org_, end, v,
+			axis_[3] = {0,0,0, 0,0,0, 0,0,0};	// shut the compiler up
+	trace_t	trace;
+	int i = 0;
+	int trailDur;
+	float saberLen;
+	float diff;
+	clientInfo_t *client;
+	centity_t *saberEnt;
+	saberTrail_t *saberTrail;
+	mdxaBone_t	boltMatrix;
+	vec3_t futureAngles;
+	effectTrailArgStruct_t fx;
+	int scolor = 0;
+
+	if (cent->currentState.eType == ET_NPC)
+	{
+		client = cent->npcClient;
+		assert(client);
+	}
+	else
+	{
+		client = &cgs.clientinfo[cent->currentState.number];
+	}
+
+	saberEnt = &cg_entities[cent->currentState.saberEntityNum];
+	saberLen = client->saber[saberNum].blade[bladeNum].length;
+
+	if (saberLen <= 0 && !dontDraw)
+	{ //don't bother then.
+		return;
+	}
+
+	futureAngles[YAW] = angles[YAW];
+	futureAngles[PITCH] = angles[PITCH];
+	futureAngles[ROLL] = angles[ROLL];
+
+	//Assume bladeNum is equal to the bolt index because bolts should be added in order of the blades.
+	if (fromSaber)
+	{
+		trap_G2API_GetBoltMatrix(scent->ghoul2, 0, bladeNum, &boltMatrix, futureAngles, origin, cg.time, cgs.gameModels, scent->modelScale);
+	}
+	else
+	{
+		trap_G2API_GetBoltMatrix(scent->ghoul2, saberNum+1, bladeNum, &boltMatrix, futureAngles, origin, cg.time, cgs.gameModels, scent->modelScale);
+	}
+	// work the matrix axis stuff into the original axis and origins used.
+	BG_GiveMeVectorFromMatrix(&boltMatrix, ORIGIN, org_);
+	BG_GiveMeVectorFromMatrix(&boltMatrix, NEGATIVE_Y, axis_[0]);
+
+	if (!fromSaber && saberEnt && !cent->currentState.saberInFlight)
+	{
+		VectorCopy(org_, saberEnt->currentState.pos.trBase);
+
+		VectorCopy(axis_[0], saberEnt->currentState.apos.trBase);
+	}
+
+	VectorMA( org_, saberLen, axis_[0], end );
+	
+	VectorAdd( end, axis_[0], end );
+
+	if (cent->currentState.eType == ET_NPC)
+	{
+		scolor = client->saber[saberNum].blade[bladeNum].color;
+	}
+	else
+	{
+		if (saberNum == 0)
+		{
+			scolor = client->icolor1;
+		}
+		else
+		{
+			scolor = client->icolor2;
+		}
+	}
+
+	if (cgs.gametype >= GT_TEAM &&
+		cgs.gametype != GT_SIEGE &&
+		!cgs.jediVmerc &&
+		cent->currentState.eType != ET_NPC)
+	{
+		if (client->team == TEAM_RED)
+		{
+			scolor = SABER_RED;
+		}
+		else if (client->team == TEAM_BLUE)
+		{
+			scolor = SABER_BLUE;
+		}
+	}
+
+	if (!cg_saberContact.integer)
+	{ //if we don't have saber contact enabled, just add the blade and don't care what it's touching
+		goto CheckTrail;
+	}
+
+	if (!dontDraw)
+	{
+		if (cg_saberModelTraceEffect.integer)
+		{
+			CG_G2SaberEffects(org_, end, cent);
+		}
+		else if (cg_saberClientVisualCompensation.integer)
+		{
+			CG_Trace( &trace, org_, NULL, NULL, end, ENTITYNUM_NONE, MASK_SOLID );
+
+			if (trace.fraction != 1)
+			{ //nudge the endpos a very small amount from the beginning to the end, so the comp trace hits at the end.
+			//I'm only bothering with this because I want to do a backwards trace too in the comp trace, so if the
+			//blade is sticking through a player or something the standard trace doesn't it, it will make sparks
+			//on each side.
+				vec3_t seDif;
+
+				VectorSubtract(trace.endpos, org_, seDif);
+				VectorNormalize(seDif);
+				trace.endpos[0] += seDif[0]*0.1f;
+				trace.endpos[1] += seDif[1]*0.1f;
+				trace.endpos[2] += seDif[2]*0.1f;
+			}
+
+			if (client->saber[saberNum].blade[bladeNum].storageTime < cg.time)
+			{ //debounce it in case our framerate is absurdly high. Using storageTime since it's not used for anything else in the client.
+				CG_SaberCompWork(org_, trace.endpos, cent);
+
+				client->saber[saberNum].blade[bladeNum].storageTime = cg.time + 5;
+			}
+		}
+
+		for ( i = 0; i < 1; i++ )//was 2 because it would go through architecture and leave saber trails on either side of the brush - but still looks bad if we hit a corner, blade is still 8 longer than hit
+		{
+			if ( i )
+			{//tracing from end to base
+				CG_Trace( &trace, end, NULL, NULL, org_, ENTITYNUM_NONE, MASK_SOLID );
+			}
+			else
+			{//tracing from base to end
+				CG_Trace( &trace, org_, NULL, NULL, end, ENTITYNUM_NONE, MASK_SOLID );
+			}
+			
+			if ( trace.fraction < 1.0f )
+			{
+				vec3_t trDir;
+				VectorCopy(trace.plane.normal, trDir);
+				if (!trDir[0] && !trDir[1] && !trDir[2])
+				{
+					trDir[1] = 1;
+				}
+				if (!(trace.surfaceFlags & SURF_NOIMPACT) ) // never spark on sky
+				{
+					trap_FX_PlayEffectID( cgs.effects.mSparks, trace.endpos, trDir, -1, -1 );
+				}
+
+				//Stop saber? (it wouldn't look right if it was stuck through a thin wall and unable to hurt players on the other side)
+				VectorSubtract(org_, trace.endpos, v);
+				saberLen = VectorLength(v);
+
+				VectorCopy(trace.endpos, end);
+
+				// All I need is a bool to mark whether I have a previous point to work with.
+				//....come up with something better..
+				if ( client->saber[saberNum].blade[bladeNum].trail.haveOldPos[i] )
+				{
+					if ( trace.entityNum == ENTITYNUM_WORLD || cg_entities[trace.entityNum].currentState.eType == ET_TERRAIN || (cg_entities[trace.entityNum].currentState.eFlags & EF_PERMANENT) )
+					{//only put marks on architecture
+						// Let's do some cool burn/glowing mark bits!!!
+						CG_CreateSaberMarks( client->saber[saberNum].blade[bladeNum].trail.oldPos[i], trace.endpos, trace.plane.normal );
+					
+						//make a sound
+						if ( cg.time - client->saber[saberNum].blade[bladeNum].hitWallDebounceTime >= 100 )
+						{//ugh, need to have a real sound debouncer... or do this game-side
+							client->saber[saberNum].blade[bladeNum].hitWallDebounceTime = cg.time;
+							trap_S_StartSound ( trace.endpos, -1, CHAN_WEAPON, trap_S_RegisterSound( va("sound/weapons/saber/saberhitwall%i", Q_irand(1, 3)) ) );
+						}
+					}
+				}
+				else
+				{
+					// if we impact next frame, we'll mark a slash mark
+					client->saber[saberNum].blade[bladeNum].trail.haveOldPos[i] = qtrue;
+	//				CG_ImpactMark( cgs.media.rivetMarkShader, client->saber[saberNum].blade[bladeNum].trail.oldPos[i], client->saber[saberNum].blade[bladeNum].trail.oldNormal[i],
+	//						0.0f, 1.0f, 1.0f, 1.0f, 1.0f, qfalse, 1.1f, qfalse );
+				}
+
+				// stash point so we can connect-the-dots later
+				VectorCopy( trace.endpos, client->saber[saberNum].blade[bladeNum].trail.oldPos[i] );
+				VectorCopy( trace.plane.normal, client->saber[saberNum].blade[bladeNum].trail.oldNormal[i] );
+			}
+			else
+			{
+				if ( client->saber[saberNum].blade[bladeNum].trail.haveOldPos[i] )
+				{
+					// Hmmm, no impact this frame, but we have an old point
+					// Let's put the mark there, we should use an endcap mark to close the line, but we 
+					//	can probably just get away with a round mark
+	//					CG_ImpactMark( cgs.media.rivetMarkShader, client->saber[saberNum].blade[bladeNum].trail.oldPos[i], client->saber[saberNum].blade[bladeNum].trail.oldNormal[i],
+	//							0.0f, 1.0f, 1.0f, 1.0f, 1.0f, qfalse, 1.1f, qfalse );
+				}
+
+				// we aren't impacting, so turn off our mark tracking mechanism
+				client->saber[saberNum].blade[bladeNum].trail.haveOldPos[i] = qfalse;
+			}
+		}
+	}
+CheckTrail:
+
+	if (!cg_saberTrail.integer)
+	{ //don't do the trail in this case
+		goto JustDoIt;
+	}
+
+	saberTrail = &client->saber[saberNum].blade[bladeNum].trail;
+	saberTrail->duration = saberMoveData[cent->currentState.saberMove].trailLength;
+
+	trailDur = (saberTrail->duration/5.0f);
+	if (!trailDur)
+	{ //hmm.. ok, default
+		if ( BG_SuperBreakWinAnim(cent->currentState.torsoAnim) )
+		{
+			trailDur = 150;
+		}
+		else
+		{
+			trailDur = SABER_TRAIL_TIME;
+		}
+	}
+
+	// if we happen to be timescaled or running in a high framerate situation, we don't want to flood
+	//	the system with very small trail slices...but perhaps doing it by distance would yield better results?
+	if ( cg.time > saberTrail->lastTime + 2 || cg_saberTrail.integer == 2 ) // 2ms
+	{
+		if (!dontDraw)
+		{
+			if ( (BG_SuperBreakWinAnim(cent->currentState.torsoAnim) || saberMoveData[cent->currentState.saberMove].trailLength > 0 || ((cent->currentState.powerups & (1 << PW_SPEED) && cg_speedTrail.integer)) || (cent->currentState.saberInFlight && saberNum == 0)) && cg.time < saberTrail->lastTime + 2000 ) // if we have a stale segment, don't draw until we have a fresh one
+			{
+	#if 0
+				if (cg_saberTrail.integer == 2 && cg_shadows.integer != 2 && cgs.glconfig.stencilBits >= 4)
+				{
+					polyVert_t	verts[4];
+
+					VectorCopy( org_, verts[0].xyz );
+					VectorMA( end, 3.0f, axis_[0], verts[1].xyz );
+					VectorCopy( saberTrail->tip, verts[2].xyz );
+					VectorCopy( saberTrail->base, verts[3].xyz );
+
+					//tc doesn't even matter since we're just gonna stencil an outline, but whatever.
+					verts[0].st[0] = 0;	
+					verts[0].st[1] = 0;	
+					verts[0].modulate[0] = 255;	
+					verts[0].modulate[1] = 255;	
+					verts[0].modulate[2] = 255;	
+					verts[0].modulate[3] = 255;
+
+					verts[1].st[0] = 0;	
+					verts[1].st[1] = 1;	
+					verts[1].modulate[0] = 255;	
+					verts[1].modulate[1] = 255;	
+					verts[1].modulate[2] = 255;	
+					verts[1].modulate[3] = 255;
+
+					verts[2].st[0] = 1;	
+					verts[2].st[1] = 1;	
+					verts[2].modulate[0] = 255;	
+					verts[2].modulate[1] = 255;	
+					verts[2].modulate[2] = 255;	
+					verts[2].modulate[3] = 255;
+
+					verts[3].st[0] = 1;	
+					verts[3].st[1] = 0;	
+					verts[3].modulate[0] = 255;	
+					verts[3].modulate[1] = 255;	
+					verts[3].modulate[2] = 255;	
+					verts[3].modulate[3] = 255;
+
+					//don't capture postrender objects (now we'll postrender the saber so it doesn't get in the capture)
+					trap_R_SetRefractProp(1.0f, 0.0f, qtrue, qtrue);
+
+					//shader 2 is always the crazy refractive shader.
+					trap_R_AddPolyToScene( 2, 4, verts );
+				}
+				else
+	#endif
+				{
+					vec3_t	rgb1={255.0f,255.0f,255.0f};
+
+					switch( scolor )
+					{
+						case SABER_RED:
+							VectorSet( rgb1, 255.0f, 0.0f, 0.0f );
+							break;
+						case SABER_ORANGE:
+							VectorSet( rgb1, 255.0f, 64.0f, 0.0f );
+							break;
+						case SABER_YELLOW:
+							VectorSet( rgb1, 255.0f, 255.0f, 0.0f );
+							break;
+						case SABER_GREEN:
+							VectorSet( rgb1, 0.0f, 255.0f, 0.0f );
+							break;
+						case SABER_BLUE:
+							VectorSet( rgb1, 0.0f, 64.0f, 255.0f );
+							break;
+						case SABER_PURPLE:
+							VectorSet( rgb1, 220.0f, 0.0f, 255.0f );
+							break;
+						default:
+							VectorSet( rgb1, 0.0f, 64.0f, 255.0f );
+							break;
+					}
+
+					//Here we will use the happy process of filling a struct in with arguments and passing it to a trap function
+					//so that we can take the struct and fill in an actual CTrail type using the data within it once we get it
+					//into the effects area
+
+					// Go from new muzzle to new end...then to old end...back down to old muzzle...finally
+					//	connect back to the new muzzle...this is our trail quad
+					VectorCopy( org_, fx.mVerts[0].origin );
+					VectorMA( end, 3.0f, axis_[0], fx.mVerts[1].origin );
+
+					VectorCopy( saberTrail->tip, fx.mVerts[2].origin );
+					VectorCopy( saberTrail->base, fx.mVerts[3].origin );
+
+					diff = cg.time - saberTrail->lastTime;
+
+					// I'm not sure that clipping this is really the best idea
+					//This prevents the trail from showing at all in low framerate situations.
+					//if ( diff <= SABER_TRAIL_TIME * 2 )
+					if ( diff <= 10000 )
+					{ //don't draw it if the last time is way out of date
+						float oldAlpha = 1.0f - ( diff / trailDur );
+
+						// New muzzle
+						VectorCopy( rgb1, fx.mVerts[0].rgb );
+						fx.mVerts[0].alpha = 255.0f;
+
+						fx.mVerts[0].ST[0] = 0.0f;
+						fx.mVerts[0].ST[1] = 1.0f;
+						fx.mVerts[0].destST[0] = 1.0f;
+						fx.mVerts[0].destST[1] = 1.0f;
+
+						// new tip
+						VectorCopy( rgb1, fx.mVerts[1].rgb );
+						fx.mVerts[1].alpha = 255.0f;
+						
+						fx.mVerts[1].ST[0] = 0.0f;
+						fx.mVerts[1].ST[1] = 0.0f;
+						fx.mVerts[1].destST[0] = 1.0f;
+						fx.mVerts[1].destST[1] = 0.0f;
+
+						// old tip
+						VectorCopy( rgb1, fx.mVerts[2].rgb );
+						fx.mVerts[2].alpha = 255.0f;
+
+						fx.mVerts[2].ST[0] = 1.0f - oldAlpha; // NOTE: this just happens to contain the value I want
+						fx.mVerts[2].ST[1] = 0.0f;
+						fx.mVerts[2].destST[0] = 1.0f + fx.mVerts[2].ST[0];
+						fx.mVerts[2].destST[1] = 0.0f;
+
+						// old muzzle
+						VectorCopy( rgb1, fx.mVerts[3].rgb );
+						fx.mVerts[3].alpha = 255.0f;
+
+						fx.mVerts[3].ST[0] = 1.0f - oldAlpha; // NOTE: this just happens to contain the value I want
+						fx.mVerts[3].ST[1] = 1.0f;
+						fx.mVerts[3].destST[0] = 1.0f + fx.mVerts[2].ST[0];
+						fx.mVerts[3].destST[1] = 1.0f;
+
+						if (cg_saberTrail.integer == 2 && cg_shadows.integer != 2 && cgs.glconfig.stencilBits >= 4)
+						{
+							trap_R_SetRefractProp(1.0f, 0.0f, qtrue, qtrue); //don't need to do this every frame.. but..
+
+							if (BG_SaberInAttack(cent->currentState.saberMove)
+								||BG_SuperBreakWinAnim(cent->currentState.torsoAnim))
+							{ //in attack, strong trail
+								fx.mKillTime = 300;
+							}
+							else
+							{ //faded trail
+								fx.mKillTime = 40;
+							}
+							fx.mShader = 2; //2 is always refractive shader
+							fx.mSetFlags = FX_USE_ALPHA;
+						}
+						else
+						{
+							fx.mShader = cgs.media.saberBlurShader;
+							fx.mKillTime = trailDur;
+							fx.mSetFlags = FX_USE_ALPHA;
+						}
+
+						trap_FX_AddPrimitive(&fx);
+					}
+				}
+			}
+		}
+
+		// we must always do this, even if we aren't active..otherwise we won't know where to pick up from
+		VectorCopy( org_, saberTrail->base );
+		VectorMA( end, 3.0f, axis_[0], saberTrail->tip );
+		saberTrail->lastTime = cg.time;
+	}
+
+JustDoIt:
+
+	if (dontDraw)
+	{
+		return;
+	}
+
+	// Pass in the renderfx flags attached to the saber weapon model...this is done so that saber glows
+	//	will get rendered properly in a mirror...not sure if this is necessary??
+	//CG_DoSaber( org_, axis_[0], saberLen, client->saber[saberNum].blade[bladeNum].lengthMax, client->saber[saberNum].blade[bladeNum].radius,
+	//	scolor, renderfx, (qboolean)(saberNum==0&&bladeNum==0) );
+	CG_DoSaber( org_, axis_[0], saberLen, client->saber[saberNum].blade[bladeNum].lengthMax, client->saber[saberNum].blade[bladeNum].radius,
+		scolor, renderfx, (qboolean)(client->saber[saberNum].numBlades < 3) );
+}
+
+int CG_IsMindTricked(int trickIndex1, int trickIndex2, int trickIndex3, int trickIndex4, int client)
+{
+	int checkIn;
+	int sub = 0;
+
+	if (cg_entities[client].currentState.forcePowersActive & (1 << FP_SEE))
+	{
+		return 0;
+	}
+
+	if (client > 47)
+	{
+		checkIn = trickIndex4;
+		sub = 48;
+	}
+	else if (client > 31)
+	{
+		checkIn = trickIndex3;
+		sub = 32;
+	}
+	else if (client > 15)
+	{
+		checkIn = trickIndex2;
+		sub = 16;
+	}
+	else
+	{
+		checkIn = trickIndex1;
+	}
+
+	if (checkIn & (1 << (client-sub)))
+	{
+		return 1;
+	}
+	
+	return 0;
+}
+
+#define SPEED_TRAIL_DISTANCE 6
+
+void CG_DrawPlayerSphere(centity_t *cent, vec3_t origin, float scale, int shader)
+{
+	refEntity_t ent;
+	vec3_t ang;
+	float vLen;
+	vec3_t viewDir;
+	
+	// Don't draw the shield when the player is dead.
+	if (cent->currentState.eFlags & EF_DEAD)
+	{
+		return;
+	}
+
+	memset( &ent, 0, sizeof( ent ) );
+
+	VectorCopy( origin, ent.origin );
+	ent.origin[2] += 9.0;
+
+	VectorSubtract(ent.origin, cg.refdef.vieworg, ent.axis[0]);
+	vLen = VectorLength(ent.axis[0]);
+	if (vLen <= 0.1f)
+	{	// Entity is right on vieworg.  quit.
+		return;
+	}
+
+	VectorCopy(ent.axis[0], viewDir);
+	VectorInverse(viewDir);
+	VectorNormalize(viewDir);
+
+	vectoangles(ent.axis[0], ang);
+	ang[ROLL] += 180.0f;
+	ang[PITCH] += 180.0f;
+	AnglesToAxis(ang, ent.axis);
+
+	VectorScale(ent.axis[0], scale, ent.axis[0]);
+	VectorScale(ent.axis[1], scale, ent.axis[1]);
+	VectorScale(ent.axis[2], scale, ent.axis[2]);
+
+	ent.nonNormalizedAxes = qtrue;
+
+	ent.hModel = cgs.media.halfShieldModel;
+	ent.customShader = shader;	
+
+	trap_R_AddRefEntityToScene( &ent );
+
+	if (!cg.renderingThirdPerson && cent->currentState.number == cg.predictedPlayerState.clientNum)
+	{ //don't do the rest then
+		return;
+	}
+	if (!cg_renderToTextureFX.integer)
+	{
+		return;
+	}
+
+	ang[PITCH] -= 180.0f;
+	AnglesToAxis(ang, ent.axis);
+
+	VectorScale(ent.axis[0], scale*0.5f, ent.axis[0]);
+	VectorScale(ent.axis[1], scale*0.5f, ent.axis[1]);
+	VectorScale(ent.axis[2], scale*0.5f, ent.axis[2]);
+
+	ent.renderfx = (RF_DISTORTION|RF_FORCE_ENT_ALPHA);
+	if (shader == cgs.media.invulnerabilityShader)
+	{ //ok, ok, this is a little hacky. sorry!
+		ent.shaderRGBA[0] = 0;
+		ent.shaderRGBA[1] = 255;
+		ent.shaderRGBA[2] = 0;
+		ent.shaderRGBA[3] = 100;
+	}
+	else if (shader == cgs.media.ysalimariShader)
+	{
+		ent.shaderRGBA[0] = 255;
+		ent.shaderRGBA[1] = 255;
+		ent.shaderRGBA[2] = 0;
+		ent.shaderRGBA[3] = 100;
+	}
+	else if (shader == cgs.media.endarkenmentShader)
+	{
+		ent.shaderRGBA[0] = 100;
+		ent.shaderRGBA[1] = 0;
+		ent.shaderRGBA[2] = 0;
+		ent.shaderRGBA[3] = 20;
+	}
+	else if (shader == cgs.media.enlightenmentShader)
+	{
+		ent.shaderRGBA[0] = 255;
+		ent.shaderRGBA[1] = 255;
+		ent.shaderRGBA[2] = 255;
+		ent.shaderRGBA[3] = 20;
+	}
+	else
+	{ //ysal red/blue, boon
+		ent.shaderRGBA[0] = 255.0f;
+		ent.shaderRGBA[1] = 255.0f;
+		ent.shaderRGBA[2] = 255.0f;
+		ent.shaderRGBA[3] = 20;
+	}
+
+	ent.radius = 256;
+
+	VectorMA(ent.origin, 40.0f, viewDir, ent.origin);
+
+	ent.customShader = trap_R_RegisterShader("effects/refract_2");
+	trap_R_AddRefEntityToScene( &ent );
+}
+
+void CG_AddLightningBeam(vec3_t start, vec3_t end)
+{
+	vec3_t	dir, chaos,
+			c1, c2,
+			v1, v2;
+	float	len,
+			s1, s2, s3;
+
+	addbezierArgStruct_t b;
+
+	VectorCopy(start, b.start);
+	VectorCopy(end, b.end);
+
+	VectorSubtract( b.end, b.start, dir );
+	len = VectorNormalize( dir );
+
+	// Get the base control points, we'll work from there
+	VectorMA( b.start, 0.3333f * len, dir, c1 );
+	VectorMA( b.start, 0.6666f * len, dir, c2 );
+
+	// get some chaos values that really aren't very chaotic :)
+	s1 = sin( cg.time * 0.005f ) * 2 + crandom() * 0.2f;
+	s2 = sin( cg.time * 0.001f );
+	s3 = sin( cg.time * 0.011f );
+
+	VectorSet( chaos, len * 0.01f * s1,
+						len * 0.02f * s2,
+						len * 0.04f * (s1 + s2 + s3));
+
+	VectorAdd( c1, chaos, c1 );
+	VectorScale( chaos, 4.0f, v1 );
+
+	VectorSet( chaos, -len * 0.02f * s3,
+						len * 0.01f * (s1 * s2),
+						-len * 0.02f * (s1 + s2 * s3));
+
+	VectorAdd( c2, chaos, c2 );
+	VectorScale( chaos, 2.0f, v2 );
+
+	VectorSet( chaos, 1.0f, 1.0f, 1.0f );
+
+	VectorCopy(c1, b.control1);
+	VectorCopy(vec3_origin, b.control1Vel);
+	VectorCopy(c2, b.control2);
+	VectorCopy(vec3_origin, b.control2Vel);
+
+	b.size1 = 6.0f;
+	b.size2 = 6.0f;
+	b.sizeParm = 0.0f;
+	b.alpha1 = 0.0f;
+	b.alpha2 = 0.2f;
+	b.alphaParm = 0.5f;
+	
+	/*
+	VectorCopy(WHITE, b.sRGB);
+	VectorCopy(WHITE, b.eRGB);
+	*/
+
+	b.sRGB[0] = 255;
+	b.sRGB[1] = 255;
+	b.sRGB[2] = 255;
+	VectorCopy(b.sRGB, b.eRGB);
+
+	b.rgbParm = 0.0f;
+	b.killTime = 50;
+	b.shader = trap_R_RegisterShader( "gfx/misc/electric2" );
+	b.flags = 0x00000001; //FX_ALPHA_LINEAR
+
+	trap_FX_AddBezier(&b);
+}
+
+void CG_AddRandomLightning(vec3_t start, vec3_t end)
+{
+	vec3_t inOrg, outOrg;
+
+	VectorCopy(start, inOrg);
+	VectorCopy(end, outOrg);
+
+	if ( rand() & 1 )
+	{
+		outOrg[0] += Q_irand(0, 24);
+		inOrg[0] += Q_irand(0, 8);
+	}
+	else
+	{
+		outOrg[0] -= Q_irand(0, 24);
+		inOrg[0] -= Q_irand(0, 8);
+	}
+
+	if ( rand() & 1 )
+	{
+		outOrg[1] += Q_irand(0, 24);
+		inOrg[1] += Q_irand(0, 8);
+	}
+	else
+	{
+		outOrg[1] -= Q_irand(0, 24);
+		inOrg[1] -= Q_irand(0, 8);
+	}
+
+	if ( rand() & 1 )
+	{
+		outOrg[2] += Q_irand(0, 50);
+		inOrg[2] += Q_irand(0, 40);
+	}
+	else
+	{
+		outOrg[2] -= Q_irand(0, 64);
+		inOrg[2] -= Q_irand(0, 40);
+	}
+
+	CG_AddLightningBeam(inOrg, outOrg);
+}
+
+extern char *forceHolocronModels[];
+
+qboolean CG_ThereIsAMaster(void)
+{
+	int i = 0;
+	centity_t *cent;
+
+	while (i < MAX_CLIENTS)
+	{
+		cent = &cg_entities[i];
+
+		if (cent && cent->currentState.isJediMaster)
+		{
+			return qtrue;
+		}
+
+		i++;
+	}
+
+	return qfalse;
+}
+
+#if 0
+void CG_DrawNoForceSphere(centity_t *cent, vec3_t origin, float scale, int shader)
+{
+	refEntity_t ent;
+	
+	// Don't draw the shield when the player is dead.
+	if (cent->currentState.eFlags & EF_DEAD)
+	{
+		return;
+	}
+
+	memset( &ent, 0, sizeof( ent ) );
+
+	VectorCopy( origin, ent.origin );
+	ent.origin[2] += 9.0;
+
+	VectorSubtract(cg.refdef.vieworg, ent.origin, ent.axis[0]);
+	if (VectorNormalize(ent.axis[0]) <= 0.1f)
+	{	// Entity is right on vieworg.  quit.
+		return;
+	}
+
+	VectorCopy(cg.refdef.viewaxis[2], ent.axis[2]);
+	CrossProduct(ent.axis[0], ent.axis[2], ent.axis[1]);
+
+	VectorScale(ent.axis[0], scale, ent.axis[0]);
+	VectorScale(ent.axis[1], scale, ent.axis[1]);
+	VectorScale(ent.axis[2], -scale, ent.axis[2]);
+
+	ent.shaderRGBA[3] = (cent->currentState.genericenemyindex - cg.time)/8;
+	ent.renderfx |= RF_RGB_TINT;
+	if (ent.shaderRGBA[3] > 200)
+	{
+		ent.shaderRGBA[3] = 200;
+	}
+	if (ent.shaderRGBA[3] < 1)
+	{
+		ent.shaderRGBA[3] = 1;
+	}
+
+	ent.shaderRGBA[2] = 0;
+	ent.shaderRGBA[0] = ent.shaderRGBA[1] = ent.shaderRGBA[3];
+
+	ent.hModel = cgs.media.halfShieldModel;
+	ent.customShader = shader;	
+
+	trap_R_AddRefEntityToScene( &ent );
+}
+#endif
+
+//Checks to see if the model string has a * appended with a custom skin name after.
+//If so, it terminates the model string correctly, parses the skin name out, and returns
+//the handle of the registered skin.
+int CG_HandleAppendedSkin(char *modelName)
+{
+	char skinName[MAX_QPATH];
+	char *p;
+	qhandle_t skinID = 0;
+	int i = 0;
+
+	//see if it has a skin name
+	p = Q_strrchr(modelName, '*');
+
+	if (p)
+	{ //found a *, we should have a model name before it and a skin name after it.
+		*p = 0; //terminate the modelName string at this point, then go ahead and parse to the next 0 for the skin.
+		p++;
+
+		while (p && *p)
+		{
+			skinName[i] = *p;
+			i++;
+			p++;
+		}
+		skinName[i] = 0;
+
+		if (skinName[0]) 
+		{ //got it, register the skin under the model path.
+			char baseFolder[MAX_QPATH];
+
+			strcpy(baseFolder, modelName);
+			p = Q_strrchr(baseFolder, '/'); //go back to the first /, should be the path point
+
+			if (p)
+			{ //got it.. terminate at the slash and register.
+				char *useSkinName;
+
+				*p = 0;
+
+				if (strchr(skinName, '|'))
+				{//three part skin
+					useSkinName = va("%s/|%s", baseFolder, skinName);
+				}
+				else
+				{
+					useSkinName = va("%s/model_%s.skin", baseFolder, skinName);
+				}
+
+				skinID = trap_R_RegisterSkin(useSkinName);
+			}
+		}
+	}
+
+	return skinID;
+}
+
+//Create a temporary ghoul2 instance and get the gla name so we can try loading animation data and sounds.
+#include "../namespace_begin.h"
+void BG_GetVehicleModelName(char *modelname);
+void BG_GetVehicleSkinName(char *skinname);
+#include "../namespace_end.h"
+
+void CG_CacheG2AnimInfo(char *modelName)
+{
+	void *g2 = NULL;
+	char *slash;
+	char useModel[MAX_QPATH];
+	char useSkin[MAX_QPATH];
+	int animIndex;
+
+	strcpy(useModel, modelName);
+	strcpy(useSkin, modelName);
+
+	if (modelName[0] == '$')
+	{ //it's a vehicle name actually, let's precache the whole vehicle
+		BG_GetVehicleModelName(useModel);
+		BG_GetVehicleSkinName(useSkin);
+		if ( useSkin[0] )
+		{ //use a custom skin
+			trap_R_RegisterSkin(va("models/players/%s/model_%s.skin", useModel, useSkin));
+		}
+		else
+		{
+			trap_R_RegisterSkin(va("models/players/%s/model_default.skin", useModel));
+		}
+		strcpy(useModel, va("models/players/%s/model.glm", useModel));
+	}
+
+	trap_G2API_InitGhoul2Model(&g2, useModel, 0, 0, 0, 0, 0);
+
+	if (g2)
+	{
+		char GLAName[MAX_QPATH];
+		char originalModelName[MAX_QPATH];
+
+		animIndex = -1;
+
+		GLAName[0] = 0;
+		trap_G2API_GetGLAName(g2, 0, GLAName);
+
+		strcpy(originalModelName, useModel);
+			
+		slash = Q_strrchr( GLAName, '/' );
+		if ( slash )
+		{
+			strcpy(slash, "/animation.cfg");
+
+			animIndex = BG_ParseAnimationFile(GLAName, NULL, qfalse);
+		}
+
+		if (animIndex != -1)
+		{
+			slash = Q_strrchr( originalModelName, '/' );
+			if ( slash )
+			{
+				slash++;
+				*slash = 0;
+			}
+
+			BG_ParseAnimationEvtFile(originalModelName, animIndex, bgNumAnimEvents);
+		}
+
+		//Now free the temp instance
+		trap_G2API_CleanGhoul2Models(&g2);
+	}
+}
+
+static void CG_RegisterVehicleAssets( Vehicle_t *pVeh )
+{
+	/*
+	if ( pVeh->m_pVehicleInfo->exhaustFX )
+	{
+		pVeh->m_pVehicleInfo->iExhaustFX = trap_FX_RegisterEffect( pVeh->m_pVehicleInfo->exhaustFX );
+	}
+	if ( pVeh->m_pVehicleInfo->trailFX )
+	{
+		pVeh->m_pVehicleInfo->iTrailFX = trap_FX_RegisterEffect( pVeh->m_pVehicleInfo->trailFX );
+	}
+	if ( pVeh->m_pVehicleInfo->impactFX )
+	{
+		pVeh->m_pVehicleInfo->iImpactFX = trap_FX_RegisterEffect( pVeh->m_pVehicleInfo->impactFX );
+	}
+	if ( pVeh->m_pVehicleInfo->explodeFX )
+	{
+		pVeh->m_pVehicleInfo->iExplodeFX = trap_FX_RegisterEffect( pVeh->m_pVehicleInfo->explodeFX );
+	}
+	if ( pVeh->m_pVehicleInfo->wakeFX )
+	{
+		pVeh->m_pVehicleInfo->iWakeFX = trap_FX_RegisterEffect( pVeh->m_pVehicleInfo->wakeFX );
+	}
+
+	if ( pVeh->m_pVehicleInfo->dmgFX )
+	{
+		pVeh->m_pVehicleInfo->iDmgFX = trap_FX_RegisterEffect( pVeh->m_pVehicleInfo->dmgFX );
+	}
+	if ( pVeh->m_pVehicleInfo->wpn1FX )
+	{
+		pVeh->m_pVehicleInfo->iWpn1FX = trap_FX_RegisterEffect( pVeh->m_pVehicleInfo->wpn1FX );
+	}
+	if ( pVeh->m_pVehicleInfo->wpn2FX )
+	{
+		pVeh->m_pVehicleInfo->iWpn2FX = trap_FX_RegisterEffect( pVeh->m_pVehicleInfo->wpn2FX );
+	}
+	if ( pVeh->m_pVehicleInfo->wpn1FireFX )
+	{
+		pVeh->m_pVehicleInfo->iWpn1FireFX = trap_FX_RegisterEffect( pVeh->m_pVehicleInfo->wpn1FireFX );
+	}
+	if ( pVeh->m_pVehicleInfo->wpn2FireFX )
+	{
+		pVeh->m_pVehicleInfo->iWpn2FireFX = trap_FX_RegisterEffect( pVeh->m_pVehicleInfo->wpn2FireFX );
+	}
+	*/
+}
+
+extern void CG_HandleNPCSounds(centity_t *cent);
+
+#include "../namespace_begin.h"
+extern void G_CreateAnimalNPC( Vehicle_t **pVeh, const char *strAnimalType );
+extern void G_CreateSpeederNPC( Vehicle_t **pVeh, const char *strType );
+extern void G_CreateWalkerNPC( Vehicle_t **pVeh, const char *strAnimalType );
+extern void G_CreateFighterNPC( Vehicle_t **pVeh, const char *strType );
+#include "../namespace_end.h"
+
+extern playerState_t *cgSendPS[MAX_GENTITIES];
+void CG_G2AnimEntModelLoad(centity_t *cent)
+{
+	const char *cModelName = CG_ConfigString( CS_MODELS+cent->currentState.modelindex );
+
+	if (!cent->npcClient)
+	{ //have not init'd client yet
+		return;
+	}
+
+	if (cModelName && cModelName[0])
+	{
+		char modelName[MAX_QPATH];
+		int skinID;
+		char *slash;
+
+		strcpy(modelName, cModelName);
+
+		if (cent->currentState.NPC_class == CLASS_VEHICLE && modelName[0] == '$')
+		{ //vehicles pass their veh names over as model names, then we get the model name from the veh type
+			//create a vehicle object clientside for this type
+			char *vehType = &modelName[1];
+			int iVehIndex = BG_VehicleGetIndex( vehType );
+			
+			switch( g_vehicleInfo[iVehIndex].type )
+			{
+				case VH_ANIMAL:
+					// Create the animal (making sure all it's data is initialized).
+					G_CreateAnimalNPC( &cent->m_pVehicle, vehType );
+					break;
+				case VH_SPEEDER:
+					// Create the speeder (making sure all it's data is initialized).
+					G_CreateSpeederNPC( &cent->m_pVehicle, vehType );
+					break;
+				case VH_FIGHTER:
+					// Create the fighter (making sure all it's data is initialized).
+					G_CreateFighterNPC( &cent->m_pVehicle, vehType );
+					break;
+				case VH_WALKER:
+					// Create the walker (making sure all it's data is initialized).
+					G_CreateWalkerNPC( &cent->m_pVehicle, vehType );
+					break;
+
+				default:
+					assert(!"vehicle with an unknown type - couldn't create vehicle_t");
+					break;
+			}
+			
+			//set up my happy prediction hack
+			cent->m_pVehicle->m_vOrientation = &cgSendPS[cent->currentState.number]->vehOrientation[0];
+
+			cent->m_pVehicle->m_pParentEntity = (bgEntity_t *)cent;
+
+			//attach the handles for fx cgame-side
+			CG_RegisterVehicleAssets(cent->m_pVehicle);
+
+			BG_GetVehicleModelName(modelName);
+			if (cent->m_pVehicle->m_pVehicleInfo->skin &&
+				cent->m_pVehicle->m_pVehicleInfo->skin[0])
+			{ //use a custom skin
+				skinID = trap_R_RegisterSkin(va("models/players/%s/model_%s.skin", modelName, cent->m_pVehicle->m_pVehicleInfo->skin));
+			}
+			else
+			{
+				skinID = trap_R_RegisterSkin(va("models/players/%s/model_default.skin", modelName));
+			}
+			strcpy(modelName, va("models/players/%s/model.glm", modelName));
+
+			//this sound is *only* used for vehicles now
+			cgs.media.noAmmoSound = trap_S_RegisterSound( "sound/weapons/noammo.wav" );
+		}
+		else
+		{
+			skinID = CG_HandleAppendedSkin(modelName); //get the skin if there is one.
+		}
+
+		if (cent->ghoul2)
+		{ //clean it first!
+            trap_G2API_CleanGhoul2Models(&cent->ghoul2);
+		}
+
+		trap_G2API_InitGhoul2Model(&cent->ghoul2, modelName, 0, skinID, 0, 0, 0);
+
+		if (cent->ghoul2)
+		{
+			char GLAName[MAX_QPATH];
+			char originalModelName[MAX_QPATH];
+			char *saber;
+			int j = 0;
+
+			if (cent->currentState.NPC_class == CLASS_VEHICLE &&
+				cent->m_pVehicle)
+			{ //do special vehicle stuff
+				char strTemp[128];
+				int i;
+
+				// Setup the default first bolt
+				i = trap_G2API_AddBolt( cent->ghoul2, 0, "model_root" );
+
+				// Setup the droid unit.
+				cent->m_pVehicle->m_iDroidUnitTag = trap_G2API_AddBolt( cent->ghoul2, 0, "*droidunit" );
+
+				// Setup the Exhausts.
+				for ( i = 0; i < MAX_VEHICLE_EXHAUSTS; i++ )
+				{
+					Com_sprintf( strTemp, 128, "*exhaust%i", i + 1 );
+					cent->m_pVehicle->m_iExhaustTag[i] = trap_G2API_AddBolt( cent->ghoul2, 0, strTemp );
+				}
+
+				// Setup the Muzzles.
+				for ( i = 0; i < MAX_VEHICLE_MUZZLES; i++ )
+				{
+					Com_sprintf( strTemp, 128, "*muzzle%i", i + 1 );
+					cent->m_pVehicle->m_iMuzzleTag[i] = trap_G2API_AddBolt( cent->ghoul2, 0, strTemp );
+					if ( cent->m_pVehicle->m_iMuzzleTag[i] == -1 )
+					{//ergh, try *flash?
+						Com_sprintf( strTemp, 128, "*flash%i", i + 1 );
+						cent->m_pVehicle->m_iMuzzleTag[i] = trap_G2API_AddBolt( cent->ghoul2, 0, strTemp );
+					}
+				}
+
+				// Setup the Turrets.
+				for ( i = 0; i < MAX_VEHICLE_TURRETS; i++ )
+				{
+					if ( cent->m_pVehicle->m_pVehicleInfo->turret[i].gunnerViewTag )
+					{
+						cent->m_pVehicle->m_iGunnerViewTag[i] = trap_G2API_AddBolt( cent->ghoul2, 0, cent->m_pVehicle->m_pVehicleInfo->turret[i].gunnerViewTag );
+					}
+					else
+					{
+						cent->m_pVehicle->m_iGunnerViewTag[i] = -1;
+					}
+				}
+			}
+
+			if (cent->currentState.npcSaber1)
+			{
+				saber = (char *)CG_ConfigString(CS_MODELS+cent->currentState.npcSaber1);
+				assert(!saber || !saber[0] || saber[0] == '@');
+				//valid saber names should always start with '@' for NPCs
+
+				if (saber && saber[0])
+				{
+					saber++; //skip over the @
+					WP_SetSaber(cent->currentState.number, cent->npcClient->saber, 0, saber);
+				}
+			}
+			if (cent->currentState.npcSaber2)
+			{
+				saber = (char *)CG_ConfigString(CS_MODELS+cent->currentState.npcSaber2);
+				assert(!saber || !saber[0] || saber[0] == '@');
+				//valid saber names should always start with '@' for NPCs
+
+				if (saber && saber[0])
+				{
+					saber++; //skip over the @
+					WP_SetSaber(cent->currentState.number, cent->npcClient->saber, 1, saber);
+				}
+			}
+
+			// If this is a not vehicle, give it saber stuff...
+			if ( cent->currentState.NPC_class != CLASS_VEHICLE )
+			{
+				while (j < MAX_SABERS)
+				{
+					if (cent->npcClient->saber[j].model[0])
+					{
+						if (cent->npcClient->ghoul2Weapons[j])
+						{ //free the old instance(s)
+							trap_G2API_CleanGhoul2Models(&cent->npcClient->ghoul2Weapons[j]);
+							cent->npcClient->ghoul2Weapons[j] = 0;
+						}
+
+						CG_InitG2SaberData(j, cent->npcClient);
+					}
+					j++;
+				}
+			}
+
+			trap_G2API_SetSkin(cent->ghoul2, 0, skinID, skinID);
+
+			cent->localAnimIndex = -1;
+
+			GLAName[0] = 0;
+			trap_G2API_GetGLAName(cent->ghoul2, 0, GLAName);
+
+			strcpy(originalModelName, modelName);
+
+			if (GLAName[0] &&
+				!strstr(GLAName, "players/_humanoid/") /*&&
+				!strstr(GLAName, "players/rockettrooper/")*/)
+			{ //it doesn't use humanoid anims.				
+				slash = Q_strrchr( GLAName, '/' );
+				if ( slash )
+				{
+					strcpy(slash, "/animation.cfg");
+
+					cent->localAnimIndex = BG_ParseAnimationFile(GLAName, NULL, qfalse);
+				}
+			}
+			else
+			{ //humanoid index.
+				trap_G2API_AddBolt(cent->ghoul2, 0, "*r_hand");
+				trap_G2API_AddBolt(cent->ghoul2, 0, "*l_hand");
+
+				//rhand must always be first bolt. lhand always second. Whichever you want the
+				//jetpack bolted to must always be third.
+				trap_G2API_AddBolt(cent->ghoul2, 0, "*chestg");
+
+
+				if (strstr(GLAName, "players/rockettrooper/"))
+				{
+					cent->localAnimIndex = 1;
+				}
+				else
+				{
+					cent->localAnimIndex = 0;
+				}
+
+				if (trap_G2API_AddBolt(cent->ghoul2, 0, "*head_top") == -1)
+				{
+					trap_G2API_AddBolt(cent->ghoul2, 0, "ceyebrow");
+				}
+				trap_G2API_AddBolt(cent->ghoul2, 0, "Motion");
+			}
+
+			// If this is a not vehicle...
+			if ( cent->currentState.NPC_class != CLASS_VEHICLE )
+			{
+				if (trap_G2API_AddBolt(cent->ghoul2, 0, "lower_lumbar") == -1)
+				{ //check now to see if we have this bone for setting anims and such
+					cent->noLumbar = qtrue;
+				}
+
+				if (trap_G2API_AddBolt(cent->ghoul2, 0, "face") == -1)
+				{ //check now to see if we have this bone for setting anims and such
+					cent->noFace = qtrue;
+				}
+			}
+			else
+			{
+				cent->noLumbar = qtrue;
+				cent->noFace = qtrue;
+			}
+
+			if (cent->localAnimIndex != -1)
+			{
+				slash = Q_strrchr( originalModelName, '/' );
+				if ( slash )
+				{
+					slash++;
+					*slash = 0;
+				}
+
+				cent->eventAnimIndex = BG_ParseAnimationEvtFile(originalModelName, cent->localAnimIndex, bgNumAnimEvents);
+			}
+		}
+	}
+
+	trap_S_ShutUp(qtrue);
+	CG_HandleNPCSounds(cent); //handle sound loading here as well.
+	trap_S_ShutUp(qfalse);
+}
+
+//for now this is just gonna create a big explosion on the area of the surface,
+//because I am lazy.
+static void CG_CreateSurfaceDebris(centity_t *cent, int surfNum, int fxID, qboolean throwPart)
+{
+	int lostPartFX = 0;
+	int b;
+	vec3_t v, d;
+	mdxaBone_t boltMatrix;
+	const char *surfName = bgToggleableSurfaces[surfNum];
+
+	if (!cent->ghoul2)
+	{ //oh no
+		return;
+	}
+
+	//let's add the surface as a bolt so we can get the base point of it
+	if (bgToggleableSurfaceDebris[surfNum] == 3)
+	{ //right wing flame
+		b = trap_G2API_AddBolt(cent->ghoul2, 0, "*r_wingdamage");
+		if ( throwPart
+			&& cent->m_pVehicle
+			&& cent->m_pVehicle->m_pVehicleInfo )
+		{
+			lostPartFX = cent->m_pVehicle->m_pVehicleInfo->iRWingFX;
+		}
+	}
+	else if (bgToggleableSurfaceDebris[surfNum] == 4)
+	{ //left wing flame
+		b = trap_G2API_AddBolt(cent->ghoul2, 0, "*l_wingdamage");
+		if ( throwPart
+			&& cent->m_pVehicle
+			&& cent->m_pVehicle->m_pVehicleInfo )
+		{
+			lostPartFX = cent->m_pVehicle->m_pVehicleInfo->iLWingFX;
+		}
+	}
+	else if (bgToggleableSurfaceDebris[surfNum] == 5)
+	{ //right wing flame 2
+		b = trap_G2API_AddBolt(cent->ghoul2, 0, "*r_wingdamage");
+		if ( throwPart
+			&& cent->m_pVehicle
+			&& cent->m_pVehicle->m_pVehicleInfo )
+		{
+			lostPartFX = cent->m_pVehicle->m_pVehicleInfo->iRWingFX;
+		}
+	}
+	else if (bgToggleableSurfaceDebris[surfNum] == 6)
+	{ //left wing flame 2
+		b = trap_G2API_AddBolt(cent->ghoul2, 0, "*l_wingdamage");
+		if ( throwPart
+			&& cent->m_pVehicle
+			&& cent->m_pVehicle->m_pVehicleInfo )
+		{
+			lostPartFX = cent->m_pVehicle->m_pVehicleInfo->iLWingFX;
+		}
+	}
+	else if (bgToggleableSurfaceDebris[surfNum] == 7)
+	{ //nose flame
+		b = trap_G2API_AddBolt(cent->ghoul2, 0, "*nosedamage");
+		if ( cent->m_pVehicle
+			&& cent->m_pVehicle->m_pVehicleInfo )
+		{
+			lostPartFX = cent->m_pVehicle->m_pVehicleInfo->iNoseFX;
+		}
+	}
+	else
+	{
+		b = trap_G2API_AddBolt(cent->ghoul2, 0, surfName);
+	}
+
+	if (b == -1)
+	{ //couldn't find this surface apparently
+		return;
+	}
+
+	//now let's get the position and direction of this surface and make a big explosion
+	trap_G2API_GetBoltMatrix(cent->ghoul2, 0, b, &boltMatrix, cent->lerpAngles, cent->lerpOrigin, cg.time,
+		cgs.gameModels, cent->modelScale);
+	BG_GiveMeVectorFromMatrix(&boltMatrix, ORIGIN, v);
+	BG_GiveMeVectorFromMatrix(&boltMatrix, POSITIVE_Z, d);
+
+	trap_FX_PlayEffectID(fxID, v, d, -1, -1);
+	if ( throwPart && lostPartFX )
+	{//throw off a ship part, too
+		vec3_t	fxFwd;
+		AngleVectors( cent->lerpAngles, fxFwd, NULL, NULL );
+		trap_FX_PlayEffectID(lostPartFX, v, fxFwd, -1, -1);
+	}
+}
+
+//for now this is just gonna create a big explosion on the area of the surface,
+//because I am lazy.
+static void CG_CreateSurfaceSmoke(centity_t *cent, int shipSurf, int fxID)
+{
+	int b = -1;
+	vec3_t v, d;
+	mdxaBone_t boltMatrix;
+	const char *surfName = NULL;
+
+	if (!cent->ghoul2)
+	{ //oh no
+		return;
+	}
+
+	//let's add the surface as a bolt so we can get the base point of it
+	if ( shipSurf == SHIPSURF_FRONT )
+	{ //front flame/smoke
+		surfName = "*nosedamage";
+	}
+	else if (shipSurf == SHIPSURF_BACK )
+	{ //back flame/smoke
+		surfName = "*exhaust1";//FIXME: random?  Some point in-between?
+	}
+	else if (shipSurf == SHIPSURF_RIGHT )
+	{ //right wing flame/smoke
+		surfName = "*r_wingdamage";
+	}
+	else if (shipSurf == SHIPSURF_LEFT )
+	{ //left wing flame/smoke
+		surfName = "*l_wingdamage";
+	}
+	else
+	{//unknown surf!
+		return;
+	}
+	b = trap_G2API_AddBolt(cent->ghoul2, 0, surfName);
+	if (b == -1)
+	{ //couldn't find this surface apparently
+		return;
+	}
+
+	//now let's get the position and direction of this surface and make a big explosion
+	trap_G2API_GetBoltMatrix(cent->ghoul2, 0, b, &boltMatrix, cent->lerpAngles, cent->lerpOrigin, cg.time,
+		cgs.gameModels, cent->modelScale);
+	BG_GiveMeVectorFromMatrix(&boltMatrix, ORIGIN, v);
+	BG_GiveMeVectorFromMatrix(&boltMatrix, POSITIVE_Z, d);
+
+	trap_FX_PlayEffectID(fxID, v, d, -1, -1);
+}
+
+#define SMOOTH_G2ANIM_LERPANGLES
+
+qboolean CG_VehicleShouldDrawShields( centity_t *vehCent )
+{
+	if ( vehCent->damageTime > cg.time //ship shields currently taking damage
+		&& vehCent->currentState.NPC_class == CLASS_VEHICLE 
+		&& vehCent->m_pVehicle
+		&& vehCent->m_pVehicle->m_pVehicleInfo )
+	{
+		return qtrue;
+	}
+	return qfalse;
+}
+
+/*
+extern	vmCvar_t		cg_showVehBounds;
+extern void BG_VehicleAdjustBBoxForOrientation( Vehicle_t *veh, vec3_t origin, vec3_t mins, vec3_t maxs,
+										int clientNum, int tracemask,
+										void (*localTrace)(trace_t *results, const vec3_t start, const vec3_t mins, const vec3_t maxs, const vec3_t end, int passEntityNum, int contentMask)); // bg_pmove.c
+*/
+qboolean CG_VehicleAttachDroidUnit( centity_t *droidCent, refEntity_t *legs )
+{
+	if ( droidCent
+		&& droidCent->currentState.owner 
+		&& droidCent->currentState.clientNum >= MAX_CLIENTS )
+	{//the only NPCs that can ride a vehicle are droids...???
+		centity_t *vehCent = &cg_entities[droidCent->currentState.owner];
+		if ( vehCent 
+			&& vehCent->m_pVehicle 
+			&& vehCent->ghoul2
+			&& vehCent->m_pVehicle->m_iDroidUnitTag != -1 )
+		{
+			mdxaBone_t boltMatrix;
+			vec3_t	fwd, rt, tempAng;
+
+			trap_G2API_GetBoltMatrix(vehCent->ghoul2, 0, vehCent->m_pVehicle->m_iDroidUnitTag, &boltMatrix, vehCent->lerpAngles, vehCent->lerpOrigin, cg.time,
+				cgs.gameModels, vehCent->modelScale);
+			BG_GiveMeVectorFromMatrix(&boltMatrix, ORIGIN, droidCent->lerpOrigin);
+			BG_GiveMeVectorFromMatrix(&boltMatrix, POSITIVE_X, fwd);//WTF???
+			BG_GiveMeVectorFromMatrix(&boltMatrix, NEGATIVE_Y, rt);//WTF???
+			vectoangles( fwd, droidCent->lerpAngles );
+			vectoangles( rt, tempAng );
+			droidCent->lerpAngles[ROLL] = tempAng[PITCH];
+			
+			return qtrue;
+		}
+	}
+	return qfalse;
+}
+
+void CG_G2Animated( centity_t *cent )
+{
+#ifdef SMOOTH_G2ANIM_LERPANGLES
+	float angSmoothFactor = 0.7f;
+#endif
+
+
+	if (!cent->ghoul2)
+	{ //Initialize this g2 anim ent, then return (will start rendering next frame)
+		CG_G2AnimEntModelLoad(cent);
+		cent->npcLocalSurfOff = 0;
+		cent->npcLocalSurfOn = 0;
+		return;
+	}
+
+	if (cent->npcLocalSurfOff != cent->currentState.surfacesOff ||
+		cent->npcLocalSurfOn != cent->currentState.surfacesOn)
+	{ //looks like it's time for an update.
+		int i = 0;
+
+		while (i < BG_NUM_TOGGLEABLE_SURFACES && bgToggleableSurfaces[i])
+		{
+			if (!(cent->npcLocalSurfOff & (1 << i)) &&
+				(cent->currentState.surfacesOff & (1 << i)))
+			{ //it wasn't off before but it's off now, so reflect this change in the g2 instance.
+				if (bgToggleableSurfaceDebris[i] > 0)
+				{ //make some local debris of this thing?
+					//FIXME: throw off the proper model effect, too
+					CG_CreateSurfaceDebris(cent, i, cgs.effects.mShipDestDestroyed, qtrue);
+				}
+
+				trap_G2API_SetSurfaceOnOff(cent->ghoul2, bgToggleableSurfaces[i], TURN_OFF);
+			}
+
+			if (!(cent->npcLocalSurfOn & (1 << i)) &&
+				(cent->currentState.surfacesOn & (1 << i)))
+			{ //same as above, but on instead of off.
+				trap_G2API_SetSurfaceOnOff(cent->ghoul2, bgToggleableSurfaces[i], TURN_ON);
+			}
+
+			i++;
+		}
+
+		cent->npcLocalSurfOff = cent->currentState.surfacesOff;
+		cent->npcLocalSurfOn = cent->currentState.surfacesOn;
+	}
+
+
+	/*
+	if (cent->currentState.weapon &&
+		!trap_G2API_HasGhoul2ModelOnIndex(&(cent->ghoul2), 1) &&
+		!(cent->currentState.eFlags & EF_DEAD))
+	{ //if the server says we have a weapon and we haven't copied one onto ourselves yet, then do so.
+		trap_G2API_CopySpecificGhoul2Model(g2WeaponInstances[cent->currentState.weapon], 0, cent->ghoul2, 1);
+
+		if (cent->currentState.weapon == WP_SABER)
+		{
+			trap_S_StartSound(cent->lerpOrigin, cent->currentState.number, CHAN_AUTO, trap_S_RegisterSound( "sound/weapons/saber/saberon.wav" ));
+		}
+	}
+	*/
+
+	if (cent->torsoBolt && !(cent->currentState.eFlags & EF_DEAD))
+	{ //he's alive and has a limb missing still, reattach it and reset the weapon
+		CG_ReattachLimb(cent);
+	}
+
+	if (((cent->currentState.eFlags & EF_DEAD) || (cent->currentState.eFlags & EF_RAG)) && !cent->localAnimIndex)
+	{
+		vec3_t forcedAngles;
+
+		VectorClear(forcedAngles);
+		forcedAngles[YAW] = cent->lerpAngles[YAW];
+
+		CG_RagDoll(cent, forcedAngles);
+	}
+
+#ifdef SMOOTH_G2ANIM_LERPANGLES
+	if ((cent->lerpAngles[YAW] > 0 && cent->smoothYaw < 0) ||
+		(cent->lerpAngles[YAW] < 0 && cent->smoothYaw > 0))
+	{ //keep it from snapping around on the threshold
+		cent->smoothYaw = -cent->smoothYaw;
+	}
+	cent->lerpAngles[YAW] = cent->smoothYaw+(cent->lerpAngles[YAW]-cent->smoothYaw)*angSmoothFactor;
+	cent->smoothYaw = cent->lerpAngles[YAW];
+#endif
+
+	//now just render as a player
+	CG_Player(cent);
+
+	/*
+	if ( cg_showVehBounds.integer )
+	{//show vehicle bboxes
+		if ( cent->currentState.clientNum >= MAX_CLIENTS
+			&& cent->currentState.NPC_class == CLASS_VEHICLE 
+			&& cent->m_pVehicle
+			&& cent->m_pVehicle->m_pVehicleInfo 
+			&& cent->currentState.clientNum != cg.predictedVehicleState.clientNum )
+		{//not the predicted vehicle
+			vec3_t NPCDEBUG_RED = {1.0, 0.0, 0.0};
+			vec3_t absmin, absmax;
+			vec3_t bmins, bmaxs;
+			float *old = cent->m_pVehicle->m_vOrientation;
+			cent->m_pVehicle->m_vOrientation = &cent->lerpAngles[0];
+
+			BG_VehicleAdjustBBoxForOrientation( cent->m_pVehicle, cent->lerpOrigin, bmins, bmaxs,
+										cent->currentState.number, MASK_PLAYERSOLID, NULL );
+			cent->m_pVehicle->m_vOrientation = old;
+
+			VectorAdd( cent->lerpOrigin, bmins, absmin );
+			VectorAdd( cent->lerpOrigin, bmaxs, absmax );
+			CG_Cube( absmin, absmax, NPCDEBUG_RED, 0.25 );
+		}
+	}
+	*/
+}
+//rww - here ends the majority of my g2animent stuff.
+
+//Disabled for now, I'm too lazy to keep it working with all the stuff changing around.
+#if 0
+int cgFPLSState = 0;
+
+void CG_ForceFPLSPlayerModel(centity_t *cent, clientInfo_t *ci)
+{
+	animation_t *anim;
+
+	if (cg_fpls.integer && !cg.renderingThirdPerson)
+	{
+		int				skinHandle;
+
+		skinHandle = trap_R_RegisterSkin("models/players/kyle/model_fpls2.skin");
+
+		trap_G2API_CleanGhoul2Models(&(ci->ghoul2Model));
+
+		ci->torsoSkin = skinHandle;
+		trap_G2API_InitGhoul2Model(&ci->ghoul2Model, "models/players/kyle/model.glm", 0, ci->torsoSkin, 0, 0, 0);
+
+		ci->bolt_rhand = trap_G2API_AddBolt(ci->ghoul2Model, 0, "*r_hand");
+		
+		trap_G2API_SetBoneAnim(ci->ghoul2Model, 0, "model_root", 0, 12, BONE_ANIM_OVERRIDE_LOOP, 1.0f, cg.time, -1, -1);
+		trap_G2API_SetBoneAngles(ci->ghoul2Model, 0, "upper_lumbar", vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, NULL, 0, cg.time);
+		trap_G2API_SetBoneAngles(ci->ghoul2Model, 0, "cranium", vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_Z, NEGATIVE_Y, POSITIVE_X, NULL, 0, cg.time);
+
+		ci->bolt_lhand = trap_G2API_AddBolt(ci->ghoul2Model, 0, "*l_hand");
+
+		//rhand must always be first bolt. lhand always second. Whichever you want the
+		//jetpack bolted to must always be third.
+		trap_G2API_AddBolt(ci->ghoul2Model, 0, "*chestg");
+
+		ci->bolt_head = trap_G2API_AddBolt(ci->ghoul2Model, 0, "*head_top");
+		if (ci->bolt_head == -1)
+		{
+			ci->bolt_head = trap_G2API_AddBolt(ci->ghoul2Model, 0, "ceyebrow");
+		}
+
+		ci->bolt_motion = trap_G2API_AddBolt(ci->ghoul2Model, 0, "Motion");
+
+		//We need a lower lumbar bolt for footsteps
+		ci->bolt_llumbar = trap_G2API_AddBolt(ci->ghoul2Model, 0, "lower_lumbar");
+
+		CG_CopyG2WeaponInstance(cent, cent->currentState.weapon, ci->ghoul2Model);
+	}
+	else
+	{
+		CG_RegisterClientModelname(ci, ci->modelName, ci->skinName, ci->teamName, cent->currentState.number);
+	}
+
+	anim = &bgAllAnims[cent->localAnimIndex].anims[ cent->currentState.legsAnim ];
+
+	if (anim)
+	{
+		int flags = BONE_ANIM_OVERRIDE_FREEZE;
+		int firstFrame = anim->firstFrame;
+		int setFrame = -1;
+		float animSpeed = 50.0f / anim->frameLerp;
+
+		if (anim->loopFrames != -1)
+		{
+			flags = BONE_ANIM_OVERRIDE_LOOP;
+		}
+
+		if (cent->pe.legs.frame >= anim->firstFrame && cent->pe.legs.frame <= (anim->firstFrame + anim->numFrames))
+		{
+			setFrame = cent->pe.legs.frame;
+		}
+
+		trap_G2API_SetBoneAnim(ci->ghoul2Model, 0, "model_root", firstFrame, anim->firstFrame + anim->numFrames, flags, animSpeed, cg.time, setFrame, 150);
+
+		cent->currentState.legsAnim = 0;
+	}
+
+	anim = &bgAllAnims[cent->localAnimIndex].anims[ cent->currentState.torsoAnim ];
+
+	if (anim)
+	{
+		int flags = BONE_ANIM_OVERRIDE_FREEZE;
+		int firstFrame = anim->firstFrame;
+		int setFrame = -1;
+		float animSpeed = 50.0f / anim->frameLerp;
+
+		if (anim->loopFrames != -1)
+		{
+			flags = BONE_ANIM_OVERRIDE_LOOP;
+		}
+
+		if (cent->pe.torso.frame >= anim->firstFrame && cent->pe.torso.frame <= (anim->firstFrame + anim->numFrames))
+		{
+			setFrame = cent->pe.torso.frame;
+		}
+
+		trap_G2API_SetBoneAnim(ci->ghoul2Model, 0, "lower_lumbar", firstFrame, anim->firstFrame + anim->numFrames, flags, animSpeed, cg.time, setFrame, 150);
+
+		cent->currentState.torsoAnim = 0;
+	}
+
+	trap_G2API_CleanGhoul2Models(&(cent->ghoul2));
+	trap_G2API_DuplicateGhoul2Instance(ci->ghoul2Model, &cent->ghoul2);
+
+	//Attach the instance to this entity num so we can make use of client-server
+	//shared operations if possible.
+	trap_G2API_AttachInstanceToEntNum(cent->ghoul2, cent->currentState.number, qfalse);
+}
+#endif
+
+//for allocating and freeing npc clientinfo structures.
+//Remember to free this before game shutdown no matter what
+//and don't stomp over it, as it is dynamic memory from the
+//exe.
+void CG_CreateNPCClient(clientInfo_t **ci)
+{
+	//trap_TrueMalloc((void **)ci, sizeof(clientInfo_t));
+	*ci = (clientInfo_t *) BG_Alloc(sizeof(clientInfo_t));
+}
+
+void CG_DestroyNPCClient(clientInfo_t **ci)
+{
+	memset(*ci, 0, sizeof(clientInfo_t));
+	//trap_TrueFree((void **)ci);
+}
+
+static void CG_ForceElectrocution( centity_t *cent, const vec3_t origin, vec3_t tempAngles, qhandle_t shader, qboolean alwaysDo )
+{
+	// Undoing for now, at least this code should compile if I ( or anyone else ) decides to work on this effect
+	qboolean	found = qfalse;
+	vec3_t		fxOrg, fxOrg2, dir;
+	vec3_t		rgb;
+	mdxaBone_t	boltMatrix;
+	trace_t		tr;
+	int bolt=-1;
+	int iter=0;
+	int torsoBolt = -1;
+	int crotchBolt = -1;
+	int elbowLBolt = -1;
+	int elbowRBolt = -1;
+	int handLBolt = -1;
+	int handRBolt = -1;
+	int kneeLBolt = -1;
+	int kneeRBolt = -1;
+	int footLBolt = -1;
+	int footRBolt = -1;
+
+	VectorSet(rgb, 1, 1, 1);
+
+	if (cent->localAnimIndex <= 1)
+	{ //humanoid
+		torsoBolt = trap_G2API_AddBolt(cent->ghoul2, 0, "lower_lumbar");
+		crotchBolt = trap_G2API_AddBolt(cent->ghoul2, 0, "pelvis");
+		elbowLBolt = trap_G2API_AddBolt(cent->ghoul2, 0, "*l_arm_elbow");
+		elbowRBolt = trap_G2API_AddBolt(cent->ghoul2, 0, "*r_arm_elbow");
+		handLBolt = trap_G2API_AddBolt(cent->ghoul2, 0, "*l_hand");
+		handRBolt = trap_G2API_AddBolt(cent->ghoul2, 0, "*r_hand");
+		kneeLBolt = trap_G2API_AddBolt(cent->ghoul2, 0, "*hips_l_knee");
+		kneeRBolt = trap_G2API_AddBolt(cent->ghoul2, 0, "*hips_r_knee");
+		footLBolt = trap_G2API_AddBolt(cent->ghoul2, 0, "*l_leg_foot");
+		footRBolt = trap_G2API_AddBolt(cent->ghoul2, 0, "*r_leg_foot");
+	}
+	else if (cent->currentState.NPC_class == CLASS_PROTOCOL)
+	{ //any others that can use these bolts too?
+		torsoBolt = trap_G2API_AddBolt(cent->ghoul2, 0, "lower_lumbar");
+		crotchBolt = trap_G2API_AddBolt(cent->ghoul2, 0, "pelvis");
+		elbowLBolt = trap_G2API_AddBolt(cent->ghoul2, 0, "*bicep_lg");
+		elbowRBolt = trap_G2API_AddBolt(cent->ghoul2, 0, "*bicep_rg");
+		handLBolt = trap_G2API_AddBolt(cent->ghoul2, 0, "*hand_l");
+		handRBolt = trap_G2API_AddBolt(cent->ghoul2, 0, "*weapon");
+		kneeLBolt = trap_G2API_AddBolt(cent->ghoul2, 0, "*thigh_lg");
+		kneeRBolt = trap_G2API_AddBolt(cent->ghoul2, 0, "*thigh_rg");
+		footLBolt = trap_G2API_AddBolt(cent->ghoul2, 0, "*foot_lg");
+		footRBolt = trap_G2API_AddBolt(cent->ghoul2, 0, "*foot_rg");
+	}
+
+	// Pick a random start point
+	while (bolt<0)
+	{
+		int test;
+		if (iter>5)
+		{
+			test=iter-5;
+		}
+		else
+		{
+			test=Q_irand(0,6);
+		}
+		switch(test)
+		{
+		case 0:
+			// Right Elbow
+			bolt=elbowRBolt;
+			break;
+		case 1:
+			// Left Hand
+			bolt=handLBolt;
+			break;
+		case 2:
+			// Right hand
+			bolt=handRBolt;
+			break;
+		case 3:
+			// Left Foot
+			bolt=footLBolt;
+			break;
+		case 4:
+			// Right foot
+			bolt=footRBolt;
+			break;
+		case 5:
+			// Torso
+			bolt=torsoBolt;
+			break;
+		case 6:
+		default:
+			// Left Elbow
+			bolt=elbowLBolt;
+			break;
+		}
+		if (++iter==20)
+			break;
+	}
+	if (bolt>=0)
+	{
+		found = trap_G2API_GetBoltMatrix( cent->ghoul2, 0, bolt, 
+				&boltMatrix, tempAngles, origin, cg.time, 
+				cgs.gameModels, cent->modelScale);
+	}
+
+	// Make sure that it's safe to even try and get these values out of the Matrix, otherwise the values could be garbage
+	if ( found )
+	{
+		BG_GiveMeVectorFromMatrix( &boltMatrix, ORIGIN, fxOrg );
+		if ( random() > 0.5f )
+		{
+			BG_GiveMeVectorFromMatrix( &boltMatrix, NEGATIVE_X, dir );
+		}
+		else
+		{
+			BG_GiveMeVectorFromMatrix( &boltMatrix, NEGATIVE_Y, dir );
+		}
+
+		// Add some fudge, makes us not normalized, but that isn't really important
+		dir[0] += crandom() * 0.4f;
+		dir[1] += crandom() * 0.4f;
+		dir[2] += crandom() * 0.4f;
+	}
+	else
+	{
+		// Just use the lerp Origin and a random direction
+		VectorCopy( cent->lerpOrigin, fxOrg );
+		VectorSet( dir, crandom(), crandom(), crandom() ); // Not normalized, but who cares.
+		switch ( cent->currentState.NPC_class )
+		{
+		case CLASS_PROBE:
+			fxOrg[2] += 50;
+			break;
+		case CLASS_MARK1:
+			fxOrg[2] += 50;
+			break;
+		case CLASS_ATST:
+			fxOrg[2] += 120;
+			break;
+		default:
+			break;
+		}
+	}
+
+	VectorMA( fxOrg, random() * 40 + 40, dir, fxOrg2 );
+
+	CG_Trace( &tr, fxOrg, NULL, NULL, fxOrg2, -1, CONTENTS_SOLID );
+
+	if ( tr.fraction < 1.0f || random() > 0.94f || alwaysDo )
+	{
+		addElectricityArgStruct_t p;
+
+		VectorCopy(fxOrg, p.start);
+		VectorCopy(tr.endpos, p.end);
+		p.size1 = 1.5f;
+		p.size2 = 4.0f;
+		p.sizeParm = 0.0f;
+		p.alpha1 = 1.0f;
+		p.alpha2 = 0.5f;
+		p.alphaParm = 0.0f;
+		VectorCopy(rgb, p.sRGB);
+		VectorCopy(rgb, p.eRGB);
+		p.rgbParm = 0.0f;
+		p.chaos = 5.0f;
+		p.killTime = (random() * 50 + 100);
+		p.shader = shader;
+		p.flags = (0x00000001 | 0x00000100 | 0x02000000 | 0x04000000 | 0x01000000);
+
+		trap_FX_AddElectricity(&p);
+
+		//In other words:
+		/*
+		FX_AddElectricity( fxOrg, tr.endpos,
+			1.5f, 4.0f, 0.0f, 
+			1.0f, 0.5f, 0.0f,
+			rgb, rgb, 0.0f,
+			5.5f, random() * 50 + 100, shader, FX_ALPHA_LINEAR | FX_SIZE_LINEAR | FX_BRANCH | FX_GROW | FX_TAPER );
+		*/
+	}
+}
+
+void *cg_g2JetpackInstance = NULL;
+
+#define JETPACK_MODEL "models/weapons2/jetpack/model.glm"
+
+void CG_InitJetpackGhoul2(void)
+{
+	if (cg_g2JetpackInstance)
+	{
+		assert(!"Tried to init jetpack inst, already init'd");
+		return;
+	}
+
+	trap_G2API_InitGhoul2Model(&cg_g2JetpackInstance, JETPACK_MODEL, 0, 0, 0, 0, 0);
+
+	assert(cg_g2JetpackInstance);
+
+	//Indicate which bolt on the player we will be attached to
+	//In this case bolt 0 is rhand, 1 is lhand, and 2 is the bolt
+	//for the jetpack (*chestg)
+	trap_G2API_SetBoltInfo(cg_g2JetpackInstance, 0, 2);
+
+	//Add the bolts jet effects will be played from
+	trap_G2API_AddBolt(cg_g2JetpackInstance, 0, "torso_ljet");
+	trap_G2API_AddBolt(cg_g2JetpackInstance, 0, "torso_rjet");
+}
+
+void CG_CleanJetpackGhoul2(void)
+{
+	if (cg_g2JetpackInstance)
+	{
+		trap_G2API_CleanGhoul2Models(&cg_g2JetpackInstance);
+		cg_g2JetpackInstance = NULL;
+	}
+}
+
+#define RARMBIT			(1 << (G2_MODELPART_RARM-10))
+#define RHANDBIT		(1 << (G2_MODELPART_RHAND-10))
+#define WAISTBIT		(1 << (G2_MODELPART_WAIST-10))
+
+#if 0
+static void CG_VehicleHeatEffect( vec3_t org, centity_t *cent )
+{
+	refEntity_t ent;
+	vec3_t ang;
+	float scale;
+	float vLen;
+	float alpha;
+
+	if (!cg_renderToTextureFX.integer)
+	{
+		return;
+	}
+	scale = 0.1f;
+
+	alpha = 200.0f;
+
+	memset( &ent, 0, sizeof( ent ) );
+
+	VectorCopy( org, ent.origin );
+
+	VectorSubtract(ent.origin, cg.refdef.vieworg, ent.axis[0]);
+	vLen = VectorLength(ent.axis[0]);
+	if (VectorNormalize(ent.axis[0]) <= 0.1f)
+	{	// Entity is right on vieworg.  quit.
+		return;
+	}
+
+	vectoangles(ent.axis[0], ang);
+	AnglesToAxis(ang, ent.axis);
+
+	//radius must be a power of 2, and is the actual captured texture size
+	ent.radius = 32;
+
+	VectorScale(ent.axis[0], scale, ent.axis[0]);
+	VectorScale(ent.axis[1], scale, ent.axis[1]);
+	VectorScale(ent.axis[2], -scale, ent.axis[2]);
+
+	ent.hModel = cgs.media.halfShieldModel;
+	ent.customShader = cgs.media.cloakedShader;
+
+	//make it partially transparent so it blends with the background
+	ent.renderfx = (RF_DISTORTION|RF_FORCE_ENT_ALPHA);
+	ent.shaderRGBA[0] = 255.0f;
+	ent.shaderRGBA[1] = 255.0f;
+	ent.shaderRGBA[2] = 255.0f;
+	ent.shaderRGBA[3] = alpha;
+
+	trap_R_AddRefEntityToScene( &ent );
+}
+#endif
+
+static int lastFlyBySound[MAX_GENTITIES] = {0};
+#define	FLYBYSOUNDTIME 2000
+int	cg_lastHyperSpaceEffectTime = 0;
+static CGAME_INLINE void CG_VehicleEffects(centity_t *cent)
+{
+	Vehicle_t *pVehNPC;
+
+	if (cent->currentState.eType != ET_NPC ||
+		cent->currentState.NPC_class != CLASS_VEHICLE ||
+		!cent->m_pVehicle)
+	{
+		return;
+	}
+
+	pVehNPC = cent->m_pVehicle;
+
+	if ( cent->currentState.clientNum == cg.predictedPlayerState.m_iVehicleNum//my vehicle
+		&& (cent->currentState.eFlags2&EF2_HYPERSPACE) )//hyperspacing
+	{//in hyperspace!
+		if ( cg.predictedVehicleState.hyperSpaceTime
+			&& (cg.time-cg.predictedVehicleState.hyperSpaceTime) < HYPERSPACE_TIME )
+		{
+			if ( !cg_lastHyperSpaceEffectTime
+				|| (cg.time - cg_lastHyperSpaceEffectTime) > HYPERSPACE_TIME+500 )
+			{//can't be from the last time we were in hyperspace, so play the effect!
+				trap_FX_PlayBoltedEffectID( cgs.effects.mHyperspaceStars, cent->lerpOrigin, cent->ghoul2, 0, 
+											cent->currentState.number, 0, 0, qtrue );
+				cg_lastHyperSpaceEffectTime = cg.time;
+			}
+		}
+	}
+
+	//FLYBY sound
+	if ( cent->currentState.clientNum != cg.predictedPlayerState.m_iVehicleNum
+		&& (pVehNPC->m_pVehicleInfo->soundFlyBy||pVehNPC->m_pVehicleInfo->soundFlyBy2) )
+	{//not my vehicle
+		if ( cent->currentState.speed && cg.predictedPlayerState.speed+cent->currentState.speed > 500 )
+		{//he's moving and between the two of us, we're moving fast
+			vec3_t diff;
+			VectorSubtract( cent->lerpOrigin, cg.predictedPlayerState.origin, diff );
+			if ( VectorLength( diff ) < 2048 )
+			{//close
+				vec3_t	myFwd, theirFwd;
+				AngleVectors( cg.predictedPlayerState.viewangles, myFwd, NULL, NULL );
+				VectorScale( myFwd, cg.predictedPlayerState.speed, myFwd );
+				AngleVectors( cent->lerpAngles, theirFwd, NULL, NULL );
+				VectorScale( theirFwd, cent->currentState.speed, theirFwd );
+				if ( lastFlyBySound[cent->currentState.clientNum]+FLYBYSOUNDTIME < cg.time )
+				{//okay to do a flyby sound on this vehicle
+					if ( DotProduct( myFwd, theirFwd ) < 500 )
+					{
+						int flyBySound = 0;
+						if ( pVehNPC->m_pVehicleInfo->soundFlyBy && pVehNPC->m_pVehicleInfo->soundFlyBy2 )
+						{
+							flyBySound = Q_irand(0,1)?pVehNPC->m_pVehicleInfo->soundFlyBy:pVehNPC->m_pVehicleInfo->soundFlyBy2;
+						}
+						else if ( pVehNPC->m_pVehicleInfo->soundFlyBy  )
+						{
+							flyBySound = pVehNPC->m_pVehicleInfo->soundFlyBy;
+						}
+						else //if ( pVehNPC->m_pVehicleInfo->soundFlyBy2 )
+						{
+							flyBySound = pVehNPC->m_pVehicleInfo->soundFlyBy2;
+						}
+						trap_S_StartSound(NULL, cent->currentState.clientNum, CHAN_LESS_ATTEN, flyBySound );
+						lastFlyBySound[cent->currentState.clientNum] = cg.time;
+					}
+				}
+			}
+		}
+	}
+
+	if ( !cent->currentState.speed//was stopped
+		&& cent->nextState.speed > 0//now moving forward
+		&& cent->m_pVehicle->m_pVehicleInfo->soundEngineStart )
+	{//engines rev up for the first time
+		trap_S_StartSound(NULL, cent->currentState.clientNum, CHAN_LESS_ATTEN, cent->m_pVehicle->m_pVehicleInfo->soundEngineStart );
+	}
+	// Animals don't exude any effects...
+	if ( pVehNPC->m_pVehicleInfo->type != VH_ANIMAL )
+	{
+		if (pVehNPC->m_pVehicleInfo->surfDestruction && cent->ghoul2)
+		{ //see if anything has been blown off
+			int i = 0;
+			qboolean surfDmg = qfalse;
+
+			while (i < BG_NUM_TOGGLEABLE_SURFACES)
+			{
+				if (bgToggleableSurfaceDebris[i] > 1)
+				{ //this is decidedly a destroyable surface, let's check its status
+					int surfTest = trap_G2API_GetSurfaceRenderStatus(cent->ghoul2, 0, bgToggleableSurfaces[i]);
+
+					if ( surfTest != -1
+						&& (surfTest&TURN_OFF) )
+					{ //it exists, but it's off...
+						surfDmg = qtrue;
+
+						//create some flames
+                        CG_CreateSurfaceDebris(cent, i, cgs.effects.mShipDestBurning, qfalse);
+					}
+				}
+
+				i++;
+			}
+
+			if (surfDmg)
+			{ //if any surface are damaged, neglect exhaust etc effects (so we don't have exhaust trails coming out of invisible surfaces)
+				return;
+			}
+		}
+
+		if ( pVehNPC->m_iLastFXTime <= cg.time )
+		{//until we attach it, we need to debounce this
+			vec3_t	fwd, rt, up;
+			vec3_t	flat;
+			float nextFXDelay = 50;
+			VectorSet(flat, 0, cent->lerpAngles[1], cent->lerpAngles[2]);
+			AngleVectors( flat, fwd, rt, up );
+			if ( cent->currentState.speed > 0 )
+			{//FIXME: only do this when accelerator is being pressed! (must have a driver?)
+				vec3_t	org;
+				qboolean doExhaust = qfalse;
+				VectorMA( cent->lerpOrigin, -16, up, org );
+				VectorMA( org, -42, fwd, org );
+				// Play damage effects.
+				//if ( pVehNPC->m_iArmor <= 75 )
+				if (0)
+				{//hurt
+					trap_FX_PlayEffectID( cgs.effects.mBlackSmoke, org, fwd, -1, -1 );
+				}
+				else if ( pVehNPC->m_pVehicleInfo->iTrailFX )
+				{//okay, do normal trail
+					trap_FX_PlayEffectID( pVehNPC->m_pVehicleInfo->iTrailFX, org, fwd, -1, -1 );
+				}
+				//=====================================================================
+				//EXHAUST FX
+				//=====================================================================
+				//do exhaust
+				if ( (cent->currentState.eFlags&EF_JETPACK_ACTIVE) )
+				{//cheap way of telling us the vehicle is in "turbo" mode
+					doExhaust = (pVehNPC->m_pVehicleInfo->iTurboFX!=0);
+				}
+				else
+				{
+					doExhaust = (pVehNPC->m_pVehicleInfo->iExhaustFX!=0);
+				}
+				if ( doExhaust && cent->ghoul2 )
+				{
+					int i;
+					int fx;
+
+					for ( i = 0; i < MAX_VEHICLE_EXHAUSTS; i++ )
+					{
+						// We hit an invalid tag, we quit (they should be created in order so tough luck if not).
+						if ( pVehNPC->m_iExhaustTag[i] == -1 )
+						{
+							break;
+						}
+
+						if ( (cent->currentState.brokenLimbs&(1<<SHIPSURF_DAMAGE_BACK_HEAVY)) )
+						{//engine has taken heavy damage
+							if ( !Q_irand( 0, 1 ) )
+							{//50% chance of not drawing this engine glow this frame
+								continue;
+							}
+						}
+						else if ( (cent->currentState.brokenLimbs&(1<<SHIPSURF_DAMAGE_BACK_LIGHT)) )
+						{//engine has taken light damage
+							if ( !Q_irand( 0, 4 ) )
+							{//20% chance of not drawing this engine glow this frame
+								continue;
+							}
+						}
+
+						if ( (cent->currentState.eFlags&EF_JETPACK_ACTIVE) //cheap way of telling us the vehicle is in "turbo" mode
+							&& pVehNPC->m_pVehicleInfo->iTurboFX )//they have a valid turbo exhaust effect to play
+						{
+							fx = pVehNPC->m_pVehicleInfo->iTurboFX;
+						}
+						else
+						{//play the normal one
+							fx = pVehNPC->m_pVehicleInfo->iExhaustFX;
+						}
+
+						if (pVehNPC->m_pVehicleInfo->type == VH_FIGHTER)
+						{
+							trap_FX_PlayBoltedEffectID(fx, cent->lerpOrigin, cent->ghoul2, pVehNPC->m_iExhaustTag[i], 
+														cent->currentState.number, 0, 0, qtrue);
+						}
+						else
+						{ //fixme: bolt these too
+							mdxaBone_t boltMatrix;
+							vec3_t boltOrg, boltDir;
+
+							trap_G2API_GetBoltMatrix(cent->ghoul2, 0, pVehNPC->m_iExhaustTag[i], &boltMatrix, flat,
+								cent->lerpOrigin, cg.time, cgs.gameModels, cent->modelScale);
+
+							BG_GiveMeVectorFromMatrix(&boltMatrix, ORIGIN, boltOrg);
+							VectorCopy(fwd, boltDir); //fixme?
+
+							trap_FX_PlayEffectID( fx, boltOrg, boltDir, -1, -1 );
+						}
+					}
+				}
+				//=====================================================================
+				//WING TRAIL FX
+				//=====================================================================
+				//do trail
+				//FIXME: not in space!!!
+				if ( pVehNPC->m_pVehicleInfo->iTrailFX != 0 && cent->ghoul2 )
+				{
+					int i;
+					vec3_t boltOrg, boltDir;
+					mdxaBone_t boltMatrix;
+					vec3_t getBoltAngles;
+
+					VectorCopy(cent->lerpAngles, getBoltAngles);
+					if (pVehNPC->m_pVehicleInfo->type != VH_FIGHTER)
+					{ //only fighters use pitch/roll in refent axis
+                        getBoltAngles[PITCH] = getBoltAngles[ROLL] = 0.0f;
+					}
+
+					for ( i = 1; i < 5; i++ )
+					{
+						int trailBolt = trap_G2API_AddBolt(cent->ghoul2, 0, va("*trail%d",i) );
+						// We hit an invalid tag, we quit (they should be created in order so tough luck if not).
+						if ( trailBolt == -1 )
+						{
+							break;
+						}
+
+						trap_G2API_GetBoltMatrix(cent->ghoul2, 0, trailBolt, &boltMatrix, getBoltAngles,
+							cent->lerpOrigin, cg.time, cgs.gameModels, cent->modelScale);
+
+						BG_GiveMeVectorFromMatrix(&boltMatrix, ORIGIN, boltOrg);
+						VectorCopy(fwd, boltDir); //fixme?
+
+						trap_FX_PlayEffectID( pVehNPC->m_pVehicleInfo->iTrailFX, boltOrg, boltDir, -1, -1 );
+					}
+				}
+			}
+			//FIXME armor needs to be sent over network
+			{
+				if ( (cent->currentState.eFlags&EF_DEAD) )
+				{//just plain dead, use flames 
+					vec3_t	up ={0,0,1};
+					vec3_t boltOrg;
+
+					//if ( pVehNPC->m_iDriverTag == -1 )
+					{//doh!  no tag
+						VectorCopy( cent->lerpOrigin, boltOrg );
+					}
+					//else
+					//{
+					//	mdxaBone_t boltMatrix;
+					//	vec3_t getBoltAngles;
+
+					//	VectorCopy(cent->lerpAngles, getBoltAngles);
+					//	if (pVehNPC->m_pVehicleInfo->type != VH_FIGHTER)
+					//	{ //only fighters use pitch/roll in refent axis
+					//		getBoltAngles[PITCH] = getBoltAngles[ROLL] = 0.0f;
+					//	}
+
+					//	trap_G2API_GetBoltMatrix(cent->ghoul2, 0, pVehNPC->m_iDriverTag, &boltMatrix, getBoltAngles,
+					//		cent->lerpOrigin, cg.time, cgs.gameModels, cent->modelScale);
+
+					//	BG_GiveMeVectorFromMatrix(&boltMatrix, ORIGIN, boltOrg);
+					//}
+					trap_FX_PlayEffectID( cgs.effects.mShipDestBurning, boltOrg, up, -1, -1 );
+				}
+			}
+			if ( cent->currentState.brokenLimbs )
+			{
+				int i;
+				if ( !Q_irand( 0, 5 ) )
+				{
+					for ( i = SHIPSURF_FRONT; i <= SHIPSURF_LEFT; i++ )
+					{
+						if ( (cent->currentState.brokenLimbs&(1<<((i-SHIPSURF_FRONT)+SHIPSURF_DAMAGE_FRONT_HEAVY))) )
+						{//heavy damage, do both effects
+							if ( pVehNPC->m_pVehicleInfo->iInjureFX )
+							{
+								CG_CreateSurfaceSmoke( cent, i, pVehNPC->m_pVehicleInfo->iInjureFX );
+							}
+							if ( pVehNPC->m_pVehicleInfo->iDmgFX )
+							{
+								CG_CreateSurfaceSmoke( cent, i, pVehNPC->m_pVehicleInfo->iDmgFX );
+							}
+						}
+						else if ( (cent->currentState.brokenLimbs&(1<<((i-SHIPSURF_FRONT)+SHIPSURF_DAMAGE_FRONT_LIGHT))) )
+						{//only light damage
+							if ( pVehNPC->m_pVehicleInfo->iInjureFX )
+							{
+								CG_CreateSurfaceSmoke( cent, i, pVehNPC->m_pVehicleInfo->iInjureFX );
+							}
+						}
+					}
+				}
+			}
+			/*
+			if ( pVehNPC->m_iArmor <= 50 )
+			{//FIXME: use as a proportion of max armor?
+				VectorMA( cent->lerpOrigin, 64, fwd, org );
+				VectorScale( fwd, -1, fwd );
+				
+				trap_FX_PlayEffectID( cgs.effects.mBlackSmoke, org, fwd, -1, -1 );
+			}
+			if ( pVehNPC->m_iArmor <= 0 )
+			{//FIXME: should use something attached.. but want it to build up over time, so...
+				if ( flrand( 0, cg.time - pVehNPC->m_iDieTime ) < 1000 )
+				{//flaming!
+					VectorMA( cent->lerpOrigin, flrand(-64, 64), fwd, org );
+					VectorScale( fwd, -1, fwd );
+					trap_FX_PlayEffectID( trap_FX_RegisterEffect("ships/fire"), org, fwd, -1, -1 );
+					nextFXDelay = 50;
+				}
+			}
+			*/
+			pVehNPC->m_iLastFXTime = cg.time + nextFXDelay;
+		}
+	}
+}
+
+/*
+===============
+CG_Player
+===============
+*/
+#include "../namespace_begin.h"
+int BG_EmplacedView(vec3_t baseAngles, vec3_t angles, float *newYaw, float constraint);
+#include "../namespace_end.h"
+
+float CG_RadiusForCent( centity_t *cent )
+{
+	if ( cent->currentState.eType == ET_NPC )
+	{
+		if (cent->currentState.NPC_class == CLASS_VEHICLE &&
+			cent->m_pVehicle &&
+			cent->m_pVehicle->m_pVehicleInfo->g2radius)
+		{ //has override
+			return cent->m_pVehicle->m_pVehicleInfo->g2radius;
+		}
+		else if ( cent->currentState.g2radius )
+		{
+			return cent->currentState.g2radius;
+		}
+	}
+	else if ( cent->currentState.g2radius )
+	{
+		return cent->currentState.g2radius;
+	}
+	return 64.0f;
+}
+
+static float cg_vehThirdPersonAlpha = 1.0f;
+extern vec3_t	cg_crosshairPos;
+extern vec3_t	cameraCurLoc;
+void CG_CheckThirdPersonAlpha( centity_t *cent, refEntity_t *legs )
+{
+	float alpha = 1.0f;		
+	int	setFlags = 0;
+
+	if ( cent->m_pVehicle )
+	{//a vehicle 
+		if ( cg.predictedPlayerState.m_iVehicleNum != cent->currentState.clientNum//not mine
+			&& cent->m_pVehicle->m_pVehicleInfo
+			&& cent->m_pVehicle->m_pVehicleInfo->cameraOverride
+			&& cent->m_pVehicle->m_pVehicleInfo->cameraAlpha )//it has alpha
+		{//make sure it's not using any alpha
+			legs->renderfx |= RF_FORCE_ENT_ALPHA;
+			legs->shaderRGBA[3] = 255;
+			return;
+		}
+	}
+
+	if ( !cg.renderingThirdPerson )
+	{
+		return;
+	}
+
+	if ( cg.predictedPlayerState.m_iVehicleNum )
+	{//in a vehicle
+		if ( cg.predictedPlayerState.m_iVehicleNum == cent->currentState.clientNum )
+		{//this is my vehicle
+			if ( cent->m_pVehicle
+				&& cent->m_pVehicle->m_pVehicleInfo
+				&& cent->m_pVehicle->m_pVehicleInfo->cameraOverride
+				&& cent->m_pVehicle->m_pVehicleInfo->cameraAlpha )
+			{//vehicle has auto third-person alpha on
+				trace_t trace;
+				vec3_t	dir2Crosshair, end;
+				VectorSubtract( cg_crosshairPos, cameraCurLoc, dir2Crosshair );
+				VectorNormalize( dir2Crosshair );
+				VectorMA( cameraCurLoc, cent->m_pVehicle->m_pVehicleInfo->cameraRange*2.0f, dir2Crosshair, end );
+				CG_G2Trace( &trace, cameraCurLoc, vec3_origin, vec3_origin, end, ENTITYNUM_NONE, CONTENTS_BODY );
+				if ( trace.entityNum == cent->currentState.clientNum 
+					|| trace.entityNum == cg.predictedPlayerState.clientNum)
+				{//hit me or the vehicle I'm in
+					cg_vehThirdPersonAlpha -= 0.1f*cg.frametime/50.0f;
+					if ( cg_vehThirdPersonAlpha < cent->m_pVehicle->m_pVehicleInfo->cameraAlpha )
+					{
+						cg_vehThirdPersonAlpha = cent->m_pVehicle->m_pVehicleInfo->cameraAlpha;
+					}
+				}
+				else
+				{
+					cg_vehThirdPersonAlpha += 0.1f*cg.frametime/50.0f;
+					if ( cg_vehThirdPersonAlpha > 1.0f )
+					{
+						cg_vehThirdPersonAlpha = 1.0f;
+					}
+				}
+				alpha = cg_vehThirdPersonAlpha;
+			}
+			else
+			{//use the cvar
+				//reset this
+				cg_vehThirdPersonAlpha = 1.0f;
+				//use the cvar
+				alpha = cg_thirdPersonAlpha.value;
+			}
+		}
+	}
+	else if ( cg.predictedPlayerState.clientNum == cent->currentState.clientNum )
+	{//it's me
+		//reset this
+		cg_vehThirdPersonAlpha = 1.0f;
+		//use the cvar
+		setFlags = RF_FORCE_ENT_ALPHA;
+		alpha = cg_thirdPersonAlpha.value;
+	}
+	
+	if ( alpha < 1.0f )
+	{
+		legs->renderfx |= setFlags;
+		legs->shaderRGBA[3] = (unsigned char)(alpha * 255.0f);
+	}
+}
+
+void CG_Player( centity_t *cent ) {
+	clientInfo_t	*ci;
+	refEntity_t		legs;
+	refEntity_t		torso;
+	int				clientNum;
+	int				renderfx;
+	qboolean		shadow = qfalse;
+	float			shadowPlane = 0;
+	qboolean		dead = qfalse;
+	vec3_t			rootAngles;
+	float			angle;
+	vec3_t			angles, dir, elevated, enang, seekorg;
+	int				iwantout = 0, successchange = 0;
+	int				team;
+	mdxaBone_t 		boltMatrix, lHandMatrix;
+	int				doAlpha = 0;
+	qboolean		gotLHandMatrix = qfalse;
+	qboolean		g2HasWeapon = qfalse;
+	qboolean		drawPlayerSaber = qfalse;
+	qboolean		checkDroidShields = qfalse;
+
+	//first if we are not an npc and we are using an emplaced gun then make sure our
+	//angles are visually capped to the constraints (otherwise it's possible to lerp
+	//a little outside and look kind of twitchy)
+	if (cent->currentState.weapon == WP_EMPLACED_GUN &&
+		cent->currentState.otherEntityNum2)
+	{
+		float empYaw;
+
+		if (BG_EmplacedView(cent->lerpAngles, cg_entities[cent->currentState.otherEntityNum2].currentState.angles, &empYaw, cg_entities[cent->currentState.otherEntityNum2].currentState.origin2[0]))
+		{
+			cent->lerpAngles[YAW] = empYaw;
+		}
+	}
+
+	if (cent->currentState.iModelScale)
+	{ //if the server says we have a custom scale then set it now.
+		cent->modelScale[0] = cent->modelScale[1] = cent->modelScale[2] = cent->currentState.iModelScale/100.0f;
+	}
+	else
+	{
+		VectorClear(cent->modelScale);
+	}
+
+	if ((cg_smoothClients.integer || cent->currentState.heldByClient) && (cent->currentState.groundEntityNum >= ENTITYNUM_WORLD || cent->currentState.eType == ET_TERRAIN) &&
+		!(cent->currentState.eFlags2 & EF2_HYPERSPACE) && cg.predictedPlayerState.m_iVehicleNum != cent->currentState.number)
+	{ //always smooth when being thrown
+		vec3_t			posDif;
+		float			smoothFactor;
+		int				k = 0;
+		float			fTolerance = 20000.0f;
+
+		if (cent->currentState.heldByClient)
+		{ //smooth the origin more when in this state, because movement is origin-based on server.
+			smoothFactor = 0.2f;
+		}
+		else if ( (cent->currentState.powerups & (1 << PW_SPEED)) ||
+			(cent->currentState.forcePowersActive & (1 << FP_RAGE)) )
+		{ //we're moving fast so don't smooth as much
+			smoothFactor = 0.6f;
+		}
+		else if (cent->currentState.eType == ET_NPC && cent->currentState.NPC_class == CLASS_VEHICLE &&
+			cent->m_pVehicle && cent->m_pVehicle->m_pVehicleInfo->type == VH_FIGHTER)
+		{ //greater smoothing for flying vehicles, since they move so fast
+			fTolerance = 6000000.0f;//500000.0f; //yeah, this is so wrong..but..
+			smoothFactor = 0.5f;
+		}
+		else
+		{
+			smoothFactor = 0.5f;
+		}
+		
+		if (DistanceSquared(cent->beamEnd,cent->lerpOrigin) > smoothFactor*fTolerance) //10000
+		{
+			VectorCopy(cent->lerpOrigin, cent->beamEnd);
+		}
+
+		VectorSubtract(cent->lerpOrigin, cent->beamEnd, posDif);
+		
+		for (k=0;k<3;k++)
+		{
+			cent->beamEnd[k]=(cent->beamEnd[k]+posDif[k]*smoothFactor);
+			cent->lerpOrigin[k]=cent->beamEnd[k];
+		}
+	}
+	else
+	{
+		VectorCopy(cent->lerpOrigin, cent->beamEnd);
+	}
+
+	if (cent->currentState.m_iVehicleNum &&
+		cent->currentState.NPC_class != CLASS_VEHICLE)
+	{ //this player is riding a vehicle
+		centity_t *veh = &cg_entities[cent->currentState.m_iVehicleNum];
+
+		cent->lerpAngles[YAW] = veh->lerpAngles[YAW];
+
+		//Attach ourself to the vehicle
+        if (veh->m_pVehicle &&
+			cent->playerState &&
+			veh->playerState &&
+			cent->ghoul2 &&
+			veh->ghoul2 )
+		{
+			if ( veh->currentState.owner != cent->currentState.clientNum )
+			{//FIXME: what about visible passengers?
+				if ( CG_VehicleAttachDroidUnit( cent, &legs ) )
+				{
+					checkDroidShields = qtrue;
+				}
+			}
+			else if ( veh->currentState.owner != ENTITYNUM_NONE)
+			{//has a pilot...???
+				vec3_t oldPSOrg;
+
+				//make sure it has its pilot and parent set
+				veh->m_pVehicle->m_pPilot = (bgEntity_t *)&cg_entities[veh->currentState.owner];
+				veh->m_pVehicle->m_pParentEntity = (bgEntity_t *)veh;
+	            
+				VectorCopy(veh->playerState->origin, oldPSOrg);
+
+				//update the veh's playerstate org for getting the bolt
+				VectorCopy(veh->lerpOrigin, veh->playerState->origin);
+				VectorCopy(cent->lerpOrigin, cent->playerState->origin);
+
+				//Now do the attach
+				VectorCopy(veh->lerpAngles, veh->playerState->viewangles);
+				veh->m_pVehicle->m_pVehicleInfo->AttachRiders(veh->m_pVehicle);
+
+				//copy the "playerstate origin" to the lerpOrigin since that's what we use to display
+				VectorCopy(cent->playerState->origin, cent->lerpOrigin);
+
+				VectorCopy(oldPSOrg, veh->playerState->origin);
+			}
+		}
+	}
+
+	// the client number is stored in clientNum.  It can't be derived
+	// from the entity number, because a single client may have
+	// multiple corpses on the level using the same clientinfo
+	if (cent->currentState.eType != ET_NPC)
+	{
+		clientNum = cent->currentState.clientNum;
+		if ( clientNum < 0 || clientNum >= MAX_CLIENTS ) {
+			CG_Error( "Bad clientNum on player entity");
+		}
+		ci = &cgs.clientinfo[ clientNum ];
+	}
+	else
+	{
+		if (!cent->npcClient)
+		{
+			CG_CreateNPCClient(&cent->npcClient); //allocate memory for it
+
+			if (!cent->npcClient)
+			{
+				assert(0);
+				return;
+			}
+
+			memset(cent->npcClient, 0, sizeof(clientInfo_t));
+			cent->npcClient->ghoul2Model = NULL;
+		}
+
+		assert(cent->npcClient);
+
+		if (cent->npcClient->ghoul2Model != cent->ghoul2 && cent->ghoul2)
+		{
+			cent->npcClient->ghoul2Model = cent->ghoul2;
+			if (cent->localAnimIndex <= 1)
+			{
+				cent->npcClient->bolt_rhand = trap_G2API_AddBolt(cent->npcClient->ghoul2Model, 0, "*r_hand");
+				cent->npcClient->bolt_lhand = trap_G2API_AddBolt(cent->npcClient->ghoul2Model, 0, "*l_hand");
+
+				//rhand must always be first bolt. lhand always second. Whichever you want the
+				//jetpack bolted to must always be third.
+				trap_G2API_AddBolt(cent->npcClient->ghoul2Model, 0, "*chestg");
+
+				cent->npcClient->bolt_head = trap_G2API_AddBolt(cent->npcClient->ghoul2Model, 0, "*head_top");
+				if (cent->npcClient->bolt_head == -1)
+				{
+					cent->npcClient->bolt_head = trap_G2API_AddBolt(cent->npcClient->ghoul2Model, 0, "ceyebrow");
+				}
+				cent->npcClient->bolt_motion = trap_G2API_AddBolt(cent->npcClient->ghoul2Model, 0, "Motion");
+				cent->npcClient->bolt_llumbar = trap_G2API_AddBolt(cent->npcClient->ghoul2Model, 0, "lower_lumbar");
+			}
+			else
+			{
+				cent->npcClient->bolt_rhand = -1;
+				cent->npcClient->bolt_lhand = -1;
+				cent->npcClient->bolt_head = -1;
+				cent->npcClient->bolt_motion = -1;
+				cent->npcClient->bolt_llumbar = -1;
+			}
+			cent->npcClient->team = TEAM_FREE;
+			cent->npcClient->infoValid = qtrue;
+		}
+		ci = cent->npcClient;
+	}
+
+	// it is possible to see corpses from disconnected players that may
+	// not have valid clientinfo
+	if ( !ci->infoValid ) {
+		return;
+	}
+
+	// Add the player to the radar if on the same team and its a team game
+	if (cgs.gametype >= GT_TEAM)
+	{
+		if ( cent->currentState.eType != ET_NPC &&
+			cg.snap->ps.clientNum != cent->currentState.number &&
+			ci->team == cg.snap->ps.persistant[PERS_TEAM] )
+		{
+			CG_AddRadarEnt(cent);
+		}
+	}
+
+	if (cent->currentState.eType == ET_NPC &&
+		cent->currentState.NPC_class == CLASS_VEHICLE)
+	{ //add vehicles
+		CG_AddRadarEnt(cent);
+		if ( CG_InFighter() )
+		{//this is a vehicle, bracket it
+			if ( cg.predictedPlayerState.m_iVehicleNum != cent->currentState.clientNum )
+			{//don't add the vehicle I'm in... :)
+				CG_AddBracketedEnt(cent);
+			}
+		}
+
+	}
+
+	if (!cent->ghoul2)
+	{ //not ready yet?
+#ifdef _DEBUG
+		Com_Printf("WARNING: Client %i has a null ghoul2 instance\n", cent->currentState.number);
+#endif
+		trap_G2API_ClearAttachedInstance(cent->currentState.number);
+
+		if (ci->ghoul2Model &&
+			trap_G2_HaveWeGhoul2Models(ci->ghoul2Model))
+		{
+#ifdef _DEBUG
+			Com_Printf("Clientinfo instance was valid, duplicating for cent\n");
+#endif
+			trap_G2API_DuplicateGhoul2Instance(ci->ghoul2Model, &cent->ghoul2);
+
+			//Attach the instance to this entity num so we can make use of client-server
+			//shared operations if possible.
+			trap_G2API_AttachInstanceToEntNum(cent->ghoul2, cent->currentState.number, qfalse);
+
+			if (trap_G2API_AddBolt(cent->ghoul2, 0, "face") == -1)
+			{ //check now to see if we have this bone for setting anims and such
+				cent->noFace = qtrue;
+			}
+
+			cent->localAnimIndex = CG_G2SkelForModel(cent->ghoul2);
+			cent->eventAnimIndex = CG_G2EvIndexForModel(cent->ghoul2, cent->localAnimIndex);
+		}
+		return;
+	}
+
+	if (ci->superSmoothTime)
+	{ //do crazy smoothing
+		if (ci->superSmoothTime > cg.time)
+		{ //do it
+			trap_G2API_AbsurdSmoothing(cent->ghoul2, qtrue);
+		}
+		else
+		{ //turn it off
+			ci->superSmoothTime = 0;
+			trap_G2API_AbsurdSmoothing(cent->ghoul2, qfalse);
+		}
+	}
+
+	if (cg.predictedPlayerState.pm_type == PM_INTERMISSION)
+	{ //don't show all this shit during intermission
+		return;
+	}
+
+	CG_VehicleEffects(cent);
+
+	if ((cent->currentState.eFlags & EF_JETPACK) && !(cent->currentState.eFlags & EF_DEAD) &&
+		cg_g2JetpackInstance)
+	{ //should have a jetpack attached
+		//1 is rhand weap, 2 is lhand weap (akimbo sabs), 3 is jetpack
+		if (!trap_G2API_HasGhoul2ModelOnIndex(&(cent->ghoul2), 3))
+		{
+			trap_G2API_CopySpecificGhoul2Model(cg_g2JetpackInstance, 0, cent->ghoul2, 3); 
+		}
+
+		if (cent->currentState.eFlags & EF_JETPACK_ACTIVE)
+		{
+			mdxaBone_t mat;
+			vec3_t flamePos, flameDir;
+			int n = 0;
+
+			while (n < 2)
+			{
+				//Get the position/dir of the flame bolt on the jetpack model bolted to the player
+				trap_G2API_GetBoltMatrix(cent->ghoul2, 3, n, &mat, cent->turAngles, cent->lerpOrigin, cg.time, cgs.gameModels, cent->modelScale);
+				BG_GiveMeVectorFromMatrix(&mat, ORIGIN, flamePos);
+
+				if (n == 0)
+				{
+					BG_GiveMeVectorFromMatrix(&mat, NEGATIVE_Y, flameDir);
+					VectorMA(flamePos, -9.5f, flameDir, flamePos);
+					BG_GiveMeVectorFromMatrix(&mat, POSITIVE_X, flameDir);
+					VectorMA(flamePos, -13.5f, flameDir, flamePos);
+				}
+				else
+				{
+					BG_GiveMeVectorFromMatrix(&mat, POSITIVE_X, flameDir);
+					VectorMA(flamePos, -9.5f, flameDir, flamePos);
+					BG_GiveMeVectorFromMatrix(&mat, NEGATIVE_Y, flameDir);
+					VectorMA(flamePos, -13.5f, flameDir, flamePos);
+				}
+
+				if (cent->currentState.eFlags & EF_JETPACK_FLAMING)
+				{ //create effects
+					//FIXME: Just one big effect
+					//Play the effect
+					trap_FX_PlayEffectID(cgs.effects.mBobaJet, flamePos, flameDir, -1, -1);
+					trap_FX_PlayEffectID(cgs.effects.mBobaJet, flamePos, flameDir, -1, -1);
+
+					//Keep the jet fire sound looping
+					trap_S_AddLoopingSound( cent->currentState.number, cent->lerpOrigin, vec3_origin, 
+						trap_S_RegisterSound( "sound/effects/fire_lp" ) );
+				}
+				else
+				{ //just idling
+					//FIXME: Different smaller effect for idle
+					//Play the effect
+					trap_FX_PlayEffectID(cgs.effects.mBobaJet, flamePos, flameDir, -1, -1);
+				}
+
+				n++;
+			}
+
+			trap_S_AddLoopingSound( cent->currentState.number, cent->lerpOrigin, vec3_origin, 
+				trap_S_RegisterSound( "sound/boba/JETHOVER" ) );
+		}
+	}
+	else if (trap_G2API_HasGhoul2ModelOnIndex(&(cent->ghoul2), 3))
+	{ //fixme: would be good if this could be done not every frame
+		trap_G2API_RemoveGhoul2Model(&(cent->ghoul2), 3);
+	}
+
+	g2HasWeapon = trap_G2API_HasGhoul2ModelOnIndex(&(cent->ghoul2), 1);
+
+	if (!g2HasWeapon)
+	{ //force a redup of the weapon instance onto the client instance
+		cent->ghoul2weapon = NULL;
+		cent->weapon = 0;
+	}
+
+	if (cent->torsoBolt && !(cent->currentState.eFlags & EF_DEAD))
+	{ //he's alive and has a limb missing still, reattach it and reset the weapon
+		CG_ReattachLimb(cent);
+	}
+
+	if (cent->isRagging && !(cent->currentState.eFlags & EF_DEAD) && !(cent->currentState.eFlags & EF_RAG))
+	{ //make sure we don't ragdoll ever while alive unless directly told to with eFlags
+		cent->isRagging = qfalse;
+		trap_G2API_SetRagDoll(cent->ghoul2, NULL); //calling with null parms resets to no ragdoll.
+	}
+
+	if (cent->ghoul2 && cent->torsoBolt && ((cent->torsoBolt & RARMBIT) || (cent->torsoBolt & RHANDBIT) || (cent->torsoBolt & WAISTBIT)) && g2HasWeapon)
+	{ //kill the weapon if the limb holding it is no longer on the model
+		trap_G2API_RemoveGhoul2Model(&(cent->ghoul2), 1);
+		g2HasWeapon = qfalse;
+	}
+
+	if (!cent->trickAlphaTime || (cg.time - cent->trickAlphaTime) > 1000)
+	{ //things got out of sync, perhaps a new client is trying to fill in this slot
+		cent->trickAlpha = 255;
+		cent->trickAlphaTime = cg.time;
+	}
+
+	if (cent->currentState.eFlags & EF_NODRAW)
+	{ //If nodraw, return here
+		return;
+	}
+	else if (cent->currentState.eFlags2 & EF2_SHIP_DEATH)
+	{ //died in ship, don't draw, we were "obliterated"
+		return;
+	}
+
+	//If this client has tricked you.
+	if (CG_IsMindTricked(cent->currentState.trickedentindex,
+		cent->currentState.trickedentindex2,
+		cent->currentState.trickedentindex3,
+		cent->currentState.trickedentindex4,
+		cg.snap->ps.clientNum))
+	{
+		if (cent->trickAlpha > 1)
+		{
+			cent->trickAlpha -= (cg.time - cent->trickAlphaTime)*0.5;
+			cent->trickAlphaTime = cg.time;
+
+			if (cent->trickAlpha < 0)
+			{
+				cent->trickAlpha = 0;
+			}
+
+			doAlpha = 1;
+		}
+		else
+		{
+			doAlpha = 1;
+			cent->trickAlpha = 1;
+			cent->trickAlphaTime = cg.time;
+			iwantout = 1;
+		}
+	}
+	else
+	{
+		if (cent->trickAlpha < 255)
+		{
+			cent->trickAlpha += (cg.time - cent->trickAlphaTime);
+			cent->trickAlphaTime = cg.time;
+
+			if (cent->trickAlpha > 255)
+			{
+				cent->trickAlpha = 255;
+			}
+
+			doAlpha = 1;
+		}
+		else
+		{
+			cent->trickAlpha = 255;
+			cent->trickAlphaTime = cg.time;
+		}
+	}
+
+	// get the player model information
+	renderfx = 0;
+	if ( cent->currentState.number == cg.snap->ps.clientNum) {
+		if (!cg.renderingThirdPerson) {
+#if 0
+			if (!cg_fpls.integer || cent->currentState.weapon != WP_SABER)
+#else
+			if (cent->currentState.weapon != WP_SABER)
+#endif
+			{
+				renderfx = RF_THIRD_PERSON;			// only draw in mirrors
+			}
+		} else {
+			if (cg_cameraMode.integer) {
+				iwantout = 1;
+
+				
+				// goto minimal_add;
+				
+				// NOTENOTE Temporary
+				return;
+			}
+		}
+	}
+
+	// Update the player's client entity information regarding weapons.
+	// Explanation:  The entitystate has a weapond defined on it.  The cliententity does as well.
+	// The cliententity's weapon tells us what the ghoul2 instance on the cliententity has bolted to it.
+	// If the entitystate and cliententity weapons differ, then the state's needs to be copied to the client.
+	// Save the old weapon, to verify that it is or is not the same as the new weapon.
+	// rww - Make sure weapons don't get set BEFORE cent->ghoul2 is initialized or else we'll have no
+	// weapon bolted on
+	if (cent->currentState.saberInFlight)
+	{
+		cent->ghoul2weapon = CG_G2WeaponInstance(cent, WP_SABER);
+	}
+
+	if (cent->ghoul2 && 
+		(cent->currentState.eType != ET_NPC || (cent->currentState.NPC_class != CLASS_VEHICLE&&cent->currentState.NPC_class != CLASS_REMOTE&&cent->currentState.NPC_class != CLASS_SEEKER)) && //don't add weapon models to NPCs that have no bolt for them!
+		cent->ghoul2weapon != CG_G2WeaponInstance(cent, cent->currentState.weapon) &&
+		!(cent->currentState.eFlags & EF_DEAD) && !cent->torsoBolt &&
+		cg.snap && (cent->currentState.number != cg.snap->ps.clientNum || (cg.snap->ps.pm_flags & PMF_FOLLOW)))
+	{
+		if (ci->team == TEAM_SPECTATOR)
+		{
+			cent->ghoul2weapon = NULL;
+			cent->weapon = 0;
+		}
+		else
+		{
+			CG_CopyG2WeaponInstance(cent, cent->currentState.weapon, cent->ghoul2);
+
+			if (cent->currentState.eType != ET_NPC)
+			{
+				if (cent->weapon == WP_SABER 
+					&& cent->weapon != cent->currentState.weapon 
+					&& !cent->currentState.saberHolstered)
+				{ //switching away from the saber
+					//trap_S_StartSound(cent->lerpOrigin, cent->currentState.number, CHAN_AUTO, trap_S_RegisterSound( "sound/weapons/saber/saberoffquick.wav" ));
+					if (ci->saber[0].soundOff 
+						&& !cent->currentState.saberHolstered)
+					{
+						trap_S_StartSound(cent->lerpOrigin, cent->currentState.number, CHAN_AUTO, ci->saber[0].soundOff);
+					}
+
+					if (ci->saber[1].soundOff &&
+						ci->saber[1].model[0] &&
+						!cent->currentState.saberHolstered)
+					{
+						trap_S_StartSound(cent->lerpOrigin, cent->currentState.number, CHAN_AUTO, ci->saber[1].soundOff);
+					}
+
+				}
+				else if (cent->currentState.weapon == WP_SABER
+					&& cent->weapon != cent->currentState.weapon 
+					&& !cent->saberWasInFlight)
+				{ //switching to the saber
+					//trap_S_StartSound(cent->lerpOrigin, cent->currentState.number, CHAN_AUTO, trap_S_RegisterSound( "sound/weapons/saber/saberon.wav" ));
+					if (ci->saber[0].soundOn)
+					{
+						trap_S_StartSound(cent->lerpOrigin, cent->currentState.number, CHAN_AUTO, ci->saber[0].soundOn);
+					}
+
+					if (ci->saber[1].soundOn)
+					{
+						trap_S_StartSound(cent->lerpOrigin, cent->currentState.number, CHAN_AUTO, ci->saber[1].soundOn);
+					}
+
+					BG_SI_SetDesiredLength(&ci->saber[0], 0, -1);
+					BG_SI_SetDesiredLength(&ci->saber[1], 0, -1);
+				}
+			}
+
+			cent->weapon = cent->currentState.weapon;
+			cent->ghoul2weapon = CG_G2WeaponInstance(cent, cent->currentState.weapon);
+		}
+	}
+	else if ((cent->currentState.eFlags & EF_DEAD) || cent->torsoBolt)
+	{
+		cent->ghoul2weapon = NULL; //be sure to update after respawning/getting limb regrown
+	}
+
+	
+	if (cent->saberWasInFlight && g2HasWeapon)
+	{
+		 cent->saberWasInFlight = qfalse;
+	}
+
+	memset (&legs, 0, sizeof(legs));
+
+	CG_SetGhoul2Info(&legs, cent);
+
+	VectorCopy(cent->modelScale, legs.modelScale);
+	legs.radius = CG_RadiusForCent( cent );
+	VectorClear(legs.angles);
+
+	if (ci->colorOverride[0] != 0.0f ||
+		ci->colorOverride[1] != 0.0f ||
+		ci->colorOverride[2] != 0.0f)
+	{
+		legs.shaderRGBA[0] = ci->colorOverride[0]*255.0f;
+		legs.shaderRGBA[1] = ci->colorOverride[1]*255.0f;
+		legs.shaderRGBA[2] = ci->colorOverride[2]*255.0f;
+		legs.shaderRGBA[3] = cent->currentState.customRGBA[3];
+	}
+	else
+	{
+		legs.shaderRGBA[0] = cent->currentState.customRGBA[0];
+		legs.shaderRGBA[1] = cent->currentState.customRGBA[1];
+		legs.shaderRGBA[2] = cent->currentState.customRGBA[2];
+		legs.shaderRGBA[3] = cent->currentState.customRGBA[3];
+	}
+
+// minimal_add:
+
+	team = ci->team;
+
+	if (cgs.gametype >= GT_TEAM && cg_drawFriend.integer &&
+		cent->currentState.number != cg.snap->ps.clientNum &&
+		cent->currentState.eType != ET_NPC)
+	{	// If the view is either a spectator or on the same team as this character, show a symbol above their head.
+		if ((cg.snap->ps.persistant[PERS_TEAM] == TEAM_SPECTATOR || cg.snap->ps.persistant[PERS_TEAM] == team) &&
+			!(cent->currentState.eFlags & EF_DEAD))
+		{
+			if (cgs.gametype == GT_SIEGE)
+			{ //check for per-map team shaders
+				if (team == SIEGETEAM_TEAM1)
+				{
+					if (cgSiegeTeam1PlShader)
+					{
+						CG_PlayerFloatSprite( cent, cgSiegeTeam1PlShader);
+					}
+					else
+					{ //if there isn't one fallback to default
+						CG_PlayerFloatSprite( cent, cgs.media.teamRedShader);
+					}
+				}
+				else
+				{
+					if (cgSiegeTeam2PlShader)
+					{
+						CG_PlayerFloatSprite( cent, cgSiegeTeam2PlShader);
+					}
+					else
+					{ //if there isn't one fallback to default
+						CG_PlayerFloatSprite( cent, cgs.media.teamBlueShader);
+					}
+				}
+			}
+			else
+			{ //generic teamplay
+				if (team == TEAM_RED)
+				{
+					CG_PlayerFloatSprite( cent, cgs.media.teamRedShader);
+				}
+				else	// if (team == TEAM_BLUE)
+				{
+					CG_PlayerFloatSprite( cent, cgs.media.teamBlueShader);
+				}
+			}
+		}
+	}
+	else if (cgs.gametype == GT_POWERDUEL && cg_drawFriend.integer &&
+		cent->currentState.number != cg.snap->ps.clientNum)
+	{
+		if (cg.predictedPlayerState.persistant[PERS_TEAM] != TEAM_SPECTATOR &&
+			cent->currentState.number < MAX_CLIENTS &&
+			!(cent->currentState.eFlags & EF_DEAD) &&
+			ci &&
+			cgs.clientinfo[cg.snap->ps.clientNum].duelTeam == ci->duelTeam)
+		{ //ally in powerduel, so draw the icon
+			CG_PlayerFloatSprite( cent, cgs.media.powerDuelAllyShader);
+		}
+		else if (cg.predictedPlayerState.persistant[PERS_TEAM] == TEAM_SPECTATOR &&
+			cent->currentState.number < MAX_CLIENTS &&
+			!(cent->currentState.eFlags & EF_DEAD) &&
+			ci->duelTeam == DUELTEAM_DOUBLE)
+		{
+			CG_PlayerFloatSprite( cent, cgs.media.powerDuelAllyShader);
+		}
+	}
+
+	if (cgs.gametype == GT_JEDIMASTER && cg_drawFriend.integer &&
+		cent->currentState.number != cg.snap->ps.clientNum)			// Don't show a sprite above a player's own head in 3rd person.
+	{	// If the view is either a spectator or on the same team as this character, show a symbol above their head.
+		if ((cg.snap->ps.persistant[PERS_TEAM] == TEAM_SPECTATOR || cg.snap->ps.persistant[PERS_TEAM] == team) &&
+			!(cent->currentState.eFlags & EF_DEAD))
+		{
+			if (CG_ThereIsAMaster())
+			{
+				if (!cg.snap->ps.isJediMaster)
+				{
+					if (!cent->currentState.isJediMaster)
+					{
+						CG_PlayerFloatSprite( cent, cgs.media.teamRedShader);
+					}
+				}
+			}
+		}
+	}
+
+	// add the shadow
+	shadow = CG_PlayerShadow( cent, &shadowPlane );
+
+	if ( ((cent->currentState.eFlags & EF_SEEKERDRONE) || cent->currentState.genericenemyindex != -1) && cent->currentState.eType != ET_NPC )
+	{
+		refEntity_t		seeker;
+
+		memset( &seeker, 0, sizeof(seeker) );
+
+		VectorCopy(cent->lerpOrigin, elevated);
+		elevated[2] += 40;
+
+		VectorCopy( elevated, seeker.lightingOrigin );
+		seeker.shadowPlane = shadowPlane;
+		seeker.renderfx = 0; //renderfx;
+							 //don't show in first person?
+
+		angle = ((cg.time / 12) & 255) * (M_PI * 2) / 255;
+		dir[0] = cos(angle) * 20;
+		dir[1] = sin(angle) * 20;
+		dir[2] = cos(angle) * 5;
+		VectorAdd(elevated, dir, seeker.origin);
+
+		VectorCopy(seeker.origin, seekorg);
+
+		if (cent->currentState.genericenemyindex > MAX_GENTITIES)
+		{
+			float prefig = (cent->currentState.genericenemyindex-cg.time)/80;
+
+			if (prefig > 55)
+			{
+				prefig = 55;
+			}
+			else if (prefig < 1)
+			{
+				prefig = 1;
+			}
+
+			elevated[2] -= 55-prefig;
+
+			angle = ((cg.time / 12) & 255) * (M_PI * 2) / 255;
+			dir[0] = cos(angle) * 20;
+			dir[1] = sin(angle) * 20;
+			dir[2] = cos(angle) * 5;
+			VectorAdd(elevated, dir, seeker.origin);
+		}
+		else if (cent->currentState.genericenemyindex != ENTITYNUM_NONE && cent->currentState.genericenemyindex != -1)
+		{
+			centity_t *enent = &cg_entities[cent->currentState.genericenemyindex];
+
+			if (enent)
+			{
+				VectorSubtract(enent->lerpOrigin, seekorg, enang);
+				VectorNormalize(enang);
+				vectoangles(enang, angles);
+				successchange = 1;
+			}
+		}
+
+		if (!successchange)
+		{
+			angles[0] = sin(angle) * 30;
+			angles[1] = (angle * 180 / M_PI) + 90;
+			if (angles[1] > 360)
+				angles[1] -= 360;
+			angles[2] = 0;
+		}
+
+		AnglesToAxis( angles, seeker.axis );
+
+		seeker.hModel = trap_R_RegisterModel("models/items/remote.md3");
+		trap_R_AddRefEntityToScene( &seeker );
+	}
+
+	// add a water splash if partially in and out of water
+	CG_PlayerSplash( cent );
+
+	if ( (cg_shadows.integer == 3 || cg_shadows.integer == 2) && shadow ) {
+		renderfx |= RF_SHADOW_PLANE;
+	}
+	renderfx |= RF_LIGHTING_ORIGIN;			// use the same origin for all
+
+	// if we've been hit, display proper fullscreen fx
+	CG_PlayerHitFX(cent);
+
+	VectorCopy( cent->lerpOrigin, legs.origin );
+
+	VectorCopy( cent->lerpOrigin, legs.lightingOrigin );
+	legs.shadowPlane = shadowPlane;
+	legs.renderfx = renderfx;
+	if (cg_shadows.integer == 2 && (renderfx & RF_THIRD_PERSON))
+	{ //can see own shadow
+		legs.renderfx |= RF_SHADOW_ONLY;
+	}
+	VectorCopy (legs.origin, legs.oldorigin);	// don't positionally lerp at all
+
+	CG_G2PlayerAngles( cent, legs.axis, rootAngles );
+	CG_G2PlayerHeadAnims( cent );
+
+	if ( (cent->currentState.eFlags2&EF2_HELD_BY_MONSTER) 
+		&& cent->currentState.hasLookTarget )//NOTE: lookTarget is an entity number, so this presumes that client 0 is NOT a Rancor...
+	{
+		centity_t	*rancor = &cg_entities[cent->currentState.lookTarget];
+		if ( rancor )
+		{
+			BG_AttachToRancor( rancor->ghoul2, //ghoul2 info
+				rancor->lerpAngles[YAW],
+				rancor->lerpOrigin,
+				cg.time,
+				cgs.gameModels,
+				rancor->modelScale,
+				(rancor->currentState.eFlags2&EF2_GENERIC_NPC_FLAG),
+				legs.origin,
+				legs.angles,
+				NULL );
+
+			if ( cent->isRagging )
+			{//hack, ragdoll has you way at bottom of bounding box
+				VectorMA( legs.origin, 32, legs.axis[2], legs.origin );
+			}
+			VectorCopy( legs.origin, legs.oldorigin );
+			VectorCopy( legs.origin, legs.lightingOrigin );
+
+			VectorCopy( legs.angles, cent->lerpAngles );
+			VectorCopy( cent->lerpAngles, rootAngles );//??? tempAngles );//tempAngles is needed a lot below
+			VectorCopy( cent->lerpAngles, cent->turAngles );
+			VectorCopy( legs.origin, cent->lerpOrigin );
+		}
+	}
+	//This call is mainly just to reconstruct the skeleton. But we'll get the left hand matrix while we're at it.
+	//If we don't reconstruct the skeleton after setting the bone angles, we will get bad bolt points on the model
+	//(e.g. the weapon model bolt will look "lagged") if there's no other GetBoltMatrix call for the rest of the
+	//frame. Yes, this is stupid and needs to be fixed properly.
+	//The current solution is to force it not to reconstruct the skeleton for the first GBM call in G2PlayerAngles.
+	//It works and we end up only reconstructing it once, but it doesn't seem like the best solution.
+	trap_G2API_GetBoltMatrix(cent->ghoul2, 0, ci->bolt_lhand, &lHandMatrix, cent->turAngles, cent->lerpOrigin, cg.time, cgs.gameModels, cent->modelScale);
+	gotLHandMatrix = qtrue;
+#if 0
+	if (cg.renderingThirdPerson)
+	{
+		if (cgFPLSState != 0)
+		{
+			CG_ForceFPLSPlayerModel(cent, ci);
+			cgFPLSState = 0;
+			return;
+		}
+	}
+	else if (ci->team == TEAM_SPECTATOR || (cg.snap && (cg.snap->ps.pm_flags & PMF_FOLLOW)))
+	{ //don't allow this when spectating
+		if (cgFPLSState != 0)
+		{
+			trap_Cvar_Set("cg_fpls", "0");
+			cg_fpls.integer = 0;
+
+			CG_ForceFPLSPlayerModel(cent, ci);
+			cgFPLSState = 0;
+			return;
+		}
+
+		if (cg_fpls.integer)
+		{
+			trap_Cvar_Set("cg_fpls", "0");
+		}
+	}
+	else
+	{
+		if (cg_fpls.integer && cent->currentState.weapon == WP_SABER && cg.snap && cent->currentState.number == cg.snap->ps.clientNum)
+		{
+
+			if (cgFPLSState != cg_fpls.integer)
+			{
+				CG_ForceFPLSPlayerModel(cent, ci);
+				cgFPLSState = cg_fpls.integer;
+				return;
+			}
+
+			/*
+			mdxaBone_t 		headMatrix;
+			trap_G2API_GetBoltMatrix(cent->ghoul2, 0, ci->bolt_head, &headMatrix, cent->turAngles, cent->lerpOrigin, cg.time, cgs.gameModels, cent->modelScale);
+			BG_GiveMeVectorFromMatrix(&headMatrix, ORIGIN, cg.refdef.vieworg);
+			*/
+		}
+		else if (!cg_fpls.integer && cgFPLSState)
+		{
+			if (cgFPLSState != cg_fpls.integer)
+			{
+				CG_ForceFPLSPlayerModel(cent, ci);
+				cgFPLSState = cg_fpls.integer;
+				return;
+			}
+		}
+	}
+#endif
+
+	if (cent->currentState.eFlags & EF_DEAD)
+	{
+		dead = qtrue;
+		//rww - since our angles are fixed when we're dead this shouldn't be an issue anyway
+		//we need to render the dying/dead player because we are now spawning the body on respawn instead of death
+		//return;
+	}
+
+	ScaleModelAxis(&legs);
+
+	memset( &torso, 0, sizeof(torso) );
+
+	//rww - force speed "trail" effect
+	if (!(cent->currentState.powerups & (1 << PW_SPEED)) || doAlpha || !cg_speedTrail.integer)
+	{
+		cent->frame_minus1_refreshed = 0;
+		cent->frame_minus2_refreshed = 0;
+	}
+
+	if (cent->frame_minus1_refreshed ||
+		cent->frame_minus2_refreshed)
+	{
+		vec3_t			tDir;
+		int				distVelBase;
+
+		VectorCopy(cent->currentState.pos.trDelta, tDir);
+		distVelBase = SPEED_TRAIL_DISTANCE*(VectorNormalize(tDir)*0.004);
+
+		if (cent->frame_minus1_refreshed)
+		{
+			refEntity_t reframe_minus1 = legs;
+			reframe_minus1.renderfx |= RF_FORCE_ENT_ALPHA;
+			reframe_minus1.shaderRGBA[0] = legs.shaderRGBA[0];
+			reframe_minus1.shaderRGBA[1] = legs.shaderRGBA[1];
+			reframe_minus1.shaderRGBA[2] = legs.shaderRGBA[2];
+			reframe_minus1.shaderRGBA[3] = 100;
+
+			//rww - if the client gets a bad framerate we will only receive frame positions
+			//once per frame anyway, so we might end up with speed trails very spread out.
+			//in order to avoid that, we'll get the direction of the last trail from the player
+			//and place the trail refent a set distance from the player location this frame
+			VectorSubtract(cent->frame_minus1, legs.origin, tDir);
+			VectorNormalize(tDir);
+
+			cent->frame_minus1[0] = legs.origin[0]+tDir[0]*distVelBase;
+			cent->frame_minus1[1] = legs.origin[1]+tDir[1]*distVelBase;
+			cent->frame_minus1[2] = legs.origin[2]+tDir[2]*distVelBase;
+
+			VectorCopy(cent->frame_minus1, reframe_minus1.origin);
+
+			//reframe_minus1.customShader = 2;
+
+			trap_R_AddRefEntityToScene(&reframe_minus1);
+		}
+
+		if (cent->frame_minus2_refreshed)
+		{
+			refEntity_t reframe_minus2 = legs;
+
+			reframe_minus2.renderfx |= RF_FORCE_ENT_ALPHA;
+			reframe_minus2.shaderRGBA[0] = legs.shaderRGBA[0];
+			reframe_minus2.shaderRGBA[1] = legs.shaderRGBA[1];
+			reframe_minus2.shaderRGBA[2] = legs.shaderRGBA[2];
+			reframe_minus2.shaderRGBA[3] = 50;
+
+			//Same as above but do it between trail points instead of the player and first trail entry
+			VectorSubtract(cent->frame_minus2, cent->frame_minus1, tDir);
+			VectorNormalize(tDir);
+
+			cent->frame_minus2[0] = cent->frame_minus1[0]+tDir[0]*distVelBase;
+			cent->frame_minus2[1] = cent->frame_minus1[1]+tDir[1]*distVelBase;
+			cent->frame_minus2[2] = cent->frame_minus1[2]+tDir[2]*distVelBase;
+
+			VectorCopy(cent->frame_minus2, reframe_minus2.origin);
+
+			//reframe_minus2.customShader = 2;
+
+			trap_R_AddRefEntityToScene(&reframe_minus2);
+		}
+	}
+
+	//trigger animation-based sounds, done before next lerp frame.
+	CG_TriggerAnimSounds(cent);
+
+	// get the animation state (after rotation, to allow feet shuffle)
+	CG_PlayerAnimation( cent, &legs.oldframe, &legs.frame, &legs.backlerp,
+		 &torso.oldframe, &torso.frame, &torso.backlerp );
+
+	// add the talk baloon or disconnect icon
+	CG_PlayerSprites( cent );
+
+	if (cent->currentState.eFlags & EF_DEAD)
+	{ //keep track of death anim frame for when we copy off the bodyqueue
+		ci->frame = cent->pe.torso.frame;
+	}
+
+	if (cent->currentState.activeForcePass > FORCE_LEVEL_3
+		&& cent->currentState.NPC_class != CLASS_VEHICLE)
+	{
+		vec3_t axis[3];
+		vec3_t tAng, fAng, fxDir;
+		vec3_t efOrg;
+
+		int realForceLev = (cent->currentState.activeForcePass - FORCE_LEVEL_3);
+
+		VectorSet( tAng, cent->turAngles[PITCH], cent->turAngles[YAW], cent->turAngles[ROLL] );
+
+		VectorSet( fAng, cent->pe.torso.pitchAngle, cent->pe.torso.yawAngle, 0 );
+
+		AngleVectors( fAng, fxDir, NULL, NULL );
+
+		if ( cent->currentState.torsoAnim == BOTH_FORCE_2HANDEDLIGHTNING_HOLD 
+			&& Q_irand( 0, 1 ) )
+		{//alternate back and forth between left and right
+			mdxaBone_t 	rHandMatrix;
+			trap_G2API_GetBoltMatrix(cent->ghoul2, 0, ci->bolt_rhand, &rHandMatrix, cent->turAngles, cent->lerpOrigin, cg.time, cgs.gameModels, cent->modelScale);
+			efOrg[0] = rHandMatrix.matrix[0][3];
+			efOrg[1] = rHandMatrix.matrix[1][3];
+			efOrg[2] = rHandMatrix.matrix[2][3];
+		}
+		else
+		{
+			//trap_G2API_GetBoltMatrix(cent->ghoul2, 0, ci->bolt_lhand, &boltMatrix, tAng, cent->lerpOrigin, cg.time, cgs.gameModels, cent->modelScale);
+			if (!gotLHandMatrix)
+			{
+				trap_G2API_GetBoltMatrix(cent->ghoul2, 0, ci->bolt_lhand, &lHandMatrix, cent->turAngles, cent->lerpOrigin, cg.time, cgs.gameModels, cent->modelScale);
+				gotLHandMatrix = qtrue;
+			}
+			efOrg[0] = lHandMatrix.matrix[0][3];
+			efOrg[1] = lHandMatrix.matrix[1][3];
+			efOrg[2] = lHandMatrix.matrix[2][3];
+		}
+
+		AnglesToAxis( fAng, axis );
+	
+		if ( realForceLev > FORCE_LEVEL_2 )
+		{//arc
+			//trap_FX_PlayEffectID( cgs.effects.forceLightningWide, efOrg, fxDir );
+			//trap_FX_PlayEntityEffectID(cgs.effects.forceDrainWide, efOrg, axis, cent->boltInfo, cent->currentState.number, -1, -1);
+			trap_FX_PlayEntityEffectID(cgs.effects.forceDrainWide, efOrg, axis, -1, -1, -1, -1);
+		}
+		else
+		{//line
+			//trap_FX_PlayEffectID( cgs.effects.forceLightning, efOrg, fxDir );
+			//trap_FX_PlayEntityEffectID(cgs.effects.forceDrain, efOrg, axis, cent->boltInfo, cent->currentState.number, -1, -1);
+			trap_FX_PlayEntityEffectID(cgs.effects.forceDrain, efOrg, axis, -1, -1, -1, -1);
+		}
+
+		/*
+		if (cent->bolt4 < cg.time)
+		{
+			cent->bolt4 = cg.time + 100;
+			trap_S_StartSound(NULL, cent->currentState.number, CHAN_AUTO, trap_S_RegisterSound("sound/weapons/force/drain.wav") );
+		}
+		*/
+	}
+	else if ( cent->currentState.activeForcePass 
+		&& cent->currentState.NPC_class != CLASS_VEHICLE)
+	{//doing the electrocuting
+		vec3_t axis[3];
+		vec3_t tAng, fAng, fxDir;
+		vec3_t efOrg;
+
+		VectorSet( tAng, cent->turAngles[PITCH], cent->turAngles[YAW], cent->turAngles[ROLL] );
+
+		VectorSet( fAng, cent->pe.torso.pitchAngle, cent->pe.torso.yawAngle, 0 );
+
+		AngleVectors( fAng, fxDir, NULL, NULL );
+
+		//trap_G2API_GetBoltMatrix(cent->ghoul2, 0, ci->bolt_lhand, &boltMatrix, tAng, cent->lerpOrigin, cg.time, cgs.gameModels, cent->modelScale);
+		if (!gotLHandMatrix)
+		{
+			trap_G2API_GetBoltMatrix(cent->ghoul2, 0, ci->bolt_lhand, &lHandMatrix, cent->turAngles, cent->lerpOrigin, cg.time, cgs.gameModels, cent->modelScale);
+			gotLHandMatrix = qtrue;
+		}
+
+		efOrg[0] = lHandMatrix.matrix[0][3];
+		efOrg[1] = lHandMatrix.matrix[1][3];
+		efOrg[2] = lHandMatrix.matrix[2][3];
+
+		AnglesToAxis( fAng, axis );
+	
+		if ( cent->currentState.activeForcePass > FORCE_LEVEL_2 )
+		{//arc
+			//trap_FX_PlayEffectID( cgs.effects.forceLightningWide, efOrg, fxDir );
+			//trap_FX_PlayEntityEffectID(cgs.effects.forceLightningWide, efOrg, axis, cent->boltInfo, cent->currentState.number, -1, -1);
+			trap_FX_PlayEntityEffectID(cgs.effects.forceLightningWide, efOrg, axis, -1, -1, -1, -1);
+		}
+		else
+		{//line
+			//trap_FX_PlayEffectID( cgs.effects.forceLightning, efOrg, fxDir );
+			//trap_FX_PlayEntityEffectID(cgs.effects.forceLightning, efOrg, axis, cent->boltInfo, cent->currentState.number, -1, -1);
+			trap_FX_PlayEntityEffectID(cgs.effects.forceLightning, efOrg, axis, -1, -1, -1, -1);
+		}
+
+		/*
+		if (cent->bolt4 < cg.time)
+		{
+			cent->bolt4 = cg.time + 100;
+			trap_S_StartSound(NULL, cent->currentState.number, CHAN_AUTO, trap_S_RegisterSound("sound/weapons/force/lightning.wav") );
+		}
+		*/
+	}
+
+	//fullbody push effect
+	if (cent->currentState.eFlags & EF_BODYPUSH)
+	{
+		CG_ForcePushBodyBlur(cent);
+	}
+
+	if ( cent->currentState.powerups & (1 << PW_DISINT_4) )
+	{
+		vec3_t tAng;
+		vec3_t efOrg;
+
+		//VectorSet( tAng, 0, cent->pe.torso.yawAngle, 0 );
+		VectorSet( tAng, cent->turAngles[PITCH], cent->turAngles[YAW], cent->turAngles[ROLL] );
+
+		//trap_G2API_GetBoltMatrix(cent->ghoul2, 0, ci->bolt_lhand, &boltMatrix, tAng, cent->lerpOrigin, cg.time, cgs.gameModels, cent->modelScale);
+		if (!gotLHandMatrix)
+		{
+			trap_G2API_GetBoltMatrix(cent->ghoul2, 0, ci->bolt_lhand, &lHandMatrix, cent->turAngles, cent->lerpOrigin, cg.time, cgs.gameModels, cent->modelScale);
+			gotLHandMatrix = qtrue;
+		}
+
+		efOrg[0] = lHandMatrix.matrix[0][3];
+		efOrg[1] = lHandMatrix.matrix[1][3];
+		efOrg[2] = lHandMatrix.matrix[2][3];
+
+		if ( (cent->currentState.forcePowersActive & (1 << FP_GRIP)) &&
+			(cg.renderingThirdPerson || cent->currentState.number != cg.snap->ps.clientNum) )
+		{
+			vec3_t boltDir;
+			vec3_t origBolt;
+			VectorCopy(efOrg, origBolt);
+			BG_GiveMeVectorFromMatrix( &lHandMatrix, NEGATIVE_Y, boltDir );
+
+			CG_ForceGripEffect( efOrg );
+			CG_ForceGripEffect( efOrg );
+
+			/*
+			//Render a scaled version of the model's hand with a n337 looking shader
+			{
+				const char *rotateBone;
+				char *limbName;
+				char *limbCapName;
+				vec3_t armAng;
+				refEntity_t regrip_arm;
+				float wv = sin( cg.time * 0.003f ) * 0.08f + 0.1f;
+
+				//rotateBone = "lradius";
+				rotateBone = "lradiusX";
+				limbName = "l_arm";
+				limbCapName = "l_arm_cap_torso";
+
+				if (cent->grip_arm && trap_G2_HaveWeGhoul2Models(cent->grip_arm))
+				{
+					trap_G2API_CleanGhoul2Models(&(cent->grip_arm));
+				}
+
+				memset( &regrip_arm, 0, sizeof(regrip_arm) );
+
+				VectorCopy(origBolt, efOrg);
+
+
+				//efOrg[2] += 8;
+				efOrg[2] -= 4;
+
+				VectorCopy(efOrg, regrip_arm.origin);
+				VectorCopy(regrip_arm.origin, regrip_arm.lightingOrigin);
+
+				//VectorCopy(cent->lerpAngles, armAng);
+				VectorAdd(vec3_origin, rootAngles, armAng);
+				//armAng[ROLL] = -90;
+				armAng[ROLL] = 0;
+				armAng[PITCH] = 0;
+				AnglesToAxis(armAng, regrip_arm.axis);
+				
+				trap_G2API_DuplicateGhoul2Instance(cent->ghoul2, &cent->grip_arm);
+
+				//remove all other models
+				if (trap_G2API_HasGhoul2ModelOnIndex(&(cent->grip_arm), 1))
+				{ //weapon right
+					trap_G2API_RemoveGhoul2Model(&(cent->grip_arm), 1);
+				}
+				if (trap_G2API_HasGhoul2ModelOnIndex(&(cent->grip_arm), 2))
+				{ //weapon left
+					trap_G2API_RemoveGhoul2Model(&(cent->grip_arm), 2);
+				}
+				if (trap_G2API_HasGhoul2ModelOnIndex(&(cent->grip_arm), 3))
+				{ //jetpack
+					trap_G2API_RemoveGhoul2Model(&(cent->grip_arm), 3);
+				}
+
+				trap_G2API_SetRootSurface(cent->grip_arm, 0, limbName);
+				trap_G2API_SetNewOrigin(cent->grip_arm, trap_G2API_AddBolt(cent->grip_arm, 0, rotateBone));
+				trap_G2API_SetSurfaceOnOff(cent->grip_arm, limbCapName, 0);
+
+				regrip_arm.modelScale[0] = 1;//+(wv*6);
+				regrip_arm.modelScale[1] = 1;//+(wv*6);
+				regrip_arm.modelScale[2] = 1;//+(wv*6);
+				ScaleModelAxis(&regrip_arm);
+
+				regrip_arm.radius = 64;
+
+				regrip_arm.customShader = trap_R_RegisterShader( "gfx/misc/red_portashield" );
+				
+				regrip_arm.renderfx |= RF_RGB_TINT;
+				regrip_arm.shaderRGBA[0] = 255 - (wv*900);
+				if (regrip_arm.shaderRGBA[0] < 30)
+				{
+					regrip_arm.shaderRGBA[0] = 30;
+				}
+				if (regrip_arm.shaderRGBA[0] > 255)
+				{
+					regrip_arm.shaderRGBA[0] = 255;
+				}
+				regrip_arm.shaderRGBA[1] = regrip_arm.shaderRGBA[2] = regrip_arm.shaderRGBA[0];
+				
+				regrip_arm.ghoul2 = cent->grip_arm;
+				trap_R_AddRefEntityToScene( &regrip_arm );
+			}
+			*/
+		}
+		else if (!(cent->currentState.forcePowersActive & (1 << FP_GRIP)))
+		{
+			//use refractive effect
+			CG_ForcePushBlur( efOrg, cent );
+		}
+	}
+	else if (cent->bodyFadeTime)
+	{ //reset the counter for keeping track of push refraction effect state
+		cent->bodyFadeTime = 0;
+	}
+
+	if (cent->currentState.weapon == WP_STUN_BATON && cent->currentState.number == cg.snap->ps.clientNum)
+	{
+		trap_S_AddLoopingSound( cent->currentState.number, cg.refdef.vieworg, vec3_origin, 
+			trap_S_RegisterSound( "sound/weapons/baton/idle.wav" ) );
+	}
+
+	//NOTE: All effects that should be visible during mindtrick should go above here
+
+	if (iwantout)
+	{
+		goto stillDoSaber;
+		//return;
+	}
+	else if (doAlpha)
+	{
+		legs.renderfx |= RF_FORCE_ENT_ALPHA;
+		legs.shaderRGBA[3] = cent->trickAlpha;
+
+		if (legs.shaderRGBA[3] < 1)
+		{ //don't cancel it out even if it's < 1
+			legs.shaderRGBA[3] = 1;
+		}
+	}
+
+	if (cent->teamPowerEffectTime > cg.time)
+	{
+		if (cent->teamPowerType == 3)
+		{ //absorb is a somewhat different effect entirely
+			//Guess I'll take care of it where it's always been, just checking these values instead.
+		}
+		else
+		{
+			vec4_t preCol;
+			int preRFX;
+
+			preRFX = legs.renderfx;
+
+			legs.renderfx |= RF_RGB_TINT;
+			legs.renderfx |= RF_FORCE_ENT_ALPHA;
+
+			preCol[0] = legs.shaderRGBA[0];
+			preCol[1] = legs.shaderRGBA[1];
+			preCol[2] = legs.shaderRGBA[2];
+			preCol[3] = legs.shaderRGBA[3];
+
+			if (cent->teamPowerType == 1)
+			{ //heal
+				legs.shaderRGBA[0] = 0;
+				legs.shaderRGBA[1] = 255;
+				legs.shaderRGBA[2] = 0;
+			}
+			else if (cent->teamPowerType == 0)
+			{ //regen
+				legs.shaderRGBA[0] = 0;
+				legs.shaderRGBA[1] = 0;
+				legs.shaderRGBA[2] = 255;
+			}
+			else
+			{ //drain
+				legs.shaderRGBA[0] = 255;
+				legs.shaderRGBA[1] = 0;
+				legs.shaderRGBA[2] = 0;
+			}
+
+			legs.shaderRGBA[3] = ((cent->teamPowerEffectTime - cg.time)/8);
+
+			legs.customShader = trap_R_RegisterShader( "powerups/ysalimarishell" );
+			trap_R_AddRefEntityToScene(&legs);
+
+			legs.customShader = 0;
+			legs.renderfx = preRFX;
+			legs.shaderRGBA[0] = preCol[0];
+			legs.shaderRGBA[1] = preCol[1];
+			legs.shaderRGBA[2] = preCol[2];
+			legs.shaderRGBA[3] = preCol[3];
+		}
+	}
+
+	//If you've tricked this client.
+	if (CG_IsMindTricked(cg.snap->ps.fd.forceMindtrickTargetIndex,
+		cg.snap->ps.fd.forceMindtrickTargetIndex2,
+		cg.snap->ps.fd.forceMindtrickTargetIndex3,
+		cg.snap->ps.fd.forceMindtrickTargetIndex4,
+		cent->currentState.number))
+	{
+		if (cent->ghoul2)
+		{
+			vec3_t efOrg;
+			vec3_t tAng, fxAng;
+			vec3_t axis[3];
+
+			//VectorSet( tAng, 0, cent->pe.torso.yawAngle, 0 );
+			VectorSet( tAng, cent->turAngles[PITCH], cent->turAngles[YAW], cent->turAngles[ROLL] );
+
+			trap_G2API_GetBoltMatrix(cent->ghoul2, 0, ci->bolt_head, &boltMatrix, tAng, cent->lerpOrigin, cg.time, cgs.gameModels, cent->modelScale);
+
+			BG_GiveMeVectorFromMatrix(&boltMatrix, ORIGIN, efOrg);
+			BG_GiveMeVectorFromMatrix(&boltMatrix, NEGATIVE_Y, fxAng);
+
+ 			axis[0][0] = boltMatrix.matrix[0][0];
+ 			axis[0][1] = boltMatrix.matrix[1][0];
+		 	axis[0][2] = boltMatrix.matrix[2][0];
+
+ 			axis[1][0] = boltMatrix.matrix[0][1];
+ 			axis[1][1] = boltMatrix.matrix[1][1];
+		 	axis[1][2] = boltMatrix.matrix[2][1];
+
+ 			axis[2][0] = boltMatrix.matrix[0][2];
+ 			axis[2][1] = boltMatrix.matrix[1][2];
+		 	axis[2][2] = boltMatrix.matrix[2][2];
+
+			//trap_FX_PlayEntityEffectID(trap_FX_RegisterEffect("force/confusion.efx"), efOrg, axis, cent->boltInfo, cent->currentState.number);
+			trap_FX_PlayEntityEffectID(cgs.effects.mForceConfustionOld, efOrg, axis, -1, -1, -1, -1);
+		}
+	}
+
+	if (cgs.gametype == GT_HOLOCRON && cent->currentState.time2 && (cg.renderingThirdPerson || cg.snap->ps.clientNum != cent->currentState.number))
+	{
+		int i = 0;
+		int renderedHolos = 0;
+		refEntity_t		holoRef;
+
+		while (i < NUM_FORCE_POWERS && renderedHolos < 3)
+		{
+			if (cent->currentState.time2 & (1 << i))
+			{
+				memset( &holoRef, 0, sizeof(holoRef) );
+
+				VectorCopy(cent->lerpOrigin, elevated);
+				elevated[2] += 8;
+
+				VectorCopy( elevated, holoRef.lightingOrigin );
+				holoRef.shadowPlane = shadowPlane;
+				holoRef.renderfx = 0;//RF_THIRD_PERSON;
+
+				if (renderedHolos == 0)
+				{
+					angle = ((cg.time / 8) & 255) * (M_PI * 2) / 255;
+					dir[0] = cos(angle) * 20;
+					dir[1] = sin(angle) * 20;
+					dir[2] = cos(angle) * 20;
+					VectorAdd(elevated, dir, holoRef.origin);
+
+					angles[0] = sin(angle) * 30;
+					angles[1] = (angle * 180 / M_PI) + 90;
+					if (angles[1] > 360)
+						angles[1] -= 360;
+					angles[2] = 0;
+					AnglesToAxis( angles, holoRef.axis );
+				}
+				else if (renderedHolos == 1)
+				{
+					angle = ((cg.time / 8) & 255) * (M_PI * 2) / 255 + M_PI;
+					if (angle > M_PI * 2)
+						angle -= (float)M_PI * 2;
+					dir[0] = sin(angle) * 20;
+					dir[1] = cos(angle) * 20;
+					dir[2] = cos(angle) * 20;
+					VectorAdd(elevated, dir, holoRef.origin);
+
+					angles[0] = cos(angle - 0.5 * M_PI) * 30;
+					angles[1] = 360 - (angle * 180 / M_PI);
+					if (angles[1] > 360)
+						angles[1] -= 360;
+					angles[2] = 0;
+					AnglesToAxis( angles, holoRef.axis );
+				}
+				else
+				{
+					angle = ((cg.time / 6) & 255) * (M_PI * 2) / 255 + 0.5 * M_PI;
+					if (angle > M_PI * 2)
+						angle -= (float)M_PI * 2;
+					dir[0] = sin(angle) * 20;
+					dir[1] = cos(angle) * 20;
+					dir[2] = 0;
+					VectorAdd(elevated, dir, holoRef.origin);
+			
+					VectorCopy(dir, holoRef.axis[1]);
+					VectorNormalize(holoRef.axis[1]);
+					VectorSet(holoRef.axis[2], 0, 0, 1);
+					CrossProduct(holoRef.axis[1], holoRef.axis[2], holoRef.axis[0]);
+				}
+
+				holoRef.modelScale[0] = 0.5;
+				holoRef.modelScale[1] = 0.5;
+				holoRef.modelScale[2] = 0.5;
+				ScaleModelAxis(&holoRef);
+
+				{
+					float wv;
+					addspriteArgStruct_t fxSArgs;
+					vec3_t holoCenter;
+
+					holoCenter[0] = holoRef.origin[0] + holoRef.axis[2][0]*18;
+					holoCenter[1] = holoRef.origin[1] + holoRef.axis[2][1]*18;
+					holoCenter[2] = holoRef.origin[2] + holoRef.axis[2][2]*18;
+
+					wv = sin( cg.time * 0.004f ) * 0.08f + 0.1f;
+
+					VectorCopy(holoCenter, fxSArgs.origin);
+					VectorClear(fxSArgs.vel);
+					VectorClear(fxSArgs.accel);
+					fxSArgs.scale = wv*60;
+					fxSArgs.dscale = wv*60;
+					fxSArgs.sAlpha = wv*12;
+					fxSArgs.eAlpha = wv*12;
+					fxSArgs.rotation = 0.0f;
+					fxSArgs.bounce = 0.0f;
+					fxSArgs.life = 1.0f;
+
+					fxSArgs.flags = 0x08000000|0x00000001;
+
+					if (forcePowerDarkLight[i] == FORCE_DARKSIDE)
+					{ //dark
+						fxSArgs.sAlpha *= 3;
+						fxSArgs.eAlpha *= 3;
+						fxSArgs.shader = cgs.media.redSaberGlowShader;
+						trap_FX_AddSprite(&fxSArgs);
+					}
+					else if (forcePowerDarkLight[i] == FORCE_LIGHTSIDE)
+					{ //light
+						fxSArgs.sAlpha *= 1.5;
+						fxSArgs.eAlpha *= 1.5;
+						fxSArgs.shader = cgs.media.redSaberGlowShader;
+						trap_FX_AddSprite(&fxSArgs);
+						fxSArgs.shader = cgs.media.greenSaberGlowShader;
+						trap_FX_AddSprite(&fxSArgs);
+						fxSArgs.shader = cgs.media.blueSaberGlowShader;
+						trap_FX_AddSprite(&fxSArgs);
+					}
+					else
+					{ //neutral
+						if (i == FP_SABER_OFFENSE ||
+							i == FP_SABER_DEFENSE ||
+							i == FP_SABERTHROW)
+						{ //saber power
+							fxSArgs.sAlpha *= 1.5;
+							fxSArgs.eAlpha *= 1.5;
+							fxSArgs.shader = cgs.media.greenSaberGlowShader;
+							trap_FX_AddSprite(&fxSArgs);
+						}
+						else
+						{
+							fxSArgs.sAlpha *= 0.5;
+							fxSArgs.eAlpha *= 0.5;
+							fxSArgs.shader = cgs.media.greenSaberGlowShader;
+							trap_FX_AddSprite(&fxSArgs);
+							fxSArgs.shader = cgs.media.blueSaberGlowShader;
+							trap_FX_AddSprite(&fxSArgs);
+						}
+					}
+				}
+
+				holoRef.hModel = trap_R_RegisterModel(forceHolocronModels[i]);
+				trap_R_AddRefEntityToScene( &holoRef );
+
+				renderedHolos++;
+			}
+			i++;
+		}
+	}
+
+	if ((cent->currentState.powerups & (1 << PW_YSALAMIRI)) ||
+		(cgs.gametype == GT_CTY && ((cent->currentState.powerups & (1 << PW_REDFLAG)) || (cent->currentState.powerups & (1 << PW_BLUEFLAG)))) )
+	{
+		if (cgs.gametype == GT_CTY && (cent->currentState.powerups & (1 << PW_REDFLAG)))
+		{
+			CG_DrawPlayerSphere(cent, cent->lerpOrigin, 1.4f, cgs.media.ysaliredShader );
+		}
+		else if (cgs.gametype == GT_CTY && (cent->currentState.powerups & (1 << PW_BLUEFLAG)))
+		{
+			CG_DrawPlayerSphere(cent, cent->lerpOrigin, 1.4f, cgs.media.ysaliblueShader );
+		}
+		else
+		{
+			CG_DrawPlayerSphere(cent, cent->lerpOrigin, 1.4f, cgs.media.ysalimariShader );
+		}
+	}
+	
+	if (cent->currentState.powerups & (1 << PW_FORCE_BOON))
+	{
+		CG_DrawPlayerSphere(cent, cent->lerpOrigin, 2.0f, cgs.media.boonShader );
+	}
+
+	if (cent->currentState.powerups & (1 << PW_FORCE_ENLIGHTENED_DARK))
+	{
+		CG_DrawPlayerSphere(cent, cent->lerpOrigin, 2.0f, cgs.media.endarkenmentShader );
+	}
+	else if (cent->currentState.powerups & (1 << PW_FORCE_ENLIGHTENED_LIGHT))
+	{
+		CG_DrawPlayerSphere(cent, cent->lerpOrigin, 2.0f, cgs.media.enlightenmentShader );
+	}
+
+	if (cent->currentState.eFlags & EF_INVULNERABLE)
+	{
+		CG_DrawPlayerSphere(cent, cent->lerpOrigin, 1.0f, cgs.media.invulnerabilityShader );
+	}
+stillDoSaber:
+	if ((cent->currentState.eFlags & EF_DEAD) && cent->currentState.weapon == WP_SABER)
+	{
+		//cent->saberLength = 0;
+		BG_SI_SetDesiredLength(&ci->saber[0], 0, -1);
+		BG_SI_SetDesiredLength(&ci->saber[1], 0, -1);
+
+		drawPlayerSaber = qtrue;
+	}
+	else if (cent->currentState.weapon == WP_SABER 
+		&& cent->currentState.saberHolstered < 2 )
+	{
+		if ( (!cent->currentState.saberInFlight //saber not in flight
+				|| ci->saber[1].soundLoop) //???
+			&& !(cent->currentState.eFlags & EF_DEAD))//still alive
+		{
+			vec3_t soundSpot;
+			qboolean didFirstSound = qfalse;
+
+			if (cg.snap->ps.clientNum == cent->currentState.number)
+			{
+				//trap_S_AddLoopingSound( cent->currentState.number, cg.refdef.vieworg, vec3_origin, 
+				//	trap_S_RegisterSound( "sound/weapons/saber/saberhum1.wav" ) );
+				VectorCopy(cg.refdef.vieworg, soundSpot);
+			}
+			else
+			{
+				//trap_S_AddLoopingSound( cent->currentState.number, cent->lerpOrigin, vec3_origin, 
+				//	trap_S_RegisterSound( "sound/weapons/saber/saberhum1.wav" ) );
+				VectorCopy(cent->lerpOrigin, soundSpot);
+			}
+
+			if (ci->saber[0].model[0] 
+				&& ci->saber[0].soundLoop 
+				&& !cent->currentState.saberInFlight)
+			{
+				int i = 0;
+				qboolean hasLen = qfalse;
+
+				while (i < ci->saber[0].numBlades)
+				{
+					if (ci->saber[0].blade[i].length)
+					{
+						hasLen = qtrue;
+						break;
+					}
+					i++;
+				}
+
+				if (hasLen)
+				{
+					trap_S_AddLoopingSound( cent->currentState.number, soundSpot, vec3_origin, 
+						ci->saber[0].soundLoop );
+					didFirstSound = qtrue;
+				}
+			}
+			if (ci->saber[1].model[0] 
+				&& ci->saber[1].soundLoop 
+					&& (!didFirstSound || ci->saber[0].soundLoop != ci->saber[1].soundLoop))
+			{
+				int i = 0;
+				qboolean hasLen = qfalse;
+
+				while (i < ci->saber[1].numBlades)
+				{
+					if (ci->saber[1].blade[i].length)
+					{
+						hasLen = qtrue;
+						break;
+					}
+					i++;
+				}
+
+				if (hasLen)
+				{
+					trap_S_AddLoopingSound( cent->currentState.number, soundSpot, vec3_origin, 
+						ci->saber[1].soundLoop );
+				}
+			}
+		}
+
+		if (iwantout 
+			&& !cent->currentState.saberInFlight)
+		{
+			if (cent->currentState.eFlags & EF_DEAD)
+			{
+				if (cent->ghoul2 
+					&& cent->currentState.saberInFlight 
+					&& g2HasWeapon)
+				{ //special case, kill the saber on a freshly dead player if another source says to.
+					trap_G2API_RemoveGhoul2Model(&(cent->ghoul2), 1);
+					g2HasWeapon = qfalse;
+				}
+			}
+			return;
+			//goto endOfCall;
+		}
+
+		if (g2HasWeapon 
+			&& cent->currentState.saberInFlight)
+		{ //keep this set, so we don't re-unholster the thing when we get it back, even if it's knocked away.
+			cent->saberWasInFlight = qtrue;
+		}
+
+		if (cent->currentState.saberInFlight 
+			&& cent->currentState.saberEntityNum)
+		{
+			centity_t *saberEnt;
+
+			saberEnt = &cg_entities[cent->currentState.saberEntityNum];
+
+			if (/*!cent->bolt4 &&*/ g2HasWeapon || !cent->bolt3 ||
+				saberEnt->serverSaberHitIndex != saberEnt->currentState.modelindex/*|| !cent->saberLength*/)
+			{ //saber is in flight, do not have it as a standard weapon model
+				qboolean addBolts = qfalse;
+				mdxaBone_t boltMat;
+
+				if (g2HasWeapon)
+				{
+					//ah well, just stick it over the right hand right now.
+					trap_G2API_GetBoltMatrix(cent->ghoul2, 0, ci->bolt_rhand, &boltMat, cent->turAngles, cent->lerpOrigin,
+						cg.time, cgs.gameModels, cent->modelScale);
+					BG_GiveMeVectorFromMatrix(&boltMat, ORIGIN, saberEnt->currentState.pos.trBase);
+
+					trap_G2API_RemoveGhoul2Model(&(cent->ghoul2), 1);
+					g2HasWeapon = qfalse;
+				}
+
+				//cent->bolt4 = 1;
+
+				saberEnt->currentState.pos.trTime = cg.time;
+				saberEnt->currentState.apos.trTime = cg.time;
+
+				VectorCopy(saberEnt->currentState.pos.trBase, saberEnt->lerpOrigin);
+				VectorCopy(saberEnt->currentState.apos.trBase, saberEnt->lerpAngles);
+
+				cent->bolt3 = saberEnt->currentState.apos.trBase[0];
+				if (!cent->bolt3)
+				{
+					cent->bolt3 = 1;
+				}
+				cent->bolt2 = 0;
+
+				saberEnt->currentState.bolt2 = 123;
+
+				if (saberEnt->ghoul2 &&
+					saberEnt->serverSaberHitIndex == saberEnt->currentState.modelindex)
+				{
+					// now set up the gun bolt on it
+					addBolts = qtrue;
+				}
+				else
+				{
+					const char *saberModel = CG_ConfigString( CS_MODELS+saberEnt->currentState.modelindex );
+
+					saberEnt->serverSaberHitIndex = saberEnt->currentState.modelindex;
+
+					if (saberEnt->ghoul2)
+					{ //clean if we already have one (because server changed model string index)
+						trap_G2API_CleanGhoul2Models(&(saberEnt->ghoul2));
+						saberEnt->ghoul2 = 0;
+					}
+
+					if (saberModel && saberModel[0])
+					{
+						trap_G2API_InitGhoul2Model(&saberEnt->ghoul2, saberModel, 0, 0, 0, 0, 0);
+					}
+					else if (ci->saber[0].model[0])
+					{
+						trap_G2API_InitGhoul2Model(&saberEnt->ghoul2, ci->saber[0].model, 0, 0, 0, 0, 0);
+					}
+					else
+					{
+						trap_G2API_InitGhoul2Model(&saberEnt->ghoul2, "models/weapons2/saber/saber_w.glm", 0, 0, 0, 0, 0);
+					}
+					//trap_G2API_DuplicateGhoul2Instance(cent->ghoul2, &saberEnt->ghoul2);
+
+					if (saberEnt->ghoul2)
+					{
+						addBolts = qtrue;
+						//cent->bolt4 = 2;
+						
+						VectorCopy(saberEnt->currentState.pos.trBase, saberEnt->lerpOrigin);
+						VectorCopy(saberEnt->currentState.apos.trBase, saberEnt->lerpAngles);
+						saberEnt->currentState.pos.trTime = cg.time;
+						saberEnt->currentState.apos.trTime = cg.time;
+					}
+				}
+
+				if (addBolts)
+				{
+					int m = 0;
+					int tagBolt;
+					char *tagName;
+
+					while (m < ci->saber[0].numBlades)
+					{
+						tagName = va("*blade%i", m+1);
+						tagBolt = trap_G2API_AddBolt(saberEnt->ghoul2, 0, tagName);
+
+						if (tagBolt == -1)
+						{
+							if (m == 0)
+							{ //guess this is an 0ldsk3wl saber
+								tagBolt = trap_G2API_AddBolt(saberEnt->ghoul2, 0, "*flash");
+
+								if (tagBolt == -1)
+								{
+									assert(0);
+								}
+								break;
+							}
+
+							if (tagBolt == -1)
+							{
+								assert(0);
+								break;
+							}
+						}
+
+						m++;
+					}
+				}
+			}
+			/*else if (cent->bolt4 != 2)
+			{
+				if (saberEnt->ghoul2)
+				{
+					trap_G2API_AddBolt(saberEnt->ghoul2, 0, "*flash");
+					cent->bolt4 = 2;
+				}
+			}*/
+
+			if (saberEnt && saberEnt->ghoul2 /*&& cent->bolt4 == 2*/)
+			{
+				vec3_t bladeAngles;
+				vec3_t tAng;
+				vec3_t efOrg;
+				float wv;
+				int k = 0;
+				int l = 0;
+				addspriteArgStruct_t fxSArgs;
+
+				if (!cent->bolt2)
+				{
+					cent->bolt2 = cg.time;
+				}
+
+				if (cent->bolt3 != 90)
+				{
+					if (cent->bolt3 < 90)
+					{
+						cent->bolt3 += (cg.time - cent->bolt2)*0.5;
+
+						if (cent->bolt3 > 90)
+						{
+							cent->bolt3 = 90;
+						}
+					}
+					else if (cent->bolt3 > 90)
+					{
+						cent->bolt3 -= (cg.time - cent->bolt2)*0.5;
+
+						if (cent->bolt3 < 90)
+						{
+							cent->bolt3 = 90;
+						}
+					}
+				}
+
+				cent->bolt2 = cg.time;
+
+				saberEnt->currentState.apos.trBase[0] = cent->bolt3;
+				saberEnt->lerpAngles[0] = cent->bolt3;
+
+				if (!saberEnt->currentState.saberInFlight && saberEnt->currentState.bolt2 != 123)
+				{ //owner is pulling is back
+					if ( !ci->saber[0].returnDamage
+						|| cent->currentState.saberHolstered )
+					{
+						vec3_t owndir;
+
+						VectorSubtract(saberEnt->lerpOrigin, cent->lerpOrigin, owndir);
+						VectorNormalize(owndir);
+
+						vectoangles(owndir, owndir);
+
+						owndir[0] += 90;
+
+						VectorCopy(owndir, saberEnt->currentState.apos.trBase);
+						VectorCopy(owndir, saberEnt->lerpAngles);
+						VectorClear(saberEnt->currentState.apos.trDelta);
+					}
+				}
+
+				//We don't actually want to rely entirely on server updates to render the position of the saber, because we actually know generally where
+				//it's going to be before the first position update even gets here, and it needs to start getting rendered the instant the saber model is
+				//removed from the player hand. So we'll just render it manually and let normal rendering for the entity be ignored.
+				if (!saberEnt->currentState.saberInFlight && saberEnt->currentState.bolt2 != 123)
+				{ //tell it that we're a saber and to render the glow around our handle because we're being pulled back
+					saberEnt->bolt3 = 999;
+				}
+
+				saberEnt->currentState.modelGhoul2 = 1;
+				CG_ManualEntityRender(saberEnt);
+				saberEnt->bolt3 = 0;
+				saberEnt->currentState.modelGhoul2 = 127;
+
+				VectorCopy(saberEnt->lerpAngles, bladeAngles);
+				bladeAngles[ROLL] = 0;
+
+				if ( ci->saber[0].numBlades > 1//staff
+					&& cent->currentState.saberHolstered == 1 )//extra blades off
+				{//only first blade should be on
+					BG_SI_SetDesiredLength(&ci->saber[0], 0, -1);
+					BG_SI_SetDesiredLength(&ci->saber[0], -1, 0);
+				}
+				else
+				{
+					BG_SI_SetDesiredLength(&ci->saber[0], -1, -1);
+				}
+				if ( ci->saber[1].model	//dual sabers
+					&& cent->currentState.saberHolstered == 1 )//second one off
+				{
+					BG_SI_SetDesiredLength(&ci->saber[1], 0, -1);
+				}
+				else
+				{
+					BG_SI_SetDesiredLength(&ci->saber[1], -1, -1);
+				}
+
+				//while (l < MAX_SABERS)
+				//Only want to do for the first saber actually, it's the one in flight.
+				while (l < 1)
+				{
+					if (!ci->saber[l].model[0])
+					{
+						break;
+					}
+
+					k = 0;
+					while (k < ci->saber[l].numBlades)
+					{
+						if ( //cent->currentState.fireflag == SS_STAFF&& //in saberstaff style
+							l == 0//first saber
+							&& cent->currentState.saberHolstered == 1 //extra blades should be off
+							&& k > 0 )//this is an extra blade
+						{//extra blades off
+							//don't draw them
+							CG_AddSaberBlade(cent, saberEnt, NULL, 0, 0, l, k, saberEnt->lerpOrigin, bladeAngles, qtrue, qtrue);
+						}
+						else
+						{
+							CG_AddSaberBlade(cent, saberEnt, NULL, 0, 0, l, k, saberEnt->lerpOrigin, bladeAngles, qtrue, qfalse);
+						}
+
+						k++;
+					}
+					if ( ci->saber[l].numBlades > 2 )
+					{//add a single glow for the saber based on all the blade colors combined
+						CG_DoSaberLight( &ci->saber[l] );
+					}
+
+					l++;
+				}
+
+				//Make the player's hand glow while guiding the saber
+				VectorSet( tAng, cent->turAngles[PITCH], cent->turAngles[YAW], cent->turAngles[ROLL] );
+
+				trap_G2API_GetBoltMatrix(cent->ghoul2, 0, ci->bolt_rhand, &boltMatrix, tAng, cent->lerpOrigin, cg.time, cgs.gameModels, cent->modelScale);
+
+				efOrg[0] = boltMatrix.matrix[0][3];
+				efOrg[1] = boltMatrix.matrix[1][3];
+				efOrg[2] = boltMatrix.matrix[2][3];
+
+				wv = sin( cg.time * 0.003f ) * 0.08f + 0.1f;
+
+				//trap_FX_AddSprite( NULL, efOrg, NULL, NULL, 8.0f, 8.0f, wv, wv, 0.0f, 0.0f, 1.0f, cgs.media.yellowSaberGlowShader, 0x08000000 );
+				VectorCopy(efOrg, fxSArgs.origin);
+				VectorClear(fxSArgs.vel);
+				VectorClear(fxSArgs.accel);
+				fxSArgs.scale = 8.0f;
+				fxSArgs.dscale = 8.0f;
+				fxSArgs.sAlpha = wv;
+				fxSArgs.eAlpha = wv;
+				fxSArgs.rotation = 0.0f;
+				fxSArgs.bounce = 0.0f;
+				fxSArgs.life = 1.0f;
+				fxSArgs.shader = cgs.media.yellowDroppedSaberShader;
+				fxSArgs.flags = 0x08000000;
+				trap_FX_AddSprite(&fxSArgs);
+			}
+		}
+		else
+		{
+			if ( ci->saber[0].numBlades > 1//staff
+				&& cent->currentState.saberHolstered == 1 )//extra blades off
+			{//only first blade should be on
+				BG_SI_SetDesiredLength(&ci->saber[0], 0, -1);
+				BG_SI_SetDesiredLength(&ci->saber[0], -1, 0);
+			}
+			else
+			{
+				BG_SI_SetDesiredLength(&ci->saber[0], -1, -1);
+			}
+			if ( ci->saber[1].model	//dual sabers
+				&& cent->currentState.saberHolstered == 1 )//second one off
+			{
+				BG_SI_SetDesiredLength(&ci->saber[1], 0, -1);
+			}
+			else
+			{
+				BG_SI_SetDesiredLength(&ci->saber[1], -1, -1);
+			}
+		}
+
+		//If the arm the saber is in is broken, turn it off.
+		/*
+		if (cent->currentState.brokenLimbs & (1 << BROKENLIMB_RARM))
+		{
+			BG_SI_SetDesiredLength(&ci->saber[0], 0, -1);
+		}
+		*/
+		//Leaving right arm on, at least for now.
+		if (cent->currentState.brokenLimbs & (1 << BROKENLIMB_LARM))
+		{
+			BG_SI_SetDesiredLength(&ci->saber[1], 0, -1);
+		}
+
+		if (!cent->currentState.saberEntityNum)
+		{
+			BG_SI_SetDesiredLength(&ci->saber[0], 0, -1);
+			//BG_SI_SetDesiredLength(&ci->saber[1], 0, -1);
+		}
+		/*
+		else
+		{
+			BG_SI_SetDesiredLength(&ci->saber[0], 0, -1);
+			BG_SI_SetDesiredLength(&ci->saber[1], 0, -1);
+		}
+		*/
+		drawPlayerSaber = qtrue;
+	}
+	else if (cent->currentState.weapon == WP_SABER)
+	{
+		//cent->saberLength = 0;
+		BG_SI_SetDesiredLength(&ci->saber[0], 0, -1);
+		BG_SI_SetDesiredLength(&ci->saber[1], 0, -1);
+
+		drawPlayerSaber = qtrue;
+	}
+	else
+	{
+		//cent->saberLength = 0;
+		BG_SI_SetDesiredLength(&ci->saber[0], 0, -1);
+		BG_SI_SetDesiredLength(&ci->saber[1], 0, -1);
+
+		BG_SI_SetLength(&ci->saber[0], 0);
+		BG_SI_SetLength(&ci->saber[1], 0);
+	}
+
+#ifdef _RAG_BOLT_TESTING
+	if (cent->currentState.eFlags & EF_RAG)
+	{
+		CG_TempTestFunction(cent, cent->turAngles);
+	}
+#endif
+
+	if (cent->currentState.weapon == WP_SABER)
+	{
+		BG_SI_SetLengthGradual(&ci->saber[0], cg.time);
+		BG_SI_SetLengthGradual(&ci->saber[1], cg.time);
+	}
+
+	if (drawPlayerSaber)
+	{
+		centity_t *saberEnt;
+		int k = 0;
+		int l = 0;
+
+		if (!cent->currentState.saberEntityNum)
+		{
+			l = 1; //The "primary" saber is missing or in flight or something, so only try to draw in the second one
+		}
+		else if (!cent->currentState.saberInFlight)
+		{
+			saberEnt = &cg_entities[cent->currentState.saberEntityNum];
+
+			if (/*cent->bolt4 && */!g2HasWeapon)
+			{
+				trap_G2API_CopySpecificGhoul2Model(CG_G2WeaponInstance(cent, WP_SABER), 0, cent->ghoul2, 1);
+
+				if (saberEnt && saberEnt->ghoul2)
+				{
+					trap_G2API_CleanGhoul2Models(&(saberEnt->ghoul2));
+				}
+
+				saberEnt->currentState.modelindex = 0;
+				saberEnt->ghoul2 = NULL;
+				VectorClear(saberEnt->currentState.pos.trBase);
+			}
+
+			cent->bolt3 = 0;
+			cent->bolt2 = 0;
+		}
+		else
+		{
+			l = 1; //The "primary" saber is missing or in flight or something, so only try to draw in the second one
+		}
+
+		while (l < MAX_SABERS)
+		{
+			k = 0;
+
+			if (!ci->saber[l].model[0])
+			{
+				break;
+			}
+
+			if (cent->currentState.eFlags2&EF2_HELD_BY_MONSTER)
+			{
+				//vectoangles(legs.axis[0], rootAngles);
+#if 0
+				if ( cent->currentState.hasLookTarget )//NOTE: lookTarget is an entity number, so this presumes that client 0 is NOT a Rancor...
+				{
+					centity_t	*rancor = &cg_entities[cent->currentState.lookTarget];
+					if ( rancor && rancor->ghoul2 )
+					{
+						BG_AttachToRancor( rancor->ghoul2, //ghoul2 info
+							rancor->lerpAngles[YAW],
+							rancor->lerpOrigin,
+							cg.time,
+							cgs.gameModels,
+							rancor->modelScale,
+							(rancor->currentState.eFlags2&EF2_GENERIC_NPC_FLAG),
+							legs.origin,
+							rootAngles,
+							NULL );
+					}
+				}
+#else
+				vectoangles(legs.axis[0], rootAngles);
+#endif
+			}
+
+			while (k < ci->saber[l].numBlades)
+			{
+				if ( //cent->currentState.fireflag == SS_STAFF&& //in saberstaff style
+					cent->currentState.saberHolstered == 1 //extra blades should be off
+					&& k > 0 //this is an extra blade
+					&& ci->saber[l].blade[k].length <= 0 )//it's completely off
+				{//extra blades off
+					//don't draw them
+					CG_AddSaberBlade( cent, cent, NULL, 0, 0, l, k, legs.origin, rootAngles, qfalse, qtrue);
+				}
+				else if ( ci->saber[1].model[0]//we have a second saber
+					&& cent->currentState.saberHolstered == 1 //it should be off
+					&& l > 0//and this is the second one
+					&& ci->saber[l].blade[k].length <= 0 )//it's completely off
+				{//second saber is turned off and this blade is done with turning off
+					CG_AddSaberBlade( cent, cent, NULL, 0, 0, l, k, legs.origin, rootAngles, qfalse, qtrue);
+				}
+				else
+				{
+					CG_AddSaberBlade( cent, cent, NULL, 0, 0, l, k, legs.origin, rootAngles, qfalse, qfalse);
+				}
+
+				k++;
+			}
+			if ( ci->saber[l].numBlades > 2 )
+			{//add a single glow for the saber based on all the blade colors combined
+				CG_DoSaberLight( &ci->saber[l] );
+			}
+
+			l++;
+		}
+	}
+
+	if (cent->currentState.saberInFlight && !cent->currentState.saberEntityNum)
+	{ //reset the length if the saber is knocked away
+		BG_SI_SetDesiredLength(&ci->saber[0], 0, -1);
+		BG_SI_SetDesiredLength(&ci->saber[1], 0, -1);
+
+		if (g2HasWeapon)
+		{ //and remember to kill the bolton model in case we didn't get a thrown saber update first
+			trap_G2API_RemoveGhoul2Model(&(cent->ghoul2), 1);
+			g2HasWeapon = qfalse;
+		}
+		cent->bolt3 = 0;
+		cent->bolt2 = 0;
+	}
+
+	if (cent->currentState.eFlags & EF_DEAD)
+	{
+		if (cent->ghoul2 && cent->currentState.saberInFlight && g2HasWeapon)
+		{ //special case, kill the saber on a freshly dead player if another source says to.
+			trap_G2API_RemoveGhoul2Model(&(cent->ghoul2), 1);
+			g2HasWeapon = qfalse;
+		}
+	}
+
+	if (iwantout)
+	{
+		return;
+		//goto endOfCall;
+	}
+
+	if ((cg.snap->ps.fd.forcePowersActive & (1 << FP_SEE)) && cg.snap->ps.clientNum != cent->currentState.number)
+	{
+		legs.shaderRGBA[0] = 255;
+		legs.shaderRGBA[1] = 255;
+		legs.shaderRGBA[2] = 0;
+		legs.renderfx |= RF_MINLIGHT;
+	}
+
+	if (cg.snap->ps.duelInProgress /*&& cent->currentState.number != cg.snap->ps.clientNum*/)
+	{ //I guess go ahead and glow your own client too in a duel
+		if (cent->currentState.number != cg.snap->ps.duelIndex &&
+			cent->currentState.number != cg.snap->ps.clientNum)
+		{ //everyone not involved in the duel is drawn very dark
+			legs.shaderRGBA[0] = 50;
+			legs.shaderRGBA[1] = 50;
+			legs.shaderRGBA[2] = 50;
+			legs.renderfx |= RF_RGB_TINT;
+		}
+		else
+		{ //adjust the glow by how far away you are from your dueling partner
+			centity_t *duelEnt;
+
+			duelEnt = &cg_entities[cg.snap->ps.duelIndex];
+			
+			if (duelEnt)
+			{
+				vec3_t vecSub;
+				float subLen = 0;
+
+				VectorSubtract(duelEnt->lerpOrigin, cg.snap->ps.origin, vecSub);
+				subLen = VectorLength(vecSub);
+
+				if (subLen < 1)
+				{
+					subLen = 1;
+				}
+
+				if (subLen > 1020)
+				{
+					subLen = 1020;
+				}
+
+				legs.shaderRGBA[0] = 255 - subLen/4;
+				legs.shaderRGBA[1] = 255 - subLen/4;
+				legs.shaderRGBA[2] = 255 - subLen/4;
+
+				if (legs.shaderRGBA[2] < 1) legs.shaderRGBA[2] = 1;
+
+				legs.renderfx &= ~RF_RGB_TINT;
+				legs.renderfx &= ~RF_FORCE_ENT_ALPHA;
+				legs.customShader = cgs.media.forceShell;
+		
+				trap_R_AddRefEntityToScene( &legs );
+
+				legs.customShader = 0;
+
+				legs.shaderRGBA[0] = 255 - subLen/8;
+				legs.shaderRGBA[1] = 255 - subLen/8;
+				legs.shaderRGBA[2] = 255 - subLen/8;
+
+				if (legs.shaderRGBA[2] < 1)
+				{
+					legs.shaderRGBA[2] = 1;
+				}
+				if (legs.shaderRGBA[2] > 255)
+				{
+					legs.shaderRGBA[2] = 255;
+				}
+
+				if (subLen <= 1024)
+				{
+					legs.renderfx |= RF_RGB_TINT;
+				}
+			}
+		}
+	}
+	else
+	{
+		if (cent->currentState.bolt1 && !(cent->currentState.eFlags & EF_DEAD) && cent->currentState.number != cg.snap->ps.clientNum && (!cg.snap->ps.duelInProgress || cg.snap->ps.duelIndex != cent->currentState.number))
+		{
+			legs.shaderRGBA[0] = 50;
+			legs.shaderRGBA[1] = 50;
+			legs.shaderRGBA[2] = 50;
+			legs.renderfx |= RF_RGB_TINT;
+		}
+	}
+
+	if (cent->currentState.eFlags & EF_DISINTEGRATION)
+	{
+		if (!cent->dustTrailTime)
+		{
+			cent->dustTrailTime = cg.time;
+			cent->miscTime = legs.frame;
+		}
+
+		if ((cg.time - cent->dustTrailTime) > 1500)
+		{ //avoid rendering the entity after disintegration has finished anyway
+			//goto endOfCall;
+			return;
+		}
+
+		trap_G2API_SetBoneAnim(legs.ghoul2, 0, "model_root", cent->miscTime, cent->miscTime, BONE_ANIM_OVERRIDE_FREEZE, 1.0f, cg.time, cent->miscTime, -1);
+
+		if (!cent->noLumbar)
+		{
+			trap_G2API_SetBoneAnim(legs.ghoul2, 0, "lower_lumbar", cent->miscTime, cent->miscTime, BONE_ANIM_OVERRIDE_FREEZE, 1.0f, cg.time, cent->miscTime, -1);
+
+			if (cent->localAnimIndex <= 1)
+			{
+				trap_G2API_SetBoneAnim(legs.ghoul2, 0, "Motion", cent->miscTime, cent->miscTime, BONE_ANIM_OVERRIDE_FREEZE, 1.0f, cg.time, cent->miscTime, -1);
+			}
+		}
+
+		CG_Disintegration(cent, &legs);
+
+		//goto endOfCall;
+		return;
+	}
+	else
+	{
+		cent->dustTrailTime = 0;
+		cent->miscTime = 0;
+	}
+
+	if (cent->currentState.powerups & (1 << PW_CLOAKED))
+	{
+		if (!cent->cloaked)
+		{
+			cent->cloaked = qtrue;
+			cent->uncloaking = cg.time + 2000;
+		}
+	}
+	else if (cent->cloaked)
+	{
+		cent->cloaked = qfalse;
+		cent->uncloaking = cg.time + 2000;
+	}
+
+	if (cent->uncloaking > cg.time)
+	{//in the middle of cloaking
+		if ((cg.snap->ps.fd.forcePowersActive & (1 << FP_SEE)) 
+			&& cg.snap->ps.clientNum != cent->currentState.number)
+		{//just draw him
+			trap_R_AddRefEntityToScene( &legs );
+		}
+		else
+		{
+			float perc = (float)(cent->uncloaking - cg.time) / 2000.0f;
+			if (( cent->currentState.powerups & ( 1 << PW_CLOAKED ))) 
+			{//actually cloaking, so reverse it
+				perc = 1.0f - perc;
+			}
+
+			if ( perc >= 0.0f && perc <= 1.0f )
+			{
+				legs.renderfx &= ~RF_FORCE_ENT_ALPHA;
+				legs.renderfx |= RF_RGB_TINT;
+				legs.shaderRGBA[0] = legs.shaderRGBA[1] = legs.shaderRGBA[2] = 255.0f * perc;
+				legs.shaderRGBA[3] = 0;
+				legs.customShader = cgs.media.cloakedShader;
+				trap_R_AddRefEntityToScene( &legs );
+
+				legs.shaderRGBA[0] = legs.shaderRGBA[1] = legs.shaderRGBA[2] = 255;
+				legs.shaderRGBA[3] = 255 * (1.0f - perc); // let model alpha in
+				legs.customShader = 0; // use regular skin
+				legs.renderfx &= ~RF_RGB_TINT;
+				legs.renderfx |= RF_FORCE_ENT_ALPHA;
+				trap_R_AddRefEntityToScene( &legs );
+			}
+		}
+	}
+	else if (( cent->currentState.powerups & ( 1 << PW_CLOAKED ))) 
+	{//fully cloaked
+		if ((cg.snap->ps.fd.forcePowersActive & (1 << FP_SEE)) 
+			&& cg.snap->ps.clientNum != cent->currentState.number)
+		{//just draw him
+			trap_R_AddRefEntityToScene( &legs );
+		}
+		else
+		{
+			if (cg.renderingThirdPerson || cent->currentState.number != cg.predictedPlayerState.clientNum)
+			{
+				/*
+				legs.renderfx = 0;//&= ~(RF_RGB_TINT|RF_ALPHA_FADE);
+				legs.shaderRGBA[0] = legs.shaderRGBA[1] = legs.shaderRGBA[2] = legs.shaderRGBA[3] = 255;
+				legs.customShader = cgs.media.cloakedShader;
+
+				legs.nonNormalizedAxes = qtrue;
+
+				legs.modelScale[0] = 1.02f;
+				legs.modelScale[1] = 1.02f;
+				legs.modelScale[2] = 1.02f;
+				VectorScale( legs.axis[0], legs.modelScale[0], legs.axis[0] );
+				VectorScale( legs.axis[1], legs.modelScale[1], legs.axis[1] );
+				VectorScale( legs.axis[2], legs.modelScale[2], legs.axis[2] );
+
+				ScaleModelAxis(&legs);
+
+				trap_R_AddRefEntityToScene( &legs );
+				
+				legs.modelScale[0] = 0.98f;
+				legs.modelScale[1] = 0.98f;
+				legs.modelScale[2] = 0.98f;
+				VectorScale( legs.axis[0], legs.modelScale[0], legs.axis[0] );
+				VectorScale( legs.axis[1], legs.modelScale[1], legs.axis[1] );
+				VectorScale( legs.axis[2], legs.modelScale[2], legs.axis[2] );
+
+				ScaleModelAxis(&legs);
+				*/
+
+				if (cg_shadows.integer != 2 && cgs.glconfig.stencilBits >= 4 && cg_renderToTextureFX.integer)
+				{
+					trap_R_SetRefractProp(1.0f, 0.0f, qfalse, qfalse); //don't need to do this every frame.. but..
+					legs.customShader = 2; //crazy "refractive" shader
+					trap_R_AddRefEntityToScene( &legs );
+					legs.customShader = 0;
+				}
+				else
+				{ //stencil buffer's in use, sorry
+					legs.renderfx = 0;//&= ~(RF_RGB_TINT|RF_ALPHA_FADE);
+					legs.shaderRGBA[0] = legs.shaderRGBA[1] = legs.shaderRGBA[2] = legs.shaderRGBA[3] = 255;
+					legs.customShader = cgs.media.cloakedShader;
+					trap_R_AddRefEntityToScene( &legs );
+					legs.customShader = 0;
+				}
+			}
+		}
+	}
+
+	if (!(cent->currentState.powerups & (1 << PW_CLOAKED)))
+	{ //don't add the normal model if cloaked
+		CG_CheckThirdPersonAlpha( cent, &legs );
+		trap_R_AddRefEntityToScene(&legs);
+	}
+
+	//cent->frame_minus2 = cent->frame_minus1;
+	VectorCopy(cent->frame_minus1, cent->frame_minus2);
+	
+	if (cent->frame_minus1_refreshed)
+	{
+		cent->frame_minus2_refreshed = 1;
+	}
+
+	//cent->frame_minus1 = legs;
+	VectorCopy(legs.origin, cent->frame_minus1);
+
+	cent->frame_minus1_refreshed = 1;
+
+	if (!cent->frame_hold_refreshed && (cent->currentState.powerups & (1 << PW_SPEEDBURST)))
+	{
+		cent->frame_hold_time = cg.time + 254;
+	}
+
+	if (cent->frame_hold_time >= cg.time)
+	{
+		refEntity_t reframe_hold;
+
+		if (!cent->frame_hold_refreshed)
+		{ //We're taking the ghoul2 instance from the original refent and duplicating it onto our refent alias so that we can then freeze the frame and fade it for the effect
+			if (cent->frame_hold && trap_G2_HaveWeGhoul2Models(cent->frame_hold) &&
+				cent->frame_hold != cent->ghoul2)
+			{
+				trap_G2API_CleanGhoul2Models(&(cent->frame_hold));
+			}
+			reframe_hold = legs;
+			cent->frame_hold_refreshed = 1;
+			reframe_hold.ghoul2 = NULL;
+	
+			trap_G2API_DuplicateGhoul2Instance(cent->ghoul2, &cent->frame_hold);
+
+			//Set the animation to the current frame and freeze on end
+			//trap_G2API_SetBoneAnim(cent->frame_hold.ghoul2, 0, "model_root", cent->frame_hold.frame, cent->frame_hold.frame, BONE_ANIM_OVERRIDE_FREEZE, 1.0f, cg.time, cent->frame_hold.frame, -1);
+			trap_G2API_SetBoneAnim(cent->frame_hold, 0, "model_root", legs.frame, legs.frame, 0, 1.0f, cg.time, legs.frame, -1);
+		}
+		else
+		{
+			reframe_hold = legs;
+			reframe_hold.ghoul2 = cent->frame_hold;
+		}
+
+		reframe_hold.renderfx |= RF_FORCE_ENT_ALPHA;
+		reframe_hold.shaderRGBA[3] = (cent->frame_hold_time - cg.time);
+		if (reframe_hold.shaderRGBA[3] > 254)
+		{
+			reframe_hold.shaderRGBA[3] = 254;
+		}
+		if (reframe_hold.shaderRGBA[3] < 1)
+		{
+			reframe_hold.shaderRGBA[3] = 1;
+		}
+
+		reframe_hold.ghoul2 = cent->frame_hold;
+		trap_R_AddRefEntityToScene(&reframe_hold);
+	}
+	else
+	{
+		cent->frame_hold_refreshed = 0;
+	}
+
+	//
+	// add the gun / barrel / flash
+	//
+	if (cent->currentState.weapon != WP_EMPLACED_GUN)
+	{
+		CG_AddPlayerWeapon( &legs, NULL, cent, ci->team, rootAngles, qtrue );
+	}
+	// add powerups floating behind the player
+	CG_PlayerPowerups( cent, &legs );
+
+	if ((cent->currentState.forcePowersActive & (1 << FP_RAGE)) &&
+		(cg.renderingThirdPerson || cent->currentState.number != cg.snap->ps.clientNum))
+	{
+		//legs.customShader = cgs.media.rageShader;
+		legs.renderfx &= ~RF_FORCE_ENT_ALPHA;
+		legs.renderfx &= ~RF_MINLIGHT;
+
+		legs.renderfx |= RF_RGB_TINT;
+		legs.shaderRGBA[0] = 255;
+		legs.shaderRGBA[1] = legs.shaderRGBA[2] = 0;
+		legs.shaderRGBA[3] = 255;
+
+		if ( rand() & 1 )
+		{
+			legs.customShader = cgs.media.electricBodyShader;	
+		}
+		else
+		{
+			legs.customShader = cgs.media.electricBody2Shader;
+		}
+
+		trap_R_AddRefEntityToScene(&legs);
+	}
+
+	if (!cg.snap->ps.duelInProgress && cent->currentState.bolt1 && !(cent->currentState.eFlags & EF_DEAD) && cent->currentState.number != cg.snap->ps.clientNum && (!cg.snap->ps.duelInProgress || cg.snap->ps.duelIndex != cent->currentState.number))
+	{
+		legs.shaderRGBA[0] = 50;
+		legs.shaderRGBA[1] = 50;
+		legs.shaderRGBA[2] = 255;
+
+		legs.renderfx &= ~RF_RGB_TINT;
+		legs.renderfx &= ~RF_FORCE_ENT_ALPHA;
+		legs.customShader = cgs.media.forceSightBubble;
+		
+		trap_R_AddRefEntityToScene( &legs );
+	}
+
+	if ( CG_VehicleShouldDrawShields( cent ) //vehicle
+		|| (checkDroidShields && CG_VehicleShouldDrawShields( &cg_entities[cent->currentState.m_iVehicleNum] )) )//droid in vehicle
+	{//Vehicles have form-fitting shields
+		Vehicle_t *pVeh = cent->m_pVehicle;
+		if ( checkDroidShields )
+		{
+			pVeh = cg_entities[cent->currentState.m_iVehicleNum].m_pVehicle;
+		}
+		legs.shaderRGBA[0] = 255;
+		legs.shaderRGBA[1] = 255;
+		legs.shaderRGBA[2] = 255;
+		legs.shaderRGBA[3] = 10.0f+(sin((float)(cg.time/4))*128.0f);//112.0 * ((cent->damageTime - cg.time) / MIN_SHIELD_TIME) + random()*16;
+
+		legs.renderfx &= ~RF_RGB_TINT;
+		legs.renderfx &= ~RF_FORCE_ENT_ALPHA;
+
+		if ( pVeh 
+			&& pVeh->m_pVehicleInfo
+			&& pVeh->m_pVehicleInfo->shieldShaderHandle )
+		{//use the vehicle-specific shader
+			legs.customShader = pVeh->m_pVehicleInfo->shieldShaderHandle;
+		}
+		else
+		{
+			legs.customShader = cgs.media.playerShieldDamage;
+		}
+		
+		trap_R_AddRefEntityToScene( &legs );
+	}
+	//For now, these two are using the old shield shader. This is just so that you
+	//can tell it apart from the JM/duel shaders, but it's still very obvious.
+	if (cent->currentState.forcePowersActive & (1 << FP_PROTECT))
+	{ //aborb is represented by green..
+		refEntity_t prot;
+		
+		memcpy(&prot, &legs, sizeof(prot));
+
+		prot.shaderRGBA[0] = 0;
+		prot.shaderRGBA[1] = 128;
+		prot.shaderRGBA[2] = 0;
+		prot.shaderRGBA[3] = 254;
+
+		prot.renderfx &= ~RF_RGB_TINT;
+		prot.renderfx &= ~RF_FORCE_ENT_ALPHA;
+		prot.customShader = cgs.media.protectShader;
+
+		/*
+		if (!prot.modelScale[0] && !prot.modelScale[1] && !prot.modelScale[2])
+		{
+			prot.modelScale[0] = prot.modelScale[1] = prot.modelScale[2] = 1.0f;
+		}
+		VectorScale(prot.modelScale, 1.1f, prot.modelScale);
+		prot.origin[2] -= 2.0f;
+		ScaleModelAxis(&prot);
+		*/
+
+		trap_R_AddRefEntityToScene( &prot );
+	}
+	//if (cent->currentState.forcePowersActive & (1 << FP_ABSORB))
+	//Showing only when the power has been active (absorbed something) recently now, instead of always.
+	//AND
+	//always show if it is you with the absorb on
+	if ((cent->currentState.number == cg.predictedPlayerState.clientNum && (cg.predictedPlayerState.fd.forcePowersActive & (1<<FP_ABSORB))) ||
+		(cent->teamPowerEffectTime > cg.time && cent->teamPowerType == 3))
+	{ //aborb is represented by blue..
+		legs.shaderRGBA[0] = 0;
+		legs.shaderRGBA[1] = 0;
+		legs.shaderRGBA[2] = 255;
+		legs.shaderRGBA[3] = 254;
+
+		legs.renderfx &= ~RF_RGB_TINT;
+		legs.renderfx &= ~RF_FORCE_ENT_ALPHA;
+		legs.customShader = cgs.media.playerShieldDamage;
+		
+		trap_R_AddRefEntityToScene( &legs );
+	}
+
+	if (cent->currentState.isJediMaster && cg.snap->ps.clientNum != cent->currentState.number)
+	{
+		legs.shaderRGBA[0] = 100;
+		legs.shaderRGBA[1] = 100;
+		legs.shaderRGBA[2] = 255;
+
+		legs.renderfx &= ~RF_RGB_TINT;
+		legs.renderfx &= ~RF_FORCE_ENT_ALPHA;
+		legs.renderfx |= RF_NODEPTH;
+		legs.customShader = cgs.media.forceShell;
+		
+		trap_R_AddRefEntityToScene( &legs );
+
+		legs.renderfx &= ~RF_NODEPTH;
+	}
+
+	if ((cg.snap->ps.fd.forcePowersActive & (1 << FP_SEE)) && cg.snap->ps.clientNum != cent->currentState.number && cg_auraShell.integer)
+	{
+		if (cgs.gametype == GT_SIEGE)
+		{	// A team game
+			if ( ci->team == TEAM_SPECTATOR || ci->team == TEAM_FREE )
+			{//yellow
+				legs.shaderRGBA[0] = 255;
+				legs.shaderRGBA[1] = 255;
+				legs.shaderRGBA[2] = 0;
+			}
+			else if ( ci->team != cgs.clientinfo[cg.snap->ps.clientNum].team )
+			{//red
+				legs.shaderRGBA[0] = 255;
+				legs.shaderRGBA[1] = 50;
+				legs.shaderRGBA[2] = 50;
+			}
+			else
+			{//green
+				legs.shaderRGBA[0] = 50;
+				legs.shaderRGBA[1] = 255;
+				legs.shaderRGBA[2] = 50;
+			}
+		}
+		else if (cgs.gametype >= GT_TEAM)
+		{	// A team game
+			switch(ci->team)
+			{
+			case TEAM_RED:
+				legs.shaderRGBA[0] = 255;
+				legs.shaderRGBA[1] = 50;
+				legs.shaderRGBA[2] = 50;
+				break;
+			case TEAM_BLUE:
+				legs.shaderRGBA[0] = 75;
+				legs.shaderRGBA[1] = 75;
+				legs.shaderRGBA[2] = 255;
+				break;
+
+			default:
+				legs.shaderRGBA[0] = 255;
+				legs.shaderRGBA[1] = 255;
+				legs.shaderRGBA[2] = 0;
+				break;
+			}
+		}
+		else
+		{	// Not a team game
+			legs.shaderRGBA[0] = 255;
+			legs.shaderRGBA[1] = 255;
+			legs.shaderRGBA[2] = 0;
+		}
+
+/*		if (cg.snap->ps.fd.forcePowerLevel[FP_SEE] <= FORCE_LEVEL_1)
+		{
+			legs.renderfx |= RF_MINLIGHT;
+		}
+		else
+*/		{	// See through walls.
+			legs.renderfx |= RF_MINLIGHT | RF_NODEPTH;
+
+			if (cg.snap->ps.fd.forcePowerLevel[FP_SEE] < FORCE_LEVEL_2)
+			{ //only level 2+ can see players through walls
+				legs.renderfx &= ~RF_NODEPTH;
+			}
+		}
+
+		legs.renderfx &= ~RF_RGB_TINT;
+		legs.renderfx &= ~RF_FORCE_ENT_ALPHA;
+		legs.customShader = cgs.media.sightShell;
+		
+		trap_R_AddRefEntityToScene( &legs );
+	}
+
+	// Electricity
+	//------------------------------------------------
+	if ( cent->currentState.emplacedOwner > cg.time ) 
+	{
+		int	dif = cent->currentState.emplacedOwner - cg.time;
+		vec3_t tempAngles;
+
+		if ( dif > 0 && random() > 0.4f )
+		{
+			// fade out over the last 500 ms
+			int brightness = 255;
+			
+			if ( dif < 500 )
+			{
+				brightness = floor((dif - 500.0f) / 500.0f * 255.0f );
+			}
+
+			legs.renderfx &= ~RF_FORCE_ENT_ALPHA;
+			legs.renderfx &= ~RF_MINLIGHT;
+
+			legs.renderfx |= RF_RGB_TINT;
+			legs.shaderRGBA[0] = legs.shaderRGBA[1] = legs.shaderRGBA[2] = brightness;
+			legs.shaderRGBA[3] = 255;
+
+			if ( rand() & 1 )
+			{
+				legs.customShader = cgs.media.electricBodyShader;	
+			}
+			else
+			{
+				legs.customShader = cgs.media.electricBody2Shader;
+			}
+
+			trap_R_AddRefEntityToScene( &legs );
+
+			if ( random() > 0.9f )
+				trap_S_StartSound ( NULL, cent->currentState.number, CHAN_AUTO, cgs.media.crackleSound );
+		}
+
+		VectorSet(tempAngles, 0, cent->lerpAngles[YAW], 0);
+		CG_ForceElectrocution( cent, legs.origin, tempAngles, cgs.media.boltShader, qfalse );
+	} 
+
+	if (cent->currentState.powerups & (1 << PW_SHIELDHIT))
+	{
+		/*
+		legs.shaderRGBA[0] = legs.shaderRGBA[1] = legs.shaderRGBA[2] = 255.0f * 0.5f;//t;
+		legs.shaderRGBA[3] = 255;
+		legs.renderfx &= ~RF_ALPHA_FADE;
+		legs.renderfx |= RF_RGB_TINT;
+		*/
+
+		legs.shaderRGBA[0] = legs.shaderRGBA[1] = legs.shaderRGBA[2] = Q_irand(1, 255);
+
+		legs.renderfx &= ~RF_FORCE_ENT_ALPHA;
+		legs.renderfx &= ~RF_MINLIGHT;
+		legs.renderfx &= ~RF_RGB_TINT;
+		legs.customShader = cgs.media.playerShieldDamage;
+		
+		trap_R_AddRefEntityToScene( &legs );
+	}
+#if 0
+endOfCall:
+	
+	if (cgBoneAnglePostSet.refreshSet)
+	{
+		trap_G2API_SetBoneAngles(cgBoneAnglePostSet.ghoul2, cgBoneAnglePostSet.modelIndex, cgBoneAnglePostSet.boneName,
+			cgBoneAnglePostSet.angles, cgBoneAnglePostSet.flags, cgBoneAnglePostSet.up, cgBoneAnglePostSet.right,
+			cgBoneAnglePostSet.forward, cgBoneAnglePostSet.modelList, cgBoneAnglePostSet.blendTime, cgBoneAnglePostSet.currentTime);
+
+		cgBoneAnglePostSet.refreshSet = qfalse;
+	}
+#endif
+}
+
+
+//=====================================================================
+
+/*
+===============
+CG_ResetPlayerEntity
+
+A player just came into view or teleported, so reset all animation info
+===============
+*/
+void CG_ResetPlayerEntity( centity_t *cent ) 
+{
+	clientInfo_t *ci;
+	int i = 0;
+	int j = 0;
+
+//	cent->errorTime = -99999;		// guarantee no error decay added
+//	cent->extrapolated = qfalse;	
+
+	if (cent->currentState.eType == ET_NPC)
+	{
+		if (!cent->npcClient)
+		{
+			CG_CreateNPCClient(&cent->npcClient); //allocate memory for it
+
+			if (!cent->npcClient)
+			{
+				assert(0);
+				return;
+			}
+
+			memset(cent->npcClient, 0, sizeof(clientInfo_t));
+			cent->npcClient->ghoul2Model = NULL;
+		}
+
+		ci = cent->npcClient;
+
+		assert(ci);
+
+		//just force these guys to be set again, it won't hurt anything if they're
+		//already set.
+		cent->npcLocalSurfOff = 0;
+		cent->npcLocalSurfOn = 0;
+	}
+	else
+	{
+		ci = &cgs.clientinfo[ cent->currentState.clientNum ];
+	}
+
+	while (i < MAX_SABERS)
+	{
+		j = 0;
+		while (j < ci->saber[i].numBlades)
+		{
+			ci->saber[i].blade[j].trail.lastTime = -20000;
+			j++;
+		}
+		i++;
+	}
+
+	ci->facial_blink = -1;
+	ci->facial_frown = 0;
+	ci->facial_aux = 0;
+	ci->superSmoothTime = 0;
+
+	//reset lerp origin smooth point
+	VectorCopy(cent->lerpOrigin, cent->beamEnd);
+
+	if (cent->currentState.eType != ET_NPC ||
+		!(cent->currentState.eFlags & EF_DEAD))
+	{
+		CG_ClearLerpFrame( cent, ci, &cent->pe.legs, cent->currentState.legsAnim, qfalse);
+		CG_ClearLerpFrame( cent, ci, &cent->pe.torso, cent->currentState.torsoAnim, qtrue);
+
+		BG_EvaluateTrajectory( &cent->currentState.pos, cg.time, cent->lerpOrigin );
+		BG_EvaluateTrajectory( &cent->currentState.apos, cg.time, cent->lerpAngles );
+
+//		VectorCopy( cent->lerpOrigin, cent->rawOrigin );
+		VectorCopy( cent->lerpAngles, cent->rawAngles );
+
+		memset( &cent->pe.legs, 0, sizeof( cent->pe.legs ) );
+		cent->pe.legs.yawAngle = cent->rawAngles[YAW];
+		cent->pe.legs.yawing = qfalse;
+		cent->pe.legs.pitchAngle = 0;
+		cent->pe.legs.pitching = qfalse;
+
+		memset( &cent->pe.torso, 0, sizeof( cent->pe.legs ) );
+		cent->pe.torso.yawAngle = cent->rawAngles[YAW];
+		cent->pe.torso.yawing = qfalse;
+		cent->pe.torso.pitchAngle = cent->rawAngles[PITCH];
+		cent->pe.torso.pitching = qfalse;
+
+		if (cent->currentState.eType == ET_NPC)
+		{ //just start them off at 0 pitch
+			cent->pe.torso.pitchAngle = 0;
+		}
+
+		if ((cent->ghoul2 == NULL) && ci->ghoul2Model && trap_G2_HaveWeGhoul2Models(ci->ghoul2Model))
+		{
+			trap_G2API_DuplicateGhoul2Instance(ci->ghoul2Model, &cent->ghoul2);
+			cent->weapon = 0;
+			cent->ghoul2weapon = NULL;
+
+			//Attach the instance to this entity num so we can make use of client-server
+			//shared operations if possible.
+			trap_G2API_AttachInstanceToEntNum(cent->ghoul2, cent->currentState.number, qfalse);
+
+			if (trap_G2API_AddBolt(cent->ghoul2, 0, "face") == -1)
+			{ //check now to see if we have this bone for setting anims and such
+				cent->noFace = qtrue;
+			}
+
+			cent->localAnimIndex = CG_G2SkelForModel(cent->ghoul2);
+			cent->eventAnimIndex = CG_G2EvIndexForModel(cent->ghoul2, cent->localAnimIndex);
+
+			//CG_CopyG2WeaponInstance(cent->currentState.weapon, ci->ghoul2Model);
+			//cent->weapon = cent->currentState.weapon;
+		}
+	}
+
+	//do this to prevent us from making a saber unholster sound the first time we enter the pvs
+	if (cent->currentState.number != cg.predictedPlayerState.clientNum &&
+		cent->currentState.weapon == WP_SABER &&
+		cent->weapon != cent->currentState.weapon)
+	{
+		cent->weapon = cent->currentState.weapon;
+		if (cent->ghoul2 && ci->ghoul2Model)
+		{
+			CG_CopyG2WeaponInstance(cent, cent->currentState.weapon, cent->ghoul2);
+			cent->ghoul2weapon = CG_G2WeaponInstance(cent, cent->currentState.weapon);
+		}
+		if (!cent->currentState.saberHolstered)
+		{ //if not holstered set length and desired length for both blades to full right now.
+			BG_SI_SetDesiredLength(&ci->saber[0], 0, -1);
+			BG_SI_SetDesiredLength(&ci->saber[1], 0, -1);
+
+			i = 0;
+			while (i < MAX_SABERS)
+			{
+				j = 0;
+				while (j < ci->saber[i].numBlades)
+				{
+					ci->saber[i].blade[j].length = ci->saber[i].blade[j].lengthMax;
+					j++;
+				}
+				i++;
+			}
+		}
+	}
+
+
+	if ( cg_debugPosition.integer ) {
+		CG_Printf("%i ResetPlayerEntity yaw=%i\n", cent->currentState.number, cent->pe.torso.yawAngle );
+	}
+}
+
diff --git a/codemp/cgame/cg_playerstate.c b/codemp/cgame/cg_playerstate.c
new file mode 100644
index 0000000..8733f12
--- /dev/null
+++ b/codemp/cgame/cg_playerstate.c
@@ -0,0 +1,535 @@
+// Copyright (C) 1999-2000 Id Software, Inc.
+//
+// cg_playerstate.c -- this file acts on changes in a new playerState_t
+// With normal play, this will be done after local prediction, but when
+// following another player or playing back a demo, it will be checked
+// when the snapshot transitions like all the other entities
+
+#include "cg_local.h"
+
+/*
+==============
+CG_CheckAmmo
+
+If the ammo has gone low enough to generate the warning, play a sound
+==============
+*/
+void CG_CheckAmmo( void ) {
+#if 0
+	int		i;
+	int		total;
+	int		previous;
+	int		weapons;
+
+	// see about how many seconds of ammo we have remaining
+	weapons = cg.snap->ps.stats[ STAT_WEAPONS ];
+	total = 0;
+	for ( i = WP_BRYAR_PISTOL; i < WP_NUM_WEAPONS ; i++ ) {
+		if ( ! ( weapons & ( 1 << i ) ) ) {
+			continue;
+		}
+		switch ( i ) 
+		{
+		case WP_BRYAR_PISTOL:
+		case WP_CONCUSSION:
+		case WP_BRYAR_OLD:
+		case WP_BLASTER:
+		case WP_DISRUPTOR:
+		case WP_BOWCASTER:
+		case WP_REPEATER:
+		case WP_DEMP2:
+		case WP_FLECHETTE:
+		case WP_ROCKET_LAUNCHER:
+		case WP_THERMAL:
+		case WP_TRIP_MINE:
+		case WP_DET_PACK:
+		case WP_EMPLACED_GUN:
+			total += cg.snap->ps.ammo[weaponData[i].ammoIndex] * 1000;
+			break;
+		default:
+			total += cg.snap->ps.ammo[weaponData[i].ammoIndex] * 200;
+			break;
+		}
+		if ( total >= 5000 ) {
+			cg.lowAmmoWarning = 0;
+			return;
+		}
+	}
+
+	previous = cg.lowAmmoWarning;
+
+	if ( total == 0 ) {
+		cg.lowAmmoWarning = 2;
+	} else {
+		cg.lowAmmoWarning = 1;
+	}
+
+	if (cg.snap->ps.weapon == WP_SABER)
+	{
+		cg.lowAmmoWarning = 0;
+	}
+
+	// play a sound on transitions
+	if ( cg.lowAmmoWarning != previous ) {
+		trap_S_StartLocalSound( cgs.media.noAmmoSound, CHAN_LOCAL_SOUND );
+	}
+#endif
+	//disabled silly ammo warning stuff for now
+}
+
+/*
+==============
+CG_DamageFeedback
+==============
+*/
+void CG_DamageFeedback( int yawByte, int pitchByte, int damage ) {
+	float		left, front, up;
+	float		kick;
+	int			health;
+	float		scale;
+	vec3_t		dir;
+	vec3_t		angles;
+	float		dist;
+	float		yaw, pitch;
+
+	// show the attacking player's head and name in corner
+	cg.attackerTime = cg.time;
+
+	// the lower on health you are, the greater the view kick will be
+	health = cg.snap->ps.stats[STAT_HEALTH];
+	if ( health < 40 ) {
+		scale = 1;
+	} else {
+		scale = 40.0 / health;
+	}
+	kick = damage * scale;
+
+	if (kick < 5)
+		kick = 5;
+	if (kick > 10)
+		kick = 10;
+
+	// if yaw and pitch are both 255, make the damage always centered (falling, etc)
+	if ( yawByte == 255 && pitchByte == 255 ) {
+		cg.damageX = 0;
+		cg.damageY = 0;
+		cg.v_dmg_roll = 0;
+		cg.v_dmg_pitch = -kick;
+	} else {
+		// positional
+		pitch = pitchByte / 255.0 * 360;
+		yaw = yawByte / 255.0 * 360;
+
+		angles[PITCH] = pitch;
+		angles[YAW] = yaw;
+		angles[ROLL] = 0;
+
+		AngleVectors( angles, dir, NULL, NULL );
+		VectorSubtract( vec3_origin, dir, dir );
+
+		front = DotProduct (dir, cg.refdef.viewaxis[0] );
+		left = DotProduct (dir, cg.refdef.viewaxis[1] );
+		up = DotProduct (dir, cg.refdef.viewaxis[2] );
+
+		dir[0] = front;
+		dir[1] = left;
+		dir[2] = 0;
+		dist = VectorLength( dir );
+		if ( dist < 0.1 ) {
+			dist = 0.1f;
+		}
+
+		cg.v_dmg_roll = kick * left;
+		
+		cg.v_dmg_pitch = -kick * front;
+
+		if ( front <= 0.1 ) {
+			front = 0.1f;
+		}
+		cg.damageX = -left / front;
+		cg.damageY = up / dist;
+	}
+
+	// clamp the position
+	if ( cg.damageX > 1.0 ) {
+		cg.damageX = 1.0;
+	}
+	if ( cg.damageX < - 1.0 ) {
+		cg.damageX = -1.0;
+	}
+
+	if ( cg.damageY > 1.0 ) {
+		cg.damageY = 1.0;
+	}
+	if ( cg.damageY < - 1.0 ) {
+		cg.damageY = -1.0;
+	}
+
+	// don't let the screen flashes vary as much
+	if ( kick > 10 ) {
+		kick = 10;
+	}
+	cg.damageValue = kick;
+	cg.v_dmg_time = cg.time + DAMAGE_TIME;
+	cg.damageTime = cg.snap->serverTime;
+
+//JLFRUMBLE
+#ifdef _XBOX
+extern void FF_XboxShake(float intensity, int duration);
+extern void FF_XboxDamage(int damage, float xpos);
+
+//FF_XboxShake(kick, 500);
+FF_XboxDamage(damage, -left);
+
+
+#endif
+
+}
+
+
+
+
+/*
+================
+CG_Respawn
+
+A respawn happened this snapshot
+================
+*/
+void CG_Respawn( void ) {
+	// no error decay on player movement
+	cg.thisFrameTeleport = qtrue;
+
+	// display weapons available
+	cg.weaponSelectTime = cg.time;
+
+	// select the weapon the server says we are using
+	cg.weaponSelect = cg.snap->ps.weapon;
+}
+
+extern char *eventnames[];
+
+/*
+==============
+CG_CheckPlayerstateEvents
+==============
+*/
+void CG_CheckPlayerstateEvents( playerState_t *ps, playerState_t *ops ) {
+	int			i;
+	int			event;
+	centity_t	*cent;
+
+	if ( ps->externalEvent && ps->externalEvent != ops->externalEvent ) {
+		cent = &cg_entities[ ps->clientNum ];
+		cent->currentState.event = ps->externalEvent;
+		cent->currentState.eventParm = ps->externalEventParm;
+		CG_EntityEvent( cent, cent->lerpOrigin );
+	}
+
+	cent = &cg_entities[ ps->clientNum ];
+	// go through the predictable events buffer
+	for ( i = ps->eventSequence - MAX_PS_EVENTS ; i < ps->eventSequence ; i++ ) {
+		// if we have a new predictable event
+		if ( i >= ops->eventSequence
+			// or the server told us to play another event instead of a predicted event we already issued
+			// or something the server told us changed our prediction causing a different event
+			|| (i > ops->eventSequence - MAX_PS_EVENTS && ps->events[i & (MAX_PS_EVENTS-1)] != ops->events[i & (MAX_PS_EVENTS-1)]) ) {
+
+			event = ps->events[ i & (MAX_PS_EVENTS-1) ];
+			cent->currentState.event = event;
+			cent->currentState.eventParm = ps->eventParms[ i & (MAX_PS_EVENTS-1) ];
+//JLF ADDED to hopefully mark events as player event
+			cent->playerState = ps;
+			CG_EntityEvent( cent, cent->lerpOrigin );
+
+			cg.predictableEvents[ i & (MAX_PREDICTED_EVENTS-1) ] = event;
+
+			cg.eventSequence++;
+		}
+	}
+}
+
+/*
+==================
+CG_CheckChangedPredictableEvents
+==================
+*/
+void CG_CheckChangedPredictableEvents( playerState_t *ps ) {
+	int i;
+	int event;
+	centity_t	*cent;
+
+	cent = &cg_entities[ps->clientNum];
+	for ( i = ps->eventSequence - MAX_PS_EVENTS ; i < ps->eventSequence ; i++ ) {
+		//
+		if (i >= cg.eventSequence) {
+			continue;
+		}
+		// if this event is not further back in than the maximum predictable events we remember
+		if (i > cg.eventSequence - MAX_PREDICTED_EVENTS) {
+			// if the new playerstate event is different from a previously predicted one
+			if ( ps->events[i & (MAX_PS_EVENTS-1)] != cg.predictableEvents[i & (MAX_PREDICTED_EVENTS-1) ] ) {
+
+				event = ps->events[ i & (MAX_PS_EVENTS-1) ];
+				cent->currentState.event = event;
+				cent->currentState.eventParm = ps->eventParms[ i & (MAX_PS_EVENTS-1) ];
+				CG_EntityEvent( cent, cent->lerpOrigin );
+
+				cg.predictableEvents[ i & (MAX_PREDICTED_EVENTS-1) ] = event;
+
+				if ( cg_showmiss.integer ) {
+					CG_Printf("WARNING: changed predicted event\n");
+				}
+			}
+		}
+	}
+}
+
+/*
+==================
+pushReward
+==================
+*/
+#ifdef JK2AWARDS
+static void pushReward(sfxHandle_t sfx, qhandle_t shader, int rewardCount) {
+	if (cg.rewardStack < (MAX_REWARDSTACK-1)) {
+		cg.rewardStack++;
+		cg.rewardSound[cg.rewardStack] = sfx;
+		cg.rewardShader[cg.rewardStack] = shader;
+		cg.rewardCount[cg.rewardStack] = rewardCount;
+	}
+}
+#endif
+
+int cgAnnouncerTime = 0; //to prevent announce sounds from playing on top of each other
+
+/*
+==================
+CG_CheckLocalSounds
+==================
+*/
+void CG_CheckLocalSounds( playerState_t *ps, playerState_t *ops ) {
+	int			highScore, health, armor, reward;
+#ifdef JK2AWARDS
+	sfxHandle_t sfx;
+#endif
+
+	// don't play the sounds if the player just changed teams
+	if ( ps->persistant[PERS_TEAM] != ops->persistant[PERS_TEAM] ) {
+		return;
+	}
+
+	// hit changes
+	if ( ps->persistant[PERS_HITS] > ops->persistant[PERS_HITS] ) {
+		armor  = ps->persistant[PERS_ATTACKEE_ARMOR] & 0xff;
+		health = ps->persistant[PERS_ATTACKEE_ARMOR] >> 8;
+
+		if (armor > health/2)
+		{	// We also hit shields along the way, so consider them "pierced".
+//			trap_S_StartLocalSound( cgs.media.shieldPierceSound, CHAN_LOCAL_SOUND );
+		}
+		else
+		{	// Shields didn't really stand in our way.
+//			trap_S_StartLocalSound( cgs.media.hitSound, CHAN_LOCAL_SOUND );
+		}
+
+		//FIXME: Hit sounds?
+		/*
+		if (armor > 50 ) {
+			trap_S_StartLocalSound( cgs.media.hitSoundHighArmor, CHAN_LOCAL_SOUND );
+		} else if (armor || health > 100) {
+			trap_S_StartLocalSound( cgs.media.hitSoundLowArmor, CHAN_LOCAL_SOUND );
+		} else {
+			trap_S_StartLocalSound( cgs.media.hitSound, CHAN_LOCAL_SOUND );
+		}
+		*/
+	} else if ( ps->persistant[PERS_HITS] < ops->persistant[PERS_HITS] ) {
+		//trap_S_StartLocalSound( cgs.media.hitTeamSound, CHAN_LOCAL_SOUND );
+	}
+
+	// health changes of more than -3 should make pain sounds
+	if (cg_oldPainSounds.integer)
+	{
+		if ( ps->stats[STAT_HEALTH] < (ops->stats[STAT_HEALTH] - 3))
+		{
+			if ( ps->stats[STAT_HEALTH] > 0 )
+			{
+				CG_PainEvent( &cg_entities[cg.predictedPlayerState.clientNum], ps->stats[STAT_HEALTH] );
+			}
+		}
+	}
+
+	// if we are going into the intermission, don't start any voices
+	if ( cg.intermissionStarted ) {
+		return;
+	}
+
+#ifdef JK2AWARDS
+	// reward sounds
+	reward = qfalse;
+	if (ps->persistant[PERS_CAPTURES] != ops->persistant[PERS_CAPTURES]) {
+		pushReward(cgs.media.captureAwardSound, cgs.media.medalCapture, ps->persistant[PERS_CAPTURES]);
+		reward = qtrue;
+		//Com_Printf("capture\n");
+	}
+	if (ps->persistant[PERS_IMPRESSIVE_COUNT] != ops->persistant[PERS_IMPRESSIVE_COUNT]) {
+		sfx = cgs.media.impressiveSound;
+
+		pushReward(sfx, cgs.media.medalImpressive, ps->persistant[PERS_IMPRESSIVE_COUNT]);
+		reward = qtrue;
+		//Com_Printf("impressive\n");
+	}
+	if (ps->persistant[PERS_EXCELLENT_COUNT] != ops->persistant[PERS_EXCELLENT_COUNT]) {
+		sfx = cgs.media.excellentSound;
+		pushReward(sfx, cgs.media.medalExcellent, ps->persistant[PERS_EXCELLENT_COUNT]);
+		reward = qtrue;
+		//Com_Printf("excellent\n");
+	}
+	if (ps->persistant[PERS_GAUNTLET_FRAG_COUNT] != ops->persistant[PERS_GAUNTLET_FRAG_COUNT]) {
+		sfx = cgs.media.humiliationSound;
+		pushReward(sfx, cgs.media.medalGauntlet, ps->persistant[PERS_GAUNTLET_FRAG_COUNT]);
+		reward = qtrue;
+		//Com_Printf("guantlet frag\n");
+	}
+	if (ps->persistant[PERS_DEFEND_COUNT] != ops->persistant[PERS_DEFEND_COUNT]) {
+		pushReward(cgs.media.defendSound, cgs.media.medalDefend, ps->persistant[PERS_DEFEND_COUNT]);
+		reward = qtrue;
+		//Com_Printf("defend\n");
+	}
+	if (ps->persistant[PERS_ASSIST_COUNT] != ops->persistant[PERS_ASSIST_COUNT]) {
+		//pushReward(cgs.media.assistSound, cgs.media.medalAssist, ps->persistant[PERS_ASSIST_COUNT]);
+		//reward = qtrue;
+		//Com_Printf("assist\n");
+	}
+	// if any of the player event bits changed
+	if (ps->persistant[PERS_PLAYEREVENTS] != ops->persistant[PERS_PLAYEREVENTS]) {
+		if ((ps->persistant[PERS_PLAYEREVENTS] & PLAYEREVENT_DENIEDREWARD) !=
+				(ops->persistant[PERS_PLAYEREVENTS] & PLAYEREVENT_DENIEDREWARD)) {
+			trap_S_StartLocalSound( cgs.media.deniedSound, CHAN_ANNOUNCER );
+		}
+		else if ((ps->persistant[PERS_PLAYEREVENTS] & PLAYEREVENT_GAUNTLETREWARD) !=
+				(ops->persistant[PERS_PLAYEREVENTS] & PLAYEREVENT_GAUNTLETREWARD)) {
+			trap_S_StartLocalSound( cgs.media.humiliationSound, CHAN_ANNOUNCER );
+		}
+		reward = qtrue;
+	}
+#else
+	reward = qfalse;
+#endif
+	// lead changes
+	if (!reward && cgAnnouncerTime < cg.time) {
+		//
+		if ( !cg.warmup && cgs.gametype != GT_POWERDUEL ) {
+			// never play lead changes during warmup and powerduel
+			if ( ps->persistant[PERS_RANK] != ops->persistant[PERS_RANK] ) {
+				if ( cgs.gametype < GT_TEAM) {
+					/*
+					if (  ps->persistant[PERS_RANK] == 0 ) {
+						CG_AddBufferedSound(cgs.media.takenLeadSound);
+						cgAnnouncerTime = cg.time + 3000;
+					} else if ( ps->persistant[PERS_RANK] == RANK_TIED_FLAG ) {
+						//CG_AddBufferedSound(cgs.media.tiedLeadSound);
+					} else if ( ( ops->persistant[PERS_RANK] & ~RANK_TIED_FLAG ) == 0 ) {
+						//rww - only bother saying this if you have more than 1 kill already.
+						//joining the server and hearing "the force is not with you" is silly.
+						if (ps->persistant[PERS_SCORE] > 0)
+						{
+							CG_AddBufferedSound(cgs.media.lostLeadSound);
+							cgAnnouncerTime = cg.time + 3000;
+						}
+					}
+					*/
+				}
+			}
+		}
+	}
+
+	// timelimit warnings
+	if ( cgs.timelimit > 0 && cgAnnouncerTime < cg.time ) {
+		int		msec;
+
+		msec = cg.time - cgs.levelStartTime;
+		if ( !( cg.timelimitWarnings & 4 ) && msec > ( cgs.timelimit * 60 + 2 ) * 1000 ) {
+			cg.timelimitWarnings |= 1 | 2 | 4;
+			//trap_S_StartLocalSound( cgs.media.suddenDeathSound, CHAN_ANNOUNCER );
+		}
+		else if ( !( cg.timelimitWarnings & 2 ) && msec > (cgs.timelimit - 1) * 60 * 1000 ) {
+			cg.timelimitWarnings |= 1 | 2;
+			trap_S_StartLocalSound( cgs.media.oneMinuteSound, CHAN_ANNOUNCER );
+			cgAnnouncerTime = cg.time + 3000;
+		}
+		else if ( cgs.timelimit > 5 && !( cg.timelimitWarnings & 1 ) && msec > (cgs.timelimit - 5) * 60 * 1000 ) {
+			cg.timelimitWarnings |= 1;
+			trap_S_StartLocalSound( cgs.media.fiveMinuteSound, CHAN_ANNOUNCER );
+			cgAnnouncerTime = cg.time + 3000;
+		}
+	}
+
+	// fraglimit warnings
+	if ( cgs.fraglimit > 0 && cgs.gametype < GT_CTF && cgs.gametype != GT_DUEL && cgs.gametype != GT_POWERDUEL && cgs.gametype != GT_SIEGE && cgAnnouncerTime < cg.time) {
+		highScore = cgs.scores1;
+		if ( !( cg.fraglimitWarnings & 4 ) && highScore == (cgs.fraglimit - 1) ) {
+			cg.fraglimitWarnings |= 1 | 2 | 4;
+			CG_AddBufferedSound(cgs.media.oneFragSound);
+			cgAnnouncerTime = cg.time + 3000;
+		}
+		else if ( cgs.fraglimit > 2 && !( cg.fraglimitWarnings & 2 ) && highScore == (cgs.fraglimit - 2) ) {
+			cg.fraglimitWarnings |= 1 | 2;
+			CG_AddBufferedSound(cgs.media.twoFragSound);
+			cgAnnouncerTime = cg.time + 3000;
+		}
+		else if ( cgs.fraglimit > 3 && !( cg.fraglimitWarnings & 1 ) && highScore == (cgs.fraglimit - 3) ) {
+			cg.fraglimitWarnings |= 1;
+			CG_AddBufferedSound(cgs.media.threeFragSound);
+			cgAnnouncerTime = cg.time + 3000;
+		}
+	}
+}
+
+/*
+===============
+CG_TransitionPlayerState
+
+===============
+*/
+void CG_TransitionPlayerState( playerState_t *ps, playerState_t *ops ) {
+	// check for changing follow mode
+	if ( ps->clientNum != ops->clientNum ) {
+		cg.thisFrameTeleport = qtrue;
+		// make sure we don't get any unwanted transition effects
+		*ops = *ps;
+	}
+
+	// damage events (player is getting wounded)
+	if ( ps->damageEvent != ops->damageEvent && ps->damageCount ) {
+		CG_DamageFeedback( ps->damageYaw, ps->damagePitch, ps->damageCount );
+	}
+
+	// respawning
+	if ( ps->persistant[PERS_SPAWN_COUNT] != ops->persistant[PERS_SPAWN_COUNT] ) {
+		CG_Respawn();
+	}
+
+	if ( cg.mapRestart ) {
+		CG_Respawn();
+		cg.mapRestart = qfalse;
+	}
+
+	if ( cg.snap->ps.pm_type != PM_INTERMISSION 
+		&& ps->persistant[PERS_TEAM] != TEAM_SPECTATOR ) {
+		CG_CheckLocalSounds( ps, ops );
+	}
+
+	// check for going low on ammo
+	CG_CheckAmmo();
+
+	// run events
+	CG_CheckPlayerstateEvents( ps, ops );
+
+	// smooth the ducking viewheight change
+	if ( ps->viewheight != ops->viewheight ) {
+		cg.duckChange = ps->viewheight - ops->viewheight;
+		cg.duckTime = cg.time;
+	}
+}
+
diff --git a/codemp/cgame/cg_predict.c b/codemp/cgame/cg_predict.c
new file mode 100644
index 0000000..3fca6cd
--- /dev/null
+++ b/codemp/cgame/cg_predict.c
@@ -0,0 +1,1512 @@
+// Copyright (C) 1999-2000 Id Software, Inc.
+//
+// cg_predict.c -- this file generates cg.predictedPlayerState by either
+// interpolating between snapshots from the server or locally predicting
+// ahead the client's movement.
+// It also handles local physics interaction, like fragments bouncing off walls
+
+#include "cg_local.h"
+
+static	pmove_t		cg_pmove;
+
+static	int			cg_numSolidEntities;
+static	centity_t	*cg_solidEntities[MAX_ENTITIES_IN_SNAPSHOT];
+static	int			cg_numTriggerEntities;
+static	centity_t	*cg_triggerEntities[MAX_ENTITIES_IN_SNAPSHOT];
+
+//is this client piloting this veh?
+static CGAME_INLINE qboolean CG_Piloting(int vehNum)
+{
+	centity_t *veh;
+
+	if (!vehNum)
+	{
+		return qfalse;
+	}
+
+	veh = &cg_entities[vehNum];
+
+	if (veh->currentState.owner != cg.predictedPlayerState.clientNum)
+	{ //the owner should be the current pilot
+		return qfalse;
+	}
+
+	return qtrue;
+}
+
+/*
+====================
+CG_BuildSolidList
+
+When a new cg.snap has been set, this function builds a sublist
+of the entities that are actually solid, to make for more
+efficient collision detection
+====================
+*/
+void CG_BuildSolidList( void ) {
+	int				i;
+	centity_t		*cent;
+	snapshot_t		*snap;
+	entityState_t	*ent;
+	vec3_t			difference;
+	float			dsquared;
+
+	cg_numSolidEntities = 0;
+	cg_numTriggerEntities = 0;
+
+	if ( cg.nextSnap && !cg.nextFrameTeleport && !cg.thisFrameTeleport ) {
+		snap = cg.nextSnap;
+	} else {
+		snap = cg.snap;
+	}
+
+	for ( i = 0 ; i < snap->numEntities ; i++ ) {
+		cent = &cg_entities[ snap->entities[ i ].number ];
+		ent = &cent->currentState;
+
+		if ( ent->eType == ET_ITEM || ent->eType == ET_PUSH_TRIGGER || ent->eType == ET_TELEPORT_TRIGGER ) {
+			cg_triggerEntities[cg_numTriggerEntities] = cent;
+			cg_numTriggerEntities++;
+			continue;
+		}
+
+		if ( cent->nextState.solid ) {
+			cg_solidEntities[cg_numSolidEntities] = cent;
+			cg_numSolidEntities++;
+			continue;
+		}
+	}
+
+	//rww - Horrible, terrible, awful hack.
+	//We don't send your client entity from the server,
+	//so it isn't added into the solid list from the snapshot,
+	//and in addition, it has no solid data. So we will force
+	//adding it in based on a hardcoded player bbox size.
+	//This will cause issues if the player box size is ever
+	//changed..
+	if (cg_numSolidEntities < MAX_ENTITIES_IN_SNAPSHOT)
+	{
+		vec3_t	playerMins = {-15, -15, DEFAULT_MINS_2};
+		vec3_t	playerMaxs = {15, 15, DEFAULT_MAXS_2};
+		int i, j, k;
+
+		i = playerMaxs[0];
+		if (i<1)
+			i = 1;
+		if (i>255)
+			i = 255;
+
+		// z is not symetric
+		j = (-playerMins[2]);
+		if (j<1)
+			j = 1;
+		if (j>255)
+			j = 255;
+
+		// and z playerMaxs can be negative...
+		k = (playerMaxs[2]+32);
+		if (k<1)
+			k = 1;
+		if (k>255)
+			k = 255;
+
+		cg_solidEntities[cg_numSolidEntities] = &cg_entities[cg.predictedPlayerState.clientNum];
+		cg_solidEntities[cg_numSolidEntities]->currentState.solid = (k<<16) | (j<<8) | i;
+
+		cg_numSolidEntities++;
+	}
+
+	dsquared = /*RMG_distancecull.value*/5000+500;
+	dsquared *= dsquared;
+
+	for(i=0;i<cg_numpermanents;i++)
+	{
+		cent = cg_permanents[i];
+		VectorSubtract(cent->lerpOrigin, snap->ps.origin, difference);
+		if (cent->currentState.eType == ET_TERRAIN ||
+			((difference[0]*difference[0]) + (difference[1]*difference[1]) + (difference[2]*difference[2])) <= dsquared)
+		{
+			cent->currentValid = qtrue;
+			if ( cent->nextState.solid ) 
+			{
+				cg_solidEntities[cg_numSolidEntities] = cent;
+				cg_numSolidEntities++;
+			}
+		}
+		else
+		{
+			cent->currentValid = qfalse;
+		}
+	}
+}
+
+static CGAME_INLINE qboolean CG_VehicleClipCheck(centity_t *ignored, trace_t *trace)
+{
+	if (!trace || trace->entityNum < 0 || trace->entityNum >= ENTITYNUM_WORLD)
+	{ //it's alright then
+		return qtrue;
+	}
+
+	if (ignored->currentState.eType != ET_PLAYER &&
+		ignored->currentState.eType != ET_NPC)
+	{ //can't possibly be valid then
+		return qtrue;
+	}
+
+	if (ignored->currentState.m_iVehicleNum)
+	{ //see if the ignore ent is a vehicle/rider - if so, see if the ent we supposedly hit is a vehicle/rider.
+		//if they belong to each other, we don't want to collide them.
+		centity_t *otherguy = &cg_entities[trace->entityNum];
+
+		if (otherguy->currentState.eType != ET_PLAYER &&
+			otherguy->currentState.eType != ET_NPC)
+		{ //can't possibly be valid then
+			return qtrue;
+		}
+
+		if (otherguy->currentState.m_iVehicleNum)
+		{ //alright, both of these are either a vehicle or a player who is on a vehicle
+			int index;
+
+			if (ignored->currentState.eType == ET_PLAYER
+				|| (ignored->currentState.eType == ET_NPC && ignored->currentState.NPC_class != CLASS_VEHICLE) )
+			{ //must be a player or NPC riding a vehicle
+				index = ignored->currentState.m_iVehicleNum;
+			}
+			else
+			{ //a vehicle
+				index = ignored->currentState.m_iVehicleNum-1;
+			}
+
+			if (index == otherguy->currentState.number)
+			{ //this means we're riding or being ridden by this guy, so don't collide
+				return qfalse;
+			}
+			else 
+			{//see if I'm hitting one of my own passengers
+				if (otherguy->currentState.eType == ET_PLAYER
+					|| (otherguy->currentState.eType == ET_NPC && otherguy->currentState.NPC_class != CLASS_VEHICLE) )
+				{ //must be a player or NPC riding a vehicle
+					if (otherguy->currentState.m_iVehicleNum==ignored->currentState.number)
+					{ //this means we're other guy is riding the ignored ent
+						return qfalse;
+					}
+				}
+			}
+		}
+	}
+
+	return qtrue;
+}
+
+//rww - I'm disabling this warning for this function. It complains about oldTrace but as you can see it
+//always gets set before use, and I am not wasting CPU memsetting it to shut the compiler up.
+#pragma warning(disable : 4701) //local variable may be used without having been initialized
+/*
+====================
+CG_ClipMoveToEntities
+
+====================
+*/
+#include "../namespace_begin.h"
+extern void BG_VehicleAdjustBBoxForOrientation( Vehicle_t *veh, vec3_t origin, vec3_t mins, vec3_t maxs,
+										int clientNum, int tracemask,
+										void (*localTrace)(trace_t *results, const vec3_t start, const vec3_t mins, const vec3_t maxs, const vec3_t end, int passEntityNum, int contentMask)); // bg_pmove.c
+#include "../namespace_end.h"
+static void CG_ClipMoveToEntities ( const vec3_t start, const vec3_t mins, const vec3_t maxs, const vec3_t end,
+							int skipNumber, int mask, trace_t *tr, qboolean g2Check ) {
+	int			i, x, zd, zu;
+	trace_t		trace, oldTrace;
+	entityState_t	*ent;
+	clipHandle_t 	cmodel;
+	vec3_t		bmins, bmaxs;
+	vec3_t		origin, angles;
+	centity_t	*cent;
+	centity_t	*ignored = NULL;
+
+	if (skipNumber != -1 && skipNumber != ENTITYNUM_NONE)
+	{
+		ignored = &cg_entities[skipNumber];
+	}
+
+	for ( i = 0 ; i < cg_numSolidEntities ; i++ ) {
+		cent = cg_solidEntities[ i ];
+		ent = &cent->currentState;
+
+		if ( ent->number == skipNumber ) {
+			continue;
+		}
+
+		if ( ent->number > MAX_CLIENTS && 
+			 (ent->genericenemyindex-MAX_GENTITIES==cg.predictedPlayerState.clientNum || ent->genericenemyindex-MAX_GENTITIES==cg.predictedVehicleState.clientNum) )
+//		if (ent->number > MAX_CLIENTS && cg.snap && ent->genericenemyindex && (ent->genericenemyindex-MAX_GENTITIES) == cg.snap->ps.clientNum)
+		{ //rww - method of keeping objects from colliding in client-prediction (in case of ownership)
+			continue;
+		}
+
+		if ( ent->solid == SOLID_BMODEL ) {
+			// special value for bmodel
+			cmodel = trap_CM_InlineModel( ent->modelindex );
+			VectorCopy( cent->lerpAngles, angles );
+			BG_EvaluateTrajectory( &cent->currentState.pos, cg.physicsTime, origin );
+		} else {
+			// encoded bbox
+			x = (ent->solid & 255);
+			zd = ((ent->solid>>8) & 255);
+			zu = ((ent->solid>>16) & 255) - 32;
+
+			bmins[0] = bmins[1] = -x;
+			bmaxs[0] = bmaxs[1] = x;
+			bmins[2] = -zd;
+			bmaxs[2] = zu;
+
+			if (ent->eType == ET_NPC && ent->NPC_class == CLASS_VEHICLE &&
+				cent->m_pVehicle)
+			{ //try to dynamically adjust his bbox dynamically, if possible
+				float *old = cent->m_pVehicle->m_vOrientation;
+				cent->m_pVehicle->m_vOrientation = &cent->lerpAngles[0];
+				BG_VehicleAdjustBBoxForOrientation(cent->m_pVehicle, cent->lerpOrigin, bmins, bmaxs,
+											cent->currentState.number, MASK_PLAYERSOLID, NULL);
+				cent->m_pVehicle->m_vOrientation = old;
+			}
+
+			cmodel = trap_CM_TempBoxModel( bmins, bmaxs );
+			VectorCopy( vec3_origin, angles );
+			
+			VectorCopy( cent->lerpOrigin, origin );
+		}
+
+
+		trap_CM_TransformedBoxTrace ( &trace, start, end,
+			mins, maxs, cmodel,  mask, origin, angles);
+		trace.entityNum = trace.fraction != 1.0 ? ent->number : ENTITYNUM_NONE;
+
+		if (g2Check || (ignored && ignored->currentState.m_iVehicleNum))
+		{
+			//keep these older variables around for a bit, incase we need to replace them in the Ghoul2 Collision check
+			//or in the vehicle owner trace check
+			oldTrace = *tr;
+		}
+
+		if (trace.allsolid || trace.fraction < tr->fraction) {
+			trace.entityNum = ent->number;
+			*tr = trace;
+		} else if (trace.startsolid) {
+			tr->startsolid = qtrue;
+
+			//rww 12-02-02
+			tr->entityNum = trace.entityNum = ent->number;
+		}
+		if ( tr->allsolid )
+		{
+			if (ignored && ignored->currentState.m_iVehicleNum)
+			{
+				trace.entityNum = ent->number;
+                if (CG_VehicleClipCheck(ignored, &trace))
+				{ //this isn't our vehicle, we're really stuck
+					return;
+				}
+				else
+				{ //it's alright, keep going
+					trace = oldTrace;
+					*tr = trace;
+				}
+			}
+			else
+			{
+				return;
+			}
+		}
+
+		if (g2Check)
+		{
+			if (trace.entityNum == ent->number && cent->ghoul2)
+			{
+				CG_G2TraceCollide(&trace, mins, maxs, start, end);
+
+				if (trace.entityNum == ENTITYNUM_NONE)
+				{ //g2 trace failed, so put it back where it was.
+					trace = oldTrace;
+					*tr = trace;
+				}
+			}
+		}
+
+		if (ignored && ignored->currentState.m_iVehicleNum)
+		{ //see if this is the vehicle we hit
+			centity_t *hit = &cg_entities[trace.entityNum];
+            if (!CG_VehicleClipCheck(ignored, &trace))
+			{ //looks like it
+				trace = oldTrace;
+				*tr = trace;
+			}
+			else if (hit->currentState.eType == ET_MISSILE &&
+				hit->currentState.owner == ignored->currentState.number)
+			{ //hack, don't hit own missiles
+				trace = oldTrace;
+				*tr = trace;
+			}
+		}
+	}
+}
+#pragma warning(default : 4701) //local variable may be used without having been initialized
+
+/*
+================
+CG_Trace
+================
+*/
+void	CG_Trace( trace_t *result, const vec3_t start, const vec3_t mins, const vec3_t maxs, const vec3_t end, 
+					 int skipNumber, int mask ) {
+	trace_t	t;
+
+	trap_CM_BoxTrace ( &t, start, end, mins, maxs, 0, mask);
+	t.entityNum = t.fraction != 1.0 ? ENTITYNUM_WORLD : ENTITYNUM_NONE;
+	// check all other solid models
+	CG_ClipMoveToEntities (start, mins, maxs, end, skipNumber, mask, &t, qfalse);
+
+	*result = t;
+}
+
+/*
+================
+CG_G2Trace
+================
+*/
+void	CG_G2Trace( trace_t *result, const vec3_t start, const vec3_t mins, const vec3_t maxs, const vec3_t end, 
+					 int skipNumber, int mask ) {
+	trace_t	t;
+
+	trap_CM_BoxTrace ( &t, start, end, mins, maxs, 0, mask);
+	t.entityNum = t.fraction != 1.0 ? ENTITYNUM_WORLD : ENTITYNUM_NONE;
+	// check all other solid models
+	CG_ClipMoveToEntities (start, mins, maxs, end, skipNumber, mask, &t, qtrue);
+
+	*result = t;
+}
+
+/*
+================
+CG_PointContents
+================
+*/
+int		CG_PointContents( const vec3_t point, int passEntityNum ) {
+	int			i;
+	entityState_t	*ent;
+	centity_t	*cent;
+	clipHandle_t cmodel;
+	int			contents;
+
+	contents = trap_CM_PointContents (point, 0);
+
+	for ( i = 0 ; i < cg_numSolidEntities ; i++ ) {
+		cent = cg_solidEntities[ i ];
+
+		ent = &cent->currentState;
+
+		if ( ent->number == passEntityNum ) {
+			continue;
+		}
+
+		if (ent->solid != SOLID_BMODEL) { // special value for bmodel
+			continue;
+		}
+
+		cmodel = trap_CM_InlineModel( ent->modelindex );
+		if ( !cmodel ) {
+			continue;
+		}
+
+		contents |= trap_CM_TransformedPointContents( point, cmodel, ent->origin, ent->angles );
+	}
+
+	return contents;
+}
+
+
+/*
+========================
+CG_InterpolatePlayerState
+
+Generates cg.predictedPlayerState by interpolating between
+cg.snap->player_state and cg.nextFrame->player_state
+========================
+*/
+static void CG_InterpolatePlayerState( qboolean grabAngles ) {
+	float			f;
+	int				i;
+	playerState_t	*out;
+	snapshot_t		*prev, *next;
+
+	out = &cg.predictedPlayerState;
+	prev = cg.snap;
+	next = cg.nextSnap;
+
+	*out = cg.snap->ps;
+
+	// if we are still allowing local input, short circuit the view angles
+	if ( grabAngles ) {
+		usercmd_t	cmd;
+		int			cmdNum;
+
+		cmdNum = trap_GetCurrentCmdNumber();
+		trap_GetUserCmd( cmdNum, &cmd );
+
+		PM_UpdateViewAngles( out, &cmd );
+	}
+
+	// if the next frame is a teleport, we can't lerp to it
+	if ( cg.nextFrameTeleport ) {
+		return;
+	}
+
+	if ( !next || next->serverTime <= prev->serverTime ) {
+		return;
+	}
+
+	f = (float)( cg.time - prev->serverTime ) / ( next->serverTime - prev->serverTime );
+
+	i = next->ps.bobCycle;
+	if ( i < prev->ps.bobCycle ) {
+		i += 256;		// handle wraparound
+	}
+	out->bobCycle = prev->ps.bobCycle + f * ( i - prev->ps.bobCycle );
+
+	for ( i = 0 ; i < 3 ; i++ ) {
+		out->origin[i] = prev->ps.origin[i] + f * (next->ps.origin[i] - prev->ps.origin[i] );
+		if ( !grabAngles ) {
+			out->viewangles[i] = LerpAngle( 
+				prev->ps.viewangles[i], next->ps.viewangles[i], f );
+		}
+		out->velocity[i] = prev->ps.velocity[i] + 
+			f * (next->ps.velocity[i] - prev->ps.velocity[i] );
+	}
+
+}
+
+static void CG_InterpolateVehiclePlayerState( qboolean grabAngles ) {
+	float			f;
+	int				i;
+	playerState_t	*out;
+	snapshot_t		*prev, *next;
+
+	out = &cg.predictedVehicleState;
+	prev = cg.snap;
+	next = cg.nextSnap;
+
+	*out = cg.snap->vps;
+
+	// if we are still allowing local input, short circuit the view angles
+	if ( grabAngles ) {
+		usercmd_t	cmd;
+		int			cmdNum;
+
+		cmdNum = trap_GetCurrentCmdNumber();
+		trap_GetUserCmd( cmdNum, &cmd );
+
+		PM_UpdateViewAngles( out, &cmd );
+	}
+
+	// if the next frame is a teleport, we can't lerp to it
+	if ( cg.nextFrameTeleport ) {
+		return;
+	}
+
+	if ( !next || next->serverTime <= prev->serverTime ) {
+		return;
+	}
+
+	f = (float)( cg.time - prev->serverTime ) / ( next->serverTime - prev->serverTime );
+
+	i = next->vps.bobCycle;
+	if ( i < prev->vps.bobCycle ) {
+		i += 256;		// handle wraparound
+	}
+	out->bobCycle = prev->vps.bobCycle + f * ( i - prev->vps.bobCycle );
+
+	for ( i = 0 ; i < 3 ; i++ ) {
+		out->origin[i] = prev->vps.origin[i] + f * (next->vps.origin[i] - prev->vps.origin[i] );
+		if ( !grabAngles ) {
+			out->viewangles[i] = LerpAngle( 
+				prev->vps.viewangles[i], next->vps.viewangles[i], f );
+		}
+		out->velocity[i] = prev->vps.velocity[i] + 
+			f * (next->vps.velocity[i] - prev->vps.velocity[i] );
+	}
+
+}
+
+/*
+===================
+CG_TouchItem
+===================
+*/
+static void CG_TouchItem( centity_t *cent ) {
+	gitem_t		*item;
+
+	if ( !cg_predictItems.integer ) {
+		return;
+	}
+	if ( !BG_PlayerTouchesItem( &cg.predictedPlayerState, &cent->currentState, cg.time ) ) {
+		return;
+	}
+
+	if (cent->currentState.brokenLimbs)
+	{ //dropped item
+		return;
+	}
+
+	if (cent->currentState.eFlags & EF_ITEMPLACEHOLDER)
+	{
+		return;
+	}
+
+	if (cent->currentState.eFlags & EF_NODRAW)
+	{
+		return;
+	}
+
+	// never pick an item up twice in a prediction
+	if ( cent->miscTime == cg.time ) {
+		return;
+	}
+
+	if ( !BG_CanItemBeGrabbed( cgs.gametype, &cent->currentState, &cg.predictedPlayerState ) ) {
+		return;		// can't hold it
+	}
+
+	item = &bg_itemlist[ cent->currentState.modelindex ];
+
+	//Currently there is no reliable way of knowing if the client has touched a certain item before another if they are next to each other, or rather
+	//if the server has touched them in the same order. This results often in grabbing an item in the prediction and the server giving you the other
+	//item. So for now prediction of armor, health, and ammo is disabled.
+/*
+	if (item->giType == IT_ARMOR)
+	{ //rww - this will be stomped next update, but it's set so that we don't try to pick up two shields in one prediction and have the server cancel one
+	//	cg.predictedPlayerState.stats[STAT_ARMOR] += item->quantity;
+
+		//FIXME: This can't be predicted properly at the moment
+		return;
+	}
+
+	if (item->giType == IT_HEALTH)
+	{ //same as above, for health
+	//	cg.predictedPlayerState.stats[STAT_HEALTH] += item->quantity;
+
+		//FIXME: This can't be predicted properly at the moment
+		return;
+	}
+
+	if (item->giType == IT_AMMO)
+	{ //same as above, for ammo
+	//	cg.predictedPlayerState.ammo[item->giTag] += item->quantity;
+
+		//FIXME: This can't be predicted properly at the moment
+		return;
+	}
+
+	if (item->giType == IT_HOLDABLE)
+	{ //same as above, for holdables
+	//	cg.predictedPlayerState.stats[STAT_HOLDABLE_ITEMS] |= (1 << item->giTag);
+	}
+*/
+	// Special case for flags.  
+	// We don't predict touching our own flag
+	if( cgs.gametype == GT_CTF || cgs.gametype == GT_CTY ) {
+		if (cg.predictedPlayerState.persistant[PERS_TEAM] == TEAM_RED &&
+			item->giTag == PW_REDFLAG)
+			return;
+		if (cg.predictedPlayerState.persistant[PERS_TEAM] == TEAM_BLUE &&
+			item->giTag == PW_BLUEFLAG)
+			return;
+	}
+
+	if (item->giType == IT_POWERUP &&
+		(item->giTag == PW_FORCE_ENLIGHTENED_LIGHT || item->giTag == PW_FORCE_ENLIGHTENED_DARK))
+	{
+		if (item->giTag == PW_FORCE_ENLIGHTENED_LIGHT)
+		{
+			if (cg.predictedPlayerState.fd.forceSide != FORCE_LIGHTSIDE)
+			{
+				return;
+			}
+		}
+		else
+		{
+			if (cg.predictedPlayerState.fd.forceSide != FORCE_DARKSIDE)
+			{
+				return;
+			}
+		}
+	}
+
+
+	// grab it
+	BG_AddPredictableEventToPlayerstate( EV_ITEM_PICKUP, cent->currentState.number , &cg.predictedPlayerState);
+
+	// remove it from the frame so it won't be drawn
+	cent->currentState.eFlags |= EF_NODRAW;
+
+	// don't touch it again this prediction
+	cent->miscTime = cg.time;
+
+	// if its a weapon, give them some predicted ammo so the autoswitch will work
+	if ( item->giType == IT_WEAPON ) {
+		cg.predictedPlayerState.stats[ STAT_WEAPONS ] |= 1 << item->giTag;
+		if ( !cg.predictedPlayerState.ammo[ item->giTag ] ) {
+			cg.predictedPlayerState.ammo[ item->giTag ] = 1;
+		}
+	}
+}
+
+
+/*
+=========================
+CG_TouchTriggerPrediction
+
+Predict push triggers and items
+=========================
+*/
+static void CG_TouchTriggerPrediction( void ) {
+	int			i;
+	trace_t		trace;
+	entityState_t	*ent;
+	clipHandle_t cmodel;
+	centity_t	*cent;
+	qboolean	spectator;
+
+	// dead clients don't activate triggers
+	if ( cg.predictedPlayerState.stats[STAT_HEALTH] <= 0 ) {
+		return;
+	}
+
+	spectator = ( cg.predictedPlayerState.pm_type == PM_SPECTATOR );
+
+	if ( cg.predictedPlayerState.pm_type != PM_NORMAL && cg.predictedPlayerState.pm_type != PM_JETPACK && cg.predictedPlayerState.pm_type != PM_FLOAT && !spectator ) {
+		return;
+	}
+
+	for ( i = 0 ; i < cg_numTriggerEntities ; i++ ) {
+		cent = cg_triggerEntities[ i ];
+		ent = &cent->currentState;
+
+		if ( ent->eType == ET_ITEM && !spectator ) {
+			CG_TouchItem( cent );
+			continue;
+		}
+
+		if ( ent->solid != SOLID_BMODEL ) {
+			continue;
+		}
+
+		cmodel = trap_CM_InlineModel( ent->modelindex );
+		if ( !cmodel ) {
+			continue;
+		}
+
+		trap_CM_BoxTrace( &trace, cg.predictedPlayerState.origin, cg.predictedPlayerState.origin, 
+			cg_pmove.mins, cg_pmove.maxs, cmodel, -1 );
+
+		if ( !trace.startsolid ) {
+			continue;
+		}
+
+		if ( ent->eType == ET_TELEPORT_TRIGGER ) {
+			cg.hyperspace = qtrue;
+		} else if ( ent->eType == ET_PUSH_TRIGGER ) {
+			BG_TouchJumpPad( &cg.predictedPlayerState, ent );
+		}
+	}
+
+	// if we didn't touch a jump pad this pmove frame
+	if ( cg.predictedPlayerState.jumppad_frame != cg.predictedPlayerState.pmove_framecount ) {
+		cg.predictedPlayerState.jumppad_frame = 0;
+		cg.predictedPlayerState.jumppad_ent = 0;
+	}
+}
+
+#if 0
+static ID_INLINE void CG_EntityStateToPlayerState( entityState_t *s, playerState_t *ps )
+{
+	//currently unused vars commented out for speed.. only uncomment if you need them.
+	ps->clientNum = s->number;
+	VectorCopy( s->pos.trBase, ps->origin );
+	VectorCopy( s->pos.trDelta, ps->velocity );
+	ps->saberLockFrame = s->forceFrame;
+	ps->legsAnim = s->legsAnim;
+	ps->torsoAnim = s->torsoAnim;
+	ps->legsFlip = s->legsFlip;
+	ps->torsoFlip = s->torsoFlip;
+	ps->clientNum = s->clientNum;
+	ps->saberMove = s->saberMove;
+
+	/*
+	VectorCopy( s->apos.trBase, ps->viewangles );
+
+	ps->fd.forceMindtrickTargetIndex = s->trickedentindex;
+	ps->fd.forceMindtrickTargetIndex2 = s->trickedentindex2;
+	ps->fd.forceMindtrickTargetIndex3 = s->trickedentindex3;
+	ps->fd.forceMindtrickTargetIndex4 = s->trickedentindex4;
+
+	ps->electrifyTime = s->emplacedOwner;
+
+	ps->speed = s->speed;
+
+	ps->genericEnemyIndex = s->genericenemyindex;
+
+	ps->activeForcePass = s->activeForcePass;
+
+	ps->movementDir = s->angles2[YAW];
+
+	ps->eFlags = s->eFlags;
+
+	ps->saberInFlight = s->saberInFlight;
+	ps->saberEntityNum = s->saberEntityNum;
+
+	ps->fd.forcePowersActive = s->forcePowersActive;
+
+	if (s->bolt1)
+	{
+		ps->duelInProgress = qtrue;
+	}
+	else
+	{
+		ps->duelInProgress = qfalse;
+	}
+
+	if (s->bolt2)
+	{
+		ps->dualBlade = qtrue;
+	}
+	else
+	{
+		ps->dualBlade = qfalse;
+	}
+
+	ps->emplacedIndex = s->otherEntityNum2;
+
+	ps->saberHolstered = s->saberHolstered; //reuse bool in entitystate for players differently
+
+	ps->genericEnemyIndex = -1; //no real option for this
+
+	//The client has no knowledge of health levels (except for the client entity)
+	if (s->eFlags & EF_DEAD)
+	{
+		ps->stats[STAT_HEALTH] = 0;
+	}
+	else
+	{
+		ps->stats[STAT_HEALTH] = 100;
+	}
+
+	if ( ps->externalEvent ) {
+		s->event = ps->externalEvent;
+		s->eventParm = ps->externalEventParm;
+	} else if ( ps->entityEventSequence < ps->eventSequence ) {
+		int		seq;
+
+		if ( ps->entityEventSequence < ps->eventSequence - MAX_PS_EVENTS) {
+			ps->entityEventSequence = ps->eventSequence - MAX_PS_EVENTS;
+		}
+		seq = ps->entityEventSequence & (MAX_PS_EVENTS-1);
+		s->event = ps->events[ seq ] | ( ( ps->entityEventSequence & 3 ) << 8 );
+		s->eventParm = ps->eventParms[ seq ];
+		ps->entityEventSequence++;
+	}
+
+	ps->weapon = s->weapon;
+	ps->groundEntityNum = s->groundEntityNum;
+
+	for ( i = 0 ; i < MAX_POWERUPS ; i++ ) {
+		if (s->powerups & (1 << i))
+		{
+			ps->powerups[i] = 30;
+		}
+		else
+		{
+			ps->powerups[i] = 0;
+		}
+	}
+
+	ps->loopSound = s->loopSound;
+	ps->generic1 = s->generic1;
+	*/
+}
+#endif
+
+// This many playerState_t structures is painfully large. And we
+// don't need that many. So we just use a small pool of them.
+// PC gets to keep one per entity, just in case.
+#ifdef _XBOX
+
+struct psLinkedNode_t
+{
+	playerState_t	ps;
+	psLinkedNode_t	*next;
+};
+
+#define CG_SEND_PS_POOL_SIZE	64
+psLinkedNode_t cgSendPSPool[ CG_SEND_PS_POOL_SIZE ];
+psLinkedNode_t *cgSendPSFreeList;
+
+#else
+playerState_t cgSendPSPool[ MAX_GENTITIES ];
+#endif
+
+playerState_t *cgSendPS[MAX_GENTITIES];
+
+#ifdef _XBOX
+void AllocSendPlayerstate(int entNum)
+{
+	if (cgSendPS[entNum])
+	{
+		//Com_Printf( S_COLOR_RED "ERROR: Entity %d already has a playerstate!\n", entNum );
+		return;
+	}
+
+	if (!cgSendPSFreeList)
+		Com_Error( ERR_DROP, "ERROR: No free playerstates! Increase CG_SEND_PS_POOL_SIZE\n" );
+
+	cgSendPS[entNum] = &cgSendPSFreeList->ps;
+	cgSendPSFreeList = cgSendPSFreeList->next;
+}
+#endif
+
+//#define _PROFILE_ES_TO_PS
+
+#ifdef _PROFILE_ES_TO_PS
+int g_cgEStoPSTime = 0;
+#endif
+
+//Assign all the entity playerstate pointers to the corresponding one
+//so that we can access playerstate stuff in bg code (and then translate
+//it back to entitystate data)
+void CG_PmoveClientPointerUpdate()
+{
+	int i;
+
+	memset(&cgSendPSPool[0], 0, sizeof(cgSendPSPool));
+
+	for ( i = 0 ; i < MAX_GENTITIES ; i++ )
+	{
+#ifdef _XBOX
+		cgSendPS[i] = NULL;
+#else
+		cgSendPS[i] = &cgSendPSPool[i];
+#endif
+
+		// These will be invalid at this point on Xbox
+		cg_entities[i].playerState = cgSendPS[i];
+	}
+
+#ifdef _XBOX
+	for ( i = 0; i < CG_SEND_PS_POOL_SIZE - 1; i++ )
+	{
+		cgSendPSPool[i].next = &cgSendPSPool[i+1];
+	}
+	
+	// Last .next is already NULL from memset above
+	cgSendPSFreeList = &cgSendPSPool[0];
+#endif
+
+	//Set up bg entity data
+	cg_pmove.baseEnt = (bgEntity_t *)cg_entities;
+	cg_pmove.entSize = sizeof(centity_t);
+
+	cg_pmove.ghoul2 = NULL;
+}
+
+//check if local client is on an eweb
+qboolean CG_UsingEWeb(void)
+{
+	if (cg.predictedPlayerState.weapon == WP_EMPLACED_GUN && cg.predictedPlayerState.emplacedIndex &&
+		cg_entities[cg.predictedPlayerState.emplacedIndex].currentState.weapon == WP_NONE)
+	{
+		return qtrue;
+	}
+
+	return qfalse;
+}
+
+/*
+=================
+CG_PredictPlayerState
+
+Generates cg.predictedPlayerState for the current cg.time
+cg.predictedPlayerState is guaranteed to be valid after exiting.
+
+For demo playback, this will be an interpolation between two valid
+playerState_t.
+
+For normal gameplay, it will be the result of predicted usercmd_t on
+top of the most recent playerState_t received from the server.
+
+Each new snapshot will usually have one or more new usercmd over the last,
+but we simulate all unacknowledged commands each time, not just the new ones.
+This means that on an internet connection, quite a few pmoves may be issued
+each frame.
+
+OPTIMIZE: don't re-simulate unless the newly arrived snapshot playerState_t
+differs from the predicted one.  Would require saving all intermediate
+playerState_t during prediction.
+
+We detect prediction errors and allow them to be decayed off over several frames
+to ease the jerk.
+=================
+*/
+extern void CG_Cube( vec3_t mins, vec3_t maxs, vec3_t color, float alpha );
+extern	vmCvar_t		cg_showVehBounds;
+pmove_t cg_vehPmove;
+qboolean cg_vehPmoveSet = qfalse;
+
+#pragma warning(disable : 4701) //local variable may be used without having been initialized
+void CG_PredictPlayerState( void ) {
+	int			cmdNum, current, i;
+	playerState_t	oldPlayerState;
+	playerState_t	oldVehicleState;
+	qboolean	moved;
+	usercmd_t	oldestCmd;
+	usercmd_t	latestCmd;
+	centity_t *pEnt;
+	clientInfo_t *ci;
+
+	cg.hyperspace = qfalse;	// will be set if touching a trigger_teleport
+
+	// if this is the first frame we must guarantee
+	// predictedPlayerState is valid even if there is some
+	// other error condition
+	if ( !cg.validPPS ) {
+		cg.validPPS = qtrue;
+		cg.predictedPlayerState = cg.snap->ps;
+		if (CG_Piloting(cg.snap->ps.m_iVehicleNum))
+		{
+			cg.predictedVehicleState = cg.snap->vps;
+		}
+	}
+
+	// demo playback just copies the moves
+	if ( cg.demoPlayback || (cg.snap->ps.pm_flags & PMF_FOLLOW) ) {
+		CG_InterpolatePlayerState( qfalse );
+		if (CG_Piloting(cg.predictedPlayerState.m_iVehicleNum))
+		{
+			CG_InterpolateVehiclePlayerState(qfalse);
+		}
+		return;
+	}
+
+	// non-predicting local movement will grab the latest angles
+	if ( cg_nopredict.integer || cg_synchronousClients.integer || CG_UsingEWeb() ) {
+		CG_InterpolatePlayerState( qtrue );
+		if (CG_Piloting(cg.predictedPlayerState.m_iVehicleNum))
+		{
+			CG_InterpolateVehiclePlayerState(qtrue);
+		}
+		return;
+	}
+
+	// prepare for pmove
+	cg_pmove.ps = &cg.predictedPlayerState;
+	cg_pmove.trace = CG_Trace;
+	cg_pmove.pointcontents = CG_PointContents;
+
+	pEnt = &cg_entities[cg.predictedPlayerState.clientNum];
+	//rww - bgghoul2
+	if (cg_pmove.ghoul2 != pEnt->ghoul2) //only update it if the g2 instance has changed
+	{
+		if (cg.snap &&
+			pEnt->ghoul2 &&
+			!(cg.snap->ps.pm_flags & PMF_FOLLOW) &&
+			cg.snap->ps.persistant[PERS_TEAM] != TEAM_SPECTATOR)
+		{
+			cg_pmove.ghoul2 = pEnt->ghoul2;
+			cg_pmove.g2Bolts_LFoot = trap_G2API_AddBolt(pEnt->ghoul2, 0, "*l_leg_foot");
+			cg_pmove.g2Bolts_RFoot = trap_G2API_AddBolt(pEnt->ghoul2, 0, "*r_leg_foot");
+		}
+		else
+		{
+			cg_pmove.ghoul2 = NULL;
+		}
+	}
+
+	ci = &cgs.clientinfo[cg.predictedPlayerState.clientNum];
+
+	//I'll just do this every frame in case the scale changes in realtime (don't need to update the g2 inst for that)
+	VectorCopy(pEnt->modelScale, cg_pmove.modelScale);
+	//rww end bgghoul2
+
+	if ( cg_pmove.ps->pm_type == PM_DEAD ) {
+		cg_pmove.tracemask = MASK_PLAYERSOLID & ~CONTENTS_BODY;
+	}
+	else {
+		cg_pmove.tracemask = MASK_PLAYERSOLID;
+	}
+	if ( cg.snap->ps.persistant[PERS_TEAM] == TEAM_SPECTATOR ) {
+		cg_pmove.tracemask &= ~CONTENTS_BODY;	// spectators can fly through bodies
+	}
+	cg_pmove.noFootsteps = ( cgs.dmflags & DF_NO_FOOTSTEPS ) > 0;
+
+	// save the state before the pmove so we can detect transitions
+	oldPlayerState = cg.predictedPlayerState;
+	if (CG_Piloting(cg.predictedPlayerState.m_iVehicleNum))
+	{
+		oldVehicleState = cg.predictedVehicleState;
+	}
+
+	current = trap_GetCurrentCmdNumber();
+
+	// if we don't have the commands right after the snapshot, we
+	// can't accurately predict a current position, so just freeze at
+	// the last good position we had
+	cmdNum = current - CMD_BACKUP + 1;
+	trap_GetUserCmd( cmdNum, &oldestCmd );
+	if ( oldestCmd.serverTime > cg.snap->ps.commandTime 
+		&& oldestCmd.serverTime < cg.time ) {	// special check for map_restart
+		if ( cg_showmiss.integer ) {
+			CG_Printf ("exceeded PACKET_BACKUP on commands\n");
+		}
+		return;
+	}
+
+	// get the latest command so we can know which commands are from previous map_restarts
+	trap_GetUserCmd( current, &latestCmd );
+
+	// get the most recent information we have, even if
+	// the server time is beyond our current cg.time,
+	// because predicted player positions are going to 
+	// be ahead of everything else anyway
+	if ( cg.nextSnap && !cg.nextFrameTeleport && !cg.thisFrameTeleport ) {
+		cg.nextSnap->ps.slopeRecalcTime = cg.predictedPlayerState.slopeRecalcTime; //this is the only value we want to maintain seperately on server/client
+		cg.predictedPlayerState = cg.nextSnap->ps;
+		if (CG_Piloting(cg.nextSnap->ps.m_iVehicleNum))
+		{
+			cg.predictedVehicleState = cg.nextSnap->vps;
+		}
+		cg.physicsTime = cg.nextSnap->serverTime;
+	} else {
+		cg.snap->ps.slopeRecalcTime = cg.predictedPlayerState.slopeRecalcTime; //this is the only value we want to maintain seperately on server/client
+		cg.predictedPlayerState = cg.snap->ps;
+		if (CG_Piloting(cg.snap->ps.m_iVehicleNum))
+		{
+			cg.predictedVehicleState = cg.snap->vps;
+		}
+		cg.physicsTime = cg.snap->serverTime;
+	}
+
+	if ( pmove_msec.integer < 8 ) {
+		trap_Cvar_Set("pmove_msec", "8");
+	}
+	else if (pmove_msec.integer > 33) {
+		trap_Cvar_Set("pmove_msec", "33");
+	}
+
+	cg_pmove.pmove_fixed = pmove_fixed.integer;// | cg_pmove_fixed.integer;
+	cg_pmove.pmove_msec = pmove_msec.integer;
+
+	for ( i = 0 ; i < MAX_GENTITIES ; i++ )
+	{
+		//Written this way for optimal speed, even though it doesn't look pretty.
+		//(we don't want to spend the time assigning pointers as it does take
+		//a small precious fraction of time and adds up in the loop.. so says
+		//the precision timer!)
+
+		if (cg_entities[i].currentState.eType == ET_PLAYER ||
+			cg_entities[i].currentState.eType == ET_NPC)
+		{
+			// Need a new playerState_t on Xbox
+#ifdef _XBOX
+			AllocSendPlayerstate(i);
+#endif
+			VectorCopy( cg_entities[i].currentState.pos.trBase, cgSendPS[i]->origin );
+			VectorCopy( cg_entities[i].currentState.pos.trDelta, cgSendPS[i]->velocity );
+			cgSendPS[i]->saberLockFrame = cg_entities[i].currentState.forceFrame;
+			cgSendPS[i]->legsAnim = cg_entities[i].currentState.legsAnim;
+			cgSendPS[i]->torsoAnim = cg_entities[i].currentState.torsoAnim;
+			cgSendPS[i]->legsFlip = cg_entities[i].currentState.legsFlip;
+			cgSendPS[i]->torsoFlip = cg_entities[i].currentState.torsoFlip;
+			cgSendPS[i]->clientNum = cg_entities[i].currentState.clientNum;
+			cgSendPS[i]->saberMove = cg_entities[i].currentState.saberMove;
+		}
+	}
+
+	if (CG_Piloting(cg.predictedPlayerState.m_iVehicleNum))
+	{
+		cg_entities[cg.predictedPlayerState.clientNum].playerState = &cg.predictedPlayerState;
+		cg_entities[cg.predictedPlayerState.m_iVehicleNum].playerState = &cg.predictedVehicleState;
+
+		//use the player command time, because we are running with the player cmds (this is even the case
+		//on the server)
+		cg.predictedVehicleState.commandTime = cg.predictedPlayerState.commandTime;
+	}
+
+	// run cmds
+	moved = qfalse;
+	for ( cmdNum = current - CMD_BACKUP + 1 ; cmdNum <= current ; cmdNum++ ) {
+		// get the command
+		trap_GetUserCmd( cmdNum, &cg_pmove.cmd );
+
+		if ( cg_pmove.pmove_fixed ) {
+			PM_UpdateViewAngles( cg_pmove.ps, &cg_pmove.cmd );
+		}
+
+		// don't do anything if the time is before the snapshot player time
+		if ( cg_pmove.cmd.serverTime <= cg.predictedPlayerState.commandTime )
+		{
+			continue;
+		}
+
+		// don't do anything if the command was from a previous map_restart
+		if ( cg_pmove.cmd.serverTime > latestCmd.serverTime ) {
+			continue;
+		}
+
+		// check for a prediction error from last frame
+		// on a lan, this will often be the exact value
+		// from the snapshot, but on a wan we will have
+		// to predict several commands to get to the point
+		// we want to compare
+		if ( CG_Piloting(oldPlayerState.m_iVehicleNum) &&
+			cg.predictedVehicleState.commandTime == oldVehicleState.commandTime )
+		{
+			vec3_t	delta;
+			float	len;
+
+			if ( cg.thisFrameTeleport ) {
+				// a teleport will not cause an error decay
+				VectorClear( cg.predictedError );
+				if ( cg_showVehMiss.integer ) {
+					CG_Printf( "VEH PredictionTeleport\n" );
+				}
+				cg.thisFrameTeleport = qfalse;
+			} else {
+				vec3_t	adjusted;
+				CG_AdjustPositionForMover( cg.predictedVehicleState.origin, 
+					cg.predictedVehicleState.groundEntityNum, cg.physicsTime, cg.oldTime, adjusted );
+
+				if ( cg_showVehMiss.integer ) {
+					if (!VectorCompare( oldVehicleState.origin, adjusted )) {
+						CG_Printf("VEH prediction error\n");
+					}
+				}
+				VectorSubtract( oldVehicleState.origin, adjusted, delta );
+				len = VectorLength( delta );
+				if ( len > 0.1 ) {
+					if ( cg_showVehMiss.integer ) {
+						CG_Printf("VEH Prediction miss: %f\n", len);
+					}
+					if ( cg_errorDecay.integer ) {
+						int		t;
+						float	f;
+
+						t = cg.time - cg.predictedErrorTime;
+						f = ( cg_errorDecay.value - t ) / cg_errorDecay.value;
+						if ( f < 0 ) {
+							f = 0;
+						}
+						if ( f > 0 && cg_showVehMiss.integer ) {
+							CG_Printf("VEH Double prediction decay: %f\n", f);
+						}
+						VectorScale( cg.predictedError, f, cg.predictedError );
+					} else {
+						VectorClear( cg.predictedError );
+					}
+					VectorAdd( delta, cg.predictedError, cg.predictedError );
+					cg.predictedErrorTime = cg.oldTime;
+				}
+				//
+				if ( cg_showVehMiss.integer ) {
+					if (!VectorCompare( oldVehicleState.vehOrientation, cg.predictedVehicleState.vehOrientation )) {
+						CG_Printf("VEH orient prediction error\n");
+						CG_Printf("VEH pitch prediction miss: %f\n", AngleSubtract( oldVehicleState.vehOrientation[0], cg.predictedVehicleState.vehOrientation[0] ) );
+						CG_Printf("VEH yaw prediction miss: %f\n", AngleSubtract( oldVehicleState.vehOrientation[1], cg.predictedVehicleState.vehOrientation[1] ) );
+						CG_Printf("VEH roll prediction miss: %f\n", AngleSubtract( oldVehicleState.vehOrientation[2], cg.predictedVehicleState.vehOrientation[2] ) );
+					}
+				}
+			}
+		}
+		else if ( !oldPlayerState.m_iVehicleNum && //don't do pred err on ps while riding veh
+			cg.predictedPlayerState.commandTime == oldPlayerState.commandTime )
+		{
+			vec3_t	delta;
+			float	len;
+
+			if ( cg.thisFrameTeleport ) {
+				// a teleport will not cause an error decay
+				VectorClear( cg.predictedError );
+				if ( cg_showmiss.integer ) {
+					CG_Printf( "PredictionTeleport\n" );
+				}
+				cg.thisFrameTeleport = qfalse;
+			} else {
+				vec3_t	adjusted;
+				CG_AdjustPositionForMover( cg.predictedPlayerState.origin, 
+					cg.predictedPlayerState.groundEntityNum, cg.physicsTime, cg.oldTime, adjusted );
+
+				if ( cg_showmiss.integer ) {
+					if (!VectorCompare( oldPlayerState.origin, adjusted )) {
+						CG_Printf("prediction error\n");
+					}
+				}
+				VectorSubtract( oldPlayerState.origin, adjusted, delta );
+				len = VectorLength( delta );
+				if ( len > 0.1 ) {
+					if ( cg_showmiss.integer ) {
+						CG_Printf("Prediction miss: %f\n", len);
+					}
+					if ( cg_errorDecay.integer ) {
+						int		t;
+						float	f;
+
+						t = cg.time - cg.predictedErrorTime;
+						f = ( cg_errorDecay.value - t ) / cg_errorDecay.value;
+						if ( f < 0 ) {
+							f = 0;
+						}
+						if ( f > 0 && cg_showmiss.integer ) {
+							CG_Printf("Double prediction decay: %f\n", f);
+						}
+						VectorScale( cg.predictedError, f, cg.predictedError );
+					} else {
+						VectorClear( cg.predictedError );
+					}
+					VectorAdd( delta, cg.predictedError, cg.predictedError );
+					cg.predictedErrorTime = cg.oldTime;
+				}
+			}
+		}
+
+		if ( cg_pmove.pmove_fixed ) {
+			cg_pmove.cmd.serverTime = ((cg_pmove.cmd.serverTime + pmove_msec.integer-1) / pmove_msec.integer) * pmove_msec.integer;
+		}
+
+		cg_pmove.animations = bgAllAnims[pEnt->localAnimIndex].anims;
+		cg_pmove.gametype = cgs.gametype;
+
+		cg_pmove.debugMelee = cgs.debugMelee;
+		cg_pmove.stepSlideFix = cgs.stepSlideFix;
+		cg_pmove.noSpecMove = cgs.noSpecMove;
+
+		cg_pmove.nonHumanoid = (pEnt->localAnimIndex > 0);
+
+		if (cg.snap && cg.snap->ps.saberLockTime > cg.time)
+		{
+			centity_t *blockOpp = &cg_entities[cg.snap->ps.saberLockEnemy];
+
+			if (blockOpp)
+			{
+				vec3_t lockDir, lockAng;
+
+				VectorSubtract( blockOpp->lerpOrigin, cg.snap->ps.origin, lockDir );
+				vectoangles(lockDir, lockAng);
+
+				VectorCopy(lockAng, cg_pmove.ps->viewangles);
+			}
+		}
+
+		//THIS is pretty much bad, but...
+		cg_pmove.ps->fd.saberAnimLevelBase = cg_pmove.ps->fd.saberAnimLevel;
+		if ( cg_pmove.ps->saberHolstered == 1 )
+		{
+			if ( ci->saber[0].numBlades > 0 )
+			{
+				cg_pmove.ps->fd.saberAnimLevelBase = SS_STAFF;
+			}
+			else if ( ci->saber[1].model[0] )
+			{
+				cg_pmove.ps->fd.saberAnimLevelBase = SS_DUAL;
+			}
+		}
+	
+		Pmove (&cg_pmove);
+
+		if (CG_Piloting(cg.predictedPlayerState.m_iVehicleNum) &&
+			cg.predictedPlayerState.pm_type != PM_INTERMISSION)
+		{ //we're riding a vehicle, let's predict it
+			centity_t *veh = &cg_entities[cg.predictedPlayerState.m_iVehicleNum];
+			int x, zd, zu;
+
+			if (veh->m_pVehicle)
+			{ //make sure pointer is set up to go to our predicted state
+				veh->m_pVehicle->m_vOrientation = &cg.predictedVehicleState.vehOrientation[0];
+
+				//keep this updated based on what the playerstate says
+				veh->m_pVehicle->m_iRemovedSurfaces = cg.predictedVehicleState.vehSurfaces;
+
+				trap_GetUserCmd( cmdNum, &veh->m_pVehicle->m_ucmd );
+
+				if ( veh->m_pVehicle->m_ucmd.buttons & BUTTON_TALK )
+				{ //forced input if "chat bubble" is up
+					veh->m_pVehicle->m_ucmd.buttons = BUTTON_TALK;
+					veh->m_pVehicle->m_ucmd.forwardmove = 0;
+					veh->m_pVehicle->m_ucmd.rightmove = 0;
+					veh->m_pVehicle->m_ucmd.upmove = 0;
+				}
+				cg_vehPmove.ps = &cg.predictedVehicleState;
+				cg_vehPmove.animations = bgAllAnims[veh->localAnimIndex].anims;
+
+				memcpy(&cg_vehPmove.cmd, &veh->m_pVehicle->m_ucmd, sizeof(usercmd_t));
+				/*
+				cg_vehPmove.cmd.rightmove = 0; //no vehicle can move right/left
+				cg_vehPmove.cmd.upmove = 0; //no vehicle can move up/down
+				*/
+
+				cg_vehPmove.gametype = cgs.gametype;
+				cg_vehPmove.ghoul2 = veh->ghoul2;
+
+				cg_vehPmove.nonHumanoid = (veh->localAnimIndex > 0);
+
+				/*
+				x = (veh->currentState.solid & 255);
+				zd = (veh->currentState.solid & 255);
+				zu = (veh->currentState.solid & 255) - 32;
+
+				cg_vehPmove.mins[0] = cg_vehPmove.mins[1] = -x;
+				cg_vehPmove.maxs[0] = cg_vehPmove.maxs[1] = x;
+				cg_vehPmove.mins[2] = -zd;
+				cg_vehPmove.maxs[2] = zu;
+				*/
+				//I think this was actually wrong.. just copy-pasted from id code. Oh well.
+				x = (veh->currentState.solid)&255;
+				zd = (veh->currentState.solid>>8)&255;
+				zu = (veh->currentState.solid>>15)&255;
+				
+				zu -= 32; //I don't quite get the reason for this.
+				zd = -zd;
+
+				//z/y must be symmetrical (blah)
+				cg_vehPmove.mins[0] = cg_vehPmove.mins[1] = -x;
+				cg_vehPmove.maxs[0] = cg_vehPmove.maxs[1] = x;
+				cg_vehPmove.mins[2] = zd;
+				cg_vehPmove.maxs[2] = zu;
+
+				VectorCopy(veh->modelScale, cg_vehPmove.modelScale);
+
+				if (!cg_vehPmoveSet)
+				{ //do all the one-time things
+					cg_vehPmove.trace = CG_Trace;
+					cg_vehPmove.pointcontents = CG_PointContents;
+					cg_vehPmove.tracemask = MASK_PLAYERSOLID;
+					cg_vehPmove.debugLevel = 0;
+					cg_vehPmove.g2Bolts_LFoot = -1;
+					cg_vehPmove.g2Bolts_RFoot = -1;
+
+					cg_vehPmove.baseEnt = (bgEntity_t *)cg_entities;
+					cg_vehPmove.entSize = sizeof(centity_t);
+
+					cg_vehPmoveSet = qtrue;
+				}
+				
+				cg_vehPmove.noFootsteps = ( cgs.dmflags & DF_NO_FOOTSTEPS ) > 0;
+				cg_vehPmove.pmove_fixed = pmove_fixed.integer;
+				cg_vehPmove.pmove_msec = pmove_msec.integer;
+
+				cg_entities[cg.predictedPlayerState.clientNum].playerState = &cg.predictedPlayerState;
+				veh->playerState = &cg.predictedVehicleState;
+
+				//update boarding value sent from server. boarding is not predicted, but no big deal
+				veh->m_pVehicle->m_iBoarding = cg.predictedVehicleState.vehBoarding;
+
+				Pmove(&cg_vehPmove);
+				/*
+				if ( !cg_paused.integer )
+				{
+					Com_Printf( "%d - PITCH change %4.2f\n", cg.time, AngleSubtract(veh->m_pVehicle->m_vOrientation[0],veh->m_pVehicle->m_vPrevOrientation[0]) );
+				}
+				*/
+				if ( cg_showVehBounds.integer )
+				{
+					vec3_t NPCDEBUG_RED = {1.0, 0.0, 0.0};
+					vec3_t absmin, absmax;
+					VectorAdd( cg_vehPmove.ps->origin, cg_vehPmove.mins, absmin );
+					VectorAdd( cg_vehPmove.ps->origin, cg_vehPmove.maxs, absmax );
+					CG_Cube( absmin, absmax, NPCDEBUG_RED, 0.25 );
+				}
+			}
+		}
+
+		moved = qtrue;
+
+		// add push trigger movement effects
+		CG_TouchTriggerPrediction();
+
+		// check for predictable events that changed from previous predictions
+		//CG_CheckChangedPredictableEvents(&cg.predictedPlayerState);
+	}
+
+	if ( cg_showmiss.integer > 1 ) {
+		CG_Printf( "[%i : %i] ", cg_pmove.cmd.serverTime, cg.time );
+	}
+
+	if ( !moved ) {
+		if ( cg_showmiss.integer ) {
+			CG_Printf( "not moved\n" );
+		}
+		goto revertES;
+	}
+
+	if (CG_Piloting(cg.predictedPlayerState.m_iVehicleNum))
+	{
+		CG_AdjustPositionForMover( cg.predictedVehicleState.origin, 
+			cg.predictedVehicleState.groundEntityNum, 
+			cg.physicsTime, cg.time, cg.predictedVehicleState.origin );
+	}
+	else
+	{
+		// adjust for the movement of the groundentity
+		CG_AdjustPositionForMover( cg.predictedPlayerState.origin, 
+			cg.predictedPlayerState.groundEntityNum, 
+			cg.physicsTime, cg.time, cg.predictedPlayerState.origin );
+	}
+
+	if ( cg_showmiss.integer ) {
+		if (cg.predictedPlayerState.eventSequence > oldPlayerState.eventSequence + MAX_PS_EVENTS) {
+			CG_Printf("WARNING: dropped event\n");
+		}
+	}
+
+	// fire events and other transition triggered things
+	CG_TransitionPlayerState( &cg.predictedPlayerState, &oldPlayerState );
+
+	if ( cg_showmiss.integer ) {
+		if (cg.eventSequence > cg.predictedPlayerState.eventSequence) {
+			CG_Printf("WARNING: double event\n");
+			cg.eventSequence = cg.predictedPlayerState.eventSequence;
+		}
+	}
+
+	if (cg.predictedPlayerState.m_iVehicleNum &&
+		!CG_Piloting(cg.predictedPlayerState.m_iVehicleNum))
+	{ //a passenger on this vehicle, bolt them in
+		centity_t *veh = &cg_entities[cg.predictedPlayerState.m_iVehicleNum];
+		VectorCopy(veh->lerpAngles, cg.predictedPlayerState.viewangles);
+		VectorCopy(veh->lerpOrigin, cg.predictedPlayerState.origin);
+	}
+
+revertES:
+	if (CG_Piloting(cg.predictedPlayerState.m_iVehicleNum))
+	{
+		centity_t *veh = &cg_entities[cg.predictedPlayerState.m_iVehicleNum];
+
+		if (veh->m_pVehicle)
+		{
+			//switch ptr back for this ent in case we stop riding it
+			veh->m_pVehicle->m_vOrientation = &cgSendPS[veh->currentState.number]->vehOrientation[0];
+		}
+
+		cg_entities[cg.predictedPlayerState.clientNum].playerState = cgSendPS[cg.predictedPlayerState.clientNum];
+		veh->playerState = cgSendPS[veh->currentState.number];
+	}
+
+	//copy some stuff back into the entstates to help actually "predict" them if applicable
+	for ( i = 0 ; i < MAX_GENTITIES ; i++ )
+	{
+		if (cg_entities[i].currentState.eType == ET_PLAYER ||
+			cg_entities[i].currentState.eType == ET_NPC)
+		{
+			cg_entities[i].currentState.torsoAnim = cgSendPS[i]->torsoAnim;
+			cg_entities[i].currentState.legsAnim = cgSendPS[i]->legsAnim;
+			cg_entities[i].currentState.forceFrame = cgSendPS[i]->saberLockFrame;
+			cg_entities[i].currentState.saberMove = cgSendPS[i]->saberMove;
+		}
+	}
+}
+#pragma warning(default : 4701) //local variable may be used without having been initialized
diff --git a/codemp/cgame/cg_public.h b/codemp/cgame/cg_public.h
new file mode 100644
index 0000000..a8e435e
--- /dev/null
+++ b/codemp/cgame/cg_public.h
@@ -0,0 +1,594 @@
+// Copyright (C) 1999-2000 Id Software, Inc.
+//
+#ifndef __CG_PUBLIC_H
+#define __CG_PUBLIC_H
+
+#define	CMD_BACKUP			64	
+#define	CMD_MASK			(CMD_BACKUP - 1)
+// allow a lot of command backups for very fast systems
+// multiple commands may be combined into a single packet, so this
+// needs to be larger than PACKET_BACKUP
+
+
+#define	MAX_ENTITIES_IN_SNAPSHOT	256
+
+// snapshots are a view of the server at a given time
+
+// Snapshots are generated at regular time intervals by the server,
+// but they may not be sent if a client's rate level is exceeded, or
+// they may be dropped by the network.
+typedef struct {
+	int				snapFlags;			// SNAPFLAG_RATE_DELAYED, etc
+	int				ping;
+
+	int				serverTime;		// server time the message is valid for (in msec)
+
+	byte			areamask[MAX_MAP_AREA_BYTES];		// portalarea visibility bits
+
+	playerState_t	ps;						// complete information about the current player at this time
+	playerState_t	vps; //vehicle I'm riding's playerstate (if applicable) -rww
+
+	int				numEntities;			// all of the entities that need to be presented
+	entityState_t	entities[MAX_ENTITIES_IN_SNAPSHOT];	// at the time of this snapshot
+
+	int				numServerCommands;		// text based server commands to execute when this
+	int				serverCommandSequence;	// snapshot becomes current
+} snapshot_t;
+
+enum {
+  CGAME_EVENT_NONE,
+  CGAME_EVENT_TEAMMENU,
+  CGAME_EVENT_SCOREBOARD,
+  CGAME_EVENT_EDITHUD
+};
+
+
+/*
+==================================================================
+
+functions imported from the main executable
+
+==================================================================
+*/
+
+#define	CGAME_IMPORT_API_VERSION	5
+
+typedef enum {
+	CG_PRINT = 0,
+	CG_ERROR,
+	CG_MILLISECONDS,
+
+	//Also for profiling.. do not use for game related tasks.
+	CG_PRECISIONTIMER_START,
+	CG_PRECISIONTIMER_END,
+
+	CG_CVAR_REGISTER,
+	CG_CVAR_UPDATE,
+	CG_CVAR_SET,
+	CG_CVAR_VARIABLESTRINGBUFFER,
+	CG_CVAR_GETHIDDENVALUE,
+	CG_ARGC,
+	CG_ARGV,
+	CG_ARGS,
+	CG_FS_FOPENFILE,
+	CG_FS_READ,
+	CG_FS_WRITE,
+	CG_FS_FCLOSEFILE,
+	CG_FS_GETFILELIST,
+	CG_SENDCONSOLECOMMAND,
+	CG_ADDCOMMAND,
+	CG_REMOVECOMMAND,
+	CG_SENDCLIENTCOMMAND,
+	CG_UPDATESCREEN,
+	CG_CM_LOADMAP,
+	CG_CM_NUMINLINEMODELS,
+	CG_CM_INLINEMODEL,
+	CG_CM_TEMPBOXMODEL,
+	CG_CM_TEMPCAPSULEMODEL,
+	CG_CM_POINTCONTENTS,
+	CG_CM_TRANSFORMEDPOINTCONTENTS,
+	CG_CM_BOXTRACE,
+	CG_CM_CAPSULETRACE,
+	CG_CM_TRANSFORMEDBOXTRACE,
+	CG_CM_TRANSFORMEDCAPSULETRACE,
+	CG_CM_MARKFRAGMENTS,
+	CG_S_GETVOICEVOLUME,
+	CG_S_MUTESOUND,
+	CG_S_STARTSOUND,
+	CG_S_STARTLOCALSOUND,
+	CG_S_CLEARLOOPINGSOUNDS,
+	CG_S_ADDLOOPINGSOUND,
+	CG_S_UPDATEENTITYPOSITION,
+	CG_S_ADDREALLOOPINGSOUND,
+	CG_S_STOPLOOPINGSOUND,
+	CG_S_RESPATIALIZE,
+	CG_S_SHUTUP,
+	CG_S_REGISTERSOUND,
+	CG_S_STARTBACKGROUNDTRACK,
+
+	//rww - AS trap implem
+	CG_S_UPDATEAMBIENTSET,
+	CG_AS_PARSESETS,
+	CG_AS_ADDPRECACHEENTRY,
+	CG_S_ADDLOCALSET,
+	CG_AS_GETBMODELSOUND,
+
+	CG_R_LOADWORLDMAP,
+	CG_R_REGISTERMODEL,
+	CG_R_REGISTERSKIN,
+	CG_R_REGISTERSHADER,
+	CG_R_REGISTERSHADERNOMIP,
+	CG_R_REGISTERFONT,
+	CG_R_FONT_STRLENPIXELS,
+	CG_R_FONT_STRLENCHARS,
+	CG_R_FONT_STRHEIGHTPIXELS,
+	CG_R_FONT_DRAWSTRING,
+	CG_LANGUAGE_ISASIAN,
+	CG_LANGUAGE_USESSPACES,
+	CG_ANYLANGUAGE_READCHARFROMSTRING,
+
+	CGAME_MEMSET = 100,
+	CGAME_MEMCPY,
+	CGAME_STRNCPY,
+	CGAME_SIN,
+	CGAME_COS,
+	CGAME_ATAN2,
+	CGAME_SQRT,
+	CGAME_MATRIXMULTIPLY,
+	CGAME_ANGLEVECTORS,
+	CGAME_PERPENDICULARVECTOR,
+	CGAME_FLOOR,
+	CGAME_CEIL,
+
+	CGAME_TESTPRINTINT,
+	CGAME_TESTPRINTFLOAT,
+
+	CGAME_ACOS,
+	CGAME_ASIN,
+
+	CG_R_CLEARSCENE = 200,
+	CG_R_CLEARDECALS,
+	CG_R_ADDREFENTITYTOSCENE,
+	CG_R_ADDPOLYTOSCENE,
+	CG_R_ADDPOLYSTOSCENE,
+	CG_R_ADDDECALTOSCENE,
+	CG_R_LIGHTFORPOINT,
+	CG_R_ADDLIGHTTOSCENE,
+	CG_R_ADDADDITIVELIGHTTOSCENE,
+	CG_R_RENDERSCENE,
+	CG_R_SETCOLOR,
+	CG_R_DRAWSTRETCHPIC,
+	CG_R_MODELBOUNDS,
+	CG_R_LERPTAG,
+	CG_R_DRAWROTATEPIC,
+	CG_R_DRAWROTATEPIC2,
+	CG_R_SETRANGEFOG, //linear fogging, with settable range -rww
+	CG_R_SETREFRACTIONPROP, //set some properties for the draw layer for my refractive effect (here primarily for mod authors) -rww
+	CG_R_REMAP_SHADER,
+	CG_R_GET_LIGHT_STYLE,
+	CG_R_SET_LIGHT_STYLE,
+	CG_R_GET_BMODEL_VERTS,
+	CG_R_GETDISTANCECULL,
+
+	CG_R_GETREALRES,
+	CG_R_AUTOMAPELEVADJ,
+	CG_R_INITWIREFRAMEAUTO,
+
+	CG_FX_ADDLINE,
+
+	CG_GETGLCONFIG,
+	CG_GETGAMESTATE,
+	CG_GETCURRENTSNAPSHOTNUMBER,
+	CG_GETSNAPSHOT,
+	CG_GETDEFAULTSTATE,
+	CG_GETSERVERCOMMAND,
+	CG_GETCURRENTCMDNUMBER,
+	CG_GETUSERCMD,
+	CG_SETUSERCMDVALUE,
+	CG_SETCLIENTFORCEANGLE,
+	CG_SETCLIENTTURNEXTENT,
+	CG_OPENUIMENU,
+	CG_TESTPRINTINT,
+	CG_TESTPRINTFLOAT,
+	CG_MEMORY_REMAINING,
+	CG_KEY_ISDOWN,
+	CG_KEY_GETCATCHER,
+	CG_KEY_SETCATCHER,
+	CG_KEY_GETKEY,
+
+ 	CG_PC_ADD_GLOBAL_DEFINE,
+	CG_PC_LOAD_SOURCE,
+	CG_PC_FREE_SOURCE,
+	CG_PC_READ_TOKEN,
+	CG_PC_SOURCE_FILE_AND_LINE,
+	CG_PC_LOAD_GLOBAL_DEFINES,
+	CG_PC_REMOVE_ALL_GLOBAL_DEFINES,
+
+	CG_S_STOPBACKGROUNDTRACK,
+	CG_REAL_TIME,
+	CG_SNAPVECTOR,
+	CG_CIN_PLAYCINEMATIC,
+	CG_CIN_STOPCINEMATIC,
+	CG_CIN_RUNCINEMATIC,
+	CG_CIN_DRAWCINEMATIC,
+	CG_CIN_SETEXTENTS,
+
+	CG_GET_ENTITY_TOKEN,
+	CG_R_INPVS,
+
+	CG_FX_REGISTER_EFFECT,
+	CG_FX_PLAY_EFFECT,
+	CG_FX_PLAY_ENTITY_EFFECT,
+	CG_FX_PLAY_EFFECT_ID,
+	CG_FX_PLAY_PORTAL_EFFECT_ID,
+	CG_FX_PLAY_ENTITY_EFFECT_ID,
+	CG_FX_PLAY_BOLTED_EFFECT_ID,
+	CG_FX_ADD_SCHEDULED_EFFECTS,
+	CG_FX_INIT_SYSTEM,
+	CG_FX_SET_REFDEF,
+	CG_FX_FREE_SYSTEM,
+	CG_FX_ADJUST_TIME,
+	CG_FX_DRAW_2D_EFFECTS,
+	CG_FX_RESET,
+	CG_FX_ADDPOLY,
+	CG_FX_ADDBEZIER,
+	CG_FX_ADDPRIMITIVE,
+	CG_FX_ADDSPRITE,
+	CG_FX_ADDELECTRICITY,
+
+//	CG_SP_PRINT,
+	CG_SP_GETSTRINGTEXTSTRING,
+
+	CG_ROFF_CLEAN,
+	CG_ROFF_UPDATE_ENTITIES,
+	CG_ROFF_CACHE,
+	CG_ROFF_PLAY,
+	CG_ROFF_PURGE_ENT,
+
+
+	//rww - dynamic vm memory allocation!
+	CG_TRUEMALLOC,
+	CG_TRUEFREE,
+
+/*
+Ghoul2 Insert Start
+*/
+	CG_G2_LISTSURFACES,
+	CG_G2_LISTBONES,
+	CG_G2_SETMODELS,
+	CG_G2_HAVEWEGHOULMODELS,
+	CG_G2_GETBOLT,
+	CG_G2_GETBOLT_NOREC,
+	CG_G2_GETBOLT_NOREC_NOROT,
+	CG_G2_INITGHOUL2MODEL,
+	CG_G2_SETSKIN,
+	CG_G2_COLLISIONDETECT,
+	CG_G2_CLEANMODELS,
+	CG_G2_ANGLEOVERRIDE,
+	CG_G2_PLAYANIM,
+	CG_G2_GETBONEANIM,
+	CG_G2_GETBONEFRAME, //trimmed down version of GBA, so I don't have to pass all those unused args across the VM-exe border
+	CG_G2_GETGLANAME,
+	CG_G2_COPYGHOUL2INSTANCE,
+	CG_G2_COPYSPECIFICGHOUL2MODEL,
+	CG_G2_DUPLICATEGHOUL2INSTANCE,
+	CG_G2_HASGHOUL2MODELONINDEX,
+	CG_G2_REMOVEGHOUL2MODEL,
+	CG_G2_SKINLESSMODEL,
+	CG_G2_GETNUMGOREMARKS,
+	CG_G2_ADDSKINGORE,
+	CG_G2_CLEARSKINGORE,
+	CG_G2_SIZE,
+	CG_G2_ADDBOLT,
+	CG_G2_ATTACHENT,
+	CG_G2_SETBOLTON,
+	CG_G2_SETROOTSURFACE,
+	CG_G2_SETSURFACEONOFF,
+	CG_G2_SETNEWORIGIN,
+	CG_G2_DOESBONEEXIST,
+	CG_G2_GETSURFACERENDERSTATUS,
+
+	CG_G2_GETTIME,
+	CG_G2_SETTIME,
+
+	CG_G2_ABSURDSMOOTHING,
+
+/*
+	//rww - RAGDOLL_BEGIN
+*/
+	CG_G2_SETRAGDOLL,
+	CG_G2_ANIMATEG2MODELS,
+/*
+	//rww - RAGDOLL_END
+*/
+
+	//additional ragdoll options -rww
+	CG_G2_RAGPCJCONSTRAINT,
+	CG_G2_RAGPCJGRADIENTSPEED,
+	CG_G2_RAGEFFECTORGOAL,
+	CG_G2_GETRAGBONEPOS,
+	CG_G2_RAGEFFECTORKICK,
+	CG_G2_RAGFORCESOLVE,
+
+	//rww - ik move method, allows you to specify a bone and move it to a world point (within joint constraints)
+	//by using the majority of gil's existing bone angling stuff from the ragdoll code.
+	CG_G2_SETBONEIKSTATE,
+	CG_G2_IKMOVE,
+
+	CG_G2_REMOVEBONE,
+
+	CG_G2_ATTACHINSTANCETOENTNUM,
+	CG_G2_CLEARATTACHEDINSTANCE,
+	CG_G2_CLEANENTATTACHMENTS,
+	CG_G2_OVERRIDESERVER,
+
+	CG_G2_GETSURFACENAME,
+
+	CG_SET_SHARED_BUFFER,
+
+	CG_CM_REGISTER_TERRAIN,
+	CG_RMG_INIT,
+	CG_RE_INIT_RENDERER_TERRAIN,
+	CG_R_WEATHER_CONTENTS_OVERRIDE,
+	CG_R_WORLDEFFECTCOMMAND,
+	//Adding trap to get weather working
+	CG_WE_ADDWEATHERZONE
+
+/*
+Ghoul2 Insert End
+*/
+} cgameImport_t;
+
+
+/*
+==================================================================
+
+functions exported to the main executable
+
+==================================================================
+*/
+
+typedef enum {
+	CG_INIT,
+//	void CG_Init( int serverMessageNum, int serverCommandSequence, int clientNum )
+	// called when the level loads or when the renderer is restarted
+	// all media should be registered at this time
+	// cgame will display loading status by calling SCR_Update, which
+	// will call CG_DrawInformation during the loading process
+	// reliableCommandSequence will be 0 on fresh loads, but higher for
+	// demos, tourney restarts, or vid_restarts
+
+	CG_SHUTDOWN,
+//	void (*CG_Shutdown)( void );
+	// oportunity to flush and close any open files
+
+	CG_CONSOLE_COMMAND,
+//	qboolean (*CG_ConsoleCommand)( void );
+	// a console command has been issued locally that is not recognized by the
+	// main game system.
+	// use Cmd_Argc() / Cmd_Argv() to read the command, return qfalse if the
+	// command is not known to the game
+
+	CG_DRAW_ACTIVE_FRAME,
+//	void (*CG_DrawActiveFrame)( int serverTime, stereoFrame_t stereoView, qboolean demoPlayback );
+	// Generates and draws a game scene and status information at the given time.
+	// If demoPlayback is set, local movement prediction will not be enabled
+
+	CG_CROSSHAIR_PLAYER,
+//	int (*CG_CrosshairPlayer)( void );
+
+	CG_LAST_ATTACKER,
+//	int (*CG_LastAttacker)( void );
+
+	CG_KEY_EVENT, 
+//	void	(*CG_KeyEvent)( int key, qboolean down );
+
+	CG_MOUSE_EVENT,
+//	void	(*CG_MouseEvent)( int dx, int dy );
+	CG_EVENT_HANDLING,
+//	void (*CG_EventHandling)(int type);
+
+	CG_POINT_CONTENTS,
+//	int	CG_PointContents( const vec3_t point, int passEntityNum );
+
+	CG_GET_LERP_ORIGIN,
+//	void CG_LerpOrigin(int num, vec3_t result);
+
+	CG_GET_LERP_DATA,
+	CG_GET_GHOUL2,
+	CG_GET_MODEL_LIST,
+
+	CG_CALC_LERP_POSITIONS,
+//	void CG_CalcEntityLerpPositions(int num);
+
+	CG_TRACE,
+	CG_G2TRACE,
+//void CG_Trace( trace_t *result, const vec3_t start, const vec3_t mins, const vec3_t maxs, const vec3_t end, 
+//					 int skipNumber, int mask );
+
+	CG_G2MARK,
+
+	CG_RAG_CALLBACK,
+
+	CG_INCOMING_CONSOLE_COMMAND,
+
+	CG_GET_USEABLE_FORCE,
+
+	CG_GET_ORIGIN,		// int entnum, vec3_t origin
+	CG_GET_ANGLES,		// int entnum, vec3_t angle
+
+	CG_GET_ORIGIN_TRAJECTORY,		// int entnum
+	CG_GET_ANGLE_TRAJECTORY,		// int entnum
+
+	CG_ROFF_NOTETRACK_CALLBACK,		// int entnum, char *notetrack
+
+	CG_IMPACT_MARK,
+//void CG_ImpactMark( qhandle_t markShader, const vec3_t origin, const vec3_t dir, 
+//				   float orientation, float red, float green, float blue, float alpha,
+//				   qboolean alphaFade, float radius, qboolean temporary )
+
+	CG_MAP_CHANGE,
+
+	CG_AUTOMAP_INPUT,
+
+	CG_MISC_ENT, //rwwRMG - added
+
+	CG_GET_SORTED_FORCE_POWER,
+} cgameExport_t;
+
+typedef struct
+{
+	float		up;
+	float		down;
+	float		yaw;
+	float		pitch;
+	qboolean	goToDefaults;
+} autoMapInput_t;
+
+// CG_POINT_CONTENTS
+typedef struct
+{
+	vec3_t		mPoint;			// input
+	int			mPassEntityNum;	// input
+} TCGPointContents;
+
+// CG_GET_BOLT_POS
+typedef struct
+{
+	vec3_t		mOrigin;		// output
+	vec3_t		mAngles;		// output
+	vec3_t		mScale;			// output
+	int			mEntityNum;		// input
+} TCGGetBoltData;
+
+// CG_IMPACT_MARK
+typedef struct
+{
+	int		mHandle;
+	vec3_t	mPoint;
+	vec3_t	mAngle;
+	float	mRotation;
+	float	mRed;
+	float	mGreen;
+	float	mBlue;
+	float	mAlphaStart;
+	float	mSizeStart;
+} TCGImpactMark;
+
+// CG_GET_LERP_ORIGIN
+// CG_GET_LERP_ANGLES
+// CG_GET_MODEL_SCALE
+typedef struct
+{
+	int			mEntityNum;		// input
+	vec3_t		mPoint;			// output
+} TCGVectorData;
+
+// CG_TRACE/CG_G2TRACE
+typedef struct
+{
+	trace_t mResult;					// output
+	vec3_t	mStart, mMins, mMaxs, mEnd;	// input
+	int		mSkipNumber, mMask;			// input
+} TCGTrace;
+
+// CG_G2MARK
+typedef struct
+{
+	int			shader;
+	float		size;
+	vec3_t		start, dir;
+} TCGG2Mark;
+
+// CG_INCOMING_CONSOLE_COMMAND
+typedef struct
+{
+	char conCommand[1024];
+} TCGIncomingConsoleCommand;
+
+// CG_FX_CAMERASHAKE
+typedef struct
+{
+	vec3_t	mOrigin;					// input
+	float	mIntensity;					// input
+	int		mRadius;					// input
+	int		mTime;						// input
+} TCGCameraShake;
+
+// CG_MISC_ENT
+typedef struct
+{
+	char	mModel[MAX_QPATH];			// input
+	vec3_t	mOrigin, mAngles, mScale;	// input
+} TCGMiscEnt;
+
+typedef struct
+{
+	refEntity_t		ent;				// output
+	void			*ghoul2;			// input
+	int				modelIndex;			// input
+	int				boltIndex;			// input
+	vec3_t			origin;				// input
+	vec3_t			angles;				// input
+	vec3_t			modelScale;			// input
+} TCGPositionOnBolt;
+
+//ragdoll callback structs -rww
+#define RAG_CALLBACK_NONE				0
+#define RAG_CALLBACK_DEBUGBOX			1
+typedef struct
+{
+	vec3_t			mins;
+	vec3_t			maxs;
+	int				duration;
+} ragCallbackDebugBox_t;
+
+#define RAG_CALLBACK_DEBUGLINE			2
+typedef struct
+{
+	vec3_t			start;
+	vec3_t			end;
+	int				time;
+	int				color;
+	int				radius;
+} ragCallbackDebugLine_t;
+
+#define RAG_CALLBACK_BONESNAP			3
+typedef struct
+{
+	char			boneName[128]; //name of the bone in question
+	int				entNum; //index of entity who owns the bone in question
+} ragCallbackBoneSnap_t;
+
+#define RAG_CALLBACK_BONEIMPACT			4
+typedef struct
+{
+	char			boneName[128]; //name of the bone in question
+	int				entNum; //index of entity who owns the bone in question
+} ragCallbackBoneImpact_t;
+
+#define RAG_CALLBACK_BONEINSOLID		5
+typedef struct
+{
+	vec3_t			bonePos; //world coordinate position of the bone
+	int				entNum; //index of entity who owns the bone in question
+	int				solidCount; //higher the count, the longer we've been in solid (the worse off we are)
+} ragCallbackBoneInSolid_t;
+
+#define RAG_CALLBACK_TRACELINE			6
+typedef struct
+{
+	trace_t			tr;
+	vec3_t			start;
+	vec3_t			end;
+	vec3_t			mins;
+	vec3_t			maxs;
+	int				ignore;
+	int				mask;
+} ragCallbackTraceLine_t;
+
+#define	MAX_CG_SHARED_BUFFER_SIZE		2048
+
+//----------------------------------------------
+
+#endif // __CG_PUBLIC_H
diff --git a/codemp/cgame/cg_saga.c b/codemp/cgame/cg_saga.c
new file mode 100644
index 0000000..c21a556
--- /dev/null
+++ b/codemp/cgame/cg_saga.c
@@ -0,0 +1,1094 @@
+// Copyright (C) 2000-2002 Raven Software, Inc.
+//
+/*****************************************************************************
+ * name:		cg_siege.c
+ *
+ * desc:		Clientgame-side module for Siege gametype.
+ *
+ * $Author: osman $ 
+ * $Revision: 1.5 $
+ *
+ *****************************************************************************/
+#include "cg_local.h"
+#include "bg_saga.h"
+
+int cgSiegeRoundState = 0;
+int cgSiegeRoundTime = 0;
+
+static char		team1[512];
+static char		team2[512];
+
+int			team1Timed = 0;
+int			team2Timed = 0;
+
+int			cgSiegeTeam1PlShader = 0;
+int			cgSiegeTeam2PlShader = 0;
+
+static char cgParseObjectives[MAX_SIEGE_INFO_SIZE];
+
+extern void CG_LoadCISounds(clientInfo_t *ci, qboolean modelloaded); //cg_players.c
+
+void CG_DrawSiegeMessage( const char *str, int objectiveScreen );
+void CG_DrawSiegeMessageNonMenu( const char *str );
+void CG_SiegeBriefingDisplay(int team, int dontshow);
+
+void CG_PrecacheSiegeObjectiveAssetsForTeam(int myTeam)
+{
+	char			teamstr[64];
+	char			objstr[256];
+	char			foundobjective[MAX_SIEGE_INFO_SIZE];
+
+	if (!siege_valid)
+	{
+		CG_Error("Siege data does not exist on client!\n");
+		return;
+	}
+
+	if (myTeam == SIEGETEAM_TEAM1)
+	{
+		Com_sprintf(teamstr, sizeof(teamstr), team1);
+	}
+	else
+	{
+		Com_sprintf(teamstr, sizeof(teamstr), team2);
+	}
+
+	if (BG_SiegeGetValueGroup(siege_info, teamstr, cgParseObjectives))
+	{
+		int i = 1;
+		while (i < 32)
+		{ //eh, just try 32 I guess
+			Com_sprintf(objstr, sizeof(objstr), "Objective%i", i);
+
+			if (BG_SiegeGetValueGroup(cgParseObjectives, objstr, foundobjective))
+			{
+				char str[MAX_QPATH];
+
+				if (BG_SiegeGetPairedValue(foundobjective, "sound_team1", str))
+				{
+					trap_S_RegisterSound(str);
+				}
+				if (BG_SiegeGetPairedValue(foundobjective, "sound_team2", str))
+				{
+					trap_S_RegisterSound(str);
+				}
+				if (BG_SiegeGetPairedValue(foundobjective, "objgfx", str))
+				{
+					trap_R_RegisterShaderNoMip(str);
+				}
+				if (BG_SiegeGetPairedValue(foundobjective, "mapicon", str))
+				{
+					trap_R_RegisterShaderNoMip(str);
+				}
+				if (BG_SiegeGetPairedValue(foundobjective, "litmapicon", str))
+				{
+					trap_R_RegisterShaderNoMip(str);
+				}
+				if (BG_SiegeGetPairedValue(foundobjective, "donemapicon", str))
+				{
+					trap_R_RegisterShaderNoMip(str);
+				}
+			}
+			else
+			{ //no more
+				break;
+			}
+			i++;
+		}
+	}
+}
+
+void CG_PrecachePlayersForSiegeTeam(int team)
+{
+	siegeTeam_t *stm;
+	int i = 0;
+
+	stm = BG_SiegeFindThemeForTeam(team);
+
+	if (!stm)
+	{ //invalid team/no theme for team?
+		return;
+	}
+
+	while (i < stm->numClasses)
+	{
+		siegeClass_t *scl = stm->classes[i];
+
+		if (scl->forcedModel[0])
+		{
+			clientInfo_t fake;
+
+			memset(&fake, 0, sizeof(fake));
+			strcpy(fake.modelName, scl->forcedModel);
+
+			trap_R_RegisterModel(va("models/players/%s/model.glm", scl->forcedModel));
+			if (scl->forcedSkin[0])
+			{
+				trap_R_RegisterSkin(va("models/players/%s/model_%s.skin", scl->forcedModel, scl->forcedSkin));
+				strcpy(fake.skinName, scl->forcedSkin);
+			}
+			else
+			{
+				strcpy(fake.skinName, "default");
+			}
+
+			//precache the sounds for the model...
+			CG_LoadCISounds(&fake, qtrue);
+		}
+
+		i++;
+	}
+}
+
+void CG_InitSiegeMode(void)
+{
+	char			levelname[MAX_QPATH];
+	char			btime[1024];
+	char			teams[2048];
+	char			teamInfo[MAX_SIEGE_INFO_SIZE];
+	int				len = 0;
+	int				i = 0;
+	int				j = 0;
+	siegeClass_t		*cl;
+	siegeTeam_t		*sTeam;
+	fileHandle_t	f;
+	char			teamIcon[128];
+
+	if (cgs.gametype != GT_SIEGE)
+	{
+		goto failure;
+	}
+
+	Com_sprintf(levelname, sizeof(levelname), "%s\0", cgs.mapname);
+
+	i = strlen(levelname)-1;
+
+	while (i > 0 && levelname[i] && levelname[i] != '.')
+	{
+		i--;
+	}
+
+	if (!i)
+	{
+		goto failure;
+	}
+
+	levelname[i] = '\0'; //kill the ".bsp"
+
+	Com_sprintf(levelname, sizeof(levelname), "%s.siege\0", levelname); 
+
+	if (!levelname || !levelname[0])
+	{
+		goto failure;
+	}
+
+	len = trap_FS_FOpenFile(levelname, &f, FS_READ);
+
+	if (!f || len >= MAX_SIEGE_INFO_SIZE)
+	{
+		goto failure;
+	}
+
+	trap_FS_Read(siege_info, len, f);
+
+	trap_FS_FCloseFile(f);
+
+	siege_valid = 1;
+
+	if (BG_SiegeGetValueGroup(siege_info, "Teams", teams))
+	{
+		char buf[1024];
+
+		trap_Cvar_VariableStringBuffer("cg_siegeTeam1", buf, 1024);
+		if (buf[0] && Q_stricmp(buf, "none"))
+		{
+			strcpy(team1, buf);
+		}
+		else
+		{
+			BG_SiegeGetPairedValue(teams, "team1", team1);
+		}
+
+		if (team1[0] == '@')
+		{ //it's a damn stringed reference.
+			char b[256];
+			trap_SP_GetStringTextString(team1+1, b, 256);
+			trap_Cvar_Set("cg_siegeTeam1Name", b);
+		}
+		else
+		{
+			trap_Cvar_Set("cg_siegeTeam1Name", team1);
+		}
+
+		trap_Cvar_VariableStringBuffer("cg_siegeTeam2", buf, 1024);
+		if (buf[0] && Q_stricmp(buf, "none"))
+		{
+			strcpy(team2, buf);
+		}
+		else
+		{
+			BG_SiegeGetPairedValue(teams, "team2", team2);
+		}
+
+		if (team2[0] == '@')
+		{ //it's a damn stringed reference.
+			char b[256];
+			trap_SP_GetStringTextString(team2+1, b, 256);
+			trap_Cvar_Set("cg_siegeTeam2Name", b);
+		}
+		else
+		{
+			trap_Cvar_Set("cg_siegeTeam2Name", team2);
+		}
+	}
+	else
+	{
+		CG_Error("Siege teams not defined");
+	}
+
+	if (BG_SiegeGetValueGroup(siege_info, team1, teamInfo))
+	{
+		if (BG_SiegeGetPairedValue(teamInfo, "TeamIcon", teamIcon))
+		{
+			trap_Cvar_Set( "team1_icon", teamIcon);
+		}
+
+		if (BG_SiegeGetPairedValue(teamInfo, "Timed", btime))
+		{
+			team1Timed = atoi(btime)*1000;
+			CG_SetSiegeTimerCvar ( team1Timed );
+		}
+		else
+		{
+			team1Timed = 0;
+		}
+	}
+	else
+	{
+		CG_Error("No team entry for '%s'\n", team1);
+	}
+
+	if (BG_SiegeGetPairedValue(siege_info, "mapgraphic", teamInfo))
+	{
+		trap_Cvar_Set("siege_mapgraphic", teamInfo);
+	}
+	else
+	{
+		trap_Cvar_Set("siege_mapgraphic", "gfx/mplevels/siege1_hoth");
+	}
+
+	if (BG_SiegeGetPairedValue(siege_info, "missionname", teamInfo))
+	{
+		trap_Cvar_Set("siege_missionname", teamInfo);
+	}
+	else
+	{
+		trap_Cvar_Set("siege_missionname", " ");
+	}
+
+	if (BG_SiegeGetValueGroup(siege_info, team2, teamInfo))
+	{
+		if (BG_SiegeGetPairedValue(teamInfo, "TeamIcon", teamIcon))
+		{
+			trap_Cvar_Set( "team2_icon", teamIcon);
+		}
+
+		if (BG_SiegeGetPairedValue(teamInfo, "Timed", btime))
+		{
+			team2Timed = atoi(btime)*1000;
+			CG_SetSiegeTimerCvar ( team2Timed );
+		}
+		else
+		{
+			team2Timed = 0;
+		}
+	}
+	else
+	{
+		CG_Error("No team entry for '%s'\n", team2);
+	}
+
+	//Load the player class types
+	BG_SiegeLoadClasses(NULL);
+
+	if (!bgNumSiegeClasses)
+	{ //We didn't find any?!
+		CG_Error("Couldn't find any player classes for Siege");
+	}
+
+	//Now load the teams since we have class data.
+	BG_SiegeLoadTeams();
+
+	if (!bgNumSiegeTeams)
+	{ //React same as with classes.
+		CG_Error("Couldn't find any player teams for Siege");
+	}
+
+	//Get and set the team themes for each team. This will control which classes can be
+	//used on each team.
+	if (BG_SiegeGetValueGroup(siege_info, team1, teamInfo))
+	{
+		if (BG_SiegeGetPairedValue(teamInfo, "UseTeam", btime))
+		{
+			BG_SiegeSetTeamTheme(SIEGETEAM_TEAM1, btime);
+		}
+		if (BG_SiegeGetPairedValue(teamInfo, "FriendlyShader", btime))
+		{
+			cgSiegeTeam1PlShader = trap_R_RegisterShaderNoMip(btime);
+		}
+		else
+		{
+			cgSiegeTeam1PlShader = 0;
+		}
+	}
+	if (BG_SiegeGetValueGroup(siege_info, team2, teamInfo))
+	{
+		if (BG_SiegeGetPairedValue(teamInfo, "UseTeam", btime))
+		{
+			BG_SiegeSetTeamTheme(SIEGETEAM_TEAM2, btime);
+		}
+		if (BG_SiegeGetPairedValue(teamInfo, "FriendlyShader", btime))
+		{
+			cgSiegeTeam2PlShader = trap_R_RegisterShaderNoMip(btime);
+		}
+		else
+		{
+			cgSiegeTeam2PlShader = 0;
+		}
+	}
+
+	//Now go through the classes used by the loaded teams and try to precache
+	//any forced models or forced skins.
+	i = SIEGETEAM_TEAM1;
+
+	while (i <= SIEGETEAM_TEAM2)
+	{
+		j = 0;
+		sTeam = BG_SiegeFindThemeForTeam(i);
+
+		if (!sTeam)
+		{
+			i++;
+			continue;
+		}
+
+		//Get custom team shaders while we're at it.
+		if (i == SIEGETEAM_TEAM1)
+		{
+			cgSiegeTeam1PlShader = sTeam->friendlyShader;
+		}
+		else if (i == SIEGETEAM_TEAM2)
+		{
+			cgSiegeTeam2PlShader = sTeam->friendlyShader;
+		}
+
+		while (j < sTeam->numClasses)
+		{
+			cl = sTeam->classes[j];
+
+			if (cl->forcedModel[0])
+			{ //This class has a forced model, so precache it.
+				trap_R_RegisterModel(va("models/players/%s/model.glm", cl->forcedModel));
+
+				if (cl->forcedSkin[0])
+				{ //also has a forced skin, precache it.
+					char *useSkinName;
+
+					if (strchr(cl->forcedSkin, '|'))
+					{//three part skin
+						useSkinName = va("models/players/%s/|%s", cl->forcedModel, cl->forcedSkin);
+					}
+					else
+					{
+						useSkinName = va("models/players/%s/model_%s.skin", cl->forcedModel, cl->forcedSkin);
+					}
+
+					trap_R_RegisterSkin(useSkinName);
+				}
+			}
+			
+			j++;
+		}
+		i++;
+	}
+
+	//precache saber data for classes that use sabers on both teams
+	BG_PrecacheSabersForSiegeTeam(SIEGETEAM_TEAM1);
+	BG_PrecacheSabersForSiegeTeam(SIEGETEAM_TEAM2);
+
+	CG_PrecachePlayersForSiegeTeam(SIEGETEAM_TEAM1);
+	CG_PrecachePlayersForSiegeTeam(SIEGETEAM_TEAM2);
+
+	CG_PrecachePlayersForSiegeTeam(SIEGETEAM_TEAM1);
+	CG_PrecachePlayersForSiegeTeam(SIEGETEAM_TEAM2);
+
+	CG_PrecacheSiegeObjectiveAssetsForTeam(SIEGETEAM_TEAM1);
+	CG_PrecacheSiegeObjectiveAssetsForTeam(SIEGETEAM_TEAM2);
+
+	return;
+failure:
+	siege_valid = 0;
+}
+
+static char CGAME_INLINE *CG_SiegeObjectiveBuffer(int team, int objective)
+{
+	static char buf[8192];
+	char teamstr[1024];
+
+	if (team == SIEGETEAM_TEAM1)
+	{
+		Com_sprintf(teamstr, sizeof(teamstr), team1);
+	}
+	else
+	{
+		Com_sprintf(teamstr, sizeof(teamstr), team2);
+	}
+
+	if (BG_SiegeGetValueGroup(siege_info, teamstr, cgParseObjectives))
+	{ //found the team group
+		if (BG_SiegeGetValueGroup(cgParseObjectives, va("Objective%i", objective), buf))
+		{ //found the objective group
+			return buf;
+		}
+	}
+
+	return NULL;
+}
+
+void CG_ParseSiegeObjectiveStatus(const char *str)
+{
+	int i = 0;
+	int	team = SIEGETEAM_TEAM1;
+	char *cvarName;
+	char *s;
+	int objectiveNum = 0;
+
+	if (!str || !str[0])
+	{
+		return;
+	}
+
+	while (str[i])
+	{
+		if (str[i] == '|')
+		{ //switch over to team2, this is the next section
+            team = SIEGETEAM_TEAM2;
+			objectiveNum = 0;
+		}
+		else if (str[i] == '-')
+		{
+			objectiveNum++;
+			i++;
+
+			cvarName = va("team%i_objective%i", team, objectiveNum);
+			if (str[i] == '1')
+			{ //it's completed
+				trap_Cvar_Set(cvarName, "1");
+			}
+			else
+			{ //otherwise assume it is not
+				trap_Cvar_Set(cvarName, "0");
+			}
+
+			s = CG_SiegeObjectiveBuffer(team, objectiveNum);
+			if (s && s[0])
+			{ //now set the description and graphic cvars to by read by the menu
+				char buffer[8192];
+
+				cvarName = va("team%i_objective%i_longdesc", team, objectiveNum);
+				if (BG_SiegeGetPairedValue(s, "objdesc", buffer))
+				{
+					trap_Cvar_Set(cvarName, buffer);
+				}
+				else
+				{
+					trap_Cvar_Set(cvarName, "UNSPECIFIED");
+				}
+
+				cvarName = va("team%i_objective%i_gfx", team, objectiveNum);
+				if (BG_SiegeGetPairedValue(s, "objgfx", buffer))
+				{
+					trap_Cvar_Set(cvarName, buffer);
+				}
+				else
+				{
+					trap_Cvar_Set(cvarName, "UNSPECIFIED");
+				}
+
+				cvarName = va("team%i_objective%i_mapicon", team, objectiveNum);
+				if (BG_SiegeGetPairedValue(s, "mapicon", buffer))
+				{
+					trap_Cvar_Set(cvarName, buffer);
+				}
+				else
+				{
+					trap_Cvar_Set(cvarName, "UNSPECIFIED");
+				}
+
+				cvarName = va("team%i_objective%i_litmapicon", team, objectiveNum);
+				if (BG_SiegeGetPairedValue(s, "litmapicon", buffer))
+				{
+					trap_Cvar_Set(cvarName, buffer);
+				}
+				else
+				{
+					trap_Cvar_Set(cvarName, "UNSPECIFIED");
+				}
+
+				cvarName = va("team%i_objective%i_donemapicon", team, objectiveNum);
+				if (BG_SiegeGetPairedValue(s, "donemapicon", buffer))
+				{
+					trap_Cvar_Set(cvarName, buffer);
+				}
+				else
+				{
+					trap_Cvar_Set(cvarName, "UNSPECIFIED");
+				}
+
+				cvarName = va("team%i_objective%i_mappos", team, objectiveNum);
+				if (BG_SiegeGetPairedValue(s, "mappos", buffer))
+				{
+					trap_Cvar_Set(cvarName, buffer);
+				}
+				else
+				{
+					trap_Cvar_Set(cvarName, "0 0 32 32");
+				}
+			}
+		}
+		i++;
+	}
+
+	if (cg.predictedPlayerState.persistant[PERS_TEAM] != TEAM_SPECTATOR)
+	{ //update menu cvars
+		CG_SiegeBriefingDisplay(cg.predictedPlayerState.persistant[PERS_TEAM], 1);
+	}
+}
+
+void CG_SiegeRoundOver(centity_t *ent, int won)
+{
+	int				myTeam;
+	char			teamstr[64];
+	char			appstring[1024];
+	char			soundstr[1024];
+	int				success = 0;
+	playerState_t	*ps = NULL;
+
+	if (!siege_valid)
+	{
+		CG_Error("ERROR: Siege data does not exist on client!\n");
+		return;
+	}
+
+	if (cg.snap)
+	{ //this should always be true, if it isn't though use the predicted ps as a fallback
+		ps = &cg.snap->ps;
+	}
+	else
+	{
+		ps = &cg.predictedPlayerState;
+	}
+
+	if (!ps)
+	{
+		assert(0);
+		return;
+	}
+
+	myTeam = ps->persistant[PERS_TEAM];
+
+	if (myTeam == TEAM_SPECTATOR)
+	{
+		return;
+	}
+
+	if (myTeam == SIEGETEAM_TEAM1)
+	{
+		Com_sprintf(teamstr, sizeof(teamstr), team1);
+	}
+	else
+	{
+		Com_sprintf(teamstr, sizeof(teamstr), team2);
+	}
+
+	if (BG_SiegeGetValueGroup(siege_info, teamstr, cgParseObjectives))
+	{
+		if (won == myTeam)
+		{
+			success = BG_SiegeGetPairedValue(cgParseObjectives, "wonround", appstring);
+		}
+		else
+		{
+			success = BG_SiegeGetPairedValue(cgParseObjectives, "lostround", appstring);
+		}
+
+		if (success)
+		{
+			CG_DrawSiegeMessage(appstring, 0);
+		}
+
+		appstring[0] = 0;
+		soundstr[0] = 0;
+
+		if (myTeam == won)
+		{
+			Com_sprintf(teamstr, sizeof(teamstr), "roundover_sound_wewon");
+		}
+		else
+		{
+			Com_sprintf(teamstr, sizeof(teamstr), "roundover_sound_welost");
+		}
+
+		if (BG_SiegeGetPairedValue(cgParseObjectives, teamstr, appstring))
+		{
+			Com_sprintf(soundstr, sizeof(soundstr), appstring);
+		}
+		/*
+		else
+		{
+			if (myTeam != won)
+			{
+				Com_sprintf(soundstr, sizeof(soundstr), DEFAULT_LOSE_ROUND);
+			}
+			else
+			{
+				Com_sprintf(soundstr, sizeof(soundstr), DEFAULT_WIN_ROUND);
+			}
+		}
+		*/
+
+		if (soundstr[0])
+		{
+			trap_S_StartLocalSound(trap_S_RegisterSound(soundstr), CHAN_ANNOUNCER);
+		}
+	}
+}
+
+void CG_SiegeGetObjectiveDescription(int team, int objective, char *buffer)
+{
+	char teamstr[1024];
+	char objectiveStr[8192];
+
+	buffer[0] = 0; //set to 0 ahead of time in case we fail to find the objective group/name
+
+	if (team == SIEGETEAM_TEAM1)
+	{
+		Com_sprintf(teamstr, sizeof(teamstr), team1);
+	}
+	else
+	{
+		Com_sprintf(teamstr, sizeof(teamstr), team2);
+	}
+
+	if (BG_SiegeGetValueGroup(siege_info, teamstr, cgParseObjectives))
+	{ //found the team group
+		if (BG_SiegeGetValueGroup(cgParseObjectives, va("Objective%i", objective), objectiveStr))
+		{ //found the objective group
+			//Parse the name right into the buffer.
+			BG_SiegeGetPairedValue(objectiveStr, "goalname", buffer);
+		}
+	}
+}
+
+int CG_SiegeGetObjectiveFinal(int team, int objective )
+{
+	char finalStr[64];
+	char teamstr[1024];
+	char objectiveStr[8192];
+
+	if (team == SIEGETEAM_TEAM1)
+	{
+		Com_sprintf(teamstr, sizeof(teamstr), team1);
+	}
+	else
+	{
+		Com_sprintf(teamstr, sizeof(teamstr), team2);
+	}
+
+	if (BG_SiegeGetValueGroup(siege_info, teamstr, cgParseObjectives))
+	{ //found the team group
+		if (BG_SiegeGetValueGroup(cgParseObjectives, va("Objective%i", objective), objectiveStr))
+		{ //found the objective group
+			//Parse the name right into the buffer.
+			BG_SiegeGetPairedValue(objectiveStr, "final", finalStr);
+			return (atoi( finalStr ));
+		}
+	}
+	return 0;
+}
+
+void CG_SiegeBriefingDisplay(int team, int dontshow)
+{
+	char			teamstr[64];
+	char			briefing[8192];
+	char			properValue[1024];
+	char			objectiveDesc[1024];
+	int				i = 1;
+	int				useTeam = team;
+	qboolean		primary = qfalse;
+
+	if (!siege_valid)
+	{
+		return;
+	}
+
+	if (team == TEAM_SPECTATOR)
+	{
+		return;
+	}
+
+	if (team == SIEGETEAM_TEAM1)
+	{
+		Com_sprintf(teamstr, sizeof(teamstr), team1);
+	}
+	else
+	{
+		Com_sprintf(teamstr, sizeof(teamstr), team2);
+	}
+
+	if (useTeam != SIEGETEAM_TEAM1 && useTeam != SIEGETEAM_TEAM2)
+	{ //This shouldn't be happening. But just fall back to team 2 anyway.
+		useTeam = SIEGETEAM_TEAM2;
+	}
+
+	trap_Cvar_Set(va("siege_primobj_inuse"), "0");
+
+	while (i < 16)
+	{ //do up to 16 objectives I suppose
+		//Get the value for this objective on this team
+		//Now set the cvar for the menu to display.
+		
+		//primary = (CG_SiegeGetObjectiveFinal(useTeam, i)>-1)?qtrue:qfalse;
+		primary = (CG_SiegeGetObjectiveFinal(useTeam, i)>0)?qtrue:qfalse;
+
+		properValue[0] = 0;
+		trap_Cvar_VariableStringBuffer(va("team%i_objective%i", useTeam, i), properValue, 1024);
+		if (primary)
+		{
+			trap_Cvar_Set(va("siege_primobj"), properValue);
+		}
+		else
+		{
+			trap_Cvar_Set(va("siege_objective%i", i), properValue);
+		}
+
+		//Now set the long desc cvar for the menu to display.
+		properValue[0] = 0;
+		trap_Cvar_VariableStringBuffer(va("team%i_objective%i_longdesc", useTeam, i), properValue, 1024);
+		if (primary)
+		{
+			trap_Cvar_Set(va("siege_primobj_longdesc"), properValue);
+		}
+		else
+		{
+			trap_Cvar_Set(va("siege_objective%i_longdesc", i), properValue);
+		}
+
+		//Now set the gfx cvar for the menu to display.
+		properValue[0] = 0;
+		trap_Cvar_VariableStringBuffer(va("team%i_objective%i_gfx", useTeam, i), properValue, 1024);
+		if (primary)
+		{
+			trap_Cvar_Set(va("siege_primobj_gfx"), properValue);
+		}
+		else
+		{
+			trap_Cvar_Set(va("siege_objective%i_gfx", i), properValue);
+		}
+
+		//Now set the mapicon cvar for the menu to display.
+		properValue[0] = 0;
+		trap_Cvar_VariableStringBuffer(va("team%i_objective%i_mapicon", useTeam, i), properValue, 1024);
+		if (primary)
+		{
+			trap_Cvar_Set(va("siege_primobj_mapicon"), properValue);
+		}
+		else
+		{
+			trap_Cvar_Set(va("siege_objective%i_mapicon", i), properValue);
+		}
+
+		//Now set the mappos cvar for the menu to display.
+		properValue[0] = 0;
+		trap_Cvar_VariableStringBuffer(va("team%i_objective%i_mappos", useTeam, i), properValue, 1024);
+		if (primary)
+		{
+			trap_Cvar_Set(va("siege_primobj_mappos"), properValue);
+		}
+		else
+		{
+			trap_Cvar_Set(va("siege_objective%i_mappos", i), properValue);
+		}
+
+		//Now set the description cvar for the objective
+		CG_SiegeGetObjectiveDescription(useTeam, i, objectiveDesc);
+
+		if (objectiveDesc[0])
+		{ //found a valid objective description
+			if ( primary )
+			{
+				trap_Cvar_Set(va("siege_primobj_desc"), objectiveDesc);
+				//this one is marked not in use because it gets primobj
+				trap_Cvar_Set(va("siege_objective%i_inuse", i), "0");
+				trap_Cvar_Set(va("siege_primobj_inuse"), "1");
+
+				trap_Cvar_Set(va("team%i_objective%i_inuse", useTeam, i), "1");
+
+			}
+			else
+			{
+				trap_Cvar_Set(va("siege_objective%i_desc", i), objectiveDesc);
+				trap_Cvar_Set(va("siege_objective%i_inuse", i), "2");
+				trap_Cvar_Set(va("team%i_objective%i_inuse", useTeam, i), "2");
+
+			}
+		}
+		else
+		{ //didn't find one, so set the "inuse" cvar to 0 for the objective and mark it non-complete.
+			trap_Cvar_Set(va("siege_objective%i_inuse", i), "0");
+			trap_Cvar_Set(va("siege_objective%i", i), "0");
+			trap_Cvar_Set(va("team%i_objective%i_inuse", useTeam, i), "0");
+			trap_Cvar_Set(va("team%i_objective%i", useTeam, i), "0");
+
+			trap_Cvar_Set(va("siege_objective%i_mappos", i), "");
+			trap_Cvar_Set(va("team%i_objective%i_mappos", useTeam, i), "");
+			trap_Cvar_Set(va("siege_objective%i_gfx", i), "");
+			trap_Cvar_Set(va("team%i_objective%i_gfx", useTeam, i), "");
+			trap_Cvar_Set(va("siege_objective%i_mapicon", i), "");
+			trap_Cvar_Set(va("team%i_objective%i_mapicon", useTeam, i), "");
+		}
+
+		i++;
+	}
+
+	if (dontshow)
+	{
+		return;
+	}
+
+	if (BG_SiegeGetValueGroup(siege_info, teamstr, cgParseObjectives))
+	{
+		if (BG_SiegeGetPairedValue(cgParseObjectives, "briefing", briefing))
+		{
+			CG_DrawSiegeMessage(briefing, 1);
+		}
+	}
+}
+
+void CG_SiegeObjectiveCompleted(centity_t *ent, int won, int objectivenum)
+{
+	int				myTeam;
+	char			teamstr[64];
+	char			objstr[256];
+	char			foundobjective[MAX_SIEGE_INFO_SIZE];
+	char			appstring[1024];
+	char			soundstr[1024];
+	int				success = 0;
+	playerState_t	*ps = NULL;
+
+	if (!siege_valid)
+	{
+		CG_Error("Siege data does not exist on client!\n");
+		return;
+	}
+
+	if (cg.snap)
+	{ //this should always be true, if it isn't though use the predicted ps as a fallback
+		ps = &cg.snap->ps;
+	}
+	else
+	{
+		ps = &cg.predictedPlayerState;
+	}
+
+	if (!ps)
+	{
+		assert(0);
+		return;
+	}
+
+	myTeam = ps->persistant[PERS_TEAM];
+
+	if (myTeam == TEAM_SPECTATOR)
+	{
+		return;
+	}
+
+	if (won == SIEGETEAM_TEAM1)
+	{
+		Com_sprintf(teamstr, sizeof(teamstr), team1);
+	}
+	else
+	{
+		Com_sprintf(teamstr, sizeof(teamstr), team2);
+	}
+
+	if (BG_SiegeGetValueGroup(siege_info, teamstr, cgParseObjectives))
+	{
+		Com_sprintf(objstr, sizeof(objstr), "Objective%i", objectivenum);
+
+		if (BG_SiegeGetValueGroup(cgParseObjectives, objstr, foundobjective))
+		{
+			if (myTeam == SIEGETEAM_TEAM1)
+			{
+				success = BG_SiegeGetPairedValue(foundobjective, "message_team1", appstring);
+			}
+			else
+			{
+				success = BG_SiegeGetPairedValue(foundobjective, "message_team2", appstring);
+			}
+
+			if (success)
+			{
+				CG_DrawSiegeMessageNonMenu(appstring);
+			}
+
+			appstring[0] = 0;
+			soundstr[0] = 0;
+
+			if (myTeam == SIEGETEAM_TEAM1)
+			{
+				Com_sprintf(teamstr, sizeof(teamstr), "sound_team1");
+			}
+			else
+			{
+				Com_sprintf(teamstr, sizeof(teamstr), "sound_team2");
+			}
+
+			if (BG_SiegeGetPairedValue(foundobjective, teamstr, appstring))
+			{
+				Com_sprintf(soundstr, sizeof(soundstr), appstring);
+			}
+			/*
+			else
+			{
+				if (myTeam != won)
+				{
+					Com_sprintf(soundstr, sizeof(soundstr), DEFAULT_LOSE_OBJECTIVE);
+				}
+				else
+				{
+					Com_sprintf(soundstr, sizeof(soundstr), DEFAULT_WIN_OBJECTIVE);
+				}
+			}
+			*/
+
+			if (soundstr[0])
+			{
+				trap_S_StartLocalSound(trap_S_RegisterSound(soundstr), CHAN_ANNOUNCER);
+			}
+		}
+	}
+}
+
+siegeExtended_t cg_siegeExtendedData[MAX_CLIENTS];
+
+//parse a single extended siege data entry
+void CG_ParseSiegeExtendedDataEntry(const char *conStr)
+{
+	char s[MAX_STRING_CHARS];
+	char *str = (char *)conStr;
+	int argParses = 0;
+	int i;
+	int maxAmmo = 0, clNum = -1, health = 1, maxhealth = 1, ammo = 1;
+	centity_t *cent;
+
+	if (!conStr || !conStr[0])
+	{
+		return;
+	}
+
+	while (*str && argParses < 4)
+	{
+		i = 0;
+        while (*str && *str != '|')
+		{
+			s[i] = *str;
+			i++;
+			*str++;
+		}
+		s[i] = 0;
+        switch (argParses)
+		{
+		case 0:
+			clNum = atoi(s);
+			break;
+		case 1:
+			health = atoi(s);
+			break;
+		case 2:
+			maxhealth = atoi(s);
+			break;
+		case 3:
+			ammo = atoi(s);
+			break;
+		default:
+			break;
+		}
+		argParses++;
+		str++;
+	}
+
+	if (clNum < 0 || clNum >= MAX_CLIENTS)
+	{
+		return;
+	}
+
+	cg_siegeExtendedData[clNum].health = health;
+	cg_siegeExtendedData[clNum].maxhealth = maxhealth;
+	cg_siegeExtendedData[clNum].ammo = ammo;
+
+	cent = &cg_entities[clNum];
+
+	maxAmmo = ammoData[weaponData[cent->currentState.weapon].ammoIndex].max;
+	if ( (cent->currentState.eFlags & EF_DOUBLE_AMMO) )
+	{
+		maxAmmo *= 2.0f;
+	}
+	if (ammo >= 0 && ammo <= maxAmmo )
+	{ //assure the weapon number is valid and not over max
+		//keep the weapon so if it changes before our next ext data update we'll know
+		//that the ammo is not applicable.
+		cg_siegeExtendedData[clNum].weapon = cent->currentState.weapon;
+	}
+	else
+	{ //not valid? Oh well, just invalidate the weapon too then so we don't display ammo
+		cg_siegeExtendedData[clNum].weapon = -1;
+	}
+
+	cg_siegeExtendedData[clNum].lastUpdated = cg.time;
+}
+
+//parse incoming siege data, see counterpart in g_saga.c
+void CG_ParseSiegeExtendedData(void)
+{
+	int numEntries = trap_Argc();
+	int i = 0;
+
+	if (numEntries < 1)
+	{
+		assert(!"Bad numEntries for sxd");
+		return;
+	}
+
+	while (i < numEntries)
+	{
+		CG_ParseSiegeExtendedDataEntry(CG_Argv(i+1));
+		i++;
+	}
+}
+
+void CG_SetSiegeTimerCvar ( int msec )
+{
+	int seconds;
+	int mins;
+	int tens;
+
+	seconds = msec / 1000;
+	mins = seconds / 60;
+	seconds -= mins * 60;
+	tens = seconds / 10;
+	seconds -= tens * 10;
+
+	trap_Cvar_Set("ui_siegeTimer", va( "%i:%i%i", mins, tens, seconds ) );
+}
diff --git a/codemp/cgame/cg_scoreboard.c b/codemp/cgame/cg_scoreboard.c
new file mode 100644
index 0000000..0387036
--- /dev/null
+++ b/codemp/cgame/cg_scoreboard.c
@@ -0,0 +1,639 @@
+// Copyright (C) 1999-2000 Id Software, Inc.
+//
+// cg_scoreboard -- draw the scoreboard on top of the game screen
+#include "cg_local.h"
+#include "../ui/ui_shared.h"
+#include "../game/bg_saga.h"
+
+#define	SCOREBOARD_X		(0)
+
+#define SB_HEADER			86
+#define SB_TOP				(SB_HEADER+32)
+
+// Where the status bar starts, so we don't overwrite it
+#define SB_STATUSBAR		420
+
+#define SB_NORMAL_HEIGHT	25
+#define SB_INTER_HEIGHT		15 // interleaved height
+
+#define SB_MAXCLIENTS_NORMAL  ((SB_STATUSBAR - SB_TOP) / SB_NORMAL_HEIGHT)
+#define SB_MAXCLIENTS_INTER   ((SB_STATUSBAR - SB_TOP) / SB_INTER_HEIGHT - 1)
+
+// Used when interleaved
+
+
+
+#define SB_LEFT_BOTICON_X	(SCOREBOARD_X+0)
+#define SB_LEFT_HEAD_X		(SCOREBOARD_X+32)
+#define SB_RIGHT_BOTICON_X	(SCOREBOARD_X+64)
+#define SB_RIGHT_HEAD_X		(SCOREBOARD_X+96)
+// Normal
+#define SB_BOTICON_X		(SCOREBOARD_X+32)
+#define SB_HEAD_X			(SCOREBOARD_X+64)
+
+#define SB_SCORELINE_X		100
+#define SB_SCORELINE_WIDTH	(640 - SB_SCORELINE_X * 2)
+
+#define SB_RATING_WIDTH	    0 // (6 * BIGCHAR_WIDTH)
+#define SB_NAME_X			(SB_SCORELINE_X)
+#define SB_SCORE_X			(SB_SCORELINE_X + .55 * SB_SCORELINE_WIDTH)
+#define SB_PING_X			(SB_SCORELINE_X + .70 * SB_SCORELINE_WIDTH)
+#define SB_TIME_X			(SB_SCORELINE_X + .85 * SB_SCORELINE_WIDTH)
+
+// The new and improved score board
+//
+// In cases where the number of clients is high, the score board heads are interleaved
+// here's the layout
+
+//
+//	0   32   80  112  144   240  320  400   <-- pixel position
+//  bot head bot head score ping time name
+//  
+//  wins/losses are drawn on bot icon now
+
+static qboolean localClient; // true if local client has been displayed
+
+
+							 /*
+=================
+CG_DrawScoreboard
+=================
+*/
+static void CG_DrawClientScore( int y, score_t *score, float *color, float fade, qboolean largeFormat ) 
+{
+	//vec3_t	headAngles;
+	clientInfo_t	*ci;
+	int iconx, headx;
+	float		scale;
+
+	if ( largeFormat )
+	{
+		scale = 1.0f;
+	}
+	else
+	{
+		scale = 0.75f;
+	}
+
+	if ( score->client < 0 || score->client >= cgs.maxclients ) {
+		Com_Printf( "Bad score->client: %i\n", score->client );
+		return;
+	}
+	
+	ci = &cgs.clientinfo[score->client];
+
+	iconx = SB_BOTICON_X + (SB_RATING_WIDTH / 2);
+	headx = SB_HEAD_X + (SB_RATING_WIDTH / 2);
+
+	// draw the handicap or bot skill marker (unless player has flag)
+	if ( ci->powerups & ( 1 << PW_NEUTRALFLAG ) )
+	{
+		if( largeFormat )
+		{
+			CG_DrawFlagModel( iconx, y - ( 32 - BIGCHAR_HEIGHT ) / 2, 32, 32, TEAM_FREE, qfalse );
+		}
+		else
+		{
+			CG_DrawFlagModel( iconx, y, 16, 16, TEAM_FREE, qfalse );
+		}
+	}
+	else if ( ci->powerups & ( 1 << PW_REDFLAG ) )
+	{
+		if( largeFormat )
+		{
+			CG_DrawFlagModel( iconx*cgs.screenXScale, y*cgs.screenYScale, 32*cgs.screenXScale, 32*cgs.screenYScale, TEAM_RED, qfalse );
+		}
+		else
+		{
+			CG_DrawFlagModel( iconx*cgs.screenXScale, y*cgs.screenYScale, 32*cgs.screenXScale, 32*cgs.screenYScale, TEAM_RED, qfalse );
+		}
+	}
+	else if ( ci->powerups & ( 1 << PW_BLUEFLAG ) )
+	{
+		if( largeFormat )
+		{
+			CG_DrawFlagModel( iconx*cgs.screenXScale, y*cgs.screenYScale, 32*cgs.screenXScale, 32*cgs.screenYScale, TEAM_BLUE, qfalse );
+		}
+		else
+		{
+			CG_DrawFlagModel( iconx*cgs.screenXScale, y*cgs.screenYScale, 32*cgs.screenXScale, 32*cgs.screenYScale, TEAM_BLUE, qfalse );
+		}
+	}
+	else if (cgs.gametype == GT_POWERDUEL &&
+		(ci->duelTeam == DUELTEAM_LONE || ci->duelTeam == DUELTEAM_DOUBLE))
+	{
+		if (ci->duelTeam == DUELTEAM_LONE)
+		{
+			CG_DrawPic ( iconx, y, 32, 32, trap_R_RegisterShaderNoMip ( "gfx/mp/pduel_icon_lone" ) );
+		}
+		else
+		{
+			CG_DrawPic ( iconx, y, 32, 32, trap_R_RegisterShaderNoMip ( "gfx/mp/pduel_icon_double" ) );
+		}
+	}
+	else if (cgs.gametype == GT_SIEGE)
+	{ //try to draw the shader for this class on the scoreboard
+		if (ci->siegeIndex != -1)
+		{
+			siegeClass_t *scl = &bgSiegeClasses[ci->siegeIndex];
+
+			if (scl->classShader)
+			{
+				CG_DrawPic (iconx, y, largeFormat?24:12, largeFormat?24:12, scl->classShader);
+			}
+		}
+	}
+	else
+	{
+		// draw the wins / losses
+		/*
+		if ( cgs.gametype == GT_DUEL || cgs.gametype == GT_POWERDUEL ) 
+		{
+			CG_DrawSmallStringColor( iconx, y + SMALLCHAR_HEIGHT/2, va("%i/%i", ci->wins, ci->losses ), color );
+		}
+		*/
+		//rww - in duel, we now show wins/losses in place of "frags". This is because duel now defaults to 1 kill per round.
+	}
+
+	// highlight your position
+	if ( score->client == cg.snap->ps.clientNum ) 
+	{
+		float	hcolor[4];
+		int		rank;
+
+		localClient = qtrue;
+
+		if ( cg.snap->ps.persistant[PERS_TEAM] == TEAM_SPECTATOR 
+			|| cgs.gametype >= GT_TEAM ) {
+			rank = -1;
+		} else {
+			rank = cg.snap->ps.persistant[PERS_RANK] & ~RANK_TIED_FLAG;
+		}
+		if ( rank == 0 ) {
+			hcolor[0] = 0;
+			hcolor[1] = 0;
+			hcolor[2] = 0.7f;
+		} else if ( rank == 1 ) {
+			hcolor[0] = 0.7f;
+			hcolor[1] = 0;
+			hcolor[2] = 0;
+		} else if ( rank == 2 ) {
+			hcolor[0] = 0.7f;
+			hcolor[1] = 0.7f;
+			hcolor[2] = 0;
+		} else {
+			hcolor[0] = 0.7f;
+			hcolor[1] = 0.7f;
+			hcolor[2] = 0.7f;
+		}
+
+		hcolor[3] = fade * 0.7;
+		CG_FillRect( SB_SCORELINE_X - 5, y + 2, 640 - SB_SCORELINE_X * 2 + 10, largeFormat?SB_NORMAL_HEIGHT:SB_INTER_HEIGHT, hcolor );
+	}
+
+	CG_Text_Paint (SB_NAME_X, y, 0.9f * scale, colorWhite, ci->name,0, 0, ITEM_TEXTSTYLE_OUTLINED, FONT_MEDIUM );
+
+	if ( score->ping != -1 )
+	{
+		if ( ci->team != TEAM_SPECTATOR || cgs.gametype == GT_DUEL || cgs.gametype == GT_POWERDUEL )
+		{
+			if (cgs.gametype == GT_DUEL || cgs.gametype == GT_POWERDUEL)
+			{
+				CG_Text_Paint (SB_SCORE_X, y, 1.0f * scale, colorWhite, va("%i/%i", ci->wins, ci->losses),0, 0, ITEM_TEXTSTYLE_OUTLINED, FONT_SMALL );
+			}
+			else
+			{
+				CG_Text_Paint (SB_SCORE_X, y, 1.0f * scale, colorWhite, va("%i", score->score),0, 0, ITEM_TEXTSTYLE_OUTLINED, FONT_SMALL );
+			}
+		}
+
+		CG_Text_Paint (SB_PING_X, y, 1.0f * scale, colorWhite, va("%i", score->ping),0, 0, ITEM_TEXTSTYLE_OUTLINED, FONT_SMALL );	
+		CG_Text_Paint (SB_TIME_X, y, 1.0f * scale, colorWhite, va("%i", score->time),0, 0, ITEM_TEXTSTYLE_OUTLINED, FONT_SMALL );		
+	}
+	else
+	{
+		CG_Text_Paint (SB_SCORE_X, y, 1.0f * scale, colorWhite, "-",0, 0, ITEM_TEXTSTYLE_OUTLINED, FONT_SMALL );
+		CG_Text_Paint (SB_PING_X, y, 1.0f * scale, colorWhite, "-",0, 0, ITEM_TEXTSTYLE_OUTLINED, FONT_SMALL );	
+		CG_Text_Paint (SB_TIME_X, y, 1.0f * scale, colorWhite, "-",0, 0, ITEM_TEXTSTYLE_OUTLINED, FONT_SMALL );
+	}
+
+	// add the "ready" marker for intermission exiting
+	if ( cg.snap->ps.stats[ STAT_CLIENTS_READY ] & ( 1 << score->client ) ) 
+	{
+		CG_Text_Paint (SB_NAME_X - 64, y + 2, 0.7f * scale, colorWhite, CG_GetStringEdString("MP_INGAME", "READY"),0, 0, ITEM_TEXTSTYLE_OUTLINED, FONT_MEDIUM );
+	}
+}
+
+/*
+=================
+CG_TeamScoreboard
+=================
+*/
+static int CG_TeamScoreboard( int y, team_t team, float fade, int maxClients, int lineHeight, qboolean countOnly ) 
+{
+	int		i;
+	score_t	*score;
+	float	color[4];
+	int		count;
+	clientInfo_t	*ci;
+
+	color[0] = color[1] = color[2] = 1.0;
+	color[3] = fade;
+
+	count = 0;
+	for ( i = 0 ; i < cg.numScores && count < maxClients ; i++ ) {
+		score = &cg.scores[i];
+		ci = &cgs.clientinfo[ score->client ];
+
+		if ( team != ci->team ) {
+			continue;
+		}
+
+		if ( !countOnly )
+		{
+			CG_DrawClientScore( y + lineHeight * count, score, color, fade, lineHeight == SB_NORMAL_HEIGHT );
+		}
+
+		count++;
+	}
+
+	return count;
+}
+
+int	CG_GetClassCount(team_t team,int siegeClass )
+{
+	int i = 0;
+	int count = 0;
+	clientInfo_t	*ci;
+	siegeClass_t *scl;
+
+	for ( i = 0 ; i < cgs.maxclients ; i++ )
+	{
+		ci = &cgs.clientinfo[ i ];
+
+		if ((!ci->infoValid) || ( team != ci->team ))
+		{
+			continue;
+		}
+
+		scl = &bgSiegeClasses[ci->siegeIndex];
+
+		// Correct class?
+		if ( siegeClass != scl->classShader )
+		{
+			continue;
+		}
+
+		count++;
+	}
+
+ 	return count;
+
+}
+
+int CG_GetTeamNonScoreCount(team_t team)
+{
+	int i = 0,count=0;
+	clientInfo_t	*ci;
+
+	for ( i = 0 ; i < cgs.maxclients ; i++ )
+	{
+		ci = &cgs.clientinfo[ i ];
+
+		if ( (!ci->infoValid) || (team != ci->team && team != ci->siegeDesiredTeam) )
+		{
+			continue;
+		}
+
+		count++;
+	}
+
+ 	return count;
+}
+
+int CG_GetTeamCount(team_t team, int maxClients)
+{
+	int i = 0;
+	int count = 0;
+	clientInfo_t	*ci;
+	score_t	*score;
+
+	for ( i = 0 ; i < cg.numScores && count < maxClients ; i++ )
+	{
+		score = &cg.scores[i];
+		ci = &cgs.clientinfo[ score->client ];
+
+		if ( team != ci->team )
+		{
+			continue;
+		}
+
+		count++;
+	}
+
+	return count;
+
+}
+/*
+=================
+CG_DrawScoreboard
+
+Draw the normal in-game scoreboard
+=================
+*/
+int cg_siegeWinTeam = 0;
+qboolean CG_DrawOldScoreboard( void ) {
+	int		x, y, w, i, n1, n2;
+	float	fade;
+	float	*fadeColor;
+	char	*s;
+	int maxClients;
+	int lineHeight;
+	int topBorderSize, bottomBorderSize;
+
+	// don't draw amuthing if the menu or console is up
+	if ( cg_paused.integer ) {
+		cg.deferredPlayerLoading = 0;
+		return qfalse;
+	}
+
+	// don't draw scoreboard during death while warmup up
+	if ( cg.warmup && !cg.showScores ) {
+		return qfalse;
+	}
+
+	if ( cg.showScores || cg.predictedPlayerState.pm_type == PM_DEAD ||
+		 cg.predictedPlayerState.pm_type == PM_INTERMISSION ) {
+		fade = 1.0;
+		fadeColor = colorWhite;
+	} else {
+		fadeColor = CG_FadeColor( cg.scoreFadeTime, FADE_TIME );
+		
+		if ( !fadeColor ) {
+			// next time scoreboard comes up, don't print killer
+			cg.deferredPlayerLoading = 0;
+			cg.killerName[0] = 0;
+			return qfalse;
+		}
+		fade = *fadeColor;
+	}
+
+	// fragged by ... line
+	// or if in intermission and duel, prints the winner of the duel round
+	if ((cgs.gametype == GT_DUEL || cgs.gametype == GT_POWERDUEL) && cgs.duelWinner != -1 &&
+		cg.predictedPlayerState.pm_type == PM_INTERMISSION)
+	{
+		s = va("%s^7 %s", cgs.clientinfo[cgs.duelWinner].name, CG_GetStringEdString("MP_INGAME", "DUEL_WINS") );
+		/*w = CG_DrawStrlen( s ) * BIGCHAR_WIDTH;
+		x = ( SCREEN_WIDTH - w ) / 2;
+		y = 40;
+		CG_DrawBigString( x, y, s, fade );
+		*/
+		x = ( SCREEN_WIDTH ) / 2;
+		y = 40;
+		CG_Text_Paint ( x - CG_Text_Width ( s, 1.0f, FONT_MEDIUM ) / 2, y, 1.0f, colorWhite, s, 0, 0, ITEM_TEXTSTYLE_OUTLINED, FONT_MEDIUM );
+	}
+	else if ((cgs.gametype == GT_DUEL || cgs.gametype == GT_POWERDUEL) && cgs.duelist1 != -1 && cgs.duelist2 != -1 &&
+		cg.predictedPlayerState.pm_type == PM_INTERMISSION)
+	{
+		if (cgs.gametype == GT_POWERDUEL && cgs.duelist3 != -1)
+		{
+			s = va("%s^7 %s %s^7 %s %s", cgs.clientinfo[cgs.duelist1].name, CG_GetStringEdString("MP_INGAME", "SPECHUD_VERSUS"), cgs.clientinfo[cgs.duelist2].name, CG_GetStringEdString("MP_INGAME", "AND"), cgs.clientinfo[cgs.duelist3].name );
+		}
+		else
+		{
+			s = va("%s^7 %s %s", cgs.clientinfo[cgs.duelist1].name, CG_GetStringEdString("MP_INGAME", "SPECHUD_VERSUS"), cgs.clientinfo[cgs.duelist2].name );
+		}
+		/*w = CG_DrawStrlen( s ) * BIGCHAR_WIDTH;
+		x = ( SCREEN_WIDTH - w ) / 2;
+		y = 40;
+		CG_DrawBigString( x, y, s, fade );
+		*/
+		x = ( SCREEN_WIDTH ) / 2;
+		y = 40;
+		CG_Text_Paint ( x - CG_Text_Width ( s, 1.0f, FONT_MEDIUM ) / 2, y, 1.0f, colorWhite, s, 0, 0, ITEM_TEXTSTYLE_OUTLINED, FONT_MEDIUM );
+	}
+	else if ( cg.killerName[0] ) {
+		s = va("%s %s", CG_GetStringEdString("MP_INGAME", "KILLEDBY"), cg.killerName );
+		/*w = CG_DrawStrlen( s ) * BIGCHAR_WIDTH;
+		x = ( SCREEN_WIDTH - w ) / 2;
+		y = 40;
+		CG_DrawBigString( x, y, s, fade );
+		*/
+		x = ( SCREEN_WIDTH ) / 2;
+		y = 40;
+		CG_Text_Paint ( x - CG_Text_Width ( s, 1.0f, FONT_MEDIUM ) / 2, y, 1.0f, colorWhite, s, 0, 0, ITEM_TEXTSTYLE_OUTLINED, FONT_MEDIUM );
+	}
+
+	// current rank
+	if (cgs.gametype == GT_POWERDUEL)
+	{ //do nothing?
+	}
+	else if ( cgs.gametype < GT_TEAM) {
+		if (cg.snap->ps.persistant[PERS_TEAM] != TEAM_SPECTATOR ) 
+		{
+			char sPlace[256];
+			char sOf[256];
+			char sWith[256];
+
+			trap_SP_GetStringTextString("MP_INGAME_PLACE",	sPlace,	sizeof(sPlace));
+			trap_SP_GetStringTextString("MP_INGAME_OF",		sOf,	sizeof(sOf));
+			trap_SP_GetStringTextString("MP_INGAME_WITH",	sWith,	sizeof(sWith));
+
+			s = va("%s %s (%s %i) %s %i",
+				CG_PlaceString( cg.snap->ps.persistant[PERS_RANK] + 1 ),
+				sPlace,
+				sOf,
+				cg.numScores,
+				sWith,
+				cg.snap->ps.persistant[PERS_SCORE] );
+			w = CG_DrawStrlen( s ) * BIGCHAR_WIDTH;
+			x = ( SCREEN_WIDTH ) / 2;
+			y = 60;
+			//CG_DrawBigString( x, y, s, fade );
+			UI_DrawProportionalString(x, y, s, UI_CENTER|UI_DROPSHADOW, colorTable[CT_WHITE]);
+		}
+	}
+	else if (cgs.gametype != GT_SIEGE)
+	{
+		if ( cg.teamScores[0] == cg.teamScores[1] ) {
+			s = va("%s %i", CG_GetStringEdString("MP_INGAME", "TIEDAT"), cg.teamScores[0] );
+		} else if ( cg.teamScores[0] >= cg.teamScores[1] ) {
+			s = va("%s, %i / %i", CG_GetStringEdString("MP_INGAME", "RED_LEADS"), cg.teamScores[0], cg.teamScores[1] );
+		} else {
+			s = va("%s, %i / %i", CG_GetStringEdString("MP_INGAME", "BLUE_LEADS"), cg.teamScores[1], cg.teamScores[0] );
+		}
+
+		x = ( SCREEN_WIDTH ) / 2;
+		y = 60;
+		
+		CG_Text_Paint ( x - CG_Text_Width ( s, 1.0f, FONT_MEDIUM ) / 2, y, 1.0f, colorWhite, s, 0, 0, ITEM_TEXTSTYLE_OUTLINED, FONT_MEDIUM );
+	}
+	else if (cgs.gametype == GT_SIEGE && (cg_siegeWinTeam == 1 || cg_siegeWinTeam == 2))
+	{
+		if (cg_siegeWinTeam == 1)
+		{
+			s = va("%s", CG_GetStringEdString("MP_INGAME", "SIEGETEAM1WIN") );
+		}
+		else
+		{
+			s = va("%s", CG_GetStringEdString("MP_INGAME", "SIEGETEAM2WIN") );
+		}
+
+		x = ( SCREEN_WIDTH ) / 2;
+		y = 60;
+		
+		CG_Text_Paint ( x - CG_Text_Width ( s, 1.0f, FONT_MEDIUM ) / 2, y, 1.0f, colorWhite, s, 0, 0, ITEM_TEXTSTYLE_OUTLINED, FONT_MEDIUM );
+	}
+
+	// scoreboard
+	y = SB_HEADER;
+
+	CG_DrawPic ( SB_SCORELINE_X - 40, y - 5, SB_SCORELINE_WIDTH + 80, 40, trap_R_RegisterShaderNoMip ( "gfx/menus/menu_buttonback.tga" ) );
+
+	CG_Text_Paint ( SB_NAME_X, y, 1.0f, colorWhite, CG_GetStringEdString("MP_INGAME", "NAME"),0, 0, ITEM_TEXTSTYLE_OUTLINED, FONT_MEDIUM );
+	if (cgs.gametype == GT_DUEL || cgs.gametype == GT_POWERDUEL)
+	{
+		char sWL[100];
+		trap_SP_GetStringTextString("MP_INGAME_W_L", sWL,	sizeof(sWL));
+
+		CG_Text_Paint ( SB_SCORE_X, y, 1.0f, colorWhite, sWL, 0, 0, ITEM_TEXTSTYLE_OUTLINED, FONT_MEDIUM );
+	}
+	else
+	{
+		CG_Text_Paint ( SB_SCORE_X, y, 1.0f, colorWhite, CG_GetStringEdString("MP_INGAME", "SCORE"), 0, 0, ITEM_TEXTSTYLE_OUTLINED, FONT_MEDIUM );
+	}
+	CG_Text_Paint ( SB_PING_X, y, 1.0f, colorWhite, CG_GetStringEdString("MP_INGAME", "PING"), 0, 0, ITEM_TEXTSTYLE_OUTLINED, FONT_MEDIUM );
+	CG_Text_Paint ( SB_TIME_X, y, 1.0f, colorWhite, CG_GetStringEdString("MP_INGAME", "TIME"), 0, 0, ITEM_TEXTSTYLE_OUTLINED, FONT_MEDIUM );
+
+	y = SB_TOP;
+
+	// If there are more than SB_MAXCLIENTS_NORMAL, use the interleaved scores
+	if ( cg.numScores > SB_MAXCLIENTS_NORMAL ) {
+		maxClients = SB_MAXCLIENTS_INTER;
+		lineHeight = SB_INTER_HEIGHT;
+		topBorderSize = 8;
+		bottomBorderSize = 16;
+	} else {
+		maxClients = SB_MAXCLIENTS_NORMAL;
+		lineHeight = SB_NORMAL_HEIGHT;
+		topBorderSize = 8;
+		bottomBorderSize = 8;
+	}
+
+	localClient = qfalse;
+
+
+	//I guess this should end up being able to display 19 clients at once.
+	//In a team game, if there are 9 or more clients on the team not in the lead,
+	//we only want to show 10 of the clients on the team in the lead, so that we
+	//have room to display the clients in the lead on the losing team.
+
+	//I guess this can be accomplished simply by printing the first teams score with a maxClients
+	//value passed in related to how many players are on both teams.
+	if ( cgs.gametype >= GT_TEAM ) {
+		//
+		// teamplay scoreboard
+		//
+		y += lineHeight/2;
+
+		if ( cg.teamScores[0] >= cg.teamScores[1] ) {
+			int team1MaxCl = CG_GetTeamCount(TEAM_RED, maxClients);
+			int team2MaxCl = CG_GetTeamCount(TEAM_BLUE, maxClients);
+
+			if (team1MaxCl > 10 && (team1MaxCl+team2MaxCl) > maxClients)
+			{
+				team1MaxCl -= team2MaxCl;
+				//subtract as many as you have to down to 10, once we get there
+				//we just set it to 10
+
+				if (team1MaxCl < 10)
+				{
+					team1MaxCl = 10;
+				}
+			}
+
+			team2MaxCl = (maxClients-team1MaxCl); //team2 can display however many is left over after team1's display
+
+			n1 = CG_TeamScoreboard( y, TEAM_RED, fade, team1MaxCl, lineHeight, qtrue );
+			CG_DrawTeamBackground( SB_SCORELINE_X - 5, y - topBorderSize, 640 - SB_SCORELINE_X * 2 + 10, n1 * lineHeight + bottomBorderSize, 0.33f, TEAM_RED );
+			CG_TeamScoreboard( y, TEAM_RED, fade, team1MaxCl, lineHeight, qfalse );
+			y += (n1 * lineHeight) + BIGCHAR_HEIGHT;
+
+			//maxClients -= n1;
+
+			n2 = CG_TeamScoreboard( y, TEAM_BLUE, fade, team2MaxCl, lineHeight, qtrue );
+			CG_DrawTeamBackground( SB_SCORELINE_X - 5, y - topBorderSize, 640 - SB_SCORELINE_X * 2 + 10, n2 * lineHeight + bottomBorderSize, 0.33f, TEAM_BLUE );
+			CG_TeamScoreboard( y, TEAM_BLUE, fade, team2MaxCl, lineHeight, qfalse );
+			y += (n2 * lineHeight) + BIGCHAR_HEIGHT;
+
+			//maxClients -= n2;
+
+			maxClients -= (team1MaxCl+team2MaxCl);
+		} else {
+			int team1MaxCl = CG_GetTeamCount(TEAM_BLUE, maxClients);
+			int team2MaxCl = CG_GetTeamCount(TEAM_RED, maxClients);
+
+			if (team1MaxCl > 10 && (team1MaxCl+team2MaxCl) > maxClients)
+			{
+				team1MaxCl -= team2MaxCl;
+				//subtract as many as you have to down to 10, once we get there
+				//we just set it to 10
+
+				if (team1MaxCl < 10)
+				{
+					team1MaxCl = 10;
+				}
+			}
+
+			team2MaxCl = (maxClients-team1MaxCl); //team2 can display however many is left over after team1's display
+
+			n1 = CG_TeamScoreboard( y, TEAM_BLUE, fade, team1MaxCl, lineHeight, qtrue );
+			CG_DrawTeamBackground( SB_SCORELINE_X - 5, y - topBorderSize, 640 - SB_SCORELINE_X * 2 + 10, n1 * lineHeight + bottomBorderSize, 0.33f, TEAM_BLUE );
+			CG_TeamScoreboard( y, TEAM_BLUE, fade, team1MaxCl, lineHeight, qfalse );
+			y += (n1 * lineHeight) + BIGCHAR_HEIGHT;
+
+			//maxClients -= n1;
+
+			n2 = CG_TeamScoreboard( y, TEAM_RED, fade, team2MaxCl, lineHeight, qtrue );
+			CG_DrawTeamBackground( SB_SCORELINE_X - 5, y - topBorderSize, 640 - SB_SCORELINE_X * 2 + 10, n2 * lineHeight + bottomBorderSize, 0.33f, TEAM_RED );
+			CG_TeamScoreboard( y, TEAM_RED, fade, team2MaxCl, lineHeight, qfalse );
+			y += (n2 * lineHeight) + BIGCHAR_HEIGHT;
+
+			//maxClients -= n2;
+
+			maxClients -= (team1MaxCl+team2MaxCl);
+		}
+		n1 = CG_TeamScoreboard( y, TEAM_SPECTATOR, fade, maxClients, lineHeight, qfalse );
+		y += (n1 * lineHeight) + BIGCHAR_HEIGHT;
+
+	} else {
+		//
+		// free for all scoreboard
+		//
+		n1 = CG_TeamScoreboard( y, TEAM_FREE, fade, maxClients, lineHeight, qfalse );
+		y += (n1 * lineHeight) + BIGCHAR_HEIGHT;
+		n2 = CG_TeamScoreboard( y, TEAM_SPECTATOR, fade, maxClients - n1, lineHeight, qfalse );
+		y += (n2 * lineHeight) + BIGCHAR_HEIGHT;
+	}
+
+	if (!localClient) {
+		// draw local client at the bottom
+		for ( i = 0 ; i < cg.numScores ; i++ ) {
+			if ( cg.scores[i].client == cg.snap->ps.clientNum ) {
+				CG_DrawClientScore( y, &cg.scores[i], fadeColor, fade, lineHeight == SB_NORMAL_HEIGHT );
+				break;
+			}
+		}
+	}
+
+	// load any models that have been deferred
+	if ( ++cg.deferredPlayerLoading > 10 ) {
+		CG_LoadDeferredPlayers();
+	}
+
+	return qtrue;
+}
+
+//================================================================================
+
diff --git a/codemp/cgame/cg_servercmds.c b/codemp/cgame/cg_servercmds.c
new file mode 100644
index 0000000..eb8faab
--- /dev/null
+++ b/codemp/cgame/cg_servercmds.c
@@ -0,0 +1,1687 @@
+// Copyright (C) 1999-2000 Id Software, Inc.
+//
+// cg_servercmds.c -- reliably sequenced text commands sent by the server
+// these are processed at snapshot transition time, so there will definately
+// be a valid snapshot this frame
+
+#include "cg_local.h"
+#include "../../ui/menudef.h"
+#if !defined(CL_LIGHT_H_INC)
+	#include "cg_lights.h"
+#endif
+#include "..\ghoul2\g2.h"
+#include "../ui/ui_public.h"
+
+/*
+=================
+CG_ParseScores
+
+=================
+*/
+static void CG_ParseScores( void ) {
+	int		i, powerups, readScores;
+
+	cg.numScores = atoi( CG_Argv( 1 ) );
+
+	readScores = cg.numScores;
+
+	if (readScores > MAX_CLIENT_SCORE_SEND)
+	{
+		readScores = MAX_CLIENT_SCORE_SEND;
+	}
+
+	if ( cg.numScores > MAX_CLIENTS ) {
+		cg.numScores = MAX_CLIENTS;
+	}
+
+	cg.numScores = readScores;
+
+	cg.teamScores[0] = atoi( CG_Argv( 2 ) );
+	cg.teamScores[1] = atoi( CG_Argv( 3 ) );
+
+	memset( cg.scores, 0, sizeof( cg.scores ) );
+	for ( i = 0 ; i < readScores ; i++ ) {
+		//
+		cg.scores[i].client = atoi( CG_Argv( i * 14 + 4 ) );
+		cg.scores[i].score = atoi( CG_Argv( i * 14 + 5 ) );
+		cg.scores[i].ping = atoi( CG_Argv( i * 14 + 6 ) );
+		cg.scores[i].time = atoi( CG_Argv( i * 14 + 7 ) );
+		cg.scores[i].scoreFlags = atoi( CG_Argv( i * 14 + 8 ) );
+		powerups = atoi( CG_Argv( i * 14 + 9 ) );
+		cg.scores[i].accuracy = atoi(CG_Argv(i * 14 + 10));
+		cg.scores[i].impressiveCount = atoi(CG_Argv(i * 14 + 11));
+		cg.scores[i].excellentCount = atoi(CG_Argv(i * 14 + 12));
+		cg.scores[i].guantletCount = atoi(CG_Argv(i * 14 + 13));
+		cg.scores[i].defendCount = atoi(CG_Argv(i * 14 + 14));
+		cg.scores[i].assistCount = atoi(CG_Argv(i * 14 + 15));
+		cg.scores[i].perfect = atoi(CG_Argv(i * 14 + 16));
+		cg.scores[i].captures = atoi(CG_Argv(i * 14 + 17));
+
+		if ( cg.scores[i].client < 0 || cg.scores[i].client >= MAX_CLIENTS ) {
+			cg.scores[i].client = 0;
+		}
+		cgs.clientinfo[ cg.scores[i].client ].score = cg.scores[i].score;
+		cgs.clientinfo[ cg.scores[i].client ].powerups = powerups;
+
+		cg.scores[i].team = cgs.clientinfo[cg.scores[i].client].team;
+	}
+	CG_SetScoreSelection(NULL);
+}
+
+/*
+=================
+CG_ParseTeamInfo
+
+=================
+*/
+static void CG_ParseTeamInfo( void ) {
+	int		i;
+	int		client;
+
+	numSortedTeamPlayers = atoi( CG_Argv( 1 ) );
+
+	for ( i = 0 ; i < numSortedTeamPlayers ; i++ ) {
+		client = atoi( CG_Argv( i * 6 + 2 ) );
+
+		sortedTeamPlayers[i] = client;
+
+		cgs.clientinfo[ client ].location = atoi( CG_Argv( i * 6 + 3 ) );
+		cgs.clientinfo[ client ].health = atoi( CG_Argv( i * 6 + 4 ) );
+		cgs.clientinfo[ client ].armor = atoi( CG_Argv( i * 6 + 5 ) );
+		cgs.clientinfo[ client ].curWeapon = atoi( CG_Argv( i * 6 + 6 ) );
+		cgs.clientinfo[ client ].powerups = atoi( CG_Argv( i * 6 + 7 ) );
+	}
+}
+
+
+/*
+================
+CG_ParseServerinfo
+
+This is called explicitly when the gamestate is first received,
+and whenever the server updates any serverinfo flagged cvars
+================
+*/
+void CG_ParseServerinfo( void ) {
+	const char	*info;
+	const char	*tinfo;
+	char	*mapname;
+
+	info = CG_ConfigString( CS_SERVERINFO );
+
+	cgs.debugMelee = atoi( Info_ValueForKey( info, "g_debugMelee" ) ); //trap_Cvar_GetHiddenVarValue("g_iknowkungfu");
+	cgs.stepSlideFix = atoi( Info_ValueForKey( info, "g_stepSlideFix" ) );
+
+	cgs.noSpecMove = atoi( Info_ValueForKey( info, "g_noSpecMove" ) );
+
+	trap_Cvar_Set("bg_fighterAltControl", Info_ValueForKey( info, "bg_fighterAltControl" ));
+
+	cgs.siegeTeamSwitch = atoi( Info_ValueForKey( info, "g_siegeTeamSwitch" ) );
+
+	cgs.showDuelHealths = atoi( Info_ValueForKey( info, "g_showDuelHealths" ) );
+
+	cgs.gametype = atoi( Info_ValueForKey( info, "g_gametype" ) );
+	trap_Cvar_Set("g_gametype", va("%i", cgs.gametype));
+	cgs.needpass = atoi( Info_ValueForKey( info, "needpass" ) );
+	cgs.jediVmerc = atoi( Info_ValueForKey( info, "g_jediVmerc" ) );
+	cgs.wDisable = atoi( Info_ValueForKey( info, "wdisable" ) );
+	cgs.fDisable = atoi( Info_ValueForKey( info, "fdisable" ) );
+	cgs.dmflags = atoi( Info_ValueForKey( info, "dmflags" ) );
+	cgs.teamflags = atoi( Info_ValueForKey( info, "teamflags" ) );
+	cgs.fraglimit = atoi( Info_ValueForKey( info, "fraglimit" ) );
+	cgs.duel_fraglimit = atoi( Info_ValueForKey( info, "duel_fraglimit" ) );
+	cgs.capturelimit = atoi( Info_ValueForKey( info, "capturelimit" ) );
+	cgs.timelimit = atoi( Info_ValueForKey( info, "timelimit" ) );
+	cgs.maxclients = atoi( Info_ValueForKey( info, "sv_maxclients" ) );
+	mapname = Info_ValueForKey( info, "mapname" );
+
+	//rww - You must do this one here, Info_ValueForKey always uses the same memory pointer.
+	trap_Cvar_Set ( "ui_about_mapname", mapname );
+
+	Com_sprintf( cgs.mapname, sizeof( cgs.mapname ), "maps/%s.bsp", mapname );
+	Q_strncpyz( cgs.redTeam, Info_ValueForKey( info, "g_redTeam" ), sizeof(cgs.redTeam) );
+	trap_Cvar_Set("g_redTeam", cgs.redTeam);
+	Q_strncpyz( cgs.blueTeam, Info_ValueForKey( info, "g_blueTeam" ), sizeof(cgs.blueTeam) );
+	trap_Cvar_Set("g_blueTeam", cgs.blueTeam);
+
+	trap_Cvar_Set ( "ui_about_gametype", va("%i", cgs.gametype ) );
+	trap_Cvar_Set ( "ui_about_fraglimit", va("%i", cgs.fraglimit ) );
+	trap_Cvar_Set ( "ui_about_duellimit", va("%i", cgs.duel_fraglimit ) );
+	trap_Cvar_Set ( "ui_about_capturelimit", va("%i", cgs.capturelimit ) );
+	trap_Cvar_Set ( "ui_about_timelimit", va("%i", cgs.timelimit ) );
+	trap_Cvar_Set ( "ui_about_maxclients", va("%i", cgs.maxclients ) );
+	trap_Cvar_Set ( "ui_about_dmflags", va("%i", cgs.dmflags ) );
+	trap_Cvar_Set ( "ui_about_hostname", Info_ValueForKey( info, "sv_hostname" ) );
+	trap_Cvar_Set ( "ui_about_needpass", Info_ValueForKey( info, "g_needpass" ) );
+	trap_Cvar_Set ( "ui_about_botminplayers", Info_ValueForKey ( info, "bot_minplayers" ) );
+
+	//Set the siege teams based on what the server has for overrides.
+	trap_Cvar_Set("cg_siegeTeam1", Info_ValueForKey(info, "g_siegeTeam1"));
+	trap_Cvar_Set("cg_siegeTeam2", Info_ValueForKey(info, "g_siegeTeam2"));
+
+	tinfo = CG_ConfigString( CS_TERRAINS + 1 );
+	if ( !tinfo || !*tinfo )
+	{
+		cg.mInRMG = qfalse;
+	}
+	else
+	{
+		int weather = 0;
+
+		cg.mInRMG = qtrue;
+		trap_Cvar_Set("RMG", "1");
+
+		weather = atoi( Info_ValueForKey( info, "RMG_weather" ) );
+
+		trap_Cvar_Set("RMG_weather", va("%i", weather));
+
+		if (weather == 1 || weather == 2)
+		{
+			cg.mRMGWeather = qtrue;
+		}
+		else
+		{
+			cg.mRMGWeather = qfalse;
+		}
+	}
+}
+
+/*
+==================
+CG_ParseWarmup
+==================
+*/
+static void CG_ParseWarmup( void ) {
+	const char	*info;
+	int			warmup;
+
+	info = CG_ConfigString( CS_WARMUP );
+
+	warmup = atoi( info );
+	cg.warmupCount = -1;
+
+	cg.warmup = warmup;
+}
+
+/*
+================
+CG_SetConfigValues
+
+Called on load to set the initial values from configure strings
+================
+*/
+void CG_SetConfigValues( void ) 
+{
+	const char *s;
+	const char *str;
+
+	cgs.scores1 = atoi( CG_ConfigString( CS_SCORES1 ) );
+	cgs.scores2 = atoi( CG_ConfigString( CS_SCORES2 ) );
+	cgs.levelStartTime = atoi( CG_ConfigString( CS_LEVEL_START_TIME ) );
+	if( cgs.gametype == GT_CTF || cgs.gametype == GT_CTY ) {
+		s = CG_ConfigString( CS_FLAGSTATUS );
+		cgs.redflag = s[0] - '0';
+		cgs.blueflag = s[1] - '0';
+	}
+	cg.warmup = atoi( CG_ConfigString( CS_WARMUP ) );
+
+	// Track who the jedi master is
+	cgs.jediMaster = atoi ( CG_ConfigString ( CS_CLIENT_JEDIMASTER ) );
+	cgs.duelWinner = atoi ( CG_ConfigString ( CS_CLIENT_DUELWINNER ) );
+
+	str = CG_ConfigString(CS_CLIENT_DUELISTS);
+
+	if (str && str[0])
+	{
+		char buf[64];
+		int c = 0;
+		int i = 0;
+
+		while (str[i] && str[i] != '|')
+		{
+			buf[c] = str[i];
+			c++;
+			i++;
+		}
+		buf[c] = 0;
+
+		cgs.duelist1 = atoi ( buf );
+		c = 0;
+
+		i++;
+		while (str[i])
+		{
+			buf[c] = str[i];
+			c++;
+			i++;
+		}
+		buf[c] = 0;
+
+		cgs.duelist2 = atoi ( buf );
+	}
+}
+
+/*
+=====================
+CG_ShaderStateChanged
+=====================
+*/
+void CG_ShaderStateChanged(void) {
+	char originalShader[MAX_QPATH];
+	char newShader[MAX_QPATH];
+	char timeOffset[16];
+	const char *o;
+	char *n,*t;
+
+	o = CG_ConfigString( CS_SHADERSTATE );
+	while (o && *o) {
+		n = strstr(o, "=");
+		if (n && *n) {
+			strncpy(originalShader, o, n-o);
+			originalShader[n-o] = 0;
+			n++;
+			t = strstr(n, ":");
+			if (t && *t) {
+				strncpy(newShader, n, t-n);
+				newShader[t-n] = 0;
+			} else {
+				break;
+			}
+			t++;
+			o = strstr(t, "@");
+			if (o) {
+				strncpy(timeOffset, t, o-t);
+				timeOffset[o-t] = 0;
+				o++;
+				trap_R_RemapShader( originalShader, newShader, timeOffset );
+			}
+		} else {
+			break;
+		}
+	}
+}
+
+extern char *cg_customSoundNames[MAX_CUSTOM_SOUNDS];
+extern const char *cg_customCombatSoundNames[MAX_CUSTOM_COMBAT_SOUNDS];
+extern const char *cg_customExtraSoundNames[MAX_CUSTOM_EXTRA_SOUNDS];
+extern const char *cg_customJediSoundNames[MAX_CUSTOM_JEDI_SOUNDS];
+extern const char *cg_customDuelSoundNames[MAX_CUSTOM_DUEL_SOUNDS];
+
+static const char *GetCustomSoundForType(int setType, int index)
+{
+	switch (setType)
+	{
+	case 1:
+		return cg_customSoundNames[index];
+	case 2:
+		return cg_customCombatSoundNames[index];
+	case 3:
+		return cg_customExtraSoundNames[index];
+	case 4:
+		return cg_customJediSoundNames[index];
+	case 5:
+		return bg_customSiegeSoundNames[index];
+	case 6:
+		return cg_customDuelSoundNames[index];
+	default:
+		assert(0);
+		return NULL;
+	}
+}
+
+void SetCustomSoundForType(clientInfo_t *ci, int setType, int index, sfxHandle_t sfx)
+{
+	switch (setType)
+	{
+	case 1:
+		ci->sounds[index] = sfx;
+		break;
+	case 2:
+		ci->combatSounds[index] = sfx;
+		break;
+	case 3:
+		ci->extraSounds[index] = sfx;
+		break;
+	case 4:
+		ci->jediSounds[index] = sfx;
+		break;
+	case 5:
+		ci->siegeSounds[index] = sfx;
+		break;
+	case 6:
+		ci->duelSounds[index] = sfx;
+		break;
+	default:
+		assert(0);
+		break;
+	}
+}
+
+static void CG_RegisterCustomSounds(clientInfo_t *ci, int setType, const char *psDir)
+{
+	int iTableEntries = 0;
+	int i;
+
+	switch (setType)
+	{
+	case 1:
+		iTableEntries = MAX_CUSTOM_SOUNDS;
+		break;
+	case 2:
+		iTableEntries = MAX_CUSTOM_COMBAT_SOUNDS;
+		break;
+	case 3:
+		iTableEntries = MAX_CUSTOM_EXTRA_SOUNDS;
+		break;
+	case 4:
+		iTableEntries = MAX_CUSTOM_JEDI_SOUNDS;
+		break;
+	case 5:
+		iTableEntries = MAX_CUSTOM_SIEGE_SOUNDS;
+	default:
+		assert(0);
+		return;
+	}
+
+	for ( i = 0 ; i<iTableEntries; i++ ) 
+	{
+		sfxHandle_t hSFX;
+		const char *s = GetCustomSoundForType(setType, i);
+
+		if ( !s ) 
+		{
+			break;
+		}
+
+		s++;
+		hSFX = trap_S_RegisterSound( va("sound/chars/%s/misc/%s", psDir, s) );
+
+		if (hSFX == 0)
+		{
+			char modifiedSound[MAX_QPATH];
+			char *p;
+
+			strcpy(modifiedSound, s);
+			p = strchr(modifiedSound,'.');
+
+			if (p)
+			{
+				char testNumber[2];
+				p--;
+
+				//before we destroy it.. we want to see if this is actually a number.
+				//If it isn't a number then don't try decrementing and registering as
+				//it will only cause a disk hit (we don't try precaching such files)
+				testNumber[0] = *p;
+				testNumber[1] = 0;
+				if (atoi(testNumber))
+				{
+					*p = 0;
+
+					strcat(modifiedSound, "1.wav");
+
+					hSFX = trap_S_RegisterSound( va("sound/chars/%s/misc/%s", psDir, modifiedSound) );
+				}
+			}
+		}
+		
+		SetCustomSoundForType(ci, setType, i, hSFX);
+	}
+}
+
+void CG_PrecacheNPCSounds(const char *str)
+{
+	char sEnd[MAX_QPATH];
+	char pEnd[MAX_QPATH];
+	int i = 0;
+	int j = 0;
+	int k = 0;
+
+	k = 2;
+
+	while (str[k])
+	{
+		pEnd[k-2] = str[k];
+		k++;
+	}
+	pEnd[k-2] = 0;
+
+	while (i < 4) //4 types
+	{ //It would be better if we knew what type this actually was (extra, combat, jedi, etc).
+	  //But that would require extra configstring indexing and that is a bad thing.
+
+		while (j < MAX_CUSTOM_SOUNDS)
+		{
+			const char *s = GetCustomSoundForType(i+1, j);
+
+			if (s && s[0])
+			{ //whatever it is, try registering it under this folder.
+				k = 1;
+				while (s[k])
+				{
+					sEnd[k-1] = s[k];
+					k++;
+				}
+				sEnd[k-1] = 0;
+
+				trap_S_ShutUp(qtrue);
+				trap_S_RegisterSound( va("sound/chars/%s/misc/%s", pEnd, sEnd) );
+				trap_S_ShutUp(qfalse);
+			}
+			else
+			{ //move onto the next set
+				break;
+			}
+
+			j++;
+		}
+
+		j = 0;
+		i++;
+	}
+}
+
+void CG_HandleNPCSounds(centity_t *cent)
+{
+	if (!cent->npcClient)
+	{
+		return;
+	}
+
+	//standard
+	if (cent->currentState.csSounds_Std)
+	{
+		const char *s = CG_ConfigString( CS_SOUNDS + cent->currentState.csSounds_Std );
+
+		if (s && s[0])
+		{
+			char sEnd[MAX_QPATH];
+			int i = 2;
+			int j = 0;
+
+			//Parse past the initial "*" which indicates this is a custom sound, and the $ which indicates
+			//it is an NPC custom sound dir.
+			while (s[i])
+			{
+				sEnd[j] = s[i];
+				j++;
+				i++;
+			}
+			sEnd[j] = 0;
+
+			CG_RegisterCustomSounds(cent->npcClient, 1, sEnd);
+		}
+	}
+	else
+	{
+		memset(&cent->npcClient->sounds, 0, sizeof(cent->npcClient->sounds));
+	}
+
+	//combat
+	if (cent->currentState.csSounds_Combat)
+	{
+		const char *s = CG_ConfigString( CS_SOUNDS + cent->currentState.csSounds_Combat );
+
+		if (s && s[0])
+		{
+			char sEnd[MAX_QPATH];
+			int i = 2;
+			int j = 0;
+
+			//Parse past the initial "*" which indicates this is a custom sound, and the $ which indicates
+			//it is an NPC custom sound dir.
+			while (s[i])
+			{
+				sEnd[j] = s[i];
+				j++;
+				i++;
+			}
+			sEnd[j] = 0;
+
+			CG_RegisterCustomSounds(cent->npcClient, 2, sEnd);
+		}
+	}
+	else
+	{
+		memset(&cent->npcClient->combatSounds, 0, sizeof(cent->npcClient->combatSounds));
+	}
+
+	//extra
+	if (cent->currentState.csSounds_Extra)
+	{
+		const char *s = CG_ConfigString( CS_SOUNDS + cent->currentState.csSounds_Extra );
+
+		if (s && s[0])
+		{
+			char sEnd[MAX_QPATH];
+			int i = 2;
+			int j = 0;
+
+			//Parse past the initial "*" which indicates this is a custom sound, and the $ which indicates
+			//it is an NPC custom sound dir.
+			while (s[i])
+			{
+				sEnd[j] = s[i];
+				j++;
+				i++;
+			}
+			sEnd[j] = 0;
+
+			CG_RegisterCustomSounds(cent->npcClient, 3, sEnd);
+		}
+	}
+	else
+	{
+		memset(&cent->npcClient->extraSounds, 0, sizeof(cent->npcClient->extraSounds));
+	}
+
+	//jedi
+	if (cent->currentState.csSounds_Jedi)
+	{
+		const char *s = CG_ConfigString( CS_SOUNDS + cent->currentState.csSounds_Jedi );
+
+		if (s && s[0])
+		{
+			char sEnd[MAX_QPATH];
+			int i = 2;
+			int j = 0;
+
+			//Parse past the initial "*" which indicates this is a custom sound, and the $ which indicates
+			//it is an NPC custom sound dir.
+			while (s[i])
+			{
+				sEnd[j] = s[i];
+				j++;
+				i++;
+			}
+			sEnd[j] = 0;
+
+			CG_RegisterCustomSounds(cent->npcClient, 4, sEnd);
+		}
+	}
+	else
+	{
+		memset(&cent->npcClient->jediSounds, 0, sizeof(cent->npcClient->jediSounds));
+	}
+}
+
+int CG_HandleAppendedSkin(char *modelName);
+void CG_CacheG2AnimInfo(char *modelName);
+
+// nmckenzie: DUEL_HEALTH - fixme - we could really clean this up immensely with some helper functions.
+void SetDuelistHealthsFromConfigString ( const char *str ) {
+	char buf[64];
+	int c = 0;
+	int i = 0;
+
+	while (str[i] && str[i] != '|')
+	{
+		buf[c] = str[i];
+		c++;
+		i++;
+	}
+	buf[c] = 0;
+
+	cgs.duelist1health = atoi ( buf );
+
+	c = 0;
+	i++;
+	while (str[i] && str[i] != '|')
+	{
+		buf[c] = str[i];
+		c++;
+		i++;
+	}
+	buf[c] = 0;
+
+	cgs.duelist2health = atoi ( buf );
+
+	c = 0;
+	i++;
+	if ( str[i] == '!' )
+	{	// we only have 2 duelists, apparently.
+		cgs.duelist3health = -1;
+		return;
+	}
+
+	while (str[i] && str[i] != '|')
+	{
+		buf[c] = str[i];
+		c++;
+		i++;
+	}
+	buf[c] = 0;
+
+	cgs.duelist3health = atoi ( buf );
+}
+
+/*
+================
+CG_ConfigStringModified
+
+================
+*/
+extern int cgSiegeRoundState;
+extern int cgSiegeRoundTime;
+void CG_ParseSiegeObjectiveStatus(const char *str);
+void CG_ParseWeatherEffect(const char *str);
+extern void CG_ParseSiegeState(const char *str); //cg_main.c
+extern int cg_beatingSiegeTime;
+extern int cg_siegeWinTeam;
+static void CG_ConfigStringModified( void ) {
+	const char	*str;
+	int		num;
+
+	num = atoi( CG_Argv( 1 ) );
+
+	// get the gamestate from the client system, which will have the
+	// new configstring already integrated
+	trap_GetGameState( &cgs.gameState );
+
+	// look up the individual string that was modified
+	str = CG_ConfigString( num );
+
+	// do something with it if necessary
+	if ( num == CS_MUSIC ) {
+		CG_StartMusic( qtrue );
+	} else if ( num == CS_SERVERINFO ) {
+		CG_ParseServerinfo();
+	} else if ( num == CS_WARMUP ) {
+		CG_ParseWarmup();
+	} else if ( num == CS_SCORES1 ) {
+		cgs.scores1 = atoi( str );
+	} else if ( num == CS_SCORES2 ) {
+		cgs.scores2 = atoi( str );
+	} else if ( num == CS_CLIENT_JEDIMASTER ) {
+		cgs.jediMaster = atoi ( str );
+	}
+	else if ( num == CS_CLIENT_DUELWINNER )
+	{
+		cgs.duelWinner = atoi ( str );
+	}
+	else if ( num == CS_CLIENT_DUELISTS )
+	{
+		char buf[64];
+		int c = 0;
+		int i = 0;
+
+		while (str[i] && str[i] != '|')
+		{
+			buf[c] = str[i];
+			c++;
+			i++;
+		}
+		buf[c] = 0;
+
+		cgs.duelist1 = atoi ( buf );
+		c = 0;
+
+		i++;
+		while (str[i] && str[i] != '|')
+		{
+			buf[c] = str[i];
+			c++;
+			i++;
+		}
+		buf[c] = 0;
+
+		cgs.duelist2 = atoi ( buf );
+
+		if (str[i])
+		{
+			c = 0;
+			i++;
+
+			while (str[i])
+			{
+				buf[c] = str[i];
+				c++;
+				i++;
+			}
+			buf[c] = 0;
+
+			cgs.duelist3 = atoi(buf);
+		}
+	}
+	else if ( num == CS_CLIENT_DUELHEALTHS ) {	// nmckenzie: DUEL_HEALTH
+		SetDuelistHealthsFromConfigString(str);
+	}
+	else if ( num == CS_LEVEL_START_TIME ) {
+		cgs.levelStartTime = atoi( str );
+	} else if ( num == CS_VOTE_TIME ) {
+		cgs.voteTime = atoi( str );
+		cgs.voteModified = qtrue;
+	} else if ( num == CS_VOTE_YES ) {
+		cgs.voteYes = atoi( str );
+		cgs.voteModified = qtrue;
+	} else if ( num == CS_VOTE_NO ) {
+		cgs.voteNo = atoi( str );
+		cgs.voteModified = qtrue;
+	} else if ( num == CS_VOTE_STRING ) {
+		Q_strncpyz( cgs.voteString, str, sizeof( cgs.voteString ) );
+	} else if ( num >= CS_TEAMVOTE_TIME && num <= CS_TEAMVOTE_TIME + 1) {
+		cgs.teamVoteTime[num-CS_TEAMVOTE_TIME] = atoi( str );
+		cgs.teamVoteModified[num-CS_TEAMVOTE_TIME] = qtrue;
+	} else if ( num >= CS_TEAMVOTE_YES && num <= CS_TEAMVOTE_YES + 1) {
+		cgs.teamVoteYes[num-CS_TEAMVOTE_YES] = atoi( str );
+		cgs.teamVoteModified[num-CS_TEAMVOTE_YES] = qtrue;
+	} else if ( num >= CS_TEAMVOTE_NO && num <= CS_TEAMVOTE_NO + 1) {
+		cgs.teamVoteNo[num-CS_TEAMVOTE_NO] = atoi( str );
+		cgs.teamVoteModified[num-CS_TEAMVOTE_NO] = qtrue;
+	} else if ( num >= CS_TEAMVOTE_STRING && num <= CS_TEAMVOTE_STRING + 1) {
+		Q_strncpyz( cgs.teamVoteString[num-CS_TEAMVOTE_STRING], str, sizeof( cgs.teamVoteString ) );
+	} else if ( num == CS_INTERMISSION ) {
+		cg.intermissionStarted = atoi( str );
+	} else if ( num >= CS_MODELS && num < CS_MODELS+MAX_MODELS ) {
+		char modelName[MAX_QPATH];
+		strcpy(modelName, str);
+		if (strstr(modelName, ".glm") || modelName[0] == '$')
+		{ //Check to see if it has a custom skin attached.
+			CG_HandleAppendedSkin(modelName);
+			CG_CacheG2AnimInfo(modelName);
+		}
+
+		if (modelName[0] != '$' && modelName[0] != '@')
+		{ //don't register vehicle names and saber names as models.
+			cgs.gameModels[ num-CS_MODELS ] = trap_R_RegisterModel( modelName );
+		}
+		else
+		{
+            cgs.gameModels[ num-CS_MODELS ] = 0;
+		}
+// GHOUL2 Insert start
+		/*
+	} else if ( num >= CS_CHARSKINS && num < CS_CHARSKINS+MAX_CHARSKINS ) {
+		cgs.skins[ num-CS_CHARSKINS ] = trap_R_RegisterSkin( str );
+		*/
+		//rww - removed and replaced with CS_G2BONES
+// Ghoul2 Insert end
+	} else if ( num >= CS_SOUNDS && num < CS_SOUNDS+MAX_SOUNDS ) {
+		if ( str[0] != '*' ) {	// player specific sounds don't register here
+			cgs.gameSounds[ num-CS_SOUNDS] = trap_S_RegisterSound( str );
+		}
+		else if (str[1] == '$')
+		{ //an NPC soundset
+			CG_PrecacheNPCSounds(str);
+		}
+	} else if ( num >= CS_EFFECTS && num < CS_EFFECTS+MAX_FX ) {
+		if (str[0] == '*')
+		{ //it's a special global weather effect
+			CG_ParseWeatherEffect(str);
+			cgs.gameEffects[ num-CS_EFFECTS] = 0;
+		}
+		else
+		{
+			cgs.gameEffects[ num-CS_EFFECTS] = trap_FX_RegisterEffect( str );
+		}
+	}
+	else if ( num >= CS_SIEGE_STATE && num < CS_SIEGE_STATE+1 )
+	{
+		if (str[0])
+		{
+			CG_ParseSiegeState(str);
+		}
+	}
+	else if ( num >= CS_SIEGE_WINTEAM && num < CS_SIEGE_WINTEAM+1 )
+	{
+		if (str[0])
+		{
+			cg_siegeWinTeam = atoi(str);
+		}
+	}
+	else if ( num >= CS_SIEGE_OBJECTIVES && num < CS_SIEGE_OBJECTIVES+1 )
+	{
+		CG_ParseSiegeObjectiveStatus(str);
+	}
+	else if (num >= CS_SIEGE_TIMEOVERRIDE && num < CS_SIEGE_TIMEOVERRIDE+1)
+	{
+		cg_beatingSiegeTime = atoi(str);
+		CG_SetSiegeTimerCvar ( cg_beatingSiegeTime );
+	}
+	else if ( num >= CS_PLAYERS && num < CS_PLAYERS+MAX_CLIENTS )
+	{
+		CG_NewClientInfo( num - CS_PLAYERS, qtrue);
+		CG_BuildSpectatorString();
+	} else if ( num == CS_FLAGSTATUS ) {
+		if( cgs.gametype == GT_CTF || cgs.gametype == GT_CTY ) {
+			// format is rb where its red/blue, 0 is at base, 1 is taken, 2 is dropped
+			cgs.redflag = str[0] - '0';
+			cgs.blueflag = str[1] - '0';
+		}
+	}
+	else if ( num == CS_SHADERSTATE ) {
+		CG_ShaderStateChanged();
+	}
+	else if ( num >= CS_LIGHT_STYLES && num < CS_LIGHT_STYLES + (MAX_LIGHT_STYLES * 3))
+	{
+		CG_SetLightstyle(num - CS_LIGHT_STYLES);
+	}
+		
+}
+
+//frees all ghoul2 stuff and npc stuff from a centity -rww
+void CG_KillCEntityG2(int entNum)
+{
+	int j;
+	clientInfo_t *ci = NULL;
+	centity_t *cent = &cg_entities[entNum];
+
+	if (entNum < MAX_CLIENTS)
+	{
+		ci = &cgs.clientinfo[entNum];
+	}
+	else
+	{
+		ci = cent->npcClient;
+	}
+
+	if (ci)
+	{
+		if (ci == cent->npcClient)
+		{ //never going to be != cent->ghoul2, unless cent->ghoul2 has already been removed (and then this ptr is not valid)
+			ci->ghoul2Model = NULL;
+		}
+		else if (ci->ghoul2Model == cent->ghoul2)
+		{
+			ci->ghoul2Model = NULL;
+		}
+		else if (ci->ghoul2Model && trap_G2_HaveWeGhoul2Models(ci->ghoul2Model))
+		{
+			trap_G2API_CleanGhoul2Models(&ci->ghoul2Model);
+			ci->ghoul2Model = NULL;
+		}
+
+		//Clean up any weapon instances for custom saber stuff
+		j = 0;
+		while (j < MAX_SABERS)
+		{
+			if (ci->ghoul2Weapons[j] && trap_G2_HaveWeGhoul2Models(ci->ghoul2Weapons[j]))
+			{
+				trap_G2API_CleanGhoul2Models(&ci->ghoul2Weapons[j]);
+				ci->ghoul2Weapons[j] = NULL;
+			}
+
+			j++;
+		}
+	}
+
+	if (cent->ghoul2 && trap_G2_HaveWeGhoul2Models(cent->ghoul2))
+	{
+		trap_G2API_CleanGhoul2Models(&cent->ghoul2);
+		cent->ghoul2 = NULL;
+	}
+
+	if (cent->grip_arm && trap_G2_HaveWeGhoul2Models(cent->grip_arm))
+	{
+		trap_G2API_CleanGhoul2Models(&cent->grip_arm);
+		cent->grip_arm = NULL;
+	}
+
+	if (cent->frame_hold && trap_G2_HaveWeGhoul2Models(cent->frame_hold))
+	{
+		trap_G2API_CleanGhoul2Models(&cent->frame_hold);
+		cent->frame_hold = NULL;
+	}
+
+	if (cent->npcClient)
+	{
+		CG_DestroyNPCClient(&cent->npcClient);
+	}
+
+	cent->isRagging = qfalse; //just in case.
+	cent->ikStatus = qfalse;
+
+	cent->localAnimIndex = 0;
+}
+
+void CG_KillCEntityInstances(void)
+{
+	int i = 0;
+	centity_t *cent;
+
+	while (i < MAX_GENTITIES)
+	{
+		cent = &cg_entities[i];
+
+		if (i >= MAX_CLIENTS && cent->currentState.number == i)
+		{ //do not clear G2 instances on client ents, they are constant
+			CG_KillCEntityG2(i);
+		}
+
+		cent->bolt1 = 0;
+		cent->bolt2 = 0;
+		cent->bolt3 = 0;
+		cent->bolt4 = 0;
+
+		cent->bodyHeight = 0;//SABER_LENGTH_MAX;
+		//cent->saberExtendTime = 0;
+
+		cent->boltInfo = 0;
+
+		cent->frame_minus1_refreshed = 0;
+		cent->frame_minus2_refreshed = 0;
+		cent->dustTrailTime = 0;
+		cent->ghoul2weapon = NULL;
+		//cent->torsoBolt = 0;
+		cent->trailTime = 0;
+		cent->frame_hold_time = 0;
+		cent->frame_hold_refreshed = 0;
+		cent->trickAlpha = 0;
+		cent->trickAlphaTime = 0;
+		VectorClear(cent->turAngles);
+		cent->weapon = 0;
+		cent->teamPowerEffectTime = 0;
+		cent->teamPowerType = 0;
+		cent->numLoopingSounds = 0;
+
+		cent->localAnimIndex = 0;
+
+		i++;
+	}
+}
+
+/*
+===============
+CG_MapRestart
+
+The server has issued a map_restart, so the next snapshot
+is completely new and should not be interpolated to.
+
+A tournement restart will clear everything, but doesn't
+require a reload of all the media
+===============
+*/
+static void CG_MapRestart( void ) {
+	if ( cg_showmiss.integer ) {
+		CG_Printf( "CG_MapRestart\n" );
+	}
+
+	trap_R_ClearDecals ( );
+	//FIXME: trap_FX_Reset?
+
+	CG_InitLocalEntities();
+	CG_InitMarkPolys();
+	CG_ClearParticles ();
+	CG_KillCEntityInstances();
+
+	// make sure the "3 frags left" warnings play again
+	cg.fraglimitWarnings = 0;
+
+	cg.timelimitWarnings = 0;
+
+	cg.intermissionStarted = qfalse;
+
+	cgs.voteTime = 0;
+
+	cg.mapRestart = qtrue;
+
+	CG_StartMusic(qtrue);
+
+	trap_S_ClearLoopingSounds();
+
+	// we really should clear more parts of cg here and stop sounds
+
+	// play the "fight" sound if this is a restart without warmup
+	if ( cg.warmup == 0 && cgs.gametype != GT_SIEGE && cgs.gametype != GT_POWERDUEL/* && cgs.gametype == GT_DUEL */) {
+		trap_S_StartLocalSound( cgs.media.countFightSound, CHAN_ANNOUNCER );
+		CG_CenterPrint( CG_GetStringEdString("MP_SVGAME", "BEGIN_DUEL"), 120, GIANTCHAR_WIDTH*2 );
+	}
+	/*
+	if (cg_singlePlayerActive.integer) {
+		trap_Cvar_Set("ui_matchStartTime", va("%i", cg.time));
+		if (cg_recordSPDemo.integer && cg_recordSPDemoName.string && *cg_recordSPDemoName.string) {
+			trap_SendConsoleCommand(va("set g_synchronousclients 1 ; record %s \n", cg_recordSPDemoName.string));
+		}
+	}
+	*/
+	trap_Cvar_Set("cg_thirdPerson", "0");
+}
+
+/*
+=================
+CG_RemoveChatEscapeChar
+=================
+*/
+static void CG_RemoveChatEscapeChar( char *text ) {
+	int i, l;
+
+	l = 0;
+	for ( i = 0; text[i]; i++ ) {
+		if (text[i] == '\x19')
+			continue;
+		text[l++] = text[i];
+	}
+	text[l] = '\0';
+}
+
+#define MAX_STRINGED_SV_STRING 1024	// this is an quake-engine limit, not a StringEd limit
+
+void CG_CheckSVStringEdRef(char *buf, const char *str)
+{ //I don't really like doing this. But it utilizes the system that was already in place.
+	int i = 0;
+	int b = 0;
+	int strLen = 0;
+	qboolean gotStrip = qfalse;
+
+	if (!str || !str[0])
+	{
+		if (str)
+		{
+			strcpy(buf, str);
+		}
+		return;
+	}
+
+	strcpy(buf, str);
+
+	strLen = strlen(str);
+
+	if (strLen >= MAX_STRINGED_SV_STRING)
+	{
+		return;
+	}
+
+	while (i < strLen && str[i])
+	{
+		gotStrip = qfalse;
+
+		if (str[i] == '@' && (i+1) < strLen)
+		{
+			if (str[i+1] == '@' && (i+2) < strLen)
+			{
+				if (str[i+2] == '@' && (i+3) < strLen)
+				{ //@@@ should mean to insert a StringEd reference here, so insert it into buf at the current place
+					char stringRef[MAX_STRINGED_SV_STRING];
+					int r = 0;
+
+					while (i < strLen && str[i] == '@')
+					{
+						i++;
+					}
+
+					while (i < strLen && str[i] && str[i] != ' ' && str[i] != ':' && str[i] != '.' && str[i] != '\n')
+					{
+						stringRef[r] = str[i];
+						r++;
+						i++;
+					}
+					stringRef[r] = 0;
+
+					buf[b] = 0;
+					Q_strcat(buf, MAX_STRINGED_SV_STRING, CG_GetStringEdString("MP_SVGAME", stringRef));
+					b = strlen(buf);
+				}
+			}
+		}
+
+		if (!gotStrip)
+		{
+			buf[b] = str[i];
+			b++;
+		}
+		i++;
+	}
+
+	buf[b] = 0;
+}
+
+static void CG_BodyQueueCopy(centity_t *cent, int clientNum, int knownWeapon)
+{
+	centity_t		*source;
+	animation_t		*anim;
+	float			animSpeed;
+	int				flags=BONE_ANIM_OVERRIDE_FREEZE;
+	clientInfo_t	*ci;
+
+	if (cent->ghoul2)
+	{
+		trap_G2API_CleanGhoul2Models(&cent->ghoul2);
+	}
+
+	if (clientNum < 0 || clientNum >= MAX_CLIENTS)
+	{
+		return;
+	}
+
+	source = &cg_entities[ clientNum ];
+	ci = &cgs.clientinfo[ clientNum ];
+
+	if (!source)
+	{
+		return;
+	}
+
+	if (!source->ghoul2)
+	{
+		return;
+	}
+
+	cent->isRagging = qfalse; //reset in case it's still set from another body that was in this cent slot.
+	cent->ownerRagging = source->isRagging; //if the owner was in ragdoll state, then we want to go into it too right away.
+
+#if 0
+	VectorCopy(source->lerpOriginOffset, cent->lerpOriginOffset);
+#endif
+
+	cent->bodyFadeTime = 0;
+	cent->bodyHeight = 0;
+
+	cent->dustTrailTime = source->dustTrailTime;
+
+	trap_G2API_DuplicateGhoul2Instance(source->ghoul2, &cent->ghoul2);
+
+	if (source->isRagging)
+	{ //just reset it now.
+		source->isRagging = qfalse;
+		trap_G2API_SetRagDoll(source->ghoul2, NULL); //calling with null parms resets to no ragdoll.
+	}
+
+	//either force the weapon from when we died or remove it if it was a dropped weapon
+	if (knownWeapon > WP_BRYAR_PISTOL && trap_G2API_HasGhoul2ModelOnIndex(&(cent->ghoul2), 1))
+	{
+		trap_G2API_RemoveGhoul2Model(&(cent->ghoul2), 1);
+	}
+	else if (trap_G2API_HasGhoul2ModelOnIndex(&(cent->ghoul2), 1))
+	{
+		trap_G2API_CopySpecificGhoul2Model(CG_G2WeaponInstance(cent, knownWeapon), 0, cent->ghoul2, 1);
+	}
+
+	if (!cent->ownerRagging)
+	{
+		int aNum;
+		int eFrame;
+		qboolean fallBack = qfalse;
+
+		//anim = &bgAllAnims[cent->localAnimIndex].anims[ cent->currentState.torsoAnim ];
+		if (!BG_InDeathAnim(source->currentState.torsoAnim))
+		{ //then just snap the corpse into a default
+			anim = &bgAllAnims[source->localAnimIndex].anims[ BOTH_DEAD1 ];
+			fallBack = qtrue;
+		}
+		else
+		{
+			anim = &bgAllAnims[source->localAnimIndex].anims[ source->currentState.torsoAnim ];
+		}
+		animSpeed = 50.0f / anim->frameLerp;
+
+		if (!fallBack)
+		{
+			//this will just set us to the last frame of the animation, in theory
+			aNum = cgs.clientinfo[source->currentState.number].frame+1;
+
+			while (aNum >= anim->firstFrame+anim->numFrames)
+			{
+				aNum--;
+			}
+
+			if (aNum < anim->firstFrame-1)
+			{ //wrong animation...?
+				aNum = (anim->firstFrame+anim->numFrames)-1;
+			}
+		}
+		else
+		{
+			aNum = anim->firstFrame;
+		}
+
+		eFrame = anim->firstFrame + anim->numFrames;
+
+		//if (!cgs.clientinfo[source->currentState.number].frame || (cent->currentState.torsoAnim) != (source->currentState.torsoAnim) )
+		//{
+		//	aNum = (anim->firstFrame+anim->numFrames)-1;
+		//}
+
+		trap_G2API_SetBoneAnim(cent->ghoul2, 0, "upper_lumbar", aNum, eFrame, flags, animSpeed, cg.time, -1, 150);
+		trap_G2API_SetBoneAnim(cent->ghoul2, 0, "model_root", aNum, eFrame, flags, animSpeed, cg.time, -1, 150);
+		trap_G2API_SetBoneAnim(cent->ghoul2, 0, "Motion", aNum, eFrame, flags, animSpeed, cg.time, -1, 150);
+	}
+
+	//After we create the bodyqueue, regenerate any limbs on the real instance
+	if (source->torsoBolt)
+	{
+		CG_ReattachLimb(source);
+	}
+}
+
+/*
+=================
+CG_ServerCommand
+
+The string has been tokenized and can be retrieved with
+Cmd_Argc() / Cmd_Argv()
+=================
+*/
+void CG_SiegeBriefingDisplay(int team, int dontshow);
+void CG_ParseSiegeExtendedData(void);
+extern void CG_ChatBox_AddString(char *chatStr); //cg_draw.c
+static void CG_ServerCommand( void ) {
+	const char	*cmd;
+	char		text[MAX_SAY_TEXT];
+	qboolean	IRCG = qfalse;
+
+	cmd = CG_Argv(0);
+
+	if ( !cmd[0] ) {
+		// server claimed the command
+		return;
+	}
+
+#if 0
+	// never seems to get used -Ste
+	if ( !strcmp( cmd, "spd" ) ) 
+	{
+		const char *ID;
+		int holdInt,count,i;
+		char string[1204];
+
+		count = trap_Argc();
+
+		ID =  CG_Argv(1);
+		holdInt = atoi(ID);
+
+		memset( &string, 0, sizeof( string ) );
+
+		Com_sprintf( string,sizeof(string)," \"%s\"", (const char *) CG_Argv(2));
+
+		for (i=3;i<count;i++)
+		{
+			Com_sprintf( string,sizeof(string)," %s \"%s\"", string, (const char *) CG_Argv(i));
+		}
+
+		trap_SP_Print(holdInt, (byte *)string);
+		return;
+	}
+#endif
+
+	if (!strcmp(cmd, "sxd"))
+	{ //siege extended data, contains extra info certain classes may want to know about other clients
+        CG_ParseSiegeExtendedData();
+		return;
+	}
+
+	if (!strcmp(cmd, "sb"))
+	{ //siege briefing display
+		CG_SiegeBriefingDisplay(atoi(CG_Argv(1)), 0);
+		return;
+	}
+
+	if ( !strcmp( cmd, "scl" ) )
+	{
+		//if (!( trap_Key_GetCatcher() & KEYCATCH_UI ))
+		//Well, I want it to come up even if the briefing display is up.
+		{
+			trap_OpenUIMenu(UIMENU_CLASSSEL); //UIMENU_CLASSSEL
+		}
+		return;
+	}
+
+	if ( !strcmp( cmd, "spc" ) )
+	{
+		trap_Cvar_Set("ui_myteam", "3");
+		trap_OpenUIMenu(UIMENU_PLAYERCONFIG); //UIMENU_CLASSSEL
+		return;
+	}
+
+	if ( !strcmp( cmd, "nfr" ) )
+	{ //"nfr" == "new force rank" (want a short string)
+		int doMenu = 0;
+		int setTeam = 0;
+		int newRank = 0;
+
+		if (trap_Argc() < 3)
+		{
+#ifdef _DEBUG
+			Com_Printf("WARNING: Invalid newForceRank string\n");
+#endif
+			return;
+		}
+
+		newRank = atoi(CG_Argv(1));
+		doMenu = atoi(CG_Argv(2));
+		setTeam = atoi(CG_Argv(3));
+
+		trap_Cvar_Set("ui_rankChange", va("%i", newRank));
+
+		trap_Cvar_Set("ui_myteam", va("%i", setTeam));
+
+		if (!( trap_Key_GetCatcher() & KEYCATCH_UI ) && doMenu)
+		{
+			trap_OpenUIMenu(UIMENU_PLAYERCONFIG);
+		}
+
+		return;
+	}
+
+	if ( !strcmp( cmd, "kg2" ) )
+	{ //Kill a ghoul2 instance in this slot.
+	  //If it has been occupied since this message was sent somehow, the worst that can (should) happen
+	  //is the instance will have to reinit with its current info.
+		int indexNum = 0;
+		int argNum = trap_Argc();
+		int i = 1;
+		
+		if (argNum < 1)
+		{
+			return;
+		}
+
+		while (i < argNum)
+		{
+			indexNum = atoi(CG_Argv(i));
+
+			if (cg_entities[indexNum].ghoul2 && trap_G2_HaveWeGhoul2Models(cg_entities[indexNum].ghoul2))
+			{
+				if (indexNum < MAX_CLIENTS)
+				{ //You try to do very bad thing!
+#ifdef _DEBUG
+					Com_Printf("WARNING: Tried to kill a client ghoul2 instance with a kg2 command!\n");
+#endif
+					return;
+				}
+
+				CG_KillCEntityG2(indexNum);
+			}
+
+			i++;
+		}
+		
+		return;
+	}
+
+	if (!strcmp(cmd, "kls"))
+	{ //kill looping sounds
+		int indexNum = 0;
+		int argNum = trap_Argc();
+		centity_t *clent = NULL;
+		centity_t *trackerent = NULL;
+		
+		if (argNum < 1)
+		{
+			assert(0);
+			return;
+		}
+
+		indexNum = atoi(CG_Argv(1));
+
+		if (indexNum != -1)
+		{
+			clent = &cg_entities[indexNum];
+		}
+
+		if (argNum >= 2)
+		{
+			indexNum = atoi(CG_Argv(2));
+
+			if (indexNum != -1)
+			{
+				trackerent = &cg_entities[indexNum];
+			}
+		}
+
+		if (clent)
+		{
+			CG_S_StopLoopingSound(clent->currentState.number, -1);
+		}
+		if (trackerent)
+		{
+			CG_S_StopLoopingSound(trackerent->currentState.number, -1);
+		}
+
+		return;
+	}
+
+	if (!strcmp(cmd, "ircg"))
+	{ //this means param 2 is the body index and we want to copy to bodyqueue on it
+		IRCG = qtrue;
+	}
+
+	if (!strcmp(cmd, "rcg") || IRCG)
+	{ //rcg - Restore Client Ghoul (make sure limbs are reattached and ragdoll state is reset - this must be done reliably)
+		int indexNum = 0;
+		int argNum = trap_Argc();
+		centity_t *clent;
+		
+		if (argNum < 1)
+		{
+			assert(0);
+			return;
+		}
+
+		indexNum = atoi(CG_Argv(1));
+		if (indexNum < 0 || indexNum >= MAX_CLIENTS)
+		{
+			assert(0);
+			return;
+		}
+
+		clent = &cg_entities[indexNum];
+
+		//assert(clent->ghoul2);
+		if (!clent->ghoul2)
+		{ //this can happen while connecting as a client
+			return;
+		}
+
+#ifdef _DEBUG
+		if (!trap_G2_HaveWeGhoul2Models(clent->ghoul2))
+		{
+			assert(!"Tried to reset state on a bad instance. Crash is inevitable.");
+		}
+#endif
+
+		if (IRCG)
+		{
+			int bodyIndex = 0;
+			int weaponIndex = 0;
+			int side = 0;
+			centity_t *body;
+
+			assert(argNum >= 3);
+			bodyIndex = atoi(CG_Argv(2));
+			weaponIndex = atoi(CG_Argv(3));
+			side = atoi(CG_Argv(4));
+
+			body = &cg_entities[bodyIndex];
+
+			if (side)
+			{
+				body->teamPowerType = qtrue; //light side
+			}
+			else
+			{
+				body->teamPowerType = qfalse; //dark side
+			}
+
+			CG_BodyQueueCopy(body, clent->currentState.number, weaponIndex);
+		}
+
+		//reattach any missing limbs
+		if (clent->torsoBolt)
+		{
+			CG_ReattachLimb(clent);
+		}
+
+		//make sure ragdoll state is reset
+		if (clent->isRagging)
+		{
+			clent->isRagging = qfalse;
+			trap_G2API_SetRagDoll(clent->ghoul2, NULL); //calling with null parms resets to no ragdoll.
+		}
+		
+		//clear all the decals as well
+		trap_G2API_ClearSkinGore(clent->ghoul2);
+
+		clent->weapon = 0;
+		clent->ghoul2weapon = NULL; //force a weapon reinit
+
+		return;
+	}
+
+	if ( !strcmp( cmd, "cp" ) ) {
+		char strEd[MAX_STRINGED_SV_STRING];
+		CG_CheckSVStringEdRef(strEd, CG_Argv(1));
+		CG_CenterPrint( strEd, SCREEN_HEIGHT * 0.30, BIGCHAR_WIDTH );
+		return;
+	}
+
+	if ( !strcmp( cmd, "cps" ) ) {
+		char strEd[MAX_STRINGED_SV_STRING];
+		char *x = (char *)CG_Argv(1);
+		if (x[0] == '@')
+		{
+			x++;
+		}
+		trap_SP_GetStringTextString(x, strEd, MAX_STRINGED_SV_STRING);
+		CG_CenterPrint( strEd, SCREEN_HEIGHT * 0.30, BIGCHAR_WIDTH );
+		return;
+	}
+
+	if ( !strcmp( cmd, "cs" ) ) {
+		CG_ConfigStringModified();
+		return;
+	}
+
+	if ( !strcmp( cmd, "print" ) ) {
+		char strEd[MAX_STRINGED_SV_STRING];
+		CG_CheckSVStringEdRef(strEd, CG_Argv(1));
+		CG_Printf( "%s", strEd );
+		return;
+	}
+
+	if ( !strcmp( cmd, "chat" ) ) {
+		if ( !cg_teamChatsOnly.integer ) {
+			trap_S_StartLocalSound( cgs.media.talkSound, CHAN_LOCAL_SOUND );
+			Q_strncpyz( text, CG_Argv(1), MAX_SAY_TEXT );
+			CG_RemoveChatEscapeChar( text );
+			CG_ChatBox_AddString(text);
+			CG_Printf( "*%s\n", text );
+		}
+		return;
+	}
+
+	if ( !strcmp( cmd, "tchat" ) ) {
+		trap_S_StartLocalSound( cgs.media.talkSound, CHAN_LOCAL_SOUND );
+		Q_strncpyz( text, CG_Argv(1), MAX_SAY_TEXT );
+		CG_RemoveChatEscapeChar( text );
+		CG_ChatBox_AddString(text);
+		CG_Printf( "*%s\n", text );
+
+		return;
+	}
+
+	//chat with location, possibly localized.
+	if ( !strcmp( cmd, "lchat" ) ) {
+		if ( !cg_teamChatsOnly.integer ) {
+			char name[MAX_STRING_CHARS];
+			char loc[MAX_STRING_CHARS];
+			char color[8];
+			char message[MAX_STRING_CHARS];
+
+			if (trap_Argc() < 4)
+			{
+				return;
+			}
+
+			strcpy(name, CG_Argv(1));
+			strcpy(loc, CG_Argv(2));
+			strcpy(color, CG_Argv(3));
+			strcpy(message, CG_Argv(4));
+
+			if (loc[0] == '@')
+			{ //get localized text
+				trap_SP_GetStringTextString(loc+1, loc, MAX_STRING_CHARS);
+			}
+
+			trap_S_StartLocalSound( cgs.media.talkSound, CHAN_LOCAL_SOUND );
+			//Q_strncpyz( text, CG_Argv(1), MAX_SAY_TEXT );
+			Com_sprintf(text, MAX_SAY_TEXT, "%s<%s>^%s%s", name, loc, color, message);
+			CG_RemoveChatEscapeChar( text );
+			CG_ChatBox_AddString(text);
+			CG_Printf( "*%s\n", text );
+		}
+		return;
+	}
+	if ( !strcmp( cmd, "ltchat" ) ) {
+		char name[MAX_STRING_CHARS];
+		char loc[MAX_STRING_CHARS];
+		char color[8];
+		char message[MAX_STRING_CHARS];
+
+		if (trap_Argc() < 4)
+		{
+			return;
+		}
+
+		strcpy(name, CG_Argv(1));
+		strcpy(loc, CG_Argv(2));
+		strcpy(color, CG_Argv(3));
+		strcpy(message, CG_Argv(4));
+
+		if (loc[0] == '@')
+		{ //get localized text
+			trap_SP_GetStringTextString(loc+1, loc, MAX_STRING_CHARS);
+		}
+
+		trap_S_StartLocalSound( cgs.media.talkSound, CHAN_LOCAL_SOUND );
+		//Q_strncpyz( text, CG_Argv(1), MAX_SAY_TEXT );
+		Com_sprintf(text, MAX_SAY_TEXT, "%s<%s> ^%s%s", name, loc, color, message);
+		CG_RemoveChatEscapeChar( text );
+		CG_ChatBox_AddString(text);
+		CG_Printf( "*%s\n", text );
+
+		return;
+	}
+
+	if ( !strcmp( cmd, "scores" ) ) {
+		CG_ParseScores();
+		return;
+	}
+
+	if ( !strcmp( cmd, "tinfo" ) ) {
+		CG_ParseTeamInfo();
+		return;
+	}
+
+	if ( !strcmp( cmd, "map_restart" ) ) {
+		CG_MapRestart();
+		return;
+	}
+
+  if ( Q_stricmp (cmd, "remapShader") == 0 ) {
+		if (trap_Argc() == 4) {
+			trap_R_RemapShader(CG_Argv(1), CG_Argv(2), CG_Argv(3));
+		}
+	}
+
+	// loaddeferred can be both a servercmd and a consolecmd
+	if ( !strcmp( cmd, "loaddefered" ) ) {	// FIXME: spelled wrong, but not changing for demo
+		CG_LoadDeferredPlayers();
+		return;
+	}
+
+	// clientLevelShot is sent before taking a special screenshot for
+	// the menu system during development
+	if ( !strcmp( cmd, "clientLevelShot" ) ) {
+		cg.levelShot = qtrue;
+		return;
+	}
+
+	CG_Printf( "Unknown client game command: %s\n", cmd );
+}
+
+
+/*
+====================
+CG_ExecuteNewServerCommands
+
+Execute all of the server commands that were received along
+with this this snapshot.
+====================
+*/
+void CG_ExecuteNewServerCommands( int latestSequence ) {
+	while ( cgs.serverCommandSequence < latestSequence ) {
+		if ( trap_GetServerCommand( ++cgs.serverCommandSequence ) ) {
+			CG_ServerCommand();
+		}
+	}
+}
diff --git a/codemp/cgame/cg_snapshot.c b/codemp/cgame/cg_snapshot.c
new file mode 100644
index 0000000..55c5a0e
--- /dev/null
+++ b/codemp/cgame/cg_snapshot.c
@@ -0,0 +1,414 @@
+// Copyright (C) 1999-2000 Id Software, Inc.
+//
+// cg_snapshot.c -- things that happen on snapshot transition,
+// not necessarily every single rendered frame
+
+#include "cg_local.h"
+
+
+
+/*
+==================
+CG_ResetEntity
+==================
+*/
+static void CG_ResetEntity( centity_t *cent ) {
+	// if the previous snapshot this entity was updated in is at least
+	// an event window back in time then we can reset the previous event
+	if ( cent->snapShotTime < cg.time - EVENT_VALID_MSEC ) {
+		cent->previousEvent = 0;
+	}
+
+	cent->trailTime = cg.snap->serverTime;
+
+	VectorCopy (cent->currentState.origin, cent->lerpOrigin);
+	VectorCopy (cent->currentState.angles, cent->lerpAngles);
+
+	if (cent->currentState.eFlags & EF_G2ANIMATING)
+	{ //reset the animation state
+		cent->pe.torso.animationNumber = -1;
+		cent->pe.legs.animationNumber = -1;
+	}
+
+#if 0
+	if (cent->isRagging && (cent->currentState.eFlags & EF_DEAD))
+	{
+		VectorAdd(cent->lerpOrigin, cent->lerpOriginOffset, cent->lerpOrigin);
+	}
+#endif
+
+	if ( cent->currentState.eType == ET_PLAYER || cent->currentState.eType == ET_NPC ) {
+		CG_ResetPlayerEntity( cent );
+	}
+}
+
+/*
+===============
+CG_TransitionEntity
+
+cent->nextState is moved to cent->currentState and events are fired
+===============
+*/
+static void CG_TransitionEntity( centity_t *cent ) {
+	cent->currentState = cent->nextState;
+	cent->currentValid = qtrue;
+
+	// reset if the entity wasn't in the last frame or was teleported
+	if ( !cent->interpolate ) {
+		CG_ResetEntity( cent );
+	}
+
+	// clear the next state.  if will be set by the next CG_SetNextSnap
+	cent->interpolate = qfalse;
+
+	// check for events
+	CG_CheckEvents( cent );
+}
+
+
+/*
+==================
+CG_SetInitialSnapshot
+
+This will only happen on the very first snapshot, or
+on tourney restarts.  All other times will use 
+CG_TransitionSnapshot instead.
+
+FIXME: Also called by map_restart?
+==================
+*/
+void CG_SetInitialSnapshot( snapshot_t *snap ) {
+	int				i;
+	centity_t		*cent;
+	entityState_t	*state;
+
+	cg.snap = snap; 
+
+	if ((cg_entities[snap->ps.clientNum].ghoul2 == NULL) && trap_G2_HaveWeGhoul2Models(cgs.clientinfo[snap->ps.clientNum].ghoul2Model))
+	{
+		trap_G2API_DuplicateGhoul2Instance(cgs.clientinfo[snap->ps.clientNum].ghoul2Model, &cg_entities[snap->ps.clientNum].ghoul2);
+		CG_CopyG2WeaponInstance(&cg_entities[snap->ps.clientNum], FIRST_WEAPON, cg_entities[snap->ps.clientNum].ghoul2);
+		
+		if (trap_G2API_AddBolt(cg_entities[snap->ps.clientNum].ghoul2, 0, "face") == -1)
+		{ //check now to see if we have this bone for setting anims and such
+			cg_entities[snap->ps.clientNum].noFace = qtrue;
+		}
+	}
+	BG_PlayerStateToEntityState( &snap->ps, &cg_entities[ snap->ps.clientNum ].currentState, qfalse );
+
+	// sort out solid entities
+	CG_BuildSolidList();
+
+	CG_ExecuteNewServerCommands( snap->serverCommandSequence );
+
+	// set our local weapon selection pointer to
+	// what the server has indicated the current weapon is
+	CG_Respawn();
+
+	for ( i = 0 ; i < cg.snap->numEntities ; i++ ) {
+		state = &cg.snap->entities[ i ];
+		cent = &cg_entities[ state->number ];
+
+		memcpy(&cent->currentState, state, sizeof(entityState_t));
+		//cent->currentState = *state;
+		cent->interpolate = qfalse;
+		cent->currentValid = qtrue;
+
+		CG_ResetEntity( cent );
+
+		// check for events
+		CG_CheckEvents( cent );
+	}
+}
+
+
+/*
+===================
+CG_TransitionSnapshot
+
+The transition point from snap to nextSnap has passed
+===================
+*/
+extern qboolean CG_UsingEWeb(void); //cg_predict.c
+static void CG_TransitionSnapshot( void ) {
+	centity_t			*cent;
+	snapshot_t			*oldFrame;
+	int					i;
+
+	if ( !cg.snap ) {
+		CG_Error( "CG_TransitionSnapshot: NULL cg.snap" );
+	}
+	if ( !cg.nextSnap ) {
+		CG_Error( "CG_TransitionSnapshot: NULL cg.nextSnap" );
+	}
+
+	// execute any server string commands before transitioning entities
+	CG_ExecuteNewServerCommands( cg.nextSnap->serverCommandSequence );
+
+	// if we had a map_restart, set everthing with initial
+	if ( !cg.snap ) {
+	}
+
+	// clear the currentValid flag for all entities in the existing snapshot
+	for ( i = 0 ; i < cg.snap->numEntities ; i++ ) {
+		cent = &cg_entities[ cg.snap->entities[ i ].number ];
+		cent->currentValid = qfalse;
+	}
+
+	// move nextSnap to snap and do the transitions
+	oldFrame = cg.snap;
+	cg.snap = cg.nextSnap;
+
+	//CG_CheckPlayerG2Weapons(&cg.snap->ps, &cg_entities[cg.snap->ps.clientNum]);
+	//CG_CheckPlayerG2Weapons(&cg.snap->ps, &cg.predictedPlayerEntity);
+	BG_PlayerStateToEntityState( &cg.snap->ps, &cg_entities[ cg.snap->ps.clientNum ].currentState, qfalse );
+	cg_entities[ cg.snap->ps.clientNum ].interpolate = qfalse;
+
+	for ( i = 0 ; i < cg.snap->numEntities ; i++ ) {
+		cent = &cg_entities[ cg.snap->entities[ i ].number ];
+		CG_TransitionEntity( cent );
+
+		// remember time of snapshot this entity was last updated in
+		cent->snapShotTime = cg.snap->serverTime;
+	}
+
+	cg.nextSnap = NULL;
+
+	// check for playerstate transition events
+	if ( oldFrame ) {
+		playerState_t	*ops, *ps;
+
+		ops = &oldFrame->ps;
+		ps = &cg.snap->ps;
+		// teleporting checks are irrespective of prediction
+		if ( ( ps->eFlags ^ ops->eFlags ) & EF_TELEPORT_BIT ) {
+			cg.thisFrameTeleport = qtrue;	// will be cleared by prediction code
+		}
+
+		// if we are not doing client side movement prediction for any
+		// reason, then the client events and view changes will be issued now
+		if ( cg.demoPlayback || (cg.snap->ps.pm_flags & PMF_FOLLOW)
+			|| cg_nopredict.integer || cg_synchronousClients.integer || CG_UsingEWeb() ) {
+			CG_TransitionPlayerState( ps, ops );
+		}
+	}
+
+}
+
+
+/*
+===================
+CG_SetNextSnap
+
+A new snapshot has just been read in from the client system.
+===================
+*/
+static void CG_SetNextSnap( snapshot_t *snap ) {
+	int					num;
+	entityState_t		*es;
+	centity_t			*cent;
+
+	cg.nextSnap = snap;
+
+	//CG_CheckPlayerG2Weapons(&cg.snap->ps, &cg_entities[cg.snap->ps.clientNum]);
+	//CG_CheckPlayerG2Weapons(&cg.snap->ps, &cg.predictedPlayerEntity);
+	BG_PlayerStateToEntityState( &snap->ps, &cg_entities[ snap->ps.clientNum ].nextState, qfalse );
+	//cg_entities[ cg.snap->ps.clientNum ].interpolate = qtrue;
+	//No longer want to do this, as the cg_entities[clnum] and cg.predictedPlayerEntity are one in the same.
+
+	// check for extrapolation errors
+	for ( num = 0 ; num < snap->numEntities ; num++ ) 
+	{
+		es = &snap->entities[num];
+		cent = &cg_entities[ es->number ];
+
+		memcpy(&cent->nextState, es, sizeof(entityState_t));
+		//cent->nextState = *es;
+
+		// if this frame is a teleport, or the entity wasn't in the
+		// previous frame, don't interpolate
+		if ( !cent->currentValid || ( ( cent->currentState.eFlags ^ es->eFlags ) & EF_TELEPORT_BIT )  ) {
+			cent->interpolate = qfalse;
+		} else {
+			cent->interpolate = qtrue;
+		}
+	}
+
+	// if the next frame is a teleport for the playerstate, we
+	// can't interpolate during demos
+	if ( cg.snap && ( ( snap->ps.eFlags ^ cg.snap->ps.eFlags ) & EF_TELEPORT_BIT ) ) {
+		cg.nextFrameTeleport = qtrue;
+	} else {
+		cg.nextFrameTeleport = qfalse;
+	}
+
+	// if changing follow mode, don't interpolate
+	if ( cg.nextSnap->ps.clientNum != cg.snap->ps.clientNum ) {
+		cg.nextFrameTeleport = qtrue;
+	}
+
+	// if changing server restarts, don't interpolate
+	if ( ( cg.nextSnap->snapFlags ^ cg.snap->snapFlags ) & SNAPFLAG_SERVERCOUNT ) {
+		cg.nextFrameTeleport = qtrue;
+	}
+
+	// sort out solid entities
+	CG_BuildSolidList();
+}
+
+
+/*
+========================
+CG_ReadNextSnapshot
+
+This is the only place new snapshots are requested
+This may increment cgs.processedSnapshotNum multiple
+times if the client system fails to return a
+valid snapshot.
+========================
+*/
+static snapshot_t *CG_ReadNextSnapshot( void ) {
+	qboolean	r;
+	snapshot_t	*dest;
+
+	if ( cg.latestSnapshotNum > cgs.processedSnapshotNum + 1000 ) {
+		CG_Printf( "WARNING: CG_ReadNextSnapshot: way out of range, %i > %i", 
+			cg.latestSnapshotNum, cgs.processedSnapshotNum );
+	}
+
+	while ( cgs.processedSnapshotNum < cg.latestSnapshotNum ) {
+		// decide which of the two slots to load it into
+		if ( cg.snap == &cg.activeSnapshots[0] ) {
+			dest = &cg.activeSnapshots[1];
+		} else {
+			dest = &cg.activeSnapshots[0];
+		}
+
+		// try to read the snapshot from the client system
+		cgs.processedSnapshotNum++;
+		r = trap_GetSnapshot( cgs.processedSnapshotNum, dest );
+
+		// FIXME: why would trap_GetSnapshot return a snapshot with the same server time
+		if ( cg.snap && r && dest->serverTime == cg.snap->serverTime ) {
+			//continue;
+		}
+
+		// if it succeeded, return
+		if ( r ) {
+			CG_AddLagometerSnapshotInfo( dest );
+			return dest;
+		}
+
+		// a GetSnapshot will return failure if the snapshot
+		// never arrived, or  is so old that its entities
+		// have been shoved off the end of the circular
+		// buffer in the client system.
+
+		// record as a dropped packet
+		CG_AddLagometerSnapshotInfo( NULL );
+
+		// If there are additional snapshots, continue trying to
+		// read them.
+	}
+
+	// nothing left to read
+	return NULL;
+}
+
+
+/*
+============
+CG_ProcessSnapshots
+
+We are trying to set up a renderable view, so determine
+what the simulated time is, and try to get snapshots
+both before and after that time if available.
+
+If we don't have a valid cg.snap after exiting this function,
+then a 3D game view cannot be rendered.  This should only happen
+right after the initial connection.  After cg.snap has been valid
+once, it will never turn invalid.
+
+Even if cg.snap is valid, cg.nextSnap may not be, if the snapshot
+hasn't arrived yet (it becomes an extrapolating situation instead
+of an interpolating one)
+
+============
+*/
+void CG_ProcessSnapshots( void ) {
+	snapshot_t		*snap;
+	int				n;
+
+	// see what the latest snapshot the client system has is
+	trap_GetCurrentSnapshotNumber( &n, &cg.latestSnapshotTime );
+	if ( n != cg.latestSnapshotNum ) {
+		if ( n < cg.latestSnapshotNum ) {
+			// this should never happen
+			CG_Error( "CG_ProcessSnapshots: n < cg.latestSnapshotNum" );
+		}
+		cg.latestSnapshotNum = n;
+	}
+
+	// If we have yet to receive a snapshot, check for it.
+	// Once we have gotten the first snapshot, cg.snap will
+	// always have valid data for the rest of the game
+	while ( !cg.snap ) {
+		snap = CG_ReadNextSnapshot();
+		if ( !snap ) {
+			// we can't continue until we get a snapshot
+			return;
+		}
+
+		// set our weapon selection to what
+		// the playerstate is currently using
+		if ( !( snap->snapFlags & SNAPFLAG_NOT_ACTIVE ) ) {
+			CG_SetInitialSnapshot( snap );
+		}
+	}
+
+	// loop until we either have a valid nextSnap with a serverTime
+	// greater than cg.time to interpolate towards, or we run
+	// out of available snapshots
+	do {
+		// if we don't have a nextframe, try and read a new one in
+		if ( !cg.nextSnap ) {
+			snap = CG_ReadNextSnapshot();
+
+			// if we still don't have a nextframe, we will just have to
+			// extrapolate
+			if ( !snap ) {
+				break;
+			}
+
+			CG_SetNextSnap( snap );
+
+
+			// if time went backwards, we have a level restart
+			if ( cg.nextSnap->serverTime < cg.snap->serverTime ) {
+				CG_Error( "CG_ProcessSnapshots: Server time went backwards" );
+			}
+		}
+
+		// if our time is < nextFrame's, we have a nice interpolating state
+		if ( cg.time >= cg.snap->serverTime && cg.time < cg.nextSnap->serverTime ) {
+			break;
+		}
+
+		// we have passed the transition from nextFrame to frame
+		CG_TransitionSnapshot();
+	} while ( 1 );
+
+	// assert our valid conditions upon exiting
+	if ( cg.snap == NULL ) {
+		CG_Error( "CG_ProcessSnapshots: cg.snap == NULL" );
+	}
+	if ( cg.time < cg.snap->serverTime ) {
+		// this can happen right after a vid_restart
+		cg.time = cg.snap->serverTime;
+	}
+	if ( cg.nextSnap != NULL && cg.nextSnap->serverTime <= cg.time ) {
+		CG_Error( "CG_ProcessSnapshots: cg.nextSnap->serverTime <= cg.time" );
+	}
+
+}
+
diff --git a/codemp/cgame/cg_strap.c b/codemp/cgame/cg_strap.c
new file mode 100644
index 0000000..9a74d06
--- /dev/null
+++ b/codemp/cgame/cg_strap.c
@@ -0,0 +1,73 @@
+//rww - shared trap call system
+#include "cg_local.h"
+
+#include "../namespace_begin.h"
+
+qboolean strap_G2API_GetBoltMatrix(void *ghoul2, const int modelIndex, const int boltIndex, mdxaBone_t *matrix,
+								const vec3_t angles, const vec3_t position, const int frameNum, qhandle_t *modelList, vec3_t scale)
+{
+	return trap_G2API_GetBoltMatrix(ghoul2, modelIndex, boltIndex, matrix, angles, position, frameNum, modelList, scale);
+}
+
+qboolean strap_G2API_GetBoltMatrix_NoReconstruct(void *ghoul2, const int modelIndex, const int boltIndex, mdxaBone_t *matrix,
+								const vec3_t angles, const vec3_t position, const int frameNum, qhandle_t *modelList, vec3_t scale)
+{
+	return trap_G2API_GetBoltMatrix_NoReconstruct(ghoul2, modelIndex, boltIndex, matrix, angles, position, frameNum, modelList, scale);
+}
+
+qboolean strap_G2API_GetBoltMatrix_NoRecNoRot(void *ghoul2, const int modelIndex, const int boltIndex, mdxaBone_t *matrix,
+								const vec3_t angles, const vec3_t position, const int frameNum, qhandle_t *modelList, vec3_t scale)
+{
+	return trap_G2API_GetBoltMatrix_NoRecNoRot(ghoul2, modelIndex, boltIndex, matrix, angles, position, frameNum, modelList, scale);
+}
+
+qboolean strap_G2API_SetBoneAngles(void *ghoul2, int modelIndex, const char *boneName, const vec3_t angles, const int flags,
+								const int up, const int right, const int forward, qhandle_t *modelList,
+								int blendTime , int currentTime )
+{
+	return trap_G2API_SetBoneAngles(ghoul2, modelIndex, boneName, angles, flags, up, right, forward, modelList, blendTime, currentTime);
+}
+
+qboolean strap_G2API_SetBoneAnim(void *ghoul2, const int modelIndex, const char *boneName, const int startFrame, const int endFrame,
+							  const int flags, const float animSpeed, const int currentTime, const float setFrame , const int blendTime )
+{
+	return trap_G2API_SetBoneAnim(ghoul2, modelIndex, boneName, startFrame, endFrame, flags, animSpeed, currentTime, setFrame, blendTime);
+}
+
+qboolean strap_G2API_GetBoneAnim(void *ghoul2, const char *boneName, const int currentTime, float *currentFrame,
+						   int *startFrame, int *endFrame, int *flags, float *animSpeed, int *modelList, const int modelIndex)
+{
+	return trap_G2API_GetBoneAnim(ghoul2, boneName, currentTime, currentFrame, startFrame, endFrame, flags, animSpeed, modelList, modelIndex);
+}
+
+void strap_G2API_SetRagDoll(void *ghoul2, sharedRagDollParams_t *params)
+{
+	trap_G2API_SetRagDoll(ghoul2, params);
+}
+
+void strap_G2API_AnimateG2Models(void *ghoul2, int time, sharedRagDollUpdateParams_t *params)
+{
+	trap_G2API_AnimateG2Models(ghoul2, time, params);
+}
+
+qboolean strap_G2API_SetBoneIKState(void *ghoul2, int time, const char *boneName, int ikState, sharedSetBoneIKStateParams_t *params)
+{
+	return trap_G2API_SetBoneIKState(ghoul2, time, boneName, ikState, params);
+}
+
+qboolean strap_G2API_IKMove(void *ghoul2, int time, sharedIKMoveParams_t *params)
+{
+	return trap_G2API_IKMove(ghoul2, time, params);
+}
+
+void strap_TrueMalloc(void **ptr, int size)
+{
+	trap_TrueMalloc(ptr, size);
+}
+
+void strap_TrueFree(void **ptr)
+{
+	trap_TrueFree(ptr);
+}
+
+#include "../namespace_end.h"
diff --git a/codemp/cgame/cg_syscalls.c b/codemp/cgame/cg_syscalls.c
new file mode 100644
index 0000000..99426cd
--- /dev/null
+++ b/codemp/cgame/cg_syscalls.c
@@ -0,0 +1,1106 @@
+// Copyright (C) 1999-2000 Id Software, Inc.
+//
+// cg_syscalls.c -- this file is only included when building a dll
+// cg_syscalls.asm is included instead when building a qvm
+#include "cg_local.h"
+
+static int (QDECL *syscall)( int arg, ... ) = (int (QDECL *)( int, ...))-1;
+
+#include "../namespace_begin.h"
+void dllEntry( int (QDECL  *syscallptr)( int arg,... ) ) {
+	syscall = syscallptr;
+}
+
+
+int PASSFLOAT( float x ) {
+	float	floatTemp;
+	floatTemp = x;
+	return *(int *)&floatTemp;
+}
+
+void	trap_Print( const char *fmt ) {
+	syscall( CG_PRINT, fmt );
+}
+
+void	trap_Error( const char *fmt ) {
+	syscall( CG_ERROR, fmt );
+}
+
+int		trap_Milliseconds( void ) {
+	return syscall( CG_MILLISECONDS ); 
+}
+
+//rww - precision timer funcs... -ALWAYS- call end after start with supplied ptr, or you'll get a nasty memory leak.
+//not that you should be using these outside of debug anyway.. because you shouldn't be. So don't.
+
+//Start should be suppled with a pointer to an empty pointer (e.g. void *blah; trap_PrecisionTimer_Start(&blah);),
+//the empty pointer will be filled with an exe address to our timer (this address means nothing in vm land however).
+//You must pass this pointer back unmodified to the timer end func.
+void trap_PrecisionTimer_Start(void **theNewTimer)
+{
+	syscall(CG_PRECISIONTIMER_START, theNewTimer);
+}
+
+//If you're using the above example, the appropriate call for this is int result = trap_PrecisionTimer_End(blah);
+int trap_PrecisionTimer_End(void *theTimer)
+{
+	return syscall(CG_PRECISIONTIMER_END, theTimer);
+}
+
+void	trap_Cvar_Register( vmCvar_t *vmCvar, const char *varName, const char *defaultValue, int flags ) {
+	syscall( CG_CVAR_REGISTER, vmCvar, varName, defaultValue, flags );
+}
+
+void	trap_Cvar_Update( vmCvar_t *vmCvar ) {
+	syscall( CG_CVAR_UPDATE, vmCvar );
+}
+
+void	trap_Cvar_Set( const char *var_name, const char *value ) {
+	syscall( CG_CVAR_SET, var_name, value );
+}
+
+void trap_Cvar_VariableStringBuffer( const char *var_name, char *buffer, int bufsize ) {
+	syscall( CG_CVAR_VARIABLESTRINGBUFFER, var_name, buffer, bufsize );
+}
+
+int trap_Cvar_GetHiddenVarValue(const char *name)
+{
+	return syscall(CG_CVAR_GETHIDDENVALUE, name);
+}
+
+int		trap_Argc( void ) {
+	return syscall( CG_ARGC );
+}
+
+void	trap_Argv( int n, char *buffer, int bufferLength ) {
+	syscall( CG_ARGV, n, buffer, bufferLength );
+}
+
+void	trap_Args( char *buffer, int bufferLength ) {
+	syscall( CG_ARGS, buffer, bufferLength );
+}
+
+int		trap_FS_FOpenFile( const char *qpath, fileHandle_t *f, fsMode_t mode ) {
+	return syscall( CG_FS_FOPENFILE, qpath, f, mode );
+}
+
+void	trap_FS_Read( void *buffer, int len, fileHandle_t f ) {
+	syscall( CG_FS_READ, buffer, len, f );
+}
+
+void	trap_FS_Write( const void *buffer, int len, fileHandle_t f ) {
+	syscall( CG_FS_WRITE, buffer, len, f );
+}
+
+void	trap_FS_FCloseFile( fileHandle_t f ) {
+	syscall( CG_FS_FCLOSEFILE, f );
+}
+
+int trap_FS_GetFileList(  const char *path, const char *extension, char *listbuf, int bufsize ) {
+	return syscall( CG_FS_GETFILELIST, path, extension, listbuf, bufsize );
+}
+
+void	trap_SendConsoleCommand( const char *text ) {
+	syscall( CG_SENDCONSOLECOMMAND, text );
+}
+
+void	trap_AddCommand( const char *cmdName ) {
+	syscall( CG_ADDCOMMAND, cmdName );
+}
+
+void	trap_RemoveCommand( const char *cmdName ) {
+	syscall( CG_REMOVECOMMAND, cmdName );
+}
+
+void	trap_SendClientCommand( const char *s ) {
+	syscall( CG_SENDCLIENTCOMMAND, s );
+}
+
+void	trap_UpdateScreen( void ) {
+	syscall( CG_UPDATESCREEN );
+}
+
+void	trap_CM_LoadMap( const char *mapname, qboolean SubBSP ) {
+	syscall( CG_CM_LOADMAP, mapname, SubBSP );
+}
+
+int		trap_CM_NumInlineModels( void ) {
+	return syscall( CG_CM_NUMINLINEMODELS );
+}
+
+clipHandle_t trap_CM_InlineModel( int index ) {
+	return syscall( CG_CM_INLINEMODEL, index );
+}
+
+clipHandle_t trap_CM_TempBoxModel( const vec3_t mins, const vec3_t maxs ) {
+	return syscall( CG_CM_TEMPBOXMODEL, mins, maxs );
+}
+
+clipHandle_t trap_CM_TempCapsuleModel( const vec3_t mins, const vec3_t maxs ) {
+	return syscall( CG_CM_TEMPCAPSULEMODEL, mins, maxs );
+}
+
+int		trap_CM_PointContents( const vec3_t p, clipHandle_t model ) {
+	return syscall( CG_CM_POINTCONTENTS, p, model );
+}
+
+int		trap_CM_TransformedPointContents( const vec3_t p, clipHandle_t model, const vec3_t origin, const vec3_t angles ) {
+	return syscall( CG_CM_TRANSFORMEDPOINTCONTENTS, p, model, origin, angles );
+}
+
+void	trap_CM_BoxTrace( trace_t *results, const vec3_t start, const vec3_t end,
+						  const vec3_t mins, const vec3_t maxs,
+						  clipHandle_t model, int brushmask ) {
+	syscall( CG_CM_BOXTRACE, results, start, end, mins, maxs, model, brushmask );
+}
+
+void	trap_CM_CapsuleTrace( trace_t *results, const vec3_t start, const vec3_t end,
+						  const vec3_t mins, const vec3_t maxs,
+						  clipHandle_t model, int brushmask ) {
+	syscall( CG_CM_CAPSULETRACE, results, start, end, mins, maxs, model, brushmask );
+}
+
+void	trap_CM_TransformedBoxTrace( trace_t *results, const vec3_t start, const vec3_t end,
+						  const vec3_t mins, const vec3_t maxs,
+						  clipHandle_t model, int brushmask,
+						  const vec3_t origin, const vec3_t angles ) {
+	syscall( CG_CM_TRANSFORMEDBOXTRACE, results, start, end, mins, maxs, model, brushmask, origin, angles );
+}
+
+void	trap_CM_TransformedCapsuleTrace( trace_t *results, const vec3_t start, const vec3_t end,
+						  const vec3_t mins, const vec3_t maxs,
+						  clipHandle_t model, int brushmask,
+						  const vec3_t origin, const vec3_t angles ) {
+	syscall( CG_CM_TRANSFORMEDCAPSULETRACE, results, start, end, mins, maxs, model, brushmask, origin, angles );
+}
+
+int		trap_CM_MarkFragments( int numPoints, const vec3_t *points, 
+				const vec3_t projection,
+				int maxPoints, vec3_t pointBuffer,
+				int maxFragments, markFragment_t *fragmentBuffer ) {
+	return syscall( CG_CM_MARKFRAGMENTS, numPoints, points, projection, maxPoints, pointBuffer, maxFragments, fragmentBuffer );
+}
+
+int trap_S_GetVoiceVolume( int entityNum ) {
+	return syscall( CG_S_GETVOICEVOLUME, entityNum );
+}
+
+void	trap_S_MuteSound( int entityNum, int entchannel ) {
+	syscall( CG_S_MUTESOUND, entityNum, entchannel );
+}
+
+void	trap_S_StartSound( vec3_t origin, int entityNum, int entchannel, sfxHandle_t sfx ) {
+	syscall( CG_S_STARTSOUND, origin, entityNum, entchannel, sfx );
+}
+
+void	trap_S_StartLocalSound( sfxHandle_t sfx, int channelNum ) {
+	syscall( CG_S_STARTLOCALSOUND, sfx, channelNum );
+}
+
+void	trap_S_ClearLoopingSounds(void) {
+	syscall( CG_S_CLEARLOOPINGSOUNDS );
+}
+
+void	trap_S_AddLoopingSound( int entityNum, const vec3_t origin, const vec3_t velocity, sfxHandle_t sfx ) {
+	syscall( CG_S_ADDLOOPINGSOUND, entityNum, origin, velocity, sfx );
+}
+
+void	trap_S_UpdateEntityPosition( int entityNum, const vec3_t origin ) {
+	syscall( CG_S_UPDATEENTITYPOSITION, entityNum, origin );
+}
+
+void	trap_S_AddRealLoopingSound( int entityNum, const vec3_t origin, const vec3_t velocity, sfxHandle_t sfx ) {
+	syscall( CG_S_ADDREALLOOPINGSOUND, entityNum, origin, velocity, sfx );
+}
+
+void	trap_S_StopLoopingSound( int entityNum ) {
+	syscall( CG_S_STOPLOOPINGSOUND, entityNum );
+}
+
+void	trap_S_Respatialize( int entityNum, const vec3_t origin, vec3_t axis[3], int inwater ) {
+	syscall( CG_S_RESPATIALIZE, entityNum, origin, axis, inwater );
+}
+
+void trap_S_ShutUp(qboolean shutUpFactor)
+{
+	syscall(CG_S_SHUTUP, shutUpFactor);
+}
+
+sfxHandle_t	trap_S_RegisterSound( const char *sample ) {
+	return syscall( CG_S_REGISTERSOUND, sample );
+}
+
+void	trap_S_StartBackgroundTrack( const char *intro, const char *loop, qboolean bReturnWithoutStarting  ) {
+	syscall( CG_S_STARTBACKGROUNDTRACK, intro, loop, bReturnWithoutStarting  );
+}
+
+void trap_S_UpdateAmbientSet( const char *name, vec3_t origin )
+{
+	syscall(CG_S_UPDATEAMBIENTSET, name, origin);
+}
+
+void trap_AS_ParseSets( void )
+{
+	syscall(CG_AS_PARSESETS);
+}
+
+void trap_AS_AddPrecacheEntry( const char *name )
+{
+	syscall(CG_AS_ADDPRECACHEENTRY, name);
+}
+
+int trap_S_AddLocalSet( const char *name, vec3_t listener_origin, vec3_t origin, int entID, int time )
+{
+	return syscall(CG_S_ADDLOCALSET, name, listener_origin, origin, entID, time);
+}
+
+sfxHandle_t trap_AS_GetBModelSound( const char *name, int stage )
+{
+	return syscall(CG_AS_GETBMODELSOUND, name, stage);
+}
+
+void	trap_R_LoadWorldMap( const char *mapname ) {
+	syscall( CG_R_LOADWORLDMAP, mapname );
+}
+
+qhandle_t trap_R_RegisterModel( const char *name ) {
+	return syscall( CG_R_REGISTERMODEL, name );
+}
+
+qhandle_t trap_R_RegisterSkin( const char *name ) {
+	return syscall( CG_R_REGISTERSKIN, name );
+}
+
+qhandle_t trap_R_RegisterShader( const char *name ) {
+	return syscall( CG_R_REGISTERSHADER, name );
+}
+
+qhandle_t trap_R_RegisterShaderNoMip( const char *name ) {
+	return syscall( CG_R_REGISTERSHADERNOMIP, name );
+}
+
+qhandle_t trap_R_RegisterFont( const char *fontName )
+{
+	return syscall( CG_R_REGISTERFONT, fontName);
+}
+
+int	trap_R_Font_StrLenPixels(const char *text, const int iFontIndex, const float scale)
+{
+	return syscall( CG_R_FONT_STRLENPIXELS, text, iFontIndex, PASSFLOAT(scale));
+}
+
+int trap_R_Font_StrLenChars(const char *text)
+{
+	return syscall( CG_R_FONT_STRLENCHARS, text);
+}
+
+int trap_R_Font_HeightPixels(const int iFontIndex, const float scale)
+{
+	return syscall( CG_R_FONT_STRHEIGHTPIXELS, iFontIndex, PASSFLOAT(scale));
+}
+
+void trap_R_Font_DrawString(int ox, int oy, const char *text, const float *rgba, const int setIndex, int iCharLimit, const float scale)
+{
+	syscall( CG_R_FONT_DRAWSTRING, ox, oy, text, rgba, setIndex, iCharLimit, PASSFLOAT(scale));
+}
+
+qboolean trap_Language_IsAsian(void)
+{
+	return syscall( CG_LANGUAGE_ISASIAN );
+}
+
+qboolean trap_Language_UsesSpaces(void)
+{
+	return syscall( CG_LANGUAGE_USESSPACES );
+}
+
+unsigned int trap_AnyLanguage_ReadCharFromString( const char *psText, int *piAdvanceCount, qboolean *pbIsTrailingPunctuation/* = NULL*/ )
+{
+	return syscall( CG_ANYLANGUAGE_READCHARFROMSTRING, psText, piAdvanceCount, pbIsTrailingPunctuation);
+}
+
+void	trap_R_ClearScene( void ) {
+	syscall( CG_R_CLEARSCENE );
+}
+
+void trap_R_ClearDecals ( void )
+{
+	syscall ( CG_R_CLEARDECALS );
+}
+
+void	trap_R_AddRefEntityToScene( const refEntity_t *re ) {
+	syscall( CG_R_ADDREFENTITYTOSCENE, re );
+}
+
+void	trap_R_AddPolyToScene( qhandle_t hShader , int numVerts, const polyVert_t *verts ) {
+	syscall( CG_R_ADDPOLYTOSCENE, hShader, numVerts, verts );
+}
+
+void	trap_R_AddPolysToScene( qhandle_t hShader , int numVerts, const polyVert_t *verts, int num ) {
+	syscall( CG_R_ADDPOLYSTOSCENE, hShader, numVerts, verts, num );
+}
+
+void trap_R_AddDecalToScene ( qhandle_t shader, const vec3_t origin, const vec3_t dir, float orientation, float r, float g, float b, float a, qboolean alphaFade, float radius, qboolean temporary )
+{
+	syscall( CG_R_ADDDECALTOSCENE, shader, origin, dir, PASSFLOAT(orientation), PASSFLOAT(r), PASSFLOAT(g), PASSFLOAT(b), PASSFLOAT(a), alphaFade, PASSFLOAT(radius), temporary );
+}
+
+int		trap_R_LightForPoint( vec3_t point, vec3_t ambientLight, vec3_t directedLight, vec3_t lightDir ) {
+	return syscall( CG_R_LIGHTFORPOINT, point, ambientLight, directedLight, lightDir );
+}
+
+void	trap_R_AddLightToScene( const vec3_t org, float intensity, float r, float g, float b ) {
+	syscall( CG_R_ADDLIGHTTOSCENE, org, PASSFLOAT(intensity), PASSFLOAT(r), PASSFLOAT(g), PASSFLOAT(b) );
+}
+
+void	trap_R_AddAdditiveLightToScene( const vec3_t org, float intensity, float r, float g, float b ) {
+	syscall( CG_R_ADDADDITIVELIGHTTOSCENE, org, PASSFLOAT(intensity), PASSFLOAT(r), PASSFLOAT(g), PASSFLOAT(b) );
+}
+
+void	trap_R_RenderScene( const refdef_t *fd ) {
+	syscall( CG_R_RENDERSCENE, fd );
+}
+
+void	trap_R_SetColor( const float *rgba ) {
+	syscall( CG_R_SETCOLOR, rgba );
+}
+
+void	trap_R_DrawStretchPic( float x, float y, float w, float h, 
+							   float s1, float t1, float s2, float t2, qhandle_t hShader ) {
+	syscall( CG_R_DRAWSTRETCHPIC, PASSFLOAT(x), PASSFLOAT(y), PASSFLOAT(w), PASSFLOAT(h), PASSFLOAT(s1), PASSFLOAT(t1), PASSFLOAT(s2), PASSFLOAT(t2), hShader );
+}
+
+void	trap_R_ModelBounds( clipHandle_t model, vec3_t mins, vec3_t maxs ) {
+	syscall( CG_R_MODELBOUNDS, model, mins, maxs );
+}
+
+int		trap_R_LerpTag( orientation_t *tag, clipHandle_t mod, int startFrame, int endFrame, 
+					   float frac, const char *tagName ) {
+	return syscall( CG_R_LERPTAG, tag, mod, startFrame, endFrame, PASSFLOAT(frac), tagName );
+}
+
+void	trap_R_DrawRotatePic( float x, float y, float w, float h, 
+				   float s1, float t1, float s2, float t2,float a, qhandle_t hShader ) 
+{
+	syscall( CG_R_DRAWROTATEPIC, PASSFLOAT(x), PASSFLOAT(y), PASSFLOAT(w), PASSFLOAT(h), PASSFLOAT(s1), PASSFLOAT(t1), PASSFLOAT(s2), PASSFLOAT(t2), PASSFLOAT(a), hShader );
+}
+
+void	trap_R_DrawRotatePic2( float x, float y, float w, float h, 
+				   float s1, float t1, float s2, float t2,float a, qhandle_t hShader ) 
+{
+	syscall( CG_R_DRAWROTATEPIC2, PASSFLOAT(x), PASSFLOAT(y), PASSFLOAT(w), PASSFLOAT(h), PASSFLOAT(s1), PASSFLOAT(t1), PASSFLOAT(s2), PASSFLOAT(t2), PASSFLOAT(a), hShader );
+}
+
+//linear fogging, with settable range -rww
+void trap_R_SetRangeFog(float range)
+{
+	syscall(CG_R_SETRANGEFOG, PASSFLOAT(range));
+}
+
+//set some properties for the draw layer for my refractive effect (here primarily for mod authors) -rww
+void trap_R_SetRefractProp(float alpha, float stretch, qboolean prepost, qboolean negate)
+{
+	syscall(CG_R_SETREFRACTIONPROP, PASSFLOAT(alpha), PASSFLOAT(stretch), prepost, negate);
+}
+
+void	trap_R_RemapShader( const char *oldShader, const char *newShader, const char *timeOffset ) 
+{
+	syscall( CG_R_REMAP_SHADER, oldShader, newShader, timeOffset );
+}
+
+void	trap_R_GetLightStyle(int style, color4ub_t color)
+{
+	syscall( CG_R_GET_LIGHT_STYLE, style, color );
+}
+
+void	trap_R_SetLightStyle(int style, int color)
+{
+	syscall( CG_R_SET_LIGHT_STYLE, style, color );
+}
+
+void	trap_R_GetBModelVerts(int bmodelIndex, vec3_t *verts, vec3_t normal )
+{
+	syscall( CG_R_GET_BMODEL_VERTS, bmodelIndex, verts, normal );
+}
+
+void trap_R_GetDistanceCull(float *f)
+{
+	syscall(CG_R_GETDISTANCECULL, f);
+}
+
+//get screen resolution -rww
+void trap_R_GetRealRes(int *w, int *h)
+{
+	syscall( CG_R_GETREALRES, w, h );
+}
+
+
+//automap elevation setting -rww
+void trap_R_AutomapElevAdj(float newHeight)
+{
+	syscall( CG_R_AUTOMAPELEVADJ, PASSFLOAT(newHeight) );
+}
+
+//initialize automap -rww
+qboolean trap_R_InitWireframeAutomap(void)
+{
+	return syscall( CG_R_INITWIREFRAMEAUTO );
+}
+
+void	trap_FX_AddLine( const vec3_t start, const vec3_t end, float size1, float size2, float sizeParm,
+									float alpha1, float alpha2, float alphaParm,
+									const vec3_t sRGB, const vec3_t eRGB, float rgbParm,
+									int killTime, qhandle_t shader, int flags)
+{
+	syscall( CG_FX_ADDLINE, start, end, PASSFLOAT(size1), PASSFLOAT(size2), PASSFLOAT(sizeParm),
+									PASSFLOAT(alpha1), PASSFLOAT(alpha2), PASSFLOAT(alphaParm),
+									sRGB, eRGB, PASSFLOAT(rgbParm),
+									killTime, shader, flags);
+}
+
+void		trap_GetGlconfig( glconfig_t *glconfig ) {
+	syscall( CG_GETGLCONFIG, glconfig );
+}
+
+void		trap_GetGameState( gameState_t *gamestate ) {
+	syscall( CG_GETGAMESTATE, gamestate );
+}
+
+void		trap_GetCurrentSnapshotNumber( int *snapshotNumber, int *serverTime ) {
+	syscall( CG_GETCURRENTSNAPSHOTNUMBER, snapshotNumber, serverTime );
+}
+
+qboolean	trap_GetSnapshot( int snapshotNumber, snapshot_t *snapshot ) {
+	return syscall( CG_GETSNAPSHOT, snapshotNumber, snapshot );
+}
+
+qboolean	trap_GetDefaultState(int entityIndex, entityState_t *state )
+{ //rwwRMG - added [NEWTRAP]
+	return syscall( CG_GETDEFAULTSTATE, entityIndex, state );
+}
+
+qboolean	trap_GetServerCommand( int serverCommandNumber ) {
+	return syscall( CG_GETSERVERCOMMAND, serverCommandNumber );
+}
+
+int			trap_GetCurrentCmdNumber( void ) {
+	return syscall( CG_GETCURRENTCMDNUMBER );
+}
+
+qboolean	trap_GetUserCmd( int cmdNumber, usercmd_t *ucmd ) {
+	return syscall( CG_GETUSERCMD, cmdNumber, ucmd );
+}
+
+void		trap_SetUserCmdValue( int stateValue, float sensitivityScale, float mPitchOverride, float mYawOverride, float mSensitivityOverride, int fpSel, int invenSel, qboolean fighterControls ) {
+	syscall( CG_SETUSERCMDVALUE, stateValue, PASSFLOAT(sensitivityScale), PASSFLOAT(mPitchOverride), PASSFLOAT(mYawOverride), PASSFLOAT(mSensitivityOverride), fpSel, invenSel, fighterControls );
+}
+
+void trap_SetClientForceAngle(int time, vec3_t angle)
+{
+	syscall( CG_SETCLIENTFORCEANGLE, time, angle );
+}
+
+void trap_SetClientTurnExtent(float turnAdd, float turnSub, int turnTime)
+{
+	syscall( CG_SETCLIENTTURNEXTENT, PASSFLOAT(turnAdd), PASSFLOAT(turnSub), turnTime );
+}
+
+void trap_OpenUIMenu(int menuID)
+{
+	syscall( CG_OPENUIMENU, menuID );
+}
+
+void		testPrintInt( char *string, int i ) {
+	syscall( CG_TESTPRINTINT, string, i );
+}
+
+void		testPrintFloat( char *string, float f ) {
+	syscall( CG_TESTPRINTFLOAT, string, PASSFLOAT(f) );
+}
+
+int trap_MemoryRemaining( void ) {
+	return syscall( CG_MEMORY_REMAINING );
+}
+
+qboolean trap_Key_IsDown( int keynum ) {
+	return syscall( CG_KEY_ISDOWN, keynum );
+}
+
+int trap_Key_GetCatcher( void ) {
+	return syscall( CG_KEY_GETCATCHER );
+}
+
+void trap_Key_SetCatcher( int catcher ) {
+	syscall( CG_KEY_SETCATCHER, catcher );
+}
+
+int trap_Key_GetKey( const char *binding ) {
+	return syscall( CG_KEY_GETKEY, binding );
+}
+
+int trap_PC_AddGlobalDefine( char *define ) {
+	return syscall( CG_PC_ADD_GLOBAL_DEFINE, define );
+}
+
+int trap_PC_LoadSource( const char *filename ) {
+	return syscall( CG_PC_LOAD_SOURCE, filename );
+}
+
+int trap_PC_FreeSource( int handle ) {
+	return syscall( CG_PC_FREE_SOURCE, handle );
+}
+
+int trap_PC_ReadToken( int handle, pc_token_t *pc_token ) {
+	return syscall( CG_PC_READ_TOKEN, handle, pc_token );
+}
+
+int trap_PC_SourceFileAndLine( int handle, char *filename, int *line ) {
+	return syscall( CG_PC_SOURCE_FILE_AND_LINE, handle, filename, line );
+}
+
+int trap_PC_LoadGlobalDefines ( const char* filename )
+{
+	return syscall ( CG_PC_LOAD_GLOBAL_DEFINES, filename );
+}
+
+void trap_PC_RemoveAllGlobalDefines ( void )
+{
+	syscall ( CG_PC_REMOVE_ALL_GLOBAL_DEFINES );
+}
+
+void	trap_S_StopBackgroundTrack( void ) {
+	syscall( CG_S_STOPBACKGROUNDTRACK );
+}
+
+int trap_RealTime(qtime_t *qtime) {
+	return syscall( CG_REAL_TIME, qtime );
+}
+
+void trap_SnapVector( float *v ) {
+	syscall( CG_SNAPVECTOR, v );
+}
+
+// this returns a handle.  arg0 is the name in the format "idlogo.roq", set arg1 to NULL, alteredstates to qfalse (do not alter gamestate)
+int trap_CIN_PlayCinematic( const char *arg0, int xpos, int ypos, int width, int height, int bits) {
+  return syscall(CG_CIN_PLAYCINEMATIC, arg0, xpos, ypos, width, height, bits);
+}
+ 
+// stops playing the cinematic and ends it.  should always return FMV_EOF
+// cinematics must be stopped in reverse order of when they are started
+e_status trap_CIN_StopCinematic(int handle) {
+  return syscall(CG_CIN_STOPCINEMATIC, handle);
+}
+
+
+// will run a frame of the cinematic but will not draw it.  Will return FMV_EOF if the end of the cinematic has been reached.
+e_status trap_CIN_RunCinematic (int handle) {
+  return syscall(CG_CIN_RUNCINEMATIC, handle);
+}
+ 
+
+// draws the current frame
+void trap_CIN_DrawCinematic (int handle) {
+  syscall(CG_CIN_DRAWCINEMATIC, handle);
+}
+ 
+
+// allows you to resize the animation dynamically
+void trap_CIN_SetExtents (int handle, int x, int y, int w, int h) {
+  syscall(CG_CIN_SETEXTENTS, handle, x, y, w, h);
+}
+
+qboolean trap_GetEntityToken( char *buffer, int bufferSize ) {
+	return syscall( CG_GET_ENTITY_TOKEN, buffer, bufferSize );
+}
+
+qboolean trap_R_inPVS( const vec3_t p1, const vec3_t p2, byte *mask ) {
+	return syscall( CG_R_INPVS, p1, p2, mask );
+}
+
+
+int	trap_FX_RegisterEffect(const char *file)
+{
+	return syscall( CG_FX_REGISTER_EFFECT, file);
+}
+
+void trap_FX_PlayEffect( const char *file, vec3_t org, vec3_t fwd, int vol, int rad )
+{
+	syscall( CG_FX_PLAY_EFFECT, file, org, fwd, vol, rad);
+}
+
+void trap_FX_PlayEntityEffect( const char *file, vec3_t org, 
+						vec3_t axis[3], const int boltInfo, const int entNum, int vol, int rad )
+{
+	syscall( CG_FX_PLAY_ENTITY_EFFECT, file, org, axis, boltInfo, entNum, vol, rad );
+}
+
+void trap_FX_PlayEffectID( int id, vec3_t org, vec3_t fwd, int vol, int rad )
+{
+	syscall( CG_FX_PLAY_EFFECT_ID, id, org, fwd, vol, rad );
+}
+
+void trap_FX_PlayPortalEffectID( int id, vec3_t org, vec3_t fwd, int vol, int rad )
+{
+	syscall( CG_FX_PLAY_PORTAL_EFFECT_ID, id, org, fwd);
+}
+
+void trap_FX_PlayEntityEffectID( int id, vec3_t org, 
+						vec3_t axis[3], const int boltInfo, const int entNum, int vol, int rad )
+{
+	syscall( CG_FX_PLAY_ENTITY_EFFECT_ID, id, org, axis, boltInfo, entNum, vol, rad );
+}
+
+void trap_FX_PlayBoltedEffectID( int id, vec3_t org, 
+						void *ghoul2, const int boltNum, const int entNum, const int modelNum, int iLooptime, qboolean isRelative )
+{
+	syscall( CG_FX_PLAY_BOLTED_EFFECT_ID, id, org, ghoul2, boltNum, entNum, modelNum, iLooptime, isRelative );
+}
+
+void trap_FX_AddScheduledEffects( qboolean skyPortal )
+{
+	syscall( CG_FX_ADD_SCHEDULED_EFFECTS, skyPortal );
+}
+
+void trap_FX_Draw2DEffects ( float screenXScale, float screenYScale )
+{
+	syscall( CG_FX_DRAW_2D_EFFECTS, PASSFLOAT(screenXScale), PASSFLOAT(screenYScale) );
+}	
+
+int	trap_FX_InitSystem( refdef_t* refdef )
+{
+	return syscall( CG_FX_INIT_SYSTEM, refdef );
+}
+
+void trap_FX_SetRefDef( refdef_t* refdef )
+{
+	syscall( CG_FX_SET_REFDEF, refdef );
+}
+
+qboolean trap_FX_FreeSystem( void )
+{
+	return syscall( CG_FX_FREE_SYSTEM );
+}
+
+void trap_FX_Reset ( void )
+{
+	syscall ( CG_FX_RESET );
+}
+
+void trap_FX_AdjustTime( int time )
+{
+	syscall( CG_FX_ADJUST_TIME, time );
+}
+
+
+void trap_FX_AddPoly( addpolyArgStruct_t *p )
+{
+	syscall( CG_FX_ADDPOLY, p );
+}
+
+void trap_FX_AddBezier( addbezierArgStruct_t *p )
+{
+	syscall( CG_FX_ADDBEZIER, p );
+}
+
+void trap_FX_AddPrimitive( effectTrailArgStruct_t *p )
+{
+	syscall( CG_FX_ADDPRIMITIVE, p );
+}
+
+void trap_FX_AddSprite( addspriteArgStruct_t *p )
+{
+	syscall( CG_FX_ADDSPRITE, p );
+}
+
+void trap_FX_AddElectricity( addElectricityArgStruct_t *p )
+{
+	syscall( CG_FX_ADDELECTRICITY, p );
+}
+
+//void trap_SP_Print(const unsigned ID, byte *Data)
+//{
+//	syscall( CG_SP_PRINT, ID, Data);
+//}
+
+int trap_SP_GetStringTextString(const char *text, char *buffer, int bufferLength)
+{
+	return syscall( CG_SP_GETSTRINGTEXTSTRING, text, buffer, bufferLength );
+}
+
+qboolean trap_ROFF_Clean( void ) 
+{
+	return syscall( CG_ROFF_CLEAN );
+}
+
+void trap_ROFF_UpdateEntities( void ) 
+{
+	syscall( CG_ROFF_UPDATE_ENTITIES );
+}
+
+int trap_ROFF_Cache( char *file ) 
+{
+	return syscall( CG_ROFF_CACHE, file );
+}
+
+qboolean trap_ROFF_Play( int entID, int roffID, qboolean doTranslation ) 
+{
+	return syscall( CG_ROFF_PLAY, entID, roffID, doTranslation );
+}
+
+qboolean trap_ROFF_Purge_Ent( int entID ) 
+{
+	return syscall( CG_ROFF_PURGE_ENT, entID );
+}
+
+
+//rww - dynamic vm memory allocation!
+void trap_TrueMalloc(void **ptr, int size)
+{
+	syscall(CG_TRUEMALLOC, ptr, size);
+}
+
+void trap_TrueFree(void **ptr)
+{
+	syscall(CG_TRUEFREE, ptr);
+}
+
+/*
+Ghoul2 Insert Start
+*/
+// CG Specific API calls
+void trap_G2_ListModelSurfaces(void *ghlInfo)
+{
+	syscall( CG_G2_LISTSURFACES, ghlInfo);
+}
+
+void trap_G2_ListModelBones(void *ghlInfo, int frame)
+{
+	syscall( CG_G2_LISTBONES, ghlInfo, frame);
+}
+
+void trap_G2_SetGhoul2ModelIndexes(void *ghoul2, qhandle_t *modelList, qhandle_t *skinList)
+{
+	syscall( CG_G2_SETMODELS, ghoul2, modelList, skinList);
+}
+
+qboolean trap_G2_HaveWeGhoul2Models(void *ghoul2)
+{
+	return (qboolean)(syscall(CG_G2_HAVEWEGHOULMODELS, ghoul2));
+}
+
+qboolean trap_G2API_GetBoltMatrix(void *ghoul2, const int modelIndex, const int boltIndex, mdxaBone_t *matrix,
+								const vec3_t angles, const vec3_t position, const int frameNum, qhandle_t *modelList, vec3_t scale)
+{
+	return (qboolean)(syscall(CG_G2_GETBOLT, ghoul2, modelIndex, boltIndex, matrix, angles, position, frameNum, modelList, scale));
+}
+
+qboolean trap_G2API_GetBoltMatrix_NoReconstruct(void *ghoul2, const int modelIndex, const int boltIndex, mdxaBone_t *matrix,
+								const vec3_t angles, const vec3_t position, const int frameNum, qhandle_t *modelList, vec3_t scale)
+{ //Same as above but force it to not reconstruct the skeleton before getting the bolt position
+	return (qboolean)(syscall(CG_G2_GETBOLT_NOREC, ghoul2, modelIndex, boltIndex, matrix, angles, position, frameNum, modelList, scale));
+}
+
+qboolean trap_G2API_GetBoltMatrix_NoRecNoRot(void *ghoul2, const int modelIndex, const int boltIndex, mdxaBone_t *matrix,
+								const vec3_t angles, const vec3_t position, const int frameNum, qhandle_t *modelList, vec3_t scale)
+{ //Same as above but force it to not reconstruct the skeleton before getting the bolt position
+	return (qboolean)(syscall(CG_G2_GETBOLT_NOREC_NOROT, ghoul2, modelIndex, boltIndex, matrix, angles, position, frameNum, modelList, scale));
+}
+
+int trap_G2API_InitGhoul2Model(void **ghoul2Ptr, const char *fileName, int modelIndex, qhandle_t customSkin,
+						  qhandle_t customShader, int modelFlags, int lodBias)
+{
+	return syscall(CG_G2_INITGHOUL2MODEL, ghoul2Ptr, fileName, modelIndex, customSkin, customShader, modelFlags, lodBias);
+}
+
+qboolean trap_G2API_SetSkin(void *ghoul2, int modelIndex, qhandle_t customSkin, qhandle_t renderSkin)
+{
+	return syscall(CG_G2_SETSKIN, ghoul2, modelIndex, customSkin, renderSkin);
+}
+
+void trap_G2API_CollisionDetect ( 
+	CollisionRecord_t *collRecMap, 
+	void* ghoul2, 
+	const vec3_t angles, 
+	const vec3_t position,
+	int frameNumber, 
+	int entNum, 
+	const vec3_t rayStart, 
+	const vec3_t rayEnd, 
+	const vec3_t scale, 
+	int traceFlags, 
+	int useLod,
+	float fRadius
+	)
+{
+	syscall ( CG_G2_COLLISIONDETECT, collRecMap, ghoul2, angles, position, frameNumber, entNum, rayStart, rayEnd, scale, traceFlags, useLod, PASSFLOAT(fRadius) );
+}
+
+void trap_G2API_CleanGhoul2Models(void **ghoul2Ptr)
+{
+	syscall(CG_G2_CLEANMODELS, ghoul2Ptr);
+}
+
+qboolean trap_G2API_SetBoneAngles(void *ghoul2, int modelIndex, const char *boneName, const vec3_t angles, const int flags,
+								const int up, const int right, const int forward, qhandle_t *modelList,
+								int blendTime , int currentTime )
+{
+	return (syscall(CG_G2_ANGLEOVERRIDE, ghoul2, modelIndex, boneName, angles, flags, up, right, forward, modelList, blendTime, currentTime));
+}
+
+qboolean trap_G2API_SetBoneAnim(void *ghoul2, const int modelIndex, const char *boneName, const int startFrame, const int endFrame,
+							  const int flags, const float animSpeed, const int currentTime, const float setFrame , const int blendTime )
+{
+	return syscall(CG_G2_PLAYANIM, ghoul2, modelIndex, boneName, startFrame, endFrame, flags, PASSFLOAT(animSpeed), currentTime, PASSFLOAT(setFrame), blendTime);
+}
+
+qboolean trap_G2API_GetBoneAnim(void *ghoul2, const char *boneName, const int currentTime, float *currentFrame,
+						   int *startFrame, int *endFrame, int *flags, float *animSpeed, int *modelList, const int modelIndex)
+{
+	return syscall(CG_G2_GETBONEANIM, ghoul2, boneName, currentTime, currentFrame, startFrame, endFrame, flags, animSpeed, modelList, modelIndex);
+}
+
+qboolean trap_G2API_GetBoneFrame(void *ghoul2, const char *boneName, const int currentTime, float *currentFrame, int *modelList, const int modelIndex)
+{
+	return syscall(CG_G2_GETBONEFRAME, ghoul2, boneName, currentTime, currentFrame, modelList, modelIndex);
+}
+
+void trap_G2API_GetGLAName(void *ghoul2, int modelIndex, char *fillBuf)
+{
+	syscall(CG_G2_GETGLANAME, ghoul2, modelIndex, fillBuf);
+}
+
+int trap_G2API_CopyGhoul2Instance(void *g2From, void *g2To, int modelIndex)
+{
+	return syscall(CG_G2_COPYGHOUL2INSTANCE, g2From, g2To, modelIndex);
+}
+
+void trap_G2API_CopySpecificGhoul2Model(void *g2From, int modelFrom, void *g2To, int modelTo)
+{
+	syscall(CG_G2_COPYSPECIFICGHOUL2MODEL, g2From, modelFrom, g2To, modelTo);
+}
+
+void trap_G2API_DuplicateGhoul2Instance(void *g2From, void **g2To)
+{
+	syscall(CG_G2_DUPLICATEGHOUL2INSTANCE, g2From, g2To);
+}
+
+qboolean trap_G2API_HasGhoul2ModelOnIndex(void *ghlInfo, int modelIndex)
+{
+	return syscall(CG_G2_HASGHOUL2MODELONINDEX, ghlInfo, modelIndex);
+}
+
+qboolean trap_G2API_RemoveGhoul2Model(void *ghlInfo, int modelIndex)
+{
+	return syscall(CG_G2_REMOVEGHOUL2MODEL, ghlInfo, modelIndex);
+}
+
+qboolean trap_G2API_SkinlessModel(void *ghlInfo, int modelIndex)
+{
+	return syscall(CG_G2_SKINLESSMODEL, ghlInfo, modelIndex);
+}
+
+int trap_G2API_GetNumGoreMarks(void *ghlInfo, int modelIndex)
+{
+	return syscall(CG_G2_GETNUMGOREMARKS, ghlInfo, modelIndex);
+}
+
+void trap_G2API_AddSkinGore(void *ghlInfo,SSkinGoreData *gore)
+{
+	syscall(CG_G2_ADDSKINGORE, ghlInfo, gore);
+}
+
+void trap_G2API_ClearSkinGore ( void* ghlInfo )
+{
+	syscall(CG_G2_CLEARSKINGORE, ghlInfo );
+}
+
+int trap_G2API_Ghoul2Size ( void* ghlInfo )
+{
+	return syscall(CG_G2_SIZE, ghlInfo );
+}
+
+int	trap_G2API_AddBolt(void *ghoul2, int modelIndex, const char *boneName)
+{
+	return syscall(CG_G2_ADDBOLT, ghoul2, modelIndex, boneName);
+}
+
+qboolean trap_G2API_AttachEnt(int *boltInfo, void *ghlInfoTo, int toBoltIndex, int entNum, int toModelNum)
+{
+	return syscall(CG_G2_ATTACHENT, boltInfo, ghlInfoTo, toBoltIndex, entNum, toModelNum);
+}
+
+void trap_G2API_SetBoltInfo(void *ghoul2, int modelIndex, int boltInfo)
+{
+	syscall(CG_G2_SETBOLTON, ghoul2, modelIndex, boltInfo);
+}
+
+qboolean trap_G2API_SetRootSurface(void *ghoul2, const int modelIndex, const char *surfaceName)
+{
+	return syscall(CG_G2_SETROOTSURFACE, ghoul2, modelIndex, surfaceName);
+}
+
+qboolean trap_G2API_SetSurfaceOnOff(void *ghoul2, const char *surfaceName, const int flags)
+{
+	return syscall(CG_G2_SETSURFACEONOFF, ghoul2, surfaceName, flags);
+}
+
+qboolean trap_G2API_SetNewOrigin(void *ghoul2, const int boltIndex)
+{
+	return syscall(CG_G2_SETNEWORIGIN, ghoul2, boltIndex);
+}
+
+//check if a bone exists on skeleton without actually adding to the bone list -rww
+qboolean trap_G2API_DoesBoneExist(void *ghoul2, int modelIndex, const char *boneName)
+{
+	return syscall(CG_G2_DOESBONEEXIST, ghoul2, modelIndex, boneName);
+}
+
+int trap_G2API_GetSurfaceRenderStatus(void *ghoul2, const int modelIndex, const char *surfaceName)
+{
+	return syscall(CG_G2_GETSURFACERENDERSTATUS, ghoul2, modelIndex, surfaceName);
+}
+
+int trap_G2API_GetTime(void)
+{
+	return syscall(CG_G2_GETTIME);
+}
+
+void trap_G2API_SetTime(int time, int clock)
+{
+	syscall(CG_G2_SETTIME, time, clock);
+}
+
+//hack for smoothing during ugly situations. forgive me.
+void trap_G2API_AbsurdSmoothing(void *ghoul2, qboolean status)
+{
+	syscall(CG_G2_ABSURDSMOOTHING, ghoul2, status);
+}
+
+//rww - RAGDOLL_BEGIN
+void trap_G2API_SetRagDoll(void *ghoul2, sharedRagDollParams_t *params)
+{
+	syscall(CG_G2_SETRAGDOLL, ghoul2, params);
+}
+
+void trap_G2API_AnimateG2Models(void *ghoul2, int time, sharedRagDollUpdateParams_t *params)
+{
+	syscall(CG_G2_ANIMATEG2MODELS, ghoul2, time, params);
+}
+//rww - RAGDOLL_END
+
+//additional ragdoll options -rww
+qboolean trap_G2API_RagPCJConstraint(void *ghoul2, const char *boneName, vec3_t min, vec3_t max) //override default pcj bonee constraints
+{
+	return syscall(CG_G2_RAGPCJCONSTRAINT, ghoul2, boneName, min, max);
+}
+
+qboolean trap_G2API_RagPCJGradientSpeed(void *ghoul2, const char *boneName, const float speed) //override the default gradient movespeed for a pcj bone
+{
+	return syscall(CG_G2_RAGPCJGRADIENTSPEED, ghoul2, boneName, PASSFLOAT(speed));
+}
+
+qboolean trap_G2API_RagEffectorGoal(void *ghoul2, const char *boneName, vec3_t pos) //override an effector bone's goal position (world coordinates)
+{
+	return syscall(CG_G2_RAGEFFECTORGOAL, ghoul2, boneName, pos);
+}
+
+qboolean trap_G2API_GetRagBonePos(void *ghoul2, const char *boneName, vec3_t pos, vec3_t entAngles, vec3_t entPos, vec3_t entScale) //current position of said bone is put into pos (world coordinates)
+{
+	return syscall(CG_G2_GETRAGBONEPOS, ghoul2, boneName, pos, entAngles, entPos, entScale);
+}
+
+qboolean trap_G2API_RagEffectorKick(void *ghoul2, const char *boneName, vec3_t velocity) //add velocity to a rag bone
+{
+	return syscall(CG_G2_RAGEFFECTORKICK, ghoul2, boneName, velocity);
+}
+
+qboolean trap_G2API_RagForceSolve(void *ghoul2, qboolean force) //make sure we are actively performing solve/settle routines, if desired
+{
+	return syscall(CG_G2_RAGFORCESOLVE, ghoul2, force);
+}
+
+qboolean trap_G2API_SetBoneIKState(void *ghoul2, int time, const char *boneName, int ikState, sharedSetBoneIKStateParams_t *params)
+{
+	return syscall(CG_G2_SETBONEIKSTATE, ghoul2, time, boneName, ikState, params);
+}
+
+qboolean trap_G2API_IKMove(void *ghoul2, int time, sharedIKMoveParams_t *params)
+{
+	return syscall(CG_G2_IKMOVE, ghoul2, time, params);
+}
+
+qboolean trap_G2API_RemoveBone(void *ghoul2, const char *boneName, int modelIndex)
+{
+	return syscall(CG_G2_REMOVEBONE, ghoul2, boneName, modelIndex);
+}
+
+//rww - Stuff to allow association of ghoul2 instances to entity numbers.
+//This way, on listen servers when both the client and server are doing
+//ghoul2 operations, we can copy relevant data off the client instance
+//directly onto the server instance and slash the transforms and whatnot
+//right in half.
+void trap_G2API_AttachInstanceToEntNum(void *ghoul2, int entityNum, qboolean server)
+{
+	syscall(CG_G2_ATTACHINSTANCETOENTNUM, ghoul2, entityNum, server);
+}
+
+void trap_G2API_ClearAttachedInstance(int entityNum)
+{
+	syscall(CG_G2_CLEARATTACHEDINSTANCE, entityNum);
+}
+
+void trap_G2API_CleanEntAttachments(void)
+{
+	syscall(CG_G2_CLEANENTATTACHMENTS);
+}
+
+qboolean trap_G2API_OverrideServer(void *serverInstance)
+{
+	return syscall(CG_G2_OVERRIDESERVER, serverInstance);
+}
+
+void trap_G2API_GetSurfaceName(void *ghoul2, int surfNumber, int modelIndex, char *fillBuf)
+{
+	syscall(CG_G2_GETSURFACENAME, ghoul2, surfNumber, modelIndex, fillBuf);
+}
+
+void trap_CG_RegisterSharedMemory(char *memory)
+{
+	syscall(CG_SET_SHARED_BUFFER, memory);
+}
+
+int	trap_CM_RegisterTerrain(const char *config)
+{ //rwwRMG - added [NEWTRAP]
+	return syscall(CG_CM_REGISTER_TERRAIN, config);
+}
+
+void trap_RMG_Init(int terrainID, const char *terrainInfo)
+{ //rwwRMG - added [NEWTRAP]
+	syscall(CG_RMG_INIT, terrainID, terrainInfo);
+}
+
+void trap_RE_InitRendererTerrain( const char *info )
+{ //rwwRMG - added [NEWTRAP]
+	syscall(CG_RE_INIT_RENDERER_TERRAIN, info);
+}
+
+void trap_R_WeatherContentsOverride( int contents )
+{ //rwwRMG - added [NEWTRAP]
+	syscall(CG_R_WEATHER_CONTENTS_OVERRIDE, contents);
+}
+
+void trap_R_WorldEffectCommand(const char *cmd)
+{
+	syscall(CG_R_WORLDEFFECTCOMMAND, cmd);
+}
+
+void trap_WE_AddWeatherZone( const vec3_t mins, const vec3_t maxs )
+{
+	syscall( CG_WE_ADDWEATHERZONE, mins, maxs );
+}
+
+/*
+Ghoul2 Insert End
+*/
+
+#include "../namespace_end.h"
diff --git a/codemp/cgame/cg_turret.c b/codemp/cgame/cg_turret.c
new file mode 100644
index 0000000..c4f3a83
--- /dev/null
+++ b/codemp/cgame/cg_turret.c
@@ -0,0 +1,242 @@
+#include "cg_local.h"
+#include "..\game\q_shared.h"
+#include "..\ghoul2\g2.h"
+
+//rww - The turret is heavily dependant on bone angles. We can't happily set that on the server, so it is done client-only.
+
+void CreepToPosition(vec3_t ideal, vec3_t current)
+{
+	float max_degree_switch = 90;
+	int degrees_negative = 0;
+	int degrees_positive = 0;
+	int doNegative = 0;
+
+	int angle_ideal;
+	int angle_current;
+
+	angle_ideal = (int)ideal[YAW];
+	angle_current = (int)current[YAW];
+
+	if (angle_ideal <= angle_current)
+	{
+		degrees_negative = (angle_current - angle_ideal);
+
+		degrees_positive = (360 - angle_current) + angle_ideal;
+	}
+	else
+	{
+		degrees_negative = angle_current + (360 - angle_ideal);
+
+		degrees_positive = (angle_ideal - angle_current);
+	}
+
+	if (degrees_negative < degrees_positive)
+	{
+		doNegative = 1;
+	}
+
+	if (doNegative)
+	{
+		current[YAW] -= max_degree_switch;
+
+		if (current[YAW] < ideal[YAW] && (current[YAW]+(max_degree_switch*2)) >= ideal[YAW])
+		{
+			current[YAW] = ideal[YAW];
+		}
+
+		if (current[YAW] < 0)
+		{
+			current[YAW] += 361;
+		}
+	}
+	else
+	{
+		current[YAW] += max_degree_switch;
+
+		if (current[YAW] > ideal[YAW] && (current[YAW]-(max_degree_switch*2)) <= ideal[YAW])
+		{
+			current[YAW] = ideal[YAW];
+		}
+
+		if (current[YAW] > 360)
+		{
+			current[YAW] -= 361;
+		}
+	}
+
+	if (ideal[PITCH] < 0)
+	{
+		ideal[PITCH] += 360;
+	}
+
+	angle_ideal = (int)ideal[PITCH];
+	angle_current = (int)current[PITCH];
+
+	doNegative = 0;
+
+	if (angle_ideal <= angle_current)
+	{
+		degrees_negative = (angle_current - angle_ideal);
+
+		degrees_positive = (360 - angle_current) + angle_ideal;
+	}
+	else
+	{
+		degrees_negative = angle_current + (360 - angle_ideal);
+
+		degrees_positive = (angle_ideal - angle_current);
+	}
+
+	if (degrees_negative < degrees_positive)
+	{
+		doNegative = 1;
+	}
+
+	if (doNegative)
+	{
+		current[PITCH] -= max_degree_switch;
+
+		if (current[PITCH] < ideal[PITCH] && (current[PITCH]+(max_degree_switch*2)) >= ideal[PITCH])
+		{
+			current[PITCH] = ideal[PITCH];
+		}
+
+		if (current[PITCH] < 0)
+		{
+			current[PITCH] += 361;
+		}
+	}
+	else
+	{
+		current[PITCH] += max_degree_switch;
+
+		if (current[PITCH] > ideal[PITCH] && (current[PITCH]-(max_degree_switch*2)) <= ideal[PITCH])
+		{
+			current[PITCH] = ideal[PITCH];
+		}
+
+		if (current[PITCH] > 360)
+		{
+			current[PITCH] -= 361;
+		}
+	}
+}
+
+void TurretClientRun(centity_t *ent)
+{
+	if (!ent->ghoul2)
+	{
+		weaponInfo_t	*weaponInfo;
+
+		trap_G2API_InitGhoul2Model(&ent->ghoul2, CG_ConfigString( CS_MODELS+ent->currentState.modelindex ), 0, 0, 0, 0, 0);
+
+		if (!ent->ghoul2)
+		{ //bad
+			return;
+		}
+
+		ent->torsoBolt = trap_G2API_AddBolt( ent->ghoul2, 0, "*flash02" );
+
+		trap_G2API_SetBoneAngles( ent->ghoul2, 0, "bone_hinge", vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_Y, POSITIVE_Z, POSITIVE_X, NULL, 100, cg.time ); 
+		trap_G2API_SetBoneAngles( ent->ghoul2, 0, "bone_gback", vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_Y, POSITIVE_Z, POSITIVE_X, NULL, 100, cg.time ); 
+		trap_G2API_SetBoneAngles( ent->ghoul2, 0, "bone_barrel", vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_Y, POSITIVE_Z, POSITIVE_X, NULL, 100, cg.time ); 
+
+		trap_G2API_SetBoneAnim( ent->ghoul2, 0, "model_root", 0, 11, BONE_ANIM_OVERRIDE_FREEZE, 0.8f, cg.time, 0, 0 );
+
+		ent->turAngles[ROLL] = 0;
+		ent->turAngles[PITCH] = 90;
+		ent->turAngles[YAW] = 0;
+
+		weaponInfo = &cg_weapons[WP_TURRET];
+
+		if ( !weaponInfo->registered )
+		{
+			CG_RegisterWeapon(WP_TURRET);
+		}
+	}
+
+	if (ent->currentState.fireflag == 2)
+	{ //I'm about to blow
+		if (ent->turAngles)
+		{
+			trap_G2API_SetBoneAngles( ent->ghoul2, 0, "bone_hinge", ent->turAngles, BONE_ANGLES_REPLACE, NEGATIVE_Y, NEGATIVE_Z, NEGATIVE_X, NULL, 100, cg.time ); 
+		}
+		return;
+	}
+	else if (ent->currentState.fireflag && ent->bolt4 != ent->currentState.fireflag)
+	{
+		vec3_t muzzleOrg, muzzleDir;
+		mdxaBone_t boltMatrix;
+
+		trap_G2API_GetBoltMatrix(ent->ghoul2, 0, ent->torsoBolt, &boltMatrix, /*ent->lerpAngles*/vec3_origin, ent->lerpOrigin, cg.time, cgs.gameModels, ent->modelScale);
+		BG_GiveMeVectorFromMatrix(&boltMatrix, ORIGIN, muzzleOrg);
+		BG_GiveMeVectorFromMatrix(&boltMatrix, NEGATIVE_X, muzzleDir);
+
+		trap_FX_PlayEffectID(cgs.effects.mTurretMuzzleFlash, muzzleOrg, muzzleDir, -1, -1);
+
+		ent->bolt4 = ent->currentState.fireflag;
+	}
+	else if (!ent->currentState.fireflag)
+	{
+		ent->bolt4 = 0;
+	}
+
+	if (ent->currentState.bolt2 != ENTITYNUM_NONE)
+	{ //turn toward the enemy
+		centity_t *enemy = &cg_entities[ent->currentState.bolt2];
+
+		if (enemy)
+		{
+			vec3_t enAng;
+			vec3_t enPos;
+
+			VectorCopy(enemy->currentState.pos.trBase, enPos);
+
+			VectorSubtract(enPos, ent->lerpOrigin, enAng);
+			VectorNormalize(enAng);
+			vectoangles(enAng, enAng);
+			enAng[ROLL] = 0;
+			enAng[PITCH] += 90;
+
+			CreepToPosition(enAng, ent->turAngles);
+		}
+	}
+	else
+	{
+		vec3_t idleAng;
+		float turnAmount;
+
+		if (ent->turAngles[YAW] > 360)
+		{
+			ent->turAngles[YAW] -= 361;
+		}
+
+		if (!ent->dustTrailTime)
+		{
+			ent->dustTrailTime = cg.time;
+		}
+
+		turnAmount = (cg.time-ent->dustTrailTime)*0.03;
+
+		if (turnAmount > 360)
+		{
+			turnAmount = 360;
+		}
+
+		idleAng[PITCH] = 90;
+		idleAng[ROLL] = 0;
+		idleAng[YAW] = ent->turAngles[YAW] + turnAmount;
+		ent->dustTrailTime = cg.time;
+
+		CreepToPosition(idleAng, ent->turAngles);
+	}
+
+	if (cg.time < ent->frame_minus1_refreshed)
+	{
+		ent->frame_minus1_refreshed = cg.time;
+		return;
+	}
+
+	ent->frame_minus1_refreshed = cg.time;
+	trap_G2API_SetBoneAngles( ent->ghoul2, 0, "bone_hinge", ent->turAngles, BONE_ANGLES_REPLACE, NEGATIVE_Y, NEGATIVE_Z, NEGATIVE_X, NULL, 100, cg.time ); 
+}
diff --git a/codemp/cgame/cg_view.c b/codemp/cgame/cg_view.c
new file mode 100644
index 0000000..1725da4
--- /dev/null
+++ b/codemp/cgame/cg_view.c
@@ -0,0 +1,2724 @@
+// Copyright (C) 1999-2000 Id Software, Inc.
+//
+// cg_view.c -- setup all the parameters (position, angle, etc)
+// for a 3D rendering
+#include "cg_local.h"
+
+#include "bg_saga.h"
+
+#if !defined(CL_LIGHT_H_INC)
+	#include "cg_lights.h"
+#endif
+
+#define MASK_CAMERACLIP (MASK_SOLID|CONTENTS_PLAYERCLIP)
+#define CAMERA_SIZE	4
+
+
+/*
+=============================================================================
+
+  MODEL TESTING
+
+The viewthing and gun positioning tools from Q2 have been integrated and
+enhanced into a single model testing facility.
+
+Model viewing can begin with either "testmodel <modelname>" or "testgun <modelname>".
+
+The names must be the full pathname after the basedir, like 
+"models/weapons/v_launch/tris.md3" or "players/male/tris.md3"
+
+Testmodel will create a fake entity 100 units in front of the current view
+position, directly facing the viewer.  It will remain immobile, so you can
+move around it to view it from different angles.
+
+Testgun will cause the model to follow the player around and supress the real
+view weapon model.  The default frame 0 of most guns is completely off screen,
+so you will probably have to cycle a couple frames to see it.
+
+"nextframe", "prevframe", "nextskin", and "prevskin" commands will change the
+frame or skin of the testmodel.  These are bound to F5, F6, F7, and F8 in
+q3default.cfg.
+
+If a gun is being tested, the "gun_x", "gun_y", and "gun_z" variables will let
+you adjust the positioning.
+
+Note that none of the model testing features update while the game is paused, so
+it may be convenient to test with deathmatch set to 1 so that bringing down the
+console doesn't pause the game.
+
+=============================================================================
+*/
+
+/*
+=================
+CG_TestModel_f
+
+Creates an entity in front of the current position, which
+can then be moved around
+=================
+*/
+void CG_TestModel_f (void) {
+	vec3_t		angles;
+
+	memset( &cg.testModelEntity, 0, sizeof(cg.testModelEntity) );
+	if ( trap_Argc() < 2 ) {
+		return;
+	}
+
+	Q_strncpyz (cg.testModelName, CG_Argv( 1 ), MAX_QPATH );
+	cg.testModelEntity.hModel = trap_R_RegisterModel( cg.testModelName );
+
+	if ( trap_Argc() == 3 ) {
+		cg.testModelEntity.backlerp = atof( CG_Argv( 2 ) );
+		cg.testModelEntity.frame = 1;
+		cg.testModelEntity.oldframe = 0;
+	}
+	if (! cg.testModelEntity.hModel ) {
+		CG_Printf( "Can't register model\n" );
+		return;
+	}
+
+	VectorMA( cg.refdef.vieworg, 100, cg.refdef.viewaxis[0], cg.testModelEntity.origin );
+
+	angles[PITCH] = 0;
+	angles[YAW] = 180 + cg.refdef.viewangles[1];
+	angles[ROLL] = 0;
+
+	AnglesToAxis( angles, cg.testModelEntity.axis );
+	cg.testGun = qfalse;
+}
+
+/*
+=================
+CG_TestGun_f
+
+Replaces the current view weapon with the given model
+=================
+*/
+void CG_TestGun_f (void) {
+	CG_TestModel_f();
+	cg.testGun = qtrue;
+	//cg.testModelEntity.renderfx = RF_MINLIGHT | RF_DEPTHHACK | RF_FIRST_PERSON;
+
+	// rww - 9-13-01 [1-26-01-sof2]
+	cg.testModelEntity.renderfx = RF_DEPTHHACK | RF_FIRST_PERSON;
+}
+
+
+void CG_TestModelNextFrame_f (void) {
+	cg.testModelEntity.frame++;
+	CG_Printf( "frame %i\n", cg.testModelEntity.frame );
+}
+
+void CG_TestModelPrevFrame_f (void) {
+	cg.testModelEntity.frame--;
+	if ( cg.testModelEntity.frame < 0 ) {
+		cg.testModelEntity.frame = 0;
+	}
+	CG_Printf( "frame %i\n", cg.testModelEntity.frame );
+}
+
+void CG_TestModelNextSkin_f (void) {
+	cg.testModelEntity.skinNum++;
+	CG_Printf( "skin %i\n", cg.testModelEntity.skinNum );
+}
+
+void CG_TestModelPrevSkin_f (void) {
+	cg.testModelEntity.skinNum--;
+	if ( cg.testModelEntity.skinNum < 0 ) {
+		cg.testModelEntity.skinNum = 0;
+	}
+	CG_Printf( "skin %i\n", cg.testModelEntity.skinNum );
+}
+
+static void CG_AddTestModel (void) {
+	int		i;
+
+	// re-register the model, because the level may have changed
+	cg.testModelEntity.hModel = trap_R_RegisterModel( cg.testModelName );
+	if (! cg.testModelEntity.hModel ) {
+		CG_Printf ("Can't register model\n");
+		return;
+	}
+
+	// if testing a gun, set the origin reletive to the view origin
+	if ( cg.testGun ) {
+		VectorCopy( cg.refdef.vieworg, cg.testModelEntity.origin );
+		VectorCopy( cg.refdef.viewaxis[0], cg.testModelEntity.axis[0] );
+		VectorCopy( cg.refdef.viewaxis[1], cg.testModelEntity.axis[1] );
+		VectorCopy( cg.refdef.viewaxis[2], cg.testModelEntity.axis[2] );
+
+		// allow the position to be adjusted
+		for (i=0 ; i<3 ; i++) {
+			cg.testModelEntity.origin[i] += cg.refdef.viewaxis[0][i] * cg_gun_x.value;
+			cg.testModelEntity.origin[i] += cg.refdef.viewaxis[1][i] * cg_gun_y.value;
+			cg.testModelEntity.origin[i] += cg.refdef.viewaxis[2][i] * cg_gun_z.value;
+		}
+	}
+
+	trap_R_AddRefEntityToScene( &cg.testModelEntity );
+}
+
+
+
+//============================================================================
+
+
+/*
+=================
+CG_CalcVrect
+
+Sets the coordinates of the rendered window
+=================
+*/
+static void CG_CalcVrect (void) {
+	int		size;
+
+	// the intermission should allways be full screen
+	if ( cg.snap->ps.pm_type == PM_INTERMISSION ) {
+		size = 100;
+	} else {
+		// bound normal viewsize
+		if (cg_viewsize.integer < 30) {
+			trap_Cvar_Set ("cg_viewsize","30");
+			size = 30;
+		} else if (cg_viewsize.integer > 100) {
+			trap_Cvar_Set ("cg_viewsize","100");
+			size = 100;
+		} else {
+			size = cg_viewsize.integer;
+		}
+
+	}
+	cg.refdef.width = cgs.glconfig.vidWidth*size/100;
+	cg.refdef.width &= ~1;
+
+	cg.refdef.height = cgs.glconfig.vidHeight*size/100;
+	cg.refdef.height &= ~1;
+
+	cg.refdef.x = (cgs.glconfig.vidWidth - cg.refdef.width)/2;
+	cg.refdef.y = (cgs.glconfig.vidHeight - cg.refdef.height)/2;
+}
+
+//==============================================================================
+
+//==============================================================================
+//==============================================================================
+// this causes a compiler bug on mac MrC compiler
+static void CG_StepOffset( void ) {
+	int		timeDelta;
+	
+	// smooth out stair climbing
+	timeDelta = cg.time - cg.stepTime;
+	if ( timeDelta < STEP_TIME ) {
+		cg.refdef.vieworg[2] -= cg.stepChange 
+			* (STEP_TIME - timeDelta) / STEP_TIME;
+	}
+}
+
+#define CAMERA_DAMP_INTERVAL	50
+
+static vec3_t	cameramins = { -CAMERA_SIZE, -CAMERA_SIZE, -CAMERA_SIZE };
+static vec3_t	cameramaxs = { CAMERA_SIZE, CAMERA_SIZE, CAMERA_SIZE };
+vec3_t	camerafwd, cameraup;
+
+vec3_t	cameraFocusAngles,			cameraFocusLoc;
+vec3_t	cameraIdealTarget,			cameraIdealLoc;
+vec3_t	cameraCurTarget={0,0,0},	cameraCurLoc={0,0,0};
+vec3_t	cameraOldLoc={0,0,0},		cameraNewLoc={0,0,0};
+int		cameraLastFrame=0;
+
+float	cameraLastYaw=0;
+float	cameraStiffFactor=0.0f;
+
+/*
+===============
+Notes on the camera viewpoint in and out...
+
+cg.refdef.vieworg
+--at the start of the function holds the player actor's origin (center of player model).
+--it is set to the final view location of the camera at the end of the camera code.
+cg.refdef.viewangles
+--at the start holds the client's view angles
+--it is set to the final view angle of the camera at the end of the camera code.
+
+===============
+*/
+  
+extern qboolean gCGHasFallVector;
+extern vec3_t gCGFallVector;
+
+/*
+===============
+CG_CalcTargetThirdPersonViewLocation
+
+===============
+*/
+static void CG_CalcIdealThirdPersonViewTarget(void)
+{
+	// Initialize IdealTarget
+	if (gCGHasFallVector)
+	{
+		VectorCopy(gCGFallVector, cameraFocusLoc);
+	}
+	else
+	{
+		VectorCopy(cg.refdef.vieworg, cameraFocusLoc);
+	}
+
+	// Add in the new viewheight
+	cameraFocusLoc[2] += cg.snap->ps.viewheight;
+
+	// Add in a vertical offset from the viewpoint, which puts the actual target above the head, regardless of angle.
+//	VectorMA(cameraFocusLoc, thirdPersonVertOffset, cameraup, cameraIdealTarget);
+	
+	// Add in a vertical offset from the viewpoint, which puts the actual target above the head, regardless of angle.
+	VectorCopy( cameraFocusLoc, cameraIdealTarget );
+	
+	{
+		float vertOffset = cg_thirdPersonVertOffset.value;
+
+		if (cg.snap && cg.snap->ps.m_iVehicleNum)
+		{
+			centity_t *veh = &cg_entities[cg.snap->ps.m_iVehicleNum];
+			if (veh->m_pVehicle &&
+				veh->m_pVehicle->m_pVehicleInfo->cameraOverride)
+			{ //override the range with what the vehicle wants it to be
+				if ( veh->m_pVehicle->m_pVehicleInfo->cameraPitchDependantVertOffset )
+				{
+					if ( cg.snap->ps.viewangles[PITCH] > 0 )
+					{
+						vertOffset = 130+cg.predictedPlayerState.viewangles[PITCH]*-10;
+						if ( vertOffset < -170 )
+						{
+							vertOffset = -170;
+						}
+					}
+					else if ( cg.snap->ps.viewangles[PITCH] < 0 )
+					{
+						vertOffset = 130+cg.predictedPlayerState.viewangles[PITCH]*-5;
+						if ( vertOffset > 130 )
+						{
+							vertOffset = 130;
+						}
+					}
+					else
+					{
+						vertOffset = 30;
+					}
+				}
+				else 
+				{
+					vertOffset = veh->m_pVehicle->m_pVehicleInfo->cameraVertOffset;
+				}
+			}
+			else if ( veh->m_pVehicle
+				&& veh->m_pVehicle->m_pVehicleInfo
+				&& veh->m_pVehicle->m_pVehicleInfo->type == VH_ANIMAL )
+			{
+				vertOffset = 0;
+			}
+		}
+		cameraIdealTarget[2] += vertOffset;
+	}
+	//VectorMA(cameraFocusLoc, cg_thirdPersonVertOffset.value, cameraup, cameraIdealTarget);
+}
+
+	
+
+/*
+===============
+CG_CalcTargetThirdPersonViewLocation
+
+===============
+*/
+static void CG_CalcIdealThirdPersonViewLocation(void)
+{
+	float thirdPersonRange = cg_thirdPersonRange.value;
+
+	if (cg.snap && cg.snap->ps.m_iVehicleNum)
+	{
+		centity_t *veh = &cg_entities[cg.snap->ps.m_iVehicleNum];
+		if (veh->m_pVehicle &&
+			veh->m_pVehicle->m_pVehicleInfo->cameraOverride)
+		{ //override the range with what the vehicle wants it to be
+			thirdPersonRange = veh->m_pVehicle->m_pVehicleInfo->cameraRange;
+			if ( veh->playerState->hackingTime )
+			{
+				thirdPersonRange += fabs(((float)veh->playerState->hackingTime)/MAX_STRAFE_TIME) * 100.0f;
+			}
+		}
+	}
+
+	if ( cg.snap
+		&& (cg.snap->ps.eFlags2&EF2_HELD_BY_MONSTER) 
+		&& cg.snap->ps.hasLookTarget
+		&& cg_entities[cg.snap->ps.lookTarget].currentState.NPC_class == CLASS_RANCOR )//only possibility for now, may add Wampa and sand creature later
+	{//stay back
+		//thirdPersonRange = 180.0f;
+		thirdPersonRange = 120.0f;
+	}
+
+	VectorMA(cameraIdealTarget, -(thirdPersonRange), camerafwd, cameraIdealLoc);
+}
+
+
+
+static void CG_ResetThirdPersonViewDamp(void)
+{
+	trace_t trace;
+
+	// Cap the pitch within reasonable limits
+	if (cameraFocusAngles[PITCH] > 89.0)
+	{
+		cameraFocusAngles[PITCH] = 89.0;
+	}
+	else if (cameraFocusAngles[PITCH] < -89.0)
+	{
+		cameraFocusAngles[PITCH] = -89.0;
+	}
+
+	AngleVectors(cameraFocusAngles, camerafwd, NULL, cameraup);
+
+	// Set the cameraIdealTarget
+	CG_CalcIdealThirdPersonViewTarget();
+
+	// Set the cameraIdealLoc
+	CG_CalcIdealThirdPersonViewLocation();
+
+	// Now, we just set everything to the new positions.
+	VectorCopy(cameraIdealLoc, cameraCurLoc);
+	VectorCopy(cameraIdealTarget, cameraCurTarget);
+
+	// First thing we do is trace from the first person viewpoint out to the new target location.
+	CG_Trace(&trace, cameraFocusLoc, cameramins, cameramaxs, cameraCurTarget, cg.snap->ps.clientNum, MASK_CAMERACLIP);
+	if (trace.fraction <= 1.0)
+	{
+		VectorCopy(trace.endpos, cameraCurTarget);
+	}
+
+	// Now we trace from the new target location to the new view location, to make sure there is nothing in the way.
+	CG_Trace(&trace, cameraCurTarget, cameramins, cameramaxs, cameraCurLoc, cg.snap->ps.clientNum, MASK_CAMERACLIP);
+	if (trace.fraction <= 1.0)
+	{
+		VectorCopy(trace.endpos, cameraCurLoc);
+	}
+
+	cameraLastFrame = cg.time;
+	cameraLastYaw = cameraFocusAngles[YAW];
+	cameraStiffFactor = 0.0f;
+}
+
+// This is called every frame.
+static void CG_UpdateThirdPersonTargetDamp(void)
+{
+	trace_t trace;
+	vec3_t	targetdiff;
+	float	dampfactor, dtime, ratio;
+
+	// Set the cameraIdealTarget
+	// Automatically get the ideal target, to avoid jittering.
+	CG_CalcIdealThirdPersonViewTarget();
+
+	if ( cg.predictedVehicleState.hyperSpaceTime
+		&& (cg.time-cg.predictedVehicleState.hyperSpaceTime) < HYPERSPACE_TIME )
+	{//hyperspacing, no damp
+		VectorCopy(cameraIdealTarget, cameraCurTarget);
+	}
+	else if (cg_thirdPersonTargetDamp.value>=1.0||cg.thisFrameTeleport||cg.predictedPlayerState.m_iVehicleNum)
+	{	// No damping.
+		VectorCopy(cameraIdealTarget, cameraCurTarget);
+	}
+	else if (cg_thirdPersonTargetDamp.value>=0.0)
+	{	
+		// Calculate the difference from the current position to the new one.
+		VectorSubtract(cameraIdealTarget, cameraCurTarget, targetdiff);
+
+		// Now we calculate how much of the difference we cover in the time allotted.
+		// The equation is (Damp)^(time)
+		dampfactor = 1.0-cg_thirdPersonTargetDamp.value;	// We must exponent the amount LEFT rather than the amount bled off
+		dtime = (float)(cg.time-cameraLastFrame) * (1.0/(float)CAMERA_DAMP_INTERVAL);	// Our dampfactor is geared towards a time interval equal to "1".
+
+		// Note that since there are a finite number of "practical" delta millisecond values possible, 
+		// the ratio should be initialized into a chart ultimately.
+		ratio = powf(dampfactor, dtime);
+		
+		// This value is how much distance is "left" from the ideal.
+		VectorMA(cameraIdealTarget, -ratio, targetdiff, cameraCurTarget);
+		/////////////////////////////////////////////////////////////////////////////////////////////////////////
+	}
+
+	// Now we trace to see if the new location is cool or not.
+
+	// First thing we do is trace from the first person viewpoint out to the new target location.
+	CG_Trace(&trace, cameraFocusLoc, cameramins, cameramaxs, cameraCurTarget, cg.snap->ps.clientNum, MASK_CAMERACLIP);
+	if (trace.fraction < 1.0)
+	{
+		VectorCopy(trace.endpos, cameraCurTarget);
+	}
+
+	// Note that previously there was an upper limit to the number of physics traces that are done through the world
+	// for the sake of camera collision, since it wasn't calced per frame.  Now it is calculated every frame.
+	// This has the benefit that the camera is a lot smoother now (before it lerped between tested points),
+	// however two full volume traces each frame is a bit scary to think about.
+}
+
+// This can be called every interval, at the user's discretion.
+extern void CG_CalcEntityLerpPositions( centity_t *cent ); //cg_ents.c
+static void CG_UpdateThirdPersonCameraDamp(void)
+{
+	trace_t trace;
+	vec3_t	locdiff;
+	float dampfactor, dtime, ratio;
+
+	// Set the cameraIdealLoc
+	CG_CalcIdealThirdPersonViewLocation();
+	
+	
+	// First thing we do is calculate the appropriate damping factor for the camera.
+	dampfactor=0.0;
+	if ( cg.predictedVehicleState.hyperSpaceTime
+		&& (cg.time-cg.predictedVehicleState.hyperSpaceTime) < HYPERSPACE_TIME )
+	{//hyperspacing - don't damp camera
+		dampfactor = 1.0f;
+	}
+	else if (cg_thirdPersonCameraDamp.value != 0.0)
+	{
+		float pitch;
+		float dFactor;
+
+		if (!cg.predictedPlayerState.m_iVehicleNum)
+		{
+			dFactor = cg_thirdPersonCameraDamp.value;
+		}
+		else
+		{
+			dFactor = 1.0f;
+		}
+
+		// Note that the camera pitch has already been capped off to 89.
+		pitch = Q_fabs(cameraFocusAngles[PITCH]);
+
+		// The higher the pitch, the larger the factor, so as you look up, it damps a lot less.
+		pitch /= 115.0;	
+		dampfactor = (1.0-dFactor)*(pitch*pitch);
+
+		dampfactor += dFactor;
+
+		// Now we also multiply in the stiff factor, so that faster yaw changes are stiffer.
+		if (cameraStiffFactor > 0.0f)
+		{	// The cameraStiffFactor is how much of the remaining damp below 1 should be shaved off, i.e. approach 1 as stiffening increases.
+			dampfactor += (1.0-dampfactor)*cameraStiffFactor;
+		}
+	}
+
+	if (dampfactor>=1.0||cg.thisFrameTeleport)
+	{	// No damping.
+		VectorCopy(cameraIdealLoc, cameraCurLoc);
+	}
+	else if (dampfactor>=0.0)
+	{	
+		// Calculate the difference from the current position to the new one.
+		VectorSubtract(cameraIdealLoc, cameraCurLoc, locdiff);
+
+		// Now we calculate how much of the difference we cover in the time allotted.
+		// The equation is (Damp)^(time)
+		dampfactor = 1.0-dampfactor;	// We must exponent the amount LEFT rather than the amount bled off
+		dtime = (float)(cg.time-cameraLastFrame) * (1.0/(float)CAMERA_DAMP_INTERVAL);	// Our dampfactor is geared towards a time interval equal to "1".
+
+		// Note that since there are a finite number of "practical" delta millisecond values possible, 
+		// the ratio should be initialized into a chart ultimately.
+		ratio = powf(dampfactor, dtime);
+		
+		// This value is how much distance is "left" from the ideal.
+		VectorMA(cameraIdealLoc, -ratio, locdiff, cameraCurLoc);
+		/////////////////////////////////////////////////////////////////////////////////////////////////////////
+	}
+
+	// Now we trace from the new target location to the new view location, to make sure there is nothing in the way.
+	CG_Trace(&trace, cameraCurTarget, cameramins, cameramaxs, cameraCurLoc, cg.snap->ps.clientNum, MASK_CAMERACLIP);
+
+	if (trace.fraction < 1.0)
+	{
+		if (trace.entityNum < ENTITYNUM_WORLD &&
+			cg_entities[trace.entityNum].currentState.solid == SOLID_BMODEL &&
+			cg_entities[trace.entityNum].currentState.eType == ET_MOVER)
+		{ //get a different position for movers -rww
+			centity_t *mover = &cg_entities[trace.entityNum];
+
+			//this is absolutely hackiful, since we calc view values before we add packet ents and lerp,
+			//if we hit a mover we want to update its lerp pos and force it when we do the trace against
+			//it.
+			if (mover->currentState.pos.trType != TR_STATIONARY &&
+				mover->currentState.pos.trType != TR_LINEAR)
+			{
+				int curTr = mover->currentState.pos.trType;
+				vec3_t curTrB;
+
+				VectorCopy(mover->currentState.pos.trBase, curTrB);
+
+				//calc lerporigin for this client frame
+				CG_CalcEntityLerpPositions(mover);
+
+				//force the calc'd lerp to be the base and say we are stationary so we don't try to extrapolate
+				//out further.
+				mover->currentState.pos.trType = TR_STATIONARY;
+				VectorCopy(mover->lerpOrigin, mover->currentState.pos.trBase);
+				
+				//retrace
+				CG_Trace(&trace, cameraCurTarget, cameramins, cameramaxs, cameraCurLoc, cg.snap->ps.clientNum, MASK_CAMERACLIP);
+
+				//copy old data back in
+				mover->currentState.pos.trType = (trType_t) curTr;
+				VectorCopy(curTrB, mover->currentState.pos.trBase);
+			}
+			if (trace.fraction < 1.0f)
+			{ //still hit it, so take the proper trace endpos and use that.
+				VectorCopy(trace.endpos, cameraCurLoc);
+			}
+		}
+		else
+		{
+			VectorCopy( trace.endpos, cameraCurLoc );
+		}
+	}
+
+	// Note that previously there was an upper limit to the number of physics traces that are done through the world
+	// for the sake of camera collision, since it wasn't calced per frame.  Now it is calculated every frame.
+	// This has the benefit that the camera is a lot smoother now (before it lerped between tested points),
+	// however two full volume traces each frame is a bit scary to think about.
+}
+
+
+
+
+/*
+===============`
+CG_OffsetThirdPersonView
+
+===============
+*/
+extern vmCvar_t cg_thirdPersonHorzOffset;
+extern qboolean BG_UnrestrainedPitchRoll( playerState_t *ps, Vehicle_t *pVeh );
+static void CG_OffsetThirdPersonView( void ) 
+{
+	vec3_t diff;
+	float thirdPersonHorzOffset = cg_thirdPersonHorzOffset.value;
+	float deltayaw;
+
+	if (cg.snap && cg.snap->ps.m_iVehicleNum)
+	{
+		centity_t *veh = &cg_entities[cg.snap->ps.m_iVehicleNum];
+		if (veh->m_pVehicle &&
+			veh->m_pVehicle->m_pVehicleInfo->cameraOverride)
+		{ //override the range with what the vehicle wants it to be
+			thirdPersonHorzOffset = veh->m_pVehicle->m_pVehicleInfo->cameraHorzOffset;
+			if ( veh->playerState->hackingTime )
+			{
+				thirdPersonHorzOffset += (((float)veh->playerState->hackingTime)/MAX_STRAFE_TIME) * -80.0f;
+			}
+		}
+	}
+
+	cameraStiffFactor = 0.0;
+
+	// Set camera viewing direction.
+	VectorCopy( cg.refdef.viewangles, cameraFocusAngles );
+
+	// if dead, look at killer
+	if ( cg.snap
+		&& (cg.snap->ps.eFlags2&EF2_HELD_BY_MONSTER) 
+		&& cg.snap->ps.hasLookTarget
+		&& cg_entities[cg.snap->ps.lookTarget].currentState.NPC_class == CLASS_RANCOR )//only possibility for now, may add Wampa and sand creature later
+	{//being held
+		//vec3_t monsterPos, dir2Me;
+		centity_t	*monster = &cg_entities[cg.snap->ps.lookTarget];
+		VectorSet( cameraFocusAngles, 0, AngleNormalize180(monster->lerpAngles[YAW]+180), 0 );
+		//make the look angle the vector from his mouth to me
+		/*
+		VectorCopy( monster->lerpOrigin, monsterPos );
+		monsterPos[2] = cg.snap->ps.origin[2];
+		VectorSubtract( monsterPos, cg.snap->ps.origin, dir2Me );
+		vectoangles( dir2Me, cameraFocusAngles );
+		*/
+	}
+	else if ( cg.snap->ps.stats[STAT_HEALTH] <= 0 ) 
+	{
+		cameraFocusAngles[YAW] = cg.snap->ps.stats[STAT_DEAD_YAW];
+	}
+	else
+	{	// Add in the third Person Angle.
+		cameraFocusAngles[YAW] += cg_thirdPersonAngle.value;
+		{
+			float pitchOffset = cg_thirdPersonPitchOffset.value;
+			if (cg.snap && cg.snap->ps.m_iVehicleNum)
+			{
+				centity_t *veh = &cg_entities[cg.snap->ps.m_iVehicleNum];
+				if (veh->m_pVehicle &&
+					veh->m_pVehicle->m_pVehicleInfo->cameraOverride)
+				{ //override the range with what the vehicle wants it to be
+					if ( veh->m_pVehicle->m_pVehicleInfo->cameraPitchDependantVertOffset )
+					{
+						if ( cg.snap->ps.viewangles[PITCH] > 0 )
+						{
+							pitchOffset = cg.predictedPlayerState.viewangles[PITCH]*-0.75;
+						}
+						else if ( cg.snap->ps.viewangles[PITCH] < 0 )
+						{
+							pitchOffset = cg.predictedPlayerState.viewangles[PITCH]*-0.75;
+						}
+						else
+						{
+							pitchOffset = 0;
+						}
+					}
+					else
+					{
+						pitchOffset = veh->m_pVehicle->m_pVehicleInfo->cameraPitchOffset;
+					}
+				}
+			}
+			if ( 0 && cg.predictedPlayerState.m_iVehicleNum //in a vehicle
+				&& BG_UnrestrainedPitchRoll( &cg.predictedPlayerState, cg_entities[cg.predictedPlayerState.m_iVehicleNum].m_pVehicle ) )//can roll/pitch without restriction
+			{
+				float pitchPerc = ((90.0f-fabs(cameraFocusAngles[ROLL]))/90.0f);
+				cameraFocusAngles[PITCH] += pitchOffset*pitchPerc;
+				if ( cameraFocusAngles[ROLL] > 0 )
+				{
+					cameraFocusAngles[YAW] -= pitchOffset-(pitchOffset*pitchPerc);
+				}
+				else
+				{
+					cameraFocusAngles[YAW] += pitchOffset-(pitchOffset*pitchPerc);
+				}
+			}
+			else
+			{
+				cameraFocusAngles[PITCH] += pitchOffset;
+			}
+		}
+	}
+
+	// The next thing to do is to see if we need to calculate a new camera target location.
+
+	// If we went back in time for some reason, or if we just started, reset the sample.
+	if (cameraLastFrame == 0 || cameraLastFrame > cg.time)
+	{
+		CG_ResetThirdPersonViewDamp();
+	}
+	else
+	{
+		// Cap the pitch within reasonable limits
+		if ( cg.predictedPlayerState.m_iVehicleNum //in a vehicle
+			&& BG_UnrestrainedPitchRoll( &cg.predictedPlayerState, cg_entities[cg.predictedPlayerState.m_iVehicleNum].m_pVehicle ) )//can roll/pitch without restriction
+		{//no clamp on pitch
+			//FIXME: when pitch >= 90 or <= -90, camera rotates oddly... need to CrossProduct not just vectoangles
+		}
+		else
+		{
+			if (cameraFocusAngles[PITCH] > 80.0)
+			{
+				cameraFocusAngles[PITCH] = 80.0;
+			}
+			else if (cameraFocusAngles[PITCH] < -80.0)
+			{
+				cameraFocusAngles[PITCH] = -80.0;
+			}
+		}
+
+		AngleVectors(cameraFocusAngles, camerafwd, NULL, cameraup);
+
+		deltayaw = fabs(cameraFocusAngles[YAW] - cameraLastYaw);
+		if (deltayaw > 180.0f)
+		{ // Normalize this angle so that it is between 0 and 180.
+			deltayaw = fabs(deltayaw - 360.0f);
+		}
+		cameraStiffFactor = deltayaw / (float)(cg.time-cameraLastFrame);
+		if (cameraStiffFactor < 1.0)
+		{
+			cameraStiffFactor = 0.0;
+		}
+		else if (cameraStiffFactor > 2.5)
+		{
+			cameraStiffFactor = 0.75;
+		}
+		else
+		{	// 1 to 2 scales from 0.0 to 0.5
+			cameraStiffFactor = (cameraStiffFactor-1.0f)*0.5f;
+		}
+		cameraLastYaw = cameraFocusAngles[YAW];
+
+		// Move the target to the new location.
+		CG_UpdateThirdPersonTargetDamp();
+		CG_UpdateThirdPersonCameraDamp();
+	}
+
+	// Now interestingly, the Quake method is to calculate a target focus point above the player, and point the camera at it.
+	// We won't do that for now.
+
+	// We must now take the angle taken from the camera target and location.
+	/*VectorSubtract(cameraCurTarget, cameraCurLoc, diff);
+	VectorNormalize(diff);
+	vectoangles(diff, cg.refdef.viewangles);*/
+	VectorSubtract(cameraCurTarget, cameraCurLoc, diff);
+	{
+		float dist = VectorNormalize(diff);
+		//under normal circumstances, should never be 0.00000 and so on.
+		if ( !dist || (diff[0] == 0 || diff[1] == 0) )
+		{//must be hitting something, need some value to calc angles, so use cam forward
+			VectorCopy( camerafwd, diff );
+		}
+	}
+	if ( 0 && cg.predictedPlayerState.m_iVehicleNum //in a vehicle
+		&& BG_UnrestrainedPitchRoll( &cg.predictedPlayerState, cg_entities[cg.predictedPlayerState.m_iVehicleNum].m_pVehicle ) )//can roll/pitch without restriction
+	{//FIXME: this causes camera jerkiness, need to blend the roll?
+		float sav_Roll = cg.refdef.viewangles[ROLL];
+		vectoangles(diff, cg.refdef.viewangles);
+		cg.refdef.viewangles[ROLL] = sav_Roll;
+	}
+	else
+	{
+		vectoangles(diff, cg.refdef.viewangles);
+	}
+
+	// Temp: just move the camera to the side a bit
+	if ( thirdPersonHorzOffset != 0.0f )
+	{
+		AnglesToAxis( cg.refdef.viewangles, cg.refdef.viewaxis );
+		VectorMA( cameraCurLoc, thirdPersonHorzOffset, cg.refdef.viewaxis[1], cameraCurLoc );
+	}
+
+	// ...and of course we should copy the new view location to the proper spot too.
+	VectorCopy(cameraCurLoc, cg.refdef.vieworg);
+
+	cameraLastFrame=cg.time;
+}
+
+
+
+/*
+===============
+CG_OffsetThirdPersonView
+
+===============
+*//*
+#define	FOCUS_DISTANCE	512
+static void CG_OffsetThirdPersonView( void ) {
+	vec3_t		forward, right, up;
+	vec3_t		view;
+	vec3_t		focusAngles;
+	trace_t		trace;
+	static vec3_t	mins = { -4, -4, -4 };
+	static vec3_t	maxs = { 4, 4, 4 };
+	vec3_t		focusPoint;
+	float		focusDist;
+	float		forwardScale, sideScale;
+
+	cg.refdef.vieworg[2] += cg.predictedPlayerState.viewheight;
+
+	VectorCopy( cg.refdef.viewangles, focusAngles );
+
+	// if dead, look at killer
+	if ( cg.predictedPlayerState.stats[STAT_HEALTH] <= 0 ) {
+		focusAngles[YAW] = cg.predictedPlayerState.stats[STAT_DEAD_YAW];
+		cg.refdef.viewangles[YAW] = cg.predictedPlayerState.stats[STAT_DEAD_YAW];
+	}
+
+	if ( focusAngles[PITCH] > 45 ) {
+		focusAngles[PITCH] = 45;		// don't go too far overhead
+	}
+	AngleVectors( focusAngles, forward, NULL, NULL );
+
+	VectorMA( cg.refdef.vieworg, FOCUS_DISTANCE, forward, focusPoint );
+
+	VectorCopy( cg.refdef.vieworg, view );
+
+	view[2] += 8;
+
+	cg.refdef.viewangles[PITCH] *= 0.5;
+
+	AngleVectors( cg.refdef.viewangles, forward, right, up );
+
+	forwardScale = cos( cg_thirdPersonAngle.value / 180 * M_PI );
+	sideScale = sin( cg_thirdPersonAngle.value / 180 * M_PI );
+	VectorMA( view, -cg_thirdPersonRange.value * forwardScale, forward, view );
+	VectorMA( view, -cg_thirdPersonRange.value * sideScale, right, view );
+
+	// trace a ray from the origin to the viewpoint to make sure the view isn't
+	// in a solid block.  Use an 8 by 8 block to prevent the view from near clipping anything
+
+	if (!cg_cameraMode.integer) {
+		CG_Trace( &trace, cg.refdef.vieworg, mins, maxs, view, cg.predictedPlayerState.clientNum, MASK_CAMERACLIP);
+
+		if ( trace.fraction != 1.0 ) {
+			VectorCopy( trace.endpos, view );
+			view[2] += (1.0 - trace.fraction) * 32;
+			// try another trace to this position, because a tunnel may have the ceiling
+			// close enogh that this is poking out
+
+			CG_Trace( &trace, cg.refdef.vieworg, mins, maxs, view, cg.predictedPlayerState.clientNum, MASK_CAMERACLIP);
+			VectorCopy( trace.endpos, view );
+		}
+	}
+
+
+	VectorCopy( view, cg.refdef.vieworg );
+
+	// select pitch to look at focus point from vieword
+	VectorSubtract( focusPoint, cg.refdef.vieworg, focusPoint );
+	focusDist = sqrt( focusPoint[0] * focusPoint[0] + focusPoint[1] * focusPoint[1] );
+	if ( focusDist < 1 ) {
+		focusDist = 1;	// should never happen
+	}
+	cg.refdef.viewangles[PITCH] = -180 / M_PI * atan2( focusPoint[2], focusDist );
+	cg.refdef.viewangles[YAW] -= cg_thirdPersonAngle.value;
+}
+
+
+// this causes a compiler bug on mac MrC compiler
+static void CG_StepOffset( void ) {
+	int		timeDelta;
+	
+	// smooth out stair climbing
+	timeDelta = cg.time - cg.stepTime;
+	if ( timeDelta < STEP_TIME ) {
+		cg.refdef.vieworg[2] -= cg.stepChange 
+			* (STEP_TIME - timeDelta) / STEP_TIME;
+	}
+}*/
+
+/*
+===============
+CG_OffsetFirstPersonView
+
+===============
+*/
+static void CG_OffsetFirstPersonView( void ) {
+	float			*origin;
+	float			*angles;
+	float			bob;
+	float			ratio;
+	float			delta;
+	float			speed;
+	float			f;
+	vec3_t			predictedVelocity;
+	int				timeDelta;
+	int				kickTime;
+	
+	if ( cg.snap->ps.pm_type == PM_INTERMISSION ) {
+		return;
+	}
+
+	origin = cg.refdef.vieworg;
+	angles = cg.refdef.viewangles;
+
+	// if dead, fix the angle and don't add any kick
+	if ( cg.snap->ps.stats[STAT_HEALTH] <= 0 ) {
+		angles[ROLL] = 40;
+		angles[PITCH] = -15;
+		angles[YAW] = cg.snap->ps.stats[STAT_DEAD_YAW];
+		origin[2] += cg.predictedPlayerState.viewheight;
+		return;
+	}
+
+	// add angles based on weapon kick
+	kickTime = (cg.time - cg.kick_time);
+	if ( kickTime < 800 )
+	{//kicks are always 1 second long.  Deal with it.
+		float kickPerc = 0.0f;
+		if ( kickTime <= 200 )
+		{//winding up
+			kickPerc = kickTime/200.0f;
+		}
+		else
+		{//returning to normal
+			kickTime = 800 - kickTime;
+			kickPerc = kickTime/600.0f;
+		}
+		VectorMA( angles, kickPerc, cg.kick_angles, angles );
+	}
+	// add angles based on damage kick
+	if ( cg.damageTime ) {
+		ratio = cg.time - cg.damageTime;
+		if ( ratio < DAMAGE_DEFLECT_TIME ) {
+			ratio /= DAMAGE_DEFLECT_TIME;
+			angles[PITCH] += ratio * cg.v_dmg_pitch;
+			angles[ROLL] += ratio * cg.v_dmg_roll;
+		} else {
+			ratio = 1.0 - ( ratio - DAMAGE_DEFLECT_TIME ) / DAMAGE_RETURN_TIME;
+			if ( ratio > 0 ) {
+				angles[PITCH] += ratio * cg.v_dmg_pitch;
+				angles[ROLL] += ratio * cg.v_dmg_roll;
+			}
+		}
+	}
+
+	// add pitch based on fall kick
+#if 0
+	ratio = ( cg.time - cg.landTime) / FALL_TIME;
+	if (ratio < 0)
+		ratio = 0;
+	angles[PITCH] += ratio * cg.fall_value;
+#endif
+
+	// add angles based on velocity
+	VectorCopy( cg.predictedPlayerState.velocity, predictedVelocity );
+
+	delta = DotProduct ( predictedVelocity, cg.refdef.viewaxis[0]);
+	angles[PITCH] += delta * cg_runpitch.value;
+	
+	delta = DotProduct ( predictedVelocity, cg.refdef.viewaxis[1]);
+	angles[ROLL] -= delta * cg_runroll.value;
+
+	// add angles based on bob
+
+	// make sure the bob is visible even at low speeds
+	speed = cg.xyspeed > 200 ? cg.xyspeed : 200;
+
+	delta = cg.bobfracsin * cg_bobpitch.value * speed;
+	if (cg.predictedPlayerState.pm_flags & PMF_DUCKED)
+		delta *= 3;		// crouching
+	angles[PITCH] += delta;
+	delta = cg.bobfracsin * cg_bobroll.value * speed;
+	if (cg.predictedPlayerState.pm_flags & PMF_DUCKED)
+		delta *= 3;		// crouching accentuates roll
+	if (cg.bobcycle & 1)
+		delta = -delta;
+	angles[ROLL] += delta;
+
+//===================================
+
+	// add view height
+	origin[2] += cg.predictedPlayerState.viewheight;
+
+	// smooth out duck height changes
+	timeDelta = cg.time - cg.duckTime;
+	if ( timeDelta < DUCK_TIME) {
+		cg.refdef.vieworg[2] -= cg.duckChange 
+			* (DUCK_TIME - timeDelta) / DUCK_TIME;
+	}
+
+	// add bob height
+	bob = cg.bobfracsin * cg.xyspeed * cg_bobup.value;
+	if (bob > 6) {
+		bob = 6;
+	}
+
+	origin[2] += bob;
+
+
+	// add fall height
+	delta = cg.time - cg.landTime;
+	if ( delta < LAND_DEFLECT_TIME ) {
+		f = delta / LAND_DEFLECT_TIME;
+		cg.refdef.vieworg[2] += cg.landChange * f;
+	} else if ( delta < LAND_DEFLECT_TIME + LAND_RETURN_TIME ) {
+		delta -= LAND_DEFLECT_TIME;
+		f = 1.0 - ( delta / LAND_RETURN_TIME );
+		cg.refdef.vieworg[2] += cg.landChange * f;
+	}
+
+	// add step offset
+	CG_StepOffset();
+
+	// add kick offset
+
+	VectorAdd (origin, cg.kick_origin, origin);
+
+	// pivot the eye based on a neck length
+#if 0
+	{
+#define	NECK_LENGTH		8
+	vec3_t			forward, up;
+ 
+	cg.refdef.vieworg[2] -= NECK_LENGTH;
+	AngleVectors( cg.refdef.viewangles, forward, NULL, up );
+	VectorMA( cg.refdef.vieworg, 3, forward, cg.refdef.vieworg );
+	VectorMA( cg.refdef.vieworg, NECK_LENGTH, up, cg.refdef.vieworg );
+	}
+#endif
+}
+
+static void CG_OffsetFighterView( void )
+{
+	vec3_t vehFwd, vehRight, vehUp, backDir;
+	vec3_t	camOrg, camBackOrg;
+	float horzOffset = cg_thirdPersonHorzOffset.value;
+	float vertOffset = cg_thirdPersonVertOffset.value;
+	float pitchOffset = cg_thirdPersonPitchOffset.value;
+	float yawOffset = cg_thirdPersonAngle.value;
+	float range = cg_thirdPersonRange.value;
+	trace_t	trace;
+	centity_t *veh = &cg_entities[cg.predictedPlayerState.m_iVehicleNum];
+
+	AngleVectors( cg.refdef.viewangles, vehFwd, vehRight, vehUp );
+
+	if ( veh->m_pVehicle &&
+		veh->m_pVehicle->m_pVehicleInfo->cameraOverride )
+	{ //override the horizontal offset with what the vehicle wants it to be
+		horzOffset = veh->m_pVehicle->m_pVehicleInfo->cameraHorzOffset;
+		vertOffset = veh->m_pVehicle->m_pVehicleInfo->cameraVertOffset;
+		//NOTE: no yaw offset?
+		pitchOffset = veh->m_pVehicle->m_pVehicleInfo->cameraPitchOffset;
+		range = veh->m_pVehicle->m_pVehicleInfo->cameraRange;
+		if ( veh->playerState->hackingTime )
+		{
+			horzOffset += (((float)veh->playerState->hackingTime)/MAX_STRAFE_TIME) * -80.0f;
+			range += fabs(((float)veh->playerState->hackingTime)/MAX_STRAFE_TIME) * 100.0f;
+		}
+	}
+
+	//Set camera viewing position
+	VectorMA( cg.refdef.vieworg, horzOffset, vehRight, camOrg );
+	VectorMA( camOrg, vertOffset, vehUp, camOrg );
+
+	//trace to that pos
+	CG_Trace(&trace, cg.refdef.vieworg, cameramins, cameramaxs, camOrg, cg.snap->ps.clientNum, MASK_CAMERACLIP);
+	if ( trace.fraction < 1.0 )
+	{
+		VectorCopy( trace.endpos, camOrg );
+	}
+
+	// Set camera viewing direction.
+	cg.refdef.viewangles[YAW] += yawOffset;
+	cg.refdef.viewangles[PITCH] += pitchOffset;
+
+	//Now bring the cam back from that pos and angles at range
+	AngleVectors( cg.refdef.viewangles, backDir, NULL, NULL );
+	VectorScale( backDir, -1, backDir );
+
+	VectorMA( camOrg, range, backDir, camBackOrg );
+
+	//trace to that pos
+	CG_Trace(&trace, camOrg, cameramins, cameramaxs, camBackOrg, cg.snap->ps.clientNum, MASK_CAMERACLIP);
+	VectorCopy( trace.endpos, camOrg );
+
+	//FIXME: do we need to smooth the org?
+	// ...and of course we should copy the new view location to the proper spot too.
+	VectorCopy(camOrg, cg.refdef.vieworg);
+}
+//======================================================================
+
+void CG_ZoomDown_f( void ) { 
+	if ( cg.zoomed ) {
+		return;
+	}
+	cg.zoomed = qtrue;
+	cg.zoomTime = cg.time;
+}
+
+void CG_ZoomUp_f( void ) { 
+	if ( !cg.zoomed ) {
+		return;
+	}
+	cg.zoomed = qfalse;
+	cg.zoomTime = cg.time;
+}
+
+
+
+/*
+====================
+CG_CalcFovFromX
+
+Calcs Y FOV from given X FOV
+====================
+*/
+qboolean CG_CalcFOVFromX( float fov_x ) 
+{
+	float	x;
+//	float	phase;
+//	float	v;
+//	int		contents;
+	float	fov_y;
+	qboolean	inwater;
+
+	x = cg.refdef.width / tan( fov_x / 360 * M_PI );
+	fov_y = atan2( cg.refdef.height, x );
+	fov_y = fov_y * 360 / M_PI;
+
+	// there's a problem with this, it only takes the leafbrushes into account, not the entity brushes,
+	//	so if you give slime/water etc properties to a func_door area brush in order to move the whole water 
+	//	level up/down this doesn't take into account the door position, so warps the view the whole time
+	//	whether the water is up or not. Fortunately there's only one slime area in Trek that you can be under,
+	//	so lose it...
+#if 0
+/*
+	// warp if underwater
+	contents = CG_PointContents( cg.refdef.vieworg, -1 );
+	if ( contents & ( CONTENTS_WATER | CONTENTS_SLIME | CONTENTS_LAVA ) ){
+		phase = cg.time / 1000.0 * WAVE_FREQUENCY * M_PI * 2;
+		v = WAVE_AMPLITUDE * sin( phase );
+		fov_x += v;
+		fov_y -= v;
+		inwater = qtrue;
+	}
+	else {
+		inwater = qfalse;
+	}
+*/
+#else
+	inwater = qfalse;
+#endif
+
+
+	// set it
+	cg.refdef.fov_x = fov_x;
+	cg.refdef.fov_y = fov_y;
+
+#ifdef _XBOX
+	if(cg.widescreen)
+		cg.refdef.fov_x *= 1.125f;
+#endif
+
+	return (inwater);
+}
+
+/*
+====================
+CG_CalcFov
+
+Fixed fov at intermissions, otherwise account for fov variable and zooms.
+====================
+*/
+#define	WAVE_AMPLITUDE	1
+#define	WAVE_FREQUENCY	0.4
+float zoomFov; //this has to be global client-side
+
+static int CG_CalcFov( void ) {
+	float	x;
+	float	phase;
+	float	v;
+	float	fov_x, fov_y;
+	float	f;
+	int		inwater;
+	float	cgFov = cg_fov.value;
+
+	if (cgFov < 1)
+	{
+		cgFov = 1;
+	}
+	if (cgFov > 97)
+	{
+		cgFov = 97;
+	}
+
+	if ( cg.predictedPlayerState.pm_type == PM_INTERMISSION ) {
+		// if in intermission, use a fixed value
+		fov_x = 80;//90;
+	} else {
+		// user selectable
+		if ( cgs.dmflags & DF_FIXED_FOV ) {
+			// dmflag to prevent wide fov for all clients
+			fov_x = 80;//90;
+		} else {
+			fov_x = cgFov;
+			if ( fov_x < 1 ) {
+				fov_x = 1;
+			} else if ( fov_x > 160 ) {
+				fov_x = 160;
+			}
+		}
+
+		if (cg.predictedPlayerState.zoomMode == 2)
+		{ //binoculars
+			if (zoomFov > 40.0f)
+			{
+				zoomFov -= cg.frametime * 0.075f;
+
+				if (zoomFov < 40.0f)
+				{
+					zoomFov = 40.0f;
+				}
+				else if (zoomFov > cgFov)
+				{
+					zoomFov = cgFov;
+				}
+			}
+
+			fov_x = zoomFov;
+		}
+		else if (cg.predictedPlayerState.zoomMode)
+		{
+			if (!cg.predictedPlayerState.zoomLocked)
+			{
+				if (zoomFov > 50)
+				{ //Now starting out at nearly half zoomed in
+					zoomFov = 50;
+				}
+				zoomFov -= cg.frametime * 0.035f;//0.075f;
+
+				if (zoomFov < MAX_ZOOM_FOV)
+				{
+					zoomFov = MAX_ZOOM_FOV;
+				}
+				else if (zoomFov > cgFov)
+				{
+					zoomFov = cgFov;
+				}
+				else
+				{	// Still zooming
+					static int zoomSoundTime = 0;
+
+					if (zoomSoundTime < cg.time || zoomSoundTime > cg.time + 10000)
+					{
+						trap_S_StartSound(cg.refdef.vieworg, ENTITYNUM_WORLD, CHAN_LOCAL, cgs.media.disruptorZoomLoop);
+						zoomSoundTime = cg.time + 300;
+					}
+				}
+			}
+
+			if (zoomFov < MAX_ZOOM_FOV)
+			{
+				zoomFov = 50;		// hack to fix zoom during vid restart
+			}
+			fov_x = zoomFov;
+		}
+		else 
+		{
+			zoomFov = 80;
+
+			f = ( cg.time - cg.predictedPlayerState.zoomTime ) / ZOOM_OUT_TIME;
+			if ( f > 1.0 ) 
+			{
+				fov_x = fov_x;
+			} 
+			else 
+			{
+				fov_x = cg.predictedPlayerState.zoomFov + f * ( fov_x - cg.predictedPlayerState.zoomFov );
+			}
+		}
+	}
+
+	x = cg.refdef.width / tan( fov_x / 360 * M_PI );
+	fov_y = atan2( cg.refdef.height, x );
+	fov_y = fov_y * 360 / M_PI;
+
+	// warp if underwater
+	cg.refdef.viewContents = CG_PointContents( cg.refdef.vieworg, -1 );
+	if ( cg.refdef.viewContents & ( CONTENTS_WATER | CONTENTS_SLIME | CONTENTS_LAVA ) ){
+		phase = cg.time / 1000.0 * WAVE_FREQUENCY * M_PI * 2;
+		v = WAVE_AMPLITUDE * sin( phase );
+		fov_x += v;
+		fov_y -= v;
+		inwater = qtrue;
+	}
+	else {
+		inwater = qfalse;
+	}
+
+#ifdef _XBOX
+	if(cg.widescreen)
+		fov_x = fov_y * 1.77777f;
+#endif
+
+
+	// set it
+	cg.refdef.fov_x = fov_x;
+	cg.refdef.fov_y = fov_y;
+
+	if (cg.predictedPlayerState.zoomMode)
+	{
+		cg.zoomSensitivity = zoomFov/cgFov;
+	}
+	else if ( !cg.zoomed ) {
+		cg.zoomSensitivity = 1;
+	} else {
+		cg.zoomSensitivity = cg.refdef.fov_y / 75.0;
+	}
+
+	return inwater;
+}
+
+
+/*
+===============
+CG_DamageBlendBlob
+
+===============
+*/
+static void CG_DamageBlendBlob( void ) 
+{
+	int			t;
+	int			maxTime;
+	refEntity_t		ent;
+
+	if ( !cg.damageValue ) {
+		return;
+	}
+
+	maxTime = DAMAGE_TIME;
+	t = cg.time - cg.damageTime;
+	if ( t <= 0 || t >= maxTime ) {
+		return;
+	}
+
+	memset( &ent, 0, sizeof( ent ) );
+	ent.reType = RT_SPRITE;
+	ent.renderfx = RF_FIRST_PERSON;
+
+	VectorMA( cg.refdef.vieworg, 8, cg.refdef.viewaxis[0], ent.origin );
+	VectorMA( ent.origin, cg.damageX * -8, cg.refdef.viewaxis[1], ent.origin );
+	VectorMA( ent.origin, cg.damageY * 8, cg.refdef.viewaxis[2], ent.origin );
+
+	ent.radius = cg.damageValue * 3 * ( 1.0 - ((float)t / maxTime) );
+
+	if (cg.snap->ps.damageType == 0)
+	{ //pure health
+		ent.customShader = cgs.media.viewPainShader;
+		ent.shaderRGBA[0] = 180 * ( 1.0 - ((float)t / maxTime) );
+		ent.shaderRGBA[1] = 50 * ( 1.0 - ((float)t / maxTime) );
+		ent.shaderRGBA[2] = 50 * ( 1.0 - ((float)t / maxTime) );
+		ent.shaderRGBA[3] = 255;
+	}
+	else if (cg.snap->ps.damageType == 1)
+	{ //pure shields
+		ent.customShader = cgs.media.viewPainShader_Shields;
+		ent.shaderRGBA[0] = 50 * ( 1.0 - ((float)t / maxTime) );
+		ent.shaderRGBA[1] = 180 * ( 1.0 - ((float)t / maxTime) );
+		ent.shaderRGBA[2] = 50 * ( 1.0 - ((float)t / maxTime) );
+		ent.shaderRGBA[3] = 255;
+	}
+	else
+	{ //shields and health
+		ent.customShader = cgs.media.viewPainShader_ShieldsAndHealth;
+		ent.shaderRGBA[0] = 180 * ( 1.0 - ((float)t / maxTime) );
+		ent.shaderRGBA[1] = 180 * ( 1.0 - ((float)t / maxTime) );
+		ent.shaderRGBA[2] = 50 * ( 1.0 - ((float)t / maxTime) );
+		ent.shaderRGBA[3] = 255;
+	}
+	trap_R_AddRefEntityToScene( &ent );
+}
+
+int cg_actionCamLastTime = 0;
+vec3_t cg_actionCamLastPos;
+
+//action cam routine -rww
+static qboolean CG_ThirdPersonActionCam(void)
+{
+    centity_t *cent = &cg_entities[cg.snap->ps.clientNum];
+	clientInfo_t *ci = &cgs.clientinfo[cg.snap->ps.clientNum];
+	trace_t tr;
+	vec3_t positionDir;
+	vec3_t desiredAngles;
+	vec3_t desiredPos;
+	vec3_t v;
+	const float smoothFactor = 0.1f*cg_timescale.value;
+	int i;
+
+	if (!cent->ghoul2)
+	{ //if we don't have a g2 instance this frame for whatever reason then do nothing
+		return qfalse;
+	}
+
+	if (cent->currentState.weapon != WP_SABER)
+	{ //just being safe, should not ever happen
+		return qfalse;
+	}
+
+	if ((cg.time - ci->saber[0].blade[0].trail.lastTime) > 300)
+	{ //too long since we last got the blade position
+		return qfalse;
+	}
+
+	//get direction from base to ent origin
+	VectorSubtract(ci->saber[0].blade[0].trail.base, cent->lerpOrigin, positionDir);
+	VectorNormalize(positionDir);
+
+	//position the cam based on the direction and saber position
+	VectorMA(cent->lerpOrigin, cg_thirdPersonRange.value*2, positionDir, desiredPos);
+
+	//trace to the desired pos to see how far that way we can actually go before we hit something
+	//the endpos will be valid for our desiredpos no matter what
+	CG_Trace(&tr, cent->lerpOrigin, NULL, NULL, desiredPos, cent->currentState.number, MASK_SOLID);
+	VectorCopy(tr.endpos, desiredPos);
+
+	if ((cg.time - cg_actionCamLastTime) > 300)
+	{
+		//do a third person offset first and grab the initial point from that
+		CG_OffsetThirdPersonView();
+		VectorCopy(cg.refdef.vieworg, cg_actionCamLastPos);
+	}
+
+	cg_actionCamLastTime = cg.time;
+
+	//lerp the vieworg to the desired pos from the last valid
+	VectorSubtract(desiredPos, cg_actionCamLastPos, v);
+	
+	if (VectorLength(v) > 64.0f)
+	{ //don't bother moving yet if not far from the last pos
+		for (i = 0; i < 3; i++)
+		{
+			cg_actionCamLastPos[i] = (cg_actionCamLastPos[i] + (v[i]*smoothFactor));
+			cg.refdef.vieworg[i] = cg_actionCamLastPos[i];
+		}
+	}
+	else
+	{
+		VectorCopy(cg_actionCamLastPos, cg.refdef.vieworg);
+	}
+
+	//Make sure the point is alright
+	CG_Trace(&tr, cent->lerpOrigin, NULL, NULL, cg.refdef.vieworg, cent->currentState.number, MASK_SOLID);
+	VectorCopy(tr.endpos, cg.refdef.vieworg);
+
+	VectorSubtract(cent->lerpOrigin, cg.refdef.vieworg, positionDir);
+	vectoangles(positionDir, desiredAngles);
+
+	//just set the angles for now
+	VectorCopy(desiredAngles, cg.refdef.viewangles);
+	return qtrue;
+}
+
+vec3_t	cg_lastTurretViewAngles={0};
+qboolean CG_CheckPassengerTurretView( void )
+{
+	if ( cg.predictedPlayerState.m_iVehicleNum //in a vehicle
+		&& cg.predictedPlayerState.generic1 )//as a passenger
+	{//passenger in a vehicle
+		centity_t *vehCent = &cg_entities[cg.predictedPlayerState.m_iVehicleNum];
+		if ( vehCent->m_pVehicle
+			&& vehCent->m_pVehicle->m_pVehicleInfo 
+			&& vehCent->m_pVehicle->m_pVehicleInfo->maxPassengers )
+		{//a vehicle capable of carrying passengers
+			int turretNum;
+			for ( turretNum = 0; turretNum < MAX_VEHICLE_TURRETS; turretNum++ )
+			{
+				if ( vehCent->m_pVehicle->m_pVehicleInfo->turret[turretNum].iAmmoMax )
+				{// valid turret
+					if ( vehCent->m_pVehicle->m_pVehicleInfo->turret[turretNum].passengerNum == cg.predictedPlayerState.generic1 )
+					{//I control this turret
+						int boltIndex = -1;
+						qboolean hackPosAndAngle = qfalse;
+						if ( vehCent->m_pVehicle->m_iGunnerViewTag[turretNum] != -1 )
+						{
+							boltIndex = vehCent->m_pVehicle->m_iGunnerViewTag[turretNum];
+						}
+						else
+						{//crap... guess?
+							hackPosAndAngle = qtrue;
+							if ( vehCent->m_pVehicle->m_pVehicleInfo->turret[turretNum].yawBone )
+							{
+								boltIndex = trap_G2API_AddBolt( vehCent->ghoul2, 0, vehCent->m_pVehicle->m_pVehicleInfo->turret[turretNum].yawBone );
+							}
+							else if ( vehCent->m_pVehicle->m_pVehicleInfo->turret[turretNum].pitchBone )
+							{
+								boltIndex = trap_G2API_AddBolt( vehCent->ghoul2, 0, vehCent->m_pVehicle->m_pVehicleInfo->turret[turretNum].pitchBone );
+							}
+							else
+							{//well, no way of knowing, so screw it
+								return qfalse;
+							}
+						}
+						if ( boltIndex != -1 )
+						{
+							mdxaBone_t boltMatrix;
+							vec3_t fwd, up;
+							trap_G2API_GetBoltMatrix_NoRecNoRot(vehCent->ghoul2, 0, boltIndex, &boltMatrix, vehCent->lerpAngles,
+								vehCent->lerpOrigin, cg.time, NULL, vehCent->modelScale);
+							BG_GiveMeVectorFromMatrix(&boltMatrix, ORIGIN, cg.refdef.vieworg);
+							if ( hackPosAndAngle )
+							{
+								//FIXME: these are assumptions, externalize?  BETTER YET: give me a controller view bolt/tag for each turret
+								BG_GiveMeVectorFromMatrix(&boltMatrix, NEGATIVE_X, fwd);
+								BG_GiveMeVectorFromMatrix(&boltMatrix, NEGATIVE_Y, up);
+								VectorMA( cg.refdef.vieworg, 8.0f, fwd, cg.refdef.vieworg );
+								VectorMA( cg.refdef.vieworg, 4.0f, up, cg.refdef.vieworg );
+							}
+							else
+							{
+								BG_GiveMeVectorFromMatrix(&boltMatrix, NEGATIVE_Y, fwd);
+							}
+							{
+								vec3_t	newAngles, deltaAngles;
+								vectoangles( fwd, newAngles );
+								AnglesSubtract( newAngles, cg_lastTurretViewAngles, deltaAngles );
+								VectorMA( cg_lastTurretViewAngles, 0.5f*(float)cg.frametime/100.0f, deltaAngles, cg.refdef.viewangles );
+							}
+							return qtrue;
+						}
+					}
+				}
+			}
+		}
+	}
+	return qfalse;
+}
+/*
+===============
+CG_CalcViewValues
+
+Sets cg.refdef view values
+===============
+*/
+void CG_EmplacedView(vec3_t angles);
+static int CG_CalcViewValues( void ) {
+	qboolean manningTurret = qfalse;
+	playerState_t	*ps;
+
+	memset( &cg.refdef, 0, sizeof( cg.refdef ) );
+
+	// strings for in game rendering
+	// Q_strncpyz( cg.refdef.text[0], "Park Ranger", sizeof(cg.refdef.text[0]) );
+	// Q_strncpyz( cg.refdef.text[1], "19", sizeof(cg.refdef.text[1]) );
+
+	// calculate size of 3D view
+	CG_CalcVrect();
+
+	ps = &cg.predictedPlayerState;
+/*
+	if (cg.cameraMode) {
+		vec3_t origin, angles;
+		if (trap_getCameraInfo(cg.time, &origin, &angles)) {
+			VectorCopy(origin, cg.refdef.vieworg);
+			angles[ROLL] = 0;
+			VectorCopy(angles, cg.refdef.viewangles);
+			AnglesToAxis( cg.refdef.viewangles, cg.refdef.viewaxis );
+			return CG_CalcFov();
+		} else {
+			cg.cameraMode = qfalse;
+		}
+	}
+*/
+	// intermission view
+	if ( ps->pm_type == PM_INTERMISSION ) {
+		VectorCopy( ps->origin, cg.refdef.vieworg );
+		VectorCopy( ps->viewangles, cg.refdef.viewangles );
+		AnglesToAxis( cg.refdef.viewangles, cg.refdef.viewaxis );
+		return CG_CalcFov();
+	}
+
+	cg.bobcycle = ( ps->bobCycle & 128 ) >> 7;
+	cg.bobfracsin = fabs( sin( ( ps->bobCycle & 127 ) / 127.0 * M_PI ) );
+	cg.xyspeed = sqrt( ps->velocity[0] * ps->velocity[0] +
+		ps->velocity[1] * ps->velocity[1] );
+
+	if (cg.xyspeed > 270)
+	{
+		cg.xyspeed = 270;
+	}
+
+	manningTurret = CG_CheckPassengerTurretView();
+	if ( !manningTurret )
+	{//not manning a turret on a vehicle
+		VectorCopy( ps->origin, cg.refdef.vieworg );
+		if ( cg.predictedPlayerState.m_iVehicleNum )//in a vehicle
+		{
+			Vehicle_t *pVeh = cg_entities[cg.predictedPlayerState.m_iVehicleNum].m_pVehicle;
+			if ( BG_UnrestrainedPitchRoll( &cg.predictedPlayerState, pVeh ) )//can roll/pitch without restriction
+			{//use the vehicle's viewangles to render view!
+				VectorCopy( cg.predictedVehicleState.viewangles, cg.refdef.viewangles );
+			}
+			else if ( pVeh //valid vehicle data pointer
+				&& pVeh->m_pVehicleInfo//valid vehicle info
+				&& pVeh->m_pVehicleInfo->type == VH_FIGHTER )//fighter
+			{
+				VectorCopy( cg.predictedVehicleState.viewangles, cg.refdef.viewangles );
+				cg.refdef.viewangles[PITCH] = AngleNormalize180( cg.refdef.viewangles[PITCH] );
+			}
+			else
+			{
+				VectorCopy( ps->viewangles, cg.refdef.viewangles );
+			}
+		/*
+		if ( cg.predictedPlayerState.m_iVehicleNum //in a vehicle
+			&& BG_UnrestrainedPitchRoll( &cg.predictedPlayerState, cg_entities[cg.predictedPlayerState.m_iVehicleNum].m_pVehicle ) )//can roll/pitch without restriction
+		{//use the vehicle's viewangles to render view!
+			VectorCopy( cg.predictedVehicleState.viewangles, cg.refdef.viewangles );
+		*/
+		}
+		else
+		{
+			VectorCopy( ps->viewangles, cg.refdef.viewangles );
+		}
+	}
+	VectorCopy( cg.refdef.viewangles, cg_lastTurretViewAngles );
+
+	if (cg_cameraOrbit.integer) {
+		if (cg.time > cg.nextOrbitTime) {
+			cg.nextOrbitTime = cg.time + cg_cameraOrbitDelay.integer;
+			cg_thirdPersonAngle.value += cg_cameraOrbit.value;
+		}
+	}
+	// add error decay
+	if ( cg_errorDecay.value > 0 ) {
+		int		t;
+		float	f;
+
+		t = cg.time - cg.predictedErrorTime;
+		f = ( cg_errorDecay.value - t ) / cg_errorDecay.value;
+		if ( f > 0 && f < 1 ) {
+			VectorMA( cg.refdef.vieworg, f, cg.predictedError, cg.refdef.vieworg );
+		} else {
+			cg.predictedErrorTime = 0;
+		}
+	}
+
+	if (cg.snap->ps.weapon == WP_EMPLACED_GUN &&
+		cg.snap->ps.emplacedIndex)
+	{ //constrain the view properly for emplaced guns
+		CG_EmplacedView(cg_entities[cg.snap->ps.emplacedIndex].currentState.angles);
+	}
+
+	if ( !manningTurret )
+	{
+		if ( cg.predictedPlayerState.m_iVehicleNum //in a vehicle
+			&& BG_UnrestrainedPitchRoll( &cg.predictedPlayerState, cg_entities[cg.predictedPlayerState.m_iVehicleNum].m_pVehicle ) )//can roll/pitch without restriction
+		{//use the vehicle's viewangles to render view!
+			CG_OffsetFighterView();
+		}
+		else if ( cg.renderingThirdPerson ) {
+			// back away from character
+			if (cg_thirdPersonSpecialCam.integer &&
+				BG_SaberInSpecial(cg.snap->ps.saberMove))
+			{ //the action cam
+				if (!CG_ThirdPersonActionCam())
+				{ //couldn't do it for whatever reason, resort back to third person then
+					CG_OffsetThirdPersonView();
+				}
+			}
+			else
+			{
+				CG_OffsetThirdPersonView();
+			}
+		} else {
+			// offset for local bobbing and kicks
+			CG_OffsetFirstPersonView();
+		}
+	}
+
+	// position eye relative to origin
+	AnglesToAxis( cg.refdef.viewangles, cg.refdef.viewaxis );
+
+	if ( cg.hyperspace ) {
+		cg.refdef.rdflags |= RDF_NOWORLDMODEL | RDF_HYPERSPACE;
+	}
+
+	// field of view
+	return CG_CalcFov();
+}
+
+
+/*
+=====================
+CG_PowerupTimerSounds
+=====================
+*/
+static void CG_PowerupTimerSounds( void ) {
+	int		i;
+	int		t;
+
+	// powerup timers going away
+	for ( i = 0 ; i < MAX_POWERUPS ; i++ ) {
+		t = cg.snap->ps.powerups[i];
+		if ( t <= cg.time ) {
+			continue;
+		}
+		if ( t - cg.time >= POWERUP_BLINKS * POWERUP_BLINK_TIME ) {
+			continue;
+		}
+		if ( ( t - cg.time ) / POWERUP_BLINK_TIME != ( t - cg.oldTime ) / POWERUP_BLINK_TIME ) {
+			//trap_S_StartSound( NULL, cg.snap->ps.clientNum, CHAN_ITEM, cgs.media.wearOffSound );
+		}
+	}
+}
+
+/*
+==============
+CG_DrawSkyBoxPortal
+==============
+*/
+extern qboolean cg_skyOri;
+extern vec3_t cg_skyOriPos;
+extern float cg_skyOriScale;
+extern qboolean cg_noFogOutsidePortal;
+void CG_DrawSkyBoxPortal(const char *cstr)
+{
+	static float lastfov;
+	refdef_t backuprefdef;
+	float fov_x;
+	float fov_y;
+	float x;
+	char *token;
+	float f = 0;
+
+	lastfov = zoomFov;	// for transitions back from zoomed in modes
+
+	backuprefdef = cg.refdef;
+
+	token = COM_ParseExt(&cstr, qfalse);
+	if (!token || !token[0])
+	{
+		CG_Error( "CG_DrawSkyBoxPortal: error parsing skybox configstring\n");
+	}
+	cg.refdef.vieworg[0] = atof(token);
+
+	token = COM_ParseExt(&cstr, qfalse);
+	if (!token || !token[0])
+	{
+		CG_Error( "CG_DrawSkyBoxPortal: error parsing skybox configstring\n");
+	}
+	cg.refdef.vieworg[1] = atof(token);
+
+	token = COM_ParseExt(&cstr, qfalse);
+	if (!token || !token[0])
+	{
+		CG_Error( "CG_DrawSkyBoxPortal: error parsing skybox configstring\n");
+	}
+	cg.refdef.vieworg[2] = atof(token);
+
+	token = COM_ParseExt(&cstr, qfalse);
+	if (!token || !token[0]) 
+	{
+		CG_Error( "CG_DrawSkyBoxPortal: error parsing skybox configstring\n");
+	}
+	fov_x = atoi(token);
+
+	if (!fov_x)
+	{
+		fov_x = cg_fov.value;
+	}
+
+	// setup fog the first time, ignore this part of the configstring after that
+	token = COM_ParseExt(&cstr, qfalse);
+	if (!token || !token[0])
+	{
+		CG_Error( "CG_DrawSkyBoxPortal: error parsing skybox configstring.  No fog state\n");
+	}
+	else 
+	{
+		vec4_t	fogColor;
+		int		fogStart, fogEnd;
+
+		if(atoi(token))
+		{	// this camera has fog
+			token = COM_ParseExt(&cstr, qfalse);
+
+			if (!token || !token[0])
+			{
+				CG_Error( "CG_DrawSkyBoxPortal: error parsing skybox configstring.  No fog[0]\n");
+			}
+			fogColor[0] = atof(token);
+
+			token = COM_ParseExt(&cstr, qfalse);
+			if (!token || !token[0])
+			{
+				CG_Error( "CG_DrawSkyBoxPortal: error parsing skybox configstring.  No fog[1]\n");
+			}
+			fogColor[1] = atof(token);
+
+			token = COM_ParseExt(&cstr, qfalse);
+			if (!token || !token[0])
+			{
+				CG_Error( "CG_DrawSkyBoxPortal: error parsing skybox configstring.  No fog[2]\n");
+			}
+			fogColor[2] = atof(token);
+
+			token = COM_ParseExt(&cstr, qfalse);
+			if (!token || !token[0])
+			{
+				fogStart = 0;
+			}
+			else
+			{
+				fogStart = atoi(token);
+			}
+
+			token = COM_ParseExt(&cstr, qfalse);
+			if (!token || !token[0])
+			{
+				fogEnd = 0;
+			}
+			else
+			{
+				fogEnd = atoi(token);
+			}
+		}
+	}
+
+	if ( cg.predictedPlayerState.pm_type == PM_INTERMISSION )
+	{
+		// if in intermission, use a fixed value
+		fov_x = cg_fov.value;
+	}
+	else
+	{
+		fov_x = cg_fov.value;
+		if ( fov_x < 1 ) 
+		{
+			fov_x = 1;
+		}
+		else if ( fov_x > 160 )
+		{
+			fov_x = 160;
+		}
+
+		if (cg.predictedPlayerState.zoomMode)
+		{
+			fov_x = zoomFov;
+		}
+
+		// do smooth transitions for zooming
+		if (cg.predictedPlayerState.zoomMode)
+		{ //zoomed/zooming in
+			f = ( cg.time - cg.zoomTime ) / (float)ZOOM_OUT_TIME;
+			if ( f > 1.0 ) {
+				fov_x = zoomFov;
+			} else {
+				fov_x = fov_x + f * ( zoomFov - fov_x );
+			}
+			lastfov = fov_x;
+		}
+		else
+		{ //zooming out
+			f = ( cg.time - cg.zoomTime ) / (float)ZOOM_OUT_TIME;
+			if ( f > 1.0 ) {
+				fov_x = fov_x;
+			} else {
+				fov_x = zoomFov + f * ( fov_x - zoomFov);
+			}
+		}
+	}
+
+	x = cg.refdef.width / tan( fov_x / 360 * M_PI );
+	fov_y = atan2( cg.refdef.height, x );
+	fov_y = fov_y * 360 / M_PI;
+
+	cg.refdef.fov_x = fov_x;
+	cg.refdef.fov_y = fov_y;
+	
+	cg.refdef.rdflags |= RDF_SKYBOXPORTAL;
+	cg.refdef.rdflags |= RDF_DRAWSKYBOX;
+
+	cg.refdef.time = cg.time;
+
+	if ( !cg.hyperspace) 
+	{ //rww - also had to add this to add effects being rendered in portal sky areas properly.
+		trap_FX_AddScheduledEffects(qtrue);
+	}
+
+	CG_AddPacketEntities(qtrue); //rww - There was no proper way to put real entities inside the portal view before.
+									//This will put specially flagged entities in the render.
+
+	if (cg_skyOri)
+	{ //ok, we want to orient the sky refdef vieworg based on the normal vieworg's relation to the ori pos
+		vec3_t dif;
+
+		VectorSubtract(backuprefdef.vieworg, cg_skyOriPos, dif);
+		VectorScale(dif, cg_skyOriScale, dif);
+		VectorAdd(cg.refdef.vieworg, dif, cg.refdef.vieworg);
+	}
+
+	if (cg_noFogOutsidePortal)
+	{ //make sure no fog flag is stripped first, and make sure it is set on the normal refdef
+		cg.refdef.rdflags &= ~RDF_NOFOG;
+		backuprefdef.rdflags |= RDF_NOFOG;
+	}
+
+	// draw the skybox
+	trap_R_RenderScene( &cg.refdef );
+
+	cg.refdef = backuprefdef;
+}
+
+/*
+=====================
+CG_AddBufferedSound
+=====================
+*/
+void CG_AddBufferedSound( sfxHandle_t sfx ) {
+	if ( !sfx )
+		return;
+	cg.soundBuffer[cg.soundBufferIn] = sfx;
+	cg.soundBufferIn = (cg.soundBufferIn + 1) % MAX_SOUNDBUFFER;
+	if (cg.soundBufferIn == cg.soundBufferOut) {
+		cg.soundBufferOut++;
+	}
+}
+
+/*
+=====================
+CG_PlayBufferedSounds
+=====================
+*/
+static void CG_PlayBufferedSounds( void ) {
+	if ( cg.soundTime < cg.time ) {
+		if (cg.soundBufferOut != cg.soundBufferIn && cg.soundBuffer[cg.soundBufferOut]) {
+			trap_S_StartLocalSound(cg.soundBuffer[cg.soundBufferOut], CHAN_ANNOUNCER);
+			cg.soundBuffer[cg.soundBufferOut] = 0;
+			cg.soundBufferOut = (cg.soundBufferOut + 1) % MAX_SOUNDBUFFER;
+			cg.soundTime = cg.time + 750;
+		}
+	}
+}
+
+void CG_UpdateSoundTrackers()
+{
+	int num;
+	centity_t *cent;
+
+	for ( num = 0 ; num < ENTITYNUM_NONE ; num++ )
+	{
+		cent = &cg_entities[num];
+
+		if (cent && (cent->currentState.eFlags & EF_SOUNDTRACKER) && cent->currentState.number == num)
+			//make sure the thing is valid at least.
+		{ //keep sound for this entity updated in accordance with its attached entity at all times
+			if (cg.snap && cent->currentState.trickedentindex == cg.snap->ps.clientNum)
+			{ //this is actually the player, so center the sound origin right on top of us
+				VectorCopy(cg.refdef.vieworg, cent->lerpOrigin);
+				trap_S_UpdateEntityPosition( cent->currentState.number, cent->lerpOrigin );
+			}
+			else
+			{
+				trap_S_UpdateEntityPosition( cent->currentState.number, cg_entities[cent->currentState.trickedentindex].lerpOrigin );
+			}
+		}
+
+		if (cent->currentState.number == num)
+		{
+			//update all looping sounds..
+			CG_S_UpdateLoopingSounds(num);
+		}
+	}
+}
+
+//=========================================================================
+
+/*
+================================
+Screen Effect stuff starts here
+================================
+*/
+#define	CAMERA_DEFAULT_FOV			90.0f
+#define MAX_SHAKE_INTENSITY			16.0f
+
+cgscreffects_t cgScreenEffects;
+
+void CG_SE_UpdateShake( vec3_t origin, vec3_t angles )
+{
+	vec3_t	moveDir;
+	float	intensity_scale, intensity;
+	int		i;
+
+	if ( cgScreenEffects.shake_duration <= 0 )
+		return;
+
+	if ( cg.time > ( cgScreenEffects.shake_start + cgScreenEffects.shake_duration ) )
+	{
+		cgScreenEffects.shake_intensity = 0;
+		cgScreenEffects.shake_duration = 0;
+		cgScreenEffects.shake_start = 0;
+		return;
+	}
+
+	cgScreenEffects.FOV = CAMERA_DEFAULT_FOV;
+	cgScreenEffects.FOV2 = CAMERA_DEFAULT_FOV;
+
+	//intensity_scale now also takes into account FOV with 90.0 as normal
+	intensity_scale = 1.0f - ( (float) ( cg.time - cgScreenEffects.shake_start ) / (float) cgScreenEffects.shake_duration ) * (((cgScreenEffects.FOV+cgScreenEffects.FOV2)/2.0f)/90.0f);
+
+	intensity = cgScreenEffects.shake_intensity * intensity_scale;
+
+	for ( i = 0; i < 3; i++ )
+	{
+		moveDir[i] = ( crandom() * intensity );
+	}
+
+	//Move the camera
+	VectorAdd( origin, moveDir, origin );
+
+	for ( i=0; i < 2; i++ ) // Don't do ROLL
+		moveDir[i] = ( crandom() * intensity );
+
+	//Move the angles
+	VectorAdd( angles, moveDir, angles );
+}
+
+void CG_SE_UpdateMusic(void)
+{
+	if (cgScreenEffects.music_volume_multiplier < 0.1)
+	{
+		cgScreenEffects.music_volume_multiplier = 1.0;
+		return;
+	}
+
+	if (cgScreenEffects.music_volume_time < cg.time)
+	{
+		if (cgScreenEffects.music_volume_multiplier != 1.0 || cgScreenEffects.music_volume_set)
+		{
+			char musMultStr[512];
+
+			cgScreenEffects.music_volume_multiplier += 0.1;
+			if (cgScreenEffects.music_volume_multiplier > 1.0)
+			{
+				cgScreenEffects.music_volume_multiplier = 1.0;
+			}
+
+			Com_sprintf(musMultStr, sizeof(musMultStr), "%f", cgScreenEffects.music_volume_multiplier);
+			trap_Cvar_Set("s_musicMult", musMultStr);
+
+			if (cgScreenEffects.music_volume_multiplier == 1.0)
+			{
+				cgScreenEffects.music_volume_set = qfalse;
+			}
+			else
+			{
+				cgScreenEffects.music_volume_time = cg.time + 200;
+			}
+		}
+
+		return;
+	}
+
+	if (!cgScreenEffects.music_volume_set)
+	{ //if the volume_time is >= cg.time, we should have a volume multiplier set
+		char musMultStr[512];
+
+		Com_sprintf(musMultStr, sizeof(musMultStr), "%f", cgScreenEffects.music_volume_multiplier);
+		trap_Cvar_Set("s_musicMult", musMultStr);
+		cgScreenEffects.music_volume_set = qtrue;
+	}
+}
+
+/*
+=================
+CG_CalcScreenEffects
+
+Currently just for screen shaking (and music volume management)
+=================
+*/
+void CG_CalcScreenEffects(void)
+{
+	CG_SE_UpdateShake(cg.refdef.vieworg, cg.refdef.viewangles);
+	CG_SE_UpdateMusic();
+}
+
+void CGCam_Shake( float intensity, int duration )
+{
+	if ( intensity > MAX_SHAKE_INTENSITY )
+		intensity = MAX_SHAKE_INTENSITY;
+
+	cgScreenEffects.shake_intensity = intensity;
+	cgScreenEffects.shake_duration = duration;
+	
+
+	cgScreenEffects.shake_start = cg.time;
+//JLFRUMBLE
+#ifdef _XBOX
+extern void FF_XboxShake(float intensity, int duration);
+
+FF_XboxShake(intensity, duration);
+
+#endif
+}
+
+void CGCam_SetMusicMult( float multiplier, int duration )
+{
+	if (multiplier < 0.1f)
+	{
+		multiplier = 0.1f;
+	}
+
+	if (multiplier > 1.0f)
+	{
+		multiplier = 1.0f;
+	}
+
+	cgScreenEffects.music_volume_multiplier = multiplier;
+	cgScreenEffects.music_volume_time = cg.time + duration;
+	cgScreenEffects.music_volume_set = qfalse;
+}
+
+/*
+================================
+Screen Effect stuff ends here
+================================
+*/
+
+/*
+=================
+CG_EmplacedView
+
+Keep view reasonably constrained in relation to gun -rww
+=================
+*/
+#include "../namespace_begin.h"
+int BG_EmplacedView(vec3_t baseAngles, vec3_t angles, float *newYaw, float constraint);
+#include "../namespace_end.h"
+
+void CG_EmplacedView(vec3_t angles)
+{
+	float yaw;
+	int override;
+	
+	override = BG_EmplacedView(cg.refdef.viewangles, angles, &yaw,
+		cg_entities[cg.snap->ps.emplacedIndex].currentState.origin2[0]);
+	
+	if (override)
+	{
+        cg.refdef.viewangles[YAW] = yaw;
+		AnglesToAxis(cg.refdef.viewangles, cg.refdef.viewaxis);
+
+		if (override == 2)
+		{
+			trap_SetClientForceAngle(cg.time + 5000, cg.refdef.viewangles);
+		}
+	}
+
+	//we want to constrain the predicted player state viewangles as well
+	override = BG_EmplacedView(cg.predictedPlayerState.viewangles, angles, &yaw,
+		cg_entities[cg.snap->ps.emplacedIndex].currentState.origin2[0]);
+	if (override)
+	{
+        cg.predictedPlayerState.viewangles[YAW] = yaw;
+	}
+}
+
+//specially add cent's for automap
+static void CG_AddRefentForAutoMap(centity_t *cent)
+{
+	refEntity_t ent;
+	vec3_t flat;
+
+	if (cent->currentState.eFlags & EF_NODRAW)
+	{
+		return;
+	}
+
+	memset(&ent, 0, sizeof(refEntity_t));
+	ent.reType = RT_MODEL;
+
+	VectorCopy(cent->lerpAngles, flat);
+	flat[PITCH] = flat[ROLL] = 0.0f;
+
+	VectorCopy(cent->lerpOrigin, ent.origin);
+	VectorCopy(flat, ent.angles);
+	AnglesToAxis(flat, ent.axis);
+
+	if (cent->ghoul2 &&
+		(cent->currentState.eType == ET_PLAYER ||
+		cent->currentState.eType == ET_NPC ||
+		cent->currentState.modelGhoul2))
+	{ //using a ghoul2 model
+		ent.ghoul2 = cent->ghoul2;
+		ent.radius = cent->currentState.g2radius;
+
+		if (!ent.radius)
+		{
+			ent.radius = 64.0f;
+		}
+	}
+	else
+	{ //then assume a standard indexed model
+		ent.hModel = cgs.gameModels[cent->currentState.modelindex];
+	}
+
+	trap_R_AddRefEntityToScene(&ent);
+}
+
+//add all entities that would be on the radar
+void CG_AddRadarAutomapEnts(void)
+{
+	int i = 0;
+
+	//first add yourself
+	CG_AddRefentForAutoMap(&cg_entities[cg.predictedPlayerState.clientNum]);
+
+	while (i < cg.radarEntityCount)
+	{
+		CG_AddRefentForAutoMap(&cg_entities[cg.radarEntities[i]]);
+		i++;
+	}
+}
+
+/*
+================
+CG_DrawAutoMap
+
+Draws the automap scene. -rww
+================
+*/
+float cg_autoMapZoom = 512.0f;
+float cg_autoMapZoomMainOffset = 0.0f;
+vec3_t cg_autoMapAngle = {90.0f, 0.0f, 0.0f};
+autoMapInput_t cg_autoMapInput;
+int cg_autoMapInputTime = 0;
+#define	SIDEFRAME_WIDTH			16
+#define	SIDEFRAME_HEIGHT		32
+void CG_DrawAutoMap(void)
+{
+	clientInfo_t	*local;
+	refdef_t		refdef;
+	trace_t			tr;
+	vec3_t			fwd;
+	vec3_t			playerMins, playerMaxs;
+	int				vWidth, vHeight;
+	float			hScale, vScale;
+	float			x, y, w, h;
+
+	if (!cg_autoMap.integer)
+	{ //don't do anything then
+		return;
+	}
+
+	if ( cg.snap->ps.stats[STAT_HEALTH] <= 0 )
+	{ //don't show when dead
+		return;
+	}
+
+	if ( (cg.predictedPlayerState.pm_flags & PMF_FOLLOW) || cg.predictedPlayerState.persistant[PERS_TEAM] == TEAM_SPECTATOR )
+	{ //don't show when spec
+		return;
+	}
+
+	local = &cgs.clientinfo[ cg.predictedPlayerState.clientNum ];
+	if ( !local->infoValid )
+	{ //don't show if bad ci
+		return;
+	}
+
+	if (cgs.gametype < GT_TEAM)
+	{ //don't show in non-team gametypes
+		return;
+	}
+
+	if (cg_autoMapInputTime >= cg.time)
+	{
+		if (cg_autoMapInput.up)
+		{
+			cg_autoMapZoom -= cg_autoMapInput.up;
+			if (cg_autoMapZoom < cg_autoMapZoomMainOffset+64.0f)
+			{
+				cg_autoMapZoom = cg_autoMapZoomMainOffset+64.0f;
+			}
+		}
+
+		if (cg_autoMapInput.down)
+		{
+			cg_autoMapZoom += cg_autoMapInput.down;
+			if (cg_autoMapZoom > cg_autoMapZoomMainOffset+4096.0f)
+			{
+				cg_autoMapZoom = cg_autoMapZoomMainOffset+4096.0f;
+			}
+		}
+
+		if (cg_autoMapInput.yaw)
+		{
+			cg_autoMapAngle[YAW] += cg_autoMapInput.yaw;
+		}
+
+		if (cg_autoMapInput.pitch)
+		{
+			cg_autoMapAngle[PITCH] += cg_autoMapInput.pitch;
+		}
+
+		if (cg_autoMapInput.goToDefaults)
+		{
+			cg_autoMapZoom = 512.0f;
+			VectorSet(cg_autoMapAngle, 90.0f, 0.0f, 0.0f);
+		}
+	}
+
+	memset( &refdef, 0, sizeof( refdef ) );
+
+	refdef.rdflags = (RDF_NOWORLDMODEL|RDF_AUTOMAP);
+
+	VectorCopy(cg.predictedPlayerState.origin, refdef.vieworg);
+	VectorCopy(cg_autoMapAngle, refdef.viewangles);
+	
+	//scale out in the direction of the view angles base on the zoom factor
+	AngleVectors(refdef.viewangles, fwd, 0, 0);
+	VectorMA(refdef.vieworg, -cg_autoMapZoom, fwd, refdef.vieworg);
+
+	AnglesToAxis(refdef.viewangles, refdef.viewaxis);
+
+	refdef.fov_x = 50;
+	refdef.fov_y = 50;
+
+	//guess this doesn't need to be done every frame, but eh
+	trap_R_GetRealRes(&vWidth, &vHeight);
+
+	//set scaling values so that the 640x480 will result at 1.0/1.0
+	hScale = vWidth/640.0f;
+	vScale = vHeight/480.0f;
+
+	x = cg_autoMapX.value;
+	y = cg_autoMapY.value;
+	w = cg_autoMapW.value;
+	h = cg_autoMapH.value;
+
+	refdef.x = x*hScale;
+	refdef.y = y*vScale;
+	refdef.width = w*hScale;
+	refdef.height = h*vScale;
+
+	CG_DrawPic(x-SIDEFRAME_WIDTH, y, SIDEFRAME_WIDTH, h, cgs.media.wireframeAutomapFrame_left);
+	CG_DrawPic(x+w, y, SIDEFRAME_WIDTH, h, cgs.media.wireframeAutomapFrame_right);
+	CG_DrawPic(x-SIDEFRAME_WIDTH, y-SIDEFRAME_HEIGHT, w+(SIDEFRAME_WIDTH*2), SIDEFRAME_HEIGHT, cgs.media.wireframeAutomapFrame_top);
+	CG_DrawPic(x-SIDEFRAME_WIDTH, y+h, w+(SIDEFRAME_WIDTH*2), SIDEFRAME_HEIGHT, cgs.media.wireframeAutomapFrame_bottom);
+
+	refdef.time = cg.time;
+
+	trap_R_ClearScene();
+	CG_AddRadarAutomapEnts();
+
+	if (cg.predictedPlayerState.m_iVehicleNum &&
+		cg_entities[cg.predictedPlayerState.m_iVehicleNum].currentState.eType == ET_NPC &&
+		cg_entities[cg.predictedPlayerState.m_iVehicleNum].currentState.NPC_class == CLASS_VEHICLE &&
+		cg_entities[cg.predictedPlayerState.m_iVehicleNum].m_pVehicle &&
+		cg_entities[cg.predictedPlayerState.m_iVehicleNum].m_pVehicle->m_pVehicleInfo->type == VH_FIGHTER)
+	{ //constantly adjust to current height
+		trap_R_AutomapElevAdj(cg.predictedPlayerState.origin[2]);
+	}
+	else
+	{
+		//Trace down and set the ground elevation as the main automap elevation point
+		VectorSet(playerMins, -15, -15, DEFAULT_MINS_2);
+		VectorSet(playerMaxs, 15, 15, DEFAULT_MAXS_2);
+
+		VectorCopy(cg.predictedPlayerState.origin, fwd);
+		fwd[2] -= 4096.0f;
+		CG_Trace(&tr, cg.predictedPlayerState.origin, playerMins, playerMaxs, fwd, cg.predictedPlayerState.clientNum, MASK_SOLID);
+
+		if (!tr.startsolid && !tr.allsolid)
+		{
+			trap_R_AutomapElevAdj(tr.endpos[2]);
+		}
+	}
+	trap_R_RenderScene( &refdef );
+}
+
+/*
+=================
+CG_DrawActiveFrame
+
+Generates and draws a game scene and status information at the given time.
+=================
+*/
+static qboolean cg_rangedFogging = qfalse; //so we know if we should go back to normal fog
+float cg_linearFogOverride = 0.0f; //designer-specified override for linear fogging style
+
+#include "../namespace_begin.h"
+extern void BG_VehicleTurnRateForSpeed( Vehicle_t *pVeh, float speed, float *mPitchOverride, float *mYawOverride );
+extern qboolean PM_InKnockDown( playerState_t *ps );
+#include "../namespace_end.h"
+
+extern qboolean cgQueueLoad;
+extern void CG_ActualLoadDeferredPlayers( void );
+
+static int cg_siegeClassIndex = -2;
+
+void CG_DrawActiveFrame( int serverTime, stereoFrame_t stereoView, qboolean demoPlayback ) {
+	int		inwater;
+	const char *cstr;
+	float mSensitivity = cg.zoomSensitivity;
+	float mPitchOverride = 0.0f;
+	float mYawOverride = 0.0f;
+	float mSensitivityOverride = 0.0f;
+	qboolean bUseFighterPitch = qfalse;
+	static centity_t *veh = NULL;
+	qboolean	isFighter = qfalse;
+
+	if (cgQueueLoad)
+	{ //do this before you start messing around with adding ghoul2 refents and crap
+		CG_ActualLoadDeferredPlayers();
+		cgQueueLoad = qfalse;
+	}
+
+	cg.time = serverTime;
+	cg.demoPlayback = demoPlayback;
+
+	if (cg.snap && ui_myteam.integer != cg.snap->ps.persistant[PERS_TEAM])
+	{
+		trap_Cvar_Set ( "ui_myteam", va("%i", cg.snap->ps.persistant[PERS_TEAM]) );
+	}
+	if (cgs.gametype == GT_SIEGE &&
+		cg.snap &&
+		cg_siegeClassIndex != cgs.clientinfo[cg.snap->ps.clientNum].siegeIndex)
+	{
+		cg_siegeClassIndex = cgs.clientinfo[cg.snap->ps.clientNum].siegeIndex;
+		if (cg_siegeClassIndex == -1)
+		{
+			trap_Cvar_Set("ui_mySiegeClass", "<none>");
+		}
+		else
+		{
+			trap_Cvar_Set("ui_mySiegeClass", bgSiegeClasses[cg_siegeClassIndex].name);
+		}
+	}
+
+	// update cvars
+	CG_UpdateCvars();
+
+	// if we are only updating the screen as a loading
+	// pacifier, don't even try to read snapshots
+	if ( cg.infoScreenText[0] != 0 ) {
+		CG_DrawInformation();
+		return;
+	}
+
+	trap_FX_AdjustTime( cg.time );
+
+	CG_RunLightStyles();
+
+	// any looped sounds will be respecified as entities
+	// are added to the render list
+	trap_S_ClearLoopingSounds();
+
+	// clear all the render lists
+	trap_R_ClearScene();
+
+	// set up cg.snap and possibly cg.nextSnap
+	CG_ProcessSnapshots();
+
+	trap_ROFF_UpdateEntities();
+
+	// if we haven't received any snapshots yet, all
+	// we can draw is the information screen
+	if ( !cg.snap || ( cg.snap->snapFlags & SNAPFLAG_NOT_ACTIVE ) )
+	{
+#if 0	
+		// Transition from zero to negative one on the snapshot timeout.
+		// The reason we do this is because the first client frame is responsible for
+		// some farily slow processing (such as weather) and we dont want to include
+		// that processing time into our calculations
+		if ( !cg.snapshotTimeoutTime )
+		{
+			cg.snapshotTimeoutTime = -1;
+		}
+		// Transition the snapshot timeout time from -1 to the current time in 
+		// milliseconds which will start the timeout.
+		else if ( cg.snapshotTimeoutTime == -1 )
+		{		
+			cg.snapshotTimeoutTime = trap_Milliseconds ( );
+		}
+
+		// If we have been waiting too long then just error out
+		if ( cg.snapshotTimeoutTime > 0 && (trap_Milliseconds ( ) - cg.snapshotTimeoutTime > cg_snapshotTimeout.integer * 1000) )
+		{
+			Com_Error ( ERR_DROP, CG_GetStringEdString("MP_SVGAME", "SNAPSHOT_TIMEOUT"));
+			return;
+		}
+#endif	
+		CG_DrawInformation();
+		return;
+	}
+
+	// let the client system know what our weapon and zoom settings are
+	if (cg.snap && cg.snap->ps.saberLockTime > cg.time)
+	{
+		mSensitivity = 0.01f;
+	}
+	else if (cg.predictedPlayerState.weapon == WP_EMPLACED_GUN)
+	{ //lower sens for emplaced guns and vehicles
+		mSensitivity = 0.2f;
+	}
+	else if (cg.predictedPlayerState.m_iVehicleNum//in a vehicle
+		&& !cg.predictedPlayerState.generic1 )//not as a passenger
+	{
+		centity_t *cent = &cg_entities[cg.predictedPlayerState.m_iVehicleNum];
+		if ( cent->m_pVehicle
+			&& cent->m_pVehicle->m_pVehicleInfo
+			&& cent->m_pVehicle->m_pVehicleInfo->type == VH_FIGHTER )
+		{
+			BG_VehicleTurnRateForSpeed( cent->m_pVehicle, cent->currentState.speed, &mPitchOverride, &mYawOverride );
+			//mSensitivityOverride = 5.0f;//old default value
+			mSensitivityOverride = 0.0f;
+			bUseFighterPitch = qtrue;
+			trap_SetUserCmdValue( cg.weaponSelect, mSensitivity, mPitchOverride, mYawOverride, mSensitivityOverride, cg.forceSelect, cg.itemSelect, bUseFighterPitch );
+			isFighter = qtrue;
+		}
+	} 
+
+	if ( !isFighter )
+	{
+		if (cg.predictedPlayerState.m_iVehicleNum)
+		{
+			veh = &cg_entities[cg.predictedPlayerState.m_iVehicleNum];
+		}
+		if (veh &&
+			veh->currentState.eType == ET_NPC &&
+			veh->currentState.NPC_class == CLASS_VEHICLE &&
+			veh->m_pVehicle &&
+			veh->m_pVehicle->m_pVehicleInfo->type == VH_FIGHTER &&
+			bg_fighterAltControl.integer)
+		{
+			trap_SetUserCmdValue( cg.weaponSelect, mSensitivity, mPitchOverride, mYawOverride, 0.0f, cg.forceSelect, cg.itemSelect, qtrue );
+			veh = NULL; //this is done because I don't want an extra assign each frame because I am so perfect and super efficient.
+		}
+		else
+		{
+			trap_SetUserCmdValue( cg.weaponSelect, mSensitivity, mPitchOverride, mYawOverride, 0.0f, cg.forceSelect, cg.itemSelect, qfalse );
+		}
+	}
+
+	// this counter will be bumped for every valid scene we generate
+	cg.clientFrame++;
+
+	// update cg.predictedPlayerState
+	CG_PredictPlayerState();
+
+	// decide on third person view
+	cg.renderingThirdPerson = cg_thirdPerson.integer || (cg.snap->ps.stats[STAT_HEALTH] <= 0);
+
+	if (cg.snap->ps.stats[STAT_HEALTH] > 0)
+	{
+		if (cg.predictedPlayerState.weapon == WP_EMPLACED_GUN && cg.predictedPlayerState.emplacedIndex /*&&
+			cg_entities[cg.predictedPlayerState.emplacedIndex].currentState.weapon == WP_NONE*/)
+		{ //force third person for e-web and emplaced use
+			cg.renderingThirdPerson = 1;
+		}
+		else if (cg.predictedPlayerState.weapon == WP_SABER || cg.predictedPlayerState.weapon == WP_MELEE ||
+			BG_InGrappleMove(cg.predictedPlayerState.torsoAnim) || BG_InGrappleMove(cg.predictedPlayerState.legsAnim) ||
+			cg.predictedPlayerState.forceHandExtend == HANDEXTEND_KNOCKDOWN || cg.predictedPlayerState.fallingToDeath ||
+			cg.predictedPlayerState.m_iVehicleNum || PM_InKnockDown(&cg.predictedPlayerState))
+		{
+			if (cg_fpls.integer && cg.predictedPlayerState.weapon == WP_SABER)
+			{ //force to first person for fpls
+				cg.renderingThirdPerson = 0;
+			}
+			else
+			{
+				cg.renderingThirdPerson = 1;
+			}
+		}
+		else if (cg.snap->ps.zoomMode)
+		{ //always force first person when zoomed
+			cg.renderingThirdPerson = 0;
+		}
+	}
+	
+	if (cg.predictedPlayerState.pm_type == PM_SPECTATOR)
+	{ //always first person for spec
+		cg.renderingThirdPerson = 0;
+	}
+
+
+	if (cg.snap->ps.persistant[PERS_TEAM] == TEAM_SPECTATOR)
+	{
+		cg.renderingThirdPerson = 0;
+	}
+
+	// build cg.refdef
+	inwater = CG_CalcViewValues();
+
+	if (cg_linearFogOverride)
+	{
+		trap_R_SetRangeFog(-cg_linearFogOverride);
+	}
+	else if (cg.predictedPlayerState.zoomMode)
+	{ //zooming with binoculars or sniper, set the fog range based on the zoom level -rww
+		cg_rangedFogging = qtrue;
+		//smaller the fov the less fog we have between the view and cull dist
+		trap_R_SetRangeFog(cg.refdef.fov_x*64.0f);
+	}
+	else if (cg_rangedFogging)
+	{ //disable it
+		cg_rangedFogging = qfalse;
+		trap_R_SetRangeFog(0.0f);
+	}
+
+	cstr = CG_ConfigString(CS_SKYBOXORG);
+
+	if (cstr && cstr[0])
+	{ //we have a skyportal
+		CG_DrawSkyBoxPortal(cstr);
+	}
+
+	CG_CalcScreenEffects();
+
+	// first person blend blobs, done after AnglesToAxis
+	if ( !cg.renderingThirdPerson && cg.predictedPlayerState.pm_type != PM_SPECTATOR ) {
+		CG_DamageBlendBlob();
+	}
+
+	// build the render lists
+	if ( !cg.hyperspace ) {
+		CG_AddPacketEntities(qfalse);			// adter calcViewValues, so predicted player state is correct
+		CG_AddMarks();
+		CG_AddParticles ();
+		CG_AddLocalEntities();
+		CG_DrawMiscEnts();
+	}
+	CG_AddViewWeapon( &cg.predictedPlayerState );
+
+	if ( !cg.hyperspace) 
+	{
+		trap_FX_AddScheduledEffects(qfalse);
+	}
+
+	// add buffered sounds
+	CG_PlayBufferedSounds();
+
+	// finish up the rest of the refdef
+	if ( cg.testModelEntity.hModel ) {
+		CG_AddTestModel();
+	}
+	cg.refdef.time = cg.time;
+	memcpy( cg.refdef.areamask, cg.snap->areamask, sizeof( cg.refdef.areamask ) );
+
+	// warning sounds when powerup is wearing off
+	CG_PowerupTimerSounds();
+
+	// if there are any entities flagged as sound trackers and attached to other entities, update their sound pos
+	CG_UpdateSoundTrackers();
+
+	if (gCGHasFallVector)
+	{
+		vec3_t lookAng;
+
+		VectorSubtract(cg.snap->ps.origin, cg.refdef.vieworg, lookAng);
+		VectorNormalize(lookAng);
+		vectoangles(lookAng, lookAng);
+
+		VectorCopy(gCGFallVector, cg.refdef.vieworg);
+		AnglesToAxis(lookAng, cg.refdef.viewaxis);
+	}
+
+	//This is done from the vieworg to get origin for non-attenuated sounds
+	cstr = CG_ConfigString( CS_GLOBAL_AMBIENT_SET );
+
+	if (cstr && cstr[0])
+	{
+		trap_S_UpdateAmbientSet( cstr, cg.refdef.vieworg );
+	}
+
+	// update audio positions
+	trap_S_Respatialize( cg.snap->ps.clientNum, cg.refdef.vieworg, cg.refdef.viewaxis, inwater );
+
+	// make sure the lagometerSample and frame timing isn't done twice when in stereo
+	if ( stereoView != STEREO_RIGHT ) {
+		cg.frametime = cg.time - cg.oldTime;
+		if ( cg.frametime < 0 ) {
+			cg.frametime = 0;
+		}
+		cg.oldTime = cg.time;
+		CG_AddLagometerFrameInfo();
+	}
+	if (cg_timescale.value != cg_timescaleFadeEnd.value) {
+		if (cg_timescale.value < cg_timescaleFadeEnd.value) {
+			cg_timescale.value += cg_timescaleFadeSpeed.value * ((float)cg.frametime) / 1000;
+			if (cg_timescale.value > cg_timescaleFadeEnd.value)
+				cg_timescale.value = cg_timescaleFadeEnd.value;
+		}
+		else {
+			cg_timescale.value -= cg_timescaleFadeSpeed.value * ((float)cg.frametime) / 1000;
+			if (cg_timescale.value < cg_timescaleFadeEnd.value)
+				cg_timescale.value = cg_timescaleFadeEnd.value;
+		}
+		if (cg_timescaleFadeSpeed.value) {
+			trap_Cvar_Set("timescale", va("%f", cg_timescale.value));
+		}
+	}
+
+	// actually issue the rendering calls
+	CG_DrawActive( stereoView );
+
+	CG_DrawAutoMap();
+
+	if ( cg_stats.integer ) {
+		CG_Printf( "cg.clientFrame:%i\n", cg.clientFrame );
+	}
+}
+
diff --git a/codemp/cgame/cg_weaponinit.c b/codemp/cgame/cg_weaponinit.c
new file mode 100644
index 0000000..118155d
--- /dev/null
+++ b/codemp/cgame/cg_weaponinit.c
@@ -0,0 +1,592 @@
+//
+// cg_weaponinit.c -- events and effects dealing with weapons
+#include "cg_local.h"
+#include "fx_local.h"
+
+
+/*
+=================
+CG_RegisterWeapon
+
+The server says this item is used on this level
+=================
+*/
+void CG_RegisterWeapon( int weaponNum) {
+	weaponInfo_t	*weaponInfo;
+	gitem_t			*item, *ammo;
+	char			path[MAX_QPATH];
+	vec3_t			mins, maxs;
+	int				i;
+
+	weaponInfo = &cg_weapons[weaponNum];
+
+	if ( weaponNum == 0 ) {
+		return;
+	}
+
+	if ( weaponInfo->registered ) {
+		return;
+	}
+
+	memset( weaponInfo, 0, sizeof( *weaponInfo ) );
+	weaponInfo->registered = qtrue;
+
+	for ( item = bg_itemlist + 1 ; item->classname ; item++ ) {
+		if ( item->giType == IT_WEAPON && item->giTag == weaponNum ) {
+			weaponInfo->item = item;
+			break;
+		}
+	}
+	if ( !item->classname ) {
+		CG_Error( "Couldn't find weapon %i", weaponNum );
+	}
+	CG_RegisterItemVisuals( item - bg_itemlist );
+
+	// load cmodel before model so filecache works
+	weaponInfo->weaponModel = trap_R_RegisterModel( item->world_model[0] );
+	// load in-view model also
+	weaponInfo->viewModel = trap_R_RegisterModel(item->view_model);
+
+	// calc midpoint for rotation
+	trap_R_ModelBounds( weaponInfo->weaponModel, mins, maxs );
+	for ( i = 0 ; i < 3 ; i++ ) {
+		weaponInfo->weaponMidpoint[i] = mins[i] + 0.5 * ( maxs[i] - mins[i] );
+	}
+
+	weaponInfo->weaponIcon = trap_R_RegisterShader( item->icon );
+	weaponInfo->ammoIcon = trap_R_RegisterShader( item->icon );
+
+	for ( ammo = bg_itemlist + 1 ; ammo->classname ; ammo++ ) {
+		if ( ammo->giType == IT_AMMO && ammo->giTag == weaponNum ) {
+			break;
+		}
+	}
+	if ( ammo->classname && ammo->world_model[0] ) {
+		weaponInfo->ammoModel = trap_R_RegisterModel( ammo->world_model[0] );
+	}
+
+//	strcpy( path, item->view_model );
+//	COM_StripExtension( path, path );
+//	strcat( path, "_flash.md3" );
+	weaponInfo->flashModel = 0;//trap_R_RegisterModel( path );
+
+	if (weaponNum == WP_DISRUPTOR ||
+		weaponNum == WP_FLECHETTE ||
+		weaponNum == WP_REPEATER ||
+		weaponNum == WP_ROCKET_LAUNCHER)
+	{
+		strcpy( path, item->view_model );
+		COM_StripExtension( path, path );
+		strcat( path, "_barrel.md3" );
+		weaponInfo->barrelModel = trap_R_RegisterModel( path );
+	}
+	else if (weaponNum == WP_STUN_BATON)
+	{ //only weapon with more than 1 barrel..
+		trap_R_RegisterModel("models/weapons2/stun_baton/baton_barrel.md3");
+		trap_R_RegisterModel("models/weapons2/stun_baton/baton_barrel2.md3");
+		trap_R_RegisterModel("models/weapons2/stun_baton/baton_barrel3.md3");
+	}
+	else
+	{
+		weaponInfo->barrelModel = 0;
+	}
+
+	if (weaponNum != WP_SABER)
+	{
+		strcpy( path, item->view_model );
+		COM_StripExtension( path, path );
+		strcat( path, "_hand.md3" );
+		weaponInfo->handsModel = trap_R_RegisterModel( path );
+	}
+	else
+	{
+		weaponInfo->handsModel = 0;
+	}
+
+//	if ( !weaponInfo->handsModel ) {
+//		weaponInfo->handsModel = trap_R_RegisterModel( "models/weapons2/shotgun/shotgun_hand.md3" );
+//	}
+
+	switch ( weaponNum ) {
+	case WP_STUN_BATON:
+	case WP_MELEE:
+/*		MAKERGB( weaponInfo->flashDlightColor, 0.6f, 0.6f, 1.0f );
+		weaponInfo->firingSound = trap_S_RegisterSound( "sound/weapons/saber/saberhum.wav" );
+//		weaponInfo->flashSound[0] = trap_S_RegisterSound( "sound/weapons/melee/fstatck.wav" );
+*/
+		//trap_R_RegisterShader( "gfx/effects/stunPass" );
+		trap_FX_RegisterEffect( "stunBaton/flesh_impact" );
+
+		if (weaponNum == WP_STUN_BATON)
+		{
+			trap_S_RegisterSound( "sound/weapons/baton/idle.wav" );
+			weaponInfo->flashSound[0] = trap_S_RegisterSound( "sound/weapons/baton/fire.mp3" );
+			weaponInfo->altFlashSound[0] = trap_S_RegisterSound( "sound/weapons/baton/fire.mp3" );
+		}
+		else
+		{
+			/*
+			int j = 0;
+
+			while (j < 4)
+			{
+				weaponInfo->flashSound[j] = trap_S_RegisterSound( va("sound/weapons/melee/swing%i", j+1) );
+				weaponInfo->altFlashSound[j] = weaponInfo->flashSound[j];
+				j++;
+			}
+			*/
+			//No longer needed, animsound config plays them for us
+		}
+		break;
+	case WP_SABER:
+		MAKERGB( weaponInfo->flashDlightColor, 0.6f, 0.6f, 1.0f );
+		weaponInfo->firingSound = trap_S_RegisterSound( "sound/weapons/saber/saberhum1.wav" );
+		weaponInfo->missileModel		= trap_R_RegisterModel( "models/weapons2/saber/saber_w.glm" );
+		break;
+
+	case WP_CONCUSSION:
+		weaponInfo->selectSound			= trap_S_RegisterSound("sound/weapons/concussion/select.wav");
+
+		weaponInfo->flashSound[0]		= NULL_SOUND;
+		weaponInfo->firingSound			= NULL_SOUND;
+		weaponInfo->chargeSound			= NULL_SOUND;
+		weaponInfo->muzzleEffect		= trap_FX_RegisterEffect( "concussion/muzzle_flash" );
+		weaponInfo->missileModel		= NULL_HANDLE;
+		weaponInfo->missileSound		= NULL_SOUND;
+		weaponInfo->missileDlight		= 0;
+		//weaponInfo->missileDlightColor= {0,0,0};
+		weaponInfo->missileHitSound		= NULL_SOUND;
+		weaponInfo->missileTrailFunc	= FX_ConcussionProjectileThink;
+
+		weaponInfo->altFlashSound[0]	= NULL_SOUND;
+		weaponInfo->altFiringSound		= NULL_SOUND;
+		weaponInfo->altChargeSound		= trap_S_RegisterSound( "sound/weapons/bryar/altcharge.wav");
+		weaponInfo->altMuzzleEffect		= trap_FX_RegisterEffect( "concussion/altmuzzle_flash" );
+		weaponInfo->altMissileModel		= NULL_HANDLE;
+		weaponInfo->altMissileSound		= NULL_SOUND;
+		weaponInfo->altMissileDlight	= 0;
+		//weaponInfo->altMissileDlightColor= {0,0,0};
+		weaponInfo->altMissileHitSound	= NULL_SOUND;
+		weaponInfo->altMissileTrailFunc = FX_ConcussionProjectileThink;
+
+		cgs.effects.disruptorAltMissEffect		= trap_FX_RegisterEffect( "disruptor/alt_miss" );
+
+		cgs.effects.concussionShotEffect		= trap_FX_RegisterEffect( "concussion/shot" );
+		cgs.effects.concussionImpactEffect		= trap_FX_RegisterEffect( "concussion/explosion" );
+		trap_R_RegisterShader("gfx/effects/blueLine");
+		trap_R_RegisterShader("gfx/misc/whiteline2");
+		break;
+
+	case WP_BRYAR_PISTOL:
+	case WP_BRYAR_OLD:
+		weaponInfo->selectSound			= trap_S_RegisterSound("sound/weapons/bryar/select.wav");
+
+		weaponInfo->flashSound[0]		= trap_S_RegisterSound( "sound/weapons/bryar/fire.wav");
+		weaponInfo->firingSound			= NULL_SOUND;
+		weaponInfo->chargeSound			= NULL_SOUND;
+		weaponInfo->muzzleEffect		= trap_FX_RegisterEffect( "bryar/muzzle_flash" );
+		weaponInfo->missileModel		= NULL_HANDLE;
+		weaponInfo->missileSound		= NULL_SOUND;
+		weaponInfo->missileDlight		= 0;
+		//weaponInfo->missileDlightColor= {0,0,0};
+		weaponInfo->missileHitSound		= NULL_SOUND;
+		weaponInfo->missileTrailFunc	= FX_BryarProjectileThink;
+
+		weaponInfo->altFlashSound[0]	= trap_S_RegisterSound( "sound/weapons/bryar/alt_fire.wav");
+		weaponInfo->altFiringSound		= NULL_SOUND;
+		weaponInfo->altChargeSound		= trap_S_RegisterSound( "sound/weapons/bryar/altcharge.wav");
+		weaponInfo->altMuzzleEffect		= trap_FX_RegisterEffect( "bryar/muzzle_flash" );
+		weaponInfo->altMissileModel		= NULL_HANDLE;
+		weaponInfo->altMissileSound		= NULL_SOUND;
+		weaponInfo->altMissileDlight	= 0;
+		//weaponInfo->altMissileDlightColor= {0,0,0};
+		weaponInfo->altMissileHitSound	= NULL_SOUND;
+		weaponInfo->altMissileTrailFunc = FX_BryarAltProjectileThink;
+
+		cgs.effects.bryarShotEffect			= trap_FX_RegisterEffect( "bryar/shot" );
+		cgs.effects.bryarPowerupShotEffect	= trap_FX_RegisterEffect( "bryar/crackleShot" );
+		cgs.effects.bryarWallImpactEffect	= trap_FX_RegisterEffect( "bryar/wall_impact" );
+		cgs.effects.bryarWallImpactEffect2	= trap_FX_RegisterEffect( "bryar/wall_impact2" );
+		cgs.effects.bryarWallImpactEffect3	= trap_FX_RegisterEffect( "bryar/wall_impact3" );
+		cgs.effects.bryarFleshImpactEffect	= trap_FX_RegisterEffect( "bryar/flesh_impact" );
+		cgs.effects.bryarDroidImpactEffect	= trap_FX_RegisterEffect( "bryar/droid_impact" );
+
+		cgs.media.bryarFrontFlash = trap_R_RegisterShader( "gfx/effects/bryarFrontFlash" );
+
+		// Note these are temp shared effects
+		trap_FX_RegisterEffect("blaster/wall_impact.efx");
+		trap_FX_RegisterEffect("blaster/flesh_impact.efx");
+
+		break;
+
+	case WP_BLASTER:
+	case WP_EMPLACED_GUN: //rww - just use the same as this for now..
+		weaponInfo->selectSound			= trap_S_RegisterSound("sound/weapons/blaster/select.wav");
+
+		weaponInfo->flashSound[0]		= trap_S_RegisterSound( "sound/weapons/blaster/fire.wav");
+		weaponInfo->firingSound			= NULL_SOUND;
+		weaponInfo->chargeSound			= NULL_SOUND;
+		weaponInfo->muzzleEffect		= trap_FX_RegisterEffect( "blaster/muzzle_flash" );
+		weaponInfo->missileModel		= NULL_HANDLE;
+		weaponInfo->missileSound		= NULL_SOUND;
+		weaponInfo->missileDlight		= 0;
+//		weaponInfo->missileDlightColor	= {0,0,0};
+		weaponInfo->missileHitSound		= NULL_SOUND;
+		weaponInfo->missileTrailFunc	= FX_BlasterProjectileThink;
+
+		weaponInfo->altFlashSound[0]	= trap_S_RegisterSound( "sound/weapons/blaster/alt_fire.wav");
+		weaponInfo->altFiringSound		= NULL_SOUND;
+		weaponInfo->altChargeSound		= NULL_SOUND;
+		weaponInfo->altMuzzleEffect		= trap_FX_RegisterEffect( "blaster/muzzle_flash" );
+		weaponInfo->altMissileModel		= NULL_HANDLE;
+		weaponInfo->altMissileSound		= NULL_SOUND;
+		weaponInfo->altMissileDlight	= 0;
+//		weaponInfo->altMissileDlightColor= {0,0,0};
+		weaponInfo->altMissileHitSound	= NULL_SOUND;
+		weaponInfo->altMissileTrailFunc = FX_BlasterProjectileThink;
+
+		trap_FX_RegisterEffect( "blaster/deflect" );
+		cgs.effects.blasterShotEffect			= trap_FX_RegisterEffect( "blaster/shot" );
+		cgs.effects.blasterWallImpactEffect		= trap_FX_RegisterEffect( "blaster/wall_impact" );
+		cgs.effects.blasterFleshImpactEffect	= trap_FX_RegisterEffect( "blaster/flesh_impact" );
+		cgs.effects.blasterDroidImpactEffect	= trap_FX_RegisterEffect( "blaster/droid_impact" );
+		break;
+
+	case WP_DISRUPTOR:
+		weaponInfo->selectSound			= trap_S_RegisterSound("sound/weapons/disruptor/select.wav");
+
+		weaponInfo->flashSound[0]		= trap_S_RegisterSound( "sound/weapons/disruptor/fire.wav");
+		weaponInfo->firingSound			= NULL_SOUND;
+		weaponInfo->chargeSound			= NULL_SOUND;
+		weaponInfo->muzzleEffect		= trap_FX_RegisterEffect( "disruptor/muzzle_flash" );
+		weaponInfo->missileModel		= NULL_HANDLE;
+		weaponInfo->missileSound		= NULL_SOUND;
+		weaponInfo->missileDlight		= 0;
+//		weaponInfo->missileDlightColor	= {0,0,0};
+		weaponInfo->missileHitSound		= NULL_SOUND;
+		weaponInfo->missileTrailFunc	= 0;
+
+		weaponInfo->altFlashSound[0]	= trap_S_RegisterSound( "sound/weapons/disruptor/alt_fire.wav");
+		weaponInfo->altFiringSound		= NULL_SOUND;
+		weaponInfo->altChargeSound		= trap_S_RegisterSound("sound/weapons/disruptor/altCharge.wav");
+		weaponInfo->altMuzzleEffect		= trap_FX_RegisterEffect( "disruptor/muzzle_flash" );
+		weaponInfo->altMissileModel		= NULL_HANDLE;
+		weaponInfo->altMissileSound		= NULL_SOUND;
+		weaponInfo->altMissileDlight	= 0;
+//		weaponInfo->altMissileDlightColor= {0,0,0};
+		weaponInfo->altMissileHitSound	= NULL_SOUND;
+		weaponInfo->altMissileTrailFunc = 0;
+
+		cgs.effects.disruptorRingsEffect		= trap_FX_RegisterEffect( "disruptor/rings" );
+		cgs.effects.disruptorProjectileEffect	= trap_FX_RegisterEffect( "disruptor/projectile" );
+		cgs.effects.disruptorWallImpactEffect	= trap_FX_RegisterEffect( "disruptor/wall_impact" );
+		cgs.effects.disruptorFleshImpactEffect	= trap_FX_RegisterEffect( "disruptor/flesh_impact" );
+		cgs.effects.disruptorAltMissEffect		= trap_FX_RegisterEffect( "disruptor/alt_miss" );
+		cgs.effects.disruptorAltHitEffect		= trap_FX_RegisterEffect( "disruptor/alt_hit" );
+
+		trap_R_RegisterShader( "gfx/effects/redLine" );
+		trap_R_RegisterShader( "gfx/misc/whiteline2" );
+		trap_R_RegisterShader( "gfx/effects/smokeTrail" );
+
+		trap_S_RegisterSound("sound/weapons/disruptor/zoomstart.wav");
+		trap_S_RegisterSound("sound/weapons/disruptor/zoomend.wav");
+
+		// Disruptor gun zoom interface
+		cgs.media.disruptorMask			= trap_R_RegisterShader( "gfx/2d/cropCircle2");
+		cgs.media.disruptorInsert		= trap_R_RegisterShader( "gfx/2d/cropCircle");
+		cgs.media.disruptorLight		= trap_R_RegisterShader( "gfx/2d/cropCircleGlow" );
+		cgs.media.disruptorInsertTick	= trap_R_RegisterShader( "gfx/2d/insertTick" );
+		cgs.media.disruptorChargeShader	= trap_R_RegisterShaderNoMip("gfx/2d/crop_charge");
+
+		cgs.media.disruptorZoomLoop		= trap_S_RegisterSound( "sound/weapons/disruptor/zoomloop.wav" );
+		break;
+
+	case WP_BOWCASTER:
+		weaponInfo->selectSound			= trap_S_RegisterSound("sound/weapons/bowcaster/select.wav");
+
+		weaponInfo->altFlashSound[0]		= trap_S_RegisterSound( "sound/weapons/bowcaster/fire.wav");
+		weaponInfo->altFiringSound			= NULL_SOUND;
+		weaponInfo->altChargeSound			= NULL_SOUND;
+		weaponInfo->altMuzzleEffect		= trap_FX_RegisterEffect( "bowcaster/muzzle_flash" );
+		weaponInfo->altMissileModel		= NULL_HANDLE;
+		weaponInfo->altMissileSound		= NULL_SOUND;
+		weaponInfo->altMissileDlight		= 0;
+//		weaponInfo->altMissileDlightColor	= {0,0,0};
+		weaponInfo->altMissileHitSound		= NULL_SOUND;
+		weaponInfo->altMissileTrailFunc	= FX_BowcasterProjectileThink;
+
+		weaponInfo->flashSound[0]	= trap_S_RegisterSound( "sound/weapons/bowcaster/fire.wav");
+		weaponInfo->firingSound		= NULL_SOUND;
+		weaponInfo->chargeSound		= trap_S_RegisterSound( "sound/weapons/bowcaster/altcharge.wav");
+		weaponInfo->muzzleEffect		= trap_FX_RegisterEffect( "bowcaster/muzzle_flash" );
+		weaponInfo->missileModel		= NULL_HANDLE;
+		weaponInfo->missileSound		= NULL_SOUND;
+		weaponInfo->missileDlight	= 0;
+//		weaponInfo->missileDlightColor= {0,0,0};
+		weaponInfo->missileHitSound	= NULL_SOUND;
+		weaponInfo->missileTrailFunc = FX_BowcasterAltProjectileThink;
+
+		cgs.effects.bowcasterShotEffect		= trap_FX_RegisterEffect( "bowcaster/shot" );
+		cgs.effects.bowcasterImpactEffect	= trap_FX_RegisterEffect( "bowcaster/explosion" );
+
+		trap_FX_RegisterEffect( "bowcaster/deflect" );
+
+		cgs.media.greenFrontFlash = trap_R_RegisterShader( "gfx/effects/greenFrontFlash" );
+		break;
+
+	case WP_REPEATER:
+		weaponInfo->selectSound			= trap_S_RegisterSound("sound/weapons/repeater/select.wav");
+
+		weaponInfo->flashSound[0]		= trap_S_RegisterSound( "sound/weapons/repeater/fire.wav");
+		weaponInfo->firingSound			= NULL_SOUND;
+		weaponInfo->chargeSound			= NULL_SOUND;
+		weaponInfo->muzzleEffect		= trap_FX_RegisterEffect( "repeater/muzzle_flash" );
+		weaponInfo->missileModel		= NULL_HANDLE;
+		weaponInfo->missileSound		= NULL_SOUND;
+		weaponInfo->missileDlight		= 0;
+//		weaponInfo->missileDlightColor	= {0,0,0};
+		weaponInfo->missileHitSound		= NULL_SOUND;
+		weaponInfo->missileTrailFunc	= FX_RepeaterProjectileThink;
+
+		weaponInfo->altFlashSound[0]	= trap_S_RegisterSound( "sound/weapons/repeater/alt_fire.wav");
+		weaponInfo->altFiringSound		= NULL_SOUND;
+		weaponInfo->altChargeSound		= NULL_SOUND;
+		weaponInfo->altMuzzleEffect		= trap_FX_RegisterEffect( "repeater/muzzle_flash" );
+		weaponInfo->altMissileModel		= NULL_HANDLE;
+		weaponInfo->altMissileSound		= NULL_SOUND;
+		weaponInfo->altMissileDlight	= 0;
+//		weaponInfo->altMissileDlightColor= {0,0,0};
+		weaponInfo->altMissileHitSound	= NULL_SOUND;
+		weaponInfo->altMissileTrailFunc = FX_RepeaterAltProjectileThink;
+
+		cgs.effects.repeaterProjectileEffect	= trap_FX_RegisterEffect( "repeater/projectile" );
+		cgs.effects.repeaterAltProjectileEffect	= trap_FX_RegisterEffect( "repeater/alt_projectile" );
+		cgs.effects.repeaterWallImpactEffect	= trap_FX_RegisterEffect( "repeater/wall_impact" );
+		cgs.effects.repeaterFleshImpactEffect	= trap_FX_RegisterEffect( "repeater/flesh_impact" );
+		//cgs.effects.repeaterAltWallImpactEffect	= trap_FX_RegisterEffect( "repeater/alt_wall_impact" );
+		cgs.effects.repeaterAltWallImpactEffect	= trap_FX_RegisterEffect( "repeater/concussion" );
+		break;
+
+	case WP_DEMP2:
+		weaponInfo->selectSound			= trap_S_RegisterSound("sound/weapons/demp2/select.wav");
+
+		weaponInfo->flashSound[0]		= trap_S_RegisterSound("sound/weapons/demp2/fire.wav");
+		weaponInfo->firingSound			= NULL_SOUND;
+		weaponInfo->chargeSound			= NULL_SOUND;
+		weaponInfo->muzzleEffect		= trap_FX_RegisterEffect("demp2/muzzle_flash");
+		weaponInfo->missileModel		= NULL_HANDLE;
+		weaponInfo->missileSound		= NULL_SOUND;
+		weaponInfo->missileDlight		= 0;
+//		weaponInfo->missileDlightColor	= {0,0,0};
+		weaponInfo->missileHitSound		= NULL_SOUND;
+		weaponInfo->missileTrailFunc	= FX_DEMP2_ProjectileThink;
+
+		weaponInfo->altFlashSound[0]	= trap_S_RegisterSound("sound/weapons/demp2/altfire.wav");
+		weaponInfo->altFiringSound		= NULL_SOUND;
+		weaponInfo->altChargeSound		= trap_S_RegisterSound("sound/weapons/demp2/altCharge.wav");
+		weaponInfo->altMuzzleEffect		= trap_FX_RegisterEffect("demp2/muzzle_flash");
+		weaponInfo->altMissileModel		= NULL_HANDLE;
+		weaponInfo->altMissileSound		= NULL_SOUND;
+		weaponInfo->altMissileDlight	= 0;
+//		weaponInfo->altMissileDlightColor= {0,0,0};
+		weaponInfo->altMissileHitSound	= NULL_SOUND;
+		weaponInfo->altMissileTrailFunc = 0;
+
+		cgs.effects.demp2ProjectileEffect		= trap_FX_RegisterEffect( "demp2/projectile" );
+		cgs.effects.demp2WallImpactEffect		= trap_FX_RegisterEffect( "demp2/wall_impact" );
+		cgs.effects.demp2FleshImpactEffect		= trap_FX_RegisterEffect( "demp2/flesh_impact" );
+
+		cgs.media.demp2Shell = trap_R_RegisterModel( "models/items/sphere.md3" );
+		cgs.media.demp2ShellShader = trap_R_RegisterShader( "gfx/effects/demp2shell" );
+
+		cgs.media.lightningFlash = trap_R_RegisterShader("gfx/misc/lightningFlash");
+		break;
+
+	case WP_FLECHETTE:
+		weaponInfo->selectSound			= trap_S_RegisterSound("sound/weapons/flechette/select.wav");
+
+		weaponInfo->flashSound[0]		= trap_S_RegisterSound( "sound/weapons/flechette/fire.wav");
+		weaponInfo->firingSound			= NULL_SOUND;
+		weaponInfo->chargeSound			= NULL_SOUND;
+		weaponInfo->muzzleEffect		= trap_FX_RegisterEffect( "flechette/muzzle_flash" );
+		weaponInfo->missileModel		= trap_R_RegisterModel("models/weapons2/golan_arms/projectileMain.md3");
+		weaponInfo->missileSound		= NULL_SOUND;
+		weaponInfo->missileDlight		= 0;
+//		weaponInfo->missileDlightColor	= {0,0,0};
+		weaponInfo->missileHitSound		= NULL_SOUND;
+		weaponInfo->missileTrailFunc	= FX_FlechetteProjectileThink;
+
+		weaponInfo->altFlashSound[0]	= trap_S_RegisterSound( "sound/weapons/flechette/alt_fire.wav");
+		weaponInfo->altFiringSound		= NULL_SOUND;
+		weaponInfo->altChargeSound		= NULL_SOUND;
+		weaponInfo->altMuzzleEffect		= trap_FX_RegisterEffect( "flechette/muzzle_flash" );
+		weaponInfo->altMissileModel		= trap_R_RegisterModel( "models/weapons2/golan_arms/projectile.md3" );
+		weaponInfo->altMissileSound		= NULL_SOUND;
+		weaponInfo->altMissileDlight	= 0;
+//		weaponInfo->altMissileDlightColor= {0,0,0};
+		weaponInfo->altMissileHitSound	= NULL_SOUND;
+		weaponInfo->altMissileTrailFunc = FX_FlechetteAltProjectileThink;
+
+		cgs.effects.flechetteShotEffect			= trap_FX_RegisterEffect( "flechette/shot" );
+		cgs.effects.flechetteAltShotEffect		= trap_FX_RegisterEffect( "flechette/alt_shot" );
+		cgs.effects.flechetteWallImpactEffect	= trap_FX_RegisterEffect( "flechette/wall_impact" );
+		cgs.effects.flechetteFleshImpactEffect	= trap_FX_RegisterEffect( "flechette/flesh_impact" );
+		break;
+
+	case WP_ROCKET_LAUNCHER:
+		weaponInfo->selectSound			= trap_S_RegisterSound("sound/weapons/rocket/select.wav");
+
+		weaponInfo->flashSound[0]		= trap_S_RegisterSound( "sound/weapons/rocket/fire.wav");
+		weaponInfo->firingSound			= NULL_SOUND;
+		weaponInfo->chargeSound			= NULL_SOUND;
+		weaponInfo->muzzleEffect		= trap_FX_RegisterEffect( "rocket/muzzle_flash" ); //trap_FX_RegisterEffect( "rocket/muzzle_flash2" );
+		//flash2 still looks crappy with the fx bolt stuff. Because the fx bolt stuff doesn't work entirely right.
+		weaponInfo->missileModel		= trap_R_RegisterModel( "models/weapons2/merr_sonn/projectile.md3" );
+		weaponInfo->missileSound		= trap_S_RegisterSound( "sound/weapons/rocket/missleloop.wav");
+		weaponInfo->missileDlight		= 125;
+		VectorSet(weaponInfo->missileDlightColor, 1.0, 1.0, 0.5);
+		weaponInfo->missileHitSound		= NULL_SOUND;
+		weaponInfo->missileTrailFunc	= FX_RocketProjectileThink;
+
+		weaponInfo->altFlashSound[0]	= trap_S_RegisterSound( "sound/weapons/rocket/alt_fire.wav");
+		weaponInfo->altFiringSound		= NULL_SOUND;
+		weaponInfo->altChargeSound		= NULL_SOUND;
+		weaponInfo->altMuzzleEffect		= trap_FX_RegisterEffect( "rocket/altmuzzle_flash" );
+		weaponInfo->altMissileModel		= trap_R_RegisterModel( "models/weapons2/merr_sonn/projectile.md3" );
+		weaponInfo->altMissileSound		= trap_S_RegisterSound( "sound/weapons/rocket/missleloop.wav");
+		weaponInfo->altMissileDlight	= 125;
+		VectorSet(weaponInfo->altMissileDlightColor, 1.0, 1.0, 0.5);
+		weaponInfo->altMissileHitSound	= NULL_SOUND;
+		weaponInfo->altMissileTrailFunc = FX_RocketAltProjectileThink;
+
+		cgs.effects.rocketShotEffect			= trap_FX_RegisterEffect( "rocket/shot" );
+		cgs.effects.rocketExplosionEffect		= trap_FX_RegisterEffect( "rocket/explosion" );
+	
+		trap_R_RegisterShaderNoMip( "gfx/2d/wedge" );
+		trap_R_RegisterShaderNoMip( "gfx/2d/lock" );
+
+		trap_S_RegisterSound( "sound/weapons/rocket/lock.wav" );
+		trap_S_RegisterSound( "sound/weapons/rocket/tick.wav" );
+		break;
+
+	case WP_THERMAL:
+		weaponInfo->selectSound			= trap_S_RegisterSound("sound/weapons/thermal/select.wav");
+
+		weaponInfo->flashSound[0]		= trap_S_RegisterSound( "sound/weapons/thermal/fire.wav");
+		weaponInfo->firingSound			= NULL_SOUND;
+		weaponInfo->chargeSound			= trap_S_RegisterSound( "sound/weapons/thermal/charge.wav");
+		weaponInfo->muzzleEffect		= NULL_FX;
+		weaponInfo->missileModel		= trap_R_RegisterModel( "models/weapons2/thermal/thermal_proj.md3" );
+		weaponInfo->missileSound		= NULL_SOUND;
+		weaponInfo->missileDlight		= 0;
+//		weaponInfo->missileDlightColor	= {0,0,0};
+		weaponInfo->missileHitSound		= NULL_SOUND;
+		weaponInfo->missileTrailFunc	= 0;
+
+		weaponInfo->altFlashSound[0]	= trap_S_RegisterSound( "sound/weapons/thermal/fire.wav");
+		weaponInfo->altFiringSound		= NULL_SOUND;
+		weaponInfo->altChargeSound		= trap_S_RegisterSound( "sound/weapons/thermal/charge.wav");
+		weaponInfo->altMuzzleEffect		= NULL_FX;
+		weaponInfo->altMissileModel		= trap_R_RegisterModel( "models/weapons2/thermal/thermal_proj.md3" );
+		weaponInfo->altMissileSound		= NULL_SOUND;
+		weaponInfo->altMissileDlight	= 0;
+//		weaponInfo->altMissileDlightColor= {0,0,0};
+		weaponInfo->altMissileHitSound	= NULL_SOUND;
+		weaponInfo->altMissileTrailFunc = 0;
+
+		cgs.effects.thermalExplosionEffect		= trap_FX_RegisterEffect( "thermal/explosion" );
+		cgs.effects.thermalShockwaveEffect		= trap_FX_RegisterEffect( "thermal/shockwave" );
+
+		cgs.media.grenadeBounce1		= trap_S_RegisterSound( "sound/weapons/thermal/bounce1.wav" );
+		cgs.media.grenadeBounce2		= trap_S_RegisterSound( "sound/weapons/thermal/bounce2.wav" );
+
+		trap_S_RegisterSound( "sound/weapons/thermal/thermloop.wav" );
+		trap_S_RegisterSound( "sound/weapons/thermal/warning.wav" );
+
+		break;
+
+	case WP_TRIP_MINE:
+		weaponInfo->selectSound			= trap_S_RegisterSound("sound/weapons/detpack/select.wav");
+
+		weaponInfo->flashSound[0]		= trap_S_RegisterSound( "sound/weapons/laser_trap/fire.wav");
+		weaponInfo->firingSound			= NULL_SOUND;
+		weaponInfo->chargeSound			= NULL_SOUND;
+		weaponInfo->muzzleEffect		= NULL_FX;
+		weaponInfo->missileModel		= 0;//trap_R_RegisterModel( "models/weapons2/laser_trap/laser_trap_w.md3" );
+		weaponInfo->missileSound		= NULL_SOUND;
+		weaponInfo->missileDlight		= 0;
+//		weaponInfo->missileDlightColor	= {0,0,0};
+		weaponInfo->missileHitSound		= NULL_SOUND;
+		weaponInfo->missileTrailFunc	= 0;
+
+		weaponInfo->altFlashSound[0]	= trap_S_RegisterSound( "sound/weapons/laser_trap/fire.wav");
+		weaponInfo->altFiringSound		= NULL_SOUND;
+		weaponInfo->altChargeSound		= NULL_SOUND;
+		weaponInfo->altMuzzleEffect		= NULL_FX;
+		weaponInfo->altMissileModel		= 0;//trap_R_RegisterModel( "models/weapons2/laser_trap/laser_trap_w.md3" );
+		weaponInfo->altMissileSound		= NULL_SOUND;
+		weaponInfo->altMissileDlight	= 0;
+//		weaponInfo->altMissileDlightColor= {0,0,0};
+		weaponInfo->altMissileHitSound	= NULL_SOUND;
+		weaponInfo->altMissileTrailFunc = 0;
+
+		cgs.effects.tripmineLaserFX = trap_FX_RegisterEffect("tripMine/laserMP.efx");
+		cgs.effects.tripmineGlowFX = trap_FX_RegisterEffect("tripMine/glowbit.efx");
+
+		trap_FX_RegisterEffect( "tripMine/explosion" );
+		// NOTENOTE temp stuff
+		trap_S_RegisterSound( "sound/weapons/laser_trap/stick.wav" );
+		trap_S_RegisterSound( "sound/weapons/laser_trap/warning.wav" );
+		break;
+
+	case WP_DET_PACK:
+		weaponInfo->selectSound			= trap_S_RegisterSound("sound/weapons/detpack/select.wav");
+
+		weaponInfo->flashSound[0]		= trap_S_RegisterSound( "sound/weapons/detpack/fire.wav");
+		weaponInfo->firingSound			= NULL_SOUND;
+		weaponInfo->chargeSound			= NULL_SOUND;
+		weaponInfo->muzzleEffect		= NULL_FX;
+		weaponInfo->missileModel		= trap_R_RegisterModel( "models/weapons2/detpack/det_pack.md3" );
+		weaponInfo->missileSound		= NULL_SOUND;
+		weaponInfo->missileDlight		= 0;
+//		weaponInfo->missileDlightColor	= {0,0,0};
+		weaponInfo->missileHitSound		= NULL_SOUND;
+		weaponInfo->missileTrailFunc	= 0;
+
+		weaponInfo->altFlashSound[0]	= trap_S_RegisterSound( "sound/weapons/detpack/fire.wav");
+		weaponInfo->altFiringSound		= NULL_SOUND;
+		weaponInfo->altChargeSound		= NULL_SOUND;
+		weaponInfo->altMuzzleEffect		= NULL_FX;
+		weaponInfo->altMissileModel		= trap_R_RegisterModel( "models/weapons2/detpack/det_pack.md3" );
+		weaponInfo->altMissileSound		= NULL_SOUND;
+		weaponInfo->altMissileDlight	= 0;
+//		weaponInfo->altMissileDlightColor= {0,0,0};
+		weaponInfo->altMissileHitSound	= NULL_SOUND;
+		weaponInfo->altMissileTrailFunc = 0;
+
+		trap_R_RegisterModel( "models/weapons2/detpack/det_pack.md3" );
+		trap_S_RegisterSound( "sound/weapons/detpack/stick.wav" );
+		trap_S_RegisterSound( "sound/weapons/detpack/warning.wav" );
+		trap_S_RegisterSound( "sound/weapons/explosions/explode5.wav" );
+		break;
+	case WP_TURRET:
+		weaponInfo->flashSound[0]		= NULL_SOUND;
+		weaponInfo->firingSound			= NULL_SOUND;
+		weaponInfo->chargeSound			= NULL_SOUND;
+		weaponInfo->muzzleEffect		= NULL_HANDLE;
+		weaponInfo->missileModel		= NULL_HANDLE;
+		weaponInfo->missileSound		= NULL_SOUND;
+		weaponInfo->missileDlight		= 0;
+		weaponInfo->missileHitSound		= NULL_SOUND;
+		weaponInfo->missileTrailFunc	= FX_TurretProjectileThink;
+
+		trap_FX_RegisterEffect("effects/blaster/wall_impact.efx");
+		trap_FX_RegisterEffect("effects/blaster/flesh_impact.efx");
+		break;
+
+	 default:
+		MAKERGB( weaponInfo->flashDlightColor, 1, 1, 1 );
+		weaponInfo->flashSound[0] = trap_S_RegisterSound( "sound/weapons/rocket/rocklf1a.wav" );
+		break;
+	}
+}
diff --git a/codemp/cgame/cg_weapons.c b/codemp/cgame/cg_weapons.c
new file mode 100644
index 0000000..b8d532a
--- /dev/null
+++ b/codemp/cgame/cg_weapons.c
@@ -0,0 +1,2582 @@
+// Copyright (C) 1999-2000 Id Software, Inc.
+//
+// cg_weapons.c -- events and effects dealing with weapons
+#include "cg_local.h"
+#include "fx_local.h"
+
+extern vec4_t	bluehudtint;
+extern vec4_t	redhudtint;
+extern float	*hudTintColor;
+
+/*
+Ghoul2 Insert Start
+*/
+// set up the appropriate ghoul2 info to a refent
+void CG_SetGhoul2InfoRef( refEntity_t *ent, refEntity_t	*s1)
+{
+	ent->ghoul2 = s1->ghoul2;
+	VectorCopy( s1->modelScale, ent->modelScale);
+	ent->radius = s1->radius;
+	VectorCopy( s1->angles, ent->angles);
+}
+
+/*
+Ghoul2 Insert End
+*/
+
+/*
+=================
+CG_RegisterItemVisuals
+
+The server says this item is used on this level
+=================
+*/
+void CG_RegisterItemVisuals( int itemNum ) {
+	itemInfo_t		*itemInfo;
+	gitem_t			*item;
+	int				handle;
+
+	if ( itemNum < 0 || itemNum >= bg_numItems ) {
+		CG_Error( "CG_RegisterItemVisuals: itemNum %d out of range [0-%d]", itemNum, bg_numItems-1 );
+	}
+
+	itemInfo = &cg_items[ itemNum ];
+	if ( itemInfo->registered ) {
+		return;
+	}
+
+	item = &bg_itemlist[ itemNum ];
+
+	memset( itemInfo, 0, sizeof( &itemInfo ) );
+	itemInfo->registered = qtrue;
+
+	if (item->giType == IT_TEAM &&
+		(item->giTag == PW_REDFLAG || item->giTag == PW_BLUEFLAG) &&
+		cgs.gametype == GT_CTY)
+	{ //in CTY the flag model is different
+		itemInfo->models[0] = trap_R_RegisterModel( item->world_model[1] );
+	}
+	else if (item->giType == IT_WEAPON &&
+		(item->giTag == WP_THERMAL || item->giTag == WP_TRIP_MINE || item->giTag == WP_DET_PACK))
+	{
+		itemInfo->models[0] = trap_R_RegisterModel( item->world_model[1] );
+	}
+	else
+	{
+		itemInfo->models[0] = trap_R_RegisterModel( item->world_model[0] );
+	}
+/*
+Ghoul2 Insert Start
+*/
+	if (!Q_stricmp(&item->world_model[0][strlen(item->world_model[0]) - 4], ".glm"))
+	{
+		handle = trap_G2API_InitGhoul2Model(&itemInfo->g2Models[0], item->world_model[0], 0 , 0, 0, 0, 0);
+		if (handle<0)
+		{
+			itemInfo->g2Models[0] = NULL;
+		}
+		else
+		{
+			itemInfo->radius[0] = 60;
+		}
+	}
+/*
+Ghoul2 Insert End
+*/
+	if (item->icon)
+	{
+		if (item->giType == IT_HEALTH)
+		{ //medpack gets nomip'd by the ui or something I guess.
+			itemInfo->icon = trap_R_RegisterShaderNoMip( item->icon );
+		}
+		else
+		{
+			itemInfo->icon = trap_R_RegisterShader( item->icon );
+		}
+	}
+	else
+	{
+		itemInfo->icon = 0;
+	}
+
+	if ( item->giType == IT_WEAPON ) {
+		CG_RegisterWeapon( item->giTag );
+	}
+
+	//
+	// powerups have an accompanying ring or sphere
+	//
+	if ( item->giType == IT_POWERUP || item->giType == IT_HEALTH || 
+		item->giType == IT_ARMOR || item->giType == IT_HOLDABLE ) {
+		if ( item->world_model[1] ) {
+			itemInfo->models[1] = trap_R_RegisterModel( item->world_model[1] );
+		}
+	}
+}
+
+
+/*
+========================================================================================
+
+VIEW WEAPON
+
+========================================================================================
+*/
+
+#define WEAPON_FORCE_BUSY_HOLSTER
+
+#ifdef WEAPON_FORCE_BUSY_HOLSTER
+//rww - this was done as a last resort. Forgive me.
+static int cgWeapFrame = 0;
+static int cgWeapFrameTime = 0;
+#endif
+
+/*
+=================
+CG_MapTorsoToWeaponFrame
+
+=================
+*/
+static int CG_MapTorsoToWeaponFrame( clientInfo_t *ci, int frame, int animNum ) {
+	animation_t *animations = bgHumanoidAnimations;
+#ifdef WEAPON_FORCE_BUSY_HOLSTER
+	if (cg.snap->ps.forceHandExtend != HANDEXTEND_NONE || cgWeapFrameTime > cg.time)
+	{ //the reason for the after delay is so that it doesn't snap the weapon frame to the "idle" (0) frame
+		//for a very quick moment
+		if (cgWeapFrame < 6)
+		{
+			cgWeapFrame = 6;
+			cgWeapFrameTime = cg.time + 10;
+		}
+
+		if (cgWeapFrameTime < cg.time && cgWeapFrame < 10)
+		{
+			cgWeapFrame++;
+			cgWeapFrameTime = cg.time + 10;
+		}
+
+		if (cg.snap->ps.forceHandExtend != HANDEXTEND_NONE &&
+			cgWeapFrame == 10)
+		{
+			cgWeapFrameTime = cg.time + 100;
+		}
+
+		return cgWeapFrame;
+	}
+	else
+	{
+		cgWeapFrame = 0;
+		cgWeapFrameTime = 0;
+	}
+#endif
+
+	switch( animNum )
+	{
+	case TORSO_DROPWEAP1:
+		if ( frame >= animations[animNum].firstFrame && frame < animations[animNum].firstFrame + 5 ) 
+		{
+			return frame - animations[animNum].firstFrame + 6;
+		}
+		break;
+
+	case TORSO_RAISEWEAP1:
+		if ( frame >= animations[animNum].firstFrame && frame < animations[animNum].firstFrame + 4 ) 
+		{
+			return frame - animations[animNum].firstFrame + 6 + 4;
+		}
+		break;
+	case BOTH_ATTACK1:
+	case BOTH_ATTACK2:
+	case BOTH_ATTACK3:
+	case BOTH_ATTACK4:
+	case BOTH_ATTACK10:
+	case BOTH_THERMAL_THROW:
+		if ( frame >= animations[animNum].firstFrame && frame < animations[animNum].firstFrame + 6 ) 
+		{
+			return 1 + ( frame - animations[animNum].firstFrame );
+		}
+
+		break;
+	}	
+	return -1;
+}
+
+
+/*
+==============
+CG_CalculateWeaponPosition
+==============
+*/
+static void CG_CalculateWeaponPosition( vec3_t origin, vec3_t angles ) {
+	float	scale;
+	int		delta;
+	float	fracsin;
+
+	VectorCopy( cg.refdef.vieworg, origin );
+	VectorCopy( cg.refdef.viewangles, angles );
+
+	// on odd legs, invert some angles
+	if ( cg.bobcycle & 1 ) {
+		scale = -cg.xyspeed;
+	} else {
+		scale = cg.xyspeed;
+	}
+
+	// gun angles from bobbing
+	angles[ROLL] += scale * cg.bobfracsin * 0.005;
+	angles[YAW] += scale * cg.bobfracsin * 0.01;
+	angles[PITCH] += cg.xyspeed * cg.bobfracsin * 0.005;
+
+	// drop the weapon when landing
+	delta = cg.time - cg.landTime;
+	if ( delta < LAND_DEFLECT_TIME ) {
+		origin[2] += cg.landChange*0.25 * delta / LAND_DEFLECT_TIME;
+	} else if ( delta < LAND_DEFLECT_TIME + LAND_RETURN_TIME ) {
+		origin[2] += cg.landChange*0.25 * 
+			(LAND_DEFLECT_TIME + LAND_RETURN_TIME - delta) / LAND_RETURN_TIME;
+	}
+
+#if 0
+	// drop the weapon when stair climbing
+	delta = cg.time - cg.stepTime;
+	if ( delta < STEP_TIME/2 ) {
+		origin[2] -= cg.stepChange*0.25 * delta / (STEP_TIME/2);
+	} else if ( delta < STEP_TIME ) {
+		origin[2] -= cg.stepChange*0.25 * (STEP_TIME - delta) / (STEP_TIME/2);
+	}
+#endif
+
+	// idle drift
+	scale = cg.xyspeed + 40;
+	fracsin = sin( cg.time * 0.001 );
+	angles[ROLL] += scale * fracsin * 0.01;
+	angles[YAW] += scale * fracsin * 0.01;
+	angles[PITCH] += scale * fracsin * 0.01;
+}
+
+
+/*
+===============
+CG_LightningBolt
+
+Origin will be the exact tag point, which is slightly
+different than the muzzle point used for determining hits.
+The cent should be the non-predicted cent if it is from the player,
+so the endpoint will reflect the simulated strike (lagging the predicted
+angle)
+===============
+*/
+static void CG_LightningBolt( centity_t *cent, vec3_t origin ) {
+//	trace_t  trace;
+	refEntity_t  beam;
+//	vec3_t   forward;
+//	vec3_t   muzzlePoint, endPoint;
+
+	//Must be a durational weapon that continuously generates an effect.
+	if ( cent->currentState.weapon == WP_DEMP2 && cent->currentState.eFlags & EF_ALT_FIRING ) 
+	{ /*nothing*/ }
+	else
+	{
+		return;
+	}
+
+	memset( &beam, 0, sizeof( beam ) );
+
+	// NOTENOTE No lightning gun-ish stuff yet.
+/*
+	// CPMA  "true" lightning
+	if ((cent->currentState.number == cg.predictedPlayerState.clientNum) && (cg_trueLightning.value != 0)) {
+		vec3_t angle;
+		int i;
+
+		for (i = 0; i < 3; i++) {
+			float a = cent->lerpAngles[i] - cg.refdef.viewangles[i];
+			if (a > 180) {
+				a -= 360;
+			}
+			if (a < -180) {
+				a += 360;
+			}
+
+			angle[i] = cg.refdef.viewangles[i] + a * (1.0 - cg_trueLightning.value);
+			if (angle[i] < 0) {
+				angle[i] += 360;
+			}
+			if (angle[i] > 360) {
+				angle[i] -= 360;
+			}
+		}
+
+		AngleVectors(angle, forward, NULL, NULL );
+		VectorCopy(cent->lerpOrigin, muzzlePoint );
+//		VectorCopy(cg.refdef.vieworg, muzzlePoint );
+	} else {
+		// !CPMA
+		AngleVectors( cent->lerpAngles, forward, NULL, NULL );
+		VectorCopy(cent->lerpOrigin, muzzlePoint );
+	}
+
+	// FIXME: crouch
+	muzzlePoint[2] += DEFAULT_VIEWHEIGHT;
+
+	VectorMA( muzzlePoint, 14, forward, muzzlePoint );
+
+	// project forward by the lightning range
+	VectorMA( muzzlePoint, LIGHTNING_RANGE, forward, endPoint );
+
+	// see if it hit a wall
+	CG_Trace( &trace, muzzlePoint, vec3_origin, vec3_origin, endPoint, 
+		cent->currentState.number, MASK_SHOT );
+
+	// this is the endpoint
+	VectorCopy( trace.endpos, beam.oldorigin );
+
+	// use the provided origin, even though it may be slightly
+	// different than the muzzle origin
+	VectorCopy( origin, beam.origin );
+
+	beam.reType = RT_LIGHTNING;
+	beam.customShader = cgs.media.lightningShader;
+	trap_R_AddRefEntityToScene( &beam );
+*/
+
+	// NOTENOTE No lightning gun-ish stuff yet.
+/*
+	// add the impact flare if it hit something
+	if ( trace.fraction < 1.0 ) {
+		vec3_t	angles;
+		vec3_t	dir;
+
+		VectorSubtract( beam.oldorigin, beam.origin, dir );
+		VectorNormalize( dir );
+
+		memset( &beam, 0, sizeof( beam ) );
+		beam.hModel = cgs.media.lightningExplosionModel;
+
+		VectorMA( trace.endpos, -16, dir, beam.origin );
+
+		// make a random orientation
+		angles[0] = rand() % 360;
+		angles[1] = rand() % 360;
+		angles[2] = rand() % 360;
+		AnglesToAxis( angles, beam.axis );
+		trap_R_AddRefEntityToScene( &beam );
+	}
+*/
+}
+
+
+/*
+========================
+CG_AddWeaponWithPowerups
+========================
+*/
+static void CG_AddWeaponWithPowerups( refEntity_t *gun, int powerups ) {
+	// add powerup effects
+	trap_R_AddRefEntityToScene( gun );
+
+	if (cg.predictedPlayerState.electrifyTime > cg.time)
+	{ //add electrocution shell
+		int preShader = gun->customShader;
+		if ( rand() & 1 )
+		{
+			gun->customShader = cgs.media.electricBodyShader;	
+		}
+		else
+		{
+			gun->customShader = cgs.media.electricBody2Shader;
+		}
+		trap_R_AddRefEntityToScene( gun );
+		gun->customShader = preShader; //set back just to be safe
+	}
+}
+
+
+/*
+=============
+CG_AddPlayerWeapon
+
+Used for both the view weapon (ps is valid) and the world modelother character models (ps is NULL)
+The main player will have this called for BOTH cases, so effects like light and
+sound should only be done on the world model case.
+=============
+*/
+void CG_AddPlayerWeapon( refEntity_t *parent, playerState_t *ps, centity_t *cent, int team, vec3_t newAngles, qboolean thirdPerson ) {
+	refEntity_t	gun;
+	refEntity_t	barrel;
+	vec3_t		angles;
+	weapon_t	weaponNum;
+	weaponInfo_t	*weapon;
+	centity_t	*nonPredictedCent;
+	refEntity_t	flash;
+
+	weaponNum = cent->currentState.weapon;
+
+	if (cent->currentState.weapon == WP_EMPLACED_GUN)
+	{
+		return;
+	}
+
+	if (cg.predictedPlayerState.pm_type == PM_SPECTATOR &&
+		cent->currentState.number == cg.predictedPlayerState.clientNum)
+	{ //spectator mode, don't draw it...
+		return;
+	}
+
+	CG_RegisterWeapon( weaponNum );
+	weapon = &cg_weapons[weaponNum];
+/*
+Ghoul2 Insert Start
+*/
+
+	memset( &gun, 0, sizeof( gun ) );
+
+	// only do this if we are in first person, since world weapons are now handled on the server by Ghoul2
+	if (!thirdPerson)
+	{
+
+		// add the weapon
+		VectorCopy( parent->lightingOrigin, gun.lightingOrigin );
+		gun.shadowPlane = parent->shadowPlane;
+		gun.renderfx = parent->renderfx;
+
+		if (ps)
+		{	// this player, in first person view
+			gun.hModel = weapon->viewModel;
+		}
+		else
+		{
+			gun.hModel = weapon->weaponModel;
+		}
+		if (!gun.hModel) {
+			return;
+		}
+
+		if ( !ps ) {
+			// add weapon ready sound
+			cent->pe.lightningFiring = qfalse;
+			if ( ( cent->currentState.eFlags & EF_FIRING ) && weapon->firingSound ) {
+				// lightning gun and guantlet make a different sound when fire is held down
+				trap_S_AddLoopingSound( cent->currentState.number, cent->lerpOrigin, vec3_origin, weapon->firingSound );
+				cent->pe.lightningFiring = qtrue;
+			} else if ( weapon->readySound ) {
+				trap_S_AddLoopingSound( cent->currentState.number, cent->lerpOrigin, vec3_origin, weapon->readySound );
+			}
+		}
+	
+		CG_PositionEntityOnTag( &gun, parent, parent->hModel, "tag_weapon");
+
+		if (!CG_IsMindTricked(cent->currentState.trickedentindex,
+			cent->currentState.trickedentindex2,
+			cent->currentState.trickedentindex3,
+			cent->currentState.trickedentindex4,
+			cg.snap->ps.clientNum))
+		{
+			CG_AddWeaponWithPowerups( &gun, cent->currentState.powerups ); //don't draw the weapon if the player is invisible
+			/*
+			if ( weaponNum == WP_STUN_BATON )
+			{
+				gun.shaderRGBA[0] = gun.shaderRGBA[1] = gun.shaderRGBA[2] = 25;
+	
+				gun.customShader = trap_R_RegisterShader( "gfx/effects/stunPass" );
+				gun.renderfx = RF_RGB_TINT | RF_FIRST_PERSON | RF_DEPTHHACK;
+				trap_R_AddRefEntityToScene( &gun );
+			}
+			*/
+		}
+
+		if (weaponNum == WP_STUN_BATON)
+		{
+			int i = 0;
+
+			while (i < 3)
+			{
+				memset( &barrel, 0, sizeof( barrel ) );
+				VectorCopy( parent->lightingOrigin, barrel.lightingOrigin );
+				barrel.shadowPlane = parent->shadowPlane;
+				barrel.renderfx = parent->renderfx;
+
+				if (i == 0)
+				{
+					barrel.hModel = trap_R_RegisterModel("models/weapons2/stun_baton/baton_barrel.md3");
+				}
+				else if (i == 1)
+				{
+					barrel.hModel = trap_R_RegisterModel("models/weapons2/stun_baton/baton_barrel2.md3");
+				}
+				else
+				{
+					barrel.hModel = trap_R_RegisterModel("models/weapons2/stun_baton/baton_barrel3.md3");
+				}
+				angles[YAW] = 0;
+				angles[PITCH] = 0;
+				angles[ROLL] = 0;
+
+				AnglesToAxis( angles, barrel.axis );
+
+				if (i == 0)
+				{
+					CG_PositionRotatedEntityOnTag( &barrel, parent/*&gun*/, /*weapon->weaponModel*/weapon->handsModel, "tag_barrel" );
+				}
+				else if (i == 1)
+				{
+					CG_PositionRotatedEntityOnTag( &barrel, parent/*&gun*/, /*weapon->weaponModel*/weapon->handsModel, "tag_barrel2" );
+				}
+				else
+				{
+					CG_PositionRotatedEntityOnTag( &barrel, parent/*&gun*/, /*weapon->weaponModel*/weapon->handsModel, "tag_barrel3" );
+				}
+				CG_AddWeaponWithPowerups( &barrel, cent->currentState.powerups );
+
+				i++;
+			}
+		}
+		else
+		{
+			// add the spinning barrel
+			if ( weapon->barrelModel ) {
+				memset( &barrel, 0, sizeof( barrel ) );
+				VectorCopy( parent->lightingOrigin, barrel.lightingOrigin );
+				barrel.shadowPlane = parent->shadowPlane;
+				barrel.renderfx = parent->renderfx;
+
+				barrel.hModel = weapon->barrelModel;
+				angles[YAW] = 0;
+				angles[PITCH] = 0;
+				angles[ROLL] = 0;
+
+				AnglesToAxis( angles, barrel.axis );
+
+				CG_PositionRotatedEntityOnTag( &barrel, parent/*&gun*/, /*weapon->weaponModel*/weapon->handsModel, "tag_barrel" );
+
+				CG_AddWeaponWithPowerups( &barrel, cent->currentState.powerups );
+			}
+		}
+	}
+/*
+Ghoul2 Insert End
+*/
+
+	memset (&flash, 0, sizeof(flash));
+	CG_PositionEntityOnTag( &flash, &gun, gun.hModel, "tag_flash");
+
+	VectorCopy(flash.origin, cg.lastFPFlashPoint);
+
+	// Do special charge bits
+	//-----------------------
+	if ( (ps || cg.renderingThirdPerson || cg.predictedPlayerState.clientNum != cent->currentState.number) &&
+		( ( cent->currentState.modelindex2 == WEAPON_CHARGING_ALT && cent->currentState.weapon == WP_BRYAR_PISTOL ) ||
+		  ( cent->currentState.modelindex2 == WEAPON_CHARGING_ALT && cent->currentState.weapon == WP_BRYAR_OLD ) ||
+		  ( cent->currentState.weapon == WP_BOWCASTER && cent->currentState.modelindex2 == WEAPON_CHARGING ) ||
+		  ( cent->currentState.weapon == WP_DEMP2 && cent->currentState.modelindex2 == WEAPON_CHARGING_ALT) ) )
+	{
+		int		shader = 0;
+		float	val = 0.0f;
+		float	scale = 1.0f;
+		addspriteArgStruct_t fxSArgs;
+		vec3_t flashorigin, flashdir;
+
+		if (!thirdPerson)
+		{
+			VectorCopy(flash.origin, flashorigin);
+			VectorCopy(flash.axis[0], flashdir);
+		}
+		else
+		{
+			mdxaBone_t 		boltMatrix;
+
+			if (!trap_G2API_HasGhoul2ModelOnIndex(&(cent->ghoul2), 1))
+			{ //it's quite possible that we may have have no weapon model and be in a valid state, so return here if this is the case
+				return;
+			}
+
+			// go away and get me the bolt position for this frame please
+ 			if (!(trap_G2API_GetBoltMatrix(cent->ghoul2, 1, 0, &boltMatrix, newAngles, cent->lerpOrigin, cg.time, cgs.gameModels, cent->modelScale)))
+			{	// Couldn't find bolt point.
+				return;
+			}
+			
+			BG_GiveMeVectorFromMatrix(&boltMatrix, ORIGIN, flashorigin);
+			BG_GiveMeVectorFromMatrix(&boltMatrix, POSITIVE_X, flashdir);
+		}
+
+		if ( cent->currentState.weapon == WP_BRYAR_PISTOL ||
+			cent->currentState.weapon == WP_BRYAR_OLD)
+		{
+			// Hardcoded max charge time of 1 second
+			val = ( cg.time - cent->currentState.constantLight ) * 0.001f;
+			shader = cgs.media.bryarFrontFlash;
+		}
+		else if ( cent->currentState.weapon == WP_BOWCASTER )
+		{
+			// Hardcoded max charge time of 1 second
+			val = ( cg.time - cent->currentState.constantLight ) * 0.001f;
+			shader = cgs.media.greenFrontFlash;
+		}
+		else if ( cent->currentState.weapon == WP_DEMP2 )
+		{
+			val = ( cg.time - cent->currentState.constantLight ) * 0.001f;
+			shader = cgs.media.lightningFlash;
+			scale = 1.75f;
+		}
+
+		if ( val < 0.0f )
+		{
+			val = 0.0f;
+		}
+		else if ( val > 1.0f )
+		{
+			val = 1.0f;
+			if (ps && cent->currentState.number == ps->clientNum)
+			{
+				CGCam_Shake( /*0.1f*/0.2f, 100 );
+			}
+		}
+		else
+		{
+			if (ps && cent->currentState.number == ps->clientNum)
+			{
+				CGCam_Shake( val * val * /*0.3f*/0.6f, 100 );
+			}
+		}
+
+		val += random() * 0.5f;
+
+		VectorCopy(flashorigin, fxSArgs.origin);
+		VectorClear(fxSArgs.vel);
+		VectorClear(fxSArgs.accel);
+		fxSArgs.scale = 3.0f*val*scale;
+		fxSArgs.dscale = 0.0f;
+		fxSArgs.sAlpha = 0.7f;
+		fxSArgs.eAlpha = 0.7f;
+		fxSArgs.rotation = random()*360;
+		fxSArgs.bounce = 0.0f;
+		fxSArgs.life = 1.0f;
+		fxSArgs.shader = shader;
+		fxSArgs.flags = 0x08000000;
+
+		//FX_AddSprite( flash.origin, NULL, NULL, 3.0f * val, 0.0f, 0.7f, 0.7f, WHITE, WHITE, random() * 360, 0.0f, 1.0f, shader, FX_USE_ALPHA );
+		trap_FX_AddSprite(&fxSArgs);
+	}
+
+	// make sure we aren't looking at cg.predictedPlayerEntity for LG
+	nonPredictedCent = &cg_entities[cent->currentState.clientNum];
+
+	// if the index of the nonPredictedCent is not the same as the clientNum
+	// then this is a fake player (like on teh single player podiums), so
+	// go ahead and use the cent
+	if( ( nonPredictedCent - cg_entities ) != cent->currentState.clientNum ) {
+		nonPredictedCent = cent;
+	}
+
+	// add the flash
+	if ( ( weaponNum == WP_DEMP2)
+		&& ( nonPredictedCent->currentState.eFlags & EF_FIRING ) ) 
+	{
+		// continuous flash
+	} else {
+		// impulse flash
+		if ( cg.time - cent->muzzleFlashTime > MUZZLE_FLASH_TIME) {
+			return;
+		}
+	}
+
+	if ( ps || cg.renderingThirdPerson ||
+			cent->currentState.number != cg.predictedPlayerState.clientNum ) 
+	{	// Make sure we don't do the thirdperson model effects for the local player if we're in first person
+		vec3_t flashorigin, flashdir;
+		refEntity_t	flash;
+
+		memset (&flash, 0, sizeof(flash));
+
+		if (!thirdPerson)
+		{
+			CG_PositionEntityOnTag( &flash, &gun, gun.hModel, "tag_flash");
+			VectorCopy(flash.origin, flashorigin);
+			VectorCopy(flash.axis[0], flashdir);
+		}
+		else
+		{
+			mdxaBone_t 		boltMatrix;
+
+			if (!trap_G2API_HasGhoul2ModelOnIndex(&(cent->ghoul2), 1))
+			{ //it's quite possible that we may have have no weapon model and be in a valid state, so return here if this is the case
+				return;
+			}
+
+			// go away and get me the bolt position for this frame please
+ 			if (!(trap_G2API_GetBoltMatrix(cent->ghoul2, 1, 0, &boltMatrix, newAngles, cent->lerpOrigin, cg.time, cgs.gameModels, cent->modelScale)))
+			{	// Couldn't find bolt point.
+				return;
+			}
+			
+			BG_GiveMeVectorFromMatrix(&boltMatrix, ORIGIN, flashorigin);
+			BG_GiveMeVectorFromMatrix(&boltMatrix, POSITIVE_X, flashdir);
+		}
+
+		if ( cg.time - cent->muzzleFlashTime <= MUZZLE_FLASH_TIME + 10 )
+		{	// Handle muzzle flashes
+			if ( cent->currentState.eFlags & EF_ALT_FIRING )
+			{	// Check the alt firing first.
+				if (weapon->altMuzzleEffect)
+				{
+					if (!thirdPerson)
+					{
+						trap_FX_PlayEntityEffectID(weapon->altMuzzleEffect, flashorigin, flash.axis, -1, -1, -1, -1  );
+					}
+					else
+					{
+						trap_FX_PlayEffectID(weapon->altMuzzleEffect, flashorigin, flashdir, -1, -1);
+					}
+				}
+			}
+			else
+			{	// Regular firing
+				if (weapon->muzzleEffect)
+				{
+					if (!thirdPerson)
+					{
+						trap_FX_PlayEntityEffectID(weapon->muzzleEffect, flashorigin, flash.axis, -1, -1, -1, -1  );
+					}
+					else
+					{
+						trap_FX_PlayEffectID(weapon->muzzleEffect, flashorigin, flashdir, -1, -1);
+					}
+				}
+			}
+		}
+
+		// add lightning bolt
+		CG_LightningBolt( nonPredictedCent, flashorigin );
+
+		if ( weapon->flashDlightColor[0] || weapon->flashDlightColor[1] || weapon->flashDlightColor[2] ) {
+			trap_R_AddLightToScene( flashorigin, 300 + (rand()&31), weapon->flashDlightColor[0],
+				weapon->flashDlightColor[1], weapon->flashDlightColor[2] );
+		}
+	}
+}
+
+/*
+==============
+CG_AddViewWeapon
+
+Add the weapon, and flash for the player's view
+==============
+*/
+void CG_AddViewWeapon( playerState_t *ps ) {
+	refEntity_t	hand;
+	centity_t	*cent;
+	clientInfo_t	*ci;
+	float		fovOffset;
+	vec3_t		angles;
+	weaponInfo_t	*weapon;
+	float	cgFov = cg_fov.value;
+
+	if (cgFov < 1)
+	{
+		cgFov = 1;
+	}
+	if (cgFov > 97)
+	{
+		cgFov = 97;
+	}
+
+	if ( ps->persistant[PERS_TEAM] == TEAM_SPECTATOR ) {
+		return;
+	}
+
+	if ( ps->pm_type == PM_INTERMISSION ) {
+		return;
+	}
+
+	// no gun if in third person view or a camera is active
+	//if ( cg.renderingThirdPerson || cg.cameraMode) {
+	if ( cg.renderingThirdPerson ) {
+		return;
+	}
+
+	// allow the gun to be completely removed
+	if ( !cg_drawGun.integer || cg.predictedPlayerState.zoomMode) {
+		vec3_t		origin;
+
+		if ( cg.predictedPlayerState.eFlags & EF_FIRING ) {
+			// special hack for lightning gun...
+			VectorCopy( cg.refdef.vieworg, origin );
+			VectorMA( origin, -8, cg.refdef.viewaxis[2], origin );
+			CG_LightningBolt( &cg_entities[ps->clientNum], origin );
+		}
+		return;
+	}
+
+	// don't draw if testing a gun model
+	if ( cg.testGun ) {
+		return;
+	}
+
+	// drop gun lower at higher fov
+	if ( cgFov > 90 ) {
+		fovOffset = -0.2 * ( cgFov - 90 );
+	} else {
+		fovOffset = 0;
+	}
+
+	cent = &cg_entities[cg.predictedPlayerState.clientNum];
+	CG_RegisterWeapon( ps->weapon );
+	weapon = &cg_weapons[ ps->weapon ];
+
+	memset (&hand, 0, sizeof(hand));
+
+	// set up gun position
+	CG_CalculateWeaponPosition( hand.origin, angles );
+
+	VectorMA( hand.origin, cg_gun_x.value, cg.refdef.viewaxis[0], hand.origin );
+	VectorMA( hand.origin, cg_gun_y.value, cg.refdef.viewaxis[1], hand.origin );
+	VectorMA( hand.origin, (cg_gun_z.value+fovOffset), cg.refdef.viewaxis[2], hand.origin );
+
+	AnglesToAxis( angles, hand.axis );
+
+	// map torso animations to weapon animations
+	if ( cg_gun_frame.integer ) {
+		// development tool
+		hand.frame = hand.oldframe = cg_gun_frame.integer;
+		hand.backlerp = 0;
+	} else {
+		// get clientinfo for animation map
+		if (cent->currentState.eType == ET_NPC)
+		{
+			if (!cent->npcClient)
+			{
+				return;
+			}
+
+			ci = cent->npcClient;
+		}
+		else
+		{
+			ci = &cgs.clientinfo[ cent->currentState.clientNum ];
+		}
+		hand.frame = CG_MapTorsoToWeaponFrame( ci, cent->pe.torso.frame, cent->currentState.torsoAnim );
+		hand.oldframe = CG_MapTorsoToWeaponFrame( ci, cent->pe.torso.oldFrame, cent->currentState.torsoAnim );
+		hand.backlerp = cent->pe.torso.backlerp;
+
+		// Handle the fringe situation where oldframe is invalid
+		if ( hand.frame == -1 )
+		{
+			hand.frame = 0;
+			hand.oldframe = 0;
+			hand.backlerp = 0;
+		}
+		else if ( hand.oldframe == -1 )
+		{
+			hand.oldframe = hand.frame;
+			hand.backlerp = 0;
+		}
+	}
+
+	hand.hModel = weapon->handsModel;
+	hand.renderfx = RF_DEPTHHACK | RF_FIRST_PERSON;// | RF_MINLIGHT;
+
+	// add everything onto the hand
+	CG_AddPlayerWeapon( &hand, ps, &cg_entities[cg.predictedPlayerState.clientNum], ps->persistant[PERS_TEAM], angles, qfalse );
+}
+
+/*
+==============================================================================
+
+WEAPON SELECTION
+
+==============================================================================
+*/
+#define ICON_WEAPONS	0
+#define ICON_FORCE		1
+#define ICON_INVENTORY	2
+
+
+void CG_DrawIconBackground(void)
+{
+	int				height,xAdd,x2,y2,t;
+//	int				prongLeftX,prongRightX;
+	float			inTime = cg.invenSelectTime+WEAPON_SELECT_TIME;
+	float			wpTime = cg.weaponSelectTime+WEAPON_SELECT_TIME;
+	float			fpTime = cg.forceSelectTime+WEAPON_SELECT_TIME;
+//	int				drawType = cgs.media.weaponIconBackground;
+//	int				yOffset = 0;
+
+#ifdef _XBOX
+	//yOffset = -50;
+#endif
+
+	// don't display if dead
+	if ( cg.snap->ps.stats[STAT_HEALTH] <= 0 ) 
+	{
+		return;
+	}
+
+	if (cg_hudFiles.integer)
+	{ //simple hud
+		return;
+	}
+
+	x2 = 30;
+	y2 = SCREEN_HEIGHT-70;
+
+	//prongLeftX =x2+37; 
+	//prongRightX =x2+544; 
+
+	if (inTime > wpTime)
+	{
+//		drawType = cgs.media.inventoryIconBackground;
+		cg.iconSelectTime = cg.invenSelectTime;
+	}
+	else
+	{
+//		drawType = cgs.media.weaponIconBackground;
+		cg.iconSelectTime = cg.weaponSelectTime;
+	}
+
+	if (fpTime > inTime && fpTime > wpTime)
+	{
+//		drawType = cgs.media.forceIconBackground;
+		cg.iconSelectTime = cg.forceSelectTime;
+	}
+
+	if ((cg.iconSelectTime+WEAPON_SELECT_TIME)<cg.time)	// Time is up for the HUD to display
+	{
+		if (cg.iconHUDActive)		// The time is up, but we still need to move the prongs back to their original position
+		{
+			t =  cg.time - (cg.iconSelectTime+WEAPON_SELECT_TIME);
+			cg.iconHUDPercent = t/ 130.0f;
+			cg.iconHUDPercent = 1 - cg.iconHUDPercent;
+
+			if (cg.iconHUDPercent<0)
+			{
+				cg.iconHUDActive = qfalse;
+				cg.iconHUDPercent=0;
+			}
+
+			xAdd = (int) 8*cg.iconHUDPercent;
+
+			height = (int) (60.0f*cg.iconHUDPercent);
+			//CG_DrawPic( x2+60, y2+30+yOffset, 460, -height, drawType);	// Top half
+			//CG_DrawPic( x2+60, y2+30-2+yOffset, 460, height, drawType);	// Bottom half
+
+		}
+		else
+		{
+			xAdd = 0;
+		}
+
+		return;
+	}
+	//prongLeftX =x2+37; 
+	//prongRightX =x2+544; 
+
+	if (!cg.iconHUDActive)
+	{
+		t = cg.time - cg.iconSelectTime;
+		cg.iconHUDPercent = t/ 130.0f;
+
+		// Calc how far into opening sequence we are
+		if (cg.iconHUDPercent>1)
+		{
+			cg.iconHUDActive = qtrue;
+			cg.iconHUDPercent=1;
+		}
+		else if (cg.iconHUDPercent<0)
+		{
+			cg.iconHUDPercent=0;
+		}
+	}
+	else
+	{
+		cg.iconHUDPercent=1;
+	}
+
+	//trap_R_SetColor( colorTable[CT_WHITE] );					
+	//height = (int) (60.0f*cg.iconHUDPercent);
+	//CG_DrawPic( x2+60, y2+30+yOffset, 460, -height, drawType);	// Top half
+	//CG_DrawPic( x2+60, y2+30-2+yOffset, 460, height, drawType);	// Bottom half
+
+	// And now for the prongs
+/*	if ((cg.inventorySelectTime+WEAPON_SELECT_TIME)>cg.time)	
+	{
+		cgs.media.currentBackground = ICON_INVENTORY;
+		background = &cgs.media.inventoryProngsOn;
+	}
+	else if ((cg.weaponSelectTime+WEAPON_SELECT_TIME)>cg.time)	
+	{
+		cgs.media.currentBackground = ICON_WEAPONS;
+	}
+	else 
+	{
+		cgs.media.currentBackground = ICON_FORCE;
+		background = &cgs.media.forceProngsOn;
+	}
+*/
+	// Side Prongs
+//	trap_R_SetColor( colorTable[CT_WHITE]);					
+//	xAdd = (int) 8*cg.iconHUDPercent;
+//	CG_DrawPic( prongLeftX+xAdd, y2-10, 40, 80, background);
+//	CG_DrawPic( prongRightX-xAdd, y2-10, -40, 80, background);
+
+}
+
+qboolean CG_WeaponCheck(int weap)
+{
+	if (cg.snap->ps.ammo[weaponData[weap].ammoIndex] < weaponData[weap].energyPerShot &&
+		cg.snap->ps.ammo[weaponData[weap].ammoIndex] < weaponData[weap].altEnergyPerShot)
+	{
+		return qfalse;
+	}
+
+	return qtrue;
+}
+
+/*
+===============
+CG_WeaponSelectable
+===============
+*/
+static qboolean CG_WeaponSelectable( int i ) {
+	/*if ( !cg.snap->ps.ammo[weaponData[i].ammoIndex] ) {
+		return qfalse;
+	}*/
+	if (!i)
+	{
+		return qfalse;
+	}
+
+	if (cg.predictedPlayerState.ammo[weaponData[i].ammoIndex] < weaponData[i].energyPerShot &&
+		cg.predictedPlayerState.ammo[weaponData[i].ammoIndex] < weaponData[i].altEnergyPerShot)
+	{
+		return qfalse;
+	}
+
+	if (i == WP_DET_PACK && cg.predictedPlayerState.ammo[weaponData[i].ammoIndex] < 1 &&
+		!cg.predictedPlayerState.hasDetPackPlanted)
+	{
+		return qfalse;
+	}
+
+	if ( ! (cg.predictedPlayerState.stats[ STAT_WEAPONS ] & ( 1 << i ) ) ) {
+		return qfalse;
+	}
+
+	return qtrue;
+}
+
+/*
+===================
+CG_DrawWeaponSelect
+===================
+*/
+#ifdef _XBOX
+extern bool CL_ExtendSelectTime(void);
+#endif
+void CG_DrawWeaponSelect( void ) {
+	int				i;
+	int				bits;
+	int				count;
+	int				smallIconSize,bigIconSize;
+	int				holdX,x,y,pad;
+	int				sideLeftIconCnt,sideRightIconCnt;
+	int				sideMax,holdCount,iconCnt;
+	int				height;
+	int		yOffset = 0;
+	qboolean drewConc = qfalse;
+
+	if (cg.predictedPlayerState.emplacedIndex)
+	{ //can't cycle when on a weapon
+		cg.weaponSelectTime = 0;
+	}
+
+	if ((cg.weaponSelectTime+WEAPON_SELECT_TIME)<cg.time)	// Time is up for the HUD to display
+	{
+		return;
+	}
+
+	// don't display if dead
+	if ( cg.predictedPlayerState.stats[STAT_HEALTH] <= 0 ) 
+	{
+		return;
+	}
+
+#ifdef _XBOX
+	if(CL_ExtendSelectTime()) {
+		cg.weaponSelectTime = cg.time;
+	}
+
+	yOffset = -50;
+#endif
+
+	// showing weapon select clears pickup item display, but not the blend blob
+	cg.itemPickupTime = 0;
+
+	bits = cg.predictedPlayerState.stats[ STAT_WEAPONS ];
+
+	// count the number of weapons owned
+	count = 0;
+
+	if ( !CG_WeaponSelectable(cg.weaponSelect) &&
+		(cg.weaponSelect == WP_THERMAL || cg.weaponSelect == WP_TRIP_MINE) )
+	{ //display this weapon that we don't actually "have" as unhighlighted until it's deselected
+	  //since it's selected we must increase the count to display the proper number of valid selectable weapons
+		count++;
+	}
+
+	for ( i = 1 ; i < WP_NUM_WEAPONS ; i++ ) 
+	{
+		if ( bits & ( 1 << i ) ) 
+		{
+			if ( CG_WeaponSelectable(i) ||
+				(i != WP_THERMAL && i != WP_TRIP_MINE) )
+			{
+				count++;
+			}
+		}
+	}
+
+	if (count == 0)	// If no weapons, don't display
+	{
+		return;
+	}
+
+	sideMax = 3;	// Max number of icons on the side
+
+	// Calculate how many icons will appear to either side of the center one
+	holdCount = count - 1;	// -1 for the center icon
+	if (holdCount == 0)			// No icons to either side
+	{
+		sideLeftIconCnt = 0;
+		sideRightIconCnt = 0;
+	}
+	else if (count > (2*sideMax))	// Go to the max on each side
+	{
+		sideLeftIconCnt = sideMax;
+		sideRightIconCnt = sideMax;
+	}
+	else							// Less than max, so do the calc
+	{
+		sideLeftIconCnt = holdCount/2;
+		sideRightIconCnt = holdCount - sideLeftIconCnt;
+	}
+
+	if ( cg.weaponSelect == WP_CONCUSSION )
+	{
+		i = WP_FLECHETTE;
+	}
+	else
+	{
+		i = cg.weaponSelect - 1;
+	}
+	if (i<1)
+	{
+		i = LAST_USEABLE_WEAPON;
+	}
+
+	smallIconSize = 40;
+	bigIconSize = 80;
+	pad = 12;
+
+	x = 320;
+	y = 410;
+
+	// Background
+//	memcpy(calcColor, colorTable[CT_WHITE], sizeof(vec4_t));
+//	calcColor[3] = .35f;
+//	trap_R_SetColor( calcColor);					
+
+	// Left side ICONS
+	trap_R_SetColor(colorTable[CT_WHITE]);
+	// Work backwards from current icon
+	holdX = x - ((bigIconSize/2) + pad + smallIconSize);
+	height = smallIconSize * 1;//cg.iconHUDPercent;
+	drewConc = qfalse;
+
+	for (iconCnt=1;iconCnt<(sideLeftIconCnt+1);i--)
+	{
+		if ( i == WP_CONCUSSION )
+		{
+			i--;
+		}
+		else if ( i == WP_FLECHETTE && !drewConc && cg.weaponSelect != WP_CONCUSSION )
+		{
+			i = WP_CONCUSSION;
+		}
+		if (i<1)
+		{
+			//i = 13;
+			//...don't ever do this.
+			i = LAST_USEABLE_WEAPON;
+		}
+
+		if ( !(bits & ( 1 << i )))	// Does he have this weapon?
+		{
+			if ( i == WP_CONCUSSION )
+			{
+				drewConc = qtrue;
+				i = WP_ROCKET_LAUNCHER;
+			}
+			continue;
+		}
+
+		if ( !CG_WeaponSelectable(i) &&
+			(i == WP_THERMAL || i == WP_TRIP_MINE) )
+		{ //Don't show thermal and tripmine when out of them
+			continue;
+		}
+
+		++iconCnt;					// Good icon
+
+		if (cgs.media.weaponIcons[i])
+		{
+			weaponInfo_t	*weaponInfo;
+			CG_RegisterWeapon( i );	
+			weaponInfo = &cg_weapons[i];
+
+			trap_R_SetColor(colorTable[CT_WHITE]);
+			if (!CG_WeaponCheck(i))
+			{
+				CG_DrawPic( holdX, y+10+yOffset, smallIconSize, smallIconSize, /*weaponInfo->weaponIconNoAmmo*/cgs.media.weaponIcons_NA[i] );
+			}
+			else
+			{
+				CG_DrawPic( holdX, y+10+yOffset, smallIconSize, smallIconSize, /*weaponInfo->weaponIcon*/cgs.media.weaponIcons[i] );
+			}
+
+			holdX -= (smallIconSize+pad);
+		}
+		if ( i == WP_CONCUSSION )
+		{
+			drewConc = qtrue;
+			i = WP_ROCKET_LAUNCHER;
+		}
+	}
+
+	// Current Center Icon
+	height = bigIconSize * cg.iconHUDPercent;
+	if (cgs.media.weaponIcons[cg.weaponSelect])
+	{
+		weaponInfo_t	*weaponInfo;
+		CG_RegisterWeapon( cg.weaponSelect );	
+		weaponInfo = &cg_weapons[cg.weaponSelect];
+
+		trap_R_SetColor( colorTable[CT_WHITE]);
+		if (!CG_WeaponCheck(cg.weaponSelect))
+		{
+			CG_DrawPic( x-(bigIconSize/2), (y-((bigIconSize-smallIconSize)/2))+10+yOffset, bigIconSize, bigIconSize, cgs.media.weaponIcons_NA[cg.weaponSelect] );
+		}
+		else
+		{
+			CG_DrawPic( x-(bigIconSize/2), (y-((bigIconSize-smallIconSize)/2))+10+yOffset, bigIconSize, bigIconSize, cgs.media.weaponIcons[cg.weaponSelect] );
+		}
+	}
+
+	if ( cg.weaponSelect == WP_CONCUSSION )
+	{
+		i = WP_ROCKET_LAUNCHER;
+	}
+	else
+	{
+		i = cg.weaponSelect + 1;
+	}
+	if (i> LAST_USEABLE_WEAPON)
+	{
+		i = 1;
+	}
+
+	// Right side ICONS
+	// Work forwards from current icon
+	holdX = x + (bigIconSize/2) + pad;
+	height = smallIconSize * cg.iconHUDPercent;
+	for (iconCnt=1;iconCnt<(sideRightIconCnt+1);i++)
+	{
+		if ( i == WP_CONCUSSION )
+		{
+			i++;
+		}
+		else if ( i == WP_ROCKET_LAUNCHER && !drewConc && cg.weaponSelect != WP_CONCUSSION )
+		{
+			i = WP_CONCUSSION;
+		}
+		if (i>LAST_USEABLE_WEAPON)
+		{
+			i = 1;
+		}
+
+		if ( !(bits & ( 1 << i )))	// Does he have this weapon?
+		{
+			if ( i == WP_CONCUSSION )
+			{
+				drewConc = qtrue;
+				i = WP_FLECHETTE;
+			}
+			continue;
+		}
+
+		if ( !CG_WeaponSelectable(i) &&
+			(i == WP_THERMAL || i == WP_TRIP_MINE) )
+		{ //Don't show thermal and tripmine when out of them
+			continue;
+		}
+
+		++iconCnt;					// Good icon
+
+		if (/*weaponData[i].weaponIcon[0]*/cgs.media.weaponIcons[i])
+		{
+			weaponInfo_t	*weaponInfo;
+			CG_RegisterWeapon( i );	
+			weaponInfo = &cg_weapons[i];
+			// No ammo for this weapon?
+			trap_R_SetColor( colorTable[CT_WHITE]);
+			if (!CG_WeaponCheck(i))
+			{
+				CG_DrawPic( holdX, y+10+yOffset, smallIconSize, smallIconSize, cgs.media.weaponIcons_NA[i] );
+			}
+			else
+			{
+				CG_DrawPic( holdX, y+10+yOffset, smallIconSize, smallIconSize, cgs.media.weaponIcons[i] );
+			}
+
+
+			holdX += (smallIconSize+pad);
+		}
+		if ( i == WP_CONCUSSION )
+		{
+			drewConc = qtrue;
+			i = WP_FLECHETTE;
+		}
+	}
+
+	// draw the selected name
+	if ( cg_weapons[ cg.weaponSelect ].item ) 
+	{
+		vec4_t			textColor = { .875f, .718f, .121f, 1.0f };
+		char	text[1024];
+		char	upperKey[1024];
+
+		strcpy(upperKey, cg_weapons[ cg.weaponSelect ].item->classname);
+
+		if ( trap_SP_GetStringTextString( va("SP_INGAME_%s",Q_strupr(upperKey)), text, sizeof( text )))
+		{
+			UI_DrawProportionalString(320, y+45+yOffset, text, UI_CENTER|UI_SMALLFONT, textColor);
+		}
+		else
+		{
+			UI_DrawProportionalString(320, y+45+yOffset, cg_weapons[ cg.weaponSelect ].item->classname, UI_CENTER|UI_SMALLFONT, textColor);
+		}
+	}
+
+	trap_R_SetColor( NULL );
+}
+
+
+/*
+===============
+CG_NextWeapon_f
+===============
+*/
+void CG_NextWeapon_f( void ) {
+	int		i;
+	int		original;
+
+	if ( !cg.snap ) {
+		return;
+	}
+	if ( cg.snap->ps.pm_flags & PMF_FOLLOW ) {
+		return;
+	}
+
+	if (cg.predictedPlayerState.pm_type == PM_SPECTATOR)
+	{
+		return;
+	}
+
+	if (cg.snap->ps.emplacedIndex)
+	{
+		return;
+	}
+
+	cg.weaponSelectTime = cg.time;
+	original = cg.weaponSelect;
+
+	for ( i = 0 ; i < WP_NUM_WEAPONS ; i++ ) {
+		//*SIGH*... Hack to put concussion rifle before rocketlauncher
+		if ( cg.weaponSelect == WP_FLECHETTE )
+		{
+			cg.weaponSelect = WP_CONCUSSION;
+		}
+		else if ( cg.weaponSelect == WP_CONCUSSION )
+		{
+			cg.weaponSelect = WP_ROCKET_LAUNCHER;
+		}
+		else if ( cg.weaponSelect == WP_DET_PACK )
+		{
+			cg.weaponSelect = WP_BRYAR_OLD;
+		}
+		else
+		{
+			cg.weaponSelect++;
+		}
+		if ( cg.weaponSelect == WP_NUM_WEAPONS ) {
+			cg.weaponSelect = 0;
+		}
+	//	if ( cg.weaponSelect == WP_STUN_BATON ) {
+	//		continue;		// never cycle to gauntlet
+	//	}
+		if ( CG_WeaponSelectable( cg.weaponSelect ) ) {
+			break;
+		}
+	}
+	if ( i == WP_NUM_WEAPONS ) {
+		cg.weaponSelect = original;
+	}
+	else
+	{
+		trap_S_MuteSound(cg.snap->ps.clientNum, CHAN_WEAPON);
+	}
+}
+
+/*
+===============
+CG_PrevWeapon_f
+===============
+*/
+void CG_PrevWeapon_f( void ) {
+	int		i;
+	int		original;
+
+	if ( !cg.snap ) {
+		return;
+	}
+	if ( cg.snap->ps.pm_flags & PMF_FOLLOW ) {
+		return;
+	}
+
+	if (cg.predictedPlayerState.pm_type == PM_SPECTATOR)
+	{
+		return;
+	}
+
+	if (cg.snap->ps.emplacedIndex)
+	{
+		return;
+	}
+
+	cg.weaponSelectTime = cg.time;
+	original = cg.weaponSelect;
+
+	for ( i = 0 ; i < WP_NUM_WEAPONS ; i++ ) {
+		//*SIGH*... Hack to put concussion rifle before rocketlauncher
+		if ( cg.weaponSelect == WP_ROCKET_LAUNCHER )
+		{
+			cg.weaponSelect = WP_CONCUSSION;
+		}
+		else if ( cg.weaponSelect == WP_CONCUSSION )
+		{
+			cg.weaponSelect = WP_FLECHETTE;
+		}
+		else if ( cg.weaponSelect == WP_BRYAR_OLD )
+		{
+			cg.weaponSelect = WP_DET_PACK;
+		}
+		else
+		{
+			cg.weaponSelect--;
+		}
+		if ( cg.weaponSelect == -1 ) {
+			cg.weaponSelect = WP_NUM_WEAPONS-1;
+		}
+	//	if ( cg.weaponSelect == WP_STUN_BATON ) {
+	//		continue;		// never cycle to gauntlet
+	//	}
+		if ( CG_WeaponSelectable( cg.weaponSelect ) ) {
+			break;
+		}
+	}
+	if ( i == WP_NUM_WEAPONS ) {
+		cg.weaponSelect = original;
+	}
+	else
+	{
+		trap_S_MuteSound(cg.snap->ps.clientNum, CHAN_WEAPON);
+	}
+}
+
+/*
+===============
+CG_Weapon_f
+===============
+*/
+void CG_Weapon_f( void ) {
+	int		num;
+
+	if ( !cg.snap ) {
+		return;
+	}
+	if ( cg.snap->ps.pm_flags & PMF_FOLLOW ) {
+		return;
+	}
+
+	if (cg.snap->ps.emplacedIndex)
+	{
+		return;
+	}
+
+	num = atoi( CG_Argv( 1 ) );
+
+	if ( num < 1 || num > LAST_USEABLE_WEAPON ) {
+		return;
+	}
+
+	if (num == 1 && cg.snap->ps.weapon == WP_SABER)
+	{
+		if (cg.snap->ps.weaponTime < 1)
+		{
+			trap_SendConsoleCommand("sv_saberswitch\n");
+		}
+		return;
+	}
+
+	//rww - hack to make weapon numbers same as single player
+	if (num > WP_STUN_BATON)
+	{
+		//num++;
+		num += 2; //I suppose this is getting kind of crazy, what with the wp_melee in there too now.
+	}
+	else
+	{
+		if (cg.snap->ps.stats[STAT_WEAPONS] & (1 << WP_SABER))
+		{
+			num = WP_SABER;
+		}
+		else
+		{
+			num = WP_MELEE;
+		}
+	}
+
+	if (num > LAST_USEABLE_WEAPON+1)
+	{ //other weapons are off limits due to not actually being weapon weapons
+		return;
+	}
+
+	if (num >= WP_THERMAL && num <= WP_DET_PACK)
+	{
+		int weap, i = 0;
+
+		if (cg.snap->ps.weapon >= WP_THERMAL &&
+			cg.snap->ps.weapon <= WP_DET_PACK)
+		{
+			// already in cycle range so start with next cycle item
+			weap = cg.snap->ps.weapon + 1;
+		}
+		else
+		{
+			// not in cycle range, so start with thermal detonator
+			weap = WP_THERMAL;
+		}
+
+		// prevent an endless loop
+		while ( i <= 4 )
+		{
+			if (weap > WP_DET_PACK)
+			{
+				weap = WP_THERMAL;
+			}
+
+			if (CG_WeaponSelectable(weap))
+			{
+				num = weap;
+				break;
+			}
+
+			weap++;
+			i++;
+		}
+	}
+
+	if (!CG_WeaponSelectable(num))
+	{
+		return;
+	}
+
+	cg.weaponSelectTime = cg.time;
+
+	if ( ! ( cg.snap->ps.stats[STAT_WEAPONS] & ( 1 << num ) ) )
+	{
+		if (num == WP_SABER)
+		{ //don't have saber, try melee on the same slot
+			num = WP_MELEE;
+
+			if ( ! ( cg.snap->ps.stats[STAT_WEAPONS] & ( 1 << num ) ) )
+			{
+				return;
+			}
+		}
+		else
+		{
+			return;		// don't have the weapon
+		}
+	}
+
+	if (cg.weaponSelect != num)
+	{
+		trap_S_MuteSound(cg.snap->ps.clientNum, CHAN_WEAPON);
+	}
+
+	cg.weaponSelect = num;
+}
+
+
+//Version of the above which doesn't add +2 to a weapon.  The above can't
+//triger WP_MELEE or WP_STUN_BATON.  Derogatory comments go here.
+void CG_WeaponClean_f( void ) {
+	int		num;
+
+	if ( !cg.snap ) {
+		return;
+	}
+	if ( cg.snap->ps.pm_flags & PMF_FOLLOW ) {
+		return;
+	}
+
+	if (cg.snap->ps.emplacedIndex)
+	{
+		return;
+	}
+
+	num = atoi( CG_Argv( 1 ) );
+
+	if ( num < 1 || num > LAST_USEABLE_WEAPON ) {
+		return;
+	}
+
+	if (num == 1 && cg.snap->ps.weapon == WP_SABER)
+	{
+		if (cg.snap->ps.weaponTime < 1)
+		{
+			trap_SendConsoleCommand("sv_saberswitch\n");
+		}
+		return;
+	}
+
+	if(num == WP_STUN_BATON) {
+		if (cg.snap->ps.stats[STAT_WEAPONS] & (1 << WP_SABER))
+		{
+			num = WP_SABER;
+		}
+		else
+		{
+			num = WP_MELEE;
+		}
+	}
+
+	if (num > LAST_USEABLE_WEAPON+1)
+	{ //other weapons are off limits due to not actually being weapon weapons
+		return;
+	}
+
+	if (num >= WP_THERMAL && num <= WP_DET_PACK)
+	{
+		int weap, i = 0;
+
+		if (cg.snap->ps.weapon >= WP_THERMAL &&
+			cg.snap->ps.weapon <= WP_DET_PACK)
+		{
+			// already in cycle range so start with next cycle item
+			weap = cg.snap->ps.weapon + 1;
+		}
+		else
+		{
+			// not in cycle range, so start with thermal detonator
+			weap = WP_THERMAL;
+		}
+
+		// prevent an endless loop
+		while ( i <= 4 )
+		{
+			if (weap > WP_DET_PACK)
+			{
+				weap = WP_THERMAL;
+			}
+
+			if (CG_WeaponSelectable(weap))
+			{
+				num = weap;
+				break;
+			}
+
+			weap++;
+			i++;
+		}
+	}
+
+	if (!CG_WeaponSelectable(num))
+	{
+		return;
+	}
+
+	cg.weaponSelectTime = cg.time;
+
+	if ( ! ( cg.snap->ps.stats[STAT_WEAPONS] & ( 1 << num ) ) )
+	{
+		if (num == WP_SABER)
+		{ //don't have saber, try melee on the same slot
+			num = WP_MELEE;
+
+			if ( ! ( cg.snap->ps.stats[STAT_WEAPONS] & ( 1 << num ) ) )
+			{
+				return;
+			}
+		}
+		else
+		{
+			return;		// don't have the weapon
+		}
+	}
+
+	if (cg.weaponSelect != num)
+	{
+		trap_S_MuteSound(cg.snap->ps.clientNum, CHAN_WEAPON);
+	}
+
+	cg.weaponSelect = num;
+}
+
+
+
+/*
+===================
+CG_OutOfAmmoChange
+
+The current weapon has just run out of ammo
+===================
+*/
+void CG_OutOfAmmoChange( int oldWeapon )
+{
+	int		i;
+
+	cg.weaponSelectTime = cg.time;
+
+	for ( i = LAST_USEABLE_WEAPON ; i > 0 ; i-- )	//We don't want the emplaced or turret
+	{
+		if ( CG_WeaponSelectable( i ) )
+		{
+			/*
+			if ( 1 == cg_autoswitch.integer && 
+				( i == WP_TRIP_MINE || i == WP_DET_PACK || i == WP_THERMAL || i == WP_ROCKET_LAUNCHER) ) // safe weapon switch
+			*/
+			//rww - Don't we want to make sure i != one of these if autoswitch is 1 (safe)?
+			if (cg_autoswitch.integer != 1 || (i != WP_TRIP_MINE && i != WP_DET_PACK && i != WP_THERMAL && i != WP_ROCKET_LAUNCHER))
+			{
+				if (i != oldWeapon)
+				{ //don't even do anything if we're just selecting the weapon we already have/had
+					cg.weaponSelect = i;
+					break;
+				}
+			}
+		}
+	}
+
+	trap_S_MuteSound(cg.snap->ps.clientNum, CHAN_WEAPON);
+}
+
+
+
+/*
+===================================================================================================
+
+WEAPON EVENTS
+
+===================================================================================================
+*/
+
+void CG_GetClientWeaponMuzzleBoltPoint(int clIndex, vec3_t to)
+{
+	centity_t *cent;
+	mdxaBone_t	boltMatrix;
+
+	if (clIndex < 0 || clIndex >= MAX_CLIENTS)
+	{
+		return;
+	}
+
+	cent = &cg_entities[clIndex];
+
+	if (!cent || !cent->ghoul2 || !trap_G2_HaveWeGhoul2Models(cent->ghoul2) ||
+		!trap_G2API_HasGhoul2ModelOnIndex(&(cent->ghoul2), 1))
+	{
+		return;
+	}
+
+	trap_G2API_GetBoltMatrix(cent->ghoul2, 1, 0, &boltMatrix, cent->turAngles, cent->lerpOrigin, cg.time, cgs.gameModels, cent->modelScale);
+	BG_GiveMeVectorFromMatrix(&boltMatrix, ORIGIN, to);
+}
+
+/*
+================
+CG_FireWeapon
+
+Caused by an EV_FIRE_WEAPON event
+================
+*/
+void CG_FireWeapon( centity_t *cent, qboolean altFire ) {
+	entityState_t *ent;
+	int				c;
+	weaponInfo_t	*weap;
+
+	ent = &cent->currentState;
+	if ( ent->weapon == WP_NONE ) {
+		return;
+	}
+	if ( ent->weapon >= WP_NUM_WEAPONS ) {
+		CG_Error( "CG_FireWeapon: ent->weapon >= WP_NUM_WEAPONS" );
+		return;
+	}
+	weap = &cg_weapons[ ent->weapon ];
+
+	// mark the entity as muzzle flashing, so when it is added it will
+	// append the flash to the weapon model
+	cent->muzzleFlashTime = cg.time;
+
+	if (cg.predictedPlayerState.clientNum == cent->currentState.number)
+	{
+		if ((ent->weapon == WP_BRYAR_PISTOL && altFire) ||
+			(ent->weapon == WP_BRYAR_OLD && altFire) ||
+			(ent->weapon == WP_BOWCASTER && !altFire) ||
+			(ent->weapon == WP_DEMP2 && altFire))
+		{
+			float val = ( cg.time - cent->currentState.constantLight ) * 0.001f;
+
+			if (val > 3)
+			{
+				val = 3;
+			}
+			if (val < 0.2)
+			{
+				val = 0.2;
+			}
+
+			val *= 2;
+
+			CGCam_Shake( val, 250 );
+		}
+		else if (ent->weapon == WP_ROCKET_LAUNCHER ||
+			(ent->weapon == WP_REPEATER && altFire) ||
+			ent->weapon == WP_FLECHETTE ||
+			(ent->weapon == WP_CONCUSSION && !altFire))
+		{
+			if (ent->weapon == WP_CONCUSSION)
+			{
+				if (!cg.renderingThirdPerson )//gives an advantage to being in 3rd person, but would look silly otherwise
+				{//kick the view back
+					cg.kick_angles[PITCH] = flrand( -10, -15 );
+					cg.kick_time = cg.time;
+				}
+			}
+			else if (ent->weapon == WP_ROCKET_LAUNCHER)
+			{
+				CGCam_Shake(flrand(2, 3), 350);
+			}
+			else if (ent->weapon == WP_REPEATER)
+			{
+				CGCam_Shake(flrand(2, 3), 350);
+			}
+			else if (ent->weapon == WP_FLECHETTE)
+			{
+				if (altFire)
+				{
+					CGCam_Shake(flrand(2, 3), 350);
+				}
+				else
+				{
+					CGCam_Shake(1.5, 250);
+				}
+			}
+		}
+	}
+	// lightning gun only does this this on initial press
+	if ( ent->weapon == WP_DEMP2 ) {
+		if ( cent->pe.lightningFiring ) {
+			return;
+		}
+	}
+
+	// play quad sound if needed
+	if ( cent->currentState.powerups & ( 1 << PW_QUAD ) ) {
+		//trap_S_StartSound (NULL, cent->currentState.number, CHAN_ITEM, cgs.media.quadSound );
+	}
+
+
+	// play a sound
+	if (altFire)
+	{
+		// play a sound
+		for ( c = 0 ; c < 4 ; c++ ) {
+			if ( !weap->altFlashSound[c] ) {
+				break;
+			}
+		}
+		if ( c > 0 ) {
+			c = rand() % c;
+			if ( weap->altFlashSound[c] )
+			{
+				trap_S_StartSound( NULL, ent->number, CHAN_WEAPON, weap->altFlashSound[c] );
+			}
+		}
+//		if ( weap->altFlashSnd )
+//		{
+//			trap_S_StartSound( NULL, ent->number, CHAN_WEAPON, weap->altFlashSnd );
+//		}
+	}
+	else
+	{
+		// play a sound
+		for ( c = 0 ; c < 4 ; c++ ) {
+			if ( !weap->flashSound[c] ) {
+				break;
+			}
+		}
+		if ( c > 0 ) {
+			c = rand() % c;
+			if ( weap->flashSound[c] )
+			{
+				trap_S_StartSound( NULL, ent->number, CHAN_WEAPON, weap->flashSound[c] );
+			}
+		}
+	}
+}
+
+qboolean CG_VehicleWeaponImpact( centity_t *cent )
+{//see if this is a missile entity that's owned by a vehicle and should do a special, overridden impact effect
+	if ((cent->currentState.eFlags&EF_JETPACK_ACTIVE)//hack so we know we're a vehicle Weapon shot
+		&& cent->currentState.otherEntityNum2
+		&& g_vehWeaponInfo[cent->currentState.otherEntityNum2].iImpactFX)
+	{//missile is from a special vehWeapon
+		vec3_t normal;
+		ByteToDir( cent->currentState.eventParm, normal );
+
+		trap_FX_PlayEffectID( g_vehWeaponInfo[cent->currentState.otherEntityNum2].iImpactFX, cent->lerpOrigin, normal, -1, -1 );
+		return qtrue;
+	}
+	return qfalse;
+}
+
+/*
+=================
+CG_MissileHitWall
+
+Caused by an EV_MISSILE_MISS event, or directly by local bullet tracing
+=================
+*/
+void CG_MissileHitWall(int weapon, int clientNum, vec3_t origin, vec3_t dir, impactSound_t soundType, qboolean altFire, int charge) 
+{
+	int parm;
+	vec3_t up={0,0,1};
+
+	switch( weapon )
+	{
+	case WP_BRYAR_PISTOL:
+		if ( altFire )
+		{
+			parm = charge;
+			FX_BryarAltHitWall( origin, dir, parm );
+		}
+		else
+		{
+			FX_BryarHitWall( origin, dir );
+		}
+		break;
+
+	case WP_CONCUSSION:
+		FX_ConcussionHitWall( origin, dir );
+		break;
+
+	case WP_BRYAR_OLD:
+		if ( altFire )
+		{
+			parm = charge;
+			FX_BryarAltHitWall( origin, dir, parm );
+		}
+		else
+		{
+			FX_BryarHitWall( origin, dir );
+		}
+		break;
+
+	case WP_TURRET:
+		FX_TurretHitWall( origin, dir );
+		break;
+
+	case WP_BLASTER:
+		FX_BlasterWeaponHitWall( origin, dir );
+		break;
+
+	case WP_DISRUPTOR:
+		FX_DisruptorAltMiss( origin, dir );
+		break;
+
+	case WP_BOWCASTER:
+		FX_BowcasterHitWall( origin, dir );
+		break;
+
+	case WP_REPEATER:
+		if ( altFire )
+		{
+			FX_RepeaterAltHitWall( origin, dir );
+		}
+		else
+		{
+			FX_RepeaterHitWall( origin, dir );
+		}
+		break;
+
+	case WP_DEMP2:
+		if (altFire)
+		{
+			trap_FX_PlayEffectID(cgs.effects.mAltDetonate, origin, dir, -1, -1);
+		}
+		else
+		{
+			FX_DEMP2_HitWall( origin, dir );
+		}
+		break;
+
+	case WP_FLECHETTE:
+		/*if (altFire)
+		{
+			CG_SurfaceExplosion(origin, dir, 20.0f, 12.0f, qtrue);
+		}
+		else
+		*/
+		if (!altFire)
+		{
+			FX_FlechetteWeaponHitWall( origin, dir );
+		}
+		break;
+
+	case WP_ROCKET_LAUNCHER:
+		FX_RocketHitWall( origin, dir );
+		break;
+
+	case WP_THERMAL:
+		trap_FX_PlayEffectID( cgs.effects.thermalExplosionEffect, origin, dir, -1, -1 );
+		trap_FX_PlayEffectID( cgs.effects.thermalShockwaveEffect, origin, up, -1, -1 );
+		break;
+
+	case WP_EMPLACED_GUN:
+		FX_BlasterWeaponHitWall( origin, dir );
+		//FIXME: Give it its own hit wall effect
+		break;
+	}
+}
+
+
+/*
+=================
+CG_MissileHitPlayer
+=================
+*/
+void CG_MissileHitPlayer(int weapon, vec3_t origin, vec3_t dir, int entityNum, qboolean altFire) 
+{
+	qboolean	humanoid = qtrue;
+	vec3_t up={0,0,1};
+
+	/*
+	// NOTENOTE Non-portable code from single player
+	if ( cent->gent )
+	{
+		other = &g_entities[cent->gent->s.otherEntityNum];
+
+		if ( other->client && other->client->playerTeam == TEAM_BOTS )
+		{
+			humanoid = qfalse;
+		}
+	}
+	*/	
+
+	// NOTENOTE No bleeding in this game
+//	CG_Bleed( origin, entityNum );
+
+	// some weapons will make an explosion with the blood, while
+	// others will just make the blood
+	switch ( weapon ) {
+	case WP_BRYAR_PISTOL:
+		if ( altFire )
+		{
+			FX_BryarAltHitPlayer( origin, dir, humanoid );
+		}
+		else
+		{
+			FX_BryarHitPlayer( origin, dir, humanoid );
+		}
+		break;
+
+	case WP_CONCUSSION:
+		FX_ConcussionHitPlayer( origin, dir, humanoid );
+		break;
+
+	case WP_BRYAR_OLD:
+		if ( altFire )
+		{
+			FX_BryarAltHitPlayer( origin, dir, humanoid );
+		}
+		else
+		{
+			FX_BryarHitPlayer( origin, dir, humanoid );
+		}
+		break;
+
+	case WP_TURRET:
+		FX_TurretHitPlayer( origin, dir, humanoid );
+		break;
+
+	case WP_BLASTER:
+		FX_BlasterWeaponHitPlayer( origin, dir, humanoid );
+		break;
+
+	case WP_DISRUPTOR:
+		FX_DisruptorAltHit( origin, dir);
+		break;
+
+	case WP_BOWCASTER:
+		FX_BowcasterHitPlayer( origin, dir, humanoid );
+		break;
+
+	case WP_REPEATER:
+		if ( altFire )
+		{
+			FX_RepeaterAltHitPlayer( origin, dir, humanoid );
+		}
+		else
+		{
+			FX_RepeaterHitPlayer( origin, dir, humanoid );
+		}
+		break;
+
+	case WP_DEMP2:
+		// Do a full body effect here for some more feedback
+		// NOTENOTE The chaining of the demp2 is not yet implemented.
+		/*
+		if ( other )
+		{
+			other->s.powerups |= ( 1 << PW_DISINT_1 );
+			other->client->ps.powerups[PW_DISINT_1] = cg.time + 650;
+		}
+		*/
+		if (altFire)
+		{
+			trap_FX_PlayEffectID(cgs.effects.mAltDetonate, origin, dir, -1, -1);
+		}
+		else
+		{
+			FX_DEMP2_HitPlayer( origin, dir, humanoid );
+		}
+		break;
+
+	case WP_FLECHETTE:
+		FX_FlechetteWeaponHitPlayer( origin, dir, humanoid );
+		break;
+
+	case WP_ROCKET_LAUNCHER:
+		FX_RocketHitPlayer( origin, dir, humanoid );
+		break;
+
+	case WP_THERMAL:
+		trap_FX_PlayEffectID( cgs.effects.thermalExplosionEffect, origin, dir, -1, -1 );
+		trap_FX_PlayEffectID( cgs.effects.thermalShockwaveEffect, origin, up, -1, -1 );
+		break;
+	case WP_EMPLACED_GUN:
+		//FIXME: Its own effect?
+		FX_BlasterWeaponHitPlayer( origin, dir, humanoid );
+		break;
+
+	default:
+		break;
+	}
+}
+
+
+/*
+============================================================================
+
+BULLETS
+
+============================================================================
+*/
+
+
+/*
+======================
+CG_CalcMuzzlePoint
+======================
+*/
+qboolean CG_CalcMuzzlePoint( int entityNum, vec3_t muzzle ) {
+	vec3_t		forward, right;
+	vec3_t		gunpoint;
+	centity_t	*cent;
+	int			anim;
+
+	if ( entityNum == cg.snap->ps.clientNum )
+	{ //I'm not exactly sure why we'd be rendering someone else's crosshair, but hey.
+		int weapontype = cg.snap->ps.weapon;
+		vec3_t weaponMuzzle;
+		centity_t *pEnt = &cg_entities[cg.predictedPlayerState.clientNum];
+
+		VectorCopy(WP_MuzzlePoint[weapontype], weaponMuzzle);
+
+		if (weapontype == WP_DISRUPTOR || weapontype == WP_STUN_BATON || weapontype == WP_MELEE || weapontype == WP_SABER)
+		{
+			VectorClear(weaponMuzzle);
+		}
+
+		if (cg.renderingThirdPerson)
+		{
+			VectorCopy( pEnt->lerpOrigin, gunpoint );
+			AngleVectors( pEnt->lerpAngles, forward, right, NULL );
+		}
+		else
+		{
+			VectorCopy( cg.refdef.vieworg, gunpoint );
+			AngleVectors( cg.refdef.viewangles, forward, right, NULL );
+		}
+
+		if (weapontype == WP_EMPLACED_GUN && cg.snap->ps.emplacedIndex)
+		{
+			centity_t *gunEnt = &cg_entities[cg.snap->ps.emplacedIndex];
+
+			if (gunEnt)
+			{
+				vec3_t pitchConstraint;
+
+				VectorCopy(gunEnt->lerpOrigin, gunpoint);
+				gunpoint[2] += 46;
+
+				if (cg.renderingThirdPerson)
+				{
+					VectorCopy(pEnt->lerpAngles, pitchConstraint);
+				}
+				else
+				{
+					VectorCopy(cg.refdef.viewangles, pitchConstraint);
+				}
+
+				if (pitchConstraint[PITCH] > 40)
+				{
+					pitchConstraint[PITCH] = 40;
+				}
+				AngleVectors( pitchConstraint, forward, right, NULL );
+			}
+		}
+
+		VectorCopy(gunpoint, muzzle);
+
+		VectorMA(muzzle, weaponMuzzle[0], forward, muzzle);
+		VectorMA(muzzle, weaponMuzzle[1], right, muzzle);
+
+		if (weapontype == WP_EMPLACED_GUN && cg.snap->ps.emplacedIndex)
+		{
+			//Do nothing
+		}
+		else if (cg.renderingThirdPerson)
+		{
+			muzzle[2] += cg.snap->ps.viewheight + weaponMuzzle[2];
+		}
+		else
+		{
+			muzzle[2] += weaponMuzzle[2];
+		}
+
+		return qtrue;
+	}
+
+	cent = &cg_entities[entityNum];
+	if ( !cent->currentValid ) {
+		return qfalse;
+	}
+
+	VectorCopy( cent->currentState.pos.trBase, muzzle );
+
+	AngleVectors( cent->currentState.apos.trBase, forward, NULL, NULL );
+	anim = cent->currentState.legsAnim;
+	if ( anim == BOTH_CROUCH1WALK || anim == BOTH_CROUCH1IDLE ) {
+		muzzle[2] += CROUCH_VIEWHEIGHT;
+	} else {
+		muzzle[2] += DEFAULT_VIEWHEIGHT;
+	}
+
+	VectorMA( muzzle, 14, forward, muzzle );
+
+	return qtrue;
+
+}
+
+
+
+/*
+Ghoul2 Insert Start
+*/
+
+// create one instance of all the weapons we are going to use so we can just copy this info into each clients gun ghoul2 object in fast way
+static void *g2WeaponInstances[MAX_WEAPONS];
+
+void CG_InitG2Weapons(void)
+{
+	int i = 0;
+	gitem_t		*item;
+	memset(g2WeaponInstances, 0, sizeof(g2WeaponInstances));
+	for ( item = bg_itemlist + 1 ; item->classname ; item++ ) 
+	{
+		if ( item->giType == IT_WEAPON )
+		{
+			assert(item->giTag < MAX_WEAPONS);
+
+			// initialise model
+			trap_G2API_InitGhoul2Model(&g2WeaponInstances[/*i*/item->giTag], item->world_model[0], 0, 0, 0, 0, 0);
+//			trap_G2API_InitGhoul2Model(&g2WeaponInstances[i], item->world_model[0],G_ModelIndex( item->world_model[0] ) , 0, 0, 0, 0);
+			if (g2WeaponInstances[/*i*/item->giTag])
+			{
+				// indicate we will be bolted to model 0 (ie the player) on bolt 0 (always the right hand) when we get copied
+				trap_G2API_SetBoltInfo(g2WeaponInstances[/*i*/item->giTag], 0, 0);
+				// now set up the gun bolt on it
+				if (item->giTag == WP_SABER)
+				{
+					trap_G2API_AddBolt(g2WeaponInstances[/*i*/item->giTag], 0, "*blade1");
+				}
+				else
+				{
+					trap_G2API_AddBolt(g2WeaponInstances[/*i*/item->giTag], 0, "*flash");
+				}
+				i++;
+			}
+			if (i == MAX_WEAPONS)
+			{
+				assert(0);	
+				break;
+			}
+			
+		}
+	}
+}
+
+// clean out any g2 models we instanciated for copying purposes
+void CG_ShutDownG2Weapons(void)
+{
+	int i;
+	for (i=0; i<MAX_WEAPONS; i++)
+	{
+		trap_G2API_CleanGhoul2Models(&g2WeaponInstances[i]);
+	}
+}
+
+void *CG_G2WeaponInstance(centity_t *cent, int weapon)
+{
+	clientInfo_t *ci = NULL;
+
+	if (weapon != WP_SABER)
+	{
+		return g2WeaponInstances[weapon];
+	}
+
+	if (cent->currentState.eType != ET_PLAYER &&
+		cent->currentState.eType != ET_NPC)
+	{
+		return g2WeaponInstances[weapon];
+	}
+
+	if (cent->currentState.eType == ET_NPC)
+	{
+		ci = cent->npcClient;
+	}
+	else
+	{
+		ci = &cgs.clientinfo[cent->currentState.number];
+	}
+
+	if (!ci)
+	{
+		return g2WeaponInstances[weapon];
+	}
+
+	//Try to return the custom saber instance if we can.
+	if (ci->saber[0].model[0] &&
+		ci->ghoul2Weapons[0])
+	{
+		return ci->ghoul2Weapons[0];
+	}
+
+	//If no custom then just use the default.
+	return g2WeaponInstances[weapon];
+}
+
+// what ghoul2 model do we want to copy ?
+void CG_CopyG2WeaponInstance(centity_t *cent, int weaponNum, void *toGhoul2)
+{
+	//rww - the -1 is because there is no "weapon" for WP_NONE
+	assert(weaponNum < MAX_WEAPONS);
+	if (CG_G2WeaponInstance(cent, weaponNum/*-1*/))
+	{
+		if (weaponNum == WP_SABER)
+		{
+			clientInfo_t *ci = NULL;
+
+			if (cent->currentState.eType == ET_NPC)
+			{
+				ci = cent->npcClient;
+			}
+			else
+			{
+				ci = &cgs.clientinfo[cent->currentState.number];
+			}
+
+			if (!ci)
+			{
+				trap_G2API_CopySpecificGhoul2Model(CG_G2WeaponInstance(cent, weaponNum/*-1*/), 0, toGhoul2, 1); 
+			}
+			else
+			{ //Try both the left hand saber and the right hand saber
+				int i = 0;
+
+				while (i < MAX_SABERS)
+				{
+					if (ci->saber[i].model[0] &&
+						ci->ghoul2Weapons[i])
+					{
+						trap_G2API_CopySpecificGhoul2Model(ci->ghoul2Weapons[i], 0, toGhoul2, i+1); 
+					}
+					else if (ci->ghoul2Weapons[i])
+					{ //if the second saber has been removed, then be sure to remove it and free the instance.
+						qboolean g2HasSecondSaber = trap_G2API_HasGhoul2ModelOnIndex(&(toGhoul2), 2);
+
+						if (g2HasSecondSaber)
+						{ //remove it now since we're switching away from sabers
+							trap_G2API_RemoveGhoul2Model(&(toGhoul2), 2);
+						}
+						trap_G2API_CleanGhoul2Models(&ci->ghoul2Weapons[i]);
+					}
+
+					i++;
+				}
+			}
+		}
+		else
+		{
+			qboolean g2HasSecondSaber = trap_G2API_HasGhoul2ModelOnIndex(&(toGhoul2), 2);
+
+			if (g2HasSecondSaber)
+			{ //remove it now since we're switching away from sabers
+				trap_G2API_RemoveGhoul2Model(&(toGhoul2), 2);
+			}
+
+			if (weaponNum == WP_EMPLACED_GUN)
+			{ //a bit of a hack to remove gun model when using an emplaced weap
+				if (trap_G2API_HasGhoul2ModelOnIndex(&(toGhoul2), 1))
+				{
+					trap_G2API_RemoveGhoul2Model(&(toGhoul2), 1);
+				}
+			}
+			else if (weaponNum == WP_MELEE)
+			{ //don't want a weapon on the model for this one
+				if (trap_G2API_HasGhoul2ModelOnIndex(&(toGhoul2), 1))
+				{
+					trap_G2API_RemoveGhoul2Model(&(toGhoul2), 1);
+				}
+			}
+			else
+			{
+				trap_G2API_CopySpecificGhoul2Model(CG_G2WeaponInstance(cent, weaponNum/*-1*/), 0, toGhoul2, 1); 
+			}
+		}
+	}
+}
+
+void CG_CheckPlayerG2Weapons(playerState_t *ps, centity_t *cent) 
+{
+	if (!ps)
+	{
+		assert(0);
+		return;
+	}
+
+	if (ps->pm_flags & PMF_FOLLOW)
+	{
+		return;
+	}
+
+	if (cent->currentState.eType == ET_NPC)
+	{
+		assert(0);
+		return;
+	}
+
+	// should we change the gun model on this player?
+	if (cent->currentState.saberInFlight)
+	{
+		cent->ghoul2weapon = CG_G2WeaponInstance(cent, WP_SABER);
+	}
+
+	if (cent->currentState.eFlags & EF_DEAD)
+	{ //no updating weapons when dead
+		cent->ghoul2weapon = NULL;
+		return;
+	}
+
+	if (cent->torsoBolt)
+	{ //got our limb cut off, no updating weapons until it's restored
+		cent->ghoul2weapon = NULL;
+		return;
+	}
+
+	if (cgs.clientinfo[ps->clientNum].team == TEAM_SPECTATOR ||
+		ps->persistant[PERS_TEAM] == TEAM_SPECTATOR)
+	{
+		cent->ghoul2weapon = cg_entities[ps->clientNum].ghoul2weapon = NULL;
+		cent->weapon = cg_entities[ps->clientNum].weapon = 0;
+		return;
+	}
+
+	if (cent->ghoul2 && cent->ghoul2weapon != CG_G2WeaponInstance(cent, ps->weapon) &&
+		ps->clientNum == cent->currentState.number) //don't want spectator mode forcing one client's weapon instance over another's
+	{
+		CG_CopyG2WeaponInstance(cent, ps->weapon, cent->ghoul2);
+		cent->ghoul2weapon = CG_G2WeaponInstance(cent, ps->weapon);
+		if (cent->weapon == WP_SABER && cent->weapon != ps->weapon && !ps->saberHolstered)
+		{ //switching away from the saber
+			//trap_S_StartSound(cent->lerpOrigin, cent->currentState.number, CHAN_AUTO, trap_S_RegisterSound( "sound/weapons/saber/saberoffquick.wav" ));
+			if (cgs.clientinfo[ps->clientNum].saber[0].soundOff && !ps->saberHolstered)
+			{
+				trap_S_StartSound(cent->lerpOrigin, cent->currentState.number, CHAN_AUTO, cgs.clientinfo[ps->clientNum].saber[0].soundOff);
+			}
+
+			if (cgs.clientinfo[ps->clientNum].saber[1].soundOff &&
+				cgs.clientinfo[ps->clientNum].saber[1].model[0] &&
+				!ps->saberHolstered)
+			{
+				trap_S_StartSound(cent->lerpOrigin, cent->currentState.number, CHAN_AUTO, cgs.clientinfo[ps->clientNum].saber[1].soundOff);
+			}
+		}
+		else if (ps->weapon == WP_SABER && cent->weapon != ps->weapon && !cent->saberWasInFlight)
+		{ //switching to the saber
+			//trap_S_StartSound(cent->lerpOrigin, cent->currentState.number, CHAN_AUTO, trap_S_RegisterSound( "sound/weapons/saber/saberon.wav" ));
+			if (cgs.clientinfo[ps->clientNum].saber[0].soundOn)
+			{
+				trap_S_StartSound(cent->lerpOrigin, cent->currentState.number, CHAN_AUTO, cgs.clientinfo[ps->clientNum].saber[0].soundOn);
+			}
+
+			if (cgs.clientinfo[ps->clientNum].saber[1].soundOn)
+			{
+				trap_S_StartSound(cent->lerpOrigin, cent->currentState.number, CHAN_AUTO, cgs.clientinfo[ps->clientNum].saber[1].soundOn);
+			}
+
+			BG_SI_SetDesiredLength(&cgs.clientinfo[ps->clientNum].saber[0], 0, -1);
+			BG_SI_SetDesiredLength(&cgs.clientinfo[ps->clientNum].saber[1], 0, -1);
+		}
+		cent->weapon = ps->weapon;
+	}
+}
+
+
+/*
+Ghoul2 Insert End
+*/
diff --git a/codemp/cgame/cgame.bat b/codemp/cgame/cgame.bat
new file mode 100644
index 0000000..14a9a1d
--- /dev/null
+++ b/codemp/cgame/cgame.bat
@@ -0,0 +1,19 @@
+echo off
+
+REM del /q vm
+REM rww - removed this.. point of makefile is not have to rebuild all of it
+
+mkdir vm
+
+del vm\bg_lib.asm
+asm2mak cgame makefile
+make cgame
+
+cd vm
+
+mkdir "..\..\base\vm"
+copy *.map "..\..\base\vm"
+copy *.qvm "..\..\base\vm"
+
+:quit
+cd ..
diff --git a/codemp/cgame/cgame.q3asm b/codemp/cgame/cgame.q3asm
new file mode 100644
index 0000000..a09d027
--- /dev/null
+++ b/codemp/cgame/cgame.q3asm
@@ -0,0 +1,48 @@
+-o "vm/cgame"
+vm/cg_main
+vm/cg_syscalls
+vm/cg_consolecmds
+vm/cg_draw
+vm/cg_drawtools
+vm/cg_effects
+vm/cg_ents
+vm/cg_event
+vm/cg_info
+vm/cg_light
+vm/cg_localents
+vm/cg_marks
+vm/cg_players
+vm/cg_playerstate
+vm/cg_predict
+vm/cg_saga
+vm/cg_scoreboard
+vm/cg_servercmds
+vm/cg_snapshot
+vm/cg_strap
+vm/cg_turret
+vm/cg_view
+vm/cg_weaponinit
+vm/cg_weapons
+vm/fx_blaster
+vm/fx_bowcaster
+vm/fx_bryarpistol
+vm/fx_demp2
+vm/fx_disruptor
+vm/fx_flechette
+vm/fx_heavyrepeater
+vm/fx_rocketlauncher
+vm/fx_force
+vm/bg_slidemove
+vm/bg_weapons
+vm/bg_panimate
+vm/bg_pmove
+vm/bg_lib
+vm/bg_misc
+vm/bg_saber
+vm/bg_saberLoad
+vm/bg_saga
+vm/bg_vehicleLoad
+vm/q_math
+vm/q_shared
+vm/ui_shared
+vm/cg_newDraw
diff --git a/codemp/cgame/fx_blaster.c b/codemp/cgame/fx_blaster.c
new file mode 100644
index 0000000..98bfe00
--- /dev/null
+++ b/codemp/cgame/fx_blaster.c
@@ -0,0 +1,65 @@
+// Blaster Weapon
+
+#include "cg_local.h"
+
+/*
+-------------------------
+FX_BlasterProjectileThink
+-------------------------
+*/
+
+void FX_BlasterProjectileThink( centity_t *cent, const struct weaponInfo_s *weapon )
+{
+	vec3_t forward;
+
+	if ( VectorNormalize2( cent->currentState.pos.trDelta, forward ) == 0.0f )
+	{
+		forward[2] = 1.0f;
+	}
+
+	trap_FX_PlayEffectID( cgs.effects.blasterShotEffect, cent->lerpOrigin, forward, -1, -1 );
+}
+
+/*
+-------------------------
+FX_BlasterAltFireThink
+-------------------------
+*/
+void FX_BlasterAltFireThink( centity_t *cent, const struct weaponInfo_s *weapon )
+{
+	vec3_t forward;
+
+	if ( VectorNormalize2( cent->currentState.pos.trDelta, forward ) == 0.0f )
+	{
+		forward[2] = 1.0f;
+	}
+
+	trap_FX_PlayEffectID( cgs.effects.blasterShotEffect, cent->lerpOrigin, forward, -1, -1 );
+}
+
+/*
+-------------------------
+FX_BlasterWeaponHitWall
+-------------------------
+*/
+void FX_BlasterWeaponHitWall( vec3_t origin, vec3_t normal )
+{
+	trap_FX_PlayEffectID( cgs.effects.blasterWallImpactEffect, origin, normal, -1, -1 );
+}
+
+/*
+-------------------------
+FX_BlasterWeaponHitPlayer
+-------------------------
+*/
+void FX_BlasterWeaponHitPlayer( vec3_t origin, vec3_t normal, qboolean humanoid )
+{
+	if ( humanoid )
+	{
+		trap_FX_PlayEffectID( cgs.effects.blasterFleshImpactEffect, origin, normal, -1, -1 );
+	}
+	else
+	{
+		trap_FX_PlayEffectID( cgs.effects.blasterDroidImpactEffect, origin, normal, -1, -1 );
+	}
+}
diff --git a/codemp/cgame/fx_bowcaster.c b/codemp/cgame/fx_bowcaster.c
new file mode 100644
index 0000000..005f399
--- /dev/null
+++ b/codemp/cgame/fx_bowcaster.c
@@ -0,0 +1,62 @@
+// Bowcaster Weapon
+
+#include "cg_local.h"
+
+/*
+---------------------------
+FX_BowcasterProjectileThink
+---------------------------
+*/
+
+void FX_BowcasterProjectileThink( centity_t *cent, const struct weaponInfo_s *weapon )
+{
+	vec3_t forward;
+
+	if ( VectorNormalize2( cent->currentState.pos.trDelta, forward ) == 0.0f )
+	{
+		forward[2] = 1.0f;
+	}
+
+	trap_FX_PlayEffectID( cgs.effects.bowcasterShotEffect, cent->lerpOrigin, forward, -1, -1 );
+}
+
+/*
+---------------------------
+FX_BowcasterHitWall
+---------------------------
+*/
+
+void FX_BowcasterHitWall( vec3_t origin, vec3_t normal )
+{
+	trap_FX_PlayEffectID( cgs.effects.bowcasterImpactEffect, origin, normal, -1, -1 );
+}
+
+/*
+---------------------------
+FX_BowcasterHitPlayer
+---------------------------
+*/
+
+void FX_BowcasterHitPlayer( vec3_t origin, vec3_t normal, qboolean humanoid )
+{
+	trap_FX_PlayEffectID( cgs.effects.bowcasterImpactEffect, origin, normal, -1, -1 );
+}
+
+/*
+------------------------------
+FX_BowcasterAltProjectileThink
+------------------------------
+*/
+
+void FX_BowcasterAltProjectileThink( centity_t *cent, const struct weaponInfo_s *weapon )
+{
+	vec3_t forward;
+
+	if ( VectorNormalize2( cent->currentState.pos.trDelta, forward ) == 0.0f )
+	{
+		forward[2] = 1.0f;
+	}
+
+	trap_FX_PlayEffectID( cgs.effects.bowcasterShotEffect, cent->lerpOrigin, forward, -1, -1 );
+}
+
diff --git a/codemp/cgame/fx_bryarpistol.c b/codemp/cgame/fx_bryarpistol.c
new file mode 100644
index 0000000..b5fdfdd
--- /dev/null
+++ b/codemp/cgame/fx_bryarpistol.c
@@ -0,0 +1,237 @@
+// Bryar Pistol Weapon Effects
+
+#include "cg_local.h"
+#include "fx_local.h"
+
+/*
+-------------------------
+
+	MAIN FIRE
+
+-------------------------
+FX_BryarProjectileThink
+-------------------------
+*/
+void FX_BryarProjectileThink(  centity_t *cent, const struct weaponInfo_s *weapon )
+{
+	vec3_t forward;
+
+	if ( VectorNormalize2( cent->currentState.pos.trDelta, forward ) == 0.0f )
+	{
+		forward[2] = 1.0f;
+	}
+
+	trap_FX_PlayEffectID( cgs.effects.bryarShotEffect, cent->lerpOrigin, forward, -1, -1 );
+}
+
+/*
+-------------------------
+FX_BryarHitWall
+-------------------------
+*/
+void FX_BryarHitWall( vec3_t origin, vec3_t normal )
+{
+	trap_FX_PlayEffectID( cgs.effects.bryarWallImpactEffect, origin, normal, -1, -1 );
+}
+
+/*
+-------------------------
+FX_BryarHitPlayer
+-------------------------
+*/
+void FX_BryarHitPlayer( vec3_t origin, vec3_t normal, qboolean humanoid )
+{
+	if ( humanoid )
+	{
+		trap_FX_PlayEffectID( cgs.effects.bryarFleshImpactEffect, origin, normal, -1, -1 );
+	}
+	else
+	{
+		trap_FX_PlayEffectID( cgs.effects.bryarDroidImpactEffect, origin, normal, -1, -1 );
+	}
+}
+
+
+/*
+-------------------------
+
+	ALT FIRE
+
+-------------------------
+FX_BryarAltProjectileThink
+-------------------------
+*/
+void FX_BryarAltProjectileThink(  centity_t *cent, const struct weaponInfo_s *weapon )
+{
+	vec3_t forward;
+	int t;
+
+	if ( VectorNormalize2( cent->currentState.pos.trDelta, forward ) == 0.0f )
+	{
+		forward[2] = 1.0f;
+	}
+
+	// see if we have some sort of extra charge going on
+	for (t = 1; t < cent->currentState.generic1; t++ )
+	{
+		// just add ourselves over, and over, and over when we are charged
+		trap_FX_PlayEffectID( cgs.effects.bryarPowerupShotEffect, cent->lerpOrigin, forward, -1, -1 );
+	}
+
+	//	for ( int t = 1; t < cent->gent->count; t++ )	// The single player stores the charge in count, which isn't accessible on the client
+
+	trap_FX_PlayEffectID( cgs.effects.bryarShotEffect, cent->lerpOrigin, forward, -1, -1 );
+}
+
+/*
+-------------------------
+FX_BryarAltHitWall
+-------------------------
+*/
+void FX_BryarAltHitWall( vec3_t origin, vec3_t normal, int power )
+{
+	switch( power )
+	{
+	case 4:
+	case 5:
+		trap_FX_PlayEffectID( cgs.effects.bryarWallImpactEffect3, origin, normal, -1, -1 );
+		break;
+
+	case 2:
+	case 3:
+		trap_FX_PlayEffectID( cgs.effects.bryarWallImpactEffect2, origin, normal, -1, -1 );
+		break;
+
+	default:
+		trap_FX_PlayEffectID( cgs.effects.bryarWallImpactEffect, origin, normal, -1, -1 );
+		break;
+	}
+}
+
+/*
+-------------------------
+FX_BryarAltHitPlayer
+-------------------------
+*/
+void FX_BryarAltHitPlayer( vec3_t origin, vec3_t normal, qboolean humanoid )
+{
+	if ( humanoid )
+	{
+		trap_FX_PlayEffectID( cgs.effects.bryarFleshImpactEffect, origin, normal, -1, -1 );
+	}
+	else
+	{
+		trap_FX_PlayEffectID( cgs.effects.bryarDroidImpactEffect, origin, normal, -1, -1 );
+	}
+}
+
+
+//TURRET
+/*
+-------------------------
+FX_TurretProjectileThink
+-------------------------
+*/
+void FX_TurretProjectileThink(  centity_t *cent, const struct weaponInfo_s *weapon )
+{
+	vec3_t forward;
+
+	if ( VectorNormalize2( cent->currentState.pos.trDelta, forward ) == 0.0f )
+	{
+		forward[2] = 1.0f;
+	}
+
+	trap_FX_PlayEffectID( cgs.effects.turretShotEffect, cent->lerpOrigin, forward, -1, -1 );
+}
+
+/*
+-------------------------
+FX_TurretHitWall
+-------------------------
+*/
+void FX_TurretHitWall( vec3_t origin, vec3_t normal )
+{
+	trap_FX_PlayEffectID( cgs.effects.bryarWallImpactEffect, origin, normal, -1, -1 );
+}
+
+/*
+-------------------------
+FX_TurretHitPlayer
+-------------------------
+*/
+void FX_TurretHitPlayer( vec3_t origin, vec3_t normal, qboolean humanoid )
+{
+	if ( humanoid )
+	{
+		trap_FX_PlayEffectID( cgs.effects.bryarFleshImpactEffect, origin, normal, -1, -1 );
+	}
+	else
+	{
+		trap_FX_PlayEffectID( cgs.effects.bryarDroidImpactEffect, origin, normal, -1, -1 );
+	}
+}
+
+
+
+//CONCUSSION (yeah, should probably make a new file for this.. or maybe just move all these stupid semi-redundant fx_ functions into one file)
+/*
+-------------------------
+FX_ConcussionHitWall
+-------------------------
+*/
+void FX_ConcussionHitWall( vec3_t origin, vec3_t normal )
+{
+	trap_FX_PlayEffectID( cgs.effects.concussionImpactEffect, origin, normal, -1, -1 );
+}
+
+/*
+-------------------------
+FX_ConcussionHitPlayer
+-------------------------
+*/
+void FX_ConcussionHitPlayer( vec3_t origin, vec3_t normal, qboolean humanoid )
+{
+	trap_FX_PlayEffectID( cgs.effects.concussionImpactEffect, origin, normal, -1, -1 );
+}
+
+/*
+-------------------------
+FX_ConcussionProjectileThink
+-------------------------
+*/
+void FX_ConcussionProjectileThink(  centity_t *cent, const struct weaponInfo_s *weapon )
+{
+	vec3_t forward;
+
+	if ( VectorNormalize2( cent->currentState.pos.trDelta, forward ) == 0.0f )
+	{
+		forward[2] = 1.0f;
+	}
+
+	trap_FX_PlayEffectID( cgs.effects.concussionShotEffect, cent->lerpOrigin, forward, -1, -1 );
+}
+
+/*
+---------------------------
+FX_ConcAltShot
+---------------------------
+*/
+static vec3_t WHITE	={1.0f,1.0f,1.0f};
+static vec3_t BRIGHT={0.75f,0.5f,1.0f};
+
+void FX_ConcAltShot( vec3_t start, vec3_t end )
+{
+	//"concussion/beam"
+	trap_FX_AddLine( start, end, 0.1f, 10.0f, 0.0f, 
+							1.0f, 0.0f, 0.0f,
+							WHITE, WHITE, 0.0f,
+							175, trap_R_RegisterShader( "gfx/effects/blueLine" ), 
+							FX_SIZE_LINEAR | FX_ALPHA_LINEAR );
+
+	// add some beef
+	trap_FX_AddLine( start, end, 0.1f, 7.0f, 0.0f, 
+						1.0f, 0.0f, 0.0f,
+						BRIGHT, BRIGHT, 0.0f,
+						150, trap_R_RegisterShader( "gfx/misc/whiteline2" ), 
+						FX_SIZE_LINEAR | FX_ALPHA_LINEAR );
+}
diff --git a/codemp/cgame/fx_demp2.c b/codemp/cgame/fx_demp2.c
new file mode 100644
index 0000000..ff3376c
--- /dev/null
+++ b/codemp/cgame/fx_demp2.c
@@ -0,0 +1,259 @@
+// DEMP2 Weapon
+
+#include "cg_local.h"
+
+/*
+---------------------------
+FX_DEMP2_ProjectileThink
+---------------------------
+*/
+
+void FX_DEMP2_ProjectileThink( centity_t *cent, const struct weaponInfo_s *weapon )
+{
+	vec3_t forward;
+
+	if ( VectorNormalize2( cent->currentState.pos.trDelta, forward ) == 0.0f )
+	{
+		forward[2] = 1.0f;
+	}
+
+	trap_FX_PlayEffectID( cgs.effects.demp2ProjectileEffect, cent->lerpOrigin, forward, -1, -1 );
+}
+
+/*
+---------------------------
+FX_DEMP2_HitWall
+---------------------------
+*/
+
+void FX_DEMP2_HitWall( vec3_t origin, vec3_t normal )
+{
+	trap_FX_PlayEffectID( cgs.effects.demp2WallImpactEffect, origin, normal, -1, -1 );
+}
+
+/*
+---------------------------
+FX_DEMP2_HitPlayer
+---------------------------
+*/
+
+void FX_DEMP2_HitPlayer( vec3_t origin, vec3_t normal, qboolean humanoid )
+{
+	trap_FX_PlayEffectID( cgs.effects.demp2FleshImpactEffect, origin, normal, -1, -1 );
+}
+
+/*
+---------------------------
+FX_DEMP2_AltBeam
+---------------------------
+*/
+void FX_DEMP2_AltBeam( vec3_t start, vec3_t end, vec3_t normal, //qboolean spark, 
+								vec3_t targ1, vec3_t targ2 )
+{
+//NOTENOTE Fix this after trap calls for all primitives are created.
+/*
+	vec3_t	dir, chaos,
+			c1, c2,
+			v1, v2;
+	float	len,
+			s1, s2, s3;
+
+	VectorSubtract( end, start, dir );
+	len = VectorNormalize( dir );
+
+	// Get the base control points, we'll work from there
+	VectorMA( start, 0.3333f * len, dir, c1 );
+	VectorMA( start, 0.6666f * len, dir, c2 );
+
+	// get some chaos values that really aren't very chaotic :)
+	s1 = sin( cg.time * 0.005f ) * 2 + crandom() * 0.2f;
+	s2 = sin( cg.time * 0.001f );
+	s3 = sin( cg.time * 0.011f );
+
+	VectorSet( chaos, len * 0.01f * s1,
+						len * 0.02f * s2,
+						len * 0.04f * (s1 + s2 + s3));
+
+	VectorAdd( c1, chaos, c1 );
+	VectorScale( chaos, 4.0f, v1 );
+
+	VectorSet( chaos, -len * 0.02f * s3,
+						len * 0.01f * (s1 * s2),
+						-len * 0.02f * (s1 + s2 * s3));
+
+	VectorAdd( c2, chaos, c2 );
+	VectorScale( chaos, 2.0f, v2 );
+
+	VectorSet( chaos, 1.0f, 1.0f, 1.0f );
+
+	FX_AddBezier( start, targ1,
+						c1, v1, c2, v2, 
+						5.0f + s1 * 2, 8.0f, 0.0f, 
+						1.0f, 0.0f, 0.0f,
+						chaos, chaos, 0.0f,
+						1.0f, trap_R_RegisterShader( "gfx/misc/electric2" ), FX_ALPHA_LINEAR );
+
+	FX_AddBezier( start, targ1,
+						c2, v2, c1, v1, 
+						3.0f + s3, 3.0f, 0.0f, 
+						1.0f, 0.0f, 0.0f,
+						chaos, chaos, 0.0f,
+						1.0f, trap_R_RegisterShader( "gfx/misc/electric2" ), FX_ALPHA_LINEAR );
+
+	s1 = sin( cg.time * 0.0005f ) + crandom() * 0.1f;
+	s2 = sin( cg.time * 0.0025f );
+	float cc2 = cos( cg.time * 0.0025f );
+	s3 = sin( cg.time * 0.01f ) + crandom() * 0.1f;
+
+	VectorSet( chaos, len * 0.08f * s2,
+						len * 0.04f * cc2,//s1 * -s3,
+						len * 0.06f * s3 );
+
+	VectorAdd( c1, chaos, c1 );
+	VectorScale( chaos, 4.0f, v1 );
+
+	VectorSet( chaos, len * 0.02f * s1 * s3,
+						len * 0.04f * s2,
+						len * 0.03f * s1 * s2 );
+
+	VectorAdd( c2, chaos, c2 );
+	VectorScale( chaos, 3.0f, v2 );
+
+	VectorSet( chaos, 1.0f, 1.0f, 1.0f );
+
+	FX_AddBezier( start, targ1,
+						c1, v1, c2, v2, 
+						4.0f + s3, 8.0f, 0.0f, 
+						1.0f, 0.0f, 0.0f,
+						chaos, chaos, 0.0f,
+						1.0f, trap_R_RegisterShader( "gfx/misc/electric2" ), FX_ALPHA_LINEAR );
+
+	FX_AddBezier( start, targ1,
+						c2, v1, c1, v2, 
+						5.0f + s1 * 2, 8.0f, 0.0f, 
+						1.0f, 0.0f, 0.0f,
+						chaos, chaos, 0.0f,
+						1.0f, trap_R_RegisterShader( "gfx/misc/electric2" ), FX_ALPHA_LINEAR );
+
+
+	VectorMA( start, 14.0f, dir, c1 );
+
+	FX_AddSprite( c1, NULL, NULL, 12.0f + crandom() * 4, 0.0f, 1.0f, 1.0f, random() * 360, 0.0f, 1.0f, 
+						trap_R_RegisterShader( "gfx/misc/lightningFlash" ));
+	FX_AddSprite( c1, NULL, NULL, 6.0f + crandom() * 2, 0.0f, 1.0f, 1.0f, random() * 360, 0.0f, 1.0f, 
+						trap_R_RegisterShader( "gfx/misc/lightningFlash" ));
+
+	FX_AddSprite( targ1, NULL, NULL, 4.0f + crandom(), 0.0f, 1.0f, 0.0f, chaos, chaos, random() * 360, 0.0f, 10, 
+						trap_R_RegisterShader( "gfx/misc/lightningFlash" ));
+	FX_AddSprite( targ1, NULL, NULL, 8.0f + crandom() * 2, 0.0f, 1.0f, 0.0f, chaos, chaos, random() * 360, 0.0f, 10, 
+						trap_R_RegisterShader( "gfx/misc/lightningFlash" ));
+
+
+	//--------------------------------------------
+
+	VectorSubtract( targ2, targ1, dir );
+	len = VectorNormalize( dir );
+
+	// Get the base control points, we'll work from there
+	VectorMA( targ1, 0.3333f * len, dir, c1 );
+	VectorMA( targ1, 0.6666f * len, dir, c2 );
+
+	// get some chaos values that really aren't very chaotic :)
+	s1 = sin( cg.time * 0.005f ) * 2 + crandom() * 0.2f;
+	s2 = sin( cg.time * 0.001f );
+	s3 = sin( cg.time * 0.011f );
+
+	VectorSet( chaos, len * 0.01f * s1,
+						len * 0.02f * s2,
+						len * 0.04f * (s1 + s2 + s3));
+
+	VectorAdd( c1, chaos, c1 );
+	VectorScale( chaos, 4.0f, v1 );
+
+	VectorSet( chaos, -len * 0.02f * s3,
+						len * 0.01f * (s1 * s2),
+						-len * 0.02f * (s1 + s2 * s3));
+
+	VectorAdd( c2, chaos, c2 );
+	VectorScale( chaos, 2.0f, v2 );
+
+	VectorSet( chaos, 1.0f, 1.0f, 1.0f );
+
+	FX_AddBezier( targ1, targ2,
+						c1, v1, c2, v2, 
+						5.0f + s1 * 2, 8.0f, 0.0f, 
+						1.0f, 0.0f, 0.0f,
+						chaos, chaos, 0.0f,
+						1.0f, trap_R_RegisterShader( "gfx/misc/electric2" ), FX_ALPHA_LINEAR );
+
+	FX_AddBezier( targ1, targ2,
+						c2, v2, c1, v1, 
+						3.0f + s3, 3.0f, 0.0f, 
+						1.0f, 0.0f, 0.0f,
+						chaos, chaos, 0.0f,
+						1.0f, trap_R_RegisterShader( "gfx/misc/electric2" ), FX_ALPHA_LINEAR );
+
+	s1 = sin( cg.time * 0.0005f ) + crandom() * 0.1f;
+	s2 = sin( cg.time * 0.0025f );
+	cc2 = cos( cg.time * 0.0025f );
+	s3 = sin( cg.time * 0.01f ) + crandom() * 0.1f;
+
+	VectorSet( chaos, len * 0.08f * s2,
+						len * 0.04f * cc2,//s1 * -s3,
+						len * 0.06f * s3 );
+
+	VectorAdd( c1, chaos, c1 );
+	VectorScale( chaos, 4.0f, v1 );
+
+	VectorSet( chaos, len * 0.02f * s1 * s3,
+						len * 0.04f * s2,
+						len * 0.03f * s1 * s2 );
+
+	VectorAdd( c2, chaos, c2 );
+	VectorScale( chaos, 3.0f, v2 );
+
+	VectorSet( chaos, 1.0f, 1.0f, 1.0f );
+
+	FX_AddBezier( targ1, targ2,
+						c1, v1, c2, v2, 
+						4.0f + s3, 8.0f, 0.0f, 
+						1.0f, 0.0f, 0.0f,
+						chaos, chaos, 0.0f,
+						1.0f, trap_R_RegisterShader( "gfx/misc/electric2" ), FX_ALPHA_LINEAR );
+
+	FX_AddBezier( targ1, targ2,
+						c2, v1, c1, v2, 
+						5.0f + s1 * 2, 8.0f, 0.0f, 
+						1.0f, 0.0f, 0.0f,
+						chaos, chaos, 0.0f,
+						1.0f, trap_R_RegisterShader( "gfx/misc/electric2" ), FX_ALPHA_LINEAR );
+
+
+	FX_AddSprite( targ2, NULL, NULL, 4.0f + crandom(), 0.0f, 1.0f, 0.0f, chaos, chaos, random() * 360, 0.0f, 10, 
+						trap_R_RegisterShader( "gfx/misc/lightningFlash" ));
+	FX_AddSprite( targ2, NULL, NULL, 8.0f + crandom() * 2, 0.0f, 1.0f, 0.0f, chaos, chaos, random() * 360, 0.0f, 10, 
+						trap_R_RegisterShader( "gfx/misc/lightningFlash" ));
+*/
+}
+
+//---------------------------------------------
+void FX_DEMP2_AltDetonate( vec3_t org, float size )
+{
+	localEntity_t	*ex;
+
+	ex = CG_AllocLocalEntity();
+	ex->leType = LE_FADE_SCALE_MODEL;
+	memset( &ex->refEntity, 0, sizeof( refEntity_t ));
+
+	ex->refEntity.renderfx |= RF_VOLUMETRIC;
+
+	ex->startTime = cg.time;
+	ex->endTime = ex->startTime + 800;//1600;
+	
+	ex->radius = size;
+	ex->refEntity.customShader = cgs.media.demp2ShellShader;
+	ex->refEntity.hModel = cgs.media.demp2Shell;
+	VectorCopy( org, ex->refEntity.origin );
+		
+	ex->color[0] = ex->color[1] = ex->color[2] = 255.0f;
+}
diff --git a/codemp/cgame/fx_disruptor.c b/codemp/cgame/fx_disruptor.c
new file mode 100644
index 0000000..21b8d12
--- /dev/null
+++ b/codemp/cgame/fx_disruptor.c
@@ -0,0 +1,148 @@
+// Disruptor Weapon
+
+#include "cg_local.h"
+#include "fx_local.h"
+
+/*
+---------------------------
+FX_DisruptorMainShot
+---------------------------
+*/
+static vec3_t WHITE={1.0f,1.0f,1.0f};
+
+void FX_DisruptorMainShot( vec3_t start, vec3_t end )
+{
+//	vec3_t	dir;
+//	float	len;
+
+	trap_FX_AddLine( start, end, 0.1f, 6.0f, 0.0f, 
+							1.0f, 0.0f, 0.0f,
+							WHITE, WHITE, 0.0f,
+							150, trap_R_RegisterShader( "gfx/effects/redLine" ), 
+							FX_SIZE_LINEAR | FX_ALPHA_LINEAR );
+
+//	VectorSubtract( end, start, dir );
+//	len = VectorNormalize( dir );
+
+//	FX_AddCylinder( start, dir, 5.0f, 5.0f, 0.0f,
+//								5.0f, 5.0f, 0.0f,
+//								len, len, 0.0f,
+//								1.0f, 1.0f, 0.0f,
+//								WHITE, WHITE, 0.0f,
+//								400, cgi_R_RegisterShader( "gfx/effects/spiral" ), 0 );
+}
+
+
+/*
+---------------------------
+FX_DisruptorAltShot
+---------------------------
+*/
+void FX_DisruptorAltShot( vec3_t start, vec3_t end, qboolean fullCharge )
+{
+	trap_FX_AddLine( start, end, 0.1f, 10.0f, 0.0f, 
+							1.0f, 0.0f, 0.0f,
+							WHITE, WHITE, 0.0f,
+							175, trap_R_RegisterShader( "gfx/effects/redLine" ), 
+							FX_SIZE_LINEAR | FX_ALPHA_LINEAR );
+
+	if ( fullCharge )
+	{
+		vec3_t	YELLER={0.8f,0.7f,0.0f};
+
+		// add some beef
+		trap_FX_AddLine( start, end, 0.1f, 7.0f, 0.0f, 
+							1.0f, 0.0f, 0.0f,
+							YELLER, YELLER, 0.0f,
+							150, trap_R_RegisterShader( "gfx/misc/whiteline2" ), 
+							FX_SIZE_LINEAR | FX_ALPHA_LINEAR );
+	}
+}
+
+
+/*
+---------------------------
+FX_DisruptorAltMiss
+---------------------------
+*/
+#define FX_ALPHA_WAVE		0x00000008
+
+void FX_DisruptorAltMiss( vec3_t origin, vec3_t normal )
+{
+	vec3_t pos, c1, c2;
+	addbezierArgStruct_t b;
+
+	VectorMA( origin, 4.0f, normal, c1 );
+	VectorCopy( c1, c2 );
+	c1[2] += 4;
+	c2[2] += 12;
+	
+	VectorAdd( origin, normal, pos );
+	pos[2] += 28;
+
+	/*
+	FX_AddBezier( origin, pos, c1, vec3_origin, c2, vec3_origin, 6.0f, 6.0f, 0.0f, 0.0f, 0.2f, 0.5f,
+	WHITE, WHITE, 0.0f, 4000, trap_R_RegisterShader( "gfx/effects/smokeTrail" ), FX_ALPHA_WAVE );
+	*/
+
+	VectorCopy(origin, b.start);
+	VectorCopy(pos, b.end);
+	VectorCopy(c1, b.control1);
+	VectorCopy(vec3_origin, b.control1Vel);
+	VectorCopy(c2, b.control2);
+	VectorCopy(vec3_origin, b.control2Vel);
+
+	b.size1 = 6.0f;
+	b.size2 = 6.0f;
+	b.sizeParm = 0.0f;
+	b.alpha1 = 0.0f;
+	b.alpha2 = 0.2f;
+	b.alphaParm = 0.5f;
+	
+	VectorCopy(WHITE, b.sRGB);
+	VectorCopy(WHITE, b.eRGB);
+
+	b.rgbParm = 0.0f;
+	b.killTime = 4000;
+	b.shader = trap_R_RegisterShader( "gfx/effects/smokeTrail" );
+	b.flags = FX_ALPHA_WAVE;
+
+	trap_FX_AddBezier(&b);
+
+	trap_FX_PlayEffectID( cgs.effects.disruptorAltMissEffect, origin, normal, -1, -1 );
+}
+
+/*
+---------------------------
+FX_DisruptorAltHit
+---------------------------
+*/
+
+void FX_DisruptorAltHit( vec3_t origin, vec3_t normal )
+{
+	trap_FX_PlayEffectID( cgs.effects.disruptorAltHitEffect, origin, normal, -1, -1 );
+}
+
+
+
+/*
+---------------------------
+FX_DisruptorHitWall
+---------------------------
+*/
+
+void FX_DisruptorHitWall( vec3_t origin, vec3_t normal )
+{
+	trap_FX_PlayEffectID( cgs.effects.disruptorWallImpactEffect, origin, normal, -1, -1 );
+}
+
+/*
+---------------------------
+FX_DisruptorHitPlayer
+---------------------------
+*/
+
+void FX_DisruptorHitPlayer( vec3_t origin, vec3_t normal, qboolean humanoid )
+{
+	trap_FX_PlayEffectID( cgs.effects.disruptorFleshImpactEffect, origin, normal, -1, -1 );
+}
diff --git a/codemp/cgame/fx_flechette.c b/codemp/cgame/fx_flechette.c
new file mode 100644
index 0000000..a2a722d
--- /dev/null
+++ b/codemp/cgame/fx_flechette.c
@@ -0,0 +1,67 @@
+// Golan Arms Flechette Weapon
+
+#include "cg_local.h"
+
+/*
+-------------------------
+FX_FlechetteProjectileThink
+-------------------------
+*/
+
+void FX_FlechetteProjectileThink( centity_t *cent, const struct weaponInfo_s *weapon )
+{
+	vec3_t forward;
+
+	if ( VectorNormalize2( cent->currentState.pos.trDelta, forward ) == 0.0f )
+	{
+		forward[2] = 1.0f;
+	}
+
+	trap_FX_PlayEffectID( cgs.effects.flechetteShotEffect, cent->lerpOrigin, forward, -1, -1 );
+}
+
+/*
+-------------------------
+FX_FlechetteWeaponHitWall
+-------------------------
+*/
+void FX_FlechetteWeaponHitWall( vec3_t origin, vec3_t normal )
+{
+	trap_FX_PlayEffectID( cgs.effects.flechetteWallImpactEffect, origin, normal, -1, -1 );
+}
+
+/*
+-------------------------
+FX_FlechetteWeaponHitPlayer
+-------------------------
+*/
+void FX_FlechetteWeaponHitPlayer( vec3_t origin, vec3_t normal, qboolean humanoid )
+{
+//	if ( humanoid )
+//	{
+		trap_FX_PlayEffectID( cgs.effects.flechetteFleshImpactEffect, origin, normal, -1, -1 );
+//	}
+//	else
+//	{
+//		trap_FX_PlayEffect( "blaster/droid_impact", origin, normal );
+//	}
+}
+
+
+/*
+-------------------------
+FX_FlechetteProjectileThink
+-------------------------
+*/
+
+void FX_FlechetteAltProjectileThink( centity_t *cent, const struct weaponInfo_s *weapon )
+{
+	vec3_t forward;
+
+	if ( VectorNormalize2( cent->currentState.pos.trDelta, forward ) == 0.0f )
+	{
+		forward[2] = 1.0f;
+	}
+
+	trap_FX_PlayEffectID( cgs.effects.flechetteAltShotEffect, cent->lerpOrigin, forward, -1, -1 );
+}
diff --git a/codemp/cgame/fx_force.c b/codemp/cgame/fx_force.c
new file mode 100644
index 0000000..1e8ec3e
--- /dev/null
+++ b/codemp/cgame/fx_force.c
@@ -0,0 +1,16 @@
+// Any dedicated force oriented effects
+
+#include "cg_local.h"
+
+/*
+-------------------------
+FX_ForceDrained
+-------------------------
+*/
+// This effect is not generic because of possible enhancements
+void FX_ForceDrained(vec3_t origin, vec3_t dir)
+{
+	VectorScale(dir, -1.0, dir);
+	trap_FX_PlayEffectID(cgs.effects.forceDrained, origin, dir, -1, -1);
+}
+	
diff --git a/codemp/cgame/fx_heavyrepeater.c b/codemp/cgame/fx_heavyrepeater.c
new file mode 100644
index 0000000..d0c852f
--- /dev/null
+++ b/codemp/cgame/fx_heavyrepeater.c
@@ -0,0 +1,155 @@
+// Heavy Repeater Weapon
+
+#include "cg_local.h"
+
+/*
+---------------------------
+FX_RepeaterProjectileThink
+---------------------------
+*/
+
+void FX_RepeaterProjectileThink( centity_t *cent, const struct weaponInfo_s *weapon )
+{
+	vec3_t forward;
+
+	if ( VectorNormalize2( cent->currentState.pos.trDelta, forward ) == 0.0f )
+	{
+		forward[2] = 1.0f;
+	}
+
+	trap_FX_PlayEffectID( cgs.effects.repeaterProjectileEffect, cent->lerpOrigin, forward, -1, -1 );
+}
+
+/*
+------------------------
+FX_RepeaterHitWall
+------------------------
+*/
+
+void FX_RepeaterHitWall( vec3_t origin, vec3_t normal )
+{
+	trap_FX_PlayEffectID( cgs.effects.repeaterWallImpactEffect, origin, normal, -1, -1 );
+}
+
+/*
+------------------------
+FX_RepeaterHitPlayer
+------------------------
+*/
+
+void FX_RepeaterHitPlayer( vec3_t origin, vec3_t normal, qboolean humanoid )
+{
+	trap_FX_PlayEffectID( cgs.effects.repeaterFleshImpactEffect, origin, normal, -1, -1 );
+}
+
+static void CG_DistortionOrb( centity_t *cent )
+{
+	refEntity_t ent;
+	vec3_t ang;
+	float scale = 0.5f;
+	float vLen;
+
+	if (!cg_renderToTextureFX.integer)
+	{
+		return;
+	}
+	memset( &ent, 0, sizeof( ent ) );
+
+	VectorCopy( cent->lerpOrigin, ent.origin );
+
+	VectorSubtract(ent.origin, cg.refdef.vieworg, ent.axis[0]);
+	vLen = VectorLength(ent.axis[0]);
+	if (VectorNormalize(ent.axis[0]) <= 0.1f)
+	{	// Entity is right on vieworg.  quit.
+		return;
+	}
+
+//	VectorCopy(cg.refdef.viewaxis[2], ent.axis[2]);
+//	CrossProduct(ent.axis[0], ent.axis[2], ent.axis[1]);
+	vectoangles(ent.axis[0], ang);
+	ang[ROLL] = cent->trickAlpha;
+	cent->trickAlpha += 16; //spin the half-sphere to give a "screwdriver" effect
+	AnglesToAxis(ang, ent.axis);
+
+	//radius must be a power of 2, and is the actual captured texture size
+	if (vLen < 128)
+	{
+		ent.radius = 256;
+	}
+	else if (vLen < 256)
+	{
+		ent.radius = 128;
+	}
+	else if (vLen < 512)
+	{
+		ent.radius = 64;
+	}
+	else
+	{
+		ent.radius = 32;
+	}
+
+	VectorScale(ent.axis[0], scale, ent.axis[0]);
+	VectorScale(ent.axis[1], scale, ent.axis[1]);
+	VectorScale(ent.axis[2], -scale, ent.axis[2]);
+
+	ent.hModel = cgs.media.halfShieldModel;
+	ent.customShader = 0;//cgs.media.halfShieldShader;	
+
+#if 1
+	ent.renderfx = (RF_DISTORTION|RF_RGB_TINT);
+
+	//tint the whole thing a shade of blue
+	ent.shaderRGBA[0] = 200.0f;
+	ent.shaderRGBA[1] = 200.0f;
+	ent.shaderRGBA[2] = 255.0f;
+#else //no tint
+	ent.renderfx = RF_DISTORTION;
+#endif
+
+	trap_R_AddRefEntityToScene( &ent );
+}
+
+/*
+------------------------------
+FX_RepeaterAltProjectileThink
+-----------------------------
+*/
+
+void FX_RepeaterAltProjectileThink( centity_t *cent, const struct weaponInfo_s *weapon )
+{
+	vec3_t forward;
+
+	if ( VectorNormalize2( cent->currentState.pos.trDelta, forward ) == 0.0f )
+	{
+		forward[2] = 1.0f;
+	}
+
+	if (cg_repeaterOrb.integer)
+	{
+		CG_DistortionOrb(cent);
+	}
+	trap_FX_PlayEffectID( cgs.effects.repeaterAltProjectileEffect, cent->lerpOrigin, forward, -1, -1 );
+}
+
+/*
+------------------------
+FX_RepeaterAltHitWall
+------------------------
+*/
+
+void FX_RepeaterAltHitWall( vec3_t origin, vec3_t normal )
+{
+	trap_FX_PlayEffectID( cgs.effects.repeaterAltWallImpactEffect, origin, normal, -1, -1 );
+}
+
+/*
+------------------------
+FX_RepeaterAltHitPlayer
+------------------------
+*/
+
+void FX_RepeaterAltHitPlayer( vec3_t origin, vec3_t normal, qboolean humanoid )
+{
+	trap_FX_PlayEffectID( cgs.effects.repeaterAltWallImpactEffect, origin, normal, -1, -1 );
+}
diff --git a/codemp/cgame/fx_local.h b/codemp/cgame/fx_local.h
new file mode 100644
index 0000000..04dee62
--- /dev/null
+++ b/codemp/cgame/fx_local.h
@@ -0,0 +1,63 @@
+//
+// fx_*.c
+//
+
+// NOTENOTE This is not the best, DO NOT CHANGE THESE!
+#define	FX_ALPHA_LINEAR		0x00000001
+#define	FX_SIZE_LINEAR		0x00000100
+
+
+
+// Bryar
+void FX_BryarProjectileThink(  centity_t *cent, const struct weaponInfo_s *weapon );
+void FX_BryarAltProjectileThink(  centity_t *cent, const struct weaponInfo_s *weapon );
+void FX_BryarHitWall( vec3_t origin, vec3_t normal );
+void FX_BryarAltHitWall( vec3_t origin, vec3_t normal, int power );
+void FX_BryarHitPlayer( vec3_t origin, vec3_t normal, qboolean humanoid );
+void FX_BryarAltHitPlayer( vec3_t origin, vec3_t normal, qboolean humanoid );
+
+// Blaster
+void FX_BlasterProjectileThink( centity_t *cent, const struct weaponInfo_s *weapon );
+void FX_BlasterAltFireThink( centity_t *cent, const struct weaponInfo_s *weapon );
+void FX_BlasterWeaponHitWall( vec3_t origin, vec3_t normal );
+void FX_BlasterWeaponHitPlayer( vec3_t origin, vec3_t normal, qboolean humanoid );
+
+// Disruptor
+void FX_DisruptorMainShot( vec3_t start, vec3_t end );
+void FX_DisruptorAltShot( vec3_t start, vec3_t end, qboolean fullCharge );
+void FX_DisruptorAltMiss( vec3_t origin, vec3_t normal );
+void FX_DisruptorAltHit( vec3_t origin, vec3_t normal );
+void FX_DisruptorHitWall( vec3_t origin, vec3_t normal );
+void FX_DisruptorHitPlayer( vec3_t origin, vec3_t normal, qboolean humanoid );
+
+// Bowcaster
+void FX_BowcasterProjectileThink( centity_t *cent, const struct weaponInfo_s *weapon );
+void FX_BowcasterAltProjectileThink( centity_t *cent, const struct weaponInfo_s *weapon );
+void FX_BowcasterHitWall( vec3_t origin, vec3_t normal );
+void FX_BowcasterHitPlayer( vec3_t origin, vec3_t normal, qboolean humanoid );
+
+// Heavy Repeater
+void FX_RepeaterProjectileThink( centity_t *cent, const struct weaponInfo_s *weapon );
+void FX_RepeaterAltProjectileThink( centity_t *cent, const struct weaponInfo_s *weapon );
+void FX_RepeaterHitWall( vec3_t origin, vec3_t normal );
+void FX_RepeaterAltHitWall( vec3_t origin, vec3_t normal );
+void FX_RepeaterHitPlayer( vec3_t origin, vec3_t normal, qboolean humanoid );
+void FX_RepeaterAltHitPlayer( vec3_t origin, vec3_t normal, qboolean humanoid );
+
+// DEMP2
+void FX_DEMP2_ProjectileThink( centity_t *cent, const struct weaponInfo_s *weapon );
+void FX_DEMP2_HitWall( vec3_t origin, vec3_t normal );
+void FX_DEMP2_HitPlayer( vec3_t origin, vec3_t normal, qboolean humanoid );
+void FX_DEMP2_AltDetonate( vec3_t org, float size );
+
+// Golan Arms Flechette
+void FX_FlechetteProjectileThink( centity_t *cent, const struct weaponInfo_s *weapon );
+void FX_FlechetteWeaponHitWall( vec3_t origin, vec3_t normal );
+void FX_FlechetteWeaponHitPlayer( vec3_t origin, vec3_t normal, qboolean humanoid );
+void FX_FlechetteAltProjectileThink( centity_t *cent, const struct weaponInfo_s *weapon );
+
+// Personal Rocket Launcher
+void FX_RocketProjectileThink( centity_t *cent, const struct weaponInfo_s *weapon );
+void FX_RocketAltProjectileThink( centity_t *cent, const struct weaponInfo_s *weapon );
+void FX_RocketHitWall( vec3_t origin, vec3_t normal );
+void FX_RocketHitPlayer( vec3_t origin, vec3_t normal, qboolean humanoid );
diff --git a/codemp/cgame/fx_rocketlauncher.c b/codemp/cgame/fx_rocketlauncher.c
new file mode 100644
index 0000000..1054787
--- /dev/null
+++ b/codemp/cgame/fx_rocketlauncher.c
@@ -0,0 +1,61 @@
+// Rocket Launcher Weapon
+
+#include "cg_local.h"
+
+/*
+---------------------------
+FX_RocketProjectileThink
+---------------------------
+*/
+
+void FX_RocketProjectileThink( centity_t *cent, const struct weaponInfo_s *weapon )
+{
+	vec3_t forward;
+
+	if ( VectorNormalize2( cent->currentState.pos.trDelta, forward ) == 0.0f )
+	{
+		forward[2] = 1.0f;
+	}
+
+	trap_FX_PlayEffectID( cgs.effects.rocketShotEffect, cent->lerpOrigin, forward, -1, -1 );
+}
+
+/*
+---------------------------
+FX_RocketHitWall
+---------------------------
+*/
+
+void FX_RocketHitWall( vec3_t origin, vec3_t normal )
+{
+	trap_FX_PlayEffectID( cgs.effects.rocketExplosionEffect, origin, normal, -1, -1 );
+}
+
+/*
+---------------------------
+FX_RocketHitPlayer
+---------------------------
+*/
+
+void FX_RocketHitPlayer( vec3_t origin, vec3_t normal, qboolean humanoid )
+{
+	trap_FX_PlayEffectID( cgs.effects.rocketExplosionEffect, origin, normal, -1, -1 );
+}
+
+/*
+---------------------------
+FX_RocketAltProjectileThink
+---------------------------
+*/
+
+void FX_RocketAltProjectileThink( centity_t *cent, const struct weaponInfo_s *weapon )
+{
+	vec3_t forward;
+
+	if ( VectorNormalize2( cent->currentState.pos.trDelta, forward ) == 0.0f )
+	{
+		forward[2] = 1.0f;
+	}
+
+	trap_FX_PlayEffectID( cgs.effects.rocketShotEffect, cent->lerpOrigin, forward, -1, -1 );
+}
diff --git a/codemp/cgame/holocronicons.h b/codemp/cgame/holocronicons.h
new file mode 100644
index 0000000..44c76de
--- /dev/null
+++ b/codemp/cgame/holocronicons.h
@@ -0,0 +1,24 @@
+#if defined(_XBOX) && defined(_UI)
+extern char *HolocronIcons[];
+#else
+char *HolocronIcons[] = {
+	"gfx/mp/f_icon_lt_heal",		//FP_HEAL,
+	"gfx/mp/f_icon_levitation",		//FP_LEVITATION,
+	"gfx/mp/f_icon_speed",			//FP_SPEED,
+	"gfx/mp/f_icon_push",			//FP_PUSH,
+	"gfx/mp/f_icon_pull",			//FP_PULL,
+	"gfx/mp/f_icon_lt_telepathy",	//FP_TELEPATHY,
+	"gfx/mp/f_icon_dk_grip",		//FP_GRIP,
+	"gfx/mp/f_icon_dk_l1",			//FP_LIGHTNING,
+	"gfx/mp/f_icon_dk_rage",		//FP_RAGE,
+	"gfx/mp/f_icon_lt_protect",		//FP_PROTECT,
+	"gfx/mp/f_icon_lt_absorb",		//FP_ABSORB,
+	"gfx/mp/f_icon_lt_healother",	//FP_TEAM_HEAL,
+	"gfx/mp/f_icon_dk_forceother",	//FP_TEAM_FORCE,
+	"gfx/mp/f_icon_dk_drain",		//FP_DRAIN,
+	"gfx/mp/f_icon_sight",			//FP_SEE,
+	"gfx/mp/f_icon_saber_attack",	//FP_SABER_OFFENSE,
+	"gfx/mp/f_icon_saber_defend",	//FP_SABER_DEFENSE,
+	"gfx/mp/f_icon_saber_throw"		//FP_SABERTHROW
+};
+#endif
\ No newline at end of file
diff --git a/codemp/cgame/mssccprj.scc b/codemp/cgame/mssccprj.scc
new file mode 100644
index 0000000..29690e0
--- /dev/null
+++ b/codemp/cgame/mssccprj.scc
@@ -0,0 +1,5 @@
+SCC = This is a Source Code Control file
+
+[JK2_cgame.vcproj]
+SCC_Aux_Path = "\\ravendata1\vss\central_code"
+SCC_Project_Name = "$/jedi/codemp/cgame", ICAAAAAA
diff --git a/codemp/cgame/tr_types.h b/codemp/cgame/tr_types.h
new file mode 100644
index 0000000..5570c5b
--- /dev/null
+++ b/codemp/cgame/tr_types.h
@@ -0,0 +1,339 @@
+// Copyright (C) 1999-2000 Id Software, Inc.
+//
+#ifndef __TR_TYPES_H
+#define __TR_TYPES_H
+
+
+#define	MAX_DLIGHTS		32			// can't be increased, because bit flags are used on surfaces
+#ifdef _XBOX
+#define	MAX_ENTITIES	1024		// 11 bits, can't be increased without changing drawsurf bit packing (QSORT_ENTITYNUM_SHIFT)
+#else
+#define	MAX_ENTITIES	2048		// 11 bits, can't be increased without changing drawsurf bit packing (QSORT_ENTITYNUM_SHIFT)
+#endif
+#define	MAX_MINI_ENTITIES	1024		
+
+#define	TR_WORLDENT		(MAX_ENTITIES-1)
+
+// renderfx flags
+#define	RF_MINLIGHT			0x00001	// allways have some light (viewmodel, some items)
+#define	RF_THIRD_PERSON		0x00002	// don't draw through eyes, only mirrors (player bodies, chat sprites)
+#define	RF_FIRST_PERSON		0x00004	// only draw through eyes (view weapon, damage blood blob)
+#define	RF_DEPTHHACK		0x00008	// for view weapon Z crunching
+#define RF_NODEPTH			0x00010	// No depth at all (seeing through walls)
+
+#define RF_VOLUMETRIC		0x00020	// fake volumetric shading
+
+#define	RF_NOSHADOW			0x00040	// don't add stencil shadows
+
+#define RF_LIGHTING_ORIGIN	0x00080	// use refEntity->lightingOrigin instead of refEntity->origin
+									// for lighting.  This allows entities to sink into the floor
+									// with their origin going solid, and allows all parts of a
+									// player to get the same lighting
+#define	RF_SHADOW_PLANE		0x00100	// use refEntity->shadowPlane
+#define	RF_WRAP_FRAMES		0x00200	// mod the model frames by the maxframes to allow continuous
+										// animation without needing to know the frame count
+
+#define RF_FORCE_ENT_ALPHA	0x00400 // override shader alpha settings
+#define RF_RGB_TINT			0x00800 // override shader rgb settings
+
+#define	RF_SHADOW_ONLY		0x01000	//add surfs for shadowing but don't draw them -rww
+
+#define	RF_DISTORTION		0x02000	//area distortion effect -rww
+
+#define RF_FORKED			0x04000	// override lightning to have forks
+#define RF_TAPERED			0x08000	// lightning tapers
+#define RF_GROW				0x10000	// lightning grows from start to end during its life
+
+#define RF_DISINTEGRATE1	0x20000	// does a procedural hole-ripping thing.
+#define RF_DISINTEGRATE2	0x40000	// does a procedural hole-ripping thing with scaling at the ripping point
+
+#define RF_SETANIMINDEX		0x80000	//use backEnd.currentEntity->e.skinNum for R_BindAnimatedImage
+
+#define RF_ALPHA_DEPTH		0x100000 //depth write on alpha model
+
+#define RF_FORCEPOST		0x200000 //force it to post-render -rww
+
+// refdef flags
+#define RDF_NOWORLDMODEL	1		// used for player configuration screen
+#define RDF_HYPERSPACE		4		// teleportation effect
+
+#define RDF_SKYBOXPORTAL	8
+#define RDF_DRAWSKYBOX		16		// the above marks a scene as being a 'portal sky'.  this flag says to draw it or not
+
+#define RDF_AUTOMAP			32		//means this scene is to draw the automap -rww
+#define	RDF_NOFOG			64		//no global fog in this scene (but still brush fog) -rww
+
+extern int	skyboxportal;
+extern int	drawskyboxportal;
+
+typedef byte color4ub_t[4];
+
+typedef struct {
+	vec3_t		xyz;
+	float		st[2];
+	byte		modulate[4];
+} polyVert_t;
+
+typedef struct poly_s {
+	qhandle_t			hShader;
+	int					numVerts;
+	polyVert_t			*verts;
+} poly_t;
+
+typedef enum {
+	RT_MODEL,
+	RT_POLY,
+	RT_SPRITE,
+	RT_ORIENTED_QUAD,
+	RT_BEAM,
+	RT_SABER_GLOW,
+	RT_ELECTRICITY,
+	RT_PORTALSURFACE,		// doesn't draw anything, just info for portals
+	RT_LINE,
+	RT_ORIENTEDLINE,
+	RT_CYLINDER,
+	RT_ENT_CHAIN,
+
+	RT_MAX_REF_ENTITY_TYPE
+} refEntityType_t;
+
+typedef struct miniRefEntity_s 
+{
+	refEntityType_t		reType;
+	int					renderfx;
+
+	qhandle_t			hModel;				// opaque type outside refresh
+
+	// most recent data
+	vec3_t				axis[3];			// rotation vectors
+	qboolean			nonNormalizedAxes;	// axis are not normalized, i.e. they have scale
+	vec3_t				origin;				// also used as MODEL_BEAM's "from"
+
+	// previous data for frame interpolation
+	vec3_t				oldorigin;			// also used as MODEL_BEAM's "to"
+
+	// texturing
+	qhandle_t			customShader;		// use one image for the entire thing
+
+	// misc
+	byte				shaderRGBA[4];		// colors used by rgbgen entity shaders
+	vec2_t				shaderTexCoord;		// texture coordinates used by tcMod entity modifiers
+
+	// extra sprite information
+	float				radius;
+	float				rotation;			// size 2 for RT_CYLINDER or number of verts in RT_ELECTRICITY
+
+	// misc
+	float		shaderTime;			// subtracted from refdef time to control effect start times
+	int			frame;				// also used as MODEL_BEAM's diameter
+
+} miniRefEntity_t;
+
+#pragma warning (disable : 4201 )
+typedef struct {
+	// this stucture must remain identical as the miniRefEntity_t
+	//
+	//
+	refEntityType_t		reType;
+	int					renderfx;
+
+	qhandle_t			hModel;				// opaque type outside refresh
+
+	// most recent data
+	vec3_t				axis[3];			// rotation vectors
+	qboolean			nonNormalizedAxes;	// axis are not normalized, i.e. they have scale
+	vec3_t				origin;				// also used as MODEL_BEAM's "from"
+
+	// previous data for frame interpolation
+	vec3_t				oldorigin;			// also used as MODEL_BEAM's "to"
+
+	// texturing
+	qhandle_t			customShader;		// use one image for the entire thing
+
+	// misc
+	byte				shaderRGBA[4];		// colors used by rgbgen entity shaders
+	vec2_t				shaderTexCoord;		// texture coordinates used by tcMod entity modifiers
+
+	// extra sprite information
+	float				radius;
+	float				rotation;
+
+	// misc
+	float		shaderTime;			// subtracted from refdef time to control effect start times
+	int			frame;				// also used as MODEL_BEAM's diameter
+	//
+	//
+	// end miniRefEntity_t
+
+	//
+	//
+	// specific full refEntity_t data
+	//
+	//
+
+	// most recent data
+	vec3_t		lightingOrigin;		// so multi-part models can be lit identically (RF_LIGHTING_ORIGIN)
+	float		shadowPlane;		// projection shadows go here, stencils go slightly lower
+
+	// previous data for frame interpolation
+	int			oldframe;
+	float		backlerp;			// 0.0 = current, 1.0 = old
+
+	// texturing
+	int			skinNum;			// inline skin index
+	qhandle_t	customSkin;			// NULL for default skin
+
+	// texturing
+	union	
+	{
+//		int			skinNum;		// inline skin index
+//		ivec3_t		terxelCoords;	// coords of patch for RT_TERXELS	
+		struct
+		{
+			int		miniStart;
+			int		miniCount;
+		} uMini;
+	} uRefEnt;
+
+	// extra sprite information
+	union {
+		struct 
+		{
+			float rotation;
+			float radius;
+			byte  vertRGBA[4][4];
+		} sprite;
+		struct 
+		{
+			float width;
+			float width2;
+			float stscale;
+		} line;
+		struct	// that whole put-the-opening-brace-on-the-same-line-as-the-beginning-of-the-definition coding style is fecal
+		{
+			float	width;
+			vec3_t	control1;
+			vec3_t	control2;
+		} bezier;
+		struct
+		{
+			float width;
+			float width2;
+			float stscale;
+			float height;
+			float bias;
+			qboolean wrap;
+		} cylinder;
+		struct 
+		{
+			float width;
+			float deviation;
+			float stscale;
+			qboolean wrap;
+			qboolean taper;
+		} electricity;
+	} data;
+
+	float		endTime;
+	float		saberLength;
+
+/*
+Ghoul2 Insert Start
+*/
+	vec3_t		angles;				// rotation angles - used for Ghoul2
+
+	vec3_t		modelScale;			// axis scale for models
+//	CGhoul2Info_v	*ghoul2;  		// has to be at the end of the ref-ent in order for it to be created properly
+	void		*ghoul2;  		// has to be at the end of the ref-ent in order for it to be created properly
+/*
+Ghoul2 Insert End
+*/
+} refEntity_t;
+
+
+#define	MAX_RENDER_STRINGS			8
+#define	MAX_RENDER_STRING_LENGTH	32
+
+typedef struct {
+	int			x, y, width, height;
+	float		fov_x, fov_y;
+	vec3_t		vieworg;
+	vec3_t		viewangles;
+	vec3_t		viewaxis[3];		// transformation matrix
+	int			viewContents;		// world contents at vieworg
+
+	// time in milliseconds for shader effects and other time dependent rendering issues
+	int			time;
+
+	int			rdflags;			// RDF_NOWORLDMODEL, etc
+
+	// 1 bits will prevent the associated area from rendering at all
+	byte		areamask[MAX_MAP_AREA_BYTES];
+
+	// text messages for deform text shaders
+	char		text[MAX_RENDER_STRINGS][MAX_RENDER_STRING_LENGTH];
+} refdef_t;
+
+
+typedef enum {
+	STEREO_CENTER,
+	STEREO_LEFT,
+	STEREO_RIGHT
+};
+typedef int stereoFrame_t;
+
+
+/*
+** glconfig_t
+**
+** Contains variables specific to the OpenGL configuration
+** being run right now.  These are constant once the OpenGL
+** subsystem is initialized.
+*/
+typedef enum {
+	TC_NONE,
+	TC_S3TC,
+	TC_S3TC_DXT
+} textureCompression_t;
+
+typedef struct {
+	const char				*renderer_string;
+	const char				*vendor_string;
+	const char				*version_string;
+	const char				*extensions_string;
+
+	int						maxTextureSize;			// queried from GL
+	int						maxActiveTextures;		// multitexture ability
+	float					maxTextureFilterAnisotropy;
+
+	int						colorBits, depthBits, stencilBits;
+
+	qboolean				deviceSupportsGamma;
+	textureCompression_t	textureCompression;
+	qboolean				textureEnvAddAvailable;
+	qboolean				clampToEdgeAvailable;
+
+	int						vidWidth, vidHeight;
+
+	int						displayFrequency;
+
+	// synonymous with "does rendering consume the entire screen?", therefore
+	// a Voodoo or Voodoo2 will have this set to TRUE, as will a Win32 ICD that
+	// used CDS.
+	qboolean				isFullscreen;
+	qboolean				stereoEnabled;
+} glconfig_t;
+
+
+#if !defined _WIN32
+
+#define OPENGL_DRIVER_NAME	"libGL.so"
+
+#else
+
+#define OPENGL_DRIVER_NAME	"opengl32"
+
+#endif	// !defined _WIN32
+
+
+#endif	// __TR_TYPES_H
diff --git a/codemp/cgame/vssver.scc b/codemp/cgame/vssver.scc
new file mode 100644
index 0000000..816c8ab
Binary files /dev/null and b/codemp/cgame/vssver.scc differ
diff --git a/codemp/cleanvms.bat b/codemp/cleanvms.bat
new file mode 100644
index 0000000..6935dfa
--- /dev/null
+++ b/codemp/cleanvms.bat
@@ -0,0 +1,11 @@
+set include=
+cd game
+asm2mak game makefile
+make clean
+cd ..\cgame
+asm2mak cgame makefile
+make clean
+cd ..\ui
+asm2mak ui makefile
+make clean
+cd ..
diff --git a/codemp/client/0_SH_Leak.cpp b/codemp/client/0_SH_Leak.cpp
new file mode 100644
index 0000000..5766f88
--- /dev/null
+++ b/codemp/client/0_SH_Leak.cpp
@@ -0,0 +1,412 @@
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+#pragma warning( disable : 4786) 
+#include "client.h"
+
+#include <windows.h>
+#include "..\smartheap\smrtheap.h"
+#if !defined(__Q_SHARED_H)
+	#include "../game/q_shared.h"
+#endif
+#if !defined(_QCOMMON_H_)
+	#include "../qcommon/qcommon.h"
+#endif
+#include <stdio.h>
+#include <map>
+
+using namespace std;
+
+#if MEM_DEBUG
+#include "..\smartheap\heapagnt.h"
+
+static const int maxStack=2048;
+static int TotalMem;
+static int TotalBlocks;
+static int nStack;
+static char StackNames[maxStack][256];
+static int StackSize[maxStack];
+static int StackCount[maxStack];
+static int StackCache[48];
+static int StackCacheAt=0;
+static int CheckpointSize[1000];
+static int CheckpointCount[1000];
+
+#define _FASTRPT_
+
+cvar_t	*mem_leakfile;
+cvar_t	*mem_leakreport;
+
+MEM_BOOL MEM_CALLBACK MyMemReporter2(MEM_ERROR_INFO *info)
+{
+	static char buffer[10000];
+	if (!info->objectCreationInfo)
+		return 1;
+	info=info->objectCreationInfo;
+	int idx=info->checkpoint;
+	if (idx<0||idx>=1000)
+	{
+		idx=0;
+	}
+	CheckpointCount[idx]++;
+	CheckpointSize[idx]+=info->argSize;
+//return 1;
+	dbgMemFormatCall(info,buffer,9999);
+	if (strstr(buffer,"ntdll"))
+		return 1;
+	if (strstr(buffer,"CLBCATQ"))
+		return 1;
+	int i;
+	TotalBlocks++;
+	if (TotalBlocks%1000==0)
+	{
+		char mess[1000];
+		sprintf(mess,"%d blocks processed\n",TotalBlocks);
+		OutputDebugString(mess);
+	}
+	for (i=strlen(buffer);i>0;i--)
+	{
+		if (buffer[i]=='\n')
+			break;
+	}
+	if (!i)
+		return 1;
+	buffer[i]=0;
+	char *buf=buffer;
+	while (*buf)
+	{
+		if (*buf=='\n')
+		{
+			buf++;
+			break;
+		}
+		buf++;
+	}
+	char *start=0;
+	while (*buf)
+	{
+		while (*buf==' ')
+			buf++;
+		start=buf;
+		while (*buf!=0&&*buf!='\n')
+			buf++;
+		if (*start)
+		{
+			if (*buf)
+			{
+				*buf=0;
+				buf++;
+			}
+			if (strlen(start)>255)
+				start[255]=0;
+			if (strstr(start,"std::"))
+			{
+//				start=0;
+				continue;
+			}
+			if (strstr(start,"Malloc"))
+			{
+				start=0;
+				continue;
+			}
+			if (strstr(start,"FS_LoadFile"))
+			{
+				start=0;
+				continue;
+			}
+			if (strstr(start,"CopyString"))
+			{
+				start=0;
+				continue;
+			}
+			break;
+		}
+	}
+	if (!start||!*start)
+	{
+		start="UNKNOWN";
+	}
+
+	for (i=0;i<48;i++)
+	{
+		if (StackCache[i]<0||StackCache[i]>=nStack)
+			continue;
+		if (!strcmpi(start,StackNames[StackCache[i]]))
+			break;
+	}
+	if (i<48)
+	{
+		StackSize[StackCache[i]]+=info->argSize;
+		StackCount[StackCache[i]]++;
+	}
+	else
+	{
+		for (i=0;i<nStack;i++)
+		{
+			if (!strcmpi(start,StackNames[i]))
+				break;
+		}
+		if (i<nStack)
+		{
+			StackSize[i]+=info->argSize;
+			StackCount[i]++;
+			StackCache[StackCacheAt]=i;
+			StackCacheAt++;
+			if (StackCacheAt>=48)
+				StackCacheAt=0;
+		}
+		else if (i<maxStack)
+		{
+			strcpy(StackNames[i],start);
+			StackSize[i]=info->argSize;
+			StackCount[i]=1;
+			nStack++;
+		}
+		else if (nStack<maxStack)
+		{
+			nStack++;
+			strcpy(StackNames[maxStack-1],"*****OTHER*****");
+			StackSize[maxStack-1]=info->argSize;
+			StackCount[maxStack-1]=1;
+		}
+		else
+		{
+			StackSize[maxStack-1]+=info->argSize;
+			StackCount[maxStack-1]++;
+		}
+	}
+	TotalMem+=info->argSize;
+	return 1;
+}
+
+void SH_Checking_f(void);
+#endif
+
+class Leakage
+{
+	MEM_POOL MyPool;
+
+public:
+	Leakage()
+	{
+		MyPool = MemInitDefaultPool();
+//		MemPoolSetSmallBlockSize(MyPool, 16); 
+		MemPoolSetSmallBlockAllocator(MyPool,MEM_SMALL_BLOCK_SH3);
+#if MEM_DEBUG
+		dbgMemSetGuardSize(2);
+#endif
+		EnableChecking(100000);
+	}
+
+	void LeakReport(void)
+	{
+#if MEM_DEBUG
+
+		int i;
+		char mess[1000];
+		int blocks=dbgMemTotalCount();
+		int mem=dbgMemTotalSize()/1024;
+		sprintf(mess,"Final Memory Summary %d blocks %d K\n",blocks,mem);
+		OutputDebugString(mess);
+		for (i=0;i<1000;i++)
+		{
+			CheckpointSize[i]=0;
+			CheckpointCount[i]=0;
+		}
+
+		TotalMem=0;
+		TotalBlocks=0;
+		nStack=0;
+		MemSetErrorHandler(MyMemReporter2);
+		dbgMemReportLeakage(NULL,1,1000);
+		MemSetErrorHandler(MemDefaultErrorHandler);
+		if (TotalBlocks)
+		{
+			// Sort by size.
+			Sleep(100);
+			OutputDebugString("**************************************\n");
+			OutputDebugString("**********Memory Leak Report**********\n");
+			OutputDebugString("*************** By Size **************\n");
+			OutputDebugString("**************************************\n");
+			sprintf(mess,"Actual leakage %d blocks %d K\n",TotalBlocks,TotalMem/1024);
+			OutputDebugString(mess);
+			multimap<int,pair<int,char *> > sortit;
+			for (i=0;i<nStack;i++)
+				sortit.insert(pair<int,pair<int,char *> >(-StackSize[i],pair<int,char *>(StackCount[i],StackNames[i])));
+			multimap<int,pair<int,char *> >::iterator j;
+			Sleep(5);
+			for (j=sortit.begin();j!=sortit.end();j++)
+			{
+				sprintf(mess,"%5d KB %6d cnt  %s\n",-(*j).first/1024,(*j).second.first,(*j).second.second);
+	//			if (!(-(*j).first/1024))
+	//				break;
+				Sleep(5);
+				OutputDebugString(mess);
+			}
+
+			// Sort by count.
+			Sleep(100);
+			OutputDebugString("**************************************\n");
+			OutputDebugString("**********Memory Leak Report**********\n");
+			OutputDebugString("************** By Count **************\n");
+			OutputDebugString("**************************************\n");
+			sprintf(mess,"Actual leakage %d blocks %d K\n",TotalBlocks,TotalMem/1024);
+			OutputDebugString(mess);
+			sortit.clear();
+			for (i=0;i<nStack;i++)
+				sortit.insert(pair<int,pair<int,char *> >(-StackCount[i],pair<int,char *>(StackSize[i],StackNames[i])));
+			Sleep(5);
+			for (j=sortit.begin();j!=sortit.end();j++)
+			{
+				sprintf(mess,"%5d KB %6d cnt  %s\n",(*j).second.first/1024,-(*j).first,(*j).second.second);
+	//			if (!(-(*j).first/1024))
+	//				break;
+				Sleep(5);
+				OutputDebugString(mess);
+			}
+		}
+		else
+		{
+			OutputDebugString("No Memory Leaks\n");
+		}
+		
+		// Sort by size.
+		Sleep(5);
+		OutputDebugString("***************************************\n");
+		OutputDebugString("By Tag, sort: size ********************\n");
+		OutputDebugString("size(K)   count  name  \n");
+		OutputDebugString("-----------------------\n");
+		Sleep(5);
+		multimap<int,int> sorted;
+		for (i=0;i<1000;i++)
+		{
+			if (CheckpointCount[i])
+			{
+				sorted.insert(pair<int,int>(-CheckpointSize[i],i));
+			}
+		}
+		multimap<int,int>::iterator k;
+		for (k=sorted.begin();k!=sorted.end();k++)
+		{
+//			sprintf(mess,"%8d %8d %s\n",CheckpointSize[(*k).second]/1024,CheckpointCount[(*k).second],(*k).second>=2?tagDefs[(*k).second-2]:"unknown");
+			sprintf(mess,"%8d %8d %s\n",CheckpointSize[(*k).second]/1024,CheckpointCount[(*k).second],"unknown");
+			Sleep(5);
+			OutputDebugString(mess);
+		}
+		
+		// Sort by count.
+		Sleep(5);
+		OutputDebugString("***************************************\n");
+		OutputDebugString("By Tag, sort: count *******************\n");
+		OutputDebugString("size(K)   count  name  \n");
+		OutputDebugString("-----------------------\n");
+		Sleep(5);
+		sorted.clear();
+		for (i=0;i<1000;i++)
+		{
+			if (CheckpointCount[i])
+			{
+				sorted.insert(pair<int,int>(-CheckpointCount[i],i));
+			}
+		}
+		for (k=sorted.begin();k!=sorted.end();k++)
+		{
+//			sprintf(mess,"%8d %8d %s\n",CheckpointSize[(*k).second]/1024,CheckpointCount[(*k).second],(*k).second>=2?tagDefs[(*k).second-2]:"unknown");
+			sprintf(mess,"%8d %8d %s\n",CheckpointSize[(*k).second]/1024,CheckpointCount[(*k).second],"unknown");
+			Sleep(5);
+			OutputDebugString(mess);
+		}
+#endif
+	}
+
+	~Leakage()
+	{
+#if MEM_DEBUG
+#if 0
+		if (mem_leakfile && mem_leakfile->integer)
+		{
+			dbgMemSetDefaultErrorOutput(DBGMEM_OUTPUT_FILE,"leakage.out");
+			dbgMemReportLeakage(NULL,1,1);
+			dbgMemSetDefaultErrorOutput(DBGMEM_OUTPUT_PROMPT,NULL);
+		}
+#endif
+		if (mem_leakreport && mem_leakreport->integer)
+		{
+			LeakReport();
+		}
+#endif
+	}
+#if MEM_DEBUG
+
+	void EnableChecking(int x)
+	{
+		if (x)
+		{
+			dbgMemSetSafetyLevel(MEM_SAFETY_DEBUG);
+			dbgMemPoolSetCheckFrequency(MyPool, x);
+			dbgMemSetCheckFrequency(x);
+			dbgMemDeferFreeing(TRUE);
+			if (x>50000)
+			{
+				dbgMemSetDeferQueueLen(x+5000);
+			}
+			else
+			{
+				dbgMemSetDeferQueueLen(50000);
+			}
+		}
+		else
+		{
+			dbgMemSetSafetyLevel(MEM_SAFETY_SOME);
+			dbgMemDeferFreeing(FALSE);
+		}
+
+	}
+#endif
+
+};
+
+static Leakage TheLeakage;
+
+#if MEM_DEBUG
+
+void MEM_Checking_f(void)
+{
+	if (Cmd_Argc() != 2)
+	{
+		Com_Printf ("mem_checking <frequency>\n");
+		return;
+	}
+
+	if (atol(Cmd_Argv(1)) > 0 && atol(Cmd_Argv(1)) < 100)
+	{
+		Com_Printf ("mem_checking frequency is too low ( < 100 )\n");
+		return;
+	}
+
+	TheLeakage.EnableChecking(atol(Cmd_Argv(1)));
+}
+
+void MEM_Report_f(void)
+{
+	TheLeakage.LeakReport();
+}
+
+/*
+void myexit(void)
+{
+	TheLeakage.LeakReport();
+}
+*/
+
+void SH_Register(void)
+{
+	Cmd_AddCommand ("mem_checking", MEM_Checking_f);
+	Cmd_AddCommand ("mem_report", MEM_Report_f);
+
+	mem_leakfile = Cvar_Get( "mem_leakfile", "1", 0 );
+	mem_leakreport = Cvar_Get( "mem_leakreport", "1", 0 );
+//	atexit(myexit);
+}
+
+#endif
diff --git a/codemp/client/BinkVideo.cpp b/codemp/client/BinkVideo.cpp
new file mode 100644
index 0000000..6f24ef0
--- /dev/null
+++ b/codemp/client/BinkVideo.cpp
@@ -0,0 +1,524 @@
+#include "snd_local_console.h"
+#include "../renderer/tr_local.h"
+#include "BinkVideo.h"
+#include "RAD.h"
+
+
+bool	bvUseGCTexMem = true;
+
+#ifdef _XBOX
+int		memMarker     = 0;
+char*	binkXboxStartAddr = NULL;
+char*	binkXboxCurrentAddr = NULL;
+char*	binkXboxNextAddr = NULL;
+#endif
+
+static void PTR4* RADEXPLINK AllocWrapper(U32 size)
+{
+
+// Give bink pre-initialized mem on xbox
+#ifdef _XBOX
+	switch(memMarker)
+	{
+	case 0:
+		memMarker++;
+		binkXboxCurrentAddr = binkXboxStartAddr;
+		binkXboxNextAddr = binkXboxCurrentAddr + size;
+		return (void *)binkXboxStartAddr;	
+	case 1: case 2: case 3: case 4: case 5: case 6: case 7:
+		memMarker++;
+		binkXboxCurrentAddr = binkXboxNextAddr;
+		binkXboxNextAddr = binkXboxCurrentAddr + size;
+		return (void *)binkXboxCurrentAddr;
+	case 8:
+		memMarker = -1;
+		binkXboxCurrentAddr = binkXboxNextAddr;
+		binkXboxNextAddr = binkXboxStartAddr;
+		return (void *)binkXboxCurrentAddr;
+	default:
+		return BinkVideo::Allocate(size);
+	}
+#endif
+
+	return BinkVideo::Allocate(size);
+}
+
+static void RADEXPLINK FreeWrapper(void PTR4* ptr)
+{
+
+// Don't free the preinitialized mem
+#ifdef _XBOX
+	if(memMarker < 6)
+	{
+		memMarker++;
+		return;
+	}
+	else if(memMarker == 6)
+	{
+		memMarker = 1;
+		binkXboxNextAddr = binkXboxStartAddr + XBOX_MEM_STAGE_1;
+		return;
+	}
+#endif
+	BinkVideo::Free(ptr);
+}
+
+
+/*********
+BinkVideo
+*********/
+BinkVideo::BinkVideo()
+{
+	bink		= NULL;
+	buffer		= NULL;
+	texture		= 0;
+	x1			= 0.0f;
+	y1			= 0.0f;
+	x2			= 0.0f;
+	y2			= 0.0f;
+	w			= 0.0f;
+	h			= 0.0f;
+	status		= NS_BV_STOPPED;
+	looping		= false;
+#ifdef _XBOX
+	initialized = false;
+#endif
+}
+
+/*********
+~BinkVideo
+*********/
+BinkVideo::~BinkVideo()
+{
+	Free(buffer);
+	BinkClose(bink);
+}
+
+/*********
+AllocateXboxMem
+Pre-Allocates memory for xbox
+*********/
+#ifdef _XBOX
+void BinkVideo::AllocateXboxMem(void)
+{
+	u32 memToAllocate = XBOX_MEM_STAGE_1 +
+						XBOX_MEM_STAGE_2 +
+						XBOX_MEM_STAGE_3 +
+						XBOX_MEM_STAGE_4 +
+						XBOX_MEM_STAGE_5 +
+						XBOX_MEM_STAGE_6 +
+						XBOX_MEM_STAGE_7 +
+						XBOX_MEM_STAGE_8 +
+						XBOX_BUFFER_SIZE;
+	binkXboxStartAddr = (char*)Allocate(memToAllocate);
+	memMarker = 0;
+	initialized = true;
+}
+
+/*********
+FreeXboxMem
+*********/
+void BinkVideo::FreeXboxMem(void)
+{
+	initialized = false;
+	Z_Free(binkXboxStartAddr);
+	memMarker = 0;
+}
+#endif
+
+
+/*********
+Start
+Opens a bink file and gets it ready to play
+*********/
+bool BinkVideo::Start(const char *filename, float xOrigin, float yOrigin, float width, float height)
+{
+
+#ifdef _XBOX
+	assert(initialized);
+#endif
+
+	// Check to see if a video is being played.
+	if(status == NS_BV_PLAYING)
+	{
+		// stop
+		this->Stop();
+	}
+
+	// Set memory allocation wrapper
+	RADSetMemory(AllocWrapper,FreeWrapper);
+
+	// Set up sound for consoles
+#if defined(_XBOX)
+	// If we are on XBox, tell Bink to play all of the 5.1 tracks
+	U32 TrackIDsToPlay[ 4 ] = { 0, 1, 2, 3 };	
+	BinkSetSoundTrack( 4, TrackIDsToPlay );
+	
+	// Now route the sound tracks to the correct speaker
+	U32 bins[ 2 ];
+
+	bins[ 0 ] = DSMIXBIN_FRONT_LEFT;
+	bins[ 1 ] = DSMIXBIN_FRONT_RIGHT;
+	BinkSetMixBins( bink, 0, bins, 2 );
+	bins[ 0 ] = DSMIXBIN_FRONT_CENTER;
+	BinkSetMixBins( bink, 1, bins, 1 );
+	bins[ 0 ] = DSMIXBIN_LOW_FREQUENCY;
+	BinkSetMixBins( bink, 2, bins, 1 );
+	bins[ 0 ] = DSMIXBIN_BACK_LEFT;
+	bins[ 1 ] = DSMIXBIN_BACK_RIGHT;
+	BinkSetMixBins( bink, 3, bins, 2 );
+
+#elif defined(_GAMECUBE)	
+	BinkSoundUseNGCSound();
+	
+	RADMEMALLOC a;
+	alGeti(AL_MEMORY_ALLOCATOR, (ALint*)&a);
+	
+	RADMEMFREE f;
+	alGeti(AL_MEMORY_DEALLOCATOR, (ALint*)&f);
+	
+	RADSetAudioMemory(a, f); 
+#endif
+	
+	
+	// Try to open the Bink file.
+#ifdef _XBOX
+	bink = BinkOpen( filename, BINKSNDTRACK );
+	if(!bink)
+	{
+		return false;
+	}
+#elif defined _GAMECUBE
+	if(bvUseGCTexMem)
+	{
+		extern void GLW_TexCacheLock(void);
+		GLW_TexCacheLock();
+	}
+
+	bink = BinkOpen( filename, 0);
+
+	if(!bink)
+	{
+		extern void GLW_TexCacheUnlock(void);
+		GLW_TexCacheUnlock();
+		return false;
+	}
+#endif
+
+
+	assert(bink->Width <= MAX_WIDTH && bink->Height <=MAX_HEIGHT);
+
+	// allocate memory for the frame buffer
+#ifdef _XBOX
+	buffer = AllocWrapper(XBOX_BUFFER_SIZE);
+#elif _GAMECUBE
+	buffer = Allocate(XBOX_BUFFER_SIZE);
+#endif
+
+	// set the height, width, etc...
+	x1 = xOrigin;
+	y1 = yOrigin;
+	x2 = x1 + width;
+	y2 = y1 + height;
+	w = width;
+	h = height;
+
+	// flush any background sound reads
+#if defined (_XBOX)|| (_GAMECUBE)
+	extern void S_DrainRawSoundData(void);
+	S_DrainRawSoundData();
+#endif
+	
+	// Create the video texture
+	GLuint tex = (GLuint)texture;
+	if (tex != 0)
+		qglDeleteTextures(1, &tex);
+
+	qglGenTextures(1, &tex);
+	qglBindTexture(GL_TEXTURE_2D, tex);
+	glState.currenttextures[glState.currenttmu] = tex;
+	
+	qglTexImage2D( GL_TEXTURE_2D, 0, GL_RGB5, bink->Width, bink->Height, 0, 
+		GL_RGB_SWIZZLE_EXT, GL_UNSIGNED_BYTE, buffer );
+	
+	qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
+	qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
+	qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP );
+	qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP );
+
+	texture = (int)tex;
+
+	status = NS_BV_PLAYING;
+
+	return true;
+}
+
+/*********
+Run
+Decompresses a frame, renders it to the screen, and advances to
+the next frame.
+*********/
+bool BinkVideo::Run(void)
+{
+	if(status == NS_BV_STOPPED) // A movie can't be run if it's not started first
+	{
+		return false;
+	}
+	
+	while(BinkWait(bink)); // Wait
+	
+	DecompressFrame(); // Decompress
+	Draw(); // Render
+	
+	if(status != NS_BV_PAUSED) // Only advance the frame is not paused
+	{
+		BinkNextFrame( bink );
+	}
+	
+	
+	if(bink->FrameNum == (bink->Frames - 1) && !looping) // The movie is done
+	{
+		Stop();
+		return false;
+	}
+	
+	return true;
+}
+
+/*********
+GetBinkData
+Returns the buffer data for the next frame of the video
+*********/
+void* BinkVideo::GetBinkData(void)
+{
+	while(BinkWait(bink));
+	DecompressFrame();
+	BinkNextFrame(bink);
+	return buffer;
+}
+
+/********
+Draw
+Copies the decompressed frame to a texture to be rendered on
+the screen.
+********/
+void BinkVideo::Draw(void)
+{
+	if(buffer)
+	{
+		qglFlush();
+		
+		extern void	RB_SetGL2D (void);
+		RB_SetGL2D();
+
+		GL_SelectTexture(0);
+
+		// Update the video texture
+		qglBindTexture(GL_TEXTURE_2D, (GLuint)texture);
+		glState.currenttextures[glState.currenttmu] = texture;
+		
+		qglTexSubImage2D( GL_TEXTURE_2D, 0, 0, 0, bink->Width, bink->Height,
+			GL_RGB_SWIZZLE_EXT, GL_UNSIGNED_BYTE, buffer );
+			
+		// Clear the screen.  We use triangles here (instead
+		// of glClear) because we want the back buffer to stick
+		// around... so we can get a nice, cheap fade on Gamecube
+		// reset.
+		qglColor3f(0.f, 0.f, 0.f);
+#if defined (_XBOX) || (_GAMECUBE)
+		qglBeginEXT (GL_TRIANGLE_STRIP, 4, 0, 0, 4, 0);
+#else
+		qglBegin(GL_TRIANGLE_STRIP);
+#endif
+		qglTexCoord2f ( 0,  0 );
+		qglVertex2f (-10, -10);
+		qglTexCoord2f ( 1 ,  0 );
+		qglVertex2f (650, -10);
+		qglTexCoord2f ( 0, 1 );
+		qglVertex2f (-10, 490);
+		qglTexCoord2f ( 1, 1 );
+		qglVertex2f (650, 490);
+		qglEnd ();
+		
+		// Draw the video
+		qglColor3f(1.f, 1.f, 1.f);
+#if defined (_XBOX) || (_GAMECUBE)
+		qglBeginEXT (GL_TRIANGLE_STRIP, 4, 0, 0, 4, 0);
+#else
+		qglBegin(GL_TRIANGLE_STRIP);
+#endif
+		qglTexCoord2f ( 0,  0 );
+		qglVertex2f (x1, y1);
+		qglTexCoord2f ( 1 ,  0 );
+		qglVertex2f (x2, y1);
+		qglTexCoord2f ( 0, 1 );
+		qglVertex2f (x1, y2);
+		qglTexCoord2f ( 1, 1 );
+		qglVertex2f (x2, y2);
+		qglEnd ();
+	}
+}
+
+/*********
+Stop
+Stops the current movie, and clears it from memory
+*********/
+void BinkVideo::Stop(void)
+{
+	BinkClose(bink);
+	bink	= NULL;
+#ifdef _XBOX
+	FreeWrapper(buffer);
+#elif _GAMECUBE
+	Free(buffer);
+#endif
+	buffer	= NULL;
+
+	GLuint tex = (GLuint)texture;
+	if (tex != 0)
+		qglDeleteTextures(1, &tex);
+
+	texture	= 0;
+	x1		= 0.0f;
+	y1		= 0.0f;
+	x2		= 0.0f;
+	y2		= 0.0f;
+	w		= 0.0f;
+	h		= 0.0f;
+	status	= NS_BV_STOPPED;
+#ifdef _XBOX
+	memMarker	= 0;
+#endif
+	
+#ifdef _GAMECUBE
+	extern void GLW_TexCacheUnlock(void);
+	GLW_TexCacheUnlock();
+#endif
+}
+
+/*********
+Pause
+Pauses the current movie. Only the current frame is rendered
+*********/
+void BinkVideo::Pause(void)
+{
+	status = NS_BV_PAUSED;
+}
+
+/*********
+SetExtends
+Sets dimmension variables
+*********/
+
+void BinkVideo::SetExtents(float xOrigin, float yOrigin, float width, float height)
+{
+	x1 = xOrigin;
+	y1 = yOrigin;
+	x2 = x1 + width;
+	y2 = y1 + height;
+	w = width;
+	h = height;
+}
+
+/*********
+SetMasterVolume
+Sets the volume of the specified track
+*********/
+void BinkVideo::SetMasterVolume(s32 volume)
+{
+#ifdef _XBOX
+	int i;
+	for(i = 0; i < 4; i++)
+	{
+		BinkSetVolume(bink,i,volume);
+	}
+#else
+	BinkSetVolume(bink,0,volume);
+#endif
+}
+
+/*********
+DecompressFrame
+Decompresses current frame and copies the data to
+the buffer
+*********/
+S32 BinkVideo::DecompressFrame()
+{
+	BinkDoFrame(bink);
+
+	S32 skip;	
+	skip = BinkCopyToBuffer(
+		bink,
+		(void *)buffer,
+		NS_BV_DEFAULT_CIN_BPS * bink->Width, //pitch
+		bink->Height,
+		0,
+		0,
+		BINKCOPYALL | BINKSURFACE565);
+	return skip;
+}
+
+/*********
+Allocate
+Allocates memory for the frame buffer
+*********/
+void *BinkVideo::Allocate(U32 size)
+{
+
+	size = RoundUp(size + 32, 32);
+	char* ptr = NULL;
+
+#ifdef _GAMECUBE
+	if (bvUseGCTexMem)
+	{
+		// Try allocating from texture cache
+		extern void* GLW_TexCacheAllocRaw(int size);
+		ptr = (char*)GLW_TexCacheAllocRaw(size);
+	}
+#endif
+
+	if (!ptr)
+	{
+		// Did not allocate texture cache memory, fall
+		// back to main memory..
+		ptr = (char*)Z_Malloc(size, TAG_BINK, qfalse, 32);
+		ptr[0] = 'z';
+	}
+	else
+	{
+		// Allocated memory from the texture cache
+		ptr[0] = 't';
+	}
+
+	return (void*)(ptr + 32);
+}
+
+/*********
+FreeBuffer
+Releases the frame buffer memory
+*********/
+void BinkVideo::Free(void* ptr)
+{
+	char* base = (char*)ptr - 32;
+	
+	switch (*base)
+	{
+#ifdef _GAMECUBE
+	case 't':
+		{
+			// Free texture cache memory
+			extern void GLW_TexCacheFreeRaw(void* ptr);
+			GLW_TexCacheFreeRaw(base);
+			break;
+		}
+#endif
+		
+	case 'z':
+		// Free main memory
+		Z_Free(base);
+		break;
+		
+	default:
+		assert(false);
+	}
+}
diff --git a/codemp/client/BinkVideo.h b/codemp/client/BinkVideo.h
new file mode 100644
index 0000000..ef97d0e
--- /dev/null
+++ b/codemp/client/BinkVideo.h
@@ -0,0 +1,73 @@
+#ifndef NS_BINKVIDEO
+#define NS_BINKVIDEO
+
+#include "bink.h"
+#define NS_BV_DEFAULT_CIN_BPS (2)
+#define MAX_WIDTH			512
+#define MAX_HEIGHT			512
+
+#define XBOX_MEM_STAGE_1	32640
+#define XBOX_MEM_STAGE_2	786528
+#define XBOX_MEM_STAGE_3	557152
+#define XBOX_MEM_STAGE_4	106560
+#define XBOX_MEM_STAGE_5	138304
+#define XBOX_MEM_STAGE_6	25696
+#define XBOX_MEM_STAGE_7	100
+#define XBOX_MEM_STAGE_8	100
+
+#define XBOX_BUFFER_SIZE	NS_BV_DEFAULT_CIN_BPS * MAX_WIDTH * MAX_HEIGHT
+
+typedef enum {
+	NS_BV_PLAYING,		// Movie is playing
+	NS_BV_STOPPED,		// Movie is stopped
+	NS_BV_PAUSED		// Movie is paused
+};
+
+class BinkVideo
+{
+private:
+	HBINK	bink;
+	void*	buffer;
+	int		texture;
+	int		status;
+	bool	looping;
+	float	x1;
+	float	y1;
+	float   x2;
+	float	y2;
+	float	w;
+	float	h;
+
+#ifdef _XBOX
+	bool	initialized;
+#endif
+
+	void	Draw(void);
+	S32		DecompressFrame();
+	
+
+public:
+	
+	BinkVideo();
+	~BinkVideo();
+	bool	Start(const char *filename, float xOrigin, float yOrigin, float width, float height);
+	bool	Run(void);
+	void	Stop(void);
+	void	Pause(void);
+	void	SetExtents(float xOrigin, float yOrigin, float width, float height);
+	int		GetStatus(void) { return status; }
+	void	SetLooping(bool loop) { looping = loop; }
+	void*	GetBinkData(void);
+	int		GetBinkWidth(void) { return this->bink->Width; }
+	int		GetBinkHeight(void) { return this->bink->Height; }
+	void	SetMasterVolume(s32 volume);
+#ifdef _XBOX
+	void	AllocateXboxMem(void);
+	void	FreeXboxMem(void);
+#endif
+	static void*	Allocate(U32 size);
+	static void		Free(void* ptr);
+	bool	Ready(void) { return this->bink != NULL; }
+};
+
+#endif
diff --git a/codemp/client/FXExport.cpp b/codemp/client/FXExport.cpp
new file mode 100644
index 0000000..0459f67
--- /dev/null
+++ b/codemp/client/FXExport.cpp
@@ -0,0 +1,105 @@
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+#include "client.h"
+#include "FXScheduler.h"
+
+//#define __FXCHECKER
+ 
+#ifdef __FXCHECKER
+	#include <float.h>
+#endif // __FXCHECKER
+
+int	FX_RegisterEffect(const char *file)
+{
+	return theFxScheduler.RegisterEffect(file, true);
+}
+
+void FX_PlayEffect( const char *file, vec3_t org, vec3_t fwd, int vol, int rad )
+{
+#ifdef __FXCHECKER
+	if (_isnan(org[0]) || _isnan(org[1]) || _isnan(org[2]))
+	{
+		assert(0);
+	}
+	if (_isnan(fwd[0]) || _isnan(fwd[1]) || _isnan(fwd[2]))
+	{
+		assert(0);
+	}
+	if (fabs(fwd[0]) < 0.1 && fabs(fwd[1]) < 0.1 && fabs(fwd[2]) < 0.1)
+	{
+		assert(0);
+	}
+#endif // __FXCHECKER
+
+	theFxScheduler.PlayEffect(file, org, fwd, vol, rad);
+}
+
+void FX_PlayEffectID( int id, vec3_t org, vec3_t fwd, int vol, int rad, qboolean isPortal )
+{
+#ifdef __FXCHECKER
+	if (_isnan(org[0]) || _isnan(org[1]) || _isnan(org[2]))
+	{
+		assert(0);
+	}
+	if (_isnan(fwd[0]) || _isnan(fwd[1]) || _isnan(fwd[2]))
+	{
+		assert(0);
+	}
+	if (fabs(fwd[0]) < 0.1 && fabs(fwd[1]) < 0.1 && fabs(fwd[2]) < 0.1)
+	{
+		assert(0);
+	}
+#endif // __FXCHECKER
+
+	theFxScheduler.PlayEffect(id, org, fwd, vol, rad, !!isPortal );
+}
+
+void FX_PlayBoltedEffectID( int id, vec3_t org, 
+						   const int boltInfo, int iGhoul2, int iLooptime, qboolean isRelative )
+{
+	theFxScheduler.PlayEffect(id, org, 0, boltInfo, iGhoul2, -1, -1, -1, qfalse, iLooptime, !!isRelative  );
+}
+
+void FX_PlayEntityEffectID( int id, vec3_t org, 
+						vec3_t axis[3], const int boltInfo, const int entNum, int vol, int rad )
+{
+#ifdef __FXCHECKER
+	if (_isnan(org[0]) || _isnan(org[1]) || _isnan(org[2]))
+	{
+		assert(0);
+	}
+#endif // __FXCHECKER
+
+	theFxScheduler.PlayEffect(id, org, axis, boltInfo, NULL, -1, vol, rad );
+}
+
+void FX_AddScheduledEffects( qboolean portal )
+{
+	theFxScheduler.AddScheduledEffects(!!portal);
+}
+
+void FX_Draw2DEffects( float screenXScale, float screenYScale )
+{
+	theFxScheduler.Draw2DEffects( screenXScale, screenYScale );
+}
+
+int FX_InitSystem( refdef_t* refdef )
+{
+	return FX_Init( refdef );
+}
+
+void FX_SetRefDefFromCGame( refdef_t* refdef )
+{
+	FX_SetRefDef( refdef );
+}
+
+qboolean FX_FreeSystem( void )
+{
+	return (qboolean)FX_Free( true );
+}
+
+void FX_AdjustTime( int time )
+{
+	theFxHelper.AdjustTime(time);
+}
diff --git a/codemp/client/FXExport.h b/codemp/client/FXExport.h
new file mode 100644
index 0000000..3ca9003
--- /dev/null
+++ b/codemp/client/FXExport.h
@@ -0,0 +1,23 @@
+#ifndef FX_EXPORT_H_INC
+#define FX_EXPORT_H_INC
+
+int	FX_RegisterEffect(const char *file);
+
+void FX_PlayEffect( const char *file, vec3_t org, vec3_t fwd, int vol, int rad );		// builds arbitrary perp. right vector, does a cross product to define up
+
+void FX_PlayEffectID( int id, vec3_t org, vec3_t fwd, int vol, int rad, qboolean isPortal = qfalse );		// builds arbitrary perp. right vector, does a cross product to define up
+void FX_PlayEntityEffectID( int id, vec3_t org, 
+							vec3_t axis[3], const int boltInfo, const int entNum, int vol, int rad );
+void FX_PlayBoltedEffectID( int id, vec3_t org, 
+							const int boltInfo, int iGhoul2, int iLooptime, qboolean isRelative );
+
+void FX_AddScheduledEffects( qboolean portal );
+void		FX_Draw2DEffects ( float screenXScale, float screenYScale );
+
+int			FX_InitSystem( refdef_t* refdef );	// called in CG_Init to purge the fx system.
+void		FX_SetRefDefFromCGame( refdef_t* refdef );
+qboolean	FX_FreeSystem( void );	// ditches all active effects;
+void		FX_AdjustTime( int time );
+
+
+#endif // FX_EXPORT_H_INC
diff --git a/codemp/client/FxPrimitives.cpp b/codemp/client/FxPrimitives.cpp
new file mode 100644
index 0000000..0510522
--- /dev/null
+++ b/codemp/client/FxPrimitives.cpp
@@ -0,0 +1,2344 @@
+// this include must remain at the top of every CPP file
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+#include "client.h"
+
+#if !defined(FX_SCHEDULER_H_INC)
+	#include "FxScheduler.h"
+#endif
+
+#if !defined(G2_H_INC)
+	#include "../ghoul2/G2.h"
+	#include "../ghoul2/G2_local.h"
+#endif
+
+#ifdef VV_LIGHTING
+#include "../renderer/tr_lightmanager.h"
+#endif
+
+extern int		drawnFx;
+
+//--------------------------
+//
+// Base Effect Class
+//
+//--------------------------
+CEffect::CEffect(void) :
+	mMatImpactFX(MATIMPACTFX_NONE),
+	mMatImpactParm(-1),
+	mSoundVolume(-1),
+	mSoundRadius(-1),
+	mFlags(0)
+{
+	memset( &mRefEnt, 0, sizeof( mRefEnt ));
+}
+
+//--------------------------
+//
+// Derived Particle Class
+//
+//--------------------------
+
+//----------------------------
+void CParticle::Init(void)
+{
+	mRefEnt.radius = 0.0f;
+	if (mFlags & FX_PLAYER_VIEW)
+	{
+		mOrigin1[0] = irand(0, 639);
+		mOrigin1[1] = irand(0, 479);
+	}
+}
+
+//----------------------------
+void CParticle::Die(void)
+{
+	if ( mFlags & FX_DEATH_RUNS_FX && !(mFlags & FX_KILL_ON_IMPACT) )
+	{
+		vec3_t	norm;
+
+		// Man, this just seems so, like, uncool and stuff...
+		VectorSet( norm, flrand(-1.0f, 1.0f), flrand(-1.0f, 1.0f), flrand(-1.0f, 1.0f));
+		VectorNormalize( norm );
+
+		theFxScheduler.PlayEffect( mDeathFxID, mOrigin1, norm );
+	}
+}
+
+//----------------------------
+bool CParticle::Cull(void)
+{
+	vec3_t	dir;
+
+	if (mFlags & FX_PLAYER_VIEW)
+	{
+		// this will be drawn as a 2D effect so don't cull it
+		return false;
+	}
+
+	// Get the direction to the view
+	VectorSubtract( mOrigin1, theFxHelper.refdef->vieworg, dir );
+
+	// Check if it's behind the viewer
+	if ( (DotProduct( theFxHelper.refdef->viewaxis[0], dir )) < 0) // cg.cosHalfFOV * (len - mRadius) )
+	{
+		return true;
+	}
+
+	// don't cull if this is hacked to show up close to the inview wpn
+	if (mFlags & FX_DEPTH_HACK)
+	{
+		return false;
+	}
+	// Can't be too close
+	float len = VectorLengthSquared( dir );
+	if ( len < fx_nearCull->value )
+	{
+		return true;
+	}
+
+	return false;
+}
+
+//----------------------------
+void CParticle::Draw(void)
+{
+	if ( mFlags & FX_DEPTH_HACK )
+	{
+		// Not sure if first person needs to be set, but it can't hurt?
+		mRefEnt.renderfx |= RF_DEPTHHACK;
+	}
+
+	if (mFlags & FX_PLAYER_VIEW)
+	{
+		vec4_t	color;
+
+		color[0] = mRefEnt.shaderRGBA[0] / 255.0;
+		color[1] = mRefEnt.shaderRGBA[1] / 255.0;
+		color[2] = mRefEnt.shaderRGBA[2] / 255.0;
+		color[3] = mRefEnt.shaderRGBA[3] / 255.0;
+
+		// add this 2D effect to the proper list. it will get drawn after the cgi.RenderScene call
+		theFxScheduler.Add2DEffect(mOrigin1[0], mOrigin1[1], mRefEnt.radius, mRefEnt.radius, color, mRefEnt.customShader);
+	}
+	else
+	{
+		// Add our refEntity to the scene
+		VectorCopy( mOrigin1, mRefEnt.origin );
+
+		theFxHelper.AddFxToScene(&mRefEnt);
+	}
+	drawnFx++;	
+}
+
+//----------------------------
+// Update
+//----------------------------
+bool CParticle::Update(void)
+{
+	// Game pausing can cause dumb time things to happen, so kill the effect in this instance
+	if ( mTimeStart > theFxHelper.mTime )
+	{
+		return false;
+	}
+
+	if ( mFlags & FX_RELATIVE )
+	{
+		if ( !mGhoul2.IsValid())
+		{	// the thing we are bolted to is no longer valid, so we may as well just die.
+			return false;
+		}
+
+		vec3_t	org;
+		vec3_t	ax[3];
+
+		// Get our current position and direction
+		if (!theFxHelper.GetOriginAxisFromBolt(&mGhoul2, mEntNum, mModelNum, mBoltNum, org, ax))
+		{	//could not get bolt
+			return false;
+		}
+		vec3_t 	realVel, realAccel;
+
+		VectorMA( org, mOrgOffset[0], ax[0], org );
+		VectorMA( org, mOrgOffset[1], ax[1], org );
+		VectorMA( org, mOrgOffset[2], ax[2], org );
+
+		const float	time = (theFxHelper.mTime - mTimeStart) * 0.001f;
+		// calc the real velocity and accel vectors
+		VectorScale( ax[0], mVel[0], realVel );
+		VectorMA( realVel, mVel[1], ax[1], realVel );
+		VectorMA( realVel, mVel[2], ax[2], realVel );
+		//realVel[2] += 0.5f * mGravity * time;
+
+		VectorScale( ax[0], mAccel[0], realAccel );
+		VectorMA( realAccel, mAccel[1], ax[1], realAccel );
+		VectorMA( realAccel, mAccel[2], ax[2], realAccel );
+
+		// Get our real velocity at the current time, taking into account the effects of acceleartion.  NOTE: not sure if this is even 100% correct math-wise
+		VectorMA( realVel, time, realAccel, realVel );
+
+		// Now move us to where we should be at the given time
+		VectorMA( org, time, realVel, mOrigin1 );
+		
+	}
+	else if (( mTimeStart < theFxHelper.mTime ) && UpdateOrigin() == false )
+	{
+		// we are marked for death
+		return false;
+	}
+
+
+	if ( !Cull() )
+	{	
+		// Only update these if the thing is visible.	
+		UpdateSize();
+		UpdateRGB();
+		UpdateAlpha();
+		UpdateRotation();
+
+		Draw();
+	}
+
+	return true;
+}
+
+//----------------------------
+// Update Origin
+//----------------------------
+bool CParticle::UpdateOrigin(void)
+{
+	vec3_t	new_origin;
+
+	VectorMA( mVel, theFxHelper.mRealTime, mAccel, mVel );
+
+	// Predict the new position
+	new_origin[0] = mOrigin1[0] + (theFxHelper.mRealTime * mVel[0]);// + (theFxHelper.mHalfRealTimeSq * mVel[0]);
+	new_origin[1] = mOrigin1[1] + (theFxHelper.mRealTime * mVel[1]);// + (theFxHelper.mHalfRealTimeSq * mVel[1]);
+	new_origin[2] = mOrigin1[2] + (theFxHelper.mRealTime * mVel[2]);// + (theFxHelper.mHalfRealTimeSq * mVel[2]);
+
+	// Only perform physics if this object is tagged to do so
+	if ( (mFlags & FX_APPLY_PHYSICS) && !(mFlags & FX_PLAYER_VIEW) )
+	{
+		bool solid;
+
+		if ( mFlags & FX_EXPENSIVE_PHYSICS )
+		{
+			solid = true; // by setting this to true, we force a real trace to happen
+		}
+		else
+		{
+			// if this returns solid, we need to do a trace
+			if (!com_RMG || com_RMG->integer)
+			{	// don't do this call for RMG maps
+				TCGPointContents	*data = (TCGPointContents *)cl.mSharedMemory;
+
+				VectorCopy(new_origin, data->mPoint);
+				data->mPassEntityNum = ENTITYNUM_WORLD;
+
+				// if this returns solid, we need to do a trace
+				solid = !!(VM_Call( cgvm, CG_POINT_CONTENTS ) & MASK_SOLID); 
+			}
+			else
+			{
+				solid = false;
+			}
+		}
+
+		if ( solid )
+		{
+			trace_t	trace;
+			float	dot;
+
+			if ( mFlags & FX_USE_BBOX )
+			{
+				if (mFlags & FX_GHOUL2_TRACE)
+				{
+					theFxHelper.G2Trace( trace, mOrigin1, mMin, mMax, new_origin, -1, MASK_SOLID );
+				}
+				else
+				{
+					theFxHelper.Trace( trace, mOrigin1, mMin, mMax, new_origin, -1, MASK_SOLID );
+				}
+			}
+			else
+			{
+				if (mFlags & FX_GHOUL2_TRACE)
+				{
+					theFxHelper.G2Trace( trace, mOrigin1, NULL, NULL, new_origin, -1, MASK_PLAYERSOLID );
+				}
+				else
+				{
+					theFxHelper.Trace( trace, mOrigin1, NULL, NULL, new_origin, -1, MASK_SOLID );
+				}
+			}
+
+			// Hit something
+			if (trace.startsolid || trace.allsolid)
+			{
+				VectorClear( mVel );
+				VectorClear( mAccel );
+
+				if ((mFlags & FX_GHOUL2_TRACE) && (mFlags & FX_IMPACT_RUNS_FX))
+				{
+					static vec3_t bsNormal = {0, 1, 0};
+
+					theFxScheduler.PlayEffect( mImpactFxID, trace.endpos, bsNormal );
+				}
+
+				mFlags &= ~(FX_APPLY_PHYSICS | FX_IMPACT_RUNS_FX);
+
+				return true;
+			}
+			else if ( trace.fraction < 1.0f )//&& !trace.startsolid && !trace.allsolid )
+			{
+				if ( mFlags & FX_IMPACT_RUNS_FX && !(trace.surfaceFlags & SURF_NOIMPACT ))
+				{
+					theFxScheduler.PlayEffect( mImpactFxID, trace.endpos, trace.plane.normal );
+				}
+
+				// may need to interact with the material type we hit
+				theFxScheduler.MaterialImpact(&trace, (CEffect*)this);
+
+				if ( mFlags & FX_KILL_ON_IMPACT	)
+				{
+					// time to die
+					return false;
+				}
+
+				VectorMA( mVel, theFxHelper.mRealTime * trace.fraction, mAccel, mVel );
+
+				dot = DotProduct( mVel, trace.plane.normal );
+
+				VectorMA( mVel, -2.0f * dot, trace.plane.normal, mVel );
+
+				VectorScale( mVel, mElasticity, mVel );
+				mElasticity *= 0.5f;
+
+				// If the velocity is too low, make it stop moving, rotating, and turn off physics to avoid
+				//	doing expensive operations when they aren't needed
+				//if ( trace.plane.normal[2] > 0.33f && mVel[2] < 10.0f )
+				if (VectorLengthSquared(mVel) < 100.0f)
+				{
+					VectorClear( mVel );
+					VectorClear( mAccel );
+
+					mFlags &= ~(FX_APPLY_PHYSICS | FX_IMPACT_RUNS_FX);
+				}
+
+				// Set the origin to the exact impact point
+				VectorMA( trace.endpos, 1.0f, trace.plane.normal, mOrigin1 );
+				return true;
+			}
+		}
+	}
+
+	// No physics were done to this object, move it
+	VectorCopy( new_origin, mOrigin1 );
+
+	if (mFlags & FX_PLAYER_VIEW)
+	{
+		if (mOrigin1[0] < 0 || mOrigin1[0] > 639 || mOrigin1[1] < 0 || mOrigin1[1] > 479)
+		{
+			return false;
+		}
+	}
+
+	return true;
+}
+
+//----------------------------
+// Update Size
+//----------------------------
+void CParticle::UpdateSize(void)
+{
+	// completely biased towards start if it doesn't get overridden
+	float	perc1 = 1.0f, perc2 = 1.0f; 
+
+	if ( (mFlags & FX_SIZE_LINEAR) )
+	{ 
+		// calculate element biasing
+		perc1 = 1.0f - (float)(theFxHelper.mTime - mTimeStart) / (float)(mTimeEnd - mTimeStart);
+	}
+
+	// We can combine FX_LINEAR with _either_ FX_NONLINEAR, FX_WAVE, or FX_CLAMP
+	if (( mFlags & FX_SIZE_PARM_MASK ) == FX_SIZE_NONLINEAR )
+	{
+		if ( theFxHelper.mTime > mSizeParm )
+		{ 
+			// get percent done, using parm as the start of the non-linear fade
+			perc2 = 1.0f - (float)(theFxHelper.mTime - mSizeParm) / (float)(mTimeEnd - mSizeParm);
+		}
+
+		if ( mFlags & FX_SIZE_LINEAR )
+		{
+			// do an even blend
+			perc1 = perc1 * 0.5f + perc2 * 0.5f;
+		}
+		else
+		{ 
+			// just copy it over...sigh
+			perc1 = perc2;
+		}
+	}
+	else if (( mFlags & FX_SIZE_PARM_MASK ) == FX_SIZE_WAVE )
+	{ 
+		// wave gen, with parm being the frequency multiplier
+		perc1 = perc1 * cosf( (theFxHelper.mTime - mTimeStart) * mSizeParm );
+	}
+	else if (( mFlags & FX_SIZE_PARM_MASK ) == FX_SIZE_CLAMP )
+	{
+		if ( theFxHelper.mTime < mSizeParm )
+		{ 
+			// get percent done, using parm as the start of the non-linear fade
+			perc2 = (float)(mSizeParm - theFxHelper.mTime) / (float)(mSizeParm - mTimeStart);
+		}
+		else
+		{
+			perc2 = 0.0f; // make it full size??
+		}
+
+		if ( (mFlags & FX_SIZE_LINEAR) )
+		{ 
+			// do an even blend
+			perc1 = perc1 * 0.5f + perc2 * 0.5f;
+		}
+		else
+		{ 
+			// just copy it over...sigh
+			perc1 = perc2;
+		}
+	}
+
+	// If needed, RAND can coexist with linear and either non-linear or wave.
+	if ( mFlags & FX_SIZE_RAND )
+	{ 
+		// Random simply modulates the existing value
+		perc1 = flrand(0.0f, perc1);
+	}
+
+	mRefEnt.radius = (mSizeStart * perc1) + (mSizeEnd * (1.0f - perc1));
+}
+
+inline int VectorToInt(vec3_t vec)
+{
+	int			tmp, retval;
+
+	_asm
+	{
+		push	edx
+		mov		edx, [vec]
+		fld		dword ptr[edx + 0]
+		fld		dword ptr[edx + 4]
+		fld		dword ptr[edx + 8]
+
+		mov		eax, 0xff00
+
+		fistp	tmp	   
+		mov		al, byte ptr [tmp]
+		shl		eax, 16
+		
+		fistp	tmp
+		mov		ah, byte ptr [tmp]
+
+		fistp	tmp
+		mov		al, byte ptr [tmp]
+
+		mov		[retval], eax
+		pop		edx
+	}
+	return(retval);
+}
+
+//----------------------------
+// Update RGB
+//----------------------------
+void CParticle::UpdateRGB(void)
+{
+	// completely biased towards start if it doesn't get overridden
+	float	perc1 = 1.0f, perc2 = 1.0f; 
+	vec3_t	res;
+
+	if ( (mFlags & FX_RGB_LINEAR) )
+	{ 
+		// calculate element biasing
+		perc1 = 1.0f - (float)( theFxHelper.mTime - mTimeStart ) / (float)( mTimeEnd - mTimeStart );
+	}
+
+	// We can combine FX_LINEAR with _either_ FX_NONLINEAR, FX_WAVE, or FX_CLAMP
+	if (( mFlags & FX_RGB_PARM_MASK ) == FX_RGB_NONLINEAR )
+	{
+		if ( theFxHelper.mTime > mRGBParm )
+		{ 
+			// get percent done, using parm as the start of the non-linear fade
+			perc2 = 1.0f - (float)( theFxHelper.mTime - mRGBParm ) / (float)( mTimeEnd - mRGBParm );
+		}
+
+		if ( (mFlags & FX_RGB_LINEAR) )
+		{ 
+			// do an even blend
+			perc1 = perc1 * 0.5f + perc2 * 0.5f;
+		}
+		else
+		{ 
+			// just copy it over...sigh
+			perc1 = perc2;
+		}
+	}
+	else if (( mFlags & FX_RGB_PARM_MASK ) == FX_RGB_WAVE )
+	{ 
+		// wave gen, with parm being the frequency multiplier
+		perc1 = perc1 * cosf(( theFxHelper.mTime - mTimeStart ) * mRGBParm );
+	}
+	else if (( mFlags & FX_RGB_PARM_MASK ) == FX_RGB_CLAMP )
+	{
+		if ( theFxHelper.mTime < mRGBParm )
+		{ 
+			// get percent done, using parm as the start of the non-linear fade
+			perc2 = (float)(mRGBParm - theFxHelper.mTime) / (float)(mRGBParm - mTimeStart);
+		}
+		else
+		{
+			perc2 = 0.0f; // make it full size??
+		}
+
+		if (( mFlags & FX_RGB_LINEAR ))
+		{ 
+			// do an even blend
+			perc1 = perc1 * 0.5f + perc2 * 0.5f;
+		}
+		else
+		{ 
+			// just copy it over...sigh
+			perc1 = perc2;
+		}
+	}
+
+	// If needed, RAND can coexist with linear and either non-linear or wave.
+	if ( mFlags & FX_RGB_RAND )
+	{ 
+		// Random simply modulates the existing value
+		perc1 = flrand(0.0f, perc1);
+	}
+
+	// Now get the correct color 
+	VectorScale( mRGBStart, perc1, res );
+	VectorMA( res, 1.0f - perc1, mRGBEnd, res );
+
+	res[0] = Com_Clamp(0.0f, 1.0f, res[0]) * 255.0f;
+	res[1] = Com_Clamp(0.0f, 1.0f, res[1]) * 255.0f;
+	res[2] = Com_Clamp(0.0f, 1.0f, res[2]) * 255.0f;
+
+	*(int *)mRefEnt.shaderRGBA = VectorToInt(res);
+}
+
+//----------------------------
+// Update Alpha
+//----------------------------
+void CParticle::UpdateAlpha(void)
+{
+	int		alpha;
+
+	// completely biased towards start if it doesn't get overridden
+	float	perc1 = 1.0f, perc2 = 1.0f;
+
+	if ( (mFlags & FX_ALPHA_LINEAR) )
+	{ 
+		// calculate element biasing
+		perc1 = 1.0f - (float)(theFxHelper.mTime - mTimeStart) / (float)(mTimeEnd - mTimeStart);
+	}
+
+	// We can combine FX_LINEAR with _either_ FX_NONLINEAR, FX_WAVE, or FX_CLAMP
+	if (( mFlags & FX_ALPHA_PARM_MASK ) == FX_ALPHA_NONLINEAR )
+	{
+		if ( theFxHelper.mTime > mAlphaParm )
+		{ 
+			// get percent done, using parm as the start of the non-linear fade
+			perc2 = 1.0f - (float)(theFxHelper.mTime - mAlphaParm) / (float)(mTimeEnd - mAlphaParm);
+		}
+
+		if (( mFlags & FX_ALPHA_LINEAR ))
+		{ 
+			// do an even blend
+			perc1 = perc1 * 0.5f + perc2 * 0.5f;
+		}
+		else
+		{ 
+			// just copy it over...sigh
+			perc1 = perc2;
+		}
+	}
+	else if (( mFlags & FX_ALPHA_PARM_MASK ) == FX_ALPHA_WAVE )
+	{ 
+		// wave gen, with parm being the frequency multiplier
+		perc1 = perc1 * cosf( (theFxHelper.mTime - mTimeStart) * mAlphaParm );
+	}
+	else if (( mFlags & FX_ALPHA_PARM_MASK ) == FX_ALPHA_CLAMP )
+	{
+		if ( theFxHelper.mTime < mAlphaParm )
+		{ 
+			// get percent done, using parm as the start of the non-linear fade
+			perc2 = (float)(mAlphaParm - theFxHelper.mTime) / (float)(mAlphaParm - mTimeStart);
+		}
+		else
+		{
+			perc2 = 0.0f; // make it full size??
+		}
+
+		if (( mFlags & FX_ALPHA_LINEAR ))
+		{ 
+			// do an even blend
+			perc1 = perc1 * 0.5f + perc2 * 0.5f;
+		}
+		else
+		{ 
+			// just copy it over...sigh
+			perc1 = perc2;
+		}
+	}
+
+	perc1 = (mAlphaStart * perc1) + (mAlphaEnd * (1.0f - perc1));
+
+	// We should be in the right range, but clamp to ensure
+	perc1 = Com_Clamp(0.0f, 1.0f, perc1);
+
+	// If needed, RAND can coexist with linear and either non-linear or wave.
+	if ( mFlags & FX_ALPHA_RAND )
+	{ 
+		// Random simply modulates the existing value
+		perc1 = flrand(0.0f, perc1);
+	}
+
+	alpha = Com_Clamp(0, 255, perc1 * 255.0f);
+	if ( mFlags & FX_USE_ALPHA )
+	{
+		// should use this when using art that has an alpha channel
+		 mRefEnt.shaderRGBA[3] = (byte)alpha;
+	}
+	else
+	{
+		// Modulate the rgb fields by the alpha value to do the fade, works fine for additive blending
+		mRefEnt.shaderRGBA[0] = ((int)mRefEnt.shaderRGBA[0] * alpha) >> 8;
+		mRefEnt.shaderRGBA[1] = ((int)mRefEnt.shaderRGBA[1] * alpha) >> 8;
+		mRefEnt.shaderRGBA[2] = ((int)mRefEnt.shaderRGBA[2] * alpha) >> 8;
+	}
+}
+
+//--------------------------
+void CParticle::UpdateRotation(void)
+{
+	mRefEnt.rotation += theFxHelper.mFrameTime * 0.01f * mRotationDelta;
+	mRotationDelta *= ( 1.0f - ( theFxHelper.mFrameTime * 0.0007f )); // decay rotationDelta
+}
+
+
+//--------------------------------
+//
+// Derived Oriented Particle Class
+//
+//--------------------------------
+COrientedParticle::COrientedParticle(void)
+{
+	mRefEnt.reType = RT_ORIENTED_QUAD;
+}
+
+//----------------------------
+bool COrientedParticle::Cull(void)
+{
+	vec3_t	dir;
+//	float	len;
+
+	// Get the direction to the view
+	VectorSubtract( mOrigin1, theFxHelper.refdef->vieworg, dir );
+
+	// Check if it's behind the viewer
+	if ( (DotProduct( theFxHelper.refdef->viewaxis[0], dir )) < 0 )
+	{
+		return true;
+	}
+
+//	len = VectorLengthSquared( dir );
+
+	// don't cull stuff that's associated with inview wpns
+	if ( mFlags & FX_DEPTH_HACK )
+	{
+		return false;
+	}
+	// Can't be too close
+//	if ( len < fx_nearCull->value * fx_nearCull->value)
+//	{
+//		return true;
+//	}
+
+	return false;
+}
+
+//----------------------------
+void COrientedParticle::Draw(void)
+{
+	if ( mFlags & FX_DEPTH_HACK )
+	{
+		// Not sure if first person needs to be set
+		mRefEnt.renderfx |= RF_DEPTHHACK;
+	}
+
+	// Add our refEntity to the scene
+	VectorCopy( mOrigin1, mRefEnt.origin );
+	if ( !(mFlags&FX_RELATIVE) )
+	{
+		VectorCopy( mNormal, mRefEnt.axis[0] );
+		MakeNormalVectors( mRefEnt.axis[0], mRefEnt.axis[1], mRefEnt.axis[2] );
+	}
+
+	theFxHelper.AddFxToScene( &mRefEnt );
+	drawnFx++;	
+}
+
+//----------------------------
+// Update
+//----------------------------
+bool COrientedParticle::Update(void)
+{
+	// Game pausing can cause dumb time things to happen, so kill the effect in this instance
+	if ( mTimeStart > theFxHelper.mTime )
+	{
+		return false;
+	}
+		
+	if ( mFlags & FX_RELATIVE )
+	{
+		if ( !mGhoul2.IsValid())
+		{	// the thing we are bolted to is no longer valid, so we may as well just die.
+			return false;
+		}
+		vec3_t	org;
+		vec3_t	ax[3];
+
+		// Get our current position and direction
+		if (!theFxHelper.GetOriginAxisFromBolt(&mGhoul2, mEntNum, mModelNum, mBoltNum, org, ax))
+		{	//could not get bolt
+			return false;
+		}
+		vec3_t 	realVel, realAccel;
+
+		VectorMA( org, mOrgOffset[0], ax[0], org );
+		VectorMA( org, mOrgOffset[1], ax[1], org );
+		VectorMA( org, mOrgOffset[2], ax[2], org );
+
+		const float	time = (theFxHelper.mTime - mTimeStart) * 0.001f;
+		// calc the real velocity and accel vectors
+		VectorScale( ax[0], mVel[0], realVel );
+		VectorMA( realVel, mVel[1], ax[1], realVel );
+		VectorMA( realVel, mVel[2], ax[2], realVel );
+//		realVel[2] += 0.5f * mGravity * time;
+
+		VectorScale( ax[0], mAccel[0], realAccel );
+		VectorMA( realAccel, mAccel[1], ax[1], realAccel );
+		VectorMA( realAccel, mAccel[2], ax[2], realAccel );
+
+		// Get our real velocity at the current time, taking into account the effects of acceleartion.  NOTE: not sure if this is even 100% correct math-wise
+		VectorMA( realVel, time, realAccel, realVel );
+
+		// Now move us to where we should be at the given time
+		VectorMA( org, time, realVel, mOrigin1 );
+
+		//use the normalOffset and add that to the actual normal of the bolt
+		//NOTE: not tested!!!
+		VectorCopy( ax[0], mRefEnt.axis[0] );
+		VectorCopy( ax[1], mRefEnt.axis[1] );
+		VectorCopy( ax[2], mRefEnt.axis[2] );
+
+		//vec3_t	offsetAngles;
+		//VectorSet( offsetAngles, 0, 90, 90 );
+
+		vec3_t	offsetAxis[3];
+		//NOTE: mNormal is actually PITCH YAW and ROLL offsets
+		AnglesToAxis( mNormal, offsetAxis );
+		MatrixMultiply( offsetAxis, ax, mRefEnt.axis );
+	}
+	else if (( mTimeStart < theFxHelper.mTime ) && UpdateOrigin() == false )
+	{
+		// we are marked for death
+		return false;
+	}
+
+	if ( !Cull() )
+	{	// Only update these if the thing is visible.	
+		UpdateSize();
+		UpdateRGB();
+		UpdateAlpha();
+		UpdateRotation();
+
+		Draw();
+	}
+
+	return true;
+}
+
+
+//----------------------------
+//
+// Derived Line Class
+//
+//----------------------------
+CLine::CLine(void)
+{
+	mRefEnt.reType = RT_LINE;
+}
+
+//----------------------------
+void CLine::Draw(void)
+{
+	if ( mFlags & FX_DEPTH_HACK )
+	{
+		// Not sure if first person needs to be set, but it can't hurt?
+		mRefEnt.renderfx |= RF_DEPTHHACK;
+	}
+
+	VectorCopy( mOrigin1, mRefEnt.origin );
+	VectorCopy( mOrigin2, mRefEnt.oldorigin );
+
+	theFxHelper.AddFxToScene(&mRefEnt);
+	drawnFx++;	
+}
+
+//----------------------------
+bool CLine::Update(void)
+{
+	// Game pausing can cause dumb time things to happen, so kill the effect in this instance
+	if ( mTimeStart > theFxHelper.mTime )
+	{
+		return false;
+	}
+
+	if ( mFlags & FX_RELATIVE )
+	{
+		if ( !mGhoul2.IsValid())
+		{	// the thing we are bolted to is no longer valid, so we may as well just die.
+			return false;
+		}
+
+		vec3_t	ax[3];
+		// Get our current position and direction
+		if (!theFxHelper.GetOriginAxisFromBolt(&mGhoul2, mEntNum, mModelNum, mBoltNum, mOrigin1, ax))
+		{	//could not get bolt
+			return false;
+		}
+
+		VectorAdd(mOrigin1, mOrgOffset, mOrigin1);	//add the offset to the bolt point
+		
+		VectorMA( mOrigin1, mVel[0], ax[0], mOrigin2 );
+		VectorMA( mOrigin2, mVel[1], ax[1], mOrigin2 );
+		VectorMA( mOrigin2, mVel[2], ax[2], mOrigin2 );
+	}
+
+	if ( !Cull())
+	{	
+		// Only update these if the thing is visible.	
+		UpdateSize();
+		UpdateRGB();
+		UpdateAlpha();
+
+		Draw();
+	}
+
+	return true;
+}
+
+//----------------------------
+//
+// Derived Electricity Class
+//
+//----------------------------
+CElectricity::CElectricity(void)
+{
+	mRefEnt.reType = RT_ELECTRICITY;
+}
+
+//----------------------------
+void CElectricity::Initialize(void)
+{
+	mRefEnt.frame = flrand(0.0f, 1.0f) * 1265536.0f;
+	mRefEnt.axis[0][2] = theFxHelper.mTime + (mTimeEnd - mTimeStart); // endtime
+
+	if ( mFlags & FX_DEPTH_HACK )
+	{
+		mRefEnt.renderfx |= RF_DEPTHHACK;
+	}
+
+	if ( mFlags & FX_BRANCH )
+	{
+		mRefEnt.renderfx |= RF_FORKED;	
+	}
+
+	if ( mFlags & FX_TAPER )
+	{
+		mRefEnt.renderfx |= RF_TAPERED;
+	}
+
+	if ( mFlags & FX_GROW )
+	{
+		mRefEnt.renderfx |= RF_GROW;
+	}
+}
+
+//----------------------------
+void CElectricity::Draw(void)
+{
+	VectorCopy( mOrigin1, mRefEnt.origin );
+	VectorCopy( mOrigin2, mRefEnt.oldorigin );
+	mRefEnt.axis[0][0] = mChaos;
+	mRefEnt.axis[0][1] = mTimeEnd - mTimeStart;
+
+	theFxHelper.AddFxToScene( &mRefEnt );
+	drawnFx++;	
+}
+
+//----------------------------
+bool CElectricity::Update(void)
+{
+	// Game pausing can cause dumb time things to happen, so kill the effect in this instance
+	if ( mTimeStart > theFxHelper.mTime )
+	{
+		return false;
+	}
+
+	if ( mFlags & FX_RELATIVE )
+	{
+		if ( !mGhoul2.IsValid())
+		{	// the thing we are bolted to is no longer valid, so we may as well just die.
+			return false;
+		}
+
+		vec3_t	ax[3];
+		// Get our current position and direction
+		if (!theFxHelper.GetOriginAxisFromBolt(&mGhoul2, mEntNum, mModelNum, mBoltNum, mOrigin1, ax))
+		{	//could not get bolt
+			return false;
+		}
+
+		VectorAdd(mOrigin1, mOrgOffset, mOrigin1);	//add the offset to the bolt point
+		
+		VectorMA( mOrigin1, mVel[0], ax[0], mOrigin2 );
+		VectorMA( mOrigin2, mVel[1], ax[1], mOrigin2 );
+		VectorMA( mOrigin2, mVel[2], ax[2], mOrigin2 );
+	}
+
+	if ( !Cull())
+	{	
+		// Only update these if the thing is visible.	
+		UpdateSize();
+		UpdateRGB();
+		UpdateAlpha();
+		
+		Draw();
+	}
+
+	return true;
+}
+
+//----------------------------
+//
+// Derived Tail Class
+//
+//----------------------------
+CTail::CTail(void)
+{
+	mRefEnt.reType = RT_LINE;
+}
+
+//----------------------------
+void CTail::Draw(void)
+{
+	if ( mFlags & FX_DEPTH_HACK )
+	{
+		// Not sure if first person needs to be set
+		mRefEnt.renderfx |= RF_DEPTHHACK;
+	}
+
+	VectorCopy( mOrigin1, mRefEnt.origin );
+
+	theFxHelper.AddFxToScene(&mRefEnt);
+	drawnFx++;	
+}
+
+//----------------------------
+bool CTail::Update(void)
+{
+	// Game pausing can cause dumb time things to happen, so kill the effect in this instance
+	if ( mTimeStart > theFxHelper.mTime )
+	{
+		return false;
+	}
+		
+	if ( mFlags & FX_RELATIVE )
+	{
+		if ( !mGhoul2.IsValid())
+		{	// the thing we are bolted to is no longer valid, so we may as well just die.
+			return false;
+		}
+		vec3_t	org;
+		vec3_t	ax[3];
+		if (mModelNum>=0 && mBoltNum>=0)	//bolt style
+		{
+			if (!theFxHelper.GetOriginAxisFromBolt(&mGhoul2, mEntNum, mModelNum, mBoltNum, org, ax))
+			{	//could not get bolt
+				return false;
+			}
+		}
+
+		vec3_t 	realVel, realAccel;
+
+		VectorMA( org, mOrgOffset[0], ax[0], org );
+		VectorMA( org, mOrgOffset[1], ax[1], org );
+		VectorMA( org, mOrgOffset[2], ax[2], org );
+
+		// calc the real velocity and accel vectors
+		// FIXME: if you want right and up movement in addition to the forward movement, you'll have to convert dir into a set of perp. axes and do some extra work
+		VectorScale( ax[0], mVel[0], realVel );
+		VectorMA( realVel, mVel[1], ax[1], realVel );
+		VectorMA( realVel, mVel[2], ax[2], realVel );
+
+		VectorScale( ax[0], mAccel[0], realAccel );
+		VectorMA( realAccel, mAccel[1], ax[1], realAccel );
+		VectorMA( realAccel, mAccel[2], ax[2], realAccel );
+
+		const float	time = (theFxHelper.mTime - mTimeStart) * 0.001f;
+
+		// Get our real velocity at the current time, taking into account the effects of acceleration.  NOTE: not sure if this is even 100% correct math-wise
+		VectorMA( realVel, time, realAccel, realVel );
+
+		// Now move us to where we should be at the given time
+		VectorMA( org, time, realVel, mOrigin1 );
+
+		// Just calc an old point some time in the past, doesn't really matter when
+		VectorMA( org, (time - 0.003f), realVel, mOldOrigin );
+	}
+#ifdef _SOF2DEV_
+	else if ( !fx_freeze->integer )
+#else
+	else
+#endif
+	{
+		VectorCopy( mOrigin1, mOldOrigin );
+	}
+
+	if (( mTimeStart < theFxHelper.mTime ) && UpdateOrigin() == false )
+	{
+		// we are marked for death
+		return false;
+	}
+
+	if ( !Cull() )
+	{	
+		// Only update these if the thing is visible.	
+		UpdateSize();
+		UpdateLength();
+		UpdateRGB();
+		UpdateAlpha();
+
+		CalcNewEndpoint();
+		Draw();
+	}
+
+	return true;
+}
+
+//----------------------------
+void CTail::UpdateLength(void)
+{
+	// completely biased towards start if it doesn't get overridden
+	float	perc1 = 1.0f, perc2 = 1.0f; 
+
+	if ( mFlags & FX_LENGTH_LINEAR )
+	{ 
+		// calculate element biasing
+		perc1 = 1.0f - (float)(theFxHelper.mTime - mTimeStart) / (float)(mTimeEnd - mTimeStart);
+	}
+
+	// We can combine FX_LINEAR with _either_ FX_NONLINEAR or FX_WAVE
+	if (( mFlags & FX_LENGTH_PARM_MASK ) == FX_LENGTH_NONLINEAR )
+	{
+		if ( theFxHelper.mTime > mLengthParm )
+		{ 
+			// get percent done, using parm as the start of the non-linear fade
+			perc2 = 1.0f - (float)(theFxHelper.mTime - mLengthParm) / (float)(mTimeEnd - mLengthParm);
+		}
+
+		if ( mFlags & FX_LENGTH_LINEAR )
+		{ 
+			// do an even blend
+			perc1 = perc1 * 0.5f + perc2 * 0.5f;
+		}
+		else
+		{ 
+			// just copy it over...sigh
+			perc1 = perc2;
+		}
+	}
+	else if (( mFlags & FX_LENGTH_PARM_MASK ) == FX_LENGTH_WAVE )
+	{ 
+		// wave gen, with parm being the frequency multiplier
+		perc1 = perc1 * cosf( (theFxHelper.mTime - mTimeStart) * mLengthParm );
+	}
+	else if (( mFlags & FX_LENGTH_PARM_MASK ) == FX_LENGTH_CLAMP )
+	{
+		if ( theFxHelper.mTime < mLengthParm )
+		{ 
+			// get percent done, using parm as the start of the non-linear fade
+			perc2 = (float)(mLengthParm - theFxHelper.mTime) / (float)(mLengthParm - mTimeStart);
+		}
+		else
+		{
+			perc2 = 0.0f; // make it full size??
+		}
+
+		if ( mFlags & FX_LENGTH_LINEAR )
+		{ 
+			// do an even blend
+			perc1 = perc1 * 0.5f + perc2 * 0.5f;
+		}
+		else
+		{ 
+			// just copy it over...sigh
+			perc1 = perc2;
+		}
+	}
+
+	// If needed, RAND can coexist with linear and either non-linear or wave.
+	if ( mFlags & FX_LENGTH_RAND )
+	{ 
+		// Random simply modulates the existing value
+		perc1 = flrand(0.0f, perc1);
+	}
+
+	mLength = (mLengthStart * perc1) + (mLengthEnd * (1.0f - perc1));
+}
+
+
+//----------------------------
+void CTail::CalcNewEndpoint(void)
+{
+	vec3_t temp;
+
+	// FIXME:  Hmmm, this looks dumb when physics are on and a bounce happens
+	VectorSubtract( mOldOrigin, mOrigin1, temp );
+
+	// I wish we didn't have to do a VectorNormalize every frame.....
+	VectorNormalize( temp );
+
+	VectorMA( mOrigin1, mLength, temp, mRefEnt.oldorigin );
+}
+
+
+//----------------------------
+//
+// Derived Cylinder Class
+//
+//----------------------------
+CCylinder::CCylinder(void)
+{
+	mRefEnt.reType = RT_CYLINDER;
+	mTraceEnd = qfalse;
+}
+
+bool CCylinder::Cull(void)
+{
+	if (mTraceEnd)
+	{ //eh, don't cull variable-length cylinders
+		return false;
+	}
+
+	return CTail::Cull();
+}
+
+void CCylinder::UpdateLength(void)
+{
+	if (mTraceEnd)
+	{
+		vec3_t temp;
+		trace_t tr;
+
+		VectorMA( mOrigin1, FX_MAX_TRACE_DIST, mRefEnt.axis[0], temp );
+		theFxHelper.Trace( tr, mOrigin1, NULL, NULL, temp, -1, MASK_SOLID );
+		VectorSubtract( tr.endpos, mOrigin1, temp );
+		mLength = VectorLength(temp);
+	}
+	else
+	{
+		CTail::UpdateLength();
+	}
+}
+
+//----------------------------
+void CCylinder::Draw(void)
+{
+	if ( mFlags & FX_DEPTH_HACK )
+	{
+		// Not sure if first person needs to be set, but it can't hurt?
+		mRefEnt.renderfx |= RF_DEPTHHACK;
+	}
+
+	VectorCopy( mOrigin1, mRefEnt.origin );
+	VectorMA( mOrigin1, mLength, mRefEnt.axis[0], mRefEnt.oldorigin );
+
+	theFxHelper.AddFxToScene(&mRefEnt);
+	drawnFx++;	
+}
+
+//----------------------------
+// Update Size2
+//----------------------------
+void CCylinder::UpdateSize2(void)
+{
+	// completely biased towards start if it doesn't get overridden
+	float	perc1 = 1.0f, perc2 = 1.0f; 
+
+	if ( mFlags & FX_SIZE2_LINEAR )
+	{ 
+		// calculate element biasing
+		perc1 = 1.0f - (float)(theFxHelper.mTime - mTimeStart) / (float)(mTimeEnd - mTimeStart);
+	}
+
+	// We can combine FX_LINEAR with _either_ FX_NONLINEAR or FX_WAVE
+	if (( mFlags & FX_SIZE2_PARM_MASK ) == FX_SIZE2_NONLINEAR )
+	{
+		if ( theFxHelper.mTime > mSize2Parm )
+		{ 
+			// get percent done, using parm as the start of the non-linear fade
+			perc2 = 1.0f - (float)(theFxHelper.mTime - mSize2Parm) / (float)(mTimeEnd - mSize2Parm);
+		}
+
+		if ( (mFlags & FX_SIZE2_LINEAR) )
+		{ 
+			// do an even blend
+			perc1 = perc1 * 0.5f + perc2 * 0.5f;
+		}
+		else
+		{ 
+			// just copy it over...sigh
+			perc1 = perc2;
+		}
+	}
+	else if (( mFlags & FX_SIZE2_PARM_MASK ) == FX_SIZE2_WAVE )
+	{ 
+		// wave gen, with parm being the frequency multiplier
+		perc1 = perc1 * cosf( (theFxHelper.mTime - mTimeStart) * mSize2Parm );
+	}
+	else if (( mFlags & FX_SIZE2_PARM_MASK ) == FX_SIZE2_CLAMP )
+	{
+		if ( theFxHelper.mTime < mSize2Parm )
+		{ 
+			// get percent done, using parm as the start of the non-linear fade
+			perc2 = (float)(mSize2Parm - theFxHelper.mTime) / (float)(mSize2Parm - mTimeStart);
+		}
+		else
+		{
+			perc2 = 0.0f; // make it full size??
+		}
+
+		if ( mFlags & FX_SIZE2_LINEAR )
+		{ 
+			// do an even blend
+			perc1 = perc1 * 0.5f + perc2 * 0.5f;
+		}
+		else
+		{ 
+			// just copy it over...sigh
+			perc1 = perc2;
+		}
+	}
+
+	// If needed, RAND can coexist with linear and either non-linear or wave.
+	if ( mFlags & FX_SIZE2_RAND )
+	{ 
+		// Random simply modulates the existing value
+		perc1 = flrand(0.0f, perc1);
+	}
+
+	mRefEnt.rotation = (mSize2Start * perc1) + (mSize2End * (1.0f - perc1));
+}
+
+//----------------------------
+bool CCylinder::Update(void)
+{
+	// Game pausing can cause dumb time things to happen, so kill the effect in this instance
+	if ( mTimeStart > theFxHelper.mTime )
+	{
+		return false;
+	}
+
+	if ( mFlags & FX_RELATIVE )
+	{
+		if ( !mGhoul2.IsValid())
+		{	// the thing we are bolted to is no longer valid, so we may as well just die.
+			return false;
+		}
+
+		vec3_t	ax[3];
+		// Get our current position and direction
+		if (!theFxHelper.GetOriginAxisFromBolt(&mGhoul2, mEntNum, mModelNum, mBoltNum, mOrigin1, ax))
+		{	//could not get bolt
+			return false;
+		}
+
+		VectorAdd(mOrigin1, mOrgOffset, mOrigin1);	//add the offset to the bolt point
+		
+		VectorCopy( ax[0], mRefEnt.axis[0] );
+		//FIXME: should mNormal be a modifier on the forward axis?
+		/*
+		VectorMA( mOrigin1, mNormal[0], ax[0], mOrigin2 );
+		VectorMA( mOrigin2, mNormal[1], ax[1], mOrigin2 );
+		VectorMA( mOrigin2, mNormal[2], ax[2], mOrigin2 );
+		*/
+	}
+		
+	if ( !Cull() )
+	{	
+		// Only update these if the thing is visible.	
+		UpdateSize();
+		UpdateSize2();
+		UpdateLength();
+		UpdateRGB();
+		UpdateAlpha();
+		
+		Draw();
+	}
+
+	return true;
+}
+
+
+//----------------------------
+//
+// Derived Emitter Class
+//
+//----------------------------
+CEmitter::CEmitter(void)
+{
+	// There may or may not be a model, but if there isn't one, 
+	//	we just won't bother adding the refEnt in our Draw func
+	mRefEnt.reType = RT_MODEL;
+}
+
+//----------------------------
+CEmitter::~CEmitter(void)
+{
+}
+
+//----------------------------
+// Draw
+//----------------------------
+void CEmitter::Draw(void)
+{
+	// Emitters don't draw themselves, but they may need to add an attached model
+	if ( mFlags & FX_ATTACHED_MODEL )
+	{
+		mRefEnt.nonNormalizedAxes = qtrue;
+
+		VectorCopy( mOrigin1, mRefEnt.origin );
+
+	 	VectorScale( mRefEnt.axis[0], mRefEnt.radius, mRefEnt.axis[0] );
+	 	VectorScale( mRefEnt.axis[1], mRefEnt.radius, mRefEnt.axis[1] );
+	 	VectorScale( mRefEnt.axis[2], mRefEnt.radius, mRefEnt.axis[2] );
+
+		theFxHelper.AddFxToScene((miniRefEntity_t*)0);// I hate having to do this, but this needs to get added as a regular refEntity
+		theFxHelper.AddFxToScene(&mRefEnt);
+	}
+
+	// If we are emitting effects, we had better be careful because just calling it every cgame frame could
+	//	either choke up the effects system on a fast machine, or look really nasty on a low end one.
+	if ( mFlags & FX_EMIT_FX )
+	{
+		vec3_t	org, v;
+		float	ftime, time2, step;
+		int		t, dif;
+
+#define TRAIL_RATE		12 // we "think" at about a 60hz rate
+
+		// Pick a target step distance and square it
+		step = mDensity + flrand(-mVariance, mVariance);
+		step *= step;
+
+		dif = 0;
+
+		for ( t = mOldTime; t <= theFxHelper.mTime; t += TRAIL_RATE ) 
+		{
+			dif += TRAIL_RATE;
+
+			// ?Not sure if it's better to update this before or after updating the origin
+			VectorMA( mOldVelocity, dif * 0.001f, mAccel, v );
+
+			// Calc the time differences
+			ftime = dif * 0.001f;
+			time2 = ftime * ftime * 0.5f;
+
+			// Predict the new position
+			org[0] = mOldOrigin[0] + (ftime * v[0]) + (time2 * v[0]);
+			org[1] = mOldOrigin[1] + (ftime * v[1]) + (time2 * v[1]);
+			org[2] = mOldOrigin[2] + (ftime * v[2]) + (time2 * v[2]);
+	
+			// Is it time to draw an effect?
+			if ( DistanceSquared( org, mOldOrigin ) >= step )
+			{ 
+				// Pick a new target step distance and square it
+				step = mDensity + flrand(-mVariance, mVariance);
+				step *= step;
+
+				// We met the step criteria so, we should add in the effect
+				theFxScheduler.PlayEffect( mEmitterFxID, org, mRefEnt.axis );
+
+				VectorCopy( org, mOldOrigin );
+				VectorCopy( v, mOldVelocity );
+				dif = 0;
+				mOldTime = t;
+			}
+		}
+	}
+	drawnFx++;	
+}
+
+//----------------------------
+bool CEmitter::Update(void)
+{
+	// Game pausing can cause dumb time things to happen, so kill the effect in this instance
+	if ( mTimeStart > theFxHelper.mTime )
+	{
+		return false;
+	}
+		
+	// Use this to track if we've stopped moving
+	VectorCopy( mOrigin1, mOldOrigin );
+	VectorCopy( mVel, mOldVelocity );
+
+	if ( mFlags & FX_RELATIVE )
+	{
+		if ( !mGhoul2.IsValid())
+		{	// the thing we are bolted to is no longer valid, so we may as well just die.
+			return false;
+		}
+		assert(0);//need this?
+		
+	}
+	if (( mTimeStart < theFxHelper.mTime ) && UpdateOrigin() == false )
+	{
+		// we are marked for death
+		return false;
+	}
+
+	bool moving = false;
+
+	// If the thing is no longer moving, kill the angle delta, but don't do it too quickly or it will
+	//	look very artificial.  Don't do it too slowly or it will look like there is no friction.
+	if ( VectorCompare( mOldOrigin, mOrigin1 ))
+	{
+		VectorScale( mAngleDelta, 0.7f, mAngleDelta );
+	}
+	else
+	{
+		moving = true;
+	}
+
+	if ( mFlags & FX_PAPER_PHYSICS )
+	{
+		// do this in a more framerate independant manner
+		float sc = ( 20.0f / theFxHelper.mFrameTime);
+
+		// bah, evil clamping
+		if ( sc >= 1.0f )
+		{
+			sc = 1.0f;
+		}
+
+		if ( moving )
+		{
+			// scale the velocity down, basically inducing drag.  Acceleration ( gravity ) should keep it pulling down, which is what we want.
+			VectorScale( mVel, (sc * 0.8f + 0.2f ) * 0.92f, mVel );
+
+			// add some chaotic motion based on the way we are oriented
+			VectorMA( mVel, (1.5f - sc) * 4.0f, mRefEnt.axis[0], mVel );
+			VectorMA( mVel, (1.5f - sc) * 4.0f, mRefEnt.axis[1], mVel );
+		}
+
+		// make us settle so we can lay flat
+		mAngles[0] *= (0.97f * (sc * 0.4f + 0.6f ));
+		mAngles[2] *= (0.97f * (sc * 0.4f + 0.6f ));
+
+		// decay our angle delta so we don't rotate as quickly
+		VectorScale( mAngleDelta, (0.96f * (sc * 0.1f + 0.9f )), mAngleDelta );
+	}
+
+	UpdateAngles();
+	UpdateSize();
+
+	Draw();
+
+	return true;
+}
+
+//----------------------------
+void CEmitter::UpdateAngles(void)
+{
+	VectorMA( mAngles, theFxHelper.mFrameTime * 0.01f, mAngleDelta, mAngles ); // was 0.001f, but then you really have to jack up the delta to even notice anything
+	AnglesToAxis( mAngles, mRefEnt.axis );
+}
+
+
+//--------------------------
+//
+// Derived Light Class
+//
+//--------------------------
+
+//----------------------------
+void CLight::Draw(void)
+{
+#ifdef VV_LIGHTING
+	VVLightMan.RE_AddLightToScene( mOrigin1, mRefEnt.radius, mRefEnt.origin[0], mRefEnt.origin[1], mRefEnt.origin[2] );
+#else
+	theFxHelper.AddLightToScene( mOrigin1, mRefEnt.radius, mRefEnt.origin[0], mRefEnt.origin[1], mRefEnt.origin[2] );
+#endif
+	drawnFx++;	
+}
+
+//----------------------------
+// Update
+//----------------------------
+bool CLight::Update(void)
+{
+	// Game pausing can cause dumb time things to happen, so kill the effect in this instance
+	if ( mTimeStart > theFxHelper.mTime )
+	{
+		return false;
+	}
+
+	if ( mFlags & FX_RELATIVE )
+	{
+		if ( !mGhoul2.IsValid())
+		{	// the thing we are bolted to is no longer valid, so we may as well just die.
+			return false;
+		}
+
+		vec3_t	ax[3];
+		// Get our current position and direction
+		if (!theFxHelper.GetOriginAxisFromBolt(&mGhoul2, mEntNum, mModelNum, mBoltNum, mOrigin1, ax))
+		{	//could not get bolt
+			return false;
+		}
+
+		VectorMA( mOrigin1, mOrgOffset[0], ax[0], mOrigin1 );
+		VectorMA( mOrigin1, mOrgOffset[1], ax[1], mOrigin1 );
+		VectorMA( mOrigin1, mOrgOffset[2], ax[2], mOrigin1 );
+	}
+
+	UpdateSize();
+	UpdateRGB();
+	
+	Draw();
+
+	return true;
+}
+
+//----------------------------
+// Update Size
+//----------------------------
+void CLight::UpdateSize(void)
+{
+	// completely biased towards start if it doesn't get overridden
+	float	perc1 = 1.0f, perc2 = 1.0f; 
+
+	if ( mFlags & FX_SIZE_LINEAR )
+	{ 
+		// calculate element biasing
+		perc1 = 1.0f - (float)(theFxHelper.mTime - mTimeStart) / (float)(mTimeEnd - mTimeStart);
+	}
+
+	// We can combine FX_LINEAR with _either_ FX_NONLINEAR or FX_WAVE
+	if (( mFlags & FX_SIZE_PARM_MASK ) == FX_SIZE_NONLINEAR )
+	{
+		if ( theFxHelper.mTime > mSizeParm )
+		{ 
+			// get percent done, using parm as the start of the non-linear fade
+			perc2 = 1.0f - (float)(theFxHelper.mTime - mSizeParm) / (float)(mTimeEnd - mSizeParm);
+		}
+
+		if ( (mFlags & FX_SIZE_LINEAR) )
+		{ 
+			// do an even blend
+			perc1 = perc1 * 0.5f + perc2 * 0.5f;
+		}
+		else
+		{ 
+			// just copy it over...sigh
+			perc1 = perc2;
+		}
+	}
+	else if (( mFlags & FX_SIZE_PARM_MASK ) == FX_SIZE_WAVE )
+	{ 
+		// wave gen, with parm being the frequency multiplier
+		perc1 = perc1 * cosf( (theFxHelper.mTime - mTimeStart) * mSizeParm );
+	}
+	else if (( mFlags & FX_SIZE_PARM_MASK ) == FX_SIZE_CLAMP )
+	{
+		if ( theFxHelper.mTime < mSizeParm )
+		{ 
+			// get percent done, using parm as the start of the non-linear fade
+			perc2 = (float)(mSizeParm - theFxHelper.mTime) / (float)(mSizeParm - mTimeStart);
+		}
+		else
+		{
+			perc2 = 0.0f; // make it full size??
+		}
+
+		if ( mFlags & FX_SIZE_LINEAR )
+		{ 
+			// do an even blend
+			perc1 = perc1 * 0.5f + perc2 * 0.5f;
+		}
+		else
+		{ 
+			// just copy it over...sigh
+			perc1 = perc2;
+		}
+	}
+
+	// If needed, RAND can coexist with linear and either non-linear or wave.
+	if ( mFlags & FX_SIZE_RAND )
+	{ 
+		// Random simply modulates the existing value
+		perc1 = flrand(0.0f, perc1);
+	}
+
+	mRefEnt.radius = (mSizeStart * perc1) + (mSizeEnd * (1.0f - perc1));
+}
+
+//----------------------------
+// Update RGB
+//----------------------------
+void CLight::UpdateRGB(void)
+{
+	// completely biased towards start if it doesn't get overridden
+	float	perc1 = 1.0f, perc2 = 1.0f; 
+	vec3_t	res;
+
+	if ( mFlags & FX_RGB_LINEAR )
+	{ 
+		// calculate element biasing
+		perc1 = 1.0f - (float)( theFxHelper.mTime - mTimeStart ) / (float)( mTimeEnd - mTimeStart );
+	}
+
+	// We can combine FX_LINEAR with _either_ FX_NONLINEAR or FX_WAVE
+	if (( mFlags & FX_RGB_PARM_MASK ) == FX_RGB_NONLINEAR )
+	{
+		if ( theFxHelper.mTime > mRGBParm )
+		{ 
+			// get percent done, using parm as the start of the non-linear fade
+			perc2 = 1.0f - (float)( theFxHelper.mTime - mRGBParm ) / (float)( mTimeEnd - mRGBParm );
+		}
+
+		if ( mFlags & FX_RGB_LINEAR )
+		{ 
+			// do an even blend
+			perc1 = perc1 * 0.5f + perc2 * 0.5f;
+		}
+		else
+		{ 
+			// just copy it over...sigh
+			perc1 = perc2;
+		}
+	}
+	else if (( mFlags & FX_RGB_PARM_MASK ) == FX_RGB_WAVE )
+	{ 
+		// wave gen, with parm being the frequency multiplier
+		perc1 = perc1 * cosf(( theFxHelper.mTime - mTimeStart ) * mRGBParm );
+	}
+	else if (( mFlags & FX_RGB_PARM_MASK ) == FX_RGB_CLAMP )
+	{
+		if ( theFxHelper.mTime < mRGBParm )
+		{ 
+			// get percent done, using parm as the start of the non-linear fade
+			perc2 = (float)(mRGBParm - theFxHelper.mTime) / (float)(mRGBParm - mTimeStart);
+		}
+		else
+		{
+			perc2 = 0.0f; // make it full size??
+		}
+
+		if ( mFlags & FX_RGB_LINEAR )
+		{ 
+			// do an even blend
+			perc1 = perc1 * 0.5f + perc2 * 0.5f;
+		}
+		else
+		{ 
+			// just copy it over...sigh
+			perc1 = perc2;
+		}
+	}
+
+	// If needed, RAND can coexist with linear and either non-linear or wave.
+	if ( mFlags & FX_RGB_RAND )
+	{ 
+		// Random simply modulates the existing value
+		perc1 = flrand(0.0f, perc1);
+	}
+
+	// Now get the correct color 
+	VectorScale( mRGBStart, perc1, res );
+	VectorMA(res, ( 1.0f - perc1 ), mRGBEnd, mRefEnt.origin);
+}
+
+//--------------------------
+//
+// Derived Trail Class
+//
+//--------------------------
+#define NEW_MUZZLE	0
+#define NEW_TIP		1
+#define OLD_TIP		2
+#define OLD_MUZZLE	3
+
+//----------------------------
+void CTrail::Draw()
+{
+	polyVert_t	verts[3];
+//	vec3_t		color;
+
+	// build the first tri out of the new muzzle...new tip...old muzzle
+	VectorCopy( mVerts[NEW_MUZZLE].origin, verts[0].xyz );
+	VectorCopy( mVerts[NEW_TIP].origin, verts[1].xyz );
+	VectorCopy( mVerts[OLD_MUZZLE].origin, verts[2].xyz );
+
+//	VectorScale( mVerts[NEW_MUZZLE].curRGB, mVerts[NEW_MUZZLE].curAlpha, color );
+	verts[0].modulate[0] = mVerts[NEW_MUZZLE].rgb[0];
+	verts[0].modulate[1] = mVerts[NEW_MUZZLE].rgb[1];
+	verts[0].modulate[2] = mVerts[NEW_MUZZLE].rgb[2];
+	verts[0].modulate[3] = mVerts[NEW_MUZZLE].alpha;
+
+//	VectorScale( mVerts[NEW_TIP].curRGB, mVerts[NEW_TIP].curAlpha, color );
+	verts[1].modulate[0] = mVerts[NEW_TIP].rgb[0];
+	verts[1].modulate[1] = mVerts[NEW_TIP].rgb[1];
+	verts[1].modulate[2] = mVerts[NEW_TIP].rgb[2];
+	verts[1].modulate[3] = mVerts[NEW_TIP].alpha;
+
+//	VectorScale( mVerts[OLD_MUZZLE].curRGB, mVerts[OLD_MUZZLE].curAlpha, color );
+	verts[2].modulate[0] = mVerts[OLD_MUZZLE].rgb[0];
+	verts[2].modulate[1] = mVerts[OLD_MUZZLE].rgb[1];
+	verts[2].modulate[2] = mVerts[OLD_MUZZLE].rgb[2];
+	verts[2].modulate[3] = mVerts[OLD_MUZZLE].alpha;
+
+	verts[0].st[0] = mVerts[NEW_MUZZLE].curST[0];
+	verts[0].st[1] = mVerts[NEW_MUZZLE].curST[1];
+	verts[1].st[0] = mVerts[NEW_TIP].curST[0];
+	verts[1].st[1] = mVerts[NEW_TIP].curST[1];
+	verts[2].st[0] = mVerts[OLD_MUZZLE].curST[0];
+	verts[2].st[1] = mVerts[OLD_MUZZLE].curST[1];
+
+	// Add this tri
+	theFxHelper.AddPolyToScene( mShader, 3, verts );
+
+	// build the second tri out of the old muzzle...old tip...new tip
+	VectorCopy( mVerts[OLD_MUZZLE].origin, verts[0].xyz );
+	VectorCopy( mVerts[OLD_TIP].origin, verts[1].xyz );
+	VectorCopy( mVerts[NEW_TIP].origin, verts[2].xyz );
+
+//	VectorScale( mVerts[OLD_MUZZLE].curRGB, mVerts[OLD_MUZZLE].curAlpha, color );
+	verts[0].modulate[0] = mVerts[OLD_MUZZLE].rgb[0];
+	verts[0].modulate[1] = mVerts[OLD_MUZZLE].rgb[1];
+	verts[0].modulate[2] = mVerts[OLD_MUZZLE].rgb[2];
+	verts[0].modulate[3] = mVerts[OLD_MUZZLE].alpha;
+
+//	VectorScale( mVerts[OLD_TIP].curRGB, mVerts[OLD_TIP].curAlpha, color );
+	verts[1].modulate[0] = mVerts[OLD_TIP].rgb[0];
+	verts[1].modulate[1] = mVerts[OLD_TIP].rgb[1];
+	verts[1].modulate[2] = mVerts[OLD_TIP].rgb[2];
+	verts[0].modulate[3] = mVerts[OLD_TIP].alpha;
+
+//	VectorScale( mVerts[NEW_TIP].curRGB, mVerts[NEW_TIP].curAlpha, color );
+	verts[2].modulate[0] = mVerts[NEW_TIP].rgb[0];
+	verts[2].modulate[1] = mVerts[NEW_TIP].rgb[1];
+	verts[2].modulate[2] = mVerts[NEW_TIP].rgb[2];
+	verts[0].modulate[3] = mVerts[NEW_TIP].alpha;
+
+	verts[0].st[0] = mVerts[OLD_MUZZLE].curST[0];
+	verts[0].st[1] = mVerts[OLD_MUZZLE].curST[1];
+	verts[1].st[0] = mVerts[OLD_TIP].curST[0];
+	verts[1].st[1] = mVerts[OLD_TIP].curST[1];
+	verts[2].st[0] = mVerts[NEW_TIP].curST[0];
+	verts[2].st[1] = mVerts[NEW_TIP].curST[1];
+
+	// Add this tri
+	theFxHelper.AddPolyToScene( mShader, 3, verts );
+
+	drawnFx++;
+}
+
+//----------------------------
+// Update
+//----------------------------
+bool CTrail::Update()
+{
+	// Game pausing can cause dumb time things to happen, so kill the effect in this instance
+	if ( mTimeStart > theFxHelper.mTime )
+	{
+		return false;
+	}
+		
+	float perc = (float)(mTimeEnd - theFxHelper.mTime) / (float)(mTimeEnd - mTimeStart);
+
+	for ( int t = 0; t < 4; t++ )
+	{
+//		mVerts[t].curAlpha = mVerts[t].alpha * perc + mVerts[t].destAlpha * ( 1.0f - perc );
+//		if ( mVerts[t].curAlpha < 0.0f )
+//		{
+//			mVerts[t].curAlpha = 0.0f;
+//		}
+
+//		VectorScale( mVerts[t].rgb, perc, mVerts[t].curRGB );
+//		VectorMA( mVerts[t].curRGB, ( 1.0f - perc ), mVerts[t].destrgb, mVerts[t].curRGB );
+		mVerts[t].curST[0] = mVerts[t].ST[0] * perc + mVerts[t].destST[0] * ( 1.0f - perc );
+		if ( mVerts[t].curST[0] > 1.0f )
+		{
+			mVerts[t].curST[0] = 1.0f;
+		}
+		mVerts[t].curST[1] = mVerts[t].ST[1] * perc + mVerts[t].destST[1] * ( 1.0f - perc );
+	}
+
+	Draw();
+
+	return true;
+}
+
+//--------------------------
+//
+// Derived Poly Class
+//
+//--------------------------
+
+//----------------------------
+bool CPoly::Cull(void)
+{
+	vec3_t	dir;
+
+	// Get the direction to the view
+	VectorSubtract( mOrigin1, theFxHelper.refdef->vieworg, dir );
+
+	// Check if it's behind the viewer
+	if ( (DotProduct( theFxHelper.refdef->viewaxis[0], dir )) < 0 )
+	{
+		return true;
+	}
+
+	float len = VectorLengthSquared( dir );
+
+	// Can't be too close
+	if ( len < fx_nearCull->value * fx_nearCull->value)
+	{
+		return true;
+	}
+
+	return false;
+}
+
+//----------------------------
+void CPoly::Draw(void)
+{
+	polyVert_t	verts[MAX_CPOLY_VERTS];
+
+	for ( int i = 0; i < mCount; i++ )
+	{
+		// Add our midpoint and vert offset to get the actual vertex
+		VectorAdd( mOrigin1, mOrg[i], verts[i].xyz );
+
+		// Assign the same color to each vert
+		*(int *)verts[i].modulate = *(int *)mRefEnt.shaderRGBA;
+
+		// Copy the ST coords
+		Vector2Copy( mST[i], verts[i].st );
+	}
+
+	// Add this poly
+	theFxHelper.AddPolyToScene( mRefEnt.customShader, mCount, verts );
+	drawnFx++;	
+}
+
+//----------------------------
+void CPoly::CalcRotateMatrix(void)
+{
+	float	cosX, cosZ;
+	float	sinX, sinZ;
+	float	rad;
+
+	// rotate around Z
+	rad = DEG2RAD( mRotDelta[YAW] * theFxHelper.mFrameTime * 0.01f );
+	cosZ = cosf( rad );
+	sinZ = sinf( rad );
+	// rotate around X
+	rad = DEG2RAD( mRotDelta[PITCH] * theFxHelper.mFrameTime * 0.01f );
+	cosX = cosf( rad );
+	sinX = sinf( rad );
+
+/*Pitch - aroundx  Yaw - around z
+1 0  0			 c -s 0
+0 c -s			 s  c 0 
+0 s  c			 0  0 1
+*/
+	mRot[0][0] = cosZ;
+	mRot[1][0] = -sinZ;
+	mRot[2][0] = 0;
+	mRot[0][1] = cosX * sinZ;
+	mRot[1][1] = cosX * cosZ;
+	mRot[2][1] = -sinX;
+	mRot[0][2] = sinX * sinZ;
+	mRot[1][2] = sinX * cosZ;
+	mRot[2][2] = cosX;
+/*
+// ROLL is not supported unless anyone complains, if it needs to be added, use this format
+Roll
+
+ c 0 s
+ 0 1 0 
+-s 0 c
+*/
+	mLastFrameTime = theFxHelper.mFrameTime;
+}
+
+//--------------------------------
+void CPoly::Rotate(void)
+{
+	vec3_t	temp[MAX_CPOLY_VERTS];
+	float	dif = fabs( (float)(mLastFrameTime - theFxHelper.mFrameTime) );
+	
+	if ( dif > 0.1f * mLastFrameTime )
+	{
+		CalcRotateMatrix();
+	}
+
+	// Multiply our rotation matrix by each of the offset verts to get their new position
+	for ( int i = 0; i < mCount; i++ )
+	{
+		VectorRotate( mOrg[i], mRot, temp[i] );
+		VectorCopy( temp[i], mOrg[i] );
+	}
+}
+
+//----------------------------
+// Update
+//----------------------------
+bool CPoly::Update(void)
+{
+	// Game pausing can cause dumb time things to happen, so kill the effect in this instance
+	if ( mTimeStart > theFxHelper.mTime )
+	{
+		return false;
+	}
+		
+	// If our timestamp hasn't exired yet, we won't even consider doing any kind of motion
+	if ( theFxHelper.mTime > mTimeStamp )
+	{
+		vec3_t mOldOrigin;
+
+		VectorCopy( mOrigin1, mOldOrigin );
+
+		if (( mTimeStart < theFxHelper.mTime ) && UpdateOrigin() == false )
+		{
+			// we are marked for death
+			return false;
+		}
+
+		// Only rotate whilst moving
+		if ( !VectorCompare( mOldOrigin, mOrigin1 ))
+		{
+			Rotate();
+		}
+	}
+
+	if ( !Cull())
+	{	
+		// Only update these if the thing is visible.	
+		UpdateRGB();
+		UpdateAlpha();
+		
+		Draw();
+	}
+
+	return true;
+}
+
+//----------------------------
+void CPoly::PolyInit(void)
+{
+	if ( mCount < 3 )
+	{
+		return;
+	}
+
+	int		i;
+	vec3_t	org = {0.0f, 0.0f ,0.0f};
+
+	// Find our midpoint
+	for ( i = 0; i < mCount; i++ )
+	{
+		VectorAdd( org, mOrg[i], org );
+	}
+
+	VectorScale( org, (float)(1.0f / mCount), org );
+
+	// now store our midpoint for physics purposes
+	VectorCopy( org, mOrigin1 );
+
+	// Now we process the passed in points and make it so that they aren't actually the point...
+	//	rather, they are the offset from mOrigin1.
+	for ( i = 0; i < mCount; i++ )
+	{
+		VectorSubtract( mOrg[i], mOrigin1, mOrg[i] );
+	}
+
+	CalcRotateMatrix();
+}
+
+/*
+-------------------------
+CBezier
+
+Bezier curve line
+-------------------------
+*/
+bool CBezier::Cull( void )
+{
+	vec3_t	dir;
+
+	VectorSubtract( mOrigin1, theFxHelper.refdef->vieworg, dir );
+
+	//Check if it's in front of the viewer
+	if ( (DotProduct( theFxHelper.refdef->viewaxis[0], dir )) >= 0 )
+	{
+		return false;	//don't cull
+	}
+
+	VectorSubtract( mOrigin2, theFxHelper.refdef->vieworg, dir );
+
+	//Check if it's in front of the viewer
+	if ( (DotProduct( theFxHelper.refdef->viewaxis[0], dir )) >= 0 )
+	{
+		return false;
+	}
+
+	VectorSubtract( mControl1, theFxHelper.refdef->vieworg, dir );
+
+	//Check if it's in front of the viewer
+	if ( (DotProduct( theFxHelper.refdef->viewaxis[0], dir )) >= 0 )
+	{
+		return false;
+	}
+
+	return true; //all points behind viewer
+}
+
+//----------------------------
+bool CBezier::Update( void )
+{
+	float	ftime, time2;
+
+	ftime = theFxHelper.mFrameTime * 0.001f;
+	time2 = ftime * ftime * 0.5f;
+
+	mControl1[0] = mControl1[0] + (ftime * mControl1Vel[0]) + (time2 * mControl1Vel[0]);
+	mControl2[0] = mControl2[0] + (ftime * mControl2Vel[0]) + (time2 * mControl2Vel[0]);
+	mControl1[1] = mControl1[1] + (ftime * mControl1Vel[1]) + (time2 * mControl1Vel[1]);
+	mControl2[1] = mControl2[1] + (ftime * mControl2Vel[1]) + (time2 * mControl2Vel[1]);
+	mControl1[2] = mControl1[2] + (ftime * mControl1Vel[2]) + (time2 * mControl1Vel[2]);
+	mControl2[2] = mControl2[2] + (ftime * mControl2Vel[2]) + (time2 * mControl2Vel[2]);
+
+	if ( Cull() == false )
+	{	
+		// Only update these if the thing is visible.	
+		UpdateSize();
+		UpdateRGB();
+		UpdateAlpha();
+
+		Draw();
+	}
+	return true;
+}
+
+//----------------------------
+inline void CBezier::DrawSegment( vec3_t start, vec3_t end, float texcoord1, float texcoord2, float segPercent, float lastSegPercent )
+{
+	vec3_t			lineDir, cross, viewDir;
+	static vec3_t	lastEnd[2];
+	polyVert_t		verts[4];
+	float			scaleBottom = 0.0f, scaleTop = 0.0f;
+
+	VectorSubtract( end, start, lineDir );
+	VectorSubtract( end, theFxHelper.refdef->vieworg, viewDir );
+	CrossProduct( lineDir, viewDir, cross );
+	VectorNormalize( cross );
+
+	// scaleBottom is the width of the bottom edge of the quad, scaleTop is the width of the top edge
+	scaleBottom = (mSizeStart + ((mSizeEnd - mSizeStart) * lastSegPercent)) * 0.5f;
+	scaleTop = (mSizeStart + ((mSizeEnd - mSizeStart) * segPercent)) * 0.5f;
+
+	//Construct the oriented quad
+	if ( mInit )
+	{
+		VectorCopy( lastEnd[0], verts[0].xyz );
+		VectorCopy( lastEnd[1], verts[1].xyz );
+	}
+	else
+	{
+		VectorMA( start, -scaleBottom, cross, verts[0].xyz );
+		VectorMA( start, scaleBottom, cross, verts[1].xyz );
+	}
+
+	verts[0].st[0] = 0.0f;
+	verts[0].st[1] = texcoord1;
+
+	verts[0].modulate[0] = mRefEnt.shaderRGBA[0] * ( 1.0f - texcoord1 );
+	verts[0].modulate[1] = mRefEnt.shaderRGBA[1] * ( 1.0f - texcoord1 );
+	verts[0].modulate[2] = mRefEnt.shaderRGBA[2] * ( 1.0f - texcoord1 );
+	verts[0].modulate[3] = mRefEnt.shaderRGBA[3];
+
+	verts[1].st[0] = 1.0f;
+	verts[1].st[1] = texcoord1;
+
+	verts[1].modulate[0] = mRefEnt.shaderRGBA[0] * ( 1.0f - texcoord1 );
+	verts[1].modulate[1] = mRefEnt.shaderRGBA[1] * ( 1.0f - texcoord1 );
+	verts[1].modulate[2] = mRefEnt.shaderRGBA[2] * ( 1.0f - texcoord1 );
+	verts[1].modulate[3] = mRefEnt.shaderRGBA[3];
+
+	if ( texcoord1 == 0.0f )
+	{
+		*(int *)verts[0].modulate = 0;
+		*(int *)verts[1].modulate = 0;
+	}
+
+	VectorMA( end, scaleTop, cross, verts[2].xyz );
+	verts[2].st[0] = 1.0f;
+	verts[2].st[1] = texcoord2;
+
+	verts[2].modulate[0] = mRefEnt.shaderRGBA[0] * ( 1.0f - texcoord2 );
+	verts[2].modulate[1] = mRefEnt.shaderRGBA[1] * ( 1.0f - texcoord2 );
+	verts[2].modulate[2] = mRefEnt.shaderRGBA[2] * ( 1.0f - texcoord2 );
+	verts[2].modulate[3] = mRefEnt.shaderRGBA[3];
+
+	VectorMA( end, -scaleTop, cross, verts[3].xyz );
+	verts[3].st[0] = 0.0f;
+	verts[3].st[1] = texcoord2;
+
+	verts[3].modulate[0] = mRefEnt.shaderRGBA[0] * ( 1.0f - texcoord2 );
+	verts[3].modulate[1] = mRefEnt.shaderRGBA[1] * ( 1.0f - texcoord2 );
+	verts[3].modulate[2] = mRefEnt.shaderRGBA[2] * ( 1.0f - texcoord2 );
+	verts[3].modulate[3] = mRefEnt.shaderRGBA[3];
+
+	theFxHelper.AddPolyToScene( mRefEnt.customShader, 4, verts );
+
+	VectorCopy( verts[2].xyz, lastEnd[1] );
+	VectorCopy( verts[3].xyz, lastEnd[0] );
+
+	mInit = true;
+}
+
+const	float	BEZIER_RESOLUTION	= 16.0f;
+
+//----------------------------
+void CBezier::Draw( void )	
+{
+	vec3_t	pos, old_pos;
+    float	mu, mum1;
+	float	incr = 1.0f / BEZIER_RESOLUTION, tex = 1.0f, tc1, tc2;
+	int		i = 0;
+
+	VectorCopy( mOrigin1, old_pos );
+
+	mInit = false;	//Signify a new batch for vert gluing
+
+	float mum13, mu3, group1, group2;
+
+	tc1 = 0.0f;
+
+	for ( mu = incr; mu <= 1.0f; mu += incr)
+	{
+		//Four point curve
+		mum1	= 1 - mu;
+		mum13	= mum1 * mum1 * mum1;
+		mu3		= mu * mu * mu;
+		group1	= 3 * mu * mum1 * mum1;
+		group2	= 3 * mu * mu *mum1;
+
+		for ( i = 0; i < 3; i++ )
+		{
+			pos[i] = mum13 * mOrigin1[i] + group1 * mControl1[i] + group2 * mControl2[i] + mu3 * mOrigin2[i];
+		}
+
+		tc2 = mu * tex;
+
+		//Draw it
+		DrawSegment( old_pos, pos, tc1, tc2, mu, mu - incr );
+
+		VectorCopy( pos, old_pos );
+		tc1 = tc2;
+	}
+	drawnFx++;	
+}
+
+/*
+-------------------------
+CFlash
+
+Full screen flash
+-------------------------
+*/
+
+//----------------------------
+bool CFlash::Update( void )
+{
+	if ( UpdateOrigin() == false )
+	{
+		// we are marked for death
+		return false;
+	}
+
+	UpdateSize();
+	mRefEnt.radius *= mRadiusModifier;
+	UpdateRGB();
+	UpdateAlpha();
+
+	Draw();
+	return true;
+}
+
+bool FX_WorldToScreen(vec3_t worldCoord, float *x, float *y)
+{
+	int	xcenter, ycenter;
+	vec3_t	local, transformed;
+	vec3_t	vfwd, vright, vup;
+
+	//NOTE: did it this way because most draw functions expect virtual 640x480 coords
+	//	and adjust them for current resolution
+	xcenter = 640 / 2;//gives screen coords in virtual 640x480, to be adjusted when drawn
+	ycenter = 480 / 2;//gives screen coords in virtual 640x480, to be adjusted when drawn
+
+	VectorSubtract (worldCoord, theFxHelper.refdef->vieworg, local);
+
+	AngleVectors (theFxHelper.refdef->viewangles, vfwd, vright, vup);
+
+	transformed[0] = DotProduct(local,vright);
+	transformed[1] = DotProduct(local,vup);
+	transformed[2] = DotProduct(local,vfwd);		
+
+	// Make sure Z is not negative.
+	if(transformed[2] < 0.01)
+	{
+		return false;
+	}
+	// Simple convert to screen coords.
+	float xzi = xcenter / transformed[2] * (90.0/theFxHelper.refdef->fov_x);
+	float yzi = ycenter / transformed[2] * (90.0/theFxHelper.refdef->fov_y);
+
+	*x = (xcenter + xzi * transformed[0]);
+	*y = (ycenter - yzi * transformed[1]);
+
+	return true;
+}
+
+//----------------------------
+void CFlash::Init( void )
+{
+	// 10/19/01 kef -- maybe we want to do something different here for localized flashes, but right
+	//now I want to be sure that whatever RGB changes occur to a non-localized flash will also occur
+	//to a localized flash (so I'll have the same initial RGBA values for both...I need them sync'd for an effect)
+
+	vec3_t	dif;
+	float	mod = 1.0f, dis = 0.0f, maxRange = 900;
+
+	VectorSubtract( mOrigin1, theFxHelper.refdef->vieworg, dif );
+	dis = VectorNormalize( dif );
+
+	mod = DotProduct( dif, theFxHelper.refdef->viewaxis[0] );
+
+	if ( dis > maxRange || ( mod < 0.5f && dis > 100 ))
+	{
+		mod = 0.0f;
+	}
+	else if ( mod < 0.5f && dis <= 100 )
+	{
+		mod += 1.1f;
+	}
+
+	mod *= (1.0f - ((dis * dis) / (maxRange * maxRange)));
+
+	VectorScale( mRGBStart, mod, mRGBStart );
+	VectorScale( mRGBEnd, mod, mRGBEnd );
+
+	if ( mFlags & FX_LOCALIZED_FLASH )
+	{
+		FX_WorldToScreen(mOrigin1, &mScreenX, &mScreenY);
+
+		// modify size of localized flash based on distance to effect (but not orientation)
+		if (dis > 100 && dis < maxRange)
+		{
+			mRadiusModifier = (1.0f - ((dis * dis) / (maxRange * maxRange)));
+		}
+	}
+}
+
+//----------------------------
+void CFlash::Draw( void )	
+{
+	mRefEnt.reType = RT_SPRITE;
+
+	if ( mFlags & FX_LOCALIZED_FLASH )
+	{
+		vec4_t	color;
+
+		color[0] = mRefEnt.shaderRGBA[0] / 255.0;
+		color[1] = mRefEnt.shaderRGBA[1] / 255.0;
+		color[2] = mRefEnt.shaderRGBA[2] / 255.0;
+		color[3] = mRefEnt.shaderRGBA[3] / 255.0;
+
+		// add this 2D effect to the proper list. it will get drawn after the cgi.RenderScene call
+		theFxScheduler.Add2DEffect(mScreenX, mScreenY, mRefEnt.radius, mRefEnt.radius, color, mRefEnt.customShader);
+	}
+	else
+	{
+		VectorCopy( theFxHelper.refdef->vieworg, mRefEnt.origin );
+		VectorMA( mRefEnt.origin, 12, theFxHelper.refdef->viewaxis[0], mRefEnt.origin );
+		mRefEnt.radius = 11.0f;
+
+		theFxHelper.AddFxToScene( &mRefEnt );
+	}
+	drawnFx++;	
+}
+
+void FX_AddPrimitive( CEffect **pEffect, int killTime );
+void FX_FeedTrail(effectTrailArgStruct_t *a)
+{
+	CTrail *fx = new CTrail;
+	int i = 0;
+
+	while (i < 4)
+	{
+		VectorCopy(a->mVerts[i].origin, fx->mVerts[i].origin);
+		VectorCopy(a->mVerts[i].rgb, fx->mVerts[i].rgb);
+		VectorCopy(a->mVerts[i].destrgb, fx->mVerts[i].destrgb);
+		VectorCopy(a->mVerts[i].curRGB, fx->mVerts[i].curRGB);
+		fx->mVerts[i].alpha = a->mVerts[i].alpha;
+		fx->mVerts[i].destAlpha = a->mVerts[i].destAlpha;
+		fx->mVerts[i].curAlpha = a->mVerts[i].curAlpha;
+		fx->mVerts[i].ST[0] = a->mVerts[i].ST[0];
+		fx->mVerts[i].ST[1] = a->mVerts[i].ST[1];
+		fx->mVerts[i].destST[0] = a->mVerts[i].destST[0];
+		fx->mVerts[i].destST[1] = a->mVerts[i].destST[1];
+		fx->mVerts[i].curST[0] = a->mVerts[i].curST[0];
+		fx->mVerts[i].curST[1] = a->mVerts[i].curST[1];
+		i++;
+	}
+
+	fx->SetFlags(a->mSetFlags);
+
+	fx->mShader = a->mShader;
+
+	FX_AddPrimitive((CEffect **)&fx, a->mKillTime);
+}
+// end
diff --git a/codemp/client/FxPrimitives.h b/codemp/client/FxPrimitives.h
new file mode 100644
index 0000000..0e9142d
--- /dev/null
+++ b/codemp/client/FxPrimitives.h
@@ -0,0 +1,611 @@
+
+#if !defined(FX_SYSTEM_H_INC)
+	#include "FxSystem.h"
+#endif
+
+#ifndef FX_PRIMITIVES_H_INC
+#define FX_PRIMITIVES_H_INC
+
+
+#define MAX_EFFECTS			1800
+
+// Generic group flags, used by parser, then get converted to the appropriate specific flags
+#define FX_PARM_MASK		0xC	// use this to mask off any transition types that use a parm
+#define FX_GENERIC_MASK		0xF
+#define FX_LINEAR			0x1
+#define FX_RAND				0x2
+#define FX_NONLINEAR		0x4
+#define FX_WAVE				0x8
+#define FX_CLAMP			0xC
+
+// Group flags
+#define FX_ALPHA_SHIFT		0
+#define FX_ALPHA_PARM_MASK	0x0000000C
+#define	FX_ALPHA_LINEAR		0x00000001
+#define FX_ALPHA_RAND		0x00000002
+#define	FX_ALPHA_NONLINEAR	0x00000004
+#define FX_ALPHA_WAVE		0x00000008
+#define FX_ALPHA_CLAMP		0x0000000C
+
+#define FX_RGB_SHIFT		4
+#define FX_RGB_PARM_MASK	0x000000C0
+#define	FX_RGB_LINEAR		0x00000010
+#define FX_RGB_RAND			0x00000020
+#define	FX_RGB_NONLINEAR	0x00000040
+#define FX_RGB_WAVE			0x00000080
+#define FX_RGB_CLAMP		0x000000C0
+
+#define FX_SIZE_SHIFT		8
+#define FX_SIZE_PARM_MASK	0x00000C00
+#define	FX_SIZE_LINEAR		0x00000100
+#define FX_SIZE_RAND		0x00000200
+#define	FX_SIZE_NONLINEAR	0x00000400
+#define FX_SIZE_WAVE		0x00000800
+#define FX_SIZE_CLAMP		0x00000C00
+
+#define FX_LENGTH_SHIFT		12
+#define FX_LENGTH_PARM_MASK	0x0000C000
+#define	FX_LENGTH_LINEAR	0x00001000
+#define FX_LENGTH_RAND		0x00002000
+#define	FX_LENGTH_NONLINEAR	0x00004000
+#define FX_LENGTH_WAVE		0x00008000
+#define FX_LENGTH_CLAMP		0x0000C000
+
+#define FX_SIZE2_SHIFT		16
+#define FX_SIZE2_PARM_MASK	0x000C0000
+#define	FX_SIZE2_LINEAR		0x00010000
+#define FX_SIZE2_RAND		0x00020000
+#define	FX_SIZE2_NONLINEAR	0x00040000
+#define FX_SIZE2_WAVE		0x00080000
+#define FX_SIZE2_CLAMP		0x000C0000
+
+// Shared flag--these flags, at first glance would appear to be shared, but are safe.  I'd rather not do this, but as you can see, features flags are currently all accounted for
+#define	FX_PAPER_PHYSICS	0x00010000		// emitters ONLY.  shared with FX_SIZE_2_LINEAR
+#define	FX_LOCALIZED_FLASH	0x00010000		// full screen flashes ONLY.  shared with FX_SIZE_2_LINEAR
+#define	FX_PLAYER_VIEW		0x00010000		// player view effects ONLY.  shared with FX_SIZE_2_LINEAR
+
+// Feature flags
+#define	FX_DEPTH_HACK		0x00100000
+#define	FX_RELATIVE			0x00200000
+#define FX_SET_SHADER_TIME	0x00400000
+#define FX_EXPENSIVE_PHYSICS 0x00800000		
+
+//rww - g2-related flags (these can slow things down significantly, use sparingly)
+//These should be used only with particles/decals as they steal flags used by cylinders.
+#define	FX_GHOUL2_TRACE		0x00020000		//use in conjunction with particles - actually do full ghoul2 traces for physics collision against entities with a ghoul2 instance
+							//shared FX_SIZE2_RAND (used only with cylinders)
+#define	FX_GHOUL2_DECALS	0x00040000		//use in conjunction with decals - can project decal as a ghoul2 gore skin object onto ghoul2 models
+							//shared FX_SIZE2_NONLINEAR (used only with cylinders)
+
+#define FX_ATTACHED_MODEL	0x01000000
+
+#define FX_APPLY_PHYSICS	0x02000000
+#define FX_USE_BBOX			0x04000000		// can make physics more accurate at the expense of speed
+
+#define FX_USE_ALPHA		0x08000000		// the FX system actually uses RGB to do fades, but this will override that
+											//	and cause it to fill in the alpha.
+
+#define FX_EMIT_FX			0x10000000		// emitters technically don't have to emit stuff, but when they do
+											//	this flag needs to be set
+#define FX_DEATH_RUNS_FX	0x20000000		// Normal death triggers effect, but not kill_on_impact
+#define FX_KILL_ON_IMPACT	0x40000000		// works just like it says, but only when physics are on.
+#define FX_IMPACT_RUNS_FX	0x80000000		// an effect can call another effect when it hits something.
+
+// Lightning flags, duplicates of existing flags, but lightning doesn't use those flags in that context...and nothing will ever use these in this context..so we are safe.
+#define FX_TAPER			0x01000000		// tapers as it moves towards its endpoint
+#define FX_BRANCH			0x02000000		// enables lightning branching
+#define FX_GROW				0x04000000		// lightning grows from start point to end point over the course of its life
+
+
+// stuff that can occur when an effect is flagged with "materialImpact" and it hits something
+enum EMatImpactEffect
+{
+	MATIMPACTFX_NONE = 0,
+	MATIMPACTFX_SHELLSOUND
+};
+
+//------------------------------
+class CEffect
+{
+protected:
+
+	CEffect		*mNext;
+	vec3_t		mOrigin1;
+
+	int			mTimeStart;
+	int			mTimeEnd;
+
+	unsigned int	mFlags;
+
+	EMatImpactEffect	mMatImpactFX;
+	int					mMatImpactParm;
+
+	// Size of our object, useful for things that have physics
+	vec3_t		mMin;
+	vec3_t		mMax;
+
+	int			mImpactFxID;		// if we have an impact event, we may have to call an effect
+	int			mDeathFxID;			// if we have a death event, we may have to call an effect
+
+	miniRefEntity_t		mRefEnt;
+
+	int			mSoundRadius;
+	int			mSoundVolume;
+
+public:
+
+	CEffect();
+	virtual ~CEffect() {}
+
+	virtual void Die() {}
+	virtual bool Update()	{ return true;		}
+	virtual	void Draw(void) {}
+
+	inline	miniRefEntity_t	&GetRefEnt(void) { return mRefEnt; } 
+
+	inline void		SetNext(CEffect *Next) { mNext = Next; }
+	inline CEffect	*GetNext(void) { return mNext; }
+	inline void		GetOrigin(vec3_t dest)		{VectorCopy( mOrigin1, dest); }
+
+	inline void SetSTScale(float s,float t)	{ mRefEnt.shaderTexCoord[0]=s;mRefEnt.shaderTexCoord[1]=t;}
+
+	inline void SetSound ( int vol, int rad) { mSoundRadius = rad; mSoundVolume = vol; }
+	inline void SetMin( vec3_t min )		{ if(min){VectorCopy(min,mMin);}else{VectorClear(mMin);}			}
+	inline void SetMax( vec3_t max )		{ if(max){VectorCopy(max,mMax);}else{VectorClear(mMax);}			}
+	inline void SetFlags( int flags )		{ mFlags = flags;				}
+	inline void AddFlags( int flags )		{ mFlags |= flags;				}
+	inline void ClearFlags( int flags )		{ mFlags &= ~flags;				}
+	inline void SetOrigin1( vec3_t org )	{ if(org){VectorCopy(org,mOrigin1);}else{VectorClear(mOrigin1);}	}
+	inline void SetTimeStart( int time )	{ mTimeStart = time; if (mFlags&FX_SET_SHADER_TIME) { mRefEnt.shaderTime = time * 0.001f; }}
+	inline void	SetTimeEnd( int time )		{ mTimeEnd = time;				}
+	inline void SetImpactFxID( int id )		{ mImpactFxID = id;				}
+	inline void SetDeathFxID( int id )		{ mDeathFxID = id;				}
+	inline EMatImpactEffect GetMatImpactFX() { return mMatImpactFX; }
+	inline int	GetMatImpactParm() { return mMatImpactParm; }
+	inline void SetMatImpactFX(EMatImpactEffect matFX) { mMatImpactFX = matFX; }
+	inline void SetMatImpactParm(int matParm) { mMatImpactParm = matParm; }
+};
+
+//---------------------------------------------------
+// This class is kind of an exception to the "rule".
+//	For now it exists only for allowing an easy way
+//	to get the saber slash trails rendered.
+//---------------------------------------------------
+class CTrail : public CEffect
+{
+// This is such a specific case thing, just grant public access to the goods.
+protected:
+
+	void Draw();
+
+public:
+
+	typedef struct
+	{
+		vec3_t	origin;
+
+		// very specifc case, we can modulate the color and the alpha
+		vec3_t	rgb;
+		vec3_t	destrgb;
+		vec3_t	curRGB;
+
+		float	alpha;
+		float	destAlpha;
+		float	curAlpha;
+
+		// this is a very specific case thing...allow interpolating the st coords so we can map the texture
+		//	properly as this segement progresses through it's life
+		float	ST[2];
+		float	destST[2];
+		float	curST[2];
+
+	} TVert;
+
+	TVert		mVerts[4];
+	qhandle_t	mShader;
+
+
+	CTrail()			{};
+	virtual ~CTrail()	{};
+
+	virtual bool Update();
+};
+
+//------------------------------
+class CLight : public CEffect
+{
+protected:
+
+	float		mSizeStart;
+	float		mSizeEnd;
+	float		mSizeParm;
+	
+	vec3_t		mOrgOffset;
+	vec3_t		mRGBStart;
+	vec3_t		mRGBEnd;
+	float		mRGBParm;
+
+	CGhoul2Info_v mGhoul2;
+	short		mEntNum;
+	char		mModelNum;
+	char		mBoltNum;
+
+	void		UpdateSize();
+	void		UpdateRGB();
+
+	virtual void		Draw(void);
+public:
+
+	inline CLight(void)
+	{
+		mEntNum = -1; mModelNum = -1; mBoltNum = -1;
+	}
+
+	virtual ~CLight(void)
+	{
+		mGhoul2.kill();	//remove my model ref without actually deleting
+	}
+
+	inline void SetBoltinfo( int iGhoul2,  int entNum, int modelNum = -1, int boltNum = -1 )	
+	{ 
+		mGhoul2 = iGhoul2; mEntNum = entNum; mModelNum = modelNum; mBoltNum = boltNum; 
+	}
+
+	virtual bool Update();
+
+	inline void SetSizeStart( float sz )	{ mSizeStart = sz;			}
+	inline void SetSizeEnd( float sz )		{ mSizeEnd = sz;			}
+	inline void SetSizeParm( float parm )	{ mSizeParm = parm;			}
+
+	inline void SetOrgOffset( const vec3_t o )	{ if(o){VectorCopy(o,mOrgOffset);}else{VectorClear(mOrgOffset);}}
+	inline void SetRGBStart( vec3_t rgb )	{ if(rgb){VectorCopy(rgb,mRGBStart);}else{VectorClear(mRGBStart);}	}
+	inline void SetRGBEnd( vec3_t rgb )		{ if(rgb){VectorCopy(rgb,mRGBEnd);}else{VectorClear(mRGBEnd);}		}
+	inline void SetRGBParm( float parm )	{ mRGBParm = parm;			}
+};
+
+//------------------------------
+class CParticle : public CEffect
+{
+protected:
+
+	vec3_t		mOrgOffset;
+
+	vec3_t		mVel;
+	vec3_t		mAccel;
+
+	float		mSizeStart;
+	float		mSizeEnd;
+	float		mSizeParm;
+
+	vec3_t		mRGBStart;
+	vec3_t		mRGBEnd;
+	float		mRGBParm;
+	
+	float		mAlphaStart;
+	float		mAlphaEnd;
+	float		mAlphaParm;
+
+	float		mRotationDelta;
+	float		mElasticity;
+
+	CGhoul2Info_v mGhoul2;
+	short		mEntNum;
+	char		mModelNum;
+	char		mBoltNum;
+
+	bool		UpdateOrigin();
+	void		UpdateSize();
+	void		UpdateRGB();
+	void		UpdateAlpha();
+	void		UpdateRotation();
+
+
+public:
+
+	inline void SetBoltinfo( int iGhoul2,  int entNum, int modelNum = -1, int boltNum = -1 )	
+	{ 
+		mGhoul2 = iGhoul2; mEntNum = entNum; mModelNum = modelNum; mBoltNum = boltNum; 
+	}
+
+	inline CParticle::CParticle(void)
+	{
+		mRefEnt.reType = RT_SPRITE; mEntNum = -1; mModelNum = -1; mBoltNum = -1;
+	}
+
+	virtual CParticle::~CParticle(void)
+	{
+		mGhoul2.kill();	//remove my model ref without actually deleting
+	}
+
+
+	virtual void Init();
+	virtual void Die();
+	virtual bool Update();
+	virtual bool Cull(void);
+	virtual void Draw(void);
+
+	inline void SetShader( qhandle_t sh )	{ mRefEnt.customShader = sh;		}
+
+	inline void SetOrgOffset( const vec3_t o )	{ if(o){VectorCopy(o,mOrgOffset);}else{VectorClear(mOrgOffset);}}
+	inline void SetVel( vec3_t vel )		{ if(vel){VectorCopy(vel,mVel);}else{VectorClear(mVel);}	}
+	inline void SetAccel( vec3_t ac )		{ if(ac){VectorCopy(ac,mAccel);}else{VectorClear(mAccel);}	}
+
+	inline void SetSizeStart( float sz )	{ mSizeStart = sz; mRefEnt.radius = sz;	}
+	inline void SetSizeEnd( float sz )		{ mSizeEnd = sz;			}
+	inline void SetSizeParm( float parm )	{ mSizeParm = parm;			}
+
+	inline void SetRGBStart( vec3_t rgb )	{ if(rgb){VectorCopy(rgb,mRGBStart);}else{VectorClear(mRGBStart);}	}
+	inline void SetRGBEnd( vec3_t rgb )		{ if(rgb){VectorCopy(rgb,mRGBEnd);}else{VectorClear(mRGBEnd);}		}
+	inline void SetRGBParm( float parm )	{ mRGBParm = parm;			}
+
+	inline void SetAlphaStart( float al )	{ mAlphaStart = al;			}
+	inline void SetAlphaEnd( float al )		{ mAlphaEnd = al;			}
+	inline void SetAlphaParm( float parm )	{ mAlphaParm = parm;		}
+
+	inline void SetRotation( float rot )		{ mRefEnt.rotation = rot;	}
+	inline void SetRotationDelta( float rot )	{ mRotationDelta = rot;		}
+	inline void SetElasticity( float el )		{ mElasticity = el;			}
+};
+
+//------------------------------
+class CFlash : public CParticle
+{
+public:
+
+	CFlash():
+	mScreenX(0),
+	mScreenY(0),
+	mRadiusModifier(1)
+	{}
+
+	virtual ~CFlash() {}
+
+	virtual bool Update();
+	virtual void Draw(void);
+	virtual bool Cull(void) { return false; }
+
+	void		Init( void );
+
+protected:
+	// kef -- mScreenX and mScreenY are used for flashes that are FX_LOCALIZED_FLASH
+	float		mScreenX;
+	float		mScreenY;
+	float		mRadiusModifier;
+};
+
+//------------------------------
+class CLine : public CParticle
+{
+protected:
+
+	vec3_t	mOrigin2;
+
+	virtual void		Draw(void);
+public:
+
+	CLine();
+	virtual ~CLine() {}
+
+	virtual void Die() {}
+
+	virtual bool Update();
+
+	inline void SetOrigin2( vec3_t org2 )	{ VectorCopy( org2, mOrigin2 ); }
+};
+
+//------------------------------
+class CBezier : public CLine
+{
+protected:
+
+	vec3_t	mControl1;
+	vec3_t	mControl1Vel;
+
+	vec3_t	mControl2;
+	vec3_t	mControl2Vel;
+
+	bool	mInit;
+
+public:
+
+	CBezier(){ mInit = false; }
+	virtual ~CBezier() {}
+
+	virtual void Die() {}
+	virtual bool Update();
+	virtual bool Cull(void);
+	virtual void Draw(void);
+	
+	void DrawSegment( vec3_t start, vec3_t end, float texcoord1, float texcoord2, float segPercent, float lastSegPercent );
+
+	inline void SetControlPoints( vec3_t ctrl1, vec3_t ctrl2 )	{ VectorCopy( ctrl1, mControl1 ); VectorCopy( ctrl2, mControl2 ); }
+	inline void SetControlVel( vec3_t ctrl1v, vec3_t ctrl2v )	{ VectorCopy( ctrl1v, mControl1Vel ); VectorCopy( ctrl2v, mControl2Vel ); }
+};
+
+//------------------------------
+class CElectricity : public CLine
+{
+protected:
+
+	float	mChaos;
+
+	virtual void		Draw(void);
+public:
+
+	CElectricity();
+	virtual ~CElectricity() {}
+
+	virtual void Die() {}
+
+	virtual bool Update();
+
+	void Initialize();
+
+	inline void SetChaos( float chaos )		{ mChaos = chaos; }
+};
+
+
+// Oriented quad
+//------------------------------
+class COrientedParticle : public CParticle
+{
+protected:
+
+	vec3_t	mNormal;
+
+public:
+
+	COrientedParticle();
+	virtual ~COrientedParticle() {}
+
+	virtual bool Update();
+	virtual bool Cull(void);
+	virtual void Draw(void);
+
+	inline void SetNormal( vec3_t norm )	{ VectorCopy( norm, mNormal );	}
+};
+
+//------------------------------
+class CTail : public CParticle
+{
+protected:
+
+	vec3_t	mOldOrigin;
+
+	float	mLengthStart;
+	float	mLengthEnd;
+	float	mLengthParm;
+
+	float	mLength;
+
+	void	UpdateLength();
+	void	CalcNewEndpoint();
+
+	virtual void		Draw(void);
+public:
+
+	CTail();
+	virtual ~CTail() {}
+
+	virtual bool Update();
+
+	inline void SetLengthStart( float len )	{ mLengthStart = len;	}
+	inline void SetLengthEnd( float len )	{ mLengthEnd = len;	}
+	inline void SetLengthParm( float len )	{ mLengthParm = len;	}
+};
+
+
+//------------------------------
+class CCylinder : public CTail
+{
+protected:
+
+	float		mSize2Start;
+	float		mSize2End;
+	float		mSize2Parm;
+	qboolean	mTraceEnd;
+
+	void	UpdateSize2();
+
+	virtual void		Draw(void);
+public:
+
+	CCylinder();
+	virtual ~CCylinder() {}
+
+	virtual bool Cull(void);
+	virtual void UpdateLength(void);
+	virtual bool Update();
+
+	inline void SetSize2Start( float sz )	{ mSize2Start = sz;			}
+	inline void SetSize2End( float sz )		{ mSize2End = sz;			}
+	inline void SetSize2Parm( float parm )	{ mSize2Parm = parm;		}
+	inline void SetTraceEnd(qboolean traceEnd) { mTraceEnd = traceEnd; }
+
+	inline void SetNormal( vec3_t norm )	{ VectorCopy( norm, mRefEnt.axis[0] ); }
+};
+
+
+//------------------------------
+// Emitters are derived from particles because, although they don't draw, any effect called
+//	from them can borrow an initial or ending value from the emitters current alpha, rgb, etc..
+class CEmitter : public CParticle
+{
+protected:
+
+	vec3_t		mOldOrigin;		// we use these to do some nice
+	vec3_t		mLastOrigin;	//	tricks...
+	vec3_t		mOldVelocity;	//	
+	int			mOldTime;
+
+	vec3_t		mAngles;		// for a rotating thing, using a delta  
+	vec3_t		mAngleDelta;	//	as opposed to an end angle is probably much easier
+
+	int			mEmitterFxID;	// if we have emitter fx, this is our id
+
+	float		mDensity;		// controls how often emitter chucks an effect
+	float		mVariance;		// density sloppiness
+
+	void		UpdateAngles();
+
+	virtual void		Draw(void);
+public:
+
+	CEmitter();
+	virtual ~CEmitter();
+
+	virtual bool Cull(void) {return false;}
+	virtual bool Update();
+
+	inline void SetModel( qhandle_t model )	{ mRefEnt.hModel = model;	}
+	inline void SetAngles( vec3_t ang )		{ if(ang){VectorCopy(ang,mAngles);}else{VectorClear(mAngles);}				}
+	inline void SetAngleDelta( vec3_t ang )	{ if(ang){VectorCopy(ang,mAngleDelta);}else{VectorClear(mAngleDelta);}		}
+	inline void SetEmitterFxID( int id )	{ mEmitterFxID = id;		}
+	inline void SetDensity( float density )	{ mDensity = density;		}
+	inline void SetVariance( float var )	{ mVariance = var;			}
+	inline void SetOldTime( int time )		{ mOldTime = time;			}
+	inline void SetLastOrg( vec3_t org )	{ if(org){VectorCopy(org,mLastOrigin);}else{VectorClear(mLastOrigin);}		}
+	inline void SetLastVel( vec3_t vel )	{ if(vel){VectorCopy(vel,mOldVelocity);}else{VectorClear(mOldVelocity);}	}
+};
+
+// We're getting pretty low level here, not the kind of thing to abuse considering how much overhead this
+//	adds to a SINGLE triangle or quad....
+//------------------------------
+#define MAX_CPOLY_VERTS	5
+
+class CPoly : public CParticle
+{
+protected:
+
+	int		mCount;
+	vec3_t	mRotDelta;
+	int		mTimeStamp;
+
+public:
+
+	vec3_t	mOrg[MAX_CPOLY_VERTS];
+	vec2_t	mST[MAX_CPOLY_VERTS];
+
+	float	mRot[3][3];
+	int		mLastFrameTime;
+
+
+	CPoly() {}
+	virtual ~CPoly() {}
+
+	virtual bool Update();
+	virtual bool Cull(void);
+	virtual void Draw(void);
+
+	void PolyInit();
+	void CalcRotateMatrix();
+	void Rotate();
+
+	inline void SetNumVerts( int c )					{ mCount = c;			}
+	inline void SetRot( vec3_t r )						{ if(r){VectorCopy(r,mRotDelta);}else{VectorClear(mRotDelta);}}
+	inline void SetMotionTimeStamp( int t )				{ mTimeStamp = theFxHelper.GetTime() + t; }
+	inline int	GetMotionTimeStamp()					{ return mTimeStamp; }
+};
+
+
+#endif //FX_PRIMITIVES_H_INC
\ No newline at end of file
diff --git a/codemp/client/FxScheduler.cpp b/codemp/client/FxScheduler.cpp
new file mode 100644
index 0000000..4ec51db
--- /dev/null
+++ b/codemp/client/FxScheduler.cpp
@@ -0,0 +1,1750 @@
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+#include "client.h"
+
+#if !defined(FX_SCHEDULER_H_INC)
+	#include "FxScheduler.h"
+#endif
+
+#if !defined(G2_H_INC)
+	#include "../ghoul2/G2.h"
+	#include "../ghoul2/G2_local.h"
+#endif
+
+#if !defined(__Q_SHARED_H)
+	#include "../game/q_shared.h"
+#endif
+
+CFxScheduler	theFxScheduler;
+
+//-----------------------------------------------------------
+void CMediaHandles::operator=(const CMediaHandles &that )
+{
+	mMediaList.clear();
+
+	for ( int i = 0; i < that.mMediaList.size(); i++ )
+	{
+		mMediaList.push_back( that.mMediaList[i] );
+	}
+}
+
+//------------------------------------------------------
+CFxScheduler::CFxScheduler()
+{ 
+	mNextFree2DEffect = 0;
+	memset( &mEffectTemplates, 0, sizeof( mEffectTemplates ));
+	memset( &mLoopedEffectArray, 0, sizeof( mLoopedEffectArray ));
+}
+
+int CFxScheduler::ScheduleLoopedEffect( int id, int boltInfo, int iGhoul2, bool isPortal, int iLoopTime, bool isRelative  )
+{
+	int i;
+	
+	assert(id);
+	assert(boltInfo!=-1);
+
+	for (i=0;i<MAX_LOOPED_FX;i++)	//see if it's already playing so we can just update it
+	{
+		if (mLoopedEffectArray[i].mId == id &&
+			mLoopedEffectArray[i].mBoltInfo == boltInfo &&
+			mLoopedEffectArray[i].mPortalEffect == isPortal 
+			)
+		{
+#ifdef _DEBUG
+			theFxHelper.Print( "CFxScheduler::ScheduleLoopedEffect- updating %s\n", mEffectTemplates[id].mEffectName);
+#endif
+			break;
+		}
+	}
+
+	if(i==MAX_LOOPED_FX)	//didn't find it existing, so find a free spot
+	{
+		for (i=0;i<MAX_LOOPED_FX;i++)
+		{
+			if (!mLoopedEffectArray[i].mId)
+			{
+				break;
+			}
+		}
+	}
+
+	if(i==MAX_LOOPED_FX)
+	{//bad
+		assert(i!=MAX_LOOPED_FX);
+		theFxHelper.Print( "CFxScheduler::AddLoopedEffect- No Free Slots available for %d\n", mEffectTemplates[id].mEffectName);
+		return -1;
+	}
+	mLoopedEffectArray[i].mId = id;
+	mLoopedEffectArray[i].mBoltInfo = boltInfo;
+	mLoopedEffectArray[i].mGhoul2  = iGhoul2;
+	mLoopedEffectArray[i].mPortalEffect = isPortal;
+	mLoopedEffectArray[i].mIsRelative = isRelative;
+	mLoopedEffectArray[i].mNextTime = theFxHelper.mTime + mEffectTemplates[id].mRepeatDelay ;
+	mLoopedEffectArray[i].mLoopStopTime = (iLoopTime==1) ? 0 : theFxHelper.mTime + iLoopTime;
+	return i;
+}
+
+void CFxScheduler::StopEffect( const char *file, int boltInfo, bool isPortal )
+{
+	int i;
+	char	sfile[MAX_QPATH];
+
+	// Get an extenstion stripped version of the file
+	COM_StripExtension( file, sfile );
+	const int id = mEffectIDs[sfile];
+#ifndef FINAL_BUILD
+	if ( id == 0 )
+	{
+		theFxHelper.Print( "CFxScheduler::StopEffect- unregistered/non-existent effect: %s\n", sfile );
+		return;
+	}
+#endif
+
+	for (i=0;i<MAX_LOOPED_FX;i++)
+	{
+		if (mLoopedEffectArray[i].mId == id &&
+			mLoopedEffectArray[i].mBoltInfo == boltInfo &&
+			mLoopedEffectArray[i].mPortalEffect == isPortal 
+			)
+		{
+			memset( &mLoopedEffectArray[i], 0, sizeof(mLoopedEffectArray[i]) );
+			return;
+		}
+	}
+#ifdef _DEBUG
+	theFxHelper.Print( "CFxScheduler::StopEffect- (%s) is not looping!\n", file);
+#endif
+}
+
+void CFxScheduler::AddLoopedEffects()
+{
+	int i;
+	
+	for (i=0;i<MAX_LOOPED_FX;i++)
+	{
+		if (mLoopedEffectArray[i].mId && mLoopedEffectArray[i].mNextTime < theFxHelper.mTime )
+		{
+			const int entNum = ( mLoopedEffectArray[i].mBoltInfo >> ENTITY_SHIFT )	& ENTITY_AND;
+			// Find out where the entity currently is
+			TCGVectorData	*data = (TCGVectorData*)cl.mSharedMemory;
+
+			data->mEntityNum = entNum;
+			VM_Call( cgvm, CG_GET_LERP_ORIGIN );
+
+			PlayEffect( mLoopedEffectArray[i].mId, data->mPoint, 0, mLoopedEffectArray[i].mBoltInfo, mLoopedEffectArray[i].mGhoul2.mItem, -1, mLoopedEffectArray[i].mPortalEffect, false, mLoopedEffectArray[i].mIsRelative );	//very important to send FALSE to not recursively add me!
+			mLoopedEffectArray[i].mNextTime = theFxHelper.mTime + mEffectTemplates[mLoopedEffectArray[i].mId].mRepeatDelay;
+			if (mLoopedEffectArray[i].mLoopStopTime && mLoopedEffectArray[i].mLoopStopTime < theFxHelper.mTime)	//time's up
+			{//kill this entry
+				memset( &mLoopedEffectArray[i], 0, sizeof(mLoopedEffectArray[i]) );
+			}
+		}
+	}
+
+}
+
+//-----------------------------------------------------------
+void SEffectTemplate::operator=(const SEffectTemplate &that)
+{
+	mCopy = true;
+
+	strcpy( mEffectName, that.mEffectName );
+
+	mPrimitiveCount = that.mPrimitiveCount;
+
+	for( int i = 0; i < mPrimitiveCount; i++ )
+	{
+		mPrimitives[i] = new CPrimitiveTemplate;
+		*(mPrimitives[i]) = *(that.mPrimitives[i]);
+		// Mark use as a copy so that we know that we should be chucked when used up
+		mPrimitives[i]->mCopy = true;
+	}
+}
+
+//------------------------------------------------------
+// Clean
+//	Free up any memory we've allocated so we aren't leaking memory
+//
+// Input:
+//	Whether to clean everything or just stop the playing (active) effects
+//
+// Return:
+//	None
+//
+//------------------------------------------------------
+void CFxScheduler::Clean(bool bRemoveTemplates /*= true*/, int idToPreserve /*= 0*/)
+{
+	int								i, j;
+	TScheduledEffect::iterator		itr, next;
+
+	// Ditch any scheduled effects
+	itr = mFxSchedule.begin();
+
+	while ( itr != mFxSchedule.end() )
+	{
+		next = itr;
+		next++;
+
+		delete *itr;
+		mFxSchedule.erase(itr);
+
+		itr = next;
+	}
+
+	if (bRemoveTemplates)
+	{
+		// Ditch any effect templates
+		for ( i = 1; i < FX_MAX_EFFECTS; i++ )
+		{
+			if ( i == idToPreserve)
+			{
+				continue;
+			}
+
+			if ( mEffectTemplates[i].mInUse )
+			{
+				// Ditch the primitives
+				for (j = 0; j < mEffectTemplates[i].mPrimitiveCount; j++)
+				{
+					delete mEffectTemplates[i].mPrimitives[j];
+				}
+			} 
+
+			mEffectTemplates[i].mInUse = false;
+		}
+
+		if (idToPreserve == 0)
+		{
+			mEffectIDs.clear();
+		}
+		else
+		{
+			// Clear the effect names, but first get the name of the effect to preserve,
+			// and restore it after clearing.
+			string str;
+			TEffectID::iterator iter;
+
+			for (iter = mEffectIDs.begin(); iter != mEffectIDs.end(); ++iter)
+			{
+				if ((*iter).second == idToPreserve)
+				{
+					str = (*iter).first;
+					break;
+				}
+			}
+
+			mEffectIDs.clear();
+
+			mEffectIDs[str] = idToPreserve;
+		}
+	}
+}
+
+//------------------------------------------------------
+// RegisterEffect
+//	Attempt to open the specified effect file, if 
+//	file read succeeds, parse the file.
+//
+// Input:
+//	path or filename to open
+//
+// Return:
+//	int handle to the effect
+//------------------------------------------------------
+int CFxScheduler::RegisterEffect( const char *file, bool bHasCorrectPath /*= false*/ )
+{
+	// Dealing with file names:
+	// File names can come from two places - the editor, in which case we should use the given
+	// path as is, and the effect file, in which case we should add the correct path and extension.
+	// In either case we create a stripped file name to use for naming effects.
+	//
+
+	char sfile[MAX_QPATH];
+
+	COM_StripExtension( file, sfile );
+	strlwr(sfile);
+
+	Com_DPrintf("Registering effect : %s\n", sfile);
+
+	// see if the specified file is already registered.  If it is, just return the id of that file
+	TEffectID::iterator itr;
+	
+	itr = mEffectIDs.find( sfile );
+
+	if ( itr != mEffectIDs.end() )
+	{
+		return (*itr).second;
+	}
+
+	CGenericParser2	parser;
+	int				len = 0;
+	fileHandle_t	fh;
+	char			data[65536];
+	char			*bufParse = 0;
+
+	// if our file doesn't have an extension, add one
+	string finalFilename = file;
+	string effectsSubstr = finalFilename.substr(0, 7);
+
+	if (finalFilename.find('.') == string::npos)
+	{
+		// didn't find an extension so add one
+		finalFilename += ".efx";
+	}
+
+	// kef - grr. this angers me. every filename everywhere should start from the base dir
+	if (effectsSubstr.compare("effects") != 0)
+	{
+		//theFxHelper.Print("Hey!!! '%s' should be pathed from the base directory!!!\n", finalFilename.c_str());
+		string strTemp = finalFilename;
+		finalFilename = "effects/";
+		finalFilename += strTemp;
+	}
+
+	len = theFxHelper.OpenFile( finalFilename.c_str(), &fh, FS_READ );
+
+	/*
+	if (bHasCorrectPath)
+	{
+		pfile = file;
+	}
+	else
+	{
+		// Add on our extension and prepend the file with the default path
+		sprintf( temp, "%s/%s.efx", FX_FILE_PATH, sfile );
+		pfile = temp;
+	}
+	len = theFxHelper.OpenFile( pfile, &fh, FS_READ );
+	*/
+
+
+	if ( len < 0 )
+	{
+		theFxHelper.Print( "Effect file load failed: %s\n", finalFilename.c_str() );
+		return 0;
+	}
+
+	if (len == 0)
+	{
+		theFxHelper.Print( "INVALID Effect file: %s\n", finalFilename.c_str() );
+		theFxHelper.CloseFile( fh );
+		return 0;
+	}
+
+	// If we'll overflow our buffer, bail out--not a particularly elegant solution
+	if (len >= sizeof(data) - 1 )
+	{
+		theFxHelper.CloseFile( fh );
+		return 0;
+	}
+
+	// Get the goods and ensure Null termination
+	theFxHelper.ReadFile( data, len, fh );
+	data[len] = '\0';
+	bufParse = data;
+
+	// Let the generic parser process the whole file
+	parser.Parse( &bufParse );
+
+	theFxHelper.CloseFile( fh );
+
+	// Lets convert the effect file into something that we can work with
+	return ParseEffect( sfile, parser.GetBaseParseGroup() );
+}
+
+
+//------------------------------------------------------
+// ParseEffect
+//	Starts at ground zero, using each group header to 
+//	determine which kind of effect we are working with.
+//	Then we call the appropriate function to parse the
+//	specified effect group.
+//
+// Input:
+//	base group, essentially the whole files contents
+//
+// Return:
+//	int handle of the effect
+//------------------------------------------------------
+int CFxScheduler::ParseEffect( const char *file, CGPGroup *base )
+{
+	CGPGroup			*primitiveGroup;
+	CPrimitiveTemplate	*prim;
+	const char			*grpName;
+	SEffectTemplate		*effect = 0;
+	EPrimType			type;
+	int					handle;
+	CGPValue			*pair;
+
+	effect = GetNewEffectTemplate( &handle, file );
+
+	if ( !handle || !effect )
+	{
+		// failure
+		return 0;
+	}
+	if ((pair = base->GetPairs())!=0)
+	{
+		grpName = pair->GetName();
+		if ( !stricmp( grpName, "repeatDelay" ))
+		{
+			effect->mRepeatDelay = atoi(pair->GetTopValue());
+		}
+		else
+		{//unknown
+
+		}
+	}
+
+	primitiveGroup = base->GetSubGroups();
+
+	while ( primitiveGroup )
+	{
+		grpName = primitiveGroup->GetName();
+
+		// Huge stricmp lists suxor
+		if ( !stricmp( grpName, "particle" ))
+		{
+			type = Particle;
+		}
+		else if ( !stricmp( grpName, "line" ))
+		{
+			type = Line;
+		}
+		else if ( !stricmp( grpName, "tail" ))
+		{
+			type = Tail;
+		}
+		else if ( !stricmp( grpName, "sound" ))
+		{
+			type = Sound;
+		}
+		else if ( !stricmp( grpName, "cylinder" ))
+		{
+			type = Cylinder;
+		}
+		else if ( !stricmp( grpName, "electricity" ))
+		{
+			type = Electricity;
+		}
+		else if ( !stricmp( grpName, "emitter" ))
+		{
+			type = Emitter;
+		}
+		else if ( !stricmp( grpName, "decal" ))
+		{
+			type = Decal;
+		}
+		else if ( !stricmp( grpName, "orientedparticle" ))
+		{
+			type = OrientedParticle;
+		}
+		else if ( !stricmp( grpName, "fxrunner" ))
+		{
+			type = FxRunner;
+		}
+		else if ( !stricmp( grpName, "light" ))
+		{
+			type = Light;
+		}
+		else if ( !stricmp( grpName, "cameraShake" ))
+		{
+			type = CameraShake;
+		}
+		else if ( !stricmp( grpName, "flash" ))
+		{
+			type = ScreenFlash;
+		}
+		else 
+		{
+			type = None;
+		}
+		
+		if ( type != None )
+		{
+			prim = new CPrimitiveTemplate;
+
+			prim->mType = type;
+			prim->ParsePrimitive( primitiveGroup );
+
+			// Add our primitive template to the effect list
+			AddPrimitiveToEffect( effect, prim );
+		}
+
+		primitiveGroup = (CGPGroup *)primitiveGroup->GetNext();
+	}
+
+	return handle;
+}
+
+
+//------------------------------------------------------
+// AddPrimitiveToEffect
+//	Takes a primitive and attaches it to the effect.
+//	
+// Input:
+//	Effect template that we tack the primitive on to
+//	Primitive to add to the effect template
+//
+// Return:
+//	None
+//------------------------------------------------------
+void CFxScheduler::AddPrimitiveToEffect( SEffectTemplate *fx, CPrimitiveTemplate *prim )
+{
+	int ct = fx->mPrimitiveCount;
+
+	if ( ct >= FX_MAX_EFFECT_COMPONENTS )
+	{
+		theFxHelper.Print( "FxScheduler:  Error--too many primitives in an effect\n" );
+	}
+	else
+	{
+		fx->mPrimitives[ct] = prim;
+		fx->mPrimitiveCount++;
+	}
+}
+
+//------------------------------------------------------
+// GetNewEffectTemplate
+//	Finds an unused effect template and returns it to the
+//	caller.
+//	
+// Input:
+//	pointer to an id that will be filled in, 
+//	file name-- should be NULL when requesting a copy
+//
+// Return:
+//	the id of the added effect template
+//------------------------------------------------------
+SEffectTemplate *CFxScheduler::GetNewEffectTemplate( int *id, const char *file )
+{
+	SEffectTemplate *effect;
+
+	// wanted zero to be a bogus effect ID, so we just skip it.
+	for ( int i = 1; i < FX_MAX_EFFECTS; i++ )
+	{
+		effect = &mEffectTemplates[i];
+
+		if ( !effect->mInUse )
+		{
+			*id = i;
+			memset( effect, 0, sizeof( SEffectTemplate ));
+
+			// If we are a copy, we really won't have a name that we care about saving for later
+			if ( file )
+			{
+				mEffectIDs[file] = i;
+				strcpy( effect->mEffectName, file );
+			}
+
+			effect->mInUse = true;
+			effect->mRepeatDelay = 300;
+			return effect;
+		}
+	}
+
+	theFxHelper.Print( "FxScheduler:  Error--reached max effects\n" );
+	*id = 0;
+	return 0;
+}
+
+//------------------------------------------------------
+// GetEffectCopy
+//	Returns a copy of the desired effect so that it can
+//	easily be modified run-time.
+//	
+// Input:
+//	file-- the name of the effect file that you want a copy of
+//	newHandle-- will actually be the returned handle to the new effect
+//				you have to hold onto this if you intend to call it again
+//
+// Return:
+//	the pointer to the copy
+//------------------------------------------------------
+SEffectTemplate *CFxScheduler::GetEffectCopy( const char *file, int *newHandle )
+{
+	return ( GetEffectCopy( mEffectIDs[file], newHandle ) );
+}
+
+//------------------------------------------------------
+// GetEffectCopy
+//	Returns a copy of the desired effect so that it can
+//	easily be modified run-time.
+//	
+// Input:
+//	fxHandle-- the handle to the effect that you want a copy of
+//	newHandle-- will actually be the returned handle to the new effect
+//				you have to hold onto this if you intend to call it again
+//
+// Return:
+//	the pointer to the copy
+//------------------------------------------------------
+SEffectTemplate *CFxScheduler::GetEffectCopy( int fxHandle, int *newHandle )
+{
+	if ( fxHandle < 1 || fxHandle >= FX_MAX_EFFECTS)
+	{
+		// Didn't even request a valid effect to copy!!!
+		theFxHelper.Print( "FxScheduler: Bad effect file copy request: id = %d\n", fxHandle );
+
+		*newHandle = 0;
+		return 0;
+	}
+
+	if (!mEffectTemplates[fxHandle].mInUse )
+	{
+		// Didn't even request a valid effect to copy!!!
+		theFxHelper.Print( "FxScheduler: Bad effect file copy request: id %d not inuse\n", fxHandle );
+
+		*newHandle = 0;
+		return 0;
+	}
+
+#ifdef _SOF2DEV_
+	// never get a copy when time is frozen
+	if ( fx_freeze->integer )
+	{
+		return 0;
+	}
+#endif
+
+	// Copies shouldn't have names, otherwise they could trash our stl map used for getting ID from name
+	SEffectTemplate *copy = GetNewEffectTemplate( newHandle, NULL );
+
+	if ( copy && *newHandle )
+	{
+		// do the effect copy and mark us as what we are
+		*copy = mEffectTemplates[fxHandle];
+		copy->mCopy = true;
+
+		// the user had better hold onto this handle if they ever hope to call this effect.
+		return copy;
+	}
+
+	// No space left to return an effect
+	*newHandle = 0;
+	return 0;
+}
+
+//------------------------------------------------------
+// GetPrimitiveCopy
+//	Helper function that returns a copy of the desired primitive
+//	
+// Input:
+//	fxHandle - the pointer to the effect copy you want to override
+//	componentName - name of the component to find
+//
+// Return:
+//	the pointer to the desired primitive
+//------------------------------------------------------
+CPrimitiveTemplate *CFxScheduler::GetPrimitiveCopy( SEffectTemplate *effectCopy, const char *componentName )
+{
+	if ( !effectCopy || !effectCopy->mInUse )
+	{
+		return NULL;
+	}
+
+	for ( int i = 0; i < effectCopy->mPrimitiveCount; i++ )
+	{
+		if ( !stricmp( effectCopy->mPrimitives[i]->mName, componentName ))
+		{
+			// we found a match, so return it
+			return effectCopy->mPrimitives[i];
+		}
+	}
+
+	// bah, no good.
+	return NULL;
+}
+
+
+void	CFxScheduler::MaterialImpact(trace_t *tr, CEffect *effect)
+{
+/*	EMatImpactEffect matImpactEffect = effect->GetMatImpactFX();
+	int impactParm = effect->GetMatImpactParm();
+
+	if (matImpactEffect == MATIMPACTFX_NONE)
+	{
+		return;
+	}
+	else if (matImpactEffect == MATIMPACTFX_SHELLSOUND)
+	{
+		// only want to play this for the first impact
+		effect->SetMatImpactFX(MATIMPACTFX_NONE);
+
+		int	material = tr->surfaceFlags & MATERIAL_MASK;
+		const char *ammoName = CWeaponSystem::GetAmmoName(impactParm);
+		
+		if(ammoName && materials[material].HasShellSound(ammoName))
+		{
+			theFxHelper.PlaySound( tr->endpos, ENTITYNUM_NONE, CHAN_AUTO, materials[material].GetShellSoundHandle(ammoName) );
+		}
+	}*/
+}
+
+
+//------------------------------------------------------
+static void ReportPlayEffectError(int id)
+{
+	theFxHelper.Print( "CFxScheduler::PlayEffect called with invalid effect ID: %i\n", id );
+}
+
+
+//------------------------------------------------------
+// PlayEffect
+//	Handles scheduling an effect so all the components
+//	happen at the specified time.  Applies a default up
+//	axis.
+//	
+// Input:
+//	Effect file id and the origin
+//
+// Return:
+//	none
+//------------------------------------------------------
+/*void CFxScheduler::PlayEffect( int id, vec3_t origin, int vol, int rad )
+{
+	vec3_t	axis[3];
+
+	VectorSet( axis[0], 0, 0, 1 );
+	VectorSet( axis[1], 1, 0, 0 );
+	VectorSet( axis[2], 0, 1, 0 );
+
+	PlayEffect( id, origin, axis, vol, rad );
+}
+*/
+//------------------------------------------------------
+// PlayEffect
+//	Handles scheduling an effect so all the components
+//	happen at the specified time.  Takes a fwd vector
+//	and builds a right and up vector
+//	
+// Input:
+//	Effect file id, the origin, and a fwd vector
+//
+// Return:
+//	none
+//------------------------------------------------------
+void CFxScheduler::PlayEffect( int id, vec3_t origin, vec3_t forward, int vol, int rad, bool isPortal )
+{
+	vec3_t	axis[3];
+
+	// Take the forward vector and create two arbitrary but perpendicular vectors
+	VectorCopy( forward, axis[0] );
+	MakeNormalVectors( forward, axis[1], axis[2] );
+
+	PlayEffect( id, origin, axis, -1, 0, -1, vol, rad, isPortal );
+}
+
+
+//------------------------------------------------------
+// PlayEffect
+//	Handles scheduling an effect so all the components
+//	happen at the specified time.  Uses the specified axis
+//	
+// Input:
+//	Effect file name, the origin, and axis.
+//	Optional boltInfo (defaults to -1) 
+//  and iGhoul2 used by boltInfo
+//
+// Return:
+//	none
+//------------------------------------------------------
+void CFxScheduler::PlayEffect( const char *file, vec3_t origin, vec3_t axis[3], const int boltInfo, int iGhoul2,
+							  int fxParm /*-1*/, int vol, int rad, int iLoopTime, bool isRelative )
+{
+	char	sfile[MAX_QPATH];
+
+	// Get an extenstion stripped version of the file
+	COM_StripExtension( file, sfile );
+
+#ifndef FINAL_BUILD
+	if ( mEffectIDs[sfile] == 0 )
+	{
+		theFxHelper.Print( "CFxScheduler::PlayEffect unregistered/non-existent effect: %s\n", sfile );
+		return;
+	}
+#endif
+
+	PlayEffect( mEffectIDs[sfile], origin, axis, boltInfo, iGhoul2, fxParm, vol, rad, qfalse, iLoopTime, isRelative );
+}
+
+int	totalPrimitives = 0;
+int	totalEffects = 0;
+
+void GetRGB_Colors( CPrimitiveTemplate *fx, vec3_t outStartRGB, vec3_t outEndRGB )
+{
+	float	percent;
+
+	if ( fx->mSpawnFlags & FX_RGB_COMPONENT_INTERP )
+	{
+		percent = flrand(0.0f, 1.0f);
+
+		VectorSet( outStartRGB, fx->mRedStart.GetVal(percent), fx->mGreenStart.GetVal(percent), fx->mBlueStart.GetVal(percent) );
+		VectorSet( outEndRGB, fx->mRedEnd.GetVal(percent), fx->mGreenEnd.GetVal(percent), fx->mBlueEnd.GetVal(percent) );
+	}
+	else
+	{
+		VectorSet( outStartRGB, fx->mRedStart.GetVal(), fx->mGreenStart.GetVal(), fx->mBlueStart.GetVal() );
+		VectorSet( outEndRGB, fx->mRedEnd.GetVal(), fx->mGreenEnd.GetVal(), fx->mBlueEnd.GetVal() );
+	}
+}
+
+//------------------------------------------------------
+// PlayEffect
+//	Handles scheduling an effect so all the components
+//	happen at the specified time.  Uses the specified axis
+//	
+// Input:
+//	Effect id, the origin, and axis.
+//	Optional boltInfo (defaults to -1)
+//  Optional entity number to be used by a cheap entity origin bolt (defaults to -1)
+//
+// Return:
+//	none
+//------------------------------------------------------
+void CFxScheduler::PlayEffect( int id, vec3_t origin, vec3_t axis[3], const int boltInfo, int iGhoul2, int fxParm /*-1*/, int vol, int rad, bool isPortal/*false*/, int iLoopTime/*0*/,  bool isRelative )
+{
+	SEffectTemplate			*fx;
+	CPrimitiveTemplate		*prim;
+	int						i = 0;
+	int						count = 0, delay = 0;
+	float					factor = 0.0f, fxscale;
+	bool					forceScheduling = false;
+
+	if ( id < 1 || id >= FX_MAX_EFFECTS || !mEffectTemplates[id].mInUse )
+	{
+		// Now you've done it!
+		ReportPlayEffectError(id);
+		return;
+	}
+
+#ifdef _SOF2DEV_
+	// Don't bother scheduling the effect if the system is currently frozen
+	if ( fx_freeze->integer )
+	{
+		return;
+	}
+#endif
+
+	int						modelNum = 0, boltNum = -1;
+	int						entityNum = -1;
+
+	if ( boltInfo > 0 )
+	{
+		// extract the wraith ID from the bolt info
+		modelNum	= ( boltInfo >> MODEL_SHIFT )	& MODEL_AND;
+		boltNum		= ( boltInfo >> BOLT_SHIFT )	& BOLT_AND;
+		entityNum	= ( boltInfo >> ENTITY_SHIFT )	& ENTITY_AND;
+
+		// We always force ghoul bolted objects to be scheduled so that they don't play right away.
+		forceScheduling = true;
+
+		if (iLoopTime)//0 = not looping, 1 for infinite, else duration
+		{//store off the id to reschedule every frame
+			ScheduleLoopedEffect(id, boltInfo, iGhoul2, !!isPortal, iLoopTime, isRelative);
+		}
+	}
+
+	// Get the effect.
+	fx = &mEffectTemplates[id];
+
+#ifndef FINAL_BUILD
+	if ( fx_debug->integer == 2 )
+	{
+		Com_Printf( "> %s\n", fx->mEffectName);
+	}
+#endif
+
+	// Loop through the primitives and schedule each bit
+	for ( i = 0; i < fx->mPrimitiveCount; i++ )
+	{
+		totalPrimitives++;
+		prim = fx->mPrimitives[i];
+
+		prim->mSoundRadius = rad;
+		prim->mSoundVolume = vol;
+
+		if ( prim->mCullRange )
+		{
+			if ( DistanceSquared( origin, theFxHelper.refdef->vieworg ) > prim->mCullRange ) // cullrange gets squared on load
+			{
+				// is too far away
+				continue;
+			}
+		}
+
+		// Scale the particles based on the countscale factor.  Never, ever scale the particles upwards, however.
+		fxscale = fx_countScale->value;
+		if (fxscale > 1.0) 
+		{
+			fxscale = 1.0;
+		}
+		// Only use scalability if there is a range
+		// Temp fix until I have time to reweight all the scalability files
+		if(fabsf(prim->mSpawnCount.GetMax() - prim->mSpawnCount.GetMin()) > 1.0f)
+		{
+			count = Round(prim->mSpawnCount.GetVal() * fxscale);
+		}
+		else
+		{
+			count = Round(prim->mSpawnCount.GetVal());
+		}
+		// Make sure we have at least one particle after scaling
+		if(prim->mSpawnCount.GetMin() >= 1.0f && count < 1)
+		{
+			count = 1;
+		}
+
+		if ( prim->mCopy )
+		{
+			// If we are a copy, we need to store a "how many references count" so that we
+			//	can keep the primitive template around for the correct amount of time.
+			prim->mRefCount = count;
+		}
+
+		if ( prim->mSpawnFlags & FX_EVEN_DISTRIBUTION )
+		{
+			factor = abs(prim->mSpawnDelay.GetMax() - prim->mSpawnDelay.GetMin()) / (float)count;
+		}
+
+		// Schedule the random number of bits
+		for ( int t = 0; t < count; t++ )
+		{
+			totalEffects++;
+			if ( prim->mSpawnFlags & FX_EVEN_DISTRIBUTION )
+			{
+				delay = t * factor;
+			}
+			else
+			{
+				delay = prim->mSpawnDelay.GetVal();
+			}
+
+			// if the delay is so small, we may as well just create this bit right now
+			if ( delay < 1 && !forceScheduling && !isPortal )
+			{
+				if ( boltInfo == -1 && entityNum != -1 )
+				{
+					// Find out where the entity currently is
+					TCGVectorData	*data = (TCGVectorData*)cl.mSharedMemory;
+
+					data->mEntityNum = entityNum;
+					VM_Call( cgvm, CG_GET_LERP_ORIGIN );
+					CreateEffect( prim, data->mPoint, axis, -delay, fxParm );
+				}
+				else
+				{
+					CreateEffect( prim, origin, axis, -delay, fxParm );
+				}
+			}
+			else
+			{
+				// We have to create a new scheduled effect so that we can create it at a later point
+				//	you should avoid this because it's much more expensive
+				SScheduledEffect		*sfx;
+				sfx = new SScheduledEffect;
+				sfx->mStartTime = theFxHelper.mTime + delay;
+				sfx->mpTemplate = prim;
+				sfx->mIsRelative = isRelative;
+				sfx->mPortalEffect = isPortal;
+
+				if ( boltInfo == -1 )
+				{
+					sfx->iGhoul2 = 0;
+					if ( entityNum == -1 )
+					{
+						// we aren't bolting, so make sure the spawn system knows this by putting -1's in these fields
+						sfx->mBoltNum = -1;
+						sfx->mEntNum = ENTITYNUM_NONE;
+						sfx->mModelNum = 0;
+
+						if ( origin )
+						{
+							VectorCopy( origin, sfx->mOrigin );
+						}
+						else
+						{
+							VectorClear( sfx->mOrigin );
+						}
+
+						AxisCopy( axis, sfx->mAxis );
+					}
+					else
+					{
+						// we are doing bolting onto the origin of the entity, so use a cheaper method
+						sfx->mBoltNum = -1;
+						sfx->mEntNum = entityNum;
+						sfx->mModelNum = 0;
+
+						AxisCopy( axis, sfx->mAxis );
+					}
+				}
+				else
+				{
+					// we are bolting, so store the extra info
+					sfx->mBoltNum = boltNum;
+					sfx->mEntNum = entityNum;
+					sfx->mModelNum = modelNum;
+					sfx->iGhoul2 = iGhoul2;
+
+					// Also, the ghoul bolt may not be around yet, so delay the creation one frame
+					sfx->mStartTime++;
+				}
+
+				mFxSchedule.push_front( sfx );
+			}
+		}
+	}
+
+	// We track effect templates and primitive templates separately.
+	if ( fx->mCopy )
+	{
+		// We don't use dynamic memory allocation, so just mark us as dead
+		fx->mInUse = false;
+	}
+}
+
+//------------------------------------------------------
+// PlayEffect
+//	Handles scheduling an effect so all the components
+//	happen at the specified time.  Applies a default up
+//	axis.
+//	
+// Input:
+//	Effect file name and the origin
+//
+// Return:
+//	none
+//------------------------------------------------------
+/*
+void CFxScheduler::PlayEffect( const char *file, vec3_t origin, int vol, int rad )
+{
+	char	sfile[MAX_QPATH];
+
+	// Get an extenstion stripped version of the file
+	COM_StripExtension( file, sfile );
+
+	PlayEffect( mEffectIDs[sfile], origin, vol, rad );
+}
+*/
+//------------------------------------------------------
+// PlayEffect
+//	Handles scheduling an effect so all the components
+//	happen at the specified time.  Takes a forward vector
+//	and uses this to complete the axis field.
+//	
+// Input:
+//	Effect file name, the origin, and a forward vector
+//
+// Return:
+//	none
+//------------------------------------------------------
+void CFxScheduler::PlayEffect( const char *file, vec3_t origin, vec3_t forward, int vol, int rad )
+{
+	char	sfile[MAX_QPATH];
+
+	// Get an extenstion stripped version of the file
+	COM_StripExtension( file, sfile );
+
+	PlayEffect( mEffectIDs[sfile], origin, forward, vol, rad );
+}
+
+//------------------------------------------------------
+// AddScheduledEffects
+//	Handles determining if a scheduled effect should
+//	be created or not.  If it should it handles converting
+//	the template effect into a real one.
+//	
+// Input:
+//	none
+//
+// Return:
+//	none
+//------------------------------------------------------
+bool gEffectsInPortal = qfalse; //this is just because I don't want to have to add an mPortalEffect field to every actual effect.
+
+void CFxScheduler::AddScheduledEffects( bool portal )
+{
+	TScheduledEffect::iterator	itr, next;
+	SScheduledEffect			*schedEffect = 0;
+	vec3_t						origin;
+	vec3_t						axis[3];
+	int							oldEntNum = -1, oldBoltIndex = -1, oldModelNum = -1;
+	qboolean					doesBoltExist  = qfalse;
+
+	if (portal)
+	{
+		gEffectsInPortal = true;
+	}
+	else
+	{
+		AddLoopedEffects();
+	}
+
+	itr = mFxSchedule.begin();
+
+	while ( itr != mFxSchedule.end() )
+	{
+		next = itr;
+		next++;
+		schedEffect = (*itr);
+
+		if (portal == (*itr)->mPortalEffect)
+		{ //only render portal fx on the skyportal pass and vice versa
+			if ( *(*itr) <= theFxHelper.mTime )
+			{
+				if ((*itr)->mBoltNum == -1)
+				{// ok, are we spawning a bolt on effect or a normal one?
+					if ( (*itr)->mEntNum != ENTITYNUM_NONE )
+					{
+						// Find out where the entity currently is
+						TCGVectorData	*data = (TCGVectorData*)cl.mSharedMemory;
+
+						data->mEntityNum = (*itr)->mEntNum;
+						VM_Call( cgvm, CG_GET_LERP_ORIGIN );
+						CreateEffect( (*itr)->mpTemplate, 
+									data->mPoint, (*itr)->mAxis, 
+									theFxHelper.mTime - (*itr)->mStartTime );
+					}
+					else
+					{
+						CreateEffect( (*itr)->mpTemplate, 
+									(*itr)->mOrigin, (*itr)->mAxis, 
+									theFxHelper.mTime - (*itr)->mStartTime );
+					}
+				}
+				else
+				{	//bolted on effect
+					// do we need to go and re-get the bolt matrix again? Since it takes time lets try to do it only once
+					if (((*itr)->mModelNum != oldModelNum) || 
+						((*itr)->mEntNum != oldEntNum) || 
+						((*itr)->mBoltNum != oldBoltIndex))
+					{
+						oldModelNum = (*itr)->mModelNum;
+						oldEntNum = (*itr)->mEntNum;
+						oldBoltIndex = (*itr)->mBoltNum;
+						CGhoul2Info_v Ghoul2((*itr)->iGhoul2);
+						doesBoltExist = theFxHelper.GetOriginAxisFromBolt(&Ghoul2, (*itr)->mEntNum, (*itr)->mModelNum, (*itr)->mBoltNum, origin, axis);
+						Ghoul2.kill();	//remove the model ref without actually deleting it
+					}
+
+					// only do this if we found the bolt
+					if (doesBoltExist)
+					{
+						if ((*itr)->mIsRelative )
+						{
+							CreateEffect( (*itr)->mpTemplate, 
+										origin, axis, 0, -1, 
+										(*itr)->iGhoul2, (*itr)->mEntNum, (*itr)->mModelNum, (*itr)->mBoltNum );
+						}
+						else
+						{
+							CreateEffect( (*itr)->mpTemplate, 
+										origin, axis, 
+										theFxHelper.mTime - (*itr)->mStartTime );
+						}
+					}
+				}
+
+				delete *itr;
+				mFxSchedule.erase(itr);
+			}
+		}
+
+		itr = next;
+	}
+
+	// Add all active effects into the scene
+	FX_Add( !!portal );
+
+	gEffectsInPortal = false;
+}
+
+bool CFxScheduler::Add2DEffect(float x, float y, float w, float h, vec4_t color, qhandle_t shaderHandle)
+{
+	// need some sort of scale here because the effect was created using world units, not pixels
+	float		fxScale2D = 10.0f;
+
+	if (mNextFree2DEffect < FX_MAX_2DEFFECTS)
+	{
+		m2DEffects[mNextFree2DEffect].mScreenX = x;
+		m2DEffects[mNextFree2DEffect].mScreenY = y;
+		m2DEffects[mNextFree2DEffect].mWidth = w*fxScale2D;
+		m2DEffects[mNextFree2DEffect].mHeight = h*fxScale2D;
+		VectorCopy4(color, m2DEffects[mNextFree2DEffect].mColor);
+		m2DEffects[mNextFree2DEffect].mShaderHandle = shaderHandle;
+
+		mNextFree2DEffect++;
+		return true;
+	}
+	return false;
+}
+
+void CFxScheduler::Draw2DEffects(float screenXScale, float screenYScale)
+{
+	float	x = 0, y = 0, w = 0, h = 0;
+
+	for (int i = 0; i < mNextFree2DEffect; i++)
+	{
+		x = m2DEffects[i].mScreenX;
+		y = m2DEffects[i].mScreenY;
+		w = m2DEffects[i].mWidth;
+		h = m2DEffects[i].mHeight;
+
+		x *= screenXScale;
+		w *= screenXScale;
+		y *= screenYScale;
+		h *= screenYScale;
+
+		//allow 2d effect coloring?
+		re.DrawStretchPic(x - (w*0.5f), y - (h*0.5f), w, h, 0, 0, 1, 1, /*m2DEffects[i].mColor,*/ m2DEffects[i].mShaderHandle);
+	}
+	// now that all 2D effects have been drawn we can consider the entire array to be free
+	mNextFree2DEffect = 0;
+}
+
+//------------------------------------------------------
+// CreateEffect
+//	Creates the specified fx taking into account the
+//	multitude of different ways it could be spawned.
+//	
+// Input:
+//	template used to build the effect, desired effect origin, 
+//	desired orientation and how late the effect is so that
+//	it can be moved to the correct spot
+//
+// Return:
+//	none
+//------------------------------------------------------
+void CFxScheduler::CreateEffect( CPrimitiveTemplate *fx, const vec3_t origin, vec3_t axis[3], int lateTime, int fxParm /*-1*/, int iGhoul2, int entNum, int modelNum, int boltNum  )
+{
+	vec3_t	org, org2, temp,
+				vel, accel,
+				sRGB, eRGB,
+				ang, angDelta,
+				ax[3];
+	trace_t	tr;
+	int		emitterModel;
+
+	// We may modify the axis, so make a work copy
+	AxisCopy( axis, ax );
+
+	int flags = fx->mFlags;
+	if (iGhoul2>0 && modelNum>=0 && boltNum>=0)
+	{//since you passed in these values, mark as relative to use them if it is supported
+		switch( fx->mType )
+		{
+		case Particle:
+		case Line:
+		case Tail:
+		case Electricity:
+		case Cylinder:
+		case Emitter:
+		case OrientedParticle:
+		case Light:
+			flags |= FX_RELATIVE;
+			break;
+		case Decal:
+		case FxRunner:
+		case ScreenFlash:
+			//not supported yet
+		case Sound:
+		case CameraShake:
+			//does not work bolted
+				break;
+		}
+	}
+
+	if( fx->mSpawnFlags & FX_RAND_ROT_AROUND_FWD )
+	{
+		RotatePointAroundVector( ax[1], ax[0], axis[1], flrand(0.0f, 360.0f) );
+		CrossProduct( ax[0], ax[1], ax[2] );
+	}
+
+	// Origin calculations
+	//-------------------------------------
+	if ( fx->mSpawnFlags & FX_CHEAP_ORG_CALC || flags & FX_RELATIVE  )
+	{ // let's take the easy way out
+		VectorSet( org, fx->mOrigin1X.GetVal(), fx->mOrigin1Y.GetVal(), fx->mOrigin1Z.GetVal() );
+	}
+	else
+	{ // time for some extra work
+		VectorScale( ax[0], fx->mOrigin1X.GetVal(), org );
+		VectorMA( org, fx->mOrigin1Y.GetVal(), ax[1], org );
+		VectorMA( org, fx->mOrigin1Z.GetVal(), ax[2], org );
+	}
+
+	// We always add our calculated offset to the passed in origin, unless relative!
+	if( !(flags & FX_RELATIVE) )
+	{
+		VectorAdd( org, origin, org );
+	}
+	// Now, we may need to calc a point on a sphere/ellipsoid/cylinder/disk and add that to it
+	//----------------------------------------------------------------
+	if ( fx->mSpawnFlags & FX_ORG_ON_SPHERE )
+	{
+		float x, y;
+		float width, height;
+		
+		x = DEG2RAD( flrand(0.0f, 360.0f) );
+		y = DEG2RAD( flrand(0.0f, 180.0f) );
+
+		width = fx->mRadius.GetVal();
+		height = fx->mHeight.GetVal();
+
+		// calculate point on ellipse
+		VectorSet( temp, sin(x) * width * sin(y), cos(x) * width * sin(y), cos(y) * height ); // sinx * siny, cosx * siny, cosy
+		VectorAdd( org, temp, org );
+
+		if ( fx->mSpawnFlags & FX_AXIS_FROM_SPHERE )
+		{ 
+			// well, we will now override the axis at the users request
+			VectorNormalize2( temp, ax[0] );
+			MakeNormalVectors( ax[0], ax[1], ax[2] );
+		}
+	}
+	else if ( fx->mSpawnFlags & FX_ORG_ON_CYLINDER )
+	{
+		vec3_t	pt;
+
+		// set up our point, then rotate around the current direction to.  Make unrotated cylinder centered around 0,0,0
+		VectorScale( ax[1], fx->mRadius.GetVal(), pt );
+		VectorMA( pt, flrand(-1.0f, 1.0f) * 0.5f * fx->mHeight.GetVal(), ax[0], pt );
+		RotatePointAroundVector( temp, ax[0], pt, flrand(0.0f, 360.0f) );
+
+		VectorAdd( org, temp, org );
+
+		if ( fx->mSpawnFlags & FX_AXIS_FROM_SPHERE )
+		{ 
+			vec3_t up={0,0,1};
+
+			// well, we will now override the axis at the users request
+			VectorNormalize2( temp, ax[0] );
+
+			if ( ax[0][2] == 1.0f )
+			{
+				// readjust up
+				VectorSet( up, 0, 1, 0 );
+			}
+
+			CrossProduct( up, ax[0], ax[1] );
+			CrossProduct( ax[0], ax[1], ax[2] );
+		}
+	}
+
+	if ( fx->mType == OrientedParticle )
+	{//bolted oriented particles use origin2 as an angular rotation offset...
+		if ( flags & FX_RELATIVE )
+		{
+			VectorSet( ax[0], fx->mOrigin2X.GetVal(), fx->mOrigin2Y.GetVal(), fx->mOrigin2Z.GetVal() );
+		}
+	}
+	
+	// There are only a few types that really use velocity and acceleration, so do extra work for those types
+	//--------------------------------------------------------------------------------------------------------
+	if ( fx->mType == Particle || fx->mType == OrientedParticle || fx->mType == Tail || fx->mType == Emitter )
+	{
+		// Velocity calculations
+		//-------------------------------------
+		if ( fx->mSpawnFlags & FX_VEL_IS_ABSOLUTE || flags & FX_RELATIVE )
+		{  
+			VectorSet( vel, fx->mVelX.GetVal(), fx->mVelY.GetVal(), fx->mVelZ.GetVal() );
+		}
+		else
+		{ // bah, do some extra work to coerce it
+			VectorScale( ax[0], fx->mVelX.GetVal(), vel );
+			VectorMA( vel, fx->mVelY.GetVal(), ax[1], vel );
+			VectorMA( vel, fx->mVelZ.GetVal(), ax[2], vel );
+		}
+
+		//-------------------------------------
+		if ( fx->mSpawnFlags & FX_AFFECTED_BY_WIND )
+		{
+/*rjr			vec3_t wind;
+
+			// wind is affecting us, so modify our initial velocity.  ideally, we would update throughout our lives, but this is easier
+			CL_GetWindVector( wind );
+			VectorMA( vel, fx->mWindModifier.GetVal() * 0.01f, wind, vel );
+			*/
+		}
+
+		// Acceleration calculations
+		//-------------------------------------
+		if ( fx->mSpawnFlags & FX_ACCEL_IS_ABSOLUTE || flags & FX_RELATIVE )
+		{ 
+			VectorSet( accel, fx->mAccelX.GetVal(), fx->mAccelY.GetVal(), fx->mAccelZ.GetVal() );
+		}
+		else
+		{
+			VectorScale( ax[0], fx->mAccelX.GetVal(), accel );
+			VectorMA( accel, fx->mAccelY.GetVal(), ax[1], accel );
+			VectorMA( accel, fx->mAccelZ.GetVal(), ax[2], accel );
+		}
+
+		// Gravity is completely decoupled from acceleration since it is __always__ absolute
+		// NOTE: I only effect Z ( up/down in the Quake world )
+		accel[2] += fx->mGravity.GetVal();
+	
+		// There may be a lag between when the effect should be created and when it actually gets created.  
+		//	Since we know what the discrepancy is, we can attempt to compensate...
+		if ( lateTime > 0 )
+		{
+			// Calc the time differences
+			float ftime = lateTime * 0.001f;
+			float time2 = ftime * ftime * 0.5f;
+
+			VectorMA( vel, ftime, accel, vel );
+
+			// Predict the new position
+			for ( int i = 0 ; i < 3 ; i++ ) 
+			{
+				org[i] = org[i] + ftime * vel[i] + time2 * vel[i];
+			}
+		}
+	} // end moving types
+
+	// Line type primitives work with an origin2, so do the extra work for them
+	//--------------------------------------------------------------------------
+	if ( fx->mType == Line || fx->mType == Electricity )
+	{
+		// We may have to do a trace to find our endpoint
+		if ( fx->mSpawnFlags & FX_ORG2_FROM_TRACE )
+		{
+			VectorMA( org, FX_MAX_TRACE_DIST, ax[0], temp );
+
+			if ( fx->mSpawnFlags & FX_ORG2_IS_OFFSET )
+			{ // add a random flair to the endpoint...note: org2 will have to be pretty large to affect this much
+				// we also do this pre-trace as opposed to post trace since we may have to render an impact effect
+				//	and we will want the normal at the exact endpos...
+				if ( fx->mSpawnFlags & FX_CHEAP_ORG2_CALC || flags & FX_RELATIVE )
+				{ 
+					VectorSet( org2, fx->mOrigin2X.GetVal(), fx->mOrigin2Y.GetVal(), fx->mOrigin2Z.GetVal() );
+					VectorAdd( org2, temp, temp );
+				}
+				else
+				{ // I can only imagine a few cases where you might want to do this...
+					VectorMA( temp, fx->mOrigin2X.GetVal(), ax[0], temp );
+					VectorMA( temp, fx->mOrigin2Y.GetVal(), ax[1], temp );
+					VectorMA( temp, fx->mOrigin2Z.GetVal(), ax[2], temp );
+				}
+			}
+
+			theFxHelper.Trace( tr, org, NULL, NULL, temp, -1, MASK_SOLID );
+
+			VectorCopy( tr.endpos, org2 );
+
+			if ( fx->mSpawnFlags & FX_TRACE_IMPACT_FX )
+			{
+				PlayEffect( fx->mImpactFxHandles.GetHandle(), org2, tr.plane.normal );
+			}
+		}
+		else
+		{
+			if ( fx->mSpawnFlags & FX_CHEAP_ORG2_CALC || flags & FX_RELATIVE )
+			{
+				VectorSet( org2, fx->mOrigin2X.GetVal(), fx->mOrigin2Y.GetVal(), fx->mOrigin2Z.GetVal() );
+			}
+			else
+			{
+				VectorScale( ax[0], fx->mOrigin2X.GetVal(), org2 );
+				VectorMA( org2, fx->mOrigin2Y.GetVal(), ax[1], org2 );
+				VectorMA( org2, fx->mOrigin2Z.GetVal(), ax[2], org2 );
+			}
+			if( !(flags & FX_RELATIVE) )
+			{
+				VectorAdd( org2, origin, org2 );
+			}
+		}
+	} // end special org2 types
+
+	// handle RGB color, but only for types that will use it
+	//---------------------------------------------------------------------------
+	if ( fx->mType != Sound && fx->mType != FxRunner && fx->mType != CameraShake )
+	{
+		GetRGB_Colors( fx, sRGB, eRGB );
+	}
+
+	// Now create the appropriate effect entity
+	//------------------------
+	switch( fx->mType )
+	{
+	//---------
+	case Particle:
+	//---------
+
+		FX_AddParticle( org, vel, accel, 
+						fx->mSizeStart.GetVal(), fx->mSizeEnd.GetVal(), fx->mSizeParm.GetVal(),
+						fx->mAlphaStart.GetVal(), fx->mAlphaEnd.GetVal(), fx->mAlphaParm.GetVal(),
+						sRGB, eRGB, fx->mRGBParm.GetVal(),
+						fx->mRotation.GetVal(), fx->mRotationDelta.GetVal(),
+						fx->mMin, fx->mMax, fx->mElasticity.GetVal(), 
+						fx->mDeathFxHandles.GetHandle(), fx->mImpactFxHandles.GetHandle(),
+						fx->mLife.GetVal(), fx->mMediaHandles.GetHandle(), flags, fx->mMatImpactFX, fxParm,
+						iGhoul2, entNum, modelNum, boltNum );
+		break;
+
+	//---------
+	case Line:
+	//---------
+
+		FX_AddLine( org, org2, 
+						fx->mSizeStart.GetVal(), fx->mSizeEnd.GetVal(), fx->mSizeParm.GetVal(),
+						fx->mAlphaStart.GetVal(), fx->mAlphaEnd.GetVal(), fx->mAlphaParm.GetVal(),
+						sRGB, eRGB, fx->mRGBParm.GetVal(),
+						fx->mLife.GetVal(), fx->mMediaHandles.GetHandle(), flags, fx->mMatImpactFX, fxParm,
+						iGhoul2, entNum, modelNum, boltNum);
+		break;
+
+	//---------
+	case Tail:
+	//---------
+
+		FX_AddTail( org, vel, accel,
+						fx->mSizeStart.GetVal(), fx->mSizeEnd.GetVal(), fx->mSizeParm.GetVal(),
+						fx->mLengthStart.GetVal(), fx->mLengthEnd.GetVal(), fx->mLengthParm.GetVal(),
+						fx->mAlphaStart.GetVal(), fx->mAlphaEnd.GetVal(), fx->mAlphaParm.GetVal(),
+						sRGB, eRGB, fx->mRGBParm.GetVal(),
+						fx->mMin, fx->mMax, fx->mElasticity.GetVal(), 
+						fx->mDeathFxHandles.GetHandle(), fx->mImpactFxHandles.GetHandle(),
+						fx->mLife.GetVal(), fx->mMediaHandles.GetHandle(), flags, fx->mMatImpactFX, fxParm,
+						iGhoul2, entNum, modelNum, boltNum);
+		break;
+
+	//----------------
+	case Electricity:
+	//----------------
+
+		FX_AddElectricity( org, org2, 
+						fx->mSizeStart.GetVal(), fx->mSizeEnd.GetVal(), fx->mSizeParm.GetVal(),
+						fx->mAlphaStart.GetVal(), fx->mAlphaEnd.GetVal(), fx->mAlphaParm.GetVal(),
+						sRGB, eRGB, fx->mRGBParm.GetVal(),
+						fx->mElasticity.GetVal(), fx->mLife.GetVal(), fx->mMediaHandles.GetHandle(), flags,
+						fx->mMatImpactFX, fxParm,
+						iGhoul2, entNum, modelNum, boltNum);
+		break;
+
+	//---------
+	case Cylinder:
+	//---------
+
+		FX_AddCylinder( org, ax[0],
+						fx->mSizeStart.GetVal(), fx->mSizeEnd.GetVal(), fx->mSizeParm.GetVal(),
+						fx->mSize2Start.GetVal(), fx->mSize2End.GetVal(), fx->mSize2Parm.GetVal(),
+						fx->mLengthStart.GetVal(), fx->mLengthEnd.GetVal(), fx->mLengthParm.GetVal(),
+						fx->mAlphaStart.GetVal(), fx->mAlphaEnd.GetVal(), fx->mAlphaParm.GetVal(),
+						sRGB, eRGB, fx->mRGBParm.GetVal(),
+						fx->mLife.GetVal(), fx->mMediaHandles.GetHandle(), flags, fx->mMatImpactFX, fxParm,
+						iGhoul2, entNum, modelNum, boltNum,
+						(qboolean)( fx->mSpawnFlags & FX_ORG2_FROM_TRACE ));
+		break;
+
+	//---------
+	case Emitter:
+	//---------
+
+		// for chunk angles, you don't really need much control over the end result...you just want variation..
+		VectorSet( ang, 
+					fx->mAngle1.GetVal(), 
+					fx->mAngle2.GetVal(), 
+					fx->mAngle3.GetVal() );
+
+		vectoangles( ax[0], temp );
+		VectorAdd( ang, temp, ang );
+
+		VectorSet( angDelta, 
+					fx->mAngle1Delta.GetVal(), 
+					fx->mAngle2Delta.GetVal(), 
+					fx->mAngle3Delta.GetVal() );
+
+		emitterModel = fx->mMediaHandles.GetHandle();
+
+		FX_AddEmitter( org, vel, accel,
+						fx->mSizeStart.GetVal(), fx->mSizeEnd.GetVal(), fx->mSizeParm.GetVal(),
+						fx->mAlphaStart.GetVal(), fx->mAlphaEnd.GetVal(), fx->mAlphaParm.GetVal(),
+						sRGB, eRGB, fx->mRGBParm.GetVal(),
+						ang, angDelta,
+						fx->mMin, fx->mMax, fx->mElasticity.GetVal(),
+						fx->mDeathFxHandles.GetHandle(), fx->mImpactFxHandles.GetHandle(),
+						fx->mEmitterFxHandles.GetHandle(),
+						fx->mDensity.GetVal(), fx->mVariance.GetVal(),
+						fx->mLife.GetVal(), emitterModel, flags, fx->mMatImpactFX, fxParm );
+		break;
+
+	//---------
+	case Decal:
+	//---------
+
+/* rjr
+		// This function is a somewhat higher-cost function for projecting a decal mark onto a surface.
+		// We shouldn't always need this, only for big hits or when a decal is very close-up.
+
+		// If the impact size is greater than 6, don't even try to use cheap sprites.  Big marks need real decals.
+		if (fx->mSizeStart.GetVal()<6)
+		{
+			vec3_t dest, normal;
+			int findmarkret;
+
+			findmarkret = CG_FindMark(org, ax[0], dest, normal);
+
+			if (findmarkret)
+			{	// Legal to put down a mark.
+				
+				if ( findmarkret == FINDMARK_CHEAP ||		// If we can't put down a decal OR if and distance > 200
+						DistanceSquared( dest, cg.refdef.vieworg ) > 40000)
+				{	// Use cheap oriented particle decals.
+					vec3_t zerovec={0,0,0};
+
+					FX_AddOrientedParticle( effectCloud, org, ax[0], 
+							zerovec,	// velocity
+							zerovec,	// acceleration
+							fx->mSizeStart.GetVal(), fx->mSizeStart.GetVal(), 0,	// size params
+							fx->mAlphaStart.GetVal(), 0, 0.75,						// alpha params (start fading at 75% life)
+							sRGB, sRGB, 0,											// rgb params
+							fx->mRotation.GetVal(), 0,								// rotation delta
+							zerovec,	// min
+							zerovec,	// max
+							0,			// bounce
+							0,			// deathID
+							0,			// impactID
+							20000,		// lifetime
+							fx->mMediaHandles.GetHandle(), 
+							(fx->mFlags&~FX_ALPHA_PARM_MASK)|FX_ALPHA_NONLINEAR, 
+							MATIMPACTFX_NONE, -1);
+				}
+				else
+				{	// Use the expensive kind.
+					color.rgba.r = sRGB[0] * 0xff;
+					color.rgba.g = sRGB[1] * 0xff;
+					color.rgba.b = sRGB[2] * 0xff;
+					color.rgba.a = fx->mAlphaStart.GetVal() * 0xff;
+
+					CG_ImpactMark( fx->mMediaHandles.GetHandle(), org, ax[0], 
+								fx->mRotation.GetVal(), color.c, 12000, 8000,
+								true, fx->mSizeStart.GetVal(), false );
+				}
+			}
+		}
+		else
+		{	// Use the expensive kind.
+			color.rgba.r = sRGB[0] * 0xff;
+			color.rgba.g = sRGB[1] * 0xff;
+			color.rgba.b = sRGB[2] * 0xff;
+			color.rgba.a = fx->mAlphaStart.GetVal() * 0xff;
+
+			CG_ImpactMark( fx->mMediaHandles.GetHandle(), org, ax[0], 
+						fx->mRotation.GetVal(), color.c, 12000, 8000,
+						true, fx->mSizeStart.GetVal(), false );
+		} */
+
+		theFxHelper.AddDecalToScene ( fx->mMediaHandles.GetHandle(), org, ax[0], fx->mRotation.GetVal(), sRGB[0], sRGB[1], sRGB[2], fx->mAlphaStart.GetVal(), qtrue, fx->mSizeStart.GetVal(), qfalse );
+
+		if (fx->mFlags & FX_GHOUL2_DECALS)
+		{
+			theFxHelper.AddGhoul2Decal(fx->mMediaHandles.GetHandle(), org, ax[0], fx->mSizeStart.GetVal());
+		}
+
+		break;
+
+	//-------------------
+	case OrientedParticle:
+	//-------------------
+
+		FX_AddOrientedParticle( org, ax[0], vel, accel,
+					fx->mSizeStart.GetVal(), fx->mSizeEnd.GetVal(), fx->mSizeParm.GetVal(),
+					fx->mAlphaStart.GetVal(), fx->mAlphaEnd.GetVal(), fx->mAlphaParm.GetVal(),
+					sRGB, eRGB, fx->mRGBParm.GetVal(),
+					fx->mRotation.GetVal(), fx->mRotationDelta.GetVal(),
+					fx->mMin, fx->mMax, fx->mElasticity.GetVal(),
+					fx->mDeathFxHandles.GetHandle(), fx->mImpactFxHandles.GetHandle(),
+					fx->mLife.GetVal(), fx->mMediaHandles.GetHandle(), flags, fx->mMatImpactFX, fxParm,
+					iGhoul2, entNum, modelNum, boltNum);
+		break;
+
+	//---------
+	case Sound:
+	//---------
+		if (gEffectsInPortal)
+		{ //could orient this anyway for panning, but eh. It's going to appear to the player in the sky the same place no matter what, so just make it a local sound.
+			theFxHelper.PlayLocalSound( fx->mMediaHandles.GetHandle(), CHAN_AUTO );
+		}
+		else
+		{
+			theFxHelper.PlaySound( org, ENTITYNUM_NONE, CHAN_AUTO, fx->mMediaHandles.GetHandle(), fx->mSoundVolume, fx->mSoundRadius );
+		}
+		break;
+
+	//---------
+	case FxRunner:
+	//---------
+		
+		PlayEffect( fx->mPlayFxHandles.GetHandle(), org, ax );
+		break;
+
+	//---------
+	case Light:
+	//---------
+
+		FX_AddLight( org, fx->mSizeStart.GetVal(), fx->mSizeEnd.GetVal(), fx->mSizeParm.GetVal(),
+						sRGB, eRGB, fx->mRGBParm.GetVal(),
+						fx->mLife.GetVal(), flags, fx->mMatImpactFX, fxParm,
+						iGhoul2, entNum, modelNum, boltNum);
+		break;
+
+	//---------
+	case CameraShake:
+	//---------
+		// It calculates how intense the shake should be based on how close you are to the origin you pass in here
+		//	elasticity is actually the intensity...radius is the distance in which the shake will have some effect
+		//	life is how long the effect lasts.
+		theFxHelper.CameraShake( org, fx->mElasticity.GetVal(), fx->mRadius.GetVal(), fx->mLife.GetVal() );
+		break;
+
+	//--------------
+	case ScreenFlash:
+	//--------------
+
+		FX_AddFlash( org, fx->mSizeStart.GetVal(), fx->mSizeEnd.GetVal(), fx->mSizeParm.GetVal(),
+					fx->mAlphaStart.GetVal(), fx->mAlphaEnd.GetVal(), fx->mAlphaParm.GetVal(),
+					sRGB, eRGB, fx->mRGBParm.GetVal(),
+					fx->mLife.GetVal(), fx->mMediaHandles.GetHandle(), flags, fx->mMatImpactFX, fxParm );
+		break;
+
+	default:
+		assert(0);
+		break;
+	}
+
+	// Track when we need to clean ourselves up if we are a copy
+	if ( fx->mCopy )
+	{
+		fx->mRefCount--;
+
+		if ( fx->mRefCount <= 0 )
+		{
+			delete fx;
+		}
+	}
+}
+
+//------------------------------------------------------
+// CreateEffect
+//	Creates the fx_runner
+//	
+// Input:
+//	template used to build the effect, and the scheduled effect we are based off of
+//
+// Return:
+//	none
+//------------------------------------------------------
+void CFxScheduler::CreateEffect( CPrimitiveTemplate *fx, SScheduledEffect *scheduledFx )
+{
+	int boltInfo;
+
+	// annoying bit....we have to pack the values back into an int before calling playEffect since there isn't the ideal overload we can already use.
+	boltInfo    =  (( scheduledFx->mModelNum & MODEL_AND  ) << MODEL_SHIFT  ); 
+	boltInfo    |= (( scheduledFx->mBoltNum  & BOLT_AND   ) << BOLT_SHIFT   );
+	boltInfo    |= (( scheduledFx->mEntNum   & ENTITY_AND ) << ENTITY_SHIFT );
+		
+	PlayEffect( fx->mPlayFxHandles.GetHandle(), scheduledFx->mOrigin, scheduledFx->mAxis, boltInfo );
+}
+
diff --git a/codemp/client/FxScheduler.h b/codemp/client/FxScheduler.h
new file mode 100644
index 0000000..2f39c40
--- /dev/null
+++ b/codemp/client/FxScheduler.h
@@ -0,0 +1,505 @@
+
+#if !defined(FX_UTIL_H_INC)
+	#include "FxUtil.h"
+#endif
+
+#if !defined(GENERICPARSER2_H_INC)
+	#include "../qcommon/GenericParser2.h"
+#endif
+
+#ifndef FX_SCHEDULER_H_INC
+#define FX_SCHEDULER_H_INC
+
+#pragma warning (push, 3)	//go back down to 3 for the stl include
+#include <vector>
+#include <map>
+#include <list>
+#include <string>
+#pragma warning (pop)
+
+using namespace std;
+
+
+#define FX_FILE_PATH	"effects"
+
+#define FX_MAX_TRACE_DIST		16384	// SOF2 uses a larger scale
+#define FX_MAX_EFFECTS				256		// how many effects the system can store
+#define FX_MAX_2DEFFECTS			64		// how many 2d effects the system can store
+#define FX_MAX_EFFECT_COMPONENTS	24		// how many primitives an effect can hold, this should be plenty
+#define FX_MAX_PRIM_NAME			32
+	
+//-----------------------------------------------
+// These are spawn flags for primitiveTemplates
+//-----------------------------------------------
+
+#define FX_ORG_ON_SPHERE		0x00001	// Pretty dang expensive, calculates a point on a sphere/ellipsoid
+#define FX_AXIS_FROM_SPHERE		0x00002	// Can be used in conjunction with org_on_sphere to cause particles to move out 
+										//	from the center of the sphere
+#define FX_ORG_ON_CYLINDER		0x00004	// calculate point on cylinder/disk
+
+#define FX_ORG2_FROM_TRACE		0x00010
+#define FX_TRACE_IMPACT_FX		0x00020	// if trace impacts, we should play one of the specified impact fx files
+#define FX_ORG2_IS_OFFSET		0x00040	// template specified org2 should be the offset from a trace endpos or 
+										//	passed in org2. You might use this to lend a random flair to the endpos.
+										//	Note: this is done pre-trace, so you may have to specify large numbers for this
+
+#define FX_CHEAP_ORG_CALC		0x00100	// Origin is calculated relative to passed in axis unless this is on.
+#define FX_CHEAP_ORG2_CALC		0x00200	// Origin2 is calculated relative to passed in axis unless this is on.
+#define FX_VEL_IS_ABSOLUTE		0x00400	// Velocity isn't relative to passed in axis with this flag on.
+#define FX_ACCEL_IS_ABSOLUTE	0x00800	// Acceleration isn't relative to passed in axis with this flag on.
+
+#define FX_RAND_ROT_AROUND_FWD	0x01000	// Randomly rotates up and right around forward vector
+#define FX_EVEN_DISTRIBUTION	0x02000	// When you have a delay, it normally picks a random time to play.  When
+										// this flag is on, it generates an even time distribution
+#define FX_RGB_COMPONENT_INTERP	0x04000	// Picks a color on the line defined by RGB min & max, default is to pick color in cube defined by min & max
+
+#define FX_AFFECTED_BY_WIND		0x10000	// this effect primitive needs to query wind
+
+//-----------------------------------------------------------------
+//
+// CMediaHandles
+//
+// Primitive templates might want to use a list of sounds, shaders 
+//	or models to get a bit more variation in their effects.
+//
+//-----------------------------------------------------------------
+class CMediaHandles
+{
+private:
+
+	vector<int>	mMediaList;
+
+public:
+
+	void	AddHandle( int item )	{ mMediaList.push_back( item );	}
+	int		GetHandle()				{ if (mMediaList.size()==0) {return 0;}
+										else {return mMediaList[irand(0,mMediaList.size()-1)];} }
+
+	void operator=(const CMediaHandles &that );
+};
+
+
+//-----------------------------------------------------------------
+//
+// CFxRange
+//
+// Primitive templates typically use this class to define each of
+//	its members.  This is done to make it easier to create effects 
+//	with a desired range of characteristics.
+//
+//-----------------------------------------------------------------
+class CFxRange
+{
+private:
+
+	float	mMin;
+	float	mMax;
+
+public:
+
+	CFxRange(void) 									{ mMin = 0.0f; mMax = 0.0f; }
+
+	inline void		SetRange(float min,float max)	{ mMin = min; mMax = max; }
+
+	inline float	GetMax(void) const				{ return mMax; }
+	inline float	GetMin(void) const				{ return mMin; }
+	inline float	GetVal(float fraction) const	{ if(mMin != mMax) { return mMin + fraction * (mMax - mMin); } else { return mMin; } }
+	inline float	GetVal(void) const	 			{ if(mMin != mMax) { return flrand(mMin,mMax); } else { return mMin; } }
+
+	inline int		GetRoundedVal() const			{if(mMin == mMax){return (int)mMin;}
+														return (int)(flrand(mMin, mMax) + 0.5f);}
+
+	bool operator==(const CFxRange &rhs) const		{ return ((mMin == rhs.mMin) &&	(mMax == rhs.mMax)); }
+};
+
+
+//----------------------------
+// Supported primitive types
+//----------------------------
+
+enum EPrimType
+{
+	None = 0,
+	Particle,		// sprite
+	Line,
+	Tail,			// comet-like tail thing
+	Cylinder,
+	Emitter,		// emits effects as it moves, can also attach a chunk
+	Sound,
+	Decal,			// projected onto architecture
+	OrientedParticle,
+	Electricity,
+	FxRunner,
+	Light,
+	CameraShake,
+	ScreenFlash
+};
+
+
+//-----------------------------------------------------------------
+//
+// CPrimitiveTemplate
+//
+// The primitive template is used to spawn 1 or more fx primitives 
+//	with the range of characteristics defined by the template.
+//
+// As such, I just made this one huge shared class knowing that 
+//	there won't be many of them in memory at once, 	and we won't 
+//	be dynamically creating and deleting them mid-game.  Also,
+//	note that not every primitive type will use all of these fields.
+//
+//-----------------------------------------------------------------
+class CPrimitiveTemplate
+{
+
+public:
+
+	// These kinds of things should not even be allowed to be accessed publicly
+	bool			mCopy;
+	int				mRefCount;		// For a copy of a primitive...when we figure out how many items we want to spawn, 
+									//	we'll store that here and then decrement us for each we actually spawn.  When we 
+									//	hit zero, we are no longer used and so we can just free ourselves
+
+	char			mName[FX_MAX_PRIM_NAME];
+
+	EPrimType		mType;
+
+	CFxRange		mSpawnDelay;
+	CFxRange		mSpawnCount;
+	CFxRange		mLife;
+	int				mCullRange;
+
+	CMediaHandles	mMediaHandles;
+	CMediaHandles	mImpactFxHandles;
+	CMediaHandles	mDeathFxHandles;
+	CMediaHandles	mEmitterFxHandles;
+	CMediaHandles	mPlayFxHandles;
+
+	int				mFlags;			// These need to get passed on to the primitive
+	int				mSpawnFlags;	// These are only used to control spawning, but never get passed to prims.
+
+	EMatImpactEffect	mMatImpactFX;
+
+	vec3_t			mMin;
+	vec3_t			mMax;
+
+	CFxRange		mOrigin1X;
+	CFxRange		mOrigin1Y;
+	CFxRange		mOrigin1Z;
+
+	CFxRange		mOrigin2X;
+	CFxRange		mOrigin2Y;
+	CFxRange		mOrigin2Z;
+
+	CFxRange		mRadius;		// spawn on sphere/ellipse/disk stuff.
+	CFxRange		mHeight;
+	CFxRange		mWindModifier;
+
+	CFxRange		mRotation;
+	CFxRange		mRotationDelta;
+
+	CFxRange		mAngle1;
+	CFxRange		mAngle2;
+	CFxRange		mAngle3;
+
+	CFxRange		mAngle1Delta;
+	CFxRange		mAngle2Delta;
+	CFxRange		mAngle3Delta;
+
+	CFxRange		mVelX;
+	CFxRange		mVelY;
+	CFxRange		mVelZ;
+
+	CFxRange		mAccelX;
+	CFxRange		mAccelY;
+	CFxRange		mAccelZ;
+
+	CFxRange		mGravity;
+
+	CFxRange		mDensity;
+	CFxRange		mVariance;
+
+	CFxRange		mRedStart;
+	CFxRange		mGreenStart;
+	CFxRange		mBlueStart;
+
+	CFxRange		mRedEnd;
+	CFxRange		mGreenEnd;
+	CFxRange		mBlueEnd;
+
+	CFxRange		mRGBParm;
+
+	CFxRange		mAlphaStart;
+	CFxRange		mAlphaEnd;
+	CFxRange		mAlphaParm;
+
+	CFxRange		mSizeStart;
+	CFxRange		mSizeEnd;
+	CFxRange		mSizeParm;
+
+	CFxRange		mSize2Start;
+	CFxRange		mSize2End;
+	CFxRange		mSize2Parm;
+
+	CFxRange		mLengthStart;
+	CFxRange		mLengthEnd;
+	CFxRange		mLengthParm;
+
+	CFxRange		mTexCoordS;
+	CFxRange		mTexCoordT;
+
+	CFxRange		mElasticity;
+
+	int				mSoundRadius;
+	int				mSoundVolume;
+
+	// Lower level parsing utilities
+	bool ParseVector( const char *val, vec3_t min, vec3_t max );
+	bool ParseFloat( const char *val, float *min, float *max );
+	bool ParseGroupFlags( const char *val, int *flags );
+
+	// Base key processing
+	// Note that these all have their own parse functions in case it becomes important to do certain kinds
+	//	of validation specific to that type.
+	bool ParseMin( const char *val );
+	bool ParseMax( const char *val );
+	bool ParseDelay( const char *val );
+	bool ParseCount( const char *val );
+	bool ParseLife( const char *val );
+	bool ParseElasticity( const char *val );
+	bool ParseFlags( const char *val );
+	bool ParseSpawnFlags( const char *val );
+
+	bool ParseOrigin1( const char *val );
+	bool ParseOrigin2( const char *val );
+	bool ParseRadius( const char *val );
+	bool ParseHeight( const char *val );
+	bool ParseWindModifier( const char *val );
+	bool ParseRotation( const char *val );
+	bool ParseRotationDelta( const char *val );
+	bool ParseAngle( const char *val );
+	bool ParseAngleDelta( const char *val );
+	bool ParseVelocity( const char *val );
+	bool ParseAcceleration( const char *val );
+	bool ParseGravity( const char *val );
+	bool ParseDensity( const char *val );
+	bool ParseVariance( const char *val );
+
+	// Group type processing
+	bool ParseRGB( CGPGroup *grp );
+	bool ParseAlpha( CGPGroup *grp );
+	bool ParseSize( CGPGroup *grp );
+	bool ParseSize2( CGPGroup *grp );
+	bool ParseLength( CGPGroup *grp );
+
+	bool ParseModels( CGPValue *grp );
+	bool ParseShaders( CGPValue *grp );
+	bool ParseSounds( CGPValue *grp );
+
+	bool ParseImpactFxStrings( CGPValue *grp );
+	bool ParseDeathFxStrings( CGPValue *grp );
+	bool ParseEmitterFxStrings( CGPValue *grp );
+	bool ParsePlayFxStrings( CGPValue *grp );
+
+	// Group keys
+	bool ParseRGBStart( const char *val );
+	bool ParseRGBEnd( const char *val );
+	bool ParseRGBParm( const char *val );
+	bool ParseRGBFlags( const char *val );
+
+	bool ParseAlphaStart( const char *val );
+	bool ParseAlphaEnd( const char *val );
+	bool ParseAlphaParm( const char *val );
+	bool ParseAlphaFlags( const char *val );
+
+	bool ParseSizeStart( const char *val );
+	bool ParseSizeEnd( const char *val );
+	bool ParseSizeParm( const char *val );
+	bool ParseSizeFlags( const char *val );
+
+	bool ParseSize2Start( const char *val );
+	bool ParseSize2End( const char *val );
+	bool ParseSize2Parm( const char *val );
+	bool ParseSize2Flags( const char *val );
+
+	bool ParseLengthStart( const char *val );
+	bool ParseLengthEnd( const char *val );
+	bool ParseLengthParm( const char *val );
+	bool ParseLengthFlags( const char *val );
+
+	bool ParseMaterialImpact(const char *val);
+
+public:
+
+	CPrimitiveTemplate();
+	~CPrimitiveTemplate()	{};
+
+	bool ParsePrimitive( CGPGroup *grp );
+
+	void operator=(const CPrimitiveTemplate &that);
+};
+
+// forward declaration
+struct SEffectTemplate;
+
+// Effects are built of one or more primitives
+struct SEffectTemplate
+{
+	bool	mInUse;
+	bool	mCopy;
+	char	mEffectName[MAX_QPATH];					// is this extraneous??
+	int		mPrimitiveCount;
+	int		mRepeatDelay;
+	CPrimitiveTemplate	*mPrimitives[FX_MAX_EFFECT_COMPONENTS];	 
+
+	bool operator == (const char * name) const 
+	{
+		return !stricmp( mEffectName, name );
+	}
+	void operator=(const SEffectTemplate &that);
+};
+
+
+
+//-----------------------------------------------------------------
+//
+// CFxScheduler
+//
+// The scheduler not only handles requests to play an effect, it 
+//	tracks the request throughout its life if necessary, creating 
+//	any of the delayed components as needed.
+//
+//-----------------------------------------------------------------
+class CFxScheduler
+{
+private:
+
+	// We hold a scheduled effect here
+	struct SScheduledEffect
+	{
+		CPrimitiveTemplate	*mpTemplate;	// primitive template
+		int		mStartTime;
+		char	mModelNum;		// uset to determine which ghoul2 model we want to bolt this effect to
+		char	mBoltNum;		// used to determine which bolt on the ghoul2 model we should be attaching this effect to
+		short	mEntNum;		// used to determine which entity this ghoul model is attached to.
+		bool	mPortalEffect;	// rww - render this before skyportals, and not in the normal world view.
+		bool	mIsRelative;	// bolt this puppy on keep it updated
+		int		iGhoul2;
+		vec3_t	mOrigin;
+		vec3_t	mAxis[3];
+
+		bool operator <= (const int time) const 
+		{
+			return mStartTime <= time;
+		}
+	};
+
+/* Looped Effects get stored and reschedule at mRepeatRate */
+	#define MAX_LOOPED_FX 32
+	// We hold a looped effect here
+	struct SLoopedEffect
+	{
+		int		mId;			// effect id
+		int		mBoltInfo;		// used to determine which bolt on the ghoul2 model we should be attaching this effect to
+		CGhoul2Info_v mGhoul2;
+		int		mNextTime;		//time to render again
+		int		mLoopStopTime;	//time to die
+		bool	mPortalEffect;	// rww - render this before skyportals, and not in the normal world view.
+		bool	mIsRelative;	// bolt this puppy on keep it updated
+	};
+
+	SLoopedEffect	mLoopedEffectArray[MAX_LOOPED_FX];
+
+	int		ScheduleLoopedEffect( int id, int boltInfo, int iGhoul2, bool isPortal, int iLoopTime, bool isRelative );
+	void	AddLoopedEffects( );
+
+
+	class CScheduled2DEffect
+	{
+	public:
+		CScheduled2DEffect():
+		mScreenX(0),
+		mScreenY(0),
+		mWidth(0),
+		mHeight(0),
+		mShaderHandle(0)
+		{mColor[0]=mColor[1]=mColor[2]=mColor[3]=1.0f;}
+
+	public:
+		float		mScreenX;
+		float		mScreenY;
+		float		mWidth;
+		float		mHeight;
+		vec4_t		mColor;		// bytes A, G, B, R -- see class paletteRGBA_c
+		qhandle_t	mShaderHandle;
+	};
+
+	// this makes looking up the index based on the string name much easier
+	typedef map<string, int>				TEffectID;
+
+	typedef list<SScheduledEffect*>			TScheduledEffect;
+
+	// Effects
+	SEffectTemplate		mEffectTemplates[FX_MAX_EFFECTS];
+	TEffectID			mEffectIDs;								// if you only have the unique effect name, you'll have to use this to get the ID.
+
+	// 2D effects
+	CScheduled2DEffect	m2DEffects[FX_MAX_2DEFFECTS];
+	int					mNextFree2DEffect;
+
+	// List of scheduled effects that will need to be created at the correct time.
+	TScheduledEffect	mFxSchedule;
+
+
+	// Private function prototypes
+	SEffectTemplate *GetNewEffectTemplate( int *id, const char *file );
+
+	void	AddPrimitiveToEffect( SEffectTemplate *fx, CPrimitiveTemplate *prim );
+	int		ParseEffect( const char *file, CGPGroup *base );
+
+	void	CreateEffect( CPrimitiveTemplate *fx, const vec3_t origin, vec3_t axis[3], int lateTime, int fxParm = -1,  int iGhoul2 = 0, int entNum = -1, int modelNum = -1, int boltNum = -1);
+	void	CreateEffect( CPrimitiveTemplate *fx, SScheduledEffect *schedFx );
+
+public:
+
+	CFxScheduler();
+	
+	int		RegisterEffect( const char *file, bool bHasCorrectPath = false );	// handles pre-caching
+
+	// Nasty overloaded madness
+	//rww - maybe this should be done differently.. it's more than a bit confusing.
+	//Remind me when I don't have 50 files checked out.
+	void	PlayEffect( int id, vec3_t org, vec3_t fwd, int vol = -1, int rad = -1, bool isPortal = false );				// builds arbitrary perp. right vector, does a cross product to define up
+	void	PlayEffect( int id, vec3_t origin, vec3_t axis[3], const int boltInfo=-1, int iGhoul2 = 0,
+				int fxParm = -1, int vol = -1, int rad = -1, bool isPortal = false, int iLoopTime = false, bool isRelative = false  );
+	void	PlayEffect( const char *file, vec3_t org, int vol = -1, int rad = -1 );					// uses a default up axis
+	void	PlayEffect( const char *file, vec3_t org, vec3_t fwd, int vol = -1, int rad = -1 );		// builds arbitrary perp. right vector, does a cross product to define up
+	void	PlayEffect( const char *file, vec3_t origin, 
+				vec3_t axis[3], const int boltInfo = -1, int iGhoul2 = 0, int fxParm = -1, int vol = -1, int rad = -1, int iLoopTime = false, bool isRelative = false );
+
+	void	StopEffect( const char *file, const int boltInfo, bool isPortal = false );	//find a scheduled Looping effect with these parms and kill it
+	void	AddScheduledEffects( bool portal );								// call once per CGame frame
+
+	// kef -- called for a 2D effect instead of addRefToScene
+	bool	Add2DEffect(float x, float y, float w, float h, vec4_t color, qhandle_t shaderHandle);
+	// kef -- called once per cgame frame AFTER cgi.RenderScene
+	void	Draw2DEffects(float screenXScale, float screenYScale);
+
+	int		NumScheduledFx()	{ return mFxSchedule.size();	}
+	void	Clean(bool bRemoveTemplates = true, int idToPreserve = 0);	// clean out the system
+
+	// FX Override functions
+	SEffectTemplate		*GetEffectCopy( int fxHandle, int *newHandle );
+	SEffectTemplate		*GetEffectCopy( const char *file, int *newHandle );
+
+	CPrimitiveTemplate	*GetPrimitiveCopy( SEffectTemplate *effectCopy, const char *componentName );
+
+	void	MaterialImpact(trace_t *tr, CEffect *effect);
+};
+
+//-------------------
+// The one and only
+//-------------------
+extern CFxScheduler theFxScheduler;
+
+#endif // FX_SCHEDULER_H_INC
diff --git a/codemp/client/FxSystem.cpp b/codemp/client/FxSystem.cpp
new file mode 100644
index 0000000..9bb5a51
--- /dev/null
+++ b/codemp/client/FxSystem.cpp
@@ -0,0 +1,130 @@
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+// this include must remain at the top of every CPP file
+#include "client.h"
+
+#if !defined(FX_SCHEDULER_H_INC)
+	#include "FxScheduler.h"
+#endif
+
+cvar_t	*fx_debug;
+#ifdef _SOF2DEV_
+cvar_t	*fx_freeze;
+#endif
+cvar_t	*fx_countScale;
+cvar_t	*fx_nearCull;
+
+#define DEFAULT_EXPLOSION_RADIUS	512
+
+// Stuff for the FxHelper
+//------------------------------------------------------
+SFxHelper::SFxHelper(void) :
+	mTime(0),
+	mOldTime(0),
+	mFrameTime(0),
+	mTimeFrozen(false),
+	refdef(0)
+{
+}
+ 
+void SFxHelper::ReInit(refdef_t* pRefdef)
+{
+	mTime = 0;
+	mOldTime = 0;
+	mFrameTime = 0;
+	mTimeFrozen = false;
+	refdef = pRefdef;
+}
+
+//------------------------------------------------------
+void SFxHelper::Print( const char *msg, ... )
+{
+	va_list		argptr;
+	char		text[1024];
+
+	va_start( argptr, msg );
+	vsprintf( text, msg, argptr );
+	va_end( argptr );
+
+	Com_DPrintf( text );
+}
+
+//------------------------------------------------------
+void SFxHelper::AdjustTime( int frametime )
+{
+#ifdef _SOF2DEV_
+	if ( fx_freeze->integer || ( frametime <= 0 ))
+#else
+	if ( frametime <= 0 )
+#endif
+	{
+		// Allow no time progression when we are paused.
+		mFrameTime = 0;
+		mRealTime = 0.0f;
+	}
+	else
+	{
+		mOldTime = mTime;
+		mTime = frametime;
+		mFrameTime = mTime - mOldTime;
+		
+		mRealTime = mFrameTime * 0.001f;
+
+
+/*		mFrameTime = frametime;
+		mTime += mFrameTime;
+		mRealTime = mFrameTime * 0.001f;*/
+
+//		mHalfRealTimeSq = mRealTime * mRealTime * 0.5f;
+	}
+}
+
+//------------------------------------------------------
+void SFxHelper::CameraShake( vec3_t origin, float intensity, int radius, int time )
+{
+	TCGCameraShake	*data = (TCGCameraShake *)cl.mSharedMemory;
+
+	VectorCopy(origin, data->mOrigin);
+	data->mIntensity = intensity;
+	data->mRadius = radius;
+	data->mTime = time;
+
+//	VM_Call( cgvm, CG_FX_CAMERASHAKE ); 
+	//FIXME
+}
+
+//------------------------------------------------------
+qboolean SFxHelper::GetOriginAxisFromBolt(CGhoul2Info_v *pGhoul2, int mEntNum, int modelNum, int boltNum, vec3_t /*out*/origin, vec3_t /*out*/axis[3])
+{
+	qboolean doesBoltExist;
+	mdxaBone_t 		boltMatrix;
+	TCGGetBoltData	*data = (TCGGetBoltData*)cl.mSharedMemory;
+	data->mEntityNum = mEntNum;
+	VM_Call( cgvm, CG_GET_LERP_DATA );//this func will zero out pitch and roll for players, and ridable vehicles
+
+	//Fixme: optimize these VM calls away by storing 
+
+	// go away and get me the bolt position for this frame please
+	doesBoltExist = G2API_GetBoltMatrix(*pGhoul2, modelNum, boltNum, 
+		&boltMatrix, data->mAngles, data->mOrigin, theFxHelper.mOldTime, 0, data->mScale);
+
+	if (doesBoltExist)
+	{	// set up the axis and origin we need for the actual effect spawning
+	   	origin[0] = boltMatrix.matrix[0][3];
+		origin[1] = boltMatrix.matrix[1][3];
+		origin[2] = boltMatrix.matrix[2][3];
+
+		axis[1][0] = boltMatrix.matrix[0][0];
+		axis[1][1] = boltMatrix.matrix[1][0];
+		axis[1][2] = boltMatrix.matrix[2][0];
+
+		axis[0][0] = boltMatrix.matrix[0][1];
+		axis[0][1] = boltMatrix.matrix[1][1];
+		axis[0][2] = boltMatrix.matrix[2][1];
+
+		axis[2][0] = boltMatrix.matrix[0][2];
+		axis[2][1] = boltMatrix.matrix[1][2];
+		axis[2][2] = boltMatrix.matrix[2][2];
+	}
+	return doesBoltExist;
+}
\ No newline at end of file
diff --git a/codemp/client/FxSystem.h b/codemp/client/FxSystem.h
new file mode 100644
index 0000000..34642a8
--- /dev/null
+++ b/codemp/client/FxSystem.h
@@ -0,0 +1,223 @@
+
+#ifndef FX_SYSTEM_H_INC
+#define FX_SYSTEM_H_INC
+
+#if !defined(G2_H_INC)
+	#include "../ghoul2/G2.h"
+	#include "../ghoul2/G2_local.h"
+#endif
+
+extern cvar_t	*fx_debug;
+
+#ifdef _SOF2DEV_
+extern cvar_t	*fx_freeze;
+#endif
+
+extern cvar_t	*fx_countScale;
+extern cvar_t	*fx_nearCull;
+
+inline void Vector2Clear(vec2_t a)
+{
+	a[0] = 0.0f;
+	a[1] = 0.0f;
+}
+
+inline void Vector2Set(vec2_t a,float b,float c)
+{
+	a[0] = b;
+	a[1] = c;
+}
+
+inline void Vector2Copy(vec2_t src,vec2_t dst)
+{
+	dst[0] = src[0];
+	dst[1] = src[1];
+}
+
+inline void Vector2MA(vec2_t src, float m, vec2_t v, vec2_t dst)
+{
+	dst[0] = src[0] + (m*v[0]);
+	dst[1] = src[1] + (m*v[1]);
+}
+
+inline void Vector2Scale(vec2_t src,float b,vec2_t dst)
+{
+	dst[0] = src[0] * b;
+	dst[1] = src[1] * b;
+}
+
+class SFxHelper
+{
+public:
+	int		mTime;
+	int		mOldTime;
+	int		mFrameTime;
+	bool	mTimeFrozen;
+	float	mRealTime;
+	refdef_t*	refdef;
+#ifdef _DEBUG
+	int		mMainRefs;
+	int		mMiniRefs;
+#endif
+
+public:
+	SFxHelper(void);
+
+	inline	int	GetTime(void) { return mTime; }
+	inline	int	GetFrameTime(void) { return mFrameTime; }
+
+	void	ReInit(refdef_t* pRefdef);
+	void	AdjustTime( int time );
+
+	// These functions are wrapped and used by the fx system in case it makes things a bit more portable
+	void	Print( const char *msg, ... );
+
+	// File handling
+	inline	int		OpenFile( const char *path, fileHandle_t *fh, int mode )
+	{
+		return FS_FOpenFileByMode( path, fh, FS_READ );
+	}
+	inline	int		ReadFile( void *data, int len, fileHandle_t fh )
+	{
+		FS_Read2( data, len, fh );
+		return 1;
+	}
+	inline	void	CloseFile( fileHandle_t fh )
+	{
+		FS_FCloseFile( fh );
+	}
+
+	// Sound
+	inline	void	PlaySound( vec3_t origin, int entityNum, int entchannel, sfxHandle_t sfxHandle, int volume, int radius )
+	{
+		//S_StartSound( origin, ENTITYNUM_NONE, CHAN_AUTO, sfxHandle, volume, radius );
+		S_StartSound( origin, ENTITYNUM_NONE, CHAN_AUTO, sfxHandle );
+	}
+	inline	void	PlayLocalSound(sfxHandle_t sfxHandle, int entchannel)
+	{
+		//S_StartSound( origin, ENTITYNUM_NONE, CHAN_AUTO, sfxHandle, volume, radius );
+		S_StartLocalSound(sfxHandle, entchannel);
+	}
+	inline	int		RegisterSound( const char *sound )
+	{
+		return S_RegisterSound( sound );
+	}
+
+	// Physics/collision
+	inline	void	Trace( trace_t &tr, vec3_t start, vec3_t min, vec3_t max, vec3_t end, int skipEntNum, int flags )
+	{
+		TCGTrace		*td = (TCGTrace *)cl.mSharedMemory;
+
+		if ( !min )
+		{
+			min = vec3_origin;
+		}
+
+		if ( !max )
+		{
+			max = vec3_origin;
+		}
+
+		memset(td, sizeof(*td), 0);
+		VectorCopy(start, td->mStart);
+		VectorCopy(min, td->mMins);
+		VectorCopy(max, td->mMaxs);
+		VectorCopy(end, td->mEnd);
+		td->mSkipNumber = skipEntNum;
+		td->mMask = flags;
+
+		VM_Call( cgvm, CG_TRACE );
+
+		tr = td->mResult;
+	}
+
+	inline	void	G2Trace( trace_t &tr, vec3_t start, vec3_t min, vec3_t max, vec3_t end, int skipEntNum, int flags )
+	{
+		TCGTrace		*td = (TCGTrace *)cl.mSharedMemory;
+
+		if ( !min )
+		{
+			min = vec3_origin;
+		}
+
+		if ( !max )
+		{
+			max = vec3_origin;
+		}
+
+		memset(td, sizeof(*td), 0);
+		VectorCopy(start, td->mStart);
+		VectorCopy(min, td->mMins);
+		VectorCopy(max, td->mMaxs);
+		VectorCopy(end, td->mEnd);
+		td->mSkipNumber = skipEntNum;
+		td->mMask = flags;
+
+		VM_Call( cgvm, CG_G2TRACE );
+
+		tr = td->mResult;
+	}
+
+	inline	void	AddGhoul2Decal(int shader, vec3_t start, vec3_t dir, float size)
+	{
+		TCGG2Mark		*td = (TCGG2Mark *)cl.mSharedMemory;
+
+		td->size = size;
+		td->shader = shader;
+		VectorCopy(start, td->start);
+		VectorCopy(dir, td->dir);
+
+		VM_Call(cgvm, CG_G2MARK);
+	}
+
+	inline	void	AddFxToScene( refEntity_t *ent )
+	{
+#ifdef _DEBUG
+		mMainRefs++;
+
+		assert(!ent || ent->renderfx >= 0);
+#endif
+		re.AddRefEntityToScene( ent );
+	}
+	inline	void	AddFxToScene( miniRefEntity_t *ent )
+	{
+#ifdef _DEBUG
+		mMiniRefs++;
+
+		assert(!ent || ent->renderfx >= 0);
+#endif
+		re.AddMiniRefEntityToScene( ent );
+	}
+#ifndef VV_LIGHTING
+	inline	void	AddLightToScene( vec3_t org, float radius, float red, float green, float blue )
+	{
+		re.AddLightToScene(	org, radius, red, green, blue );
+	}
+#endif
+
+	inline	int		RegisterShader( const char *shader )
+	{
+		return re.RegisterShader( shader );
+	}
+	inline	int		RegisterModel( const char *model )
+	{
+		return re.RegisterModel( model );
+	}
+
+	inline	void	AddPolyToScene( int shader, int count, polyVert_t *verts )
+	{
+		re.AddPolyToScene( shader, count, verts, 1 );
+	}
+
+	inline void AddDecalToScene ( qhandle_t shader, const vec3_t origin, const vec3_t dir, float orientation, float r, float g, float b, float a, qboolean alphaFade, float radius, qboolean temporary )
+	{
+		re.AddDecalToScene ( shader, origin, dir, orientation, r, g, b, a, alphaFade, radius, temporary );
+	}
+
+	void	CameraShake( vec3_t origin, float intensity, int radius, int time );
+	qboolean SFxHelper::GetOriginAxisFromBolt(CGhoul2Info_v *pGhoul2, int mEntNum, int modelNum, int boltNum, vec3_t /*out*/origin, vec3_t /*out*/axis[3]);
+};
+
+extern SFxHelper	theFxHelper;
+
+#endif // FX_SYSTEM_H_INC
diff --git a/codemp/client/FxTemplate.cpp b/codemp/client/FxTemplate.cpp
new file mode 100644
index 0000000..f8ba54e
--- /dev/null
+++ b/codemp/client/FxTemplate.cpp
@@ -0,0 +1,2386 @@
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+// this include must remain at the top of every CPP file
+#include "client.h"
+
+#if !defined(FX_SCHEDULER_H_INC)
+	#include "FxScheduler.h"
+#endif
+
+//------------------------------------------------------
+// CPrimitiveTemplate
+//	Set up our minimal default values
+//
+// Input:
+//	none
+//
+// Return:
+//	none
+//------------------------------------------------------
+CPrimitiveTemplate::CPrimitiveTemplate()
+{ 
+	// We never start out as a copy or with a name
+	mCopy = false;
+	mName[0] = 0;
+	mCullRange = 0; // no distance culling
+
+	mFlags = mSpawnFlags = 0;
+	mElasticity.SetRange(0.1f, 0.1f);
+
+	mSoundVolume = -1;
+	mSoundRadius = -1;
+
+	mMatImpactFX = MATIMPACTFX_NONE;
+
+	mLife.SetRange( 50.0f, 50.0f );
+	mSpawnCount.SetRange( 1.0f, 1.0f );
+	mRadius.SetRange( 10.0f, 10.0f );
+	mHeight.SetRange( 10.0f, 10.0f );
+	mWindModifier.SetRange( 1.0f, 1.0f );
+
+	VectorSet( mMin, 0.0f, 0.0f, 0.0f );
+	VectorSet( mMax, 0.0f, 0.0f, 0.0f );
+
+	mRedStart.SetRange( 1.0f, 1.0f );
+	mGreenStart.SetRange( 1.0f, 1.0f );
+	mBlueStart.SetRange( 1.0f, 1.0f );
+
+	mRedEnd.SetRange( 1.0f, 1.0f );
+	mGreenEnd.SetRange( 1.0f, 1.0f );
+	mBlueEnd.SetRange( 1.0f, 1.0f );
+
+	mAlphaStart.SetRange( 1.0f, 1.0f );
+	mAlphaEnd.SetRange( 1.0f, 1.0f );
+
+	mSizeStart.SetRange( 1.0f, 1.0f );
+	mSizeEnd.SetRange( 1.0f, 1.0f );
+
+	mSize2Start.SetRange( 1.0f, 1.0f );
+	mSize2End.SetRange( 1.0f, 1.0f );
+
+	mLengthStart.SetRange( 1.0f, 1.0f );
+	mLengthEnd.SetRange( 1.0f, 1.0f );
+
+	mTexCoordS.SetRange( 1.0f, 1.0f );
+	mTexCoordT.SetRange( 1.0f, 1.0f );
+
+	mVariance.SetRange( 1.0f, 1.0f );
+	mDensity.SetRange( 10.0f, 10.0f );// default this high so it doesn't do bad things
+}
+
+//-----------------------------------------------------------
+void CPrimitiveTemplate::operator=(const CPrimitiveTemplate &that)
+{
+	// I'm assuming that doing a memcpy wouldn't work here
+	// If you are looking at this and know a better way to do this, please tell me.
+	strcpy( mName, that.mName );
+
+	mType				= that.mType;
+
+	mSpawnDelay			= that.mSpawnDelay;
+	mSpawnCount			= that.mSpawnCount;
+	mLife				= that.mLife;
+	mCullRange			= that.mCullRange;
+
+	mMediaHandles		= that.mMediaHandles;
+	mImpactFxHandles	= that.mImpactFxHandles;
+	mDeathFxHandles		= that.mDeathFxHandles;
+	mEmitterFxHandles	= that.mEmitterFxHandles;
+	mPlayFxHandles		= that.mPlayFxHandles;
+
+	mFlags				= that.mFlags;
+	mSpawnFlags			= that.mSpawnFlags;
+
+	VectorCopy( that.mMin, mMin );
+	VectorCopy( that.mMax, mMax );
+
+	mOrigin1X			= that.mOrigin1X;
+	mOrigin1Y			= that.mOrigin1Y;
+	mOrigin1Z			= that.mOrigin1Z;
+
+	mOrigin2X			= that.mOrigin2X;
+	mOrigin2Y			= that.mOrigin2Y;
+	mOrigin2Z			= that.mOrigin2Z;
+
+	mRadius				= that.mRadius;
+	mHeight				= that.mHeight;
+	mWindModifier		= that.mWindModifier;
+
+	mRotation			= that.mRotation;
+	mRotationDelta		= that.mRotationDelta;
+
+	mAngle1				= that.mAngle1;
+	mAngle2				= that.mAngle2;
+	mAngle3				= that.mAngle3;
+
+	mAngle1Delta		= that.mAngle1Delta;
+	mAngle2Delta		= that.mAngle2Delta;
+	mAngle3Delta		= that.mAngle3Delta;
+
+	mVelX				= that.mVelX;
+	mVelY				= that.mVelY;
+	mVelZ				= that.mVelZ;
+
+	mAccelX				= that.mAccelX;
+	mAccelY				= that.mAccelY;
+	mAccelZ				= that.mAccelZ;
+
+	mGravity			= that.mGravity;
+
+	mDensity			= that.mDensity;
+	mVariance			= that.mVariance;
+
+	mRedStart			= that.mRedStart;
+	mGreenStart			= that.mGreenStart;
+	mBlueStart			= that.mBlueStart;
+
+	mRedEnd				= that.mRedEnd;
+	mGreenEnd			= that.mGreenEnd;
+	mBlueEnd			= that.mBlueEnd;
+
+	mRGBParm			= that.mRGBParm;
+
+	mAlphaStart			= that.mAlphaStart;
+	mAlphaEnd			= that.mAlphaEnd;
+	mAlphaParm			= that.mAlphaParm;
+
+	mSizeStart			= that.mSizeStart;
+	mSizeEnd			= that.mSizeEnd;
+	mSizeParm			= that.mSizeParm;
+
+	mSize2Start			= that.mSize2Start;
+	mSize2End			= that.mSize2End;
+	mSize2Parm			= that.mSize2Parm;
+
+	mLengthStart		= that.mLengthStart;
+	mLengthEnd			= that.mLengthEnd;
+	mLengthParm			= that.mLengthParm;
+
+	mTexCoordS			= that.mTexCoordS;
+	mTexCoordT			= that.mTexCoordT;
+
+	mElasticity			= that.mElasticity;
+
+	mSoundRadius		= that.mSoundRadius;
+	mSoundVolume		= that.mSoundVolume;
+}
+
+//------------------------------------------------------
+// ParseFloat
+//	Removes up to two values from a passed in string and
+//	sets these values into the passed in min and max 
+//	fields.  if no max is present, min is copied into it.
+//
+// input:
+//	string that contains up to two float values
+//  min & max are used to return the parse values
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseFloat( const char *val, float *min, float *max )
+{
+	// We don't allow passing in a null for either of the fields
+	if ( min == 0 || max == 0 )
+	{ // failue
+		return false;
+	}
+
+	// attempt to read out the values
+	int v = sscanf( val, "%f %f", min, max );
+
+	if ( v == 0 )
+	{ // nothing was there, failure
+		return false;
+	}
+	else if ( v == 1 )
+	{ // only one field entered, this is ok, but we should copy min into max
+		*max = *min;
+	}
+
+	return true;
+}
+
+
+//------------------------------------------------------
+// ParseVector
+//	Removes up to six values from a passed in string and
+//	sets these values into the passed in min and max vector
+//	fields. if no max is present, min is copied into it.
+//
+// input:
+//	string that contains up to six float values
+//  min & max are used to return the parse values
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseVector( const char *val, vec3_t min, vec3_t max )
+{
+	// we don't allow passing in a null
+	if ( min == 0 || max == 0 )
+	{
+		return false;
+	}
+
+	// attempt to read out our values
+	int v = sscanf( val, "%f %f %f   %f %f %f", &min[0], &min[1], &min[2], &max[0], &max[1], &max[2] );
+
+	// Check for completeness
+	if ( v < 3 || v == 4 || v == 5 )
+	{ // not a complete value
+		return false;
+	}
+	else if ( v == 3 )
+	{ // only a min was entered, so copy the result into max
+		VectorCopy( min, max );
+	}
+
+	return true;
+}
+
+//------------------------------------------------------
+// ParseGroupFlags
+//	Group flags are generic in nature, so we can easily
+//	use a generic function to parse them in, then the
+//	caller can shift them into the appropriate range.
+//
+// input:
+//	string that contains the flag strings
+//  *flags returns the set bit flags
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseGroupFlags( const char *val, int *flags )
+{
+	// Must pass in a non-null pointer
+	if ( flags == 0 )
+	{
+		return false;
+	}
+
+	char	flag[][32] = {"\0","\0","\0","0"};
+	bool	ok = true;
+	
+	// For a sub group, really you probably only have one or two flags set
+	int v = sscanf( val, "%s %s %s %s", flag[0], flag[1], flag[2], flag[3] );
+
+	// Clear out the flags field, then convert the flag string to an actual value ( use generic flags )
+	*flags = 0;
+
+	for ( int i = 0; i < 4; i++ )
+	{
+		if ( i + 1 > v )
+		{
+			return true;
+		}
+
+		if ( !stricmp( flag[i], "linear" ))
+		{
+			*flags |= FX_LINEAR;
+		}
+		else if ( !stricmp( flag[i], "nonlinear" ))
+		{
+			*flags |= FX_NONLINEAR;
+		}
+		else if ( !stricmp( flag[i], "wave" ))
+		{
+			*flags |= FX_WAVE;
+		}
+		else if ( !stricmp( flag[i], "random" ))
+		{
+			*flags |= FX_RAND;
+		}
+		else if ( !stricmp( flag[i], "clamp" ))
+		{
+			*flags |= FX_CLAMP;
+		}
+		else
+		{ // we have badness going on, but continue on in case there are any valid fields in here
+			ok = false;
+		}
+	}
+
+	return ok;
+}
+
+//------------------------------------------------------
+// ParseMin
+//	Reads in a min bounding box field in vector format
+//
+// input:
+//	string that contains three float values
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseMin( const char *val )
+{
+	vec3_t min;
+
+	if ( ParseVector( val, min, min ) == true )
+	{
+		VectorCopy( min, mMin );
+
+		// We assume that if a min is being set that we are using physics and a bounding box
+		mFlags |= (FX_USE_BBOX | FX_APPLY_PHYSICS);
+		return true;
+	}
+
+	return false;
+}
+
+//------------------------------------------------------
+// ParseMax
+//	Reads in a max bounding box field in vector format
+//
+// input:
+//	string that contains three float values
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseMax( const char *val )
+{
+	vec3_t max;
+
+	if ( ParseVector( val, max, max ) == true )
+	{
+		VectorCopy( max, mMax );
+
+		// We assume that if a max is being set that we are using physics and a bounding box
+		mFlags |= (FX_USE_BBOX | FX_APPLY_PHYSICS);
+		return true;
+	}
+
+	return false;
+}
+
+//------------------------------------------------------
+// ParseLife
+//	Reads in a ranged life value
+//
+// input:
+//	string that contains a float range ( two vals )
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseLife( const char *val )
+{
+	float min, max;
+
+	if ( ParseFloat( val, &min, &max ) == true )
+	{
+		mLife.SetRange( min, max );
+		return true;
+	}
+
+	return false;
+}
+
+//------------------------------------------------------
+// ParseDelay
+//	Reads in a ranged delay value
+//
+// input:
+//	string that contains a float range ( two vals )
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseDelay( const char *val )
+{
+	float min, max;
+
+	if ( ParseFloat( val, &min, &max ) == true )
+	{
+		mSpawnDelay.SetRange( min, max );
+		return true;
+	}
+
+	return false;
+}
+
+//------------------------------------------------------
+// ParseCount
+//	Reads in a ranged count value
+//
+// input:
+//	string that contains a float range ( two vals )
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseCount( const char *val )
+{
+	float min, max;
+
+	if ( ParseFloat( val, &min, &max ) == true )
+	{
+		mSpawnCount.SetRange( min, max );
+		return true;
+	}
+
+	return false;
+}
+
+//------------------------------------------------------
+// ParseElasticity
+//	Reads in a ranged elasticity value
+//
+// input:
+//	string that contains a float range ( two vals )
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseElasticity( const char *val )
+{
+	float min, max;
+
+	if ( ParseFloat( val, &min, &max ) == true )
+	{
+		mElasticity.SetRange( min, max );
+
+		// We assume that if elasticity is set that we are using physics, but don't assume we are
+		//	using a bounding box unless a min/max are explicitly set
+		mFlags |= FX_APPLY_PHYSICS;
+		return true;
+	}
+
+	return false;
+}
+
+//------------------------------------------------------
+// ParseOrigin1
+//	Reads in an origin field in vector format
+//
+// input:
+//	string that contains three float values
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseOrigin1( const char *val )
+{
+	vec3_t min, max;
+
+	if ( ParseVector( val, min, max ) == true )
+	{
+		mOrigin1X.SetRange( min[0], max[0] );
+		mOrigin1Y.SetRange( min[1], max[1] );
+		mOrigin1Z.SetRange( min[2], max[2] );
+		return true;
+	}
+
+	return false;
+}
+
+//------------------------------------------------------
+// ParseOrigin2
+//	Reads in an origin field in vector format
+//
+// input:
+//	string that contains three float values
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseOrigin2( const char *val )
+{
+	vec3_t min, max;
+
+	if ( ParseVector( val, min, max ) == true )
+	{
+		mOrigin2X.SetRange( min[0], max[0] );
+		mOrigin2Y.SetRange( min[1], max[1] );
+		mOrigin2Z.SetRange( min[2], max[2] );
+		return true;
+	}
+
+	return false;
+}
+
+//------------------------------------------------------
+// ParseRadius
+//	Reads in a ranged radius value
+//
+// input:
+//	string that contains one or two floats
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseRadius( const char *val )
+{
+	float min, max;
+
+	if ( ParseFloat( val, &min, &max ) == true )
+	{
+		mRadius.SetRange( min, max );
+		return true;
+	}
+
+	return false;
+}
+
+//------------------------------------------------------
+// ParseHeight
+//	Reads in a ranged height value
+//
+// input:
+//	string that contains one or two floats
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseHeight( const char *val )
+{
+	float min, max;
+
+	if ( ParseFloat( val, &min, &max ) == true )
+	{
+		mHeight.SetRange( min, max );
+		return true;
+	}
+
+	return false;
+}
+
+//------------------------------------------------------
+// ParseWindModifier
+//	Reads in a ranged wind modifier value
+//
+// input:
+//	string that contains one or two floats
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseWindModifier( const char *val )
+{
+	float min, max;
+
+	if ( ParseFloat( val, &min, &max ) == true )
+	{
+		mWindModifier.SetRange( min, max );
+		return true;
+	}
+
+	return false;
+}
+
+//------------------------------------------------------
+// ParseRotation
+//	Reads in a ranged rotation value
+//
+// input:
+//	string that contains one or two floats
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseRotation( const char *val )
+{
+	float min, max;
+
+	if ( ParseFloat( val, &min, &max ) == qtrue )
+	{
+		mRotation.SetRange( min, max );
+		return true;
+	}
+
+	return false;
+}
+
+//------------------------------------------------------
+// ParseRotationDelta
+//	Reads in a ranged rotationDelta value
+//
+// input:
+//	string that contains one or two floats
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseRotationDelta( const char *val )
+{
+	float min, max;
+
+	if ( ParseFloat( val, &min, &max ) == qtrue )
+	{
+		mRotationDelta.SetRange( min, max );
+		return true;
+	}
+
+	return false;
+}
+
+//------------------------------------------------------
+// ParseAngle
+//	Reads in a ranged angle field in vector format
+//
+// input:
+//	string that contains one or two vectors
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseAngle( const char *val )
+{
+	vec3_t min, max;
+
+	if ( ParseVector( val, min, max ) == true )
+	{
+		mAngle1.SetRange( min[0], max[0] );
+		mAngle2.SetRange( min[1], max[1] );
+		mAngle3.SetRange( min[2], max[2] );
+		return true;
+	}
+
+	return false;
+}
+
+//------------------------------------------------------
+// ParseAngleDelta
+//	Reads in a ranged angleDelta field in vector format
+//
+// input:
+//	string that contains one or two vectors
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseAngleDelta( const char *val )
+{
+	vec3_t min, max;
+
+	if ( ParseVector( val, min, max ) == true )
+	{
+		mAngle1Delta.SetRange( min[0], max[0] );
+		mAngle2Delta.SetRange( min[1], max[1] );
+		mAngle3Delta.SetRange( min[2], max[2] );
+		return true;
+	}
+
+	return false;
+}
+
+//------------------------------------------------------
+// ParseVelocity
+//	Reads in a ranged velocity field in vector format
+//
+// input:
+//	string that contains one or two vectors
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseVelocity( const char *val )
+{
+	vec3_t min, max;
+
+	if ( ParseVector( val, min, max ) == true )
+	{
+		mVelX.SetRange( min[0], max[0] );
+		mVelY.SetRange( min[1], max[1] );
+		mVelZ.SetRange( min[2], max[2] );
+		return true;
+	}
+
+	return false;
+}
+
+//------------------------------------------------------
+// ParseFlags
+//	These are flags that are not specific to a group, 
+//	rather, they are specific to the whole primitive.
+//
+// input:
+//	string that contains the flag strings
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseFlags( const char *val )
+{
+	char	flag[][32] = {"\0","\0","\0","\0","\0","\0","\0"};
+	bool	ok = true;
+	
+	// For a primitive, really you probably only have two or less flags set
+	int v = sscanf( val, "%s %s %s %s %s %s %s", flag[0], flag[1], flag[2], flag[3], flag[4], flag[5], flag[6] );
+
+	for ( int i = 0; i < 7; i++ )
+	{
+		if ( i + 1 > v )
+		{
+			return true;
+		}
+
+		if ( !stricmp( flag[i], "useModel" ))
+		{
+			mFlags |= FX_ATTACHED_MODEL;
+		}
+		else if ( !stricmp( flag[i], "useBBox" ))
+		{
+			mFlags |= FX_USE_BBOX;
+		}
+		else if ( !stricmp( flag[i], "usePhysics" ))
+		{
+			mFlags |= FX_APPLY_PHYSICS;
+		}
+		else if ( !stricmp( flag[i], "expensivePhysics" ))
+		{
+			mFlags |= FX_EXPENSIVE_PHYSICS;
+		}
+		//rww - begin g2 stuff
+		else if ( !stricmp( flag[i], "ghoul2Collision" ))
+		{
+			mFlags |= (FX_GHOUL2_TRACE|FX_APPLY_PHYSICS|FX_EXPENSIVE_PHYSICS);
+		}
+		else if ( !stricmp( flag[i], "ghoul2Decals" ))
+		{
+			mFlags |= FX_GHOUL2_DECALS;
+		}
+		//rww - end
+		else if ( !stricmp( flag[i], "impactKills" ))
+		{
+			mFlags |= FX_KILL_ON_IMPACT;
+		}
+		else if ( !stricmp( flag[i], "impactFx" ))
+		{
+			mFlags |= FX_IMPACT_RUNS_FX;
+		}
+		else if ( !stricmp( flag[i], "deathFx" ))
+		{
+			mFlags |= FX_DEATH_RUNS_FX;
+		}
+		else if ( !stricmp( flag[i], "useAlpha" ))
+		{
+			mFlags |= FX_USE_ALPHA;
+		}
+		else if ( !stricmp( flag[i], "emitFx" ))
+		{
+			mFlags |= FX_EMIT_FX;
+		}
+		else if ( !stricmp( flag[i], "depthHack" ))
+		{
+			mFlags |= FX_DEPTH_HACK;
+		}
+		else if ( !stricmp( flag[i], "relative" ))
+		{
+			mFlags |= FX_RELATIVE;
+		}
+		else if ( !stricmp( flag[i], "setShaderTime" ))
+		{
+			mFlags |= FX_SET_SHADER_TIME;
+		}
+		else if ( !stricmp( flag[i], "paperPhysics" ))
+		{
+			mFlags |= FX_PAPER_PHYSICS; //warning! shared flag.  You use this with a cylinder and you can expect evilness to ensue
+		}
+		else if ( !stricmp( flag[i], "localizedFlash" ))
+		{
+			mFlags |= FX_LOCALIZED_FLASH; //warning! shared flag.  You use this with a cylinder and you can expect evilness to ensue
+		}
+		else if ( !stricmp( flag[i], "playerView" ))
+		{
+			mFlags |= FX_PLAYER_VIEW; //warning! shared flag.  You use this with a cylinder and you can expect evilness to ensue
+		}
+		else
+		{ // we have badness going on, but continue on in case there are any valid fields in here
+			ok = false;
+		}
+	}
+
+	return ok;
+}
+
+//------------------------------------------------------
+// ParseSpawnFlags
+//	These kinds of flags control how things spawn.  They 
+//	never get passed on to a primitive.
+//
+// input:
+//	string that contains the flag strings
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseSpawnFlags( const char *val )
+{
+	char	flag[][32] = {"\0","\0","\0","\0","\0","\0","\0"};
+	bool	ok = true;
+	
+	// For a primitive, really you probably only have two or less flags set
+	int v = sscanf( val, "%s %s %s %s %s %s %s", flag[0], flag[1], flag[2], flag[3], flag[4], flag[5], flag[6] );
+
+	for ( int i = 0; i < 7; i++ )
+	{
+		if ( i + 1 > v )
+		{
+			return true;
+		}
+
+		if ( !stricmp( flag[i], "org2fromTrace" ))
+		{
+			mSpawnFlags |= FX_ORG2_FROM_TRACE;
+		}
+		else if ( !stricmp( flag[i], "traceImpactFx" ))
+		{
+			mSpawnFlags |= FX_TRACE_IMPACT_FX;
+		}
+		else if ( !stricmp( flag[i], "org2isOffset" ))
+		{
+			mSpawnFlags |= FX_ORG2_IS_OFFSET;
+		}
+		else if ( !stricmp( flag[i], "cheapOrgCalc" ))
+		{
+			mSpawnFlags |= FX_CHEAP_ORG_CALC;
+		}
+		else if ( !stricmp( flag[i], "cheapOrg2Calc" ))
+		{
+			mSpawnFlags |= FX_CHEAP_ORG2_CALC;
+		}
+		else if ( !stricmp( flag[i], "absoluteVel" ))
+		{
+			mSpawnFlags |= FX_VEL_IS_ABSOLUTE;
+		}
+		else if ( !stricmp( flag[i], "absoluteAccel" ))
+		{
+			mSpawnFlags |= FX_ACCEL_IS_ABSOLUTE;
+		}
+		else if ( !stricmp( flag[i], "orgOnSphere" )) // sphere/ellipsoid
+		{
+			mSpawnFlags |= FX_ORG_ON_SPHERE;
+		}
+		else if ( !stricmp( flag[i], "orgOnCylinder" )) // cylinder/disk
+		{
+			mSpawnFlags |= FX_ORG_ON_CYLINDER;
+		}
+		else if ( !stricmp( flag[i], "axisFromSphere" ))
+		{
+			mSpawnFlags |= FX_AXIS_FROM_SPHERE;
+		}
+		else if ( !stricmp( flag[i], "randrotaroundfwd" ))
+		{
+			mSpawnFlags |= FX_RAND_ROT_AROUND_FWD;
+		}
+		else if ( !stricmp( flag[i], "evenDistribution" ))
+		{
+			mSpawnFlags |= FX_EVEN_DISTRIBUTION;
+		}
+		else if ( !stricmp( flag[i], "rgbComponentInterpolation" ))
+		{
+			mSpawnFlags |= FX_RGB_COMPONENT_INTERP;
+		}
+		else if ( !stricmp( flag[i], "affectedByWind" ))
+		{
+			mSpawnFlags |= FX_AFFECTED_BY_WIND;
+		}
+		else
+		{ // we have badness going on, but continue on in case there are any valid fields in here
+			ok = false;
+		}
+	}
+
+	return ok;
+}
+
+
+
+bool CPrimitiveTemplate::ParseMaterialImpact(const char *val)
+{
+	if (!stricmp(val, "shellsound"))
+	{
+		mMatImpactFX = MATIMPACTFX_SHELLSOUND;
+	}
+	else
+	{
+		mMatImpactFX = MATIMPACTFX_NONE;
+		theFxHelper.Print( "CPrimitiveTemplate::ParseMaterialImpact -- unknown materialImpact type!\n" );
+		return false;
+	}
+	return true;
+}
+
+
+//------------------------------------------------------
+// ParseAcceleration
+//	Reads in a ranged acceleration field in vector format
+//
+// input:
+//	string that contains one or two vectors
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseAcceleration( const char *val )
+{
+	vec3_t min, max;
+
+	if ( ParseVector( val, min, max ) == true )
+	{
+		mAccelX.SetRange( min[0], max[0] );
+		mAccelY.SetRange( min[1], max[1] );
+		mAccelZ.SetRange( min[2], max[2] );
+		return true;
+	}
+
+	return false;
+}
+
+//------------------------------------------------------
+// ParseGravity
+//	Reads in a ranged gravity value
+//
+// input:
+//	string that contains one or two floats
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseGravity( const char *val )
+{
+	float min, max;
+
+	if ( ParseFloat( val, &min, &max ) == true )
+	{
+		mGravity.SetRange( min, max );
+		return true;
+	}
+
+	return false;
+}
+
+//------------------------------------------------------
+// ParseDensity
+//	Reads in a ranged density value.  Density is only
+//	for emitters that are calling effects...it basically
+//	specifies how often the emitter should emit fx.
+//
+// input:
+//	string that contains one or two floats
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseDensity( const char *val )
+{
+	float min, max;
+
+	if ( ParseFloat( val, &min, &max ) == true )
+	{
+		mDensity.SetRange( min, max );
+		return true;
+	}
+
+	return false;
+}
+
+//------------------------------------------------------
+// ParseVariance
+//	Reads in a ranged variance value.  Variance is only 
+//	valid for emitters that are calling effects...
+//	it basically determines the amount of slop in the
+//	density calculations
+//
+// input:
+//	string that contains one or two floats
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseVariance( const char *val )
+{
+	float min, max;
+
+	if ( ParseFloat( val, &min, &max ) == true )
+	{
+		mVariance.SetRange( min, max );
+		return true;
+	}
+
+	return false;
+}
+
+//------------------------------------------------------
+// ParseRGBStart
+//	Reads in a ranged rgbStart field in vector format
+//
+// input:
+//	string that contains one or two vectors
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseRGBStart( const char *val )
+{
+	vec3_t min, max;
+
+	if ( ParseVector( val, min, max ) == true )
+	{
+		mRedStart.SetRange( min[0], max[0] );
+		mGreenStart.SetRange( min[1], max[1] );
+		mBlueStart.SetRange( min[2], max[2] );
+		return true;
+	}
+
+	return false;
+}
+
+//------------------------------------------------------
+// ParseRGBEnd
+//	Reads in a ranged rgbEnd field in vector format
+//
+// input:
+//	string that contains one or two vectors
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseRGBEnd( const char *val )
+{
+	vec3_t min, max;
+
+	if ( ParseVector( val, min, max ) == true )
+	{
+		mRedEnd.SetRange( min[0], max[0] );
+		mGreenEnd.SetRange( min[1], max[1] );
+		mBlueEnd.SetRange( min[2], max[2] );
+		return true;
+	}
+
+	return false;
+}
+
+//------------------------------------------------------
+// ParseRGBParm
+//	Reads in a ranged rgbParm field in float format
+//
+// input:
+//	string that contains one or two floats
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseRGBParm( const char *val )
+{
+	float min, max;
+
+	if ( ParseFloat( val, &min, &max ) == true )
+	{
+		mRGBParm.SetRange( min, max );
+		return true;
+	}
+
+	return false;
+}
+
+//------------------------------------------------------
+// ParseRGBFlags
+//	Reads in a set of rgbFlags in string format
+//
+// input:
+//	string that contains the flag strings
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseRGBFlags( const char *val )
+{
+	int flags;
+
+	if ( ParseGroupFlags( val, &flags ) == true )
+	{
+		// Convert our generic flag values into type specific ones
+		mFlags |= ( flags << FX_RGB_SHIFT );
+		return true;
+	}
+
+	return false;
+}
+
+//------------------------------------------------------
+// ParseAlphaStart
+//	Reads in a ranged alphaStart field in float format
+//
+// input:
+//	string that contains one or two floats
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseAlphaStart( const char *val )
+{
+	float min, max;
+
+	if ( ParseFloat( val, &min, &max ) == true )
+	{
+		mAlphaStart.SetRange( min, max );
+		return true;
+	}
+
+	return false;
+}
+
+//------------------------------------------------------
+// ParseAlphaEnd
+//	Reads in a ranged alphaEnd field in float format
+//
+// input:
+//	string that contains one or two floats
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseAlphaEnd( const char *val )
+{
+	float min, max;
+
+	if ( ParseFloat( val, &min, &max ) == true )
+	{
+		mAlphaEnd.SetRange( min, max );
+		return true;
+	}
+
+	return false;
+}
+
+//------------------------------------------------------
+// ParseAlphaParm
+//	Reads in a ranged alphaParm field in float format
+//
+// input:
+//	string that contains one or two floats
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseAlphaParm( const char *val )
+{
+	float min, max;
+
+	if ( ParseFloat( val, &min, &max ) == true )
+	{
+		mAlphaParm.SetRange( min, max );
+		return true;
+	}
+
+	return false;
+}
+
+//------------------------------------------------------
+// ParseAlphaFlags
+//	Reads in a set of alphaFlags in string format
+//
+// input:
+//	string that contains the flag strings
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseAlphaFlags( const char *val )
+{
+	int flags;
+
+	if ( ParseGroupFlags( val, &flags ) == true )
+	{
+		// Convert our generic flag values into type specific ones
+		mFlags |= ( flags << FX_ALPHA_SHIFT );
+		return true;
+	}
+
+	return false;
+}
+
+//------------------------------------------------------
+// ParseSizeStart
+//	Reads in a ranged sizeStart field in float format
+//
+// input:
+//	string that contains one or two floats
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseSizeStart( const char *val )
+{
+	float min, max;
+
+	if ( ParseFloat( val, &min, &max ) == true )
+	{
+		mSizeStart.SetRange( min, max );
+		return true;
+	}
+
+	return false;
+}
+
+//------------------------------------------------------
+// ParseSizeEnd
+//	Reads in a ranged sizeEnd field in float format
+//
+// input:
+//	string that contains one or two floats
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseSizeEnd( const char *val )
+{
+	float min, max;
+
+	if ( ParseFloat( val, &min, &max ) == true )
+	{
+		mSizeEnd.SetRange( min, max );
+		return true;
+	}
+
+	return false;
+}
+
+//------------------------------------------------------
+// ParseSizeParm
+//	Reads in a ranged sizeParm field in float format
+//
+// input:
+//	string that contains one or two floats
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseSizeParm( const char *val )
+{
+	float min, max;
+
+	if ( ParseFloat( val, &min, &max ) == true )
+	{
+		mSizeParm.SetRange( min, max );
+		return true;
+	}
+
+	return false;
+}
+
+//------------------------------------------------------
+// ParseSizeFlags
+//	Reads in a set of sizeFlags in string format
+//
+// input:
+//	string that contains the flag strings
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseSizeFlags( const char *val )
+{
+	int flags;
+
+	if ( ParseGroupFlags( val, &flags ) == true )
+	{
+		// Convert our generic flag values into type specific ones
+		mFlags |= ( flags << FX_SIZE_SHIFT );
+		return true;
+	}
+
+	return false;
+}
+
+//------------------------------------------------------
+// ParseSize2Start
+//	Reads in a ranged Size2Start field in float format
+//
+// input:
+//	string that contains one or two floats
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseSize2Start( const char *val )
+{
+	float min, max;
+
+	if ( ParseFloat( val, &min, &max ) == true )
+	{
+		mSize2Start.SetRange( min, max );
+		return true;
+	}
+
+	return false;
+}
+
+//------------------------------------------------------
+// ParseSize2End
+//	Reads in a ranged Size2End field in float format
+//
+// input:
+//	string that contains one or two floats
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseSize2End( const char *val )
+{
+	float min, max;
+
+	if ( ParseFloat( val, &min, &max ) == true )
+	{
+		mSize2End.SetRange( min, max );
+		return true;
+	}
+
+	return false;
+}
+
+//------------------------------------------------------
+// ParseSize2Parm
+//	Reads in a ranged Size2Parm field in float format
+//
+// input:
+//	string that contains one or two floats
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseSize2Parm( const char *val )
+{
+	float min, max;
+
+	if ( ParseFloat( val, &min, &max ) == true )
+	{
+		mSize2Parm.SetRange( min, max );
+		return true;
+	}
+
+	return false;
+}
+
+//------------------------------------------------------
+// ParseSize2Flags
+//	Reads in a set of Size2Flags in string format
+//
+// input:
+//	string that contains the flag strings
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseSize2Flags( const char *val )
+{
+	int flags;
+
+	if ( ParseGroupFlags( val, &flags ) == true )
+	{
+		// Convert our generic flag values into type specific ones
+		mFlags |= ( flags << FX_SIZE2_SHIFT );
+		return true;
+	}
+
+	return false;
+}
+
+//------------------------------------------------------
+// ParseLengthStart
+//	Reads in a ranged lengthStart field in float format
+//
+// input:
+//	string that contains one or two floats
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseLengthStart( const char *val )
+{
+	float min, max;
+
+	if ( ParseFloat( val, &min, &max ) == true )
+	{
+		mLengthStart.SetRange( min, max );
+		return true;
+	}
+
+	return false;
+}
+
+//------------------------------------------------------
+// ParseLengthEnd
+//	Reads in a ranged lengthEnd field in float format
+//
+// input:
+//	string that contains one or two floats
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseLengthEnd( const char *val )
+{
+	float min, max;
+
+	if ( ParseFloat( val, &min, &max ) == true )
+	{
+		mLengthEnd.SetRange( min, max );
+		return true;
+	}
+
+	return false;
+}
+
+//------------------------------------------------------
+// ParseLengthParm
+//	Reads in a ranged lengthParm field in float format
+//
+// input:
+//	string that contains one or two floats
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseLengthParm( const char *val )
+{
+	float min, max;
+
+	if ( ParseFloat( val, &min, &max ) == true )
+	{
+		mLengthParm.SetRange( min, max );
+		return true;
+	}
+
+	return false;
+}
+
+//------------------------------------------------------
+// ParseLengthFlags
+//	Reads in a set of lengthFlags in string format
+//
+// input:
+//	string that contains the flag strings
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseLengthFlags( const char *val )
+{
+	int flags;
+
+	if ( ParseGroupFlags( val, &flags ) == true )
+	{
+		// Convert our generic flag values into type specific ones
+		mFlags |= ( flags << FX_LENGTH_SHIFT );
+		return true;
+	}
+
+	return false;
+}
+
+//------------------------------------------------------
+// ParseShaders
+//	Reads in a group of shaders and registers them
+//
+// input:
+//	Parse group that contains the list of shaders to parse
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseShaders( CGPValue *grp )
+{
+	const char	*val;
+	int			handle;
+
+	if ( grp->IsList() )
+	{
+		// If we are a list we have to do separate processing
+		CGPObject *list = grp->GetList();
+
+		while ( list )
+		{
+			// name is actually the value contained in the list
+			val = list->GetName();
+
+			handle = theFxHelper.RegisterShader( val );
+			mMediaHandles.AddHandle( handle );
+
+			list = (CGPValue *)list->GetNext();
+		}
+	}
+	else
+	{
+		// Let's get a value
+		val = grp->GetTopValue();
+
+		if ( val )
+		{
+			handle = theFxHelper.RegisterShader( val );
+			mMediaHandles.AddHandle( handle );
+		}
+		else
+		{
+			// empty "list"
+			theFxHelper.Print( "CPrimitiveTemplate::ParseShaders called with an empty list!\n" );
+			return false;
+		}
+	}
+
+	return true;
+}
+
+//------------------------------------------------------
+// ParseSounds
+//	Reads in a group of sounds and registers them
+//
+// input:
+//	Parse group that contains the list of sounds to parse
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseSounds( CGPValue *grp )
+{
+	const char	*val;
+	int			handle;
+
+	if ( grp->IsList() )
+	{
+		// If we are a list we have to do separate processing
+		CGPObject *list = grp->GetList();
+
+		while ( list )
+		{
+			// name is actually the value contained in the list
+			val = list->GetName();
+
+			handle = theFxHelper.RegisterSound( val );
+			mMediaHandles.AddHandle( handle );
+
+			list = (CGPValue *)list->GetNext();
+		}
+	}
+	else
+	{
+		// Let's get a value
+		val = grp->GetTopValue();
+
+		if ( val )
+		{
+			handle = theFxHelper.RegisterSound( val );
+			mMediaHandles.AddHandle( handle );
+		}
+		else
+		{
+			// empty "list"
+			theFxHelper.Print( "CPrimitiveTemplate::ParseSounds called with an empty list!\n" );
+			return false;
+		}
+	}
+
+	return true;
+}
+
+//------------------------------------------------------
+// ParseModels
+//	Reads in a group of models and registers them
+//
+// input:
+//	Parse group that contains the list of models to parse
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseModels( CGPValue *grp )
+{
+	const char	*val;
+	int			handle;
+
+	if ( grp->IsList() )
+	{
+		// If we are a list we have to do separate processing
+		CGPObject *list = grp->GetList();
+
+		while ( list )
+		{
+			// name is actually the value contained in the list
+			val = list->GetName();
+
+			handle = theFxHelper.RegisterModel( val );
+			mMediaHandles.AddHandle( handle );
+
+			list = (CGPValue *)list->GetNext();
+		}
+	}
+	else
+	{
+		// Let's get a value
+		val = grp->GetTopValue();
+
+		if ( val )
+		{
+			handle = theFxHelper.RegisterModel( val );
+			mMediaHandles.AddHandle( handle );
+		}
+		else
+		{
+			// empty "list"
+			theFxHelper.Print( "CPrimitiveTemplate::ParseModels called with an empty list!\n" );
+			return false;
+		}
+	}
+
+	mFlags |= FX_ATTACHED_MODEL;
+
+	return true;
+}
+
+//------------------------------------------------------
+// ParseImpactFxStrings
+//	Reads in a group of fx file names and registers them
+//
+// input:
+//	Parse group that contains the list of fx to parse
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseImpactFxStrings( CGPValue *grp )
+{
+	const char	*val;
+	int			handle;
+
+	if ( grp->IsList() )
+	{
+		// If we are a list we have to do separate processing
+		CGPObject *list = grp->GetList();
+
+		while ( list )
+		{
+			// name is actually the value contained in the list
+			val = list->GetName();
+			handle = theFxScheduler.RegisterEffect( val );
+	
+			if ( handle )
+			{
+				mImpactFxHandles.AddHandle( handle );
+			}
+			else
+			{
+				theFxHelper.Print( "FxTemplate: Impact effect file not found.\n" );
+				return false;
+			}
+
+			list = (CGPValue *)list->GetNext();
+		}
+	}
+	else
+	{
+		// Let's get a value
+		val = grp->GetTopValue();
+
+		if ( val )
+		{
+			handle = theFxScheduler.RegisterEffect( val );
+
+			if ( handle )
+			{
+				mImpactFxHandles.AddHandle( handle );
+			}
+			else
+			{
+				theFxHelper.Print( "FxTemplate: Impact effect file not found.\n" );
+				return false;
+			}
+		}
+		else
+		{
+			// empty "list"
+			theFxHelper.Print( "CPrimitiveTemplate::ParseImpactFxStrings called with an empty list!\n" );
+			return false;
+		}
+	}
+
+	mFlags |= FX_IMPACT_RUNS_FX | FX_APPLY_PHYSICS;	
+
+	return true;
+}
+
+//------------------------------------------------------
+// ParseDeathFxStrings
+//	Reads in a group of fx file names and registers them
+//
+// input:
+//	Parse group that contains the list of fx to parse
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseDeathFxStrings( CGPValue *grp )
+{
+	const char	*val;
+	int			handle;
+
+	if ( grp->IsList() )
+	{
+		// If we are a list we have to do separate processing
+		CGPObject *list = grp->GetList();
+
+		while ( list )
+		{
+			// name is actually the value contained in the list
+			val = list->GetName();
+			handle = theFxScheduler.RegisterEffect( val );
+	
+			if ( handle )
+			{
+				mDeathFxHandles.AddHandle( handle );
+			}
+			else
+			{
+				theFxHelper.Print( "FxTemplate: Death effect file not found.\n" );
+				return false;
+			}
+
+			list = (CGPValue *)list->GetNext();
+		}
+	}
+	else
+	{
+		// Let's get a value
+		val = grp->GetTopValue();
+
+		if ( val )
+		{
+			handle = theFxScheduler.RegisterEffect( val );
+
+			if ( handle )
+			{
+				mDeathFxHandles.AddHandle( handle );
+			}
+			else
+			{
+				theFxHelper.Print( "FxTemplate: Death effect file not found.\n" );
+				return false;
+			}
+		}
+		else
+		{
+			// empty "list"
+			theFxHelper.Print( "CPrimitiveTemplate::ParseDeathFxStrings called with an empty list!\n" );
+			return false;
+		}
+	}
+
+	mFlags |= FX_DEATH_RUNS_FX;	
+
+	return true;
+}
+
+//------------------------------------------------------
+// ParseEmitterFxStrings
+//	Reads in a group of fx file names and registers them
+//
+// input:
+//	Parse group that contains the list of fx to parse
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseEmitterFxStrings( CGPValue *grp )
+{
+	const char	*val;
+	int			handle;
+
+	if ( grp->IsList() )
+	{
+		// If we are a list we have to do separate processing
+		CGPObject *list = grp->GetList();
+
+		while ( list )
+		{
+			// name is actually the value contained in the list
+			val = list->GetName();
+			handle = theFxScheduler.RegisterEffect( val );
+
+			if ( handle )
+			{
+				mEmitterFxHandles.AddHandle( handle );
+			}
+			else
+			{
+				theFxHelper.Print( "FxTemplate: Emitter effect file not found.\n" );
+				return false;
+			}
+
+			list = (CGPValue *)list->GetNext();
+		}
+	}
+	else
+	{
+		// Let's get a value
+		val = grp->GetTopValue();
+
+		if ( val )
+		{
+			handle = theFxScheduler.RegisterEffect( val );
+
+			if ( handle )
+			{
+				mEmitterFxHandles.AddHandle( handle );
+			}
+			else
+			{
+				theFxHelper.Print( "FxTemplate: Emitter effect file not found.\n" );
+				return false;
+			}
+		}
+		else
+		{
+			// empty "list"
+			theFxHelper.Print( "CPrimitiveTemplate::ParseEmitterFxStrings called with an empty list!\n" );
+			return false;
+		}
+	}
+
+	mFlags |= FX_EMIT_FX;	
+
+	return true;
+}
+
+//------------------------------------------------------
+// ParsePlayFxStrings
+//	Reads in a group of fx file names and registers them
+//
+// input:
+//	Parse group that contains the list of fx to parse
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParsePlayFxStrings( CGPValue *grp )
+{
+	const char	*val;
+	int			handle;
+
+	if ( grp->IsList() )
+	{
+		// If we are a list we have to do separate processing
+		CGPObject *list = grp->GetList();
+
+		while ( list )
+		{
+			// name is actually the value contained in the list
+			val = list->GetName();
+			handle = theFxScheduler.RegisterEffect( val );
+
+			if ( handle )
+			{
+				mPlayFxHandles.AddHandle( handle );
+			}
+			else
+			{
+				theFxHelper.Print( "FxTemplate: Effect file not found.\n" );
+				return false;
+			}
+
+			list = (CGPValue *)list->GetNext();
+		}
+	}
+	else
+	{
+		// Let's get a value
+		val = grp->GetTopValue();
+
+		if ( val )
+		{
+			handle = theFxScheduler.RegisterEffect( val );
+
+			if ( handle )
+			{
+				mPlayFxHandles.AddHandle( handle );
+			}
+			else
+			{
+				theFxHelper.Print( "FxTemplate: Effect file not found.\n" );
+				return false;
+			}
+		}
+		else
+		{
+			// empty "list"
+			theFxHelper.Print( "CPrimitiveTemplate::ParsePlayFxStrings called with an empty list!\n" );
+			return false;
+		}
+	}
+
+	return true;
+}
+
+//------------------------------------------------------
+// ParseRGB
+//	Takes an RGB group and chomps out any pairs contained
+//	in it.
+//
+// input:
+//	the parse group to process
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseRGB( CGPGroup *grp )
+{
+	CGPValue	*pairs;
+	const char	*key;
+	const char	*val;
+
+	// Inside of the group, we should have a series of pairs
+	pairs = grp->GetPairs();
+
+	while( pairs )
+	{	
+		// Let's get the key field
+		key = pairs->GetName();
+		val = pairs->GetTopValue();
+
+		// Huge stricmp lists suxor
+		if ( !stricmp( key, "start" ))
+		{
+			ParseRGBStart( val );
+		}
+		else if ( !stricmp( key, "end" ))
+		{
+			ParseRGBEnd( val );
+		}
+		else if ( !stricmp( key, "parm" ) || !stricmp( key, "parms" ))
+		{
+			ParseRGBParm( val );
+		}
+		else if ( !stricmp( key, "flags" ) || !stricmp( key, "flag" ))
+		{
+			ParseRGBFlags( val );
+		}
+		else
+		{
+			theFxHelper.Print( "Unknown key parsing an RGB group: %s\n", key );
+		}
+
+		pairs = (CGPValue *)pairs->GetNext();
+	}
+
+	return true;
+}
+
+//------------------------------------------------------
+// ParseAlpha
+//	Takes an alpha group and chomps out any pairs contained
+//	in it.
+//
+// input:
+//	the parse group to process
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseAlpha( CGPGroup *grp )
+{
+	CGPValue	*pairs;
+	const char	*key;
+	const char	*val;
+
+	// Inside of the group, we should have a series of pairs
+	pairs = grp->GetPairs();
+
+	while( pairs )
+	{	
+		// Let's get the key field
+		key = pairs->GetName();
+		val = pairs->GetTopValue();
+
+		// Huge stricmp lists suxor
+		if ( !stricmp( key, "start" ))
+		{
+			ParseAlphaStart( val );
+		}
+		else if ( !stricmp( key, "end" ))
+		{
+			ParseAlphaEnd( val );
+		}
+		else if ( !stricmp( key, "parm" ) || !stricmp( key, "parms" ))
+		{
+			ParseAlphaParm( val );
+		}
+		else if ( !stricmp( key, "flags" ) || !stricmp( key, "flag" ))
+		{
+			ParseAlphaFlags( val );
+		}
+		else
+		{
+			theFxHelper.Print( "Unknown key parsing an Alpha group: %s\n", key );
+		}
+
+		pairs = (CGPValue *)pairs->GetNext();
+	}
+
+	return true;
+}
+
+//------------------------------------------------------
+// ParseSize
+//	Takes a size group and chomps out any pairs contained
+//	in it.
+//
+// input:
+//	the parse group to process
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseSize( CGPGroup *grp )
+{
+	CGPValue	*pairs;
+	const char	*key;
+	const char	*val;
+
+	// Inside of the group, we should have a series of pairs
+	pairs = grp->GetPairs();
+
+	while( pairs )
+	{	
+		// Let's get the key field
+		key = pairs->GetName();
+		val = pairs->GetTopValue();
+
+		// Huge stricmp lists suxor
+		if ( !stricmp( key, "start" ))
+		{
+			ParseSizeStart( val );
+		}
+		else if ( !stricmp( key, "end" ))
+		{
+			ParseSizeEnd( val );
+		}
+		else if ( !stricmp( key, "parm" ) || !stricmp( key, "parms" ))
+		{
+			ParseSizeParm( val );
+		}
+		else if ( !stricmp( key, "flags" ) || !stricmp( key, "flag" ))
+		{
+			ParseSizeFlags( val );
+		}
+		else
+		{
+			theFxHelper.Print( "Unknown key parsing a Size group: %s\n", key );
+		}
+
+		pairs = (CGPValue *)pairs->GetNext();
+	}
+
+	return true;
+}
+
+//------------------------------------------------------
+// ParseSize2
+//	Takes a Size2 group and chomps out any pairs contained
+//	in it.
+//
+// input:
+//	the parse group to process
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseSize2( CGPGroup *grp )
+{
+	CGPValue	*pairs;
+	const char	*key;
+	const char	*val;
+
+	// Inside of the group, we should have a series of pairs
+	pairs = grp->GetPairs();
+
+	while( pairs )
+	{	
+		// Let's get the key field
+		key = pairs->GetName();
+		val = pairs->GetTopValue();
+
+		// Huge stricmp lists suxor
+		if ( !stricmp( key, "start" ))
+		{
+			ParseSize2Start( val );
+		}
+		else if ( !stricmp( key, "end" ))
+		{
+			ParseSize2End( val );
+		}
+		else if ( !stricmp( key, "parm" ) || !stricmp( key, "parms" ))
+		{
+			ParseSize2Parm( val );
+		}
+		else if ( !stricmp( key, "flags" ) || !stricmp( key, "flag" ))
+		{
+			ParseSize2Flags( val );
+		}
+		else
+		{
+			theFxHelper.Print( "Unknown key parsing a Size2 group: %s\n", key );
+		}
+
+		pairs = (CGPValue *)pairs->GetNext();
+	}
+
+	return true;
+}
+
+//------------------------------------------------------
+// ParseLength
+//	Takes a length group and chomps out any pairs contained
+//	in it.
+//
+// input:
+//	the parse group to process
+//
+// return:
+//	success of parse operation.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParseLength( CGPGroup *grp )
+{
+	CGPValue	*pairs;
+	const char	*key;
+	const char	*val;
+
+	// Inside of the group, we should have a series of pairs
+	pairs = grp->GetPairs();
+
+	while( pairs )
+	{	
+		// Let's get the key field
+		key = pairs->GetName();
+		val = pairs->GetTopValue();
+
+		// Huge stricmp lists suxor
+		if ( !stricmp( key, "start" ))
+		{
+			ParseLengthStart( val );
+		}
+		else if ( !stricmp( key, "end" ))
+		{
+			ParseLengthEnd( val );
+		}
+		else if ( !stricmp( key, "parm" ) || !stricmp( key, "parms" ))
+		{
+			ParseLengthParm( val );
+		}
+		else if ( !stricmp( key, "flags" ) || !stricmp( key, "flag" ))
+		{
+			ParseLengthFlags( val );
+		}
+		else
+		{
+			theFxHelper.Print( "Unknown key parsing a Length group: %s\n", key );
+		}
+
+		pairs = (CGPValue *)pairs->GetNext();
+	}
+
+	return true;
+}
+
+
+// Parse a primitive, apply defaults first, grab any base level
+//	key pairs, then process any sub groups we may contain.
+//------------------------------------------------------
+bool CPrimitiveTemplate::ParsePrimitive( CGPGroup *grp )
+{
+	CGPGroup	*subGrp;
+	CGPValue	*pairs;
+	const char	*key; 
+	const char	*val;
+
+	// Lets work with the pairs first
+	pairs = grp->GetPairs();
+
+	while( pairs )
+	{
+		// the fields
+		key = pairs->GetName();
+		val = pairs->GetTopValue();
+
+		// Huge stricmp lists suxor
+		if ( !stricmp( key, "count" ))
+		{
+			ParseCount( val );
+		}
+		else if ( !stricmp( key, "shaders" ) || !stricmp( key, "shader" ))
+		{
+			ParseShaders( pairs );
+		}
+		else if ( !stricmp( key, "models" ) || !stricmp( key, "model" ))
+		{
+			ParseModels( pairs );
+		}
+		else if ( !stricmp( key, "sounds" ) || !stricmp( key, "sound" ))
+		{
+			ParseSounds( pairs );
+		}
+		else if ( !stricmp( key, "impactfx" ))
+		{
+			ParseImpactFxStrings( pairs );
+		}
+		else if ( !stricmp( key, "deathfx" ))
+		{
+			ParseDeathFxStrings( pairs );
+		}
+		else if ( !stricmp( key, "emitfx" ))
+		{
+			ParseEmitterFxStrings( pairs );
+		}
+		else if ( !stricmp( key, "playfx" ))
+		{
+			ParsePlayFxStrings( pairs );
+		}
+		else if ( !stricmp( key, "life" ))
+		{
+			ParseLife( val );
+		}
+		else if ( !stricmp( key, "delay" ))
+		{
+			ParseDelay( val );
+		}
+		else if ( !stricmp( key, "cullrange" ))
+		{
+//			mCullRange = atoi( val );
+//			mCullRange *= mCullRange; // square it now so we don't have to square every time we compare
+		}
+		else if ( !stricmp( key, "bounce" ) || !stricmp( key, "intensity" )) // me==bad for reusing this...but it shouldn't hurt anything)
+		{
+			ParseElasticity( val );
+		}
+		else if ( !stricmp( key, "min" ))
+		{
+			ParseMin( val );
+		}
+		else if ( !stricmp( key, "max" ))
+		{
+			ParseMax( val );
+		}
+		else if ( !stricmp( key, "angle" ) || !stricmp( key, "angles" ))
+		{
+			ParseAngle( val );
+		}
+		else if ( !stricmp( key, "angleDelta" ))
+		{
+			ParseAngleDelta( val );
+		}
+		else if ( !stricmp( key, "velocity" ) || !stricmp( key, "vel" ))
+		{
+			ParseVelocity( val );
+		}
+		else if ( !stricmp( key, "acceleration" ) || !stricmp( key, "accel" ))
+		{
+			ParseAcceleration( val );
+		}
+		else if ( !stricmp( key, "gravity" ))
+		{
+			ParseGravity( val );
+		}
+		else if ( !stricmp( key, "density" ))
+		{
+			ParseDensity( val );
+		}
+		else if ( !stricmp( key, "variance" ))
+		{
+			ParseVariance( val );
+		}
+		else if ( !stricmp( key, "origin" ))
+		{
+			ParseOrigin1( val );
+		}
+		else if ( !stricmp( key, "origin2" ))
+		{
+			ParseOrigin2( val );
+		}
+		else if ( !stricmp( key, "radius" )) // part of ellipse/cylinder calcs.
+		{
+			ParseRadius( val );
+		}
+		else if ( !stricmp( key, "height" )) // part of ellipse/cylinder calcs.
+		{
+			ParseHeight( val );
+		}
+		else if ( !stricmp( key, "wind" ))
+		{
+			ParseWindModifier( val );
+		}
+		else if ( !stricmp( key, "rotation" ))
+		{
+			ParseRotation( val );
+		}
+		else if ( !stricmp( key, "rotationDelta" ))
+		{
+			ParseRotationDelta( val );
+		}
+		else if ( !stricmp( key, "flags" ) || !stricmp( key, "flag" ))
+		{ // these need to get passed on to the primitive
+			ParseFlags( val );
+		}
+		else if ( !stricmp( key, "spawnFlags" ) || !stricmp( key, "spawnFlag" ))
+		{ // these are used to spawn things in cool ways, but don't ever get passed on to prims.
+			ParseSpawnFlags( val );
+		}
+		else if ( !stricmp( key, "name" ))
+		{
+			if ( val )
+			{
+				// just stash the descriptive name of the primitive
+				strcpy( mName, val );
+			}
+		}
+		else if (!stricmp(key, "materialImpact"))
+		{
+			ParseMaterialImpact(val);
+		}
+		else
+		{
+			theFxHelper.Print( "Unknown key parsing an effect primitive: %s\n", key );
+		}
+
+		pairs = (CGPValue *)pairs->GetNext();
+	}
+
+	subGrp = grp->GetSubGroups();
+
+	// Lets chomp on the groups now
+	while ( subGrp )
+	{
+		key = subGrp->GetName();
+
+		if ( !stricmp( key, "rgb" ))
+		{
+			ParseRGB( subGrp );
+		}
+		else if ( !stricmp( key, "alpha" ))
+		{
+			ParseAlpha( subGrp );
+		}
+		else if ( !stricmp( key, "size" ) || !stricmp( key, "width" ))
+		{
+			ParseSize( subGrp );
+		}
+		else if ( !stricmp( key, "size2" ) || !stricmp( key, "width2" ))
+		{
+			ParseSize2( subGrp );
+		}
+		else if ( !stricmp( key, "length" ) || !stricmp( key, "height" ))
+		{
+			ParseLength( subGrp );
+		}
+		else
+		{
+			theFxHelper.Print( "Unknown group key parsing a particle: %s\n", key );
+		}
+
+		subGrp = (CGPGroup *)subGrp->GetNext();
+	}
+
+	return true;
+}
diff --git a/codemp/client/FxUtil.cpp b/codemp/client/FxUtil.cpp
new file mode 100644
index 0000000..d196990
--- /dev/null
+++ b/codemp/client/FxUtil.cpp
@@ -0,0 +1,1232 @@
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+// this include must remain at the top of every CPP file
+#include "client.h"
+
+
+#if !defined(FX_SCHEDULER_H_INC)
+	#include "FxScheduler.h"
+#endif
+
+vec3_t	WHITE = {1.0f, 1.0f, 1.0f};
+
+struct SEffectList
+{
+	CEffect *mEffect;
+	int		mKillTime;
+	bool	mPortal;
+};
+
+#define PI		3.14159f
+
+SEffectList		effectList[MAX_EFFECTS];
+SEffectList		*nextValidEffect;
+SFxHelper		theFxHelper;
+
+int				activeFx = 0;
+int				drawnFx;
+qboolean		fxInitialized = qfalse;	
+
+//-------------------------
+// FX_Free
+//
+// Frees all FX
+//-------------------------
+bool FX_Free( bool templates )
+{
+	for ( int i = 0; i < MAX_EFFECTS; i++ )
+	{
+		if ( effectList[i].mEffect )
+		{
+			delete effectList[i].mEffect;
+		}
+
+		effectList[i].mEffect = 0;
+	}
+
+	activeFx = 0;
+
+	theFxScheduler.Clean( templates );
+	return true;
+}
+
+//-------------------------
+// FX_Stop
+//
+// Frees all active FX but leaves the templates
+//-------------------------
+void FX_Stop( void )
+{
+	for ( int i = 0; i < MAX_EFFECTS; i++ )
+	{
+		if ( effectList[i].mEffect )
+		{
+			delete effectList[i].mEffect;
+		}
+
+		effectList[i].mEffect = 0;
+	}
+
+	activeFx = 0;
+
+	theFxScheduler.Clean(false);
+}
+
+//-------------------------
+// FX_Init
+//
+// Preps system for use
+//-------------------------
+int	FX_Init( refdef_t* refdef )
+{ 
+//	FX_Free( true );
+	if ( fxInitialized == qfalse )
+	{
+		fxInitialized = qtrue;
+
+		for ( int i = 0; i < MAX_EFFECTS; i++ )
+		{
+			effectList[i].mEffect = 0;
+		}
+	}
+	nextValidEffect = &effectList[0];
+
+#ifdef _SOF2DEV_
+	fx_freeze = Cvar_Get("fx_freeze", "0", CVAR_CHEAT);
+#endif
+	fx_debug = Cvar_Get("fx_debug", "0", CVAR_TEMP);
+	fx_countScale = Cvar_Get("fx_countScale", "1", CVAR_ARCHIVE);
+	fx_nearCull = Cvar_Get("fx_nearCull", "16", CVAR_ARCHIVE);
+
+	theFxHelper.ReInit(refdef);
+
+	return true;
+}
+
+void FX_SetRefDef(refdef_t *refdef)
+{
+	theFxHelper.refdef = refdef;
+}
+
+//-------------------------
+// FX_FreeMember
+//-------------------------
+static void FX_FreeMember( SEffectList *obj )
+{
+	obj->mEffect->Die();
+	delete obj->mEffect;
+	obj->mEffect = 0;
+
+	// May as well mark this to be used next
+	nextValidEffect = obj;
+
+	activeFx--;
+}
+
+
+//-------------------------
+// FX_GetValidEffect
+//
+// Finds an unused effect slot
+//
+// Note - in the editor, this function may return NULL, indicating that all
+// effects are being stopped.
+//-------------------------
+static SEffectList *FX_GetValidEffect()
+{
+	if ( nextValidEffect->mEffect == 0 )
+	{
+		return nextValidEffect;
+	}
+
+	int			i;
+	SEffectList	*ef;
+
+	// Blah..plow through the list till we find something that is currently untainted
+	for ( i = 0, ef = effectList; i < MAX_EFFECTS; i++, ef++ )
+	{
+		if ( ef->mEffect == 0 )
+		{
+			return ef;
+		}
+	}
+
+	// report the error.
+#ifndef FINAL_BUILD
+	theFxHelper.Print( "FX system out of effects\n" );
+#endif
+
+	// Hmmm.. just trashing the first effect in the list is a poor approach
+	FX_FreeMember( &effectList[0] );
+
+	// Recursive call
+	return nextValidEffect;
+}
+
+//-------------------------
+// FX_Add
+//
+// Adds all fx to the view
+//-------------------------
+void FX_Add( bool portal )
+{
+	int			i;
+	SEffectList	*ef;
+	
+	drawnFx = 0;
+
+	int numFx = activeFx;	//but stop when there can't be any more left!
+	for ( i = 0, ef = effectList; i < MAX_EFFECTS && numFx; i++, ef++ )
+	{
+		if ( ef->mEffect != 0)
+		{ 
+			--numFx;
+			if (portal != ef->mPortal)
+			{
+				continue;	//this one does not render in this scene
+			}
+			// Effect is active
+			if ( theFxHelper.mTime > ef->mKillTime )
+			{ 
+				// Clean up old effects, calling any death effects as needed
+				// this flag just has to be cleared otherwise death effects might not happen correctly
+				ef->mEffect->ClearFlags( FX_KILL_ON_IMPACT ); 
+				FX_FreeMember( ef );
+			}
+			else
+			{
+				if ( ef->mEffect->Update() == false )
+				{
+					// We've been marked for death
+					FX_FreeMember( ef );
+					continue;
+				}
+			}
+		}
+	}
+
+
+	if ( fx_debug->integer && !portal)
+	{
+		theFxHelper.Print( "Active    FX: %i\n", activeFx );
+		theFxHelper.Print( "Drawn     FX: %i\n", drawnFx );
+		theFxHelper.Print( "Scheduled FX: %i\n", theFxScheduler.NumScheduledFx() );
+	}
+}
+
+
+
+//-------------------------
+// FX_AddPrimitive
+//
+// Note - in the editor, this function may change *pEffect to NULL, indicating that
+// all effects are being stopped.
+//-------------------------
+extern bool gEffectsInPortal;	//from FXScheduler.cpp so i don't have to pass it in on EVERY FX_ADD*
+void FX_AddPrimitive( CEffect **pEffect, int killTime )
+{
+	SEffectList *item = FX_GetValidEffect();
+
+	item->mEffect = *pEffect;
+	item->mKillTime = theFxHelper.mTime + killTime;
+	item->mPortal = gEffectsInPortal;	//global set in AddScheduledEffects
+
+	activeFx++;
+
+	// Stash these in the primitive so it has easy access to the vals
+	(*pEffect)->SetTimeStart( theFxHelper.mTime );
+	(*pEffect)->SetTimeEnd( theFxHelper.mTime + killTime );
+}
+
+//-------------------------
+//  FX_AddParticle
+//-------------------------
+CParticle *FX_AddParticle( vec3_t org, vec3_t vel, vec3_t accel, float size1, float size2, float sizeParm, 
+							float alpha1, float alpha2, float alphaParm, 
+							vec3_t sRGB, vec3_t eRGB, float rgbParm,
+							float rotation, float rotationDelta,
+							vec3_t min, vec3_t max, float elasticity,
+							int deathID, int impactID,
+							int killTime, qhandle_t shader, int flags = 0, 
+							EMatImpactEffect matImpactFX /*MATIMPACTFX_NONE*/, int fxParm /*-1*/,
+							int iGhoul2/*0*/, int entNum/*-1*/, int modelNum/*-1*/, int boltNum/*-1*/ )
+{
+	if ( theFxHelper.mFrameTime < 1 )
+	{ // disallow adding effects when the system is paused
+		return 0;
+	}
+
+	CParticle *fx = new CParticle;
+
+	if ( fx )
+	{
+		if (flags&FX_RELATIVE && iGhoul2>0)
+		{
+			fx->SetOrigin1( NULL );
+			fx->SetOrgOffset( org );
+			fx->SetBoltinfo( iGhoul2, entNum, modelNum, boltNum );
+		}
+		else
+		{
+			fx->SetOrigin1( org );
+		}
+		fx->SetOrigin1( org );
+		fx->SetMatImpactFX(matImpactFX);
+		fx->SetMatImpactParm(fxParm);
+		fx->SetVel( vel );
+		fx->SetAccel( accel );
+
+		// RGB----------------
+		fx->SetRGBStart( sRGB );
+		fx->SetRGBEnd( eRGB );
+
+		if (( flags & FX_RGB_PARM_MASK ) == FX_RGB_WAVE )
+		{
+			fx->SetRGBParm( rgbParm * PI * 0.001f );
+		}
+		else if ( flags & FX_RGB_PARM_MASK )
+		{
+			// rgbParm should be a value from 0-100..
+			fx->SetRGBParm( rgbParm * 0.01f * killTime + theFxHelper.mTime );
+		}
+
+		// Alpha----------------
+		fx->SetAlphaStart( alpha1 );
+		fx->SetAlphaEnd( alpha2 );
+
+		if (( flags & FX_ALPHA_PARM_MASK ) == FX_ALPHA_WAVE )
+		{
+			fx->SetAlphaParm( alphaParm * PI * 0.001f );
+		}
+		else if ( flags & FX_ALPHA_PARM_MASK )
+		{
+			fx->SetAlphaParm( alphaParm * 0.01f * killTime + theFxHelper.mTime );
+		}
+
+		// Size----------------
+		fx->SetSizeStart( size1 );
+		fx->SetSizeEnd( size2 );
+
+		if (( flags & FX_SIZE_PARM_MASK ) == FX_SIZE_WAVE )
+		{
+			fx->SetSizeParm( sizeParm * PI * 0.001f );
+		}
+		else if ( flags & FX_SIZE_PARM_MASK )
+		{
+			fx->SetSizeParm( sizeParm * 0.01f * killTime + theFxHelper.mTime );
+		}
+
+		fx->SetFlags( flags );
+		fx->SetShader( shader );
+		fx->SetRotation( rotation );
+		fx->SetRotationDelta( rotationDelta );
+		fx->SetElasticity( elasticity );
+		fx->SetMin( min );
+		fx->SetMax( max );
+		fx->SetDeathFxID( deathID );
+		fx->SetImpactFxID( impactID );
+
+		fx->Init();
+
+		FX_AddPrimitive( (CEffect**)&fx, killTime );
+	}
+
+	return fx;
+}
+
+
+
+//-------------------------
+//  FX_AddLine
+//-------------------------
+CLine *FX_AddLine( vec3_t start, vec3_t end, float size1, float size2, float sizeParm,
+									float alpha1, float alpha2, float alphaParm,
+									vec3_t sRGB, vec3_t eRGB, float rgbParm,
+									int killTime, qhandle_t shader, int flags = 0, 
+									EMatImpactEffect matImpactFX /*MATIMPACTFX_NONE*/, int fxParm /*-1*/,
+									int iGhoul2/*0*/, int entNum/*-1*/, int modelNum/*-1*/, int boltNum/*-1*/)
+{
+	if ( theFxHelper.mFrameTime < 1 )
+	{ // disallow adding new effects when the system is paused
+		return 0;
+	}
+
+	CLine *fx = new CLine;
+
+	if ( fx )
+	{
+		if (flags&FX_RELATIVE && iGhoul2>0)
+		{
+			fx->SetOrigin1( NULL );
+			fx->SetOrgOffset( start ); //offset from bolt pos
+			fx->SetVel( end );	//vel is the vector offset from bolt+orgOffset
+			fx->SetBoltinfo( iGhoul2, entNum, modelNum, boltNum );
+		}
+		else
+		{
+			fx->SetOrigin1( start );
+			fx->SetOrigin2( end );
+		}
+		fx->SetMatImpactFX(matImpactFX);
+		fx->SetMatImpactParm(fxParm);
+
+		// RGB----------------
+		fx->SetRGBStart( sRGB );
+		fx->SetRGBEnd( eRGB );
+
+		if (( flags & FX_RGB_PARM_MASK ) == FX_RGB_WAVE )
+		{
+			fx->SetRGBParm( rgbParm * PI * 0.001f );
+		}
+		else if ( flags & FX_RGB_PARM_MASK )
+		{
+			// rgbParm should be a value from 0-100..
+			fx->SetRGBParm( rgbParm * 0.01f * killTime + theFxHelper.mTime );
+		}
+
+		// Alpha----------------
+		fx->SetAlphaStart( alpha1 );
+		fx->SetAlphaEnd( alpha2 );
+
+		if (( flags & FX_ALPHA_PARM_MASK ) == FX_ALPHA_WAVE )
+		{
+			fx->SetAlphaParm( alphaParm * PI * 0.001f );
+		}
+		else if ( flags & FX_ALPHA_PARM_MASK )
+		{
+			fx->SetAlphaParm( alphaParm * 0.01f * killTime + theFxHelper.mTime );
+		}
+
+		// Size----------------
+		fx->SetSizeStart( size1 );
+		fx->SetSizeEnd( size2 );
+
+		if (( flags & FX_SIZE_PARM_MASK ) == FX_SIZE_WAVE )
+		{
+			fx->SetSizeParm( sizeParm * PI * 0.001f );
+		}
+		else if ( flags & FX_SIZE_PARM_MASK )
+		{
+			fx->SetSizeParm( sizeParm * 0.01f * killTime + theFxHelper.mTime );
+		}
+
+		fx->SetShader( shader );
+		fx->SetFlags( flags );
+
+		fx->SetSTScale( 1.0f, 1.0f );
+
+		FX_AddPrimitive( (CEffect**)&fx, killTime );
+	}
+
+	return fx;
+}
+
+
+//-------------------------
+//  FX_AddElectricity
+//-------------------------
+CElectricity *FX_AddElectricity( vec3_t start, vec3_t end, float size1, float size2, float sizeParm,
+								float alpha1, float alpha2, float alphaParm,
+								vec3_t sRGB, vec3_t eRGB, float rgbParm,
+								float chaos, int killTime, qhandle_t shader, int flags = 0, 
+								EMatImpactEffect matImpactFX /*MATIMPACTFX_NONE*/, int fxParm /*-1*/,
+								int iGhoul2/*0*/, int entNum/*-1*/, int modelNum/*-1*/, int boltNum/*-1*/ )
+{
+	if ( theFxHelper.mFrameTime < 1 )
+	{ // disallow adding new effects when the system is paused
+		return 0;
+	}
+
+	CElectricity *fx = new CElectricity;
+
+	if ( fx )
+	{
+		if (flags&FX_RELATIVE && iGhoul2>0)
+		{
+			fx->SetOrigin1( NULL );
+			fx->SetOrgOffset( start );//offset
+			fx->SetVel( end );	//vel is the vector offset from bolt+orgOffset
+			fx->SetBoltinfo( iGhoul2, entNum, modelNum, boltNum );
+		}
+		else
+		{
+			fx->SetOrigin1( start );
+			fx->SetOrigin2( end );
+		}
+		fx->SetMatImpactFX(matImpactFX);
+		fx->SetMatImpactParm(fxParm);
+
+		// RGB----------------
+		fx->SetRGBStart( sRGB );
+		fx->SetRGBEnd( eRGB );
+
+		if (( flags & FX_RGB_PARM_MASK ) == FX_RGB_WAVE )
+		{
+			fx->SetRGBParm( rgbParm * PI * 0.001f );
+		}
+		else if ( flags & FX_RGB_PARM_MASK )
+		{
+			// rgbParm should be a value from 0-100..
+			fx->SetRGBParm( rgbParm * 0.01f * killTime + theFxHelper.mTime );
+		}
+
+		// Alpha----------------
+		fx->SetAlphaStart( alpha1 );
+		fx->SetAlphaEnd( alpha2 );
+
+		if (( flags & FX_ALPHA_PARM_MASK ) == FX_ALPHA_WAVE )
+		{
+			fx->SetAlphaParm( alphaParm * PI * 0.001f );
+		}
+		else if ( flags & FX_ALPHA_PARM_MASK )
+		{
+			fx->SetAlphaParm( alphaParm * 0.01f * killTime + theFxHelper.mTime );
+		}
+
+		// Size----------------
+		fx->SetSizeStart( size1 );
+		fx->SetSizeEnd( size2 );
+
+		if (( flags & FX_SIZE_PARM_MASK ) == FX_SIZE_WAVE )
+		{
+			fx->SetSizeParm( sizeParm * PI * 0.001f );
+		}
+		else if ( flags & FX_SIZE_PARM_MASK )
+		{
+			fx->SetSizeParm( sizeParm * 0.01f * killTime + theFxHelper.mTime );
+		}
+
+		fx->SetShader( shader );
+		fx->SetFlags( flags );
+		fx->SetChaos( chaos );
+
+		fx->SetSTScale( 1.0f, 1.0f );
+
+		FX_AddPrimitive( (CEffect**)&fx, killTime );
+		// in the editor, fx may now be NULL?
+		if ( fx )
+		{
+			fx->Initialize(); 
+		}
+	}
+
+	return fx;
+}
+
+
+//-------------------------
+//  FX_AddTail
+//-------------------------
+CTail *FX_AddTail( vec3_t org, vec3_t vel, vec3_t accel, 
+							float size1, float size2, float sizeParm, 
+							float length1, float length2, float lengthParm,
+							float alpha1, float alpha2, float alphaParm,
+							vec3_t sRGB, vec3_t eRGB, float rgbParm,
+							vec3_t min, vec3_t max, float elasticity, 
+							int deathID, int impactID,
+							int killTime, qhandle_t shader, int flags = 0, 
+							EMatImpactEffect matImpactFX /*MATIMPACTFX_NONE*/, int fxParm /*-1*/,
+							int iGhoul2/*0*/, int entNum/*-1*/, int modelNum/*-1*/, int boltNum/*-1*/ )
+{
+	if ( theFxHelper.mFrameTime < 1 )
+	{ // disallow adding effects when the system is paused
+		return 0;
+	}
+
+	CTail *fx = new CTail;
+
+	if ( fx )
+	{
+		if (flags&FX_RELATIVE && iGhoul2>0)
+		{
+			fx->SetOrigin1( NULL );
+			fx->SetOrgOffset( org );
+			fx->SetBoltinfo( iGhoul2, entNum, modelNum, boltNum );
+		}
+		else
+		{
+			fx->SetOrigin1( org );
+		}
+		fx->SetMatImpactFX(matImpactFX);
+		fx->SetMatImpactParm(fxParm);
+		fx->SetVel( vel );
+		fx->SetAccel( accel );
+
+		// RGB----------------
+		fx->SetRGBStart( sRGB );
+		fx->SetRGBEnd( eRGB );
+
+		if (( flags & FX_RGB_PARM_MASK ) == FX_RGB_WAVE )
+		{
+			fx->SetRGBParm( rgbParm * PI * 0.001f );
+		}
+		else if ( flags & FX_RGB_PARM_MASK )
+		{
+			// rgbParm should be a value from 0-100..
+			fx->SetRGBParm( rgbParm * 0.01f * killTime + theFxHelper.mTime );
+		}
+
+		// Alpha----------------
+		fx->SetAlphaStart( alpha1 );
+		fx->SetAlphaEnd( alpha2 );
+
+		if (( flags & FX_ALPHA_PARM_MASK ) == FX_ALPHA_WAVE )
+		{
+			fx->SetAlphaParm( alphaParm * PI * 0.001f );
+		}
+		else if ( flags & FX_ALPHA_PARM_MASK )
+		{
+			fx->SetAlphaParm( alphaParm * 0.01f * killTime + theFxHelper.mTime );
+		}
+
+		// Size----------------
+		fx->SetSizeStart( size1 );
+		fx->SetSizeEnd( size2 );
+
+		if (( flags & FX_SIZE_PARM_MASK ) == FX_SIZE_WAVE )
+		{
+			fx->SetSizeParm( sizeParm * PI * 0.001f );
+		}
+		else if ( flags & FX_SIZE_PARM_MASK )
+		{
+			fx->SetSizeParm( sizeParm * 0.01f * killTime + theFxHelper.mTime );
+		}
+
+		// Length----------------
+		fx->SetLengthStart( length1 );
+		fx->SetLengthEnd( length2 );
+
+		if (( flags & FX_LENGTH_PARM_MASK ) == FX_LENGTH_WAVE )
+		{
+			fx->SetLengthParm( lengthParm * PI * 0.001f );
+		}
+		else if ( flags & FX_LENGTH_PARM_MASK )
+		{
+			fx->SetLengthParm( lengthParm * 0.01f * killTime + theFxHelper.mTime );
+		}
+
+		fx->SetFlags( flags );
+		fx->SetShader( shader );
+		fx->SetElasticity( elasticity );
+		fx->SetMin( min );
+		fx->SetMax( max );
+		fx->SetSTScale( 1.0f, 1.0f );
+		fx->SetDeathFxID( deathID );
+		fx->SetImpactFxID( impactID );
+
+		FX_AddPrimitive( (CEffect**)&fx, killTime );
+	}
+
+	return fx;
+}
+
+
+//-------------------------
+//  FX_AddCylinder
+//-------------------------
+CCylinder *FX_AddCylinder( vec3_t start, vec3_t normal, 
+							float size1s, float size1e, float size1Parm,
+							float size2s, float size2e, float size2Parm,
+							float length1, float length2, float lengthParm,
+							float alpha1, float alpha2, float alphaParm,
+							vec3_t rgb1, vec3_t rgb2, float rgbParm,
+							int killTime, qhandle_t shader, int flags, 
+							EMatImpactEffect matImpactFX /*MATIMPACTFX_NONE*/, int fxParm /*-1*/,
+							int iGhoul2/*0*/, int entNum/*-1*/, int modelNum/*-1*/, int boltNum/*-1*/,
+							qboolean traceEnd)
+{
+	if ( theFxHelper.mFrameTime < 1 )
+	{ // disallow adding new effects when the system is paused
+		return 0;
+	}
+
+	CCylinder *fx = new CCylinder;
+
+	if ( fx )
+	{
+		if (flags&FX_RELATIVE && iGhoul2>0)
+		{
+			fx->SetOrigin1( NULL );
+			fx->SetOrgOffset( start );//offset
+			fx->SetBoltinfo( iGhoul2, entNum, modelNum, boltNum );
+		}
+		else
+		{
+			fx->SetOrigin1( start );
+		}
+		fx->SetTraceEnd(traceEnd);
+
+		fx->SetMatImpactFX(matImpactFX);
+		fx->SetMatImpactParm(fxParm);
+		fx->SetOrigin1( start );
+		fx->SetNormal( normal );
+
+		// RGB----------------
+		fx->SetRGBStart( rgb1 );
+		fx->SetRGBEnd( rgb2 );
+
+		if (( flags & FX_RGB_PARM_MASK ) == FX_RGB_WAVE )
+		{
+			fx->SetRGBParm( rgbParm * PI * 0.001f );
+		}
+		else if ( flags & FX_RGB_PARM_MASK )
+		{
+			// rgbParm should be a value from 0-100..
+			fx->SetRGBParm( rgbParm * 0.01f * killTime + theFxHelper.mTime );
+		}
+
+		// Size1----------------
+		fx->SetSizeStart( size1s );
+		fx->SetSizeEnd( size1e );
+
+		if (( flags & FX_SIZE_PARM_MASK ) == FX_SIZE_WAVE )
+		{
+			fx->SetSizeParm( size1Parm * PI * 0.001f );
+		}
+		else if ( flags & FX_SIZE_PARM_MASK )
+		{
+			fx->SetSizeParm( size1Parm * 0.01f * killTime + theFxHelper.mTime );
+		}
+
+		// Size2----------------
+		fx->SetSize2Start( size2s );
+		fx->SetSize2End( size2e );
+
+		if (( flags & FX_SIZE2_PARM_MASK ) == FX_SIZE2_WAVE )
+		{
+			fx->SetSize2Parm( size2Parm * PI * 0.001f );
+		}
+		else if ( flags & FX_SIZE2_PARM_MASK )
+		{
+			fx->SetSize2Parm( size2Parm * 0.01f * killTime + theFxHelper.mTime );
+		}
+
+		// Length1---------------
+		fx->SetLengthStart( length1 );
+		fx->SetLengthEnd( length2 );
+
+		if (( flags & FX_LENGTH_PARM_MASK ) == FX_LENGTH_WAVE )
+		{
+			fx->SetLengthParm( lengthParm * PI * 0.001f );
+		}
+		else if ( flags & FX_LENGTH_PARM_MASK )
+		{
+			fx->SetLengthParm( lengthParm * 0.01f * killTime + theFxHelper.mTime );
+		}
+
+		// Alpha----------------
+		fx->SetAlphaStart( alpha1 );
+		fx->SetAlphaEnd( alpha2 );
+
+		if (( flags & FX_ALPHA_PARM_MASK ) == FX_ALPHA_WAVE )
+		{
+			fx->SetAlphaParm( alphaParm * PI * 0.001f );
+		}
+		else if ( flags & FX_ALPHA_PARM_MASK )
+		{
+			fx->SetAlphaParm( alphaParm * 0.01f * killTime + theFxHelper.mTime );
+		}
+
+		fx->SetShader( shader );
+		fx->SetFlags( flags );
+
+		FX_AddPrimitive( (CEffect**)&fx, killTime );
+	}
+
+	return fx;
+}
+
+//-------------------------
+//  FX_AddEmitter
+//-------------------------
+CEmitter *FX_AddEmitter( vec3_t org, vec3_t vel, vec3_t accel, 
+								float size1, float size2, float sizeParm,
+								float alpha1, float alpha2, float alphaParm,
+								vec3_t rgb1, vec3_t rgb2, float rgbParm,
+								vec3_t angs, vec3_t deltaAngs,
+								vec3_t min, vec3_t max, float elasticity, 
+								int deathID, int impactID, int emitterID,
+								float density, float variance,
+								int killTime, qhandle_t model, int flags = 0, 
+								EMatImpactEffect matImpactFX /*MATIMPACTFX_NONE*/, int fxParm /*-1*/,
+								int iGhoul2/*0*/, int entNum/*-1*/, int modelNum/*-1*/, int boltNum/*-1*/ )
+{
+	if ( theFxHelper.mFrameTime < 1 )
+	{ // disallow adding effects when the system is paused
+		return 0;
+	}
+
+	CEmitter *fx = new CEmitter;
+
+	if ( fx )
+	{
+		if (flags&FX_RELATIVE && iGhoul2>0)
+		{
+			assert(0);//not done
+//			fx->SetBoltinfo( iGhoul2, entNum, modelNum, boltNum );
+		}
+		fx->SetMatImpactFX(matImpactFX);
+		fx->SetMatImpactParm(fxParm);
+		fx->SetOrigin1( org );
+		fx->SetVel( vel );
+		fx->SetAccel( accel );
+
+		// RGB----------------
+		fx->SetRGBStart( rgb1 );
+		fx->SetRGBEnd( rgb2 );
+
+		if (( flags & FX_RGB_PARM_MASK ) == FX_RGB_WAVE )
+		{
+			fx->SetRGBParm( rgbParm * PI * 0.001f );
+		}
+		else if ( flags & FX_RGB_PARM_MASK )
+		{
+			// rgbParm should be a value from 0-100..
+			fx->SetRGBParm( rgbParm * 0.01f * killTime + theFxHelper.mTime );
+		}
+
+		// Size----------------
+		fx->SetSizeStart( size1 );
+		fx->SetSizeEnd( size2 );
+
+		if (( flags & FX_SIZE_PARM_MASK ) == FX_SIZE_WAVE )
+		{
+			fx->SetSizeParm( sizeParm * PI * 0.001f );
+		}
+		else if ( flags & FX_SIZE_PARM_MASK )
+		{
+			fx->SetSizeParm( sizeParm * 0.01f * killTime + theFxHelper.mTime );
+		}
+
+		// Alpha----------------
+		fx->SetAlphaStart( alpha1 );
+		fx->SetAlphaEnd( alpha2 );
+
+		if (( flags & FX_ALPHA_PARM_MASK ) == FX_ALPHA_WAVE )
+		{
+			fx->SetAlphaParm( alphaParm * PI * 0.001f );
+		}
+		else if ( flags & FX_ALPHA_PARM_MASK )
+		{
+			fx->SetAlphaParm( alphaParm * 0.01f * killTime + theFxHelper.mTime );
+		}
+
+		fx->SetAngles( angs );
+		fx->SetAngleDelta( deltaAngs );
+		fx->SetFlags( flags );
+		fx->SetModel( model );
+		fx->SetElasticity( elasticity );
+		fx->SetMin( min );
+		fx->SetMax( max );
+		fx->SetDeathFxID( deathID );
+		fx->SetImpactFxID( impactID );
+		fx->SetEmitterFxID( emitterID );
+		fx->SetDensity( density );
+		fx->SetVariance( variance );
+		fx->SetOldTime( theFxHelper.mTime );
+
+		fx->SetLastOrg( org );
+		fx->SetLastVel( vel );
+
+		FX_AddPrimitive( (CEffect**)&fx, killTime );
+	}
+
+	return fx;
+}
+
+//-------------------------
+//  FX_AddLight
+//-------------------------
+CLight *FX_AddLight( vec3_t org, float size1, float size2, float sizeParm,
+							vec3_t rgb1, vec3_t rgb2, float rgbParm,
+							int killTime, int flags = 0, 
+							EMatImpactEffect matImpactFX /*MATIMPACTFX_NONE*/, int fxParm /*-1*/,
+							int iGhoul2/*0*/, int entNum/*-1*/, int modelNum/*-1*/, int boltNum/*-1*/)
+{
+	if ( theFxHelper.mFrameTime < 1 )
+	{ // disallow adding effects when the system is paused
+		return 0;
+	}
+
+	CLight *fx = new CLight;
+
+	if ( fx )
+	{
+		if (flags&FX_RELATIVE && iGhoul2>0)
+		{
+			fx->SetOrigin1( NULL );
+			fx->SetOrgOffset( org );//offset
+			fx->SetBoltinfo( iGhoul2, entNum, modelNum, boltNum );
+		}
+		else
+		{
+			fx->SetOrigin1( org );
+		}
+		fx->SetMatImpactFX(matImpactFX);
+		fx->SetMatImpactParm(fxParm);
+
+		// RGB----------------
+		fx->SetRGBStart( rgb1 );
+		fx->SetRGBEnd( rgb2 );
+
+		if (( flags & FX_RGB_PARM_MASK ) == FX_RGB_WAVE )
+		{
+			fx->SetRGBParm( rgbParm * PI * 0.001f );
+		}
+		else if ( flags & FX_RGB_PARM_MASK )
+		{
+			// rgbParm should be a value from 0-100..
+			fx->SetRGBParm( rgbParm * 0.01f * killTime + theFxHelper.mTime );
+		}
+
+		// Size----------------
+		fx->SetSizeStart( size1 );
+		fx->SetSizeEnd( size2 );
+
+		if (( flags & FX_SIZE_PARM_MASK ) == FX_SIZE_WAVE )
+		{
+			fx->SetSizeParm( sizeParm * PI * 0.001f );
+		}
+		else if ( flags & FX_SIZE_PARM_MASK )
+		{
+			fx->SetSizeParm( sizeParm * 0.01f * killTime + theFxHelper.mTime );
+		}
+
+		fx->SetFlags( flags );
+
+		FX_AddPrimitive( (CEffect**)&fx, killTime );
+	}
+
+	return fx;
+
+}
+
+
+//-------------------------
+//  FX_AddOrientedParticle
+//-------------------------
+COrientedParticle *FX_AddOrientedParticle( vec3_t org, vec3_t norm, vec3_t vel, vec3_t accel,
+						float size1, float size2, float sizeParm,
+						float alpha1, float alpha2, float alphaParm,
+						vec3_t rgb1, vec3_t rgb2, float rgbParm,
+						float rotation, float rotationDelta,
+						vec3_t min, vec3_t max, float bounce,
+						int deathID, int impactID,
+						int killTime, qhandle_t shader, int flags = 0, 
+						EMatImpactEffect matImpactFX /*MATIMPACTFX_NONE*/, int fxParm /*-1*/,
+						int iGhoul2/*0*/, int entNum/*-1*/, int modelNum/*-1*/, int boltNum/*-1*/ )
+{
+	if ( theFxHelper.mFrameTime < 1 )
+	{ // disallow adding effects when the system is paused
+		return 0;
+	}
+
+	COrientedParticle *fx = new COrientedParticle;
+
+	if ( fx )
+	{
+		if (flags&FX_RELATIVE && iGhoul2>0)
+		{
+			fx->SetOrigin1( NULL );
+			fx->SetOrgOffset( org );//offset
+			fx->SetBoltinfo( iGhoul2, entNum, modelNum, boltNum );
+		}
+		else
+		{
+			fx->SetOrigin1( org );
+		}
+		fx->SetMatImpactFX(matImpactFX);
+		fx->SetMatImpactParm(fxParm);
+		fx->SetOrigin1( org );
+		fx->SetNormal( norm );
+		fx->SetVel( vel );
+		fx->SetAccel( accel );
+
+		// RGB----------------
+		fx->SetRGBStart( rgb1 );
+		fx->SetRGBEnd( rgb2 );
+
+		if (( flags & FX_RGB_PARM_MASK ) == FX_RGB_WAVE )
+		{
+			fx->SetRGBParm( rgbParm * PI * 0.001f );
+		}
+		else if ( flags & FX_RGB_PARM_MASK )
+		{
+			// rgbParm should be a value from 0-100..
+			fx->SetRGBParm( rgbParm * 0.01f * killTime + theFxHelper.mTime );
+		}
+
+		// Alpha----------------
+		fx->SetAlphaStart( alpha1 );
+		fx->SetAlphaEnd( alpha2 );
+
+		if (( flags & FX_ALPHA_PARM_MASK ) == FX_ALPHA_WAVE )
+		{
+			fx->SetAlphaParm( alphaParm * PI * 0.001f );
+		}
+		else if ( flags & FX_ALPHA_PARM_MASK )
+		{
+			fx->SetAlphaParm( alphaParm * 0.01f * killTime + theFxHelper.mTime );
+		}
+
+		// Size----------------
+		fx->SetSizeStart( size1 );
+		fx->SetSizeEnd( size2 );
+
+		if (( flags & FX_SIZE_PARM_MASK ) == FX_SIZE_WAVE )
+		{
+			fx->SetSizeParm( sizeParm * PI * 0.001f );
+		}
+		else if ( flags & FX_SIZE_PARM_MASK )
+		{
+			fx->SetSizeParm( sizeParm * 0.01f * killTime + theFxHelper.mTime );
+		}
+
+		fx->SetFlags( flags );
+		fx->SetShader( shader );
+		fx->SetRotation( rotation );
+		fx->SetRotationDelta( rotationDelta );
+		fx->SetElasticity( bounce );
+		fx->SetMin( min );
+		fx->SetMax( max );
+		fx->SetDeathFxID( deathID );
+		fx->SetImpactFxID( impactID );
+
+		FX_AddPrimitive( (CEffect**)&fx, killTime );
+	}
+
+	return fx;
+}
+
+
+//-------------------------
+//  FX_AddPoly
+//-------------------------
+CPoly *FX_AddPoly( vec3_t *verts, vec2_t *st, int numVerts, 
+							vec3_t vel, vec3_t accel,
+							float alpha1, float alpha2, float alphaParm,
+							vec3_t rgb1, vec3_t rgb2, float rgbParm,
+							vec3_t rotationDelta, float bounce, int motionDelay,
+							int killTime, qhandle_t shader, int flags )
+{
+	if ( theFxHelper.mFrameTime < 1 || !verts )
+	{ // disallow adding effects when the system is paused or the user doesn't pass in a vert array
+		return 0;
+	}
+
+	CPoly *fx = new CPoly;
+
+	if ( fx )
+	{
+		// Do a cheesy copy of the verts and texture coords into our own structure
+		for ( int i = 0; i < numVerts; i++ )
+		{
+			VectorCopy( verts[i], fx->mOrg[i] );
+			Vector2Copy( st[i], fx->mST[i] );
+		}
+
+		fx->SetVel( vel );
+		fx->SetAccel( accel );
+
+		// RGB----------------
+		fx->SetRGBStart( rgb1 );
+		fx->SetRGBEnd( rgb2 );
+
+		if (( flags & FX_RGB_PARM_MASK ) == FX_RGB_WAVE )
+		{
+			fx->SetRGBParm( rgbParm * PI * 0.001f );
+		}
+		else if ( flags & FX_RGB_PARM_MASK )
+		{
+			// rgbParm should be a value from 0-100..
+			fx->SetRGBParm( rgbParm * 0.01f * killTime + theFxHelper.mTime );
+		}
+
+		// Alpha----------------
+		fx->SetAlphaStart( alpha1 );
+		fx->SetAlphaEnd( alpha2 );
+
+		if (( flags & FX_ALPHA_PARM_MASK ) == FX_ALPHA_WAVE )
+		{
+			fx->SetAlphaParm( alphaParm * PI * 0.001f );
+		}
+		else if ( flags & FX_ALPHA_PARM_MASK )
+		{
+			fx->SetAlphaParm( alphaParm * 0.01f * killTime + theFxHelper.mTime );
+		}
+
+		fx->SetFlags( flags );
+		fx->SetShader( shader );
+		fx->SetRot( rotationDelta );
+		fx->SetElasticity( bounce );
+		fx->SetMotionTimeStamp( motionDelay );
+		fx->SetNumVerts( numVerts );
+
+		// Now that we've set our data up, let's process it into a useful format
+		fx->PolyInit();
+
+		FX_AddPrimitive( (CEffect**)&fx, killTime );
+	}
+
+	return fx;
+}
+
+
+//-------------------------
+//  FX_AddFlash
+//-------------------------
+CFlash *FX_AddFlash( vec3_t origin, 
+					float size1, float size2, float sizeParm,
+					float alpha1, float alpha2, float alphaParm,
+					vec3_t sRGB, vec3_t eRGB, float rgbParm,
+					int killTime, qhandle_t shader, int flags, 
+					EMatImpactEffect matImpactFX /*MATIMPACTFX_NONE*/, int fxParm /*-1*/ )
+{
+	if ( theFxHelper.mFrameTime < 1 )
+	{ // disallow adding new effects when the system is paused
+		return 0;
+	}
+
+	if (!shader)
+	{ //yeah..this is bad, I guess, but SP seems to handle it by not drawing the flash, so I will too.
+		assert(shader);
+		return 0;
+	}
+
+	CFlash *fx = new CFlash;
+
+	if ( fx )
+	{
+		fx->SetMatImpactFX(matImpactFX);
+		fx->SetMatImpactParm(fxParm);
+		fx->SetOrigin1( origin );
+
+		// RGB----------------
+		fx->SetRGBStart( sRGB );
+		fx->SetRGBEnd( eRGB );
+
+		if (( flags & FX_RGB_PARM_MASK ) == FX_RGB_WAVE )
+		{
+			fx->SetRGBParm( rgbParm * PI * 0.001f );
+		}
+		else if ( flags & FX_RGB_PARM_MASK )
+		{
+			// rgbParm should be a value from 0-100..
+			fx->SetRGBParm( rgbParm * 0.01f * killTime + theFxHelper.mTime );
+		}
+
+		// Alpha----------------
+		fx->SetAlphaStart( alpha1 );
+		fx->SetAlphaEnd( alpha2 );
+
+		if (( flags & FX_ALPHA_PARM_MASK ) == FX_ALPHA_WAVE )
+		{
+			fx->SetAlphaParm( alphaParm * PI * 0.001f );
+		}
+		else if ( flags & FX_ALPHA_PARM_MASK )
+		{
+			fx->SetAlphaParm( alphaParm * 0.01f * killTime + theFxHelper.mTime );
+		}
+
+		// Size----------------
+		fx->SetSizeStart( size1 );
+		fx->SetSizeEnd( size2 );
+
+		if (( flags & FX_SIZE_PARM_MASK ) == FX_SIZE_WAVE )
+		{
+			fx->SetSizeParm( sizeParm * PI * 0.001f );
+		}
+		else if ( flags & FX_SIZE_PARM_MASK )
+		{
+			fx->SetSizeParm( sizeParm * 0.01f * killTime + theFxHelper.mTime );
+		}
+
+		fx->SetShader( shader );
+		fx->SetFlags( flags );
+
+//		fx->SetSTScale( 1.0f, 1.0f );
+		
+		fx->Init();
+
+		FX_AddPrimitive( (CEffect**)&fx, killTime );
+	}
+
+	return fx;
+}
+
+//-------------------------
+//  FX_AddBezier
+//-------------------------
+CBezier *FX_AddBezier( vec3_t start, vec3_t end, 
+								vec3_t control1, vec3_t control1Vel,
+								vec3_t control2, vec3_t control2Vel,
+								float size1, float size2, float sizeParm,
+								float alpha1, float alpha2, float alphaParm,
+								vec3_t sRGB, vec3_t eRGB, float rgbParm,
+								int killTime, qhandle_t shader, int flags )
+{
+	if ( theFxHelper.mFrameTime < 1 )
+	{ // disallow adding new effects when the system is paused
+		return 0;
+	}
+
+	CBezier *fx = new CBezier;
+
+	if ( fx )
+	{
+		fx->SetOrigin1( start );
+		fx->SetOrigin2( end );
+
+		fx->SetControlPoints( control1, control2 );
+		fx->SetControlVel( control1Vel, control2Vel );
+
+		// RGB----------------
+		fx->SetRGBStart( sRGB );
+		fx->SetRGBEnd( eRGB );
+
+		if (( flags & FX_RGB_PARM_MASK ) == FX_RGB_WAVE )
+		{
+			fx->SetRGBParm( rgbParm * PI * 0.001f );
+		}
+		else if ( flags & FX_RGB_PARM_MASK )
+		{
+			// rgbParm should be a value from 0-100..
+			fx->SetRGBParm( rgbParm * 0.01f * killTime + theFxHelper.mTime );
+		}
+
+		// Alpha----------------
+		fx->SetAlphaStart( alpha1 );
+		fx->SetAlphaEnd( alpha2 );
+
+		if (( flags & FX_ALPHA_PARM_MASK ) == FX_ALPHA_WAVE )
+		{
+			fx->SetAlphaParm( alphaParm * PI * 0.001f );
+		}
+		else if ( flags & FX_ALPHA_PARM_MASK )
+		{
+			fx->SetAlphaParm( alphaParm * 0.01f * killTime + theFxHelper.mTime );
+		}
+
+		// Size----------------
+		fx->SetSizeStart( size1 );
+		fx->SetSizeEnd( size2 );
+
+		if (( flags & FX_SIZE_PARM_MASK ) == FX_SIZE_WAVE )
+		{
+			fx->SetSizeParm( sizeParm * PI * 0.001f );
+		}
+		else if ( flags & FX_SIZE_PARM_MASK )
+		{
+			fx->SetSizeParm( sizeParm * 0.01f * killTime + theFxHelper.mTime );
+		}
+
+		fx->SetShader( shader );
+		fx->SetFlags( flags );
+
+		fx->SetSTScale( 1.0f, 1.0f );
+
+		FX_AddPrimitive( (CEffect**)&fx, killTime );
+	}
+
+	return fx;
+}
diff --git a/codemp/client/FxUtil.h b/codemp/client/FxUtil.h
new file mode 100644
index 0000000..92e9175
--- /dev/null
+++ b/codemp/client/FxUtil.h
@@ -0,0 +1,116 @@
+
+#if !defined(FX_PRIMITIVES_H_INC)
+	#include "FxPrimitives.h"
+#endif
+
+#ifndef FX_UTIL_H_INC
+#define FX_UTIL_H_INC
+
+
+bool	FX_Free( bool templates );	// ditches all active effects;
+int		FX_Init( refdef_t* refdef );	// called in CG_Init to purge the fx system.
+void	FX_SetRefDef(refdef_t *refdef);
+void	FX_Add( bool portal );		// called every cgame frame to add all fx into the scene.
+void	FX_Stop( void );	// ditches all active effects without touching the templates.
+
+
+CParticle *FX_AddParticle( vec3_t org, vec3_t vel, vec3_t accel, 
+							float size1, float size2, float sizeParm, 
+							float alpha1, float alpha2, float alphaParm, 
+							vec3_t rgb1, vec3_t rgb2, float rgbParm,
+							float rotation, float rotationDelta,
+							vec3_t min, vec3_t max, float elasticity, 
+							int deathID, int impactID,
+							int killTime, qhandle_t shader, int flags,
+							EMatImpactEffect matImpactFX = MATIMPACTFX_NONE, int fxParm = -1, 
+							int iGhoul2=0, int entNum=-1, int modelNum=-1, int boltNum=-1);
+
+CLine *FX_AddLine( vec3_t start, vec3_t end, 
+							float size1, float size2, float sizeParm,
+							float alpha1, float alpha2, float alphaParm,
+							vec3_t rgb1, vec3_t rgb2, float rgbParm,
+							int killTime, qhandle_t shader, int flags,
+							EMatImpactEffect matImpactFX = MATIMPACTFX_NONE, int fxParm = -1,
+							int iGhoul2=0, int entNum=-1, int modelNum=-1, int boltNum=-1);
+
+CElectricity *FX_AddElectricity( vec3_t start, vec3_t end, float size1, float size2, float sizeParm,
+							float alpha1, float alpha2, float alphaParm,
+							vec3_t sRGB, vec3_t eRGB, float rgbParm,
+							float chaos, int killTime, qhandle_t shader, int flags,
+							EMatImpactEffect matImpactFX = MATIMPACTFX_NONE, int fxParm = -1,
+							int iGhoul2=0, int entNum=-1, int modelNum=-1, int boltNum=-1);
+
+CTail *FX_AddTail( vec3_t org, vec3_t vel, vec3_t accel, 
+							float size1, float size2, float sizeParm, 
+							float length1, float length2, float lengthParm,
+							float alpha1, float alpha2, float alphaParm,
+							vec3_t rgb1, vec3_t rgb2, float rgbParm,
+							vec3_t min, vec3_t max, float elasticity, 
+							int deathID, int impactID,
+							int killTime, qhandle_t shader, int flags,
+							EMatImpactEffect matImpactFX = MATIMPACTFX_NONE, int fxParm = -1,
+							int iGhoul2=0, int entNum=-1, int modelNum=-1, int boltNum=-1);
+
+CCylinder *FX_AddCylinder( vec3_t start, vec3_t normal, 
+							float size1s, float size1e, float size1Parm,
+							float size2s, float size2e, float size2Parm,
+							float length1, float length2, float lengthParm,
+							float alpha1, float alpha2, float alphaParm,
+							vec3_t rgb1, vec3_t rgb2, float rgbParm,
+							int killTime, qhandle_t shader, int flags,
+							EMatImpactEffect matImpactFX = MATIMPACTFX_NONE, int fxParm = -1,
+							int iGhoul2=0, int entNum=-1, int modelNum=-1, int boltNum=-1,
+							qboolean traceEnd = qfalse);
+
+CEmitter *FX_AddEmitter( vec3_t org, vec3_t vel, vec3_t accel,
+							float size1, float size2, float sizeParm,
+							float alpha1, float alpha2, float alphaParm,
+							vec3_t rgb1, vec3_t rgb2, float rgbParm,
+							vec3_t angs, vec3_t deltaAngs,
+							vec3_t min, vec3_t max, float elasticity, 
+							int deathID, int impactID, int emitterID,
+							float density, float variance,
+							int killTime, qhandle_t model, int flags,
+							EMatImpactEffect matImpactFX = MATIMPACTFX_NONE, int fxParm = -1,
+							int iGhoul2=0, int entNum=-1, int modelNum=-1, int boltNum=-1);
+
+CLight *FX_AddLight( vec3_t org, float size1, float size2, float sizeParm,
+							vec3_t rgb1, vec3_t rgb2, float rgbParm,
+							int killTime, int flags,
+							EMatImpactEffect matImpactFX = MATIMPACTFX_NONE, int fxParm = -1,
+							int iGhoul2=0, int entNum=-1, int modelNum=-1, int boltNum=-1);
+
+COrientedParticle *FX_AddOrientedParticle( vec3_t org, vec3_t norm, vec3_t vel, vec3_t accel,
+							float size1, float size2, float sizeParm,
+							float alpha1, float alpha2, float alphaParm,
+							vec3_t rgb1, vec3_t rgb2, float rgbParm,
+							float rotation, float rotationDelta,
+							vec3_t min, vec3_t max, float bounce,
+							int deathID, int impactID,
+							int killTime, qhandle_t shader, int flags,
+							EMatImpactEffect matImpactFX = MATIMPACTFX_NONE, int fxParm = -1,
+							int iGhoul2=0, int entNum=-1, int modelNum=-1, int boltNum=-1);
+
+CPoly *FX_AddPoly( vec3_t *verts, vec2_t *st, int numVerts,
+							vec3_t vel, vec3_t accel,
+							float alpha1, float alpha2, float alphaParm,
+							vec3_t rgb1, vec3_t rgb2, float rgbParm,
+							vec3_t rotationDelta, float bounce, int motionDelay,
+							int killTime, qhandle_t shader, int flags );
+
+CFlash *FX_AddFlash( vec3_t origin, 
+							float size1, float size2, float sizeParm,
+							float alpha1, float alpha2, float alphaParm,
+							vec3_t sRGB, vec3_t eRGB, float rgbParm,
+							int killTime, qhandle_t shader, int flags = 0,
+							EMatImpactEffect matImpactFX = MATIMPACTFX_NONE, int fxParm = -1);
+
+CBezier *FX_AddBezier( vec3_t start, vec3_t end, 
+								vec3_t control1, vec3_t control1Vel,
+								vec3_t control2, vec3_t control2Vel,
+								float size1, float size2, float sizeParm,
+								float alpha1, float alpha2, float alphaParm,
+								vec3_t sRGB, vec3_t eRGB, float rgbParm,
+								int killTime, qhandle_t shader, int flags = 0 );
+
+#endif //FX_UTIL_H_INC
\ No newline at end of file
diff --git a/codemp/client/OpenAL/al.h b/codemp/client/OpenAL/al.h
new file mode 100644
index 0000000..0afa74b
--- /dev/null
+++ b/codemp/client/OpenAL/al.h
@@ -0,0 +1,564 @@
+#ifndef _AL_H_
+#define _AL_H_
+
+/**
+ * OpenAL cross platform audio library
+ * Copyright (C) 1999-2000 by authors.
+ * This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ *  Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the
+ *  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ *  Boston, MA  02111-1307, USA.
+ * Or go to http://www.gnu.org/copyleft/lgpl.html
+ */
+#include "altypes.h"
+
+#ifdef _XBOX
+ #define ALAPI
+ #define ALAPIENTRY
+ #define AL_CALLBACK
+#else
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef _WIN32
+ #ifdef _OPENAL32LIB
+  #define ALAPI __declspec(dllexport)
+ #else
+  #define ALAPI __declspec(dllimport)
+ #endif
+ #define ALAPIENTRY __cdecl
+ #define AL_CALLBACK
+#else
+ #ifdef TARGET_OS_MAC
+  #if TARGET_OS_MAC
+   #pragma export on
+  #endif
+ #endif
+ #define ALAPI
+ #define ALAPIENTRY __cdecl
+ #define AL_CALLBACK
+#endif
+#endif
+
+#define OPENAL
+
+#ifndef AL_NO_PROTOTYPES
+
+/**
+ * OpenAL Maintenance Functions
+ * Initialization and exiting.
+ * State Management and Query.
+ * Error Handling.
+ * Extension Support.
+ */
+
+/** State management. */
+ALAPI ALvoid	ALAPIENTRY alEnable( ALenum capability );
+ALAPI ALvoid	ALAPIENTRY alDisable( ALenum capability ); 
+ALAPI ALboolean ALAPIENTRY alIsEnabled( ALenum capability ); 
+
+/** Application preferences for driver performance choices. */
+ALAPI ALvoid	ALAPIENTRY alHint( ALenum target, ALenum mode );
+
+/** State retrieval. */
+ALAPI ALboolean ALAPIENTRY alGetBoolean( ALenum param );
+ALAPI ALint		ALAPIENTRY alGetInteger( ALenum param );
+ALAPI ALfloat	ALAPIENTRY alGetFloat( ALenum param );
+ALAPI ALdouble	ALAPIENTRY alGetDouble( ALenum param );
+ALAPI ALvoid	ALAPIENTRY alGetBooleanv( ALenum param, ALboolean* data );
+ALAPI ALvoid	ALAPIENTRY alGetIntegerv( ALenum param, ALint* data );
+ALAPI ALvoid	ALAPIENTRY alGetFloatv( ALenum param, ALfloat* data );
+ALAPI ALvoid	ALAPIENTRY alGetDoublev( ALenum param, ALdouble* data );
+ALAPI ALubyte*	ALAPIENTRY alGetString( ALenum param );
+
+/**
+ * Error support.
+ * Obtain the most recent error generated in the AL state machine.
+ */
+ALAPI ALenum	ALAPIENTRY alGetError( ALvoid );
+
+#ifdef _XBOX
+/**
+ * Update cycle.
+ */
+ALAPI ALvoid	ALAPIENTRY alUpdate( ALvoid );
+
+/**
+ * Returns a global state parameter.
+ */
+ALAPI ALvoid	ALAPIENTRY alGeti( ALenum param, ALint* value );
+
+/**
+ * Adjust the size of the sound buffer pool.
+ */
+ALAPI ALvoid	ALAPIENTRY alResizePool( ALuint size );
+#endif
+
+/** 
+ * Extension support.
+ * Obtain the address of a function (usually an extension)
+ *  with the name fname. All addresses are context-independent. 
+ */
+ALAPI ALboolean ALAPIENTRY alIsExtensionPresent( ALubyte* fname );
+
+
+/** 
+ * Extension support.
+ * Obtain the address of a function (usually an extension)
+ *  with the name fname. All addresses are context-independent. 
+ */
+ALAPI ALvoid*	ALAPIENTRY alGetProcAddress( ALubyte* fname );
+
+
+/**
+ * Extension support.
+ * Obtain the integer value of an enumeration (usually an extension) with the name ename. 
+ */
+ALAPI ALenum	ALAPIENTRY alGetEnumValue( ALubyte* ename );
+
+
+
+
+/**
+ * LISTENER
+ * Listener is the sample position for a given context.
+ * The multi-channel (usually stereo) output stream generated
+ *  by the mixer is parametrized by this Listener object:
+ *  its position and velocity relative to Sources, within
+ *  occluder and reflector geometry.
+ */
+
+
+
+#ifdef _XBOX
+/**
+ * Listener create and delete
+ */
+ALAPI ALvoid	ALAPIENTRY alGenListeners( ALsizei n, ALuint* listeners );
+ALAPI ALvoid	ALAPIENTRY alDeleteListeners( ALsizei n, ALuint* listeners );
+#endif
+
+// VV's Console version of openAL includes multiple listener support,
+// as an extra first arg to the alListener functions. We wrap that up
+// in a macro here, to make the following more concise.
+#ifdef _XBOX
+#define AL_VV_LISTENER ALuint listener,
+#else
+#define AL_VV_LISTENER
+#endif
+
+/**
+ *
+ * Listener Environment:  default 0.
+ */
+ALAPI ALvoid	ALAPIENTRY alListeneri( AL_VV_LISTENER ALenum param, ALint value );
+
+
+/**
+ *
+ * Listener Gain:  default 1.0f.
+ */
+ALAPI ALvoid	ALAPIENTRY alListenerf( AL_VV_LISTENER ALenum param, ALfloat value );
+
+
+/**  
+ *
+ * Listener Position.
+ * Listener Velocity.
+ */
+ALAPI ALvoid	ALAPIENTRY alListener3f( AL_VV_LISTENER ALenum param, ALfloat v1, ALfloat v2, ALfloat v3 ); 
+
+
+/**
+ *
+ * Listener Position:        ALfloat[3]
+ * Listener Velocity:        ALfloat[3]
+ * Listener Orientation:     ALfloat[6]  (forward and up vector).
+ */
+ALAPI ALvoid	ALAPIENTRY alListenerfv( AL_VV_LISTENER ALenum param, ALfloat* values ); 
+
+ALAPI ALvoid	ALAPIENTRY alGetListeneri( AL_VV_LISTENER ALenum param, ALint* value );
+ALAPI ALvoid	ALAPIENTRY alGetListenerf( AL_VV_LISTENER ALenum param, ALfloat* value );
+ALAPI ALvoid	ALAPIENTRY alGetListener3f( AL_VV_LISTENER ALenum param, ALfloat* v1, ALfloat* v2, ALfloat* v3 ); 
+ALAPI ALvoid	ALAPIENTRY alGetListenerfv( AL_VV_LISTENER ALenum param, ALfloat* values ); 
+
+
+/**
+ * SOURCE
+ * Source objects are by default localized. Sources
+ *  take the PCM data provided in the specified Buffer,
+ *  apply Source-specific modifications, and then
+ *  submit them to be mixed according to spatial 
+ *  arrangement etc.
+ */
+
+
+
+/** Create Source objects. */
+#ifdef _XBOX
+ALAPI ALvoid	ALAPIENTRY alGenSources2D( ALsizei n, ALuint* sources ); 
+ALAPI ALvoid	ALAPIENTRY alGenSources3D( ALsizei n, ALuint* sources ); 
+#else
+ALAPI ALvoid	ALAPIENTRY alGenSources( ALsizei n, ALuint* sources ); 
+#endif
+
+/** Delete Source objects. */
+ALAPI ALvoid	ALAPIENTRY alDeleteSources( ALsizei n, ALuint* sources );
+
+/** Verify a handle is a valid Source. */ 
+ALAPI ALboolean ALAPIENTRY alIsSource( ALuint id ); 
+
+/** Set an integer parameter for a Source object. */
+ALAPI ALvoid	ALAPIENTRY alSourcei( ALuint source, ALenum param, ALint value ); 
+ALAPI ALvoid	ALAPIENTRY alSourcef( ALuint source, ALenum param, ALfloat value ); 
+ALAPI ALvoid	ALAPIENTRY alSource3f( ALuint source, ALenum param, ALfloat v1, ALfloat v2, ALfloat v3 );
+ALAPI ALvoid	ALAPIENTRY alSourcefv( ALuint source, ALenum param, ALfloat* values ); 
+
+/** Get an integer parameter for a Source object. */
+ALAPI ALvoid	ALAPIENTRY alGetSourcei( ALuint source,  ALenum param, ALint* value );
+ALAPI ALvoid	ALAPIENTRY alGetSourcef( ALuint source,  ALenum param, ALfloat* value );
+ALAPI ALvoid	ALAPIENTRY alGetSource3f( ALuint source,  ALenum param, ALfloat* v1, ALfloat* v2, ALfloat* v3 );
+ALAPI ALvoid	ALAPIENTRY alGetSourcefv( ALuint source, ALenum param, ALfloat* values );
+
+ALAPI ALvoid	ALAPIENTRY alSourcePlayv( ALsizei n, ALuint *sources );
+ALAPI ALvoid	ALAPIENTRY alSourcePausev( ALsizei n, ALuint *sources );
+ALAPI ALvoid	ALAPIENTRY alSourceStopv( ALsizei n, ALuint *sources );
+ALAPI ALvoid	ALAPIENTRY alSourceRewindv(ALsizei n,ALuint *sources);
+
+/** Activate a source, start replay. */
+ALAPI ALvoid	ALAPIENTRY alSourcePlay( ALuint source );
+
+/**
+ * Pause a source, 
+ *  temporarily remove it from the mixer list.
+ */
+ALAPI ALvoid	ALAPIENTRY alSourcePause( ALuint source );
+
+/**
+ * Stop a source,
+ *  temporarily remove it from the mixer list,
+ *  and reset its internal state to pre-Play.
+ * To remove a Source completely, it has to be
+ *  deleted following Stop, or before Play.
+ */
+ALAPI ALvoid	ALAPIENTRY alSourceStop( ALuint source );
+
+/**
+ * Rewinds a source, 
+ *  temporarily remove it from the mixer list,
+ *  and reset its internal state to pre-Play.
+ */
+ALAPI ALvoid	ALAPIENTRY alSourceRewind( ALuint source );
+
+
+
+/**
+ * BUFFER
+ * Buffer objects are storage space for sample data.
+ * Buffers are referred to by Sources. There can be more than
+ *  one Source using the same Buffer data. If Buffers have
+ *  to be duplicated on a per-Source basis, the driver has to
+ *  take care of allocation, copying, and deallocation as well
+ *  as propagating buffer data changes.
+ */
+
+
+
+
+/** Buffer object generation. */
+ALAPI ALvoid 	ALAPIENTRY alGenBuffers( ALsizei n, ALuint* buffers );
+ALAPI ALvoid	ALAPIENTRY alDeleteBuffers( ALsizei n, ALuint* buffers );
+ALAPI ALboolean ALAPIENTRY alIsBuffer( ALuint buffer );
+
+/**
+ * Specify the data to be filled into a buffer.
+ */
+ALAPI ALvoid	ALAPIENTRY alBufferData( ALuint   buffer,
+										 ALenum   format,
+										 ALvoid*  data,
+										 ALsizei  size,
+										 ALsizei  freq );
+
+
+ALAPI ALvoid	ALAPIENTRY alGetBufferi( ALuint buffer, ALenum param, ALint*   value );
+ALAPI ALvoid	ALAPIENTRY alGetBufferf( ALuint buffer, ALenum param, ALfloat* value );
+
+
+
+
+/**
+ * Queue stuff
+ */
+
+ALAPI ALvoid	ALAPIENTRY alSourceQueueBuffers( ALuint source, ALsizei n, ALuint* buffers );
+ALAPI ALvoid	ALAPIENTRY alSourceUnqueueBuffers( ALuint source, ALsizei n, ALuint* buffers );
+
+
+
+
+#ifdef _XBOX
+/**
+ * STREAM
+ * Stream objects encapsulate traditional sound stream and
+ *  act as both sources and buffers.  They emit sound and 
+ *  manage sound data.
+ */
+
+ALAPI ALvoid	ALAPIENTRY alGenStream( ALvoid );
+ALAPI ALvoid	ALAPIENTRY alDeleteStream( ALvoid );
+
+ALAPI ALvoid	ALAPIENTRY alStreamStop( ALvoid );
+ALAPI ALvoid	ALAPIENTRY alStreamPlay( ALsizei offset, ALint file, ALint loop );
+
+ALAPI ALvoid	ALAPIENTRY alStreamf( ALenum param, ALfloat value );
+
+ALAPI ALvoid	ALAPIENTRY alGetStreamf( ALenum param, ALfloat* value );
+ALAPI ALvoid	ALAPIENTRY alGetStreami( ALenum param, ALint* value );
+#endif
+
+
+/**
+ * Knobs and dials
+ */
+ALAPI ALvoid	ALAPIENTRY alDistanceModel( ALenum value );
+ALAPI ALvoid	ALAPIENTRY alDopplerFactor( ALfloat value );
+ALAPI ALvoid	ALAPIENTRY alDopplerVelocity( ALfloat value );
+#ifdef _XBOX
+ALAPI ALvoid	ALAPIENTRY alGain( ALfloat value );
+#endif
+
+#else /* AL_NO_PROTOTYPES */
+
+/**
+ * OpenAL Maintenance Functions
+ * Initialization and exiting.
+ * State Management and Query.
+ * Error Handling.
+ * Extension Support.
+ */
+
+/** State management. */
+ALAPI ALvoid	ALAPIENTRY (*alEnable)( ALenum capability );
+ALAPI ALvoid	ALAPIENTRY (*alDisable)( ALenum capability ); 
+ALAPI ALboolean ALAPIENTRY (*alIsEnabled)( ALenum capability ); 
+
+/** Application preferences for driver performance choices. */
+ALAPI ALvoid	ALAPIENTRY (*alHint)( ALenum target, ALenum mode );
+
+/** State retrieval. */
+ALAPI ALboolean ALAPIENTRY (*alGetBoolean)( ALenum param );
+ALAPI ALint		ALAPIENTRY (*alGetInteger)( ALenum param );
+ALAPI ALfloat	ALAPIENTRY (*alGetFloat)( ALenum param );
+ALAPI ALdouble	ALAPIENTRY (*alGetDouble)( ALenum param );
+ALAPI ALvoid	ALAPIENTRY (*alGetBooleanv)( ALenum param, ALboolean* data );
+ALAPI ALvoid	ALAPIENTRY (*alGetIntegerv)( ALenum param, ALint* data );
+ALAPI ALvoid	ALAPIENTRY (*alGetFloatv)( ALenum param, ALfloat* data );
+ALAPI ALvoid	ALAPIENTRY (*alGetDoublev)( ALenum param, ALdouble* data );
+ALAPI ALubyte*	ALAPIENTRY (*alGetString)( ALenum param );
+
+/**
+ * Error support.
+ * Obtain the most recent error generated in the AL state machine.
+ */
+ALAPI ALenum	ALAPIENTRY (*alGetError)( ALvoid );
+
+
+/** 
+ * Extension support.
+ * Obtain the address of a function (usually an extension)
+ *  with the name fname. All addresses are context-independent. 
+ */
+ALAPI ALboolean ALAPIENTRY (*alIsExtensionPresent)( ALubyte* fname );
+
+
+/** 
+ * Extension support.
+ * Obtain the address of a function (usually an extension)
+ *  with the name fname. All addresses are context-independent. 
+ */
+ALAPI ALvoid*	ALAPIENTRY (*alGetProcAddress)( ALubyte* fname );
+
+
+/**
+ * Extension support.
+ * Obtain the integer value of an enumeration (usually an extension) with the name ename. 
+ */
+ALAPI ALenum	ALAPIENTRY (*alGetEnumValue)( ALubyte* ename );
+
+
+
+
+/**
+ * LISTENER
+ * Listener is the sample position for a given context.
+ * The multi-channel (usually stereo) output stream generated
+ *  by the mixer is parametrized by this Listener object:
+ *  its position and velocity relative to Sources, within
+ *  occluder and reflector geometry.
+ */
+
+
+
+/**
+ *
+ * Listener Environment:  default 0.
+ */
+ALAPI ALvoid	ALAPIENTRY (*alListeneri)( ALenum param, ALint value );
+
+
+/**
+ *
+ * Listener Gain:  default 1.0f.
+ */
+ALAPI ALvoid	ALAPIENTRY (*alListenerf)( ALenum param, ALfloat value );
+
+
+/**  
+ *
+ * Listener Position.
+ * Listener Velocity.
+ */
+ALAPI ALvoid	ALAPIENTRY (*alListener3f)( ALenum param, ALfloat v1, ALfloat v2, ALfloat v3 ); 
+
+
+/**
+ *
+ * Listener Position:        ALfloat[3]
+ * Listener Velocity:        ALfloat[3]
+ * Listener Orientation:     ALfloat[6]  (forward and up vector).
+ */
+ALAPI ALvoid	ALAPIENTRY (*alListenerfv)( ALenum param, ALfloat* values ); 
+
+ALAPI ALvoid	ALAPIENTRY (*alGetListeneri)( ALenum param, ALint* value );
+ALAPI ALvoid	ALAPIENTRY (*alGetListenerf)( ALenum param, ALfloat* value );
+ALAPI ALvoid	ALAPIENTRY (*alGetListener3f)( ALenum param, ALfloat* v1, ALfloat* v2, ALfloat* v3 ); 
+ALAPI ALvoid	ALAPIENTRY (*alGetListenerfv)( ALenum param, ALfloat* values ); 
+
+
+/**
+ * SOURCE
+ * Source objects are by default localized. Sources
+ *  take the PCM data provided in the specified Buffer,
+ *  apply Source-specific modifications, and then
+ *  submit them to be mixed according to spatial 
+ *  arrangement etc.
+ */
+
+
+
+/** Create Source objects. */
+ALAPI ALvoid	ALAPIENTRY (*alGenSources)( ALsizei n, ALuint* sources ); 
+
+/** Delete Source objects. */
+ALAPI ALvoid	ALAPIENTRY (*alDeleteSources)( ALsizei n, ALuint* sources );
+
+/** Verify a handle is a valid Source. */ 
+ALAPI ALboolean ALAPIENTRY (*alIsSource)( ALuint id ); 
+
+/** Set an integer parameter for a Source object. */
+ALAPI ALvoid	ALAPIENTRY (*alSourcei)( ALuint source, ALenum param, ALint value ); 
+ALAPI ALvoid	ALAPIENTRY (*alSourcef)( ALuint source, ALenum param, ALfloat value ); 
+ALAPI ALvoid	ALAPIENTRY (*alSource3f)( ALuint source, ALenum param, ALfloat v1, ALfloat v2, ALfloat v3 );
+ALAPI ALvoid	ALAPIENTRY (*alSourcefv)( ALuint source, ALenum param, ALfloat* values ); 
+
+/** Get an integer parameter for a Source object. */
+ALAPI ALvoid	ALAPIENTRY (*alGetSourcei)( ALuint source,  ALenum param, ALint* value );
+ALAPI ALvoid	ALAPIENTRY (*alGetSourcef)( ALuint source,  ALenum param, ALfloat* value );
+ALAPI ALvoid	ALAPIENTRY (*alGetSourcefv)( ALuint source, ALenum param, ALfloat* values );
+
+ALAPI ALvoid	ALAPIENTRY (*alSourcePlayv)( ALsizei n, ALuint *sources );
+ALAPI ALvoid	ALAPIENTRY (*alSourceStopv)( ALsizei n, ALuint *sources );
+
+/** Activate a source, start replay. */
+ALAPI ALvoid	ALAPIENTRY (*alSourcePlay)( ALuint source );
+
+/**
+ * Pause a source, 
+ *  temporarily remove it from the mixer list.
+ */
+ALAPI ALvoid	ALAPIENTRY (*alSourcePause)( ALuint source );
+
+/**
+ * Stop a source,
+ *  temporarily remove it from the mixer list,
+ *  and reset its internal state to pre-Play.
+ * To remove a Source completely, it has to be
+ *  deleted following Stop, or before Play.
+ */
+ALAPI ALvoid	ALAPIENTRY (*alSourceStop)( ALuint source );
+
+
+
+/**
+ * BUFFER
+ * Buffer objects are storage space for sample data.
+ * Buffers are referred to by Sources. There can be more than
+ *  one Source using the same Buffer data. If Buffers have
+ *  to be duplicated on a per-Source basis, the driver has to
+ *  take care of allocation, copying, and deallocation as well
+ *  as propagating buffer data changes.
+ */
+
+
+
+
+/** Buffer object generation. */
+ALAPI ALvoid 	ALAPIENTRY (*alGenBuffers)( ALsizei n, ALuint* buffers );
+ALAPI ALvoid	ALAPIENTRY (*alDeleteBuffers)( ALsizei n, ALuint* buffers );
+ALAPI ALboolean ALAPIENTRY (*alIsBuffer)( ALuint buffer );
+
+/**
+ * Specify the data to be filled into a buffer.
+ */
+ALAPI ALvoid	ALAPIENTRY (*alBufferData)( ALuint   buffer,
+											ALenum   format,
+											ALvoid*  data,
+											ALsizei  size,
+											ALsizei  freq );
+
+ALAPI ALvoid	ALAPIENTRY (*alGetBufferi)( ALuint buffer, ALenum param, ALint*   value );
+ALAPI ALvoid	ALAPIENTRY (*alGetBufferf)( ALuint buffer, ALenum param, ALfloat* value );
+
+
+
+
+/**
+ * Queue stuff
+ */
+ALAPI ALvoid	ALAPIENTRY (*alSourceQueueBuffers)( ALuint source, ALsizei n, ALuint* buffers );
+ALAPI ALvoid	ALAPIENTRY (*alSourceUnqueueBuffers)( ALuint source, ALsizei n, ALuint* buffers );
+
+/**
+ * Knobs and dials
+ */
+ALAPI ALvoid	ALAPIENTRY (*alDistanceModel)( ALenum value );
+ALAPI ALvoid	ALAPIENTRY (*alDopplerFactor)( ALfloat value );
+ALAPI ALvoid	ALAPIENTRY (*alDopplerVelocity)( ALfloat value );
+
+#endif /* AL_NO_PROTOTYPES */
+
+#ifdef TARGET_OS_MAC
+ #if TARGET_OS_MAC
+  #pragma export off
+ #endif
+#endif
+
+#ifndef _XBOX
+#ifdef __cplusplus
+}
+#endif
+#endif
+
+#endif
diff --git a/codemp/client/OpenAL/alc.h b/codemp/client/OpenAL/alc.h
new file mode 100644
index 0000000..ab1fd3c
--- /dev/null
+++ b/codemp/client/OpenAL/alc.h
@@ -0,0 +1,97 @@
+#ifndef _ALC_H_
+#define _ALC_H_
+
+#include "altypes.h"
+#include "alctypes.h"
+
+#ifdef _XBOX
+ #define ALCAPI
+ #define ALCAPIENTRY
+#else
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef _WIN32
+ #ifdef _OPENAL32LIB
+  #define ALCAPI __declspec(dllexport)
+ #else
+  #define ALCAPI __declspec(dllimport)
+ #endif
+
+ typedef struct ALCdevice_struct ALCdevice;
+ typedef struct ALCcontext_struct ALCcontext;
+
+ #define ALCAPIENTRY __cdecl
+#else
+ #ifdef TARGET_OS_MAC
+  #if TARGET_OS_MAC
+   #pragma export on
+  #endif
+ #endif
+ #define ALCAPI
+ #define ALCAPIENTRY __cdecl
+#endif
+
+#endif
+
+#ifndef ALC_NO_PROTOTYPES
+
+ALCAPI ALCubyte*  ALCAPIENTRY alcGetString(ALCdevice *device,ALCenum param);
+ALCAPI ALCvoid    ALCAPIENTRY alcGetIntegerv(ALCdevice *device,ALCenum param,ALCsizei size,ALCint *data);
+
+ALCAPI ALCdevice* ALCAPIENTRY alcOpenDevice(ALCubyte *deviceName);
+ALCAPI ALCvoid    ALCAPIENTRY alcCloseDevice(ALCdevice *device);
+
+ALCAPI ALCcontext*ALCAPIENTRY alcCreateContext(ALCdevice *device,ALCint *attrList);
+ALCAPI ALCboolean ALCAPIENTRY alcMakeContextCurrent(ALCcontext *context);
+ALCAPI ALCvoid	  ALCAPIENTRY alcProcessContext(ALCcontext *context);
+ALCAPI ALCcontext*ALCAPIENTRY alcGetCurrentContext(ALCvoid);
+ALCAPI ALCdevice* ALCAPIENTRY alcGetContextsDevice(ALCcontext *context);
+ALCAPI ALCvoid	  ALCAPIENTRY alcSuspendContext(ALCcontext *context);
+ALCAPI ALCvoid    ALCAPIENTRY alcDestroyContext(ALCcontext *context);
+
+ALCAPI ALCenum	  ALCAPIENTRY alcGetError(ALCdevice *device);
+
+ALCAPI ALCboolean ALCAPIENTRY alcIsExtensionPresent(ALCdevice *device,ALCubyte *extName);
+ALCAPI ALCvoid *  ALCAPIENTRY alcGetProcAddress(ALCdevice *device,ALCubyte *funcName);
+ALCAPI ALCenum	  ALCAPIENTRY alcGetEnumValue(ALCdevice *device,ALCubyte *enumName);
+				
+#else /* AL_NO_PROTOTYPES */
+
+ALCAPI ALCubyte*  ALCAPIENTRY (*alcGetString)(ALCdevice *device,ALCenum param);
+ALCAPI ALCvoid    ALCAPIENTRY (*alcGetIntegerv)(ALCdevice * device,ALCenum param,ALCsizei size,ALCint *data);
+
+ALCAPI ALCdevice* ALCAPIENTRY (*alcOpenDevice)(ALubyte *deviceName);
+ALCAPI ALCvoid    ALCAPIENTRY (*alcCloseDevice)(ALCdevice *device);
+
+ALCAPI ALCcontext*ALCAPIENTRY (*alcCreateContext)(ALCdevice *device,ALCint *attrList);
+ALCAPI ALCboolean ALCAPIENTRY (*alcMakeContextCurrent)(ALCcontext *context);
+ALCAPI ALCvoid	  ALCAPIENTRY (*alcProcessContext)(ALCcontext *context);
+ALCAPI ALCcontext*ALCAPIENTRY (*alcGetCurrentContext)(ALCvoid);
+ALCAPI ALCdevice* ALCAPIENTRY (*alcGetContextsDevice)(ALCcontext *context);
+ALCAPI ALCvoid	  ALCAPIENTRY (*alcSuspendContext)(ALCcontext *context);
+ALCAPI ALCvoid    ALCAPIENTRY (*alcDestroyContext)(ALCcontext *context);
+
+ALCAPI ALCenum	  ALCAPIENTRY (*alcGetError)(ALCdevice *device);
+
+ALCAPI ALCboolean ALCAPIENTRY (*alcIsExtensionPresent)(ALCdevice *device,ALCubyte *extName);
+ALCAPI ALCvoid *  ALCAPIENTRY (*alcGetProcAddress)(ALCdevice *device,ALCubyte *funcName);
+ALCAPI ALCenum	  ALCAPIENTRY (*alcGetEnumValue)(ALCdevice *device,ALCubyte *enumName);
+
+#endif /* AL_NO_PROTOTYPES */
+
+#ifdef TARGET_OS_MAC
+ #if TARGET_OS_MAC
+  #pragma export off
+ #endif
+#endif
+
+#ifndef _XBOX
+#ifdef __cplusplus
+}
+#endif
+#endif
+
+#endif
diff --git a/codemp/client/OpenAL/alctypes.h b/codemp/client/OpenAL/alctypes.h
new file mode 100644
index 0000000..6450837
--- /dev/null
+++ b/codemp/client/OpenAL/alctypes.h
@@ -0,0 +1,133 @@
+#ifndef _ALCTYPES_H_
+#define _ALCTYPES_H_
+
+/**
+ * OpenAL cross platform audio library
+ * Copyright (C) 1999-2000 by authors.
+ * This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ *  Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the
+ *  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ *  Boston, MA  02111-1307, USA.
+ * Or go to http://www.gnu.org/copyleft/lgpl.html
+ */
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef _XBOX
+/** ALC device type. */
+typedef int ALCdevice;
+
+/** ALC context type. */
+typedef int ALCcontext;
+#endif
+
+/** ALC boolean type. */
+typedef char ALCboolean;
+
+/** ALC 8bit signed byte. */
+typedef char ALCbyte;
+
+/** ALC 8bit unsigned byte. */
+typedef unsigned char ALCubyte;
+
+/** ALC 16bit signed short integer type. */
+typedef short ALCshort;
+
+/** ALC 16bit unsigned short integer type. */
+typedef unsigned short ALCushort;
+
+/** ALC 32bit unsigned integer type. */
+typedef unsigned ALCuint;
+
+/** ALC 32bit signed integer type. */
+typedef int ALCint;
+
+/** ALC 32bit floating point type. */
+typedef float ALCfloat;
+
+/** ALC 64bit double point type. */
+typedef double ALCdouble;
+
+/** ALC 32bit type. */
+typedef unsigned int ALCsizei;
+
+/** ALC void type */
+typedef void ALCvoid;
+
+/** ALC enumerations. */
+typedef int ALCenum;
+
+/* Bad value. */
+#define ALC_INVALID                              (-1)
+
+/* Boolean False. */
+#define ALC_FALSE                                0
+
+/* Boolean True. */
+#define ALC_TRUE                                 1
+
+/** Errors: No Error. */
+#define ALC_NO_ERROR                             ALC_FALSE
+
+#define ALC_MAJOR_VERSION                        0x1000
+#define ALC_MINOR_VERSION                        0x1001
+#define ALC_ATTRIBUTES_SIZE                      0x1002
+#define ALC_ALL_ATTRIBUTES                       0x1003
+
+#define ALC_DEFAULT_DEVICE_SPECIFIER             0x1004
+#define ALC_DEVICE_SPECIFIER                     0x1005
+#define ALC_EXTENSIONS                           0x1006
+
+#define ALC_FREQUENCY							 0x1007
+#define	ALC_REFRESH								 0x1008
+#define ALC_SYNC								 0x1009
+
+/** 
+ * The device argument does not name a valid dvice.
+ */
+#define ALC_INVALID_DEVICE                       0xA001
+
+/** 
+ * The context argument does not name a valid context.
+ */
+#define ALC_INVALID_CONTEXT                      0xA002  
+
+/**
+ * A function was called at inappropriate time,
+ *  or in an inappropriate way, causing an illegal state.
+ * This can be an incompatible ALenum, object ID,
+ *  and/or function.
+ */
+#define ALC_INVALID_ENUM						 0xA003
+
+/** 
+ * Illegal value passed as an argument to an AL call.
+ * Applies to parameter values, but not to enumerations.
+ */
+#define ALC_INVALID_VALUE                        0xA004
+
+/**
+ * A function could not be completed,
+ * because there is not enough memory available.
+ */
+#define ALC_OUT_OF_MEMORY                        0xA005
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
diff --git a/codemp/client/OpenAL/altypes.h b/codemp/client/OpenAL/altypes.h
new file mode 100644
index 0000000..d33514f
--- /dev/null
+++ b/codemp/client/OpenAL/altypes.h
@@ -0,0 +1,351 @@
+#ifndef _ALTYPES_H_
+#define _ALTYPES_H_
+
+/**
+ * OpenAL cross platform audio library
+ * Copyright (C) 1999-2000 by authors.
+ * This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ *  Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the
+ *  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ *  Boston, MA  02111-1307, USA.
+ * Or go to http://www.gnu.org/copyleft/lgpl.html
+ */
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** OpenAL boolean type. */
+typedef char ALboolean;
+
+/** OpenAL 8bit signed byte. */
+typedef char ALbyte;
+
+/** OpenAL 8bit unsigned byte. */
+typedef unsigned char ALubyte;
+
+/** OpenAL 16bit signed short integer type. */
+typedef short ALshort;
+
+/** OpenAL 16bit unsigned short integer type. */
+typedef unsigned short ALushort;
+
+/** OpenAL 32bit unsigned integer type. */
+typedef unsigned ALuint;
+
+/** OpenAL 32bit signed integer type. */
+typedef int ALint;
+
+/** OpenAL 32bit floating point type. */
+typedef float ALfloat;
+
+/** OpenAL 64bit double point type. */
+typedef double ALdouble;
+
+/** OpenAL 32bit type. */
+typedef unsigned int ALsizei;
+
+/** OpenAL void type */
+typedef void ALvoid;
+
+/** OpenAL enumerations. */
+typedef int ALenum;
+
+/* Bad value. */
+#define AL_INVALID                               (-1)
+
+/* Disable value. */
+#define AL_NONE									 0
+
+/* Boolean False. */
+#define AL_FALSE                                 0
+
+/* Boolean True. */
+#define AL_TRUE                                  1
+
+/**
+  * Indicate the type of AL_SOURCE.
+  * Sources can be spatialized 
+  */
+#define AL_SOURCE_TYPE                           0x200
+
+/** Indicate source has absolute coordinates. */
+#define AL_SOURCE_ABSOLUTE                       0x201
+
+/** Indicate Source has listener relative coordinates. */
+#define AL_SOURCE_RELATIVE                       0x202
+
+/**
+ * Directional source, inner cone angle, in degrees.
+ * Range:    [0-360] 
+ * Default:  360
+ */
+#define AL_CONE_INNER_ANGLE                      0x1001
+
+/**
+ * Directional source, outer cone angle, in degrees.
+ * Range:    [0-360] 
+ * Default:  360
+ */
+#define AL_CONE_OUTER_ANGLE                      0x1002
+
+/**
+ * Specify the pitch to be applied, either at source,
+ *  or on mixer results, at listener.
+ * Range:	 [0.5-2.0]
+ * Default:  1.0
+ */
+#define AL_PITCH                                 0x1003
+
+/** 
+ * Specify the current location in three dimensional space.
+ * OpenAL, like OpenGL, uses a right handed coordinate system,
+ *  where in a frontal default view X (thumb) points right, 
+ *  Y points up (index finger), and Z points towards the
+ *  viewer/camera (middle finger). 
+ * To switch from a left handed coordinate system, flip the
+ *  sign on the Z coordinate.
+ * Listener position is always in the world coordinate system.
+ */ 
+#define AL_POSITION                              0x1004
+  
+/** Specify the current direction as forward vector. */
+#define AL_DIRECTION                             0x1005
+  
+/** Specify the current velocity in three dimensional space. */
+#define AL_VELOCITY                              0x1006
+
+/**
+ * Indicate whether source has to loop infinite.
+ * Type: ALboolean
+ * Range:    [AL_TRUE, AL_FALSE]
+ * Default:  AL_FALSE
+ */
+#define AL_LOOPING                               0x1007
+
+/**
+ * Indicate the buffer to provide sound samples. 
+ * Type: ALuint.
+ * Range: any valid Buffer id.
+ */
+#define AL_BUFFER                                0x1009
+
+/**
+ * Indicate the gain (volume amplification) applied. 
+ * Type:     ALfloat.
+ * Range:    ]0.0-  ]
+ * A value of 1.0 means un-attenuated/unchanged.
+ * Each division by 2 equals an attenuation of -6dB.
+ * Each multiplicaton with 2 equals an amplification of +6dB.
+ * A value of 0.0 is meaningless with respect to a logarithmic
+ *  scale; it is interpreted as zero volume - the channel
+ *  is effectively disabled.
+ */
+#define AL_GAIN                                  0x100A
+
+/**
+ * Indicate minimum source attenuation.
+ * Type:     ALfloat
+ * Range:	 [0.0 - 1.0]
+ */
+#define AL_MIN_GAIN                              0x100D
+
+/**
+ * Indicate maximum source attenuation.
+ * Type:	 ALfloat
+ * Range:	 [0.0 - 1.0]
+ */
+#define AL_MAX_GAIN                              0x100E
+
+/** 
+ * Specify the current orientation.
+ * Type:	 ALfv6 (at/up)
+ * Range:	 N/A
+ */
+#define AL_ORIENTATION                           0x100F
+
+/* byte offset into source (in canon format).  -1 if source
+ * is not playing.  Don't set this, get this.
+ *
+ * Type:     ALfloat
+ * Range:    [0.0 - ]
+ * Default:  1.0
+ */
+#define AL_REFERENCE_DISTANCE                    0x1020
+
+ /**
+ * Indicate the rolloff factor for the source.
+ * Type: ALfloat
+ * Range:    [0.0 - ]
+ * Default:  1.0
+ */
+#define AL_ROLLOFF_FACTOR                        0x1021
+
+/**
+ * Indicate the gain (volume amplification) applied. 
+ * Type:     ALfloat.
+ * Range:    ]0.0-  ]
+ * A value of 1.0 means un-attenuated/unchanged.
+ * Each division by 2 equals an attenuation of -6dB.
+ * Each multiplicaton with 2 equals an amplification of +6dB.
+ * A value of 0.0 is meaningless with respect to a logarithmic
+ *  scale; it is interpreted as zero volume - the channel
+ *  is effectively disabled.
+ */
+#define AL_CONE_OUTER_GAIN                       0x1022
+
+/** 
+ * Specify the maximum distance.
+ * Type:	 ALfloat
+ * Range:	 [0.0 - ]
+ */
+#define AL_MAX_DISTANCE                          0x1023
+
+/**
+ * Specify the panning to be applied (2D only.)
+ * Range:	 [-1.0 - 1.0]
+ * Default:  0.0
+ */
+#define AL_PAN                                   0x1024
+
+/**
+ * Get the playing time of a stream.
+ * Range:	 [0.0 - infinity]
+ */
+#define AL_TIME                                   0x1025
+
+/**
+ * Specify the channel mask. (Creative)
+ * Type:	 ALuint
+ * Range:	 [0 - 255]
+ */
+#define AL_CHANNEL_MASK							 0x3000
+
+/**
+ * Source state information
+ */
+#define AL_SOURCE_STATE                          0x1010
+#define AL_INITIAL                               0x1011
+#define AL_PLAYING                               0x1012
+#define AL_PAUSED                                0x1013
+#define AL_STOPPED                               0x1014
+
+/**
+ * Buffer Queue params
+ */
+#define AL_BUFFERS_QUEUED                        0x1015
+#define AL_BUFFERS_PROCESSED                     0x1016
+
+/** Sound buffers: format specifier. */
+#define AL_FORMAT_MONO8                          0x1100
+#define AL_FORMAT_MONO16                         0x1101
+#define AL_FORMAT_STEREO8                        0x1102
+#define AL_FORMAT_STEREO16                       0x1103
+#define AL_FORMAT_MONO4                          0x1104
+#define AL_FORMAT_STEREO4                        0x1105
+
+/** 
+ * Sound buffers: frequency, in units of Hertz [Hz].
+ * This is the number of samples per second. Half of the
+ *  sample frequency marks the maximum significant
+ *  frequency component.
+ */
+#define AL_FREQUENCY                             0x2001
+#define AL_BITS                                  0x2002
+#define AL_CHANNELS                              0x2003
+#define AL_SIZE                                  0x2004
+#define AL_DATA                                  0x2005
+
+/**
+ * Buffer state.
+ *
+ * Not supported for public use (yet).
+ */
+#define AL_UNUSED                                0x2010
+#define AL_PENDING                               0x2011
+#define AL_PROCESSED                             0x2012
+
+/** Errors: No Error. */
+#define AL_NO_ERROR                              AL_FALSE
+
+/** 
+ * Illegal name passed as an argument to an AL call.
+ */
+#define AL_INVALID_NAME                          0xA001
+
+/** 
+ * Illegal enum passed as an argument to an AL call.
+ */
+#define AL_INVALID_ENUM                          0xA002  
+/** 
+ * Illegal value passed as an argument to an AL call.
+ * Applies to parameter values, but not to enumerations.
+ */
+#define AL_INVALID_VALUE                         0xA003
+  
+/**
+ * A function was called at inappropriate time,
+ *  or in an inappropriate way, causing an illegal state.
+ * This can be an incompatible ALenum, object ID,
+ *  and/or function.
+ */
+#define AL_INVALID_OPERATION                     0xA004
+
+/**
+ * A function could not be completed,
+ * because there is not enough memory available.
+ */
+#define AL_OUT_OF_MEMORY                         0xA005
+
+/** Context strings: Vendor Name. */
+#define AL_VENDOR                                0xB001
+#define AL_VERSION                               0xB002
+#define AL_RENDERER                              0xB003
+#define AL_EXTENSIONS                            0xB004
+#define AL_MEMORY_USED                           0xB005
+#define AL_MEMORY_ALLOCATOR                      0xB006
+#define AL_MEMORY_DEALLOCATOR                    0xB007
+#define AL_STEREO                                0xB008
+
+/** Global tweakage. */
+
+/**
+ * Doppler scale.  Default 1.0
+ */
+#define AL_DOPPLER_FACTOR                        0xC000
+ 
+/**
+ * Doppler velocity.  Default 1.0
+ */
+#define AL_DOPPLER_VELOCITY                      0xC001
+
+/**
+ * Distance model.  Default AL_INVERSE_DISTANCE_CLAMPED
+ */
+#define AL_DISTANCE_MODEL                        0xD000
+
+/** Distance models. */
+
+#define AL_INVERSE_DISTANCE                      0xD001
+#define AL_INVERSE_DISTANCE_CLAMPED              0xD002
+ 
+ /**
+ * enables
+ */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/codemp/client/OpenAL/alu.h b/codemp/client/OpenAL/alu.h
new file mode 100644
index 0000000..8a4004b
--- /dev/null
+++ b/codemp/client/OpenAL/alu.h
@@ -0,0 +1,34 @@
+#ifndef _ALU_H_
+#define _ALU_H_
+
+#define ALUAPI
+#define ALUAPIENTRY __cdecl
+
+#define BUFFERSIZE 48000
+#define FRACTIONBITS 14
+#define FRACTIONMASK ((1L<<FRACTIONBITS)-1)
+#define OUTPUTCHANNELS 2
+
+#include "altypes.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+ALUAPI ALint	ALUAPIENTRY aluF2L(ALfloat value);
+ALUAPI ALshort	ALUAPIENTRY aluF2S(ALfloat value);
+ALUAPI ALvoid	ALUAPIENTRY aluCrossproduct(ALfloat *inVector1,ALfloat *inVector2,ALfloat *outVector);
+ALUAPI ALfloat	ALUAPIENTRY aluDotproduct(ALfloat *inVector1,ALfloat *inVector2);
+ALUAPI ALvoid	ALUAPIENTRY aluNormalize(ALfloat *inVector);
+ALUAPI ALvoid	ALUAPIENTRY aluMatrixVector(ALfloat matrix[3][3],ALfloat *vector);
+ALUAPI ALvoid	ALUAPIENTRY aluCalculateSourceParameters(ALuint source,ALuint channels,ALfloat *drysend,ALfloat *wetsend,ALfloat *pitch);
+ALUAPI ALvoid	ALUAPIENTRY aluMixData(ALvoid *context,ALvoid *buffer,ALsizei size,ALenum format);
+ALUAPI ALvoid	ALUAPIENTRY aluSetReverb(ALvoid *Reverb,ALuint Environment);
+ALUAPI ALvoid	ALUAPIENTRY aluReverb(ALvoid *Reverb,ALfloat Buffer[][2],ALsizei BufferSize);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
diff --git a/codemp/client/OpenAL/alut.h b/codemp/client/OpenAL/alut.h
new file mode 100644
index 0000000..e86eb95
--- /dev/null
+++ b/codemp/client/OpenAL/alut.h
@@ -0,0 +1,24 @@
+#ifndef _ALUT_H_
+#define _ALUT_H_
+
+#define ALUTAPI
+#define ALUTAPIENTRY __cdecl
+
+#include "al.h"
+#include "alu.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+ALUTAPI ALvoid	ALUTAPIENTRY alutInit(ALint *argc,ALbyte **argv);
+ALUTAPI ALvoid	ALUTAPIENTRY alutExit(ALvoid);
+ALUTAPI ALvoid	ALUTAPIENTRY alutLoadWAVFile(ALbyte *file,ALenum *format,ALvoid **data,ALsizei *size,ALsizei *freq,ALboolean *loop);
+ALUTAPI ALvoid	ALUTAPIENTRY alutLoadWAVMemory(ALbyte *memory,ALenum *format,ALvoid **data,ALsizei *size,ALsizei *freq,ALboolean *loop);
+ALUTAPI ALvoid  ALUTAPIENTRY alutUnloadWAV(ALenum format,ALvoid *data,ALsizei size,ALsizei freq);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/codemp/client/OpenAL/vssver.scc b/codemp/client/OpenAL/vssver.scc
new file mode 100644
index 0000000..b5e63e3
Binary files /dev/null and b/codemp/client/OpenAL/vssver.scc differ
diff --git a/codemp/client/cl_cgame.cpp b/codemp/client/cl_cgame.cpp
new file mode 100644
index 0000000..0b86ded
--- /dev/null
+++ b/codemp/client/cl_cgame.cpp
@@ -0,0 +1,2093 @@
+// cl_cgame.c  -- client system interaction with client game
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+#include "../RMG/RM_Headers.h"
+
+#include "client.h"
+
+#include "../game/botlib.h"
+
+#include "../RMG/RM_Headers.h"
+
+#if !defined(FX_EXPORT_H_INC)
+	#include "FXExport.h"
+#endif
+
+#include "FXutil.h"
+
+#if !defined(CROFFSYSTEM_H_INC)
+	#include "../qcommon/ROFFSystem.h"
+#endif
+
+#ifdef _DONETPROFILE_
+#include "../qcommon/INetProfile.h"
+#endif
+
+#include "../renderer/tr_worldeffects.h"
+
+#ifdef VV_LIGHTING
+#include "../renderer/tr_lightmanager.h"
+#endif
+
+/*
+Ghoul2 Insert Start
+*/
+
+#if !defined(G2_H_INC)
+	#include "../ghoul2/G2_local.h"
+#endif
+
+#include "../qcommon/stringed_ingame.h"
+
+#include "../ghoul2/G2_gore.h"
+
+extern CMiniHeap *G2VertSpaceClient;
+
+#include "snd_ambient.h"
+
+#include "../qcommon/timing.h"
+
+#include "../renderer/tr_local.h"
+
+//extern int contentOverride;
+
+/*
+Ghoul2 Insert End
+*/
+
+#include "../cgame/cg_local.h"
+
+extern	botlib_export_t	*botlib_export;
+
+extern qboolean loadCamera(const char *name);
+extern void startCamera(int time);
+extern qboolean getCameraInfo(int time, vec3_t *origin, vec3_t *angles);
+
+void FX_FeedTrail(effectTrailArgStruct_t *a);
+
+int CM_LoadSubBSP(const char *name, qboolean clientload);
+void RE_InitRendererTerrain( const char *info );
+
+
+/*
+====================
+CL_GetGameState
+====================
+*/
+void CL_GetGameState( gameState_t *gs ) {
+	*gs = cl.gameState;
+}
+
+/*
+====================
+CL_GetGlconfig
+====================
+*/
+void CL_GetGlconfig( glconfig_t *glconfig ) {
+	*glconfig = cls.glconfig;
+}
+
+
+/*
+====================
+CL_GetUserCmd
+====================
+*/
+qboolean CL_GetUserCmd( int cmdNumber, usercmd_t *ucmd ) {
+	// cmds[cmdNumber] is the last properly generated command
+
+	// can't return anything that we haven't created yet
+	if ( cmdNumber > cl.cmdNumber ) {
+		Com_Error( ERR_DROP, "CL_GetUserCmd: %i >= %i", cmdNumber, cl.cmdNumber );
+	}
+
+	// the usercmd has been overwritten in the wrapping
+	// buffer because it is too far out of date
+	if ( cmdNumber <= cl.cmdNumber - CMD_BACKUP ) {
+		return qfalse;
+	}
+
+	*ucmd = cl.cmds[ cmdNumber & CMD_MASK ];
+
+	return qtrue;
+}
+
+int CL_GetCurrentCmdNumber( void ) {
+	return cl.cmdNumber;
+}
+
+
+/*
+====================
+CL_GetParseEntityState
+====================
+*/
+qboolean	CL_GetParseEntityState( int parseEntityNumber, entityState_t *state ) {
+	// can't return anything that hasn't been parsed yet
+	if ( parseEntityNumber >= cl.parseEntitiesNum ) {
+		Com_Error( ERR_DROP, "CL_GetParseEntityState: %i >= %i",
+			parseEntityNumber, cl.parseEntitiesNum );
+	}
+
+	// can't return anything that has been overwritten in the circular buffer
+	if ( parseEntityNumber <= cl.parseEntitiesNum - MAX_PARSE_ENTITIES ) {
+		return qfalse;
+	}
+
+	*state = cl.parseEntities[ parseEntityNumber & ( MAX_PARSE_ENTITIES - 1 ) ];
+	return qtrue;
+}
+
+/*
+====================
+CL_GetCurrentSnapshotNumber
+====================
+*/
+void	CL_GetCurrentSnapshotNumber( int *snapshotNumber, int *serverTime ) {
+	*snapshotNumber = cl.snap.messageNum;
+	*serverTime = cl.snap.serverTime;
+}
+
+/*
+====================
+CL_GetSnapshot
+====================
+*/
+qboolean	CL_GetSnapshot( int snapshotNumber, snapshot_t *snapshot ) {
+	clSnapshot_t	*clSnap;
+	int				i, count;
+
+	if ( snapshotNumber > cl.snap.messageNum ) {
+		Com_Error( ERR_DROP, "CL_GetSnapshot: snapshotNumber > cl.snapshot.messageNum" );
+	}
+
+	// if the frame has fallen out of the circular buffer, we can't return it
+	if ( cl.snap.messageNum - snapshotNumber >= PACKET_BACKUP ) {
+		return qfalse;
+	}
+
+	// if the frame is not valid, we can't return it
+	clSnap = &cl.snapshots[snapshotNumber & PACKET_MASK];
+	if ( !clSnap->valid ) {
+		return qfalse;
+	}
+
+	// if the entities in the frame have fallen out of their
+	// circular buffer, we can't return it
+	if ( cl.parseEntitiesNum - clSnap->parseEntitiesNum >= MAX_PARSE_ENTITIES ) {
+		return qfalse;
+	}
+
+	// write the snapshot
+	snapshot->snapFlags = clSnap->snapFlags;
+	snapshot->serverCommandSequence = clSnap->serverCommandNum;
+	snapshot->ping = clSnap->ping;
+	snapshot->serverTime = clSnap->serverTime;
+	Com_Memcpy( snapshot->areamask, clSnap->areamask, sizeof( snapshot->areamask ) );
+	snapshot->ps = clSnap->ps;
+	snapshot->vps = clSnap->vps; //get the vehicle ps
+	count = clSnap->numEntities;
+	if ( count > MAX_ENTITIES_IN_SNAPSHOT ) {
+		Com_DPrintf( "CL_GetSnapshot: truncated %i entities to %i\n", count, MAX_ENTITIES_IN_SNAPSHOT );
+		count = MAX_ENTITIES_IN_SNAPSHOT;
+	}
+	snapshot->numEntities = count;
+
+ 	for ( i = 0 ; i < count ; i++ ) {
+
+		int entNum =  ( clSnap->parseEntitiesNum + i ) & (MAX_PARSE_ENTITIES-1) ;
+
+		// copy everything but the ghoul2 pointer
+		memcpy(&snapshot->entities[i], &cl.parseEntities[ entNum ], sizeof(entityState_t));
+	}
+
+	// FIXME: configstring changes and server commands!!!
+
+	return qtrue;
+}
+
+qboolean CL_GetDefaultState(int index, entityState_t *state)
+{
+	if (index < 0 || index >= MAX_GENTITIES)
+	{
+		return qfalse;
+	}
+
+	if (!(cl.entityBaselines[index].eFlags & EF_PERMANENT))
+	{
+		return qfalse;
+	}
+
+	*state = cl.entityBaselines[index];
+
+	return qtrue;
+}
+
+/*
+=====================
+CL_SetUserCmdValue
+=====================
+*/
+extern float cl_mPitchOverride;
+extern float cl_mYawOverride;
+extern float cl_mSensitivityOverride;
+void CL_SetUserCmdValue( int userCmdValue, float sensitivityScale, float mPitchOverride, float mYawOverride, float mSensitivityOverride, int fpSel, int invenSel ) {
+	cl.cgameUserCmdValue = userCmdValue;
+	cl.cgameSensitivity = sensitivityScale;
+	cl_mPitchOverride = mPitchOverride;
+	cl_mYawOverride = mYawOverride;
+	cl_mSensitivityOverride = mSensitivityOverride;
+	cl.cgameForceSelection = fpSel;
+	cl.cgameInvenSelection = invenSel;
+}
+
+/*
+=====================
+CL_SetClientForceAngle
+=====================
+*/
+void CL_SetClientForceAngle(int time, vec3_t angle)
+{
+	cl.cgameViewAngleForceTime = time;
+	VectorCopy(angle, cl.cgameViewAngleForce);
+}
+
+/*
+=====================
+CL_AddCgameCommand
+=====================
+*/
+void CL_AddCgameCommand( const char *cmdName ) {
+	Cmd_AddCommand( cmdName, NULL );
+}
+
+/*
+=====================
+CL_CgameError
+=====================
+*/
+void CL_CgameError( const char *string ) {
+	Com_Error( ERR_DROP, "%s", string );
+}
+
+
+int gCLTotalClientNum = 0;
+//keep track of the total number of clients
+extern cvar_t	*cl_autolodscale;
+//if we want to do autolodscaling
+
+void CL_DoAutoLODScale(void)
+{
+	float finalLODScaleFactor = 0;
+
+	if ( gCLTotalClientNum >= 8 )
+	{
+		finalLODScaleFactor = (gCLTotalClientNum/-8.0f);
+	}
+
+
+	Cvar_Set( "r_autolodscalevalue", va("%f", finalLODScaleFactor) );
+}
+
+/*
+=====================
+CL_ConfigstringModified
+=====================
+*/
+void CL_ConfigstringModified( void ) {
+	char		*old, *s;
+	int			i, index;
+	char		*dup;
+	gameState_t	oldGs;
+	int			len;
+
+	index = atoi( Cmd_Argv(1) );
+	if ( index < 0 || index >= MAX_CONFIGSTRINGS ) {
+		Com_Error( ERR_DROP, "configstring > MAX_CONFIGSTRINGS" );
+	}
+	// get everything after "cs <num>"
+	s = Cmd_ArgsFrom(2);
+
+	old = cl.gameState.stringData + cl.gameState.stringOffsets[ index ];
+	if ( !strcmp( old, s ) ) {
+		return;		// unchanged
+	}
+
+	// build the new gameState_t
+	oldGs = cl.gameState;
+
+	Com_Memset( &cl.gameState, 0, sizeof( cl.gameState ) );
+
+	// leave the first 0 for uninitialized strings
+	cl.gameState.dataCount = 1;
+		
+	for ( i = 0 ; i < MAX_CONFIGSTRINGS ; i++ ) {
+		if ( i == index ) {
+			dup = s;
+		} else {
+			dup = oldGs.stringData + oldGs.stringOffsets[ i ];
+		}
+		if ( !dup[0] ) {
+			continue;		// leave with the default empty string
+		}
+
+		len = strlen( dup );
+
+		if ( len + 1 + cl.gameState.dataCount > MAX_GAMESTATE_CHARS ) {
+			Com_Error( ERR_DROP, "MAX_GAMESTATE_CHARS exceeded" );
+		}
+
+		// append it to the gameState string buffer
+		cl.gameState.stringOffsets[ i ] = cl.gameState.dataCount;
+		Com_Memcpy( cl.gameState.stringData + cl.gameState.dataCount, dup, len + 1 );
+		cl.gameState.dataCount += len + 1;
+	}
+
+	if (cl_autolodscale && cl_autolodscale->integer)
+	{
+		if (index >= CS_PLAYERS &&
+			index < CS_G2BONES)
+		{ //this means that a client was updated in some way. Go through and count the clients.
+			int clientCount = 0;
+			i = CS_PLAYERS;
+
+			while (i < CS_G2BONES)
+			{
+				s = cl.gameState.stringData + cl.gameState.stringOffsets[ i ];
+
+				if (s && s[0])
+				{
+					clientCount++;
+				}
+
+				i++;
+			}
+
+			gCLTotalClientNum = clientCount;
+
+#ifdef _DEBUG
+			Com_DPrintf("%i clients\n", gCLTotalClientNum);
+#endif
+
+			CL_DoAutoLODScale();
+		}
+	}
+
+	if ( index == CS_SYSTEMINFO ) {
+		// parse serverId and other cvars
+		CL_SystemInfoChanged();
+	}
+
+}
+#ifndef MAX_STRINGED_SV_STRING
+	#define MAX_STRINGED_SV_STRING 1024
+#endif
+// just copied it from CG_CheckSVStringEdRef(
+void CL_CheckSVStringEdRef(char *buf, const char *str)
+{ //I don't really like doing this. But it utilizes the system that was already in place.
+	int i = 0;
+	int b = 0;
+	int strLen = 0;
+	qboolean gotStrip = qfalse;
+
+	if (!str || !str[0])
+	{
+		if (str)
+		{
+			strcpy(buf, str);
+		}
+		return;
+	}
+
+	strcpy(buf, str);
+
+	strLen = strlen(str);
+
+	if (strLen >= MAX_STRINGED_SV_STRING)
+	{
+		return;
+	}
+
+	while (i < strLen && str[i])
+	{
+		gotStrip = qfalse;
+
+		if (str[i] == '@' && (i+1) < strLen)
+		{
+			if (str[i+1] == '@' && (i+2) < strLen)
+			{
+				if (str[i+2] == '@' && (i+3) < strLen)
+				{ //@@@ should mean to insert a StringEd reference here, so insert it into buf at the current place
+					char stringRef[MAX_STRINGED_SV_STRING];
+					int r = 0;
+
+					while (i < strLen && str[i] == '@')
+					{
+						i++;
+					}
+
+					while (i < strLen && str[i] && str[i] != ' ' && str[i] != ':' && str[i] != '.' && str[i] != '\n')
+					{
+						stringRef[r] = str[i];
+						r++;
+						i++;
+					}
+					stringRef[r] = 0;
+
+					buf[b] = 0;
+					Q_strcat(buf, MAX_STRINGED_SV_STRING, SE_GetString("MP_SVGAME", stringRef));
+					b = strlen(buf);
+				}
+			}
+		}
+
+		if (!gotStrip)
+		{
+			buf[b] = str[i];
+			b++;
+		}
+		i++;
+	}
+
+	buf[b] = 0;
+}
+/*
+===================
+CL_GetServerCommand
+
+Set up argc/argv for the given command
+===================
+*/
+qboolean CL_GetServerCommand( int serverCommandNumber ) {
+	char	*s;
+	char	*cmd;
+	static char bigConfigString[BIG_INFO_STRING];
+
+	// if we have irretrievably lost a reliable command, drop the connection
+	if ( serverCommandNumber <= clc.serverCommandSequence - MAX_RELIABLE_COMMANDS )
+	{
+		int i = 0;
+
+		// when a demo record was started after the client got a whole bunch of
+		// reliable commands then the client never got those first reliable commands
+#ifndef _XBOX	// No demos on Xbox
+		if ( clc.demoplaying )
+			return qfalse;
+#endif
+		while (i < MAX_RELIABLE_COMMANDS)
+		{ //spew out the reliable command buffer
+			if (clc.reliableCommands[i][0])
+			{
+				Com_Printf("%i: %s\n", i, clc.reliableCommands[i]);
+			}
+			i++;
+		}
+		Com_Error( ERR_DROP, "CL_GetServerCommand: a reliable command was cycled out" );
+		return qfalse;
+	}
+
+	if ( serverCommandNumber > clc.serverCommandSequence ) {
+		Com_Error( ERR_DROP, "CL_GetServerCommand: requested a command not received" );
+		return qfalse;
+	}
+
+	s = clc.serverCommands[ serverCommandNumber & ( MAX_RELIABLE_COMMANDS - 1 ) ];
+	clc.lastExecutedServerCommand = serverCommandNumber;
+
+	Com_DPrintf( "serverCommand: %i : %s\n", serverCommandNumber, s );
+
+rescan:
+	Cmd_TokenizeString( s );
+	cmd = Cmd_Argv(0);
+
+	if ( !strcmp( cmd, "disconnect" ) ) {
+		char strEd[MAX_STRINGED_SV_STRING];
+		CL_CheckSVStringEdRef(strEd, Cmd_Argv(1));
+		Com_Error (ERR_SERVERDISCONNECT, "%s: %s\n", SE_GetString("MP_SVGAME_SERVER_DISCONNECTED"), strEd );
+	}
+
+	if ( !strcmp( cmd, "bcs0" ) ) {
+		Com_sprintf( bigConfigString, BIG_INFO_STRING, "cs %s \"%s", Cmd_Argv(1), Cmd_Argv(2) );
+		return qfalse;
+	}
+
+	if ( !strcmp( cmd, "bcs1" ) ) {
+		s = Cmd_Argv(2);
+		if( strlen(bigConfigString) + strlen(s) >= BIG_INFO_STRING ) {
+			Com_Error( ERR_DROP, "bcs exceeded BIG_INFO_STRING" );
+		}
+		strcat( bigConfigString, s );
+		return qfalse;
+	}
+
+	if ( !strcmp( cmd, "bcs2" ) ) {
+		s = Cmd_Argv(2);
+		if( strlen(bigConfigString) + strlen(s) + 1 >= BIG_INFO_STRING ) {
+			Com_Error( ERR_DROP, "bcs exceeded BIG_INFO_STRING" );
+		}
+		strcat( bigConfigString, s );
+		strcat( bigConfigString, "\"" );
+		s = bigConfigString;
+		goto rescan;
+	}
+
+	if ( !strcmp( cmd, "cs" ) ) {
+		CL_ConfigstringModified();
+		// reparse the string, because CL_ConfigstringModified may have done another Cmd_TokenizeString()
+		Cmd_TokenizeString( s );
+		return qtrue;
+	}
+
+	if ( !strcmp( cmd, "map_restart" ) ) {
+		// clear notify lines and outgoing commands before passing
+		// the restart to the cgame
+		Con_ClearNotify();
+		Com_Memset( cl.cmds, 0, sizeof( cl.cmds ) );
+		return qtrue;
+	}
+
+	// the clientLevelShot command is used during development
+	// to generate 128*128 screenshots from the intermission
+	// point of levels for the menu system to use
+	// we pass it along to the cgame to make apropriate adjustments,
+	// but we also clear the console and notify lines here
+	if ( !strcmp( cmd, "clientLevelShot" ) ) {
+		// don't do it if we aren't running the server locally,
+		// otherwise malicious remote servers could overwrite
+		// the existing thumbnails
+		if ( !com_sv_running->integer ) {
+			return qfalse;
+		}
+		// close the console
+		Con_Close();
+		// take a special screenshot next frame
+		Cbuf_AddText( "wait ; wait ; wait ; wait ; screenshot levelshot\n" );
+		return qtrue;
+	}
+
+	// we may want to put a "connect to other server" command here
+
+	// cgame can now act on the command
+	return qtrue;
+}
+
+
+/*
+====================
+CL_CM_LoadMap
+
+Just adds default parameters that cgame doesn't need to know about
+====================
+*/
+void CL_CM_LoadMap( const char *mapname ) {
+	int		checksum;
+
+	CM_LoadMap( mapname, qtrue, &checksum );
+}
+
+/*
+====================
+CL_ShutdonwCGame
+
+====================
+*/
+void CL_ShutdownCGame( void ) {
+	cls.keyCatchers &= ~KEYCATCH_CGAME;
+	cls.cgameStarted = qfalse;
+	if ( !cgvm ) {
+		return;
+	}
+	VM_Call( cgvm, CG_SHUTDOWN );
+	VM_Free( cgvm );
+	cgvm = NULL;
+#ifdef _DONETPROFILE_
+	ClReadProf().ShowTotals();
+#endif
+}
+
+static int	FloatAsInt( float f ) {
+	int		temp;
+
+	*(float *)&temp = f;
+
+	return temp;
+}
+
+/*
+====================
+CL_CgameSystemCalls
+
+The cgame module is making a system call
+====================
+*/
+#define	VMA(x) VM_ArgPtr(args[x])
+#define	VMF(x)	((float *)args)[x]
+#ifdef _XBOX
+extern int *s_entityWavVol;
+#else
+extern int s_entityWavVol[MAX_GENTITIES];
+#endif
+void R_WorldEffectCommand(const char *command);
+
+extern int CL_GetValueForHidden(const char *s); //cl_parse.cpp
+
+extern void R_AutomapElevationAdjustment(float newHeight); //tr_world.cpp
+extern qboolean R_InitializeWireframeAutomap(void); //tr_world.cpp
+
+extern float tr_distortionAlpha; //tr_shadows.cpp
+extern float tr_distortionStretch; //tr_shadows.cpp
+extern qboolean tr_distortionPrePost; //tr_shadows.cpp
+extern qboolean tr_distortionNegate; //tr_shadows.cpp
+extern qboolean cl_bUseFighterPitch; //cl_input.cpp
+
+int CL_CgameSystemCalls( int *args ) {
+	switch( args[0] ) {
+	//rww - alright, DO NOT EVER add a GAME/CGAME/UI generic call without adding a trap to match, and
+	//all of these traps must be shared and have cases in sv_game, cl_cgame, and cl_ui. They must also
+	//all be in the same order, and start at 100.
+	case TRAP_MEMSET:
+		Com_Memset( VMA(1), args[2], args[3] );
+		return 0;
+	case TRAP_MEMCPY:
+		Com_Memcpy( VMA(1), VMA(2), args[3] );
+		return 0;
+	case TRAP_STRNCPY:
+		return (int)strncpy( (char *)VMA(1), (const char *)VMA(2), args[3] );
+	case TRAP_SIN:
+		return FloatAsInt( sin( VMF(1) ) );
+	case TRAP_COS:
+		return FloatAsInt( cos( VMF(1) ) );
+	case TRAP_ATAN2:
+		return FloatAsInt( atan2( VMF(1), VMF(2) ) );
+	case TRAP_SQRT:
+		return FloatAsInt( sqrt( VMF(1) ) );
+	case TRAP_MATRIXMULTIPLY:
+		MatrixMultiply( (vec3_t *)VMA(1), (vec3_t *)VMA(2), (vec3_t *)VMA(3) );
+		return 0;
+	case TRAP_ANGLEVECTORS:
+		AngleVectors( (const float *)VMA(1), (float *)VMA(2), (float *)VMA(3), (float *)VMA(4) );
+		return 0;
+	case TRAP_PERPENDICULARVECTOR:
+		PerpendicularVector( (float *)VMA(1), (const float *)VMA(2) );
+		return 0;
+	case TRAP_FLOOR:
+		return FloatAsInt( floor( VMF(1) ) );
+	case TRAP_CEIL:
+		return FloatAsInt( ceil( VMF(1) ) );
+	case TRAP_TESTPRINTINT:
+		return 0;
+	case TRAP_TESTPRINTFLOAT:
+		return 0;
+	case TRAP_ACOS:
+		return FloatAsInt( Q_acos( VMF(1) ) );
+	case TRAP_ASIN:
+		return FloatAsInt( Q_asin( VMF(1) ) );
+
+
+	case CG_PRINT:
+		Com_Printf( "%s", VMA(1) );
+		return 0;
+	case CG_ERROR:
+		Com_Error( ERR_DROP, "%s", VMA(1) );
+		return 0;
+	case CG_MILLISECONDS:
+		return Sys_Milliseconds();
+	//rww - precision timer funcs... -ALWAYS- call end after start with supplied ptr, or you'll get a nasty memory leak.
+	//not that you should be using these outside of debug anyway.. because you shouldn't be. So don't.
+	case CG_PRECISIONTIMER_START:
+		{
+			void **suppliedPtr =(void **)VMA(1); //we passed in a pointer to a point
+			timing_c *newTimer = new timing_c; //create the new timer
+			*suppliedPtr = newTimer; //assign the pointer within the pointer to point at the mem addr of our new timer
+			newTimer->Start(); //start the timer
+		}
+		return 0;
+	case CG_PRECISIONTIMER_END:
+		{
+			int r;
+			timing_c *timer = (timing_c *)args[1]; //this is the pointer we assigned in start, so we can directly cast it back
+			r = timer->End(); //get the result
+			delete timer; //delete the timer since we're done with it
+			return r; //return the result
+		}
+	case CG_CVAR_REGISTER:
+		Cvar_Register( (vmCvar_t *)VMA(1), (const char *)VMA(2), (const char *)VMA(3), args[4] ); 
+		return 0;
+	case CG_CVAR_UPDATE:
+		Cvar_Update( (vmCvar_t *)VMA(1) );
+		return 0;
+	case CG_CVAR_SET:
+		Cvar_Set( (const char *)VMA(1), (const char *)VMA(2) );
+		return 0;
+	case CG_CVAR_VARIABLESTRINGBUFFER:
+		Cvar_VariableStringBuffer( (const char *)VMA(1), (char *)VMA(2), args[3] );
+		return 0;
+	case CG_CVAR_GETHIDDENVALUE:
+		return CL_GetValueForHidden((const char *)VMA(1));
+	case CG_ARGC:
+		return Cmd_Argc();
+	case CG_ARGV:
+		Cmd_ArgvBuffer( args[1], (char *)VMA(2), args[3] );
+		return 0;
+	case CG_ARGS:
+		Cmd_ArgsBuffer( (char *)VMA(1), args[2] );
+		return 0;
+
+	case CG_FS_FOPENFILE:
+		return FS_FOpenFileByMode( (const char *)VMA(1), (int *)VMA(2), (fsMode_t)args[3] );
+	case CG_FS_READ:
+		FS_Read2( VMA(1), args[2], args[3] );
+		return 0;
+	case CG_FS_WRITE:
+		FS_Write( VMA(1), args[2], args[3] );
+		return 0;
+	case CG_FS_FCLOSEFILE:
+		FS_FCloseFile( args[1] );
+		return 0;
+	case CG_FS_GETFILELIST:
+		return FS_GetFileList( (const char *)VMA(1), (const char *)VMA(2), (char *)VMA(3), args[4] );
+
+	case CG_SENDCONSOLECOMMAND:
+		Cbuf_AddText( (const char *)VMA(1) );
+		return 0;
+	case CG_ADDCOMMAND:
+		CL_AddCgameCommand( (const char *)VMA(1) );
+		return 0;
+	case CG_REMOVECOMMAND:
+		Cmd_RemoveCommand( (const char *)VMA(1) );
+		return 0;
+	case CG_SENDCLIENTCOMMAND:
+		CL_AddReliableCommand( (const char *)VMA(1) );
+		return 0;
+	case CG_UPDATESCREEN:
+		// this is used during lengthy level loading, so pump message loop
+//		Com_EventLoop();	// FIXME: if a server restarts here, BAD THINGS HAPPEN!
+// We can't call Com_EventLoop here, a restart will crash and this _does_ happen
+// if there is a map change while we are downloading at pk3.
+// ZOID
+		SCR_UpdateScreen();
+		return 0;
+	case CG_CM_LOADMAP:
+		if (args[2])
+		{
+			CM_LoadSubBSP(va("maps/%s.bsp", ((const char *)VMA(1)) + 1), qfalse);
+		}
+		else
+		{
+			CL_CM_LoadMap( (const char *)VMA(1) );
+		}
+		return 0;
+	case CG_CM_NUMINLINEMODELS:
+		return CM_NumInlineModels();
+	case CG_CM_INLINEMODEL:
+		return CM_InlineModel( args[1] );
+	case CG_CM_TEMPBOXMODEL:
+		return CM_TempBoxModel( (const float *)VMA(1), (const float *)VMA(2), /*int capsule*/ qfalse );
+	case CG_CM_TEMPCAPSULEMODEL:
+		return CM_TempBoxModel( (const float *)VMA(1), (const float *)VMA(2), /*int capsule*/ qtrue );
+	case CG_CM_POINTCONTENTS:
+		return CM_PointContents( (const float *)VMA(1), args[2] );
+	case CG_CM_TRANSFORMEDPOINTCONTENTS:
+		return CM_TransformedPointContents( (const float *)VMA(1), args[2], (const float *)VMA(3), (const float *)VMA(4) );
+	case CG_CM_BOXTRACE:
+		CM_BoxTrace( (trace_t *)VMA(1), (const float *)VMA(2), (const float *)VMA(3), (const float *)VMA(4), (const float *)VMA(5), args[6], args[7], /*int capsule*/ qfalse );
+		return 0;
+	case CG_CM_CAPSULETRACE:
+		CM_BoxTrace( (trace_t *)VMA(1), (const float *)VMA(2), (const float *)VMA(3), (const float *)VMA(4), (const float *)VMA(5), args[6], args[7], /*int capsule*/ qtrue );
+		return 0;
+	case CG_CM_TRANSFORMEDBOXTRACE:
+		CM_TransformedBoxTrace( (trace_t *)VMA(1), (const float *)VMA(2), (const float *)VMA(3), (const float *)VMA(4), (const float *)VMA(5), args[6], args[7], (const float *)VMA(8), (const float *)VMA(9), /*int capsule*/ qfalse );
+		return 0;
+	case CG_CM_TRANSFORMEDCAPSULETRACE:
+		CM_TransformedBoxTrace( (trace_t *)VMA(1), (const float *)VMA(2), (const float *)VMA(3), (const float *)VMA(4), (const float *)VMA(5), args[6], args[7], (const float *)VMA(8), (const float *)VMA(9), /*int capsule*/ qtrue );
+		return 0;
+	case CG_CM_MARKFRAGMENTS:
+		return re.MarkFragments( args[1], (const vec3_t *)VMA(2), (const float *)VMA(3), args[4], (float *)VMA(5), args[6], (markFragment_t *)VMA(7) );
+	case CG_S_GETVOICEVOLUME:
+		return s_entityWavVol[args[1]];
+	case CG_S_MUTESOUND:
+		S_MuteSound( args[1], args[2] );
+		return 0;
+	case CG_S_STARTSOUND:
+		S_StartSound( (float *)VMA(1), args[2], args[3], args[4] );
+		return 0;
+	case CG_S_STARTLOCALSOUND:
+		S_StartLocalSound( args[1], args[2] );
+		return 0;
+	case CG_S_CLEARLOOPINGSOUNDS:
+		S_ClearLoopingSounds();
+		return 0;
+	case CG_S_ADDLOOPINGSOUND:
+		S_AddLoopingSound( args[1], (const float *)VMA(2), (const float *)VMA(3), args[4] );
+		return 0;
+	case CG_S_ADDREALLOOPINGSOUND:
+		//S_AddRealLoopingSound( args[1], (const float *)VMA(2), (const float *)VMA(3), args[4] );
+		S_AddLoopingSound( args[1], (const float *)VMA(2), (const float *)VMA(3), args[4] );
+		return 0;
+	case CG_S_STOPLOOPINGSOUND:
+		S_StopLoopingSound( args[1] );
+		return 0;
+	case CG_S_UPDATEENTITYPOSITION:
+		S_UpdateEntityPosition( args[1], (const float *)VMA(2) );
+		return 0;
+	case CG_S_RESPATIALIZE:
+		S_Respatialize( args[1], (const float *)VMA(2), (vec3_t *)VMA(3), args[4] );
+		return 0;
+	case CG_S_SHUTUP:
+		s_shutUp = (qboolean)args[1];
+		return 0;
+	case CG_S_REGISTERSOUND:
+		return S_RegisterSound( (const char *)VMA(1) );
+	case CG_S_STARTBACKGROUNDTRACK:
+		S_StartBackgroundTrack( (const char *)VMA(1), (const char *)VMA(2), args[3]?qtrue:qfalse );
+		return 0;
+
+	case CG_S_UPDATEAMBIENTSET:
+		S_UpdateAmbientSet((const char *)VMA(1), (float *)VMA(2));
+		return 0;
+	case CG_AS_PARSESETS:
+		AS_ParseSets();
+		return 0;
+	case CG_AS_ADDPRECACHEENTRY:
+		AS_AddPrecacheEntry((const char *)VMA(1));
+		return 0;
+	case CG_S_ADDLOCALSET:
+		return S_AddLocalSet((const char *)VMA(1), (float *)VMA(2), (float *)VMA(3), args[4], args[5]);
+	case CG_AS_GETBMODELSOUND:
+		return AS_GetBModelSound((const char *)VMA(1), args[2]);
+
+	case CG_R_LOADWORLDMAP:
+		re.LoadWorld( (const char *)VMA(1) );
+		return 0; 
+	case CG_R_REGISTERMODEL:
+		return re.RegisterModel( (const char *)VMA(1) );
+	case CG_R_REGISTERSKIN:
+		return re.RegisterSkin( (const char *)VMA(1) );
+	case CG_R_REGISTERSHADER:
+		return re.RegisterShader( (const char *)VMA(1) );
+	case CG_R_REGISTERSHADERNOMIP:
+		return re.RegisterShaderNoMip( (const char *)VMA(1) );
+	case CG_R_REGISTERFONT:
+		return re.RegisterFont( (const char *)VMA(1) );
+	case CG_R_FONT_STRLENPIXELS:
+		return re.Font_StrLenPixels( (const char *)VMA(1), args[2], VMF(3) );
+	case CG_R_FONT_STRLENCHARS:
+		return re.Font_StrLenChars( (const char *)VMA(1) );
+	case CG_R_FONT_STRHEIGHTPIXELS:
+		return re.Font_HeightPixels( args[1], VMF(2) );
+	case CG_R_FONT_DRAWSTRING:
+		re.Font_DrawString( args[1], args[2], (const char *)VMA(3), (const float *) VMA(4), args[5], args[6], VMF(7) );
+		return 0;
+	case CG_LANGUAGE_ISASIAN:
+		return re.Language_IsAsian();
+	case CG_LANGUAGE_USESSPACES:
+		return re.Language_UsesSpaces();
+	case CG_ANYLANGUAGE_READCHARFROMSTRING:
+		return re.AnyLanguage_ReadCharFromString( (const char *) VMA(1), (int *) VMA(2), (qboolean *) VMA(3) );
+	case CG_R_CLEARSCENE:
+		re.ClearScene();
+		return 0;
+	case CG_R_CLEARDECALS:
+		re.ClearDecals();
+		return 0;
+	case CG_R_ADDREFENTITYTOSCENE:
+		re.AddRefEntityToScene( (const refEntity_t *)VMA(1) );
+		return 0;
+	case CG_R_ADDPOLYTOSCENE:
+		re.AddPolyToScene( args[1], args[2], (const polyVert_t *)VMA(3), 1 );
+		return 0;
+	case CG_R_ADDPOLYSTOSCENE:
+		re.AddPolyToScene( args[1], args[2], (const polyVert_t *)VMA(3), args[4] );
+		return 0;
+	case CG_R_ADDDECALTOSCENE:
+		re.AddDecalToScene( (qhandle_t)args[1], (const float*)VMA(2), (const float*)VMA(3), VMF(4), VMF(5), VMF(6), VMF(7), VMF(8), (qboolean)args[9], VMF(10), (qboolean)args[11] );
+		return 0;
+	case CG_R_LIGHTFORPOINT:
+		return re.LightForPoint( (float *)VMA(1), (float *)VMA(2), (float *)VMA(3), (float *)VMA(4) );
+	case CG_R_ADDLIGHTTOSCENE:
+#ifdef VV_LIGHTING
+		VVLightMan.RE_AddLightToScene( (const float *)VMA(1), VMF(2), VMF(3), VMF(4), VMF(5) );
+#else
+		re.AddLightToScene( (const float *)VMA(1), VMF(2), VMF(3), VMF(4), VMF(5) );
+#endif
+		return 0;
+	case CG_R_ADDADDITIVELIGHTTOSCENE:
+#ifdef VV_LIGHTING
+		VVLightMan.RE_AddLightToScene( (const float *)VMA(1), VMF(2), VMF(3), VMF(4), VMF(5) );
+#else
+		re.AddAdditiveLightToScene( (const float *)VMA(1), VMF(2), VMF(3), VMF(4), VMF(5) );
+#endif
+		return 0;
+	case CG_R_RENDERSCENE:
+		re.RenderScene( (const refdef_t *)VMA(1) );
+		return 0;
+	case CG_R_SETCOLOR:
+		re.SetColor( (const float *)VMA(1) );
+		return 0;
+	case CG_R_DRAWSTRETCHPIC:
+		re.DrawStretchPic( VMF(1), VMF(2), VMF(3), VMF(4), VMF(5), VMF(6), VMF(7), VMF(8), args[9] );
+		return 0;
+	case CG_R_MODELBOUNDS:
+		re.ModelBounds( args[1], (float *)VMA(2), (float *)VMA(3) );
+		return 0;
+	case CG_R_LERPTAG:
+		return re.LerpTag( (orientation_t *)VMA(1), args[2], args[3], args[4], VMF(5), (const char *)VMA(6) );
+	case CG_R_DRAWROTATEPIC:
+		re.DrawRotatePic( VMF(1), VMF(2), VMF(3), VMF(4), VMF(5), VMF(6), VMF(7), VMF(8), VMF(9), args[10] );
+		return 0;
+	case CG_R_DRAWROTATEPIC2:
+		re.DrawRotatePic2( VMF(1), VMF(2), VMF(3), VMF(4), VMF(5), VMF(6), VMF(7), VMF(8), VMF(9), args[10] );
+		return 0;
+	
+	case CG_R_SETRANGEFOG:
+		tr.rangedFog = VMF(1);
+		return 0;
+
+	case CG_R_SETREFRACTIONPROP:
+		tr_distortionAlpha = VMF(1);
+		tr_distortionStretch = VMF(2);
+		tr_distortionPrePost = (qboolean)args[3];
+		tr_distortionNegate = (qboolean)args[4];
+		return 0;
+
+	case CG_GETGLCONFIG:
+		CL_GetGlconfig( (glconfig_t *)VMA(1) );
+		return 0;
+	case CG_GETGAMESTATE:
+		CL_GetGameState( (gameState_t *)VMA(1) );
+		return 0;
+	case CG_GETCURRENTSNAPSHOTNUMBER:
+		CL_GetCurrentSnapshotNumber( (int *)VMA(1), (int *)VMA(2) );
+		return 0;
+	case CG_GETSNAPSHOT:
+		return CL_GetSnapshot( args[1], (snapshot_t *)VMA(2) );
+	case CG_GETDEFAULTSTATE:
+		return CL_GetDefaultState(args[1], (entityState_t *)VMA(2));
+	case CG_GETSERVERCOMMAND:
+		return CL_GetServerCommand( args[1] );
+	case CG_GETCURRENTCMDNUMBER:
+		return CL_GetCurrentCmdNumber();
+	case CG_GETUSERCMD:
+		return CL_GetUserCmd( args[1], (struct usercmd_s *)VMA(2) );
+	case CG_SETUSERCMDVALUE:
+		cl_bUseFighterPitch = (qboolean)args[8];
+		CL_SetUserCmdValue( args[1], VMF(2), VMF(3), VMF(4), VMF(5), args[6], args[7] );
+		return 0;
+	case CG_SETCLIENTFORCEANGLE:
+		CL_SetClientForceAngle(args[1], (float *)VMA(2));
+		return 0;
+	case CG_SETCLIENTTURNEXTENT:
+		return 0;
+
+	case CG_OPENUIMENU:
+		VM_Call( uivm, UI_SET_ACTIVE_MENU, args[1] );
+		return 0;
+
+	case CG_MEMORY_REMAINING:
+		return Hunk_MemoryRemaining();
+  case CG_KEY_ISDOWN:
+		return Key_IsDown( args[1] );
+  case CG_KEY_GETCATCHER:
+		return Key_GetCatcher();
+  case CG_KEY_SETCATCHER:
+		Key_SetCatcher( args[1] );
+    return 0;
+  case CG_KEY_GETKEY:
+		return Key_GetKey( (const char *)VMA(1) );
+
+	case CG_PC_ADD_GLOBAL_DEFINE:
+		return botlib_export->PC_AddGlobalDefine( (char *)VMA(1) );
+	case CG_PC_LOAD_SOURCE:
+		return botlib_export->PC_LoadSourceHandle( (const char *)VMA(1) );
+	case CG_PC_FREE_SOURCE:
+		return botlib_export->PC_FreeSourceHandle( args[1] );
+	case CG_PC_READ_TOKEN:
+		return botlib_export->PC_ReadTokenHandle( args[1], (struct pc_token_s *)VMA(2) );
+	case CG_PC_SOURCE_FILE_AND_LINE:
+		return botlib_export->PC_SourceFileAndLine( args[1], (char *)VMA(2), (int *)VMA(3) );
+	case CG_PC_LOAD_GLOBAL_DEFINES:
+		return botlib_export->PC_LoadGlobalDefines ( (char *)VMA(1) );
+	case CG_PC_REMOVE_ALL_GLOBAL_DEFINES:
+		botlib_export->PC_RemoveAllGlobalDefines ( );
+		return 0;
+
+	case CG_S_STOPBACKGROUNDTRACK:
+		S_StopBackgroundTrack();
+		return 0;
+
+	case CG_REAL_TIME:
+		return Com_RealTime( (struct qtime_s *)VMA(1) );
+	case CG_SNAPVECTOR:
+		Sys_SnapVector( (float *)VMA(1) );
+		return 0;
+
+	case CG_CIN_PLAYCINEMATIC:
+	  return CIN_PlayCinematic((const char *)VMA(1), args[2], args[3], args[4], args[5], args[6]);
+
+	case CG_CIN_STOPCINEMATIC:
+	  return CIN_StopCinematic(args[1]);
+
+	case CG_CIN_RUNCINEMATIC:
+	  return CIN_RunCinematic(args[1]);
+
+	case CG_CIN_DRAWCINEMATIC:
+	  CIN_DrawCinematic(args[1]);
+	  return 0;
+
+	case CG_CIN_SETEXTENTS:
+	  CIN_SetExtents(args[1], args[2], args[3], args[4], args[5]);
+	  return 0;
+
+	case CG_R_REMAP_SHADER:
+		re.RemapShader( (const char *)VMA(1), (const char *)VMA(2), (const char *)VMA(3) );
+		return 0;
+
+	case CG_R_GET_LIGHT_STYLE:
+		re.GetLightStyle(args[1], (unsigned char *)VMA(2));
+		return 0;
+
+	case CG_R_SET_LIGHT_STYLE:
+		re.SetLightStyle(args[1], args[2]);
+		return 0;
+
+	case CG_R_GET_BMODEL_VERTS:
+		re.GetBModelVerts( args[1], (float (*)[3])VMA(2), (float *)VMA(3) );
+		return 0;
+
+	case CG_R_GETDISTANCECULL:
+		{
+			float *f;
+			f = (float *)VMA(1);
+			*f = tr.distanceCull;
+		}
+		return 0;
+
+	case CG_R_GETREALRES:
+		{
+			int *w = (int *)VMA(1);
+			int *h = (int *)VMA(2);
+			*w = glConfig.vidWidth;
+			*h = glConfig.vidHeight;
+		}
+		return 0;
+
+	case CG_R_AUTOMAPELEVADJ:
+		R_AutomapElevationAdjustment(VMF(1));
+		return 0;
+
+	case CG_R_INITWIREFRAMEAUTO:
+		return R_InitializeWireframeAutomap();
+
+/*
+	case CG_LOADCAMERA:
+		return loadCamera(VMA(1));
+
+	case CG_STARTCAMERA:
+		startCamera(args[1]);
+		return 0;
+
+	case CG_GETCAMERAINFO:
+		return getCameraInfo(args[1], VMA(2), VMA(3));
+*/
+	case CG_GET_ENTITY_TOKEN:
+		return re.GetEntityToken( (char *)VMA(1), args[2] );
+	case CG_R_INPVS:
+		return re.inPVS( (const float *)VMA(1), (const float *)VMA(2), (byte *)VMA(3) );
+
+#ifndef DEBUG_DISABLEFXCALLS
+	case CG_FX_ADDLINE:
+		FX_AddLine( (float *)VMA(1), (float *)VMA(2), VMF(3), VMF(4), VMF(5), 
+									VMF(6), VMF(7), VMF(8), 
+									(float *)VMA(9), (float *)VMA(10), VMF(11), 
+									args[12], args[13], args[14]);
+		return 0;
+	case CG_FX_REGISTER_EFFECT:
+		return FX_RegisterEffect((const char *)VMA(1));
+
+	case CG_FX_PLAY_EFFECT:
+		FX_PlayEffect((const char *)VMA(1), (float *)VMA(2), (float *)VMA(3), args[4], args[5] );
+		return 0;
+
+	case CG_FX_PLAY_ENTITY_EFFECT:
+		assert(0);//gone!
+		//FX_PlayEntityEffect((const char *)VMA(1), (float *)VMA(2), (vec3_t *)VMA(3), args[4], args[5], args[6], args[7] );
+		return 0;
+
+	case CG_FX_PLAY_EFFECT_ID:
+		FX_PlayEffectID(args[1], (float *)VMA(2), (float *)VMA(3), args[4], args[5] );
+		return 0;
+
+	case CG_FX_PLAY_PORTAL_EFFECT_ID:
+		FX_PlayEffectID(args[1], (float *)VMA(2), (float *)VMA(3), args[4], args[5], qtrue );
+		return 0;
+
+	case CG_FX_PLAY_ENTITY_EFFECT_ID:
+		FX_PlayEntityEffectID(args[1], (float *)VMA(2), (vec3_t *)VMA(3), args[4], args[5], args[6], args[7] );
+		return 0;
+
+	case CG_FX_PLAY_BOLTED_EFFECT_ID:
+		{
+		//( int id, vec3_t org, void *pGhoul2, const int boltNum, const int entNum, const int modelNum, int iLooptime, qboolean isRelative );
+		CGhoul2Info_v &g2 = *((CGhoul2Info_v *)args[3]);
+		int boltInfo=0;
+		if ( G2API_AttachEnt( &boltInfo, &g2[args[6]], args[4], args[5], args[6] ) )
+		{
+			FX_PlayBoltedEffectID(args[1], (float *)VMA(2), boltInfo, g2.mItem, args[7], (qboolean)args[8] );
+			return 1;
+		}
+		return 0;
+		}
+	case CG_FX_ADD_SCHEDULED_EFFECTS:
+		FX_AddScheduledEffects((qboolean)args[1]);
+		return 0;
+
+	case CG_FX_DRAW_2D_EFFECTS:
+		FX_Draw2DEffects ( VMF(1), VMF(2) );
+		return 0;
+
+	case CG_FX_INIT_SYSTEM:
+		return FX_InitSystem( (refdef_t*)VMA(1) );
+
+	case CG_FX_SET_REFDEF:
+		FX_SetRefDefFromCGame( (refdef_t*)VMA(1) );
+		return 0;
+
+	case CG_FX_FREE_SYSTEM:
+		return FX_FreeSystem();
+
+	case CG_FX_ADJUST_TIME:
+		FX_AdjustTime(args[1]);
+		return 0;
+
+	case CG_FX_RESET:
+		FX_Free ( false );
+		return 0;
+
+	case CG_FX_ADDPOLY:
+		{
+			addpolyArgStruct_t *p;
+
+			p = (addpolyArgStruct_t *)VMA(1);//args[1];
+
+			if (p)
+			{
+				FX_AddPoly(p->p, p->ev, p->numVerts, p->vel, p->accel, p->alpha1, p->alpha2,
+					p->alphaParm, p->rgb1, p->rgb2, p->rgbParm, p->rotationDelta, p->bounce, p->motionDelay,
+					p->killTime, p->shader, p->flags);
+			}
+		}
+		return 0;
+
+	case CG_FX_ADDBEZIER:
+		{
+			addbezierArgStruct_t *b;
+
+			b = (addbezierArgStruct_t *)VMA(1);//args[1];
+
+			if (b)
+			{
+				FX_AddBezier(b->start, b->end, b->control1, b->control1Vel, b->control2, b->control2Vel,
+					b->size1, b->size2, b->sizeParm, b->alpha1, b->alpha2, b->alphaParm, b->sRGB,
+					b->eRGB, b->rgbParm, b->killTime, b->shader, b->flags);
+			}
+		}
+		return 0;
+
+	case CG_FX_ADDPRIMITIVE:
+		{
+			effectTrailArgStruct_t *a;
+
+			a = (effectTrailArgStruct_t *)VMA(1);//args[1];
+
+			if (a)
+			{
+				FX_FeedTrail(a);
+			}
+		}
+		return 0;
+
+	case CG_FX_ADDSPRITE:
+		{
+			addspriteArgStruct_t *s;
+
+			s = (addspriteArgStruct_t *)VMA(1);//args[1];
+
+			if (s)
+			{
+				vec3_t rgb;
+				rgb[0] = 1;
+				rgb[1] = 1;
+				rgb[2] = 1;
+				//FX_AddSprite(NULL, s->origin, s->vel, s->accel, s->scale, s->dscale, s->sAlpha, s->eAlpha,
+				//	s->rotation, s->bounce, s->life, s->shader, s->flags);
+				FX_AddParticle(s->origin, s->vel, s->accel, s->scale, s->dscale, 0, s->sAlpha, s->eAlpha, 0,
+					rgb, rgb, 0, s->rotation, 0, vec3_origin, vec3_origin, s->bounce, 0, 0, s->life,
+					s->shader, s->flags);
+			}
+		}
+		return 0;
+	case CG_FX_ADDELECTRICITY:
+		{
+			addElectricityArgStruct_t *p;
+
+			p = (addElectricityArgStruct_t *)VMA(1);
+
+			if (p)
+			{
+
+				FX_AddElectricity(p->start, p->end, p->size1, p->size2, p->sizeParm, p->alpha1, p->alpha2,
+					p->alphaParm, p->sRGB, p->eRGB, p->rgbParm, p->chaos, p->killTime, p->shader, p->flags);
+			}
+		}
+		return 0;
+#else
+	case CG_FX_REGISTER_EFFECT:
+	case CG_FX_PLAY_EFFECT:
+	case CG_FX_PLAY_ENTITY_EFFECT:
+	case CG_FX_PLAY_EFFECT_ID:
+	case CG_FX_PLAY_PORTAL_EFFECT_ID:
+	case CG_FX_PLAY_ENTITY_EFFECT_ID:
+	case CG_FX_PLAY_BOLTED_EFFECT_ID:
+	case CG_FX_ADD_SCHEDULED_EFFECTS:
+	case CG_FX_INIT_SYSTEM:
+	case CG_FX_FREE_SYSTEM:
+	case CG_FX_ADJUST_TIME:
+	case CG_FX_ADDPOLY:
+	case CG_FX_ADDBEZIER:
+	case CG_FX_ADDPRIMITIVE:
+	case CG_FX_ADDSPRITE:
+	case CG_FX_ADDELECTRICITY:
+		return 0;
+#endif
+
+//	case CG_SP_PRINT:
+//		CL_SP_Print(args[1], (byte *)VMA(2));
+//		return 0;
+
+	case CG_ROFF_CLEAN:
+		return theROFFSystem.Clean(qtrue);
+	
+	case CG_ROFF_UPDATE_ENTITIES:
+		theROFFSystem.UpdateEntities(qtrue);
+		return 0;
+
+	case CG_ROFF_CACHE:
+		return theROFFSystem.Cache( (char *)VMA(1), qtrue );
+		
+	case CG_ROFF_PLAY:
+		return theROFFSystem.Play(args[1], args[2], (qboolean)args[3], qtrue );
+
+	case CG_ROFF_PURGE_ENT:
+		return theROFFSystem.PurgeEnt( args[1], qtrue );
+
+	//rww - dynamic vm memory allocation!
+	case CG_TRUEMALLOC:
+		VM_Shifted_Alloc((void **)VMA(1), args[2]);
+		return 0;
+	case CG_TRUEFREE:
+		VM_Shifted_Free((void **)VMA(1));
+		return 0;
+
+/*
+Ghoul2 Insert Start
+*/
+		
+	case CG_G2_LISTSURFACES:
+		G2API_ListSurfaces( (CGhoul2Info *) args[1] );
+		return 0;
+
+	case CG_G2_LISTBONES:
+		G2API_ListBones( (CGhoul2Info *) args[1], args[2]);
+		return 0;
+
+	case CG_G2_HAVEWEGHOULMODELS:
+		return G2API_HaveWeGhoul2Models( *((CGhoul2Info_v *)args[1]) );
+
+	case CG_G2_SETMODELS:
+		G2API_SetGhoul2ModelIndexes( *((CGhoul2Info_v *)args[1]),(qhandle_t *)VMA(2),(qhandle_t *)VMA(3));
+		return 0;
+
+	case CG_G2_GETBOLT:
+		return G2API_GetBoltMatrix(*((CGhoul2Info_v *)args[1]), args[2], args[3], (mdxaBone_t *)VMA(4), (const float *)VMA(5),(const float *)VMA(6), args[7], (qhandle_t *)VMA(8), (float *)VMA(9));
+
+	case CG_G2_GETBOLT_NOREC:
+		gG2_GBMNoReconstruct = qtrue;
+		return G2API_GetBoltMatrix(*((CGhoul2Info_v *)args[1]), args[2], args[3], (mdxaBone_t *)VMA(4), (const float *)VMA(5),(const float *)VMA(6), args[7], (qhandle_t *)VMA(8), (float *)VMA(9));
+
+	case CG_G2_GETBOLT_NOREC_NOROT:
+		//gG2_GBMNoReconstruct = qtrue;
+		//Yeah, this was probably BAD.
+		gG2_GBMUseSPMethod = qtrue;
+		return G2API_GetBoltMatrix(*((CGhoul2Info_v *)args[1]), args[2], args[3], (mdxaBone_t *)VMA(4), (const float *)VMA(5),(const float *)VMA(6), args[7], (qhandle_t *)VMA(8), (float *)VMA(9));
+
+	case CG_G2_INITGHOUL2MODEL:
+#ifdef _FULL_G2_LEAK_CHECKING
+		g_G2AllocServer = 0;
+#endif
+		return	G2API_InitGhoul2Model((CGhoul2Info_v **)VMA(1), (const char *)VMA(2), args[3], (qhandle_t) args[4],
+									  (qhandle_t) args[5], args[6], args[7]);
+
+	case CG_G2_SETSKIN:
+		{
+			CGhoul2Info_v &g2 = *((CGhoul2Info_v *)args[1]);
+			int modelIndex = args[2];
+			
+			return G2API_SetSkin(&g2[modelIndex], args[3], args[4]);
+		}
+
+	case CG_G2_COLLISIONDETECT:
+		G2API_CollisionDetect ( (CollisionRecord_t*)VMA(1), *((CGhoul2Info_v *)args[2]), 
+								   (const float*)VMA(3),
+								   (const float*)VMA(4),
+								   args[5],
+								   args[6],
+								   (float*)VMA(7),
+								   (float*)VMA(8),
+								   (float*)VMA(9),
+								   G2VertSpaceClient,
+								   args[10],
+								   args[11],
+								   VMF(12) );
+		return 0;
+
+	case CG_G2_ANGLEOVERRIDE:
+		return G2API_SetBoneAngles(*((CGhoul2Info_v *)args[1]), args[2], (const char *)VMA(3), (float *)VMA(4), args[5],
+							 (const Eorientations) args[6], (const Eorientations) args[7], (const Eorientations) args[8],
+							 (qhandle_t *)VMA(9), args[10], args[11] );
+	
+	case CG_G2_CLEANMODELS:
+#ifdef _FULL_G2_LEAK_CHECKING
+		g_G2AllocServer = 0;
+#endif
+		G2API_CleanGhoul2Models((CGhoul2Info_v **)VMA(1));
+	//	G2API_CleanGhoul2Models((CGhoul2Info_v **)args[1]);
+		return 0;
+
+	case CG_G2_PLAYANIM:
+		return G2API_SetBoneAnim(*((CGhoul2Info_v *)args[1]), args[2], (const char *)VMA(3), args[4], args[5],
+								args[6], VMF(7), args[8], VMF(9), args[10]);
+
+	case CG_G2_GETBONEANIM:
+		{
+			CGhoul2Info_v &g2 = *((CGhoul2Info_v *)args[1]);
+			int modelIndex = args[10];
+
+			return G2API_GetBoneAnim(&g2[modelIndex], (const char*)VMA(2), args[3], (float *)VMA(4), (int *)VMA(5),
+								(int *)VMA(6), (int *)VMA(7), (float *)VMA(8), (int *)VMA(9));
+		}
+
+	case CG_G2_GETBONEFRAME:
+		{ //rwwFIXMEFIXME: Just make a G2API_GetBoneFrame func too. This is dirty.
+			CGhoul2Info_v &g2 = *((CGhoul2Info_v *)args[1]);
+			int modelIndex = args[6];
+			int iDontCare1 = 0, iDontCare2 = 0, iDontCare3 = 0;
+			float fDontCare1 = 0;
+
+			return G2API_GetBoneAnim(&g2[modelIndex], (const char*)VMA(2), args[3], (float *)VMA(4), &iDontCare1,
+								&iDontCare2, &iDontCare3, &fDontCare1, (int *)VMA(5));
+		}
+
+	case CG_G2_GETGLANAME:
+		//	return (int)G2API_GetGLAName(*((CGhoul2Info_v *)VMA(1)), args[2]);
+		{
+			char *point = ((char *)VMA(3));
+			char *local;
+			local = G2API_GetGLAName(*((CGhoul2Info_v *)args[1]), args[2]);
+			if (local)
+			{
+				strcpy(point, local);
+			}
+		}
+		return 0;
+
+	case CG_G2_COPYGHOUL2INSTANCE:
+		return (int)G2API_CopyGhoul2Instance(*((CGhoul2Info_v *)args[1]), *((CGhoul2Info_v *)args[2]), args[3]);
+
+	case CG_G2_COPYSPECIFICGHOUL2MODEL:
+		G2API_CopySpecificG2Model(*((CGhoul2Info_v *)args[1]), args[2], *((CGhoul2Info_v *)args[3]), args[4]);
+		return 0;
+
+	case CG_G2_DUPLICATEGHOUL2INSTANCE:
+#ifdef _FULL_G2_LEAK_CHECKING
+		g_G2AllocServer = 0;
+#endif
+		G2API_DuplicateGhoul2Instance(*((CGhoul2Info_v *)args[1]), (CGhoul2Info_v **)VMA(2));
+		return 0;
+
+	case CG_G2_HASGHOUL2MODELONINDEX:
+		return (int)G2API_HasGhoul2ModelOnIndex((CGhoul2Info_v **)VMA(1), args[2]);
+		//return (int)G2API_HasGhoul2ModelOnIndex((CGhoul2Info_v **)args[1], args[2]);
+
+	case CG_G2_REMOVEGHOUL2MODEL:
+#ifdef _FULL_G2_LEAK_CHECKING
+		g_G2AllocServer = 0;
+#endif
+		return (int)G2API_RemoveGhoul2Model((CGhoul2Info_v **)VMA(1), args[2]);
+		//return (int)G2API_RemoveGhoul2Model((CGhoul2Info_v **)args[1], args[2]);
+
+	case CG_G2_SKINLESSMODEL:
+		{
+			CGhoul2Info_v &g2 = *((CGhoul2Info_v *)args[1]);
+			return G2API_SkinlessModel(&g2[args[2]]);
+		}
+
+	case CG_G2_GETNUMGOREMARKS:
+#ifdef _G2_GORE
+		{
+			CGhoul2Info_v &g2 = *((CGhoul2Info_v *)args[1]);
+			return G2API_GetNumGoreMarks(&g2[args[2]]);
+		}
+#endif
+		return 0;
+
+	case CG_G2_ADDSKINGORE:
+#ifdef _G2_GORE
+		G2API_AddSkinGore(*((CGhoul2Info_v *)args[1]),*(SSkinGoreData *)VMA(2));
+#endif
+		return 0;
+
+	case CG_G2_CLEARSKINGORE:
+#ifdef _G2_GORE
+		G2API_ClearSkinGore ( *((CGhoul2Info_v *)args[1]) );
+#endif
+		return 0;
+
+	case CG_G2_SIZE:
+		return G2API_Ghoul2Size ( *((CGhoul2Info_v *)args[1]) );
+		break;
+
+	case CG_G2_ADDBOLT:
+		return	G2API_AddBolt(*((CGhoul2Info_v *)args[1]), args[2], (const char *)VMA(3));
+
+
+	case CG_G2_ATTACHENT:
+//				G2API_AttachEnt(int *boltInfo, CGhoul2Info *ghlInfoTo, int toBoltIndex, int entNum, int toModelNum)
+		{
+			CGhoul2Info_v &g2 = *((CGhoul2Info_v *)args[2]);
+			return	G2API_AttachEnt( (int*)VMA(1), &g2[0], args[3], args[4], args[5] );
+		}
+
+	case CG_G2_SETBOLTON:
+		G2API_SetBoltInfo(*((CGhoul2Info_v *)args[1]), args[2], args[3]);
+		return 0;
+
+#ifdef _SOF2	
+	case CG_G2_ADDSKINGORE:
+		G2API_AddSkinGore(*((CGhoul2Info_v *)args[1]),*(SSkinGoreData *)VMA(2));
+		return 0;
+#endif // _SOF2
+/*
+Ghoul2 Insert End
+*/
+	case CG_G2_SETROOTSURFACE:
+		return G2API_SetRootSurface(*((CGhoul2Info_v *)args[1]), args[2], (const char *)VMA(3));
+
+	case CG_G2_SETSURFACEONOFF:
+		return G2API_SetSurfaceOnOff(*((CGhoul2Info_v *)args[1]), (const char *)VMA(2), /*(const int)VMA(3)*/args[3]);
+
+	case CG_G2_SETNEWORIGIN:
+		return G2API_SetNewOrigin(*((CGhoul2Info_v *)args[1]), /*(const int)VMA(2)*/args[2]);
+
+	case CG_G2_DOESBONEEXIST:
+		{
+			CGhoul2Info_v &g2 = *((CGhoul2Info_v *)args[1]);
+			return G2API_DoesBoneExist(&g2[args[2]], (const char *)VMA(3));
+		}
+
+	case CG_G2_GETSURFACERENDERSTATUS:
+	{
+		CGhoul2Info_v &g2 = *((CGhoul2Info_v *)args[1]);
+
+		return G2API_GetSurfaceRenderStatus(&g2[args[2]], (const char *)VMA(3));
+	}
+
+	case CG_G2_GETTIME:
+		return G2API_GetTime(0);
+
+	case CG_G2_SETTIME:
+		G2API_SetTime(args[1], args[2]);
+		return 0;
+
+	case CG_G2_ABSURDSMOOTHING:
+		{
+			CGhoul2Info_v &g2 = *((CGhoul2Info_v *)args[1]);
+
+			G2API_AbsurdSmoothing(g2, (qboolean)args[2]);
+		}
+		return 0;
+
+
+	case CG_G2_SETRAGDOLL:
+		{
+			//Convert the info in the shared structure over to the class-based version.
+			sharedRagDollParams_t *rdParamst = (sharedRagDollParams_t *)VMA(2);
+			CRagDollParams rdParams;
+
+			if (!rdParamst)
+			{
+				G2API_ResetRagDoll(*((CGhoul2Info_v *)args[1]));
+				return 0;
+			}
+
+			VectorCopy(rdParamst->angles, rdParams.angles);
+			VectorCopy(rdParamst->position, rdParams.position);
+			VectorCopy(rdParamst->scale, rdParams.scale);
+			VectorCopy(rdParamst->pelvisAnglesOffset, rdParams.pelvisAnglesOffset);
+			VectorCopy(rdParamst->pelvisPositionOffset, rdParams.pelvisPositionOffset);
+
+			rdParams.fImpactStrength = rdParamst->fImpactStrength;
+			rdParams.fShotStrength = rdParamst->fShotStrength;
+			rdParams.me = rdParamst->me;
+
+			rdParams.startFrame = rdParamst->startFrame;
+			rdParams.endFrame = rdParamst->endFrame;
+
+			rdParams.collisionType = rdParamst->collisionType;
+			rdParams.CallRagDollBegin = rdParamst->CallRagDollBegin;
+
+			rdParams.RagPhase = (CRagDollParams::ERagPhase)rdParamst->RagPhase;
+			rdParams.effectorsToTurnOff = (CRagDollParams::ERagEffector)rdParamst->effectorsToTurnOff;
+
+			G2API_SetRagDoll(*((CGhoul2Info_v *)args[1]), &rdParams);
+		}
+		return 0;
+		break;
+	case CG_G2_ANIMATEG2MODELS:
+		{
+			sharedRagDollUpdateParams_t *rduParamst = (sharedRagDollUpdateParams_t *)VMA(3);
+			CRagDollUpdateParams rduParams;
+
+			if (!rduParamst)
+			{
+				return 0;
+			}
+
+			VectorCopy(rduParamst->angles, rduParams.angles);
+			VectorCopy(rduParamst->position, rduParams.position);
+			VectorCopy(rduParamst->scale, rduParams.scale);
+			VectorCopy(rduParamst->velocity, rduParams.velocity);
+
+			rduParams.me = rduParamst->me;
+			rduParams.settleFrame = rduParamst->settleFrame;
+
+			G2API_AnimateG2Models(*((CGhoul2Info_v *)args[1]), args[2], &rduParams);
+		}
+		return 0;
+		break;
+
+	//additional ragdoll options -rww
+	case CG_G2_RAGPCJCONSTRAINT:
+		return G2API_RagPCJConstraint(*((CGhoul2Info_v *)args[1]), (const char *)VMA(2), (float *)VMA(3), (float *)VMA(4));
+	case CG_G2_RAGPCJGRADIENTSPEED:
+		return G2API_RagPCJGradientSpeed(*((CGhoul2Info_v *)args[1]), (const char *)VMA(2), VMF(3));
+	case CG_G2_RAGEFFECTORGOAL:
+		return G2API_RagEffectorGoal(*((CGhoul2Info_v *)args[1]), (const char *)VMA(2), (float *)VMA(3));
+	case CG_G2_GETRAGBONEPOS:
+		return G2API_GetRagBonePos(*((CGhoul2Info_v *)args[1]), (const char *)VMA(2), (float *)VMA(3), (float *)VMA(4), (float *)VMA(5), (float *)VMA(6));
+	case CG_G2_RAGEFFECTORKICK:
+		return G2API_RagEffectorKick(*((CGhoul2Info_v *)args[1]), (const char *)VMA(2), (float *)VMA(3));
+	case CG_G2_RAGFORCESOLVE:
+		return G2API_RagForceSolve(*((CGhoul2Info_v *)args[1]), (qboolean)args[2]);
+
+	case CG_G2_SETBONEIKSTATE:
+		return G2API_SetBoneIKState(*((CGhoul2Info_v *)args[1]), args[2], (const char *)VMA(3), args[4], (sharedSetBoneIKStateParams_t *)VMA(5));
+	case CG_G2_IKMOVE:
+		return G2API_IKMove(*((CGhoul2Info_v *)args[1]), args[2], (sharedIKMoveParams_t *)VMA(3));
+
+	case CG_G2_REMOVEBONE:
+		{
+			CGhoul2Info_v &g2 = *((CGhoul2Info_v *)args[1]);
+
+			return G2API_RemoveBone(&g2[args[3]], (const char *)VMA(2));
+		}
+
+	case CG_G2_ATTACHINSTANCETOENTNUM:
+		{
+			G2API_AttachInstanceToEntNum(*((CGhoul2Info_v *)args[1]), args[2], (qboolean)args[3]);
+		}
+		return 0;
+	case CG_G2_CLEARATTACHEDINSTANCE:
+		G2API_ClearAttachedInstance(args[1]);
+		return 0;
+	case CG_G2_CLEANENTATTACHMENTS:
+		G2API_CleanEntAttachments();
+		return 0;
+	case CG_G2_OVERRIDESERVER:
+		{
+			CGhoul2Info_v &g2 = *((CGhoul2Info_v *)args[1]);
+			return G2API_OverrideServerWithClientData(&g2[0]);
+		}
+
+	case CG_G2_GETSURFACENAME:
+		{ //Since returning a pointer in such a way to a VM seems to cause MASSIVE FAILURE<tm>, we will shove data into the pointer the vm passes instead
+			char *point = ((char *)VMA(4));
+			char *local;
+			int modelindex = args[3];
+
+			CGhoul2Info_v &g2 = *((CGhoul2Info_v *)args[1]);
+
+			local = G2API_GetSurfaceName(&g2[modelindex], args[2]);
+			if (local)
+			{
+				strcpy(point, local);
+			}
+		}
+
+		return 0;
+
+	case CG_SP_GETSTRINGTEXTSTRING:
+//	case CG_SP_GETSTRINGTEXT:
+		const char* text;
+
+		assert(VMA(1));
+		assert(VMA(2));
+
+//		if (args[0] == CG_SP_GETSTRINGTEXT)
+//		{
+//			text = SP_GetStringText( args[1] );
+//		}
+//		else
+		{
+			text = SE_GetString( (const char *) VMA(1) );
+		}
+
+		if ( text[0] )
+		{
+			Q_strncpyz( (char *) VMA(2), text, args[3] );
+			return qtrue;
+		}
+		else 
+		{
+			Com_sprintf( (char *) VMA(2), args[3], "??%s", VMA(1) );
+			return qfalse;
+		}
+		break;
+
+	case CG_SET_SHARED_BUFFER:
+		cl.mSharedMemory = ((char *)VMA(1));
+		return 0;
+
+	case CG_CM_REGISTER_TERRAIN:
+		return CM_RegisterTerrain((const char *)VMA(1), false)->GetTerrainId();
+
+	case CG_RMG_INIT:
+#ifndef PRE_RELEASE_DEMO
+		if (!com_sv_running->integer)
+		{	// don't do this if we are connected locally
+			if (!TheRandomMissionManager)
+			{
+				TheRandomMissionManager = new CRMManager;
+			}
+			TheRandomMissionManager->SetLandScape( cmg.landScape );
+			if (TheRandomMissionManager->LoadMission(qfalse))
+			{
+				if (!TheRandomMissionManager->SpawnMission(qfalse))
+				{
+					Com_Error(ERR_DROP, "Error spawning mission for terrain");
+				}
+			}
+			cmg.landScape->UpdatePatches();
+		}
+		RM_CreateRandomModels(args[1], (const char *)VMA(2));
+//		TheRandomMissionManager->CreateMap();
+#endif // PRE_RELEASE_DEMO
+		return 0;
+
+	case CG_RE_INIT_RENDERER_TERRAIN:
+		RE_InitRendererTerrain((const char *)VMA(1));
+		return 0;
+
+	case CG_R_WEATHER_CONTENTS_OVERRIDE:
+		//contentOverride = args[1];
+		return 0;
+
+	case CG_R_WORLDEFFECTCOMMAND:
+		R_WorldEffectCommand((const char *)VMA(1));
+		return 0;
+
+	case CG_WE_ADDWEATHERZONE:
+		R_AddWeatherZone( (vec_t *)VMA(1), (vec_t *)VMA(2) );
+		return 0;
+
+	default:
+	        assert(0); // bk010102
+		Com_Error( ERR_DROP, "Bad cgame system trap: %i", args[0] );
+	}
+	return 0;
+}
+
+
+/*
+====================
+CL_InitCGame
+
+Should only be called by CL_StartHunkUsers
+====================
+*/
+void CL_InitCGame( void ) {
+	const char			*info;
+	const char			*mapname;
+//	int					t1, t2;
+	vmInterpret_t		interpret;
+
+//	t1 = Sys_Milliseconds();
+
+	// put away the console
+	Con_Close();
+
+	// find the current mapname
+	info = cl.gameState.stringData + cl.gameState.stringOffsets[ CS_SERVERINFO ];
+	mapname = Info_ValueForKey( info, "mapname" );
+	Com_sprintf( cl.mapname, sizeof( cl.mapname ), "maps/%s.bsp", mapname );
+
+	// load the dll or bytecode
+	if ( cl_connectedToPureServer != 0 ) {
+#if 0
+		// if sv_pure is set we only allow qvms to be loaded
+		interpret = VMI_COMPILED;
+#else //load the module type based on what the server is doing -rww
+		interpret = (vmInterpret_t)cl_connectedCGAME;
+#endif
+	}
+	else {
+		interpret = (vmInterpret_t)(int)Cvar_VariableValue( "vm_cgame" );
+	}
+	cgvm = VM_Create( "cgame", CL_CgameSystemCalls, interpret );
+	if ( !cgvm ) {
+		Com_Error( ERR_DROP, "VM_Create on cgame failed" );
+	}
+	cls.state = CA_LOADING;
+
+	// init for this gamestate
+	// use the lastExecutedServerCommand instead of the serverCommandSequence
+	// otherwise server commands sent just before a gamestate are dropped
+	VM_Call( cgvm, CG_INIT, clc.serverMessageSequence, clc.lastExecutedServerCommand, clc.clientNum );
+
+	// we will send a usercmd this frame, which
+	// will cause the server to send us the first snapshot
+	cls.state = CA_PRIMED;
+
+//	t2 = Sys_Milliseconds();
+
+//	Com_Printf( "CL_InitCGame: %5.2f seconds\n", (t2-t1)/1000.0 );
+
+	// have the renderer touch all its images, so they are present
+	// on the card even if the driver does deferred loading
+	re.EndRegistration();
+
+	// make sure everything is paged in
+//	if (!Sys_LowPhysicalMemory()) 
+	{
+		Com_TouchMemory();
+	}
+
+	// clear anything that got printed
+	Con_ClearNotify ();
+#ifdef _DONETPROFILE_
+	ClReadProf().Reset();
+#endif
+}
+
+
+/*
+====================
+CL_GameCommand
+
+See if the current console command is claimed by the cgame
+====================
+*/
+qboolean CL_GameCommand( void ) {
+	if ( !cgvm ) {
+		return qfalse;
+	}
+
+	return (qboolean)VM_Call( cgvm, CG_CONSOLE_COMMAND );
+}
+
+
+
+/*
+=====================
+CL_CGameRendering
+=====================
+*/
+void CL_CGameRendering( stereoFrame_t stereo ) {
+	//rww - RAGDOLL_BEGIN
+	if (!com_sv_running->integer)
+	{ //set the server time to match the client time, if we don't have a server going.
+		G2API_SetTime(cl.serverTime, 0);
+	}
+	G2API_SetTime(cl.serverTime, 1);
+	//rww - RAGDOLL_END
+
+#ifdef _XBOX	// No demos on Xbox
+	VM_Call( cgvm, CG_DRAW_ACTIVE_FRAME, cl.serverTime, stereo, 0 );
+#else
+	VM_Call( cgvm, CG_DRAW_ACTIVE_FRAME, cl.serverTime, stereo, clc.demoplaying );
+#endif
+	VM_Debug( 0 );
+}
+
+
+/*
+=================
+CL_AdjustTimeDelta
+
+Adjust the clients view of server time.
+
+We attempt to have cl.serverTime exactly equal the server's view
+of time plus the timeNudge, but with variable latencies over
+the internet it will often need to drift a bit to match conditions.
+
+Our ideal time would be to have the adjusted time approach, but not pass,
+the very latest snapshot.
+
+Adjustments are only made when a new snapshot arrives with a rational
+latency, which keeps the adjustment process framerate independent and
+prevents massive overadjustment during times of significant packet loss
+or bursted delayed packets.
+=================
+*/
+
+#define	RESET_TIME	500
+
+void CL_AdjustTimeDelta( void ) {
+	int		resetTime;
+	int		newDelta;
+	int		deltaDelta;
+
+	cl.newSnapshots = qfalse;
+
+	// the delta never drifts when replaying a demo
+#ifndef _XBOX	// No demos on Xbox
+	if ( clc.demoplaying ) {
+		return;
+	}
+#endif
+
+	// if the current time is WAY off, just correct to the current value
+	if ( com_sv_running->integer ) {
+		resetTime = 100;
+	} else {
+		resetTime = RESET_TIME;
+	}
+
+	newDelta = cl.snap.serverTime - cls.realtime;
+	deltaDelta = abs( newDelta - cl.serverTimeDelta );
+
+	if ( deltaDelta > RESET_TIME ) {
+		cl.serverTimeDelta = newDelta;
+		cl.oldServerTime = cl.snap.serverTime;	// FIXME: is this a problem for cgame?
+		cl.serverTime = cl.snap.serverTime;
+		if ( cl_showTimeDelta->integer ) {
+			Com_Printf( "<RESET> " );
+		}
+	} else if ( deltaDelta > 100 ) {
+		// fast adjust, cut the difference in half
+		if ( cl_showTimeDelta->integer ) {
+			Com_Printf( "<FAST> " );
+		}
+		cl.serverTimeDelta = ( cl.serverTimeDelta + newDelta ) >> 1;
+	} else {
+		// slow drift adjust, only move 1 or 2 msec
+
+		// if any of the frames between this and the previous snapshot
+		// had to be extrapolated, nudge our sense of time back a little
+		// the granularity of +1 / -2 is too high for timescale modified frametimes
+		if ( com_timescale->value == 0 || com_timescale->value == 1 ) {
+			if ( cl.extrapolatedSnapshot ) {
+				cl.extrapolatedSnapshot = qfalse;
+				cl.serverTimeDelta -= 2;
+			} else {
+				// otherwise, move our sense of time forward to minimize total latency
+				cl.serverTimeDelta++;
+			}
+		}
+	}
+
+	if ( cl_showTimeDelta->integer ) {
+		Com_Printf( "%i ", cl.serverTimeDelta );
+	}
+}
+
+
+/*
+==================
+CL_FirstSnapshot
+==================
+*/
+extern void RE_RegisterMedia_LevelLoadEnd(void);
+void CL_FirstSnapshot( void ) {
+	// ignore snapshots that don't have entities
+	if ( cl.snap.snapFlags & SNAPFLAG_NOT_ACTIVE ) {
+		return;
+	}
+
+	RE_RegisterMedia_LevelLoadEnd();
+
+	cls.state = CA_ACTIVE;
+
+	// set the timedelta so we are exactly on this first frame
+	cl.serverTimeDelta = cl.snap.serverTime - cls.realtime;
+	cl.oldServerTime = cl.snap.serverTime;
+
+#ifndef _XBOX	// No demos on Xbox
+	clc.timeDemoBaseTime = cl.snap.serverTime;
+#endif
+
+	// if this is the first frame of active play,
+	// execute the contents of activeAction now
+	// this is to allow scripting a timedemo to start right
+	// after loading
+	if ( cl_activeAction->string[0] ) {
+		Cbuf_AddText( cl_activeAction->string );
+		Cvar_Set( "activeAction", "" );
+	}
+	
+	Sys_BeginProfiling();
+
+#ifdef _XBOX
+	// turn vsync back on - tearing is ugly
+	qglEnable(GL_VSYNC);
+
+	// Start (or update) advertising on MM
+	if ( com_sv_running->integer )
+		XBL_MM_Advertise();
+#endif
+}
+
+/*
+==================
+CL_SetCGameTime
+==================
+*/
+void CL_SetCGameTime( void ) {
+	// getting a valid frame message ends the connection process
+	if ( cls.state != CA_ACTIVE ) {
+		if ( cls.state != CA_PRIMED ) {
+			return;
+		}
+#ifndef _XBOX	// No demos on Xbox
+		if ( clc.demoplaying ) {
+			// we shouldn't get the first snapshot on the same frame
+			// as the gamestate, because it causes a bad time skip
+			if ( !clc.firstDemoFrameSkipped ) {
+				clc.firstDemoFrameSkipped = qtrue;
+				return;
+			}
+			CL_ReadDemoMessage();
+		}
+#endif
+		if ( cl.newSnapshots ) {
+			cl.newSnapshots = qfalse;
+			CL_FirstSnapshot();
+		}
+		if ( cls.state != CA_ACTIVE ) {
+			return;
+		}
+	}	
+
+	// if we have gotten to this point, cl.snap is guaranteed to be valid
+	if ( !cl.snap.valid ) {
+		Com_Error( ERR_DROP, "CL_SetCGameTime: !cl.snap.valid" );
+	}
+
+	// allow pause in single player
+	if ( sv_paused->integer && cl_paused->integer && com_sv_running->integer ) {
+		// paused
+		return;
+	}
+
+	if ( cl.snap.serverTime < cl.oldFrameServerTime ) {
+		Com_Error( ERR_DROP, "cl.snap.serverTime < cl.oldFrameServerTime" );
+	}
+	cl.oldFrameServerTime = cl.snap.serverTime;
+
+
+	// get our current view of time
+
+#ifndef _XBOX	// No demos on Xbox
+	if ( clc.demoplaying && cl_freezeDemo->integer ) {
+		// cl_freezeDemo is used to lock a demo in place for single frame advances
+
+	} else
+#endif
+	{
+		// cl_timeNudge is a user adjustable cvar that allows more
+		// or less latency to be added in the interest of better 
+		// smoothness or better responsiveness.
+		int tn;
+		
+		tn = cl_timeNudge->integer;
+#ifdef _DEBUG
+		if (tn<-900) {
+			tn = -900;
+		} else if (tn>900) {
+			tn = 900;
+		}
+#else
+		if (tn<-30) {
+			tn = -30;
+		} else if (tn>30) {
+			tn = 30;
+		}
+#endif
+
+		cl.serverTime = cls.realtime + cl.serverTimeDelta - tn;
+
+		// guarantee that time will never flow backwards, even if
+		// serverTimeDelta made an adjustment or cl_timeNudge was changed
+		if ( cl.serverTime < cl.oldServerTime ) {
+			cl.serverTime = cl.oldServerTime;
+		}
+		cl.oldServerTime = cl.serverTime;
+
+		// note if we are almost past the latest frame (without timeNudge),
+		// so we will try and adjust back a bit when the next snapshot arrives
+		if ( cls.realtime + cl.serverTimeDelta >= cl.snap.serverTime - 5 ) {
+			cl.extrapolatedSnapshot = qtrue;
+		}
+	}
+
+	// if we have gotten new snapshots, drift serverTimeDelta
+	// don't do this every frame, or a period of packet loss would
+	// make a huge adjustment
+	if ( cl.newSnapshots ) {
+		CL_AdjustTimeDelta();
+	}
+
+#ifndef _XBOX	// No demos on Xbox
+	if ( !clc.demoplaying ) {
+		return;
+	}
+
+	// if we are playing a demo back, we can just keep reading
+	// messages from the demo file until the cgame definately
+	// has valid snapshots to interpolate between
+
+	// a timedemo will always use a deterministic set of time samples
+	// no matter what speed machine it is run on,
+	// while a normal demo may have different time samples
+	// each time it is played back
+	if ( cl_timedemo->integer ) {
+		if (!clc.timeDemoStart) {
+			clc.timeDemoStart = Sys_Milliseconds();
+		}
+		clc.timeDemoFrames++;
+		cl.serverTime = clc.timeDemoBaseTime + clc.timeDemoFrames * 50;
+	}
+
+	while ( cl.serverTime >= cl.snap.serverTime ) {
+		// feed another messag, which should change
+		// the contents of cl.snap
+		CL_ReadDemoMessage();
+		if ( cls.state != CA_ACTIVE ) {
+			return;		// end of demo
+		}
+	}
+#endif	// _XBOX
+}
+
+
+
diff --git a/codemp/client/cl_cin.cpp b/codemp/client/cl_cin.cpp
new file mode 100644
index 0000000..efc0714
--- /dev/null
+++ b/codemp/client/cl_cin.cpp
@@ -0,0 +1,1494 @@
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+/*****************************************************************************
+ * name:		cl_cin.c
+ *
+ * desc:		video and cinematic playback
+ *
+ * $Archive: /MissionPack/code/client/cl_cin.c $
+ * $Author: osman $ 
+ * $Revision: 1.4 $
+ * $Modtime: 6/12/01 10:36a $
+ * $Date: 2003/03/15 23:43:59 $
+ *
+ * cl_glconfig.hwtype trtypes 3dfx/ragepro need 256x256
+ *
+ *****************************************************************************/
+
+#include "client.h"
+#include "snd_local.h"
+
+#define MAXSIZE				8
+#define MINSIZE				4
+
+#define DEFAULT_CIN_WIDTH	512
+#define DEFAULT_CIN_HEIGHT	512
+
+#define ROQ_QUAD			0x1000
+#define ROQ_QUAD_INFO		0x1001
+#define ROQ_CODEBOOK		0x1002
+#define ROQ_QUAD_VQ			0x1011
+#define ROQ_QUAD_JPEG		0x1012
+#define ROQ_QUAD_HANG		0x1013
+#define ROQ_PACKET			0x1030
+#define ZA_SOUND_MONO		0x1020
+#define ZA_SOUND_STEREO		0x1021
+
+#define MAX_VIDEO_HANDLES	16
+
+extern glconfig_t glConfig;
+extern	int		s_paintedtime;
+extern	int		s_rawend;
+
+
+static void RoQ_init( void );
+
+/******************************************************************************
+*
+* Class:		trFMV
+*
+* Description:	RoQ/RnR manipulation routines
+*				not entirely complete for first run
+*
+******************************************************************************/
+
+static	long				ROQ_YY_tab[256];
+static	long				ROQ_UB_tab[256];
+static	long				ROQ_UG_tab[256];
+static	long				ROQ_VG_tab[256];
+static	long				ROQ_VR_tab[256];
+static	unsigned short		vq2[256*16*4];
+static	unsigned short		vq4[256*64*4];
+static	unsigned short		vq8[256*256*4];
+
+
+typedef struct {
+	byte				linbuf[DEFAULT_CIN_WIDTH*DEFAULT_CIN_HEIGHT*4*2];
+	byte				file[65536];
+	short				sqrTable[256];
+
+	unsigned int		mcomp[256];
+	byte				*qStatus[2][32768];
+
+	long				oldXOff, oldYOff;
+	unsigned int		oldysize, oldxsize;
+} cinematics_t;
+
+typedef struct {
+	char				fileName[MAX_OSPATH];
+	int					CIN_WIDTH, CIN_HEIGHT;
+	int					xpos, ypos, width, height;
+	qboolean			looping, holdAtEnd, dirty, alterGameState, silent, shader;
+	fileHandle_t		iFile;
+	e_status			status;
+	unsigned int		startTime;
+	unsigned int		lastTime;
+	long				tfps;
+	long				RoQPlayed;
+	long				ROQSize;
+	unsigned int		RoQFrameSize;
+	long				onQuad;
+	long				numQuads;
+	long				samplesPerLine;
+	unsigned int		roq_id;
+	long				screenDelta;
+
+	void ( *VQ0)(byte *status, void *qdata );
+	void ( *VQ1)(byte *status, void *qdata );
+	void ( *VQNormal)(byte *status, void *qdata );
+	void ( *VQBuffer)(byte *status, void *qdata );
+
+	byte*				gray;
+	unsigned int		xsize, ysize, maxsize, minsize;
+
+	qboolean			inMemory;
+	long				normalBuffer0;
+	long				roq_flags;
+	long				roqF0;
+	long				roqF1;
+	long				t[2];
+	long				roqFPS;
+	int					playonwalls;
+	byte*				buf;
+	long				drawX, drawY;
+} cin_cache;
+
+static cinematics_t		cin;
+static cin_cache		cinTable[MAX_VIDEO_HANDLES];
+static int				currentHandle = -1;
+static int				CL_handle = -1;
+
+extern int				s_soundtime;		// sample PAIRS
+extern int   			s_paintedtime; 		// sample PAIRS
+
+
+void CIN_CloseAllVideos(void) {
+	int		i;
+
+	for ( i = 0 ; i < MAX_VIDEO_HANDLES ; i++ ) {
+		if (cinTable[i].fileName[0] != 0 ) {
+			CIN_StopCinematic(i);
+		}
+	}
+}
+
+
+static int CIN_HandleForVideo(void) {
+	int		i;
+
+	for ( i = 0 ; i < MAX_VIDEO_HANDLES ; i++ ) {
+		if ( cinTable[i].fileName[0] == 0 ) {
+			return i;
+		}
+	}
+	Com_Error( ERR_DROP, "CIN_HandleForVideo: none free" );
+	return -1;
+}
+
+
+//-----------------------------------------------------------------------------
+// RllSetupTable
+//
+// Allocates and initializes the square table.
+//
+// Parameters:	None
+//
+// Returns:		Nothing
+//-----------------------------------------------------------------------------
+static void RllSetupTable()
+{
+	int z;
+
+	for (z=0;z<128;z++) {
+		cin.sqrTable[z] = (short)(z*z);
+		cin.sqrTable[z+128] = (short)(-cin.sqrTable[z]);
+	}
+}
+
+
+
+//-----------------------------------------------------------------------------
+// RllDecodeMonoToMono
+//
+// Decode mono source data into a mono buffer.
+//
+// Parameters:	from -> buffer holding encoded data
+//				to ->	buffer to hold decoded data
+//				size =	number of bytes of input (= # of shorts of output)
+//				signedOutput = 0 for unsigned output, non-zero for signed output
+//				flag = flags from asset header
+//
+// Returns:		Number of samples placed in output buffer
+//-----------------------------------------------------------------------------
+long RllDecodeMonoToMono(unsigned char *from,short *to,unsigned int size,char signedOutput ,unsigned short flag)
+{
+	unsigned int z;
+	int prev;
+	
+	if (signedOutput)	
+		prev =  flag - 0x8000;
+	else 
+		prev = flag;
+
+	for (z=0;z<size;z++) {
+		prev = to[z] = (short)(prev + cin.sqrTable[from[z]]); 
+	}
+	return size;	//*sizeof(short));
+}
+
+
+//-----------------------------------------------------------------------------
+// RllDecodeMonoToStereo
+//
+// Decode mono source data into a stereo buffer. Output is 4 times the number
+// of bytes in the input.
+//
+// Parameters:	from -> buffer holding encoded data
+//				to ->	buffer to hold decoded data
+//				size =	number of bytes of input (= 1/4 # of bytes of output)
+//				signedOutput = 0 for unsigned output, non-zero for signed output
+//				flag = flags from asset header
+//
+// Returns:		Number of samples placed in output buffer
+//-----------------------------------------------------------------------------
+long RllDecodeMonoToStereo(unsigned char *from,short *to,unsigned int size,char signedOutput,unsigned short flag)
+{
+	unsigned int z;
+	int prev;
+	
+	if (signedOutput)	
+		prev =  flag - 0x8000;
+	else 
+		prev = flag;
+
+	for (z = 0; z < size; z++) {
+		prev = (short)(prev + cin.sqrTable[from[z]]);
+		to[z*2+0] = to[z*2+1] = (short)(prev);
+	}
+	
+	return size;	// * 2 * sizeof(short));
+}
+
+
+//-----------------------------------------------------------------------------
+// RllDecodeStereoToStereo
+//
+// Decode stereo source data into a stereo buffer.
+//
+// Parameters:	from -> buffer holding encoded data
+//				to ->	buffer to hold decoded data
+//				size =	number of bytes of input (= 1/2 # of bytes of output)
+//				signedOutput = 0 for unsigned output, non-zero for signed output
+//				flag = flags from asset header
+//
+// Returns:		Number of samples placed in output buffer
+//-----------------------------------------------------------------------------
+long RllDecodeStereoToStereo(unsigned char *from,short *to,unsigned int size,char signedOutput, unsigned short flag)
+{
+	unsigned int z;
+	unsigned char *zz = from;
+	int	prevL, prevR;
+
+	if (signedOutput) {
+		prevL = (flag & 0xff00) - 0x8000;
+		prevR = ((flag & 0x00ff) << 8) - 0x8000;
+	} else {
+		prevL = flag & 0xff00;
+		prevR = (flag & 0x00ff) << 8;
+	}
+
+	for (z=0;z<size;z+=2) {
+                prevL = (short)(prevL + cin.sqrTable[*zz++]); 
+                prevR = (short)(prevR + cin.sqrTable[*zz++]);
+                to[z+0] = (short)(prevL);
+                to[z+1] = (short)(prevR);
+	}
+	
+	return (size>>1);	//*sizeof(short));
+}
+
+
+//-----------------------------------------------------------------------------
+// RllDecodeStereoToMono
+//
+// Decode stereo source data into a mono buffer.
+//
+// Parameters:	from -> buffer holding encoded data
+//				to ->	buffer to hold decoded data
+//				size =	number of bytes of input (= # of bytes of output)
+//				signedOutput = 0 for unsigned output, non-zero for signed output
+//				flag = flags from asset header
+//
+// Returns:		Number of samples placed in output buffer
+//-----------------------------------------------------------------------------
+long RllDecodeStereoToMono(unsigned char *from,short *to,unsigned int size,char signedOutput, unsigned short flag)
+{
+	unsigned int z;
+	int prevL,prevR;
+	
+	if (signedOutput) {
+		prevL = (flag & 0xff00) - 0x8000;
+		prevR = ((flag & 0x00ff) << 8) -0x8000;
+	} else {
+		prevL = flag & 0xff00;
+		prevR = (flag & 0x00ff) << 8;
+	}
+
+	for (z=0;z<size;z+=1) {
+		prevL= prevL + cin.sqrTable[from[z*2]];
+		prevR = prevR + cin.sqrTable[from[z*2+1]];
+		to[z] = (short)((prevL + prevR)/2);
+	}
+
+	return size;
+}
+
+/******************************************************************************
+*
+* Function:		
+*
+* Description:	
+*
+******************************************************************************/
+
+static void move8_32( byte *src, byte *dst, int spl )
+{
+	double *dsrc, *ddst;
+	int dspl;
+
+	dsrc = (double *)src;
+	ddst = (double *)dst;
+	dspl = spl>>3;
+
+	ddst[0] = dsrc[0]; ddst[1] = dsrc[1]; ddst[2] = dsrc[2]; ddst[3] = dsrc[3];
+	dsrc += dspl; ddst += dspl;
+	ddst[0] = dsrc[0]; ddst[1] = dsrc[1]; ddst[2] = dsrc[2]; ddst[3] = dsrc[3];
+	dsrc += dspl; ddst += dspl;
+	ddst[0] = dsrc[0]; ddst[1] = dsrc[1]; ddst[2] = dsrc[2]; ddst[3] = dsrc[3];
+	dsrc += dspl; ddst += dspl;
+	ddst[0] = dsrc[0]; ddst[1] = dsrc[1]; ddst[2] = dsrc[2]; ddst[3] = dsrc[3];
+	dsrc += dspl; ddst += dspl;
+	ddst[0] = dsrc[0]; ddst[1] = dsrc[1]; ddst[2] = dsrc[2]; ddst[3] = dsrc[3];
+	dsrc += dspl; ddst += dspl;
+	ddst[0] = dsrc[0]; ddst[1] = dsrc[1]; ddst[2] = dsrc[2]; ddst[3] = dsrc[3];
+	dsrc += dspl; ddst += dspl;
+	ddst[0] = dsrc[0]; ddst[1] = dsrc[1]; ddst[2] = dsrc[2]; ddst[3] = dsrc[3];
+	dsrc += dspl; ddst += dspl;
+	ddst[0] = dsrc[0]; ddst[1] = dsrc[1]; ddst[2] = dsrc[2]; ddst[3] = dsrc[3];
+}
+
+/******************************************************************************
+*
+* Function:		
+*
+* Description:	
+*
+******************************************************************************/
+
+static void move4_32( byte *src, byte *dst, int spl  )
+{
+	double *dsrc, *ddst;
+	int dspl;
+
+	dsrc = (double *)src;
+	ddst = (double *)dst;
+	dspl = spl>>3;
+
+	ddst[0] = dsrc[0]; ddst[1] = dsrc[1];
+	dsrc += dspl; ddst += dspl;
+	ddst[0] = dsrc[0]; ddst[1] = dsrc[1];
+	dsrc += dspl; ddst += dspl;
+	ddst[0] = dsrc[0]; ddst[1] = dsrc[1];
+	dsrc += dspl; ddst += dspl;
+	ddst[0] = dsrc[0]; ddst[1] = dsrc[1];
+}
+
+/******************************************************************************
+*
+* Function:		
+*
+* Description:	
+*
+******************************************************************************/
+
+static void blit8_32( byte *src, byte *dst, int spl  )
+{
+	double *dsrc, *ddst;
+	int dspl;
+
+	dsrc = (double *)src;
+	ddst = (double *)dst;
+	dspl = spl>>3;
+
+	ddst[0] = dsrc[0]; ddst[1] = dsrc[1]; ddst[2] = dsrc[2]; ddst[3] = dsrc[3];
+	dsrc += 4; ddst += dspl;
+	ddst[0] = dsrc[0]; ddst[1] = dsrc[1]; ddst[2] = dsrc[2]; ddst[3] = dsrc[3];
+	dsrc += 4; ddst += dspl;
+	ddst[0] = dsrc[0]; ddst[1] = dsrc[1]; ddst[2] = dsrc[2]; ddst[3] = dsrc[3];
+	dsrc += 4; ddst += dspl;
+	ddst[0] = dsrc[0]; ddst[1] = dsrc[1]; ddst[2] = dsrc[2]; ddst[3] = dsrc[3];
+	dsrc += 4; ddst += dspl;
+	ddst[0] = dsrc[0]; ddst[1] = dsrc[1]; ddst[2] = dsrc[2]; ddst[3] = dsrc[3];
+	dsrc += 4; ddst += dspl;
+	ddst[0] = dsrc[0]; ddst[1] = dsrc[1]; ddst[2] = dsrc[2]; ddst[3] = dsrc[3];
+	dsrc += 4; ddst += dspl;
+	ddst[0] = dsrc[0]; ddst[1] = dsrc[1]; ddst[2] = dsrc[2]; ddst[3] = dsrc[3];
+	dsrc += 4; ddst += dspl;
+	ddst[0] = dsrc[0]; ddst[1] = dsrc[1]; ddst[2] = dsrc[2]; ddst[3] = dsrc[3];
+}
+
+/******************************************************************************
+*
+* Function:		
+*
+* Description:	
+*
+******************************************************************************/
+#define movs double
+static void blit4_32( byte *src, byte *dst, int spl  )
+{
+	movs *dsrc, *ddst;
+	int dspl;
+
+	dsrc = (movs *)src;
+	ddst = (movs *)dst;
+	dspl = spl>>3;
+
+	ddst[0] = dsrc[0]; ddst[1] = dsrc[1];
+	dsrc += 2; ddst += dspl;
+	ddst[0] = dsrc[0]; ddst[1] = dsrc[1];
+	dsrc += 2; ddst += dspl;
+	ddst[0] = dsrc[0]; ddst[1] = dsrc[1];
+	dsrc += 2; ddst += dspl;
+	ddst[0] = dsrc[0]; ddst[1] = dsrc[1];
+}
+
+/******************************************************************************
+*
+* Function:		
+*
+* Description:	
+*
+******************************************************************************/
+
+static void blit2_32( byte *src, byte *dst, int spl  )
+{
+	double *dsrc, *ddst;
+	int dspl;
+
+	dsrc = (double *)src;
+	ddst = (double *)dst;
+	dspl = spl>>3;
+
+	ddst[0] = dsrc[0];
+	ddst[dspl] = dsrc[1];
+}
+
+/******************************************************************************
+*
+* Function:		
+*
+* Description:	
+*
+******************************************************************************/
+
+static void blitVQQuad32fs( byte **status, unsigned char *data )
+{
+unsigned short	newd, celdata, code;
+unsigned int	index, i;
+int		spl;
+
+	newd	= 0;
+	celdata = 0;
+	index	= 0;
+	
+        spl = cinTable[currentHandle].samplesPerLine;
+        
+	do {
+		if (!newd) { 
+			newd = 7;
+			celdata = data[0] + data[1]*256;
+			data += 2;
+		} else {
+			newd--;
+		}
+
+		code = (unsigned short)(celdata&0xc000); 
+		celdata <<= 2;
+		
+		switch (code) {
+			case	0x8000:													// vq code
+				blit8_32( (byte *)&vq8[(*data)*128], status[index], spl );
+				data++;
+				index += 5;
+				break;
+			case	0xc000:													// drop
+				index++;													// skip 8x8
+				for(i=0;i<4;i++) {
+					if (!newd) { 
+						newd = 7;
+						celdata = data[0] + data[1]*256;
+						data += 2;
+					} else {
+						newd--;
+					}
+						
+					code = (unsigned short)(celdata&0xc000); celdata <<= 2; 
+
+					switch (code) {											// code in top two bits of code
+						case	0x8000:										// 4x4 vq code
+							blit4_32( (byte *)&vq4[(*data)*32], status[index], spl );
+							data++;
+							break;
+						case	0xc000:										// 2x2 vq code
+							blit2_32( (byte *)&vq2[(*data)*8], status[index], spl );
+							data++;
+							blit2_32( (byte *)&vq2[(*data)*8], status[index]+8, spl );
+							data++;
+							blit2_32( (byte *)&vq2[(*data)*8], status[index]+spl*2, spl );
+							data++;
+							blit2_32( (byte *)&vq2[(*data)*8], status[index]+spl*2+8, spl );
+							data++;
+							break;
+						case	0x4000:										// motion compensation
+							move4_32( status[index] + cin.mcomp[(*data)], status[index], spl );
+							data++;
+							break;
+					}
+					index++;
+				}
+				break;
+			case	0x4000:													// motion compensation
+				move8_32( status[index] + cin.mcomp[(*data)], status[index], spl );
+				data++;
+				index += 5;
+				break;
+			case	0x0000:
+				index += 5;
+				break;
+		}
+	} while ( status[index] != NULL );
+}
+
+/******************************************************************************
+*
+* Function:		
+*
+* Description:	
+*
+******************************************************************************/
+
+static void ROQ_GenYUVTables( void )
+{
+	float t_ub,t_vr,t_ug,t_vg;
+	long i;
+
+	t_ub = (1.77200f/2.0f) * (float)(1<<6) + 0.5f;
+	t_vr = (1.40200f/2.0f) * (float)(1<<6) + 0.5f;
+	t_ug = (0.34414f/2.0f) * (float)(1<<6) + 0.5f;
+	t_vg = (0.71414f/2.0f) * (float)(1<<6) + 0.5f;
+	for(i=0;i<256;i++) {
+		float x = (float)(2 * i - 255);
+	
+		ROQ_UB_tab[i] = (long)( ( t_ub * x) + (1<<5));
+		ROQ_VR_tab[i] = (long)( ( t_vr * x) + (1<<5));
+		ROQ_UG_tab[i] = (long)( (-t_ug * x)		 );
+		ROQ_VG_tab[i] = (long)( (-t_vg * x) + (1<<5));
+		ROQ_YY_tab[i] = (long)( (i << 6) | (i >> 2) );
+	}
+}
+
+#define VQ2TO4(a,b,c,d) { \
+    	*c++ = a[0];	\
+	*d++ = a[0];	\
+	*d++ = a[0];	\
+	*c++ = a[1];	\
+	*d++ = a[1];	\
+	*d++ = a[1];	\
+	*c++ = b[0];	\
+	*d++ = b[0];	\
+	*d++ = b[0];	\
+	*c++ = b[1];	\
+	*d++ = b[1];	\
+	*d++ = b[1];	\
+	*d++ = a[0];	\
+	*d++ = a[0];	\
+	*d++ = a[1];	\
+	*d++ = a[1];	\
+	*d++ = b[0];	\
+	*d++ = b[0];	\
+	*d++ = b[1];	\
+	*d++ = b[1];	\
+	a += 2; b += 2; }
+ 
+#define VQ2TO2(a,b,c,d) { \
+	*c++ = *a;	\
+	*d++ = *a;	\
+	*d++ = *a;	\
+	*c++ = *b;	\
+	*d++ = *b;	\
+	*d++ = *b;	\
+	*d++ = *a;	\
+	*d++ = *a;	\
+	*d++ = *b;	\
+	*d++ = *b;	\
+	a++; b++; }
+
+
+/******************************************************************************
+*
+* Function:		
+*
+* Description:	
+*
+******************************************************************************/
+#if defined(MACOS_X)
+
+static inline unsigned int yuv_to_rgb24( long y, long u, long v )
+{ 
+	long r,g,b,YY;
+        
+        YY = (long)(ROQ_YY_tab[(y)]);
+
+	r = (YY + ROQ_VR_tab[v]) >> 6;
+	g = (YY + ROQ_UG_tab[u] + ROQ_VG_tab[v]) >> 6;
+	b = (YY + ROQ_UB_tab[u]) >> 6;
+	
+	if (r<0) r = 0; if (g<0) g = 0; if (b<0) b = 0;
+	if (r > 255) r = 255; if (g > 255) g = 255; if (b > 255) b = 255;
+	
+	return ((r<<24)|(g<<16)|(b<<8))|(255);	//+(255<<24));
+}
+
+#else
+static unsigned int yuv_to_rgb24( long y, long u, long v )
+{ 
+	long r,g,b,YY = (long)(ROQ_YY_tab[(y)]);
+
+	r = (YY + ROQ_VR_tab[v]) >> 6;
+	g = (YY + ROQ_UG_tab[u] + ROQ_VG_tab[v]) >> 6;
+	b = (YY + ROQ_UB_tab[u]) >> 6;
+	
+	if (r<0) r = 0; if (g<0) g = 0; if (b<0) b = 0;
+	if (r > 255) r = 255; if (g > 255) g = 255; if (b > 255) b = 255;
+	
+	return LittleLong ((r)|(g<<8)|(b<<16)|(255<<24));
+}
+#endif
+
+/******************************************************************************
+*
+* Function:		
+*
+* Description:	
+*
+******************************************************************************/
+
+static void decodeCodeBook( byte *input, unsigned short roq_flags )
+{
+	long	i, j, two, four;
+	unsigned short	*bptr;
+	long	y0,y1,y2,y3,cr,cb;
+	unsigned int *iaptr, *ibptr, *icptr, *idptr;
+	
+	if (!roq_flags) {
+		two = four = 256;
+	} else {
+		two  = roq_flags>>8;
+		if (!two) two = 256;
+		four = roq_flags&0xff;
+	}
+	
+	four *= 2;
+	
+	bptr = (unsigned short *)vq2;
+	
+	//
+	// normal height
+	//
+	ibptr = (unsigned int *)bptr;
+	for(i=0;i<two;i++) {
+		y0 = (long)*input++;
+		y1 = (long)*input++;
+		y2 = (long)*input++;
+		y3 = (long)*input++;
+		cr = (long)*input++;
+		cb = (long)*input++;
+		*ibptr++ = yuv_to_rgb24( y0, cr, cb );
+		*ibptr++ = yuv_to_rgb24( y1, cr, cb );
+		*ibptr++ = yuv_to_rgb24( y2, cr, cb );
+		*ibptr++ = yuv_to_rgb24( y3, cr, cb );
+	}
+	
+	icptr = (unsigned int *)vq4;
+	idptr = (unsigned int *)vq8;
+	
+	for(i=0;i<four;i++) {
+		iaptr = (unsigned int *)vq2 + (*input++)*4;
+		ibptr = (unsigned int *)vq2 + (*input++)*4;
+		for(j=0;j<2;j++) 
+			VQ2TO4(iaptr, ibptr, icptr, idptr);
+	}
+}
+
+/******************************************************************************
+*
+* Function:		
+*
+* Description:	
+*
+******************************************************************************/
+
+static void recurseQuad( long startX, long startY, long quadSize, long xOff, long yOff )
+{
+	byte *scroff;
+	long bigx, bigy, lowx, lowy, useY;
+	long offset;
+
+	offset = cinTable[currentHandle].screenDelta;
+	
+	lowx = lowy = 0;
+	bigx = cinTable[currentHandle].xsize;
+	bigy = cinTable[currentHandle].ysize;
+
+	if (bigx > cinTable[currentHandle].CIN_WIDTH) bigx = cinTable[currentHandle].CIN_WIDTH;
+	if (bigy > cinTable[currentHandle].CIN_HEIGHT) bigy = cinTable[currentHandle].CIN_HEIGHT;
+
+	if ( (startX >= lowx) && (startX+quadSize) <= (bigx) && (startY+quadSize) <= (bigy) && (startY >= lowy) && quadSize <= MAXSIZE) {
+		useY = startY;
+		scroff = cin.linbuf + (useY+((cinTable[currentHandle].CIN_HEIGHT-bigy)>>1)+yOff)*(cinTable[currentHandle].samplesPerLine) + (((startX+xOff))*4);
+
+		cin.qStatus[0][cinTable[currentHandle].onQuad  ] = scroff;
+		cin.qStatus[1][cinTable[currentHandle].onQuad++] = scroff+offset;
+	}
+
+	if ( quadSize != MINSIZE ) {
+		quadSize >>= 1;
+		recurseQuad( startX,		  startY		  , quadSize, xOff, yOff );
+		recurseQuad( startX+quadSize, startY		  , quadSize, xOff, yOff );
+		recurseQuad( startX,		  startY+quadSize , quadSize, xOff, yOff );
+		recurseQuad( startX+quadSize, startY+quadSize , quadSize, xOff, yOff );
+	}
+}
+
+
+/******************************************************************************
+*
+* Function:		
+*
+* Description:	
+*
+******************************************************************************/
+
+static void setupQuad( long xOff, long yOff )
+{
+	long numQuadCels, i,x,y;
+	byte *temp;
+
+	if (xOff == cin.oldXOff && yOff == cin.oldYOff && cinTable[currentHandle].ysize == cin.oldysize && cinTable[currentHandle].xsize == cin.oldxsize) {
+		return;
+	}
+
+	cin.oldXOff = xOff;
+	cin.oldYOff = yOff;
+	cin.oldysize = cinTable[currentHandle].ysize;
+	cin.oldxsize = cinTable[currentHandle].xsize;
+
+	numQuadCels  = (cinTable[currentHandle].CIN_WIDTH*cinTable[currentHandle].CIN_HEIGHT) / (16);
+	numQuadCels += numQuadCels/4 + numQuadCels/16;
+	numQuadCels += 64;							  // for overflow
+
+	numQuadCels  = (cinTable[currentHandle].xsize*cinTable[currentHandle].ysize) / (16);
+	numQuadCels += numQuadCels/4;
+	numQuadCels += 64;							  // for overflow
+
+	cinTable[currentHandle].onQuad = 0;
+
+	for(y=0;y<(long)cinTable[currentHandle].ysize;y+=16) 
+		for(x=0;x<(long)cinTable[currentHandle].xsize;x+=16) 
+			recurseQuad( x, y, 16, xOff, yOff );
+
+	temp = NULL;
+
+	for(i=(numQuadCels-64);i<numQuadCels;i++) {
+		cin.qStatus[0][i] = temp;			  // eoq
+		cin.qStatus[1][i] = temp;			  // eoq
+	}
+}
+
+/******************************************************************************
+*
+* Function:		
+*
+* Description:	
+*
+******************************************************************************/
+
+static void readQuadInfo( byte *qData )
+{
+	if (currentHandle < 0) return;
+
+	cinTable[currentHandle].xsize    = qData[0]+qData[1]*256;
+	cinTable[currentHandle].ysize    = qData[2]+qData[3]*256;
+	cinTable[currentHandle].maxsize  = qData[4]+qData[5]*256;
+	cinTable[currentHandle].minsize  = qData[6]+qData[7]*256;
+	
+	cinTable[currentHandle].CIN_HEIGHT = cinTable[currentHandle].ysize;
+	cinTable[currentHandle].CIN_WIDTH  = cinTable[currentHandle].xsize;
+
+	cinTable[currentHandle].samplesPerLine = cinTable[currentHandle].CIN_WIDTH*4;
+	cinTable[currentHandle].screenDelta = cinTable[currentHandle].CIN_HEIGHT*cinTable[currentHandle].samplesPerLine;
+	
+	cinTable[currentHandle].VQ0 = cinTable[currentHandle].VQNormal;
+	cinTable[currentHandle].VQ1 = cinTable[currentHandle].VQBuffer;
+
+	cinTable[currentHandle].t[0] = (0 - (unsigned int)cin.linbuf)+(unsigned int)cin.linbuf+cinTable[currentHandle].screenDelta;
+	cinTable[currentHandle].t[1] = (0 - ((unsigned int)cin.linbuf + cinTable[currentHandle].screenDelta))+(unsigned int)cin.linbuf;
+
+    cinTable[currentHandle].drawX = cinTable[currentHandle].CIN_WIDTH;
+    cinTable[currentHandle].drawY = cinTable[currentHandle].CIN_HEIGHT;
+	// jic the card sucks
+	if ( glConfig.maxTextureSize <= 256) {
+        if (cinTable[currentHandle].drawX>256) {
+            cinTable[currentHandle].drawX = 256;
+        }
+        if (cinTable[currentHandle].drawY>256) {
+            cinTable[currentHandle].drawY = 256;
+        }
+		if (cinTable[currentHandle].CIN_WIDTH != 256 || cinTable[currentHandle].CIN_HEIGHT != 256) {
+			Com_Printf("HACK: approxmimating cinematic for Rage Pro or Voodoo\n");
+		}
+	}
+#if defined(MACOS_X)
+	cinTable[currentHandle].drawX = 256;
+	cinTable[currentHandle].drawX = 256;
+#endif
+}
+
+/******************************************************************************
+*
+* Function:		
+*
+* Description:	
+*
+******************************************************************************/
+
+static void RoQPrepMcomp( long xoff, long yoff ) 
+{
+	long i, j, x, y, temp, temp2;
+
+	i=cinTable[currentHandle].samplesPerLine; 
+	j=4;
+	if ( cinTable[currentHandle].xsize == (cinTable[currentHandle].ysize*4) ) 
+	{ 
+		j = j+j;
+		i = i+i; 
+	}
+	
+	for(y=0;y<16;y++) {
+		temp2 = (y+yoff-8)*i;
+		for(x=0;x<16;x++) {
+			temp = (x+xoff-8)*j;
+			cin.mcomp[(x*16)+y] = cinTable[currentHandle].normalBuffer0-(temp2+temp);
+		}
+	}
+}
+
+/******************************************************************************
+*
+* Function:		
+*
+* Description:	
+*
+******************************************************************************/
+
+static void initRoQ() 
+{
+	if (currentHandle < 0) return;
+
+	cinTable[currentHandle].VQNormal = (void (*)(byte *, void *))blitVQQuad32fs;
+	cinTable[currentHandle].VQBuffer = (void (*)(byte *, void *))blitVQQuad32fs;
+	ROQ_GenYUVTables();
+	RllSetupTable();
+}
+
+/******************************************************************************
+*
+* Function:		
+*
+* Description:	
+*
+******************************************************************************/
+/*
+static byte* RoQFetchInterlaced( byte *source ) {
+	int x, *src, *dst;
+
+	if (currentHandle < 0) return NULL;
+
+	src = (int *)source;
+	dst = (int *)cinTable[currentHandle].buf2;
+
+	for(x=0;x<256*256;x++) {
+		*dst = *src;
+		dst++; src += 2;
+	}
+	return cinTable[currentHandle].buf2;
+}
+*/
+static void RoQReset() {
+	
+	if (currentHandle < 0) return;
+
+	if (cinTable[currentHandle].iFile) {
+		Sys_EndStreamedFile(cinTable[currentHandle].iFile);
+		FS_Seek(cinTable[currentHandle].iFile, 0, FS_SEEK_SET);
+		FS_Read (cin.file, 16, cinTable[currentHandle].iFile);
+		RoQ_init();
+		// let the background thread start reading ahead
+		Sys_BeginStreamedFile( cinTable[currentHandle].iFile, 0x10000 );
+		cinTable[currentHandle].status = FMV_LOOPED;
+	}
+}
+
+/******************************************************************************
+*
+* Function:		
+*
+* Description:	
+*
+******************************************************************************/
+
+static void RoQInterrupt(void)
+{
+	byte				*framedata;
+        short		sbuf[32768];
+        int		ssize;
+        
+	if (currentHandle < 0) return;
+
+	Sys_StreamedRead( cin.file, cinTable[currentHandle].RoQFrameSize+8, 1, cinTable[currentHandle].iFile );
+	if ( cinTable[currentHandle].RoQPlayed >= cinTable[currentHandle].ROQSize ) { 
+		if (cinTable[currentHandle].holdAtEnd==qfalse) {
+			if (cinTable[currentHandle].looping) {
+				RoQReset();
+			} else {
+				cinTable[currentHandle].status = FMV_EOF;
+			}
+		} else {
+			cinTable[currentHandle].status = FMV_IDLE;
+		}
+		return; 
+	}
+
+	framedata = cin.file;
+//
+// new frame is ready
+//
+redump:
+	switch(cinTable[currentHandle].roq_id) 
+	{
+		case	ROQ_QUAD_VQ:
+			if ((cinTable[currentHandle].numQuads&1)) {
+				cinTable[currentHandle].normalBuffer0 = cinTable[currentHandle].t[1];
+				RoQPrepMcomp( cinTable[currentHandle].roqF0, cinTable[currentHandle].roqF1 );
+				cinTable[currentHandle].VQ1( (byte *)cin.qStatus[1], framedata);
+				cinTable[currentHandle].buf = 	cin.linbuf + cinTable[currentHandle].screenDelta;
+			} else {
+				cinTable[currentHandle].normalBuffer0 = cinTable[currentHandle].t[0];
+				RoQPrepMcomp( cinTable[currentHandle].roqF0, cinTable[currentHandle].roqF1 );
+				cinTable[currentHandle].VQ0( (byte *)cin.qStatus[0], framedata );
+				cinTable[currentHandle].buf = 	cin.linbuf;
+			}
+			if (cinTable[currentHandle].numQuads == 0) {		// first frame
+				Com_Memcpy(cin.linbuf+cinTable[currentHandle].screenDelta, cin.linbuf, cinTable[currentHandle].samplesPerLine*cinTable[currentHandle].ysize);
+			}
+			cinTable[currentHandle].numQuads++;
+			cinTable[currentHandle].dirty = qtrue;
+			break;
+		case	ROQ_CODEBOOK:
+			decodeCodeBook( framedata, (unsigned short)cinTable[currentHandle].roq_flags );
+			break;
+		case	ZA_SOUND_MONO:
+			if (!cinTable[currentHandle].silent) {
+				ssize = RllDecodeMonoToStereo( framedata, sbuf, cinTable[currentHandle].RoQFrameSize, 0, (unsigned short)cinTable[currentHandle].roq_flags);
+                S_RawSamples( ssize, 22050, 2, 1, (byte *)sbuf, s_volume->value, 1 );
+			}
+			break;
+		case	ZA_SOUND_STEREO:
+			if (!cinTable[currentHandle].silent) {
+				if (cinTable[currentHandle].numQuads == -1) {
+					S_Update();
+					s_rawend = s_soundtime;
+				}
+				ssize = RllDecodeStereoToStereo( framedata, sbuf, cinTable[currentHandle].RoQFrameSize, 0, (unsigned short)cinTable[currentHandle].roq_flags);
+                S_RawSamples( ssize, 22050, 2, 2, (byte *)sbuf, s_volume->value, 1 );
+			}
+			break;
+		case	ROQ_QUAD_INFO:
+			if (cinTable[currentHandle].numQuads == -1) {
+				readQuadInfo( framedata );
+				setupQuad( 0, 0 );
+				cinTable[currentHandle].startTime = cinTable[currentHandle].lastTime = Sys_Milliseconds()*com_timescale->value;
+			}
+			if (cinTable[currentHandle].numQuads != 1) cinTable[currentHandle].numQuads = 0;
+			break;
+		case	ROQ_PACKET:
+			cinTable[currentHandle].inMemory = (qboolean)cinTable[currentHandle].roq_flags;
+			cinTable[currentHandle].RoQFrameSize = 0;           // for header
+			break;
+		case	ROQ_QUAD_HANG:
+			cinTable[currentHandle].RoQFrameSize = 0;
+			break;
+		case	ROQ_QUAD_JPEG:
+			break;
+		default:
+			cinTable[currentHandle].status = FMV_EOF;
+			break;
+	}	
+//
+// read in next frame data
+//
+	if ( cinTable[currentHandle].RoQPlayed >= cinTable[currentHandle].ROQSize ) { 
+		if (cinTable[currentHandle].holdAtEnd==qfalse) {
+			if (cinTable[currentHandle].looping) {
+				RoQReset();
+			} else {
+				cinTable[currentHandle].status = FMV_EOF;
+			}
+		} else {
+			cinTable[currentHandle].status = FMV_IDLE;
+		}
+		return; 
+	}
+	
+	framedata		 += cinTable[currentHandle].RoQFrameSize;
+	cinTable[currentHandle].roq_id		 = framedata[0] + framedata[1]*256;
+	cinTable[currentHandle].RoQFrameSize = framedata[2] + framedata[3]*256 + framedata[4]*65536;
+	cinTable[currentHandle].roq_flags	 = framedata[6] + framedata[7]*256;
+	cinTable[currentHandle].roqF0		 = (char)framedata[7];
+	cinTable[currentHandle].roqF1		 = (char)framedata[6];
+
+	if (cinTable[currentHandle].RoQFrameSize>65536||cinTable[currentHandle].roq_id==0x1084) {
+		Com_DPrintf("roq_size>65536||roq_id==0x1084\n");
+		cinTable[currentHandle].status = FMV_EOF;
+		if (cinTable[currentHandle].looping) {
+			RoQReset();
+		}
+		return;
+	}
+	if (cinTable[currentHandle].inMemory && (cinTable[currentHandle].status != FMV_EOF)) 
+	{ 
+		cinTable[currentHandle].inMemory = (qboolean)(((int)cinTable[currentHandle].inMemory)-1); 
+		framedata += 8; 
+		goto redump; 
+	}
+//
+// one more frame hits the dust
+//
+//	assert(cinTable[currentHandle].RoQFrameSize <= 65536);
+//	r = Sys_StreamedRead( cin.file, cinTable[currentHandle].RoQFrameSize+8, 1, cinTable[currentHandle].iFile );
+	cinTable[currentHandle].RoQPlayed	+= cinTable[currentHandle].RoQFrameSize+8;
+}
+
+/******************************************************************************
+*
+* Function:		
+*
+* Description:	
+*
+******************************************************************************/
+
+static void RoQ_init( void )
+{
+	cinTable[currentHandle].startTime = cinTable[currentHandle].lastTime = Sys_Milliseconds()*com_timescale->value;
+
+	cinTable[currentHandle].RoQPlayed = 24;
+
+/*	get frame rate */	
+	cinTable[currentHandle].roqFPS	 = cin.file[ 6] + cin.file[ 7]*256;
+	
+	if (!cinTable[currentHandle].roqFPS) cinTable[currentHandle].roqFPS = 30;
+
+	cinTable[currentHandle].numQuads = -1;
+
+	cinTable[currentHandle].roq_id		= cin.file[ 8] + cin.file[ 9]*256;
+	cinTable[currentHandle].RoQFrameSize	= cin.file[10] + cin.file[11]*256 + cin.file[12]*65536;
+	cinTable[currentHandle].roq_flags	= cin.file[14] + cin.file[15]*256;
+
+	if (cinTable[currentHandle].RoQFrameSize > 65536 || !cinTable[currentHandle].RoQFrameSize) { 
+		return;
+	}
+
+}
+
+/******************************************************************************
+*
+* Function:		
+*
+* Description:	
+*
+******************************************************************************/
+
+static void RoQShutdown( void ) {
+	const char *s;
+
+	if (!cinTable[currentHandle].buf) {
+		return;
+	}
+
+	if ( cinTable[currentHandle].status == FMV_IDLE ) {
+		return;
+	}
+	Com_DPrintf("finished cinematic\n");
+	cinTable[currentHandle].status = FMV_IDLE;
+
+	if (cinTable[currentHandle].iFile) {
+		Sys_EndStreamedFile( cinTable[currentHandle].iFile );
+		FS_FCloseFile( cinTable[currentHandle].iFile );
+		cinTable[currentHandle].iFile = 0;
+	}
+
+	if (cinTable[currentHandle].alterGameState) {
+		cls.state = CA_DISCONNECTED;
+		// we can't just do a vstr nextmap, because
+		// if we are aborting the intro cinematic with
+		// a devmap command, nextmap would be valid by
+		// the time it was referenced
+		s = Cvar_VariableString( "nextmap" );
+		if ( s[0] ) {
+			Cbuf_ExecuteText( EXEC_APPEND, va("%s\n", s) );
+			Cvar_Set( "nextmap", "" );
+		}
+		CL_handle = -1;
+	}
+	cinTable[currentHandle].fileName[0] = 0;
+	currentHandle = -1;
+}
+
+/*
+==================
+SCR_StopCinematic
+==================
+*/
+e_status CIN_StopCinematic(int handle) {
+	
+	if (handle < 0 || handle>= MAX_VIDEO_HANDLES || cinTable[handle].status == FMV_EOF) return FMV_EOF;
+	currentHandle = handle;
+
+	Com_DPrintf("trFMV::stop(), closing %s\n", cinTable[currentHandle].fileName);
+
+	if (!cinTable[currentHandle].buf) {
+		return FMV_EOF;
+	}
+
+	if (cinTable[currentHandle].alterGameState) {
+		if ( cls.state != CA_CINEMATIC ) {
+			return cinTable[currentHandle].status;
+		}
+	}
+	cinTable[currentHandle].status = FMV_EOF;
+	RoQShutdown();
+
+	return FMV_EOF;
+}
+
+/*
+==================
+SCR_RunCinematic
+
+Fetch and decompress the pending frame
+==================
+*/
+
+
+e_status CIN_RunCinematic (int handle)
+{
+        // bk001204 - init
+	int	start = 0;
+	int     thisTime = 0;
+
+	if (handle < 0 || handle>= MAX_VIDEO_HANDLES || cinTable[handle].status == FMV_EOF) return FMV_EOF;
+
+	if (currentHandle != handle) {
+		currentHandle = handle;
+		cinTable[currentHandle].status = FMV_EOF;
+		RoQReset();
+	}
+
+	if (cinTable[handle].playonwalls < -1)
+	{
+		return cinTable[handle].status;
+	}
+
+	currentHandle = handle;
+
+	if (cinTable[currentHandle].alterGameState) {
+		if ( cls.state != CA_CINEMATIC ) {
+			return cinTable[currentHandle].status;
+		}
+	}
+
+	if (cinTable[currentHandle].status == FMV_IDLE) {
+		return cinTable[currentHandle].status;
+	}
+
+	thisTime = Sys_Milliseconds()*com_timescale->value;
+	if (cinTable[currentHandle].shader && (abs(thisTime - cinTable[currentHandle].lastTime))>100) {
+		cinTable[currentHandle].startTime += thisTime - cinTable[currentHandle].lastTime;
+	}
+	cinTable[currentHandle].tfps = ((((Sys_Milliseconds()*com_timescale->value) - cinTable[currentHandle].startTime)*cinTable[currentHandle].roqFPS)/1000);
+
+	start = cinTable[currentHandle].startTime;
+	while(  (cinTable[currentHandle].tfps != cinTable[currentHandle].numQuads)
+		&& (cinTable[currentHandle].status == FMV_PLAY) ) 
+	{
+		RoQInterrupt();
+		if (start != cinTable[currentHandle].startTime) {
+		  cinTable[currentHandle].tfps = ((((Sys_Milliseconds()*com_timescale->value)
+							  - cinTable[currentHandle].startTime)*cinTable[currentHandle].roqFPS)/1000);
+			start = cinTable[currentHandle].startTime;
+		}
+	}
+
+	cinTable[currentHandle].lastTime = thisTime;
+
+	if (cinTable[currentHandle].status == FMV_LOOPED) {
+		cinTable[currentHandle].status = FMV_PLAY;
+	}
+
+	if (cinTable[currentHandle].status == FMV_EOF) {
+	  if (cinTable[currentHandle].looping) {
+		RoQReset();
+	  } else {
+		RoQShutdown();
+	  }
+	}
+
+	return cinTable[currentHandle].status;
+}
+
+/*
+==================
+CL_PlayCinematic
+
+==================
+*/
+int CIN_PlayCinematic( const char *arg, int x, int y, int w, int h, int systemBits ) {
+	unsigned short RoQID;
+	char	name[MAX_OSPATH];
+	int		i;
+
+	if (strstr(arg, "/") == NULL && strstr(arg, "\\") == NULL) {
+		Com_sprintf (name, sizeof(name), "video/%s", arg);
+	} else {
+		Com_sprintf (name, sizeof(name), "%s", arg);
+	}
+	COM_DefaultExtension(name,sizeof(name),".roq");
+
+	if (!(systemBits & CIN_system)) {
+		for ( i = 0 ; i < MAX_VIDEO_HANDLES ; i++ ) {
+			if (!strcmp(cinTable[i].fileName, name) ) {
+				return i;
+			}
+		}
+	}
+
+	Com_DPrintf("SCR_PlayCinematic( %s )\n", arg);
+
+	Com_Memset(&cin, 0, sizeof(cinematics_t) );
+	currentHandle = CIN_HandleForVideo();
+
+	strcpy(cinTable[currentHandle].fileName, name);
+
+	cinTable[currentHandle].ROQSize = 0;
+	cinTable[currentHandle].ROQSize = FS_FOpenFileRead (cinTable[currentHandle].fileName, &cinTable[currentHandle].iFile, qtrue);
+
+	if (cinTable[currentHandle].ROQSize<=0) {
+		Com_DPrintf("cinematic failed to open %s\n", arg);
+		cinTable[currentHandle].fileName[0] = 0;
+		return -1;
+	}
+
+	CIN_SetExtents(currentHandle, x, y, w, h);
+	CIN_SetLooping(currentHandle, (qboolean)((systemBits & CIN_loop)!=0));
+
+	cinTable[currentHandle].CIN_HEIGHT = DEFAULT_CIN_HEIGHT;
+	cinTable[currentHandle].CIN_WIDTH  =  DEFAULT_CIN_WIDTH;
+	cinTable[currentHandle].holdAtEnd = (qboolean)((systemBits & CIN_hold) != 0);
+	cinTable[currentHandle].alterGameState = (qboolean)((systemBits & CIN_system) != 0);
+	cinTable[currentHandle].playonwalls = 1;
+	cinTable[currentHandle].silent = (qboolean)((systemBits & CIN_silent) != 0);
+	cinTable[currentHandle].shader = (qboolean)((systemBits & CIN_shader) != 0);
+
+	if (cinTable[currentHandle].alterGameState) {
+		// close the menu
+		if ( uivm ) {
+			VM_Call( uivm, UI_SET_ACTIVE_MENU, UIMENU_NONE );
+		}
+	} else {
+		cinTable[currentHandle].playonwalls = cl_inGameVideo->integer;
+	}
+
+	initRoQ();
+					
+	FS_Read (cin.file, 16, cinTable[currentHandle].iFile);
+
+	RoQID = (unsigned short)(cin.file[0]) + (unsigned short)(cin.file[1])*256;
+	if (RoQID == 0x1084)
+	{
+		RoQ_init();
+//		FS_Read (cin.file, cinTable[currentHandle].RoQFrameSize+8, cinTable[currentHandle].iFile);
+		// let the background thread start reading ahead
+		Sys_BeginStreamedFile( cinTable[currentHandle].iFile, 0x10000 );
+
+		cinTable[currentHandle].status = FMV_PLAY;
+		Com_DPrintf("trFMV::play(), playing %s\n", arg);
+
+		if (cinTable[currentHandle].alterGameState) {
+			cls.state = CA_CINEMATIC;
+		}
+		
+		Con_Close();
+
+		s_rawend = s_soundtime;
+
+		return currentHandle;
+	}
+	Com_DPrintf("trFMV::play(), invalid RoQ ID\n");
+
+	RoQShutdown();
+	return -1;
+}
+
+void CIN_SetExtents (int handle, int x, int y, int w, int h) {
+	if (handle < 0 || handle>= MAX_VIDEO_HANDLES || cinTable[handle].status == FMV_EOF) return;
+	cinTable[handle].xpos = x;
+	cinTable[handle].ypos = y;
+	cinTable[handle].width = w;
+	cinTable[handle].height = h;
+	cinTable[handle].dirty = qtrue;
+}
+
+void CIN_SetLooping(int handle, qboolean loop) {
+	if (handle < 0 || handle>= MAX_VIDEO_HANDLES || cinTable[handle].status == FMV_EOF) return;
+	cinTable[handle].looping = loop;
+}
+
+/*
+==================
+SCR_DrawCinematic
+
+==================
+*/
+void CIN_DrawCinematic (int handle) {
+	float	x, y, w, h;
+
+	if (handle < 0 || handle>= MAX_VIDEO_HANDLES || cinTable[handle].status == FMV_EOF) return;
+
+	if (!cinTable[handle].buf) {
+		return;
+	}
+
+	x = cinTable[handle].xpos;
+	y = cinTable[handle].ypos;
+	w = cinTable[handle].width;
+	h = cinTable[handle].height;
+
+	if (cinTable[handle].dirty && (cinTable[handle].CIN_WIDTH != cinTable[handle].drawX || cinTable[handle].CIN_HEIGHT != cinTable[handle].drawY)) {
+		int ix, iy, *buf2, *buf3, xm, ym, ll;
+                
+		xm = cinTable[handle].CIN_WIDTH/256;
+		ym = cinTable[handle].CIN_HEIGHT/256;
+                ll = 8;
+                if (cinTable[handle].CIN_WIDTH==512) {
+                    ll = 9;
+                }
+                
+		buf3 = (int*)cinTable[handle].buf;
+		buf2 = (int *)Hunk_AllocateTempMemory( 256*256*4 );
+                if (xm==2 && ym==2) {
+                    byte *bc2, *bc3;
+                    int	ic, iiy;
+                    
+                    bc2 = (byte *)buf2;
+                    bc3 = (byte *)buf3;
+                    for (iy = 0; iy<256; iy++) {
+                            iiy = iy<<12;
+                            for (ix = 0; ix<2048; ix+=8) {
+                                for(ic = ix;ic<(ix+4);ic++) {
+                                    *bc2=(bc3[iiy+ic]+bc3[iiy+4+ic]+bc3[iiy+2048+ic]+bc3[iiy+2048+4+ic])>>2;
+                                    bc2++;
+                                }
+                            }
+                    }
+                } else if (xm==2 && ym==1) {
+                    byte *bc2, *bc3;
+                    int	ic, iiy;
+                    
+                    bc2 = (byte *)buf2;
+                    bc3 = (byte *)buf3;
+                    for (iy = 0; iy<256; iy++) {
+                            iiy = iy<<11;
+                            for (ix = 0; ix<2048; ix+=8) {
+                                for(ic = ix;ic<(ix+4);ic++) {
+                                    *bc2=(bc3[iiy+ic]+bc3[iiy+4+ic])>>1;
+                                    bc2++;
+                                }
+                            }
+                    }
+                } else {
+                    for (iy = 0; iy<256; iy++) {
+                            for (ix = 0; ix<256; ix++) {
+                                    buf2[(iy<<8)+ix] = buf3[((iy*ym)<<ll) + (ix*xm)];
+                            }
+                    }
+                }
+		re.DrawStretchRaw( x, y, w, h, 256, 256, (byte *)buf2, handle, qtrue);
+		cinTable[handle].dirty = qfalse;
+		Hunk_FreeTempMemory(buf2);
+		return;
+	}
+
+	re.DrawStretchRaw( x, y, w, h, cinTable[handle].drawX, cinTable[handle].drawY, cinTable[handle].buf, handle, cinTable[handle].dirty);
+	cinTable[handle].dirty = qfalse;
+}
+
+void CL_PlayCinematic_f(void) {
+	char	*arg, *s;
+	int bits = CIN_system;
+
+	Com_DPrintf("CL_PlayCinematic_f\n");
+	if (cls.state == CA_CINEMATIC) {
+		SCR_StopCinematic();
+	}
+
+	arg = Cmd_Argv(1);
+	s = Cmd_Argv(2);
+
+	if ((s && s[0] == '1') || Q_stricmp(arg,"demoend.roq")==0 || Q_stricmp(arg,"end.roq")==0) {
+		bits |= CIN_hold;
+	}
+	if (s && s[0] == '2') {
+		bits |= CIN_loop;
+	}
+	
+	S_StopAllSounds ();
+	
+	CL_handle = CIN_PlayCinematic( arg, 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, bits );
+	if (CL_handle >= 0) {
+		do {
+			SCR_RunCinematic();
+		} while (cinTable[currentHandle].buf == NULL && cinTable[currentHandle].status == FMV_PLAY);		// wait for first frame (load codebook and sound)
+	}
+	else
+	{
+		Com_Printf(va(S_COLOR_RED "PlayCinematic(): Failed to open \"%s\"\n",arg));
+	}	
+}
+
+
+void SCR_DrawCinematic (void) {
+	if (CL_handle >= 0 && CL_handle < MAX_VIDEO_HANDLES) {
+		CIN_DrawCinematic(CL_handle);
+	}
+}
+
+void SCR_RunCinematic (void)
+{
+	if (CL_handle >= 0 && CL_handle < MAX_VIDEO_HANDLES) {
+		CIN_RunCinematic(CL_handle);
+	}
+}
+
+void SCR_StopCinematic(void) {
+	if (CL_handle >= 0 && CL_handle < MAX_VIDEO_HANDLES) {
+		CIN_StopCinematic(CL_handle);
+		S_StopAllSounds ();
+		CL_handle = -1;
+	}
+}
+
+void CIN_UploadCinematic(int handle) {
+	if (handle >= 0 && handle < MAX_VIDEO_HANDLES) {
+		if (!cinTable[handle].buf) {
+			return;
+		}
+		if (cinTable[handle].playonwalls <= 0 && cinTable[handle].dirty) {
+			if (cinTable[handle].playonwalls == 0) {
+				cinTable[handle].playonwalls = -1;
+			} else {
+				if (cinTable[handle].playonwalls == -1) {
+					cinTable[handle].playonwalls = -2;
+				} else {
+					cinTable[handle].dirty = qfalse;
+				}
+			}
+		}
+		re.UploadCinematic( cinTable[handle].drawX, cinTable[handle].drawY, cinTable[handle].buf, handle, cinTable[handle].dirty);
+		if (cl_inGameVideo->integer == 0 && cinTable[handle].playonwalls == 1) {
+			cinTable[handle].playonwalls--;
+		}
+	}
+}
+
diff --git a/codemp/client/cl_cin_console.cpp b/codemp/client/cl_cin_console.cpp
new file mode 100644
index 0000000..047c603
--- /dev/null
+++ b/codemp/client/cl_cin_console.cpp
@@ -0,0 +1,332 @@
+
+/*****************************************************************************
+ * name:		cl_cin_stubs.cpp
+ *
+ * desc:		video and cinematic playback stubs to avoid link errors
+ *
+ *
+ * cl_glconfig.hwtype trtypes 3dfx/ragepro need 256x256
+ *
+ *****************************************************************************/
+
+#include "client.h"
+#include "../win32/win_local.h"
+#include "../win32/win_input.h"
+#include "BinkVideo.h"
+
+#define XBOX_VIDEO_PATH "d:\\base\\video\\"
+
+BinkVideo bVideo;	// bink video object
+connstate_t	previousState = CA_UNINITIALIZED;	// previous cinematic state
+
+/********
+CIN_CloseAllVideos
+Stops all currently running videos
+*********/
+void CIN_CloseAllVideos(void)
+{
+	// Stop the current bink video
+	bVideo.Stop();
+}
+
+/********
+CIN_StopCinematic
+
+handle	- Not used
+return	- FMV status
+
+Stops the current cinematic
+*********/
+e_status CIN_StopCinematic(int handle)
+{
+	if(previousState != CA_UNINITIALIZED)
+	{
+		cls.state = previousState;
+		previousState = CA_UNINITIALIZED;
+	}
+	if(bVideo.GetStatus() != NS_BV_STOPPED)
+	{
+		bVideo.Stop();
+	}
+	return FMV_EOF;
+}
+
+/********
+CIN_StopCinematic
+
+handle	- Not used
+return	- FMV status
+
+Checks the status of the current cinematic
+*********/
+e_status CIN_RunCinematic (int handle)
+{
+	if(bVideo.GetStatus() == NS_BV_STOPPED)
+	{
+		return FMV_EOF;
+	}
+	else
+	{
+		return FMV_PLAY;
+	}
+}
+
+/********
+CIN_PlayCinematic
+
+arg0	- filename of bink video
+xpos	- x origin
+ypos	- y origin
+width	- width of the movie window
+height	- height of the movie window
+bits	- CIN flags
+psAudioFile	- audio file for movie (not used)
+
+Starts playing the given bink video file
+*********/
+#ifdef _JK2MP
+int CIN_PlayCinematic( const char *arg0, int xpos, int ypos, int width, int height, int bits)
+#else
+int CIN_PlayCinematic( const char *arg0, int xpos, int ypos, int width, int height, int bits, const char *psAudioFile /* = NULL */)
+#endif
+{
+	char	name[MAX_OSPATH];
+	char	arg[MAX_OSPATH];
+	char*	nameonly;
+
+	// get a local copy of the name
+	strcpy(arg,arg0);
+
+	// remove path
+	nameonly = COM_SkipPath(arg);
+
+	// form the proper name with path
+	Com_sprintf(name,sizeof(name),XBOX_VIDEO_PATH);
+	strcat(name,nameonly);
+	COM_DefaultExtension(name, sizeof(name),".bik");
+
+	if(bVideo.Start(name,xpos,ypos,width,height))
+	{
+		if(bits & CIN_loop)
+		{
+			bVideo.SetLooping(true);
+		}
+		if(bits & CIN_silent)
+		{
+			bVideo.SetMasterVolume(0);
+		}
+		if(!(bits & CIN_shader))
+		{
+			previousState = cls.state;
+			cls.state = CA_CINEMATIC;
+		}
+		return 1;
+	}
+	else
+	{
+		return -1;
+	}
+}
+
+/*********
+CIN_SetExtents
+
+handle	- handle to a video (not used)
+x		- x origin for window
+y		- y origin for window
+w		- width for window
+h		- height for window
+*********/
+void CIN_SetExtents (int handle, int x, int y, int w, int h)
+{
+	bVideo.SetExtents(x,y,w,h);
+}
+
+/********
+CIN_DrawCinematic
+
+handle	- handle to a video (not used)
+
+Updates the current frame of the current video
+*********/
+void CIN_DrawCinematic (int handle)
+{
+	bVideo.Run();
+}
+
+/*********
+SCR_DrawCinematic
+*********/
+void SCR_DrawCinematic (void)
+{
+	CIN_DrawCinematic(1);
+}
+/*********
+SCR_RunCinematic
+*********/
+void SCR_RunCinematic (void)
+{
+	CIN_RunCinematic(1);
+}
+
+/*********
+SCR_StopCinematic
+*********/
+#ifdef _JK2MP
+void SCR_StopCinematic(void)
+#else
+void SCR_StopCinematic(qboolean bAllowRefusal /* = qfalse */)
+#endif
+{
+	CIN_StopCinematic(1);
+}
+
+/*********
+CIN_UploadCinematic
+
+handle		- (not used)
+
+This function can be used to render a frame of a movie, if
+it needs to be done outside of CA_CINEMATIC. For example,
+a menu background or wall texture.
+*********/
+void CIN_UploadCinematic(int handle)
+{
+	int w, h;
+	byte* data;
+
+	if(!bVideo.Ready()) {
+		return;
+	}
+
+	w		= bVideo.GetBinkWidth();
+	h		= bVideo.GetBinkHeight();
+	data	= (byte*)bVideo.GetBinkData();
+
+	re.UploadCinematic( w, h, data, handle, 1);
+}
+
+/*********
+CIN_PlayAllFrames
+
+arg				- bink video filename
+x				- x origin for movie
+y				- y origin for movie
+w				- width of the movie
+h				- height of the movie
+systemBits		- bit rate for movie
+keyBreakAllowed	- if true, button press will end playback
+
+Plays the target movie in full
+*********/
+#ifdef _XBOX
+extern void Key_ClearStates(void);
+#endif
+bool CIN_PlayAllFrames( const char *arg, int x, int y, int w, int h, int systemBits, bool keyBreakAllowed )
+{
+//JLF new
+	bool retval;
+//endJLF
+	Key_ClearStates();
+
+#ifdef _JK2MP
+	int Handle = CIN_PlayCinematic(arg, x, y, w, h, systemBits);
+#else
+	int Handle = CIN_PlayCinematic(arg, x, y, w, h, systemBits, NULL);
+#endif
+	if (Handle != -1)
+	{
+		while (CIN_RunCinematic(Handle) == FMV_PLAY && !(keyBreakAllowed && kg.anykeydown))
+		{
+			SCR_UpdateScreen	();
+			IN_Frame			();
+			Com_EventLoop		();
+		}
+#ifdef _XBOX
+		while (CIN_RunCinematic(Handle) == FMV_PLAY && !(keyBreakAllowed && !kg.anykeydown))
+		{
+			SCR_UpdateScreen	();
+			IN_Frame			();
+			Com_EventLoop		();
+		}
+#endif
+		CIN_StopCinematic(Handle);
+		
+	}
+	retval =(keyBreakAllowed && kg.anykeydown);
+	Key_ClearStates();
+	return retval;
+}
+
+/*********
+CIN_DisplayIntros
+Draws intro movies to the screen
+*********/
+void CIN_DisplayIntros(void)
+{
+
+	////////////////////////////////////
+	// Play 1st video: Activision
+	////////////////////////////////////
+	CIN_PlayAllFrames( "atvi.bik", 0, 0, 640, 480, 0, true );
+
+	
+	////////////////////////////////////
+	// Play 2nd video: Vicarious Visions
+	////////////////////////////////////
+	CIN_PlayAllFrames( "vvintro.bik", 0, 0, 640, 480, 0, true );
+}
+
+/*********
+CIN_Init
+Initializes cinematic system
+*********/
+void CIN_Init(void)
+{
+	// Allocate Memory for Bink System
+	bVideo.AllocateXboxMem();
+}
+
+/********
+CIN_Shutdown
+Shutdown the cinematic system
+********/
+void CIN_Shutdown(void)
+{
+	// Free Memory for the Bink System
+	bVideo.FreeXboxMem();
+}
+
+
+/***** Possible FIXME *****/
+/***** The following function may need to be implemented *****/
+/***** BEGIN *****/
+void CL_PlayCinematic_f(void)
+{
+	// Nothing
+}
+
+qboolean CL_IsRunningInGameCinematic(void)
+{
+	// Nothing
+	return qfalse;
+}
+
+qboolean CL_CheckPendingCinematic(void)
+{
+	// Nothing
+	return qfalse;
+}
+
+void CL_PlayInGameCinematic_f(void)
+{
+	// Nothing
+}
+
+qboolean CL_InGameCinematicOnStandBy(void)
+{
+	// Nothing
+	return qfalse;
+}
+/***** END *****/
+
diff --git a/codemp/client/cl_console.cpp b/codemp/client/cl_console.cpp
new file mode 100644
index 0000000..0829418
--- /dev/null
+++ b/codemp/client/cl_console.cpp
@@ -0,0 +1,831 @@
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+// console.c
+
+#include "client.h"
+#include "../qcommon/stringed_ingame.h"
+#include "../qcommon/game_version.h"
+
+
+int g_console_field_width = 78;
+
+console_t	con;
+
+cvar_t		*con_conspeed;
+cvar_t		*con_notifytime;
+
+#define	DEFAULT_CONSOLE_WIDTH	78
+
+vec4_t	console_color = {1.0, 1.0, 1.0, 1.0};
+
+
+/*
+================
+Con_ToggleConsole_f
+================
+*/
+#ifndef _XBOX	// No console on Xbox
+void Con_ToggleConsole_f (void) {
+	// closing a full screen console restarts the demo loop
+	if ( cls.state == CA_DISCONNECTED && cls.keyCatchers == KEYCATCH_CONSOLE ) {
+		CL_StartDemoLoop();
+		return;
+	}
+
+	Field_Clear( &kg.g_consoleField );
+	kg.g_consoleField.widthInChars = g_console_field_width;
+
+	Con_ClearNotify ();
+	cls.keyCatchers ^= KEYCATCH_CONSOLE;
+}
+#endif
+
+/*
+================
+Con_MessageMode_f
+================
+*/
+void Con_MessageMode_f (void) {	//yell
+	chat_playerNum = -1;
+	chat_team = qfalse;
+	Field_Clear( &chatField );
+	chatField.widthInChars = 30;
+
+	cls.keyCatchers ^= KEYCATCH_MESSAGE;
+}
+
+/*
+================
+Con_MessageMode2_f
+================
+*/
+void Con_MessageMode2_f (void) {	//team chat
+	chat_playerNum = -1;
+	chat_team = qtrue;
+	Field_Clear( &chatField );
+	chatField.widthInChars = 25;
+	cls.keyCatchers ^= KEYCATCH_MESSAGE;
+}
+
+/*
+================
+Con_MessageMode3_f
+================
+*/
+void Con_MessageMode3_f (void)
+{		//target chat
+	if (!cgvm)
+	{
+		assert(!"null cgvm");
+		return;
+	}
+
+	chat_playerNum = VM_Call( cgvm, CG_CROSSHAIR_PLAYER );
+	if ( chat_playerNum < 0 || chat_playerNum >= MAX_CLIENTS ) {
+		chat_playerNum = -1;
+		return;
+	}
+	chat_team = qfalse;
+	Field_Clear( &chatField );
+	chatField.widthInChars = 30;
+	cls.keyCatchers ^= KEYCATCH_MESSAGE;
+}
+
+/*
+================
+Con_MessageMode4_f
+================
+*/
+void Con_MessageMode4_f (void)
+{	//attacker
+	if (!cgvm)
+	{
+		assert(!"null cgvm");
+		return;
+	}
+
+	chat_playerNum = VM_Call( cgvm, CG_LAST_ATTACKER );
+	if ( chat_playerNum < 0 || chat_playerNum >= MAX_CLIENTS ) {
+		chat_playerNum = -1;
+		return;
+	}
+	chat_team = qfalse;
+	Field_Clear( &chatField );
+	chatField.widthInChars = 30;
+	cls.keyCatchers ^= KEYCATCH_MESSAGE;
+}
+
+/*
+================
+Con_Clear_f
+================
+*/
+void Con_Clear_f (void) {
+	int		i;
+
+	for ( i = 0 ; i < CON_TEXTSIZE ; i++ ) {
+		con.text[i] = (ColorIndex(COLOR_WHITE)<<8) | ' ';
+	}
+
+	Con_Bottom();		// go to end
+}
+
+						
+/*
+================
+Con_Dump_f
+
+Save the console contents out to a file
+================
+*/
+void Con_Dump_f (void)
+{
+	int				l, x, i;
+	short			*line;
+	fileHandle_t	f;
+	char			buffer[1024];
+
+	if (Cmd_Argc() != 2)
+	{
+		Com_Printf (SE_GetString("CON_TEXT_DUMP_USAGE"));
+		return;
+	}
+
+	Com_Printf ("Dumped console text to %s.\n", Cmd_Argv(1) );
+
+	f = FS_FOpenFileWrite( Cmd_Argv( 1 ) );
+	if (!f)
+	{
+		Com_Printf (S_COLOR_RED"ERROR: couldn't open.\n");
+		return;
+	}
+
+	// skip empty lines
+	for (l = con.current - con.totallines + 1 ; l <= con.current ; l++)
+	{
+		line = con.text + (l%con.totallines)*con.linewidth;
+		for (x=0 ; x<con.linewidth ; x++)
+			if ((line[x] & 0xff) != ' ')
+				break;
+		if (x != con.linewidth)
+			break;
+	}
+
+	// write the remaining lines
+	buffer[con.linewidth] = 0;
+	for ( ; l <= con.current ; l++)
+	{
+		line = con.text + (l%con.totallines)*con.linewidth;
+		for(i=0; i<con.linewidth; i++)
+			buffer[i] = (char) (line[i] & 0xff);
+		for (x=con.linewidth-1 ; x>=0 ; x--)
+		{
+			if (buffer[x] == ' ')
+				buffer[x] = 0;
+			else
+				break;
+		}
+		strcat( buffer, "\n" );
+		FS_Write(buffer, strlen(buffer), f);
+	}
+
+	FS_FCloseFile( f );
+}
+
+						
+/*
+================
+Con_ClearNotify
+================
+*/
+void Con_ClearNotify( void ) {
+	int		i;
+	
+	for ( i = 0 ; i < NUM_CON_TIMES ; i++ ) {
+		con.times[i] = 0;
+	}
+}
+
+						
+
+/*
+================
+Con_CheckResize
+
+If the line width has changed, reformat the buffer.
+================
+*/
+void Con_CheckResize (void)
+{
+	int		i, j, width, oldwidth, oldtotallines, numlines, numchars;
+	MAC_STATIC short	tbuf[CON_TEXTSIZE];
+
+//	width = (SCREEN_WIDTH / SMALLCHAR_WIDTH) - 2;
+	width = (cls.glconfig.vidWidth / SMALLCHAR_WIDTH) - 2;
+
+	if (width == con.linewidth)
+		return;
+
+
+	if (width < 1)			// video hasn't been initialized yet
+	{
+		con.xadjust = 1;
+		con.yadjust = 1;
+		width = DEFAULT_CONSOLE_WIDTH;
+		con.linewidth = width;
+		con.totallines = CON_TEXTSIZE / con.linewidth;
+		for(i=0; i<CON_TEXTSIZE; i++)
+		{
+			con.text[i] = (ColorIndex(COLOR_WHITE)<<8) | ' ';
+		}
+	}
+	else
+	{
+		// on wide screens, we will center the text
+		con.xadjust = 640.0f / cls.glconfig.vidWidth;
+		con.yadjust = 480.0f / cls.glconfig.vidHeight;
+
+		oldwidth = con.linewidth;
+		con.linewidth = width;
+		oldtotallines = con.totallines;
+		con.totallines = CON_TEXTSIZE / con.linewidth;
+		numlines = oldtotallines;
+
+		if (con.totallines < numlines)
+			numlines = con.totallines;
+
+		numchars = oldwidth;
+	
+		if (con.linewidth < numchars)
+			numchars = con.linewidth;
+
+		Com_Memcpy (tbuf, con.text, CON_TEXTSIZE * sizeof(short));
+		for(i=0; i<CON_TEXTSIZE; i++)
+
+			con.text[i] = (ColorIndex(COLOR_WHITE)<<8) | ' ';
+
+
+		for (i=0 ; i<numlines ; i++)
+		{
+			for (j=0 ; j<numchars ; j++)
+			{
+				con.text[(con.totallines - 1 - i) * con.linewidth + j] =
+						tbuf[((con.current - i + oldtotallines) %
+							  oldtotallines) * oldwidth + j];
+			}
+		}
+
+		Con_ClearNotify ();
+	}
+
+	con.current = con.totallines - 1;
+	con.display = con.current;
+}
+
+
+/*
+================
+Con_Init
+================
+*/
+void Con_Init (void) {
+	int		i;
+
+	con_notifytime = Cvar_Get ("con_notifytime", "3", 0);
+	con_conspeed = Cvar_Get ("scr_conspeed", "3", 0);
+
+	Field_Clear( &kg.g_consoleField );
+	kg.g_consoleField.widthInChars = g_console_field_width;
+	for ( i = 0 ; i < COMMAND_HISTORY ; i++ ) {
+		Field_Clear( &kg.historyEditLines[i] );
+		kg.historyEditLines[i].widthInChars = g_console_field_width;
+	}
+
+#ifndef _XBOX	// No console on Xbox
+	Cmd_AddCommand ("toggleconsole", Con_ToggleConsole_f);
+#endif
+	Cmd_AddCommand ("messagemode", Con_MessageMode_f);
+	Cmd_AddCommand ("messagemode2", Con_MessageMode2_f);
+	Cmd_AddCommand ("messagemode3", Con_MessageMode3_f);
+	Cmd_AddCommand ("messagemode4", Con_MessageMode4_f);
+	Cmd_AddCommand ("clear", Con_Clear_f);
+	Cmd_AddCommand ("condump", Con_Dump_f);
+
+	//Initialize values on first print
+	con.initialized = qfalse;
+}
+
+
+/*
+===============
+Con_Linefeed
+===============
+*/
+static void Con_Linefeed (qboolean silent)
+{
+	int		i;
+
+	// mark time for transparent overlay
+	if (con.current >= 0 && !silent )
+	{
+		con.times[con.current % NUM_CON_TIMES] = cls.realtime;
+	}
+	else
+	{
+		con.times[con.current % NUM_CON_TIMES] = 0;
+	}
+
+	con.x = 0;
+	if (con.display == con.current)
+		con.display++;
+	con.current++;
+	for(i=0; i<con.linewidth; i++)
+		con.text[(con.current%con.totallines)*con.linewidth+i] = (ColorIndex(COLOR_WHITE)<<8) | ' ';
+}
+
+/*
+================
+CL_ConsolePrint
+
+Handles cursor positioning, line wrapping, etc
+All console printing must go through this in order to be logged to disk
+If no console is visible, the text will appear at the top of the game window
+================
+*/
+void CL_ConsolePrint( const char *txt, qboolean silent) {
+	int		y;
+	int		c, l;
+	int		color;
+
+	// for some demos we don't want to ever show anything on the console
+	if ( cl_noprint && cl_noprint->integer ) {
+		return;
+	}
+	
+	if (!con.initialized) {
+		con.color[0] = 
+		con.color[1] = 
+		con.color[2] =
+		con.color[3] = 1.0f;
+		con.linewidth = -1;
+		Con_CheckResize ();
+		con.initialized = qtrue;
+	}
+
+	color = ColorIndex(COLOR_WHITE);
+
+	while ( (c = (unsigned char) *txt) != 0 ) {
+		if ( Q_IsColorString( (unsigned char*) txt ) ) {
+			color = ColorIndex( *(txt+1) );
+			txt += 2;
+			continue;
+		}
+
+		// count word length
+		for (l=0 ; l< con.linewidth ; l++) {
+			if ( txt[l] <= ' ') {
+				break;
+			}
+
+		}
+
+		// word wrap
+		if (l != con.linewidth && (con.x + l >= con.linewidth) ) {
+			Con_Linefeed(silent);
+
+		}
+
+		txt++;
+
+		switch (c)
+		{
+		case '\n':
+			Con_Linefeed (silent);
+			break;
+		case '\r':
+			con.x = 0;
+			break;
+		default:	// display character and advance
+			y = con.current % con.totallines;
+			con.text[y*con.linewidth+con.x] = (short) ((color << 8) | c);
+			con.x++;
+			if (con.x >= con.linewidth) {
+
+				Con_Linefeed(silent);
+				con.x = 0;
+			}
+			break;
+		}
+	}
+
+
+	// mark time for transparent overlay
+
+	if (con.current >= 0 && !silent )
+	{
+		con.times[con.current % NUM_CON_TIMES] = cls.realtime;
+	}
+	else
+	{
+		con.times[con.current % NUM_CON_TIMES] = 0;
+	}
+}
+
+
+/*
+==============================================================================
+
+DRAWING
+
+==============================================================================
+*/
+
+
+/*
+================
+Con_DrawInput
+
+Draw the editline after a ] prompt
+================
+*/
+void Con_DrawInput (void) {
+	int		y;
+
+	if ( cls.state != CA_DISCONNECTED && !(cls.keyCatchers & KEYCATCH_CONSOLE ) ) {
+		return;
+	}
+
+	y = con.vislines - ( SMALLCHAR_HEIGHT * (re.Language_IsAsian() ? 1.5 : 2) );
+
+	re.SetColor( con.color );
+
+	SCR_DrawSmallChar( (int)(con.xadjust + 1 * SMALLCHAR_WIDTH), y, ']' );
+
+	Field_Draw( &kg.g_consoleField, (int)(con.xadjust + 2 * SMALLCHAR_WIDTH), y,
+				SCREEN_WIDTH - 3 * SMALLCHAR_WIDTH, qtrue );
+}
+
+
+
+
+/*
+================
+Con_DrawNotify
+
+Draws the last few lines of output transparently over the game top
+================
+*/
+void Con_DrawNotify (void)
+{
+	int		x, v;
+	short	*text;
+	int		i;
+	int		time;
+	int		skip;
+	int		currentColor;
+	const char* chattext;
+
+	currentColor = 7;
+	re.SetColor( g_color_table[currentColor] );
+
+	v = 0;
+	for (i= con.current-NUM_CON_TIMES+1 ; i<=con.current ; i++)
+	{
+		if (i < 0)
+			continue;
+		time = con.times[i % NUM_CON_TIMES];
+		if (time == 0)
+			continue;
+		time = cls.realtime - time;
+		if (time > con_notifytime->value*1000)
+			continue;
+		text = con.text + (i % con.totallines)*con.linewidth;
+
+		if (cl.snap.ps.pm_type != PM_INTERMISSION && cls.keyCatchers & (KEYCATCH_UI | KEYCATCH_CGAME) ) {
+			continue;
+		}
+
+
+		if (!cl_conXOffset)
+		{
+			cl_conXOffset = Cvar_Get ("cl_conXOffset", "0", 0);
+		}
+
+		// asian language needs to use the new font system to print glyphs...
+		//
+		// (ignore colours since we're going to print the whole thing as one string)
+		//
+		if (re.Language_IsAsian())
+		{
+			static int iFontIndex = re.RegisterFont("ocr_a");	// this seems naughty
+			const float fFontScale = 0.75f*con.yadjust;
+			const int iPixelHeightToAdvance =   2+(1.3/con.yadjust) * re.Font_HeightPixels(iFontIndex, fFontScale);	// for asian spacing, since we don't want glyphs to touch.
+
+			// concat the text to be printed...
+			//
+			char sTemp[4096]={0};	// ott
+			for (x = 0 ; x < con.linewidth ; x++) 
+			{
+				if ( ( (text[x]>>8)&7 ) != currentColor ) {
+					currentColor = (text[x]>>8)&7;
+					strcat(sTemp,va("^%i", (text[x]>>8)&7) );
+				}
+				strcat(sTemp,va("%c",text[x] & 0xFF));				
+			}
+			//
+			// and print...
+			//
+			re.Font_DrawString(cl_conXOffset->integer + con.xadjust*(con.xadjust + (1*SMALLCHAR_WIDTH/*aesthetics*/)), con.yadjust*(v), sTemp, g_color_table[currentColor], iFontIndex, -1, fFontScale);
+
+			v +=  iPixelHeightToAdvance;
+		}
+		else
+		{		
+			for (x = 0 ; x < con.linewidth ; x++) {
+				if ( ( text[x] & 0xff ) == ' ' ) {
+					continue;
+				}
+				if ( ( (text[x]>>8)&7 ) != currentColor ) {
+					currentColor = (text[x]>>8)&7;
+					re.SetColor( g_color_table[currentColor] );
+				}
+				if (!cl_conXOffset)
+				{
+					cl_conXOffset = Cvar_Get ("cl_conXOffset", "0", 0);
+				}
+				SCR_DrawSmallChar( (int)(cl_conXOffset->integer + con.xadjust + (x+1)*SMALLCHAR_WIDTH), v, text[x] & 0xff );
+			}
+
+			v += SMALLCHAR_HEIGHT;
+		}
+	}
+
+	re.SetColor( NULL );
+
+	if (cls.keyCatchers & (KEYCATCH_UI | KEYCATCH_CGAME) ) {
+		return;
+	}
+
+	// draw the chat line
+	if ( cls.keyCatchers & KEYCATCH_MESSAGE )
+	{
+		if (chat_team)
+		{
+			chattext = SE_GetString("MP_SVGAME", "SAY_TEAM");
+			SCR_DrawBigString (8, v, chattext, 1.0f );
+			skip = strlen(chattext)+1;
+		}
+		else
+		{
+			chattext = SE_GetString("MP_SVGAME", "SAY");
+			SCR_DrawBigString (8, v, chattext, 1.0f );
+			skip = strlen(chattext)+1;
+		}
+
+		Field_BigDraw( &chatField, skip * BIGCHAR_WIDTH, v,
+			SCREEN_WIDTH - ( skip + 1 ) * BIGCHAR_WIDTH, qtrue );
+
+		v += BIGCHAR_HEIGHT;
+	}
+
+}
+
+/*
+================
+Con_DrawSolidConsole
+
+Draws the console with the solid background
+================
+*/
+void Con_DrawSolidConsole( float frac ) {
+	int				i, x, y;
+	int				rows;
+	short			*text;
+	int				row;
+	int				lines;
+//	qhandle_t		conShader;
+	int				currentColor;
+
+	lines = (int) (cls.glconfig.vidHeight * frac);
+	if (lines <= 0)
+		return;
+
+	if (lines > cls.glconfig.vidHeight )
+		lines = cls.glconfig.vidHeight;
+
+	// draw the background
+	y = (int) (frac * SCREEN_HEIGHT - 2);
+	if ( y < 1 ) {
+		y = 0;
+	}
+	else {
+		SCR_DrawPic( 0, 0, SCREEN_WIDTH, (float) y, cls.consoleShader );
+	}
+
+	const vec4_t color = { 0.509f, 0.609f, 0.847f,  1.0f};
+	// draw the bottom bar and version number
+
+	re.SetColor( color );
+	re.DrawStretchPic( 0, y, SCREEN_WIDTH, 2, 0, 0, 0, 0, cls.whiteShader );
+
+	i = strlen( Q3_VERSION );
+
+	for (x=0 ; x<i ; x++) {
+		SCR_DrawSmallChar( cls.glconfig.vidWidth - ( i - x ) * SMALLCHAR_WIDTH, 
+			(lines-(SMALLCHAR_HEIGHT+SMALLCHAR_HEIGHT/2)), Q3_VERSION[x] );
+	}
+
+
+	// draw the text
+	con.vislines = lines;
+	rows = (lines-SMALLCHAR_WIDTH)/SMALLCHAR_WIDTH;		// rows of text to draw
+
+	y = lines - (SMALLCHAR_HEIGHT*3);
+
+	// draw from the bottom up
+	if (con.display != con.current)
+	{
+	// draw arrows to show the buffer is backscrolled
+		re.SetColor( g_color_table[ColorIndex(COLOR_RED)] );
+		for (x=0 ; x<con.linewidth ; x+=4)
+			SCR_DrawSmallChar( (int) (con.xadjust + (x+1)*SMALLCHAR_WIDTH), y, '^' );
+		y -= SMALLCHAR_HEIGHT;
+		rows--;
+	}
+	
+	row = con.display;
+
+	if ( con.x == 0 ) {
+		row--;
+	}
+
+	currentColor = 7;
+	re.SetColor( g_color_table[currentColor] );
+
+	static int iFontIndexForAsian = 0;
+	const float fFontScaleForAsian = 0.75f*con.yadjust;
+	int iPixelHeightToAdvance = SMALLCHAR_HEIGHT;
+	if (re.Language_IsAsian())
+	{
+		if (!iFontIndexForAsian) 
+		{
+			iFontIndexForAsian = re.RegisterFont("ocr_a");
+		}
+		iPixelHeightToAdvance = (1.3/con.yadjust) * re.Font_HeightPixels(iFontIndexForAsian, fFontScaleForAsian);	// for asian spacing, since we don't want glyphs to touch.
+	}
+
+	for (i=0 ; i<rows ; i++, y -= iPixelHeightToAdvance, row--)
+	{
+		if (row < 0)
+			break;
+		if (con.current - row >= con.totallines) {
+			// past scrollback wrap point
+			continue;	
+		}
+
+		text = con.text + (row % con.totallines)*con.linewidth;
+
+		// asian language needs to use the new font system to print glyphs...
+		//
+		// (ignore colours since we're going to print the whole thing as one string)
+		//
+		if (re.Language_IsAsian())
+		{
+			// concat the text to be printed...
+			//
+			char sTemp[4096]={0};	// ott
+			for (x = 0 ; x < con.linewidth ; x++) 
+			{
+				if ( ( (text[x]>>8)&7 ) != currentColor ) {
+					currentColor = (text[x]>>8)&7;
+					strcat(sTemp,va("^%i", (text[x]>>8)&7) );
+				}
+				strcat(sTemp,va("%c",text[x] & 0xFF));				
+			}
+			//
+			// and print...
+			//
+			re.Font_DrawString(con.xadjust*(con.xadjust + (1*SMALLCHAR_WIDTH/*(aesthetics)*/)), con.yadjust*(y), sTemp, g_color_table[currentColor], iFontIndexForAsian, -1, fFontScaleForAsian);
+		}
+		else
+		{		
+			for (x=0 ; x<con.linewidth ; x++) {
+				if ( ( text[x] & 0xff ) == ' ' ) {
+					continue;
+				}
+
+				if ( ( (text[x]>>8)&7 ) != currentColor ) {
+					currentColor = (text[x]>>8)&7;
+					re.SetColor( g_color_table[currentColor] );
+				}
+				SCR_DrawSmallChar(  (int) (con.xadjust + (x+1)*SMALLCHAR_WIDTH), y, text[x] & 0xff );
+			}
+		}
+	}
+
+	// draw the input prompt, user text, and cursor if desired
+	Con_DrawInput ();
+
+	re.SetColor( NULL );
+}
+
+
+
+/*
+==================
+Con_DrawConsole
+==================
+*/
+void Con_DrawConsole( void ) {
+	// check for console width changes from a vid mode change
+	Con_CheckResize ();
+
+	// if disconnected, render console full screen
+	if ( cls.state == CA_DISCONNECTED ) {
+		if ( !( cls.keyCatchers & (KEYCATCH_UI | KEYCATCH_CGAME)) ) {
+			Con_DrawSolidConsole( 1.0 );
+			return;
+		}
+	}
+
+	if ( con.displayFrac ) {
+		Con_DrawSolidConsole( con.displayFrac );
+	} else {
+		// draw notify lines
+		if ( cls.state == CA_ACTIVE ) {
+			Con_DrawNotify ();
+		}
+	}
+}
+
+//================================================================
+
+/*
+==================
+Con_RunConsole
+
+Scroll it up or down
+==================
+*/
+void Con_RunConsole (void) {
+	// decide on the destination height of the console
+	if ( cls.keyCatchers & KEYCATCH_CONSOLE )
+		con.finalFrac = 0.5;		// half screen
+	else
+		con.finalFrac = 0;				// none visible
+	
+	// scroll towards the destination height
+	if (con.finalFrac < con.displayFrac)
+	{
+		con.displayFrac -= con_conspeed->value*(float)(cls.realFrametime*0.001);
+		if (con.finalFrac > con.displayFrac)
+			con.displayFrac = con.finalFrac;
+
+	}
+	else if (con.finalFrac > con.displayFrac)
+	{
+		con.displayFrac += con_conspeed->value*(float)(cls.realFrametime*0.001);
+		if (con.finalFrac < con.displayFrac)
+			con.displayFrac = con.finalFrac;
+	}
+
+}
+
+
+void Con_PageUp( void ) {
+	con.display -= 2;
+	if ( con.current - con.display >= con.totallines ) {
+		con.display = con.current - con.totallines + 1;
+	}
+}
+
+void Con_PageDown( void ) {
+	con.display += 2;
+	if (con.display > con.current) {
+		con.display = con.current;
+	}
+}
+
+void Con_Top( void ) {
+	con.display = con.totallines;
+	if ( con.current - con.display >= con.totallines ) {
+		con.display = con.current - con.totallines + 1;
+	}
+}
+
+void Con_Bottom( void ) {
+	con.display = con.current;
+}
+
+
+void Con_Close( void ) {
+	if ( !com_cl_running->integer ) {
+		return;
+	}
+	Field_Clear( &kg.g_consoleField );
+	Con_ClearNotify ();
+	cls.keyCatchers &= ~KEYCATCH_CONSOLE;
+	con.finalFrac = 0;				// none visible
+	con.displayFrac = 0;
+}
diff --git a/codemp/client/cl_input.cpp b/codemp/client/cl_input.cpp
new file mode 100644
index 0000000..0bf6dd6
--- /dev/null
+++ b/codemp/client/cl_input.cpp
@@ -0,0 +1,1892 @@
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+// cl.input.c  -- builds an intended movement command to send to the server
+
+#include "client.h"
+#ifdef _XBOX
+#include "../../code/client/cl_input_hotswap.h"
+#include "../xbox/XBVoice.h"
+#endif
+unsigned	frame_msec;
+int			old_com_frameTime;
+
+float cl_mPitchOverride = 0.0f;
+float cl_mYawOverride = 0.0f;
+float cl_mSensitivityOverride = 0.0f;
+qboolean cl_bUseFighterPitch = qfalse;
+qboolean cl_crazyShipControls = qfalse;
+#define	OVERRIDE_MOUSE_SENSITIVITY 5.0f//20.0f = 180 degree turn in one mouse swipe across keyboard
+/*
+===============================================================================
+
+KEY BUTTONS
+
+Continuous button event tracking is complicated by the fact that two different
+input sources (say, mouse button 1 and the control key) can both press the
+same button, but the button should only be released when both of the
+pressing key have been released.
+
+When a key event issues a button command (+forward, +attack, etc), it appends
+its key number as argv(1) so it can be matched up with the release.
+
+argv(2) will be set to the time the event happened, which allows exact
+control even at low framerates when the down and up events may both get qued
+at the same time.
+
+===============================================================================
+*/
+
+
+kbutton_t	in_left, in_right, in_forward, in_back;
+kbutton_t	in_lookup, in_lookdown, in_moveleft, in_moveright;
+kbutton_t	in_strafe, in_speed;
+kbutton_t	in_up, in_down;
+
+kbutton_t	in_buttons[16];
+
+
+qboolean	in_mlooking;
+
+
+#ifdef _XBOX
+HotSwapManager swapMan1(HOTSWAP_ID_WHITE);
+HotSwapManager swapMan2(HOTSWAP_ID_BLACK);
+
+
+void IN_HotSwap1On(void)
+{
+	swapMan1.SetDown();
+}
+
+
+void IN_HotSwap2On(void)
+{
+	swapMan2.SetDown();
+}
+
+
+void IN_HotSwap1Off(void)
+{
+	swapMan1.SetUp();
+}
+
+
+void IN_HotSwap2Off(void)
+{
+	swapMan2.SetUp();
+}
+
+
+void CL_UpdateHotSwap(void)
+{
+	swapMan1.Update();
+	swapMan2.Update();
+}
+
+
+bool CL_ExtendSelectTime(void)
+{
+	return swapMan1.ButtonDown() || swapMan2.ButtonDown();
+}
+
+
+#endif
+
+
+void IN_Button11Down(void);
+void IN_Button11Up(void);
+void IN_Button10Down(void);
+void IN_Button10Up(void);
+void IN_Button6Down(void);
+void IN_Button6Up(void);
+void IN_UseGivenForce(void)
+{
+	char *c = Cmd_Argv(1);
+	int forceNum =-1;
+	int genCmdNum = 0;
+
+	if(c) {
+		forceNum = atoi(c);
+	} else {
+		return;
+	}
+
+	switch(forceNum) {
+	case FP_DRAIN:
+		IN_Button11Down();
+		IN_Button11Up();
+		break;
+	case FP_PUSH:
+		genCmdNum = GENCMD_FORCE_THROW;
+		break;
+	case FP_SPEED:
+		genCmdNum = GENCMD_FORCE_SPEED;
+		break;
+	case FP_PULL:
+		genCmdNum = GENCMD_FORCE_PULL;
+		break;
+	case FP_TELEPATHY:
+		genCmdNum = GENCMD_FORCE_DISTRACT;
+		break;
+	case FP_GRIP:
+		IN_Button6Down();
+		IN_Button6Up();
+		break;
+	case FP_LIGHTNING:
+		IN_Button10Down();
+		IN_Button10Up();
+		break;
+	case FP_RAGE:
+		genCmdNum = GENCMD_FORCE_RAGE;
+		break;
+	case FP_PROTECT:
+		genCmdNum = GENCMD_FORCE_PROTECT;
+		break;
+	case FP_ABSORB:
+		genCmdNum = GENCMD_FORCE_ABSORB;
+		break;
+	case FP_SEE:
+		genCmdNum = GENCMD_FORCE_SEEING;
+		break;
+	case FP_HEAL:
+		genCmdNum = GENCMD_FORCE_HEAL;
+		break;
+	case FP_TEAM_HEAL:
+		genCmdNum = GENCMD_FORCE_HEALOTHER;
+		break;
+	case FP_TEAM_FORCE:
+		genCmdNum = GENCMD_FORCE_FORCEPOWEROTHER;
+		break;
+	default:
+		assert(0);
+		break;
+	}
+
+	if(genCmdNum != 0) {
+		cl.gcmdSendValue = qtrue;
+		cl.gcmdValue = genCmdNum;
+	}
+}
+
+void IN_MLookDown( void ) {
+	in_mlooking = qtrue;
+}
+
+void IN_MLookUp( void ) {
+	in_mlooking = qfalse;
+	if ( !cl_freelook->integer ) {
+		IN_CenterView ();
+	}
+}
+
+void IN_GenCMD1( void )
+{
+	cl.gcmdSendValue = qtrue;
+	cl.gcmdValue = GENCMD_SABERSWITCH;
+}
+
+void IN_GenCMD2( void )
+{
+	cl.gcmdSendValue = qtrue;
+	cl.gcmdValue = GENCMD_ENGAGE_DUEL;
+}
+
+void IN_GenCMD3( void )
+{
+	cl.gcmdSendValue = qtrue;
+	cl.gcmdValue = GENCMD_FORCE_HEAL;
+}
+
+void IN_GenCMD4( void )
+{
+	cl.gcmdSendValue = qtrue;
+	cl.gcmdValue = GENCMD_FORCE_SPEED;
+}
+
+void IN_GenCMD5( void )
+{
+	cl.gcmdSendValue = qtrue;
+	cl.gcmdValue = GENCMD_FORCE_PULL;
+}
+
+void IN_GenCMD6( void )
+{
+	cl.gcmdSendValue = qtrue;
+	cl.gcmdValue = GENCMD_FORCE_DISTRACT;
+}
+
+void IN_GenCMD7( void )
+{
+	cl.gcmdSendValue = qtrue;
+	cl.gcmdValue = GENCMD_FORCE_RAGE;
+}
+
+void IN_GenCMD8( void )
+{
+	cl.gcmdSendValue = qtrue;
+	cl.gcmdValue = GENCMD_FORCE_PROTECT;
+}
+
+void IN_GenCMD9( void )
+{
+	cl.gcmdSendValue = qtrue;
+	cl.gcmdValue = GENCMD_FORCE_ABSORB;
+}
+
+void IN_GenCMD10( void )
+{
+	cl.gcmdSendValue = qtrue;
+	cl.gcmdValue = GENCMD_FORCE_HEALOTHER;
+}
+
+void IN_GenCMD11( void )
+{
+	cl.gcmdSendValue = qtrue;
+	cl.gcmdValue = GENCMD_FORCE_FORCEPOWEROTHER;
+}
+
+void IN_GenCMD12( void )
+{
+	cl.gcmdSendValue = qtrue;
+	cl.gcmdValue = GENCMD_FORCE_SEEING;
+}
+
+void IN_GenCMD13( void )
+{
+	cl.gcmdSendValue = qtrue;
+	cl.gcmdValue = GENCMD_USE_SEEKER;
+}
+
+void IN_GenCMD14( void )
+{
+	cl.gcmdSendValue = qtrue;
+	cl.gcmdValue = GENCMD_USE_FIELD;
+}
+
+void IN_GenCMD15( void )
+{
+	cl.gcmdSendValue = qtrue;
+	cl.gcmdValue = GENCMD_USE_BACTA;
+}
+
+void IN_GenCMD16( void )
+{
+	cl.gcmdSendValue = qtrue;
+	cl.gcmdValue = GENCMD_USE_ELECTROBINOCULARS;
+}
+
+void IN_GenCMD17( void )
+{
+	cl.gcmdSendValue = qtrue;
+	cl.gcmdValue = GENCMD_ZOOM;
+}
+
+void IN_GenCMD18( void )
+{
+	cl.gcmdSendValue = qtrue;
+	cl.gcmdValue = GENCMD_USE_SENTRY;
+}
+
+void IN_GenCMD19( void )
+{
+#ifdef _XBOX
+	if (cl.snap.ps.weapon != WP_SABER)
+	{
+		Cbuf_ExecuteText(EXEC_APPEND, "weapon 1");
+		return;
+	}
+#endif
+
+	if (Cvar_VariableIntegerValue("d_saberStanceDebug"))
+	{
+		Com_Printf("SABERSTANCEDEBUG: Gencmd on client set successfully.\n");
+	}
+	cl.gcmdSendValue = qtrue;
+	cl.gcmdValue = GENCMD_SABERATTACKCYCLE;
+}
+
+void IN_GenCMD20( void )
+{
+	cl.gcmdSendValue = qtrue;
+	cl.gcmdValue = GENCMD_FORCE_THROW;
+}
+
+void IN_GenCMD21( void )
+{
+	cl.gcmdSendValue = qtrue;
+	cl.gcmdValue = GENCMD_USE_JETPACK;
+}
+
+void IN_GenCMD22( void )
+{
+	cl.gcmdSendValue = qtrue;
+	cl.gcmdValue = GENCMD_USE_BACTABIG;
+}
+
+void IN_GenCMD23( void )
+{
+	cl.gcmdSendValue = qtrue;
+	cl.gcmdValue = GENCMD_USE_HEALTHDISP;
+}
+
+void IN_GenCMD24( void )
+{
+	cl.gcmdSendValue = qtrue;
+	cl.gcmdValue = GENCMD_USE_AMMODISP;
+}
+
+void IN_GenCMD25( void )
+{
+	cl.gcmdSendValue = qtrue;
+	cl.gcmdValue = GENCMD_USE_EWEB;
+}
+
+void IN_GenCMD26( void )
+{
+	cl.gcmdSendValue = qtrue;
+	cl.gcmdValue = GENCMD_USE_CLOAK;
+}
+
+void IN_GenCMD27( void )
+{
+	cl.gcmdSendValue = qtrue;
+	cl.gcmdValue = GENCMD_TAUNT;
+}
+
+void IN_GenCMD28( void )
+{
+	cl.gcmdSendValue = qtrue;
+	cl.gcmdValue = GENCMD_BOW;
+}
+
+void IN_GenCMD29( void )
+{
+	cl.gcmdSendValue = qtrue;
+	cl.gcmdValue = GENCMD_MEDITATE;
+}
+
+void IN_GenCMD30( void )
+{
+	cl.gcmdSendValue = qtrue;
+	cl.gcmdValue = GENCMD_FLOURISH;
+}
+
+void IN_GenCMD31( void )
+{
+	cl.gcmdSendValue = qtrue;
+	cl.gcmdValue = GENCMD_GLOAT;
+}
+
+
+//toggle automap view mode
+static bool g_clAutoMapMode = false;
+void IN_AutoMapButton(void)
+{
+	g_clAutoMapMode = !g_clAutoMapMode;
+}
+
+//toggle between automap, radar, nothing
+extern cvar_t *r_autoMap;
+void IN_AutoMapToggle(void)
+{
+
+	if (Cvar_VariableIntegerValue("cg_drawRadar"))
+	{
+		Cvar_Set("cg_drawRadar", "0");
+	}
+	else
+	{
+		Cvar_Set("cg_drawRadar", "1");
+	}
+	/*
+	if (r_autoMap && r_autoMap->integer)
+	{ //automap off, radar on
+		Cvar_Set("r_autoMap", "0");
+		Cvar_Set("cg_drawRadar", "1");
+	}
+	else if (Cvar_VariableIntegerValue("cg_drawRadar"))
+	{ //radar off, automap should be off too
+		Cvar_Set("cg_drawRadar", "0");
+	}
+	else
+	{ //turn automap on
+		Cvar_Set("r_autoMap", "1");
+	}
+	*/
+}
+
+void IN_VoiceChatButton(void)
+{
+	if (!uivm)
+	{ //ui not loaded so this command is useless
+		return;
+	}
+	VM_Call( uivm, UI_SET_ACTIVE_MENU, UIMENU_VOICECHAT );
+}
+
+void IN_KeyDown( kbutton_t *b ) {
+	int		k;
+	char	*c;
+	
+	c = Cmd_Argv(1);
+	if ( c[0] ) {
+		k = atoi(c);
+	} else {
+		k = -1;		// typed manually at the console for continuous down
+	}
+
+	if ( k == b->down[0] || k == b->down[1] ) {
+		return;		// repeating key
+	}
+	
+	if ( !b->down[0] ) {
+		b->down[0] = k;
+	} else if ( !b->down[1] ) {
+		b->down[1] = k;
+	} else {
+		Com_Printf ("Three keys down for a button!\n");
+		return;
+	}
+	
+	if ( b->active ) {
+		return;		// still down
+	}
+
+	// save timestamp for partial frame summing
+	c = Cmd_Argv(2);
+	b->downtime = atoi(c);
+
+	b->active = qtrue;
+	b->wasPressed = qtrue;
+}
+
+void IN_KeyUp( kbutton_t *b ) {
+	int		k;
+	char	*c;
+	unsigned	uptime;
+
+	c = Cmd_Argv(1);
+	if ( c[0] ) {
+		k = atoi(c);
+	} else {
+		// typed manually at the console, assume for unsticking, so clear all
+		b->down[0] = b->down[1] = 0;
+		b->active = qfalse;
+		return;
+	}
+
+	if ( b->down[0] == k ) {
+		b->down[0] = 0;
+	} else if ( b->down[1] == k ) {
+		b->down[1] = 0;
+	} else {
+		return;		// key up without coresponding down (menu pass through)
+	}
+	if ( b->down[0] || b->down[1] ) {
+		return;		// some other key is still holding it down
+	}
+
+	b->active = qfalse;
+
+	// save timestamp for partial frame summing
+	c = Cmd_Argv(2);
+	uptime = atoi(c);
+	if ( uptime ) {
+		b->msec += uptime - b->downtime;
+	} else {
+		b->msec += frame_msec / 2;
+	}
+
+	b->active = qfalse;
+}
+
+
+
+/*
+===============
+CL_KeyState
+
+Returns the fraction of the frame that the key was down
+===============
+*/
+float CL_KeyState( kbutton_t *key ) {
+	float		val;
+	int			msec;
+
+	msec = key->msec;
+	key->msec = 0;
+
+	if ( key->active ) {
+		// still down
+		if ( !key->downtime ) {
+			msec = com_frameTime;
+		} else {
+			msec += com_frameTime - key->downtime;
+		}
+		key->downtime = com_frameTime;
+	}
+
+#if 0
+	if (msec) {
+		Com_Printf ("%i ", msec);
+	}
+#endif
+
+	val = (float)msec / frame_msec;
+	if ( val < 0 ) {
+		val = 0;
+	}
+	if ( val > 1 ) {
+		val = 1;
+	}
+
+	return val;
+}
+
+#define		AUTOMAP_KEY_FORWARD			1
+#define		AUTOMAP_KEY_BACK			2
+#define		AUTOMAP_KEY_YAWLEFT			3
+#define		AUTOMAP_KEY_YAWRIGHT		4
+#define		AUTOMAP_KEY_PITCHUP			5
+#define		AUTOMAP_KEY_PITCHDOWN		6
+#define		AUTOMAP_KEY_DEFAULTVIEW		7
+static autoMapInput_t			g_clAutoMapInput;
+//intercept certain keys during automap mode
+static void CL_AutoMapKey(int autoMapKey, qboolean up)
+{
+	autoMapInput_t *data = (autoMapInput_t *)cl.mSharedMemory;
+
+	switch (autoMapKey)
+	{
+	case AUTOMAP_KEY_FORWARD:
+        if (up)
+		{
+			g_clAutoMapInput.up = 0.0f;
+		}
+		else
+		{
+			g_clAutoMapInput.up = 16.0f;
+		}
+		break;
+	case AUTOMAP_KEY_BACK:
+        if (up)
+		{
+			g_clAutoMapInput.down = 0.0f;
+		}
+		else
+		{
+			g_clAutoMapInput.down = 16.0f;
+		}
+		break;
+	case AUTOMAP_KEY_YAWLEFT:
+		if (up)
+		{
+			g_clAutoMapInput.yaw = 0.0f;
+		}
+		else
+		{
+			g_clAutoMapInput.yaw = -4.0f;
+		}
+		break;
+	case AUTOMAP_KEY_YAWRIGHT:
+		if (up)
+		{
+			g_clAutoMapInput.yaw = 0.0f;
+		}
+		else
+		{
+			g_clAutoMapInput.yaw = 4.0f;
+		}
+		break;
+	case AUTOMAP_KEY_PITCHUP:
+		if (up)
+		{
+			g_clAutoMapInput.pitch = 0.0f;
+		}
+		else
+		{
+			g_clAutoMapInput.pitch = -4.0f;
+		}
+		break;
+	case AUTOMAP_KEY_PITCHDOWN:
+		if (up)
+		{
+			g_clAutoMapInput.pitch = 0.0f;
+		}
+		else
+		{
+			g_clAutoMapInput.pitch = 4.0f;
+		}
+		break;
+	case AUTOMAP_KEY_DEFAULTVIEW:
+		memset(&g_clAutoMapInput, 0, sizeof(autoMapInput_t));
+		g_clAutoMapInput.goToDefaults = qtrue;
+		break;
+	default:
+		break;
+	}
+
+	memcpy(data, &g_clAutoMapInput, sizeof(autoMapInput_t));
+
+	if (cgvm)
+	{
+		VM_Call(cgvm, CG_AUTOMAP_INPUT, 0);
+	}
+
+	g_clAutoMapInput.goToDefaults = qfalse;
+}
+
+
+void IN_UpDown(void)
+{
+	if (g_clAutoMapMode)
+	{
+		CL_AutoMapKey(AUTOMAP_KEY_PITCHUP, qfalse);
+	}
+	else
+	{
+		IN_KeyDown(&in_up);
+	}
+}
+void IN_UpUp(void) 
+{
+	if (g_clAutoMapMode)
+	{
+		CL_AutoMapKey(AUTOMAP_KEY_PITCHUP, qtrue);
+	}
+	else
+	{
+		IN_KeyUp(&in_up);
+	}
+}
+void IN_DownDown(void)
+{
+	if (g_clAutoMapMode)
+	{
+		CL_AutoMapKey(AUTOMAP_KEY_PITCHDOWN, qfalse);
+	}
+	else
+	{
+		IN_KeyDown(&in_down);
+	}
+}
+void IN_DownUp(void)
+{
+	if (g_clAutoMapMode)
+	{
+		CL_AutoMapKey(AUTOMAP_KEY_PITCHDOWN, qtrue);
+	}
+	else
+	{
+		IN_KeyUp(&in_down);
+	}
+}
+void IN_LeftDown(void) {IN_KeyDown(&in_left);}
+void IN_LeftUp(void) {IN_KeyUp(&in_left);}
+void IN_RightDown(void) {IN_KeyDown(&in_right);}
+void IN_RightUp(void) {IN_KeyUp(&in_right);}
+void IN_ForwardDown(void)
+{
+	if (g_clAutoMapMode)
+	{
+		CL_AutoMapKey(AUTOMAP_KEY_FORWARD, qfalse);
+	}
+	else
+	{
+		IN_KeyDown(&in_forward);
+	}
+}
+void IN_ForwardUp(void)
+{
+	if (g_clAutoMapMode)
+	{
+		CL_AutoMapKey(AUTOMAP_KEY_FORWARD, qtrue);
+	}
+	else
+	{
+		IN_KeyUp(&in_forward);
+	}
+}
+void IN_BackDown(void)
+{
+	if (g_clAutoMapMode)
+	{
+		CL_AutoMapKey(AUTOMAP_KEY_BACK, qfalse);
+	}
+	else
+	{
+		IN_KeyDown(&in_back);
+	}
+}
+void IN_BackUp(void)
+{
+	if (g_clAutoMapMode)
+	{
+		CL_AutoMapKey(AUTOMAP_KEY_BACK, qtrue);
+	}
+	else
+	{
+		IN_KeyUp(&in_back);
+	}
+}
+void IN_LookupDown(void) {IN_KeyDown(&in_lookup);}
+void IN_LookupUp(void) {IN_KeyUp(&in_lookup);}
+void IN_LookdownDown(void) {IN_KeyDown(&in_lookdown);}
+void IN_LookdownUp(void) {IN_KeyUp(&in_lookdown);}
+void IN_MoveleftDown(void)
+{
+	if (g_clAutoMapMode)
+	{
+		CL_AutoMapKey(AUTOMAP_KEY_YAWLEFT, qfalse);
+	}
+	else
+	{
+		IN_KeyDown(&in_moveleft);
+	}
+}
+void IN_MoveleftUp(void)
+{
+	if (g_clAutoMapMode)
+	{
+		CL_AutoMapKey(AUTOMAP_KEY_YAWLEFT, qtrue);
+	}
+	else
+	{
+		IN_KeyUp(&in_moveleft);
+	}
+}
+void IN_MoverightDown(void)
+{
+	if (g_clAutoMapMode)
+	{
+		CL_AutoMapKey(AUTOMAP_KEY_YAWRIGHT, qfalse);
+	}
+	else
+	{
+		IN_KeyDown(&in_moveright);
+	}
+}
+void IN_MoverightUp(void)
+{
+	if (g_clAutoMapMode)
+	{
+		CL_AutoMapKey(AUTOMAP_KEY_YAWRIGHT, qtrue);
+	}
+	else
+	{
+		IN_KeyUp(&in_moveright);
+	}
+}
+
+#ifdef _XBOX
+// BTO - State for auto-level usage. This REALLY ought to be in cl[sc ].
+// Honestly, I don't want to figure out which one, especially anticipating
+// split-screen. All I want for Christmas is to not do split-screen.
+static unsigned long sLastFireTime = 0;
+#endif
+
+void IN_SpeedDown(void) {IN_KeyDown(&in_speed);}
+void IN_SpeedUp(void) {IN_KeyUp(&in_speed);}
+void IN_StrafeDown(void) {IN_KeyDown(&in_strafe);}
+void IN_StrafeUp(void) {IN_KeyUp(&in_strafe);}
+
+void IN_Button0Down(void) {IN_KeyDown(&in_buttons[0]);}
+void IN_Button0Up(void)
+{
+	IN_KeyUp(&in_buttons[0]);
+#ifdef _XBOX	// Auto-level. Thought this was nasty, but now I sort of like it.
+	sLastFireTime = Sys_Milliseconds();
+#endif
+}
+void IN_Button1Down(void) {IN_KeyDown(&in_buttons[1]);}
+void IN_Button1Up(void) {IN_KeyUp(&in_buttons[1]);}
+void IN_Button2Down(void) {IN_KeyDown(&in_buttons[2]);}
+void IN_Button2Up(void) {IN_KeyUp(&in_buttons[2]);}
+void IN_Button3Down(void) {IN_KeyDown(&in_buttons[3]);}
+void IN_Button3Up(void) {IN_KeyUp(&in_buttons[3]);}
+void IN_Button4Down(void) {IN_KeyDown(&in_buttons[4]);}
+void IN_Button4Up(void) {IN_KeyUp(&in_buttons[4]);}
+void IN_Button5Down(void) //use key
+{
+	if (g_clAutoMapMode)
+	{
+		CL_AutoMapKey(AUTOMAP_KEY_DEFAULTVIEW, qfalse);
+	}
+	else
+	{
+		IN_KeyDown(&in_buttons[5]);
+	}
+}
+void IN_Button5Up(void) {IN_KeyUp(&in_buttons[5]);}
+void IN_Button6Down(void) {IN_KeyDown(&in_buttons[6]);}
+void IN_Button6Up(void) {IN_KeyUp(&in_buttons[6]);}
+void IN_Button7Down(void) {IN_KeyDown(&in_buttons[7]);}
+void IN_Button7Up(void)
+{
+	IN_KeyUp(&in_buttons[7]);
+#ifdef _XBOX	// Auto-level. Thought this was nasty, but now I sort of like it.
+	sLastFireTime = Sys_Milliseconds();
+#endif
+}
+void IN_Button8Down(void) {IN_KeyDown(&in_buttons[8]);}
+void IN_Button8Up(void) {IN_KeyUp(&in_buttons[8]);}
+void IN_Button9Down(void) {IN_KeyDown(&in_buttons[9]);}
+void IN_Button9Up(void) {IN_KeyUp(&in_buttons[9]);}
+void IN_Button10Down(void) {IN_KeyDown(&in_buttons[10]);}
+void IN_Button10Up(void) {IN_KeyUp(&in_buttons[10]);}
+void IN_Button11Down(void) {IN_KeyDown(&in_buttons[11]);}
+void IN_Button11Up(void) {IN_KeyUp(&in_buttons[11]);}
+void IN_Button12Down(void) {IN_KeyDown(&in_buttons[12]);}
+void IN_Button12Up(void) {IN_KeyUp(&in_buttons[12]);}
+void IN_Button13Down(void) {IN_KeyDown(&in_buttons[13]);}
+void IN_Button13Up(void) {IN_KeyUp(&in_buttons[13]);}
+void IN_Button14Down(void) {IN_KeyDown(&in_buttons[14]);}
+void IN_Button14Up(void) {IN_KeyUp(&in_buttons[14]);}
+void IN_Button15Down(void) {IN_KeyDown(&in_buttons[15]);}
+void IN_Button15Up(void) {IN_KeyUp(&in_buttons[15]);}
+
+void IN_ButtonDown (void) {
+	IN_KeyDown(&in_buttons[1]);}
+void IN_ButtonUp (void) {
+	IN_KeyUp(&in_buttons[1]);}
+
+void IN_CenterView (void) {
+	cl.viewangles[PITCH] = -SHORT2ANGLE(cl.snap.ps.delta_angles[PITCH]);
+}
+
+#ifdef _XBOX
+void IN_VoiceToggleDown(void) { g_Voice.SetChannel( CHAN_ALL ); }
+void IN_VoiceToggleUp(void) { g_Voice.SetChannel( CHAN_TEAM ); }
+#endif
+
+
+//==========================================================================
+
+cvar_t	*cl_upspeed;
+cvar_t	*cl_forwardspeed;
+cvar_t	*cl_sidespeed;
+
+cvar_t	*cl_yawspeed;
+cvar_t	*cl_pitchspeed;
+
+cvar_t	*cl_run;
+
+cvar_t	*cl_anglespeedkey;
+
+
+/*
+================
+CL_AdjustAngles
+
+Moves the local angle positions
+================
+*/
+void CL_AdjustAngles( void ) {
+	float	speed;
+	
+	if ( in_speed.active ) {
+		speed = 0.001 * cls.frametime * cl_anglespeedkey->value;
+	} else {
+		speed = 0.001 * cls.frametime;
+	}
+
+	if ( !in_strafe.active ) {
+		if ( cl_mYawOverride )
+		{
+			if ( cl_mSensitivityOverride )
+			{
+				cl.viewangles[YAW] -= cl_mYawOverride*cl_mSensitivityOverride*speed*cl_yawspeed->value*CL_KeyState (&in_right);
+				cl.viewangles[YAW] += cl_mYawOverride*cl_mSensitivityOverride*speed*cl_yawspeed->value*CL_KeyState (&in_left);
+			}
+			else
+			{
+				cl.viewangles[YAW] -= cl_mYawOverride*OVERRIDE_MOUSE_SENSITIVITY*speed*cl_yawspeed->value*CL_KeyState (&in_right);
+				cl.viewangles[YAW] += cl_mYawOverride*OVERRIDE_MOUSE_SENSITIVITY*speed*cl_yawspeed->value*CL_KeyState (&in_left);
+			}
+		}
+		else
+		{
+			cl.viewangles[YAW] -= speed*cl_yawspeed->value*CL_KeyState (&in_right);
+			cl.viewangles[YAW] += speed*cl_yawspeed->value*CL_KeyState (&in_left);
+		}
+	}
+
+	if ( cl_mPitchOverride )
+	{
+		if ( cl_mSensitivityOverride )
+		{
+			cl.viewangles[PITCH] -= cl_mPitchOverride*cl_mSensitivityOverride*speed*cl_pitchspeed->value * CL_KeyState (&in_lookup);
+			cl.viewangles[PITCH] += cl_mPitchOverride*cl_mSensitivityOverride*speed*cl_pitchspeed->value * CL_KeyState (&in_lookdown);
+		}
+		else
+		{
+			cl.viewangles[PITCH] -= cl_mPitchOverride*OVERRIDE_MOUSE_SENSITIVITY*speed*cl_pitchspeed->value * CL_KeyState (&in_lookup);
+			cl.viewangles[PITCH] += cl_mPitchOverride*OVERRIDE_MOUSE_SENSITIVITY*speed*cl_pitchspeed->value * CL_KeyState (&in_lookdown);
+		}
+	}
+	else
+	{
+		cl.viewangles[PITCH] -= speed*cl_pitchspeed->value * CL_KeyState (&in_lookup);
+		cl.viewangles[PITCH] += speed*cl_pitchspeed->value * CL_KeyState (&in_lookdown);
+	}
+}
+
+/*
+================
+CL_KeyMove
+
+Sets the usercmd_t based on key states
+================
+*/
+void CL_KeyMove( usercmd_t *cmd ) {
+	int		movespeed;
+	int		forward, side, up;
+
+	//
+	// adjust for speed key / running
+	// the walking flag is to keep animations consistant
+	// even during acceleration and develeration
+	//
+	if ( in_speed.active ^ cl_run->integer ) {
+		movespeed = 127;
+		cmd->buttons &= ~BUTTON_WALKING;
+	} else {
+		cmd->buttons |= BUTTON_WALKING;
+		movespeed = 46;
+	}
+
+	forward = 0;
+	side = 0;
+	up = 0;
+	if ( in_strafe.active ) {
+		side += movespeed * CL_KeyState (&in_right);
+		side -= movespeed * CL_KeyState (&in_left);
+	}
+
+	side += movespeed * CL_KeyState (&in_moveright);
+	side -= movespeed * CL_KeyState (&in_moveleft);
+
+
+	up += movespeed * CL_KeyState (&in_up);
+	up -= movespeed * CL_KeyState (&in_down);
+
+	forward += movespeed * CL_KeyState (&in_forward);
+	forward -= movespeed * CL_KeyState (&in_back);
+
+	cmd->forwardmove = ClampChar( forward );
+	cmd->rightmove = ClampChar( side );
+	cmd->upmove = ClampChar( up );
+}
+
+/*
+=================
+CL_MouseEvent
+=================
+*/
+void CL_MouseEvent( int dx, int dy, int time ) {
+	if (g_clAutoMapMode && cgvm)
+	{ //automap input
+		autoMapInput_t *data = (autoMapInput_t *)cl.mSharedMemory;
+
+		g_clAutoMapInput.yaw = dx;
+		g_clAutoMapInput.pitch = dy;
+		memcpy(data, &g_clAutoMapInput, sizeof(autoMapInput_t));
+		VM_Call(cgvm, CG_AUTOMAP_INPUT, 1);
+
+		g_clAutoMapInput.yaw = 0.0f;
+		g_clAutoMapInput.pitch = 0.0f;
+	}
+	else if ( cls.keyCatchers & KEYCATCH_UI ) {
+		VM_Call( uivm, UI_MOUSE_EVENT, dx, dy );
+	} else if (cls.keyCatchers & KEYCATCH_CGAME) {
+		VM_Call (cgvm, CG_MOUSE_EVENT, dx, dy);
+	} else {
+		cl.mouseDx[cl.mouseIndex] += dx;
+		cl.mouseDy[cl.mouseIndex] += dy;
+	}
+}
+
+/*
+=================
+CL_JoystickEvent
+
+Joystick values stay set until changed
+=================
+*/
+void CL_JoystickEvent( int axis, int value, int time ) {
+	if ( axis < 0 || axis >= MAX_JOYSTICK_AXIS ) {
+		Com_Error( ERR_DROP, "CL_JoystickEvent: bad axis %i", axis );
+	}
+	cl.joystickAxis[axis] = value;
+}
+
+/*
+=================
+CL_JoystickMove
+=================
+*/
+extern cvar_t *in_joystick;
+void CL_JoystickMove( usercmd_t *cmd ) {
+#ifndef _XBOX	// We always have a joystick, won't bother adding another cvar
+	if ( !in_joystick->integer )
+	{
+		return;
+	}
+#endif
+
+	int		movespeed;
+	float	anglespeed;
+
+	if ( in_speed.active ^ cl_run->integer ) {
+		movespeed = 2;
+	} else {
+		movespeed = 1;
+		cmd->buttons |= BUTTON_WALKING;
+	}
+
+	if ( in_speed.active ) {
+		anglespeed = 0.001 * cls.frametime * cl_anglespeedkey->value;
+	} else {
+		anglespeed = 0.001 * cls.frametime;
+	}
+
+#ifndef _XBOX
+	if ( !in_strafe.active ) {
+		if ( cl_mYawOverride )
+		{
+			if ( cl_mSensitivityOverride )
+			{
+				cl.viewangles[YAW] += cl_mYawOverride * cl_mSensitivityOverride * cl.joystickAxis[AXIS_SIDE]/2.0f;
+			}
+			else
+			{
+				cl.viewangles[YAW] += cl_mYawOverride * OVERRIDE_MOUSE_SENSITIVITY * cl.joystickAxis[AXIS_SIDE]/2.0f;
+			}
+		}
+		else
+		{
+			cl.viewangles[YAW] += anglespeed * (cl_yawspeed->value / 100.0f) * cl.joystickAxis[AXIS_SIDE];
+		}
+	} else
+#endif
+	{
+		cmd->rightmove = ClampChar( cmd->rightmove + cl.joystickAxis[AXIS_SIDE] );
+	}
+
+#ifndef _XBOX
+	if ( in_mlooking || cl_freelook->integer ) {
+		if ( cl_mPitchOverride )
+		{
+			if ( cl_mSensitivityOverride )
+			{
+				cl.viewangles[PITCH] += cl_mPitchOverride * cl_mSensitivityOverride * cl.joystickAxis[AXIS_FORWARD]/2.0f;
+			}
+			else
+			{
+				cl.viewangles[PITCH] += cl_mPitchOverride * OVERRIDE_MOUSE_SENSITIVITY * cl.joystickAxis[AXIS_FORWARD]/2.0f;
+			}
+		}
+		else
+		{
+			cl.viewangles[PITCH] += anglespeed * (cl_pitchspeed->value / 100.0f) * cl.joystickAxis[AXIS_FORWARD];
+		}
+	} else
+#endif
+	{
+		cmd->forwardmove = ClampChar( cmd->forwardmove + cl.joystickAxis[AXIS_FORWARD] );
+	}
+
+	cmd->upmove = ClampChar( cmd->upmove + cl.joystickAxis[AXIS_UP] );
+}
+
+/*
+=================
+CL_MouseMove
+=================
+*/
+#ifdef _XBOX
+void CL_MouseClamp(int *x, int *y)
+{
+	float ax = Q_fabs(*x);
+	float ay = Q_fabs(*y);
+
+	ax = (ax-10)*(3.0f/45.0f) * (ax-10) * (Q_fabs(*x) > 10);
+	ay = (ay-10)*(3.0f/45.0f) * (ay-10) * (Q_fabs(*y) > 10);
+	if (*x < 0)
+		*x = -ax;
+	else
+		*x = ax;
+	if (*y < 0)
+		*y = -ay;
+	else
+		*y = ay;
+}
+#endif
+
+void CL_MouseMove( usercmd_t *cmd ) {
+	float	mx, my;
+	float	accelSensitivity;
+	float	rate;
+	const float	speed = static_cast<float>(frame_msec);
+	const float pitch = cl_bUseFighterPitch?m_pitchVeh->value:m_pitch->value;
+
+#ifdef _XBOX
+	const float mouseSpeedX = 0.06f;
+	const float mouseSpeedY = 0.05f;
+
+	// allow mouse smoothing
+	if ( m_filter->integer ) {
+		mx = ( cl.mouseDx[0] + cl.mouseDx[1] ) * 0.5f * frame_msec * mouseSpeedX;
+		my = ( cl.mouseDy[0] + cl.mouseDy[1] ) * 0.5f * frame_msec * mouseSpeedY;
+	} else {
+		int ax = cl.mouseDx[cl.mouseIndex];
+		int ay = cl.mouseDy[cl.mouseIndex];
+		CL_MouseClamp(&ax, &ay);
+		
+		mx = ax * speed * mouseSpeedX;
+		my = ay * speed * mouseSpeedY;		
+	}
+
+	extern int cg_crossHairStatus;
+	const float m_hoverSensitivity = 0.4f;
+	if (cg_crossHairStatus)
+	{
+		mx *= m_hoverSensitivity;
+		my *= m_hoverSensitivity;
+	}
+#else
+	// allow mouse smoothing
+	if ( m_filter->integer ) {
+		mx = ( cl.mouseDx[0] + cl.mouseDx[1] ) * 0.5;
+		my = ( cl.mouseDy[0] + cl.mouseDy[1] ) * 0.5;
+	} else {
+		mx = cl.mouseDx[cl.mouseIndex];
+		my = cl.mouseDy[cl.mouseIndex];
+	}
+#endif
+
+	cl.mouseIndex ^= 1;
+	cl.mouseDx[cl.mouseIndex] = 0;
+	cl.mouseDy[cl.mouseIndex] = 0;
+
+	rate = SQRTFAST( mx * mx + my * my ) / speed;
+	if ( cl_mYawOverride || cl_mPitchOverride )
+	{//FIXME: different people have different speed mouses,
+		if ( cl_mSensitivityOverride )
+		{
+			//this will fuck things up for them, need to clamp 
+			//max input?
+			accelSensitivity = cl_mSensitivityOverride;
+		}
+		else
+		{
+			accelSensitivity = cl_sensitivity->value + rate * cl_mouseAccel->value;
+			// scale by FOV
+			accelSensitivity *= cl.cgameSensitivity;
+		}
+	}
+	else
+	{
+		accelSensitivity = cl_sensitivity->value + rate * cl_mouseAccel->value;
+		// scale by FOV
+		accelSensitivity *= cl.cgameSensitivity;
+	}
+
+	if ( rate && cl_showMouseRate->integer ) {
+		Com_Printf( "%f : %f\n", rate, accelSensitivity );
+	}
+
+	mx *= accelSensitivity;
+	my *= accelSensitivity;
+
+	if (!mx && !my) {
+#ifdef _XBOX
+		// If there was a movement but no change in angles then start auto-leveling the camera
+		float autolevelSpeed = 0.03f;
+
+		if (!cg_crossHairStatus &&								// Not looking at an enemy
+			cl.joystickAxis[AXIS_FORWARD] &&					// Moving forward/backward
+			cl.snap.ps.groundEntityNum != ENTITYNUM_NONE &&		// Not in the air
+			Cvar_VariableIntegerValue("cl_autolevel") &&		// Autolevel is turned on
+			!(in_buttons[0].active || in_buttons[7].active) &&	// Not firing a weapon
+			sLastFireTime < Sys_Milliseconds() - 1000)			// Haven't fired recently
+		{
+			float normAngle = -SHORT2ANGLE(cl.snap.ps.delta_angles[PITCH]);
+			// The adjustment to normAngle below is meant to add or remove some multiple
+			// of 360, so that normAngle is within 180 of viewangles[PITCH]. It should
+			// be correct.
+			int diff = (int)(cl.viewangles[PITCH] - normAngle);
+			if (diff > 180)
+				normAngle += 360.0f * ((diff+180) / 360);
+			else if (diff < -180)
+				normAngle -= 360.0f * ((-diff+180) / 360);
+
+			if (Cvar_VariableIntegerValue("cg_thirdperson") == 1)
+			{
+				normAngle += 10;
+				autolevelSpeed *= 1.5f;
+			}
+			if (cl.viewangles[PITCH] > normAngle)
+			{
+				cl.viewangles[PITCH] -= autolevelSpeed * speed;
+				if (cl.viewangles[PITCH] < normAngle) cl.viewangles[PITCH] = normAngle;
+			}
+			else if (cl.viewangles[PITCH] < normAngle)
+			{
+				cl.viewangles[PITCH] += autolevelSpeed * speed;
+				if (cl.viewangles[PITCH] > normAngle) cl.viewangles[PITCH] = normAngle;
+			}
+		}
+#endif
+		return;
+	}
+
+	// add mouse X/Y movement to cmd
+	if ( in_strafe.active ) {
+		cmd->rightmove = ClampChar( cmd->rightmove + m_side->value * mx );
+	} else {
+		if ( cl_mYawOverride )
+		{
+			cl.viewangles[YAW] -= cl_mYawOverride * mx;
+		}
+		else
+		{
+			cl.viewangles[YAW] -= m_yaw->value * mx;
+		}
+	}
+
+	if ( (in_mlooking || cl_freelook->integer) && !in_strafe.active ) {
+		// VVFIXME - This is supposed to be a CVAR
+#ifdef _XBOX
+		const float cl_pitchSensitivity = 0.5f;
+#else
+		const float cl_pitchSensitivity = 1.0f;
+#endif
+		if ( cl_mPitchOverride )
+		{
+			if ( pitch > 0 )
+			{
+				cl.viewangles[PITCH] += cl_mPitchOverride * my * cl_pitchSensitivity;
+			}
+			else
+			{
+				cl.viewangles[PITCH] -= cl_mPitchOverride * my * cl_pitchSensitivity;
+			}
+		}
+		else
+		{
+			cl.viewangles[PITCH] += pitch * my * cl_pitchSensitivity;
+		}
+	} else {
+		cmd->forwardmove = ClampChar( cmd->forwardmove - m_forward->value * my );
+	}
+}
+
+qboolean CL_NoUseableForce(void)
+{
+	if (!cgvm)
+	{ //ahh, no cgame loaded
+		return qfalse;
+	}
+
+	return (qboolean)VM_Call(cgvm, CG_GET_USEABLE_FORCE);
+}
+
+/*
+==============
+CL_CmdButtons
+==============
+*/
+void CL_CmdButtons( usercmd_t *cmd ) {
+	int		i;
+
+	//
+	// figure button bits
+	// send a button bit even if the key was pressed and released in
+	// less than a frame
+	//	
+	for (i = 0 ; i < 15 ; i++) {
+		if ( in_buttons[i].active || in_buttons[i].wasPressed ) {
+			cmd->buttons |= 1 << i;
+		}
+		in_buttons[i].wasPressed = qfalse;
+	}
+
+	if (cmd->buttons & BUTTON_FORCEPOWER)
+	{ //check for transferring a use force to a use inventory...
+		if ((cmd->buttons & BUTTON_USE) || CL_NoUseableForce())
+		{ //it's pushed, remap it!
+			cmd->buttons &= ~BUTTON_FORCEPOWER;
+			cmd->buttons |= BUTTON_USE_HOLDABLE;
+		}
+	}
+
+	if ( cls.keyCatchers ) {
+		cmd->buttons |= BUTTON_TALK;
+	}
+
+	// allow the game to know if any key at all is
+	// currently pressed, even if it isn't bound to anything
+	if ( kg.anykeydown && !cls.keyCatchers ) {
+		cmd->buttons |= BUTTON_ANY;
+	}
+}
+
+
+/*
+==============
+CL_FinishMove
+==============
+*/
+vec3_t cl_sendAngles={0};
+vec3_t cl_lastViewAngles={0};
+void CL_FinishMove( usercmd_t *cmd ) {
+	int		i;
+
+	// copy the state that the cgame is currently sending
+	cmd->weapon = cl.cgameUserCmdValue;
+	cmd->forcesel = cl.cgameForceSelection;
+	cmd->invensel = cl.cgameInvenSelection;
+
+	if (cl.gcmdSendValue)
+	{
+		cmd->generic_cmd = cl.gcmdValue;
+		//cl.gcmdSendValue = qfalse;
+		cl.gcmdSentValue = qtrue;
+	}
+	else
+	{
+		cmd->generic_cmd = 0;
+	}
+
+	// send the current server time so the amount of movement
+	// can be determined without allowing cheating
+	cmd->serverTime = cl.serverTime;
+	
+	if (cl.cgameViewAngleForceTime > cl.serverTime)
+	{
+		cl.cgameViewAngleForce[YAW] -= SHORT2ANGLE(cl.snap.ps.delta_angles[YAW]);
+
+		cl.viewangles[YAW] = cl.cgameViewAngleForce[YAW];
+		cl.cgameViewAngleForceTime = 0;
+	}
+
+	if ( cl_crazyShipControls )
+	{
+		float pitchSubtract, pitchDelta, yawDelta;
+
+		yawDelta = AngleSubtract(cl.viewangles[YAW],cl_lastViewAngles[YAW]);
+		//yawDelta *= (4.0f*pVeh->m_fTimeModifier);
+		cl_sendAngles[ROLL] -= yawDelta;
+
+		float nRoll = fabs(cl_sendAngles[ROLL]);
+
+		pitchDelta = AngleSubtract(cl.viewangles[PITCH],cl_lastViewAngles[PITCH]);
+		//pitchDelta *= (2.0f*pVeh->m_fTimeModifier);
+		pitchSubtract = pitchDelta * (nRoll/90.0f);
+		cl_sendAngles[PITCH] += pitchDelta-pitchSubtract;
+
+		//yaw-roll calc should be different
+		if (nRoll > 90.0f)
+		{
+			nRoll -= 180.0f;
+		}
+		if (nRoll < 0.0f)
+		{
+			nRoll = -nRoll;
+		}
+		pitchSubtract = pitchDelta * (nRoll/90.0f);
+		if ( cl_sendAngles[ROLL] > 0.0f )
+		{
+			cl_sendAngles[YAW] += pitchSubtract;
+		}
+		else
+		{
+			cl_sendAngles[YAW] -= pitchSubtract;
+		}
+		
+		cl_sendAngles[PITCH] = AngleNormalize180( cl_sendAngles[PITCH] );
+		cl_sendAngles[YAW] = AngleNormalize360( cl_sendAngles[YAW] );
+		cl_sendAngles[ROLL] = AngleNormalize180( cl_sendAngles[ROLL] );
+
+		for (i=0 ; i<3 ; i++) {
+			cmd->angles[i] = ANGLE2SHORT(cl_sendAngles[i]);
+		}
+	}
+	else
+	{
+		for (i=0 ; i<3 ; i++) {
+			cmd->angles[i] = ANGLE2SHORT(cl.viewangles[i]);
+		}
+		//in case we switch to the cl_crazyShipControls
+		VectorCopy( cl.viewangles, cl_sendAngles );
+	}
+	//always needed in for the cl_crazyShipControls
+	VectorCopy( cl.viewangles, cl_lastViewAngles );
+}
+
+/*
+=================
+CL_CreateCmd
+=================
+*/
+usercmd_t CL_CreateCmd( void ) {
+	usercmd_t	cmd;
+	vec3_t		oldAngles;
+
+	VectorCopy( cl.viewangles, oldAngles );
+
+	// keyboard angle adjustment
+	CL_AdjustAngles ();
+	
+	Com_Memset( &cmd, 0, sizeof( cmd ) );
+
+	CL_CmdButtons( &cmd );
+
+	// get basic movement from keyboard
+	CL_KeyMove( &cmd );
+
+	// get basic movement from mouse
+	CL_MouseMove( &cmd );
+
+	// get basic movement from joystick
+	CL_JoystickMove( &cmd );
+
+	// check to make sure the angles haven't wrapped
+	if ( cl.viewangles[PITCH] - oldAngles[PITCH] > 90 ) {
+		cl.viewangles[PITCH] = oldAngles[PITCH] + 90;
+	} else if ( oldAngles[PITCH] - cl.viewangles[PITCH] > 90 ) {
+		cl.viewangles[PITCH] = oldAngles[PITCH] - 90;
+	} 
+
+	// store out the final values
+	CL_FinishMove( &cmd );
+
+	// draw debug graphs of turning for mouse testing
+	if ( cl_debugMove->integer ) {
+		if ( cl_debugMove->integer == 1 ) {
+			SCR_DebugGraph( abs(cl.viewangles[YAW] - oldAngles[YAW]), 0 );
+		}
+		if ( cl_debugMove->integer == 2 ) {
+			SCR_DebugGraph( abs(cl.viewangles[PITCH] - oldAngles[PITCH]), 0 );
+		}
+	}
+
+	return cmd;
+}
+
+
+/*
+=================
+CL_CreateNewCommands
+
+Create a new usercmd_t structure for this frame
+=================
+*/
+void CL_CreateNewCommands( void ) {
+	usercmd_t	*cmd;
+	int			cmdNum;
+
+	// no need to create usercmds until we have a gamestate
+	if ( cls.state < CA_PRIMED ) {
+		return;
+	}
+
+	frame_msec = com_frameTime - old_com_frameTime;
+
+	// if running less than 5fps, truncate the extra time to prevent
+	// unexpected moves after a hitch
+	if ( frame_msec > 200 ) {
+		frame_msec = 200;
+	}
+	old_com_frameTime = com_frameTime;
+
+
+	// generate a command for this frame
+	cl.cmdNumber++;
+	cmdNum = cl.cmdNumber & CMD_MASK;
+	cl.cmds[cmdNum] = CL_CreateCmd ();
+	cmd = &cl.cmds[cmdNum];
+}
+
+/*
+=================
+CL_ReadyToSendPacket
+
+Returns qfalse if we are over the maxpackets limit
+and should choke back the bandwidth a bit by not sending
+a packet this frame.  All the commands will still get
+delivered in the next packet, but saving a header and
+getting more delta compression will reduce total bandwidth.
+=================
+*/
+qboolean CL_ReadyToSendPacket( void ) {
+	int		oldPacketNum;
+	int		delta;
+
+	// don't send anything if playing back a demo
+#ifdef _XBOX	// No demos on Xbox
+	if ( cls.state == CA_CINEMATIC ) {
+#else
+	if ( clc.demoplaying || cls.state == CA_CINEMATIC ) {
+#endif
+		return qfalse;
+	}
+
+	// If we are downloading, we send no less than 50ms between packets
+#ifndef _XBOX	// No downloads on Xbox
+	if ( *clc.downloadTempName &&
+		cls.realtime - clc.lastPacketSentTime < 50 ) {
+		return qfalse;
+	}
+#endif
+
+	// if we don't have a valid gamestate yet, only send
+	// one packet a second
+	if ( cls.state != CA_ACTIVE && 
+		cls.state != CA_PRIMED && 
+#ifndef _XBOX	// No downloads on Xbox
+		!*clc.downloadTempName &&
+#endif
+		cls.realtime - clc.lastPacketSentTime < 1000 ) {
+		return qfalse;
+	}
+
+	// send every frame for loopbacks
+	if ( clc.netchan.remoteAddress.type == NA_LOOPBACK ) {
+		return qtrue;
+	}
+
+	// send every frame for LAN
+	if ( Sys_IsLANAddress( clc.netchan.remoteAddress ) ) {
+		return qtrue;
+	}
+
+	// check for exceeding cl_maxpackets
+	if ( cl_maxpackets->integer < 15 ) {
+		Cvar_Set( "cl_maxpackets", "15" );
+	} else if ( cl_maxpackets->integer > 100 ) {
+		Cvar_Set( "cl_maxpackets", "100" );
+	}
+	oldPacketNum = (clc.netchan.outgoingSequence - 1) & PACKET_MASK;
+	delta = cls.realtime -  cl.outPackets[ oldPacketNum ].p_realtime;
+	if ( delta < 1000 / cl_maxpackets->integer ) {
+		// the accumulated commands will go out in the next packet
+		return qfalse;
+	}
+
+	return qtrue;
+}
+
+/*
+===================
+CL_WritePacket
+
+Create and send the command packet to the server
+Including both the reliable commands and the usercmds
+
+During normal gameplay, a client packet will contain something like:
+
+4	sequence number
+2	qport
+4	serverid
+4	acknowledged sequence number
+4	clc.serverCommandSequence
+<optional reliable commands>
+1	clc_move or clc_moveNoDelta
+1	command count
+<count * usercmds>
+
+===================
+*/
+void CL_WritePacket( void ) {
+	msg_t		buf;
+	byte		data[MAX_MSGLEN];
+	int			i, j;
+	usercmd_t	*cmd, *oldcmd;
+	usercmd_t	nullcmd;
+	int			packetNum;
+	int			oldPacketNum;
+	int			count, key;
+
+	// don't send anything if playing back a demo
+#ifdef _XBOX	// No demos on Xbox
+	if ( cls.state == CA_CINEMATIC ) {
+#else
+	if ( clc.demoplaying || cls.state == CA_CINEMATIC ) {
+#endif
+		return;
+	}
+
+	Com_Memset( &nullcmd, 0, sizeof(nullcmd) );
+	oldcmd = &nullcmd;
+
+	MSG_Init( &buf, data, sizeof(data) );
+
+	MSG_Bitstream( &buf );
+	// write the current serverId so the server
+	// can tell if this is from the current gameState
+	MSG_WriteLong( &buf, cl.serverId );
+
+	// write the last message we received, which can
+	// be used for delta compression, and is also used
+	// to tell if we dropped a gamestate
+	MSG_WriteLong( &buf, clc.serverMessageSequence );
+
+	// write the last reliable message we received
+	MSG_WriteLong( &buf, clc.serverCommandSequence );
+
+	// write any unacknowledged clientCommands
+	for ( i = clc.reliableAcknowledge + 1 ; i <= clc.reliableSequence ; i++ ) {
+		MSG_WriteByte( &buf, clc_clientCommand );
+		MSG_WriteLong( &buf, i );
+		MSG_WriteString( &buf, clc.reliableCommands[ i & (MAX_RELIABLE_COMMANDS-1) ] );
+	}
+
+	// we want to send all the usercmds that were generated in the last
+	// few packet, so even if a couple packets are dropped in a row,
+	// all the cmds will make it to the server
+	if ( cl_packetdup->integer < 0 ) {
+		Cvar_Set( "cl_packetdup", "0" );
+	} else if ( cl_packetdup->integer > 5 ) {
+		Cvar_Set( "cl_packetdup", "5" );
+	}
+	oldPacketNum = (clc.netchan.outgoingSequence - 1 - cl_packetdup->integer) & PACKET_MASK;
+	count = cl.cmdNumber - cl.outPackets[ oldPacketNum ].p_cmdNumber;
+	if ( count > MAX_PACKET_USERCMDS ) {
+		count = MAX_PACKET_USERCMDS;
+		Com_Printf("MAX_PACKET_USERCMDS\n");
+	}
+	if ( count >= 1 ) {
+		if ( cl_showSend->integer ) {
+			Com_Printf( "(%i)", count );
+		}
+
+		// begin a client move command
+		if ( cl_nodelta->integer || !cl.snap.valid
+#ifndef _XBOX	// No demos on Xbox
+			|| clc.demowaiting
+#endif
+			|| clc.serverMessageSequence != cl.snap.messageNum ) {
+			MSG_WriteByte (&buf, clc_moveNoDelta);
+		} else {
+			MSG_WriteByte (&buf, clc_move);
+		}
+
+		// write the command count
+		MSG_WriteByte( &buf, count );
+
+		// use the checksum feed in the key
+		key = clc.checksumFeed;
+		// also use the message acknowledge
+		key ^= clc.serverMessageSequence;
+		// also use the last acknowledged server command in the key
+		key ^= Com_HashKey(clc.serverCommands[ clc.serverCommandSequence & (MAX_RELIABLE_COMMANDS-1) ], 32);
+
+		// write all the commands, including the predicted command
+		for ( i = 0 ; i < count ; i++ ) {
+			j = (cl.cmdNumber - count + i + 1) & CMD_MASK;
+			cmd = &cl.cmds[j];
+			MSG_WriteDeltaUsercmdKey (&buf, key, oldcmd, cmd);
+			oldcmd = cmd;
+		}
+
+		if (cl.gcmdSentValue)
+		{ //hmm, just clear here, I guess.. hoping it will resolve issues with gencmd values sometimes not going through.
+			cl.gcmdSendValue = qfalse;
+			cl.gcmdSentValue = qfalse;
+			cl.gcmdValue = 0;
+		}
+	}
+
+	//
+	// deliver the message
+	//
+	packetNum = clc.netchan.outgoingSequence & PACKET_MASK;
+	cl.outPackets[ packetNum ].p_realtime = cls.realtime;
+	cl.outPackets[ packetNum ].p_serverTime = oldcmd->serverTime;
+	cl.outPackets[ packetNum ].p_cmdNumber = cl.cmdNumber;
+	clc.lastPacketSentTime = cls.realtime;
+
+	if ( cl_showSend->integer ) {
+		Com_Printf( "%i ", buf.cursize );
+	}
+
+	CL_Netchan_Transmit (&clc.netchan, &buf);	
+
+	// clients never really should have messages large enough
+	// to fragment, but in case they do, fire them all off
+	// at once
+	while ( clc.netchan.unsentFragments ) {
+		CL_Netchan_TransmitNextFragment( &clc.netchan );
+	}
+}
+
+/*
+=================
+CL_SendCmd
+
+Called every frame to builds and sends a command packet to the server.
+=================
+*/
+void CL_SendCmd( void ) {
+	// don't send any message if not connected
+	if ( cls.state < CA_CONNECTED ) {
+		return;
+	}
+
+	// don't send commands if paused
+	if ( com_sv_running->integer && sv_paused->integer && cl_paused->integer ) {
+		return;
+	}
+
+	// we create commands even if a demo is playing,
+	CL_CreateNewCommands();
+
+	// don't send a packet if the last packet was sent too recently
+	if ( !CL_ReadyToSendPacket() ) {
+		if ( cl_showSend->integer ) {
+			Com_Printf( ". " );
+		}
+		return;
+	}
+
+	CL_WritePacket();
+}
+
+
+/*
+============
+CL_InitInput
+============
+*/
+void CL_InitInput( void ) {
+	Cmd_AddCommand ("centerview",IN_CenterView);
+
+	//Cmd_AddCommand ("+taunt", IN_Button3Down);//gesture
+	//Cmd_AddCommand ("-taunt", IN_Button3Up);
+	Cmd_AddCommand ("+moveup",IN_UpDown);
+	Cmd_AddCommand ("-moveup",IN_UpUp);
+	Cmd_AddCommand ("+movedown",IN_DownDown);
+	Cmd_AddCommand ("-movedown",IN_DownUp);
+	Cmd_AddCommand ("+left",IN_LeftDown);
+	Cmd_AddCommand ("-left",IN_LeftUp);
+	Cmd_AddCommand ("+right",IN_RightDown);
+	Cmd_AddCommand ("-right",IN_RightUp);
+	Cmd_AddCommand ("+forward",IN_ForwardDown);
+	Cmd_AddCommand ("-forward",IN_ForwardUp);
+	Cmd_AddCommand ("+back",IN_BackDown);
+	Cmd_AddCommand ("-back",IN_BackUp);
+	Cmd_AddCommand ("+lookup", IN_LookupDown);
+	Cmd_AddCommand ("-lookup", IN_LookupUp);
+	Cmd_AddCommand ("+lookdown", IN_LookdownDown);
+	Cmd_AddCommand ("-lookdown", IN_LookdownUp);
+	Cmd_AddCommand ("+strafe", IN_StrafeDown);
+	Cmd_AddCommand ("-strafe", IN_StrafeUp);
+	Cmd_AddCommand ("+moveleft", IN_MoveleftDown);
+	Cmd_AddCommand ("-moveleft", IN_MoveleftUp);
+	Cmd_AddCommand ("+moveright", IN_MoverightDown);
+	Cmd_AddCommand ("-moveright", IN_MoverightUp);
+	Cmd_AddCommand ("+speed", IN_SpeedDown);
+	Cmd_AddCommand ("-speed", IN_SpeedUp);
+	Cmd_AddCommand ("+attack", IN_Button0Down);
+	Cmd_AddCommand ("-attack", IN_Button0Up);
+	//Cmd_AddCommand ("+force_jump", IN_Button1Down);//force jump
+	//Cmd_AddCommand ("-force_jump", IN_Button1Up);
+	Cmd_AddCommand ("+use", IN_Button5Down);
+	Cmd_AddCommand ("-use", IN_Button5Up);
+	Cmd_AddCommand ("+force_grip", IN_Button6Down);//force grip
+	Cmd_AddCommand ("-force_grip", IN_Button6Up);
+	Cmd_AddCommand ("+altattack", IN_Button7Down);//altattack
+	Cmd_AddCommand ("-altattack", IN_Button7Up);
+	Cmd_AddCommand ("+useforce", IN_Button9Down);//active force power
+	Cmd_AddCommand ("-useforce", IN_Button9Up);
+	Cmd_AddCommand ("+force_lightning", IN_Button10Down);//active force power
+	Cmd_AddCommand ("-force_lightning", IN_Button10Up);
+	Cmd_AddCommand ("+force_drain", IN_Button11Down);//active force power
+	Cmd_AddCommand ("-force_drain", IN_Button11Up);
+	//buttons
+	Cmd_AddCommand ("+button0", IN_Button0Down);//attack
+	Cmd_AddCommand ("-button0", IN_Button0Up);
+	Cmd_AddCommand ("+button1", IN_Button1Down);//force jump
+	Cmd_AddCommand ("-button1", IN_Button1Up);
+	Cmd_AddCommand ("+button2", IN_Button2Down);//use holdable (not used - change to use jedi power?)
+	Cmd_AddCommand ("-button2", IN_Button2Up);
+	Cmd_AddCommand ("+button3", IN_Button3Down);//gesture
+	Cmd_AddCommand ("-button3", IN_Button3Up);
+	Cmd_AddCommand ("+button4", IN_Button4Down);//walking
+	Cmd_AddCommand ("-button4", IN_Button4Up);
+	Cmd_AddCommand ("+button5", IN_Button5Down);//use object
+	Cmd_AddCommand ("-button5", IN_Button5Up);
+	Cmd_AddCommand ("+button6", IN_Button6Down);//force grip
+	Cmd_AddCommand ("-button6", IN_Button6Up);
+	Cmd_AddCommand ("+button7", IN_Button7Down);//altattack
+	Cmd_AddCommand ("-button7", IN_Button7Up);
+	Cmd_AddCommand ("+button8", IN_Button8Down);
+	Cmd_AddCommand ("-button8", IN_Button8Up);
+	Cmd_AddCommand ("+button9", IN_Button9Down);//active force power
+	Cmd_AddCommand ("-button9", IN_Button9Up);
+	Cmd_AddCommand ("+button10", IN_Button10Down);//force lightning
+	Cmd_AddCommand ("-button10", IN_Button10Up);
+	Cmd_AddCommand ("+button11", IN_Button11Down);//force drain
+	Cmd_AddCommand ("-button11", IN_Button11Up);
+	Cmd_AddCommand ("+button12", IN_Button12Down);
+	Cmd_AddCommand ("-button12", IN_Button12Up);
+	Cmd_AddCommand ("+button13", IN_Button13Down);
+	Cmd_AddCommand ("-button13", IN_Button13Up);
+	Cmd_AddCommand ("+button14", IN_Button14Down);
+	Cmd_AddCommand ("-button14", IN_Button14Up);
+	Cmd_AddCommand ("+mlook", IN_MLookDown);
+	Cmd_AddCommand ("-mlook", IN_MLookUp);
+
+	Cmd_AddCommand ("sv_saberswitch", IN_GenCMD1);
+	Cmd_AddCommand ("engage_duel", IN_GenCMD2);
+	Cmd_AddCommand ("force_heal", IN_GenCMD3);
+	Cmd_AddCommand ("force_speed", IN_GenCMD4);
+	Cmd_AddCommand ("force_pull", IN_GenCMD5);
+	Cmd_AddCommand ("force_distract", IN_GenCMD6);
+	Cmd_AddCommand ("force_rage", IN_GenCMD7);
+	Cmd_AddCommand ("force_protect", IN_GenCMD8);
+	Cmd_AddCommand ("force_absorb", IN_GenCMD9);
+	Cmd_AddCommand ("force_healother", IN_GenCMD10);
+	Cmd_AddCommand ("force_forcepowerother", IN_GenCMD11);
+	Cmd_AddCommand ("force_seeing", IN_GenCMD12);
+	Cmd_AddCommand ("use_seeker", IN_GenCMD13);
+	Cmd_AddCommand ("use_field", IN_GenCMD14);
+	Cmd_AddCommand ("use_bacta", IN_GenCMD15);
+	Cmd_AddCommand ("use_electrobinoculars", IN_GenCMD16);
+	Cmd_AddCommand ("zoom", IN_GenCMD17);
+	Cmd_AddCommand ("use_sentry", IN_GenCMD18);
+	Cmd_AddCommand ("use_jetpack", IN_GenCMD21);
+	Cmd_AddCommand ("use_bactabig", IN_GenCMD22);
+	Cmd_AddCommand ("use_healthdisp", IN_GenCMD23);
+	Cmd_AddCommand ("use_ammodisp", IN_GenCMD24);
+	Cmd_AddCommand ("use_eweb", IN_GenCMD25);
+	Cmd_AddCommand ("use_cloak", IN_GenCMD26);
+	Cmd_AddCommand ("taunt", IN_GenCMD27);
+	Cmd_AddCommand ("bow", IN_GenCMD28);
+	Cmd_AddCommand ("meditate", IN_GenCMD29);
+	Cmd_AddCommand ("flourish", IN_GenCMD30);
+	Cmd_AddCommand ("gloat", IN_GenCMD31);
+	Cmd_AddCommand ("saberAttackCycle", IN_GenCMD19);
+	Cmd_AddCommand ("force_throw", IN_GenCMD20);
+#ifdef _XBOX
+	Cmd_AddCommand ("+hotswap1", IN_HotSwap1On);
+	Cmd_AddCommand ("+hotswap2", IN_HotSwap2On);
+	Cmd_AddCommand ("-hotswap1", IN_HotSwap1Off);
+	Cmd_AddCommand ("-hotswap2", IN_HotSwap2Off);
+
+	Cmd_AddCommand ("+voicetoggle", IN_VoiceToggleDown);
+	Cmd_AddCommand ("-voicetoggle", IN_VoiceToggleUp);
+#endif
+	Cmd_AddCommand ("useGivenForce", IN_UseGivenForce);
+
+
+	Cmd_AddCommand("automap_button", IN_AutoMapButton);
+	Cmd_AddCommand("automap_toggle", IN_AutoMapToggle);
+	Cmd_AddCommand("voicechat", IN_VoiceChatButton);
+
+	cl_nodelta = Cvar_Get ("cl_nodelta", "0", 0);
+	cl_debugMove = Cvar_Get ("cl_debugMove", "0", 0);
+}
diff --git a/codemp/client/cl_keys.cpp b/codemp/client/cl_keys.cpp
new file mode 100644
index 0000000..9f639a5
--- /dev/null
+++ b/codemp/client/cl_keys.cpp
@@ -0,0 +1,1708 @@
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+#include "client.h"
+#include "../qcommon/stringed_ingame.h"
+/*
+
+key up events are sent even if in console mode
+
+*/
+
+field_t		chatField;
+qboolean	chat_team;
+
+int			chat_playerNum;
+
+keyGlobals_t	kg;										
+
+// do NOT blithely change any of the key names (3rd field) here, since they have to match the key binds
+//	in the CFG files, they're also prepended with "KEYNAME_" when looking up StringEd references
+//
+keyname_t keynames[MAX_KEYS] =							
+{														
+	{ 0x00, 0x00, NULL, A_NULL, false									},					  
+	{ 0x01, 0x01, "SHIFT", A_SHIFT, false 								},					       
+	{ 0x02, 0x02, "CTRL", A_CTRL, false   								},					       
+	{ 0x03, 0x03, "ALT", A_ALT, false									},					       
+	{ 0x04, 0x04, "CAPSLOCK", A_CAPSLOCK, false							},					       
+	{ 0x05, 0x05, "KP_NUMLOCK", A_NUMLOCK, false						},					       
+	{ 0x06, 0x06, "SCROLLLOCK", A_SCROLLLOCK, false						},					       
+	{ 0x07, 0x07, "PAUSE", A_PAUSE, false								},					       
+	{ 0x08, 0x08, "BACKSPACE", A_BACKSPACE, false						},					       
+	{ 0x09, 0x09, "TAB", A_TAB, false									},					       
+	{ 0x0a, 0x0a, "ENTER", A_ENTER, false								},					       
+	{ 0x0b, 0x0b, "KP_PLUS", A_KP_PLUS, false							},					       
+	{ 0x0c, 0x0c, "KP_MINUS", A_KP_MINUS, false							},					       
+	{ 0x0d, 0x0d, "KP_ENTER", A_KP_ENTER, false							},					       
+	{ 0x0e, 0x0e, "KP_DEL", A_KP_PERIOD, false							},					       
+	{ 0x0f, 0x0f, NULL, A_PRINTSCREEN, false							},
+	{ 0x10, 0x10, "KP_INS", A_KP_0, false								},					       
+	{ 0x11, 0x11, "KP_END", A_KP_1, false								},					       
+	{ 0x12, 0x12, "KP_DOWNARROW", A_KP_2, false							},					       
+	{ 0x13, 0x13, "KP_PGDN", A_KP_3, false								},					       
+	{ 0x14, 0x14, "KP_LEFTARROW", A_KP_4, false							},					       
+	{ 0x15, 0x15, "KP_5", A_KP_5, false									},					       
+	{ 0x16, 0x16, "KP_RIGHTARROW", A_KP_6, false						},					       
+	{ 0x17, 0x17, "KP_HOME", A_KP_7, false								},					       
+	{ 0x18, 0x18, "KP_UPARROW", A_KP_8, false							},					       
+	{ 0x19, 0x19, "KP_PGUP", A_KP_9, false								},					       
+	{ 0x1a, 0x1a, "CONSOLE", A_CONSOLE, false 							},					       
+	{ 0x1b, 0x1b, "ESCAPE", A_ESCAPE, false								},					       
+	{ 0x1c, 0x1c, "F1", A_F1, true										},					       
+	{ 0x1d, 0x1d, "F2", A_F2, true										},					       
+	{ 0x1e, 0x1e, "F3", A_F3, true										},					       
+	{ 0x1f, 0x1f, "F4", A_F4, true										},					       
+			    													        
+	{ 0x20, 0x20, "SPACE", A_SPACE, false								},
+	{ (word)'!', (word)'!', NULL, A_PLING, false		  				},
+	{ (word)'"', (word)'"', NULL, A_DOUBLE_QUOTE, false  				},
+	{ (word)'#', (word)'#', NULL, A_HASH, false		  					},
+	{ (word)'$', (word)'$', NULL, A_STRING, false						},
+	{ (word)'%', (word)'%', NULL, A_PERCENT, false						},
+	{ (word)'&', (word)'&', NULL, A_AND, false							},
+	{ 0x27, 0x27, NULL, A_SINGLE_QUOTE, false							},
+	{ (word)'(', (word)'(', NULL, A_OPEN_BRACKET, false					},
+	{ (word)')', (word)')', NULL, A_CLOSE_BRACKET, false				},
+	{ (word)'*', (word)'*', NULL, A_STAR, false							},
+	{ (word)'+', (word)'+', NULL, A_PLUS, false							},
+	{ (word)',', (word)',', NULL, A_COMMA, false						},
+	{ (word)'-', (word)'-', NULL, A_MINUS, false						},
+	{ (word)'.', (word)'.', NULL, A_PERIOD, false						},
+	{ (word)'/', (word)'/', NULL, A_FORWARD_SLASH, false				},
+	{ (word)'0', (word)'0', NULL, A_0, false							},
+	{ (word)'1', (word)'1', NULL, A_1, false							},
+	{ (word)'2', (word)'2', NULL, A_2, false							},
+	{ (word)'3', (word)'3', NULL, A_3, false							},
+	{ (word)'4', (word)'4', NULL, A_4, false							},
+	{ (word)'5', (word)'5', NULL, A_5, false							},
+	{ (word)'6', (word)'6', NULL, A_6, false							},
+	{ (word)'7', (word)'7', NULL, A_7, false							},
+	{ (word)'8', (word)'8', NULL, A_8, false							},
+	{ (word)'9', (word)'9', NULL, A_9, false							},
+	{ (word)':', (word)':', NULL, A_COLON, false						},
+	{ (word)';', (word)';', "SEMICOLON", A_SEMICOLON, false				},
+	{ (word)'<', (word)'<', NULL, A_LESSTHAN, false						},
+	{ (word)'=', (word)'=', NULL, A_EQUALS, false						},
+	{ (word)'>', (word)'>', NULL, A_GREATERTHAN, false					},
+	{ (word)'?', (word)'?', NULL, A_QUESTION, false						},
+			    													
+	{ (word)'@', (word)'@', NULL, A_AT, false							},	   	            
+	{ (word)'A', (word)'a', NULL, A_CAP_A, false						},		            
+	{ (word)'B', (word)'b', NULL, A_CAP_B, false						},		            
+	{ (word)'C', (word)'c', NULL, A_CAP_C, false						},		            
+	{ (word)'D', (word)'d', NULL, A_CAP_D, false						},		            
+	{ (word)'E', (word)'e', NULL, A_CAP_E, false						},		            
+	{ (word)'F', (word)'f', NULL, A_CAP_F, false						},		            
+	{ (word)'G', (word)'g', NULL, A_CAP_G, false						},		            
+	{ (word)'H', (word)'h', NULL, A_CAP_H, false						},		            
+	{ (word)'I', (word)'i', NULL, A_CAP_I, false						},		            
+	{ (word)'J', (word)'j', NULL, A_CAP_J, false						},		            
+	{ (word)'K', (word)'k', NULL, A_CAP_K, false						},		            
+	{ (word)'L', (word)'l', NULL, A_CAP_L, false						},		            
+	{ (word)'M', (word)'m', NULL, A_CAP_M, false						},		            
+	{ (word)'N', (word)'n', NULL, A_CAP_N, false						},		            
+	{ (word)'O', (word)'o', NULL, A_CAP_O, false						},		            
+	{ (word)'P', (word)'p', NULL, A_CAP_P, false						},		            
+	{ (word)'Q', (word)'q', NULL, A_CAP_Q, false						},		            
+	{ (word)'R', (word)'r', NULL, A_CAP_R, false						},		            
+	{ (word)'S', (word)'s', NULL, A_CAP_S, false						},		            
+	{ (word)'T', (word)'t', NULL, A_CAP_T, false						},		            
+	{ (word)'U', (word)'u', NULL, A_CAP_U, false						},		            
+	{ (word)'V', (word)'v', NULL, A_CAP_V, false						},		            
+	{ (word)'W', (word)'w', NULL, A_CAP_W, false						},		            
+	{ (word)'X', (word)'x', NULL, A_CAP_X, false						},		            
+	{ (word)'Y', (word)'y', NULL, A_CAP_Y, false						},		            
+	{ (word)'Z', (word)'z', NULL, A_CAP_Z, false						},		            
+	{ (word)'[', (word)'[', NULL, A_OPEN_SQUARE, false					},					    
+	{ 0x5c, 0x5c, NULL, A_BACKSLASH, false								},					    
+	{ (word)']', (word)']', NULL, A_CLOSE_SQUARE, false 				},					    
+	{ (word)'^', (word)'^', NULL, A_CARET, false		 				},					    
+	{ (word)'_', (word)'_', NULL, A_UNDERSCORE, false					},					    
+			    													   
+	{ 0x60, 0x60, NULL, A_LEFT_SINGLE_QUOTE, false						},
+	{ (word)'A', (word)'a', NULL, A_LOW_A, false						},           
+	{ (word)'B', (word)'b', NULL, A_LOW_B, false						},           
+	{ (word)'C', (word)'c', NULL, A_LOW_C, false						},           
+	{ (word)'D', (word)'d', NULL, A_LOW_D, false						},           
+	{ (word)'E', (word)'e', NULL, A_LOW_E, false						},           
+	{ (word)'F', (word)'f', NULL, A_LOW_F, false						},           
+	{ (word)'G', (word)'g', NULL, A_LOW_G, false						},           
+	{ (word)'H', (word)'h', NULL, A_LOW_H, false						},           
+	{ (word)'I', (word)'i', NULL, A_LOW_I, false						},           
+	{ (word)'J', (word)'j', NULL, A_LOW_J, false						},           
+	{ (word)'K', (word)'k', NULL, A_LOW_K, false						},           
+	{ (word)'L', (word)'l', NULL, A_LOW_L, false						},           
+	{ (word)'M', (word)'m', NULL, A_LOW_M, false						},           
+	{ (word)'N', (word)'n', NULL, A_LOW_N, false						},           
+	{ (word)'O', (word)'o', NULL, A_LOW_O, false						},           
+	{ (word)'P', (word)'p', NULL, A_LOW_P, false						},           
+	{ (word)'Q', (word)'q', NULL, A_LOW_Q, false						},           
+	{ (word)'R', (word)'r', NULL, A_LOW_R, false						},           
+	{ (word)'S', (word)'s', NULL, A_LOW_S, false						},           
+	{ (word)'T', (word)'t', NULL, A_LOW_T, false						},           
+	{ (word)'U', (word)'u', NULL, A_LOW_U, false						},           
+	{ (word)'V', (word)'v', NULL, A_LOW_V, false						},           
+	{ (word)'W', (word)'w', NULL, A_LOW_W, false						},           
+	{ (word)'X', (word)'x', NULL, A_LOW_X, false						},           
+	{ (word)'Y', (word)'y', NULL, A_LOW_Y, false						},           
+	{ (word)'Z', (word)'z', NULL, A_LOW_Z, false						},           
+	{ (word)'{', (word)'{', NULL, A_OPEN_BRACE, false					},
+	{ (word)'|', (word)'|', NULL, A_BAR, false							},
+	{ (word)'}', (word)'}', NULL, A_CLOSE_BRACE, false					},
+	{ (word)'~', (word)'~', NULL, A_TILDE, false						},
+	{ 0x7f, 0x7f, "DEL", A_DELETE, false								},
+			    													               
+	{ 0x80, 0x80, "EURO", A_EURO, false  								},
+	{ 0x81, 0x81, "SHIFT", A_SHIFT2, false								},
+	{ 0x82, 0x82, "CTRL", A_CTRL2, false								},
+	{ 0x83, 0x83, "ALT", A_ALT2, false									},
+	{ 0x84, 0x84, "F5", A_F5, true										},
+	{ 0x85, 0x85, "F6", A_F6, true										},
+	{ 0x86, 0x86, "F7", A_F7, true										},
+	{ 0x87, 0x87, "F8", A_F8, true										},
+	{ 0x88, 0x88, "CIRCUMFLEX", A_CIRCUMFLEX, false  					},
+	{ 0x89, 0x89, "MWHEELUP", A_MWHEELUP, false							},
+	{ 0x8a, 0x9a, NULL, A_CAP_SCARON, false								},	// ******
+	{ 0x8b, 0x8b, "MWHEELDOWN", A_MWHEELDOWN, false						},
+	{ 0x8c, 0x9c, NULL, A_CAP_OE, false									},	// ******
+	{ 0x8d, 0x8d, "MOUSE1", A_MOUSE1, false								},
+	{ 0x8e, 0x8e, "MOUSE2", A_MOUSE2, false								},
+	{ 0x8f, 0x8f, "INS", A_INSERT, false								},
+	{ 0x90, 0x90, "HOME", A_HOME, false									},
+	{ 0x91, 0x91, "PGUP", A_PAGE_UP, false								},
+	{ 0x92, 0x92, NULL, A_RIGHT_SINGLE_QUOTE, false						},
+	{ 0x93, 0x93, NULL, A_LEFT_DOUBLE_QUOTE, false						},
+	{ 0x94, 0x94, NULL, A_RIGHT_DOUBLE_QUOTE, false						},
+	{ 0x95, 0x95, "F9", A_F9, true										},
+	{ 0x96, 0x96, "F10", A_F10, true									},
+	{ 0x97, 0x97, "F11", A_F11, true									},
+	{ 0x98, 0x98, "F12", A_F12, true									},
+	{ 0x99, 0x99, NULL, A_TRADEMARK, false								},
+	{ 0x8a, 0x9a, NULL, A_LOW_SCARON, false								},	// ******
+	{ 0x9b, 0x9b, "SHIFT_ENTER", A_ENTER, false							},
+	{ 0x8c, 0x9c, NULL, A_LOW_OE, false									},	// ******
+	{ 0x9d, 0x9d, "END", A_END, false									},
+	{ 0x9e, 0x9e, "PGDN", A_PAGE_DOWN, false							},
+	{ 0x9f, 0xff, NULL, A_CAP_YDIERESIS, false							},	// ******
+			    													
+	{ 0xa0, 0,	  "SHIFT_SPACE", A_SPACE, false							},
+	{ 0xa1, 0xa1, NULL, A_EXCLAMDOWN, false								},	// upside down '!' - undisplayable
+	{ (word)(byte)'¢', (word)(byte)'¢', NULL, A_CENT, false	  			},
+	{ (word)(byte)'£', (word)(byte)'£', NULL, A_POUND, false	  		},
+	{ 0xa4, 0,    "SHIFT_KP_ENTER", A_KP_ENTER, false					},
+	{ (word)(byte)'¥', (word)(byte)'¥', NULL, A_YEN, false		  		},
+	{ 0xa6, 0xa6, "MOUSE3", A_MOUSE3, false								},
+	{ 0xa7, 0xa7, "MOUSE4", A_MOUSE4, false								},
+	{ 0xa8, 0xa8, "MOUSE5", A_MOUSE5, false								},
+	{ (word)(byte)'©', (word)(byte)'©', NULL, A_COPYRIGHT, false 		},
+	{ 0xaa, 0xaa, "UPARROW", A_CURSOR_UP, false							},
+	{ 0xab, 0xab, "DOWNARROW", A_CURSOR_DOWN, false						},
+	{ 0xac, 0xac, "LEFTARROW", A_CURSOR_LEFT, false						},
+	{ 0xad, 0xad, "RIGHTARROW", A_CURSOR_RIGHT, false					},
+	{ (word)(byte)'®', (word)(byte)'®', NULL, A_REGISTERED, false		},
+	{ 0xaf, 0,	  NULL, A_UNDEFINED_7, false							},
+	{ 0xb0, 0,	  NULL, A_UNDEFINED_8, false							},
+	{ 0xb1, 0,	  NULL, A_UNDEFINED_9, false							},
+	{ 0xb2, 0,	  NULL, A_UNDEFINED_10, false							},
+	{ 0xb3, 0,	  NULL, A_UNDEFINED_11, false							},
+	{ 0xb4, 0,	  NULL, A_UNDEFINED_12, false							},
+	{ 0xb5, 0,	  NULL, A_UNDEFINED_13, false							},
+	{ 0xb6, 0,	  NULL, A_UNDEFINED_14, false							},
+	{ 0xb7, 0,	  NULL, A_UNDEFINED_15, false							},
+	{ 0xb8, 0,	  NULL, A_UNDEFINED_16, false							},
+	{ 0xb9, 0,	  NULL, A_UNDEFINED_17, false							},
+	{ 0xba, 0,	  NULL, A_UNDEFINED_18, false							},
+	{ 0xbb, 0,	  NULL, A_UNDEFINED_19, false							},
+	{ 0xbc, 0,	  NULL, A_UNDEFINED_20, false							},
+	{ 0xbd, 0,	  NULL, A_UNDEFINED_21, false							},
+	{ 0xbe, 0,	  NULL, A_UNDEFINED_22, false							},
+	{ (word)(byte)'¿', (word)(byte)'¿', NULL, A_QUESTION_DOWN, false	},
+			    		                       
+	{ (word)(byte)'À', (word)(byte)'à', NULL, A_CAP_AGRAVE, false		},
+	{ (word)(byte)'Á', (word)(byte)'á', NULL, A_CAP_AACUTE, false		},
+	{ (word)(byte)'Â', (word)(byte)'â', NULL, A_CAP_ACIRCUMFLEX, false	},
+	{ (word)(byte)'Ã', (word)(byte)'ã', NULL, A_CAP_ATILDE, false		},
+	{ (word)(byte)'Ä', (word)(byte)'ä', NULL, A_CAP_ADIERESIS, false	},
+	{ (word)(byte)'Å', (word)(byte)'å', NULL, A_CAP_ARING, false		},
+	{ (word)(byte)'Æ', (word)(byte)'æ', NULL, A_CAP_AE, false			},
+	{ (word)(byte)'Ç', (word)(byte)'ç', NULL, A_CAP_CCEDILLA, false		},
+	{ (word)(byte)'È', (word)(byte)'è', NULL, A_CAP_EGRAVE, false		},
+	{ (word)(byte)'É', (word)(byte)'é', NULL, A_CAP_EACUTE, false		},
+	{ (word)(byte)'Ê', (word)(byte)'ê', NULL, A_CAP_ECIRCUMFLEX, false	},
+	{ (word)(byte)'Ë', (word)(byte)'ë', NULL, A_CAP_EDIERESIS, false	},
+	{ (word)(byte)'Ì', (word)(byte)'ì', NULL, A_CAP_IGRAVE, false		},
+	{ (word)(byte)'Í', (word)(byte)'í', NULL, A_CAP_IACUTE, false		},
+	{ (word)(byte)'Î', (word)(byte)'î', NULL, A_CAP_ICIRCUMFLEX, false	},
+	{ (word)(byte)'Ï', (word)(byte)'ï', NULL, A_CAP_IDIERESIS, false	},
+	{ (word)(byte)'Ð', (word)(byte)'ð', NULL, A_CAP_ETH, false			},
+	{ (word)(byte)'Ñ', (word)(byte)'ñ', NULL, A_CAP_NTILDE, false		},
+	{ (word)(byte)'Ò', (word)(byte)'ò', NULL, A_CAP_OGRAVE, false		},
+	{ (word)(byte)'Ó', (word)(byte)'ó', NULL, A_CAP_OACUTE, false		},
+	{ (word)(byte)'Ô', (word)(byte)'ô', NULL, A_CAP_OCIRCUMFLEX, false	},
+	{ (word)(byte)'Õ', (word)(byte)'õ', NULL, A_CAP_OTILDE, false		},
+	{ (word)(byte)'Ö', (word)(byte)'ö', NULL, A_CAP_ODIERESIS, false	},
+	{ (word)(byte)'×', (word)(byte)'×', "KP_STAR", A_MULTIPLY, false 	},
+	{ (word)(byte)'Ø', (word)(byte)'ø', NULL, A_CAP_OSLASH, false		},  
+	{ (word)(byte)'Ù', (word)(byte)'ù', NULL, A_CAP_UGRAVE, false		},  
+	{ (word)(byte)'Ú', (word)(byte)'ú', NULL, A_CAP_UACUTE, false		},  
+	{ (word)(byte)'Û', (word)(byte)'û', NULL, A_CAP_UCIRCUMFLEX, false	},  
+	{ (word)(byte)'Ü', (word)(byte)'ü', NULL, A_CAP_UDIERESIS, false	},  
+	{ (word)(byte)'Ý', (word)(byte)'ý', NULL, A_CAP_YACUTE, false		},  
+	{ (word)(byte)'Þ', (word)(byte)'þ', NULL, A_CAP_THORN, false		},  
+	{ (word)(byte)'ß', (word)(byte)'ß', NULL, A_GERMANDBLS, false 		},
+			    		                       
+	{ (word)(byte)'À', (word)(byte)'à', NULL, A_LOW_AGRAVE, false		},		 
+	{ (word)(byte)'Á', (word)(byte)'á', NULL, A_LOW_AACUTE, false		},		 
+	{ (word)(byte)'Â', (word)(byte)'â', NULL, A_LOW_ACIRCUMFLEX, false	},		 
+	{ (word)(byte)'Ã', (word)(byte)'ã', NULL, A_LOW_ATILDE, false		},		 
+	{ (word)(byte)'Ä', (word)(byte)'ä', NULL, A_LOW_ADIERESIS, false	},		 
+	{ (word)(byte)'Å', (word)(byte)'å', NULL, A_LOW_ARING, false		},		 
+	{ (word)(byte)'Æ', (word)(byte)'æ', NULL, A_LOW_AE, false			},		 
+	{ (word)(byte)'Ç', (word)(byte)'ç', NULL, A_LOW_CCEDILLA, false		},		 
+	{ (word)(byte)'È', (word)(byte)'è', NULL, A_LOW_EGRAVE, false		},		 
+	{ (word)(byte)'É', (word)(byte)'é', NULL, A_LOW_EACUTE, false		},		 
+	{ (word)(byte)'Ê', (word)(byte)'ê', NULL, A_LOW_ECIRCUMFLEX, false	},		 
+	{ (word)(byte)'Ë', (word)(byte)'ë', NULL, A_LOW_EDIERESIS, false	},		 
+	{ (word)(byte)'Ì', (word)(byte)'ì', NULL, A_LOW_IGRAVE, false		},		 
+	{ (word)(byte)'Í', (word)(byte)'í', NULL, A_LOW_IACUTE, false		},		 
+	{ (word)(byte)'Î', (word)(byte)'î', NULL, A_LOW_ICIRCUMFLEX, false	},		 
+	{ (word)(byte)'Ï', (word)(byte)'ï', NULL, A_LOW_IDIERESIS, false	},		 
+	{ (word)(byte)'Ð', (word)(byte)'ð', NULL, A_LOW_ETH, false			},		 
+	{ (word)(byte)'Ñ', (word)(byte)'ñ', NULL, A_LOW_NTILDE, false		},		 
+	{ (word)(byte)'Ò', (word)(byte)'ò', NULL, A_LOW_OGRAVE, false		},		 
+	{ (word)(byte)'Ó', (word)(byte)'ó', NULL, A_LOW_OACUTE, false		},		 
+	{ (word)(byte)'Ô', (word)(byte)'ô', NULL, A_LOW_OCIRCUMFLEX, false	},		 
+	{ (word)(byte)'Õ', (word)(byte)'õ', NULL, A_LOW_OTILDE, false		},		 
+	{ (word)(byte)'Ö', (word)(byte)'ö', NULL, A_LOW_ODIERESIS, false	},		 
+	{ (word)(byte)'÷', (word)(byte)'÷', "KP_SLASH", A_DIVIDE, false 	},		 
+	{ (word)(byte)'Ø', (word)(byte)'ø', NULL, A_LOW_OSLASH, false		},		 
+	{ (word)(byte)'Ù', (word)(byte)'ù', NULL, A_LOW_UGRAVE, false		},		 
+	{ (word)(byte)'Ú', (word)(byte)'ú', NULL, A_LOW_UACUTE, false		},		 
+	{ (word)(byte)'Û', (word)(byte)'û', NULL, A_LOW_UCIRCUMFLEX, false	},		 
+	{ (word)(byte)'Ü', (word)(byte)'ü', NULL, A_LOW_UDIERESIS, false	},		 
+	{ (word)(byte)'Ý', (word)(byte)'ý', NULL, A_LOW_YACUTE, false		},		 
+	{ (word)(byte)'Þ', (word)(byte)'þ', NULL, A_LOW_THORN, false		},		 
+	{ 0x9f, 0xff, NULL, A_LOW_YDIERESIS, false							},	// *******
+																		
+	{ 0x100, 0x100, "JOY0", A_JOY0, false								},
+	{ 0x101, 0x101, "JOY1", A_JOY1, false								},
+	{ 0x102, 0x102, "JOY2", A_JOY2, false								},
+	{ 0x103, 0x103, "JOY3", A_JOY3, false								},
+	{ 0x104, 0x104, "JOY4", A_JOY4, false								},
+	{ 0x105, 0x105, "JOY5", A_JOY5, false								},
+	{ 0x106, 0x106, "JOY6", A_JOY6, false								},
+	{ 0x107, 0x107, "JOY7", A_JOY7, false								},
+	{ 0x108, 0x108, "JOY8", A_JOY8, false								},
+	{ 0x109, 0x109, "JOY9", A_JOY9, false								},
+	{ 0x10a, 0x10a, "JOY10", A_JOY10, false								},
+	{ 0x10b, 0x10b, "JOY11", A_JOY11, false								},
+	{ 0x10c, 0x10c, "JOY12", A_JOY12, false								},
+	{ 0x10d, 0x10d, "JOY13", A_JOY13, false								},
+	{ 0x10e, 0x10e, "JOY14", A_JOY14, false								},
+	{ 0x10f, 0x10f, "JOY15", A_JOY15, false								},
+	{ 0x110, 0x110, "JOY16", A_JOY16, false								},
+	{ 0x111, 0x111, "JOY17", A_JOY17, false								},
+	{ 0x112, 0x112, "JOY18", A_JOY18, false								},
+	{ 0x113, 0x113, "JOY19", A_JOY19, false								},
+	{ 0x114, 0x114, "JOY20", A_JOY20, false								},
+	{ 0x115, 0x115, "JOY21", A_JOY21, false								},
+	{ 0x116, 0x116, "JOY22", A_JOY22, false								},
+	{ 0x117, 0x117, "JOY23", A_JOY23, false								},
+	{ 0x118, 0x118, "JOY24", A_JOY24, false								},
+	{ 0x119, 0x119, "JOY25", A_JOY25, false								},
+	{ 0x11a, 0x11a, "JOY26", A_JOY26, false								},
+	{ 0x11b, 0x11b, "JOY27", A_JOY27, false								},
+	{ 0x11c, 0x11c, "JOY28", A_JOY28, false								},
+	{ 0x11d, 0x11d, "JOY29", A_JOY29, false								},
+	{ 0x11e, 0x11e, "JOY30", A_JOY30, false								},
+	{ 0x11f, 0x11f, "JOY31", A_JOY31, false								},
+		    	    												
+	{ 0x120, 0x120, "AUX0", A_AUX0, false								},
+	{ 0x121, 0x121, "AUX1", A_AUX1, false								},
+	{ 0x122, 0x122, "AUX2", A_AUX2, false								},
+	{ 0x123, 0x123, "AUX3", A_AUX3, false								},
+	{ 0x124, 0x124, "AUX4", A_AUX4, false								},
+	{ 0x125, 0x125, "AUX5", A_AUX5, false								},
+	{ 0x126, 0x126, "AUX6", A_AUX6, false								},
+	{ 0x127, 0x127, "AUX7", A_AUX7, false								},
+	{ 0x128, 0x128, "AUX8", A_AUX8, false								},
+	{ 0x129, 0x129, "AUX9", A_AUX9, false								},
+	{ 0x12a, 0x12a, "AUX10", A_AUX10, false								},
+	{ 0x12b, 0x12b, "AUX11", A_AUX11, false								},
+	{ 0x12c, 0x12c, "AUX12", A_AUX12, false								},
+	{ 0x12d, 0x12d, "AUX13", A_AUX13, false								},
+	{ 0x12e, 0x12e, "AUX14", A_AUX14, false								},
+	{ 0x12f, 0x12f, "AUX15", A_AUX15, false								},
+	{ 0x130, 0x130, "AUX16", A_AUX16, false								},
+	{ 0x131, 0x131, "AUX17", A_AUX17, false								},
+	{ 0x132, 0x132, "AUX18", A_AUX18, false								},
+	{ 0x133, 0x133, "AUX19", A_AUX19, false								},
+	{ 0x134, 0x134, "AUX20", A_AUX20, false								},
+	{ 0x135, 0x135, "AUX21", A_AUX21, false								},
+	{ 0x136, 0x136, "AUX22", A_AUX22, false								},
+	{ 0x137, 0x137, "AUX23", A_AUX23, false								},
+	{ 0x138, 0x138, "AUX24", A_AUX24, false								},
+	{ 0x139, 0x139, "AUX25", A_AUX25, false								},
+	{ 0x13a, 0x13a, "AUX26", A_AUX26, false								},
+	{ 0x13b, 0x13b, "AUX27", A_AUX27, false								},
+	{ 0x13c, 0x13c, "AUX28", A_AUX28, false								},
+	{ 0x13d, 0x13d, "AUX29", A_AUX29, false								},
+	{ 0x13e, 0x13e, "AUX30", A_AUX30, false								},
+	{ 0x13f, 0x13f, "AUX31", A_AUX31, false								}
+};
+
+
+
+/*
+=============================================================================
+
+EDIT FIELDS
+
+=============================================================================
+*/
+
+
+/*
+===================
+Field_Draw
+
+Handles horizontal scrolling and cursor blinking
+x, y, amd width are in pixels
+===================
+*/
+void Field_VariableSizeDraw( field_t *edit, int x, int y, int width, int size, qboolean showCursor ) {
+	int		len;
+	int		drawLen;
+	int		prestep;
+	int		cursorChar;
+	char	str[MAX_STRING_CHARS];
+	int		i;
+
+	drawLen = edit->widthInChars;
+	len = strlen( edit->buffer ) + 1;
+
+	// guarantee that cursor will be visible
+	if ( len <= drawLen ) {
+		prestep = 0;
+	} else {
+		if ( edit->scroll + drawLen > len ) {
+			edit->scroll = len - drawLen;
+			if ( edit->scroll < 0 ) {
+				edit->scroll = 0;
+			}
+		}
+		prestep = edit->scroll;
+
+/*
+		if ( edit->cursor < len - drawLen ) {
+			prestep = edit->cursor;	// cursor at start
+		} else {
+			prestep = len - drawLen;
+		}
+*/
+	}
+
+	if ( prestep + drawLen > len ) {
+		drawLen = len - prestep;
+	}
+
+	// extract <drawLen> characters from the field at <prestep>
+	if ( drawLen >= MAX_STRING_CHARS ) {
+		Com_Error( ERR_DROP, "drawLen >= MAX_STRING_CHARS" );
+	}
+
+	Com_Memcpy( str, edit->buffer + prestep, drawLen );
+	str[ drawLen ] = 0;
+
+	// draw it
+	if ( size == SMALLCHAR_WIDTH ) {
+		float	color[4];
+
+		color[0] = color[1] = color[2] = color[3] = 1.0;
+		SCR_DrawSmallStringExt( x, y, str, color, qfalse );
+	} else {
+		// draw big string with drop shadow
+		SCR_DrawBigString( x, y, str, 1.0 );
+	}
+
+	// draw the cursor
+	if ( !showCursor ) {
+		return;
+	}
+
+	if ( (int)( cls.realtime >> 8 ) & 1 ) {
+		return;		// off blink
+	}
+
+	if ( kg.key_overstrikeMode ) {
+		cursorChar = 11;
+	} else {
+		cursorChar = 10;
+	}
+
+	i = drawLen - ( Q_PrintStrlen( str ) + 1 );
+
+	if ( size == SMALLCHAR_WIDTH ) {
+		SCR_DrawSmallChar( x + ( edit->cursor - prestep - i ) * size, y, cursorChar );
+	} else {
+		str[0] = cursorChar;
+		str[1] = 0;
+		SCR_DrawBigString( x + ( edit->cursor - prestep - i ) * size, y, str, 1.0 );
+
+	}
+}
+
+void Field_Draw( field_t *edit, int x, int y, int width, qboolean showCursor ) 
+{
+	Field_VariableSizeDraw( edit, x, y, width, SMALLCHAR_WIDTH, showCursor );
+}
+
+void Field_BigDraw( field_t *edit, int x, int y, int width, qboolean showCursor ) 
+{
+	Field_VariableSizeDraw( edit, x, y, width, BIGCHAR_WIDTH, showCursor );
+}
+
+/*
+================
+Field_Paste
+================
+*/
+void Field_Paste( field_t *edit ) {
+	char	*cbd;
+	int		pasteLen, i;
+
+	cbd = Sys_GetClipboardData();
+
+	if ( !cbd ) {
+		return;
+	}
+
+	// send as if typed, so insert / overstrike works properly
+	pasteLen = strlen( cbd );
+	for ( i = 0 ; i < pasteLen ; i++ ) {
+		Field_CharEvent( edit, cbd[i] );
+	}
+
+	Z_Free( cbd );
+}
+
+/*
+=================
+Field_KeyDownEvent
+
+Performs the basic line editing functions for the console,
+in-game talk, and menu fields
+
+Key events are used for non-printable characters, others are gotten from char events.
+=================
+*/
+void Field_KeyDownEvent( field_t *edit, int key ) {
+	int		len;
+
+	// shift-insert is paste
+	if ( ( ( key == A_INSERT ) || ( key == A_KP_0 ) ) && kg.keys[A_SHIFT].down ) {
+		Field_Paste( edit );
+		return;
+	}
+
+	len = strlen( edit->buffer );
+
+	if ( key == A_DELETE ) {
+		if ( edit->cursor < len ) {
+			memmove( edit->buffer + edit->cursor, 
+				edit->buffer + edit->cursor + 1, len - edit->cursor );
+		}
+		return;
+	}
+
+	if ( key == A_CURSOR_RIGHT ) 
+	{
+		if ( edit->cursor < len ) {
+			edit->cursor++;
+		}
+
+		if ( edit->cursor >= edit->scroll + edit->widthInChars && edit->cursor <= len )
+		{
+			edit->scroll++;
+		}
+		return;
+	}
+
+	if ( key == A_CURSOR_LEFT ) 
+	{
+		if ( edit->cursor > 0 ) {
+			edit->cursor--;
+		}
+		if ( edit->cursor < edit->scroll )
+		{
+			edit->scroll--;
+		}
+		return;
+	}
+
+	if ( key == A_HOME || ( keynames[key].lower == 'a' && kg.keys[A_CTRL].down ) ) 
+	{
+		edit->cursor = 0;
+		return;
+	}
+
+	if ( key == A_END || ( keynames[key].lower == 'e' && kg.keys[A_CTRL].down ) ) 
+	{
+		edit->cursor = len;
+		return;
+	}
+
+	if ( key == A_INSERT ) {
+		kg.key_overstrikeMode = (qboolean)!kg.key_overstrikeMode;
+		return;
+	}
+}
+
+/*
+==================
+Field_CharEvent
+==================
+*/
+void Field_CharEvent( field_t *edit, int ch ) {
+	int		len;
+
+	if ( ch == 'v' - 'a' + 1 ) {	// ctrl-v is paste
+		Field_Paste( edit );
+		return;
+	}
+
+	if ( ch == 'c' - 'a' + 1 ) {	// ctrl-c clears the field
+		Field_Clear( edit );
+		return;
+	}
+
+	len = strlen( edit->buffer );
+
+	if ( ch == 'h' - 'a' + 1 )	{	// ctrl-h is backspace
+		if ( edit->cursor > 0 ) {
+			memmove( edit->buffer + edit->cursor - 1, 
+				edit->buffer + edit->cursor, len + 1 - edit->cursor );
+			edit->cursor--;
+			if ( edit->cursor < edit->scroll )
+			{
+				edit->scroll--;
+			}
+		}
+		return;
+	}
+
+	if ( ch == 'a' - 'a' + 1 ) {	// ctrl-a is home
+		edit->cursor = 0;
+		edit->scroll = 0;
+		return;
+	}
+
+	if ( ch == 'e' - 'a' + 1 ) {	// ctrl-e is end
+		edit->cursor = len;
+		edit->scroll = edit->cursor - edit->widthInChars;
+		return;
+	}
+
+	//
+	// ignore any other non printable chars
+	//
+	if ( ch < 32 ) {
+		return;
+	}
+
+	if ( kg.key_overstrikeMode ) {	
+		if ( edit->cursor == MAX_EDIT_LINE - 1 )
+			return;
+		edit->buffer[edit->cursor] = ch;
+		edit->cursor++;
+	} else {	// insert mode
+		if ( len == MAX_EDIT_LINE - 1 ) {
+			return; // all full
+		}
+		memmove( edit->buffer + edit->cursor + 1, 
+			edit->buffer + edit->cursor, len + 1 - edit->cursor );
+		edit->buffer[edit->cursor] = ch;
+		edit->cursor++;
+	}
+
+
+	if ( edit->cursor >= edit->widthInChars ) {
+		edit->scroll++;
+	}
+
+	if ( edit->cursor == len + 1) {
+		edit->buffer[edit->cursor] = 0;
+	}
+}
+
+/*
+==================
+Field_Clear
+==================
+*/
+void Field_Clear( field_t *edit ) {
+	edit->buffer[0] = 0;
+	edit->cursor = 0;
+	edit->scroll = 0;
+}
+
+/*
+=============================================================================
+
+CONSOLE LINE EDITING
+
+==============================================================================
+*/
+
+static const char *completionString;
+static char shortestMatch[MAX_TOKEN_CHARS];
+static int	matchCount;
+
+/*
+===============
+FindMatches
+
+===============
+*/
+static void FindMatches( const char *s ) {
+	int		i;
+
+	if ( Q_stricmpn( s, completionString, strlen( completionString ) ) ) {
+		return;
+	}
+	matchCount++;
+	if ( matchCount == 1 ) {
+		Q_strncpyz( shortestMatch, s, sizeof( shortestMatch ) );
+		return;
+	}
+
+	// cut shortestMatch to the amount common with s
+	for ( i = 0 ; s[i] ; i++ ) {
+		if ( tolower(shortestMatch[i]) != tolower(s[i]) ) {
+			shortestMatch[i] = 0;
+			break;
+		}
+	}
+	if (!s[i])
+	{
+		shortestMatch[i] = 0;
+	}
+}
+
+/*
+===============
+PrintMatches
+
+===============
+*/
+static void PrintMatches( const char *s ) {
+	if ( !Q_stricmpn( s, shortestMatch, strlen( shortestMatch ) ) ) {
+		Com_Printf( "    %s\n", s );
+	}
+}
+
+static void keyConcatArgs( void ) {
+	int		i;
+	char	*arg;
+
+	for ( i = 1 ; i < Cmd_Argc() ; i++ ) {
+		Q_strcat( kg.g_consoleField.buffer, sizeof( kg.g_consoleField.buffer ), " " );
+		arg = Cmd_Argv( i );
+		while (*arg) {
+			if (*arg == ' ') {
+				Q_strcat( kg.g_consoleField.buffer, sizeof( kg.g_consoleField.buffer ),  "\"");
+				break;
+			}
+			arg++;
+		}
+		Q_strcat( kg.g_consoleField.buffer, sizeof( kg.g_consoleField.buffer ),  Cmd_Argv( i ) );
+		if (*arg == ' ') {
+			Q_strcat( kg.g_consoleField.buffer, sizeof( kg.g_consoleField.buffer ),  "\"");
+		}
+	}
+}
+
+static void ConcatRemaining( const char *src, const char *start ) {
+	char *str;
+
+	str = strstr(src, start);
+	if (!str) {
+		keyConcatArgs();
+		return;
+	}
+
+	str += strlen(start);
+	Q_strcat( kg.g_consoleField.buffer, sizeof( kg.g_consoleField.buffer ), str);
+}
+
+
+/*
+===============
+CompleteCommand
+
+Tab expansion
+===============
+*/
+void CompleteCommand( void ) 
+{
+#ifndef _XBOX
+	field_t		*edit;
+	field_t		temp;
+
+	edit = &kg.g_consoleField;
+
+	// only look at the first token for completion purposes
+	Cmd_TokenizeString( edit->buffer );
+
+	completionString = Cmd_Argv(0);
+	if ( completionString[0] == '\\' || completionString[0] == '/' ) {
+		completionString++;
+	}
+	matchCount = 0;
+	shortestMatch[0] = 0;
+
+	if ( strlen( completionString ) == 0 ) {
+		return;
+	}
+
+	Cmd_CommandCompletion( FindMatches );
+	Cvar_CommandCompletion( FindMatches );
+
+	if ( matchCount == 0 ) {
+		return;	// no matches
+	}
+
+	Com_Memcpy(&temp, edit, sizeof(field_t));
+
+	if ( matchCount == 1 ) {
+		Com_sprintf( edit->buffer, sizeof( edit->buffer ), "\\%s", shortestMatch );
+		if ( Cmd_Argc() == 1 ) {
+			Q_strcat( kg.g_consoleField.buffer, sizeof( kg.g_consoleField.buffer ), " " );
+		} else {
+			ConcatRemaining( temp.buffer, completionString );
+		}
+		edit->cursor = strlen( edit->buffer );
+		return;
+	}
+
+	// multiple matches, complete to shortest
+	Com_sprintf( edit->buffer, sizeof( edit->buffer ), "\\%s", shortestMatch );
+	edit->cursor = strlen( edit->buffer );
+	ConcatRemaining( temp.buffer, completionString );
+
+	Com_Printf( "]%s\n", edit->buffer );
+
+	// run through again, printing matches
+	Cmd_CommandCompletion( PrintMatches );
+	Cvar_CommandCompletion( PrintMatches );
+#endif
+}
+
+
+/*
+====================
+Console_Key
+
+Handles history and console scrollback
+====================
+*/
+void Console_Key (int key) {
+	// ctrl-L clears screen
+	if ( keynames[ key ].lower == 'l' && kg.keys[A_CTRL].down ) {
+		Cbuf_AddText ("clear\n");
+		return;
+	}
+
+	// enter finishes the line
+	if ( key == A_ENTER || key == A_KP_ENTER ) {
+		// if not in the game explicitly prepent a slash if needed
+		if ( cls.state != CA_ACTIVE && kg.g_consoleField.buffer[0] != '\\' 
+			&& kg.g_consoleField.buffer[0] != '/' ) {
+			char	temp[MAX_STRING_CHARS];
+
+			Q_strncpyz( temp, kg.g_consoleField.buffer, sizeof( temp ) );
+			Com_sprintf( kg.g_consoleField.buffer, sizeof( kg.g_consoleField.buffer ), "\\%s", temp );
+			kg.g_consoleField.cursor++;
+		}
+		else
+		{	// Added this to automatically make explicit commands not need slashes.
+			CompleteCommand();
+		}
+
+		Com_Printf ( "]%s\n", kg.g_consoleField.buffer );
+
+		// leading slash is an explicit command
+		if ( kg.g_consoleField.buffer[0] == '\\' || kg.g_consoleField.buffer[0] == '/' ) {
+			if (cgvm && cl.mSharedMemory)
+			{ //don't do this unless cgame is inited and shared memory is valid
+				const char *buf = (kg.g_consoleField.buffer+1);
+				TCGIncomingConsoleCommand *icc = (TCGIncomingConsoleCommand *)cl.mSharedMemory;
+
+				strcpy(icc->conCommand, buf);
+				
+				if (VM_Call(cgvm, CG_INCOMING_CONSOLE_COMMAND))
+				{ //rww - let mod authors filter client console messages so they can cut them off if they want.
+					Cbuf_AddText( kg.g_consoleField.buffer+1 );	// valid command
+					Cbuf_AddText ("\n");
+				}
+				else if (icc->conCommand[0])
+				{ //the vm call says to execute this command in place
+					Cbuf_AddText( icc->conCommand );
+					Cbuf_AddText ("\n");
+				}
+			}
+			else
+			{ //just exec it then
+				Cbuf_AddText( kg.g_consoleField.buffer+1 );	// valid command
+				Cbuf_AddText ("\n");
+			}
+		} else {
+			// other text will be chat messages
+			if ( !kg.g_consoleField.buffer[0] ) {
+				return;	// empty lines just scroll the console without adding to history
+			} else {
+				Cbuf_AddText ("cmd say ");
+				Cbuf_AddText( kg.g_consoleField.buffer );
+				Cbuf_AddText ("\n");
+			}
+		}
+
+		// copy line to history buffer
+		kg.historyEditLines[kg.nextHistoryLine % COMMAND_HISTORY] = kg.g_consoleField;
+		kg.nextHistoryLine++;
+		kg.historyLine = kg.nextHistoryLine;
+
+		Field_Clear( &kg.g_consoleField );
+
+		kg.g_consoleField.widthInChars = g_console_field_width;
+
+		if ( cls.state == CA_DISCONNECTED ) {
+			SCR_UpdateScreen ();	// force an update, because the command
+		}							// may take some time
+		return;
+	}
+
+	// command completion
+
+	if (key == A_TAB) {
+		CompleteCommand();
+		return;
+	}
+
+	// command history (ctrl-p ctrl-n for unix style)
+
+	if ( ( key == A_CURSOR_UP ) || ( ( keynames[ key ].lower == 'p' ) && kg.keys[A_CTRL].down ) ) 
+	{
+		if ( kg.nextHistoryLine - kg.historyLine < COMMAND_HISTORY && kg.historyLine > 0 ) 
+		{
+			kg.historyLine--;
+		}
+		kg.g_consoleField = kg.historyEditLines[ kg.historyLine % COMMAND_HISTORY ];
+		return;
+	}
+
+	if ( ( key == A_CURSOR_DOWN ) || ( ( keynames[ key ].lower == 'n' ) && kg.keys[A_CTRL].down ) ) 
+	{
+		if (kg.historyLine == kg.nextHistoryLine)
+			return;
+		kg.historyLine++;
+		kg.g_consoleField = kg.historyEditLines[ kg.historyLine % COMMAND_HISTORY ];
+		return;
+	}
+
+	// console scrolling
+	if ( key == A_PAGE_UP ) {
+		Con_PageUp();
+		return;
+	}
+
+	if ( key == A_PAGE_DOWN ) {
+		Con_PageDown();
+		return;
+	}
+
+	// ctrl-home = top of console
+	if ( key == A_HOME && kg.keys[A_CTRL].down ) {
+		Con_Top();
+		return;
+	}
+
+	// ctrl-end = bottom of console
+	if ( key == A_END && kg.keys[A_CTRL].down ) {
+		Con_Bottom();
+		return;
+	}
+
+	// pass to the normal editline routine
+	Field_KeyDownEvent( &kg.g_consoleField, key );
+}
+
+//============================================================================
+
+
+/*
+================
+Message_Key
+
+In game talk message
+================
+*/
+void Message_Key( int key ) {
+
+	char	buffer[MAX_STRING_CHARS];
+
+
+	if (key == A_ESCAPE) {
+		cls.keyCatchers &= ~KEYCATCH_MESSAGE;
+		Field_Clear( &chatField );
+		return;
+	}
+
+	if ( key == A_ENTER || key == A_KP_ENTER )
+	{
+		if ( chatField.buffer[0] && cls.state == CA_ACTIVE ) {
+			if (chat_playerNum != -1 )
+
+				Com_sprintf( buffer, sizeof( buffer ), "tell %i \"%s\"\n", chat_playerNum, chatField.buffer );
+
+			else if (chat_team)
+
+				Com_sprintf( buffer, sizeof( buffer ), "say_team \"%s\"\n", chatField.buffer );
+			else
+				Com_sprintf( buffer, sizeof( buffer ), "say \"%s\"\n", chatField.buffer );
+
+
+
+			CL_AddReliableCommand( buffer );
+		}
+		cls.keyCatchers &= ~KEYCATCH_MESSAGE;
+		Field_Clear( &chatField );
+		return;
+	}
+
+	Field_KeyDownEvent( &chatField, key );
+}
+
+//============================================================================
+
+
+qboolean Key_GetOverstrikeMode( void ) {
+	return kg.key_overstrikeMode;
+}
+
+
+void Key_SetOverstrikeMode( qboolean state ) {
+	kg.key_overstrikeMode = state;
+}
+
+
+/*
+===================
+Key_IsDown
+===================
+*/
+qboolean Key_IsDown( int keynum ) {
+	if ( keynum == -1 ) {
+		return qfalse;
+	}
+
+	return kg.keys[ keynames[keynum].upper ].down;
+}
+
+
+/*
+===================
+Key_StringToKeynum
+
+Returns a key number to be used to index keys[] by looking at
+the given string.  Single ascii characters return themselves, while
+the K_* names are matched up.
+
+0x11 will be interpreted as raw hex, which will allow new controlers
+to be configured even if they don't have defined names.
+===================
+*/
+int Key_StringToKeynum( char *str ) {
+	int			i;
+	
+	if ( !str || !str[0] ) 
+	{
+		return -1;
+	}
+	// If single char bind, presume ascii char bind
+	if ( !str[1] ) 
+	{
+		return keynames[ (unsigned char)str[0] ].upper;
+	}
+
+	// scan for a text match
+	for ( i = 0 ; i < MAX_KEYS ; i++ ) 
+	{
+		if ( keynames[i].name && !stricmp( str, keynames[i].name ) )
+		{
+			return keynames[i].keynum;
+		}
+	}
+
+	// check for hex code
+	if ( str[0] == '0' && str[1] == 'x' && strlen( str ) == 4) 
+	{
+		int		n1, n2;
+		
+		n1 = str[2];
+		if ( n1 >= '0' && n1 <= '9' ) 
+		{
+			n1 -= '0';
+		}
+		else if ( n1 >= 'A' && n1 <= 'F' ) 
+		{
+			n1 = n1 - 'A' + 10;
+		}
+		else 
+		{
+			n1 = 0;
+		}
+
+		n2 = str[3];
+		if ( n2 >= '0' && n2 <= '9' ) 
+		{
+			n2 -= '0';
+		}
+		else if ( n2 >= 'A' && n2 <= 'F' ) 
+		{
+			n2 = n2 - 'A' + 10;
+		}
+		else 
+		{
+			n2 = 0;
+		}
+		return n1 * 16 + n2;
+	}
+
+	return -1;
+}
+
+
+static char tinyString[16];
+static const char *Key_KeynumValid( int keynum )
+{
+	if ( keynum == -1 ) 
+	{
+		return "<KEY NOT FOUND>";
+	}
+	if ( keynum < 0 || keynum >= MAX_KEYS ) 
+	{
+		return "<OUT OF RANGE>";
+	}
+	return NULL;
+}
+
+static const char *Key_KeyToName( int keynum )
+{
+	return keynames[keynum].name;
+}
+
+
+static const char *Key_KeyToAscii( int keynum )
+{
+	if(!keynames[keynum].lower)
+	{
+		return(NULL);
+	}
+	if(keynum == A_SPACE)
+	{
+		tinyString[0] = (char)A_SHIFT_SPACE;
+	}
+	else if(keynum == A_ENTER)
+	{
+		tinyString[0] = (char)A_SHIFT_ENTER;
+	}
+	else if(keynum == A_KP_ENTER)
+	{
+		tinyString[0] = (char)A_SHIFT_KP_ENTER;
+	}
+	else
+	{
+		tinyString[0] = keynames[keynum].upper;
+	}
+	tinyString[1] = 0;
+	return tinyString;
+}
+
+static const char *Key_KeyToHex( int keynum )
+{
+	int		i, j;
+
+	i = keynum >> 4;
+	j = keynum & 15;
+
+	tinyString[0] = '0';
+	tinyString[1] = 'x';
+	tinyString[2] = i > 9 ? i - 10 + 'A' : i + '0';
+	tinyString[3] = j > 9 ? j - 10 + 'A' : j + '0';
+	tinyString[4] = 0;
+
+	return tinyString;
+}
+
+// Returns the ascii code of the keynum
+const char *Key_KeynumToAscii( int keynum ) 
+{
+	const char	*name;
+
+	name = Key_KeynumValid(keynum);
+
+	// check for printable ascii
+	if ( !name && keynum > 0 && keynum < 256 ) 
+	{
+		name = Key_KeyToAscii(keynum);
+	}
+	// Check for name (for JOYx and AUXx buttons)
+	if ( !name )
+	{
+		name = Key_KeyToName(keynum);
+	}
+	// Fallback to hex number
+	if ( !name )
+	{
+		name = Key_KeyToHex(keynum);
+	}
+	return name;
+}
+
+
+/*
+===================
+Key_KeynumToString
+
+Returns a string (either a single ascii char, a K_* name, or a 0x11 hex string) for the
+given keynum.
+===================
+*/
+// Returns a console/config file friendly name for the key
+const char *Key_KeynumToString( int keynum ) 
+{
+	const char	*name;
+
+	name = Key_KeynumValid(keynum);
+
+	// Check for friendly name
+	if ( !name )
+	{
+		name = Key_KeyToName(keynum);
+	}
+	// check for printable ascii
+	if ( !name && keynum > 0 && keynum < 256) 
+	{
+		name = Key_KeyToAscii(keynum);
+	}
+	// Fallback to hex number
+	if ( !name )
+	{
+		name = Key_KeyToHex(keynum);
+	}
+	return name;
+}
+
+
+
+/*
+===================
+Key_SetBinding
+===================
+*/
+void Key_SetBinding( int keynum, const char *binding ) {
+	if ( keynum == -1 ) {
+		return;
+	}
+
+	// free old bindings
+	if ( kg.keys[ keynames[keynum].upper ].binding ) {
+		Z_Free( kg.keys[ keynames[keynum].upper ].binding );
+		kg.keys[ keynames[keynum].upper ].binding = NULL;
+	}
+			
+	// allocate memory for new binding
+	if (binding)
+	{
+		kg.keys[ keynames[keynum].upper ].binding = CopyString( binding );
+	}
+
+	// consider this like modifying an archived cvar, so the
+	// file write will be triggered at the next oportunity
+	cvar_modifiedFlags |= CVAR_ARCHIVE;
+}
+
+
+/*
+===================
+Key_GetBinding
+===================
+*/
+char *Key_GetBinding( int keynum ) {
+	if ( keynum == -1 ) {
+		return "";
+	}
+
+	return kg.keys[ keynum ].binding;
+}
+
+/* 
+===================
+Key_GetKey
+===================
+*/
+
+int Key_GetKey(const char *binding) {
+  int i;
+
+  if (binding) {
+  	for (i=0 ; i<256 ; i++) {
+      if (kg.keys[i].binding && Q_stricmp(binding, kg.keys[i].binding) == 0) {
+        return i;
+      }
+    }
+  }
+  return -1;
+}
+
+/*
+===================
+Key_Unbind_f
+===================
+*/
+void Key_Unbind_f (void)
+{
+	int		b;
+
+	if (Cmd_Argc() != 2)
+	{
+		Com_Printf ("unbind <key> : remove commands from a key\n");
+		return;
+	}
+	
+	b = Key_StringToKeynum (Cmd_Argv(1));
+	if (b==-1)
+	{
+		Com_Printf ("\"%s\" isn't a valid key\n", Cmd_Argv(1));
+		return;
+	}
+
+	Key_SetBinding (b, "");
+}
+
+/*
+===================
+Key_Unbindall_f
+===================
+*/
+void Key_Unbindall_f (void)
+{
+	int		i;
+	
+	for (i = 0; i < MAX_KEYS ; i++)
+	{
+		if (kg.keys[i].binding)
+		{
+			Key_SetBinding (i, "");
+		}
+	}
+}
+
+
+
+/*
+===================
+Key_Bind_f
+===================
+*/
+void Key_Bind_f (void)
+{
+	int			i, c, b;
+	char		cmd[1024];
+	
+	c = Cmd_Argc();
+
+	if (c < 2)
+	{
+		Com_Printf ("bind <key> [command] : attach a command to a key\n");
+		return;
+	}
+	b = Key_StringToKeynum (Cmd_Argv(1));
+	if (b==-1)
+	{
+		Com_Printf ("\"%s\" isn't a valid key\n", Cmd_Argv(1));
+		return;
+	}
+
+	if (c == 2)
+	{
+		if (kg.keys[b].binding)
+			Com_Printf ("\"%s\" = \"%s\"\n", Cmd_Argv(1), kg.keys[b].binding );
+		else
+			Com_Printf ("\"%s\" is not bound\n", Cmd_Argv(1) );
+		return;
+	}
+	
+// copy the rest of the command line
+	cmd[0] = 0;		// start out with a null string
+	for (i=2 ; i< c ; i++)
+	{
+		strcat (cmd, Cmd_Argv(i));
+		if (i != (c-1))
+			strcat (cmd, " ");
+	}
+
+	Key_SetBinding (b, cmd);
+}
+
+/*
+============
+Key_WriteBindings
+
+Writes lines containing "bind key value"
+============
+*/
+void Key_WriteBindings( fileHandle_t f ) {
+	int		i;
+
+	FS_Printf (f, "unbindall\n" );
+	for (i=0 ; i<MAX_KEYS ; i++) {
+		if (kg.keys[i].binding && kg.keys[i].binding[0] ) {
+			FS_Printf (f, "bind %s \"%s\"\n", Key_KeynumToString(i), kg.keys[i].binding);
+		}
+	}
+}
+
+
+
+
+/*
+============
+Key_Bindlist_f
+
+============
+*/
+void Key_Bindlist_f( void ) {
+	int		i;
+
+	for ( i = 0 ; i < MAX_KEYS ; i++ ) {
+		if ( kg.keys[i].binding && kg.keys[i].binding[0] ) {
+			Com_Printf( "Key : %s (%s) \"%s\"\n", Key_KeynumToAscii(i), Key_KeynumToString(i), kg.keys[i].binding );
+		}
+	}
+}
+
+
+/*
+===================
+CL_InitKeyCommands
+===================
+*/
+void CL_InitKeyCommands( void ) {
+	// register our functions
+	Cmd_AddCommand ("bind",Key_Bind_f);
+	Cmd_AddCommand ("unbind",Key_Unbind_f);
+	Cmd_AddCommand ("unbindall",Key_Unbindall_f);
+	Cmd_AddCommand ("bindlist",Key_Bindlist_f);
+}
+
+/*
+===================
+CL_AddKeyUpCommands
+===================
+*/
+void CL_AddKeyUpCommands( int key, char *kb ) {
+	int i;
+	char button[1024], *buttonPtr;
+	char	cmd[1024];
+	qboolean keyevent;
+
+	if ( !kb ) {
+		return;
+	}
+	keyevent = qfalse;
+	buttonPtr = button;
+	for ( i = 0; ; i++ ) {
+		if ( kb[i] == ';' || !kb[i] ) {
+			*buttonPtr = '\0';
+			if ( button[0] == '+') {
+				// button commands add keynum and time as parms so that multiple
+				// sources can be discriminated and subframe corrected
+				Com_sprintf (cmd, sizeof(cmd), "-%s %i %i\n", button+1, key, time);
+				Cbuf_AddText (cmd);
+				keyevent = qtrue;
+			} else {
+				if (keyevent) {
+					// down-only command
+					Cbuf_AddText (button);
+					Cbuf_AddText ("\n");
+				}
+			}
+			buttonPtr = button;
+			while ( (kb[i] <= ' ' || kb[i] == ';') && kb[i] != 0 ) {
+				i++;
+			}
+		}
+		*buttonPtr++ = kb[i];
+		if ( !kb[i] ) {
+			break;
+		}
+	}
+}
+
+/*
+===================
+CL_KeyEvent
+
+Called by the system for both key up and key down events
+===================
+*/
+void CL_KeyEvent (int key, qboolean down, unsigned time) {
+	char	*kb;
+	char	cmd[1024];
+
+	// update auto-repeat status and BUTTON_ANY status
+	kg.keys[ keynames[key].upper ].down = down;
+	if (down)
+	{
+		kg.keys[ keynames[key].upper ].repeats++;
+		if ( kg.keys[ keynames[key].upper ].repeats == 1)
+		{
+			kg.anykeydown = qtrue;
+			kg.keyDownCount++;
+		}
+	}
+	else
+	{
+		kg.keys[ keynames[key].upper ].repeats = 0;
+		kg.keyDownCount--;
+		if(kg.keyDownCount <= 0)
+		{
+			kg.anykeydown = qfalse;
+			kg.keyDownCount = 0;
+		}
+	}
+
+	// console key is hardcoded, so the user can never unbind it
+#ifndef _XBOX	// No console on Xbox
+	if (key == A_CONSOLE) {
+		if (!down) {
+			return;
+
+		}
+#ifdef FINAL_BUILD
+		if (!(cls.keyCatchers & KEYCATCH_CONSOLE) && !kg.keys[A_SHIFT].down )	//we're not in the console
+		{//so we require the control kg.keys to get in
+			return;
+		}
+#endif
+	    Con_ToggleConsole_f ();
+		return;
+	}
+#endif
+
+	// kg.keys can still be used for bound actions
+	if ( down && /*( key < 128 || key == A_MOUSE1 ) && */
+#ifdef _XBOX	// No demos on Xbox
+		( cls.state == CA_CINEMATIC ) &&
+#else
+		( clc.demoplaying || cls.state == CA_CINEMATIC ) &&
+#endif
+		!cls.keyCatchers) {
+
+		if (Cvar_VariableValue ("com_cameraMode") == 0) {
+			Cvar_Set ("nextdemo","");
+			key = A_ESCAPE;
+		}
+	}
+
+
+	// escape is always handled special
+	if ( key == A_ESCAPE && down ) {
+		if ( cls.keyCatchers & KEYCATCH_MESSAGE ) {
+			// clear message mode
+			Message_Key( key );
+			return;
+		}
+
+		// escape always gets out of CGAME stuff
+		if (cls.keyCatchers & KEYCATCH_CGAME) {
+			cls.keyCatchers &= ~KEYCATCH_CGAME;
+			VM_Call (cgvm, CG_EVENT_HANDLING, CGAME_EVENT_NONE);
+			return;
+		}
+
+		if ( !( cls.keyCatchers & KEYCATCH_UI ) ) {
+#ifdef _XBOX	// No demos on Xbox
+			if ( cls.state == CA_ACTIVE ) {
+#else
+			if ( cls.state == CA_ACTIVE && !clc.demoplaying ) {
+#endif
+				VM_Call( uivm, UI_SET_ACTIVE_MENU, UIMENU_INGAME );
+			}
+			else {
+				CL_Disconnect_f();
+				S_StopAllSounds();
+				VM_Call( uivm, UI_SET_ACTIVE_MENU, UIMENU_MAIN );
+			}
+			return;
+		}
+
+		VM_Call( uivm, UI_KEY_EVENT, key, down );
+		return;
+	}
+
+	//
+	// key up events only perform actions if the game key binding is
+	// a button command (leading + sign).  These will be processed even in
+	// console mode and menu mode, to keep the character from continuing 
+	// an action started before a mode switch.
+	//
+	if (!down) {
+		kb = kg.keys[ keynames[key].upper ].binding;
+
+		CL_AddKeyUpCommands( key, kb );
+
+		if ( cls.keyCatchers & KEYCATCH_UI && uivm ) {
+			VM_Call( uivm, UI_KEY_EVENT, key, down );
+		} else if ( cls.keyCatchers & KEYCATCH_CGAME && cgvm ) {
+			VM_Call( cgvm, CG_KEY_EVENT, key, down );
+		} 
+
+		return;
+	}
+
+
+	// distribute the key down event to the apropriate handler
+	if ( cls.keyCatchers & KEYCATCH_CONSOLE ) {
+		Console_Key( key );
+	} else if ( cls.keyCatchers & KEYCATCH_UI ) {
+		if ( uivm ) {
+			VM_Call( uivm, UI_KEY_EVENT, key, down );
+		} 
+	} else if ( cls.keyCatchers & KEYCATCH_CGAME ) {
+		if ( cgvm ) {
+			VM_Call( cgvm, CG_KEY_EVENT, key, down );
+		} 
+	} else if ( cls.keyCatchers & KEYCATCH_MESSAGE ) {
+		Message_Key( key );
+	} else if ( cls.state == CA_DISCONNECTED ) {
+		Console_Key( key );
+	} else {
+		// send the bound action
+		kb = kg.keys[ keynames[key].upper ].binding;
+		if (kb)
+		{
+			if (kb[0] == '+') {	
+				int i;
+				char button[1024], *buttonPtr;
+				buttonPtr = button;
+				for ( i = 0; ; i++ ) {
+					if ( kb[i] == ';' || !kb[i] ) {
+						*buttonPtr = '\0';
+						if ( button[0] == '+') {
+							// button commands add keynum and time as parms so that multiple
+							// sources can be discriminated and subframe corrected
+							Com_sprintf (cmd, sizeof(cmd), "%s %i %i\n", button, key, time);
+							Cbuf_AddText (cmd);
+						} else {
+							// down-only command
+							Cbuf_AddText (button);
+							Cbuf_AddText ("\n");
+						}
+						buttonPtr = button;
+						while ( (kb[i] <= ' ' || kb[i] == ';') && kb[i] != 0 ) {
+							i++;
+						}
+					}
+					*buttonPtr++ = kb[i];
+					if ( !kb[i] ) {
+						break;
+					}
+				}
+			} else {
+				// down-only command
+				if (cgvm && cl.mSharedMemory)
+				{ //don't do this unless cgame is inited and shared memory is valid
+					TCGIncomingConsoleCommand *icc = (TCGIncomingConsoleCommand *)cl.mSharedMemory;
+
+					strcpy(icc->conCommand, kb);
+					
+					if (VM_Call(cgvm, CG_INCOMING_CONSOLE_COMMAND))
+					{ //rww - let mod authors filter client console messages so they can cut them off if they want.
+						Cbuf_AddText (kb);
+						Cbuf_AddText ("\n");
+					}
+					else if (icc->conCommand[0])
+					{ //the vm call says to execute this command in place
+						Cbuf_AddText( icc->conCommand );
+						Cbuf_AddText ("\n");
+					}
+				}
+				else
+				{ //otherwise just add it
+					Cbuf_AddText (kb);
+					Cbuf_AddText ("\n");
+				}
+			}
+		}
+	}
+}
+
+
+/*
+===================
+CL_CharEvent
+
+Normal keyboard characters, already shifted / capslocked / etc
+===================
+*/
+void CL_CharEvent( int key ) {
+	// the console key should never be used as a char
+	if ( key == '`' || key == '~' ) {
+		return;
+	}
+
+	// distribute the key down event to the apropriate handler
+	if ( cls.keyCatchers & KEYCATCH_CONSOLE )
+	{
+		Field_CharEvent( &kg.g_consoleField, key );
+	}
+	else if ( cls.keyCatchers & KEYCATCH_UI )
+	{
+		VM_Call( uivm, UI_KEY_EVENT, key | K_CHAR_FLAG, qtrue );
+	}
+	else if ( cls.keyCatchers & KEYCATCH_MESSAGE ) 
+	{
+		Field_CharEvent( &chatField, key );
+	}
+	else if ( cls.state == CA_DISCONNECTED )
+	{
+		Field_CharEvent( &kg.g_consoleField, key );
+	}
+}
+
+
+/*
+===================
+Key_ClearStates
+===================
+*/
+void Key_ClearStates (void)
+{
+	int		i;
+
+	kg.anykeydown = qfalse;
+
+	for ( i=0 ; i < MAX_KEYS ; i++ ) {
+		if ( kg.keys[i].down ) {
+			CL_KeyEvent( i, qfalse, 0 );
+
+		}
+		kg.keys[i].down = (qboolean)0;
+		kg.keys[i].repeats = 0;
+	}
+}
+
diff --git a/codemp/client/cl_main.cpp b/codemp/client/cl_main.cpp
new file mode 100644
index 0000000..9c9af3d
--- /dev/null
+++ b/codemp/client/cl_main.cpp
@@ -0,0 +1,3679 @@
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+// cl_main.c  -- client main loop
+
+#include "client.h"
+#include "../qcommon/stringed_ingame.h"
+#include <limits.h>
+#ifdef _XBOX
+#include "snd_local_console.h"
+#include "../xbox/XBLive.h"
+#include "../xbox/XBoxCommon.h"
+#else
+#include "snd_local.h"
+#endif
+
+//rwwRMG - added:
+#include "..\qcommon\cm_local.h"
+#include "..\qcommon\cm_landscape.h"
+
+#if !defined(G2_H_INC)
+	#include "..\ghoul2\G2_local.h"
+#endif
+
+#if !defined (MINIHEAP_H_INC)
+#include "../qcommon/miniheap.h"
+#endif
+
+#ifdef _DONETPROFILE_
+#include "../qcommon/INetProfile.h"
+#endif
+
+#if 0 //rwwFIXMEFIXME: Disable this before release!!!!!! I am just trying to find a crash bug.
+#include "../renderer/tr_local.h"
+#endif
+
+#ifdef _XBOX
+#include "../renderer/tr_local.h"
+#endif
+
+cvar_t	*cl_nodelta;
+cvar_t	*cl_debugMove;
+
+cvar_t	*cl_noprint;
+cvar_t	*cl_motd;
+
+cvar_t	*rcon_client_password;
+cvar_t	*rconAddress;
+
+cvar_t	*cl_timeout;
+cvar_t	*cl_maxpackets;
+cvar_t	*cl_packetdup;
+cvar_t	*cl_timeNudge;
+cvar_t	*cl_showTimeDelta;
+cvar_t	*cl_freezeDemo;
+
+cvar_t	*cl_shownet;
+cvar_t	*cl_showSend;
+cvar_t	*cl_timedemo;
+cvar_t	*cl_avidemo;
+cvar_t	*cl_forceavidemo;
+
+cvar_t	*cl_freelook;
+cvar_t	*cl_sensitivity;
+
+cvar_t	*cl_mouseAccel;
+cvar_t	*cl_showMouseRate;
+
+cvar_t	*m_pitchVeh;
+cvar_t	*m_pitch;
+cvar_t	*m_yaw;
+cvar_t	*m_forward;
+cvar_t	*m_side;
+cvar_t	*m_filter;
+
+#ifdef _XBOX
+//MAP HACK
+cvar_t	*cl_mapname;
+#endif
+
+cvar_t	*cl_activeAction;
+
+cvar_t	*cl_motdString;
+
+cvar_t	*cl_allowDownload;
+cvar_t	*cl_allowAltEnter;
+cvar_t	*cl_conXOffset;
+cvar_t	*cl_inGameVideo;
+
+cvar_t	*cl_serverStatusResendTime;
+cvar_t	*cl_trn;
+cvar_t	*cl_framerate;
+
+cvar_t	*cl_autolodscale;
+
+vec3_t cl_windVec;
+
+#ifdef USE_CD_KEY
+char	cl_cdkey[34] = "                                ";
+
+
+#endif	// USE_CD_KEY
+
+
+clientActive_t		cl;
+clientConnection_t	clc;
+clientStatic_t		cls;
+vm_t				*cgvm;
+
+// Structure containing functions exported from refresh DLL
+refexport_t	re;
+
+ping_t	cl_pinglist[MAX_PINGREQUESTS];
+
+typedef struct serverStatus_s
+{
+	char string[BIG_INFO_STRING];
+	netadr_t address;
+	int time, startTime;
+	qboolean pending;
+	qboolean print;
+	qboolean retrieved;
+} serverStatus_t;
+
+serverStatus_t cl_serverStatusList[MAX_SERVERSTATUSREQUESTS];
+int serverStatusCount;
+
+CMiniHeap *G2VertSpaceClient = 0;
+
+#if defined __USEA3D && defined __A3D_GEOM
+	void hA3Dg_ExportRenderGeom (refexport_t *incoming_re);
+#endif
+
+extern void SV_BotFrame( int time );
+void CL_CheckForResend( void );
+void CL_ShowIP_f(void);
+void CL_ServerStatus_f(void);
+void CL_ServerStatusResponse( netadr_t from, msg_t *msg );
+
+/*
+=======================================================================
+
+CLIENT RELIABLE COMMAND COMMUNICATION
+
+=======================================================================
+*/
+
+/*
+======================
+CL_AddReliableCommand
+
+The given command will be transmitted to the server, and is gauranteed to
+not have future usercmd_t executed before it is executed
+======================
+*/
+void CL_AddReliableCommand( const char *cmd ) {
+	int		index;
+
+	// if we would be losing an old command that hasn't been acknowledged,
+	// we must drop the connection
+	if ( clc.reliableSequence - clc.reliableAcknowledge > MAX_RELIABLE_COMMANDS ) {
+		Com_Error( ERR_DROP, "Client command overflow" );
+	}
+	clc.reliableSequence++;
+	index = clc.reliableSequence & ( MAX_RELIABLE_COMMANDS - 1 );
+	Q_strncpyz( clc.reliableCommands[ index ], cmd, sizeof( clc.reliableCommands[ index ] ) );
+}
+
+/*
+======================
+CL_ChangeReliableCommand
+======================
+*/
+void CL_ChangeReliableCommand( void ) {
+	int r, index, l;
+
+	r = clc.reliableSequence - ((int)(random()) * 5);
+	index = clc.reliableSequence & ( MAX_RELIABLE_COMMANDS - 1 );
+	l = strlen(clc.reliableCommands[ index ]);
+	if ( l >= MAX_STRING_CHARS - 1 ) {
+		l = MAX_STRING_CHARS - 2;
+	}
+	clc.reliableCommands[ index ][ l ] = '\n';
+	clc.reliableCommands[ index ][ l+1 ] = '\0';
+}
+
+/*
+======================
+CL_MakeMonkeyDoLaundry
+======================
+*/
+void CL_MakeMonkeyDoLaundry( void ) {
+	if ( Sys_MonkeyShouldBeSpanked() ) {
+		if ( !(cls.framecount & 255) ) {
+			if ( random() < 0.1 ) {
+				CL_ChangeReliableCommand();
+			}
+		}
+	}
+}
+
+/*
+=======================================================================
+
+CLIENT SIDE DEMO RECORDING
+
+=======================================================================
+*/
+
+/*
+====================
+CL_WriteDemoMessage
+
+Dumps the current net message, prefixed by the length
+====================
+*/
+#ifndef _XBOX	// No demos on Xbox
+void CL_WriteDemoMessage ( msg_t *msg, int headerBytes ) {
+	int		len, swlen;
+
+	// write the packet sequence
+	len = clc.serverMessageSequence;
+	swlen = LittleLong( len );
+	FS_Write (&swlen, 4, clc.demofile);
+
+	// skip the packet sequencing information
+	len = msg->cursize - headerBytes;
+	swlen = LittleLong(len);
+	FS_Write (&swlen, 4, clc.demofile);
+	FS_Write ( msg->data + headerBytes, len, clc.demofile );
+}
+
+
+/*
+====================
+CL_StopRecording_f
+
+stop recording a demo
+====================
+*/
+void CL_StopRecord_f( void ) {
+	int		len;
+
+	if ( !clc.demorecording ) {
+		Com_Printf ("Not recording a demo.\n");
+		return;
+	}
+
+	// finish up
+	len = -1;
+	FS_Write (&len, 4, clc.demofile);
+	FS_Write (&len, 4, clc.demofile);
+	FS_FCloseFile (clc.demofile);
+	clc.demofile = 0;
+	clc.demorecording = qfalse;
+	clc.spDemoRecording = qfalse;
+	Com_Printf ("Stopped demo.\n");
+}
+
+/* 
+================== 
+CL_DemoFilename
+================== 
+*/  
+void CL_DemoFilename( int number, char *fileName ) {
+	int		a,b,c,d;
+
+	if ( number < 0 || number > 9999 ) {
+		Com_sprintf( fileName, MAX_OSPATH, "demo9999.tga" );
+		return;
+	}
+
+	a = number / 1000;
+	number -= a*1000;
+	b = number / 100;
+	number -= b*100;
+	c = number / 10;
+	number -= c*10;
+	d = number;
+
+	Com_sprintf( fileName, MAX_OSPATH, "demo%i%i%i%i"
+		, a, b, c, d );
+}
+
+/*
+====================
+CL_Record_f
+
+record <demoname>
+
+Begins recording a demo from the current position
+====================
+*/
+static char		demoName[MAX_QPATH];	// compiler bug workaround
+void CL_Record_f( void ) {
+	char		name[MAX_OSPATH];
+	byte		bufData[MAX_MSGLEN];
+	msg_t	buf;
+	int			i;
+	int			len;
+	entityState_t	*ent;
+	entityState_t	nullstate;
+	char		*s;
+
+	if ( Cmd_Argc() > 2 ) {
+		Com_Printf ("record <demoname>\n");
+		return;
+	}
+
+	if ( clc.demorecording ) {
+		if (!clc.spDemoRecording) {
+			Com_Printf ("Already recording.\n");
+		}
+		return;
+	}
+
+	if ( cls.state != CA_ACTIVE ) {
+		Com_Printf ("You must be in a level to record.\n");
+		return;
+	}
+
+	if ( !Cvar_VariableValue( "g_synchronousClients" ) ) {
+		Com_Printf ("The server must have 'g_synchronousClients 1' set for demos\n");
+		return;
+	}
+
+	if ( Cmd_Argc() == 2 ) {
+		s = Cmd_Argv(1);
+		Q_strncpyz( demoName, s, sizeof( demoName ) );
+		Com_sprintf (name, sizeof(name), "demos/%s.dm_%d", demoName, PROTOCOL_VERSION );
+	} else {
+		int		number;
+
+		// scan for a free demo name
+		for ( number = 0 ; number <= 9999 ; number++ ) {
+			CL_DemoFilename( number, demoName );
+			Com_sprintf (name, sizeof(name), "demos/%s.dm_%d", demoName, PROTOCOL_VERSION );
+
+			len = FS_ReadFile( name, NULL );
+			if ( len <= 0 ) {
+				break;	// file doesn't exist
+			}
+		}
+	}
+
+	// open the demo file
+
+	Com_Printf ("recording to %s.\n", name);
+	clc.demofile = FS_FOpenFileWrite( name );
+	if ( !clc.demofile ) {
+		Com_Printf ("ERROR: couldn't open.\n");
+		return;
+	}
+	clc.demorecording = qtrue;
+	if (Cvar_VariableValue("ui_recordSPDemo")) {
+	  clc.spDemoRecording = qtrue;
+	} else {
+	  clc.spDemoRecording = qfalse;
+	}
+
+
+	Q_strncpyz( clc.demoName, demoName, sizeof( clc.demoName ) );
+
+	// don't start saving messages until a non-delta compressed message is received
+	clc.demowaiting = qtrue;
+
+	// write out the gamestate message
+	MSG_Init (&buf, bufData, sizeof(bufData));
+	MSG_Bitstream(&buf);
+
+	// NOTE, MRE: all server->client messages now acknowledge
+	MSG_WriteLong( &buf, clc.reliableSequence );
+
+	MSG_WriteByte (&buf, svc_gamestate);
+	MSG_WriteLong (&buf, clc.serverCommandSequence );
+
+	// configstrings
+	for ( i = 0 ; i < MAX_CONFIGSTRINGS ; i++ ) {
+		if ( !cl.gameState.stringOffsets[i] ) {
+			continue;
+		}
+		s = cl.gameState.stringData + cl.gameState.stringOffsets[i];
+		MSG_WriteByte (&buf, svc_configstring);
+		MSG_WriteShort (&buf, i);
+		MSG_WriteBigString (&buf, s);
+	}
+
+	// baselines
+	Com_Memset (&nullstate, 0, sizeof(nullstate));
+	for ( i = 0; i < MAX_GENTITIES ; i++ ) {
+		ent = &cl.entityBaselines[i];
+		if ( !ent->number ) {
+			continue;
+		}
+		MSG_WriteByte (&buf, svc_baseline);		
+		MSG_WriteDeltaEntity (&buf, &nullstate, ent, qtrue );
+	}
+
+	MSG_WriteByte( &buf, svc_EOF );
+	
+	// finished writing the gamestate stuff
+
+	// write the client num
+	MSG_WriteLong(&buf, clc.clientNum);
+	// write the checksum feed
+	MSG_WriteLong(&buf, clc.checksumFeed);
+
+	// RMG stuff
+	if ( clc.rmgHeightMapSize )
+	{
+		int i;
+
+		// Height map
+		MSG_WriteShort ( &buf, (unsigned short)clc.rmgHeightMapSize );
+		MSG_WriteBits ( &buf, 0, 1 );
+		MSG_WriteData( &buf, clc.rmgHeightMap, clc.rmgHeightMapSize );
+
+		// Flatten map
+		MSG_WriteShort ( &buf, (unsigned short)clc.rmgHeightMapSize );
+		MSG_WriteBits ( &buf, 0, 1 );
+		MSG_WriteData( &buf, clc.rmgFlattenMap, clc.rmgHeightMapSize );
+
+		// Seed 
+		MSG_WriteLong ( &buf, clc.rmgSeed );
+
+		// Automap symbols
+		MSG_WriteShort ( &buf, (unsigned short)clc.rmgAutomapSymbolCount );
+		for ( i = 0; i < clc.rmgAutomapSymbolCount; i ++ )
+		{
+			MSG_WriteByte ( &buf, (unsigned char)clc.rmgAutomapSymbols[i].mType );
+			MSG_WriteByte ( &buf, (unsigned char)clc.rmgAutomapSymbols[i].mSide );
+			MSG_WriteLong ( &buf, (long)clc.rmgAutomapSymbols[i].mOrigin[0] );
+			MSG_WriteLong ( &buf, (long)clc.rmgAutomapSymbols[i].mOrigin[1] );
+		}
+	}
+	else
+	{
+		MSG_WriteShort ( &buf, 0 );
+	}
+
+	// finished writing the client packet
+	MSG_WriteByte( &buf, svc_EOF );
+
+	// write it to the demo file
+	len = LittleLong( clc.serverMessageSequence - 1 );
+	FS_Write (&len, 4, clc.demofile);
+
+	len = LittleLong (buf.cursize);
+	FS_Write (&len, 4, clc.demofile);
+	FS_Write (buf.data, buf.cursize, clc.demofile);
+
+	// the rest of the demo file will be copied from net messages
+}
+
+/*
+=======================================================================
+
+CLIENT SIDE DEMO PLAYBACK
+
+=======================================================================
+*/
+
+/*
+=================
+CL_DemoCompleted
+=================
+*/
+void CL_DemoCompleted( void ) {
+	if (cl_timedemo && cl_timedemo->integer) {
+		int	time;
+		
+		time = Sys_Milliseconds() - clc.timeDemoStart;
+		if ( time > 0 ) {
+			Com_Printf ("%i frames, %3.1f seconds: %3.1f fps\n", clc.timeDemoFrames,
+			time/1000.0, clc.timeDemoFrames*1000.0 / time);
+		}
+	}
+
+/*	CL_Disconnect( qtrue );
+	CL_NextDemo();
+	*/
+
+	//rww - The above code seems to just stick you in a no-menu state and you can't do anything there.
+	//I'm not sure why it ever worked in TA, but whatever. This code will bring us back to the main menu
+	//after a demo is finished playing instead.
+	CL_Disconnect_f();
+	S_StopAllSounds();
+	VM_Call( uivm, UI_SET_ACTIVE_MENU, UIMENU_MAIN );
+
+	CL_NextDemo();
+}
+
+/*
+=================
+CL_ReadDemoMessage
+=================
+*/
+void CL_ReadDemoMessage( void ) {
+	int			r;
+	msg_t		buf;
+	byte		bufData[ MAX_MSGLEN ];
+	int			s;
+
+	if ( !clc.demofile ) {
+		CL_DemoCompleted ();
+		return;
+	}
+
+	// get the sequence number
+	r = FS_Read( &s, 4, clc.demofile);
+	if ( r != 4 ) {
+		CL_DemoCompleted ();
+		return;
+	}
+	clc.serverMessageSequence = LittleLong( s );
+
+	// init the message
+	MSG_Init( &buf, bufData, sizeof( bufData ) );
+
+	// get the length
+	r = FS_Read (&buf.cursize, 4, clc.demofile);
+	if ( r != 4 ) {
+		CL_DemoCompleted ();
+		return;
+	}
+	buf.cursize = LittleLong( buf.cursize );
+	if ( buf.cursize == -1 ) {
+		CL_DemoCompleted ();
+		return;
+	}
+	if ( buf.cursize > buf.maxsize ) {
+		Com_Error (ERR_DROP, "CL_ReadDemoMessage: demoMsglen > MAX_MSGLEN");
+	}
+	r = FS_Read( buf.data, buf.cursize, clc.demofile );
+	if ( r != buf.cursize ) {
+		Com_Printf( "Demo file was truncated.\n");
+		CL_DemoCompleted ();
+		return;
+	}
+
+	clc.lastPacketTime = cls.realtime;
+	buf.readcount = 0;
+	CL_ParseServerMessage( &buf );
+}
+
+/*
+====================
+CL_PlayDemo_f
+
+demo <demoname>
+
+====================
+*/
+void CL_PlayDemo_f( void ) {
+	char		name[MAX_OSPATH], extension[32];
+	char		*arg;
+
+	if (Cmd_Argc() != 2) {
+		Com_Printf ("playdemo <demoname>\n");
+		return;
+	}
+
+	// make sure a local server is killed
+	Cvar_Set( "sv_killserver", "1" );
+
+	CL_Disconnect( qtrue );
+
+	/* MrE: 2000-09-13: now called in CL_DownloadsComplete
+	CL_FlushMemory( );
+	*/
+
+	// open the demo file
+	arg = Cmd_Argv(1);
+	Com_sprintf(extension, sizeof(extension), ".dm_%d", PROTOCOL_VERSION);
+	if ( !Q_stricmp( arg + strlen(arg) - strlen(extension), extension ) ) {
+		Com_sprintf (name, sizeof(name), "demos/%s", arg);
+	} else {
+		Com_sprintf (name, sizeof(name), "demos/%s.dm_%d", arg, PROTOCOL_VERSION);
+	}
+	
+	FS_FOpenFileRead( name, &clc.demofile, qtrue );
+	if (!clc.demofile) {
+		if (!Q_stricmp(arg, "(null)"))
+		{
+			Com_Error( ERR_DROP, SE_GetString("CON_TEXT_NO_DEMO_SELECTED") );
+		}
+		else
+		{
+			Com_Error( ERR_DROP, "couldn't open %s", name);
+		}
+		return;
+	}
+	Q_strncpyz( clc.demoName, Cmd_Argv(1), sizeof( clc.demoName ) );
+
+	Con_Close();
+
+	cls.state = CA_CONNECTED;
+	clc.demoplaying = qtrue;
+	Q_strncpyz( cls.servername, Cmd_Argv(1), sizeof( cls.servername ) );
+
+	// read demo messages until connected
+	while ( cls.state >= CA_CONNECTED && cls.state < CA_PRIMED ) {
+		CL_ReadDemoMessage();
+	}
+	// don't get the first snapshot this frame, to prevent the long
+	// time from the gamestate load from messing causing a time skip
+	clc.firstDemoFrameSkipped = qfalse;
+}
+
+
+/*
+====================
+CL_StartDemoLoop
+
+Closing the main menu will restart the demo loop
+====================
+*/
+void CL_StartDemoLoop( void ) {
+	// start the demo loop again
+	Cbuf_AddText ("d1\n");
+	cls.keyCatchers = 0;
+}
+
+/*
+==================
+CL_NextDemo
+
+Called when a demo or cinematic finishes
+If the "nextdemo" cvar is set, that command will be issued
+==================
+*/
+void CL_NextDemo( void ) {
+	char	v[MAX_STRING_CHARS];
+
+	Q_strncpyz( v, Cvar_VariableString ("nextdemo"), sizeof(v) );
+	v[MAX_STRING_CHARS-1] = 0;
+	Com_DPrintf("CL_NextDemo: %s\n", v );
+	if (!v[0]) {
+		return;
+	}
+
+	Cvar_Set ("nextdemo","");
+	Cbuf_AddText (v);
+	Cbuf_AddText ("\n");
+	Cbuf_Execute();
+}
+
+#endif	// _XBOX	- No demos on Xbox
+
+//======================================================================
+
+/*
+=====================
+CL_ShutdownAll
+=====================
+*/
+void CL_ShutdownAll(void) {
+
+#if 0 //rwwFIXMEFIXME: Disable this before release!!!!!! I am just trying to find a crash bug.
+	//so it doesn't barf on shutdown saying refentities belong to each other
+	tr.refdef.num_entities = 0;
+#endif
+
+	// clear sounds
+	S_DisableSounds();
+	// shutdown CGame
+	CL_ShutdownCGame();
+	// shutdown UI
+	CL_ShutdownUI();
+
+	// shutdown the renderer
+	if ( re.Shutdown ) {
+		re.Shutdown( qfalse );		// don't destroy window or context
+	}
+
+#ifndef _XBOX
+	cls.uiStarted = qfalse;
+	cls.cgameStarted = qfalse;
+#endif
+	cls.rendererStarted = qfalse;
+	cls.soundRegistered = qfalse;
+}
+
+
+#ifdef _XBOX
+//To avoid fragmentation, we want everything free by this point.
+//Much of this probably violates DLL boundaries, so it's done on
+//Xbox only.
+extern void R_DestroyWireframeMap(void);
+extern void Sys_IORequestQueueClear(void);
+extern void AS_FreePartial(void);
+extern void Cvar_Defrag(void);
+extern void R_ModelFree(void);
+extern void Ghoul2InfoArray_Free(void);
+extern void CM_Free(void);
+extern void G_ClPtrClear(void);
+extern void NPC_NPCPtrsClear(void);
+extern void Sys_StreamRequestQueueClear(void);
+extern void RemoveAllWP(void);
+extern void BG_ClearVehicleParseParms(void);
+extern void NAV_ClearStoredWaypoints(void);
+void CL_ClearLastLevel(void)
+{
+	Z_TagFree(TAG_UI_ALLOC);
+	Z_TagFree(TAG_CG_UI_ALLOC);
+	Z_TagFree(TAG_BG_ALLOC);
+	CM_Free();
+	R_DestroyWireframeMap();
+	Ghoul2InfoArray_Free();
+	CM_FreeShaderText();
+	R_ModelFree();
+	Sys_IORequestQueueClear();
+	Sys_StreamRequestQueueClear();
+	AS_FreePartial();
+	Cvar_Defrag();
+	G_ClPtrClear();
+	NPC_NPCPtrsClear();
+	RemoveAllWP();
+	BG_ClearVehicleParseParms();
+	NAV_ClearStoredWaypoints();
+}
+#endif
+
+
+/*
+=================
+CL_FlushMemory
+
+Called by CL_MapLoading, CL_Connect_f, CL_PlayDemo_f, and CL_ParseGamestate the only
+ways a client gets into a game
+Also called by Com_Error
+=================
+*/
+void CL_FlushMemory( void ) {
+
+	// shutdown all the client stuff
+	CL_ShutdownAll();
+
+	// if not running a server clear the whole hunk
+	if ( !com_sv_running->integer ) {
+		// clear collision map data
+		CM_ClearMap();
+		// clear the whole hunk
+		Hunk_Clear();
+
+		//clear everything else to avoid fragmentation
+#ifdef _XBOX
+		CL_ClearLastLevel();
+
+		#ifdef _DEBUG
+		//Useful for memory debugging.  Please don't delete.  Comment out if
+		//necessary.
+		extern void Z_DisplayLevelMemory(int, int, int);
+		extern void Z_Details_f(void);
+		extern void Z_TagPointers(memtag_t);
+		Z_DisplayLevelMemory(0, 0, 0);
+		Z_Details_f();
+		#endif
+#endif
+	}
+	else {
+		// clear all the client data on the hunk
+		Hunk_ClearToMark();
+	}
+
+	CL_StartHunkUsers();
+}
+
+/*
+=====================
+CL_MapLoading
+
+A local server is starting to load a map, so update the
+screen to let the user know about it, then dump all client
+memory on the hunk from cgame, ui, and renderer
+=====================
+*/
+void CL_MapLoading( void ) {
+	if ( !com_cl_running->integer ) {
+		return;
+	}
+
+	// Set this to localhost.
+	Cvar_Set( "cl_currentServerAddress", "Localhost");
+
+	Con_Close();
+	cls.keyCatchers = 0;
+
+	// if we are already connected to the local host, stay connected
+	if ( cls.state >= CA_CONNECTED && !Q_stricmp( cls.servername, "localhost" ) ) {
+		cls.state = CA_CONNECTED;		// so the connect screen is drawn
+		Com_Memset( cls.updateInfoString, 0, sizeof( cls.updateInfoString ) );
+		Com_Memset( clc.serverMessage, 0, sizeof( clc.serverMessage ) );
+		Com_Memset( &cl.gameState, 0, sizeof( cl.gameState ) );
+		clc.lastPacketSentTime = -9999;
+		SCR_UpdateScreen();
+	} else {
+		// clear nextmap so the cinematic shutdown doesn't execute it
+		Cvar_Set( "nextmap", "" );
+		CL_Disconnect( qtrue );
+		Q_strncpyz( cls.servername, "localhost", sizeof(cls.servername) );
+		cls.state = CA_CHALLENGING;		// so the connect screen is drawn
+		cls.keyCatchers = 0;
+		SCR_UpdateScreen();
+		clc.connectTime = -RETRANSMIT_TIMEOUT;
+		NET_StringToAdr( cls.servername, &clc.serverAddress);
+		// we don't need a challenge on the localhost
+
+		CL_CheckForResend();
+	}
+}
+
+/*
+=====================
+CL_ClearState
+
+Called before parsing a gamestate
+=====================
+*/
+void CL_ClearState (void) {
+
+//	S_StopAllSounds();
+	Com_Memset( &cl, 0, sizeof( cl ) );
+}
+
+
+/*
+=====================
+CL_Disconnect
+
+Called when a connection, demo, or cinematic is being terminated.
+Goes from a connected state to either a menu state or a console state
+Sends a disconnect message to the server
+This is also called on Com_Error and Com_Quit, so it shouldn't cause any errors
+=====================
+*/
+void CL_Disconnect( qboolean showMainMenu ) {
+	if ( !com_cl_running || !com_cl_running->integer ) {
+		return;
+	}
+
+#ifdef _XBOX
+	Cvar_Set("r_norefresh", "0");
+#endif
+
+	// shutting down the client so enter full screen ui mode
+	Cvar_Set("r_uiFullScreen", "1");
+
+#ifndef _XBOX	// No demos or downloads on Xbox
+	if ( clc.demorecording ) {
+		CL_StopRecord_f ();
+	}
+
+	if (clc.download) {
+		FS_FCloseFile( clc.download );
+		clc.download = 0;
+	}
+	*clc.downloadTempName = *clc.downloadName = 0;
+	Cvar_Set( "cl_downloadName", "" );
+
+	if ( clc.demofile ) {
+		FS_FCloseFile( clc.demofile );
+		clc.demofile = 0;
+	}
+#endif	// _XBOX
+
+	if ( uivm && showMainMenu ) {
+		VM_Call( uivm, UI_SET_ACTIVE_MENU, UIMENU_NONE );
+	}
+
+	SCR_StopCinematic ();
+	S_ClearSoundBuffer();
+
+#ifdef _XBOX
+//	extern qboolean RE_RegisterImages_LevelLoadEnd(void);
+//	RE_RegisterImages_LevelLoadEnd();
+	R_DeleteTextures();
+#endif
+
+	// send a disconnect message to the server
+	// send it a few times in case one is dropped
+	if ( cls.state >= CA_CONNECTED ) {
+		CL_AddReliableCommand( "disconnect" );
+		CL_WritePacket();
+		CL_WritePacket();
+		CL_WritePacket();
+	}
+
+	CL_ClearState ();
+
+	// wipe the client connection
+	Com_Memset( &clc, 0, sizeof( clc ) );
+
+	cls.state = CA_DISCONNECTED;
+
+	// not connected to a pure server anymore
+	cl_connectedToPureServer = qfalse;
+	cl_connectedGAME = 0;
+	cl_connectedCGAME = 0;
+	cl_connectedUI = 0;
+}
+
+
+/*
+===================
+CL_ForwardCommandToServer
+
+adds the current command line as a clientCommand
+things like godmode, noclip, etc, are commands directed to the server,
+so when they are typed in at the console, they will need to be forwarded.
+===================
+*/
+void CL_ForwardCommandToServer( const char *string ) {
+	char	*cmd;
+
+	cmd = Cmd_Argv(0);
+
+	// ignore key up commands
+	if ( cmd[0] == '-' ) {
+		return;
+	}
+
+#ifdef _XBOX	// No demos on Xbox
+	if (cls.state < CA_CONNECTED || cmd[0] == '+' ) {
+#else
+	if (clc.demoplaying || cls.state < CA_CONNECTED || cmd[0] == '+' ) {
+#endif
+		Com_Printf ("Unknown command \"%s\"\n", cmd);
+		return;
+	}
+
+	if ( Cmd_Argc() > 1 ) {
+		CL_AddReliableCommand( string );
+	} else {
+		CL_AddReliableCommand( cmd );
+	}
+}
+
+/*
+===================
+CL_RequestMotd
+
+===================
+*/
+void CL_RequestMotd( void ) {
+#ifndef _XBOX	// No MOTD on Xbox
+	char		info[MAX_INFO_STRING];
+
+	if ( !cl_motd->integer ) {
+		return;
+	}
+	Com_Printf( "Resolving %s\n", UPDATE_SERVER_NAME );
+	if ( !NET_StringToAdr( UPDATE_SERVER_NAME, &cls.updateServer  ) ) {
+		Com_Printf( "Couldn't resolve address\n" );
+		return;
+	}
+	cls.updateServer.port = BigShort( PORT_UPDATE );
+	Com_Printf( "%s resolved to %i.%i.%i.%i:%i\n", UPDATE_SERVER_NAME,
+		cls.updateServer.ip[0], cls.updateServer.ip[1],
+		cls.updateServer.ip[2], cls.updateServer.ip[3],
+		BigShort( cls.updateServer.port ) );
+	
+	info[0] = 0;
+  // NOTE TTimo xoring against Com_Milliseconds, otherwise we may not have a true randomization
+  // only srand I could catch before here is tr_noise.c l:26 srand(1001)
+  // https://zerowing.idsoftware.com/bugzilla/show_bug.cgi?id=382
+  // NOTE: the Com_Milliseconds xoring only affects the lower 16-bit word,
+  //   but I decided it was enough randomization
+	Com_sprintf( cls.updateChallenge, sizeof( cls.updateChallenge ), "%i", ((rand() << 16) ^ rand()) ^ Com_Milliseconds());
+
+
+	Info_SetValueForKey( info, "challenge", cls.updateChallenge );
+	Info_SetValueForKey( info, "renderer", cls.glconfig.renderer_string );
+	Info_SetValueForKey( info, "version", com_version->string );
+
+	Info_SetValueForKey( info, "cputype", Cvar_VariableString("sys_cpustring") );
+	Info_SetValueForKey( info, "mhz", Cvar_VariableString("sys_cpuspeed") );
+	Info_SetValueForKey( info, "memory", Cvar_VariableString("sys_memory") );
+	Info_SetValueForKey( info, "joystick", Cvar_VariableString("in_joystick") );
+	Info_SetValueForKey( info, "colorbits", va("%d",cls.glconfig.colorBits) );
+
+
+	NET_OutOfBandPrint( NS_CLIENT, cls.updateServer, "getmotd \"%s\"\n", info );
+#endif
+}
+
+
+/*
+===================
+CL_RequestAuthorization
+
+Authorization server protocol
+-----------------------------
+
+All commands are text in Q3 out of band packets (leading 0xff 0xff 0xff 0xff).
+
+Whenever the client tries to get a challenge from the server it wants to
+connect to, it also blindly fires off a packet to the authorize server:
+
+getKeyAuthorize <challenge> <cdkey>
+
+cdkey may be "demo"
+
+
+#OLD The authorize server returns a:
+#OLD 
+#OLD keyAthorize <challenge> <accept | deny>
+#OLD 
+#OLD A client will be accepted if the cdkey is valid and it has not been used by any other IP
+#OLD address in the last 15 minutes.
+
+
+The server sends a:
+
+getIpAuthorize <challenge> <ip>
+
+The authorize server returns a:
+
+ipAuthorize <challenge> <accept | deny | demo | unknown >
+
+A client will be accepted if a valid cdkey was sent by that ip (only) in the last 15 minutes.
+If no response is received from the authorize server after two tries, the client will be let
+in anyway.
+===================
+*/
+#ifdef USE_CD_KEY
+
+void CL_RequestAuthorization( void ) {
+	char	nums[64];
+	int		i, j, l;
+	cvar_t	*fs;
+
+	if ( !cls.authorizeServer.port ) {
+		Com_Printf( "Resolving %s\n", AUTHORIZE_SERVER_NAME );
+		if ( !NET_StringToAdr( AUTHORIZE_SERVER_NAME, &cls.authorizeServer  ) ) {
+			Com_Printf( "Couldn't resolve address\n" );
+			return;
+		}
+
+		cls.authorizeServer.port = BigShort( PORT_AUTHORIZE );
+		Com_Printf( "%s resolved to %i.%i.%i.%i:%i\n", AUTHORIZE_SERVER_NAME,
+			cls.authorizeServer.ip[0], cls.authorizeServer.ip[1],
+			cls.authorizeServer.ip[2], cls.authorizeServer.ip[3],
+			BigShort( cls.authorizeServer.port ) );
+	}
+	if ( cls.authorizeServer.type == NA_BAD ) {
+		return;
+	}
+
+	if ( Cvar_VariableValue( "fs_restrict" ) ) {
+		Q_strncpyz( nums, "demota", sizeof( nums ) );
+	} else {
+		// only grab the alphanumeric values from the cdkey, to avoid any dashes or spaces
+		j = 0;
+		l = strlen( cl_cdkey );
+		if ( l > 32 ) {
+			l = 32;
+		}
+		for ( i = 0 ; i < l ; i++ ) {
+			if ( ( cl_cdkey[i] >= '0' && cl_cdkey[i] <= '9' )
+				|| ( cl_cdkey[i] >= 'a' && cl_cdkey[i] <= 'z' )
+				|| ( cl_cdkey[i] >= 'A' && cl_cdkey[i] <= 'Z' )
+				) {
+				nums[j] = cl_cdkey[i];
+				j++;
+			}
+		}
+		nums[j] = 0;
+	}
+
+	fs = Cvar_Get ("cl_anonymous", "0", CVAR_INIT|CVAR_SYSTEMINFO );
+	NET_OutOfBandPrint(NS_CLIENT, cls.authorizeServer, va("getKeyAuthorize %i %s", fs->integer, nums) );
+}
+
+#endif // USE_CD_KEY
+
+/*
+======================================================================
+
+CONSOLE COMMANDS
+
+======================================================================
+*/
+
+/*
+==================
+CL_ForwardToServer_f
+==================
+*/
+#ifndef _XBOX	// Don't need it
+void CL_ForwardToServer_f( void ) {
+	if ( cls.state != CA_ACTIVE || clc.demoplaying ) {
+		Com_Printf ("Not connected to a server.\n");
+		return;
+	}
+	
+	// don't forward the first argument
+	if ( Cmd_Argc() > 1 ) {
+		CL_AddReliableCommand( Cmd_Args() );
+	}
+}
+#endif
+
+
+/*
+==================
+CL_Disconnect_f
+==================
+*/
+void CL_Disconnect_f( void ) {
+	SCR_StopCinematic();
+	Cvar_Set("ui_singlePlayerActive", "0");
+	if ( cls.state != CA_DISCONNECTED && cls.state != CA_CINEMATIC ) {
+		Com_Error (ERR_DISCONNECT, "Disconnected from server");
+	}
+}
+
+
+/*
+================
+CL_Reconnect_f
+
+================
+*/
+void CL_Reconnect_f( void ) {
+	if ( !strlen( cls.servername ) || !strcmp( cls.servername, "localhost" ) ) {
+		Com_Printf( "Can't reconnect to localhost.\n" );
+		return;
+	}
+	Cvar_Set("ui_singlePlayerActive", "0");
+	Cbuf_AddText( va("connect %s\n", cls.servername ) );
+}
+
+/*
+================
+CL_Connect_f
+
+================
+*/
+void CL_Connect_f( void ) {
+	char	*server;
+
+	if ( !Cvar_VariableValue("fs_restrict") && !Sys_CheckCD() )
+	{
+		Com_Error( ERR_NEED_CD, SE_GetString("CON_TEXT_NEED_CD") ); //"Game CD not in drive" );		
+	}
+
+	if ( Cmd_Argc() != 2 ) {
+		Com_Printf( "usage: connect [server]\n");
+		return;	
+	}
+
+	Cvar_Set("ui_singlePlayerActive", "0");
+
+	// fire a message off to the motd server
+	CL_RequestMotd();
+
+	// clear any previous "server full" type messages
+	clc.serverMessage[0] = 0;
+
+	server = Cmd_Argv (1);
+
+	if ( com_sv_running->integer && !strcmp( server, "localhost" ) ) {
+		// if running a local server, kill it
+		SV_Shutdown( "Server quit\n" );
+	}
+
+	// make sure a local server is killed
+	Cvar_Set( "sv_killserver", "1" );
+	SV_Frame( 0 );
+
+	CL_Disconnect( qtrue );
+	Con_Close();
+
+	/* MrE: 2000-09-13: now called in CL_DownloadsComplete
+	CL_FlushMemory( );
+	*/
+
+	Q_strncpyz( cls.servername, server, sizeof(cls.servername) );
+
+	if (!NET_StringToAdr( cls.servername, &clc.serverAddress) ) {
+		Com_Printf ("Bad server address\n");
+		cls.state = CA_DISCONNECTED;
+		return;
+	}
+	if (clc.serverAddress.port == 0) {
+		clc.serverAddress.port = BigShort( PORT_SERVER );
+	}
+	Com_Printf( "%s resolved to %i.%i.%i.%i:%i\n", cls.servername,
+		clc.serverAddress.ip[0], clc.serverAddress.ip[1],
+		clc.serverAddress.ip[2], clc.serverAddress.ip[3],
+		BigShort( clc.serverAddress.port ) );
+
+	// if we aren't playing on a lan, we need to authenticate
+	// with the cd key
+	if ( NET_IsLocalAddress( clc.serverAddress ) ) {
+		cls.state = CA_CHALLENGING;
+	} else {
+		cls.state = CA_CONNECTING;
+	}
+
+	cls.keyCatchers = 0;
+	clc.connectTime = -99999;	// CL_CheckForResend() will fire immediately
+	clc.connectPacketCount = 0;
+
+	// server connection string
+	Cvar_Set( "cl_currentServerAddress", server );
+}
+
+
+/*
+=====================
+CL_Rcon_f
+
+  Send the rest of the command line over as
+  an unconnected command.
+=====================
+*/
+void CL_Rcon_f( void ) {
+	char	message[1024];
+	int		i;
+	netadr_t	to;
+
+	if ( !rcon_client_password->string ) {
+		Com_Printf ("You must set 'rcon_password' before\n"
+					"issuing an rcon command.\n");
+		return;
+	}
+
+	message[0] = -1;
+	message[1] = -1;
+	message[2] = -1;
+	message[3] = -1;
+	message[4] = 0;
+
+	strcat (message, "rcon ");
+
+	strcat (message, rcon_client_password->string);
+	strcat (message, " ");
+
+	for (i=1 ; i<Cmd_Argc() ; i++) {
+		strcat (message, Cmd_Argv(i));
+		strcat (message, " ");
+	}
+
+	if ( cls.state >= CA_CONNECTED ) {
+		to = clc.netchan.remoteAddress;
+	} else {
+		if (!strlen(rconAddress->string)) {
+			Com_Printf ("You must either be connected,\n"
+						"or set the 'rconAddress' cvar\n"
+						"to issue rcon commands\n");
+
+			return;
+		}
+		NET_StringToAdr (rconAddress->string, &to);
+		if (to.port == 0) {
+			to.port = BigShort (PORT_SERVER);
+		}
+	}
+	
+	NET_SendPacket (NS_CLIENT, strlen(message)+1, message, to);
+}
+
+/*
+=================
+CL_SendPureChecksums
+=================
+*/
+void CL_SendPureChecksums( void ) {
+#ifndef _XBOX
+	const char *pChecksums;
+	char cMsg[MAX_INFO_VALUE];
+	int i;
+
+	// if we are pure we need to send back a command with our referenced pk3 checksums
+	pChecksums = FS_ReferencedPakPureChecksums();
+
+	// "cp"
+	// "Yf"
+	Com_sprintf(cMsg, sizeof(cMsg), "Yf ");
+	Q_strcat(cMsg, sizeof(cMsg), pChecksums);
+	for (i = 0; i < 2; i++) {
+		cMsg[i] += 10;
+	}
+	CL_AddReliableCommand( cMsg );
+#endif
+}
+
+/*
+=================
+CL_ResetPureClientAtServer
+=================
+*/
+void CL_ResetPureClientAtServer( void ) {
+	CL_AddReliableCommand( va("vdr") );
+}
+
+/*
+=================
+CL_Vid_Restart_f
+
+Restart the video subsystem
+
+we also have to reload the UI and CGame because the renderer
+doesn't know what graphics to reload
+=================
+*/
+extern bool g_nOverrideChecked;
+void CL_Vid_Restart_f( void ) {
+	//rww - sort of nasty, but when a user selects a mod
+	//from the menu all it does is a vid_restart, so we
+	//have to check for new net overrides for the mod then.
+#ifndef _XBOX	// No mods on Xbox
+	g_nOverrideChecked = false;
+#endif
+
+	// don't let them loop during the restart
+	S_StopAllSounds();
+	// shutdown the UI
+	CL_ShutdownUI();
+	// shutdown the CGame
+	CL_ShutdownCGame();
+	// shutdown the renderer and clear the renderer interface
+	CL_ShutdownRef();
+	// client is no longer pure untill new checksums are sent
+	CL_ResetPureClientAtServer();
+	// clear pak references
+	FS_ClearPakReferences( FS_UI_REF | FS_CGAME_REF );
+	// reinitialize the filesystem if the game directory or checksum has changed
+	FS_ConditionalRestart( clc.checksumFeed );
+
+	cls.rendererStarted = qfalse;
+	cls.uiStarted = qfalse;
+	cls.cgameStarted = qfalse;
+	cls.soundRegistered = qfalse;
+
+	// unpause so the cgame definately gets a snapshot and renders a frame
+	Cvar_Set( "cl_paused", "0" );
+
+	// if not running a server clear the whole hunk
+	if ( !com_sv_running->integer ) {
+		CM_ClearMap();
+		// clear the whole hunk
+		Hunk_Clear();
+	}
+	else {
+		// clear all the client data on the hunk
+		Hunk_ClearToMark();
+	}
+
+	// initialize the renderer interface
+	CL_InitRef();
+
+	// startup all the client stuff
+	CL_StartHunkUsers();
+
+	// start the cgame if connected
+	if ( cls.state > CA_CONNECTED && cls.state != CA_CINEMATIC ) {
+		cls.cgameStarted = qtrue;
+		CL_InitCGame();
+		// send pure checksums
+		CL_SendPureChecksums();
+	}
+}
+
+/*
+=================
+CL_Snd_Restart_f
+
+Restart the sound subsystem
+The cgame and game must also be forced to restart because
+handles will be invalid
+=================
+*/
+// extern void S_UnCacheDynamicMusic( void );
+void CL_Snd_Restart_f( void ) {
+	S_Shutdown();
+	S_Init();
+
+//	S_FreeAllSFXMem();			// These two removed by BTO (VV)
+//	S_UnCacheDynamicMusic();	// S_Shutdown() already does this!
+
+//	CL_Vid_Restart_f();
+
+	extern qboolean	s_soundMuted;
+	s_soundMuted = qfalse;		// we can play again
+
+	extern void S_RestartMusic( void );
+	S_RestartMusic();
+}
+
+
+/*
+==================
+CL_PK3List_f
+==================
+*/
+void CL_OpenedPK3List_f( void ) {
+	Com_Printf("Opened PK3 Names: %s\n", FS_LoadedPakNames());
+}
+
+/*
+==================
+CL_PureList_f
+==================
+*/
+void CL_ReferencedPK3List_f( void ) {
+	Com_Printf("Referenced PK3 Names: %s\n", FS_ReferencedPakNames());
+}
+
+/*
+==================
+CL_Configstrings_f
+==================
+*/
+void CL_Configstrings_f( void ) {
+	int		i;
+	int		ofs;
+
+	if ( cls.state != CA_ACTIVE ) {
+		Com_Printf( "Not connected to a server.\n");
+		return;
+	}
+
+	for ( i = 0 ; i < MAX_CONFIGSTRINGS ; i++ ) {
+		ofs = cl.gameState.stringOffsets[ i ];
+		if ( !ofs ) {
+			continue;
+		}
+		Com_Printf( "%4i: %s\n", i, cl.gameState.stringData + ofs );
+	}
+}
+
+/*
+==============
+CL_Clientinfo_f
+==============
+*/
+void CL_Clientinfo_f( void ) {
+	Com_Printf( "--------- Client Information ---------\n" );
+	Com_Printf( "state: %i\n", cls.state );
+	Com_Printf( "Server: %s\n", cls.servername );
+	Com_Printf ("User info settings:\n");
+	Info_Print( Cvar_InfoString( CVAR_USERINFO ) );
+	Com_Printf( "--------------------------------------\n" );
+}
+
+
+//====================================================================
+
+/*
+=================
+CL_DownloadsComplete
+
+Called when all downloading has been completed
+=================
+*/
+void CL_DownloadsComplete( void ) {
+
+	// if we downloaded files we need to restart the file system
+#ifndef _XBOX	// No downloads on Xbox
+	if (clc.downloadRestart) {
+		clc.downloadRestart = qfalse;
+
+		FS_Restart(clc.checksumFeed); // We possibly downloaded a pak, restart the file system to load it
+
+		// inform the server so we get new gamestate info
+		CL_AddReliableCommand( "donedl" );
+
+		// by sending the donenl command we request a new gamestate
+		// so we don't want to load stuff yet
+		return;
+	}
+#endif
+
+	// let the client game init and load data
+	cls.state = CA_LOADING;
+
+	// Pump the loop, this may change gamestate!
+	Com_EventLoop();
+
+	// if the gamestate was changed by calling Com_EventLoop
+	// then we loaded everything already and we don't want to do it again.
+	if ( cls.state != CA_LOADING ) {
+		return;
+	}
+
+	// starting to load a map so we get out of full screen ui mode
+	Cvar_Set("r_uiFullScreen", "0");
+
+	// flush client memory and start loading stuff
+	// this will also (re)load the UI
+	// if this is a local client then only the client part of the hunk
+	// will be cleared, note that this is done after the hunk mark has been set
+	CL_FlushMemory();
+
+	// initialize the CGame
+	cls.cgameStarted = qtrue;
+	CL_InitCGame();
+
+	// set pure checksums
+	CL_SendPureChecksums();
+
+	CL_WritePacket();
+	CL_WritePacket();
+	CL_WritePacket();
+}
+
+/*
+=================
+CL_BeginDownload
+
+Requests a file to download from the server.  Stores it in the current
+game directory.
+=================
+*/
+
+#ifndef _XBOX	// No downloads on Xbox
+
+void CL_BeginDownload( const char *localName, const char *remoteName ) {
+
+	Com_DPrintf("***** CL_BeginDownload *****\n"
+				"Localname: %s\n"
+				"Remotename: %s\n"
+				"****************************\n", localName, remoteName);
+
+	Q_strncpyz ( clc.downloadName, localName, sizeof(clc.downloadName) );
+	Com_sprintf( clc.downloadTempName, sizeof(clc.downloadTempName), "%s.tmp", localName );
+
+	// Set so UI gets access to it
+	Cvar_Set( "cl_downloadName", remoteName );
+	Cvar_Set( "cl_downloadSize", "0" );
+	Cvar_Set( "cl_downloadCount", "0" );
+	Cvar_SetValue( "cl_downloadTime", (float) cls.realtime );
+
+	clc.downloadBlock = 0; // Starting new file
+	clc.downloadCount = 0;
+
+	CL_AddReliableCommand( va("download %s", remoteName) );
+}
+
+/*
+=================
+CL_NextDownload
+
+A download completed or failed
+=================
+*/
+void CL_NextDownload(void) {
+	char *s;
+	char *remoteName, *localName;
+
+	// We are looking to start a download here
+	if (*clc.downloadList) {
+		s = clc.downloadList;
+
+		// format is:
+		//  @remotename@localname@remotename@localname, etc.
+
+		if (*s == '@')
+			s++;
+		remoteName = s;
+		
+		if ( (s = strchr(s, '@')) == NULL ) {
+			CL_DownloadsComplete();
+			return;
+		}
+
+		*s++ = 0;
+		localName = s;
+		if ( (s = strchr(s, '@')) != NULL )
+			*s++ = 0;
+		else
+			s = localName + strlen(localName); // point at the nul byte
+
+		CL_BeginDownload( localName, remoteName );
+
+		clc.downloadRestart = qtrue;
+
+		// move over the rest
+		memmove( clc.downloadList, s, strlen(s) + 1);
+
+		return;
+	}
+
+	CL_DownloadsComplete();
+}
+
+#endif	// XBOX		- No downloads on Xbox
+
+/*
+=================
+CL_InitDownloads
+
+After receiving a valid game state, we valid the cgame and local zip files here
+and determine if we need to download them
+=================
+*/
+void CL_InitDownloads(void) {
+#ifndef _XBOX
+  char missingfiles[1024];
+	
+	if ( !cl_allowDownload->integer )
+	{
+		// autodownload is disabled on the client
+		// but it's possible that some referenced files on the server are missing
+		if (FS_ComparePaks( missingfiles, sizeof( missingfiles ), qfalse ) )
+		{      
+			// NOTE TTimo I would rather have that printed as a modal message box
+			//   but at this point while joining the game we don't know wether we will successfully join or not
+			Com_Printf( "\nWARNING: You are missing some files referenced by the server:\n%s"
+				"You might not be able to join the game\n"
+				"Go to the setting menu to turn on autodownload, or get the file elsewhere\n\n", missingfiles );
+		}
+	}
+	else if ( FS_ComparePaks( clc.downloadList, sizeof( clc.downloadList ) , qtrue ) ) {
+		
+		Com_Printf("Need paks: %s\n", clc.downloadList );
+		
+		if ( *clc.downloadList ) {
+			// if autodownloading is not enabled on the server
+			cls.state = CA_CONNECTED;
+			CL_NextDownload();
+			return;
+		}
+		
+	}
+#endif
+	CL_DownloadsComplete();
+}
+
+/*
+=================
+CL_CheckForResend
+
+Resend a connect message if the last one has timed out
+=================
+*/
+void CL_CheckForResend( void ) {
+	int		port;
+	char	info[MAX_INFO_STRING];
+	char	data[MAX_INFO_STRING];
+
+	// don't send anything if playing back a demo
+#ifndef _XBOX	// No demos on Xbox
+	if ( clc.demoplaying ) {
+		return;
+	}
+#endif
+
+	// resend if we haven't gotten a reply yet
+	if ( cls.state != CA_CONNECTING && cls.state != CA_CHALLENGING ) {
+		return;
+	}
+
+	if ( cls.realtime - clc.connectTime < RETRANSMIT_TIMEOUT ) {
+		return;
+	}
+
+	clc.connectTime = cls.realtime;	// for retransmit requests
+	clc.connectPacketCount++;
+
+
+	switch ( cls.state ) {
+	case CA_CONNECTING:
+		// requesting a challenge
+#ifdef USE_CD_KEY
+		if ( !Sys_IsLANAddress( clc.serverAddress ) ) {
+			CL_RequestAuthorization();
+		}
+#endif	// USE_CD_KEY
+		NET_OutOfBandPrint(NS_CLIENT, clc.serverAddress, "getchallenge");
+		break;
+		
+	case CA_CHALLENGING:
+		// sending back the challenge
+		port = (int) Cvar_VariableValue ("net_qport");
+
+		Q_strncpyz( info, Cvar_InfoString( CVAR_USERINFO ), sizeof( info ) );
+		Info_SetValueForKey( info, "protocol", va("%i", PROTOCOL_VERSION ) );
+		Info_SetValueForKey( info, "qport", va("%i", port ) );
+		Info_SetValueForKey( info, "challenge", va("%i", clc.challenge ) );
+
+#ifdef _XBOX
+		// Send Xbox stuff to host
+		// This stuff needs to be parsed in SV_DirectConnect(). SOF2 sent a raw
+		// XBPlayerInfo, which changed net traffic type. I'm just sending what I
+		// need to, and doing text encode to avoid other changes.
+
+		// Send our Xbox Address
+		char sxnaddr[XNADDR_STRING_LEN];
+		XnAddrToString(Net_GetXNADDR(), sxnaddr);
+		Info_SetValueForKey(info, "xnaddr", sxnaddr);
+
+		// Send our XUID if we're logged on and it's good
+		if (logged_on)
+		{
+			XONLINE_USER *pUser = XOnlineGetLogonUsers();
+			if (pUser && pUser->hr == S_OK)
+			{
+				char sxuid[XUID_STRING_LEN];
+				XUIDToString(&pUser->xuid, sxuid);
+				Info_SetValueForKey(info, "xuid", sxuid);
+			}
+		}
+
+		// If we're allowed to take a private slot (ie, we joined a friend or got invited):
+		if (XBL_MM_CanUsePrivateSlot())
+			Info_SetValueForKey(info, "xbps", "1");
+#endif
+
+		sprintf(data, "connect \"%s\"", info );
+		NET_OutOfBandData( NS_CLIENT, clc.serverAddress, (unsigned char *)data, strlen(data) );
+
+		// the most current userinfo has been sent, so watch for any
+		// newer changes to userinfo variables
+		cvar_modifiedFlags &= ~CVAR_USERINFO;
+		break;
+
+	default:
+		Com_Error( ERR_FATAL, "CL_CheckForResend: bad cls.state" );
+	}
+}
+
+
+/*
+===================
+CL_DisconnectPacket
+
+Sometimes the server can drop the client and the netchan based
+disconnect can be lost.  If the client continues to send packets
+to the server, the server will send out of band disconnect packets
+to the client so it doesn't have to wait for the full timeout period.
+===================
+*/
+void CL_DisconnectPacket( netadr_t from ) {
+	if ( cls.state < CA_AUTHORIZING ) {
+		return;
+	}
+
+	// if not from our server, ignore it
+	if ( !NET_CompareAdr( from, clc.netchan.remoteAddress ) ) {
+		return;
+	}
+
+	// if we have received packets within three seconds, ignore it
+	// (it might be a malicious spoof)
+	if ( cls.realtime - clc.lastPacketTime < 3000 ) {
+		return;
+	}
+
+	// drop the connection (FIXME: connection dropped dialog)
+	Com_Printf( "Server disconnected for unknown reason\n" );
+
+#ifdef _XBOX
+	Net_XboxDisconnect();
+#endif
+
+	CL_Disconnect( qtrue );
+}
+
+
+/*
+===================
+CL_MotdPacket
+
+===================
+*/
+void CL_MotdPacket( netadr_t from ) {
+	char	*challenge;
+	char	*info;
+
+	// if not from our server, ignore it
+	if ( !NET_CompareAdr( from, cls.updateServer ) ) {
+		return;
+	}
+
+	info = Cmd_Argv(1);
+
+	// check challenge
+	challenge = Info_ValueForKey( info, "challenge" );
+	if ( strcmp( challenge, cls.updateChallenge ) ) {
+		return;
+	}
+
+	challenge = Info_ValueForKey( info, "motd" );
+
+	Q_strncpyz( cls.updateInfoString, info, sizeof( cls.updateInfoString ) );
+	Cvar_Set( "cl_motdString", challenge );
+}
+
+/*
+===================
+CL_InitServerInfo
+===================
+*/
+void CL_InitServerInfo( serverInfo_t *server, serverAddress_t *address ) {
+	server->adr.type  = NA_IP;
+	server->adr.ip[0] = address->ip[0];
+	server->adr.ip[1] = address->ip[1];
+	server->adr.ip[2] = address->ip[2];
+	server->adr.ip[3] = address->ip[3];
+	server->adr.port  = address->port;
+	server->clients = 0;
+	server->hostName[0] = '\0';
+	server->mapName[0] = '\0';
+	server->maxClients = 0;
+#ifndef _XBOX
+	server->maxPing = 0;
+	server->minPing = 0;
+	server->netType = 0;
+	server->needPassword = qfalse;
+	server->trueJedi = 0;
+	server->weaponDisable = 0;
+	server->forceDisable = 0;
+#else
+	server->saberOnly = 0;
+#endif
+	server->ping = -1;
+	server->game[0] = '\0';
+	server->gameType = 0;
+	//server->pure = qfalse;
+}
+
+#define MAX_SERVERSPERPACKET	256
+
+/*
+===================
+CL_ServersResponsePacket
+===================
+*/
+void CL_ServersResponsePacket( netadr_t from, msg_t *msg ) {
+	int				i, count, max, total;
+	serverAddress_t addresses[MAX_SERVERSPERPACKET];
+	int				numservers;
+	byte*			buffptr;
+	byte*			buffend;
+	
+	Com_Printf("CL_ServersResponsePacket\n");
+
+	if (cls.numglobalservers == -1) {
+		// state to detect lack of servers or lack of response
+		cls.numglobalservers = 0;
+		cls.numGlobalServerAddresses = 0;
+	}
+
+	if (cls.nummplayerservers == -1) {
+		cls.nummplayerservers = 0;
+	}
+
+	// parse through server response string
+	numservers = 0;
+	buffptr    = msg->data;
+	buffend    = buffptr + msg->cursize;
+	while (buffptr+1 < buffend) {
+		// advance to initial token
+		do {
+			if (*buffptr++ == '\\')
+				break;		
+		}
+		while (buffptr < buffend);
+
+		if ( buffptr >= buffend - 6 ) {
+			break;
+		}
+
+		// parse out ip
+		addresses[numservers].ip[0] = *buffptr++;
+		addresses[numservers].ip[1] = *buffptr++;
+		addresses[numservers].ip[2] = *buffptr++;
+		addresses[numservers].ip[3] = *buffptr++;
+
+		// parse out port
+		addresses[numservers].port = (unsigned short) ((*buffptr++)<<8);		
+		addresses[numservers].port += (unsigned short) (*buffptr++);
+		addresses[numservers].port = BigShort( addresses[numservers].port );
+
+		// syntax check
+		if (*buffptr != '\\') {
+			break;
+		}
+
+		Com_DPrintf( "server: %d ip: %d.%d.%d.%d:%d\n",numservers,
+				addresses[numservers].ip[0],
+				addresses[numservers].ip[1],
+				addresses[numservers].ip[2],
+				addresses[numservers].ip[3],
+				addresses[numservers].port );
+
+		numservers++;
+		if (numservers >= MAX_SERVERSPERPACKET) {
+			break;
+		}
+
+		// parse out EOT
+		if (buffptr[1] == 'E' && buffptr[2] == 'O' && buffptr[3] == 'T') {
+			break;
+		}
+	}
+
+	if (cls.masterNum == 0) {
+		count = cls.numglobalservers;
+		max = MAX_GLOBAL_SERVERS;
+	} else {
+		count = cls.nummplayerservers;
+		max = MAX_OTHER_SERVERS;
+	}
+
+	for (i = 0; i < numservers && count < max; i++) {
+		// build net address
+		serverInfo_t *server = (cls.masterNum == 0) ? &cls.globalServers[count] : &cls.mplayerServers[count];
+
+		CL_InitServerInfo( server, &addresses[i] );
+		// advance to next slot
+		count++;
+	}
+
+	// if getting the global list
+	if (cls.masterNum == 0) {
+		if ( cls.numGlobalServerAddresses < MAX_GLOBAL_SERVERS ) {
+			// if we couldn't store the servers in the main list anymore
+			for (; i < numservers && count >= max; i++) {
+				serverAddress_t *addr;
+				// just store the addresses in an additional list
+				addr = &cls.globalServerAddresses[cls.numGlobalServerAddresses++];
+				addr->ip[0] = addresses[i].ip[0];
+				addr->ip[1] = addresses[i].ip[1];
+				addr->ip[2] = addresses[i].ip[2];
+				addr->ip[3] = addresses[i].ip[3];
+				addr->port  = addresses[i].port;
+			}
+		}
+	}
+
+	if (cls.masterNum == 0) {
+		cls.numglobalservers = count;
+		total = count + cls.numGlobalServerAddresses;
+	} else {
+		cls.nummplayerservers = count;
+		total = count;
+	}
+
+	Com_Printf("%d servers parsed (total %d)\n", numservers, total);
+}
+
+#ifndef MAX_STRINGED_SV_STRING
+#define MAX_STRINGED_SV_STRING 1024
+#endif
+static void CL_CheckSVStringEdRef(char *buf, const char *str)
+{ //I don't really like doing this. But it utilizes the system that was already in place.
+	int i = 0;
+	int b = 0;
+	int strLen = 0;
+	qboolean gotStrip = qfalse;
+
+	if (!str || !str[0])
+	{
+		if (str)
+		{
+			strcpy(buf, str);
+		}
+		return;
+	}
+
+	strcpy(buf, str);
+
+	strLen = strlen(str);
+
+	if (strLen >= MAX_STRINGED_SV_STRING)
+	{
+		return;
+	}
+
+	while (i < strLen && str[i])
+	{
+		gotStrip = qfalse;
+
+		if (str[i] == '@' && (i+1) < strLen)
+		{
+			if (str[i+1] == '@' && (i+2) < strLen)
+			{
+				if (str[i+2] == '@' && (i+3) < strLen)
+				{ //@@@ should mean to insert a stringed reference here, so insert it into buf at the current place
+					char stripRef[MAX_STRINGED_SV_STRING];
+					int r = 0;
+
+					while (i < strLen && str[i] == '@')
+					{
+						i++;
+					}
+
+					while (i < strLen && str[i] && str[i] != ' ' && str[i] != ':' && str[i] != '.' && str[i] != '\n')
+					{
+						stripRef[r] = str[i];
+						r++;
+						i++;
+					}
+					stripRef[r] = 0;
+
+					buf[b] = 0;
+					Q_strcat(buf, MAX_STRINGED_SV_STRING, SE_GetString(va("MP_SVGAME_%s", stripRef)));
+					b = strlen(buf);
+				}
+			}
+		}
+
+		if (!gotStrip)
+		{
+			buf[b] = str[i];
+			b++;
+		}
+		i++;
+	}
+
+	buf[b] = 0;
+}
+
+
+/*
+=================
+CL_ConnectionlessPacket
+
+Responses to broadcasts, etc
+=================
+*/
+void CL_ConnectionlessPacket( netadr_t from, msg_t *msg ) {
+	char	*s;
+	char	*c;
+
+	MSG_BeginReadingOOB( msg );
+	MSG_ReadLong( msg );	// skip the -1
+
+	s = MSG_ReadStringLine( msg );
+
+	Cmd_TokenizeString( s );
+
+	c = Cmd_Argv(0);
+
+	Com_DPrintf ("CL packet %s: %s\n", NET_AdrToString(from), c);
+
+	// challenge from the server we are connecting to
+	if ( !Q_stricmp(c, "challengeResponse") ) {
+		if ( cls.state != CA_CONNECTING ) {
+			Com_Printf( "Unwanted challenge response received.  Ignored.\n" );
+		} else {
+			// start sending challenge repsonse instead of challenge request packets
+			clc.challenge = atoi(Cmd_Argv(1));
+			cls.state = CA_CHALLENGING;
+			clc.connectPacketCount = 0;
+			clc.connectTime = -99999;
+
+			// take this address as the new server address.  This allows
+			// a server proxy to hand off connections to multiple servers
+			clc.serverAddress = from;
+			Com_DPrintf ("challengeResponse: %d\n", clc.challenge);
+		}
+		return;
+	}
+
+	// server connection
+	if ( !Q_stricmp(c, "connectResponse") ) {
+		if ( cls.state >= CA_CONNECTED ) {
+			Com_Printf ("Dup connect received.  Ignored.\n");
+			return;
+		}
+		if ( cls.state != CA_CHALLENGING ) {
+			Com_Printf ("connectResponse packet while not connecting.  Ignored.\n");
+			return;
+		}
+		if ( !NET_CompareBaseAdr( from, clc.serverAddress ) ) {
+			Com_Printf( "connectResponse from a different address.  Ignored.\n" );
+			Com_Printf( "%s should have been %s\n", NET_AdrToString( from ), 
+				NET_AdrToString( clc.serverAddress ) );
+			return;
+		}
+		Netchan_Setup (NS_CLIENT, &clc.netchan, from, Cvar_VariableValue( "net_qport" ) );
+		cls.state = CA_CONNECTED;
+		clc.lastPacketSentTime = -9999;		// send first packet immediately
+		return;
+	}
+
+	// server responding to an info broadcast
+	if ( !Q_stricmp(c, "infoResponse") ) {
+		CL_ServerInfoPacket( from, msg );
+		return;
+	}
+
+	// server responding to a get playerlist
+	if ( !Q_stricmp(c, "statusResponse") ) {
+		CL_ServerStatusResponse( from, msg );
+		return;
+	}
+
+	// a disconnect message from the server, which will happen if the server
+	// dropped the connection but it is still getting packets from us
+	if (!Q_stricmp(c, "disconnect")) {
+		CL_DisconnectPacket( from );
+		return;
+	}
+
+	// echo request from server
+	if ( !Q_stricmp(c, "echo") ) {
+		NET_OutOfBandPrint( NS_CLIENT, from, "%s", Cmd_Argv(1) );
+		return;
+	}
+
+	// cd check
+	if ( !Q_stricmp(c, "keyAuthorize") ) {
+		// we don't use these now, so dump them on the floor
+		return;
+	}
+
+	// global MOTD from id
+	if ( !Q_stricmp(c, "motd") ) {
+		CL_MotdPacket( from );
+		return;
+	}
+
+	// echo request from server
+	if ( !Q_stricmp(c, "print") ) 
+	{
+		char sTemp[MAX_STRINGED_SV_STRING];
+
+		s = MSG_ReadString( msg );
+		CL_CheckSVStringEdRef(sTemp, s);
+		Q_strncpyz( clc.serverMessage, sTemp, sizeof( clc.serverMessage ) );
+		Com_Printf( "%s", sTemp );
+		return;
+	}
+
+	// echo request from server
+//	if ( !Q_stricmp(c, "getserversResponse\\") ) {
+	if ( !Q_strncmp(c, "getserversResponse", 18) ) {
+		CL_ServersResponsePacket( from, msg );
+		return;
+	}
+
+	Com_DPrintf ("Unknown connectionless packet command.\n");
+}
+
+
+/*
+=================
+CL_PacketEvent
+
+A packet has arrived from the main event loop
+=================
+*/
+void CL_PacketEvent( netadr_t from, msg_t *msg ) {
+	int		headerBytes;
+
+	clc.lastPacketTime = cls.realtime;
+
+	if ( msg->cursize >= 4 && *(int *)msg->data == -1 ) {
+		CL_ConnectionlessPacket( from, msg );
+		return;
+	}
+
+	if ( cls.state < CA_CONNECTED ) {
+		return;		// can't be a valid sequenced packet
+	}
+
+	if ( msg->cursize < 4 ) {
+		Com_Printf ("%s: Runt packet\n",NET_AdrToString( from ));
+		return;
+	}
+
+	//
+	// packet from server
+	//
+	if ( !NET_CompareAdr( from, clc.netchan.remoteAddress ) ) {
+		Com_DPrintf ("%s:sequenced packet without connection\n"
+			,NET_AdrToString( from ) );
+		// FIXME: send a client disconnect?
+		return;
+	}
+
+	if (!CL_Netchan_Process( &clc.netchan, msg) ) {
+		return;		// out of order, duplicated, etc
+	}
+
+	// the header is different lengths for reliable and unreliable messages
+	headerBytes = msg->readcount;
+
+	// track the last message received so it can be returned in 
+	// client messages, allowing the server to detect a dropped
+	// gamestate
+	clc.serverMessageSequence = LittleLong( *(int *)msg->data );
+
+	clc.lastPacketTime = cls.realtime;
+	CL_ParseServerMessage( msg );
+
+	//
+	// we don't know if it is ok to save a demo message until
+	// after we have parsed the frame
+	//
+#ifndef _XBOX	// No demos on Xbox
+	if ( clc.demorecording && !clc.demowaiting ) {
+		CL_WriteDemoMessage( msg, headerBytes );
+	}
+#endif
+}
+
+/*
+==================
+CL_CheckTimeout
+
+==================
+*/
+void CL_CheckTimeout( void ) {
+	//
+	// check timeout
+	//
+	if ( ( !cl_paused->integer || !sv_paused->integer ) 
+		&& cls.state >= CA_CONNECTED && cls.state != CA_CINEMATIC
+	    && cls.realtime - clc.lastPacketTime > cl_timeout->value*1000) {
+		if (++cl.timeoutcount > 5) {	// timeoutcount saves debugger
+			const char *psTimedOut = SE_GetString("MP_SVGAME_SERVER_CONNECTION_TIMED_OUT");
+			Com_Printf ("\n%s\n",psTimedOut);
+			Com_Error(ERR_DROP, psTimedOut);
+			//CL_Disconnect( qtrue );
+			return;
+		}
+	} else {
+		cl.timeoutcount = 0;
+	}
+}
+
+
+//============================================================================
+
+/*
+==================
+CL_CheckUserinfo
+
+==================
+*/
+void CL_CheckUserinfo( void ) {
+	// don't add reliable commands when not yet connected
+	if ( cls.state < CA_CHALLENGING ) {
+		return;
+	}
+	// don't overflow the reliable command buffer when paused
+	if ( cl_paused->integer ) {
+		return;
+	}
+	// send a reliable userinfo update if needed
+	if ( cvar_modifiedFlags & CVAR_USERINFO ) {
+		cvar_modifiedFlags &= ~CVAR_USERINFO;
+		CL_AddReliableCommand( va("userinfo \"%s\"", Cvar_InfoString( CVAR_USERINFO ) ) );
+	}
+
+}
+
+extern CMiniHeap *G2VertSpaceServer;
+
+/*
+==================
+CL_Frame
+
+==================
+*/
+static unsigned int frameCount;
+static float avgFrametime=0.0;
+extern void SE_CheckForLanguageUpdates(void);
+void CL_Frame ( int msec ) {
+
+	if ( !com_cl_running->integer ) {
+		return;
+	}
+
+	SE_CheckForLanguageUpdates();	// will take zero time to execute unless language changes, then will reload strings.
+									//	of course this still doesn't work for menus...
+
+	if ( cls.state == CA_DISCONNECTED && !( cls.keyCatchers & KEYCATCH_UI )
+		&& !com_sv_running->integer ) {
+		// if disconnected, bring up the menu
+		S_StopAllSounds();
+		VM_Call( uivm, UI_SET_ACTIVE_MENU, UIMENU_MAIN );
+	}
+
+	// if recording an avi, lock to a fixed fps
+	if ( cl_avidemo->integer && msec) {
+		// save the current screen
+		if ( cls.state == CA_ACTIVE || cl_forceavidemo->integer) {
+			if (cl_avidemo->integer > 0) {
+				Cbuf_ExecuteText( EXEC_NOW, "screenshot silent\n" );
+			} else {
+				Cbuf_ExecuteText( EXEC_NOW, "screenshot_tga silent\n" );
+			}
+		}
+		// fixed time for next frame'
+		msec = (1000 / abs(cl_avidemo->integer)) * com_timescale->value;
+		if (msec == 0) {
+			msec = 1;
+		}
+	}
+
+	CL_MakeMonkeyDoLaundry();
+
+	// save the msec before checking pause
+	cls.realFrametime = msec;
+
+	// decide the simulation time
+	cls.frametime = msec;
+	if(cl_framerate->integer)
+	{
+		avgFrametime+=msec;
+		char mess[256];
+		if(!(frameCount&0x1f))
+		{
+			sprintf(mess,"Frame rate=%f\n\n",1000.0f*(1.0/(avgFrametime/32.0f)));
+	//		OutputDebugString(mess);
+			Com_Printf(mess);
+			avgFrametime=0.0f;
+		}
+		frameCount++;
+	}
+
+	cls.realtime += cls.frametime;
+
+#ifdef _DONETPROFILE_
+	if(cls.state==CA_ACTIVE)
+	{
+		ClReadProf().IncTime(cls.frametime);
+	}
+#endif
+
+	if ( cl_timegraph->integer ) {
+		SCR_DebugGraph ( cls.realFrametime * 0.25, 0 );
+	}
+
+#ifdef _XBOX
+	//Check on the hot swappable button states.
+	CL_UpdateHotSwap();
+#endif
+
+	// see if we need to update any userinfo
+	CL_CheckUserinfo();
+
+	// if we haven't gotten a packet in a long time,
+	// drop the connection
+	CL_CheckTimeout();
+
+	// send intentions now
+	CL_SendCmd();
+
+	// resend a connection request if necessary
+	CL_CheckForResend();
+
+	// decide on the serverTime to render
+	CL_SetCGameTime();
+
+	// update the screen
+	SCR_UpdateScreen();
+
+	// update audio
+	S_Update();
+
+	// advance local effects for next frame
+	SCR_RunCinematic();
+
+	Con_RunConsole();
+
+	// reset the heap for Ghoul2 vert transform space gameside
+	if (G2VertSpaceServer)
+	{
+		G2VertSpaceServer->ResetHeap();
+	}
+
+	cls.framecount++;
+}
+
+
+//============================================================================
+
+/*
+================
+CL_RefPrintf
+
+DLL glue
+================
+*/
+#define	MAXPRINTMSG	4096
+void QDECL CL_RefPrintf( int print_level, const char *fmt, ...) {
+	va_list		argptr;
+	char		msg[MAXPRINTMSG];
+	
+	va_start (argptr,fmt);
+	vsprintf (msg,fmt,argptr);
+	va_end (argptr);
+
+	if ( print_level == PRINT_ALL ) {
+		Com_Printf ("%s", msg);
+	} else if ( print_level == PRINT_WARNING ) {
+		Com_Printf (S_COLOR_YELLOW "%s", msg);		// yellow
+	} else if ( print_level == PRINT_DEVELOPER ) {
+		Com_DPrintf (S_COLOR_RED "%s", msg);		// red
+	}
+}
+
+
+
+/*
+============
+CL_ShutdownRef
+============
+*/
+void CL_ShutdownRef( void ) {
+	if ( !re.Shutdown ) {
+		return;
+	}
+	re.Shutdown( qtrue );
+	Com_Memset( &re, 0, sizeof( re ) );
+}
+
+/*
+============
+CL_InitRenderer
+============
+*/
+void CL_InitRenderer( void ) {
+	// this sets up the renderer and calls R_Init
+	re.BeginRegistration( &cls.glconfig );
+
+	// load character sets
+	cls.charSetShader = re.RegisterShaderNoMip("gfx/2d/charsgrid_med");
+
+	cls.whiteShader = re.RegisterShader( "white" );
+	cls.consoleShader = re.RegisterShader( "console" );
+	g_console_field_width = cls.glconfig.vidWidth / SMALLCHAR_WIDTH - 2;
+	kg.g_consoleField.widthInChars = g_console_field_width;
+}
+
+/*
+============================
+CL_StartHunkUsers
+
+After the server has cleared the hunk, these will need to be restarted
+This is the only place that any of these functions are called from
+============================
+*/
+void CL_StartHunkUsers( void ) {
+	if (!com_cl_running) {
+		return;
+	}
+
+	if ( !com_cl_running->integer ) {
+		return;
+	}
+
+	if ( !cls.rendererStarted ) {
+		cls.rendererStarted = qtrue;
+		CL_InitRenderer();
+	}
+
+	if ( !cls.soundStarted ) {
+		cls.soundStarted = qtrue;
+		S_Init();
+	}
+
+	if ( !cls.soundRegistered ) {
+		cls.soundRegistered = qtrue;
+		S_BeginRegistration();
+	}
+
+	if ( !cls.uiStarted ) {
+		cls.uiStarted = qtrue;
+		CL_InitUI();
+	}
+}
+
+/*
+============
+CL_InitRef
+============
+*/
+void CL_InitRef( void ) {
+	refexport_t	*ret;
+
+	ret = GetRefAPI( REF_API_VERSION );
+
+#if defined __USEA3D && defined __A3D_GEOM
+	hA3Dg_ExportRenderGeom (ret);
+#endif
+
+//	Com_Printf( "-------------------------------\n");
+
+	if ( !ret ) {
+		Com_Error (ERR_FATAL, "Couldn't initialize refresh" );
+	}
+
+	re = *ret;
+
+	// unpause so the cgame definately gets a snapshot and renders a frame
+	Cvar_Set( "cl_paused", "0" );
+}
+
+
+//===========================================================================================
+
+#define MODEL_CHANGE_DELAY 5000
+int gCLModelDelay = 0;
+
+void CL_SetModel_f( void ) {
+	char	*arg;
+	char	name[256];
+
+	arg = Cmd_Argv( 1 );
+	if (arg[0])
+	{
+		/*
+		//If you wanted to be foolproof you would put this on the server I guess. But that
+		//tends to put things out of sync regarding cvar status. And I sort of doubt someone
+		//is going to write a client and figure out the protocol so that they can annoy people
+		//by changing models real fast.
+		int curTime = Com_Milliseconds();
+		if (gCLModelDelay > curTime)
+		{
+			Com_Printf("You can only change your model every %i seconds.\n", (MODEL_CHANGE_DELAY/1000));
+			return;
+		}
+		
+		gCLModelDelay = curTime + MODEL_CHANGE_DELAY;
+		*/
+		//rwwFIXMEFIXME: This is currently broken and doesn't seem to work for connecting clients
+		Cvar_Set( "model", arg );
+	}
+	else
+	{
+		Cvar_VariableStringBuffer( "model", name, sizeof(name) );
+		Com_Printf("model is set to %s\n", name);
+	}
+}
+
+void CL_SetForcePowers_f( void ) {
+	return;
+}
+
+#define G2_VERT_SPACE_CLIENT_SIZE 256
+
+/*
+====================
+CL_Init
+====================
+*/
+void CL_Init( void ) {
+//	Com_Printf( "----- Client Initialization -----\n" );
+
+	Con_Init ();	
+
+	CL_ClearState ();
+
+	cls.state = CA_DISCONNECTED;	// no longer CA_UNINITIALIZED
+
+	cls.realtime = 0;
+
+	CL_InitInput ();
+
+	//
+	// register our variables
+	//
+	cl_noprint = Cvar_Get( "cl_noprint", "0", 0 );
+	cl_motd = Cvar_Get ("cl_motd", "1", 0);
+
+	cl_timeout = Cvar_Get ("cl_timeout", "200", 0);
+
+	cl_timeNudge = Cvar_Get ("cl_timeNudge", "0", CVAR_TEMP );
+	cl_shownet = Cvar_Get ("cl_shownet", "0", CVAR_TEMP );
+	cl_showSend = Cvar_Get ("cl_showSend", "0", CVAR_TEMP );
+	cl_showTimeDelta = Cvar_Get ("cl_showTimeDelta", "0", CVAR_TEMP );
+	cl_freezeDemo = Cvar_Get ("cl_freezeDemo", "0", CVAR_TEMP );
+	rcon_client_password = Cvar_Get ("rconPassword", "", CVAR_TEMP );
+	cl_activeAction = Cvar_Get( "activeAction", "", CVAR_TEMP );
+
+	cl_timedemo = Cvar_Get ("timedemo", "0", 0);
+	cl_avidemo = Cvar_Get ("cl_avidemo", "0", 0);
+	cl_forceavidemo = Cvar_Get ("cl_forceavidemo", "0", 0);
+
+	rconAddress = Cvar_Get ("rconAddress", "", 0);
+
+	cl_yawspeed = Cvar_Get ("cl_yawspeed", "140", CVAR_ARCHIVE);
+	cl_pitchspeed = Cvar_Get ("cl_pitchspeed", "140", CVAR_ARCHIVE);
+	cl_anglespeedkey = Cvar_Get ("cl_anglespeedkey", "1.5", CVAR_ARCHIVE);
+
+	cl_maxpackets = Cvar_Get ("cl_maxpackets", "30", CVAR_ARCHIVE );
+	cl_packetdup = Cvar_Get ("cl_packetdup", "1", CVAR_ARCHIVE );
+
+	cl_run = Cvar_Get ("cl_run", "1", CVAR_ARCHIVE);
+	cl_sensitivity = Cvar_Get ("sensitivity", "5", CVAR_ARCHIVE);
+	cl_mouseAccel = Cvar_Get ("cl_mouseAccel", "0", CVAR_ARCHIVE);
+	cl_freelook = Cvar_Get( "cl_freelook", "1", CVAR_ARCHIVE );
+
+	cl_showMouseRate = Cvar_Get ("cl_showmouserate", "0", 0);
+	cl_framerate	= Cvar_Get ("cl_framerate", "0", CVAR_TEMP);
+	cl_allowDownload = Cvar_Get ("cl_allowDownload", "0", CVAR_ARCHIVE);
+	cl_allowAltEnter = Cvar_Get ("cl_allowAltEnter", "0", CVAR_ARCHIVE);
+
+	cl_autolodscale = Cvar_Get( "cl_autolodscale", "1", CVAR_ARCHIVE );
+
+	cl_conXOffset = Cvar_Get ("cl_conXOffset", "0", 0);
+#ifdef MACOS_X
+        // In game video is REALLY slow in Mac OS X right now due to driver slowness
+	cl_inGameVideo = Cvar_Get ("r_inGameVideo", "0", CVAR_ARCHIVE);
+#else
+	cl_inGameVideo = Cvar_Get ("r_inGameVideo", "1", CVAR_ARCHIVE);
+#endif
+
+	cl_serverStatusResendTime = Cvar_Get ("cl_serverStatusResendTime", "750", 0);
+
+	// init autoswitch so the ui will have it correctly even
+	// if the cgame hasn't been started
+	Cvar_Get ("cg_autoswitch", "1", CVAR_ARCHIVE);
+
+	m_pitchVeh = Cvar_Get ("m_pitchVeh", "0.022", CVAR_ARCHIVE);
+	m_pitch = Cvar_Get ("m_pitch", "0.022", CVAR_ARCHIVE);
+	m_yaw = Cvar_Get ("m_yaw", "0.022", CVAR_ARCHIVE);
+	m_forward = Cvar_Get ("m_forward", "0.25", CVAR_ARCHIVE);
+	m_side = Cvar_Get ("m_side", "0.25", CVAR_ARCHIVE);
+#ifdef MACOS_X
+        // Input is jittery on OS X w/o this
+	m_filter = Cvar_Get ("m_filter", "1", CVAR_ARCHIVE);
+#else
+	m_filter = Cvar_Get ("m_filter", "0", CVAR_ARCHIVE);
+#endif
+
+	cl_motdString = Cvar_Get( "cl_motdString", "", CVAR_ROM );
+
+	Cvar_Get( "cl_maxPing", "800", CVAR_ARCHIVE );
+
+
+	// userinfo
+	Cvar_Get ("name", "Padawan", CVAR_USERINFO | CVAR_ARCHIVE );
+	Cvar_Get ("rate", "4000", CVAR_USERINFO | CVAR_ARCHIVE );
+	Cvar_Get ("snaps", "20", CVAR_USERINFO | CVAR_ARCHIVE );
+	Cvar_Get ("model", "kyle/default", CVAR_USERINFO | CVAR_ARCHIVE );
+	Cvar_Get ("forcepowers", "7-1-032330000000001333", CVAR_USERINFO | CVAR_ARCHIVE );
+	Cvar_Get ("g_redTeam", "Empire", CVAR_SERVERINFO | CVAR_ARCHIVE);
+	Cvar_Get ("g_blueTeam", "Rebellion", CVAR_SERVERINFO | CVAR_ARCHIVE);
+	Cvar_Get ("color1",  "4", CVAR_USERINFO | CVAR_ARCHIVE );
+	Cvar_Get ("color2", "4", CVAR_USERINFO | CVAR_ARCHIVE );
+	Cvar_Get ("handicap", "100", CVAR_USERINFO | CVAR_ARCHIVE );
+	Cvar_Get ("teamtask", "0", CVAR_USERINFO );
+	Cvar_Get ("sex", "male", CVAR_USERINFO | CVAR_ARCHIVE );
+	Cvar_Get ("cl_anonymous", "0", CVAR_USERINFO | CVAR_ARCHIVE );
+
+	Cvar_Get ("password", "", CVAR_USERINFO);
+	Cvar_Get ("cg_predictItems", "1", CVAR_USERINFO | CVAR_ARCHIVE );
+
+	//default sabers
+	Cvar_Get ("saber1",  "single_1", CVAR_USERINFO | CVAR_ARCHIVE );
+	Cvar_Get ("saber2",  "none", CVAR_USERINFO | CVAR_ARCHIVE );
+
+	//skin color
+	Cvar_Get ("char_color_red",  "255", CVAR_USERINFO | CVAR_ARCHIVE );
+	Cvar_Get ("char_color_green",  "255", CVAR_USERINFO | CVAR_ARCHIVE );
+	Cvar_Get ("char_color_blue",  "255", CVAR_USERINFO | CVAR_ARCHIVE );
+
+	// cgame might not be initialized before menu is used
+	Cvar_Get ("cg_viewsize", "100", CVAR_ARCHIVE );
+
+	//
+	// register our commands
+	//
+#ifndef _XBOX
+	Cmd_AddCommand ("cmd", CL_ForwardToServer_f);
+	Cmd_AddCommand ("globalservers", CL_GlobalServers_f);
+	Cmd_AddCommand ("record", CL_Record_f);
+	Cmd_AddCommand ("demo", CL_PlayDemo_f);
+	Cmd_AddCommand ("stoprecord", CL_StopRecord_f);
+#endif
+	Cmd_AddCommand ("configstrings", CL_Configstrings_f);
+	Cmd_AddCommand ("clientinfo", CL_Clientinfo_f);
+	Cmd_AddCommand ("snd_restart", CL_Snd_Restart_f);
+	Cmd_AddCommand ("vid_restart", CL_Vid_Restart_f);
+	Cmd_AddCommand ("disconnect", CL_Disconnect_f);
+	Cmd_AddCommand ("cinematic", CL_PlayCinematic_f);
+	Cmd_AddCommand ("connect", CL_Connect_f);
+	Cmd_AddCommand ("reconnect", CL_Reconnect_f);
+	Cmd_AddCommand ("localservers", CL_LocalServers_f);
+	Cmd_AddCommand ("rcon", CL_Rcon_f);
+	Cmd_AddCommand ("ping", CL_Ping_f );
+	Cmd_AddCommand ("serverstatus", CL_ServerStatus_f );
+	Cmd_AddCommand ("showip", CL_ShowIP_f );
+	Cmd_AddCommand ("fs_openedList", CL_OpenedPK3List_f );
+	Cmd_AddCommand ("fs_referencedList", CL_ReferencedPK3List_f );
+	Cmd_AddCommand ("model", CL_SetModel_f );
+	Cmd_AddCommand ("forcepowers", CL_SetForcePowers_f );
+
+	CL_InitRef();
+
+	SCR_Init ();
+
+	Cbuf_Execute ();
+
+	Cvar_Set( "cl_running", "1" );
+
+	G2VertSpaceClient = new CMiniHeap(G2_VERT_SPACE_CLIENT_SIZE * 1024);
+
+#ifdef _XBOX
+	extern void CIN_Init(void);
+	Com_Printf( "Initializing Cinematics...\n");
+	CIN_Init();
+#endif
+
+//	Com_Printf( "----- Client Initialization Complete -----\n" );
+}
+
+
+/*
+===============
+CL_Shutdown
+
+===============
+*/
+void CL_Shutdown( void ) {
+	static qboolean recursive = qfalse;
+	
+	//Com_Printf( "----- CL_Shutdown -----\n" );
+
+	if ( recursive ) {
+		printf ("recursive CL_Shutdown shutdown\n");
+		return;
+	}
+	recursive = qtrue;
+
+	if (G2VertSpaceClient)
+	{
+		delete G2VertSpaceClient;
+		G2VertSpaceClient = 0;
+	}
+
+	CL_Disconnect( qtrue );
+
+	CL_ShutdownRef();	//must be before shutdown all so the images get dumped in RE_Shutdown
+
+	// RJ: added the shutdown all to close down the cgame (to free up some memory, such as in the fx system)
+	CL_ShutdownAll();
+
+	S_Shutdown();
+	//CL_ShutdownUI();
+
+	Cmd_RemoveCommand ("cmd");
+	Cmd_RemoveCommand ("configstrings");
+	Cmd_RemoveCommand ("userinfo");
+	Cmd_RemoveCommand ("snd_restart");
+	Cmd_RemoveCommand ("vid_restart");
+	Cmd_RemoveCommand ("disconnect");
+	Cmd_RemoveCommand ("record");
+	Cmd_RemoveCommand ("demo");
+	Cmd_RemoveCommand ("cinematic");
+	Cmd_RemoveCommand ("stoprecord");
+	Cmd_RemoveCommand ("connect");
+	Cmd_RemoveCommand ("localservers");
+	Cmd_RemoveCommand ("globalservers");
+	Cmd_RemoveCommand ("rcon");
+	Cmd_RemoveCommand ("ping");
+	Cmd_RemoveCommand ("serverstatus");
+	Cmd_RemoveCommand ("showip");
+	Cmd_RemoveCommand ("model");
+	Cmd_RemoveCommand ("forcepowers");
+
+	Cvar_Set( "cl_running", "0" );
+
+	recursive = qfalse;
+
+	Com_Memset( &cls, 0, sizeof( cls ) );
+
+	//Com_Printf( "-----------------------\n" );
+
+}
+
+static void CL_SetServerInfo(serverInfo_t *server, const char *info, int ping) {
+	if (server) {
+		if (info) {
+			server->clients = atoi(Info_ValueForKey(info, "clients"));
+			Q_strncpyz(server->hostName,Info_ValueForKey(info, "hostname"), MAX_NAME_LENGTH);
+			Q_strncpyz(server->mapName, Info_ValueForKey(info, "mapname"), MAX_NAME_LENGTH);
+			server->maxClients = atoi(Info_ValueForKey(info, "sv_maxclients"));
+			Q_strncpyz(server->game,Info_ValueForKey(info, "game"), MAX_NAME_LENGTH);
+			server->gameType = atoi(Info_ValueForKey(info, "gametype"));
+#ifndef _XBOX
+			server->netType = atoi(Info_ValueForKey(info, "nettype"));
+			server->minPing = atoi(Info_ValueForKey(info, "minping"));
+			server->maxPing = atoi(Info_ValueForKey(info, "maxping"));
+//			server->allowAnonymous = atoi(Info_ValueForKey(info, "sv_allowAnonymous"));
+			server->needPassword = (qboolean)atoi(Info_ValueForKey(info, "needpass" ));
+			server->trueJedi = atoi(Info_ValueForKey(info, "truejedi" ));
+			server->weaponDisable = atoi(Info_ValueForKey(info, "wdisable" ));
+			server->forceDisable = atoi(Info_ValueForKey(info, "fdisable" ));
+#else
+			server->saberOnly = atoi(Info_ValueForKey(info, "saberonly" ));
+#endif
+//			server->pure = (qboolean)atoi(Info_ValueForKey(info, "pure" ));
+		}
+		server->ping = ping;
+	}
+}
+
+static void CL_SetServerInfoByAddress(netadr_t from, const char *info, int ping) {
+	int i;
+
+	for (i = 0; i < MAX_OTHER_SERVERS; i++) {
+		if (NET_CompareAdr(from, cls.localServers[i].adr)) {
+			CL_SetServerInfo(&cls.localServers[i], info, ping);
+		}
+	}
+
+	for (i = 0; i < MAX_OTHER_SERVERS; i++) {
+		if (NET_CompareAdr(from, cls.mplayerServers[i].adr)) {
+			CL_SetServerInfo(&cls.mplayerServers[i], info, ping);
+		}
+	}
+
+	for (i = 0; i < MAX_GLOBAL_SERVERS; i++) {
+		if (NET_CompareAdr(from, cls.globalServers[i].adr)) {
+			CL_SetServerInfo(&cls.globalServers[i], info, ping);
+		}
+	}
+
+	for (i = 0; i < MAX_OTHER_SERVERS; i++) {
+		if (NET_CompareAdr(from, cls.favoriteServers[i].adr)) {
+			CL_SetServerInfo(&cls.favoriteServers[i], info, ping);
+		}
+	}
+
+}
+
+/*
+===================
+CL_ServerInfoPacket
+===================
+*/
+void CL_ServerInfoPacket( netadr_t from, msg_t *msg ) {
+	int		i, type;
+	char	info[MAX_INFO_STRING];
+	char*	str;
+	char	*infoString;
+	int		prot;
+
+	infoString = MSG_ReadString( msg );
+
+	// if this isn't the correct protocol version, ignore it
+	prot = atoi( Info_ValueForKey( infoString, "protocol" ) );
+	if ( prot != PROTOCOL_VERSION ) {
+		Com_DPrintf( "Different protocol info packet: %s\n", infoString );
+//		return;
+	}
+
+#ifdef _XBOX
+	// Ignore servers that don't send an xnaddr
+	if (!(*Info_ValueForKey(infoString, "xnaddr")))
+		return;
+#endif
+
+	// iterate servers waiting for ping response
+	for (i=0; i<MAX_PINGREQUESTS; i++)
+	{
+		if ( cl_pinglist[i].adr.port && !cl_pinglist[i].time && NET_CompareAdr( from, cl_pinglist[i].adr ) )
+		{
+			// calc ping time
+			cl_pinglist[i].time = cls.realtime - cl_pinglist[i].start + 1;
+			Com_DPrintf( "ping time %dms from %s\n", cl_pinglist[i].time, NET_AdrToString( from ) );
+
+			// save of info
+			Q_strncpyz( cl_pinglist[i].info, infoString, sizeof( cl_pinglist[i].info ) );
+
+			// tack on the net type
+			// NOTE: make sure these types are in sync with the netnames strings in the UI
+			switch (from.type)
+			{
+				case NA_BROADCAST:
+				case NA_IP:
+					str = "udp";
+					type = 1;
+					break;
+
+				case NA_IPX:
+				case NA_BROADCAST_IPX:
+					str = "ipx";
+					type = 2;
+					break;
+
+				default:
+					str = "???";
+					type = 0;
+					break;
+			}
+			Info_SetValueForKey( cl_pinglist[i].info, "nettype", va("%d", type) );
+			CL_SetServerInfoByAddress(from, infoString, cl_pinglist[i].time);
+
+			return;
+		}
+	}
+
+	// if not just sent a local broadcast or pinging local servers
+	if (cls.pingUpdateSource != AS_LOCAL) {
+		return;
+	}
+
+	for ( i = 0 ; i < MAX_OTHER_SERVERS ; i++ ) {
+		// empty slot
+		if ( cls.localServers[i].adr.port == 0 ) {
+			break;
+		}
+
+		// avoid duplicate
+		if ( NET_CompareAdr( from, cls.localServers[i].adr ) ) {
+			return;
+		}
+	}
+
+	if ( i == MAX_OTHER_SERVERS ) {
+		Com_DPrintf( "MAX_OTHER_SERVERS hit, dropping infoResponse\n" );
+		return;
+	}
+
+	// add this to the list
+	cls.numlocalservers = i+1;
+	cls.localServers[i].adr = from;
+	cls.localServers[i].clients = 0;
+	cls.localServers[i].hostName[0] = '\0';
+	cls.localServers[i].mapName[0] = '\0';
+	cls.localServers[i].maxClients = 0;
+#ifndef _XBOX
+	cls.localServers[i].maxPing = 0;
+	cls.localServers[i].minPing = 0;
+	cls.localServers[i].netType = from.type;
+	cls.localServers[i].needPassword = qfalse;
+	cls.localServers[i].trueJedi = 0;
+	cls.localServers[i].weaponDisable = 0;
+	cls.localServers[i].forceDisable = 0;
+#else
+	cls.localServers[i].saberOnly = 0;
+#endif
+	cls.localServers[i].ping = -1;
+	cls.localServers[i].game[0] = '\0';
+	cls.localServers[i].gameType = 0;
+//	cls.localServers[i].allowAnonymous = 0;
+//	cls.localServers[i].pure = qfalse;
+
+#ifdef _XBOX
+	// Store off Xbox info. We don't do any key registration or address translation yet.
+	// That happens when we connect.
+	StringToXnAddr(&cls.localServers[i].HostAddress, Info_ValueForKey(infoString, "xnaddr"));
+	StringToXNKID(&cls.localServers[i].SessionID, Info_ValueForKey(infoString, "xnkid"));
+	StringToXNKEY(&cls.localServers[i].KeyExchangeKey, Info_ValueForKey(infoString, "xnkey"));
+#endif
+
+	Q_strncpyz( info, MSG_ReadString( msg ), MAX_INFO_STRING );
+	if (strlen(info)) {
+		if (info[strlen(info)-1] != '\n') {
+			strncat(info, "\n", sizeof(info));
+		}
+		Com_Printf( "%s: %s", NET_AdrToString( from ), info );
+	}
+}
+
+/*
+===================
+CL_GetServerStatus
+===================
+*/
+serverStatus_t *CL_GetServerStatus( netadr_t from ) {
+	serverStatus_t *serverStatus;
+	int i, oldest, oldestTime;
+
+	serverStatus = NULL;
+	for (i = 0; i < MAX_SERVERSTATUSREQUESTS; i++) {
+		if ( NET_CompareAdr( from, cl_serverStatusList[i].address ) ) {
+			return &cl_serverStatusList[i];
+		}
+	}
+	for (i = 0; i < MAX_SERVERSTATUSREQUESTS; i++) {
+		if ( cl_serverStatusList[i].retrieved ) {
+			return &cl_serverStatusList[i];
+		}
+	}
+	oldest = -1;
+	oldestTime = 0;
+	for (i = 0; i < MAX_SERVERSTATUSREQUESTS; i++) {
+		if (oldest == -1 || cl_serverStatusList[i].startTime < oldestTime) {
+			oldest = i;
+			oldestTime = cl_serverStatusList[i].startTime;
+		}
+	}
+	if (oldest != -1) {
+		return &cl_serverStatusList[oldest];
+	}
+	serverStatusCount++;
+	return &cl_serverStatusList[serverStatusCount & (MAX_SERVERSTATUSREQUESTS-1)];
+}
+
+/*
+===================
+CL_ServerStatus
+===================
+*/
+int CL_ServerStatus( char *serverAddress, char *serverStatusString, int maxLen ) {
+	int i;
+	netadr_t	to;
+	serverStatus_t *serverStatus;
+
+	// if no server address then reset all server status requests
+	if ( !serverAddress ) {
+		for (i = 0; i < MAX_SERVERSTATUSREQUESTS; i++) {
+			cl_serverStatusList[i].address.port = 0;
+			cl_serverStatusList[i].retrieved = qtrue;
+		}
+		return qfalse;
+	}
+	// get the address
+	if ( !NET_StringToAdr( serverAddress, &to ) ) {
+		return qfalse;
+	}
+	serverStatus = CL_GetServerStatus( to );
+	// if no server status string then reset the server status request for this address
+	if ( !serverStatusString ) {
+		serverStatus->retrieved = qtrue;
+		return qfalse;
+	}
+
+	// if this server status request has the same address
+	if ( NET_CompareAdr( to, serverStatus->address) ) {
+		// if we recieved an response for this server status request
+		if (!serverStatus->pending) {
+			Q_strncpyz(serverStatusString, serverStatus->string, maxLen);
+			serverStatus->retrieved = qtrue;
+			serverStatus->startTime = 0;
+			return qtrue;
+		}
+		// resend the request regularly
+		else if ( serverStatus->startTime < Com_Milliseconds() - cl_serverStatusResendTime->integer ) {
+			serverStatus->print = qfalse;
+			serverStatus->pending = qtrue;
+			serverStatus->retrieved = qfalse;
+			serverStatus->time = 0;
+			serverStatus->startTime = Com_Milliseconds();
+			NET_OutOfBandPrint( NS_CLIENT, to, "getstatus" );
+			return qfalse;
+		}
+	}
+	// if retrieved
+	else if ( serverStatus->retrieved ) {
+		serverStatus->address = to;
+		serverStatus->print = qfalse;
+		serverStatus->pending = qtrue;
+		serverStatus->retrieved = qfalse;
+		serverStatus->startTime = Com_Milliseconds();
+		serverStatus->time = 0;
+		NET_OutOfBandPrint( NS_CLIENT, to, "getstatus" );
+		return qfalse;
+	}
+	return qfalse;
+}
+
+/*
+===================
+CL_ServerStatusResponse
+===================
+*/
+void CL_ServerStatusResponse( netadr_t from, msg_t *msg ) {
+	char	*s;
+	char	info[MAX_INFO_STRING];
+	int		i, l, score, ping;
+	int		len;
+	serverStatus_t *serverStatus;
+
+	serverStatus = NULL;
+	for (i = 0; i < MAX_SERVERSTATUSREQUESTS; i++) {
+		if ( NET_CompareAdr( from, cl_serverStatusList[i].address ) ) {
+			serverStatus = &cl_serverStatusList[i];
+			break;
+		}
+	}
+	// if we didn't request this server status
+	if (!serverStatus) {
+		return;
+	}
+
+	s = MSG_ReadStringLine( msg );
+
+	len = 0;
+	Com_sprintf(&serverStatus->string[len], sizeof(serverStatus->string)-len, "%s", s);
+
+	if (serverStatus->print) {
+		Com_Printf("Server settings:\n");
+		// print cvars
+		while (*s) {
+			for (i = 0; i < 2 && *s; i++) {
+				if (*s == '\\')
+					s++;
+				l = 0;
+				while (*s) {
+					info[l++] = *s;
+					if (l >= MAX_INFO_STRING-1)
+						break;
+					s++;
+					if (*s == '\\') {
+						break;
+					}
+				}
+				info[l] = '\0';
+				if (i) {
+					Com_Printf("%s\n", info);
+				}
+				else {
+					Com_Printf("%-24s", info);
+				}
+			}
+		}
+	}
+
+	len = strlen(serverStatus->string);
+	Com_sprintf(&serverStatus->string[len], sizeof(serverStatus->string)-len, "\\");
+
+	if (serverStatus->print) {
+		Com_Printf("\nPlayers:\n");
+		Com_Printf("num: score: ping: name:\n");
+	}
+	for (i = 0, s = MSG_ReadStringLine( msg ); *s; s = MSG_ReadStringLine( msg ), i++) {
+
+		len = strlen(serverStatus->string);
+		Com_sprintf(&serverStatus->string[len], sizeof(serverStatus->string)-len, "\\%s", s);
+
+		if (serverStatus->print) {
+			score = ping = 0;
+			sscanf(s, "%d %d", &score, &ping);
+			s = strchr(s, ' ');
+			if (s)
+				s = strchr(s+1, ' ');
+			if (s)
+				s++;
+			else
+				s = "unknown";
+			Com_Printf("%-2d   %-3d    %-3d   %s\n", i, score, ping, s );
+		}
+	}
+	len = strlen(serverStatus->string);
+	Com_sprintf(&serverStatus->string[len], sizeof(serverStatus->string)-len, "\\");
+
+	serverStatus->time = Com_Milliseconds();
+	serverStatus->address = from;
+	serverStatus->pending = qfalse;
+	if (serverStatus->print) {
+		serverStatus->retrieved = qtrue;
+	}
+}
+
+/*
+==================
+CL_LocalServers_f
+==================
+*/
+void CL_LocalServers_f( void ) {
+	char		*message;
+	int			i, j;
+	netadr_t	to;
+
+	Com_Printf( "Scanning for servers on the local network...\n");
+
+	// reset the list, waiting for response
+	cls.numlocalservers = 0;
+	cls.pingUpdateSource = AS_LOCAL;
+
+	for (i = 0; i < MAX_OTHER_SERVERS; i++) {
+		qboolean b = cls.localServers[i].visible;
+		Com_Memset(&cls.localServers[i], 0, sizeof(cls.localServers[i]));
+		cls.localServers[i].visible = b;
+	}
+	Com_Memset( &to, 0, sizeof( to ) );
+
+	// The 'xxx' in the message is a challenge that will be echoed back
+	// by the server.  We don't care about that here, but master servers
+	// can use that to prevent spoofed server responses from invalid ip
+	message = "\377\377\377\377getinfo xxx";
+
+	// send each message twice in case one is dropped
+	for ( i = 0 ; i < 2 ; i++ ) {
+		// send a broadcast packet on each server port
+		// we support multiple server ports so a single machine
+		// can nicely run multiple servers
+		for ( j = 0 ; j < NUM_SERVER_PORTS ; j++ ) {
+			to.port = BigShort( (short)(PORT_SERVER + j) );
+
+			to.type = NA_BROADCAST;
+			NET_SendPacket( NS_CLIENT, strlen( message ), message, to );
+
+			to.type = NA_BROADCAST_IPX;
+			NET_SendPacket( NS_CLIENT, strlen( message ), message, to );
+		}
+	}
+}
+
+/*
+==================
+CL_GlobalServers_f
+==================
+*/
+#ifndef _XBOX	// No master on Xbox
+void CL_GlobalServers_f( void ) {
+	netadr_t	to;
+	int			i;
+	int			count;
+	char		*buffptr;
+	char		command[1024];
+	
+	if ( Cmd_Argc() < 3) {
+		Com_Printf( "usage: globalservers <master# 0-1> <protocol> [keywords]\n");
+		return;	
+	}
+
+	cls.masterNum = atoi( Cmd_Argv(1) );
+
+	Com_Printf( "Requesting servers from the master...\n");
+
+	// reset the list, waiting for response
+	// -1 is used to distinguish a "no response"
+
+/*	if( cls.masterNum == 1 ) {
+		NET_StringToAdr( "master.quake3world.com", &to );
+		cls.nummplayerservers = -1;
+		cls.pingUpdateSource = AS_MPLAYER;
+	}
+	else 
+*/	{
+		NET_StringToAdr( MASTER_SERVER_NAME, &to );
+		cls.numglobalservers = -1;
+		cls.pingUpdateSource = AS_GLOBAL;
+	}
+	to.type = NA_IP;
+	to.port = BigShort(PORT_MASTER);
+
+	sprintf( command, "getservers %s", Cmd_Argv(2) );
+
+	// tack on keywords
+	buffptr = command + strlen( command );
+	count   = Cmd_Argc();
+	for (i=3; i<count; i++)
+		buffptr += sprintf( buffptr, " %s", Cmd_Argv(i) );
+
+	// if we are a demo, automatically add a "demo" keyword
+	if ( Cvar_VariableValue( "fs_restrict" ) ) {
+		buffptr += sprintf( buffptr, " demo" );
+	}
+
+	NET_OutOfBandPrint( NS_SERVER, to, command );
+}
+#endif	// _XBOX
+
+/*
+==================
+CL_GetPing
+==================
+*/
+void CL_GetPing( int n, char *buf, int buflen, int *pingtime )
+{
+	const char	*str;
+	int		time;
+	int		maxPing;
+
+	if (!cl_pinglist[n].adr.port)
+	{
+		// empty slot
+		buf[0]    = '\0';
+		*pingtime = 0;
+		return;
+	}
+
+	str = NET_AdrToString( cl_pinglist[n].adr );
+	Q_strncpyz( buf, str, buflen );
+
+	time = cl_pinglist[n].time;
+	if (!time)
+	{
+		// check for timeout
+		time = cls.realtime - cl_pinglist[n].start;
+		maxPing = Cvar_VariableIntegerValue( "cl_maxPing" );
+		if( maxPing < 100 ) {
+			maxPing = 100;
+		}
+		if (time < maxPing)
+		{
+			// not timed out yet
+			time = 0;
+		}
+	}
+
+	CL_SetServerInfoByAddress(cl_pinglist[n].adr, cl_pinglist[n].info, cl_pinglist[n].time);
+
+	*pingtime = time;
+}
+
+/*
+==================
+CL_UpdateServerInfo
+==================
+*/
+void CL_UpdateServerInfo( int n )
+{
+	if (!cl_pinglist[n].adr.port)
+	{
+		return;
+	}
+
+	CL_SetServerInfoByAddress(cl_pinglist[n].adr, cl_pinglist[n].info, cl_pinglist[n].time );
+}
+
+/*
+==================
+CL_GetPingInfo
+==================
+*/
+void CL_GetPingInfo( int n, char *buf, int buflen )
+{
+	if (!cl_pinglist[n].adr.port)
+	{
+		// empty slot
+		if (buflen)
+			buf[0] = '\0';
+		return;
+	}
+
+	Q_strncpyz( buf, cl_pinglist[n].info, buflen );
+}
+
+/*
+==================
+CL_ClearPing
+==================
+*/
+void CL_ClearPing( int n )
+{
+	if (n < 0 || n >= MAX_PINGREQUESTS)
+		return;
+
+	cl_pinglist[n].adr.port = 0;
+}
+
+/*
+==================
+CL_GetPingQueueCount
+==================
+*/
+int CL_GetPingQueueCount( void )
+{
+	int		i;
+	int		count;
+	ping_t*	pingptr;
+
+	count   = 0;
+	pingptr = cl_pinglist;
+
+	for (i=0; i<MAX_PINGREQUESTS; i++, pingptr++ ) {
+		if (pingptr->adr.port) {
+			count++;
+		}
+	}
+
+	return (count);
+}
+
+/*
+==================
+CL_GetFreePing
+==================
+*/
+ping_t* CL_GetFreePing( void )
+{
+	ping_t*	pingptr;
+	ping_t*	best;	
+	int		oldest;
+	int		i;
+	int		time;
+
+	pingptr = cl_pinglist;
+	for (i=0; i<MAX_PINGREQUESTS; i++, pingptr++ )
+	{
+		// find free ping slot
+		if (pingptr->adr.port)
+		{
+			if (!pingptr->time)
+			{
+				if (cls.realtime - pingptr->start < 500)
+				{
+					// still waiting for response
+					continue;
+				}
+			}
+			else if (pingptr->time < 500)
+			{
+				// results have not been queried
+				continue;
+			}
+		}
+
+		// clear it
+		pingptr->adr.port = 0;
+		return (pingptr);
+	}
+
+	// use oldest entry
+	pingptr = cl_pinglist;
+	best    = cl_pinglist;
+	oldest  = INT_MIN;
+	for (i=0; i<MAX_PINGREQUESTS; i++, pingptr++ )
+	{
+		// scan for oldest
+		time = cls.realtime - pingptr->start;
+		if (time > oldest)
+		{
+			oldest = time;
+			best   = pingptr;
+		}
+	}
+
+	return (best);
+}
+
+/*
+==================
+CL_Ping_f
+==================
+*/
+void CL_Ping_f( void ) {
+	netadr_t	to;
+	ping_t*		pingptr;
+	char*		server;
+
+	if ( Cmd_Argc() != 2 ) {
+		Com_Printf( "usage: ping [server]\n");
+		return;	
+	}
+
+	Com_Memset( &to, 0, sizeof(netadr_t) );
+
+	server = Cmd_Argv(1);
+
+	if ( !NET_StringToAdr( server, &to ) ) {
+		return;
+	}
+
+	pingptr = CL_GetFreePing();
+
+	memcpy( &pingptr->adr, &to, sizeof (netadr_t) );
+	pingptr->start = cls.realtime;
+	pingptr->time  = 0;
+
+	CL_SetServerInfoByAddress(pingptr->adr, NULL, 0);
+		
+	NET_OutOfBandPrint( NS_CLIENT, to, "getinfo xxx" );
+}
+
+/*
+==================
+CL_UpdateVisiblePings_f
+==================
+*/
+qboolean CL_UpdateVisiblePings_f(int source) {
+	int			slots, i;
+	char		buff[MAX_STRING_CHARS];
+	int			pingTime;
+	int			max;
+	qboolean status = qfalse;
+
+	if (source < 0 || source > AS_FAVORITES) {
+		return qfalse;
+	}
+
+	cls.pingUpdateSource = source;
+
+	slots = CL_GetPingQueueCount();
+	if (slots < MAX_PINGREQUESTS) {
+		serverInfo_t *server = NULL;
+
+		max = (source == AS_GLOBAL) ? MAX_GLOBAL_SERVERS : MAX_OTHER_SERVERS;
+		switch (source) {
+			case AS_LOCAL :
+				server = &cls.localServers[0];
+				max = cls.numlocalservers;
+			break;
+			case AS_MPLAYER :
+				server = &cls.mplayerServers[0];
+				max = cls.nummplayerservers;
+			break;
+			case AS_GLOBAL :
+				server = &cls.globalServers[0];
+				max = cls.numglobalservers;
+			break;
+			case AS_FAVORITES :
+				server = &cls.favoriteServers[0];
+				max = cls.numfavoriteservers;
+			break;
+		}
+		for (i = 0; i < max; i++) {
+			if (server[i].visible) {
+				if (server[i].ping == -1) {
+					int j;
+
+					if (slots >= MAX_PINGREQUESTS) {
+						break;
+					}
+					for (j = 0; j < MAX_PINGREQUESTS; j++) {
+						if (!cl_pinglist[j].adr.port) {
+							continue;
+						}
+						if (NET_CompareAdr( cl_pinglist[j].adr, server[i].adr)) {
+							// already on the list
+							break;
+						}
+					}
+					if (j >= MAX_PINGREQUESTS) {
+						status = qtrue;
+						for (j = 0; j < MAX_PINGREQUESTS; j++) {
+							if (!cl_pinglist[j].adr.port) {
+								break;
+							}
+						}
+						memcpy(&cl_pinglist[j].adr, &server[i].adr, sizeof(netadr_t));
+						cl_pinglist[j].start = cls.realtime;
+						cl_pinglist[j].time = 0;
+						NET_OutOfBandPrint( NS_CLIENT, cl_pinglist[j].adr, "getinfo xxx" );
+						slots++;
+					}
+				}
+				// if the server has a ping higher than cl_maxPing or
+				// the ping packet got lost
+				else if (server[i].ping == 0) {
+					// if we are updating global servers
+					if (source == AS_GLOBAL) {
+						//
+						if ( cls.numGlobalServerAddresses > 0 ) {
+							// overwrite this server with one from the additional global servers
+							cls.numGlobalServerAddresses--;
+							CL_InitServerInfo(&server[i], &cls.globalServerAddresses[cls.numGlobalServerAddresses]);
+							// NOTE: the server[i].visible flag stays untouched
+						}
+					}
+				}
+			}
+		}
+	} 
+
+	if (slots) {
+		status = qtrue;
+	}
+	for (i = 0; i < MAX_PINGREQUESTS; i++) {
+		if (!cl_pinglist[i].adr.port) {
+			continue;
+		}
+		CL_GetPing( i, buff, MAX_STRING_CHARS, &pingTime );
+		if (pingTime != 0) {
+			CL_ClearPing(i);
+			status = qtrue;
+		}
+	}
+
+	return status;
+}
+
+/*
+==================
+CL_ServerStatus_f
+==================
+*/
+void CL_ServerStatus_f(void) {
+	netadr_t	to;
+	char		*server;
+	serverStatus_t *serverStatus;
+
+	Com_Memset( &to, 0, sizeof(netadr_t) );
+
+	if ( Cmd_Argc() != 2 ) {
+#ifdef _XBOX	// No demos on Xbox
+		if ( cls.state != CA_ACTIVE ) {
+#else
+		if ( cls.state != CA_ACTIVE || clc.demoplaying ) {
+#endif
+			Com_Printf ("Not connected to a server.\n");
+			Com_Printf( "Usage: serverstatus [server]\n");
+			return;	
+		}
+		server = cls.servername;
+	}
+	else {
+		server = Cmd_Argv(1);
+	}
+
+	if ( !NET_StringToAdr( server, &to ) ) {
+		return;
+	}
+
+	NET_OutOfBandPrint( NS_CLIENT, to, "getstatus" );
+
+	serverStatus = CL_GetServerStatus( to );
+	serverStatus->address = to;
+	serverStatus->print = qtrue;
+	serverStatus->pending = qtrue;
+}
+
+/*
+==================
+CL_ShowIP_f
+==================
+*/
+void CL_ShowIP_f(void) {
+	Sys_ShowIP();
+}
+
+#ifdef USE_CD_KEY
+
+/*
+=================
+bool CL_CDKeyValidate
+=================
+*/
+qboolean CL_CDKeyValidate( const char *key, const char *checksum ) {
+	char	ch;
+	byte	sum;
+	char	chs[3];
+	int i, len;
+
+	len = strlen(key);
+	if( len != CDKEY_LEN ) {
+		return qfalse;
+	}
+
+	if( checksum && strlen( checksum ) != CDCHKSUM_LEN ) {
+		return qfalse;
+	}
+
+	sum = 0;
+	// for loop gets rid of conditional assignment warning
+	for (i = 0; i < len; i++) {
+		ch = *key++;
+		if (ch>='a' && ch<='z') {
+			ch -= 32;
+		}
+		switch( ch ) {
+		case '2':
+		case '3':
+		case '7':
+		case 'A':
+		case 'B':
+		case 'C':
+		case 'D':
+		case 'G':
+		case 'H':
+		case 'J':
+		case 'L':
+		case 'P':
+		case 'R':
+		case 'S':
+		case 'T':
+		case 'W':
+			sum += ch;
+			continue;
+		default:
+			return qfalse;
+		}
+	}
+
+
+	sprintf(chs, "%02x", sum);
+
+	if (checksum && !Q_stricmp(chs, checksum)) {
+		return qtrue;
+	}
+
+	if (!checksum) {
+		return qtrue;
+	}
+
+	return qfalse;
+}
+
+#endif // USE_CD_KEY
+
diff --git a/codemp/client/cl_net_chan.cpp b/codemp/client/cl_net_chan.cpp
new file mode 100644
index 0000000..7ce9de4
--- /dev/null
+++ b/codemp/client/cl_net_chan.cpp
@@ -0,0 +1,175 @@
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+#include "client.h"
+
+// TTimo: unused, commenting out to make gcc happy
+#if 1
+/*
+==============
+CL_Netchan_Encode
+
+	// first 12 bytes of the data are always:
+	long serverId;
+	long messageAcknowledge;
+	long reliableAcknowledge;
+
+==============
+*/
+static void CL_Netchan_Encode( msg_t *msg ) {
+#ifdef _XBOX
+	return;
+#endif
+	int serverId, messageAcknowledge, reliableAcknowledge;
+	int i, index, srdc, sbit, soob;
+	byte key, *string;
+
+	if ( msg->cursize <= CL_ENCODE_START ) {
+		return;
+	}
+
+        srdc = msg->readcount;
+        sbit = msg->bit;
+        soob = msg->oob;
+        
+        msg->bit = 0;
+        msg->readcount = 0;
+        msg->oob = (qboolean)0;
+        
+        serverId = MSG_ReadLong(msg);
+	messageAcknowledge = MSG_ReadLong(msg);
+	reliableAcknowledge = MSG_ReadLong(msg);
+
+        msg->oob = (qboolean)soob;
+        msg->bit = sbit;
+        msg->readcount = srdc;
+        
+	string = (byte *)clc.serverCommands[ reliableAcknowledge & (MAX_RELIABLE_COMMANDS-1) ];
+	index = 0;
+	//
+	key = clc.challenge ^ serverId ^ messageAcknowledge;
+	for (i = CL_ENCODE_START; i < msg->cursize; i++) {
+		// modify the key with the last received now acknowledged server command
+		if (!string[index])
+			index = 0;
+		if (/*string[index] > 127 || */	// eurofix: remove this so we can chat in european languages...	-ste
+			string[index] == '%') 
+		{
+			key ^= '.' << (i & 1);
+		}
+		else {
+			key ^= string[index] << (i & 1);
+		}
+		index++;
+		// encode the data with this key
+		*(msg->data + i) = (*(msg->data + i)) ^ key;
+	}
+}
+
+/*
+==============
+CL_Netchan_Decode
+
+	// first four bytes of the data are always:
+	long reliableAcknowledge;
+
+==============
+*/
+static void CL_Netchan_Decode( msg_t *msg ) {
+#ifdef _XBOX
+	return;
+#endif
+	long reliableAcknowledge, i, index;
+	byte key, *string;
+        int	srdc, sbit, soob;
+
+        srdc = msg->readcount;
+        sbit = msg->bit;
+        soob = msg->oob;
+        
+        msg->oob = (qboolean)0;
+        
+	reliableAcknowledge = MSG_ReadLong(msg);
+
+        msg->oob = (qboolean)soob;
+        msg->bit = sbit;
+        msg->readcount = srdc;
+
+	string = (unsigned char *)clc.reliableCommands[ reliableAcknowledge & (MAX_RELIABLE_COMMANDS-1) ];
+	index = 0;
+	// xor the client challenge with the netchan sequence number (need something that changes every message)
+	key = clc.challenge ^ LittleLong( *(unsigned *)msg->data );
+	for (i = msg->readcount + CL_DECODE_START; i < msg->cursize; i++) {
+		// modify the key with the last sent and with this message acknowledged client command
+		if (!string[index])
+			index = 0;
+		if (/*string[index] > 127 || */	// eurofix: remove this so we can chat in european languages...	-ste
+			string[index] == '%') 
+		{
+			key ^= '.' << (i & 1);
+		}
+		else {
+			key ^= string[index] << (i & 1);
+		}
+		index++;
+		// decode the data with this key
+		*(msg->data + i) = *(msg->data + i) ^ key;
+	}
+}
+#endif
+
+/*
+=================
+CL_Netchan_TransmitNextFragment
+=================
+*/
+void CL_Netchan_TransmitNextFragment( netchan_t *chan ) {
+	Netchan_TransmitNextFragment( chan );
+}
+
+//byte chksum[65536];
+
+/*
+===============
+CL_Netchan_Transmit
+================
+*/
+void CL_Netchan_Transmit( netchan_t *chan, msg_t* msg ) {
+//	int i;
+	MSG_WriteByte( msg, clc_EOF );
+//	for(i=CL_ENCODE_START;i<msg->cursize;i++) {
+//		chksum[i-CL_ENCODE_START] = msg->data[i];
+//	}
+
+//	Huff_Compress( msg, CL_ENCODE_START );
+	CL_Netchan_Encode( msg );
+	Netchan_Transmit( chan, msg->cursize, msg->data );
+}
+
+extern 	int oldsize;
+int newsize = 0;
+
+/*
+=================
+CL_Netchan_Process
+=================
+*/
+qboolean CL_Netchan_Process( netchan_t *chan, msg_t *msg ) {
+	int ret;
+//	int i;
+//	static		int newsize = 0;
+
+	ret = Netchan_Process( chan, msg );
+	if (!ret)
+		return qfalse;
+	CL_Netchan_Decode( msg );
+//	Huff_Decompress( msg, CL_DECODE_START );
+//	for(i=CL_DECODE_START+msg->readcount;i<msg->cursize;i++) {
+//		if (msg->data[i] != chksum[i-(CL_DECODE_START+msg->readcount)]) {
+//			Com_Error(ERR_DROP,"bad %d v %d\n", msg->data[i], chksum[i-(CL_DECODE_START+msg->readcount)]);
+//		}
+//	}
+	newsize += msg->cursize;
+//	Com_Printf("saved %d to %d (%d%%)\n", (oldsize>>3), newsize, 100-(newsize*100/(oldsize>>3)));
+	return qtrue;
+}
diff --git a/codemp/client/cl_parse.cpp b/codemp/client/cl_parse.cpp
new file mode 100644
index 0000000..9d476b0
--- /dev/null
+++ b/codemp/client/cl_parse.cpp
@@ -0,0 +1,1033 @@
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+// cl_parse.c  -- parse a message received from the server
+
+#include "client.h"
+#include "../qcommon/stringed_ingame.h"
+#include "../ghoul2/g2_local.h"
+#ifdef _DONETPROFILE_
+#include "../qcommon/INetProfile.h"
+#endif
+#include "../zlib32/zip.h"
+
+#ifdef _XBOX
+#include "../xbox/XBLive.h"
+#include "../xbox/XBoxCommon.h"
+#include "../xbox/XBVoice.h"
+#endif
+
+static char hiddenCvarVal[128];
+
+char *svc_strings[256] = {
+	"svc_bad",
+
+	"svc_nop",
+	"svc_gamestate",
+	"svc_configstring",
+	"svc_baseline",	
+	"svc_serverCommand",
+	"svc_download",
+	"svc_snapshot",
+	"svc_setgame",
+	"svc_mapchange",
+#ifdef _XBOX
+	"svc_newpeer",
+	"svc_removepeer",
+	"svc_xbInfo",
+#endif
+};
+
+void SHOWNET( msg_t *msg, char *s) {
+	if ( cl_shownet->integer >= 2) {
+		Com_Printf ("%3i:%s\n", msg->readcount-1, s);
+	}
+}
+
+//void CL_SP_Print(const word ID, byte *Data); //, char* color)
+
+/*
+=========================================================================
+
+MESSAGE PARSING
+
+=========================================================================
+*/
+
+/*
+==================
+CL_DeltaEntity
+
+Parses deltas from the given base and adds the resulting entity
+to the current frame
+==================
+*/
+void CL_DeltaEntity (msg_t *msg, clSnapshot_t *frame, int newnum, entityState_t *old, 
+					 qboolean unchanged) {
+	entityState_t	*state;
+
+	// save the parsed entity state into the big circular buffer so
+	// it can be used as the source for a later delta
+	state = &cl.parseEntities[cl.parseEntitiesNum & (MAX_PARSE_ENTITIES-1)];
+
+	if ( unchanged ) 
+	{
+		*state = *old;
+	} 
+	else 
+	{
+		MSG_ReadDeltaEntity( msg, old, state, newnum );
+	}
+
+	if ( state->number == (MAX_GENTITIES-1) ) {
+		return;		// entity was delta removed
+	}
+	cl.parseEntitiesNum++;
+	frame->numEntities++;
+}
+
+/*
+==================
+CL_ParsePacketEntities
+
+==================
+*/
+void CL_ParsePacketEntities( msg_t *msg, clSnapshot_t *oldframe, clSnapshot_t *newframe) {
+	int			newnum;
+	entityState_t	*oldstate;
+	int			oldindex, oldnum;
+
+	newframe->parseEntitiesNum = cl.parseEntitiesNum;
+	newframe->numEntities = 0;
+
+	// delta from the entities present in oldframe
+	oldindex = 0;
+	oldstate = NULL;
+	if (!oldframe) {
+		oldnum = 99999;
+	} else {
+		if ( oldindex >= oldframe->numEntities ) {
+			oldnum = 99999;
+		} else {
+			oldstate = &cl.parseEntities[
+				(oldframe->parseEntitiesNum + oldindex) & (MAX_PARSE_ENTITIES-1)];
+			oldnum = oldstate->number;
+		}
+	}
+
+	while ( 1 ) {
+		// read the entity index number
+		newnum = MSG_ReadBits( msg, GENTITYNUM_BITS );
+
+		if ( newnum == (MAX_GENTITIES-1) ) {
+			break;
+		}
+
+		if ( msg->readcount > msg->cursize ) {
+			Com_Error (ERR_DROP,"CL_ParsePacketEntities: end of message");
+		}
+
+		while ( oldnum < newnum ) {
+			// one or more entities from the old packet are unchanged
+			if ( cl_shownet->integer == 3 ) {
+				Com_Printf ("%3i:  unchanged: %i\n", msg->readcount, oldnum);
+			}
+			CL_DeltaEntity( msg, newframe, oldnum, oldstate, qtrue );
+			
+			oldindex++;
+
+			if ( oldindex >= oldframe->numEntities ) {
+				oldnum = 99999;
+			} else {
+				oldstate = &cl.parseEntities[
+					(oldframe->parseEntitiesNum + oldindex) & (MAX_PARSE_ENTITIES-1)];
+				oldnum = oldstate->number;
+			}
+		}
+		if (oldnum == newnum) {
+			// delta from previous state
+			if ( cl_shownet->integer == 3 ) {
+				Com_Printf ("%3i:  delta: %i\n", msg->readcount, newnum);
+			}
+			CL_DeltaEntity( msg, newframe, newnum, oldstate, qfalse );
+
+			oldindex++;
+
+			if ( oldindex >= oldframe->numEntities ) {
+				oldnum = 99999;
+			} else {
+				oldstate = &cl.parseEntities[
+					(oldframe->parseEntitiesNum + oldindex) & (MAX_PARSE_ENTITIES-1)];
+				oldnum = oldstate->number;
+			}
+			continue;
+		}
+
+		if ( oldnum > newnum ) {
+			// delta from baseline
+			if ( cl_shownet->integer == 3 ) {
+				Com_Printf ("%3i:  baseline: %i\n", msg->readcount, newnum);
+			}
+			CL_DeltaEntity( msg, newframe, newnum, &cl.entityBaselines[newnum], qfalse );
+			continue;
+		}
+
+	}
+
+	// any remaining entities in the old frame are copied over
+	while ( oldnum != 99999 ) {
+		// one or more entities from the old packet are unchanged
+		if ( cl_shownet->integer == 3 ) {
+			Com_Printf ("%3i:  unchanged: %i\n", msg->readcount, oldnum);
+		}
+		CL_DeltaEntity( msg, newframe, oldnum, oldstate, qtrue );
+		
+		oldindex++;
+
+		if ( oldindex >= oldframe->numEntities ) {
+			oldnum = 99999;
+		} else {
+			oldstate = &cl.parseEntities[
+				(oldframe->parseEntitiesNum + oldindex) & (MAX_PARSE_ENTITIES-1)];
+			oldnum = oldstate->number;
+		}
+	}
+}
+
+
+/*
+================
+CL_ParseSnapshot
+
+If the snapshot is parsed properly, it will be copied to
+cl.snap and saved in cl.snapshots[].  If the snapshot is invalid
+for any reason, no changes to the state will be made at all.
+================
+*/
+void CL_ParseSnapshot( msg_t *msg ) {
+	int			len;
+	clSnapshot_t	*old;
+	clSnapshot_t	newSnap;
+	int			deltaNum;
+	int			oldMessageNum;
+	int			i, packetNum;
+
+	// get the reliable sequence acknowledge number
+	// NOTE: now sent with all server to client messages
+	//clc.reliableAcknowledge = MSG_ReadLong( msg );
+
+	// read in the new snapshot to a temporary buffer
+	// we will only copy to cl.snap if it is valid
+	Com_Memset (&newSnap, 0, sizeof(newSnap));
+
+	// we will have read any new server commands in this
+	// message before we got to svc_snapshot
+	newSnap.serverCommandNum = clc.serverCommandSequence;
+
+	newSnap.serverTime = MSG_ReadLong( msg );
+
+	newSnap.messageNum = clc.serverMessageSequence;
+
+	deltaNum = MSG_ReadByte( msg );
+	if ( !deltaNum ) {
+		newSnap.deltaNum = -1;
+	} else {
+		newSnap.deltaNum = newSnap.messageNum - deltaNum;
+	}
+	newSnap.snapFlags = MSG_ReadByte( msg );
+
+	// If the frame is delta compressed from data that we
+	// no longer have available, we must suck up the rest of
+	// the frame, but not use it, then ask for a non-compressed
+	// message 
+	if ( newSnap.deltaNum <= 0 ) {
+		newSnap.valid = qtrue;		// uncompressed frame
+		old = NULL;
+#ifndef _XBOX	// No demos on Xbox
+		clc.demowaiting = qfalse;	// we can start recording now
+#endif
+	} else {
+		old = &cl.snapshots[newSnap.deltaNum & PACKET_MASK];
+		if ( !old->valid ) {
+			// should never happen
+			Com_Printf ("Delta from invalid frame (not supposed to happen!).\n");
+		} else if ( old->messageNum != newSnap.deltaNum ) {
+			// The frame that the server did the delta from
+			// is too old, so we can't reconstruct it properly.
+			Com_Printf ("Delta frame too old.\n");
+		} else if ( cl.parseEntitiesNum - old->parseEntitiesNum > MAX_PARSE_ENTITIES-128 ) {
+			Com_DPrintf ("Delta parseEntitiesNum too old.\n");
+		} else {
+			newSnap.valid = qtrue;	// valid delta parse
+		}
+	}
+
+	// read areamask
+	len = MSG_ReadByte( msg );
+	MSG_ReadData( msg, &newSnap.areamask, len);
+
+	// read playerinfo
+	SHOWNET( msg, "playerstate" );
+	if ( old ) {
+		MSG_ReadDeltaPlayerstate( msg, &old->ps, &newSnap.ps );
+		if (newSnap.ps.m_iVehicleNum)
+		{ //this means we must have written our vehicle's ps too
+			MSG_ReadDeltaPlayerstate( msg, &old->vps, &newSnap.vps, qtrue );
+		}
+	} else {
+		MSG_ReadDeltaPlayerstate( msg, NULL, &newSnap.ps );
+		if (newSnap.ps.m_iVehicleNum)
+		{ //this means we must have written our vehicle's ps too
+			MSG_ReadDeltaPlayerstate( msg, NULL, &newSnap.vps, qtrue );			
+		}
+	}
+
+	// read packet entities
+	SHOWNET( msg, "packet entities" );
+	CL_ParsePacketEntities( msg, old, &newSnap );
+
+	// if not valid, dump the entire thing now that it has
+	// been properly read
+	if ( !newSnap.valid ) {
+		return;
+	}
+
+	// clear the valid flags of any snapshots between the last
+	// received and this one, so if there was a dropped packet
+	// it won't look like something valid to delta from next
+	// time we wrap around in the buffer
+	oldMessageNum = cl.snap.messageNum + 1;
+
+	if ( newSnap.messageNum - oldMessageNum >= PACKET_BACKUP ) {
+		oldMessageNum = newSnap.messageNum - ( PACKET_BACKUP - 1 );
+	}
+	for ( ; oldMessageNum < newSnap.messageNum ; oldMessageNum++ ) {
+		cl.snapshots[oldMessageNum & PACKET_MASK].valid = qfalse;
+	}
+
+	// copy to the current good spot
+	cl.snap = newSnap;
+	cl.snap.ping = 999;
+	// calculate ping time
+	for ( i = 0 ; i < PACKET_BACKUP ; i++ ) {
+		packetNum = ( clc.netchan.outgoingSequence - 1 - i ) & PACKET_MASK;
+		if ( cl.snap.ps.commandTime >= cl.outPackets[ packetNum ].p_serverTime ) {
+			cl.snap.ping = cls.realtime - cl.outPackets[ packetNum ].p_realtime;
+			break;
+		}
+	}
+	// save the frame off in the backup array for later delta comparisons
+	cl.snapshots[cl.snap.messageNum & PACKET_MASK] = cl.snap;
+
+	if (cl_shownet->integer == 3) {
+		Com_Printf( "   snapshot:%i  delta:%i  ping:%i\n", cl.snap.messageNum,
+		cl.snap.deltaNum, cl.snap.ping );
+	}
+
+	cl.newSnapshots = qtrue;
+}
+
+
+/*
+================
+CL_ParseSetGame
+
+rww - Update fs_game, this message is so we can use the ext_data
+*_overrides.txt files for mods.
+================
+*/
+void MSG_CheckNETFPSFOverrides(qboolean psfOverrides);
+void FS_UpdateGamedir(void);
+void CL_ParseSetGame( msg_t *msg )
+{
+	char newGameDir[MAX_QPATH];
+	int i = 0;
+	char next;
+
+	while (i < MAX_QPATH)
+	{
+		next = MSG_ReadByte( msg );
+
+		if (next)
+		{ //if next is 0 then we have finished reading to the end of the message
+			newGameDir[i] = next;
+		}
+		else
+		{
+			break;
+		}
+		i++;
+	}
+	newGameDir[i] = 0;
+
+	Cvar_Set("fs_game", newGameDir);
+
+	//Update the search path for the mod dir
+	FS_UpdateGamedir();
+
+	//Now update the overrides manually
+#ifndef _XBOX	// No mods on Xbox
+	MSG_CheckNETFPSFOverrides(qfalse);
+	MSG_CheckNETFPSFOverrides(qtrue);
+#endif
+}
+
+
+//=====================================================================
+
+int cl_connectedToPureServer;
+int cl_connectedGAME;
+int cl_connectedCGAME;
+int cl_connectedUI;
+
+/*
+==================
+CL_SystemInfoChanged
+
+The systeminfo configstring has been changed, so parse
+new information out of it.  This will happen at every
+gamestate, and possibly during gameplay.
+==================
+*/
+void CL_SystemInfoChanged( void ) {
+	char			*systemInfo;
+	const char		*s, *t;
+	char			key[BIG_INFO_KEY];
+	char			value[BIG_INFO_VALUE];
+	qboolean		gameSet;
+
+	systemInfo = cl.gameState.stringData + cl.gameState.stringOffsets[ CS_SYSTEMINFO ];
+	cl.serverId = atoi( Info_ValueForKey( systemInfo, "sv_serverid" ) );
+
+	// don't set any vars when playing a demo
+#ifndef _XBOX	// No demos on Xbox
+	if ( clc.demoplaying ) {
+		return;
+	}
+#endif
+
+	s = Info_ValueForKey( systemInfo, "sv_cheats" );
+	if ( atoi(s) == 0 )
+	{
+		Cvar_SetCheatState();
+	}
+
+	// check pure server string
+	s = Info_ValueForKey( systemInfo, "sv_paks" );
+	t = Info_ValueForKey( systemInfo, "sv_pakNames" );
+	FS_PureServerSetLoadedPaks( s, t );
+
+	s = Info_ValueForKey( systemInfo, "sv_referencedPaks" );
+	t = Info_ValueForKey( systemInfo, "sv_referencedPakNames" );
+	FS_PureServerSetReferencedPaks( s, t );
+
+	gameSet = qfalse;
+	// scan through all the variables in the systeminfo and locally set cvars to match
+	s = systemInfo;
+	while ( s ) {
+		Info_NextPair( &s, key, value );
+		if ( !key[0] ) {
+			break;
+		}
+		// ehw!
+		if ( !Q_stricmp( key, "fs_game" ) ) {
+			gameSet = qtrue;
+		}
+
+		Cvar_Set( key, value );
+	}
+	// if game folder should not be set and it is set at the client side
+	if ( !gameSet && *Cvar_VariableString("fs_game") ) {
+		Cvar_Set( "fs_game", "" );
+	}
+	cl_connectedToPureServer = Cvar_VariableValue( "sv_pure" );
+
+	cl_connectedGAME = atoi(Info_ValueForKey( systemInfo, "vm_game" ));
+	cl_connectedCGAME = atoi(Info_ValueForKey( systemInfo, "vm_cgame" ));
+	cl_connectedUI = atoi(Info_ValueForKey( systemInfo, "vm_ui" ));
+}
+
+void CL_ParseAutomapSymbols ( msg_t* msg )
+{
+	int i;
+
+	clc.rmgAutomapSymbolCount = (unsigned short) MSG_ReadShort ( msg );
+
+	for ( i = 0; i < clc.rmgAutomapSymbolCount; i ++ )
+	{
+		clc.rmgAutomapSymbols[i].mType = (int)MSG_ReadByte ( msg );
+		clc.rmgAutomapSymbols[i].mSide = (int)MSG_ReadByte ( msg );
+		clc.rmgAutomapSymbols[i].mOrigin[0] = (float)MSG_ReadLong ( msg );
+		clc.rmgAutomapSymbols[i].mOrigin[1] = (float)MSG_ReadLong ( msg );
+	}
+}
+
+void CL_ParseRMG ( msg_t* msg )
+{
+	clc.rmgHeightMapSize = (unsigned short)MSG_ReadShort ( msg );
+	if ( !clc.rmgHeightMapSize )
+	{
+		return;
+	}
+
+	z_stream zdata;
+	int		 size;
+	unsigned char heightmap1[15000];
+
+	if ( MSG_ReadBits ( msg, 1 ) )
+	{
+		// Read the heightmap
+		memset(&zdata, 0, sizeof(z_stream));
+		inflateInit ( &zdata, Z_SYNC_FLUSH );		
+
+		MSG_ReadData ( msg, heightmap1, clc.rmgHeightMapSize );
+
+		zdata.next_in = heightmap1;
+		zdata.avail_in = clc.rmgHeightMapSize;
+		zdata.next_out = (unsigned char*)clc.rmgHeightMap;
+		zdata.avail_out = MAX_HEIGHTMAP_SIZE;
+		inflate (&zdata);
+
+		clc.rmgHeightMapSize = zdata.total_out;
+
+		inflateEnd(&zdata);
+	}
+	else
+	{
+		MSG_ReadData ( msg, (unsigned char*)clc.rmgHeightMap, clc.rmgHeightMapSize );
+	}
+
+	size = (unsigned short)MSG_ReadShort ( msg );
+
+	if ( MSG_ReadBits ( msg, 1 ) )
+	{	
+		// Read the flatten map
+		memset(&zdata, 0, sizeof(z_stream));
+		inflateInit ( &zdata, Z_SYNC_FLUSH );
+
+		MSG_ReadData ( msg, heightmap1, size );
+
+		zdata.next_in = heightmap1;
+		zdata.avail_in = clc.rmgHeightMapSize;
+		zdata.next_out = (unsigned char*)clc.rmgFlattenMap;
+		zdata.avail_out = MAX_HEIGHTMAP_SIZE;
+		inflate (&zdata );
+		inflateEnd(&zdata);
+	}
+	else
+	{
+		MSG_ReadData ( msg, (unsigned char*)clc.rmgFlattenMap, size );
+	}
+
+	// Read the seed		
+	clc.rmgSeed = MSG_ReadLong ( msg );
+
+	CL_ParseAutomapSymbols ( msg );
+}
+
+/*
+==================
+CL_ParseGamestate
+==================
+*/
+void CL_ParseGamestate( msg_t *msg ) {
+	int				i;
+	entityState_t	*es;
+	int				newnum;
+	entityState_t	nullstate;
+	int				cmd;
+	char			*s;
+
+	Con_Close();
+
+	clc.connectPacketCount = 0;
+
+	// wipe local client state
+	CL_ClearState();
+
+#ifdef _DONETPROFILE_
+	int startBytes,endBytes;
+	startBytes=msg->readcount;
+#endif
+
+	// a gamestate always marks a server command sequence
+	clc.serverCommandSequence = MSG_ReadLong( msg );
+
+	// parse all the configstrings and baselines
+	cl.gameState.dataCount = 1;	// leave a 0 at the beginning for uninitialized configstrings
+	while ( 1 ) {
+		cmd = MSG_ReadByte( msg );
+
+		if ( cmd == svc_EOF ) {
+			break;
+		}
+		
+		if ( cmd == svc_configstring ) {
+			int		len, start;
+
+			start = msg->readcount;
+
+			i = MSG_ReadShort( msg );
+			if ( i < 0 || i >= MAX_CONFIGSTRINGS ) {
+				Com_Error( ERR_DROP, "configstring > MAX_CONFIGSTRINGS" );
+			}
+			s = MSG_ReadBigString( msg );
+
+			if (cl_shownet->integer >= 2)
+			{
+				Com_Printf("%3i: %d: %s\n", start, i, s);
+			}
+
+			/*
+			if (i == CS_SERVERINFO)
+			{ //get the special value here
+				char *f = strstr(s, "g_debugMelee");
+				if (f)
+				{
+					while (*f && *f != '\\')
+					{ //find the \ after it
+						f++;
+					}
+					if (*f == '\\')
+					{ //got it
+						int i = 0;
+
+						f++;
+						while (*f && *f != '\\' && i < 128)
+						{
+							hiddenCvarVal[i] = *f;
+							i++;
+							f++;
+						}
+						hiddenCvarVal[i] = 0;
+
+						//resume here
+						s = f;
+					}
+				}
+			}
+			*/
+
+			len = strlen( s );
+
+			if ( len + 1 + cl.gameState.dataCount > MAX_GAMESTATE_CHARS ) {
+				Com_Error( ERR_DROP, "MAX_GAMESTATE_CHARS exceeded" );
+			}
+
+			// append it to the gameState string buffer
+			cl.gameState.stringOffsets[ i ] = cl.gameState.dataCount;
+			Com_Memcpy( cl.gameState.stringData + cl.gameState.dataCount, s, len + 1 );
+			cl.gameState.dataCount += len + 1;
+		} else if ( cmd == svc_baseline ) {
+			newnum = MSG_ReadBits( msg, GENTITYNUM_BITS );
+			if ( newnum < 0 || newnum >= MAX_GENTITIES ) {
+				Com_Error( ERR_DROP, "Baseline number out of range: %i", newnum );
+			}
+			Com_Memset (&nullstate, 0, sizeof(nullstate));
+			es = &cl.entityBaselines[ newnum ];
+			MSG_ReadDeltaEntity( msg, &nullstate, es, newnum );
+		} else {
+			Com_Error( ERR_DROP, "CL_ParseGamestate: bad command byte" );
+		}
+	}
+
+	clc.clientNum = MSG_ReadLong(msg);
+	// read the checksum feed
+	clc.checksumFeed = MSG_ReadLong( msg );
+
+	CL_ParseRMG ( msg ); //rwwRMG - get info for it from the server
+
+#ifdef _DONETPROFILE_
+	endBytes=msg->readcount;
+//	ClReadProf().AddField("svc_gamestate",endBytes-startBytes);
+#endif
+
+	// parse serverId and other cvars
+	CL_SystemInfoChanged();
+
+	// reinitialize the filesystem if the game directory has changed
+	if( FS_ConditionalRestart( clc.checksumFeed ) ) {
+		// don't set to true because we yet have to start downloading
+		// enabling this can cause double loading of a map when connecting to
+		// a server which has a different game directory set
+		//clc.downloadRestart = qtrue;
+	}
+
+	// This used to call CL_StartHunkUsers, but now we enter the download state before loading the
+	// cgame
+	CL_InitDownloads();
+
+	// make sure the game starts
+	Cvar_Set( "cl_paused", "0" );
+}
+
+
+//=====================================================================
+
+/*
+=====================
+CL_ParseDownload
+
+A download message has been received from the server
+=====================
+*/
+void CL_ParseDownload ( msg_t *msg ) {
+#ifdef _XBOX
+	assert(!"Xbox received a download message. Unsupported!");
+#else
+	int		size;
+	unsigned char data[MAX_MSGLEN];
+	int block;
+
+	// read the data
+	block = (unsigned short)MSG_ReadShort ( msg );
+
+	if ( !block )
+	{
+		// block zero is special, contains file size
+		clc.downloadSize = MSG_ReadLong ( msg );
+
+		Cvar_SetValue( "cl_downloadSize", clc.downloadSize );
+
+		if (clc.downloadSize < 0)
+		{
+			Com_Error(ERR_DROP, MSG_ReadString( msg ) );
+			return;
+		}
+	}
+
+	size = (unsigned short)MSG_ReadShort ( msg );
+	if (size > 0)
+		MSG_ReadData( msg, data, size );
+
+	if (clc.downloadBlock != block) {
+		Com_DPrintf( "CL_ParseDownload: Expected block %d, got %d\n", clc.downloadBlock, block);
+		return;
+	}
+
+	// open the file if not opened yet
+	if (!clc.download)
+	{
+		if (!*clc.downloadTempName) {
+			Com_Printf("Server sending download, but no download was requested\n");
+			CL_AddReliableCommand( "stopdl" );
+			return;
+		}
+
+		clc.download = FS_SV_FOpenFileWrite( clc.downloadTempName );
+
+		if (!clc.download) {
+			Com_Printf( "Could not create %s\n", clc.downloadTempName );
+			CL_AddReliableCommand( "stopdl" );
+			CL_NextDownload();
+			return;
+		}
+	}
+
+	if (size)
+		FS_Write( data, size, clc.download );
+
+	CL_AddReliableCommand( va("nextdl %d", clc.downloadBlock) );
+	clc.downloadBlock++;
+
+	clc.downloadCount += size;
+
+	// So UI gets access to it
+	Cvar_SetValue( "cl_downloadCount", clc.downloadCount );
+
+	if (!size) { // A zero length block means EOF
+		if (clc.download) {
+			FS_FCloseFile( clc.download );
+			clc.download = 0;
+
+			// rename the file
+			FS_SV_Rename ( clc.downloadTempName, clc.downloadName );
+		}
+		*clc.downloadTempName = *clc.downloadName = 0;
+		Cvar_Set( "cl_downloadName", "" );
+
+		// send intentions now
+		// We need this because without it, we would hold the last nextdl and then start
+		// loading right away.  If we take a while to load, the server is happily trying
+		// to send us that last block over and over.
+		// Write it twice to help make sure we acknowledge the download
+		CL_WritePacket();
+		CL_WritePacket();
+
+		// get another file if needed
+		CL_NextDownload ();
+	}
+#endif
+}
+
+int CL_GetValueForHidden(const char *s)
+{ //string arg here just in case I want to add more sometime and make a lookup table
+	return atoi(hiddenCvarVal);
+}
+
+/*
+=====================
+CL_ParseCommandString
+
+Command strings are just saved off until cgame asks for them
+when it transitions a snapshot
+=====================
+*/
+void CL_ParseCommandString( msg_t *msg ) {
+	char	*s;
+	int		seq;
+	int		index;
+
+#ifdef _DONETPROFILE_
+	int startBytes,endBytes;
+	startBytes=msg->readcount;
+#endif
+	seq = MSG_ReadLong( msg );
+	s = MSG_ReadString( msg );
+#ifdef _DONETPROFILE_
+	endBytes=msg->readcount;
+	ClReadProf().AddField("svc_serverCommand",endBytes-startBytes);
+#endif
+	// see if we have already executed stored it off
+	if ( clc.serverCommandSequence >= seq ) {
+		return;
+	}
+	clc.serverCommandSequence = seq;
+
+	index = seq & (MAX_RELIABLE_COMMANDS-1);
+	/*
+	if (s[0] == 'c' && s[1] == 's' && s[2] == ' ' && s[3] == '0' && s[4] == ' ')
+	{ //yes.. we seem to have an incoming server info.
+		char *f = strstr(s, "g_debugMelee");
+		if (f)
+		{
+			while (*f && *f != '\\')
+			{ //find the \ after it
+				f++;
+			}
+			if (*f == '\\')
+			{ //got it
+				int i = 0;
+
+				f++;
+				while (*f && *f != '\\' && i < 128)
+				{
+					hiddenCvarVal[i] = *f;
+					i++;
+					f++;
+				}
+				hiddenCvarVal[i] = 0;
+
+				//don't worry about backing over beginning of string I guess,
+				//we already know we successfully strstr'd the initial string
+				//which exceeds this length.
+				//MSG_ReadString appears to just return a static buffer so I
+				//can stomp over its contents safely.
+				f--;
+				*f = '\"';
+				f--;
+				*f = ' ';
+				f--;
+				*f = '0';
+				f--;
+				*f = ' ';
+				f--;
+				*f = 's';
+				f--;
+				*f = 'c';
+
+				//the normal configstring gets to start here...
+				s = f;
+			}
+		}
+	}
+	*/
+	Q_strncpyz( clc.serverCommands[ index ], s, sizeof( clc.serverCommands[ index ] ) );
+}
+
+
+/*
+=====================
+CL_ParseServerMessage
+=====================
+*/
+void CL_ParseServerMessage( msg_t *msg ) {
+	int			cmd;
+
+	if ( cl_shownet->integer == 1 ) {
+		Com_Printf ("%i ",msg->cursize);
+	} else if ( cl_shownet->integer >= 2 ) {
+		Com_Printf ("------------------\n");
+	}
+
+	MSG_Bitstream(msg);
+
+	// get the reliable sequence acknowledge number
+	clc.reliableAcknowledge = MSG_ReadLong( msg );
+	// 
+	if ( clc.reliableAcknowledge < clc.reliableSequence - MAX_RELIABLE_COMMANDS ) {
+		clc.reliableAcknowledge = clc.reliableSequence;
+	}
+
+	//
+	// parse the message
+	//
+	while ( 1 ) {
+		if ( msg->readcount > msg->cursize ) {
+			Com_Error (ERR_DROP,"CL_ParseServerMessage: read past end of server message");
+			break;
+		}
+
+		cmd = MSG_ReadByte( msg );
+
+		if ( cmd == svc_EOF) {
+			SHOWNET( msg, "END OF MESSAGE" );
+			break;
+		}
+
+		if ( cl_shownet->integer >= 2 ) {
+			if ( !svc_strings[cmd] ) {
+				Com_Printf( "%3i:BAD CMD %i\n", msg->readcount-1, cmd );
+			} else {
+				SHOWNET( msg, svc_strings[cmd] );
+			}
+		}
+	
+	// other commands
+		switch ( cmd ) {
+		default:
+			Com_Error (ERR_DROP,"CL_ParseServerMessage: Illegible server message\n");
+			break;			
+		case svc_nop:
+			break;
+		case svc_serverCommand:
+			CL_ParseCommandString( msg );
+			break;
+		case svc_gamestate:
+			CL_ParseGamestate( msg );
+			break;
+		case svc_snapshot:
+			CL_ParseSnapshot( msg );
+			break;
+		case svc_setgame:
+			CL_ParseSetGame( msg );
+			break;
+		case svc_download:
+			CL_ParseDownload( msg );
+			break;
+		case svc_mapchange:
+			if (cgvm)
+			{
+				VM_Call( cgvm, CG_MAP_CHANGE );
+			}
+			break;
+#ifdef _XBOX
+		case svc_newpeer:
+			{ //jsw// new client to add to our XBonlineInfo
+				// We now get the index that we should use to store this from the server
+				// That ensures that our playerlist and clientinfo stay in sync!
+				int index = MSG_ReadLong(msg);
+
+				// Sanity check - server shouldn't have us overwriting an active player
+				// Unless, we're the server, in which case it will be active. Doh.
+				assert( com_sv_running->integer ||
+						!xbOnlineInfo.xbPlayerList[index].isActive );
+
+				// OK. Read directly into the right place
+				MSG_ReadData(msg, &xbOnlineInfo.xbPlayerList[index], sizeof(XBPlayerInfo));
+
+				// Need to do address conversion here, voice needs it
+				XNetXnAddrToInAddr( &xbOnlineInfo.xbPlayerList[index].xbAddr,
+									Net_GetXNKID(),
+									&xbOnlineInfo.xbPlayerList[index].inAddr );
+
+				// VVFIXME - Search for g_Voice here - lots of stuff we're not doing
+				// g_Voice.OnPlayerJoined( index );
+				//if(g_Voice.IsPlayerMuted(&xbOnlineInfo.xbPlayerList[index].xuid))
+				//{
+				//	g_Voice.MutePlayer(&xbOnlineInfo.xbPlayerList[index].xbAddr, &xbOnlineInfo.xbPlayerList[index].xuid, false);
+				//	xbOnlineInfo.xbPlayerList[index].flags |= MUTED_PLAYER;
+				//}
+				//else if(Cvar_Get(CVAR_XBL_WT_ACTIVE)->integer)
+				//{	//reset w/t in case he's on the channel
+				//	g_Voice.EnableWalkieTalkie();
+				//}
+
+				XBL_PL_CheckHistoryList(&xbOnlineInfo.xbPlayerList[index]);
+				break;
+			}
+		case svc_removepeer:
+			{
+				// Remove a client from our xbOnlineInfo. Our ordering is the same
+				// as the server, so we just get an index.
+				int index = MSG_ReadLong(msg);
+
+				// Sanity check
+				assert( xbOnlineInfo.xbPlayerList[index].isActive &&
+						index != xbOnlineInfo.localIndex );
+
+				// Clear out important information
+				xbOnlineInfo.xbPlayerList[index].isActive = false;
+				g_Voice.OnPlayerDisconnect( &xbOnlineInfo.xbPlayerList[index] );
+				XBL_PL_RemoveActivePeer(&xbOnlineInfo.xbPlayerList[index].xuid, index);
+				break;
+			}
+		case svc_xbInfo:
+			{ //jsw//get XNADDR list from server
+				MSG_ReadData(msg, &xbOnlineInfo, sizeof(XBOnlineInfo));
+
+				// Immediately convert everyone's XNADDR to an IN_ADDR
+				for( int i = 0; i < MAX_ONLINE_PLAYERS; ++i )
+				{
+					if( xbOnlineInfo.xbPlayerList[i].isActive )
+						XNetXnAddrToInAddr( &xbOnlineInfo.xbPlayerList[i].xbAddr,
+											Net_GetXNKID(),
+											&xbOnlineInfo.xbPlayerList[i].inAddr );
+				}
+
+				//now find which entry we are
+				if( logged_on )
+				{
+					PXONLINE_USER pToUser = XOnlineGetLogonUsers();
+					BOOL found = false;
+					for( int i = 0; i < MAX_ONLINE_PLAYERS && !found; i++ )
+					{
+						if( xbOnlineInfo.xbPlayerList[i].isActive && XOnlineAreUsersIdentical(&pToUser->xuid, &xbOnlineInfo.xbPlayerList[i].xuid))
+						{
+							xbOnlineInfo.localIndex = i;
+							found = true;
+						}
+					}
+
+					// OK. Time to join the chat! - VVFIXME - need to check mute lists
+					g_Voice.JoinSession();
+				}
+				else
+				{
+					DWORD dwStatus;
+					IN_ADDR localAddr;
+					XNetXnAddrToInAddr(Net_GetXNADDR( &dwStatus ), Net_GetXNKID(), &localAddr);
+
+					if( dwStatus != XNET_GET_XNADDR_NONE )
+					{
+						int j;
+						for( j = 0; j < MAX_ONLINE_PLAYERS; ++j )
+						{
+							if( xbOnlineInfo.xbPlayerList[j].isActive &&
+								localAddr.s_addr == xbOnlineInfo.xbPlayerList[i].inAddr.s_addr )
+								break;
+						}
+						xbOnlineInfo.localIndex = (j == MAX_ONLINE_PLAYERS) ? -1 : j;
+					}
+				}
+
+				break;
+			}
+#endif
+		}
+	}
+}
+
+
+extern int			scr_center_y;
+void SCR_CenterPrint (char *str);//, PalIdx_t colour)
diff --git a/codemp/client/cl_scrn.cpp b/codemp/client/cl_scrn.cpp
new file mode 100644
index 0000000..ec12b2b
--- /dev/null
+++ b/codemp/client/cl_scrn.cpp
@@ -0,0 +1,624 @@
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+// cl_scrn.c -- master for refresh, status bar, console, chat, notify, etc
+
+#include "client.h"
+
+extern console_t con;
+qboolean	scr_initialized;		// ready to draw
+
+cvar_t		*cl_timegraph;
+cvar_t		*cl_debuggraph;
+cvar_t		*cl_graphheight;
+cvar_t		*cl_graphscale;
+cvar_t		*cl_graphshift;
+
+/*
+================
+SCR_DrawNamedPic
+
+Coordinates are 640*480 virtual values
+=================
+*/
+void SCR_DrawNamedPic( float x, float y, float width, float height, const char *picname ) {
+	qhandle_t	hShader;
+
+	assert( width != 0 );
+
+	hShader = re.RegisterShader( picname );
+	re.DrawStretchPic( x, y, width, height, 0, 0, 1, 1, hShader );
+}
+
+
+/*
+================
+SCR_FillRect
+
+Coordinates are 640*480 virtual values
+=================
+*/
+void SCR_FillRect( float x, float y, float width, float height, const float *color ) {
+	re.SetColor( color );
+
+	re.DrawStretchPic( x, y, width, height, 0, 0, 0, 0, cls.whiteShader );
+
+	re.SetColor( NULL );
+}
+
+
+/*
+================
+SCR_DrawPic
+
+Coordinates are 640*480 virtual values
+=================
+*/
+void SCR_DrawPic( float x, float y, float width, float height, qhandle_t hShader ) {
+	re.DrawStretchPic( x, y, width, height, 0, 0, 1, 1, hShader );
+}
+
+
+
+/*
+** SCR_DrawChar
+** chars are drawn at 640*480 virtual screen size
+*/
+static void SCR_DrawChar( int x, int y, float size, int ch ) {
+	int row, col;
+	float frow, fcol;
+	float	ax, ay, aw, ah;
+
+	ch &= 255;
+
+	if ( ch == ' ' ) {
+		return;
+	}
+
+	if ( y < -size ) {
+		return;
+	}
+
+	ax = x;
+	ay = y;
+	aw = size;
+	ah = size;
+
+	row = ch>>4;
+	col = ch&15;
+
+	float size2;
+
+	frow = row*0.0625;
+	fcol = col*0.0625;
+	size = 0.03125;
+	size2 = 0.0625;
+
+	re.DrawStretchPic( ax, ay, aw, ah,
+					   fcol, frow, 
+					   fcol + size, frow + size2, 
+					   cls.charSetShader );
+}
+
+/*
+** SCR_DrawSmallChar
+** small chars are drawn at native screen resolution
+*/
+void SCR_DrawSmallChar( int x, int y, int ch ) {
+	int row, col;
+	float frow, fcol;
+	float size;
+
+	ch &= 255;
+
+	if ( ch == ' ' ) {
+		return;
+	}
+
+	if ( y < -SMALLCHAR_HEIGHT ) {
+		return;
+	}
+
+	row = ch>>4;
+	col = ch&15;
+
+	float size2;
+
+	frow = row*0.0625;
+	fcol = col*0.0625;
+
+#ifdef _JK2
+	size = 0.03125;
+#else
+	size = 0.0625;
+#endif
+	size2 = 0.0625;
+
+	re.DrawStretchPic( x * con.xadjust, y * con.yadjust, 
+						SMALLCHAR_WIDTH * con.xadjust, SMALLCHAR_HEIGHT * con.yadjust, 
+					   fcol, frow, 
+					   fcol + size, frow + size2, 
+					   cls.charSetShader );
+}
+
+
+/*
+==================
+SCR_DrawBigString[Color]
+
+Draws a multi-colored string with a drop shadow, optionally forcing
+to a fixed color.
+
+Coordinates are at 640 by 480 virtual resolution
+==================
+*/
+void SCR_DrawStringExt( int x, int y, float size, const char *string, float *setColor, qboolean forceColor ) {
+	vec4_t		color;
+	const char	*s;
+	int			xx;
+
+	// draw the drop shadow
+	color[0] = color[1] = color[2] = 0;
+	color[3] = setColor[3];
+	re.SetColor( color );
+	s = string;
+	xx = x;
+	while ( *s ) {
+		if ( Q_IsColorString( s ) ) {
+			s += 2;
+			continue;
+		}
+		SCR_DrawChar( xx+2, y+2, size, *s );
+		xx += size;
+		s++;
+	}
+
+
+	// draw the colored text
+	s = string;
+	xx = x;
+	re.SetColor( setColor );
+	while ( *s ) {
+		if ( Q_IsColorString( s ) ) {
+			if ( !forceColor ) {
+				Com_Memcpy( color, g_color_table[ColorIndex(*(s+1))], sizeof( color ) );
+				color[3] = setColor[3];
+				re.SetColor( color );
+			}
+			s += 2;
+			continue;
+		}
+		SCR_DrawChar( xx, y, size, *s );
+		xx += size;
+		s++;
+	}
+	re.SetColor( NULL );
+}
+
+
+void SCR_DrawBigString( int x, int y, const char *s, float alpha ) {
+	float	color[4];
+
+	color[0] = color[1] = color[2] = 1.0;
+	color[3] = alpha;
+	SCR_DrawStringExt( x, y, BIGCHAR_WIDTH, s, color, qfalse );
+}
+
+void SCR_DrawBigStringColor( int x, int y, const char *s, vec4_t color ) {
+	SCR_DrawStringExt( x, y, BIGCHAR_WIDTH, s, color, qtrue );
+}
+
+
+/*
+==================
+SCR_DrawSmallString[Color]
+
+Draws a multi-colored string with a drop shadow, optionally forcing
+to a fixed color.
+
+Coordinates are at 640 by 480 virtual resolution
+==================
+*/
+void SCR_DrawSmallStringExt( int x, int y, const char *string, float *setColor, qboolean forceColor ) {
+	vec4_t		color;
+	const char	*s;
+	int			xx;
+
+	// draw the colored text
+	s = string;
+	xx = x;
+	re.SetColor( setColor );
+	while ( *s ) {
+		if ( Q_IsColorString( s ) ) {
+			if ( !forceColor ) {
+				Com_Memcpy( color, g_color_table[ColorIndex(*(s+1))], sizeof( color ) );
+				color[3] = setColor[3];
+				re.SetColor( color );
+			}
+			s += 2;
+			continue;
+		}
+		SCR_DrawSmallChar( xx, y, *s );
+		xx += SMALLCHAR_WIDTH;
+		s++;
+	}
+	re.SetColor( NULL );
+}
+
+
+
+/*
+** SCR_Strlen -- skips color escape codes
+*/
+static int SCR_Strlen( const char *str ) {
+	const char *s = str;
+	int count = 0;
+
+	while ( *s ) {
+		if ( Q_IsColorString( s ) ) {
+			s += 2;
+		} else {
+			count++;
+			s++;
+		}
+	}
+
+	return count;
+}
+
+/*
+** SCR_GetBigStringWidth
+*/ 
+int	SCR_GetBigStringWidth( const char *str ) {
+	return SCR_Strlen( str ) * 16;
+}
+
+
+//===============================================================================
+
+/*
+=================
+SCR_DrawDemoRecording
+=================
+*/
+void SCR_DrawDemoRecording( void ) {
+#ifndef _XBOX	// No demos on Xbox
+	char	string[1024];
+	int		pos;
+
+	if ( !clc.demorecording ) {
+		return;
+	}
+	if ( clc.spDemoRecording ) {
+		return;
+	}
+
+	pos = FS_FTell( clc.demofile );
+	sprintf( string, "RECORDING %s: %ik", clc.demoName, pos / 1024 );
+
+	SCR_DrawStringExt( 320 - strlen( string ) * 4, 20, 8, string, g_color_table[7], qtrue );
+#endif
+}
+
+
+/*
+===============================================================================
+
+DEBUG GRAPH
+
+===============================================================================
+*/
+
+typedef struct
+{
+	float	value;
+	int		color;
+} graphsamp_t;
+
+static	int			current;
+static	graphsamp_t	values[1024];
+
+/*
+==============
+SCR_DebugGraph
+==============
+*/
+void SCR_DebugGraph (float value, int color)
+{
+	values[current&1023].value = value;
+	values[current&1023].color = color;
+	current++;
+}
+
+/*
+==============
+SCR_DrawDebugGraph
+==============
+*/
+void SCR_DrawDebugGraph (void)
+{
+	int		a, x, y, w, i, h;
+	float	v;
+	int		color;
+
+	//
+	// draw the graph
+	//
+	w = cls.glconfig.vidWidth;
+	x = 0;
+	y = cls.glconfig.vidHeight;
+	re.SetColor( g_color_table[0] );
+	re.DrawStretchPic(x, y - cl_graphheight->integer, 
+		w, cl_graphheight->integer, 0, 0, 0, 0, cls.whiteShader );
+	re.SetColor( NULL );
+
+	for (a=0 ; a<w ; a++)
+	{
+		i = (current-1-a+1024) & 1023;
+		v = values[i].value;
+		color = values[i].color;
+		v = v * cl_graphscale->integer + cl_graphshift->integer;
+		
+		if (v < 0)
+			v += cl_graphheight->integer * (1+(int)(-v / cl_graphheight->integer));
+		h = (int)v % cl_graphheight->integer;
+		re.DrawStretchPic( x+w-1-a, y - h, 1, h, 0, 0, 0, 0, cls.whiteShader );
+	}
+}
+
+//=============================================================================
+
+/*
+==================
+SCR_Init
+==================
+*/
+void SCR_Init( void ) {
+	cl_timegraph = Cvar_Get ("timegraph", "0", CVAR_CHEAT);
+	cl_debuggraph = Cvar_Get ("debuggraph", "0", CVAR_CHEAT);
+	cl_graphheight = Cvar_Get ("graphheight", "32", CVAR_CHEAT);
+	cl_graphscale = Cvar_Get ("graphscale", "1", CVAR_CHEAT);
+	cl_graphshift = Cvar_Get ("graphshift", "0", CVAR_CHEAT);
+
+	scr_initialized = qtrue;
+}
+
+
+//=======================================================
+
+/*
+==================
+SCR_DrawScreenField
+
+This will be called twice if rendering in stereo mode
+==================
+*/
+void SCR_DrawScreenField( stereoFrame_t stereoFrame ) {
+	re.BeginFrame( stereoFrame );
+
+	// wide aspect ratio screens need to have the sides cleared
+	// unless they are displaying game renderings
+	if ( cls.state != CA_ACTIVE ) {
+		if ( cls.glconfig.vidWidth * 480 > cls.glconfig.vidHeight * 640 ) {
+			re.SetColor( g_color_table[0] );
+			re.DrawStretchPic( 0, 0, cls.glconfig.vidWidth, cls.glconfig.vidHeight, 0, 0, 0, 0, cls.whiteShader );
+			re.SetColor( NULL );
+		}
+	}
+
+	if ( !uivm ) {
+		Com_DPrintf("draw screen without UI loaded\n");
+		return;
+	}
+
+	// if the menu is going to cover the entire screen, we
+	// don't need to render anything under it
+	//actually, yes you do, unless you want clients to cycle out their reliable
+	//commands from sitting in the menu. -rww
+	if ( !VM_Call( uivm, UI_IS_FULLSCREEN ) || (!(cls.framecount&7) && cls.state == CA_ACTIVE)) {
+		switch( cls.state ) {
+		default:
+			Com_Error( ERR_FATAL, "SCR_DrawScreenField: bad cls.state" );
+			break;
+		case CA_CINEMATIC:
+			SCR_DrawCinematic();
+			break;
+		case CA_DISCONNECTED:
+			// force menu up
+			S_StopAllSounds();
+			VM_Call( uivm, UI_SET_ACTIVE_MENU, UIMENU_MAIN );
+			break;
+		case CA_CONNECTING:
+		case CA_CHALLENGING:
+		case CA_CONNECTED:
+			// connecting clients will only show the connection dialog
+			// refresh to update the time
+			VM_Call( uivm, UI_REFRESH, cls.realtime );
+			VM_Call( uivm, UI_DRAW_CONNECT_SCREEN, qfalse );
+			break;
+		case CA_LOADING:
+		case CA_PRIMED:
+			// draw the game information screen and loading progress
+			CL_CGameRendering( stereoFrame );
+
+			// also draw the connection information, so it doesn't
+			// flash away too briefly on local or lan games
+			// refresh to update the time
+			VM_Call( uivm, UI_REFRESH, cls.realtime );
+			VM_Call( uivm, UI_DRAW_CONNECT_SCREEN, qtrue );
+			break;
+		case CA_ACTIVE:
+			CL_CGameRendering( stereoFrame );
+			SCR_DrawDemoRecording();
+			break;
+		}
+	}
+
+	// the menu draws next
+	if ( cls.keyCatchers & KEYCATCH_UI && uivm ) {
+		VM_Call( uivm, UI_REFRESH, cls.realtime );
+	}
+
+	// console draws next
+	Con_DrawConsole ();
+
+	// debug graph can be drawn on top of anything
+	if ( cl_debuggraph->integer || cl_timegraph->integer || cl_debugMove->integer ) {
+		SCR_DrawDebugGraph ();
+	}
+}
+
+/*
+==================
+SCR_UpdateScreen
+
+This is called every frame, and can also be called explicitly to flush
+text to the screen.
+==================
+*/
+void SCR_UpdateScreen( void ) {
+	static int	recursive;
+
+	if ( !scr_initialized ) {
+		return;				// not initialized yet
+	}
+
+	if ( ++recursive > 2 ) {
+		Com_Error( ERR_FATAL, "SCR_UpdateScreen: recursively called" );
+	}
+	recursive = 1;
+
+	// if running in stereo, we need to draw the frame twice
+	if ( cls.glconfig.stereoEnabled ) {
+		SCR_DrawScreenField( STEREO_LEFT );
+		SCR_DrawScreenField( STEREO_RIGHT );
+	} else {
+		SCR_DrawScreenField( STEREO_CENTER );
+	}
+
+	if ( com_speeds->integer ) {
+		re.EndFrame( &time_frontend, &time_backend );
+	} else {
+		re.EndFrame( NULL, NULL );
+	}
+
+	recursive = 0;
+}
+
+#define MAX_SCR_LINES 10
+
+static float		scr_centertime_off;
+int					scr_center_y;
+//static string		scr_font;
+static char			scr_centerstring[1024];
+static int			scr_center_lines;
+static int			scr_center_widths[MAX_SCR_LINES];
+
+cvar_t		*scr_centertime;
+
+void SCR_CenterPrint (char *str)//, PalIdx_t colour)
+{
+	char	*s, *last, *start, *write_pos, *save_pos;
+	int		num_chars;
+	int		num_lines;
+	int		width;
+	bool	done = false;
+	bool	spaced;
+
+	if (!str)
+	{
+		scr_centertime_off = 0;
+		return;
+	}
+
+//	scr_font = string("medium");
+
+	// RWL - commented out
+//	width = viddef.width / 8;	// rjr hardcoded yuckiness
+	width = 640 / 8;	// rjr hardcoded yuckiness
+	width -= 4;
+
+	// RWL - commented out
+/*
+	if (cl.frame.playerstate.remote_type != REMOTE_TYPE_LETTERBOX)
+	{
+		width -= 30;
+	}
+*/
+
+	scr_centertime_off = scr_centertime->value;
+
+	Com_Printf("\n");
+
+	num_lines = 0;
+	write_pos = scr_centerstring;
+	scr_center_lines = 0;
+	spaced = false;
+	for(s = start = str, last=NULL, num_chars = 0; !done ; s++)
+	{
+		num_chars++;
+		if ((*s) == ' ')
+		{
+			spaced = true;
+			last = s;
+			scr_centertime_off += 0.2;//give them an extra 0.05 second for each character
+		}
+
+		if ((*s) == '\n' || (*s) == 0)
+		{
+			last = s;
+			num_chars = width;
+			spaced = true;
+		}
+
+		if (num_chars >= width)
+		{
+			scr_centertime_off += 0.8;//give them an extra half second for each newline
+			if (!last)
+			{
+				last = s;
+			}
+			if (!spaced)
+			{
+				last++;
+			}
+
+			save_pos = write_pos;
+			strncpy(write_pos, start, last-start);
+			write_pos += last-start;
+			*write_pos = 0;
+			write_pos++;
+
+			Com_Printf ("%s\n", save_pos);
+
+			// RWL - commented out
+//			scr_center_widths[scr_center_lines] = re.StrlenFont(save_pos, scr_font);;
+			scr_center_widths[scr_center_lines] = 640;
+
+
+			scr_center_lines++;
+
+			if ((*s) == NULL || scr_center_lines >= MAX_SCR_LINES)
+			{
+				done = true;
+			}
+			else
+			{
+				s = last;
+				if (spaced)
+				{
+					last++;
+				}
+				start = last;
+				last = NULL;
+				num_chars = 0;
+				spaced = false;
+			}
+			continue;
+		}
+	}
+
+	// echo it to the console
+	Com_Printf("\n\n");
+	Con_ClearNotify ();
+}
diff --git a/codemp/client/cl_ui.cpp b/codemp/client/cl_ui.cpp
new file mode 100644
index 0000000..b0fd9f8
--- /dev/null
+++ b/codemp/client/cl_ui.cpp
@@ -0,0 +1,1518 @@
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+#include "client.h"
+
+#include "../game/botlib.h"
+#include "../qcommon/stringed_ingame.h"
+
+/*
+Ghoul2 Insert Start
+*/
+
+#if !defined(G2_H_INC)
+	#include "../ghoul2/G2_local.h"
+#endif
+
+/*
+Ghoul2 Insert End
+*/
+
+#ifdef VV_LIGHTING
+#include "../renderer/tr_lightmanager.h"
+#endif
+
+extern	botlib_export_t	*botlib_export;
+void SP_Register(const char *Package);
+
+vm_t *uivm;
+
+#ifdef USE_CD_KEY
+
+extern char cl_cdkey[34];
+
+#endif // USE_CD_KEY
+
+/*
+====================
+GetClientState
+====================
+*/
+static void GetClientState( uiClientState_t *state ) {
+	state->connectPacketCount = clc.connectPacketCount;
+	state->connState = cls.state;
+	Q_strncpyz( state->servername, cls.servername, sizeof( state->servername ) );
+	Q_strncpyz( state->updateInfoString, cls.updateInfoString, sizeof( state->updateInfoString ) );
+	Q_strncpyz( state->messageString, clc.serverMessage, sizeof( state->messageString ) );
+	state->clientNum = cl.snap.ps.clientNum;
+}
+
+/*
+====================
+LAN_LoadCachedServers
+====================
+*/
+void LAN_LoadCachedServers( ) {
+	int size;
+	fileHandle_t fileIn;
+	cls.numglobalservers = cls.nummplayerservers = cls.numfavoriteservers = 0;
+	cls.numGlobalServerAddresses = 0;
+#ifndef _XBOX
+	if (FS_SV_FOpenFileRead("servercache.dat", &fileIn)) {
+		FS_Read(&cls.numglobalservers, sizeof(int), fileIn);
+		FS_Read(&cls.nummplayerservers, sizeof(int), fileIn);
+		FS_Read(&cls.numfavoriteservers, sizeof(int), fileIn);
+		FS_Read(&size, sizeof(int), fileIn);
+		if (size == sizeof(cls.globalServers) + sizeof(cls.favoriteServers) + sizeof(cls.mplayerServers)) {
+			FS_Read(&cls.globalServers, sizeof(cls.globalServers), fileIn);
+			FS_Read(&cls.mplayerServers, sizeof(cls.mplayerServers), fileIn);
+			FS_Read(&cls.favoriteServers, sizeof(cls.favoriteServers), fileIn);
+		} else {
+			cls.numglobalservers = cls.nummplayerservers = cls.numfavoriteservers = 0;
+			cls.numGlobalServerAddresses = 0;
+		}
+		FS_FCloseFile(fileIn);
+	}
+#endif
+}
+
+/*
+====================
+LAN_SaveServersToCache
+====================
+*/
+void LAN_SaveServersToCache( ) {
+#ifndef _XBOX
+	int size;
+	fileHandle_t fileOut = FS_SV_FOpenFileWrite("servercache.dat");
+	FS_Write(&cls.numglobalservers, sizeof(int), fileOut);
+	FS_Write(&cls.nummplayerservers, sizeof(int), fileOut);
+	FS_Write(&cls.numfavoriteservers, sizeof(int), fileOut);
+	size = sizeof(cls.globalServers) + sizeof(cls.favoriteServers) + sizeof(cls.mplayerServers);
+	FS_Write(&size, sizeof(int), fileOut);
+	FS_Write(&cls.globalServers, sizeof(cls.globalServers), fileOut);
+	FS_Write(&cls.mplayerServers, sizeof(cls.mplayerServers), fileOut);
+	FS_Write(&cls.favoriteServers, sizeof(cls.favoriteServers), fileOut);
+	FS_FCloseFile(fileOut);
+#endif
+}
+
+
+/*
+====================
+LAN_ResetPings
+====================
+*/
+static void LAN_ResetPings(int source) {
+	int count,i;
+	serverInfo_t *servers = NULL;
+	count = 0;
+
+	switch (source) {
+		case AS_LOCAL :
+			servers = &cls.localServers[0];
+			count = MAX_OTHER_SERVERS;
+			break;
+		case AS_MPLAYER :
+			servers = &cls.mplayerServers[0];
+			count = MAX_OTHER_SERVERS;
+			break;
+		case AS_GLOBAL :
+			servers = &cls.globalServers[0];
+			count = MAX_GLOBAL_SERVERS;
+			break;
+		case AS_FAVORITES :
+			servers = &cls.favoriteServers[0];
+			count = MAX_OTHER_SERVERS;
+			break;
+	}
+	if (servers) {
+		for (i = 0; i < count; i++) {
+			servers[i].ping = -1;
+		}
+	}
+}
+
+/*
+====================
+LAN_AddServer
+====================
+*/
+static int LAN_AddServer(int source, const char *name, const char *address) {
+	int max, *count, i;
+	netadr_t adr;
+	serverInfo_t *servers = NULL;
+	max = MAX_OTHER_SERVERS;
+	count = 0;
+
+	switch (source) {
+		case AS_LOCAL :
+			count = &cls.numlocalservers;
+			servers = &cls.localServers[0];
+			break;
+		case AS_MPLAYER :
+			count = &cls.nummplayerservers;
+			servers = &cls.mplayerServers[0];
+			break;
+		case AS_GLOBAL :
+			max = MAX_GLOBAL_SERVERS;
+			count = &cls.numglobalservers;
+			servers = &cls.globalServers[0];
+			break;
+		case AS_FAVORITES :
+			count = &cls.numfavoriteservers;
+			servers = &cls.favoriteServers[0];
+/*			if (!name || !*name)
+			{
+				name = "?";
+			}
+*/
+			break;
+	}
+	if (servers && *count < max) {
+		NET_StringToAdr( address, &adr );
+		if (adr.type == NA_BAD)
+		{
+			return -1;
+		}
+		for ( i = 0; i < *count; i++ ) {
+			if (NET_CompareAdr(servers[i].adr, adr)) {
+				break;
+			}
+		}
+		if (i >= *count) {
+			servers[*count].adr = adr;
+			Q_strncpyz(servers[*count].hostName, name, sizeof(servers[*count].hostName));
+			servers[*count].visible = qtrue;
+			(*count)++;
+			return 1;
+		}
+		return 0;
+	}
+	return -1;
+}
+
+/*
+====================
+LAN_RemoveServer
+====================
+*/
+static void LAN_RemoveServer(int source, const char *addr) {
+	int *count, i;
+	serverInfo_t *servers = NULL;
+	count = 0;
+	switch (source) {
+		case AS_LOCAL :
+			count = &cls.numlocalservers;
+			servers = &cls.localServers[0];
+			break;
+		case AS_MPLAYER :
+			count = &cls.nummplayerservers;
+			servers = &cls.mplayerServers[0];
+			break;
+		case AS_GLOBAL :
+			count = &cls.numglobalservers;
+			servers = &cls.globalServers[0];
+			break;
+		case AS_FAVORITES :
+			count = &cls.numfavoriteservers;
+			servers = &cls.favoriteServers[0];
+			break;
+	}
+	if (servers) {
+		netadr_t comp;
+		NET_StringToAdr( addr, &comp );
+		for (i = 0; i < *count; i++) {
+			if (servers[i].adr.type==NA_BAD || NET_CompareAdr( comp, servers[i].adr)) {
+				int j = i;
+				while (j < *count - 1) {
+					Com_Memcpy(&servers[j], &servers[j+1], sizeof(servers[j]));
+					j++;
+				}
+				(*count)--;
+				break;
+			}
+		}
+	}
+}
+
+
+/*
+====================
+LAN_GetServerCount
+====================
+*/
+static int LAN_GetServerCount( int source ) {
+	switch (source) {
+		case AS_LOCAL :
+			return cls.numlocalservers;
+			break;
+		case AS_MPLAYER :
+			return cls.nummplayerservers;
+			break;
+		case AS_GLOBAL :
+			return cls.numglobalservers;
+			break;
+		case AS_FAVORITES :
+			return cls.numfavoriteservers;
+			break;
+	}
+	return 0;
+}
+
+/*
+====================
+LAN_GetLocalServerAddressString
+====================
+*/
+static void LAN_GetServerAddressString( int source, int n, char *buf, int buflen ) {
+	switch (source) {
+		case AS_LOCAL :
+			if (n >= 0 && n < MAX_OTHER_SERVERS) {
+				Q_strncpyz(buf, NET_AdrToString( cls.localServers[n].adr) , buflen );
+				return;
+			}
+			break;
+		case AS_MPLAYER :
+			if (n >= 0 && n < MAX_OTHER_SERVERS) {
+				Q_strncpyz(buf, NET_AdrToString( cls.mplayerServers[n].adr) , buflen );
+				return;
+			}
+			break;
+		case AS_GLOBAL :
+			if (n >= 0 && n < MAX_GLOBAL_SERVERS) {
+				Q_strncpyz(buf, NET_AdrToString( cls.globalServers[n].adr) , buflen );
+				return;
+			}
+			break;
+		case AS_FAVORITES :
+			if (n >= 0 && n < MAX_OTHER_SERVERS) {
+				Q_strncpyz(buf, NET_AdrToString( cls.favoriteServers[n].adr) , buflen );
+				return;
+			}
+			break;
+	}
+	buf[0] = '\0';
+}
+
+/*
+====================
+LAN_GetServerInfo
+====================
+*/
+static void LAN_GetServerInfo( int source, int n, char *buf, int buflen ) {
+	char info[MAX_STRING_CHARS];
+	serverInfo_t *server = NULL;
+	info[0] = '\0';
+	switch (source) {
+		case AS_LOCAL :
+			if (n >= 0 && n < MAX_OTHER_SERVERS) {
+				server = &cls.localServers[n];
+			}
+			break;
+		case AS_MPLAYER :
+			if (n >= 0 && n < MAX_OTHER_SERVERS) {
+				server = &cls.mplayerServers[n];
+			}
+			break;
+		case AS_GLOBAL :
+			if (n >= 0 && n < MAX_GLOBAL_SERVERS) {
+				server = &cls.globalServers[n];
+			}
+			break;
+		case AS_FAVORITES :
+			if (n >= 0 && n < MAX_OTHER_SERVERS) {
+				server = &cls.favoriteServers[n];
+			}
+			break;
+	}
+	if (server && buf) {
+		buf[0] = '\0';
+		Info_SetValueForKey( info, "hostname", server->hostName);
+		Info_SetValueForKey( info, "mapname", server->mapName);
+		Info_SetValueForKey( info, "clients", va("%i",server->clients));
+		Info_SetValueForKey( info, "sv_maxclients", va("%i",server->maxClients));
+		Info_SetValueForKey( info, "ping", va("%i",server->ping));
+#ifndef _XBOX
+		Info_SetValueForKey( info, "minping", va("%i",server->minPing));
+		Info_SetValueForKey( info, "maxping", va("%i",server->maxPing));
+		Info_SetValueForKey( info, "nettype", va("%i",server->netType));
+		Info_SetValueForKey( info, "needpass", va("%i", server->needPassword ) );
+		Info_SetValueForKey( info, "truejedi", va("%i", server->trueJedi ) );
+		Info_SetValueForKey( info, "wdisable", va("%i", server->weaponDisable ) );
+		Info_SetValueForKey( info, "fdisable", va("%i", server->forceDisable ) );
+#else
+		Info_SetValueForKey( info, "saberonly", va("%i", server->saberOnly));
+#endif
+		Info_SetValueForKey( info, "game", server->game);
+		Info_SetValueForKey( info, "gametype", va("%i",server->gameType));
+		Info_SetValueForKey( info, "addr", NET_AdrToString(server->adr));
+//		Info_SetValueForKey( info, "sv_allowAnonymous", va("%i", server->allowAnonymous));
+//		Info_SetValueForKey( info, "pure", va("%i", server->pure ) );
+		Q_strncpyz(buf, info, buflen);
+	} else {
+		if (buf) {
+			buf[0] = '\0';
+		}
+	}
+}
+
+/*
+====================
+LAN_GetServerPing
+====================
+*/
+static int LAN_GetServerPing( int source, int n ) {
+	serverInfo_t *server = NULL;
+	switch (source) {
+		case AS_LOCAL :
+			if (n >= 0 && n < MAX_OTHER_SERVERS) {
+				server = &cls.localServers[n];
+			}
+			break;
+		case AS_MPLAYER :
+			if (n >= 0 && n < MAX_OTHER_SERVERS) {
+				server = &cls.mplayerServers[n];
+			}
+			break;
+		case AS_GLOBAL :
+			if (n >= 0 && n < MAX_GLOBAL_SERVERS) {
+				server = &cls.globalServers[n];
+			}
+			break;
+		case AS_FAVORITES :
+			if (n >= 0 && n < MAX_OTHER_SERVERS) {
+				server = &cls.favoriteServers[n];
+			}
+			break;
+	}
+	if (server) {
+		return server->ping;
+	}
+	return -1;
+}
+
+/*
+====================
+LAN_GetServerPtr
+====================
+*/
+static serverInfo_t *LAN_GetServerPtr( int source, int n ) {
+	switch (source) {
+		case AS_LOCAL :
+			if (n >= 0 && n < MAX_OTHER_SERVERS) {
+				return &cls.localServers[n];
+			}
+			break;
+		case AS_MPLAYER :
+			if (n >= 0 && n < MAX_OTHER_SERVERS) {
+				return &cls.mplayerServers[n];
+			}
+			break;
+		case AS_GLOBAL :
+			if (n >= 0 && n < MAX_GLOBAL_SERVERS) {
+				return &cls.globalServers[n];
+			}
+			break;
+		case AS_FAVORITES :
+			if (n >= 0 && n < MAX_OTHER_SERVERS) {
+				return &cls.favoriteServers[n];
+			}
+			break;
+	}
+	return NULL;
+}
+
+/*
+====================
+LAN_CompareServers
+====================
+*/
+static int LAN_CompareServers( int source, int sortKey, int sortDir, int s1, int s2 ) {
+	int res;
+	serverInfo_t *server1, *server2;
+
+	server1 = LAN_GetServerPtr(source, s1);
+	server2 = LAN_GetServerPtr(source, s2);
+	if (!server1 || !server2) {
+		return 0;
+	}
+
+	res = 0;
+	switch( sortKey ) {
+		case SORT_HOST:
+			res = Q_stricmp( server1->hostName, server2->hostName );
+			break;
+
+		case SORT_MAP:
+			res = Q_stricmp( server1->mapName, server2->mapName );
+			break;
+		case SORT_CLIENTS:
+			if (server1->clients < server2->clients) {
+				res = -1;
+			}
+			else if (server1->clients > server2->clients) {
+				res = 1;
+			}
+			else {
+				res = 0;
+			}
+			break;
+		case SORT_GAME:
+			if (server1->gameType < server2->gameType) {
+				res = -1;
+			}
+			else if (server1->gameType > server2->gameType) {
+				res = 1;
+			}
+			else {
+				res = 0;
+			}
+			break;
+		case SORT_PING:
+			if (server1->ping < server2->ping) {
+				res = -1;
+			}
+			else if (server1->ping > server2->ping) {
+				res = 1;
+			}
+			else {
+				res = 0;
+			}
+			break;
+	}
+
+	if (sortDir) {
+		if (res < 0)
+			return 1;
+		if (res > 0)
+			return -1;
+		return 0;
+	}
+	return res;
+}
+
+/*
+====================
+LAN_GetPingQueueCount
+====================
+*/
+static int LAN_GetPingQueueCount( void ) {
+	return (CL_GetPingQueueCount());
+}
+
+/*
+====================
+LAN_ClearPing
+====================
+*/
+static void LAN_ClearPing( int n ) {
+	CL_ClearPing( n );
+}
+
+/*
+====================
+LAN_GetPing
+====================
+*/
+static void LAN_GetPing( int n, char *buf, int buflen, int *pingtime ) {
+	CL_GetPing( n, buf, buflen, pingtime );
+}
+
+/*
+====================
+LAN_GetPingInfo
+====================
+*/
+static void LAN_GetPingInfo( int n, char *buf, int buflen ) {
+	CL_GetPingInfo( n, buf, buflen );
+}
+
+/*
+====================
+LAN_MarkServerVisible
+====================
+*/
+static void LAN_MarkServerVisible(int source, int n, qboolean visible ) {
+	if (n == -1) {
+		int count = MAX_OTHER_SERVERS;
+		serverInfo_t *server = NULL;
+		switch (source) {
+			case AS_LOCAL :
+				server = &cls.localServers[0];
+				break;
+			case AS_MPLAYER :
+				server = &cls.mplayerServers[0];
+				break;
+			case AS_GLOBAL :
+				server = &cls.globalServers[0];
+				count = MAX_GLOBAL_SERVERS;
+				break;
+			case AS_FAVORITES :
+				server = &cls.favoriteServers[0];
+				break;
+		}
+		if (server) {
+			for (n = 0; n < count; n++) {
+				server[n].visible = visible;
+			}
+		}
+
+	} else {
+		switch (source) {
+			case AS_LOCAL :
+				if (n >= 0 && n < MAX_OTHER_SERVERS) {
+					cls.localServers[n].visible = visible;
+				}
+				break;
+			case AS_MPLAYER :
+				if (n >= 0 && n < MAX_OTHER_SERVERS) {
+					cls.mplayerServers[n].visible = visible;
+				}
+				break;
+			case AS_GLOBAL :
+				if (n >= 0 && n < MAX_GLOBAL_SERVERS) {
+					cls.globalServers[n].visible = visible;
+				}
+				break;
+			case AS_FAVORITES :
+				if (n >= 0 && n < MAX_OTHER_SERVERS) {
+					cls.favoriteServers[n].visible = visible;
+				}
+				break;
+		}
+	}
+}
+
+
+/*
+=======================
+LAN_ServerIsVisible
+=======================
+*/
+static int LAN_ServerIsVisible(int source, int n ) {
+	switch (source) {
+		case AS_LOCAL :
+			if (n >= 0 && n < MAX_OTHER_SERVERS) {
+				return cls.localServers[n].visible;
+			}
+			break;
+		case AS_MPLAYER :
+			if (n >= 0 && n < MAX_OTHER_SERVERS) {
+				return cls.mplayerServers[n].visible;
+			}
+			break;
+		case AS_GLOBAL :
+			if (n >= 0 && n < MAX_GLOBAL_SERVERS) {
+				return cls.globalServers[n].visible;
+			}
+			break;
+		case AS_FAVORITES :
+			if (n >= 0 && n < MAX_OTHER_SERVERS) {
+				return cls.favoriteServers[n].visible;
+			}
+			break;
+	}
+	return qfalse;
+}
+
+/*
+=======================
+LAN_UpdateVisiblePings
+=======================
+*/
+qboolean LAN_UpdateVisiblePings(int source ) {
+	return CL_UpdateVisiblePings_f(source);
+}
+
+/*
+====================
+LAN_GetServerStatus
+====================
+*/
+int LAN_GetServerStatus( char *serverAddress, char *serverStatus, int maxLen ) {
+	return CL_ServerStatus( serverAddress, serverStatus, maxLen );
+}
+
+/*
+====================
+CL_GetGlConfig
+====================
+*/
+static void CL_GetGlconfig( glconfig_t *config ) {
+	*config = cls.glconfig;
+}
+
+/*
+====================
+GetClipboardData
+====================
+*/
+static void GetClipboardData( char *buf, int buflen ) {
+	char	*cbd;
+
+	cbd = Sys_GetClipboardData();
+
+	if ( !cbd ) {
+		*buf = 0;
+		return;
+	}
+
+	Q_strncpyz( buf, cbd, buflen );
+
+	Z_Free( cbd );
+}
+
+/*
+====================
+Key_KeynumToStringBuf
+====================
+*/
+// only ever called by binding-display code, therefore returns non-technical "friendly" names 
+//	in any language that don't necessarily match those in the config file...
+//
+void Key_KeynumToStringBuf( int keynum, char *buf, int buflen ) 
+{
+	const char *psKeyName = Key_KeynumToString( keynum/*, qtrue */);
+
+	// see if there's a more friendly (or localised) name...
+	//
+	const char *psKeyNameFriendly = SE_GetString( va("KEYNAMES_KEYNAME_%s",psKeyName) );
+
+	Q_strncpyz( buf, (psKeyNameFriendly && psKeyNameFriendly[0]) ? psKeyNameFriendly : psKeyName, buflen );
+}
+
+
+/*
+====================
+Key_GetBindingBuf
+====================
+*/
+static void Key_GetBindingBuf( int keynum, char *buf, int buflen ) {
+	char	*value;
+
+	value = Key_GetBinding( keynum );
+	if ( value ) {
+		Q_strncpyz( buf, value, buflen );
+	}
+	else {
+		*buf = 0;
+	}
+}
+
+/*
+====================
+Key_GetCatcher
+====================
+*/
+int Key_GetCatcher( void ) {
+	return cls.keyCatchers;
+}
+
+/*
+====================
+Ket_SetCatcher
+====================
+*/
+void Key_SetCatcher( int catcher ) {
+	cls.keyCatchers = catcher;
+}
+
+
+#ifdef USE_CD_KEY
+
+/*
+====================
+CLUI_GetCDKey
+====================
+*/
+static void CLUI_GetCDKey( char *buf, int buflen ) {
+	cvar_t	*fs;
+	fs = Cvar_Get ("fs_game", "", CVAR_INIT|CVAR_SYSTEMINFO );
+	if (UI_usesUniqueCDKey() && fs && fs->string[0] != 0) {
+		Com_Memcpy( buf, &cl_cdkey[16], 16);
+		buf[16] = 0;
+	} else {
+		Com_Memcpy( buf, cl_cdkey, 16);
+		buf[16] = 0;
+	}
+}
+
+
+/*
+====================
+CLUI_SetCDKey
+====================
+*/
+static void CLUI_SetCDKey( char *buf ) {
+	cvar_t	*fs;
+	fs = Cvar_Get ("fs_game", "", CVAR_INIT|CVAR_SYSTEMINFO );
+	if (UI_usesUniqueCDKey() && fs && fs->string[0] != 0) {
+		Com_Memcpy( &cl_cdkey[16], buf, 16 );
+		cl_cdkey[32] = 0;
+		// set the flag so the fle will be written at the next opportunity
+		cvar_modifiedFlags |= CVAR_ARCHIVE;
+	} else {
+		Com_Memcpy( cl_cdkey, buf, 16 );
+		// set the flag so the fle will be written at the next opportunity
+		cvar_modifiedFlags |= CVAR_ARCHIVE;
+	}
+}
+
+#endif // USE_CD_KEY
+
+/*
+====================
+GetConfigString
+====================
+*/
+static int GetConfigString(int index, char *buf, int size)
+{
+	int		offset;
+
+	if (index < 0 || index >= MAX_CONFIGSTRINGS)
+		return qfalse;
+
+	offset = cl.gameState.stringOffsets[index];
+	if (!offset) {
+		if( size ) {
+			buf[0] = 0;
+		}
+		return qfalse;
+	}
+
+	Q_strncpyz( buf, cl.gameState.stringData+offset, size);
+ 
+	return qtrue;
+}
+
+/*
+====================
+FloatAsInt
+====================
+*/
+static int FloatAsInt( float f ) {
+	int		temp;
+
+	*(float *)&temp = f;
+
+	return temp;
+}
+
+void *VM_ArgPtr( int intValue );
+#define	VMA(x) VM_ArgPtr(args[x])
+#define	VMF(x)	((float *)args)[x]
+
+/*
+====================
+CL_UISystemCalls
+
+The ui module is making a system call
+====================
+*/
+int CL_UISystemCalls( int *args ) {
+	switch( args[0] ) {
+	//rww - alright, DO NOT EVER add a GAME/CGAME/UI generic call without adding a trap to match, and
+	//all of these traps must be shared and have cases in sv_game, cl_cgame, and cl_ui. They must also
+	//all be in the same order, and start at 100.
+	case TRAP_MEMSET:
+		Com_Memset( VMA(1), args[2], args[3] );
+		return 0;
+	case TRAP_MEMCPY:
+		Com_Memcpy( VMA(1), VMA(2), args[3] );
+		return 0;
+	case TRAP_STRNCPY:
+		return (int)strncpy( (char *)VMA(1), (const char *)VMA(2), args[3] );
+	case TRAP_SIN:
+		return FloatAsInt( sin( VMF(1) ) );
+	case TRAP_COS:
+		return FloatAsInt( cos( VMF(1) ) );
+	case TRAP_ATAN2:
+		return FloatAsInt( atan2( VMF(1), VMF(2) ) );
+	case TRAP_SQRT:
+		return FloatAsInt( sqrt( VMF(1) ) );
+	case TRAP_MATRIXMULTIPLY:
+		MatrixMultiply( (vec3_t *)VMA(1), (vec3_t *)VMA(2), (vec3_t *)VMA(3) );
+		return 0;
+	case TRAP_ANGLEVECTORS:
+		AngleVectors( (const float *)VMA(1), (float *)VMA(2), (float *)VMA(3), (float *)VMA(4) );
+		return 0;
+	case TRAP_PERPENDICULARVECTOR:
+		PerpendicularVector( (float *)VMA(1), (const float *)VMA(2) );
+		return 0;
+	case TRAP_FLOOR:
+		return FloatAsInt( floor( VMF(1) ) );
+	case TRAP_CEIL:
+		return FloatAsInt( ceil( VMF(1) ) );
+	case TRAP_TESTPRINTINT:
+		return 0;
+	case TRAP_TESTPRINTFLOAT:
+		return 0;
+	case TRAP_ACOS:
+		return FloatAsInt( Q_acos( VMF(1) ) );
+	case TRAP_ASIN:
+		return FloatAsInt( Q_asin( VMF(1) ) );
+
+
+	case UI_ERROR:
+		Com_Error( ERR_DROP, "%s", VMA(1) );
+		return 0;
+
+	case UI_PRINT:
+		Com_Printf( "%s", VMA(1) );
+		return 0;
+
+	case UI_MILLISECONDS:
+		return Sys_Milliseconds();
+
+	case UI_CVAR_REGISTER:
+		Cvar_Register( (vmCvar_t *)VMA(1), (const char *)VMA(2), (const char *)VMA(3), args[4] ); 
+		return 0;
+
+	case UI_CVAR_UPDATE:
+		Cvar_Update( (vmCvar_t *)VMA(1) );
+		return 0;
+
+	case UI_CVAR_SET:
+		Cvar_Set( (const char *)VMA(1), (const char *)VMA(2) );
+		return 0;
+
+	case UI_CVAR_VARIABLEVALUE:
+		return FloatAsInt( Cvar_VariableValue( (const char *)VMA(1) ) );
+
+	case UI_CVAR_VARIABLESTRINGBUFFER:
+		Cvar_VariableStringBuffer( (const char *)VMA(1), (char *)VMA(2), args[3] );
+		return 0;
+
+	case UI_CVAR_SETVALUE:
+		Cvar_SetValue( (const char *)VMA(1), VMF(2) );
+		return 0;
+
+	case UI_CVAR_RESET:
+		Cvar_Reset( (const char *)VMA(1) );
+		return 0;
+
+	case UI_CVAR_CREATE:
+		Cvar_Get( (const char *)VMA(1), (const char *)VMA(2), args[3] );
+		return 0;
+
+	case UI_CVAR_INFOSTRINGBUFFER:
+		Cvar_InfoStringBuffer( args[1], (char *)VMA(2), args[3] );
+		return 0;
+
+	case UI_ARGC:
+		return Cmd_Argc();
+
+	case UI_ARGV:
+		Cmd_ArgvBuffer( args[1], (char *)VMA(2), args[3] );
+		return 0;
+
+	case UI_CMD_EXECUTETEXT:
+		Cbuf_ExecuteText( args[1], (const char *)VMA(2) );
+		return 0;
+
+	case UI_FS_FOPENFILE:
+		return FS_FOpenFileByMode( (const char *)VMA(1), (int *)VMA(2), (fsMode_t)args[3] );
+
+	case UI_FS_READ:
+		FS_Read2( VMA(1), args[2], args[3] );
+		return 0;
+
+	case UI_FS_WRITE:
+		FS_Write( VMA(1), args[2], args[3] );
+		return 0;
+
+	case UI_FS_FCLOSEFILE:
+		FS_FCloseFile( args[1] );
+		return 0;
+
+	case UI_FS_GETFILELIST:
+		return FS_GetFileList( (const char *)VMA(1), (const char *)VMA(2), (char *)VMA(3), args[4] );
+
+	case UI_R_REGISTERMODEL:
+		return re.RegisterModel( (const char *)VMA(1) );
+
+	case UI_R_REGISTERSKIN:
+		return re.RegisterSkin( (const char *)VMA(1) );
+
+	case UI_R_REGISTERSHADERNOMIP:
+		return re.RegisterShaderNoMip( (const char *)VMA(1) );
+
+	case UI_R_SHADERNAMEFROMINDEX:
+		{
+			char *gameMem = (char *)VMA(1);
+			const char *retMem = re.ShaderNameFromIndex(args[2]);
+			if (retMem)
+			{
+				strcpy(gameMem, retMem);
+			}
+			else
+			{
+				gameMem[0] = 0;
+			}
+		}
+		return 0;
+
+	case UI_R_CLEARSCENE:
+		re.ClearScene();
+		return 0;
+
+	case UI_R_ADDREFENTITYTOSCENE:
+		re.AddRefEntityToScene( (const refEntity_t *)VMA(1) );
+		return 0;
+
+	case UI_R_ADDPOLYTOSCENE:
+		re.AddPolyToScene( args[1], args[2], (const polyVert_t *)VMA(3), 1 );
+		return 0;
+
+	case UI_R_ADDLIGHTTOSCENE:
+#ifdef VV_LIGHTING
+		VVLightMan.RE_AddLightToScene( (const float *)VMA(1), VMF(2), VMF(3), VMF(4), VMF(5) );
+#else
+		re.AddLightToScene( (const float *)VMA(1), VMF(2), VMF(3), VMF(4), VMF(5) );
+#endif
+		return 0;
+
+	case UI_R_RENDERSCENE:
+		re.RenderScene( (const refdef_t *)VMA(1) );
+		return 0;
+
+	case UI_R_SETCOLOR:
+		re.SetColor( (const float *)VMA(1) );
+		return 0;
+
+	case UI_R_DRAWSTRETCHPIC:
+		re.DrawStretchPic( VMF(1), VMF(2), VMF(3), VMF(4), VMF(5), VMF(6), VMF(7), VMF(8), args[9] );
+		return 0;
+
+  case UI_R_MODELBOUNDS:
+		re.ModelBounds( args[1], (float *)VMA(2), (float *)VMA(3) );
+		return 0;
+
+	case UI_UPDATESCREEN:
+		SCR_UpdateScreen();
+		return 0;
+
+	case UI_CM_LERPTAG:
+		re.LerpTag( (orientation_t *)VMA(1), args[2], args[3], args[4], VMF(5), (const char *)VMA(6) );
+		return 0;
+
+	case UI_S_REGISTERSOUND:
+		return S_RegisterSound( (const char *)VMA(1) );
+
+	case UI_S_STARTLOCALSOUND:
+		S_StartLocalSound( args[1], args[2] );
+		return 0;
+
+	case UI_KEY_KEYNUMTOSTRINGBUF:
+		Key_KeynumToStringBuf( args[1], (char *)VMA(2), args[3] );
+		return 0;
+
+	case UI_KEY_GETBINDINGBUF:
+		Key_GetBindingBuf( args[1], (char *)VMA(2), args[3] );
+		return 0;
+
+	case UI_KEY_SETBINDING:
+		Key_SetBinding( args[1], (const char *)VMA(2) );
+		return 0;
+
+	case UI_KEY_ISDOWN:
+		return Key_IsDown( args[1] );
+
+	case UI_KEY_GETOVERSTRIKEMODE:
+		return Key_GetOverstrikeMode();
+
+	case UI_KEY_SETOVERSTRIKEMODE:
+		Key_SetOverstrikeMode( (qboolean)args[1] );
+		return 0;
+
+	case UI_KEY_CLEARSTATES:
+		Key_ClearStates();
+		return 0;
+
+	case UI_KEY_GETCATCHER:
+		return Key_GetCatcher();
+
+	case UI_KEY_SETCATCHER:
+		Key_SetCatcher( args[1] );
+		return 0;
+
+	case UI_GETCLIPBOARDDATA:
+		GetClipboardData( (char *)VMA(1), args[2] );
+		return 0;
+
+	case UI_GETCLIENTSTATE:
+		GetClientState( (uiClientState_t *)VMA(1) );
+		return 0;		
+
+	case UI_GETGLCONFIG:
+		CL_GetGlconfig( (glconfig_t *)VMA(1) );
+		return 0;
+
+	case UI_GETCONFIGSTRING:
+		return GetConfigString( args[1], (char *)VMA(2), args[3] );
+
+	case UI_LAN_LOADCACHEDSERVERS:
+		LAN_LoadCachedServers();
+		return 0;
+
+	case UI_LAN_SAVECACHEDSERVERS:
+		LAN_SaveServersToCache();
+		return 0;
+
+	case UI_LAN_ADDSERVER:
+		return LAN_AddServer(args[1], (const char *)VMA(2), (const char *)VMA(3));
+
+	case UI_LAN_REMOVESERVER:
+		LAN_RemoveServer(args[1], (const char *)VMA(2));
+		return 0;
+
+	case UI_LAN_GETPINGQUEUECOUNT:
+		return LAN_GetPingQueueCount();
+
+	case UI_LAN_CLEARPING:
+		LAN_ClearPing( args[1] );
+		return 0;
+
+	case UI_LAN_GETPING:
+		LAN_GetPing( args[1], (char *)VMA(2), args[3], (int *)VMA(4) );
+		return 0;
+
+	case UI_LAN_GETPINGINFO:
+		LAN_GetPingInfo( args[1], (char *)VMA(2), args[3] );
+		return 0;
+
+	case UI_LAN_GETSERVERCOUNT:
+		return LAN_GetServerCount(args[1]);
+
+	case UI_LAN_GETSERVERADDRESSSTRING:
+		LAN_GetServerAddressString( args[1], args[2], (char *)VMA(3), args[4] );
+		return 0;
+
+	case UI_LAN_GETSERVERINFO:
+		LAN_GetServerInfo( args[1], args[2], (char *)VMA(3), args[4] );
+		return 0;
+
+	case UI_LAN_GETSERVERPING:
+		return LAN_GetServerPing( args[1], args[2] );
+
+	case UI_LAN_MARKSERVERVISIBLE:
+		LAN_MarkServerVisible( args[1], args[2], (qboolean)args[3] );
+		return 0;
+
+	case UI_LAN_SERVERISVISIBLE:
+		return LAN_ServerIsVisible( args[1], args[2] );
+
+	case UI_LAN_UPDATEVISIBLEPINGS:
+		return LAN_UpdateVisiblePings( args[1] );
+
+	case UI_LAN_RESETPINGS:
+		LAN_ResetPings( args[1] );
+		return 0;
+
+	case UI_LAN_SERVERSTATUS:
+		return LAN_GetServerStatus( (char *)VMA(1), (char *)VMA(2), args[3] );
+
+	case UI_LAN_COMPARESERVERS:
+		return LAN_CompareServers( args[1], args[2], args[3], args[4], args[5] );
+
+	case UI_MEMORY_REMAINING:
+		return Hunk_MemoryRemaining();
+
+#ifdef USE_CD_KEY
+	case UI_GET_CDKEY:
+		CLUI_GetCDKey( (char *)VMA(1), args[2] );
+		return 0;
+
+	case UI_SET_CDKEY:
+		CLUI_SetCDKey( (char *)VMA(1) );
+		return 0;
+#endif	// USE_CD_KEY
+
+	case UI_R_REGISTERFONT:
+		return re.RegisterFont( (const char *)VMA(1) );
+
+	case UI_R_FONT_STRLENPIXELS:
+		return re.Font_StrLenPixels( (const char *)VMA(1), args[2], VMF(3) );
+
+	case UI_R_FONT_STRLENCHARS:
+		return re.Font_StrLenChars( (const char *)VMA(1) );
+
+	case UI_R_FONT_STRHEIGHTPIXELS:
+		return re.Font_HeightPixels( args[1], VMF(2) );
+
+	case UI_R_FONT_DRAWSTRING:
+		re.Font_DrawString( args[1], args[2], (const char *)VMA(3), (const float *) VMA(4), args[5], args[6], VMF(7) );
+		return 0;
+
+	case UI_LANGUAGE_ISASIAN:
+		return re.Language_IsAsian();
+
+	case UI_LANGUAGE_USESSPACES:
+		return re.Language_UsesSpaces();
+
+	case UI_ANYLANGUAGE_READCHARFROMSTRING:
+		return re.AnyLanguage_ReadCharFromString( (const char *)VMA(1), (int *) VMA(2), (qboolean *) VMA(3) );
+
+	case UI_PC_ADD_GLOBAL_DEFINE:
+		return botlib_export->PC_AddGlobalDefine( (char *)VMA(1) );
+	case UI_PC_LOAD_SOURCE:
+		return botlib_export->PC_LoadSourceHandle( (const char *)VMA(1) );
+	case UI_PC_FREE_SOURCE:
+		return botlib_export->PC_FreeSourceHandle( args[1] );
+	case UI_PC_READ_TOKEN:
+		return botlib_export->PC_ReadTokenHandle( args[1], (struct pc_token_s *)VMA(2) );
+	case UI_PC_SOURCE_FILE_AND_LINE:
+		return botlib_export->PC_SourceFileAndLine( args[1], (char *)VMA(2), (int *)VMA(3) );
+	case UI_PC_LOAD_GLOBAL_DEFINES:
+		return botlib_export->PC_LoadGlobalDefines ( (char *)VMA(1) );
+	case UI_PC_REMOVE_ALL_GLOBAL_DEFINES:
+		botlib_export->PC_RemoveAllGlobalDefines ( );
+		return 0;
+
+	case UI_S_STOPBACKGROUNDTRACK:
+		S_StopBackgroundTrack();
+		return 0;
+	case UI_S_STARTBACKGROUNDTRACK:
+		S_StartBackgroundTrack( (const char *)VMA(1), (const char *)VMA(2), qfalse);
+		return 0;
+
+	case UI_REAL_TIME:
+		return Com_RealTime( (struct qtime_s *)VMA(1) );
+
+	case UI_CIN_PLAYCINEMATIC:
+	  Com_DPrintf("UI_CIN_PlayCinematic\n");
+	  return CIN_PlayCinematic((const char *)VMA(1), args[2], args[3], args[4], args[5], args[6]);
+
+	case UI_CIN_STOPCINEMATIC:
+	  return CIN_StopCinematic(args[1]);
+
+	case UI_CIN_RUNCINEMATIC:
+	  return CIN_RunCinematic(args[1]);
+
+	case UI_CIN_DRAWCINEMATIC:
+	  CIN_DrawCinematic(args[1]);
+	  return 0;
+
+	case UI_CIN_SETEXTENTS:
+	  CIN_SetExtents(args[1], args[2], args[3], args[4], args[5]);
+	  return 0;
+
+	case UI_R_REMAP_SHADER:
+		re.RemapShader( (const char *)VMA(1), (const char *)VMA(2), (const char *)VMA(3) );
+		return 0;
+
+#ifdef USE_CD_KEY
+	case UI_VERIFY_CDKEY:
+		return CL_CDKeyValidate((const char *)VMA(1), (const char *)VMA(2));
+#endif // USE_CD_KEY
+
+	case UI_SP_GETNUMLANGUAGES:
+		return SE_GetNumLanguages();
+
+	case UI_SP_GETLANGUAGENAME:
+		char *languageName,*holdName;
+
+		holdName = ((char *)VMA(2));
+		languageName = (char *) SE_GetLanguageName((const int)VMA(1));
+		Q_strncpyz( holdName, languageName,128 );
+		return 0;
+
+	case UI_SP_GETSTRINGTEXTSTRING:
+		const char* text;
+
+		assert(VMA(1));
+		assert(VMA(2));
+		text = SE_GetString((const char *) VMA(1));
+		Q_strncpyz( (char *) VMA(2), text, args[3] );
+		return qtrue;
+
+/*
+Ghoul2 Insert Start
+*/
+/*
+Ghoul2 Insert Start
+*/
+		
+	case UI_G2_LISTSURFACES:
+		G2API_ListSurfaces( (CGhoul2Info *) args[1] );
+		return 0;
+
+	case UI_G2_LISTBONES:
+		G2API_ListBones( (CGhoul2Info *) args[1], args[2]);
+		return 0;
+
+	case UI_G2_HAVEWEGHOULMODELS:
+		return G2API_HaveWeGhoul2Models( *((CGhoul2Info_v *)args[1]) );
+
+	case UI_G2_SETMODELS:
+		G2API_SetGhoul2ModelIndexes( *((CGhoul2Info_v *)args[1]),(qhandle_t *)VMA(2),(qhandle_t *)VMA(3));
+		return 0;
+
+	case UI_G2_GETBOLT:
+		return G2API_GetBoltMatrix(*((CGhoul2Info_v *)args[1]), args[2], args[3], (mdxaBone_t *)VMA(4), (const float *)VMA(5),(const float *)VMA(6), args[7], (qhandle_t *)VMA(8), (float *)VMA(9));
+
+	case UI_G2_GETBOLT_NOREC:
+		gG2_GBMNoReconstruct = qtrue;
+		return G2API_GetBoltMatrix(*((CGhoul2Info_v *)args[1]), args[2], args[3], (mdxaBone_t *)VMA(4), (const float *)VMA(5),(const float *)VMA(6), args[7], (qhandle_t *)VMA(8), (float *)VMA(9));
+
+	case UI_G2_GETBOLT_NOREC_NOROT:
+		gG2_GBMNoReconstruct = qtrue;
+		gG2_GBMUseSPMethod = qtrue;
+		return G2API_GetBoltMatrix(*((CGhoul2Info_v *)args[1]), args[2], args[3], (mdxaBone_t *)VMA(4), (const float *)VMA(5),(const float *)VMA(6), args[7], (qhandle_t *)VMA(8), (float *)VMA(9));
+
+	case UI_G2_INITGHOUL2MODEL:
+#ifdef _FULL_G2_LEAK_CHECKING
+		g_G2AllocServer = 0;
+#endif
+		return	G2API_InitGhoul2Model((CGhoul2Info_v **)VMA(1), (const char *)VMA(2), args[3], (qhandle_t) args[4],
+									  (qhandle_t) args[5], args[6], args[7]);
+
+
+	case UI_G2_COLLISIONDETECT:
+		return 0; //not supported for ui
+
+	case UI_G2_ANGLEOVERRIDE:
+		return G2API_SetBoneAngles(*((CGhoul2Info_v *)args[1]), args[2], (const char *)VMA(3), (float *)VMA(4), args[5],
+							 (const Eorientations) args[6], (const Eorientations) args[7], (const Eorientations) args[8],
+							 (qhandle_t *)VMA(9), args[10], args[11] );
+	
+	case UI_G2_CLEANMODELS:
+#ifdef _FULL_G2_LEAK_CHECKING
+		g_G2AllocServer = 0;
+#endif
+		G2API_CleanGhoul2Models((CGhoul2Info_v **)VMA(1));
+	//	G2API_CleanGhoul2Models((CGhoul2Info_v **)args[1]);
+		return 0;
+
+	case UI_G2_PLAYANIM:
+		return G2API_SetBoneAnim(*((CGhoul2Info_v *)args[1]), args[2], (const char *)VMA(3), args[4], args[5],
+								args[6], VMF(7), args[8], VMF(9), args[10]);
+
+	case UI_G2_GETBONEANIM:
+		{
+			CGhoul2Info_v &g2 = *((CGhoul2Info_v *)args[1]);
+			int modelIndex = args[10];
+
+			return G2API_GetBoneAnim(&g2[modelIndex], (const char*)VMA(2), args[3], (float *)VMA(4), (int *)VMA(5),
+								(int *)VMA(6), (int *)VMA(7), (float *)VMA(8), (int *)VMA(9));
+		}
+
+	case UI_G2_GETBONEFRAME:
+		{ //rwwFIXMEFIXME: Just make a G2API_GetBoneFrame func too. This is dirty.
+			CGhoul2Info_v &g2 = *((CGhoul2Info_v *)args[1]);
+			int modelIndex = args[6];
+			int iDontCare1 = 0, iDontCare2 = 0, iDontCare3 = 0;
+			float fDontCare1 = 0;
+
+			return G2API_GetBoneAnim(&g2[modelIndex], (const char*)VMA(2), args[3], (float *)VMA(4), &iDontCare1,
+								&iDontCare2, &iDontCare3, &fDontCare1, (int *)VMA(5));
+		}
+
+	case UI_G2_GETGLANAME:
+		//	return (int)G2API_GetGLAName(*((CGhoul2Info_v *)VMA(1)), args[2]);
+		{
+			char *point = ((char *)VMA(3));
+			char *local;
+			local = G2API_GetGLAName(*((CGhoul2Info_v *)args[1]), args[2]);
+			if (local)
+			{
+				strcpy(point, local);
+			}
+		}
+		return 0;
+
+	case UI_G2_COPYGHOUL2INSTANCE:
+		return (int)G2API_CopyGhoul2Instance(*((CGhoul2Info_v *)args[1]), *((CGhoul2Info_v *)args[2]), args[3]);
+
+	case UI_G2_COPYSPECIFICGHOUL2MODEL:
+		G2API_CopySpecificG2Model(*((CGhoul2Info_v *)args[1]), args[2], *((CGhoul2Info_v *)args[3]), args[4]);
+		return 0;
+
+	case UI_G2_DUPLICATEGHOUL2INSTANCE:
+#ifdef _FULL_G2_LEAK_CHECKING
+		g_G2AllocServer = 0;
+#endif
+		G2API_DuplicateGhoul2Instance(*((CGhoul2Info_v *)args[1]), (CGhoul2Info_v **)VMA(2));
+		return 0;
+
+	case UI_G2_HASGHOUL2MODELONINDEX:
+		return (int)G2API_HasGhoul2ModelOnIndex((CGhoul2Info_v **)VMA(1), args[2]);
+		//return (int)G2API_HasGhoul2ModelOnIndex((CGhoul2Info_v **)args[1], args[2]);
+
+	case UI_G2_REMOVEGHOUL2MODEL:
+#ifdef _FULL_G2_LEAK_CHECKING
+		g_G2AllocServer = 0;
+#endif
+		return (int)G2API_RemoveGhoul2Model((CGhoul2Info_v **)VMA(1), args[2]);
+		//return (int)G2API_RemoveGhoul2Model((CGhoul2Info_v **)args[1], args[2]);
+
+	case UI_G2_ADDBOLT:
+		return G2API_AddBolt(*((CGhoul2Info_v *)args[1]), args[2], (const char *)VMA(3));
+
+//	case UI_G2_REMOVEBOLT:
+//		return G2API_RemoveBolt(*((CGhoul2Info_v *)VMA(1)), args[2]);
+
+	case UI_G2_SETBOLTON:
+		G2API_SetBoltInfo(*((CGhoul2Info_v *)args[1]), args[2], args[3]);
+		return 0;
+
+#ifdef _SOF2	
+	case UI_G2_ADDSKINGORE:
+		G2API_AddSkinGore(*((CGhoul2Info_v *)args[1]),*(SSkinGoreData *)VMA(2));
+		return 0;
+#endif // _SOF2
+/*
+Ghoul2 Insert End
+*/
+	case UI_G2_SETROOTSURFACE:
+		return G2API_SetRootSurface(*((CGhoul2Info_v *)args[1]), args[2], (const char *)VMA(3));
+
+	case UI_G2_SETSURFACEONOFF:
+		return G2API_SetSurfaceOnOff(*((CGhoul2Info_v *)args[1]), (const char *)VMA(2), /*(const int)VMA(3)*/args[3]);
+
+	case UI_G2_SETNEWORIGIN:
+		return G2API_SetNewOrigin(*((CGhoul2Info_v *)args[1]), /*(const int)VMA(2)*/args[2]);
+
+	case UI_G2_GETTIME:
+		return G2API_GetTime(0);
+
+	case UI_G2_SETTIME:
+		G2API_SetTime(args[1], args[2]);
+		return 0;
+
+	case UI_G2_SETRAGDOLL:
+		return 0; //not supported for ui
+		break;
+	case UI_G2_ANIMATEG2MODELS:
+		return 0; //not supported for ui
+		break;
+
+	case UI_G2_SETBONEIKSTATE:
+		return G2API_SetBoneIKState(*((CGhoul2Info_v *)args[1]), args[2], (const char *)VMA(3), args[4], (sharedSetBoneIKStateParams_t *)VMA(5));
+	case UI_G2_IKMOVE:
+		return G2API_IKMove(*((CGhoul2Info_v *)args[1]), args[2], (sharedIKMoveParams_t *)VMA(3));
+
+	case UI_G2_GETSURFACENAME:
+		{ //Since returning a pointer in such a way to a VM seems to cause MASSIVE FAILURE<tm>, we will shove data into the pointer the vm passes instead
+			char *point = ((char *)VMA(4));
+			char *local;
+			int modelindex = args[3];
+
+			CGhoul2Info_v &g2 = *((CGhoul2Info_v *)args[1]);
+
+			local = G2API_GetSurfaceName(&g2[modelindex], args[2]);
+			if (local)
+			{
+				strcpy(point, local);
+			}
+		}
+
+		return 0;
+	case UI_G2_SETSKIN:
+		{
+			CGhoul2Info_v &g2 = *((CGhoul2Info_v *)args[1]);
+			int modelIndex = args[2];
+			
+			return G2API_SetSkin(&g2[modelIndex], args[3], args[4]);
+		}
+
+	case UI_G2_ATTACHG2MODEL:
+		{
+			CGhoul2Info_v *g2From = ((CGhoul2Info_v *)args[1]);
+			CGhoul2Info_v *g2To = ((CGhoul2Info_v *)args[3]);
+			
+			return G2API_AttachG2Model(g2From[0], args[2], g2To[0], args[4], args[5]);
+		}
+/*
+Ghoul2 Insert End
+*/
+	default:
+		Com_Error( ERR_DROP, "Bad UI system trap: %i", args[0] );
+
+	}
+
+	return 0;
+}
+
+/*
+====================
+CL_ShutdownUI
+====================
+*/
+void CL_ShutdownUI( void ) {
+	cls.keyCatchers &= ~KEYCATCH_UI;
+	cls.uiStarted = qfalse;
+	if ( !uivm ) {
+		return;
+	}
+	VM_Call( uivm, UI_SHUTDOWN );
+	VM_Call( uivm, UI_MENU_RESET );
+	VM_Free( uivm );
+	uivm = NULL;
+}
+
+/*
+====================
+CL_InitUI
+====================
+*/
+
+void CL_InitUI( void ) {
+	int		v;
+	vmInterpret_t		interpret;
+
+	// load the dll or bytecode
+	if ( cl_connectedToPureServer != 0 ) {
+#if 0
+		// if sv_pure is set we only allow qvms to be loaded
+		interpret = VMI_COMPILED;
+#else //load the module type based on what the server is doing -rww
+		interpret = (vmInterpret_t)cl_connectedUI;
+#endif
+	}
+	else {
+		interpret = (vmInterpret_t)(int)Cvar_VariableValue( "vm_ui" );
+	}
+	uivm = VM_Create( "ui", CL_UISystemCalls, interpret );
+	if ( !uivm ) {
+		Com_Error( ERR_FATAL, "VM_Create on UI failed" );
+	}
+
+	// sanity check
+	v = VM_Call( uivm, UI_GETAPIVERSION );
+	if (v != UI_API_VERSION) {
+		Com_Error( ERR_DROP, "User Interface is version %d, expected %d", v, UI_API_VERSION );
+		cls.uiStarted = qfalse;
+	}
+	else {
+		// init for this gamestate
+		//rww - changed to <= CA_ACTIVE, because that is the state when we did a vid_restart
+		//ingame (was just < CA_ACTIVE before, resulting in ingame menus getting wiped and
+		//not reloaded on vid restart from ingame menu)
+		VM_Call( uivm, UI_INIT, (cls.state >= CA_AUTHORIZING && cls.state <= CA_ACTIVE) );
+	}
+}
+
+qboolean UI_usesUniqueCDKey() {
+	if (uivm) {
+		return (qboolean)(VM_Call( uivm, UI_HASUNIQUECDKEY) == qtrue);
+	} else {
+		return qfalse;
+	}
+}
+
+/*
+====================
+UI_GameCommand
+
+See if the current console command is claimed by the ui
+====================
+*/
+qboolean UI_GameCommand( void ) {
+	if ( !uivm ) {
+		return qfalse;
+	}
+
+	return (qboolean)VM_Call( uivm, UI_CONSOLE_COMMAND, cls.realtime );
+}
diff --git a/codemp/client/client.h b/codemp/client/client.h
new file mode 100644
index 0000000..1da516b
--- /dev/null
+++ b/codemp/client/client.h
@@ -0,0 +1,622 @@
+// client.h -- primary header for client
+#pragma once
+#if !defined(CLIENT_H_INC)
+#define CLIENT_H_INC
+
+#include "../game/q_shared.h"
+#include "../qcommon/qcommon.h"
+#include "../renderer/tr_public.h"
+#include "../ui/ui_public.h"
+#include "keys.h"
+#include "snd_public.h"
+#include "../cgame/cg_public.h"
+#include "../game/bg_public.h"
+
+#ifdef _XBOX
+#include <xtl.h>
+#endif
+
+#define	RETRANSMIT_TIMEOUT	3000	// time between connection packet retransmits
+
+// Wind
+extern vec3_t cl_windVec;
+
+// snapshots are a view of the server at a given time
+typedef struct {
+	qboolean		valid;			// cleared if delta parsing was invalid
+	int				snapFlags;		// rate delayed and dropped commands
+
+	int				serverTime;		// server time the message is valid for (in msec)
+
+	int				messageNum;		// copied from netchan->incoming_sequence
+	int				deltaNum;		// messageNum the delta is from
+	int				ping;			// time from when cmdNum-1 was sent to time packet was reeceived
+	byte			areamask[MAX_MAP_AREA_BYTES];		// portalarea visibility bits
+
+	int				cmdNum;			// the next cmdNum the server is expecting
+	playerState_t	ps;						// complete information about the current player at this time
+	playerState_t	vps; //vehicle I'm riding's playerstate (if applicable) -rww
+
+	int				numEntities;			// all of the entities that need to be presented
+	int				parseEntitiesNum;		// at the time of this snapshot
+
+	int				serverCommandNum;		// execute all commands up to this before
+											// making the snapshot current
+} clSnapshot_t;
+
+
+
+/*
+=============================================================================
+
+the clientActive_t structure is wiped completely at every
+new gamestate_t, potentially several times during an established connection
+
+=============================================================================
+*/
+
+typedef struct {
+	int		p_cmdNumber;		// cl.cmdNumber when packet was sent
+	int		p_serverTime;		// usercmd->serverTime when packet was sent
+	int		p_realtime;			// cls.realtime when packet was sent
+} outPacket_t;
+
+// the parseEntities array must be large enough to hold PACKET_BACKUP frames of
+// entities, so that when a delta compressed message arives from the server
+// it can be un-deltad from the original 
+#ifdef _XBOX
+#define	MAX_PARSE_ENTITIES	1024
+#else
+#define	MAX_PARSE_ENTITIES	2048
+#endif
+
+extern int g_console_field_width;
+
+typedef struct {
+	int			timeoutcount;		// it requres several frames in a timeout condition
+									// to disconnect, preventing debugging breaks from
+									// causing immediate disconnects on continue
+	clSnapshot_t	snap;			// latest received from server
+
+	int			serverTime;			// may be paused during play
+	int			oldServerTime;		// to prevent time from flowing bakcwards
+	int			oldFrameServerTime;	// to check tournament restarts
+	int			serverTimeDelta;	// cl.serverTime = cls.realtime + cl.serverTimeDelta
+									// this value changes as net lag varies
+	qboolean	extrapolatedSnapshot;	// set if any cgame frame has been forced to extrapolate
+									// cleared when CL_AdjustTimeDelta looks at it
+	qboolean	newSnapshots;		// set on parse of any valid packet
+
+	gameState_t	gameState;			// configstrings
+	char		mapname[MAX_QPATH];	// extracted from CS_SERVERINFO
+
+	int			parseEntitiesNum;	// index (not anded off) into cl_parse_entities[]
+
+	int			mouseDx[2], mouseDy[2];	// added to by mouse events
+	int			mouseIndex;
+	int			joystickAxis[MAX_JOYSTICK_AXIS];	// set by joystick events
+
+	// cgame communicates a few values to the client system
+	int			cgameUserCmdValue;	// current weapon to add to usercmd_t
+	vec3_t		cgameViewAngleForce;
+	int			cgameViewAngleForceTime;
+	float		cgameSensitivity;
+
+	int			cgameForceSelection;
+	int			cgameInvenSelection;
+
+	qboolean	gcmdSendValue;
+	qboolean	gcmdSentValue;
+	byte		gcmdValue;
+
+	// cmds[cmdNumber] is the predicted command, [cmdNumber-1] is the last
+	// properly generated command
+	usercmd_t	cmds[CMD_BACKUP];	// each mesage will send several old cmds
+	int			cmdNumber;			// incremented each frame, because multiple
+									// frames may need to be packed into a single packet
+
+	outPacket_t	outPackets[PACKET_BACKUP];	// information about each packet we have sent out
+
+	// the client maintains its own idea of view angles, which are
+	// sent to the server each frame.  It is cleared to 0 upon entering each level.
+	// the server sends a delta each frame which is added to the locally
+	// tracked view angles to account for standing on rotating objects,
+	// and teleport direction changes
+	vec3_t		viewangles;
+
+	int			serverId;			// included in each client message so the server
+												// can tell if it is for a prior map_restart
+	// big stuff at end of structure so most offsets are 15 bits or less
+	clSnapshot_t	snapshots[PACKET_BACKUP];
+
+	entityState_t	entityBaselines[MAX_GENTITIES];	// for delta compression when not in previous frame
+
+	entityState_t	parseEntities[MAX_PARSE_ENTITIES];
+
+	char			*mSharedMemory;
+} clientActive_t;
+
+extern	clientActive_t		cl;
+
+#define MAX_HEIGHTMAP_SIZE	16000
+
+typedef struct 
+{
+	int			mType;
+	int			mSide;
+	vec3_t		mOrigin;
+
+} rmAutomapSymbol_t;
+
+#define	MAX_AUTOMAP_SYMBOLS	512
+
+/*
+=============================================================================
+
+the clientConnection_t structure is wiped when disconnecting from a server,
+either to go to a full screen console, play a demo, or connect to a different server
+
+A connection can be to either a server through the network layer or a
+demo through a file.
+
+=============================================================================
+*/
+
+
+typedef struct {
+
+	int			clientNum;
+	int			lastPacketSentTime;			// for retransmits during connection
+	int			lastPacketTime;				// for timeouts
+
+	netadr_t	serverAddress;
+	int			connectTime;				// for connection retransmits
+	int			connectPacketCount;			// for display on connection dialog
+	char		serverMessage[MAX_STRING_TOKENS];	// for display on connection dialog
+
+	int			challenge;					// from the server to use for connecting
+	int			checksumFeed;				// from the server for checksum calculations
+
+	// these are our reliable messages that go to the server
+	int			reliableSequence;
+	int			reliableAcknowledge;		// the last one the server has executed
+	char		reliableCommands[MAX_RELIABLE_COMMANDS][MAX_STRING_CHARS];
+
+	// server message (unreliable) and command (reliable) sequence
+	// numbers are NOT cleared at level changes, but continue to
+	// increase as long as the connection is valid
+
+	// message sequence is used by both the network layer and the
+	// delta compression layer
+	int			serverMessageSequence;
+
+	// reliable messages received from server
+	int			serverCommandSequence;
+	int			lastExecutedServerCommand;		// last server command grabbed or executed with CL_GetServerCommand
+	char		serverCommands[MAX_RELIABLE_COMMANDS][MAX_STRING_CHARS];
+
+#ifndef _XBOX	// No downloading or demos on Xbox
+	// file transfer from server
+	fileHandle_t download;
+	char		downloadTempName[MAX_OSPATH];
+	char		downloadName[MAX_OSPATH];
+	int			downloadNumber;
+	int			downloadBlock;	// block we are waiting for
+	int			downloadCount;	// how many bytes we got
+	int			downloadSize;	// how many bytes we got
+	char		downloadList[MAX_INFO_STRING]; // list of paks we need to download
+	qboolean	downloadRestart;	// if true, we need to do another FS_Restart because we downloaded a pak
+
+	// demo information
+	char		demoName[MAX_QPATH];
+	qboolean	spDemoRecording;
+	qboolean	demorecording;
+	qboolean	demoplaying;
+	qboolean	demowaiting;	// don't record until a non-delta message is received
+	qboolean	firstDemoFrameSkipped;
+	fileHandle_t	demofile;
+
+	int			timeDemoFrames;		// counter of rendered frames
+	int			timeDemoStart;		// cls.realtime before first frame
+	int			timeDemoBaseTime;	// each frame will be at this time + frameNum * 50
+#endif
+
+	// big stuff at end of structure so most offsets are 15 bits or less
+	netchan_t	netchan;
+
+	//rwwRMG - added:
+	int					rmgSeed;
+	int					rmgHeightMapSize;
+	unsigned char		rmgHeightMap[MAX_HEIGHTMAP_SIZE];
+	unsigned char		rmgFlattenMap[MAX_HEIGHTMAP_SIZE];
+	rmAutomapSymbol_t	rmgAutomapSymbols[MAX_AUTOMAP_SYMBOLS];
+	int					rmgAutomapSymbolCount;
+} clientConnection_t;
+
+extern	clientConnection_t clc;
+
+/*
+==================================================================
+
+the clientStatic_t structure is never wiped, and is used even when
+no client connection is active at all
+
+==================================================================
+*/
+
+typedef struct {
+	netadr_t	adr;
+	int			start;
+	int			time;
+	char		info[MAX_INFO_STRING];
+#ifdef _XBOX
+	XNADDR		xnaddr;
+#endif
+} ping_t;
+
+typedef struct {
+	netadr_t	adr;
+	char	  	hostName[MAX_NAME_LENGTH];
+	char	  	mapName[MAX_NAME_LENGTH];
+	char	  	game[MAX_NAME_LENGTH];
+#ifndef _XBOX
+	int			netType;
+#endif
+	int			gameType;
+	int		  	clients;
+	int		  	maxClients;
+#ifndef _XBOX
+	int			minPing;
+	int			maxPing;
+#endif
+	int			ping;
+	qboolean	visible;
+//	int			allowAnonymous;
+#ifndef _XBOX
+	qboolean	needPassword;
+	int			trueJedi;
+	int			weaponDisable;
+	int			forceDisable;
+#endif
+//	qboolean	pure;
+#ifdef _XBOX
+	qboolean	saberOnly;			// Not the same as weaponDisable!
+	XNKID		SessionID;				
+	XNKEY		KeyExchangeKey;
+	XNADDR		HostAddress;
+#endif
+} serverInfo_t;
+
+typedef struct {
+	byte	ip[4];
+	unsigned short	port;
+} serverAddress_t;
+
+typedef struct {
+	connstate_t	state;				// connection status
+	int			keyCatchers;		// bit flags
+
+	char		servername[MAX_OSPATH];		// name of server from original connect (used by reconnect)
+
+	// when the server clears the hunk, all of these must be restarted
+	qboolean	rendererStarted;
+	qboolean	soundStarted;
+	qboolean	soundRegistered;
+	qboolean	uiStarted;
+	qboolean	cgameStarted;
+
+	int			framecount;
+	int			frametime;			// msec since last frame
+
+	int			realtime;			// ignores pause
+	int			realFrametime;		// ignoring pause, so console always works
+
+	int			numlocalservers;
+	serverInfo_t	localServers[MAX_OTHER_SERVERS];
+
+	int			numglobalservers;
+	serverInfo_t  globalServers[MAX_GLOBAL_SERVERS];
+	// additional global servers
+	int			numGlobalServerAddresses;
+	serverAddress_t		globalServerAddresses[MAX_GLOBAL_SERVERS];
+
+	int			numfavoriteservers;
+	serverInfo_t	favoriteServers[MAX_OTHER_SERVERS];
+
+	int			nummplayerservers;
+	serverInfo_t	mplayerServers[MAX_OTHER_SERVERS];
+
+	int pingUpdateSource;		// source currently pinging or updating
+
+	int masterNum;
+
+	// update server info
+	netadr_t	updateServer;
+	char		updateChallenge[MAX_TOKEN_CHARS];
+	char		updateInfoString[MAX_INFO_STRING];
+
+	netadr_t	authorizeServer;
+
+	// rendering info
+	glconfig_t	glconfig;
+	qhandle_t	charSetShader;
+	qhandle_t	whiteShader;
+	qhandle_t	consoleShader;
+
+#ifdef _XBOX
+	short		mainGamepad;
+#endif
+} clientStatic_t;
+
+#ifdef _XBOX
+#define	CON_TEXTSIZE	256
+#else
+#define	CON_TEXTSIZE	32768
+#endif
+#define	NUM_CON_TIMES	4
+
+typedef struct {
+	qboolean	initialized;
+
+	short	text[CON_TEXTSIZE];
+	int		current;		// line where next message will be printed
+	int		x;				// offset in current line for next print
+	int		display;		// bottom of console displays this line
+
+	int 	linewidth;		// characters across screen
+	int		totallines;		// total lines in console scrollback
+
+	float	xadjust;		// for wide aspect screens
+	float	yadjust;		// for wide aspect screens
+
+	float	displayFrac;	// aproaches finalFrac at scr_conspeed
+	float	finalFrac;		// 0.0 to 1.0 lines of console to display
+
+	int		vislines;		// in scanlines
+
+	int		times[NUM_CON_TIMES];	// cls.realtime time the line was generated
+								// for transparent notify lines
+	vec4_t	color;
+} console_t;
+
+extern	clientStatic_t		cls;
+
+//=============================================================================
+
+extern	vm_t			*cgvm;	// interface to cgame dll or vm
+extern	vm_t			*uivm;	// interface to ui dll or vm
+extern	refexport_t		re;		// interface to refresh .dll
+
+
+//
+// cvars
+//
+extern	cvar_t	*cl_nodelta;
+extern	cvar_t	*cl_debugMove;
+extern	cvar_t	*cl_noprint;
+extern	cvar_t	*cl_timegraph;
+extern	cvar_t	*cl_maxpackets;
+extern	cvar_t	*cl_packetdup;
+extern	cvar_t	*cl_shownet;
+extern	cvar_t	*cl_showSend;
+extern	cvar_t	*cl_timeNudge;
+extern	cvar_t	*cl_showTimeDelta;
+extern	cvar_t	*cl_freezeDemo;
+
+extern	cvar_t	*cl_yawspeed;
+extern	cvar_t	*cl_pitchspeed;
+extern	cvar_t	*cl_run;
+extern	cvar_t	*cl_anglespeedkey;
+
+extern	cvar_t	*cl_sensitivity;
+extern	cvar_t	*cl_freelook;
+
+extern	cvar_t	*cl_mouseAccel;
+extern	cvar_t	*cl_showMouseRate;
+
+extern	cvar_t	*m_pitchVeh;
+extern	cvar_t	*m_pitch;
+extern	cvar_t	*m_yaw;
+extern	cvar_t	*m_forward;
+extern	cvar_t	*m_side;
+extern	cvar_t	*m_filter;
+
+extern	cvar_t	*cl_timedemo;
+
+extern	cvar_t	*cl_activeAction;
+
+#ifndef _XBOX
+extern	cvar_t	*cl_allowDownload;
+extern	cvar_t	*cl_allowAltEnter;
+#endif
+extern	cvar_t	*cl_conXOffset;
+extern	cvar_t	*cl_inGameVideo;
+
+//=================================================
+
+//
+// cl_main
+//
+
+void CL_Init (void);
+void CL_FlushMemory(void);
+void CL_ShutdownAll(void);
+void CL_AddReliableCommand( const char *cmd );
+
+void CL_StartHunkUsers( void );
+
+void CL_Disconnect_f (void);
+void CL_GetChallengePacket (void);
+void CL_Vid_Restart_f( void );
+void CL_Snd_Restart_f (void);
+void CL_StartDemoLoop( void );
+void CL_NextDemo( void );
+void CL_ReadDemoMessage( void );
+
+void CL_InitDownloads(void);
+void CL_NextDownload(void);
+
+void CL_GetPing( int n, char *buf, int buflen, int *pingtime );
+void CL_GetPingInfo( int n, char *buf, int buflen );
+void CL_ClearPing( int n );
+int CL_GetPingQueueCount( void );
+
+void CL_ShutdownRef( void );
+void CL_InitRef( void );
+
+#ifdef USE_CD_KEY
+
+qboolean CL_CDKeyValidate( const char *key, const char *checksum );
+
+#endif // USE_CD_KEY
+
+int CL_ServerStatus( char *serverAddress, char *serverStatusString, int maxLen );
+
+
+//
+// cl_input
+//
+typedef struct {
+	int			down[2];		// key nums holding it down
+	unsigned	downtime;		// msec timestamp
+	unsigned	msec;			// msec down this frame if both a down and up happened
+	qboolean	active;			// current state
+	qboolean	wasPressed;		// set when down, not cleared when up
+} kbutton_t;
+
+extern	kbutton_t	in_mlook, in_klook;
+extern 	kbutton_t 	in_strafe;
+extern 	kbutton_t 	in_speed;
+
+void CL_InitInput (void);
+void CL_SendCmd (void);
+void CL_ClearState (void);
+void CL_ReadPackets (void);
+
+void CL_WritePacket( void );
+void IN_CenterView (void);
+
+void CL_VerifyCode( void );
+
+float CL_KeyState (kbutton_t *key);
+const char *Key_KeynumToString( int keynum/*, qboolean bTranslate */ ); //note: translate is only called for menu display not configs
+
+//
+// cl_parse.c
+//
+extern int cl_connectedToPureServer;
+extern int cl_connectedGAME;
+extern int cl_connectedCGAME;
+extern int cl_connectedUI;
+
+void CL_SystemInfoChanged( void );
+void CL_ParseServerMessage( msg_t *msg );
+//void CL_SP_Print(const word ID, byte *Data);
+
+//====================================================================
+
+void	CL_ServerInfoPacket( netadr_t from, msg_t *msg );
+void	CL_LocalServers_f( void );
+#ifndef _XBOX
+void	CL_GlobalServers_f( void );
+void	CL_FavoriteServers_f( void );
+#endif
+void	CL_Ping_f( void );
+qboolean CL_UpdateVisiblePings_f( int source );
+
+
+//
+// console
+//
+void Con_DrawCharacter (int cx, int line, int num);
+
+void Con_CheckResize (void);
+void Con_Init (void);
+void Con_Clear_f (void);
+void Con_ToggleConsole_f (void);
+void Con_DrawNotify (void);
+void Con_ClearNotify (void);
+void Con_RunConsole (void);
+void Con_DrawConsole (void);
+void Con_PageUp( void );
+void Con_PageDown( void );
+void Con_Top( void );
+void Con_Bottom( void );
+void Con_Close( void );
+
+
+//
+// cl_scrn.c
+//
+void	SCR_Init (void);
+void	SCR_UpdateScreen (void);
+
+void	SCR_DebugGraph (float value, int color);
+
+int		SCR_GetBigStringWidth( const char *str );	// returns in virtual 640x480 coordinates
+
+void	SCR_FillRect( float x, float y, float width, float height, 
+					 const float *color );
+void	SCR_DrawPic( float x, float y, float width, float height, qhandle_t hShader );
+void	SCR_DrawNamedPic( float x, float y, float width, float height, const char *picname );
+
+void	SCR_DrawBigString( int x, int y, const char *s, float alpha );			// draws a string with embedded color control characters with fade
+void	SCR_DrawBigStringColor( int x, int y, const char *s, vec4_t color );	// ignores embedded color control characters
+void	SCR_DrawSmallStringExt( int x, int y, const char *string, float *setColor, qboolean forceColor );
+void	SCR_DrawSmallChar( int x, int y, int ch );
+
+
+//
+// cl_cin.c
+//
+
+void CL_PlayCinematic_f( void );
+void SCR_DrawCinematic (void);
+void SCR_RunCinematic (void);
+void SCR_StopCinematic (void);
+int CIN_PlayCinematic( const char *arg0, int xpos, int ypos, int width, int height, int bits);
+e_status CIN_StopCinematic(int handle);
+e_status CIN_RunCinematic (int handle);
+void CIN_DrawCinematic (int handle);
+void CIN_SetExtents (int handle, int x, int y, int w, int h);
+void CIN_SetLooping (int handle, qboolean loop);
+void CIN_UploadCinematic(int handle);
+void CIN_CloseAllVideos(void);
+
+void CL_UpdateHotSwap(void);
+
+#ifdef _XBOX
+void CIN_Init(void);
+bool CIN_PlayAllFrames( const char *arg, int x, int y, int w, int h, int systemBits, bool keyBreakAllowed );
+#endif
+
+
+//
+// cl_cgame.c
+//
+void CL_InitCGame( void );
+void CL_ShutdownCGame( void );
+qboolean CL_GameCommand( void );
+void CL_CGameRendering( stereoFrame_t stereo );
+void CL_SetCGameTime( void );
+void CL_FirstSnapshot( void );
+void CL_ShaderStateChanged(void);
+
+//
+// cl_ui.c
+//
+void CL_InitUI( void );
+void CL_ShutdownUI( void );
+int Key_GetCatcher( void );
+void Key_SetCatcher( int catcher );
+void LAN_LoadCachedServers();
+void LAN_SaveServersToCache();
+
+
+//
+// cl_net_chan.c
+//
+void CL_Netchan_Transmit( netchan_t *chan, msg_t* msg);	//int length, const byte *data );
+void CL_Netchan_TransmitNextFragment( netchan_t *chan );
+qboolean CL_Netchan_Process( netchan_t *chan, msg_t *msg );
+#endif
diff --git a/codemp/client/eax/EaxMan.h b/codemp/client/eax/EaxMan.h
new file mode 100644
index 0000000..c530911
--- /dev/null
+++ b/codemp/client/eax/EaxMan.h
@@ -0,0 +1,171 @@
+/*
+*/
+#ifndef __EAXMANH
+#define __EAXMANH
+
+#define COM_NO_WINDOWS_H
+#include <objbase.h>
+#include "eax.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+//#define CLSID_EAXMANAGER CLSID_EAX20_Manager
+//#define IID_IEaxManager IID_EAX20_Manager
+#define EM_MAX_NAME 32
+
+#define EMFLAG_IDDEFAULT (-1)
+#define EMFLAG_IDNONE (-2)
+#define EMFLAG_LOCKPOSITION 1
+#define EMFLAG_LOADFROMMEMORY 2
+#define EMFLAG_NODIFFRACTION 4
+
+typedef struct _EMPOINT {
+ float fX;
+ float fY;
+ float fZ;
+} EMPOINT;
+typedef EMPOINT FAR *LPEMPOINT;
+
+typedef struct _LISTENERATTRIBUTES {
+ float fDistanceFactor;
+ float fRolloffFactor;
+ float fDopplerFactor;
+} LISTENERATTRIBUTES;
+typedef LISTENERATTRIBUTES FAR *LPLISTENERATTRIBUTES;
+
+typedef struct _SOURCEATTRIBUTES {
+ EAXSOURCEPROPERTIES eaxAttributes;
+ unsigned long       ulInsideConeAngle;
+ unsigned long       ulOutsideConeAngle;
+ long                lConeOutsideVolume;
+ float               fConeXdir;
+ float               fConeYdir;
+ float               fConeZdir;
+ float               fMinDistance;
+ float               fMaxDistance;
+ long                lDupCount;
+ long                lPriority;
+} SOURCEATTRIBUTES; 
+typedef SOURCEATTRIBUTES FAR *LPSOURCEATTRIBUTES;
+
+typedef struct _MATERIALATTRIBUTES {
+ long  lLevel;
+ float fLFRatio;
+ float fRoomRatio;
+ DWORD dwFlags;
+} MATERIALATTRIBUTES;
+typedef MATERIALATTRIBUTES FAR *LPMATERIALATTRIBUTES;
+
+#define EMMATERIAL_OBSTRUCTS 1
+#define EMMATERIAL_OCCLUDES 3
+
+typedef struct _DIFFRACTIONBOX {
+ long    lSubspaceID;
+ EMPOINT empMin;
+ EMPOINT empMax;
+} DIFFRACTIONBOX;
+typedef DIFFRACTIONBOX FAR *LPDIFFRACTIONBOX;
+
+// {7CE4D6E6-562F-11d3-8812-005004062F83}
+DEFINE_GUID(CLSID_EAXMANAGER, 0x60b721a1, 0xf7c8, 0x11d2, 0xa0, 0x2e, 0x0, 0x50, 0x4, 0x6, 0x18, 0xb8);
+
+#ifdef __cplusplus
+struct IEaxManager;
+#endif // __cplusplus
+
+typedef struct IEaxManager *LPEAXMANAGER;
+
+// {7CE4D6E8-562F-11d3-8812-005004062F83}
+DEFINE_GUID(IID_IEaxManager, 0x60b721a2, 0xf7c8, 0x11d2, 0xa0, 0x2e, 0x0, 0x50, 0x4, 0x6, 0x18, 0xb8);
+
+#undef INTERFACE
+#define INTERFACE IEaxManager
+
+extern HRESULT __stdcall EaxManagerCreate(LPEAXMANAGER*);
+typedef HRESULT (__stdcall *LPEAXMANAGERCREATE)(LPEAXMANAGER*);
+
+DECLARE_INTERFACE_(IEaxManager, IUnknown)
+{
+ // IUnknown methods
+ STDMETHOD(QueryInterface)       (THIS_ REFIID, LPVOID *) PURE;
+ STDMETHOD_(ULONG,AddRef)        (THIS) PURE;
+ STDMETHOD_(ULONG,Release)       (THIS) PURE;
+
+ STDMETHOD(GetDataSetSize) (THIS_ unsigned long*, DWORD) PURE;
+ STDMETHOD(LoadDataSet) (THIS_ char*, DWORD) PURE;
+ STDMETHOD(FreeDataSet) (THIS_ DWORD) PURE;
+ STDMETHOD(GetListenerAttributes) (THIS_ LPLISTENERATTRIBUTES) PURE;
+ STDMETHOD(GetSourceID) (THIS_ char*, long*) PURE;
+ STDMETHOD(GetSourceAttributes) (THIS_ long, LPSOURCEATTRIBUTES) PURE;
+ STDMETHOD(GetSourceNumInstances) (THIS_ long, long*) PURE;
+ STDMETHOD(GetSourceInstancePos) (THIS_ long, long, LPEMPOINT) PURE;
+ STDMETHOD(GetEnvironmentID) (THIS_ char*, long*) PURE;
+ STDMETHOD(GetEnvironmentAttributes) (THIS_ long, LPEAXREVERBPROPERTIES) PURE;
+ STDMETHOD(GetMaterialID) (THIS_ char*, long*) PURE;
+ STDMETHOD(GetMaterialAttributes) (THIS_ long, LPMATERIALATTRIBUTES) PURE;
+ STDMETHOD(GetGeometrySetID) (THIS_ char*, long*) PURE;
+ STDMETHOD(GetListenerDynamicAttributes) (THIS_ long, LPEMPOINT, long*, DWORD) PURE;
+ STDMETHOD(GetSourceDynamicAttributes) (THIS_ long, LPEMPOINT, long*, float*, long*, float*, float*, LPEMPOINT, DWORD) PURE;
+// STDMETHOD(GetSubSpaceID) (THIS_ long, LPEMPOINT, long *) PURE;
+ STDMETHOD(GetEnvironmentName) (THIS_ long, char *szString, long lStrlen) PURE;
+};
+
+#if !defined(__cplusplus) || defined(CINTERFACE)
+#define IEaxManager_QueryInterface(p,a,b)                           (p)->lpVtbl->QueryInterface(p,a,b)
+#define IEaxManager_AddRef(p)                                       (p)->lpVtbl->AddRef(p)
+#define IEaxManager_Release(p)                                      (p)->lpVtbl->Release(p)
+#define IEaxManager_GetDataSetSize(p,a,b)                           (p)->lpVtbl->GetDataSetSize(p,a,b)
+#define IEaxManager_LoadDataSet(p,a,b)                              (p)->lpVtbl->LoadDataSet(p,a,b)
+#define IEaxManager_FreeDataSet(p,a)                                (p)->lpVtbl->FreeDataSet(p,a)
+#define IEaxManager_GetListenerAttributes(p,a)                      (p)->lpVtbl->GetListenerAttributes(p,a)
+#define IEaxManager_GetSourceID(p,a,b)                              (p)->lpVtbl->GetSourceID(p,a,b)
+#define IEaxManager_GetSourceAttributes(p,a,b)                      (p)->lpVtbl->GetSourceAttributes(p,a,b)
+#define IEaxManager_GetSourceNumInstances(p,a,b)                    (p)->lpVtbl->GetSourceNumInstances(p,a,b)
+#define IEaxManager_GetSourceInstancePos(p,a,b,c)                   (p)->lpVtbl->GetSourceInstancePos(p,a,b,c)
+#define IEaxManager_GetEnvironmentID(p,a,b)                         (p)->lpVtbl->GetEnvironmentID(p,a,b)
+#define IEaxManager_GetEnvironmentAttributes(p,a,b)                 (p)->lpVtbl->GetEnvironmentAttributes(p,a,b)
+#define IEaxManager_GetMaterialID(p,a,b)                            (p)->lpVtbl->GetMaterialID(p,a,b)
+#define IEaxManager_GetMaterialAttributes(p,a,b)                    (p)->lpVtbl->GetMaterialAttributes(p,a,b)
+#define IEaxManager_GetGeometrySetID(p,a,b)                         (p)->lpVtbl->GetGeometrySetID(p,a,b)
+#define IEaxManager_GetListenerDynamicAttributes(p,a,b,c,d)         (p)->lpVtbl->GetListenerDynamicAttributes(p,a,b,c,d)
+#define IEaxManager_GetSourceDynamicAttributes(p,a,b,c,d,e,f,g,h,i) (p)->lpVtbl->GetSourceDynamicAttributes(p,a,b,c,d,e,f,g,h,i)
+//#define IEaxManager_GetSubSpaceID(p,a,b,c)							(p)->lpVtbl->GetSubSpaceID(p,a,b,c)
+#define IEaxManager_GetEnvironmentName(p,a,b,c)						(p)->lpVtbl->GetEnvironmentName(p,a,b,c)
+#else
+#define IEaxManager_QueryInterface(p,a,b)                           (p)->QueryInterface(a,b)
+#define IEaxManager_AddRef(p)                                       (p)->AddRef()
+#define IEaxManager_Release(p)                                      (p)->Release()
+#define IEaxManager_GetDataSetSize(p,a,b)                           (p)->GetDataSetSize(a,b)
+#define IEaxManager_LoadDataSet(p,a,b)                              (p)->LoadDataSet(a,b)
+#define IEaxManager_FreeDataSet(p,a)                                (p)->FreeDataSet(a)
+#define IEaxManager_GetListenerAttributes(p,a)                      (p)->GetListenerAttributes(a)
+#define IEaxManager_GetSourceID(p,a,b)                              (p)->GetSourceID(a,b)
+#define IEaxManager_GetSourceAttributes(p,a,b)                      (p)->GetSourceAttributes(a,b)
+#define IEaxManager_GetSourceNumInstances(p,a,b)                    (p)->GetSourceNumInstances(a,b)
+#define IEaxManager_GetSourceInstancePos(p,a,b,c)                   (p)->GetSourceInstancePos(a,b,c)
+#define IEaxManager_GetEnvironmentID(p,a,b)                         (p)->GetEnvironmentID(a,b)
+#define IEaxManager_GetEnvironmentAttributes(p,a,b)                 (p)->GetEnvironmentAttributes(a,b)
+#define IEaxManager_GetMaterialID(p,a,b)                            (p)->GetMaterialID(a,b)
+#define IEaxManager_GetMaterialAttributes(p,a,b)                    (p)->GetMaterialAttributes(a,b)
+#define IEaxManager_GetGeometrySetID(p,a,b)                         (p)->GetGeometrySetID(a,b)
+#define IEaxManager_GetListenerDynamicAttributes(p,a,b,c,d)         (p)->GetListenerDynamicAttributes(a,b,c,d)
+#define IEaxManager_GetSourceDynamicAttributes(p,a,b,c,d,e,f,g,h,i) (p)->GetSourceDynamicAttributes(a,b,c,d,e,f,g,h,i)
+//#define IEaxManager_GetSubSpaceID(p,a,b,c)							(p)->GetSubSpaceID(a,b,c)
+#define IEaxManager_GetEnvironmentName(p,a,b,c)						(p)->GetEnvironmentName(a,b,c)
+#endif
+
+#define EM_OK 0
+#define EM_INVALIDID        MAKE_HRESULT(1, FACILITY_ITF, 1)
+#define EM_IDNOTFOUND       MAKE_HRESULT(1, FACILITY_ITF, 2)
+#define EM_FILENOTFOUND     MAKE_HRESULT(1, FACILITY_ITF, 3)
+#define EM_FILEINVALID      MAKE_HRESULT(1, FACILITY_ITF, 4)
+#define EM_VERSIONINVALID   MAKE_HRESULT(1, FACILITY_ITF, 5)
+#define EM_INSTANCENOTFOUND MAKE_HRESULT(1, FACILITY_ITF, 6)
+
+#ifdef __cplusplus
+};
+#endif // __cplusplus
+
+#endif
diff --git a/codemp/client/eax/eax.h b/codemp/client/eax/eax.h
new file mode 100644
index 0000000..538cc6c
--- /dev/null
+++ b/codemp/client/eax/eax.h
@@ -0,0 +1,1562 @@
+/*******************************************************************\
+*                                                                   *
+*  EAX.H - Environmental Audio Extensions version 4.0               *
+*          for OpenAL and DirectSound3D                             *
+*                                                                   *
+*          File revision 1.6.3 (21 February 2003)                   *
+*          EAX 4.0 API Spec version 1.6                             *
+*                                                                   *
+\*******************************************************************/
+
+#ifndef EAX_H_INCLUDED
+#define EAX_H_INCLUDED
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+#ifndef OPENAL
+    #include <dsound.h>
+
+    /*
+     * EAX Unified Interface (using Direct X 7) {4FF53B81-1CE0-11d3-AAB8-00A0C95949D5}
+     */
+    DEFINE_GUID(CLSID_EAXDirectSound, 
+        0x4ff53b81, 
+        0x1ce0, 
+        0x11d3,
+        0xaa, 0xb8, 0x0, 0xa0, 0xc9, 0x59, 0x49, 0xd5);
+        
+   /*
+    * EAX Unified Interface (using Direct X 8) {CA503B60-B176-11d4-A094-D0C0BF3A560C}
+    */
+    DEFINE_GUID(CLSID_EAXDirectSound8, 
+        0xca503b60,
+        0xb176,
+        0x11d4,
+        0xa0, 0x94, 0xd0, 0xc0, 0xbf, 0x3a, 0x56, 0xc);
+
+    
+
+#ifdef DIRECTSOUND_VERSION        
+#if DIRECTSOUND_VERSION >= 0x0800
+    __declspec(dllimport) HRESULT WINAPI EAXDirectSoundCreate8(GUID*, LPDIRECTSOUND8*, IUnknown FAR *);
+    typedef HRESULT (FAR PASCAL *LPEAXDIRECTSOUNDCREATE8)(GUID*, LPDIRECTSOUND8*, IUnknown FAR*);
+#endif
+#endif
+    
+    __declspec(dllimport) HRESULT WINAPI EAXDirectSoundCreate(GUID*, LPDIRECTSOUND*, IUnknown FAR *);
+    typedef HRESULT (FAR PASCAL *LPEAXDIRECTSOUNDCREATE)(GUID*, LPDIRECTSOUND*, IUnknown FAR*);
+
+#else // OPENAL
+    #include "../OpenAl/al.h"
+    
+    #ifndef GUID_DEFINED
+        #define GUID_DEFINED
+        typedef struct _GUID
+        {
+            unsigned long Data1;
+            unsigned short Data2;
+            unsigned short Data3;
+            unsigned char Data4[8];
+        } GUID;
+    #endif // GUID_DEFINED
+
+    #ifndef DEFINE_GUID
+        #ifndef INITGUID
+            #define DEFINE_GUID(name, l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8) \
+                    extern const GUID /*FAR*/ name
+        #else
+            #define DEFINE_GUID(name, l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8) \
+                    extern const GUID name = { l, w1, w2, { b1, b2,  b3,  b4,  b5,  b6,  b7,  b8 } }
+        #endif // INITGUID
+    #endif // DEFINE_GUID
+
+    /*
+     * EAX OpenAL Extensions
+     */
+    typedef ALenum (*EAXSet)(const GUID*, ALuint, ALuint, ALvoid*, ALuint);
+    typedef ALenum (*EAXGet)(const GUID*, ALuint, ALuint, ALvoid*, ALuint);
+#endif
+
+#pragma pack(push, 4)
+
+
+
+
+////////////////////////////////////////////////////////////////////////////
+// Constants
+
+#define EAX_MAX_FXSLOTS 4
+#define EAX_MAX_ACTIVE_FXSLOTS 2
+
+// The EAX_NULL_GUID is used by EAXFXSLOT_LOADEFFECT, EAXCONTEXT_PRIMARYFXSLOTID
+// and EAXSOURCE_ACTIVEFXSLOTID
+
+// {00000000-0000-0000-0000-000000000000}
+DEFINE_GUID(EAX_NULL_GUID, 
+    0x00000000, 
+    0x0000, 
+    0x0000, 
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00);
+
+// The EAX_PrimaryFXSlotID GUID is used by EAXSOURCE_ACTIVEFXSLOTID 
+
+// {F317866D-924C-450C-861B-E6DAA25E7C20}
+DEFINE_GUID(EAX_PrimaryFXSlotID, 
+    0xf317866d,
+    0x924c,
+    0x450c,
+    0x86, 0x1b, 0xe6, 0xda, 0xa2, 0x5e, 0x7c, 0x20);
+
+
+////////////////////////////////////////////////////////////////////////////
+
+    
+
+    
+////////////////////////////////////////////////////////////////////////////
+// Structures
+
+// Use this structure for EAXCONTEXT_ALL property.
+typedef struct _EAXCONTEXTPROPERTIES
+{
+    GUID          guidPrimaryFXSlotID;
+    float         flDistanceFactor;
+    float         flAirAbsorptionHF;
+    float         flHFReference;
+} EAXCONTEXTPROPERTIES, *LPEAXCONTEXTPROPERTIES; 
+
+// Use this structure for EAXSOURCE_ALLPARAMETERS
+// - all levels are hundredths of decibels
+// - all delays are in seconds
+//
+// NOTE: This structure may change in future EAX versions.
+//       It is recommended to initialize fields by name:
+//              myBuffer.lDirect = 0;
+//              myBuffer.lDirectHF = -200;
+//              ...
+//              myBuffer.dwFlags = myFlags /* see EAXSOURCEFLAGS below */ ;
+//       instead of:
+//              myBuffer = { 0, -200, ... , 0x00000003 };
+//
+typedef struct _EAXSOURCEPROPERTIES
+{
+    long          lDirect;                 // direct path level (at low and mid frequencies)
+    long          lDirectHF;               // relative direct path level at high frequencies
+    long          lRoom;                   // room effect level (at low and mid frequencies)
+    long          lRoomHF;                 // relative room effect level at high frequencies
+    long          lObstruction;            // main obstruction control (attenuation at high frequencies) 
+    float         flObstructionLFRatio;    // obstruction low-frequency level re. main control
+    long          lOcclusion;              // main occlusion control (attenuation at high frequencies)
+    float         flOcclusionLFRatio;      // occlusion low-frequency level re. main control
+    float         flOcclusionRoomRatio;    // relative occlusion control for room effect
+    float         flOcclusionDirectRatio;  // relative occlusion control for direct path
+    long          lExclusion;              // main exlusion control (attenuation at high frequencies)
+    float         flExclusionLFRatio;      // exclusion low-frequency level re. main control
+    long          lOutsideVolumeHF;        // outside sound cone level at high frequencies
+    float         flDopplerFactor;         // like DS3D flDopplerFactor but per source
+    float         flRolloffFactor;         // like DS3D flRolloffFactor but per source
+    float         flRoomRolloffFactor;     // like DS3D flRolloffFactor but for room effect
+    float         flAirAbsorptionFactor;   // multiplies EAXREVERB_AIRABSORPTIONHF
+    unsigned long ulFlags;                 // modifies the behavior of properties
+} EAXSOURCEPROPERTIES, *LPEAXSOURCEPROPERTIES;
+
+// Use this structure for EAXSOURCE_ALLSENDPARAMETERS
+// - all levels are hundredths of decibels
+//
+typedef struct _EAXSOURCEALLSENDPROPERTIES
+{
+	GUID          guidReceivingFXSlotID;
+	long          lSend;                   // send level (at low and mid frequencies)
+	long          lSendHF;                 // relative send level at high frequencies
+	long          lOcclusion;
+	float         flOcclusionLFRatio;
+	float         flOcclusionRoomRatio;
+	float         flOcclusionDirectRatio;
+	long          lExclusion; 
+	float         flExclusionLFRatio;
+} EAXSOURCEALLSENDPROPERTIES, *LPEAXSOURCEALLSENDPROPERTIES;
+
+// Use this structure for EAXSOURCE_ACTIVEFXSLOTID
+typedef struct _EAXACTIVEFXSLOTS
+{
+    GUID          guidActiveFXSlots[EAX_MAX_ACTIVE_FXSLOTS];
+} EAXACTIVEFXSLOTS, *LPEAXACTIVEFXSLOTS;
+
+// Use this structure for EAXSOURCE_OBSTRUCTIONPARAMETERS property.
+typedef struct _EAXOBSTRUCTIONPROPERTIES
+{
+    long          lObstruction;
+    float         flObstructionLFRatio;
+} EAXOBSTRUCTIONPROPERTIES, *LPEAXOBSTRUCTIONPROPERTIES;
+
+// Use this structure for EAXSOURCE_OCCLUSIONPARAMETERS property.
+typedef struct _EAXOCCLUSIONPROPERTIES
+{
+    long          lOcclusion;
+    float         flOcclusionLFRatio;
+    float         flOcclusionRoomRatio;
+    float         flOcclusionDirectRatio;
+} EAXOCCLUSIONPROPERTIES, *LPEAXOCCLUSIONPROPERTIES;
+
+// Use this structure for EAXSOURCE_EXCLUSIONPARAMETERS property.
+typedef struct _EAXEXCLUSIONPROPERTIES
+{
+    long          lExclusion;
+    float         flExclusionLFRatio;
+} EAXEXCLUSIONPROPERTIES, *LPEAXEXCLUSIONPROPERTIES;
+
+// Use this structure for EAXSOURCE_SENDPARAMETERS properties.
+typedef struct _EAXSOURCESENDPROPERTIES
+{
+    GUID          guidReceivingFXSlotID;
+    long          lSend;
+    long          lSendHF;
+} EAXSOURCESENDPROPERTIES, *LPEAXSOURCESENDPROPERTIES;
+
+// Use this structure for EAXSOURCE_OCCLUSIONSENDPARAMETERS 
+typedef struct _EAXSOURCEOCCLUSIONSENDPROPERTIES
+{
+	GUID          guidReceivingFXSlotID;
+	long          lOcclusion;
+	float         flOcclusionLFRatio;
+	float         flOcclusionRoomRatio;
+	float         flOcclusionDirectRatio;
+} EAXSOURCEOCCLUSIONSENDPROPERTIES, *LPEAXSOURCEOCCLUSIONSENDPROPERTIES;
+
+// Use this structure for EAXSOURCE_EXCLUSIONSENDPARAMETERS
+typedef struct _EAXSOURCEEXCLUSIONSENDPROPERTIES
+{
+	GUID          guidReceivingFXSlotID;
+	long          lExclusion;
+	float         flExclusionLFRatio;
+} EAXSOURCEEXCLUSIONSENDPROPERTIES, *LPEAXSOURCEEXCLUSIONSENDPROPERTIES;
+
+// Use this structure for EAXFXSLOT_ALLPARAMETERS
+// - all levels are hundredths of decibels
+//
+// NOTE: This structure may change in future EAX versions.
+//       It is recommended to initialize fields by name:
+//              myFXSlot.guidLoadEffect = EAX_REVERB_EFFECT;
+//              myFXSlot.lVolume = 0;
+//              myFXSlot.lLock = 1;
+//              myFXSlot.ulFlags = myFlags /* see EAXFXSLOTFLAGS below */ ;
+//       instead of:
+//              myFXSlot = { EAX_REVERB_EFFECT, 0, 1, 0x00000001 };
+//
+typedef struct _EAXFXSLOTPROPERTIES
+{
+	GUID          guidLoadEffect;
+	long          lVolume;
+	long          lLock;
+	unsigned long ulFlags;
+} EAXFXSLOTPROPERTIES, *LPEAXFXSLOTPROPERTIES;
+
+// Use this structure for EAXREVERB_REFLECTIONSPAN and EAXREVERB_REVERBPAN properties.
+#ifndef EAXVECTOR_DEFINED
+#define EAXVECTOR_DEFINED
+typedef struct _EAXVECTOR {
+    float x;
+    float y;
+    float z;
+} EAXVECTOR;
+#endif
+
+
+////////////////////////////////////////////////////////////////////////////
+
+
+
+
+////////////////////////////////////////////////////////////////////////////
+// Error Codes
+
+#define EAX_OK                     0
+#define EAXERR_INVALID_OPERATION   (-1)
+#define EAXERR_INVALID_VALUE       (-2)
+#define EAXERR_NO_EFFECT_LOADED    (-3)
+#define EAXERR_UNKNOWN_EFFECT      (-4)
+////////////////////////////////////////////////////////////////////////////
+
+
+
+
+////////////////////////////////////////////////////////////////////////////
+// Context Object
+
+// {1D4870AD-0DEF-43c0-A40C-523632296342}
+DEFINE_GUID(EAXPROPERTYID_EAX40_Context, 
+    0x1d4870ad, 
+    0xdef, 
+    0x43c0, 
+    0xa4, 0xc, 0x52, 0x36, 0x32, 0x29, 0x63, 0x42);
+
+// For compatibility with future EAX versions:
+#define EAXPROPERTYID_EAX_Context EAXPROPERTYID_EAX40_Context
+
+typedef enum
+{
+    EAXCONTEXT_NONE = 0,
+    EAXCONTEXT_ALLPARAMETERS,
+    EAXCONTEXT_PRIMARYFXSLOTID,
+    EAXCONTEXT_DISTANCEFACTOR,
+    EAXCONTEXT_AIRABSORPTIONHF,
+    EAXCONTEXT_HFREFERENCE,
+    EAXCONTEXT_LASTERROR
+} EAXCONTEXT_PROPERTY;
+
+// OR these flags with property id
+#define EAXCONTEXT_PARAMETER_IMMEDIATE 0x00000000 // changes take effect immediately
+#define EAXCONTEXT_PARAMETER_DEFER     0x80000000 // changes take effect later
+#define EAXCONTEXT_PARAMETER_COMMITDEFERREDSETTINGS (EAXCONTEXT_NONE | \
+                                                      EAXCONTEXT_PARAMETER_IMMEDIATE)
+
+// EAX Context property ranges and defaults:
+#define EAXCONTEXT_DEFAULTPRIMARYFXSLOTID EAXPROPERTYID_EAX40_FXSlot0
+
+#define EAXCONTEXT_MINDISTANCEFACTOR        FLT_MIN //minimum positive value
+#define EAXCONTEXT_MAXDISTANCEFACTOR        FLT_MAX
+#define EAXCONTEXT_DEFAULTDISTANCEFACTOR    1.0f
+
+#define EAXCONTEXT_MINAIRABSORPTIONHF     (-100.0f)
+#define EAXCONTEXT_MAXAIRABSORPTIONHF     0.0f
+#define EAXCONTEXT_DEFAULTAIRABSORPTIONHF (-5.0f)
+
+#define EAXCONTEXT_MINHFREFERENCE         1000.0f
+#define EAXCONTEXT_MAXHFREFERENCE         20000.0f
+#define EAXCONTEXT_DEFAULTHFREFERENCE     5000.0f
+
+#define EAXCONTEXT_DEFAULTLASTERROR         EAX_OK
+
+////////////////////////////////////////////////////////////////////////////
+
+
+
+
+////////////////////////////////////////////////////////////////////////////
+// Effect Slot Objects
+
+// {C4D79F1E-F1AC-436b-A81D-A738E7045469}
+DEFINE_GUID(EAXPROPERTYID_EAX40_FXSlot0, 
+    0xc4d79f1e, 
+    0xf1ac, 
+    0x436b, 
+    0xa8, 0x1d, 0xa7, 0x38, 0xe7, 0x4, 0x54, 0x69);
+
+// {08C00E96-74BE-4491-93AA-E8AD35A49117}
+DEFINE_GUID(EAXPROPERTYID_EAX40_FXSlot1, 
+    0x8c00e96, 
+    0x74be, 
+    0x4491, 
+    0x93, 0xaa, 0xe8, 0xad, 0x35, 0xa4, 0x91, 0x17);
+
+// {1D433B88-F0F6-4637-919F-60E7E06B5EDD}
+DEFINE_GUID(EAXPROPERTYID_EAX40_FXSlot2, 
+    0x1d433b88, 
+    0xf0f6, 
+    0x4637, 
+    0x91, 0x9f, 0x60, 0xe7, 0xe0, 0x6b, 0x5e, 0xdd);
+
+// {EFFF08EA-C7D8-44ab-93AD-6DBD5F910064}
+DEFINE_GUID(EAXPROPERTYID_EAX40_FXSlot3, 
+    0xefff08ea, 
+    0xc7d8, 
+    0x44ab, 
+    0x93, 0xad, 0x6d, 0xbd, 0x5f, 0x91, 0x0, 0x64);
+
+// For compatibility with future EAX versions:
+#define EAXPROPERTYID_EAX_FXSlot0 EAXPROPERTYID_EAX40_FXSlot0
+#define EAXPROPERTYID_EAX_FXSlot1 EAXPROPERTYID_EAX40_FXSlot1
+#define EAXPROPERTYID_EAX_FXSlot2 EAXPROPERTYID_EAX40_FXSlot2
+#define EAXPROPERTYID_EAX_FXSlot3 EAXPROPERTYID_EAX40_FXSlot3
+
+// FXSlot object properties
+typedef enum
+{
+    EAXFXSLOT_PARAMETER = 0, // range 0-0x40 reserved for loaded effect parameters
+    EAXFXSLOT_NONE = 0x10000,
+	EAXFXSLOT_ALLPARAMETERS,
+    EAXFXSLOT_LOADEFFECT,
+    EAXFXSLOT_VOLUME,
+	EAXFXSLOT_LOCK,
+	EAXFXSLOT_FLAGS
+} EAXFXSLOT_PROPERTY;
+
+// Note: The number and order of flags may change in future EAX versions.
+//       To insure future compatibility, use flag defines as follows:
+//              myFlags = EAXFXSLOTFLAGS_ENVIRONMENT;
+//       instead of:
+//              myFlags = 0x00000001;
+//
+#define EAXFXSLOTFLAGS_ENVIRONMENT   0x00000001
+#define EAXFXSLOTFLAGS_RESERVED      0xFFFFFFFE // reserved future use
+
+// EAX Effect Slot property ranges and defaults:
+#define EAXFXSLOT_MINVOLUME                    (-10000)
+#define EAXFXSLOT_MAXVOLUME                    0
+#define EAXFXSLOT_DEFAULTVOLUME                0
+
+#define EAXFXSLOT_MINLOCK    0
+#define EAXFXSLOT_MAXLOCK    1
+
+enum
+{
+   EAXFXSLOT_UNLOCKED = 0,
+   EAXFXSLOT_LOCKED = 1
+};
+
+#define EAXFXSLOT_DEFAULTFLAGS                 (EAXFXSLOTFLAGS_ENVIRONMENT)
+////////////////////////////////////////////////////////////////////////////
+
+
+
+
+////////////////////////////////////////////////////////////////////////////
+// Source Object
+
+// {1B86B823-22DF-4eae-8B3C-1278CE544227}
+DEFINE_GUID(EAXPROPERTYID_EAX40_Source, 
+    0x1b86b823, 
+    0x22df, 
+    0x4eae, 
+    0x8b, 0x3c, 0x12, 0x78, 0xce, 0x54, 0x42, 0x27);
+
+// For compatibility with future EAX versions:
+#define EAXPROPERTYID_EAX_Source EAXPROPERTYID_EAX40_Source
+
+// Source object properties
+typedef enum
+{
+    EAXSOURCE_NONE,
+    EAXSOURCE_ALLPARAMETERS,
+    EAXSOURCE_OBSTRUCTIONPARAMETERS,
+    EAXSOURCE_OCCLUSIONPARAMETERS,
+    EAXSOURCE_EXCLUSIONPARAMETERS,
+    EAXSOURCE_DIRECT,
+    EAXSOURCE_DIRECTHF,
+    EAXSOURCE_ROOM,
+    EAXSOURCE_ROOMHF,
+    EAXSOURCE_OBSTRUCTION,
+    EAXSOURCE_OBSTRUCTIONLFRATIO,
+    EAXSOURCE_OCCLUSION,
+    EAXSOURCE_OCCLUSIONLFRATIO, 
+    EAXSOURCE_OCCLUSIONROOMRATIO,
+    EAXSOURCE_OCCLUSIONDIRECTRATIO,
+    EAXSOURCE_EXCLUSION, 
+    EAXSOURCE_EXCLUSIONLFRATIO,
+    EAXSOURCE_OUTSIDEVOLUMEHF, 
+    EAXSOURCE_DOPPLERFACTOR, 
+    EAXSOURCE_ROLLOFFFACTOR, 
+    EAXSOURCE_ROOMROLLOFFFACTOR,
+    EAXSOURCE_AIRABSORPTIONFACTOR,
+    EAXSOURCE_FLAGS,
+    EAXSOURCE_SENDPARAMETERS,
+    EAXSOURCE_ALLSENDPARAMETERS,
+    EAXSOURCE_OCCLUSIONSENDPARAMETERS,
+    EAXSOURCE_EXCLUSIONSENDPARAMETERS,
+    EAXSOURCE_ACTIVEFXSLOTID,
+} EAXSOURCE_PROPERTY;
+
+// OR these flags with property id
+#define EAXSOURCE_PARAMETER_IMMEDIATE 0x00000000 // changes take effect immediately
+#define EAXSOURCE_PARAMETER_DEFERRED  0x80000000 // changes take effect later
+#define EAXSOURCE_PARAMETER_COMMITDEFERREDSETTINGS (EAXSOURCE_NONE | \
+                                                    EAXSOURCE_PARAMETER_IMMEDIATE)
+// Used by EAXSOURCE_FLAGS for EAXSOURCEFLAGS_xxxAUTO
+//    TRUE:    value is computed automatically - property is an offset
+//    FALSE:   value is used directly
+//
+// Note: The number and order of flags may change in future EAX versions.
+//       To insure future compatibility, use flag defines as follows:
+//              myFlags = EAXSOURCE_DIRECTHFAUTO | EAXSOURCE_ROOMAUTO;
+//       instead of:
+//              myFlags = 0x00000003;
+//
+#define EAXSOURCEFLAGS_DIRECTHFAUTO          0x00000001 // relates to EAXSOURCE_DIRECTHF
+#define EAXSOURCEFLAGS_ROOMAUTO              0x00000002 // relates to EAXSOURCE_ROOM
+#define EAXSOURCEFLAGS_ROOMHFAUTO            0x00000004 // relates to EAXSOURCE_ROOMHF
+#define EAXSOURCEFLAGS_RESERVED              0xFFFFFFF8 // reserved future use
+
+// EAX Source property ranges and defaults:
+#define EAXSOURCE_MINSEND                      (-10000)
+#define EAXSOURCE_MAXSEND                      0
+#define EAXSOURCE_DEFAULTSEND                  0
+
+#define EAXSOURCE_MINSENDHF                    (-10000)
+#define EAXSOURCE_MAXSENDHF                    0
+#define EAXSOURCE_DEFAULTSENDHF                0
+
+#define EAXSOURCE_MINDIRECT                    (-10000)
+#define EAXSOURCE_MAXDIRECT                    1000
+#define EAXSOURCE_DEFAULTDIRECT                0
+
+#define EAXSOURCE_MINDIRECTHF                  (-10000)
+#define EAXSOURCE_MAXDIRECTHF                  0
+#define EAXSOURCE_DEFAULTDIRECTHF              0
+
+#define EAXSOURCE_MINROOM                      (-10000)
+#define EAXSOURCE_MAXROOM                      1000
+#define EAXSOURCE_DEFAULTROOM                  0
+
+#define EAXSOURCE_MINROOMHF                    (-10000)
+#define EAXSOURCE_MAXROOMHF                    0
+#define EAXSOURCE_DEFAULTROOMHF                0
+
+#define EAXSOURCE_MINOBSTRUCTION               (-10000)
+#define EAXSOURCE_MAXOBSTRUCTION               0
+#define EAXSOURCE_DEFAULTOBSTRUCTION           0
+
+#define EAXSOURCE_MINOBSTRUCTIONLFRATIO        0.0f
+#define EAXSOURCE_MAXOBSTRUCTIONLFRATIO        1.0f
+#define EAXSOURCE_DEFAULTOBSTRUCTIONLFRATIO    0.0f
+
+#define EAXSOURCE_MINOCCLUSION                 (-10000)
+#define EAXSOURCE_MAXOCCLUSION                 0
+#define EAXSOURCE_DEFAULTOCCLUSION             0
+
+#define EAXSOURCE_MINOCCLUSIONLFRATIO          0.0f
+#define EAXSOURCE_MAXOCCLUSIONLFRATIO          1.0f
+#define EAXSOURCE_DEFAULTOCCLUSIONLFRATIO      0.25f
+
+#define EAXSOURCE_MINOCCLUSIONROOMRATIO        0.0f
+#define EAXSOURCE_MAXOCCLUSIONROOMRATIO        10.0f
+#define EAXSOURCE_DEFAULTOCCLUSIONROOMRATIO    1.5f
+
+#define EAXSOURCE_MINOCCLUSIONDIRECTRATIO      0.0f
+#define EAXSOURCE_MAXOCCLUSIONDIRECTRATIO      10.0f
+#define EAXSOURCE_DEFAULTOCCLUSIONDIRECTRATIO  1.0f
+
+#define EAXSOURCE_MINEXCLUSION                 (-10000)
+#define EAXSOURCE_MAXEXCLUSION                 0
+#define EAXSOURCE_DEFAULTEXCLUSION             0
+
+#define EAXSOURCE_MINEXCLUSIONLFRATIO          0.0f
+#define EAXSOURCE_MAXEXCLUSIONLFRATIO          1.0f
+#define EAXSOURCE_DEFAULTEXCLUSIONLFRATIO      1.0f
+
+#define EAXSOURCE_MINOUTSIDEVOLUMEHF           (-10000)
+#define EAXSOURCE_MAXOUTSIDEVOLUMEHF           0
+#define EAXSOURCE_DEFAULTOUTSIDEVOLUMEHF       0
+
+#define EAXSOURCE_MINDOPPLERFACTOR             0.0f
+#define EAXSOURCE_MAXDOPPLERFACTOR             10.f
+#define EAXSOURCE_DEFAULTDOPPLERFACTOR         1.0f
+
+#define EAXSOURCE_MINROLLOFFFACTOR             0.0f
+#define EAXSOURCE_MAXROLLOFFFACTOR             10.f
+#define EAXSOURCE_DEFAULTROLLOFFFACTOR         0.0f
+
+#define EAXSOURCE_MINROOMROLLOFFFACTOR         0.0f
+#define EAXSOURCE_MAXROOMROLLOFFFACTOR         10.f
+#define EAXSOURCE_DEFAULTROOMROLLOFFFACTOR     0.0f
+
+#define EAXSOURCE_MINAIRABSORPTIONFACTOR       0.0f
+#define EAXSOURCE_MAXAIRABSORPTIONFACTOR       10.0f
+#define EAXSOURCE_DEFAULTAIRABSORPTIONFACTOR   0.0f
+
+#define EAXSOURCE_DEFAULTFLAGS                 (EAXSOURCEFLAGS_DIRECTHFAUTO |       \
+                                                EAXSOURCEFLAGS_ROOMAUTO     |       \
+                                                EAXSOURCEFLAGS_ROOMHFAUTO  )
+
+#define EAXSOURCE_DEFAULTACTIVEFXSLOTID  {{ EAX_NULL_GUID.Data1, EAX_NULL_GUID.Data2, EAX_NULL_GUID.Data3, \
+                                    EAX_NULL_GUID.Data4[0],EAX_NULL_GUID.Data4[1],EAX_NULL_GUID.Data4[2],\
+                                    EAX_NULL_GUID.Data4[3],EAX_NULL_GUID.Data4[4],EAX_NULL_GUID.Data4[5],\
+                                    EAX_NULL_GUID.Data4[6],EAX_NULL_GUID.Data4[7] },                       \
+                                  { EAX_PrimaryFXSlotID.Data1, EAX_PrimaryFXSlotID.Data2, \
+                                    EAX_PrimaryFXSlotID.Data3, EAX_PrimaryFXSlotID.Data4[0],\
+                                    EAX_PrimaryFXSlotID.Data4[1],EAX_PrimaryFXSlotID.Data4[2],\
+                                    EAX_PrimaryFXSlotID.Data4[3],EAX_PrimaryFXSlotID.Data4[4],\
+                                    EAX_PrimaryFXSlotID.Data4[5],EAX_PrimaryFXSlotID.Data4[6],\
+                                    EAX_PrimaryFXSlotID.Data4[7] }}
+
+
+////////////////////////////////////////////////////////////////////////////
+
+
+
+
+////////////////////////////////////////////////////////////////////////////
+// Reverb Effect
+
+// EAX REVERB {0CF95C8F-A3CC-4849-B0B6-832ECC1822DF}
+DEFINE_GUID(EAX_REVERB_EFFECT, 
+    0xcf95c8f, 
+    0xa3cc, 
+    0x4849, 
+    0xb0, 0xb6, 0x83, 0x2e, 0xcc, 0x18, 0x22, 0xdf);
+
+// Reverb effect properties
+typedef enum
+{
+    EAXREVERB_NONE,
+    EAXREVERB_ALLPARAMETERS,
+    EAXREVERB_ENVIRONMENT,
+    EAXREVERB_ENVIRONMENTSIZE,
+    EAXREVERB_ENVIRONMENTDIFFUSION,
+    EAXREVERB_ROOM,
+    EAXREVERB_ROOMHF,
+    EAXREVERB_ROOMLF,
+    EAXREVERB_DECAYTIME,
+    EAXREVERB_DECAYHFRATIO,
+    EAXREVERB_DECAYLFRATIO,
+    EAXREVERB_REFLECTIONS,
+    EAXREVERB_REFLECTIONSDELAY,
+    EAXREVERB_REFLECTIONSPAN,
+    EAXREVERB_REVERB,
+    EAXREVERB_REVERBDELAY,
+    EAXREVERB_REVERBPAN,
+    EAXREVERB_ECHOTIME,
+    EAXREVERB_ECHODEPTH,
+    EAXREVERB_MODULATIONTIME,
+    EAXREVERB_MODULATIONDEPTH,
+    EAXREVERB_AIRABSORPTIONHF,
+    EAXREVERB_HFREFERENCE,
+    EAXREVERB_LFREFERENCE,
+    EAXREVERB_ROOMROLLOFFFACTOR,
+    EAXREVERB_FLAGS,
+} EAXREVERB_PROPERTY;
+
+// OR these flags with property id
+#define EAXREVERB_IMMEDIATE 0x00000000 // changes take effect immediately
+#define EAXREVERB_DEFERRED  0x80000000 // changes take effect later
+#define EAXREVERB_COMMITDEFERREDSETTINGS (EAXREVERB_NONE | \
+                                          EAXREVERB_IMMEDIATE)
+
+// used by EAXREVERB_ENVIRONMENT
+enum
+{
+    EAX_ENVIRONMENT_GENERIC,
+    EAX_ENVIRONMENT_PADDEDCELL,
+    EAX_ENVIRONMENT_ROOM,
+    EAX_ENVIRONMENT_BATHROOM,
+    EAX_ENVIRONMENT_LIVINGROOM,
+    EAX_ENVIRONMENT_STONEROOM,
+    EAX_ENVIRONMENT_AUDITORIUM,
+    EAX_ENVIRONMENT_CONCERTHALL,
+    EAX_ENVIRONMENT_CAVE,
+    EAX_ENVIRONMENT_ARENA,
+    EAX_ENVIRONMENT_HANGAR,
+    EAX_ENVIRONMENT_CARPETEDHALLWAY,
+    EAX_ENVIRONMENT_HALLWAY,
+    EAX_ENVIRONMENT_STONECORRIDOR,
+    EAX_ENVIRONMENT_ALLEY,
+    EAX_ENVIRONMENT_FOREST,
+    EAX_ENVIRONMENT_CITY,
+    EAX_ENVIRONMENT_MOUNTAINS,
+    EAX_ENVIRONMENT_QUARRY,
+    EAX_ENVIRONMENT_PLAIN,
+    EAX_ENVIRONMENT_PARKINGLOT,
+    EAX_ENVIRONMENT_SEWERPIPE,
+    EAX_ENVIRONMENT_UNDERWATER,
+    EAX_ENVIRONMENT_DRUGGED,
+    EAX_ENVIRONMENT_DIZZY,
+    EAX_ENVIRONMENT_PSYCHOTIC,
+
+    EAX_ENVIRONMENT_UNDEFINED,
+
+    EAX_ENVIRONMENT_COUNT
+};
+
+// Used by EAXREVERB_FLAGS
+//
+// Note: The number and order of flags may change in future EAX versions.
+//       It is recommended to use the flag defines as follows:
+//              myFlags = EAXREVERBFLAGS_DECAYTIMESCALE | EAXREVERBFLAGS_REVERBSCALE;
+//       instead of:
+//              myFlags = 0x00000009;
+//
+// These flags determine what properties are affected by environment size.
+#define EAXREVERBFLAGS_DECAYTIMESCALE        0x00000001 // reverberation decay time
+#define EAXREVERBFLAGS_REFLECTIONSSCALE      0x00000002 // reflection level
+#define EAXREVERBFLAGS_REFLECTIONSDELAYSCALE 0x00000004 // initial reflection delay time
+#define EAXREVERBFLAGS_REVERBSCALE           0x00000008 // reflections level
+#define EAXREVERBFLAGS_REVERBDELAYSCALE      0x00000010 // late reverberation delay time
+#define EAXREVERBFLAGS_ECHOTIMESCALE         0x00000040 // echo time
+#define EAXREVERBFLAGS_MODULATIONTIMESCALE   0x00000080 // modulation time
+// This flag limits high-frequency decay time according to air absorption.
+#define EAXREVERBFLAGS_DECAYHFLIMIT          0x00000020
+#define EAXREVERBFLAGS_RESERVED              0xFFFFFF00 // reserved future use
+
+// Use this structure for EAXREVERB_ALLPARAMETERS
+// - all levels are hundredths of decibels
+// - all times and delays are in seconds
+//
+// NOTE: This structure may change in future EAX versions.
+//       It is recommended to initialize fields by name:
+//              myReverb.lRoom = -1000;
+//              myReverb.lRoomHF = -100;
+//              ...
+//              myReverb.dwFlags = myFlags /* see EAXREVERBFLAGS below */ ;
+//       instead of:
+//              myReverb = { -1000, -100, ... , 0x00000009 };
+//       If you want to save and load presets in binary form, you 
+//       should define your own structure to insure future compatibility.
+//
+typedef struct _EAXREVERBPROPERTIES
+{
+    unsigned long ulEnvironment;   // sets all reverb properties
+    float flEnvironmentSize;       // environment size in meters
+    float flEnvironmentDiffusion;  // environment diffusion
+    long lRoom;                    // room effect level (at mid frequencies)
+    long lRoomHF;                  // relative room effect level at high frequencies
+    long lRoomLF;                  // relative room effect level at low frequencies  
+    float flDecayTime;             // reverberation decay time at mid frequencies
+    float flDecayHFRatio;          // high-frequency to mid-frequency decay time ratio
+    float flDecayLFRatio;          // low-frequency to mid-frequency decay time ratio   
+    long lReflections;             // early reflections level relative to room effect
+    float flReflectionsDelay;      // initial reflection delay time
+    EAXVECTOR vReflectionsPan;     // early reflections panning vector
+    long lReverb;                  // late reverberation level relative to room effect
+    float flReverbDelay;           // late reverberation delay time relative to initial reflection
+    EAXVECTOR vReverbPan;          // late reverberation panning vector
+    float flEchoTime;              // echo time
+    float flEchoDepth;             // echo depth
+    float flModulationTime;        // modulation time
+    float flModulationDepth;       // modulation depth
+    float flAirAbsorptionHF;       // change in level per meter at high frequencies
+    float flHFReference;           // reference high frequency
+    float flLFReference;           // reference low frequency 
+    float flRoomRolloffFactor;     // like DS3D flRolloffFactor but for room effect
+    unsigned long ulFlags;         // modifies the behavior of properties
+} EAXREVERBPROPERTIES, *LPEAXREVERBPROPERTIES;
+
+// Property ranges and defaults:
+#define EAXREVERB_MINENVIRONMENT                0
+#define EAXREVERB_MAXENVIRONMENT               (EAX_ENVIRONMENT_COUNT-1)
+#define EAXREVERB_DEFAULTENVIRONMENT            EAX_ENVIRONMENT_GENERIC
+
+#define EAXREVERB_MINENVIRONMENTSIZE            1.0f
+#define EAXREVERB_MAXENVIRONMENTSIZE            100.0f
+#define EAXREVERB_DEFAULTENVIRONMENTSIZE        7.5f
+
+#define EAXREVERB_MINENVIRONMENTDIFFUSION       0.0f
+#define EAXREVERB_MAXENVIRONMENTDIFFUSION       1.0f
+#define EAXREVERB_DEFAULTENVIRONMENTDIFFUSION   1.0f
+
+#define EAXREVERB_MINROOM                       (-10000)
+#define EAXREVERB_MAXROOM                       0
+#define EAXREVERB_DEFAULTROOM                   (-1000)
+
+#define EAXREVERB_MINROOMHF                     (-10000)
+#define EAXREVERB_MAXROOMHF                     0
+#define EAXREVERB_DEFAULTROOMHF                 (-100)
+
+#define EAXREVERB_MINROOMLF                     (-10000)
+#define EAXREVERB_MAXROOMLF                     0
+#define EAXREVERB_DEFAULTROOMLF                 0
+
+#define EAXREVERB_MINDECAYTIME                  0.1f
+#define EAXREVERB_MAXDECAYTIME                  20.0f
+#define EAXREVERB_DEFAULTDECAYTIME              1.49f
+
+#define EAXREVERB_MINDECAYHFRATIO               0.1f
+#define EAXREVERB_MAXDECAYHFRATIO               2.0f
+#define EAXREVERB_DEFAULTDECAYHFRATIO           0.83f
+
+#define EAXREVERB_MINDECAYLFRATIO               0.1f
+#define EAXREVERB_MAXDECAYLFRATIO               2.0f
+#define EAXREVERB_DEFAULTDECAYLFRATIO           1.00f
+
+#define EAXREVERB_MINREFLECTIONS                (-10000)
+#define EAXREVERB_MAXREFLECTIONS                1000
+#define EAXREVERB_DEFAULTREFLECTIONS            (-2602)
+
+#define EAXREVERB_MINREFLECTIONSDELAY           0.0f
+#define EAXREVERB_MAXREFLECTIONSDELAY           0.3f
+#define EAXREVERB_DEFAULTREFLECTIONSDELAY       0.007f
+
+#define EAXREVERB_DEFAULTREFLECTIONSPAN         {0.0f, 0.0f, 0.0f}
+
+#define EAXREVERB_MINREVERB                     (-10000)
+#define EAXREVERB_MAXREVERB                     2000
+#define EAXREVERB_DEFAULTREVERB                 200
+
+#define EAXREVERB_MINREVERBDELAY                0.0f
+#define EAXREVERB_MAXREVERBDELAY                0.1f
+#define EAXREVERB_DEFAULTREVERBDELAY            0.011f
+
+#define EAXREVERB_DEFAULTREVERBPAN              {0.0f, 0.0f, 0.0f}
+
+#define EAXREVERB_MINECHOTIME                   0.075f
+#define EAXREVERB_MAXECHOTIME                      0.25f
+#define EAXREVERB_DEFAULTECHOTIME               0.25f
+
+#define EAXREVERB_MINECHODEPTH                  0.0f
+#define EAXREVERB_MAXECHODEPTH                  1.0f
+#define EAXREVERB_DEFAULTECHODEPTH              0.0f
+
+#define EAXREVERB_MINMODULATIONTIME             0.04f
+#define EAXREVERB_MAXMODULATIONTIME             4.0f
+#define EAXREVERB_DEFAULTMODULATIONTIME         0.25f
+
+#define EAXREVERB_MINMODULATIONDEPTH            0.0f
+#define EAXREVERB_MAXMODULATIONDEPTH            1.0f
+#define EAXREVERB_DEFAULTMODULATIONDEPTH        0.0f
+
+#define EAXREVERB_MINAIRABSORPTIONHF            (-100.0f)
+#define EAXREVERB_MAXAIRABSORPTIONHF            0.0f
+#define EAXREVERB_DEFAULTAIRABSORPTIONHF        (-5.0f)
+
+#define EAXREVERB_MINHFREFERENCE                1000.0f
+#define EAXREVERB_MAXHFREFERENCE                20000.0f
+#define EAXREVERB_DEFAULTHFREFERENCE            5000.0f
+
+#define EAXREVERB_MINLFREFERENCE                20.0f
+#define EAXREVERB_MAXLFREFERENCE                1000.0f
+#define EAXREVERB_DEFAULTLFREFERENCE            250.0f
+
+#define EAXREVERB_MINROOMROLLOFFFACTOR          0.0f
+#define EAXREVERB_MAXROOMROLLOFFFACTOR          10.0f
+#define EAXREVERB_DEFAULTROOMROLLOFFFACTOR      0.0f
+
+#define EAXREVERB_DEFAULTFLAGS                  (EAXREVERBFLAGS_DECAYTIMESCALE |        \
+                                                 EAXREVERBFLAGS_REFLECTIONSSCALE |      \
+                                                 EAXREVERBFLAGS_REFLECTIONSDELAYSCALE | \
+                                                 EAXREVERBFLAGS_REVERBSCALE |           \
+                                                 EAXREVERBFLAGS_REVERBDELAYSCALE |      \
+                                                 EAXREVERBFLAGS_DECAYHFLIMIT)
+////////////////////////////////////////////////////////////////////////////
+
+
+
+
+////////////////////////////////////////////////////////////////////////////
+
+//          New Effect Types
+
+////////////////////////////////////////////////////////////////////////////
+
+
+////////////////////////////////////////////////////////////////////////////
+// AGC Compressor Effect
+
+// EAX AGC COMPRESSOR {BFB7A01E-7825-4039-927F-3AABDA0C560}
+
+DEFINE_GUID(EAX_AGCCOMPRESSOR_EFFECT,
+    0xbfb7a01e,
+    0x7825,
+    0x4039,
+    0x92, 0x7f, 0x3, 0xaa, 0xbd, 0xa0, 0xc5, 0x60);
+
+// AGC Compressor properties
+typedef enum
+{
+    EAXAGCCOMPRESSOR_NONE,
+    EAXAGCCOMPRESSOR_ALLPARAMETERS,
+    EAXAGCCOMPRESSOR_ONOFF
+} EAXAGCCOMPRESSOR_PROPERTY;
+
+// OR these flags with property id
+#define EAXAGCCOMPRESSOR_IMMEDIATE 0x00000000 // changes take effect immediately
+#define EAXAGCCOMPRESSOR_DEFERRED  0x80000000 // changes take effect later
+#define EAXAGCCOMPRESSOR_COMMITDEFERREDSETTINGS (EAXAGCCOMPRESSOR_NONE | \
+                                                 EAXAGCCOMPRESSOR_IMMEDIATE)
+
+// Use this structure for EAXAGCCOMPRESSOR_ALLPARAMETERS
+typedef struct _EAXAGCCOMPRESSORPROPERTIES
+{
+    unsigned long ulOnOff;   // Switch Compressor on or off
+} EAXAGCCOMPRESSORPROPERTIES, *LPEAXAGCCOMPRESSORPROPERTIES;
+
+// Property ranges and defaults:
+
+#define EAXAGCCOMPRESSOR_MINONOFF           0
+#define EAXAGCCOMPRESSOR_MAXONOFF           1
+#define EAXAGCCOMPRESSOR_DEFAULTONOFF       1
+
+////////////////////////////////////////////////////////////////////////////
+
+
+////////////////////////////////////////////////////////////////////////////
+// Autowah Effect
+
+// EAX AUTOWAH {EC3130C0-AC7A-11D2-88DD-A024D13CE1}
+DEFINE_GUID(EAX_AUTOWAH_EFFECT, 
+    0xec3130c0,
+    0xac7a,
+    0x11d2,
+    0x88, 0xdd, 0x0, 0xa0, 0x24, 0xd1, 0x3c, 0xe1);
+
+// Autowah properties
+typedef enum
+{
+    EAXAUTOWAH_NONE,
+    EAXAUTOWAH_ALLPARAMETERS,
+    EAXAUTOWAH_ATTACKTIME,
+    EAXAUTOWAH_RELEASETIME,
+    EAXAUTOWAH_RESONANCE,
+    EAXAUTOWAH_PEAKLEVEL
+} EAXAUTOWAH_PROPERTY;
+
+// OR these flags with property id
+#define EAXAUTOWAH_IMMEDIATE 0x00000000 // changes take effect immediately
+#define EAXAUTOWAH_DEFERRED  0x80000000 // changes take effect later
+#define EAXAUTOWAH_COMMITDEFERREDSETTINGS (EAXAUTOWAH_NONE | \
+                                           EAXAUTOWAH_IMMEDIATE)
+
+// Use this structure for EAXAUTOWAH_ALLPARAMETERS
+typedef struct _EAXAUTOWAHPROPERTIES
+{
+    float   flAttackTime;                // Attack time (seconds)
+    float   flReleaseTime;          // Release time (seconds)
+    long    lResonance;             // Resonance (mB)
+    long    lPeakLevel;             // Peak level (mB)
+} EAXAUTOWAHPROPERTIES, *LPEAXAUTOWAHPROPERTIES;
+
+// Property ranges and defaults:
+
+#define EAXAUTOWAH_MINATTACKTIME            0.0001f 
+#define EAXAUTOWAH_MAXATTACKTIME            1.0f
+#define EAXAUTOWAH_DEFAULTATTACKTIME        0.06f
+
+#define EAXAUTOWAH_MINRELEASETIME           0.0001f
+#define EAXAUTOWAH_MAXRELEASETIME           1.0f
+#define EAXAUTOWAH_DEFAULTRELEASETIME       0.06f
+
+#define EAXAUTOWAH_MINRESONANCE             600     
+#define EAXAUTOWAH_MAXRESONANCE             6000
+#define EAXAUTOWAH_DEFAULTRESONANCE         6000
+
+#define EAXAUTOWAH_MINPEAKLEVEL             (-9000)
+#define EAXAUTOWAH_MAXPEAKLEVEL             9000
+#define EAXAUTOWAH_DEFAULTPEAKLEVEL         2100
+
+////////////////////////////////////////////////////////////////////////////
+
+
+////////////////////////////////////////////////////////////////////////////
+// Chorus Effect
+
+// EAX CHORUS {DE6D6FE0-AC79-11D2-88DD-A024D13CE1}
+
+DEFINE_GUID(EAX_CHORUS_EFFECT,
+    0xde6d6fe0,
+    0xac79,
+    0x11d2,
+    0x88, 0xdd, 0x0, 0xa0, 0x24, 0xd1, 0x3c, 0xe1);
+
+
+// Chorus properties
+typedef enum
+{
+    EAXCHORUS_NONE,
+    EAXCHORUS_ALLPARAMETERS,
+    EAXCHORUS_WAVEFORM,
+    EAXCHORUS_PHASE,
+    EAXCHORUS_RATE,
+    EAXCHORUS_DEPTH,
+    EAXCHORUS_FEEDBACK,
+    EAXCHORUS_DELAY
+} EAXCHORUS_PROPERTY;
+
+// OR these flags with property id
+#define EAXCHORUS_IMMEDIATE 0x00000000 // changes take effect immediately
+#define EAXCHORUS_DEFERRED  0x80000000 // changes take effect later
+#define EAXCHORUS_COMMITDEFERREDSETTINGS (EAXCHORUS_NONE | \
+                                          EAXCHORUS_IMMEDIATE)
+
+// used by EAXCHORUS_WAVEFORM
+enum
+{
+    EAX_CHORUS_SINUSOID,
+    EAX_CHORUS_TRIANGLE
+};
+
+// Use this structure for EAXCHORUS_ALLPARAMETERS
+typedef struct _EAXCHORUSPROPERTIES
+{
+    unsigned long   ulWaveform;      // Waveform selector - see enum above
+    long            lPhase;         // Phase (Degrees)
+    float           flRate;         // Rate (Hz)
+    float           flDepth;        // Depth (0 to 1)
+    float           flFeedback;     // Feedback (-1 to 1)
+    float           flDelay;        // Delay (seconds)
+} EAXCHORUSPROPERTIES, *LPEAXCHORUSPROPERTIES;
+
+// Property ranges and defaults:
+
+#define EAXCHORUS_MINWAVEFORM               0
+#define EAXCHORUS_MAXWAVEFORM               1
+#define EAXCHORUS_DEFAULTWAVEFORM           1
+
+#define EAXCHORUS_MINPHASE              (-180)
+#define EAXCHORUS_MAXPHASE              180
+#define EAXCHORUS_DEFAULTPHASE          90
+
+#define EAXCHORUS_MINRATE               0.0f
+#define EAXCHORUS_MAXRATE               10.0f
+#define EAXCHORUS_DEFAULTRATE           1.1f
+
+#define EAXCHORUS_MINDEPTH              0.0f
+#define EAXCHORUS_MAXDEPTH              1.0f
+#define EAXCHORUS_DEFAULTDEPTH          0.1f
+
+#define EAXCHORUS_MINFEEDBACK           (-1.0f)
+#define EAXCHORUS_MAXFEEDBACK           1.0f
+#define EAXCHORUS_DEFAULTFEEDBACK       0.25f
+
+#define EAXCHORUS_MINDELAY              0.0f
+#define EAXCHORUS_MAXDELAY              0.016f
+#define EAXCHORUS_DEFAULTDELAY          0.016f
+
+////////////////////////////////////////////////////////////////////////////
+
+
+////////////////////////////////////////////////////////////////////////////
+// Distortion Effect
+
+// EAX DISTORTION {975A4CE0-AC7E-11D2-88DD-A024D13CE1}
+
+DEFINE_GUID(EAX_DISTORTION_EFFECT,
+    0x975a4ce0,
+    0xac7e,
+    0x11d2,
+    0x88, 0xdd, 0x0, 0xa0, 0x24, 0xd1, 0x3c, 0xe1);
+
+// Distortion properties
+typedef enum
+{
+    EAXDISTORTION_NONE,
+    EAXDISTORTION_ALLPARAMETERS,
+    EAXDISTORTION_EDGE,
+    EAXDISTORTION_GAIN,
+    EAXDISTORTION_LOWPASSCUTOFF,
+    EAXDISTORTION_EQCENTER,
+    EAXDISTORTION_EQBANDWIDTH
+} EAXDISTORTION_PROPERTY;
+
+// OR these flags with property id
+#define EAXDISTORTION_IMMEDIATE 0x00000000 // changes take effect immediately
+#define EAXDISTORTION_DEFERRED  0x80000000 // changes take effect later
+#define EAXDISTORTION_COMMITDEFERREDSETTINGS (EAXDISTORTION_NONE | \
+                                              EAXDISTORTION_IMMEDIATE)
+
+// Use this structure for EAXDISTORTION_ALLPARAMETERS
+typedef struct _EAXDISTORTIONPROPERTIES
+{
+    float   flEdge;             // Controls the shape of the distortion (0 to 1)
+    long    lGain;              // Controls the post distortion gain (mB)
+    float   flLowPassCutOff;    // Controls the cut-off of the filter pre-distortion (Hz)
+    float   flEQCenter;         // Controls the center frequency of the EQ post-distortion (Hz)
+    float   flEQBandwidth;      // Controls the bandwidth of the EQ post-distortion (Hz)
+} EAXDISTORTIONPROPERTIES, *LPEAXDISTORTIONPROPERTIES;
+
+// Property ranges and defaults:
+
+#define EAXDISTORTION_MINEDGE               0.0f
+#define EAXDISTORTION_MAXEDGE               1.0f
+#define EAXDISTORTION_DEFAULTEDGE           0.2f
+
+#define EAXDISTORTION_MINGAIN               (-6000)
+#define EAXDISTORTION_MAXGAIN               0
+#define EAXDISTORTION_DEFAULTGAIN           (-2600)
+
+#define EAXDISTORTION_MINLOWPASSCUTOFF      80.0f
+#define EAXDISTORTION_MAXLOWPASSCUTOFF      24000.0f
+#define EAXDISTORTION_DEFAULTLOWPASSCUTOFF  8000.0f
+
+#define EAXDISTORTION_MINEQCENTER           80.0f
+#define EAXDISTORTION_MAXEQCENTER           24000.0f
+#define EAXDISTORTION_DEFAULTEQCENTER       3600.0f
+
+#define EAXDISTORTION_MINEQBANDWIDTH        80.0f
+#define EAXDISTORTION_MAXEQBANDWIDTH        24000.0f
+#define EAXDISTORTION_DEFAULTEQBANDWIDTH    3600.0f
+
+////////////////////////////////////////////////////////////////////////////
+
+
+////////////////////////////////////////////////////////////////////////////
+// Echo Effect
+
+// EAX ECHO {E9F1BC0-AC82-11D2-88DD-A024D13CE1}
+
+DEFINE_GUID(EAX_ECHO_EFFECT,
+    0xe9f1bc0,
+    0xac82,
+    0x11d2,
+    0x88, 0xdd, 0x0, 0xa0, 0x24, 0xd1, 0x3c, 0xe1);
+
+// Echo properties
+typedef enum
+{
+    EAXECHO_NONE,
+    EAXECHO_ALLPARAMETERS,
+    EAXECHO_DELAY,
+    EAXECHO_LRDELAY,
+    EAXECHO_DAMPING,
+    EAXECHO_FEEDBACK,
+    EAXECHO_SPREAD
+} EAXECHO_PROPERTY;
+
+// OR these flags with property id
+#define EAXECHO_IMMEDIATE 0x00000000 // changes take effect immediately
+#define EAXECHO_DEFERRED  0x80000000 // changes take effect later
+#define EAXECHO_COMMITDEFERREDSETTINGS (EAXECHO_NONE | \
+                                        EAXECHO_IMMEDIATE)
+
+// Use this structure for EAXECHO_ALLPARAMETERS
+typedef struct _EAXECHOPROPERTIES
+{
+    float   flDelay;            // Controls the initial delay time (seconds)
+    float   flLRDelay;          // Controls the delay time between the first and second taps (seconds)
+    float   flDamping;          // Controls a low-pass filter that dampens the echoes (0 to 1)
+    float   flFeedback;         // Controls the duration of echo repetition (0 to 1)
+    float   flSpread;           // Controls the left-right spread of the echoes
+} EAXECHOPROPERTIES, *LPEAXECHOPROPERTIES;
+
+// Property ranges and defaults:
+                    
+#define EAXECHO_MINDAMPING          0.0f
+#define EAXECHO_MAXDAMPING          0.99f
+#define EAXECHO_DEFAULTDAMPING      0.5f
+
+#define EAXECHO_MINDELAY            0.0f
+#define EAXECHO_MAXDELAY            0.207f
+#define EAXECHO_DEFAULTDELAY        0.1f
+
+#define EAXECHO_MINLRDELAY          0.0f
+#define EAXECHO_MAXLRDELAY          0.404f
+#define EAXECHO_DEFAULTLRDELAY      0.1f
+
+#define EAXECHO_MINFEEDBACK         0.0f
+#define EAXECHO_MAXFEEDBACK         1.0f
+#define EAXECHO_DEFAULTFEEDBACK     0.5f
+
+#define EAXECHO_MINSPREAD           (-1.0f)
+#define EAXECHO_MAXSPREAD             1.0f
+#define EAXECHO_DEFAULTSPREAD       (-1.0f)
+
+////////////////////////////////////////////////////////////////////////////
+
+
+////////////////////////////////////////////////////////////////////////////
+// Equalizer Effect
+
+// EAX EQUALIZER {65F94CE0-9793-11D3-939D-C0F02DD6F0}
+
+DEFINE_GUID(EAX_EQUALIZER_EFFECT,
+    0x65f94ce0,
+    0x9793,
+    0x11d3,
+    0x93, 0x9d, 0x0, 0xc0, 0xf0, 0x2d, 0xd6, 0xf0);
+
+
+// Equalizer properties
+typedef enum
+{
+    EAXEQUALIZER_NONE,
+    EAXEQUALIZER_ALLPARAMETERS,
+    EAXEQUALIZER_LOWGAIN,
+    EAXEQUALIZER_LOWCUTOFF,
+    EAXEQUALIZER_MID1GAIN,
+    EAXEQUALIZER_MID1CENTER,
+    EAXEQUALIZER_MID1WIDTH,
+    EAXEQUALIZER_MID2GAIN,
+    EAXEQUALIZER_MID2CENTER,
+    EAXEQUALIZER_MID2WIDTH,
+    EAXEQUALIZER_HIGHGAIN,
+    EAXEQUALIZER_HIGHCUTOFF
+} EAXEQUALIZER_PROPERTY;
+
+// OR these flags with property id
+#define EAXEQUALIZER_IMMEDIATE 0x00000000 // changes take effect immediately
+#define EAXEQUALIZER_DEFERRED  0x80000000 // changes take effect later
+#define EAXEQUALIZER_COMMITDEFERREDSETTINGS (EAXEQUALIZER_NONE | \
+                                             EAXEQUALIZER_IMMEDIATE)
+
+// Use this structure for EAXEQUALIZER_ALLPARAMETERS
+typedef struct _EAXEQUALIZERPROPERTIES
+{
+    long    lLowGain;           // (mB)
+    float   flLowCutOff;        // (Hz)
+    long    lMid1Gain;          // (mB)
+    float   flMid1Center;       // (Hz)
+    float   flMid1Width;        // (octaves)
+    long    lMid2Gain;          // (mB)
+    float   flMid2Center;       // (Hz)
+    float   flMid2Width;        // (octaves)
+    long    lHighGain;          // (mB)
+    float   flHighCutOff;       // (Hz)
+} EAXEQUALIZERPROPERTIES, *LPEAXEQUALIZERPROPERTIES;
+
+// Property ranges and defaults:
+
+#define EAXEQUALIZER_MINLOWGAIN         (-1800)
+#define EAXEQUALIZER_MAXLOWGAIN         1800
+#define EAXEQUALIZER_DEFAULTLOWGAIN     0
+
+#define EAXEQUALIZER_MINLOWCUTOFF       50.0f
+#define EAXEQUALIZER_MAXLOWCUTOFF       800.0f
+#define EAXEQUALIZER_DEFAULTLOWCUTOFF   200.0f
+
+#define EAXEQUALIZER_MINMID1GAIN        (-1800)
+#define EAXEQUALIZER_MAXMID1GAIN        1800
+#define EAXEQUALIZER_DEFAULTMID1GAIN    0
+
+#define EAXEQUALIZER_MINMID1CENTER      200.0f
+#define EAXEQUALIZER_MAXMID1CENTER      3000.0f
+#define EAXEQUALIZER_DEFAULTMID1CENTER  500.0f
+
+#define EAXEQUALIZER_MINMID1WIDTH       0.01f
+#define EAXEQUALIZER_MAXMID1WIDTH       1.0f
+#define EAXEQUALIZER_DEFAULTMID1WIDTH   1.0f
+
+#define EAXEQUALIZER_MINMID2GAIN        (-1800)
+#define EAXEQUALIZER_MAXMID2GAIN        1800
+#define EAXEQUALIZER_DEFAULTMID2GAIN    0
+
+#define EAXEQUALIZER_MINMID2CENTER      1000.0f
+#define EAXEQUALIZER_MAXMID2CENTER      8000.0f
+#define EAXEQUALIZER_DEFAULTMID2CENTER  3000.0f
+
+#define EAXEQUALIZER_MINMID2WIDTH       0.01f
+#define EAXEQUALIZER_MAXMID2WIDTH       1.0f
+#define EAXEQUALIZER_DEFAULTMID2WIDTH   1.0f
+
+#define EAXEQUALIZER_MINHIGHGAIN        (-1800)
+#define EAXEQUALIZER_MAXHIGHGAIN        1800
+#define EAXEQUALIZER_DEFAULTHIGHGAIN    0
+
+#define EAXEQUALIZER_MINHIGHCUTOFF      4000.0f
+#define EAXEQUALIZER_MAXHIGHCUTOFF      16000.0f
+#define EAXEQUALIZER_DEFAULTHIGHCUTOFF  6000.0f
+
+////////////////////////////////////////////////////////////////////////////
+
+
+////////////////////////////////////////////////////////////////////////////
+// Flanger Effect
+
+// EAX FLANGER {A70007C0-7D2-11D3-9B1E-A024D13CE1}
+
+DEFINE_GUID(EAX_FLANGER_EFFECT,
+    0xa70007c0,
+    0x7d2,
+    0x11d3,
+    0x9b, 0x1e, 0x0, 0xa0, 0x24, 0xd1, 0x3c, 0xe1);
+
+// Flanger properties
+typedef enum
+{
+    EAXFLANGER_NONE,
+    EAXFLANGER_ALLPARAMETERS,
+    EAXFLANGER_WAVEFORM,
+    EAXFLANGER_PHASE,
+    EAXFLANGER_RATE,
+    EAXFLANGER_DEPTH,
+    EAXFLANGER_FEEDBACK,
+    EAXFLANGER_DELAY
+} EAXFLANGER_PROPERTY;
+
+// OR these flags with property id
+#define EAXFLANGER_IMMEDIATE 0x00000000 // changes take effect immediately
+#define EAXFLANGER_DEFERRED  0x80000000 // changes take effect later
+#define EAXFLANGER_COMMITDEFERREDSETTINGS (EAXFLANGER_NONE | \
+                                           EAXFLANGER_IMMEDIATE)
+
+// used by EAXFLANGER_WAVEFORM
+enum
+{
+    EAX_FLANGER_SINUSOID,
+    EAX_FLANGER_TRIANGLE
+};
+
+// Use this structure for EAXFLANGER_ALLPARAMETERS
+typedef struct _EAXFLANGERPROPERTIES
+{
+    unsigned long   ulWaveform;  // Waveform selector - see enum above
+    long            lPhase;     // Phase (Degrees)
+    float           flRate;     // Rate (Hz)
+    float           flDepth;    // Depth (0 to 1)
+    float           flFeedback; // Feedback (0 to 1)
+    float           flDelay;    // Delay (seconds)
+} EAXFLANGERPROPERTIES, *LPEAXFLANGERPROPERTIES;
+
+// Property ranges and defaults:
+
+#define EAXFLANGER_MINWAVEFORM              0
+#define EAXFLANGER_MAXWAVEFORM              1
+#define EAXFLANGER_DEFAULTWAVEFORM          1
+
+#define EAXFLANGER_MINPHASE             (-180)
+#define EAXFLANGER_MAXPHASE             180
+#define EAXFLANGER_DEFAULTPHASE         0
+
+#define EAXFLANGER_MINRATE              0.0f
+#define EAXFLANGER_MAXRATE              10.0f
+#define EAXFLANGER_DEFAULTRATE          0.27f
+
+#define EAXFLANGER_MINDEPTH             0.0f
+#define EAXFLANGER_MAXDEPTH             1.0f
+#define EAXFLANGER_DEFAULTDEPTH         1.0f
+
+#define EAXFLANGER_MINFEEDBACK          (-1.0f)
+#define EAXFLANGER_MAXFEEDBACK          1.0f
+#define EAXFLANGER_DEFAULTFEEDBACK      (-0.5f)
+
+#define EAXFLANGER_MINDELAY             0.0f
+#define EAXFLANGER_MAXDELAY             0.004f
+#define EAXFLANGER_DEFAULTDELAY         0.002f
+
+////////////////////////////////////////////////////////////////////////////
+
+
+////////////////////////////////////////////////////////////////////////////
+// Frequency Shifter Effect
+
+// EAX FREQUENCY SHIFTER {DC3E1880-9212-11D3-939D-C0F02DD6F0}
+
+DEFINE_GUID(EAX_FREQUENCYSHIFTER_EFFECT,
+    0xdc3e1880,
+    0x9212,
+    0x11d3,
+    0x93, 0x9d, 0x0, 0xc0, 0xf0, 0x2d, 0xd6, 0xf0);
+
+// Frequency Shifter properties
+typedef enum
+{
+    EAXFREQUENCYSHIFTER_NONE,
+    EAXFREQUENCYSHIFTER_ALLPARAMETERS,
+    EAXFREQUENCYSHIFTER_FREQUENCY,
+    EAXFREQUENCYSHIFTER_LEFTDIRECTION,
+    EAXFREQUENCYSHIFTER_RIGHTDIRECTION
+} EAXFREQUENCYSHIFTER_PROPERTY;
+
+// OR these flags with property id
+#define EAXFREQUENCYSHIFTER_IMMEDIATE 0x00000000 // changes take effect immediately
+#define EAXFREQUENCYSHIFTER_DEFERRED  0x80000000 // changes take effect later
+#define EAXFREQUENCYSHIFTER_COMMITDEFERREDSETTINGS (EAXFREQUENCYSHIFTER_NONE | \
+                                                    EAXFREQUENCYSHIFTER_IMMEDIATE)
+
+// used by EAXFREQUENCYSHIFTER_LEFTDIRECTION and EAXFREQUENCYSHIFTER_RIGHTDIRECTION 
+enum
+{
+    EAX_FREQUENCYSHIFTER_DOWN,
+    EAX_FREQUENCYSHIFTER_UP,
+    EAX_FREQUENCYSHIFTER_OFF
+};
+
+// Use this structure for EAXFREQUENCYSHIFTER_ALLPARAMETERS
+typedef struct _EAXFREQUENCYSHIFTERPROPERTIES
+{
+    float           flFrequency;        // (Hz)
+    unsigned long   ulLeftDirection;     // see enum above
+    unsigned long   ulRightDirection;    // see enum above
+} EAXFREQUENCYSHIFTERPROPERTIES, *LPEAXFREQUENCYSHIFTERPROPERTIES;
+
+// Property ranges and defaults:
+
+#define EAXFREQUENCYSHIFTER_MINFREQUENCY            0.0f
+#define EAXFREQUENCYSHIFTER_MAXFREQUENCY            24000.0f
+#define EAXFREQUENCYSHIFTER_DEFAULTFREQUENCY        0.0f
+
+#define EAXFREQUENCYSHIFTER_MINLEFTDIRECTION        0
+#define EAXFREQUENCYSHIFTER_MAXLEFTDIRECTION        2
+#define EAXFREQUENCYSHIFTER_DEFAULTLEFTDIRECTION    0
+
+#define EAXFREQUENCYSHIFTER_MINRIGHTDIRECTION       0
+#define EAXFREQUENCYSHIFTER_MAXRIGHTDIRECTION       2
+#define EAXFREQUENCYSHIFTER_DEFAULTRIGHTDIRECTION   0
+
+////////////////////////////////////////////////////////////////////////////
+
+
+////////////////////////////////////////////////////////////////////////////
+// Vocal Morpher Effect
+
+// EAX VOCAL MORPHER {E41CF10C-3383-11D2-88DD-A024D13CE1}
+
+DEFINE_GUID(EAX_VOCALMORPHER_EFFECT, 
+    0xe41cf10c,
+    0x3383,
+    0x11d2,
+    0x88, 0xdd, 0x0, 0xa0, 0x24, 0xd1, 0x3c, 0xe1);
+
+// Vocal Morpher properties
+typedef enum
+{
+    EAXVOCALMORPHER_NONE,
+    EAXVOCALMORPHER_ALLPARAMETERS,
+    EAXVOCALMORPHER_PHONEMEA,
+    EAXVOCALMORPHER_PHONEMEACOARSETUNING,
+    EAXVOCALMORPHER_PHONEMEB,
+    EAXVOCALMORPHER_PHONEMEBCOARSETUNING,
+    EAXVOCALMORPHER_WAVEFORM,
+    EAXVOCALMORPHER_RATE
+} EAXVOCALMORPHER_PROPERTY;
+
+// OR these flags with property id
+#define EAXVOCALMORPHER_IMMEDIATE 0x00000000 // changes take effect immediately
+#define EAXVOCALMORPHER_DEFERRED  0x80000000 // changes take effect later
+#define EAXVOCALMORPHER_COMMITDEFERREDSETTINGS (EAXVOCALMORPHER_NONE | \
+                                                EAXVOCALMORPHER_IMMEDIATE)
+
+// used by EAXVOCALMORPHER_PHONEMEA and EAXVOCALMORPHER_PHONEMEB
+enum
+{
+    A, E, I, O, U, AA, AE, AH, AO, EH, ER, IH, IY, UH, UW, B, D, F, G,
+    J, K, L, M, N, P, R, S, T, V, Z
+};
+
+// used by EAXVOCALMORPHER_WAVEFORM
+enum
+{
+    EAX_VOCALMORPHER_SINUSOID,
+    EAX_VOCALMORPHER_TRIANGLE,
+    EAX_VOCALMORPHER_SAWTOOTH
+};
+
+// Use this structure for EAXVOCALMORPHER_ALLPARAMETERS
+typedef struct _EAXVOCALMORPHERPROPERTIES
+{
+    unsigned long   ulPhonemeA;              // see enum above
+    long            lPhonemeACoarseTuning;  // (semitones)
+    unsigned long   ulPhonemeB;              // see enum above
+    long            lPhonemeBCoarseTuning;  // (semitones)
+    unsigned long   ulWaveform;              // Waveform selector - see enum above
+    float           flRate;                 // (Hz)
+} EAXVOCALMORPHERPROPERTIES, *LPEAXVOCALMORPHERPROPERTIES;
+
+// Property ranges and defaults:
+
+#define EAXVOCALMORPHER_MINPHONEMEA                 0
+#define EAXVOCALMORPHER_MAXPHONEMEA                 29
+#define EAXVOCALMORPHER_DEFAULTPHONEMEA             0
+
+#define EAXVOCALMORPHER_MINPHONEMEACOARSETUNING     (-24)
+#define EAXVOCALMORPHER_MAXPHONEMEACOARSETUNING     24
+#define EAXVOCALMORPHER_DEFAULTPHONEMEACOARSETUNING 0
+
+#define EAXVOCALMORPHER_MINPHONEMEB                 0
+#define EAXVOCALMORPHER_MAXPHONEMEB                 29
+#define EAXVOCALMORPHER_DEFAULTPHONEMEB             10
+
+#define EAXVOCALMORPHER_MINPHONEMEBCOARSETUNING     (-24)
+#define EAXVOCALMORPHER_MAXPHONEMEBCOARSETUNING     24
+#define EAXVOCALMORPHER_DEFAULTPHONEMEBCOARSETUNING 0
+
+#define EAXVOCALMORPHER_MINWAVEFORM                 0
+#define EAXVOCALMORPHER_MAXWAVEFORM                 2
+#define EAXVOCALMORPHER_DEFAULTWAVEFORM             0
+
+#define EAXVOCALMORPHER_MINRATE                     0.0f
+#define EAXVOCALMORPHER_MAXRATE                     10.0f
+#define EAXVOCALMORPHER_DEFAULTRATE                 1.41f
+
+////////////////////////////////////////////////////////////////////////////
+
+
+////////////////////////////////////////////////////////////////////////////
+// Pitch Shifter Effect
+
+// EAX PITCH SHIFTER {E7905100-AFB2-11D2-88DD-A024D13CE1}
+
+DEFINE_GUID(EAX_PITCHSHIFTER_EFFECT,
+    0xe7905100,
+    0xafb2,
+    0x11d2,
+    0x88, 0xdd, 0x0, 0xa0, 0x24, 0xd1, 0x3c, 0xe1);
+
+// Pitch Shifter properties
+typedef enum
+{
+    EAXPITCHSHIFTER_NONE,
+    EAXPITCHSHIFTER_ALLPARAMETERS,
+    EAXPITCHSHIFTER_COARSETUNE,
+    EAXPITCHSHIFTER_FINETUNE
+} EAXPITCHSHIFTER_PROPERTY;
+
+// OR these flags with property id
+#define EAXPITCHSHIFTER_IMMEDIATE 0x00000000 // changes take effect immediately
+#define EAXPITCHSHIFTER_DEFERRED  0x80000000 // changes take effect later
+#define EAXPITCHSHIFTER_COMMITDEFERREDSETTINGS (EAXPITCHSHIFTER_NONE | \
+                                                EAXPITCHSHIFTER_IMMEDIATE)
+
+// Use this structure for EAXPITCHSHIFTER_ALLPARAMETERS
+typedef struct _EAXPITCHSHIFTERPROPERTIES
+{
+    long    lCoarseTune;    // Amount of pitch shift (semitones)
+    long    lFineTune;      // Amount of pitch shift (cents)
+} EAXPITCHSHIFTERPROPERTIES, *LPEAXPITCHSHIFTERPROPERTIES;
+
+// Property ranges and defaults:
+
+#define EAXPITCHSHIFTER_MINCOARSETUNE       (-12)
+#define EAXPITCHSHIFTER_MAXCOARSETUNE       12
+#define EAXPITCHSHIFTER_DEFAULTCOARSETUNE   12
+
+#define EAXPITCHSHIFTER_MINFINETUNE         (-50)
+#define EAXPITCHSHIFTER_MAXFINETUNE         50
+#define EAXPITCHSHIFTER_DEFAULTFINETUNE     0
+
+////////////////////////////////////////////////////////////////////////////
+
+
+////////////////////////////////////////////////////////////////////////////
+// Ring Modulator Effect
+
+// EAX RING MODULATOR {B89FE60-AFB5-11D2-88DD-A024D13CE1}
+
+DEFINE_GUID(EAX_RINGMODULATOR_EFFECT,
+    0xb89fe60,
+    0xafb5,
+    0x11d2,
+    0x88, 0xdd, 0x0, 0xa0, 0x24, 0xd1, 0x3c, 0xe1);
+
+// Ring Modulator properties
+typedef enum
+{
+    EAXRINGMODULATOR_NONE,
+    EAXRINGMODULATOR_ALLPARAMETERS,
+    EAXRINGMODULATOR_FREQUENCY,
+    EAXRINGMODULATOR_HIGHPASSCUTOFF,
+    EAXRINGMODULATOR_WAVEFORM
+} EAXRINGMODULATOR_PROPERTY;
+
+// OR these flags with property id
+#define EAXRINGMODULATOR_IMMEDIATE 0x00000000 // changes take effect immediately
+#define EAXRINGMODULATOR_DEFERRED  0x80000000 // changes take effect later
+#define EAXRINGMODULATOR_COMMITDEFERREDSETTINGS (EAXRINGMODULATOR_NONE | \
+                                                 EAXRINGMODULATOR_IMMEDIATE)
+
+// used by EAXRINGMODULATOR_WAVEFORM
+enum
+{
+    EAX_RINGMODULATOR_SINUSOID,
+    EAX_RINGMODULATOR_SAWTOOTH,
+    EAX_RINGMODULATOR_SQUARE
+};
+
+// Use this structure for EAXRINGMODULATOR_ALLPARAMETERS
+typedef struct _EAXRINGMODULATORPROPERTIES
+{
+    float           flFrequency;        // Frequency of modulation (Hz)
+    float           flHighPassCutOff;   // Cut-off frequency of high-pass filter (Hz)
+    unsigned long   ulWaveform;          // Waveform selector - see enum above
+} EAXRINGMODULATORPROPERTIES, *LPEAXRINGMODULATORPROPERTIES;
+
+// Property ranges and defaults:
+
+#define EAXRINGMODULATOR_MINFREQUENCY           0.0f
+#define EAXRINGMODULATOR_MAXFREQUENCY           8000.0f
+#define EAXRINGMODULATOR_DEFAULTFREQUENCY       440.0f
+
+#define EAXRINGMODULATOR_MINHIGHPASSCUTOFF      0.0f
+#define EAXRINGMODULATOR_MAXHIGHPASSCUTOFF      24000.0f
+#define EAXRINGMODULATOR_DEFAULTHIGHPASSCUTOFF  800.0f
+
+#define EAXRINGMODULATOR_MINWAVEFORM            0
+#define EAXRINGMODULATOR_MAXWAVEFORM            2
+#define EAXRINGMODULATOR_DEFAULTWAVEFORM        0
+
+////////////////////////////////////////////////////////////////////////////
+
+#pragma pack(pop)
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+
+#endif
diff --git a/codemp/client/eax/vssver.scc b/codemp/client/eax/vssver.scc
new file mode 100644
index 0000000..980e029
Binary files /dev/null and b/codemp/client/eax/vssver.scc differ
diff --git a/codemp/client/fffx.h b/codemp/client/fffx.h
new file mode 100644
index 0000000..c6958b9
--- /dev/null
+++ b/codemp/client/fffx.h
@@ -0,0 +1,129 @@
+// Filename:-	fffx.h		(Force Feedback FX)
+
+#ifndef FFFX_H
+#define FFFX_H
+
+// this part can be seen by the CGAME as well...
+
+// These enums match the generic ones built into the effects ROM in the MS SideWinder FF Joystick, 
+//	so blame MS for anything you don't like (like that aircraft carrier one - jeez!)...
+//
+// (Judging from the names of most of these, the MS FF guys appear to be rather fond of ID-type games...)
+//
+typedef enum 
+	{
+	fffx_RandomNoise=0,
+	fffx_AircraftCarrierTakeOff,	// this one is pointless / dumb
+	fffx_BasketballDribble,
+	fffx_CarEngineIdle,
+	fffx_ChainsawIdle,
+	fffx_ChainsawInAction,
+	fffx_DieselEngineIdle,
+	fffx_Jump,
+	fffx_Land,
+	fffx_MachineGun,
+	fffx_Punched,
+	fffx_RocketLaunch,
+	fffx_SecretDoor,
+	fffx_SwitchClick,
+	fffx_WindGust,
+	fffx_WindShear,		// also pretty crap
+	fffx_Pistol,
+	fffx_Shotgun,
+	fffx_Laser1,
+	fffx_Laser2,
+	fffx_Laser3,
+	fffx_Laser4,
+	fffx_Laser5,
+	fffx_Laser6,
+	fffx_OutOfAmmo,
+	fffx_LightningGun,
+	fffx_Missile,
+	fffx_GatlingGun,
+	fffx_ShortPlasma,
+	fffx_PlasmaCannon1,
+	fffx_PlasmaCannon2,
+	fffx_Cannon,
+#ifdef _XBOX
+	fffx_FallingShort,
+	fffx_FallingMedium,
+	fffx_FallingFar,
+	fffx_StartConst,
+	fffx_StopConst,
+#endif
+	//
+	fffx_NUMBEROF,
+	fffx_NULL		// special use, ignore during array mallocs etc, use fffx_NUMBEROF instead
+	} ffFX_e;
+
+
+#ifndef CGAME_ONLY
+
+/////////////////////////// START of functions to call /////////////////////////////////
+//
+//
+//
+// Once the game is running you should *only* access FF functions through these 4 macros. Savvy?
+//
+// Usage note: In practice, you can have about 4 FF FX running concurrently, though I defy anyone to make sense
+//	of that amount of white-noise vibration. MS guidelines say you shouldn't leave vibration on for long periods
+//	of time (eg engine rumble) because of various nerve-damage/lawsuit issues, so for this reason there is no API
+//	support for setting durations etc. All FF FX stuff here is designed for things like firing, hit damage, driving
+//	over bumps, etc that can be played as one-off events, though you *can* do things like FFFX_ENSURE(fffx_ChainsawIdle)
+//	if you really want to.
+//
+// Combining small numbers of effects such as having a laser firing (MS photons have higher mass apparently <g>), 
+//	and then firing a machine gun in bursts as well are no problem, and easily felt, hence the ability to stop playing
+//	individual FF FX.
+//
+#define FFFX_START(f)	FF_Play(f)
+#define FFFX_ENSURE(f)	FF_EnsurePlaying(f)
+#define FFFX_STOP(f)	FF_Stop(f)			// some effects (eg. gatling, chainsaw), need this, or they play too long after trigger-off.
+#define FFFX_STOPALL	FF_StopAll()
+
+
+//
+// These 2 are called at app start/stop, but you can call FF_Init to change FF devices anytime (takes a couple of seconds)
+//
+void		FF_Init(qboolean bTryMouseFirst=true);
+void		FF_Shutdown(void);
+//
+// other stuff you may want to call but don't have to...
+//
+qboolean	FF_IsAvailable(void);	
+qboolean	FF_IsMouse(void);		
+qboolean	FF_SetTension(int iTension);	// tension setting 0..3 (0=none)
+qboolean	FF_SetSpring(long lSpring);		// precision version of above, 0..n..10000
+											// (only provided for command line fiddling with 
+											//	weird hardware. FF_SetTension(1) = default
+											// = FF_SetSpring(2000) (internal lookup table))
+
+//
+//
+//
+/////////////////////////// END of functions to call /////////////////////////////////
+
+
+
+
+// do *not* call this functions directly (or else!), use the macros above
+//
+void FF_Play			(ffFX_e fffx);
+void FF_EnsurePlaying	(ffFX_e fffx);
+void FF_Stop			(ffFX_e fffx);
+void FF_StopAll			(void);
+
+#ifdef _XBOX
+void FF_XboxShake		(float intensity, int duration);
+void FF_XboxDamage		(int damage, float xpos);
+#endif
+
+#define MAX_CONCURRENT_FFFXs 4	// only for my code to use/read, do NOT alter!
+
+
+
+#endif	// #ifndef CGAME_ONLY
+#endif	// #ifndef FFFX_H
+
+//////////////////////// eof //////////////////////
+
diff --git a/codemp/client/keycodes.h b/codemp/client/keycodes.h
new file mode 100644
index 0000000..8d0f171
--- /dev/null
+++ b/codemp/client/keycodes.h
@@ -0,0 +1,347 @@
+#ifndef __KEYCODES_H__
+#define __KEYCODES_H__
+
+// these are the key numbers that should be passed to KeyEvent
+
+typedef enum
+{
+	A_NULL = 0,
+	A_SHIFT,
+	A_CTRL,
+	A_ALT,
+	A_CAPSLOCK,
+	A_NUMLOCK,
+	A_SCROLLLOCK,
+	A_PAUSE,
+	A_BACKSPACE,
+	A_TAB,
+	A_ENTER,
+	A_KP_PLUS,
+	A_KP_MINUS,
+	A_KP_ENTER,
+	A_KP_PERIOD,
+	A_PRINTSCREEN,
+	A_KP_0,
+	A_KP_1,
+	A_KP_2,
+	A_KP_3,
+	A_KP_4,
+	A_KP_5,
+	A_KP_6,
+	A_KP_7,
+	A_KP_8,
+	A_KP_9,
+	A_CONSOLE,
+	A_ESCAPE,
+	A_F1,
+	A_F2,
+	A_F3,
+	A_F4,
+
+	A_SPACE,
+	A_PLING,
+	A_DOUBLE_QUOTE,
+	A_HASH,
+	A_STRING,
+	A_PERCENT,
+	A_AND,
+	A_SINGLE_QUOTE,
+	A_OPEN_BRACKET,
+	A_CLOSE_BRACKET,
+	A_STAR,
+	A_PLUS,
+	A_COMMA,
+	A_MINUS,
+	A_PERIOD,
+	A_FORWARD_SLASH,
+	A_0,
+	A_1,
+	A_2,
+	A_3,
+	A_4,
+	A_5,
+	A_6,
+	A_7,
+	A_8,
+	A_9,
+	A_COLON,
+	A_SEMICOLON,
+	A_LESSTHAN,
+	A_EQUALS,
+	A_GREATERTHAN,
+	A_QUESTION,
+
+	A_AT,
+	A_CAP_A,
+	A_CAP_B,
+	A_CAP_C,
+	A_CAP_D,
+	A_CAP_E,
+	A_CAP_F,
+	A_CAP_G,
+	A_CAP_H,
+	A_CAP_I,
+	A_CAP_J,
+	A_CAP_K,
+	A_CAP_L,
+	A_CAP_M,
+	A_CAP_N,
+	A_CAP_O,
+	A_CAP_P,
+	A_CAP_Q,
+	A_CAP_R,
+	A_CAP_S,
+	A_CAP_T,
+	A_CAP_U,
+	A_CAP_V,
+	A_CAP_W,
+	A_CAP_X,
+	A_CAP_Y,
+	A_CAP_Z,
+	A_OPEN_SQUARE,
+	A_BACKSLASH,
+	A_CLOSE_SQUARE,
+	A_CARET,
+	A_UNDERSCORE,
+
+	A_LEFT_SINGLE_QUOTE,
+	A_LOW_A,
+	A_LOW_B,
+	A_LOW_C,
+	A_LOW_D,
+	A_LOW_E,
+	A_LOW_F,
+	A_LOW_G,
+	A_LOW_H,
+	A_LOW_I,
+	A_LOW_J,
+	A_LOW_K,
+	A_LOW_L,
+	A_LOW_M,
+	A_LOW_N,
+	A_LOW_O,
+	A_LOW_P,
+	A_LOW_Q,
+	A_LOW_R,
+	A_LOW_S,
+	A_LOW_T,
+	A_LOW_U,
+	A_LOW_V,
+	A_LOW_W,
+	A_LOW_X,
+	A_LOW_Y,
+	A_LOW_Z,
+	A_OPEN_BRACE,
+	A_BAR,
+	A_CLOSE_BRACE,
+	A_TILDE,
+	A_DELETE,
+
+	A_EURO,
+	A_SHIFT2,
+	A_CTRL2,
+	A_ALT2,
+	A_F5,
+	A_F6,
+	A_F7,
+	A_F8,
+	A_CIRCUMFLEX,
+	A_MWHEELUP,
+	A_CAP_SCARON,
+	A_MWHEELDOWN,
+	A_CAP_OE,
+	A_MOUSE1,
+	A_MOUSE2,
+	A_INSERT,
+	A_HOME,
+	A_PAGE_UP,
+	A_RIGHT_SINGLE_QUOTE,
+	A_LEFT_DOUBLE_QUOTE,
+	A_RIGHT_DOUBLE_QUOTE,
+	A_F9,
+	A_F10,
+	A_F11,
+	A_F12,
+	A_TRADEMARK,
+	A_LOW_SCARON,
+	A_SHIFT_ENTER,
+	A_LOW_OE,
+	A_END,
+	A_PAGE_DOWN,
+	A_CAP_YDIERESIS,
+
+	A_SHIFT_SPACE,
+	A_EXCLAMDOWN,
+	A_CENT,
+	A_POUND,
+	A_SHIFT_KP_ENTER,
+	A_YEN,
+	A_MOUSE3,
+	A_MOUSE4,
+	A_MOUSE5,
+	A_COPYRIGHT,
+	A_CURSOR_UP,
+	A_CURSOR_DOWN,
+	A_CURSOR_LEFT,
+	A_CURSOR_RIGHT,
+	A_REGISTERED,
+	A_UNDEFINED_7,
+	A_UNDEFINED_8,
+	A_UNDEFINED_9,
+	A_UNDEFINED_10,
+	A_UNDEFINED_11,
+	A_UNDEFINED_12,
+	A_UNDEFINED_13,
+	A_UNDEFINED_14,
+	A_UNDEFINED_15,
+	A_UNDEFINED_16,
+	A_UNDEFINED_17,
+	A_UNDEFINED_18,
+	A_UNDEFINED_19,
+	A_UNDEFINED_20,
+	A_UNDEFINED_21,
+	A_UNDEFINED_22,
+	A_QUESTION_DOWN,
+
+	A_CAP_AGRAVE,
+	A_CAP_AACUTE,
+	A_CAP_ACIRCUMFLEX,
+	A_CAP_ATILDE,
+	A_CAP_ADIERESIS,
+	A_CAP_ARING,
+	A_CAP_AE,
+	A_CAP_CCEDILLA,
+	A_CAP_EGRAVE,
+	A_CAP_EACUTE,
+	A_CAP_ECIRCUMFLEX,
+	A_CAP_EDIERESIS,
+	A_CAP_IGRAVE,
+	A_CAP_IACUTE,
+	A_CAP_ICIRCUMFLEX,
+	A_CAP_IDIERESIS,
+	A_CAP_ETH,
+	A_CAP_NTILDE,
+	A_CAP_OGRAVE,
+	A_CAP_OACUTE,
+	A_CAP_OCIRCUMFLEX,
+	A_CAP_OTILDE,
+	A_CAP_ODIERESIS,
+	A_MULTIPLY,
+	A_CAP_OSLASH,
+	A_CAP_UGRAVE,
+	A_CAP_UACUTE,
+	A_CAP_UCIRCUMFLEX,
+	A_CAP_UDIERESIS,
+	A_CAP_YACUTE,
+	A_CAP_THORN,
+	A_GERMANDBLS,
+
+	A_LOW_AGRAVE,
+	A_LOW_AACUTE,
+	A_LOW_ACIRCUMFLEX,
+	A_LOW_ATILDE,
+	A_LOW_ADIERESIS,
+	A_LOW_ARING,
+	A_LOW_AE,
+	A_LOW_CCEDILLA,
+	A_LOW_EGRAVE,
+	A_LOW_EACUTE,
+	A_LOW_ECIRCUMFLEX,
+	A_LOW_EDIERESIS,
+	A_LOW_IGRAVE,
+	A_LOW_IACUTE,
+	A_LOW_ICIRCUMFLEX,
+	A_LOW_IDIERESIS,
+	A_LOW_ETH,
+	A_LOW_NTILDE,
+	A_LOW_OGRAVE,
+	A_LOW_OACUTE,
+	A_LOW_OCIRCUMFLEX,
+	A_LOW_OTILDE,
+	A_LOW_ODIERESIS,
+	A_DIVIDE,
+	A_LOW_OSLASH,
+	A_LOW_UGRAVE,
+	A_LOW_UACUTE,
+	A_LOW_UCIRCUMFLEX,
+	A_LOW_UDIERESIS,
+	A_LOW_YACUTE,
+	A_LOW_THORN,
+	A_LOW_YDIERESIS,
+	
+	A_JOY0,
+	A_JOY1,
+	A_JOY2,
+	A_JOY3,
+	A_JOY4,
+	A_JOY5,
+	A_JOY6,
+	A_JOY7,
+	A_JOY8,
+	A_JOY9,
+	A_JOY10,
+	A_JOY11,
+	A_JOY12,
+	A_JOY13,
+	A_JOY14,
+	A_JOY15,
+	A_JOY16,
+	A_JOY17,
+	A_JOY18,
+	A_JOY19,
+	A_JOY20,
+	A_JOY21,
+	A_JOY22,
+	A_JOY23,
+	A_JOY24,
+	A_JOY25,
+	A_JOY26,
+	A_JOY27,
+	A_JOY28,
+	A_JOY29,
+	A_JOY30,
+	A_JOY31,
+
+	A_AUX0,
+	A_AUX1,
+	A_AUX2,
+	A_AUX3,
+	A_AUX4,
+	A_AUX5,
+	A_AUX6,
+	A_AUX7,
+	A_AUX8,
+	A_AUX9,
+	A_AUX10,
+	A_AUX11,
+	A_AUX12,
+	A_AUX13,
+	A_AUX14,
+	A_AUX15,
+	A_AUX16,
+	A_AUX17,
+	A_AUX18,
+	A_AUX19,
+	A_AUX20,
+	A_AUX21,
+	A_AUX22,
+	A_AUX23,
+	A_AUX24,
+	A_AUX25,
+	A_AUX26,
+	A_AUX27,
+	A_AUX28,
+	A_AUX29,
+	A_AUX30,
+	A_AUX31,
+
+	MAX_KEYS
+} fakeAscii_t;
+
+
+// The menu code needs to get both key and char events, but
+// to avoid duplicating the paths, the char events are just
+// distinguished by or'ing in K_CHAR_FLAG (ugly)
+#define	K_CHAR_FLAG		1024
+
+#endif
diff --git a/codemp/client/keys.h b/codemp/client/keys.h
new file mode 100644
index 0000000..de965c4
--- /dev/null
+++ b/codemp/client/keys.h
@@ -0,0 +1,66 @@
+#include "../ui/keycodes.h"
+
+typedef struct {
+	qboolean	down;
+	int			repeats;		// if > 1, it is autorepeating
+	char		*binding;
+} qkey_t;
+
+#define	MAX_EDIT_LINE		256
+#define COMMAND_HISTORY		32
+
+typedef struct {
+	int		cursor;
+	int		scroll;
+	int		widthInChars;
+	char	buffer[MAX_EDIT_LINE];
+} field_t;
+
+typedef struct keyGlobals_s
+{
+	field_t		historyEditLines[COMMAND_HISTORY];
+
+	int			nextHistoryLine;		// the last line in the history buffer, not masked
+	int			historyLine;			// the line being displayed from history buffer
+										// will be <= nextHistoryLine
+	field_t		g_consoleField;
+
+	qboolean	anykeydown;
+	qboolean	key_overstrikeMode;
+	int			keyDownCount;
+
+	qkey_t		keys[MAX_KEYS];
+} keyGlobals_t;
+
+
+typedef struct 
+{
+	word	upper;
+	word	lower;
+	char	*name;
+	int		keynum;
+	bool	menukey;
+} keyname_t;
+
+extern keyGlobals_t	kg;
+extern keyname_t	keynames[MAX_KEYS];
+
+
+void Field_Clear( field_t *edit );
+void Field_KeyDownEvent( field_t *edit, int key );
+void Field_CharEvent( field_t *edit, int ch );
+void Field_Draw( field_t *edit, int x, int y, int width, qboolean showCursor );
+void Field_BigDraw( field_t *edit, int x, int y, int width, qboolean showCursor );
+
+extern	field_t	chatField;
+extern	qboolean	chat_team;
+extern	int			chat_playerNum;
+
+void Key_WriteBindings( fileHandle_t f );
+void Key_SetBinding( int keynum, const char *binding );
+char *Key_GetBinding( int keynum );
+qboolean Key_IsDown( int keynum );
+qboolean Key_GetOverstrikeMode( void );
+void Key_SetOverstrikeMode( qboolean state );
+void Key_ClearStates( void );
+int Key_GetKey(const char *binding);
diff --git a/codemp/client/snd_ambient.cpp b/codemp/client/snd_ambient.cpp
new file mode 100644
index 0000000..8c6c018
--- /dev/null
+++ b/codemp/client/snd_ambient.cpp
@@ -0,0 +1,1137 @@
+// Ambient Sound System (ASS!)
+
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+#pragma warning ( disable : 4710 )	//not inlined
+#include "client.h"
+#include "snd_ambient.h"
+#ifdef _XBOX
+#include "snd_local_console.h"
+#else
+#include "snd_local.h"
+#endif
+
+static const int MAX_SET_VOLUME =	255;
+
+static void AS_GetGeneralSet( ambientSet_t & );
+static void AS_GetLocalSet( ambientSet_t & );
+static void AS_GetBModelSet( ambientSet_t & );
+
+//Current set and old set for crossfading
+static int	currentSet	= -1;
+static int oldSet		= -1;
+static int crossDelay	= 1000;	//1 second
+
+static int currentSetTime = 0;
+static int oldSetTime = 0;
+
+// Globals for debug purposes
+static int		numSets	= 0;
+
+// Main ambient sound group
+static CSetGroup*	aSets = NULL;
+
+// Globals for speed, blech
+static char	*parseBuffer	= NULL;
+static int		parseSize		= 0;
+static int		parsePos		= 0;
+static char	tempBuffer[1024];
+
+//NOTENOTE: Be sure to change the mirrored code in g_spawn.cpp, and cg_main.cpp
+typedef	map<sstring_t, unsigned char>	namePrecache_m;
+static namePrecache_m*	pMap = NULL;
+
+// Used for enum / string matching
+static const char	*setNames[NUM_AS_SETS] =
+					{	
+						"generalSet",
+						"localSet",
+						"bmodelSet",
+					};
+
+// Used for enum / function matching
+static const parseFunc_t 	parseFuncs[NUM_AS_SETS] =	
+							{
+								AS_GetGeneralSet,
+								AS_GetLocalSet,
+								AS_GetBModelSet,
+							};
+
+// Used for keyword / enum matching
+static const char	*keywordNames[NUM_AS_KEYWORDS]=
+					{	
+						"timeBetweenWaves",
+						"subWaves",
+						"loopedWave",
+						"volRange",
+						"radius",
+						"type",
+						"amsdir",
+						"outdir",
+						"basedir",
+					};
+
+
+CSetGroup::CSetGroup(void)
+{
+	m_ambientSets = new vector<ambientSet_t*>;
+	m_setMap = new map<sstring_t, ambientSet_t*>;
+}
+
+
+CSetGroup::~CSetGroup(void)
+{
+	delete m_ambientSets;
+	delete m_setMap;
+}
+
+/*
+-------------------------
+Free
+-------------------------
+*/
+
+void CSetGroup::Free( void )
+{
+	vector < ambientSet_t * >::iterator	ai;
+
+	for ( ai = m_ambientSets->begin(); ai != m_ambientSets->end(); ai++ )
+	{
+		Z_Free ( (*ai) );
+	}
+
+	//Do this in place of clear() so it *really* frees the memory.
+	delete m_ambientSets;
+	delete m_setMap;
+	m_ambientSets = new vector<ambientSet_t*>;
+	m_setMap = new map<sstring_t, ambientSet_t*>;
+
+	m_numSets = 0;
+}
+
+/*
+-------------------------
+AddSet
+-------------------------
+*/
+
+ambientSet_t *CSetGroup::AddSet( const char *name )
+{
+	ambientSet_t	*set;
+
+	//Allocate the memory
+	set = (ambientSet_t *) Z_Malloc( sizeof( ambientSet_t ), TAG_AMBIENTSET, qtrue);
+
+	//Set up some defaults
+	Q_strncpyz(set->name,name,sizeof(set->name));
+	set->loopedVolume = MAX_SET_VOLUME;
+	set->masterVolume = MAX_SET_VOLUME;
+	set->radius = 250;
+	set->time_start = 10;
+	set->time_end	= 25;
+
+	set->volRange_start = MAX_SET_VOLUME;
+	set->volRange_end	= MAX_SET_VOLUME;
+
+	m_ambientSets->insert( m_ambientSets->end(), set );
+
+	set->id = m_numSets++;
+
+	//Map the name to the pointer for reference later
+	(*m_setMap)[name] = set;
+
+	return set;
+}
+
+/*
+-------------------------
+GetSet
+-------------------------
+*/
+
+ambientSet_t *CSetGroup::GetSet( const char *name )
+{
+	map < sstring_t, ambientSet_t *>::iterator	mi;
+
+	if ( name == NULL )
+		return NULL;
+
+	mi = m_setMap->find( name );
+
+	if ( mi == m_setMap->end() )
+		return NULL;
+
+	return (*mi).second;
+}
+
+ambientSet_t *CSetGroup::GetSet( int ID )
+{
+	if ( m_ambientSets->empty() )
+		return NULL;
+
+	if ( ID < 0 )
+		return NULL;
+
+	if ( ID >= m_numSets )
+		return NULL;
+
+	return (*m_ambientSets)[ID];
+}
+
+
+/*
+===============================================
+
+File Parsing
+
+===============================================
+*/
+
+/*
+-------------------------
+AS_GetSetNameIDForString
+-------------------------
+*/
+
+static int AS_GetSetNameIDForString( const char *name )
+{
+	//Make sure it's valid
+	if ( name == NULL || name[0] == NULL )
+		return -1;
+
+	for ( int i = 0; i < NUM_AS_SETS; i++ )
+	{
+		if ( stricmp( name, setNames[i] ) == 0 )
+			return i;
+	}
+
+	return -1;
+}
+
+/*
+-------------------------
+AS_GetKeywordIDForString
+-------------------------
+*/
+
+static int AS_GetKeywordIDForString( const char *name )
+{
+	//Make sure it's valid
+	if ( name == NULL || name[0] == NULL )
+		return -1;
+
+	for ( int i = 0; i < NUM_AS_KEYWORDS; i++ )
+	{
+		if ( stricmp( name, keywordNames[i] ) == 0 )
+			return i;
+	}
+
+	return -1;
+}
+
+/*
+-------------------------
+AS_SkipLine
+
+Skips a line in the character buffer
+-------------------------
+*/
+
+static void AS_SkipLine( void )
+{
+	if ( parsePos > parseSize )	// needed to avoid a crash because of some OOR access that shouldn't be done
+		return;
+
+	while ( (parseBuffer[parsePos] != '\n') && (parseBuffer[parsePos] != '\r') )
+	{
+		parsePos++;
+
+		if ( parsePos > parseSize )
+			return;
+	}
+
+	parsePos++;
+}
+
+/*
+-------------------------
+AS_GetTimeBetweenWaves
+
+getTimeBetweenWaves <start> <end>
+-------------------------
+*/
+
+static void AS_GetTimeBetweenWaves( ambientSet_t &set )
+{
+	int		startTime, endTime;
+
+	//Get the data
+	sscanf( parseBuffer+parsePos, "%s %d %d", &tempBuffer, &startTime, &endTime );
+
+	//Check for swapped start / end
+	if ( startTime > endTime )
+	{
+		#ifndef FINAL_BUILD
+		Com_Printf(S_COLOR_YELLOW"WARNING: Corrected swapped start / end times in a \"timeBetweenWaves\" keyword\n");
+		#endif
+		
+		int swap = startTime;
+		startTime = endTime;
+		endTime = swap;
+	}
+
+	//Store it
+	set.time_start	= startTime;
+	set.time_end	= endTime;
+
+	AS_SkipLine();
+}
+
+/*
+-------------------------
+AS_GetSubWaves
+
+subWaves <directory> <wave1> <wave2> ...
+-------------------------
+*/
+
+static void AS_GetSubWaves( ambientSet_t &set )
+{
+	char	dirBuffer[512], waveBuffer[256], waveName[1024];
+
+	//Get the directory for these sets
+	sscanf( parseBuffer+parsePos, "%s %s", &tempBuffer, &dirBuffer );	
+
+	//Move the pointer past these two strings
+	parsePos += ((strlen(keywordNames[SET_KEYWORD_SUBWAVES])+1) + (strlen(dirBuffer)+1));
+
+	//Get all the subwaves
+	while ( parsePos <= parseSize )
+	{
+		//Get the data
+		sscanf( parseBuffer+parsePos, "%s", &waveBuffer );
+
+		if ( set.numSubWaves > MAX_WAVES_PER_GROUP )
+		{
+			#ifndef FINAL_BUILD
+			Com_Printf(S_COLOR_YELLOW"WARNING: Too many subwaves on set \"%s\"\n", set.name );
+			#endif
+		}
+		else
+		{
+			//Construct the wave name (pretty, huh?)
+			strcpy( (char *) waveName, "sound/" );
+			strncat( (char *) waveName, (const char *) dirBuffer, 1024 );
+			strncat( (char *) waveName, "/", 512 );
+			strncat( (char *) waveName, (const char *) waveBuffer, 512 );
+			strncat( (char *) waveName, ".wav", 512 );
+			
+			//Place this onto the sound directory name
+
+			//Precache the file at this point and store off the ID instead of the name
+			if ( ( set.subWaves[set.numSubWaves++] = S_RegisterSound( waveName ) ) <= 0 )
+			{
+				#ifndef FINAL_BUILD
+				Com_Printf(S_COLOR_YELLOW"WARNING: Unable to load ambient sound \"%s\"\n", waveName);
+				#endif
+			}
+		}
+
+		//Move the pointer past this string
+		parsePos += strlen(waveBuffer)+1;
+
+		if ( ( (parseBuffer+parsePos)[0] == '\n') || ( (parseBuffer+parsePos)[0] == '\r') )
+			break;
+	}
+
+	AS_SkipLine();
+}
+
+/*
+-------------------------
+AS_GetLoopedWave
+
+loopedWave <name>
+-------------------------
+*/
+
+static void AS_GetLoopedWave( ambientSet_t &set )
+{
+	char	waveBuffer[256], waveName[1024];
+
+	//Get the looped wave name
+	sscanf( parseBuffer+parsePos, "%s %s", &tempBuffer, &waveBuffer );
+
+	//Construct the wave name
+	strcpy( (char *) waveName, "sound/" );
+	strncat( (char *) waveName, (const char *) waveBuffer, 1024 );
+	strncat( (char *) waveName, ".wav", 1024 );
+	
+	//Precache the file at this point and store off the ID instead of the name
+	if ( ( set.loopedWave = S_RegisterSound( waveName ) ) <= 0 )
+	{
+		#ifndef FINAL_BUILD
+		Com_Printf(S_COLOR_YELLOW"WARNING: Unable to load ambient sound \"%s\"\n", waveName);
+		#endif
+	}
+
+	AS_SkipLine();
+}
+
+/*
+-------------------------
+AS_GetVolumeRange
+-------------------------
+*/
+
+static void AS_GetVolumeRange( ambientSet_t &set )
+{
+	int		min, max;
+
+	//Get the data
+	sscanf( parseBuffer+parsePos, "%s %d %d", &tempBuffer, &min, &max );
+
+	//Check for swapped min / max
+	if ( min > max )
+	{
+		#ifndef FINAL_BUILD
+		Com_Printf(S_COLOR_YELLOW"WARNING: Corrected swapped min / max range in a \"volRange\" keyword\n");
+		#endif
+		
+		int swap =	min;
+					min = max;
+						  max = swap;		
+	}
+
+	//Store the data
+	set.volRange_start	= min;
+	set.volRange_end	= max;
+
+	AS_SkipLine();
+}
+
+/*
+-------------------------
+AS_GetRadius
+-------------------------
+*/
+
+static void AS_GetRadius( ambientSet_t &set )
+{
+	//Get the data
+	sscanf( parseBuffer+parsePos, "%s %d", &tempBuffer, &set.radius );
+
+	AS_SkipLine();
+}
+
+/*
+-------------------------
+AS_GetGeneralSet
+-------------------------
+*/
+
+static void AS_GetGeneralSet( ambientSet_t &set )
+{
+	int		keywordID;
+
+	//The other parameters of the set come in a specific order
+	while ( parsePos <= parseSize )
+	{
+		int iFieldsScanned = sscanf( parseBuffer+parsePos, "%s", &tempBuffer );
+		if (iFieldsScanned <= 0)
+			return;
+
+		keywordID = AS_GetKeywordIDForString( (const char *) &tempBuffer );
+
+		//Find and parse the keyword info
+		switch ( keywordID )
+		{
+		case SET_KEYWORD_TIMEBETWEENWAVES:
+			AS_GetTimeBetweenWaves( set );
+			break;
+
+		case SET_KEYWORD_SUBWAVES:
+			AS_GetSubWaves( set );
+			break;
+
+		case SET_KEYWORD_LOOPEDWAVE:
+			AS_GetLoopedWave( set );
+			break;
+
+		case SET_KEYWORD_VOLRANGE:
+			AS_GetVolumeRange( set );
+			break;
+
+		default:
+
+			//Check to see if we've finished this group
+			if ( AS_GetSetNameIDForString( (const char *) &tempBuffer ) == -1 )
+			{
+				//Ignore comments
+				if ( tempBuffer[0] == ';' )
+					return;
+
+				//This wasn't a set name, so it's an error
+				#ifndef FINAL_BUILD
+				Com_Printf( S_COLOR_YELLOW"WARNING: Unknown ambient set keyword \"%s\"\n", tempBuffer );
+				#endif
+			}
+
+			return;
+			break;
+		}
+	}
+}
+
+/*
+-------------------------
+AS_GetLocalSet
+-------------------------
+*/
+
+static void AS_GetLocalSet( ambientSet_t &set )
+{
+	int		keywordID;
+
+	//The other parameters of the set come in a specific order
+	while ( parsePos <= parseSize )
+	{
+		int iFieldsScanned = sscanf( parseBuffer+parsePos, "%s", &tempBuffer );
+		if (iFieldsScanned <= 0)
+			return;
+
+		keywordID = AS_GetKeywordIDForString( (const char *) &tempBuffer );
+
+		//Find and parse the keyword info
+		switch ( keywordID )
+		{
+		case SET_KEYWORD_TIMEBETWEENWAVES:
+			AS_GetTimeBetweenWaves( set );
+			break;
+
+		case SET_KEYWORD_SUBWAVES:
+			AS_GetSubWaves( set );
+			break;
+
+		case SET_KEYWORD_LOOPEDWAVE:
+			AS_GetLoopedWave( set );
+			break;
+
+		case SET_KEYWORD_VOLRANGE:
+			AS_GetVolumeRange( set );
+			break;
+
+		case SET_KEYWORD_RADIUS:
+			AS_GetRadius( set );
+			break;
+
+		default:
+
+			//Check to see if we've finished this group
+			if ( AS_GetSetNameIDForString( (const char *) &tempBuffer ) == -1 )
+			{
+				//Ignore comments
+				if ( tempBuffer[0] == ';' )
+					return;
+
+				//This wasn't a set name, so it's an error
+				#ifndef FINAL_BUILD
+				Com_Printf( S_COLOR_YELLOW"WARNING: Unknown ambient set keyword \"%s\"\n", tempBuffer );
+				#endif
+			}
+
+			return;
+			break;
+		}
+	}
+}
+
+/*
+-------------------------
+AS_GetBModelSet
+-------------------------
+*/
+
+static void AS_GetBModelSet( ambientSet_t &set )
+{
+	int		keywordID;
+
+	//The other parameters of the set come in a specific order
+	while ( parsePos <= parseSize )
+	{
+		int iFieldsScanned = sscanf( parseBuffer+parsePos, "%s", &tempBuffer );
+		if (iFieldsScanned <= 0)
+			return;
+
+		keywordID = AS_GetKeywordIDForString( (const char *) &tempBuffer );
+
+		//Find and parse the keyword info
+		switch ( keywordID )
+		{
+		case SET_KEYWORD_SUBWAVES:
+			AS_GetSubWaves( set );
+			break;
+
+		default:
+
+			//Check to see if we've finished this group
+			if ( AS_GetSetNameIDForString( (const char *) &tempBuffer ) == -1 )
+			{
+				//Ignore comments
+				if ( tempBuffer[0] == ';' )
+					return;
+
+				//This wasn't a set name, so it's an error
+				#ifndef FINAL_BUILD
+				Com_Printf( S_COLOR_YELLOW"WARNING: Unknown ambient set keyword \"%s\"\n", tempBuffer );
+				#endif
+			}
+
+			return;
+			break;
+		}
+	}
+}
+
+/*
+-------------------------
+AS_ParseSet
+
+Parses an individual set group out of a set file buffer
+-------------------------
+*/
+
+static sboolean AS_ParseSet( int setID, CSetGroup *sg )
+{
+	ambientSet_t	*set;
+	const char		*name;
+
+	//Make sure we're not overstepping the name array
+	if ( setID > NUM_AS_SETS )
+		return qfalse;
+
+	//Reset the pointers for this run through
+	parsePos = 0;
+
+	name = setNames[setID];
+
+	//Iterate through the whole file and find every occurance of a set
+	while ( parsePos <= parseSize )
+	{
+		//Check for a valid set group
+		if ( strncmp( parseBuffer+parsePos, name, strlen(name) ) == 0 )
+		{
+			//Update the debug info
+			numSets++;	
+			
+			//Push past the set specifier and on to the name
+			parsePos+=strlen(name)+1;	//Also take the following space out
+
+			//Get the set name (this MUST be first)
+			sscanf( parseBuffer+parsePos, "%s", &tempBuffer );
+			AS_SkipLine();
+	
+			//Test the string against the precaches
+			if ( tempBuffer[0] )
+			{
+				//Not in our precache listings, so skip it
+				if ( ( pMap->find( (const char *) &tempBuffer ) == pMap->end() ) )
+					continue;
+			}
+
+			//Create a new set
+			set = sg->AddSet( (const char *) &tempBuffer );
+			
+			//Run the function to parse the data out
+			parseFuncs[setID]( *set );
+			continue;
+		}
+
+		//If not found on this line, go down another and check again
+		AS_SkipLine();
+	}
+	
+	return qtrue;
+}
+
+/*
+-------------------------
+AS_ParseHeader
+
+Parses the directory information out of the beginning of the file
+-------------------------
+*/
+
+static void AS_ParseHeader( void )
+{	
+	char	typeBuffer[128];
+	int		keywordID;
+
+	while ( parsePos <= parseSize )
+	{
+		sscanf( parseBuffer+parsePos, "%s", &tempBuffer );
+
+		keywordID = AS_GetKeywordIDForString( (const char *) &tempBuffer );
+
+		switch ( keywordID )
+		{
+		case SET_KEYWORD_TYPE:
+			sscanf( parseBuffer+parsePos, "%s %s", &tempBuffer, &typeBuffer );
+
+			if ( !stricmp( (const char *) typeBuffer, "ambientSet" ) )
+			{
+				return;
+			}
+			Com_Error( ERR_DROP, "AS_ParseHeader: Set type \"%s\" is not a valid set type!\n", typeBuffer );
+
+			break;
+
+		case SET_KEYWORD_AMSDIR:
+			//TODO: Implement
+			break;
+
+		case SET_KEYWORD_OUTDIR:
+			//TODO: Implement
+			break;
+
+		case SET_KEYWORD_BASEDIR:
+			//TODO: Implement
+			break;
+		}
+
+		AS_SkipLine();
+	}
+}
+
+/*
+-------------------------
+AS_ParseFile
+
+Opens and parses a sound set file
+-------------------------
+*/
+
+static sboolean AS_ParseFile( const char *filename, CSetGroup *sg )
+{
+	//Open the file and read the information from it
+	parseSize = FS_ReadFile( filename, (void **) &parseBuffer );
+
+	if ( parseSize <= 0 )
+		return qfalse;
+
+	//Parse the directory information out of the file
+	AS_ParseHeader();
+
+	//Parse all the relevent sets out of it
+	for ( int i = 0; i < NUM_AS_SETS; i++ )
+		AS_ParseSet( i, sg );
+
+	//Free the memory and close the file
+	FS_FreeFile( parseBuffer );
+
+	return qtrue;
+}
+
+/*
+===============================================
+
+Main code
+
+===============================================
+*/
+
+/*
+-------------------------
+AS_Init
+
+Loads the ambient sound sets and prepares to play them when needed
+-------------------------
+*/
+
+void AS_Init( void )
+{
+	if (!aSets)
+	{
+		numSets = 0;
+
+		pMap = new namePrecache_m;
+
+		//Setup the structure
+		aSets = new CSetGroup();
+		aSets->Init();
+	}
+}
+
+/*
+-------------------------
+AS_AddPrecacheEntry
+-------------------------
+*/
+
+void AS_AddPrecacheEntry( const char *name )
+{
+	if (!stricmp(name,"#clear"))
+	{
+		pMap->clear();
+	}
+	else
+	{
+		(*pMap)[ name ] = 1;
+	}
+}
+
+/*
+-------------------------
+AS_ParseSets
+
+Called on the client side to load and precache all the ambient sound sets
+-------------------------
+*/
+
+void AS_ParseSets( void )
+{
+	AS_Init();
+
+	//Parse all the sets
+	if ( AS_ParseFile( AMBIENT_SET_FILENAME, aSets ) == qfalse )
+	{
+		Com_Error ( ERR_FATAL, S_COLOR_RED"ERROR: Couldn't load ambient sound sets from %s", AMBIENT_SET_FILENAME );
+	}
+
+//	Com_Printf( "AS_ParseFile: Loaded %d of %d ambient set(s)\n", pMap.size(), numSets );
+
+	int iErrorsOccured = 0;
+	for (namePrecache_m::iterator it = pMap->begin(); it != pMap->end(); ++it)
+	{
+		const char* str = (*it).first.c_str();
+		ambientSet_t *aSet = aSets->GetSet( str );
+		if (!aSet)
+		{
+			// I print these red instead of yellow because they're going to cause an ERR_DROP if they occur
+			Com_Printf( S_COLOR_RED"ERROR: AS_ParseSets: Unable to find ambient soundset \"%s\"!\n",str);
+			iErrorsOccured++;
+		}
+	}
+
+	if (iErrorsOccured)
+	{
+		Com_Error( ERR_DROP, "....%d missing sound sets! (see above)\n", iErrorsOccured);
+	}
+
+//	//Done with the precache info, it will be rebuilt on a restart
+//	pMap->clear();	// do NOT do this here now
+}
+
+/*
+-------------------------
+AS_Free
+
+Frees up the ambient sound system
+-------------------------
+*/
+
+void AS_Free( void )
+{
+	if (aSets)
+	{
+		aSets->Free();
+		delete aSets;
+		aSets = NULL;
+
+		currentSet	= -1;
+		oldSet		= -1;
+
+		currentSetTime = 0;
+		oldSetTime = 0;
+
+		numSets	= 0;
+	}
+}
+
+
+void AS_FreePartial(void)
+{
+	if (aSets)
+	{
+		aSets->Free();
+		currentSet	= -1;
+		oldSet		= -1;
+
+		currentSetTime = 0;
+		oldSetTime = 0;
+
+		numSets	= 0;
+
+		delete pMap;
+		pMap = new namePrecache_m;
+	}
+}
+
+/*
+===============================================
+
+Sound code
+
+===============================================
+*/
+
+/*
+-------------------------
+AS_UpdateSetVolumes
+
+Fades volumes up or down depending on the action being taken on them.
+-------------------------
+*/
+
+static void AS_UpdateSetVolumes( void )
+{
+	ambientSet_t	*old, *current;
+	float			scale;
+	int				deltaTime;
+
+	//Get the sets and validate them
+	current = aSets->GetSet( currentSet );
+
+	if ( current == NULL )
+		return;
+
+	if ( current->masterVolume < MAX_SET_VOLUME )
+	{
+		deltaTime = cls.realtime - current->fadeTime;
+		scale = ((float)(deltaTime)/(float)(crossDelay));
+		current->masterVolume = (int)((scale) * (float)MAX_SET_VOLUME);
+	}
+
+	if ( current->masterVolume > MAX_SET_VOLUME )
+		current->masterVolume = MAX_SET_VOLUME;
+
+	//Only update the old set if it's still valid
+	if ( oldSet == -1 )
+		return;
+
+	old = aSets->GetSet( oldSet );
+
+	if ( old == NULL )
+		return;
+
+	//Update the volumes
+	if ( old->masterVolume > 0 )
+	{
+		deltaTime = cls.realtime - old->fadeTime;
+		scale = ((float)(deltaTime)/(float)(crossDelay));
+		old->masterVolume = MAX_SET_VOLUME - (int)((scale) * (float)MAX_SET_VOLUME);
+	}
+
+	if ( old->masterVolume <= 0 )
+	{
+		old->masterVolume = 0;
+		oldSet = -1;
+	}
+}
+
+/*
+-------------------------
+S_UpdateCurrentSet
+
+Does internal maintenance to keep track of changing sets.
+-------------------------
+*/
+
+static void AS_UpdateCurrentSet( int id )
+{
+	ambientSet_t	*old, *current;
+
+	//Check for a change
+	if ( id != currentSet )
+	{
+		//This is new, so start the fading
+		oldSet = currentSet;
+		currentSet = id;
+
+		old = aSets->GetSet( oldSet );
+		current = aSets->GetSet( currentSet );
+		// Ste, I just put this null check in for now, not sure if there's a more graceful way to exit this function - dmv
+		if( !current )
+		{
+			return;
+		}
+		if ( old )
+		{
+			old->masterVolume = MAX_SET_VOLUME;
+			old->fadeTime = cls.realtime;
+		}
+	
+		current->masterVolume = 0;
+
+		//Set the fading starts
+		current->fadeTime = cls.realtime;
+	}
+
+	//Update their volumes if fading
+	AS_UpdateSetVolumes();
+}
+
+/*
+-------------------------
+AS_PlayLocalSet
+
+Plays a local set taking volume and subwave playing into account.  
+Alters lastTime to reflect the time updates.
+-------------------------
+*/
+
+static void AS_PlayLocalSet( vec3_t listener_origin, vec3_t origin, ambientSet_t *set, int entID, int *lastTime )
+{
+	unsigned char	volume;
+	vec3_t			dir;
+	float			volScale, dist, distScale;
+	int				time = cls.realtime;
+
+	//Make sure it's valid
+	if ( set == NULL )
+		return;
+
+	VectorSubtract( origin, listener_origin, dir );
+	dist = VectorLength( dir );
+
+	//Determine the volume based on distance (NOTE: This sits on top of what SpatializeOrigin does)
+	distScale	= ( dist < ( set->radius * 0.5f ) ) ? 1 : ( set->radius - dist ) / ( set->radius * 0.5f );
+	volume		= ( distScale > 1.0f || distScale < 0.0f ) ? 0 : (unsigned char) ( set->masterVolume * distScale );
+
+	//Add the looping sound
+	if ( set->loopedWave )
+		S_AddAmbientLoopingSound( origin, volume, set->loopedWave );
+
+	//Check the time to start another one-shot subwave
+	if ( ( time - *lastTime ) < ( ( Q_irand( set->time_start, set->time_end ) ) * 1000 ) )
+		return;
+	
+	//Update the time
+	*lastTime = time;
+
+	//Scale the volume ranges for the subwaves based on the overall master volume
+	volScale = (float) volume / (float) MAX_SET_VOLUME;
+	volume = (unsigned char) Q_irand( (int)(volScale*set->volRange_start), (int)(volScale*set->volRange_end) );
+
+	//Add the random subwave
+	if ( set->numSubWaves )
+		S_StartAmbientSound( origin, entID, volume, set->subWaves[Q_irand( 0, set->numSubWaves-1)] );
+}
+
+/*
+-------------------------
+AS_PlayAmbientSet
+
+Plays an ambient set taking volume and subwave playing into account.  
+Alters lastTime to reflect the time updates.
+-------------------------
+*/
+
+static void AS_PlayAmbientSet( vec3_t origin, ambientSet_t *set, int *lastTime )
+{
+	unsigned char	volume;
+	float			volScale;
+	int				time = cls.realtime;
+
+	//Make sure it's valid
+	if ( set == NULL )
+		return;
+
+	//Add the looping sound
+	if ( set->loopedWave )
+		S_AddAmbientLoopingSound( origin, (unsigned char) set->masterVolume, set->loopedWave );
+
+	//Check the time to start another one-shot subwave
+	if ( ( time - *lastTime ) < ( ( Q_irand( set->time_start, set->time_end ) ) * 1000 ) )
+		return;
+	
+	//Update the time
+	*lastTime = time;
+
+	//Scale the volume ranges for the subwaves based on the overall master volume
+	volScale = (float) set->masterVolume / (float) MAX_SET_VOLUME;
+	volume = Q_irand( (int)(volScale*set->volRange_start), (int)(volScale*set->volRange_end) );
+
+	//Allow for softer noises than the masterVolume, but not louder
+	if ( volume > set->masterVolume )
+		volume = set->masterVolume;
+
+	//Add the random subwave
+	if ( set->numSubWaves )
+		S_StartAmbientSound( origin, 0, volume, set->subWaves[Q_irand( 0, set->numSubWaves-1)] );
+}
+
+/*
+-------------------------
+S_UpdateAmbientSet
+
+Does maintenance and plays the ambient sets (two if crossfading)
+-------------------------
+*/
+
+void S_UpdateAmbientSet ( const char *name, vec3_t origin ) 
+{
+	ambientSet_t	*current, *old;
+	ambientSet_t	*set = aSets->GetSet( name );
+	
+	if ( set == NULL )
+		return;
+
+	//Update the current and old set for crossfading
+	AS_UpdateCurrentSet( set->id );
+
+	current = aSets->GetSet( currentSet );
+	old = aSets->GetSet( oldSet );
+
+	if ( current )
+		AS_PlayAmbientSet( origin, set, &currentSetTime );
+
+	if ( old )
+		AS_PlayAmbientSet( origin, old, &oldSetTime );
+}
+
+/*
+-------------------------
+S_AddLocalSet
+-------------------------
+*/
+
+int S_AddLocalSet( const char *name, vec3_t listener_origin, vec3_t origin, int entID, int time )
+{
+	ambientSet_t	*set;
+	int				currentTime = 0;
+
+	set = aSets->GetSet( name );
+
+	if ( set == NULL )
+		return cls.realtime;
+
+	currentTime = time;
+
+	AS_PlayLocalSet( listener_origin, origin, set, entID, &currentTime );
+	
+	return currentTime;
+}
+
+/*
+-------------------------
+AS_GetBModelSound
+-------------------------
+*/
+
+sfxHandle_t AS_GetBModelSound( const char *name, int stage )
+{
+	ambientSet_t	*set;
+
+	set = aSets->GetSet( name );
+
+	if ( set == NULL )
+		return -1;
+
+	//Stage must be within a valid range
+	if ( ( stage > ( set->numSubWaves - 1 ) ) || ( stage < 0 ) )
+		return -1;
+
+	return set->subWaves[ stage ];
+}
diff --git a/codemp/client/snd_ambient.h b/codemp/client/snd_ambient.h
new file mode 100644
index 0000000..ba0b5a5
--- /dev/null
+++ b/codemp/client/snd_ambient.h
@@ -0,0 +1,118 @@
+#ifndef	__SND_AMBIENT__
+#define __SND_AMBIENT__
+
+// Includes
+
+#pragma warning ( disable : 4786 )
+#pragma warning ( disable : 4511 )	//copy constructor could not be gen
+#pragma warning ( disable : 4512 )	//assign constructor could not be gen
+
+//these don't work because stl re-sets them
+//#pragma warning ( disable : 4663 )	//spcialize class
+//#pragma warning ( disable : 4018 )	//signed/unsigned
+#pragma warning (disable:4503)	// decorated name length xceeded, name was truncated
+#pragma warning (push, 3)	//go back down to 3 for the stl include
+
+#include "../qcommon/sstring.h"	// #include <string>
+#include <vector>
+#include <map>
+#pragma warning (pop)
+#pragma warning (disable:4503)	// decorated name length xceeded, name was truncated
+
+using namespace std;
+
+// Defines
+
+#define	AMBIENT_SET_FILENAME	"sound/sound.txt"
+
+const	int	MAX_WAVES_PER_GROUP	= 8;
+const	int	MAX_SET_NAME_LENGTH	= 64;
+
+// Enums
+
+enum set_e
+{
+	AS_SET_GENERAL,		//General sets
+	AS_SET_LOCAL,		//Local sets (regional)
+	AS_SET_BMODEL,		//Brush model sets (doors, plats, etc.)
+
+	NUM_AS_SETS
+};
+
+enum setKeyword_e
+{
+	SET_KEYWORD_TIMEBETWEENWAVES,
+	SET_KEYWORD_SUBWAVES,
+	SET_KEYWORD_LOOPEDWAVE,
+	SET_KEYWORD_VOLRANGE,
+	SET_KEYWORD_RADIUS,
+	SET_KEYWORD_TYPE,
+	SET_KEYWORD_AMSDIR,
+	SET_KEYWORD_OUTDIR,
+	SET_KEYWORD_BASEDIR,
+	
+	NUM_AS_KEYWORDS,
+};
+
+// Structures
+
+//NOTENOTE: Was going to make this a class, but don't want to muck around
+typedef struct ambientSet_s
+{
+	char			name[MAX_SET_NAME_LENGTH];
+	unsigned char	loopedVolume;
+	unsigned int	time_start, time_end;
+	unsigned int	volRange_start, volRange_end;
+	unsigned char	numSubWaves;
+	int				subWaves[MAX_WAVES_PER_GROUP];
+	int				loopedWave;
+	int				radius;							//NOTENOTE: -1 is global
+	int				masterVolume;					//Used for fading ambient sets (not a byte to prevent wrapping)
+	int				id;								//Used for easier referencing of sets
+	int				fadeTime;						//When the fade was started on this set
+} ambientSet_t;
+
+typedef void (*parseFunc_t)( ambientSet_t & );
+
+// Classes
+
+//NOTENOTE: But this one should be a class because of all the mapping and internal data handling
+class CSetGroup
+{
+public:
+
+	CSetGroup();
+	~CSetGroup();
+
+	void Init( void ) 
+	{
+		Free();
+	}
+
+	void Free( void );
+
+	ambientSet_t *AddSet( const char *name );
+	
+	ambientSet_t *GetSet ( const char *name );
+	ambientSet_t *GetSet ( int ID );
+
+protected:
+
+	int								m_numSets;
+	vector < ambientSet_t * >		*m_ambientSets;
+	map	< sstring_t, ambientSet_t * >	*m_setMap;
+};
+
+// Prototypes
+
+extern void AS_Init( void );
+extern void AS_Free( void );
+extern void AS_ParseSets( void );
+extern void AS_AddPrecacheEntry( const char *name );
+
+extern void S_UpdateAmbientSet ( const char *name, vec3_t origin );
+extern int S_AddLocalSet( const char *name, vec3_t listener_origin, vec3_t origin, int entID, int time );
+
+extern sfxHandle_t	AS_GetBModelSound( const char *name, int stage );
+
+#endif	//__SND_AMBIENT__
\ No newline at end of file
diff --git a/codemp/client/snd_dma.cpp b/codemp/client/snd_dma.cpp
new file mode 100644
index 0000000..0d340e3
--- /dev/null
+++ b/codemp/client/snd_dma.cpp
@@ -0,0 +1,6322 @@
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+/*****************************************************************************
+ * name:		snd_dma.c
+ *
+ * desc:		main control for any streaming sound output device
+ *
+ *
+ *****************************************************************************/
+#include "snd_local.h"
+#include "snd_mp3.h"
+#include "snd_music.h"
+#include "client.h"
+
+qboolean s_shutUp = qfalse;
+
+static void S_Play_f(void);
+static void S_SoundList_f(void);
+static void S_Music_f(void);
+static void S_SetDynamicMusic_f(void);
+
+void S_Update_();
+void S_StopAllSounds(void);
+static void S_UpdateBackgroundTrack( void );
+sfx_t *S_FindName( const char *name );
+static int SND_FreeSFXMem(sfx_t *sfx);
+
+extern qboolean Sys_LowPhysicalMemory();
+
+//////////////////////////
+//
+// vars for bgrnd music track...
+//
+const int iMP3MusicStream_DiskBytesToRead = 10000;//4096;
+const int iMP3MusicStream_DiskBufferSize = iMP3MusicStream_DiskBytesToRead*2; //*10;
+
+typedef struct
+{	
+	sboolean	bIsMP3;
+	//
+	// MP3 specific...
+	//
+	sfx_t		sfxMP3_Bgrnd;
+	MP3STREAM	streamMP3_Bgrnd;	// this one is pointed at by the sfx_t's ptr, and is NOT the one the decoder uses every cycle
+	channel_t	chMP3_Bgrnd;		// ... but the one in this struct IS.	
+	//
+	// MP3 disk streamer stuff... (if music is non-dynamic)
+	//
+	byte		byMP3MusicStream_DiskBuffer[iMP3MusicStream_DiskBufferSize];
+	int			iMP3MusicStream_DiskReadPos;
+	int			iMP3MusicStream_DiskWindowPos;
+	//
+	// MP3 disk-load stuff (for use during dynamic music, which is mem-resident)
+	//
+	byte		*pLoadedData;	// Z_Malloc, Z_Free	// these two MUST be kept as valid/invalid together	
+	char		sLoadedDataName[MAX_QPATH];			//  " " " " "  
+	int			iLoadedDataLen;	
+	//
+	// remaining dynamic fields...
+	//
+	int			iXFadeVolumeSeekTime;
+	int			iXFadeVolumeSeekTo;	// when changing this, set the above timer to Sys_Milliseconds(). 
+									//	Note that this should be thought of more as an up/down bool rather than as a 
+									//	number now, in other words set it only to 0 or 255. I'll probably change this
+									//	to actually be a bool later.
+	int			iXFadeVolume;		// 0 = silent, 255 = max mixer vol, though still modulated via overall music_volume 
+	float		fSmoothedOutVolume;
+	sboolean	bActive;			// whether playing or not
+	sboolean	bExists;			// whether was even loaded for this level (ie don't try and start playing it)
+	//
+	// new dynamic fields...
+	//
+	sboolean	bTrackSwitchPending;
+	MusicState_e eTS_NewState;
+	float		 fTS_NewTime;
+	//
+	// Generic...
+	//
+	fileHandle_t s_backgroundFile;	// valid handle, else -1 if an MP3 (so that NZ compares still work)
+	wavinfo_t	s_backgroundInfo;
+	int			s_backgroundSamples;	
+
+	void Rewind()
+	{
+		MP3Stream_Rewind( &chMP3_Bgrnd );
+		s_backgroundSamples = sfxMP3_Bgrnd.iSoundLengthInSamples;
+	}
+
+	void SeekTo(float fTime)
+	{
+		chMP3_Bgrnd.iMP3SlidingDecodeWindowPos = 0;
+		chMP3_Bgrnd.iMP3SlidingDecodeWritePos = 0;
+		MP3Stream_SeekTo( &chMP3_Bgrnd, fTime );
+		s_backgroundSamples = sfxMP3_Bgrnd.iSoundLengthInSamples;
+	}
+
+} MusicInfo_t;
+
+static void S_SetDynamicMusicState( MusicState_e musicState );
+
+#define fDYNAMIC_XFADE_SECONDS (1.0f)
+
+static MusicInfo_t	tMusic_Info[eBGRNDTRACK_NUMBEROF]	= {0};
+static sboolean		bMusic_IsDynamic					= qfalse;
+static MusicState_e	eMusic_StateActual					= eBGRNDTRACK_EXPLORE;	// actual state, can be any enum
+static MusicState_e	eMusic_StateRequest					= eBGRNDTRACK_EXPLORE;	// requested state, can only be explore, action, boss, or silence
+static char			sMusic_BackgroundLoop[MAX_QPATH]	= {0};	// only valid for non-dynamic music
+static char			sInfoOnly_CurrentDynamicMusicSet[64];	// any old reasonable size, only has to fit stuff like "kejim_post"
+//
+//////////////////////////
+
+
+// =======================================================================
+// Internal sound data & structures
+// =======================================================================
+ 
+// only begin attenuating sound volumes when outside the FULLVOLUME range
+#define		SOUND_FULLVOLUME	256
+
+#define		SOUND_ATTENUATE		0.0008f
+#define		VOICE_ATTENUATE		0.004f
+
+const float	SOUND_FMAXVOL=0.75;//1.0;
+const int	SOUND_MAXVOL=255;
+
+channel_t   s_channels[MAX_CHANNELS];
+
+int			s_soundStarted;
+qboolean	s_soundMuted;
+
+dma_t		dma;
+
+int			listener_number;
+vec3_t		listener_origin;
+vec3_t		listener_axis[3];
+
+int			s_soundtime;		// sample PAIRS
+int   		s_paintedtime; 		// sample PAIRS
+
+// MAX_SFX may be larger than MAX_SOUNDS because
+// of custom player sounds
+#define		MAX_SFX			10000	//512 * 2
+sfx_t		s_knownSfx[MAX_SFX];
+int			s_numSfx;
+
+#define		LOOP_HASH		128
+static	sfx_t		*sfxHash[LOOP_HASH];
+
+
+cvar_t		*s_volume;
+cvar_t		*s_volumeVoice;
+cvar_t		*s_testsound;
+cvar_t		*s_khz;
+cvar_t		*s_allowDynamicMusic;
+cvar_t		*s_show;
+cvar_t		*s_mixahead;
+cvar_t		*s_mixPreStep;
+cvar_t		*s_musicVolume;
+cvar_t		*s_separation;
+cvar_t		*s_lip_threshold_1;
+cvar_t		*s_lip_threshold_2;
+cvar_t		*s_lip_threshold_3;
+cvar_t		*s_lip_threshold_4;
+cvar_t		*s_CPUType;
+cvar_t		*s_language;	// note that this is distinct from "g_language"
+cvar_t		*s_dynamix;
+cvar_t		*s_debugdynamic;
+
+typedef struct 
+{ 
+	unsigned char	volume;
+	vec3_t			origin;
+	vec3_t			velocity;
+/*	const*/ sfx_t		*sfx;
+	int				mergeFrame;
+	int			entnum;
+
+	// For Open AL
+	bool	bProcessed;
+	bool	bRelative;
+} loopSound_t;
+
+#define	MAX_LOOP_SOUNDS		32
+
+int			numLoopSounds;
+loopSound_t	loopSounds[MAX_LOOP_SOUNDS];
+
+
+int			s_rawend;
+portable_samplepair_t	s_rawsamples[MAX_RAW_SAMPLES];
+vec3_t		s_entityPosition[MAX_GENTITIES];
+int			s_entityWavVol[MAX_GENTITIES];
+int			s_entityWavVol_back[MAX_GENTITIES];
+
+
+/**************************************************************************************************\
+*
+*	Open AL Specific
+*
+\**************************************************************************************************/
+
+#define FLT_MAX         3.402823466e+38F
+#define FLT_MIN         1.175494351e-38F
+#define sqr(a)			((a)*(a))
+#define ENV_UPDATE_RATE	100			// Environmental audio update rate (in ms)
+
+//#define DISPLAY_CLOSEST_ENVS		// Displays the closest env. zones (including the one the listener is in)
+
+#define DEFAULT_REF_DISTANCE		300.0f		// Default reference distance
+#define DEFAULT_VOICE_REF_DISTANCE	1500.0f		// Default voice reference distance
+
+int			s_UseOpenAL	= false;	// Determines if using Open AL or the default software mixer
+
+ALfloat		listener_pos[3];		// Listener Position
+ALfloat		listener_ori[6];		// Listener Orientation
+int			s_numChannels;			// Number of AL Sources == Num of Channels
+short		s_rawdata[MAX_RAW_SAMPLES*2];	// Used for Raw Samples (Music etc...)
+
+channel_t *S_OpenALPickChannel(int entnum, int entchannel);
+int  S_MP3PreProcessLipSync(channel_t *ch, short *data);
+void UpdateSingleShotSounds();
+void UpdateLoopingSounds();
+void AL_UpdateRawSamples();
+void S_SetLipSyncs();
+
+// EAX Related
+
+typedef struct
+{
+	ALuint		ulNumApertures;
+	ALint		lFXSlotID;
+	ALboolean	bUsed;
+	struct
+	{
+		ALfloat vPos1[3];
+		ALfloat vPos2[3];
+		ALfloat vCenter[3];
+	} Aperture[64];
+} ENVTABLE, *LPENVTABLE;
+
+typedef struct
+{
+	long lEnvID;
+	long lApertureNum;
+	float flDist;
+} REVERBDATA, *LPREVERBDATA;
+
+typedef struct
+{
+	GUID	FXSlotGuid;
+	ALint	lEnvID;
+} FXSLOTINFO, *LPFXSLOTINFO;
+
+ALboolean				s_bEAX;					// Is EAX 4.0 support available
+bool					s_bEALFileLoaded;		// Has an .eal file been loaded for the current level
+bool					s_bInWater;				// Underwater effect currently active 
+int						s_EnvironmentID;		// EAGLE ID of current environment
+LPEAXMANAGER			s_lpEAXManager;			// Pointer to EAXManager object
+HINSTANCE				s_hEAXManInst;			// Handle of EAXManager DLL
+EAXSet					s_eaxSet;				// EAXSet() function
+EAXGet					s_eaxGet;				// EAXGet() function
+EAXREVERBPROPERTIES		s_eaxLPCur;				// Current EAX Parameters
+LPENVTABLE				s_lpEnvTable=NULL;		// Stores information about each environment zone
+long					s_lLastEnvUpdate;		// Time of last EAX update
+long					s_lNumEnvironments;		// Number of environment zones
+long					s_NumFXSlots;			// Number of EAX 4.0 FX Slots
+FXSLOTINFO				s_FXSlotInfo[EAX_MAX_FXSLOTS];	// Stores information about the EAX 4.0 FX Slots
+
+void InitEAXManager();
+void ReleaseEAXManager();
+bool LoadEALFile(char *szEALFilename);
+void UnloadEALFile();
+void UpdateEAXListener();
+void UpdateEAXBuffer(channel_t *ch);
+void EALFileInit(char *level);
+float CalcDistance(EMPOINT A, EMPOINT B);
+
+void Normalize(EAXVECTOR *v)
+{
+	float flMagnitude;
+
+	flMagnitude = (float)sqrt(sqr(v->x) + sqr(v->y) + sqr(v->z));
+
+	v->x = v->x / flMagnitude;
+	v->y = v->y / flMagnitude;
+	v->z = v->z / flMagnitude;	
+}
+
+// EAX 4.0 GUIDS ... confidential information ...
+
+const GUID EAXPROPERTYID_EAX40_FXSlot0 = { 0xc4d79f1e, 0xf1ac, 0x436b, { 0xa8, 0x1d, 0xa7, 0x38, 0xe7, 0x4, 0x54, 0x69} };
+
+const GUID EAXPROPERTYID_EAX40_FXSlot1 = { 0x8c00e96, 0x74be, 0x4491, { 0x93, 0xaa, 0xe8, 0xad, 0x35, 0xa4, 0x91, 0x17} };
+
+const GUID EAXPROPERTYID_EAX40_FXSlot2 = { 0x1d433b88, 0xf0f6, 0x4637, { 0x91, 0x9f, 0x60, 0xe7, 0xe0, 0x6b, 0x5e, 0xdd} };
+
+const GUID EAXPROPERTYID_EAX40_FXSlot3 = { 0xefff08ea, 0xc7d8, 0x44ab, { 0x93, 0xad, 0x6d, 0xbd, 0x5f, 0x91, 0x0, 0x64} };
+
+const GUID EAXPROPERTYID_EAX40_Context = { 0x1d4870ad, 0xdef, 0x43c0, { 0xa4, 0xc, 0x52, 0x36, 0x32, 0x29, 0x63, 0x42} };
+
+const GUID EAXPROPERTYID_EAX40_Source = { 0x1b86b823, 0x22df, 0x4eae, { 0x8b, 0x3c, 0x12, 0x78, 0xce, 0x54, 0x42, 0x27} };
+
+const GUID EAX_NULL_GUID = { 0x00000000, 0x0000, 0x0000, { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } };
+
+const GUID EAX_PrimaryFXSlotID = { 0xf317866d, 0x924c, 0x450c, { 0x86, 0x1b, 0xe6, 0xda, 0xa2, 0x5e, 0x7c, 0x20} };
+
+const GUID EAX_REVERB_EFFECT = { 0xcf95c8f, 0xa3cc, 0x4849, { 0xb0, 0xb6, 0x83, 0x2e, 0xcc, 0x18, 0x22, 0xdf} };
+
+/**************************************************************************************************\
+*
+*	End of Open AL Specific
+*
+\**************************************************************************************************/
+
+// instead of clearing a whole channel_t struct, we're going to skip the MP3SlidingDecodeBuffer[] buffer in the middle...
+//
+#ifndef offsetof
+#include <stddef.h>
+#endif
+static inline void Channel_Clear(channel_t *ch)
+{
+	// memset (ch, 0, sizeof(*ch));
+
+	memset(ch,0,offsetof(channel_t,MP3SlidingDecodeBuffer));
+
+	byte *const p = (byte *)ch + offsetof(channel_t,MP3SlidingDecodeBuffer) + sizeof(ch->MP3SlidingDecodeBuffer);
+
+	memset(p,0,(sizeof(*ch) - offsetof(channel_t,MP3SlidingDecodeBuffer)) - sizeof(ch->MP3SlidingDecodeBuffer));
+}
+
+// ====================================================================
+// User-setable variables
+// ====================================================================
+static void DynamicMusicInfoPrint(void)
+{
+	if (bMusic_IsDynamic)
+	{
+		// horribly lazy... ;-)
+		//
+		LPCSTR psRequestMusicState	= Music_BaseStateToString( eMusic_StateRequest );
+		LPCSTR psActualMusicState	= Music_BaseStateToString( eMusic_StateActual, qtrue );
+		if (psRequestMusicState == NULL)
+		{
+			psRequestMusicState = "<unknown>";
+		}
+		if (psActualMusicState	== NULL)
+		{
+			psActualMusicState	= "<unknown>";
+		}
+		
+		Com_Printf("( Dynamic music ON, request state: '%s'(%d), actual: '%s' (%d) )\n", psRequestMusicState, eMusic_StateRequest, psActualMusicState, eMusic_StateActual);
+	}
+	else
+	{
+		Com_Printf("( Dynamic music OFF )\n");
+	}
+}
+
+void S_SoundInfo_f(void) {	
+	Com_Printf("----- Sound Info -----\n" );
+
+	if (!s_soundStarted) {
+		Com_Printf ("sound system not started\n");
+	} else {
+		if ( s_soundMuted ) {
+			Com_Printf ("sound system is muted\n");
+		}
+
+		if (s_UseOpenAL)
+		{
+			Com_Printf("EAX 4.0 %s supported\n",s_bEAX?"is":"not");
+			Com_Printf("Eal file %s loaded\n",s_bEALFileLoaded?"is":"not");
+			Com_Printf("s_EnvironmentID = %d\n",s_EnvironmentID);
+			Com_Printf("s_bInWater = %s\n",s_bInWater?"true":"false");
+		}
+		else
+		{
+			Com_Printf("%5d stereo\n", dma.channels - 1);
+			Com_Printf("%5d samples\n", dma.samples);
+			Com_Printf("%5d samplebits\n", dma.samplebits);
+			Com_Printf("%5d submission_chunk\n", dma.submission_chunk);
+			Com_Printf("%5d speed\n", dma.speed);
+			Com_Printf("0x%x dma buffer\n", dma.buffer);
+		}
+
+		if (bMusic_IsDynamic)
+		{		
+			DynamicMusicInfoPrint();
+			Com_Printf("( Dynamic music set name: \"%s\" )\n",sInfoOnly_CurrentDynamicMusicSet);
+		}
+		else
+		{
+			if (!s_allowDynamicMusic->integer)
+			{
+				Com_Printf("( Dynamic music inhibited (s_allowDynamicMusic == 0) )\n", sMusic_BackgroundLoop );
+			}
+			if ( tMusic_Info[eBGRNDTRACK_NONDYNAMIC].s_backgroundFile )
+			{
+				Com_Printf("Background file: %s\n", sMusic_BackgroundLoop );
+			}
+			else 
+			{
+				Com_Printf("No background file.\n" );
+			}
+		}
+	}
+	S_DisplayFreeMemory();
+	Com_Printf("----------------------\n" );
+}
+
+
+
+/*
+================
+S_Init
+================
+*/
+void S_Init( void ) {
+	ALCcontext *ALCContext = NULL;
+	ALCdevice *ALCDevice = NULL;
+	ALfloat listenerPos[]={0.0,0.0,0.0};
+	ALfloat listenerVel[]={0.0,0.0,0.0};
+	ALfloat	listenerOri[]={0.0,0.0,-1.0, 0.0,1.0,0.0};
+	cvar_t	*cv;
+	sboolean	r;
+	int i, j;
+	channel_t *ch;
+	char *mapname;
+
+	Com_Printf("\n------- sound initialization -------\n");
+
+	s_volume = Cvar_Get ("s_volume", "0.5", CVAR_ARCHIVE);
+	s_volumeVoice= Cvar_Get ("s_volumeVoice", "1.0", CVAR_ARCHIVE);
+	s_musicVolume = Cvar_Get ("s_musicvolume", "0.25", CVAR_ARCHIVE);
+	s_separation = Cvar_Get ("s_separation", "0.5", CVAR_ARCHIVE);
+	s_khz = Cvar_Get ("s_khz", "22", CVAR_ARCHIVE|CVAR_LATCH);
+	s_allowDynamicMusic = Cvar_Get ("s_allowDynamicMusic", "1", CVAR_ARCHIVE);
+	s_mixahead = Cvar_Get ("s_mixahead", "0.2", CVAR_ARCHIVE);
+
+	s_mixPreStep = Cvar_Get ("s_mixPreStep", "0.05", CVAR_ARCHIVE);
+	s_show = Cvar_Get ("s_show", "0", CVAR_CHEAT);
+	s_testsound = Cvar_Get ("s_testsound", "0", CVAR_CHEAT);
+	s_debugdynamic = Cvar_Get("s_debugdynamic","0", CVAR_CHEAT);
+	s_lip_threshold_1 = Cvar_Get("s_threshold1" , "0.5",0);
+	s_lip_threshold_2 = Cvar_Get("s_threshold2" , "4.0",0);
+	s_lip_threshold_3 = Cvar_Get("s_threshold3" , "7.0",0);
+	s_lip_threshold_4 = Cvar_Get("s_threshold4" , "8.0",0);
+
+	s_language = Cvar_Get("s_language","english",CVAR_ARCHIVE | CVAR_NORESTART);
+
+	MP3_InitCvars();
+
+	s_CPUType = Cvar_Get("sys_cpuid","",0);
+
+#if !(defined __linux__ && defined __i386__)
+#if	!id386
+#else
+	extern unsigned int uiMMXAvailable;
+	uiMMXAvailable = !!(s_CPUType->integer >= CPUID_INTEL_MMX);
+#endif
+#endif
+
+	cv = Cvar_Get ("s_initsound", "1", CVAR_ROM);
+	if ( !cv->integer ) {
+		s_soundStarted = 0;	// needed in case you set s_initsound to 0 midgame then snd_restart (div0 err otherwise later)
+		Com_Printf ("not initializing.\n");
+		Com_Printf("------------------------------------\n");
+		return;
+	}
+
+	Cmd_AddCommand("play", S_Play_f);
+	Cmd_AddCommand("music", S_Music_f);
+	Cmd_AddCommand("soundlist", S_SoundList_f);
+	Cmd_AddCommand("soundinfo", S_SoundInfo_f);
+	Cmd_AddCommand("soundstop", S_StopAllSounds);
+	Cmd_AddCommand("mp3_calcvols", S_MP3_CalcVols_f);
+	Cmd_AddCommand("s_dynamic", S_SetDynamicMusic_f);
+
+	cv = Cvar_Get("s_UseOpenAL" , "0",CVAR_ARCHIVE|CVAR_LATCH);
+	s_UseOpenAL = !!(cv->integer);
+
+
+	if (s_UseOpenAL)
+	{
+		ALCDevice = alcOpenDevice((ALubyte*)"DirectSound3D");
+		if (!ALCDevice)
+			return;
+
+		//Create context(s)
+		ALCContext = alcCreateContext(ALCDevice, NULL);
+		if (!ALCContext)
+			return;
+
+		//Set active context
+		alcMakeContextCurrent(ALCContext);		
+		if (alcGetError(ALCDevice) != ALC_NO_ERROR)
+			return;
+
+		s_soundStarted = 1;
+		s_soundMuted = qtrue;
+		s_soundtime = 0;
+		s_paintedtime = 0;
+		s_rawend = 0;
+
+		S_StopAllSounds();
+
+		S_SoundInfo_f();
+
+		// Set Listener attributes
+		alListenerfv(AL_POSITION,listenerPos);
+		alListenerfv(AL_VELOCITY,listenerVel);
+		alListenerfv(AL_ORIENTATION,listenerOri);
+
+		InitEAXManager();
+
+		memset(s_channels, 0, sizeof(s_channels));
+
+		s_numChannels = 0;
+
+		// Create as many AL Sources (up to Max) as possible
+		for (i = 0; i < MAX_CHANNELS; i++)
+		{
+			alGenSources(1, &s_channels[i].alSource); // &g_Sources[i]);
+			if (alGetError() != AL_NO_ERROR)
+			{
+				// Reached limit of sources
+				break;
+			}
+			alSourcef(s_channels[i].alSource, AL_REFERENCE_DISTANCE, DEFAULT_REF_DISTANCE);
+			if (alGetError() != AL_NO_ERROR)
+			{
+				break;
+			}
+
+			// Sources / Channels are not sending to any Slots (other than the Listener / Primary FX Slot)
+			s_channels[i].lSlotID = -1;
+
+			s_numChannels++;
+		}
+
+		// Generate AL Buffers for streaming audio playback (used for MP3s)
+		ch = s_channels + 1;
+		for (i = 1; i < s_numChannels; i++, ch++)
+		{
+			for (j = 0; j < NUM_STREAMING_BUFFERS; j++)
+			{
+				alGenBuffers(1, &(ch->buffers[j].BufferID));
+				ch->buffers[j].Status = UNQUEUED;
+				ch->buffers[j].Data = (char *)Z_Malloc(STREAMING_BUFFER_SIZE, TAG_SND_RAWDATA, qfalse);
+			}
+		}
+
+		// clear out the lip synching override array
+		memset(s_entityWavVol, 0, sizeof(s_entityWavVol));
+
+		// These aren't really relevant for Open AL, but for completeness ...
+		dma.speed = 22050;
+		dma.channels = 2;
+		dma.samplebits = 16;
+		dma.samples = 0;
+		dma.submission_chunk = 0;
+		dma.buffer = NULL;
+
+		// Clamp sound volumes between 0.0f and 1.0f (just in case they aren't already)
+		if (s_volume->value < 0.f)
+			s_volume->value = 0.f;
+		if (s_volume->value > 1.f)
+			s_volume->value = 1.f;
+
+		if (s_volumeVoice->value < 0.f)
+			s_volumeVoice->value = 0.f;
+		if (s_volumeVoice->value > 1.f)
+			s_volumeVoice->value = 1.f;
+
+		if (s_musicVolume->value < 0.f)
+			s_musicVolume->value = 0.f;
+		if (s_musicVolume->value > 1.f)
+			s_musicVolume->value = 1.f;
+		
+		// s_init could be called in game, if so there may be an .eal file 
+		// for this level
+
+		mapname = Cvar_VariableString( "mapname" );
+		EALFileInit(mapname);
+
+	}
+	else
+	{
+		r = SNDDMA_Init();
+
+		if ( r ) {
+			s_soundStarted = 1;
+			s_soundMuted = qtrue;
+	//		s_numSfx = 0;	// do NOT do this here now!!!
+
+			s_soundtime = 0;
+			s_paintedtime = 0;
+
+			S_StopAllSounds ();
+
+			S_SoundInfo_f();
+		}
+	}
+
+	Com_Printf("------------------------------------\n");
+
+	Com_Printf("\n--- ambient sound initialization ---\n");
+
+	AS_Init();
+}
+
+// only called from snd_restart. QA request...
+//
+int RE_RegisterMedia_GetLevel(void);
+void S_ReloadAllUsedSounds(void)
+{
+	if (s_soundStarted && !s_soundMuted )
+	{
+		// new bit, reload all soundsthat are used on the current level...
+		//
+		for (int i=1 ; i < s_numSfx ; i++)	// start @ 1 to skip freeing default sound
+		{
+			sfx_t *sfx = &s_knownSfx[i];
+
+			if (!sfx->bInMemory && !sfx->bDefaultSound && sfx->iLastLevelUsedOn == RE_RegisterMedia_GetLevel()){
+				S_memoryLoad(sfx);
+			}
+		}
+	}
+}
+
+// =======================================================================
+// Shutdown sound engine
+// =======================================================================
+
+void S_Shutdown( void )
+{
+	ALCcontext	*ALCContext;
+	ALCdevice	*ALCDevice;
+	channel_t	*ch;
+	int			i, j;
+
+	if ( !s_soundStarted ) {
+		return;
+	}
+
+	S_FreeAllSFXMem();
+	S_UnCacheDynamicMusic();
+
+	if (s_UseOpenAL)
+	{
+		// Release all the AL Sources (including Music channel (Source 0))
+		for (i = 0; i < s_numChannels; i++)
+		{
+			alDeleteSources(1, &(s_channels[i].alSource));
+		}
+
+		// Release Streaming AL Buffers
+		ch = s_channels + 1;
+		for (i = 1; i < s_numChannels; i++, ch++)
+		{
+			for (j = 0; j < NUM_STREAMING_BUFFERS; j++)
+			{
+				alDeleteBuffers(1, &(ch->buffers[j].BufferID));
+				ch->buffers[j].BufferID = 0;
+				ch->buffers[j].Status = UNQUEUED;
+				if (ch->buffers[j].Data)
+				{
+					Z_Free(ch->buffers[j].Data);
+					ch->buffers[j].Data = NULL;
+				}
+			}
+		}
+
+		// Get active context
+		ALCContext = alcGetCurrentContext();
+		// Get device for active context
+		ALCDevice = alcGetContextsDevice(ALCContext);
+		// Release context(s)
+		alcDestroyContext(ALCContext);
+		// Close device
+		alcCloseDevice(ALCDevice);
+
+		ReleaseEAXManager();
+
+		s_numChannels = 0;
+
+	}
+	else
+	{
+		SNDDMA_Shutdown();
+	}
+
+	s_soundStarted = 0;
+
+	Cmd_RemoveCommand("play");
+	Cmd_RemoveCommand("music");
+	Cmd_RemoveCommand("stopsound");
+	Cmd_RemoveCommand("soundlist");
+	Cmd_RemoveCommand("soundinfo");
+	Cmd_RemoveCommand("soundstop");
+	Cmd_RemoveCommand("mp3_calcvols");
+	Cmd_RemoveCommand("s_dynamic");
+	AS_Free();
+}
+
+
+
+/*
+	Mutes / Unmutes all OpenAL sound
+*/
+void S_AL_MuteAllSounds(sboolean bMute)
+{
+     if (!s_soundStarted)
+          return;
+
+     if (!s_UseOpenAL)
+          return;
+
+     if (bMute)
+     {
+          alListenerf(AL_GAIN, 0.0f);
+     }
+     else
+     {
+          alListenerf(AL_GAIN, 1.0f);
+     }
+}
+
+
+
+
+
+// =======================================================================
+// Load a sound
+// =======================================================================
+/*
+================
+return a hash value for the sfx name
+================
+*/
+static long S_HashSFXName(const char *name) {
+	int		i;
+	long	hash;
+	char	letter;
+
+	hash = 0;
+	i = 0;
+	while (name[i] != '\0') {
+		letter = tolower(name[i]);
+		if (letter =='.') break;				// don't include extension
+		if (letter =='\\') letter = '/';		// damn path names
+		hash+=(long)(letter)*(i+119);
+		i++;
+	}
+	hash &= (LOOP_HASH-1);
+	return hash;
+}
+
+/*
+==================
+S_FindName
+
+Will allocate a new sfx if it isn't found
+==================
+*/
+sfx_t *S_FindName( const char *name ) {
+	int		i;
+	int		hash;
+
+	sfx_t	*sfx;
+
+	if (!name) {
+		Com_Error (ERR_FATAL, "S_FindName: NULL\n");
+	}
+	if (!name[0]) {
+		Com_Error (ERR_FATAL, "S_FindName: empty name\n");
+	}
+
+	if (strlen(name) >= MAX_QPATH) {
+		Com_Error (ERR_FATAL, "Sound name too long: %s", name);
+	}
+
+	char sSoundNameNoExt[MAX_QPATH];
+	COM_StripExtension(name,sSoundNameNoExt);
+
+	hash = S_HashSFXName(sSoundNameNoExt);
+
+	sfx = sfxHash[hash];
+	// see if already loaded
+	while (sfx) {
+		if (!Q_stricmp(sfx->sSoundName, sSoundNameNoExt) ) {
+			return sfx;
+		}
+		sfx = sfx->next;
+	}
+/*
+	// find a free sfx
+	for (i=0 ; i < s_numSfx ; i++) {
+		if (!s_knownSfx[i].soundName[0]) {
+			break;
+		}
+	}
+*/
+	i = s_numSfx;	//we don't clear the soundName after failed loads any more, so it'll always be the last entry
+		
+	if (s_numSfx == MAX_SFX) 
+	{
+		// ok, no sfx's free, but are there any with defaultSound set? (which the registering ent will never
+		//	see because he gets zero returned if it's default...)
+		//
+		for (i=0 ; i < s_numSfx ; i++) {
+			if (s_knownSfx[i].bDefaultSound) {
+				break;
+			}
+		}
+
+		if (i==s_numSfx)
+		{	  
+			// genuinely out of handles...
+
+			// if we ever reach this, let me know and I'll either boost the array or put in a map-used-on
+			//	reference to enable sfx_t recycling. TA codebase relies on being able to have structs for every sound
+			//	used anywhere, ever, all at once (though audio bit-buffer gets recycled). SOF1 used about 1900 distinct
+			//	events, so current MAX_SFX limit should do, or only need a small boost...	-ste
+			//
+
+			Com_Error (ERR_FATAL, "S_FindName: out of sfx_t");
+		}
+	}
+	else
+	{
+		s_numSfx++;
+	}
+	
+	sfx = &s_knownSfx[i];
+	memset (sfx, 0, sizeof(*sfx));
+	Q_strncpyz(sfx->sSoundName, sSoundNameNoExt, sizeof(sfx->sSoundName));
+	strlwr(sfx->sSoundName);//force it down low
+
+	sfx->next = sfxHash[hash];
+	sfxHash[hash] = sfx;
+
+	return sfx;
+}
+
+/*
+=================
+S_DefaultSound
+=================
+*/
+void S_DefaultSound( sfx_t *sfx ) {
+	
+	int		i;
+
+	sfx->iSoundLengthInSamples	= 512;								// #samples, ie shorts
+	sfx->pSoundData				= (short *)	SND_malloc(512*2, sfx);	// ... so *2 for alloc bytes	
+	sfx->bInMemory				= qtrue;
+	
+	for ( i=0 ; i < sfx->iSoundLengthInSamples ; i++ ) 
+	{
+		sfx->pSoundData[i] = i;
+	}
+}
+
+
+/*
+===================
+S_DisableSounds
+
+Disables sounds until the next S_BeginRegistration.
+This is called when the hunk is cleared and the sounds
+are no longer valid.
+===================
+*/
+void S_DisableSounds( void ) {
+	S_StopAllSounds();
+	s_soundMuted = qtrue;
+}
+
+/*
+=====================
+S_BeginRegistration
+
+=====================
+*/
+void S_BeginRegistration( void )
+{
+	char *mapname;
+
+	s_soundMuted = qfalse;		// we can play again
+
+	// Find name of level so we can load in the appropriate EAL file
+	if (s_UseOpenAL)
+	{
+		mapname = Cvar_VariableString( "mapname" );
+		EALFileInit(mapname);
+		// clear carry crap from previous map
+		for (int i = 0; i < EAX_MAX_FXSLOTS; i++)
+		{
+			s_FXSlotInfo[i].lEnvID = -1;
+		}
+	}
+
+	if (s_numSfx == 0) {
+		SND_setup();
+
+		s_numSfx = 0;
+		memset( s_knownSfx, 0, sizeof( s_knownSfx ) );
+		memset(sfxHash, 0, sizeof(sfx_t *)*LOOP_HASH);
+
+#ifdef _DEBUG
+		sfx_t *sfx = S_FindName( "***DEFAULT***" );
+		S_DefaultSound( sfx );
+#else
+		S_RegisterSound("sound/null.wav");
+#endif
+	}
+}
+
+
+void EALFileInit(char *level)
+{
+	long		lRoom;
+	char		name[MAX_QPATH];
+	char		szEALFilename[MAX_QPATH];
+	int			i;
+
+	// If an EAL File is already unloaded, remove it
+	if (s_bEALFileLoaded)
+	{
+		UnloadEALFile();
+	}
+
+	// Reset variables
+	s_bInWater = false;
+
+	// Try and load an EAL file for the new level
+	COM_StripExtension(level, name);
+	Com_sprintf(szEALFilename, MAX_QPATH, "eagle/%s.eal", name);
+
+	s_bEALFileLoaded = LoadEALFile(szEALFilename);
+
+	if (!s_bEALFileLoaded)
+	{
+		Com_sprintf(szEALFilename, MAX_QPATH, "base/eagle/%s.eal", name);
+		s_bEALFileLoaded = LoadEALFile(szEALFilename);
+	}
+
+	if (s_bEALFileLoaded)
+	{
+		s_lLastEnvUpdate = timeGetTime();
+	}
+	else
+	{
+		// Mute reverbs if no EAL file is found
+		if ((s_bEAX)&&(s_eaxSet))
+		{
+			lRoom = -10000;
+			for (i = 0; i < s_NumFXSlots; i++)
+			{
+				s_eaxSet(&s_FXSlotInfo[i].FXSlotGuid, EAXREVERB_ROOM, NULL,
+					&lRoom, sizeof(long));
+			}
+		}
+	}
+}
+
+
+
+/*
+==================
+S_RegisterSound
+
+Creates a default buzz sound if the file can't be loaded
+==================
+*/
+sfxHandle_t	S_RegisterSound( const char *name) 
+{
+	sfx_t	*sfx;
+
+	if (!s_soundStarted) {
+		return 0;
+	}
+
+	if ( strlen( name ) >= MAX_QPATH ) {		
+		Com_Printf( S_COLOR_RED"Sound name exceeds MAX_QPATH - %s\n", name );
+		return 0;
+	}
+
+	sfx = S_FindName( name );
+
+	SND_TouchSFX(sfx);
+
+	if ( sfx->bDefaultSound )
+		return 0;
+
+	if (s_UseOpenAL)
+	{
+		if ((sfx->pSoundData) || (sfx->Buffer))
+			return sfx - s_knownSfx;
+	}
+	else
+	{
+		if ( sfx->pSoundData )
+		{
+			return sfx - s_knownSfx;
+		}
+	}
+
+	sfx->bInMemory = qfalse;
+
+	S_memoryLoad(sfx);
+
+	if ( sfx->bDefaultSound ) {
+#ifndef FINAL_BUILD
+		if (!s_shutUp)
+		{
+			Com_Printf( S_COLOR_YELLOW "WARNING: could not find %s - using default\n", sfx->sSoundName );
+		}
+#endif
+
+
+		return 0;
+	}
+
+	return sfx - s_knownSfx;
+}
+
+void S_memoryLoad(sfx_t	*sfx) 
+{
+	// load the sound file...
+	//
+	if ( !S_LoadSound( sfx ) ) 
+	{
+//		Com_Printf( S_COLOR_YELLOW "WARNING: couldn't load sound: %s\n", sfx->sSoundName );
+		sfx->bDefaultSound = qtrue;
+	}
+	sfx->bInMemory = qtrue;
+}
+
+
+
+//=============================================================================
+static sboolean S_CheckChannelStomp( int chan1, int chan2 )
+{
+	if (!s_UseOpenAL)
+	{
+		if ( chan1 == chan2 )
+		{
+			return qtrue;
+		}
+	}
+
+	if ( ( chan1 == CHAN_VOICE || chan1 == CHAN_VOICE_ATTEN || chan1 == CHAN_VOICE_GLOBAL  ) && ( chan2 == CHAN_VOICE || chan2 == CHAN_VOICE_ATTEN || chan2 == CHAN_VOICE_GLOBAL ) )
+	{
+		return qtrue;
+	}
+
+	return qfalse;
+}
+
+
+/*
+=================
+S_PickChannel
+=================
+*/
+// there were 2 versions of this, one for A3D and one normal, but the normal one wouldn't compile because
+//	it hadn't been updated for some time, so rather than risk anything weird/out of date, I just removed the 
+//	A3D lines from this version and deleted the other one. 
+//
+// If this really bothers you then feel free to play with it. -Ste.
+//
+channel_t *S_PickChannel(int entnum, int entchannel)
+{
+    int			ch_idx;
+	channel_t	*ch, *firstToDie;
+	sboolean	foundChan = qfalse;
+
+	if (s_UseOpenAL)
+		return S_OpenALPickChannel(entnum, entchannel);
+
+	if ( entchannel<0 ) {
+		Com_Error (ERR_DROP, "S_PickChannel: entchannel<0");
+	}
+
+	// Check for replacement sound, or find the best one to replace
+
+    firstToDie = &s_channels[0];
+
+	for ( int pass = 0; (pass < ((entchannel == CHAN_AUTO || entchannel == CHAN_LESS_ATTEN)?1:2)) && !foundChan; pass++ )
+	{
+		for (ch_idx = 0, ch = &s_channels[0]; ch_idx < MAX_CHANNELS ; ch_idx++, ch++ ) 
+		{
+			if ( entchannel == CHAN_AUTO || entchannel == CHAN_LESS_ATTEN || pass > 0 )
+			{//if we're on the second pass, just find the first open chan
+				if ( !ch->thesfx )
+				{//grab the first open channel
+					firstToDie = ch;
+					break;
+				}
+
+			}
+			else if ( ch->entnum == entnum && S_CheckChannelStomp( ch->entchannel, entchannel ) ) 
+			{
+				// always override sound from same entity
+				if ( s_show->integer == 1 && ch->thesfx ) {
+					Com_Printf( S_COLOR_YELLOW"...overrides %s\n", ch->thesfx->sSoundName );
+					ch->thesfx = 0;	//just to clear the next error msg
+				}
+				firstToDie = ch;
+				foundChan = qtrue;
+				break;
+			}
+
+			// don't let anything else override local player sounds
+			if ( ch->entnum == listener_number 	&& entnum != listener_number && ch->thesfx) {
+				continue;
+			}
+
+			// don't override loop sounds
+			if ( ch->loopSound ) {
+				continue;
+			}
+
+			if ( ch->startSample < firstToDie->startSample ) {
+				firstToDie = ch;
+			}
+		}
+	}
+
+	if ( s_show->integer == 1 && firstToDie->thesfx ) {
+		Com_Printf( S_COLOR_RED"***kicking %s\n", firstToDie->thesfx->sSoundName );
+	}
+
+	Channel_Clear(firstToDie);	// memset(firstToDie, 0, sizeof(*firstToDie));
+    
+	return firstToDie;
+}
+
+
+
+/*
+	For use with Open AL
+
+	Allows more than one sound of the same type to emanate from the same entity - sounds much better
+	on hardware this way esp. rapid fire modes of weapons!
+*/
+channel_t *S_OpenALPickChannel(int entnum, int entchannel)
+{
+    int			ch_idx;
+	channel_t	*ch, *ch_firstToDie;
+	bool	foundChan = false;
+	float	source_pos[3];
+
+	if ( entchannel < 0 ) 
+	{
+		Com_Error (ERR_DROP, "S_PickChannel: entchannel<0");
+	}
+
+	// Check for replacement sound, or find the best one to replace
+
+    ch_firstToDie = s_channels + 1;	// channel 0 is reserved for Music
+
+	for (ch_idx = 1, ch = s_channels + ch_idx; ch_idx < s_numChannels; ch_idx++, ch++)
+	{
+		if ( ch->entnum == entnum && S_CheckChannelStomp( ch->entchannel, entchannel ) ) 
+		{
+			// always override sound from same entity
+			if ( s_show->integer == 1 && ch->thesfx ) {
+				Com_Printf( S_COLOR_YELLOW"...overrides %s\n", ch->thesfx->sSoundName );
+				ch->thesfx = 0;	//just to clear the next error msg
+			}
+			ch_firstToDie = ch;
+			foundChan = true;
+			break;
+		}
+	}
+
+	if (!foundChan)
+	for (ch_idx = 1, ch = s_channels + ch_idx; ch_idx < s_numChannels; ch_idx++, ch++)
+	{
+		// See if the channel is free
+		if (!ch->thesfx)
+		{
+			ch_firstToDie = ch;
+			foundChan = true;
+			break;
+		}
+	}
+
+	if (!foundChan)
+	{
+		for (ch_idx = 1, ch = s_channels + ch_idx; ch_idx < s_numChannels; ch_idx++, ch++)
+		{
+			if (	(ch->entnum == entnum) && (ch->entchannel == entchannel) && (ch->entchannel != CHAN_AMBIENT)
+				 && (ch->entnum != listener_number) ) 
+			{
+				// Same entity and same type of sound effect (entchannel)
+				ch_firstToDie = ch;
+				foundChan = true;
+				break;
+			}
+		}
+	}
+
+	int longestDist;
+	int dist;
+
+	if (!foundChan)
+	{
+		// Find sound effect furthest from listener
+		ch = s_channels + 1;
+
+		if (ch->fixed_origin)
+		{
+			// Convert to Open AL co-ordinates
+			source_pos[0] = ch->origin[0];
+			source_pos[1] = ch->origin[2];
+			source_pos[2] = -ch->origin[1];
+
+			longestDist = ((listener_pos[0] - source_pos[0]) * (listener_pos[0] - source_pos[0])) +
+						  ((listener_pos[1] - source_pos[1]) * (listener_pos[1] - source_pos[1])) +
+						  ((listener_pos[2] - source_pos[2]) * (listener_pos[2] - source_pos[2]));
+		}
+		else
+		{
+			if (ch->entnum == listener_number)
+				longestDist = 0;
+			else
+			{
+				if (ch->bLooping)
+				{
+					// Convert to Open AL co-ordinates
+					source_pos[0] = loopSounds[ch->entnum].origin[0];
+					source_pos[1] = loopSounds[ch->entnum].origin[2];
+					source_pos[2] = -loopSounds[ch->entnum].origin[1];
+				}
+				else
+				{
+					// Convert to Open AL co-ordinates
+					source_pos[0] = s_entityPosition[ch->entnum][0];
+					source_pos[1] = s_entityPosition[ch->entnum][2];
+					source_pos[2] = -s_entityPosition[ch->entnum][1];
+				}
+
+				longestDist = ((listener_pos[0] - source_pos[0]) * (listener_pos[0] - source_pos[0])) +
+							  ((listener_pos[1] - source_pos[1]) * (listener_pos[1] - source_pos[1])) +
+							  ((listener_pos[2] - source_pos[2]) * (listener_pos[2] - source_pos[2]));
+			}
+		}
+
+		for (ch_idx = 2, ch = s_channels + ch_idx; ch_idx < s_numChannels; ch_idx++, ch++)
+		{
+			if (ch->fixed_origin)
+			{
+				// Convert to Open AL co-ordinates
+				source_pos[0] = ch->origin[0];
+				source_pos[1] = ch->origin[2];
+				source_pos[2] = -ch->origin[1];
+			
+				dist = ((listener_pos[0] - source_pos[0]) * (listener_pos[0] - source_pos[0])) +
+					   ((listener_pos[1] - source_pos[1]) * (listener_pos[1] - source_pos[1])) +
+					   ((listener_pos[2] - source_pos[2]) * (listener_pos[2] - source_pos[2]));
+			}
+			else
+			{
+				if (ch->entnum == listener_number)
+					dist = 0;
+				else
+				{
+					if (ch->bLooping)
+					{
+						// Convert to Open AL co-ordinates
+						source_pos[0] = loopSounds[ch->entnum].origin[0];
+						source_pos[1] = loopSounds[ch->entnum].origin[2];
+						source_pos[2] = -loopSounds[ch->entnum].origin[1];
+					}
+					else
+					{
+						// Convert to Open AL co-ordinates
+						source_pos[0] = s_entityPosition[ch->entnum][0];
+						source_pos[1] = s_entityPosition[ch->entnum][2];
+						source_pos[2] = -s_entityPosition[ch->entnum][1];
+					}
+
+					dist = ((listener_pos[0] - source_pos[0]) * (listener_pos[0] - source_pos[0])) +
+					       ((listener_pos[1] - source_pos[1]) * (listener_pos[1] - source_pos[1])) +
+						   ((listener_pos[2] - source_pos[2]) * (listener_pos[2] - source_pos[2]));
+				}
+			}
+
+			if (dist > longestDist)
+			{
+				longestDist = dist;
+				ch_firstToDie = ch;
+			}
+		}
+	}
+
+	if (ch_firstToDie->bPlaying)
+	{
+		if (s_show->integer == 1  && ch_firstToDie->thesfx ) 
+		{
+			Com_Printf(S_COLOR_RED"***kicking %s\n", ch_firstToDie->thesfx->sSoundName );
+		}
+
+		// Stop sound
+		alSourceStop(ch_firstToDie->alSource);
+		ch_firstToDie->bPlaying = false;
+	}
+
+	// Reset channel variables
+	memset(&ch_firstToDie->MP3StreamHeader, 0, sizeof(MP3STREAM));
+	ch_firstToDie->bLooping = false;
+	ch_firstToDie->bProcessed = false;
+	ch_firstToDie->bStreaming = false;
+	
+    return ch_firstToDie;
+}
+
+
+/*
+=================
+S_SpatializeOrigin
+
+Used for spatializing s_channels
+=================
+*/
+void S_SpatializeOrigin (const vec3_t origin, float master_vol, int *left_vol, int *right_vol, int channel)
+{
+    vec_t		dot;
+    vec_t		dist;
+    vec_t		lscale, rscale, scale;
+    vec3_t		source_vec;
+	float		dist_mult = SOUND_ATTENUATE;
+
+	// calculate stereo seperation and distance attenuation
+	VectorSubtract(origin, listener_origin, source_vec);
+
+	dist = VectorNormalize(source_vec);
+	if ( channel == CHAN_VOICE )
+	{
+		dist -= SOUND_FULLVOLUME * 3.0f;
+//		dist_mult = VOICE_ATTENUATE;	// tweak added (this fixes an NPC dialogue "in your ears" bug, but we're not sure if it'll make a bunch of others fade too early. Too close to shipping...)
+	}
+	else if ( channel == CHAN_LESS_ATTEN )
+	{
+		dist -= SOUND_FULLVOLUME * 8.0f; // maybe is too large
+	}
+	else if ( channel == CHAN_VOICE_ATTEN )
+	{
+		dist -= SOUND_FULLVOLUME * 1.35f; // used to be 0.15f, dropped off too sharply - dmv
+		dist_mult = VOICE_ATTENUATE;
+	}
+	else if ( channel == CHAN_VOICE_GLOBAL )
+	{
+		dist = -1;
+	}
+	else	// use normal attenuation.
+	{
+		dist -= SOUND_FULLVOLUME;
+	}
+	
+	if (dist < 0)
+	{
+		dist = 0;			// close enough to be at full volume
+	}
+	dist *= dist_mult;		// different attenuation levels
+
+	dot = -DotProduct(listener_axis[1], source_vec);
+
+	if (dma.channels == 1)	// || !dist_mult)
+	{ // no attenuation = no spatialization
+		rscale = SOUND_FMAXVOL;
+		lscale = SOUND_FMAXVOL;
+	}
+	else
+	{
+		//rscale = 0.5 * (1.0 + dot);
+		//lscale = 0.5 * (1.0 - dot);
+		rscale = s_separation->value + ( 1.0f - s_separation->value ) * dot;
+		lscale = s_separation->value - ( 1.0f - s_separation->value ) * dot;
+		if ( rscale < 0 ) 
+		{
+			rscale = 0;
+		}
+		if ( lscale < 0 ) 
+		{
+			lscale = 0;
+		}
+	}
+
+	// add in distance effect
+	scale = (1.0f - dist) * rscale;
+	*right_vol = (int) (master_vol * scale);
+	if (*right_vol < 0)
+	{
+		*right_vol = 0;
+	}
+
+	scale = (1.0f - dist) * lscale;
+	*left_vol = (int) (master_vol * scale);
+	if (*left_vol < 0)
+	{
+		*left_vol = 0;
+	}
+}
+
+
+// =======================================================================
+// Start a sound effect
+// =======================================================================
+
+/*
+====================
+S_StartAmbientSound
+
+Starts an ambient, 'one-shot" sound.
+====================
+*/
+
+void S_StartAmbientSound( const vec3_t origin, int entityNum, unsigned char volume, sfxHandle_t sfxHandle )
+{
+	channel_t	*ch;
+	/*const*/ sfx_t *sfx;
+
+	if ( !s_soundStarted || s_soundMuted ) {
+		return;
+	}
+	if ( !origin && ( entityNum < 0 || entityNum > MAX_GENTITIES ) )
+		Com_Error( ERR_DROP, "S_StartAmbientSound: bad entitynum %i", entityNum );
+
+	if ( sfxHandle < 0 || sfxHandle >= s_numSfx )
+		Com_Error( ERR_DROP, "S_StartAmbientSound: handle %i out of range", sfxHandle );
+
+	sfx = &s_knownSfx[ sfxHandle ];
+	if (sfx->bInMemory == qfalse){
+		S_memoryLoad(sfx);
+	}	
+	SND_TouchSFX(sfx);
+
+	if (s_UseOpenAL)
+	{
+		if (volume==0)
+			return;
+	}
+
+	if ( s_show->integer == 1 ) {
+		Com_Printf( "%i : %s on (%d) Ambient\n", s_paintedtime, sfx->sSoundName, entityNum );
+	}
+
+	// pick a channel to play on
+	ch = S_PickChannel( entityNum, CHAN_AMBIENT );
+	if (!ch) {
+		return;
+	}
+	
+	if (origin) 
+	{
+		VectorCopy (origin, ch->origin);
+		ch->fixed_origin = qtrue;
+	} 
+	else 
+	{
+		ch->fixed_origin = qfalse;
+	}
+
+	ch->master_vol = volume;
+	ch->entnum = entityNum;
+	ch->entchannel = CHAN_AMBIENT;
+	ch->thesfx = sfx;
+	ch->startSample = START_SAMPLE_IMMEDIATE;
+
+	ch->leftvol = ch->master_vol;		// these will get calced at next spatialize
+	ch->rightvol = ch->master_vol;		// unless the game isn't running
+
+	if (sfx->pMP3StreamHeader)
+	{
+		memcpy(&ch->MP3StreamHeader,sfx->pMP3StreamHeader,	sizeof(ch->MP3StreamHeader));
+		//ch->iMP3SlidingDecodeWritePos = 0; // These will be zero from the memset in S_PickChannel(), but keep them here for reference...
+		//ch->iMP3SlidingDecodeWindowPos= 0; //
+	}
+	else
+	{
+		memset(&ch->MP3StreamHeader,0,						sizeof(ch->MP3StreamHeader));
+	}
+}
+
+/*
+====================
+S_MuteSound
+
+Mutes sound on specified channel for specified entity.
+====================
+*/
+void S_MuteSound(int entityNum, int entchannel) 
+{
+	//I guess this works.
+	channel_t *ch = S_PickChannel( entityNum, entchannel );
+
+	if (!ch)
+	{
+		return;
+	}
+
+	ch->master_vol = 0;
+	ch->entnum = 0;
+	ch->entchannel = 0;
+	ch->thesfx = 0;
+	ch->startSample = 0;
+
+	ch->leftvol = 0;
+	ch->rightvol = 0;
+}
+
+/*
+====================
+S_StartSound
+
+Validates the parms and ques the sound up
+if pos is NULL, the sound will be dynamically sourced from the entity
+Entchannel 0 will never override a playing sound
+====================
+*/
+void S_StartSound(const vec3_t origin, int entityNum, int entchannel, sfxHandle_t sfxHandle ) 
+{
+	int i;
+	channel_t	*ch;
+	/*const*/ sfx_t *sfx;
+
+	if ( !s_soundStarted || s_soundMuted ) {
+		return;
+	}
+
+	if ( !origin && ( entityNum < 0 || entityNum > MAX_GENTITIES ) ) {
+		Com_Error( ERR_DROP, "S_StartSound: bad entitynum %i", entityNum );
+	}
+
+	if ( sfxHandle < 0 || sfxHandle >= s_numSfx ) {
+		Com_Error( ERR_DROP, "S_StartSound: handle %i out of range", sfxHandle );
+	}
+
+	sfx = &s_knownSfx[ sfxHandle ];
+	if (sfx->bInMemory == qfalse){
+		S_memoryLoad(sfx);
+	}
+	SND_TouchSFX(sfx);
+
+	if ( s_show->integer == 1 ) {
+		Com_Printf( "%i : %s on (%d)\n", s_paintedtime, sfx->sSoundName, entityNum );
+	}
+
+	if (s_UseOpenAL)
+	{
+		if (entchannel == CHAN_WEAPON)
+		{
+			// Check if we are playing a 'charging' sound, if so, stop it now ..
+			ch = s_channels + 1;
+			for (i = 1; i < s_numChannels; i++, ch++)
+			{
+				if ((ch->entnum == entityNum) && (ch->entchannel == CHAN_WEAPON) && (ch->thesfx) && (strstr(ch->thesfx->sSoundName, "altcharge") != NULL))
+				{
+					// Stop this sound
+					alSourceStop(ch->alSource);
+					alSourcei(ch->alSource, AL_BUFFER, NULL);
+					ch->bPlaying = false;
+					ch->thesfx = NULL;
+					break;
+				}
+			}
+		}
+		else
+		{
+			ch = s_channels + 1;
+			for (i = 1; i < s_numChannels; i++, ch++)
+			{
+				if ((ch->entnum == entityNum) && (ch->thesfx) && (strstr(ch->thesfx->sSoundName, "falling") != NULL))
+				{
+					// Stop this sound
+					alSourceStop(ch->alSource);
+					alSourcei(ch->alSource, AL_BUFFER, NULL);
+					ch->bPlaying = false;
+					ch->thesfx = NULL;
+					break;
+				}
+			}
+		}
+	}
+
+
+	// pick a channel to play on
+	
+	ch = S_PickChannel( entityNum, entchannel );
+	if (!ch) {
+		return;
+	}
+
+	if (origin) {
+		VectorCopy (origin, ch->origin);
+		ch->fixed_origin = qtrue;
+	} else {
+		ch->fixed_origin = qfalse;
+	}
+
+	ch->master_vol = SOUND_MAXVOL;	//FIXME: Um.. control?
+	ch->entnum = entityNum;
+	ch->entchannel = entchannel;
+	ch->thesfx = sfx;
+	ch->startSample = START_SAMPLE_IMMEDIATE;
+
+	ch->leftvol = ch->master_vol;		// these will get calced at next spatialize
+	ch->rightvol = ch->master_vol;		// unless the game isn't running
+
+	if (entchannel < CHAN_AMBIENT && entityNum == listener_number) {	//only do it for body sounds not local sounds
+		ch->master_vol = SOUND_MAXVOL * SOUND_FMAXVOL;	//this won't be attenuated so let it scale down
+	}
+	if ( entchannel == CHAN_VOICE || entchannel == CHAN_VOICE_ATTEN || entchannel == CHAN_VOICE_GLOBAL ) 
+	{
+		s_entityWavVol[ ch->entnum ] = -1;	//we've started the sound but it's silent for now
+	}
+
+	if (sfx->pMP3StreamHeader)
+	{
+		memcpy(&ch->MP3StreamHeader,sfx->pMP3StreamHeader,	sizeof(ch->MP3StreamHeader));
+		//ch->iMP3SlidingDecodeWritePos = 0; // These will be zero from the memset in S_PickChannel(), but keep them here for reference...
+		//ch->iMP3SlidingDecodeWindowPos= 0; //
+	}
+	else
+	{
+		memset(&ch->MP3StreamHeader,0,						sizeof(ch->MP3StreamHeader));
+	}
+}
+
+/*
+==================
+S_StartLocalSound
+==================
+*/
+void S_StartLocalSound( sfxHandle_t sfxHandle, int channelNum ) {
+	if ( !s_soundStarted || s_soundMuted ) {
+		return;
+	}
+
+	if ( sfxHandle < 0 || sfxHandle >= s_numSfx ) {
+		Com_Error( ERR_DROP, "S_StartLocalSound: handle %i out of range", sfxHandle );
+	}
+
+	S_StartSound (NULL, listener_number, channelNum, sfxHandle );
+}
+
+
+/*
+==================
+S_StartLocalLoopingSound
+==================
+*/
+void S_StartLocalLoopingSound( sfxHandle_t sfxHandle) {
+	vec3_t nullVec = {0,0,0};
+
+	if ( !s_soundStarted || s_soundMuted ) {
+		return;
+	}
+
+	if ( sfxHandle < 0 || sfxHandle >= s_numSfx ) {
+		Com_Error( ERR_DROP, "S_StartLocalLoopingSound: handle %i out of range", sfxHandle );
+	}
+
+	S_AddLoopingSound( listener_number, nullVec, nullVec, sfxHandle );
+
+}
+
+// returns length in milliseconds of supplied sound effect...  (else 0 for bad handle now)
+//
+float S_GetSampleLengthInMilliSeconds( sfxHandle_t sfxHandle)
+{
+	sfx_t *sfx;
+
+	if (!s_soundStarted)
+	{	//we have no sound, so let's just make a reasonable guess
+		return 512 * 1000;
+	}
+
+	if ( sfxHandle < 0 || sfxHandle >= s_numSfx )
+		return 0.0f;
+
+	sfx = &s_knownSfx[ sfxHandle ];
+
+	float f = (float)sfx->iSoundLengthInSamples / (float)dma.speed;
+
+	return (f * 1000);
+}
+
+
+/*
+==================
+S_ClearSoundBuffer
+
+If we are about to perform file access, clear the buffer
+so sound doesn't stutter.
+==================
+*/
+void S_ClearSoundBuffer( void ) {
+	int		clear;
+		
+	if ( !s_soundStarted || s_soundMuted ) {
+		return;
+	}
+#if 0	//this causes scripts to freak when the sounds get cut...
+	// clear all the sounds so they don't
+	// start back up after the load finishes
+	memset( s_channels, 0, sizeof( s_channels ) );
+	// clear out the lip synching override array
+	memset(s_entityWavVol, 0,sizeof(s_entityWavVol));
+#endif
+	s_rawend = 0;
+
+	if (!s_UseOpenAL)
+	{
+		if (dma.samplebits == 8)
+			clear = 0x80;
+		else
+			clear = 0;
+
+		SNDDMA_BeginPainting ();
+		if (dma.buffer)
+			memset(dma.buffer, clear, dma.samples * dma.samplebits/8);
+		SNDDMA_Submit ();
+	}
+	else
+	{
+		s_paintedtime = 0;
+		s_soundtime = 0;
+	}
+}
+
+
+// kinda kludgy way to stop a special-use sfx_t playing...
+//
+void S_CIN_StopSound(sfxHandle_t sfxHandle)
+{
+	if ( sfxHandle < 0 || sfxHandle >= s_numSfx ) {
+		Com_Error( ERR_DROP, "S_CIN_StopSound: handle %i out of range", sfxHandle );
+	}
+
+	sfx_t *sfx = &s_knownSfx[ sfxHandle ];
+	channel_t *ch = s_channels;
+	int i;
+
+	for ( i = 0; i < MAX_CHANNELS ; i++, ch++ ) 
+	{
+		if ( !ch->thesfx || (ch->leftvol<0.25 && ch->rightvol<0.25 )) {
+			continue;
+		}
+		if (ch->thesfx == sfx)
+		{
+			if (s_UseOpenAL)
+			{
+				alSourceStop(s_channels[i].alSource);
+			}
+			SND_FreeSFXMem(ch->thesfx);	// heh, may as well...
+			ch->thesfx = NULL;
+			memset(&ch->MP3StreamHeader, 0, sizeof(MP3STREAM));
+			ch->bLooping = false;
+			ch->bProcessed = false;
+			ch->bPlaying = false;
+			ch->bStreaming = false;
+			break;
+		}
+	}
+}
+
+
+/*
+==================
+S_StopAllSounds
+==================
+*/
+void S_StopSounds(void)
+{
+	int i; //, j;
+	channel_t *ch;
+
+	if ( !s_soundStarted ) {
+		return;
+	}
+
+	// stop looping sounds
+	S_ClearLoopingSounds();
+
+	// clear all the s_channels
+	if (s_UseOpenAL)
+	{
+		ch = s_channels;
+		for (i = 0; i < s_numChannels; i++, ch++)
+		{
+			alSourceStop(s_channels[i].alSource);
+			alSourcei(s_channels[i].alSource, AL_BUFFER, NULL);
+			ch->thesfx = NULL;
+			memset(&ch->MP3StreamHeader, 0, sizeof(MP3STREAM));
+			ch->bLooping = false;
+			ch->bProcessed = false;
+			ch->bPlaying = false;
+			ch->bStreaming = false;
+		}
+	}
+	else
+	{
+		memset(s_channels, 0, sizeof(s_channels));
+	}
+
+	// clear out the lip synching override array
+	memset(s_entityWavVol, 0,sizeof(s_entityWavVol));
+
+	S_ClearSoundBuffer ();
+}
+
+/*
+==================
+S_StopAllSounds
+ and music
+==================
+*/
+void S_StopAllSounds(void) {
+	if ( !s_soundStarted ) {
+		return;
+	}
+	// stop the background music
+	S_StopBackgroundTrack();
+
+	S_StopSounds();
+}
+
+/*
+==============================================================
+
+continuous looping sounds are added each frame
+
+==============================================================
+*/
+
+/*
+==================
+S_ClearLoopingSounds
+
+==================
+*/
+void S_ClearLoopingSounds( void )
+{
+	int i;
+
+	if (s_UseOpenAL)
+	{
+		for (i = 0; i < MAX_LOOP_SOUNDS; i++)
+			loopSounds[i].bProcessed = false;
+	}
+	numLoopSounds = 0;
+
+}
+
+/*
+==================
+S_StopLoopingSound
+
+Stops all active looping sounds on a specified entity.
+Sort of a slow method though, isn't there some better way?
+==================
+*/
+void S_StopLoopingSound( int entityNum )
+{
+	int i = 0;
+
+	while (i < numLoopSounds)
+	{
+		if (loopSounds[i].entnum == entityNum)
+		{
+			int x = i+1;
+			while (x < numLoopSounds)
+			{
+				memcpy(&loopSounds[x-1], &loopSounds[x], sizeof(loopSounds[x]));
+				x++;
+			}
+			numLoopSounds--;
+		}
+		i++;
+	}
+}
+
+/*
+==================
+S_AddLoopingSound
+
+Called during entity generation for a frame
+Include velocity in case I get around to doing doppler...
+==================
+*/
+void S_AddLoopingSound( int entityNum, const vec3_t origin, const vec3_t velocity, sfxHandle_t sfxHandle ) {
+	/*const*/ sfx_t *sfx;
+
+  	if ( !s_soundStarted || s_soundMuted ) {
+		return;
+	}
+	if ( numLoopSounds >= MAX_LOOP_SOUNDS ) {
+		return;
+	}
+
+	if ( sfxHandle < 0 || sfxHandle >= s_numSfx ) {
+		Com_Error( ERR_DROP, "S_AddLoopingSound: handle %i out of range", sfxHandle );
+	}
+
+	sfx = &s_knownSfx[ sfxHandle ];
+	if (sfx->bInMemory == qfalse){
+		S_memoryLoad(sfx);
+	}
+	SND_TouchSFX(sfx);
+
+	if ( !sfx->iSoundLengthInSamples ) {
+		Com_Error( ERR_DROP, "%s has length 0", sfx->sSoundName );
+	}
+	assert(!sfx->pMP3StreamHeader);
+	VectorCopy( origin, loopSounds[numLoopSounds].origin );
+	VectorCopy( velocity, loopSounds[numLoopSounds].velocity );
+	loopSounds[numLoopSounds].sfx = sfx;
+	loopSounds[numLoopSounds].volume = SOUND_MAXVOL;
+	loopSounds[numLoopSounds].entnum = entityNum;
+	numLoopSounds++;
+}
+
+
+/*
+==================
+S_AddAmbientLoopingSound
+==================
+*/
+void S_AddAmbientLoopingSound( const vec3_t origin, unsigned char volume, sfxHandle_t sfxHandle ) 
+{
+	/*const*/ sfx_t *sfx;
+
+	if ( !s_soundStarted || s_soundMuted ) {
+		return;
+	}
+	if ( numLoopSounds >= MAX_LOOP_SOUNDS ) {
+		return;
+	}
+
+	if (s_UseOpenAL)
+	{
+		if (volume == 0)
+			return;
+	}
+
+	if ( sfxHandle < 0 || sfxHandle >= s_numSfx ) {
+		Com_Error( ERR_DROP, "S_StartSound: handle %i out of range", sfxHandle );
+	}
+
+	sfx = &s_knownSfx[ sfxHandle ];
+	if (sfx->bInMemory == qfalse){
+		S_memoryLoad(sfx);
+	}
+	SND_TouchSFX(sfx);
+
+	if ( !sfx->iSoundLengthInSamples ) {
+		Com_Error( ERR_DROP, "%s has length 0", sfx->sSoundName );
+	}
+	VectorCopy( origin, loopSounds[numLoopSounds].origin );
+	loopSounds[numLoopSounds].sfx = sfx;
+	assert(!sfx->pMP3StreamHeader);
+	
+	//TODO: Calculate the distance falloff
+	loopSounds[numLoopSounds].volume = volume;
+	numLoopSounds++;
+}
+
+
+
+/*
+==================
+S_AddLoopSounds
+
+Spatialize all of the looping sounds.
+All sounds are on the same cycle, so any duplicates can just
+sum up the channel multipliers.
+==================
+*/
+void S_AddLoopSounds (void) 
+{
+	int			i, j;
+	int			left, right, left_total, right_total;
+	channel_t	*ch;
+	loopSound_t	*loop, *loop2;
+	static int	loopFrame;
+
+	loopFrame++;
+	for ( i = 0 ; i < numLoopSounds ; i++) {
+		loop = &loopSounds[i];
+		if ( loop->mergeFrame == loopFrame ) {
+			continue;	// already merged into an earlier sound
+		}
+
+		// find the total contribution of all sounds of this type
+		left_total = right_total = 0;
+
+		for ( j = i ; j < numLoopSounds ; j++) {
+			loop2 = &loopSounds[j];
+			if ( loop2->sfx != loop->sfx ) {
+				continue;
+			}
+			loop2->mergeFrame = loopFrame;	// don't check this again later
+
+			S_SpatializeOrigin( loop2->origin, loop2->volume, &left, &right, CHAN_AUTO);	//FIXME: Allow for volume change!!
+
+			left_total += left;
+			right_total += right;
+		}
+
+		if (left_total == 0 && right_total == 0)
+			continue;		// not audible
+
+		// allocate a channel
+		ch = S_PickChannel(0, 0);
+		if (!ch)
+			return;
+
+		if (left_total > SOUND_MAXVOL)
+			left_total = SOUND_MAXVOL;
+		if (right_total > SOUND_MAXVOL)
+			right_total = SOUND_MAXVOL;
+		ch->leftvol = left_total;
+		ch->rightvol = right_total;
+		ch->loopSound = qtrue;	// remove next frame
+		ch->thesfx = loop->sfx;
+
+		// you cannot use MP3 files here because they offer only streaming access, not random
+		//
+		if (loop->sfx->pMP3StreamHeader)
+		{				
+			Com_Error( ERR_DROP, "S_AddLoopSounds(): Cannot use streamed MP3 files here for random access (%s)\n",loop->sfx->sSoundName );
+		}
+		else
+		{
+			memset(&ch->MP3StreamHeader,0,						sizeof(ch->MP3StreamHeader));
+		}
+	}
+}
+
+//=============================================================================
+
+/*
+=================
+S_ByteSwapRawSamples
+
+If raw data has been loaded in little endien binary form, this must be done.
+If raw data was calculated, as with ADPCM, this should not be called.
+=================
+*/
+void S_ByteSwapRawSamples( int samples, int width, int s_channels, const byte *data ) {
+	int		i;
+
+	if ( width != 2 ) {
+		return;
+	}
+	if ( LittleShort( 256 ) == 256 ) {
+		return;
+	}
+
+	if ( s_channels == 2 ) {
+		samples <<= 1;
+	}
+	for ( i = 0 ; i < samples ; i++ ) {
+		((short *)data)[i] = LittleShort( ((short *)data)[i] );
+	}
+}
+
+
+portable_samplepair_t *S_GetRawSamplePointer() {
+	return s_rawsamples;
+}
+
+
+/*
+============
+S_RawSamples
+
+Music streaming
+============
+*/
+void S_RawSamples( int samples, int rate, int width, int s_channels, const byte *data, float volume, int bFirstOrOnlyUpdateThisFrame )
+{
+	int		i;
+	int		src, dst;
+	float	scale;
+	int		intVolume;
+
+	if ( !s_soundStarted || s_soundMuted ) {
+		return;
+	}
+
+	intVolume = 256 * volume;
+
+	if ( s_rawend < s_soundtime ) {
+		Com_DPrintf( "S_RawSamples: resetting minimum: %i < %i\n", s_rawend, s_soundtime );
+		s_rawend = s_soundtime;
+	}
+
+	scale = (float)rate / dma.speed;
+
+//Com_Printf ("%i < %i < %i\n", s_soundtime, s_paintedtime, s_rawend);
+	if (s_channels == 2 && width == 2)
+	{
+		if (scale == 1.0)
+		{	// optimized case
+			if (bFirstOrOnlyUpdateThisFrame)
+			{
+				for (i=0 ; i<samples ; i++)
+				{
+					dst = s_rawend&(MAX_RAW_SAMPLES-1);
+					s_rawend++;
+					s_rawsamples[dst].left = ((short *)data)[i*2] * intVolume;
+					s_rawsamples[dst].right = ((short *)data)[i*2+1] * intVolume;
+				}
+			}
+			else
+			{
+				for (i=0 ; i<samples ; i++)
+				{
+					dst = s_rawend&(MAX_RAW_SAMPLES-1);
+					s_rawend++;
+					s_rawsamples[dst].left  += ((short *)data)[i*2] * intVolume;
+					s_rawsamples[dst].right += ((short *)data)[i*2+1] * intVolume;
+				}
+			}
+		}
+		else
+		{
+			if (bFirstOrOnlyUpdateThisFrame)
+			{
+				for (i=0 ; ; i++)
+				{
+					src = i*scale;
+					if (src >= samples)
+						break;
+					dst = s_rawend&(MAX_RAW_SAMPLES-1);
+					s_rawend++;
+					s_rawsamples[dst].left = ((short *)data)[src*2] * intVolume;
+					s_rawsamples[dst].right = ((short *)data)[src*2+1] * intVolume;
+				}
+			}
+			else
+			{
+				for (i=0 ; ; i++)
+				{
+					src = i*scale;
+					if (src >= samples)
+						break;
+					dst = s_rawend&(MAX_RAW_SAMPLES-1);
+					s_rawend++;
+					s_rawsamples[dst].left  += ((short *)data)[src*2] * intVolume;
+					s_rawsamples[dst].right += ((short *)data)[src*2+1] * intVolume;
+				}
+			}
+		}
+	}
+	else if (s_channels == 1 && width == 2)
+	{
+		if (bFirstOrOnlyUpdateThisFrame)
+		{
+			for (i=0 ; ; i++)
+			{
+				src = i*scale;
+				if (src >= samples)
+					break;
+				dst = s_rawend&(MAX_RAW_SAMPLES-1);
+				s_rawend++;
+				s_rawsamples[dst].left = ((short *)data)[src] * intVolume;
+				s_rawsamples[dst].right = ((short *)data)[src] * intVolume;
+			}
+		}
+		else
+		{
+			for (i=0 ; ; i++)
+			{
+				src = i*scale;
+				if (src >= samples)
+					break;
+				dst = s_rawend&(MAX_RAW_SAMPLES-1);
+				s_rawend++;
+				s_rawsamples[dst].left  += ((short *)data)[src] * intVolume;
+				s_rawsamples[dst].right += ((short *)data)[src] * intVolume;
+			}
+		}
+	}
+	else if (s_channels == 2 && width == 1)
+	{
+		intVolume *= 256;
+
+		if (bFirstOrOnlyUpdateThisFrame)
+		{
+			for (i=0 ; ; i++)
+			{
+				src = i*scale;
+				if (src >= samples)
+					break;
+				dst = s_rawend&(MAX_RAW_SAMPLES-1);
+				s_rawend++;
+				s_rawsamples[dst].left = ((char *)data)[src*2] * intVolume;
+				s_rawsamples[dst].right = ((char *)data)[src*2+1] * intVolume;
+			}
+		}
+		else
+		{
+			for (i=0 ; ; i++)
+			{
+				src = i*scale;
+				if (src >= samples)
+					break;
+				dst = s_rawend&(MAX_RAW_SAMPLES-1);
+				s_rawend++;
+				s_rawsamples[dst].left  += ((char *)data)[src*2] * intVolume;
+				s_rawsamples[dst].right += ((char *)data)[src*2+1] * intVolume;
+			}
+		}
+	}
+	else if (s_channels == 1 && width == 1)
+	{
+		intVolume *= 256;
+
+		if (bFirstOrOnlyUpdateThisFrame)
+		{
+			for (i=0 ; ; i++)
+			{
+				src = i*scale;
+				if (src >= samples)
+					break;
+				dst = s_rawend&(MAX_RAW_SAMPLES-1);
+				s_rawend++;
+				s_rawsamples[dst].left = (((byte *)data)[src]-128) * intVolume;
+				s_rawsamples[dst].right = (((byte *)data)[src]-128) * intVolume;
+			}
+		}
+		else
+		{
+			for (i=0 ; ; i++)
+			{
+				src = i*scale;
+				if (src >= samples)
+					break;
+				dst = s_rawend&(MAX_RAW_SAMPLES-1);
+				s_rawend++;
+				s_rawsamples[dst].left  += (((byte *)data)[src]-128) * intVolume;
+				s_rawsamples[dst].right += (((byte *)data)[src]-128) * intVolume;
+			}
+		}
+	}
+
+	if ( s_rawend > s_soundtime + MAX_RAW_SAMPLES ) {
+		Com_DPrintf( "S_RawSamples: overflowed %i > %i\n", s_rawend, s_soundtime );
+	}
+}
+
+//=============================================================================
+
+/*
+=====================
+S_UpdateEntityPosition
+
+let the sound system know where an entity currently is
+======================
+*/
+void S_UpdateEntityPosition( int entityNum, const vec3_t origin )
+{
+	ALfloat pos[3];
+	channel_t *ch;
+	int i;
+
+	if ( entityNum < 0 || entityNum > MAX_GENTITIES ) {
+		Com_Error( ERR_DROP, "S_UpdateEntityPosition: bad entitynum %i", entityNum );
+	}
+
+	if (s_UseOpenAL)
+	{
+		if (entityNum == 0)
+			return;
+
+		ch = s_channels + 1;
+		for (i = 1; i < s_numChannels; i++, ch++)
+		{
+			if ((s_channels[i].bPlaying) & (s_channels[i].entnum == entityNum) & (!s_channels[i].bLooping))
+			{
+				// Ignore position updates for CHAN_VOICE_GLOBAL
+				if (ch->entchannel != CHAN_VOICE_GLOBAL && ch->entchannel != CHAN_ANNOUNCER)
+				{
+					pos[0] = origin[0];
+					pos[1] = origin[2];
+					pos[2] = -origin[1];
+					alSourcefv(s_channels[i].alSource, AL_POSITION, pos);
+
+					UpdateEAXBuffer(ch);
+				}
+
+/*				pos[0] = origin[0];
+				pos[1] = origin[2];
+				pos[2] = -origin[1];
+				alSourcefv(s_channels[i].alSource, AL_POSITION, pos);
+	
+				if ((s_bEALFileLoaded) && !( ch->entchannel == CHAN_VOICE || ch->entchannel == CHAN_VOICE_ATTEN || ch->entchannel == CHAN_VOICE_GLOBAL ) )
+				{
+					UpdateEAXBuffer(ch);
+				}
+*/
+			}
+		}
+	}
+
+	VectorCopy( origin, s_entityPosition[entityNum] );
+}
+
+
+// Given a current wav we are playing, and our position within it, lets figure out its volume...
+//
+// (this is mostly Jake's code from EF1, which explains a lot...:-)
+//
+static int next_amplitude = 0;
+static int S_CheckAmplitude(channel_t	*ch, const unsigned int s_oldpaintedtime )
+{
+	// now, is this a cycle - or have we just started a new sample - where we should update the backup table, and write this value
+	// into the new table? or should we just take the value FROM the back up table and feed it out.
+	assert( ch->startSample != START_SAMPLE_IMMEDIATE );
+	if ( ch->startSample == s_oldpaintedtime || (next_amplitude < s_soundtime) )//(ch->startSample == START_SAMPLE_IMMEDIATE)//!s_entityWavVol_back[ch->entnum] 
+	{
+		int	sample;
+		int	sample_total = 0;
+		int	count = 0;
+		short *current_pos_s;
+//		char *current_pos_c;
+		int	offset = 0;
+
+		// if we haven't started the sample yet, we must be at the beginning
+		current_pos_s = ((short*)ch->thesfx->pSoundData);
+//		current_pos_c = ((char*)ch->thesfx->data);
+
+		//if (ch->startSample != START_SAMPLE_IMMEDIATE)
+		//{
+			// figure out where we are in the sample right now.
+			offset = s_oldpaintedtime - ch->startSample;//s_paintedtime
+			current_pos_s += offset;
+//			current_pos_c += offset;
+		//}
+		
+		// scan through 10 samples 100( at 11hz or 200 at 22hz) samples apart.
+		//
+		for (int i=0; i<10; i++)
+		{				
+			//
+			// have we run off the end?
+			if ((offset + (i*100)) > ch->thesfx->iSoundLengthInSamples)
+			{
+				break;
+			}
+//			if (ch->thesfx->width == 1)
+//			{
+//				sample = current_pos_c[i*100];
+//			}
+//			else
+			{					
+				switch (ch->thesfx->eSoundCompressionMethod)
+				{					
+					case ct_16:
+					{
+						sample = LittleShort(current_pos_s[i*100]);
+					}
+					break;
+
+					case ct_MP3:
+					{
+						const int iIndex = (i*100) + ((offset * /*ch->thesfx->width*/2) - ch->iMP3SlidingDecodeWindowPos);
+						const short* pwSamples = (short*) (ch->MP3SlidingDecodeBuffer + iIndex);
+
+						sample = LittleShort(*pwSamples);						
+					}
+					break;
+
+					default:			
+					{
+						assert(0);
+						sample = 0;
+					}
+					break;
+				}
+				
+//				if (sample < 0)
+//					sample = -sample;
+				sample = sample>>8;
+			}
+			// square it for better accuracy
+			sample_total += (sample * sample);
+			count++;
+		}
+		
+		// if we are already done with this sample, then its silence
+		if (!count)
+		{
+			return(0);
+		}
+		sample_total /= count;
+
+		// I hate doing this, but its the simplest way
+		if (sample_total < ch->thesfx->fVolRange * s_lip_threshold_1->value)
+		{
+		// tell the scripts that are relying on this that we are still going, but actually silent right now.
+			sample = -1;
+		}
+		else
+		if (sample_total < ch->thesfx->fVolRange * s_lip_threshold_2->value)
+		{
+			sample = 1;
+		}
+		else
+		if (sample_total < ch->thesfx->fVolRange * s_lip_threshold_3->value)
+		{
+			sample = 2;
+		}
+		else
+		if (sample_total < ch->thesfx->fVolRange * s_lip_threshold_4->value)
+		{
+			sample = 3;
+		}
+		else
+		{
+			sample = 4;
+		}
+
+//		OutputDebugString(va("Returning sample %d\n",sample));
+
+		// store away the value we got into the back up table
+		s_entityWavVol_back[ ch->entnum ] = sample;
+		return (sample);
+	}
+	// no, just get last value calculated from backup table
+	assert( s_entityWavVol_back[ch->entnum] );
+	return (s_entityWavVol_back[ ch->entnum]);
+}
+/*
+============
+S_Respatialize
+
+Change the volumes of all the playing sounds for changes in their positions
+============
+*/
+void S_Respatialize( int entityNum, const vec3_t head, vec3_t axis[3], int inwater )
+{
+	EAXOCCLUSIONPROPERTIES eaxOCProp;
+	EAXACTIVEFXSLOTS eaxActiveSlots;
+	unsigned int ulEnvironment;
+	int			i;
+	channel_t	*ch;
+	vec3_t		origin;
+
+	if ( !s_soundStarted || s_soundMuted ) {
+		return; 
+	}
+
+	if (s_UseOpenAL)
+	{
+		listener_pos[0] = head[0];
+		listener_pos[1] = head[2];
+		listener_pos[2] = -head[1];
+		alListenerfv(AL_POSITION, listener_pos);
+
+		listener_ori[0] = axis[0][0];
+		listener_ori[1] = axis[0][2];
+		listener_ori[2] = -axis[0][1];
+		listener_ori[3] = axis[2][0];
+		listener_ori[4] = axis[2][2];
+		listener_ori[5] = -axis[2][1];
+		alListenerfv(AL_ORIENTATION, listener_ori);
+
+		// Update EAX effects here
+		if (s_bEALFileLoaded)
+		{
+			// Check if the Listener is underwater
+			if (inwater)
+			{
+				// Check if we have already applied Underwater effect
+				if (!s_bInWater)
+				{
+					// New underwater fix
+					for (i = 0; i < EAX_MAX_FXSLOTS; i++)
+					{
+						s_FXSlotInfo[i].lEnvID = -1;
+					}
+
+					// Load underwater reverb effect into FX Slot 0, and set this as the Primary FX Slot
+					ulEnvironment = EAX_ENVIRONMENT_UNDERWATER;
+					s_eaxSet(&EAXPROPERTYID_EAX40_FXSlot0, EAXREVERB_ENVIRONMENT,
+						NULL, &ulEnvironment, sizeof(unsigned int));
+					s_EnvironmentID = 999;
+
+					s_eaxSet(&EAXPROPERTYID_EAX40_Context, EAXCONTEXT_PRIMARYFXSLOTID, NULL, (ALvoid*)&EAXPROPERTYID_EAX40_FXSlot0,
+						sizeof(GUID));
+
+					// Occlude all sounds into this environment, and mute all their sends to other reverbs
+					eaxOCProp.lOcclusion = -3000;
+					eaxOCProp.flOcclusionLFRatio = 0.0f;
+					eaxOCProp.flOcclusionRoomRatio = 1.37f;
+					eaxOCProp.flOcclusionDirectRatio = 1.0f;
+
+					eaxActiveSlots.guidActiveFXSlots[0] = EAX_NULL_GUID;
+					eaxActiveSlots.guidActiveFXSlots[1] = EAX_PrimaryFXSlotID;
+
+					ch = s_channels + 1;
+					for (i = 1; i < s_numChannels; i++, ch++)
+					{
+						// New underwater fix
+						s_channels[i].lSlotID = -1;
+
+						s_eaxSet(&EAXPROPERTYID_EAX40_Source, EAXSOURCE_OCCLUSIONPARAMETERS,
+							ch->alSource, &eaxOCProp, sizeof(EAXOCCLUSIONPROPERTIES));
+
+						s_eaxSet(&EAXPROPERTYID_EAX40_Source, EAXSOURCE_ACTIVEFXSLOTID, ch->alSource,
+							&eaxActiveSlots, 2*sizeof(GUID));
+					}
+
+					s_bInWater = true;
+				}
+			}
+			else
+			{
+				// Not underwater ... check if the underwater effect is still present
+				if (s_bInWater)
+				{
+					s_bInWater = false;
+
+					// Remove underwater Reverb effect, and reset Occlusion / Obstruction amount on all Sources
+					UpdateEAXListener();
+
+					ch = s_channels + 1;
+					for (i = 1; i < s_numChannels; i++, ch++)
+					{
+						UpdateEAXBuffer(ch);
+					}
+				}
+				else
+				{
+					UpdateEAXListener();
+				}
+			}
+		}
+	}
+	else
+	{
+		listener_number = entityNum;
+		VectorCopy(head, listener_origin);
+		VectorCopy(axis[0], listener_axis[0]);
+		VectorCopy(axis[1], listener_axis[1]);
+		VectorCopy(axis[2], listener_axis[2]);
+
+		// update spatialization for dynamic sounds	
+		ch = s_channels;
+		for ( i = 0 ; i < MAX_CHANNELS ; i++, ch++ ) {
+			if ( !ch->thesfx ) {
+				continue;
+			}
+			if ( ch->loopSound ) {	// loopSounds are regenerated fresh each frame
+				Channel_Clear(ch);	// memset (ch, 0, sizeof(*ch));
+				continue;
+			}
+
+			// anything coming from the view entity will always be full volume
+			if (ch->entnum == listener_number) {
+				ch->leftvol = ch->master_vol;
+				ch->rightvol = ch->master_vol;
+			} else {
+				if (ch->fixed_origin) {
+					VectorCopy( ch->origin, origin );
+				} else {
+					VectorCopy( s_entityPosition[ ch->entnum ], origin );
+				}
+
+				S_SpatializeOrigin (origin, (float)ch->master_vol, &ch->leftvol, &ch->rightvol, ch->entchannel);
+			}
+
+			//NOTE: Made it so that voice sounds keep playing, even out of range
+			//		so that tasks waiting for sound completion keep proper timing
+			if ( !( ch->entchannel == CHAN_VOICE || ch->entchannel == CHAN_VOICE_ATTEN || ch->entchannel == CHAN_VOICE_GLOBAL ) && !ch->leftvol && !ch->rightvol ) {
+				Channel_Clear(ch);	// memset (ch, 0, sizeof(*ch));
+				continue;
+			}
+		}
+
+		// add loopsounds
+		S_AddLoopSounds ();
+	}
+
+	return;
+}
+
+
+/*
+========================
+S_ScanChannelStarts
+
+Returns qtrue if any new sounds were started since the last mix
+========================
+*/
+sboolean S_ScanChannelStarts( void ) {
+	channel_t		*ch;
+	int				i;
+	sboolean		newSamples;
+
+	newSamples = qfalse;
+	ch = s_channels;
+	for (i=0; i<MAX_CHANNELS ; i++, ch++) {
+		if ( !ch->thesfx ) {
+			continue;
+		}
+		if ( ch->loopSound ) {
+			continue;
+		}
+
+		// if this channel was just started this frame,
+		// set the sample count to it begins mixing
+		// into the very first sample
+		if ( ch->startSample == START_SAMPLE_IMMEDIATE ) {
+			ch->startSample = s_paintedtime;
+			newSamples = qtrue;
+			continue;
+		}
+
+		// if it is completely finished by now, clear it
+		if ( ch->startSample + ch->thesfx->iSoundLengthInSamples <= s_paintedtime ) {
+			ch->thesfx = NULL;
+			continue;
+		}
+	}
+
+	return newSamples;
+}
+
+// this is now called AFTER the DMA painting, since it's only the painter calls that cause the MP3s to be unpacked,
+//	and therefore to have data readable by the lip-sync volume calc code.
+//
+void S_DoLipSynchs( const unsigned s_oldpaintedtime )
+{
+	channel_t		*ch;
+	int				i;
+	sboolean		newSamples;
+
+	// clear out the lip synching override array for this frame
+	memset(s_entityWavVol, 0,(MAX_GENTITIES * 4));
+
+	newSamples = qfalse;
+	ch = s_channels;
+	for (i=0; i<MAX_CHANNELS ; i++, ch++) {
+		if ( !ch->thesfx ) {
+			continue;
+		}
+		if ( ch->loopSound ) {
+			continue;
+		}
+
+		// if we are playing a sample that should override the lip texture on its owning model, lets figure out
+		// what the amplitude is, stick it in a table, then return it 
+		if ( ch->entchannel == CHAN_VOICE || ch->entchannel == CHAN_VOICE_ATTEN || ch->entchannel == CHAN_VOICE_GLOBAL )
+		{
+			// go away and work out amplitude for this sound we are playing right now.
+			s_entityWavVol[ ch->entnum ] = S_CheckAmplitude( ch, s_oldpaintedtime );
+			if ( s_show->integer == 3 ) {
+				Com_Printf( "(%i)%i %s vol = %i\n", ch->entnum, i, ch->thesfx->sSoundName, s_entityWavVol[ ch->entnum ] );
+			}
+		}
+	}
+
+	if (next_amplitude < s_soundtime)	{
+		next_amplitude = s_soundtime + 800;
+	}
+}
+
+/*
+============
+S_Update
+
+Called once each time through the main loop
+============
+*/
+void S_Update( void ) {
+	int			i;
+	int			total;
+	channel_t	*ch;
+
+	if ( !s_soundStarted || s_soundMuted ) {
+		return;
+	}
+
+	//
+	// debugging output
+	//
+	if ( s_show->integer == 2 ) {
+		total = 0;
+		int totalMeg =0;
+		ch = s_channels;
+		for (i=0 ; i<MAX_CHANNELS; i++, ch++) {
+			if (ch->thesfx && (ch->leftvol || ch->rightvol) ) {				
+				Com_Printf ("(%i) %3i %3i %s\n", ch->entnum, ch->leftvol, ch->rightvol, ch->thesfx->sSoundName);
+				total++;
+				totalMeg += Z_Size(ch->thesfx->pSoundData);
+				if (ch->thesfx->pMP3StreamHeader)
+				{
+					totalMeg += sizeof(*ch->thesfx->pMP3StreamHeader);
+				}
+			}
+		}
+		
+		if (total)
+			Com_Printf ("----(%i)---- painted: %i, SND %.2fMB\n", total, s_paintedtime, totalMeg/1024.0f/1024.0f);
+	}
+
+	// The Open AL code, handles background music in the S_UpdateRawSamples function
+	if (!s_UseOpenAL)
+	{
+		// add raw data from streamed samples
+		S_UpdateBackgroundTrack();
+	}
+
+	// mix some sound
+	S_Update_();
+}
+
+void S_GetSoundtime(void)
+{
+	int		samplepos;
+	static	int		buffers;
+	static	int		oldsamplepos;
+	int		fullsamples;
+	
+	fullsamples = dma.samples / dma.channels;
+
+	// it is possible to miscount buffers if it has wrapped twice between
+	// calls to S_Update.  Oh well.
+	samplepos = SNDDMA_GetDMAPos();
+	if (samplepos < oldsamplepos)
+	{
+		buffers++;					// buffer wrapped
+		
+		if (s_paintedtime > 0x40000000)
+		{	// time to chop things off to avoid 32 bit limits
+			buffers = 0;
+			s_paintedtime = fullsamples;
+			S_StopAllSounds ();
+		}
+	}
+	oldsamplepos = samplepos;
+
+	s_soundtime = buffers*fullsamples + samplepos/dma.channels;
+
+#if 0
+// check to make sure that we haven't overshot
+	if (s_paintedtime < s_soundtime)
+	{
+		Com_DPrintf ("S_Update_ : overflow\n");
+		s_paintedtime = s_soundtime;
+	}
+#endif
+
+	if ( dma.submission_chunk < 256 ) {
+		s_paintedtime = (int)(s_soundtime + s_mixPreStep->value * dma.speed);
+	} else {
+		s_paintedtime = s_soundtime + dma.submission_chunk;
+	}
+}
+
+
+void S_Update_(void) {
+	unsigned        endtime;
+	int				samps;
+	channel_t		*ch;
+	int i,j;
+	int			source;
+	float		pos[3];
+#ifdef _DEBUG
+	char szString[256];
+#endif
+
+	if ( !s_soundStarted || s_soundMuted ) {
+		return;
+	}
+
+	if (s_UseOpenAL)
+	{
+		UpdateSingleShotSounds();
+
+		ch = s_channels + 1;
+		for ( i = 1; i < MAX_CHANNELS ; i++, ch++ )
+		{	
+			if ( !ch->thesfx || (ch->bPlaying))
+				continue;
+
+			source = ch - s_channels;
+
+			if (ch->entchannel == CHAN_VOICE_GLOBAL || ch->entchannel == CHAN_ANNOUNCER)
+			{
+				// Always play these sounds at 0,0,-1 (in front of listener)
+				pos[0] = 0.0f;
+				pos[1] = 0.0f;
+				pos[2] = -1.0f;
+
+				alSourcefv(s_channels[source].alSource, AL_POSITION, pos);
+				alSourcei(s_channels[source].alSource, AL_LOOPING, AL_FALSE);
+				alSourcei(s_channels[source].alSource, AL_SOURCE_RELATIVE, AL_TRUE);
+				if (ch->entchannel == CHAN_ANNOUNCER)
+				{
+					alSourcef(s_channels[source].alSource, AL_GAIN, ((float)(ch->master_vol) * s_volume->value) / 255.0f);
+				}
+				else
+				{
+					alSourcef(s_channels[source].alSource, AL_GAIN, ((float)(ch->master_vol) * s_volumeVoice->value) / 255.0f);
+				}
+			}
+			else
+			{
+				// Get position of source
+				if (ch->fixed_origin)
+				{
+					pos[0] = ch->origin[0];
+					pos[1] = ch->origin[2];
+					pos[2] = -ch->origin[1];
+					alSourcei(s_channels[source].alSource, AL_SOURCE_RELATIVE, AL_FALSE);
+				}
+				else
+				{
+					if (ch->entnum == listener_number)
+					{
+						pos[0] = 0.0f;
+						pos[1] = 0.0f;
+						pos[2] = 0.0f;
+						alSourcei(s_channels[source].alSource, AL_SOURCE_RELATIVE, AL_TRUE);
+					}
+					else
+					{
+						// Get position of Entity
+						if (ch->bLooping)
+						{
+							pos[0] = loopSounds[ ch->entnum ].origin[0];
+							pos[1] = loopSounds[ ch->entnum ].origin[2];
+							pos[2] = -loopSounds[ ch->entnum ].origin[1];
+						}
+						else
+						{
+							pos[0] = s_entityPosition[ch->entnum][0];
+							pos[1] = s_entityPosition[ch->entnum][2];
+							pos[2] = -s_entityPosition[ch->entnum][1];
+						}
+						alSourcei(s_channels[source].alSource, AL_SOURCE_RELATIVE, AL_FALSE);
+					}
+				}
+		
+				alSourcefv(s_channels[source].alSource, AL_POSITION, pos);
+				alSourcei(s_channels[source].alSource, AL_LOOPING, AL_FALSE);
+
+				if (ch->entchannel == CHAN_VOICE)
+				{
+					// Reduced fall-off (Large Reference Distance), affected by Voice Volume
+					alSourcef(s_channels[source].alSource, AL_REFERENCE_DISTANCE, DEFAULT_VOICE_REF_DISTANCE);
+					alSourcef(s_channels[source].alSource, AL_GAIN, ((float)(ch->master_vol) * s_volumeVoice->value) / 255.0f);
+				}
+				else if (ch->entchannel == CHAN_VOICE_ATTEN)
+				{
+					// Normal fall-off, affected by Voice Volume
+					alSourcef(s_channels[source].alSource, AL_REFERENCE_DISTANCE, DEFAULT_REF_DISTANCE);
+					alSourcef(s_channels[source].alSource, AL_GAIN, ((float)(ch->master_vol) * s_volumeVoice->value) / 255.0f);
+				}
+				else if (ch->entchannel == CHAN_LESS_ATTEN)
+				{
+					// Reduced fall-off, affected by Sound Effect Volume
+					alSourcef(s_channels[source].alSource, AL_REFERENCE_DISTANCE, DEFAULT_VOICE_REF_DISTANCE);
+					alSourcef(s_channels[source].alSource, AL_GAIN, ((float)(ch->master_vol) * s_volume->value) / 255.f);
+				}
+				else
+				{
+					// Normal fall-off, affect by Sound Effect Volume
+					alSourcef(s_channels[source].alSource, AL_REFERENCE_DISTANCE, DEFAULT_REF_DISTANCE);
+					alSourcef(s_channels[source].alSource, AL_GAIN, ((float)(ch->master_vol) * s_volume->value) / 255.f);
+				}
+			}
+
+			if (s_bEALFileLoaded)
+				UpdateEAXBuffer(ch);
+
+			int nBytesDecoded = 0;
+			int nTotalBytesDecoded = 0;
+			int nBuffersToAdd = 0;
+
+			if (ch->thesfx->pMP3StreamHeader)
+			{
+				memcpy(&ch->MP3StreamHeader, ch->thesfx->pMP3StreamHeader,	sizeof(ch->MP3StreamHeader));
+				ch->iMP3SlidingDecodeWritePos = 0;
+				ch->iMP3SlidingDecodeWindowPos= 0;
+
+				// Reset streaming buffers status's
+				for (i = 0; i < NUM_STREAMING_BUFFERS; i++)
+					ch->buffers[i].Status = UNQUEUED;
+
+				// Decode (STREAMING_BUFFER_SIZE / 1152) MP3 frames for each of the NUM_STREAMING_BUFFERS AL Buffers
+				for (i = 0; i < NUM_STREAMING_BUFFERS; i++)
+				{
+					nTotalBytesDecoded = 0;
+					
+					for (j = 0; j < (STREAMING_BUFFER_SIZE / 1152); j++)
+					{
+						nBytesDecoded = C_MP3Stream_Decode(&ch->MP3StreamHeader, 0);	// added ,0 ?
+						memcpy(ch->buffers[i].Data + nTotalBytesDecoded, ch->MP3StreamHeader.bDecodeBuffer, nBytesDecoded);
+						if (ch->entchannel == CHAN_VOICE || ch->entchannel == CHAN_VOICE_ATTEN || ch->entchannel == CHAN_VOICE_GLOBAL )
+						{
+							if (ch->thesfx->lipSyncData)
+							{
+								ch->thesfx->lipSyncData[(i*NUM_STREAMING_BUFFERS)+j] = S_MP3PreProcessLipSync(ch, (short *)(ch->MP3StreamHeader.bDecodeBuffer));
+							}
+							else
+							{
+#ifdef _DEBUG
+								sprintf(szString, "Missing lip-sync info. for %s\n", ch->thesfx->sSoundName);
+								OutputDebugString(szString);
+#endif
+							}
+						}
+						nTotalBytesDecoded += nBytesDecoded;
+					}
+
+					if (nTotalBytesDecoded != STREAMING_BUFFER_SIZE)
+					{
+						memset(ch->buffers[i].Data + nTotalBytesDecoded, 0, (STREAMING_BUFFER_SIZE - nTotalBytesDecoded));
+						break;
+					}
+				}
+
+				if (i >= NUM_STREAMING_BUFFERS)
+					nBuffersToAdd = NUM_STREAMING_BUFFERS;
+				else
+					nBuffersToAdd = i + 1;
+
+				// Make sure queue is empty first
+				alSourcei(s_channels[source].alSource, AL_BUFFER, NULL);
+
+				for (i = 0; i < nBuffersToAdd; i++)
+				{
+					// Copy decoded data to AL Buffer
+					alBufferData(ch->buffers[i].BufferID, AL_FORMAT_MONO16, ch->buffers[i].Data, STREAMING_BUFFER_SIZE, 22050);
+		
+					// Queue AL Buffer on Source
+					alSourceQueueBuffers(s_channels[source].alSource, 1, &(ch->buffers[i].BufferID));
+					if (alGetError() == AL_NO_ERROR)
+					{
+						ch->buffers[i].Status = QUEUED;
+					}
+				}
+
+				// Clear error state, and check for successful Play call
+				alGetError();
+				alSourcePlay(s_channels[source].alSource);
+				if (alGetError() == AL_NO_ERROR)
+					s_channels[source].bPlaying = true;
+
+				ch->bStreaming = true;
+
+				if ( ch->entchannel == CHAN_VOICE || ch->entchannel == CHAN_VOICE_ATTEN || ch->entchannel == CHAN_VOICE_GLOBAL )
+				{
+					if (ch->thesfx->lipSyncData)
+					{
+						// Record start time for Lip-syncing
+						s_channels[source].iStartTime = timeGetTime();
+
+						// Prepare lipsync value(s)
+						s_entityWavVol[ ch->entnum ] = ch->thesfx->lipSyncData[0];
+					}
+					else
+					{
+#ifdef _DEBUG
+						sprintf(szString, "Missing lip-sync info. for %s\n", ch->thesfx->sSoundName);
+						OutputDebugString(szString);
+#endif
+					}
+				}
+
+				return;
+			}
+			else
+			{
+				// Attach buffer to source
+				alSourcei(s_channels[source].alSource, AL_BUFFER, ch->thesfx->Buffer);
+
+				ch->bStreaming = false;
+
+				// Clear error state, and check for successful Play call
+				alGetError();
+				alSourcePlay(s_channels[source].alSource);
+				if (alGetError() == AL_NO_ERROR)
+					s_channels[source].bPlaying = true;
+
+				if ( ch->entchannel == CHAN_VOICE || ch->entchannel == CHAN_VOICE_ATTEN || ch->entchannel == CHAN_VOICE_GLOBAL )
+				{
+					if (ch->thesfx->lipSyncData)
+					{
+						// Record start time for Lip-syncing
+						s_channels[source].iStartTime = timeGetTime();
+
+						// Prepare lipsync value(s)
+						s_entityWavVol[ ch->entnum ] = ch->thesfx->lipSyncData[0];
+					}
+					else
+					{
+#ifdef _DEBUG
+						sprintf(szString, "Missing lip-sync info. for %s\n", ch->thesfx->sSoundName);
+						OutputDebugString(szString);
+#endif
+					}
+				}
+			}
+		}
+
+		S_SetLipSyncs();
+
+		UpdateLoopingSounds();
+
+		AL_UpdateRawSamples();
+	}
+	else
+	{
+		// Updates s_soundtime
+		S_GetSoundtime();
+
+		const unsigned s_oldpaintedtime = s_paintedtime;
+
+		// clear any sound effects that end before the current time,
+		// and start any new sounds
+		S_ScanChannelStarts();
+
+		// mix ahead of current position
+		endtime = (int)(s_soundtime + s_mixahead->value * dma.speed);
+
+		// mix to an even submission block size
+		endtime = (endtime + dma.submission_chunk-1)
+			& ~(dma.submission_chunk-1);
+
+		// never mix more than the complete buffer
+		samps = dma.samples >> (dma.channels-1);
+		if (endtime - s_soundtime > samps)
+			endtime = s_soundtime + samps;
+
+
+		SNDDMA_BeginPainting ();
+
+		S_PaintChannels (endtime);
+
+		SNDDMA_Submit ();
+
+		S_DoLipSynchs( s_oldpaintedtime );
+	}
+}
+
+
+void UpdateSingleShotSounds()
+{
+	int i, j, k;
+	ALint state;
+	ALint processed;
+	channel_t *ch;
+#ifdef _DEBUG
+	char szString[256];
+#endif
+
+	// Firstly, check if any single-shot sounds have completed, or if they need more data (for streaming Sources),
+	// and/or if any of the currently playing (non-Ambient) looping sounds need to be stopped
+	ch = s_channels + 1;
+	for (i = 1; i < s_numChannels; i++, ch++)
+	{
+		ch->bProcessed = false;
+		if ((s_channels[i].bPlaying) && (!ch->bLooping))
+		{	
+			// Single-shot
+			if (s_channels[i].bStreaming == false)
+			{
+				alGetSourcei(s_channels[i].alSource, AL_SOURCE_STATE, &state);
+				if (state == AL_STOPPED)
+				{
+					s_channels[i].thesfx = NULL;
+					s_channels[i].bPlaying = false;
+				}
+			}
+			else
+			{	
+				// Process streaming sample
+
+				// Procedure :-
+				// if more data to play
+				//		if any UNQUEUED Buffers
+				//			fill them with data
+				//		(else ?)
+				//			get number of buffers processed
+				//			fill them with data
+				//		restart playback if it has stopped (buffer underrun)
+				// else
+				//		free channel
+				
+				int nBytesDecoded;
+
+				if (ch->thesfx->pMP3StreamHeader)
+				{
+					if (ch->MP3StreamHeader.iSourceBytesRemaining == 0)
+					{
+						// Finished decoding data - if the source has finished playing then we're done
+						alGetSourcei(ch->alSource, AL_SOURCE_STATE, &state);
+						if (state == AL_STOPPED)
+						{
+							// Attach NULL buffer to Source to remove any buffers left in the queue
+							alSourcei(ch->alSource, AL_BUFFER, NULL);
+							ch->thesfx = NULL;
+							ch->bPlaying = false;
+						}
+						// Move on to next channel ...
+						continue;
+					}
+
+					// Check to see if any Buffers have been processed
+					alGetSourcei(ch->alSource, AL_BUFFERS_PROCESSED, &processed);
+
+					ALuint buffer;
+					while (processed)
+					{
+						alSourceUnqueueBuffers(ch->alSource, 1, &buffer);			
+						for (j = 0; j < NUM_STREAMING_BUFFERS; j++)
+						{
+							if (ch->buffers[j].BufferID == buffer)
+							{
+								ch->buffers[j].Status = UNQUEUED;
+								break;
+							}
+						}
+						processed--;
+					}
+
+					int nTotalBytesDecoded = 0;
+
+					for (j = 0; j < NUM_STREAMING_BUFFERS; j++)
+					{
+						if ((ch->buffers[j].Status == UNQUEUED) & (ch->MP3StreamHeader.iSourceBytesRemaining > 0))
+						{
+							nTotalBytesDecoded = 0;
+		
+							for (k = 0; k < (STREAMING_BUFFER_SIZE / 1152); k++)
+							{
+								nBytesDecoded = C_MP3Stream_Decode(&ch->MP3StreamHeader, 0); // added ,0
+
+								if (nBytesDecoded > 0)
+								{
+									memcpy(ch->buffers[j].Data + nTotalBytesDecoded, ch->MP3StreamHeader.bDecodeBuffer, nBytesDecoded);
+
+									if (ch->entchannel == CHAN_VOICE || ch->entchannel == CHAN_VOICE_ATTEN || ch->entchannel == CHAN_VOICE_GLOBAL )
+									{
+										if (ch->thesfx->lipSyncData)
+										{
+											ch->thesfx->lipSyncData[(j*4)+k] = S_MP3PreProcessLipSync(ch, (short *)(ch->buffers[j].Data));
+										}
+										else
+										{
+#ifdef _DEBUG
+											sprintf(szString, "Missing lip-sync info. for %s\n", ch->thesfx->sSoundName);
+											OutputDebugString(szString);
+#endif
+										}
+									}
+									nTotalBytesDecoded += nBytesDecoded;
+								}
+								else
+								{
+									// Make sure that iSourceBytesRemaining is 0
+									if (ch->MP3StreamHeader.iSourceBytesRemaining != 0)
+									{
+										ch->MP3StreamHeader.iSourceBytesRemaining = 0;
+										break;
+									}
+								}
+							}
+
+							if (nTotalBytesDecoded != STREAMING_BUFFER_SIZE)
+							{
+								memset(ch->buffers[j].Data + nTotalBytesDecoded, 0, (STREAMING_BUFFER_SIZE - nTotalBytesDecoded));
+
+								// Move data to buffer
+								alBufferData(ch->buffers[j].BufferID, AL_FORMAT_MONO16, ch->buffers[j].Data, STREAMING_BUFFER_SIZE, 22050);
+
+								// Queue Buffer on Source
+								alSourceQueueBuffers(ch->alSource, 1, &(ch->buffers[j].BufferID));
+
+								// Update status of Buffer
+								ch->buffers[j].Status = QUEUED;
+
+								break;
+							}
+							else
+							{
+								// Move data to buffer
+								alBufferData(ch->buffers[j].BufferID, AL_FORMAT_MONO16, ch->buffers[j].Data, STREAMING_BUFFER_SIZE, 22050);
+
+								// Queue Buffer on Source
+								alSourceQueueBuffers(ch->alSource, 1, &(ch->buffers[j].BufferID));
+								
+								// Update status of Buffer
+								ch->buffers[j].Status = QUEUED;
+							}
+						}
+					}
+
+					// Get state of Buffer
+					alGetSourcei(ch->alSource, AL_SOURCE_STATE, &state);
+					if (state != AL_PLAYING)
+					{
+						alSourcePlay(ch->alSource);
+#ifdef _DEBUG
+						char szString[256];
+						sprintf(szString,"[%d] Restarting playback of single-shot streaming MP3 sample - still have %d bytes to decode\n", i, ch->MP3StreamHeader.iSourceBytesRemaining);
+						OutputDebugString(szString);
+#endif
+					}
+				}
+			}
+		}
+	}
+}
+
+
+
+
+void UpdateLoopingSounds()
+{
+	int i,j;
+	ALuint source;
+	channel_t *ch;
+	loopSound_t	*loop;
+	float pos[3];
+
+	// First check to see if any of the looping sounds are already playing at the correct positions
+	ch = s_channels + 1;
+	for (i = 1; i < s_numChannels; i++, ch++)
+	{
+		if (ch->bLooping && s_channels[i].bPlaying)
+		{
+			for (j = 0; j < numLoopSounds; j++)
+			{
+				loop = &loopSounds[j];
+
+				// If this channel is playing the right sound effect at the right position then mark this channel and looping sound
+				// as processed
+				if ((loop->bProcessed == false) && (ch->thesfx == loop->sfx) )
+				{
+					if ( (loop->origin[0] == listener_pos[0]) && (loop->origin[1] == -listener_pos[2])
+						&& (loop->origin[2] == listener_pos[1]) )
+					{
+						// Assume that this sound is head relative
+						if (!loop->bRelative)
+						{
+							// Set position to 0,0,0 and turn on Head Relative Mode
+							float pos[3];
+							pos[0] = 0.f;
+							pos[1] = 0.f;
+							pos[2] = 0.f;
+
+							alSourcefv(s_channels[i].alSource, AL_POSITION, pos);
+							alSourcei(s_channels[i].alSource, AL_SOURCE_RELATIVE, AL_TRUE);
+							loop->bRelative = true;
+						}
+
+						// Make sure Gain is set correctly
+						if (ch->master_vol != loop->volume)
+						{
+							ch->master_vol = loop->volume;
+							alSourcef(s_channels[i].alSource, AL_GAIN, ((float)(ch->master_vol) * s_volume->value) / 255.f);
+						}
+
+						ch->bProcessed = true;
+						loop->bProcessed = true;
+					}	
+					else if ((loop->bProcessed == false) && (ch->thesfx == loop->sfx) && (!memcmp(ch->origin, loop->origin, sizeof(ch->origin))))
+					{
+						// Match !
+						ch->bProcessed = true;
+						loop->bProcessed = true;
+
+						// Make sure Gain is set correctly
+						if (ch->master_vol != loop->volume)
+						{
+							ch->master_vol = loop->volume;
+							alSourcef(s_channels[i].alSource, AL_GAIN, ((float)(ch->master_vol) * s_volume->value) / 255.f);
+						}
+
+						break;
+					}
+				}
+			}
+		}
+	}
+
+	// Next check if the correct looping sound is playing, but at the wrong position
+	ch = s_channels + 1;
+	for (i = 1; i < s_numChannels; i++, ch++)
+	{
+		if ((ch->bLooping) && (ch->bProcessed == false) && s_channels[i].bPlaying)
+		{
+			for (j = 0; j < numLoopSounds; j++)
+			{
+				loop = &loopSounds[j];
+
+				if ((loop->bProcessed == false) && (ch->thesfx == loop->sfx))
+				{
+					// Same sound - wrong position
+					ch->origin[0] = loop->origin[0];
+					ch->origin[1] = loop->origin[1];
+					ch->origin[2] = loop->origin[2];
+
+					pos[0] = loop->origin[0];
+					pos[1] = loop->origin[2];
+					pos[2] = -loop->origin[1];
+					alSourcefv(s_channels[i].alSource, AL_POSITION, pos);
+
+					ch->master_vol = loop->volume;
+					alSourcef(s_channels[i].alSource, AL_GAIN, ((float)(ch->master_vol) * s_volume->value) / 255.f);
+
+					if (s_bEALFileLoaded)
+						UpdateEAXBuffer(ch);
+
+					ch->bProcessed = true;
+					loop->bProcessed = true;
+					break;
+				}
+			}
+		}
+	}
+
+	// If any non-procesed looping sounds are still playing on a channel, they can be removed as they are no longer
+	// required
+	ch = s_channels + 1;
+	for (i = 1; i < s_numChannels; i++, ch++)
+	{
+		if (s_channels[i].bPlaying && ch->bLooping && !ch->bProcessed)
+		{
+			// Sound no longer needed
+			alSourceStop(s_channels[i].alSource);
+			ch->thesfx = NULL;
+			ch->bPlaying = false;
+		}
+	}
+
+#ifdef _DEBUG
+	alGetError();
+#endif
+	// Finally if there are any non-processed sounds left, we need to try and play them
+	for (j = 0; j < numLoopSounds; j++)
+	{
+		loop = &loopSounds[j];
+
+		if (loop->bProcessed == false)
+		{
+			ch = S_PickChannel(0,0);
+
+			ch->master_vol = loop->volume;
+			ch->entnum = loop->entnum;
+			ch->entchannel = CHAN_AMBIENT;	// Make sure this gets set to something
+			ch->thesfx = loop->sfx;
+			ch->bLooping = true;
+
+			// Check if the Source is positioned at exactly the same location as the listener
+			if ( (loop->origin[0] == listener_pos[0]) && (loop->origin[1] == -listener_pos[2])
+						&& (loop->origin[2] == listener_pos[1]) )
+			{
+				// Assume that this sound is head relative
+				loop->bRelative = true;
+				ch->origin[0] = 0.f;
+				ch->origin[1] = 0.f;
+				ch->origin[2] = 0.f;
+			}
+			else
+			{
+				ch->origin[0] = loop->origin[0];
+				ch->origin[1] = loop->origin[1];
+				ch->origin[2] = loop->origin[2];
+				loop->bRelative = false;
+			}
+			
+			ch->fixed_origin = loop->bRelative;
+			pos[0] = ch->origin[0];
+			pos[1] = ch->origin[2];
+			pos[2] = -ch->origin[1];
+
+			source = ch - s_channels;
+			alSourcei(s_channels[source].alSource, AL_BUFFER, ch->thesfx->Buffer);
+			alSourcefv(s_channels[source].alSource, AL_POSITION, pos);
+			alSourcei(s_channels[source].alSource, AL_LOOPING, AL_TRUE);
+			alSourcef(s_channels[source].alSource, AL_REFERENCE_DISTANCE, DEFAULT_REF_DISTANCE);
+			alSourcef(s_channels[source].alSource, AL_GAIN, ((float)(ch->master_vol) * s_volume->value) / 255.0f);
+			alSourcei(s_channels[source].alSource, AL_SOURCE_RELATIVE, ch->fixed_origin ? AL_TRUE : AL_FALSE);
+
+			if (s_bEALFileLoaded)
+				UpdateEAXBuffer(ch);
+
+			alGetError();
+			alSourcePlay(s_channels[source].alSource);
+			if (alGetError() == AL_NO_ERROR)
+				s_channels[source].bPlaying = true;
+		}
+	}
+}
+
+
+
+
+
+void AL_UpdateRawSamples()
+{
+	ALuint buffer;
+	ALint size;
+	ALint processed;
+	ALint state;
+	int i,j,src;
+
+#ifdef _DEBUG
+	// Clear Open AL Error
+	alGetError();
+#endif
+
+	S_UpdateBackgroundTrack();
+
+	// Find out how many buffers have been processed (played) by the Source
+	alGetSourcei(s_channels[0].alSource, AL_BUFFERS_PROCESSED, &processed);
+
+	while (processed)
+	{
+		// Unqueue each buffer, determine the length of the buffer, and then delete it
+		alSourceUnqueueBuffers(s_channels[0].alSource, 1, &buffer);
+		alGetBufferi(buffer, AL_SIZE, &size);
+		alDeleteBuffers(1, &buffer);
+		
+		// Update sg.soundtime (+= number of samples played (number of bytes / 4))
+		s_soundtime += (size >> 2);
+
+		processed--;
+	}
+
+	// Add new data to a new Buffer and queue it on the Source
+	if (s_rawend > s_paintedtime)
+	{
+		size = (s_rawend - s_paintedtime)<<2;
+		if (size > (MAX_RAW_SAMPLES<<2))
+		{
+			OutputDebugString("UpdateRawSamples :- Raw Sample buffer has overflowed !!!\n");
+			size = MAX_RAW_SAMPLES<<2;
+			s_paintedtime = s_rawend - MAX_RAW_SAMPLES;
+		}
+
+		// Copy samples from RawSamples to audio buffer (sg.rawdata)
+		for (i = s_paintedtime, j = 0; i < s_rawend; i++, j+=2)
+		{
+			src = i & (MAX_RAW_SAMPLES - 1);
+			s_rawdata[j] = (short)(s_rawsamples[src].left>>8);
+			s_rawdata[j+1] = (short)(s_rawsamples[src].right>>8);
+		}
+
+		// Need to generate more than 1 buffer for music playback
+		// iterations = 0;
+		// largestBufferSize = (MAX_RAW_SAMPLES / 4) * 4
+		// while (size)
+		//	generate a buffer
+		//	if size > largestBufferSize
+		//		copy sg.rawdata + ((iterations * largestBufferSize)>>1) to buffer
+		//		size -= largestBufferSize
+		//	else
+		//		copy remainder
+		//		size = 0
+		//	queue the buffer
+		//  iterations++;
+
+		int iterations = 0;
+		int largestBufferSize = MAX_RAW_SAMPLES;	// in bytes (== quarter of Raw Samples data)
+		while (size)
+		{
+			alGenBuffers(1, &buffer);
+
+			if (size > largestBufferSize)
+			{
+				alBufferData(buffer, AL_FORMAT_STEREO16, (char*)(s_rawdata + ((iterations * largestBufferSize)>>1)), largestBufferSize, 22050);
+				size -= largestBufferSize;
+			}
+			else
+			{
+				alBufferData(buffer, AL_FORMAT_STEREO16, (char*)(s_rawdata + ((iterations * largestBufferSize)>>1)), size, 22050);
+				size = 0;
+			}
+
+			alSourceQueueBuffers(s_channels[0].alSource, 1, &buffer);
+			iterations++;
+		}
+
+		// Update paintedtime
+		s_paintedtime = s_rawend;
+		
+		// Check that the Source is actually playing
+		alGetSourcei(s_channels[0].alSource, AL_SOURCE_STATE, &state);
+		if (state != AL_PLAYING)
+		{
+			// Stopped playing ... due to buffer underrun
+			// Unqueue any buffers still on the Source (they will be PROCESSED), and restart playback
+			alGetSourcei(s_channels[0].alSource, AL_BUFFERS_PROCESSED, &processed);
+			while (processed)
+			{
+				alSourceUnqueueBuffers(s_channels[0].alSource, 1, &buffer);
+				processed--;
+				alGetBufferi(buffer, AL_SIZE, &size);
+				alDeleteBuffers(1, &buffer);
+		
+				// Update sg.soundtime (+= number of samples played (number of bytes / 4))
+				s_soundtime += (size >> 2);
+			}
+
+#ifdef _DEBUG
+			OutputDebugString("Restarting / Starting playback of Raw Samples\n");
+#endif
+			alSourcePlay(s_channels[0].alSource);
+		}
+	}
+
+#ifdef _DEBUG
+	if (alGetError() != AL_NO_ERROR)
+		OutputDebugString("OAL Error : UpdateRawSamples\n");
+#endif
+}
+
+
+int S_MP3PreProcessLipSync(channel_t *ch, short *data)
+{
+	int i;
+	int sample;
+	int sampleTotal = 0;
+
+	for (i = 0; i < 576; i += 100)
+	{
+		sample = LittleShort(data[i]);
+		sample = sample >> 8;
+		sampleTotal += sample * sample;
+	}
+
+	sampleTotal /= 6;
+
+	if (sampleTotal < ch->thesfx->fVolRange * s_lip_threshold_1->value)
+		sample = -1;
+	else if (sampleTotal < ch->thesfx->fVolRange * s_lip_threshold_2->value)
+		sample = 1;
+	else if (sampleTotal < ch->thesfx->fVolRange * s_lip_threshold_3->value)
+		sample = 2;
+	else if (sampleTotal < ch->thesfx->fVolRange * s_lip_threshold_4->value)
+		sample = 3;
+	else
+		sample = 4;
+
+	return sample;
+}
+
+
+void S_SetLipSyncs()
+{
+	int i;
+	unsigned int samples;
+	int currentTime, timePlayed;
+	channel_t *ch;
+#ifdef _DEBUG
+	char szString[256];
+#endif
+
+	currentTime = timeGetTime();
+
+	memset(s_entityWavVol, 0, sizeof(s_entityWavVol));
+
+	ch = s_channels + 1;
+	for (i = 1; i < s_numChannels; i++, ch++)
+	{
+		if ((!ch->thesfx)||(!ch->bPlaying))
+			continue;
+		
+		if ( ch->entchannel == CHAN_VOICE || ch->entchannel == CHAN_VOICE_ATTEN || ch->entchannel == CHAN_VOICE_GLOBAL )
+		{
+			// Calculate how much time has passed since the sample was started
+			timePlayed = currentTime - ch->iStartTime;
+
+			if (ch->thesfx->eSoundCompressionMethod==ct_16)
+			{
+				// There is a new computed lip-sync value every 1000 samples - so find out how many samples
+				// have been played and lookup the value in the lip-sync table
+				samples = (timePlayed * 22050) / 1000;
+
+				if (ch->thesfx->lipSyncData == NULL)
+				{
+#ifdef _DEBUG
+					sprintf(szString, "Missing lip-sync info. for %s\n", ch->thesfx->sSoundName);
+					OutputDebugString(szString);
+#endif
+				}
+				
+				if ((ch->thesfx->lipSyncData) && (samples < ch->thesfx->iSoundLengthInSamples))
+				{
+					s_entityWavVol[ ch->entnum ] = ch->thesfx->lipSyncData[samples / 1000];
+					if ( s_show->integer == 3 ) 
+					{
+						Com_Printf( "(%i)%i %s vol = %i\n", ch->entnum, i, ch->thesfx->sSoundName, s_entityWavVol[ ch->entnum ] );
+					}
+				}
+			}
+			else
+			{
+				// MP3
+
+				// There is a new computed lip-sync value every 576 samples - so find out how many samples
+				// have been played and lookup the value in the lip-sync table
+				samples = (timePlayed * 22050) / 1000;
+
+				if (ch->thesfx->lipSyncData == NULL)
+				{
+#ifdef _DEBUG
+					sprintf(szString, "Missing lip-sync info. for %s\n", ch->thesfx->sSoundName);
+					OutputDebugString(szString);
+#endif
+				}
+
+				if ((ch->thesfx->lipSyncData) && (samples < ch->thesfx->iSoundLengthInSamples))
+				{
+					s_entityWavVol[ ch->entnum ] = ch->thesfx->lipSyncData[(samples / 576) % 16];
+
+					if ( s_show->integer == 3 ) 
+					{
+						Com_Printf( "(%i)%i %s vol = %i\n", ch->entnum, i, ch->thesfx->sSoundName, s_entityWavVol[ ch->entnum ] );
+					}
+				}
+			}
+		}
+	}
+}
+
+
+/*
+===============================================================================
+
+console functions
+
+===============================================================================
+*/
+
+static void S_Play_f( void ) {
+	int 	i;
+	sfxHandle_t	h;
+	char name[256];
+	
+	i = 1;
+	while ( i<Cmd_Argc() ) {
+		if ( !strrchr(Cmd_Argv(i), '.') ) {
+			Com_sprintf( name, sizeof(name), "%s.wav", Cmd_Argv(1) );
+		} else {
+			Q_strncpyz( name, Cmd_Argv(i), sizeof(name) );
+		}
+		h = S_RegisterSound( name );
+		if( h ) {
+			S_StartLocalSound( h, CHAN_LOCAL_SOUND );
+		}
+		i++;
+	}
+}
+
+static void S_Music_f( void ) {
+	int		c;
+
+	c = Cmd_Argc();
+
+	if ( c == 2 ) {
+		S_StartBackgroundTrack( Cmd_Argv(1), Cmd_Argv(1), qfalse );
+	} else if ( c == 3 ) {
+		S_StartBackgroundTrack( Cmd_Argv(1), Cmd_Argv(2), qfalse );		
+	} else {
+		Com_Printf ("music <musicfile> [loopfile]\n");
+		return;
+	}
+}
+
+// a debug function, but no harm to leave in...
+//
+static void S_SetDynamicMusic_f(void)
+{
+	int c = Cmd_Argc();
+
+	if ( c == 2 ) 
+	{
+		if (bMusic_IsDynamic)
+		{
+			// don't need to check existance of 'explore' or 'action' music, since music wouldn't
+			//	be counted as dynamic if either were missing, but other types are optional...
+			//
+			if (!Q_stricmp(Cmd_Argv(1),"explore"))
+			{
+				S_SetDynamicMusicState( eBGRNDTRACK_EXPLORE );
+				return;
+			}
+			else
+			if (!Q_stricmp(Cmd_Argv(1),"action"))
+			{
+				S_SetDynamicMusicState( eBGRNDTRACK_ACTION );
+				return;
+			}
+			else
+			if (!Q_stricmp(Cmd_Argv(1),"silence"))
+			{
+				S_SetDynamicMusicState( eBGRNDTRACK_SILENCE );
+				return;
+			}
+			else
+			if (!Q_stricmp(Cmd_Argv(1),"boss"))
+			{
+				if (tMusic_Info[ eBGRNDTRACK_BOSS ].bExists)
+				{
+					S_SetDynamicMusicState( eBGRNDTRACK_BOSS );
+				}
+				else
+				{
+					Com_Printf("No 'boss' music defined in current dynamic set\n");
+				}
+				return;
+			}
+			else
+			if (!Q_stricmp(Cmd_Argv(1),"death"))
+			{
+				if (tMusic_Info[ eBGRNDTRACK_DEATH ].bExists)
+				{
+					S_SetDynamicMusicState( eBGRNDTRACK_DEATH );
+				}
+				else
+				{
+					Com_Printf("No 'death' music defined in current dynamic set\n");
+				}
+				return;
+			}
+		}
+		else
+		{
+			DynamicMusicInfoPrint();	// print "inactive" string
+			return;
+		}
+	}
+
+	// show usage...
+	//
+	Com_Printf("Usage: s_dynamic <explore/action/silence/boss/death>\n");
+	DynamicMusicInfoPrint();
+}
+
+
+// this table needs to be in-sync with the typedef'd enum "SoundCompressionMethod_t"...	-ste
+//
+static const char *sSoundCompressionMethodStrings[ct_NUMBEROF] = 
+{
+	"16b",	// ct_16
+	"mp3"	// ct_MP3
+};
+void S_SoundList_f( void ) {
+	int		i;
+	sfx_t	*sfx;
+	int		size, total;
+	int		iVariantCap = -1;	// for %d-inquiry stuff
+	int		iTotalBytes = 0;
+
+	sboolean bWavOnly = qfalse;
+	sboolean bShouldBeMP3 = qfalse;
+
+	if ( Cmd_Argc() == 2 ) 
+	{
+		if (!stricmp(Cmd_Argv(1), "shouldbeMP3"))
+		{
+			bShouldBeMP3 = qtrue;
+		}
+		else
+		if (!stricmp(Cmd_Argv(1), "wavonly"))
+		{
+			bWavOnly = qtrue;
+		}
+		else
+		{
+			if (!stricmp(Cmd_Argv(1), "1"))
+			{
+				iVariantCap = 1;
+			}
+			else
+			if (!stricmp(Cmd_Argv(1), "2"))
+			{
+				iVariantCap = 2;
+			}
+			else
+			if (!stricmp(Cmd_Argv(1), "3"))
+			{
+				iVariantCap = 3;
+			}
+		}		
+	}
+	else
+	{
+		Com_Printf("( additional (mutually exclusive) options available:\n'wavonly', 'ShouldBeMP3', '1'/'2'/'3' for %%d-variant capping )\n" );
+	}
+
+
+
+	total = 0;
+
+	Com_Printf("\n");
+	Com_Printf("                    InMemory?\n");
+	Com_Printf("                    |\n");
+	Com_Printf("                    |  LevelLastUsedOn\n");
+	Com_Printf("                    |  |\n");
+	Com_Printf("                    |  |\n");
+	Com_Printf(" Slot   Smpls Type  |  |   Name\n");
+//	Com_Printf(" Slot   Smpls Type  InMem?   Name\n");
+
+	for (sfx=s_knownSfx, i=0 ; i<s_numSfx ; i++, sfx++) 
+	{
+		extern cvar_t *cv_MP3overhead;
+		sboolean bMP3DumpOverride = bShouldBeMP3 && cv_MP3overhead && !sfx->bDefaultSound && !sfx->pMP3StreamHeader && sfx->pSoundData && (Z_Size(sfx->pSoundData) > cv_MP3overhead->integer);
+
+		if (bMP3DumpOverride || (!bShouldBeMP3 && (!bWavOnly || sfx->eSoundCompressionMethod == ct_16)))
+		{
+			sboolean bDumpThisOne = qtrue;
+			if (iVariantCap >= 1 && iVariantCap <= 3)
+			{
+				int iStrLen = strlen(sfx->sSoundName);
+				if (iStrLen > 2)	// crash-safety, jic.
+				{
+					char c  = sfx->sSoundName[iStrLen-1];
+					char c2 = sfx->sSoundName[iStrLen-2];
+					if (!isdigit(c2) // quick-avoid of stuff like "pain75"
+						&& isdigit(c) && atoi(va("%c",c)) > iVariantCap)
+					{
+						// need to see if this %d-variant should be omitted, in other words if there's a %1 version then skip this...
+						//
+						char sFindName[MAX_QPATH];
+						Q_strncpyz(sFindName,sfx->sSoundName,sizeof(sFindName));
+						sFindName[iStrLen-1] = '1';
+						int i2;
+						sfx_t *sfx2;
+						for (sfx2 = s_knownSfx, i2=0 ; i2<s_numSfx ; i2++, sfx2++) 
+						{
+							if (!stricmp(sFindName,sfx2->sSoundName))
+							{
+								bDumpThisOne = qfalse;	// found a %1-variant of this, so use variant capping and ignore this sfx_t
+								break;
+							}
+						}
+					}
+				}
+			}
+
+			size = sfx->iSoundLengthInSamples;
+			if (sfx->bDefaultSound)
+			{
+				Com_Printf("%5d Missing file: \"%s\"\n", i, sfx->sSoundName );
+			}
+			else
+			{
+				if (bDumpThisOne)
+				{
+					iTotalBytes += (sfx->bInMemory && sfx->pSoundData) ? Z_Size(sfx->pSoundData) : 0;
+					iTotalBytes += (sfx->bInMemory && sfx->pMP3StreamHeader) ? sizeof(*sfx->pMP3StreamHeader) : 0;
+					total		+=  sfx->bInMemory ? size : 0;				
+				}
+				Com_Printf("%5d %7i [%s] %s %2d %s", i, size, sSoundCompressionMethodStrings[sfx->eSoundCompressionMethod], sfx->bInMemory?"y":"n", sfx->iLastLevelUsedOn, sfx->sSoundName );
+
+				if (!bDumpThisOne)
+				{
+					Com_Printf("   ( Skipping, variant capped )");
+					//OutputDebugString(va("Variant capped: %s\n",sfx->sSoundName));
+				}
+				Com_Printf("\n");
+			}
+		}
+	}
+	Com_Printf(" Slot   Smpls Type  In? Lev  Name\n");
+
+
+	Com_Printf ("Total resident samples: %i %s ( not mem usage, see 'meminfo' ).\n", total, bWavOnly?"(WAV only)":"");
+	Com_Printf ("%d out of %d sfx_t slots used\n", s_numSfx, MAX_SFX);
+	Com_Printf ("%.2fMB bytes used when counting sfx_t->pSoundData + MP3 headers (if any)\n", (float)iTotalBytes / 1024.0f / 1024.0f);
+	S_DisplayFreeMemory();
+}
+
+
+/*
+===============================================================================
+
+background music functions
+
+===============================================================================
+*/
+
+int	FGetLittleLong( fileHandle_t f ) {
+	int		v;
+
+	FS_Read( &v, sizeof(v), f );
+
+	return LittleLong( v);
+}
+
+int	FGetLittleShort( fileHandle_t f ) {
+	short	v;
+
+	FS_Read( &v, sizeof(v), f );
+
+	return LittleShort( v);
+}
+
+// returns the length of the data in the chunk, or 0 if not found
+int S_FindWavChunk( fileHandle_t f, char *chunk ) {
+	char	name[5];
+	int		len;
+	int		r;
+
+	name[4] = 0;
+	len = 0;
+	r = FS_Read( name, 4, f );
+	if ( r != 4 ) {
+		return 0;
+	}
+	len = FGetLittleLong( f );
+	if ( len < 0 || len > 0xfffffff ) {
+		len = 0;
+		return 0;
+	}
+	len = (len + 1 ) & ~1;		// pad to word boundary
+//	s_nextWavChunk += len + 8;
+
+	if ( strcmp( name, chunk ) ) {
+		return 0;
+	}
+	return len;
+}
+
+// fixme: need to move this into qcommon sometime?, but too much stuff altered by other people and I won't be able
+//	to compile again for ages if I check that out...
+//
+// DO NOT replace this with a call to FS_FileExists, that's for checking about writing out, and doesn't work for this.
+//
+sboolean S_FileExists( const char *psFilename )
+{
+	fileHandle_t fhTemp;
+
+	FS_FOpenFileRead (psFilename, &fhTemp, qtrue);	// qtrue so I can fclose the handle without closing a PAK
+	if (!fhTemp) 
+		return qfalse;
+	
+	FS_FCloseFile(fhTemp);
+	return qtrue;
+}
+
+// some stuff for streaming MP3 files from disk (not pleasant, but nothing about MP3 is, other than compression ratios...)
+//
+static void MP3MusicStream_Reset(MusicInfo_t *pMusicInfo)
+{
+	pMusicInfo->iMP3MusicStream_DiskReadPos		= 0;
+	pMusicInfo->iMP3MusicStream_DiskWindowPos	= 0;
+}
+
+//
+// return is where the decoder should read from...
+//
+static byte *MP3MusicStream_ReadFromDisk(MusicInfo_t *pMusicInfo, int iReadOffset, int iReadBytesNeeded)
+{
+	if (iReadOffset < pMusicInfo->iMP3MusicStream_DiskWindowPos)
+	{
+		assert(0);											// should never happen
+		return pMusicInfo->byMP3MusicStream_DiskBuffer;		// ...but return something safe anyway
+	}
+
+	while (iReadOffset + iReadBytesNeeded > pMusicInfo->iMP3MusicStream_DiskReadPos)
+	{
+		int iBytesRead = FS_Read( pMusicInfo->byMP3MusicStream_DiskBuffer + (pMusicInfo->iMP3MusicStream_DiskReadPos - pMusicInfo->iMP3MusicStream_DiskWindowPos), iMP3MusicStream_DiskBytesToRead, pMusicInfo->s_backgroundFile );
+
+		pMusicInfo->iMP3MusicStream_DiskReadPos += iBytesRead;
+
+		if (iBytesRead != iMP3MusicStream_DiskBytesToRead)	// quietly ignore any requests to read past file end
+		{
+			break;		// we need to do this because the disk read code can't know how much source data we need to
+						//	read for a given number of requested output bytes, so we'll always be asking for too many
+		}
+	}
+
+	// if reached halfway point in buffer (approx 20k), backscroll it...
+	//
+	if (pMusicInfo->iMP3MusicStream_DiskReadPos - pMusicInfo->iMP3MusicStream_DiskWindowPos > iMP3MusicStream_DiskBufferSize/2)
+	{
+		int iMoveSrcOffset = iReadOffset - pMusicInfo->iMP3MusicStream_DiskWindowPos;		
+		int iMoveCount     = (pMusicInfo->iMP3MusicStream_DiskReadPos - pMusicInfo->iMP3MusicStream_DiskWindowPos ) - iMoveSrcOffset;
+		memmove( &pMusicInfo->byMP3MusicStream_DiskBuffer, &pMusicInfo->byMP3MusicStream_DiskBuffer[iMoveSrcOffset], iMoveCount);
+		pMusicInfo->iMP3MusicStream_DiskWindowPos += iMoveSrcOffset;
+	}
+
+	return pMusicInfo->byMP3MusicStream_DiskBuffer + (iReadOffset - pMusicInfo->iMP3MusicStream_DiskWindowPos);
+}
+
+
+// does NOT set s_rawend!...
+//
+static void S_StopBackgroundTrack_Actual( MusicInfo_t *pMusicInfo ) 
+{
+	if ( pMusicInfo->s_backgroundFile ) 
+	{
+		if ( pMusicInfo->s_backgroundFile != -1)
+		{
+			Sys_EndStreamedFile( pMusicInfo->s_backgroundFile );
+			FS_FCloseFile( pMusicInfo->s_backgroundFile );
+		}
+		pMusicInfo->s_backgroundFile = 0;	
+	}
+}
+
+static void FreeMusic( MusicInfo_t *pMusicInfo )
+{
+	if (pMusicInfo->pLoadedData)
+	{
+		Z_Free(pMusicInfo->pLoadedData);
+		pMusicInfo->pLoadedData		= NULL;		// these two MUST be kept as valid/invalid together
+		pMusicInfo->sLoadedDataName[0]= '\0';	// 
+		pMusicInfo->iLoadedDataLen	= 0;
+	}
+}
+
+// called only by snd_shutdown (from snd_restart or app exit)
+//
+void S_UnCacheDynamicMusic( void )
+{
+	for (int i = eBGRNDTRACK_DATABEGIN; i != eBGRNDTRACK_DATAEND; i++)
+	{
+		FreeMusic( &tMusic_Info[i]);
+	}
+}
+
+static sboolean S_StartBackgroundTrack_Actual( MusicInfo_t *pMusicInfo, sboolean qbDynamic, const char *intro, const char *loop )
+{
+	int		len;
+	char	dump[16];
+	char	name[MAX_QPATH];
+
+	Q_strncpyz( sMusic_BackgroundLoop, loop, sizeof( sMusic_BackgroundLoop ));	
+
+	Q_strncpyz( name, intro, sizeof( name ) - 4 );	// this seems to be so that if the filename hasn't got an extension
+													//	but doesn't have the room to append on either then you'll just
+													//	get the "soft" fopen() error, rather than the ERR_DROP you'd get
+													//	if COM_DefaultExtension didn't have room to add it on.
+	COM_DefaultExtension( name, sizeof( name ), ".mp3" );
+
+	// close the background track, but DON'T reset s_rawend (or remaining music bits that haven't been output yet will be cut off)
+	//
+	S_StopBackgroundTrack_Actual( pMusicInfo );
+
+	pMusicInfo->bIsMP3 = qfalse;
+
+	if ( !intro[0] ) {
+		return qfalse;
+	}
+
+	// new bit, if file requested is not same any loaded one (if prev was in-mem), ditch it...
+	//
+	if (Q_stricmp(name, pMusicInfo->sLoadedDataName))
+	{
+		FreeMusic( pMusicInfo );
+	}
+
+	if (!Q_stricmpn(name+(strlen(name)-4),".mp3",4))
+	{
+		if (pMusicInfo->pLoadedData)
+		{				
+			pMusicInfo->s_backgroundFile = -1;
+		}
+		else
+		{
+			pMusicInfo->iLoadedDataLen = FS_FOpenFileRead( name, &pMusicInfo->s_backgroundFile, qtrue );
+		}
+
+		if (!pMusicInfo->s_backgroundFile)
+		{
+			Com_Printf( S_COLOR_RED"Couldn't open music file %s\n", name );
+			return qfalse;
+		}
+
+		MP3MusicStream_Reset( pMusicInfo );
+
+		byte *pbMP3DataSegment	= NULL;
+		int iInitialMP3ReadSize = 8192;		// fairly arbitrary, whatever size this is then the decoder is allowed to
+											// scan up to halfway of it to find floating headers, so don't make it 
+											// too small. 8k works fine.
+		sboolean bMusicSucceeded = qfalse;
+		if (qbDynamic)
+		{	
+			if (!pMusicInfo->pLoadedData)
+			{
+				pMusicInfo->pLoadedData = (byte *) Z_Malloc(pMusicInfo->iLoadedDataLen, TAG_SND_DYNAMICMUSIC, qfalse);
+
+				S_ClearSoundBuffer();
+				FS_Read(pMusicInfo->pLoadedData, pMusicInfo->iLoadedDataLen, pMusicInfo->s_backgroundFile);
+				Q_strncpyz(pMusicInfo->sLoadedDataName, name, sizeof(pMusicInfo->sLoadedDataName));
+			}
+
+			// enable the rest of the code to work as before...
+			//
+			pbMP3DataSegment	= pMusicInfo->pLoadedData;
+			iInitialMP3ReadSize = pMusicInfo->iLoadedDataLen;
+		}
+		else
+		{
+			pbMP3DataSegment = MP3MusicStream_ReadFromDisk(pMusicInfo, 0, iInitialMP3ReadSize);
+		}
+
+		if (MP3_IsValid(name, pbMP3DataSegment, iInitialMP3ReadSize, qtrue /*bStereoDesired*/))
+		{
+			// init stream struct...
+			//
+			memset(&pMusicInfo->streamMP3_Bgrnd,0,sizeof(pMusicInfo->streamMP3_Bgrnd));
+			char *psError = C_MP3Stream_DecodeInit( &pMusicInfo->streamMP3_Bgrnd, pbMP3DataSegment, pMusicInfo->iLoadedDataLen,
+													dma.speed,
+													16,		// sfx->width * 8,
+													qtrue	// bStereoDesired
+													);
+
+
+			if (psError == NULL)
+			{
+				// init sfx struct & setup the few fields I actually need...
+				//
+				memset(	   &pMusicInfo->sfxMP3_Bgrnd,0,sizeof(pMusicInfo->sfxMP3_Bgrnd));
+				//			pMusicInfo->sfxMP3_Bgrnd.width					= 2;			// read by MP3_GetSamples()
+							pMusicInfo->sfxMP3_Bgrnd.iSoundLengthInSamples	= 0x7FFFFFFF;	// max possible +ve int, since music finishes when decoder stops
+							pMusicInfo->sfxMP3_Bgrnd.pMP3StreamHeader		= &pMusicInfo->streamMP3_Bgrnd;
+				Q_strncpyz( pMusicInfo->sfxMP3_Bgrnd.sSoundName, name, sizeof(pMusicInfo->sfxMP3_Bgrnd.sSoundName) );
+
+				if (qbDynamic)
+				{
+					MP3Stream_InitPlayingTimeFields ( &pMusicInfo->streamMP3_Bgrnd, name, pbMP3DataSegment, pMusicInfo->iLoadedDataLen, qtrue);
+				}
+
+				pMusicInfo->s_backgroundInfo.format		= WAV_FORMAT_MP3;	// not actually used this way, but just ensures we don't match one of the legit formats
+				pMusicInfo->s_backgroundInfo.channels	= 2;		// always, for our MP3s when used for music (else 1 for FX)
+				pMusicInfo->s_backgroundInfo.rate		= dma.speed;
+				pMusicInfo->s_backgroundInfo.width		= 2;		// always, for our MP3s
+				pMusicInfo->s_backgroundInfo.samples	= pMusicInfo->sfxMP3_Bgrnd.iSoundLengthInSamples;
+				pMusicInfo->s_backgroundSamples			= pMusicInfo->sfxMP3_Bgrnd.iSoundLengthInSamples;
+
+				memset(&pMusicInfo->chMP3_Bgrnd,0,sizeof(pMusicInfo->chMP3_Bgrnd));
+						pMusicInfo->chMP3_Bgrnd.thesfx = &pMusicInfo->sfxMP3_Bgrnd;
+				memcpy(&pMusicInfo->chMP3_Bgrnd.MP3StreamHeader, pMusicInfo->sfxMP3_Bgrnd.pMP3StreamHeader, sizeof(*pMusicInfo->sfxMP3_Bgrnd.pMP3StreamHeader));				
+
+				if (qbDynamic)
+				{					
+					if (pMusicInfo->s_backgroundFile != -1)
+					{
+						FS_FCloseFile( pMusicInfo->s_backgroundFile );
+						pMusicInfo->s_backgroundFile = -1;	// special mp3 value for "valid, but not a real file"
+					}
+				}
+				
+				pMusicInfo->bIsMP3 = qtrue;
+				bMusicSucceeded = qtrue;
+			}
+			else
+			{
+				Com_Printf(S_COLOR_RED"Error streaming file %s: %s\n", name, psError);
+				if (pMusicInfo->s_backgroundFile != -1)
+				{
+					FS_FCloseFile( pMusicInfo->s_backgroundFile );
+				}
+				pMusicInfo->s_backgroundFile = 0;
+			}
+		}
+		else
+		{
+			// MP3_IsValid() will already have printed any errors via Com_Printf at this point...
+			//			
+			if (pMusicInfo->s_backgroundFile != -1)
+			{
+				FS_FCloseFile( pMusicInfo->s_backgroundFile );
+			}
+			pMusicInfo->s_backgroundFile = 0;
+		}
+		
+		return bMusicSucceeded;
+	}
+	else	// not an mp3 file
+	{
+		//
+		// open up a wav file and get all the info
+		//
+		FS_FOpenFileRead( name, &pMusicInfo->s_backgroundFile, qtrue );
+		if ( !pMusicInfo->s_backgroundFile ) {
+			Com_Printf( S_COLOR_YELLOW "WARNING: couldn't open music file %s\n", name );
+			return qfalse;
+		}
+
+		// skip the riff wav header
+
+		FS_Read(dump, 12, pMusicInfo->s_backgroundFile);
+
+		if ( !S_FindWavChunk( pMusicInfo->s_backgroundFile, "fmt " ) ) {
+			Com_Printf( S_COLOR_YELLOW "WARNING: No fmt chunk in %s\n", name );
+			FS_FCloseFile( pMusicInfo->s_backgroundFile );
+			pMusicInfo->s_backgroundFile = 0;
+			return qfalse;
+		}
+
+		// save name for soundinfo
+		pMusicInfo->s_backgroundInfo.format = FGetLittleShort( pMusicInfo->s_backgroundFile );
+		pMusicInfo->s_backgroundInfo.channels = FGetLittleShort( pMusicInfo->s_backgroundFile );
+		pMusicInfo->s_backgroundInfo.rate = FGetLittleLong( pMusicInfo->s_backgroundFile );
+		FGetLittleLong(  pMusicInfo->s_backgroundFile );
+		FGetLittleShort(  pMusicInfo->s_backgroundFile );
+		pMusicInfo->s_backgroundInfo.width = FGetLittleShort( pMusicInfo->s_backgroundFile ) / 8;
+
+		if ( pMusicInfo->s_backgroundInfo.format != WAV_FORMAT_PCM ) {
+			FS_FCloseFile( pMusicInfo->s_backgroundFile );
+			pMusicInfo->s_backgroundFile = 0;
+			Com_Printf(S_COLOR_YELLOW "WARNING: Not a microsoft PCM format wav: %s\n", name);
+			return qfalse;
+		}
+
+		if ( pMusicInfo->s_backgroundInfo.channels != 2 || pMusicInfo->s_backgroundInfo.rate != 22050 ) {
+			Com_Printf(S_COLOR_YELLOW "WARNING: music file %s is not 22k stereo\n", name );
+		}
+
+		if ( ( len = S_FindWavChunk( pMusicInfo->s_backgroundFile, "data" ) ) == 0 ) {
+			FS_FCloseFile( pMusicInfo->s_backgroundFile );
+			pMusicInfo->s_backgroundFile = 0;
+			Com_Printf(S_COLOR_YELLOW "WARNING: No data chunk in %s\n", name);
+			return qfalse;
+		}
+
+		pMusicInfo->s_backgroundInfo.samples = len / (pMusicInfo->s_backgroundInfo.width * pMusicInfo->s_backgroundInfo.channels);
+
+		pMusicInfo->s_backgroundSamples = pMusicInfo->s_backgroundInfo.samples;
+
+		//
+		// start the background streaming
+		//
+		Sys_BeginStreamedFile( pMusicInfo->s_backgroundFile, 0x10000 );
+	}
+
+	return qtrue;
+}
+
+
+static void S_SwitchDynamicTracks( MusicState_e eOldState, MusicState_e eNewState, sboolean bNewTrackStartsFullVolume )
+{
+	// copy old track into fader...
+	//
+	tMusic_Info[ eBGRNDTRACK_FADE ] = tMusic_Info[ eOldState ];
+//	tMusic_Info[ eBGRNDTRACK_FADE ].bActive = qtrue;	// inherent
+//	tMusic_Info[ eBGRNDTRACK_FADE ].bExists = qtrue;	// inherent
+	tMusic_Info[ eBGRNDTRACK_FADE ].iXFadeVolumeSeekTime= Sys_Milliseconds();
+	tMusic_Info[ eBGRNDTRACK_FADE ].iXFadeVolumeSeekTo	= 0;
+	//
+	// ... and deactivate...
+	//
+	tMusic_Info[ eOldState ].bActive = qfalse;
+	//
+	// set new track to either full volume or fade up...
+	//
+	tMusic_Info[eNewState].bActive				= qtrue;
+	tMusic_Info[eNewState].iXFadeVolumeSeekTime	= Sys_Milliseconds();
+	tMusic_Info[eNewState].iXFadeVolumeSeekTo	= 255;
+	tMusic_Info[eNewState].iXFadeVolume			= bNewTrackStartsFullVolume ? 255 : 0;
+
+	eMusic_StateActual = eNewState;
+
+
+	if (s_debugdynamic->integer)
+	{
+		LPCSTR	psNewStateString = Music_BaseStateToString( eNewState, qtrue );
+				psNewStateString = psNewStateString?psNewStateString:"<unknown>";
+
+		Com_Printf( S_COLOR_MAGENTA "S_SwitchDynamicTracks( \"%s\" )\n", psNewStateString );
+	}
+}
+
+// called by both the config-string parser and the console-command state-changer...
+//
+// This either changes the music right now (copying track structures etc), or leaves the new state as pending
+//	so it gets picked up by the general music player if in a transition that can't be overridden...
+//
+static void S_SetDynamicMusicState( MusicState_e eNewState )
+{
+	if (eMusic_StateRequest != eNewState)
+	{
+		eMusic_StateRequest  = eNewState;
+
+		if (s_debugdynamic->integer)
+		{
+			LPCSTR	psNewStateString = Music_BaseStateToString( eNewState, qtrue );
+					psNewStateString = psNewStateString?psNewStateString:"<unknown>";
+
+			Com_Printf( S_COLOR_MAGENTA "S_SetDynamicMusicState( Request: \"%s\" )\n", psNewStateString );
+		}		
+	}
+}
+
+
+static void S_HandleDynamicMusicStateChange( void )
+{
+	if (eMusic_StateRequest != eMusic_StateActual)
+	{
+		// check whether or not the new request can be honoured, given what's currently playing...
+		//
+		if (Music_StateCanBeInterrupted( eMusic_StateActual, eMusic_StateRequest ))
+		{
+			LP_MP3STREAM pMP3StreamActual = &tMusic_Info[ eMusic_StateActual ].chMP3_Bgrnd.MP3StreamHeader;
+
+			switch (eMusic_StateRequest)
+			{
+				case eBGRNDTRACK_EXPLORE:	// ... from action or silence
+				{
+					switch (eMusic_StateActual)
+					{
+						case eBGRNDTRACK_ACTION:	// action->explore
+						{
+							// find the transition track to play, and the entry point for explore when we get there,
+							//	and also see if we're at a permitted exit point to switch at all...
+							//
+							float fPlayingTimeElapsed = MP3Stream_GetPlayingTimeInSeconds( pMP3StreamActual ) - MP3Stream_GetRemainingTimeInSeconds( pMP3StreamActual );
+
+							// supply:
+							//
+							// playing point in float seconds
+							// enum of track being queried
+							//
+							// get:
+							//
+							// enum of transition track to switch to
+							// float time of entry point of new track *after* transition
+
+							MusicState_e	eTransition;
+							float			fNewTrackEntryTime = 0.0f;
+							if (Music_AllowedToTransition( fPlayingTimeElapsed, eBGRNDTRACK_ACTION, &eTransition, &fNewTrackEntryTime))
+							{
+								S_SwitchDynamicTracks( eMusic_StateActual, eTransition, qfalse );	// sboolean bNewTrackStartsFullVolume
+
+								tMusic_Info[eTransition].Rewind();
+								tMusic_Info[eTransition].bTrackSwitchPending	= qtrue;
+								tMusic_Info[eTransition].eTS_NewState			= eMusic_StateRequest;
+								tMusic_Info[eTransition].fTS_NewTime			= fNewTrackEntryTime;
+							}
+						}
+						break;						
+
+						case eBGRNDTRACK_SILENCE:	// silence->explore
+						{
+							S_SwitchDynamicTracks( eMusic_StateActual, eMusic_StateRequest, qfalse );	// sboolean bNewTrackStartsFullVolume
+
+//							float fEntryTime = Music_GetRandomEntryTime( eMusic_StateRequest );
+//							tMusic_Info[ eMusic_StateRequest ].SeekTo(fEntryTime);
+							tMusic_Info[ eMusic_StateRequest ].Rewind();
+						}
+						break;
+
+						default:	// trying to transition from some state I wasn't aware you could transition from (shouldn't happen), so ignore
+						{
+							assert(0); 
+							S_SwitchDynamicTracks( eMusic_StateActual, eBGRNDTRACK_SILENCE, qfalse );	// sboolean bNewTrackStartsFullVolume
+						}
+						break;
+					}
+				}
+				break;
+
+				case eBGRNDTRACK_SILENCE:	// from explore or action
+				{
+					switch (eMusic_StateActual)
+					{
+						case eBGRNDTRACK_ACTION:	// action->silence
+						case eBGRNDTRACK_EXPLORE:	// explore->silence
+						{
+							// find the transition track to play, and the entry point for explore when we get there,
+							//	and also see if we're at a permitted exit point to switch at all...
+							//
+							float fPlayingTimeElapsed = MP3Stream_GetPlayingTimeInSeconds( pMP3StreamActual ) - MP3Stream_GetRemainingTimeInSeconds( pMP3StreamActual );
+
+							MusicState_e	eTransition;
+							float			fNewTrackEntryTime = 0.0f;
+							if (Music_AllowedToTransition( fPlayingTimeElapsed, eMusic_StateActual, &eTransition, &fNewTrackEntryTime))
+							{
+								S_SwitchDynamicTracks( eMusic_StateActual, eTransition, qfalse );	// sboolean bNewTrackStartsFullVolume
+
+								tMusic_Info[eTransition].Rewind();
+								tMusic_Info[eTransition].bTrackSwitchPending	= qtrue;
+								tMusic_Info[eTransition].eTS_NewState			= eMusic_StateRequest;
+								tMusic_Info[eTransition].fTS_NewTime			= 0.0f;	//fNewTrackEntryTime;  irrelevant when switching to silence
+							}
+						}
+						break;
+
+						default:		// some unhandled type switching to silence
+							assert(0);	// fall through since boss case just does silence->switch anyway
+
+						case eBGRNDTRACK_BOSS:	// boss->silence
+						{
+							S_SwitchDynamicTracks( eMusic_StateActual, eBGRNDTRACK_SILENCE, qfalse );	// sboolean bNewTrackStartsFullVolume
+						}
+						break;
+					}
+				}
+				break;
+
+				case eBGRNDTRACK_ACTION:	// anything->action
+				{
+					switch (eMusic_StateActual)
+					{
+						case eBGRNDTRACK_SILENCE:	// silence->action
+						{
+							S_SwitchDynamicTracks( eMusic_StateActual, eMusic_StateRequest, qfalse );	// sboolean bNewTrackStartsFullVolume
+							tMusic_Info[ eMusic_StateRequest ].Rewind();
+						}
+						break;
+
+						default:	// !silence->action
+						{
+							S_SwitchDynamicTracks( eMusic_StateActual, eMusic_StateRequest, qtrue );	// sboolean bNewTrackStartsFullVolume
+							float fEntryTime = Music_GetRandomEntryTime( eMusic_StateRequest );
+							tMusic_Info[ eMusic_StateRequest ].SeekTo(fEntryTime);
+						}
+						break;
+					}
+				}
+				break;
+
+				case eBGRNDTRACK_BOSS:
+				{	
+					S_SwitchDynamicTracks( eMusic_StateActual, eMusic_StateRequest, qfalse );	// sboolean bNewTrackStartsFullVolume
+					//
+					// ( no need to fast forward or rewind, boss track is only entered into once, at start, and can't exit )
+					//
+				}
+				break;
+
+				case eBGRNDTRACK_DEATH:
+				{	
+					S_SwitchDynamicTracks( eMusic_StateActual, eMusic_StateRequest, qtrue );	// sboolean bNewTrackStartsFullVolume
+					//
+					// ( no need to fast forward or rewind, death track is only entered into once, at start, and can't exit or loop)
+					//
+				}
+				break;
+
+				default: assert(0); break;	// unknown new mode request, so just ignore it
+			}
+		}
+	}
+}
+
+
+
+static char gsIntroMusic[MAX_QPATH]={0};
+static char gsLoopMusic [MAX_QPATH]={0};
+
+void S_RestartMusic( void ) 
+{
+	if (s_soundStarted && !s_soundMuted )
+	{
+		//if (gsIntroMusic[0] || gsLoopMusic[0])	// dont test this anymore (but still *use* them), they're blank for JK2 dynamic-music levels anyway
+		{
+			MusicState_e ePrevState	= eMusic_StateRequest;
+			S_StartBackgroundTrack( gsIntroMusic, gsLoopMusic, qfalse );	// ( default music start will set the state to EXPLORE )
+			S_SetDynamicMusicState( ePrevState );					// restore to prev state
+		}
+	}
+}
+
+// Basic logic here is to see if the intro file specified actually exists, and if so, then it's not dynamic music,
+//	When called by the cgame start it loads up, then stops the playback (because of stutter issues), so that when the
+//	actual snapshot is received and the real play request is processed the data has already been loaded so will be quicker.
+//
+// to be honest, although the code still plays WAVs some of the file-check logic only works for MP3s, so if you ever want
+//	to use WAV music you'll have to do some tweaking below (but I've got other things to do so it'll have to wait - Ste)
+//
+void S_StartBackgroundTrack( const char *intro, const char *loop, int bCalledByCGameStart )
+{
+	bMusic_IsDynamic = qfalse;
+
+	if (!s_soundStarted)
+	{	//we have no sound, so don't even bother trying
+		return;
+	}
+
+	if ( !intro ) {
+		intro = "";
+	}
+	if ( !loop || !loop[0] ) {
+		loop = intro;
+	}
+
+	Q_strncpyz(gsIntroMusic,intro, sizeof(gsIntroMusic));
+	Q_strncpyz(gsLoopMusic, loop,  sizeof(gsLoopMusic));
+
+	char sNameIntro[MAX_QPATH];
+	char sNameLoop [MAX_QPATH];
+	Q_strncpyz(sNameIntro,	intro,	sizeof(sNameIntro));
+	Q_strncpyz(sNameLoop,	loop,	sizeof(sNameLoop));
+
+	COM_DefaultExtension( sNameIntro, sizeof( sNameIntro ), ".mp3" );
+	COM_DefaultExtension( sNameLoop,  sizeof( sNameLoop),	".mp3" );
+
+	// if dynamic music not allowed, then just stream the explore music instead of playing dynamic...
+	//
+	if (!s_allowDynamicMusic->integer && Music_DynamicDataAvailable(intro))	// "intro", NOT "sName" (i.e. don't use version with ".mp3" extension)
+	{
+		LPCSTR psMusicName = Music_GetFileNameForState( eBGRNDTRACK_DATABEGIN );
+		if (psMusicName && S_FileExists( psMusicName ))
+		{
+			Q_strncpyz(sNameIntro,psMusicName,sizeof(sNameIntro));
+			Q_strncpyz(sNameLoop, psMusicName,sizeof(sNameLoop ));
+		}
+	}
+
+	// conceptually we always play the 'intro'[/sName] track, intro-to-loop transition is handled in UpdateBackGroundTrack().
+	//
+	if ( (strstr(sNameIntro,"/") && S_FileExists( sNameIntro )) )	// strstr() check avoids extra file-exists check at runtime if reverting from streamed music to dynamic since literal files all need at least one slash in their name (eg "music/blah")
+	{
+		LPCSTR psLoopName = S_FileExists( sNameLoop ) ? sNameLoop : sNameIntro;
+		Com_DPrintf("S_StartBackgroundTrack: Found/using non-dynamic music track '%s' (loop: '%s')\n", sNameIntro, psLoopName);
+		S_StartBackgroundTrack_Actual( &tMusic_Info[eBGRNDTRACK_NONDYNAMIC], bMusic_IsDynamic, sNameIntro, psLoopName );
+	}
+	else
+	{
+		if (Music_DynamicDataAvailable(intro))	// "intro", NOT "sName" (i.e. don't use version with ".mp3" extension)
+		{
+			extern const char *Music_GetLevelSetName(void);
+			Q_strncpyz(sInfoOnly_CurrentDynamicMusicSet, Music_GetLevelSetName(), sizeof(sInfoOnly_CurrentDynamicMusicSet));
+			for (int i = eBGRNDTRACK_DATABEGIN; i != eBGRNDTRACK_DATAEND; i++)
+			{
+				sboolean bOk = qfalse;
+				LPCSTR psMusicName = Music_GetFileNameForState( (MusicState_e) i);
+				if (psMusicName && (!Q_stricmp(tMusic_Info[i].sLoadedDataName, psMusicName) || S_FileExists( psMusicName )) )
+				{
+					bOk = S_StartBackgroundTrack_Actual( &tMusic_Info[i], qtrue, psMusicName, loop );
+				}
+				
+				tMusic_Info[i].bExists = bOk;
+
+				if (!tMusic_Info[i].bExists)
+				{
+					FreeMusic( &tMusic_Info[i] );
+				}
+			}
+
+			//
+			// default all tracks to OFF first (and set any other vars)
+			//
+			for (i=0; i<eBGRNDTRACK_NUMBEROF; i++)
+			{
+				tMusic_Info[i].bActive				= qfalse;
+				tMusic_Info[i].bTrackSwitchPending	= qfalse;
+				tMusic_Info[i].fSmoothedOutVolume	= 0.25f;
+			}
+
+			if (tMusic_Info[eBGRNDTRACK_EXPLORE].bExists &&
+				tMusic_Info[eBGRNDTRACK_ACTION ].bExists
+				)
+			{
+				Com_DPrintf("S_StartBackgroundTrack: Found dynamic music tracks\n");
+				bMusic_IsDynamic = qtrue;
+
+				//
+				// ... then start the default music state...
+				//
+				eMusic_StateActual = eMusic_StateRequest = eBGRNDTRACK_EXPLORE;
+
+				MusicInfo_t *pMusicInfo = &tMusic_Info[ eMusic_StateActual ];
+
+				pMusicInfo->bActive				= qtrue;
+				pMusicInfo->iXFadeVolumeSeekTime= Sys_Milliseconds();
+				pMusicInfo->iXFadeVolumeSeekTo	= 255;
+				pMusicInfo->iXFadeVolume		= 0;			
+				
+	//#ifdef _DEBUG
+	//			float fRemaining = MP3Stream_GetPlayingTimeInSeconds( &pMusicInfo->chMP3_Bgrnd.MP3StreamHeader);
+	//#endif
+			}
+			else
+			{
+				Com_Printf( S_COLOR_RED "Dynamic music did not have both 'action' and 'explore' versions, inhibiting...\n");
+				S_StopBackgroundTrack();
+			}
+		}
+		else
+		{
+			if (sNameIntro[0]!='.')	// blank name with ".mp3" or whatever attached - no error print out
+			{
+				Com_Printf( S_COLOR_RED "Unable to find music \"%s\" as explicit track or dynamic music entry!\n",sNameIntro);
+				S_StopBackgroundTrack();
+			}
+		}
+	}	
+
+	if (bCalledByCGameStart)
+	{
+		S_StopBackgroundTrack();
+	}
+}
+
+void S_StopBackgroundTrack( void )
+{
+	for (int i=0; i<eBGRNDTRACK_NUMBEROF; i++)
+	{
+		S_StopBackgroundTrack_Actual( &tMusic_Info[i] );
+	}
+
+	s_rawend = 0;
+}
+
+
+
+// sboolean return is true only if we're changing from a streamed intro to a dynamic loop...
+//
+static sboolean S_UpdateBackgroundTrack_Actual( MusicInfo_t *pMusicInfo, sboolean bFirstOrOnlyMusicTrack, float fDefaultVolume) 
+{
+	int		bufferSamples;
+	int		fileSamples;
+	byte	raw[30000];		// just enough to fit in a mac stack frame  (note that MP3 doesn't use full size of it)
+	int		fileBytes;
+	int		r;
+
+	float fMasterVol = fDefaultVolume; // s_musicVolume->value;
+
+	if (bMusic_IsDynamic)
+	{
+		// step xfade volume...
+		//
+		if ( pMusicInfo->iXFadeVolume != pMusicInfo->iXFadeVolumeSeekTo )
+		{
+			int iFadeMillisecondsElapsed = Sys_Milliseconds() - pMusicInfo->iXFadeVolumeSeekTime;
+
+			if (iFadeMillisecondsElapsed > (fDYNAMIC_XFADE_SECONDS * 1000))
+			{
+				pMusicInfo->iXFadeVolume = pMusicInfo->iXFadeVolumeSeekTo;
+			}
+			else
+			{
+				pMusicInfo->iXFadeVolume = (int) (255.0f * ((float)iFadeMillisecondsElapsed/(fDYNAMIC_XFADE_SECONDS * 1000.0f)));
+				if (pMusicInfo->iXFadeVolumeSeekTo == 0)	// bleurgh
+					pMusicInfo->iXFadeVolume = 255 - pMusicInfo->iXFadeVolume;
+			}
+		}
+		fMasterVol *= (float)((float)pMusicInfo->iXFadeVolume / 255.0f);
+	}
+
+// this is to work around an obscure issue to do with sliding decoder windows and amounts being requested, since the
+//	original MP3 stream-decoder wrapper was designed to work with audio-paintbuffer sized pieces... Basically 30000
+//	is far too big for the window decoder to handle in one request because of the time-travel issue associated with
+//	normal sfx buffer painting, and allowing sufficient sliding room, even though the music file never goes back in time.
+//
+#define SIZEOF_RAW_BUFFER_FOR_MP3 4096
+#define RAWSIZE (pMusicInfo->bIsMP3?SIZEOF_RAW_BUFFER_FOR_MP3:sizeof(raw))
+
+	if ( !pMusicInfo->s_backgroundFile ) {
+		return qfalse;
+	}	
+
+	pMusicInfo->fSmoothedOutVolume = (pMusicInfo->fSmoothedOutVolume + fMasterVol)/2.0f;
+//	OutputDebugString(va("%f\n",pMusicInfo->fSmoothedOutVolume));
+
+	// don't bother playing anything if musicvolume is 0
+	if ( pMusicInfo->fSmoothedOutVolume <= 0 ) {
+		return qfalse;
+	}
+
+	// see how many samples should be copied into the raw buffer
+	if ( s_rawend < s_soundtime ) {
+		s_rawend = s_soundtime;
+	}
+
+	while ( s_rawend < s_soundtime + MAX_RAW_SAMPLES ) 
+	{
+		bufferSamples = MAX_RAW_SAMPLES - (s_rawend - s_soundtime);
+
+		// decide how much data needs to be read from the file
+		fileSamples = bufferSamples * pMusicInfo->s_backgroundInfo.rate / dma.speed;
+
+		// don't try and read past the end of the file
+		if ( fileSamples > pMusicInfo->s_backgroundSamples ) {
+			fileSamples = pMusicInfo->s_backgroundSamples;
+		}
+
+		// our max buffer size
+		fileBytes = fileSamples * (pMusicInfo->s_backgroundInfo.width * pMusicInfo->s_backgroundInfo.channels);
+		if (fileBytes > RAWSIZE ) {
+			fileBytes = RAWSIZE;
+			fileSamples = fileBytes / (pMusicInfo->s_backgroundInfo.width * pMusicInfo->s_backgroundInfo.channels);
+		}
+
+		sboolean qbForceFinish = qfalse;
+		if (pMusicInfo->bIsMP3)
+		{
+			int iStartingSampleNum = pMusicInfo->chMP3_Bgrnd.thesfx->iSoundLengthInSamples - pMusicInfo->s_backgroundSamples;	// but this IS relevant
+			// Com_Printf(S_COLOR_YELLOW "Requesting MP3 samples: sample %d\n",iStartingSampleNum);
+
+
+			if (pMusicInfo->s_backgroundFile == -1)
+			{
+				// in-mem...
+				//
+				qbForceFinish = (MP3Stream_GetSamples( &pMusicInfo->chMP3_Bgrnd, iStartingSampleNum, fileBytes/2, (short*) raw, qtrue ))?qfalse:qtrue;				
+
+				//Com_Printf(S_COLOR_YELLOW "Music time remaining: %f seconds\n", MP3Stream_GetRemainingTimeInSeconds( &pMusicInfo->chMP3_Bgrnd.MP3StreamHeader ));				
+			}
+			else
+			{
+				// streaming an MP3 file instead... (note that the 'fileBytes' request size isn't that relevant for MP3s, 
+				//										since code here can't know how much the MP3 needs to decompress)
+				//
+				byte *pbScrolledStreamData = MP3MusicStream_ReadFromDisk(pMusicInfo, pMusicInfo->chMP3_Bgrnd.MP3StreamHeader.iSourceReadIndex, fileBytes);
+
+				pMusicInfo->chMP3_Bgrnd.MP3StreamHeader.pbSourceData = pbScrolledStreamData - pMusicInfo->chMP3_Bgrnd.MP3StreamHeader.iSourceReadIndex;
+
+				qbForceFinish = (MP3Stream_GetSamples( &pMusicInfo->chMP3_Bgrnd, iStartingSampleNum, fileBytes/2, (short*) raw, qtrue ))?qfalse:qtrue;
+			}
+		}
+		else
+		{
+			// streaming a WAV off disk...
+			//
+			r = Sys_StreamedRead( raw, 1, fileBytes, pMusicInfo->s_backgroundFile );
+			if ( r != fileBytes ) {
+				Com_Printf(S_COLOR_RED"StreamedRead failure on music track\n");
+				S_StopBackgroundTrack();
+				return qfalse;
+			}
+
+			// byte swap if needed (do NOT do for MP3 decoder, that has an internal big/little endian handler)
+			//
+			S_ByteSwapRawSamples( fileSamples, pMusicInfo->s_backgroundInfo.width, pMusicInfo->s_backgroundInfo.channels, raw );
+		}
+
+		// add to raw buffer
+		S_RawSamples(	fileSamples, pMusicInfo->s_backgroundInfo.rate, 
+						pMusicInfo->s_backgroundInfo.width, pMusicInfo->s_backgroundInfo.channels, raw, pMusicInfo->fSmoothedOutVolume,
+						bFirstOrOnlyMusicTrack
+					);
+
+		pMusicInfo->s_backgroundSamples -= fileSamples;
+		if ( !pMusicInfo->s_backgroundSamples || qbForceFinish ) 
+		{
+			// loop the music, or play the next piece if we were on the intro...
+			//	(but not for dynamic, that can only be used for loop music)
+			//
+			if (bMusic_IsDynamic)	// needs special logic for this, different call
+			{
+				pMusicInfo->Rewind();
+			}
+			else
+			{
+				// for non-dynamic music we need to check if "sMusic_BackgroundLoop" is an actual filename,
+				//	or if it's a dynamic music specifier (which can't literally exist), in which case it should set
+				//	a return flag then exit...
+				//
+				char sTestName[MAX_QPATH*2];// *2 so COM_DefaultExtension doesn't do an ERR_DROP if there was no space
+											//	for an extension, since this is a "soft" test				
+				Q_strncpyz( sTestName, sMusic_BackgroundLoop, sizeof(sTestName));
+				COM_DefaultExtension(sTestName, sizeof(sTestName), ".mp3");
+
+				if (S_FileExists( sTestName ))
+				{
+					S_StartBackgroundTrack_Actual( pMusicInfo, qfalse, sMusic_BackgroundLoop, sMusic_BackgroundLoop );
+				}
+				else
+				{
+					// proposed file doesn't exist, but this may be a dynamic track we're wanting to loop, 
+					//	so exit with a special flag...
+					//
+					return qtrue;
+				}
+			}
+			if ( !pMusicInfo->s_backgroundFile ) 
+			{
+				return qfalse;		// loop failed to restart
+			}
+		}
+	}
+
+#undef SIZEOF_RAW_BUFFER_FOR_MP3
+#undef RAWSIZE
+
+	return qfalse;
+}
+
+
+// used to be just for dynamic, but now even non-dynamic music has to know whether it should be silent or not...
+//
+static LPCSTR S_Music_GetRequestedState(void)
+{
+	/*
+	int iStringOffset = cl.gameState.stringOffsets[CS_DYNAMIC_MUSIC_STATE];
+	if (iStringOffset)
+	{
+		LPCSTR psCommand = cl.gameState.stringData+iStringOffset; 
+
+		return psCommand;
+	}
+	*/
+	//rwwFIXMEFIXME: Maybe use the above for something in MP?
+	
+	return NULL;
+}
+
+
+// scan the configstring to see if there's been a state-change requested...
+// (note that even if the state doesn't change it still gets here, so do a same-state check for applying)
+//
+// then go on to do transition handling etc...
+//
+static void S_CheckDynamicMusicState(void)
+{
+	LPCSTR psCommand = S_Music_GetRequestedState();
+
+	if (psCommand)
+	{
+		MusicState_e eNewState;
+
+		if ( !Q_stricmpn( psCommand, "silence", 7) )
+		{				
+			eNewState = eBGRNDTRACK_SILENCE;
+		}
+		else if ( !Q_stricmpn( psCommand, "action", 6) )
+		{
+			eNewState = eBGRNDTRACK_ACTION;
+		}
+		else if ( !Q_stricmpn( psCommand, "boss", 4) )
+		{
+			// special case, boss music is optional and may not be defined...
+			//
+			if (tMusic_Info[ eBGRNDTRACK_BOSS ].bExists)
+			{
+				eNewState = eBGRNDTRACK_BOSS;
+			}
+			else
+			{
+				// ( leave it playing current track )
+				//
+				eNewState = eMusic_StateActual;
+			}
+		}
+		else if ( !Q_stricmpn( psCommand, "death", 5) )
+		{
+			// special case, death music is optional and may not be defined...
+			//
+			if (tMusic_Info[ eBGRNDTRACK_DEATH ].bExists)
+			{
+				eNewState = eBGRNDTRACK_DEATH;
+			}
+			else
+			{
+				// ( leave it playing current track, typically either boss or action )
+				//
+				eNewState = eMusic_StateActual;
+			}
+		}
+		else
+		{
+			// seems a reasonable default...
+			//
+			eNewState = eBGRNDTRACK_EXPLORE;
+		}
+		
+		S_SetDynamicMusicState( eNewState );
+	}
+
+	S_HandleDynamicMusicStateChange();
+}
+
+static void S_UpdateBackgroundTrack( void )
+{
+	if (bMusic_IsDynamic)
+	{
+		if (s_debugdynamic->integer == 2)
+		{
+			DynamicMusicInfoPrint();
+		}
+				
+		S_CheckDynamicMusicState();
+		
+		if (eMusic_StateActual != eBGRNDTRACK_SILENCE)
+		{
+			MusicInfo_t *pMusicInfoCurrent = &tMusic_Info[ (eMusic_StateActual == eBGRNDTRACK_FADE)?eBGRNDTRACK_EXPLORE:eMusic_StateActual ];
+			MusicInfo_t *pMusicInfoFadeOut = &tMusic_Info[ eBGRNDTRACK_FADE ];
+
+			if ( pMusicInfoCurrent->s_backgroundFile == -1)
+			{
+				int iRawEnd = s_rawend;
+				S_UpdateBackgroundTrack_Actual( pMusicInfoCurrent, qtrue, s_musicVolume->value );
+
+	/*			static int iPrevFrontVol = 0;
+				if (iPrevFrontVol != pMusicInfoCurrent->iXFadeVolume)
+				{
+					iPrevFrontVol  = pMusicInfoCurrent->iXFadeVolume;
+					Com_Printf("front vol = %d\n",pMusicInfoCurrent->iXFadeVolume);
+				}
+	*/
+				if (pMusicInfoFadeOut->bActive)
+				{
+					s_rawend = iRawEnd;
+					S_UpdateBackgroundTrack_Actual( pMusicInfoFadeOut, qfalse, s_musicVolume->value );	// inactive-checked internally
+	/*
+					static int iPrevFadeVol = 0;
+					if (iPrevFadeVol != pMusicInfoFadeOut->iXFadeVolume)
+					{
+						iPrevFadeVol  = pMusicInfoFadeOut->iXFadeVolume;
+						Com_Printf("fade vol = %d\n",pMusicInfoFadeOut->iXFadeVolume);
+					}
+	*/
+					//
+					// only do this for the fader!...
+					//
+					if (pMusicInfoFadeOut->iXFadeVolume == 0)
+					{
+						pMusicInfoFadeOut->bActive = qfalse;
+					}
+				}
+				
+				float fRemainingTimeInSeconds = MP3Stream_GetRemainingTimeInSeconds( &pMusicInfoCurrent->chMP3_Bgrnd.MP3StreamHeader );
+				// Com_Printf("Remaining: %3.3f\n",fRemainingTimeInSeconds);
+
+				if ( fRemainingTimeInSeconds < fDYNAMIC_XFADE_SECONDS*2 )
+				{
+					// now either loop current track, switch if finishing a transition, or stop if finished a death...
+					//
+					if (pMusicInfoCurrent->bTrackSwitchPending)
+					{
+						pMusicInfoCurrent->bTrackSwitchPending = qfalse;	// ack
+						S_SwitchDynamicTracks( eMusic_StateActual, pMusicInfoCurrent->eTS_NewState, qfalse);	// sboolean bNewTrackStartsFullVolume
+						if (tMusic_Info[ pMusicInfoCurrent->eTS_NewState ].bExists)	// don't do this if switching to silence
+						{							
+							tMusic_Info[ pMusicInfoCurrent->eTS_NewState ].SeekTo(pMusicInfoCurrent->fTS_NewTime);
+						}					
+					}
+					else
+					{
+						// normal looping, so set rewind current track, set volume to 0 and fade up to full (unless death track playing, then stays quiet)
+						//	(while fader copy of end-section fades down)
+						//
+						// copy current track to fader...
+						//
+						*pMusicInfoFadeOut = *pMusicInfoCurrent;	// struct copy
+						pMusicInfoFadeOut->iXFadeVolumeSeekTime	= Sys_Milliseconds();
+						pMusicInfoFadeOut->iXFadeVolumeSeekTo	= 0;
+						//
+						pMusicInfoCurrent->Rewind();
+						pMusicInfoCurrent->iXFadeVolumeSeekTime	= Sys_Milliseconds();
+						pMusicInfoCurrent->iXFadeVolumeSeekTo	= (eMusic_StateActual == eBGRNDTRACK_DEATH) ? 0: 255;
+						pMusicInfoCurrent->iXFadeVolume			= 0;
+					}
+				}
+			}
+		}
+		else
+		{
+			// special case, when foreground music is shut off but fader still running to fade off previous track...
+			//
+			MusicInfo_t *pMusicInfoFadeOut = &tMusic_Info[ eBGRNDTRACK_FADE ];
+			if (pMusicInfoFadeOut->bActive)
+			{
+				S_UpdateBackgroundTrack_Actual( pMusicInfoFadeOut, qtrue, s_musicVolume->value );
+				if (pMusicInfoFadeOut->iXFadeVolume == 0)
+				{
+					pMusicInfoFadeOut->bActive = qfalse;
+				}
+			}	
+		}
+	}
+	else
+	{
+		// standard / non-dynamic one-track music...
+		//
+		LPCSTR psCommand = S_Music_GetRequestedState();	// special check just for "silence" case...
+		sboolean bShouldBeSilent = (psCommand && !stricmp(psCommand,"silence"));
+		float fDesiredVolume = bShouldBeSilent ? 0.0f : s_musicVolume->value;
+		//
+		// internal to this code is a volume-smoother...
+		//
+		sboolean bNewTrackDesired = S_UpdateBackgroundTrack_Actual(&tMusic_Info[eBGRNDTRACK_NONDYNAMIC], qtrue, fDesiredVolume);
+
+		if (bNewTrackDesired)
+		{
+			S_StartBackgroundTrack( sMusic_BackgroundLoop, sMusic_BackgroundLoop, qfalse );
+		}
+	}
+}
+
+
+cvar_t *s_soundpoolmegs = NULL;
+
+
+// currently passing in sfx as a param in case I want to do something with it later.
+//
+byte *SND_malloc(int iSize, sfx_t *sfx) 
+{
+	byte *pData = (byte *) Z_Malloc(iSize, TAG_SND_RAWDATA, qfalse);	// don't bother asking for zeroed mem
+
+	// if "s_soundpoolmegs" is < 0, then the -ve of the value is the maximum amount of sounds we're allowed to have loaded...
+	//
+	if (s_soundpoolmegs && s_soundpoolmegs->integer < 0)
+	{
+		while ( (Z_MemSize(TAG_SND_RAWDATA) + Z_MemSize(TAG_SND_MP3STREAMHDR)) > ((-s_soundpoolmegs->integer) * 1024 * 1024))		
+		{
+			int iBytesFreed = SND_FreeOldestSound(sfx);
+			if (iBytesFreed == 0)
+				break;	// sanity
+		}
+	}
+
+	return pData;
+}
+
+
+// called once-only in EXE lifetime...
+//
+void SND_setup() 
+{		 
+	s_soundpoolmegs = Cvar_Get("s_soundpoolmegs", "25", CVAR_ARCHIVE);
+	if (Sys_LowPhysicalMemory() )
+	{
+		Cvar_Set("s_soundpoolmegs", "0");
+	}
+	
+	Com_Printf("Sound memory manager started\n");
+}
+
+
+// ask how much mem an sfx has allocated...
+//
+static int SND_MemUsed(sfx_t *sfx)
+{
+	int iSize = 0;
+	if (sfx->pSoundData){
+		iSize += Z_Size(sfx->pSoundData);
+	}
+
+	if (sfx->pMP3StreamHeader) {
+		iSize += Z_Size(sfx->pMP3StreamHeader);
+	}
+
+	return iSize;
+}
+
+// free any allocated sfx mem...
+//
+// now returns # bytes freed to help with z_malloc()-fail recovery
+//
+static int SND_FreeSFXMem(sfx_t *sfx)
+{
+	int iBytesFreed = 0;
+
+	if (s_UseOpenAL)
+	{
+		alGetError();
+		if (sfx->Buffer)
+		{
+			alDeleteBuffers(1, &(sfx->Buffer));
+#ifdef _DEBUG
+			char szString[256];
+			if (alGetError() != AL_NO_ERROR)
+			{
+				sprintf(szString, "Failed to delete AL Buffer (%s) ... !\n", sfx->sSoundName);
+				OutputDebugString(szString);
+			}
+#endif
+			sfx->Buffer = 0;
+		}
+
+		if (sfx->lipSyncData)
+		{
+			iBytesFreed +=	Z_Size(	sfx->lipSyncData);
+							Z_Free(	sfx->lipSyncData);
+									sfx->lipSyncData = NULL;
+		}
+	}
+
+	if (						sfx->pSoundData) {
+		iBytesFreed +=	Z_Size(	sfx->pSoundData);
+						Z_Free(	sfx->pSoundData );
+								sfx->pSoundData = NULL;
+	}
+
+	sfx->bInMemory = qfalse;	
+
+	if (						sfx->pMP3StreamHeader) {
+		iBytesFreed +=	Z_Size(	sfx->pMP3StreamHeader);
+						Z_Free(	sfx->pMP3StreamHeader );
+								sfx->pMP3StreamHeader = NULL;
+	}
+
+	return iBytesFreed;
+}
+
+void S_DisplayFreeMemory() 
+{
+	int iSoundDataSize = Z_MemSize ( TAG_SND_RAWDATA ) + Z_MemSize( TAG_SND_MP3STREAMHDR );
+	int iMusicDataSize = Z_MemSize ( TAG_SND_DYNAMICMUSIC );
+
+	if (iSoundDataSize || iMusicDataSize)
+	{
+		Com_Printf("\n%.2fMB audio data:  ( %.2fMB WAV/MP3 ) + ( %.2fMB Music )\n",
+					((float)(iSoundDataSize+iMusicDataSize))/1024.0f/1024.0f,
+										((float)(iSoundDataSize))/1024.0f/1024.0f,
+																((float)(iMusicDataSize))/1024.0f/1024.0f
+					);
+
+		// now count up amount used on this level...
+		//
+		iSoundDataSize = 0;
+		for (int i=1; i<s_numSfx; i++)
+		{
+			sfx_t *sfx = &s_knownSfx[i];
+
+			if (sfx->iLastLevelUsedOn == RE_RegisterMedia_GetLevel()){
+				iSoundDataSize += SND_MemUsed(sfx);
+			}
+		}
+
+		Com_Printf("%.2fMB in sfx_t alloc data (WAV/MP3) loaded this level\n",(float)iSoundDataSize/1024.0f/1024.0f);
+	}
+}
+
+void SND_TouchSFX(sfx_t *sfx)
+{
+	sfx->iLastTimeUsed		= Com_Milliseconds()+1;
+	sfx->iLastLevelUsedOn	= RE_RegisterMedia_GetLevel();
+}
+
+
+// currently this is only called during snd_shutdown or snd_restart
+//
+void S_FreeAllSFXMem(void)
+{
+	for (int i=1 ; i < s_numSfx ; i++)	// start @ 1 to skip freeing default sound
+	{
+		SND_FreeSFXMem(&s_knownSfx[i]);
+	}
+}
+
+// returns number of bytes freed up...
+//
+// new param is so we can be usre of not freeing ourselves (without having to rely on possible uninitialised timers etc)
+//
+int SND_FreeOldestSound(sfx_t *pButNotThisOne /* = NULL */) 
+{	
+	int iBytesFreed = 0;
+	sfx_t *sfx;
+
+	int	iOldest = Com_Milliseconds();
+	int	iUsed	= 0;
+
+	// start on 1 so we never dump the default sound...
+	//
+	for (int i=1 ; i < s_numSfx ; i++) 
+	{
+		sfx = &s_knownSfx[i];
+
+		if (sfx != pButNotThisOne)
+		{
+			if (!sfx->bDefaultSound && sfx->bInMemory && sfx->iLastTimeUsed < iOldest) 
+			{
+				// new bit, we can't throw away any sfx_t struct in use by a channel, else the paint code will crash...
+				//
+				for (int iChannel=0; iChannel<MAX_CHANNELS; iChannel++)
+				{
+					channel_t *ch = & s_channels[iChannel];
+
+					if (ch->thesfx == sfx)
+						break;	// damn, being used
+				}
+				if (iChannel == MAX_CHANNELS)
+				{
+					// this sfx_t struct wasn't used by any channels, so we can lose it...
+					//			
+					iUsed = i;
+					iOldest = sfx->iLastTimeUsed;
+				}
+			}
+		}
+	}
+
+	if (iUsed)
+	{
+		sfx = &s_knownSfx[ iUsed ];
+	
+		Com_DPrintf("SND_FreeOldestSound: freeing sound %s\n", sfx->sSoundName);
+	
+		iBytesFreed = SND_FreeSFXMem(sfx);
+	}
+
+	return iBytesFreed;
+}
+int SND_FreeOldestSound(void)
+{
+	return SND_FreeOldestSound(NULL);	// I had to add a void-arg version of this because of link issues, sigh
+}
+
+
+// just before we drop into a level, ensure the audio pool is under whatever the maximum
+//	pool size is (but not by dropping out sounds used by the current level)...
+//
+// returns qtrue if at least one sound was dropped out, so z_malloc-fail recovery code knows if anything changed
+//
+extern qboolean gbInsideLoadSound;
+qboolean SND_RegisterAudio_LevelLoadEnd(qboolean bDeleteEverythingNotUsedThisLevel /* 99% qfalse */)
+{
+	qboolean bAtLeastOneSoundDropped = qfalse;
+
+	Com_DPrintf( "SND_RegisterAudio_LevelLoadEnd():\n");
+
+	if (gbInsideLoadSound)
+	{
+		Com_DPrintf( "(Inside S_LoadSound (z_malloc recovery?), exiting...\n");
+	}
+	else
+	{
+		int iLoadedAudioBytes	 = Z_MemSize ( TAG_SND_RAWDATA ) + Z_MemSize( TAG_SND_MP3STREAMHDR );
+		const int iMaxAudioBytes = s_soundpoolmegs->integer * 1024 * 1024;
+
+		for (int i=1; i<s_numSfx && ( iLoadedAudioBytes > iMaxAudioBytes || bDeleteEverythingNotUsedThisLevel) ; i++) // i=1 so we never page out default sound
+		{
+			sfx_t *sfx = &s_knownSfx[i];
+
+			if (sfx->bInMemory)
+			{
+				sboolean bDeleteThis = qfalse;
+
+				if (bDeleteEverythingNotUsedThisLevel)
+				{
+					bDeleteThis = (sfx->iLastLevelUsedOn != RE_RegisterMedia_GetLevel());
+				}
+				else
+				{
+					bDeleteThis = (sfx->iLastLevelUsedOn < RE_RegisterMedia_GetLevel());
+				}
+
+				if (bDeleteThis)
+				{
+					Com_DPrintf( "Dumping sfx_t \"%s\"\n",sfx->sSoundName);			
+
+					if (SND_FreeSFXMem(sfx))
+					{
+						bAtLeastOneSoundDropped = qtrue;
+					}
+
+					iLoadedAudioBytes = Z_MemSize ( TAG_SND_RAWDATA ) + Z_MemSize( TAG_SND_MP3STREAMHDR );					
+				}
+			}
+		}
+	}
+
+	Com_DPrintf( "SND_RegisterAudio_LevelLoadEnd(): Ok\n");	
+
+	return bAtLeastOneSoundDropped;
+}
+
+
+/****************************************************************************************************\
+*
+*	EAX Related
+*
+\****************************************************************************************************/
+
+/*
+	Initialize the EAX Manager
+*/
+void InitEAXManager()
+{
+	LPEAXMANAGERCREATE lpEAXManagerCreateFn;
+	EAXFXSLOTPROPERTIES FXSlotProp;
+	GUID	Effect;
+	GUID	FXSlotGuids[4];
+	int i;
+
+	s_bEALFileLoaded = false;
+
+	// Check for EAX 4.0 support
+	s_bEAX = alIsExtensionPresent((ALubyte*)"EAX4.0");
+	
+	if (s_bEAX)
+	{
+		Com_Printf("Found EAX 4.0 native support\n");
+	}
+	else
+	{
+		// Support for EAXUnified (automatic translation of EAX 4.0 calls into EAX 3.0)
+		if ((alIsExtensionPresent((ALubyte*)"EAX3.0")) && (alIsExtensionPresent((ALubyte*)"EAX4.0Emulated")))
+		{
+			s_bEAX = AL_TRUE;
+			Com_Printf("Found EAX 4.0 EMULATION support\n");
+		}
+	}
+
+	if (s_bEAX)
+	{
+		s_eaxSet = (EAXSet)alGetProcAddress((ALubyte*)"EAXSet");
+		if (s_eaxSet == NULL)
+			s_bEAX = false;
+		s_eaxGet = (EAXGet)alGetProcAddress((ALubyte*)"EAXGet");
+		if (s_eaxGet == NULL)
+			s_bEAX = false;
+	}
+
+	// If we have detected EAX support, then try and load the EAX Manager DLL
+	if (s_bEAX)
+	{
+		s_hEAXManInst = LoadLibrary("EAXMan.dll");
+		if (s_hEAXManInst)
+		{
+			lpEAXManagerCreateFn = (LPEAXMANAGERCREATE)GetProcAddress(s_hEAXManInst, "EaxManagerCreate");
+			if (lpEAXManagerCreateFn)
+			{
+				if (lpEAXManagerCreateFn(&s_lpEAXManager)==EM_OK)
+				{
+					// Configure our EAX 4.0 Effect Slots
+
+					s_NumFXSlots = 0;
+					for (i = 0; i < EAX_MAX_FXSLOTS; i++)
+					{
+						s_FXSlotInfo[i].FXSlotGuid = EAX_NULL_GUID;
+						s_FXSlotInfo[i].lEnvID = -1;
+					}
+
+					FXSlotGuids[0] = EAXPROPERTYID_EAX40_FXSlot0;
+					FXSlotGuids[1] = EAXPROPERTYID_EAX40_FXSlot1;
+					FXSlotGuids[2] = EAXPROPERTYID_EAX40_FXSlot2;
+					FXSlotGuids[3] = EAXPROPERTYID_EAX40_FXSlot3;
+
+					// For each effect slot, try and load a reverb and lock the slot
+					FXSlotProp.guidLoadEffect = EAX_REVERB_EFFECT;
+					FXSlotProp.lVolume = 0;
+					FXSlotProp.lLock = EAXFXSLOT_LOCKED;
+					FXSlotProp.ulFlags = EAXFXSLOTFLAGS_ENVIRONMENT;
+
+					for (i = 0; i < EAX_MAX_FXSLOTS; i++)
+					{
+						if (s_eaxSet(&FXSlotGuids[i], EAXFXSLOT_ALLPARAMETERS, NULL, &FXSlotProp, sizeof(EAXFXSLOTPROPERTIES))==AL_NO_ERROR)
+						{
+							// We can use this slot
+							s_FXSlotInfo[s_NumFXSlots].FXSlotGuid = FXSlotGuids[i];
+							s_NumFXSlots++;
+						}
+						else
+						{
+							// If this slot already contains a reverb, then we will use it anyway (Slot 0 will
+							// be in this category).  (It probably means that Slot 0 is locked)
+							if (s_eaxGet(&FXSlotGuids[i], EAXFXSLOT_LOADEFFECT, NULL, &Effect, sizeof(GUID))==AL_NO_ERROR)
+							{
+								if (Effect == EAX_REVERB_EFFECT)
+								{
+									// We can use this slot
+									// Make sure the environment flag is on
+									s_eaxSet(&FXSlotGuids[i], EAXFXSLOT_FLAGS, NULL, &FXSlotProp.ulFlags, sizeof(unsigned long));
+									s_FXSlotInfo[s_NumFXSlots].FXSlotGuid = FXSlotGuids[i];
+									s_NumFXSlots++;
+								}
+							}
+						}
+					}
+
+					return;
+				}
+			}
+		}
+	}
+
+	// If the EAXManager library was loaded (and there was a problem), then unload it
+	if (s_hEAXManInst)
+	{
+		FreeLibrary(s_hEAXManInst);
+		s_hEAXManInst = NULL;
+	}
+
+	s_lpEAXManager = NULL;
+	s_bEAX = false;
+
+	return;
+}
+
+/*
+	Release the EAX Manager
+*/
+void ReleaseEAXManager()
+{
+	s_bEAX = false;
+
+	UnloadEALFile();
+
+	if (s_lpEAXManager)
+	{
+		s_lpEAXManager->Release();
+		s_lpEAXManager = NULL;
+	}
+	if (s_hEAXManInst)
+	{
+		FreeLibrary(s_hEAXManInst);
+		s_hEAXManInst = NULL;
+	}
+}
+
+
+/*
+	Try to load the given .eal file
+*/
+bool LoadEALFile(char *szEALFilename)
+{
+	char		*ealData = NULL;
+	HRESULT		hr;
+	long		i, j, lID, lEnvID;
+	EMPOINT		EMPoint;
+	char		szAperture[128];
+	char		szFullEALFilename[MAX_QPATH];
+	long		lNumInst, lNumInstA, lNumInstB;
+	bool		bLoaded = false;
+	bool		bValid = true;
+	int			result;
+	char		szString[256];
+	
+	if ((!s_lpEAXManager) || (!s_bEAX))
+		return false;
+
+	if (strstr(szEALFilename, "nomap"))
+		return false;
+
+	s_EnvironmentID = 0xFFFFFFFF;
+
+	// Assume there is no aperture information in the .eal file
+	s_lpEnvTable = NULL;
+
+	// Load EAL file from PAK file
+	result = FS_ReadFile(szEALFilename, (void **)&ealData);
+
+	if ((ealData) && (result != -1))
+	{
+		hr = s_lpEAXManager->LoadDataSet(ealData, EMFLAG_LOADFROMMEMORY);
+	
+		// Unload EAL file
+		FS_FreeFile (ealData);
+	
+		if (hr == EM_OK)
+		{
+			Com_DPrintf("Loaded %s by Quake loader\n", szEALFilename);
+			bLoaded = true;
+		}
+	}
+	else
+	{
+		// Failed to load via Quake loader, try manually
+		Com_sprintf(szFullEALFilename, MAX_QPATH, "base/%s", szEALFilename);
+		if (SUCCEEDED(s_lpEAXManager->LoadDataSet(szFullEALFilename, 0)))
+		{
+			Com_DPrintf("Loaded %s by EAXManager\n", szEALFilename);
+			bLoaded = true;
+		}
+	}
+
+	if (bLoaded)
+	{
+		// For a valid eal file ... need to find 'Center' tag, record num of instances,  and then find
+		// the right number of instances of 'Aperture0a' and 'Aperture0b'.
+
+		if (s_lpEAXManager->GetSourceID("Center", &lID)==EM_OK)
+		{
+			if (s_lpEAXManager->GetSourceNumInstances(lID, &s_lNumEnvironments)==EM_OK)
+			{
+				if (s_lpEAXManager->GetSourceID("Aperture0a", &lID)==EM_OK)
+				{
+					if (s_lpEAXManager->GetSourceNumInstances(lID, &lNumInst)==EM_OK)
+					{
+						if (lNumInst == s_lNumEnvironments)
+						{
+							if (s_lpEAXManager->GetSourceID("Aperture0b", &lID)==EM_OK)
+							{
+								if (s_lpEAXManager->GetSourceNumInstances(lID, &lNumInst)==EM_OK)
+								{
+									if (lNumInst == s_lNumEnvironments)
+									{
+										// Check equal numbers of ApertureXa and ApertureXb
+										i = 1;
+										while (true)
+										{
+											lNumInstA = lNumInstB = 0;
+
+											sprintf(szAperture,"Aperture%da",i);
+											if ((s_lpEAXManager->GetSourceID(szAperture, &lID)==EM_OK) && (s_lpEAXManager->GetSourceNumInstances(lID, &lNumInstA)==EM_OK))
+											{
+												sprintf(szAperture,"Aperture%db",i);
+												s_lpEAXManager->GetSourceID(szAperture, &lID);
+												s_lpEAXManager->GetSourceNumInstances(lID, &lNumInstB);
+
+												if (lNumInstA!=lNumInstB)
+												{
+													Com_DPrintf( S_COLOR_YELLOW "Invalid EAL file - %d Aperture%da tags, and %d Aperture%db tags\n", lNumInstA, i, lNumInstB, i);
+													bValid = false;
+												}
+											}
+											else
+											{
+												break;
+											}
+
+											i++;
+										}
+
+										if (bValid)
+										{
+											s_lpEnvTable = (LPENVTABLE)Z_Malloc(s_lNumEnvironments * sizeof(ENVTABLE), TAG_GENERAL, qtrue);
+										}
+									}
+									else
+										Com_DPrintf( S_COLOR_YELLOW "Invalid EAL File - expected %d instances of Aperture0b, found %d\n", s_lNumEnvironments, lNumInst);
+								}
+								else
+									Com_DPrintf( S_COLOR_YELLOW "EAXManager- failed GetSourceNumInstances()\n");
+							}
+							else
+								Com_DPrintf( S_COLOR_YELLOW "Invalid EAL File - no instances of 'Aperture0b' source-tag\n");
+						}
+						else
+							Com_DPrintf( S_COLOR_YELLOW "Invalid EAL File - found %d instances of the 'Center' tag, but only %d instances of 'Aperture0a'\n", s_lNumEnvironments, lNumInst);
+					}
+					else
+						Com_DPrintf( S_COLOR_YELLOW "EAXManager- failed GetSourceNumInstances()\n");
+				}
+				else
+					Com_DPrintf( S_COLOR_YELLOW "Invalid EAL File - no instances of 'Aperture0a' source-tag\n");
+			}
+			else
+				Com_DPrintf( S_COLOR_YELLOW "EAXManager- failed GetSourceNumInstances()\n");
+		}
+		else
+			Com_DPrintf( S_COLOR_YELLOW "Invalid EAL File - no instances of 'Center' source-tag\n");
+
+
+		if (s_lpEnvTable)
+		{
+			i = 0;
+			while (true)
+			{
+				sprintf(szAperture, "Aperture%da", i);
+				if (s_lpEAXManager->GetSourceID(szAperture, &lID)==EM_OK)
+				{
+					if (s_lpEAXManager->GetSourceNumInstances(lID, &lNumInst)==EM_OK)
+					{
+						for (j = 0; j < s_lNumEnvironments; j++)
+						{
+							s_lpEnvTable[j].bUsed = false;
+						}
+
+						for (j = 0; j < lNumInst; j++)
+						{
+							if (s_lpEAXManager->GetSourceInstancePos(lID, j, &EMPoint)==EM_OK)
+							{
+								if (s_lpEAXManager->GetListenerDynamicAttributes(0, &EMPoint, &lEnvID, 0)==EM_OK)
+								{
+									if ((lEnvID >= 0) && (lEnvID < s_lNumEnvironments))
+									{
+										if (!s_lpEnvTable[lEnvID].bUsed)
+										{
+											s_lpEnvTable[lEnvID].bUsed = true;
+											s_lpEnvTable[lEnvID].Aperture[s_lpEnvTable[lEnvID].ulNumApertures].vPos1[0] = EMPoint.fX;
+											s_lpEnvTable[lEnvID].Aperture[s_lpEnvTable[lEnvID].ulNumApertures].vPos1[1] = EMPoint.fY;
+											s_lpEnvTable[lEnvID].Aperture[s_lpEnvTable[lEnvID].ulNumApertures].vPos1[2] = EMPoint.fZ;
+										}
+										else
+										{
+											s_lpEAXManager->GetEnvironmentName(lEnvID, szString, 256);
+											Com_DPrintf( S_COLOR_YELLOW "Found more than one occurance of Aperture%da in %s sub-space\n", i, szString);
+											Com_DPrintf( S_COLOR_YELLOW "One tag at %.3f,%.3f,%.3f, other at %.3f,%.3f,%.3f\n", EMPoint.fX, EMPoint.fY, EMPoint.fZ,
+												s_lpEnvTable[lEnvID].Aperture[s_lpEnvTable[lEnvID].ulNumApertures].vPos1[0], s_lpEnvTable[lEnvID].Aperture[s_lpEnvTable[lEnvID].ulNumApertures].vPos1[1],
+												s_lpEnvTable[lEnvID].Aperture[s_lpEnvTable[lEnvID].ulNumApertures].vPos1[2]);
+											bValid = false;
+										}
+									}
+									else
+									{
+										if (lEnvID==-1)
+											Com_DPrintf( S_COLOR_YELLOW "%s (%.3f,%.3f,%.3f) in Default Environment - please remove\n", szAperture, EMPoint.fX, EMPoint.fY, EMPoint.fZ);
+										else
+											Com_DPrintf( S_COLOR_YELLOW "Detected more reverb presets than zones - please delete unused presets\n");
+										bValid = false;
+									}
+								}
+							}
+						}
+					}
+				}
+				else
+				{
+					break;
+				}
+
+				if (bValid)
+				{
+					sprintf(szAperture, "Aperture%db", i);
+					if (s_lpEAXManager->GetSourceID(szAperture, &lID)==EM_OK)
+					{
+						if (s_lpEAXManager->GetSourceNumInstances(lID, &lNumInst)==EM_OK)
+						{
+							for (j = 0; j < s_lNumEnvironments; j++)
+							{
+								s_lpEnvTable[j].bUsed = false;
+							}
+
+							for (j = 0; j < lNumInst; j++)
+							{
+								if (s_lpEAXManager->GetSourceInstancePos(lID, j, &EMPoint)==EM_OK)
+								{
+									if (s_lpEAXManager->GetListenerDynamicAttributes(0, &EMPoint, &lEnvID, 0)==EM_OK)
+									{
+										if ((lEnvID >= 0) && (lEnvID < s_lNumEnvironments))
+										{
+											if (!s_lpEnvTable[lEnvID].bUsed)
+											{
+												s_lpEnvTable[lEnvID].bUsed = true;
+												s_lpEnvTable[lEnvID].Aperture[s_lpEnvTable[lEnvID].ulNumApertures].vPos2[0] = EMPoint.fX;
+												s_lpEnvTable[lEnvID].Aperture[s_lpEnvTable[lEnvID].ulNumApertures].vPos2[1] = EMPoint.fY;
+												s_lpEnvTable[lEnvID].Aperture[s_lpEnvTable[lEnvID].ulNumApertures].vPos2[2] = EMPoint.fZ;
+											}
+											else
+											{
+												s_lpEAXManager->GetEnvironmentName(lEnvID, szString, 256);
+												Com_DPrintf( S_COLOR_YELLOW "Found more than one occurance of Aperture%db in %s sub-space\n", i, szString);
+												bValid = false;
+											}
+
+											// Calculate center position of aperture (average of 2 points)
+
+											s_lpEnvTable[lEnvID].Aperture[s_lpEnvTable[lEnvID].ulNumApertures].vCenter[0] =
+												(s_lpEnvTable[lEnvID].Aperture[s_lpEnvTable[lEnvID].ulNumApertures].vPos1[0] +
+												s_lpEnvTable[lEnvID].Aperture[s_lpEnvTable[lEnvID].ulNumApertures].vPos2[0]) / 2;
+
+											s_lpEnvTable[lEnvID].Aperture[s_lpEnvTable[lEnvID].ulNumApertures].vCenter[1] =
+												(s_lpEnvTable[lEnvID].Aperture[s_lpEnvTable[lEnvID].ulNumApertures].vPos1[1] +
+												s_lpEnvTable[lEnvID].Aperture[s_lpEnvTable[lEnvID].ulNumApertures].vPos2[1]) / 2;
+
+											s_lpEnvTable[lEnvID].Aperture[s_lpEnvTable[lEnvID].ulNumApertures].vCenter[2] =
+												(s_lpEnvTable[lEnvID].Aperture[s_lpEnvTable[lEnvID].ulNumApertures].vPos1[2] +
+												s_lpEnvTable[lEnvID].Aperture[s_lpEnvTable[lEnvID].ulNumApertures].vPos2[2]) / 2;
+
+											s_lpEnvTable[lEnvID].ulNumApertures++;
+										}
+										else
+										{
+											if (lEnvID==-1)
+												Com_DPrintf( S_COLOR_YELLOW "%s (%.3f,%.3f,%.3f) in Default Environment - please remove\n", szAperture, EMPoint.fX, EMPoint.fY, EMPoint.fZ);
+											else
+												Com_DPrintf( S_COLOR_YELLOW "Detected more reverb presets than zones - please delete unused presets\n");
+											bValid = false;
+										}
+									}
+								}
+							}
+						}
+					}
+				}
+
+				if (!bValid)
+				{
+					// Found a problem
+					Com_DPrintf( S_COLOR_YELLOW "EAX legacy behaviour invoked (one reverb)\n");
+
+					Z_Free( s_lpEnvTable );
+					s_lpEnvTable = NULL;
+					break;
+				}
+
+				i++;
+			}
+		}
+		else
+		{
+			Com_DPrintf( S_COLOR_YELLOW "EAX legacy behaviour invoked (one reverb)\n");
+		}
+
+		return true;
+	}
+
+	
+	Com_DPrintf( S_COLOR_YELLOW "Failed to load %s\n", szEALFilename);
+	return false;
+}
+
+/*
+	Unload current .eal file
+*/
+void UnloadEALFile()
+{
+	HRESULT hr;
+
+	if ((!s_lpEAXManager) || (!s_bEAX))
+		return;
+
+	hr = s_lpEAXManager->FreeDataSet(0);
+	s_bEALFileLoaded = false;
+
+	if (s_lpEnvTable)
+	{
+		Z_Free( s_lpEnvTable );
+		s_lpEnvTable = NULL;
+	}
+
+	return;
+}
+
+/*
+	Updates the current EAX Reverb setting, based on the location of the listener
+*/
+void UpdateEAXListener()
+{
+	EMPOINT ListPos, ListOri;
+	EMPOINT EMAperture;
+	EMPOINT EMSourcePoint;
+	long lID, lSourceID, lApertureNum;
+	int i, j, k;
+	float flDistance, flNearest;
+	EAXREVERBPROPERTIES Reverb;
+	bool bFound;
+	long lVolume;
+	long lCurTime;
+	channel_t	*ch;
+	EAXVECTOR	LR, LP1, LP2, Pan;
+	REVERBDATA ReverbData[3]; // Hardcoded to three (maximum no of reverbs)
+#ifdef DISPLAY_CLOSEST_ENVS
+	char szEnvName[256];
+#endif
+
+	if ((!s_lpEAXManager) || (!s_bEAX))
+		return;
+	
+	lCurTime = timeGetTime();
+
+	if ((s_lLastEnvUpdate + ENV_UPDATE_RATE) < lCurTime)
+	{
+		// Update closest reverbs
+		s_lLastEnvUpdate = lCurTime;
+
+		// No panning information in .eal file, or we only have 1 FX Slot to use, revert to legacy
+		// behaviour (i.e only one reverb)
+		if ((!s_lpEnvTable) || (s_NumFXSlots==1))
+		{
+			// Convert Listener co-ordinate to left-handed system
+			ListPos.fX = listener_pos[0];
+			ListPos.fY = listener_pos[1];
+			ListPos.fZ = -listener_pos[2];
+
+			if (SUCCEEDED(s_lpEAXManager->GetListenerDynamicAttributes(0, &ListPos, &lID, EMFLAG_LOCKPOSITION)))
+			{
+				if (lID != s_EnvironmentID)
+				{
+#ifdef DISPLAY_CLOSEST_ENVS
+					if (SUCCEEDED(s_lpEAXManager->GetEnvironmentName(lID, szEnvName, 256)))
+						Com_Printf("Changing to '%s' zone !\n", szEnvName);
+#endif
+					// Get EAX Preset info.
+					if (SUCCEEDED(s_lpEAXManager->GetEnvironmentAttributes(lID, &s_eaxLPCur)))
+					{
+						// Override
+						s_eaxLPCur.flAirAbsorptionHF = 0.0f;
+
+						// Set Environment
+						s_eaxSet(&EAXPROPERTYID_EAX40_FXSlot0, EAXREVERB_ALLPARAMETERS,
+							NULL, &s_eaxLPCur, sizeof(EAXREVERBPROPERTIES));
+
+						s_EnvironmentID = lID;
+					}
+				}
+			}
+
+			return;
+		}
+
+		// Convert Listener position and orientation to left-handed system
+		ListPos.fX = listener_pos[0];
+		ListPos.fY = listener_pos[1];
+		ListPos.fZ = -listener_pos[2];
+
+		ListOri.fX = listener_ori[0];
+		ListOri.fY = listener_ori[1];
+		ListOri.fZ = -listener_ori[2];
+
+		// Need to find closest s_NumFXSlots (including the Listener's slot)
+
+		if (s_lpEAXManager->GetListenerDynamicAttributes(0, &ListPos, &lID, EMFLAG_LOCKPOSITION)==EM_OK)
+		{
+			if (lID == -1)
+			{
+				// Found default environment
+//				Com_Printf( S_COLOR_YELLOW "Listener in default environment - ignoring zone !\n");
+				return;
+			}
+
+			ReverbData[0].lEnvID = -1;
+			ReverbData[0].lApertureNum = -1;
+			ReverbData[0].flDist = FLT_MAX;
+
+			ReverbData[1].lEnvID = -1;
+			ReverbData[1].lApertureNum = -1;
+			ReverbData[1].flDist = FLT_MAX;
+
+			ReverbData[2].lEnvID = lID;
+			ReverbData[2].lApertureNum = -1;
+			ReverbData[2].flDist = 0.0f;
+
+			for (i = 0; i < s_lNumEnvironments; i++)
+			{
+				// Ignore Environment id lID as this one will always be used
+				if (i != lID)
+				{
+					flNearest = FLT_MAX;
+					lApertureNum = 0;	//shut up compile warning
+
+					for (j = 0; j < s_lpEnvTable[i].ulNumApertures; j++)
+					{
+						EMAperture.fX = s_lpEnvTable[i].Aperture[j].vCenter[0];
+						EMAperture.fY = s_lpEnvTable[i].Aperture[j].vCenter[1];
+						EMAperture.fZ = s_lpEnvTable[i].Aperture[j].vCenter[2];
+
+						flDistance = CalcDistance(EMAperture, ListPos);
+
+						if (flDistance < flNearest)
+						{
+							flNearest = flDistance;
+							lApertureNum = j;
+						}
+					}
+
+					// Now have closest point for this Environment - see if this is closer than any others
+
+					if (flNearest < ReverbData[1].flDist)
+					{
+						if (flNearest < ReverbData[0].flDist)
+						{
+							ReverbData[1] = ReverbData[0];
+							ReverbData[0].flDist = flNearest;
+							ReverbData[0].lApertureNum = lApertureNum;
+							ReverbData[0].lEnvID = i;
+						}
+						else
+						{
+							ReverbData[1].flDist = flNearest;
+							ReverbData[1].lApertureNum = lApertureNum;
+							ReverbData[1].lEnvID = i;
+						}
+					}
+				}
+			}
+
+		}
+
+#ifdef DISPLAY_CLOSEST_ENVS
+		char szEnvName1[256] = {0};
+		char szEnvName2[256] = {0};
+		char szEnvName3[256] = {0};
+
+		s_lpEAXManager->GetEnvironmentName(ReverbData[0].lEnvID, szEnvName1, 256);
+		s_lpEAXManager->GetEnvironmentName(ReverbData[1].lEnvID, szEnvName2, 256);
+		s_lpEAXManager->GetEnvironmentName(ReverbData[2].lEnvID, szEnvName3, 256);
+
+		Com_Printf("Closest zones are %s, %s (Listener in %s)\n", szEnvName1,
+			szEnvName2, szEnvName3);
+#endif
+
+		// Mute any reverbs no longer required ...
+
+		for (i = 0; i < s_NumFXSlots; i++)
+		{
+			if ((s_FXSlotInfo[i].lEnvID != -1) && (s_FXSlotInfo[i].lEnvID != ReverbData[0].lEnvID) && (s_FXSlotInfo[i].lEnvID != ReverbData[1].lEnvID)
+				&& (s_FXSlotInfo[i].lEnvID != ReverbData[2].lEnvID))
+			{
+				// This environment is no longer needed
+
+				// Mute it
+				lVolume = -10000;
+				if (s_eaxSet(&s_FXSlotInfo[i].FXSlotGuid, EAXFXSLOT_VOLUME, NULL, &lVolume, sizeof(long))!=AL_NO_ERROR)
+					OutputDebugString("Failed to Mute FX Slot\n");
+
+				// If any source is sending to this Slot ID then we need to stop them sending to the slot
+				for (j = 1; j < s_numChannels; j++)
+				{
+					if (s_channels[j].lSlotID == i)
+					{
+						if (s_eaxSet(&EAXPROPERTYID_EAX40_Source, EAXSOURCE_ACTIVEFXSLOTID, s_channels[j].alSource, (void*)&EAX_NULL_GUID, sizeof(GUID))!=AL_NO_ERROR)
+						{
+							OutputDebugString("Failed to set Source ActiveFXSlotID to NULL\n");
+						}
+
+						s_channels[j].lSlotID = -1;
+					}
+				}
+
+				assert(s_FXSlotInfo[i].lEnvID < s_lNumEnvironments && s_FXSlotInfo[i].lEnvID >= 0);
+				if (s_FXSlotInfo[i].lEnvID < s_lNumEnvironments && s_FXSlotInfo[i].lEnvID >= 0)
+				{
+					s_lpEnvTable[s_FXSlotInfo[i].lEnvID].lFXSlotID = -1;
+				}
+				s_FXSlotInfo[i].lEnvID = -1;
+			}
+		}
+
+
+		// Make sure all the reverbs we want are being rendered, if not, find an empty slot
+		// and apply appropriate reverb settings
+		for (j = 0; j < 3; j++)
+		{
+			bFound = false;
+
+			for (i = 0; i < s_NumFXSlots; i++)
+			{
+				if (s_FXSlotInfo[i].lEnvID == ReverbData[j].lEnvID)
+				{
+					bFound = true;
+					break;
+				}
+			}
+
+			if (!bFound)
+			{
+				// Find the first available slot and use that one
+				for (i = 0; i < s_NumFXSlots; i++)
+				{
+					if (s_FXSlotInfo[i].lEnvID == -1)
+					{
+						// Found slot 
+
+						// load reverb here
+
+						// Retrieve reverb properties from EAX Manager
+						if (s_lpEAXManager->GetEnvironmentAttributes(ReverbData[j].lEnvID, &Reverb)==EM_OK)
+						{
+							// Override Air Absorption HF
+							Reverb.flAirAbsorptionHF = 0.0f;
+
+							s_eaxSet(&s_FXSlotInfo[i].FXSlotGuid, EAXREVERB_ALLPARAMETERS, NULL, &Reverb, sizeof(EAXREVERBPROPERTIES));
+
+							// See if any Sources are in this environment, if they are, enable their sends
+							ch = s_channels + 1;
+							for (k = 1; k < s_numChannels; k++, ch++)
+							{
+								if (ch->fixed_origin)
+								{
+									// Converting from Quake -> DS3D (for EAGLE) ... swap Y and Z
+									EMSourcePoint.fX = ch->origin[0];
+									EMSourcePoint.fY = ch->origin[2];
+									EMSourcePoint.fZ = ch->origin[1];
+								}
+								else
+								{
+									if (ch->entnum == listener_number)
+									{
+										// Source at same position as listener
+										// Probably won't be any Occlusion / Obstruction effect -- unless the listener is underwater
+										// Converting from Open AL -> DS3D (for EAGLE) ... invert Z
+										EMSourcePoint.fX = listener_pos[0];
+										EMSourcePoint.fY = listener_pos[1];
+										EMSourcePoint.fZ = -listener_pos[2];
+									}
+									else
+									{
+										// Get position of Entity
+										// Converting from Quake -> DS3D (for EAGLE) ... swap Y and Z
+										EMSourcePoint.fX = loopSounds[ ch->entnum ].origin[0];
+										EMSourcePoint.fY = loopSounds[ ch->entnum ].origin[2];
+										EMSourcePoint.fZ = loopSounds[ ch->entnum ].origin[1];
+									}
+								}
+
+								// Get Source Environment point
+								if (s_lpEAXManager->GetListenerDynamicAttributes(0, &EMSourcePoint, &lSourceID, 0)!=EM_OK)
+									OutputDebugString("Failed to get environment zone for Source\n");
+
+								if (lSourceID == i)
+								{
+									if (s_eaxSet(&EAXPROPERTYID_EAX40_Source, EAXSOURCE_ACTIVEFXSLOTID, ch->alSource, (void*)&(s_FXSlotInfo[i].FXSlotGuid), sizeof(GUID))!=AL_NO_ERROR)
+									{
+										OutputDebugString("Failed to set Source ActiveFXSlotID to new environment\n");
+									}
+
+									ch->lSlotID = i;
+								}
+							}
+
+							assert(ReverbData[j].lEnvID < s_lNumEnvironments && ReverbData[j].lEnvID >= 0);
+							if (ReverbData[j].lEnvID < s_lNumEnvironments && ReverbData[j].lEnvID >= 0)
+							{
+								s_FXSlotInfo[i].lEnvID = ReverbData[j].lEnvID;
+								s_lpEnvTable[ReverbData[j].lEnvID].lFXSlotID = i;
+							}
+							break;
+						}
+					}
+				}
+			}
+		}
+
+		// Make sure Primary FX Slot ID is set correctly
+		if (s_EnvironmentID != ReverbData[2].lEnvID)
+		{
+			s_eaxSet(&EAXPROPERTYID_EAX40_Context, EAXCONTEXT_PRIMARYFXSLOTID, NULL, &(s_FXSlotInfo[s_lpEnvTable[ReverbData[2].lEnvID].lFXSlotID].FXSlotGuid), sizeof(GUID));
+			s_EnvironmentID = ReverbData[2].lEnvID;
+		}
+
+		// Have right reverbs loaded ... now to pan them and adjust volume
+
+
+		// We need to rotate the vector from the Listener to the reverb Aperture by minus the listener
+		// orientation
+
+		// Need dot product of Listener Orientation and the straight ahead vector (0, 0, 1)
+
+		// Since both vectors are already normalized, and two terms cancel out (0's), the angle
+		// is the arc cosine of the z component of the Listener Orientation
+
+		float flTheta = (float)acos(ListOri.fZ);
+
+		// If the Listener Orientation is to the left of straight ahead, then invert the angle
+		if (ListOri.fX < 0)
+			flTheta = -flTheta;
+
+		float flSin = (float)sin(-flTheta);
+		float flCos = (float)cos(-flTheta);
+
+		for (i = 0; i < min(s_NumFXSlots,s_lNumEnvironments); i++)
+		{
+			if (s_FXSlotInfo[i].lEnvID == s_EnvironmentID)
+			{
+				// Listener's environment
+
+				// Find the closest Aperture in *this* environment
+
+				flNearest = FLT_MAX;
+				lApertureNum = 0;	//shut up compile warning
+
+				for (j = 0; j < s_lpEnvTable[s_EnvironmentID].ulNumApertures; j++)
+				{
+					EMAperture.fX = s_lpEnvTable[s_EnvironmentID].Aperture[j].vCenter[0];
+					EMAperture.fY = s_lpEnvTable[s_EnvironmentID].Aperture[j].vCenter[1];
+					EMAperture.fZ = s_lpEnvTable[s_EnvironmentID].Aperture[j].vCenter[2];
+
+					flDistance = CalcDistance(EMAperture, ListPos);
+
+					if (flDistance < flNearest)
+					{
+						flNearest = flDistance;
+						lApertureNum = j;
+					}
+				}
+
+				// Have closest environment, work out pan vector direction
+
+				LR.x = s_lpEnvTable[s_EnvironmentID].Aperture[lApertureNum].vCenter[0] - ListPos.fX;
+				LR.y = s_lpEnvTable[s_EnvironmentID].Aperture[lApertureNum].vCenter[1] - ListPos.fY;
+				LR.z = s_lpEnvTable[s_EnvironmentID].Aperture[lApertureNum].vCenter[2] - ListPos.fZ;
+
+				Pan.x = (LR.x * flCos) + (LR.z * flSin);
+				Pan.y = 0.0f;
+				Pan.z = (LR.x * -flSin) + (LR.z * flCos);
+
+				Normalize(&Pan);
+
+
+				// Adjust magnitude ...
+
+				// Magnitude is based on the angle subtended by the aperture, so compute the angle between
+				// the vector from the Listener to Pos1 of the aperture, and the vector from the
+				// Listener to Pos2 of the aperture.
+
+				
+				LP1.x = s_lpEnvTable[s_EnvironmentID].Aperture[lApertureNum].vPos1[0] - ListPos.fX;
+				LP1.y = s_lpEnvTable[s_EnvironmentID].Aperture[lApertureNum].vPos1[1] - ListPos.fY;
+				LP1.z = s_lpEnvTable[s_EnvironmentID].Aperture[lApertureNum].vPos1[2] - ListPos.fZ;
+
+				LP2.x = s_lpEnvTable[s_EnvironmentID].Aperture[lApertureNum].vPos2[0] - ListPos.fX;
+				LP2.y = s_lpEnvTable[s_EnvironmentID].Aperture[lApertureNum].vPos2[1] - ListPos.fY;
+				LP2.z = s_lpEnvTable[s_EnvironmentID].Aperture[lApertureNum].vPos2[2] - ListPos.fZ;
+
+				Normalize(&LP1);
+				Normalize(&LP2);
+
+				float flGamma = acos((LP1.x * LP2.x) + (LP1.y * LP2.y) + (LP1.z * LP2.z));
+
+				// We want opposite magnitude (because we are 'in' this environment)
+				float flMagnitude = 1.0f - ((2.0f * (float)sin(flGamma/2.0f)) / flGamma);
+
+				// Negative (because pan should be 180 degrees)
+				Pan.x *= -flMagnitude;
+				Pan.y *= -flMagnitude;
+				Pan.z *= -flMagnitude;
+
+				if (s_eaxSet(&s_FXSlotInfo[i].FXSlotGuid, EAXREVERB_REVERBPAN, NULL, &Pan, sizeof(EAXVECTOR))!=AL_NO_ERROR)
+					OutputDebugString("Failed to set Listener Reverb Pan\n");
+
+				if (s_eaxSet(&s_FXSlotInfo[i].FXSlotGuid, EAXREVERB_REFLECTIONSPAN, NULL, &Pan, sizeof(EAXVECTOR))!=AL_NO_ERROR)
+					OutputDebugString("Failed to set Listener Reflections Pan\n");
+			}
+			else
+			{
+				// Find out which Reverb this is
+				if (ReverbData[0].lEnvID == s_FXSlotInfo[i].lEnvID)
+					k = 0;
+				else
+					k = 1;
+
+				LR.x = s_lpEnvTable[ReverbData[k].lEnvID].Aperture[ReverbData[k].lApertureNum].vCenter[0] - ListPos.fX;
+				LR.y = s_lpEnvTable[ReverbData[k].lEnvID].Aperture[ReverbData[k].lApertureNum].vCenter[1] - ListPos.fY;
+				LR.z = s_lpEnvTable[ReverbData[k].lEnvID].Aperture[ReverbData[k].lApertureNum].vCenter[2] - ListPos.fZ;
+
+				// Rotate the vector
+
+				Pan.x = (LR.x * flCos) + (LR.z * flSin);
+				Pan.y = 0.0f;
+				Pan.z = (LR.x * -flSin) + (LR.z * flCos);
+
+				Normalize(&Pan);
+
+				// Adjust magnitude ...
+
+				// Magnitude is based on the angle subtended by the aperture, so compute the angle between
+				// the vector from the Listener to Pos1 of the aperture, and the vector from the
+				// Listener to Pos2 of the aperture.
+
+				
+				LP1.x = s_lpEnvTable[ReverbData[k].lEnvID].Aperture[ReverbData[k].lApertureNum].vPos1[0] - ListPos.fX;
+				LP1.y = s_lpEnvTable[ReverbData[k].lEnvID].Aperture[ReverbData[k].lApertureNum].vPos1[1] - ListPos.fY;
+				LP1.z = s_lpEnvTable[ReverbData[k].lEnvID].Aperture[ReverbData[k].lApertureNum].vPos1[2] - ListPos.fZ;
+
+				LP2.x = s_lpEnvTable[ReverbData[k].lEnvID].Aperture[ReverbData[k].lApertureNum].vPos2[0] - ListPos.fX;
+				LP2.y = s_lpEnvTable[ReverbData[k].lEnvID].Aperture[ReverbData[k].lApertureNum].vPos2[1] - ListPos.fY;
+				LP2.z = s_lpEnvTable[ReverbData[k].lEnvID].Aperture[ReverbData[k].lApertureNum].vPos2[2] - ListPos.fZ;
+
+				Normalize(&LP1);
+				Normalize(&LP2);
+
+				float flGamma = acos((LP1.x * LP2.x) + (LP1.y * LP2.y) + (LP1.z * LP2.z));
+				float flMagnitude = (2.0f * (float)sin(flGamma/2.0f)) / flGamma;
+
+				Pan.x *= flMagnitude;
+				Pan.y *= flMagnitude;
+				Pan.z *= flMagnitude;
+
+				if (s_eaxSet(&s_FXSlotInfo[i].FXSlotGuid, EAXREVERB_REVERBPAN, NULL, &Pan, sizeof(EAXVECTOR))!=AL_NO_ERROR)
+					OutputDebugString("Failed to set Reverb Pan\n");
+
+				if (s_eaxSet(&s_FXSlotInfo[i].FXSlotGuid, EAXREVERB_REFLECTIONSPAN, NULL, &Pan, sizeof(EAXVECTOR))!=AL_NO_ERROR)
+					OutputDebugString("Failed to set Reflections Pan\n");
+			}
+		}
+
+		for (i = 0; i < s_NumFXSlots; i++)
+		{
+			if (s_FXSlotInfo[i].lEnvID == s_EnvironmentID)
+			{
+				lVolume = 0;
+				if (s_eaxSet(&s_FXSlotInfo[i].FXSlotGuid, EAXFXSLOT_VOLUME, NULL, &lVolume, sizeof(long))!=AL_NO_ERROR)
+					OutputDebugString("Failed to set Listener's FX Slot Volume to 0\n");
+			}
+			else
+			{
+				// This will change to lower the volume based on distance from aperture ...
+				lVolume = -600;
+				if (s_eaxSet(&s_FXSlotInfo[i].FXSlotGuid, EAXFXSLOT_VOLUME, NULL, &lVolume, sizeof(long))!=AL_NO_ERROR)
+					OutputDebugString("Failed to set FX Slot Volume to 0\n");
+			}
+		}
+	}
+
+	return;
+}
+
+/*
+	Updates the EAX Buffer related effects on the given Source
+*/
+void UpdateEAXBuffer(channel_t *ch)
+{
+	HRESULT hr;
+	EMPOINT EMSourcePoint;
+	EMPOINT EMVirtualSourcePoint;
+	EAXOBSTRUCTIONPROPERTIES eaxOBProp;
+	EAXOCCLUSIONPROPERTIES eaxOCProp;
+	int i;
+	long lSourceID;
+
+	// If EAX Manager is not initialized, or there is no EAX support, or the listener
+	// is underwater, return
+	if ((!s_lpEAXManager) || (!s_bEAX) || (s_bInWater))
+		return;
+	
+	// Set Occlusion Direct Ratio to the default value (it won't get set by the current version of
+	// EAX Manager)
+	eaxOCProp.flOcclusionDirectRatio = EAXSOURCE_DEFAULTOCCLUSIONDIRECTRATIO;
+
+	// Convert Source co-ordinate to left-handed system
+	if (ch->fixed_origin)
+	{
+		// Converting from Quake -> DS3D (for EAGLE) ... swap Y and Z
+		EMSourcePoint.fX = ch->origin[0];
+		EMSourcePoint.fY = ch->origin[2];
+		EMSourcePoint.fZ = ch->origin[1];
+	}
+	else
+	{
+		if (ch->entnum == listener_number)
+		{
+			// Source at same position as listener
+			// Probably won't be any Occlusion / Obstruction effect -- unless the listener is underwater
+			// Converting from Open AL -> DS3D (for EAGLE) ... invert Z
+			EMSourcePoint.fX = listener_pos[0];
+			EMSourcePoint.fY = listener_pos[1];
+			EMSourcePoint.fZ = -listener_pos[2];
+		}
+		else
+		{
+			// Get position of Entity
+			// Converting from Quake -> DS3D (for EAGLE) ... swap Y and Z
+			if (ch->bLooping)
+			{
+				EMSourcePoint.fX = loopSounds[ ch->entnum ].origin[0];
+				EMSourcePoint.fY = loopSounds[ ch->entnum ].origin[2];
+				EMSourcePoint.fZ = loopSounds[ ch->entnum ].origin[1];
+			}
+			else
+			{
+				EMSourcePoint.fX = s_entityPosition[ch->entnum][0];
+				EMSourcePoint.fY = s_entityPosition[ch->entnum][2];
+				EMSourcePoint.fZ = s_entityPosition[ch->entnum][1];
+			}
+		}
+	}
+
+	long lExclusion;
+
+	// Just determine what environment the source is in
+	if (s_lpEAXManager->GetListenerDynamicAttributes(0, &EMSourcePoint, &lSourceID, 0)==EM_OK)
+	{
+		// See if a Slot is rendering this environment
+		for (i = 0; i < s_NumFXSlots; i++)
+		{
+			if (s_FXSlotInfo[i].lEnvID == lSourceID)
+			{
+				// If the Source is not sending to this slot, then enable the send now
+				if (ch->lSlotID != i)
+				{
+					// Set this
+					if (s_eaxSet(&EAXPROPERTYID_EAX40_Source, EAXSOURCE_ACTIVEFXSLOTID, ch->alSource, &s_FXSlotInfo[i].FXSlotGuid, sizeof(GUID))!=AL_NO_ERROR)
+						OutputDebugString("UpdateEAXBuffer = failed to set ActiveFXSlotID\n");
+
+					ch->lSlotID = i;
+				}
+
+				break;
+			}
+		}
+	}
+	else
+	{
+		OutputDebugString("UpdateEAXBuffer::Failed to get Source environment zone\n");
+	}
+
+	// Add some Exclusion to sounds that are not located in the Listener's environment
+	if (s_FXSlotInfo[ch->lSlotID].lEnvID == s_EnvironmentID)
+	{
+		lExclusion = 0;
+		if (s_eaxSet(&EAXPROPERTYID_EAX40_Source, EAXSOURCE_EXCLUSION, ch->alSource, &lExclusion, sizeof(long))!=AL_NO_ERROR)
+			OutputDebugString("UpdateEAXBuffer : Failed to set exclusion to 0\n");
+	}
+	else
+	{
+		lExclusion = -1000;
+		if (s_eaxSet(&EAXPROPERTYID_EAX40_Source, EAXSOURCE_EXCLUSION, ch->alSource, &lExclusion, sizeof(long))!=AL_NO_ERROR)
+			OutputDebugString("UpdateEAXBuffer : Failed to set exclusion to -1000\n");
+	}
+
+	if ((ch->entchannel == CHAN_VOICE) || (ch->entchannel == CHAN_VOICE_ATTEN) || (ch->entchannel == CHAN_VOICE_GLOBAL))
+	{
+		// Remove any Occlusion + Obstruction
+		eaxOBProp.lObstruction = EAXSOURCE_DEFAULTOBSTRUCTION;
+		eaxOBProp.flObstructionLFRatio = EAXSOURCE_DEFAULTOBSTRUCTIONLFRATIO;
+
+		eaxOCProp.lOcclusion = EAXSOURCE_DEFAULTOCCLUSION;
+		eaxOCProp.flOcclusionLFRatio = EAXSOURCE_DEFAULTOCCLUSIONLFRATIO;
+		eaxOCProp.flOcclusionRoomRatio = EAXSOURCE_DEFAULTOCCLUSIONROOMRATIO;
+		eaxOCProp.flOcclusionDirectRatio = EAXSOURCE_DEFAULTOCCLUSIONDIRECTRATIO;
+
+		s_eaxSet(&EAXPROPERTYID_EAX40_Source, EAXSOURCE_OBSTRUCTIONPARAMETERS,
+			ch->alSource, &eaxOBProp, sizeof(EAXOBSTRUCTIONPROPERTIES));
+
+		s_eaxSet(&EAXPROPERTYID_EAX40_Source, EAXSOURCE_OCCLUSIONPARAMETERS,
+			ch->alSource, &eaxOCProp, sizeof(EAXOCCLUSIONPROPERTIES));
+	}
+	else
+	{
+		// Check for Occlusion + Obstruction
+		hr = s_lpEAXManager->GetSourceDynamicAttributes(0, &EMSourcePoint, &eaxOBProp.lObstruction, &eaxOBProp.flObstructionLFRatio,
+			&eaxOCProp.lOcclusion, &eaxOCProp.flOcclusionLFRatio, &eaxOCProp.flOcclusionRoomRatio, &EMVirtualSourcePoint, 0);
+		if (hr == EM_OK)
+		{	
+			// Set EAX effect !
+			s_eaxSet(&EAXPROPERTYID_EAX40_Source, EAXSOURCE_OBSTRUCTIONPARAMETERS,
+				ch->alSource, &eaxOBProp, sizeof(EAXOBSTRUCTIONPROPERTIES));
+
+			s_eaxSet(&EAXPROPERTYID_EAX40_Source, EAXSOURCE_OCCLUSIONPARAMETERS,
+				ch->alSource, &eaxOCProp, sizeof(EAXOCCLUSIONPROPERTIES));
+		}
+	}
+
+	return;
+}
+
+float CalcDistance(EMPOINT A, EMPOINT B)
+{
+	return (float)sqrt(sqr(A.fX - B.fX)+sqr(A.fY - B.fY) + sqr(A.fZ - B.fZ));
+}
diff --git a/codemp/client/snd_dma_console.cpp b/codemp/client/snd_dma_console.cpp
new file mode 100644
index 0000000..146d9df
--- /dev/null
+++ b/codemp/client/snd_dma_console.cpp
@@ -0,0 +1,2933 @@
+/*****************************************************************************
+ * name:		snd_dma.c
+ *
+ * desc:		main control for any streaming sound output device
+ *
+ *
+ *****************************************************************************/
+// leave this as first line for PCH reasons...
+//
+// #include "../server/exe_headers.h"
+
+#include "snd_local_console.h"
+#include "snd_music.h"
+
+// #include "../../toolbox/zlib/zlib.h"
+
+#include "../client/client.h"
+
+// Doesn't do anything on Xbox
+qboolean s_shutUp = qfalse;
+
+#ifdef _XBOX
+#include <Xtl.h>
+#endif
+
+#ifdef _GAMECUBE
+typedef const char* LPCSTR;
+#endif
+
+static void S_Play_f(void);
+#ifndef _JK2MP
+static void S_PlayEx_f(void);
+#endif
+static void S_SoundList_f(void);
+static void S_Music_f(void);
+
+void S_Update_();
+void S_StopAllSounds(void);
+static void S_UpdateBackgroundTrack( void );
+unsigned int S_HashName( const char *name );
+static int SND_FreeSFXMem(sfx_t *sfx);
+
+/*static void S_FreeAllSFXMem(void);
+static void S_UnCacheDynamicMusic( void );
+*/
+extern unsigned long crc32(unsigned long crc, const unsigned char *buf, unsigned long len);
+
+extern int Sys_GetFileCodeSize(int code);
+
+extern void Sys_StreamInit(void);
+extern void Sys_StreamShutdown(void);
+
+qboolean SND_RegisterAudio_Clean(void);
+void S_KillEntityChannel(int entnum, int chan);
+
+//////////////////////////
+//
+// vars for bgrnd music track...
+//
+typedef struct
+{	
+	//
+	// disk-load stuff
+	//
+	char		sLoadedDataName[MAX_QPATH];
+	int			iFileCode;
+	int			iFileSeekTo;
+	bool		bLoaded;
+	//
+	// remaining dynamic fields...
+	//
+	int			iXFadeVolumeSeekTime;
+	int			iXFadeVolumeSeekTo;	// when changing this, set the above timer to Sys_Milliseconds(). 
+									//	Note that this should be thought of more as an up/down bool rather than as a 
+									//	number now, in other words set it only to 0 or 255. I'll probably change this
+									//	to actually be a bool later.
+	int			iXFadeVolume;		// 0 = silent, 255 = max mixer vol, though still modulated via overall music_volume 
+	float		fSmoothedOutVolume;
+	qboolean	bActive;			// whether playing or not
+	qboolean	bExists;			// whether was even loaded for this level (ie don't try and start playing it)
+	//
+	// new dynamic fields...
+	//
+	qboolean		bTrackSwitchPending;
+	qboolean		bLooping;
+	MusicState_e	eTS_NewState;
+	float			fTS_NewTime;
+	//
+	// Generic...
+	//
+	int				s_backgroundSize;
+	int				s_backgroundBPS;
+
+	void Rewind()
+	{
+		iFileSeekTo = 0;
+	}
+
+	void SeekTo(float fTime)
+	{
+		iFileSeekTo = (int)((float)(s_backgroundBPS) * fTime);
+	}
+
+	float TotalTime(void)
+	{
+		return (float)(s_backgroundSize) / (float)(s_backgroundBPS);
+	}
+
+	float PlayTime(void)
+	{
+		ALfloat playTime;
+		alGetStreamf(AL_TIME, &playTime);
+		return playTime;
+	}
+
+	float ElapsedTime(void)
+	{
+		return fmod(PlayTime(), TotalTime());
+	}
+} MusicInfo_t;
+
+static void S_SetDynamicMusicState( MusicState_e musicState );
+
+#define fDYNAMIC_XFADE_SECONDS (1.f)
+
+static MusicInfo_t	tMusic_Info[eBGRNDTRACK_NUMBEROF]	= {0};
+static qboolean		bMusic_IsDynamic					= qfalse;
+static MusicState_e	eMusic_StateActual					= eBGRNDTRACK_EXPLORE;	// actual state, can be any enum
+static MusicState_e	eMusic_StateRequest					= eBGRNDTRACK_EXPLORE;	// requested state, can only be explore, action, boss, or silence
+static char			sMusic_BackgroundLoop[MAX_QPATH]	= {0};	// only valid for non-dynamic music
+static char			sInfoOnly_CurrentDynamicMusicSet[64];	// any old reasonable size, only has to fit stuff like "kejim_post"
+//
+//////////////////////////
+
+// =======================================================================
+// Internal sound data & structures
+// =======================================================================
+ 
+// only begin attenuating sound volumes when outside the FULLVOLUME range
+#define		SOUND_FULLVOLUME	256
+
+#define		SOUND_ATTENUATE		0.0008f
+#define		VOICE_ATTENUATE		0.004f
+
+// This number has dramatic affects on volume.  QA has
+// determined that 100 is too quiet in some spots and
+// 200 is too loud in others.  Modify with care...
+#define		SOUND_REF_DIST_BASE	150.f
+
+#define		SOUND_UPDATE_TIME	100
+
+const float	SOUND_FMAXVOL=0.75;//1.0;
+const int	SOUND_MAXVOL=255;
+
+int					s_soundStarted;
+qboolean			s_soundMuted;
+int					s_loopEnabled;
+int					s_updateTime;
+
+struct listener_t
+{
+	ALuint handle;
+	ALfloat pos[3];
+	ALfloat orient[6];
+	int entnum;
+};
+
+#define SND_MAX_LISTENERS 2
+static listener_t s_listeners[SND_MAX_LISTENERS];
+static int s_numListeners;
+
+static int			s_numChannels;			// Number of AL Sources == Num of Channels
+
+#ifdef _XBOX
+#	define	MAX_CHANNELS_2D 64
+#	define	MAX_CHANNELS_3D 64
+#else
+#	define	MAX_CHANNELS_2D 30
+#	define	MAX_CHANNELS_3D 30
+#endif
+
+#define MAX_CHANNELS (MAX_CHANNELS_2D + MAX_CHANNELS_3D)
+static channel_t*   s_channels;
+
+#define	MAX_SFX 2048
+#define INVALID_CODE 0
+static sfx_t* s_sfxBlock;
+static int* s_sfxCodes;
+
+static bool s_registered = false;
+static int s_defaultSound = 0;
+
+typedef struct 
+{ 
+	int				volume;
+	vec3_t			origin;
+	sfx_t			*sfx;
+	int				entnum;
+	int				entchannel;
+	bool			bProcessed;
+	bool			bMarked;
+} loopSound_t;
+
+#define	MAX_LOOP_SOUNDS 32
+static int numLoopSounds;
+static loopSound_t* loopSounds;
+
+int* s_entityWavVol = NULL;
+
+cvar_t		*s_effects_volume;
+cvar_t		*s_music_volume;
+cvar_t		*s_voice_volume;
+cvar_t		*s_testsound;
+cvar_t		*s_allowDynamicMusic;
+cvar_t		*s_show;
+cvar_t		*s_separation;
+cvar_t		*s_CPUType;
+cvar_t		*s_debugdynamic;
+cvar_t		*s_soundpoolmegs;
+cvar_t		*s_language;	// note that this is distinct from "g_language"
+
+
+
+void S_SoundInfo_f(void) {	
+	Com_Printf("----- Sound Info -----\n" );
+
+	if (!s_soundStarted) {
+		Com_Printf ("sound system not started\n");
+	} else {
+		if ( s_soundMuted ) {
+			Com_Printf ("sound system is muted\n");
+		}
+	}
+	S_DisplayFreeMemory();
+	Com_Printf("----------------------\n" );
+}
+
+
+
+/*
+================
+S_Init
+================
+*/
+void S_Init( void ) {
+	ALCcontext *ALCContext = NULL;
+	ALCdevice *ALCDevice = NULL;
+	cvar_t	*cv;
+
+	Com_Printf("\n------- sound initialization -------\n");
+
+	AS_Init();
+
+	s_effects_volume = Cvar_Get ("s_effects_volume", "0.5", CVAR_ARCHIVE);
+	s_voice_volume= Cvar_Get ("s_voice_volume", "1.0", CVAR_ARCHIVE);
+	s_music_volume = Cvar_Get ("s_music_volume", "0.25", CVAR_ARCHIVE);
+	s_separation = Cvar_Get ("s_separation", "0.5", CVAR_ARCHIVE);
+	s_allowDynamicMusic = Cvar_Get ("s_allowDynamicMusic", "1", CVAR_ARCHIVE);
+
+	s_show = Cvar_Get ("s_show", "0", CVAR_CHEAT);
+	s_testsound = Cvar_Get ("s_testsound", "0", CVAR_CHEAT);
+	s_debugdynamic = Cvar_Get("s_debugdynamic","0", CVAR_CHEAT);
+
+	s_CPUType = Cvar_Get("sys_cpuid","",0);
+	s_soundpoolmegs = Cvar_Get("s_soundpoolmegs", "6", CVAR_ARCHIVE);
+
+	s_language = Cvar_Get("s_language","english",CVAR_ARCHIVE | CVAR_NORESTART);
+
+	cv = Cvar_Get ("s_initsound", "1", CVAR_ROM);
+	if ( !cv->integer ) {
+		s_soundStarted = 0;	// needed in case you set s_initsound to 0 midgame then snd_restart (div0 err otherwise later)
+		Com_Printf ("not initializing.\n");
+		Com_Printf("------------------------------------\n");
+		return;
+	}
+
+	Cmd_AddCommand("play", S_Play_f);
+#ifndef _JK2MP
+	Cmd_AddCommand("playex", S_PlayEx_f);
+#endif
+	Cmd_AddCommand("music", S_Music_f);
+	Cmd_AddCommand("soundlist", S_SoundList_f);
+	Cmd_AddCommand("soundinfo", S_SoundInfo_f);
+	Cmd_AddCommand("soundstop", S_StopAllSounds);
+
+	s_entityWavVol = new int[MAX_GENTITIES];
+	
+	// clear out the lip synching override array
+	memset(s_entityWavVol, 0, sizeof(int) * MAX_GENTITIES);
+
+	ALCDevice = alcOpenDevice((ALubyte*)"DirectSound3D");
+	if (!ALCDevice)
+		return;
+
+	//Create context(s)
+	ALCContext = alcCreateContext(ALCDevice, NULL);
+	if (!ALCContext)
+		return;
+
+	//Set active context
+	alcMakeContextCurrent(ALCContext);		
+	if (alcGetError(ALCDevice) != ALC_NO_ERROR)
+		return;
+
+	s_channels = new channel_t[MAX_CHANNELS];
+	
+	s_sfxBlock = new sfx_t[MAX_SFX];
+	s_sfxCodes = new int[MAX_SFX];
+	memset(s_sfxCodes, INVALID_CODE, sizeof(int) * MAX_SFX);
+
+	loopSounds = new loopSound_t[MAX_LOOP_SOUNDS];
+
+	S_StopAllSounds();
+
+	s_soundStarted = 1;
+	s_soundMuted = 1;
+	s_loopEnabled = 0;
+	s_updateTime = 0;
+
+	S_SoundInfo_f();
+
+	memset(s_channels, 0, sizeof(channel_t) * MAX_CHANNELS);
+	s_numChannels = 0;
+	
+	// create music channel
+	alGenStream();
+
+	Com_Printf("------------------------------------\n");
+
+	S_InitLoad();
+}
+
+// only called from snd_restart. QA request...
+//
+void S_ReloadAllUsedSounds(void)
+{
+	if (s_soundStarted && !s_soundMuted )
+	{
+		// new bit, reload all soundsthat are used on the current level->..
+		//
+		for (int i = 0; i < MAX_SFX; ++i)
+		{
+			if (s_sfxCodes[i] == INVALID_CODE || s_sfxCodes[i] == s_defaultSound) continue;
+
+			sfx_t *sfx = &s_sfxBlock[i];
+
+			if ((sfx->iFlags & SFX_FLAG_UNLOADED) && 
+				!(sfx->iFlags & (SFX_FLAG_DEFAULT | SFX_FLAG_DEMAND)))
+			{
+				S_StartLoadSound(sfx);
+			}
+		}
+	}
+}
+
+// =======================================================================
+// Shutdown sound engine
+// =======================================================================
+
+void S_Shutdown( void )
+{
+	ALCcontext	*ALCContext;
+	ALCdevice	*ALCDevice;
+	int			i;
+
+	delete [] s_entityWavVol;
+	s_entityWavVol = NULL;
+
+	if ( !s_soundStarted ) {
+		return;
+	}
+
+	alDeleteStream();
+
+	// Release all the AL Sources (including Music channel (Source 0))
+	for (i = 0; i < s_numChannels; i++)
+	{
+		alDeleteSources(1, &(s_channels[i].alSource));
+	}
+
+	S_FreeAllSFXMem();
+	S_UnCacheDynamicMusic();
+	
+	// Release listeners
+	for (i = 0; i < s_numListeners; ++i)
+	{
+		alDeleteListeners(1, &s_listeners[i].handle);
+	}
+	s_numListeners = 0;
+	
+	delete [] s_channels;
+	delete [] s_sfxBlock;
+	delete [] s_sfxCodes;
+	delete [] loopSounds;
+
+	// Get active context
+	ALCContext = alcGetCurrentContext();
+	// Get device for active context
+	ALCDevice = alcGetContextsDevice(ALCContext);
+	// Release context(s)
+	alcDestroyContext(ALCContext);
+	// Close device
+	alcCloseDevice(ALCDevice);
+	
+	s_numChannels = 0;
+	s_soundStarted = 0;
+
+	Cmd_RemoveCommand("play");
+	Cmd_RemoveCommand("music");
+	Cmd_RemoveCommand("stopsound");
+	Cmd_RemoveCommand("soundlist");
+	Cmd_RemoveCommand("soundinfo");
+	AS_Free();
+	S_CloseLoad();
+}
+
+
+
+/*
+	Mutes / Unmutes all OpenAL sound
+*/
+void S_AL_MuteAllSounds(qboolean bMute)
+{
+	if (!s_soundStarted) return;
+	if (bMute) alGain(0.f);
+	else alGain(1.f);
+}
+
+void S_SetVolume(float volume)
+{
+	if (!s_soundStarted) return;
+	alGain(volume);
+	alUpdate();
+}
+
+
+
+
+
+// =======================================================================
+// Load a sound
+// =======================================================================
+/*
+==================
+S_FixMusicFileExtension
+==================
+*/
+char* S_FixMusicFileName(const char* name)
+{
+	static char xname[MAX_QPATH];
+
+#if defined(_XBOX)
+	const char* ext = "wxb";
+#elif defined(_WINDOWS)
+	const char* ext = "wav";
+#elif defined(_GAMECUBE)
+	const char* ext = "adp";
+#endif
+
+	Q_strncpyz(xname, name, sizeof(xname));
+	if (xname[strlen(xname) - 4] != '.')
+	{
+		strcat(xname, ".");
+		strcat(xname, ext);
+	}
+	else
+	{
+		int len = strlen(xname);
+		xname[len-3] = ext[0];
+		xname[len-2] = ext[1];
+		xname[len-1] = ext[2];
+	}
+
+#ifdef _GAMECUBE
+	if (!strncmp("music/", xname, 6) ||
+		!strncmp("music\\", xname, 6))
+	{
+		char chan_name[MAX_QPATH];
+
+		/*
+		ALint is_stereo;
+		alGeti(AL_STEREO, &is_stereo);
+
+		sprintf(chan_name,"music-%s/%s", 
+			is_stereo ? "stereo" : "mono", &xname[6]);
+		strcpy(xname, chan_name);
+		*/
+
+		sprintf(chan_name,"music-stereo/%s", &xname[6]);
+		strcpy(xname, chan_name);
+	}
+#endif
+	
+	return xname;
+}
+
+
+/*
+==================
+S_HashName
+==================
+*/
+unsigned int S_HashName( const char *name ) {
+	if (!name) {
+		Com_Error (ERR_FATAL, "S_HashName: NULL\n");
+	}
+	if (!name[0]) {
+		Com_Error (ERR_FATAL, "S_HashName: empty name\n");
+	}
+
+	if (strlen(name) >= MAX_QPATH) {
+		Com_Error (ERR_FATAL, "Sound name too long: %s", name);
+	}
+
+	char sSoundNameNoExt[MAX_QPATH];
+	COM_StripExtension(name,sSoundNameNoExt);
+
+	Q_strlwr(sSoundNameNoExt);
+	for (int i = 0; i < strlen(sSoundNameNoExt); ++i)
+	{
+		if (sSoundNameNoExt[i] == '\\') sSoundNameNoExt[i] = '/';
+	}
+
+	return crc32(0, (const byte *)sSoundNameNoExt, strlen(sSoundNameNoExt));
+}
+
+/*
+===================
+S_DisableSounds
+
+Disables sounds until the next S_BeginRegistration.
+This is called when the hunk is cleared and the sounds
+are no longer valid.
+===================
+*/
+void S_DisableSounds( void ) {
+	if (!s_soundStarted) return;
+	S_StopAllSounds();
+	SND_RegisterAudio_Clean(); // unregister sounds
+	s_soundMuted = qtrue;
+}
+
+void S_SetLoopState( qboolean s ) {
+	if (!s_soundStarted) return;
+	s_loopEnabled = s;
+}
+
+void S_CreateSources( void ) {
+	int i;
+
+	// Remove any old sources
+	for (i = 0; i < s_numChannels; ++i)
+	{
+		alDeleteSources(1, &s_channels[i].alSource);
+	}
+	s_numChannels = 0;
+
+	// Create as many AL Sources (up to Max) as possible
+	int limit = MAX_CHANNELS_2D + MAX_CHANNELS_3D / s_numListeners;
+	for (i = 0; i < limit; i++)
+	{
+		if (i < MAX_CHANNELS_2D)
+		{
+			alGenSources2D(1, &s_channels[i].alSource);
+			s_channels[i].b2D = true;
+		}
+		else
+		{
+			alGenSources3D(1, &s_channels[i].alSource);
+			s_channels[i].b2D = false;
+		}
+
+		if (alGetError() != AL_NO_ERROR)
+		{
+			// Reached limit of sources
+			break;
+		}
+
+		if (!s_channels[i].b2D)
+		{
+			alSourcef(s_channels[i].alSource, AL_REFERENCE_DISTANCE, SOUND_REF_DIST_BASE);
+		}
+
+		s_numChannels++;
+	}
+
+	assert(s_numChannels > MAX_CHANNELS_2D);
+}
+
+/*
+=====================
+S_BeginRegistration
+
+=====================
+*/
+extern bool debugSoundOff;
+void S_BeginRegistration( void )
+{
+	if (!s_soundStarted) return;
+
+	int i;
+	int num_listeners = 1;
+
+	if(!debugSoundOff) {
+		s_soundMuted = qfalse;		// we can play again
+	}
+
+	// Create listeners
+	assert(num_listeners <= SND_MAX_LISTENERS);
+	if (num_listeners < s_numListeners)
+	{
+		// remove some listeners
+		for (i = num_listeners; i < s_numListeners; ++i)
+		{
+			alDeleteListeners(1, &s_listeners[i].handle);
+		}
+
+		s_numListeners = num_listeners;
+	
+		S_CreateSources();
+	}
+	else if (num_listeners > s_numListeners)
+	{
+		// add some listeners
+		for (i = s_numListeners; i < num_listeners; ++i)
+		{
+			memset(&s_listeners[i], 0, sizeof(listener_t));
+			s_listeners[i].entnum = i;
+			s_listeners[i].orient[2] = -1;
+			s_listeners[i].orient[4] = 1;
+			alGenListeners(1, &s_listeners[i].handle);
+			alListenerfv(s_listeners[i].handle, AL_POSITION, s_listeners[i].pos);
+			alListenerfv(s_listeners[i].handle, AL_ORIENTATION, s_listeners[i].orient);
+		}
+		
+		s_numListeners = num_listeners;
+		
+		S_CreateSources();
+	}
+
+	S_SetLoopState(qtrue);
+
+	if (!s_registered) {
+		s_defaultSound = S_RegisterSound("sound/null.wav");
+		S_LoadSound(s_defaultSound);
+		s_registered = true;
+	}
+}
+
+/*
+==================
+S_LookupSfx
+==================
+*/
+sfxHandle_t S_LookupSfx(int hash) 
+{
+	for (int i = 0; i < MAX_SFX; ++i)
+	{
+		if (s_sfxCodes[i] == hash)
+		{
+			return i;
+		}
+	}
+	return -1;
+}
+
+/*
+==================
+S_AllocSfx
+==================
+*/
+sfxHandle_t S_AllocSfx(int hash) 
+{
+	for (int i = 0; i < MAX_SFX; ++i)
+	{
+		if (s_sfxCodes[i] == INVALID_CODE)
+		{
+			s_sfxCodes[i] = hash;
+			return i;
+		}
+	}
+	return -1;
+}
+
+
+/*
+==================
+S_RegisterSound
+
+Creates a default buzz sound if the file can't be loaded
+==================
+*/
+sfxHandle_t	S_RegisterSound(const char *name)
+{
+	sfx_t *sfx;
+	unsigned int hash;
+	sfxHandle_t handle;
+
+	if (!s_soundStarted) {
+		return 0;
+	}
+
+	if ( strlen( name ) >= MAX_QPATH || !name[0] ) {		
+		Com_Printf( S_COLOR_RED"Sound name exceeds MAX_QPATH - %s\n", name );
+		return s_defaultSound;
+	}
+
+	hash = S_HashName( name );
+	handle = S_LookupSfx(hash);
+	
+	if (handle < 0)
+	{
+		handle = S_AllocSfx(hash);
+
+		if (handle < 0)
+			Com_Error (ERR_DROP, "No free sound channels");
+
+		sfx = &s_sfxBlock[handle];
+		memset(sfx, 0, sizeof(sfx_t));
+
+		if (strlen(name) < 5 || name[0] == '*') sfx->iFileCode = -1;
+		else sfx->iFileCode = S_GetFileCode(name);
+
+		sfx->iFlags |= SFX_FLAG_UNLOADED;
+	}
+	else
+	{
+		sfx = &s_sfxBlock[handle];
+	}
+
+	SND_TouchSFX(sfx);
+
+	if ( sfx->iFileCode == -1 ) sfx->iFlags |= SFX_FLAG_DEFAULT;
+
+	if (strstr(name, "chars") ||
+		strstr(name, "chr_d") ||
+		strstr(name, "chr_f"))
+	{
+		sfx->iFlags |= SFX_FLAG_VOICE;
+		sfx->iFlags |= SFX_FLAG_DEMAND;
+	}
+
+	if ( sfx->iFlags & SFX_FLAG_DEFAULT )
+	{
+		sfx->iFlags |= SFX_FLAG_RESIDENT;
+		return s_defaultSound;
+	}
+
+	return handle;
+}
+
+
+//=============================================================================
+channel_t *S_FindFurthestChannel(void)
+{
+	int			ch_idx;
+	channel_t	*ch;
+	channel_t	*ch_firstToDie = NULL;
+	int			li_idx;
+	listener_t	*li;
+	int			longestDist = -1;
+	int			dist;
+
+	for (li_idx = 0, li = s_listeners; li_idx < s_numListeners; ++li_idx, ++li)
+	{
+		for (ch_idx = MAX_CHANNELS_2D, ch = s_channels + ch_idx; 
+		ch_idx < s_numChannels; ch_idx++, ch++)
+		{				
+			dist = 
+				((li->pos[0] - ch->origin[0]) * (li->pos[0] - ch->origin[0])) +
+				((li->pos[1] - ch->origin[1]) * (li->pos[1] - ch->origin[1])) +
+				((li->pos[2] - ch->origin[2]) * (li->pos[2] - ch->origin[2]));
+			
+			if (dist > longestDist)
+			{
+				longestDist = dist;
+				ch_firstToDie = ch;
+			}
+		}
+	}
+
+	return ch_firstToDie;
+}
+
+static bool IsListenerEnt(int entnum)
+{
+	for (int i = 0; i < s_numListeners; ++i)
+	{
+		if (s_listeners[i].entnum == entnum) return true;
+	}
+	return false;
+}
+
+/*
+=================
+S_PickChannel
+=================
+*/
+channel_t *S_PickChannel(int entnum, int entchannel, bool is2D, sfx_t* sfx)
+{
+	int			ch_idx;
+	channel_t	*ch, *ch_firstToDie;
+	bool	foundChan = false;
+
+	if ( entchannel < 0 ) 
+	{
+		Com_Error (ERR_DROP, "S_PickChannel: entchannel<0");
+	}
+
+	// Check for replacement sound, or find the best one to replace
+
+    ch_firstToDie = s_channels;
+	unsigned int age = 0xFFFFFFFF;
+
+	for (ch_idx = 0, ch = s_channels + ch_idx; ch_idx < s_numChannels; ch_idx++, ch++)
+	{
+		// Special check to prevent 2d voices from being played
+		// twice in 2 player games...
+		if (is2D && ch->b2D && 
+			sfx == ch->thesfx && 
+			ch->bPlaying && 
+			(sfx->iFlags & SFX_FLAG_VOICE))
+		{
+			return NULL;
+		}
+		
+		// See if the channel is free
+		if (!ch->thesfx && is2D == ch->b2D && ch->iLastPlayTime < age)
+		{
+			ch_firstToDie = ch;
+			age = ch->iLastPlayTime;
+			foundChan = true;
+		}
+	}
+
+	if (!foundChan)
+	{
+		for (ch_idx = 0, ch = s_channels + ch_idx; ch_idx < s_numChannels; ch_idx++, ch++)
+		{
+			if ( (ch->entnum == entnum) && 
+				(ch->entchannel == entchannel) && 
+				(ch->entchannel != CHAN_AMBIENT) && 
+				(!IsListenerEnt(ch->entnum)) &&
+				(ch->b2D == is2D) &&
+				(!ch_firstToDie->thesfx || 
+				!(ch_firstToDie->thesfx->iFlags & SFX_FLAG_LOADING)) ) 
+			{
+				// Same entity and same type of sound effect (entchannel)
+				ch_firstToDie = ch;
+				foundChan = true;
+				break;
+			}
+		}
+	}
+
+	if (!foundChan)
+	{
+		if (is2D)
+		{
+			// Find random sound effect
+			ch_firstToDie = s_channels + (rand() % MAX_CHANNELS_2D);
+		}
+		else
+		{
+			// Find sound effect furthest from listeners
+			ch_firstToDie = S_FindFurthestChannel();
+		}
+	}
+
+	assert(ch_firstToDie->b2D == is2D);
+
+	if (ch_firstToDie->thesfx && ch_firstToDie->thesfx->iFlags & SFX_FLAG_LOADING)
+	{
+		// If the sound is loading, just give up...
+		return NULL;
+	}
+	
+	if (ch_firstToDie->bPlaying)
+	{
+#ifdef _XBOX
+		// We have an insane amount of channels on the Xbox
+		// and stopping one is a blocking operation.  Let's
+		// just assume that no one will care if a sound is
+		// dropped when over 100 are already playing...
+		return NULL;
+#else
+		// Stop sound
+		alSourceStop(ch_firstToDie->alSource);
+		ch_firstToDie->bPlaying = false;
+#endif
+	}
+
+	// Reset channel variables
+	alSourcei(ch_firstToDie->alSource, AL_BUFFER, 0);
+	ch_firstToDie->thesfx = NULL;
+	ch_firstToDie->bLooping = false;
+	
+    return ch_firstToDie;
+}
+
+
+
+// =======================================================================
+// Start a sound effect
+// =======================================================================
+
+static void SetChannelOrigin(channel_t *ch, const vec3_t origin, int entityNum)
+{
+	if (origin) 
+	{
+		ch->origin[0] = origin[0];
+		ch->origin[1] = origin[1];
+		ch->origin[2] = origin[2];
+	}
+	else
+	{
+		vec3_t pos;
+
+		extern void G_EntityPosition( int i, vec3_t ret );
+		G_EntityPosition(entityNum, pos);
+		
+		ch->origin[0] = pos[0];
+		ch->origin[1] = pos[1];
+		ch->origin[2] = pos[2];
+	}
+
+	ch->bOriginDirty = true;
+}
+
+/*
+====================
+S_StartAmbientSound
+
+Starts an ambient, 'one-shot" sound.
+====================
+*/
+
+void S_StartAmbientSound( const vec3_t origin, int entityNum, unsigned char volume, sfxHandle_t sfxHandle )
+{
+	channel_t	*ch;
+	/*const*/ sfx_t *sfx;
+
+	if ( !s_soundStarted || s_soundMuted ) {
+		return;
+	}
+	if ( sfxHandle < 0 || sfxHandle > MAX_SFX || s_sfxCodes[sfxHandle] == INVALID_CODE ) {
+		return;
+	}
+	if ( !origin && ( entityNum < 0 || entityNum > MAX_GENTITIES ) ) {
+		Com_Error( ERR_DROP, "S_StartAmbientSound: bad entitynum %i", entityNum );
+	}
+
+	sfx = &s_sfxBlock[sfxHandle];
+	if (sfx->iFlags & SFX_FLAG_UNLOADED){
+		S_StartLoadSound(sfx);
+	}	
+	SND_TouchSFX(sfx);
+
+	// pick a channel to play on
+	bool is2D = false;
+	for (int i = 0; i < s_numListeners; ++i)
+	{
+		if ((entityNum == s_listeners[i].entnum && !origin) ||
+			(origin &&
+			origin[0] == s_listeners[i].pos[0] &&
+			origin[1] == s_listeners[i].pos[1] &&
+			origin[2] == s_listeners[i].pos[2]))
+		{
+			is2D = true;
+			break;
+		}
+	}
+
+	ch = S_PickChannel( entityNum, CHAN_AMBIENT, is2D, NULL );
+	if (!ch) {
+		return;
+	}
+	
+	if (!is2D)
+	{
+		SetChannelOrigin(ch, origin, entityNum);
+	}
+
+	ch->master_vol = volume;
+	ch->fLastVolume = -1;
+	ch->entnum = entityNum;
+	ch->entchannel = CHAN_AMBIENT;
+	ch->thesfx = sfx;
+}
+
+/*
+====================
+S_MuteSound
+
+Mutes sound on specified channel for specified entity.
+This seems to be implemented quite incorrectly on PC. I
+think the following is what this function should do...
+
+Perhaps we should actually be changing the volume on all
+the channels that meet our criteria, but for now we'll just
+kill the sounds and hope it does what is expected.
+====================
+*/
+void S_MuteSound(int entityNum, int entchannel) 
+{
+	S_KillEntityChannel( entityNum, entchannel );
+
+/*
+	if (!s_soundStarted) {
+		return;
+	}
+
+	//I guess this works.
+	channel_t *ch = S_PickChannel( entityNum, entchannel );
+
+	if (!ch)
+	{
+		return;
+	}
+	
+	ch->master_vol = 0;
+	ch->entnum = 0;
+	ch->entchannel = 0;
+	ch->thesfx = 0;
+	ch->startSample = 0;
+
+	ch->leftvol = 0;
+	ch->rightvol = 0;
+*/
+}
+
+/*
+====================
+S_StartSound
+
+Validates the parms and ques the sound up
+if pos is NULL, the sound will be dynamically sourced from the entity
+Entchannel 0 will never override a playing sound
+====================
+*/
+void S_StartSound(const vec3_t origin, int entityNum, int entchannel, sfxHandle_t sfxHandle ) 
+{
+	channel_t	*ch;
+	/*const*/ sfx_t *sfx;
+
+	if ( !s_soundStarted || s_soundMuted ) {
+		return;
+	}
+
+	if ( sfxHandle < 0 || sfxHandle > MAX_SFX || s_sfxCodes[sfxHandle] == INVALID_CODE ) {
+		return;
+	}
+
+	if ( !origin && ( entityNum < 0 || entityNum > MAX_GENTITIES ) ) {
+		Com_Error( ERR_DROP, "S_StartSound: bad entitynum %i", entityNum );
+	}
+
+	sfx = &s_sfxBlock[sfxHandle];
+
+	if (sfx->iFlags & SFX_FLAG_UNLOADED){
+		S_StartLoadSound(sfx);
+	}
+	SND_TouchSFX(sfx);
+
+	// pick a channel to play on
+	bool is2D = false;
+	for (int i = 0; i < s_numListeners; ++i)
+	{
+		if ((entityNum == s_listeners[i].entnum && !origin) ||
+			(origin &&
+			origin[0] == s_listeners[i].pos[0] &&
+			origin[1] == s_listeners[i].pos[1] &&
+			origin[2] == s_listeners[i].pos[2]))
+		{
+			is2D = true;
+			break;
+		}
+	}
+	
+	ch = S_PickChannel( entityNum, entchannel, is2D, sfx );
+	if (!ch) {
+		return;
+	}
+
+	if (!is2D)
+	{
+		SetChannelOrigin(ch, origin, entityNum);
+	}
+		
+	if (entchannel == CHAN_AUTO && (sfx->iFlags & SFX_FLAG_VOICE)) {
+		entchannel = CHAN_VOICE; // Compensate of the incompetance of others. Yeah. ;)
+//		entchannel = CHAN_VOICE_ATTEN; // Super hack to put Rancor noises on a different channel E3!
+	}
+
+	ch->master_vol = SOUND_MAXVOL;	//FIXME: Um.. control?
+	ch->fLastVolume = -1;
+	ch->entnum = entityNum;
+	ch->entchannel = entchannel;
+	ch->thesfx = sfx;
+
+	if (entchannel < CHAN_AMBIENT && IsListenerEnt(ch->entnum))
+	{
+		ch->master_vol = SOUND_MAXVOL * SOUND_FMAXVOL;	//this won't be attenuated so let it scale down
+	}
+	if ( entchannel == CHAN_VOICE || entchannel == CHAN_VOICE_ATTEN || entchannel == CHAN_VOICE_GLOBAL ) 
+	{
+		s_entityWavVol[ ch->entnum ] = -1;	//we've started the sound but it's silent for now
+	}
+}
+
+/*
+==================
+S_StartLocalSound
+==================
+*/
+void S_StartLocalSound( sfxHandle_t sfxHandle, int channelNum ) {
+	if ( !s_soundStarted || s_soundMuted ) {
+		return;
+	}
+
+	// Play a 2D sound -- doesn't matter which listener we use
+	S_StartSound (NULL, 0, channelNum, sfxHandle );
+}
+
+
+/*
+==================
+S_StartLocalLoopingSound
+==================
+*/
+void S_StartLocalLoopingSound( sfxHandle_t sfxHandle) {
+	vec3_t nullVec = {0,0,0};
+
+	if ( !s_soundStarted || s_soundMuted ) {
+		return;
+	}
+
+	// Play a 2D sound -- doesn't matter which listener we use
+	S_AddLoopingSound( 0, nullVec, nullVec, sfxHandle, CHAN_AMBIENT );
+
+}
+
+// Kill an voice sounds from an entity
+void S_KillEntityChannel(int entnum, int chan)
+{
+	int i;
+	channel_t *ch;
+
+	if ( !s_soundStarted ) {
+		return;
+	}
+
+	if ( entnum < s_numListeners && chan == CHAN_VOICE ) {
+		// don't kill player death sounds
+		return;
+	}
+
+	ch = s_channels;
+	for (i = 0; i < s_numChannels; i++, ch++)
+	{
+		if (ch->bPlaying &&
+			ch->entnum == entnum &&
+			ch->entchannel == chan)
+		{
+			alSourceStop(ch->alSource);
+			ch->bPlaying = false;
+	
+			alSourcei(ch->alSource, AL_BUFFER, 0);
+			ch->thesfx = NULL;
+			ch->bLooping = false;
+		}
+	}
+}
+
+/*
+==================
+S_StopLoopingSound
+
+Stops all active looping sounds on a specified entity.
+Sort of a slow method though, isn't there some better way?
+==================
+*/
+void S_StopLoopingSound( int entnum )
+{
+	if (!s_soundStarted) {
+		return;
+	}
+
+	int i = 0;
+
+	while (i < numLoopSounds)
+	{
+		if (loopSounds[i].entnum == entnum)
+		{
+			int x = i+1;
+			while (x < numLoopSounds)
+			{
+				memcpy(&loopSounds[x-1], &loopSounds[x], sizeof(loopSounds[x]));
+				x++;
+			}
+			numLoopSounds--;
+		}
+		i++;
+	}
+}
+
+// returns length in milliseconds of supplied sound effect...  (else 0 for bad handle now)
+//
+float S_GetSampleLengthInMilliSeconds( sfxHandle_t sfxHandle)
+{
+	sfx_t *sfx;
+
+	if (!s_soundStarted)
+	{	//we have no sound, so let's just make a reasonable guess
+		return 512;
+	}
+
+	if ( s_sfxCodes[sfxHandle] == INVALID_CODE ) {
+		return 0.0f;
+	}
+
+	sfx = &s_sfxBlock[sfxHandle];
+
+	int size = Sys_GetFileCodeSize(sfx->iFileCode);
+	if (size < 0) return 0;
+
+	return 1000 * size / (22050 / 2);
+}
+
+/*
+==================
+S_LoadSound
+==================
+*/
+void S_LoadSound( sfxHandle_t sfxHandle ) 
+{
+	/*const*/ sfx_t *sfx;
+
+	if ( !s_soundStarted || s_soundMuted ) {
+		return;
+	}
+
+	if ( sfxHandle < 0 || sfxHandle > MAX_SFX || s_sfxCodes[sfxHandle] == INVALID_CODE ) {
+		return;
+	}
+
+	sfx = &s_sfxBlock[sfxHandle];
+
+	if (sfx->iFlags & SFX_FLAG_UNLOADED){
+		S_StartLoadSound(sfx);
+
+		extern void S_DrainRawSoundData(void);
+		S_DrainRawSoundData();
+	}
+}
+
+/*
+==================
+S_ClearSoundBuffer
+
+If we are about to perform file access, clear the buffer
+so sound doesn't stutter.
+==================
+*/
+void S_ClearSoundBuffer( void ) {
+	if ( !s_soundStarted || s_soundMuted ) {
+		return;
+	}
+}
+
+
+/*
+==================
+S_StopAllSounds
+==================
+*/
+void S_StopSounds(void)
+{
+	int i; //, j;
+	channel_t *ch;
+
+	if ( !s_soundStarted ) {
+		return;
+	}
+
+	// stop looping sounds
+	S_ClearLoopingSounds();
+
+	// clear all the s_channels
+	ch = s_channels;
+	for (i = 0; i < s_numChannels; i++, ch++)
+	{
+		if (ch->bPlaying)
+		{
+			alSourceStop(ch->alSource);
+			ch->bPlaying = false;
+		}
+	
+		alSourcei(ch->alSource, AL_BUFFER, 0);
+		ch->thesfx = NULL;
+		ch->bLooping = false;
+	}
+
+	// clear out the lip synching override array
+	memset(s_entityWavVol, 0, sizeof(int) * MAX_GENTITIES);
+
+	S_ClearSoundBuffer ();
+}
+
+/*
+==================
+S_StopAllSounds
+ and music
+==================
+*/
+void S_StopAllSounds(void) {
+	if ( !s_soundStarted ) {
+		return;
+	}
+	// stop the background music
+	S_StopBackgroundTrack();
+
+	S_StopSounds();
+}
+
+/*
+==============================================================
+
+continuous looping sounds are added each frame
+
+==============================================================
+*/
+
+/*
+==================
+S_ClearLoopingSounds
+
+==================
+*/
+void S_ClearLoopingSounds( void )
+{
+	if ( !s_soundStarted ) {
+		return;
+	}
+
+	int i;
+
+	for (i = 0; i < MAX_LOOP_SOUNDS; i++)
+	{
+		loopSounds[i].bProcessed = false;
+		loopSounds[i].bMarked = false;
+		loopSounds[i].sfx = NULL;
+	}
+
+	numLoopSounds = 0;
+}
+
+/*
+==================
+S_AddLoopingSound
+
+Called during entity generation for a frame
+==================
+*/
+void S_AddLoopingSound( int entityNum, const vec3_t origin, const vec3_t velocity, sfxHandle_t sfxHandle, int chan ) {
+	/*const*/ sfx_t *sfx;
+
+  	if ( !s_soundStarted || s_soundMuted || !s_loopEnabled ) {
+		return;
+	}
+	if ( numLoopSounds >= MAX_LOOP_SOUNDS ) {
+		return;
+	}
+
+	if ( sfxHandle < 0 || sfxHandle > MAX_SFX || s_sfxCodes[sfxHandle] == INVALID_CODE ) {
+		return;
+	}
+
+	sfx = &s_sfxBlock[sfxHandle];
+	if (sfx->iFlags & SFX_FLAG_UNLOADED){
+		S_StartLoadSound(sfx);
+	}
+	SND_TouchSFX(sfx);
+
+	loopSounds[numLoopSounds].origin[0] = origin[0];
+	loopSounds[numLoopSounds].origin[1] = origin[1];
+	loopSounds[numLoopSounds].origin[2] = origin[2];
+
+	loopSounds[numLoopSounds].sfx = sfx;
+	loopSounds[numLoopSounds].volume = SOUND_MAXVOL;
+	loopSounds[numLoopSounds].entnum = entityNum;
+	loopSounds[numLoopSounds].entchannel = chan;
+	numLoopSounds++;
+}
+
+
+/*
+==================
+S_AddAmbientLoopingSound
+==================
+*/
+void S_AddAmbientLoopingSound( const vec3_t origin, unsigned char volume, sfxHandle_t sfxHandle ) 
+{
+	/*const*/ sfx_t *sfx;
+
+	if ( !s_soundStarted || s_soundMuted || !s_loopEnabled ) {
+		return;
+	}
+	if ( numLoopSounds >= MAX_LOOP_SOUNDS ) {
+		return;
+	}
+
+	if (volume == 0)
+		return;
+
+	if ( sfxHandle < 0 || sfxHandle > MAX_SFX || s_sfxCodes[sfxHandle] == INVALID_CODE ) {
+		return;
+	}
+
+	sfx = &s_sfxBlock[sfxHandle];
+	if (sfx->iFlags & SFX_FLAG_UNLOADED){
+		S_StartLoadSound(sfx);
+	}
+	SND_TouchSFX(sfx);
+
+	loopSounds[numLoopSounds].origin[0] = origin[0];
+	loopSounds[numLoopSounds].origin[1] = origin[1];
+	loopSounds[numLoopSounds].origin[2] = origin[2];
+	
+	loopSounds[numLoopSounds].sfx = sfx;	
+	loopSounds[numLoopSounds].volume = volume;
+	loopSounds[numLoopSounds].entnum = -1;
+	numLoopSounds++;
+}
+
+
+
+
+/*
+=====================
+S_UpdateEntityPosition
+
+let the sound system know where an entity currently is
+======================
+*/
+void S_UpdateEntityPosition( int entityNum, const vec3_t origin )
+{
+	if ( !s_soundStarted ) {
+		return;
+	}
+
+	channel_t *ch;
+	int i;
+
+	if ( entityNum < 0 || entityNum > MAX_GENTITIES ) {
+		Com_Error( ERR_DROP, "S_UpdateEntityPosition: bad entitynum %i", entityNum );
+	}
+
+	if (entityNum == 0)
+		return;
+	
+	ch = s_channels;
+	for (i = 0; i < s_numChannels; i++, ch++)
+	{
+		if ((ch->bPlaying) && 
+			(ch->entnum == entityNum) &&
+			(!ch->b2D))
+		{
+			if (ch->origin[0] != origin[0] ||
+				ch->origin[1] != origin[1] ||
+				ch->origin[2] != origin[2])
+			{
+				ch->origin[0] = origin[0];
+				ch->origin[1] = origin[1];
+				ch->origin[2] = origin[2];
+				ch->bOriginDirty = true;
+			}
+		}
+	}
+}
+
+
+/*
+============
+S_Respatialize
+
+Change the volumes of all the playing sounds for changes in their positions
+============
+*/
+void S_Respatialize( int entityNum, const vec3_t head, vec3_t axis[3], qboolean inwater )
+{
+	if ( !s_soundStarted || s_soundMuted ) {
+		return; 
+	}
+
+	int index = 0;
+
+#if 0	
+	extern qboolean g_isMultiplayer;
+	if ( g_isMultiplayer ) {
+		index = entityNum;
+	}
+#endif
+
+	if ( index >= s_numListeners ) {
+		return;
+	}
+
+	listener_t *li = &s_listeners[index];
+
+	li->entnum = entityNum;
+	
+	li->pos[0] = head[0];
+	li->pos[1] = head[1];
+	li->pos[2] = head[2];
+	alListenerfv(li->handle, AL_POSITION, li->pos);
+	
+	li->orient[0] = axis[0][0];
+	li->orient[1] = axis[0][1];
+	li->orient[2] = axis[0][2];
+	li->orient[3] = axis[2][0];
+	li->orient[4] = axis[2][1];
+	li->orient[5] = axis[2][2];
+	
+	alListenerfv(li->handle, AL_ORIENTATION, li->orient);
+}
+
+/*
+============
+S_Update
+
+Called once each time through the main loop
+============
+*/
+void S_Update( void ) {
+	if ( !s_soundStarted ) {
+		return;
+	}
+
+	// don't update too often
+	int now = Sys_Milliseconds();
+	if (now - s_updateTime < SOUND_UPDATE_TIME) {
+		return;
+	}
+	s_updateTime = now;
+	
+	if ( s_soundMuted ) {
+		alUpdate();
+		return;
+	}
+
+	// finish up any pending loads
+	S_UpdateLoading();
+
+	// update the music stream
+	S_UpdateBackgroundTrack();
+
+	// mix some sound
+	S_Update_();
+
+	alUpdate();
+}
+
+static void UpdatePosition(channel_t *ch)
+{
+	if ( !ch->b2D )
+	{
+		if ( ch->bLooping && ch->bPlaying )
+		{
+			loopSound_t	*loop = &loopSounds[ch->loopChannel];
+			if ( loop->origin[0] != ch->origin[0] ||
+				loop->origin[1] != ch->origin[1] ||
+				loop->origin[2] != ch->origin[2] )
+			{
+				ch->origin[0] = loop->origin[0];
+				ch->origin[1] = loop->origin[1];
+				ch->origin[2] = loop->origin[2];
+				ch->bOriginDirty = true;
+			}
+		}
+		
+		if ( ch->bOriginDirty )
+		{
+			alSourcefv(ch->alSource, AL_POSITION, ch->origin);
+			ch->bOriginDirty = false;
+		}
+	}
+}
+
+static void UpdateGain(channel_t *ch)
+{
+	float v = 0.f;
+
+	if ( ch->bLooping && ch->bPlaying )
+	{
+		loopSound_t	*loop = &loopSounds[ch->loopChannel];
+		if ( loop->volume != ch->master_vol )
+		{
+			ch->master_vol = loop->volume;
+		}
+	}
+	
+	if ( ch->entchannel == CHAN_ANNOUNCER ||
+		ch->entchannel == CHAN_VOICE || 
+		ch->entchannel == CHAN_VOICE_ATTEN || 
+		ch->entchannel == CHAN_VOICE_GLOBAL )
+	{
+		v = ((float)(ch->master_vol) * s_voice_volume->value) / 255.0f;
+	}
+	else if ( ch->entchannel == CHAN_MUSIC )
+	{
+		v = ((float)(ch->master_vol) * s_music_volume->value) / 255.f;
+	}
+	else
+	{
+		v = ((float)(ch->master_vol) * s_effects_volume->value) / 255.f;
+	}
+	
+	if ( ch->fLastVolume != v)
+	{
+		alSourcef(ch->alSource, AL_GAIN, v);
+		ch->fLastVolume = v;
+	}
+}
+
+static void UpdatePlayState(channel_t *ch)
+{
+	if (!ch->bPlaying) return;
+
+	if (ch->bLooping)
+	{
+		// Looping sound
+		loopSound_t	*loop = &loopSounds[ch->loopChannel];
+		
+		if (loop->bProcessed == false && loop->sfx != NULL &&
+			(loop->sfx == ch->thesfx ||
+			(loop->sfx->iFlags & SFX_FLAG_DEFAULT)))
+		{
+			// Playing
+			loop->bProcessed = true;
+		}
+		else
+		{
+			// Sound no longer needed
+			alSourceStop(ch->alSource);
+			alSourcei(ch->alSource, AL_BUFFER, 0);
+			ch->thesfx = NULL;
+			ch->bPlaying = false;
+		}
+	}
+	else
+	{
+		// Single shot sound
+		ALint state;
+		alGetSourcei(ch->alSource, AL_SOURCE_STATE, &state);
+		if (state == AL_STOPPED)
+		{
+			alSourcei(ch->alSource, AL_BUFFER, 0);
+			ch->thesfx = NULL;
+			ch->bPlaying = false;
+		}
+	}
+}
+
+static void UpdateAttenuation(channel_t *ch)
+{
+	if (!ch->b2D)
+	{
+		/*
+		if ( ch->entchannel == CHAN_VOICE || ch->entchannel == CHAN_VOICE_ATTEN || ch->entchannel == CHAN_VOICE_GLOBAL )
+		{
+			alSourcef(ch->alSource, AL_REFERENCE_DISTANCE, 1500.0f);
+		}
+		else
+		{
+			alSourcef(ch->alSource, AL_REFERENCE_DISTANCE, 400.0f);
+		}
+		*/
+#if 0
+		extern qboolean g_isMultiplayer;
+		if (!g_isMultiplayer)
+		{
+#endif
+			switch (ch->entchannel)
+			{
+			case CHAN_VOICE:
+				alSourcef(ch->alSource, AL_REFERENCE_DISTANCE, SOUND_REF_DIST_BASE * 3.f);
+				break;
+			case CHAN_LESS_ATTEN:
+				alSourcef(ch->alSource, AL_REFERENCE_DISTANCE, SOUND_REF_DIST_BASE * 8.f);
+				break;
+			case CHAN_VOICE_ATTEN:
+				alSourcef(ch->alSource, AL_REFERENCE_DISTANCE, SOUND_REF_DIST_BASE * 1.35f);
+				break;
+			case CHAN_VOICE_GLOBAL:
+				alSourcef(ch->alSource, AL_REFERENCE_DISTANCE, SOUND_REF_DIST_BASE * 100.f);
+				break;
+			default:
+				alSourcef(ch->alSource, AL_REFERENCE_DISTANCE, SOUND_REF_DIST_BASE);
+				break;
+			}
+#if 0
+		}
+		else
+		{
+			alSourcef(ch->alSource, AL_REFERENCE_DISTANCE, SOUND_REF_DIST_BASE * 2.f);
+		}
+#endif
+	}
+}
+
+static void PlaySingleShot(channel_t *ch)
+{
+	alSourcei(ch->alSource, AL_LOOPING, AL_FALSE);
+	
+	UpdateAttenuation(ch);
+	UpdatePosition(ch);
+	
+	// Attach buffer to source
+	alSourcei(ch->alSource, AL_BUFFER, ch->thesfx->Buffer);
+	
+	// Clear error state, and check for successful Play call
+	alGetError();
+	alSourcePlay(ch->alSource);
+	if (alGetError() == AL_NO_ERROR)
+	{
+		ch->bPlaying = true;
+		ch->iLastPlayTime = Sys_Milliseconds();
+	}
+}
+
+void UpdateLoopingSounds()
+{
+	// Look for non-processed loops that are ready to play
+	for (int j = 0; j < numLoopSounds; j++)
+	{
+		loopSound_t	*loop = &loopSounds[j];
+		
+		{
+			// merge all loops with the same sfx into a single loop
+			float num = 1;
+			for (int k = j+1; k < numLoopSounds; ++k)
+			{
+				if (loopSounds[k].sfx == loop->sfx)
+				{
+					loop->origin[0] += loopSounds[k].origin[0];
+					loop->origin[1] += loopSounds[k].origin[1];
+					loop->origin[2] += loopSounds[k].origin[2];
+					loop->volume += loopSounds[k].volume;
+					loopSounds[k].bProcessed = true;
+					num += 1;
+				}
+			}
+
+			loop->origin[0] /= num;
+			loop->origin[1] /= num;
+			loop->origin[2] /= num;
+			loop->volume /= (int)num;
+		}
+
+		if (loop->bProcessed == false && (loop->sfx->iFlags & SFX_FLAG_RESIDENT))
+		{
+			// play the loop
+			bool is2D = false;
+			for (int i = 0; i < s_numListeners; ++i)
+			{
+				if (loop->entnum == s_listeners[i].entnum ||
+					(loop->origin[0] == s_listeners[i].pos[0] &&
+					loop->origin[1] == s_listeners[i].pos[1] &&
+					loop->origin[2] == s_listeners[i].pos[2]))
+				{
+					is2D = true;
+					break;
+				}
+			}
+
+			channel_t *ch = S_PickChannel(0, 0, is2D, NULL);
+			if (!ch) continue;
+
+			ch->master_vol = loop->volume;
+			ch->fLastVolume = -1;
+			ch->entnum = loop->entnum;
+			ch->entchannel = loop->entchannel;
+			ch->thesfx = loop->sfx;
+			ch->loopChannel = j;
+			ch->bLooping = true;
+			
+			ch->origin[0] = loop->origin[0];
+			ch->origin[1] = loop->origin[1];
+			ch->origin[2] = loop->origin[2];
+			ch->bOriginDirty = true;
+
+			alSourcei(ch->alSource, AL_LOOPING, AL_TRUE);
+			alSourcei(ch->alSource, AL_BUFFER, ch->thesfx->Buffer);
+			UpdateAttenuation(ch);
+			UpdatePosition(ch);
+			UpdateGain(ch);
+			
+			alGetError();
+			alSourcePlay(ch->alSource);
+			if (alGetError() == AL_NO_ERROR)
+			{
+				ch->bPlaying = true;
+				ch->iLastPlayTime = Sys_Milliseconds();
+			}
+		}
+	}
+}
+
+static void SyncChannelLoops(void)
+{
+	channel_t		*ch;
+	int				i, j;
+
+	// Try to match up channels with looping sounds
+	// (The order of sounds in loopSounds can change
+	// frame to frame.)
+	ch = s_channels;
+	for ( i = 0; i < s_numChannels ; i++, ch++ )
+	{
+		if ( ch->bPlaying && ch->bLooping )
+		{
+			for ( j = 0; j < numLoopSounds; ++j )
+			{
+				if ( ch->thesfx == loopSounds[j].sfx && 
+					!loopSounds[j].bMarked )
+				{
+					ch->loopChannel = j;
+					loopSounds[j].bMarked = true;
+					break;
+				}
+			}
+		}
+	}
+}
+
+void S_Update_(void)
+{
+	channel_t		*ch;
+	int				i;
+
+	if ( !s_soundStarted || s_soundMuted ) {
+		return;
+	}
+	
+	memset(s_entityWavVol, 0, sizeof(int) * MAX_GENTITIES);
+
+	SyncChannelLoops();
+
+	ch = s_channels;
+	for ( i = 0; i < s_numChannels ; i++, ch++ )
+	{	
+		if ( !ch->thesfx ) continue;
+
+		if ( ch->thesfx->iFlags & SFX_FLAG_UNLOADED )
+		{
+			// if the sound is not going to be loaded, force the 
+			// playing flag high, stop the source, and hope that 
+			// the update code cleans it up...
+			ch->bPlaying = true;
+			alSourceStop(ch->alSource);
+			continue;
+		}
+		
+		if ( ch->entchannel == CHAN_VOICE || 
+			ch->entchannel == CHAN_VOICE_ATTEN || 
+			ch->entchannel == CHAN_VOICE_GLOBAL )
+		{
+			s_entityWavVol[ch->entnum] = ch->bPlaying ? 4 : -1;
+		}
+
+		if ( !(ch->thesfx->iFlags & SFX_FLAG_RESIDENT) ) continue;
+
+		UpdatePosition(ch);
+		UpdateGain(ch);
+
+		if ( ch->bPlaying )
+		{
+			UpdatePlayState(ch);
+		}
+		else
+		{
+			PlaySingleShot(ch);
+		}
+	}
+
+	UpdateLoopingSounds();
+}
+
+
+
+/*
+===============================================================================
+
+console functions
+
+===============================================================================
+*/
+
+static void S_Play_f( void ) {
+	int 	i;
+	sfxHandle_t	h;
+	char name[256];
+	
+	i = 1;
+	while ( i<Cmd_Argc() ) {
+		if ( !strrchr(Cmd_Argv(i), '.') ) {
+			Com_sprintf( name, sizeof(name), "%s.wav", Cmd_Argv(1) );
+		} else {
+			Q_strncpyz( name, Cmd_Argv(i), sizeof(name) );
+		}
+		h = S_RegisterSound( name );
+		if( h ) {
+			S_StartLocalSound( h, CHAN_LOCAL_SOUND );
+		}
+		i++;
+	}
+}
+
+/*
+ * Crazy expanded play function:
+ * playex <file name> xOffset yOffset zOffset channel
+ */
+#ifndef _JK2MP
+static void S_PlayEx_f( void ) {
+	sfxHandle_t	h;
+	char		name[256] = { 0 };
+	vec3_t		origin;
+	int			entchannel;
+
+	if (Cmd_Argc() < 6)
+		return;
+
+	Q_strncpyz( name, Cmd_Argv(1), sizeof(name) );
+	h = S_RegisterSound( name );
+	if (!h)
+		return;
+
+	extern void G_EntityPosition( int i, vec3_t ret );
+	G_EntityPosition(0, origin);
+
+	origin[0] += atof(Cmd_Argv(2));
+	origin[1] += atof(Cmd_Argv(3));
+	origin[2] += atof(Cmd_Argv(4));
+
+	entchannel = atoi(Cmd_Argv(5));
+
+	S_StartSound(origin, 0, entchannel, h);
+}
+#endif
+
+static void S_Music_f( void ) {
+	int		c;
+
+	c = Cmd_Argc();
+
+	if ( c == 2 ) {
+		S_StartBackgroundTrack( Cmd_Argv(1), Cmd_Argv(1), qfalse );
+	} else if ( c == 3 ) {
+		S_StartBackgroundTrack( Cmd_Argv(1), Cmd_Argv(2), qfalse );		
+	} else {
+		Com_Printf ("music <musicfile> [loopfile]\n");
+		return;
+	}
+}
+
+void S_SoundList_f( void ) {
+}
+
+
+/*
+===============================================================================
+
+background music functions
+
+===============================================================================
+*/
+
+// fixme: need to move this into qcommon sometime?, but too much stuff altered by other people and I won't be able
+//	to compile again for ages if I check that out...
+//
+// DO NOT replace this with a call to FS_FileExists, that's for checking about writing out, and doesn't work for this.
+//
+qboolean S_MusicFileExists( const char *psFilename )
+{
+	fileHandle_t fhTemp;
+
+	char* pLoadName = S_FixMusicFileName(psFilename);
+	
+	FS_FOpenFileRead (pLoadName, &fhTemp, qtrue);	// qtrue so I can fclose the handle without closing a PAK
+	if (!fhTemp) 
+		return qfalse;
+	
+	FS_FCloseFile(fhTemp);
+	return qtrue;
+}
+
+static void S_StopBackgroundTrack_Actual( MusicInfo_t *pMusicInfo ) 
+{
+	pMusicInfo->bLoaded = false;
+	pMusicInfo->Rewind();
+	alStreamStop();
+}
+
+static void FreeMusic( MusicInfo_t *pMusicInfo )
+{
+	pMusicInfo->sLoadedDataName[0] = '\0';
+}
+
+// called only by snd_shutdown (from snd_restart or app exit)
+//
+static void S_UnCacheDynamicMusic( void )
+{
+	for (int i = eBGRNDTRACK_DATABEGIN; i != eBGRNDTRACK_DATAEND; i++)
+	{
+		FreeMusic( &tMusic_Info[i]);
+	}
+}
+
+static qboolean S_StartBackgroundTrack_Actual( MusicInfo_t *pMusicInfo, qboolean qbDynamic, const char *intro, const char *loop )
+{
+	Q_strncpyz( sMusic_BackgroundLoop, loop, sizeof( sMusic_BackgroundLoop ));	
+
+	char* name = S_FixMusicFileName(intro);
+
+	if ( !intro[0] ) {
+		S_StopBackgroundTrack_Actual( pMusicInfo );
+		return qfalse;
+	}
+
+	// new bit, if file requested is not same any loaded one (if prev was in-mem), ditch it...
+	//
+	if (Q_stricmp(name, pMusicInfo->sLoadedDataName))
+	{
+		FreeMusic( pMusicInfo );
+	}
+
+	//
+	// open up a wav file and get all the info
+	//
+	fileHandle_t handle;
+	int len = FS_FOpenFileRead( name, &handle, qtrue );
+	if ( !handle ) {
+		Com_Printf( S_COLOR_YELLOW "WARNING: couldn't open music file %s\n", name );
+		S_StopBackgroundTrack_Actual( pMusicInfo );
+		return qfalse;
+	}
+	
+#if defined(_XBOX) || defined(_WINDOWS)
+	// read enough of the file to get the header...
+	byte buffer[128];
+	FS_Read(buffer, sizeof(buffer), handle);
+	FS_FCloseFile( handle );
+
+	wavinfo_t info = GetWavInfo(buffer);
+	if ( info.size == 0 ) {
+		Com_Printf(S_COLOR_YELLOW "WARNING: Invalid format in %s\n", name);
+		S_StopBackgroundTrack_Actual( pMusicInfo );
+		return qfalse;
+	}
+	
+	pMusicInfo->s_backgroundSize = info.size;
+	pMusicInfo->s_backgroundBPS = info.rate * info.width / 8;
+	if (info.format == AL_FORMAT_STEREO4)
+	{
+		pMusicInfo->s_backgroundBPS <<= 1;
+	}
+#elif defined(_GAMECUBE)
+	FS_FCloseFile( handle );
+	pMusicInfo->s_backgroundSize = len;
+	pMusicInfo->s_backgroundBPS = 48000 * 4 / 8 * 2;
+#endif
+	
+	Q_strncpyz(pMusicInfo->sLoadedDataName, intro, sizeof(pMusicInfo->sLoadedDataName));
+	pMusicInfo->iFileCode = Sys_GetFileCode(name);
+	pMusicInfo->bLoaded = true;
+	
+	return qtrue;
+}
+
+static void S_SwitchDynamicTracks( MusicState_e eOldState, MusicState_e eNewState, qboolean bNewTrackStartsFullVolume )
+{
+	// copy old track into fader...
+	//
+	tMusic_Info[ eBGRNDTRACK_FADE ] = tMusic_Info[ eOldState ];
+	tMusic_Info[ eBGRNDTRACK_FADE ].iXFadeVolumeSeekTime= Sys_Milliseconds();
+	tMusic_Info[ eBGRNDTRACK_FADE ].iXFadeVolumeSeekTo	= 0;
+	//
+	// ... and deactivate...
+	//
+	tMusic_Info[ eOldState ].bActive = qfalse;
+	//
+	// set new track to either full volume or fade up...
+	//
+	tMusic_Info[eNewState].bActive				= qtrue;
+	tMusic_Info[eNewState].iXFadeVolumeSeekTime	= Sys_Milliseconds();
+	tMusic_Info[eNewState].iXFadeVolumeSeekTo	= 255;
+	tMusic_Info[eNewState].iXFadeVolume			= bNewTrackStartsFullVolume ? 255 : 0;
+	
+	eMusic_StateActual = eNewState;
+
+	// sanity check
+	if (tMusic_Info[eNewState].iFileSeekTo >= tMusic_Info[eNewState].s_backgroundSize)
+	{
+		tMusic_Info[eNewState].iFileSeekTo = 0;
+	}
+}
+
+// called by both the config-string parser and the console-command state-changer...
+//
+// This either changes the music right now (copying track structures etc), or leaves the new state as pending
+//	so it gets picked up by the general music player if in a transition that can't be overridden...
+//
+static void S_SetDynamicMusicState( MusicState_e eNewState )
+{
+	if (eMusic_StateRequest != eNewState)
+	{
+		eMusic_StateRequest  = eNewState;
+
+		if (s_debugdynamic->integer)
+		{
+			LPCSTR	psNewStateString = Music_BaseStateToString( eNewState, qtrue );
+					psNewStateString = psNewStateString?psNewStateString:"<unknown>";
+
+			Com_Printf( S_COLOR_MAGENTA "S_SetDynamicMusicState( Request: \"%s\" )\n", psNewStateString );
+		}		
+	}
+}
+
+
+static void S_HandleDynamicMusicStateChange( void )
+{
+	if (eMusic_StateRequest != eMusic_StateActual)
+	{
+		// check whether or not the new request can be honoured, given what's currently playing...
+		//
+		if (Music_StateCanBeInterrupted( eMusic_StateActual, eMusic_StateRequest ))
+		{
+			switch (eMusic_StateRequest)
+			{
+				case eBGRNDTRACK_EXPLORE:	// ... from action or silence
+				{
+					switch (eMusic_StateActual)
+					{
+						case eBGRNDTRACK_ACTION:	// action->explore
+						{
+							// find the transition track to play, and the entry point for explore when we get there,
+							//	and also see if we're at a permitted exit point to switch at all...
+							//
+							float fPlayingTimeElapsed = tMusic_Info[ eMusic_StateActual ].ElapsedTime();
+
+							// supply:
+							//
+							// playing point in float seconds
+							// enum of track being queried
+							//
+							// get:
+							//
+							// enum of transition track to switch to
+							// float time of entry point of new track *after* transition
+
+							MusicState_e	eTransition;
+							float			fNewTrackEntryTime = 0.0f;
+							if (Music_AllowedToTransition( fPlayingTimeElapsed, eBGRNDTRACK_ACTION, &eTransition, &fNewTrackEntryTime))
+							{
+								tMusic_Info[eTransition].Rewind();
+								tMusic_Info[eTransition].bTrackSwitchPending	= qtrue;
+								tMusic_Info[eTransition].bLooping				= qfalse;
+								tMusic_Info[eTransition].eTS_NewState			= eMusic_StateRequest;
+								tMusic_Info[eTransition].fTS_NewTime			= fNewTrackEntryTime;
+
+								S_SwitchDynamicTracks( eMusic_StateActual, eTransition, qfalse );	// qboolean bNewTrackStartsFullVolume
+							}
+						}
+						break;						
+
+						case eBGRNDTRACK_SILENCE:	// silence->explore
+						{
+							tMusic_Info[ eMusic_StateRequest ].Rewind();
+							S_SwitchDynamicTracks( eMusic_StateActual, eMusic_StateRequest, qfalse );	// qboolean bNewTrackStartsFullVolume
+						}
+						break;
+
+						default:	// trying to transition from some state I wasn't aware you could transition from (shouldn't happen), so ignore
+						{
+							assert(0); 
+							S_SwitchDynamicTracks( eMusic_StateActual, eBGRNDTRACK_SILENCE, qfalse );	// qboolean bNewTrackStartsFullVolume
+						}
+						break;
+					}
+				}
+				break;
+
+				case eBGRNDTRACK_SILENCE:	// from explore or action
+				{
+					switch (eMusic_StateActual)
+					{
+						case eBGRNDTRACK_ACTION:	// action->silence
+						case eBGRNDTRACK_EXPLORE:	// explore->silence
+						{
+							// find the transition track to play, and the entry point for explore when we get there,
+							//	and also see if we're at a permitted exit point to switch at all...
+							//
+							float fPlayingTimeElapsed = tMusic_Info[ eMusic_StateActual ].ElapsedTime();
+
+							MusicState_e	eTransition;
+							float			fNewTrackEntryTime = 0.0f;
+							if (Music_AllowedToTransition( fPlayingTimeElapsed, eMusic_StateActual, &eTransition, &fNewTrackEntryTime))
+							{
+								tMusic_Info[eTransition].Rewind();
+								tMusic_Info[eTransition].bTrackSwitchPending	= qtrue;
+								tMusic_Info[eTransition].bLooping				= qfalse;
+								tMusic_Info[eTransition].eTS_NewState			= eMusic_StateRequest;
+								tMusic_Info[eTransition].fTS_NewTime			= 0.0f;	//fNewTrackEntryTime;  irrelevant when switching to silence
+
+								S_SwitchDynamicTracks( eMusic_StateActual, eTransition, qfalse );	// qboolean bNewTrackStartsFullVolume
+							}
+						}
+						break;
+
+						default:		// some unhandled type switching to silence
+							assert(0);	// fall through since boss case just does silence->switch anyway
+
+						case eBGRNDTRACK_BOSS:	// boss->silence
+						{
+							tMusic_Info[eBGRNDTRACK_SILENCE].Rewind();
+							S_SwitchDynamicTracks( eMusic_StateActual, eBGRNDTRACK_SILENCE, qfalse );	// qboolean bNewTrackStartsFullVolume
+						}
+						break;
+					}
+				}
+				break;
+
+				case eBGRNDTRACK_ACTION:	// anything->action
+				{
+					switch (eMusic_StateActual)
+					{
+						case eBGRNDTRACK_SILENCE:	// silence->action
+						{
+							tMusic_Info[ eMusic_StateRequest ].Rewind();
+							S_SwitchDynamicTracks( eMusic_StateActual, eMusic_StateRequest, qfalse );	// qboolean bNewTrackStartsFullVolume
+						}
+						break;
+
+						default:	// !silence->action
+						{
+							float fEntryTime = Music_GetRandomEntryTime( eMusic_StateRequest );
+							tMusic_Info[ eMusic_StateRequest ].SeekTo(fEntryTime);
+							S_SwitchDynamicTracks( eMusic_StateActual, eMusic_StateRequest, qfalse );	// qboolean bNewTrackStartsFullVolume
+						}
+						break;
+					}
+				}
+				break;
+
+				case eBGRNDTRACK_BOSS:
+				{	
+					tMusic_Info[eMusic_StateRequest].Rewind();
+					S_SwitchDynamicTracks( eMusic_StateActual, eMusic_StateRequest, qfalse );	// qboolean bNewTrackStartsFullVolume
+				}
+				break;
+
+				case eBGRNDTRACK_DEATH:
+				{	
+					tMusic_Info[eMusic_StateRequest].Rewind();
+					S_SwitchDynamicTracks( eMusic_StateActual, eMusic_StateRequest, qtrue );	// qboolean bNewTrackStartsFullVolume
+				}
+				break;
+
+				default: assert(0); break;	// unknown new mode request, so just ignore it
+			}
+		}
+	}
+}
+
+
+
+static char gsIntroMusic[MAX_QPATH]={0};
+static char gsLoopMusic [MAX_QPATH]={0};
+
+void S_RestartMusic( void ) 
+{
+	if (s_soundStarted && !s_soundMuted )
+	{
+		S_StartBackgroundTrack( gsIntroMusic, gsLoopMusic, qfalse );	// ( default music start will set the state to EXPLORE )
+		S_SetDynamicMusicState( eMusic_StateRequest );					// restore to prev state
+	}
+}
+
+
+// Basic logic here is to see if the intro file specified actually exists, and if so, then it's not dynamic music,
+//	When called by the cgame start it loads up, then stops the playback (because of stutter issues), so that when the
+//	actual snapshot is received and the real play request is processed the data has already been loaded so will be quicker.
+//
+void S_StartBackgroundTrack( const char *intro, const char *loop, qboolean bCalledByCGameStart )
+{
+	bMusic_IsDynamic = qfalse;
+
+	if (!s_soundStarted)
+	{	//we have no sound, so don't even bother trying
+		return;
+	}
+
+	if ( !intro ) {
+		intro = "";
+	}
+	if ( !loop || !loop[0] ) {
+		loop = intro;
+	}
+
+	Q_strncpyz(gsIntroMusic,intro, sizeof(gsIntroMusic));
+	Q_strncpyz(gsLoopMusic, loop,  sizeof(gsLoopMusic));
+
+	char sName[MAX_QPATH];
+	Q_strncpyz(sName,intro,sizeof(sName));
+
+	COM_DefaultExtension( sName, sizeof( sName ), ".wxb" );
+
+	// if dynamic music not allowed, then just stream the explore music instead of playing dynamic...
+	//
+	if (!s_allowDynamicMusic->integer && Music_DynamicDataAvailable(intro))	// "intro", NOT "sName" (i.e. don't use version with ".wxb" extension)
+	{
+		LPCSTR psMusicName = Music_GetFileNameForState( eBGRNDTRACK_DATABEGIN );
+		if (psMusicName && S_MusicFileExists( psMusicName ))
+		{
+			Q_strncpyz(sName,psMusicName,sizeof(sName));
+		}
+	}
+
+	// conceptually we always play the 'intro'[/sName] track, intro-to-loop transition is handled in UpdateBackGroundTrack().
+	//
+	if ( (strstr(sName,"/") && S_MusicFileExists( sName )) )	// strstr() check avoids extra file-exists check at runtime if reverting from streamed music to dynamic since literal files all need at least one slash in their name (eg "music/blah")
+	{
+		Com_DPrintf("S_StartBackgroundTrack: Found/using non-dynamic music track '%s'\n", sName);
+		tMusic_Info[eBGRNDTRACK_NONDYNAMIC].bLooping = qtrue;
+		S_StartBackgroundTrack_Actual( &tMusic_Info[eBGRNDTRACK_NONDYNAMIC], bMusic_IsDynamic, sName, sName );
+	}
+	else
+	{
+		if (Music_DynamicDataAvailable(intro))	// "intro", NOT "sName" (i.e. don't use version with ".wxb" extension)
+		{
+			int i;
+			extern const char *Music_GetLevelSetName(void);
+			Q_strncpyz(sInfoOnly_CurrentDynamicMusicSet, Music_GetLevelSetName(), sizeof(sInfoOnly_CurrentDynamicMusicSet));
+			for (i = eBGRNDTRACK_DATABEGIN; i != eBGRNDTRACK_DATAEND; i++)
+			{
+				qboolean bOk = qfalse;
+				LPCSTR psMusicName = Music_GetFileNameForState( (MusicState_e) i);
+				if (psMusicName && (!Q_stricmp(tMusic_Info[i].sLoadedDataName, psMusicName) || S_MusicFileExists( psMusicName )) )
+				{
+					bOk = S_StartBackgroundTrack_Actual( &tMusic_Info[i], qtrue, psMusicName, loop );
+				}
+				
+				tMusic_Info[i].bExists = bOk;
+
+				if (!tMusic_Info[i].bExists)
+				{
+					FreeMusic( &tMusic_Info[i] );
+				}
+			}
+
+			//
+			// default all tracks to OFF first (and set any other vars)
+			//
+			for (i=0; i<eBGRNDTRACK_NUMBEROF; i++)
+			{
+				tMusic_Info[i].bActive				= qfalse;
+				tMusic_Info[i].bTrackSwitchPending	= qfalse;
+				tMusic_Info[i].bLooping				= qtrue;
+				tMusic_Info[i].fSmoothedOutVolume	= 0.25f;
+			}
+
+			tMusic_Info[eBGRNDTRACK_DEATH].bLooping		= qfalse;
+
+			if (tMusic_Info[eBGRNDTRACK_EXPLORE].bExists &&
+				tMusic_Info[eBGRNDTRACK_ACTION ].bExists
+				)
+			{
+				Com_DPrintf("S_StartBackgroundTrack: Found dynamic music tracks\n");
+				bMusic_IsDynamic = qtrue;
+
+				//
+				// ... then start the default music state...
+				//
+				eMusic_StateActual = eMusic_StateRequest = eBGRNDTRACK_EXPLORE;
+
+				MusicInfo_t *pMusicInfo = &tMusic_Info[ eMusic_StateActual ];
+
+				pMusicInfo->bActive				= qtrue;
+				pMusicInfo->iXFadeVolumeSeekTime= Sys_Milliseconds();
+				pMusicInfo->iXFadeVolumeSeekTo	= 255;
+				pMusicInfo->iXFadeVolume		= 0;			
+			}
+			else
+			{
+				Com_Printf( S_COLOR_RED "Dynamic music did not have both 'action' and 'explore' versions, inhibiting...\n");
+				S_StopBackgroundTrack();
+			}
+		}
+		else
+		{
+			if (sName[0]!='.')	// blank name with ".wxb" or whatever attached - no error print out
+			{
+				Com_Printf( S_COLOR_RED "Unable to find music \"%s\" as explicit track or dynamic music entry!\n",sName);
+				S_StopBackgroundTrack();
+			}
+		}
+	}	
+
+	if (bCalledByCGameStart)
+	{
+		S_StopBackgroundTrack();
+	}
+}
+
+void S_StopBackgroundTrack( void )
+{
+	for (int i=0; i<eBGRNDTRACK_NUMBEROF; i++)
+	{
+		S_StopBackgroundTrack_Actual( &tMusic_Info[i] );
+	}
+}
+
+
+
+// qboolean return is true only if we're changing from a streamed intro to a dynamic loop...
+//
+static qboolean S_UpdateBackgroundTrack_Actual( MusicInfo_t *pMusicInfo, qboolean bFirstOrOnlyMusicTrack, float fDefaultVolume) 
+{
+	float fMasterVol = fDefaultVolume; // s_musicVolume->value;
+
+	if (bMusic_IsDynamic)
+	{
+		// step xfade volume...
+		//
+		if ( pMusicInfo->iXFadeVolume != pMusicInfo->iXFadeVolumeSeekTo )
+		{
+			int iFadeMillisecondsElapsed = Sys_Milliseconds() - pMusicInfo->iXFadeVolumeSeekTime;
+
+			if (iFadeMillisecondsElapsed > (fDYNAMIC_XFADE_SECONDS * 1000))
+			{
+				pMusicInfo->iXFadeVolume = pMusicInfo->iXFadeVolumeSeekTo;
+			}
+			else
+			{
+				pMusicInfo->iXFadeVolume = (int) (255.0f * ((float)iFadeMillisecondsElapsed/(fDYNAMIC_XFADE_SECONDS * 1000.0f)));
+				if (pMusicInfo->iXFadeVolumeSeekTo == 0)	// bleurgh
+					pMusicInfo->iXFadeVolume = 255 - pMusicInfo->iXFadeVolume;
+			}
+		}
+		fMasterVol *= (float)((float)pMusicInfo->iXFadeVolume / 255.0f);
+	}
+
+	if ( pMusicInfo->bLoaded == false ) {
+		return qfalse;
+	}
+
+	pMusicInfo->fSmoothedOutVolume = (pMusicInfo->fSmoothedOutVolume + fMasterVol)/2.0f;
+
+	alStreamf(AL_GAIN, pMusicInfo->fSmoothedOutVolume);
+
+	// don't bother playing anything if musicvolume is 0
+	if ( pMusicInfo->fSmoothedOutVolume <= 0 ) {
+		return qfalse;
+	}
+
+	// start playing if necessary
+	if ( pMusicInfo->bLooping )
+	{
+		ALint state;
+		alGetStreami(AL_SOURCE_STATE, &state);
+		if ( state != AL_PLAYING )
+		{
+			alStreamPlay(pMusicInfo->iFileSeekTo, 
+				pMusicInfo->iFileCode, 
+				pMusicInfo->bLooping);
+		}
+	}
+
+	if ( pMusicInfo->PlayTime() >= pMusicInfo->TotalTime() ) 
+	{
+		// loop the music, or play the next piece if we were on the intro...
+		//	(but not for dynamic, that can only be used for loop music)
+		//
+		if (bMusic_IsDynamic)	// needs special logic for this, different call
+		{
+			pMusicInfo->Rewind();
+		}
+		else
+		{
+			// for non-dynamic music we need to check if "sMusic_BackgroundLoop" is an actual filename,
+			//	or if it's a dynamic music specifier (which can't literally exist), in which case it should set
+			//	a return flag then exit...
+			//
+			char sTestName[MAX_QPATH*2];// *2 so COM_DefaultExtension doesn't do an ERR_DROP if there was no space
+			//	for an extension, since this is a "soft" test				
+			Q_strncpyz( sTestName, sMusic_BackgroundLoop, sizeof(sTestName));
+			COM_DefaultExtension(sTestName, sizeof(sTestName), ".mp3");
+			
+			if (S_MusicFileExists( sTestName ))
+			{
+				// Restart the music
+				alStreamStop();
+				alStreamPlay(pMusicInfo->iFileSeekTo, 
+					pMusicInfo->iFileCode, 
+					pMusicInfo->bLooping);
+			}
+			else
+			{
+				// proposed file doesn't exist, but this may be a dynamic track we're wanting to loop, 
+				//	so exit with a special flag...
+				//
+				return qtrue;
+			}
+		}
+	}
+
+	return qfalse;
+}
+
+
+// used to be just for dynamic, but now even non-dynamic music has to know whether it should be silent or not...
+//
+static LPCSTR S_Music_GetRequestedState(void)
+{
+// This doesn't do anything in MP - just return NULL
+#ifndef _JK2MP
+	int iStringOffset = cl.gameState.stringOffsets[CS_DYNAMIC_MUSIC_STATE];
+	if (iStringOffset)
+	{
+		LPCSTR psCommand = cl.gameState.stringData+iStringOffset; 
+
+		return psCommand;
+	}
+#endif
+
+	return NULL;
+}
+
+
+// scan the configstring to see if there's been a state-change requested...
+// (note that even if the state doesn't change it still gets here, so do a same-state check for applying)
+//
+// then go on to do transition handling etc...
+//
+static void S_CheckDynamicMusicState(void)
+{
+	LPCSTR psCommand = S_Music_GetRequestedState();
+
+	if (psCommand)
+	{
+		MusicState_e eNewState;
+
+		if ( !Q_stricmpn( psCommand, "silence", 7) )
+		{				
+			eNewState = eBGRNDTRACK_SILENCE;
+		}
+		else if ( !Q_stricmpn( psCommand, "action", 6) )
+		{
+			eNewState = eBGRNDTRACK_ACTION;
+		}
+		else if ( !Q_stricmpn( psCommand, "boss", 4) )
+		{
+			// special case, boss music is optional and may not be defined...
+			//
+			if (tMusic_Info[ eBGRNDTRACK_BOSS ].bExists)
+			{
+				eNewState = eBGRNDTRACK_BOSS;
+			}
+			else
+			{
+				// ( leave it playing current track )
+				//
+				eNewState = eMusic_StateActual;
+			}
+		}
+		else if ( !Q_stricmpn( psCommand, "death", 5) )
+		{
+			// special case, death music is optional and may not be defined...
+			//
+			if (tMusic_Info[ eBGRNDTRACK_DEATH ].bExists)
+			{
+				eNewState = eBGRNDTRACK_DEATH;
+			}
+			else
+			{
+				// ( leave it playing current track, typically either boss or action )
+				//
+				eNewState = eMusic_StateActual;
+			}
+		}
+		else
+		{
+			// seems a reasonable default...
+			//
+			eNewState = eBGRNDTRACK_EXPLORE;
+		}
+		
+		S_SetDynamicMusicState( eNewState );
+	}
+
+	S_HandleDynamicMusicStateChange();
+}
+
+static void S_UpdateBackgroundTrack( void )
+{
+	if (bMusic_IsDynamic)
+	{
+		S_CheckDynamicMusicState();
+		
+		if (eMusic_StateActual != eBGRNDTRACK_SILENCE)
+		{
+			MusicInfo_t *pMusicInfoCurrent = &tMusic_Info[ (eMusic_StateActual == eBGRNDTRACK_FADE)?eBGRNDTRACK_EXPLORE:eMusic_StateActual ];
+			MusicInfo_t *pMusicInfoFadeOut = &tMusic_Info[ eBGRNDTRACK_FADE ];
+
+			if ( pMusicInfoCurrent->bLoaded )
+			{
+				float fRemainingTimeInSeconds = 1000000;
+
+				if (pMusicInfoFadeOut->bActive)
+				{
+					S_UpdateBackgroundTrack_Actual( pMusicInfoFadeOut, qfalse, s_music_volume->value );	// inactive-checked internally
+
+					//
+					// only do this for the fader!...
+					//
+					if (pMusicInfoFadeOut->iXFadeVolume == 0)
+					{
+						pMusicInfoFadeOut->bActive = qfalse;
+
+						// play if we have a file
+						if (pMusicInfoCurrent->iFileCode)
+						{
+							alStreamPlay(pMusicInfoCurrent->iFileSeekTo, 
+								pMusicInfoCurrent->iFileCode,
+								pMusicInfoCurrent->bLooping);
+							
+							pMusicInfoCurrent->iXFadeVolumeSeekTime = Sys_Milliseconds();
+						}
+						else
+						{
+							alStreamStop();
+						}
+					}
+				}
+				else
+				{
+					S_UpdateBackgroundTrack_Actual( pMusicInfoCurrent, qtrue, s_music_volume->value );
+					fRemainingTimeInSeconds = pMusicInfoCurrent->TotalTime() - pMusicInfoCurrent->ElapsedTime();
+				}
+				
+				if ( fRemainingTimeInSeconds < fDYNAMIC_XFADE_SECONDS*2 )
+				{
+					// now either loop current track, switch if finishing a transition, or stop if finished a death...
+					//
+					if (pMusicInfoCurrent->bTrackSwitchPending)
+					{
+						pMusicInfoCurrent->bTrackSwitchPending = qfalse;	// ack
+						tMusic_Info[ pMusicInfoCurrent->eTS_NewState ].SeekTo(pMusicInfoCurrent->fTS_NewTime);
+						S_SwitchDynamicTracks( eMusic_StateActual, pMusicInfoCurrent->eTS_NewState, qfalse);	// qboolean bNewTrackStartsFullVolume
+					}
+					else
+					{
+						// normal looping, so set rewind current track, set volume to 0 and fade up to full (unless death track playing, then stays quiet)
+						//	(while fader copy of end-section fades down)
+						//
+						// copy current track to fader...
+						//
+						*pMusicInfoFadeOut = *pMusicInfoCurrent;	// struct copy
+						pMusicInfoFadeOut->iXFadeVolumeSeekTime	= Sys_Milliseconds();
+						pMusicInfoFadeOut->iXFadeVolumeSeekTo	= 0;
+						//
+						pMusicInfoCurrent->Rewind();
+						pMusicInfoCurrent->iXFadeVolumeSeekTime	= Sys_Milliseconds();
+						pMusicInfoCurrent->iXFadeVolumeSeekTo	= (eMusic_StateActual == eBGRNDTRACK_DEATH) ? 0: 255;
+						pMusicInfoCurrent->iXFadeVolume			= 0;
+					}
+				}
+			}
+		}
+		else
+		{
+			// special case, when foreground music is shut off but fader still running to fade off previous track...
+			//
+			MusicInfo_t *pMusicInfoFadeOut = &tMusic_Info[ eBGRNDTRACK_FADE ];
+			if (pMusicInfoFadeOut->bActive)
+			{
+				S_UpdateBackgroundTrack_Actual( pMusicInfoFadeOut, qtrue, s_music_volume->value );
+				if (pMusicInfoFadeOut->iXFadeVolume == 0)
+				{
+					pMusicInfoFadeOut->bActive = qfalse;
+					alStreamStop();
+				}
+			}	
+		}
+	}
+	else
+	{
+		// standard / non-dynamic one-track music...
+		//
+		LPCSTR psCommand = S_Music_GetRequestedState();	// special check just for "silence" case...
+		qboolean bShouldBeSilent = (psCommand && !Q_stricmp(psCommand,"silence"));
+		float fDesiredVolume = bShouldBeSilent ? 0.0f : s_music_volume->value;
+		//
+		// internal to this code is a volume-smoother...
+		//
+		qboolean bNewTrackDesired = S_UpdateBackgroundTrack_Actual(&tMusic_Info[eBGRNDTRACK_NONDYNAMIC], qtrue, fDesiredVolume);
+
+		if (bNewTrackDesired)
+		{
+			S_StartBackgroundTrack( sMusic_BackgroundLoop, sMusic_BackgroundLoop, qfalse );
+		}
+	}
+}
+
+
+
+
+int SND_GetMemoryUsed(void)
+{
+	ALint used;
+	alGeti(AL_MEMORY_USED, &used);
+	return used;
+}
+
+void SND_update(sfx_t *sfx) 
+{
+	while ( SND_GetMemoryUsed() > (s_soundpoolmegs->integer * 1024 * 1024 * 3 / 4))
+	{
+		int iBytesFreed = SND_FreeOldestSound(sfx);
+		if (iBytesFreed == 0)
+			break;	// sanity
+	}
+}
+
+
+// free any allocated sfx mem...
+//
+// now returns # bytes freed to help with z_malloc()-fail recovery
+//
+static int SND_FreeSFXMem(sfx_t *sfx)
+{
+	int iOrgMem = SND_GetMemoryUsed();
+
+	alGetError();
+	if (sfx->Buffer)
+	{
+		alDeleteBuffers(1, &(sfx->Buffer));
+		sfx->Buffer = 0;
+	}
+
+	sfx->iFlags &= ~(SFX_FLAG_RESIDENT | SFX_FLAG_LOADING);
+	sfx->iFlags |= SFX_FLAG_UNLOADED;
+
+	return iOrgMem - SND_GetMemoryUsed();
+}
+
+void S_DisplayFreeMemory() 
+{
+}
+
+void SND_TouchSFX(sfx_t *sfx)
+{
+	sfx->iLastTimeUsed		= Com_Milliseconds()+1;
+}
+
+
+// currently this is only called during snd_shutdown or snd_restart
+//
+static void S_FreeAllSFXMem(void)
+{
+	for (int i = 0; i < MAX_SFX; ++i)
+	{
+		if (s_sfxCodes[i] != INVALID_CODE && i != s_defaultSound)
+		{
+			SND_FreeSFXMem(&s_sfxBlock[i]);
+		}
+	}
+}
+
+// returns number of bytes freed up...
+//
+// new param is so we can be usre of not freeing ourselves (without having to rely on possible uninitialised timers etc)
+//
+int SND_FreeOldestSound(sfx_t *pButNotThisOne /* = NULL */) 
+{	
+	int iBytesFreed = 0;
+	sfx_t *sfx;
+
+	int	iOldest = Com_Milliseconds();
+	int	iUsed	= 0;
+	bool bDemandLoad = false;
+
+	// start on 1 so we never dump the default sound...
+	//
+	for (int i = 0; i < MAX_SFX; ++i)
+	{
+		if (s_sfxCodes[i] == INVALID_CODE || i == s_defaultSound) continue;
+
+		sfx = &s_sfxBlock[i];
+
+		if (sfx != pButNotThisOne)
+		{
+			// Don't throw out the default sound, sounds that
+			// are not in memory, or sounds newer then the oldest.
+			// Also, throw out demand load sounds first.
+			//
+			if (!(sfx->iFlags & SFX_FLAG_DEFAULT) && 
+				(sfx->iFlags & SFX_FLAG_RESIDENT) && 
+				(!bDemandLoad || (sfx->iFlags & SFX_FLAG_DEMAND)) &&
+				sfx->iLastTimeUsed < iOldest) 
+			{
+				// new bit, we can't throw away any sfx_t struct in use by a channel, 
+				// else the paint code will crash...
+				//
+				int iChannel;
+				for (iChannel=0; iChannel<s_numChannels; iChannel++)
+				{
+					channel_t *ch = & s_channels[iChannel];
+
+					if (ch->thesfx == sfx)
+						break;	// damn, being used
+				}
+				if (iChannel == s_numChannels)
+				{
+					// this sfx_t struct wasn't used by any channels, so we can lose it...
+					//			
+					iUsed = i;
+					iOldest = sfx->iLastTimeUsed;
+					bDemandLoad = (sfx->iFlags & SFX_FLAG_DEMAND);
+				}
+			}
+		}
+	}
+
+	if (iUsed)
+	{
+		sfx = &s_sfxBlock[ iUsed ];
+		iBytesFreed = SND_FreeSFXMem(sfx);
+	}
+
+	return iBytesFreed;
+}
+int SND_FreeOldestSound(void)
+{
+	return SND_FreeOldestSound(NULL);	// I had to add a void-arg version of this because of link issues, sigh
+}
+
+
+// just before we drop into a level, ensure the audio pool is under whatever the maximum
+//	pool size is (but not by dropping out sounds used by the current level)...
+//
+// returns qtrue if at least one sound was dropped out, so z_malloc-fail recovery code knows if anything changed
+//
+qboolean SND_RegisterAudio_Clean(void)
+{
+	if ( !s_soundStarted ) {
+		return qfalse;
+	}
+
+	qboolean bAtLeastOneSoundDropped = qfalse;
+
+	Com_DPrintf( "SND_RegisterAudio_Clean():\n");
+
+	extern void S_DrainRawSoundData(void);
+	S_DrainRawSoundData();
+
+	{
+		for (int i = 0;	i < MAX_SFX; ++i)
+		{
+			if (s_sfxCodes[i] == INVALID_CODE || i == s_defaultSound) continue;
+
+			sfx_t *sfx = &s_sfxBlock[i];
+
+			if (sfx->iFlags & (SFX_FLAG_RESIDENT | SFX_FLAG_DEMAND))
+			{
+				qboolean bDeleteThis = qtrue;
+				//if (bDeleteThis)
+				{
+					int iChannel;
+					for (iChannel=0; iChannel<s_numChannels; iChannel++)
+					{
+						if (s_channels[iChannel].thesfx == sfx)
+						{
+							bDeleteThis = false;
+							break;
+						}
+					}
+					
+					if (bDeleteThis)
+					{
+						if (!(sfx->iFlags & SFX_FLAG_DEFAULT) &&
+							(sfx->iFlags & SFX_FLAG_RESIDENT) && 
+							SND_FreeSFXMem(sfx))
+						{
+							bAtLeastOneSoundDropped = qtrue;
+						}
+						if (sfx->iFlags & SFX_FLAG_DEMAND)
+						{
+							s_sfxCodes[i] = INVALID_CODE;
+						}
+					}
+				}
+			}
+		}
+	}
+
+	Com_DPrintf( "SND_RegisterAudio_Clean(): Ok\n");	
+
+	return bAtLeastOneSoundDropped;
+}
+
+qboolean SND_RegisterAudio_LevelLoadEnd(qboolean bDeleteEverythingNotUsedThisLevel /* 99% qfalse */)
+{
+        return qfalse;
+}
+
+qboolean S_FileExists( const char *psFilename )
+{
+	// This is only really used for music. Need to swap .mp3 with .wxb on Xbox
+	char *fixedName = S_FixMusicFileName(psFilename);
+
+	// VVFIXME : This can be done better?
+	fileHandle_t fhTemp;
+
+	FS_FOpenFileRead (fixedName, &fhTemp, qtrue);	// qtrue so I can fclose the handle without closing a PAK
+	if (!fhTemp) 
+		return qfalse;
+	
+	FS_FCloseFile(fhTemp);
+	return qtrue;
+}
+
diff --git a/codemp/client/snd_local.h b/codemp/client/snd_local.h
new file mode 100644
index 0000000..d80978c
--- /dev/null
+++ b/codemp/client/snd_local.h
@@ -0,0 +1,228 @@
+// snd_local.h -- private sound definations
+
+#ifndef SND_LOCAL_H
+#define SND_LOCAL_H
+
+#define sboolean int //rww - argh (in SP qboolean type is merely #define'd as an int, but I do not want to do that for MP over the whole base)
+
+#include "snd_public.h"
+#include "../mp3code/mp3struct.h"
+
+// Open AL Specific
+#include "openal\al.h"
+#include "openal\alc.h"
+#include "eax\eax.h"
+#include "eax\eaxman.h"
+
+// Added for Open AL to know when to mute all sounds (e.g when app. loses focus)
+void S_AL_MuteAllSounds(sboolean bMute);
+
+
+//from SND_AMBIENT
+extern void AS_Init( void );
+extern void AS_Free( void );
+
+
+#define	PAINTBUFFER_SIZE	1024
+
+
+// !!! if this is changed, the asm code must change !!!
+typedef struct {
+	int			left;	// the final values will be clamped to +/- 0x00ffff00 and shifted down
+	int			right;
+} portable_samplepair_t;
+
+
+// keep this enum in sync with the table "sSoundCompressionMethodStrings"	-ste
+//
+typedef enum
+{
+	ct_16 = 0,		// formerly ct_NONE in EF1, now indicates 16-bit samples (the default)
+	ct_MP3,			
+	//
+	ct_NUMBEROF		// used only for array sizing
+
+} SoundCompressionMethod_t;
+
+
+typedef struct sfx_s {
+	short			*pSoundData;
+	sboolean		bDefaultSound;			// couldn't be loaded, so use buzz
+	sboolean		bInMemory;				// not in Memory, set qtrue when loaded, and qfalse when its buffers are freed up because of being old, so can be reloaded
+	SoundCompressionMethod_t eSoundCompressionMethod;	
+	MP3STREAM		*pMP3StreamHeader;		// NULL ptr unless this sfx_t is an MP3. Use Z_Malloc and Z_Free
+	int 			iSoundLengthInSamples;	// length in samples, always kept as 16bit now so this is #shorts (watch for stereo later for music?)
+	char 			sSoundName[MAX_QPATH];
+	int				iLastTimeUsed;
+	float			fVolRange;				// used to set the highest volume this sample has at load time - used for lipsynching
+	int				iLastLevelUsedOn;		// used for cacheing purposes
+
+	// Open AL
+	ALuint		Buffer;
+	char		*lipSyncData;
+
+	struct sfx_s	*next;					// only used because of hash table when registering
+} sfx_t;
+
+typedef struct {
+	int			channels;
+	int			samples;				// mono samples in buffer
+	int			submission_chunk;		// don't mix less than this #
+	int			samplebits;
+	int			speed;
+	byte		*buffer;
+} dma_t;
+
+
+#define START_SAMPLE_IMMEDIATE	0x7fffffff
+
+// Open AL specific
+typedef struct
+{
+	ALuint	BufferID;
+	ALuint	Status;
+	char	*Data;
+} STREAMINGBUFFER;
+
+#define NUM_STREAMING_BUFFERS	4
+#define STREAMING_BUFFER_SIZE	4608		// 4 decoded MP3 frames
+
+#define QUEUED		1
+#define UNQUEUED	2
+
+
+typedef struct
+{
+// back-indented fields new in TA codebase, will re-format when MP3 code finished -ste
+// note: field missing in TA: sboolean	loopSound;		// from an S_AddLoopSound call, cleared each frame
+//
+	unsigned int startSample;	// START_SAMPLE_IMMEDIATE = set immediately on next mix
+	int			entnum;			// to allow overriding a specific sound
+	int			entchannel;		// to allow overriding a specific sound
+	int			leftvol;		// 0-255 volume after spatialization
+	int			rightvol;		// 0-255 volume after spatialization
+	int			master_vol;		// 0-255 volume before spatialization
+
+
+	vec3_t		origin;			// only use if fixed_origin is set
+
+	sboolean	fixed_origin;	// use origin instead of fetching entnum's origin
+	sfx_t		*thesfx;		// sfx structure
+	sboolean	loopSound;		// from an S_AddLoopSound call, cleared each frame
+	//
+	MP3STREAM	MP3StreamHeader;
+	byte		MP3SlidingDecodeBuffer[50000/*12000*/];	// typical back-request = -3072, so roughly double is 6000 (safety), then doubled again so the 6K pos is in the middle of the buffer)
+	int			iMP3SlidingDecodeWritePos;
+	int			iMP3SlidingDecodeWindowPos;
+
+
+	// Open AL specific
+	bool	bLooping;	// Signifies if this channel / source is playing a looping sound
+//	bool	bAmbient;	// Signifies if this channel / source is playing a looping ambient sound
+	bool	bProcessed;	// Signifies if this channel / source has been processed
+	bool	bStreaming;	// Set to true if the data needs to be streamed (MP3 or dialogue)
+	STREAMINGBUFFER	buffers[NUM_STREAMING_BUFFERS];	// AL Buffers for streaming
+	ALuint		alSource;		// Open AL Source
+	bool		bPlaying;		// Set to true when a sound is playing on this channel / source
+	int			iStartTime;		// Time playback of Source begins
+	int			lSlotID;		// ID of Slot rendering Source's environment (enables a send to this FXSlot)
+} channel_t;
+
+
+#define	WAV_FORMAT_PCM		1
+#define WAV_FORMAT_ADPCM	2	// not actually implemented, but is the value that you get in a header
+#define WAV_FORMAT_MP3		3	// not actually used this way, but just ensures we don't match one of the legit formats
+
+
+typedef struct {
+	int			format;
+	int			rate;
+	int			width;
+	int			channels;
+	int			samples;
+	int			dataofs;		// chunk starts this many bytes from file start
+} wavinfo_t;
+
+
+
+/*
+====================================================================
+
+  SYSTEM SPECIFIC FUNCTIONS
+
+====================================================================
+*/
+
+// initializes cycling through a DMA buffer and returns information on it
+qboolean SNDDMA_Init(void);
+
+// gets the current DMA position
+int		SNDDMA_GetDMAPos(void);
+
+// shutdown the DMA xfer.
+void	SNDDMA_Shutdown(void);
+
+void	SNDDMA_BeginPainting (void);
+
+void	SNDDMA_Submit(void);
+
+//====================================================================
+
+#define	MAX_CHANNELS			32
+extern	channel_t   s_channels[MAX_CHANNELS];
+
+extern	int		s_paintedtime;
+extern	int		s_rawend;
+extern	vec3_t	listener_origin;
+extern	vec3_t	listener_forward;
+extern	vec3_t	listener_right;
+extern	vec3_t	listener_up;
+extern	dma_t	dma;
+
+#define	MAX_RAW_SAMPLES	16384
+extern	portable_samplepair_t	s_rawsamples[MAX_RAW_SAMPLES];
+portable_samplepair_t *S_GetRawSamplePointer();	// TA added this, but it just returns the s_rawsamples[] array above. Oh well...
+
+extern cvar_t	*s_volume;
+extern cvar_t	*s_volumeVoice;
+extern cvar_t	*s_nosound;
+extern cvar_t	*s_khz;
+extern cvar_t	*s_allowDynamicMusic;
+extern cvar_t	*s_show;
+extern cvar_t	*s_mixahead;
+
+extern cvar_t	*s_testsound;
+extern cvar_t	*s_separation;
+
+wavinfo_t GetWavinfo (const char *name, byte *wav, int wavlength);
+
+sboolean S_LoadSound( sfx_t *sfx );
+
+
+void S_PaintChannels(int endtime);
+
+// picks a channel based on priorities, empty slots, number of channels
+channel_t *S_PickChannel(int entnum, int entchannel);
+
+// spatializes a channel
+void S_Spatialize(channel_t *ch);
+
+
+//////////////////////////////////
+//
+// new stuff from TA codebase
+
+byte	*SND_malloc(int iSize, sfx_t *sfx);
+void	 SND_setup();
+int		 SND_FreeOldestSound(sfx_t *pButNotThisOne = NULL);
+void	 SND_TouchSFX(sfx_t *sfx);
+
+void S_DisplayFreeMemory(void);
+void S_memoryLoad(sfx_t *sfx);
+//
+//////////////////////////////////
+
+#include "snd_mp3.h"
+
+#endif	// #ifndef SND_LOCAL_H
+
diff --git a/codemp/client/snd_local_console.h b/codemp/client/snd_local_console.h
new file mode 100644
index 0000000..8c9b22b
--- /dev/null
+++ b/codemp/client/snd_local_console.h
@@ -0,0 +1,121 @@
+// snd_local.h -- private sound definations
+
+#ifndef SND_LOCAL_H
+#define SND_LOCAL_H
+
+// Following #define is ONLY for MP JKA code.
+// They want to keep qboolean pure enum in that code, so all
+// sound code uses sboolean.
+#define sboolean int
+
+#include "../game/q_shared.h"
+#include "../qcommon/qcommon.h"
+#include "snd_public.h"
+#include "../mp3code/mp3struct.h"
+
+#include "openal/al.h"
+#include "openal/alc.h"
+
+typedef int streamHandle_t;
+
+//from SND_AMBIENT
+extern void AS_Init( void );
+extern void AS_Free( void );
+
+typedef struct {
+	int			format;
+	int			size;
+	int			width;
+	int			rate;
+} wavinfo_t;
+
+extern wavinfo_t GetWavInfo(byte *data);
+
+
+#define SFX_FLAG_UNLOADED	(1 << 0)
+#define SFX_FLAG_LOADING	(1 << 1)
+#define SFX_FLAG_RESIDENT	(1 << 2)
+#define SFX_FLAG_DEFAULT	(1 << 3)
+#define SFX_FLAG_DEMAND		(1 << 4)
+#define SFX_FLAG_VOICE		(1 << 5)
+
+typedef struct sfx_s {
+	int				iFlags;
+	int 			iSoundLength;			// length in bytes
+	int				iLastTimeUsed;			// last time sound was played in ms
+	int				iFileCode;				// CRC of the file name
+	streamHandle_t	iStreamHandle;			// handle to the sound file when reading
+	void*			pSoundData;				// buffer to hold sound as we are loading it
+	ALuint			Buffer;
+} sfx_t;
+
+typedef struct
+{
+	int			entnum;			// to allow overriding a specific sound
+	int			entchannel;		// to allow overriding a specific sound
+	int			master_vol;		// 0-255 volume before spatialization
+	float		fLastVolume;	// 0-1 last volume sent to AL
+
+	vec3_t		origin;			// sound location
+	bool		bOriginDirty;	// does the AL position need to be updated
+	
+	sfx_t		*thesfx;		// sfx structure
+
+	int			loopChannel;	// index into loopSounds (if appropriate)
+
+	bool		bPlaying;		// Set to true when a sound is playing on this channel / source
+	bool		b2D;			// Signifies a 2d sound
+	bool		bLooping;		// Signifies if this channel / source is playing a looping sound
+	ALuint		alSource;		// Open AL Source
+
+	unsigned int iLastPlayTime;	// Last time a sound was played on this channel
+} channel_t;
+
+extern cvar_t	*s_nosound;
+extern cvar_t	*s_allowDynamicMusic;
+extern cvar_t	*s_show;
+
+extern cvar_t	*s_testsound;
+extern cvar_t	*s_separation;
+
+extern int*	s_entityWavVol;
+
+int Sys_GetFileCode( const char* sSoundName );
+int S_GetFileCode( const char* sSoundName );
+
+qboolean S_StartLoadSound( sfx_t *sfx );
+qboolean S_EndLoadSound( sfx_t *sfx );
+
+void S_InitLoad(void);
+void S_CloseLoad(void);
+void S_UpdateLoading(void);
+
+// New stuff from VV
+void S_LoadSound( sfxHandle_t sfxHandle );
+
+// picks a channel based on priorities, empty slots, number of channels
+channel_t *S_PickChannel(int entnum, int entchannel);
+
+//////////////////////////////////
+//
+// new stuff from TA codebase
+
+void	 SND_update(sfx_t *sfx);
+void	 SND_setup();
+int		 SND_FreeOldestSound(sfx_t *pButNotThisOne = NULL);
+void	 SND_TouchSFX(sfx_t *sfx);
+
+void S_DisplayFreeMemory(void);
+void S_memoryLoad(sfx_t *sfx);
+
+bool Sys_StreamIsReading(streamHandle_t handle);
+int  Sys_StreamOpen(int code, streamHandle_t *handle);
+bool Sys_StreamRead(void* buffer, int size, int pos, streamHandle_t handle);
+void Sys_StreamClose(streamHandle_t handle);
+bool Sys_StreamIsError(streamHandle_t handle);
+
+//
+//////////////////////////////////
+
+#endif	// #ifndef SND_LOCAL_H
+
diff --git a/codemp/client/snd_mem.cpp b/codemp/client/snd_mem.cpp
new file mode 100644
index 0000000..8e3ee1f
--- /dev/null
+++ b/codemp/client/snd_mem.cpp
@@ -0,0 +1,1015 @@
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+// snd_mem.c: sound caching
+
+#include "snd_local.h"
+#include "snd_mp3.h"
+#include "snd_ambient.h"
+
+// Open AL
+void S_PreProcessLipSync(sfx_t *sfx);
+extern int s_UseOpenAL;
+/*
+===============================================================================
+
+WAV loading
+
+===============================================================================
+*/
+
+byte	*data_p;
+byte 	*iff_end;
+byte 	*last_chunk;
+byte 	*iff_data;
+int 	iff_chunk_len;
+extern sfx_t		s_knownSfx[];
+extern	int			s_numSfx;
+
+extern cvar_t		*s_lip_threshold_1;
+extern cvar_t		*s_lip_threshold_2;
+extern cvar_t		*s_lip_threshold_3;
+extern cvar_t		*s_lip_threshold_4;
+
+short GetLittleShort(void)
+{
+	short val = 0;
+	val = *data_p;
+	val = (short)(val + (*(data_p+1)<<8));
+	data_p += 2;
+	return val;
+}
+
+int GetLittleLong(void)
+{
+	int val = 0;
+	val = *data_p;
+	val = val + (*(data_p+1)<<8);
+	val = val + (*(data_p+2)<<16);
+	val = val + (*(data_p+3)<<24);
+	data_p += 4;
+	return val;
+}
+
+void FindNextChunk(char *name)
+{
+	while (1)
+	{
+		data_p=last_chunk;
+
+		if (data_p >= iff_end)
+		{	// didn't find the chunk
+			data_p = NULL;
+			return;
+		}
+		
+		data_p += 4;
+		iff_chunk_len = GetLittleLong();
+		if (iff_chunk_len < 0)
+		{
+			data_p = NULL;
+			return;
+		}
+		data_p -= 8;
+		last_chunk = data_p + 8 + ( (iff_chunk_len + 1) & ~1 );
+		if (!strncmp((char *)data_p, name, 4))
+			return;
+	}
+}
+
+void FindChunk(char *name)
+{
+	last_chunk = iff_data;
+	FindNextChunk (name);
+}
+
+
+void DumpChunks(void)
+{
+	char	str[5];
+	
+	str[4] = 0;
+	data_p=iff_data;
+	do
+	{
+		memcpy (str, data_p, 4);
+		data_p += 4;
+		iff_chunk_len = GetLittleLong();
+		Com_Printf ("0x%x : %s (%d)\n", (int)(data_p - 4), str, iff_chunk_len);
+		data_p += (iff_chunk_len + 1) & ~1;
+	} while (data_p < iff_end);
+}
+
+/*
+============
+GetWavinfo
+============
+*/
+wavinfo_t GetWavinfo (const char *name, byte *wav, int wavlength)
+{
+	wavinfo_t	info;
+	int		samples;
+
+	memset (&info, 0, sizeof(info));
+
+	if (!wav)
+		return info;
+		
+	iff_data = wav;
+	iff_end = wav + wavlength;
+
+// find "RIFF" chunk
+	FindChunk("RIFF");
+	if (!(data_p && !strncmp((char *)data_p+8, "WAVE", 4)))
+	{
+		Com_Printf("Missing RIFF/WAVE chunks\n");
+		return info;
+	}
+
+// get "fmt " chunk
+	iff_data = data_p + 12;
+// DumpChunks ();
+
+	FindChunk("fmt ");
+	if (!data_p)
+	{
+		Com_Printf("Missing fmt chunk\n");
+		return info;
+	}
+	data_p += 8;
+	info.format = GetLittleShort();
+	info.channels = GetLittleShort();
+	info.rate = GetLittleLong();
+	data_p += 4+2;
+	info.width = GetLittleShort() / 8;
+
+	if (info.format != 1)
+	{
+		Com_Printf("Microsoft PCM format only\n");
+		return info;
+	}
+
+
+// find data chunk
+	FindChunk("data");
+	if (!data_p)
+	{
+		Com_Printf("Missing data chunk\n");
+		return info;
+	}
+
+	data_p += 4;
+	samples = GetLittleLong () / info.width;
+
+	if (info.samples)
+	{
+		if (samples < info.samples)
+			Com_Error (ERR_DROP, "Sound %s has a bad loop length", name);
+	}
+	else
+		info.samples = samples;
+
+	info.dataofs = data_p - wav;
+
+
+	return info;
+}
+
+
+/*
+================
+ResampleSfx
+
+resample / decimate to the current source rate
+================
+*/
+void ResampleSfx (sfx_t *sfx, int iInRate, int iInWidth, byte *pData)
+{
+	int		iOutCount;
+	int		iSrcSample;
+	float	fStepScale;
+	int		i;
+	int		iSample;
+	unsigned int uiSampleFrac, uiFracStep;	// uiSampleFrac MUST be unsigned, or large samples (eg music tracks) crash
+	
+	fStepScale = (float)iInRate / dma.speed;	// this is usually 0.5, 1, or 2
+
+	// When stepscale is > 1 (we're downsampling), we really ought to run a low pass filter on the samples
+
+	iOutCount = (int)(sfx->iSoundLengthInSamples / fStepScale);
+	sfx->iSoundLengthInSamples = iOutCount;
+
+	sfx->pSoundData = (short *) SND_malloc( sfx->iSoundLengthInSamples*2 ,sfx );
+
+	sfx->fVolRange	= 0;
+	uiSampleFrac	= 0;
+	uiFracStep		= (int)(fStepScale*256);
+
+	for (i=0 ; i<sfx->iSoundLengthInSamples ; i++)
+	{
+		iSrcSample = uiSampleFrac >> 8;
+		uiSampleFrac += uiFracStep;
+		if (iInWidth == 2) {
+			iSample = LittleShort ( ((short *)pData)[iSrcSample] );			
+		} else {
+			iSample = (int)( (unsigned char)(pData[iSrcSample]) - 128) << 8;			
+		}
+
+		sfx->pSoundData[i] = (short)iSample;
+
+		// work out max vol for this sample...
+		//
+		if (iSample < 0)
+			iSample = -iSample;
+		if (sfx->fVolRange < (iSample >> 8) )
+		{
+			sfx->fVolRange =  iSample >> 8;
+		}
+	}
+}
+
+
+//=============================================================================
+
+
+void S_LoadSound_Finalize(wavinfo_t	*info, sfx_t *sfx, byte *data)
+{				   
+	float	stepscale	= (float)info->rate / dma.speed;	
+	int		len			= (int)(info->samples / stepscale);
+
+	len *= info->width;
+
+	sfx->eSoundCompressionMethod = ct_16;
+	sfx->iSoundLengthInSamples	 = info->samples;
+	ResampleSfx( sfx, info->rate, info->width, data + info->dataofs );	
+}
+
+
+
+
+
+// maybe I'm re-inventing the wheel, here, but I can't see any functions that already do this, so...
+//
+char *Filename_WithoutPath(const char *psFilename)
+{
+	static char sString[MAX_QPATH];	// !!
+	const char *p = strrchr(psFilename,'\\');
+
+  	if (!p++)
+		p=psFilename;
+
+	strcpy(sString,p);
+
+	return sString;
+
+}
+
+// returns (eg) "\dir\name" for "\dir\name.bmp"
+//
+char *Filename_WithoutExt(const char *psFilename)
+{
+	static char sString[MAX_QPATH];	// !
+
+	strcpy(sString,psFilename);
+
+	char *p = strrchr(sString,'.');		
+	char *p2= strrchr(sString,'\\');
+
+	// special check, make sure the first suffix we found from the end wasn't just a directory suffix (eg on a path'd filename with no extension anyway)
+	//
+	if (p && (p2==0 || (p2 && p>p2)))
+		*p=0;	
+
+	return sString;
+
+}
+
+
+
+int iFilesFound;
+int iFilesUpdated;
+int iErrors;
+sboolean qbForceRescan;
+sboolean qbForceStereo;
+string strErrors;
+
+void R_CheckMP3s( const char *psDir )
+{
+//	Com_Printf(va("Scanning Dir: %s\n",psDir));
+	Com_Printf(".");	// stops useful info scrolling off screen
+
+	char	**sysFiles, **dirFiles;
+	int		numSysFiles, i, numdirs;
+
+	dirFiles = FS_ListFiles( psDir, "/", &numdirs);
+	if (numdirs > 2)
+	{
+		for (i=2;i<numdirs;i++)
+		{
+			char	sDirName[MAX_QPATH];
+			sprintf(sDirName, "%s\\%s", psDir, dirFiles[i]);
+			R_CheckMP3s(sDirName);
+		}
+	}
+
+	sysFiles = FS_ListFiles( psDir, ".mp3", &numSysFiles );
+	for(i=0; i<numSysFiles; i++)
+	{
+		char	sFilename[MAX_QPATH];
+		sprintf(sFilename,"%s\\%s", psDir, sysFiles[i]);		
+			
+		Com_Printf("%sFound file: %s",!i?"\n":"",sFilename);
+
+		iFilesFound++;
+
+		// read it in...
+		//
+		byte *pbData = NULL;
+		int iSize = FS_ReadFile( sFilename, (void **)&pbData);
+
+		if (pbData)
+		{
+			id3v1_1* pTAG;
+
+			// do NOT check 'qbForceRescan' here as an opt, because we need to actually fill in 'pTAG' if there is one...
+			//
+			sboolean qbTagNeedsUpdating = (/* qbForceRescan || */ !MP3_ReadSpecialTagInfo(pbData, iSize, &pTAG))?qtrue:qfalse;
+
+			if (pTAG == NULL || qbTagNeedsUpdating || qbForceRescan)
+			{
+				Com_Printf(" ( Updating )\n");
+
+				// I need to scan this file to get the volume...
+				//
+				// For EF1 I used a temp sfx_t struct, but I can't do that now with this new alloc scheme,
+				//	I have to ask for it legally, so I'll keep re-using one, and restoring it's name after use.
+				//	(slightly dodgy, but works ok if no-one else changes stuff)
+				//
+				//sfx_t SFX = {0};
+				extern sfx_t *S_FindName( const char *name );
+				//
+				static sfx_t *pSFX = NULL;
+				const char sReservedSFXEntrynameForMP3[] = "reserved_for_mp3";	// ( strlen() < MAX_QPATH )
+
+				if (pSFX == NULL)	// once only
+				{
+					pSFX = S_FindName(sReservedSFXEntrynameForMP3);	// always returns, else ERR_FATAL					
+				}
+
+				if (MP3_IsValid(sFilename,pbData, iSize, qbForceStereo))
+				{
+					wavinfo_t info;
+
+					int iRawPCMDataSize = MP3_GetUnpackedSize(sFilename, pbData, iSize, qtrue, qbForceStereo);
+
+					if (iRawPCMDataSize)	// should always be true, unless file is fucked, in which case, stop this conversion process
+					{
+						float fMaxVol = 128;	// any old default
+						int iActualUnpackedSize = iRawPCMDataSize;	// default, override later if not doing music
+
+						if (!qbForceStereo)	// no point for stereo files, which are for music and therefore no lip-sync
+						{
+							byte *pbUnpackBuffer = (byte *) Z_Malloc( iRawPCMDataSize+10, TAG_TEMP_WORKSPACE, qfalse );	// won't return if fails
+
+							iActualUnpackedSize = MP3_UnpackRawPCM( sFilename, pbData, iSize, pbUnpackBuffer );
+							if (iActualUnpackedSize != iRawPCMDataSize)
+							{
+								Com_Error(ERR_DROP, "******* Whoah! MP3 %s unpacked to %d bytes, but size calc said %d!\n",sFilename,iActualUnpackedSize,iRawPCMDataSize);
+							}
+						
+							// fake up a WAV structure so I can use the other post-load sound code such as volume calc for lip-synching
+							//
+							MP3_FakeUpWAVInfo( sFilename, pbData, iSize, iActualUnpackedSize,
+												// these params are all references...
+												info.format, info.rate, info.width, info.channels, info.samples, info.dataofs
+												);
+
+							S_LoadSound_Finalize(&info, pSFX, pbUnpackBuffer);	// all this just for lipsynch. Oh well.
+
+							fMaxVol = pSFX->fVolRange;
+
+							// free sfx->data...
+							//
+							{
+								#ifndef INT_MIN
+								#define INT_MIN     (-2147483647 - 1) /* minimum (signed) int value */
+								#endif
+								//
+								pSFX->iLastTimeUsed = INT_MIN;		// force this to be oldest sound file, therefore disposable...
+								pSFX->bInMemory = qtrue;
+								SND_FreeOldestSound();		// ... and do the disposal
+
+								// now set our temp SFX struct back to default name so nothing else accidentally uses it...
+								//
+								strcpy(pSFX->sSoundName, sReservedSFXEntrynameForMP3);
+								pSFX->bDefaultSound = qfalse;								
+							}
+
+//							OutputDebugString(va("File: \"%s\"   MaxVol %f\n",sFilename,pSFX->fVolRange));
+
+							// other stuff...
+							//
+							Z_Free(pbUnpackBuffer);
+						}
+
+						// well, time to update the file now...
+						//
+						fileHandle_t f = FS_FOpenFileWrite( sFilename );
+						if (f)
+						{
+							// write the file back out, but omitting the tag if there was one...
+							//
+							int iWritten = FS_Write(pbData, iSize-(pTAG?sizeof(*pTAG):0), f);
+
+							if (iWritten)
+							{
+								// make up a new tag if we didn't find one in the original file...
+								//
+								id3v1_1 TAG;
+								if (!pTAG)
+								{
+									pTAG = &TAG;
+									memset(&TAG,0,sizeof(TAG));
+									strncpy(pTAG->id,"TAG",3);
+								}
+
+								strncpy(pTAG->title,	Filename_WithoutPath(Filename_WithoutExt(sFilename)), sizeof(pTAG->title));
+								strncpy(pTAG->artist,	"Raven Software",						sizeof(pTAG->artist)	);
+								strncpy(pTAG->year,		"2002",									sizeof(pTAG->year)		);
+								strncpy(pTAG->comment,	va("%s %g",sKEY_MAXVOL,fMaxVol),		sizeof(pTAG->comment)	);
+								strncpy(pTAG->album,	va("%s %d",sKEY_UNCOMP,iActualUnpackedSize),sizeof(pTAG->album)	);
+								
+								if (FS_Write( pTAG, sizeof(*pTAG), f ))	// NZ = success
+								{
+									iFilesUpdated++;
+								}
+								else
+								{
+									Com_Printf("*********** Failed write to file \"%s\"!\n",sFilename);
+									iErrors++;
+									strErrors += va("Failed to write: \"%s\"\n",sFilename);
+								}
+							}
+							else
+							{
+								Com_Printf("*********** Failed write to file \"%s\"!\n",sFilename);
+								iErrors++;
+								strErrors += va("Failed to write: \"%s\"\n",sFilename);
+							}
+							FS_FCloseFile( f );
+						}
+						else
+						{
+							Com_Printf("*********** Failed to re-open for write \"%s\"!\n",sFilename);
+							iErrors++;
+							strErrors += va("Failed to re-open for write: \"%s\"\n",sFilename);
+						}					
+					}
+					else
+					{
+						Com_Error(ERR_DROP, "******* This MP3 should be deleted: \"%s\"\n",sFilename);
+					}
+				}
+				else
+				{
+					Com_Printf("*********** File was not a valid MP3!: \"%s\"\n",sFilename);
+					iErrors++;
+					strErrors += va("Not game-legal MP3 format: \"%s\"\n",sFilename);
+				}
+			}
+			else
+			{
+				Com_Printf(" ( OK )\n");
+			}
+
+			FS_FreeFile( pbData );
+		}
+	}
+	FS_FreeFileList( sysFiles );
+	FS_FreeFileList( dirFiles );
+}
+
+// this console-function is for development purposes, and makes sure that sound/*.mp3 /s have tags in them
+//	specifying stuff like their max volume (and uncompressed size) etc...
+//
+void S_MP3_CalcVols_f( void )
+{
+	char sStartDir[MAX_QPATH] = {"sound"};
+	const char sUsage[] = "Usage: mp3_calcvols [-rescan] <startdir>\ne.g. mp3_calcvols sound/chars";
+
+	if (Cmd_Argc() == 1 || Cmd_Argc()>4)	// 3 optional arguments
+	{
+		Com_Printf(sUsage);
+		return;
+	}
+
+	S_StopAllSounds();
+
+
+	qbForceRescan = qfalse;
+	qbForceStereo = qfalse;
+	iFilesFound		= 0;
+	iFilesUpdated	= 0;
+	iErrors			= 0;
+	strErrors		= "";
+
+	for (int i=1; i<Cmd_Argc(); i++)
+	{
+		if (Cmd_Argv(i)[0] == '-')
+		{
+			if (!Q_stricmp(Cmd_Argv(i),"-rescan"))
+			{
+				qbForceRescan = qtrue;
+			}
+			else
+			if (!Q_stricmp(Cmd_Argv(i),"-stereo"))
+			{
+				qbForceStereo = qtrue;
+			}
+			else
+			{
+				// unknown switch...
+				//
+				Com_Printf(sUsage);
+				return;
+			}
+			continue;
+		}
+		strcpy(sStartDir,Cmd_Argv(i));
+	}
+
+	Com_Printf(va("Starting Scan for Updates in Dir: %s\n",sStartDir));
+	R_CheckMP3s( sStartDir );
+
+	Com_Printf("\n%d files found/scanned, %d files updated      ( %d errors total)\n",iFilesFound,iFilesUpdated,iErrors);
+
+	if (iErrors)
+	{
+		Com_Printf("\nBad Files:\n%s\n",strErrors.c_str());
+	}
+}
+
+
+
+
+
+// adjust filename for foreign languages and WAV/MP3 issues. 
+//
+// returns qfalse if failed to load, else fills in *pData
+//
+extern	cvar_t	*com_buildScript;
+static sboolean S_LoadSound_FileLoadAndNameAdjuster(char *psFilename, byte **pData, int *piSize, int iNameStrlen)
+{
+	char *psVoice = strstr(psFilename,"chars");
+	if (psVoice)
+	{
+		// cache foreign voices...
+		//		
+		if (com_buildScript->integer)
+		{
+			fileHandle_t hFile;
+			//German
+			strncpy(psVoice,"chr_d",5);	// same number of letters as "chars"
+			FS_FOpenFileRead(psFilename, &hFile, qfalse);		//cache the wav
+			if (!hFile)
+			{
+				strcpy(&psFilename[iNameStrlen-3],"mp3");		//not there try mp3
+				FS_FOpenFileRead(psFilename, &hFile, qfalse);	//cache the mp3
+			}
+			if (hFile)
+			{
+				FS_FCloseFile(hFile);
+			}
+			strcpy(&psFilename[iNameStrlen-3],"wav");	//put it back to wav
+
+			//French
+			strncpy(psVoice,"chr_f",5);	// same number of letters as "chars"
+			FS_FOpenFileRead(psFilename, &hFile, qfalse);		//cache the wav
+			if (!hFile)
+			{
+				strcpy(&psFilename[iNameStrlen-3],"mp3");		//not there try mp3
+				FS_FOpenFileRead(psFilename, &hFile, qfalse);	//cache the mp3
+			}
+			if (hFile)
+			{
+				FS_FCloseFile(hFile);
+			}
+			strcpy(&psFilename[iNameStrlen-3],"wav");	//put it back to wav
+
+			//Spanish
+			strncpy(psVoice,"chr_e",5);	// same number of letters as "chars"
+			FS_FOpenFileRead(psFilename, &hFile, qfalse);		//cache the wav
+			if (!hFile)
+			{
+				strcpy(&psFilename[iNameStrlen-3],"mp3");		//not there try mp3
+				FS_FOpenFileRead(psFilename, &hFile, qfalse);	//cache the mp3
+			}
+			if (hFile)
+			{
+				FS_FCloseFile(hFile);
+			}
+			strcpy(&psFilename[iNameStrlen-3],"wav");	//put it back to wav
+
+			strncpy(psVoice,"chars",5);	//put it back to chars
+		}
+
+		// account for foreign voices...
+		//		
+		extern cvar_t* s_language;
+		if (s_language && stricmp("DEUTSCH",s_language->string)==0)
+		{				
+			strncpy(psVoice,"chr_d",5);	// same number of letters as "chars"
+		}
+		else if (s_language && stricmp("FRANCAIS",s_language->string)==0)
+		{				
+			strncpy(psVoice,"chr_f",5);	// same number of letters as "chars"
+		}
+		else if (s_language && stricmp("ESPANOL",s_language->string)==0)
+		{				
+			strncpy(psVoice,"chr_e",5);	// same number of letters as "chars"
+		}
+		else
+		{
+			psVoice = NULL;	// use this ptr as a flag as to whether or not we substituted with a foreign version
+		}
+	}
+
+	*piSize = FS_ReadFile( psFilename, (void **)pData );	// try WAV
+	if ( !*pData ) {
+		psFilename[iNameStrlen-3] = 'm';
+		psFilename[iNameStrlen-2] = 'p';
+		psFilename[iNameStrlen-1] = '3';
+		*piSize = FS_ReadFile( psFilename, (void **)pData );	// try MP3
+
+		if ( !*pData ) 
+		{
+			//hmmm, not found, ok, maybe we were trying a foreign noise ("arghhhhh.mp3" that doesn't matter?) but it
+			// was missing?   Can't tell really, since both types are now in sound/chars. Oh well, fall back to English for now...
+			
+			if (psVoice)	// were we trying to load foreign?
+			{
+				// yep, so fallback to re-try the english...
+				//				
+#ifndef FINAL_BUILD
+				Com_Printf(S_COLOR_YELLOW "Foreign file missing: \"%s\"! (using English...)\n",psFilename);
+#endif
+
+				strncpy(psVoice,"chars",5);
+
+				psFilename[iNameStrlen-3] = 'w';
+				psFilename[iNameStrlen-2] = 'a';
+				psFilename[iNameStrlen-1] = 'v';
+				*piSize = FS_ReadFile( psFilename, (void **)pData );	// try English WAV
+				if ( !*pData ) 
+				{						
+					psFilename[iNameStrlen-3] = 'm';
+					psFilename[iNameStrlen-2] = 'p';
+					psFilename[iNameStrlen-1] = '3';
+					*piSize = FS_ReadFile( psFilename, (void **)pData );	// try English MP3
+				}
+			}
+
+			if (!*pData)
+			{
+				return qfalse;	// sod it, give up...
+			}
+		}
+	}
+
+	return qtrue;
+}
+
+
+// returns qtrue if this dir is allowed to keep loaded MP3s, else qfalse if they should be WAV'd instead...
+//
+// note that this is passed the original, un-language'd name
+//
+// (I was going to remove this, but on kejim_post I hit an assert because someone had got an ambient sound when the
+//	perimter fence goes online that was an MP3, then it tried to get added as looping. Presumably it sounded ok or
+//	they'd have noticed, but we therefore need to stop other levels using those. "sound/ambience" I can check for,
+//	but doors etc could be anything. Sigh...)
+//
+static sboolean S_LoadSound_DirIsAllowedToKeepMP3s(const char *psFilename)
+{
+	static const char *psAllowedDirs[] = 
+	{
+		"sound/chars/",
+//		"sound/chr_d/"	// no need for this now, or any other language, since we'll always compare against english
+	};
+
+	int i;
+	for (i=0; i< (sizeof(psAllowedDirs) / sizeof(psAllowedDirs[0])); i++)
+	{
+		if (strnicmp(psFilename, psAllowedDirs[i], strlen(psAllowedDirs[i]))==0)
+			return qtrue;	// found a dir that's allowed to keep MP3s
+	}
+
+	return qfalse;
+}
+
+
+
+/*
+==============
+S_LoadSound
+
+The filename may be different than sfx->name in the case
+of a forced fallback of a player specific sound	(or of a wav/mp3 substitution now -Ste)
+==============
+*/
+qboolean gbInsideLoadSound = qfalse;
+static sboolean S_LoadSound_Actual( sfx_t *sfx )
+{
+	byte	*data;
+	short	*samples;
+	wavinfo_t	info;
+	int		size;
+	char	*psExt;
+	char	sLoadName[MAX_QPATH];
+	ALuint  Buffer;
+	
+	int		len = strlen(sfx->sSoundName);
+	if (len<5)
+	{
+		return qfalse;
+	}
+
+	// player specific sounds are never directly loaded...
+	//
+	if ( sfx->sSoundName[0] == '*') {
+		return qfalse;
+	}
+	// make up a local filename to try wav/mp3 substitutes...
+	//	
+	Q_strncpyz(sLoadName, sfx->sSoundName, sizeof(sLoadName));	
+	strlwr( sLoadName );
+	//
+	// Ensure name has an extension (which it must have, but you never know), and get ptr to it...
+	//
+	psExt = &sLoadName[strlen(sLoadName)-4];
+	if (*psExt != '.')
+	{
+		//Com_Printf( "WARNING: soundname '%s' does not have 3-letter extension\n",sLoadName);
+		COM_DefaultExtension(sLoadName,sizeof(sLoadName),".wav");	// so psExt below is always valid
+		psExt = &sLoadName[strlen(sLoadName)-4];
+		len = strlen(sLoadName);
+	}
+
+	if (!S_LoadSound_FileLoadAndNameAdjuster(sLoadName, &data, &size, len))
+	{
+		return qfalse;
+	}
+
+	SND_TouchSFX(sfx);
+
+//=========
+	if (strnicmp(psExt,".mp3",4)==0)
+	{
+		// load MP3 file instead...
+		//		
+		if (MP3_IsValid(sLoadName,data, size, qfalse))
+		{
+			int iRawPCMDataSize = MP3_GetUnpackedSize(sLoadName,data,size,qfalse,qfalse);
+			
+			if (S_LoadSound_DirIsAllowedToKeepMP3s(sfx->sSoundName)	// NOT sLoadName, this uses original un-languaged name
+				&&
+				MP3Stream_InitFromFile(sfx, data, size, sLoadName, iRawPCMDataSize + 2304 /* + 1 MP3 frame size, jic */,qfalse)				
+				)
+			{
+//				Com_DPrintf("(Keeping file \"%s\" as MP3)\n",sLoadName);
+
+				if (s_UseOpenAL)
+				{
+					// Create space for lipsync data (4 lip sync values per streaming AL buffer)
+					if ((strstr(sfx->sSoundName, "chars")) || (strstr(sfx->sSoundName, "CHARS")))
+						sfx->lipSyncData = (char *)Z_Malloc(16, TAG_SND_RAWDATA, qfalse);
+					else
+						sfx->lipSyncData = NULL;
+				}
+			}
+			else
+			{
+				// small file, not worth keeping as MP3 since it would increase in size (with MP3 header etc)...
+				//
+				Com_DPrintf("S_LoadSound: Unpacking MP3 file(%i) \"%s\" to wav(%i).\n",size,sLoadName,iRawPCMDataSize);
+				//
+				// unpack and convert into WAV...
+				//
+				{
+					byte *pbUnpackBuffer = (byte *) Z_Malloc( iRawPCMDataSize+10 +2304 /* <g> */, TAG_TEMP_WORKSPACE, qfalse );	// won't return if fails
+					
+					{
+						int iResultBytes = MP3_UnpackRawPCM( sLoadName, data, size, pbUnpackBuffer, qfalse );
+
+						if (iResultBytes!= iRawPCMDataSize){
+							Com_Printf(S_COLOR_YELLOW"**** MP3 %s final unpack size %d different to previous value %d\n",sLoadName,iResultBytes,iRawPCMDataSize);
+							//assert (iResultBytes == iRawPCMDataSize);
+						}
+
+
+						// fake up a WAV structure so I can use the other post-load sound code such as volume calc for lip-synching
+						//
+						// (this is a bit crap really, but it lets me drop through into existing code)...
+						//
+						MP3_FakeUpWAVInfo( sLoadName, data, size, iResultBytes,
+											// these params are all references...
+											info.format, info.rate, info.width, info.channels, info.samples, info.dataofs,
+											qfalse
+										);
+
+						S_LoadSound_Finalize(&info,sfx,pbUnpackBuffer);
+
+						// Open AL
+						if (s_UseOpenAL)
+						{
+							if ((strstr(sfx->sSoundName, "chars")) || (strstr(sfx->sSoundName, "CHARS")))
+							{
+								sfx->lipSyncData = (char *)Z_Malloc((sfx->iSoundLengthInSamples / 1000) + 1, TAG_SND_RAWDATA, qfalse);
+								S_PreProcessLipSync(sfx);
+							}
+							else
+								sfx->lipSyncData = NULL;
+
+							// Clear Open AL Error state
+							alGetError();
+
+							// Generate AL Buffer
+							alGenBuffers(1, &Buffer);
+							if (alGetError() == AL_NO_ERROR)
+							{
+								// Copy audio data to AL Buffer
+								alBufferData(Buffer, AL_FORMAT_MONO16, sfx->pSoundData, sfx->iSoundLengthInSamples*2, 22050);
+								if (alGetError() == AL_NO_ERROR)
+								{
+									sfx->Buffer = Buffer;
+									Z_Free(sfx->pSoundData);
+									sfx->pSoundData = NULL;
+								}
+							}
+						}
+
+						Z_Free(pbUnpackBuffer);
+					}
+				}
+			}
+		}
+		else
+		{
+			// MP3_IsValid() will already have printed any errors via Com_Printf at this point...
+			//			
+			FS_FreeFile (data);
+			return qfalse;
+		}
+	}
+	else
+	{
+		// loading a WAV, presumably...
+
+//=========
+
+		info = GetWavinfo( sLoadName, data, size );
+		if ( info.channels != 1 ) {
+			Com_Printf ("%s is a stereo wav file\n", sLoadName);
+			FS_FreeFile (data);
+			return qfalse;
+		}
+
+/*		if ( info.width == 1 ) {
+			Com_Printf(S_COLOR_YELLOW "WARNING: %s is a 8 bit wav file\n", sLoadName);
+		}
+
+		if ( info.rate != 22050 ) {
+			Com_Printf(S_COLOR_YELLOW "WARNING: %s is not a 22kHz wav file\n", sLoadName);
+		}
+*/
+		samples = (short *)Z_Malloc(info.samples * sizeof(short) * 2, TAG_TEMP_WORKSPACE, qfalse);
+
+		sfx->eSoundCompressionMethod = ct_16;
+		sfx->iSoundLengthInSamples	 = info.samples;
+		sfx->pSoundData = NULL;
+		ResampleSfx( sfx, info.rate, info.width, data + info.dataofs );
+
+		// Open AL
+		if (s_UseOpenAL)
+		{
+			if ((strstr(sfx->sSoundName, "chars")) || (strstr(sfx->sSoundName, "CHARS")))
+			{
+				sfx->lipSyncData = (char *)Z_Malloc((sfx->iSoundLengthInSamples / 1000) + 1, TAG_SND_RAWDATA, qfalse);
+				S_PreProcessLipSync(sfx);
+			}
+			else
+				sfx->lipSyncData = NULL;
+
+			// Clear Open AL Error State
+			alGetError();
+
+			// Generate AL Buffer
+			alGenBuffers(1, &Buffer);
+			if (alGetError() == AL_NO_ERROR)
+			{
+				// Copy audio data to AL Buffer
+				alBufferData(Buffer, AL_FORMAT_MONO16, sfx->pSoundData, sfx->iSoundLengthInSamples*2, 22050);
+				if (alGetError() == AL_NO_ERROR)
+				{
+					// Store AL Buffer in sfx struct, and release sample data
+					sfx->Buffer = Buffer;
+					Z_Free(sfx->pSoundData);
+					sfx->pSoundData = NULL;
+				}
+			}
+		}
+
+		Z_Free(samples);
+	}
+	
+	FS_FreeFile( data );
+
+	return qtrue;
+}
+
+
+// wrapper function for above so I can guarantee that we don't attempt any audio-dumping during this call because
+//	of a z_malloc() fail recovery...
+//
+sboolean S_LoadSound( sfx_t *sfx )
+{
+	gbInsideLoadSound = qtrue;	// !!!!!!!!!!!!!
+		
+		sboolean bReturn = S_LoadSound_Actual( sfx );
+
+	gbInsideLoadSound = qfalse;	// !!!!!!!!!!!!!
+
+	return bReturn;
+}
+
+
+/*
+	Precalculate the lipsync values for the whole sample
+*/
+void S_PreProcessLipSync(sfx_t *sfx)
+{
+	int i, j;
+	int sample;
+	int sampleTotal = 0;
+
+	j = 0;
+	for (i = 0; i < sfx->iSoundLengthInSamples; i += 100)
+	{
+		sample = LittleShort(sfx->pSoundData[i]);
+
+		sample = sample >> 8;
+		sampleTotal += sample * sample;
+		if (((i + 100) % 1000) == 0)
+		{
+			sampleTotal /= 10;
+
+			if (sampleTotal < sfx->fVolRange *  s_lip_threshold_1->value)
+			{
+				// tell the scripts that are relying on this that we are still going, but actually silent right now.
+				sample = -1;
+			}
+			else if (sampleTotal < sfx->fVolRange * s_lip_threshold_2->value)
+				sample = 1;
+			else if (sampleTotal < sfx->fVolRange * s_lip_threshold_3->value)
+				sample = 2;
+			else if (sampleTotal < sfx->fVolRange * s_lip_threshold_4->value)
+				sample = 3;
+			else
+				sample = 4;
+			
+			sfx->lipSyncData[j] = sample;
+			j++;
+
+			sampleTotal = 0;
+		}
+	}
+
+	if ((i % 1000) == 0)
+		return;
+
+	i -= 100;
+	i = i % 1000;
+	i = i / 100;
+	// Process last < 1000 samples
+	if (i != 0)
+		sampleTotal /= i;
+	else
+		sampleTotal = 0;
+
+	if (sampleTotal < sfx->fVolRange * s_lip_threshold_1->value)
+	{
+		// tell the scripts that are relying on this that we are still going, but actually silent right now.
+		sample = -1;
+	}
+	else if (sampleTotal < sfx->fVolRange * s_lip_threshold_2->value)
+		sample = 1;
+	else if (sampleTotal < sfx->fVolRange * s_lip_threshold_3->value)
+		sample = 2;
+	else if (sampleTotal < sfx->fVolRange * s_lip_threshold_4->value)
+		sample = 3;
+	else
+		sample = 4;
+			
+	sfx->lipSyncData[j] = sample;
+}
+
diff --git a/codemp/client/snd_mem_console.cpp b/codemp/client/snd_mem_console.cpp
new file mode 100644
index 0000000..14cb57c
--- /dev/null
+++ b/codemp/client/snd_mem_console.cpp
@@ -0,0 +1,355 @@
+// snd_mem.c: sound caching
+
+
+// leave this as first line for PCH reasons...
+//
+// #include "../server/exe_headers.h"
+
+#include "snd_local_console.h"
+
+#ifdef _XBOX
+#include <xtl.h>
+#endif
+
+#define SND_MAX_LOADS 48
+static sfx_t** s_LoadList = NULL;
+static int s_LoadListSize = 0;
+qboolean gbInsideLoadSound = qfalse;	// Needed to link VVFIXME
+
+extern int Sys_GetFileCode(const char *name);
+
+//Drain sound main memory into ARAM.
+void S_DrainRawSoundData(void)
+{
+	extern int s_soundStarted;
+	if (!s_soundStarted) return;
+
+	do
+	{
+		S_UpdateLoading();
+
+#ifdef _GAMECUBE
+		extern void ERR_DiscFail(bool);
+		ERR_DiscFail(true);
+#endif
+	} 
+	while (s_LoadListSize);
+}
+
+
+
+/*
+============
+GetWavInfo
+============
+*/
+wavinfo_t GetWavInfo(byte *data)
+{
+	wavinfo_t info;
+	memset(&info, 0, sizeof(wavinfo_t));
+
+	if (!data) return info;
+
+#ifdef _GAMECUBE
+	if (*(short*)&data[14] != 0)
+	{
+		// invalid type, abort
+		return info;
+	}
+
+	info.format = AL_FORMAT_MONO4;
+	info.width = 4;
+	info.size = ((*(int*)&data[20]) >> 1) + 96;
+	info.rate = *(int*)&data[8];
+#else
+	int dataofs = 0;
+	if (strncmp((char *)&data[dataofs + 0], "RIFF", 4) ||
+		strncmp((char *)&data[dataofs + 8], "WAVE", 4))
+	{
+		// invalid type, abort
+		return info;
+	}
+	dataofs += 12; // done with riff chunk
+
+	WAVEFORMATEX* wav = (WAVEFORMATEX*)&data[dataofs + 8];
+	info.format = wav->nChannels == 1 ? AL_FORMAT_MONO4 : AL_FORMAT_STEREO4;
+	info.rate = wav->nSamplesPerSec;
+	info.width = wav->wBitsPerSample;
+	dataofs += sizeof(WAVEFORMATEX) + wav->cbSize + 8; // done with fmt chunk
+	
+	info.size = *(int*)&data[dataofs + 4];
+	dataofs += 8; // done with data chunk
+#endif
+
+	return info;
+}
+
+// adjust filename for foreign languages and WAV/MP3 issues. 
+//
+static qboolean S_LoadSound_FileNameAdjuster(char *psFilename)
+{
+#if defined(_XBOX)
+	const char* ext = "wxb";
+#elif defined(_WINDOWS)
+	const char* ext = "wav";
+#elif defined(_GAMECUBE)
+	const char* ext = "wgc";
+#endif
+	
+	int len = strlen(psFilename);
+#if 0
+	char *psVoice = strstr(psFilename,"chars");
+	if (psVoice)
+	{
+		// account for foreign voices...
+		//		
+		extern cvar_t* sp_language;
+		if (sp_language && sp_language->integer==SP_LANGUAGE_GERMAN)
+		{				
+			strncpy(psVoice,"chr_d",5);	// same number of letters as "chars"
+		}
+		else
+		if (sp_language && sp_language->integer==SP_LANGUAGE_FRENCH)
+		{				
+			strncpy(psVoice,"chr_f",5);	// same number of letters as "chars"
+		}
+		else
+		{
+			psVoice = NULL;	// use this ptr as a flag as to whether or not we substituted with a foreign version
+		}
+	}
+#else
+	char *psVoice = NULL;
+#endif
+
+	psFilename[len-3] = ext[0];
+	psFilename[len-2] = ext[1];
+	psFilename[len-1] = ext[2];
+	int code = Sys_GetFileCode( psFilename );
+
+	if ( code == -1 )
+	{
+		//hmmm, not found, ok, maybe we were trying a foreign noise ("arghhhhh.mp3" that doesn't matter?) but it
+		// was missing?   Can't tell really, since both types are now in sound/chars. Oh well, fall back to English for now...
+		
+		if (psVoice)	// were we trying to load foreign?
+		{
+			// yep, so fallback to re-try the english...
+			//
+			strncpy(psVoice,"chars",5);
+			
+			psFilename[len-3] = ext[0];
+			psFilename[len-2] = ext[1];
+			psFilename[len-1] = ext[2];
+			code = Sys_GetFileCode( psFilename );
+		}
+	}
+
+	return code;
+}
+
+/*
+==============
+S_GetFileCode
+==============
+*/
+int S_GetFileCode( const char* sSoundName )
+{
+	char	sLoadName[MAX_QPATH];
+
+	// make up a local filename to try wav/mp3 substitutes...
+	//	
+	Q_strncpyz(sLoadName, sSoundName, sizeof(sLoadName));	
+	Q_strlwr( sLoadName );
+
+	// make sure we have an extension...
+	//
+	if (sLoadName[strlen(sLoadName) - 4] != '.')
+	{
+		strcat(sLoadName, ".xxx");
+	}
+
+	return S_LoadSound_FileNameAdjuster(sLoadName);
+}
+
+/*
+============
+S_UpdateLoading
+============
+*/
+void S_UpdateLoading(void) {
+	for ( int i = 0; i < SND_MAX_LOADS; ++i )
+	{
+		if ( s_LoadList[i] &&
+			(s_LoadList[i]->iFlags & SFX_FLAG_LOADING) &&
+			!Sys_StreamIsReading(s_LoadList[i]->iStreamHandle) )
+		{
+			S_EndLoadSound(s_LoadList[i]);
+			s_LoadList[i] = NULL;
+			--s_LoadListSize;
+		}
+	}
+}
+
+/*
+==============
+S_BeginLoadSound
+==============
+*/
+qboolean S_StartLoadSound( sfx_t *sfx )
+{
+	assert(sfx->iFlags & SFX_FLAG_UNLOADED);
+	sfx->iFlags &= ~SFX_FLAG_UNLOADED;
+	
+	// Valid file?
+	if (sfx->iFileCode == -1)
+	{
+		sfx->iFlags |= SFX_FLAG_RESIDENT | SFX_FLAG_DEFAULT;
+		return qfalse;
+	}
+
+	// Finish up any pending loads
+	do
+	{
+		S_UpdateLoading();
+	} 
+	while (s_LoadListSize >= SND_MAX_LOADS);
+
+	// Open the file
+	sfx->iSoundLength = Sys_StreamOpen(sfx->iFileCode, &sfx->iStreamHandle);
+	if ( sfx->iSoundLength <= 0 )
+	{
+		sfx->iFlags |= SFX_FLAG_RESIDENT | SFX_FLAG_DEFAULT;
+		return qfalse;
+	}
+
+#ifdef _GAMECUBE
+	// Allocate a buffer to read into...
+	sfx->pSoundData = Z_Malloc(sfx->iSoundLength + 64, TAG_SND_RAWDATA,
+			qtrue, 32);
+#else
+	// Allocate a buffer to read into...
+	sfx->pSoundData = Z_Malloc(sfx->iSoundLength, TAG_SND_RAWDATA, qtrue, 32);
+#endif
+
+	// Setup the background read
+	if ( !sfx->pSoundData || 
+			!Sys_StreamRead(sfx->pSoundData, sfx->iSoundLength, 0, 
+				sfx->iStreamHandle) )
+	{
+		if(sfx->pSoundData) {
+			Z_Free(sfx->pSoundData);
+		}
+		Sys_StreamClose(sfx->iStreamHandle);
+		sfx->iFlags |= SFX_FLAG_RESIDENT | SFX_FLAG_DEFAULT;
+		return qfalse;
+	}
+	sfx->iFlags |= SFX_FLAG_LOADING;
+
+	// add sound to load list
+	for (int i = 0; i < SND_MAX_LOADS; ++i)
+	{
+		if (!s_LoadList[i])
+		{
+			s_LoadList[i] = sfx;
+			++s_LoadListSize;
+			break;
+		}
+	}
+
+	return qtrue;
+}
+
+/*
+==============
+S_EndLoadSound
+==============
+*/
+qboolean S_EndLoadSound( sfx_t *sfx )
+{
+	wavinfo_t	info;
+	byte*		data;
+	ALuint		Buffer;
+
+	assert(sfx->iFlags & SFX_FLAG_LOADING);
+	sfx->iFlags &= ~SFX_FLAG_LOADING;
+
+	// was the read successful?
+	if (Sys_StreamIsError(sfx->iStreamHandle))
+	{
+#if 0 // defined(FINAL_BUILD) //PORT
+		extern void ERR_DiscFail(bool);
+		ERR_DiscFail(false);
+#endif
+		Sys_StreamClose(sfx->iStreamHandle);
+		Z_Free(sfx->pSoundData);
+		sfx->iFlags |= SFX_FLAG_RESIDENT | SFX_FLAG_DEFAULT;
+		return qfalse;
+	}
+
+	Sys_StreamClose(sfx->iStreamHandle);
+	SND_TouchSFX(sfx);
+
+	sfx->iLastTimeUsed = Com_Milliseconds()+1;	// why +1? Hmmm, leave it for now I guess	
+
+	// loading a WAV, presumably...
+	data = (byte*)sfx->pSoundData;
+	info = GetWavInfo( data );
+
+	if (info.size == 0)
+	{
+		Z_Free(sfx->pSoundData);
+		sfx->iFlags |= SFX_FLAG_RESIDENT | SFX_FLAG_DEFAULT;
+		return qfalse;
+	}
+	
+	sfx->iSoundLength = info.size;
+
+	// make sure we have enough space for the sound
+	SND_update(sfx);
+
+	// Clear Open AL Error State
+	alGetError();
+
+	// Generate AL Buffer
+	alGenBuffers(1, &Buffer);
+
+	// Copy audio data to AL Buffer
+	alBufferData(Buffer, info.format, data, 
+		sfx->iSoundLength, info.rate);
+	if (alGetError() != AL_NO_ERROR)
+	{
+		Z_Free(sfx->pSoundData);
+		sfx->iFlags |= SFX_FLAG_UNLOADED;
+		return qfalse;
+	}
+	
+	sfx->Buffer = Buffer;
+#ifdef _GAMECUBE
+	Z_Free(sfx->pSoundData);
+#endif
+	sfx->iFlags |= SFX_FLAG_RESIDENT;
+
+	return qtrue;
+}
+
+/*
+============
+S_InitLoad
+============
+*/
+void S_InitLoad(void) {
+	s_LoadList = new sfx_t*[SND_MAX_LOADS];
+	memset(s_LoadList, 0, SND_MAX_LOADS * sizeof(sfx_t*));
+	s_LoadListSize = 0;
+}
+
+/*
+============
+S_CloseLoad
+============
+*/
+void S_CloseLoad(void) {
+	delete [] s_LoadList;
+}
+
diff --git a/codemp/client/snd_mix.cpp b/codemp/client/snd_mix.cpp
new file mode 100644
index 0000000..19a490e
--- /dev/null
+++ b/codemp/client/snd_mix.cpp
@@ -0,0 +1,470 @@
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+// snd_mix.c -- portable code to mix sounds for snd_dma.c
+
+// leave this as first line for PCH reasons...
+//
+#include "snd_local.h"
+
+portable_samplepair_t paintbuffer[PAINTBUFFER_SIZE];
+int 	*snd_p, snd_linear_count, snd_vol;
+short	*snd_out;
+
+
+
+
+#if !(defined __linux__ && defined __i386__)
+#if	!id386
+
+
+void S_WriteLinearBlastStereo16 (void)
+{
+	int		i;
+	int		val;
+
+	for (i=0 ; i<snd_linear_count ; i+=2)
+	{
+		val = snd_p[i]>>8;
+		if (val > 0x7fff)
+			snd_out[i] = 0x7fff;
+		else if (val < (short)0x8000)
+			snd_out[i] = (short)0x8000;
+		else
+			snd_out[i] = val;
+
+		val = snd_p[i+1]>>8;
+		if (val > 0x7fff)
+			snd_out[i+1] = 0x7fff;
+		else if (val < (short)0x8000)
+			snd_out[i+1] = (short)0x8000;
+		else
+			snd_out[i+1] = val;
+	}
+}
+#else
+unsigned int uiMMXAvailable = 0;	// leave as 32 bit
+__declspec( naked ) void S_WriteLinearBlastStereo16 (void)
+{
+	__asm {
+
+ push edi
+ push ebx
+
+ mov ecx,ds:dword ptr[snd_linear_count]		// snd_linear_count is always even at this point, but not nec. mult of 4
+ mov ebx,ds:dword ptr[snd_p]
+ mov edi,ds:dword ptr[snd_out]
+
+ cmp		[uiMMXAvailable], dword ptr 0 
+ je			NoMMX
+
+// writes 8 items (128 bits) per loop pass...
+//   
+ cmp		ecx,8
+ jb			NoMMX	 
+
+LWLBLoopTop_MMX:
+
+ movq		mm1,[-8+ebx+ecx*4]
+ movq		mm0,[-16+ebx+ecx*4]
+ movq		mm3,[-24+ebx+ecx*4]
+ movq		mm2,[-32+ebx+ecx*4]
+ psrad		mm0,8
+ psrad		mm1,8
+ psrad		mm2,8
+ psrad		mm3,8
+ packssdw	mm0,mm1
+ packssdw	mm2,mm3
+ movq		[-8+edi+ecx*2],mm0
+ movq		[-16+edi+ecx*2],mm2
+ 
+ sub		ecx,8
+ cmp		ecx,8
+ jae		LWLBLoopTop_MMX
+
+ emms
+		
+ // now deal with any remaining count...
+ //
+ jecxz		LExit
+
+NoMMX:  
+ 
+// writes 2 items (32 bits) per loop pass...
+//
+LWLBLoopTop:
+ mov eax,ds:dword ptr[-8+ebx+ecx*4]
+ sar eax,8
+ cmp eax,07FFFh
+ jg LClampHigh
+ cmp eax,0FFFF8000h
+ jnl LClampDone
+ mov eax,0FFFF8000h
+ jmp LClampDone
+LClampHigh:
+ mov eax,07FFFh
+LClampDone:
+ mov edx,ds:dword ptr[-4+ebx+ecx*4]
+ sar edx,8
+ cmp edx,07FFFh
+ jg LClampHigh2
+ cmp edx,0FFFF8000h
+ jnl LClampDone2
+ mov edx,0FFFF8000h
+ jmp LClampDone2
+LClampHigh2:
+ mov edx,07FFFh
+LClampDone2:
+ shl edx,16
+ and eax,0FFFFh
+ or edx,eax
+ mov ds:dword ptr[-4+edi+ecx*2],edx
+
+ sub ecx,2
+ jnz LWLBLoopTop
+
+LExit:
+ pop ebx
+ pop edi
+ ret
+	}
+}
+
+#endif
+#endif
+
+
+void S_TransferStereo16 (unsigned long *pbuf, int endtime)
+{
+	int		lpos;
+	int		ls_paintedtime;
+	
+	snd_p = (int *) paintbuffer;
+	ls_paintedtime = s_paintedtime;
+
+	while (ls_paintedtime < endtime)
+	{
+	// handle recirculating buffer issues
+		lpos = ls_paintedtime & ((dma.samples>>1)-1);
+
+		snd_out = (short *) pbuf + (lpos<<1);
+
+		snd_linear_count = (dma.samples>>1) - lpos;
+		if (ls_paintedtime + snd_linear_count > endtime)
+			snd_linear_count = endtime - ls_paintedtime;
+
+		snd_linear_count <<= 1;
+
+	// write a linear blast of samples
+		S_WriteLinearBlastStereo16 ();
+
+		snd_p += snd_linear_count;
+		ls_paintedtime += (snd_linear_count>>1);
+	}
+}
+
+/*
+===================
+S_TransferPaintBuffer
+
+===================
+*/
+void S_TransferPaintBuffer(int endtime)
+{
+	int 	out_idx;
+	int 	count;
+	int 	out_mask;
+	int 	*p;
+	int 	step;
+	int		val;
+	unsigned long *pbuf;
+
+	pbuf = (unsigned long *)dma.buffer;
+
+
+	if ( s_testsound->integer ) {
+		int		i;
+		int		count;
+
+		// write a fixed sine wave
+		count = (endtime - s_paintedtime);
+		for (i=0 ; i<count ; i++)
+			paintbuffer[i].left = paintbuffer[i].right = (int)(sin((s_paintedtime+i)*0.1)*20000*256);
+	}
+
+
+	if (dma.samplebits == 16 && dma.channels == 2)
+	{	// optimized case
+		S_TransferStereo16 (pbuf, endtime);
+	}
+	else
+	{	// general case
+		p = (int *) paintbuffer;
+		count = (endtime - s_paintedtime) * dma.channels;
+		out_mask = dma.samples - 1; 
+		out_idx = s_paintedtime * dma.channels & out_mask;
+		step = 3 - dma.channels;
+
+		if (dma.samplebits == 16)
+		{
+			short *out = (short *) pbuf;
+			while (count--)
+			{
+				val = *p >> 8;
+				p+= step;
+				if (val > 0x7fff)
+					val = 0x7fff;
+				else if (val < (short)0x8000)
+					val = (short)0x8000;
+				out[out_idx] = (short)val;
+				out_idx = (out_idx + 1) & out_mask;
+			}
+		}
+		else if (dma.samplebits == 8)
+		{
+			unsigned char *out = (unsigned char *) pbuf;
+			while (count--)
+			{
+				val = *p >> 8;
+				p+= step;
+				if (val > 0x7fff)
+					val = 0x7fff;
+				else if (val < (short)0x8000)
+					val = (short)0x8000;
+				out[out_idx] = (short)((val>>8) + 128);
+				out_idx = (out_idx + 1) & out_mask;
+			}
+		}
+	}
+}
+
+
+/*
+===============================================================================
+
+CHANNEL MIXING
+
+===============================================================================
+*/
+static void S_PaintChannelFrom16( channel_t *ch, const sfx_t *sfx, int count, int sampleOffset, int bufferOffset ) 
+{
+	portable_samplepair_t	*pSamplesDest;	
+	int iData;
+
+
+	int iLeftVol	= ch->leftvol  * snd_vol;
+	int iRightVol	= ch->rightvol * snd_vol;
+
+	pSamplesDest	= &paintbuffer[ bufferOffset ];
+	
+	for ( int i=0 ; i<count ; i++ ) 
+	{
+		iData = sfx->pSoundData[ sampleOffset++ ];
+
+		pSamplesDest[i].left  += (iData * iLeftVol )>>8;
+		pSamplesDest[i].right += (iData * iRightVol)>>8;
+	}
+}
+
+
+void S_PaintChannelFromMP3( channel_t *ch, const sfx_t *sc, int count, int sampleOffset, int bufferOffset ) 
+{
+	int data;
+	int leftvol, rightvol;
+	signed short *sfx;
+	int	i;
+	portable_samplepair_t	*samp;
+	static short tempMP3Buffer[PAINTBUFFER_SIZE];
+
+	MP3Stream_GetSamples( ch, sampleOffset, count, tempMP3Buffer, qfalse );	// qfalse = not stereo
+
+	leftvol = ch->leftvol*snd_vol;
+	rightvol = ch->rightvol*snd_vol;
+	sfx = tempMP3Buffer;
+
+	samp = &paintbuffer[ bufferOffset ];
+
+
+	while ( count & 3 ) {
+		data = *sfx;
+		samp->left += (data * leftvol)>>8;
+		samp->right += (data * rightvol)>>8;
+
+		sfx++;
+		samp++;
+		count--;
+	}
+
+	for ( i=0 ; i<count ; i += 4 ) {
+		data = sfx[i];
+		samp[i].left += (data * leftvol)>>8;
+		samp[i].right += (data * rightvol)>>8;
+
+		data = sfx[i+1];
+		samp[i+1].left += (data * leftvol)>>8;
+		samp[i+1].right += (data * rightvol)>>8;
+
+		data = sfx[i+2];
+		samp[i+2].left += (data * leftvol)>>8;
+		samp[i+2].right += (data * rightvol)>>8;
+
+		data = sfx[i+3];
+		samp[i+3].left += (data * leftvol)>>8;
+		samp[i+3].right += (data * rightvol)>>8;
+	}
+}
+
+
+// subroutinised to save code dup (called twice)	-ste
+//
+void ChannelPaint(channel_t *ch, sfx_t *sc, int count, int sampleOffset, int bufferOffset)
+{
+	switch (sc->eSoundCompressionMethod)
+	{
+		case ct_16:		
+			
+			S_PaintChannelFrom16		(ch, sc, count, sampleOffset, bufferOffset);
+			break;
+
+		case ct_MP3:
+
+			S_PaintChannelFromMP3		(ch, sc, count, sampleOffset, bufferOffset);
+			break;
+
+		default:
+
+			assert(0);	// debug aid, ignored in release. FIXME: Should we ERR_DROP here for badness-catch?
+			break;
+	}
+}
+
+
+
+void S_PaintChannels( int endtime ) {
+	int 	i;
+	int 	end;
+	channel_t *ch;
+	sfx_t	*sc;
+	int		ltime, count;
+	int		sampleOffset;
+	int	normal_vol,voice_vol;
+
+	snd_vol = normal_vol = s_volume->value*256;
+	voice_vol  = (int)(s_volumeVoice->value*256);
+
+//Com_Printf ("%i to %i\n", s_paintedtime, endtime);
+	while ( s_paintedtime < endtime ) {
+		// if paintbuffer is smaller than DMA buffer
+		// we may need to fill it multiple times
+		end = endtime;
+		if ( endtime - s_paintedtime > PAINTBUFFER_SIZE ) {
+			end = s_paintedtime + PAINTBUFFER_SIZE;
+		}
+
+		// clear the paint buffer to either music or zeros
+		if ( s_rawend < s_paintedtime ) {
+			if ( s_rawend ) {
+				//Com_DPrintf ("background sound underrun\n");
+			}
+			memset(paintbuffer, 0, (end - s_paintedtime) * sizeof(portable_samplepair_t));
+		} else {
+			// copy from the streaming sound source
+			int		s;
+			int		stop;
+
+			stop = (end < s_rawend) ? end : s_rawend;
+
+			for ( i = s_paintedtime ; i < stop ; i++ ) {
+				s = i&(MAX_RAW_SAMPLES-1);
+				paintbuffer[i-s_paintedtime] = s_rawsamples[s];
+			}
+//		if (i != end)
+//			Com_Printf ("partial stream\n");
+//		else
+//			Com_Printf ("full stream\n");
+			for ( ; i < end ; i++ ) {
+				paintbuffer[i-s_paintedtime].left =
+				paintbuffer[i-s_paintedtime].right = 0;
+			}
+		}
+
+		// paint in the channels.
+		ch = s_channels;
+		for ( i = 0; i < MAX_CHANNELS ; i++, ch++ ) {		
+			if ( !ch->thesfx || (ch->leftvol<0.25 && ch->rightvol<0.25 )) {
+				continue;
+			}
+
+			if ( ch->entchannel == CHAN_VOICE || ch->entchannel == CHAN_VOICE_ATTEN || ch->entchannel == CHAN_VOICE_GLOBAL )
+				snd_vol = voice_vol;
+			else
+				snd_vol = normal_vol;
+
+			ltime = s_paintedtime;
+			sc = ch->thesfx;
+
+			// we might have to make 2 passes if it is
+			//	a looping sound effect and the end of 
+			//	the sameple is hit...
+			//
+			do
+			{
+				if (ch->loopSound) {
+					sampleOffset = ltime % sc->iSoundLengthInSamples;
+				} else {
+					sampleOffset = ltime - ch->startSample;
+				}
+				
+				count = end - ltime;
+				if ( sampleOffset + count > sc->iSoundLengthInSamples ) {
+					count = sc->iSoundLengthInSamples - sampleOffset;
+				}
+
+				if ( count > 0 ) {
+					ChannelPaint(ch, sc, count, sampleOffset, ltime - s_paintedtime);
+					ltime += count;
+				}
+			} while ( ltime < end && ch->loopSound );
+		}
+/* temprem
+		// paint in the looped channels.
+		ch = loop_channels;
+		for ( i = 0; i < numLoopChannels ; i++, ch++ ) {		
+			if ( !ch->thesfx || (!ch->leftvol && !ch->rightvol )) {
+				continue;
+			}
+
+			{
+
+				ltime = s_paintedtime;
+				sc = ch->thesfx;
+
+				if (sc->soundData==NULL || sc->soundLength==0) {
+					continue;
+				}
+				// we might have to make two passes if it
+				// is a looping sound effect and the end of
+				// the sample is hit
+				do {
+					sampleOffset = (ltime % sc->soundLength);
+
+					count = end - ltime;
+					if ( sampleOffset + count > sc->soundLength ) {
+						count = sc->soundLength - sampleOffset;
+					}
+
+					if ( count > 0 ) 
+					{
+						ChannelPaint(ch, sc, count, sampleOffset, ltime - s_paintedtime);
+						ltime += count;
+					}
+
+				} while ( ltime < end);
+			}
+		}
+*/
+		// transfer out according to DMA format
+		S_TransferPaintBuffer( end );
+		s_paintedtime = end;
+	}
+}
diff --git a/codemp/client/snd_mp3.cpp b/codemp/client/snd_mp3.cpp
new file mode 100644
index 0000000..5eb4dbf
--- /dev/null
+++ b/codemp/client/snd_mp3.cpp
@@ -0,0 +1,553 @@
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+// Filename:-	cl_mp3.cpp
+//
+// (The interface module between all the MP3 stuff and the game)
+
+
+#include "client.h"
+#include "snd_mp3.h"					// only included directly by a few snd_xxxx.cpp files plus this one
+#include "../mp3code/mp3struct.h"	// keep this rather awful file secret from the rest of the program
+#include "../mp3code/copyright.h"
+
+// expects data already loaded, filename arg is for error printing only
+//
+// returns success/fail
+//
+sboolean MP3_IsValid( const char *psLocalFilename, void *pvData, int iDataLen, sboolean bStereoDesired /* = qfalse */)
+{
+	char *psError = C_MP3_IsValid(pvData, iDataLen, bStereoDesired);
+
+	if (psError)
+	{
+		Com_Printf(va(S_COLOR_RED"%s(%s)\n",psError, psLocalFilename));
+	}
+
+	return !psError;
+}
+
+
+
+// expects data already loaded, filename arg is for error printing only
+//
+// returns unpacked length, or 0 for errors (which will be printed internally)
+//
+int MP3_GetUnpackedSize( const char *psLocalFilename, void *pvData, int iDataLen, sboolean qbIgnoreID3Tag /* = qfalse */
+						, sboolean bStereoDesired /* = qfalse */
+						)
+{
+	int	iUnpackedSize = 0;	
+
+	// always do this now that we have fast-unpack code for measuring output size... (much safer than relying on tags that may have been edited, or if MP3 has been re-saved with same tag)
+	//
+	if (1)//qbIgnoreID3Tag || !MP3_ReadSpecialTagInfo((byte *)pvData, iDataLen, NULL, &iUnpackedSize))
+	{	
+		char *psError = C_MP3_GetUnpackedSize( pvData, iDataLen, &iUnpackedSize, bStereoDesired);
+
+		if (psError)
+		{
+			Com_Printf(va(S_COLOR_RED"%s\n(File: %s)\n",psError, psLocalFilename));
+			return 0;
+		}
+	}	
+
+	return iUnpackedSize;
+}
+
+
+
+// expects data already loaded, filename arg is for error printing only
+//
+// returns byte count of unpacked data (effectively a success/fail bool)
+//
+int MP3_UnpackRawPCM( const char *psLocalFilename, void *pvData, int iDataLen, byte *pbUnpackBuffer, sboolean bStereoDesired /* = qfalse */)
+{
+	int iUnpackedSize;
+	char *psError = C_MP3_UnpackRawPCM( pvData, iDataLen, &iUnpackedSize, pbUnpackBuffer, bStereoDesired);
+
+	if (psError)
+	{
+		Com_Printf(va(S_COLOR_RED"%s\n(File: %s)\n",psError, psLocalFilename));
+		return 0;
+	}
+
+	return iUnpackedSize;
+}
+
+
+// psLocalFilename is just for error reporting (if any)...
+//
+sboolean MP3Stream_InitPlayingTimeFields( LP_MP3STREAM lpMP3Stream, const char *psLocalFilename, void *pvData, int iDataLen, sboolean bStereoDesired /* = qfalse */)
+{
+	sboolean bRetval = qfalse;
+
+	int iRate, iWidth, iChannels;
+
+	char *psError = C_MP3_GetHeaderData(pvData, iDataLen, &iRate, &iWidth, &iChannels, bStereoDesired );
+	if (psError)
+	{
+		Com_Printf(va(S_COLOR_RED"MP3Stream_InitPlayingTimeFields(): %s\n(File: %s)\n",psError, psLocalFilename));
+	}
+	else
+	{
+		int iUnpackLength = MP3_GetUnpackedSize( psLocalFilename, pvData, iDataLen, qfalse,	// sboolean qbIgnoreID3Tag 
+													bStereoDesired);
+		if (iUnpackLength)
+		{
+			lpMP3Stream->iTimeQuery_UnpackedLength	= iUnpackLength;
+			lpMP3Stream->iTimeQuery_SampleRate		= iRate;
+			lpMP3Stream->iTimeQuery_Channels		= iChannels;
+			lpMP3Stream->iTimeQuery_Width			= iWidth;
+
+			bRetval = qtrue;
+		}
+	}
+
+	return bRetval;
+}
+
+float MP3Stream_GetPlayingTimeInSeconds( LP_MP3STREAM lpMP3Stream )
+{
+	if (lpMP3Stream->iTimeQuery_UnpackedLength)	// fields initialised?
+		return (float)((((double)lpMP3Stream->iTimeQuery_UnpackedLength / (double)lpMP3Stream->iTimeQuery_SampleRate) / (double)lpMP3Stream->iTimeQuery_Channels) / (double)lpMP3Stream->iTimeQuery_Width);
+
+	return 0.0f;
+}
+
+float MP3Stream_GetRemainingTimeInSeconds( LP_MP3STREAM lpMP3Stream )
+{
+	if (lpMP3Stream->iTimeQuery_UnpackedLength)	// fields initialised?
+		return (float)(((((double)(lpMP3Stream->iTimeQuery_UnpackedLength - (lpMP3Stream->iBytesDecodedTotal * (lpMP3Stream->iTimeQuery_SampleRate / dma.speed)))) / (double)lpMP3Stream->iTimeQuery_SampleRate) / (double)lpMP3Stream->iTimeQuery_Channels) / (double)lpMP3Stream->iTimeQuery_Width);
+
+	return 0.0f;
+}
+
+
+
+
+// expects data already loaded, filename arg is for error printing only
+//
+sboolean MP3_FakeUpWAVInfo( const char *psLocalFilename, void *pvData, int iDataLen, int iUnpackedDataLength, 
+						   int &format, int &rate, int &width, int &channels, int &samples, int &dataofs,
+						   sboolean bStereoDesired /* = qfalse */
+						   )
+{
+	// some things can be done instantly...
+	//
+	format = 1;		// 1 for MS format
+	dataofs= 0;		// will be 0 for me (since there's no header in the unpacked data)
+
+	// some things need to be read...  (though the whole stereo flag thing is crap)
+	//
+	char *psError = C_MP3_GetHeaderData(pvData, iDataLen, &rate, &width, &channels, bStereoDesired );
+	if (psError)
+	{
+		Com_Printf(va(S_COLOR_RED"%s\n(File: %s)\n",psError, psLocalFilename));
+	}
+
+	// and some stuff needs calculating...
+	//
+	samples	= iUnpackedDataLength / width;		
+
+	return !psError;
+}
+
+
+
+const char sKEY_MAXVOL[]="#MAXVOL";	// formerly #defines
+const char sKEY_UNCOMP[]="#UNCOMP";	//    "        "
+
+// returns qtrue for success...
+//
+sboolean MP3_ReadSpecialTagInfo(byte *pbLoadedFile, int iLoadedFileLen,
+								id3v1_1** ppTAG /* = NULL */,
+								int *piUncompressedSize /* = NULL */, 
+								float *pfMaxVol /* = NULL */
+								)
+{
+	sboolean qbError = qfalse;
+
+	id3v1_1* pTAG = (id3v1_1*) ((pbLoadedFile+iLoadedFileLen)-sizeof(id3v1_1));	// sizeof = 128	
+
+	if (!strncmp(pTAG->id, "TAG", 3))
+	{
+		// TAG found...
+		//
+		
+		// read MAXVOL key...
+		//
+		if (strncmp(pTAG->comment, sKEY_MAXVOL,	strlen(sKEY_MAXVOL)))
+		{
+			qbError = qtrue;
+		}
+		else
+		{
+			if ( pfMaxVol)
+			{
+				*pfMaxVol = atof(pTAG->comment + strlen(sKEY_MAXVOL));
+			}
+		}
+
+		//
+		// read UNCOMP key...
+		//
+		if (strncmp(pTAG->album, sKEY_UNCOMP, strlen(sKEY_UNCOMP)))
+		{
+			qbError = qtrue;
+		}
+		else
+		{
+			if ( piUncompressedSize)
+			{
+				*piUncompressedSize = atoi(pTAG->album + strlen(sKEY_UNCOMP));
+			}
+		}
+	}
+	else
+	{
+		pTAG = NULL;
+	}
+
+	if (ppTAG)
+	{
+		*ppTAG = pTAG;
+	}
+
+	return (pTAG && !qbError);
+}
+
+
+
+#define FUZZY_AMOUNT (5*1024)	// so it has to be significantly over, not just break even, because of
+								// the xtra CPU time versus memory saving
+
+cvar_t* cv_MP3overhead = NULL;
+void MP3_InitCvars(void)
+{
+	cv_MP3overhead = Cvar_Get("s_mp3overhead", va("%d", sizeof(MP3STREAM) + FUZZY_AMOUNT), CVAR_ARCHIVE );
+}
+
+
+// a file has been loaded in memory, see if we want to keep it as MP3, else as normal WAV...
+//
+// return = qtrue if keeping as MP3
+//
+// (note: the reason I pass in the unpacked size rather than working it out here is simply because I already have it)
+//
+sboolean MP3Stream_InitFromFile( sfx_t* sfx, byte *pbSrcData, int iSrcDatalen, const char *psSrcDataFilename, 
+									int iMP3UnPackedSize, sboolean bStereoDesired /* = qfalse */
+								)
+{
+	// first, make a decision based on size here as to whether or not it's worth it because of MP3 buffer space
+	//	making small files much bigger (and therefore best left as WAV)...
+	//
+	
+	if (cv_MP3overhead &&
+			(
+			//iSrcDatalen + sizeof(MP3STREAM) + FUZZY_AMOUNT < iMP3UnPackedSize
+			iSrcDatalen + cv_MP3overhead->integer < iMP3UnPackedSize
+			)
+		)
+	{
+		// ok, let's keep it as MP3 then...
+		//
+		float fMaxVol = 128;	// seems to be a reasonable typical default for maxvol (for lip synch). Naturally there's no #define I can use instead...
+
+		MP3_ReadSpecialTagInfo(pbSrcData, iSrcDatalen, NULL, NULL, &fMaxVol );	// try and read a read maxvol from MP3 header
+	
+		// fill in some sfx_t fields...
+		//
+//		Q_strncpyz( sfx->name, psSrcDataFilename, sizeof(sfx->name) );					
+		sfx->eSoundCompressionMethod = ct_MP3;
+		sfx->fVolRange = fMaxVol;
+		//sfx->width  = 2;
+		sfx->iSoundLengthInSamples = ((iMP3UnPackedSize / 2/*sfx->width*/) / (44100 / dma.speed)) / (bStereoDesired?2:1);
+		//
+		// alloc mem for data and store it (raw MP3 in this case)...
+		//
+		sfx->pSoundData = (short *) SND_malloc( iSrcDatalen, sfx );
+		memcpy( sfx->pSoundData, pbSrcData, iSrcDatalen );
+		
+		// now init the low-level MP3 stuff...
+		//
+		MP3STREAM SFX_MP3Stream = {0};	// important to init to all zeroes!
+		char *psError = C_MP3Stream_DecodeInit( &SFX_MP3Stream, /*sfx->data*/ /*sfx->soundData*/ pbSrcData, iSrcDatalen,
+												dma.speed,//(s_khz->value == 44)?44100:(s_khz->value == 22)?22050:11025,
+												2/*sfx->width*/ * 8,
+												bStereoDesired
+												);
+		SFX_MP3Stream.pbSourceData = (byte *) sfx->pSoundData;
+		if (psError)
+		{
+			// This should never happen, since any errors or problems with the MP3 file would have stopped us getting
+			//	to this whole function, but just in case...
+			//
+			Com_Printf(va(S_COLOR_YELLOW"File \"%s\": %s\n",psSrcDataFilename,psError));
+
+			// This will leave iSrcDatalen bytes on the hunk stack (since you can't dealloc that), but MP3 files are
+			//	usually small, and like I say, it should never happen.
+			//
+			// Strictly speaking, I should do a Z_Malloc above, then I could do a Z_Free if failed, else do a Hunk_Alloc
+			//	to copy the Z_Malloc data into, then Z_Free, but for something that shouldn't happen it seemed bad to
+			//	penalise the rest of the game with extra alloc demands.
+			//
+			return qfalse;	
+		}
+
+		// success ( ...on a plate).
+		//
+		// make a copy of the filled-in stream struct and attach to the sfx_t struct...
+		//
+				sfx->pMP3StreamHeader = (MP3STREAM *) Z_Malloc( sizeof(MP3STREAM), TAG_SND_MP3STREAMHDR, qfalse );
+		memcpy(	sfx->pMP3StreamHeader, &SFX_MP3Stream,		    sizeof(MP3STREAM) );
+		//
+		return qtrue;
+	}
+
+	return qfalse;
+}
+
+
+
+// decode one packet of MP3 data only (typical output size is 2304, or 2304*2 for stereo, so input size is less
+//
+// return is decoded byte count, else 0 for finished
+//
+int MP3Stream_Decode( LP_MP3STREAM lpMP3Stream, sboolean bDoingMusic )
+{
+	lpMP3Stream->iCopyOffset = 0;
+
+	if (0)//!bDoingMusic)
+	{
+		/*
+		// SOF2: need to make a local buffer up so we can decode the piece we want from a contiguous bitstream rather than
+		//	this linklist junk...
+		//
+		// since MP3 packets are generally 416 or 417 bytes in length it seems reasonable to just find which linked-chunk
+		//	the current read offset lies within then grab the next one as well (since they're 2048 bytes) and make one
+		//	buffer with just the two concat'd together. Shouldn't be much of a processor hit.
+		//
+		sndBuffer *pChunk = (sndBuffer *) lpMP3Stream->pbSourceData;	
+		//
+		// may as well make this static to avoid cut down on stack-validation run-time...
+		//
+		static byte	byRawBuffer[SND_CHUNK_SIZE_BYTE*2];	// *2 for byte->short	// easily enough to decode one frame of MP3 data, most are 416 or 417 bytes
+			
+		// fast-forward to the correct chunk...
+		//		
+		int iBytesToSkipPast = lpMP3Stream->iSourceReadIndex;
+
+		while (iBytesToSkipPast >= SND_CHUNK_SIZE_BYTE) 
+		{
+			pChunk = pChunk->next;			
+			if (!pChunk) 
+			{
+				// err.... reading off the end of the data stream guys...
+				//
+				// pChunk = (sndBuffer *) lpMP3Stream->pbSourceData;	// restart
+				return 0;	// ... 0 bytes decoded, so will just stop caller-decoder all nice and legal as EOS
+			}
+			iBytesToSkipPast -= SND_CHUNK_SIZE_BYTE;
+		}
+
+		{
+			// ok, pChunk is now the 2k or so chunk we're in the middle of...
+			//
+			int iChunk1BytesToCopy = SND_CHUNK_SIZE_BYTE - iBytesToSkipPast;
+			memcpy(byRawBuffer,((byte *)pChunk->sndChunk) + iBytesToSkipPast, iChunk1BytesToCopy);
+			//
+			// concat next chunk on to this as well...
+			//
+			pChunk = pChunk->next;
+			if (pChunk)
+			{
+				memcpy(byRawBuffer + iChunk1BytesToCopy, pChunk->sndChunk,	SND_CHUNK_SIZE_BYTE);
+			}
+			else
+			{
+				memset(byRawBuffer + iChunk1BytesToCopy, 0,					SND_CHUNK_SIZE_BYTE);
+			}
+		}
+
+
+		{
+			// now we need to backup some struct fields, fake 'em, do the lo-level call, then restore 'em...
+			//
+			byte *pbSourceData_Old	= lpMP3Stream->pbSourceData;
+			int iSourceReadIndex_Old= lpMP3Stream->iSourceReadIndex;
+
+			lpMP3Stream->pbSourceData	= &byRawBuffer[0];
+			lpMP3Stream->iSourceReadIndex= 0;	// since this is zero, not the buffer offset within a chunk, we can play tricks further down when restoring
+
+			{
+				unsigned int uiBytesDecoded = C_MP3Stream_Decode( lpMP3Stream, qfalse );
+
+				lpMP3Stream->iSourceReadIndex += iSourceReadIndex_Old;	// note '+=' rather than '=', to take account of movement.
+				lpMP3Stream->pbSourceData	   = pbSourceData_Old;
+
+				return uiBytesDecoded;
+			}
+		}
+		*/
+	}
+	else
+	{
+		// SOF2 music, or EF1 anything...
+		//
+		return C_MP3Stream_Decode( lpMP3Stream, qfalse );	// bFastForwarding
+	}
+}
+
+
+sboolean MP3Stream_SeekTo( channel_t *ch, float fTimeToSeekTo )
+{		
+	const float fEpsilon = 0.05f;	// accurate to 1/50 of a second, but plus or minus this gives 1/10 of second
+
+	MP3Stream_Rewind( ch );
+	//
+	// sanity... :-)
+	//
+	const float fTrackLengthInSeconds = MP3Stream_GetPlayingTimeInSeconds( &ch->MP3StreamHeader );
+	if (fTimeToSeekTo > fTrackLengthInSeconds)
+	{
+		fTimeToSeekTo = fTrackLengthInSeconds;
+	}
+
+	// now do the seek...
+	//
+	while (1)
+	{
+		float fPlayingTimeElapsed = MP3Stream_GetPlayingTimeInSeconds( &ch->MP3StreamHeader ) - MP3Stream_GetRemainingTimeInSeconds( &ch->MP3StreamHeader );
+		float fAbsTimeDiff = fabs(fTimeToSeekTo - fPlayingTimeElapsed);
+
+		if ( fAbsTimeDiff <= fEpsilon)
+			return qtrue;
+
+		// when decoding, use fast-forward until within 3 seconds, then slow-decode (which should init stuff properly?)...
+		//
+		int iBytesDecodedThisPacket = C_MP3Stream_Decode( &ch->MP3StreamHeader, (fAbsTimeDiff > 3.0f) );	// bFastForwarding
+		if (iBytesDecodedThisPacket == 0)
+			break;	// EOS		
+	}
+
+	return qfalse;
+}
+							   
+
+// returns qtrue for all ok
+//
+sboolean MP3Stream_Rewind( channel_t *ch )
+{		
+	ch->iMP3SlidingDecodeWritePos = 0;
+	ch->iMP3SlidingDecodeWindowPos= 0;
+
+/*
+	char *psError = C_MP3Stream_Rewind( &ch->MP3StreamHeader );
+
+	if (psError)
+	{
+		Com_Printf(S_COLOR_YELLOW"%s\n",psError);
+		return qfalse;
+	}
+
+	return qtrue;
+*/
+
+	// speed opt, since I know I already have the right data setup here...
+	//
+	memcpy(&ch->MP3StreamHeader, ch->thesfx->pMP3StreamHeader, sizeof(ch->MP3StreamHeader));
+	return qtrue;
+
+}
+
+
+// returns qtrue while still playing normally, else qfalse for either finished or request-offset-error
+//
+sboolean MP3Stream_GetSamples( channel_t *ch, int startingSampleNum, int count, short *buf, sboolean bStereo )
+{
+	sboolean qbStreamStillGoing = qtrue;
+
+	const int iQuarterOfSlidingBuffer		=  sizeof(ch->MP3SlidingDecodeBuffer)/4;
+	const int iThreeQuartersOfSlidingBuffer	= (sizeof(ch->MP3SlidingDecodeBuffer)*3)/4;
+
+//	Com_Printf("startingSampleNum %d\n",startingSampleNum);
+
+	count *= 2/* <- = SOF2; ch->sfx->width*/;	// count arg was for words, so double it for bytes;
+
+	// convert sample number into a byte offset... (make new variable for clarity?)
+	//
+	startingSampleNum *= 2 /* <- = SOF2; ch->sfx->width*/ * (bStereo?2:1);
+
+	if ( startingSampleNum < ch->iMP3SlidingDecodeWindowPos)
+	{
+		// what?!?!?!   smegging time travel needed or something?, forget it
+		memset(buf,0,count);
+		return qfalse;
+	}
+
+//	OutputDebugString(va("\nRequest: startingSampleNum %d, count %d\n",startingSampleNum,count));
+//	OutputDebugString(va("WindowPos %d, WindowWritePos %d\n",ch->iMP3SlidingDecodeWindowPos,ch->iMP3SlidingDecodeWritePos));
+
+//	sboolean _bDecoded = qfalse;
+
+	while (!
+		(
+			(startingSampleNum			>= ch->iMP3SlidingDecodeWindowPos)
+			&&
+			(startingSampleNum + count	<  ch->iMP3SlidingDecodeWindowPos + ch->iMP3SlidingDecodeWritePos)
+			)
+			)
+	{
+//		if (!_bDecoded)
+//		{
+//			Com_Printf(S_COLOR_YELLOW"Decode needed!\n");
+//		}
+//		_bDecoded = qtrue;
+//		OutputDebugString("Scrolling...");
+
+		int _iBytesDecoded = MP3Stream_Decode( (LP_MP3STREAM) &ch->MP3StreamHeader, bStereo );	// stereo only for music, so this is safe
+//		OutputDebugString(va("%d bytes decoded\n",_iBytesDecoded));
+		if (_iBytesDecoded == 0)
+		{
+			// no more source data left so clear the remainder of the buffer...
+			//
+			memset(ch->MP3SlidingDecodeBuffer + ch->iMP3SlidingDecodeWritePos, 0, sizeof(ch->MP3SlidingDecodeBuffer)-ch->iMP3SlidingDecodeWritePos);
+//			OutputDebugString("Finished\n");
+			qbStreamStillGoing = qfalse;
+			break;
+		}
+		else
+		{
+			memcpy(ch->MP3SlidingDecodeBuffer + ch->iMP3SlidingDecodeWritePos,ch->MP3StreamHeader.bDecodeBuffer,_iBytesDecoded);
+
+			ch->iMP3SlidingDecodeWritePos += _iBytesDecoded;
+
+			// if reached 3/4 of buffer pos, backscroll the decode window by one quarter...
+			//
+			if (ch->iMP3SlidingDecodeWritePos > iThreeQuartersOfSlidingBuffer)
+			{
+				memmove(ch->MP3SlidingDecodeBuffer, ((byte *)ch->MP3SlidingDecodeBuffer + iQuarterOfSlidingBuffer), iThreeQuartersOfSlidingBuffer);
+				ch->iMP3SlidingDecodeWritePos -= iQuarterOfSlidingBuffer;
+				ch->iMP3SlidingDecodeWindowPos+= iQuarterOfSlidingBuffer;
+			}
+		}
+//		OutputDebugString(va("WindowPos %d, WindowWritePos %d\n",ch->iMP3SlidingDecodeWindowPos,ch->iMP3SlidingDecodeWritePos));
+	}
+
+//	if (!_bDecoded)
+//	{
+//		Com_Printf(S_COLOR_YELLOW"No decode needed\n");
+//	}
+
+	assert(startingSampleNum >= ch->iMP3SlidingDecodeWindowPos);
+	memcpy( buf, ch->MP3SlidingDecodeBuffer + (startingSampleNum-ch->iMP3SlidingDecodeWindowPos), count);	
+
+//	OutputDebugString("OK\n\n");
+
+	return qbStreamStillGoing;
+}
+
+
+///////////// eof /////////////
+
diff --git a/codemp/client/snd_mp3.h b/codemp/client/snd_mp3.h
new file mode 100644
index 0000000..cdecf50
--- /dev/null
+++ b/codemp/client/snd_mp3.h
@@ -0,0 +1,87 @@
+// Filename:-	cl_mp3.h
+//
+// (Interface to the rest of the game for the MP3 functions)
+//
+#ifndef CL_MP3_H
+#define CL_MP3_H
+
+
+#ifndef sfx_t
+#include "snd_local.h"
+#endif
+
+
+
+typedef struct id3v1_1 {
+    char id[3];
+    char title[30];		// <file basename>
+    char artist[30];	// "Raven Software"
+    char album[30];		// "#UNCOMP %d"		// needed
+    char year[4];		// "2000"
+    char comment[28];	// "#MAXVOL %g"		// needed
+    char zero;
+    char track;
+    char genre;
+} id3v1_1;	// 128 bytes in size
+
+
+extern const char sKEY_MAXVOL[];
+extern const char sKEY_UNCOMP[];
+
+
+// (so far, all these functions are only called from one place in snd_mem.cpp)
+//
+// (filenames are used purely for error reporting, all files should already be loaded before you get here)
+//
+void		MP3_InitCvars			( void );
+sboolean	MP3_IsValid				( const char *psLocalFilename, void *pvData, int iDataLen, sboolean bStereoDesired = qfalse );
+int			MP3_GetUnpackedSize		( const char *psLocalFilename, void *pvData, int iDataLen, sboolean qbIgnoreID3Tag = qfalse, sboolean bStereoDesired = qfalse );
+sboolean	MP3_UnpackRawPCM		( const char *psLocalFilename, void *pvData, int iDataLen, byte *pbUnpackBuffer, sboolean bStereoDesired = qfalse );
+sboolean	MP3Stream_InitPlayingTimeFields( LP_MP3STREAM lpMP3Stream, const char *psLocalFilename, void *pvData, int iDataLen, sboolean bStereoDesired = qfalse);
+float		MP3Stream_GetPlayingTimeInSeconds( LP_MP3STREAM lpMP3Stream );
+float		MP3Stream_GetRemainingTimeInSeconds( LP_MP3STREAM lpMP3Stream );
+sboolean	MP3_FakeUpWAVInfo		( const char *psLocalFilename, void *pvData, int iDataLen, int iUnpackedDataLength, int &format, int &rate, int &width, int &channels, int &samples, int &dataofs, sboolean bStereoDesired = qfalse );
+sboolean	MP3_ReadSpecialTagInfo	( byte *pbLoadedFile, int iLoadedFileLen,
+										id3v1_1** ppTAG = NULL, int *piUncompressedSize = NULL, float *pfMaxVol = NULL);
+sboolean	MP3Stream_InitFromFile	( sfx_t* sfx, byte *pbSrcData, int iSrcDatalen, const char *psSrcDataFilename, int iMP3UnPackedSize, sboolean bStereoDesired = qfalse );
+int			MP3Stream_Decode		( LP_MP3STREAM lpMP3Stream,  sboolean bDoingMusic );
+sboolean	MP3Stream_SeekTo		( channel_t *ch, float fTimeToSeekTo );
+sboolean	MP3Stream_Rewind		( channel_t *ch );
+sboolean	MP3Stream_GetSamples	( channel_t *ch, int startingSampleNum, int count, short *buf, sboolean bStereo );
+
+
+
+
+
+///////////////////////////////////////
+//
+// the real worker code deep down in the MP3 C code...  (now externalised here so the music streamer can access one)
+//
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+
+char*	C_MP3_IsValid			(void *pvData, int iDataLen, int bStereoDesired);
+char*	C_MP3_GetUnpackedSize	(void *pvData, int iDataLen, int *piUnpackedSize, int bStereoDesired);
+char*	C_MP3_UnpackRawPCM		(void *pvData, int iDataLen, int *piUnpackedSize, void *pbUnpackBuffer, int bStereoDesired);
+char*	C_MP3_GetHeaderData		(void *pvData, int iDataLen, int *piRate, int *piWidth, int *piChannels, int bStereoDesired);
+char*	C_MP3Stream_DecodeInit	(LP_MP3STREAM pSFX_MP3Stream, void *pvSourceData, int iSourceBytesRemaining,
+								int iGameAudioSampleRate, int iGameAudioSampleBits, int bStereoDesired);
+unsigned int C_MP3Stream_Decode( LP_MP3STREAM pSFX_MP3Stream, int bFastForwarding );
+char*	C_MP3Stream_Rewind		(LP_MP3STREAM pSFX_MP3Stream);
+
+
+#ifdef __cplusplus
+}
+#endif
+//
+///////////////////////////////////////
+
+
+
+#endif	// #ifndef CL_MP3_H
+
+///////////////// eof /////////////////////
+
diff --git a/codemp/client/snd_music.cpp b/codemp/client/snd_music.cpp
new file mode 100644
index 0000000..27a9f1b
--- /dev/null
+++ b/codemp/client/snd_music.cpp
@@ -0,0 +1,1153 @@
+// Filename:-	snd_music.cpp
+//
+//  Stuff to parse in special x-fade music format and handle blending etc
+
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+
+#include "../game/q_shared.h"
+#include "../qcommon/sstring.h"
+
+#pragma warning ( disable : 4663 )	//spcialize class
+#pragma warning( push, 3 )
+#include <algorithm>
+#pragma warning (pop)
+
+#ifdef _XBOX
+#include "snd_local_console.h"
+#include <xtl.h>
+#else
+#include "snd_local.h"
+//#include "snd_mp3.h"
+#endif
+
+//
+#include "snd_music.h"
+#include "snd_ambient.h"
+
+#include "../qcommon/GenericParser2.h"
+
+extern sboolean S_FileExists( const char *psFilename );
+
+#ifdef _XBOX
+extern void Z_SetNewDeleteTemporary(bool bTemp);
+#endif
+
+#define sKEY_MUSICFILES	"musicfiles"
+#define sKEY_ENTRY		"entry"
+#define sKEY_EXIT		"exit"
+#define sKEY_MARKER		"marker"
+#define sKEY_TIME		"time"
+#define sKEY_NEXTFILE	"nextfile"
+#define sKEY_NEXTMARK	"nextmark"
+#define sKEY_LEVELMUSIC	"levelmusic"
+#define sKEY_EXPLORE	"explore"
+#define sKEY_ACTION		"action"
+#define sKEY_BOSS		"boss"
+#define sKEY_DEATH		"death"
+#define sKEY_USES		"uses"
+#define sKEY_USEBOSS	"useboss"
+
+#define sKEY_PLACEHOLDER "placeholder"	// ignore these
+
+#define sFILENAME_DMS	"ext_data/dms.dat"
+
+
+#define MUSIC_PARSE_ERROR(_string)		Music_Parse_Error(_string)	// only use during parse, not run-time use, and bear in mid that data is zapped after error message, so exit any loops immediately
+#define MUSIC_PARSE_WARNING(_string)	Music_Parse_Warning(_string)
+
+typedef struct
+{
+	sstring_t	sNextFile;
+	sstring_t	sNextMark;		// blank if used for an explore piece, name of marker point to enter new file at
+
+} MusicExitPoint_t;
+
+struct MusicExitTime_t	// need to declare this way for operator < below
+{
+	float		fTime;
+	int			iExitPoint;
+
+	// I'm defining this '<' operator so STL's sort algorithm will work
+	//
+	bool operator < (const MusicExitTime_t& _X) const {return (fTime < _X.fTime);}
+};
+
+// it's possible for all 3 of these to be empty if it's boss or death music
+//
+typedef vector	<MusicExitPoint_t>	MusicExitPoints_t;
+typedef vector	<MusicExitTime_t>	MusicExitTimes_t;
+typedef map		<sstring_t, float>	MusicEntryTimes_t;	// key eg "marker1"
+
+typedef struct
+{
+	sstring_t			sFileNameBase;
+	MusicEntryTimes_t	MusicEntryTimes;
+	MusicExitPoints_t	MusicExitPoints;
+	MusicExitTimes_t	MusicExitTimes;
+
+} MusicFile_t;
+
+typedef map <sstring_t, MusicFile_t>	MusicData_t;			// string is "explore", "action", "boss" etc
+										MusicData_t* MusicData = NULL;
+// there are now 2 of these, because of the new "uses" keyword...
+//
+sstring_t	gsLevelNameForLoad;		// eg "kejim_base", formed from literal BSP name, but also used as dir name for music paths
+sstring_t	gsLevelNameForCompare;	// eg "kejim_base", formed from literal BSP name, but also used as dir name for music paths
+sstring_t	gsLevelNameForBossLoad;	// eg "kejim_base', special case for enabling boss music to come from a different dir - sigh....
+
+void Music_Free(void)
+{
+	delete MusicData;
+	MusicData = NULL;
+}
+
+// some sort of error in the music data...
+//
+static void Music_Parse_Error(LPCSTR psError)
+{
+#ifdef FINAL_BUILD
+	extern cvar_t *s_debugdynamic;
+	if (s_debugdynamic && s_debugdynamic->integer)
+	{
+#endif
+		Com_Printf(S_COLOR_RED "Error parsing music data ( in \"%s\" ):\n%s\n",sFILENAME_DMS,psError);
+#ifdef FINAL_BUILD
+	}	
+#endif
+	MusicData->clear();
+}
+
+// something to just mention if interested...
+//
+static void Music_Parse_Warning(LPCSTR psError)
+{
+#ifdef FINAL_BUILD
+	extern cvar_t *s_debugdynamic;
+	if (s_debugdynamic && s_debugdynamic->integer)
+	{
+#endif
+		Com_Printf(S_COLOR_YELLOW "%s", psError);
+#ifdef FINAL_BUILD
+	}	
+#endif
+}
+
+// the 2nd param here is pretty kludgy (sigh), and only used for testing for the "boss" type.
+// Unfortunately two of the places that calls this doesn't have much other access to the state other than
+//	a string, not an enum, so for those cases they only pass in BOSS or EXPLORE, so don't rely on it totally.
+//
+static LPCSTR Music_BuildFileName(LPCSTR psFileNameBase, MusicState_e eMusicState )
+{
+	static sstring_t sFileName;
+
+	//HACK!
+	if (eMusicState == eBGRNDTRACK_DEATH)
+	{
+		return "music/death_music.mp3";
+	}
+
+	LPCSTR psDirName = (eMusicState == eBGRNDTRACK_BOSS) ? gsLevelNameForBossLoad.c_str() : gsLevelNameForLoad.c_str();	
+
+	sFileName = va("music/%s/%s.mp3",psDirName,psFileNameBase);
+	return sFileName.c_str();
+}
+
+// this MUST return NULL for non-base states unless doing debug-query
+const char *Music_BaseStateToString( MusicState_e eMusicState, sboolean bDebugPrintQuery /* = qfalse */ )
+{
+	switch (eMusicState)
+	{
+		case eBGRNDTRACK_EXPLORE:	return "explore";
+		case eBGRNDTRACK_ACTION:	return "action";
+		case eBGRNDTRACK_BOSS:		return "boss";
+		case eBGRNDTRACK_SILENCE:	return "silence";	// not used in this module, but snd_dma uses it now it's de-static'd
+		case eBGRNDTRACK_DEATH:		return "death";
+
+		// info only, not map<> lookup keys (unlike above)...
+		//
+		case eBGRNDTRACK_ACTIONTRANS0:		if (bDebugPrintQuery) return "action_tr0";
+		case eBGRNDTRACK_ACTIONTRANS1:		if (bDebugPrintQuery) return "action_tr1";
+		case eBGRNDTRACK_ACTIONTRANS2:		if (bDebugPrintQuery) return "action_tr2";
+		case eBGRNDTRACK_ACTIONTRANS3:		if (bDebugPrintQuery) return "action_tr3";
+		case eBGRNDTRACK_EXPLORETRANS0:		if (bDebugPrintQuery) return "explore_tr0";
+		case eBGRNDTRACK_EXPLORETRANS1:		if (bDebugPrintQuery) return "explore_tr1";
+		case eBGRNDTRACK_EXPLORETRANS2:		if (bDebugPrintQuery) return "explore_tr2";
+		case eBGRNDTRACK_EXPLORETRANS3:		if (bDebugPrintQuery) return "explore_tr3";
+		case eBGRNDTRACK_FADE:				if (bDebugPrintQuery) return "fade";
+	}
+
+	return NULL;
+}
+
+static sboolean Music_ParseMusic(CGenericParser2 &Parser, MusicData_t *MusicData, CGPGroup *pgMusicFiles, LPCSTR psMusicName, LPCSTR psMusicNameKey, MusicState_e eMusicState)
+{
+	sboolean bReturn = qfalse;
+
+#ifdef _XBOX
+	Z_SetNewDeleteTemporary(true);
+#endif
+	MusicFile_t MusicFile;
+#ifdef _XBOX
+	Z_SetNewDeleteTemporary(false);
+#endif
+
+	CGPGroup *pgMusicFile = pgMusicFiles->FindSubGroup(psMusicName);
+	if (pgMusicFile)
+	{
+		// read subgroups...  
+		//
+		sboolean bEntryFound = qfalse;
+		sboolean bExitFound  = qfalse;
+		//
+		// (read entry points first, so I can check exit points aren't too close in time)
+		//
+		CGPGroup *pEntryGroup = pgMusicFile->FindSubGroup(sKEY_ENTRY);
+		if (pEntryGroup)
+		{
+			// read entry points...
+			//
+			for (CGPValue *pValue = pEntryGroup->GetPairs(); pValue; pValue = pValue->GetNext())
+			{
+				LPCSTR psKey	= pValue->GetName();
+				LPCSTR psValue	= pValue->GetTopValue();
+
+				//if (!strncmp(psKey,sKEY_MARKER,strlen(sKEY_MARKER)))	// for now, assume anything is a marker
+				{
+					MusicFile.MusicEntryTimes[psKey] = atof(psValue);
+					bEntryFound = qtrue;						// harmless to keep setting
+				}
+			}
+		}
+
+		for (CGPGroup *pGroup = pgMusicFile->GetSubGroups(); pGroup; pGroup = pGroup->GetNext())
+		{
+			LPCSTR psGroupName = pGroup->GetName();
+
+			if (!strcmp(psGroupName,sKEY_ENTRY))
+			{
+				// skip entry points, I've already read them in above
+				//
+			}
+			else
+			if (!strcmp(psGroupName,sKEY_EXIT))
+			{
+				int iThisExitPointIndex = MusicFile.MusicExitPoints.size();	// must eval this first, so unaffected by push_back etc
+				//
+				// read this set of exit points...
+				//
+				MusicExitPoint_t MusicExitPoint;
+				for (CGPValue *pValue = pGroup->GetPairs(); pValue; pValue = pValue->GetNext())
+				{
+					LPCSTR psKey	= pValue->GetName();
+					LPCSTR psValue	= pValue->GetTopValue();
+
+					if (!strcmp(psKey,sKEY_NEXTFILE))
+					{
+						MusicExitPoint.sNextFile = psValue;
+						bExitFound  = qtrue;	// harmless to keep setting
+					}
+					else
+					if (!strcmp(psKey,sKEY_NEXTMARK))
+					{
+						MusicExitPoint.sNextMark = psValue;
+					}
+					else
+					if (!strncmp(psKey,sKEY_TIME,strlen(sKEY_TIME)))
+					{
+						MusicExitTime_t MusicExitTime;
+										MusicExitTime.fTime		= atof(psValue);
+										MusicExitTime.iExitPoint= iThisExitPointIndex;
+
+						// new check, don't keep this this exit point if it's within 1.5 seconds either way of an entry point...
+						//
+						sboolean bTooCloseToEntryPoint = qfalse;
+						for (MusicEntryTimes_t::iterator itEntryTimes = MusicFile.MusicEntryTimes.begin(); itEntryTimes != MusicFile.MusicEntryTimes.end(); ++itEntryTimes)
+						{
+							float fThisEntryTime = (*itEntryTimes).second;
+
+							if (Q_fabs(fThisEntryTime - MusicExitTime.fTime) < 1.5f)
+							{
+//								bTooCloseToEntryPoint = qtrue;	// not sure about this, ignore for now
+								break;
+							}
+						}
+						if (!bTooCloseToEntryPoint)
+						{
+#ifdef _XBOX
+							Z_SetNewDeleteTemporary(true);
+#endif
+							MusicFile.MusicExitTimes.push_back(MusicExitTime);
+#ifdef _XBOX
+							Z_SetNewDeleteTemporary(false);
+#endif
+						}
+					}
+				}
+
+#ifdef _XBOX
+				Z_SetNewDeleteTemporary(true);
+#endif
+				MusicFile.MusicExitPoints.push_back(MusicExitPoint);
+#ifdef _XBOX
+				Z_SetNewDeleteTemporary(false);
+#endif
+				int iNumExitPoints = MusicFile.MusicExitPoints.size();
+
+				// error checking...
+				//
+				switch (eMusicState)
+				{
+					case eBGRNDTRACK_EXPLORE:	
+						if (iNumExitPoints > iMAX_EXPLORE_TRANSITIONS)
+						{
+							MUSIC_PARSE_ERROR( va("\"%s\" has > %d %s transitions defined!\n",psMusicName,iMAX_EXPLORE_TRANSITIONS,psMusicNameKey) );
+							return qfalse;
+						}
+						break;
+
+					case eBGRNDTRACK_ACTION:
+						if (iNumExitPoints > iMAX_ACTION_TRANSITIONS)
+						{
+							MUSIC_PARSE_ERROR( va("\"%s\" has > %d %s transitions defined!\n",psMusicName,iMAX_ACTION_TRANSITIONS,psMusicNameKey) );
+							return qfalse;
+						}
+						break;
+
+					case eBGRNDTRACK_BOSS:
+					case eBGRNDTRACK_DEATH:
+
+						MUSIC_PARSE_ERROR( va("\"%s\" has %s transitions defined, this is not allowed!\n",psMusicName,psMusicNameKey) );
+						break;					
+				}
+			}
+		}
+
+		// for now, assume everything was ok unless some obvious things are missing...
+		//
+		bReturn = qtrue;
+
+		if (eMusicState != eBGRNDTRACK_BOSS && eMusicState != eBGRNDTRACK_DEATH)	// boss & death pieces can omit entry/exit stuff
+		{
+			if (!bEntryFound)
+			{
+				MUSIC_PARSE_ERROR(va("Unable to find subgroup \"%s\" in group \"%s\"\n",sKEY_ENTRY,psMusicName));
+				bReturn = qfalse;
+			}
+			if (!bExitFound)
+			{
+				MUSIC_PARSE_ERROR(va("Unable to find subgroup \"%s\" in group \"%s\"\n",sKEY_EXIT,psMusicName));
+				bReturn = qfalse;
+			}
+		}
+	}
+	else
+	{
+		MUSIC_PARSE_ERROR(va("Unable to find musicfiles entry \"%s\"\n",psMusicName));
+	}
+
+	if (bReturn)
+	{
+		MusicFile.sFileNameBase  = psMusicName; 
+		(*MusicData)[ psMusicNameKey ] = MusicFile;
+	}
+
+	return bReturn;
+}
+
+
+
+
+// I only need this because GP2 can't cope with trailing whitespace (for !@#$%^'s sake!!!!)...
+//
+// (output buffer will always be just '\n' seperated, regardless of possible "\r\n" pairs)
+//
+// (remember to Z_Free() the returned char * when done with it!!!)
+//
+static char *StripTrailingWhiteSpaceOnEveryLine(char *pText)
+{
+#ifdef _XBOX
+	Z_SetNewDeleteTemporary(true);
+#endif
+	string strNewText;
+
+	while (*pText)
+	{
+		char sOneLine[1024];	// BTO: was 16k
+
+		// find end of line...
+		//				
+		char *pThisLineEnd = pText;
+		while (*pThisLineEnd && *pThisLineEnd != '\r' && ((pThisLineEnd-pText) < sizeof(sOneLine)-1))
+		{
+			pThisLineEnd++;
+		}	
+
+		int iCharsToCopy = pThisLineEnd - pText;
+		strncpy(sOneLine, pText, iCharsToCopy);
+				sOneLine[iCharsToCopy]='\0';
+		pText += iCharsToCopy;
+		while (*pText == '\n' || *pText == '\r') pText++;
+
+		// trim trailing...
+		//
+		sboolean bTrimmed = qfalse;
+		do
+		{
+			bTrimmed = qfalse;
+			int iStrLen = strlen(sOneLine);
+
+			if (iStrLen)
+			{
+				if (sOneLine[iStrLen-1] == '\t' || sOneLine[iStrLen-1] == ' ')
+				{
+					sOneLine[iStrLen-1] = '\0';
+					bTrimmed = qtrue;
+				}
+			}
+		}
+		while (bTrimmed);
+		
+		strNewText += sOneLine;
+		strNewText += "\n";
+	}
+
+	char  *pNewText = (char *) Z_Malloc( strlen(strNewText.c_str())+1, TAG_TEMP_WORKSPACE, qfalse);
+	strcpy(pNewText, strNewText.c_str());
+#ifdef _XBOX
+	Z_SetNewDeleteTemporary(false);
+#endif
+	return pNewText;
+}
+
+
+// called from SV_SpawnServer, but before map load and music start etc.
+//
+// This just initialises the Lucas music structs so the background music player can interrogate them...
+//
+sstring_t gsLevelNameFromServer;
+void Music_SetLevelName(const char *psLevelName)
+{	
+	gsLevelNameFromServer = psLevelName;	
+}
+
+static sboolean Music_ParseLeveldata(const char *psLevelName)
+{
+	sboolean bReturn = qfalse;
+
+	if (MusicData == NULL)
+	{
+		MusicData = new MusicData_t;
+	}
+	
+		// already got this data?
+	//
+	if (MusicData->size() && !Q_stricmp(psLevelName,gsLevelNameForCompare.c_str()))
+	{
+		return qtrue;
+	}
+	
+	MusicData->clear();	
+
+	char sLevelName[MAX_QPATH];
+	Q_strncpyz(sLevelName,psLevelName,sizeof(sLevelName));
+	
+	gsLevelNameForLoad		= sLevelName;	// harmless to init here even if we fail to parse dms.dat file	
+	gsLevelNameForCompare	= sLevelName;	// harmless to init here even if we fail to parse dms.dat file	
+	gsLevelNameForBossLoad	= sLevelName;	// harmless to init here even if we fail to parse dms.dat file	
+
+	char *pText = NULL;
+	/*int iTotalBytesLoaded = */FS_ReadFile(sFILENAME_DMS, (void **)&pText );			
+	if (pText) 
+	{
+		char *psStrippedText = StripTrailingWhiteSpaceOnEveryLine(pText);		
+		CGenericParser2 Parser;
+		char *psDataPtr = psStrippedText;	// because ptr gets advanced, so we supply a clone that GP can alter
+		if (Parser.Parse(&psDataPtr, true))
+		{
+			CGPGroup *pFileGroup = Parser.GetBaseParseGroup();
+			if (pFileGroup)
+			{
+				CGPGroup *pgMusicFiles = pFileGroup->FindSubGroup(sKEY_MUSICFILES);
+				if (pgMusicFiles)
+				{
+					CGPGroup *pgLevelMusic = pFileGroup->FindSubGroup(sKEY_LEVELMUSIC);
+
+					if (pgLevelMusic)
+					{
+						CGPGroup *pgThisLevelMusic = NULL;
+						//
+						// check for new USE keyword...
+						//
+						int iSanityLimit = 0;
+						sstring_t sSearchName(sLevelName);
+
+						while (sSearchName.c_str()[0] && iSanityLimit < 10)
+						{
+							gsLevelNameForLoad		= sSearchName;
+							gsLevelNameForBossLoad	= sSearchName;
+							pgThisLevelMusic = pgLevelMusic->FindSubGroup(sSearchName.c_str());
+
+							if (pgThisLevelMusic)
+							{
+								CGPValue *pValue = pgThisLevelMusic->FindPair(sKEY_USES);
+								if (pValue)
+								{
+									// re-search using the USE param...
+									//									
+									sSearchName = pValue->GetTopValue();
+									iSanityLimit++;
+//									Com_DPrintf("Using \"%s\"\n",sSearchName.c_str());
+								}
+								else
+								{
+									// no new USE keyword found...
+									//
+									sSearchName = "";
+								}
+							}
+							else
+							{
+								// level entry not found...
+								//
+								break;
+							}
+						}
+
+						// now go ahead and use the final music set we've decided on...
+						//
+						if (pgThisLevelMusic && iSanityLimit < 10)
+						{
+							// these are optional fields, so see which ones we find...
+							//
+							LPCSTR psName_Explore = NULL;
+							LPCSTR psName_Action  = NULL;
+							LPCSTR psName_Boss	  = NULL;
+							LPCSTR psName_Death	  = NULL;
+							//
+							LPCSTR psName_UseBoss = NULL;
+
+							for (CGPValue *pValue = pgThisLevelMusic->GetPairs(); pValue; pValue = pValue->GetNext())
+							{
+								LPCSTR psKey	= pValue->GetName();
+								LPCSTR psValue	= pValue->GetTopValue();								
+
+								if (Q_stricmp(psValue,sKEY_PLACEHOLDER))	// ignore "placeholder" items
+								{
+									if (!Q_stricmp(psKey,sKEY_EXPLORE))
+									{
+										psName_Explore = psValue;
+									}
+									else
+									if (!Q_stricmp(psKey,sKEY_ACTION))
+									{
+										psName_Action  = psValue;
+									}
+									else
+									if (!Q_stricmp(psKey,sKEY_USEBOSS))
+									{
+										psName_UseBoss = psValue;
+									}
+									else
+									if (!Q_stricmp(psKey,sKEY_BOSS))
+									{
+										psName_Boss = psValue;
+									}
+									else
+									if (!Q_stricmp(psKey,sKEY_DEATH))
+									{
+										psName_Death = psValue;
+									}
+								}
+							}
+									
+							bReturn = qtrue;	// defualt to ON now, so I can turn it off if "useboss" fails
+
+							if (psName_UseBoss)
+							{
+								CGPGroup *pgLevelMusicOfBoss = pgLevelMusic->FindSubGroup(psName_UseBoss);
+								if (pgLevelMusicOfBoss)
+								{
+									CGPValue *pValueBoss = pgLevelMusicOfBoss->FindPair(sKEY_BOSS);
+									if (pValueBoss)
+									{	
+										psName_Boss = pValueBoss->GetTopValue();
+										gsLevelNameForBossLoad = psName_UseBoss;
+									}
+									else
+									{
+										MUSIC_PARSE_ERROR(va("'useboss' \"%s\" has no \"boss\" entry!\n",psName_UseBoss));
+										bReturn = qfalse;
+									}
+								}
+								else
+								{
+									MUSIC_PARSE_ERROR(va("Unable to find 'useboss' entry \"%s\"\n",psName_UseBoss));									
+									bReturn = qfalse;
+								}
+							}
+
+
+							// done this way in case I want to conditionally pass any bools depending on music type...
+							//
+							if (bReturn && psName_Explore)
+							{
+								bReturn = Music_ParseMusic(Parser, MusicData, pgMusicFiles, psName_Explore,	sKEY_EXPLORE, eBGRNDTRACK_EXPLORE);
+							}
+							if (bReturn && psName_Action)
+							{
+								bReturn = Music_ParseMusic(Parser, MusicData, pgMusicFiles, psName_Action,	sKEY_ACTION,  eBGRNDTRACK_ACTION);
+							}
+							if (bReturn && psName_Boss)
+							{
+								bReturn = Music_ParseMusic(Parser, MusicData, pgMusicFiles, psName_Boss,	sKEY_BOSS,    eBGRNDTRACK_BOSS);
+							}
+							if (bReturn /*&& psName_Death*/)	// LAST MINUTE HACK!!, always force in some death music!!!!
+							{
+								//bReturn = Music_ParseMusic(Parser, MusicData, pgMusicFiles, psName_Death,	sKEY_DEATH,   eBGRNDTRACK_DEATH);
+
+								MusicFile_t m;
+											m.sFileNameBase = "death_music";
+								(*MusicData)[ sKEY_DEATH ] = m;
+							}
+						}
+						else
+						{
+							MUSIC_PARSE_WARNING(va("Unable to find entry for \"%s\" in \"%s\"\n",sLevelName,sFILENAME_DMS));
+						}
+					}
+					else
+					{
+						MUSIC_PARSE_ERROR(va("Unable to find subgroup \"%s\"\n",sKEY_LEVELMUSIC));
+					}
+				}
+				else
+				{
+					MUSIC_PARSE_ERROR(va("Unable to find subgroup \"%s\"\n",sKEY_MUSICFILES));
+				}
+			}
+			else
+			{
+				MUSIC_PARSE_ERROR( "Error calling GP2.GetBaseParseGroup()\n" );
+			}
+		}
+		else
+		{
+			MUSIC_PARSE_ERROR( "Error using GP to parse file\n" );
+		}
+
+		Z_Free(psStrippedText);
+		FS_FreeFile( pText );
+	}
+	else
+	{
+		MUSIC_PARSE_ERROR( "Unable to even read main file\n" );	// file name specified in error message
+	}
+
+	if (bReturn)
+	{
+		// sort exit points, and do some error checking...
+		//
+		for (MusicData_t::iterator itMusicData = MusicData->begin(); itMusicData != MusicData->end(); ++itMusicData)
+		{
+			LPCSTR psMusicStateType	= (*itMusicData).first.c_str();
+			MusicFile_t &MusicFile	= (*itMusicData).second;
+
+			// kludge up an enum, only interested in boss or not at the moment, so...
+			//
+			MusicState_e eMusicState = !stricmp(psMusicStateType,"boss") ? eBGRNDTRACK_BOSS : !stricmp(psMusicStateType,"death") ? eBGRNDTRACK_DEATH : eBGRNDTRACK_EXPLORE;
+
+			if (!MusicFile.MusicExitTimes.empty())
+			{
+				sort(MusicFile.MusicExitTimes.begin(),MusicFile.MusicExitTimes.end());
+			}
+
+			// check music exists...
+			//
+			LPCSTR psMusicFileName = Music_BuildFileName( MusicFile.sFileNameBase.c_str(), eMusicState );
+			if (!S_FileExists( psMusicFileName ))
+			{
+				MUSIC_PARSE_ERROR(va("Music file \"%s\" not found!\n",psMusicFileName));
+				return qfalse;		// have to return, because music data destroyed now
+			}
+
+			// check all transition music pieces exist, and that entry points into new pieces after transitions also exist...
+			//
+			for (int iExitPoint=0; iExitPoint < MusicFile.MusicExitPoints.size(); iExitPoint++)
+			{
+				MusicExitPoint_t &MusicExitPoint = MusicFile.MusicExitPoints[ iExitPoint ];
+
+				LPCSTR psTransitionFileName = Music_BuildFileName( MusicExitPoint.sNextFile.c_str(), eMusicState );
+				if (!S_FileExists( psTransitionFileName ))
+				{
+					MUSIC_PARSE_ERROR(va("Transition file \"%s\" (entry \"%s\" ) not found!\n",psTransitionFileName, MusicExitPoint.sNextFile.c_str()));
+					return qfalse;		// have to return, because music data destroyed now
+				}
+
+				LPCSTR psNextMark = MusicExitPoint.sNextMark.c_str();
+				if (strlen(psNextMark))	// always NZ ptr
+				{
+					// then this must be "action" music under current rules...
+					//					
+					assert( !strcmp(psMusicStateType, Music_BaseStateToString(eBGRNDTRACK_ACTION) ? Music_BaseStateToString(eBGRNDTRACK_ACTION):"") );
+					//
+					// does this marker exist in the explore piece?
+					//					
+					MusicData_t::iterator itExploreMusicData = MusicData->find( Music_BaseStateToString(eBGRNDTRACK_EXPLORE) );
+					if (itExploreMusicData != MusicData->end())
+					{
+						MusicFile_t &MusicFile_Explore = (*itExploreMusicData).second;
+
+						if (!MusicFile_Explore.MusicEntryTimes.count(psNextMark))
+						{
+							MUSIC_PARSE_ERROR( va("Unable to find entry point \"%s\" in description for \"%s\"\n",psNextMark,MusicFile_Explore.sFileNameBase.c_str()) );
+							return qfalse;		// have to return, because music data destroyed now
+						}
+					}
+					else
+					{
+						MUSIC_PARSE_ERROR( va("Unable to find %s piece to match \"%s\"\n", Music_BaseStateToString(eBGRNDTRACK_EXPLORE), MusicFile.sFileNameBase.c_str() ) );
+						return qfalse;		// have to return, because music data destroyed now
+					}
+				}
+			}
+		}
+	}
+	
+#ifdef _DEBUG
+/*
+	// dump the whole thing out to prove it was read in ok...
+	//
+	if (bReturn)
+	{
+		for (MusicData_t::iterator itMusicData = MusicData->begin(); itMusicData != MusicData->end(); ++itMusicData)
+		{
+			LPCSTR psMusicState		= (*itMusicData).first.c_str();
+			MusicFile_t &MusicFile	= (*itMusicData).second;
+
+			OutputDebugString(va("Music State:  \"%s\",  File: \"%s\"\n",psMusicState, MusicFile.sFileNameBase.c_str()));
+
+			// entry times...
+			//
+			for (MusicEntryTimes_t::iterator itEntryTimes = MusicFile.MusicEntryTimes.begin(); itEntryTimes != MusicFile.MusicEntryTimes.end(); ++itEntryTimes)
+			{
+				LPCSTR	psMarkerName	= (*itEntryTimes).first.c_str();
+				float	fEntryTime		= (*itEntryTimes).second;
+
+				OutputDebugString(va("Entry time for \"%s\": %f\n", psMarkerName, fEntryTime));
+			}
+
+			// exit points...
+			//
+			for (int i=0; i<MusicFile.MusicExitPoints.size(); i++)
+			{
+				MusicExitPoint_t &MusicExitPoint = MusicFile.MusicExitPoints[i];
+
+				OutputDebugString(va("Exit point %d:	sNextFile: \"%s\", sNextMark: \"%s\"\n",i,MusicExitPoint.sNextFile.c_str(),MusicExitPoint.sNextMark.c_str()));
+			}
+
+			// exit times...
+			//
+			for (i=0; i<MusicFile.MusicExitTimes.size(); i++)
+			{
+				MusicExitTime_t &MusicExitTime = MusicFile.MusicExitTimes[i];
+				
+				OutputDebugString(va("Exit time %d:		fTime: %f, iExitPoint: %d\n",i,MusicExitTime.fTime,MusicExitTime.iExitPoint));
+			}
+		}
+	}
+*/
+#endif
+
+	return bReturn;
+}
+
+
+// returns ptr to music file, or NULL for error/missing...
+//
+static MusicFile_t *Music_GetBaseMusicFile( LPCSTR psMusicState )	// where psMusicState is (eg) "explore", "action" or "boss"
+{
+	MusicData_t::iterator it = MusicData->find( psMusicState );
+	if (it != MusicData->end())
+	{
+		MusicFile_t *pMusicFile = &(*it).second;
+		return pMusicFile;
+	}
+
+	return NULL;
+}
+
+static MusicFile_t *Music_GetBaseMusicFile( MusicState_e eMusicState )
+{
+	LPCSTR	psMusicStateString = Music_BaseStateToString( eMusicState );
+	if ( psMusicStateString )
+	{
+		return Music_GetBaseMusicFile( psMusicStateString );
+	}
+
+	return NULL;
+}
+
+
+// where label is (eg) "kejim_base"...
+//
+sboolean Music_DynamicDataAvailable(const char *psDynamicMusicLabel)
+{		
+	char sLevelName[MAX_QPATH];
+	Q_strncpyz(sLevelName,COM_SkipPath( const_cast<char*>( (psDynamicMusicLabel&&psDynamicMusicLabel[0])?psDynamicMusicLabel:gsLevelNameFromServer.c_str() ) ),sizeof(sLevelName));
+	strlwr(sLevelName);
+
+	if (strlen(sLevelName))	// avoid error messages when there's no music waiting to be played and we try and restart it...
+	{
+		if (Music_ParseLeveldata(sLevelName))
+		{
+			return !!(	Music_GetBaseMusicFile( eBGRNDTRACK_EXPLORE ) &&
+						Music_GetBaseMusicFile(	eBGRNDTRACK_ACTION	)
+						);
+		}
+	}
+
+	return qfalse;
+}
+
+LPCSTR Music_GetFileNameForState( MusicState_e eMusicState)
+{
+	MusicFile_t *pMusicFile = NULL;
+	switch (eMusicState)
+	{
+		case eBGRNDTRACK_EXPLORE:
+		case eBGRNDTRACK_ACTION:
+		case eBGRNDTRACK_BOSS:
+		case eBGRNDTRACK_DEATH:
+
+			pMusicFile = Music_GetBaseMusicFile( eMusicState );
+			if (pMusicFile)
+			{
+				return Music_BuildFileName( pMusicFile->sFileNameBase.c_str(), eMusicState );
+			}
+			break;
+
+		case eBGRNDTRACK_ACTIONTRANS0:
+		case eBGRNDTRACK_ACTIONTRANS1:
+		case eBGRNDTRACK_ACTIONTRANS2:
+		case eBGRNDTRACK_ACTIONTRANS3:
+
+			pMusicFile = Music_GetBaseMusicFile( eBGRNDTRACK_ACTION );
+			if (pMusicFile)
+			{
+				int iTransNum = eMusicState - eBGRNDTRACK_ACTIONTRANS0;
+				if (iTransNum < pMusicFile->MusicExitPoints.size())
+				{
+					return Music_BuildFileName( pMusicFile->MusicExitPoints[iTransNum].sNextFile.c_str(), eMusicState );
+				}
+			}
+			break;
+
+		case eBGRNDTRACK_EXPLORETRANS0:
+		case eBGRNDTRACK_EXPLORETRANS1:
+		case eBGRNDTRACK_EXPLORETRANS2:
+		case eBGRNDTRACK_EXPLORETRANS3:
+
+			pMusicFile = Music_GetBaseMusicFile( eBGRNDTRACK_EXPLORE );
+			if (pMusicFile)
+			{
+				int iTransNum = eMusicState - eBGRNDTRACK_EXPLORETRANS0;
+				if (iTransNum < pMusicFile->MusicExitPoints.size())
+				{
+					return Music_BuildFileName( pMusicFile->MusicExitPoints[iTransNum].sNextFile.c_str(), eMusicState );
+				}
+			}
+			break;
+
+		default:
+			#ifndef FINAL_BUILD
+			assert(0);	// duh....what state are they asking for?
+			Com_Printf( S_COLOR_RED "Music_GetFileNameForState( %d ) unhandled case!\n",eMusicState );
+			#endif
+			break;
+	}
+
+	return NULL;
+}
+
+
+
+sboolean Music_StateIsTransition( MusicState_e eMusicState )
+{
+	return (eMusicState >= eBGRNDTRACK_FIRSTTRANSITION &&
+			eMusicState <= eBGRNDTRACK_LASTTRANSITION
+			);
+}
+
+
+sboolean Music_StateCanBeInterrupted( MusicState_e eMusicState, MusicState_e eProposedMusicState )
+{
+	// death music can interrupt anything...
+	//
+	if (eProposedMusicState == eBGRNDTRACK_DEATH)
+		return qtrue;
+	//
+	// ... and can't be interrupted once started...(though it will internally-switch to silence at the end, rather than loop)
+	//
+	if (eMusicState == eBGRNDTRACK_DEATH)
+	{
+		return qfalse;
+	}
+
+	// boss music can interrupt anything (other than death, but that's already handled above)...
+	//
+	if (eProposedMusicState == eBGRNDTRACK_BOSS)
+		return qtrue;
+	//
+	// ... and can't be interrupted once started...
+	//
+	if (eMusicState == eBGRNDTRACK_BOSS)
+	{
+		// ...except by silence (or death, but again, that's already handled above)
+		//
+		if (eProposedMusicState == eBGRNDTRACK_SILENCE)	 
+			return qtrue;	
+
+		return qfalse;
+	}
+
+	// action music can interrupt anything (after boss & death filters above)...
+	//
+	if (eProposedMusicState == eBGRNDTRACK_ACTION)
+		return qtrue;
+
+	// nothing can interrupt a transition (after above filters)...
+	//
+	if (Music_StateIsTransition( eMusicState ))
+		return qfalse;
+
+	// current state is therefore interruptable...
+	//
+	return qtrue;
+}
+
+
+
+// returns qtrue if music is allowed to transition out of current state, based on current play position...
+// (doesn't bother returning final state after transition (eg action->transition->explore) becuase it's fairly obvious)
+//
+// supply:
+//
+// playing point in float seconds
+// enum of track being queried
+//
+// get:
+//
+// enum of transition track to switch to
+// float time of entry point of new track *after* transition
+//
+sboolean Music_AllowedToTransition( float			fPlayingTimeElapsed,
+									MusicState_e	eMusicState,
+									//
+									MusicState_e	*peTransition /* = NULL */,
+									float			*pfNewTrackEntryTime /* = NULL */
+									)
+{
+	const float fTimeEpsilon = 0.3f;	// arb., how close we have to be to an exit point to take it.
+										//		if set too high then music change is sloppy
+										//		if set too low[/precise] then we might miss an exit if client fps is poor
+
+
+	MusicFile_t *pMusicFile = Music_GetBaseMusicFile( eMusicState );	
+	if (pMusicFile && !pMusicFile->MusicExitTimes.empty())
+	{
+		MusicExitTime_t	T;
+						T.fTime = fPlayingTimeElapsed;
+
+		// since a MusicExitTimes_t item is a sorted array, we can use the equal_range algorithm...
+		//
+		pair <MusicExitTimes_t::iterator, MusicExitTimes_t::iterator> itp = equal_range( pMusicFile->MusicExitTimes.begin(), pMusicFile->MusicExitTimes.end(), T);
+		if (itp.first != pMusicFile->MusicExitTimes.begin())
+			itp.first--;	// encompass the one before, in case we've just missed an exit point by < fTimeEpsilon
+		if (itp.second!= pMusicFile->MusicExitTimes.end())
+			itp.second++;	// increase range to one beyond, so we can do normal STL being/end looping below
+		for (MusicExitTimes_t::iterator it = itp.first; it != itp.second; ++it)
+		{
+			MusicExitTimes_t::iterator pExitTime = it;
+			
+			if ( Q_fabs(pExitTime->fTime - fPlayingTimeElapsed) <= fTimeEpsilon )
+			{
+				// got an exit point!, work out feedback params...
+				//
+				int iExitPoint = pExitTime->iExitPoint;
+				//
+				// the two params to give back...
+				//
+				MusicState_e	eFeedBackTransition			= eBGRNDTRACK_EXPLORETRANS0;	// any old default
+				float			fFeedBackNewTrackEntryTime	= 0.0f;
+				//
+				// check legality in case of crap data...
+				//
+				if (iExitPoint < pMusicFile->MusicExitPoints.size())
+				{
+					MusicExitPoint_t &ExitPoint = pMusicFile->MusicExitPoints[ iExitPoint ];
+
+					switch (eMusicState)
+					{
+						case eBGRNDTRACK_EXPLORE:
+						{
+							assert(iExitPoint < iMAX_EXPLORE_TRANSITIONS);	// already been checked, but sanity
+							assert(!ExitPoint.sNextMark.c_str()[0]);		// simple error checking, but harmless if tripped. explore transitions go to silence, hence no entry time for [silence] state after transition
+
+							eFeedBackTransition = (MusicState_e) (eBGRNDTRACK_EXPLORETRANS0 + iExitPoint);
+						}
+						break;
+
+						case eBGRNDTRACK_ACTION:
+						{
+							assert(iExitPoint < iMAX_ACTION_TRANSITIONS);	// already been checked, but sanity
+
+							// if there's an entry marker point defined...
+							//
+							if (ExitPoint.sNextMark.c_str()[0])
+							{
+								MusicData_t::iterator itExploreMusicData = MusicData->find( Music_BaseStateToString(eBGRNDTRACK_EXPLORE) );
+								//
+								// find "explore" music...
+								//
+								if (itExploreMusicData != MusicData->end())
+								{
+									MusicFile_t &MusicFile_Explore = (*itExploreMusicData).second;
+									//
+									// find the entry marker within the music and read the time there...
+									//
+									MusicEntryTimes_t::iterator itEntryTime = MusicFile_Explore.MusicEntryTimes.find( ExitPoint.sNextMark.c_str() );
+									if (itEntryTime != MusicFile_Explore.MusicEntryTimes.end())
+									{
+										fFeedBackNewTrackEntryTime = (*itEntryTime).second;										
+										eFeedBackTransition = (MusicState_e) (eBGRNDTRACK_ACTIONTRANS0 + iExitPoint);
+									}
+									else
+									{
+										#ifndef FINAL_BUILD
+										assert(0);	// sanity, should have been caught elsewhere, but harmless to do this
+										Com_Printf( S_COLOR_RED "Music_AllowedToTransition() unable to find entry marker \"%s\" in \"%s\"",ExitPoint.sNextMark.c_str(), MusicFile_Explore.sFileNameBase.c_str());
+										#endif
+										return qfalse;
+									}
+								}
+								else
+								{
+									#ifndef FINAL_BUILD
+									assert(0);	// sanity, should have been caught elsewhere, but harmless to do this
+									Com_Printf( S_COLOR_RED "Music_AllowedToTransition() unable to find %s version of \"%s\"\n",Music_BaseStateToString(eBGRNDTRACK_EXPLORE), pMusicFile->sFileNameBase.c_str());
+									#endif
+									return qfalse;
+								}
+							}
+							else
+							{
+								eFeedBackTransition			= eBGRNDTRACK_ACTIONTRANS0;
+								fFeedBackNewTrackEntryTime	= 0.0f;		// already set to this, but FYI
+							}
+						}
+						break;
+
+						default:
+						{
+							#ifndef FINAL_BUILD
+							assert(0);
+							Com_Printf( S_COLOR_RED "Music_AllowedToTransition(): No code to transition from music type %d\n",eMusicState);
+							#endif
+							return qfalse;
+						}
+						break;
+					}
+				}
+				else
+				{
+					#ifndef FINAL_BUILD
+					assert(0);
+					Com_Printf( S_COLOR_RED "Music_AllowedToTransition(): Illegal exit point %d, max = %d (music: \"%s\")\n",iExitPoint, pMusicFile->MusicExitPoints.size()-1, pMusicFile->sFileNameBase.c_str() );
+					#endif
+					return qfalse;
+				}
+
+
+				// feed back answers...
+				//
+				if ( peTransition)
+				{
+					*peTransition = eFeedBackTransition;
+				}
+
+				if ( pfNewTrackEntryTime )
+				{
+					*pfNewTrackEntryTime = fFeedBackNewTrackEntryTime;
+				}
+
+				return qtrue;
+			}
+		}
+	}
+
+	return qfalse;
+}
+
+
+// typically used to get a (predefined) random entry point for the action music, but will work on any defined type with entry points, 
+//	defaults safely to 0.0f if no info available...
+//
+float Music_GetRandomEntryTime( MusicState_e eMusicState )
+{
+	MusicData_t::iterator itMusicData = MusicData->find( Music_BaseStateToString( eMusicState ) );
+	if (itMusicData != MusicData->end())
+	{
+		MusicFile_t &MusicFile = (*itMusicData).second;
+
+		if (MusicFile.MusicEntryTimes.size())	// make sure at least one defined, else default to start
+		{
+			// Quake's random number generator isn't very good, so instead of this:
+			//
+			// int iRandomEntryNum = Q_irand(0, (MusicFile.MusicEntryTimes.size()-1) );
+			//
+			// ... I'll do this (ensuring we don't get the same result on two consecutive calls, but without while-loop)...
+			//
+			static int	iPrevRandomNumber = -1;
+			static int	iCallCount = 0;
+						iCallCount++;
+			int iRandomEntryNum = (rand()+iCallCount) % (MusicFile.MusicEntryTimes.size());	// legal range
+			if (iRandomEntryNum == iPrevRandomNumber && MusicFile.MusicEntryTimes.size()>1)
+			{
+				iRandomEntryNum += 1;
+				iRandomEntryNum %= (MusicFile.MusicEntryTimes.size());
+			}
+			iPrevRandomNumber = iRandomEntryNum;
+
+//			OutputDebugString(va("Music_GetRandomEntryTime(): Entry %d\n",iRandomEntryNum));
+
+			for (MusicEntryTimes_t::iterator itEntryTime = MusicFile.MusicEntryTimes.begin(); itEntryTime != MusicFile.MusicEntryTimes.end(); ++itEntryTime)
+			{
+				if (!iRandomEntryNum--)
+				{
+					return (*itEntryTime).second;										
+				}
+			}
+		}
+	}
+
+	return 0.0f;
+}
+
+// info only, used in "soundinfo" command...
+//
+const char *Music_GetLevelSetName(void)
+{
+	if (Q_stricmp(gsLevelNameForCompare.c_str(), gsLevelNameForLoad.c_str()))
+	{
+		// music remap via USES command...
+		//
+		return va("%s -> %s",gsLevelNameForCompare.c_str(), gsLevelNameForLoad.c_str());
+	}
+
+	return gsLevelNameForLoad.c_str();
+}
+
+///////////////// eof /////////////////////
+
diff --git a/codemp/client/snd_music.h b/codemp/client/snd_music.h
new file mode 100644
index 0000000..1de2619
--- /dev/null
+++ b/codemp/client/snd_music.h
@@ -0,0 +1,65 @@
+// Filename:-	snd_music.h
+//
+//
+
+
+
+#ifndef SND_MUSIC_H
+#define SND_MUSIC_H
+
+// if you change this enum, you MUST update the #defines below
+typedef enum 
+{
+//( eBGRNDTRACK_DATABEGIN )			// begin-label for FOR loops
+	//
+	eBGRNDTRACK_EXPLORE = 0,		// for normal walking around
+	eBGRNDTRACK_ACTION,				// for excitement	
+	eBGRNDTRACK_BOSS,				// (optional) for final encounter
+	eBGRNDTRACK_DEATH,				// (optional) death "flourish"
+	eBGRNDTRACK_ACTIONTRANS0,		// transition from action to explore
+	eBGRNDTRACK_ACTIONTRANS1,		// "
+	eBGRNDTRACK_ACTIONTRANS2,		// "
+	eBGRNDTRACK_ACTIONTRANS3,		// "
+	eBGRNDTRACK_EXPLORETRANS0,		// transition from explore to silence
+	eBGRNDTRACK_EXPLORETRANS1,		// "
+	eBGRNDTRACK_EXPLORETRANS2,		// "
+	eBGRNDTRACK_EXPLORETRANS3,		// "
+	//
+//(	eBGRNDTRACK_DATAEND ),			// tracks from this point on are for logic or copies, do NOT free them.
+	//
+	eBGRNDTRACK_NONDYNAMIC,			// used for when music is just streaming, not part of dynamic stuff (used to be defined as same as explore entry, but this allows playing music in between 2 invokations of the same dynamic music without midleve reload, and also faster level transitioning if two consecutive dynamic sections use same DMS.DAT entries. Are you still reading this far?
+	eBGRNDTRACK_SILENCE,			// silence (more of a logic thing than an actual track at the moment)
+	eBGRNDTRACK_FADE,				// the xfade channel
+	//
+	eBGRNDTRACK_NUMBEROF
+
+} MusicState_e;
+
+#define iMAX_ACTION_TRANSITIONS		4	// these can be increased easily enough, I just need to know about them
+#define iMAX_EXPLORE_TRANSITIONS	4	//
+
+#define eBGRNDTRACK_DATABEGIN	eBGRNDTRACK_EXPLORE	// label for FOR() loops (not in enum, else debugger shows in instead of the explore one unless I declare them backwards, which is gay)
+#define eBGRNDTRACK_DATAEND		eBGRNDTRACK_NONDYNAMIC // tracks from this point on are for logic or copies, do NOT free them.
+
+#define eBGRNDTRACK_FIRSTTRANSITION	eBGRNDTRACK_ACTIONTRANS0	// used for "are we in transition mode" check
+#define eBGRNDTRACK_LASTTRANSITION	eBGRNDTRACK_EXPLORETRANS3	//
+
+
+void		Music_SetLevelName			( const char *psLevelName );
+sboolean	Music_DynamicDataAvailable	( const char *psDynamicMusicLabel );
+const char *Music_GetFileNameForState	( MusicState_e eMusicState );
+sboolean	Music_StateIsTransition		( MusicState_e eMusicState );
+sboolean	Music_StateCanBeInterrupted	( MusicState_e eMusicState, MusicState_e eProposedMusicState );
+float		Music_GetRandomEntryTime	( MusicState_e eMusicState );
+
+sboolean	Music_AllowedToTransition	( float fPlayingTimeElapsed, MusicState_e eMusicState, MusicState_e	*peTransition = NULL, float *pfNewTrackEntryTime = NULL);
+
+const char *Music_BaseStateToString		( MusicState_e eMusicState, sboolean bDebugPrintQuery = qfalse);
+
+
+#endif	// #ifndef SND_MUSIC_H
+
+
+//////////////// eof /////////////////
+
+
diff --git a/codemp/client/snd_public.h b/codemp/client/snd_public.h
new file mode 100644
index 0000000..62a1fde
--- /dev/null
+++ b/codemp/client/snd_public.h
@@ -0,0 +1,63 @@
+#ifndef _SND_PUBLIC_H
+#define _SND_PUBLIC_H
+
+void S_Init( void );
+void S_Shutdown( void );
+
+// if origin is NULL, the sound will be dynamically sourced from the entity
+void S_AddAmbientLoopingSound( const vec3_t origin, unsigned char volume, sfxHandle_t sfxHandle );
+void S_StartAmbientSound( const vec3_t origin, int entityNum, unsigned char volume, sfxHandle_t sfxHandle );
+void S_MuteSound(int entityNum, int entchannel);
+void S_StartSound( const vec3_t origin, int entnum, int entchannel, sfxHandle_t sfx );
+void S_StartLocalSound( sfxHandle_t sfx, int channelNum );
+void S_StartLocalLoopingSound( sfxHandle_t sfx);
+
+void S_UnCacheDynamicMusic( void );
+void S_RestartMusic( void );
+void S_StartBackgroundTrack( const char *intro, const char *loop, int bCalledByCGameStart );
+void S_StopBackgroundTrack( void );
+float S_GetSampleLengthInMilliSeconds( sfxHandle_t sfxHandle);
+
+// cinematics and voice-over-network will send raw samples
+// 1.0 volume will be direct output of source samples
+void S_RawSamples( int samples, int rate, int width, int s_channels, const byte *data, float volume, int bFirstOrOnlyUpdateThisFrame );
+// stop all sounds
+void S_StopSounds(void);	// from snd_dma.cpp
+// stop all sounds and the background track
+void S_StopAllSounds( void );
+
+// scan all MP3s in the sound dir and add maxvol info if necessary.
+void S_MP3_CalcVols_f( void );
+
+// all continuous looping sounds must be added before calling S_Update
+void S_ClearLoopingSounds( void );
+void S_StopLoopingSound( int entityNum );
+#ifdef _XBOX
+void S_AddLoopingSound( int entityNum, const vec3_t origin, const vec3_t velocity, sfxHandle_t sfx, int chan = 0 );
+#else
+void S_AddLoopingSound( int entityNum, const vec3_t origin, const vec3_t velocity, sfxHandle_t sfx );
+#endif
+
+// recompute the reletive volumes for all running sounds
+// relative to the given entityNum / orientation
+void S_Respatialize( int entityNum, const vec3_t head, vec3_t axis[3], int inwater );
+
+// let the sound system know where an entity currently is
+void S_UpdateEntityPosition( int entityNum, const vec3_t origin );
+
+void S_Update( void );
+
+void S_DisableSounds( void );
+
+void S_BeginRegistration( void );
+
+// RegisterSound will allways return a valid sample, even if it
+// has to create a placeholder.  This prevents continuous filesystem
+// checks for missing files
+sfxHandle_t	S_RegisterSound( const char *sample );
+
+extern qboolean s_shutUp;
+
+void S_FreeAllSFXMem(void);
+
+#endif
diff --git a/codemp/client/vssver.scc b/codemp/client/vssver.scc
new file mode 100644
index 0000000..bfad7ab
Binary files /dev/null and b/codemp/client/vssver.scc differ
diff --git a/codemp/encryption/encryption.h b/codemp/encryption/encryption.h
new file mode 100644
index 0000000..3295ae1
--- /dev/null
+++ b/codemp/encryption/encryption.h
@@ -0,0 +1,6 @@
+//Pakinator Main Header
+
+//define this to enable all pak files encryption requirements
+#ifdef FINAL_BUILD
+//#define _ENCRYPTION_
+#endif
\ No newline at end of file
diff --git a/codemp/encryption/vssver.scc b/codemp/encryption/vssver.scc
new file mode 100644
index 0000000..0b49e26
Binary files /dev/null and b/codemp/encryption/vssver.scc differ
diff --git a/codemp/ff/ff_console.cpp b/codemp/ff/ff_console.cpp
new file mode 100644
index 0000000..0919f9b
--- /dev/null
+++ b/codemp/ff/ff_console.cpp
@@ -0,0 +1,248 @@
+/*
+ * Stubs to allow linking with FF_ fnuctions declared.
+ * Brian Osman
+ */
+
+//JLFRUMBLE includes modified to avoid typename collision field_t
+#ifdef _JK2MP
+#include "../namespace_begin.h"
+#endif
+#include "../game/q_shared.h"
+#include "../qcommon/qcommon.h"
+#include "../client/keycodes.h"
+//#include "../client/client.h"
+#include "../client/fffx.h"
+#include "../win32/win_input.h"
+#ifdef _JK2MP
+#include "../namespace_end.h"
+#endif
+
+void FF_StopAll(void)
+{
+	Com_Printf("FF_StopAll: Please implement.\n");
+	// Do nothing
+}
+
+void FF_Stop(ffFX_e effect)
+{
+	Com_Printf("FF_Stop: Please implement fffx_id = %i\n",effect);
+	// Do nothing
+}
+
+void FF_EnsurePlaying(ffFX_e effect)
+{
+	Com_Printf("FF_EnsurePlaying: Please implement fffx_id = %i\n",effect);
+	// Do nothing
+}
+
+void FF_Play(ffFX_e effect)
+{
+	int s;	// script id
+	static int const_rumble[2] = {-1}; // script id for constant rumble
+	int client;
+
+	// super huge switch for rumble effects
+	switch(effect)
+	{
+	case fffx_AircraftCarrierTakeOff:
+	case fffx_BasketballDribble:
+	case fffx_CarEngineIdle:
+	case fffx_ChainsawIdle:
+	case fffx_ChainsawInAction:
+	case fffx_DieselEngineIdle:
+	case fffx_Jump:
+		s = IN_CreateRumbleScript(IN_GetMainController(), 2, true);
+		if (s != -1)
+		{
+			IN_AddRumbleState(s, 50000, 10000, 200);
+			IN_AddRumbleState(s, 0, 0, 10);
+			IN_ExecuteRumbleScript(s);
+		}
+		break;
+	case fffx_Land:
+		s = IN_CreateRumbleScript(IN_GetMainController(), 2, true);
+		if (s != -1)
+		{
+			IN_AddRumbleState(s, 50000, 10000, 200);
+			IN_AddRumbleState(s, 0, 0, 10);
+			IN_ExecuteRumbleScript(s);
+		}
+		break;
+	case fffx_MachineGun:
+		s = IN_CreateRumbleScript(IN_GetMainController(), 2, true);
+		if (s != -1)
+		{
+			IN_AddRumbleState(s, 56000, 20000, 230);
+			IN_AddRumbleState(s, 0, 0, 10);
+			IN_ExecuteRumbleScript(s);
+		}
+		break;
+	case fffx_Punched:
+	case fffx_RocketLaunch:
+
+	case fffx_SecretDoor:
+	case fffx_SwitchClick:	// used by saber
+		s = IN_CreateRumbleScript(IN_GetMainController(), 1, true);
+		if (s != -1)
+		{
+			IN_AddRumbleState(s, 30000, 10000, 120);
+			IN_ExecuteRumbleScript(s);
+		}
+		break;
+	case fffx_WindGust:
+	case fffx_WindShear:
+	case fffx_Pistol:
+		s = IN_CreateRumbleScript(IN_GetMainController(), 2, true);
+		if (s != -1)
+		{
+			IN_AddRumbleState(s, 50000, 10000, 200);
+			IN_AddRumbleState(s, 0, 0, 10);
+			IN_ExecuteRumbleScript(s);
+		}
+		break;
+	case fffx_Shotgun:
+	case fffx_Laser1:
+	case fffx_Laser2:
+	case fffx_Laser3:
+	case fffx_Laser4:
+	case fffx_Laser5:
+	case fffx_Laser6:
+	case fffx_OutOfAmmo:
+	case fffx_LightningGun:
+	case fffx_Missile:
+	case fffx_GatlingGun:
+		s = IN_CreateRumbleScript(IN_GetMainController(), 2, true);
+		if (s != -1)
+		{
+			IN_AddRumbleState(s, 39000, 0, 220);
+			IN_AddRumbleState(s, 0, 0, 10);
+			IN_ExecuteRumbleScript(s);
+		}
+		break;
+	case fffx_ShortPlasma:
+	case fffx_PlasmaCannon1:
+	case fffx_PlasmaCannon2:
+	case fffx_Cannon:
+	case fffx_FallingShort:
+	case fffx_FallingMedium:
+		s = IN_CreateRumbleScript(IN_GetMainController(), 1, true);
+		if (s != -1)
+		{
+			IN_AddRumbleState(s, 25000,10000, 230);
+			IN_ExecuteRumbleScript(s);
+		}
+		break;
+	case fffx_FallingFar:
+		s = IN_CreateRumbleScript(IN_GetMainController(), 1, true);
+		if (s != -1)
+		{
+			IN_AddRumbleState(s, 32000,10000, 230);
+			IN_ExecuteRumbleScript(s);
+		}
+		break;
+	case fffx_StartConst:
+		client = IN_GetMainController();
+		if(const_rumble[client] == -1)
+		{
+			const_rumble[client] = IN_CreateRumbleScript(IN_GetMainController(), 9, true);
+			if (const_rumble[client] != -1)
+			{
+				IN_AddEffectFade4(const_rumble[client], 0,0, 50000, 0, 2000);
+				IN_AddRumbleState(const_rumble[client], 50000, 0, 300);
+				IN_AddEffectFade4(const_rumble[client], 50000,50000, 0, 0, 1000);
+				IN_ExecuteRumbleScript(const_rumble[client]);
+			}
+		}
+		break;
+	case fffx_StopConst:
+		client = IN_GetMainController();
+		if (const_rumble[client] == -1)
+			return;
+		IN_KillRumbleScript(const_rumble[client]);
+		const_rumble[client] = -1;
+		break;
+	default:
+		Com_Printf("No rumble script is defined for fffx_id = %i\n",effect);
+		break;
+	}
+}
+
+/*********
+FF_XboxShake
+
+intensity	- speed of rumble
+duration	- length of rumble
+*********/
+#define	FF_SH_MIN_MOTOR_SPEED		20000
+#define	FF_SH_MOTOR_SPEED_MODIFIER	(65535 - FF_SH_MIN_MOTOR_SPEED)
+void FF_XboxShake(float intensity, int duration)
+{
+	int s;
+	s = IN_CreateRumbleScript(IN_GetMainController(), 1, true);
+	if (s != -1)
+	{
+		int speed;
+		// figure out the speed
+		speed = (FF_SH_MIN_MOTOR_SPEED) + (FF_SH_MOTOR_SPEED_MODIFIER * intensity);
+		
+		// Add the state and execute
+		IN_AddRumbleState(s, speed, speed, duration);
+		IN_ExecuteRumbleScript(s);
+	}
+}
+
+/*********
+FF_XboxDamage
+
+damage	- Amount of damage
+xpos	- x position for the damage ( -1.0 - 1.0 )
+
+The following function various the rumble based upon
+the amount of damage and the position of the damage.
+*********/
+#define FF_DA_MIN_MOTOR_SPEED		20000	// use this to vary the minimum intensity
+#define FF_DA_MOTOR_SPEED_MODIFIER	(65535 - FF_DA_MIN_MOTOR_SPEED)
+void FF_XboxDamage(int damage, float xpos)
+{
+	int s;
+	s = IN_CreateRumbleScript(IN_GetMainController(), 1, true);
+	if (s != -1)
+	{
+		int leftMotorSpeed;
+		int rightMotorSpeed;
+		int duration;
+		float per;
+
+		duration = 175;
+
+		// how much damage?
+		if(damage > 100)
+		{
+			per = 1.0;
+		}
+		else
+		{
+			per = damage/100;
+		}
+		
+		if(xpos >= -0.2 && xpos <= 0.2)	// damge to center
+		{
+			leftMotorSpeed = rightMotorSpeed = (FF_DA_MIN_MOTOR_SPEED)+(FF_DA_MOTOR_SPEED_MODIFIER * per);
+		}
+		else if(xpos > 0.2)	// damage to right
+		{
+			rightMotorSpeed = (FF_DA_MIN_MOTOR_SPEED)+(FF_DA_MOTOR_SPEED_MODIFIER * per);
+			leftMotorSpeed = 0;
+		}
+		else	// damage to left
+		{
+			leftMotorSpeed = (FF_DA_MIN_MOTOR_SPEED)+(FF_DA_MOTOR_SPEED_MODIFIER * per);;
+			rightMotorSpeed = 0;
+		}
+		
+		// Add the state and execute
+		IN_AddRumbleState(s, leftMotorSpeed, rightMotorSpeed, duration);
+		IN_ExecuteRumbleScript(s);
+	}
+}
+
diff --git a/codemp/ff/vssver.scc b/codemp/ff/vssver.scc
new file mode 100644
index 0000000..f018f4c
Binary files /dev/null and b/codemp/ff/vssver.scc differ
diff --git a/codemp/game/AnimalNPC.c b/codemp/game/AnimalNPC.c
new file mode 100644
index 0000000..a0f2948
--- /dev/null
+++ b/codemp/game/AnimalNPC.c
@@ -0,0 +1,946 @@
+// leave this line at the top for all g_xxxx.cpp files...
+#include "g_headers.h"
+
+//seems to be a compiler bug, it doesn't clean out the #ifdefs between dif-compiles
+//or something, so the headers spew errors on these defs from the previous compile.
+//this fixes that. -rww
+#ifdef _JK2MP
+//get rid of all the crazy defs we added for this file
+#undef currentAngles
+#undef currentOrigin
+#undef mins
+#undef maxs
+#undef legsAnimTimer
+#undef torsoAnimTimer
+#undef bool
+#undef false
+#undef true
+
+#undef sqrtf
+#undef Q_flrand
+
+#undef MOD_EXPLOSIVE
+#endif
+
+#ifdef _JK2 //SP does not have this preprocessor for game like MP does
+#ifndef _JK2MP
+#define _JK2MP
+#endif
+#endif
+
+#ifndef _JK2MP //if single player
+#ifndef QAGAME //I don't think we have a QAGAME define
+#define QAGAME //but define it cause in sp we're always in the game
+#endif
+#endif
+
+#ifdef QAGAME //including game headers on cgame is FORBIDDEN ^_^
+#include "g_local.h"
+#elif defined _JK2MP
+#include "bg_public.h"
+#endif
+
+#ifndef _JK2MP
+#include "g_functions.h"
+#include "g_vehicles.h"
+#else
+#include "bg_vehicles.h"
+#endif
+
+#ifdef _JK2MP
+//this is really horrible, but it works! just be sure not to use any locals or anything
+//with these names (exluding bool, false, true). -rww
+#define currentAngles r.currentAngles
+#define currentOrigin r.currentOrigin
+#define mins r.mins
+#define maxs r.maxs
+#define legsAnimTimer legsTimer
+#define torsoAnimTimer torsoTimer
+#define bool qboolean
+#define false qfalse
+#define true qtrue
+
+#define sqrtf sqrt
+#define Q_flrand flrand
+
+#define MOD_EXPLOSIVE MOD_SUICIDE
+#else
+#define bgEntity_t gentity_t
+#endif
+
+#ifdef QAGAME //we only want a few of these functions for BG
+
+extern float DotToSpot( vec3_t spot, vec3_t from, vec3_t fromAngles );
+extern vmCvar_t	cg_thirdPersonAlpha;
+extern vec3_t playerMins;
+extern vec3_t playerMaxs;
+extern cvar_t	*g_speederControlScheme;
+
+#ifdef _JK2MP
+#include "../namespace_begin.h"
+#endif
+extern void PM_SetAnim(pmove_t	*pm,int setAnimParts,int anim,int setAnimFlags, int blendTime);
+extern int PM_AnimLength( int index, animNumber_t anim );
+#ifdef _JK2MP
+#include "../namespace_end.h"
+#endif
+
+#ifndef	_JK2MP
+extern void CG_ChangeWeapon( int num );
+#endif
+
+extern void Vehicle_SetAnim(gentity_t *ent,int setAnimParts,int anim,int setAnimFlags, int iBlend);
+extern void G_Knockdown( gentity_t *self, gentity_t *attacker, const vec3_t pushDir, float strength, qboolean breakSaberLock );
+extern void G_VehicleTrace( trace_t *results, const vec3_t start, const vec3_t tMins, const vec3_t tMaxs, const vec3_t end, int passEntityNum, int contentmask );
+
+// Update death sequence.
+static void DeathUpdate( Vehicle_t *pVeh )
+{
+	if ( level.time >= pVeh->m_iDieTime )
+	{
+		// If the vehicle is not empty.
+		if ( pVeh->m_pVehicleInfo->Inhabited( pVeh ) )
+		{
+			pVeh->m_pVehicleInfo->EjectAll( pVeh );
+		}
+		else
+		{
+			// Waste this sucker.
+		}
+
+		// Die now...
+/*		else
+		{
+			vec3_t	mins, maxs, bottom;
+			trace_t	trace;
+
+			if ( pVeh->m_pVehicleInfo->explodeFX )
+			{
+				G_PlayEffect( pVeh->m_pVehicleInfo->explodeFX, parent->currentOrigin );
+				//trace down and place mark
+				VectorCopy( parent->currentOrigin, bottom );
+				bottom[2] -= 80;
+				gi.trace( &trace, parent->currentOrigin, vec3_origin, vec3_origin, bottom, parent->s.number, CONTENTS_SOLID );
+				if ( trace.fraction < 1.0f )
+				{
+					VectorCopy( trace.endpos, bottom );
+					bottom[2] += 2;
+					G_PlayEffect( "ships/ship_explosion_mark", trace.endpos );
+				}
+			}
+
+			parent->takedamage = qfalse;//so we don't recursively damage ourselves
+			if ( pVeh->m_pVehicleInfo->explosionRadius > 0 && pVeh->m_pVehicleInfo->explosionDamage > 0 )
+			{
+				VectorCopy( parent->mins, mins );
+				mins[2] = -4;//to keep it off the ground a *little*
+				VectorCopy( parent->maxs, maxs );
+				VectorCopy( parent->currentOrigin, bottom );
+				bottom[2] += parent->mins[2] - 32;
+				gi.trace( &trace, parent->currentOrigin, mins, maxs, bottom, parent->s.number, CONTENTS_SOLID );
+				G_RadiusDamage( trace.endpos, NULL, pVeh->m_pVehicleInfo->explosionDamage, pVeh->m_pVehicleInfo->explosionRadius, NULL, MOD_EXPLOSIVE );//FIXME: extern damage and radius or base on fuel
+			}
+
+			parent->e_ThinkFunc = thinkF_G_FreeEntity;
+			parent->nextthink = level.time + FRAMETIME;
+		}*/
+	}
+}
+
+// Like a think or move command, this updates various vehicle properties.
+static bool Update( Vehicle_t *pVeh, const usercmd_t *pUcmd )
+{
+	return g_vehicleInfo[VEHICLE_BASE].Update( pVeh, pUcmd );
+}
+#endif //QAGAME
+
+#ifdef _JK2MP
+#include "../namespace_begin.h"
+#endif
+
+//MP RULE - ALL PROCESSMOVECOMMANDS FUNCTIONS MUST BE BG-COMPATIBLE!!!
+//If you really need to violate this rule for SP, then use ifdefs.
+//By BG-compatible, I mean no use of game-specific data - ONLY use
+//stuff available in the MP bgEntity (in SP, the bgEntity is #defined
+//as a gentity, but the MP-compatible access restrictions are based
+//on the bgEntity structure in the MP codebase) -rww
+// ProcessMoveCommands the Vehicle.
+static void ProcessMoveCommands( Vehicle_t *pVeh )
+{
+	/************************************************************************************/
+	/*	BEGIN	Here is where we move the vehicle (forward or back or whatever). BEGIN	*/
+	/************************************************************************************/
+
+	//Client sets ucmds and such for speed alterations
+	float speedInc, speedIdleDec, speedIdle, speedIdleAccel, speedMin, speedMax;
+	float fWalkSpeedMax;
+	int		curTime;
+	bgEntity_t *parent = pVeh->m_pParentEntity;
+#ifdef _JK2MP
+	playerState_t *parentPS = parent->playerState;
+#else
+	playerState_t *parentPS = &parent->client->ps;
+#endif
+
+#ifndef _JK2MP//SP
+	curTime = level.time;
+#elif QAGAME//MP GAME
+	curTime = level.time;
+#elif CGAME//MP CGAME
+	//FIXME: pass in ucmd?  Not sure if this is reliable...
+	curTime = pm->cmd.serverTime;
+#endif
+
+
+#ifndef _JK2MP //bad for prediction - fixme
+	// Bucking so we can't do anything.
+	if ( pVeh->m_ulFlags & VEH_BUCKING || pVeh->m_ulFlags & VEH_FLYING || pVeh->m_ulFlags & VEH_CRASHING )
+	{
+//#ifdef QAGAME //this was in Update above
+//		((gentity_t *)parent)->client->ps.speed = 0;
+//#endif
+		parentPS->speed = 0;
+		return;
+	}
+#endif
+	speedIdleDec = pVeh->m_pVehicleInfo->decelIdle * pVeh->m_fTimeModifier;
+	speedMax = pVeh->m_pVehicleInfo->speedMax;
+
+	speedIdle = pVeh->m_pVehicleInfo->speedIdle;
+	speedIdleAccel = pVeh->m_pVehicleInfo->accelIdle * pVeh->m_fTimeModifier;
+	speedMin = pVeh->m_pVehicleInfo->speedMin;
+
+
+
+	if ( pVeh->m_pPilot /*&& (pilotPS->weapon == WP_NONE || pilotPS->weapon == WP_MELEE )*/ &&
+		(pVeh->m_ucmd.buttons & BUTTON_ALT_ATTACK) && pVeh->m_pVehicleInfo->turboSpeed )
+	{
+		if ((curTime - pVeh->m_iTurboTime)>pVeh->m_pVehicleInfo->turboRecharge)
+		{
+			pVeh->m_iTurboTime = (curTime + pVeh->m_pVehicleInfo->turboDuration);
+#ifndef _JK2MP //kill me now
+			if (pVeh->m_pVehicleInfo->soundTurbo)
+			{
+				G_SoundIndexOnEnt(pVeh->m_pParentEntity, CHAN_AUTO, pVeh->m_pVehicleInfo->soundTurbo);
+			}
+#endif
+			parentPS->speed = pVeh->m_pVehicleInfo->turboSpeed;	// Instantly Jump To Turbo Speed
+		}
+	}
+
+	if ( curTime < pVeh->m_iTurboTime )
+	{
+		speedMax = pVeh->m_pVehicleInfo->turboSpeed;
+	}
+	else
+	{
+		speedMax = pVeh->m_pVehicleInfo->speedMax;
+	}
+
+#ifdef _JK2MP
+	if ( !parentPS->m_iVehicleNum  )
+#else
+	if ( !pVeh->m_pVehicleInfo->Inhabited( pVeh ) )
+#endif
+	{//drifts to a stop
+		speedInc = speedIdle * pVeh->m_fTimeModifier;
+		VectorClear( parentPS->moveDir );
+		//m_ucmd.forwardmove = 127;
+		parentPS->speed = 0;
+	}
+	else
+	{
+		speedInc = pVeh->m_pVehicleInfo->acceleration * pVeh->m_fTimeModifier;
+	}
+
+	if ( parentPS->speed || parentPS->groundEntityNum == ENTITYNUM_NONE  ||
+		 pVeh->m_ucmd.forwardmove || pVeh->m_ucmd.upmove > 0 )
+	{ 
+		if ( pVeh->m_ucmd.forwardmove > 0 && speedInc )
+		{
+			parentPS->speed += speedInc;
+		}
+		else if ( pVeh->m_ucmd.forwardmove < 0 )
+		{
+			if ( parentPS->speed > speedIdle )
+			{
+				parentPS->speed -= speedInc;
+			}
+			else if ( parentPS->speed > speedMin )
+			{
+				parentPS->speed -= speedIdleDec;
+			}
+		}
+		// No input, so coast to stop.
+		else if ( parentPS->speed > 0.0f )
+		{
+			parentPS->speed -= speedIdleDec;
+			if ( parentPS->speed < 0.0f )
+			{
+				parentPS->speed = 0.0f;
+			}
+		}
+		else if ( parentPS->speed < 0.0f )
+		{
+			parentPS->speed += speedIdleDec;
+			if ( parentPS->speed > 0.0f )
+			{
+				parentPS->speed = 0.0f;
+			}
+		}
+	}
+	else
+	{
+		if ( pVeh->m_ucmd.forwardmove < 0 )
+		{
+			pVeh->m_ucmd.forwardmove = 0;
+		}
+		if ( pVeh->m_ucmd.upmove < 0 )
+		{
+			pVeh->m_ucmd.upmove = 0;
+		}
+
+		//pVeh->m_ucmd.rightmove = 0;
+
+		/*if ( !pVeh->m_pVehicleInfo->strafePerc 
+			|| (!g_speederControlScheme->value && !parent->s.number) )
+		{//if in a strafe-capable vehicle, clear strafing unless using alternate control scheme
+			pVeh->m_ucmd.rightmove = 0;
+		}*/
+	}
+
+	fWalkSpeedMax = speedMax * 0.275f;
+	if ( curTime>pVeh->m_iTurboTime && (pVeh->m_ucmd.buttons & BUTTON_WALKING) && parentPS->speed > fWalkSpeedMax )
+	{
+		parentPS->speed = fWalkSpeedMax;
+	}
+	else if ( parentPS->speed > speedMax )
+	{
+		parentPS->speed = speedMax;
+	}
+	else if ( parentPS->speed < speedMin )
+	{
+		parentPS->speed = speedMin;
+	}
+
+	/********************************************************************************/
+	/*	END Here is where we move the vehicle (forward or back or whatever). END	*/
+	/********************************************************************************/
+}
+
+//MP RULE - ALL PROCESSORIENTCOMMANDS FUNCTIONS MUST BE BG-COMPATIBLE!!!
+//If you really need to violate this rule for SP, then use ifdefs.
+//By BG-compatible, I mean no use of game-specific data - ONLY use
+//stuff available in the MP bgEntity (in SP, the bgEntity is #defined
+//as a gentity, but the MP-compatible access restrictions are based
+//on the bgEntity structure in the MP codebase) -rww
+// ProcessOrientCommands the Vehicle.
+static void ProcessOrientCommands( Vehicle_t *pVeh )
+{
+	/********************************************************************************/
+	/*	BEGIN	Here is where make sure the vehicle is properly oriented.	BEGIN	*/
+	/********************************************************************************/
+	bgEntity_t *parent = pVeh->m_pParentEntity;
+	playerState_t *parentPS, *riderPS;
+	
+#ifdef _JK2MP
+	bgEntity_t *rider = NULL;
+	if (parent->s.owner != ENTITYNUM_NONE)
+	{
+		rider = PM_BGEntForNum(parent->s.owner); //&g_entities[parent->r.ownerNum];
+	}
+#else
+	gentity_t *rider = parent->owner;
+#endif
+
+	// Bucking so we can't do anything.
+#ifndef _JK2MP //bad for prediction - fixme
+	if ( pVeh->m_ulFlags & VEH_BUCKING || pVeh->m_ulFlags & VEH_FLYING || pVeh->m_ulFlags & VEH_CRASHING )
+	{
+		return;
+	}
+#endif
+
+#ifdef _JK2MP
+	if ( !rider )
+#else
+	if ( !rider || !rider->client )
+#endif
+	{
+		rider = parent;
+	}
+
+
+
+#ifdef _JK2MP
+	parentPS = parent->playerState;
+	riderPS = rider->playerState;
+#else
+	parentPS = &parent->client->ps;
+	riderPS = &rider->client->ps;
+#endif
+
+	if (rider)
+	{
+#ifdef _JK2MP
+	float angDif = AngleSubtract(pVeh->m_vOrientation[YAW], riderPS->viewangles[YAW]);
+	if (parentPS && parentPS->speed)
+	{
+		float s = parentPS->speed;
+		float maxDif = pVeh->m_pVehicleInfo->turningSpeed*4.0f; //magic number hackery
+		if (s < 0.0f)
+		{
+			s = -s;
+		}
+		angDif *= s/pVeh->m_pVehicleInfo->speedMax;
+		if (angDif > maxDif)
+		{
+			angDif = maxDif;
+		}
+		else if (angDif < -maxDif)
+		{
+			angDif = -maxDif;
+		}
+		pVeh->m_vOrientation[YAW] = AngleNormalize180(pVeh->m_vOrientation[YAW] - angDif*(pVeh->m_fTimeModifier*0.2f));
+	}
+#else
+		pVeh->m_vOrientation[YAW] = riderPS->viewangles[YAW];
+#endif
+	}
+
+
+/*	speed = VectorLength( parentPS->velocity );
+
+	// If the player is the rider...
+	if ( rider->s.number < MAX_CLIENTS )
+	{//FIXME: use the vehicle's turning stat in this calc
+		pVeh->m_vOrientation[YAW] = riderPS->viewangles[YAW];
+	}
+	else
+	{
+		float turnSpeed = pVeh->m_pVehicleInfo->turningSpeed;
+		if ( !pVeh->m_pVehicleInfo->turnWhenStopped 
+			&& !parentPS->speed )//FIXME: or !pVeh->m_ucmd.forwardmove?
+		{//can't turn when not moving
+			//FIXME: or ramp up to max turnSpeed?
+			turnSpeed = 0.0f;
+		}
+#ifdef _JK2MP
+		if (rider->s.eType == ET_NPC)
+#else
+		if ( !rider || rider->NPC )
+#endif
+		{//help NPCs out some
+			turnSpeed *= 2.0f;
+#ifdef _JK2MP
+			if (parentPS->speed > 200.0f)
+#else
+			if ( parent->client->ps.speed > 200.0f )
+#endif
+			{
+				turnSpeed += turnSpeed * parentPS->speed/200.0f*0.05f;
+			}
+		}
+		turnSpeed *= pVeh->m_fTimeModifier;
+
+		//default control scheme: strafing turns, mouselook aims
+		if ( pVeh->m_ucmd.rightmove < 0 )
+		{
+			pVeh->m_vOrientation[YAW] += turnSpeed;
+		}
+		else if ( pVeh->m_ucmd.rightmove > 0 )
+		{
+			pVeh->m_vOrientation[YAW] -= turnSpeed;
+		}
+
+		if ( pVeh->m_pVehicleInfo->malfunctionArmorLevel && pVeh->m_iArmor <= pVeh->m_pVehicleInfo->malfunctionArmorLevel )
+		{//damaged badly
+		}
+	}*/
+
+	/********************************************************************************/
+	/*	END	Here is where make sure the vehicle is properly oriented.	END			*/
+	/********************************************************************************/
+}
+
+#ifdef _JK2MP //temp hack til mp speeder controls are sorted -rww
+void AnimalProcessOri(Vehicle_t *pVeh)
+{
+	ProcessOrientCommands(pVeh);
+}
+#endif
+
+#ifdef QAGAME //back to our game-only functions
+static void AnimateVehicle( Vehicle_t *pVeh )
+{
+	animNumber_t	Anim = BOTH_VT_IDLE; 
+	int				iFlags = SETANIM_FLAG_NORMAL, iBlend = 300;
+	gentity_t *		pilot = (gentity_t *)pVeh->m_pPilot;
+	gentity_t *		parent = (gentity_t *)pVeh->m_pParentEntity;
+	playerState_t *	pilotPS;
+	playerState_t *	parentPS;
+	float			fSpeedPercToMax;
+
+#ifdef _JK2MP
+	pilotPS = (pilot)?(pilot->playerState):(0);
+	parentPS = parent->playerState;
+#else
+	pilotPS = (pilot)?(&pilot->client->ps):(0);
+	parentPS = &parent->client->ps;
+#endif
+
+	// We're dead (boarding is reused here so I don't have to make another variable :-).
+	if ( parent->health <= 0 ) 
+	{
+		/*
+		if ( pVeh->m_iBoarding != -999 )	// Animate the death just once!
+		{
+			pVeh->m_iBoarding = -999;
+			iFlags = SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLD; 
+
+			// FIXME! Why do you keep repeating over and over!!?!?!? Bastard!
+			//Vehicle_SetAnim( parent, SETANIM_LEGS, BOTH_VT_DEATH1, iFlags, iBlend );
+		}
+		*/
+		return;
+	}
+
+	// If they're bucking, play the animation and leave...
+	if ( parent->client->ps.legsAnim == BOTH_VT_BUCK )
+	{
+		// Done with animation? Erase the flag.
+		if ( parent->client->ps.legsAnimTimer <= 0 )
+		{
+			pVeh->m_ulFlags &= ~VEH_BUCKING;
+		}
+		else
+		{
+			return;
+		}
+	}
+	else if ( pVeh->m_ulFlags & VEH_BUCKING )
+	{
+		iFlags = SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLD;
+		Anim = BOTH_VT_BUCK;
+		iBlend = 500;
+		Vehicle_SetAnim( parent, SETANIM_LEGS, BOTH_VT_BUCK, iFlags, iBlend );
+		return;
+	}
+
+	// Boarding animation.
+	if ( pVeh->m_iBoarding != 0 )
+	{
+		// We've just started boarding, set the amount of time it will take to finish boarding.
+		if ( pVeh->m_iBoarding < 0 )
+		{
+			int iAnimLen;
+
+			// Boarding from left...
+			if ( pVeh->m_iBoarding == -1 )
+			{
+				Anim = BOTH_VT_MOUNT_L;
+			}
+			else if ( pVeh->m_iBoarding == -2 )
+			{
+				Anim = BOTH_VT_MOUNT_R;
+			}
+			else if ( pVeh->m_iBoarding == -3 )
+			{
+				Anim = BOTH_VT_MOUNT_B;
+			}
+
+			// Set the delay time (which happens to be the time it takes for the animation to complete).
+			// NOTE: Here I made it so the delay is actually 70% (0.7f) of the animation time.
+#ifdef _JK2MP
+			iAnimLen = BG_AnimLength( parent->localAnimIndex, Anim ) * 0.7f;
+#else
+			iAnimLen = PM_AnimLength( parent->client->clientInfo.animFileIndex, Anim ) * 0.7f;
+#endif
+			pVeh->m_iBoarding = level.time + iAnimLen;
+
+			// Set the animation, which won't be interrupted until it's completed.
+			// TODO: But what if he's killed? Should the animation remain persistant???
+			iFlags = SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLD;
+
+			Vehicle_SetAnim( parent, SETANIM_LEGS, Anim, iFlags, iBlend );
+			if (pilot)
+			{
+				Vehicle_SetAnim(pilot, SETANIM_BOTH, Anim, iFlags, iBlend );
+			}
+			return;
+		}
+		// Otherwise we're done.
+		else if ( pVeh->m_iBoarding <= level.time )
+		{
+			pVeh->m_iBoarding = 0;
+		}
+	}
+
+	// Percentage of maximum speed relative to current speed.
+	//float fSpeed = VectorLength( client->ps.velocity );
+	fSpeedPercToMax = parent->client->ps.speed / pVeh->m_pVehicleInfo->speedMax; 
+
+
+	// Going in reverse...
+	if ( fSpeedPercToMax < -0.01f )
+	{
+		Anim = BOTH_VT_WALK_REV;
+		iBlend = 600;
+	}
+	else
+	{
+		bool		Turbo		= (fSpeedPercToMax>0.0f && level.time<pVeh->m_iTurboTime);
+		bool		Walking		= (fSpeedPercToMax>0.0f && ((pVeh->m_ucmd.buttons&BUTTON_WALKING) || fSpeedPercToMax<=0.275f));
+		bool		Running		= (fSpeedPercToMax>0.275f);
+
+
+		// Remove Crashing Flag
+		//----------------------
+		pVeh->m_ulFlags &= ~VEH_CRASHING;
+
+		if (Turbo)
+		{// Kicked In Turbo
+			iBlend	= 50;
+			iFlags	= SETANIM_FLAG_OVERRIDE;
+			Anim	= BOTH_VT_TURBO;
+		}
+		else
+		{// No Special Moves
+			iBlend	= 300;
+ 			iFlags	= SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLDLESS;
+			Anim	= (Walking)?(BOTH_VT_WALK_FWD  ):((Running)?(BOTH_VT_RUN_FWD  ):(BOTH_VT_IDLE1));
+		}
+	}
+	Vehicle_SetAnim( parent, SETANIM_LEGS, Anim, iFlags, iBlend );
+}
+
+//rwwFIXMEFIXME: This is all going to have to be predicted I think, or it will feel awful
+//and lagged
+// This function makes sure that the rider's in this vehicle are properly animated.
+static void AnimateRiders( Vehicle_t *pVeh )
+{
+	animNumber_t Anim = BOTH_VT_IDLE;
+	int iFlags = SETANIM_FLAG_NORMAL, iBlend = 500;
+	gentity_t *pilot = (gentity_t *)pVeh->m_pPilot;
+	gentity_t *parent = (gentity_t *)pVeh->m_pParentEntity;
+	playerState_t *pilotPS;
+	playerState_t *parentPS;
+	float fSpeedPercToMax;
+
+#ifdef _JK2MP
+	pilotPS = pVeh->m_pPilot->playerState;
+	parentPS = pVeh->m_pPilot->playerState;
+#else
+	pilotPS = &pVeh->m_pPilot->client->ps;
+	parentPS = &pVeh->m_pParentEntity->client->ps;
+#endif
+
+	// Boarding animation.
+	if ( pVeh->m_iBoarding != 0 )
+	{
+		return;
+	}
+
+	// Percentage of maximum speed relative to current speed.
+	fSpeedPercToMax = parent->client->ps.speed / pVeh->m_pVehicleInfo->speedMax;
+
+	// Going in reverse...
+#ifdef _JK2MP //handled in pmove in mp
+	if (0)
+#else
+	if ( fSpeedPercToMax < -0.01f )
+#endif
+	{
+		Anim = BOTH_VT_WALK_REV;
+		iBlend = 600;
+	}
+	else
+	{
+		bool		HasWeapon	= ((pilotPS->weapon != WP_NONE) && (pilotPS->weapon != WP_MELEE));
+		bool		Attacking	= (HasWeapon && !!(pVeh->m_ucmd.buttons&BUTTON_ATTACK));
+		bool		Right		= (pVeh->m_ucmd.rightmove>0);
+		bool		Left		= (pVeh->m_ucmd.rightmove<0);
+		bool		Turbo		= (fSpeedPercToMax>0.0f && level.time<pVeh->m_iTurboTime);
+		bool		Walking		= (fSpeedPercToMax>0.0f && ((pVeh->m_ucmd.buttons&BUTTON_WALKING) || fSpeedPercToMax<=0.275f));
+		bool		Running		= (fSpeedPercToMax>0.275f);
+		EWeaponPose	WeaponPose	= WPOSE_NONE;
+
+
+		// Remove Crashing Flag
+		//----------------------
+		pVeh->m_ulFlags &= ~VEH_CRASHING;
+
+
+		// Put Away Saber When It Is Not Active
+		//--------------------------------------
+#ifndef _JK2MP
+		if (HasWeapon && (Turbo || (pilotPS->weapon==WP_SABER && !pilotPS->SaberActive())))
+		{
+			if (pVeh->m_pPilot->s.number<MAX_CLIENTS)
+			{
+				CG_ChangeWeapon(WP_NONE);
+			}
+
+			pVeh->m_pPilot->client->ps.weapon = WP_NONE;
+			G_RemoveWeaponModels(pVeh->m_pPilot);
+		}
+#endif
+
+		// Don't Interrupt Attack Anims
+		//------------------------------
+#ifdef _JK2MP
+		if (pilotPS->weaponTime>0)
+		{
+			return;
+		}
+#else		
+		if (pilotPS->torsoAnim>=BOTH_VT_ATL_S && pilotPS->torsoAnim<=BOTH_VT_ATF_G)
+		{
+			float		bodyCurrent	  = 0.0f;
+			int			bodyEnd		  = 0;
+			if (!!gi.G2API_GetBoneAnimIndex(&pVeh->m_pPilot->ghoul2[pVeh->m_pPilot->playerModel], pVeh->m_pPilot->rootBone, level.time, &bodyCurrent, NULL, &bodyEnd, NULL, NULL, NULL))
+			{
+				if (bodyCurrent<=((float)(bodyEnd)-1.5f))
+				{
+					return;
+				}
+			}
+		}
+#endif
+
+		// Compute The Weapon Pose
+		//--------------------------
+		if (pilotPS->weapon==WP_BLASTER)
+		{
+			WeaponPose = WPOSE_BLASTER;
+		}
+		else if (pilotPS->weapon==WP_SABER)
+		{
+			if ( (pVeh->m_ulFlags&VEH_SABERINLEFTHAND) && pilotPS->torsoAnim==BOTH_VT_ATL_TO_R_S)
+			{
+				pVeh->m_ulFlags	&= ~VEH_SABERINLEFTHAND;
+			}
+			if (!(pVeh->m_ulFlags&VEH_SABERINLEFTHAND) && pilotPS->torsoAnim==BOTH_VT_ATR_TO_L_S)
+			{
+				pVeh->m_ulFlags	|=  VEH_SABERINLEFTHAND;
+			}
+			WeaponPose = (pVeh->m_ulFlags&VEH_SABERINLEFTHAND)?(WPOSE_SABERLEFT):(WPOSE_SABERRIGHT);
+		}
+		
+
+ 		if (Attacking && WeaponPose)
+		{// Attack!
+			iBlend	= 100;
+ 			iFlags	= SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD|SETANIM_FLAG_RESTART;
+
+			if (Turbo)
+			{
+				Right = true;
+				Left = false;
+			}
+
+			// Auto Aiming
+			//===============================================
+			if (!Left && !Right)		// Allow player strafe keys to override
+			{
+#ifndef _JK2MP
+				if (pVeh->m_pPilot->enemy)
+				{
+					vec3_t	toEnemy;
+					float	toEnemyDistance;
+					vec3_t	actorRight;
+					float	actorRightDot;
+
+					VectorSubtract(pVeh->m_pPilot->currentOrigin, pVeh->m_pPilot->enemy->currentOrigin, toEnemy);
+					toEnemyDistance = VectorNormalize(toEnemy);
+
+					AngleVectors(pVeh->m_pParentEntity->currentAngles, 0, actorRight, 0);
+					actorRightDot = DotProduct(toEnemy, actorRight);
+
+	 				if (fabsf(actorRightDot)>0.5f || pilotPS->weapon==WP_SABER)
+					{
+						Left	= (actorRightDot>0.0f);
+						Right	= !Left;
+					}
+					else
+					{
+						Right = Left = false;
+					}
+				}
+				else
+#endif
+				if (pilotPS->weapon==WP_SABER && !Left && !Right)
+				{
+					Left = (WeaponPose==WPOSE_SABERLEFT);
+					Right	= !Left;
+				}
+			}
+
+
+			if (Left)
+			{// Attack Left
+				switch(WeaponPose)
+				{
+				case WPOSE_BLASTER:		Anim = BOTH_VT_ATL_G;		break;
+				case WPOSE_SABERLEFT:	Anim = BOTH_VT_ATL_S;		break;
+				case WPOSE_SABERRIGHT:	Anim = BOTH_VT_ATR_TO_L_S;	break;
+				default:				assert(0);
+				}
+			}
+			else if (Right)
+			{// Attack Right
+				switch(WeaponPose)
+				{
+				case WPOSE_BLASTER:		Anim = BOTH_VT_ATR_G;		break;
+				case WPOSE_SABERLEFT:	Anim = BOTH_VT_ATL_TO_R_S;	break;
+				case WPOSE_SABERRIGHT:	Anim = BOTH_VT_ATR_S;		break;
+				default:				assert(0);
+				}
+			}
+			else
+			{// Attack Ahead
+				switch(WeaponPose)
+				{
+				case WPOSE_BLASTER:		Anim = BOTH_VT_ATF_G;		break;
+				default:				assert(0);
+				}
+			}
+		}
+		else if (Turbo)
+		{// Kicked In Turbo
+			iBlend	= 50;
+			iFlags	= SETANIM_FLAG_OVERRIDE;
+			Anim	= BOTH_VT_TURBO;
+		}
+		else
+		{// No Special Moves
+			iBlend	= 300;
+ 			iFlags	= SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLDLESS;
+
+			if (WeaponPose==WPOSE_NONE)
+			{
+				if (Walking)
+				{
+					Anim = BOTH_VT_WALK_FWD;
+				}
+				else if (Running)
+				{
+					Anim = BOTH_VT_RUN_FWD;
+				}
+				else
+				{
+					Anim = BOTH_VT_IDLE1;//(Q_irand(0,1)==0)?(BOTH_VT_IDLE):(BOTH_VT_IDLE1);
+				}
+			}
+			else
+			{
+				switch(WeaponPose)
+				{
+				case WPOSE_BLASTER:		Anim = BOTH_VT_IDLE_G;			break;
+				case WPOSE_SABERLEFT:	Anim = BOTH_VT_IDLE_SL;			break;
+				case WPOSE_SABERRIGHT:	Anim = BOTH_VT_IDLE_SR;			break;
+				default:				assert(0);
+				}
+			}
+		}// No Special Moves
+	}
+
+	Vehicle_SetAnim( pilot, SETANIM_BOTH, Anim, iFlags, iBlend );
+}
+#endif //QAGAME
+
+#ifndef QAGAME
+void AttachRidersGeneric( Vehicle_t *pVeh );
+#endif
+
+//on the client this function will only set up the process command funcs
+void G_SetAnimalVehicleFunctions( vehicleInfo_t *pVehInfo )
+{
+#ifdef QAGAME
+	pVehInfo->AnimateVehicle			=		AnimateVehicle;
+	pVehInfo->AnimateRiders				=		AnimateRiders;
+//	pVehInfo->ValidateBoard				=		ValidateBoard;
+//	pVehInfo->SetParent					=		SetParent;
+//	pVehInfo->SetPilot					=		SetPilot;
+//	pVehInfo->AddPassenger				=		AddPassenger;
+//	pVehInfo->Animate					=		Animate;
+//	pVehInfo->Board						=		Board;
+//	pVehInfo->Eject						=		Eject;
+//	pVehInfo->EjectAll					=		EjectAll;
+//	pVehInfo->StartDeathDelay			=		StartDeathDelay;
+	pVehInfo->DeathUpdate				=		DeathUpdate;
+//	pVehInfo->RegisterAssets			=		RegisterAssets;
+//	pVehInfo->Initialize				=		Initialize;
+	pVehInfo->Update					=		Update;
+//	pVehInfo->UpdateRider				=		UpdateRider;
+#endif //QAGAME
+	pVehInfo->ProcessMoveCommands		=		ProcessMoveCommands;
+	pVehInfo->ProcessOrientCommands		=		ProcessOrientCommands;
+
+#ifndef QAGAME //cgame prediction attachment func
+	pVehInfo->AttachRiders				=		AttachRidersGeneric;
+#endif
+//	pVehInfo->AttachRiders				=		AttachRiders;
+//	pVehInfo->Ghost						=		Ghost;
+//	pVehInfo->UnGhost					=		UnGhost;
+//	pVehInfo->Inhabited					=		Inhabited;
+}
+
+// Following is only in game, not in namespace
+#ifdef _JK2MP
+#include "../namespace_end.h"
+#endif
+
+#ifdef QAGAME
+extern void G_AllocateVehicleObject(Vehicle_t **pVeh);
+#endif
+
+#ifdef _JK2MP
+#include "../namespace_begin.h"
+#endif
+
+// Create/Allocate a new Animal Vehicle (initializing it as well).
+//this is a BG function too in MP so don't un-bg-compatibilify it -rww
+void G_CreateAnimalNPC( Vehicle_t **pVeh, const char *strAnimalType )
+{
+	// Allocate the Vehicle.
+#ifdef _JK2MP
+#ifdef QAGAME
+	//these will remain on entities on the client once allocated because the pointer is
+	//never stomped. on the server, however, when an ent is freed, the entity struct is
+	//memset to 0, so this memory would be lost..
+    G_AllocateVehicleObject(pVeh);
+#else
+	if (!*pVeh)
+	{ //only allocate a new one if we really have to
+		(*pVeh) = (Vehicle_t *) BG_Alloc( sizeof(Vehicle_t) );
+	}
+#endif
+	memset(*pVeh, 0, sizeof(Vehicle_t));
+	(*pVeh)->m_pVehicleInfo = &g_vehicleInfo[BG_VehicleGetIndex( strAnimalType )];
+#else
+	(*pVeh) = (Vehicle_t *) gi.Malloc( sizeof(Vehicle_t), TAG_G_ALLOC, qtrue );
+	(*pVeh)->m_pVehicleInfo = &g_vehicleInfo[BG_VehicleGetIndex( strAnimalType )];
+#endif
+}
+
+#ifdef _JK2MP
+
+#include "../namespace_end.h"
+
+//get rid of all the crazy defs we added for this file
+#undef currentAngles
+#undef currentOrigin
+#undef mins
+#undef maxs
+#undef legsAnimTimer
+#undef torsoAnimTimer
+#undef bool
+#undef false
+#undef true
+
+#undef sqrtf
+#undef Q_flrand
+
+#undef MOD_EXPLOSIVE
+#endif
diff --git a/codemp/game/FighterNPC.c b/codemp/game/FighterNPC.c
new file mode 100644
index 0000000..c694b76
--- /dev/null
+++ b/codemp/game/FighterNPC.c
@@ -0,0 +1,1961 @@
+// leave this line at the top for all g_xxxx.cpp files...
+#include "g_headers.h"
+
+//seems to be a compiler bug, it doesn't clean out the #ifdefs between dif-compiles
+//or something, so the headers spew errors on these defs from the previous compile.
+//this fixes that. -rww
+#ifdef _JK2MP
+//get rid of all the crazy defs we added for this file
+#undef currentAngles
+#undef currentOrigin
+#undef mins
+#undef maxs
+#undef legsAnimTimer
+#undef torsoAnimTimer
+#undef bool
+#undef false
+#undef true
+
+#undef sqrtf
+#undef Q_flrand
+
+#undef MOD_EXPLOSIVE
+#endif
+
+#ifdef _JK2 //SP does not have this preprocessor for game like MP does
+#ifndef _JK2MP
+#define _JK2MP
+#endif
+#endif
+
+#ifndef _JK2MP //if single player
+#ifndef QAGAME //I don't think we have a QAGAME define
+#define QAGAME //but define it cause in sp we're always in the game
+#endif
+#endif
+
+#ifdef QAGAME //including game headers on cgame is FORBIDDEN ^_^
+#include "g_local.h"
+#elif defined _JK2MP
+#include "bg_public.h"
+#endif
+
+#ifndef _JK2MP
+#include "g_functions.h"
+#include "g_vehicles.h"
+#else
+#include "bg_vehicles.h"
+#endif
+
+#ifdef _JK2MP
+//this is really horrible, but it works! just be sure not to use any locals or anything
+//with these names (exluding bool, false, true). -rww
+#define currentAngles r.currentAngles
+#define currentOrigin r.currentOrigin
+#define mins r.mins
+#define maxs r.maxs
+#define legsAnimTimer legsTimer
+#define torsoAnimTimer torsoTimer
+#define bool qboolean
+#define false qfalse
+#define true qtrue
+
+#define sqrtf sqrt
+#define Q_flrand flrand
+
+#define MOD_EXPLOSIVE MOD_SUICIDE
+#else
+#define bgEntity_t gentity_t
+#endif
+
+extern float DotToSpot( vec3_t spot, vec3_t from, vec3_t fromAngles );
+#ifdef QAGAME //SP or gameside MP
+extern vmCvar_t	cg_thirdPersonAlpha;
+extern vec3_t playerMins;
+extern vec3_t playerMaxs;
+extern cvar_t	*g_speederControlScheme;
+extern void ChangeWeapon( gentity_t *ent, int newWeapon );
+extern void PM_SetAnim(pmove_t	*pm,int setAnimParts,int anim,int setAnimFlags, int blendTime);
+extern int PM_AnimLength( int index, animNumber_t anim );
+extern void G_VehicleTrace( trace_t *results, const vec3_t start, const vec3_t tMins, const vec3_t tMaxs, const vec3_t end, int passEntityNum, int contentmask );
+#endif
+
+extern qboolean BG_UnrestrainedPitchRoll( playerState_t *ps, Vehicle_t *pVeh );
+
+#ifdef _JK2MP
+
+#include "../namespace_begin.h"
+
+extern void BG_SetAnim(playerState_t *ps, animation_t *animations, int setAnimParts,int anim,int setAnimFlags, int blendTime);
+extern int BG_GetTime(void);
+#endif
+
+extern void BG_ExternThisSoICanRecompileInDebug( Vehicle_t *pVeh, playerState_t *riderPS );
+
+//this stuff has got to be predicted, so..
+bool BG_FighterUpdate(Vehicle_t *pVeh, const usercmd_t *pUcmd, vec3_t trMins, vec3_t trMaxs, float gravity,
+					  void (*traceFunc)( trace_t *results, const vec3_t start, const vec3_t lmins, const vec3_t lmaxs, const vec3_t end, int passEntityNum, int contentMask ))
+{
+	vec3_t		bottom;
+	playerState_t *parentPS;
+	qboolean	isDead = qfalse;
+#ifdef QAGAME //don't do this on client
+	int i;
+
+	// Make sure the riders are not visible or collidable.
+	pVeh->m_pVehicleInfo->Ghost( pVeh, pVeh->m_pPilot );
+	for ( i = 0; i < pVeh->m_pVehicleInfo->maxPassengers; i++ )
+	{
+		pVeh->m_pVehicleInfo->Ghost( pVeh, pVeh->m_ppPassengers[i] );
+	}
+#endif
+
+
+#ifdef _JK2MP
+	parentPS = pVeh->m_pParentEntity->playerState;
+#else
+	parentPS = &pVeh->m_pParentEntity->client->ps;
+#endif
+
+	if (!parentPS)
+	{
+		Com_Error(ERR_DROP, "NULL PS in BG_FighterUpdate (%s)", pVeh->m_pVehicleInfo->name);
+		return false;
+	}
+
+	// If we have a pilot, take out gravity (it's a flying craft...).
+	if ( pVeh->m_pPilot )
+	{
+		parentPS->gravity = 0;
+#ifndef _JK2MP //don't need this flag in mp, I.. guess
+		pVeh->m_pParentEntity->svFlags |= SVF_CUSTOM_GRAVITY;
+#endif
+	}
+	else
+	{
+#ifndef _JK2MP //don't need this flag in mp, I.. guess
+		pVeh->m_pParentEntity->svFlags &= ~SVF_CUSTOM_GRAVITY;
+#else //in MP set grav back to normal gravity
+		if (pVeh->m_pVehicleInfo->gravity)
+		{
+			parentPS->gravity = pVeh->m_pVehicleInfo->gravity;
+		}
+		else
+		{ //it doesn't have gravity specified apparently
+			parentPS->gravity = gravity;
+		}
+#endif
+	}
+
+#ifdef _JK2MP
+	isDead = (qboolean)((parentPS->eFlags&EF_DEAD)!=0);
+#else
+	isDead = (parentPS->stats[STAT_HEALTH] <= 0 );
+#endif
+
+	/*
+	if ( isDead || 
+		(pVeh->m_pVehicleInfo->surfDestruction &&
+			pVeh->m_iRemovedSurfaces ) )
+	{//can't land if dead or spiralling out of control
+		pVeh->m_LandTrace.fraction = 1.0f;
+		pVeh->m_LandTrace.contents = pVeh->m_LandTrace.surfaceFlags = 0;
+		VectorClear( pVeh->m_LandTrace.plane.normal );
+		pVeh->m_LandTrace.allsolid = qfalse;
+		pVeh->m_LandTrace.startsolid = qfalse;
+	}
+	else
+	{
+	*/
+	//argh, no, I need to have a way to see when they impact the ground while damaged. -rww
+
+		// Check to see if the fighter has taken off yet (if it's a certain height above ground).
+		VectorCopy( parentPS->origin, bottom );
+		bottom[2] -= pVeh->m_pVehicleInfo->landingHeight;
+
+		traceFunc( &pVeh->m_LandTrace, parentPS->origin, trMins, trMaxs, bottom, pVeh->m_pParentEntity->s.number, (MASK_NPCSOLID&~CONTENTS_BODY) );
+	//}
+
+	return true;
+}
+
+#ifdef QAGAME //ONLY in SP or on server, not cgame
+
+// Like a think or move command, this updates various vehicle properties.
+static bool Update( Vehicle_t *pVeh, const usercmd_t *pUcmd )
+{
+	assert(pVeh->m_pParentEntity);
+	if (!BG_FighterUpdate(pVeh, pUcmd, ((gentity_t *)pVeh->m_pParentEntity)->mins,
+		((gentity_t *)pVeh->m_pParentEntity)->maxs, 
+#ifdef _JK2MP
+		g_gravity.value,
+#else
+		g_gravity->value,
+#endif
+		G_VehicleTrace))
+	{
+		return false;
+	}
+
+	if ( !g_vehicleInfo[VEHICLE_BASE].Update( pVeh, pUcmd ) )
+	{
+		return false;
+	}
+
+	return true;
+}
+
+// Board this Vehicle (get on). The first entity to board an empty vehicle becomes the Pilot.
+static bool Board( Vehicle_t *pVeh, bgEntity_t *pEnt )
+{
+	if ( !g_vehicleInfo[VEHICLE_BASE].Board( pVeh, pEnt ) )
+		return false;
+
+	// Set the board wait time (they won't be able to do anything, including getting off, for this amount of time).
+	pVeh->m_iBoarding = level.time + 1500;
+
+	return true;
+}
+
+// Eject an entity from the vehicle.
+static bool Eject( Vehicle_t *pVeh, bgEntity_t *pEnt, qboolean forceEject )
+{
+	if ( g_vehicleInfo[VEHICLE_BASE].Eject( pVeh, pEnt, forceEject ) )
+	{
+		return true;
+	}
+	
+	return false;
+}
+
+#endif //end game-side only
+
+//method of decrementing the given angle based on the given taking variable frame times into account
+static float PredictedAngularDecrement(float scale, float timeMod, float originalAngle)
+{
+	float fixedBaseDec = originalAngle*0.05f;
+	float r = 0.0f;
+
+	if (fixedBaseDec < 0.0f)
+	{
+		fixedBaseDec = -fixedBaseDec;
+	}
+	
+	fixedBaseDec *= (1.0f+(1.0f-scale));
+
+	if (fixedBaseDec < 0.1f)
+	{ //don't increment in incredibly small fractions, it would eat up unnecessary bandwidth.
+		fixedBaseDec = 0.1f;
+	}
+
+	fixedBaseDec *= (timeMod*0.1f);
+	if (originalAngle > 0.0f)
+	{ //subtract
+		r = (originalAngle-fixedBaseDec);
+		if (r < 0.0f)
+		{
+			r = 0.0f;
+		}
+	}
+	else if (originalAngle < 0.0f)
+	{ //add
+		r = (originalAngle+fixedBaseDec);
+		if (r > 0.0f)
+		{
+			r = 0.0f;
+		}
+	}
+
+	return r;
+}
+
+#ifdef QAGAME//only do this check on GAME side, because if it's CGAME, it's being predicted, and it's only predicted if the local client is the driver
+qboolean FighterIsInSpace( gentity_t *gParent )
+{
+	if ( gParent 
+		&& gParent->client 
+		&& gParent->client->inSpaceIndex
+		&& gParent->client->inSpaceIndex < ENTITYNUM_WORLD )
+	{
+		return qtrue;
+	}
+	return qfalse;
+}
+#endif
+
+qboolean FighterOverValidLandingSurface( Vehicle_t *pVeh )
+{
+	if ( pVeh->m_LandTrace.fraction < 1.0f //ground present
+		&& pVeh->m_LandTrace.plane.normal[2] >= MIN_LANDING_SLOPE )//flat enough
+		//FIXME: also check for a certain surface flag ... "landing zones"?
+	{
+		return qtrue;
+	}
+	return qfalse;
+}
+
+qboolean FighterIsLanded( Vehicle_t *pVeh, playerState_t *parentPS )
+{
+	if ( FighterOverValidLandingSurface( pVeh )
+		&& !parentPS->speed )//stopped
+	{
+		return qtrue;
+	}
+	return qfalse;
+}
+
+qboolean FighterIsLanding( Vehicle_t *pVeh, playerState_t *parentPS )
+{
+
+	if ( FighterOverValidLandingSurface( pVeh )
+#ifdef QAGAME//only do this check on GAME side, because if it's CGAME, it's being predicted, and it's only predicted if the local client is the driver
+		&& pVeh->m_pVehicleInfo->Inhabited( pVeh )//has to have a driver in order to be capable of landing
+#endif
+		&& (pVeh->m_ucmd.forwardmove < 0||pVeh->m_ucmd.upmove<0) //decelerating or holding crouch button
+		&& parentPS->speed <= MIN_LANDING_SPEED )//going slow enough to start landing - was using pVeh->m_pVehicleInfo->speedIdle, but that's still too fast
+	{
+		return qtrue;
+	}
+	return qfalse;
+}
+
+qboolean FighterIsLaunching( Vehicle_t *pVeh, playerState_t *parentPS )
+{
+
+	if ( FighterOverValidLandingSurface( pVeh )
+#ifdef QAGAME//only do this check on GAME side, because if it's CGAME, it's being predicted, and it's only predicted if the local client is the driver
+		&& pVeh->m_pVehicleInfo->Inhabited( pVeh )//has to have a driver in order to be capable of landing
+#endif
+		&& pVeh->m_ucmd.upmove > 0 //trying to take off
+		&& parentPS->speed <= 200.0f )//going slow enough to start landing - was using pVeh->m_pVehicleInfo->speedIdle, but that's still too fast
+	{
+		return qtrue;
+	}
+	return qfalse;
+}
+
+qboolean FighterSuspended( Vehicle_t *pVeh, playerState_t *parentPS )
+{
+#ifdef QAGAME//only do this check on GAME side, because if it's CGAME, it's being predicted, and it's only predicted if the local client is the driver
+	if (!pVeh->m_pPilot//empty
+		&& !parentPS->speed//not moving
+		&& pVeh->m_ucmd.forwardmove <= 0//not trying to go forward for whatever reason
+		&& pVeh->m_pParentEntity != NULL
+		&& (((gentity_t *)pVeh->m_pParentEntity)->spawnflags&2) )//SUSPENDED spawnflag is on
+	{
+		return qtrue;
+	}
+	return qfalse;
+#elif CGAME
+	return qfalse;
+#endif
+}
+
+#ifdef CGAME
+extern void trap_S_StartSound( vec3_t origin, int entityNum, int entchannel, sfxHandle_t sfx ); //cg_syscalls.c
+extern sfxHandle_t trap_S_RegisterSound( const char *sample); //cg_syscalls.c
+#endif
+
+//MP RULE - ALL PROCESSMOVECOMMANDS FUNCTIONS MUST BE BG-COMPATIBLE!!!
+//If you really need to violate this rule for SP, then use ifdefs.
+//By BG-compatible, I mean no use of game-specific data - ONLY use
+//stuff available in the MP bgEntity (in SP, the bgEntity is #defined
+//as a gentity, but the MP-compatible access restrictions are based
+//on the bgEntity structure in the MP codebase) -rww
+// ProcessMoveCommands the Vehicle.
+#define FIGHTER_MIN_TAKEOFF_FRACTION 0.7f
+static void ProcessMoveCommands( Vehicle_t *pVeh )
+{
+	/************************************************************************************/
+	/*	BEGIN	Here is where we move the vehicle (forward or back or whatever). BEGIN	*/
+	/************************************************************************************/
+
+	//Client sets ucmds and such for speed alterations
+	float speedInc, speedIdleDec, speedIdle, speedIdleAccel, speedMin, speedMax;
+	bgEntity_t *parent = pVeh->m_pParentEntity;
+	qboolean isLandingOrLaunching = qfalse;
+#ifndef _JK2MP//SP
+	int curTime = level.time;
+#elif QAGAME//MP GAME
+	int curTime = level.time;
+#elif CGAME//MP CGAME
+	//FIXME: pass in ucmd?  Not sure if this is reliable...
+	int curTime = pm->cmd.serverTime;
+#endif
+
+#ifdef _JK2MP
+	playerState_t *parentPS = parent->playerState;
+#else
+	playerState_t *parentPS = &parent->client->ps;
+#endif
+
+#ifdef _JK2MP
+	if ( parentPS->hyperSpaceTime
+		&& curTime - parentPS->hyperSpaceTime < HYPERSPACE_TIME )
+	{//Going to Hyperspace
+		//totally override movement
+		float timeFrac = ((float)(curTime-parentPS->hyperSpaceTime))/HYPERSPACE_TIME;
+		if ( timeFrac < HYPERSPACE_TELEPORT_FRAC )
+		{//for first half, instantly jump to top speed!
+			if ( !(parentPS->eFlags2&EF2_HYPERSPACE) )
+			{//waiting to face the right direction, do nothing
+				parentPS->speed = 0.0f;
+			}
+			else
+			{
+				if ( parentPS->speed < HYPERSPACE_SPEED )
+				{//just started hyperspace
+//MIKE: This is going to play the sound twice for the predicting client, I suggest using
+//a predicted event or only doing it game-side. -rich
+#ifdef QAGAME//MP GAME-side
+					//G_EntitySound( ((gentity_t *)(pVeh->m_pParentEntity)), CHAN_LOCAL, pVeh->m_pVehicleInfo->soundHyper );
+#elif CGAME//MP CGAME-side
+					trap_S_StartSound( NULL, pm->ps->clientNum, CHAN_LOCAL, pVeh->m_pVehicleInfo->soundHyper );
+#endif			
+				}
+
+				parentPS->speed = HYPERSPACE_SPEED;
+			}
+		}
+		else
+		{//slow from top speed to 200...
+			parentPS->speed = 200.0f + ((1.0f-timeFrac)*(1.0f/HYPERSPACE_TELEPORT_FRAC)*(HYPERSPACE_SPEED-200.0f));
+			//don't mess with acceleration, just pop to the high velocity
+			if ( VectorLength( parentPS->velocity ) < parentPS->speed )
+			{
+				VectorScale( parentPS->moveDir, parentPS->speed, parentPS->velocity );
+			}
+		}
+		return;
+	}
+#endif
+
+	if ( pVeh->m_iDropTime >= curTime )
+	{//no speed, just drop
+		parentPS->speed = 0.0f;
+		parentPS->gravity = 800;
+		return;
+	}
+
+	isLandingOrLaunching = (FighterIsLanding( pVeh, parentPS )||FighterIsLaunching( pVeh, parentPS ));
+
+	// If we are hitting the ground, just allow the fighter to go up and down.
+	if ( isLandingOrLaunching//going slow enough to start landing
+		&& (pVeh->m_ucmd.forwardmove<=0||pVeh->m_LandTrace.fraction<=FIGHTER_MIN_TAKEOFF_FRACTION) )//not trying to accelerate away already (or: you are trying to, but not high enough off the ground yet)
+	{//FIXME: if start to move forward and fly over something low while still going relatively slow, you may try to land even though you don't mean to...
+		//float fInvFrac = 1.0f - pVeh->m_LandTrace.fraction; 
+
+		if ( pVeh->m_ucmd.upmove > 0 )
+		{
+#ifdef _JK2MP
+			if ( parentPS->velocity[2] <= 0 
+				&& pVeh->m_pVehicleInfo->soundTakeOff )
+			{//taking off for the first time
+#ifdef QAGAME//MP GAME-side
+				G_EntitySound( ((gentity_t *)(pVeh->m_pParentEntity)), CHAN_AUTO, pVeh->m_pVehicleInfo->soundTakeOff );
+#endif
+			}
+#endif
+			parentPS->velocity[2] += pVeh->m_pVehicleInfo->acceleration * pVeh->m_fTimeModifier;// * ( /*fInvFrac **/ 1.5f );
+		}
+		else if ( pVeh->m_ucmd.upmove < 0 )
+		{
+			parentPS->velocity[2] -= pVeh->m_pVehicleInfo->acceleration * pVeh->m_fTimeModifier;// * ( /*fInvFrac **/ 1.8f );
+		}
+		else if ( pVeh->m_ucmd.forwardmove < 0 )
+		{
+			if ( pVeh->m_LandTrace.fraction != 0.0f ) 
+			{
+				parentPS->velocity[2] -= pVeh->m_pVehicleInfo->acceleration * pVeh->m_fTimeModifier;
+			}
+
+			if ( pVeh->m_LandTrace.fraction <= FIGHTER_MIN_TAKEOFF_FRACTION )
+			{
+				//pVeh->m_pParentEntity->client->ps.velocity[0] *= pVeh->m_LandTrace.fraction;
+				//pVeh->m_pParentEntity->client->ps.velocity[1] *= pVeh->m_LandTrace.fraction;
+
+				//remember to always base this stuff on the time modifier! otherwise, you create
+				//framerate-dependancy issues and break prediction in MP -rww
+				//parentPS->velocity[2] *= pVeh->m_LandTrace.fraction;
+				//it's not an angle, but hey
+				parentPS->velocity[2] = PredictedAngularDecrement(pVeh->m_LandTrace.fraction, pVeh->m_fTimeModifier*5.0f, parentPS->velocity[2]);
+			
+				parentPS->speed = 0;
+			}
+		}
+
+		// Make sure they don't pitch as they near the ground.
+		//pVeh->m_vOrientation[PITCH] *= 0.7f;
+		pVeh->m_vOrientation[PITCH] = PredictedAngularDecrement(0.7f, pVeh->m_fTimeModifier*10.0f, pVeh->m_vOrientation[PITCH]);
+
+		return;
+	}
+
+	if ( (pVeh->m_ucmd.upmove > 0) && pVeh->m_pVehicleInfo->turboSpeed )
+	{
+		if ((curTime - pVeh->m_iTurboTime)>pVeh->m_pVehicleInfo->turboRecharge)
+		{
+			pVeh->m_iTurboTime = (curTime + pVeh->m_pVehicleInfo->turboDuration);
+			if (pVeh->m_pVehicleInfo->iTurboStartFX)
+			{
+				int i;
+				for (i=0; i<MAX_VEHICLE_EXHAUSTS; i++)
+				{
+					if (pVeh->m_iExhaustTag[i]==-1)
+					{
+						break;
+					}
+					#ifndef _JK2MP//SP
+						G_PlayEffect(pVeh->m_pVehicleInfo->iTurboStartFX, pVeh->m_pParentEntity->playerModel, pVeh->m_iExhaustTag[i], pVeh->m_pParentEntity->s.number, pVeh->m_pParentEntity->currentOrigin );
+					#else
+						//TODO: MP Play Effect?
+					#endif
+				}
+			}
+			//NOTE: turbo sound can't be part of effect if effect is played on every muzzle!
+			if ( pVeh->m_pVehicleInfo->soundTurbo )
+			{
+#ifndef _JK2MP//SP
+				G_SoundIndexOnEnt( pVeh->m_pParentEntity, CHAN_AUTO, pVeh->m_pVehicleInfo->soundTurbo );
+#elif QAGAME//MP GAME-side
+				G_EntitySound( ((gentity_t *)(pVeh->m_pParentEntity)), CHAN_AUTO, pVeh->m_pVehicleInfo->soundTurbo );
+#elif CGAME//MP CGAME-side
+				//trap_S_StartSound( NULL, pVeh->m_pParentEntity->s.number, CHAN_AUTO, pVeh->m_pVehicleInfo->soundTurbo );
+#endif		
+			}
+		}
+	}
+	speedInc = pVeh->m_pVehicleInfo->acceleration * pVeh->m_fTimeModifier;
+	if ( curTime < pVeh->m_iTurboTime )
+	{//going turbo speed
+		speedMax = pVeh->m_pVehicleInfo->turboSpeed;
+		//double our acceleration
+		speedInc *= 2.0f;
+		//force us to move forward
+		pVeh->m_ucmd.forwardmove = 127;
+#ifdef _JK2MP//SP can cheat and just check m_iTurboTime directly... :)
+		//add flag to let cgame know to draw the iTurboFX effect
+		parentPS->eFlags |= EF_JETPACK_ACTIVE;
+#endif
+	}
+	/*
+	//FIXME: if turbotime is up and we're waiting for it to recharge, should our max speed drop while we recharge?
+	else if ( (curTime - pVeh->m_iTurboTime)<3000 )
+	{//still waiting for the recharge
+		speedMax = pVeh->m_pVehicleInfo->speedMax*0.75;
+	}
+	*/
+	else
+	{//normal max speed
+		speedMax = pVeh->m_pVehicleInfo->speedMax;
+#ifdef _JK2MP//SP can cheat and just check m_iTurboTime directly... :)
+		if ( (parentPS->eFlags&EF_JETPACK_ACTIVE) )
+		{//stop cgame from playing the turbo exhaust effect
+			parentPS->eFlags &= ~EF_JETPACK_ACTIVE;
+		}
+#endif
+	}
+	speedIdleDec = pVeh->m_pVehicleInfo->decelIdle * pVeh->m_fTimeModifier;
+	speedIdle = pVeh->m_pVehicleInfo->speedIdle;
+	speedIdleAccel = pVeh->m_pVehicleInfo->accelIdle * pVeh->m_fTimeModifier;
+	speedMin = pVeh->m_pVehicleInfo->speedMin;
+
+	if ( (parentPS->brokenLimbs&(1<<SHIPSURF_DAMAGE_BACK_HEAVY)) )
+	{//engine has taken heavy damage
+		speedMax *= 0.8f;//at 80% speed
+	}
+	else if ( (parentPS->brokenLimbs&(1<<SHIPSURF_DAMAGE_BACK_LIGHT)) )
+	{//engine has taken light damage
+		speedMax *= 0.6f;//at 60% speed
+	}
+
+	if (pVeh->m_iRemovedSurfaces
+		|| parentPS->electrifyTime>=curTime)
+	{ //go out of control
+		parentPS->speed += speedInc;
+		//Why set forwardmove?  PMove code doesn't use it... does it?
+		pVeh->m_ucmd.forwardmove = 127;
+	}
+#ifdef QAGAME //well, the thing is always going to be inhabited if it's being predicted!
+	else if ( FighterSuspended( pVeh, parentPS ) )
+	{
+		parentPS->speed = 0;
+		pVeh->m_ucmd.forwardmove = 0;
+	}
+	else if ( !pVeh->m_pVehicleInfo->Inhabited( pVeh ) 
+		&& parentPS->speed > 0 )
+	{//pilot jumped out while we were moving forward (not landing or landed) so just keep the throttle locked
+		//Why set forwardmove?  PMove code doesn't use it... does it?
+		pVeh->m_ucmd.forwardmove = 127;
+	}
+#endif
+	else if ( ( parentPS->speed || parentPS->groundEntityNum == ENTITYNUM_NONE  ||
+		 pVeh->m_ucmd.forwardmove || pVeh->m_ucmd.upmove > 0 ) && pVeh->m_LandTrace.fraction >= 0.05f ) 
+	{
+		if ( pVeh->m_ucmd.forwardmove > 0 && speedInc )
+		{
+			parentPS->speed += speedInc;
+			pVeh->m_ucmd.forwardmove = 127;
+		}
+		else if ( pVeh->m_ucmd.forwardmove < 0 
+			|| pVeh->m_ucmd.upmove < 0 )
+		{//decelerating or braking
+			if ( pVeh->m_ucmd.upmove < 0 )
+			{//braking (trying to land?), slow down faster
+				if ( pVeh->m_ucmd.forwardmove )
+				{//decelerator + brakes
+					speedInc += pVeh->m_pVehicleInfo->braking;
+					speedIdleDec += pVeh->m_pVehicleInfo->braking;
+				}
+				else
+				{//just brakes
+					speedInc = speedIdleDec = pVeh->m_pVehicleInfo->braking;
+				}
+			}
+			if ( parentPS->speed > speedIdle )
+			{
+				parentPS->speed -= speedInc;
+			}
+			else if ( parentPS->speed > speedMin )
+			{
+				if ( FighterOverValidLandingSurface( pVeh ) )
+				{//there's ground below us and we're trying to slow down, slow down faster
+					parentPS->speed -= speedInc;
+				}
+				else
+				{
+					parentPS->speed -= speedIdleDec;
+					if ( parentPS->speed < MIN_LANDING_SPEED )
+					{//unless you can land, don't drop below the landing speed!!!  This way you can't come to a dead stop in mid-air
+						parentPS->speed = MIN_LANDING_SPEED;
+					}
+				}
+			}
+			if ( pVeh->m_pVehicleInfo->type == VH_FIGHTER )
+			{
+				pVeh->m_ucmd.forwardmove = 127;
+			}
+			else if ( speedMin >= 0 )
+			{
+				pVeh->m_ucmd.forwardmove = 0;
+			}
+		}
+		//else not accel, decel or braking
+		else if ( pVeh->m_pVehicleInfo->throttleSticks )
+		{//we're using a throttle that sticks at current speed
+			if ( parentPS->speed <= MIN_LANDING_SPEED )
+			{//going less than landing speed
+				if ( FighterOverValidLandingSurface( pVeh ) )
+				{//close to ground and not going very fast
+					//slow to a stop if within landing height and not accel/decel/braking
+					if ( parentPS->speed > 0 )
+					{//slow down
+						parentPS->speed -= speedIdleDec;
+					}
+					else if ( parentPS->speed < 0 )
+					{//going backwards, slow down
+						parentPS->speed += speedIdleDec;
+					}
+				}
+				else
+				{//not over a valid landing surf, but going too slow
+					//speed up to idle speed if not over a valid landing surf and not accel/decel/braking
+					if ( parentPS->speed < speedIdle )
+					{
+						parentPS->speed += speedIdleAccel;
+						if ( parentPS->speed > speedIdle )
+						{
+							parentPS->speed = speedIdle;
+						}
+					}
+				}
+			}
+		}
+		else
+		{//then speed up or slow down to idle speed
+			//accelerate to cruising speed only, otherwise, just coast
+			// If they've launched, apply some constant motion.
+			if ( (pVeh->m_LandTrace.fraction >= 1.0f //no ground
+					|| pVeh->m_LandTrace.plane.normal[2] < MIN_LANDING_SLOPE )//or can't land on ground below us
+				&& speedIdle > 0 ) 
+			{//not above ground and have an idle speed
+				//float fSpeed = pVeh->m_pParentEntity->client->ps.speed;
+				if ( parentPS->speed < speedIdle )
+				{
+					parentPS->speed += speedIdleAccel;
+					if ( parentPS->speed > speedIdle )
+					{
+						parentPS->speed = speedIdle;
+					}
+				}
+				else if ( parentPS->speed > 0 )
+				{//slow down
+					parentPS->speed -= speedIdleDec;
+
+					if ( parentPS->speed < speedIdle )
+					{
+						parentPS->speed = speedIdle;
+					}
+				}
+			}
+			else//either close to ground or no idle speed
+			{//slow to a stop if no idle speed or within landing height and not accel/decel/braking
+				if ( parentPS->speed > 0 )
+				{//slow down
+					parentPS->speed -= speedIdleDec;
+				}
+				else if ( parentPS->speed < 0 )
+				{//going backwards, slow down
+					parentPS->speed += speedIdleDec;
+				}
+			}
+		}
+	}
+	else
+	{
+		if ( pVeh->m_ucmd.forwardmove < 0 )
+		{
+			pVeh->m_ucmd.forwardmove = 0;
+		}
+		if ( pVeh->m_ucmd.upmove < 0 )
+		{
+			pVeh->m_ucmd.upmove = 0;
+		}
+
+#ifndef _JK2MP
+		if ( !pVeh->m_pVehicleInfo->strafePerc || (!g_speederControlScheme->value && !pVeh->m_pParentEntity->s.number) )
+		{//if in a strafe-capable vehicle, clear strafing unless using alternate control scheme
+			pVeh->m_ucmd.rightmove = 0;
+		}
+#endif
+	}
+
+#if 1//This is working now, but there are some transitional jitters... Rich?
+//STRAFING==============================================================================
+	if ( pVeh->m_pVehicleInfo->strafePerc 
+#ifdef QAGAME//only do this check on GAME side, because if it's CGAME, it's being predicted, and it's only predicted if the local client is the driver
+		&& pVeh->m_pVehicleInfo->Inhabited( pVeh )//has to have a driver in order to be capable of landing
+#endif
+		&& !pVeh->m_iRemovedSurfaces
+		&& parentPS->electrifyTime<curTime
+		&& (pVeh->m_LandTrace.fraction >= 1.0f//no grounf
+			||pVeh->m_LandTrace.plane.normal[2] < MIN_LANDING_SLOPE//can't land here
+			||parentPS->speed>MIN_LANDING_SPEED)//going too fast to land
+		&& pVeh->m_ucmd.rightmove )
+	{//strafe
+		vec3_t vAngles, vRight;
+		float strafeSpeed = (pVeh->m_pVehicleInfo->strafePerc*speedMax)*5.0f;
+		VectorCopy( pVeh->m_vOrientation, vAngles );
+		vAngles[PITCH] = vAngles[ROLL] = 0;
+		AngleVectors( vAngles, NULL, vRight, NULL );
+
+		if ( pVeh->m_ucmd.rightmove > 0 )
+		{//strafe right
+			//FIXME: this will probably make it possible to cheat and
+			//		go faster than max speed if you keep turning and strafing...
+			if ( parentPS->hackingTime > -MAX_STRAFE_TIME )
+			{//can strafe right for 2 seconds
+				float curStrafeSpeed = DotProduct( parentPS->velocity, vRight );
+				if ( curStrafeSpeed > 0.0f )
+				{//if > 0, already strafing right
+					strafeSpeed -= curStrafeSpeed;//so it doesn't add up
+				}
+				if ( strafeSpeed > 0 )
+				{
+					VectorMA( parentPS->velocity, strafeSpeed*pVeh->m_fTimeModifier, vRight, parentPS->velocity );
+				}
+				parentPS->hackingTime -= 50*pVeh->m_fTimeModifier;
+			}
+		}
+		else
+		{//strafe left
+			if ( parentPS->hackingTime < MAX_STRAFE_TIME )
+			{//can strafe left for 2 seconds
+				float curStrafeSpeed = DotProduct( parentPS->velocity, vRight );
+				if ( curStrafeSpeed < 0.0f )
+				{//if < 0, already strafing left
+					strafeSpeed += curStrafeSpeed;//so it doesn't add up
+				}
+				if ( strafeSpeed > 0 )
+				{
+					VectorMA( parentPS->velocity, -strafeSpeed*pVeh->m_fTimeModifier, vRight, parentPS->velocity );
+				}
+				parentPS->hackingTime += 50*pVeh->m_fTimeModifier;
+			}
+		}
+		//strafing takes away from forward speed?  If so, strafePerc above should use speedMax
+		//parentPS->speed *= (1.0f-pVeh->m_pVehicleInfo->strafePerc);
+	}
+	else//if ( parentPS->hackingTimef )
+	{
+		if ( parentPS->hackingTime > 0 )
+		{
+			parentPS->hackingTime -= 50*pVeh->m_fTimeModifier;
+			if ( parentPS->hackingTime < 0 )
+			{
+				parentPS->hackingTime = 0.0f;
+			}
+		}
+		else if ( parentPS->hackingTime < 0 )
+		{
+			parentPS->hackingTime += 50*pVeh->m_fTimeModifier;
+			if ( parentPS->hackingTime > 0 )
+			{
+				parentPS->hackingTime = 0.0f;
+			}
+		}
+	}
+//STRAFING==============================================================================
+#endif
+
+	if ( parentPS->speed > speedMax )
+	{
+		parentPS->speed = speedMax;
+	}
+	else if ( parentPS->speed < speedMin )
+	{
+		parentPS->speed = speedMin;
+	}
+
+#ifdef QAGAME//FIXME: get working in GAME and CGAME
+	if ((pVeh->m_vOrientation[PITCH]*0.1f) > 10.0f)
+	{ //pitched downward, increase speed more and more based on our tilt
+		if ( FighterIsInSpace( (gentity_t *)parent ) )
+		{//in space, do nothing with speed base on pitch...
+		}
+		else
+		{
+			//really should only do this when on a planet
+			float mult = pVeh->m_vOrientation[PITCH]*0.1f;
+			if (mult < 1.0f)
+			{
+				mult = 1.0f;
+			}
+			parentPS->speed = PredictedAngularDecrement(mult, pVeh->m_fTimeModifier*10.0f, parentPS->speed);
+		}
+	}
+
+	if (pVeh->m_iRemovedSurfaces
+		|| parentPS->electrifyTime>=curTime)
+	{ //going down
+		if ( FighterIsInSpace( (gentity_t *)parent ) )
+		{//we're in a valid trigger_space brush
+			//simulate randomness
+			if ( !(parent->s.number&3) )
+			{//even multiple of 3, don't do anything
+				parentPS->gravity = 0;
+			}
+			else if ( !(parent->s.number&2) )
+			{//even multiple of 2, go up
+				parentPS->gravity = -500.0f;
+				parentPS->velocity[2] = 80.0f;
+			}
+			else
+			{//odd number, go down
+				parentPS->gravity = 500.0f;
+				parentPS->velocity[2] = -80.0f;
+			}
+		}
+		else
+		{//over a planet
+			parentPS->gravity = 500.0f;
+			parentPS->velocity[2] = -80.0f;
+		}
+	}
+	else if ( FighterSuspended( pVeh, parentPS ) )
+	{
+		parentPS->gravity = 0;
+	}
+	else if ( (!parentPS->speed||parentPS->speed < speedIdle) && pVeh->m_ucmd.upmove <= 0 )
+	{//slowing down or stopped and not trying to take off
+		if ( FighterIsInSpace( (gentity_t *)parent ) )
+		{//we're in space, stopping doesn't make us drift downward
+			if ( FighterOverValidLandingSurface( pVeh ) )
+			{//well, there's something below us to land on, so go ahead and lower us down to it
+				parentPS->gravity = (speedIdle - parentPS->speed)/4;
+			}
+		}
+		else
+		{//over a planet
+			parentPS->gravity = (speedIdle - parentPS->speed)/4;
+		}
+	}
+	else
+	{
+		parentPS->gravity = 0;
+	}
+#else//FIXME: get above checks working in GAME and CGAME
+	parentPS->gravity = 0;
+#endif
+
+	/********************************************************************************/
+	/*	END Here is where we move the vehicle (forward or back or whatever). END	*/
+	/********************************************************************************/
+}
+
+extern void BG_VehicleTurnRateForSpeed( Vehicle_t *pVeh, float speed, float *mPitchOverride, float *mYawOverride );
+static void FighterWingMalfunctionCheck( Vehicle_t *pVeh, playerState_t *parentPS )
+{
+	float mPitchOverride = 1.0f;
+	float mYawOverride = 1.0f;
+	BG_VehicleTurnRateForSpeed( pVeh, parentPS->speed, &mPitchOverride, &mYawOverride );
+	//check right wing damage
+	if ( (parentPS->brokenLimbs&(1<<SHIPSURF_DAMAGE_RIGHT_HEAVY)) )
+	{//right wing has taken heavy damage
+		pVeh->m_vOrientation[ROLL] += (sin( pVeh->m_ucmd.serverTime*0.001 )+1.0f)*pVeh->m_fTimeModifier*mYawOverride*50.0f;
+	}
+	else if ( (parentPS->brokenLimbs&(1<<SHIPSURF_DAMAGE_RIGHT_LIGHT)) )
+	{//right wing has taken light damage
+		pVeh->m_vOrientation[ROLL] += (sin( pVeh->m_ucmd.serverTime*0.001 )+1.0f)*pVeh->m_fTimeModifier*mYawOverride*12.5f;
+	}
+
+	//check left wing damage
+	if ( (parentPS->brokenLimbs&(1<<SHIPSURF_DAMAGE_LEFT_HEAVY)) )
+	{//left wing has taken heavy damage
+		pVeh->m_vOrientation[ROLL] -= (sin( pVeh->m_ucmd.serverTime*0.001 )+1.0f)*pVeh->m_fTimeModifier*mYawOverride*50.0f;
+	}
+	else if ( (parentPS->brokenLimbs&(1<<SHIPSURF_DAMAGE_LEFT_LIGHT)) )
+	{//left wing has taken light damage
+		pVeh->m_vOrientation[ROLL] -= (sin( pVeh->m_ucmd.serverTime*0.001 )+1.0f)*pVeh->m_fTimeModifier*mYawOverride*12.5f;
+	}
+
+}
+
+static void FighterNoseMalfunctionCheck( Vehicle_t *pVeh, playerState_t *parentPS )
+{
+	float mPitchOverride = 1.0f;
+	float mYawOverride = 1.0f;
+	BG_VehicleTurnRateForSpeed( pVeh, parentPS->speed, &mPitchOverride, &mYawOverride );
+	//check nose damage
+	if ( (parentPS->brokenLimbs&(1<<SHIPSURF_DAMAGE_FRONT_HEAVY)) )
+	{//nose has taken heavy damage
+		//pitch up and down over time
+		pVeh->m_vOrientation[PITCH] += sin( pVeh->m_ucmd.serverTime*0.001 )*pVeh->m_fTimeModifier*mPitchOverride*50.0f;
+	}
+	else if ( (parentPS->brokenLimbs&(1<<SHIPSURF_DAMAGE_FRONT_LIGHT)) )
+	{//nose has taken heavy damage
+		//pitch up and down over time
+		pVeh->m_vOrientation[PITCH] += sin( pVeh->m_ucmd.serverTime*0.001 )*pVeh->m_fTimeModifier*mPitchOverride*20.0f;
+	}
+}
+
+static void FighterDamageRoutine( Vehicle_t *pVeh, bgEntity_t *parent, playerState_t *parentPS, playerState_t *riderPS, qboolean isDead )
+{
+ 	if ( !pVeh->m_iRemovedSurfaces )
+	{//still in one piece
+		if ( pVeh->m_pParentEntity && isDead )
+		{//death spiral
+			pVeh->m_ucmd.upmove = 0;
+			//FIXME: don't bias toward pitching down when not in space
+			/*
+			if ( FighterIsInSpace( pVeh->m_pParentEntity ) )
+			{
+			}
+			else
+			*/
+			if ( !(pVeh->m_pParentEntity->s.number%3) )
+			{//NOT everyone should do this
+				pVeh->m_vOrientation[PITCH] += pVeh->m_fTimeModifier; 
+				if ( !BG_UnrestrainedPitchRoll( riderPS, pVeh ) )
+				{
+					if ( pVeh->m_vOrientation[PITCH] > 60.0f )  
+					{
+						pVeh->m_vOrientation[PITCH] = 60.0f;
+					}
+				}
+			}
+			else if ( !(pVeh->m_pParentEntity->s.number%2) )
+			{
+				pVeh->m_vOrientation[PITCH] -= pVeh->m_fTimeModifier; 
+				if ( !BG_UnrestrainedPitchRoll( riderPS, pVeh ) )
+				{
+					if ( pVeh->m_vOrientation[PITCH] > -60.0f )  
+					{
+						pVeh->m_vOrientation[PITCH] = -60.0f;
+					}
+				}
+			}
+			if ( (pVeh->m_pParentEntity->s.number%2) )
+			{
+				pVeh->m_vOrientation[YAW] += pVeh->m_fTimeModifier;
+				pVeh->m_vOrientation[ROLL] += pVeh->m_fTimeModifier*4.0f;
+			}
+			else
+			{
+				pVeh->m_vOrientation[YAW] -= pVeh->m_fTimeModifier;
+				pVeh->m_vOrientation[ROLL] -= pVeh->m_fTimeModifier*4.0f;
+			}
+		}
+		return;
+	}
+
+	//if we get into here we have at least one broken piece
+	pVeh->m_ucmd.upmove = 0;
+	
+	//if you're off the ground and not suspended, pitch down
+	//FIXME: not in space!
+	if ( pVeh->m_LandTrace.fraction >= 0.1f )
+	{
+		if ( !FighterSuspended( pVeh, parentPS ) )
+		{
+			//pVeh->m_ucmd.forwardmove = 0;
+			//FIXME: don't bias towards pitching down when in space...
+			if ( !(pVeh->m_pParentEntity->s.number%2) )
+			{//NOT everyone should do this
+				pVeh->m_vOrientation[PITCH] += pVeh->m_fTimeModifier; 
+				if ( !BG_UnrestrainedPitchRoll( riderPS, pVeh ) )
+				{
+					if ( pVeh->m_vOrientation[PITCH] > 60.0f )  
+					{
+						pVeh->m_vOrientation[PITCH] = 60.0f;
+					}
+				}
+			}
+			else if ( !(pVeh->m_pParentEntity->s.number%3) )
+			{
+				pVeh->m_vOrientation[PITCH] -= pVeh->m_fTimeModifier; 
+				if ( !BG_UnrestrainedPitchRoll( riderPS, pVeh ) )
+				{
+					if ( pVeh->m_vOrientation[PITCH] > -60.0f )  
+					{
+						pVeh->m_vOrientation[PITCH] = -60.0f;
+					}
+				}
+			}
+			//else: just keep going forward
+		}
+	}
+#ifdef QAGAME
+	if ( pVeh->m_LandTrace.fraction < 1.0f )
+	{ //if you land at all when pieces of your ship are missing, then die
+		gentity_t *parent = (gentity_t *)pVeh->m_pParentEntity;
+		gentity_t *killer = parent;
+#ifdef _JK2MP//only have this info in MP...
+		if (parent->client->ps.otherKiller < ENTITYNUM_WORLD &&
+			parent->client->ps.otherKillerTime > level.time)
+		{
+			gentity_t *potentialKiller = &g_entities[parent->client->ps.otherKiller];
+
+			if (potentialKiller->inuse && potentialKiller->client)
+			{ //he's valid I guess
+				killer = potentialKiller;
+			}
+		}
+#endif
+		G_Damage(parent, killer, killer, vec3_origin, parent->client->ps.origin, 99999, DAMAGE_NO_ARMOR, MOD_SUICIDE);
+	}
+#endif
+
+	if ( ((pVeh->m_iRemovedSurfaces & SHIPSURF_BROKEN_C) ||
+		(pVeh->m_iRemovedSurfaces & SHIPSURF_BROKEN_D)) &&
+		((pVeh->m_iRemovedSurfaces & SHIPSURF_BROKEN_E) ||
+		(pVeh->m_iRemovedSurfaces & SHIPSURF_BROKEN_F)) )
+	{ //wings on both side broken
+		float factor = 2.0f;
+		if ((pVeh->m_iRemovedSurfaces & SHIPSURF_BROKEN_E) &&
+			(pVeh->m_iRemovedSurfaces & SHIPSURF_BROKEN_F) &&
+			(pVeh->m_iRemovedSurfaces & SHIPSURF_BROKEN_C) &&
+			(pVeh->m_iRemovedSurfaces & SHIPSURF_BROKEN_D))
+		{ //all wings broken
+			factor *= 2.0f;
+		}
+
+		if ( !(pVeh->m_pParentEntity->s.number%4)||!(pVeh->m_pParentEntity->s.number%5) )
+		{//won't yaw, so increase roll factor
+			factor *= 4.0f;
+		}
+
+		pVeh->m_vOrientation[ROLL] += (pVeh->m_fTimeModifier*factor); //do some spiralling
+	}
+	else if ((pVeh->m_iRemovedSurfaces & SHIPSURF_BROKEN_C) ||
+		(pVeh->m_iRemovedSurfaces & SHIPSURF_BROKEN_D))
+	{ //left wing broken
+		float factor = 2.0f;
+		if ((pVeh->m_iRemovedSurfaces & SHIPSURF_BROKEN_C) &&
+			(pVeh->m_iRemovedSurfaces & SHIPSURF_BROKEN_D))
+		{ //if both are broken..
+			factor *= 2.0f;
+		}
+
+		if ( !(pVeh->m_pParentEntity->s.number%4)||!(pVeh->m_pParentEntity->s.number%5) )
+		{//won't yaw, so increase roll factor
+			factor *= 4.0f;
+		}
+
+		pVeh->m_vOrientation[ROLL] += factor*pVeh->m_fTimeModifier;
+	}
+	else if ((pVeh->m_iRemovedSurfaces & SHIPSURF_BROKEN_E) ||
+		(pVeh->m_iRemovedSurfaces & SHIPSURF_BROKEN_F))
+	{ //right wing broken
+		float factor = 2.0f;
+		if ((pVeh->m_iRemovedSurfaces & SHIPSURF_BROKEN_E) &&
+			(pVeh->m_iRemovedSurfaces & SHIPSURF_BROKEN_F))
+		{ //if both are broken..
+			factor *= 2.0f;
+		}
+
+		if ( !(pVeh->m_pParentEntity->s.number%4)||!(pVeh->m_pParentEntity->s.number%5) )
+		{//won't yaw, so increase roll factor
+			factor *= 4.0f;
+		}
+
+		pVeh->m_vOrientation[ROLL] -= factor*pVeh->m_fTimeModifier;
+	}
+}
+
+#ifdef _JK2MP
+#define FIGHTER_TURNING_MULTIPLIER 0.8f//was 1.6f //magic number hackery
+#define FIGHTER_TURNING_DEADZONE 0.25f//no turning if offset is this much
+void FighterRollAdjust(Vehicle_t *pVeh, playerState_t *riderPS, playerState_t *parentPS)
+{
+/*
+	float angDif = AngleSubtract(pVeh->m_vOrientation[YAW], riderPS->viewangles[YAW]);
+*/
+	float angDif = AngleSubtract(pVeh->m_vPrevRiderViewAngles[YAW],riderPS->viewangles[YAW]);///2.0f;//AngleSubtract(pVeh->m_vPrevRiderViewAngles[YAW], riderPS->viewangles[YAW]);
+	/*
+	if ( fabs( angDif ) < FIGHTER_TURNING_DEADZONE )
+	{
+		angDif = 0.0f;
+	}
+	else if ( angDif >= FIGHTER_TURNING_DEADZONE )
+	{
+		angDif -= FIGHTER_TURNING_DEADZONE;
+	}
+	else if ( angDif <= -FIGHTER_TURNING_DEADZONE )
+	{
+		angDif += FIGHTER_TURNING_DEADZONE;
+	}
+	*/
+	
+	angDif *= 0.5f;
+	if ( angDif > 0.0f )
+	{
+		angDif *= angDif;
+	}
+	else if ( angDif < 0.0f )
+	{
+		angDif *= -angDif;
+	}
+
+	if (parentPS && parentPS->speed)
+	{
+		float maxDif = pVeh->m_pVehicleInfo->turningSpeed*FIGHTER_TURNING_MULTIPLIER;
+
+		if ( pVeh->m_pVehicleInfo->speedDependantTurning )
+		{
+			float speedFrac = 1.0f;
+			if ( pVeh->m_LandTrace.fraction >= 1.0f 
+				|| pVeh->m_LandTrace.plane.normal[2] < MIN_LANDING_SLOPE  )
+			{
+				float s = parentPS->speed;
+				if (s < 0.0f)
+				{
+					s = -s;
+				}
+				speedFrac = (s/(pVeh->m_pVehicleInfo->speedMax*0.75f));
+				if ( speedFrac < 0.25f )
+				{
+					speedFrac = 0.25f;
+				}
+				else if ( speedFrac > 1.0f )
+				{
+					speedFrac = 1.0f;
+				}
+			}
+			angDif *= speedFrac;
+		}
+		if (angDif > maxDif)
+		{
+			angDif = maxDif;
+		}
+		else if (angDif < -maxDif)
+		{
+			angDif = -maxDif;
+		}
+		pVeh->m_vOrientation[ROLL] = AngleNormalize180(pVeh->m_vOrientation[ROLL] + angDif*(pVeh->m_fTimeModifier*0.2f));
+	}
+}
+
+void FighterYawAdjust(Vehicle_t *pVeh, playerState_t *riderPS, playerState_t *parentPS)
+{
+/*
+	float angDif = AngleSubtract(pVeh->m_vOrientation[YAW], riderPS->viewangles[YAW]);
+*/
+	float angDif = AngleSubtract(pVeh->m_vPrevRiderViewAngles[YAW],riderPS->viewangles[YAW]);///2.0f;//AngleSubtract(pVeh->m_vPrevRiderViewAngles[YAW], riderPS->viewangles[YAW]);
+	if ( fabs( angDif ) < FIGHTER_TURNING_DEADZONE )
+	{
+		angDif = 0.0f;
+	}
+	else if ( angDif >= FIGHTER_TURNING_DEADZONE )
+	{
+		angDif -= FIGHTER_TURNING_DEADZONE;
+	}
+	else if ( angDif <= -FIGHTER_TURNING_DEADZONE )
+	{
+		angDif += FIGHTER_TURNING_DEADZONE;
+	}
+	
+	angDif *= 0.5f;
+	if ( angDif > 0.0f )
+	{
+		angDif *= angDif;
+	}
+	else if ( angDif < 0.0f )
+	{
+		angDif *= -angDif;
+	}
+
+	if (parentPS && parentPS->speed)
+	{
+		float maxDif = pVeh->m_pVehicleInfo->turningSpeed*FIGHTER_TURNING_MULTIPLIER;
+
+		if ( pVeh->m_pVehicleInfo->speedDependantTurning )
+		{
+			float speedFrac = 1.0f;
+			if ( pVeh->m_LandTrace.fraction >= 1.0f 
+				|| pVeh->m_LandTrace.plane.normal[2] < MIN_LANDING_SLOPE  )
+			{
+				float s = parentPS->speed;
+				if (s < 0.0f)
+				{
+					s = -s;
+				}
+				speedFrac = (s/(pVeh->m_pVehicleInfo->speedMax*0.75f));
+				if ( speedFrac < 0.25f )
+				{
+					speedFrac = 0.25f;
+				}
+				else if ( speedFrac > 1.0f )
+				{
+					speedFrac = 1.0f;
+				}
+			}
+			angDif *= speedFrac;
+		}
+		if (angDif > maxDif)
+		{
+			angDif = maxDif;
+		}
+		else if (angDif < -maxDif)
+		{
+			angDif = -maxDif;
+		}
+		pVeh->m_vOrientation[YAW] = AngleNormalize180(pVeh->m_vOrientation[YAW] - (angDif*(pVeh->m_fTimeModifier*0.2f)) );
+	}
+}
+
+void FighterPitchAdjust(Vehicle_t *pVeh, playerState_t *riderPS, playerState_t *parentPS)
+{
+/*
+	float angDif = AngleSubtract(pVeh->m_vOrientation[PITCH], riderPS->viewangles[PITCH]);
+*/
+	float angDif = AngleSubtract(0,riderPS->viewangles[PITCH]);//AngleSubtract(pVeh->m_vPrevRiderViewAngles[PITCH], riderPS->viewangles[PITCH]);
+	if ( fabs( angDif ) < FIGHTER_TURNING_DEADZONE )
+	{
+		angDif = 0.0f;
+	}
+	else if ( angDif >= FIGHTER_TURNING_DEADZONE )
+	{
+		angDif -= FIGHTER_TURNING_DEADZONE;
+	}
+	else if ( angDif <= -FIGHTER_TURNING_DEADZONE )
+	{
+		angDif += FIGHTER_TURNING_DEADZONE;
+	}
+
+	angDif *= 0.5f;
+	if ( angDif > 0.0f )
+	{
+		angDif *= angDif;
+	}
+	else if ( angDif < 0.0f )
+	{
+		angDif *= -angDif;
+	}
+
+	if (parentPS && parentPS->speed)
+	{
+		float maxDif = pVeh->m_pVehicleInfo->turningSpeed*FIGHTER_TURNING_MULTIPLIER;
+
+		if ( pVeh->m_pVehicleInfo->speedDependantTurning )
+		{
+			float speedFrac = 1.0f;
+			if ( pVeh->m_LandTrace.fraction >= 1.0f 
+				|| pVeh->m_LandTrace.plane.normal[2] < MIN_LANDING_SLOPE  )
+			{
+				float s = parentPS->speed;
+				if (s < 0.0f)
+				{
+					s = -s;
+				}
+				speedFrac = (s/(pVeh->m_pVehicleInfo->speedMax*0.75f));
+				if ( speedFrac < 0.25f )
+				{
+					speedFrac = 0.25f;
+				}
+				else if ( speedFrac > 1.0f )
+				{
+					speedFrac = 1.0f;
+				}
+			}
+			angDif *= speedFrac;
+		}
+		if (angDif > maxDif)
+		{
+			angDif = maxDif;
+		}
+		else if (angDif < -maxDif)
+		{
+			angDif = -maxDif;
+		}
+		pVeh->m_vOrientation[PITCH] = AngleNormalize180(pVeh->m_vOrientation[PITCH] - (angDif*(pVeh->m_fTimeModifier*0.2f)) );
+	}
+}
+
+void FighterPitchClamp(Vehicle_t *pVeh, playerState_t *riderPS, playerState_t *parentPS, int curTime )
+{
+	if ( !BG_UnrestrainedPitchRoll( riderPS, pVeh ) )
+	{//cap pitch reasonably
+		if ( pVeh->m_pVehicleInfo->pitchLimit != -1 
+			&& !pVeh->m_iRemovedSurfaces 
+			&& parentPS->electrifyTime < curTime )
+		{
+			if (pVeh->m_vOrientation[PITCH] > pVeh->m_pVehicleInfo->pitchLimit )
+			{
+				pVeh->m_vOrientation[PITCH] = pVeh->m_pVehicleInfo->pitchLimit;
+			}
+			else if (pVeh->m_vOrientation[PITCH] < -pVeh->m_pVehicleInfo->pitchLimit)
+			{
+				pVeh->m_vOrientation[PITCH] = -pVeh->m_pVehicleInfo->pitchLimit;
+			}
+		}
+	}
+}
+#endif
+
+//MP RULE - ALL PROCESSORIENTCOMMANDS FUNCTIONS MUST BE BG-COMPATIBLE!!!
+//If you really need to violate this rule for SP, then use ifdefs.
+//By BG-compatible, I mean no use of game-specific data - ONLY use
+//stuff available in the MP bgEntity (in SP, the bgEntity is #defined
+//as a gentity, but the MP-compatible access restrictions are based
+//on the bgEntity structure in the MP codebase) -rww
+// ProcessOrientCommands the Vehicle.
+static void ProcessOrientCommands( Vehicle_t *pVeh )
+{
+	/********************************************************************************/
+	/*	BEGIN	Here is where make sure the vehicle is properly oriented.	BEGIN	*/
+	/********************************************************************************/
+
+	bgEntity_t *parent = pVeh->m_pParentEntity;
+	playerState_t *parentPS, *riderPS;
+	float angleTimeMod;
+#ifdef QAGAME
+	const float groundFraction = 0.1f;
+#endif
+	float	curRoll = 0.0f;
+	qboolean isDead = qfalse;
+	qboolean isLandingOrLanded = qfalse;
+#ifndef _JK2MP//SP
+	int curTime = level.time;
+#elif QAGAME//MP GAME
+	int curTime = level.time;
+#elif CGAME//MP CGAME
+	//FIXME: pass in ucmd?  Not sure if this is reliable...
+	int curTime = pm->cmd.serverTime;
+#endif
+
+#ifdef _JK2MP
+	bgEntity_t *rider = NULL;
+	if (parent->s.owner != ENTITYNUM_NONE)
+	{
+		rider = PM_BGEntForNum(parent->s.owner); //&g_entities[parent->r.ownerNum];
+	}
+#else
+	gentity_t *rider = parent->owner;
+#endif
+
+#ifdef _JK2MP
+	if ( !rider )
+#else
+	if ( !rider || !rider->client )
+#endif
+	{
+		rider = parent;
+	}
+
+#ifdef _JK2MP
+	parentPS = parent->playerState;
+	riderPS = rider->playerState;
+	isDead = (qboolean)((parentPS->eFlags&EF_DEAD)!=0);
+#else
+	parentPS = &parent->client->ps;
+	riderPS = &rider->client->ps;
+	isDead = (parentPS->stats[STAT_HEALTH] <= 0 );
+#endif
+
+#ifdef _JK2MP
+	if ( parentPS->hyperSpaceTime
+		&& (curTime - parentPS->hyperSpaceTime) < HYPERSPACE_TIME )
+	{//Going to Hyperspace
+		//VectorCopy( riderPS->viewangles, pVeh->m_vOrientation );
+		//VectorCopy( riderPS->viewangles, parentPS->viewangles );
+		VectorCopy( parentPS->viewangles, pVeh->m_vOrientation );
+		VectorClear( pVeh->m_vPrevRiderViewAngles );
+		pVeh->m_vPrevRiderViewAngles[YAW] = AngleNormalize180(riderPS->viewangles[YAW]);
+		FighterPitchClamp( pVeh, riderPS, parentPS, curTime );
+		return;
+	}
+	else if ( parentPS->vehTurnaroundIndex
+		&& parentPS->vehTurnaroundTime > curTime )
+	{//in turn-around brush
+		//VectorCopy( riderPS->viewangles, pVeh->m_vOrientation );
+		//VectorCopy( riderPS->viewangles, parentPS->viewangles );
+		VectorCopy( parentPS->viewangles, pVeh->m_vOrientation );
+		VectorClear( pVeh->m_vPrevRiderViewAngles );
+		pVeh->m_vPrevRiderViewAngles[YAW] = AngleNormalize180(riderPS->viewangles[YAW]);
+		FighterPitchClamp( pVeh, riderPS, parentPS, curTime );
+		return;
+	}
+#endif
+	
+	if ( pVeh->m_iDropTime >= curTime )
+	{//you can only YAW during this
+		parentPS->viewangles[YAW] = pVeh->m_vOrientation[YAW] = riderPS->viewangles[YAW];
+		VectorClear( pVeh->m_vPrevRiderViewAngles );
+		pVeh->m_vPrevRiderViewAngles[YAW] = AngleNormalize180(riderPS->viewangles[YAW]);
+		return;
+	}
+
+	angleTimeMod = pVeh->m_fTimeModifier;
+
+	if ( isDead || parentPS->electrifyTime>=curTime ||
+		(pVeh->m_pVehicleInfo->surfDestruction &&
+		pVeh->m_iRemovedSurfaces &&
+		(pVeh->m_iRemovedSurfaces & SHIPSURF_BROKEN_C) &&
+		(pVeh->m_iRemovedSurfaces & SHIPSURF_BROKEN_D) &&
+		(pVeh->m_iRemovedSurfaces & SHIPSURF_BROKEN_E) &&
+		(pVeh->m_iRemovedSurfaces & SHIPSURF_BROKEN_F)) )
+	{ //do some special stuff for when all the wings are torn off
+		FighterDamageRoutine(pVeh, parent, parentPS, riderPS, isDead);
+		pVeh->m_vOrientation[ROLL] = AngleNormalize180( pVeh->m_vOrientation[ROLL] );
+		return;
+	}
+
+	if ( !BG_UnrestrainedPitchRoll( riderPS, pVeh ) )
+	{
+		pVeh->m_vOrientation[ROLL] = PredictedAngularDecrement(0.95f, angleTimeMod*2.0f, pVeh->m_vOrientation[ROLL]);
+	}
+
+	isLandingOrLanded = (FighterIsLanding( pVeh, parentPS )||FighterIsLanded( pVeh, parentPS ));
+
+	if (!isLandingOrLanded)
+	{ //don't do this stuff while landed.. I guess. I don't want ships spinning in place, looks silly.
+		int m = 0;
+		float aVelDif;
+		float dForVel;
+
+		FighterWingMalfunctionCheck( pVeh, parentPS );
+
+		while (m < 3)
+		{
+			aVelDif = pVeh->m_vFullAngleVelocity[m];
+
+			if (aVelDif != 0.0f)
+			{
+				dForVel = (aVelDif*0.1f)*pVeh->m_fTimeModifier;
+				if (dForVel > 1.0f || dForVel < -1.0f)
+				{
+					pVeh->m_vOrientation[m] += dForVel;
+					pVeh->m_vOrientation[m] = AngleNormalize180(pVeh->m_vOrientation[m]);
+					if (m == PITCH)
+					{ //don't pitch downward into ground even more.
+						if (pVeh->m_vOrientation[m] > 90.0f && (pVeh->m_vOrientation[m]-dForVel) < 90.0f)
+						{
+							pVeh->m_vOrientation[m] = 90.0f;
+							pVeh->m_vFullAngleVelocity[m] = -pVeh->m_vFullAngleVelocity[m];
+						}
+					}
+					pVeh->m_vFullAngleVelocity[m] -= dForVel;
+				}
+				else
+				{
+					pVeh->m_vFullAngleVelocity[m] = 0.0f;
+				}
+			}
+
+			m++;
+		}
+	}
+	else
+	{ //clear decr/incr angles once landed.
+		VectorClear(pVeh->m_vFullAngleVelocity);
+	}
+
+	curRoll = pVeh->m_vOrientation[ROLL];
+
+	// If we're landed, we shouldn't be able to do anything but take off.
+	if ( isLandingOrLanded //going slow enough to start landing
+		&& !pVeh->m_iRemovedSurfaces 
+		&& parentPS->electrifyTime<curTime)//not spiraling out of control
+	{
+		if ( parentPS->speed > 0.0f )
+		{//Uh... what?  Why?
+			if ( pVeh->m_LandTrace.fraction < 0.3f )
+			{
+				pVeh->m_vOrientation[PITCH] = 0.0f;
+			}
+			else
+			{
+				pVeh->m_vOrientation[PITCH] = PredictedAngularDecrement(0.83f, angleTimeMod*10.0f, pVeh->m_vOrientation[PITCH]);
+			}
+		}
+		if ( pVeh->m_LandTrace.fraction > 0.1f 
+			|| pVeh->m_LandTrace.plane.normal[2] < MIN_LANDING_SLOPE )
+		{//off the ground, at least (or not on a valid landing surf)
+			// Dampen the turn rate based on the current height.
+#ifdef _JK2MP
+			FighterYawAdjust(pVeh, riderPS, parentPS);
+#else
+			pVeh->m_vOrientation[YAW] = riderPS->viewangles[YAW];//*pVeh->m_LandTrace.fraction;
+#endif
+		}
+		else
+		{
+			VectorClear( pVeh->m_vPrevRiderViewAngles );
+			pVeh->m_vPrevRiderViewAngles[YAW] = AngleNormalize180(riderPS->viewangles[YAW]);
+		}
+	}
+	else if ( (pVeh->m_iRemovedSurfaces||parentPS->electrifyTime>=curTime)//spiralling out of control
+		&& (!(pVeh->m_pParentEntity->s.number%4)||!(pVeh->m_pParentEntity->s.number%5)) )
+	{//no yaw control
+	}
+	else if ( pVeh->m_pPilot && pVeh->m_pPilot->s.number < MAX_CLIENTS && parentPS->speed > 0.0f )//&& !( pVeh->m_ucmd.forwardmove > 0 && pVeh->m_LandTrace.fraction != 1.0f ) )   
+	{
+		if ( 0 && BG_UnrestrainedPitchRoll( riderPS, pVeh ) )
+		{
+			VectorCopy( riderPS->viewangles, pVeh->m_vOrientation );
+			VectorCopy( riderPS->viewangles, parentPS->viewangles );
+#ifdef _JK2MP
+			//BG_ExternThisSoICanRecompileInDebug( pVeh, riderPS );
+#endif
+
+			curRoll = pVeh->m_vOrientation[ROLL];
+
+			FighterNoseMalfunctionCheck( pVeh, parentPS );
+
+			//VectorCopy( pVeh->m_vOrientation, parentPS->viewangles );
+		}
+		else
+		{
+			/*
+			float fTurnAmt[3];
+			//PITCH
+			fTurnAmt[PITCH] = riderPS->viewangles[PITCH] * 0.08f;
+			//YAW
+			fTurnAmt[YAW] = riderPS->viewangles[YAW] * 0.065f;
+			fTurnAmt[YAW] *= fTurnAmt[YAW];
+			// Dampen the turn rate based on the current height.
+			if ( riderPS->viewangles[YAW] < 0 )
+			{//must keep it negative because squaring a negative makes it positive
+				fTurnAmt[YAW] = -fTurnAmt[YAW];
+			}
+			fTurnAmt[YAW] *= pVeh->m_LandTrace.fraction;
+			//ROLL
+			fTurnAmt[2] = 0.0f;
+			*/
+
+			//Actal YAW
+#ifdef _JK2MP
+			/*
+			pVeh->m_vOrientation[ROLL] = curRoll;
+			FighterRollAdjust(pVeh, riderPS, parentPS);
+			curRoll = pVeh->m_vOrientation[ROLL];
+			*/
+			FighterYawAdjust(pVeh, riderPS, parentPS);
+#else
+			pVeh->m_vOrientation[YAW] = riderPS->viewangles[YAW];
+#endif
+
+			// If we are not hitting the ground, allow the fighter to pitch up and down.
+			if ( !FighterOverValidLandingSurface( pVeh ) 
+				|| parentPS->speed > MIN_LANDING_SPEED )
+			//if ( ( pVeh->m_LandTrace.fraction >= 1.0f || pVeh->m_ucmd.forwardmove != 0 ) && pVeh->m_LandTrace.fraction >= 0.0f )
+			{
+				float fYawDelta;
+
+#ifdef _JK2MP
+				FighterPitchAdjust(pVeh, riderPS, parentPS);
+				FighterPitchClamp( pVeh, riderPS, parentPS, curTime );
+#else
+				pVeh->m_vOrientation[PITCH] = riderPS->viewangles[PITCH]; 
+#endif
+
+				FighterNoseMalfunctionCheck( pVeh, parentPS );
+
+				// Adjust the roll based on the turn amount and dampen it a little.
+				fYawDelta = AngleSubtract(pVeh->m_vOrientation[YAW], pVeh->m_vPrevOrientation[YAW]); //pVeh->m_vOrientation[YAW] - pVeh->m_vPrevOrientation[YAW];
+				if ( fYawDelta > 8.0f ) 
+				{
+					fYawDelta = 8.0f;
+				}
+				else if ( fYawDelta < -8.0f )
+				{
+					fYawDelta = -8.0f;
+				}
+				curRoll -= fYawDelta;
+				curRoll = PredictedAngularDecrement(0.93f, angleTimeMod*2.0f, curRoll);
+
+				//cap it reasonably
+				//NOTE: was hardcoded to 40.0f, now using extern data
+				if ( !BG_UnrestrainedPitchRoll( riderPS, pVeh ) )
+				{
+					if ( pVeh->m_pVehicleInfo->rollLimit != -1 )
+					{
+						if (curRoll > pVeh->m_pVehicleInfo->rollLimit )
+						{
+							curRoll = pVeh->m_pVehicleInfo->rollLimit;
+						}
+						else if (curRoll < -pVeh->m_pVehicleInfo->rollLimit)
+						{
+							curRoll = -pVeh->m_pVehicleInfo->rollLimit;
+						}
+					}
+				}
+			}
+		}
+	}
+
+	// If you are directly impacting the ground, even out your pitch.
+	if ( isLandingOrLanded )    
+	{//only if capable of landing
+		if ( !isDead 
+			&& parentPS->electrifyTime<curTime
+			&& (!pVeh->m_pVehicleInfo->surfDestruction || !pVeh->m_iRemovedSurfaces ) )
+		{//not crashing or spiralling out of control...
+			if ( pVeh->m_vOrientation[PITCH] > 0 )
+			{
+				pVeh->m_vOrientation[PITCH] = PredictedAngularDecrement(0.2f, angleTimeMod*10.0f, pVeh->m_vOrientation[PITCH]);
+			}
+			else
+			{
+				pVeh->m_vOrientation[PITCH] = PredictedAngularDecrement(0.75f, angleTimeMod*10.0f, pVeh->m_vOrientation[PITCH]);
+			}
+		}
+	}
+
+
+/*
+//NOTE: all this is redundant now since we have the FighterDamageRoutine func...
+#ifdef _JK2MP //...yeah. Need to send armor across net for prediction to work.
+	if ( isDead )
+#else
+	if ( pVeh->m_iArmor <= 0 )
+#endif
+	{//going to explode
+		//FIXME: maybe make it erratically jerk or spin or start and stop?
+#ifndef _JK2MP
+		if ( g_speederControlScheme->value > 0 || !rider || rider->s.number )
+#else
+		if (1)
+#endif
+		{
+			pVeh->m_ucmd.rightmove = Q_irand( -64, 64 );
+		}
+		else
+		{
+			pVeh->m_ucmd.rightmove = 0;
+		}
+		pVeh->m_ucmd.forwardmove = Q_irand( -32, 127 );
+		pVeh->m_ucmd.upmove = Q_irand( -127, 127 );
+		pVeh->m_vOrientation[YAW] += Q_flrand( -10, 10 );
+		pVeh->m_vOrientation[PITCH] += pVeh->m_fTimeModifier; 
+		if ( pVeh->m_vOrientation[PITCH] > 60.0f )  
+		{
+			pVeh->m_vOrientation[PITCH] = 60.0f;
+		}
+		if ( pVeh->m_LandTrace.fraction != 0.0f )
+		{
+			parentPS->velocity[2] -= pVeh->m_pVehicleInfo->acceleration * pVeh->m_fTimeModifier;
+		}
+	}
+*/
+	// If no one is in this vehicle and it's up in the sky, pitch it forward as it comes tumbling down.
+#ifdef QAGAME //never gonna happen on client anyway, we can't be getting predicted unless the predicting client is boarded
+ 	if ( !pVeh->m_pVehicleInfo->Inhabited( pVeh ) 
+		&& pVeh->m_LandTrace.fraction >= groundFraction 
+		&& !FighterIsInSpace( (gentity_t *)parent ) 
+		&& !FighterSuspended( pVeh, parentPS ) )
+	{
+		pVeh->m_ucmd.upmove = 0;
+		//pVeh->m_ucmd.forwardmove = 0;
+		pVeh->m_vOrientation[PITCH] += pVeh->m_fTimeModifier; 
+		if ( !BG_UnrestrainedPitchRoll( riderPS, pVeh ) )
+		{
+			if ( pVeh->m_vOrientation[PITCH] > 60.0f )  
+			{
+				pVeh->m_vOrientation[PITCH] = 60.0f;
+			}
+		}
+	}
+#endif
+
+	if ( !parentPS->hackingTime )
+	{//use that roll
+		pVeh->m_vOrientation[ROLL] = curRoll;
+		//NOTE: this seems really backwards...
+		if ( pVeh->m_vOrientation[ROLL] )
+		{ //continually adjust the yaw based on the roll..
+			if ( (pVeh->m_iRemovedSurfaces||parentPS->electrifyTime>=curTime)//spiralling out of control
+				&& (!(pVeh->m_pParentEntity->s.number%4)||!(pVeh->m_pParentEntity->s.number%5)) )
+			{//leave YAW alone
+			}
+			else
+			{
+				if ( !BG_UnrestrainedPitchRoll( riderPS, pVeh ) )
+				{
+					pVeh->m_vOrientation[YAW] -= ((pVeh->m_vOrientation[ROLL])*0.05f)*pVeh->m_fTimeModifier;
+				}
+			}
+		}
+	}
+	else
+	{//add in strafing roll
+		float strafeRoll = (parentPS->hackingTime/MAX_STRAFE_TIME)*pVeh->m_pVehicleInfo->rollLimit;//pVeh->m_pVehicleInfo->bankingSpeed*
+		float strafeDif = AngleSubtract(strafeRoll, pVeh->m_vOrientation[ROLL]);
+		pVeh->m_vOrientation[ROLL] += (strafeDif*0.1f)*pVeh->m_fTimeModifier;
+		if ( !BG_UnrestrainedPitchRoll( riderPS, pVeh ) )
+		{//cap it reasonably
+			if ( pVeh->m_pVehicleInfo->rollLimit != -1 
+				&& !pVeh->m_iRemovedSurfaces 
+				&& parentPS->electrifyTime<curTime)
+			{
+				if (pVeh->m_vOrientation[ROLL] > pVeh->m_pVehicleInfo->rollLimit )
+				{
+					pVeh->m_vOrientation[ROLL] = pVeh->m_pVehicleInfo->rollLimit;
+				}
+				else if (pVeh->m_vOrientation[ROLL] < -pVeh->m_pVehicleInfo->rollLimit)
+				{
+					pVeh->m_vOrientation[ROLL] = -pVeh->m_pVehicleInfo->rollLimit;
+				}
+			}
+		}
+	}
+
+	if (pVeh->m_pVehicleInfo->surfDestruction)
+	{
+		FighterDamageRoutine(pVeh, parent, parentPS, riderPS, isDead);
+	}
+	pVeh->m_vOrientation[ROLL] = AngleNormalize180( pVeh->m_vOrientation[ROLL] );
+
+	/********************************************************************************/
+	/*	END	Here is where make sure the vehicle is properly oriented.	END			*/
+	/********************************************************************************/
+}
+
+#ifdef QAGAME //ONLY in SP or on server, not cgame
+
+extern void PM_SetAnim(pmove_t	*pm,int setAnimParts,int anim,int setAnimFlags, int blendTime);
+
+// This function makes sure that the vehicle is properly animated.
+static void AnimateVehicle( Vehicle_t *pVeh )
+{
+	int Anim = -1; 
+	int iFlags = SETANIM_FLAG_NORMAL, iBlend = 300;
+	qboolean isLanding = qfalse, isLanded = qfalse;
+#ifdef _JK2MP
+	playerState_t *parentPS = pVeh->m_pParentEntity->playerState;
+#else
+	playerState_t *parentPS = &pVeh->m_pParentEntity->client->ps;
+#endif
+#ifndef _JK2MP//SP
+	//nothing
+#elif QAGAME//MP GAME
+	int curTime = level.time;
+#elif CGAME//MP CGAME
+	//FIXME: pass in ucmd?  Not sure if this is reliable...
+	int curTime = pm->cmd.serverTime;
+#endif
+
+#ifdef _JK2MP
+	if ( parentPS->hyperSpaceTime
+		&& curTime - parentPS->hyperSpaceTime < HYPERSPACE_TIME )
+	{//Going to Hyperspace
+		//close the wings (FIXME: makes sense on X-Wing, not Shuttle?)
+		if ( pVeh->m_ulFlags & VEH_WINGSOPEN )
+		{
+			pVeh->m_ulFlags &= ~VEH_WINGSOPEN;
+			Anim = BOTH_WINGS_CLOSE;
+		}
+	}
+	else
+#endif
+	{
+		isLanding = FighterIsLanding( pVeh, parentPS );
+		isLanded = FighterIsLanded( pVeh, parentPS );
+
+		// if we're above launch height (way up in the air)... 
+		if ( !isLanding && !isLanded ) 
+		{
+			if ( !( pVeh->m_ulFlags & VEH_WINGSOPEN ) )
+			{
+				pVeh->m_ulFlags |= VEH_WINGSOPEN;
+				pVeh->m_ulFlags &= ~VEH_GEARSOPEN;
+				Anim = BOTH_WINGS_OPEN;
+			}
+		}
+		// otherwise we're below launch height and still taking off.
+		else
+		{
+			if ( (pVeh->m_ucmd.forwardmove < 0 || pVeh->m_ucmd.upmove < 0||isLanded)
+				&& pVeh->m_LandTrace.fraction <= 0.4f
+				&& pVeh->m_LandTrace.plane.normal[2] >= MIN_LANDING_SLOPE )
+			{//already landed or trying to land and close to ground
+				// Open gears.
+				if ( !( pVeh->m_ulFlags & VEH_GEARSOPEN ) )
+				{
+#ifdef _JK2MP
+					if ( pVeh->m_pVehicleInfo->soundLand )
+					{//just landed?
+#ifdef QAGAME//MP GAME-side
+						G_EntitySound( ((gentity_t *)(pVeh->m_pParentEntity)), CHAN_AUTO, pVeh->m_pVehicleInfo->soundLand );
+#elif CGAME//MP CGAME-side
+						//trap_S_StartSound( NULL, pVeh->m_pParentEntity->s.number, CHAN_AUTO, pVeh->m_pVehicleInfo->soundLand );
+#endif
+					}
+#endif
+					pVeh->m_ulFlags |= VEH_GEARSOPEN;
+					Anim = BOTH_GEARS_OPEN;
+				}
+			}
+			else
+			{//trying to take off and almost halfway off the ground
+				// Close gears (if they're open).
+				if ( pVeh->m_ulFlags & VEH_GEARSOPEN )
+				{
+					pVeh->m_ulFlags &= ~VEH_GEARSOPEN;
+					Anim = BOTH_GEARS_CLOSE;
+					//iFlags = SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLD; 
+				}
+				// If gears are closed, and we are below launch height, close the wings.
+				else
+				{
+					if ( pVeh->m_ulFlags & VEH_WINGSOPEN )
+					{
+						pVeh->m_ulFlags &= ~VEH_WINGSOPEN;
+						Anim = BOTH_WINGS_CLOSE;
+					}
+				}
+			}
+		}
+	}
+
+	if ( Anim != -1 )
+	{
+		#ifdef _JK2MP
+			BG_SetAnim(pVeh->m_pParentEntity->playerState, bgAllAnims[pVeh->m_pParentEntity->localAnimIndex].anims,
+				SETANIM_BOTH, Anim, iFlags, iBlend);
+		#else
+			NPC_SetAnim( pVeh->m_pParentEntity, SETANIM_BOTH, Anim, iFlags, iBlend );
+		#endif
+	}
+}
+
+// This function makes sure that the rider's in this vehicle are properly animated.
+static void AnimateRiders( Vehicle_t *pVeh )
+{
+}
+
+#endif //game-only
+
+#ifndef QAGAME
+void AttachRidersGeneric( Vehicle_t *pVeh );
+#endif
+
+void G_SetFighterVehicleFunctions( vehicleInfo_t *pVehInfo )
+{
+#ifdef QAGAME //ONLY in SP or on server, not cgame
+	pVehInfo->AnimateVehicle			=		AnimateVehicle;
+	pVehInfo->AnimateRiders				=		AnimateRiders;
+//	pVehInfo->ValidateBoard				=		ValidateBoard;
+//	pVehInfo->SetParent					=		SetParent;
+//	pVehInfo->SetPilot					=		SetPilot;
+//	pVehInfo->AddPassenger				=		AddPassenger;
+//	pVehInfo->Animate					=		Animate;
+	pVehInfo->Board						=		Board;
+	pVehInfo->Eject						=		Eject;
+//	pVehInfo->EjectAll					=		EjectAll;
+//	pVehInfo->StartDeathDelay			=		StartDeathDelay;
+//	pVehInfo->DeathUpdate				=		DeathUpdate;
+//	pVehInfo->RegisterAssets			=		RegisterAssets;
+//	pVehInfo->Initialize				=		Initialize;
+	pVehInfo->Update					=		Update;
+//	pVehInfo->UpdateRider				=		UpdateRider;
+#endif //game-only
+	pVehInfo->ProcessMoveCommands		=		ProcessMoveCommands;
+	pVehInfo->ProcessOrientCommands		=		ProcessOrientCommands;
+
+#ifndef QAGAME //cgame prediction attachment func
+	pVehInfo->AttachRiders				=		AttachRidersGeneric;
+#endif
+//	pVehInfo->AttachRiders				=		AttachRiders;
+//	pVehInfo->Ghost						=		Ghost;
+//	pVehInfo->UnGhost					=		UnGhost;
+//	pVehInfo->Inhabited					=		Inhabited;
+}
+
+// Following is only in game, not in namespace
+#ifdef _JK2MP
+#include "../namespace_end.h"
+#endif
+
+#ifdef QAGAME
+extern void G_AllocateVehicleObject(Vehicle_t **pVeh);
+#endif
+
+#ifdef _JK2MP
+#include "../namespace_begin.h"
+#endif
+
+// Create/Allocate a new Animal Vehicle (initializing it as well).
+void G_CreateFighterNPC( Vehicle_t **pVeh, const char *strType )
+{
+	// Allocate the Vehicle.
+#ifdef _JK2MP
+#ifdef QAGAME
+	//these will remain on entities on the client once allocated because the pointer is
+	//never stomped. on the server, however, when an ent is freed, the entity struct is
+	//memset to 0, so this memory would be lost..
+    G_AllocateVehicleObject(pVeh);
+#else
+	if (!*pVeh)
+	{ //only allocate a new one if we really have to
+		(*pVeh) = (Vehicle_t *) BG_Alloc( sizeof(Vehicle_t) );
+	}
+#endif
+	memset(*pVeh, 0, sizeof(Vehicle_t));
+#else
+	(*pVeh) = (Vehicle_t *) gi.Malloc( sizeof(Vehicle_t), TAG_G_ALLOC, qtrue );
+#endif
+	(*pVeh)->m_pVehicleInfo = &g_vehicleInfo[BG_VehicleGetIndex( strType )];
+}
+
+#ifdef _JK2MP
+
+#include "../namespace_end.h"
+
+//get rid of all the crazy defs we added for this file
+#undef currentAngles
+#undef currentOrigin
+#undef mins
+#undef maxs
+#undef legsAnimTimer
+#undef torsoAnimTimer
+#undef bool
+#undef false
+#undef true
+
+#undef sqrtf
+#undef Q_flrand
+
+#undef MOD_EXPLOSIVE
+#endif
diff --git a/codemp/game/JK2_game.def b/codemp/game/JK2_game.def
new file mode 100644
index 0000000..ea649b4
--- /dev/null
+++ b/codemp/game/JK2_game.def
@@ -0,0 +1,3 @@
+EXPORTS
+	dllEntry
+	vmMain
diff --git a/codemp/game/JK2_game.vcproj b/codemp/game/JK2_game.vcproj
new file mode 100644
index 0000000..7856483
--- /dev/null
+++ b/codemp/game/JK2_game.vcproj
@@ -0,0 +1,744 @@
+<?xml version="1.0" encoding = "Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="7.00"
+	Name="JK2game"
+	SccProjectName="&quot;$/jedi/codemp/game&quot;, EGAAAAAA"
+	SccAuxPath=""
+	SccLocalPath="."
+	SccProvider="MSSCCI:Microsoft Visual SourceSafe">
+	<Platforms>
+		<Platform
+			Name="Win32"/>
+	</Platforms>
+	<Configurations>
+		<Configuration
+			Name="Release|Win32"
+			OutputDirectory=".\../Release"
+			IntermediateDirectory=".\../Release/JK2game"
+			ConfigurationType="2"
+			UseOfMFC="0"
+			ATLMinimizesCRunTimeLibraryUsage="FALSE">
+			<Tool
+				Name="VCCLCompilerTool"
+				InlineFunctionExpansion="2"
+				EnableIntrinsicFunctions="TRUE"
+				ImproveFloatingPointConsistency="TRUE"
+				FavorSizeOrSpeed="1"
+				OptimizeForProcessor="2"
+				OptimizeForWindowsApplication="TRUE"
+				PreprocessorDefinitions="NDEBUG;WIN32;_WINDOWS;MISSIONPACK;QAGAME;_JK2"
+				StringPooling="TRUE"
+				MinimalRebuild="TRUE"
+				RuntimeLibrary="4"
+				BufferSecurityCheck="FALSE"
+				EnableFunctionLevelLinking="TRUE"
+				UsePrecompiledHeader="2"
+				PrecompiledHeaderFile=".\../Release/JK2game/JK2_game.pch"
+				AssemblerListingLocation=".\../Release/JK2game/"
+				ObjectFile=".\../Release/JK2game/"
+				ProgramDataBaseFileName=".\../Release/JK2game/"
+				WarningLevel="4"
+				SuppressStartupBanner="TRUE"
+				DebugInformationFormat="3"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalOptions="/MACHINE:I386"
+				AdditionalDependencies="winmm.lib"
+				OutputFile="../Release/jampgamex86.dll"
+				LinkIncremental="1"
+				SuppressStartupBanner="TRUE"
+				ModuleDefinitionFile=".\JK2_game.def"
+				GenerateDebugInformation="TRUE"
+				ProgramDatabaseFile=".\../Release/jampgamex86.pdb"
+				GenerateMapFile="TRUE"
+				MapFileName="../Release/jampgamex86.map"
+				SubSystem="2"
+				OptimizeReferences="2"
+				EnableCOMDATFolding="2"
+				SetChecksum="TRUE"
+				BaseAddress="0x20000000"
+				ImportLibrary=".\../Release/jampgamex86.lib"/>
+			<Tool
+				Name="VCMIDLTool"
+				PreprocessorDefinitions="NDebug"
+				MkTypLibCompatible="TRUE"
+				SuppressStartupBanner="TRUE"
+				TargetEnvironment="1"
+				TypeLibraryName=".\../Release/JK2_game.tlb"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="VCResourceCompilerTool"
+				PreprocessorDefinitions="NDebug"
+				Culture="1033"/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"/>
+			<Tool
+				Name="VCWebDeploymentTool"/>
+		</Configuration>
+		<Configuration
+			Name="Final|Win32"
+			OutputDirectory=".\../Final"
+			IntermediateDirectory=".\../Final/JK2game"
+			ConfigurationType="2"
+			UseOfMFC="0"
+			ATLMinimizesCRunTimeLibraryUsage="FALSE">
+			<Tool
+				Name="VCCLCompilerTool"
+				InlineFunctionExpansion="2"
+				EnableIntrinsicFunctions="TRUE"
+				ImproveFloatingPointConsistency="TRUE"
+				FavorSizeOrSpeed="1"
+				OptimizeForProcessor="2"
+				OptimizeForWindowsApplication="TRUE"
+				PreprocessorDefinitions="NDEBUG;_WINDOWS;MISSIONPACK;QAGAME;WIN32;_JK2;FINAL_BUILD"
+				StringPooling="TRUE"
+				RuntimeLibrary="4"
+				BufferSecurityCheck="FALSE"
+				EnableFunctionLevelLinking="TRUE"
+				UsePrecompiledHeader="2"
+				PrecompiledHeaderFile=".\../Final/JK2game/JK2_game.pch"
+				AssemblerListingLocation=".\../Final/JK2game/"
+				ObjectFile=".\../Final/JK2game/"
+				ProgramDataBaseFileName=".\../Final/JK2game/"
+				WarningLevel="4"
+				SuppressStartupBanner="TRUE"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalOptions="/MACHINE:I386"
+				AdditionalDependencies="winmm.lib"
+				OutputFile="../Final/jampgamex86.dll"
+				LinkIncremental="1"
+				SuppressStartupBanner="TRUE"
+				ModuleDefinitionFile=".\JK2_game.def"
+				ProgramDatabaseFile=""
+				GenerateMapFile="TRUE"
+				MapFileName=".\../Final/jampgamex86.map"
+				MapLines="TRUE"
+				SubSystem="2"
+				OptimizeReferences="2"
+				EnableCOMDATFolding="2"
+				SetChecksum="TRUE"
+				BaseAddress="0x20000000"
+				ImportLibrary=".\../Final/jampgamex86.lib"/>
+			<Tool
+				Name="VCMIDLTool"
+				PreprocessorDefinitions="NDebug"
+				MkTypLibCompatible="TRUE"
+				SuppressStartupBanner="TRUE"
+				TargetEnvironment="1"
+				TypeLibraryName=".\../Final/JK2_game.tlb"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="VCResourceCompilerTool"
+				PreprocessorDefinitions="NDebug"
+				Culture="1033"/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"/>
+			<Tool
+				Name="VCWebDeploymentTool"/>
+		</Configuration>
+		<Configuration
+			Name="Debug|Win32"
+			OutputDirectory=".\../Debug"
+			IntermediateDirectory=".\../Debug/JK2game"
+			ConfigurationType="2"
+			UseOfMFC="0"
+			ATLMinimizesCRunTimeLibraryUsage="FALSE">
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				OptimizeForProcessor="2"
+				PreprocessorDefinitions="_DEBUG;BUILDING_REF_GL;Debug;WIN32;_WINDOWS;MISSIONPACK;QAGAME;_JK2;JK2AWARDS"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="5"
+				UsePrecompiledHeader="2"
+				PrecompiledHeaderFile=".\../Debug/JK2game/JK2_game.pch"
+				AssemblerListingLocation=".\../Debug/JK2game/"
+				ObjectFile=".\../Debug/JK2game/"
+				ProgramDataBaseFileName=".\../Debug/JK2game/"
+				BrowseInformation="1"
+				WarningLevel="3"
+				SuppressStartupBanner="TRUE"
+				DebugInformationFormat="4"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalOptions="/MACHINE:I386"
+				AdditionalDependencies="winmm.lib"
+				OutputFile="..\Debug\jampgamex86.dll"
+				LinkIncremental="2"
+				SuppressStartupBanner="TRUE"
+				ModuleDefinitionFile=".\JK2_game.def"
+				GenerateDebugInformation="TRUE"
+				ProgramDatabaseFile=".\../Debug/jampgamex86.pdb"
+				GenerateMapFile="TRUE"
+				MapFileName="../Debug/jampgamex86.map"
+				SubSystem="2"
+				BaseAddress="0x20000000"
+				ImportLibrary=".\../Debug/jampgamex86.lib"/>
+			<Tool
+				Name="VCMIDLTool"
+				PreprocessorDefinitions="_Debug"
+				MkTypLibCompatible="TRUE"
+				SuppressStartupBanner="TRUE"
+				TargetEnvironment="1"
+				TypeLibraryName=".\../Debug/JK2_game.tlb"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="VCResourceCompilerTool"
+				PreprocessorDefinitions="_Debug"
+				Culture="1033"/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"/>
+			<Tool
+				Name="VCWebDeploymentTool"/>
+		</Configuration>
+		<Configuration
+			Name="Debug(SH)|Win32"
+			OutputDirectory="Debug(SH)"
+			IntermediateDirectory="Debug(SH)"
+			ConfigurationType="2"
+			UseOfMFC="0"
+			ATLMinimizesCRunTimeLibraryUsage="FALSE">
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				OptimizeForProcessor="2"
+				PreprocessorDefinitions="_DEBUG;BUILDING_REF_GL;Debug;WIN32;_WINDOWS;MISSIONPACK;QAGAME;_JK2;JK2AWARDS"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="5"
+				UsePrecompiledHeader="2"
+				PrecompiledHeaderFile=".\../Debug/JK2game/JK2_game.pch"
+				AssemblerListingLocation=".\../Debug/JK2game/"
+				ObjectFile=".\../Debug/JK2game/"
+				ProgramDataBaseFileName=".\../Debug/JK2game/"
+				BrowseInformation="1"
+				WarningLevel="3"
+				SuppressStartupBanner="TRUE"
+				DebugInformationFormat="4"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalOptions="/MACHINE:I386"
+				AdditionalDependencies="winmm.lib"
+				OutputFile="..\Debug\jampgamex86.dll"
+				LinkIncremental="2"
+				SuppressStartupBanner="TRUE"
+				ModuleDefinitionFile=".\JK2_game.def"
+				GenerateDebugInformation="TRUE"
+				ProgramDatabaseFile=".\../Debug/jampgamex86.pdb"
+				GenerateMapFile="TRUE"
+				MapFileName=".\../Debug/jampgamex86.map"
+				SubSystem="2"
+				BaseAddress="0x20000000"
+				ImportLibrary=".\../Debug/jampgamex86.lib"/>
+			<Tool
+				Name="VCMIDLTool"
+				PreprocessorDefinitions="_Debug"
+				MkTypLibCompatible="TRUE"
+				SuppressStartupBanner="TRUE"
+				TargetEnvironment="1"
+				TypeLibraryName=".\../Debug/JK2_game.tlb"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="VCResourceCompilerTool"
+				PreprocessorDefinitions="_Debug"
+				Culture="1033"/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"/>
+			<Tool
+				Name="VCWebDeploymentTool"/>
+		</Configuration>
+	</Configurations>
+	<Files>
+		<Filter
+			Name="Source Files"
+			Filter="cpp;c;cxx;rc;def;r;odl;hpj;bat;for;f90">
+			<File
+				RelativePath="AnimalNPC.c">
+			</File>
+			<File
+				RelativePath="FighterNPC.c">
+			</File>
+			<File
+				RelativePath=".\NPC.c">
+			</File>
+			<File
+				RelativePath=".\NPC_AI_Atst.c">
+			</File>
+			<File
+				RelativePath=".\NPC_AI_Default.c">
+			</File>
+			<File
+				RelativePath=".\NPC_AI_Droid.c">
+			</File>
+			<File
+				RelativePath=".\NPC_AI_GalakMech.c">
+			</File>
+			<File
+				RelativePath=".\NPC_AI_Grenadier.c">
+			</File>
+			<File
+				RelativePath=".\NPC_AI_Howler.c">
+			</File>
+			<File
+				RelativePath=".\NPC_AI_ImperialProbe.c">
+			</File>
+			<File
+				RelativePath=".\NPC_AI_Interrogator.c">
+			</File>
+			<File
+				RelativePath=".\NPC_AI_Jedi.c">
+			</File>
+			<File
+				RelativePath=".\NPC_AI_Mark1.c">
+			</File>
+			<File
+				RelativePath=".\NPC_AI_Mark2.c">
+			</File>
+			<File
+				RelativePath=".\NPC_AI_MineMonster.c">
+			</File>
+			<File
+				RelativePath="NPC_AI_Rancor.c">
+			</File>
+			<File
+				RelativePath=".\NPC_AI_Remote.c">
+			</File>
+			<File
+				RelativePath=".\NPC_AI_Seeker.c">
+			</File>
+			<File
+				RelativePath=".\NPC_AI_Sentry.c">
+			</File>
+			<File
+				RelativePath=".\NPC_AI_Sniper.c">
+			</File>
+			<File
+				RelativePath=".\NPC_AI_Stormtrooper.c">
+			</File>
+			<File
+				RelativePath=".\NPC_AI_Utils.c">
+			</File>
+			<File
+				RelativePath="NPC_AI_Wampa.c">
+			</File>
+			<File
+				RelativePath=".\NPC_behavior.c">
+			</File>
+			<File
+				RelativePath=".\NPC_combat.c">
+			</File>
+			<File
+				RelativePath=".\NPC_goal.c">
+			</File>
+			<File
+				RelativePath=".\NPC_misc.c">
+			</File>
+			<File
+				RelativePath=".\NPC_move.c">
+			</File>
+			<File
+				RelativePath=".\NPC_reactions.c">
+			</File>
+			<File
+				RelativePath=".\NPC_senses.c">
+			</File>
+			<File
+				RelativePath=".\NPC_sounds.c">
+			</File>
+			<File
+				RelativePath=".\NPC_spawn.c">
+			</File>
+			<File
+				RelativePath=".\NPC_stats.c">
+			</File>
+			<File
+				RelativePath=".\NPC_utils.c">
+			</File>
+			<File
+				RelativePath="SpeederNPC.c">
+			</File>
+			<File
+				RelativePath="WalkerNPC.c">
+			</File>
+			<File
+				RelativePath=".\ai_main.c">
+			</File>
+			<File
+				RelativePath=".\ai_util.c">
+			</File>
+			<File
+				RelativePath=".\ai_wpnav.c">
+			</File>
+			<File
+				RelativePath="bg_g2_utils.c">
+			</File>
+			<File
+				RelativePath=".\bg_lib.c">
+				<FileConfiguration
+					Name="Release|Win32"
+					ExcludedFromBuild="TRUE">
+					<Tool
+						Name="VCCLCompilerTool"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Final|Win32"
+					ExcludedFromBuild="TRUE">
+					<Tool
+						Name="VCCLCompilerTool"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32"
+					ExcludedFromBuild="TRUE">
+					<Tool
+						Name="VCCLCompilerTool"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32"
+					ExcludedFromBuild="TRUE">
+					<Tool
+						Name="VCCLCompilerTool"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\bg_misc.c">
+			</File>
+			<File
+				RelativePath=".\bg_panimate.c">
+			</File>
+			<File
+				RelativePath=".\bg_pmove.c">
+			</File>
+			<File
+				RelativePath=".\bg_saber.c">
+			</File>
+			<File
+				RelativePath="bg_saberLoad.c">
+			</File>
+			<File
+				RelativePath="bg_saga.c">
+			</File>
+			<File
+				RelativePath=".\bg_slidemove.c">
+			</File>
+			<File
+				RelativePath="bg_vehicleLoad.c">
+			</File>
+			<File
+				RelativePath=".\bg_weapons.c">
+			</File>
+			<File
+				RelativePath=".\g_ICARUScb.c">
+			</File>
+			<File
+				RelativePath=".\g_active.c">
+			</File>
+			<File
+				RelativePath=".\g_arenas.c">
+			</File>
+			<File
+				RelativePath=".\g_bot.c">
+			</File>
+			<File
+				RelativePath=".\g_client.c">
+			</File>
+			<File
+				RelativePath=".\g_cmds.c">
+			</File>
+			<File
+				RelativePath=".\g_combat.c">
+			</File>
+			<File
+				RelativePath=".\g_exphysics.c">
+			</File>
+			<File
+				RelativePath=".\g_items.c">
+			</File>
+			<File
+				RelativePath=".\g_log.c">
+			</File>
+			<File
+				RelativePath=".\g_main.c">
+			</File>
+			<File
+				RelativePath=".\g_mem.c">
+			</File>
+			<File
+				RelativePath=".\g_misc.c">
+			</File>
+			<File
+				RelativePath=".\g_missile.c">
+			</File>
+			<File
+				RelativePath=".\g_mover.c">
+			</File>
+			<File
+				RelativePath=".\g_nav.c">
+			</File>
+			<File
+				RelativePath=".\g_navnew.c">
+			</File>
+			<File
+				RelativePath=".\g_object.c">
+			</File>
+			<File
+				RelativePath=".\g_saga.c">
+			</File>
+			<File
+				RelativePath=".\g_session.c">
+			</File>
+			<File
+				RelativePath=".\g_spawn.c">
+			</File>
+			<File
+				RelativePath=".\g_strap.c">
+			</File>
+			<File
+				RelativePath=".\g_svcmds.c">
+			</File>
+			<File
+				RelativePath=".\g_syscalls.c">
+			</File>
+			<File
+				RelativePath=".\g_target.c">
+			</File>
+			<File
+				RelativePath=".\g_team.c">
+			</File>
+			<File
+				RelativePath=".\g_timer.c">
+			</File>
+			<File
+				RelativePath=".\g_trigger.c">
+			</File>
+			<File
+				RelativePath="g_turret.c">
+			</File>
+			<File
+				RelativePath="g_turret_G2.c">
+			</File>
+			<File
+				RelativePath=".\g_utils.c">
+			</File>
+			<File
+				RelativePath="g_vehicleTurret.c">
+			</File>
+			<File
+				RelativePath="g_vehicles.c">
+			</File>
+			<File
+				RelativePath=".\g_weapon.c">
+			</File>
+			<File
+				RelativePath=".\q_math.c">
+			</File>
+			<File
+				RelativePath=".\q_shared.c">
+			</File>
+			<File
+				RelativePath="tri_coll_test.c">
+			</File>
+			<File
+				RelativePath=".\w_force.c">
+			</File>
+			<File
+				RelativePath=".\w_saber.c">
+			</File>
+		</Filter>
+		<Filter
+			Name="Header Files"
+			Filter="h;hpp;hxx;hm;inl;fi;fd">
+			<File
+				RelativePath="..\ghoul2\G2.h">
+			</File>
+			<File
+				RelativePath=".\JK2_game.def">
+			</File>
+			<File
+				RelativePath=".\ai.h">
+			</File>
+			<File
+				RelativePath=".\ai_main.h">
+			</File>
+			<File
+				RelativePath=".\anims.h">
+			</File>
+			<File
+				RelativePath="..\cgame\animtable.h">
+			</File>
+			<File
+				RelativePath=".\b_local.h">
+			</File>
+			<File
+				RelativePath=".\b_public.h">
+			</File>
+			<File
+				RelativePath=".\be_aas.h">
+			</File>
+			<File
+				RelativePath=".\be_ai_char.h">
+			</File>
+			<File
+				RelativePath=".\be_ai_chat.h">
+			</File>
+			<File
+				RelativePath=".\be_ai_gen.h">
+			</File>
+			<File
+				RelativePath=".\be_ai_goal.h">
+			</File>
+			<File
+				RelativePath=".\be_ai_move.h">
+			</File>
+			<File
+				RelativePath=".\be_ai_weap.h">
+			</File>
+			<File
+				RelativePath=".\be_ea.h">
+			</File>
+			<File
+				RelativePath=".\bg_lib.h">
+			</File>
+			<File
+				RelativePath=".\bg_local.h">
+			</File>
+			<File
+				RelativePath=".\bg_public.h">
+			</File>
+			<File
+				RelativePath=".\bg_saga.h">
+			</File>
+			<File
+				RelativePath=".\bg_strap.h">
+			</File>
+			<File
+				RelativePath="bg_vehicles.h">
+			</File>
+			<File
+				RelativePath=".\bg_weapons.h">
+			</File>
+			<File
+				RelativePath=".\botlib.h">
+			</File>
+			<File
+				RelativePath="..\cgame\cg_local.h">
+			</File>
+			<File
+				RelativePath="..\cgame\cg_public.h">
+			</File>
+			<File
+				RelativePath=".\chars.h">
+			</File>
+			<File
+				RelativePath="..\qcommon\disablewarnings.h">
+			</File>
+			<File
+				RelativePath=".\g_ICARUScb.h">
+			</File>
+			<File
+				RelativePath="g_headers.h">
+			</File>
+			<File
+				RelativePath=".\g_local.h">
+			</File>
+			<File
+				RelativePath=".\g_nav.h">
+			</File>
+			<File
+				RelativePath=".\g_public.h">
+			</File>
+			<File
+				RelativePath=".\g_team.h">
+			</File>
+			<File
+				RelativePath=".\inv.h">
+			</File>
+			<File
+				RelativePath=".\match.h">
+			</File>
+			<File
+				RelativePath="..\..\ui\menudef.h">
+			</File>
+			<File
+				RelativePath=".\npc_headers.h">
+			</File>
+			<File
+				RelativePath=".\q_shared.h">
+			</File>
+			<File
+				RelativePath=".\say.h">
+			</File>
+			<File
+				RelativePath=".\surfaceflags.h">
+			</File>
+			<File
+				RelativePath=".\syn.h">
+			</File>
+			<File
+				RelativePath="..\qcommon\tags.h">
+			</File>
+			<File
+				RelativePath=".\teams.h">
+			</File>
+			<File
+				RelativePath="..\cgame\tr_types.h">
+			</File>
+			<File
+				RelativePath=".\w_saber.h">
+			</File>
+			<Filter
+				Name="ICARUS Headers"
+				Filter="">
+				<File
+					RelativePath="..\icarus\Q3_Interface.h">
+				</File>
+				<File
+					RelativePath="..\icarus\interpreter.h">
+				</File>
+			</Filter>
+		</Filter>
+		<Filter
+			Name="win32"
+			Filter="">
+			<File
+				RelativePath="..\win32\JK2game.rc">
+			</File>
+		</Filter>
+		<File
+			RelativePath=".\game.bat">
+		</File>
+		<File
+			RelativePath=".\game.q3asm">
+		</File>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>
diff --git a/codemp/game/JK2_game.vcproj.vspscc b/codemp/game/JK2_game.vcproj.vspscc
new file mode 100644
index 0000000..7c9b6bb
--- /dev/null
+++ b/codemp/game/JK2_game.vcproj.vspscc
@@ -0,0 +1,10 @@
+""
+{
+"FILE_VERSION" = "9237"
+"ENLISTMENT_CHOICE" = "NEVER"
+"PROJECT_FILE_RELATIVE_PATH" = ""
+"NUMBER_OF_EXCLUDED_FILES" = "0"
+"ORIGINAL_PROJECT_FILE_PATH" = "file:C:\\projects\\Jedi\\codemp\\game\\JK2_game.vcproj"
+"NUMBER_OF_NESTED_PROJECTS" = "0"
+"SOURCE_CONTROL_SETTINGS_PROVIDER" = "PROJECT"
+}
diff --git a/codemp/game/NPC.c b/codemp/game/NPC.c
new file mode 100644
index 0000000..f5f22c6
--- /dev/null
+++ b/codemp/game/NPC.c
@@ -0,0 +1,2110 @@
+//
+// NPC.cpp - generic functions
+//
+#include "b_local.h"
+#include "anims.h"
+#include "say.h"
+#include "../icarus/Q3_Interface.h"
+
+extern vec3_t playerMins;
+extern vec3_t playerMaxs;
+//extern void PM_SetAnimFinal(int *torsoAnim,int *legsAnim,int type,int anim,int priority,int *torsoAnimTimer,int *legsAnimTimer,gentity_t *gent);
+extern void G_SoundOnEnt( gentity_t *ent, soundChannel_t channel, const char *soundPath );
+extern void PM_SetTorsoAnimTimer( gentity_t *ent, int *torsoAnimTimer, int time );
+extern void PM_SetLegsAnimTimer( gentity_t *ent, int *legsAnimTimer, int time );
+extern void NPC_BSNoClip ( void );
+extern void G_AddVoiceEvent( gentity_t *self, int event, int speakDebounceTime );
+extern void NPC_ApplyRoff (void);
+extern void NPC_TempLookTarget ( gentity_t *self, int lookEntNum, int minLookTime, int maxLookTime );
+extern void NPC_CheckPlayerAim ( void );
+extern void NPC_CheckAllClear ( void );
+extern void G_AddVoiceEvent( gentity_t *self, int event, int speakDebounceTime );
+extern qboolean NPC_CheckLookTarget( gentity_t *self );
+extern void NPC_SetLookTarget( gentity_t *self, int entNum, int clearTime );
+extern void Mark1_dying( gentity_t *self );
+extern void NPC_BSCinematic( void );
+extern int GetTime ( int lastTime );
+extern void NPC_BSGM_Default( void );
+extern void NPC_CheckCharmed( void );
+extern qboolean Boba_Flying( gentity_t *self );
+
+extern vmCvar_t		g_saberRealisticCombat;
+
+//Local Variables
+gentity_t		*NPC;
+gNPC_t			*NPCInfo;
+gclient_t		*client;
+usercmd_t		ucmd;
+visibility_t	enemyVisibility;
+
+void NPC_SetAnim(gentity_t	*ent,int type,int anim,int priority);
+void pitch_roll_for_slope( gentity_t *forwhom, vec3_t pass_slope );
+extern void GM_Dying( gentity_t *self );
+
+extern int eventClearTime;
+
+void CorpsePhysics( gentity_t *self )
+{
+	// run the bot through the server like it was a real client
+	memset( &ucmd, 0, sizeof( ucmd ) );
+	ClientThink( self->s.number, &ucmd );
+	//VectorCopy( self->s.origin, self->s.origin2 );
+	//rww - don't get why this is happening.
+	
+	if ( self->client->NPC_class == CLASS_GALAKMECH )
+	{
+		GM_Dying( self );
+	}
+	//FIXME: match my pitch and roll for the slope of my groundPlane
+	if ( self->client->ps.groundEntityNum != ENTITYNUM_NONE && !(self->s.eFlags&EF_DISINTEGRATION) )
+	{//on the ground
+		//FIXME: check 4 corners
+		pitch_roll_for_slope( self, NULL );
+	}
+
+	if ( eventClearTime == level.time + ALERT_CLEAR_TIME )
+	{//events were just cleared out so add me again
+		if ( !(self->client->ps.eFlags&EF_NODRAW) )
+		{
+			AddSightEvent( self->enemy, self->r.currentOrigin, 384, AEL_DISCOVERED, 0.0f );
+		}
+	}
+
+	if ( level.time - self->s.time > 3000 )
+	{//been dead for 3 seconds
+		if ( g_dismember.integer < 11381138 && !g_saberRealisticCombat.integer )
+		{//can't be dismembered once dead
+			if ( self->client->NPC_class != CLASS_PROTOCOL )
+			{
+			//	self->client->dismembered = qtrue;
+			}
+		}
+	}
+
+	//if ( level.time - self->s.time > 500 )
+	if (self->client->respawnTime < (level.time+500))
+	{//don't turn "nonsolid" until about 1 second after actual death
+
+		if (self->client->ps.eFlags & EF_DISINTEGRATION)
+		{
+			self->r.contents = 0;
+		}
+		else if ((self->client->NPC_class != CLASS_MARK1) && (self->client->NPC_class != CLASS_INTERROGATOR))	// The Mark1 & Interrogator stays solid.
+		{
+			self->r.contents = CONTENTS_CORPSE;
+			//self->r.maxs[2] = -8;
+		}
+
+		if ( self->message )
+		{
+			self->r.contents |= CONTENTS_TRIGGER;
+		}
+	}
+}
+
+/*
+----------------------------------------
+NPC_RemoveBody
+
+Determines when it's ok to ditch the corpse
+----------------------------------------
+*/
+#define REMOVE_DISTANCE		128
+#define REMOVE_DISTANCE_SQR (REMOVE_DISTANCE * REMOVE_DISTANCE)
+
+void NPC_RemoveBody( gentity_t *self )
+{
+	CorpsePhysics( self );
+
+	self->nextthink = level.time + FRAMETIME;
+
+	if ( self->NPC->nextBStateThink <= level.time )
+	{
+		trap_ICARUS_MaintainTaskManager(self->s.number);
+	}
+	self->NPC->nextBStateThink = level.time + FRAMETIME;
+
+	if ( self->message )
+	{//I still have a key
+		return;
+	}
+
+	// I don't consider this a hack, it's creative coding . . . 
+	// I agree, very creative... need something like this for ATST and GALAKMECH too!
+	if (self->client->NPC_class == CLASS_MARK1)
+	{
+		Mark1_dying( self );
+	}
+
+	// Since these blow up, remove the bounding box.
+	if ( self->client->NPC_class == CLASS_REMOTE 
+		|| self->client->NPC_class == CLASS_SENTRY
+		|| self->client->NPC_class == CLASS_PROBE
+		|| self->client->NPC_class == CLASS_INTERROGATOR
+		|| self->client->NPC_class == CLASS_PROBE
+		|| self->client->NPC_class == CLASS_MARK2 )
+	{
+		//if ( !self->taskManager || !self->taskManager->IsRunning() )
+		if (!trap_ICARUS_IsRunning(self->s.number))
+		{
+			if ( !self->activator || !self->activator->client || !(self->activator->client->ps.eFlags2&EF2_HELD_BY_MONSTER) )
+			{//not being held by a Rancor
+				G_FreeEntity( self );
+			}
+		}
+		return;
+	}
+
+	//FIXME: don't ever inflate back up?
+	self->r.maxs[2] = self->client->renderInfo.eyePoint[2] - self->r.currentOrigin[2] + 4;
+	if ( self->r.maxs[2] < -8 )
+	{
+		self->r.maxs[2] = -8;
+	}
+
+	if ( self->client->NPC_class == CLASS_GALAKMECH )
+	{//never disappears
+		return;
+	}
+	if ( self->NPC && self->NPC->timeOfDeath <= level.time )
+	{
+		self->NPC->timeOfDeath = level.time + 1000;
+		// Only do all of this nonsense for Scav boys ( and girls )
+	///	if ( self->client->playerTeam == NPCTEAM_SCAVENGERS || self->client->playerTeam == NPCTEAM_KLINGON 
+	//		|| self->client->playerTeam == NPCTEAM_HIROGEN || self->client->playerTeam == NPCTEAM_MALON )
+		// should I check NPC_class here instead of TEAM ? - dmv
+		if( self->client->playerTeam == NPCTEAM_ENEMY || self->client->NPC_class == CLASS_PROTOCOL )
+		{
+			self->nextthink = level.time + FRAMETIME; // try back in a second
+
+			/*
+			if ( DistanceSquared( g_entities[0].r.currentOrigin, self->r.currentOrigin ) <= REMOVE_DISTANCE_SQR )
+			{
+				return;
+			}
+
+			if ( (InFOV( self, &g_entities[0], 110, 90 )) ) // generous FOV check
+			{
+				if ( (NPC_ClearLOS2( &g_entities[0], self->r.currentOrigin )) )
+				{
+					return;
+				}
+			}
+			*/
+			//Don't care about this for MP I guess.
+		}
+
+		//FIXME: there are some conditions - such as heavy combat - in which we want
+		//			to remove the bodies... but in other cases it's just weird, like
+		//			when they're right behind you in a closed room and when they've been
+		//			placed as dead NPCs by a designer...
+		//			For now we just assume that a corpse with no enemy was 
+		//			placed in the map as a corpse
+		if ( self->enemy )
+		{
+			//if ( !self->taskManager || !self->taskManager->IsRunning() )
+			if (!trap_ICARUS_IsRunning(self->s.number))
+			{
+				if ( !self->activator || !self->activator->client || !(self->activator->client->ps.eFlags2&EF2_HELD_BY_MONSTER) )
+				{//not being held by a Rancor
+					if ( self->client && self->client->ps.saberEntityNum > 0 && self->client->ps.saberEntityNum < ENTITYNUM_WORLD )
+					{
+						gentity_t *saberent = &g_entities[self->client->ps.saberEntityNum];
+						if ( saberent )
+						{
+							G_FreeEntity( saberent );
+						}
+					}
+					G_FreeEntity( self );
+				}
+			}
+		}
+	}
+}
+
+/*
+----------------------------------------
+NPC_RemoveBody
+
+Determines when it's ok to ditch the corpse
+----------------------------------------
+*/
+
+int BodyRemovalPadTime( gentity_t *ent )
+{
+	int	time;
+
+	if ( !ent || !ent->client )
+		return 0;
+/*
+	switch ( ent->client->playerTeam )
+	{
+	case NPCTEAM_KLINGON:	// no effect, we just remove them when the player isn't looking
+	case NPCTEAM_SCAVENGERS:
+	case NPCTEAM_HIROGEN:
+	case NPCTEAM_MALON:
+	case NPCTEAM_IMPERIAL:
+	case NPCTEAM_STARFLEET:
+		time = 10000; // 15 secs.
+		break;
+
+	case NPCTEAM_BORG:
+		time = 2000;
+		break;
+
+	case NPCTEAM_STASIS:
+		return qtrue;
+		break;
+
+	case NPCTEAM_FORGE:
+		time = 1000;
+		break;
+
+	case NPCTEAM_BOTS:
+//		if (!Q_stricmp( ent->NPC_type, "mouse" ))
+//		{
+			time = 0;
+//		}
+//		else
+//		{
+//			time = 10000;
+//		}
+		break;
+
+	case NPCTEAM_8472:
+		time = 2000;
+		break;
+
+	default:
+		// never go away
+		time = Q3_INFINITE;
+		break;
+	}
+*/
+	// team no longer indicates species/race, so in this case we'd use NPC_class, but
+	switch( ent->client->NPC_class )
+	{
+	case CLASS_MOUSE:
+	case CLASS_GONK:
+	case CLASS_R2D2:
+	case CLASS_R5D2:
+	//case CLASS_PROTOCOL:
+	case CLASS_MARK1:
+	case CLASS_MARK2:
+	case CLASS_PROBE:
+	case CLASS_SEEKER:
+	case CLASS_REMOTE:
+	case CLASS_SENTRY:
+	case CLASS_INTERROGATOR:
+		time = 0;
+		break;
+	default:
+		// never go away
+	//	time = Q3_INFINITE;
+		// for now I'm making default 10000
+		time = 10000;
+		break;
+
+	}
+	
+
+	return time;
+}
+
+
+/*
+----------------------------------------
+NPC_RemoveBodyEffect
+
+Effect to be applied when ditching the corpse
+----------------------------------------
+*/
+
+static void NPC_RemoveBodyEffect(void)
+{
+//	vec3_t		org;
+//	gentity_t	*tent;
+
+	if ( !NPC || !NPC->client || (NPC->s.eFlags & EF_NODRAW) )
+		return;
+/*
+	switch(NPC->client->playerTeam)
+	{
+	case NPCTEAM_STARFLEET:
+		//FIXME: Starfleet beam out
+		break;
+
+	case NPCTEAM_BOTS:
+//		VectorCopy( NPC->r.currentOrigin, org );
+//		org[2] -= 16;
+//		tent = G_TempEntity( org, EV_BOT_EXPLODE );
+//		tent->owner = NPC;
+
+		break;
+
+	default:
+		break;
+	}
+*/
+
+
+	// team no longer indicates species/race, so in this case we'd use NPC_class, but
+	
+	// stub code
+	switch(NPC->client->NPC_class)
+	{
+	case CLASS_PROBE:
+	case CLASS_SEEKER:
+	case CLASS_REMOTE:
+	case CLASS_SENTRY:
+	case CLASS_GONK:
+	case CLASS_R2D2:
+	case CLASS_R5D2:
+	//case CLASS_PROTOCOL:
+	case CLASS_MARK1:
+	case CLASS_MARK2:
+	case CLASS_INTERROGATOR:
+	case CLASS_ATST: // yeah, this is a little weird, but for now I'm listing all droids
+	//	VectorCopy( NPC->r.currentOrigin, org );
+	//	org[2] -= 16;
+	//	tent = G_TempEntity( org, EV_BOT_EXPLODE );
+	//	tent->owner = NPC;
+		break;
+	default:
+		break;
+	}
+
+
+}
+
+
+/*
+====================================================================
+void pitch_roll_for_slope( gentity_t *forwhom, vec3_t pass_slope )
+
+MG
+
+This will adjust the pitch and roll of a monster to match
+a given slope - if a non-'0 0 0' slope is passed, it will
+use that value, otherwise it will use the ground underneath
+the monster.  If it doesn't find a surface, it does nothinh\g
+and returns.
+====================================================================
+*/
+
+void pitch_roll_for_slope( gentity_t *forwhom, vec3_t pass_slope )
+{
+	vec3_t	slope;
+	vec3_t	nvf, ovf, ovr, startspot, endspot, new_angles = { 0, 0, 0 };
+	float	pitch, mod, dot;
+
+	//if we don't have a slope, get one
+	if( !pass_slope || VectorCompare( vec3_origin, pass_slope ) )
+	{
+		trace_t trace;
+
+		VectorCopy( forwhom->r.currentOrigin, startspot );
+		startspot[2] += forwhom->r.mins[2] + 4;
+		VectorCopy( startspot, endspot );
+		endspot[2] -= 300;
+		trap_Trace( &trace, forwhom->r.currentOrigin, vec3_origin, vec3_origin, endspot, forwhom->s.number, MASK_SOLID );
+//		if(trace_fraction>0.05&&forwhom.movetype==MOVETYPE_STEP)
+//			forwhom.flags(-)FL_ONGROUND;
+
+		if ( trace.fraction >= 1.0 )
+			return;
+
+		if( !( &trace.plane ) )
+			return;
+
+		if ( VectorCompare( vec3_origin, trace.plane.normal ) )
+			return;
+
+		VectorCopy( trace.plane.normal, slope );
+	}
+	else
+	{
+		VectorCopy( pass_slope, slope );
+	}
+
+
+	AngleVectors( forwhom->r.currentAngles, ovf, ovr, NULL );
+
+	vectoangles( slope, new_angles );
+	pitch = new_angles[PITCH] + 90;
+	new_angles[ROLL] = new_angles[PITCH] = 0;
+
+	AngleVectors( new_angles, nvf, NULL, NULL );
+
+	mod = DotProduct( nvf, ovr );
+
+	if ( mod<0 )
+		mod = -1;
+	else
+		mod = 1;
+
+	dot = DotProduct( nvf, ovf );
+
+	if ( forwhom->client )
+	{
+		float oldmins2;
+
+		forwhom->client->ps.viewangles[PITCH] = dot * pitch;
+		forwhom->client->ps.viewangles[ROLL] = ((1-Q_fabs(dot)) * pitch * mod);
+		oldmins2 = forwhom->r.mins[2];
+		forwhom->r.mins[2] = -24 + 12 * fabs(forwhom->client->ps.viewangles[PITCH])/180.0f;
+		//FIXME: if it gets bigger, move up
+		if ( oldmins2 > forwhom->r.mins[2] )
+		{//our mins is now lower, need to move up
+			//FIXME: trace?
+			forwhom->client->ps.origin[2] += (oldmins2 - forwhom->r.mins[2]);
+			forwhom->r.currentOrigin[2] = forwhom->client->ps.origin[2];
+			trap_LinkEntity( forwhom );
+		}
+	}
+	else
+	{
+		forwhom->r.currentAngles[PITCH] = dot * pitch;
+		forwhom->r.currentAngles[ROLL] = ((1-Q_fabs(dot)) * pitch * mod);
+	}
+}
+
+
+/*
+----------------------------------------
+DeadThink
+----------------------------------------
+*/
+static void DeadThink ( void ) 
+{
+	trace_t	trace;
+
+	//HACKHACKHACKHACKHACK
+	//We should really have a seperate G2 bounding box (seperate from the physics bbox) for G2 collisions only
+	//FIXME: don't ever inflate back up?
+	NPC->r.maxs[2] = NPC->client->renderInfo.eyePoint[2] - NPC->r.currentOrigin[2] + 4;
+	if ( NPC->r.maxs[2] < -8 )
+	{
+		NPC->r.maxs[2] = -8;
+	}
+	if ( VectorCompare( NPC->client->ps.velocity, vec3_origin ) )
+	{//not flying through the air
+		if ( NPC->r.mins[0] > -32 )
+		{
+			NPC->r.mins[0] -= 1;
+			trap_Trace (&trace, NPC->r.currentOrigin, NPC->r.mins, NPC->r.maxs, NPC->r.currentOrigin, NPC->s.number, NPC->clipmask );
+			if ( trace.allsolid )
+			{
+				NPC->r.mins[0] += 1;
+			}
+		}
+		if ( NPC->r.maxs[0] < 32 )
+		{
+			NPC->r.maxs[0] += 1;
+			trap_Trace (&trace, NPC->r.currentOrigin, NPC->r.mins, NPC->r.maxs, NPC->r.currentOrigin, NPC->s.number, NPC->clipmask );
+			if ( trace.allsolid )
+			{
+				NPC->r.maxs[0] -= 1;
+			}
+		}
+		if ( NPC->r.mins[1] > -32 )
+		{
+			NPC->r.mins[1] -= 1;
+			trap_Trace (&trace, NPC->r.currentOrigin, NPC->r.mins, NPC->r.maxs, NPC->r.currentOrigin, NPC->s.number, NPC->clipmask );
+			if ( trace.allsolid )
+			{
+				NPC->r.mins[1] += 1;
+			}
+		}
+		if ( NPC->r.maxs[1] < 32 )
+		{
+			NPC->r.maxs[1] += 1;
+			trap_Trace (&trace, NPC->r.currentOrigin, NPC->r.mins, NPC->r.maxs, NPC->r.currentOrigin, NPC->s.number, NPC->clipmask );
+			if ( trace.allsolid )
+			{
+				NPC->r.maxs[1] -= 1;
+			}
+		}
+	}
+	//HACKHACKHACKHACKHACK
+
+	//FIXME: tilt and fall off of ledges?
+	//NPC_PostDeathThink();
+
+	/*
+	if ( !NPCInfo->timeOfDeath && NPC->client != NULL && NPCInfo != NULL ) 
+	{
+		//haven't finished death anim yet and were NOT given a specific amount of time to wait before removal
+		int				legsAnim	= NPC->client->ps.legsAnim;
+		animation_t		*animations	= knownAnimFileSets[NPC->client->clientInfo.animFileIndex].animations;
+
+		NPC->bounceCount = -1; // This is a cheap hack for optimizing the pointcontents check below
+
+		//ghoul doesn't tell us this anymore
+		//if ( NPC->client->renderInfo.legsFrame == animations[legsAnim].firstFrame + (animations[legsAnim].numFrames - 1) )
+		{
+			//reached the end of the death anim
+			NPCInfo->timeOfDeath = level.time + BodyRemovalPadTime( NPC );
+		}
+	}
+	else
+	*/
+	{
+		//death anim done (or were given a specific amount of time to wait before removal), wait the requisite amount of time them remove
+		if ( level.time >= NPCInfo->timeOfDeath + BodyRemovalPadTime( NPC ) )
+		{
+			if ( NPC->client->ps.eFlags & EF_NODRAW )
+			{
+				if (!trap_ICARUS_IsRunning(NPC->s.number))
+				//if ( !NPC->taskManager || !NPC->taskManager->IsRunning() )
+				{
+					NPC->think = G_FreeEntity;
+					NPC->nextthink = level.time + FRAMETIME;
+				}
+			}
+			else
+			{
+				class_t	npc_class;
+
+				// Start the body effect first, then delay 400ms before ditching the corpse
+				NPC_RemoveBodyEffect();
+
+				//FIXME: keep it running through physics somehow?
+				NPC->think = NPC_RemoveBody;
+				NPC->nextthink = level.time + FRAMETIME;
+			//	if ( NPC->client->playerTeam == NPCTEAM_FORGE )
+			//		NPCInfo->timeOfDeath = level.time + FRAMETIME * 8;
+			//	else if ( NPC->client->playerTeam == NPCTEAM_BOTS )
+				npc_class = NPC->client->NPC_class;
+				// check for droids
+				if ( npc_class == CLASS_SEEKER || npc_class == CLASS_REMOTE || npc_class == CLASS_PROBE || npc_class == CLASS_MOUSE ||
+					 npc_class == CLASS_GONK || npc_class == CLASS_R2D2 || npc_class == CLASS_R5D2 ||
+					 npc_class == CLASS_MARK2 || npc_class == CLASS_SENTRY )//npc_class == CLASS_PROTOCOL ||
+				{
+					NPC->client->ps.eFlags |= EF_NODRAW;
+					NPCInfo->timeOfDeath = level.time + FRAMETIME * 8;
+				}
+				else
+					NPCInfo->timeOfDeath = level.time + FRAMETIME * 4;
+			}
+			return;
+		}
+	}
+
+	// If the player is on the ground and the resting position contents haven't been set yet...(BounceCount tracks the contents)
+	if ( NPC->bounceCount < 0 && NPC->s.groundEntityNum >= 0 )
+	{
+		// if client is in a nodrop area, make him/her nodraw
+		int contents = NPC->bounceCount = trap_PointContents( NPC->r.currentOrigin, -1 );
+
+		if ( ( contents & CONTENTS_NODROP ) ) 
+		{
+			NPC->client->ps.eFlags |= EF_NODRAW;
+		}
+	}
+
+	CorpsePhysics( NPC );
+}
+
+
+/*
+===============
+SetNPCGlobals
+
+local function to set globals used throughout the AI code
+===============
+*/
+void SetNPCGlobals( gentity_t *ent ) 
+{
+	NPC = ent;
+	NPCInfo = ent->NPC;
+	client = ent->client;
+	memset( &ucmd, 0, sizeof( usercmd_t ) );
+}
+
+gentity_t	*_saved_NPC;
+gNPC_t		*_saved_NPCInfo;
+gclient_t	*_saved_client;
+usercmd_t	_saved_ucmd;
+
+void SaveNPCGlobals(void) 
+{
+	_saved_NPC = NPC;
+	_saved_NPCInfo = NPCInfo;
+	_saved_client = client;
+	memcpy( &_saved_ucmd, &ucmd, sizeof( usercmd_t ) );
+}
+
+void RestoreNPCGlobals(void) 
+{
+	NPC = _saved_NPC;
+	NPCInfo = _saved_NPCInfo;
+	client = _saved_client;
+	memcpy( &ucmd, &_saved_ucmd, sizeof( usercmd_t ) );
+}
+
+//We MUST do this, other funcs were using NPC illegally when "self" wasn't the global NPC
+void ClearNPCGlobals( void ) 
+{
+	NPC = NULL;
+	NPCInfo = NULL;
+	client = NULL;
+}
+//===============
+
+extern	qboolean	showBBoxes;
+vec3_t NPCDEBUG_RED = {1.0, 0.0, 0.0};
+vec3_t NPCDEBUG_GREEN = {0.0, 1.0, 0.0};
+vec3_t NPCDEBUG_BLUE = {0.0, 0.0, 1.0};
+vec3_t NPCDEBUG_LIGHT_BLUE = {0.3f, 0.7f, 1.0};
+extern void G_Cube( vec3_t mins, vec3_t maxs, vec3_t color, float alpha );
+extern void G_Line( vec3_t start, vec3_t end, vec3_t color, float alpha );
+extern void G_Cylinder( vec3_t start, vec3_t end, float radius, vec3_t color );
+
+void NPC_ShowDebugInfo (void)
+{
+	if ( showBBoxes )
+	{
+		gentity_t	*found = NULL;
+		vec3_t		mins, maxs;
+
+		while( (found = G_Find( found, FOFS(classname), "NPC" ) ) != NULL )
+		{
+			if ( trap_InPVS( found->r.currentOrigin, g_entities[0].r.currentOrigin ) )
+			{
+				VectorAdd( found->r.currentOrigin, found->r.mins, mins );
+				VectorAdd( found->r.currentOrigin, found->r.maxs, maxs );
+				G_Cube( mins, maxs, NPCDEBUG_RED, 0.25 );
+			}
+		}
+	}
+}
+
+void NPC_ApplyScriptFlags (void)
+{
+	if ( NPCInfo->scriptFlags & SCF_CROUCHED )
+	{
+		if ( NPCInfo->charmedTime > level.time && (ucmd.forwardmove || ucmd.rightmove) )
+		{//ugh, if charmed and moving, ignore the crouched command
+		}
+		else
+		{
+			ucmd.upmove = -127;
+		}
+	}
+
+	if(NPCInfo->scriptFlags & SCF_RUNNING)
+	{
+		ucmd.buttons &= ~BUTTON_WALKING;
+	}
+	else if(NPCInfo->scriptFlags & SCF_WALKING)
+	{
+		if ( NPCInfo->charmedTime > level.time && (ucmd.forwardmove || ucmd.rightmove) )
+		{//ugh, if charmed and moving, ignore the walking command
+		}
+		else
+		{
+			ucmd.buttons |= BUTTON_WALKING;
+		}
+	}
+/*
+	if(NPCInfo->scriptFlags & SCF_CAREFUL)
+	{
+		ucmd.buttons |= BUTTON_CAREFUL;
+	}
+*/
+	if(NPCInfo->scriptFlags & SCF_LEAN_RIGHT)
+	{
+		ucmd.buttons |= BUTTON_USE;
+		ucmd.rightmove = 127;
+		ucmd.forwardmove = 0;
+		ucmd.upmove = 0;
+	}
+	else if(NPCInfo->scriptFlags & SCF_LEAN_LEFT)
+	{
+		ucmd.buttons |= BUTTON_USE;
+		ucmd.rightmove = -127;
+		ucmd.forwardmove = 0;
+		ucmd.upmove = 0;
+	}
+
+	if ( (NPCInfo->scriptFlags & SCF_ALT_FIRE) && (ucmd.buttons & BUTTON_ATTACK) )
+	{//Use altfire instead
+		ucmd.buttons |= BUTTON_ALT_ATTACK;
+	}
+}
+
+void Q3_DebugPrint( int level, const char *format, ... );
+void NPC_HandleAIFlags (void)
+{
+	//FIXME: make these flags checks a function call like NPC_CheckAIFlagsAndTimers
+	if ( NPCInfo->aiFlags & NPCAI_LOST )
+	{//Print that you need help!
+		//FIXME: shouldn't remove this just yet if cg_draw needs it
+		NPCInfo->aiFlags &= ~NPCAI_LOST;
+		
+		/*
+		if ( showWaypoints )
+		{
+			Q3_DebugPrint(WL_WARNING, "%s can't navigate to target %s (my wp: %d, goal wp: %d)\n", NPC->targetname, NPCInfo->goalEntity->targetname, NPC->waypoint, NPCInfo->goalEntity->waypoint );
+		}
+		*/
+
+		if ( NPCInfo->goalEntity && NPCInfo->goalEntity == NPC->enemy )
+		{//We can't nav to our enemy
+			//Drop enemy and see if we should search for him
+			NPC_LostEnemyDecideChase();
+		}
+	}
+
+	//MRJ Request:
+	/*
+	if ( NPCInfo->aiFlags & NPCAI_GREET_ALLIES && !NPC->enemy )//what if "enemy" is the greetEnt?
+	{//If no enemy, look for teammates to greet
+		//FIXME: don't say hi to the same guy over and over again.
+		if ( NPCInfo->greetingDebounceTime < level.time )
+		{//Has been at least 2 seconds since we greeted last
+			if ( !NPCInfo->greetEnt )
+			{//Find a teammate whom I'm facing and who is facing me and within 128
+				NPCInfo->greetEnt = NPC_PickAlly( qtrue, 128, qtrue, qtrue );
+			}
+
+			if ( NPCInfo->greetEnt && !Q_irand(0, 5) )
+			{//Start greeting someone
+				qboolean	greeted = qfalse;
+
+				//TODO:  If have a greetscript, run that instead?
+
+				//FIXME: make them greet back?
+				if( !Q_irand( 0, 2 ) )
+				{//Play gesture anim (press gesture button?)
+					greeted = qtrue;
+					NPC_SetAnim( NPC, SETANIM_TORSO, Q_irand( BOTH_GESTURE1, BOTH_GESTURE3 ), SETANIM_FLAG_NORMAL|SETANIM_FLAG_HOLD );
+					//NOTE: play full-body gesture if not moving?
+				}
+
+				if( !Q_irand( 0, 2 ) )
+				{//Play random voice greeting sound
+					greeted = qtrue;
+					//FIXME: need NPC sound sets
+
+					//G_AddVoiceEvent( NPC, Q_irand(EV_GREET1, EV_GREET3), 2000 );
+				}
+
+				if( !Q_irand( 0, 1 ) )
+				{//set looktarget to them for a second or two
+					greeted = qtrue;
+					NPC_TempLookTarget( NPC, NPCInfo->greetEnt->s.number, 1000, 3000 );
+				}
+
+				if ( greeted )
+				{//Did at least one of the things above
+					//Don't greet again for 2 - 4 seconds
+					NPCInfo->greetingDebounceTime = level.time + Q_irand( 2000, 4000 );
+					NPCInfo->greetEnt = NULL;
+				}
+			}
+		}
+	}
+	*/
+	//been told to play a victory sound after a delay
+	if ( NPCInfo->greetingDebounceTime && NPCInfo->greetingDebounceTime < level.time )
+	{
+		G_AddVoiceEvent( NPC, Q_irand(EV_VICTORY1, EV_VICTORY3), Q_irand( 2000, 4000 ) );
+		NPCInfo->greetingDebounceTime = 0;
+	}
+
+	if ( NPCInfo->ffireCount > 0 )
+	{
+		if ( NPCInfo->ffireFadeDebounce < level.time )
+		{
+			NPCInfo->ffireCount--;
+			//Com_Printf( "drop: %d < %d\n", NPCInfo->ffireCount, 3+((2-g_spskill.integer)*2) );
+			NPCInfo->ffireFadeDebounce = level.time + 3000;
+		}
+	}
+	if ( d_patched.integer )
+	{//use patch-style navigation
+		if ( NPCInfo->consecutiveBlockedMoves > 20 )
+		{//been stuck for a while, try again?
+			NPCInfo->consecutiveBlockedMoves = 0;
+		}
+	}
+}
+
+void NPC_AvoidWallsAndCliffs (void)
+{
+	//...
+}
+
+void NPC_CheckAttackScript(void)
+{
+	if(!(ucmd.buttons & BUTTON_ATTACK))
+	{
+		return;
+	}
+
+	G_ActivateBehavior(NPC, BSET_ATTACK);
+}
+
+float NPC_MaxDistSquaredForWeapon (void);
+void NPC_CheckAttackHold(void)
+{
+	vec3_t		vec;
+
+	// If they don't have an enemy they shouldn't hold their attack anim.
+	if ( !NPC->enemy )
+	{
+		NPCInfo->attackHoldTime = 0;
+		return;
+	}
+
+/*	if ( ( NPC->client->ps.weapon == WP_BORG_ASSIMILATOR ) || ( NPC->client->ps.weapon == WP_BORG_DRILL ) )
+	{//FIXME: don't keep holding this if can't hit enemy?
+
+		// If they don't have shields ( been disabled) they shouldn't hold their attack anim.
+		if ( !(NPC->NPC->aiFlags & NPCAI_SHIELDS) )
+		{
+			NPCInfo->attackHoldTime = 0;
+			return;
+		}
+
+		VectorSubtract(NPC->enemy->r.currentOrigin, NPC->r.currentOrigin, vec);
+		if( VectorLengthSquared(vec) > NPC_MaxDistSquaredForWeapon() )
+		{
+			NPCInfo->attackHoldTime = 0;
+			PM_SetTorsoAnimTimer(NPC, &NPC->client->ps.torsoAnimTimer, 0);
+		}
+		else if( NPCInfo->attackHoldTime && NPCInfo->attackHoldTime > level.time )
+		{
+			ucmd.buttons |= BUTTON_ATTACK;
+		}
+		else if ( ( NPCInfo->attackHold ) && ( ucmd.buttons & BUTTON_ATTACK ) )
+		{
+			NPCInfo->attackHoldTime = level.time + NPCInfo->attackHold;
+			PM_SetTorsoAnimTimer(NPC, &NPC->client->ps.torsoAnimTimer, NPCInfo->attackHold);
+		}
+		else
+		{
+			NPCInfo->attackHoldTime = 0;
+			PM_SetTorsoAnimTimer(NPC, &NPC->client->ps.torsoAnimTimer, 0);
+		}
+	}
+	else*/
+	{//everyone else...?  FIXME: need to tie this into AI somehow?
+		VectorSubtract(NPC->enemy->r.currentOrigin, NPC->r.currentOrigin, vec);
+		if( VectorLengthSquared(vec) > NPC_MaxDistSquaredForWeapon() )
+		{
+			NPCInfo->attackHoldTime = 0;
+		}
+		else if( NPCInfo->attackHoldTime && NPCInfo->attackHoldTime > level.time )
+		{
+			ucmd.buttons |= BUTTON_ATTACK;
+		}
+		else if ( ( NPCInfo->attackHold ) && ( ucmd.buttons & BUTTON_ATTACK ) )
+		{
+			NPCInfo->attackHoldTime = level.time + NPCInfo->attackHold;
+		}
+		else
+		{
+			NPCInfo->attackHoldTime = 0;
+		}
+	}
+}
+
+/*
+void NPC_KeepCurrentFacing(void)
+
+Fills in a default ucmd to keep current angles facing
+*/
+void NPC_KeepCurrentFacing(void)
+{
+	if(!ucmd.angles[YAW])
+	{
+		ucmd.angles[YAW] = ANGLE2SHORT( client->ps.viewangles[YAW] ) - client->ps.delta_angles[YAW];
+	}
+
+	if(!ucmd.angles[PITCH])
+	{
+		ucmd.angles[PITCH] = ANGLE2SHORT( client->ps.viewangles[PITCH] ) - client->ps.delta_angles[PITCH];
+	}
+}
+
+/*
+-------------------------
+NPC_BehaviorSet_Charmed
+-------------------------
+*/
+
+void NPC_BehaviorSet_Charmed( int bState )
+{
+	switch( bState )
+	{
+	case BS_FOLLOW_LEADER://# 40: Follow your leader and shoot any enemies you come across
+		NPC_BSFollowLeader();
+		break;
+	case BS_REMOVE:
+		NPC_BSRemove();
+		break;
+	case BS_SEARCH:			//# 43: Using current waypoint as a base, search the immediate branches of waypoints for enemies
+		NPC_BSSearch();
+		break;
+	case BS_WANDER:			//# 46: Wander down random waypoint paths
+		NPC_BSWander();
+		break;
+	case BS_FLEE:
+		NPC_BSFlee();
+		break;
+	default:
+	case BS_DEFAULT://whatever
+		NPC_BSDefault();
+		break;
+	}
+}
+/*
+-------------------------
+NPC_BehaviorSet_Default
+-------------------------
+*/
+
+void NPC_BehaviorSet_Default( int bState )
+{
+	switch( bState )
+	{
+	case BS_ADVANCE_FIGHT://head toward captureGoal, shoot anything that gets in the way
+		NPC_BSAdvanceFight ();
+		break;
+	case BS_SLEEP://Follow a path, looking for enemies
+		NPC_BSSleep ();
+		break;
+	case BS_FOLLOW_LEADER://# 40: Follow your leader and shoot any enemies you come across
+		NPC_BSFollowLeader();
+		break;
+	case BS_JUMP:			//41: Face navgoal and jump to it.
+		NPC_BSJump();
+		break;
+	case BS_REMOVE:
+		NPC_BSRemove();
+		break;
+	case BS_SEARCH:			//# 43: Using current waypoint as a base, search the immediate branches of waypoints for enemies
+		NPC_BSSearch();
+		break;
+	case BS_NOCLIP:
+		NPC_BSNoClip();
+		break;
+	case BS_WANDER:			//# 46: Wander down random waypoint paths
+		NPC_BSWander();
+		break;
+	case BS_FLEE:
+		NPC_BSFlee();
+		break;
+	case BS_WAIT:
+		NPC_BSWait();
+		break;
+	case BS_CINEMATIC:
+		NPC_BSCinematic();
+		break;
+	default:
+	case BS_DEFAULT://whatever
+		NPC_BSDefault();
+		break;
+	}
+}
+
+/*
+-------------------------
+NPC_BehaviorSet_Interrogator
+-------------------------
+*/
+void NPC_BehaviorSet_Interrogator( int bState )
+{
+	switch( bState )
+	{
+	case BS_STAND_GUARD:
+	case BS_PATROL:
+	case BS_STAND_AND_SHOOT:
+	case BS_HUNT_AND_KILL:
+	case BS_DEFAULT:
+		NPC_BSInterrogator_Default();
+		break;
+	default:
+		NPC_BehaviorSet_Default( bState );
+		break;
+	}
+}
+
+void NPC_BSImperialProbe_Attack( void );
+void NPC_BSImperialProbe_Patrol( void );
+void NPC_BSImperialProbe_Wait(void);
+
+/*
+-------------------------
+NPC_BehaviorSet_ImperialProbe
+-------------------------
+*/
+void NPC_BehaviorSet_ImperialProbe( int bState )
+{
+	switch( bState )
+	{
+	case BS_STAND_GUARD:
+	case BS_PATROL:
+	case BS_STAND_AND_SHOOT:
+	case BS_HUNT_AND_KILL:
+	case BS_DEFAULT:
+		NPC_BSImperialProbe_Default();
+		break;
+	default:
+		NPC_BehaviorSet_Default( bState );
+		break;
+	}
+}
+
+
+void NPC_BSSeeker_Default( void );
+
+/*
+-------------------------
+NPC_BehaviorSet_Seeker
+-------------------------
+*/
+void NPC_BehaviorSet_Seeker( int bState )
+{
+	switch( bState )
+	{
+	case BS_STAND_GUARD:
+	case BS_PATROL:
+	case BS_STAND_AND_SHOOT:
+	case BS_HUNT_AND_KILL:
+	case BS_DEFAULT:
+		NPC_BSSeeker_Default();
+		break; 
+	default:
+		NPC_BehaviorSet_Default( bState );
+		break;
+	}
+}
+
+void NPC_BSRemote_Default( void );
+
+/*
+-------------------------
+NPC_BehaviorSet_Remote
+-------------------------
+*/
+void NPC_BehaviorSet_Remote( int bState )
+{
+	NPC_BSRemote_Default();
+}
+
+void NPC_BSSentry_Default( void );
+
+/*
+-------------------------
+NPC_BehaviorSet_Sentry
+-------------------------
+*/
+void NPC_BehaviorSet_Sentry( int bState )
+{
+	switch( bState )
+	{
+	case BS_STAND_GUARD:
+	case BS_PATROL:
+	case BS_STAND_AND_SHOOT:
+	case BS_HUNT_AND_KILL:
+	case BS_DEFAULT:
+		NPC_BSSentry_Default();
+		break; 
+	default:
+		NPC_BehaviorSet_Default( bState );
+		break;
+	}
+}
+
+/*
+-------------------------
+NPC_BehaviorSet_Grenadier
+-------------------------
+*/
+void NPC_BehaviorSet_Grenadier( int bState )
+{
+	switch( bState )
+	{
+	case BS_STAND_GUARD:
+	case BS_PATROL:
+	case BS_STAND_AND_SHOOT:
+	case BS_HUNT_AND_KILL:
+	case BS_DEFAULT:
+		NPC_BSGrenadier_Default();
+		break;
+
+	default:
+		NPC_BehaviorSet_Default( bState );
+		break;
+	}
+}
+/*
+-------------------------
+NPC_BehaviorSet_Sniper
+-------------------------
+*/
+void NPC_BehaviorSet_Sniper( int bState )
+{
+	switch( bState )
+	{
+	case BS_STAND_GUARD:
+	case BS_PATROL:
+	case BS_STAND_AND_SHOOT:
+	case BS_HUNT_AND_KILL:
+	case BS_DEFAULT:
+		NPC_BSSniper_Default();
+		break;
+
+	default:
+		NPC_BehaviorSet_Default( bState );
+		break;
+	}
+}
+/*
+-------------------------
+NPC_BehaviorSet_Stormtrooper
+-------------------------
+*/
+
+void NPC_BehaviorSet_Stormtrooper( int bState )
+{
+	switch( bState )
+	{
+	case BS_STAND_GUARD:
+	case BS_PATROL:
+	case BS_STAND_AND_SHOOT:
+	case BS_HUNT_AND_KILL:
+	case BS_DEFAULT:
+		NPC_BSST_Default();
+		break;
+
+	case BS_INVESTIGATE:
+		NPC_BSST_Investigate();
+		break;
+
+	case BS_SLEEP:
+		NPC_BSST_Sleep();
+		break;
+
+	default:
+		NPC_BehaviorSet_Default( bState );
+		break;
+	}
+}
+
+/*
+-------------------------
+NPC_BehaviorSet_Jedi
+-------------------------
+*/
+
+void NPC_BehaviorSet_Jedi( int bState )
+{
+	switch( bState )
+	{
+	case BS_STAND_GUARD:
+	case BS_PATROL:
+	case BS_STAND_AND_SHOOT:
+	case BS_HUNT_AND_KILL:
+	case BS_DEFAULT:
+		NPC_BSJedi_Default();
+		break;
+
+	case BS_FOLLOW_LEADER:
+		NPC_BSJedi_FollowLeader();
+		break;
+
+	default:
+		NPC_BehaviorSet_Default( bState );
+		break;
+	}
+}
+
+/*
+-------------------------
+NPC_BehaviorSet_Droid
+-------------------------
+*/
+void NPC_BehaviorSet_Droid( int bState )
+{
+	switch( bState )
+	{
+	case BS_DEFAULT:
+	case BS_STAND_GUARD:
+	case BS_PATROL:
+		NPC_BSDroid_Default();
+		break;
+	default:
+		NPC_BehaviorSet_Default( bState );
+		break;
+	}
+}
+
+/*
+-------------------------
+NPC_BehaviorSet_Mark1
+-------------------------
+*/
+void NPC_BehaviorSet_Mark1( int bState )
+{
+	switch( bState )
+	{
+	case BS_DEFAULT:
+	case BS_STAND_GUARD:
+	case BS_PATROL:
+		NPC_BSMark1_Default();
+		break;
+	default:
+		NPC_BehaviorSet_Default( bState );
+		break;
+	}
+}
+
+/*
+-------------------------
+NPC_BehaviorSet_Mark2
+-------------------------
+*/
+void NPC_BehaviorSet_Mark2( int bState )
+{
+	switch( bState )
+	{
+	case BS_DEFAULT:
+	case BS_PATROL:
+	case BS_STAND_AND_SHOOT:
+	case BS_HUNT_AND_KILL:
+		NPC_BSMark2_Default();
+		break;
+	default:
+		NPC_BehaviorSet_Default( bState );
+		break;
+	}
+}
+
+/*
+-------------------------
+NPC_BehaviorSet_ATST
+-------------------------
+*/
+void NPC_BehaviorSet_ATST( int bState )
+{
+	switch( bState )
+	{
+	case BS_DEFAULT:
+	case BS_PATROL:
+	case BS_STAND_AND_SHOOT:
+	case BS_HUNT_AND_KILL:
+		NPC_BSATST_Default();
+		break;
+	default:
+		NPC_BehaviorSet_Default( bState );
+		break;
+	}
+}
+
+/*
+-------------------------
+NPC_BehaviorSet_MineMonster
+-------------------------
+*/
+void NPC_BehaviorSet_MineMonster( int bState )
+{
+	switch( bState )
+	{
+	case BS_STAND_GUARD:
+	case BS_PATROL:
+	case BS_STAND_AND_SHOOT:
+	case BS_HUNT_AND_KILL:
+	case BS_DEFAULT:
+		NPC_BSMineMonster_Default();
+		break;
+	default:
+		NPC_BehaviorSet_Default( bState );
+		break;
+	}
+}
+
+/*
+-------------------------
+NPC_BehaviorSet_Howler
+-------------------------
+*/
+void NPC_BehaviorSet_Howler( int bState )
+{
+	switch( bState )
+	{
+	case BS_STAND_GUARD:
+	case BS_PATROL:
+	case BS_STAND_AND_SHOOT:
+	case BS_HUNT_AND_KILL:
+	case BS_DEFAULT:
+		NPC_BSHowler_Default();
+		break;
+	default:
+		NPC_BehaviorSet_Default( bState );
+		break;
+	}
+}
+
+/*
+-------------------------
+NPC_BehaviorSet_Rancor
+-------------------------
+*/
+void NPC_BehaviorSet_Rancor( int bState )
+{
+	switch( bState )
+	{
+	case BS_STAND_GUARD:
+	case BS_PATROL:
+	case BS_STAND_AND_SHOOT:
+	case BS_HUNT_AND_KILL:
+	case BS_DEFAULT:
+		NPC_BSRancor_Default();
+		break;
+	default:
+		NPC_BehaviorSet_Default( bState );
+		break;
+	}
+}
+
+/*
+-------------------------
+NPC_RunBehavior
+-------------------------
+*/
+extern void NPC_BSEmplaced( void );
+extern qboolean NPC_CheckSurrender( void );
+extern void Boba_FlyStop( gentity_t *self );
+extern void NPC_BSWampa_Default( void );
+void NPC_RunBehavior( int team, int bState )
+{
+	qboolean dontSetAim = qfalse;
+
+	if (NPC->s.NPC_class == CLASS_VEHICLE &&
+		NPC->m_pVehicle)
+	{ //vehicles don't do AI!
+		return;
+	}
+
+	if ( bState == BS_CINEMATIC )
+	{
+		NPC_BSCinematic();
+	}
+	else if ( NPC->client->ps.weapon == WP_EMPLACED_GUN )
+	{
+		NPC_BSEmplaced();
+		NPC_CheckCharmed();
+		return;
+	}
+	else if ( NPC->client->ps.weapon == WP_SABER )
+	{//jedi
+		NPC_BehaviorSet_Jedi( bState );
+		dontSetAim = qtrue;
+	}
+	else if ( NPC->client->NPC_class == CLASS_WAMPA )
+	{//wampa
+		NPC_BSWampa_Default();
+	}
+	else if ( NPC->client->NPC_class == CLASS_RANCOR )
+	{//rancor
+		NPC_BehaviorSet_Rancor( bState );
+	}
+	else if ( NPC->client->NPC_class == CLASS_REMOTE )
+	{
+		NPC_BehaviorSet_Remote( bState );
+	}
+	else if ( NPC->client->NPC_class == CLASS_SEEKER )
+	{
+		NPC_BehaviorSet_Seeker( bState );
+	}
+	else if ( NPC->client->NPC_class == CLASS_BOBAFETT )
+	{//bounty hunter
+		if ( Boba_Flying( NPC ) )
+		{
+			NPC_BehaviorSet_Seeker(bState);
+		}
+		else
+		{
+			NPC_BehaviorSet_Jedi( bState );
+		}
+		dontSetAim = qtrue;
+	}
+	else if ( NPCInfo->scriptFlags & SCF_FORCED_MARCH )
+	{//being forced to march
+		NPC_BSDefault();
+	}
+	else
+	{
+		switch( team )
+		{
+		
+	//	case NPCTEAM_SCAVENGERS:
+	//	case NPCTEAM_IMPERIAL:
+	//	case NPCTEAM_KLINGON:
+	//	case NPCTEAM_HIROGEN:
+	//	case NPCTEAM_MALON:
+		// not sure if TEAM_ENEMY is appropriate here, I think I should be using NPC_class to check for behavior - dmv
+		case NPCTEAM_ENEMY:
+			// special cases for enemy droids
+			switch( NPC->client->NPC_class)
+			{
+			case CLASS_ATST:
+				NPC_BehaviorSet_ATST( bState );
+				return;
+			case CLASS_PROBE:
+				NPC_BehaviorSet_ImperialProbe(bState);
+				return;
+			case CLASS_REMOTE:
+				NPC_BehaviorSet_Remote( bState );
+				return;
+			case CLASS_SENTRY:
+				NPC_BehaviorSet_Sentry(bState);
+				return;
+			case CLASS_INTERROGATOR:
+				NPC_BehaviorSet_Interrogator( bState );
+				return;
+			case CLASS_MINEMONSTER:
+				NPC_BehaviorSet_MineMonster( bState );
+				return;
+			case CLASS_HOWLER:
+				NPC_BehaviorSet_Howler( bState );
+				return;
+			case CLASS_MARK1:
+				NPC_BehaviorSet_Mark1( bState );
+				return;
+			case CLASS_MARK2:
+				NPC_BehaviorSet_Mark2( bState );
+				return;
+			case CLASS_GALAKMECH:
+				NPC_BSGM_Default();
+				return;
+
+			}
+
+			if ( NPC->enemy && NPC->s.weapon == WP_NONE && bState != BS_HUNT_AND_KILL && !trap_ICARUS_TaskIDPending( NPC, TID_MOVE_NAV ) )
+			{//if in battle and have no weapon, run away, fixme: when in BS_HUNT_AND_KILL, they just stand there
+				if ( bState != BS_FLEE )
+				{
+					NPC_StartFlee( NPC->enemy, NPC->enemy->r.currentOrigin, AEL_DANGER_GREAT, 5000, 10000 );
+				}
+				else
+				{
+					NPC_BSFlee();
+				}
+				return;
+			}
+			if ( NPC->client->ps.weapon == WP_SABER )
+			{//special melee exception
+				NPC_BehaviorSet_Default( bState );
+				return;
+			}
+			if ( NPC->client->ps.weapon == WP_DISRUPTOR && (NPCInfo->scriptFlags & SCF_ALT_FIRE) )
+			{//a sniper
+				NPC_BehaviorSet_Sniper( bState );
+				return;
+			}
+			if ( NPC->client->ps.weapon == WP_THERMAL || NPC->client->ps.weapon == WP_STUN_BATON )//FIXME: separate AI for melee fighters
+			{//a grenadier
+				NPC_BehaviorSet_Grenadier( bState );
+				return;
+			}
+			if ( NPC_CheckSurrender() )
+			{
+				return;
+			}
+			NPC_BehaviorSet_Stormtrooper( bState );
+			break;
+
+		case NPCTEAM_NEUTRAL: 
+
+			// special cases for enemy droids
+			if ( NPC->client->NPC_class == CLASS_PROTOCOL || NPC->client->NPC_class == CLASS_UGNAUGHT ||
+				NPC->client->NPC_class == CLASS_JAWA)
+			{
+				NPC_BehaviorSet_Default(bState);
+			}
+			else if ( NPC->client->NPC_class == CLASS_VEHICLE )
+			{
+				// TODO: Add vehicle behaviors here.
+				NPC_UpdateAngles( qtrue, qtrue );//just face our spawn angles for now
+			}
+			else
+			{
+				// Just one of the average droids
+				NPC_BehaviorSet_Droid( bState );
+			}
+			break;
+
+		default:
+			if ( NPC->client->NPC_class == CLASS_SEEKER )
+			{
+				NPC_BehaviorSet_Seeker(bState);
+			}
+			else
+			{
+				if ( NPCInfo->charmedTime > level.time )
+				{
+					NPC_BehaviorSet_Charmed( bState );
+				}
+				else
+				{
+					NPC_BehaviorSet_Default( bState );
+				}
+				NPC_CheckCharmed();
+				dontSetAim = qtrue;
+			}
+			break;
+		}
+	}
+}
+
+/*
+===============
+NPC_ExecuteBState
+
+  MCG
+
+NPC Behavior state thinking
+
+===============
+*/
+void NPC_ExecuteBState ( gentity_t *self)//, int msec ) 
+{
+	bState_t	bState;
+
+	NPC_HandleAIFlags();
+
+	//FIXME: these next three bits could be a function call, some sort of setup/cleanup func
+	//Lookmode must be reset every think cycle
+	if(NPC->delayScriptTime && NPC->delayScriptTime <= level.time)
+	{
+		G_ActivateBehavior( NPC, BSET_DELAYED);
+		NPC->delayScriptTime = 0;
+	}
+
+	//Clear this and let bState set it itself, so it automatically handles changing bStates... but we need a set bState wrapper func
+	NPCInfo->combatMove = qfalse;
+
+	//Execute our bState
+	if(NPCInfo->tempBehavior)
+	{//Overrides normal behavior until cleared
+		bState = NPCInfo->tempBehavior;
+	}
+	else
+	{
+		if(!NPCInfo->behaviorState)
+			NPCInfo->behaviorState = NPCInfo->defaultBehavior;
+
+		bState = NPCInfo->behaviorState;
+	}
+
+	//Pick the proper bstate for us and run it
+	NPC_RunBehavior( self->client->playerTeam, bState );
+	
+
+//	if(bState != BS_POINT_COMBAT && NPCInfo->combatPoint != -1)
+//	{
+		//level.combatPoints[NPCInfo->combatPoint].occupied = qfalse;
+		//NPCInfo->combatPoint = -1;
+//	}
+
+	//Here we need to see what the scripted stuff told us to do
+//Only process snapshot if independant and in combat mode- this would pick enemies and go after needed items
+//	ProcessSnapshot();
+
+//Ignore my needs if I'm under script control- this would set needs for items
+//	CheckSelf();
+
+	//Back to normal?  All decisions made?
+	
+	//FIXME: don't walk off ledges unless we can get to our goal faster that way, or that's our goal's surface
+	//NPCPredict();
+
+	if ( NPC->enemy )
+	{
+		if ( !NPC->enemy->inuse )
+		{//just in case bState doesn't catch this
+			G_ClearEnemy( NPC );
+		}
+	}
+
+	if ( NPC->client->ps.saberLockTime && NPC->client->ps.saberLockEnemy != ENTITYNUM_NONE )
+	{
+		NPC_SetLookTarget( NPC, NPC->client->ps.saberLockEnemy, level.time+1000 );
+	}
+	else if ( !NPC_CheckLookTarget( NPC ) )
+	{
+		if ( NPC->enemy )
+		{
+			NPC_SetLookTarget( NPC, NPC->enemy->s.number, 0 );
+		}
+	}
+
+	if ( NPC->enemy )
+	{
+		if(NPC->enemy->flags & FL_DONT_SHOOT)
+		{
+			ucmd.buttons &= ~BUTTON_ATTACK;
+			ucmd.buttons &= ~BUTTON_ALT_ATTACK;
+		}
+		else if ( NPC->client->playerTeam != NPCTEAM_ENEMY && NPC->enemy->NPC && (NPC->enemy->NPC->surrenderTime > level.time || (NPC->enemy->NPC->scriptFlags&SCF_FORCED_MARCH)) )
+		{//don't shoot someone who's surrendering if you're a good guy
+			ucmd.buttons &= ~BUTTON_ATTACK;
+			ucmd.buttons &= ~BUTTON_ALT_ATTACK;
+		}
+
+		if(client->ps.weaponstate == WEAPON_IDLE)
+		{
+			client->ps.weaponstate = WEAPON_READY;
+		}
+	}
+	else 
+	{
+		if(client->ps.weaponstate == WEAPON_READY)
+		{
+			client->ps.weaponstate = WEAPON_IDLE;
+		}
+	}
+
+	if(!(ucmd.buttons & BUTTON_ATTACK) && NPC->attackDebounceTime > level.time)
+	{//We just shot but aren't still shooting, so hold the gun up for a while
+		if(client->ps.weapon == WP_SABER )
+		{//One-handed
+			NPC_SetAnim(NPC,SETANIM_TORSO,TORSO_WEAPONREADY1,SETANIM_FLAG_NORMAL);
+		}
+		else if(client->ps.weapon == WP_BRYAR_PISTOL)
+		{//Sniper pose
+			NPC_SetAnim(NPC,SETANIM_TORSO,TORSO_WEAPONREADY3,SETANIM_FLAG_NORMAL);
+		}
+		/*//FIXME: What's the proper solution here?
+		else
+		{//heavy weapon
+			NPC_SetAnim(NPC,SETANIM_TORSO,TORSO_WEAPONREADY3,SETANIM_FLAG_NORMAL);
+		}
+		*/
+	}
+	else if ( !NPC->enemy )//HACK!
+	{
+//		if(client->ps.weapon != WP_TRICORDER)
+		{
+			if( NPC->s.torsoAnim == TORSO_WEAPONREADY1 || NPC->s.torsoAnim == TORSO_WEAPONREADY3 )
+			{//we look ready for action, using one of the first 2 weapon, let's rest our weapon on our shoulder
+				NPC_SetAnim(NPC,SETANIM_TORSO,TORSO_WEAPONIDLE3,SETANIM_FLAG_NORMAL);
+			}
+		}
+	}
+
+	NPC_CheckAttackHold();
+	NPC_ApplyScriptFlags();
+	
+	//cliff and wall avoidance
+	NPC_AvoidWallsAndCliffs();
+
+	// run the bot through the server like it was a real client
+//=== Save the ucmd for the second no-think Pmove ============================
+	ucmd.serverTime = level.time - 50;
+	memcpy( &NPCInfo->last_ucmd, &ucmd, sizeof( usercmd_t ) );
+	if ( !NPCInfo->attackHoldTime )
+	{
+		NPCInfo->last_ucmd.buttons &= ~(BUTTON_ATTACK|BUTTON_ALT_ATTACK);//so we don't fire twice in one think
+	}
+//============================================================================
+	NPC_CheckAttackScript();
+	NPC_KeepCurrentFacing();
+
+	if ( !NPC->next_roff_time || NPC->next_roff_time < level.time )
+	{//If we were following a roff, we don't do normal pmoves.
+		ClientThink( NPC->s.number, &ucmd );
+	}
+	else
+	{
+		NPC_ApplyRoff();
+	}
+
+	// end of thinking cleanup
+	NPCInfo->touchedByPlayer = NULL;
+
+	NPC_CheckPlayerAim();
+	NPC_CheckAllClear();
+	
+	/*if( ucmd.forwardmove || ucmd.rightmove )
+	{
+		int	i, la = -1, ta = -1;
+
+		for(i = 0; i < MAX_ANIMATIONS; i++)
+		{
+			if( NPC->client->ps.legsAnim == i )
+			{
+				la = i;
+			}
+
+			if( NPC->client->ps.torsoAnim == i )
+			{
+				ta = i;
+			}
+			
+			if(la != -1 && ta != -1)
+			{
+				break;
+			}
+		}
+
+		if(la != -1 && ta != -1)
+		{//FIXME: should never play same frame twice or restart an anim before finishing it
+			Com_Printf("LegsAnim: %s(%d) TorsoAnim: %s(%d)\n", animTable[la].name, NPC->renderInfo.legsFrame, animTable[ta].name, NPC->client->renderInfo.torsoFrame);
+		}
+	}*/
+}
+
+void NPC_CheckInSolid(void)
+{
+	trace_t	trace;
+	vec3_t	point;
+	VectorCopy(NPC->r.currentOrigin, point);
+	point[2] -= 0.25;
+
+	trap_Trace(&trace, NPC->r.currentOrigin, NPC->r.mins, NPC->r.maxs, point, NPC->s.number, NPC->clipmask);
+	if(!trace.startsolid && !trace.allsolid)
+	{
+		VectorCopy(NPC->r.currentOrigin, NPCInfo->lastClearOrigin);
+	}
+	else
+	{
+		if(VectorLengthSquared(NPCInfo->lastClearOrigin))
+		{
+//			Com_Printf("%s stuck in solid at %s: fixing...\n", NPC->script_targetname, vtos(NPC->r.currentOrigin));
+			G_SetOrigin(NPC, NPCInfo->lastClearOrigin);
+			trap_LinkEntity(NPC);
+		}
+	}
+}
+
+void G_DroidSounds( gentity_t *self )
+{
+	if ( self->client )
+	{//make the noises
+		if ( TIMER_Done( self, "patrolNoise" ) && !Q_irand( 0, 20 ) )
+		{
+			switch( self->client->NPC_class )
+			{
+			case CLASS_R2D2:				// droid
+				G_SoundOnEnt(self, CHAN_AUTO, va("sound/chars/r2d2/misc/r2d2talk0%d.wav",Q_irand(1, 3)) );
+				break;
+			case CLASS_R5D2:				// droid
+				G_SoundOnEnt(self, CHAN_AUTO, va("sound/chars/r5d2/misc/r5talk%d.wav",Q_irand(1, 4)) );
+				break;
+			case CLASS_PROBE:				// droid
+				G_SoundOnEnt(self, CHAN_AUTO, va("sound/chars/probe/misc/probetalk%d.wav",Q_irand(1, 3)) );
+				break;
+			case CLASS_MOUSE:				// droid
+				G_SoundOnEnt(self, CHAN_AUTO, va("sound/chars/mouse/misc/mousego%d.wav",Q_irand(1, 3)) );
+				break;
+			case CLASS_GONK:				// droid
+				G_SoundOnEnt(self, CHAN_AUTO, va("sound/chars/gonk/misc/gonktalk%d.wav",Q_irand(1, 2)) );
+				break;
+			}
+			TIMER_Set( self, "patrolNoise", Q_irand( 2000, 4000 ) );
+		}
+	}
+}
+
+/*
+===============
+NPC_Think
+
+Main NPC AI - called once per frame
+===============
+*/
+#if	AI_TIMERS
+extern int AITime;
+#endif//	AI_TIMERS
+void NPC_Think ( gentity_t *self)//, int msec ) 
+{
+	vec3_t	oldMoveDir;
+	int i = 0;
+	gentity_t *player;
+
+	self->nextthink = level.time + FRAMETIME;
+
+	SetNPCGlobals( self );
+
+	memset( &ucmd, 0, sizeof( ucmd ) );
+
+	VectorCopy( self->client->ps.moveDir, oldMoveDir );
+	if (self->s.NPC_class != CLASS_VEHICLE)
+	{ //YOU ARE BREAKING MY PREDICTION. Bad clear.
+		VectorClear( self->client->ps.moveDir );
+	}
+
+	if(!self || !self->NPC || !self->client)
+	{
+		return;
+	}
+
+	// dead NPCs have a special think, don't run scripts (for now)
+	//FIXME: this breaks deathscripts
+	if ( self->health <= 0 ) 
+	{
+		DeadThink();
+		if ( NPCInfo->nextBStateThink <= level.time )
+		{
+			trap_ICARUS_MaintainTaskManager(self->s.number);
+		}
+		VectorCopy(self->r.currentOrigin, self->client->ps.origin);
+		return;
+	}
+
+	// see if NPC ai is frozen
+	if ( debugNPCFreeze.value || (NPC->r.svFlags&SVF_ICARUS_FREEZE) ) 
+	{
+		NPC_UpdateAngles( qtrue, qtrue );
+		ClientThink(self->s.number, &ucmd);
+		//VectorCopy(self->s.origin, self->s.origin2 );
+		VectorCopy(self->r.currentOrigin, self->client->ps.origin);
+		return;
+	}
+
+	self->nextthink = level.time + FRAMETIME/2;
+
+
+	while (i < MAX_CLIENTS)
+	{
+		player = &g_entities[i];
+
+		if (player->inuse && player->client && player->client->sess.sessionTeam != TEAM_SPECTATOR &&
+			!(player->client->ps.pm_flags & PMF_FOLLOW))
+		{
+			//if ( player->client->ps.viewEntity == self->s.number )
+			if (0) //rwwFIXMEFIXME: Allow controlling ents
+			{//being controlled by player
+				G_DroidSounds( self );
+				//FIXME: might want to at least make sounds or something?
+				//NPC_UpdateAngles(qtrue, qtrue);
+				//Which ucmd should we send?  Does it matter, since it gets overridden anyway?
+				NPCInfo->last_ucmd.serverTime = level.time - 50;
+				ClientThink( NPC->s.number, &ucmd );
+				//VectorCopy(self->s.origin, self->s.origin2 );
+				VectorCopy(self->r.currentOrigin, self->client->ps.origin);
+				return;
+			}
+		}
+		i++;
+	}
+
+	if ( self->client->NPC_class == CLASS_VEHICLE)
+	{
+		if (self->client->ps.m_iVehicleNum)
+		{//we don't think on our own
+			//well, run scripts, though...
+			trap_ICARUS_MaintainTaskManager(self->s.number);
+			return;
+		}
+		else
+		{
+			VectorClear(self->client->ps.moveDir);
+			self->client->pers.cmd.forwardmove = 0;
+			self->client->pers.cmd.rightmove = 0;
+			self->client->pers.cmd.upmove = 0;
+			self->client->pers.cmd.buttons = 0;
+			memcpy(&self->m_pVehicle->m_ucmd, &self->client->pers.cmd, sizeof(usercmd_t));
+		}
+	}
+	else if ( NPC->s.m_iVehicleNum )
+	{//droid in a vehicle?
+		G_DroidSounds( self );
+	}
+
+	if ( NPCInfo->nextBStateThink <= level.time 
+		&& !NPC->s.m_iVehicleNum )//NPCs sitting in Vehicles do NOTHING
+	{
+#if	AI_TIMERS
+		int	startTime = GetTime(0);
+#endif//	AI_TIMERS
+		if ( NPC->s.eType != ET_NPC )
+		{//Something drastic happened in our script
+			return;
+		}
+
+		if ( NPC->s.weapon == WP_SABER && g_spskill.integer >= 2 && NPCInfo->rank > RANK_LT_JG )
+		{//Jedi think faster on hard difficulty, except low-rank (reborn)
+			NPCInfo->nextBStateThink = level.time + FRAMETIME/2;
+		}
+		else
+		{//Maybe even 200 ms?
+			NPCInfo->nextBStateThink = level.time + FRAMETIME;
+		}
+
+		//nextthink is set before this so something in here can override it
+		if (self->s.NPC_class != CLASS_VEHICLE ||
+			!self->m_pVehicle)
+		{ //ok, let's not do this at all for vehicles.
+			NPC_ExecuteBState( self );
+		}
+
+#if	AI_TIMERS
+		int addTime = GetTime( startTime );
+		if ( addTime > 50 )
+		{
+			Com_Printf( S_COLOR_RED"ERROR: NPC number %d, %s %s at %s, weaponnum: %d, using %d of AI time!!!\n", NPC->s.number, NPC->NPC_type, NPC->targetname, vtos(NPC->r.currentOrigin), NPC->s.weapon, addTime );
+		}
+		AITime += addTime;
+#endif//	AI_TIMERS
+	}
+	else
+	{
+		VectorCopy( oldMoveDir, self->client->ps.moveDir );
+		//or use client->pers.lastCommand?
+		NPCInfo->last_ucmd.serverTime = level.time - 50;
+		if ( !NPC->next_roff_time || NPC->next_roff_time < level.time )
+		{//If we were following a roff, we don't do normal pmoves.
+			//FIXME: firing angles (no aim offset) or regular angles?
+			NPC_UpdateAngles(qtrue, qtrue);
+			memcpy( &ucmd, &NPCInfo->last_ucmd, sizeof( usercmd_t ) );
+			ClientThink(NPC->s.number, &ucmd);
+		}
+		else
+		{
+			NPC_ApplyRoff();
+		}
+		//VectorCopy(self->s.origin, self->s.origin2 );
+	}
+	//must update icarus *every* frame because of certain animation completions in the pmove stuff that can leave a 50ms gap between ICARUS animation commands
+	trap_ICARUS_MaintainTaskManager(self->s.number);
+	VectorCopy(self->r.currentOrigin, self->client->ps.origin);
+}
+
+void NPC_InitAI ( void ) 
+{
+	/*
+	trap_Cvar_Register(&g_saberRealisticCombat, "g_saberRealisticCombat", "0", CVAR_CHEAT);
+
+	trap_Cvar_Register(&debugNoRoam, "d_noroam", "0", CVAR_CHEAT);
+	trap_Cvar_Register(&debugNPCAimingBeam, "d_npcaiming", "0", CVAR_CHEAT);
+	trap_Cvar_Register(&debugBreak, "d_break", "0", CVAR_CHEAT);
+	trap_Cvar_Register(&debugNPCAI, "d_npcai", "0", CVAR_CHEAT);
+	trap_Cvar_Register(&debugNPCFreeze, "d_npcfreeze", "0", CVAR_CHEAT);
+	trap_Cvar_Register(&d_JediAI, "d_JediAI", "0", CVAR_CHEAT);
+	trap_Cvar_Register(&d_noGroupAI, "d_noGroupAI", "0", CVAR_CHEAT);
+	trap_Cvar_Register(&d_asynchronousGroupAI, "d_asynchronousGroupAI", "0", CVAR_CHEAT);
+	
+	//0 = never (BORING)
+	//1 = kyle only
+	//2 = kyle and last enemy jedi
+	//3 = kyle and any enemy jedi
+	//4 = kyle and last enemy in a group
+	//5 = kyle and any enemy
+	//6 = also when kyle takes pain or enemy jedi dodges player saber swing or does an acrobatic evasion
+
+	trap_Cvar_Register(&d_slowmodeath, "d_slowmodeath", "0", CVAR_CHEAT);
+
+	trap_Cvar_Register(&d_saberCombat, "d_saberCombat", "0", CVAR_CHEAT);
+
+	trap_Cvar_Register(&g_spskill, "g_npcspskill", "0", CVAR_ARCHIVE | CVAR_USERINFO);
+	*/
+}
+
+/*
+==================================
+void NPC_InitAnimTable( void )
+
+  Need to initialize this table.
+  If someone tried to play an anim
+  before table is filled in with
+  values, causes tasks that wait for
+  anim completion to never finish.
+  (frameLerp of 0 * numFrames of 0 = 0)
+==================================
+*/
+/*
+void NPC_InitAnimTable( void )
+{
+	int i;
+
+	for ( i = 0; i < MAX_ANIM_FILES; i++ )
+	{
+		for ( int j = 0; j < MAX_ANIMATIONS; j++ )
+		{
+			level.knownAnimFileSets[i].animations[j].firstFrame = 0;
+			level.knownAnimFileSets[i].animations[j].frameLerp = 100;
+			level.knownAnimFileSets[i].animations[j].initialLerp = 100;
+			level.knownAnimFileSets[i].animations[j].numFrames = 0;
+		}
+	}
+}
+*/
+
+void NPC_InitGame( void ) 
+{
+//	globals.NPCs = (gNPC_t *) gi.TagMalloc(game.maxclients * sizeof(game.bots[0]), TAG_GAME);
+//	trap_Cvar_Register(&debugNPCName, "d_npc", "0", CVAR_CHEAT);
+
+	NPC_LoadParms();
+	NPC_InitAI();
+//	NPC_InitAnimTable();
+	/*
+	ResetTeamCounters();
+	for ( int team = NPCTEAM_FREE; team < NPCTEAM_NUM_TEAMS; team++ )
+	{
+		teamLastEnemyTime[team] = -10000;
+	}
+	*/
+}
+
+void NPC_SetAnim(gentity_t *ent, int setAnimParts, int anim, int setAnimFlags)
+{	// FIXME : once torsoAnim and legsAnim are in the same structure for NCP and Players
+	// rename PM_SETAnimFinal to PM_SetAnim and have both NCP and Players call PM_SetAnim
+	G_SetAnim(ent, NULL, setAnimParts, anim, setAnimFlags, 0);
+/*
+	if(ent->client)
+	{//Players, NPCs
+		if (setAnimFlags&SETANIM_FLAG_OVERRIDE)
+		{		
+			if (setAnimParts & SETANIM_TORSO)
+			{
+				if( (setAnimFlags & SETANIM_FLAG_RESTART) || ent->client->ps.torsoAnim != anim )
+				{
+					PM_SetTorsoAnimTimer( ent, &ent->client->ps.torsoTimer, 0 );
+				}
+			}
+			if (setAnimParts & SETANIM_LEGS)
+			{
+				if( (setAnimFlags & SETANIM_FLAG_RESTART) || ent->client->ps.legsAnim != anim )
+				{
+					PM_SetLegsAnimTimer( ent, &ent->client->ps.legsAnimTimer, 0 );
+				}
+			}
+		}
+
+		PM_SetAnimFinal(&ent->client->ps.torsoAnim,&ent->client->ps.legsAnim,setAnimParts,anim,setAnimFlags,
+			&ent->client->ps.torsoAnimTimer,&ent->client->ps.legsAnimTimer,ent);
+	}
+	else
+	{//bodies, etc.
+		if (setAnimFlags&SETANIM_FLAG_OVERRIDE)
+		{		
+			if (setAnimParts & SETANIM_TORSO)
+			{
+				if( (setAnimFlags & SETANIM_FLAG_RESTART) || ent->s.torsoAnim != anim )
+				{
+					PM_SetTorsoAnimTimer( ent, &ent->s.torsoAnimTimer, 0 );
+				}
+			}
+			if (setAnimParts & SETANIM_LEGS)
+			{
+				if( (setAnimFlags & SETANIM_FLAG_RESTART) || ent->s.legsAnim != anim )
+				{
+					PM_SetLegsAnimTimer( ent, &ent->s.legsAnimTimer, 0 );
+				}
+			}
+		}
+
+		PM_SetAnimFinal(&ent->s.torsoAnim,&ent->s.legsAnim,setAnimParts,anim,setAnimFlags,
+			&ent->s.torsoAnimTimer,&ent->s.legsAnimTimer,ent);
+	}
+	*/
+}
diff --git a/codemp/game/NPC_AI_Atst.c b/codemp/game/NPC_AI_Atst.c
new file mode 100644
index 0000000..9cd3bdc
--- /dev/null
+++ b/codemp/game/NPC_AI_Atst.c
@@ -0,0 +1,328 @@
+#include "b_local.h"
+
+#define	MIN_MELEE_RANGE		640
+#define	MIN_MELEE_RANGE_SQR	( MIN_MELEE_RANGE * MIN_MELEE_RANGE )
+
+#define MIN_DISTANCE		128
+#define MIN_DISTANCE_SQR	( MIN_DISTANCE * MIN_DISTANCE )
+
+#define TURN_OFF			0x00000100//G2SURFACEFLAG_NODESCENDANTS
+
+#define LEFT_ARM_HEALTH 40
+#define RIGHT_ARM_HEALTH 40
+
+extern void G_SoundOnEnt( gentity_t *ent, soundChannel_t channel, const char *soundPath );
+/*
+-------------------------
+NPC_ATST_Precache
+-------------------------
+*/
+void NPC_ATST_Precache(void)
+{
+	G_SoundIndex( "sound/chars/atst/atst_damaged1" );
+	G_SoundIndex( "sound/chars/atst/atst_damaged2" );
+
+//	RegisterItem( BG_FindItemForWeapon( WP_ATST_MAIN ));	//precache the weapon
+	//rwwFIXMEFIXME: add this weapon
+	RegisterItem( BG_FindItemForWeapon( WP_BOWCASTER ));	//precache the weapon
+	RegisterItem( BG_FindItemForWeapon( WP_ROCKET_LAUNCHER ));	//precache the weapon
+
+	G_EffectIndex( "env/med_explode2" );
+//	G_EffectIndex( "smaller_chunks" );
+	G_EffectIndex( "blaster/smoke_bolton" );
+	G_EffectIndex( "explosions/droidexplosion1" );
+}
+
+//-----------------------------------------------------------------
+#if 0
+static void ATST_PlayEffect( gentity_t *self, const int boltID, const char *fx )
+{
+	if ( boltID >=0 && fx && fx[0] )
+	{
+		mdxaBone_t	boltMatrix;
+		vec3_t		org, dir;
+
+		trap_G2API_GetBoltMatrix( self->ghoul2, 0, 
+					boltID,
+					&boltMatrix, self->r.currentAngles, self->r.currentOrigin, level.time,
+					NULL, self->modelScale );
+
+		BG_GiveMeVectorFromMatrix( &boltMatrix, ORIGIN, org );
+		BG_GiveMeVectorFromMatrix( &boltMatrix, NEGATIVE_Y, dir );
+
+		G_PlayEffectID( G_EffectIndex((char *)fx), org, dir );
+	}
+}
+#endif
+
+/*
+-------------------------
+G_ATSTCheckPain
+
+Called by NPC's and player in an ATST
+-------------------------
+*/
+
+void G_ATSTCheckPain( gentity_t *self, gentity_t *other, int damage )
+{
+	//int newBolt;
+	//int hitLoc = gPainHitLoc;
+	
+	if ( rand() & 1 )
+	{
+		G_SoundOnEnt( self, CHAN_LESS_ATTEN, "sound/chars/atst/atst_damaged1" );
+	}
+	else
+	{
+		G_SoundOnEnt( self, CHAN_LESS_ATTEN, "sound/chars/atst/atst_damaged2" );
+	}
+
+	/*
+	if ((hitLoc==HL_ARM_LT) && (self->locationDamage[HL_ARM_LT] > LEFT_ARM_HEALTH))
+	{
+		if (self->locationDamage[hitLoc] >= LEFT_ARM_HEALTH)	// Blow it up?
+		{
+			newBolt = trap_G2API_AddBolt( self->ghoul2, 0, "*flash3" );
+			if ( newBolt != -1 )
+			{
+//				G_PlayEffect( "small_chunks", self->playerModel, self->genericBolt1, self->s.number);
+				ATST_PlayEffect( self, trap_G2API_AddBolt(self->ghoul2, 0, "*flash3"), "env/med_explode2" );
+				//G_PlayEffectID( G_EffectIndex("blaster/smoke_bolton"), self->playerModel, newBolt, self->s.number);
+				//Maybe bother with this some other time.
+			}
+
+			NPC_SetSurfaceOnOff( self, "head_light_blaster_cann", TURN_OFF );
+		}
+	}
+	else if ((hitLoc==HL_ARM_RT) && (self->locationDamage[HL_ARM_RT] > RIGHT_ARM_HEALTH))	// Blow it up?
+	{
+		if (self->locationDamage[hitLoc] >= RIGHT_ARM_HEALTH)
+		{			
+			newBolt = trap_G2API_AddBolt( self->ghoul2, 0, "*flash4" );
+			if ( newBolt != -1 )
+			{
+//				G_PlayEffect( "small_chunks", self->playerModel, self->genericBolt2, self->s.number);
+				ATST_PlayEffect( self, trap_G2API_AddBolt(self->ghoul2, 0, "*flash4"), "env/med_explode2" );
+				//G_PlayEffect( "blaster/smoke_bolton", self->playerModel, newBolt, self->s.number);
+			}
+
+			NPC_SetSurfaceOnOff( self, "head_concussion_charger", TURN_OFF );
+		}
+	}
+	*/
+}
+/*
+-------------------------
+NPC_ATST_Pain
+-------------------------
+*/
+void NPC_ATST_Pain(gentity_t *self, gentity_t *attacker, int damage) 
+{
+	G_ATSTCheckPain( self, attacker, damage );
+	NPC_Pain( self, attacker, damage );
+}
+
+/*
+-------------------------
+ATST_Hunt
+-------------------------`
+*/
+void ATST_Hunt( qboolean visible, qboolean advance )
+{
+
+	if ( NPCInfo->goalEntity == NULL )
+	{//hunt
+		NPCInfo->goalEntity = NPC->enemy;
+	}
+
+	NPCInfo->combatMove = qtrue;
+
+	NPC_MoveToGoal( qtrue );
+
+}
+
+/*
+-------------------------
+ATST_Ranged
+-------------------------
+*/
+void ATST_Ranged( qboolean visible, qboolean advance, qboolean altAttack )
+{
+
+	if ( TIMER_Done( NPC, "atkDelay" ) && visible )	// Attack?
+	{
+		TIMER_Set( NPC, "atkDelay", Q_irand( 500, 3000 ) );
+
+		if (altAttack)
+		{
+			ucmd.buttons |= BUTTON_ATTACK|BUTTON_ALT_ATTACK;
+		}
+		else
+		{
+			ucmd.buttons |= BUTTON_ATTACK;
+		}
+	}
+
+	if ( NPCInfo->scriptFlags & SCF_CHASE_ENEMIES )
+	{
+		ATST_Hunt( visible, advance );
+	}
+}
+
+/*
+-------------------------
+ATST_Attack
+-------------------------
+*/
+void ATST_Attack( void )
+{
+	qboolean	altAttack=qfalse;
+	int			blasterTest,chargerTest,weapon;
+	float		distance;	
+	distance_e	distRate;
+	qboolean	visible;
+	qboolean	advance;
+
+	if ( NPC_CheckEnemyExt(qfalse) == qfalse )//!NPC->enemy )//
+	{
+		NPC->enemy = NULL;
+		return;
+	}
+
+	NPC_FaceEnemy( qtrue );
+
+	// Rate our distance to the target, and our visibilty
+	distance	= (int) DistanceHorizontalSquared( NPC->r.currentOrigin, NPC->enemy->r.currentOrigin );	
+	distRate	= ( distance > MIN_MELEE_RANGE_SQR ) ? DIST_LONG : DIST_MELEE;
+	visible		= NPC_ClearLOS4( NPC->enemy );
+	advance		= (qboolean)(distance > MIN_DISTANCE_SQR);
+
+	// If we cannot see our target, move to see it
+	if ( visible == qfalse )
+	{
+		if ( NPCInfo->scriptFlags & SCF_CHASE_ENEMIES )
+		{
+			ATST_Hunt( visible, advance );
+			return;
+		}
+	}
+
+	// Decide what type of attack to do
+	switch ( distRate )
+	{
+	case DIST_MELEE:
+//		NPC_ChangeWeapon( WP_ATST_MAIN );
+		break;
+
+	case DIST_LONG:
+
+//		NPC_ChangeWeapon( WP_ATST_SIDE );
+		//rwwFIXMEFIXME: make atst weaps work.
+
+		// See if the side weapons are there
+		blasterTest = trap_G2API_GetSurfaceRenderStatus( NPC->ghoul2, 0, "head_light_blaster_cann" );
+		chargerTest = trap_G2API_GetSurfaceRenderStatus( NPC->ghoul2, 0, "head_concussion_charger" );
+
+		// It has both side weapons
+		if ( blasterTest != -1
+			&& !(blasterTest&TURN_OFF)  
+			&& chargerTest != -1
+			&& !(chargerTest&TURN_OFF))
+		{
+			weapon = Q_irand( 0, 1);	// 0 is blaster, 1 is charger (ALT SIDE)
+
+			if (weapon)				// Fire charger
+			{
+				altAttack = qtrue;
+			}
+			else
+			{
+				altAttack = qfalse;
+			}
+
+		}
+		else if (blasterTest != -1
+			&& !(blasterTest & TURN_OFF))	// Blaster is on
+		{
+			altAttack = qfalse;
+		}
+		else if (chargerTest != -1
+			&&!(chargerTest & TURN_OFF))	// Blaster is on
+		{
+			altAttack = qtrue;
+		}
+		else 
+		{
+			NPC_ChangeWeapon( WP_NONE );
+		}
+		break;
+	}
+
+	NPC_FaceEnemy( qtrue );
+
+	ATST_Ranged( visible, advance,altAttack );
+}
+
+/*
+-------------------------
+ATST_Patrol
+-------------------------
+*/
+void ATST_Patrol( void )
+{
+	if ( NPC_CheckPlayerTeamStealth() )
+	{
+		NPC_UpdateAngles( qtrue, qtrue );
+		return;
+	}
+
+	//If we have somewhere to go, then do that
+	if (!NPC->enemy)
+	{
+		if ( UpdateGoal() )
+		{
+			ucmd.buttons |= BUTTON_WALKING;
+			NPC_MoveToGoal( qtrue );
+			NPC_UpdateAngles( qtrue, qtrue );
+		}
+	}
+
+}
+
+/*
+-------------------------
+ATST_Idle
+-------------------------
+*/
+void ATST_Idle( void )
+{
+
+	NPC_BSIdle();
+
+	NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_STAND1, SETANIM_FLAG_NORMAL );
+}
+
+/*
+-------------------------
+NPC_BSDroid_Default
+-------------------------
+*/
+void NPC_BSATST_Default( void )
+{
+	if ( NPC->enemy )
+	{
+		if( (NPCInfo->scriptFlags & SCF_CHASE_ENEMIES) )
+		{
+			NPCInfo->goalEntity = NPC->enemy;
+		}
+		ATST_Attack();
+	}
+	else if ( NPCInfo->scriptFlags & SCF_LOOK_FOR_ENEMIES )
+	{
+		ATST_Patrol();
+	} 
+	else
+	{
+		ATST_Idle();
+	}
+}
diff --git a/codemp/game/NPC_AI_Default.c b/codemp/game/NPC_AI_Default.c
new file mode 100644
index 0000000..9486f8f
--- /dev/null
+++ b/codemp/game/NPC_AI_Default.c
@@ -0,0 +1,957 @@
+#include "b_local.h"
+#include "g_nav.h"
+#include "../icarus/Q3_Interface.h"
+
+//#include "anims.h"
+//extern int PM_AnimLength( int index, animNumber_t anim );
+//extern int PM_AnimLength( int index, animNumber_t anim );
+//#define	MAX_IDLE_ANIMS	8
+
+extern qboolean NPC_SomeoneLookingAtMe(gentity_t *ent);
+
+/*
+void NPC_LostEnemyDecideChase(void)
+
+  We lost our enemy and want to drop him but see if we should chase him if we are in the proper bState
+*/
+
+void NPC_LostEnemyDecideChase(void)
+{
+	switch( NPCInfo->behaviorState )
+	{
+	case BS_HUNT_AND_KILL:
+		//We were chasing him and lost him, so try to find him
+		if ( NPC->enemy == NPCInfo->goalEntity && NPC->enemy->lastWaypoint != WAYPOINT_NONE )
+		{//Remember his last valid Wp, then check it out
+			//FIXME: Should we only do this if there's no other enemies or we've got LOCKED_ENEMY on?
+			NPC_BSSearchStart( NPC->enemy->lastWaypoint, BS_SEARCH );
+		}
+		//If he's not our goalEntity, we're running somewhere else, so lose him
+		break;
+	default:
+		break;
+	}
+	G_ClearEnemy( NPC );
+}
+/*
+-------------------------
+NPC_StandIdle
+-------------------------
+*/
+
+void NPC_StandIdle( void )
+{
+/*
+	//Must be done with any other animations
+	if ( NPC->client->ps.legsAnimTimer != 0 )
+		return;
+
+	//Not ready to do another one
+	if ( TIMER_Done( NPC, "idleAnim" ) == false )
+		return;
+
+	int anim = NPC->client->ps.legsAnim;
+
+	if ( anim != BOTH_STAND1 && anim != BOTH_STAND2 )
+		return;
+
+	//FIXME: Account for STAND1 or STAND2 here and set the base anim accordingly
+	int	baseSeq = ( anim == BOTH_STAND1 ) ? BOTH_STAND1_RANDOM1 : BOTH_STAND2_RANDOM1;
+
+	//Must have at least one random idle animation
+	//NOTENOTE: This relies on proper ordering of animations, which SHOULD be okay
+	if ( PM_HasAnimation( NPC, baseSeq ) == false )
+		return;
+
+	int	newIdle = Q_irand( 0, MAX_IDLE_ANIMS-1 );
+
+	//FIXME: Technically this could never complete.. but that's not really too likely
+	while( 1 )
+	{
+		if ( PM_HasAnimation( NPC, baseSeq + newIdle ) )
+			break;
+
+		newIdle = Q_irand( 0, MAX_IDLE_ANIMS );
+	}
+	
+	//Start that animation going
+	NPC_SetAnim( NPC, SETANIM_BOTH, baseSeq + newIdle, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+	
+	int newTime = PM_AnimLength( NPC->client->clientInfo.animFileIndex, (animNumber_t) (baseSeq + newIdle) );
+
+	//Don't do this again for a random amount of time
+	TIMER_Set( NPC, "idleAnim", newTime + Q_irand( 2000, 10000 ) );
+*/
+}
+
+qboolean NPC_StandTrackAndShoot (gentity_t *NPC, qboolean canDuck)
+{
+	qboolean	attack_ok = qfalse;
+	qboolean	duck_ok = qfalse;
+	qboolean	faced = qfalse;
+	float		attack_scale = 1.0;
+
+	//First see if we're hurt bad- if so, duck
+	//FIXME: if even when ducked, we can shoot someone, we should.
+	//Maybe is can be shot even when ducked, we should run away to the nearest cover?
+	if ( canDuck )
+	{
+		if ( NPC->health < 20 )
+		{
+		//	if( NPC->svFlags&SVF_HEALING || random() )
+			if( random() )
+			{
+				duck_ok = qtrue;
+			}
+		}
+		else if ( NPC->health < 40 )
+		{
+//			if ( NPC->svFlags&SVF_HEALING )
+//			{//Medic is on the way, get down!
+//				duck_ok = qtrue;
+//			}
+			// no more borg
+///			if ( NPC->client->playerTeam!= TEAM_BORG )
+//			{//Borg don't care if they're about to die
+				//attack_scale will be a max of .66
+//				attack_scale = NPC->health/60;
+//			}
+		}
+	}
+
+	//NPC_CheckEnemy( qtrue, qfalse, qtrue );
+
+	if ( !duck_ok )
+	{//made this whole part a function call
+		attack_ok = NPC_CheckCanAttack( attack_scale, qtrue );
+		faced = qtrue;
+	}
+
+	if ( canDuck && (duck_ok || (!attack_ok && client->ps.weaponTime <= 0)) && ucmd.upmove != -127 )
+	{//if we didn't attack check to duck if we're not already
+		if( !duck_ok )
+		{
+			if ( NPC->enemy->client )
+			{
+				if ( NPC->enemy->enemy == NPC )
+				{
+					if ( NPC->enemy->client->buttons & BUTTON_ATTACK )
+					{//FIXME: determine if enemy fire angles would hit me or get close
+						if ( NPC_CheckDefend( 1.0 ) )//FIXME: Check self-preservation?  Health?
+						{
+							duck_ok = qtrue;
+						}
+					}
+				}
+			}
+		}
+
+		if ( duck_ok )
+		{//duck and don't shoot
+			attack_ok = qfalse;
+			ucmd.upmove = -127;
+			NPCInfo->duckDebounceTime = level.time + 1000;//duck for a full second
+		}
+	}
+
+	return faced;
+}
+
+
+void NPC_BSIdle( void ) 
+{
+	//FIXME if there is no nav data, we need to do something else
+	// if we're stuck, try to move around it
+	if ( UpdateGoal() )
+	{
+		NPC_MoveToGoal( qtrue );
+	}
+
+	if ( ( ucmd.forwardmove == 0 ) && ( ucmd.rightmove == 0 ) && ( ucmd.upmove == 0 ) )
+	{
+//		NPC_StandIdle();
+	}
+
+	NPC_UpdateAngles( qtrue, qtrue );
+	ucmd.buttons |= BUTTON_WALKING;
+}
+
+void NPC_BSRun (void)
+{
+	//FIXME if there is no nav data, we need to do something else
+	// if we're stuck, try to move around it
+	if ( UpdateGoal() )
+	{
+		NPC_MoveToGoal( qtrue );
+	}
+
+	NPC_UpdateAngles( qtrue, qtrue );
+}
+
+void NPC_BSStandGuard (void)
+{
+	//FIXME: Use Snapshot info
+	if ( NPC->enemy == NULL )
+	{//Possible to pick one up by being shot
+		if( random() < 0.5 )
+		{
+			if(NPC->client->enemyTeam)
+			{
+				gentity_t *newenemy = NPC_PickEnemy(NPC, NPC->client->enemyTeam, (NPC->cantHitEnemyCounter < 10), (NPC->client->enemyTeam == NPCTEAM_PLAYER), qtrue);
+				//only checks for vis if couldn't hit last enemy
+				if(newenemy)
+				{
+					G_SetEnemy( NPC, newenemy );
+				}
+			}
+		}
+	}
+
+	if ( NPC->enemy != NULL )
+	{
+		if( NPCInfo->tempBehavior == BS_STAND_GUARD )
+		{
+			NPCInfo->tempBehavior = BS_DEFAULT;
+		}
+		
+		if( NPCInfo->behaviorState == BS_STAND_GUARD )
+		{
+			NPCInfo->behaviorState = BS_STAND_AND_SHOOT;
+		}
+	}
+
+	NPC_UpdateAngles( qtrue, qtrue );
+}
+
+/*
+-------------------------
+NPC_BSHuntAndKill
+-------------------------
+*/
+
+void NPC_BSHuntAndKill( void )
+{
+	qboolean	turned = qfalse;
+	vec3_t		vec;
+	float		enemyDist;
+	visibility_t	oEVis;
+	int			curAnim;
+
+	NPC_CheckEnemy( NPCInfo->tempBehavior != BS_HUNT_AND_KILL, qfalse, qtrue );//don't find new enemy if this is tempbehav
+
+	if ( NPC->enemy )
+	{
+		oEVis = enemyVisibility = NPC_CheckVisibility ( NPC->enemy, CHECK_FOV|CHECK_SHOOT );//CHECK_360|//CHECK_PVS|
+		if(enemyVisibility > VIS_PVS)
+		{
+			if ( !NPC_EnemyTooFar( NPC->enemy, 0, qtrue ) )
+			{//Enemy is close enough to shoot - FIXME: this next func does this also, but need to know here for info on whether ot not to turn later
+				NPC_CheckCanAttack( 1.0, qfalse );
+				turned = qtrue;
+			}
+		}
+
+		curAnim = NPC->client->ps.legsAnim;
+		if(curAnim != BOTH_ATTACK1 && curAnim != BOTH_ATTACK2 && curAnim != BOTH_ATTACK3 && curAnim != BOTH_MELEE1 && curAnim != BOTH_MELEE2 )
+		{//Don't move toward enemy if we're in a full-body attack anim
+			//FIXME, use IdealDistance to determin if we need to close distance
+			VectorSubtract(NPC->enemy->r.currentOrigin, NPC->r.currentOrigin, vec);
+			enemyDist = VectorLength(vec);
+			if( enemyDist > 48 && ((enemyDist*1.5)*(enemyDist*1.5) >= NPC_MaxDistSquaredForWeapon() ||
+				oEVis != VIS_SHOOT ||
+				//!(ucmd.buttons & BUTTON_ATTACK) || 
+				enemyDist > IdealDistance(NPC)*3 ) )
+			{//We should close in?
+				NPCInfo->goalEntity = NPC->enemy;
+
+				NPC_MoveToGoal( qtrue );
+			}
+			else if(enemyDist < IdealDistance(NPC))
+			{//We should back off?
+				//if(ucmd.buttons & BUTTON_ATTACK)
+				{
+					NPCInfo->goalEntity = NPC->enemy;
+					NPCInfo->goalRadius = 12;
+					NPC_MoveToGoal( qtrue );
+
+					ucmd.forwardmove *= -1;
+					ucmd.rightmove *= -1;
+					VectorScale( NPC->client->ps.moveDir, -1, NPC->client->ps.moveDir );
+
+					ucmd.buttons |= BUTTON_WALKING;
+				}
+			}//otherwise, stay where we are
+		}
+	}
+	else 
+	{//ok, stand guard until we find an enemy
+		if( NPCInfo->tempBehavior == BS_HUNT_AND_KILL )
+		{
+			NPCInfo->tempBehavior = BS_DEFAULT;
+		}
+		else
+		{
+			NPCInfo->tempBehavior = BS_STAND_GUARD;
+			NPC_BSStandGuard();
+		}
+		return;
+	}
+
+	if(!turned)
+	{
+		NPC_UpdateAngles(qtrue, qtrue);
+	}
+}
+
+void NPC_BSStandAndShoot (void)
+{
+	//FIXME:
+	//When our numbers outnumber enemies 3 to 1, or only one of them,
+	//go into hunt and kill mode
+
+	//FIXME:
+	//When they're all dead, go to some script or wander off to sickbay?
+	
+	if(NPC->client->playerTeam && NPC->client->enemyTeam)
+	{
+		//FIXME: don't realize this right away- or else enemies show up and we're standing around
+		/*
+		if( teamNumbers[NPC->enemyTeam] == 0 )
+		{//ok, stand guard until we find another enemy
+			//reset our rush counter
+			teamCounter[NPC->playerTeam] = 0;
+			NPCInfo->tempBehavior = BS_STAND_GUARD;
+			NPC_BSStandGuard();
+			return;
+		}*/
+		/*
+		//FIXME: whether to do this or not should be settable
+		else if( NPC->playerTeam != TEAM_BORG )//Borg don't rush
+		{
+		//FIXME: In case reinforcements show up, we should wait a few seconds
+		//and keep checking before rushing!
+		//Also: what if not everyone on our team is going after playerTeam?
+		//Also: our team count includes medics!
+			if(NPC->health > 25)
+			{//Can we rush the enemy?
+				if(teamNumbers[NPC->enemyTeam] == 1 ||
+					teamNumbers[NPC->playerTeam] >= teamNumbers[NPC->enemyTeam]*3)
+				{//Only one of them or we outnumber 3 to 1
+					if(teamStrength[NPC->playerTeam] >= 75 ||
+						(teamStrength[NPC->playerTeam] >= 50 && teamStrength[NPC->playerTeam] > teamStrength[NPC->enemyTeam]))
+					{//Our team is strong enough to rush
+						teamCounter[NPC->playerTeam]++;
+						if(teamNumbers[NPC->playerTeam] * 17 <= teamCounter[NPC->playerTeam])
+						{//ok, we waited 1.7 think cycles on average and everyone is go, let's do it!
+							//FIXME: Should we do this to everyone on our team?
+							NPCInfo->behaviorState = BS_HUNT_AND_KILL;
+							//FIXME: if the tide changes, we should retreat!
+							//FIXME: when do we reset the counter?
+							NPC_BSHuntAndKill ();
+							return;
+						}
+					}
+					else//Oops!  Something's wrong, reset the counter to rush
+						teamCounter[NPC->playerTeam] = 0;
+				}
+				else//Oops!  Something's wrong, reset the counter to rush
+					teamCounter[NPC->playerTeam] = 0;
+			}
+		}
+		*/
+	}
+
+	NPC_CheckEnemy(qtrue, qfalse, qtrue);
+	
+	if(NPCInfo->duckDebounceTime > level.time && NPC->client->ps.weapon != WP_SABER )
+	{
+		ucmd.upmove = -127;
+		if(NPC->enemy)
+		{
+			NPC_CheckCanAttack(1.0, qtrue);
+		}
+		return;		
+	}
+
+	if(NPC->enemy)
+	{
+		if(!NPC_StandTrackAndShoot( NPC, qtrue ))
+		{//That func didn't update our angles
+			NPCInfo->desiredYaw = NPC->client->ps.viewangles[YAW];
+			NPCInfo->desiredPitch = NPC->client->ps.viewangles[PITCH];
+			NPC_UpdateAngles(qtrue, qtrue);
+		}
+	}
+	else
+	{
+		NPCInfo->desiredYaw = NPC->client->ps.viewangles[YAW];
+		NPCInfo->desiredPitch = NPC->client->ps.viewangles[PITCH];
+		NPC_UpdateAngles(qtrue, qtrue);
+//		NPC_BSIdle();//only moves if we have a goal
+	}
+}
+
+void NPC_BSRunAndShoot (void)
+{
+	/*if(NPC->playerTeam && NPC->enemyTeam)
+	{
+		//FIXME: don't realize this right away- or else enemies show up and we're standing around
+		if( teamNumbers[NPC->enemyTeam] == 0 )
+		{//ok, stand guard until we find another enemy
+			//reset our rush counter
+			teamCounter[NPC->playerTeam] = 0;
+			NPCInfo->tempBehavior = BS_STAND_GUARD;
+			NPC_BSStandGuard();
+			return;
+		}
+	}*/
+
+	//NOTE: are we sure we want ALL run and shoot people to move this way?
+	//Shouldn't it check to see if we have an enemy and our enemy is our goal?!
+	//Moved that check into NPC_MoveToGoal
+	//NPCInfo->combatMove = qtrue;
+
+	NPC_CheckEnemy( qtrue, qfalse, qtrue );
+	
+	if ( NPCInfo->duckDebounceTime > level.time ) // && NPCInfo->hidingGoal )
+	{
+		ucmd.upmove = -127;
+		if ( NPC->enemy )
+		{
+			NPC_CheckCanAttack( 1.0, qfalse );
+		}
+		return;		
+	}
+
+	if ( NPC->enemy )
+	{
+		int monitor = NPC->cantHitEnemyCounter;
+		NPC_StandTrackAndShoot( NPC, qfalse );//(NPCInfo->hidingGoal != NULL) );
+
+		if ( !(ucmd.buttons & BUTTON_ATTACK) && ucmd.upmove >= 0 && NPC->cantHitEnemyCounter > monitor )
+		{//not crouching and not firing
+			vec3_t	vec;
+
+			VectorSubtract( NPC->enemy->r.currentOrigin, NPC->r.currentOrigin, vec );
+			vec[2] = 0;
+			if ( VectorLength( vec ) > 128 || NPC->cantHitEnemyCounter >= 10 )
+			{//run at enemy if too far away
+				//The cantHitEnemyCounter getting high has other repercussions
+				//100 (10 seconds) will make you try to pick a new enemy... 
+				//But we're chasing, so we clamp it at 50 here
+				if ( NPC->cantHitEnemyCounter > 60 )
+				{
+					NPC->cantHitEnemyCounter = 60;
+				}
+				
+				if ( NPC->cantHitEnemyCounter >= (NPCInfo->stats.aggression+1) * 10 )
+				{
+					NPC_LostEnemyDecideChase();
+				}
+
+				//chase and face
+				ucmd.angles[YAW] = 0;
+				ucmd.angles[PITCH] = 0;
+				NPCInfo->goalEntity = NPC->enemy;
+				NPCInfo->goalRadius = 12;
+				//NAV_ClearLastRoute(NPC);
+				NPC_MoveToGoal( qtrue );
+				NPC_UpdateAngles(qtrue, qtrue);
+			}
+			else
+			{
+				//FIXME: this could happen if they're just on the other side
+				//of a thin wall or something else blocking out shot.  That
+				//would make us just stand there and not go around it...
+				//but maybe it's okay- might look like we're waiting for
+				//him to come out...?  
+				//Current solution: runs around if cantHitEnemyCounter gets
+				//to 10 (1 second).  
+			}
+		}
+		else
+		{//Clear the can't hit enemy counter here
+			NPC->cantHitEnemyCounter = 0;
+		}
+	}
+	else
+	{
+		if ( NPCInfo->tempBehavior == BS_HUNT_AND_KILL )
+		{//lost him, go back to what we were doing before
+			NPCInfo->tempBehavior = BS_DEFAULT;
+			return;
+		}
+
+//		NPC_BSRun();//only moves if we have a goal
+	}
+}
+
+//Simply turn until facing desired angles
+void NPC_BSFace (void)
+{
+	//FIXME: once you stop sending turning info, they reset to whatever their delta_angles was last????
+	//Once this is over, it snaps back to what it was facing before- WHY???
+	if( NPC_UpdateAngles ( qtrue, qtrue ) )
+	{
+		trap_ICARUS_TaskIDComplete( NPC, TID_BSTATE );
+		
+		NPCInfo->desiredYaw = client->ps.viewangles[YAW];
+		NPCInfo->desiredPitch = client->ps.viewangles[PITCH];
+
+		NPCInfo->aimTime = 0;//ok to turn normally now
+	}
+}
+
+void NPC_BSPointShoot (qboolean shoot)
+{//FIXME: doesn't check for clear shot...
+	vec3_t	muzzle, dir, angles, org;
+
+	if ( !NPC->enemy || !NPC->enemy->inuse || (NPC->enemy->NPC && NPC->enemy->health <= 0) )
+	{//FIXME: should still keep shooting for a second or two after they actually die...
+		trap_ICARUS_TaskIDComplete( NPC, TID_BSTATE );
+		goto finished;
+		return;
+	}
+
+	CalcEntitySpot(NPC, SPOT_WEAPON, muzzle);
+	CalcEntitySpot(NPC->enemy, SPOT_HEAD, org);//Was spot_org
+	//Head is a little high, so let's aim for the chest:
+	if ( NPC->enemy->client )
+	{
+		org[2] -= 12;//NOTE: is this enough?
+	}
+
+	VectorSubtract(org, muzzle, dir);
+	vectoangles(dir, angles);
+
+	switch( NPC->client->ps.weapon )
+	{
+	case WP_NONE:
+//	case WP_TRICORDER:
+	case WP_STUN_BATON:
+	case WP_SABER:
+		//don't do any pitch change if not holding a firing weapon
+		break;
+	default:
+		NPCInfo->desiredPitch = NPCInfo->lockedDesiredPitch = AngleNormalize360(angles[PITCH]);
+		break;
+	}
+
+	NPCInfo->desiredYaw = NPCInfo->lockedDesiredYaw = AngleNormalize360(angles[YAW]);
+
+	if ( NPC_UpdateAngles ( qtrue, qtrue ) )
+	{//FIXME: if angles clamped, this may never work!
+		//NPCInfo->shotTime = NPC->attackDebounceTime = 0;
+
+		if ( shoot )
+		{//FIXME: needs to hold this down if using a weapon that requires it, like phaser...
+			ucmd.buttons |= BUTTON_ATTACK;
+		}
+		
+		//if ( !shoot || !(NPC->svFlags & SVF_LOCKEDENEMY) )
+		if (1)
+		{//If locked_enemy is on, dont complete until it is destroyed...
+			trap_ICARUS_TaskIDComplete( NPC, TID_BSTATE );
+			goto finished;
+		}
+	}
+	//else if ( shoot && (NPC->svFlags & SVF_LOCKEDENEMY) )
+	if (0)
+	{//shooting them till their dead, not aiming right at them yet...
+		/*
+		qboolean movingTarget = qfalse;
+
+		if ( NPC->enemy->client )
+		{
+			if ( VectorLengthSquared( NPC->enemy->client->ps.velocity ) )
+			{
+				movingTarget = qtrue;
+			}
+		}
+		else if ( VectorLengthSquared( NPC->enemy->s.pos.trDelta ) )
+		{
+			movingTarget = qtrue;
+		}
+
+		if (movingTarget )
+		*/
+		{
+			float	dist = VectorLength( dir );
+			float	yawMiss, yawMissAllow = NPC->enemy->r.maxs[0];
+			float	pitchMiss, pitchMissAllow = (NPC->enemy->r.maxs[2] - NPC->enemy->r.mins[2])/2;
+			
+			if ( yawMissAllow < 8.0f )
+			{
+				yawMissAllow = 8.0f;
+			}
+
+			if ( pitchMissAllow < 8.0f )
+			{
+				pitchMissAllow = 8.0f;
+			}
+
+			yawMiss = tan(DEG2RAD(AngleDelta ( NPC->client->ps.viewangles[YAW], NPCInfo->desiredYaw ))) * dist;
+			pitchMiss = tan(DEG2RAD(AngleDelta ( NPC->client->ps.viewangles[PITCH], NPCInfo->desiredPitch))) * dist;
+
+			if ( yawMissAllow >= yawMiss && pitchMissAllow > pitchMiss )
+			{
+				ucmd.buttons |= BUTTON_ATTACK;
+			}
+		}
+	}
+	
+	return;
+		
+finished:
+	NPCInfo->desiredYaw = client->ps.viewangles[YAW];
+	NPCInfo->desiredPitch = client->ps.viewangles[PITCH];
+
+	NPCInfo->aimTime = 0;//ok to turn normally now
+}
+
+/*
+void NPC_BSMove(void)
+Move in a direction, face another
+*/
+void NPC_BSMove(void)
+{
+	gentity_t	*goal = NULL;
+
+	NPC_CheckEnemy(qtrue, qfalse, qtrue);
+	if(NPC->enemy)
+	{
+		NPC_CheckCanAttack(1.0, qfalse);
+	}
+	else
+	{
+		NPC_UpdateAngles(qtrue, qtrue);
+	}
+
+	goal = UpdateGoal();
+	if(goal)
+	{
+//		NPCInfo->moveToGoalMod = 1.0;
+
+		NPC_SlideMoveToGoal();
+	}
+}
+
+/*
+void NPC_BSShoot(void)
+Move in a direction, face another
+*/
+
+void NPC_BSShoot(void)
+{
+//	NPC_BSMove();
+
+	enemyVisibility = VIS_SHOOT;
+
+	if ( client->ps.weaponstate != WEAPON_READY && client->ps.weaponstate != WEAPON_FIRING ) 
+	{
+		client->ps.weaponstate = WEAPON_READY;
+	}
+
+	WeaponThink(qtrue);
+}
+
+/*
+void NPC_BSPatrol( void ) 
+
+  Same as idle, but you look for enemies every "vigilance"
+  using your angles, HFOV, VFOV and visrange, and listen for sounds within earshot...
+*/
+void NPC_BSPatrol( void ) 
+{
+	//int	alertEventNum;
+
+	if(level.time > NPCInfo->enemyCheckDebounceTime)
+	{
+		NPCInfo->enemyCheckDebounceTime = level.time + (NPCInfo->stats.vigilance * 1000);
+		NPC_CheckEnemy(qtrue, qfalse, qtrue);
+		if(NPC->enemy)
+		{//FIXME: do anger script
+			NPCInfo->behaviorState = BS_HUNT_AND_KILL;
+			//NPC_AngerSound();
+			return;
+		}
+	}
+
+	//FIXME: Implement generic sound alerts
+	/*
+	alertEventNum = NPC_CheckAlertEvents( qtrue, qtrue );
+	if( alertEventNum != -1 )
+	{//If we heard something, see if we should check it out
+		if ( NPC_CheckInvestigate( alertEventNum ) )
+		{
+			return;
+		}
+	}
+	*/
+
+	NPCInfo->investigateSoundDebounceTime = 0;
+	//FIXME if there is no nav data, we need to do something else
+	// if we're stuck, try to move around it
+	if ( UpdateGoal() )
+	{
+		NPC_MoveToGoal( qtrue );
+	}
+
+	NPC_UpdateAngles( qtrue, qtrue );
+
+	ucmd.buttons |= BUTTON_WALKING;
+}
+
+/*
+void NPC_BSDefault(void)
+	uses various scriptflags to determine how an npc should behave
+*/
+extern void NPC_CheckGetNewWeapon( void );
+extern void NPC_BSST_Attack( void );
+
+void NPC_BSDefault( void ) 
+{
+//	vec3_t		enemyDir;
+//	float		enemyDist;
+//	float		shootDist;
+//	qboolean	enemyFOV = qfalse;
+//	qboolean	enemyShotFOV = qfalse;
+//	qboolean	enemyPVS = qfalse;
+//	vec3_t		enemyHead;
+//	vec3_t		muzzle;
+//	qboolean	enemyLOS = qfalse;
+//	qboolean	enemyCS = qfalse;
+	qboolean	move = qtrue;
+//	qboolean	shoot = qfalse;
+
+	
+	if( NPCInfo->scriptFlags & SCF_FIRE_WEAPON )
+	{
+		WeaponThink( qtrue );
+	}
+
+	if ( NPCInfo->scriptFlags & SCF_FORCED_MARCH )
+	{//being forced to walk
+		if( NPC->client->ps.torsoAnim != TORSO_SURRENDER_START )
+		{
+			NPC_SetAnim( NPC, SETANIM_TORSO, TORSO_SURRENDER_START, SETANIM_FLAG_HOLD );
+		}
+	}
+	//look for a new enemy if don't have one and are allowed to look, validate current enemy if have one
+	NPC_CheckEnemy( (NPCInfo->scriptFlags&SCF_LOOK_FOR_ENEMIES), qfalse, qtrue );
+	if ( !NPC->enemy )
+	{//still don't have an enemy
+		if ( !(NPCInfo->scriptFlags&SCF_IGNORE_ALERTS) )
+		{//check for alert events
+			//FIXME: Check Alert events, see if we should investigate or just look at it
+			int alertEvent = NPC_CheckAlertEvents( qtrue, qtrue, -1, qtrue, AEL_DISCOVERED );
+
+			//There is an event to look at
+			if ( alertEvent >= 0 && level.alertEvents[alertEvent].ID != NPCInfo->lastAlertID )
+			{//heard/saw something
+				if ( level.alertEvents[alertEvent].level >= AEL_DISCOVERED && (NPCInfo->scriptFlags&SCF_LOOK_FOR_ENEMIES) )
+				{//was a big event
+					if ( level.alertEvents[alertEvent].owner && level.alertEvents[alertEvent].owner->client && level.alertEvents[alertEvent].owner->health >= 0 && level.alertEvents[alertEvent].owner->client->playerTeam == NPC->client->enemyTeam )
+					{//an enemy
+						G_SetEnemy( NPC, level.alertEvents[alertEvent].owner );
+					}
+				}
+				else
+				{//FIXME: investigate lesser events
+				}
+			}
+			//FIXME: also check our allies' condition?
+		}
+	}
+
+	if ( NPC->enemy && !(NPCInfo->scriptFlags&SCF_FORCED_MARCH) )
+	{
+		// just use the stormtrooper attack AI...
+		NPC_CheckGetNewWeapon();
+		if ( NPC->client->leader 
+			&& NPCInfo->goalEntity == NPC->client->leader 
+			&& !trap_ICARUS_TaskIDPending( NPC, TID_MOVE_NAV ) )
+		{
+			NPC_ClearGoal();
+		}
+			NPC_BSST_Attack();
+		return;
+/*
+		//have an enemy
+		//FIXME: if one of these fails, meaning we can't shoot, do we really need to do the rest?
+		VectorSubtract( NPC->enemy->r.currentOrigin, NPC->r.currentOrigin, enemyDir );
+		enemyDist = VectorNormalize( enemyDir );
+		enemyDist *= enemyDist;
+		shootDist = NPC_MaxDistSquaredForWeapon();
+
+		enemyFOV = InFOV( NPC->enemy, NPC, NPCInfo->stats.hfov, NPCInfo->stats.vfov );
+		enemyShotFOV = InFOV( NPC->enemy, NPC, 20, 20 );
+		enemyPVS = gi.inPVS( NPC->enemy->r.currentOrigin, NPC->r.currentOrigin );
+
+		if ( enemyPVS )
+		{//in the pvs
+			trace_t	tr;
+
+			CalcEntitySpot( NPC->enemy, SPOT_HEAD, enemyHead );
+			enemyHead[2] -= Q_flrand( 0.0f, NPC->enemy->maxs[2]*0.5f );
+			CalcEntitySpot( NPC, SPOT_WEAPON, muzzle );
+			enemyLOS = NPC_ClearLOS( muzzle, enemyHead );
+
+			gi.trace ( &tr, muzzle, vec3_origin, vec3_origin, enemyHead, NPC->s.number, MASK_SHOT );
+			enemyCS = NPC_EvaluateShot( tr.entityNum, qtrue );
+		}
+		else
+		{//skip thr 2 traces since they would have to fail
+			enemyLOS = qfalse;
+			enemyCS = qfalse;
+		}
+		
+		if ( enemyCS && enemyShotFOV )
+		{//can hit enemy if we want
+			NPC->cantHitEnemyCounter = 0;
+		}
+		else
+		{//can't hit
+			NPC->cantHitEnemyCounter++;
+		}
+
+		if ( enemyCS && enemyShotFOV && enemyDist < shootDist )
+		{//can shoot
+			shoot = qtrue;
+			if ( NPCInfo->goalEntity == NPC->enemy )
+			{//my goal is my enemy and I have a clear shot, no need to chase right now
+				move = qfalse;
+			}
+		}
+		else
+		{//don't shoot yet, keep chasing
+			shoot = qfalse;
+			move = qtrue;
+		}
+
+		//shoot decision
+		if ( !(NPCInfo->scriptFlags&SCF_DONT_FIRE) )
+		{//try to shoot
+			if ( NPC->enemy )
+			{
+				if ( shoot )
+				{
+					if( !(NPCInfo->scriptFlags & SCF_FIRE_WEAPON) ) // we've already fired, no need to do it again here
+					{
+						WeaponThink( qtrue );
+					}
+				}
+			}
+		}
+
+		//chase decision
+		if ( NPCInfo->scriptFlags & SCF_CHASE_ENEMIES )
+		{//go after him
+			NPCInfo->goalEntity = NPC->enemy;
+			//FIXME: don't need to chase when have a clear shot and in range?
+			if ( !enemyCS && NPC->cantHitEnemyCounter > 60 )
+			{//haven't been able to shoot enemy for about 6 seconds, need to do something
+				//FIXME: combat points?  Just chase?
+				if ( enemyPVS )
+				{//in my PVS, just pick a combat point
+					//FIXME: implement
+				}
+				else
+				{//just chase him
+				}
+			}
+			//FIXME: in normal behavior, should we use combat Points?  Do we care?  Is anyone actually going to ever use this AI?
+		}
+		else if ( NPC->cantHitEnemyCounter > 60 )
+		{//pick a new one
+			NPC_CheckEnemy( qtrue, qfalse, qtrue );
+		}
+		
+		if ( enemyPVS && enemyLOS )//&& !enemyShotFOV )
+		{//have a clear LOS to him//, but not looking at him
+			//Find the desired angles
+			vec3_t	angles;
+
+			GetAnglesForDirection( muzzle, enemyHead, angles );
+
+			NPCInfo->desiredYaw		= AngleNormalize180( angles[YAW] );
+			NPCInfo->desiredPitch	= AngleNormalize180( angles[PITCH] );
+		}
+		*/
+	}
+
+	if ( UpdateGoal() )
+	{//have a goal
+		if ( !NPC->enemy 
+			&& NPC->client->leader 
+			&& NPCInfo->goalEntity == NPC->client->leader 
+			&& !trap_ICARUS_TaskIDPending( NPC, TID_MOVE_NAV ) )
+		{
+			NPC_BSFollowLeader();
+		}
+		else
+		{
+			//set angles
+			if ( (NPCInfo->scriptFlags & SCF_FACE_MOVE_DIR) || NPCInfo->goalEntity != NPC->enemy )
+			{//face direction of movement, NOTE: default behavior when not chasing enemy
+				NPCInfo->combatMove = qfalse;
+			}
+			else
+			{//face goal.. FIXME: what if have a navgoal but want to face enemy while moving?  Will this do that?
+				vec3_t	dir, angles;
+
+				NPCInfo->combatMove = qfalse;
+
+				VectorSubtract( NPCInfo->goalEntity->r.currentOrigin, NPC->r.currentOrigin, dir );
+				vectoangles( dir, angles );
+				NPCInfo->desiredYaw = angles[YAW];
+				if ( NPCInfo->goalEntity == NPC->enemy )
+				{
+					NPCInfo->desiredPitch = angles[PITCH];
+				}
+			}
+
+			//set movement
+			//override default walk/run behavior
+			//NOTE: redundant, done in NPC_ApplyScriptFlags
+			if ( NPCInfo->scriptFlags & SCF_RUNNING )
+			{
+				ucmd.buttons &= ~BUTTON_WALKING;
+			}
+			else if ( NPCInfo->scriptFlags & SCF_WALKING )
+			{
+				ucmd.buttons |= BUTTON_WALKING;
+			}
+			else if ( NPCInfo->goalEntity == NPC->enemy )
+			{
+				ucmd.buttons &= ~BUTTON_WALKING;
+			}
+			else
+			{
+				ucmd.buttons |= BUTTON_WALKING;
+			}
+
+			if ( NPCInfo->scriptFlags & SCF_FORCED_MARCH )
+			{//being forced to walk
+				//if ( g_crosshairEntNum != NPC->s.number )
+				if (!NPC_SomeoneLookingAtMe(NPC))
+				{//don't walk if player isn't aiming at me
+					move = qfalse;
+				}
+			}
+
+			if ( move )
+			{
+				//move toward goal
+				NPC_MoveToGoal( qtrue );
+			}
+		}
+	}
+	else if ( !NPC->enemy && NPC->client->leader )
+	{
+		NPC_BSFollowLeader();
+	}
+
+	//update angles
+	NPC_UpdateAngles( qtrue, qtrue );
+}
diff --git a/codemp/game/NPC_AI_Droid.c b/codemp/game/NPC_AI_Droid.c
new file mode 100644
index 0000000..1088daa
--- /dev/null
+++ b/codemp/game/NPC_AI_Droid.c
@@ -0,0 +1,621 @@
+#include "b_local.h"
+
+//static void R5D2_LookAround( void );
+float NPC_GetPainChance( gentity_t *self, int damage );
+extern void G_SoundOnEnt( gentity_t *ent, soundChannel_t channel, const char *soundPath );
+
+#define TURN_OFF   0x00000100
+
+//Local state enums
+enum
+{
+	LSTATE_NONE = 0,
+	LSTATE_BACKINGUP,
+	LSTATE_SPINNING,
+	LSTATE_PAIN,
+	LSTATE_DROP
+};
+
+/*
+-------------------------
+R2D2_PartsMove
+-------------------------
+*/
+void R2D2_PartsMove(void)
+{
+	// Front 'eye' lense
+	if ( TIMER_Done(NPC,"eyeDelay") )
+	{
+		NPC->pos1[1] = AngleNormalize360( NPC->pos1[1]);
+
+		NPC->pos1[0]+=Q_irand( -20, 20 );	// Roll	
+		NPC->pos1[1]=Q_irand( -20, 20 );	
+		NPC->pos1[2]=Q_irand( -20, 20 );	
+
+		/*
+		if (NPC->genericBone1)
+		{
+			gi.G2API_SetBoneAnglesIndex( &NPC->ghoul2[NPC->playerModel], NPC->genericBone1, NPC->pos1, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, NULL ); 
+		}
+		*/
+		NPC_SetBoneAngles(NPC, "f_eye", NPC->pos1);
+		
+
+		TIMER_Set( NPC, "eyeDelay", Q_irand( 100, 1000 ) );
+	}
+}
+
+/*
+-------------------------
+NPC_BSDroid_Idle
+-------------------------
+*/
+void Droid_Idle( void )
+{
+//	VectorCopy( NPCInfo->investigateGoal, lookPos );
+
+//	NPC_FacePosition( lookPos );
+}
+
+/*
+-------------------------
+R2D2_TurnAnims
+-------------------------
+*/
+void R2D2_TurnAnims ( void )
+{
+	float turndelta;
+	int		anim;
+
+	turndelta = AngleDelta(NPC->r.currentAngles[YAW], NPCInfo->desiredYaw);
+
+	if ((fabs(turndelta) > 20) && ((NPC->client->NPC_class == CLASS_R2D2) || (NPC->client->NPC_class == CLASS_R5D2)))
+	{
+		anim = NPC->client->ps.legsAnim;
+		if (turndelta<0)
+		{
+			if (anim != BOTH_TURN_LEFT1)
+			{
+				NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_TURN_LEFT1, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+			}
+		}
+		else
+		{
+			if (anim != BOTH_TURN_RIGHT1)
+			{
+				NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_TURN_RIGHT1, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+			}
+		}
+	}
+	else
+	{
+			NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_RUN1, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+	}
+
+}
+
+/*
+-------------------------
+Droid_Patrol
+-------------------------
+*/
+void Droid_Patrol( void )
+{
+
+	NPC->pos1[1] = AngleNormalize360( NPC->pos1[1]);
+
+	if ( NPC->client && NPC->client->NPC_class != CLASS_GONK )
+	{
+		if (NPC->client->NPC_class != CLASS_R5D2)
+		{ //he doesn't have an eye.
+			R2D2_PartsMove();		// Get his eye moving.
+		}
+		R2D2_TurnAnims();
+	}
+
+	//If we have somewhere to go, then do that
+	if ( UpdateGoal() )
+	{
+		ucmd.buttons |= BUTTON_WALKING;
+		NPC_MoveToGoal( qtrue );
+
+		if( NPC->client && NPC->client->NPC_class == CLASS_MOUSE )
+		{
+			NPCInfo->desiredYaw += sin(level.time*.5) * 25; // Weaves side to side a little
+
+			if (TIMER_Done(NPC,"patrolNoise"))
+			{
+				G_SoundOnEnt( NPC, CHAN_AUTO, va("sound/chars/mouse/misc/mousego%d.wav", Q_irand(1, 3)) );
+
+				TIMER_Set( NPC, "patrolNoise", Q_irand( 2000, 4000 ) );
+			}
+		}
+		else if( NPC->client && NPC->client->NPC_class == CLASS_R2D2 )
+		{
+			if (TIMER_Done(NPC,"patrolNoise"))
+			{
+				G_SoundOnEnt( NPC, CHAN_AUTO, va("sound/chars/r2d2/misc/r2d2talk0%d.wav",	Q_irand(1, 3)) );
+
+				TIMER_Set( NPC, "patrolNoise", Q_irand( 2000, 4000 ) );
+			}
+		}
+		else if( NPC->client && NPC->client->NPC_class == CLASS_R5D2 )
+		{
+			if (TIMER_Done(NPC,"patrolNoise"))
+			{
+				G_SoundOnEnt( NPC, CHAN_AUTO, va("sound/chars/r5d2/misc/r5talk%d.wav", Q_irand(1, 4)) );
+
+				TIMER_Set( NPC, "patrolNoise", Q_irand( 2000, 4000 ) );
+			}
+		}
+		if( NPC->client && NPC->client->NPC_class == CLASS_GONK )
+		{
+			if (TIMER_Done(NPC,"patrolNoise"))
+			{
+				G_SoundOnEnt( NPC, CHAN_AUTO, va("sound/chars/gonk/misc/gonktalk%d.wav", Q_irand(1, 2)) );
+
+				TIMER_Set( NPC, "patrolNoise", Q_irand( 2000, 4000 ) );
+			}
+		}
+//		else
+//		{
+//			R5D2_LookAround();
+//		}
+	}
+
+	NPC_UpdateAngles( qtrue, qtrue );
+
+}
+
+/*
+-------------------------
+Droid_Run
+-------------------------
+*/
+void Droid_Run( void )
+{
+	R2D2_PartsMove();
+
+	if ( NPCInfo->localState == LSTATE_BACKINGUP )
+	{
+		ucmd.forwardmove = -127;
+		NPCInfo->desiredYaw += 5; 
+
+		NPCInfo->localState = LSTATE_NONE;	// So he doesn't constantly backup.
+	}
+	else 
+	{
+		ucmd.forwardmove = 64;
+		//If we have somewhere to go, then do that
+		if ( UpdateGoal() )
+		{
+			if (NPC_MoveToGoal( qfalse ))
+			{
+				NPCInfo->desiredYaw += sin(level.time*.5) * 5; // Weaves side to side a little
+			}
+		}
+	}
+
+	NPC_UpdateAngles( qtrue, qtrue );
+}
+
+/*
+-------------------------
+void Droid_Spin( void )
+-------------------------
+*/
+void Droid_Spin( void )
+{
+	vec3_t dir = {0,0,1};
+
+	R2D2_TurnAnims();
+
+						
+	// Head is gone, spin and spark
+	if ( NPC->client->NPC_class == CLASS_R5D2 
+		|| NPC->client->NPC_class == CLASS_R2D2 )
+	{
+		// No head?
+		if (trap_G2API_GetSurfaceRenderStatus( NPC->ghoul2, 0, "head" )>0)
+		{
+			if (TIMER_Done(NPC,"smoke") && !TIMER_Done(NPC,"droidsmoketotal"))
+			{
+				TIMER_Set( NPC, "smoke", 100);
+				G_PlayEffectID( G_EffectIndex("volumetric/droid_smoke") , NPC->r.currentOrigin,dir);
+			}
+
+			if (TIMER_Done(NPC,"droidspark"))
+			{
+				TIMER_Set( NPC, "droidspark", Q_irand(100,500));
+				G_PlayEffectID( G_EffectIndex("sparks/spark"), NPC->r.currentOrigin,dir);
+			}
+
+			ucmd.forwardmove = Q_irand( -64, 64);
+
+			if (TIMER_Done(NPC,"roam"))
+			{	
+				TIMER_Set( NPC, "roam", Q_irand( 250, 1000 ) );
+				NPCInfo->desiredYaw = Q_irand( 0, 360 ); // Go in random directions
+			}
+		}
+		else
+		{
+			if (TIMER_Done(NPC,"roam"))
+			{
+				NPCInfo->localState = LSTATE_NONE;
+			}
+			else
+			{
+				NPCInfo->desiredYaw = AngleNormalize360(NPCInfo->desiredYaw + 40); // Spin around
+			}
+		}
+	}
+	else 
+	{
+		if (TIMER_Done(NPC,"roam"))
+		{
+			NPCInfo->localState = LSTATE_NONE;
+		}
+		else
+		{
+			NPCInfo->desiredYaw = AngleNormalize360(NPCInfo->desiredYaw + 40); // Spin around
+		}
+	}
+
+	NPC_UpdateAngles( qtrue, qtrue );
+}
+
+/*
+-------------------------
+NPC_BSDroid_Pain
+-------------------------
+*/
+void NPC_Droid_Pain(gentity_t *self, gentity_t *attacker, int damage)
+{
+	gentity_t *other = attacker;
+	int		anim;
+	int		mod = gPainMOD;
+	float	pain_chance;
+
+	VectorCopy( self->NPC->lastPathAngles, self->s.angles );
+
+	if ( self->client->NPC_class == CLASS_R5D2 )
+	{
+		pain_chance = NPC_GetPainChance( self, damage );
+
+		// Put it in pain
+		if ( mod == MOD_DEMP2 || mod == MOD_DEMP2_ALT || random() < pain_chance )	// Spin around in pain? Demp2 always does this
+		{
+			// Health is between 0-30 or was hit by a DEMP2 so pop his head
+			if ( !self->s.m_iVehicleNum
+				&& ( self->health < 30 || mod == MOD_DEMP2 || mod == MOD_DEMP2_ALT ) )
+			{
+				if (!(self->spawnflags & 2))	// Doesn't have to ALWAYSDIE
+				{
+					if ((self->NPC->localState != LSTATE_SPINNING) && 
+						(!trap_G2API_GetSurfaceRenderStatus( self->ghoul2, 0, "head" )))
+					{
+						NPC_SetSurfaceOnOff( self, "head", TURN_OFF );
+
+						if ( self->client->ps.m_iVehicleNum )
+						{
+							vec3_t	up;
+							AngleVectors( self->r.currentAngles, NULL, NULL, up );
+							G_PlayEffectID( G_EffectIndex("chunks/r5d2head_veh"), self->r.currentOrigin, up );
+						}
+						else
+						{
+							G_PlayEffectID( G_EffectIndex("small_chunks") , self->r.currentOrigin, vec3_origin );
+							G_PlayEffectID( G_EffectIndex("chunks/r5d2head"), self->r.currentOrigin, vec3_origin );
+						}
+
+						//self->s.powerups |= ( 1 << PW_SHOCKED );
+						//self->client->ps.powerups[PW_SHOCKED] = level.time + 3000;
+						self->client->ps.electrifyTime = level.time + 3000;
+
+						TIMER_Set( self, "droidsmoketotal", 5000);
+						TIMER_Set( self, "droidspark", 100);
+						self->NPC->localState = LSTATE_SPINNING;
+					}
+				}
+			}
+			// Just give him normal pain for a little while
+			else
+			{
+				anim = self->client->ps.legsAnim;
+
+				if ( anim == BOTH_STAND2 )	// On two legs?
+				{
+					anim = BOTH_PAIN1;
+				}
+				else						// On three legs
+				{
+					anim = BOTH_PAIN2;
+				}
+
+				NPC_SetAnim( self, SETANIM_BOTH, anim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+
+				// Spin around in pain
+				self->NPC->localState = LSTATE_SPINNING;
+				TIMER_Set( self, "roam", Q_irand(1000,2000));
+			} 
+		}
+	}
+	else if (self->client->NPC_class == CLASS_MOUSE)
+	{
+		if ( mod == MOD_DEMP2 || mod == MOD_DEMP2_ALT )
+		{
+			self->NPC->localState = LSTATE_SPINNING;
+			//self->s.powerups |= ( 1 << PW_SHOCKED );
+			//self->client->ps.powerups[PW_SHOCKED] = level.time + 3000;
+			self->client->ps.electrifyTime = level.time + 3000;
+		}
+		else
+		{
+			self->NPC->localState = LSTATE_BACKINGUP;
+		}
+
+		self->NPC->scriptFlags &= ~SCF_LOOK_FOR_ENEMIES;
+	}
+	else if ((self->client->NPC_class == CLASS_R2D2))
+	{
+
+		pain_chance = NPC_GetPainChance( self, damage );
+
+		if ( mod == MOD_DEMP2 || mod == MOD_DEMP2_ALT || random() < pain_chance )	// Spin around in pain? Demp2 always does this
+		{
+			// Health is between 0-30 or was hit by a DEMP2 so pop his head
+			if ( !self->s.m_iVehicleNum
+				&& ( self->health < 30 || mod == MOD_DEMP2 || mod == MOD_DEMP2_ALT ) )
+			{
+				if (!(self->spawnflags & 2))	// Doesn't have to ALWAYSDIE
+				{
+					if ((self->NPC->localState != LSTATE_SPINNING) && 
+						(!trap_G2API_GetSurfaceRenderStatus( self->ghoul2, 0, "head" )))
+					{
+						NPC_SetSurfaceOnOff( self, "head", TURN_OFF );
+
+						if ( self->client->ps.m_iVehicleNum )
+						{
+							vec3_t	up;
+							AngleVectors( self->r.currentAngles, NULL, NULL, up );
+							G_PlayEffectID( G_EffectIndex("chunks/r2d2head_veh"), self->r.currentOrigin, up );
+						}
+						else
+						{
+							G_PlayEffectID( G_EffectIndex("small_chunks") , self->r.currentOrigin, vec3_origin );
+							G_PlayEffectID( G_EffectIndex("chunks/r2d2head"), self->r.currentOrigin, vec3_origin );
+						}
+
+						//self->s.powerups |= ( 1 << PW_SHOCKED );
+						//self->client->ps.powerups[PW_SHOCKED] = level.time + 3000;
+						self->client->ps.electrifyTime = level.time + 3000;
+
+						TIMER_Set( self, "droidsmoketotal", 5000);
+						TIMER_Set( self, "droidspark", 100);
+						self->NPC->localState = LSTATE_SPINNING;
+					}
+				}
+			}
+			// Just give him normal pain for a little while
+			else
+			{
+				anim = self->client->ps.legsAnim;
+
+				if ( anim == BOTH_STAND2 )	// On two legs?
+				{
+					anim = BOTH_PAIN1;
+				}
+				else						// On three legs
+				{
+					anim = BOTH_PAIN2;
+				}
+
+				NPC_SetAnim( self, SETANIM_BOTH, anim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+
+				// Spin around in pain
+				self->NPC->localState = LSTATE_SPINNING;
+				TIMER_Set( self, "roam", Q_irand(1000,2000));
+			}
+		} 
+	}
+	else if ( self->client->NPC_class == CLASS_INTERROGATOR && ( mod == MOD_DEMP2 || mod == MOD_DEMP2_ALT ) && other )
+	{
+		vec3_t dir;
+
+		VectorSubtract( self->r.currentOrigin, other->r.currentOrigin, dir );
+		VectorNormalize( dir );
+
+		VectorMA( self->client->ps.velocity, 550, dir, self->client->ps.velocity );
+		self->client->ps.velocity[2] -= 127;
+	}
+
+	NPC_Pain( self, attacker, damage);
+}
+
+
+/*
+-------------------------
+Droid_Pain
+-------------------------
+*/
+void Droid_Pain(void)
+{
+	if (TIMER_Done(NPC,"droidpain"))	//He's done jumping around
+	{
+		NPCInfo->localState = LSTATE_NONE;
+	}
+}
+
+/*
+-------------------------
+NPC_Mouse_Precache
+-------------------------
+*/
+void NPC_Mouse_Precache( void )
+{
+	int	i;
+
+	for (i = 1; i < 4; i++)
+	{
+		G_SoundIndex( va( "sound/chars/mouse/misc/mousego%d.wav", i ) );
+	}
+
+	G_EffectIndex( "env/small_explode" );
+	G_SoundIndex( "sound/chars/mouse/misc/death1" );
+	G_SoundIndex( "sound/chars/mouse/misc/mouse_lp" );
+}
+
+/*
+-------------------------
+NPC_R5D2_Precache
+-------------------------
+*/
+void NPC_R5D2_Precache(void)
+{
+	int i;
+
+	for ( i = 1; i < 5; i++)
+	{
+		G_SoundIndex( va( "sound/chars/r5d2/misc/r5talk%d.wav", i ) );
+	}
+	//G_SoundIndex( "sound/chars/r5d2/misc/falling1.wav" );
+	G_SoundIndex( "sound/chars/mark2/misc/mark2_explo" ); // ??
+	G_SoundIndex( "sound/chars/r2d2/misc/r2_move_lp2.wav" );
+	G_EffectIndex( "env/med_explode");
+	G_EffectIndex( "volumetric/droid_smoke" );
+	G_EffectIndex("sparks/spark");
+	G_EffectIndex( "chunks/r5d2head");
+	G_EffectIndex( "chunks/r5d2head_veh");
+}
+
+/*
+-------------------------
+NPC_R2D2_Precache
+-------------------------
+*/
+void NPC_R2D2_Precache(void)
+{
+	int i;
+
+	for ( i = 1; i < 4; i++)
+	{
+		G_SoundIndex( va( "sound/chars/r2d2/misc/r2d2talk0%d.wav", i ) );
+	}
+	//G_SoundIndex( "sound/chars/r2d2/misc/falling1.wav" );
+	G_SoundIndex( "sound/chars/mark2/misc/mark2_explo" ); // ??
+	G_SoundIndex( "sound/chars/r2d2/misc/r2_move_lp.wav" );
+	G_EffectIndex( "env/med_explode");
+	G_EffectIndex( "volumetric/droid_smoke" );
+	G_EffectIndex("sparks/spark");
+	G_EffectIndex( "chunks/r2d2head");
+	G_EffectIndex( "chunks/r2d2head_veh");
+}
+
+/*
+-------------------------
+NPC_Gonk_Precache
+-------------------------
+*/
+void NPC_Gonk_Precache( void )
+{
+	G_SoundIndex("sound/chars/gonk/misc/gonktalk1.wav");
+	G_SoundIndex("sound/chars/gonk/misc/gonktalk2.wav");
+
+	G_SoundIndex("sound/chars/gonk/misc/death1.wav");
+	G_SoundIndex("sound/chars/gonk/misc/death2.wav");
+	G_SoundIndex("sound/chars/gonk/misc/death3.wav");
+
+	G_EffectIndex( "env/med_explode");
+}
+
+/*
+-------------------------
+NPC_Protocol_Precache
+-------------------------
+*/
+void NPC_Protocol_Precache( void )
+{
+	G_SoundIndex( "sound/chars/mark2/misc/mark2_explo" );
+	G_EffectIndex( "env/med_explode");
+}
+
+/*
+static void R5D2_OffsetLook( float offset, vec3_t out )
+{
+	vec3_t	angles, forward, temp;
+
+	GetAnglesForDirection( NPC->r.currentOrigin, NPCInfo->investigateGoal, angles );
+	angles[YAW] += offset;
+	AngleVectors( angles, forward, NULL, NULL );
+	VectorMA( NPC->r.currentOrigin, 64, forward, out );
+	
+	CalcEntitySpot( NPC, SPOT_HEAD, temp );
+	out[2] = temp[2];
+}
+*/
+
+/*
+-------------------------
+R5D2_LookAround
+-------------------------
+*/
+/*
+static void R5D2_LookAround( void )
+{
+	vec3_t	lookPos;
+	float	perc = (float) ( level.time - NPCInfo->pauseTime ) / (float) NPCInfo->investigateDebounceTime;
+
+	//Keep looking at the spot
+	if ( perc < 0.25 )
+	{
+		VectorCopy( NPCInfo->investigateGoal, lookPos );
+	}
+	else if ( perc < 0.5f )		//Look up but straight ahead
+	{
+		R5D2_OffsetLook( 0.0f, lookPos );
+	}
+	else if ( perc < 0.75f )	//Look right
+	{
+		R5D2_OffsetLook( 45.0f, lookPos );
+	}
+	else	//Look left
+	{
+		R5D2_OffsetLook( -45.0f, lookPos );
+	}
+
+	NPC_FacePosition( lookPos );
+}
+
+*/
+
+/*
+-------------------------
+NPC_BSDroid_Default
+-------------------------
+*/
+void NPC_BSDroid_Default( void )
+{
+
+	if ( NPCInfo->localState == LSTATE_SPINNING )
+	{
+		Droid_Spin();
+	}
+	else if ( NPCInfo->localState == LSTATE_PAIN )
+	{
+		Droid_Pain();
+	}
+	else if ( NPCInfo->localState == LSTATE_DROP )
+	{
+		NPC_UpdateAngles( qtrue, qtrue );
+		ucmd.upmove = crandom() * 64;
+	}
+	else if ( NPCInfo->scriptFlags & SCF_LOOK_FOR_ENEMIES )
+	{
+		Droid_Patrol();
+	}
+	else
+	{
+		Droid_Run();
+	}
+}
diff --git a/codemp/game/NPC_AI_GalakMech.c b/codemp/game/NPC_AI_GalakMech.c
new file mode 100644
index 0000000..14b66f1
--- /dev/null
+++ b/codemp/game/NPC_AI_GalakMech.c
@@ -0,0 +1,1297 @@
+#include "b_local.h"
+#include "g_nav.h"
+#include "anims.h"
+#include "w_saber.h"
+
+extern void G_AddVoiceEvent( gentity_t *self, int event, int speakDebounceTime );
+extern void NPC_AimAdjust( int change );
+extern qboolean WP_LobFire( gentity_t *self, vec3_t start, vec3_t target, vec3_t mins, vec3_t maxs, int clipmask, 
+				vec3_t velocity, qboolean tracePath, int ignoreEntNum, int enemyNum,
+				float minSpeed, float maxSpeed, float idealSpeed, qboolean mustHit );
+extern void G_SoundOnEnt (gentity_t *ent, soundChannel_t channel, const char *soundPath);
+
+#include "../namespace_begin.h"
+extern qboolean BG_CrouchAnim( int anim );
+#include "../namespace_end.h"
+
+//extern void NPC_Mark1_Part_Explode(gentity_t *self,int bolt);
+
+#define MELEE_DIST_SQUARED 6400//80*80
+#define MIN_LOB_DIST_SQUARED 65536//256*256
+#define MAX_LOB_DIST_SQUARED 200704//448*448
+#define REPEATER_ALT_SIZE				3	// half of bbox size
+#define	GENERATOR_HEALTH	25
+#define TURN_ON				0x00000000
+#define TURN_OFF			0x00000100
+#define GALAK_SHIELD_HEALTH	500
+
+static vec3_t shieldMins = {-60, -60, -24 };
+static vec3_t shieldMaxs = {60, 60, 80};
+
+extern qboolean NPC_CheckPlayerTeamStealth( void );
+
+static qboolean enemyLOS4;
+static qboolean enemyCS4;
+static qboolean hitAlly4;
+static qboolean faceEnemy4;
+static qboolean move4;
+static qboolean shoot4;
+static float	enemyDist4;
+static vec3_t	impactPos4;
+
+void NPC_GalakMech_Precache( void )
+{
+	G_SoundIndex( "sound/weapons/galak/skewerhit.wav" );
+	G_SoundIndex( "sound/weapons/galak/lasercharge.wav" );
+	G_SoundIndex( "sound/weapons/galak/lasercutting.wav" );
+	G_SoundIndex( "sound/weapons/galak/laserdamage.wav" );
+
+	G_EffectIndex( "galak/trace_beam" );
+	G_EffectIndex( "galak/beam_warmup" );
+//	G_EffectIndex( "small_chunks");
+	G_EffectIndex( "env/med_explode2");
+	G_EffectIndex( "env/small_explode2");
+	G_EffectIndex( "galak/explode");
+	G_EffectIndex( "blaster/smoke_bolton");
+//	G_EffectIndex( "env/exp_trail_comp");
+}
+
+void NPC_GalakMech_Init( gentity_t *ent )
+{
+	if (ent->NPC->behaviorState != BS_CINEMATIC)
+	{
+		ent->client->ps.stats[STAT_ARMOR] = GALAK_SHIELD_HEALTH;
+		ent->NPC->investigateCount = ent->NPC->investigateDebounceTime = 0;
+		ent->flags |= FL_SHIELDED;//reflect normal shots
+		//rwwFIXMEFIXME: Support PW_GALAK_SHIELD
+		//ent->client->ps.powerups[PW_GALAK_SHIELD] = Q3_INFINITE;//temp, for effect
+		//ent->fx_time = level.time;
+		VectorSet( ent->r.mins, -60, -60, -24 );
+		VectorSet( ent->r.maxs, 60, 60, 80 );
+		ent->flags |= FL_NO_KNOCKBACK;//don't get pushed
+		TIMER_Set( ent, "attackDelay", 0 );	//FIXME: Slant for difficulty levels
+		TIMER_Set( ent, "flee", 0 );
+		TIMER_Set( ent, "smackTime", 0 );
+		TIMER_Set( ent, "beamDelay", 0 );
+		TIMER_Set( ent, "noLob", 0 );
+		TIMER_Set( ent, "noRapid", 0 );
+		TIMER_Set( ent, "talkDebounce", 0 );
+
+		NPC_SetSurfaceOnOff( ent, "torso_shield", TURN_ON );
+		NPC_SetSurfaceOnOff( ent, "torso_galakface", TURN_OFF );
+		NPC_SetSurfaceOnOff( ent, "torso_galakhead", TURN_OFF );
+		NPC_SetSurfaceOnOff( ent, "torso_eyes_mouth", TURN_OFF );
+		NPC_SetSurfaceOnOff( ent, "torso_collar", TURN_OFF );
+		NPC_SetSurfaceOnOff( ent, "torso_galaktorso", TURN_OFF );
+	}
+	else
+	{
+//		NPC_SetSurfaceOnOff( ent, "helmet", TURN_OFF );
+		NPC_SetSurfaceOnOff( ent, "torso_shield", TURN_OFF );
+		NPC_SetSurfaceOnOff( ent, "torso_galakface", TURN_ON );
+		NPC_SetSurfaceOnOff( ent, "torso_galakhead", TURN_ON );
+		NPC_SetSurfaceOnOff( ent, "torso_eyes_mouth", TURN_ON );
+		NPC_SetSurfaceOnOff( ent, "torso_collar", TURN_ON );
+		NPC_SetSurfaceOnOff( ent, "torso_galaktorso", TURN_ON );
+	}
+
+}
+
+//-----------------------------------------------------------------
+static void GM_CreateExplosion( gentity_t *self, const int boltID, qboolean doSmall ) //doSmall = qfalse
+{
+	if ( boltID >=0 )
+	{
+		mdxaBone_t	boltMatrix;
+		vec3_t		org, dir;
+
+		trap_G2API_GetBoltMatrix( self->ghoul2, 0, 
+					boltID,
+					&boltMatrix, self->r.currentAngles, self->r.currentOrigin, level.time,
+					NULL, self->modelScale );
+
+		BG_GiveMeVectorFromMatrix( &boltMatrix, ORIGIN, org );
+		BG_GiveMeVectorFromMatrix( &boltMatrix, NEGATIVE_Y, dir );
+
+		if ( doSmall )
+		{
+			G_PlayEffectID( G_EffectIndex("env/small_explode2"), org, dir );
+		}
+		else
+		{
+			G_PlayEffectID( G_EffectIndex("env/med_explode2"), org, dir );
+		}
+	}
+}
+
+/*
+-------------------------
+GM_Dying
+-------------------------
+*/
+
+void GM_Dying( gentity_t *self )
+{
+	if ( level.time - self->s.time < 4000 )
+	{//FIXME: need a real effect
+		//self->s.powerups |= ( 1 << PW_SHOCKED );
+		//self->client->ps.powerups[PW_SHOCKED] = level.time + 1000;
+		self->client->ps.electrifyTime = level.time + 1000;
+		if ( TIMER_Done( self, "dyingExplosion" ) )
+		{
+			int	newBolt;
+			switch ( Q_irand( 1, 14 ) )
+			{
+			// Find place to generate explosion
+			case 1:
+				if (!trap_G2API_GetSurfaceRenderStatus( self->ghoul2, 0, "r_hand" ))
+				{//r_hand still there
+					GM_CreateExplosion( self, trap_G2API_AddBolt(self->ghoul2, 0, "*flasha"), qtrue );
+					NPC_SetSurfaceOnOff( self, "r_hand", TURN_OFF );
+				}
+				else if (!trap_G2API_GetSurfaceRenderStatus( self->ghoul2, 0, "r_arm_middle" ))
+				{//r_arm_middle still there
+					newBolt = trap_G2API_AddBolt( self->ghoul2, 0, "*r_arm_elbow" );
+					NPC_SetSurfaceOnOff( self, "r_arm_middle", TURN_OFF );
+				}
+				break;
+			case 2:
+				//FIXME: do only once?
+				if (!trap_G2API_GetSurfaceRenderStatus( self->ghoul2, 0, "l_hand" ))
+				{//l_hand still there
+					GM_CreateExplosion( self, trap_G2API_AddBolt(self->ghoul2, 0, "*flashc"), qfalse );
+					NPC_SetSurfaceOnOff( self, "l_hand", TURN_OFF );
+				}
+				else if (!trap_G2API_GetSurfaceRenderStatus( self->ghoul2, 0, "l_arm_wrist" ))
+				{//l_arm_wrist still there
+					newBolt = trap_G2API_AddBolt( self->ghoul2, 0, "*l_arm_cap_l_hand" );
+					NPC_SetSurfaceOnOff( self, "l_arm_wrist", TURN_OFF );
+				}
+				else if (!trap_G2API_GetSurfaceRenderStatus( self->ghoul2, 0, "l_arm_middle" ))
+				{//l_arm_middle still there
+					newBolt = trap_G2API_AddBolt( self->ghoul2, 0, "*l_arm_cap_l_hand" );
+					NPC_SetSurfaceOnOff( self, "l_arm_middle", TURN_OFF );
+				}
+				else if (!trap_G2API_GetSurfaceRenderStatus( self->ghoul2, 0, "l_arm_augment" ))
+				{//l_arm_augment still there
+					newBolt = trap_G2API_AddBolt( self->ghoul2, 0, "*l_arm_elbow" );
+					NPC_SetSurfaceOnOff( self, "l_arm_augment", TURN_OFF );
+				}
+				break;
+			case 3:
+			case 4:
+				newBolt = trap_G2API_AddBolt( self->ghoul2, 0, "*hip_fr" );
+				GM_CreateExplosion( self, newBolt, qfalse );
+				break;
+			case 5:
+			case 6:
+				newBolt = trap_G2API_AddBolt( self->ghoul2, 0, "*shldr_l" );
+				GM_CreateExplosion( self, newBolt, qfalse );
+				break;
+			case 7:
+			case 8:
+				newBolt = trap_G2API_AddBolt( self->ghoul2, 0, "*uchest_r" );
+				GM_CreateExplosion( self, newBolt, qfalse );
+				break;
+			case 9:
+			case 10:
+				GM_CreateExplosion( self, self->client->renderInfo.headBolt, qfalse );
+				break;
+			case 11:
+				newBolt = trap_G2API_AddBolt( self->ghoul2, 0, "*l_leg_knee" );
+				GM_CreateExplosion( self, newBolt, qtrue );
+				break;
+			case 12:
+				newBolt = trap_G2API_AddBolt( self->ghoul2, 0, "*r_leg_knee" );
+				GM_CreateExplosion( self, newBolt, qtrue );
+				break;
+			case 13:
+				newBolt = trap_G2API_AddBolt( self->ghoul2, 0, "*l_leg_foot" );
+				GM_CreateExplosion( self, newBolt, qtrue );
+				break;
+			case 14:
+				newBolt = trap_G2API_AddBolt( self->ghoul2, 0, "*r_leg_foot" );
+				GM_CreateExplosion( self, newBolt, qtrue );
+				break;
+			}
+
+			TIMER_Set( self, "dyingExplosion", Q_irand( 300, 1100 ) );
+		}
+	}
+	else
+	{//one final, huge explosion
+		G_PlayEffectID( G_EffectIndex("galak/explode"), self->r.currentOrigin, vec3_origin );
+//		G_PlayEffect( "small_chunks", self->r.currentOrigin );
+//		G_PlayEffect( "env/exp_trail_comp", self->r.currentOrigin, self->currentAngles );
+		self->nextthink = level.time + FRAMETIME;
+		self->think = G_FreeEntity;
+	}
+}
+
+/*
+-------------------------
+NPC_GM_Pain
+-------------------------
+*/
+
+extern void NPC_SetPainEvent( gentity_t *self );
+void NPC_GM_Pain(gentity_t *self, gentity_t *attacker, int damage)
+{
+	vec3_t point;
+	gentity_t *inflictor = attacker;
+	int hitLoc = 1;
+	int mod = gPainMOD;
+
+	VectorCopy(gPainPoint, point);
+
+	//if ( self->client->ps.powerups[PW_GALAK_SHIELD] == 0 )
+	if (0) //rwwFIXMEFIXME: do all of this
+	{//shield is currently down
+		//FIXME: allow for radius damage?
+		/*
+		if ( (hitLoc==HL_GENERIC1) && (self->locationDamage[HL_GENERIC1] > GENERATOR_HEALTH) )
+		{
+			int newBolt = gi.G2API_AddBolt( &self->ghoul2[self->playerModel], "*antenna_base" );
+			if ( newBolt != -1 )
+			{
+				GM_CreateExplosion( self, newBolt, qfalse );
+			}
+
+			NPC_SetSurfaceOnOff( self, "torso_shield", TURN_OFF );
+			NPC_SetSurfaceOnOff( self, "torso_antenna", TURN_OFF );
+			NPC_SetSurfaceOnOff( self, "torso_antenna_base_cap", TURN_ON );
+			self->client->ps.powerups[PW_GALAK_SHIELD] = 0;//temp, for effect
+			self->client->ps.stats[STAT_ARMOR] = 0;//no more armor
+			self->NPC->investigateDebounceTime = 0;//stop recharging
+
+			NPC_SetAnim( self, SETANIM_BOTH, BOTH_ALERT1, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+			TIMER_Set( self, "attackDelay", self->client->ps.torsoTimer );
+			G_AddEvent( self, Q_irand( EV_DEATH1, EV_DEATH3 ), self->health );
+		}
+		*/
+	}
+	else
+	{//store the point for shield impact
+		if ( point )
+		{
+		//	VectorCopy( point, self->pos4 );
+		//	self->client->poisonTime = level.time;
+			//rwwFIXMEFIXME: ..do this is as well.
+		}
+	}
+
+	if ( !self->lockCount && self->client->ps.torsoTimer <= 0 )
+	{//don't interrupt laser sweep attack or other special attacks/moves
+		if ( self->count < 4 && self->health > 100 && hitLoc != HL_GENERIC1 )
+		{
+			if ( self->delay < level.time )
+			{
+				int speech;
+				switch( self->count )
+				{
+				default:
+				case 0:
+					speech = EV_PUSHED1;
+					break;
+				case 1:
+					speech = EV_PUSHED2;
+					break;
+				case 2:
+					speech = EV_PUSHED3;
+					break;
+				case 3:
+					speech = EV_DETECTED1;
+					break;
+				}
+				self->count++;
+				self->NPC->blockedSpeechDebounceTime = 0;
+				G_AddVoiceEvent( self, speech, Q_irand( 3000, 5000 ) );
+				self->delay = level.time + Q_irand( 5000, 7000 );
+			}
+		}
+		else
+		{
+			NPC_Pain(self, attacker, damage);
+		}
+	}
+	else if ( hitLoc == HL_GENERIC1 )
+	{
+		NPC_SetPainEvent( self );
+		//self->s.powerups |= ( 1 << PW_SHOCKED );
+		//self->client->ps.powerups[PW_SHOCKED] = level.time + Q_irand( 500, 2500 );
+		self->client->ps.electrifyTime = level.time + Q_irand(500, 2500);
+	}
+
+	if ( inflictor && inflictor->lastEnemy == self )
+	{//He force-pushed my own lobfires back at me
+		if ( mod == MOD_REPEATER_ALT && !Q_irand( 0, 2 ) )
+		{
+			if ( TIMER_Done( self, "noRapid" ) )
+			{
+				self->NPC->scriptFlags &= ~SCF_ALT_FIRE;
+				self->alt_fire = qfalse;
+				TIMER_Set( self, "noLob", Q_irand( 2000, 6000 ) );
+			}
+			else
+			{//hopefully this will make us fire the laser
+				TIMER_Set( self, "noLob", Q_irand( 1000, 2000 ) );
+			}
+		}
+		else if ( mod == MOD_REPEATER && !Q_irand( 0, 5 ) )
+		{
+			if ( TIMER_Done( self, "noLob" ) )
+			{
+				self->NPC->scriptFlags |= SCF_ALT_FIRE;
+				self->alt_fire = qtrue;
+				TIMER_Set( self, "noRapid", Q_irand( 2000, 6000 ) );
+			}
+			else
+			{//hopefully this will make us fire the laser
+				TIMER_Set( self, "noRapid", Q_irand( 1000, 2000 ) );
+			}
+		}
+	}
+}
+
+/*
+-------------------------
+GM_HoldPosition
+-------------------------
+*/
+
+static void GM_HoldPosition( void )
+{
+	NPC_FreeCombatPoint( NPCInfo->combatPoint, qtrue );
+	if ( !trap_ICARUS_TaskIDPending( NPC, TID_MOVE_NAV ) )
+	{//don't have a script waiting for me to get to my point, okay to stop trying and stand
+		NPCInfo->goalEntity = NULL;
+	}
+}
+
+/*
+-------------------------
+GM_Move
+-------------------------
+*/
+static qboolean GM_Move( void )
+{
+	qboolean moved;
+	navInfo_t info;
+
+	NPCInfo->combatMove = qtrue;//always move straight toward our goal
+
+	moved = NPC_MoveToGoal( qtrue );
+	
+	//Get the move info
+	NAV_GetLastMove( &info );
+
+	//FIXME: if we bump into another one of our guys and can't get around him, just stop!
+	//If we hit our target, then stop and fire!
+	if ( info.flags & NIF_COLLISION ) 
+	{
+		if ( info.blocker == NPC->enemy )
+		{
+			GM_HoldPosition();
+		}
+	}
+
+	//If our move failed, then reset
+	if ( moved == qfalse )
+	{//FIXME: if we're going to a combat point, need to pick a different one
+		if ( !trap_ICARUS_TaskIDPending( NPC, TID_MOVE_NAV ) )
+		{//can't transfer movegoal or stop when a script we're running is waiting to complete
+			GM_HoldPosition();
+		}
+	}
+
+	return moved;
+}
+
+/*
+-------------------------
+NPC_BSGM_Patrol
+-------------------------
+*/
+
+void NPC_BSGM_Patrol( void )
+{
+	if ( NPC_CheckPlayerTeamStealth() )
+	{
+		NPC_UpdateAngles( qtrue, qtrue );
+		return;
+	}
+
+	//If we have somewhere to go, then do that
+	if ( UpdateGoal() )
+	{
+		ucmd.buttons |= BUTTON_WALKING;
+		NPC_MoveToGoal( qtrue );
+	}
+
+	NPC_UpdateAngles( qtrue, qtrue );
+}
+
+/*
+-------------------------
+GM_CheckMoveState
+-------------------------
+*/
+
+static void GM_CheckMoveState( void )
+{
+	if ( trap_ICARUS_TaskIDPending( NPC, TID_MOVE_NAV ) )
+	{//moving toward a goal that a script is waiting on, so don't stop for anything!
+		move4 = qtrue;
+	}
+
+	//See if we're moving towards a goal, not the enemy
+	if ( ( NPCInfo->goalEntity != NPC->enemy ) && ( NPCInfo->goalEntity != NULL ) )
+	{
+		//Did we make it?
+		if ( NAV_HitNavGoal( NPC->r.currentOrigin, NPC->r.mins, NPC->r.maxs, NPCInfo->goalEntity->r.currentOrigin, 16, qfalse ) || 
+			( !trap_ICARUS_TaskIDPending( NPC, TID_MOVE_NAV ) && enemyLOS4 && enemyDist4 <= 10000 ) )
+		{//either hit our navgoal or our navgoal was not a crucial (scripted) one (maybe a combat point) and we're scouting and found our enemy
+			NPC_ReachedGoal();
+			//don't attack right away
+			TIMER_Set( NPC, "attackDelay", Q_irand( 250, 500 ) );	//FIXME: Slant for difficulty levels
+			return;
+		}
+	}
+}
+
+/*
+-------------------------
+GM_CheckFireState
+-------------------------
+*/
+
+static void GM_CheckFireState( void )
+{
+	if ( enemyCS4 )
+	{//if have a clear shot, always try
+		return;
+	}
+
+	if ( !VectorCompare( NPC->client->ps.velocity, vec3_origin ) )
+	{//if moving at all, don't do this
+		return;
+	}
+
+	//See if we should continue to fire on their last position
+	if ( !hitAlly4 && NPCInfo->enemyLastSeenTime > 0 )
+	{
+		if ( level.time - NPCInfo->enemyLastSeenTime < 10000 )
+		{
+			if ( !Q_irand( 0, 10 ) )
+			{
+				//Fire on the last known position
+				vec3_t	muzzle, dir, angles;
+				qboolean tooClose = qfalse;
+				qboolean tooFar = qfalse;
+				float distThreshold;
+				float dist;
+
+				CalcEntitySpot( NPC, SPOT_HEAD, muzzle );
+				if ( VectorCompare( impactPos4, vec3_origin ) )
+				{//never checked ShotEntity this frame, so must do a trace...
+					trace_t tr;
+					//vec3_t	mins = {-2,-2,-2}, maxs = {2,2,2};
+					vec3_t	forward, end;
+					AngleVectors( NPC->client->ps.viewangles, forward, NULL, NULL );
+					VectorMA( muzzle, 8192, forward, end );
+					trap_Trace( &tr, muzzle, vec3_origin, vec3_origin, end, NPC->s.number, MASK_SHOT );
+					VectorCopy( tr.endpos, impactPos4 );
+				}
+
+				//see if impact would be too close to me
+				distThreshold = 16384/*128*128*/;//default
+				if ( NPC->s.weapon == WP_REPEATER )
+				{
+					if ( NPCInfo->scriptFlags&SCF_ALT_FIRE )
+					{
+						distThreshold = 65536/*256*256*/;
+					}
+				}
+
+				dist = DistanceSquared( impactPos4, muzzle );
+
+				if ( dist < distThreshold )
+				{//impact would be too close to me
+					tooClose = qtrue;
+				}
+				else if ( level.time - NPCInfo->enemyLastSeenTime > 5000 )
+				{//we've haven't seen them in the last 5 seconds
+					//see if it's too far from where he is
+					distThreshold = 65536/*256*256*/;//default
+					if ( NPC->s.weapon == WP_REPEATER )
+					{
+						if ( NPCInfo->scriptFlags&SCF_ALT_FIRE )
+						{
+							distThreshold = 262144/*512*512*/;
+						}
+					}
+					dist = DistanceSquared( impactPos4, NPCInfo->enemyLastSeenLocation );
+					if ( dist > distThreshold )
+					{//impact would be too far from enemy
+						tooFar = qtrue;
+					}
+				}
+
+				if ( !tooClose && !tooFar )
+				{//okay too shoot at last pos
+					VectorSubtract( NPCInfo->enemyLastSeenLocation, muzzle, dir );
+					VectorNormalize( dir );
+					vectoangles( dir, angles );
+
+					NPCInfo->desiredYaw		= angles[YAW];
+					NPCInfo->desiredPitch	= angles[PITCH];
+
+					shoot4 = qtrue;
+					faceEnemy4 = qfalse;
+					return;
+				}
+			}
+		}
+	}
+}
+
+void NPC_GM_StartLaser( void )
+{
+	if ( !NPC->lockCount )
+	{//haven't already started a laser attack
+		//warm up for the beam attack
+#if 0
+		NPC_SetAnim( NPC, SETANIM_TORSO, TORSO_RAISEWEAP2, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+#endif
+		TIMER_Set( NPC, "beamDelay", NPC->client->ps.torsoTimer );
+		TIMER_Set( NPC, "attackDelay", NPC->client->ps.torsoTimer+3000 );
+		NPC->lockCount = 1;
+		//turn on warmup effect
+		G_PlayEffectID( G_EffectIndex("galak/beam_warmup"), NPC->r.currentOrigin, vec3_origin );
+		G_SoundOnEnt( NPC, CHAN_AUTO, "sound/weapons/galak/lasercharge.wav" );
+	}
+}
+
+void GM_StartGloat( void )
+{
+	NPC->wait = 0;
+	NPC_SetSurfaceOnOff( NPC, "torso_galakface", TURN_ON );
+	NPC_SetSurfaceOnOff( NPC, "torso_galakhead", TURN_ON );
+	NPC_SetSurfaceOnOff( NPC, "torso_eyes_mouth", TURN_ON );
+	NPC_SetSurfaceOnOff( NPC, "torso_collar", TURN_ON );
+	NPC_SetSurfaceOnOff( NPC, "torso_galaktorso", TURN_ON );
+
+	NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_STAND2TO1, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+	NPC->client->ps.legsTimer += 500;
+	NPC->client->ps.torsoTimer += 500;
+}
+/*
+-------------------------
+NPC_BSGM_Attack
+-------------------------
+*/
+
+void NPC_BSGM_Attack( void )
+{
+	//Don't do anything if we're hurt
+	if ( NPC->painDebounceTime > level.time )
+	{
+		NPC_UpdateAngles( qtrue, qtrue );
+		return;
+	}
+
+#if 0
+	//FIXME: if killed enemy, use victory anim
+	if ( NPC->enemy && NPC->enemy->health <= 0 
+		&& !NPC->enemy->s.number )
+	{//my enemy is dead
+		if ( NPC->client->ps.torsoAnim == BOTH_STAND2TO1 )
+		{
+			if ( NPC->client->ps.torsoTimer <= 500 )
+			{
+				G_AddVoiceEvent( NPC, Q_irand( EV_VICTORY1, EV_VICTORY3 ), 3000 );
+				NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_TRIUMPHANT1START, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+				NPC->client->ps.legsTimer += 500;
+				NPC->client->ps.torsoTimer += 500;
+			}
+		}
+		else if ( NPC->client->ps.torsoAnim == BOTH_TRIUMPHANT1START )
+		{
+			if ( NPC->client->ps.torsoTimer <= 500 )
+			{
+				NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_TRIUMPHANT1STARTGESTURE, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+				NPC->client->ps.legsTimer += 500;
+				NPC->client->ps.torsoTimer += 500;
+			}
+		}
+		else if ( NPC->client->ps.torsoAnim == BOTH_TRIUMPHANT1STARTGESTURE )
+		{
+			if ( NPC->client->ps.torsoTimer <= 500 )
+			{
+				NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_TRIUMPHANT1STOP, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+				NPC->client->ps.legsTimer += 500;
+				NPC->client->ps.torsoTimer += 500;
+			}
+		}
+		else if ( NPC->client->ps.torsoAnim == BOTH_TRIUMPHANT1STOP )
+		{
+			if ( NPC->client->ps.torsoTimer <= 500 )
+			{
+				NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_STAND1, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+				NPC->client->ps.legsTimer = -1;
+				NPC->client->ps.torsoTimer = -1;
+			}
+		}
+		else if ( NPC->wait )
+		{
+			if ( TIMER_Done( NPC, "gloatTime" ) )
+			{
+				GM_StartGloat();
+			}
+			else if ( DistanceHorizontalSquared( NPC->client->renderInfo.eyePoint, NPC->enemy->r.currentOrigin ) > 4096 && (NPCInfo->scriptFlags&SCF_CHASE_ENEMIES) )//64 squared
+			{
+				NPCInfo->goalEntity = NPC->enemy;
+				GM_Move();
+			}
+			else
+			{//got there
+				GM_StartGloat();
+			}
+		}
+		NPC_FaceEnemy( qtrue );
+		NPC_UpdateAngles( qtrue, qtrue );
+		return;
+	}
+#endif
+
+	//If we don't have an enemy, just idle
+	if ( NPC_CheckEnemyExt(qfalse) == qfalse || !NPC->enemy )
+	{
+		NPC->enemy = NULL;
+		NPC_BSGM_Patrol();
+		return;
+	}
+
+	enemyLOS4 = enemyCS4 = qfalse;
+	move4 = qtrue;
+	faceEnemy4 = qfalse;
+	shoot4 = qfalse;
+	hitAlly4 = qfalse;
+	VectorClear( impactPos4 );
+	enemyDist4 = DistanceSquared( NPC->r.currentOrigin, NPC->enemy->r.currentOrigin );
+
+	//if ( NPC->client->ps.torsoAnim == BOTH_ATTACK4 ||
+	//	NPC->client->ps.torsoAnim == BOTH_ATTACK5 )
+	if (0)
+	{
+		shoot4 = qfalse;
+		if ( TIMER_Done( NPC, "smackTime" ) && !NPCInfo->blockedDebounceTime )
+		{//time to smack
+			//recheck enemyDist4 and InFront
+			if ( enemyDist4 < MELEE_DIST_SQUARED && InFront( NPC->enemy->r.currentOrigin, NPC->r.currentOrigin, NPC->client->ps.viewangles, 0.3f ) )
+			{
+				vec3_t	smackDir;
+				VectorSubtract( NPC->enemy->r.currentOrigin, NPC->r.currentOrigin, smackDir );
+				smackDir[2] += 30;
+				VectorNormalize( smackDir );
+				//hurt them
+				G_Sound( NPC->enemy, CHAN_AUTO, G_SoundIndex( "sound/weapons/galak/skewerhit.wav" ) );
+				G_Damage( NPC->enemy, NPC, NPC, smackDir, NPC->r.currentOrigin, (g_spskill.integer+1)*Q_irand( 5, 10), DAMAGE_NO_ARMOR|DAMAGE_NO_KNOCKBACK, MOD_CRUSH ); 
+				if ( NPC->client->ps.torsoAnim == BOTH_ATTACK4 )
+				{//smackdown
+					int knockAnim = BOTH_KNOCKDOWN1;
+					if ( BG_CrouchAnim( NPC->enemy->client->ps.legsAnim ) )
+					{//knockdown from crouch
+						knockAnim = BOTH_KNOCKDOWN4;
+					}
+					//throw them
+					smackDir[2] = 1;
+					VectorNormalize( smackDir );
+					G_Throw( NPC->enemy, smackDir, 50 );
+					NPC_SetAnim( NPC->enemy, SETANIM_BOTH, knockAnim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+				}
+				else
+				{//uppercut
+					//throw them
+					G_Throw( NPC->enemy, smackDir, 100 );
+					//make them backflip
+					NPC_SetAnim( NPC->enemy, SETANIM_BOTH, BOTH_KNOCKDOWN5, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+				}
+				//done with the damage
+				NPCInfo->blockedDebounceTime = 1;
+			}
+		}
+	}
+	else if ( NPC->lockCount ) //already shooting laser
+	{//sometimes use the laser beam attack, but only after he's taken down our generator
+		shoot4 = qfalse;
+		if ( NPC->lockCount == 1 )
+		{//charging up
+			if ( TIMER_Done( NPC, "beamDelay" ) )
+			{//time to start the beam
+				int laserAnim;
+				//if ( Q_irand( 0, 1 ) )
+				if (1)
+				{
+					laserAnim = BOTH_ATTACK2;
+				}
+				/*
+				else
+				{
+					laserAnim = BOTH_ATTACK7;
+				}
+				*/
+				NPC_SetAnim( NPC, SETANIM_BOTH, laserAnim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+				TIMER_Set( NPC, "attackDelay", NPC->client->ps.torsoTimer + Q_irand( 1000, 3000 ) );
+				//turn on beam effect
+				NPC->lockCount = 2;
+				G_PlayEffectID( G_EffectIndex("galak/trace_beam"), NPC->r.currentOrigin, vec3_origin );
+				NPC->s.loopSound = G_SoundIndex( "sound/weapons/galak/lasercutting.wav" );
+				if ( !NPCInfo->coverTarg )
+				{//for moving looping sound at end of trace
+					NPCInfo->coverTarg = G_Spawn();
+					if ( NPCInfo->coverTarg )
+					{
+						G_SetOrigin( NPCInfo->coverTarg, NPC->client->renderInfo.muzzlePoint );
+						NPCInfo->coverTarg->r.svFlags |= SVF_BROADCAST;
+						NPCInfo->coverTarg->s.loopSound = G_SoundIndex( "sound/weapons/galak/lasercutting.wav" );
+					}
+				}
+			}
+		}
+		else
+		{//in the actual attack now
+			if ( NPC->client->ps.torsoTimer <= 0 )
+			{//attack done!
+				NPC->lockCount = 0;
+				G_FreeEntity( NPCInfo->coverTarg );
+				NPC->s.loopSound = 0;
+#if 0
+				NPC_SetAnim( NPC, SETANIM_TORSO, TORSO_DROPWEAP2, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+#endif
+				TIMER_Set( NPC, "attackDelay", NPC->client->ps.torsoTimer );
+			}
+			else
+			{//attack still going
+				//do the trace and damage
+				trace_t	trace;
+				vec3_t	end, mins={-3,-3,-3}, maxs={3,3,3};
+				VectorMA( NPC->client->renderInfo.muzzlePoint, 1024, NPC->client->renderInfo.muzzleDir, end );
+				trap_Trace( &trace, NPC->client->renderInfo.muzzlePoint, mins, maxs, end, NPC->s.number, MASK_SHOT );
+				if ( trace.allsolid || trace.startsolid )
+				{//oops, in a wall
+					if ( NPCInfo->coverTarg )
+					{
+						G_SetOrigin( NPCInfo->coverTarg, NPC->client->renderInfo.muzzlePoint );
+					}
+				}
+				else
+				{//clear
+					if ( trace.fraction < 1.0f )
+					{//hit something
+						gentity_t *traceEnt = &g_entities[trace.entityNum];
+						if ( traceEnt && traceEnt->takedamage )
+						{//damage it
+							G_SoundAtLoc( trace.endpos, CHAN_AUTO, G_SoundIndex( "sound/weapons/galak/laserdamage.wav" ) );
+							G_Damage( traceEnt, NPC, NPC, NPC->client->renderInfo.muzzleDir, trace.endpos, 10, 0, MOD_UNKNOWN );
+						}
+					}
+					if ( NPCInfo->coverTarg )
+					{
+						G_SetOrigin( NPCInfo->coverTarg, trace.endpos );
+					}
+					if ( !Q_irand( 0, 5 ) )
+					{
+						G_SoundAtLoc( trace.endpos, CHAN_AUTO, G_SoundIndex( "sound/weapons/galak/laserdamage.wav" ) );
+					}
+				}
+			}
+		}
+	}
+	else 
+	{//Okay, we're not in a special attack, see if we should switch weapons or start a special attack
+		/*
+		if ( NPC->s.weapon == WP_REPEATER 
+			&& !(NPCInfo->scriptFlags & SCF_ALT_FIRE)//using rapid-fire
+			&& NPC->enemy->s.weapon == WP_SABER //enemy using saber
+			&& NPC->client && (NPC->client->ps.saberEventFlags&SEF_DEFLECTED)
+			&& !Q_irand( 0, 50 ) )
+		{//he's deflecting my shots, switch to the laser or the lob fire for a while
+			TIMER_Set( NPC, "noRapid", Q_irand( 2000, 6000 ) );
+			NPCInfo->scriptFlags |= SCF_ALT_FIRE;
+			NPC->alt_fire = qtrue;
+			if ( NPC->locationDamage[HL_GENERIC1] > GENERATOR_HEALTH && (Q_irand( 0, 1 )||enemyDist4 < MAX_LOB_DIST_SQUARED) )
+			{//shield down, use laser
+				NPC_GM_StartLaser();
+			}
+		}
+		else*/
+		if (// !NPC->client->ps.powerups[PW_GALAK_SHIELD] 
+			1 //rwwFIXMEFIXME: just act like the shield is down til the effects and stuff are done
+			&& enemyDist4 < MELEE_DIST_SQUARED 
+			&& InFront( NPC->enemy->r.currentOrigin, NPC->r.currentOrigin, NPC->client->ps.viewangles, 0.3f ) 
+			&& NPC->enemy->localAnimIndex <= 1 )//within 80 and in front
+		{//our shield is down, and enemy within 80, if very close, use melee attack to slap away
+			if ( TIMER_Done( NPC, "attackDelay" ) )
+			{
+				//animate me
+				int swingAnim = BOTH_ATTACK1;
+#if 0
+				if ( NPC->locationDamage[HL_GENERIC1] > GENERATOR_HEALTH )
+				{//generator down, use random melee
+					swingAnim = Q_irand( BOTH_ATTACK4, BOTH_ATTACK5 );//smackdown or uppercut
+				}
+				else
+				{//always knock-away
+					swingAnim = BOTH_ATTACK5;//uppercut
+				}
+#endif
+				//FIXME: swing sound
+				NPC_SetAnim( NPC, SETANIM_BOTH, swingAnim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+				TIMER_Set( NPC, "attackDelay", NPC->client->ps.torsoTimer + Q_irand( 1000, 3000 ) );
+				//delay the hurt until the proper point in the anim
+				TIMER_Set( NPC, "smackTime", 600 );
+				NPCInfo->blockedDebounceTime = 0;
+				//FIXME: say something?
+			}
+		}
+		else if ( !NPC->lockCount && NPC->locationDamage[HL_GENERIC1] > GENERATOR_HEALTH
+			&& TIMER_Done( NPC, "attackDelay" )
+			&& InFront( NPC->enemy->r.currentOrigin, NPC->r.currentOrigin, NPC->client->ps.viewangles, 0.3f )
+			&& ((!Q_irand( 0, 10*(2-g_spskill.integer))&& enemyDist4 > MIN_LOB_DIST_SQUARED&& enemyDist4 < MAX_LOB_DIST_SQUARED)
+				||(!TIMER_Done( NPC, "noLob" )&&!TIMER_Done( NPC, "noRapid" ))) 
+			&& NPC->enemy->s.weapon != WP_TURRET )
+		{//sometimes use the laser beam attack, but only after he's taken down our generator
+			shoot4 = qfalse;
+			NPC_GM_StartLaser();
+		}
+		else if ( enemyDist4 < MIN_LOB_DIST_SQUARED 
+			&& (NPC->enemy->s.weapon != WP_TURRET || Q_stricmp( "PAS", NPC->enemy->classname ))
+			&& TIMER_Done( NPC, "noRapid" ) )//256
+		{//enemy within 256
+			if ( (NPC->client->ps.weapon == WP_REPEATER) && (NPCInfo->scriptFlags & SCF_ALT_FIRE) )
+			{//shooting an explosive, but enemy too close, switch to primary fire
+				NPCInfo->scriptFlags &= ~SCF_ALT_FIRE;
+				NPC->alt_fire = qfalse;
+				//FIXME: use weap raise & lower anims
+				NPC_ChangeWeapon( WP_REPEATER );
+			}
+		}
+		else if ( (enemyDist4 > MAX_LOB_DIST_SQUARED || (NPC->enemy->s.weapon == WP_TURRET && !Q_stricmp( "PAS", NPC->enemy->classname )))
+			&& TIMER_Done( NPC, "noLob" ) )//448
+		{//enemy more than 448 away and we are ready to try lob fire again
+			if ( (NPC->client->ps.weapon == WP_REPEATER) && !(NPCInfo->scriptFlags & SCF_ALT_FIRE) )
+			{//enemy far enough away to use lobby explosives
+				NPCInfo->scriptFlags |= SCF_ALT_FIRE;
+				NPC->alt_fire = qtrue;
+				//FIXME: use weap raise & lower anims
+				NPC_ChangeWeapon( WP_REPEATER );
+			}
+		}
+	}
+
+	//can we see our target?
+	if ( NPC_ClearLOS4( NPC->enemy ) )
+	{
+		NPCInfo->enemyLastSeenTime = level.time;//used here for aim debouncing, not always a clear LOS
+		enemyLOS4 = qtrue;
+
+		if ( NPC->client->ps.weapon == WP_NONE )
+		{
+			enemyCS4 = qfalse;//not true, but should stop us from firing
+			NPC_AimAdjust( -1 );//adjust aim worse longer we have no weapon
+		}
+		else
+		{//can we shoot our target?
+			if ( ((NPC->client->ps.weapon == WP_REPEATER && (NPCInfo->scriptFlags&SCF_ALT_FIRE))) && enemyDist4 < MIN_LOB_DIST_SQUARED )//256
+			{
+				enemyCS4 = qfalse;//not true, but should stop us from firing
+				hitAlly4 = qtrue;//us!
+				//FIXME: if too close, run away!
+			}
+			else
+			{
+				int hit = NPC_ShotEntity( NPC->enemy, impactPos4 );
+				gentity_t *hitEnt = &g_entities[hit];
+				if ( hit == NPC->enemy->s.number 
+					|| ( hitEnt && hitEnt->client && hitEnt->client->playerTeam == NPC->client->enemyTeam )
+					|| ( hitEnt && hitEnt->takedamage ) )
+				{//can hit enemy or will hit glass or other breakable, so shoot anyway
+					enemyCS4 = qtrue;
+					NPC_AimAdjust( 2 );//adjust aim better longer we have clear shot at enemy
+					VectorCopy( NPC->enemy->r.currentOrigin, NPCInfo->enemyLastSeenLocation );
+				}
+				else
+				{//Hmm, have to get around this bastard
+					NPC_AimAdjust( 1 );//adjust aim better longer we can see enemy
+					if ( hitEnt && hitEnt->client && hitEnt->client->playerTeam == NPC->client->playerTeam )
+					{//would hit an ally, don't fire!!!
+						hitAlly4 = qtrue;
+					}
+					else
+					{//Check and see where our shot *would* hit... if it's not close to the enemy (within 256?), then don't fire
+					}
+				}
+			}
+		}
+	}
+	else if ( trap_InPVS( NPC->enemy->r.currentOrigin, NPC->r.currentOrigin ) )
+	{
+		int hit;
+		gentity_t *hitEnt;
+
+		if ( TIMER_Done( NPC, "talkDebounce" ) && !Q_irand( 0, 10 ) )
+		{
+			if ( NPCInfo->enemyCheckDebounceTime < 8 )
+			{
+				int speech = -1;
+				switch( NPCInfo->enemyCheckDebounceTime )
+				{
+				case 0:
+				case 1:
+				case 2:
+					speech = EV_CHASE1 + NPCInfo->enemyCheckDebounceTime;
+					break;
+				case 3:
+				case 4:
+				case 5:
+					speech = EV_COVER1 + NPCInfo->enemyCheckDebounceTime-3;
+					break;
+				case 6:
+				case 7:
+					speech = EV_ESCAPING1 + NPCInfo->enemyCheckDebounceTime-6;
+					break;
+				}
+				NPCInfo->enemyCheckDebounceTime++;
+				if ( speech != -1 )
+				{
+					G_AddVoiceEvent( NPC, speech, Q_irand( 3000, 5000 ) );
+					TIMER_Set( NPC, "talkDebounce", Q_irand( 5000, 7000 ) );
+				}
+			}
+		}
+
+		NPCInfo->enemyLastSeenTime = level.time;
+
+		hit = NPC_ShotEntity( NPC->enemy, impactPos4 );
+		hitEnt = &g_entities[hit];
+		if ( hit == NPC->enemy->s.number 
+			|| ( hitEnt && hitEnt->client && hitEnt->client->playerTeam == NPC->client->enemyTeam )
+			|| ( hitEnt && hitEnt->takedamage ) )
+		{//can hit enemy or will hit glass or other breakable, so shoot anyway
+			enemyCS4 = qtrue;
+		}
+		else
+		{
+			faceEnemy4 = qtrue;
+			NPC_AimAdjust( -1 );//adjust aim worse longer we cannot see enemy
+		}
+	}
+
+	if ( enemyLOS4 )
+	{
+		faceEnemy4 = qtrue;
+	}
+	else
+	{
+		if ( !NPCInfo->goalEntity )
+		{
+			NPCInfo->goalEntity = NPC->enemy;
+		}
+		if ( NPCInfo->goalEntity == NPC->enemy )
+		{//for now, always chase the enemy
+			move4 = qtrue;
+		}
+	}
+	if ( enemyCS4 )
+	{
+		shoot4 = qtrue;
+		//NPCInfo->enemyCheckDebounceTime = level.time;//actually used here as a last actual LOS
+	}
+	else
+	{
+		if ( !NPCInfo->goalEntity )
+		{
+			NPCInfo->goalEntity = NPC->enemy;
+		}
+		if ( NPCInfo->goalEntity == NPC->enemy )
+		{//for now, always chase the enemy
+			move4 = qtrue;
+		}
+	}
+
+	//Check for movement to take care of
+	GM_CheckMoveState();
+
+	//See if we should override shooting decision with any special considerations
+	GM_CheckFireState();
+
+	if ( NPC->client->ps.weapon == WP_REPEATER && (NPCInfo->scriptFlags&SCF_ALT_FIRE) && shoot4 && TIMER_Done( NPC, "attackDelay" ) )
+	{
+		vec3_t	muzzle;
+		vec3_t	angles;
+		vec3_t	target;
+		vec3_t velocity = {0,0,0};
+		vec3_t mins = {-REPEATER_ALT_SIZE,-REPEATER_ALT_SIZE,-REPEATER_ALT_SIZE}, maxs = {REPEATER_ALT_SIZE,REPEATER_ALT_SIZE,REPEATER_ALT_SIZE};
+		qboolean clearshot;
+
+		CalcEntitySpot( NPC, SPOT_WEAPON, muzzle );
+		
+		VectorCopy( NPC->enemy->r.currentOrigin, target );
+
+		target[0] += flrand( -5, 5 )+(crandom()*(6-NPCInfo->currentAim)*2);
+		target[1] += flrand( -5, 5 )+(crandom()*(6-NPCInfo->currentAim)*2);
+		target[2] += flrand( -5, 5 )+(crandom()*(6-NPCInfo->currentAim)*2);
+
+		//Find the desired angles
+		clearshot = WP_LobFire( NPC, muzzle, target, mins, maxs, MASK_SHOT|CONTENTS_LIGHTSABER, 
+			velocity, qtrue, NPC->s.number, NPC->enemy->s.number,
+			300, 1100, 1500, qtrue );
+		if ( VectorCompare( vec3_origin, velocity ) || (!clearshot&&enemyLOS4&&enemyCS4)  )
+		{//no clear lob shot and no lob shot that will hit something breakable
+			if ( enemyLOS4 && enemyCS4 && TIMER_Done( NPC, "noRapid" ) )
+			{//have a clear straight shot, so switch to primary
+				NPCInfo->scriptFlags &= ~SCF_ALT_FIRE;
+				NPC->alt_fire = qfalse;
+				NPC_ChangeWeapon( WP_REPEATER );
+				//keep this weap for a bit
+				TIMER_Set( NPC, "noLob", Q_irand( 500, 1000 ) );
+			}
+			else
+			{
+				shoot4 = qfalse;
+			}
+		}
+		else
+		{
+			vectoangles( velocity, angles );
+
+			NPCInfo->desiredYaw		= AngleNormalize360( angles[YAW] );
+			NPCInfo->desiredPitch	= AngleNormalize360( angles[PITCH] );
+
+			VectorCopy( velocity, NPC->client->hiddenDir );
+			NPC->client->hiddenDist = VectorNormalize ( NPC->client->hiddenDir );
+		}
+	}
+	else if ( faceEnemy4 )
+	{//face the enemy
+		NPC_FaceEnemy( qtrue );
+	}
+
+	if ( !TIMER_Done( NPC, "standTime" ) )
+	{
+		move4 = qfalse;
+	}
+	if ( !(NPCInfo->scriptFlags&SCF_CHASE_ENEMIES) )
+	{//not supposed to chase my enemies
+		if ( NPCInfo->goalEntity == NPC->enemy )
+		{//goal is my entity, so don't move
+			move4 = qfalse;
+		}
+	}
+
+	if ( move4 && !NPC->lockCount )
+	{//move toward goal
+		if ( NPCInfo->goalEntity 
+			/*&& NPC->client->ps.legsAnim != BOTH_ALERT1
+			&& NPC->client->ps.legsAnim != BOTH_ATTACK2 
+			&& NPC->client->ps.legsAnim != BOTH_ATTACK4
+			&& NPC->client->ps.legsAnim != BOTH_ATTACK5 
+			&& NPC->client->ps.legsAnim != BOTH_ATTACK7*/ )
+		{
+			move4 = GM_Move();
+		}
+		else
+		{
+			move4 = qfalse;
+		}
+	}
+
+	if ( !TIMER_Done( NPC, "flee" ) )
+	{//running away
+		faceEnemy4 = qfalse;
+	}
+
+	//FIXME: check scf_face_move_dir here?
+
+	if ( !faceEnemy4 )
+	{//we want to face in the dir we're running
+		if ( !move4 )
+		{//if we haven't moved, we should look in the direction we last looked?
+			VectorCopy( NPC->client->ps.viewangles, NPCInfo->lastPathAngles );
+		}
+		if ( move4 )
+		{//don't run away and shoot
+			NPCInfo->desiredYaw = NPCInfo->lastPathAngles[YAW];
+			NPCInfo->desiredPitch = 0;
+			shoot4 = qfalse;
+		}
+	}
+	NPC_UpdateAngles( qtrue, qtrue );
+
+	if ( NPCInfo->scriptFlags & SCF_DONT_FIRE )
+	{
+		shoot4 = qfalse;
+	}
+
+	if ( NPC->enemy && NPC->enemy->enemy )
+	{
+		if ( NPC->enemy->s.weapon == WP_SABER && NPC->enemy->enemy->s.weapon == WP_SABER )
+		{//don't shoot at an enemy jedi who is fighting another jedi, for fear of injuring one or causing rogue blaster deflections (a la Obi Wan/Vader duel at end of ANH)
+			shoot4 = qfalse;
+		}
+	}
+	//FIXME: don't shoot right away!
+	if ( shoot4 )
+	{//try to shoot if it's time
+		if ( TIMER_Done( NPC, "attackDelay" ) )
+		{
+			if( !(NPCInfo->scriptFlags & SCF_FIRE_WEAPON) ) // we've already fired, no need to do it again here
+			{
+				WeaponThink( qtrue );
+			}
+		}
+	}
+
+	//also:
+	if ( NPC->enemy->s.weapon == WP_TURRET && !Q_stricmp( "PAS", NPC->enemy->classname ) )
+	{//crush turrets
+		if ( G_BoundsOverlap( NPC->r.absmin, NPC->r.absmax, NPC->enemy->r.absmin, NPC->enemy->r.absmax ) )
+		{//have to do this test because placed turrets are not solid to NPCs (so they don't obstruct navigation)
+			//if ( NPC->client->ps.powerups[PW_GALAK_SHIELD] > 0 )
+			if (0)
+			{
+				NPC->client->ps.powerups[PW_BATTLESUIT] = level.time + ARMOR_EFFECT_TIME;
+				G_Damage( NPC->enemy, NPC, NPC, NULL, NPC->r.currentOrigin, 100, DAMAGE_NO_KNOCKBACK, MOD_UNKNOWN ); 
+			}
+			else
+			{
+				G_Damage( NPC->enemy, NPC, NPC, NULL, NPC->r.currentOrigin, 100, DAMAGE_NO_KNOCKBACK, MOD_CRUSH ); 
+			}
+		}
+	}
+	else if ( NPCInfo->touchedByPlayer != NULL && NPCInfo->touchedByPlayer == NPC->enemy )
+	{//touched enemy
+		//if ( NPC->client->ps.powerups[PW_GALAK_SHIELD] > 0 )
+		if (0)
+		{//zap him!
+			vec3_t	smackDir;
+
+			//animate me
+#if 0
+			NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_ATTACK6, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+#endif
+			TIMER_Set( NPC, "attackDelay", NPC->client->ps.torsoTimer );
+			TIMER_Set( NPC, "standTime", NPC->client->ps.legsTimer );
+			//FIXME: debounce this?
+			NPCInfo->touchedByPlayer = NULL;
+			//FIXME: some shield effect?
+			NPC->client->ps.powerups[PW_BATTLESUIT] = level.time + ARMOR_EFFECT_TIME;
+
+			VectorSubtract( NPC->enemy->r.currentOrigin, NPC->r.currentOrigin, smackDir );
+			smackDir[2] += 30;
+			VectorNormalize( smackDir );
+			G_Damage( NPC->enemy, NPC, NPC, smackDir, NPC->r.currentOrigin, (g_spskill.integer+1)*Q_irand( 5, 10), DAMAGE_NO_KNOCKBACK, MOD_UNKNOWN ); 
+			//throw them
+			G_Throw( NPC->enemy, smackDir, 100 );
+			//NPC->enemy->s.powerups |= ( 1 << PW_SHOCKED );
+			if ( NPC->enemy->client )
+			{
+			//	NPC->enemy->client->ps.powerups[PW_SHOCKED] = level.time + 1000;
+				NPC->enemy->client->ps.electrifyTime = level.time + 1000;
+			}
+			//stop any attacks
+			ucmd.buttons = 0;
+		}
+	}
+
+	if ( NPCInfo->movementSpeech < 3 && NPCInfo->blockedSpeechDebounceTime <= level.time )
+	{
+		if ( NPC->enemy && NPC->enemy->health > 0 && NPC->enemy->painDebounceTime > level.time )
+		{
+			if ( NPC->enemy->health < 50 && NPCInfo->movementSpeech == 2 )
+			{
+				G_AddVoiceEvent( NPC, EV_ANGER2, Q_irand( 2000, 4000 ) );
+				NPCInfo->movementSpeech = 3;
+			}
+			else if ( NPC->enemy->health < 75 && NPCInfo->movementSpeech == 1 )
+			{
+				G_AddVoiceEvent( NPC, EV_ANGER1, Q_irand( 2000, 4000 ) );
+				NPCInfo->movementSpeech = 2;
+			}
+			else if ( NPC->enemy->health < 100 && NPCInfo->movementSpeech == 0 )
+			{
+				G_AddVoiceEvent( NPC, EV_ANGER3, Q_irand( 2000, 4000 ) );
+				NPCInfo->movementSpeech = 1;
+			}
+		}
+	}
+}
+
+void NPC_BSGM_Default( void )
+{
+	if( NPCInfo->scriptFlags & SCF_FIRE_WEAPON )
+	{
+		WeaponThink( qtrue );
+	}
+	
+	if ( NPC->client->ps.stats[STAT_ARMOR] <= 0 )
+	{//armor gone
+	//	if ( !NPCInfo->investigateDebounceTime )
+		if (0)
+		{//start regenerating the armor
+			NPC_SetSurfaceOnOff( NPC, "torso_shield", TURN_OFF );
+			NPC->flags &= ~FL_SHIELDED;//no more reflections
+			VectorSet( NPC->r.mins, -20, -20, -24 );
+			VectorSet( NPC->r.maxs, 20, 20, 64 );
+			NPC->client->ps.crouchheight = NPC->client->ps.standheight = 64;
+			if ( NPC->locationDamage[HL_GENERIC1] < GENERATOR_HEALTH )
+			{//still have the generator bolt-on
+				if ( NPCInfo->investigateCount < 12 )
+				{
+					NPCInfo->investigateCount++;
+				}
+				NPCInfo->investigateDebounceTime = level.time + (NPCInfo->investigateCount * 5000);
+			}
+		}
+		else if ( NPCInfo->investigateDebounceTime < level.time )
+		{//armor regenerated, turn shield back on
+			//do a trace and make sure we can turn this back on?
+			trace_t	tr;
+			trap_Trace( &tr, NPC->r.currentOrigin, shieldMins, shieldMaxs, NPC->r.currentOrigin, NPC->s.number, NPC->clipmask );
+			if ( !tr.startsolid )
+			{
+				VectorCopy( shieldMins, NPC->r.mins );
+				VectorCopy( shieldMaxs, NPC->r.maxs );
+				NPC->client->ps.crouchheight = NPC->client->ps.standheight = shieldMaxs[2];
+				NPC->client->ps.stats[STAT_ARMOR] = GALAK_SHIELD_HEALTH;
+				NPCInfo->investigateDebounceTime = 0;
+				NPC->flags |= FL_SHIELDED;//reflect normal shots
+			//	NPC->fx_time = level.time;
+				NPC_SetSurfaceOnOff( NPC, "torso_shield", TURN_ON );
+			}
+		}
+	}
+	/*
+	if ( NPC->client->ps.stats[STAT_ARMOR] > 0 )
+	{//armor present
+		NPC->client->ps.powerups[PW_GALAK_SHIELD] = Q3_INFINITE;//temp, for effect
+		NPC_SetSurfaceOnOff( NPC, "torso_shield", TURN_ON );
+	}
+	else
+	{
+		NPC_SetSurfaceOnOff( NPC, "torso_shield", TURN_OFF );
+	}
+	*/
+	//rwwFIXMEFIXME: Allow this stuff, and again, going to have to let the client know about it.
+	//Maybe a surface-off bitflag of some sort in the entity state?
+
+	if( !NPC->enemy )
+	{//don't have an enemy, look for one
+		NPC_BSGM_Patrol();
+	}
+	else //if ( NPC->enemy )
+	{//have an enemy
+		NPC_BSGM_Attack();
+	}
+}
diff --git a/codemp/game/NPC_AI_Grenadier.c b/codemp/game/NPC_AI_Grenadier.c
new file mode 100644
index 0000000..f0ec505
--- /dev/null
+++ b/codemp/game/NPC_AI_Grenadier.c
@@ -0,0 +1,679 @@
+#include "b_local.h"
+#include "g_nav.h"
+#include "anims.h"
+//#include "g_navigator.h"
+
+#include "../namespace_begin.h"
+extern qboolean BG_SabersOff( playerState_t *ps );
+#include "../namespace_end.h"
+
+extern void CG_DrawAlert( vec3_t origin, float rating );
+extern void G_AddVoiceEvent( gentity_t *self, int event, int speakDebounceTime );
+extern void G_SoundOnEnt( gentity_t *ent, soundChannel_t channel, const char *soundPath );
+extern void NPC_TempLookTarget( gentity_t *self, int lookEntNum, int minLookTime, int maxLookTime );
+extern qboolean G_ExpandPointToBBox( vec3_t point, const vec3_t mins, const vec3_t maxs, int ignore, int clipmask );
+extern void NPC_AimAdjust( int change );
+extern qboolean FlyingCreature( gentity_t *ent );
+
+#define	MAX_VIEW_DIST		1024
+#define MAX_VIEW_SPEED		250
+#define	MAX_LIGHT_INTENSITY 255
+#define	MIN_LIGHT_THRESHOLD	0.1
+
+#define	DISTANCE_SCALE		0.25f
+#define	DISTANCE_THRESHOLD	0.075f
+#define	SPEED_SCALE			0.25f
+#define	FOV_SCALE			0.5f
+#define	LIGHT_SCALE			0.25f
+
+#define	REALIZE_THRESHOLD	0.6f
+#define CAUTIOUS_THRESHOLD	( REALIZE_THRESHOLD * 0.75 )
+
+qboolean NPC_CheckPlayerTeamStealth( void );
+
+static qboolean enemyLOS3;
+static qboolean enemyCS3;
+static qboolean faceEnemy3;
+static qboolean move3;
+static qboolean shoot3;
+static float	enemyDist3;
+
+//Local state enums
+enum
+{
+	LSTATE_NONE = 0,
+	LSTATE_UNDERFIRE,
+	LSTATE_INVESTIGATE,
+};
+
+void Grenadier_ClearTimers( gentity_t *ent )
+{
+	TIMER_Set( ent, "chatter", 0 );
+	TIMER_Set( ent, "duck", 0 );
+	TIMER_Set( ent, "stand", 0 );
+	TIMER_Set( ent, "shuffleTime", 0 );
+	TIMER_Set( ent, "sleepTime", 0 );
+	TIMER_Set( ent, "enemyLastVisible", 0 );
+	TIMER_Set( ent, "roamTime", 0 );
+	TIMER_Set( ent, "hideTime", 0 );
+	TIMER_Set( ent, "attackDelay", 0 );	//FIXME: Slant for difficulty levels
+	TIMER_Set( ent, "stick", 0 );
+	TIMER_Set( ent, "scoutTime", 0 );
+	TIMER_Set( ent, "flee", 0 );
+}
+
+void NPC_Grenadier_PlayConfusionSound( gentity_t *self )
+{//FIXME: make this a custom sound in sound set
+	if ( self->health > 0 )
+	{
+		G_AddVoiceEvent( self, Q_irand(EV_CONFUSE1, EV_CONFUSE3), 2000 );
+	}
+	//reset him to be totally unaware again
+	TIMER_Set( self, "enemyLastVisible", 0 );
+	TIMER_Set( self, "flee", 0 );
+	self->NPC->squadState = SQUAD_IDLE;
+	self->NPC->tempBehavior = BS_DEFAULT;
+	
+	//self->NPC->behaviorState = BS_PATROL;
+	G_ClearEnemy( self );//FIXME: or just self->enemy = NULL;?
+
+	self->NPC->investigateCount = 0;
+}
+
+
+/*
+-------------------------
+NPC_ST_Pain
+-------------------------
+*/
+
+void NPC_Grenadier_Pain(gentity_t *self, gentity_t *attacker, int damage) 
+{
+	self->NPC->localState = LSTATE_UNDERFIRE;
+
+	TIMER_Set( self, "duck", -1 );
+	TIMER_Set( self, "stand", 2000 );
+
+	NPC_Pain( self, attacker, damage );
+
+	if ( !damage && self->health > 0 )
+	{//FIXME: better way to know I was pushed
+		G_AddVoiceEvent( self, Q_irand(EV_PUSHED1, EV_PUSHED3), 2000 );
+	}
+}
+
+/*
+-------------------------
+ST_HoldPosition
+-------------------------
+*/
+
+static void Grenadier_HoldPosition( void )
+{
+	NPC_FreeCombatPoint( NPCInfo->combatPoint, qtrue );
+	NPCInfo->goalEntity = NULL;
+	
+	/*if ( TIMER_Done( NPC, "stand" ) )
+	{//FIXME: what if can't shoot from this pos?
+		TIMER_Set( NPC, "duck", Q_irand( 2000, 4000 ) );
+	}
+	*/
+}
+
+/*
+-------------------------
+ST_Move
+-------------------------
+*/
+
+static qboolean Grenadier_Move( void )
+{
+	qboolean	moved;
+	navInfo_t	info;
+
+	NPCInfo->combatMove = qtrue;//always move straight toward our goal
+	moved = NPC_MoveToGoal( qtrue );
+	
+	//Get the move info
+	NAV_GetLastMove( &info );
+
+	//FIXME: if we bump into another one of our guys and can't get around him, just stop!
+	//If we hit our target, then stop and fire!
+	if ( info.flags & NIF_COLLISION ) 
+	{
+		if ( info.blocker == NPC->enemy )
+		{
+			Grenadier_HoldPosition();
+		}
+	}
+
+	//If our move failed, then reset
+	if ( moved == qfalse )
+	{//couldn't get to enemy
+		if ( (NPCInfo->scriptFlags&SCF_CHASE_ENEMIES) && NPC->client->ps.weapon == WP_THERMAL && NPCInfo->goalEntity && NPCInfo->goalEntity == NPC->enemy )
+		{//we were running after enemy
+			//Try to find a combat point that can hit the enemy
+			int cpFlags = (CP_CLEAR|CP_HAS_ROUTE);
+			int cp;
+
+			if ( NPCInfo->scriptFlags&SCF_USE_CP_NEAREST )
+			{
+				cpFlags &= ~(CP_FLANK|CP_APPROACH_ENEMY|CP_CLOSEST);
+				cpFlags |= CP_NEAREST;
+			}
+			cp = NPC_FindCombatPoint( NPC->r.currentOrigin, NPC->r.currentOrigin, NPC->r.currentOrigin, cpFlags, 32, -1 );
+			if ( cp == -1 && !(NPCInfo->scriptFlags&SCF_USE_CP_NEAREST) )
+			{//okay, try one by the enemy
+				cp = NPC_FindCombatPoint( NPC->r.currentOrigin, NPC->r.currentOrigin, NPC->enemy->r.currentOrigin, CP_CLEAR|CP_HAS_ROUTE|CP_HORZ_DIST_COLL, 32, -1 );
+			}
+			//NOTE: there may be a perfectly valid one, just not one within CP_COLLECT_RADIUS of either me or him...
+			if ( cp != -1 )
+			{//found a combat point that has a clear shot to enemy
+				NPC_SetCombatPoint( cp );
+				NPC_SetMoveGoal( NPC, level.combatPoints[cp].origin, 8, qtrue, cp, NULL );
+				return moved;
+			}
+		}
+		//just hang here
+		Grenadier_HoldPosition();
+	}
+
+	return moved;
+}
+
+/*
+-------------------------
+NPC_BSGrenadier_Patrol
+-------------------------
+*/
+
+void NPC_BSGrenadier_Patrol( void )
+{//FIXME: pick up on bodies of dead buddies?
+	if ( NPCInfo->confusionTime < level.time )
+	{
+		//Look for any enemies
+		if ( NPCInfo->scriptFlags&SCF_LOOK_FOR_ENEMIES )
+		{
+			if ( NPC_CheckPlayerTeamStealth() )
+			{
+				//NPCInfo->behaviorState = BS_HUNT_AND_KILL;//should be automatic now
+				//NPC_AngerSound();
+				NPC_UpdateAngles( qtrue, qtrue );
+				return;
+			}
+		}
+
+		if ( !(NPCInfo->scriptFlags&SCF_IGNORE_ALERTS) )
+		{
+			//Is there danger nearby
+			int alertEvent = NPC_CheckAlertEvents( qtrue, qtrue, -1, qfalse, AEL_SUSPICIOUS );
+			if ( NPC_CheckForDanger( alertEvent ) )
+			{
+				NPC_UpdateAngles( qtrue, qtrue );
+				return;
+			}
+			else
+			{//check for other alert events
+				//There is an event to look at
+				if ( alertEvent >= 0 && level.alertEvents[alertEvent].ID != NPCInfo->lastAlertID )
+				{
+					NPCInfo->lastAlertID = level.alertEvents[alertEvent].ID;
+					if ( level.alertEvents[alertEvent].level == AEL_DISCOVERED )
+					{
+						if ( level.alertEvents[alertEvent].owner && 
+							level.alertEvents[alertEvent].owner->client && 
+							level.alertEvents[alertEvent].owner->health >= 0 &&
+							level.alertEvents[alertEvent].owner->client->playerTeam == NPC->client->enemyTeam )
+						{//an enemy
+							G_SetEnemy( NPC, level.alertEvents[alertEvent].owner );
+							//NPCInfo->enemyLastSeenTime = level.time;
+							TIMER_Set( NPC, "attackDelay", Q_irand( 500, 2500 ) );
+						}
+					}
+					else
+					{//FIXME: get more suspicious over time?
+						//Save the position for movement (if necessary)
+						VectorCopy( level.alertEvents[alertEvent].position, NPCInfo->investigateGoal );
+						NPCInfo->investigateDebounceTime = level.time + Q_irand( 500, 1000 );
+						if ( level.alertEvents[alertEvent].level == AEL_SUSPICIOUS )
+						{//suspicious looks longer
+							NPCInfo->investigateDebounceTime += Q_irand( 500, 2500 );
+						}
+					}
+				}
+			}
+
+			if ( NPCInfo->investigateDebounceTime > level.time )
+			{//FIXME: walk over to it, maybe?  Not if not chase enemies
+				//NOTE: stops walking or doing anything else below
+				vec3_t	dir, angles;
+				float	o_yaw, o_pitch;
+				
+				VectorSubtract( NPCInfo->investigateGoal, NPC->client->renderInfo.eyePoint, dir );
+				vectoangles( dir, angles );
+				
+				o_yaw = NPCInfo->desiredYaw;
+				o_pitch = NPCInfo->desiredPitch;
+				NPCInfo->desiredYaw = angles[YAW];
+				NPCInfo->desiredPitch = angles[PITCH];
+				
+				NPC_UpdateAngles( qtrue, qtrue );
+
+				NPCInfo->desiredYaw = o_yaw;
+				NPCInfo->desiredPitch = o_pitch;
+				return;
+			}
+		}
+	}
+
+	//If we have somewhere to go, then do that
+	if ( UpdateGoal() )
+	{
+		ucmd.buttons |= BUTTON_WALKING;
+		NPC_MoveToGoal( qtrue );
+	}
+
+	NPC_UpdateAngles( qtrue, qtrue );
+}
+
+/*
+-------------------------
+NPC_BSGrenadier_Idle
+-------------------------
+*/
+/*
+void NPC_BSGrenadier_Idle( void )
+{
+	//FIXME: check for other alert events?
+
+	//Is there danger nearby?
+	if ( NPC_CheckForDanger( NPC_CheckAlertEvents( qtrue, qtrue, -1, qfalse, AEL_DANGER ) ) )
+	{
+		NPC_UpdateAngles( qtrue, qtrue );
+		return;
+	}
+
+	TIMER_Set( NPC, "roamTime", 2000 + Q_irand( 1000, 2000 ) );
+
+	NPC_UpdateAngles( qtrue, qtrue );
+}
+*/
+/*
+-------------------------
+ST_CheckMoveState
+-------------------------
+*/
+
+static void Grenadier_CheckMoveState( void )
+{
+	//See if we're a scout
+	if ( !(NPCInfo->scriptFlags & SCF_CHASE_ENEMIES) )//behaviorState == BS_STAND_AND_SHOOT )
+	{
+		if ( NPCInfo->goalEntity == NPC->enemy )
+		{
+			move3 = qfalse;
+			return;
+		}
+	}
+	//See if we're running away
+	else if ( NPCInfo->squadState == SQUAD_RETREAT )
+	{
+		if ( TIMER_Done( NPC, "flee" ) )
+		{
+			NPCInfo->squadState = SQUAD_IDLE;
+		}
+		else
+		{
+			faceEnemy3 = qfalse;
+		}
+	}
+	/*
+	else if ( NPCInfo->squadState == SQUAD_IDLE )
+	{
+		if ( !NPCInfo->goalEntity )
+		{
+			move3 = qfalse;
+			return;
+		}
+		//Should keep moving toward player when we're out of range... right?
+	}
+	*/
+
+	//See if we're moving towards a goal, not the enemy
+	if ( ( NPCInfo->goalEntity != NPC->enemy ) && ( NPCInfo->goalEntity != NULL ) )
+	{
+		//Did we make it?
+		if ( NAV_HitNavGoal( NPC->r.currentOrigin, NPC->r.mins, NPC->r.maxs, NPCInfo->goalEntity->r.currentOrigin, 16, FlyingCreature( NPC ) ) || 
+			( NPCInfo->squadState == SQUAD_SCOUT && enemyLOS3 && enemyDist3 <= 10000 ) )
+		{
+			int	newSquadState = SQUAD_STAND_AND_SHOOT;
+			//we got where we wanted to go, set timers based on why we were running
+			switch ( NPCInfo->squadState )
+			{
+			case SQUAD_RETREAT://was running away
+				TIMER_Set( NPC, "duck", (NPC->client->pers.maxHealth - NPC->health) * 100 );
+				TIMER_Set( NPC, "hideTime", Q_irand( 3000, 7000 ) );
+				newSquadState = SQUAD_COVER;
+				break;
+			case SQUAD_TRANSITION://was heading for a combat point
+				TIMER_Set( NPC, "hideTime", Q_irand( 2000, 4000 ) );
+				break;
+			case SQUAD_SCOUT://was running after player
+				break;
+			default:
+				break;
+			}
+			NPC_ReachedGoal();
+			//don't attack right away
+			TIMER_Set( NPC, "attackDelay", Q_irand( 250, 500 ) );	//FIXME: Slant for difficulty levels
+			//don't do something else just yet
+			TIMER_Set( NPC, "roamTime", Q_irand( 1000, 4000 ) );
+			//stop fleeing
+			if ( NPCInfo->squadState == SQUAD_RETREAT )
+			{
+				TIMER_Set( NPC, "flee", -level.time );
+				NPCInfo->squadState = SQUAD_IDLE;
+			}
+			return;
+		}
+
+		//keep going, hold of roamTimer until we get there
+		TIMER_Set( NPC, "roamTime", Q_irand( 4000, 8000 ) );
+	}
+
+	if ( !NPCInfo->goalEntity )
+	{
+		if ( NPCInfo->scriptFlags & SCF_CHASE_ENEMIES )
+		{
+			NPCInfo->goalEntity = NPC->enemy;
+		}
+	}
+}
+
+/*
+-------------------------
+ST_CheckFireState
+-------------------------
+*/
+
+static void Grenadier_CheckFireState( void )
+{
+	if ( enemyCS3 )
+	{//if have a clear shot, always try
+		return;
+	}
+
+	if ( NPCInfo->squadState == SQUAD_RETREAT || NPCInfo->squadState == SQUAD_TRANSITION || NPCInfo->squadState == SQUAD_SCOUT )
+	{//runners never try to fire at the last pos
+		return;
+	}
+
+	if ( !VectorCompare( NPC->client->ps.velocity, vec3_origin ) )
+	{//if moving at all, don't do this
+		return;
+	}
+
+	//continue to fire on their last position
+	/*
+	if ( !Q_irand( 0, 1 ) && NPCInfo->enemyLastSeenTime && level.time - NPCInfo->enemyLastSeenTime < 4000 )
+	{
+		//Fire on the last known position
+		vec3_t	muzzle, dir, angles;
+
+		CalcEntitySpot( NPC, SPOT_WEAPON, muzzle );
+		VectorSubtract( NPCInfo->enemyLastSeenLocation, muzzle, dir );
+
+		VectorNormalize( dir );
+
+		vectoangles( dir, angles );
+
+		NPCInfo->desiredYaw		= angles[YAW];
+		NPCInfo->desiredPitch	= angles[PITCH];
+		//FIXME: they always throw toward enemy, so this will be very odd...
+		shoot3 = qtrue;
+		faceEnemy3 = qfalse;
+
+		return;
+	}
+	*/
+}
+
+qboolean Grenadier_EvaluateShot( int hit )
+{
+	if ( !NPC->enemy )
+	{
+		return qfalse;
+	}
+
+	if ( hit == NPC->enemy->s.number || (&g_entities[hit] != NULL && (g_entities[hit].r.svFlags&SVF_GLASS_BRUSH)) )
+	{//can hit enemy or will hit glass, so shoot anyway
+		return qtrue;
+	}
+	return qfalse;
+}
+
+/*
+-------------------------
+NPC_BSGrenadier_Attack
+-------------------------
+*/
+
+void NPC_BSGrenadier_Attack( void )
+{
+	//Don't do anything if we're hurt
+	if ( NPC->painDebounceTime > level.time )
+	{
+		NPC_UpdateAngles( qtrue, qtrue );
+		return;
+	}
+
+	//NPC_CheckEnemy( qtrue, qfalse );
+	//If we don't have an enemy, just idle
+	if ( NPC_CheckEnemyExt(qfalse) == qfalse )//!NPC->enemy )//
+	{
+		NPC->enemy = NULL;
+		NPC_BSGrenadier_Patrol();//FIXME: or patrol?
+		return;
+	}
+
+	if ( TIMER_Done( NPC, "flee" ) && NPC_CheckForDanger( NPC_CheckAlertEvents( qtrue, qtrue, -1, qfalse, AEL_DANGER ) ) )
+	{//going to run
+		NPC_UpdateAngles( qtrue, qtrue );
+		return;
+	}
+
+	if ( !NPC->enemy )
+	{//WTF?  somehow we lost our enemy?
+		NPC_BSGrenadier_Patrol();//FIXME: or patrol?
+		return;
+	}
+
+	enemyLOS3 = enemyCS3 = qfalse;
+	move3 = qtrue;
+	faceEnemy3 = qfalse;
+	shoot3 = qfalse;
+	enemyDist3 = DistanceSquared( NPC->enemy->r.currentOrigin, NPC->r.currentOrigin );
+
+	//See if we should switch to melee attack
+	if ( enemyDist3 < 16384 //128
+		&& (!NPC->enemy->client
+			|| NPC->enemy->client->ps.weapon != WP_SABER
+			|| BG_SabersOff( &NPC->enemy->client->ps ) 
+			) 
+		)
+	{//enemy is close and not using saber
+		if ( NPC->client->ps.weapon == WP_THERMAL )
+		{//grenadier
+			trace_t	trace;
+			trap_Trace ( &trace, NPC->r.currentOrigin, NPC->enemy->r.mins, NPC->enemy->r.maxs, NPC->enemy->r.currentOrigin, NPC->s.number, NPC->enemy->clipmask );
+			if ( !trace.allsolid && !trace.startsolid && (trace.fraction == 1.0 || trace.entityNum == NPC->enemy->s.number ) )
+			{//I can get right to him
+				//reset fire-timing variables
+				NPC_ChangeWeapon( WP_STUN_BATON );
+				if ( !(NPCInfo->scriptFlags&SCF_CHASE_ENEMIES) )//NPCInfo->behaviorState == BS_STAND_AND_SHOOT )
+				{//FIXME: should we be overriding scriptFlags?
+					NPCInfo->scriptFlags |= SCF_CHASE_ENEMIES;//NPCInfo->behaviorState = BS_HUNT_AND_KILL;
+				}
+			}
+		}
+	}
+	else if ( enemyDist3 > 65536 || (NPC->enemy->client && NPC->enemy->client->ps.weapon == WP_SABER && !NPC->enemy->client->ps.saberHolstered) )//256
+	{//enemy is far or using saber
+		if ( NPC->client->ps.weapon == WP_STUN_BATON && (NPC->client->ps.stats[STAT_WEAPONS]&(1<<WP_THERMAL)) )
+		{//fisticuffs, make switch to thermal if have it
+			//reset fire-timing variables
+			NPC_ChangeWeapon( WP_THERMAL );
+		}
+	}
+
+	//can we see our target?
+	if ( NPC_ClearLOS4( NPC->enemy ) )
+	{
+		NPCInfo->enemyLastSeenTime = level.time;
+		enemyLOS3 = qtrue;
+
+		if ( NPC->client->ps.weapon == WP_STUN_BATON )
+		{
+			if ( enemyDist3 <= 4096 && InFOV3( NPC->enemy->r.currentOrigin, NPC->r.currentOrigin, NPC->client->ps.viewangles, 90, 45 ) )//within 64 & infront
+			{
+				VectorCopy( NPC->enemy->r.currentOrigin, NPCInfo->enemyLastSeenLocation );
+				enemyCS3 = qtrue;
+			}
+		}
+		else if ( InFOV3( NPC->enemy->r.currentOrigin, NPC->r.currentOrigin, NPC->client->ps.viewangles, 45, 90 ) )
+		{//in front of me 
+			//can we shoot our target?
+			//FIXME: how accurate/necessary is this check?
+			int hit = NPC_ShotEntity( NPC->enemy, NULL );
+			gentity_t *hitEnt = &g_entities[hit];
+			if ( hit == NPC->enemy->s.number 
+				|| ( hitEnt && hitEnt->client && hitEnt->client->playerTeam == NPC->client->enemyTeam ) )
+			{
+				float enemyHorzDist;
+
+				VectorCopy( NPC->enemy->r.currentOrigin, NPCInfo->enemyLastSeenLocation );
+				enemyHorzDist = DistanceHorizontalSquared( NPC->enemy->r.currentOrigin, NPC->r.currentOrigin );
+				if ( enemyHorzDist < 1048576 )
+				{//within 1024
+					enemyCS3 = qtrue;
+					NPC_AimAdjust( 2 );//adjust aim better longer we have clear shot at enemy
+				}
+				else
+				{
+					NPC_AimAdjust( 1 );//adjust aim better longer we can see enemy
+				}
+			}
+		}
+	}
+	else
+	{
+		NPC_AimAdjust( -1 );//adjust aim worse longer we cannot see enemy
+	}
+	/*
+	else if ( trap_InPVS( NPC->enemy->r.currentOrigin, NPC->r.currentOrigin ) )
+	{
+		NPCInfo->enemyLastSeenTime = level.time;
+		faceEnemy3 = qtrue;
+	}
+	*/
+
+	if ( enemyLOS3 )
+	{//FIXME: no need to face enemy if we're moving to some other goal and he's too far away to shoot?
+		faceEnemy3 = qtrue;
+	}
+
+	if ( enemyCS3 )
+	{
+		shoot3 = qtrue;
+		if ( NPC->client->ps.weapon == WP_THERMAL )
+		{//don't chase and throw
+			move3 = qfalse;
+		}
+		else if ( NPC->client->ps.weapon == WP_STUN_BATON && enemyDist3 < (NPC->r.maxs[0]+NPC->enemy->r.maxs[0]+16)*(NPC->r.maxs[0]+NPC->enemy->r.maxs[0]+16) )
+		{//close enough
+			move3 = qfalse;
+		}
+	}//this should make him chase enemy when out of range...?
+
+	//Check for movement to take care of
+	Grenadier_CheckMoveState();
+
+	//See if we should override shooting decision with any special considerations
+	Grenadier_CheckFireState();
+
+	if ( move3 )
+	{//move toward goal
+		if ( NPCInfo->goalEntity )//&& ( NPCInfo->goalEntity != NPC->enemy || enemyDist3 > 10000 ) )//100 squared
+		{
+			move3 = Grenadier_Move();
+		}
+		else
+		{
+			move3 = qfalse;
+		}
+	}
+
+	if ( !move3 )
+	{
+		if ( !TIMER_Done( NPC, "duck" ) )
+		{
+			ucmd.upmove = -127;
+		}
+		//FIXME: what about leaning?
+	}
+	else
+	{//stop ducking!
+		TIMER_Set( NPC, "duck", -1 );
+	}
+
+	if ( !faceEnemy3 )
+	{//we want to face in the dir we're running
+		if ( move3 )
+		{//don't run away and shoot
+			NPCInfo->desiredYaw = NPCInfo->lastPathAngles[YAW];
+			NPCInfo->desiredPitch = 0;
+			shoot3 = qfalse;
+		}
+		NPC_UpdateAngles( qtrue, qtrue );
+	}
+	else// if ( faceEnemy3 )
+	{//face the enemy
+		NPC_FaceEnemy(qtrue);
+	}
+
+	if ( NPCInfo->scriptFlags&SCF_DONT_FIRE )
+	{
+		shoot3 = qfalse;
+	}
+
+	//FIXME: don't shoot right away!
+	if ( shoot3 )
+	{//try to shoot if it's time
+		if ( TIMER_Done( NPC, "attackDelay" ) )
+		{	
+			if( !(NPCInfo->scriptFlags & SCF_FIRE_WEAPON) ) // we've already fired, no need to do it again here
+			{
+				WeaponThink( qtrue );
+				TIMER_Set( NPC, "attackDelay", NPCInfo->shotTime-level.time );
+			}
+			
+		}
+	}
+}
+
+void NPC_BSGrenadier_Default( void )
+{
+	if( NPCInfo->scriptFlags & SCF_FIRE_WEAPON )
+	{
+		WeaponThink( qtrue );
+	}
+
+	if( !NPC->enemy )
+	{//don't have an enemy, look for one
+		NPC_BSGrenadier_Patrol();
+	}
+	else//if ( NPC->enemy )
+	{//have an enemy
+		NPC_BSGrenadier_Attack();
+	}
+}
diff --git a/codemp/game/NPC_AI_Howler.c b/codemp/game/NPC_AI_Howler.c
new file mode 100644
index 0000000..8252274
--- /dev/null
+++ b/codemp/game/NPC_AI_Howler.c
@@ -0,0 +1,218 @@
+#include "b_local.h"
+
+// These define the working combat range for these suckers
+#define MIN_DISTANCE		54
+#define MIN_DISTANCE_SQR	( MIN_DISTANCE * MIN_DISTANCE )
+
+#define MAX_DISTANCE		128
+#define MAX_DISTANCE_SQR	( MAX_DISTANCE * MAX_DISTANCE )
+
+#define LSTATE_CLEAR		0
+#define LSTATE_WAITING		1
+
+/*
+-------------------------
+NPC_Howler_Precache
+-------------------------
+*/
+void NPC_Howler_Precache( void )
+{
+}
+
+
+/*
+-------------------------
+Howler_Idle
+-------------------------
+*/
+void Howler_Idle( void )
+{
+}
+
+
+/*
+-------------------------
+Howler_Patrol
+-------------------------
+*/
+void Howler_Patrol( void )
+{
+	vec3_t dif;
+
+	NPCInfo->localState = LSTATE_CLEAR;
+
+	//If we have somewhere to go, then do that
+	if ( UpdateGoal() )
+	{
+		ucmd.buttons &= ~BUTTON_WALKING;
+		NPC_MoveToGoal( qtrue );
+	}
+	else
+	{
+		if ( TIMER_Done( NPC, "patrolTime" ))
+		{
+			TIMER_Set( NPC, "patrolTime", crandom() * 5000 + 5000 );
+		}
+	}
+
+	//rwwFIXMEFIXME: Care about all clients, not just client 0
+	VectorSubtract( g_entities[0].r.currentOrigin, NPC->r.currentOrigin, dif );
+
+	if ( VectorLengthSquared( dif ) < 256 * 256 )
+	{
+		G_SetEnemy( NPC, &g_entities[0] );
+	}
+
+	if ( NPC_CheckEnemyExt( qtrue ) == qfalse )
+	{
+		Howler_Idle();
+		return;
+	}
+}
+ 
+/*
+-------------------------
+Howler_Move
+-------------------------
+*/
+void Howler_Move( qboolean visible )
+{
+	if ( NPCInfo->localState != LSTATE_WAITING )
+	{
+		NPCInfo->goalEntity = NPC->enemy;
+		NPC_MoveToGoal( qtrue );
+		NPCInfo->goalRadius = MAX_DISTANCE;	// just get us within combat range
+	}
+}
+
+//---------------------------------------------------------
+void Howler_TryDamage( gentity_t *enemy, int damage )
+{
+	vec3_t	end, dir;
+	trace_t	tr;
+
+	if ( !enemy )
+	{
+		return;
+	}
+
+	AngleVectors( NPC->client->ps.viewangles, dir, NULL, NULL );
+	VectorMA( NPC->r.currentOrigin, MIN_DISTANCE, dir, end );
+
+	// Should probably trace from the mouth, but, ah well.
+	trap_Trace( &tr, NPC->r.currentOrigin, vec3_origin, vec3_origin, end, NPC->s.number, MASK_SHOT );
+
+	if ( tr.entityNum != ENTITYNUM_WORLD )
+	{
+		G_Damage( &g_entities[tr.entityNum], NPC, NPC, dir, tr.endpos, damage, DAMAGE_NO_KNOCKBACK, MOD_MELEE );
+	}
+}
+
+//------------------------------
+void Howler_Attack( void )
+{
+	if ( !TIMER_Exists( NPC, "attacking" ))
+	{
+		// Going to do ATTACK1
+		TIMER_Set( NPC, "attacking", 1700 + random() * 200 );
+		NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_ATTACK1, SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLD );
+
+		TIMER_Set( NPC, "attack_dmg", 200 ); // level two damage
+	}
+
+	// Need to do delayed damage since the attack animations encapsulate multiple mini-attacks
+	if ( TIMER_Done2( NPC, "attack_dmg", qtrue ))
+	{
+		Howler_TryDamage( NPC->enemy, 5 );
+	}
+
+	// Just using this to remove the attacking flag at the right time
+	TIMER_Done2( NPC, "attacking", qtrue );
+}
+
+//----------------------------------
+void Howler_Combat( void )
+{
+	float distance;
+	qboolean advance;
+
+	// If we cannot see our target or we have somewhere to go, then do that
+	if ( !NPC_ClearLOS4( NPC->enemy ) || UpdateGoal( ))
+	{
+		NPCInfo->combatMove = qtrue;
+		NPCInfo->goalEntity = NPC->enemy;
+		NPCInfo->goalRadius = MAX_DISTANCE;	// just get us within combat range
+
+		NPC_MoveToGoal( qtrue );
+		return;
+	}
+
+	// Sometimes I have problems with facing the enemy I'm attacking, so force the issue so I don't look dumb
+	NPC_FaceEnemy( qtrue );
+
+	distance	= DistanceHorizontalSquared( NPC->r.currentOrigin, NPC->enemy->r.currentOrigin );	
+	advance = (qboolean)( distance > MIN_DISTANCE_SQR ? qtrue : qfalse  );
+
+	if (( advance || NPCInfo->localState == LSTATE_WAITING ) && TIMER_Done( NPC, "attacking" )) // waiting monsters can't attack
+	{
+		if ( TIMER_Done2( NPC, "takingPain", qtrue ))
+		{
+			NPCInfo->localState = LSTATE_CLEAR;
+		}
+		else
+		{
+			Howler_Move( 1 );
+		}
+	}
+	else
+	{
+		Howler_Attack();
+	}
+}
+
+/*
+-------------------------
+NPC_Howler_Pain
+-------------------------
+*/
+void NPC_Howler_Pain( gentity_t *self, gentity_t *attacker, int damage ) 
+{
+	if ( damage >= 10 )
+	{
+		TIMER_Remove( self, "attacking" );
+		TIMER_Set( self, "takingPain", 2900 );
+
+		VectorCopy( self->NPC->lastPathAngles, self->s.angles );
+
+		NPC_SetAnim( self, SETANIM_BOTH, BOTH_PAIN1, SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLD );
+
+		if ( self->NPC )
+		{
+			self->NPC->localState = LSTATE_WAITING;
+		}
+	}
+}
+
+
+/*
+-------------------------
+NPC_BSHowler_Default
+-------------------------
+*/
+void NPC_BSHowler_Default( void )
+{
+	if ( NPC->enemy )
+	{
+		Howler_Combat();
+	}
+	else if ( NPCInfo->scriptFlags & SCF_LOOK_FOR_ENEMIES )
+	{
+		Howler_Patrol();
+	}
+	else
+	{
+		Howler_Idle();
+	}
+
+	NPC_UpdateAngles( qtrue, qtrue );
+}
diff --git a/codemp/game/NPC_AI_ImperialProbe.c b/codemp/game/NPC_AI_ImperialProbe.c
new file mode 100644
index 0000000..a6b9714
--- /dev/null
+++ b/codemp/game/NPC_AI_ImperialProbe.c
@@ -0,0 +1,609 @@
+#include "b_local.h"
+#include "g_nav.h"
+
+#include "../namespace_begin.h"
+gitem_t	*BG_FindItemForAmmo( ammo_t ammo );
+#include "../namespace_end.h"
+extern void G_SoundOnEnt( gentity_t *ent, soundChannel_t channel, const char *soundPath );
+
+//Local state enums
+enum
+{
+	LSTATE_NONE = 0,
+	LSTATE_BACKINGUP,
+	LSTATE_SPINNING,
+	LSTATE_PAIN,
+	LSTATE_DROP
+};
+
+void ImperialProbe_Idle( void );
+
+void NPC_Probe_Precache(void)
+{
+	int i;
+
+	for ( i = 1; i < 4; i++)
+	{
+		G_SoundIndex( va( "sound/chars/probe/misc/probetalk%d", i ) );
+	}
+	G_SoundIndex( "sound/chars/probe/misc/probedroidloop" );
+	G_SoundIndex("sound/chars/probe/misc/anger1");
+	G_SoundIndex("sound/chars/probe/misc/fire");
+
+	G_EffectIndex( "chunks/probehead" );
+	G_EffectIndex( "env/med_explode2" );
+	G_EffectIndex( "explosions/probeexplosion1");
+	G_EffectIndex( "bryar/muzzle_flash" );
+
+	RegisterItem( BG_FindItemForAmmo( AMMO_BLASTER ));
+	RegisterItem( BG_FindItemForWeapon( WP_BRYAR_PISTOL ) );
+}
+/*
+-------------------------
+Hunter_MaintainHeight
+-------------------------
+*/
+
+#define VELOCITY_DECAY	0.85f
+
+void ImperialProbe_MaintainHeight( void )
+{	
+	float	dif;
+//	vec3_t	endPos;
+//	trace_t	trace;
+
+	// Update our angles regardless
+	NPC_UpdateAngles( qtrue, qtrue );
+
+	// If we have an enemy, we should try to hover at about enemy eye level
+	if ( NPC->enemy )
+	{
+		// Find the height difference
+		dif = NPC->enemy->r.currentOrigin[2] - NPC->r.currentOrigin[2]; 
+
+		// cap to prevent dramatic height shifts
+		if ( fabs( dif ) > 8 )
+		{
+			if ( fabs( dif ) > 16 )
+			{
+				dif = ( dif < 0 ? -16 : 16 );
+			}
+
+			NPC->client->ps.velocity[2] = (NPC->client->ps.velocity[2]+dif)/2;
+		}
+	}
+	else
+	{
+		gentity_t *goal = NULL;
+
+		if ( NPCInfo->goalEntity )	// Is there a goal?
+		{
+			goal = NPCInfo->goalEntity;
+		}
+		else
+		{
+			goal = NPCInfo->lastGoalEntity;
+		}
+		if ( goal )
+		{
+			dif = goal->r.currentOrigin[2] - NPC->r.currentOrigin[2];
+
+			if ( fabs( dif ) > 24 )
+			{
+				ucmd.upmove = ( ucmd.upmove < 0 ? -4 : 4 );
+			}
+			else
+			{
+				if ( NPC->client->ps.velocity[2] )
+				{
+					NPC->client->ps.velocity[2] *= VELOCITY_DECAY;
+
+					if ( fabs( NPC->client->ps.velocity[2] ) < 2 )
+					{
+						NPC->client->ps.velocity[2] = 0;
+					}
+				}
+			}
+		}
+		// Apply friction
+		else if ( NPC->client->ps.velocity[2] )
+		{
+			NPC->client->ps.velocity[2] *= VELOCITY_DECAY;
+
+			if ( fabs( NPC->client->ps.velocity[2] ) < 1 )
+			{
+				NPC->client->ps.velocity[2] = 0;
+			}
+		}
+
+		// Stay at a given height until we take on an enemy
+/*		VectorSet( endPos, NPC->r.currentOrigin[0], NPC->r.currentOrigin[1], NPC->r.currentOrigin[2] - 512 );
+		trap_Trace( &trace, NPC->r.currentOrigin, NULL, NULL, endPos, NPC->s.number, MASK_SOLID );
+
+		if ( trace.fraction != 1.0f )
+		{
+			float	length = ( trace.fraction * 512 );
+
+			if ( length < 80 )
+			{
+				ucmd.upmove = 32;
+			}
+			else if ( length > 120 )
+			{
+				ucmd.upmove = -32;
+			}
+			else
+			{ 
+				if ( NPC->client->ps.velocity[2] )
+				{
+					NPC->client->ps.velocity[2] *= VELOCITY_DECAY;
+
+					if ( fabs( NPC->client->ps.velocity[2] ) < 1 )
+					{
+						NPC->client->ps.velocity[2] = 0;
+					}
+				}
+			}
+		} */
+	}
+
+	// Apply friction
+	if ( NPC->client->ps.velocity[0] )
+	{
+		NPC->client->ps.velocity[0] *= VELOCITY_DECAY;
+
+		if ( fabs( NPC->client->ps.velocity[0] ) < 1 )
+		{
+			NPC->client->ps.velocity[0] = 0;
+		}
+	}
+
+	if ( NPC->client->ps.velocity[1] )
+	{
+		NPC->client->ps.velocity[1] *= VELOCITY_DECAY;
+
+		if ( fabs( NPC->client->ps.velocity[1] ) < 1 )
+		{
+			NPC->client->ps.velocity[1] = 0;
+		}
+	}
+}
+
+/*
+-------------------------
+ImperialProbe_Strafe
+-------------------------
+*/
+
+#define HUNTER_STRAFE_VEL	256
+#define HUNTER_STRAFE_DIS	200
+#define HUNTER_UPWARD_PUSH	32
+
+void ImperialProbe_Strafe( void )
+{
+	int		dir;
+	vec3_t	end, right;
+	trace_t	tr;
+
+	AngleVectors( NPC->client->renderInfo.eyeAngles, NULL, right, NULL );
+
+	// Pick a random strafe direction, then check to see if doing a strafe would be
+	//	reasonable valid
+	dir = ( rand() & 1 ) ? -1 : 1;
+	VectorMA( NPC->r.currentOrigin, HUNTER_STRAFE_DIS * dir, right, end );
+
+	trap_Trace( &tr, NPC->r.currentOrigin, NULL, NULL, end, NPC->s.number, MASK_SOLID );
+
+	// Close enough
+	if ( tr.fraction > 0.9f )
+	{
+		VectorMA( NPC->client->ps.velocity, HUNTER_STRAFE_VEL * dir, right, NPC->client->ps.velocity );
+
+		// Add a slight upward push
+		NPC->client->ps.velocity[2] += HUNTER_UPWARD_PUSH;
+
+		// Set the strafe start time so we can do a controlled roll
+		//NPC->fx_time = level.time;
+		NPCInfo->standTime = level.time + 3000 + random() * 500;
+	}
+}
+
+/*
+-------------------------
+ImperialProbe_Hunt
+-------------------------`
+*/
+
+#define HUNTER_FORWARD_BASE_SPEED	10
+#define HUNTER_FORWARD_MULTIPLIER	5
+
+void ImperialProbe_Hunt( qboolean visible, qboolean advance )
+{
+	float	distance, speed;
+	vec3_t	forward;
+
+	NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_RUN1, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+
+	//If we're not supposed to stand still, pursue the player
+	if ( NPCInfo->standTime < level.time )
+	{
+		// Only strafe when we can see the player
+		if ( visible )
+		{
+			ImperialProbe_Strafe();
+			return;
+		}
+	}
+
+	//If we don't want to advance, stop here
+	if ( advance == qfalse )
+		return;
+
+	//Only try and navigate if the player is visible
+	if ( visible == qfalse )
+	{
+		// Move towards our goal
+		NPCInfo->goalEntity = NPC->enemy;
+		NPCInfo->goalRadius = 12;
+
+		//Get our direction from the navigator if we can't see our target
+		if ( NPC_GetMoveDirection( forward, &distance ) == qfalse )
+			return;
+	}
+	else
+	{
+		VectorSubtract( NPC->enemy->r.currentOrigin, NPC->r.currentOrigin, forward );
+		distance = VectorNormalize( forward );
+	}
+
+	speed = HUNTER_FORWARD_BASE_SPEED + HUNTER_FORWARD_MULTIPLIER * g_spskill.integer;
+	VectorMA( NPC->client->ps.velocity, speed, forward, NPC->client->ps.velocity );
+}
+
+/*
+-------------------------
+ImperialProbe_FireBlaster
+-------------------------
+*/
+void ImperialProbe_FireBlaster(void)
+{
+	vec3_t	muzzle1,enemy_org1,delta1,angleToEnemy1;
+	static	vec3_t	forward, vright, up;
+	static	vec3_t	muzzle;
+	int genBolt1;
+	gentity_t	*missile;
+	mdxaBone_t	boltMatrix;
+
+	genBolt1 = trap_G2API_AddBolt(NPC->ghoul2, 0, "*flash");
+
+	//FIXME: use {0, NPC->client->ps.legsYaw, 0}
+	trap_G2API_GetBoltMatrix( NPC->ghoul2, 0, 
+				genBolt1,
+				&boltMatrix, NPC->r.currentAngles, NPC->r.currentOrigin, level.time,
+				NULL, NPC->modelScale );
+
+	BG_GiveMeVectorFromMatrix( &boltMatrix, ORIGIN, muzzle1 );
+
+	G_PlayEffectID( G_EffectIndex("bryar/muzzle_flash"), muzzle1, vec3_origin );
+
+	G_Sound( NPC, CHAN_AUTO, G_SoundIndex( "sound/chars/probe/misc/fire" ));
+
+	if (NPC->health)
+	{
+		CalcEntitySpot( NPC->enemy, SPOT_CHEST, enemy_org1 );
+		enemy_org1[0]+= Q_irand(0,10);
+		enemy_org1[1]+= Q_irand(0,10);
+		VectorSubtract (enemy_org1, muzzle1, delta1);
+		vectoangles ( delta1, angleToEnemy1 );
+		AngleVectors (angleToEnemy1, forward, vright, up);
+	}
+	else
+	{
+		AngleVectors (NPC->r.currentAngles, forward, vright, up);
+	}
+
+	missile = CreateMissile( muzzle1, forward, 1600, 10000, NPC, qfalse );
+
+	missile->classname = "bryar_proj";
+	missile->s.weapon = WP_BRYAR_PISTOL;
+
+	if ( g_spskill.integer <= 1 )
+	{
+		missile->damage = 5;
+	}
+	else 
+	{
+		missile->damage = 10;
+	}
+
+
+	missile->dflags = DAMAGE_DEATH_KNOCKBACK;
+	missile->methodOfDeath = MOD_UNKNOWN;
+	missile->clipmask = MASK_SHOT | CONTENTS_LIGHTSABER;
+
+}
+
+/*
+-------------------------
+ImperialProbe_Ranged
+-------------------------
+*/
+void ImperialProbe_Ranged( qboolean visible, qboolean advance )
+{
+	int	delay_min,delay_max;
+
+	if ( TIMER_Done( NPC, "attackDelay" ) )	// Attack?
+	{
+
+		if ( g_spskill.integer == 0 )
+		{
+			delay_min = 500;
+			delay_max = 3000;
+		}
+		else if ( g_spskill.integer > 1 )
+		{
+			delay_min = 500;
+			delay_max = 2000;
+		}
+		else
+		{
+			delay_min = 300;
+			delay_max = 1500;
+		}
+
+		TIMER_Set( NPC, "attackDelay", Q_irand( 500, 3000 ) );
+		ImperialProbe_FireBlaster();
+//		ucmd.buttons |= BUTTON_ATTACK;
+	}
+
+	if ( NPCInfo->scriptFlags & SCF_CHASE_ENEMIES )
+	{
+		ImperialProbe_Hunt( visible, advance );
+	}
+}
+
+/*
+-------------------------
+ImperialProbe_AttackDecision
+-------------------------
+*/
+
+#define	MIN_MELEE_RANGE		320
+#define	MIN_MELEE_RANGE_SQR	( MIN_MELEE_RANGE * MIN_MELEE_RANGE )
+
+#define MIN_DISTANCE		128
+#define MIN_DISTANCE_SQR	( MIN_DISTANCE * MIN_DISTANCE )
+
+void ImperialProbe_AttackDecision( void )
+{
+	float		distance;	
+	qboolean	visible;
+	qboolean	advance;
+
+	// Always keep a good height off the ground
+	ImperialProbe_MaintainHeight();
+
+	//randomly talk
+	if ( TIMER_Done(NPC,"patrolNoise") )
+	{
+		if (TIMER_Done(NPC,"angerNoise"))
+		{
+			G_SoundOnEnt( NPC, CHAN_AUTO, va("sound/chars/probe/misc/probetalk%d", Q_irand(1, 3)) );
+
+			TIMER_Set( NPC, "patrolNoise", Q_irand( 4000, 10000 ) );
+		}
+	}
+
+	// If we don't have an enemy, just idle
+	if ( NPC_CheckEnemyExt(qfalse) == qfalse )
+	{
+		ImperialProbe_Idle();
+		return;
+	}
+
+	NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_RUN1, SETANIM_FLAG_NORMAL);
+
+	// Rate our distance to the target, and our visibilty
+	distance	= (int) DistanceHorizontalSquared( NPC->r.currentOrigin, NPC->enemy->r.currentOrigin );	
+	visible		= NPC_ClearLOS4( NPC->enemy );
+	advance		= (qboolean)(distance > MIN_DISTANCE_SQR);
+
+	// If we cannot see our target, move to see it
+	if ( visible == qfalse )
+	{
+		if ( NPCInfo->scriptFlags & SCF_CHASE_ENEMIES )
+		{
+			ImperialProbe_Hunt( visible, advance );
+			return;
+		}
+	}
+
+	// Sometimes I have problems with facing the enemy I'm attacking, so force the issue so I don't look dumb
+	NPC_FaceEnemy( qtrue );
+
+	// Decide what type of attack to do
+	ImperialProbe_Ranged( visible, advance );
+}
+
+/*
+-------------------------
+NPC_BSDroid_Pain
+-------------------------
+*/
+void NPC_Probe_Pain(gentity_t *self, gentity_t *attacker, int damage)
+{
+	float	pain_chance;
+	gentity_t *other = attacker;
+	int mod = gPainMOD;
+	
+	VectorCopy( self->NPC->lastPathAngles, self->s.angles );
+
+	if ( self->health < 30 || mod == MOD_DEMP2 || mod == MOD_DEMP2_ALT ) // demp2 always messes them up real good
+	{
+		vec3_t endPos;
+		trace_t	trace;
+
+		VectorSet( endPos, self->r.currentOrigin[0], self->r.currentOrigin[1], self->r.currentOrigin[2] - 128 );
+		trap_Trace( &trace, self->r.currentOrigin, NULL, NULL, endPos, self->s.number, MASK_SOLID );
+
+		if ( trace.fraction == 1.0f || mod == MOD_DEMP2 ) // demp2 always does this
+		{
+			/*
+			if (self->client->clientInfo.headModel != 0)
+			{
+				vec3_t origin;
+
+				VectorCopy(self->r.currentOrigin,origin);
+				origin[2] +=50;
+//				G_PlayEffect( "small_chunks", origin );
+				G_PlayEffect( "chunks/probehead", origin );
+				G_PlayEffect( "env/med_explode2", origin );
+				self->client->clientInfo.headModel = 0;
+				self->client->moveType = MT_RUNJUMP;
+				self->client->ps.gravity = g_gravity->value*.1;
+			}
+			*/
+			
+			if ( (mod == MOD_DEMP2 || mod == MOD_DEMP2_ALT) && other )
+			{
+				vec3_t dir;
+
+				NPC_SetAnim( self, SETANIM_BOTH, BOTH_PAIN1, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD);
+
+				VectorSubtract( self->r.currentOrigin, other->r.currentOrigin, dir );
+				VectorNormalize( dir );
+
+				VectorMA( self->client->ps.velocity, 550, dir, self->client->ps.velocity );
+				self->client->ps.velocity[2] -= 127;
+			}
+
+			//self->s.powerups |= ( 1 << PW_SHOCKED );
+			//self->client->ps.powerups[PW_SHOCKED] = level.time + 3000;
+			self->client->ps.electrifyTime = level.time + 3000;
+
+			self->NPC->localState = LSTATE_DROP;
+		} 
+	}
+	else
+	{
+		pain_chance = NPC_GetPainChance( self, damage );
+
+		if ( random() < pain_chance )	// Spin around in pain?
+		{
+			NPC_SetAnim( self, SETANIM_BOTH, BOTH_PAIN1, SETANIM_FLAG_OVERRIDE);
+		}	
+	}
+
+	NPC_Pain( self, attacker, damage );
+}
+
+/*
+-------------------------
+ImperialProbe_Idle
+-------------------------
+*/
+
+void ImperialProbe_Idle( void )
+{
+	ImperialProbe_MaintainHeight();
+
+	NPC_BSIdle();
+}
+
+/*
+-------------------------
+NPC_BSImperialProbe_Patrol
+-------------------------
+*/
+void ImperialProbe_Patrol( void )
+{
+	ImperialProbe_MaintainHeight();
+
+	if ( NPC_CheckPlayerTeamStealth() )
+	{
+		NPC_UpdateAngles( qtrue, qtrue );
+		return;
+	}
+
+	//If we have somewhere to go, then do that
+	if (!NPC->enemy)
+	{
+		NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_RUN1, SETANIM_FLAG_NORMAL );
+
+		if ( UpdateGoal() )
+		{
+			//start loop sound once we move
+			NPC->s.loopSound = G_SoundIndex( "sound/chars/probe/misc/probedroidloop" );
+			ucmd.buttons |= BUTTON_WALKING;
+			NPC_MoveToGoal( qtrue );
+		}
+		//randomly talk
+		if (TIMER_Done(NPC,"patrolNoise"))
+		{
+			G_SoundOnEnt( NPC, CHAN_AUTO, va("sound/chars/probe/misc/probetalk%d", Q_irand(1, 3)) );
+
+			TIMER_Set( NPC, "patrolNoise", Q_irand( 2000, 4000 ) );
+		}
+	}
+	else	// He's got an enemy. Make him angry.
+	{
+		G_SoundOnEnt( NPC, CHAN_AUTO, "sound/chars/probe/misc/anger1" );
+		TIMER_Set( NPC, "angerNoise", Q_irand( 2000, 4000 ) );
+		//NPCInfo->behaviorState = BS_HUNT_AND_KILL;
+	}
+
+	NPC_UpdateAngles( qtrue, qtrue );
+}
+
+/*
+-------------------------
+ImperialProbe_Wait
+-------------------------
+*/
+void ImperialProbe_Wait(void)
+{
+	if ( NPCInfo->localState == LSTATE_DROP )
+	{
+		vec3_t endPos;
+		trace_t	trace;
+
+		NPCInfo->desiredYaw = AngleNormalize360( NPCInfo->desiredYaw + 25 );
+
+		VectorSet( endPos, NPC->r.currentOrigin[0], NPC->r.currentOrigin[1], NPC->r.currentOrigin[2] - 32 );
+		trap_Trace( &trace, NPC->r.currentOrigin, NULL, NULL, endPos, NPC->s.number, MASK_SOLID );
+
+		if ( trace.fraction != 1.0f )
+		{
+			G_Damage(NPC, NPC->enemy, NPC->enemy, NULL, NULL, 2000, 0,MOD_UNKNOWN); 
+		} 
+	}
+
+	NPC_UpdateAngles( qtrue, qtrue );
+}
+
+/*
+-------------------------
+NPC_BSImperialProbe_Default
+-------------------------
+*/
+void NPC_BSImperialProbe_Default( void )
+{
+
+	if ( NPC->enemy )
+	{
+		NPCInfo->goalEntity = NPC->enemy;
+		ImperialProbe_AttackDecision();
+	}
+	else if ( NPCInfo->scriptFlags & SCF_LOOK_FOR_ENEMIES )
+	{
+		ImperialProbe_Patrol();
+	}
+	else if ( NPCInfo->localState == LSTATE_DROP )
+	{
+		ImperialProbe_Wait();
+	}
+	else
+	{
+		ImperialProbe_Idle();
+	}
+}
diff --git a/codemp/game/NPC_AI_Interrogator.c b/codemp/game/NPC_AI_Interrogator.c
new file mode 100644
index 0000000..2b9131d
--- /dev/null
+++ b/codemp/game/NPC_AI_Interrogator.c
@@ -0,0 +1,467 @@
+#include "b_local.h"
+#include "g_nav.h"
+
+void Interrogator_Idle( void );
+void DeathFX( gentity_t *ent );
+extern void G_SoundOnEnt( gentity_t *ent, soundChannel_t channel, const char *soundPath );
+
+enum
+{
+LSTATE_BLADESTOP=0,
+LSTATE_BLADEUP,
+LSTATE_BLADEDOWN,
+};
+
+/*
+-------------------------
+NPC_Interrogator_Precache
+-------------------------
+*/
+void NPC_Interrogator_Precache(gentity_t *self)
+{
+	G_SoundIndex( "sound/chars/interrogator/misc/torture_droid_lp" );
+	G_SoundIndex("sound/chars/mark1/misc/anger.wav");
+	G_SoundIndex( "sound/chars/probe/misc/talk");
+	G_SoundIndex( "sound/chars/interrogator/misc/torture_droid_inject" );
+	G_SoundIndex( "sound/chars/interrogator/misc/int_droid_explo" );
+	G_EffectIndex( "explosions/droidexplosion1" );
+}
+/*
+-------------------------
+Interrogator_die
+-------------------------
+*/
+void Interrogator_die( gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int mod,int dFlags,int hitLoc )
+{
+	self->client->ps.velocity[2] = -100;
+	/*
+	self->locationDamage[HL_NONE] += damage;
+	if (self->locationDamage[HL_NONE] > 40)
+	{
+		DeathFX(self);
+		self->client->ps.eFlags |= EF_NODRAW;
+		self->contents = CONTENTS_CORPSE;
+	}
+	else
+	*/
+	{
+		self->client->ps.eFlags2 &= ~EF2_FLYING;//moveType = MT_WALK;
+		self->client->ps.velocity[0] = Q_irand( -10, -20 );
+		self->client->ps.velocity[1] = Q_irand( -10, -20 );
+		self->client->ps.velocity[2] = -100;
+	}
+	//self->takedamage = qfalse;
+	//self->client->ps.eFlags |= EF_NODRAW;
+	//self->contents = 0;
+	return;
+}
+
+/*
+-------------------------
+Interrogator_PartsMove
+-------------------------
+*/
+void Interrogator_PartsMove(void)
+{
+	// Syringe
+	if ( TIMER_Done(NPC,"syringeDelay") )
+	{
+		NPC->pos1[1] = AngleNormalize360( NPC->pos1[1]);
+
+		if ((NPC->pos1[1] < 60) || (NPC->pos1[1] > 300))
+		{
+			NPC->pos1[1]+=Q_irand( -20, 20 );	// Pitch	
+		}
+		else if (NPC->pos1[1] > 180)
+		{
+			NPC->pos1[1]=Q_irand( 300, 360 );	// Pitch	
+		}
+		else 
+		{
+			NPC->pos1[1]=Q_irand( 0, 60 );	// Pitch	
+		}
+
+	//	gi.G2API_SetBoneAnglesIndex( &NPC->ghoul2[NPC->playerModel], NPC->genericBone1, NPC->pos1, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, NULL ); 
+		NPC_SetBoneAngles(NPC, "left_arm", NPC->pos1);
+
+		TIMER_Set( NPC, "syringeDelay", Q_irand( 100, 1000 ) );
+	}
+
+	// Scalpel
+	if ( TIMER_Done(NPC,"scalpelDelay") )
+	{
+		// Change pitch
+		if ( NPCInfo->localState == LSTATE_BLADEDOWN )	// Blade is moving down
+		{
+			NPC->pos2[0]-= 30;
+			if (NPC->pos2[0] < 180)
+			{
+				NPC->pos2[0] = 180;
+				NPCInfo->localState = LSTATE_BLADEUP;	// Make it move up
+			}
+		}
+		else											// Blade is coming back up
+		{
+			NPC->pos2[0]+= 30;
+			if (NPC->pos2[0] >= 360)
+			{
+				NPC->pos2[0] = 360;
+				NPCInfo->localState = LSTATE_BLADEDOWN;	// Make it move down
+				TIMER_Set( NPC, "scalpelDelay", Q_irand( 100, 1000 ) );
+			}
+		}
+
+		NPC->pos2[0] = AngleNormalize360( NPC->pos2[0]);
+	//	gi.G2API_SetBoneAnglesIndex( &NPC->ghoul2[NPC->playerModel], NPC->genericBone2, NPC->pos2, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, NULL ); 
+
+		NPC_SetBoneAngles(NPC, "right_arm", NPC->pos2);
+	}
+
+	// Claw
+	NPC->pos3[1] += Q_irand( 10, 30 );
+	NPC->pos3[1] = AngleNormalize360( NPC->pos3[1]);
+	//gi.G2API_SetBoneAnglesIndex( &NPC->ghoul2[NPC->playerModel], NPC->genericBone3, NPC->pos3, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, NULL ); 
+
+	NPC_SetBoneAngles(NPC, "claw", NPC->pos3);
+
+}
+
+#define VELOCITY_DECAY	0.85f
+#define HUNTER_UPWARD_PUSH	2
+
+/*
+-------------------------
+Interrogator_MaintainHeight
+-------------------------
+*/
+void Interrogator_MaintainHeight( void )
+{	
+	float	dif;
+//	vec3_t	endPos;
+//	trace_t	trace;
+
+	NPC->s.loopSound = G_SoundIndex( "sound/chars/interrogator/misc/torture_droid_lp" );
+	// Update our angles regardless
+	NPC_UpdateAngles( qtrue, qtrue );
+
+	// If we have an enemy, we should try to hover at about enemy eye level
+	if ( NPC->enemy )
+	{
+		// Find the height difference
+		dif = (NPC->enemy->r.currentOrigin[2] + NPC->enemy->r.maxs[2]) - NPC->r.currentOrigin[2]; 
+
+		// cap to prevent dramatic height shifts
+		if ( fabs( dif ) > 2 )
+		{
+			if ( fabs( dif ) > 16 )
+			{
+				dif = ( dif < 0 ? -16 : 16 );
+			}
+
+			NPC->client->ps.velocity[2] = (NPC->client->ps.velocity[2]+dif)/2;
+		}
+	}
+	else
+	{
+		gentity_t *goal = NULL;
+
+		if ( NPCInfo->goalEntity )	// Is there a goal?
+		{
+			goal = NPCInfo->goalEntity;
+		}
+		else
+		{
+			goal = NPCInfo->lastGoalEntity;
+		}
+		if ( goal )
+		{
+			dif = goal->r.currentOrigin[2] - NPC->r.currentOrigin[2];
+
+			if ( fabs( dif ) > 24 )
+			{
+				ucmd.upmove = ( ucmd.upmove < 0 ? -4 : 4 );
+			}
+			else
+			{
+				if ( NPC->client->ps.velocity[2] )
+				{
+					NPC->client->ps.velocity[2] *= VELOCITY_DECAY;
+
+					if ( fabs( NPC->client->ps.velocity[2] ) < 2 )
+					{
+						NPC->client->ps.velocity[2] = 0;
+					}
+				}
+			}
+		}
+		// Apply friction
+		else if ( NPC->client->ps.velocity[2] )
+		{
+			NPC->client->ps.velocity[2] *= VELOCITY_DECAY;
+
+			if ( fabs( NPC->client->ps.velocity[2] ) < 1 )
+			{
+				NPC->client->ps.velocity[2] = 0;
+			}
+		}
+	}
+
+	// Apply friction
+	if ( NPC->client->ps.velocity[0] )
+	{
+		NPC->client->ps.velocity[0] *= VELOCITY_DECAY;
+
+		if ( fabs( NPC->client->ps.velocity[0] ) < 1 )
+		{
+			NPC->client->ps.velocity[0] = 0;
+		}
+	}
+
+	if ( NPC->client->ps.velocity[1] )
+	{
+		NPC->client->ps.velocity[1] *= VELOCITY_DECAY;
+
+		if ( fabs( NPC->client->ps.velocity[1] ) < 1 )
+		{
+			NPC->client->ps.velocity[1] = 0;
+		}
+	}
+}
+
+#define HUNTER_STRAFE_VEL	32
+#define HUNTER_STRAFE_DIS	200
+/*
+-------------------------
+Interrogator_Strafe
+-------------------------
+*/
+void Interrogator_Strafe( void )
+{
+	int		dir;
+	vec3_t	end, right;
+	trace_t	tr;
+	float	dif;
+
+	AngleVectors( NPC->client->renderInfo.eyeAngles, NULL, right, NULL );
+
+	// Pick a random strafe direction, then check to see if doing a strafe would be
+	//	reasonable valid
+	dir = ( rand() & 1 ) ? -1 : 1;
+	VectorMA( NPC->r.currentOrigin, HUNTER_STRAFE_DIS * dir, right, end );
+
+	trap_Trace( &tr, NPC->r.currentOrigin, NULL, NULL, end, NPC->s.number, MASK_SOLID );
+
+	// Close enough
+	if ( tr.fraction > 0.9f )
+	{
+		VectorMA( NPC->client->ps.velocity, HUNTER_STRAFE_VEL * dir, right, NPC->client->ps.velocity );
+
+		// Add a slight upward push
+		if ( NPC->enemy )
+		{
+			// Find the height difference
+			dif = (NPC->enemy->r.currentOrigin[2] + 32) - NPC->r.currentOrigin[2]; 
+
+			// cap to prevent dramatic height shifts
+			if ( fabs( dif ) > 8 )
+			{
+				dif = ( dif < 0 ? -HUNTER_UPWARD_PUSH : HUNTER_UPWARD_PUSH );
+			}
+
+			NPC->client->ps.velocity[2] += dif;
+
+		}
+
+		// Set the strafe start time 
+		//NPC->fx_time = level.time;
+		NPCInfo->standTime = level.time + 3000 + random() * 500;
+	}
+}
+
+/*
+-------------------------
+Interrogator_Hunt
+-------------------------`
+*/
+
+#define HUNTER_FORWARD_BASE_SPEED	10
+#define HUNTER_FORWARD_MULTIPLIER	2
+
+void Interrogator_Hunt( qboolean visible, qboolean advance )
+{
+	float	distance, speed;
+	vec3_t	forward;
+
+	Interrogator_PartsMove();
+
+	NPC_FaceEnemy(qfalse);
+
+	//If we're not supposed to stand still, pursue the player
+	if ( NPCInfo->standTime < level.time )
+	{
+		// Only strafe when we can see the player
+		if ( visible )
+		{
+			Interrogator_Strafe();
+			if ( NPCInfo->standTime > level.time )
+			{//successfully strafed
+				return;
+			}
+		}
+	}
+
+	//If we don't want to advance, stop here
+	if ( advance == qfalse )
+		return;
+
+	//Only try and navigate if the player is visible
+	if ( visible == qfalse )
+	{
+		// Move towards our goal
+		NPCInfo->goalEntity = NPC->enemy;
+		NPCInfo->goalRadius = 12;
+
+		//Get our direction from the navigator if we can't see our target
+		if ( NPC_GetMoveDirection( forward, &distance ) == qfalse )
+			return;
+	}
+	else
+	{
+		VectorSubtract( NPC->enemy->r.currentOrigin, NPC->r.currentOrigin, forward );
+		distance = VectorNormalize( forward );
+	}
+
+	speed = HUNTER_FORWARD_BASE_SPEED + HUNTER_FORWARD_MULTIPLIER * g_spskill.integer;
+	VectorMA( NPC->client->ps.velocity, speed, forward, NPC->client->ps.velocity );
+}
+
+#define MIN_DISTANCE		64
+
+/*
+-------------------------
+Interrogator_Melee
+-------------------------
+*/
+void Interrogator_Melee( qboolean visible, qboolean advance )
+{
+	if ( TIMER_Done( NPC, "attackDelay" ) )	// Attack?
+	{
+		// Make sure that we are within the height range before we allow any damage to happen
+		if ( NPC->r.currentOrigin[2] >= NPC->enemy->r.currentOrigin[2]+NPC->enemy->r.mins[2] && NPC->r.currentOrigin[2]+NPC->r.mins[2]+8 < NPC->enemy->r.currentOrigin[2]+NPC->enemy->r.maxs[2] )
+		{
+			//gentity_t *tent;
+
+			TIMER_Set( NPC, "attackDelay", Q_irand( 500, 3000 ) );
+			G_Damage( NPC->enemy, NPC, NPC, 0, 0, 2, DAMAGE_NO_KNOCKBACK, MOD_MELEE );
+
+		//	NPC->enemy->client->poisonDamage = 18;
+		//	NPC->enemy->client->poisonTime = level.time + 1000;
+
+			// Drug our enemy up and do the wonky vision thing
+//			tent = G_TempEntity( NPC->enemy->r.currentOrigin, EV_DRUGGED );
+//			tent->owner = NPC->enemy;
+
+			//rwwFIXMEFIXME: poison damage
+
+			G_Sound( NPC, CHAN_AUTO, G_SoundIndex( "sound/chars/interrogator/misc/torture_droid_inject.mp3" ));
+		}
+	}
+
+	if ( NPCInfo->scriptFlags & SCF_CHASE_ENEMIES )
+	{
+		Interrogator_Hunt( visible, advance );
+	}
+}
+
+/*
+-------------------------
+Interrogator_Attack
+-------------------------
+*/
+void Interrogator_Attack( void )
+{
+	float		distance;	
+	qboolean	visible;
+	qboolean	advance;
+
+	// Always keep a good height off the ground
+	Interrogator_MaintainHeight();
+
+	//randomly talk
+	if ( TIMER_Done(NPC,"patrolNoise") )
+	{
+		if (TIMER_Done(NPC,"angerNoise"))
+		{
+			G_SoundOnEnt( NPC, CHAN_AUTO, va("sound/chars/probe/misc/talk.wav",	Q_irand(1, 3)) );
+
+			TIMER_Set( NPC, "patrolNoise", Q_irand( 4000, 10000 ) );
+		}
+	}
+
+	// If we don't have an enemy, just idle
+	if ( NPC_CheckEnemyExt(qfalse) == qfalse )
+	{
+		Interrogator_Idle();
+		return;
+	}
+
+	// Rate our distance to the target, and our visibilty
+	distance	= (int) DistanceHorizontalSquared( NPC->r.currentOrigin, NPC->enemy->r.currentOrigin );	
+	visible		= NPC_ClearLOS4( NPC->enemy );
+	advance		= (qboolean)(distance > MIN_DISTANCE*MIN_DISTANCE );
+
+	if ( !visible )
+	{
+		advance = qtrue;
+	}
+	if ( NPCInfo->scriptFlags & SCF_CHASE_ENEMIES )
+	{
+		Interrogator_Hunt( visible, advance );
+	}
+
+	NPC_FaceEnemy( qtrue );
+
+	if (!advance)
+	{
+		Interrogator_Melee( visible, advance );
+	}
+}
+
+/*
+-------------------------
+Interrogator_Idle
+-------------------------
+*/
+void Interrogator_Idle( void )
+{
+	if ( NPC_CheckPlayerTeamStealth() )
+	{
+		G_SoundOnEnt( NPC, CHAN_AUTO, "sound/chars/mark1/misc/anger.wav" );
+		NPC_UpdateAngles( qtrue, qtrue );
+		return;
+	}
+
+	Interrogator_MaintainHeight();
+
+	NPC_BSIdle();
+}
+
+/*
+-------------------------
+NPC_BSInterrogator_Default
+-------------------------
+*/
+void NPC_BSInterrogator_Default( void )
+{
+	//NPC->e_DieFunc = dieF_Interrogator_die;
+
+	if ( NPC->enemy )
+	{
+		Interrogator_Attack();
+	}
+	else
+	{
+		Interrogator_Idle();
+	}
+
+}
diff --git a/codemp/game/NPC_AI_Jedi.c b/codemp/game/NPC_AI_Jedi.c
new file mode 100644
index 0000000..9667768
--- /dev/null
+++ b/codemp/game/NPC_AI_Jedi.c
@@ -0,0 +1,6168 @@
+#include "b_local.h"
+#include "g_nav.h"
+#include "anims.h"
+#include "w_saber.h"
+
+#include "../namespace_begin.h"
+extern qboolean BG_SabersOff( playerState_t *ps );
+#include "../namespace_end.h"
+
+extern void CG_DrawAlert( vec3_t origin, float rating );
+extern void G_AddVoiceEvent( gentity_t *self, int event, int speakDebounceTime );
+extern void ForceJump( gentity_t *self, usercmd_t *ucmd );
+extern vmCvar_t	g_saberRealisticCombat;
+extern vmCvar_t	d_slowmodeath;
+
+void G_StartMatrixEffect( gentity_t *ent )
+{ //perhaps write this at some point?
+
+}
+
+#define	MAX_VIEW_DIST		2048
+#define MAX_VIEW_SPEED		100
+#define	JEDI_MAX_LIGHT_INTENSITY 64
+#define	JEDI_MIN_LIGHT_THRESHOLD 10
+#define	JEDI_MAX_LIGHT_THRESHOLD 50
+
+#define	DISTANCE_SCALE		0.25f
+//#define	DISTANCE_THRESHOLD	0.075f
+#define	SPEED_SCALE			0.25f
+#define	FOV_SCALE			0.5f
+#define	LIGHT_SCALE			0.25f
+
+#define	REALIZE_THRESHOLD	0.6f
+#define CAUTIOUS_THRESHOLD	( REALIZE_THRESHOLD * 0.3 )
+
+#define	MAX_CHECK_THRESHOLD	1
+
+extern void NPC_ClearLookTarget( gentity_t *self );
+extern void NPC_SetLookTarget( gentity_t *self, int entNum, int clearTime );
+extern void NPC_TempLookTarget( gentity_t *self, int lookEntNum, int minLookTime, int maxLookTime );
+extern qboolean G_ExpandPointToBBox( vec3_t point, const vec3_t mins, const vec3_t maxs, int ignore, int clipmask );
+extern qboolean NPC_CheckEnemyStealth( void );
+extern void G_SoundOnEnt( gentity_t *ent, soundChannel_t channel, const char *soundPath );
+
+#include "../namespace_begin.h"
+extern gitem_t	*BG_FindItemForAmmo( ammo_t ammo );
+#include "../namespace_end.h"
+
+extern void ForceThrow( gentity_t *self, qboolean pull );
+extern void ForceLightning( gentity_t *self );
+extern void ForceHeal( gentity_t *self );
+extern void ForceRage( gentity_t *self );
+extern void ForceProtect( gentity_t *self );
+extern void ForceAbsorb( gentity_t *self );
+extern int WP_MissileBlockForBlock( int saberBlock );
+extern qboolean G_GetHitLocFromSurfName( gentity_t *ent, const char *surfName, int *hitLoc, vec3_t point, vec3_t dir, vec3_t bladeDir, int mod );
+extern qboolean WP_ForcePowerUsable( gentity_t *self, forcePowers_t forcePower, int overrideAmt );
+extern qboolean WP_ForcePowerAvailable( gentity_t *self, forcePowers_t forcePower, int overrideAmt );
+extern void WP_ForcePowerStop( gentity_t *self, forcePowers_t forcePower );
+extern void WP_DeactivateSaber( gentity_t *self, qboolean clearLength ); //clearLength = qfalse
+extern void WP_ActivateSaber( gentity_t *self );
+//extern void WP_SaberBlock(gentity_t *saber, vec3_t hitloc);
+
+#include "../namespace_begin.h"
+extern qboolean PM_SaberInStart( int move );
+extern qboolean BG_SaberInSpecialAttack( int anim );
+extern qboolean BG_SaberInAttack( int move );
+extern qboolean PM_SaberInBounce( int move );
+extern qboolean PM_SaberInParry( int move );
+extern qboolean PM_SaberInKnockaway( int move );
+extern qboolean PM_SaberInBrokenParry( int move );
+extern qboolean PM_SaberInDeflect( int move );
+extern qboolean BG_SpinningSaberAnim( int anim );
+extern qboolean BG_FlippingAnim( int anim );
+extern qboolean PM_RollingAnim( int anim );
+extern qboolean PM_InKnockDown( playerState_t *ps );
+extern qboolean BG_InRoll( playerState_t *ps, int anim );
+extern qboolean BG_CrouchAnim( int anim );
+#include "../namespace_end.h"
+
+extern qboolean NPC_SomeoneLookingAtMe(gentity_t *ent);
+
+extern int WP_GetVelocityForForceJump( gentity_t *self, vec3_t jumpVel, usercmd_t *ucmd );
+
+extern void G_TestLine(vec3_t start, vec3_t end, int color, int time);
+
+static void Jedi_Aggression( gentity_t *self, int change );
+qboolean Jedi_WaitingAmbush( gentity_t *self );
+
+#include "../namespace_begin.h"
+extern int bg_parryDebounce[];
+#include "../namespace_end.h"
+
+static int	jediSpeechDebounceTime[TEAM_NUM_TEAMS];//used to stop several jedi from speaking all at once
+//Local state enums
+enum
+{
+	LSTATE_NONE = 0,
+	LSTATE_UNDERFIRE,
+	LSTATE_INVESTIGATE,
+};
+
+void NPC_ShadowTrooper_Precache( void )
+{
+	RegisterItem( BG_FindItemForAmmo( AMMO_FORCE ) );
+	G_SoundIndex( "sound/chars/shadowtrooper/cloak.wav" );
+	G_SoundIndex( "sound/chars/shadowtrooper/decloak.wav" );
+}
+
+void Jedi_ClearTimers( gentity_t *ent )
+{
+	TIMER_Set( ent, "roamTime", 0 );
+	TIMER_Set( ent, "chatter", 0 );
+	TIMER_Set( ent, "strafeLeft", 0 );
+	TIMER_Set( ent, "strafeRight", 0 );
+	TIMER_Set( ent, "noStrafe", 0 );
+	TIMER_Set( ent, "walking", 0 );
+	TIMER_Set( ent, "taunting", 0 );
+	TIMER_Set( ent, "parryTime", 0 );
+	TIMER_Set( ent, "parryReCalcTime", 0 );
+	TIMER_Set( ent, "forceJumpChasing", 0 );
+	TIMER_Set( ent, "jumpChaseDebounce", 0 );
+	TIMER_Set( ent, "moveforward", 0 );
+	TIMER_Set( ent, "moveback", 0 );
+	TIMER_Set( ent, "movenone", 0 );
+	TIMER_Set( ent, "moveright", 0 );
+	TIMER_Set( ent, "moveleft", 0 );
+	TIMER_Set( ent, "movecenter", 0 );
+	TIMER_Set( ent, "saberLevelDebounce", 0 );
+	TIMER_Set( ent, "noRetreat", 0 );
+	TIMER_Set( ent, "holdLightning", 0 );
+	TIMER_Set( ent, "gripping", 0 );
+	TIMER_Set( ent, "draining", 0 );
+	TIMER_Set( ent, "noturn", 0 );
+}
+
+void Jedi_PlayBlockedPushSound( gentity_t *self )
+{
+	if ( !self->s.number )
+	{
+		G_AddVoiceEvent( self, EV_PUSHFAIL, 3000 );
+	}
+	else if ( self->health > 0 && self->NPC && self->NPC->blockedSpeechDebounceTime < level.time )
+	{
+		G_AddVoiceEvent( self, EV_PUSHFAIL, 3000 );
+		self->NPC->blockedSpeechDebounceTime = level.time + 3000;
+	}
+}
+
+void Jedi_PlayDeflectSound( gentity_t *self )
+{
+	if ( !self->s.number )
+	{
+		G_AddVoiceEvent( self, Q_irand( EV_DEFLECT1, EV_DEFLECT3 ), 3000 );
+	}
+	else if ( self->health > 0 && self->NPC && self->NPC->blockedSpeechDebounceTime < level.time )
+	{
+		G_AddVoiceEvent( self, Q_irand( EV_DEFLECT1, EV_DEFLECT3 ), 3000 );
+		self->NPC->blockedSpeechDebounceTime = level.time + 3000;
+	}
+}
+
+void NPC_Jedi_PlayConfusionSound( gentity_t *self )
+{
+	if ( self->health > 0 )
+	{
+		if ( self->client && ( self->client->NPC_class == CLASS_TAVION || self->client->NPC_class == CLASS_DESANN ) )
+		{
+			G_AddVoiceEvent( self, Q_irand( EV_CONFUSE1, EV_CONFUSE3 ), 2000 );
+		}
+		else if ( Q_irand( 0, 1 ) )
+		{
+			G_AddVoiceEvent( self, Q_irand( EV_TAUNT1, EV_TAUNT3 ), 2000 );
+		}
+		else
+		{
+			G_AddVoiceEvent( self, Q_irand( EV_GLOAT1, EV_GLOAT3 ), 2000 );
+		}
+	}
+}
+
+void Boba_Precache( void )
+{
+	G_SoundIndex( "sound/boba/jeton.wav" );
+	G_SoundIndex( "sound/boba/jethover.wav" );
+	G_SoundIndex( "sound/effects/combustfire.mp3" );
+	G_EffectIndex( "boba/jet" );
+	G_EffectIndex( "boba/fthrw" );
+}
+
+extern void G_CreateG2AttachedWeaponModel( gentity_t *ent, const char *weaponModel, int boltNum, int weaponNum );
+extern void ChangeWeapon( gentity_t *ent, int newWeapon );
+void Boba_ChangeWeapon( int wp )
+{
+	if ( NPC->s.weapon == wp )
+	{
+		return;
+	}
+	NPC_ChangeWeapon( wp );
+	G_AddEvent( NPC, EV_GENERAL_SOUND, G_SoundIndex( "sound/weapons/change.wav" ));
+}
+
+void WP_ResistForcePush( gentity_t *self, gentity_t *pusher, qboolean noPenalty )
+{
+	int parts;
+	qboolean runningResist = qfalse;
+
+	if ( !self || self->health <= 0 || !self->client || !pusher || !pusher->client ) 
+	{
+		return;
+	}
+	if ( (!self->s.number || self->client->NPC_class == CLASS_DESANN || !Q_stricmp("Yoda",self->NPC_type) || self->client->NPC_class == CLASS_LUKE)
+		&& (VectorLengthSquared( self->client->ps.velocity ) > 10000 || self->client->ps.fd.forcePowerLevel[FP_PUSH] >= FORCE_LEVEL_3 || self->client->ps.fd.forcePowerLevel[FP_PULL] >= FORCE_LEVEL_3 ) )
+	{
+		runningResist = qtrue;
+	}
+	if ( !runningResist
+		&& self->client->ps.groundEntityNum != ENTITYNUM_NONE 
+		&& !BG_SpinningSaberAnim( self->client->ps.legsAnim ) 
+		&& !BG_FlippingAnim( self->client->ps.legsAnim ) 
+		&& !PM_RollingAnim( self->client->ps.legsAnim ) 
+		&& !PM_InKnockDown( &self->client->ps ) 
+		&& !BG_CrouchAnim( self->client->ps.legsAnim ))
+	{//if on a surface and not in a spin or flip, play full body resist
+		parts = SETANIM_BOTH;
+	}
+	else
+	{//play resist just in torso
+		parts = SETANIM_TORSO;
+	}
+	NPC_SetAnim( self, parts, BOTH_RESISTPUSH, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+	if ( !noPenalty )
+	{
+		char buf[128];
+		float tFVal = 0;
+
+		trap_Cvar_VariableStringBuffer("timescale", buf, sizeof(buf));
+
+		tFVal = atof(buf);
+
+		if ( !runningResist )
+		{
+			VectorClear( self->client->ps.velocity );
+			//still stop them from attacking or moving for a bit, though
+			//FIXME: maybe push just a little (like, slide)?
+			self->client->ps.weaponTime = 1000;
+			if ( self->client->ps.fd.forcePowersActive&(1<<FP_SPEED) )
+			{
+				self->client->ps.weaponTime = floor( self->client->ps.weaponTime * tFVal );
+			}
+			self->client->ps.pm_time = self->client->ps.weaponTime;
+			self->client->ps.pm_flags |= PMF_TIME_KNOCKBACK;
+			//play the full body push effect on me
+			//self->forcePushTime = level.time + 600; // let the push effect last for 600 ms
+			//rwwFIXMEFIXME: Do this?
+		}
+		else
+		{
+			self->client->ps.weaponTime = 600;
+			if ( self->client->ps.fd.forcePowersActive&(1<<FP_SPEED) )
+			{
+				self->client->ps.weaponTime = floor( self->client->ps.weaponTime * tFVal );
+			}
+		}
+	}
+	//play my force push effect on my hand
+	self->client->ps.powerups[PW_DISINT_4] = level.time + self->client->ps.torsoTimer + 500;
+	self->client->ps.powerups[PW_PULL] = 0;
+	Jedi_PlayBlockedPushSound( self );
+}
+
+qboolean Boba_StopKnockdown( gentity_t *self, gentity_t *pusher, vec3_t pushDir, qboolean forceKnockdown ) //forceKnockdown = qfalse
+{
+	vec3_t	pDir, fwd, right, ang;
+	float	fDot, rDot;
+	int		strafeTime;
+
+	if ( self->client->NPC_class != CLASS_BOBAFETT )
+	{
+		return qfalse;
+	}
+
+	if ( (self->client->ps.eFlags2&EF2_FLYING) )//moveType == MT_FLYSWIM )
+	{//can't knock me down when I'm flying
+		return qtrue;
+	}
+
+	VectorSet(ang, 0, self->r.currentAngles[YAW], 0);
+	strafeTime = Q_irand( 1000, 2000 );
+
+	AngleVectors( ang, fwd, right, NULL );
+	VectorNormalize2( pushDir, pDir );
+	fDot = DotProduct( pDir, fwd );
+	rDot = DotProduct( pDir, right );
+
+	if ( Q_irand( 0, 2 ) )
+	{//flip or roll with it
+		usercmd_t	tempCmd;
+		if ( fDot >= 0.4f )
+		{
+			tempCmd.forwardmove = 127;
+			TIMER_Set( self, "moveforward", strafeTime );
+		}
+		else if ( fDot <= -0.4f )
+		{
+			tempCmd.forwardmove = -127;
+			TIMER_Set( self, "moveback", strafeTime );
+		}
+		else if ( rDot > 0 )
+		{
+			tempCmd.rightmove = 127;
+			TIMER_Set( self, "strafeRight", strafeTime );
+			TIMER_Set( self, "strafeLeft", -1 );
+		}
+		else
+		{
+			tempCmd.rightmove = -127;
+			TIMER_Set( self, "strafeLeft", strafeTime );
+			TIMER_Set( self, "strafeRight", -1 );
+		}
+		G_AddEvent( self, EV_JUMP, 0 );
+		if ( !Q_irand( 0, 1 ) )
+		{//flip
+			self->client->ps.fd.forceJumpCharge = 280;//FIXME: calc this intelligently?
+			ForceJump( self, &tempCmd );
+		}
+		else
+		{//roll
+			TIMER_Set( self, "duck", strafeTime );
+		}
+		self->painDebounceTime = 0;//so we do something
+	}
+	else if ( !Q_irand( 0, 1 ) && forceKnockdown )
+	{//resist
+		WP_ResistForcePush( self, pusher, qtrue );
+	}
+	else
+	{//fall down
+		return qfalse;
+	}
+
+	return qtrue;
+}
+
+void Boba_FlyStart( gentity_t *self )
+{//switch to seeker AI for a while
+	if ( TIMER_Done( self, "jetRecharge" ) )
+	{
+		self->client->ps.gravity = 0;
+		if ( self->NPC )
+		{
+			self->NPC->aiFlags |= NPCAI_CUSTOM_GRAVITY;
+		}
+		self->client->ps.eFlags2 |= EF2_FLYING;//moveType = MT_FLYSWIM;
+		self->client->jetPackTime = level.time + Q_irand( 3000, 10000 );
+		//take-off sound
+		G_SoundOnEnt( self, CHAN_ITEM, "sound/boba/jeton.wav" );
+		//jet loop sound
+		self->s.loopSound = G_SoundIndex( "sound/boba/jethover.wav" );
+		if ( self->NPC )
+		{
+			self->count = Q3_INFINITE; // SEEKER shot ammo count
+		}
+	}
+}
+
+void Boba_FlyStop( gentity_t *self )
+{
+	self->client->ps.gravity = g_gravity.value;
+	if ( self->NPC )
+	{
+		self->NPC->aiFlags &= ~NPCAI_CUSTOM_GRAVITY;
+	}
+	self->client->ps.eFlags2 &= ~EF2_FLYING;
+	self->client->jetPackTime = 0;
+	//stop jet loop sound
+	self->s.loopSound = 0;
+	if ( self->NPC )
+	{
+		self->count = 0; // SEEKER shot ammo count
+		TIMER_Set( self, "jetRecharge", Q_irand( 1000, 5000 ) );
+		TIMER_Set( self, "jumpChaseDebounce", Q_irand( 500, 2000 ) );
+	}
+}
+
+qboolean Boba_Flying( gentity_t *self )
+{
+	return ((qboolean)(self->client->ps.eFlags2&EF2_FLYING));//moveType==MT_FLYSWIM));
+}
+
+void Boba_FireFlameThrower( gentity_t *self )
+{
+	int		damage	= Q_irand( 20, 30 );
+	trace_t		tr;
+	gentity_t	*traceEnt = NULL;
+	mdxaBone_t	boltMatrix;
+	vec3_t		start, end, dir, traceMins = {-4, -4, -4}, traceMaxs = {4, 4, 4};
+
+	trap_G2API_GetBoltMatrix( self->ghoul2, 0, self->client->renderInfo.handLBolt,
+			&boltMatrix, self->r.currentAngles, self->r.currentOrigin, level.time,
+			NULL, self->modelScale );
+
+	BG_GiveMeVectorFromMatrix( &boltMatrix, ORIGIN, start );
+	BG_GiveMeVectorFromMatrix( &boltMatrix, NEGATIVE_Y, dir );
+	//G_PlayEffect( "boba/fthrw", start, dir );
+	VectorMA( start, 128, dir, end );
+
+	trap_Trace( &tr, start, traceMins, traceMaxs, end, self->s.number, MASK_SHOT );
+
+	traceEnt = &g_entities[tr.entityNum];
+	if ( tr.entityNum < ENTITYNUM_WORLD && traceEnt->takedamage )
+	{
+		G_Damage( traceEnt, self, self, dir, tr.endpos, damage, DAMAGE_NO_ARMOR|DAMAGE_NO_KNOCKBACK|/*DAMAGE_NO_HIT_LOC|*/DAMAGE_IGNORE_TEAM, MOD_LAVA );
+		//rwwFIXMEFIXME: add DAMAGE_NO_HIT_LOC?
+	}
+}
+
+//extern void SP_fx_explosion_trail( gentity_t *ent );
+void Boba_StartFlameThrower( gentity_t *self )
+{
+	int	flameTime = 4000;//Q_irand( 1000, 3000 );
+	mdxaBone_t	boltMatrix;
+	vec3_t		org, dir;
+
+	self->client->ps.torsoTimer = flameTime;//+1000;
+	if ( self->NPC )
+	{
+		TIMER_Set( self, "nextAttackDelay", flameTime );
+		TIMER_Set( self, "walking", 0 );
+	}
+	TIMER_Set( self, "flameTime", flameTime );
+	/*
+	gentity_t *fire = G_Spawn();
+	if ( fire != NULL )
+	{
+		mdxaBone_t	boltMatrix;
+		vec3_t		org, dir, ang;
+		gi.G2API_GetBoltMatrix( NPC->ghoul2, NPC->playerModel, NPC->handRBolt,
+				&boltMatrix, NPC->r.currentAngles, NPC->r.currentOrigin, (cg.time?cg.time:level.time),
+				NULL, NPC->s.modelScale );
+
+		gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, org );
+		gi.G2API_GiveMeVectorFromMatrix( boltMatrix, NEGATIVE_Y, dir );
+		vectoangles( dir, ang );
+
+		VectorCopy( org, fire->s.origin );
+		VectorCopy( ang, fire->s.angles );
+
+		fire->targetname = "bobafire";
+		SP_fx_explosion_trail( fire );
+		fire->damage = 1;
+		fire->radius = 10;
+		fire->speed = 200;
+		fire->fxID = G_EffectIndex( "boba/fthrw" );//"env/exp_fire_trail" );//"env/small_fire"
+		fx_explosion_trail_link( fire );
+		fx_explosion_trail_use( fire, NPC, NPC );
+
+	}
+	*/
+	G_SoundOnEnt( self, CHAN_WEAPON, "sound/effects/combustfire.mp3" );
+
+	trap_G2API_GetBoltMatrix(NPC->ghoul2, 0, NPC->client->renderInfo.handRBolt, &boltMatrix, NPC->r.currentAngles,
+		NPC->r.currentOrigin, level.time, NULL, NPC->modelScale);
+
+	BG_GiveMeVectorFromMatrix( &boltMatrix, ORIGIN, org );
+	BG_GiveMeVectorFromMatrix( &boltMatrix, NEGATIVE_Y, dir );
+
+	G_PlayEffectID( G_EffectIndex("boba/fthrw"), org, dir);
+}
+
+void Boba_DoFlameThrower( gentity_t *self )
+{
+	NPC_SetAnim( self, SETANIM_TORSO, BOTH_FORCELIGHTNING_HOLD, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+	if ( TIMER_Done( self, "nextAttackDelay" ) && TIMER_Done( self, "flameTime" ) )
+	{
+		Boba_StartFlameThrower( self );
+	}
+	Boba_FireFlameThrower( self );
+}
+
+void Boba_FireDecide( void )
+{
+	qboolean enemyLOS = qfalse;
+	qboolean enemyCS = qfalse;
+	qboolean enemyInFOV = qfalse;
+	//qboolean move = qtrue;
+	qboolean faceEnemy = qfalse;
+	qboolean shoot = qfalse;
+	qboolean hitAlly = qfalse;
+	vec3_t	impactPos;
+	float	enemyDist;
+	float	dot;
+	vec3_t	enemyDir, shootDir;
+
+	if ( NPC->client->ps.groundEntityNum == ENTITYNUM_NONE 
+		&& NPC->client->ps.fd.forceJumpZStart
+		&& !BG_FlippingAnim( NPC->client->ps.legsAnim )
+		&& !Q_irand( 0, 10 ) )
+	{//take off
+		Boba_FlyStart( NPC );
+	}
+
+	if ( !NPC->enemy )
+	{
+		return;
+	}
+
+	/*
+	if ( NPC->enemy->enemy != NPC && NPC->health == NPC->client->pers.maxHealth )
+	{
+		NPCInfo->scriptFlags |= SCF_ALT_FIRE;
+		Boba_ChangeWeapon( WP_DISRUPTOR );
+	}
+	else */if ( NPC->enemy->s.weapon == WP_SABER )
+	{
+		NPCInfo->scriptFlags &= ~SCF_ALT_FIRE;
+		Boba_ChangeWeapon( WP_ROCKET_LAUNCHER );
+	}
+	else
+	{
+		if ( NPC->health < NPC->client->pers.maxHealth*0.5f )
+		{
+			NPCInfo->scriptFlags |= SCF_ALT_FIRE;
+			Boba_ChangeWeapon( WP_BLASTER );
+			NPCInfo->burstMin = 3;
+			NPCInfo->burstMean = 12;
+			NPCInfo->burstMax = 20;
+			NPCInfo->burstSpacing = Q_irand( 300, 750 );//attack debounce
+		}
+		else
+		{
+			NPCInfo->scriptFlags &= ~SCF_ALT_FIRE;
+			Boba_ChangeWeapon( WP_BLASTER );
+		}
+	}
+
+	VectorClear( impactPos );
+	enemyDist = DistanceSquared( NPC->r.currentOrigin, NPC->enemy->r.currentOrigin );
+
+	VectorSubtract( NPC->enemy->r.currentOrigin, NPC->r.currentOrigin, enemyDir );
+	VectorNormalize( enemyDir );
+	AngleVectors( NPC->client->ps.viewangles, shootDir, NULL, NULL );
+	dot = DotProduct( enemyDir, shootDir );
+	if ( dot > 0.5f ||( enemyDist * (1.0f-dot)) < 10000 )
+	{//enemy is in front of me or they're very close and not behind me
+		enemyInFOV = qtrue;
+	}
+
+	if ( (enemyDist < (128*128)&&enemyInFOV) || !TIMER_Done( NPC, "flameTime" ) )
+	{//flamethrower
+		Boba_DoFlameThrower( NPC );
+		enemyCS = qfalse;
+		shoot = qfalse;
+		NPCInfo->enemyLastSeenTime = level.time;
+		faceEnemy = qtrue;
+		ucmd.buttons &= ~(BUTTON_ATTACK|BUTTON_ALT_ATTACK);
+	}
+	else if ( enemyDist < MIN_ROCKET_DIST_SQUARED )//128
+	{//enemy within 128
+		if ( (NPC->client->ps.weapon == WP_FLECHETTE || NPC->client->ps.weapon == WP_REPEATER) && 
+			(NPCInfo->scriptFlags & SCF_ALT_FIRE) )
+		{//shooting an explosive, but enemy too close, switch to primary fire
+			NPCInfo->scriptFlags &= ~SCF_ALT_FIRE;
+			//FIXME: we can never go back to alt-fire this way since, after this, we don't know if we were initially supposed to use alt-fire or not...
+		}
+	}
+	else if ( enemyDist > 65536 )//256 squared
+	{
+		if ( NPC->client->ps.weapon == WP_DISRUPTOR )
+		{//sniping... should be assumed
+			if ( !(NPCInfo->scriptFlags&SCF_ALT_FIRE) )
+			{//use primary fire
+				NPCInfo->scriptFlags |= SCF_ALT_FIRE;
+				//reset fire-timing variables
+				NPC_ChangeWeapon( WP_DISRUPTOR );
+				NPC_UpdateAngles( qtrue, qtrue );
+				return;
+			}
+		}
+	}
+
+	//can we see our target?
+	if ( TIMER_Done( NPC, "nextAttackDelay" ) && TIMER_Done( NPC, "flameTime" ) )
+	{
+		if ( NPC_ClearLOS4( NPC->enemy ) )
+		{
+			NPCInfo->enemyLastSeenTime = level.time;
+			enemyLOS = qtrue;
+
+			if ( NPC->client->ps.weapon == WP_NONE )
+			{
+				enemyCS = qfalse;//not true, but should stop us from firing
+			}
+			else
+			{//can we shoot our target?
+				if ( (NPC->client->ps.weapon == WP_ROCKET_LAUNCHER || (NPC->client->ps.weapon == WP_FLECHETTE && (NPCInfo->scriptFlags&SCF_ALT_FIRE))) && enemyDist < MIN_ROCKET_DIST_SQUARED )//128*128
+				{
+					enemyCS = qfalse;//not true, but should stop us from firing
+					hitAlly = qtrue;//us!
+					//FIXME: if too close, run away!
+				}
+				else if ( enemyInFOV )
+				{//if enemy is FOV, go ahead and check for shooting
+					int hit = NPC_ShotEntity( NPC->enemy, impactPos );
+					gentity_t *hitEnt = &g_entities[hit];
+
+					if ( hit == NPC->enemy->s.number 
+						|| ( hitEnt && hitEnt->client && hitEnt->client->playerTeam == NPC->client->enemyTeam )
+						|| ( hitEnt && hitEnt->takedamage && ((hitEnt->r.svFlags&SVF_GLASS_BRUSH)||hitEnt->health < 40||NPC->s.weapon == WP_EMPLACED_GUN) ) )
+					{//can hit enemy or enemy ally or will hit glass or other minor breakable (or in emplaced gun), so shoot anyway
+						enemyCS = qtrue;
+						//NPC_AimAdjust( 2 );//adjust aim better longer we have clear shot at enemy
+						VectorCopy( NPC->enemy->r.currentOrigin, NPCInfo->enemyLastSeenLocation );
+					}
+					else
+					{//Hmm, have to get around this bastard
+						//NPC_AimAdjust( 1 );//adjust aim better longer we can see enemy
+						if ( hitEnt && hitEnt->client && hitEnt->client->playerTeam == NPC->client->playerTeam )
+						{//would hit an ally, don't fire!!!
+							hitAlly = qtrue;
+						}
+						else
+						{//Check and see where our shot *would* hit... if it's not close to the enemy (within 256?), then don't fire
+						}
+					}
+				}
+				else
+				{
+					enemyCS = qfalse;//not true, but should stop us from firing
+				}
+			}
+		}
+		else if ( trap_InPVS( NPC->enemy->r.currentOrigin, NPC->r.currentOrigin ) )
+		{
+			NPCInfo->enemyLastSeenTime = level.time;
+			faceEnemy = qtrue;
+			//NPC_AimAdjust( -1 );//adjust aim worse longer we cannot see enemy
+		}
+
+		if ( NPC->client->ps.weapon == WP_NONE )
+		{
+			faceEnemy = qfalse;
+			shoot = qfalse;
+		}
+		else
+		{
+			if ( enemyLOS )
+			{//FIXME: no need to face enemy if we're moving to some other goal and he's too far away to shoot?
+				faceEnemy = qtrue;
+			}
+			if ( enemyCS )
+			{
+				shoot = qtrue;
+			}
+		}
+
+		if ( !enemyCS )
+		{//if have a clear shot, always try
+			//See if we should continue to fire on their last position
+			//!TIMER_Done( NPC, "stick" ) || 
+			if ( !hitAlly //we're not going to hit an ally
+				&& enemyInFOV //enemy is in our FOV //FIXME: or we don't have a clear LOS?
+				&& NPCInfo->enemyLastSeenTime > 0 )//we've seen the enemy
+			{
+				if ( level.time - NPCInfo->enemyLastSeenTime < 10000 )//we have seem the enemy in the last 10 seconds
+				{
+					if ( !Q_irand( 0, 10 ) )
+					{
+						//Fire on the last known position
+						vec3_t	muzzle, dir, angles;
+						qboolean tooClose = qfalse;
+						qboolean tooFar = qfalse;
+						float distThreshold;
+						float dist;
+
+						CalcEntitySpot( NPC, SPOT_HEAD, muzzle );
+						if ( VectorCompare( impactPos, vec3_origin ) )
+						{//never checked ShotEntity this frame, so must do a trace...
+							trace_t tr;
+							//vec3_t	mins = {-2,-2,-2}, maxs = {2,2,2};
+							vec3_t	forward, end;
+							AngleVectors( NPC->client->ps.viewangles, forward, NULL, NULL );
+							VectorMA( muzzle, 8192, forward, end );
+							trap_Trace( &tr, muzzle, vec3_origin, vec3_origin, end, NPC->s.number, MASK_SHOT );
+							VectorCopy( tr.endpos, impactPos );
+						}
+
+						//see if impact would be too close to me
+						distThreshold = 16384/*128*128*/;//default
+						switch ( NPC->s.weapon )
+						{
+						case WP_ROCKET_LAUNCHER:
+						case WP_FLECHETTE:
+						case WP_THERMAL:
+						case WP_TRIP_MINE:
+						case WP_DET_PACK:
+							distThreshold = 65536/*256*256*/;
+							break;
+						case WP_REPEATER:
+							if ( NPCInfo->scriptFlags&SCF_ALT_FIRE )
+							{
+								distThreshold = 65536/*256*256*/;
+							}
+							break;
+						default:
+							break;
+						}
+
+						dist = DistanceSquared( impactPos, muzzle );
+
+						if ( dist < distThreshold )
+						{//impact would be too close to me
+							tooClose = qtrue;
+						}
+						else if ( level.time - NPCInfo->enemyLastSeenTime > 5000 ||
+							(NPCInfo->group && level.time - NPCInfo->group->lastSeenEnemyTime > 5000 ))
+						{//we've haven't seen them in the last 5 seconds
+							//see if it's too far from where he is
+							distThreshold = 65536/*256*256*/;//default
+							switch ( NPC->s.weapon )
+							{
+							case WP_ROCKET_LAUNCHER:
+							case WP_FLECHETTE:
+							case WP_THERMAL:
+							case WP_TRIP_MINE:
+							case WP_DET_PACK:
+								distThreshold = 262144/*512*512*/;
+								break;
+							case WP_REPEATER:
+								if ( NPCInfo->scriptFlags&SCF_ALT_FIRE )
+								{
+									distThreshold = 262144/*512*512*/;
+								}
+								break;
+							default:
+								break;
+							}
+							dist = DistanceSquared( impactPos, NPCInfo->enemyLastSeenLocation );
+							if ( dist > distThreshold )
+							{//impact would be too far from enemy
+								tooFar = qtrue;
+							}
+						}
+
+						if ( !tooClose && !tooFar )
+						{//okay too shoot at last pos
+							VectorSubtract( NPCInfo->enemyLastSeenLocation, muzzle, dir );
+							VectorNormalize( dir );
+							vectoangles( dir, angles );
+
+							NPCInfo->desiredYaw		= angles[YAW];
+							NPCInfo->desiredPitch	= angles[PITCH];
+
+							shoot = qtrue;
+							faceEnemy = qfalse;
+						}
+					}
+				}
+			}
+		}
+
+		//FIXME: don't shoot right away!
+		if ( NPC->client->ps.weaponTime > 0 )
+		{
+			if ( NPC->s.weapon == WP_ROCKET_LAUNCHER )
+			{
+				if ( !enemyLOS || !enemyCS )
+				{//cancel it
+					NPC->client->ps.weaponTime = 0;
+				}
+				else
+				{//delay our next attempt
+					TIMER_Set( NPC, "nextAttackDelay", Q_irand( 500, 1000 ) );
+				}
+			}
+		}
+		else if ( shoot )
+		{//try to shoot if it's time
+			if ( TIMER_Done( NPC, "nextAttackDelay" ) )
+			{
+				if( !(NPCInfo->scriptFlags & SCF_FIRE_WEAPON) ) // we've already fired, no need to do it again here
+				{
+					WeaponThink( qtrue );
+				}
+				//NASTY
+				if ( NPC->s.weapon == WP_ROCKET_LAUNCHER 
+					&& (ucmd.buttons&BUTTON_ATTACK) 
+					&& !Q_irand( 0, 3 ) )
+				{//every now and then, shoot a homing rocket
+					ucmd.buttons &= ~BUTTON_ATTACK;
+					ucmd.buttons |= BUTTON_ALT_ATTACK;
+					NPC->client->ps.weaponTime = Q_irand( 500, 1500 );
+				}
+			}
+		}
+	}
+}
+
+void Jedi_Cloak( gentity_t *self )
+{
+	if ( self )
+	{
+		self->flags |= FL_NOTARGET;
+		if ( self->client )
+		{
+			if ( !self->client->ps.powerups[PW_CLOAKED] )
+			{//cloak
+				self->client->ps.powerups[PW_CLOAKED] = Q3_INFINITE;
+
+				//FIXME: debounce attacks?
+				//FIXME: temp sound
+				G_Sound( self, CHAN_ITEM, G_SoundIndex("sound/chars/shadowtrooper/cloak.wav") );
+			}
+		}
+	}
+}
+
+void Jedi_Decloak( gentity_t *self )
+{
+	if ( self )
+	{
+		self->flags &= ~FL_NOTARGET;
+		if ( self->client )
+		{
+			if ( self->client->ps.powerups[PW_CLOAKED] )
+			{//Uncloak
+				self->client->ps.powerups[PW_CLOAKED] = 0;
+
+				G_Sound( self, CHAN_ITEM, G_SoundIndex("sound/chars/shadowtrooper/decloak.wav") );
+			}
+		}
+	}
+}
+
+void Jedi_CheckCloak( void )
+{
+	if ( NPC && NPC->client && NPC->client->NPC_class == CLASS_SHADOWTROOPER )
+	{
+		if ( !NPC->client->ps.saberHolstered ||
+			NPC->health <= 0 || 
+			NPC->client->ps.saberInFlight ||
+		//	(NPC->client->ps.eFlags&EF_FORCE_GRIPPED) ||
+		//	(NPC->client->ps.eFlags&EF_FORCE_DRAINED) ||
+			NPC->painDebounceTime > level.time )
+		{//can't be cloaked if saber is on, or dead or saber in flight or taking pain or being gripped
+			Jedi_Decloak( NPC );
+		}
+		else if ( NPC->health > 0 
+			&& !NPC->client->ps.saberInFlight 
+		//	&& !(NPC->client->ps.eFlags&EF_FORCE_GRIPPED) 
+		//	&& !(NPC->client->ps.eFlags&EF_FORCE_DRAINED) 
+			&& NPC->painDebounceTime < level.time )
+		{//still alive, have saber in hand, not taking pain and not being gripped
+			Jedi_Cloak( NPC );
+		}
+	}
+}
+/*
+==========================================================================================
+AGGRESSION
+==========================================================================================
+*/
+static void Jedi_Aggression( gentity_t *self, int change )
+{
+	int	upper_threshold, lower_threshold;
+
+	self->NPC->stats.aggression += change;
+	
+	//FIXME: base this on initial NPC stats
+	if ( self->client->playerTeam == NPCTEAM_PLAYER )
+	{//good guys are less aggressive
+		upper_threshold = 7;
+		lower_threshold = 1;
+	}
+	else
+	{//bad guys are more aggressive
+		if ( self->client->NPC_class == CLASS_DESANN )
+		{
+			upper_threshold = 20;
+			lower_threshold = 5;
+		}
+		else
+		{
+			upper_threshold = 10;
+			lower_threshold = 3;
+		}
+	}
+
+	if ( self->NPC->stats.aggression > upper_threshold )
+	{
+		self->NPC->stats.aggression = upper_threshold;
+	}
+	else if ( self->NPC->stats.aggression < lower_threshold )
+	{
+		self->NPC->stats.aggression = lower_threshold;
+	}
+	//Com_Printf( "(%d) %s agg %d change: %d\n", level.time, self->NPC_type, self->NPC->stats.aggression, change );
+}
+
+static void Jedi_AggressionErosion( int amt )
+{
+	if ( TIMER_Done( NPC, "roamTime" ) )
+	{//the longer we're not alerted and have no enemy, the more our aggression goes down
+		TIMER_Set( NPC, "roamTime", Q_irand( 2000, 5000 ) );
+		Jedi_Aggression( NPC, amt );
+	}
+	
+	if ( NPCInfo->stats.aggression < 4 || (NPCInfo->stats.aggression < 6&&NPC->client->NPC_class == CLASS_DESANN))
+	{//turn off the saber
+		WP_DeactivateSaber( NPC, qfalse );
+	}
+}
+
+void NPC_Jedi_RateNewEnemy( gentity_t *self, gentity_t *enemy )
+{
+	float healthAggression;
+	float weaponAggression;
+	int newAggression;
+
+	switch( enemy->s.weapon )
+	{
+	case WP_SABER:
+		healthAggression = (float)self->health/200.0f*6.0f;
+		weaponAggression = 7;//go after him
+		break;
+	case WP_BLASTER:
+		if ( DistanceSquared( self->r.currentOrigin, enemy->r.currentOrigin ) < 65536 )//256 squared
+		{
+			healthAggression = (float)self->health/200.0f*8.0f;
+			weaponAggression = 8;//go after him
+		}
+		else
+		{
+			healthAggression = 8.0f - ((float)self->health/200.0f*8.0f);
+			weaponAggression = 2;//hang back for a second
+		}
+		break;
+	default:
+		healthAggression = (float)self->health/200.0f*8.0f;
+		weaponAggression = 6;//approach
+		break;
+	}
+	//Average these with current aggression
+	newAggression = ceil( (healthAggression + weaponAggression + (float)self->NPC->stats.aggression )/3.0f);
+	//Com_Printf( "(%d) new agg %d - new enemy\n", level.time, newAggression );
+	Jedi_Aggression( self, newAggression - self->NPC->stats.aggression );
+
+	//don't taunt right away
+	TIMER_Set( self, "chatter", Q_irand( 4000, 7000 ) );
+}
+
+static void Jedi_Rage( void )
+{
+	Jedi_Aggression( NPC, 10 - NPCInfo->stats.aggression + Q_irand( -2, 2 ) );
+	TIMER_Set( NPC, "roamTime", 0 );
+	TIMER_Set( NPC, "chatter", 0 );
+	TIMER_Set( NPC, "walking", 0 );
+	TIMER_Set( NPC, "taunting", 0 );
+	TIMER_Set( NPC, "jumpChaseDebounce", 0 );
+	TIMER_Set( NPC, "movenone", 0 );
+	TIMER_Set( NPC, "movecenter", 0 );
+	TIMER_Set( NPC, "noturn", 0 );
+	ForceRage( NPC );
+}
+
+void Jedi_RageStop( gentity_t *self )
+{
+	if ( self->NPC )
+	{//calm down and back off
+		TIMER_Set( self, "roamTime", 0 );
+		Jedi_Aggression( self, Q_irand( -5, 0 ) );
+	}
+}
+/*
+==========================================================================================
+SPEAKING
+==========================================================================================
+*/
+
+static qboolean Jedi_BattleTaunt( void )
+{
+	if ( TIMER_Done( NPC, "chatter" ) 
+		&& !Q_irand( 0, 3 ) 
+		&& NPCInfo->blockedSpeechDebounceTime < level.time 
+		&& jediSpeechDebounceTime[NPC->client->playerTeam] < level.time )
+	{
+		int event = -1;
+		if ( NPC->client->playerTeam == NPCTEAM_PLAYER 
+			&& NPC->enemy && NPC->enemy->client && NPC->enemy->client->NPC_class == CLASS_JEDI )
+		{//a jedi fighting a jedi - training
+			if ( NPC->client->NPC_class == CLASS_JEDI && NPCInfo->rank == RANK_COMMANDER )
+			{//only trainer taunts
+				event = EV_TAUNT1;
+			}
+		}
+		else
+		{//reborn or a jedi fighting an enemy
+			event = Q_irand( EV_TAUNT1, EV_TAUNT3 );
+		}
+		if ( event != -1 )
+		{
+			G_AddVoiceEvent( NPC, event, 3000 );
+			jediSpeechDebounceTime[NPC->client->playerTeam] = NPCInfo->blockedSpeechDebounceTime = level.time + 6000;
+			TIMER_Set( NPC, "chatter", Q_irand( 5000, 10000 ) );
+
+			if ( NPC->enemy && NPC->enemy->NPC && NPC->enemy->s.weapon == WP_SABER && NPC->enemy->client && NPC->enemy->client->NPC_class == CLASS_JEDI )
+			{//Have the enemy jedi say something in response when I'm done?
+			}
+			return qtrue;
+		}
+	}
+	return qfalse;
+}
+
+/*
+==========================================================================================
+MOVEMENT
+==========================================================================================
+*/
+static qboolean Jedi_ClearPathToSpot( vec3_t dest, int impactEntNum )
+{
+	trace_t	trace;
+	vec3_t	mins, start, end, dir;
+	float	dist, drop;
+	float	i;
+
+	//Offset the step height
+	VectorSet( mins, NPC->r.mins[0], NPC->r.mins[1], NPC->r.mins[2] + STEPSIZE );
+	
+	trap_Trace( &trace, NPC->r.currentOrigin, mins, NPC->r.maxs, dest, NPC->s.number, NPC->clipmask );
+
+	//Do a simple check
+	if ( trace.allsolid || trace.startsolid )
+	{//inside solid
+		return qfalse;
+	}
+
+	if ( trace.fraction < 1.0f )
+	{//hit something
+		if ( impactEntNum != ENTITYNUM_NONE && trace.entityNum == impactEntNum )
+		{//hit what we're going after
+			return qtrue;
+		}
+		else
+		{
+			return qfalse;
+		}
+	}
+
+	//otherwise, clear path in a straight line.  
+	//Now at intervals of my size, go along the trace and trace down STEPSIZE to make sure there is a solid floor.
+	VectorSubtract( dest, NPC->r.currentOrigin, dir );
+	dist = VectorNormalize( dir );
+	if ( dest[2] > NPC->r.currentOrigin[2] )
+	{//going up, check for steps
+		drop = STEPSIZE;
+	}
+	else
+	{//going down or level, check for moderate drops
+		drop = 64;
+	}
+	for ( i = NPC->r.maxs[0]*2; i < dist; i += NPC->r.maxs[0]*2 )
+	{//FIXME: does this check the last spot, too?  We're assuming that should be okay since the enemy is there?
+		VectorMA( NPC->r.currentOrigin, i, dir, start );
+		VectorCopy( start, end );
+		end[2] -= drop;
+		trap_Trace( &trace, start, mins, NPC->r.maxs, end, NPC->s.number, NPC->clipmask );//NPC->r.mins?
+		if ( trace.fraction < 1.0f || trace.allsolid || trace.startsolid )
+		{//good to go
+			continue;
+		}
+		//no floor here! (or a long drop?)
+		return qfalse;
+	}
+	//we made it!
+	return qtrue;
+}
+
+qboolean NPC_MoveDirClear( int forwardmove, int rightmove, qboolean reset )
+{
+	vec3_t	forward, right, testPos, angles, mins;
+	trace_t	trace;
+	float	fwdDist, rtDist;
+	float	bottom_max = -STEPSIZE*4 - 1;
+
+	if ( !forwardmove && !rightmove )
+	{//not even moving
+		//Com_Printf( "%d skipping walk-cliff check (not moving)\n", level.time );
+		return qtrue;
+	}
+
+	if ( ucmd.upmove > 0 || NPC->client->ps.fd.forceJumpCharge )
+	{//Going to jump
+		//Com_Printf( "%d skipping walk-cliff check (going to jump)\n", level.time );
+		return qtrue;
+	}
+
+	if ( NPC->client->ps.groundEntityNum == ENTITYNUM_NONE )
+	{//in the air
+		//Com_Printf( "%d skipping walk-cliff check (in air)\n", level.time );
+		return qtrue;
+	}
+	/*
+	if ( fabs( AngleDelta( NPC->r.currentAngles[YAW], NPCInfo->desiredYaw ) ) < 5.0 )//!ucmd.angles[YAW] )
+	{//Not turning much, don't do this
+		//NOTE: Should this not happen only if you're not turning AT ALL?
+		//	You could be turning slowly but moving fast, so that would
+		//	still let you walk right off a cliff...
+		//NOTE: Or maybe it is a good idea to ALWAYS do this, regardless
+		//	of whether ot not we're turning?  But why would we be walking
+		//  straight into a wall or off	a cliff unless we really wanted to?
+		return;
+	}
+	*/
+
+	//FIXME: to really do this right, we'd have to actually do a pmove to predict where we're
+	//going to be... maybe this should be a flag and pmove handles it and sets a flag so AI knows
+	//NEXT frame?  Or just incorporate current velocity, runspeed and possibly friction?
+	VectorCopy( NPC->r.mins, mins );
+	mins[2] += STEPSIZE;
+	angles[PITCH] = angles[ROLL] = 0;
+	angles[YAW] = NPC->client->ps.viewangles[YAW];//Add ucmd.angles[YAW]?
+	AngleVectors( angles, forward, right, NULL );
+	fwdDist = ((float)forwardmove)/2.0f;
+	rtDist = ((float)rightmove)/2.0f;
+	VectorMA( NPC->r.currentOrigin, fwdDist, forward, testPos );
+	VectorMA( testPos, rtDist, right, testPos );
+	trap_Trace( &trace, NPC->r.currentOrigin, mins, NPC->r.maxs, testPos, NPC->s.number, NPC->clipmask|CONTENTS_BOTCLIP );
+	if ( trace.allsolid || trace.startsolid )
+	{//hmm, trace started inside this brush... how do we decide if we should continue?
+		//FIXME: what do we do if we start INSIDE a CONTENTS_BOTCLIP? Try the trace again without that in the clipmask?
+		if ( reset )
+		{
+			trace.fraction = 1.0f;
+		}
+		VectorCopy( testPos, trace.endpos );
+		//return qtrue;
+	}
+	if ( trace.fraction < 0.6 )
+	{//Going to bump into something very close, don't move, just turn
+		if ( (NPC->enemy && trace.entityNum == NPC->enemy->s.number) || (NPCInfo->goalEntity && trace.entityNum == NPCInfo->goalEntity->s.number) )
+		{//okay to bump into enemy or goal
+			//Com_Printf( "%d bump into enemy/goal okay\n", level.time );
+			return qtrue;
+		}
+		else if ( reset )
+		{//actually want to screw with the ucmd
+			//Com_Printf( "%d avoiding walk into wall (entnum %d)\n", level.time, trace.entityNum );
+			ucmd.forwardmove = 0;
+			ucmd.rightmove = 0;
+			VectorClear( NPC->client->ps.moveDir );
+		}
+		return qfalse;
+	}
+
+	if ( NPCInfo->goalEntity )
+	{
+		if ( NPCInfo->goalEntity->r.currentOrigin[2] < NPC->r.currentOrigin[2] )
+		{//goal is below me, okay to step off at least that far plus stepheight
+			bottom_max += NPCInfo->goalEntity->r.currentOrigin[2] - NPC->r.currentOrigin[2];
+		}
+	}
+	VectorCopy( trace.endpos, testPos );
+	testPos[2] += bottom_max;
+
+	trap_Trace( &trace, trace.endpos, mins, NPC->r.maxs, testPos, NPC->s.number, NPC->clipmask );
+
+	//FIXME:Should we try to see if we can still get to our goal using the waypoint network from this trace.endpos?
+	//OR: just put NPC clip brushes on these edges (still fall through when die)
+
+	if ( trace.allsolid || trace.startsolid )
+	{//Not going off a cliff
+		//Com_Printf( "%d walk off cliff okay (droptrace in solid)\n", level.time );
+		return qtrue;
+	}
+
+	if ( trace.fraction < 1.0 )
+	{//Not going off a cliff
+		//FIXME: what if plane.normal is sloped?  We'll slide off, not land... plus this doesn't account for slide-movement... 
+		//Com_Printf( "%d walk off cliff okay will hit entnum %d at dropdist of %4.2f\n", level.time, trace.entityNum, (trace.fraction*bottom_max) );
+		return qtrue;
+	}
+
+	//going to fall at least bottom_max, don't move, just turn... is this bad, though?  What if we want them to drop off?
+	if ( reset )
+	{//actually want to screw with the ucmd
+		//Com_Printf( "%d avoiding walk off cliff\n", level.time );
+		ucmd.forwardmove *= -1.0;//= 0;
+		ucmd.rightmove *= -1.0;//= 0;
+		VectorScale( NPC->client->ps.moveDir, -1, NPC->client->ps.moveDir );
+	}
+	return qfalse;
+}
+/*
+-------------------------
+Jedi_HoldPosition
+-------------------------
+*/
+
+static void Jedi_HoldPosition( void )
+{
+	//NPCInfo->squadState = SQUAD_STAND_AND_SHOOT;
+	NPCInfo->goalEntity = NULL;
+	
+	/*
+	if ( TIMER_Done( NPC, "stand" ) )
+	{
+		TIMER_Set( NPC, "duck", Q_irand( 2000, 4000 ) );
+	}
+	*/
+}
+
+/*
+-------------------------
+Jedi_Move
+-------------------------
+*/
+
+static void Jedi_Move( gentity_t *goal, qboolean retreat )
+{
+	qboolean	moved;
+	navInfo_t	info;
+
+	NPCInfo->combatMove = qtrue;
+	NPCInfo->goalEntity = goal;
+
+	moved = NPC_MoveToGoal( qtrue );
+
+	//FIXME: temp retreat behavior- should really make this toward a safe spot or maybe to outflank enemy
+	if ( retreat )
+	{//FIXME: should we trace and make sure we can go this way?  Or somehow let NPC_MoveToGoal know we want to retreat and have it handle it?
+		ucmd.forwardmove *= -1;
+		ucmd.rightmove *= -1;
+		VectorScale( NPC->client->ps.moveDir, -1, NPC->client->ps.moveDir );
+	}
+	
+	//Get the move info
+	NAV_GetLastMove( &info );
+
+	//If we hit our target, then stop and fire!
+	if ( ( info.flags & NIF_COLLISION ) && ( info.blocker == NPC->enemy ) )
+	{
+		Jedi_HoldPosition();
+	}
+
+	//If our move failed, then reset
+	if ( moved == qfalse )
+	{
+		Jedi_HoldPosition();
+	}
+}
+
+static qboolean Jedi_Hunt( void )
+{
+	//Com_Printf( "Hunting\n" );
+	//if we're at all interested in fighting, go after him
+	if ( NPCInfo->stats.aggression > 1 )
+	{//approach enemy
+		NPCInfo->combatMove = qtrue;
+		if ( !(NPCInfo->scriptFlags&SCF_CHASE_ENEMIES) )
+		{
+			NPC_UpdateAngles( qtrue, qtrue );
+			return qtrue;
+		}
+		else
+		{
+			if ( NPCInfo->goalEntity == NULL )
+			{//hunt
+				NPCInfo->goalEntity = NPC->enemy;
+			}
+			//Jedi_Move( NPC->enemy, qfalse );
+			if ( NPC_MoveToGoal( qfalse ) )
+			{
+				NPC_UpdateAngles( qtrue, qtrue );
+				return qtrue;
+			}
+		}
+	}
+	return qfalse;
+}
+
+/*
+static qboolean Jedi_Track( void )
+{
+	//if we're at all interested in fighting, go after him
+	if ( NPCInfo->stats.aggression > 1 )
+	{//approach enemy
+		NPCInfo->combatMove = qtrue;
+		NPC_SetMoveGoal( NPC, NPCInfo->enemyLastSeenLocation, 16, qtrue );
+		if ( NPC_MoveToGoal( qfalse ) )
+		{
+			NPC_UpdateAngles( qtrue, qtrue );
+			return qtrue;
+		}
+	}
+	return qfalse;
+}
+*/
+
+static void Jedi_Retreat( void )
+{
+	if ( !TIMER_Done( NPC, "noRetreat" ) )
+	{//don't actually move
+		return;
+	}
+	//FIXME: when retreating, we should probably see if we can retreat 
+	//in the direction we want.  If not...?  Evade?
+	//Com_Printf( "Retreating\n" );
+	Jedi_Move( NPC->enemy, qtrue );
+}
+
+static void Jedi_Advance( void )
+{
+	if ( !NPC->client->ps.saberInFlight )
+	{
+		//NPC->client->ps.SaberActivate();
+		WP_ActivateSaber(NPC);
+	}
+	//Com_Printf( "Advancing\n" );
+	Jedi_Move( NPC->enemy, qfalse );
+		
+	//TIMER_Set( NPC, "roamTime", Q_irand( 2000, 4000 ) );
+	//TIMER_Set( NPC, "attackDelay", Q_irand( 250, 500 ) );
+	//TIMER_Set( NPC, "duck", 0 );
+}
+
+static void Jedi_AdjustSaberAnimLevel( gentity_t *self, int newLevel )
+{	
+	if ( !self || !self->client )
+	{
+		return;
+	}
+	//FIXME: each NPC shold have a unique pattern of behavior for the order in which they
+	if ( self->client->NPC_class == CLASS_TAVION )
+	{//special attacks
+		self->client->ps.fd.saberAnimLevel = FORCE_LEVEL_5;
+		return;
+	}
+	else if ( self->client->NPC_class == CLASS_DESANN )
+	{//special attacks
+		self->client->ps.fd.saberAnimLevel = FORCE_LEVEL_4;
+		return;
+	}
+	if ( self->client->playerTeam == NPCTEAM_ENEMY )
+	{
+		if ( self->NPC->rank == RANK_CIVILIAN || self->NPC->rank == RANK_LT_JG )
+		{//grunt and fencer always uses quick attacks
+			self->client->ps.fd.saberAnimLevel = FORCE_LEVEL_1;
+			return;
+		}
+		if ( self->NPC->rank == RANK_CREWMAN 
+			|| self->NPC->rank == RANK_ENSIGN )
+		{//acrobat & force-users always use medium attacks
+			self->client->ps.fd.saberAnimLevel = FORCE_LEVEL_2;
+			return;
+		}
+		/*
+		if ( self->NPC->rank == RANK_LT ) 
+		{//boss always uses strong attacks
+			self->client->ps.fd.saberAnimLevel = FORCE_LEVEL_3;
+			return;
+		}
+		*/
+	}
+	//use the different attacks, how often they switch and under what circumstances
+	if ( newLevel > self->client->ps.fd.forcePowerLevel[FP_SABER_OFFENSE] )
+	{//cap it
+		self->client->ps.fd.saberAnimLevel = self->client->ps.fd.forcePowerLevel[FP_SABER_OFFENSE];
+	}
+	else if ( newLevel < FORCE_LEVEL_1 )
+	{
+		self->client->ps.fd.saberAnimLevel = FORCE_LEVEL_1;
+	}
+	else
+	{//go ahead and set it
+		self->client->ps.fd.saberAnimLevel = newLevel;
+	}
+
+	if ( d_JediAI.integer )
+	{
+		switch ( self->client->ps.fd.saberAnimLevel )
+		{
+		case FORCE_LEVEL_1:
+			Com_Printf( S_COLOR_GREEN"%s Saber Attack Set: fast\n", self->NPC_type );
+			break;
+		case FORCE_LEVEL_2:
+			Com_Printf( S_COLOR_YELLOW"%s Saber Attack Set: medium\n", self->NPC_type );
+			break;
+		case FORCE_LEVEL_3:
+			Com_Printf( S_COLOR_RED"%s Saber Attack Set: strong\n", self->NPC_type );
+			break;
+		}
+	}
+}
+
+static void Jedi_CheckDecreaseSaberAnimLevel( void )
+{
+	if ( !NPC->client->ps.weaponTime && !(ucmd.buttons&(BUTTON_ATTACK|BUTTON_ALT_ATTACK)) )
+	{//not attacking
+		if ( TIMER_Done( NPC, "saberLevelDebounce" ) && !Q_irand( 0, 10 ) )
+		{
+			//Jedi_AdjustSaberAnimLevel( NPC, (NPC->client->ps.fd.saberAnimLevel-1) );//drop
+			Jedi_AdjustSaberAnimLevel( NPC, Q_irand( FORCE_LEVEL_1, FORCE_LEVEL_3 ));//random
+			TIMER_Set( NPC, "saberLevelDebounce", Q_irand( 3000, 10000 ) );
+		}
+	}
+	else
+	{
+		TIMER_Set( NPC, "saberLevelDebounce", Q_irand( 1000, 5000 ) );
+	}
+}
+
+static void Jedi_CombatDistance( int enemy_dist )
+{//FIXME: for many of these checks, what we really want is horizontal distance to enemy
+	if ( NPC->client->ps.fd.forcePowersActive&(1<<FP_GRIP) &&
+		NPC->client->ps.fd.forcePowerLevel[FP_GRIP] > FORCE_LEVEL_1 )
+	{//when gripping, don't move
+		return;
+	}
+	else if ( !TIMER_Done( NPC, "gripping" ) )
+	{//stopped gripping, clear timers just in case
+		TIMER_Set( NPC, "gripping", -level.time );
+		TIMER_Set( NPC, "attackDelay", Q_irand( 0, 1000 ) );
+	}
+	
+	if ( NPC->client->ps.fd.forcePowersActive&(1<<FP_DRAIN) &&
+		NPC->client->ps.fd.forcePowerLevel[FP_DRAIN] > FORCE_LEVEL_1 )
+	{//when draining, don't move
+		return;
+	}
+	else if ( !TIMER_Done( NPC, "draining" ) )
+	{//stopped draining, clear timers just in case
+		TIMER_Set( NPC, "draining", -level.time );
+		TIMER_Set( NPC, "attackDelay", Q_irand( 0, 1000 ) );
+	}
+
+	if ( NPC->client->NPC_class == CLASS_BOBAFETT )
+	{
+		if ( !TIMER_Done( NPC, "flameTime" ) )
+		{
+			if ( enemy_dist > 50 )
+			{
+				Jedi_Advance();
+			}
+			else if ( enemy_dist <= 0 )
+			{
+				Jedi_Retreat();
+			}
+		}
+		else if ( enemy_dist < 200 )
+		{
+			Jedi_Retreat();
+		}
+		else if ( enemy_dist > 1024 )
+		{
+			Jedi_Advance();
+		}
+	}
+	else if ( NPC->client->ps.saberInFlight &&
+		!PM_SaberInBrokenParry( NPC->client->ps.saberMove )
+		&& NPC->client->ps.saberBlocked != BLOCKED_PARRY_BROKEN )
+	{//maintain distance
+		if ( enemy_dist < NPC->client->ps.saberEntityDist )
+		{
+			Jedi_Retreat();
+		}
+		else if ( enemy_dist > NPC->client->ps.saberEntityDist && enemy_dist > 100 )
+		{
+			Jedi_Advance();
+		}
+		if ( NPC->client->ps.weapon == WP_SABER //using saber
+			&& NPC->client->ps.saberEntityState == SES_LEAVING  //not returning yet
+			&& NPC->client->ps.fd.forcePowerLevel[FP_SABERTHROW] > FORCE_LEVEL_1 //2nd or 3rd level lightsaber
+			&& !(NPC->client->ps.fd.forcePowersActive&(1 << FP_SPEED))
+			&& !(NPC->client->ps.saberEventFlags&SEF_INWATER) )//saber not in water
+		{//hold it out there
+			ucmd.buttons |= BUTTON_ALT_ATTACK;
+			//FIXME: time limit?
+		}
+	}
+	else if ( !TIMER_Done( NPC, "taunting" ) )
+	{
+		if ( enemy_dist <= 64 )
+		{//he's getting too close
+			ucmd.buttons |= BUTTON_ATTACK;
+			if ( !NPC->client->ps.saberInFlight )
+			{
+				WP_ActivateSaber(NPC);
+			}
+			TIMER_Set( NPC, "taunting", -level.time );
+		}
+		//else if ( NPC->client->ps.torsoAnim == BOTH_GESTURE1 && NPC->client->ps.torsoTimer < 2000 )
+		else if (NPC->client->ps.forceHandExtend == HANDEXTEND_JEDITAUNT && (NPC->client->ps.forceHandExtendTime - level.time) < 200)
+		{//we're almost done with our special taunt
+			//FIXME: this doesn't always work, for some reason
+			if ( !NPC->client->ps.saberInFlight )
+			{
+				WP_ActivateSaber(NPC);
+			}
+		}
+	}
+	else if ( NPC->client->ps.saberEventFlags&SEF_LOCK_WON )
+	{//we won a saber lock, press the advantage
+		if ( enemy_dist > 0 )
+		{//get closer so we can hit!
+			Jedi_Advance();
+		}
+		if ( enemy_dist > 128 )
+		{//lost 'em
+			NPC->client->ps.saberEventFlags &= ~SEF_LOCK_WON;
+		}
+		if ( NPC->enemy->painDebounceTime + 2000 < level.time )
+		{//the window of opportunity is gone
+			NPC->client->ps.saberEventFlags &= ~SEF_LOCK_WON;
+		}
+		//don't strafe?
+		TIMER_Set( NPC, "strafeLeft", -1 );
+		TIMER_Set( NPC, "strafeRight", -1 );
+	}
+	else if ( NPC->enemy->client 
+		&& NPC->enemy->s.weapon == WP_SABER 
+		&& NPC->enemy->client->ps.saberLockTime > level.time 
+		&& NPC->client->ps.saberLockTime < level.time )
+	{//enemy is in a saberLock and we are not
+		if ( enemy_dist < 64 )
+		{//FIXME: maybe just pick another enemy?
+			Jedi_Retreat();
+		}
+	}
+	/*
+	else if ( NPC->enemy->s.weapon == WP_TURRET 
+		&& !Q_stricmp( "PAS", NPC->enemy->classname ) 
+		&& NPC->enemy->s.apos.trType == TR_STATIONARY )
+	{
+		int	testlevel;
+		if ( enemy_dist > forcePushPullRadius[FORCE_LEVEL_1] - 16 )
+		{
+			Jedi_Advance();
+		}
+		if ( NPC->client->ps.fd.forcePowerLevel[FP_PUSH] < FORCE_LEVEL_1 )
+		{//
+			testlevel = FORCE_LEVEL_1;
+		}
+		else
+		{
+			testlevel = NPC->client->ps.fd.forcePowerLevel[FP_PUSH];
+		}
+		if ( enemy_dist < forcePushPullRadius[testlevel] - 16 )
+		{//close enough to push
+			if ( InFront( NPC->enemy->r.currentOrigin, NPC->client->renderInfo.eyePoint, NPC->client->renderInfo.eyeAngles, 0.6f ) )
+			{//knock it down
+				WP_KnockdownTurret( NPC, NPC->enemy );
+				//do the forcethrow call just for effect
+				ForceThrow( NPC, qfalse );
+			}
+		}
+	}
+	*/
+	//rwwFIXMEFIXME: Give them the ability to do this again (turret needs to be fixed up to allow it)
+	else if ( enemy_dist <= 64 
+		&& ((NPCInfo->scriptFlags&SCF_DONT_FIRE)||(!Q_stricmp("Yoda",NPC->NPC_type)&&!Q_irand(0,10))) )
+	{//can't use saber and they're in striking range
+		if ( !Q_irand( 0, 5 ) && InFront( NPC->enemy->r.currentOrigin, NPC->r.currentOrigin, NPC->client->ps.viewangles, 0.2f ) )
+		{
+			if ( ((NPCInfo->scriptFlags&SCF_DONT_FIRE)||NPC->client->pers.maxHealth - NPC->health > NPC->client->pers.maxHealth*0.25f)//lost over 1/4 of our health or not firing
+				&& NPC->client->ps.fd.forcePowersKnown&(1<<FP_DRAIN) //know how to drain
+				&& WP_ForcePowerAvailable( NPC, FP_DRAIN, 20 )//have enough power
+				&& !Q_irand( 0, 2 ) )
+			{//drain
+				TIMER_Set( NPC, "draining", 3000 );
+				TIMER_Set( NPC, "attackDelay", 3000 );
+				Jedi_Advance();
+				return;
+			}
+			else
+			{
+				ForceThrow( NPC, qfalse );
+			}
+		}
+		Jedi_Retreat();
+	}
+	else if ( enemy_dist <= 64 
+		&& NPC->client->pers.maxHealth - NPC->health > NPC->client->pers.maxHealth*0.25f//lost over 1/4 of our health
+		&& NPC->client->ps.fd.forcePowersKnown&(1<<FP_DRAIN) //know how to drain
+		&& WP_ForcePowerAvailable( NPC, FP_DRAIN, 20 )//have enough power
+		&& !Q_irand( 0, 10 ) 
+		&& InFront( NPC->enemy->r.currentOrigin, NPC->r.currentOrigin, NPC->client->ps.viewangles, 0.2f ) )
+	{
+		TIMER_Set( NPC, "draining", 3000 );
+		TIMER_Set( NPC, "attackDelay", 3000 );
+		Jedi_Advance();
+		return;
+	}
+	else if ( enemy_dist <= -16 )
+	{//we're too damn close!
+		Jedi_Retreat();
+	}
+	else if ( enemy_dist <= 0 )
+	{//we're within striking range
+		//if we are attacking, see if we should stop
+		if ( NPCInfo->stats.aggression < 4 )
+		{//back off and defend
+			Jedi_Retreat();
+		}
+	}
+	else if ( enemy_dist > 256 )
+	{//we're way out of range
+		qboolean usedForce = qfalse;
+		if ( NPCInfo->stats.aggression < Q_irand( 0, 20 ) 
+			&& NPC->health < NPC->client->pers.maxHealth*0.75f 
+			&& !Q_irand( 0, 2 ) )
+		{
+			if ( (NPC->client->ps.fd.forcePowersKnown&(1<<FP_HEAL)) != 0 
+				&& (NPC->client->ps.fd.forcePowersActive&(1<<FP_HEAL)) == 0 
+				&& Q_irand( 0, 1 ) )
+			{
+				ForceHeal( NPC );
+				usedForce = qtrue;
+				//FIXME: check level of heal and know not to move or attack when healing
+			}
+			else if ( (NPC->client->ps.fd.forcePowersKnown&(1<<FP_PROTECT)) != 0 
+				&& (NPC->client->ps.fd.forcePowersActive&(1<<FP_PROTECT)) == 0
+				&& Q_irand( 0, 1 ) )
+			{
+				ForceProtect( NPC );
+				usedForce = qtrue;
+			}
+			else if ( (NPC->client->ps.fd.forcePowersKnown&(1<<FP_ABSORB)) != 0 
+				&& (NPC->client->ps.fd.forcePowersActive&(1<<FP_ABSORB)) == 0
+				&& Q_irand( 0, 1 ) )
+			{
+				ForceAbsorb( NPC );
+				usedForce = qtrue;
+			}
+			else if ( (NPC->client->ps.fd.forcePowersKnown&(1<<FP_RAGE)) != 0 
+				&& (NPC->client->ps.fd.forcePowersActive&(1<<FP_RAGE)) == 0
+				&& Q_irand( 0, 1 ) )
+			{
+				Jedi_Rage();
+				usedForce = qtrue;
+			}
+			//FIXME: what about things like mind tricks and force sight?
+		}
+		if ( enemy_dist > 384 )
+		{//FIXME: check for enemy facing away and/or moving away
+			if ( !Q_irand( 0, 10 ) && NPCInfo->blockedSpeechDebounceTime < level.time && jediSpeechDebounceTime[NPC->client->playerTeam] < level.time )
+			{
+				if ( NPC_ClearLOS4( NPC->enemy ) )
+				{
+					G_AddVoiceEvent( NPC, Q_irand( EV_JCHASE1, EV_JCHASE3 ), 3000 );
+				}
+				jediSpeechDebounceTime[NPC->client->playerTeam] = NPCInfo->blockedSpeechDebounceTime = level.time + 3000;
+			}
+		}
+		//Unless we're totally hiding, go after him
+		if ( NPCInfo->stats.aggression > 0 )
+		{//approach enemy
+			if ( !usedForce )
+			{
+				Jedi_Advance();
+			}
+		}
+	}
+	/*
+	else if ( enemy_dist < 96 && NPC->enemy && NPC->enemy->client && NPC->enemy->client->ps.groundEntityNum == ENTITYNUM_NONE )
+	{//too close and in air, so retreat
+		Jedi_Retreat();
+	}
+	*/
+	//FIXME: enemy_dist calc needs to include all blade lengths, and include distance from hand to start of blade....
+	else if ( enemy_dist > 50 )//FIXME: not hardcoded- base on our reach (modelScale?) and saberLengthMax
+	{//we're out of striking range and we are allowed to attack
+		//first, check some tactical force power decisions
+		if ( NPC->enemy && NPC->enemy->client && (NPC->enemy->client->ps.fd.forceGripBeingGripped > level.time) )
+		{//They're being gripped, rush them!
+			if ( NPC->enemy->client->ps.groundEntityNum != ENTITYNUM_NONE )
+			{//they're on the ground, so advance
+				if ( TIMER_Done( NPC, "parryTime" ) || NPCInfo->rank > RANK_LT )
+				{//not parrying
+					if ( enemy_dist > 200 || !(NPCInfo->scriptFlags&SCF_DONT_FIRE) )
+					{//far away or allowed to use saber
+						Jedi_Advance();
+					}
+				}
+			}
+			if ( NPCInfo->rank >= RANK_LT_JG 
+				&& !Q_irand( 0, 5 ) 
+				&& !(NPC->client->ps.fd.forcePowersActive&(1 << FP_SPEED))
+				&& !(NPC->client->ps.saberEventFlags&SEF_INWATER) )//saber not in water
+			{//throw saber
+				ucmd.buttons |= BUTTON_ALT_ATTACK;
+			}
+		}
+		else if ( NPC->enemy && NPC->enemy->client && //valid enemy
+			NPC->enemy->client->ps.saberInFlight && /*NPC->enemy->client->ps.saber[0].Active()*/ NPC->enemy->client->ps.saberEntityNum && //enemy throwing saber
+			NPC->client->ps.weaponTime <= 0 && //I'm not busy
+			WP_ForcePowerAvailable( NPC, FP_GRIP, 0 ) && //I can use the power
+			!Q_irand( 0, 10 ) && //don't do it all the time, averages to 1 check a second
+			Q_irand( 0, 6 ) < g_spskill.integer && //more likely on harder diff
+			Q_irand( RANK_CIVILIAN, RANK_CAPTAIN ) < NPCInfo->rank )//more likely against harder enemies
+		{//They're throwing their saber, grip them!
+			//taunt
+			if ( TIMER_Done( NPC, "chatter" ) && jediSpeechDebounceTime[NPC->client->playerTeam] < level.time && NPCInfo->blockedSpeechDebounceTime < level.time )
+			{
+				G_AddVoiceEvent( NPC, Q_irand( EV_TAUNT1, EV_TAUNT3 ), 3000 );
+				jediSpeechDebounceTime[NPC->client->playerTeam] = NPCInfo->blockedSpeechDebounceTime = level.time + 3000;
+				TIMER_Set( NPC, "chatter", 3000 );
+			}
+
+			//grip
+			TIMER_Set( NPC, "gripping", 3000 );
+			TIMER_Set( NPC, "attackDelay", 3000 );
+		}
+		else
+		{
+			int chanceScale;
+
+			if ( NPC->enemy && NPC->enemy->client && (NPC->enemy->client->ps.fd.forcePowersActive&(1<<FP_GRIP)) )
+			{//They're choking someone, probably an ally, run at them and do some sort of attack
+				if ( NPC->enemy->client->ps.groundEntityNum != ENTITYNUM_NONE )
+				{//they're on the ground, so advance
+					if ( TIMER_Done( NPC, "parryTime" ) || NPCInfo->rank > RANK_LT )
+					{//not parrying
+						if ( enemy_dist > 200 || !(NPCInfo->scriptFlags&SCF_DONT_FIRE) )
+						{//far away or allowed to use saber
+							Jedi_Advance();
+						}
+					}
+				}
+			}
+			chanceScale = 0;
+			if ( NPC->client->NPC_class == CLASS_DESANN || !Q_stricmp("Yoda",NPC->NPC_type) )
+			{
+				chanceScale = 1;
+			}
+			else if ( NPCInfo->rank == RANK_ENSIGN )
+			{
+				chanceScale = 2;
+			}
+			else if ( NPCInfo->rank >= RANK_LT_JG )
+			{
+				chanceScale = 5;
+			}
+			if ( chanceScale 
+				&& (enemy_dist > Q_irand( 100, 200 ) || (NPCInfo->scriptFlags&SCF_DONT_FIRE) || (!Q_stricmp("Yoda",NPC->NPC_type)&&!Q_irand(0,3)) )
+				&& enemy_dist < 500 
+				&& (Q_irand( 0, chanceScale*10 )<5 || (NPC->enemy->client && NPC->enemy->client->ps.weapon != WP_SABER && !Q_irand( 0, chanceScale ) ) ) )
+			{//else, randomly try some kind of attack every now and then
+				if ( (NPCInfo->rank == RANK_ENSIGN || NPCInfo->rank > RANK_LT_JG) && !Q_irand( 0, 1 ) )
+				{
+					if ( WP_ForcePowerAvailable( NPC, FP_PULL, 0 ) && !Q_irand( 0, 2 ) )
+					{
+						//force pull the guy to me!
+						//FIXME: check forcePushRadius[NPC->client->ps.fd.forcePowerLevel[FP_PUSH]]
+						ForceThrow( NPC, qtrue );
+						//maybe strafe too?
+						TIMER_Set( NPC, "duck", enemy_dist*3 );
+						if ( Q_irand( 0, 1 ) )
+						{
+							ucmd.buttons |= BUTTON_ATTACK;
+						}
+					}
+					else if ( WP_ForcePowerAvailable( NPC, FP_LIGHTNING, 0 ) && Q_irand( 0, 1 ) )
+					{
+						ForceLightning( NPC );
+						if ( NPC->client->ps.fd.forcePowerLevel[FP_LIGHTNING] > FORCE_LEVEL_1 )
+						{
+							NPC->client->ps.weaponTime = Q_irand( 1000, 3000+(g_spskill.integer*500) );
+							TIMER_Set( NPC, "holdLightning", NPC->client->ps.weaponTime );
+						}
+						TIMER_Set( NPC, "attackDelay", NPC->client->ps.weaponTime );
+					}
+					/*else if ( NPC->health < NPC->client->pers.maxHealth * 0.75f
+						&& Q_irand( FORCE_LEVEL_0, NPC->client->ps.fd.forcePowerLevel[FP_DRAIN] ) > FORCE_LEVEL_1
+						&& WP_ForcePowerAvailable( NPC, FP_DRAIN, 0 ) 
+						&& Q_irand( 0, 1 ) )
+					{
+						ForceDrain2( NPC );
+						NPC->client->ps.weaponTime = Q_irand( 1000, 3000+(g_spskill.integer*500) );
+						TIMER_Set( NPC, "draining", NPC->client->ps.weaponTime );
+						TIMER_Set( NPC, "attackDelay", NPC->client->ps.weaponTime );
+					}*/
+					//rwwFIXMEFIXME: After new drain stuff from SP is in re-enable this.
+					else if ( WP_ForcePowerAvailable( NPC, FP_GRIP, 0 ) )
+					{
+						//taunt
+						if ( TIMER_Done( NPC, "chatter" ) && jediSpeechDebounceTime[NPC->client->playerTeam] < level.time && NPCInfo->blockedSpeechDebounceTime < level.time )
+						{
+							G_AddVoiceEvent( NPC, Q_irand( EV_TAUNT1, EV_TAUNT3 ), 3000 );
+							jediSpeechDebounceTime[NPC->client->playerTeam] = NPCInfo->blockedSpeechDebounceTime = level.time + 3000;
+							TIMER_Set( NPC, "chatter", 3000 );
+						}
+
+						//grip
+						TIMER_Set( NPC, "gripping", 3000 );
+						TIMER_Set( NPC, "attackDelay", 3000 );
+					}
+					else
+					{
+						if ( WP_ForcePowerAvailable( NPC, FP_SABERTHROW, 0 ) 
+							&& !(NPC->client->ps.fd.forcePowersActive&(1 << FP_SPEED))
+							&& !(NPC->client->ps.saberEventFlags&SEF_INWATER) )//saber not in water
+						{//throw saber
+							ucmd.buttons |= BUTTON_ALT_ATTACK;
+						}
+					}
+				}
+				else
+				{
+					if ( NPCInfo->rank >= RANK_LT_JG 
+						&& !(NPC->client->ps.fd.forcePowersActive&(1 << FP_SPEED))
+						&& !(NPC->client->ps.saberEventFlags&SEF_INWATER) )//saber not in water
+					{//throw saber
+						ucmd.buttons |= BUTTON_ALT_ATTACK;
+					}
+				}
+			}
+			//see if we should advance now
+			else if ( NPCInfo->stats.aggression > 5 )
+			{//approach enemy
+				if ( TIMER_Done( NPC, "parryTime" ) || NPCInfo->rank > RANK_LT )
+				{//not parrying
+					if ( !NPC->enemy->client || NPC->enemy->client->ps.groundEntityNum != ENTITYNUM_NONE )
+					{//they're on the ground, so advance
+						if ( enemy_dist > 200 || !(NPCInfo->scriptFlags&SCF_DONT_FIRE) )
+						{//far away or allowed to use saber
+							Jedi_Advance();
+						}
+					}
+				}
+			}
+			else
+			{//maintain this distance?
+				//walk?
+			}
+		}
+	}
+	else
+	{//we're not close enough to attack, but not far enough away to be safe
+		if ( NPCInfo->stats.aggression < 4 )
+		{//back off and defend
+			Jedi_Retreat();
+		}
+		else if ( NPCInfo->stats.aggression > 5 )
+		{//try to get closer
+			if ( enemy_dist > 0 && !(NPCInfo->scriptFlags&SCF_DONT_FIRE))
+			{//we're allowed to use our lightsaber, get closer
+				if ( TIMER_Done( NPC, "parryTime" ) || NPCInfo->rank > RANK_LT )
+				{//not parrying
+					if ( !NPC->enemy->client || NPC->enemy->client->ps.groundEntityNum != ENTITYNUM_NONE )
+					{//they're on the ground, so advance
+						Jedi_Advance();
+					}
+				}
+			}
+		}
+		else
+		{//agression is 4 or 5... somewhere in the middle
+			//what do we do here?  Nothing?
+			//Move forward and back?
+		}
+	}
+	//if really really mad, rage!
+	if ( NPCInfo->stats.aggression > Q_irand( 5, 15 )
+		&& NPC->health < NPC->client->pers.maxHealth*0.75f 
+		&& !Q_irand( 0, 2 ) )
+	{
+		if ( (NPC->client->ps.fd.forcePowersKnown&(1<<FP_RAGE)) != 0 
+			&& (NPC->client->ps.fd.forcePowersActive&(1<<FP_RAGE)) == 0 )
+		{
+			Jedi_Rage();
+		}
+	}
+}
+
+static qboolean Jedi_Strafe( int strafeTimeMin, int strafeTimeMax, int nextStrafeTimeMin, int nextStrafeTimeMax, qboolean walking )
+{
+	if ( NPC->client->ps.saberEventFlags&SEF_LOCK_WON && NPC->enemy && NPC->enemy->painDebounceTime > level.time )
+	{//don't strafe if pressing the advantage of winning a saberLock
+		return qfalse;
+	}
+	if ( TIMER_Done( NPC, "strafeLeft" ) && TIMER_Done( NPC, "strafeRight" ) )
+	{
+		qboolean strafed = qfalse;
+		//TODO: make left/right choice a tactical decision rather than random:
+		//		try to keep own back away from walls and ledges, 
+		//		try to keep enemy's back to a ledge or wall
+		//		Maybe try to strafe toward designer-placed "safe spots" or "goals"?
+		int	strafeTime = Q_irand( strafeTimeMin, strafeTimeMax );
+
+		if ( Q_irand( 0, 1 ) )
+		{
+			if ( NPC_MoveDirClear( ucmd.forwardmove, -127, qfalse ) )
+			{
+				TIMER_Set( NPC, "strafeLeft", strafeTime );
+				strafed = qtrue;
+			}
+			else if ( NPC_MoveDirClear( ucmd.forwardmove, 127, qfalse ) )
+			{
+				TIMER_Set( NPC, "strafeRight", strafeTime );
+				strafed = qtrue;
+			}
+		}
+		else
+		{
+			if ( NPC_MoveDirClear( ucmd.forwardmove, 127, qfalse  ) )
+			{
+				TIMER_Set( NPC, "strafeRight", strafeTime );
+				strafed = qtrue;
+			}
+			else if ( NPC_MoveDirClear( ucmd.forwardmove, -127, qfalse  ) )
+			{
+				TIMER_Set( NPC, "strafeLeft", strafeTime );
+				strafed = qtrue;
+			}
+		}
+
+		if ( strafed )
+		{
+			TIMER_Set( NPC, "noStrafe", strafeTime + Q_irand( nextStrafeTimeMin, nextStrafeTimeMax ) );
+			if ( walking )
+			{//should be a slow strafe
+				TIMER_Set( NPC, "walking", strafeTime );
+			}
+			return qtrue;
+		}
+	}
+	return qfalse;
+}
+
+/*
+static void Jedi_FaceEntity( gentity_t *self, gentity_t *other, qboolean doPitch )
+{
+	vec3_t		entPos;
+	vec3_t		muzzle;
+
+	//Get the positions
+	CalcEntitySpot( other, SPOT_ORIGIN, entPos );
+
+	//Get the positions
+	CalcEntitySpot( self, SPOT_HEAD_LEAN, muzzle );//SPOT_HEAD
+
+	//Find the desired angles
+	vec3_t	angles;
+
+	GetAnglesForDirection( muzzle, entPos, angles );
+
+	self->NPC->desiredYaw		= AngleNormalize360( angles[YAW] );
+	if ( doPitch )
+	{
+		self->NPC->desiredPitch	= AngleNormalize360( angles[PITCH] );
+	}
+}
+*/
+
+/*
+qboolean Jedi_DodgeEvasion( gentity_t *self, gentity_t *shooter, trace_t *tr, int hitLoc )
+
+Jedi will play a dodge anim, blur, and make the force speed noise.
+
+Right now used to dodge instant-hit weapons.
+
+FIXME: possibly call this for saber melee evasion and/or missile evasion?
+FIXME: possibly let player do this too?
+*/
+//rwwFIXMEFIXME: Going to use qboolean Jedi_DodgeEvasion( gentity_t *self, gentity_t *shooter, trace_t *tr, int hitLoc ) from
+//w_saber.c.. maybe use seperate one for NPCs or add cases to that one?
+
+evasionType_t Jedi_CheckFlipEvasions( gentity_t *self, float rightdot, float zdiff )
+{
+	if ( self->NPC && (self->NPC->scriptFlags&SCF_NO_ACROBATICS) )
+	{
+		return EVASION_NONE;
+	}
+	if ( self->client 
+		&& (self->client->ps.fd.forceRageRecoveryTime > level.time	|| (self->client->ps.fd.forcePowersActive&(1<<FP_RAGE))) )
+	{//no fancy dodges when raging
+		return EVASION_NONE;
+	}
+	//Check for:
+	//ARIALS/CARTWHEELS
+	//WALL-RUNS
+	//WALL-FLIPS
+	//FIXME: if facing a wall, do forward wall-walk-backflip
+	if ( self->client->ps.legsAnim == BOTH_WALL_RUN_LEFT || self->client->ps.legsAnim == BOTH_WALL_RUN_RIGHT )
+	{//already running on a wall
+		vec3_t right, fwdAngles;
+		int		anim = -1;
+		float animLength;
+
+		VectorSet(fwdAngles, 0, self->client->ps.viewangles[YAW], 0);
+
+		AngleVectors( fwdAngles, NULL, right, NULL );
+
+		animLength = BG_AnimLength( self->localAnimIndex, (animNumber_t)self->client->ps.legsAnim );
+		if ( self->client->ps.legsAnim == BOTH_WALL_RUN_LEFT && rightdot < 0 )
+		{//I'm running on a wall to my left and the attack is on the left
+			if ( animLength - self->client->ps.legsTimer > 400
+				&& self->client->ps.legsTimer > 400 )
+			{//not at the beginning or end of the anim
+				anim = BOTH_WALL_RUN_LEFT_FLIP;
+			}
+		}
+		else if ( self->client->ps.legsAnim == BOTH_WALL_RUN_RIGHT && rightdot > 0 )
+		{//I'm running on a wall to my right and the attack is on the right
+			if ( animLength - self->client->ps.legsTimer > 400
+				&& self->client->ps.legsTimer > 400 )
+			{//not at the beginning or end of the anim
+				anim = BOTH_WALL_RUN_RIGHT_FLIP;
+			}
+		}
+		if ( anim != -1 )
+		{//flip off the wall!
+			int parts;
+			//FIXME: check the direction we will flip towards for do-not-enter/walls/drops?
+			//NOTE: we presume there is still a wall there!
+			if ( anim == BOTH_WALL_RUN_LEFT_FLIP )
+			{
+				self->client->ps.velocity[0] *= 0.5f;
+				self->client->ps.velocity[1] *= 0.5f;
+				VectorMA( self->client->ps.velocity, 150, right, self->client->ps.velocity );
+			}
+			else if ( anim == BOTH_WALL_RUN_RIGHT_FLIP )
+			{
+				self->client->ps.velocity[0] *= 0.5f;
+				self->client->ps.velocity[1] *= 0.5f;
+				VectorMA( self->client->ps.velocity, -150, right, self->client->ps.velocity );
+			}
+			parts = SETANIM_LEGS;
+			if ( !self->client->ps.weaponTime )
+			{
+				parts = SETANIM_BOTH;
+			}
+			NPC_SetAnim( self, parts, anim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+			//self->client->ps.pm_flags |= (PMF_JUMPING|PMF_SLOW_MO_FALL);
+			//rwwFIXMEFIXME: Add these pm flags?
+			G_AddEvent( self, EV_JUMP, 0 );
+			return EVASION_OTHER;
+		}
+	}
+	else if ( self->client->NPC_class != CLASS_DESANN //desann doesn't do these kind of frilly acrobatics
+		&& (self->NPC->rank == RANK_CREWMAN || self->NPC->rank >= RANK_LT) 
+		&& Q_irand( 0, 1 ) 
+		&& !BG_InRoll( &self->client->ps, self->client->ps.legsAnim )
+		&& !PM_InKnockDown( &self->client->ps )
+		&& !BG_SaberInSpecialAttack( self->client->ps.torsoAnim ) )
+	{
+		vec3_t fwd, right, traceto, mins, maxs, fwdAngles;
+		trace_t	trace;
+		int parts, anim;
+		float	speed, checkDist;
+
+		VectorSet(mins, self->r.mins[0],self->r.mins[1],0);
+		VectorSet(maxs, self->r.maxs[0],self->r.maxs[1],24);
+		VectorSet(fwdAngles, 0, self->client->ps.viewangles[YAW], 0);
+
+		AngleVectors( fwdAngles, fwd, right, NULL );
+
+		parts = SETANIM_BOTH;
+
+		if ( BG_SaberInAttack( self->client->ps.saberMove )
+			|| PM_SaberInStart( self->client->ps.saberMove ) )
+		{
+			parts = SETANIM_LEGS;
+		}
+		if ( rightdot >= 0 )
+		{
+			if ( Q_irand( 0, 1 ) )
+			{
+				anim = BOTH_ARIAL_LEFT;
+			}
+			else
+			{
+				anim = BOTH_CARTWHEEL_LEFT;
+			}
+			checkDist = -128;
+			speed = -200;
+		}
+		else
+		{
+			if ( Q_irand( 0, 1 ) )
+			{
+				anim = BOTH_ARIAL_RIGHT;
+			}
+			else
+			{
+				anim = BOTH_CARTWHEEL_RIGHT;
+			}
+			checkDist = 128;
+			speed = 200;
+		}
+		//trace in the dir that we want to go
+		VectorMA( self->r.currentOrigin, checkDist, right, traceto );
+		trap_Trace( &trace, self->r.currentOrigin, mins, maxs, traceto, self->s.number, CONTENTS_SOLID|CONTENTS_MONSTERCLIP|CONTENTS_BOTCLIP );
+		if ( trace.fraction >= 1.0f )
+		{//it's clear, let's do it
+			//FIXME: check for drops?
+			vec3_t fwdAngles, jumpRt;
+
+			NPC_SetAnim( self, parts, anim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+			self->client->ps.weaponTime = self->client->ps.legsTimer;//don't attack again until this anim is done
+			VectorCopy( self->client->ps.viewangles, fwdAngles );
+			fwdAngles[PITCH] = fwdAngles[ROLL] = 0;
+			//do the flip
+			AngleVectors( fwdAngles, NULL, jumpRt, NULL );
+			VectorScale( jumpRt, speed, self->client->ps.velocity );
+			self->client->ps.fd.forceJumpCharge = 0;//so we don't play the force flip anim
+			self->client->ps.velocity[2] = 200;
+			self->client->ps.fd.forceJumpZStart = self->r.currentOrigin[2];//so we don't take damage if we land at same height
+			//self->client->ps.pm_flags |= PMF_JUMPING;
+			if ( self->client->NPC_class == CLASS_BOBAFETT )
+			{
+				G_AddEvent( self, EV_JUMP, 0 );
+			}
+			else
+			{
+				G_SoundOnEnt( self, CHAN_BODY, "sound/weapons/force/jump.wav" );
+			}
+			//ucmd.upmove = 0;
+			return EVASION_CARTWHEEL;
+		}
+		else if ( !(trace.contents&CONTENTS_BOTCLIP) )
+		{//hit a wall, not a do-not-enter brush
+			//FIXME: before we check any of these jump-type evasions, we should check for headroom, right?
+			//Okay, see if we can flip *off* the wall and go the other way
+			vec3_t	idealNormal;
+			gentity_t *traceEnt;
+
+			VectorSubtract( self->r.currentOrigin, traceto, idealNormal );
+			VectorNormalize( idealNormal );
+			traceEnt = &g_entities[trace.entityNum];
+			if ( (trace.entityNum<ENTITYNUM_WORLD&&traceEnt&&traceEnt->s.solid!=SOLID_BMODEL) || DotProduct( trace.plane.normal, idealNormal ) > 0.7f )
+			{//it's a ent of some sort or it's a wall roughly facing us
+				float bestCheckDist = 0;
+				//hmm, see if we're moving forward
+				if ( DotProduct( self->client->ps.velocity, fwd ) < 200 )
+				{//not running forward very fast
+					//check to see if it's okay to move the other way
+					if ( (trace.fraction*checkDist) <= 32 )
+					{//wall on that side is close enough to wall-flip off of or wall-run on
+						bestCheckDist = checkDist;
+						checkDist *= -1.0f;
+						VectorMA( self->r.currentOrigin, checkDist, right, traceto );
+						//trace in the dir that we want to go
+						trap_Trace( &trace, self->r.currentOrigin, mins, maxs, traceto, self->s.number, CONTENTS_SOLID|CONTENTS_MONSTERCLIP|CONTENTS_BOTCLIP );
+						if ( trace.fraction >= 1.0f )
+						{//it's clear, let's do it
+							int parts;
+
+							//FIXME: check for drops?
+							//turn the cartwheel into a wallflip in the other dir
+							if ( rightdot > 0 )
+							{
+								anim = BOTH_WALL_FLIP_LEFT;
+								self->client->ps.velocity[0] = self->client->ps.velocity[1] = 0;
+								VectorMA( self->client->ps.velocity, 150, right, self->client->ps.velocity );
+							}
+							else
+							{
+								anim = BOTH_WALL_FLIP_RIGHT;
+								self->client->ps.velocity[0] = self->client->ps.velocity[1] = 0;
+								VectorMA( self->client->ps.velocity, -150, right, self->client->ps.velocity );
+							}
+							self->client->ps.velocity[2] = forceJumpStrength[FORCE_LEVEL_2]/2.25f;
+							//animate me
+							parts = SETANIM_LEGS;
+							if ( !self->client->ps.weaponTime )
+							{
+								parts = SETANIM_BOTH;
+							}
+							NPC_SetAnim( self, parts, anim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+							self->client->ps.fd.forceJumpZStart = self->r.currentOrigin[2];//so we don't take damage if we land at same height
+							//self->client->ps.pm_flags |= (PMF_JUMPING|PMF_SLOW_MO_FALL);
+							if ( self->client->NPC_class == CLASS_BOBAFETT )
+							{
+								G_AddEvent( self, EV_JUMP, 0 );
+							}
+							else
+							{
+								G_SoundOnEnt( self, CHAN_BODY, "sound/weapons/force/jump.wav" );
+							}
+							return EVASION_OTHER;
+						}
+						else 
+						{//boxed in on both sides
+							if ( DotProduct( self->client->ps.velocity, fwd ) < 0 )
+							{//moving backwards
+								return EVASION_NONE;
+							}
+							if ( (trace.fraction*checkDist) <= 32 && (trace.fraction*checkDist) < bestCheckDist )
+							{
+								bestCheckDist = checkDist;
+							}
+						}
+					}
+					else
+					{//too far from that wall to flip or run off it, check other side
+						checkDist *= -1.0f;
+						VectorMA( self->r.currentOrigin, checkDist, right, traceto );
+						//trace in the dir that we want to go
+						trap_Trace( &trace, self->r.currentOrigin, mins, maxs, traceto, self->s.number, CONTENTS_SOLID|CONTENTS_MONSTERCLIP|CONTENTS_BOTCLIP );
+						if ( (trace.fraction*checkDist) <= 32 )
+						{//wall on this side is close enough
+							bestCheckDist = checkDist;
+						}
+						else
+						{//neither side has a wall within 32
+							return EVASION_NONE;
+						}
+					}
+				}
+				//Try wall run?
+				if ( bestCheckDist )
+				{//one of the walls was close enough to wall-run on
+					int parts;
+
+					//FIXME: check for long enough wall and a drop at the end?
+					if ( bestCheckDist > 0 )
+					{//it was to the right
+						anim = BOTH_WALL_RUN_RIGHT;
+					}
+					else
+					{//it was to the left
+						anim = BOTH_WALL_RUN_LEFT;
+					}
+					self->client->ps.velocity[2] = forceJumpStrength[FORCE_LEVEL_2]/2.25f;
+					//animate me
+					parts = SETANIM_LEGS;
+					if ( !self->client->ps.weaponTime )
+					{
+						parts = SETANIM_BOTH;
+					}
+					NPC_SetAnim( self, parts, anim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+					self->client->ps.fd.forceJumpZStart = self->r.currentOrigin[2];//so we don't take damage if we land at same height
+					//self->client->ps.pm_flags |= (PMF_JUMPING|PMF_SLOW_MO_FALL);
+					if ( self->client->NPC_class == CLASS_BOBAFETT )
+					{
+						G_AddEvent( self, EV_JUMP, 0 );
+					}
+					else
+					{
+						G_SoundOnEnt( self, CHAN_BODY, "sound/weapons/force/jump.wav" );
+					}
+					return EVASION_OTHER;
+				}
+				//else check for wall in front, do backflip off wall
+			}
+		}
+	}
+	return EVASION_NONE;
+}
+
+int Jedi_ReCalcParryTime( gentity_t *self, evasionType_t evasionType )
+{
+	if ( !self->client )
+	{
+		return 0;
+	}
+	if ( !self->s.number )
+	{//player 
+		return bg_parryDebounce[self->client->ps.fd.forcePowerLevel[FP_SABER_DEFENSE]];
+	}
+	else if ( self->NPC )
+	{
+		if ( !g_saberRealisticCombat.integer 
+			&& ( g_spskill.integer == 2 || (g_spskill.integer == 1 && self->client->NPC_class == CLASS_TAVION) ) )
+		{
+			if ( self->client->NPC_class == CLASS_TAVION )
+			{
+				return 0;
+			}
+			else
+			{
+				return Q_irand( 0, 150 );
+			}
+		}
+		else
+		{
+			int	baseTime;
+			if ( evasionType == EVASION_DODGE )
+			{
+				baseTime = self->client->ps.torsoTimer;
+			}
+			else if ( evasionType == EVASION_CARTWHEEL )
+			{
+				baseTime = self->client->ps.torsoTimer;
+			}
+			else if ( self->client->ps.saberInFlight )
+			{
+				baseTime = Q_irand( 1, 3 ) * 50;
+			}
+			else
+			{
+				if ( g_saberRealisticCombat.integer )
+				{
+					baseTime = 500;
+
+					switch ( g_spskill.integer )
+					{
+					case 0:
+						baseTime = 500;
+						break;
+					case 1:
+						baseTime = 300;
+						break;
+					case 2:
+					default:
+						baseTime = 100;
+						break;
+					}
+				}
+				else
+				{
+					baseTime = 150;//500;
+
+					switch ( g_spskill.integer )
+					{
+					case 0:
+						baseTime = 200;//500;
+						break;
+					case 1:
+						baseTime = 100;//300;
+						break;
+					case 2:
+					default:
+						baseTime = 50;//100;
+						break;
+					}
+				}
+
+				if ( self->client->NPC_class == CLASS_TAVION )
+				{//Tavion is faster
+					baseTime = ceil(baseTime/2.0f);
+				}
+				else if ( self->NPC->rank >= RANK_LT_JG )
+				{//fencers, bosses, shadowtroopers, luke, desann, et al use the norm
+					if ( Q_irand( 0, 2 ) )
+					{//medium speed parry
+						baseTime = baseTime;
+					}
+					else
+					{//with the occasional fast parry
+						baseTime = ceil(baseTime/2.0f);
+					}
+				}
+				else if ( self->NPC->rank == RANK_CIVILIAN )
+				{//grunts are slowest
+					baseTime = baseTime*Q_irand(1,3);
+				}
+				else if ( self->NPC->rank == RANK_CREWMAN )
+				{//acrobats aren't so bad
+					if ( evasionType == EVASION_PARRY
+						|| evasionType == EVASION_DUCK_PARRY
+						|| evasionType == EVASION_JUMP_PARRY )
+					{//slower with parries
+						baseTime = baseTime*Q_irand(1,2);
+					}
+					else
+					{//faster with acrobatics
+						//baseTime = baseTime;
+					}
+				}
+				else
+				{//force users are kinda slow
+					baseTime = baseTime*Q_irand(1,2);
+				}
+				if ( evasionType == EVASION_DUCK || evasionType == EVASION_DUCK_PARRY )
+				{
+					baseTime += 100;
+				}
+				else if ( evasionType == EVASION_JUMP || evasionType == EVASION_JUMP_PARRY )
+				{
+					baseTime += 50;
+				}
+				else if ( evasionType == EVASION_OTHER )
+				{
+					baseTime += 100;
+				}
+				else if ( evasionType == EVASION_FJUMP )
+				{
+					baseTime += 100;
+				}
+			}
+			
+			return baseTime;
+		}
+	}
+	return 0;
+}
+
+qboolean Jedi_QuickReactions( gentity_t *self )
+{
+	if ( ( self->client->NPC_class == CLASS_JEDI && NPCInfo->rank == RANK_COMMANDER ) ||
+		self->client->NPC_class == CLASS_TAVION ||
+		(self->client->ps.fd.forcePowerLevel[FP_SABER_DEFENSE]>FORCE_LEVEL_1&&g_spskill.integer>1) ||
+		(self->client->ps.fd.forcePowerLevel[FP_SABER_DEFENSE]>FORCE_LEVEL_2&&g_spskill.integer>0) )
+	{
+		return qtrue;
+	}
+	return qfalse;
+}
+
+qboolean Jedi_SaberBusy( gentity_t *self )
+{
+	if ( self->client->ps.torsoTimer > 300 
+	&& ( (BG_SaberInAttack( self->client->ps.saberMove )&&self->client->ps.fd.saberAnimLevel==FORCE_LEVEL_3) 
+		|| BG_SpinningSaberAnim( self->client->ps.torsoAnim ) 
+		|| BG_SaberInSpecialAttack( self->client->ps.torsoAnim ) 
+		//|| PM_SaberInBounce( self->client->ps.saberMove ) 
+		|| PM_SaberInBrokenParry( self->client->ps.saberMove ) 
+		//|| PM_SaberInDeflect( self->client->ps.saberMove ) 
+		|| BG_FlippingAnim( self->client->ps.torsoAnim ) 
+		|| PM_RollingAnim( self->client->ps.torsoAnim ) ) )
+	{//my saber is not in a parrying position
+		return qtrue;
+	}
+	return qfalse;
+}
+
+/*
+-------------------------
+Jedi_SaberBlock
+
+Pick proper block anim
+
+FIXME: Based on difficulty level/enemy saber combat skill, make this decision-making more/less effective
+
+NOTE: always blocking projectiles in this func!
+
+-------------------------
+*/
+extern qboolean G_FindClosestPointOnLineSegment( const vec3_t start, const vec3_t end, const vec3_t from, vec3_t result );
+evasionType_t Jedi_SaberBlockGo( gentity_t *self, usercmd_t *cmd, vec3_t pHitloc, vec3_t phitDir, gentity_t *incoming, float dist ) //dist = 0.0f
+{
+	vec3_t hitloc, hitdir, diff, fwdangles={0,0,0}, right;
+	float rightdot;
+	float zdiff;
+	int	  duckChance = 0;
+	int	  dodgeAnim = -1;
+	qboolean	saberBusy = qfalse, evaded = qfalse, doDodge = qfalse;
+	evasionType_t	evasionType = EVASION_NONE;
+
+	//FIXME: if we don't have our saber in hand, pick the force throw option or a jump or strafe!
+	//FIXME: reborn don't block enough anymore
+	if ( !incoming )
+	{
+		VectorCopy( pHitloc, hitloc );
+		VectorCopy( phitDir, hitdir );
+		//FIXME: maybe base this on rank some?  And/or g_spskill?
+		if ( self->client->ps.saberInFlight )
+		{//DOH!  do non-saber evasion!
+			saberBusy = qtrue;
+		}
+		else if ( Jedi_QuickReactions( self ) )
+		{//jedi trainer and tavion are must faster at parrying and can do it whenever they like
+			//Also, on medium, all level 3 people can parry any time and on hard, all level 2 or 3 people can parry any time
+		}
+		else
+		{
+			saberBusy = Jedi_SaberBusy( self );
+		}
+	}
+	else
+	{	
+		if ( incoming->s.weapon == WP_SABER )
+		{//flying lightsaber, face it!
+			//FIXME: for this to actually work, we'd need to call update angles too?
+			//Jedi_FaceEntity( self, incoming, qtrue );
+		}
+		VectorCopy( incoming->r.currentOrigin, hitloc );
+		VectorNormalize2( incoming->s.pos.trDelta, hitdir );
+	}
+	if ( self->client && self->client->NPC_class == CLASS_BOBAFETT )
+	{
+		saberBusy = qtrue;
+	}
+
+	VectorSubtract( hitloc, self->client->renderInfo.eyePoint, diff );
+	diff[2] = 0;
+	//VectorNormalize( diff );
+	fwdangles[1] = self->client->ps.viewangles[1];
+	// Ultimately we might care if the shot was ahead or behind, but for now, just quadrant is fine.
+	AngleVectors( fwdangles, NULL, right, NULL );
+
+	rightdot = DotProduct(right, diff);// + flrand(-0.10f,0.10f);
+	//totalHeight = self->client->renderInfo.eyePoint[2] - self->r.absmin[2];
+	zdiff = hitloc[2] - self->client->renderInfo.eyePoint[2];// + Q_irand(-6,6);
+	
+	//see if we can dodge if need-be
+	if ( (dist>16&&(Q_irand( 0, 2 )||saberBusy)) 
+		|| self->client->ps.saberInFlight 
+		|| BG_SabersOff( &self->client->ps )
+		|| self->client->NPC_class == CLASS_BOBAFETT )
+	{//either it will miss by a bit (and 25% chance) OR our saber is not in-hand OR saber is off
+		if ( self->NPC && (self->NPC->rank == RANK_CREWMAN || self->NPC->rank >= RANK_LT_JG) )
+		{//acrobat or fencer or above
+			if ( self->client->ps.groundEntityNum != ENTITYNUM_NONE &&//on the ground
+				!(self->client->ps.pm_flags&PMF_DUCKED)&&cmd->upmove>=0&&TIMER_Done( self, "duck" )//not ducking
+				&& !BG_InRoll( &self->client->ps, self->client->ps.legsAnim )//not rolling
+				&& !PM_InKnockDown( &self->client->ps )//not knocked down
+				&& ( self->client->ps.saberInFlight ||
+					self->client->NPC_class == CLASS_BOBAFETT ||
+					(!BG_SaberInAttack( self->client->ps.saberMove )//not attacking
+					&& !PM_SaberInStart( self->client->ps.saberMove )//not starting an attack
+					&& !BG_SpinningSaberAnim( self->client->ps.torsoAnim )//not in a saber spin
+					&& !BG_SaberInSpecialAttack( self->client->ps.torsoAnim ))//not in a special attack
+					)
+				)
+			{//need to check all these because it overrides both torso and legs with the dodge
+				doDodge = qtrue;
+			}
+		}
+	}
+	// Figure out what quadrant the block was in.
+	if ( d_JediAI.integer )
+	{
+		Com_Printf( "(%d) evading attack from height %4.2f, zdiff: %4.2f, rightdot: %4.2f\n", level.time, hitloc[2]-self->r.absmin[2],zdiff,rightdot);
+	}
+
+	//UL = > -1//-6
+	//UR = > -6//-9
+	//TOP = > +6//+4
+	//FIXME: take FP_SABER_DEFENSE into account here somehow?
+	if ( zdiff >= -5 )//was 0
+	{
+		if ( incoming || !saberBusy )
+		{
+			if ( rightdot > 12 
+				|| (rightdot > 3 && zdiff < 5) 
+				|| (!incoming&&fabs(hitdir[2])<0.25f) )//was normalized, 0.3
+			{//coming from right
+				if ( doDodge )
+				{
+					if ( self->client->NPC_class == CLASS_BOBAFETT && !Q_irand( 0, 2 ) )
+					{//roll!
+						TIMER_Start( self, "duck", Q_irand( 500, 1500 ) );
+						TIMER_Start( self, "strafeLeft", Q_irand( 500, 1500 ) );
+						TIMER_Set( self, "strafeRight", 0 );
+						evasionType = EVASION_DUCK;
+						evaded = qtrue;
+					}
+					else if ( Q_irand( 0, 1 ) )
+					{
+						dodgeAnim = BOTH_DODGE_FL;
+					}
+					else
+					{
+						dodgeAnim = BOTH_DODGE_BL;
+					}
+				}
+				else
+				{
+					self->client->ps.saberBlocked = BLOCKED_UPPER_RIGHT;
+					evasionType = EVASION_PARRY;
+					if ( self->client->ps.groundEntityNum != ENTITYNUM_NONE )
+					{
+						if ( zdiff > 5 )
+						{
+							TIMER_Start( self, "duck", Q_irand( 500, 1500 ) );
+							evasionType = EVASION_DUCK_PARRY;
+							evaded = qtrue;
+							if ( d_JediAI.integer )
+							{
+								Com_Printf( "duck " );
+							}
+						}
+						else
+						{
+							duckChance = 6;
+						}
+					}
+				}
+				if ( d_JediAI.integer )
+				{
+					Com_Printf( "UR block\n" );
+				}
+			}
+			else if ( rightdot < -12 
+				|| (rightdot < -3 && zdiff < 5) 
+				|| (!incoming&&fabs(hitdir[2])<0.25f) )//was normalized, -0.3
+			{//coming from left
+				if ( doDodge )
+				{
+					if ( self->client->NPC_class == CLASS_BOBAFETT && !Q_irand( 0, 2 ) )
+					{//roll!
+						TIMER_Start( self, "duck", Q_irand( 500, 1500 ) );
+						TIMER_Start( self, "strafeRight", Q_irand( 500, 1500 ) );
+						TIMER_Set( self, "strafeLeft", 0 );
+						evasionType = EVASION_DUCK;
+						evaded = qtrue;
+					}
+					else if ( Q_irand( 0, 1 ) )
+					{
+						dodgeAnim = BOTH_DODGE_FR;
+					}
+					else
+					{
+						dodgeAnim = BOTH_DODGE_BR;
+					}
+				}
+				else
+				{
+					self->client->ps.saberBlocked = BLOCKED_UPPER_LEFT;
+					evasionType = EVASION_PARRY;
+					if ( self->client->ps.groundEntityNum != ENTITYNUM_NONE )
+					{
+						if ( zdiff > 5 )
+						{
+							TIMER_Start( self, "duck", Q_irand( 500, 1500 ) );
+							evasionType = EVASION_DUCK_PARRY;
+							evaded = qtrue;
+							if ( d_JediAI.integer )
+							{
+								Com_Printf( "duck " );
+							}
+						}
+						else
+						{
+							duckChance = 6;
+						}
+					}
+				}
+				if ( d_JediAI.integer )
+				{
+					Com_Printf( "UL block\n" );
+				}
+			}
+			else
+			{
+				self->client->ps.saberBlocked = BLOCKED_TOP;
+				evasionType = EVASION_PARRY;
+				if ( self->client->ps.groundEntityNum != ENTITYNUM_NONE )
+				{
+					duckChance = 4;
+				}
+				if ( d_JediAI.integer )
+				{
+					Com_Printf( "TOP block\n" );
+				}
+			}
+			evaded = qtrue;
+		}
+		else
+		{
+			if ( self->client->ps.groundEntityNum != ENTITYNUM_NONE )
+			{
+				//duckChance = 2;
+				TIMER_Start( self, "duck", Q_irand( 500, 1500 ) );
+				evasionType = EVASION_DUCK;
+				evaded = qtrue;
+				if ( d_JediAI.integer )
+				{
+					Com_Printf( "duck " );
+				}
+			}
+		}
+	}
+	//LL = -22//= -18 to -39
+	//LR = -23//= -20 to -41
+	else if ( zdiff > -22 )//was-15 )
+	{
+		if ( 1 )//zdiff < -10 )
+		{//hmm, pretty low, but not low enough to use the low block, so we need to duck
+			if ( self->client->ps.groundEntityNum != ENTITYNUM_NONE )
+			{
+				//duckChance = 2;
+				TIMER_Start( self, "duck", Q_irand( 500, 1500 ) );
+				evasionType = EVASION_DUCK;
+				evaded = qtrue;
+				if ( d_JediAI.integer )
+				{
+					Com_Printf( "duck " );
+				}
+			}
+			else
+			{//in air!  Ducking does no good
+			}
+		}
+		if ( incoming || !saberBusy )
+		{
+			if ( rightdot > 8 || (rightdot > 3 && zdiff < -11) )//was normalized, 0.2
+			{
+				if ( doDodge )
+				{
+					if ( self->client->NPC_class == CLASS_BOBAFETT && !Q_irand( 0, 2 ) )
+					{//roll!
+						TIMER_Start( self, "strafeLeft", Q_irand( 500, 1500 ) );
+						TIMER_Set( self, "strafeRight", 0 );
+					}
+					else 
+					{
+						dodgeAnim = BOTH_DODGE_L;
+					}
+				}
+				else
+				{
+					self->client->ps.saberBlocked = BLOCKED_UPPER_RIGHT;
+					if ( evasionType == EVASION_DUCK )
+					{
+						evasionType = EVASION_DUCK_PARRY;
+					}
+					else
+					{
+						evasionType = EVASION_PARRY;
+					}
+				}
+				if ( d_JediAI.integer )
+				{
+					Com_Printf( "mid-UR block\n" );
+				}
+			}
+			else if ( rightdot < -8 || (rightdot < -3 && zdiff < -11) )//was normalized, -0.2
+			{
+				if ( doDodge )
+				{
+					if ( self->client->NPC_class == CLASS_BOBAFETT && !Q_irand( 0, 2 ) )
+					{//roll!
+						TIMER_Start( self, "strafeLeft", Q_irand( 500, 1500 ) );
+						TIMER_Set( self, "strafeRight", 0 );
+					}
+					else 
+					{
+						dodgeAnim = BOTH_DODGE_R;
+					}
+				}
+				else
+				{
+					self->client->ps.saberBlocked = BLOCKED_UPPER_LEFT;
+					if ( evasionType == EVASION_DUCK )
+					{
+						evasionType = EVASION_DUCK_PARRY;
+					}
+					else
+					{
+						evasionType = EVASION_PARRY;
+					}
+				}
+				if ( d_JediAI.integer )
+				{
+					Com_Printf( "mid-UL block\n" );
+				}
+			}
+			else
+			{
+				self->client->ps.saberBlocked = BLOCKED_TOP;
+				if ( evasionType == EVASION_DUCK )
+				{
+					evasionType = EVASION_DUCK_PARRY;
+				}
+				else
+				{
+					evasionType = EVASION_PARRY;
+				}
+				if ( d_JediAI.integer )
+				{
+					Com_Printf( "mid-TOP block\n" );
+				}
+			}
+			evaded = qtrue;
+		}
+	}
+	else if ( saberBusy || (zdiff < -36 && ( zdiff < -44 || !Q_irand( 0, 2 ) ) ) )//was -30 and -40//2nd one was -46
+	{//jump!
+		if ( self->client->ps.groundEntityNum == ENTITYNUM_NONE )
+		{//already in air, duck to pull up legs
+			TIMER_Start( self, "duck", Q_irand( 500, 1500 ) );
+			evasionType = EVASION_DUCK;
+			evaded = qtrue;
+			if ( d_JediAI.integer )
+			{
+				Com_Printf( "legs up\n" );
+			}
+			if ( incoming || !saberBusy )
+			{
+				//since the jump may be cleared if not safe, set a lower block too
+				if ( rightdot >= 0 )
+				{
+					self->client->ps.saberBlocked = BLOCKED_LOWER_RIGHT;
+					evasionType = EVASION_DUCK_PARRY;
+					if ( d_JediAI.integer )
+					{
+						Com_Printf( "LR block\n" );
+					}
+				}
+				else
+				{
+					self->client->ps.saberBlocked = BLOCKED_LOWER_LEFT;
+					evasionType = EVASION_DUCK_PARRY;
+					if ( d_JediAI.integer )
+					{
+						Com_Printf( "LL block\n" );
+					}
+				}
+				evaded = qtrue;
+			}
+		}
+		else 
+		{//gotta jump!
+			if ( self->NPC && (self->NPC->rank == RANK_CREWMAN || self->NPC->rank > RANK_LT_JG ) &&
+				(!Q_irand( 0, 10 ) || (!Q_irand( 0, 2 ) && (cmd->forwardmove || cmd->rightmove))) )
+			{//superjump
+				//FIXME: check the jump, if can't, then block
+				if ( self->NPC 
+					&& !(self->NPC->scriptFlags&SCF_NO_ACROBATICS) 
+					&& self->client->ps.fd.forceRageRecoveryTime < level.time
+					&& !(self->client->ps.fd.forcePowersActive&(1<<FP_RAGE)) 
+					&& !PM_InKnockDown( &self->client->ps ) )
+				{
+					self->client->ps.fd.forceJumpCharge = 320;//FIXME: calc this intelligently
+					evasionType = EVASION_FJUMP;
+					evaded = qtrue;
+					if ( d_JediAI.integer )
+					{
+						Com_Printf( "force jump + " );
+					}
+				}
+			}
+			else
+			{//normal jump
+				//FIXME: check the jump, if can't, then block
+				if ( self->NPC 
+					&& !(self->NPC->scriptFlags&SCF_NO_ACROBATICS) 
+					&& self->client->ps.fd.forceRageRecoveryTime < level.time
+					&& !(self->client->ps.fd.forcePowersActive&(1<<FP_RAGE)) )
+				{
+					if ( self->client->NPC_class == CLASS_BOBAFETT && !Q_irand( 0, 1 ) )
+					{//roll!
+						if ( rightdot > 0 )
+						{
+							TIMER_Start( self, "strafeLeft", Q_irand( 500, 1500 ) );
+							TIMER_Set( self, "strafeRight", 0 );
+							TIMER_Set( self, "walking", 0 );
+						}
+						else
+						{
+							TIMER_Start( self, "strafeRight", Q_irand( 500, 1500 ) );
+							TIMER_Set( self, "strafeLeft", 0 );
+							TIMER_Set( self, "walking", 0 );
+						}
+					}
+					else
+					{
+						if ( self == NPC )
+						{
+							cmd->upmove = 127;
+						}
+						else
+						{
+							self->client->ps.velocity[2] = JUMP_VELOCITY;
+						}
+					}
+					evasionType = EVASION_JUMP;
+					evaded = qtrue;
+					if ( d_JediAI.integer )
+					{
+						Com_Printf( "jump + " );
+					}
+				}
+				if ( self->client->NPC_class == CLASS_TAVION )
+				{
+					if ( !incoming 
+						&& self->client->ps.groundEntityNum < ENTITYNUM_NONE 
+						&& !Q_irand( 0, 2 ) )
+					{
+						if ( !BG_SaberInAttack( self->client->ps.saberMove )
+							&& !PM_SaberInStart( self->client->ps.saberMove ) 
+							&& !BG_InRoll( &self->client->ps, self->client->ps.legsAnim )
+							&& !PM_InKnockDown( &self->client->ps )
+							&& !BG_SaberInSpecialAttack( self->client->ps.torsoAnim ) )
+						{//do the butterfly!
+							int butterflyAnim;
+							if ( Q_irand( 0, 1 ) )
+							{
+								butterflyAnim = BOTH_BUTTERFLY_LEFT;
+							}
+							else
+							{
+								butterflyAnim = BOTH_BUTTERFLY_RIGHT;
+							}
+							evasionType = EVASION_CARTWHEEL;
+							NPC_SetAnim( self, SETANIM_BOTH, butterflyAnim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+							self->client->ps.velocity[2] = 225;
+							self->client->ps.fd.forceJumpZStart = self->r.currentOrigin[2];//so we don't take damage if we land at same height
+						//	self->client->ps.pm_flags |= PMF_JUMPING|PMF_SLOW_MO_FALL;
+						//	self->client->ps.SaberActivateTrail( 300 );//FIXME: reset this when done!
+							//Ah well. No hacking from the server for now.
+							if ( self->client->NPC_class == CLASS_BOBAFETT )
+							{
+								G_AddEvent( self, EV_JUMP, 0 );
+							}
+							else
+							{
+								G_Sound( self, CHAN_BODY, G_SoundIndex("sound/weapons/force/jump.wav") );
+							}
+							cmd->upmove = 0;
+							saberBusy = qtrue;
+							evaded = qtrue;
+						}
+					}
+				}
+			}
+			if ( ((evasionType = Jedi_CheckFlipEvasions( self, rightdot, zdiff ))!=EVASION_NONE) )
+			{
+				if ( d_slowmodeath.integer > 5 && self->enemy && !self->enemy->s.number )
+				{
+					G_StartMatrixEffect( self );
+				}
+				saberBusy = qtrue;
+				evaded = qtrue;
+			}
+			else if ( incoming || !saberBusy )
+			{
+				//since the jump may be cleared if not safe, set a lower block too
+				if ( rightdot >= 0 )
+				{
+					self->client->ps.saberBlocked = BLOCKED_LOWER_RIGHT;
+					if ( evasionType == EVASION_JUMP )
+					{
+						evasionType = EVASION_JUMP_PARRY;
+					}
+					else if ( evasionType == EVASION_NONE )
+					{
+						evasionType = EVASION_PARRY;
+					}
+					if ( d_JediAI.integer )
+					{
+						Com_Printf( "LR block\n" );
+					}
+				}
+				else
+				{
+					self->client->ps.saberBlocked = BLOCKED_LOWER_LEFT;
+					if ( evasionType == EVASION_JUMP )
+					{
+						evasionType = EVASION_JUMP_PARRY;
+					}
+					else if ( evasionType == EVASION_NONE )
+					{
+						evasionType = EVASION_PARRY;
+					}
+					if ( d_JediAI.integer )
+					{
+						Com_Printf( "LL block\n" );
+					}
+				}
+				evaded = qtrue;
+			}
+		}
+	}
+	else
+	{
+		if ( incoming || !saberBusy )
+		{
+			if ( rightdot >= 0 )
+			{
+				self->client->ps.saberBlocked = BLOCKED_LOWER_RIGHT;
+				evasionType = EVASION_PARRY;
+				if ( d_JediAI.integer )
+				{
+					Com_Printf( "LR block\n" );
+				}
+			}
+			else
+			{
+				self->client->ps.saberBlocked = BLOCKED_LOWER_LEFT;
+				evasionType = EVASION_PARRY;
+				if ( d_JediAI.integer )
+				{
+					Com_Printf( "LL block\n" );
+				}
+			}
+			if ( incoming && incoming->s.weapon == WP_SABER )
+			{//thrown saber!
+				if ( self->NPC && (self->NPC->rank == RANK_CREWMAN || self->NPC->rank > RANK_LT_JG ) &&
+					(!Q_irand( 0, 10 ) || (!Q_irand( 0, 2 ) && (cmd->forwardmove || cmd->rightmove))) )
+				{//superjump
+					//FIXME: check the jump, if can't, then block
+					if ( self->NPC 
+						&& !(self->NPC->scriptFlags&SCF_NO_ACROBATICS) 
+						&& self->client->ps.fd.forceRageRecoveryTime < level.time
+						&& !(self->client->ps.fd.forcePowersActive&(1<<FP_RAGE)) 
+						&& !PM_InKnockDown( &self->client->ps ) )
+					{
+						self->client->ps.fd.forceJumpCharge = 320;//FIXME: calc this intelligently
+						evasionType = EVASION_FJUMP;
+						if ( d_JediAI.integer )
+						{
+							Com_Printf( "force jump + " );
+						}
+					}
+				}
+				else
+				{//normal jump
+					//FIXME: check the jump, if can't, then block
+					if ( self->NPC 
+						&& !(self->NPC->scriptFlags&SCF_NO_ACROBATICS) 
+						&& self->client->ps.fd.forceRageRecoveryTime < level.time
+						&& !(self->client->ps.fd.forcePowersActive&(1<<FP_RAGE)))
+					{
+						if ( self == NPC )
+						{
+							cmd->upmove = 127;
+						}
+						else
+						{
+							self->client->ps.velocity[2] = JUMP_VELOCITY;
+						}
+						evasionType = EVASION_JUMP_PARRY;
+						if ( d_JediAI.integer )
+						{
+							Com_Printf( "jump + " );
+						}
+					}
+				}
+			}
+			evaded = qtrue;
+		}
+	}
+
+	if ( evasionType == EVASION_NONE )
+	{
+		return EVASION_NONE;
+	}
+	//stop taunting
+	TIMER_Set( self, "taunting", 0 );
+	//stop gripping
+	TIMER_Set( self, "gripping", -level.time );
+	WP_ForcePowerStop( self, FP_GRIP );
+	//stop draining
+	TIMER_Set( self, "draining", -level.time );
+	WP_ForcePowerStop( self, FP_DRAIN );
+
+	if ( dodgeAnim != -1 )
+	{//dodged
+		evasionType = EVASION_DODGE;
+		NPC_SetAnim( self, SETANIM_BOTH, dodgeAnim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+		self->client->ps.weaponTime = self->client->ps.torsoTimer;
+		//force them to stop moving in this case
+		self->client->ps.pm_time = self->client->ps.torsoTimer;
+		//FIXME: maybe make a sound?  Like a grunt?  EV_JUMP?
+		self->client->ps.pm_flags |= PMF_TIME_KNOCKBACK;
+		//dodged, not block
+		if ( d_slowmodeath.integer > 5 && self->enemy && !self->enemy->s.number )
+		{
+			G_StartMatrixEffect( self );
+		}
+	}
+	else
+	{
+		if ( duckChance )
+		{
+			if ( !Q_irand( 0, duckChance ) )
+			{
+				TIMER_Start( self, "duck", Q_irand( 500, 1500 ) );
+				if ( evasionType == EVASION_PARRY )
+				{
+					evasionType = EVASION_DUCK_PARRY;
+				}
+				else
+				{
+					evasionType = EVASION_DUCK;
+				}
+				/*
+				if ( d_JediAI.integer )
+				{
+					Com_Printf( "duck " );
+				}
+				*/
+			}
+		}
+
+		if ( incoming )
+		{
+			self->client->ps.saberBlocked = WP_MissileBlockForBlock( self->client->ps.saberBlocked );
+		}
+
+	}
+	//if ( self->client->ps.saberBlocked != BLOCKED_NONE )
+	{
+		int parryReCalcTime = Jedi_ReCalcParryTime( self, evasionType );
+		if ( self->client->ps.fd.forcePowerDebounce[FP_SABER_DEFENSE] < level.time + parryReCalcTime )
+		{
+			self->client->ps.fd.forcePowerDebounce[FP_SABER_DEFENSE] = level.time + parryReCalcTime;
+		}
+	}
+	return evasionType;
+}
+
+extern float ShortestLineSegBewteen2LineSegs( vec3_t start1, vec3_t end1, vec3_t start2, vec3_t end2, vec3_t close_pnt1, vec3_t close_pnt2 );
+extern int WPDEBUG_SaberColor( saber_colors_t saberColor );
+static qboolean Jedi_SaberBlock( int saberNum, int bladeNum ) //saberNum = 0, bladeNum = 0
+{
+	vec3_t hitloc, saberTipOld, saberTip, top, bottom, axisPoint, saberPoint, dir;//saberBase, 
+	vec3_t pointDir, baseDir, tipDir, saberHitPoint, saberMins, saberMaxs;
+	float	pointDist, baseDirPerc, dist;
+	float	bladeLen = 0;
+	trace_t	tr;
+	evasionType_t	evasionType;
+
+	//FIXME: reborn don't block enough anymore
+	/*
+	//maybe do this on easy only... or only on grunt-level reborn
+	if ( NPC->client->ps.weaponTime )
+	{//i'm attacking right now
+		return qfalse;
+	}
+	*/
+
+	if ( !TIMER_Done( NPC, "parryReCalcTime" ) )
+	{//can't do our own re-think of which parry to use yet
+		return qfalse;
+	}
+
+	if ( NPC->client->ps.fd.forcePowerDebounce[FP_SABER_DEFENSE] > level.time )
+	{//can't move the saber to another position yet
+		return qfalse;
+	}
+	
+	/*
+	if ( NPCInfo->rank < RANK_LT_JG && Q_irand( 0, (2 - g_spskill.integer) ) )
+	{//lower rank reborn have a random chance of not doing it at all
+		NPC->client->ps.fd.forcePowerDebounce[FP_SABER_DEFENSE] = level.time + 300;
+		return qfalse;
+	}
+	*/
+
+	if ( NPC->enemy->health <= 0 || !NPC->enemy->client )
+	{//don't keep blocking him once he's dead (or if not a client)
+		return qfalse;
+	}
+	/*
+	//VectorMA( NPC->enemy->client->renderInfo.muzzlePoint, NPC->enemy->client->ps.saberLength, NPC->enemy->client->renderInfo.muzzleDir, saberTip );
+	//VectorMA( NPC->enemy->client->renderInfo.muzzlePointNext, NPC->enemy->client->ps.saberLength, NPC->enemy->client->renderInfo.muzzleDirNext, saberTipNext );
+	VectorMA( NPC->enemy->client->renderInfo.muzzlePointOld, NPC->enemy->client->ps.saberLength, NPC->enemy->client->renderInfo.muzzleDirOld, saberTipOld );
+	VectorMA( NPC->enemy->client->renderInfo.muzzlePoint, NPC->enemy->client->ps.saberLength, NPC->enemy->client->renderInfo.muzzleDir, saberTip );
+
+	VectorSubtract( NPC->enemy->client->renderInfo.muzzlePoint, NPC->enemy->client->renderInfo.muzzlePointOld, dir );//get the dir
+	VectorAdd( dir, NPC->enemy->client->renderInfo.muzzlePoint, saberBase );//extrapolate
+
+	VectorSubtract( saberTip, saberTipOld, dir );//get the dir
+	VectorAdd( dir, saberTip, saberTipOld );//extrapolate
+
+	VectorCopy( NPC->r.currentOrigin, top );
+	top[2] = NPC->r.absmax[2];
+	VectorCopy( NPC->r.currentOrigin, bottom );
+	bottom[2] = NPC->r.absmin[2];
+
+	float dist = ShortestLineSegBewteen2LineSegs( saberBase, saberTipOld, bottom, top, saberPoint, axisPoint );
+	if ( 0 )//dist > NPC->r.maxs[0]*4 )//was *3
+	{//FIXME: sometimes he reacts when you're too far away to actually hit him
+		if ( d_JediAI.integer )
+		{
+			Com_Printf( "enemy saber dist: %4.2f\n", dist );
+		}
+		TIMER_Set( NPC, "parryTime", -1 );
+		return qfalse;
+	}
+
+	//get the actual point of impact
+	trace_t	tr;
+	trap_Trace( &tr, saberPoint, vec3_origin, vec3_origin, axisPoint, NPC->enemy->s.number, MASK_SHOT, G2_RETURNONHIT, 10 );
+	if ( tr.allsolid || tr.startsolid )
+	{//estimate
+		VectorSubtract( saberPoint, axisPoint, dir );
+		VectorNormalize( dir );
+		VectorMA( axisPoint, NPC->r.maxs[0]*1.22, dir, hitloc );
+	}
+	else
+	{
+		VectorCopy( tr.endpos, hitloc );
+	}
+	*/
+	VectorSet(saberMins,-4,-4,-4);
+	VectorSet(saberMaxs,4,4,4);
+
+	VectorMA( NPC->enemy->client->saber[saberNum].blade[bladeNum].muzzlePointOld, NPC->enemy->client->saber[saberNum].blade[bladeNum].length, NPC->enemy->client->saber[saberNum].blade[bladeNum].muzzleDirOld, saberTipOld );
+	VectorMA( NPC->enemy->client->saber[saberNum].blade[bladeNum].muzzlePoint, NPC->enemy->client->saber[saberNum].blade[bladeNum].length, NPC->enemy->client->saber[saberNum].blade[bladeNum].muzzleDir, saberTip );
+//	VectorCopy(NPC->enemy->client->lastSaberBase_Always, muzzlePoint);
+//	VectorMA(muzzlePoint, GAME_SABER_LENGTH, NPC->enemy->client->lastSaberDir_Always, saberTip);
+//	VectorCopy(saberTip, saberTipOld);
+
+	VectorCopy( NPC->r.currentOrigin, top );
+	top[2] = NPC->r.absmax[2];
+	VectorCopy( NPC->r.currentOrigin, bottom );
+	bottom[2] = NPC->r.absmin[2];
+
+	dist = ShortestLineSegBewteen2LineSegs( NPC->enemy->client->renderInfo.muzzlePoint, saberTip, bottom, top, saberPoint, axisPoint );
+	if ( dist > NPC->r.maxs[0]*5 )//was *3
+	{//FIXME: sometimes he reacts when you're too far away to actually hit him
+		if ( d_JediAI.integer )
+		{
+			Com_Printf( S_COLOR_RED"enemy saber dist: %4.2f\n", dist );
+		}
+		/*
+		if ( dist < 300 //close
+			&& !Jedi_QuickReactions( NPC )//quick reaction people can interrupt themselves
+			&& (PM_SaberInStart( NPC->enemy->client->ps.saberMove ) || BG_SaberInAttack( NPC->enemy->client->ps.saberMove )) )//enemy is swinging at me
+		{//he's swinging at me and close enough to be a threat, don't start an attack right now
+			TIMER_Set( NPC, "parryTime", 100 );
+		}
+		else
+		*/
+		{
+			TIMER_Set( NPC, "parryTime", -1 );
+		}
+		return qfalse;
+	}
+	if ( d_JediAI.integer )
+	{
+		Com_Printf( S_COLOR_GREEN"enemy saber dist: %4.2f\n", dist );
+	}
+	
+	VectorSubtract( saberPoint, NPC->enemy->client->renderInfo.muzzlePoint, pointDir );
+	pointDist = VectorLength( pointDir );
+	
+	bladeLen = NPC->enemy->client->saber[saberNum].blade[bladeNum].length;
+
+	if ( bladeLen <= 0 )
+	{
+		baseDirPerc = 0.5f;
+	}
+	else
+	{
+		baseDirPerc = pointDist/bladeLen;
+	}
+	VectorSubtract( NPC->enemy->client->renderInfo.muzzlePoint, NPC->enemy->client->renderInfo.muzzlePointOld, baseDir );
+	VectorSubtract( saberTip, saberTipOld, tipDir );
+	VectorScale( baseDir, baseDirPerc, baseDir );
+	VectorMA( baseDir, 1.0f-baseDirPerc, tipDir, dir );
+	VectorMA( saberPoint, 200, dir, hitloc );
+
+	//get the actual point of impact
+	trap_Trace( &tr, saberPoint, saberMins, saberMaxs, hitloc, NPC->enemy->s.number, CONTENTS_BODY );//, G2_RETURNONHIT, 10 );
+	if ( tr.allsolid || tr.startsolid || tr.fraction >= 1.0f )
+	{//estimate
+		vec3_t	dir2Me;
+		VectorSubtract( axisPoint, saberPoint, dir2Me );
+		dist = VectorNormalize( dir2Me );
+		if ( DotProduct( dir, dir2Me ) < 0.2f )
+		{//saber is not swinging in my direction
+			/*
+			if ( dist < 300 //close
+				&& !Jedi_QuickReactions( NPC )//quick reaction people can interrupt themselves
+				&& (PM_SaberInStart( NPC->enemy->client->ps.saberMove ) || BG_SaberInAttack( NPC->enemy->client->ps.saberMove )) )//enemy is swinging at me
+			{//he's swinging at me and close enough to be a threat, don't start an attack right now
+				TIMER_Set( NPC, "parryTime", 100 );
+			}
+			else
+			*/
+			{
+				TIMER_Set( NPC, "parryTime", -1 );
+			}
+			return qfalse;
+		}
+		ShortestLineSegBewteen2LineSegs( saberPoint, hitloc, bottom, top, saberHitPoint, hitloc );
+		/*
+		VectorSubtract( saberPoint, axisPoint, dir );
+		VectorNormalize( dir );
+		VectorMA( axisPoint, NPC->r.maxs[0]*1.22, dir, hitloc );
+		*/
+	}
+	else
+	{
+		VectorCopy( tr.endpos, hitloc );
+	}
+	
+	if ( d_JediAI.integer )
+	{
+		//G_DebugLine( saberPoint, hitloc, FRAMETIME, WPDEBUG_SaberColor( NPC->enemy->client->ps.saber[saberNum].blade[bladeNum].color ), qtrue );
+		G_TestLine(saberPoint, hitloc, 0x0000ff, FRAMETIME);
+	}
+
+	//FIXME: if saber is off and/or we have force speed and want to be really cocky, 
+	//		and the swing misses by some amount, we can use the dodges here... :)
+	if ( (evasionType=Jedi_SaberBlockGo( NPC, &ucmd, hitloc, dir, NULL, dist )) != EVASION_DODGE )
+	{//we did block (not dodge)
+		int parryReCalcTime;
+
+		if ( !NPC->client->ps.saberInFlight )
+		{//make sure saber is on
+			WP_ActivateSaber(NPC);
+		}
+
+		//debounce our parry recalc time
+		parryReCalcTime = Jedi_ReCalcParryTime( NPC, evasionType );
+		TIMER_Set( NPC, "parryReCalcTime", Q_irand( 0, parryReCalcTime ) );
+		if ( d_JediAI.integer )
+		{
+			Com_Printf( "Keep parry choice until: %d\n", level.time + parryReCalcTime );
+		}
+
+		//determine how long to hold this anim
+		if ( TIMER_Done( NPC, "parryTime" ) )
+		{
+			if ( NPC->client->NPC_class == CLASS_TAVION )
+			{
+				TIMER_Set( NPC, "parryTime", Q_irand( parryReCalcTime/2, parryReCalcTime*1.5 ) );
+			}
+			else if ( NPCInfo->rank >= RANK_LT_JG )
+			{//fencers and higher hold a parry less
+				TIMER_Set( NPC, "parryTime", parryReCalcTime );
+			}
+			else
+			{//others hold it longer
+				TIMER_Set( NPC, "parryTime", Q_irand( 1, 2 )*parryReCalcTime );
+			}
+		}
+	}
+	else
+	{
+		int dodgeTime = NPC->client->ps.torsoTimer;
+		if ( NPCInfo->rank > RANK_LT_COMM && NPC->client->NPC_class != CLASS_DESANN )
+		{//higher-level guys can dodge faster
+			dodgeTime -= 200;
+		}
+		TIMER_Set( NPC, "parryReCalcTime", dodgeTime );
+		TIMER_Set( NPC, "parryTime", dodgeTime );
+	}
+	return qtrue;
+}
+/*
+-------------------------
+Jedi_EvasionSaber
+
+defend if other is using saber and attacking me!
+-------------------------
+*/
+static void Jedi_EvasionSaber( vec3_t enemy_movedir, float enemy_dist, vec3_t enemy_dir )
+{
+	vec3_t	dirEnemy2Me;
+	int		evasionChance = 30;//only step aside 30% if he's moving at me but not attacking
+	qboolean	enemy_attacking = qfalse;
+	qboolean	throwing_saber = qfalse;
+	qboolean	shooting_lightning = qfalse;
+
+	if ( !NPC->enemy->client )
+	{
+		return;
+	}
+	else if ( NPC->enemy->client 
+		&& NPC->enemy->s.weapon == WP_SABER 
+		&& NPC->enemy->client->ps.saberLockTime > level.time )
+	{//don't try to block/evade an enemy who is in a saberLock
+		return;
+	}
+	else if ( NPC->client->ps.saberEventFlags&SEF_LOCK_WON && NPC->enemy->painDebounceTime > level.time )
+	{//pressing the advantage of winning a saber lock
+		return;
+	}
+
+	if ( NPC->enemy->client->ps.saberInFlight && !TIMER_Done( NPC, "taunting" ) )
+	{//if he's throwing his saber, stop taunting
+		TIMER_Set( NPC, "taunting", -level.time );
+		if ( !NPC->client->ps.saberInFlight )
+		{
+			WP_ActivateSaber(NPC);
+		}
+	}
+
+	if ( TIMER_Done( NPC, "parryTime" ) )
+	{
+		if ( NPC->client->ps.saberBlocked != BLOCKED_ATK_BOUNCE &&
+			NPC->client->ps.saberBlocked != BLOCKED_PARRY_BROKEN )
+		{//wasn't blocked myself
+			NPC->client->ps.saberBlocked = BLOCKED_NONE;
+		}
+	}
+
+	if ( NPC->enemy->client->ps.weaponTime && NPC->enemy->client->ps.weaponstate == WEAPON_FIRING )
+	{
+		if ( !NPC->client->ps.saberInFlight && Jedi_SaberBlock(0, 0) )
+		{
+			return;
+		}
+	}
+
+	VectorSubtract( NPC->r.currentOrigin, NPC->enemy->r.currentOrigin, dirEnemy2Me );
+	VectorNormalize( dirEnemy2Me );
+
+	if ( NPC->enemy->client->ps.weaponTime && NPC->enemy->client->ps.weaponstate == WEAPON_FIRING )
+	{//enemy is attacking
+		enemy_attacking = qtrue;
+		evasionChance = 90;
+	}
+
+	if ( (NPC->enemy->client->ps.fd.forcePowersActive&(1<<FP_LIGHTNING) ) )
+	{//enemy is shooting lightning
+		enemy_attacking = qtrue;
+		shooting_lightning = qtrue;
+		evasionChance = 50;
+	}
+
+	if ( NPC->enemy->client->ps.saberInFlight && NPC->enemy->client->ps.saberEntityNum != ENTITYNUM_NONE && NPC->enemy->client->ps.saberEntityState != SES_RETURNING )
+	{//enemy is shooting lightning
+		enemy_attacking = qtrue;
+		throwing_saber = qtrue;
+	}
+
+	//FIXME: this needs to take skill and rank(reborn type) into account much more
+	if ( Q_irand( 0, 100 ) < evasionChance )
+	{//check to see if he's coming at me
+		float facingAmt;
+		if ( VectorCompare( enemy_movedir, vec3_origin ) || shooting_lightning || throwing_saber )
+		{//he's not moving (or he's using a ranged attack), see if he's facing me
+			vec3_t	enemy_fwd;
+			AngleVectors( NPC->enemy->client->ps.viewangles, enemy_fwd, NULL, NULL );
+			facingAmt = DotProduct( enemy_fwd, dirEnemy2Me );
+		}
+		else
+		{//he's moving
+			facingAmt = DotProduct( enemy_movedir, dirEnemy2Me );
+		}
+			
+		if ( flrand( 0.25, 1 ) < facingAmt )
+		{//coming at/facing me!  
+			int whichDefense = 0;
+			if ( NPC->client->ps.weaponTime || NPC->client->ps.saberInFlight || NPC->client->NPC_class == CLASS_BOBAFETT )
+			{//I'm attacking or recovering from a parry, can only try to strafe/jump right now
+				if ( Q_irand( 0, 10 ) < NPCInfo->stats.aggression )
+				{
+					return;
+				}
+				whichDefense = 100;
+			}
+			else
+			{
+				if ( shooting_lightning )
+				{//check for lightning attack
+					//only valid defense is strafe and/or jump
+					whichDefense = 100;
+				}
+				else if ( throwing_saber )
+				{//he's thrown his saber!  See if it's coming at me
+					float	saberDist;
+					vec3_t	saberDir2Me;
+					vec3_t	saberMoveDir;
+					gentity_t *saber = &g_entities[NPC->enemy->client->ps.saberEntityNum];
+					VectorSubtract( NPC->r.currentOrigin, saber->r.currentOrigin, saberDir2Me );
+					saberDist = VectorNormalize( saberDir2Me );
+					VectorCopy( saber->s.pos.trDelta, saberMoveDir );
+					VectorNormalize( saberMoveDir );
+					if ( !Q_irand( 0, 3 ) )
+					{
+						//Com_Printf( "(%d) raise agg - enemy threw saber\n", level.time );
+						Jedi_Aggression( NPC, 1 );
+					}
+					if ( DotProduct( saberMoveDir, saberDir2Me ) > 0.5 )
+					{//it's heading towards me
+						if ( saberDist < 100 )
+						{//it's close
+							whichDefense = Q_irand( 3, 6 );
+						}
+						else if ( saberDist < 200 )
+						{//got some time, yet, try pushing
+							whichDefense = Q_irand( 0, 8 );
+						}
+					}
+				}
+				if ( whichDefense )
+				{//already chose one
+				}
+				else if ( enemy_dist > 80 || !enemy_attacking )
+				{//he's pretty far, or not swinging, just strafe
+					if ( VectorCompare( enemy_movedir, vec3_origin ) )
+					{//if he's not moving, not swinging and far enough away, no evasion necc.
+						return;
+					}
+					if ( Q_irand( 0, 10 ) < NPCInfo->stats.aggression )
+					{
+						return;
+					}
+					whichDefense = 100;
+				}
+				else
+				{//he's getting close and swinging at me
+					vec3_t	fwd;
+					//see if I'm facing him
+					AngleVectors( NPC->client->ps.viewangles, fwd, NULL, NULL );
+					if ( DotProduct( enemy_dir, fwd ) < 0.5 )
+					{//I'm not really facing him, best option is to strafe
+						whichDefense = Q_irand( 5, 16 );
+					}
+					else if ( enemy_dist < 56 )
+					{//he's very close, maybe we should be more inclined to block or throw
+						whichDefense = Q_irand( NPCInfo->stats.aggression, 12 );
+					}
+					else
+					{
+						whichDefense = Q_irand( 2, 16 );
+					}
+				}
+			}
+
+			if ( whichDefense >= 4 && whichDefense <= 12 )
+			{//would try to block
+				if ( NPC->client->ps.saberInFlight )
+				{//can't, saber in not in hand, so fall back to strafe/jump
+					whichDefense = 100;
+				}
+			}
+
+			switch( whichDefense )
+			{
+			case 0:
+			case 1:
+			case 2:
+			case 3:
+				//use jedi force push?
+				//FIXME: try to do this if health low or enemy back to a cliff?
+				if ( (NPCInfo->rank == RANK_ENSIGN || NPCInfo->rank > RANK_LT_JG) && TIMER_Done( NPC, "parryTime" ) )
+				{//FIXME: check forcePushRadius[NPC->client->ps.fd.forcePowerLevel[FP_PUSH]]
+					ForceThrow( NPC, qfalse );
+				}
+				break;
+			case 4:
+			case 5:
+			case 6:
+			case 7:
+			case 8:
+			case 9:
+			case 10:
+			case 11:
+			case 12:
+				//try to parry the blow
+				//Com_Printf( "blocking\n" );
+				Jedi_SaberBlock(0, 0);
+				break;
+			default:
+				//Evade!
+				//start a strafe left/right if not already
+				if ( !Q_irand( 0, 5 ) || !Jedi_Strafe( 300, 1000, 0, 1000, qfalse ) )
+				{//certain chance they will pick an alternative evasion
+					//if couldn't strafe, try a different kind of evasion...
+					if ( shooting_lightning || throwing_saber || enemy_dist < 80 )
+					{
+						//FIXME: force-jump+forward - jump over the guy!
+						if ( shooting_lightning || (!Q_irand( 0, 2 ) && NPCInfo->stats.aggression < 4 && TIMER_Done( NPC, "parryTime" ) ) )
+						{
+							if ( (NPCInfo->rank == RANK_ENSIGN || NPCInfo->rank > RANK_LT_JG) && !shooting_lightning && Q_irand( 0, 2 ) )
+							{//FIXME: check forcePushRadius[NPC->client->ps.fd.forcePowerLevel[FP_PUSH]]
+								ForceThrow( NPC, qfalse );
+							}
+							else if ( (NPCInfo->rank==RANK_CREWMAN||NPCInfo->rank>RANK_LT_JG) 
+								&& !(NPCInfo->scriptFlags&SCF_NO_ACROBATICS) 
+								&& NPC->client->ps.fd.forceRageRecoveryTime < level.time
+								&& !(NPC->client->ps.fd.forcePowersActive&(1<<FP_RAGE)) 
+								&& !PM_InKnockDown( &NPC->client->ps ) )
+							{//FIXME: make this a function call?
+								//FIXME: check for clearance, safety of landing spot?
+								NPC->client->ps.fd.forceJumpCharge = 480;
+								//Don't jump again for another 2 to 5 seconds
+								TIMER_Set( NPC, "jumpChaseDebounce", Q_irand( 2000, 5000 ) );
+								if ( Q_irand( 0, 2 ) )
+								{
+									ucmd.forwardmove = 127;
+									VectorClear( NPC->client->ps.moveDir );
+								}
+								else
+								{
+									ucmd.forwardmove = -127;
+									VectorClear( NPC->client->ps.moveDir );
+								}
+								//FIXME: if this jump is cleared, we can't block... so pick a random lower block?
+								if ( Q_irand( 0, 1 ) )//FIXME: make intelligent
+								{
+									NPC->client->ps.saberBlocked = BLOCKED_LOWER_RIGHT;
+								}
+								else
+								{
+									NPC->client->ps.saberBlocked = BLOCKED_LOWER_LEFT;
+								}
+							}
+						}
+						else if ( enemy_attacking )
+						{
+							Jedi_SaberBlock(0, 0);
+						}
+					}
+				}
+				else
+				{//strafed
+					if ( d_JediAI.integer )
+					{
+						Com_Printf( "def strafe\n" );
+					}
+					if ( !(NPCInfo->scriptFlags&SCF_NO_ACROBATICS) 
+						&& NPC->client->ps.fd.forceRageRecoveryTime < level.time
+						&& !(NPC->client->ps.fd.forcePowersActive&(1<<FP_RAGE)) 
+						&& (NPCInfo->rank == RANK_CREWMAN || NPCInfo->rank > RANK_LT_JG ) 
+						&& !PM_InKnockDown( &NPC->client->ps )
+						&& !Q_irand( 0, 5 ) )
+					{//FIXME: make this a function call?
+						//FIXME: check for clearance, safety of landing spot?
+						if ( NPC->client->NPC_class == CLASS_BOBAFETT )
+						{
+							NPC->client->ps.fd.forceJumpCharge = 280;//FIXME: calc this intelligently?
+						}
+						else
+						{
+							NPC->client->ps.fd.forceJumpCharge = 320;
+						}
+						//Don't jump again for another 2 to 5 seconds
+						TIMER_Set( NPC, "jumpChaseDebounce", Q_irand( 2000, 5000 ) );
+					}
+				}
+				break;
+			}
+		
+			//turn off slow walking no matter what
+			TIMER_Set( NPC, "walking", -level.time );
+			TIMER_Set( NPC, "taunting", -level.time );
+		}
+	}
+}
+/*
+-------------------------
+Jedi_Flee
+-------------------------
+*/
+/*
+
+static qboolean Jedi_Flee( void )
+{
+	return qfalse;
+}
+*/
+
+
+/*
+==========================================================================================
+INTERNAL AI ROUTINES
+==========================================================================================
+*/
+gentity_t *Jedi_FindEnemyInCone( gentity_t *self, gentity_t *fallback, float minDot )
+{
+	vec3_t forward, mins, maxs, dir;
+	float	dist, bestDist = Q3_INFINITE;
+	gentity_t	*enemy = fallback;
+	gentity_t	*check = NULL;
+	int			entityList[MAX_GENTITIES];
+	int			e, numListedEntities;
+	trace_t		tr;
+
+	if ( !self->client )
+	{
+		return enemy;
+	}
+
+	AngleVectors( self->client->ps.viewangles, forward, NULL, NULL );
+
+	for ( e = 0 ; e < 3 ; e++ ) 
+	{
+		mins[e] = self->r.currentOrigin[e] - 1024;
+		maxs[e] = self->r.currentOrigin[e] + 1024;
+	}
+	numListedEntities = trap_EntitiesInBox( mins, maxs, entityList, MAX_GENTITIES );
+
+	for ( e = 0 ; e < numListedEntities ; e++ ) 
+	{
+		check = &g_entities[entityList[e]];
+		if ( check == self )
+		{//me
+			continue;
+		}
+		if ( !(check->inuse) )
+		{//freed
+			continue;
+		}
+		if ( !check->client )
+		{//not a client - FIXME: what about turrets?
+			continue;
+		}
+		if ( check->client->playerTeam != self->client->enemyTeam )
+		{//not an enemy - FIXME: what about turrets?
+			continue;
+		}
+		if ( check->health <= 0 )
+		{//dead
+			continue;
+		}
+
+		if ( !trap_InPVS( check->r.currentOrigin, self->r.currentOrigin ) )
+		{//can't potentially see them
+			continue;
+		}
+
+		VectorSubtract( check->r.currentOrigin, self->r.currentOrigin, dir );
+		dist = VectorNormalize( dir );
+
+		if ( DotProduct( dir, forward ) < minDot )
+		{//not in front
+			continue;
+		}
+
+		//really should have a clear LOS to this thing...
+		trap_Trace( &tr, self->r.currentOrigin, vec3_origin, vec3_origin, check->r.currentOrigin, self->s.number, MASK_SHOT );
+		if ( tr.fraction < 1.0f && tr.entityNum != check->s.number )
+		{//must have clear shot
+			continue;
+		}
+
+		if ( dist < bestDist )
+		{//closer than our last best one
+			dist = bestDist;
+			enemy = check;
+		}
+	}
+	return enemy;
+}
+
+static void Jedi_SetEnemyInfo( vec3_t enemy_dest, vec3_t enemy_dir, float *enemy_dist, vec3_t enemy_movedir, float *enemy_movespeed, int prediction )
+{
+	if ( !NPC || !NPC->enemy )
+	{//no valid enemy
+		return;
+	}
+	if ( !NPC->enemy->client )
+	{
+		VectorClear( enemy_movedir );
+		*enemy_movespeed = 0;
+		VectorCopy( NPC->enemy->r.currentOrigin, enemy_dest );
+		enemy_dest[2] += NPC->enemy->r.mins[2] + 24;//get it's origin to a height I can work with
+		VectorSubtract( enemy_dest, NPC->r.currentOrigin, enemy_dir );
+		//FIXME: enemy_dist calc needs to include all blade lengths, and include distance from hand to start of blade....
+		*enemy_dist = VectorNormalize( enemy_dir );// - (NPC->client->ps.saberLengthMax + NPC->r.maxs[0]*1.5 + 16);
+	}
+	else
+	{//see where enemy is headed
+		VectorCopy( NPC->enemy->client->ps.velocity, enemy_movedir );
+		*enemy_movespeed = VectorNormalize( enemy_movedir );
+		//figure out where he'll be, say, 3 frames from now
+		VectorMA( NPC->enemy->r.currentOrigin, *enemy_movespeed * 0.001 * prediction, enemy_movedir, enemy_dest );
+		//figure out what dir the enemy's estimated position is from me and how far from the tip of my saber he is
+		VectorSubtract( enemy_dest, NPC->r.currentOrigin, enemy_dir );//NPC->client->renderInfo.muzzlePoint
+		//FIXME: enemy_dist calc needs to include all blade lengths, and include distance from hand to start of blade....
+		*enemy_dist = VectorNormalize( enemy_dir ) - (NPC->client->saber[0].blade[0].lengthMax + NPC->r.maxs[0]*1.5 + 16); //just use the blade 0 len I guess
+		//FIXME: keep a group of enemies around me and use that info to make decisions...
+		//		For instance, if there are multiple enemies, evade more, push them away
+		//		and use medium attacks.  If enemies are using blasters, switch to fast.
+		//		If one jedi enemy, use strong attacks.  Use grip when fighting one or
+		//		two enemies, use lightning spread when fighting multiple enemies, etc.
+		//		Also, when kill one, check rest of group instead of walking up to victim.
+	}
+}
+
+extern float WP_SpeedOfMissileForWeapon( int wp, qboolean alt_fire );
+static void Jedi_FaceEnemy( qboolean doPitch )
+{
+	vec3_t	enemy_eyes, eyes, angles;
+
+	if ( NPC == NULL )
+		return;
+
+	if ( NPC->enemy == NULL )
+		return;
+
+	if ( NPC->client->ps.fd.forcePowersActive & (1<<FP_GRIP) &&
+		NPC->client->ps.fd.forcePowerLevel[FP_GRIP] > FORCE_LEVEL_1 )
+	{//don't update?
+		NPCInfo->desiredPitch = NPC->client->ps.viewangles[PITCH];
+		NPCInfo->desiredYaw = NPC->client->ps.viewangles[YAW];
+		return;
+	}
+	CalcEntitySpot( NPC, SPOT_HEAD, eyes );
+
+	CalcEntitySpot( NPC->enemy, SPOT_HEAD, enemy_eyes );
+
+	if ( NPC->client->NPC_class == CLASS_BOBAFETT 
+		&& TIMER_Done( NPC, "flameTime" )
+		&& NPC->s.weapon != WP_NONE
+		&& NPC->s.weapon != WP_DISRUPTOR
+		&& (NPC->s.weapon != WP_ROCKET_LAUNCHER||!(NPCInfo->scriptFlags&SCF_ALT_FIRE))
+		&& NPC->s.weapon != WP_THERMAL
+		&& NPC->s.weapon != WP_TRIP_MINE
+		&& NPC->s.weapon != WP_DET_PACK
+		&& NPC->s.weapon != WP_STUN_BATON
+		/*&& NPC->s.weapon != WP_MELEE*/ )
+	{//boba leads his enemy
+		if ( NPC->health < NPC->client->pers.maxHealth*0.5f )
+		{//lead
+			float missileSpeed = WP_SpeedOfMissileForWeapon( NPC->s.weapon, ((qboolean)(NPCInfo->scriptFlags&SCF_ALT_FIRE)) );
+			if ( missileSpeed )
+			{
+				float eDist = Distance( eyes, enemy_eyes );
+				eDist /= missileSpeed;//How many seconds it will take to get to the enemy
+				VectorMA( enemy_eyes, eDist*flrand(0.95f,1.25f), NPC->enemy->client->ps.velocity, enemy_eyes );
+			}
+		}
+	}
+
+	//Find the desired angles
+	if ( !NPC->client->ps.saberInFlight 
+		&& (NPC->client->ps.legsAnim == BOTH_A2_STABBACK1 
+			|| NPC->client->ps.legsAnim == BOTH_CROUCHATTACKBACK1
+			|| NPC->client->ps.legsAnim == BOTH_ATTACK_BACK) 
+		)
+	{//point *away*
+		GetAnglesForDirection( enemy_eyes, eyes, angles );
+	}
+	else
+	{//point towards him
+		GetAnglesForDirection( eyes, enemy_eyes, angles );
+	}
+
+	NPCInfo->desiredYaw	= AngleNormalize360( angles[YAW] );
+	/*
+	if ( NPC->client->ps.saberBlocked == BLOCKED_UPPER_LEFT )
+	{//temp hack- to make up for poor coverage on left side
+		NPCInfo->desiredYaw += 30;
+	}
+	*/
+
+	if ( doPitch )
+	{
+		NPCInfo->desiredPitch = AngleNormalize360( angles[PITCH] );
+		if ( NPC->client->ps.saberInFlight )
+		{//tilt down a little
+			NPCInfo->desiredPitch += 10;
+		}
+	}
+	//FIXME: else desiredPitch = 0?  Or keep previous?
+}
+
+static void Jedi_DebounceDirectionChanges( void )
+{
+	//FIXME: check these before making fwd/back & right/left decisions?
+	//Time-debounce changes in forward/back dir
+	if ( ucmd.forwardmove > 0 )
+	{
+		if ( !TIMER_Done( NPC, "moveback" ) || !TIMER_Done( NPC, "movenone" ) )
+		{
+			ucmd.forwardmove = 0;
+			//now we have to normalize the total movement again
+			if ( ucmd.rightmove > 0 )
+			{
+				ucmd.rightmove = 127;
+			}
+			else if ( ucmd.rightmove < 0 )
+			{
+				ucmd.rightmove = -127;
+			}
+			VectorClear( NPC->client->ps.moveDir );
+			TIMER_Set( NPC, "moveback", -level.time );
+			if ( TIMER_Done( NPC, "movenone" ) )
+			{
+				TIMER_Set( NPC, "movenone", Q_irand( 1000, 2000 ) );
+			}
+		}
+		else if ( TIMER_Done( NPC, "moveforward" ) )
+		{//FIXME: should be if it's zero?
+			TIMER_Set( NPC, "moveforward", Q_irand( 500, 2000 ) );
+		}
+	}
+	else if ( ucmd.forwardmove < 0 )
+	{
+		if ( !TIMER_Done( NPC, "moveforward" ) || !TIMER_Done( NPC, "movenone" ) )
+		{
+			ucmd.forwardmove = 0;
+			//now we have to normalize the total movement again
+			if ( ucmd.rightmove > 0 )
+			{
+				ucmd.rightmove = 127;
+			}
+			else if ( ucmd.rightmove < 0 )
+			{
+				ucmd.rightmove = -127;
+			}
+			VectorClear( NPC->client->ps.moveDir );
+			TIMER_Set( NPC, "moveforward", -level.time );
+			if ( TIMER_Done( NPC, "movenone" ) )
+			{
+				TIMER_Set( NPC, "movenone", Q_irand( 1000, 2000 ) );
+			}
+		}
+		else if ( TIMER_Done( NPC, "moveback" ) )
+		{//FIXME: should be if it's zero?
+			TIMER_Set( NPC, "moveback", Q_irand( 250, 1000 ) );
+		}
+	}
+	else if ( !TIMER_Done( NPC, "moveforward" ) )
+	{//NOTE: edge checking should stop me if this is bad... but what if it sends us colliding into the enemy?
+		ucmd.forwardmove = 127;
+		VectorClear( NPC->client->ps.moveDir );
+	}
+	else if ( !TIMER_Done( NPC, "moveback" ) )
+	{//NOTE: edge checking should stop me if this is bad...
+		ucmd.forwardmove = -127;
+		VectorClear( NPC->client->ps.moveDir );
+	}
+	//Time-debounce changes in right/left dir
+	if ( ucmd.rightmove > 0 )
+	{
+		if ( !TIMER_Done( NPC, "moveleft" ) || !TIMER_Done( NPC, "movecenter" ) )
+		{
+			ucmd.rightmove = 0;
+			//now we have to normalize the total movement again
+			if ( ucmd.forwardmove > 0 )
+			{
+				ucmd.forwardmove = 127;
+			}
+			else if ( ucmd.forwardmove < 0 )
+			{
+				ucmd.forwardmove = -127;
+			}
+			VectorClear( NPC->client->ps.moveDir );
+			TIMER_Set( NPC, "moveleft", -level.time );
+			if ( TIMER_Done( NPC, "movecenter" ) )
+			{
+				TIMER_Set( NPC, "movecenter", Q_irand( 1000, 2000 ) );
+			}
+		}
+		else if ( TIMER_Done( NPC, "moveright" ) )
+		{//FIXME: should be if it's zero?
+			TIMER_Set( NPC, "moveright", Q_irand( 250, 1500 ) );
+		}
+	}
+	else if ( ucmd.rightmove < 0 )
+	{
+		if ( !TIMER_Done( NPC, "moveright" ) || !TIMER_Done( NPC, "movecenter" ) )
+		{
+			ucmd.rightmove = 0;
+			//now we have to normalize the total movement again
+			if ( ucmd.forwardmove > 0 )
+			{
+				ucmd.forwardmove = 127;
+			}
+			else if ( ucmd.forwardmove < 0 )
+			{
+				ucmd.forwardmove = -127;
+			}
+			VectorClear( NPC->client->ps.moveDir );
+			TIMER_Set( NPC, "moveright", -level.time );
+			if ( TIMER_Done( NPC, "movecenter" ) )
+			{
+				TIMER_Set( NPC, "movecenter", Q_irand( 1000, 2000 ) );
+			}
+		}
+		else if ( TIMER_Done( NPC, "moveleft" ) )
+		{//FIXME: should be if it's zero?
+			TIMER_Set( NPC, "moveleft", Q_irand( 250, 1500 ) );
+		}
+	}
+	else if ( !TIMER_Done( NPC, "moveright" ) )
+	{//NOTE: edge checking should stop me if this is bad... 
+		ucmd.rightmove = 127;
+		VectorClear( NPC->client->ps.moveDir );
+	}
+	else if ( !TIMER_Done( NPC, "moveleft" ) )
+	{//NOTE: edge checking should stop me if this is bad...
+		ucmd.rightmove = -127;
+		VectorClear( NPC->client->ps.moveDir );
+	}
+}
+
+static void Jedi_TimersApply( void )
+{
+	if ( !ucmd.rightmove )
+	{//only if not already strafing
+		//FIXME: if enemy behind me and turning to face enemy, don't strafe in that direction, too
+		if ( !TIMER_Done( NPC, "strafeLeft" ) )
+		{
+			if ( NPCInfo->desiredYaw > NPC->client->ps.viewangles[YAW] + 60 )
+			{//we want to turn left, don't apply the strafing
+			}
+			else
+			{//go ahead and strafe left
+				ucmd.rightmove = -127;
+				VectorClear( NPC->client->ps.moveDir );
+			}
+		}
+		else if ( !TIMER_Done( NPC, "strafeRight" ) )
+		{
+			if ( NPCInfo->desiredYaw < NPC->client->ps.viewangles[YAW] - 60 )
+			{//we want to turn right, don't apply the strafing
+			}
+			else
+			{//go ahead and strafe left
+				ucmd.rightmove = 127;
+				VectorClear( NPC->client->ps.moveDir );
+			}
+		}
+	}
+
+	Jedi_DebounceDirectionChanges();
+
+	//use careful anim/slower movement if not already moving
+	if ( !ucmd.forwardmove && !TIMER_Done( NPC, "walking" ) )
+	{
+		ucmd.buttons |= (BUTTON_WALKING);
+	}
+
+	if ( !TIMER_Done( NPC, "taunting" ) )
+	{
+		ucmd.buttons |= (BUTTON_WALKING);
+	}
+
+	if ( !TIMER_Done( NPC, "gripping" ) )
+	{//FIXME: what do we do if we ran out of power?  NPC's can't?
+		//FIXME: don't keep turning to face enemy or we'll end up spinning around
+		ucmd.buttons |= BUTTON_FORCEGRIP;
+	}
+
+	if ( !TIMER_Done( NPC, "draining" ) )
+	{//FIXME: what do we do if we ran out of power?  NPC's can't?
+		//FIXME: don't keep turning to face enemy or we'll end up spinning around
+		ucmd.buttons |= BUTTON_FORCE_DRAIN;
+	}
+
+	if ( !TIMER_Done( NPC, "holdLightning" ) )
+	{//hold down the lightning key
+		ucmd.buttons |= BUTTON_FORCE_LIGHTNING;
+	}
+}
+
+static void Jedi_CombatTimersUpdate( int enemy_dist )
+{
+	if ( TIMER_Done( NPC, "roamTime" ) )
+	{
+		TIMER_Set( NPC, "roamTime", Q_irand( 2000, 5000 ) );
+		//okay, now mess with agression
+		if ( NPC->client->ps.fd.forcePowersActive&(1<<FP_RAGE) )
+		{//raging
+			Jedi_Aggression( NPC, Q_irand( 0, 3 ) );
+		}
+		else if ( NPC->client->ps.fd.forceRageRecoveryTime > level.time )
+		{//recovering
+			Jedi_Aggression( NPC, Q_irand( 0, -2 ) );
+		}
+		if ( NPC->enemy && NPC->enemy->client )
+		{
+			switch( NPC->enemy->client->ps.weapon )
+			{
+			case WP_SABER:
+				//If enemy has a lightsaber, always close in
+				if ( BG_SabersOff( &NPC->enemy->client->ps ) )
+				{//fool!  Standing around unarmed, charge!
+					//Com_Printf( "(%d) raise agg - enemy saber off\n", level.time );
+					Jedi_Aggression( NPC, 2 );
+				}
+				else
+				{
+					//Com_Printf( "(%d) raise agg - enemy saber\n", level.time );
+					Jedi_Aggression( NPC, 1 );
+				}
+				break;
+			case WP_BLASTER:
+			case WP_BRYAR_PISTOL:
+			case WP_DISRUPTOR:
+			case WP_BOWCASTER:
+			case WP_REPEATER:
+			case WP_DEMP2:
+			case WP_FLECHETTE:
+			case WP_ROCKET_LAUNCHER:
+				//if he has a blaster, move in when:
+				//They're not shooting at me
+				if ( NPC->enemy->attackDebounceTime < level.time )
+				{//does this apply to players?
+					//Com_Printf( "(%d) raise agg - enemy not shooting ranged weap\n", level.time );
+					Jedi_Aggression( NPC, 1 );
+				}
+				//He's closer than a dist that gives us time to deflect
+				if ( enemy_dist < 256 )
+				{
+					//Com_Printf( "(%d) raise agg - enemy ranged weap- too close\n", level.time );
+					Jedi_Aggression( NPC, 1 );
+				}
+				break;
+			default:
+				break;
+			}
+		}
+	}
+
+	if ( TIMER_Done( NPC, "noStrafe" ) && TIMER_Done( NPC, "strafeLeft" ) && TIMER_Done( NPC, "strafeRight" ) )
+	{
+		//FIXME: Maybe more likely to do this if aggression higher?  Or some other stat?
+		if ( !Q_irand( 0, 4 ) )
+		{//start a strafe
+			if ( Jedi_Strafe( 1000, 3000, 0, 4000, qtrue ) )
+			{
+				if ( d_JediAI.integer )
+				{
+					Com_Printf( "off strafe\n" );
+				}
+			}
+		}
+		else
+		{//postpone any strafing for a while
+			TIMER_Set( NPC, "noStrafe", Q_irand( 1000, 3000 ) );
+		}
+	}
+
+	if ( NPC->client->ps.saberEventFlags )
+	{//some kind of saber combat event is still pending
+		int newFlags = NPC->client->ps.saberEventFlags;
+		if ( NPC->client->ps.saberEventFlags&SEF_PARRIED )
+		{//parried
+			TIMER_Set( NPC, "parryTime", -1 );
+			/*
+			if ( NPCInfo->rank >= RANK_LT_JG )
+			{
+				NPC->client->ps.fd.forcePowerDebounce[FP_SABER_DEFENSE] = level.time + 100;
+			}
+			else
+			{
+				NPC->client->ps.fd.forcePowerDebounce[FP_SABER_DEFENSE] = level.time + 500;
+			}
+			*/
+			if ( NPC->enemy && PM_SaberInKnockaway( NPC->enemy->client->ps.saberMove ) )
+			{//advance!
+				Jedi_Aggression( NPC, 1 );//get closer
+				Jedi_AdjustSaberAnimLevel( NPC, (NPC->client->ps.fd.saberAnimLevel-1) );//use a faster attack
+			}
+			else
+			{
+				if ( !Q_irand( 0, 1 ) )//FIXME: dependant on rank/diff?
+				{
+					//Com_Printf( "(%d) drop agg - we parried\n", level.time );
+					Jedi_Aggression( NPC, -1 );
+				}
+				if ( !Q_irand( 0, 1 ) )
+				{
+					Jedi_AdjustSaberAnimLevel( NPC, (NPC->client->ps.fd.saberAnimLevel-1) );
+				}
+			}
+			if ( d_JediAI.integer )
+			{
+				Com_Printf( "(%d) PARRY: agg %d, no parry until %d\n", level.time, NPCInfo->stats.aggression, level.time + 100 );
+			}
+			newFlags &= ~SEF_PARRIED;
+		}
+		if ( !NPC->client->ps.weaponTime && (NPC->client->ps.saberEventFlags&SEF_HITENEMY) )//hit enemy
+		{//we hit our enemy last time we swung, drop our aggression
+			if ( !Q_irand( 0, 1 ) )//FIXME: dependant on rank/diff?
+			{
+				//Com_Printf( "(%d) drop agg - we hit enemy\n", level.time );
+				Jedi_Aggression( NPC, -1 );
+				if ( d_JediAI.integer )
+				{
+					Com_Printf( "(%d) HIT: agg %d\n", level.time, NPCInfo->stats.aggression );
+				}
+				if ( !Q_irand( 0, 3 ) 
+					&& NPCInfo->blockedSpeechDebounceTime < level.time 
+					&& jediSpeechDebounceTime[NPC->client->playerTeam] < level.time 
+					&& NPC->painDebounceTime < level.time - 1000 )
+				{
+					G_AddVoiceEvent( NPC, Q_irand( EV_GLOAT1, EV_GLOAT3 ), 3000 );
+					jediSpeechDebounceTime[NPC->client->playerTeam] = NPCInfo->blockedSpeechDebounceTime = level.time + 3000;
+				}
+			}
+			if ( !Q_irand( 0, 2 ) )
+			{
+				Jedi_AdjustSaberAnimLevel( NPC, (NPC->client->ps.fd.saberAnimLevel+1) );
+			}
+			newFlags &= ~SEF_HITENEMY;
+		}
+		if ( (NPC->client->ps.saberEventFlags&SEF_BLOCKED) )
+		{//was blocked whilst attacking
+			if ( PM_SaberInBrokenParry( NPC->client->ps.saberMove )
+				|| NPC->client->ps.saberBlocked == BLOCKED_PARRY_BROKEN )
+			{
+				//Com_Printf( "(%d) drop agg - we were knock-blocked\n", level.time );
+				if ( NPC->client->ps.saberInFlight )
+				{//lost our saber, too!!!
+					Jedi_Aggression( NPC, -5 );//really really really should back off!!!
+				}
+				else
+				{
+					Jedi_Aggression( NPC, -2 );//really should back off!
+				}
+				Jedi_AdjustSaberAnimLevel( NPC, (NPC->client->ps.fd.saberAnimLevel+1) );//use a stronger attack
+				if ( d_JediAI.integer )
+				{
+					Com_Printf( "(%d) KNOCK-BLOCKED: agg %d\n", level.time, NPCInfo->stats.aggression );
+				}
+			}
+			else
+			{
+				if ( !Q_irand( 0, 2 ) )//FIXME: dependant on rank/diff?
+				{
+					//Com_Printf( "(%d) drop agg - we were blocked\n", level.time );
+					Jedi_Aggression( NPC, -1 );
+					if ( d_JediAI.integer )
+					{
+						Com_Printf( "(%d) BLOCKED: agg %d\n", level.time, NPCInfo->stats.aggression );
+					}
+				}
+				if ( !Q_irand( 0, 1 ) )
+				{
+					Jedi_AdjustSaberAnimLevel( NPC, (NPC->client->ps.fd.saberAnimLevel+1) );
+				}
+			}
+			newFlags &= ~SEF_BLOCKED;
+			//FIXME: based on the type of parry the enemy is doing and my skill,
+			//		choose an attack that is likely to get around the parry?
+			//		right now that's generic in the saber animation code, auto-picks
+			//		a next anim for me, but really should be AI-controlled.
+		}
+		if ( NPC->client->ps.saberEventFlags&SEF_DEFLECTED )
+		{//deflected a shot
+			newFlags &= ~SEF_DEFLECTED;
+			if ( !Q_irand( 0, 3 ) )
+			{
+				Jedi_AdjustSaberAnimLevel( NPC, (NPC->client->ps.fd.saberAnimLevel-1) );
+			}
+		}
+		if ( NPC->client->ps.saberEventFlags&SEF_HITWALL )
+		{//hit a wall
+			newFlags &= ~SEF_HITWALL;
+		}
+		if ( NPC->client->ps.saberEventFlags&SEF_HITOBJECT )
+		{//hit some other damagable object
+			if ( !Q_irand( 0, 3 ) )
+			{
+				Jedi_AdjustSaberAnimLevel( NPC, (NPC->client->ps.fd.saberAnimLevel-1) );
+			}
+			newFlags &= ~SEF_HITOBJECT;
+		}
+		NPC->client->ps.saberEventFlags = newFlags;
+	}
+}
+
+static void Jedi_CombatIdle( int enemy_dist )
+{
+	if ( !TIMER_Done( NPC, "parryTime" ) )
+	{
+		return;
+	}
+	if ( NPC->client->ps.saberInFlight )
+	{//don't do this idle stuff if throwing saber
+		return;
+	}
+	if ( NPC->client->ps.fd.forcePowersActive&(1<<FP_RAGE) 
+		|| NPC->client->ps.fd.forceRageRecoveryTime > level.time )
+	{//never taunt while raging or recovering from rage
+		return;
+	}
+	//FIXME: make these distance numbers defines?
+	if ( enemy_dist >= 64 )
+	{//FIXME: only do this if standing still?
+		//based on aggression, flaunt/taunt
+		int chance = 20;
+		if ( NPC->client->NPC_class == CLASS_SHADOWTROOPER )
+		{
+			chance = 10;
+		}
+		//FIXME: possibly throw local objects at enemy?
+		if ( Q_irand( 2, chance ) < NPCInfo->stats.aggression )
+		{
+			if ( TIMER_Done( NPC, "chatter" ) && NPC->client->ps.forceHandExtend == HANDEXTEND_NONE )
+			{//FIXME: add more taunt behaviors
+				//FIXME: sometimes he turns it off, then turns it right back on again???
+				if ( enemy_dist > 200 
+					&& NPC->client->NPC_class != CLASS_BOBAFETT
+					&& !NPC->client->ps.saberHolstered
+					&& !Q_irand( 0, 5 ) )
+				{//taunt even more, turn off the saber
+					//FIXME: don't do this if health low?
+					WP_DeactivateSaber( NPC, qfalse );
+					//Don't attack for a bit
+					NPCInfo->stats.aggression = 3;
+					//FIXME: maybe start strafing?
+					//debounce this
+					if ( NPC->client->playerTeam != NPCTEAM_PLAYER && !Q_irand( 0, 1 ))
+					{
+						//NPC->client->ps.taunting = level.time + 100;
+						NPC->client->ps.forceHandExtend = HANDEXTEND_JEDITAUNT;
+						NPC->client->ps.forceHandExtendTime = level.time + 5000;
+
+						TIMER_Set( NPC, "chatter", Q_irand( 5000, 10000 ) );
+						TIMER_Set( NPC, "taunting", 5500 );
+					}
+					else
+					{
+						Jedi_BattleTaunt();
+						TIMER_Set( NPC, "taunting", Q_irand( 5000, 10000 ) );
+					}
+				}
+				else if ( Jedi_BattleTaunt() )
+				{//FIXME: pick some anims
+				}
+			}
+		}
+	}
+}
+
+static qboolean Jedi_AttackDecide( int enemy_dist )
+{
+	if ( NPC->enemy->client 
+		&& NPC->enemy->s.weapon == WP_SABER 
+		&& NPC->enemy->client->ps.saberLockTime > level.time 
+		&& NPC->client->ps.saberLockTime < level.time )
+	{//enemy is in a saberLock and we are not
+		return qfalse;
+	}
+
+	if ( NPC->client->ps.saberEventFlags&SEF_LOCK_WON )
+	{//we won a saber lock, press the advantage with an attack!
+		int	chance = 0;
+		if ( NPC->client->NPC_class == CLASS_DESANN || NPC->client->NPC_class == CLASS_LUKE || !Q_stricmp("Yoda",NPC->NPC_type) )
+		{//desann and luke
+			chance = 20;
+		}
+		else if ( NPC->client->NPC_class == CLASS_TAVION )
+		{//tavion
+			chance = 10;
+		}
+		else if ( NPC->client->NPC_class == CLASS_REBORN && NPCInfo->rank == RANK_LT_JG ) 
+		{//fencer
+			chance = 5;
+		}
+		else
+		{
+			chance = NPCInfo->rank;
+		}
+		if ( Q_irand( 0, 30 ) < chance )
+		{//based on skill with some randomness
+			NPC->client->ps.saberEventFlags &= ~SEF_LOCK_WON;//clear this now that we are using the opportunity
+			TIMER_Set( NPC, "noRetreat", Q_irand( 500, 2000 ) );
+			//FIXME: check enemy_dist?
+			NPC->client->ps.weaponTime = NPCInfo->shotTime = NPC->attackDebounceTime = 0;
+			//NPC->client->ps.fd.forcePowerDebounce[FP_SABER_DEFENSE] = level.time + 500;
+			NPC->client->ps.saberBlocked = BLOCKED_NONE;
+			WeaponThink( qtrue );
+			return qtrue;
+		}
+	}
+
+	if ( NPC->client->NPC_class == CLASS_TAVION ||
+		( NPC->client->NPC_class == CLASS_REBORN && NPCInfo->rank == RANK_LT_JG ) ||
+		( NPC->client->NPC_class == CLASS_JEDI && NPCInfo->rank == RANK_COMMANDER ) )
+	{//tavion, fencers, jedi trainer are all good at following up a parry with an attack
+		if ( ( PM_SaberInParry( NPC->client->ps.saberMove ) || PM_SaberInKnockaway( NPC->client->ps.saberMove ) )
+			&& NPC->client->ps.saberBlocked != BLOCKED_PARRY_BROKEN )
+		{//try to attack straight from a parry
+			NPC->client->ps.weaponTime = NPCInfo->shotTime = NPC->attackDebounceTime = 0;
+			//NPC->client->ps.fd.forcePowerDebounce[FP_SABER_DEFENSE] = level.time + 500;
+			NPC->client->ps.saberBlocked = BLOCKED_NONE;
+			Jedi_AdjustSaberAnimLevel( NPC, FORCE_LEVEL_1 );//try to follow-up with a quick attack
+			WeaponThink( qtrue );
+			return qtrue;
+		}
+	}
+
+	//try to hit them if we can
+	if ( enemy_dist >= 64 )
+	{
+		return qfalse;
+	}
+
+	if ( !TIMER_Done( NPC, "parryTime" ) )
+	{
+		return qfalse;
+	}
+
+	if ( (NPCInfo->scriptFlags&SCF_DONT_FIRE) )
+	{//not allowed to attack
+		return qfalse;
+	}
+
+	if ( !(ucmd.buttons&BUTTON_ATTACK) && !(ucmd.buttons&BUTTON_ALT_ATTACK) )
+	{//not already attacking
+		//Try to attack
+		WeaponThink( qtrue );
+	}
+	
+	//FIXME:  Maybe try to push enemy off a ledge?
+
+	//close enough to step forward
+
+	//FIXME: an attack debounce timer other than the phaser debounce time?
+	//		or base it on aggression?
+
+	if ( ucmd.buttons&BUTTON_ATTACK )
+	{//attacking
+		/*
+		if ( enemy_dist > 32 && NPCInfo->stats.aggression >= 4 )
+		{//move forward if we're too far away and we're chasing him
+			ucmd.forwardmove = 127;
+		}
+		else if ( enemy_dist < 0 )
+		{//move back if we're too close
+			ucmd.forwardmove = -127;
+		}
+		*/
+		//FIXME: based on the type of parry/attack the enemy is doing and my skill,
+		//		choose an attack that is likely to get around the parry?
+		//		right now that's generic in the saber animation code, auto-picks
+		//		a next anim for me, but really should be AI-controlled.
+		//FIXME: have this interact with/override above strafing code?
+		if ( !ucmd.rightmove )
+		{//not already strafing
+			if ( !Q_irand( 0, 3 ) )
+			{//25% chance of doing this
+				vec3_t  right, dir2enemy;
+
+				AngleVectors( NPC->r.currentAngles, NULL, right, NULL );
+				VectorSubtract( NPC->enemy->r.currentOrigin, NPC->r.currentAngles, dir2enemy );
+				if ( DotProduct( right, dir2enemy ) > 0 )
+				{//he's to my right, strafe left
+					ucmd.rightmove = -127;
+					VectorClear( NPC->client->ps.moveDir );
+				}
+				else
+				{//he's to my left, strafe right
+					ucmd.rightmove = 127;
+					VectorClear( NPC->client->ps.moveDir );
+				}
+			}
+		}
+		return qtrue;
+	}
+
+	return qfalse;
+}
+
+#define	APEX_HEIGHT		200.0f
+#define	PARA_WIDTH		(sqrt(APEX_HEIGHT)+sqrt(APEX_HEIGHT))
+#define	JUMP_SPEED		200.0f
+
+static qboolean Jedi_Jump( vec3_t dest, int goalEntNum )
+{//FIXME: if land on enemy, knock him down & jump off again
+	/*
+	if ( dest[2] - NPC->r.currentOrigin[2] < 64 && DistanceHorizontal( NPC->r.currentOrigin, dest ) > 256 )
+	{//a pretty horizontal jump, easy to fake:
+		vec3_t enemy_diff;
+
+		VectorSubtract( dest, NPC->r.currentOrigin, enemy_diff );
+		float enemy_z_diff = enemy_diff[2];
+		enemy_diff[2] = 0;
+		float enemy_xy_diff = VectorNormalize( enemy_diff );
+
+		VectorScale( enemy_diff, enemy_xy_diff*0.8, NPC->client->ps.velocity );
+		if ( enemy_z_diff < 64 )
+		{
+			NPC->client->ps.velocity[2] = enemy_xy_diff;
+		}
+		else
+		{
+			NPC->client->ps.velocity[2] = enemy_z_diff*2+enemy_xy_diff/2;
+		}
+	}
+	else
+	*/
+	if ( 1 )
+	{
+		float	targetDist, shotSpeed = 300, travelTime, impactDist, bestImpactDist = Q3_INFINITE;//fireSpeed, 
+		vec3_t	targetDir, shotVel, failCase; 
+		trace_t	trace;
+		trajectory_t	tr;
+		qboolean	blocked;
+		int		elapsedTime, timeStep = 500, hitCount = 0, maxHits = 7;
+		vec3_t	lastPos, testPos, bottom;
+
+		while ( hitCount < maxHits )
+		{
+			VectorSubtract( dest, NPC->r.currentOrigin, targetDir );
+			targetDist = VectorNormalize( targetDir );
+
+			VectorScale( targetDir, shotSpeed, shotVel );
+			travelTime = targetDist/shotSpeed;
+			shotVel[2] += travelTime * 0.5 * NPC->client->ps.gravity;
+
+			if ( !hitCount )		
+			{//save the first one as the worst case scenario
+				VectorCopy( shotVel, failCase );
+			}
+
+			if ( 1 )//tracePath )
+			{//do a rough trace of the path
+				blocked = qfalse;
+
+				VectorCopy( NPC->r.currentOrigin, tr.trBase );
+				VectorCopy( shotVel, tr.trDelta );
+				tr.trType = TR_GRAVITY;
+				tr.trTime = level.time;
+				travelTime *= 1000.0f;
+				VectorCopy( NPC->r.currentOrigin, lastPos );
+				
+				//This may be kind of wasteful, especially on long throws... use larger steps?  Divide the travelTime into a certain hard number of slices?  Trace just to apex and down?
+				for ( elapsedTime = timeStep; elapsedTime < floor(travelTime)+timeStep; elapsedTime += timeStep )
+				{
+					if ( (float)elapsedTime > travelTime )
+					{//cap it
+						elapsedTime = floor( travelTime );
+					}
+					BG_EvaluateTrajectory( &tr, level.time + elapsedTime, testPos );
+					if ( testPos[2] < lastPos[2] )
+					{//going down, ignore botclip
+						trap_Trace( &trace, lastPos, NPC->r.mins, NPC->r.maxs, testPos, NPC->s.number, NPC->clipmask );
+					}
+					else
+					{//going up, check for botclip
+						trap_Trace( &trace, lastPos, NPC->r.mins, NPC->r.maxs, testPos, NPC->s.number, NPC->clipmask|CONTENTS_BOTCLIP );
+					}
+
+					if ( trace.allsolid || trace.startsolid )
+					{
+						blocked = qtrue;
+						break;
+					}
+					if ( trace.fraction < 1.0f )
+					{//hit something
+						if ( trace.entityNum == goalEntNum )
+						{//hit the enemy, that's perfect!
+							//Hmm, don't want to land on him, though...
+							break;
+						}
+						else 
+						{
+							if ( trace.contents & CONTENTS_BOTCLIP )
+							{//hit a do-not-enter brush
+								blocked = qtrue;
+								break;
+							}
+							if ( trace.plane.normal[2] > 0.7 && DistanceSquared( trace.endpos, dest ) < 4096 )//hit within 64 of desired location, should be okay
+							{//close enough!
+								break;
+							}
+							else
+							{//FIXME: maybe find the extents of this brush and go above or below it on next try somehow?
+								impactDist = DistanceSquared( trace.endpos, dest );
+								if ( impactDist < bestImpactDist )
+								{
+									bestImpactDist = impactDist;
+									VectorCopy( shotVel, failCase );
+								}
+								blocked = qtrue;
+								break;
+							}
+						}
+					}
+					if ( elapsedTime == floor( travelTime ) )
+					{//reached end, all clear
+						if ( trace.fraction >= 1.0f )
+						{//hmm, make sure we'll land on the ground...
+							//FIXME: do we care how far below ourselves or our dest we'll land?
+							VectorCopy( trace.endpos, bottom );
+							bottom[2] -= 128;
+							trap_Trace( &trace, trace.endpos, NPC->r.mins, NPC->r.maxs, bottom, NPC->s.number, NPC->clipmask );
+							if ( trace.fraction >= 1.0f )
+							{//would fall too far
+								blocked = qtrue;
+							}
+						}
+						break;
+					}
+					else
+					{
+						//all clear, try next slice
+						VectorCopy( testPos, lastPos );
+					}
+				}
+				if ( blocked )
+				{//hit something, adjust speed (which will change arc)
+					hitCount++;
+					shotSpeed = 300 + ((hitCount-2) * 100);//from 100 to 900 (skipping 300)
+					if ( hitCount >= 2 )
+					{//skip 300 since that was the first value we tested
+						shotSpeed += 100;
+					}
+				}
+				else
+				{//made it!
+					break;
+				}
+			}
+			else
+			{//no need to check the path, go with first calc
+				break;
+			}
+		}
+
+		if ( hitCount >= maxHits )
+		{//NOTE: worst case scenario, use the one that impacted closest to the target (or just use the first try...?)
+			//NOTE: or try failcase?
+			VectorCopy( failCase, NPC->client->ps.velocity );
+		}
+		VectorCopy( shotVel, NPC->client->ps.velocity );
+	}
+	else
+	{//a more complicated jump
+		vec3_t		dir, p1, p2, apex;
+		float		time, height, forward, z, xy, dist, apexHeight;
+
+		if ( NPC->r.currentOrigin[2] > dest[2] )//NPCInfo->goalEntity->r.currentOrigin
+		{
+			VectorCopy( NPC->r.currentOrigin, p1 );
+			VectorCopy( dest, p2 );//NPCInfo->goalEntity->r.currentOrigin
+		}
+		else if ( NPC->r.currentOrigin[2] < dest[2] )//NPCInfo->goalEntity->r.currentOrigin
+		{
+			VectorCopy( dest, p1 );//NPCInfo->goalEntity->r.currentOrigin
+			VectorCopy( NPC->r.currentOrigin, p2 );
+		}
+		else
+		{
+			VectorCopy( NPC->r.currentOrigin, p1 );
+			VectorCopy( dest, p2 );//NPCInfo->goalEntity->r.currentOrigin
+		}
+
+		//z = xy*xy
+		VectorSubtract( p2, p1, dir );
+		dir[2] = 0;
+
+		//Get xy and z diffs
+		xy = VectorNormalize( dir );
+		z = p1[2] - p2[2];
+
+		apexHeight = APEX_HEIGHT/2;
+
+		//Determine most desirable apex height
+		//FIXME: length of xy will change curve of parabola, need to account for this
+		//somewhere... PARA_WIDTH
+		/*
+		apexHeight = (APEX_HEIGHT * PARA_WIDTH/xy) + (APEX_HEIGHT * z/128);
+		if ( apexHeight < APEX_HEIGHT * 0.5 )
+		{
+			apexHeight = APEX_HEIGHT*0.5;
+		}
+		else if ( apexHeight > APEX_HEIGHT * 2 )
+		{
+			apexHeight = APEX_HEIGHT*2;
+		}
+		*/
+
+		z = (sqrt(apexHeight + z) - sqrt(apexHeight));
+
+		assert(z >= 0);
+
+//		Com_Printf("apex is %4.2f percent from p1: ", (xy-z)*0.5/xy*100.0f);
+
+		xy -= z;
+		xy *= 0.5;
+		
+		assert(xy > 0);
+
+		VectorMA( p1, xy, dir, apex );
+		apex[2] += apexHeight;
+
+		VectorCopy(apex, NPC->pos1);
+		
+		//Now we have the apex, aim for it
+		height = apex[2] - NPC->r.currentOrigin[2];
+		time = sqrt( height / ( .5 * NPC->client->ps.gravity ) );//was 0.5, but didn't work well for very long jumps
+		if ( !time ) 
+		{
+			//Com_Printf( S_COLOR_RED"ERROR: no time in jump\n" );
+			return qfalse;
+		}
+
+		VectorSubtract ( apex, NPC->r.currentOrigin, NPC->client->ps.velocity );
+		NPC->client->ps.velocity[2] = 0;
+		dist = VectorNormalize( NPC->client->ps.velocity );
+
+		forward = dist / time * 1.25;//er... probably bad, but...
+		VectorScale( NPC->client->ps.velocity, forward, NPC->client->ps.velocity );
+
+		//FIXME:  Uh.... should we trace/EvaluateTrajectory this to make sure we have clearance and we land where we want?
+		NPC->client->ps.velocity[2] = time * NPC->client->ps.gravity;
+
+		//Com_Printf("Jump Velocity: %4.2f, %4.2f, %4.2f\n", NPC->client->ps.velocity[0], NPC->client->ps.velocity[1], NPC->client->ps.velocity[2] );
+	}
+	return qtrue;
+}
+
+static qboolean Jedi_TryJump( gentity_t *goal )
+{//FIXME: never does a simple short, regular jump...
+	//FIXME: I need to be on ground too!
+	if ( (NPCInfo->scriptFlags&SCF_NO_ACROBATICS) )
+	{
+		return qfalse;
+	}
+	if ( TIMER_Done( NPC, "jumpChaseDebounce" ) )
+	{
+		if ( (!goal->client || goal->client->ps.groundEntityNum != ENTITYNUM_NONE) )
+		{
+			if ( !PM_InKnockDown( &NPC->client->ps ) && !BG_InRoll( &NPC->client->ps, NPC->client->ps.legsAnim ) )
+			{//enemy is on terra firma
+				vec3_t goal_diff;
+				float goal_z_diff;
+				float goal_xy_dist;
+				VectorSubtract( goal->r.currentOrigin, NPC->r.currentOrigin, goal_diff );
+				goal_z_diff = goal_diff[2];
+				goal_diff[2] = 0;
+				goal_xy_dist = VectorNormalize( goal_diff );
+				if ( goal_xy_dist < 550 && goal_z_diff > -400/*was -256*/ )//for now, jedi don't take falling damage && (NPC->health > 20 || goal_z_diff > 0 ) && (NPC->health >= 100 || goal_z_diff > -128 ))//closer than @512
+				{
+					qboolean debounce = qfalse;
+					if ( NPC->health < 150 && ((NPC->health < 30 && goal_z_diff < 0) || goal_z_diff < -128 ) )
+					{//don't jump, just walk off... doesn't help with ledges, though
+						debounce = qtrue;
+					}
+					else if ( goal_z_diff < 32 && goal_xy_dist < 200 )
+					{//what is their ideal jump height?
+						ucmd.upmove = 127;
+						debounce = qtrue;
+					}
+					else
+					{
+						/*
+						//NO!  All Jedi can jump-navigate now...
+						if ( NPCInfo->rank != RANK_CREWMAN && NPCInfo->rank <= RANK_LT_JG )
+						{//can't do acrobatics
+							return qfalse;
+						}
+						*/
+						if ( goal_z_diff > 0 || goal_xy_dist > 128 )
+						{//Fake a force-jump
+							//Screw it, just do my own calc & throw
+							vec3_t dest;
+							VectorCopy( goal->r.currentOrigin, dest );
+							if ( goal == NPC->enemy )
+							{
+								int	sideTry = 0;
+								while( sideTry < 10 )
+								{//FIXME: make it so it doesn't try the same spot again?
+									trace_t	trace;
+									vec3_t	bottom;
+
+									if ( Q_irand( 0, 1 ) )
+									{
+										dest[0] += NPC->enemy->r.maxs[0]*1.25;
+									}
+									else
+									{
+										dest[0] += NPC->enemy->r.mins[0]*1.25;
+									}
+									if ( Q_irand( 0, 1 ) )
+									{
+										dest[1] += NPC->enemy->r.maxs[1]*1.25;
+									}
+									else
+									{
+										dest[1] += NPC->enemy->r.mins[1]*1.25;
+									}
+									VectorCopy( dest, bottom );
+									bottom[2] -= 128;
+									trap_Trace( &trace, dest, NPC->r.mins, NPC->r.maxs, bottom, goal->s.number, NPC->clipmask );
+									if ( trace.fraction < 1.0f )
+									{//hit floor, okay to land here
+										break;
+									}
+									sideTry++;
+								}
+								if ( sideTry >= 10 )
+								{//screw it, just jump right at him?
+									VectorCopy( goal->r.currentOrigin, dest );
+								}
+							}
+							if ( Jedi_Jump( dest, goal->s.number ) )
+							{
+								//Com_Printf( "(%d) pre-checked force jump\n", level.time );
+
+								//FIXME: store the dir we;re going in in case something gets in the way of the jump?
+								//? = vectoyaw( NPC->client->ps.velocity );
+								/*
+								if ( NPC->client->ps.velocity[2] < 320 )
+								{
+									NPC->client->ps.velocity[2] = 320;
+								}
+								else
+								*/
+								{//FIXME: make this a function call
+									int jumpAnim;
+									//FIXME: this should be more intelligent, like the normal force jump anim logic
+									if ( NPC->client->NPC_class == CLASS_BOBAFETT 
+										||( NPCInfo->rank != RANK_CREWMAN && NPCInfo->rank <= RANK_LT_JG ) )
+									{//can't do acrobatics
+										jumpAnim = BOTH_FORCEJUMP1;
+									}
+									else
+									{
+										jumpAnim = BOTH_FLIP_F;
+									}
+									NPC_SetAnim( NPC, SETANIM_BOTH, jumpAnim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+								}
+
+								NPC->client->ps.fd.forceJumpZStart = NPC->r.currentOrigin[2];
+								//NPC->client->ps.pm_flags |= PMF_JUMPING;
+
+								NPC->client->ps.weaponTime = NPC->client->ps.torsoTimer;
+								NPC->client->ps.fd.forcePowersActive |= ( 1 << FP_LEVITATION );
+								if ( NPC->client->NPC_class == CLASS_BOBAFETT )
+								{
+									G_SoundOnEnt( NPC, CHAN_ITEM, "sound/boba/jeton.wav" );
+									NPC->client->jetPackTime = level.time + Q_irand( 1000, 3000 );
+								}
+								else
+								{
+									G_SoundOnEnt( NPC, CHAN_BODY, "sound/weapons/force/jump.wav" );
+								}
+
+								TIMER_Set( NPC, "forceJumpChasing", Q_irand( 2000, 3000 ) );
+								debounce = qtrue;
+							}
+						}
+					}
+					if ( debounce )
+					{
+						//Don't jump again for another 2 to 5 seconds
+						TIMER_Set( NPC, "jumpChaseDebounce", Q_irand( 2000, 5000 ) );
+						ucmd.forwardmove = 127;
+						VectorClear( NPC->client->ps.moveDir );
+						TIMER_Set( NPC, "duck", -level.time );
+						return qtrue;
+					}
+				}
+			}
+		}
+	}
+	return qfalse;
+}
+
+static qboolean Jedi_Jumping( gentity_t *goal )
+{
+	if ( !TIMER_Done( NPC, "forceJumpChasing" ) && goal )
+	{//force-jumping at the enemy
+//		if ( !(NPC->client->ps.pm_flags & PMF_JUMPING )//forceJumpZStart )
+//			&& !(NPC->client->ps.pm_flags&PMF_TRIGGER_PUSHED))
+		if (NPC->client->ps.groundEntityNum != ENTITYNUM_NONE) //rwwFIXMEFIXME: Not sure if this is gonna work, use the PM flags ideally.
+		{//landed
+			TIMER_Set( NPC, "forceJumpChasing", 0 );
+		}
+		else
+		{
+			NPC_FaceEntity( goal, qtrue );
+			//FIXME: push me torward where I was heading
+			//FIXME: if hit a ledge as soon as we jumped, we need to push toward our goal... must remember original jump dir and/or original jump dest
+			/*
+			vec3_t	viewangles_xy={0,0,0}, goal_dir, goal_xy_dir, forward, right;
+			float	goal_dist;
+			
+			//gert horz dir to goal
+			VectorSubtract( goal->r.currentOrigin, NPC->r.currentOrigin, goal_dir );
+			VectorCopy( goal_dir, goal_xy_dir );
+			goal_dist = VectorNormalize( goal_dir );
+			goal_xy_dir[2] = 0;
+			VectorNormalize( goal_xy_dir );
+
+			//get horz facing
+			viewangles_xy[1] = NPC->client->ps.viewangles[1];
+			AngleVectors( viewangles_xy, forward, right, NULL );
+
+			//get movement commands to push me toward enemy
+			float fDot = DotProduct( forward, goal_dir ) * 127;
+			float rDot = DotProduct( right, goal_dir ) * 127;
+		
+			ucmd.forwardmove = floor(fDot);
+			ucmd.rightmove = floor(rDot);
+			ucmd.upmove = 0;//don't duck
+			//Cheat:
+			if ( goal_dist < 128 && goal->r.currentOrigin[2] > NPC->r.currentOrigin[2] && NPC->client->ps.velocity[2] <= 0 )
+			{
+				NPC->client->ps.velocity[2] += 320;
+			}
+			*/
+			return qtrue;
+		}
+	}
+	return qfalse;
+}
+
+extern void G_UcmdMoveForDir( gentity_t *self, usercmd_t *cmd, vec3_t dir );
+static void Jedi_CheckEnemyMovement( float enemy_dist )
+{
+	if ( !NPC->enemy || !NPC->enemy->client )
+	{
+		return;
+	}
+
+	if ( NPC->client->NPC_class != CLASS_TAVION 
+		&& NPC->client->NPC_class != CLASS_DESANN
+		&& NPC->client->NPC_class != CLASS_LUKE 
+		&& Q_stricmp("Yoda",NPC->NPC_type) )
+	{
+		if ( NPC->enemy->enemy && NPC->enemy->enemy == NPC )
+		{//enemy is mad at *me*
+			if ( NPC->enemy->client->ps.legsAnim == BOTH_JUMPFLIPSLASHDOWN1 ||
+				NPC->enemy->client->ps.legsAnim == BOTH_JUMPFLIPSTABDOWN )
+			{//enemy is flipping over me
+				if ( Q_irand( 0, NPCInfo->rank ) < RANK_LT )
+				{//be nice and stand still for him...
+					ucmd.forwardmove = ucmd.rightmove = ucmd.upmove = 0;
+					VectorClear( NPC->client->ps.moveDir );
+					NPC->client->ps.fd.forceJumpCharge = 0;
+					TIMER_Set( NPC, "strafeLeft", -1 );
+					TIMER_Set( NPC, "strafeRight", -1 );
+					TIMER_Set( NPC, "noStrafe", Q_irand( 500, 1000 ) );
+					TIMER_Set( NPC, "movenone", Q_irand( 500, 1000 ) );
+					TIMER_Set( NPC, "movecenter", Q_irand( 500, 1000 ) );
+				}
+			}
+			else if ( NPC->enemy->client->ps.legsAnim == BOTH_WALL_FLIP_BACK1 
+				|| NPC->enemy->client->ps.legsAnim == BOTH_WALL_FLIP_RIGHT 
+				|| NPC->enemy->client->ps.legsAnim == BOTH_WALL_FLIP_LEFT 
+				|| NPC->enemy->client->ps.legsAnim == BOTH_WALL_RUN_LEFT_FLIP 
+				|| NPC->enemy->client->ps.legsAnim == BOTH_WALL_RUN_RIGHT_FLIP )
+			{//he's flipping off a wall
+				if ( NPC->enemy->client->ps.groundEntityNum == ENTITYNUM_NONE )
+				{//still in air
+					if ( enemy_dist < 256 )
+					{//close
+						if ( Q_irand( 0, NPCInfo->rank ) < RANK_LT )
+						{//be nice and stand still for him...
+							vec3_t enemyFwd, dest, dir;
+
+							/*
+							ucmd.forwardmove = ucmd.rightmove = ucmd.upmove = 0;
+							VectorClear( NPC->client->ps.moveDir );
+							NPC->client->ps.fd.forceJumpCharge = 0;
+							TIMER_Set( NPC, "strafeLeft", -1 );
+							TIMER_Set( NPC, "strafeRight", -1 );
+							TIMER_Set( NPC, "noStrafe", Q_irand( 500, 1000 ) );
+							TIMER_Set( NPC, "movenone", Q_irand( 500, 1000 ) );
+							TIMER_Set( NPC, "movecenter", Q_irand( 500, 1000 ) );
+							TIMER_Set( NPC, "noturn", Q_irand( 200, 500 ) );
+							*/
+							//stop current movement
+							ucmd.forwardmove = ucmd.rightmove = ucmd.upmove = 0;
+							VectorClear( NPC->client->ps.moveDir );
+							NPC->client->ps.fd.forceJumpCharge = 0;
+							TIMER_Set( NPC, "strafeLeft", -1 );
+							TIMER_Set( NPC, "strafeRight", -1 );
+							TIMER_Set( NPC, "noStrafe", Q_irand( 500, 1000 ) );
+							TIMER_Set( NPC, "noturn", Q_irand( 250, 500 )*(3-g_spskill.integer) );
+
+							VectorCopy( NPC->enemy->client->ps.velocity, enemyFwd );
+							VectorNormalize( enemyFwd );
+							VectorMA( NPC->enemy->r.currentOrigin, -64, enemyFwd, dest );
+							VectorSubtract( dest, NPC->r.currentOrigin, dir );
+							if ( VectorNormalize( dir ) > 32 )
+							{
+								G_UcmdMoveForDir( NPC, &ucmd, dir );
+							}
+							else
+							{
+								TIMER_Set( NPC, "movenone", Q_irand( 500, 1000 ) );
+								TIMER_Set( NPC, "movecenter", Q_irand( 500, 1000 ) );
+							}
+						}
+					}
+				}
+			}
+			else if ( NPC->enemy->client->ps.legsAnim == BOTH_A2_STABBACK1 )
+			{//he's stabbing backwards
+				if ( enemy_dist < 256 && enemy_dist > 64 )
+				{//close
+					if ( !InFront( NPC->r.currentOrigin, NPC->enemy->r.currentOrigin, NPC->enemy->r.currentAngles, 0.0f ) )
+					{//behind him
+						if ( !Q_irand( 0, NPCInfo->rank ) )
+						{//be nice and stand still for him...
+							vec3_t enemyFwd, dest, dir;
+
+							//stop current movement
+							ucmd.forwardmove = ucmd.rightmove = ucmd.upmove = 0;
+							VectorClear( NPC->client->ps.moveDir );
+							NPC->client->ps.fd.forceJumpCharge = 0;
+							TIMER_Set( NPC, "strafeLeft", -1 );
+							TIMER_Set( NPC, "strafeRight", -1 );
+							TIMER_Set( NPC, "noStrafe", Q_irand( 500, 1000 ) );
+
+							AngleVectors( NPC->enemy->r.currentAngles, enemyFwd, NULL, NULL );
+							VectorMA( NPC->enemy->r.currentOrigin, -32, enemyFwd, dest );
+							VectorSubtract( dest, NPC->r.currentOrigin, dir );
+							if ( VectorNormalize( dir ) > 64 )
+							{
+								G_UcmdMoveForDir( NPC, &ucmd, dir );
+							}
+							else
+							{
+								TIMER_Set( NPC, "movenone", Q_irand( 500, 1000 ) );
+								TIMER_Set( NPC, "movecenter", Q_irand( 500, 1000 ) );
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+	//FIXME: also:
+	//		If enemy doing wall flip, keep running forward
+	//		If enemy doing back-attack and we're behind him keep running forward toward his back, don't strafe
+}
+
+static void Jedi_CheckJumps( void )
+{
+	vec3_t	jumpVel;
+	trace_t	trace;
+	trajectory_t	tr;
+	vec3_t	lastPos, testPos, bottom;
+	int		elapsedTime;
+
+	if ( (NPCInfo->scriptFlags&SCF_NO_ACROBATICS) )
+	{
+		NPC->client->ps.fd.forceJumpCharge = 0;
+		ucmd.upmove = 0;
+		return;
+	}
+	//FIXME: should probably check this before AI decides that best move is to jump?  Otherwise, they may end up just standing there and looking dumb
+	//FIXME: all this work and he still jumps off ledges... *sigh*... need CONTENTS_BOTCLIP do-not-enter brushes...?
+	VectorClear(jumpVel);
+
+	if ( NPC->client->ps.fd.forceJumpCharge )
+	{
+		//Com_Printf( "(%d) force jump\n", level.time );
+		WP_GetVelocityForForceJump( NPC, jumpVel, &ucmd );
+	}
+	else if ( ucmd.upmove > 0 )
+	{
+		//Com_Printf( "(%d) regular jump\n", level.time );
+		VectorCopy( NPC->client->ps.velocity, jumpVel );
+		jumpVel[2] = JUMP_VELOCITY;
+	}
+	else
+	{
+		return;
+	}
+	
+	//NOTE: for now, we clear ucmd.forwardmove & ucmd.rightmove while in air to avoid jumps going awry...
+	if ( !jumpVel[0] && !jumpVel[1] )//FIXME: && !ucmd.forwardmove && !ucmd.rightmove?
+	{//we assume a jump straight up is safe
+		//Com_Printf( "(%d) jump straight up is safe\n", level.time );
+		return;
+	}
+	//Now predict where this is going
+	//in steps, keep evaluating the trajectory until the new z pos is <= than current z pos, trace down from there
+
+	VectorCopy( NPC->r.currentOrigin, tr.trBase );
+	VectorCopy( jumpVel, tr.trDelta );
+	tr.trType = TR_GRAVITY;
+	tr.trTime = level.time;
+	VectorCopy( NPC->r.currentOrigin, lastPos );
+	
+	VectorClear(trace.endpos); //shut the compiler up
+
+	//This may be kind of wasteful, especially on long throws... use larger steps?  Divide the travelTime into a certain hard number of slices?  Trace just to apex and down?
+	for ( elapsedTime = 500; elapsedTime <= 4000; elapsedTime += 500 )
+	{
+		BG_EvaluateTrajectory( &tr, level.time + elapsedTime, testPos );
+		//FIXME: account for PM_AirMove if ucmd.forwardmove and/or ucmd.rightmove is non-zero...
+		if ( testPos[2] < lastPos[2] )
+		{//going down, don't check for BOTCLIP
+			trap_Trace( &trace, lastPos, NPC->r.mins, NPC->r.maxs, testPos, NPC->s.number, NPC->clipmask );//FIXME: include CONTENTS_BOTCLIP?
+		}
+		else
+		{//going up, check for BOTCLIP
+			trap_Trace( &trace, lastPos, NPC->r.mins, NPC->r.maxs, testPos, NPC->s.number, NPC->clipmask|CONTENTS_BOTCLIP );
+		}
+		if ( trace.allsolid || trace.startsolid )
+		{//WTF?
+			//FIXME: what do we do when we start INSIDE the CONTENTS_BOTCLIP?  Do the trace again without that clipmask?
+			goto jump_unsafe;
+			return;
+		}
+		if ( trace.fraction < 1.0f )
+		{//hit something
+			if ( trace.contents & CONTENTS_BOTCLIP )
+			{//hit a do-not-enter brush
+				goto jump_unsafe;
+				return;
+			}
+			//FIXME: trace through func_glass?
+			break;
+		}
+		VectorCopy( testPos, lastPos );
+	}
+	//okay, reached end of jump, now trace down from here for a floor
+	VectorCopy( trace.endpos, bottom );
+	if ( bottom[2] > NPC->r.currentOrigin[2] )
+	{//only care about dist down from current height or lower
+		bottom[2] = NPC->r.currentOrigin[2];
+	}
+	else if ( NPC->r.currentOrigin[2] - bottom[2] > 400 )
+	{//whoa, long drop, don't do it!
+		//probably no floor at end of jump, so don't jump
+		goto jump_unsafe;
+		return;
+	}
+	bottom[2] -= 128;
+	trap_Trace( &trace, trace.endpos, NPC->r.mins, NPC->r.maxs, bottom, NPC->s.number, NPC->clipmask );
+	if ( trace.allsolid || trace.startsolid || trace.fraction < 1.0f )
+	{//hit ground!
+		if ( trace.entityNum < ENTITYNUM_WORLD )
+		{//landed on an ent
+			gentity_t *groundEnt = &g_entities[trace.entityNum];
+			if ( groundEnt->r.svFlags&SVF_GLASS_BRUSH )
+			{//don't land on breakable glass!
+				goto jump_unsafe;
+				return;
+			}
+		}
+		//Com_Printf( "(%d) jump is safe\n", level.time );
+		return;
+	}
+jump_unsafe:
+	//probably no floor at end of jump, so don't jump
+	//Com_Printf( "(%d) unsafe jump cleared\n", level.time );
+	NPC->client->ps.fd.forceJumpCharge = 0;
+	ucmd.upmove = 0;
+}
+
+static void Jedi_Combat( void )
+{
+	vec3_t	enemy_dir, enemy_movedir, enemy_dest;
+	float	enemy_dist, enemy_movespeed;
+	qboolean	enemy_lost = qfalse;
+
+	//See where enemy will be 300 ms from now
+	Jedi_SetEnemyInfo( enemy_dest, enemy_dir, &enemy_dist, enemy_movedir, &enemy_movespeed, 300 );
+
+	if ( Jedi_Jumping( NPC->enemy ) )
+	{//I'm in the middle of a jump, so just see if I should attack
+		Jedi_AttackDecide( enemy_dist );
+		return;
+	}
+
+	if ( !(NPC->client->ps.fd.forcePowersActive&(1<<FP_GRIP)) || NPC->client->ps.fd.forcePowerLevel[FP_GRIP] < FORCE_LEVEL_2 )
+	{//not gripping
+		//If we can't get straight at him
+		if ( !Jedi_ClearPathToSpot( enemy_dest, NPC->enemy->s.number ) )
+		{//hunt him down
+			//Com_Printf( "No Clear Path\n" );
+			if ( (NPC_ClearLOS4( NPC->enemy )||NPCInfo->enemyLastSeenTime>level.time-500) && NPC_FaceEnemy( qtrue ) )//( NPCInfo->rank == RANK_CREWMAN || NPCInfo->rank > RANK_LT_JG ) && 
+			{
+				//try to jump to him?
+				/*
+				vec3_t end;
+				VectorCopy( NPC->r.currentOrigin, end );
+				end[2] += 36;
+				trap_Trace( &trace, NPC->r.currentOrigin, NPC->r.mins, NPC->r.maxs, end, NPC->s.number, NPC->clipmask|CONTENTS_BOTCLIP );
+				if ( !trace.allsolid && !trace.startsolid && trace.fraction >= 1.0 )
+				{
+					vec3_t angles, forward;
+					VectorCopy( NPC->client->ps.viewangles, angles );
+					angles[0] = 0;
+					AngleVectors( angles, forward, NULL, NULL );
+					VectorMA( end, 64, forward, end );
+					trap_Trace( &trace, NPC->r.currentOrigin, NPC->r.mins, NPC->r.maxs, end, NPC->s.number, NPC->clipmask|CONTENTS_BOTCLIP );
+					if ( !trace.allsolid && !trace.startsolid )
+					{
+						if ( trace.fraction >= 1.0 || trace.plane.normal[2] > 0 )
+						{
+							ucmd.upmove = 127;
+							ucmd.forwardmove = 127;
+							return;
+						}
+					}
+				}
+				*/
+				//FIXME: about every 1 second calc a velocity, 
+				//run a loop of traces with evaluate trajectory 
+				//for gravity with my size, see if it makes it...
+				//this will also catch misacalculations that send you off ledges!
+				//Com_Printf( "Considering Jump\n" );
+				if ( Jedi_TryJump( NPC->enemy ) )
+				{//FIXME: what about jumping to his enemyLastSeenLocation?
+					return;
+				}
+			}
+
+			//Check for evasion
+			if ( TIMER_Done( NPC, "parryTime" ) )
+			{//finished parrying
+				if ( NPC->client->ps.saberBlocked != BLOCKED_ATK_BOUNCE &&
+					NPC->client->ps.saberBlocked != BLOCKED_PARRY_BROKEN )
+				{//wasn't blocked myself
+					NPC->client->ps.saberBlocked = BLOCKED_NONE;
+				}
+			}
+			if ( Jedi_Hunt() && !(NPCInfo->aiFlags&NPCAI_BLOCKED) )//FIXME: have to do this because they can ping-pong forever
+			{//can macro-navigate to him
+				if ( enemy_dist < 384 && !Q_irand( 0, 10 ) && NPCInfo->blockedSpeechDebounceTime < level.time && jediSpeechDebounceTime[NPC->client->playerTeam] < level.time && !NPC_ClearLOS4( NPC->enemy ) )
+				{
+					G_AddVoiceEvent( NPC, Q_irand( EV_JLOST1, EV_JLOST3 ), 3000 );
+					jediSpeechDebounceTime[NPC->client->playerTeam] = NPCInfo->blockedSpeechDebounceTime = level.time + 3000;
+				}
+
+				return;
+			}
+			//well, try to head for his last seen location
+	/*
+			else if ( Jedi_Track() )
+			{
+				return;
+			}
+	*/		else
+			{//FIXME: try to find a waypoint that can see enemy, jump from there
+				if ( NPCInfo->aiFlags & NPCAI_BLOCKED )
+				{//try to jump to the blockedDest
+					gentity_t *tempGoal = G_Spawn();//ugh, this is NOT good...?
+					G_SetOrigin( tempGoal, NPCInfo->blockedDest );
+					trap_LinkEntity( tempGoal );
+					if ( Jedi_TryJump( tempGoal ) )
+					{//going to jump to the dest
+						G_FreeEntity( tempGoal );
+						return;
+					}
+					G_FreeEntity( tempGoal );
+				}
+
+				enemy_lost = qtrue;
+			}
+		}
+	}
+	//else, we can see him or we can't track him at all
+
+	//every few seconds, decide if we should we advance or retreat?
+	Jedi_CombatTimersUpdate( enemy_dist );
+
+	//We call this even if lost enemy to keep him moving and to update the taunting behavior
+	//maintain a distance from enemy appropriate for our aggression level
+	Jedi_CombatDistance( enemy_dist );
+
+	//if ( !enemy_lost )
+	{
+		//Update our seen enemy position
+		if ( !NPC->enemy->client || ( NPC->enemy->client->ps.groundEntityNum != ENTITYNUM_NONE && NPC->client->ps.groundEntityNum != ENTITYNUM_NONE ) )
+		{
+			VectorCopy( NPC->enemy->r.currentOrigin, NPCInfo->enemyLastSeenLocation );
+		}
+		NPCInfo->enemyLastSeenTime = level.time;
+	}
+
+	//Turn to face the enemy
+	if ( TIMER_Done( NPC, "noturn" ) )
+	{
+		Jedi_FaceEnemy( qtrue );
+	}
+	NPC_UpdateAngles( qtrue, qtrue );
+	
+	//Check for evasion
+	if ( TIMER_Done( NPC, "parryTime" ) )
+	{//finished parrying
+		if ( NPC->client->ps.saberBlocked != BLOCKED_ATK_BOUNCE &&
+			NPC->client->ps.saberBlocked != BLOCKED_PARRY_BROKEN )
+		{//wasn't blocked myself
+			NPC->client->ps.saberBlocked = BLOCKED_NONE;
+		}
+	}
+	if ( NPC->enemy->s.weapon == WP_SABER )
+	{
+		Jedi_EvasionSaber( enemy_movedir, enemy_dist, enemy_dir );
+	}
+	else
+	{//do we need to do any evasion for other kinds of enemies?
+	}
+
+	//apply strafing/walking timers, etc.
+	Jedi_TimersApply();
+
+	if ( !NPC->client->ps.saberInFlight && (!(NPC->client->ps.fd.forcePowersActive&(1<<FP_GRIP))||NPC->client->ps.fd.forcePowerLevel[FP_GRIP] < FORCE_LEVEL_2) )
+	{//not throwing saber or using force grip
+		//see if we can attack
+		if ( !Jedi_AttackDecide( enemy_dist ) )
+		{//we're not attacking, decide what else to do
+			Jedi_CombatIdle( enemy_dist );
+			//FIXME: lower aggression when actually strike offensively?  Or just when do damage?
+		}
+		else
+		{//we are attacking
+			//stop taunting
+			TIMER_Set( NPC, "taunting", -level.time );
+		}
+	}
+	else
+	{
+	}
+	if ( NPC->client->NPC_class == CLASS_BOBAFETT )
+	{
+		Boba_FireDecide();
+	}
+
+	//Check for certain enemy special moves
+	Jedi_CheckEnemyMovement( enemy_dist );
+	//Make sure that we don't jump off ledges over long drops
+	Jedi_CheckJumps();
+	//Just make sure we don't strafe into walls or off cliffs
+	if ( !NPC_MoveDirClear( ucmd.forwardmove, ucmd.rightmove, qtrue ) )
+	{//uh-oh, we are going to fall or hit something
+		navInfo_t	info;
+		//Get the move info
+		NAV_GetLastMove( &info );
+		if ( !(info.flags & NIF_MACRO_NAV) )
+		{//micro-navigation told us to step off a ledge, try using macronav for now
+			NPC_MoveToGoal( qfalse );
+		}
+		//reset the timers.
+		TIMER_Set( NPC, "strafeLeft", 0 );
+		TIMER_Set( NPC, "strafeRight", 0 );
+	}
+}
+
+/*
+==========================================================================================
+EXTERNALLY CALLED BEHAVIOR STATES
+==========================================================================================
+*/
+
+/*
+-------------------------
+NPC_Jedi_Pain
+-------------------------
+*/
+
+void NPC_Jedi_Pain(gentity_t *self, gentity_t *attacker, int damage)
+{
+	gentity_t *other = attacker;
+	vec3_t point;
+
+	VectorCopy(gPainPoint, point);
+
+	//FIXME: base the actual aggression add/subtract on health?
+	//FIXME: don't do this more than once per frame?
+	//FIXME: when take pain, stop force gripping....?
+	if ( other->s.weapon == WP_SABER )
+	{//back off
+		TIMER_Set( self, "parryTime", -1 );
+		if ( self->client->NPC_class == CLASS_DESANN || !Q_stricmp("Yoda",self->NPC_type) )
+		{//less for Desann
+			self->client->ps.fd.forcePowerDebounce[FP_SABER_DEFENSE] = level.time + (3-g_spskill.integer)*50;
+		}
+		else if ( self->NPC->rank >= RANK_LT_JG )
+		{
+			self->client->ps.fd.forcePowerDebounce[FP_SABER_DEFENSE] = level.time + (3-g_spskill.integer)*100;//300
+		}
+		else
+		{
+			self->client->ps.fd.forcePowerDebounce[FP_SABER_DEFENSE] = level.time + (3-g_spskill.integer)*200;//500
+		}
+		if ( !Q_irand( 0, 3 ) )
+		{//ouch... maybe switch up which saber power level we're using
+			Jedi_AdjustSaberAnimLevel( self, Q_irand( FORCE_LEVEL_1, FORCE_LEVEL_3 ) );
+		}
+		if ( !Q_irand( 0, 1 ) )//damage > 20 || self->health < 40 || 
+		{
+			//Com_Printf( "(%d) drop agg - hit by saber\n", level.time );
+			Jedi_Aggression( self, -1 );
+		}
+		if ( d_JediAI.integer )
+		{
+			Com_Printf( "(%d) PAIN: agg %d, no parry until %d\n", level.time, self->NPC->stats.aggression, level.time+500 );
+		}
+		//for testing only
+		// Figure out what quadrant the hit was in.
+		if ( d_JediAI.integer )
+		{
+			vec3_t	diff, fwdangles, right;
+			float rightdot, zdiff;
+
+			VectorSubtract( point, self->client->renderInfo.eyePoint, diff );
+			diff[2] = 0;
+			fwdangles[1] = self->client->ps.viewangles[1];
+			AngleVectors( fwdangles, NULL, right, NULL );
+			rightdot = DotProduct(right, diff);
+			zdiff = point[2] - self->client->renderInfo.eyePoint[2];
+		
+			Com_Printf( "(%d) saber hit at height %4.2f, zdiff: %4.2f, rightdot: %4.2f\n", level.time, point[2]-self->r.absmin[2],zdiff,rightdot);
+		}
+	}
+	else
+	{//attack
+		//Com_Printf( "(%d) raise agg - hit by ranged\n", level.time );
+		Jedi_Aggression( self, 1 );
+	}
+
+	self->NPC->enemyCheckDebounceTime = 0;
+
+	WP_ForcePowerStop( self, FP_GRIP );
+
+	//NPC_Pain( self, inflictor, other, point, damage, mod );
+	NPC_Pain(self, attacker, damage);
+
+	if ( !damage && self->health > 0 )
+	{//FIXME: better way to know I was pushed
+		G_AddVoiceEvent( self, Q_irand(EV_PUSHED1, EV_PUSHED3), 2000 );
+	}
+
+	//drop me from the ceiling if I'm on it
+	if ( Jedi_WaitingAmbush( self ) )
+	{
+		self->client->noclip = qfalse;
+	}
+	if ( self->client->ps.legsAnim == BOTH_CEILING_CLING )
+	{
+		NPC_SetAnim( self, SETANIM_LEGS, BOTH_CEILING_DROP, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+	}
+	if ( self->client->ps.torsoAnim == BOTH_CEILING_CLING )
+	{
+		NPC_SetAnim( self, SETANIM_TORSO, BOTH_CEILING_DROP, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+	}
+}
+
+qboolean Jedi_CheckDanger( void )
+{
+	int alertEvent = NPC_CheckAlertEvents( qtrue, qtrue, -1, qfalse, AEL_MINOR );
+	if ( level.alertEvents[alertEvent].level >= AEL_DANGER )
+	{//run away!
+		if ( !level.alertEvents[alertEvent].owner 
+			|| !level.alertEvents[alertEvent].owner->client 
+			|| (level.alertEvents[alertEvent].owner!=NPC&&level.alertEvents[alertEvent].owner->client->playerTeam!=NPC->client->playerTeam) )
+		{//no owner
+			return qfalse;
+		}
+		G_SetEnemy( NPC, level.alertEvents[alertEvent].owner );
+		NPCInfo->enemyLastSeenTime = level.time;
+		TIMER_Set( NPC, "attackDelay", Q_irand( 500, 2500 ) );
+		return qtrue;
+	}
+	return qfalse;
+}
+
+qboolean Jedi_CheckAmbushPlayer( void )
+{
+	int i = 0;
+	gentity_t *player;
+	float target_dist;
+	float zDiff;
+
+	for ( i = 0; i < MAX_CLIENTS; i++ )
+	{
+		player = &g_entities[i];
+
+		if ( !player || !player->client )
+		{
+			continue;
+		}
+
+		if ( !NPC_ValidEnemy( player ) )
+		{
+			continue;
+		}
+
+//		if ( NPC->client->ps.powerups[PW_CLOAKED] || g_crosshairEntNum != NPC->s.number )
+		if (NPC->client->ps.powerups[PW_CLOAKED] || !NPC_SomeoneLookingAtMe(NPC)) //rwwFIXMEFIXME: Need to pay attention to who is under crosshair for each player or something.
+		{//if I'm not cloaked and the player's crosshair is on me, I will wake up, otherwise do this stuff down here...
+			if ( !trap_InPVS( player->r.currentOrigin, NPC->r.currentOrigin ) )
+			{//must be in same room
+				continue;
+			}
+			else
+			{
+				if ( !NPC->client->ps.powerups[PW_CLOAKED] )
+				{
+					NPC_SetLookTarget( NPC, 0, 0 );
+				}
+			}
+			zDiff = NPC->r.currentOrigin[2]-player->r.currentOrigin[2];
+			if ( zDiff <= 0 || zDiff > 512 )
+			{//never ambush if they're above me or way way below me
+				continue;
+			}
+
+			//If the target is this close, then wake up regardless
+			if ( (target_dist = DistanceHorizontalSquared( player->r.currentOrigin, NPC->r.currentOrigin )) > 4096 )
+			{//closer than 64 - always ambush
+				if ( target_dist > 147456 )
+				{//> 384, not close enough to ambush
+					continue;
+				}
+				//Check FOV first
+				if ( NPC->client->ps.powerups[PW_CLOAKED] )
+				{
+					if ( InFOV( player, NPC, 30, 90 ) == qfalse )
+					{
+						continue;
+					}
+				}
+				else
+				{
+					if ( InFOV( player, NPC, 45, 90 ) == qfalse )
+					{
+						continue;
+					}
+				}
+			}
+
+			if ( !NPC_ClearLOS4( player ) )
+			{
+				continue;
+			}
+		}
+
+		//Got him, return true;
+		G_SetEnemy( NPC, player );
+		NPCInfo->enemyLastSeenTime = level.time;
+		TIMER_Set( NPC, "attackDelay", Q_irand( 500, 2500 ) );
+		return qtrue;
+	}
+
+	//Didn't get anyone.
+	return qfalse;
+}
+
+void Jedi_Ambush( gentity_t *self )
+{
+	self->client->noclip = qfalse;
+//	self->client->ps.pm_flags |= PMF_JUMPING|PMF_SLOW_MO_FALL;
+	NPC_SetAnim( self, SETANIM_BOTH, BOTH_CEILING_DROP, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+	self->client->ps.weaponTime = self->client->ps.torsoTimer; //NPC->client->ps.torsoTimer; //what the?
+	if ( self->client->NPC_class != CLASS_BOBAFETT )
+	{
+		WP_ActivateSaber(self);
+	}
+	Jedi_Decloak( self );
+	G_AddVoiceEvent( self, Q_irand( EV_ANGER1, EV_ANGER3 ), 1000 );
+}
+
+qboolean Jedi_WaitingAmbush( gentity_t *self )
+{
+	if ( (self->spawnflags&JSF_AMBUSH) && self->client->noclip )
+	{
+		return qtrue;
+	}
+	return qfalse;
+}
+/*
+-------------------------
+Jedi_Patrol
+-------------------------
+*/
+
+static void Jedi_Patrol( void )
+{
+	NPC->client->ps.saberBlocked = BLOCKED_NONE;
+
+	if ( Jedi_WaitingAmbush( NPC ) )
+	{//hiding on the ceiling
+		NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_CEILING_CLING, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+		if ( NPCInfo->scriptFlags&SCF_LOOK_FOR_ENEMIES )
+		{//look for enemies
+			if ( Jedi_CheckAmbushPlayer() || Jedi_CheckDanger() )
+			{//found him!
+				Jedi_Ambush( NPC );
+				NPC_UpdateAngles( qtrue, qtrue );
+				return;
+			}
+		}
+	}
+	else if ( NPCInfo->scriptFlags&SCF_LOOK_FOR_ENEMIES )//NPCInfo->scriptFlags & SCF_CHASE_ENEMIES )
+	{//look for enemies
+		gentity_t *best_enemy = NULL;
+		float	best_enemy_dist = Q3_INFINITE;
+		int i;
+		for ( i = 0; i < ENTITYNUM_WORLD; i++ )
+		{
+			gentity_t *enemy = &g_entities[i];
+			float	enemy_dist;
+			if ( enemy && enemy->client && NPC_ValidEnemy( enemy ) && enemy->client->playerTeam == NPC->client->enemyTeam )
+			{
+				if ( trap_InPVS( NPC->r.currentOrigin, enemy->r.currentOrigin ) )
+				{//we could potentially see him
+					enemy_dist = DistanceSquared( NPC->r.currentOrigin, enemy->r.currentOrigin );
+					if ( enemy->s.eType == ET_PLAYER || enemy_dist < best_enemy_dist )
+					{
+						//if the enemy is close enough, or threw his saber, take him as the enemy
+						//FIXME: what if he throws a thermal detonator?
+						if ( enemy_dist < (220*220) || ( NPCInfo->investigateCount>= 3 && !NPC->client->ps.saberHolstered ) )
+						{
+							G_SetEnemy( NPC, enemy );
+							//NPCInfo->behaviorState = BS_HUNT_AND_KILL;//should be auto now
+							NPCInfo->stats.aggression = 3;
+							break;
+						}
+						else if ( enemy->client->ps.saberInFlight && !enemy->client->ps.saberHolstered )
+						{//threw his saber, see if it's heading toward me and close enough to consider a threat
+							float	saberDist;
+							vec3_t	saberDir2Me;
+							vec3_t	saberMoveDir;
+							gentity_t *saber = &g_entities[enemy->client->ps.saberEntityNum];
+							VectorSubtract( NPC->r.currentOrigin, saber->r.currentOrigin, saberDir2Me );
+							saberDist = VectorNormalize( saberDir2Me );
+							VectorCopy( saber->s.pos.trDelta, saberMoveDir );
+							VectorNormalize( saberMoveDir );
+							if ( DotProduct( saberMoveDir, saberDir2Me ) > 0.5 )
+							{//it's heading towards me
+								if ( saberDist < 200 )
+								{//incoming!
+									G_SetEnemy( NPC, enemy );
+									//NPCInfo->behaviorState = BS_HUNT_AND_KILL;//should be auto now
+									NPCInfo->stats.aggression = 3;
+									break;
+								}
+							}
+						}
+						best_enemy_dist = enemy_dist;
+						best_enemy = enemy;
+					}
+				}
+			}
+		}
+		if ( !NPC->enemy )
+		{//still not mad
+			if ( !best_enemy )
+			{
+				//Com_Printf( "(%d) drop agg - no enemy (patrol)\n", level.time );
+				Jedi_AggressionErosion(-1);
+				//FIXME: what about alerts?  But not if ignore alerts
+			}
+			else
+			{//have one to consider
+				if ( NPC_ClearLOS4( best_enemy ) )
+				{//we have a clear (of architecture) LOS to him
+					if ( best_enemy->s.number )
+					{//just attack
+						G_SetEnemy( NPC, best_enemy );
+						NPCInfo->stats.aggression = 3;
+					}
+					else if ( NPC->client->NPC_class != CLASS_BOBAFETT )
+					{//the player, toy with him
+						//get progressively more interested over time
+						if ( TIMER_Done( NPC, "watchTime" ) )
+						{//we want to pick him up in stages
+							if ( TIMER_Get( NPC, "watchTime" ) == -1 )
+							{//this is the first time, we'll ignore him for a couple seconds
+								TIMER_Set( NPC, "watchTime", Q_irand( 3000, 5000 ) );
+								goto finish;
+							}
+							else
+							{//okay, we've ignored him, now start to notice him
+								if ( !NPCInfo->investigateCount )
+								{
+									G_AddVoiceEvent( NPC, Q_irand( EV_JDETECTED1, EV_JDETECTED3 ), 3000 );
+								}
+								NPCInfo->investigateCount++;
+								TIMER_Set( NPC, "watchTime", Q_irand( 4000, 10000 ) );
+							}
+						}
+						//while we're waiting, do what we need to do
+						if ( best_enemy_dist < (440*440) || NPCInfo->investigateCount >= 2 )
+						{//stage three: keep facing him
+							NPC_FaceEntity( best_enemy, qtrue );
+							if ( best_enemy_dist < (330*330) )
+							{//stage four: turn on the saber
+								if ( !NPC->client->ps.saberInFlight )
+								{
+									WP_ActivateSaber(NPC);
+								}
+							}
+						}
+						else if ( best_enemy_dist < (550*550) || NPCInfo->investigateCount == 1 )
+						{//stage two: stop and face him every now and then
+							if ( TIMER_Done( NPC, "watchTime" ) )
+							{
+								NPC_FaceEntity( best_enemy, qtrue );
+							}
+						}
+						else
+						{//stage one: look at him.
+							NPC_SetLookTarget( NPC, best_enemy->s.number, 0 );
+						}
+					}
+				}
+				else if ( TIMER_Done( NPC, "watchTime" ) )
+				{//haven't seen him in a bit, clear the lookTarget
+					NPC_ClearLookTarget( NPC );
+				}
+			}
+		}
+	}
+finish:
+	//If we have somewhere to go, then do that
+	if ( UpdateGoal() )
+	{
+		ucmd.buttons |= BUTTON_WALKING;
+		//Jedi_Move( NPCInfo->goalEntity );
+		NPC_MoveToGoal( qtrue );
+	}
+
+	NPC_UpdateAngles( qtrue, qtrue );
+
+	if ( NPC->enemy )
+	{//just picked one up
+		NPCInfo->enemyCheckDebounceTime = level.time + Q_irand( 3000, 10000 );
+	}
+}
+
+qboolean Jedi_CanPullBackSaber( gentity_t *self )
+{
+	if ( self->client->ps.saberBlocked == BLOCKED_PARRY_BROKEN && !TIMER_Done( self, "parryTime" ) )
+	{
+		return qfalse;
+	}
+
+	if ( self->client->NPC_class == CLASS_SHADOWTROOPER
+		|| self->client->NPC_class == CLASS_TAVION
+		|| self->client->NPC_class == CLASS_LUKE
+		|| self->client->NPC_class == CLASS_DESANN 
+		|| !Q_stricmp( "Yoda", self->NPC_type ) )
+	{
+		return qtrue;
+	}
+
+	if ( self->painDebounceTime > level.time )//|| self->client->ps.weaponTime > 0 )
+	{
+		return qfalse;
+	}
+
+	return qtrue;
+}
+/*
+-------------------------
+NPC_BSJedi_FollowLeader
+-------------------------
+*/
+void NPC_BSJedi_FollowLeader( void )
+{
+	NPC->client->ps.saberBlocked = BLOCKED_NONE;
+	if ( !NPC->enemy )
+	{
+		//Com_Printf( "(%d) drop agg - no enemy (follow)\n", level.time );
+		Jedi_AggressionErosion(-1);
+	}
+	
+	//did we drop our saber?  If so, go after it!
+	if ( NPC->client->ps.saberInFlight )
+	{//saber is not in hand
+		if ( NPC->client->ps.saberEntityNum < ENTITYNUM_NONE && NPC->client->ps.saberEntityNum > 0 )//player is 0
+		{//
+			if ( g_entities[NPC->client->ps.saberEntityNum].s.pos.trType == TR_STATIONARY )
+			{//fell to the ground, try to pick it up... 
+				if ( Jedi_CanPullBackSaber( NPC ) )
+				{
+					//FIXME: if it's on the ground and we just pulled it back to us, should we
+					//		stand still for a bit to make sure it gets to us...?
+					//		otherwise we could end up running away from it while it's on its
+					//		way back to us and we could lose it again.
+					NPC->client->ps.saberBlocked = BLOCKED_NONE;
+					NPCInfo->goalEntity = &g_entities[NPC->client->ps.saberEntityNum];
+					ucmd.buttons |= BUTTON_ATTACK;
+					if ( NPC->enemy && NPC->enemy->health > 0 )
+					{//get our saber back NOW!
+						if ( !NPC_MoveToGoal( qtrue ) )//Jedi_Move( NPCInfo->goalEntity, qfalse );
+						{//can't nav to it, try jumping to it
+							NPC_FaceEntity( NPCInfo->goalEntity, qtrue );
+							Jedi_TryJump( NPCInfo->goalEntity );
+						}
+						NPC_UpdateAngles( qtrue, qtrue );
+						return;
+					}
+				}
+			}
+		}
+	}
+
+	if ( NPCInfo->goalEntity )
+	{
+		trace_t	trace;
+
+		if ( Jedi_Jumping( NPCInfo->goalEntity ) )
+		{//in mid-jump
+			return;
+		}
+
+		if ( !NAV_CheckAhead( NPC, NPCInfo->goalEntity->r.currentOrigin, &trace, ( NPC->clipmask & ~CONTENTS_BODY )|CONTENTS_BOTCLIP ) )
+		{//can't get straight to him
+			if ( NPC_ClearLOS4( NPCInfo->goalEntity ) && NPC_FaceEntity( NPCInfo->goalEntity, qtrue ) )
+			{//no line of sight
+				if ( Jedi_TryJump( NPCInfo->goalEntity ) )
+				{//started a jump
+					return;
+				}
+			}
+		}
+		if ( NPCInfo->aiFlags & NPCAI_BLOCKED )
+		{//try to jump to the blockedDest
+			if ( fabs(NPCInfo->blockedDest[2]-NPC->r.currentOrigin[2]) > 64 )
+			{
+				gentity_t *tempGoal = G_Spawn();//ugh, this is NOT good...?
+				G_SetOrigin( tempGoal, NPCInfo->blockedDest );
+				trap_LinkEntity( tempGoal );
+				TIMER_Set( NPC, "jumpChaseDebounce", -1 );
+				if ( Jedi_TryJump( tempGoal ) )
+				{//going to jump to the dest
+					G_FreeEntity( tempGoal );
+					return;
+				}
+				G_FreeEntity( tempGoal );
+			}
+		}
+	}
+	//try normal movement
+	NPC_BSFollowLeader();
+}
+
+
+/*
+-------------------------
+Jedi_Attack
+-------------------------
+*/
+
+static void Jedi_Attack( void )
+{
+	//Don't do anything if we're in a pain anim
+	if ( NPC->painDebounceTime > level.time )
+	{
+		if ( Q_irand( 0, 1 ) )
+		{
+			Jedi_FaceEnemy( qtrue );
+		}
+		NPC_UpdateAngles( qtrue, qtrue );
+		return;
+	}
+
+	if ( NPC->client->ps.saberLockTime > level.time )
+	{
+		//FIXME: maybe if I'm losing I should try to force-push out of it?  Very rarely, though...
+		if ( NPC->client->ps.fd.forcePowerLevel[FP_PUSH] > FORCE_LEVEL_2 
+			&& NPC->client->ps.saberLockTime < level.time + 5000 
+			&& !Q_irand( 0, 10 ))
+		{
+			ForceThrow( NPC, qfalse );
+		}
+		//based on my skill, hit attack button every other to every several frames in order to push enemy back
+		else
+		{
+			float chance;
+		
+			if ( NPC->client->NPC_class == CLASS_DESANN || !Q_stricmp("Yoda",NPC->NPC_type) )
+			{
+				if ( g_spskill.integer )
+				{
+					chance = 4.0f;//he pushes *hard*
+				}
+				else
+				{
+					chance = 3.0f;//he pushes *hard*
+				}
+			}
+			else if ( NPC->client->NPC_class == CLASS_TAVION )
+			{
+				chance = 2.0f+g_spskill.value;//from 2 to 4
+			}
+			else
+			{//the escalation in difficulty is nice, here, but cap it so it doesn't get *impossible* on hard
+				float maxChance	= (float)(RANK_LT)/2.0f+3.0f;//5?
+				if ( !g_spskill.value )
+				{
+					chance = (float)(NPCInfo->rank)/2.0f;
+				}
+				else
+				{
+					chance = (float)(NPCInfo->rank)/2.0f+1.0f;
+				}
+				if ( chance > maxChance )
+				{
+					chance = maxChance;
+				}
+			}
+		//	if ( flrand( -4.0f, chance ) >= 0.0f && !(NPC->client->ps.pm_flags&PMF_ATTACK_HELD) )
+		//	{
+		//		ucmd.buttons |= BUTTON_ATTACK;
+		//	}
+			if ( flrand( -4.0f, chance ) >= 0.0f )
+			{
+				ucmd.buttons |= BUTTON_ATTACK;
+			}
+			//rwwFIXMEFIXME: support for PMF_ATTACK_HELD
+		}
+		NPC_UpdateAngles( qtrue, qtrue );
+		return;
+	}
+	//did we drop our saber?  If so, go after it!
+	if ( NPC->client->ps.saberInFlight )
+	{//saber is not in hand
+	//	if ( NPC->client->ps.saberEntityNum < ENTITYNUM_NONE && NPC->client->ps.saberEntityNum > 0 )//player is 0
+		if (!NPC->client->ps.saberEntityNum && NPC->client->saberStoredIndex) //this is valid, it's 0 when our saber is gone -rww (mp-specific)
+		{//
+			//if ( g_entities[NPC->client->ps.saberEntityNum].s.pos.trType == TR_STATIONARY )
+			if (1) //no matter
+			{//fell to the ground, try to pick it up
+			//	if ( Jedi_CanPullBackSaber( NPC ) )
+				if (1) //no matter
+				{
+					NPC->client->ps.saberBlocked = BLOCKED_NONE;
+					NPCInfo->goalEntity = &g_entities[NPC->client->saberStoredIndex];
+					ucmd.buttons |= BUTTON_ATTACK;
+					if ( NPC->enemy && NPC->enemy->health > 0 )
+					{//get our saber back NOW!
+						Jedi_Move( NPCInfo->goalEntity, qfalse );
+						NPC_UpdateAngles( qtrue, qtrue );
+						if ( NPC->enemy->s.weapon == WP_SABER )
+						{//be sure to continue evasion
+							vec3_t	enemy_dir, enemy_movedir, enemy_dest;
+							float	enemy_dist, enemy_movespeed;
+							Jedi_SetEnemyInfo( enemy_dest, enemy_dir, &enemy_dist, enemy_movedir, &enemy_movespeed, 300 );
+							Jedi_EvasionSaber( enemy_movedir, enemy_dist, enemy_dir );
+						}
+						return;
+					}
+				}
+			}
+		}
+	}
+	//see if our enemy was killed by us, gloat and turn off saber after cool down.
+	//FIXME: don't do this if we have other enemies to fight...?
+	if ( NPC->enemy )
+	{
+		if ( NPC->enemy->health <= 0 && NPC->enemy->enemy == NPC && NPC->client->playerTeam != NPCTEAM_PLAYER )//good guys don't gloat
+		{//my enemy is dead and I killed him
+			NPCInfo->enemyCheckDebounceTime = 0;//keep looking for others
+
+			if ( NPC->client->NPC_class == CLASS_BOBAFETT )
+			{
+				if ( NPCInfo->walkDebounceTime < level.time && NPCInfo->walkDebounceTime >= 0 )
+				{
+					TIMER_Set( NPC, "gloatTime", 10000 );
+					NPCInfo->walkDebounceTime = -1;
+				}
+				if ( !TIMER_Done( NPC, "gloatTime" ) )
+				{
+					if ( DistanceHorizontalSquared( NPC->client->renderInfo.eyePoint, NPC->enemy->r.currentOrigin ) > 4096 && (NPCInfo->scriptFlags&SCF_CHASE_ENEMIES) )//64 squared
+					{
+						NPCInfo->goalEntity = NPC->enemy;
+						Jedi_Move( NPC->enemy, qfalse );
+						ucmd.buttons |= BUTTON_WALKING;
+					}
+					else
+					{
+						TIMER_Set( NPC, "gloatTime", 0 );
+					}
+				}
+				else if ( NPCInfo->walkDebounceTime == -1 )
+				{
+					NPCInfo->walkDebounceTime = -2;
+					G_AddVoiceEvent( NPC, Q_irand( EV_VICTORY1, EV_VICTORY3 ), 3000 );
+					jediSpeechDebounceTime[NPC->client->playerTeam] = level.time + 3000;
+					NPCInfo->desiredPitch = 0;
+					NPCInfo->goalEntity = NULL;
+				}
+				Jedi_FaceEnemy( qtrue );
+				NPC_UpdateAngles( qtrue, qtrue );
+				return;
+			}
+			else
+			{
+				if ( !TIMER_Done( NPC, "parryTime" ) )
+				{
+					TIMER_Set( NPC, "parryTime", -1 );
+					NPC->client->ps.fd.forcePowerDebounce[FP_SABER_DEFENSE] = level.time + 500;
+				}
+				NPC->client->ps.saberBlocked = BLOCKED_NONE;
+				if ( !NPC->client->ps.saberHolstered && NPC->client->ps.saberInFlight )
+				{//saber is still on (or we're trying to pull it back), count down erosion and keep facing the enemy
+					//FIXME: need to stop this from happening over and over again when they're blocking their victim's saber
+					//FIXME: turn off saber sooner so we get cool walk anim?
+					//Com_Printf( "(%d) drop agg - enemy dead\n", level.time );
+					Jedi_AggressionErosion(-3);
+					if ( BG_SabersOff( &NPC->client->ps ) && !NPC->client->ps.saberInFlight )
+					{//turned off saber (in hand), gloat
+						G_AddVoiceEvent( NPC, Q_irand( EV_VICTORY1, EV_VICTORY3 ), 3000 );
+						jediSpeechDebounceTime[NPC->client->playerTeam] = level.time + 3000;
+						NPCInfo->desiredPitch = 0;
+						NPCInfo->goalEntity = NULL;
+					}
+					TIMER_Set( NPC, "gloatTime", 10000 );
+				}
+				if ( !NPC->client->ps.saberHolstered || NPC->client->ps.saberInFlight || !TIMER_Done( NPC, "gloatTime" ) )
+				{//keep walking
+					if ( DistanceHorizontalSquared( NPC->client->renderInfo.eyePoint, NPC->enemy->r.currentOrigin ) > 4096 && (NPCInfo->scriptFlags&SCF_CHASE_ENEMIES) )//64 squared
+					{
+						NPCInfo->goalEntity = NPC->enemy;
+						Jedi_Move( NPC->enemy, qfalse );
+						ucmd.buttons |= BUTTON_WALKING;
+					}
+					else
+					{//got there
+						if ( NPC->health < NPC->client->pers.maxHealth 
+							&& (NPC->client->ps.fd.forcePowersKnown&(1<<FP_HEAL)) != 0 
+							&& (NPC->client->ps.fd.forcePowersActive&(1<<FP_HEAL)) == 0 )
+						{
+							ForceHeal( NPC );
+						}
+					}
+					Jedi_FaceEnemy( qtrue );
+					NPC_UpdateAngles( qtrue, qtrue );
+					return;
+				}
+			}
+		}
+	}
+
+	//If we don't have an enemy, just idle
+	if ( NPC->enemy->s.weapon == WP_TURRET && !Q_stricmp( "PAS", NPC->enemy->classname ) )
+	{
+		if ( NPC->enemy->count <= 0 )
+		{//it's out of ammo
+			if ( NPC->enemy->activator && NPC_ValidEnemy( NPC->enemy->activator ) )
+			{
+				gentity_t *turretOwner = NPC->enemy->activator;
+				G_ClearEnemy( NPC );
+				G_SetEnemy( NPC, turretOwner );
+			}
+			else
+			{
+				G_ClearEnemy( NPC );
+			}
+		}
+	}
+	NPC_CheckEnemy( qtrue, qtrue, qtrue );
+
+	if ( !NPC->enemy )
+	{
+		NPC->client->ps.saberBlocked = BLOCKED_NONE;
+		if ( NPCInfo->tempBehavior == BS_HUNT_AND_KILL )
+		{//lost him, go back to what we were doing before
+			NPCInfo->tempBehavior = BS_DEFAULT;
+			NPC_UpdateAngles( qtrue, qtrue );
+			return;
+		}
+		Jedi_Patrol();//was calling Idle... why?
+		return;
+	}
+
+	//always face enemy if have one
+	NPCInfo->combatMove = qtrue;
+
+	//Track the player and kill them if possible
+	Jedi_Combat();
+
+	if ( !(NPCInfo->scriptFlags&SCF_CHASE_ENEMIES) 
+		|| ((NPC->client->ps.fd.forcePowersActive&(1<<FP_HEAL))&&NPC->client->ps.fd.forcePowerLevel[FP_HEAL]<FORCE_LEVEL_2))
+	{//this is really stupid, but okay...
+		ucmd.forwardmove = 0;
+		ucmd.rightmove = 0;
+		if ( ucmd.upmove > 0 )
+		{
+			ucmd.upmove = 0;
+		}
+		NPC->client->ps.fd.forceJumpCharge = 0;
+		VectorClear( NPC->client->ps.moveDir );
+	}
+
+	//NOTE: for now, we clear ucmd.forwardmove & ucmd.rightmove while in air to avoid jumps going awry...
+	if ( NPC->client->ps.groundEntityNum == ENTITYNUM_NONE )
+	{//don't push while in air, throws off jumps!
+		//FIXME: if we are in the air over a drop near a ledge, should we try to push back towards the ledge?
+		ucmd.forwardmove = 0;
+		ucmd.rightmove = 0;
+		VectorClear( NPC->client->ps.moveDir );
+	}
+
+	if ( !TIMER_Done( NPC, "duck" ) )
+	{
+		ucmd.upmove = -127;
+	}
+
+	if ( NPC->client->NPC_class != CLASS_BOBAFETT )
+	{
+		if ( PM_SaberInBrokenParry( NPC->client->ps.saberMove ) || NPC->client->ps.saberBlocked == BLOCKED_PARRY_BROKEN )
+		{//just make sure they don't pull their saber to them if they're being blocked
+			ucmd.buttons &= ~BUTTON_ATTACK;
+		}
+	}
+
+	if( (NPCInfo->scriptFlags&SCF_DONT_FIRE) //not allowed to attack
+		|| ((NPC->client->ps.fd.forcePowersActive&(1<<FP_HEAL))&&NPC->client->ps.fd.forcePowerLevel[FP_HEAL]<FORCE_LEVEL_3)
+		|| ((NPC->client->ps.saberEventFlags&SEF_INWATER)&&!NPC->client->ps.saberInFlight) )//saber in water
+	{
+		ucmd.buttons &= ~(BUTTON_ATTACK|BUTTON_ALT_ATTACK);
+	}
+
+	if ( NPCInfo->scriptFlags&SCF_NO_ACROBATICS )
+	{
+		ucmd.upmove = 0;
+		NPC->client->ps.fd.forceJumpCharge = 0;
+	}
+
+	if ( NPC->client->NPC_class != CLASS_BOBAFETT )
+	{
+		Jedi_CheckDecreaseSaberAnimLevel();
+	}
+
+	if ( ucmd.buttons & BUTTON_ATTACK && NPC->client->playerTeam == NPCTEAM_ENEMY )
+	{
+		if ( Q_irand( 0, NPC->client->ps.fd.saberAnimLevel ) > 0 
+			&& Q_irand( 0, NPC->client->pers.maxHealth+10 ) > NPC->health 
+			&& !Q_irand( 0, 3 ))
+		{//the more we're hurt and the stronger the attack we're using, the more likely we are to make a anger noise when we swing
+			G_AddVoiceEvent( NPC, Q_irand( EV_COMBAT1, EV_COMBAT3 ), 1000 );
+		}
+	}
+
+	if ( NPC->client->NPC_class != CLASS_BOBAFETT )
+	{
+		if ( NPC->client->NPC_class == CLASS_TAVION 
+			|| (g_spskill.integer && ( NPC->client->NPC_class == CLASS_DESANN || NPCInfo->rank >= Q_irand( RANK_CREWMAN, RANK_CAPTAIN ))))
+		{//Tavion will kick in force speed if the player does...
+			if ( NPC->enemy 
+				&& !NPC->enemy->s.number 
+				&& NPC->enemy->client 
+				&& (NPC->enemy->client->ps.fd.forcePowersActive & (1<<FP_SPEED)) 
+				&& !(NPC->client->ps.fd.forcePowersActive & (1<<FP_SPEED)) )
+			{
+				int chance = 0;
+				switch ( g_spskill.integer )
+				{
+				case 0:
+					chance = 9;
+				case 1:
+					chance = 3;
+				case 2:
+					chance = 1;
+					break;
+				}
+				if ( !Q_irand( 0, chance ) )
+				{
+					ForceSpeed( NPC, 0 );
+				}
+			}
+		}
+	}
+}
+
+extern void NPC_BSST_Patrol( void );
+extern void NPC_BSSniper_Default( void );
+void NPC_BSJedi_Default( void )
+{
+
+	Jedi_CheckCloak();
+	if( !NPC->enemy )
+	{//don't have an enemy, look for one
+		if ( NPC->client->NPC_class == CLASS_BOBAFETT )
+		{
+			NPC_BSST_Patrol();
+		}
+		else
+		{
+			Jedi_Patrol();
+		}
+	}
+	else//if ( NPC->enemy )
+	{//have an enemy
+		if ( Jedi_WaitingAmbush( NPC ) )
+		{//we were still waiting to drop down - must have had enemy set on me outside my AI
+			Jedi_Ambush( NPC );
+		}
+		if ( NPC->client->NPC_class == CLASS_BOBAFETT )
+		{
+			if ( NPC->enemy->enemy != NPC && NPC->health == NPC->client->pers.maxHealth && DistanceSquared( NPC->r.currentOrigin, NPC->enemy->r.currentOrigin )>(800*800) )
+			{
+				NPCInfo->scriptFlags |= SCF_ALT_FIRE;
+				Boba_ChangeWeapon( WP_DISRUPTOR );
+				NPC_BSSniper_Default();
+				return;
+			}
+		}
+		Jedi_Attack();
+		//if we have multiple-jedi combat, probably need to keep checking (at certain debounce intervals) for a better (closer, more active) enemy and switch if needbe...
+		if ( ((!ucmd.buttons&&!NPC->client->ps.fd.forcePowersActive)||(NPC->enemy&&NPC->enemy->health<=0)) && NPCInfo->enemyCheckDebounceTime < level.time )
+		{//not doing anything (or walking toward a vanquished enemy - fixme: always taunt the player?), not using force powers and it's time to look again
+			//FIXME: build a list of all local enemies (since we have to find best anyway) for other AI factors- like when to use group attacks, determine when to change tactics, when surrounded, when blocked by another in the enemy group, etc.  Should we build this group list or let the enemies maintain their own list and we just access it?
+			gentity_t *sav_enemy = NPC->enemy;//FIXME: what about NPC->lastEnemy?
+			gentity_t *newEnemy;
+
+			NPC->enemy = NULL;
+			newEnemy = NPC_CheckEnemy( NPCInfo->confusionTime < level.time, qfalse, qfalse );
+			NPC->enemy = sav_enemy;
+			if ( newEnemy && newEnemy != sav_enemy )
+			{//picked up a new enemy!
+				NPC->lastEnemy = NPC->enemy;
+				G_SetEnemy( NPC, newEnemy );
+			}
+			NPCInfo->enemyCheckDebounceTime = level.time + Q_irand( 1000, 3000 );
+		}
+	}
+}
diff --git a/codemp/game/NPC_AI_Mark1.c b/codemp/game/NPC_AI_Mark1.c
new file mode 100644
index 0000000..5336b24
--- /dev/null
+++ b/codemp/game/NPC_AI_Mark1.c
@@ -0,0 +1,764 @@
+#include "b_local.h"
+#include "g_nav.h"
+
+#define	MIN_MELEE_RANGE				320
+#define	MIN_MELEE_RANGE_SQR			( MIN_MELEE_RANGE * MIN_MELEE_RANGE )
+
+#define MIN_DISTANCE				128
+#define MIN_DISTANCE_SQR			( MIN_DISTANCE * MIN_DISTANCE )
+
+#define TURN_OFF					0x00000100
+
+#define LEFT_ARM_HEALTH				40
+#define RIGHT_ARM_HEALTH			40
+#define AMMO_POD_HEALTH				40
+
+#define	BOWCASTER_VELOCITY			1300
+#define	BOWCASTER_NPC_DAMAGE_EASY	12
+#define	BOWCASTER_NPC_DAMAGE_NORMAL	24
+#define	BOWCASTER_NPC_DAMAGE_HARD	36
+#define BOWCASTER_SIZE				2
+#define BOWCASTER_SPLASH_DAMAGE		0
+#define BOWCASTER_SPLASH_RADIUS		0
+
+//Local state enums
+enum
+{
+	LSTATE_NONE = 0,
+	LSTATE_ASLEEP,
+	LSTATE_WAKEUP,
+	LSTATE_FIRED0,
+	LSTATE_FIRED1,
+	LSTATE_FIRED2,
+	LSTATE_FIRED3,
+	LSTATE_FIRED4,
+};
+
+qboolean NPC_CheckPlayerTeamStealth( void );
+void Mark1_BlasterAttack(qboolean advance);
+void DeathFX( gentity_t *ent );
+
+#include "../namespace_begin.h"
+extern gitem_t *BG_FindItemForAmmo( ammo_t ammo );
+#include "../namespace_end.h"
+
+/*
+-------------------------
+NPC_Mark1_Precache
+-------------------------
+*/
+void NPC_Mark1_Precache(void)
+{
+	G_SoundIndex( "sound/chars/mark1/misc/mark1_wakeup");
+	G_SoundIndex( "sound/chars/mark1/misc/shutdown");
+	G_SoundIndex( "sound/chars/mark1/misc/walk");
+	G_SoundIndex( "sound/chars/mark1/misc/run");
+	G_SoundIndex( "sound/chars/mark1/misc/death1");
+	G_SoundIndex( "sound/chars/mark1/misc/death2");
+	G_SoundIndex( "sound/chars/mark1/misc/anger");
+	G_SoundIndex( "sound/chars/mark1/misc/mark1_fire");
+	G_SoundIndex( "sound/chars/mark1/misc/mark1_pain");
+	G_SoundIndex( "sound/chars/mark1/misc/mark1_explo");
+
+//	G_EffectIndex( "small_chunks");
+	G_EffectIndex( "env/med_explode2");
+	G_EffectIndex( "explosions/probeexplosion1");
+	G_EffectIndex( "blaster/smoke_bolton");
+	G_EffectIndex( "bryar/muzzle_flash");
+	G_EffectIndex( "explosions/droidexplosion1" );
+
+	RegisterItem( BG_FindItemForAmmo( 	AMMO_METAL_BOLTS));
+	RegisterItem( BG_FindItemForAmmo( AMMO_BLASTER ));
+	RegisterItem( BG_FindItemForWeapon( WP_BOWCASTER ));
+	RegisterItem( BG_FindItemForWeapon( WP_BRYAR_PISTOL ));
+}
+
+/*
+-------------------------
+NPC_Mark1_Part_Explode
+-------------------------
+*/
+void NPC_Mark1_Part_Explode( gentity_t *self, int bolt )
+{
+	if ( bolt >=0 )
+	{
+		mdxaBone_t	boltMatrix;
+		vec3_t		org, dir;
+
+		trap_G2API_GetBoltMatrix( self->ghoul2, 0, 
+					bolt,
+					&boltMatrix, self->r.currentAngles, self->r.currentOrigin, level.time,
+					NULL, self->modelScale );
+
+		BG_GiveMeVectorFromMatrix( &boltMatrix, ORIGIN, org );
+		BG_GiveMeVectorFromMatrix( &boltMatrix, NEGATIVE_Y, dir );
+
+		G_PlayEffectID( G_EffectIndex("env/med_explode2"), org, dir );
+
+		G_PlayEffectID( G_EffectIndex("blaster/smoke_bolton"), org, dir );
+	}
+
+	//G_PlayEffectID( G_EffectIndex("blaster/smoke_bolton"), self->playerModel, bolt, self->s.number );
+}
+
+/*
+-------------------------
+Mark1_Idle
+-------------------------
+*/
+void Mark1_Idle( void )
+{
+
+	NPC_BSIdle();
+
+	NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_SLEEP1, SETANIM_FLAG_NORMAL );
+}
+
+/*
+-------------------------
+Mark1Dead_FireRocket
+- Shoot the left weapon, the multi-blaster
+-------------------------
+*/
+void Mark1Dead_FireRocket (void)
+{
+	mdxaBone_t	boltMatrix;
+	vec3_t	muzzle1,muzzle_dir;
+	gentity_t *missile;
+
+	int	damage	= 50;
+	int bolt = trap_G2API_AddBolt(NPC->ghoul2, 0, "*flash5");
+
+	trap_G2API_GetBoltMatrix( NPC->ghoul2, 0, 
+				bolt,
+				&boltMatrix, NPC->r.currentAngles, NPC->r.currentOrigin, level.time,
+				NULL, NPC->modelScale );
+
+	BG_GiveMeVectorFromMatrix( &boltMatrix, ORIGIN, muzzle1 );
+	BG_GiveMeVectorFromMatrix( &boltMatrix, NEGATIVE_Y, muzzle_dir );
+
+	G_PlayEffectID( G_EffectIndex("bryar/muzzle_flash"), muzzle1, muzzle_dir );
+
+	G_Sound( NPC, CHAN_AUTO, G_SoundIndex("sound/chars/mark1/misc/mark1_fire"));
+
+	missile = CreateMissile( muzzle1, muzzle_dir, BOWCASTER_VELOCITY, 10000, NPC, qfalse );
+
+	missile->classname = "bowcaster_proj";
+	missile->s.weapon = WP_BOWCASTER;
+
+	VectorSet( missile->r.maxs, BOWCASTER_SIZE, BOWCASTER_SIZE, BOWCASTER_SIZE );
+	VectorScale( missile->r.maxs, -1, missile->r.mins );
+
+	missile->damage = damage;
+	missile->dflags = DAMAGE_DEATH_KNOCKBACK;
+	//missile->methodOfDeath = MOD_ENERGY;
+	missile->methodOfDeath = MOD_ROCKET;
+	missile->clipmask = MASK_SHOT | CONTENTS_LIGHTSABER;
+	missile->splashDamage = BOWCASTER_SPLASH_DAMAGE;
+	missile->splashRadius = BOWCASTER_SPLASH_RADIUS;
+
+	// we don't want it to bounce
+	missile->bounceCount = 0;
+
+}
+
+/*
+-------------------------
+Mark1Dead_FireBlaster
+- Shoot the left weapon, the multi-blaster
+-------------------------
+*/
+void Mark1Dead_FireBlaster (void)
+{
+	vec3_t	muzzle1,muzzle_dir;
+	gentity_t	*missile;
+	mdxaBone_t	boltMatrix;
+	int			bolt;
+
+	bolt = trap_G2API_AddBolt(NPC->ghoul2, 0, "*flash1"); 
+
+	trap_G2API_GetBoltMatrix( NPC->ghoul2, 0, 
+				bolt,
+				&boltMatrix, NPC->r.currentAngles, NPC->r.currentOrigin, level.time,
+				NULL, NPC->modelScale );
+
+	BG_GiveMeVectorFromMatrix( &boltMatrix, ORIGIN, muzzle1 );
+	BG_GiveMeVectorFromMatrix( &boltMatrix, NEGATIVE_Y, muzzle_dir );
+
+	G_PlayEffectID( G_EffectIndex("bryar/muzzle_flash"), muzzle1, muzzle_dir );
+
+	missile = CreateMissile( muzzle1, muzzle_dir, 1600, 10000, NPC, qfalse );
+
+	G_Sound( NPC, CHAN_AUTO, G_SoundIndex("sound/chars/mark1/misc/mark1_fire"));
+
+	missile->classname = "bryar_proj";
+	missile->s.weapon = WP_BRYAR_PISTOL;
+
+	missile->damage = 1;
+	missile->dflags = DAMAGE_DEATH_KNOCKBACK;
+	missile->methodOfDeath = MOD_BRYAR_PISTOL;
+	missile->clipmask = MASK_SHOT | CONTENTS_LIGHTSABER;
+
+}
+
+/*
+-------------------------
+Mark1_die
+-------------------------
+*/
+void Mark1_die( gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int mod,int dFlags,int hitLoc )
+{
+	/*
+	int	anim;
+
+	// Is he dead already?
+	anim = self->client->ps.legsAnim;
+	if (((anim==BOTH_DEATH1) || (anim==BOTH_DEATH2)) && (self->client->ps.torsoTimer<=0)) 
+	{	// This is because self->health keeps getting zeroed out. HL_NONE acts as health in this case.
+		self->locationDamage[HL_NONE] += damage;
+		if (self->locationDamage[HL_NONE] > 50)
+		{
+			DeathFX(self);
+			self->client->ps.eFlags |= EF_NODRAW;
+			self->contents = CONTENTS_CORPSE;
+			// G_FreeEntity( self ); // Is this safe?  I can't see why we'd mark it nodraw and then just leave it around??
+			self->e_ThinkFunc = thinkF_G_FreeEntity;
+			self->nextthink = level.time + FRAMETIME;
+		}
+		return;
+	}
+	*/
+
+	G_Sound( self, CHAN_AUTO, G_SoundIndex(va("sound/chars/mark1/misc/death%d.wav",Q_irand( 1, 2))));
+
+	// Choose a death anim
+	if (Q_irand( 1, 10) > 5)
+	{
+		NPC_SetAnim( self, SETANIM_BOTH, BOTH_DEATH2, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+	}
+	else
+	{
+		NPC_SetAnim( self, SETANIM_BOTH, BOTH_DEATH1, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+	}
+}
+
+/*
+-------------------------
+Mark1_dying
+-------------------------
+*/
+void Mark1_dying( gentity_t *self )
+{
+	int	num,newBolt;
+
+	if (self->client->ps.torsoTimer>0)
+	{
+		if (TIMER_Done(self,"dyingExplosion"))
+		{
+			num = Q_irand( 1, 3);
+
+			// Find place to generate explosion
+			if (num == 1)
+			{
+				num = Q_irand( 8, 10);
+				newBolt = trap_G2API_AddBolt( self->ghoul2, 0, va("*flash%d",num) );
+				NPC_Mark1_Part_Explode(self,newBolt);
+			}
+			else
+			{
+				num = Q_irand( 1, 6);
+				newBolt = trap_G2API_AddBolt( self->ghoul2, 0, va("*torso_tube%d",num) );
+				NPC_Mark1_Part_Explode(self,newBolt);
+				NPC_SetSurfaceOnOff( self, va("torso_tube%d",num), TURN_OFF );
+			}
+
+			TIMER_Set( self, "dyingExplosion", Q_irand( 300, 1000 ) );
+		}
+
+
+//		int		dir;
+//		vec3_t	right;
+
+		// Shove to the side
+//		AngleVectors( self->client->renderInfo.eyeAngles, NULL, right, NULL );
+//		VectorMA( self->client->ps.velocity, -80, right, self->client->ps.velocity );
+
+		// See which weapons are there
+		// Randomly fire blaster
+		if (!trap_G2API_GetSurfaceRenderStatus( self->ghoul2, 0, "l_arm" ))	// Is the blaster still on the model?
+		{
+			if (Q_irand( 1, 5) == 1)
+			{
+				SaveNPCGlobals();
+				SetNPCGlobals( self );
+				Mark1Dead_FireBlaster();
+				RestoreNPCGlobals();
+			}
+		}
+
+		// Randomly fire rocket
+		if (!trap_G2API_GetSurfaceRenderStatus( self->ghoul2, 0, "r_arm" ))	// Is the rocket still on the model?
+		{
+			if (Q_irand( 1, 10) == 1)
+			{
+				SaveNPCGlobals();
+				SetNPCGlobals( self );
+				Mark1Dead_FireRocket();
+				RestoreNPCGlobals();
+			}
+		}
+	}
+
+}
+
+/*
+-------------------------
+NPC_Mark1_Pain
+- look at what was hit and see if it should be removed from the model.
+-------------------------
+*/
+void NPC_Mark1_Pain(gentity_t *self, gentity_t *attacker, int damage)
+{
+	int newBolt,i,chance;
+	int hitLoc = gPainHitLoc;
+	
+	NPC_Pain( self, attacker, damage );
+
+	G_Sound( self, CHAN_AUTO, G_SoundIndex("sound/chars/mark1/misc/mark1_pain"));
+
+	// Hit in the CHEST???
+	if (hitLoc==HL_CHEST)
+	{
+		chance = Q_irand( 1, 4);
+	
+		if ((chance == 1) && (damage > 5))
+		{
+			NPC_SetAnim( self, SETANIM_BOTH, BOTH_PAIN1, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+		}
+	}
+	// Hit in the left arm?
+	else if ((hitLoc==HL_ARM_LT) && (self->locationDamage[HL_ARM_LT] > LEFT_ARM_HEALTH))
+	{
+		if (self->locationDamage[hitLoc] >= LEFT_ARM_HEALTH)	// Blow it up?
+		{
+			newBolt = trap_G2API_AddBolt( self->ghoul2, 0, "*flash3" );
+			if ( newBolt != -1 )
+			{
+				NPC_Mark1_Part_Explode(self,newBolt);
+			}
+
+			NPC_SetSurfaceOnOff( self, "l_arm", TURN_OFF );
+		}
+	}
+	// Hit in the right arm?
+	else if ((hitLoc==HL_ARM_RT) && (self->locationDamage[HL_ARM_RT] > RIGHT_ARM_HEALTH))	// Blow it up?
+	{
+		if (self->locationDamage[hitLoc] >= RIGHT_ARM_HEALTH)
+		{			
+			newBolt = trap_G2API_AddBolt( self->ghoul2, 0, "*flash4" );
+			if ( newBolt != -1 )
+			{
+//				G_PlayEffect( "small_chunks", self->playerModel, self->genericBolt2, self->s.number);
+				NPC_Mark1_Part_Explode( self, newBolt );
+			}
+
+			NPC_SetSurfaceOnOff( self, "r_arm", TURN_OFF );
+		}
+	}
+	// Check ammo pods
+	else
+	{
+		for (i=0;i<6;i++)
+		{
+			if ((hitLoc==HL_GENERIC1+i) && (self->locationDamage[HL_GENERIC1+i] > AMMO_POD_HEALTH))	// Blow it up?
+			{
+				if (self->locationDamage[hitLoc] >= AMMO_POD_HEALTH)
+				{			
+					newBolt = trap_G2API_AddBolt( self->ghoul2, 0, va("*torso_tube%d",(i+1)) );
+					if ( newBolt != -1 )
+					{
+						NPC_Mark1_Part_Explode(self,newBolt);
+					}
+					NPC_SetSurfaceOnOff( self, va("torso_tube%d",(i+1)), TURN_OFF );
+					NPC_SetAnim( self, SETANIM_BOTH, BOTH_PAIN1, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+					break;
+				}
+			}
+		}
+	}
+
+	// Are both guns shot off?
+	if ((trap_G2API_GetSurfaceRenderStatus( self->ghoul2, 0, "l_arm" )>0) &&
+		(trap_G2API_GetSurfaceRenderStatus( self->ghoul2, 0, "r_arm" )>0))
+	{
+		G_Damage(self,NULL,NULL,NULL,NULL,self->health,0,MOD_UNKNOWN);
+	}
+}
+
+/*
+-------------------------
+Mark1_Hunt
+- look for enemy.
+-------------------------`
+*/
+void Mark1_Hunt(void)
+{
+
+	if ( NPCInfo->goalEntity == NULL )
+	{
+		NPCInfo->goalEntity = NPC->enemy;
+	}
+
+	NPC_FaceEnemy( qtrue );
+
+	NPCInfo->combatMove = qtrue;
+	NPC_MoveToGoal( qtrue );
+}
+
+/*
+-------------------------
+Mark1_FireBlaster
+- Shoot the left weapon, the multi-blaster
+-------------------------
+*/
+void Mark1_FireBlaster(void)
+{
+	vec3_t	muzzle1,enemy_org1,delta1,angleToEnemy1;
+	static	vec3_t	forward, vright, up;
+	static	vec3_t	muzzle;
+	gentity_t	*missile;
+	mdxaBone_t	boltMatrix;
+	int			bolt;
+
+	// Which muzzle to fire from?
+	if ((NPCInfo->localState <= LSTATE_FIRED0) || (NPCInfo->localState == LSTATE_FIRED4)) 
+	{
+		NPCInfo->localState = LSTATE_FIRED1;
+		bolt = trap_G2API_AddBolt(NPC->ghoul2, 0, "*flash1"); 
+	}
+	else if (NPCInfo->localState == LSTATE_FIRED1)
+	{
+		NPCInfo->localState = LSTATE_FIRED2;
+		bolt = trap_G2API_AddBolt(NPC->ghoul2, 0, "*flash2"); 
+	}
+	else if (NPCInfo->localState == LSTATE_FIRED2)
+	{
+		NPCInfo->localState = LSTATE_FIRED3;
+		bolt = trap_G2API_AddBolt(NPC->ghoul2, 0, "*flash3"); 
+	}
+	else
+	{
+		NPCInfo->localState = LSTATE_FIRED4;
+		bolt = trap_G2API_AddBolt(NPC->ghoul2, 0, "*flash4"); 
+	}
+
+	trap_G2API_GetBoltMatrix( NPC->ghoul2, 0, 
+				bolt,
+				&boltMatrix, NPC->r.currentAngles, NPC->r.currentOrigin, level.time,
+				NULL, NPC->modelScale );
+
+	BG_GiveMeVectorFromMatrix( &boltMatrix, ORIGIN, muzzle1 );
+
+	if (NPC->health)
+	{
+		CalcEntitySpot( NPC->enemy, SPOT_HEAD, enemy_org1 );
+		VectorSubtract (enemy_org1, muzzle1, delta1);
+		vectoangles ( delta1, angleToEnemy1 );
+		AngleVectors (angleToEnemy1, forward, vright, up);
+	}
+	else
+	{
+		AngleVectors (NPC->r.currentAngles, forward, vright, up);
+	}
+
+	G_PlayEffectID( G_EffectIndex("bryar/muzzle_flash"), muzzle1, forward );
+
+	G_Sound( NPC, CHAN_AUTO, G_SoundIndex("sound/chars/mark1/misc/mark1_fire"));
+
+	missile = CreateMissile( muzzle1, forward, 1600, 10000, NPC, qfalse );
+
+	missile->classname = "bryar_proj";
+	missile->s.weapon = WP_BRYAR_PISTOL;
+
+	missile->damage = 1;
+	missile->dflags = DAMAGE_DEATH_KNOCKBACK;
+	missile->methodOfDeath = MOD_BRYAR_PISTOL;
+	missile->clipmask = MASK_SHOT | CONTENTS_LIGHTSABER;
+
+}
+
+/*
+-------------------------
+Mark1_BlasterAttack
+-------------------------
+*/
+void Mark1_BlasterAttack(qboolean advance )
+{
+	int chance;
+
+	if ( TIMER_Done( NPC, "attackDelay" ) )	// Attack?
+	{
+		chance = Q_irand( 1, 5);
+	
+		NPCInfo->burstCount++;
+
+		if (NPCInfo->burstCount<3)	// Too few shots this burst?
+		{
+			chance = 2;				// Force it to keep firing.
+		}
+		else if (NPCInfo->burstCount>12)	// Too many shots fired this burst?
+		{
+			NPCInfo->burstCount = 0;
+			chance = 1;				// Force it to stop firing.
+		}
+
+		// Stop firing.
+		if (chance == 1)
+		{
+			NPCInfo->burstCount = 0;
+			TIMER_Set( NPC, "attackDelay", Q_irand( 1000, 3000) );
+			NPC->client->ps.torsoTimer=0;						// Just in case the firing anim is running.
+		}
+		else
+		{
+			if (TIMER_Done( NPC, "attackDelay2" ))	// Can't be shooting every frame.
+			{
+				TIMER_Set( NPC, "attackDelay2", Q_irand( 50, 50) );
+				Mark1_FireBlaster();
+ 				NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_ATTACK1, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+			}
+			return;
+		}
+	}
+	else if (advance)
+	{
+		if ( NPC->client->ps.torsoAnim == BOTH_ATTACK1 )
+		{
+			NPC->client->ps.torsoTimer=0;						// Just in case the firing anim is running.
+		}
+		Mark1_Hunt();
+	}
+	else	// Make sure he's not firing.
+	{
+		if ( NPC->client->ps.torsoAnim == BOTH_ATTACK1 )
+		{
+			NPC->client->ps.torsoTimer=0;						// Just in case the firing anim is running.
+		}
+	}
+}
+
+/*
+-------------------------
+Mark1_FireRocket
+-------------------------
+*/
+void Mark1_FireRocket(void)
+{
+	mdxaBone_t	boltMatrix;
+	vec3_t	muzzle1,enemy_org1,delta1,angleToEnemy1;
+	static	vec3_t	forward, vright, up;
+	int bolt = trap_G2API_AddBolt(NPC->ghoul2, 0, "*flash5");
+	gentity_t *missile;
+
+	int	damage	= 50;
+
+	trap_G2API_GetBoltMatrix( NPC->ghoul2, 0, 
+				bolt,
+				&boltMatrix, NPC->r.currentAngles, NPC->r.currentOrigin, level.time,
+				NULL, NPC->modelScale );
+
+	BG_GiveMeVectorFromMatrix( &boltMatrix, ORIGIN, muzzle1 );
+
+//	G_PlayEffect( "blaster/muzzle_flash", muzzle1 );
+
+	CalcEntitySpot( NPC->enemy, SPOT_HEAD, enemy_org1 );
+	VectorSubtract (enemy_org1, muzzle1, delta1);
+	vectoangles ( delta1, angleToEnemy1 );
+	AngleVectors (angleToEnemy1, forward, vright, up);
+
+	G_Sound( NPC, CHAN_AUTO, G_SoundIndex("sound/chars/mark1/misc/mark1_fire" ));
+
+	missile = CreateMissile( muzzle1, forward, BOWCASTER_VELOCITY, 10000, NPC, qfalse );
+
+	missile->classname = "bowcaster_proj";
+	missile->s.weapon = WP_BOWCASTER;
+
+	VectorSet( missile->r.maxs, BOWCASTER_SIZE, BOWCASTER_SIZE, BOWCASTER_SIZE );
+	VectorScale( missile->r.maxs, -1, missile->r.mins );
+
+	missile->damage = damage;
+	missile->dflags = DAMAGE_DEATH_KNOCKBACK;
+	missile->methodOfDeath = MOD_ROCKET;
+	missile->clipmask = MASK_SHOT | CONTENTS_LIGHTSABER;
+	missile->splashDamage = BOWCASTER_SPLASH_DAMAGE;
+	missile->splashRadius = BOWCASTER_SPLASH_RADIUS;
+
+	// we don't want it to bounce
+	missile->bounceCount = 0;
+
+}
+
+/*
+-------------------------
+Mark1_RocketAttack
+-------------------------
+*/
+void Mark1_RocketAttack( qboolean advance )
+{
+	if ( TIMER_Done( NPC, "attackDelay" ) )	// Attack?
+	{
+		TIMER_Set( NPC, "attackDelay", Q_irand( 1000, 3000) );
+ 		NPC_SetAnim( NPC, SETANIM_TORSO, BOTH_ATTACK2, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+		Mark1_FireRocket();
+	}
+	else if (advance)
+	{
+		Mark1_Hunt();
+	}
+}
+
+/*
+-------------------------
+Mark1_AttackDecision
+-------------------------
+*/
+void Mark1_AttackDecision( void )
+{
+	int blasterTest,rocketTest;
+	float		distance;
+	distance_e	distRate;
+	qboolean	visible;
+	qboolean	advance;
+
+	//randomly talk
+	if ( TIMER_Done(NPC,"patrolNoise") )
+	{
+		if (TIMER_Done(NPC,"angerNoise"))
+		{
+//			G_Sound( NPC, G_SoundIndex(va("sound/chars/mark1/misc/talk%d.wav",	Q_irand(1, 4))));
+			TIMER_Set( NPC, "patrolNoise", Q_irand( 4000, 10000 ) );
+		}
+	}
+
+	// Enemy is dead or he has no enemy.
+	if ((NPC->enemy->health<1) || ( NPC_CheckEnemyExt(qfalse) == qfalse ))
+	{
+		NPC->enemy = NULL;
+		return;
+	}
+
+	// Rate our distance to the target and visibility
+	distance	= (int) DistanceHorizontalSquared( NPC->r.currentOrigin, NPC->enemy->r.currentOrigin );	
+	distRate	= ( distance > MIN_MELEE_RANGE_SQR ) ? DIST_LONG : DIST_MELEE;
+	visible		= NPC_ClearLOS4( NPC->enemy );
+	advance		= (qboolean)(distance > MIN_DISTANCE_SQR);
+
+	// If we cannot see our target, move to see it
+	if ((!visible) || (!NPC_FaceEnemy(qtrue)))
+	{
+		Mark1_Hunt();
+		return;
+	}
+
+	// See if the side weapons are there
+	blasterTest = trap_G2API_GetSurfaceRenderStatus( NPC->ghoul2, 0, "l_arm" );
+	rocketTest = trap_G2API_GetSurfaceRenderStatus( NPC->ghoul2, 0, "r_arm" );
+
+	// It has both side weapons
+	if (!blasterTest  && !rocketTest)
+	{
+		;	// So do nothing.
+	}
+	else if (blasterTest!=-1
+		&&blasterTest)
+	{
+		distRate = DIST_LONG;
+	}
+	else if (rocketTest!=-1
+		&&rocketTest)
+	{
+		distRate = DIST_MELEE;
+	}
+	else	// It should never get here, but just in case
+	{ 
+		NPC->health = 0;
+		NPC->client->ps.stats[STAT_HEALTH] = 0;
+		//GEntity_DieFunc(NPC, NPC, NPC, 100, MOD_UNKNOWN);
+		if (NPC->die)
+		{
+			NPC->die(NPC, NPC, NPC, 100, MOD_UNKNOWN);
+		}
+	}
+
+	// We can see enemy so shoot him if timers let you.
+	NPC_FaceEnemy( qtrue );
+
+	if (distRate == DIST_MELEE)
+	{
+		Mark1_BlasterAttack(advance);
+	}
+	else if (distRate == DIST_LONG)
+	{
+		Mark1_RocketAttack(advance);
+	}
+}
+
+/*
+-------------------------
+Mark1_Patrol
+-------------------------
+*/
+void Mark1_Patrol( void )
+{
+	if ( NPC_CheckPlayerTeamStealth() )
+	{
+		G_Sound( NPC, CHAN_AUTO, G_SoundIndex("sound/chars/mark1/misc/mark1_wakeup"));
+		NPC_UpdateAngles( qtrue, qtrue );
+		return;
+	}
+
+	//If we have somewhere to go, then do that
+	if (!NPC->enemy)
+	{
+		if ( UpdateGoal() )
+		{
+			ucmd.buttons |= BUTTON_WALKING;
+			NPC_MoveToGoal( qtrue );
+			NPC_UpdateAngles( qtrue, qtrue );
+		}
+
+		//randomly talk
+//		if (TIMER_Done(NPC,"patrolNoise"))
+//		{
+//			G_Sound( NPC, G_SoundIndex(va("sound/chars/mark1/misc/talk%d.wav",	Q_irand(1, 4))));
+//
+//			TIMER_Set( NPC, "patrolNoise", Q_irand( 2000, 4000 ) );
+//		}
+	}
+
+}
+
+
+/*
+-------------------------
+NPC_BSMark1_Default
+-------------------------
+*/
+void NPC_BSMark1_Default( void )
+{
+	//NPC->e_DieFunc = dieF_Mark1_die;
+
+	if ( NPC->enemy )
+	{
+		NPCInfo->goalEntity = NPC->enemy;
+		Mark1_AttackDecision();
+	}
+	else if ( NPCInfo->scriptFlags & SCF_LOOK_FOR_ENEMIES )
+	{
+		Mark1_Patrol();
+	}
+	else
+	{
+		Mark1_Idle();
+	}
+}
diff --git a/codemp/game/NPC_AI_Mark2.c b/codemp/game/NPC_AI_Mark2.c
new file mode 100644
index 0000000..bf6773c
--- /dev/null
+++ b/codemp/game/NPC_AI_Mark2.c
@@ -0,0 +1,362 @@
+#include "b_local.h"
+#include "g_nav.h"
+
+//#define AMMO_POD_HEALTH				40
+#define AMMO_POD_HEALTH				1
+#define TURN_OFF					0x00000100
+
+#define VELOCITY_DECAY		0.25
+#define MAX_DISTANCE		256
+#define MAX_DISTANCE_SQR	( MAX_DISTANCE * MAX_DISTANCE )
+#define MIN_DISTANCE		24
+#define MIN_DISTANCE_SQR	( MIN_DISTANCE * MIN_DISTANCE )
+
+#include "../namespace_begin.h"
+extern gitem_t	*BG_FindItemForAmmo( ammo_t ammo );
+#include "../namespace_end.h"
+
+//Local state enums
+enum
+{
+	LSTATE_NONE = 0,
+	LSTATE_DROPPINGDOWN,
+	LSTATE_DOWN,
+	LSTATE_RISINGUP,
+};
+
+void NPC_Mark2_Precache( void )
+{
+	G_SoundIndex( "sound/chars/mark2/misc/mark2_explo" );// blows up on death
+	G_SoundIndex( "sound/chars/mark2/misc/mark2_pain" );
+	G_SoundIndex( "sound/chars/mark2/misc/mark2_fire" );
+	G_SoundIndex( "sound/chars/mark2/misc/mark2_move_lp" );
+
+	G_EffectIndex( "explosions/droidexplosion1" );
+	G_EffectIndex( "env/med_explode2" );
+	G_EffectIndex( "blaster/smoke_bolton" );
+	G_EffectIndex( "bryar/muzzle_flash" );
+
+	RegisterItem( BG_FindItemForWeapon( WP_BRYAR_PISTOL ));
+	RegisterItem( BG_FindItemForAmmo( 	AMMO_METAL_BOLTS));
+	RegisterItem( BG_FindItemForAmmo( AMMO_POWERCELL ));
+	RegisterItem( BG_FindItemForAmmo( AMMO_BLASTER ));
+}
+
+/*
+-------------------------
+NPC_Mark2_Part_Explode
+-------------------------
+*/
+void NPC_Mark2_Part_Explode( gentity_t *self, int bolt )
+{
+	if ( bolt >=0 )
+	{
+		mdxaBone_t	boltMatrix;
+		vec3_t		org, dir;
+
+		trap_G2API_GetBoltMatrix( self->ghoul2, 0, 
+					bolt,
+					&boltMatrix, self->r.currentAngles, self->r.currentOrigin, level.time,
+					NULL, self->modelScale );
+
+		BG_GiveMeVectorFromMatrix( &boltMatrix, ORIGIN, org );
+		BG_GiveMeVectorFromMatrix( &boltMatrix, NEGATIVE_Y, dir );
+
+		G_PlayEffectID( G_EffectIndex("env/med_explode2"), org, dir );
+		G_PlayEffectID( G_EffectIndex("blaster/smoke_bolton"), org, dir );
+	}
+
+	//G_PlayEffectID( G_EffectIndex("blaster/smoke_bolton"), self->playerModel, bolt, self->s.number);
+
+	self->count++;	// Count of pods blown off
+}
+
+/*
+-------------------------
+NPC_Mark2_Pain
+- look at what was hit and see if it should be removed from the model.
+-------------------------
+*/
+void NPC_Mark2_Pain(gentity_t *self, gentity_t *attacker, int damage)
+{
+	int newBolt,i;
+	int hitLoc = gPainHitLoc;
+	
+	NPC_Pain( self, attacker, damage );
+
+	for (i=0;i<3;i++)
+	{
+		if ((hitLoc==HL_GENERIC1+i) && (self->locationDamage[HL_GENERIC1+i] > AMMO_POD_HEALTH))	// Blow it up?
+		{
+			if (self->locationDamage[hitLoc] >= AMMO_POD_HEALTH)
+			{			
+				newBolt = trap_G2API_AddBolt( self->ghoul2, 0, va("torso_canister%d",(i+1)) );
+				if ( newBolt != -1 )
+				{
+					NPC_Mark2_Part_Explode(self,newBolt);
+				}
+				NPC_SetSurfaceOnOff( self, va("torso_canister%d",(i+1)), TURN_OFF );
+				break;
+			}
+		}
+	}
+
+	G_Sound( self, CHAN_AUTO, G_SoundIndex( "sound/chars/mark2/misc/mark2_pain" ));
+
+	// If any pods were blown off, kill him
+	if (self->count > 0)
+	{
+		G_Damage( self, NULL, NULL, NULL, NULL, self->health, DAMAGE_NO_PROTECTION, MOD_UNKNOWN );
+	}
+}
+
+/*
+-------------------------
+Mark2_Hunt
+-------------------------
+*/
+void Mark2_Hunt(void)
+{
+	if ( NPCInfo->goalEntity == NULL )
+	{
+		NPCInfo->goalEntity = NPC->enemy;
+	}
+
+	// Turn toward him before moving towards him.
+	NPC_FaceEnemy( qtrue );
+
+	NPCInfo->combatMove = qtrue;
+	NPC_MoveToGoal( qtrue );
+}
+
+/*
+-------------------------
+Mark2_FireBlaster
+-------------------------
+*/
+void Mark2_FireBlaster(qboolean advance)
+{
+	vec3_t	muzzle1,enemy_org1,delta1,angleToEnemy1;
+	static	vec3_t	forward, vright, up;
+	static	vec3_t	muzzle;
+	gentity_t	*missile;
+	mdxaBone_t	boltMatrix;
+	int bolt = trap_G2API_AddBolt(NPC->ghoul2, 0, "*flash");
+
+	trap_G2API_GetBoltMatrix( NPC->ghoul2, 0, 
+				bolt,
+				&boltMatrix, NPC->r.currentAngles, NPC->r.currentOrigin, level.time,
+				NULL, NPC->modelScale );
+
+	BG_GiveMeVectorFromMatrix( &boltMatrix, ORIGIN, muzzle1 );
+
+	if (NPC->health)
+	{
+		CalcEntitySpot( NPC->enemy, SPOT_HEAD, enemy_org1 );
+		VectorSubtract (enemy_org1, muzzle1, delta1);
+		vectoangles ( delta1, angleToEnemy1 );
+		AngleVectors (angleToEnemy1, forward, vright, up);
+	}
+	else
+	{
+		AngleVectors (NPC->r.currentAngles, forward, vright, up);
+	}
+
+	G_PlayEffectID( G_EffectIndex("bryar/muzzle_flash"), muzzle1, forward );
+
+	G_Sound( NPC, CHAN_AUTO, G_SoundIndex("sound/chars/mark2/misc/mark2_fire"));
+
+	missile = CreateMissile( muzzle1, forward, 1600, 10000, NPC, qfalse );
+
+	missile->classname = "bryar_proj";
+	missile->s.weapon = WP_BRYAR_PISTOL;
+
+	missile->damage = 1;
+	missile->dflags = DAMAGE_DEATH_KNOCKBACK;
+	missile->methodOfDeath = MOD_BRYAR_PISTOL;
+	missile->clipmask = MASK_SHOT | CONTENTS_LIGHTSABER;
+
+}
+
+/*
+-------------------------
+Mark2_BlasterAttack
+-------------------------
+*/
+void Mark2_BlasterAttack(qboolean advance)
+{
+	if ( TIMER_Done( NPC, "attackDelay" ) )	// Attack?
+	{
+		if (NPCInfo->localState == LSTATE_NONE)	// He's up so shoot less often.
+		{
+			TIMER_Set( NPC, "attackDelay", Q_irand( 500, 2000) );
+		}
+		else
+		{
+			TIMER_Set( NPC, "attackDelay", Q_irand( 100, 500) );
+		}
+		Mark2_FireBlaster(advance);
+		return;
+	}
+	else if (advance)
+	{
+		Mark2_Hunt();
+	}
+}
+
+/*
+-------------------------
+Mark2_AttackDecision
+-------------------------
+*/
+void Mark2_AttackDecision( void )
+{
+	float		distance;
+	qboolean	visible;
+	qboolean	advance;
+
+	NPC_FaceEnemy( qtrue );
+
+	distance	= (int) DistanceHorizontalSquared( NPC->r.currentOrigin, NPC->enemy->r.currentOrigin );	
+	visible		= NPC_ClearLOS4( NPC->enemy );
+	advance		= (qboolean)(distance > MIN_DISTANCE_SQR);
+
+	// He's been ordered to get up
+	if (NPCInfo->localState == LSTATE_RISINGUP)
+	{
+		NPC->flags &= ~FL_SHIELDED;
+		NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_RUN1START, SETANIM_FLAG_HOLD|SETANIM_FLAG_OVERRIDE );
+		if ((NPC->client->ps.legsTimer<=0) && 
+			NPC->client->ps.torsoAnim == BOTH_RUN1START )
+		{
+			NPCInfo->localState = LSTATE_NONE;	// He's up again.
+		}
+		return;
+	}
+
+	// If we cannot see our target, move to see it
+	if ((!visible) || (!NPC_FaceEnemy(qtrue)))
+	{
+		// If he's going down or is down, make him get up
+		if ((NPCInfo->localState == LSTATE_DOWN) || (NPCInfo->localState == LSTATE_DROPPINGDOWN))
+		{
+			if ( TIMER_Done( NPC, "downTime" ) )	// Down being down?? (The delay is so he doesn't pop up and down when the player goes in and out of range)
+			{
+				NPCInfo->localState = LSTATE_RISINGUP;
+				NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_RUN1STOP, SETANIM_FLAG_HOLD|SETANIM_FLAG_OVERRIDE );
+				TIMER_Set( NPC, "runTime", Q_irand( 3000, 8000) );	// So he runs for a while before testing to see if he should drop down.
+			}
+		}
+		else
+		{
+			Mark2_Hunt();
+		}
+		return;
+	}
+
+	// He's down but he could advance if he wants to.
+	if ((advance) && (TIMER_Done( NPC, "downTime" )) && (NPCInfo->localState == LSTATE_DOWN))
+	{
+		NPCInfo->localState = LSTATE_RISINGUP;
+		NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_RUN1STOP, SETANIM_FLAG_HOLD|SETANIM_FLAG_OVERRIDE );
+		TIMER_Set( NPC, "runTime", Q_irand( 3000, 8000) );	// So he runs for a while before testing to see if he should drop down.
+	}
+
+	NPC_FaceEnemy( qtrue );
+
+	// Dropping down to shoot
+	if (NPCInfo->localState == LSTATE_DROPPINGDOWN)
+	{
+		NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_RUN1STOP, SETANIM_FLAG_HOLD|SETANIM_FLAG_OVERRIDE );
+		TIMER_Set( NPC, "downTime", Q_irand( 3000, 9000) );
+
+		if ((NPC->client->ps.legsTimer<=0) && NPC->client->ps.torsoAnim == BOTH_RUN1STOP )
+		{
+			NPC->flags |= FL_SHIELDED;
+			NPCInfo->localState = LSTATE_DOWN;
+		}
+	}
+	// He's down and shooting
+	else if (NPCInfo->localState == LSTATE_DOWN)
+	{
+		NPC->flags |= FL_SHIELDED;//only damagable by lightsabers and missiles
+
+		Mark2_BlasterAttack(qfalse);
+	}
+	else if (TIMER_Done( NPC, "runTime" ))	// Lowering down to attack. But only if he's done running at you.
+	{
+		NPCInfo->localState = LSTATE_DROPPINGDOWN;
+	}
+	else if (advance)
+	{
+		// We can see enemy so shoot him if timer lets you.
+		Mark2_BlasterAttack(advance);
+	}
+}
+
+
+/*
+-------------------------
+Mark2_Patrol
+-------------------------
+*/
+void Mark2_Patrol( void )
+{
+	if ( NPC_CheckPlayerTeamStealth() )
+	{
+//		G_Sound( NPC, G_SoundIndex("sound/chars/mark1/misc/anger.wav"));
+		NPC_UpdateAngles( qtrue, qtrue );
+		return;
+	}
+
+	//If we have somewhere to go, then do that
+	if (!NPC->enemy)
+	{
+		if ( UpdateGoal() )
+		{
+			ucmd.buttons |= BUTTON_WALKING;
+			NPC_MoveToGoal( qtrue );
+			NPC_UpdateAngles( qtrue, qtrue );
+		}
+
+		//randomly talk
+		if (TIMER_Done(NPC,"patrolNoise"))
+		{
+//			G_Sound( NPC, G_SoundIndex(va("sound/chars/mark1/misc/talk%d.wav",	Q_irand(1, 4))));
+
+			TIMER_Set( NPC, "patrolNoise", Q_irand( 2000, 4000 ) );
+		}
+	}
+}
+
+/*
+-------------------------
+Mark2_Idle
+-------------------------
+*/
+void Mark2_Idle( void )
+{
+	NPC_BSIdle();
+}
+
+/*
+-------------------------
+NPC_BSMark2_Default
+-------------------------
+*/
+void NPC_BSMark2_Default( void )
+{
+	if ( NPC->enemy )
+	{
+		NPCInfo->goalEntity = NPC->enemy;
+		Mark2_AttackDecision();
+	}
+	else if ( NPCInfo->scriptFlags & SCF_LOOK_FOR_ENEMIES )
+	{
+		Mark2_Patrol();
+	}
+	else
+	{
+		Mark2_Idle();
+	}
+}
diff --git a/codemp/game/NPC_AI_MineMonster.c b/codemp/game/NPC_AI_MineMonster.c
new file mode 100644
index 0000000..43c7dc3
--- /dev/null
+++ b/codemp/game/NPC_AI_MineMonster.c
@@ -0,0 +1,278 @@
+#include "b_local.h"
+
+// These define the working combat range for these suckers
+#define MIN_DISTANCE		54
+#define MIN_DISTANCE_SQR	( MIN_DISTANCE * MIN_DISTANCE )
+
+#define MAX_DISTANCE		128
+#define MAX_DISTANCE_SQR	( MAX_DISTANCE * MAX_DISTANCE )
+
+#define LSTATE_CLEAR		0
+#define LSTATE_WAITING		1
+
+/*
+-------------------------
+NPC_MineMonster_Precache
+-------------------------
+*/
+void NPC_MineMonster_Precache( void )
+{
+	int i;
+
+	for ( i = 0; i < 4; i++ )
+	{
+		G_SoundIndex( va("sound/chars/mine/misc/bite%i.wav", i+1 ));
+		G_SoundIndex( va("sound/chars/mine/misc/miss%i.wav", i+1 ));
+	}
+}
+
+
+/*
+-------------------------
+MineMonster_Idle
+-------------------------
+*/
+void MineMonster_Idle( void )
+{
+	if ( UpdateGoal() )
+	{
+		ucmd.buttons &= ~BUTTON_WALKING;
+		NPC_MoveToGoal( qtrue );
+	}
+}
+
+
+/*
+-------------------------
+MineMonster_Patrol
+-------------------------
+*/
+void MineMonster_Patrol( void )
+{
+	vec3_t dif;
+
+	NPCInfo->localState = LSTATE_CLEAR;
+
+	//If we have somewhere to go, then do that
+	if ( UpdateGoal() )
+	{
+		ucmd.buttons &= ~BUTTON_WALKING;
+		NPC_MoveToGoal( qtrue );
+	}
+	else
+	{
+		if ( TIMER_Done( NPC, "patrolTime" ))
+		{
+			TIMER_Set( NPC, "patrolTime", crandom() * 5000 + 5000 );
+		}
+	}
+
+	//rwwFIXMEFIXME: Care about all clients, not just client 0
+	VectorSubtract( g_entities[0].r.currentOrigin, NPC->r.currentOrigin, dif );
+
+	if ( VectorLengthSquared( dif ) < 256 * 256 )
+	{
+		G_SetEnemy( NPC, &g_entities[0] );
+	}
+
+	if ( NPC_CheckEnemyExt( qtrue ) == qfalse )
+	{
+		MineMonster_Idle();
+		return;
+	}
+}
+ 
+/*
+-------------------------
+MineMonster_Move
+-------------------------
+*/
+void MineMonster_Move( qboolean visible )
+{
+	if ( NPCInfo->localState != LSTATE_WAITING )
+	{
+		NPCInfo->goalEntity = NPC->enemy;
+		NPC_MoveToGoal( qtrue );
+		NPCInfo->goalRadius = MAX_DISTANCE;	// just get us within combat range
+	}
+}
+
+//---------------------------------------------------------
+void MineMonster_TryDamage( gentity_t *enemy, int damage )
+{
+	vec3_t	end, dir;
+	trace_t	tr;
+
+	if ( !enemy )
+	{
+		return;
+	}
+
+	AngleVectors( NPC->client->ps.viewangles, dir, NULL, NULL );
+	VectorMA( NPC->r.currentOrigin, MIN_DISTANCE, dir, end );
+
+	// Should probably trace from the mouth, but, ah well.
+	trap_Trace( &tr, NPC->r.currentOrigin, vec3_origin, vec3_origin, end, NPC->s.number, MASK_SHOT );
+
+	if ( tr.entityNum >= 0 && tr.entityNum < ENTITYNUM_NONE )
+	{
+		G_Damage( &g_entities[tr.entityNum], NPC, NPC, dir, tr.endpos, damage, DAMAGE_NO_KNOCKBACK, MOD_MELEE );
+		G_Sound( NPC, CHAN_AUTO, G_EffectIndex(va("sound/chars/mine/misc/bite%i.wav", Q_irand(1,4))));
+	}
+	else
+	{
+		G_Sound( NPC, CHAN_AUTO, G_EffectIndex(va("sound/chars/mine/misc/miss%i.wav", Q_irand(1,4))));
+	}
+}
+
+//------------------------------
+void MineMonster_Attack( void )
+{
+	if ( !TIMER_Exists( NPC, "attacking" ))
+	{
+		// usually try and play a jump attack if the player somehow got above them....or just really rarely
+		if ( NPC->enemy && ((NPC->enemy->r.currentOrigin[2] - NPC->r.currentOrigin[2] > 10 && random() > 0.1f ) 
+						|| random() > 0.8f ))
+		{
+			// Going to do ATTACK4
+			TIMER_Set( NPC, "attacking", 1750 + random() * 200 );
+			NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_ATTACK4, SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLD );
+
+			TIMER_Set( NPC, "attack2_dmg", 950 ); // level two damage
+		}
+		else if ( random() > 0.5f )
+		{
+			if ( random() > 0.8f )
+			{
+				// Going to do ATTACK3, (rare)
+				TIMER_Set( NPC, "attacking", 850 );
+				NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_ATTACK3, SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLD );
+
+				TIMER_Set( NPC, "attack2_dmg", 400 ); // level two damage
+			}
+			else
+			{
+				// Going to do ATTACK1
+				TIMER_Set( NPC, "attacking", 850 );
+				NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_ATTACK1, SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLD );
+
+				TIMER_Set( NPC, "attack1_dmg", 450 ); // level one damage
+			}
+		}
+		else
+		{
+			// Going to do ATTACK2
+			TIMER_Set( NPC, "attacking", 1250 );
+			NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_ATTACK2, SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLD );
+
+			TIMER_Set( NPC, "attack1_dmg", 700 ); // level one damage
+		}
+	}
+	else
+	{
+		// Need to do delayed damage since the attack animations encapsulate multiple mini-attacks
+		if ( TIMER_Done2( NPC, "attack1_dmg", qtrue ))
+		{
+			MineMonster_TryDamage( NPC->enemy, 5 );
+		}
+		else if ( TIMER_Done2( NPC, "attack2_dmg", qtrue ))
+		{
+			MineMonster_TryDamage( NPC->enemy, 10 );
+		}
+	}
+
+	// Just using this to remove the attacking flag at the right time
+	TIMER_Done2( NPC, "attacking", qtrue );
+}
+
+//----------------------------------
+void MineMonster_Combat( void )
+{
+	float distance;
+	qboolean advance;
+
+	// If we cannot see our target or we have somewhere to go, then do that
+	if ( !NPC_ClearLOS4( NPC->enemy ) || UpdateGoal( ))
+	{
+		NPCInfo->combatMove = qtrue;
+		NPCInfo->goalEntity = NPC->enemy;
+		NPCInfo->goalRadius = MAX_DISTANCE;	// just get us within combat range
+
+		NPC_MoveToGoal( qtrue );
+		return;
+	}
+
+	// Sometimes I have problems with facing the enemy I'm attacking, so force the issue so I don't look dumb
+	NPC_FaceEnemy( qtrue );
+
+	distance	= DistanceHorizontalSquared( NPC->r.currentOrigin, NPC->enemy->r.currentOrigin );	
+
+	advance = (qboolean)( distance > MIN_DISTANCE_SQR ? qtrue : qfalse  );
+
+	if (( advance || NPCInfo->localState == LSTATE_WAITING ) && TIMER_Done( NPC, "attacking" )) // waiting monsters can't attack
+	{
+		if ( TIMER_Done2( NPC, "takingPain", qtrue ))
+		{
+			NPCInfo->localState = LSTATE_CLEAR;
+		}
+		else
+		{
+			MineMonster_Move( 1 );
+		}
+	}
+	else
+	{
+		MineMonster_Attack();
+	}
+}
+
+/*
+-------------------------
+NPC_MineMonster_Pain
+-------------------------
+*/
+void NPC_MineMonster_Pain(gentity_t *self, gentity_t *attacker, int damage)
+{
+	G_AddEvent( self, EV_PAIN, floor((float)self->health/self->client->pers.maxHealth*100.0f) );
+
+	if ( damage >= 10 )
+	{
+		TIMER_Remove( self, "attacking" );
+		TIMER_Remove( self, "attacking1_dmg" );
+		TIMER_Remove( self, "attacking2_dmg" );
+		TIMER_Set( self, "takingPain", 1350 );
+
+		VectorCopy( self->NPC->lastPathAngles, self->s.angles );
+
+		NPC_SetAnim( self, SETANIM_BOTH, BOTH_PAIN1, SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLD );
+
+		if ( self->NPC )
+		{
+			self->NPC->localState = LSTATE_WAITING;
+		}
+	}
+}
+
+
+/*
+-------------------------
+NPC_BSMineMonster_Default
+-------------------------
+*/
+void NPC_BSMineMonster_Default( void )
+{
+	if ( NPC->enemy )
+	{
+		MineMonster_Combat();
+	}
+	else if ( NPCInfo->scriptFlags & SCF_LOOK_FOR_ENEMIES )
+	{
+		MineMonster_Patrol();
+	}
+	else
+	{
+		MineMonster_Idle();
+	}
+
+	NPC_UpdateAngles( qtrue, qtrue );
+}
diff --git a/codemp/game/NPC_AI_Rancor.c b/codemp/game/NPC_AI_Rancor.c
new file mode 100644
index 0000000..d8da24c
--- /dev/null
+++ b/codemp/game/NPC_AI_Rancor.c
@@ -0,0 +1,955 @@
+// leave this line at the top of all AI_xxxx.cpp files for PCH reasons...
+#include "g_headers.h"
+
+	    
+#include "b_local.h"
+
+extern void G_GetBoltPosition( gentity_t *self, int boltIndex, vec3_t pos, int modelIndex );
+
+// These define the working combat range for these suckers
+#define MIN_DISTANCE		128
+#define MIN_DISTANCE_SQR	( MIN_DISTANCE * MIN_DISTANCE )
+
+#define MAX_DISTANCE		1024
+#define MAX_DISTANCE_SQR	( MAX_DISTANCE * MAX_DISTANCE )
+
+#define LSTATE_CLEAR		0
+#define LSTATE_WAITING		1
+
+void Rancor_SetBolts( gentity_t *self )
+{
+	if ( self && self->client )
+	{
+		renderInfo_t *ri = &self->client->renderInfo;
+		ri->handRBolt = trap_G2API_AddBolt( self->ghoul2, 0, "*r_hand" );
+		ri->handLBolt = trap_G2API_AddBolt( self->ghoul2, 0, "*l_hand" );
+		ri->headBolt = trap_G2API_AddBolt( self->ghoul2, 0, "*head_eyes" );
+		ri->torsoBolt = trap_G2API_AddBolt( self->ghoul2, 0, "jaw_bone" );
+	}
+}
+
+/*
+-------------------------
+NPC_Rancor_Precache
+-------------------------
+*/
+void NPC_Rancor_Precache( void )
+{
+	int i;
+	for ( i = 1; i < 3; i ++ )
+	{
+		G_SoundIndex( va("sound/chars/rancor/snort_%d.wav", i) );
+	}
+	G_SoundIndex( "sound/chars/rancor/swipehit.wav" );
+	G_SoundIndex( "sound/chars/rancor/chomp.wav" );
+}
+
+
+/*
+-------------------------
+Rancor_Idle
+-------------------------
+*/
+void Rancor_Idle( void )
+{
+	NPCInfo->localState = LSTATE_CLEAR;
+
+	//If we have somewhere to go, then do that
+	if ( UpdateGoal() )
+	{
+		ucmd.buttons &= ~BUTTON_WALKING;
+		NPC_MoveToGoal( qtrue );
+	}
+}
+
+
+qboolean Rancor_CheckRoar( gentity_t *self )
+{
+	if ( !self->wait )
+	{//haven't ever gotten mad yet
+		self->wait = 1;//do this only once
+		self->client->ps.eFlags2 |= EF2_ALERTED;
+		NPC_SetAnim( self, SETANIM_BOTH, BOTH_STAND1TO2, SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLD );
+		TIMER_Set( self, "rageTime", self->client->ps.legsTimer );
+		return qtrue;
+	}
+	return qfalse;
+}
+/*
+-------------------------
+Rancor_Patrol
+-------------------------
+*/
+void Rancor_Patrol( void )
+{
+	NPCInfo->localState = LSTATE_CLEAR;
+
+	//If we have somewhere to go, then do that
+	if ( UpdateGoal() )
+	{
+		ucmd.buttons &= ~BUTTON_WALKING;
+		NPC_MoveToGoal( qtrue );
+	}
+	else
+	{
+		if ( TIMER_Done( NPC, "patrolTime" ))
+		{
+			TIMER_Set( NPC, "patrolTime", crandom() * 5000 + 5000 );
+		}
+	}
+
+	if ( NPC_CheckEnemyExt( qtrue ) == qfalse )
+	{
+		Rancor_Idle();
+		return;
+	}
+	Rancor_CheckRoar( NPC );
+	TIMER_Set( NPC, "lookForNewEnemy", Q_irand( 5000, 15000 ) );
+}
+ 
+/*
+-------------------------
+Rancor_Move
+-------------------------
+*/
+void Rancor_Move( qboolean visible )
+{
+	if ( NPCInfo->localState != LSTATE_WAITING )
+	{
+		NPCInfo->goalEntity = NPC->enemy;
+		if ( !NPC_MoveToGoal( qtrue ) )
+		{
+			NPCInfo->consecutiveBlockedMoves++;
+		}
+		else
+		{
+			NPCInfo->consecutiveBlockedMoves = 0;
+		}
+		NPCInfo->goalRadius = MAX_DISTANCE;	// just get us within combat range
+	}
+}
+
+//---------------------------------------------------------
+//extern void G_Knockdown( gentity_t *self, gentity_t *attacker, const vec3_t pushDir, float strength, qboolean breakSaberLock );
+extern void G_Knockdown( gentity_t *victim );
+extern void G_Dismember( gentity_t *ent, gentity_t *enemy, vec3_t point, int limbType, float limbRollBase, float limbPitchBase, int deathAnim, qboolean postDeath );
+//extern qboolean G_DoDismemberment( gentity_t *self, vec3_t point, int mod, int damage, int hitLoc, qboolean force );
+extern float NPC_EntRangeFromBolt( gentity_t *targEnt, int boltIndex );
+extern int NPC_GetEntsNearBolt( int *radiusEnts, float radius, int boltIndex, vec3_t boltOrg );
+
+void Rancor_DropVictim( gentity_t *self )
+{
+	//FIXME: if Rancor dies, it should drop its victim.
+	//FIXME: if Rancor is removed, it must remove its victim.
+	if ( self->activator )
+	{
+		if ( self->activator->client )
+		{
+			self->activator->client->ps.eFlags2 &= ~EF2_HELD_BY_MONSTER;
+			self->activator->client->ps.hasLookTarget = qfalse;
+			self->activator->client->ps.lookTarget = ENTITYNUM_NONE;
+			self->activator->client->ps.viewangles[ROLL] = 0;
+			SetClientViewAngle( self->activator, self->activator->client->ps.viewangles );
+			self->activator->r.currentAngles[PITCH] = self->activator->r.currentAngles[ROLL] = 0;
+			G_SetAngles( self->activator, self->activator->r.currentAngles );
+		}
+		if ( self->activator->health <= 0 )
+		{
+			//if ( self->activator->s.number )
+			{//never free player
+				if ( self->count == 1 )
+				{//in my hand, just drop them
+					if ( self->activator->client )
+					{
+						self->activator->client->ps.legsTimer = self->activator->client->ps.torsoTimer = 0;
+						//FIXME: ragdoll?
+					}
+				}
+				else
+				{
+					if ( self->activator->client )
+					{
+						self->activator->client->ps.eFlags |= EF_NODRAW;//so his corpse doesn't drop out of me...
+					}
+					//G_FreeEntity( self->activator );
+				}
+			}
+		}
+		else
+		{
+			if ( self->activator->NPC )
+			{//start thinking again
+				self->activator->NPC->nextBStateThink = level.time;
+			}
+			//clear their anim and let them fall
+			self->activator->client->ps.legsTimer = self->activator->client->ps.torsoTimer = 0;
+		}
+		if ( self->enemy == self->activator )
+		{
+			self->enemy = NULL;
+		}
+		self->activator = NULL;
+	}
+	self->count = 0;//drop him
+}
+
+void Rancor_Swing( qboolean tryGrab )
+{
+	int			radiusEntNums[128];
+	int			numEnts;
+	const float	radius = 88;
+	const float	radiusSquared = (radius*radius);
+	int			i;
+	vec3_t		boltOrg;
+
+	numEnts = NPC_GetEntsNearBolt( radiusEntNums, radius, NPC->client->renderInfo.handRBolt, boltOrg );
+
+	for ( i = 0; i < numEnts; i++ )
+	{
+		gentity_t *radiusEnt = &g_entities[radiusEntNums[i]];
+		if ( !radiusEnt->inuse )
+		{
+			continue;
+		}
+		
+		if ( radiusEnt == NPC )
+		{//Skip the rancor ent
+			continue;
+		}
+		
+		if ( radiusEnt->client == NULL )
+		{//must be a client
+			continue;
+		}
+
+		if ( (radiusEnt->client->ps.eFlags2&EF2_HELD_BY_MONSTER) )
+		{//can't be one already being held
+			continue;
+		}
+		
+		if ( DistanceSquared( radiusEnt->r.currentOrigin, boltOrg ) <= radiusSquared )
+		{
+			if ( tryGrab 
+				&& NPC->count != 1 //don't have one in hand or in mouth already - FIXME: allow one in hand and any number in mouth!
+				&& radiusEnt->client->NPC_class != CLASS_RANCOR
+				&& radiusEnt->client->NPC_class != CLASS_GALAKMECH
+				&& radiusEnt->client->NPC_class != CLASS_ATST
+				&& radiusEnt->client->NPC_class != CLASS_GONK
+				&& radiusEnt->client->NPC_class != CLASS_R2D2
+				&& radiusEnt->client->NPC_class != CLASS_R5D2
+				&& radiusEnt->client->NPC_class != CLASS_MARK1
+				&& radiusEnt->client->NPC_class != CLASS_MARK2
+				&& radiusEnt->client->NPC_class != CLASS_MOUSE
+				&& radiusEnt->client->NPC_class != CLASS_PROBE
+				&& radiusEnt->client->NPC_class != CLASS_SEEKER
+				&& radiusEnt->client->NPC_class != CLASS_REMOTE
+				&& radiusEnt->client->NPC_class != CLASS_SENTRY
+				&& radiusEnt->client->NPC_class != CLASS_INTERROGATOR
+				&& radiusEnt->client->NPC_class != CLASS_VEHICLE )
+			{//grab
+				if ( NPC->count == 2 )
+				{//have one in my mouth, remove him
+					TIMER_Remove( NPC, "clearGrabbed" );
+					Rancor_DropVictim( NPC );
+				}
+				NPC->enemy = radiusEnt;//make him my new best friend
+				radiusEnt->client->ps.eFlags2 |= EF2_HELD_BY_MONSTER;
+				//FIXME: this makes it so that the victim can't hit us with shots!  Just use activator or something
+				radiusEnt->client->ps.hasLookTarget = qtrue;
+				radiusEnt->client->ps.lookTarget = NPC->s.number;
+				NPC->activator = radiusEnt;//remember him
+				NPC->count = 1;//in my hand
+				//wait to attack
+				TIMER_Set( NPC, "attacking", NPC->client->ps.legsTimer + Q_irand(500, 2500) );
+				if ( radiusEnt->health > 0 && radiusEnt->pain )
+				{//do pain on enemy
+					radiusEnt->pain( radiusEnt, NPC, 100 );
+					//GEntity_PainFunc( radiusEnt, NPC, NPC, radiusEnt->r.currentOrigin, 0, MOD_CRUSH );
+				}
+				else if ( radiusEnt->client )
+				{
+					radiusEnt->client->ps.forceHandExtend = HANDEXTEND_NONE;
+					radiusEnt->client->ps.forceHandExtendTime = 0;
+					NPC_SetAnim( radiusEnt, SETANIM_BOTH, BOTH_SWIM_IDLE1, SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLD );
+				}
+			}
+			else
+			{//smack
+				vec3_t pushDir;
+				vec3_t angs;
+
+				G_Sound( radiusEnt, CHAN_AUTO, G_SoundIndex( "sound/chars/rancor/swipehit.wav" ) );
+				//actually push the enemy
+				/*
+				//VectorSubtract( radiusEnt->r.currentOrigin, boltOrg, pushDir );
+				VectorSubtract( radiusEnt->r.currentOrigin, NPC->r.currentOrigin, pushDir );
+				pushDir[2] = Q_flrand( 100, 200 );
+				VectorNormalize( pushDir );
+				*/
+				VectorCopy( NPC->client->ps.viewangles, angs );
+				angs[YAW] += flrand( 25, 50 );
+				angs[PITCH] = flrand( -25, -15 );
+				AngleVectors( angs, pushDir, NULL, NULL );
+				if ( radiusEnt->client->NPC_class != CLASS_RANCOR
+					&& radiusEnt->client->NPC_class != CLASS_ATST )
+				{
+					G_Damage( radiusEnt, NPC, NPC, vec3_origin, radiusEnt->r.currentOrigin, Q_irand( 25, 40 ), DAMAGE_NO_ARMOR|DAMAGE_NO_KNOCKBACK, MOD_MELEE );
+					G_Throw( radiusEnt, pushDir, 250 );
+					if ( radiusEnt->health > 0 )
+					{//do pain on enemy
+						G_Knockdown( radiusEnt );//, NPC, pushDir, 100, qtrue );
+					}
+				}
+			}
+		}
+	}
+}
+
+void Rancor_Smash( void )
+{
+	int			radiusEntNums[128];
+	int			numEnts;
+	const float	radius = 128;
+	const float	halfRadSquared = ((radius/2)*(radius/2));
+	const float	radiusSquared = (radius*radius);
+	float		distSq;
+	int			i;
+	vec3_t		boltOrg;
+
+	AddSoundEvent( NPC, NPC->r.currentOrigin, 512, AEL_DANGER, qfalse );//, qtrue );
+
+	numEnts = NPC_GetEntsNearBolt( radiusEntNums, radius, NPC->client->renderInfo.handLBolt, boltOrg );
+
+	for ( i = 0; i < numEnts; i++ )
+	{
+		gentity_t *radiusEnt = &g_entities[radiusEntNums[i]];
+		if ( !radiusEnt->inuse )
+		{
+			continue;
+		}
+		
+		if ( radiusEnt == NPC )
+		{//Skip the rancor ent
+			continue;
+		}
+		
+		if ( radiusEnt->client == NULL )
+		{//must be a client
+			continue;
+		}
+
+		if ( (radiusEnt->client->ps.eFlags2&EF2_HELD_BY_MONSTER) )
+		{//can't be one being held
+			continue;
+		}
+		
+		distSq = DistanceSquared( radiusEnt->r.currentOrigin, boltOrg );
+		if ( distSq <= radiusSquared )
+		{
+			G_Sound( radiusEnt, CHAN_AUTO, G_SoundIndex( "sound/chars/rancor/swipehit.wav" ) );
+			if ( distSq < halfRadSquared )
+			{//close enough to do damage, too
+				G_Damage( radiusEnt, NPC, NPC, vec3_origin, radiusEnt->r.currentOrigin, Q_irand( 10, 25 ), DAMAGE_NO_ARMOR|DAMAGE_NO_KNOCKBACK, MOD_MELEE );
+			}
+			if ( radiusEnt->health > 0 
+				&& radiusEnt->client
+				&& radiusEnt->client->NPC_class != CLASS_RANCOR
+				&& radiusEnt->client->NPC_class != CLASS_ATST )
+			{
+				if ( distSq < halfRadSquared 
+					|| radiusEnt->client->ps.groundEntityNum != ENTITYNUM_NONE )
+				{//within range of my fist or withing ground-shaking range and not in the air
+					G_Knockdown( radiusEnt );//, NPC, vec3_origin, 100, qtrue );
+				}
+			}
+		}
+	}
+}
+
+void Rancor_Bite( void )
+{
+	int			radiusEntNums[128];
+	int			numEnts;
+	const float	radius = 100;
+	const float	radiusSquared = (radius*radius);
+	int			i;
+	vec3_t		boltOrg;
+
+	numEnts = NPC_GetEntsNearBolt( radiusEntNums, radius, NPC->client->renderInfo.crotchBolt, boltOrg );//was gutBolt?
+
+	for ( i = 0; i < numEnts; i++ )
+	{
+		gentity_t *radiusEnt = &g_entities[radiusEntNums[i]];
+		if ( !radiusEnt->inuse )
+		{
+			continue;
+		}
+		
+		if ( radiusEnt == NPC )
+		{//Skip the rancor ent
+			continue;
+		}
+		
+		if ( radiusEnt->client == NULL )
+		{//must be a client
+			continue;
+		}
+
+		if ( (radiusEnt->client->ps.eFlags2&EF2_HELD_BY_MONSTER) )
+		{//can't be one already being held
+			continue;
+		}
+		
+		if ( DistanceSquared( radiusEnt->r.currentOrigin, boltOrg ) <= radiusSquared )
+		{
+			G_Damage( radiusEnt, NPC, NPC, vec3_origin, radiusEnt->r.currentOrigin, Q_irand( 15, 30 ), DAMAGE_NO_ARMOR|DAMAGE_NO_KNOCKBACK, MOD_MELEE );
+			if ( radiusEnt->health <= 0 && radiusEnt->client )
+			{//killed them, chance of dismembering
+				if ( !Q_irand( 0, 1 ) )
+				{//bite something off
+					int hitLoc = Q_irand( G2_MODELPART_HEAD, G2_MODELPART_RLEG );
+					if ( hitLoc == G2_MODELPART_HEAD )
+					{
+						NPC_SetAnim( radiusEnt, SETANIM_BOTH, BOTH_DEATH17, SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLD );
+					}
+					else if ( hitLoc == G2_MODELPART_WAIST )
+					{
+						NPC_SetAnim( radiusEnt, SETANIM_BOTH, BOTH_DEATHBACKWARD2, SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLD );
+					}
+					//radiusEnt->client->dismembered = qfalse;
+					//FIXME: the limb should just disappear, cuz I ate it
+					G_Dismember( radiusEnt, NPC, radiusEnt->r.currentOrigin, hitLoc, 90, 0, radiusEnt->client->ps.torsoAnim, qtrue);
+					//G_DoDismemberment( radiusEnt, radiusEnt->r.currentOrigin, MOD_SABER, 1000, hitLoc, qtrue );
+				}
+			}
+			G_Sound( radiusEnt, CHAN_AUTO, G_SoundIndex( "sound/chars/rancor/chomp.wav" ) );
+		}
+	}
+}
+//------------------------------
+extern void TossClientItems( gentity_t *self );
+void Rancor_Attack( float distance, qboolean doCharge )
+{
+	if ( !TIMER_Exists( NPC, "attacking" ) )
+	{
+		if ( NPC->count == 2 && NPC->activator )
+		{
+		}
+		else if ( NPC->count == 1 && NPC->activator )
+		{//holding enemy
+			if ( NPC->activator->health > 0 && Q_irand( 0, 1 ) )
+			{//quick bite
+				NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_ATTACK1, SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLD );
+				TIMER_Set( NPC, "attack_dmg", 450 );
+			}
+			else
+			{//full eat
+				NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_ATTACK3, SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLD );
+				TIMER_Set( NPC, "attack_dmg", 900 );
+				//Make victim scream in fright
+				if ( NPC->activator->health > 0 && NPC->activator->client )
+				{
+					G_AddEvent( NPC->activator, Q_irand(EV_DEATH1, EV_DEATH3), 0 );
+					NPC_SetAnim( NPC->activator, SETANIM_TORSO, BOTH_FALLDEATH1, SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLD );
+					if ( NPC->activator->NPC )
+					{//no more thinking for you
+						TossClientItems( NPC );
+						NPC->activator->NPC->nextBStateThink = Q3_INFINITE;
+					}
+				}
+			}
+		}
+		else if ( NPC->enemy->health > 0 && doCharge )
+		{//charge
+			vec3_t	fwd, yawAng;
+			VectorSet( yawAng, 0, NPC->client->ps.viewangles[YAW], 0 );
+			AngleVectors( yawAng, fwd, NULL, NULL );
+			VectorScale( fwd, distance*1.5f, NPC->client->ps.velocity );
+			NPC->client->ps.velocity[2] = 150;
+			NPC->client->ps.groundEntityNum = ENTITYNUM_NONE;
+
+			NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_MELEE2, SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLD );
+			TIMER_Set( NPC, "attack_dmg", 1250 );
+		}
+		else if ( !Q_irand(0, 1) )
+		{//smash
+			NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_MELEE1, SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLD );
+			TIMER_Set( NPC, "attack_dmg", 1000 );
+		}
+		else
+		{//try to grab
+			NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_ATTACK2, SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLD );
+			TIMER_Set( NPC, "attack_dmg", 1000 );
+		}
+
+		TIMER_Set( NPC, "attacking", NPC->client->ps.legsTimer + random() * 200 );
+	}
+
+	// Need to do delayed damage since the attack animations encapsulate multiple mini-attacks
+
+	if ( TIMER_Done2( NPC, "attack_dmg", qtrue ) )
+	{
+		vec3_t shakePos;
+		switch ( NPC->client->ps.legsAnim )
+		{
+		case BOTH_MELEE1:
+			Rancor_Smash();
+			G_GetBoltPosition( NPC, NPC->client->renderInfo.handLBolt, shakePos, 0 );
+			G_ScreenShake( shakePos, NULL, 4.0f, 1000, qfalse );
+			//CGCam_Shake( 1.0f*playerDist/128.0f, 1000 );
+			break;
+		case BOTH_MELEE2:
+			Rancor_Bite();
+			TIMER_Set( NPC, "attack_dmg2", 450 );
+			break;
+		case BOTH_ATTACK1:
+			if ( NPC->count == 1 && NPC->activator )
+			{
+				G_Damage( NPC->activator, NPC, NPC, vec3_origin, NPC->activator->r.currentOrigin, Q_irand( 25, 40 ), DAMAGE_NO_ARMOR|DAMAGE_NO_KNOCKBACK, MOD_MELEE );
+				if ( NPC->activator->health <= 0 )
+				{//killed him
+					//make it look like we bit his head off
+					//NPC->activator->client->dismembered = qfalse;
+					G_Dismember( NPC->activator, NPC, NPC->activator->r.currentOrigin, G2_MODELPART_HEAD, 90, 0, NPC->activator->client->ps.torsoAnim, qtrue);
+					//G_DoDismemberment( NPC->activator, NPC->activator->r.currentOrigin, MOD_SABER, 1000, HL_HEAD, qtrue );
+					NPC->activator->client->ps.forceHandExtend = HANDEXTEND_NONE;
+					NPC->activator->client->ps.forceHandExtendTime = 0;
+					NPC_SetAnim( NPC->activator, SETANIM_BOTH, BOTH_SWIM_IDLE1, SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLD );
+				}
+				G_Sound( NPC->activator, CHAN_AUTO, G_SoundIndex( "sound/chars/rancor/chomp.wav" ) );
+			}
+			break;
+		case BOTH_ATTACK2:
+			//try to grab
+			Rancor_Swing( qtrue );
+			break;
+		case BOTH_ATTACK3:
+			if ( NPC->count == 1 && NPC->activator )
+			{
+				//cut in half
+				if ( NPC->activator->client )
+				{
+					//NPC->activator->client->dismembered = qfalse;
+					G_Dismember( NPC->activator, NPC, NPC->activator->r.currentOrigin, G2_MODELPART_WAIST, 90, 0, NPC->activator->client->ps.torsoAnim, qtrue);
+					//G_DoDismemberment( NPC->activator, NPC->enemy->r.currentOrigin, MOD_SABER, 1000, HL_WAIST, qtrue );
+				}
+				//KILL
+				G_Damage( NPC->activator, NPC, NPC, vec3_origin, NPC->activator->r.currentOrigin, NPC->enemy->health+10, DAMAGE_NO_PROTECTION|DAMAGE_NO_ARMOR|DAMAGE_NO_KNOCKBACK|DAMAGE_NO_HIT_LOC, MOD_MELEE );//, HL_NONE );//
+				if ( NPC->activator->client )
+				{
+					NPC->activator->client->ps.forceHandExtend = HANDEXTEND_NONE;
+					NPC->activator->client->ps.forceHandExtendTime = 0;
+					NPC_SetAnim( NPC->activator, SETANIM_BOTH, BOTH_SWIM_IDLE1, SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLD );
+				}
+				TIMER_Set( NPC, "attack_dmg2", 1350 );
+				G_Sound( NPC->activator, CHAN_AUTO, G_SoundIndex( "sound/chars/rancor/swipehit.wav" ) );
+				G_AddEvent( NPC->activator, EV_JUMP, NPC->activator->health );
+			}
+			break;
+		}
+	}
+	else if ( TIMER_Done2( NPC, "attack_dmg2", qtrue ) )
+	{
+		switch ( NPC->client->ps.legsAnim )
+		{
+		case BOTH_MELEE1:
+			break;
+		case BOTH_MELEE2:
+			Rancor_Bite();
+			break;
+		case BOTH_ATTACK1:
+			break;
+		case BOTH_ATTACK2:
+			break;
+		case BOTH_ATTACK3:
+			if ( NPC->count == 1 && NPC->activator )
+			{//swallow victim
+				G_Sound( NPC->activator, CHAN_AUTO, G_SoundIndex( "sound/chars/rancor/chomp.wav" ) );
+				//FIXME: sometimes end up with a live one in our mouths?
+				//just make sure they're dead
+				if ( NPC->activator->health > 0 )
+				{
+					//cut in half
+					//NPC->activator->client->dismembered = qfalse;
+					G_Dismember( NPC->activator, NPC, NPC->activator->r.currentOrigin, G2_MODELPART_WAIST, 90, 0, NPC->activator->client->ps.torsoAnim, qtrue);
+					//G_DoDismemberment( NPC->activator, NPC->enemy->r.currentOrigin, MOD_SABER, 1000, HL_WAIST, qtrue );
+					//KILL
+					G_Damage( NPC->activator, NPC, NPC, vec3_origin, NPC->activator->r.currentOrigin, NPC->enemy->health+10, DAMAGE_NO_PROTECTION|DAMAGE_NO_ARMOR|DAMAGE_NO_KNOCKBACK|DAMAGE_NO_HIT_LOC, MOD_MELEE );//, HL_NONE );
+					NPC->activator->client->ps.forceHandExtend = HANDEXTEND_NONE;
+					NPC->activator->client->ps.forceHandExtendTime = 0;
+					NPC_SetAnim( NPC->activator, SETANIM_BOTH, BOTH_SWIM_IDLE1, SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLD );
+					G_AddEvent( NPC->activator, EV_JUMP, NPC->activator->health );
+				}
+				if ( NPC->activator->client )
+				{//*sigh*, can't get tags right, just remove them?
+					NPC->activator->client->ps.eFlags |= EF_NODRAW;
+				}
+				NPC->count = 2;
+				TIMER_Set( NPC, "clearGrabbed", 2600 );
+			}
+			break;
+		}
+	}
+	else if ( NPC->client->ps.legsAnim == BOTH_ATTACK2 )
+	{
+		if ( NPC->client->ps.legsTimer >= 1200 && NPC->client->ps.legsTimer <= 1350 )
+		{
+			if ( Q_irand( 0, 2 ) )
+			{
+				Rancor_Swing( qfalse );
+			}
+			else
+			{
+				Rancor_Swing( qtrue );
+			}
+		}
+		else if ( NPC->client->ps.legsTimer >= 1100 && NPC->client->ps.legsTimer <= 1550 )
+		{
+			Rancor_Swing( qtrue );
+		}
+	}
+
+	// Just using this to remove the attacking flag at the right time
+	TIMER_Done2( NPC, "attacking", qtrue );
+}
+
+//----------------------------------
+void Rancor_Combat( void )
+{
+	if ( NPC->count )
+	{//holding my enemy
+		if ( TIMER_Done2( NPC, "takingPain", qtrue ))
+		{
+			NPCInfo->localState = LSTATE_CLEAR;
+		}
+		else
+		{
+			Rancor_Attack( 0, qfalse );
+		}
+		NPC_UpdateAngles( qtrue, qtrue );
+		return;
+	}
+	// If we cannot see our target or we have somewhere to go, then do that
+	if ( !NPC_ClearLOS4( NPC->enemy ) )//|| UpdateGoal( ))
+	{
+		NPCInfo->combatMove = qtrue;
+		NPCInfo->goalEntity = NPC->enemy;
+		NPCInfo->goalRadius = MIN_DISTANCE;//MAX_DISTANCE;	// just get us within combat range
+
+		if ( !NPC_MoveToGoal( qtrue ) )
+		{//couldn't go after him?  Look for a new one
+			TIMER_Set( NPC, "lookForNewEnemy", 0 );
+			NPCInfo->consecutiveBlockedMoves++;
+		}
+		else 
+		{
+			NPCInfo->consecutiveBlockedMoves = 0;
+		}
+		return;
+	}
+
+	// Sometimes I have problems with facing the enemy I'm attacking, so force the issue so I don't look dumb
+	NPC_FaceEnemy( qtrue );
+
+	{
+		float	distance;
+		qboolean	advance;
+		qboolean	doCharge;
+
+		distance	= Distance( NPC->r.currentOrigin, NPC->enemy->r.currentOrigin );	
+		advance = (qboolean)( distance > (NPC->r.maxs[0]+MIN_DISTANCE) ? qtrue : qfalse  );
+		doCharge = qfalse;
+
+		if ( advance )
+		{//have to get closer
+			vec3_t	yawOnlyAngles;
+			VectorSet( yawOnlyAngles, 0, NPC->r.currentAngles[YAW], 0 );
+			if ( NPC->enemy->health > 0
+				&& fabs(distance-250) <= 80 
+				&& InFOV3( NPC->enemy->r.currentOrigin, NPC->r.currentOrigin, yawOnlyAngles, 30, 30 ) )
+			{
+				if ( !Q_irand( 0, 9 ) )
+				{//go for the charge
+					doCharge = qtrue;
+					advance = qfalse;
+				}
+			}
+		}
+
+		if (( advance /*|| NPCInfo->localState == LSTATE_WAITING*/ ) && TIMER_Done( NPC, "attacking" )) // waiting monsters can't attack
+		{
+			if ( TIMER_Done2( NPC, "takingPain", qtrue ))
+			{
+				NPCInfo->localState = LSTATE_CLEAR;
+			}
+			else
+			{
+				Rancor_Move( 1 );
+			}
+		}
+		else
+		{
+			Rancor_Attack( distance, doCharge );
+		}
+	}
+}
+
+/*
+-------------------------
+NPC_Rancor_Pain
+-------------------------
+*/
+//void NPC_Rancor_Pain( gentity_t *self, gentity_t *inflictor, gentity_t *other, const vec3_t point, int damage, int mod,int hitLoc ) 
+void NPC_Rancor_Pain( gentity_t *self, gentity_t *attacker, int damage ) 
+{
+	qboolean hitByRancor = qfalse;
+	if ( attacker&&attacker->client&&attacker->client->NPC_class==CLASS_RANCOR )
+	{
+		hitByRancor = qtrue;
+	}
+	if ( attacker 
+		&& attacker->inuse 
+		&& attacker != self->enemy
+		&& !(attacker->flags&FL_NOTARGET) )
+	{
+		if ( !self->count )
+		{
+			if ( (!attacker->s.number&&!Q_irand(0,3))
+				|| !self->enemy
+				|| self->enemy->health == 0
+				|| (self->enemy->client&&self->enemy->client->NPC_class == CLASS_RANCOR)
+				|| (self->NPC && self->NPC->consecutiveBlockedMoves>=10 && DistanceSquared( attacker->r.currentOrigin, self->r.currentOrigin ) < DistanceSquared( self->enemy->r.currentOrigin, self->r.currentOrigin )) ) 
+			{//if my enemy is dead (or attacked by player) and I'm not still holding/eating someone, turn on the attacker
+				//FIXME: if can't nav to my enemy, take this guy if I can nav to him
+				G_SetEnemy( self, attacker );
+				TIMER_Set( self, "lookForNewEnemy", Q_irand( 5000, 15000 ) );
+				if ( hitByRancor )
+				{//stay mad at this Rancor for 2-5 secs before looking for attacker enemies
+					TIMER_Set( self, "rancorInfight", Q_irand( 2000, 5000 ) );
+				}
+
+			}
+		}
+	}
+	if ( (hitByRancor|| (self->count==1&&self->activator&&!Q_irand(0,4)) || Q_irand( 0, 200 ) < damage )//hit by rancor, hit while holding live victim, or took a lot of damage
+		&& self->client->ps.legsAnim != BOTH_STAND1TO2
+		&& TIMER_Done( self, "takingPain" ) )
+	{
+		if ( !Rancor_CheckRoar( self ) )
+		{
+			if ( self->client->ps.legsAnim != BOTH_MELEE1
+				&& self->client->ps.legsAnim != BOTH_MELEE2
+				&& self->client->ps.legsAnim != BOTH_ATTACK2 )
+			{//cant interrupt one of the big attack anims
+				/*
+				if ( self->count != 1 
+					|| attacker == self->activator
+					|| (self->client->ps.legsAnim != BOTH_ATTACK1&&self->client->ps.legsAnim != BOTH_ATTACK3) )
+				*/
+				{//if going to bite our victim, only victim can interrupt that anim
+					if ( self->health > 100 || hitByRancor )
+					{
+						TIMER_Remove( self, "attacking" );
+
+						VectorCopy( self->NPC->lastPathAngles, self->s.angles );
+
+						if ( self->count == 1 )
+						{
+							NPC_SetAnim( self, SETANIM_BOTH, BOTH_PAIN2, SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLD );
+						}
+						else
+						{
+							NPC_SetAnim( self, SETANIM_BOTH, BOTH_PAIN1, SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLD );
+						}
+						TIMER_Set( self, "takingPain", self->client->ps.legsTimer+Q_irand(0, 500) );
+
+						if ( self->NPC )
+						{
+							self->NPC->localState = LSTATE_WAITING;
+						}
+					}
+				}
+			}
+		}
+		//let go
+		/*
+		if ( !Q_irand( 0, 3 ) && self->count == 1 )
+		{
+			Rancor_DropVictim( self );
+		}
+		*/
+	}
+}
+
+void Rancor_CheckDropVictim( void )
+{
+	vec3_t mins;
+	vec3_t maxs;
+	vec3_t start; 
+	vec3_t end; 
+	trace_t	trace;
+
+	VectorSet( mins, NPC->activator->r.mins[0]-1, NPC->activator->r.mins[1]-1, 0 );
+	VectorSet( maxs, NPC->activator->r.maxs[0]+1, NPC->activator->r.maxs[1]+1, 1 );
+	VectorSet( start, NPC->activator->r.currentOrigin[0], NPC->activator->r.currentOrigin[1], NPC->activator->r.absmin[2] ); 
+	VectorSet( end, NPC->activator->r.currentOrigin[0], NPC->activator->r.currentOrigin[1], NPC->activator->r.absmax[2]-1 ); 
+
+	trap_Trace( &trace, start, mins, maxs, end, NPC->activator->s.number, NPC->activator->clipmask );
+	if ( !trace.allsolid && !trace.startsolid && trace.fraction >= 1.0f )
+	{
+		Rancor_DropVictim( NPC );
+	}
+}
+
+//if he's stepping on things then crush them -rww
+void Rancor_Crush(void)
+{
+	gentity_t *crush;
+
+	if (!NPC ||
+		!NPC->client ||
+		NPC->client->ps.groundEntityNum >= ENTITYNUM_WORLD)
+	{ //nothing to crush
+		return;
+	}
+
+	crush = &g_entities[NPC->client->ps.groundEntityNum];
+	if (crush->inuse && crush->client && !crush->localAnimIndex)
+	{ //a humanoid, smash them good.
+		G_Damage(crush, NPC, NPC, NULL, NPC->r.currentOrigin, 200, 0, MOD_CRUSH);
+	}
+}
+
+/*
+-------------------------
+NPC_BSRancor_Default
+-------------------------
+*/
+void NPC_BSRancor_Default( void )
+{
+	AddSightEvent( NPC, NPC->r.currentOrigin, 1024, AEL_DANGER_GREAT, 50 );
+
+	Rancor_Crush();
+
+	NPC->client->ps.eFlags2 &= ~(EF2_USE_ALT_ANIM|EF2_GENERIC_NPC_FLAG);
+	if ( NPC->count )
+	{//holding someone
+		NPC->client->ps.eFlags2 |= EF2_USE_ALT_ANIM;
+		if ( NPC->count == 2 )
+		{//in my mouth
+			NPC->client->ps.eFlags2 |= EF2_GENERIC_NPC_FLAG;
+		}
+	}
+	else
+	{
+		NPC->client->ps.eFlags2 &= ~(EF2_USE_ALT_ANIM|EF2_GENERIC_NPC_FLAG);
+	}
+
+	if ( TIMER_Done2( NPC, "clearGrabbed", qtrue ) )
+	{
+		Rancor_DropVictim( NPC );
+	}
+	else if ( NPC->client->ps.legsAnim == BOTH_PAIN2 
+		&& NPC->count == 1 
+		&& NPC->activator )
+	{
+		if ( !Q_irand( 0, 3 ) )
+		{
+			Rancor_CheckDropVictim();
+		}
+	}
+	if ( !TIMER_Done( NPC, "rageTime" ) )
+	{//do nothing but roar first time we see an enemy
+		AddSoundEvent( NPC, NPC->r.currentOrigin, 1024, AEL_DANGER_GREAT, qfalse );//, qfalse );
+		NPC_FaceEnemy( qtrue );
+		return;
+	}
+	if ( NPC->enemy )
+	{
+		/*
+		if ( NPC->enemy->client //enemy is a client
+			&& (NPC->enemy->client->NPC_class == CLASS_UGNAUGHT || NPC->enemy->client->NPC_class == CLASS_JAWA )//enemy is a lowly jawa or ugnaught
+			&& NPC->enemy->enemy != NPC//enemy's enemy is not me
+			&& (!NPC->enemy->enemy || !NPC->enemy->enemy->client || NPC->enemy->enemy->client->NPC_class!=CLASS_RANCOR) )//enemy's enemy is not a client or is not a rancor (which is as scary as me anyway)
+		{//they should be scared of ME and no-one else
+			G_SetEnemy( NPC->enemy, NPC );
+		}
+		*/
+		if ( TIMER_Done(NPC,"angrynoise") )
+		{
+			G_Sound( NPC, CHAN_AUTO, G_SoundIndex( va("sound/chars/rancor/misc/anger%d.wav", Q_irand(1, 3))) );
+
+			TIMER_Set( NPC, "angrynoise", Q_irand( 5000, 10000 ) );
+		}
+		else
+		{
+			AddSoundEvent( NPC, NPC->r.currentOrigin, 512, AEL_DANGER_GREAT, qfalse );//, qfalse );
+		}
+		if ( NPC->count == 2 && NPC->client->ps.legsAnim == BOTH_ATTACK3 )
+		{//we're still chewing our enemy up
+			NPC_UpdateAngles( qtrue, qtrue );
+			return;
+		}
+		//else, if he's in our hand, we eat, else if he's on the ground, we keep attacking his dead body for a while
+		if( NPC->enemy->client && NPC->enemy->client->NPC_class == CLASS_RANCOR )
+		{//got mad at another Rancor, look for a valid enemy
+			if ( TIMER_Done( NPC, "rancorInfight" ) )
+			{
+				NPC_CheckEnemyExt( qtrue );
+			}
+		}
+		else if ( !NPC->count )
+		{
+			if ( ValidEnemy( NPC->enemy ) == qfalse )
+			{
+				TIMER_Remove( NPC, "lookForNewEnemy" );//make them look again right now
+				if ( !NPC->enemy->inuse || level.time - NPC->enemy->s.time > Q_irand( 10000, 15000 ) )
+				{//it's been a while since the enemy died, or enemy is completely gone, get bored with him
+					NPC->enemy = NULL;
+					Rancor_Patrol();
+					NPC_UpdateAngles( qtrue, qtrue );
+					return;
+				}
+			}
+			if ( TIMER_Done( NPC, "lookForNewEnemy" ) )
+			{
+				gentity_t *newEnemy, *sav_enemy = NPC->enemy;//FIXME: what about NPC->lastEnemy?
+				NPC->enemy = NULL;
+				newEnemy = NPC_CheckEnemy( NPCInfo->confusionTime < level.time, qfalse, qfalse );
+				NPC->enemy = sav_enemy;
+				if ( newEnemy && newEnemy != sav_enemy )
+				{//picked up a new enemy!
+					NPC->lastEnemy = NPC->enemy;
+					G_SetEnemy( NPC, newEnemy );
+					//hold this one for at least 5-15 seconds
+					TIMER_Set( NPC, "lookForNewEnemy", Q_irand( 5000, 15000 ) );
+				}
+				else
+				{//look again in 2-5 secs
+					TIMER_Set( NPC, "lookForNewEnemy", Q_irand( 2000, 5000 ) );
+				}
+			}
+		}
+		Rancor_Combat();
+	}
+	else 
+	{
+		if ( TIMER_Done(NPC,"idlenoise") )
+		{
+			G_Sound( NPC, CHAN_AUTO, G_SoundIndex( va("sound/chars/rancor/snort_%d.wav", Q_irand(1, 2))) );
+
+			TIMER_Set( NPC, "idlenoise", Q_irand( 2000, 4000 ) );
+			AddSoundEvent( NPC, NPC->r.currentOrigin, 384, AEL_DANGER, qfalse );//, qfalse );
+		}
+		if ( NPCInfo->scriptFlags & SCF_LOOK_FOR_ENEMIES )
+		{
+			Rancor_Patrol();
+		}
+		else
+		{
+			Rancor_Idle();
+		}
+	}
+
+	NPC_UpdateAngles( qtrue, qtrue );
+}
diff --git a/codemp/game/NPC_AI_Remote.c b/codemp/game/NPC_AI_Remote.c
new file mode 100644
index 0000000..7a4150a
--- /dev/null
+++ b/codemp/game/NPC_AI_Remote.c
@@ -0,0 +1,389 @@
+#include "b_local.h"
+#include "g_nav.h"
+
+void Remote_Strafe( void );
+
+#define VELOCITY_DECAY	0.85f
+
+
+//Local state enums
+enum
+{
+	LSTATE_NONE = 0,
+};
+
+void Remote_Idle( void );
+
+void NPC_Remote_Precache(void)
+{
+	G_SoundIndex("sound/chars/remote/misc/fire.wav");
+	G_SoundIndex( "sound/chars/remote/misc/hiss.wav");
+	G_EffectIndex( "env/small_explode");
+}
+
+/*
+-------------------------
+NPC_Remote_Pain
+-------------------------
+*/
+void NPC_Remote_Pain(gentity_t *self, gentity_t *attacker, int damage)
+{
+	SaveNPCGlobals();
+	SetNPCGlobals( self );
+	Remote_Strafe();
+	RestoreNPCGlobals();
+
+	NPC_Pain( self, attacker, damage );
+}
+
+/*
+-------------------------
+Remote_MaintainHeight
+-------------------------
+*/
+void Remote_MaintainHeight( void )
+{	
+	float	dif;
+
+	// Update our angles regardless
+	NPC_UpdateAngles( qtrue, qtrue );
+
+	if ( NPC->client->ps.velocity[2] )
+	{
+		NPC->client->ps.velocity[2] *= VELOCITY_DECAY;
+
+		if ( fabs( NPC->client->ps.velocity[2] ) < 2 )
+		{
+			NPC->client->ps.velocity[2] = 0;
+		}
+	}
+	// If we have an enemy, we should try to hover at or a little below enemy eye level
+	if ( NPC->enemy )
+	{
+		if (TIMER_Done( NPC, "heightChange"))
+		{
+			TIMER_Set( NPC,"heightChange",Q_irand( 1000, 3000 ));
+
+			// Find the height difference
+			dif = (NPC->enemy->r.currentOrigin[2] +  Q_irand( 0, NPC->enemy->r.maxs[2]+8 )) - NPC->r.currentOrigin[2]; 
+
+			// cap to prevent dramatic height shifts
+			if ( fabs( dif ) > 2 )
+			{
+				if ( fabs( dif ) > 24 )
+				{
+					dif = ( dif < 0 ? -24 : 24 );
+				}
+				dif *= 10;
+				NPC->client->ps.velocity[2] = (NPC->client->ps.velocity[2]+dif)/2;
+			//	NPC->fx_time = level.time;
+				G_Sound( NPC, CHAN_AUTO, G_SoundIndex("sound/chars/remote/misc/hiss.wav"));
+			}
+		}
+	}
+	else
+	{
+		gentity_t *goal = NULL;
+
+		if ( NPCInfo->goalEntity )	// Is there a goal?
+		{
+			goal = NPCInfo->goalEntity;
+		}
+		else
+		{
+			goal = NPCInfo->lastGoalEntity;
+		}
+		if ( goal )
+		{
+			dif = goal->r.currentOrigin[2] - NPC->r.currentOrigin[2];
+
+			if ( fabs( dif ) > 24 )
+			{
+				dif = ( dif < 0 ? -24 : 24 );
+				NPC->client->ps.velocity[2] = (NPC->client->ps.velocity[2]+dif)/2;
+			}
+		}
+	}
+
+	// Apply friction
+	if ( NPC->client->ps.velocity[0] )
+	{
+		NPC->client->ps.velocity[0] *= VELOCITY_DECAY;
+
+		if ( fabs( NPC->client->ps.velocity[0] ) < 1 )
+		{
+			NPC->client->ps.velocity[0] = 0;
+		}
+	}
+
+	if ( NPC->client->ps.velocity[1] )
+	{
+		NPC->client->ps.velocity[1] *= VELOCITY_DECAY;
+
+		if ( fabs( NPC->client->ps.velocity[1] ) < 1 )
+		{
+			NPC->client->ps.velocity[1] = 0;
+		}
+	}
+}
+
+#define REMOTE_STRAFE_VEL	256
+#define REMOTE_STRAFE_DIS	200
+#define REMOTE_UPWARD_PUSH	32
+
+/*
+-------------------------
+Remote_Strafe
+-------------------------
+*/
+void Remote_Strafe( void )
+{
+	int		dir;
+	vec3_t	end, right;
+	trace_t	tr;
+
+	AngleVectors( NPC->client->renderInfo.eyeAngles, NULL, right, NULL );
+
+	// Pick a random strafe direction, then check to see if doing a strafe would be
+	//	reasonable valid
+	dir = ( rand() & 1 ) ? -1 : 1;
+	VectorMA( NPC->r.currentOrigin, REMOTE_STRAFE_DIS * dir, right, end );
+
+	trap_Trace( &tr, NPC->r.currentOrigin, NULL, NULL, end, NPC->s.number, MASK_SOLID );
+
+	// Close enough
+	if ( tr.fraction > 0.9f )
+	{
+		VectorMA( NPC->client->ps.velocity, REMOTE_STRAFE_VEL * dir, right, NPC->client->ps.velocity );
+
+		G_Sound( NPC, CHAN_AUTO, G_SoundIndex("sound/chars/remote/misc/hiss.wav"));
+
+		// Add a slight upward push
+		NPC->client->ps.velocity[2] += REMOTE_UPWARD_PUSH;
+
+		// Set the strafe start time so we can do a controlled roll
+	//	NPC->fx_time = level.time;
+		NPCInfo->standTime = level.time + 3000 + random() * 500;
+	}
+}
+
+#define REMOTE_FORWARD_BASE_SPEED	10
+#define REMOTE_FORWARD_MULTIPLIER	5
+
+/*
+-------------------------
+Remote_Hunt
+-------------------------
+*/
+void Remote_Hunt( qboolean visible, qboolean advance, qboolean retreat )
+{
+	float	distance, speed;
+	vec3_t	forward;
+
+	//If we're not supposed to stand still, pursue the player
+	if ( NPCInfo->standTime < level.time )
+	{
+		// Only strafe when we can see the player
+		if ( visible )
+		{
+			Remote_Strafe();
+			return;
+		}
+	}
+
+	//If we don't want to advance, stop here
+	if ( advance == qfalse && visible == qtrue )
+		return;
+
+	//Only try and navigate if the player is visible
+	if ( visible == qfalse )
+	{
+		// Move towards our goal
+		NPCInfo->goalEntity = NPC->enemy;
+		NPCInfo->goalRadius = 12;
+
+		//Get our direction from the navigator if we can't see our target
+		if ( NPC_GetMoveDirection( forward, &distance ) == qfalse )
+			return;
+	}
+	else
+	{
+		VectorSubtract( NPC->enemy->r.currentOrigin, NPC->r.currentOrigin, forward );
+		distance = VectorNormalize( forward );
+	}
+
+	speed = REMOTE_FORWARD_BASE_SPEED + REMOTE_FORWARD_MULTIPLIER * g_spskill.integer;
+	if ( retreat == qtrue )
+	{
+		speed *= -1;
+	}
+	VectorMA( NPC->client->ps.velocity, speed, forward, NPC->client->ps.velocity );
+}
+
+
+/*
+-------------------------
+Remote_Fire
+-------------------------
+*/
+void Remote_Fire (void)
+{
+	vec3_t	delta1, enemy_org1, muzzle1;
+	vec3_t	angleToEnemy1;
+	static	vec3_t	forward, vright, up;
+	static	vec3_t	muzzle;
+	gentity_t	*missile;
+
+	CalcEntitySpot( NPC->enemy, SPOT_HEAD, enemy_org1 );
+	VectorCopy( NPC->r.currentOrigin, muzzle1 );
+	
+	VectorSubtract (enemy_org1, muzzle1, delta1);
+
+	vectoangles ( delta1, angleToEnemy1 );
+	AngleVectors (angleToEnemy1, forward, vright, up);
+
+	missile = CreateMissile( NPC->r.currentOrigin, forward, 1000, 10000, NPC, qfalse );
+
+	G_PlayEffectID( G_EffectIndex("bryar/muzzle_flash"), NPC->r.currentOrigin, forward );
+
+	missile->classname = "briar";
+	missile->s.weapon = WP_BRYAR_PISTOL;
+
+	missile->damage = 10;
+	missile->dflags = DAMAGE_DEATH_KNOCKBACK;
+	missile->methodOfDeath = MOD_BRYAR_PISTOL;
+	missile->clipmask = MASK_SHOT | CONTENTS_LIGHTSABER;
+
+}
+
+/*
+-------------------------
+Remote_Ranged
+-------------------------
+*/
+void Remote_Ranged( qboolean visible, qboolean advance, qboolean retreat )
+{
+
+	if ( TIMER_Done( NPC, "attackDelay" ) )	// Attack?
+	{
+		TIMER_Set( NPC, "attackDelay", Q_irand( 500, 3000 ) );
+		Remote_Fire();
+	}
+
+	if ( NPCInfo->scriptFlags & SCF_CHASE_ENEMIES )
+	{
+		Remote_Hunt( visible, advance, retreat );
+	}
+}
+
+#define	MIN_MELEE_RANGE		320
+#define	MIN_MELEE_RANGE_SQR	( MIN_MELEE_RANGE * MIN_MELEE_RANGE )
+
+#define MIN_DISTANCE		80
+#define MIN_DISTANCE_SQR	( MIN_DISTANCE * MIN_DISTANCE )
+
+/*
+-------------------------
+Remote_Attack
+-------------------------
+*/
+void Remote_Attack( void )
+{
+	float		distance;
+	qboolean	visible;
+	float		idealDist;
+	qboolean	advance;
+	qboolean	retreat;
+
+	if ( TIMER_Done(NPC,"spin") )
+	{
+		TIMER_Set( NPC, "spin", Q_irand( 250, 1500 ) );
+		NPCInfo->desiredYaw += Q_irand( -200, 200 ); 
+	}
+	// Always keep a good height off the ground
+	Remote_MaintainHeight();
+
+	// If we don't have an enemy, just idle
+	if ( NPC_CheckEnemyExt(qfalse) == qfalse )
+	{
+		Remote_Idle();
+		return;
+	}
+
+	// Rate our distance to the target, and our visibilty
+	distance	= (int) DistanceHorizontalSquared( NPC->r.currentOrigin, NPC->enemy->r.currentOrigin );	
+	visible		= NPC_ClearLOS4( NPC->enemy );
+	idealDist	= MIN_DISTANCE_SQR+(MIN_DISTANCE_SQR*flrand( 0, 1 ));
+	advance		= (qboolean)(distance > idealDist*1.25);
+	retreat		= (qboolean)(distance < idealDist*0.75);
+
+	// If we cannot see our target, move to see it
+	if ( visible == qfalse )
+	{
+		if ( NPCInfo->scriptFlags & SCF_CHASE_ENEMIES )
+		{
+			Remote_Hunt( visible, advance, retreat );
+			return;
+		}
+	}
+
+	Remote_Ranged( visible, advance, retreat );
+
+}
+
+/*
+-------------------------
+Remote_Idle
+-------------------------
+*/
+void Remote_Idle( void )
+{
+	Remote_MaintainHeight();
+
+	NPC_BSIdle();
+}
+
+/*
+-------------------------
+Remote_Patrol
+-------------------------
+*/
+void Remote_Patrol( void )
+{
+	Remote_MaintainHeight();
+
+	//If we have somewhere to go, then do that
+	if (!NPC->enemy)
+	{
+		if ( UpdateGoal() )
+		{
+			//start loop sound once we move
+			ucmd.buttons |= BUTTON_WALKING;
+			NPC_MoveToGoal( qtrue );
+		}
+	}
+
+	NPC_UpdateAngles( qtrue, qtrue );
+}
+
+
+/*
+-------------------------
+NPC_BSRemote_Default
+-------------------------
+*/
+void NPC_BSRemote_Default( void )
+{
+	if ( NPC->enemy )
+	{
+		Remote_Attack();
+	}
+	else if ( NPCInfo->scriptFlags & SCF_LOOK_FOR_ENEMIES )
+	{
+		Remote_Patrol();
+	}
+	else
+	{
+		Remote_Idle();
+	}
+}
diff --git a/codemp/game/NPC_AI_Seeker.c b/codemp/game/NPC_AI_Seeker.c
new file mode 100644
index 0000000..9cfdd19
--- /dev/null
+++ b/codemp/game/NPC_AI_Seeker.c
@@ -0,0 +1,574 @@
+#include "b_local.h"
+#include "g_nav.h"
+
+extern void Boba_FireDecide( void );
+
+void Seeker_Strafe( void );
+
+#define VELOCITY_DECAY		0.7f
+
+#define	MIN_MELEE_RANGE		320
+#define	MIN_MELEE_RANGE_SQR	( MIN_MELEE_RANGE * MIN_MELEE_RANGE )
+
+#define MIN_DISTANCE		80
+#define MIN_DISTANCE_SQR	( MIN_DISTANCE * MIN_DISTANCE )
+
+#define SEEKER_STRAFE_VEL	100
+#define SEEKER_STRAFE_DIS	200
+#define SEEKER_UPWARD_PUSH	32
+
+#define SEEKER_FORWARD_BASE_SPEED	10
+#define SEEKER_FORWARD_MULTIPLIER	2
+
+#define SEEKER_SEEK_RADIUS			1024
+
+//------------------------------------
+void NPC_Seeker_Precache(void)
+{
+	G_SoundIndex("sound/chars/seeker/misc/fire.wav");
+	G_SoundIndex( "sound/chars/seeker/misc/hiss.wav");
+	G_EffectIndex( "env/small_explode");
+}
+
+//------------------------------------
+void NPC_Seeker_Pain(gentity_t *self, gentity_t *attacker, int damage)
+{
+	if ( !(self->NPC->aiFlags&NPCAI_CUSTOM_GRAVITY ))
+	{//void G_Damage( gentity_t *targ, gentity_t *inflictor, gentity_t *attacker, vec3_t dir, vec3_t point, int damage, int dflags, int mod, int hitLoc=HL_NONE );
+		G_Damage( self, NULL, NULL, (float*)vec3_origin, (float*)vec3_origin, 999, 0, MOD_FALLING );
+	}
+
+	SaveNPCGlobals();
+	SetNPCGlobals( self );
+	Seeker_Strafe();
+	RestoreNPCGlobals();
+	NPC_Pain( self, attacker, damage );
+}
+
+//------------------------------------
+void Seeker_MaintainHeight( void )
+{	
+	float	dif;
+
+	// Update our angles regardless
+	NPC_UpdateAngles( qtrue, qtrue );
+
+	// If we have an enemy, we should try to hover at or a little below enemy eye level
+	if ( NPC->enemy )
+	{
+		if (TIMER_Done( NPC, "heightChange" ))
+		{
+			float difFactor;
+
+			TIMER_Set( NPC,"heightChange",Q_irand( 1000, 3000 ));
+
+			// Find the height difference
+			dif = (NPC->enemy->r.currentOrigin[2] +  flrand( NPC->enemy->r.maxs[2]/2, NPC->enemy->r.maxs[2]+8 )) - NPC->r.currentOrigin[2]; 
+
+			difFactor = 1.0f;
+			if ( NPC->client->NPC_class == CLASS_BOBAFETT )
+			{
+				if ( TIMER_Done( NPC, "flameTime" ) )
+				{
+					difFactor = 10.0f;
+				}
+			}
+
+			// cap to prevent dramatic height shifts
+			if ( fabs( dif ) > 2*difFactor )
+			{
+				if ( fabs( dif ) > 24*difFactor )
+				{
+					dif = ( dif < 0 ? -24*difFactor : 24*difFactor );
+				}
+
+				NPC->client->ps.velocity[2] = (NPC->client->ps.velocity[2]+dif)/2;
+			}
+			if ( NPC->client->NPC_class == CLASS_BOBAFETT )
+			{
+				NPC->client->ps.velocity[2] *= flrand( 0.85f, 3.0f );
+			}
+		}
+	}
+	else
+	{
+		gentity_t *goal = NULL;
+
+		if ( NPCInfo->goalEntity )	// Is there a goal?
+		{
+			goal = NPCInfo->goalEntity;
+		}
+		else
+		{
+			goal = NPCInfo->lastGoalEntity;
+		}
+		if ( goal )
+		{
+			dif = goal->r.currentOrigin[2] - NPC->r.currentOrigin[2];
+
+			if ( fabs( dif ) > 24 )
+			{
+				ucmd.upmove = ( ucmd.upmove < 0 ? -4 : 4 );
+			}
+			else
+			{
+				if ( NPC->client->ps.velocity[2] )
+				{
+					NPC->client->ps.velocity[2] *= VELOCITY_DECAY;
+
+					if ( fabs( NPC->client->ps.velocity[2] ) < 2 )
+					{
+						NPC->client->ps.velocity[2] = 0;
+					}
+				}
+			}
+		}
+	}
+
+	// Apply friction
+	if ( NPC->client->ps.velocity[0] )
+	{
+		NPC->client->ps.velocity[0] *= VELOCITY_DECAY;
+
+		if ( fabs( NPC->client->ps.velocity[0] ) < 1 )
+		{
+			NPC->client->ps.velocity[0] = 0;
+		}
+	}
+
+	if ( NPC->client->ps.velocity[1] )
+	{
+		NPC->client->ps.velocity[1] *= VELOCITY_DECAY;
+
+		if ( fabs( NPC->client->ps.velocity[1] ) < 1 )
+		{
+			NPC->client->ps.velocity[1] = 0;
+		}
+	}
+}
+
+//------------------------------------
+void Seeker_Strafe( void )
+{
+	int		side;
+	vec3_t	end, right, dir;
+	trace_t	tr;
+
+	if ( random() > 0.7f || !NPC->enemy || !NPC->enemy->client )
+	{
+		// Do a regular style strafe
+		AngleVectors( NPC->client->renderInfo.eyeAngles, NULL, right, NULL );
+
+		// Pick a random strafe direction, then check to see if doing a strafe would be
+		//	reasonably valid
+		side = ( rand() & 1 ) ? -1 : 1;
+		VectorMA( NPC->r.currentOrigin, SEEKER_STRAFE_DIS * side, right, end );
+
+		trap_Trace( &tr, NPC->r.currentOrigin, NULL, NULL, end, NPC->s.number, MASK_SOLID );
+
+		// Close enough
+		if ( tr.fraction > 0.9f )
+		{
+			float vel = SEEKER_STRAFE_VEL;
+			float upPush = SEEKER_UPWARD_PUSH;
+			if ( NPC->client->NPC_class != CLASS_BOBAFETT )
+			{
+				G_Sound( NPC, CHAN_AUTO, G_SoundIndex( "sound/chars/seeker/misc/hiss" ));
+			}
+			else
+			{
+				vel *= 3.0f;
+				upPush *= 4.0f;
+			}
+			VectorMA( NPC->client->ps.velocity, vel*side, right, NPC->client->ps.velocity );
+			// Add a slight upward push
+			NPC->client->ps.velocity[2] += upPush;
+
+			NPCInfo->standTime = level.time + 1000 + random() * 500;
+		}
+	}
+	else
+	{
+		float stDis;
+
+		// Do a strafe to try and keep on the side of their enemy
+		AngleVectors( NPC->enemy->client->renderInfo.eyeAngles, dir, right, NULL );
+
+		// Pick a random side
+		side = ( rand() & 1 ) ? -1 : 1;
+		stDis = SEEKER_STRAFE_DIS;
+		if ( NPC->client->NPC_class == CLASS_BOBAFETT )
+		{
+			stDis *= 2.0f;
+		}
+		VectorMA( NPC->enemy->r.currentOrigin, stDis * side, right, end );
+
+		// then add a very small bit of random in front of/behind the player action
+		VectorMA( end, crandom() * 25, dir, end );
+
+		trap_Trace( &tr, NPC->r.currentOrigin, NULL, NULL, end, NPC->s.number, MASK_SOLID );
+
+		// Close enough
+		if ( tr.fraction > 0.9f )
+		{
+			float dis, upPush;
+
+			VectorSubtract( tr.endpos, NPC->r.currentOrigin, dir );
+			dir[2] *= 0.25; // do less upward change
+			dis = VectorNormalize( dir );
+
+			// Try to move the desired enemy side
+			VectorMA( NPC->client->ps.velocity, dis, dir, NPC->client->ps.velocity );
+
+			upPush = SEEKER_UPWARD_PUSH;
+			if ( NPC->client->NPC_class != CLASS_BOBAFETT )
+			{
+				G_Sound( NPC, CHAN_AUTO, G_SoundIndex( "sound/chars/seeker/misc/hiss" ));
+			}
+			else
+			{
+				upPush *= 4.0f;
+			}
+
+			// Add a slight upward push
+			NPC->client->ps.velocity[2] += upPush;
+
+			NPCInfo->standTime = level.time + 2500 + random() * 500;
+		}
+	}
+}
+
+//------------------------------------
+void Seeker_Hunt( qboolean visible, qboolean advance )
+{
+	float	distance, speed;
+	vec3_t	forward;
+
+	NPC_FaceEnemy( qtrue );
+
+	// If we're not supposed to stand still, pursue the player
+	if ( NPCInfo->standTime < level.time )
+	{
+		// Only strafe when we can see the player
+		if ( visible )
+		{
+			Seeker_Strafe();
+			return;
+		}
+	}
+
+	// If we don't want to advance, stop here
+	if ( advance == qfalse )
+	{
+		return;
+	}
+
+	// Only try and navigate if the player is visible
+	if ( visible == qfalse )
+	{
+		// Move towards our goal
+		NPCInfo->goalEntity = NPC->enemy;
+		NPCInfo->goalRadius = 24;
+
+		// Get our direction from the navigator if we can't see our target
+		if ( NPC_GetMoveDirection( forward, &distance ) == qfalse )
+		{
+			return;
+		}
+	}
+	else
+	{
+		VectorSubtract( NPC->enemy->r.currentOrigin, NPC->r.currentOrigin, forward );
+		distance = VectorNormalize( forward );
+	}
+
+	speed = SEEKER_FORWARD_BASE_SPEED + SEEKER_FORWARD_MULTIPLIER * g_spskill.integer;
+	VectorMA( NPC->client->ps.velocity, speed, forward, NPC->client->ps.velocity );
+}
+
+//------------------------------------
+void Seeker_Fire( void )
+{
+	vec3_t		dir, enemy_org, muzzle;
+	gentity_t	*missile;
+
+	CalcEntitySpot( NPC->enemy, SPOT_HEAD, enemy_org );
+	VectorSubtract( enemy_org, NPC->r.currentOrigin, dir );
+	VectorNormalize( dir );
+
+	// move a bit forward in the direction we shall shoot in so that the bolt doesn't poke out the other side of the seeker
+	VectorMA( NPC->r.currentOrigin, 15, dir, muzzle );
+
+	missile = CreateMissile( muzzle, dir, 1000, 10000, NPC, qfalse );
+
+	G_PlayEffectID( G_EffectIndex("blaster/muzzle_flash"), NPC->r.currentOrigin, dir );
+
+	missile->classname = "blaster";
+	missile->s.weapon = WP_BLASTER;
+
+	missile->damage = 5;
+	missile->dflags = DAMAGE_DEATH_KNOCKBACK;
+	missile->methodOfDeath = MOD_BLASTER;
+	missile->clipmask = MASK_SHOT | CONTENTS_LIGHTSABER;
+	if ( NPC->r.ownerNum < ENTITYNUM_NONE )
+	{
+		missile->r.ownerNum = NPC->r.ownerNum;
+	}
+}
+
+//------------------------------------
+void Seeker_Ranged( qboolean visible, qboolean advance )
+{
+	if ( NPC->client->NPC_class != CLASS_BOBAFETT )
+	{
+		if ( NPC->count > 0 )
+		{
+			if ( TIMER_Done( NPC, "attackDelay" ))	// Attack?
+			{
+				TIMER_Set( NPC, "attackDelay", Q_irand( 250, 2500 ));
+				Seeker_Fire();
+				NPC->count--;
+			}
+		}
+		else
+		{
+			// out of ammo, so let it die...give it a push up so it can fall more and blow up on impact
+	//		NPC->client->ps.gravity = 900;
+	//		NPC->svFlags &= ~SVF_CUSTOM_GRAVITY;
+	//		NPC->client->ps.velocity[2] += 16;
+			G_Damage( NPC, NPC, NPC, NULL, NULL, 999, 0, MOD_UNKNOWN );
+		}
+	}
+
+	if ( NPCInfo->scriptFlags & SCF_CHASE_ENEMIES )
+	{
+		Seeker_Hunt( visible, advance );
+	}
+} 
+
+//------------------------------------
+void Seeker_Attack( void )
+{
+	float		distance;
+	qboolean	visible;
+	qboolean	advance;
+
+	// Always keep a good height off the ground
+	Seeker_MaintainHeight();
+
+	// Rate our distance to the target, and our visibilty
+	distance	= DistanceHorizontalSquared( NPC->r.currentOrigin, NPC->enemy->r.currentOrigin );	
+	visible		= NPC_ClearLOS4( NPC->enemy );
+	advance		= (qboolean)(distance > MIN_DISTANCE_SQR);
+
+	if ( NPC->client->NPC_class == CLASS_BOBAFETT )
+	{
+		advance = (qboolean)(distance>(200.0f*200.0f));
+	}
+
+	// If we cannot see our target, move to see it
+	if ( visible == qfalse )
+	{
+		if ( NPCInfo->scriptFlags & SCF_CHASE_ENEMIES )
+		{
+			Seeker_Hunt( visible, advance );
+			return;
+		}
+	}
+
+	Seeker_Ranged( visible, advance );
+}
+
+//------------------------------------
+void Seeker_FindEnemy( void )
+{
+	int			numFound;
+	float		dis, bestDis = SEEKER_SEEK_RADIUS * SEEKER_SEEK_RADIUS + 1;
+	vec3_t		mins, maxs;
+	int			entityList[MAX_GENTITIES];
+	gentity_t	*ent, *best = NULL;
+	int			i;
+
+	VectorSet( maxs, SEEKER_SEEK_RADIUS, SEEKER_SEEK_RADIUS, SEEKER_SEEK_RADIUS );
+	VectorScale( maxs, -1, mins );
+
+	numFound = trap_EntitiesInBox( mins, maxs, entityList, MAX_GENTITIES );
+
+	for ( i = 0 ; i < numFound ; i++ ) 
+	{
+		ent = &g_entities[entityList[i]];
+
+		if ( ent->s.number == NPC->s.number 
+			|| !ent->client //&& || !ent->NPC 
+			|| ent->health <= 0 
+			|| !ent->inuse )
+		{
+			continue;
+		}
+
+		if ( ent->client->playerTeam == NPC->client->playerTeam || ent->client->playerTeam == NPCTEAM_NEUTRAL ) // don't attack same team or bots
+		{
+			continue;
+		}
+
+		// try to find the closest visible one
+		if ( !NPC_ClearLOS4( ent ))
+		{
+			continue;
+		}
+
+		dis = DistanceHorizontalSquared( NPC->r.currentOrigin, ent->r.currentOrigin );
+
+		if ( dis <= bestDis )
+		{
+			bestDis = dis;
+			best = ent;
+		}
+	}
+
+	if ( best )
+	{
+		// used to offset seekers around a circle so they don't occupy the same spot.  This is not a fool-proof method.
+		NPC->random = random() * 6.3f; // roughly 2pi
+
+		NPC->enemy = best;
+	}
+}
+
+//------------------------------------
+void Seeker_FollowOwner( void )
+{
+	float	dis, minDistSqr;
+	vec3_t	pt, dir;
+	gentity_t	*owner = &g_entities[NPC->s.owner];
+
+	Seeker_MaintainHeight();
+
+	if ( NPC->client->NPC_class == CLASS_BOBAFETT )
+	{
+		owner = NPC->enemy;
+	}
+	if ( !owner || owner == NPC || !owner->client )
+	{
+		return;
+	}
+	//rwwFIXMEFIXME: Care about all clients not just 0
+	dis	= DistanceHorizontalSquared( NPC->r.currentOrigin, owner->r.currentOrigin );
+	
+	minDistSqr = MIN_DISTANCE_SQR;
+
+	if ( NPC->client->NPC_class == CLASS_BOBAFETT )
+	{
+		if ( TIMER_Done( NPC, "flameTime" ) )
+		{
+			minDistSqr = 200*200;
+		}
+	}
+
+	if ( dis < minDistSqr )
+	{
+		// generally circle the player closely till we take an enemy..this is our target point
+		if ( NPC->client->NPC_class == CLASS_BOBAFETT )
+		{
+			pt[0] = owner->r.currentOrigin[0] + cos( level.time * 0.001f + NPC->random ) * 250;
+			pt[1] = owner->r.currentOrigin[1] + sin( level.time * 0.001f + NPC->random ) * 250;
+			if ( NPC->client->jetPackTime < level.time )
+			{
+				pt[2] = NPC->r.currentOrigin[2] - 64;
+			}
+			else
+			{
+				pt[2] = owner->r.currentOrigin[2] + 200;
+			}
+		}
+		else
+		{
+			pt[0] = owner->r.currentOrigin[0] + cos( level.time * 0.001f + NPC->random ) * 56;
+			pt[1] = owner->r.currentOrigin[1] + sin( level.time * 0.001f + NPC->random ) * 56;
+			pt[2] = owner->r.currentOrigin[2] + 40;
+		}
+
+		VectorSubtract( pt, NPC->r.currentOrigin, dir );
+		VectorMA( NPC->client->ps.velocity, 0.8f, dir, NPC->client->ps.velocity );
+	}
+	else
+	{
+		if ( NPC->client->NPC_class != CLASS_BOBAFETT )
+		{
+			if ( TIMER_Done( NPC, "seekerhiss" ))
+			{
+				TIMER_Set( NPC, "seekerhiss", 1000 + random() * 1000 );
+				G_Sound( NPC, CHAN_AUTO, G_SoundIndex( "sound/chars/seeker/misc/hiss" ));
+			}
+		}
+
+		// Hey come back!
+		NPCInfo->goalEntity = owner;
+		NPCInfo->goalRadius = 32;
+		NPC_MoveToGoal( qtrue );
+		NPC->parent = owner;
+	}
+
+	if ( NPCInfo->enemyCheckDebounceTime < level.time )
+	{
+		// check twice a second to find a new enemy
+		Seeker_FindEnemy();
+		NPCInfo->enemyCheckDebounceTime = level.time + 500;
+	}
+
+	NPC_UpdateAngles( qtrue, qtrue );
+}
+
+//------------------------------------
+void NPC_BSSeeker_Default( void )
+{
+	/*
+	if ( in_camera )
+	{
+		if ( NPC->client->NPC_class != CLASS_BOBAFETT )
+		{
+			// cameras make me commit suicide....
+			G_Damage( NPC, NPC, NPC, NULL, NULL, 999, 0, MOD_UNKNOWN );
+		}
+	}
+	*/
+	//N/A for MP.
+	if ( NPC->r.ownerNum < ENTITYNUM_NONE )
+	{
+		gentity_t *owner = &g_entities[0];
+		if ( owner->health <= 0 
+			|| (owner->client && owner->client->pers.connected == CON_DISCONNECTED) )
+		{//owner is dead or gone
+			//remove me
+			G_Damage( NPC, NULL, NULL, NULL, NULL, 10000, DAMAGE_NO_PROTECTION, MOD_TELEFRAG );
+			return;
+		}
+	}
+
+	if ( NPC->random == 0.0f )
+	{
+		// used to offset seekers around a circle so they don't occupy the same spot.  This is not a fool-proof method.
+		NPC->random = random() * 6.3f; // roughly 2pi
+	}
+
+	if ( NPC->enemy && NPC->enemy->health && NPC->enemy->inuse )
+	{
+		if ( NPC->client->NPC_class != CLASS_BOBAFETT && ( NPC->enemy->s.number == 0 || ( NPC->enemy->client && NPC->enemy->client->NPC_class == CLASS_SEEKER )) )
+		{
+			//hacked to never take the player as an enemy, even if the player shoots at it
+			NPC->enemy = NULL;
+		}
+		else
+		{
+			Seeker_Attack();
+			if ( NPC->client->NPC_class == CLASS_BOBAFETT )
+			{
+				Boba_FireDecide();
+			}
+			return;
+		}
+	}
+
+	// In all other cases, follow the player and look for enemies to take on
+	Seeker_FollowOwner();
+}
diff --git a/codemp/game/NPC_AI_Sentry.c b/codemp/game/NPC_AI_Sentry.c
new file mode 100644
index 0000000..85fc701
--- /dev/null
+++ b/codemp/game/NPC_AI_Sentry.c
@@ -0,0 +1,577 @@
+#include "b_local.h"
+#include "g_nav.h"
+
+#include "../namespace_begin.h"
+extern gitem_t	*BG_FindItemForAmmo( ammo_t ammo );
+#include "../namespace_end.h"
+extern void G_SoundOnEnt( gentity_t *ent, soundChannel_t channel, const char *soundPath );
+
+#define MIN_DISTANCE		256
+#define MIN_DISTANCE_SQR	( MIN_DISTANCE * MIN_DISTANCE )
+
+#define SENTRY_FORWARD_BASE_SPEED	10
+#define SENTRY_FORWARD_MULTIPLIER	5
+
+#define SENTRY_VELOCITY_DECAY	0.85f
+#define SENTRY_STRAFE_VEL		256
+#define SENTRY_STRAFE_DIS		200
+#define SENTRY_UPWARD_PUSH		32
+#define SENTRY_HOVER_HEIGHT		24
+
+//Local state enums
+enum
+{
+	LSTATE_NONE = 0,
+	LSTATE_ASLEEP,
+	LSTATE_WAKEUP,
+	LSTATE_ACTIVE,
+	LSTATE_POWERING_UP,
+	LSTATE_ATTACKING,
+};
+
+/*
+-------------------------
+NPC_Sentry_Precache
+-------------------------
+*/
+void NPC_Sentry_Precache(void)
+{
+	int i;
+
+	G_SoundIndex( "sound/chars/sentry/misc/sentry_explo" );
+	G_SoundIndex( "sound/chars/sentry/misc/sentry_pain" );
+	G_SoundIndex( "sound/chars/sentry/misc/sentry_shield_open" );
+	G_SoundIndex( "sound/chars/sentry/misc/sentry_shield_close" );
+	G_SoundIndex( "sound/chars/sentry/misc/sentry_hover_1_lp" );
+	G_SoundIndex( "sound/chars/sentry/misc/sentry_hover_2_lp" );
+
+	for ( i = 1; i < 4; i++)
+	{
+		G_SoundIndex( va( "sound/chars/sentry/misc/talk%d", i ) );
+	}
+
+	G_EffectIndex( "bryar/muzzle_flash");
+	G_EffectIndex( "env/med_explode");
+
+	RegisterItem( BG_FindItemForAmmo( AMMO_BLASTER ));
+}
+
+/*
+================
+sentry_use
+================
+*/
+void sentry_use( gentity_t *self, gentity_t *other, gentity_t *activator)
+{
+	G_ActivateBehavior(self,BSET_USE);
+
+	self->flags &= ~FL_SHIELDED;
+	NPC_SetAnim( self, SETANIM_BOTH, BOTH_POWERUP1, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+//	self->NPC->localState = LSTATE_WAKEUP;
+	self->NPC->localState = LSTATE_ACTIVE;
+}
+
+/*
+-------------------------
+NPC_Sentry_Pain
+-------------------------
+*/
+void NPC_Sentry_Pain(gentity_t *self, gentity_t *attacker, int damage)
+{		
+	int mod = gPainMOD;
+
+	NPC_Pain( self, attacker, damage );
+
+	if ( mod == MOD_DEMP2 || mod == MOD_DEMP2_ALT )
+	{
+		self->NPC->burstCount = 0;
+		TIMER_Set( self, "attackDelay", Q_irand( 9000, 12000) );
+		self->flags |= FL_SHIELDED;
+		NPC_SetAnim( self, SETANIM_BOTH, BOTH_FLY_SHIELDED, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+		G_Sound( self, CHAN_AUTO, G_SoundIndex("sound/chars/sentry/misc/sentry_pain") );		
+
+		self->NPC->localState = LSTATE_ACTIVE;
+	}
+
+	// You got hit, go after the enemy
+//	if (self->NPC->localState == LSTATE_ASLEEP)
+//	{
+//		G_Sound( self, G_SoundIndex("sound/chars/sentry/misc/shieldsopen.wav"));
+//
+//		self->flags &= ~FL_SHIELDED;
+//		NPC_SetAnim( self, SETANIM_BOTH, BOTH_POWERUP1, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+//		self->NPC->localState = LSTATE_WAKEUP;
+//	}
+}
+
+/*
+-------------------------
+Sentry_Fire
+-------------------------
+*/
+void Sentry_Fire (void)
+{
+	vec3_t	muzzle;
+	static	vec3_t	forward, vright, up;
+	gentity_t	*missile;
+	mdxaBone_t	boltMatrix;
+	int			bolt;
+	int			which;
+
+	NPC->flags &= ~FL_SHIELDED;
+
+	if ( NPCInfo->localState == LSTATE_POWERING_UP )
+	{
+		if ( TIMER_Done( NPC, "powerup" ))
+		{
+			NPCInfo->localState = LSTATE_ATTACKING;
+			NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_ATTACK1, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+		}
+		else
+		{
+			// can't do anything right now
+			return;
+		}
+	}
+	else if ( NPCInfo->localState == LSTATE_ACTIVE )
+	{
+		NPCInfo->localState = LSTATE_POWERING_UP;
+
+		G_Sound( NPC, CHAN_AUTO, G_SoundIndex("sound/chars/sentry/misc/sentry_shield_open") );		
+		NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_POWERUP1, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+		TIMER_Set( NPC, "powerup", 250 );
+		return;
+	}
+	else if ( NPCInfo->localState != LSTATE_ATTACKING )
+	{
+		// bad because we are uninitialized
+		NPCInfo->localState = LSTATE_ACTIVE;
+		return;
+	}
+
+	// Which muzzle to fire from?
+	which = NPCInfo->burstCount % 3;
+	switch( which )
+	{
+	case 0:
+		bolt = trap_G2API_AddBolt(NPC->ghoul2, 0, "*flash1");
+		break;
+	case 1:
+		bolt = trap_G2API_AddBolt(NPC->ghoul2, 0, "*flash2");
+		break;
+	case 2:
+	default:
+		bolt = trap_G2API_AddBolt(NPC->ghoul2, 0, "*flash03");
+	}
+
+	trap_G2API_GetBoltMatrix( NPC->ghoul2, 0, 
+				bolt,
+				&boltMatrix, NPC->r.currentAngles, NPC->r.currentOrigin, level.time,
+				NULL, NPC->modelScale );
+
+	BG_GiveMeVectorFromMatrix( &boltMatrix, ORIGIN, muzzle );
+
+	AngleVectors( NPC->r.currentAngles, forward, vright, up );
+//	G_Sound( NPC, G_SoundIndex("sound/chars/sentry/misc/shoot.wav"));
+
+	G_PlayEffectID( G_EffectIndex("bryar/muzzle_flash"), muzzle, forward );
+
+	missile = CreateMissile( muzzle, forward, 1600, 10000, NPC, qfalse );
+
+	missile->classname = "bryar_proj";
+	missile->s.weapon = WP_BRYAR_PISTOL;
+
+	missile->dflags = DAMAGE_DEATH_KNOCKBACK;
+	missile->methodOfDeath = MOD_BRYAR_PISTOL;
+	missile->clipmask = MASK_SHOT | CONTENTS_LIGHTSABER;
+
+	NPCInfo->burstCount++;
+	NPC->attackDebounceTime = level.time + 50;
+	missile->damage = 5;
+
+	// now scale for difficulty
+	if ( g_spskill.integer == 0 )
+	{
+		NPC->attackDebounceTime += 200;
+		missile->damage = 1;
+	}
+	else if ( g_spskill.integer == 1 )
+	{
+		NPC->attackDebounceTime += 100;
+		missile->damage = 3;
+	}
+}
+
+/*
+-------------------------
+Sentry_MaintainHeight
+-------------------------
+*/
+void Sentry_MaintainHeight( void )
+{	
+	float	dif;
+
+	NPC->s.loopSound = G_SoundIndex( "sound/chars/sentry/misc/sentry_hover_1_lp" );
+
+	// Update our angles regardless
+	NPC_UpdateAngles( qtrue, qtrue );
+
+	// If we have an enemy, we should try to hover at about enemy eye level
+	if ( NPC->enemy )
+	{
+		// Find the height difference
+		dif = (NPC->enemy->r.currentOrigin[2]+NPC->enemy->r.maxs[2]) - NPC->r.currentOrigin[2]; 
+
+		// cap to prevent dramatic height shifts
+		if ( fabs( dif ) > 8 )
+		{
+			if ( fabs( dif ) > SENTRY_HOVER_HEIGHT )
+			{
+				dif = ( dif < 0 ? -24 : 24 );
+			}
+
+			NPC->client->ps.velocity[2] = (NPC->client->ps.velocity[2]+dif)/2;
+		}
+	}
+	else
+	{
+		gentity_t *goal = NULL;
+
+		if ( NPCInfo->goalEntity )	// Is there a goal?
+		{
+			goal = NPCInfo->goalEntity;
+		}
+		else
+		{
+			goal = NPCInfo->lastGoalEntity;
+		}
+
+		if (goal)
+		{
+			dif = goal->r.currentOrigin[2] - NPC->r.currentOrigin[2];
+
+			if ( fabs( dif ) > SENTRY_HOVER_HEIGHT )
+			{
+				ucmd.upmove = ( ucmd.upmove < 0 ? -4 : 4 );
+			}
+			else
+			{
+				if ( NPC->client->ps.velocity[2] )
+				{
+					NPC->client->ps.velocity[2] *= SENTRY_VELOCITY_DECAY;
+
+					if ( fabs( NPC->client->ps.velocity[2] ) < 2 )
+					{
+						NPC->client->ps.velocity[2] = 0;
+					}
+				}
+			}
+		}
+		// Apply friction to Z
+		else if ( NPC->client->ps.velocity[2] )
+		{
+			NPC->client->ps.velocity[2] *= SENTRY_VELOCITY_DECAY;
+
+			if ( fabs( NPC->client->ps.velocity[2] ) < 1 )
+			{
+				NPC->client->ps.velocity[2] = 0;
+			}
+		}
+	}
+
+	// Apply friction
+	if ( NPC->client->ps.velocity[0] )
+	{
+		NPC->client->ps.velocity[0] *= SENTRY_VELOCITY_DECAY;
+
+		if ( fabs( NPC->client->ps.velocity[0] ) < 1 )
+		{
+			NPC->client->ps.velocity[0] = 0;
+		}
+	}
+
+	if ( NPC->client->ps.velocity[1] )
+	{
+		NPC->client->ps.velocity[1] *= SENTRY_VELOCITY_DECAY;
+
+		if ( fabs( NPC->client->ps.velocity[1] ) < 1 )
+		{
+			NPC->client->ps.velocity[1] = 0;
+		}
+	}
+
+	NPC_FaceEnemy( qtrue );
+}
+
+/*
+-------------------------
+Sentry_Idle
+-------------------------
+*/
+void Sentry_Idle( void )
+{
+	Sentry_MaintainHeight();
+
+	// Is he waking up?
+	if (NPCInfo->localState == LSTATE_WAKEUP)
+	{
+		if (NPC->client->ps.torsoTimer<=0)
+		{
+			NPCInfo->scriptFlags |= SCF_LOOK_FOR_ENEMIES;
+			NPCInfo->burstCount = 0;
+		}
+	}
+	else
+	{
+		NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_SLEEP1, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+		NPC->flags |= FL_SHIELDED;
+
+		NPC_BSIdle();
+	}
+}
+
+/*
+-------------------------
+Sentry_Strafe
+-------------------------
+*/
+void Sentry_Strafe( void )
+{
+	int		dir;
+	vec3_t	end, right;
+	trace_t	tr;
+
+	AngleVectors( NPC->client->renderInfo.eyeAngles, NULL, right, NULL );
+
+	// Pick a random strafe direction, then check to see if doing a strafe would be
+	//	reasonable valid
+	dir = ( rand() & 1 ) ? -1 : 1;
+	VectorMA( NPC->r.currentOrigin, SENTRY_STRAFE_DIS * dir, right, end );
+
+	trap_Trace( &tr, NPC->r.currentOrigin, NULL, NULL, end, NPC->s.number, MASK_SOLID );
+
+	// Close enough
+	if ( tr.fraction > 0.9f )
+	{
+		VectorMA( NPC->client->ps.velocity, SENTRY_STRAFE_VEL * dir, right, NPC->client->ps.velocity );
+
+		// Add a slight upward push
+		NPC->client->ps.velocity[2] += SENTRY_UPWARD_PUSH;
+
+		// Set the strafe start time so we can do a controlled roll
+	//	NPC->fx_time = level.time;
+		NPCInfo->standTime = level.time + 3000 + random() * 500;
+	}
+}
+
+/*
+-------------------------
+Sentry_Hunt
+-------------------------
+*/
+void Sentry_Hunt( qboolean visible, qboolean advance )
+{
+	float	distance, speed;
+	vec3_t	forward;
+
+	//If we're not supposed to stand still, pursue the player
+	if ( NPCInfo->standTime < level.time )
+	{
+		// Only strafe when we can see the player
+		if ( visible )
+		{
+			Sentry_Strafe();
+			return;
+		}
+	}
+
+	//If we don't want to advance, stop here
+	if ( !advance && visible )
+		return;
+
+	//Only try and navigate if the player is visible
+	if ( visible == qfalse )
+	{
+		// Move towards our goal
+		NPCInfo->goalEntity = NPC->enemy;
+		NPCInfo->goalRadius = 12;
+
+		//Get our direction from the navigator if we can't see our target
+		if ( NPC_GetMoveDirection( forward, &distance ) == qfalse )
+			return;
+	}
+	else
+	{
+		VectorSubtract( NPC->enemy->r.currentOrigin, NPC->r.currentOrigin, forward );
+		distance = VectorNormalize( forward );
+	}
+
+	speed = SENTRY_FORWARD_BASE_SPEED + SENTRY_FORWARD_MULTIPLIER * g_spskill.integer;
+	VectorMA( NPC->client->ps.velocity, speed, forward, NPC->client->ps.velocity );
+}
+
+/*
+-------------------------
+Sentry_RangedAttack
+-------------------------
+*/
+void Sentry_RangedAttack( qboolean visible, qboolean advance )
+{
+	if ( TIMER_Done( NPC, "attackDelay" ) && NPC->attackDebounceTime < level.time && visible )	// Attack?
+	{
+		if ( NPCInfo->burstCount > 6 )
+		{
+			if ( !NPC->fly_sound_debounce_time )
+			{//delay closing down to give the player an opening
+				NPC->fly_sound_debounce_time = level.time + Q_irand( 500, 2000 );
+			}
+			else if ( NPC->fly_sound_debounce_time < level.time )
+			{
+				NPCInfo->localState = LSTATE_ACTIVE;
+				NPC->fly_sound_debounce_time = NPCInfo->burstCount = 0;
+				TIMER_Set( NPC, "attackDelay", Q_irand( 2000, 3500) );
+				NPC->flags |= FL_SHIELDED;
+				NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_FLY_SHIELDED, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+				G_SoundOnEnt( NPC, CHAN_AUTO, "sound/chars/sentry/misc/sentry_shield_close" );
+			}
+		}
+		else
+		{
+			Sentry_Fire();
+		}
+	}
+
+	if ( NPCInfo->scriptFlags & SCF_CHASE_ENEMIES )
+	{
+		Sentry_Hunt( visible, advance );
+	}
+}
+
+/*
+-------------------------
+Sentry_AttackDecision
+-------------------------
+*/
+void Sentry_AttackDecision( void )
+{
+	float		distance;	
+	qboolean	visible;
+	qboolean	advance;
+
+	// Always keep a good height off the ground
+	Sentry_MaintainHeight();
+
+	NPC->s.loopSound = G_SoundIndex( "sound/chars/sentry/misc/sentry_hover_2_lp" );
+
+	//randomly talk
+	if ( TIMER_Done(NPC,"patrolNoise") )
+	{
+		if (TIMER_Done(NPC,"angerNoise"))
+		{
+			G_SoundOnEnt( NPC, CHAN_AUTO, va("sound/chars/sentry/misc/talk%d", Q_irand(1, 3)) );
+
+			TIMER_Set( NPC, "patrolNoise", Q_irand( 4000, 10000 ) );
+		}
+	}
+
+	// He's dead.
+	if (NPC->enemy->health<1)
+	{
+		NPC->enemy = NULL;
+		Sentry_Idle();
+		return;
+	}
+
+	// If we don't have an enemy, just idle
+	if ( NPC_CheckEnemyExt(qfalse) == qfalse )
+	{
+		Sentry_Idle();
+		return;
+	}
+
+	// Rate our distance to the target and visibilty
+	distance	= (int) DistanceHorizontalSquared( NPC->r.currentOrigin, NPC->enemy->r.currentOrigin );	
+	visible		= NPC_ClearLOS4( NPC->enemy );
+	advance		= (qboolean)(distance > MIN_DISTANCE_SQR);
+
+	// If we cannot see our target, move to see it
+	if ( visible == qfalse )
+	{
+		if ( NPCInfo->scriptFlags & SCF_CHASE_ENEMIES )
+		{
+			Sentry_Hunt( visible, advance );
+			return;
+		}
+	}
+
+	NPC_FaceEnemy( qtrue );
+
+	Sentry_RangedAttack( visible, advance );
+}
+
+qboolean NPC_CheckPlayerTeamStealth( void );
+
+/*
+-------------------------
+NPC_Sentry_Patrol
+-------------------------
+*/
+void NPC_Sentry_Patrol( void )
+{
+	Sentry_MaintainHeight();
+
+	//If we have somewhere to go, then do that
+	if (!NPC->enemy)
+	{
+		if ( NPC_CheckPlayerTeamStealth() )
+		{
+			//NPC_AngerSound();
+			NPC_UpdateAngles( qtrue, qtrue );
+			return;
+		}
+
+		if ( UpdateGoal() )
+		{
+			//start loop sound once we move
+			ucmd.buttons |= BUTTON_WALKING;
+			NPC_MoveToGoal( qtrue );
+		}
+
+		//randomly talk
+		if (TIMER_Done(NPC,"patrolNoise"))
+		{
+			G_SoundOnEnt( NPC, CHAN_AUTO, va("sound/chars/sentry/misc/talk%d", Q_irand(1, 3)) );
+
+			TIMER_Set( NPC, "patrolNoise", Q_irand( 2000, 4000 ) );
+		}
+	}
+
+	NPC_UpdateAngles( qtrue, qtrue );
+}
+
+/*
+-------------------------
+NPC_BSSentry_Default
+-------------------------
+*/
+void NPC_BSSentry_Default( void )
+{
+	if ( NPC->targetname )
+	{
+		NPC->use = sentry_use;
+	}
+
+	if (( NPC->enemy ) && (NPCInfo->localState != LSTATE_WAKEUP))
+	{
+		// Don't attack if waking up or if no enemy
+		Sentry_AttackDecision();
+	}
+	else if ( NPCInfo->scriptFlags & SCF_LOOK_FOR_ENEMIES )
+	{
+		NPC_Sentry_Patrol();
+	}
+	else
+	{
+		Sentry_Idle();
+	}
+}
diff --git a/codemp/game/NPC_AI_Sniper.c b/codemp/game/NPC_AI_Sniper.c
new file mode 100644
index 0000000..cb3b9c3
--- /dev/null
+++ b/codemp/game/NPC_AI_Sniper.c
@@ -0,0 +1,864 @@
+#include "b_local.h"
+#include "g_nav.h"
+#include "anims.h"
+
+extern void G_AddVoiceEvent( gentity_t *self, int event, int speakDebounceTime );
+extern void G_SoundOnEnt( gentity_t *ent, soundChannel_t channel, const char *soundPath );
+extern void NPC_TempLookTarget( gentity_t *self, int lookEntNum, int minLookTime, int maxLookTime );
+extern qboolean G_ExpandPointToBBox( vec3_t point, const vec3_t mins, const vec3_t maxs, int ignore, int clipmask );
+extern qboolean FlyingCreature( gentity_t *ent );
+
+#define	SPF_NO_HIDE			2
+
+#define	MAX_VIEW_DIST		1024
+#define MAX_VIEW_SPEED		250
+#define	MAX_LIGHT_INTENSITY 255
+#define	MIN_LIGHT_THRESHOLD	0.1
+
+#define	DISTANCE_SCALE		0.25f
+#define	DISTANCE_THRESHOLD	0.075f
+#define	SPEED_SCALE			0.25f
+#define	FOV_SCALE			0.5f
+#define	LIGHT_SCALE			0.25f
+
+#define	REALIZE_THRESHOLD	0.6f
+#define CAUTIOUS_THRESHOLD	( REALIZE_THRESHOLD * 0.75 )
+
+qboolean NPC_CheckPlayerTeamStealth( void );
+
+static qboolean enemyLOS2;
+static qboolean enemyCS2;
+static qboolean faceEnemy2;
+static qboolean move2;
+static qboolean shoot2;
+static float	enemyDist2;
+
+//Local state enums
+enum
+{
+	LSTATE_NONE = 0,
+	LSTATE_UNDERFIRE,
+	LSTATE_INVESTIGATE,
+};
+
+void Sniper_ClearTimers( gentity_t *ent )
+{
+	TIMER_Set( ent, "chatter", 0 );
+	TIMER_Set( ent, "duck", 0 );
+	TIMER_Set( ent, "stand", 0 );
+	TIMER_Set( ent, "shuffleTime", 0 );
+	TIMER_Set( ent, "sleepTime", 0 );
+	TIMER_Set( ent, "enemyLastVisible", 0 );
+	TIMER_Set( ent, "roamTime", 0 );
+	TIMER_Set( ent, "hideTime", 0 );
+	TIMER_Set( ent, "attackDelay", 0 );	//FIXME: Slant for difficulty levels
+	TIMER_Set( ent, "stick", 0 );
+	TIMER_Set( ent, "scoutTime", 0 );
+	TIMER_Set( ent, "flee", 0 );
+}
+
+void NPC_Sniper_PlayConfusionSound( gentity_t *self )
+{//FIXME: make this a custom sound in sound set
+	if ( self->health > 0 )
+	{
+		G_AddVoiceEvent( self, Q_irand(EV_CONFUSE1, EV_CONFUSE3), 2000 );
+	}
+	//reset him to be totally unaware again
+	TIMER_Set( self, "enemyLastVisible", 0 );
+	TIMER_Set( self, "flee", 0 );
+	self->NPC->squadState = SQUAD_IDLE;
+	self->NPC->tempBehavior = BS_DEFAULT;
+
+	//self->NPC->behaviorState = BS_PATROL;
+	G_ClearEnemy( self );//FIXME: or just self->enemy = NULL;?
+
+	self->NPC->investigateCount = 0;
+}
+
+
+/*
+-------------------------
+NPC_ST_Pain
+-------------------------
+*/
+
+void NPC_Sniper_Pain(gentity_t *self, gentity_t *attacker, int damage)
+{
+	self->NPC->localState = LSTATE_UNDERFIRE;
+
+	TIMER_Set( self, "duck", -1 );
+	TIMER_Set( self, "stand", 2000 );
+
+	NPC_Pain( self, attacker, damage );
+
+	if ( !damage && self->health > 0 )
+	{//FIXME: better way to know I was pushed
+		G_AddVoiceEvent( self, Q_irand(EV_PUSHED1, EV_PUSHED3), 2000 );
+	}
+}
+
+/*
+-------------------------
+ST_HoldPosition
+-------------------------
+*/
+
+static void Sniper_HoldPosition( void )
+{
+	NPC_FreeCombatPoint( NPCInfo->combatPoint, qtrue );
+	NPCInfo->goalEntity = NULL;
+	
+	/*if ( TIMER_Done( NPC, "stand" ) )
+	{//FIXME: what if can't shoot from this pos?
+		TIMER_Set( NPC, "duck", Q_irand( 2000, 4000 ) );
+	}
+	*/
+}
+
+/*
+-------------------------
+ST_Move
+-------------------------
+*/
+
+static qboolean Sniper_Move( void )
+{
+	qboolean	moved;
+	navInfo_t	info;
+
+	NPCInfo->combatMove = qtrue;//always move straight toward our goal
+
+	moved = NPC_MoveToGoal( qtrue );
+	
+	//Get the move info
+	NAV_GetLastMove( &info );
+
+	//FIXME: if we bump into another one of our guys and can't get around him, just stop!
+	//If we hit our target, then stop and fire!
+	if ( info.flags & NIF_COLLISION ) 
+	{
+		if ( info.blocker == NPC->enemy )
+		{
+			Sniper_HoldPosition();
+		}
+	}
+
+	//If our move failed, then reset
+	if ( moved == qfalse )
+	{//couldn't get to enemy
+		if ( (NPCInfo->scriptFlags&SCF_CHASE_ENEMIES) && NPCInfo->goalEntity && NPCInfo->goalEntity == NPC->enemy )
+		{//we were running after enemy
+			//Try to find a combat point that can hit the enemy
+			int cpFlags = (CP_CLEAR|CP_HAS_ROUTE);
+			int cp;
+			if ( NPCInfo->scriptFlags&SCF_USE_CP_NEAREST )
+			{
+				cpFlags &= ~(CP_FLANK|CP_APPROACH_ENEMY|CP_CLOSEST);
+				cpFlags |= CP_NEAREST;
+			}
+			cp = NPC_FindCombatPoint( NPC->r.currentOrigin, NPC->r.currentOrigin, NPC->r.currentOrigin, cpFlags, 32, -1 );
+			if ( cp == -1 && !(NPCInfo->scriptFlags&SCF_USE_CP_NEAREST) )
+			{//okay, try one by the enemy
+				cp = NPC_FindCombatPoint( NPC->r.currentOrigin, NPC->r.currentOrigin, NPC->enemy->r.currentOrigin, CP_CLEAR|CP_HAS_ROUTE|CP_HORZ_DIST_COLL, 32, -1 );
+			}
+			//NOTE: there may be a perfectly valid one, just not one within CP_COLLECT_RADIUS of either me or him...
+			if ( cp != -1 )
+			{//found a combat point that has a clear shot to enemy
+				NPC_SetCombatPoint( cp );
+				NPC_SetMoveGoal( NPC, level.combatPoints[cp].origin, 8, qtrue, cp, NULL );
+				return moved;
+			}
+		}
+		//just hang here
+		Sniper_HoldPosition();
+	}
+
+	return moved;
+}
+
+/*
+-------------------------
+NPC_BSSniper_Patrol
+-------------------------
+*/
+
+void NPC_BSSniper_Patrol( void )
+{//FIXME: pick up on bodies of dead buddies?
+	NPC->count = 0;
+
+	if ( NPCInfo->confusionTime < level.time )
+	{
+		//Look for any enemies
+		if ( NPCInfo->scriptFlags&SCF_LOOK_FOR_ENEMIES )
+		{
+			if ( NPC_CheckPlayerTeamStealth() )
+			{
+				//NPCInfo->behaviorState = BS_HUNT_AND_KILL;//Should be auto now
+				//NPC_AngerSound();
+				NPC_UpdateAngles( qtrue, qtrue );
+				return;
+			}
+		}
+
+		if ( !(NPCInfo->scriptFlags&SCF_IGNORE_ALERTS) )
+		{
+			//Is there danger nearby
+			int alertEvent = NPC_CheckAlertEvents( qtrue, qtrue, -1, qfalse, AEL_SUSPICIOUS );
+			if ( NPC_CheckForDanger( alertEvent ) )
+			{
+				NPC_UpdateAngles( qtrue, qtrue );
+				return;
+			}
+			else
+			{//check for other alert events
+				//There is an event to look at
+				if ( alertEvent >= 0 && level.alertEvents[alertEvent].ID != NPCInfo->lastAlertID )
+				{
+					NPCInfo->lastAlertID = level.alertEvents[alertEvent].ID;
+					if ( level.alertEvents[alertEvent].level == AEL_DISCOVERED )
+					{
+						if ( level.alertEvents[alertEvent].owner && 
+							level.alertEvents[alertEvent].owner->client && 
+							level.alertEvents[alertEvent].owner->health >= 0 &&
+							level.alertEvents[alertEvent].owner->client->playerTeam == NPC->client->enemyTeam )
+						{//an enemy
+							G_SetEnemy( NPC, level.alertEvents[alertEvent].owner );
+							//NPCInfo->enemyLastSeenTime = level.time;
+							TIMER_Set( NPC, "attackDelay", Q_irand( (6-NPCInfo->stats.aim)*100, (6-NPCInfo->stats.aim)*500 ) );
+						}
+					}
+					else
+					{//FIXME: get more suspicious over time?
+						//Save the position for movement (if necessary)
+						//FIXME: sound?
+						VectorCopy( level.alertEvents[alertEvent].position, NPCInfo->investigateGoal );
+						NPCInfo->investigateDebounceTime = level.time + Q_irand( 500, 1000 );
+						if ( level.alertEvents[alertEvent].level == AEL_SUSPICIOUS )
+						{//suspicious looks longer
+							NPCInfo->investigateDebounceTime += Q_irand( 500, 2500 );
+						}
+					}
+				}
+			}
+
+			if ( NPCInfo->investigateDebounceTime > level.time )
+			{//FIXME: walk over to it, maybe?  Not if not chase enemies flag
+				//NOTE: stops walking or doing anything else below
+				vec3_t	dir, angles;
+				float	o_yaw, o_pitch;
+				
+				VectorSubtract( NPCInfo->investigateGoal, NPC->client->renderInfo.eyePoint, dir );
+				vectoangles( dir, angles );
+				
+				o_yaw = NPCInfo->desiredYaw;
+				o_pitch = NPCInfo->desiredPitch;
+				NPCInfo->desiredYaw = angles[YAW];
+				NPCInfo->desiredPitch = angles[PITCH];
+				
+				NPC_UpdateAngles( qtrue, qtrue );
+
+				NPCInfo->desiredYaw = o_yaw;
+				NPCInfo->desiredPitch = o_pitch;
+				return;
+			}
+		}
+	}
+
+	//If we have somewhere to go, then do that
+	if ( UpdateGoal() )
+	{
+		ucmd.buttons |= BUTTON_WALKING;
+		NPC_MoveToGoal( qtrue );
+	}
+
+	NPC_UpdateAngles( qtrue, qtrue );
+}
+
+/*
+-------------------------
+NPC_BSSniper_Idle
+-------------------------
+*/
+/*
+void NPC_BSSniper_Idle( void )
+{
+	//reset our shotcount
+	NPC->count = 0;
+
+	//FIXME: check for other alert events?
+
+	//Is there danger nearby?
+	if ( NPC_CheckForDanger( NPC_CheckAlertEvents( qtrue, qtrue ) ) )
+	{
+		NPC_UpdateAngles( qtrue, qtrue );
+		return;
+	}
+
+	TIMER_Set( NPC, "roamTime", 2000 + Q_irand( 1000, 2000 ) );
+
+	NPC_UpdateAngles( qtrue, qtrue );
+}
+*/
+/*
+-------------------------
+ST_CheckMoveState
+-------------------------
+*/
+
+static void Sniper_CheckMoveState( void )
+{
+	//See if we're a scout
+	if ( !(NPCInfo->scriptFlags & SCF_CHASE_ENEMIES) )//NPCInfo->behaviorState == BS_STAND_AND_SHOOT )
+	{
+		if ( NPCInfo->goalEntity == NPC->enemy )
+		{
+			move2 = qfalse;
+			return;
+		}
+	}
+	//See if we're running away
+	else if ( NPCInfo->squadState == SQUAD_RETREAT )
+	{
+		if ( TIMER_Done( NPC, "flee" ) )
+		{
+			NPCInfo->squadState = SQUAD_IDLE;
+		}
+		else
+		{
+			faceEnemy2 = qfalse;
+		}
+	}
+	else if ( NPCInfo->squadState == SQUAD_IDLE )
+	{
+		if ( !NPCInfo->goalEntity )
+		{
+			move2 = qfalse;
+			return;
+		}
+	}
+
+	//See if we're moving towards a goal, not the enemy
+	if ( ( NPCInfo->goalEntity != NPC->enemy ) && ( NPCInfo->goalEntity != NULL ) )
+	{
+		//Did we make it?
+		if ( NAV_HitNavGoal( NPC->r.currentOrigin, NPC->r.mins, NPC->r.maxs, NPCInfo->goalEntity->r.currentOrigin, 16, FlyingCreature( NPC ) ) || 
+			( NPCInfo->squadState == SQUAD_SCOUT && enemyLOS2 && enemyDist2 <= 10000 ) )
+		{
+			int	newSquadState = SQUAD_STAND_AND_SHOOT;
+			//we got where we wanted to go, set timers based on why we were running
+			switch ( NPCInfo->squadState )
+			{
+			case SQUAD_RETREAT://was running away
+				TIMER_Set( NPC, "duck", (NPC->client->pers.maxHealth - NPC->health) * 100 );
+				TIMER_Set( NPC, "hideTime", Q_irand( 3000, 7000 ) );
+				newSquadState = SQUAD_COVER;
+				break;
+			case SQUAD_TRANSITION://was heading for a combat point
+				TIMER_Set( NPC, "hideTime", Q_irand( 2000, 4000 ) );
+				break;
+			case SQUAD_SCOUT://was running after player
+				break;
+			default:
+				break;
+			}
+			NPC_ReachedGoal();
+			//don't attack right away
+			TIMER_Set( NPC, "attackDelay", Q_irand( (6-NPCInfo->stats.aim)*50, (6-NPCInfo->stats.aim)*100 ) );	//FIXME: Slant for difficulty levels, too?
+			//don't do something else just yet
+			TIMER_Set( NPC, "roamTime", Q_irand( 1000, 4000 ) );
+			//stop fleeing
+			if ( NPCInfo->squadState == SQUAD_RETREAT )
+			{
+				TIMER_Set( NPC, "flee", -level.time );
+				NPCInfo->squadState = SQUAD_IDLE;
+			}
+			return;
+		}
+
+		//keep going, hold of roamTimer until we get there
+		TIMER_Set( NPC, "roamTime", Q_irand( 4000, 8000 ) );
+	}
+}
+
+static void Sniper_ResolveBlockedShot( void )
+{
+	if ( TIMER_Done( NPC, "duck" ) )
+	{//we're not ducking
+		if ( TIMER_Done( NPC, "roamTime" ) )
+		{//not roaming
+			//FIXME: try to find another spot from which to hit the enemy
+			if ( (NPCInfo->scriptFlags&SCF_CHASE_ENEMIES) && (!NPCInfo->goalEntity || NPCInfo->goalEntity == NPC->enemy) )
+			{//we were running after enemy
+				//Try to find a combat point that can hit the enemy
+				int cpFlags = (CP_CLEAR|CP_HAS_ROUTE);
+				int cp;
+
+				if ( NPCInfo->scriptFlags&SCF_USE_CP_NEAREST )
+				{
+					cpFlags &= ~(CP_FLANK|CP_APPROACH_ENEMY|CP_CLOSEST);
+					cpFlags |= CP_NEAREST;
+				}
+				cp = NPC_FindCombatPoint( NPC->r.currentOrigin, NPC->r.currentOrigin, NPC->r.currentOrigin, cpFlags, 32, -1 );
+				if ( cp == -1 && !(NPCInfo->scriptFlags&SCF_USE_CP_NEAREST) )
+				{//okay, try one by the enemy
+					cp = NPC_FindCombatPoint( NPC->r.currentOrigin, NPC->r.currentOrigin, NPC->enemy->r.currentOrigin, CP_CLEAR|CP_HAS_ROUTE|CP_HORZ_DIST_COLL, 32, -1 );
+				}
+				//NOTE: there may be a perfectly valid one, just not one within CP_COLLECT_RADIUS of either me or him...
+				if ( cp != -1 )
+				{//found a combat point that has a clear shot to enemy
+					NPC_SetCombatPoint( cp );
+					NPC_SetMoveGoal( NPC, level.combatPoints[cp].origin, 8, qtrue, cp, NULL );
+					TIMER_Set( NPC, "duck", -1 );
+					TIMER_Set( NPC, "attackDelay", Q_irand( 1000, 3000 ) );
+					return;
+				}
+			}
+		}
+	}
+	/*
+	else
+	{//maybe we should stand
+		if ( TIMER_Done( NPC, "stand" ) )
+		{//stand for as long as we'll be here
+			TIMER_Set( NPC, "stand", Q_irand( 500, 2000 ) );
+			return;
+		}
+	}
+	//Hmm, can't resolve this by telling them to duck or telling me to stand
+	//We need to move!
+	TIMER_Set( NPC, "roamTime", -1 );
+	TIMER_Set( NPC, "stick", -1 );
+	TIMER_Set( NPC, "duck", -1 );
+	TIMER_Set( NPC, "attackDelay", Q_irand( 1000, 3000 ) );
+	*/
+}
+
+/*
+-------------------------
+ST_CheckFireState
+-------------------------
+*/
+
+static void Sniper_CheckFireState( void )
+{
+	if ( enemyCS2 )
+	{//if have a clear shot, always try
+		return;
+	}
+
+	if ( NPCInfo->squadState == SQUAD_RETREAT || NPCInfo->squadState == SQUAD_TRANSITION || NPCInfo->squadState == SQUAD_SCOUT )
+	{//runners never try to fire at the last pos
+		return;
+	}
+
+	if ( !VectorCompare( NPC->client->ps.velocity, vec3_origin ) )
+	{//if moving at all, don't do this
+		return;
+	}
+
+	//continue to fire on their last position
+	if ( !Q_irand( 0, 1 ) && NPCInfo->enemyLastSeenTime && level.time - NPCInfo->enemyLastSeenTime < ((5-NPCInfo->stats.aim)*1000) )//FIXME: incorporate skill too?
+	{
+		if ( !VectorCompare( vec3_origin, NPCInfo->enemyLastSeenLocation ) )
+		{
+			//Fire on the last known position
+			vec3_t	muzzle, dir, angles;
+
+			CalcEntitySpot( NPC, SPOT_WEAPON, muzzle );
+			VectorSubtract( NPCInfo->enemyLastSeenLocation, muzzle, dir );
+
+			VectorNormalize( dir );
+
+			vectoangles( dir, angles );
+
+			NPCInfo->desiredYaw		= angles[YAW];
+			NPCInfo->desiredPitch	= angles[PITCH];
+
+			shoot2 = qtrue;
+			//faceEnemy2 = qfalse;
+		}
+		return;
+	}
+	else if ( level.time - NPCInfo->enemyLastSeenTime > 10000 )
+	{//next time we see him, we'll miss few times first
+		NPC->count = 0;
+	}
+}
+
+qboolean Sniper_EvaluateShot( int hit )
+{
+	gentity_t *hitEnt;
+
+	if ( !NPC->enemy )
+	{
+		return qfalse;
+	}
+
+	hitEnt = &g_entities[hit];
+	if ( hit == NPC->enemy->s.number 
+		|| ( hitEnt && hitEnt->client && hitEnt->client->playerTeam == NPC->client->enemyTeam )
+		|| ( hitEnt && hitEnt->takedamage && ((hitEnt->r.svFlags&SVF_GLASS_BRUSH)||hitEnt->health < 40||NPC->s.weapon == WP_EMPLACED_GUN) )
+		|| ( hitEnt && (hitEnt->r.svFlags&SVF_GLASS_BRUSH)) )
+	{//can hit enemy or will hit glass, so shoot anyway
+		return qtrue;
+	}
+	return qfalse;
+}
+
+void Sniper_FaceEnemy( void )
+{
+	//FIXME: the ones behind kill holes are facing some arbitrary direction and not firing
+	//FIXME: If actually trying to hit enemy, don't fire unless enemy is at least in front of me?
+	//FIXME: need to give designers option to make them not miss first few shots
+	if ( NPC->enemy )
+	{
+		vec3_t	muzzle, target, angles, forward, right, up;
+		//Get the positions
+		AngleVectors( NPC->client->ps.viewangles, forward, right, up );
+		CalcMuzzlePoint( NPC, forward, right, up, muzzle );
+		//CalcEntitySpot( NPC, SPOT_WEAPON, muzzle );
+		CalcEntitySpot( NPC->enemy, SPOT_ORIGIN, target );
+
+		if ( enemyDist2 > 65536 && NPCInfo->stats.aim < 5 )//is 256 squared, was 16384 (128*128)
+		{
+			if ( NPC->count < (5-NPCInfo->stats.aim) )
+			{//miss a few times first
+				if ( shoot2 && TIMER_Done( NPC, "attackDelay" ) && level.time >= NPCInfo->shotTime )
+				{//ready to fire again
+					qboolean	aimError = qfalse;
+					qboolean	hit = qtrue;
+					int			tryMissCount = 0;
+					trace_t		trace;
+
+					GetAnglesForDirection( muzzle, target, angles );
+					AngleVectors( angles, forward, right, up );
+
+					while ( hit && tryMissCount < 10 )
+					{
+						tryMissCount++;
+						if ( !Q_irand( 0, 1 ) )
+						{
+							aimError = qtrue;
+							if ( !Q_irand( 0, 1 ) )
+							{
+								VectorMA( target, NPC->enemy->r.maxs[2]*flrand(1.5, 4), right, target );
+							}
+							else
+							{
+								VectorMA( target, NPC->enemy->r.mins[2]*flrand(1.5, 4), right, target );
+							}
+						}
+						if ( !aimError || !Q_irand( 0, 1 ) )
+						{
+							if ( !Q_irand( 0, 1 ) )
+							{
+								VectorMA( target, NPC->enemy->r.maxs[2]*flrand(1.5, 4), up, target );
+							}
+							else
+							{
+								VectorMA( target, NPC->enemy->r.mins[2]*flrand(1.5, 4), up, target );
+							}
+						}
+						trap_Trace( &trace, muzzle, vec3_origin, vec3_origin, target, NPC->s.number, MASK_SHOT );
+						hit = Sniper_EvaluateShot( trace.entityNum );
+					}
+					NPC->count++;
+				}
+				else
+				{
+					if ( !enemyLOS2 )
+					{
+						NPC_UpdateAngles( qtrue, qtrue );
+						return;
+					}
+				}
+			}
+			else
+			{//based on distance, aim value, difficulty and enemy movement, miss
+				//FIXME: incorporate distance as a factor?
+				int missFactor = 8-(NPCInfo->stats.aim+g_spskill.integer) * 3;
+				if ( missFactor > ENEMY_POS_LAG_STEPS )
+				{
+					missFactor = ENEMY_POS_LAG_STEPS;
+				}
+				else if ( missFactor < 0 )
+				{//???
+					missFactor = 0 ;
+				}
+				VectorCopy( NPCInfo->enemyLaggedPos[missFactor], target );
+			}
+			GetAnglesForDirection( muzzle, target, angles );
+		}
+		else
+		{
+			target[2] += flrand( 0, NPC->enemy->r.maxs[2] );
+			//CalcEntitySpot( NPC->enemy, SPOT_HEAD_LEAN, target );
+			GetAnglesForDirection( muzzle, target, angles );
+		}
+
+		NPCInfo->desiredYaw		= AngleNormalize360( angles[YAW] );
+		NPCInfo->desiredPitch	= AngleNormalize360( angles[PITCH] );
+	}
+	NPC_UpdateAngles( qtrue, qtrue );
+}
+
+void Sniper_UpdateEnemyPos( void )
+{
+	int index;
+	int i;
+
+	for ( i = MAX_ENEMY_POS_LAG-ENEMY_POS_LAG_INTERVAL; i >= 0; i -= ENEMY_POS_LAG_INTERVAL )
+	{
+		index = i/ENEMY_POS_LAG_INTERVAL;
+		if ( !index )
+		{
+			CalcEntitySpot( NPC->enemy, SPOT_HEAD_LEAN, NPCInfo->enemyLaggedPos[index] );
+			NPCInfo->enemyLaggedPos[index][2] -= flrand( 2, 16 );
+		}
+		else
+		{
+			VectorCopy( NPCInfo->enemyLaggedPos[index-1], NPCInfo->enemyLaggedPos[index] );
+		}
+	}
+}
+
+/*
+-------------------------
+NPC_BSSniper_Attack
+-------------------------
+*/
+
+void Sniper_StartHide( void )
+{
+	int duckTime = Q_irand( 2000, 5000 );
+	
+	TIMER_Set( NPC, "duck", duckTime );
+	TIMER_Set( NPC, "watch", 500 );
+	TIMER_Set( NPC, "attackDelay", duckTime + Q_irand( 500, 2000 ) );
+}
+
+void NPC_BSSniper_Attack( void )
+{
+	//Don't do anything if we're hurt
+	if ( NPC->painDebounceTime > level.time )
+	{
+		NPC_UpdateAngles( qtrue, qtrue );
+		return;
+	}
+
+	//NPC_CheckEnemy( qtrue, qfalse );
+	//If we don't have an enemy, just idle
+	if ( NPC_CheckEnemyExt(qfalse) == qfalse )//!NPC->enemy )//
+	{
+		NPC->enemy = NULL;
+		NPC_BSSniper_Patrol();//FIXME: or patrol?
+		return;
+	}
+
+	if ( TIMER_Done( NPC, "flee" ) && NPC_CheckForDanger( NPC_CheckAlertEvents( qtrue, qtrue, -1, qfalse, AEL_DANGER ) ) )
+	{//going to run
+		NPC_UpdateAngles( qtrue, qtrue );
+		return;
+	}
+
+	if ( !NPC->enemy )
+	{//WTF?  somehow we lost our enemy?
+		NPC_BSSniper_Patrol();//FIXME: or patrol?
+		return;
+	}
+
+	enemyLOS2 = enemyCS2 = qfalse;
+	move2 = qtrue;
+	faceEnemy2 = qfalse;
+	shoot2 = qfalse;
+	enemyDist2 = DistanceSquared( NPC->r.currentOrigin, NPC->enemy->r.currentOrigin );
+	if ( enemyDist2 < 16384 )//128 squared
+	{//too close, so switch to primary fire
+		if ( NPC->client->ps.weapon == WP_DISRUPTOR )
+		{//sniping... should be assumed
+			if ( NPCInfo->scriptFlags & SCF_ALT_FIRE )
+			{//use primary fire
+				trace_t	trace;
+				trap_Trace ( &trace, NPC->enemy->r.currentOrigin, NPC->enemy->r.mins, NPC->enemy->r.maxs, NPC->r.currentOrigin, NPC->enemy->s.number, NPC->enemy->clipmask );
+				if ( !trace.allsolid && !trace.startsolid && (trace.fraction == 1.0 || trace.entityNum == NPC->s.number ) )
+				{//he can get right to me
+					NPCInfo->scriptFlags &= ~SCF_ALT_FIRE;
+					//reset fire-timing variables
+					NPC_ChangeWeapon( WP_DISRUPTOR );
+					NPC_UpdateAngles( qtrue, qtrue );
+					return;
+				}
+			}
+			//FIXME: switch back if he gets far away again?
+		}
+	}
+	else if ( enemyDist2 > 65536 )//256 squared
+	{
+		if ( NPC->client->ps.weapon == WP_DISRUPTOR )
+		{//sniping... should be assumed
+			if ( !(NPCInfo->scriptFlags&SCF_ALT_FIRE) )
+			{//use primary fire
+				NPCInfo->scriptFlags |= SCF_ALT_FIRE;
+				//reset fire-timing variables
+				NPC_ChangeWeapon( WP_DISRUPTOR );
+				NPC_UpdateAngles( qtrue, qtrue );
+				return;
+			}
+		}
+	}
+
+	Sniper_UpdateEnemyPos();
+	//can we see our target?
+	if ( NPC_ClearLOS4( NPC->enemy ) )//|| (NPCInfo->stats.aim >= 5 && gi.inPVS( NPC->client->renderInfo.eyePoint, NPC->enemy->currentOrigin )) )
+	{
+		float maxShootDist;
+
+		NPCInfo->enemyLastSeenTime = level.time;
+		VectorCopy( NPC->enemy->r.currentOrigin, NPCInfo->enemyLastSeenLocation );
+		enemyLOS2 = qtrue;
+		maxShootDist = NPC_MaxDistSquaredForWeapon();
+		if ( enemyDist2 < maxShootDist )
+		{
+			vec3_t fwd, right, up, muzzle, end;
+			trace_t	tr;
+			int hit;
+
+			AngleVectors( NPC->client->ps.viewangles, fwd, right, up );
+			CalcMuzzlePoint( NPC, fwd, right, up, muzzle );
+			VectorMA( muzzle, 8192, fwd, end );
+			trap_Trace ( &tr, muzzle, NULL, NULL, end, NPC->s.number, MASK_SHOT );
+
+			hit = tr.entityNum;
+			//can we shoot our target?
+			if ( Sniper_EvaluateShot( hit ) )
+			{
+				enemyCS2 = qtrue;
+			}
+		}
+	}
+	/*
+	else if ( gi.inPVS( NPC->enemy->currentOrigin, NPC->currentOrigin ) )
+	{
+		NPCInfo->enemyLastSeenTime = level.time;
+		faceEnemy2 = qtrue;
+	}
+	*/
+
+	if ( enemyLOS2 )
+	{//FIXME: no need to face enemy if we're moving to some other goal and he's too far away to shoot?
+		faceEnemy2 = qtrue;
+	}
+	if ( enemyCS2 )
+	{
+		shoot2 = qtrue;
+	}
+	else if ( level.time - NPCInfo->enemyLastSeenTime > 3000 )
+	{//Hmm, have to get around this bastard... FIXME: this NPCInfo->enemyLastSeenTime builds up when ducked seems to make them want to run when they uncrouch
+		Sniper_ResolveBlockedShot();
+	}
+
+	//Check for movement to take care of
+	Sniper_CheckMoveState();
+
+	//See if we should override shooting decision with any special considerations
+	Sniper_CheckFireState();
+
+	if ( move2 )
+	{//move toward goal
+		if ( NPCInfo->goalEntity )//&& ( NPCInfo->goalEntity != NPC->enemy || enemyDist2 > 10000 ) )//100 squared
+		{
+			move2 = Sniper_Move();
+		}
+		else
+		{
+			move2 = qfalse;
+		}
+	}
+
+	if ( !move2 )
+	{
+		if ( !TIMER_Done( NPC, "duck" ) )
+		{
+			if ( TIMER_Done( NPC, "watch" ) )
+			{//not while watching
+				ucmd.upmove = -127;
+			}
+		}
+		//FIXME: what about leaning?
+		//FIXME: also, when stop ducking, start looking, if enemy can see me, chance of ducking back down again
+	}
+	else
+	{//stop ducking!
+		TIMER_Set( NPC, "duck", -1 );
+	}
+
+	if ( TIMER_Done( NPC, "duck" ) 
+		&& TIMER_Done( NPC, "watch" ) 
+		&& (TIMER_Get( NPC, "attackDelay" )-level.time) > 1000 
+		&& NPC->attackDebounceTime < level.time )
+	{
+		if ( enemyLOS2 && (NPCInfo->scriptFlags&SCF_ALT_FIRE) )
+		{
+			if ( NPC->fly_sound_debounce_time < level.time )
+			{
+				NPC->fly_sound_debounce_time = level.time + 2000;
+			}
+		}
+	}
+
+	if ( !faceEnemy2 )
+	{//we want to face in the dir we're running
+		if ( move2 )
+		{//don't run away and shoot
+			NPCInfo->desiredYaw = NPCInfo->lastPathAngles[YAW];
+			NPCInfo->desiredPitch = 0;
+			shoot2 = qfalse;
+		}
+		NPC_UpdateAngles( qtrue, qtrue );
+	}
+	else// if ( faceEnemy2 )
+	{//face the enemy
+		Sniper_FaceEnemy();
+	}
+
+	if ( NPCInfo->scriptFlags&SCF_DONT_FIRE )
+	{
+		shoot2 = qfalse;
+	}
+
+	//FIXME: don't shoot right away!
+	if ( shoot2 )
+	{//try to shoot if it's time
+		if ( TIMER_Done( NPC, "attackDelay" ) )
+		{
+			WeaponThink( qtrue );
+			if ( ucmd.buttons&(BUTTON_ATTACK|BUTTON_ALT_ATTACK) )
+			{
+				G_SoundOnEnt( NPC, CHAN_WEAPON, "sound/null.wav" );
+			}
+
+			//took a shot, now hide
+			if ( !(NPC->spawnflags&SPF_NO_HIDE) && !Q_irand( 0, 1 ) )
+			{
+				//FIXME: do this if in combat point and combat point has duck-type cover... also handle lean-type cover
+				Sniper_StartHide();
+			}
+			else
+			{
+				TIMER_Set( NPC, "attackDelay", NPCInfo->shotTime-level.time );
+			}
+		}
+	}
+}
+
+void NPC_BSSniper_Default( void )
+{
+	if( !NPC->enemy )
+	{//don't have an enemy, look for one
+		NPC_BSSniper_Patrol();
+	}
+	else//if ( NPC->enemy )
+	{//have an enemy
+		NPC_BSSniper_Attack();
+	}
+}
diff --git a/codemp/game/NPC_AI_Stormtrooper.c b/codemp/game/NPC_AI_Stormtrooper.c
new file mode 100644
index 0000000..db271b9
--- /dev/null
+++ b/codemp/game/NPC_AI_Stormtrooper.c
@@ -0,0 +1,2742 @@
+#include "b_local.h"
+#include "g_nav.h"
+#include "anims.h"
+
+extern void G_AddVoiceEvent( gentity_t *self, int event, int speakDebounceTime );
+extern void AI_GroupUpdateSquadstates( AIGroupInfo_t *group, gentity_t *member, int newSquadState );
+extern qboolean AI_GroupContainsEntNum( AIGroupInfo_t *group, int entNum );
+extern void AI_GroupUpdateEnemyLastSeen( AIGroupInfo_t *group, vec3_t spot );
+extern void AI_GroupUpdateClearShotTime( AIGroupInfo_t *group );
+extern void NPC_TempLookTarget( gentity_t *self, int lookEntNum, int minLookTime, int maxLookTime );
+extern qboolean G_ExpandPointToBBox( vec3_t point, const vec3_t mins, const vec3_t maxs, int ignore, int clipmask );
+extern void ChangeWeapon( gentity_t *ent, int newWeapon );
+extern void NPC_CheckGetNewWeapon( void );
+extern int GetTime ( int lastTime );
+extern void NPC_AimAdjust( int change );
+extern qboolean FlyingCreature( gentity_t *ent );
+
+extern	vmCvar_t		d_asynchronousGroupAI;
+
+#define	MAX_VIEW_DIST		1024
+#define MAX_VIEW_SPEED		250
+#define	MAX_LIGHT_INTENSITY 255
+#define	MIN_LIGHT_THRESHOLD	0.1
+#define	ST_MIN_LIGHT_THRESHOLD 30
+#define	ST_MAX_LIGHT_THRESHOLD 180
+#define	DISTANCE_THRESHOLD	0.075f
+
+#define	DISTANCE_SCALE		0.35f	//These first three get your base detection rating, ideally add up to 1
+#define	FOV_SCALE			0.40f	//
+#define	LIGHT_SCALE			0.25f	//
+
+#define	SPEED_SCALE			0.25f	//These next two are bonuses
+#define	TURNING_SCALE		0.25f	//
+
+#define	REALIZE_THRESHOLD	0.6f
+#define CAUTIOUS_THRESHOLD	( REALIZE_THRESHOLD * 0.75 )
+
+qboolean NPC_CheckPlayerTeamStealth( void );
+
+static qboolean enemyLOS;
+static qboolean enemyCS;
+static qboolean enemyInFOV;
+static qboolean hitAlly;
+static qboolean faceEnemy;
+static qboolean move;
+static qboolean shoot;
+static float	enemyDist;
+static vec3_t	impactPos;
+
+int groupSpeechDebounceTime[TEAM_NUM_TEAMS];//used to stop several group AI from speaking all at once
+
+//Local state enums
+enum
+{
+	LSTATE_NONE = 0,
+	LSTATE_UNDERFIRE,
+	LSTATE_INVESTIGATE,
+};
+
+void ST_AggressionAdjust( gentity_t *self, int change )
+{
+	int	upper_threshold, lower_threshold;
+
+	self->NPC->stats.aggression += change;
+	
+	//FIXME: base this on initial NPC stats
+	if ( self->client->playerTeam == NPCTEAM_PLAYER )
+	{//good guys are less aggressive
+		upper_threshold = 7;
+		lower_threshold = 1;
+	}
+	else
+	{//bad guys are more aggressive
+		upper_threshold = 10;
+		lower_threshold = 3;
+	}
+
+	if ( self->NPC->stats.aggression > upper_threshold )
+	{
+		self->NPC->stats.aggression = upper_threshold;
+	}
+	else if ( self->NPC->stats.aggression < lower_threshold )
+	{
+		self->NPC->stats.aggression = lower_threshold;
+	}
+}
+
+void ST_ClearTimers( gentity_t *ent )
+{
+	TIMER_Set( ent, "chatter", 0 );
+	TIMER_Set( ent, "duck", 0 );
+	TIMER_Set( ent, "stand", 0 );
+	TIMER_Set( ent, "shuffleTime", 0 );
+	TIMER_Set( ent, "sleepTime", 0 );
+	TIMER_Set( ent, "enemyLastVisible", 0 );
+	TIMER_Set( ent, "roamTime", 0 );
+	TIMER_Set( ent, "hideTime", 0 );
+	TIMER_Set( ent, "attackDelay", 0 );	//FIXME: Slant for difficulty levels
+	TIMER_Set( ent, "stick", 0 );
+	TIMER_Set( ent, "scoutTime", 0 );
+	TIMER_Set( ent, "flee", 0 );
+	TIMER_Set( ent, "interrogating", 0 );
+	TIMER_Set( ent, "verifyCP", 0 );
+}
+
+enum
+{
+	SPEECH_CHASE,
+	SPEECH_CONFUSED,
+	SPEECH_COVER,
+	SPEECH_DETECTED,
+	SPEECH_GIVEUP,
+	SPEECH_LOOK,
+	SPEECH_LOST,
+	SPEECH_OUTFLANK,
+	SPEECH_ESCAPING,
+	SPEECH_SIGHT,
+	SPEECH_SOUND,
+	SPEECH_SUSPICIOUS,
+	SPEECH_YELL,
+	SPEECH_PUSHED
+};
+
+static void ST_Speech( gentity_t *self, int speechType, float failChance )
+{
+	if ( random() < failChance )
+	{
+		return;
+	}
+
+	if ( failChance >= 0 )
+	{//a negative failChance makes it always talk
+		if ( self->NPC->group )
+		{//group AI speech debounce timer
+			if ( self->NPC->group->speechDebounceTime > level.time )
+			{
+				return;
+			}
+			/*
+			else if ( !self->NPC->group->enemy )
+			{
+				if ( groupSpeechDebounceTime[self->client->playerTeam] > level.time )
+				{
+					return;
+				}
+			}
+			*/
+		}
+		else if ( !TIMER_Done( self, "chatter" ) )
+		{//personal timer
+			return;
+		}
+		else if ( groupSpeechDebounceTime[self->client->playerTeam] > level.time )
+		{//for those not in group AI
+			//FIXME: let certain speech types interrupt others?  Let closer NPCs interrupt farther away ones?
+			return;
+		}
+	}
+
+	if ( self->NPC->group )
+	{//So they don't all speak at once...
+		//FIXME: if they're not yet mad, they have no group, so distracting a group of them makes them all speak!
+		self->NPC->group->speechDebounceTime = level.time + Q_irand( 2000, 4000 );
+	}
+	else
+	{
+		TIMER_Set( self, "chatter", Q_irand( 2000, 4000 ) );
+	}
+	groupSpeechDebounceTime[self->client->playerTeam] = level.time + Q_irand( 2000, 4000 );
+
+	if ( self->NPC->blockedSpeechDebounceTime > level.time )
+	{
+		return;
+	}
+
+	switch( speechType )
+	{
+	case SPEECH_CHASE:
+		G_AddVoiceEvent( self, Q_irand(EV_CHASE1, EV_CHASE3), 2000 );
+		break;
+	case SPEECH_CONFUSED:
+		G_AddVoiceEvent( self, Q_irand(EV_CONFUSE1, EV_CONFUSE3), 2000 );
+		break;
+	case SPEECH_COVER:
+		G_AddVoiceEvent( self, Q_irand(EV_COVER1, EV_COVER5), 2000 );
+		break;
+	case SPEECH_DETECTED:
+		G_AddVoiceEvent( self, Q_irand(EV_DETECTED1, EV_DETECTED5), 2000 );
+		break;
+	case SPEECH_GIVEUP:
+		G_AddVoiceEvent( self, Q_irand(EV_GIVEUP1, EV_GIVEUP4), 2000 );
+		break;
+	case SPEECH_LOOK:
+		G_AddVoiceEvent( self, Q_irand(EV_LOOK1, EV_LOOK2), 2000 );
+		break;
+	case SPEECH_LOST:
+		G_AddVoiceEvent( self, EV_LOST1, 2000 );
+		break;
+	case SPEECH_OUTFLANK:
+		G_AddVoiceEvent( self, Q_irand(EV_OUTFLANK1, EV_OUTFLANK2), 2000 );
+		break;
+	case SPEECH_ESCAPING:
+		G_AddVoiceEvent( self, Q_irand(EV_ESCAPING1, EV_ESCAPING3), 2000 );
+		break;
+	case SPEECH_SIGHT:
+		G_AddVoiceEvent( self, Q_irand(EV_SIGHT1, EV_SIGHT3), 2000 );
+		break;
+	case SPEECH_SOUND:
+		G_AddVoiceEvent( self, Q_irand(EV_SOUND1, EV_SOUND3), 2000 );
+		break;
+	case SPEECH_SUSPICIOUS:
+		G_AddVoiceEvent( self, Q_irand(EV_SUSPICIOUS1, EV_SUSPICIOUS5), 2000 );
+		break;
+	case SPEECH_YELL:
+		G_AddVoiceEvent( self, Q_irand( EV_ANGER1, EV_ANGER3 ), 2000 );
+		break;
+	case SPEECH_PUSHED:
+		G_AddVoiceEvent( self, Q_irand( EV_PUSHED1, EV_PUSHED3 ), 2000 );
+		break;
+	default:
+		break;
+	}
+
+	self->NPC->blockedSpeechDebounceTime = level.time + 2000;
+}
+
+void ST_MarkToCover( gentity_t *self )
+{
+	if ( !self || !self->NPC )
+	{
+		return;
+	}
+	self->NPC->localState = LSTATE_UNDERFIRE;
+	TIMER_Set( self, "attackDelay", Q_irand( 500, 2500 ) );
+	ST_AggressionAdjust( self, -3 );
+	if ( self->NPC->group && self->NPC->group->numGroup > 1 )
+	{
+		ST_Speech( self, SPEECH_COVER, 0 );//FIXME: flee sound?
+	}
+}
+
+void ST_StartFlee( gentity_t *self, gentity_t *enemy, vec3_t dangerPoint, int dangerLevel, int minTime, int maxTime )
+{
+	if ( !self || !self->NPC )
+	{
+		return;
+	}
+	G_StartFlee( self, enemy, dangerPoint, dangerLevel, minTime, maxTime );
+	if ( self->NPC->group && self->NPC->group->numGroup > 1 )
+	{
+		ST_Speech( self, SPEECH_COVER, 0 );//FIXME: flee sound?
+	}
+}
+/*
+-------------------------
+NPC_ST_Pain
+-------------------------
+*/
+
+void NPC_ST_Pain(gentity_t *self, gentity_t *attacker, int damage)
+{
+	self->NPC->localState = LSTATE_UNDERFIRE;
+
+	TIMER_Set( self, "duck", -1 );
+	TIMER_Set( self, "hideTime", -1 );
+	TIMER_Set( self, "stand", 2000 );
+
+	NPC_Pain( self, attacker, damage );
+
+	if ( !damage && self->health > 0 )
+	{//FIXME: better way to know I was pushed
+		G_AddVoiceEvent( self, Q_irand(EV_PUSHED1, EV_PUSHED3), 2000 );
+	}
+}
+
+/*
+-------------------------
+ST_HoldPosition
+-------------------------
+*/
+
+static void ST_HoldPosition( void )
+{
+	if ( NPCInfo->squadState == SQUAD_RETREAT )
+	{
+		TIMER_Set( NPC, "flee", -level.time );
+	}
+	TIMER_Set( NPC, "verifyCP", Q_irand( 1000, 3000 ) );//don't look for another one for a few seconds
+	NPC_FreeCombatPoint( NPCInfo->combatPoint, qtrue );
+	//NPCInfo->combatPoint = -1;//???
+	if ( !trap_ICARUS_TaskIDPending( NPC, TID_MOVE_NAV ) )
+	{//don't have a script waiting for me to get to my point, okay to stop trying and stand
+		AI_GroupUpdateSquadstates( NPCInfo->group, NPC, SQUAD_STAND_AND_SHOOT );
+		NPCInfo->goalEntity = NULL;
+	}
+	
+	/*if ( TIMER_Done( NPC, "stand" ) )
+	{//FIXME: what if can't shoot from this pos?
+		TIMER_Set( NPC, "duck", Q_irand( 2000, 4000 ) );
+	}
+	*/
+}
+
+void NPC_ST_SayMovementSpeech( void )
+{
+	if ( !NPCInfo->movementSpeech )
+	{
+		return;
+	}
+	if ( NPCInfo->group && 
+		NPCInfo->group->commander && 
+		NPCInfo->group->commander->client && 
+		NPCInfo->group->commander->client->NPC_class == CLASS_IMPERIAL && 
+		!Q_irand( 0, 3 ) )
+	{//imperial (commander) gives the order
+		ST_Speech( NPCInfo->group->commander, NPCInfo->movementSpeech, NPCInfo->movementSpeechChance );
+	}
+	else
+	{//really don't want to say this unless we can actually get there...
+		ST_Speech( NPC, NPCInfo->movementSpeech, NPCInfo->movementSpeechChance );
+	}
+
+	NPCInfo->movementSpeech = 0;
+	NPCInfo->movementSpeechChance = 0.0f;
+}
+
+void NPC_ST_StoreMovementSpeech( int speech, float chance )
+{
+	NPCInfo->movementSpeech = speech;
+	NPCInfo->movementSpeechChance = chance;
+}
+/*
+-------------------------
+ST_Move
+-------------------------
+*/
+void ST_TransferMoveGoal( gentity_t *self, gentity_t *other );
+static qboolean ST_Move( void )
+{
+	qboolean	moved;
+	navInfo_t	info;
+
+	NPCInfo->combatMove = qtrue;//always move straight toward our goal
+
+	moved = NPC_MoveToGoal( qtrue );
+	
+	//Get the move info
+	NAV_GetLastMove( &info );
+
+	//FIXME: if we bump into another one of our guys and can't get around him, just stop!
+	//If we hit our target, then stop and fire!
+	if ( info.flags & NIF_COLLISION ) 
+	{
+		if ( info.blocker == NPC->enemy )
+		{
+			ST_HoldPosition();
+		}
+	}
+
+	//If our move failed, then reset
+	if ( moved == qfalse )
+	{//FIXME: if we're going to a combat point, need to pick a different one
+		if ( !trap_ICARUS_TaskIDPending( NPC, TID_MOVE_NAV ) )
+		{//can't transfer movegoal or stop when a script we're running is waiting to complete
+			if ( info.blocker && info.blocker->NPC && NPCInfo->group != NULL && info.blocker->NPC->group == NPCInfo->group )//(NPCInfo->aiFlags&NPCAI_BLOCKED) && NPCInfo->group != NULL )
+			{//dammit, something is in our way
+				//see if it's one of ours
+				int j;
+
+				for ( j = 0; j < NPCInfo->group->numGroup; j++ )
+				{
+					if ( NPCInfo->group->member[j].number == NPCInfo->blockingEntNum )
+					{//we're being blocked by one of our own, pass our goal onto them and I'll stand still
+						ST_TransferMoveGoal( NPC, &g_entities[NPCInfo->group->member[j].number] );
+						break;
+					}
+				}
+			}
+			
+			ST_HoldPosition();
+		}
+	}
+	else
+	{
+		//First time you successfully move, say what it is you're doing
+		NPC_ST_SayMovementSpeech();
+	}
+
+	return moved;
+}
+
+
+/*
+-------------------------
+NPC_ST_SleepShuffle
+-------------------------
+*/
+
+static void NPC_ST_SleepShuffle( void )
+{
+	//Play an awake script if we have one
+	if ( G_ActivateBehavior( NPC, BSET_AWAKE) )
+	{
+		return;
+	}
+
+	//Automate some movement and noise
+	if ( TIMER_Done( NPC, "shuffleTime" ) )
+	{
+		
+		//TODO: Play sleeping shuffle animation
+
+		//int	soundIndex = Q_irand( 0, 1 );
+
+		/*
+		switch ( soundIndex )
+		{
+		case 0:
+			G_Sound( NPC, G_SoundIndex("sound/chars/imperialsleeper1/scav4/hunh.mp3") );
+			break;
+
+		case 1:
+			G_Sound( NPC, G_SoundIndex("sound/chars/imperialsleeper3/scav4/tryingtosleep.wav") );
+			break;
+		}
+		*/
+
+		TIMER_Set( NPC, "shuffleTime", 4000 );
+		TIMER_Set( NPC, "sleepTime", 2000 );
+		return;
+	}
+
+	//They made another noise while we were stirring, see if we can see them
+	if ( TIMER_Done( NPC, "sleepTime" ) )
+	{
+		NPC_CheckPlayerTeamStealth();
+		TIMER_Set( NPC, "sleepTime", 2000 );
+	}
+}
+
+/*
+-------------------------
+NPC_ST_Sleep
+-------------------------
+*/
+
+void NPC_BSST_Sleep( void )
+{
+	int alertEvent = NPC_CheckAlertEvents( qfalse, qtrue, -1, qfalse, AEL_MINOR );//only check sounds since we're alseep!
+
+	//There is an event we heard
+	if ( alertEvent >= 0 )
+	{
+		//See if it was enough to wake us up
+		if ( level.alertEvents[alertEvent].level == AEL_DISCOVERED && (NPCInfo->scriptFlags&SCF_LOOK_FOR_ENEMIES) )
+		{ //rwwFIXMEFIXME: Care about all clients not just 0
+			if ( &g_entities[0] && g_entities[0].health > 0 )
+			{
+				G_SetEnemy( NPC, &g_entities[0] );
+				return;
+			}
+		}
+
+		//Otherwise just stir a bit
+		NPC_ST_SleepShuffle();
+		return;
+	}
+}
+
+/*
+-------------------------
+NPC_CheckEnemyStealth
+-------------------------
+*/
+
+qboolean NPC_CheckEnemyStealth( gentity_t *target )
+{
+	float		target_dist, minDist = 40;//any closer than 40 and we definitely notice
+	float		maxViewDist;
+	qboolean	clearLOS;
+
+	//In case we aquired one some other way
+	if ( NPC->enemy != NULL )
+		return qtrue;
+
+	//Ignore notarget
+	if ( target->flags & FL_NOTARGET )
+		return qfalse;
+
+	if ( target->health <= 0 )
+	{
+		return qfalse;
+	}
+
+	if ( target->client->ps.weapon == WP_SABER && !target->client->ps.saberHolstered && !target->client->ps.saberInFlight )
+	{//if target has saber in hand and activated, we wake up even sooner even if not facing him
+		minDist = 100;
+	}
+
+	target_dist = DistanceSquared( target->r.currentOrigin, NPC->r.currentOrigin );
+
+	//If the target is this close, then wake up regardless
+	if ( !(target->client->ps.pm_flags&PMF_DUCKED)
+		&& (NPCInfo->scriptFlags&SCF_LOOK_FOR_ENEMIES)
+		&& (target_dist) < (minDist*minDist) )
+	{
+		G_SetEnemy( NPC, target );
+		NPCInfo->enemyLastSeenTime = level.time;
+		TIMER_Set( NPC, "attackDelay", Q_irand( 500, 2500 ) );
+		return qtrue;
+	}
+
+	maxViewDist			= MAX_VIEW_DIST;
+
+	if ( NPCInfo->stats.visrange > maxViewDist )
+	{//FIXME: should we always just set maxViewDist to this?
+		maxViewDist = NPCInfo->stats.visrange;
+	}
+
+	if ( target_dist > (maxViewDist*maxViewDist) )
+	{//out of possible visRange
+		return qfalse;
+	}
+
+	//Check FOV first
+	if ( InFOV( target, NPC, NPCInfo->stats.hfov, NPCInfo->stats.vfov ) == qfalse )
+		return qfalse;
+
+	//clearLOS = ( target->client->ps.leanofs ) ? NPC_ClearLOS5( target->client->renderInfo.eyePoint ) : NPC_ClearLOS4( target );
+	clearLOS = NPC_ClearLOS4( target );
+
+	//Now check for clear line of vision
+	if ( clearLOS )
+	{
+		vec3_t	targ_org;
+		float	hAngle_perc;
+		float	vAngle_perc;
+		float	target_speed;
+		int		target_crouching;
+		float	dist_rating;
+		float	speed_rating;
+		float	turning_rating;
+		float	light_level;
+		float	FOV_perc;
+		float	vis_rating;
+		float	dist_influence;
+		float	fov_influence;
+		float	light_influence;
+		float	target_rating;
+		int		contents;
+		float	realize, cautious;
+
+		if ( target->client->NPC_class == CLASS_ATST )
+		{//can't miss 'em!
+			G_SetEnemy( NPC, target );
+			TIMER_Set( NPC, "attackDelay", Q_irand( 500, 2500 ) );
+			return qtrue;
+		}
+		VectorSet(targ_org, target->r.currentOrigin[0],target->r.currentOrigin[1],target->r.currentOrigin[2]+target->r.maxs[2]-4);
+		hAngle_perc			= NPC_GetHFOVPercentage( targ_org, NPC->client->renderInfo.eyePoint, NPC->client->renderInfo.eyeAngles, NPCInfo->stats.hfov );
+		vAngle_perc			= NPC_GetVFOVPercentage( targ_org, NPC->client->renderInfo.eyePoint, NPC->client->renderInfo.eyeAngles, NPCInfo->stats.vfov );
+
+		//Scale them vertically some, and horizontally pretty harshly
+		vAngle_perc *= vAngle_perc;//( vAngle_perc * vAngle_perc );
+		hAngle_perc *= ( hAngle_perc * hAngle_perc );
+
+		//Cap our vertical vision severely
+		//if ( vAngle_perc <= 0.3f ) // was 0.5f
+		//	return qfalse;
+
+		//Assess the player's current status
+		target_dist			= Distance( target->r.currentOrigin, NPC->r.currentOrigin );
+
+		target_speed		= VectorLength( target->client->ps.velocity );
+		target_crouching	= ( target->client->pers.cmd.upmove < 0 );
+		dist_rating			= ( target_dist / maxViewDist );
+		speed_rating		= ( target_speed / MAX_VIEW_SPEED );
+		turning_rating		= 5.0f;//AngleDelta( target->client->ps.viewangles[PITCH], target->lastAngles[PITCH] )/180.0f + AngleDelta( target->client->ps.viewangles[YAW], target->lastAngles[YAW] )/180.0f;
+		light_level			= (255/MAX_LIGHT_INTENSITY); //( target->lightLevel / MAX_LIGHT_INTENSITY );
+		FOV_perc			= 1.0f - ( hAngle_perc + vAngle_perc ) * 0.5f;	//FIXME: Dunno about the average...
+		vis_rating			= 0.0f;
+		
+		//Too dark
+		if ( light_level < MIN_LIGHT_THRESHOLD )
+			return qfalse;
+
+		//Too close?
+		if ( dist_rating < DISTANCE_THRESHOLD )
+		{
+			G_SetEnemy( NPC, target );
+			TIMER_Set( NPC, "attackDelay", Q_irand( 500, 2500 ) );
+			return qtrue;
+		}
+
+		//Out of range
+		if ( dist_rating > 1.0f )
+			return qfalse;
+		
+		//Cap our speed checks
+		if ( speed_rating > 1.0f )
+			speed_rating = 1.0f;
+		
+
+		//Calculate the distance, fov and light influences
+		//...Visibilty linearly wanes over distance
+		dist_influence	= DISTANCE_SCALE * ( ( 1.0f - dist_rating ) );
+		//...As the percentage out of the FOV increases, straight perception suffers on an exponential scale
+		fov_influence		= FOV_SCALE * ( 1.0f - FOV_perc );
+		//...Lack of light hides, abundance of light exposes
+		light_influence	= ( light_level - 0.5f ) * LIGHT_SCALE;
+		
+		//Calculate our base rating
+		target_rating		= dist_influence + fov_influence + light_influence;
+		
+		//Now award any final bonuses to this number
+		contents = trap_PointContents( targ_org, target->s.number );
+		if ( contents&CONTENTS_WATER )
+		{
+			int myContents = trap_PointContents( NPC->client->renderInfo.eyePoint, NPC->s.number );
+			if ( !(myContents&CONTENTS_WATER) )
+			{//I'm not in water
+				if ( NPC->client->NPC_class == CLASS_SWAMPTROOPER )
+				{//these guys can see in in/through water pretty well
+					vis_rating = 0.10f;//10% bonus
+				}
+				else
+				{
+					vis_rating = 0.35f;//35% bonus
+				}
+			}
+			else
+			{//else, if we're both in water
+				if ( NPC->client->NPC_class == CLASS_SWAMPTROOPER )
+				{//I can see him just fine
+				}
+				else
+				{
+					vis_rating = 0.15f;//15% bonus
+				}
+			}
+		}
+		else 
+		{//not in water
+			if ( contents&CONTENTS_FOG )
+			{
+				vis_rating = 0.15f;//15% bonus
+			}
+		}
+
+		target_rating *= (1.0f - vis_rating);
+
+		//...Motion draws the eye quickly
+		target_rating += speed_rating * SPEED_SCALE;
+		target_rating += turning_rating * TURNING_SCALE;
+		//FIXME: check to see if they're animating, too?  But can we do something as simple as frame != oldframe?
+
+		//...Smaller targets are harder to indentify
+		if ( target_crouching )
+		{
+			target_rating *= 0.9f;	//10% bonus
+		}	
+	
+		//If he's violated the threshold, then realize him
+		//float difficulty_scale = 1.0f + (2.0f-g_spskill.value);//if playing on easy, 20% harder to be seen...?
+		if ( NPC->client->NPC_class == CLASS_SWAMPTROOPER )
+		{//swamptroopers can see much better
+			realize = (float)CAUTIOUS_THRESHOLD/**difficulty_scale*/;
+			cautious = (float)CAUTIOUS_THRESHOLD * 0.75f/**difficulty_scale*/;
+		}
+		else
+		{
+			realize = (float)REALIZE_THRESHOLD/**difficulty_scale*/;
+			cautious = (float)CAUTIOUS_THRESHOLD * 0.75f/**difficulty_scale*/;
+		}
+
+		if ( target_rating > realize && (NPCInfo->scriptFlags&SCF_LOOK_FOR_ENEMIES) )
+		{
+			G_SetEnemy( NPC, target );
+			NPCInfo->enemyLastSeenTime = level.time;
+			TIMER_Set( NPC, "attackDelay", Q_irand( 500, 2500 ) );
+			return qtrue;
+		}
+
+		//If he's above the caution threshold, then realize him in a few seconds unless he moves to cover
+		if ( target_rating > cautious && !(NPCInfo->scriptFlags&SCF_IGNORE_ALERTS) )
+		{//FIXME: ambushing guys should never talk
+			if ( TIMER_Done( NPC, "enemyLastVisible" ) )
+			{//If we haven't already, start the counter
+				int	lookTime = Q_irand( 4500, 8500 );
+				//NPCInfo->timeEnemyLastVisible = level.time + 2000;
+				TIMER_Set( NPC, "enemyLastVisible", lookTime );
+				//TODO: Play a sound along the lines of, "Huh?  What was that?"
+				ST_Speech( NPC, SPEECH_SIGHT, 0 );
+				NPC_TempLookTarget( NPC, target->s.number, lookTime, lookTime );
+				//FIXME: set desired yaw and pitch towards this guy?
+			}
+			else if ( TIMER_Get( NPC, "enemyLastVisible" ) <= level.time + 500 && (NPCInfo->scriptFlags&SCF_LOOK_FOR_ENEMIES) )	//FIXME: Is this reliable?
+			{
+				if ( NPCInfo->rank < RANK_LT && !Q_irand( 0, 2 ) )
+				{
+					int	interrogateTime = Q_irand( 2000, 4000 );
+					ST_Speech( NPC, SPEECH_SUSPICIOUS, 0 );
+					TIMER_Set( NPC, "interrogating", interrogateTime );
+					G_SetEnemy( NPC, target );
+					NPCInfo->enemyLastSeenTime = level.time;
+					TIMER_Set( NPC, "attackDelay", interrogateTime );
+					TIMER_Set( NPC, "stand", interrogateTime );
+				}
+				else
+				{
+					G_SetEnemy( NPC, target );
+					NPCInfo->enemyLastSeenTime = level.time;
+					//FIXME: ambush guys (like those popping out of water) shouldn't delay...
+					TIMER_Set( NPC, "attackDelay", Q_irand( 500, 2500 ) );
+					TIMER_Set( NPC, "stand", Q_irand( 500, 2500 ) );
+				}
+				return qtrue;
+			}
+
+			return qfalse;
+		}
+	}
+
+	return qfalse;
+}
+
+qboolean NPC_CheckPlayerTeamStealth( void )
+{
+	/*
+	//NOTENOTE: For now, all stealh checks go against the player, since
+	//			he is the main focus.  Squad members and rivals do not
+	//			fall into this category and will be ignored.
+
+	NPC_CheckEnemyStealth( &g_entities[0] );	//Change this pointer to assess other entities
+	*/
+	gentity_t *enemy;
+	int i;
+
+	for ( i = 0; i < ENTITYNUM_WORLD; i++ )
+	{
+		enemy = &g_entities[i];
+
+		if (!enemy->inuse)
+		{
+			continue;
+		}
+
+		if ( enemy && enemy->client && NPC_ValidEnemy( enemy ) && enemy->client->playerTeam == NPC->client->enemyTeam )
+		{
+			if ( NPC_CheckEnemyStealth( enemy ) )	//Change this pointer to assess other entities
+			{
+				return qtrue;
+			}
+		}
+	}
+	return qfalse;
+}
+/*
+-------------------------
+NPC_ST_InvestigateEvent
+-------------------------
+*/
+
+#define	MAX_CHECK_THRESHOLD	1
+
+static qboolean NPC_ST_InvestigateEvent( int eventID, qboolean extraSuspicious )
+{
+	//If they've given themselves away, just take them as an enemy
+	if ( NPCInfo->confusionTime < level.time )
+	{
+		if ( level.alertEvents[eventID].level == AEL_DISCOVERED && (NPCInfo->scriptFlags&SCF_LOOK_FOR_ENEMIES) )
+		{
+			NPCInfo->lastAlertID = level.alertEvents[eventID].ID;
+			if ( !level.alertEvents[eventID].owner || 
+				!level.alertEvents[eventID].owner->client || 
+				level.alertEvents[eventID].owner->health <= 0 ||
+				level.alertEvents[eventID].owner->client->playerTeam != NPC->client->enemyTeam )
+			{//not an enemy
+				return qfalse;
+			}
+			//FIXME: what if can't actually see enemy, don't know where he is... should we make them just become very alert and start looking for him?  Or just let combat AI handle this... (act as if you lost him)
+			//ST_Speech( NPC, SPEECH_CHARGE, 0 );
+			G_SetEnemy( NPC, level.alertEvents[eventID].owner );
+			NPCInfo->enemyLastSeenTime = level.time;
+			TIMER_Set( NPC, "attackDelay", Q_irand( 500, 2500 ) );
+			if ( level.alertEvents[eventID].type == AET_SOUND )
+			{//heard him, didn't see him, stick for a bit
+				TIMER_Set( NPC, "roamTime", Q_irand( 500, 2500 ) );
+			}
+			return qtrue;
+		}
+	}
+
+	//don't look at the same alert twice
+	if ( level.alertEvents[eventID].ID == NPCInfo->lastAlertID )
+	{
+		return qfalse;
+	}
+	NPCInfo->lastAlertID = level.alertEvents[eventID].ID;
+
+	//Must be ready to take another sound event
+	/*
+	if ( NPCInfo->investigateSoundDebounceTime > level.time )
+	{
+		return qfalse;
+	}
+	*/
+
+	if ( level.alertEvents[eventID].type == AET_SIGHT )
+	{//sight alert, check the light level
+		if ( level.alertEvents[eventID].light < Q_irand( ST_MIN_LIGHT_THRESHOLD, ST_MAX_LIGHT_THRESHOLD ) )
+		{//below my threshhold of potentially seeing
+			return qfalse;
+		}
+	}
+
+	//Save the position for movement (if necessary)
+	VectorCopy( level.alertEvents[eventID].position, NPCInfo->investigateGoal );
+
+	//First awareness of it
+	NPCInfo->investigateCount += ( extraSuspicious ) ? 2 : 1;
+
+	//Clamp the value
+	if ( NPCInfo->investigateCount > 4 )
+		NPCInfo->investigateCount = 4;
+
+	//See if we should walk over and investigate
+	if ( level.alertEvents[eventID].level > AEL_MINOR && NPCInfo->investigateCount > 1 && (NPCInfo->scriptFlags&SCF_CHASE_ENEMIES) )
+	{
+		//make it so they can walk right to this point and look at it rather than having to use combatPoints
+		if ( G_ExpandPointToBBox( NPCInfo->investigateGoal, NPC->r.mins, NPC->r.maxs, NPC->s.number, ((NPC->clipmask&~CONTENTS_BODY)|CONTENTS_BOTCLIP) ) )
+		{//we were able to move the investigateGoal to a point in which our bbox would fit
+			//drop the goal to the ground so we can get at it
+			vec3_t	end;
+			trace_t	trace;
+			VectorCopy( NPCInfo->investigateGoal, end );
+			end[2] -= 512;//FIXME: not always right?  What if it's even higher, somehow?
+			trap_Trace( &trace, NPCInfo->investigateGoal, NPC->r.mins, NPC->r.maxs, end, ENTITYNUM_NONE, ((NPC->clipmask&~CONTENTS_BODY)|CONTENTS_BOTCLIP) );
+			if ( trace.fraction >= 1.0f )
+			{//too high to even bother
+				//FIXME: look at them???
+			}
+			else
+			{
+				VectorCopy( trace.endpos, NPCInfo->investigateGoal );
+				NPC_SetMoveGoal( NPC, NPCInfo->investigateGoal, 16, qtrue, -1, NULL );
+				NPCInfo->localState = LSTATE_INVESTIGATE;
+			}
+		}
+		else
+		{
+			int id = NPC_FindCombatPoint( NPCInfo->investigateGoal, NPCInfo->investigateGoal, NPCInfo->investigateGoal, CP_INVESTIGATE|CP_HAS_ROUTE, 0, -1 );
+
+			if ( id != -1 )
+			{
+				NPC_SetMoveGoal( NPC, level.combatPoints[id].origin, 16, qtrue, id, NULL );
+				NPCInfo->localState = LSTATE_INVESTIGATE;
+			}
+		}
+		//Say something
+		//FIXME: only if have others in group... these should be responses?
+		if ( NPCInfo->investigateDebounceTime+NPCInfo->pauseTime > level.time )
+		{//was already investigating
+			if ( NPCInfo->group && 
+				NPCInfo->group->commander && 
+				NPCInfo->group->commander->client && 
+				NPCInfo->group->commander->client->NPC_class == CLASS_IMPERIAL && 
+				!Q_irand( 0, 3 ) )
+			{
+				ST_Speech( NPCInfo->group->commander, SPEECH_LOOK, 0 );//FIXME: "I'll go check it out" type sounds
+			}
+			else
+			{
+				ST_Speech( NPC, SPEECH_LOOK, 0 );//FIXME: "I'll go check it out" type sounds
+			}
+		}
+		else
+		{
+			if ( level.alertEvents[eventID].type == AET_SIGHT )
+			{
+				ST_Speech( NPC, SPEECH_SIGHT, 0 );
+			}
+			else if ( level.alertEvents[eventID].type == AET_SOUND )
+			{
+				ST_Speech( NPC, SPEECH_SOUND, 0 );
+			}
+		}
+		//Setup the debounce info
+		NPCInfo->investigateDebounceTime		= NPCInfo->investigateCount * 5000;
+		NPCInfo->investigateSoundDebounceTime	= level.time + 2000;
+		NPCInfo->pauseTime						= level.time;
+	}
+	else
+	{//just look?
+		//Say something
+		if ( level.alertEvents[eventID].type == AET_SIGHT )
+		{
+			ST_Speech( NPC, SPEECH_SIGHT, 0 );
+		}
+		else if ( level.alertEvents[eventID].type == AET_SOUND )
+		{
+			ST_Speech( NPC, SPEECH_SOUND, 0 );
+		}
+		//Setup the debounce info
+		NPCInfo->investigateDebounceTime		= NPCInfo->investigateCount * 1000;
+		NPCInfo->investigateSoundDebounceTime	= level.time + 1000;
+		NPCInfo->pauseTime						= level.time;
+		VectorCopy( level.alertEvents[eventID].position, NPCInfo->investigateGoal );
+	}
+
+	if ( level.alertEvents[eventID].level >= AEL_DANGER )
+	{
+		NPCInfo->investigateDebounceTime = Q_irand( 500, 2500 );
+	}
+
+	//Start investigating
+	NPCInfo->tempBehavior = BS_INVESTIGATE;
+	return qtrue;
+}
+
+/*
+-------------------------
+ST_OffsetLook
+-------------------------
+*/
+
+static void ST_OffsetLook( float offset, vec3_t out )
+{
+	vec3_t	angles, forward, temp;
+
+	GetAnglesForDirection( NPC->r.currentOrigin, NPCInfo->investigateGoal, angles );
+	angles[YAW] += offset;
+	AngleVectors( angles, forward, NULL, NULL );
+	VectorMA( NPC->r.currentOrigin, 64, forward, out );
+	
+	CalcEntitySpot( NPC, SPOT_HEAD, temp );
+	out[2] = temp[2];
+}
+
+/*
+-------------------------
+ST_LookAround
+-------------------------
+*/
+
+static void ST_LookAround( void )
+{
+	vec3_t	lookPos;
+	float	perc = (float) ( level.time - NPCInfo->pauseTime ) / (float) NPCInfo->investigateDebounceTime;
+
+	//Keep looking at the spot
+	if ( perc < 0.25 )
+	{
+		VectorCopy( NPCInfo->investigateGoal, lookPos );
+	}
+	else if ( perc < 0.5f )		//Look up but straight ahead
+	{
+		ST_OffsetLook( 0.0f, lookPos );
+	}
+	else if ( perc < 0.75f )	//Look right
+	{
+		ST_OffsetLook( 45.0f, lookPos );
+	}
+	else	//Look left
+	{
+		ST_OffsetLook( -45.0f, lookPos );
+	}
+
+	NPC_FacePosition( lookPos, qtrue );
+}
+
+/*
+-------------------------
+NPC_BSST_Investigate
+-------------------------
+*/
+
+void NPC_BSST_Investigate( void )
+{
+	//get group- mainly for group speech debouncing, but may use for group scouting/investigating AI, too
+	AI_GetGroup( NPC );
+
+	if( NPCInfo->scriptFlags & SCF_FIRE_WEAPON )
+	{
+		WeaponThink( qtrue );
+	}
+
+	if ( NPCInfo->confusionTime < level.time )
+	{
+		if ( NPCInfo->scriptFlags&SCF_LOOK_FOR_ENEMIES )
+		{
+			//Look for an enemy
+			if ( NPC_CheckPlayerTeamStealth() )
+			{
+				//NPCInfo->behaviorState	= BS_HUNT_AND_KILL;//should be auto now
+				ST_Speech( NPC, SPEECH_DETECTED, 0 );
+				NPCInfo->tempBehavior	= BS_DEFAULT;
+				NPC_UpdateAngles( qtrue, qtrue );
+				return;
+			}
+		}
+	}
+
+	if ( !(NPCInfo->scriptFlags&SCF_IGNORE_ALERTS) )
+	{
+		int alertEvent = NPC_CheckAlertEvents( qtrue, qtrue, NPCInfo->lastAlertID, qfalse, AEL_MINOR );
+
+		//There is an event to look at
+		if ( alertEvent >= 0 )
+		{
+			if ( NPCInfo->confusionTime < level.time )
+			{
+				if ( NPC_CheckForDanger( alertEvent ) )
+				{//running like hell
+					ST_Speech( NPC, SPEECH_COVER, 0 );//FIXME: flee sound?
+					return;
+				}
+			}
+
+			if ( level.alertEvents[alertEvent].ID != NPCInfo->lastAlertID )
+			{
+				NPC_ST_InvestigateEvent( alertEvent, qtrue );
+			}
+		}
+	}
+
+	//If we're done looking, then just return to what we were doing
+	if ( ( NPCInfo->investigateDebounceTime + NPCInfo->pauseTime ) < level.time )
+	{
+		NPCInfo->tempBehavior = BS_DEFAULT;
+		NPCInfo->goalEntity = UpdateGoal();
+		
+		NPC_UpdateAngles( qtrue, qtrue );
+		//Say something
+		ST_Speech( NPC, SPEECH_GIVEUP, 0 );
+		return;
+	}
+
+	//FIXME: else, look for new alerts
+
+	//See if we're searching for the noise's origin
+	if ( NPCInfo->localState == LSTATE_INVESTIGATE && (NPCInfo->goalEntity!=NULL) )
+	{
+		//See if we're there
+		if ( NAV_HitNavGoal( NPC->r.currentOrigin, NPC->r.mins, NPC->r.maxs, NPCInfo->goalEntity->r.currentOrigin, 32, FlyingCreature( NPC ) ) == qfalse )
+		{
+			ucmd.buttons |= BUTTON_WALKING;
+
+			//Try and move there
+			if ( NPC_MoveToGoal( qtrue )  )
+			{
+				//Bump our times
+				NPCInfo->investigateDebounceTime	= NPCInfo->investigateCount * 5000;
+				NPCInfo->pauseTime					= level.time;
+
+				NPC_UpdateAngles( qtrue, qtrue );
+				return;
+			}
+		}
+
+		//Otherwise we're done or have given up
+		//Say something
+		//ST_Speech( NPC, SPEECH_LOOK, 0.33f );
+		NPCInfo->localState = LSTATE_NONE;
+	}
+
+	//Look around
+	ST_LookAround();
+}
+
+/*
+-------------------------
+NPC_BSST_Patrol
+-------------------------
+*/
+
+void NPC_BSST_Patrol( void )
+{//FIXME: pick up on bodies of dead buddies?
+	
+	//get group- mainly for group speech debouncing, but may use for group scouting/investigating AI, too
+	AI_GetGroup( NPC );
+
+	if ( NPCInfo->confusionTime < level.time )
+	{
+		//Look for any enemies
+		if ( NPCInfo->scriptFlags&SCF_LOOK_FOR_ENEMIES )
+		{
+			if ( NPC_CheckPlayerTeamStealth() )
+			{
+				//NPCInfo->behaviorState = BS_HUNT_AND_KILL;//should be auto now
+				//NPC_AngerSound();
+				NPC_UpdateAngles( qtrue, qtrue );
+				return;
+			}
+		}
+	}
+
+	if ( !(NPCInfo->scriptFlags&SCF_IGNORE_ALERTS) )
+	{
+		int alertEvent = NPC_CheckAlertEvents( qtrue, qtrue, -1, qfalse, AEL_MINOR );
+
+		//There is an event to look at
+		if ( alertEvent >= 0 )
+		{
+			if ( NPC_ST_InvestigateEvent( alertEvent, qfalse ) )
+			{//actually going to investigate it
+				NPC_UpdateAngles( qtrue, qtrue );
+				return;
+			}
+		}
+	}
+
+	//If we have somewhere to go, then do that
+	if ( UpdateGoal() )
+	{
+		ucmd.buttons |= BUTTON_WALKING;
+		//ST_Move( NPCInfo->goalEntity );
+		NPC_MoveToGoal( qtrue );
+	}
+	else// if ( !(NPCInfo->scriptFlags&SCF_IGNORE_ALERTS) )
+	{
+		if ( NPC->client->NPC_class != CLASS_IMPERIAL && NPC->client->NPC_class != CLASS_IMPWORKER )
+		{//imperials do not look around
+			if ( TIMER_Done( NPC, "enemyLastVisible" ) )
+			{//nothing suspicious, look around
+				if ( !Q_irand( 0, 30 ) )
+				{
+					NPCInfo->desiredYaw = NPC->s.angles[1] + Q_irand( -90, 90 );
+				}
+				if ( !Q_irand( 0, 30 ) )
+				{
+					NPCInfo->desiredPitch = Q_irand( -20, 20 );
+				}
+			}
+		}
+	}
+
+	NPC_UpdateAngles( qtrue, qtrue );
+	//TEMP hack for Imperial stand anim
+	if ( NPC->client->NPC_class == CLASS_IMPERIAL || NPC->client->NPC_class == CLASS_IMPWORKER )
+	{//hack
+		if ( ucmd.forwardmove || ucmd.rightmove || ucmd.upmove )
+		{//moving
+	
+			if( (NPC->client->ps.torsoTimer <= 0) || (NPC->client->ps.torsoAnim == BOTH_STAND4) ) 			
+			{
+				if ( (ucmd.buttons&BUTTON_WALKING) && !(NPCInfo->scriptFlags&SCF_RUNNING) )
+				{//not running, only set upper anim
+					//  No longer overrides scripted anims
+					NPC_SetAnim( NPC, SETANIM_TORSO, BOTH_STAND4, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+					NPC->client->ps.torsoTimer = 200;
+				}
+			}
+		}
+		else
+		{//standing still, set both torso and legs anim
+			//  No longer overrides scripted anims
+			if( ( NPC->client->ps.torsoTimer <= 0 || (NPC->client->ps.torsoAnim == BOTH_STAND4) ) &&
+				( NPC->client->ps.legsTimer <= 0  || (NPC->client->ps.legsAnim == BOTH_STAND4) ) )
+			{
+				NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_STAND4, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+				NPC->client->ps.torsoTimer = NPC->client->ps.legsTimer = 200;
+			}
+		}
+		//FIXME: this is a disgusting hack that is supposed to make the Imperials start with their weapon holstered- need a better way
+		if ( NPC->client->ps.weapon != WP_NONE )
+		{
+			ChangeWeapon( NPC, WP_NONE );
+			NPC->client->ps.weapon = WP_NONE;
+			NPC->client->ps.weaponstate = WEAPON_READY;
+			/*
+			if ( NPC->weaponModel[0] > 0 )
+			{
+				gi.G2API_RemoveGhoul2Model( NPC->ghoul2, NPC->weaponModel[0] );
+				NPC->weaponModel[0] = -1;
+			}
+			*/
+			//rwwFIXMEFIXME: Do this?
+		}
+	}
+}
+
+/*
+-------------------------
+NPC_BSST_Idle
+-------------------------
+*/
+/*
+void NPC_BSST_Idle( void )
+{
+	int alertEvent = NPC_CheckAlertEvents( qtrue, qtrue );
+
+	//There is an event to look at
+	if ( alertEvent >= 0 )
+	{
+		NPC_ST_InvestigateEvent( alertEvent, qfalse );
+		NPC_UpdateAngles( qtrue, qtrue );
+		return;
+	}
+
+	TIMER_Set( NPC, "roamTime", 2000 + Q_irand( 1000, 2000 ) );
+
+	NPC_UpdateAngles( qtrue, qtrue );
+}
+*/
+/*
+-------------------------
+ST_CheckMoveState
+-------------------------
+*/
+
+static void ST_CheckMoveState( void )
+{
+	if ( trap_ICARUS_TaskIDPending( NPC, TID_MOVE_NAV ) )
+	{//moving toward a goal that a script is waiting on, so don't stop for anything!
+		move = qtrue;
+	}
+	//See if we're a scout
+	else if ( NPCInfo->squadState == SQUAD_SCOUT )
+	{
+		//If we're supposed to stay put, then stand there and fire
+		if ( TIMER_Done( NPC, "stick" ) == qfalse )
+		{
+			move = qfalse;
+			return;
+		}
+
+		//Otherwise, if we can see our target, just shoot
+		if ( enemyLOS )
+		{
+			if ( enemyCS )
+			{
+				//if we're going after our enemy, we can stop now
+				if ( NPCInfo->goalEntity == NPC->enemy )
+				{
+					AI_GroupUpdateSquadstates( NPCInfo->group, NPC, SQUAD_STAND_AND_SHOOT );
+					move = qfalse;
+					return;
+				}
+			}
+		}
+		else
+		{
+			//Move to find our target
+			faceEnemy = qfalse;
+		}
+
+		/*
+		if ( TIMER_Done( NPC, "scoutTime" ) )
+		{//we can't scout to him, someone else give it a try
+			AI_GroupUpdateSquadstates( NPCInfo->group, NPC, SQUAD_STAND_AND_SHOOT );
+			TIMER_Set( NPC, "roamTime", Q_irand( 1000, 2000 ) );
+			move = qfalse;
+			return;
+		}
+		*/
+
+		//ucmd.buttons |= BUTTON_CAREFUL;
+	}
+	//See if we're running away
+	else if ( NPCInfo->squadState == SQUAD_RETREAT )
+	{
+		if ( NPCInfo->goalEntity )
+		{
+			faceEnemy = qfalse;
+		}
+		else
+		{//um, lost our goal?  Just stand and shoot, then
+			NPCInfo->squadState = SQUAD_STAND_AND_SHOOT;
+		}
+	}
+	//see if we're heading to some other combatPoint
+	else if ( NPCInfo->squadState == SQUAD_TRANSITION )
+	{
+		//ucmd.buttons |= BUTTON_CAREFUL;
+		if ( !NPCInfo->goalEntity )
+		{//um, lost our goal?  Just stand and shoot, then
+			NPCInfo->squadState = SQUAD_STAND_AND_SHOOT;
+		}
+	}
+	//see if we're at point, duck and fire
+	else if ( NPCInfo->squadState == SQUAD_POINT )
+	{
+		if ( TIMER_Done( NPC, "stick" ) )
+		{
+			AI_GroupUpdateSquadstates( NPCInfo->group, NPC, SQUAD_STAND_AND_SHOOT );
+			return;
+		}
+
+		move = qfalse;
+		return;
+	}
+	//see if we're just standing around
+	else if ( NPCInfo->squadState == SQUAD_STAND_AND_SHOOT )
+	{//from this squadState we can transition to others?
+		move = qfalse;
+		return;
+	}
+	//see if we're hiding
+	else if ( NPCInfo->squadState == SQUAD_COVER )
+	{
+		//Should we duck?
+		move = qfalse;
+		return;
+	}
+	//see if we're just standing around
+	else if ( NPCInfo->squadState == SQUAD_IDLE )
+	{
+		if ( !NPCInfo->goalEntity )
+		{
+			move = qfalse;
+			return;
+		}
+	}
+	//??
+	else
+	{//invalid squadState!
+	}
+
+	//See if we're moving towards a goal, not the enemy
+	if ( ( NPCInfo->goalEntity != NPC->enemy ) && ( NPCInfo->goalEntity != NULL ) )
+	{
+		//Did we make it?
+		if ( NAV_HitNavGoal( NPC->r.currentOrigin, NPC->r.mins, NPC->r.maxs, NPCInfo->goalEntity->r.currentOrigin, 16, FlyingCreature( NPC ) ) || 
+			( !trap_ICARUS_TaskIDPending( NPC, TID_MOVE_NAV ) && NPCInfo->squadState == SQUAD_SCOUT && enemyLOS && enemyDist <= 10000 ) )
+		{//either hit our navgoal or our navgoal was not a crucial (scripted) one (maybe a combat point) and we're scouting and found our enemy
+			int	newSquadState = SQUAD_STAND_AND_SHOOT;
+			//we got where we wanted to go, set timers based on why we were running
+			switch ( NPCInfo->squadState )
+			{
+			case SQUAD_RETREAT://was running away
+				//done fleeing, obviously
+				TIMER_Set( NPC, "duck", (NPC->client->pers.maxHealth - NPC->health) * 100 );
+				TIMER_Set( NPC, "hideTime", Q_irand( 3000, 7000 ) );
+				TIMER_Set( NPC, "flee", -level.time );
+				newSquadState = SQUAD_COVER;
+				break;
+			case SQUAD_TRANSITION://was heading for a combat point
+				TIMER_Set( NPC, "hideTime", Q_irand( 2000, 4000 ) );
+				break;
+			case SQUAD_SCOUT://was running after player
+				break;
+			default:
+				break;
+			}
+			AI_GroupUpdateSquadstates( NPCInfo->group, NPC, newSquadState );
+			NPC_ReachedGoal();
+			//don't attack right away
+			TIMER_Set( NPC, "attackDelay", Q_irand( 250, 500 ) );	//FIXME: Slant for difficulty levels
+			//don't do something else just yet
+			TIMER_Set( NPC, "roamTime", Q_irand( 1000, 4000 ) );
+			return;
+		}
+
+		//keep going, hold of roamTimer until we get there
+		TIMER_Set( NPC, "roamTime", Q_irand( 4000, 8000 ) );
+	}
+}
+
+void ST_ResolveBlockedShot( int hit )
+{
+	int	stuckTime;
+	//figure out how long we intend to stand here, max
+	if ( TIMER_Get( NPC, "roamTime" ) > TIMER_Get( NPC, "stick" ) )
+	{
+		stuckTime = TIMER_Get( NPC, "roamTime" )-level.time;
+	}
+	else
+	{
+		stuckTime = TIMER_Get( NPC, "stick" )-level.time;
+	}
+
+	if ( TIMER_Done( NPC, "duck" ) )
+	{//we're not ducking
+		if ( AI_GroupContainsEntNum( NPCInfo->group, hit ) )
+		{
+			gentity_t *member = &g_entities[hit];
+			if ( TIMER_Done( member, "duck" ) )
+			{//they aren't ducking
+				if ( TIMER_Done( member, "stand" ) )
+				{//they're not being forced to stand
+					//tell them to duck at least as long as I'm not moving
+					TIMER_Set( member, "duck", stuckTime );
+					return;
+				}
+			}
+		}
+	}
+	else
+	{//maybe we should stand
+		if ( TIMER_Done( NPC, "stand" ) )
+		{//stand for as long as we'll be here
+			TIMER_Set( NPC, "stand", stuckTime );
+			return;
+		}
+	}
+	//Hmm, can't resolve this by telling them to duck or telling me to stand
+	//We need to move!
+	TIMER_Set( NPC, "roamTime", -1 );
+	TIMER_Set( NPC, "stick", -1 );
+	TIMER_Set( NPC, "duck", -1 );
+	TIMER_Set( NPC, "attakDelay", Q_irand( 1000, 3000 ) );
+}
+
+/*
+-------------------------
+ST_CheckFireState
+-------------------------
+*/
+
+static void ST_CheckFireState( void )
+{
+	if ( enemyCS )
+	{//if have a clear shot, always try
+		return;
+	}
+
+	if ( NPCInfo->squadState == SQUAD_RETREAT || NPCInfo->squadState == SQUAD_TRANSITION || NPCInfo->squadState == SQUAD_SCOUT )
+	{//runners never try to fire at the last pos
+		return;
+	}
+
+	if ( !VectorCompare( NPC->client->ps.velocity, vec3_origin ) )
+	{//if moving at all, don't do this
+		return;
+	}
+
+	//See if we should continue to fire on their last position
+	//!TIMER_Done( NPC, "stick" ) || 
+	if ( !hitAlly //we're not going to hit an ally
+		&& enemyInFOV //enemy is in our FOV //FIXME: or we don't have a clear LOS?
+		&& NPCInfo->enemyLastSeenTime > 0 //we've seen the enemy
+		&& NPCInfo->group //have a group
+		&& (NPCInfo->group->numState[SQUAD_RETREAT]>0||NPCInfo->group->numState[SQUAD_TRANSITION]>0||NPCInfo->group->numState[SQUAD_SCOUT]>0) )//laying down covering fire
+	{
+		if ( level.time - NPCInfo->enemyLastSeenTime < 10000 &&//we have seem the enemy in the last 10 seconds
+			(!NPCInfo->group || level.time - NPCInfo->group->lastSeenEnemyTime < 10000 ))//we are not in a group or the group has seen the enemy in the last 10 seconds
+		{
+			if ( !Q_irand( 0, 10 ) )
+			{
+				//Fire on the last known position
+				vec3_t	muzzle, dir, angles;
+				qboolean tooClose = qfalse;
+				qboolean tooFar = qfalse;
+				float distThreshold;
+				float dist;
+
+				CalcEntitySpot( NPC, SPOT_HEAD, muzzle );
+				if ( VectorCompare( impactPos, vec3_origin ) )
+				{//never checked ShotEntity this frame, so must do a trace...
+					trace_t tr;
+					//vec3_t	mins = {-2,-2,-2}, maxs = {2,2,2};
+					vec3_t	forward, end;
+					AngleVectors( NPC->client->ps.viewangles, forward, NULL, NULL );
+					VectorMA( muzzle, 8192, forward, end );
+					trap_Trace( &tr, muzzle, vec3_origin, vec3_origin, end, NPC->s.number, MASK_SHOT );
+					VectorCopy( tr.endpos, impactPos );
+				}
+
+				//see if impact would be too close to me
+				distThreshold = 16384/*128*128*/;//default
+				switch ( NPC->s.weapon )
+				{
+				case WP_ROCKET_LAUNCHER:
+				case WP_FLECHETTE:
+				case WP_THERMAL:
+				case WP_TRIP_MINE:
+				case WP_DET_PACK:
+					distThreshold = 65536/*256*256*/;
+					break;
+				case WP_REPEATER:
+					if ( NPCInfo->scriptFlags&SCF_ALT_FIRE )
+					{
+						distThreshold = 65536/*256*256*/;
+					}
+					break;
+				default:
+					break;
+				}
+
+				dist = DistanceSquared( impactPos, muzzle );
+
+				if ( dist < distThreshold )
+				{//impact would be too close to me
+					tooClose = qtrue;
+				}
+				else if ( level.time - NPCInfo->enemyLastSeenTime > 5000 ||
+					(NPCInfo->group && level.time - NPCInfo->group->lastSeenEnemyTime > 5000 ))
+				{//we've haven't seen them in the last 5 seconds
+					//see if it's too far from where he is
+					distThreshold = 65536/*256*256*/;//default
+					switch ( NPC->s.weapon )
+					{
+					case WP_ROCKET_LAUNCHER:
+					case WP_FLECHETTE:
+					case WP_THERMAL:
+					case WP_TRIP_MINE:
+					case WP_DET_PACK:
+						distThreshold = 262144/*512*512*/;
+						break;
+					case WP_REPEATER:
+						if ( NPCInfo->scriptFlags&SCF_ALT_FIRE )
+						{
+							distThreshold = 262144/*512*512*/;
+						}
+						break;
+					default:
+						break;
+					}
+					dist = DistanceSquared( impactPos, NPCInfo->enemyLastSeenLocation );
+					if ( dist > distThreshold )
+					{//impact would be too far from enemy
+						tooFar = qtrue;
+					}
+				}
+
+				if ( !tooClose && !tooFar )
+				{//okay too shoot at last pos
+					VectorSubtract( NPCInfo->enemyLastSeenLocation, muzzle, dir );
+					VectorNormalize( dir );
+					vectoangles( dir, angles );
+
+					NPCInfo->desiredYaw		= angles[YAW];
+					NPCInfo->desiredPitch	= angles[PITCH];
+
+					shoot = qtrue;
+					faceEnemy = qfalse;
+					//AI_GroupUpdateSquadstates( NPCInfo->group, NPC, SQUAD_STAND_AND_SHOOT );
+					return;
+				}
+			}
+		}
+	}
+}
+
+void ST_TrackEnemy( gentity_t *self, vec3_t enemyPos )
+{
+	//clear timers
+	TIMER_Set( self, "attackDelay", Q_irand( 1000, 2000 ) );
+	//TIMER_Set( self, "duck", -1 );
+	TIMER_Set( self, "stick", Q_irand( 500, 1500 ) );
+	TIMER_Set( self, "stand", -1 );
+	TIMER_Set( self, "scoutTime", TIMER_Get( self, "stick" )-level.time+Q_irand(5000, 10000) );
+	//leave my combat point
+	NPC_FreeCombatPoint( self->NPC->combatPoint, qfalse );
+	//go after his last seen pos
+	NPC_SetMoveGoal( self, enemyPos, 16, qfalse, -1, NULL );
+}
+
+int ST_ApproachEnemy( gentity_t *self )
+{
+	TIMER_Set( self, "attackDelay", Q_irand( 250, 500 ) );
+	//TIMER_Set( self, "duck", -1 );
+	TIMER_Set( self, "stick", Q_irand( 1000, 2000 ) );
+	TIMER_Set( self, "stand", -1 );
+	TIMER_Set( self, "scoutTime", TIMER_Get( self, "stick" )-level.time+Q_irand(5000, 10000) );
+	//leave my combat point
+	NPC_FreeCombatPoint( self->NPC->combatPoint, qfalse );
+	//return the relevant combat point flags
+	return (CP_CLEAR|CP_CLOSEST);
+}
+
+void ST_HuntEnemy( gentity_t *self )
+{
+	//TIMER_Set( NPC, "attackDelay", Q_irand( 250, 500 ) );//Disabled this for now, guys who couldn't hunt would never attack
+	//TIMER_Set( NPC, "duck", -1 );
+	TIMER_Set( NPC, "stick", Q_irand( 250, 1000 ) );
+	TIMER_Set( NPC, "stand", -1 );
+	TIMER_Set( NPC, "scoutTime", TIMER_Get( NPC, "stick" )-level.time+Q_irand(5000, 10000) );
+	//leave my combat point
+	NPC_FreeCombatPoint( NPCInfo->combatPoint, qfalse );
+	//go directly after the enemy
+	if ( NPCInfo->scriptFlags & SCF_CHASE_ENEMIES )
+	{
+		self->NPC->goalEntity = NPC->enemy;
+	}
+}
+
+void ST_TransferTimers( gentity_t *self, gentity_t *other )
+{
+	TIMER_Set( other, "attackDelay", TIMER_Get( self, "attackDelay" )-level.time );
+	TIMER_Set( other, "duck", TIMER_Get( self, "duck" )-level.time );
+	TIMER_Set( other, "stick", TIMER_Get( self, "stick" )-level.time );
+	TIMER_Set( other, "scoutTime", TIMER_Get( self, "scout" )-level.time );
+	TIMER_Set( other, "roamTime", TIMER_Get( self, "roamTime" )-level.time );
+	TIMER_Set( other, "stand", TIMER_Get( self, "stand" )-level.time );
+	TIMER_Set( self, "attackDelay", -1 );
+	TIMER_Set( self, "duck", -1 );
+	TIMER_Set( self, "stick", -1 );
+	TIMER_Set( self, "scoutTime", -1 );
+	TIMER_Set( self, "roamTime", -1 );
+	TIMER_Set( self, "stand", -1 );
+}
+
+void ST_TransferMoveGoal( gentity_t *self, gentity_t *other )
+{
+	if ( trap_ICARUS_TaskIDPending( self, TID_MOVE_NAV ) )
+	{//can't transfer movegoal when a script we're running is waiting to complete
+		return;
+	}
+	if ( self->NPC->combatPoint != -1 )
+	{//I've got a combatPoint I'm going to, give it to him
+		self->NPC->lastFailedCombatPoint = other->NPC->combatPoint = self->NPC->combatPoint;
+		self->NPC->combatPoint = -1;
+	}
+	else
+	{//I must be going for a goal, give that to him instead
+		if ( self->NPC->goalEntity == self->NPC->tempGoal )
+		{
+			NPC_SetMoveGoal( other, self->NPC->tempGoal->r.currentOrigin, self->NPC->goalRadius, ((self->NPC->tempGoal->flags&FL_NAVGOAL)?qtrue:qfalse), -1, NULL );
+		}
+		else
+		{
+			other->NPC->goalEntity = self->NPC->goalEntity;
+		}
+	}
+	//give him my squadstate
+	AI_GroupUpdateSquadstates( self->NPC->group, other, NPCInfo->squadState );
+
+	//give him my timers and clear mine
+	ST_TransferTimers( self, other );
+
+	//now make me stand around for a second or two at least
+	AI_GroupUpdateSquadstates( self->NPC->group, self, SQUAD_STAND_AND_SHOOT );
+	TIMER_Set( self, "stand", Q_irand( 1000, 3000 ) );
+}
+
+int ST_GetCPFlags( void )
+{
+	int cpFlags = 0;
+	if ( NPC && NPCInfo->group )
+	{
+		if ( NPC == NPCInfo->group->commander && NPC->client->NPC_class == CLASS_IMPERIAL )
+		{//imperials hang back and give orders
+			if ( NPCInfo->group->numGroup > 1 && Q_irand( -3, NPCInfo->group->numGroup ) > 1 )
+			{//FIXME: make sure he;s giving orders with these lines
+				if ( Q_irand( 0, 1 ) )
+				{
+					ST_Speech( NPC, SPEECH_CHASE, 0.5 );
+				}
+				else
+				{
+					ST_Speech( NPC, SPEECH_YELL, 0.5 );
+				}
+			}
+			cpFlags = (CP_CLEAR|CP_COVER|CP_AVOID|CP_SAFE|CP_RETREAT);
+		}
+		else if ( NPCInfo->group->morale < 0 )
+		{//hide
+			cpFlags = (CP_COVER|CP_AVOID|CP_SAFE|CP_RETREAT);
+		}
+		else if ( NPCInfo->group->morale < NPCInfo->group->numGroup )
+		{//morale is low for our size
+			int moraleDrop = NPCInfo->group->numGroup - NPCInfo->group->morale;
+			if ( moraleDrop < -6 )
+			{//flee (no clear shot needed)
+				cpFlags = (CP_FLEE|CP_RETREAT|CP_COVER|CP_AVOID|CP_SAFE);
+			}
+			else if ( moraleDrop < -3 )
+			{//retreat (no clear shot needed)
+				cpFlags = (CP_RETREAT|CP_COVER|CP_AVOID|CP_SAFE);
+			}
+			else if ( moraleDrop < 0 )
+			{//cover (no clear shot needed)
+				cpFlags = (CP_COVER|CP_AVOID|CP_SAFE);
+			}
+		}
+		else
+		{
+			int moraleBoost = NPCInfo->group->morale - NPCInfo->group->numGroup;
+			if ( moraleBoost > 20 )
+			{//charge to any one and outflank (no cover needed)
+				cpFlags = (CP_CLEAR|CP_FLANK|CP_APPROACH_ENEMY);
+			}
+			else if ( moraleBoost > 15 )
+			{//charge to closest one (no cover needed)
+				cpFlags = (CP_CLEAR|CP_CLOSEST|CP_APPROACH_ENEMY);
+			}
+			else if ( moraleBoost > 10 )
+			{//charge closer (no cover needed)
+				cpFlags = (CP_CLEAR|CP_APPROACH_ENEMY);
+			}
+		}
+	}
+	if ( !cpFlags )
+	{
+		//at some medium level of morale
+		switch( Q_irand( 0, 3 ) )
+		{
+		case 0://just take the nearest one
+			cpFlags = (CP_CLEAR|CP_COVER|CP_NEAREST);
+			break;
+		case 1://take one closer to the enemy
+			cpFlags = (CP_CLEAR|CP_COVER|CP_APPROACH_ENEMY);
+			break;
+		case 2://take the one closest to the enemy
+			cpFlags = (CP_CLEAR|CP_COVER|CP_CLOSEST|CP_APPROACH_ENEMY);
+			break;
+		case 3://take the one on the other side of the enemy
+			cpFlags = (CP_CLEAR|CP_COVER|CP_FLANK|CP_APPROACH_ENEMY);
+			break;
+		}
+	}
+	if ( NPC && (NPCInfo->scriptFlags&SCF_USE_CP_NEAREST) )
+	{
+		cpFlags &= ~(CP_FLANK|CP_APPROACH_ENEMY|CP_CLOSEST);
+		cpFlags |= CP_NEAREST;
+	}
+	return cpFlags;
+}
+/*
+-------------------------
+ST_Commander
+
+  Make decisions about who should go where, etc.
+
+FIXME: leader (group-decision-making) AI?
+FIXME: need alternate routes!
+FIXME: more group voice interaction
+FIXME: work in pairs?
+
+-------------------------
+*/
+void ST_Commander( void )
+{
+	int		i, j;
+	int		cp, cpFlags_org, cpFlags;
+	AIGroupInfo_t	*group = NPCInfo->group;
+	gentity_t	*member;//, *buddy;
+	qboolean	runner = qfalse;
+	qboolean	enemyLost = qfalse;
+	qboolean	enemyProtected = qfalse;
+	qboolean	scouting = qfalse;
+	int			squadState;
+	int			curMemberNum, lastMemberNum;
+	float		avoidDist;
+
+	group->processed = qtrue;
+
+	if ( group->enemy == NULL || group->enemy->client == NULL )
+	{//hmm, no enemy...?!
+		return;
+	}
+
+	//FIXME: have this group commander check the enemy group (if any) and see if they have 
+	//		superior numbers.  If they do, fall back rather than advance.  If you have
+	//		superior numbers, advance on them.
+	//FIXME: find the group commander and have him occasionally give orders when there is speech
+	//FIXME: start fleeing when only a couple of you vs. a lightsaber, possibly give up if the only one left
+
+	SaveNPCGlobals();
+
+	if ( group->lastSeenEnemyTime < level.time - 180000 )
+	{//dissolve the group
+		ST_Speech( NPC, SPEECH_LOST, 0.0f );
+		group->enemy->waypoint = NAV_FindClosestWaypointForEnt( group->enemy, WAYPOINT_NONE );
+		for ( i = 0; i < group->numGroup; i++ )
+		{
+			member = &g_entities[group->member[i].number];
+			SetNPCGlobals( member );
+			if ( trap_ICARUS_TaskIDPending( NPC, TID_MOVE_NAV ) )
+			{//running somewhere that a script requires us to go, don't break from that
+				continue;
+			}
+			if ( !(NPCInfo->scriptFlags&SCF_CHASE_ENEMIES) )
+			{//not allowed to move on my own
+				continue;
+			}
+			//Lost enemy for three minutes?  go into search mode?
+			G_ClearEnemy( NPC );
+			NPC->waypoint = NAV_FindClosestWaypointForEnt( NPC, group->enemy->waypoint );
+			if ( NPC->waypoint == WAYPOINT_NONE )
+			{
+				NPCInfo->behaviorState = BS_DEFAULT;//BS_PATROL;
+			}
+			else if ( group->enemy->waypoint == WAYPOINT_NONE || (trap_Nav_GetPathCost( NPC->waypoint, group->enemy->waypoint ) >= Q3_INFINITE) )
+			{
+				NPC_BSSearchStart( NPC->waypoint, BS_SEARCH );
+			}
+			else
+			{
+				NPC_BSSearchStart( group->enemy->waypoint, BS_SEARCH );
+			}
+		}
+		group->enemy = NULL;
+		RestoreNPCGlobals();
+		return;
+	}
+
+
+	//See if anyone in our group is not alerted and alert them
+	/*
+	for ( i = 0; i < group->numGroup; i++ )
+	{
+		member = &g_entities[group->member[i].number];
+		if ( !member->enemy )
+		{//he's not mad, so get him mad
+			//Have his buddy tell him to get mad
+			if ( group->member[i].closestBuddy != ENTITYNUM_NONE )
+			{
+				buddy = &g_entities[group->member[i].closestBuddy];
+				if ( buddy->enemy == group->enemy )
+				{
+					SetNPCGlobals( buddy );
+					ST_Speech( NPC, SPEECH_CHARGE, 0.7f );
+				}
+			}
+			SetNPCGlobals( member );
+			G_SetEnemy( member, group->enemy );
+		}
+	}
+	*/
+	//Okay, everyone is mad
+
+	//see if anyone is running
+	if ( group->numState[SQUAD_SCOUT] > 0 || 
+		group->numState[SQUAD_TRANSITION] > 0 || 
+		group->numState[SQUAD_RETREAT] > 0 )
+	{//someone is running
+		runner = qtrue;
+	}
+
+	if ( /*!runner &&*/ group->lastSeenEnemyTime > level.time - 32000 && group->lastSeenEnemyTime < level.time - 30000 )
+	{//no-one has seen the enemy for 30 seconds// and no-one is running after him
+		if ( group->commander && !Q_irand( 0, 1 ) )
+		{
+			ST_Speech( group->commander, SPEECH_ESCAPING, 0.0f );
+		}
+		else
+		{
+			ST_Speech( NPC, SPEECH_ESCAPING, 0.0f );
+		}
+		//don't say this again
+		NPCInfo->blockedSpeechDebounceTime = level.time + 3000;
+	}
+
+	if ( group->lastSeenEnemyTime < level.time - 10000 )
+	{//no-one has seen the enemy for at least 10 seconds!  Should send a scout
+		enemyLost = qtrue;
+	}
+
+	if ( group->lastClearShotTime < level.time - 5000 )
+	{//no-one has had a clear shot for 5 seconds!
+		enemyProtected = qtrue;
+	}
+
+	//Go through the list:
+
+	//Everyone should try to get to a combat point if possible
+	if ( d_asynchronousGroupAI.integer )
+	{//do one member a turn
+		group->activeMemberNum++;
+		if ( group->activeMemberNum >= group->numGroup )
+		{
+			group->activeMemberNum = 0;
+		}
+		curMemberNum = group->activeMemberNum;
+		lastMemberNum = curMemberNum + 1;
+	}
+	else
+	{
+		curMemberNum = 0;
+		lastMemberNum = group->numGroup;
+	}
+	for ( i = curMemberNum; i < lastMemberNum; i++ )
+	{
+		//reset combat point flags
+		cp = -1;
+		cpFlags = 0;
+		squadState = SQUAD_IDLE;
+		avoidDist = 0;
+		scouting = qfalse;
+
+		//get the next guy
+		member = &g_entities[group->member[i].number];
+		if ( !member->enemy )
+		{//don't include guys that aren't angry
+			continue;
+		}
+		SetNPCGlobals( member );
+
+		if ( !TIMER_Done( NPC, "flee" ) )
+		{//running away
+			continue;
+		}
+
+		if ( trap_ICARUS_TaskIDPending( NPC, TID_MOVE_NAV ) )
+		{//running somewhere that a script requires us to go
+			continue;
+		}
+
+		if ( NPC->s.weapon == WP_NONE 
+			&& NPCInfo->goalEntity 
+			&& NPCInfo->goalEntity == NPCInfo->tempGoal
+			&& NPCInfo->goalEntity->enemy
+			&& NPCInfo->goalEntity->enemy->s.eType == ET_ITEM )
+		{//running to pick up a gun, don't do other logic
+			continue;
+		}
+
+		//see if this member should start running (only if have no officer... FIXME: should always run from AEL_DANGER_GREAT?)
+		if ( !group->commander || group->commander->NPC->rank < RANK_ENSIGN )
+		{
+			if ( NPC_CheckForDanger( NPC_CheckAlertEvents( qtrue, qtrue, -1, qfalse, AEL_DANGER ) ) )
+			{//going to run
+				ST_Speech( NPC, SPEECH_COVER, 0 );
+				continue;
+			}
+		}
+		
+		if ( !(NPCInfo->scriptFlags&SCF_CHASE_ENEMIES) )
+		{//not allowed to do combat-movement
+			continue;
+		}
+
+		//check the local state
+		if ( NPCInfo->squadState != SQUAD_RETREAT )
+		{//not already retreating
+			if ( NPC->client->ps.weapon == WP_NONE )
+			{//weaponless, should be hiding
+				if ( NPCInfo->goalEntity == NULL || NPCInfo->goalEntity->enemy == NULL || NPCInfo->goalEntity->enemy->s.eType != ET_ITEM )
+				{//not running after a pickup
+					if ( TIMER_Done( NPC, "hideTime" ) || (DistanceSquared( group->enemy->r.currentOrigin, NPC->r.currentOrigin ) < 65536 && NPC_ClearLOS4( NPC->enemy )) )
+					{//done hiding or enemy near and can see us
+						//er, start another flee I guess?
+						NPC_StartFlee( NPC->enemy, NPC->enemy->r.currentOrigin, AEL_DANGER_GREAT, 5000, 10000 );
+					}//else, just hang here
+				}
+				continue;
+			}
+			if ( TIMER_Done( NPC, "roamTime" ) && TIMER_Done( NPC, "hideTime" ) && NPC->health > 10 && !trap_InPVS( group->enemy->r.currentOrigin, NPC->r.currentOrigin ) )
+			{//cant even see enemy
+				//better go after him
+				cpFlags |= (CP_CLEAR|CP_COVER);
+			}
+			else if ( NPCInfo->localState == LSTATE_UNDERFIRE )
+			{//we've been shot
+				switch( group->enemy->client->ps.weapon )
+				{
+				case WP_SABER:
+					if ( DistanceSquared( group->enemy->r.currentOrigin, NPC->r.currentOrigin ) < 65536 )//256 squared
+					{
+						cpFlags |= (CP_AVOID_ENEMY|CP_COVER|CP_AVOID|CP_RETREAT);
+						if ( !group->commander || group->commander->NPC->rank  < RANK_ENSIGN )
+						{
+							squadState = SQUAD_RETREAT;
+						}
+						avoidDist = 256;
+					}
+					break;
+				default:
+				case WP_BLASTER:
+					cpFlags |= (CP_COVER);
+					break;
+				}
+				if ( NPC->health <= 10 )
+				{
+					if ( !group->commander || group->commander->NPC->rank < RANK_ENSIGN )
+					{
+						cpFlags |= (CP_FLEE|CP_AVOID|CP_RETREAT);
+						squadState = SQUAD_RETREAT;
+					}
+				}
+			}
+			else
+			{//not hit, see if there are other reasons we should run
+				if ( trap_InPVS( NPC->r.currentOrigin, group->enemy->r.currentOrigin ) )
+				{//in the same room as enemy
+					if ( NPC->client->ps.weapon == WP_ROCKET_LAUNCHER &&
+						DistanceSquared( group->enemy->r.currentOrigin, NPC->r.currentOrigin ) < MIN_ROCKET_DIST_SQUARED &&
+						NPCInfo->squadState != SQUAD_TRANSITION )
+					{//too close for me to fire my weapon and I'm not already on the move
+						cpFlags |= (CP_AVOID_ENEMY|CP_CLEAR|CP_AVOID);
+						avoidDist = 256;
+					}
+					else
+					{
+						switch( group->enemy->client->ps.weapon )
+						{
+						case WP_SABER:
+							//if ( group->enemy->client->ps.SaberLength() > 0 )
+							if (!group->enemy->client->ps.saberHolstered)
+							{
+								if ( DistanceSquared( group->enemy->r.currentOrigin, NPC->r.currentOrigin ) < 65536 )
+								{
+									if ( TIMER_Done( NPC, "hideTime" ) )
+									{
+										if ( NPCInfo->squadState != SQUAD_TRANSITION )
+										{//not already moving: FIXME: we need to see if where we're going is good now?
+											cpFlags |= (CP_AVOID_ENEMY|CP_CLEAR|CP_AVOID);
+											avoidDist = 256;
+										}
+									}
+								}
+							}
+						default:
+							break;
+						}
+					}
+				}
+			}
+		}
+
+		if ( !cpFlags )
+		{//okay, we have no new enemy-driven reason to run... let's use tactics now
+			if ( runner && NPCInfo->combatPoint != -1 )
+			{//someone is running and we have a combat point already
+				if ( NPCInfo->squadState != SQUAD_SCOUT &&
+					NPCInfo->squadState != SQUAD_TRANSITION &&
+					NPCInfo->squadState != SQUAD_RETREAT )
+				{//it's not us
+					if ( TIMER_Done( NPC, "verifyCP" ) && DistanceSquared( NPC->r.currentOrigin, level.combatPoints[NPCInfo->combatPoint].origin ) > 64*64 )
+					{//1 - 3 seconds have passed since you chose a CP, see if you're there since, for some reason, you've stopped running...
+						//uh, WTF, we're not on our combat point?
+						//er, try again, I guess?
+						cp = NPCInfo->combatPoint;
+						cpFlags |= ST_GetCPFlags();
+					}
+					else
+					{//cover them
+						//stop ducking
+						TIMER_Set( NPC, "duck", -1 );
+						//start shooting
+						TIMER_Set( NPC, "attackDelay", -1 );
+						//AI should take care of the rest - fire at enemy
+					}
+				}
+				else
+				{//we're running
+					//see if we're blocked
+					if ( NPCInfo->aiFlags & NPCAI_BLOCKED )
+					{//dammit, something is in our way
+						//see if it's one of ours
+						for ( j = 0; j < group->numGroup; j++ )
+						{
+							if ( group->member[j].number == NPCInfo->blockingEntNum )
+							{//we're being blocked by one of our own, pass our goal onto them and I'll stand still
+								ST_TransferMoveGoal( NPC, &g_entities[group->member[j].number] );
+								break;
+							}
+						}
+					}
+					//we don't need to do anything else
+					continue;
+				}
+			}
+			else
+			{//okay no-one is running, use some tactics
+				if ( NPCInfo->combatPoint != -1 )
+				{//we have a combat point we're supposed to be running to
+					if ( NPCInfo->squadState != SQUAD_SCOUT &&
+						NPCInfo->squadState != SQUAD_TRANSITION &&
+						NPCInfo->squadState != SQUAD_RETREAT )
+					{//but we're not running
+						if ( TIMER_Done( NPC, "verifyCP" ) )
+						{//1 - 3 seconds have passed since you chose a CP, see if you're there since, for some reason, you've stopped running...
+							if ( DistanceSquared( NPC->r.currentOrigin, level.combatPoints[NPCInfo->combatPoint].origin ) > 64*64 )
+							{//uh, WTF, we're not on our combat point?
+								//er, try again, I guess?
+								cp = NPCInfo->combatPoint;
+								cpFlags |= ST_GetCPFlags();
+							}
+						}
+					}
+				}
+				if ( enemyLost )
+				{//if no-one has seen the enemy for a while, send a scout
+					//ask where he went
+					if ( group->numState[SQUAD_SCOUT] <= 0 )
+					{
+						scouting = qtrue;
+						NPC_ST_StoreMovementSpeech( SPEECH_CHASE, 0.0f );
+					}
+					//Since no-one else has done this, I should be the closest one, so go after him...
+					ST_TrackEnemy( NPC, group->enemyLastSeenPos );
+					//set me into scout mode
+					AI_GroupUpdateSquadstates( group, NPC, SQUAD_SCOUT );
+					//we're not using a cp, so we need to set runner to true right here
+					runner = qtrue;
+				}
+				else if ( enemyProtected )
+				{//if no-one has a clear shot at the enemy, someone should go after him
+					//FIXME: if I'm in an area where no safe combat points have a clear shot at me, they don't come after me... they should anyway, though after some extra hesitation.
+					//ALSO: seem to give up when behind an area portal?
+					//since no-one else here has done this, I should be the closest one
+					if ( TIMER_Done( NPC, "roamTime" ) && !Q_irand( 0, group->numGroup) )
+					{//only do this if we're ready to move again and we feel like it
+						cpFlags |= ST_ApproachEnemy( NPC );
+						//set me into scout mode
+						AI_GroupUpdateSquadstates( group, NPC, SQUAD_SCOUT );
+					}
+				}
+				else
+				{//group can see and has been shooting at the enemy
+					//see if we should do something fancy?
+					
+					{//we're ready to move
+						if ( NPCInfo->combatPoint == -1 )
+						{//we're not on a combat point
+							if ( 1 )//!Q_irand( 0, 2 ) )
+							{//we should go for a combat point
+								cpFlags |= ST_GetCPFlags();
+							}
+							else
+							{
+								TIMER_Set( NPC, "stick", Q_irand( 2000, 4000 ) );
+								TIMER_Set( NPC, "roamTime", Q_irand( 1000, 3000 ) );
+							}
+						}
+						else if ( TIMER_Done( NPC, "roamTime" ) )
+						{//we are already on a combat point
+							if ( i == 0 )
+							{//we're the closest
+								if ( (group->morale-group->numGroup>0) && !Q_irand( 0, 4 ) )
+								{//try to outflank him
+									cpFlags |= (CP_CLEAR|CP_COVER|CP_FLANK|CP_APPROACH_ENEMY);
+								}
+								else if ( (group->morale-group->numGroup<0) )
+								{//better move!
+									cpFlags |= ST_GetCPFlags();
+								}
+								else
+								{//If we're point, then get down
+									TIMER_Set( NPC, "roamTime", Q_irand( 2000, 5000 ) );
+									TIMER_Set( NPC, "stick", Q_irand( 2000, 5000 ) );
+									//FIXME: what if we can't shoot from a ducked pos?
+									TIMER_Set( NPC, "duck", Q_irand( 3000, 4000 ) );
+									AI_GroupUpdateSquadstates( group, NPC, SQUAD_POINT );
+								}
+							}
+							else if ( i == group->numGroup - 1 )
+							{//farthest from the enemy
+								if ( (group->morale-group->numGroup<0) )
+								{//low morale, just hang here
+									TIMER_Set( NPC, "roamTime", Q_irand( 2000, 5000 ) );
+									TIMER_Set( NPC, "stick", Q_irand( 2000, 5000 ) );
+								}
+								else if ( (group->morale-group->numGroup>0) )
+								{//try to move in on the enemy
+									cpFlags |= ST_ApproachEnemy( NPC );
+									//set me into scout mode
+									AI_GroupUpdateSquadstates( group, NPC, SQUAD_SCOUT );
+								}
+								else
+								{//use normal decision making process
+									cpFlags |= ST_GetCPFlags();
+								}
+							}
+							else
+							{//someone in-between
+								if ( (group->morale-group->numGroup<0) || !Q_irand( 0, 4 ) )
+								{//do something
+									cpFlags |= ST_GetCPFlags();
+								}
+								else
+								{
+									TIMER_Set( NPC, "stick", Q_irand( 2000, 4000 ) );
+									TIMER_Set( NPC, "roamTime", Q_irand( 2000, 4000 ) );
+								}
+							}
+						}
+					}
+					if ( !cpFlags )
+					{//still not moving
+						//see if we should say something?
+						/*
+						if ( NPC->attackDebounceTime < level.time - 2000 )
+						{//we, personally, haven't shot for 2 seconds
+							//maybe yell at the enemy?
+							ST_Speech( NPC, SPEECH_CHARGE, 0.9f );
+						}
+						*/
+
+						//see if we should do other fun stuff
+						//toy with ducking
+						if ( TIMER_Done( NPC, "duck" ) )
+						{//not ducking
+							if ( TIMER_Done( NPC, "stand" ) )
+							{//don't have to keep standing
+								if ( NPCInfo->combatPoint == -1 || (level.combatPoints[NPCInfo->combatPoint].flags&CPF_DUCK) )
+								{//okay to duck here
+									if ( !Q_irand( 0, 3 ) )
+									{
+										TIMER_Set( NPC, "duck", Q_irand( 1000, 3000 ) );
+									}
+								}
+							}
+						}
+						//FIXME: what about CPF_LEAN?
+					}
+				}
+			}
+		}
+
+		//clear the local state
+		NPCInfo->localState = LSTATE_NONE;
+
+		if ( NPCInfo->scriptFlags&SCF_USE_CP_NEAREST )
+		{
+			cpFlags &= ~(CP_FLANK|CP_APPROACH_ENEMY|CP_CLOSEST);
+			cpFlags |= CP_NEAREST;
+		}
+		//Assign combat points
+		if ( cpFlags )
+		{//we want to run to a combat point
+			/*
+			if ( NPCInfo->combatPoint != -1 )
+			{//if we're on a combat point, we obviously don't want the one we're closest to
+				cpFlags |= CP_AVOID;
+			}
+			*/
+
+			if ( group->enemy->client->ps.weapon == WP_SABER && /*group->enemy->client->ps.SaberLength() > 0*/!group->enemy->client->ps.saberHolstered )
+			{//we obviously want to avoid the enemy if he has a saber
+				cpFlags |= CP_AVOID_ENEMY;
+				avoidDist = 256;
+			}
+
+			//remember what we *wanted* to do...
+			cpFlags_org = cpFlags;
+
+			//now get a combat point
+			if ( cp == -1 )
+			{//may have had sone set above
+				cp = NPC_FindCombatPoint( NPC->r.currentOrigin, NPC->r.currentOrigin, group->enemy->r.currentOrigin, cpFlags|CP_HAS_ROUTE, avoidDist, NPCInfo->lastFailedCombatPoint );
+			}
+			while ( cp == -1 && cpFlags != CP_ANY )
+			{//start "OR"ing out certain flags to see if we can find *any* point
+				if ( cpFlags & CP_INVESTIGATE )
+				{//don't need to investigate
+					cpFlags &= ~CP_INVESTIGATE;
+				}
+				else if ( cpFlags & CP_SQUAD )
+				{//don't need to stick to squads
+					cpFlags &= ~CP_SQUAD;
+				}
+				else if ( cpFlags & CP_DUCK )
+				{//don't need to duck
+					cpFlags &= ~CP_DUCK;
+				}
+				else if ( cpFlags & CP_NEAREST )
+				{//don't need closest one to me
+					cpFlags &= ~CP_NEAREST;
+				}
+				else if ( cpFlags & CP_FLANK )
+				{//don't need to flank enemy
+					cpFlags &= ~CP_FLANK;
+				}
+				else if ( cpFlags & CP_SAFE )
+				{//don't need one that hasn't been shot at recently
+					cpFlags &= ~CP_SAFE;
+				}
+				else if ( cpFlags & CP_CLOSEST )
+				{//don't need to get closest to enemy
+					cpFlags &= ~CP_CLOSEST;
+					//but let's try to approach at least
+					cpFlags |= CP_APPROACH_ENEMY;
+				}
+				else if ( cpFlags & CP_APPROACH_ENEMY )
+				{//don't need to approach enemy
+					cpFlags &= ~CP_APPROACH_ENEMY;
+				}
+				else if ( cpFlags & CP_COVER )
+				{//don't need cover
+					cpFlags &= ~CP_COVER;
+					//but let's pick one that makes us duck
+					cpFlags |= CP_DUCK;
+				}
+				else if ( cpFlags & CP_CLEAR )
+				{//don't need a clear shot to enemy
+					cpFlags &= ~CP_CLEAR;
+				}
+				else if ( cpFlags & CP_AVOID_ENEMY )
+				{//don't need to avoid enemy
+					cpFlags &= ~CP_AVOID_ENEMY;
+				}
+				else if ( cpFlags & CP_RETREAT )
+				{//don't need to retreat
+					cpFlags &= ~CP_RETREAT;
+				}
+				else if ( cpFlags &CP_FLEE )
+				{//don't need to flee
+					cpFlags &= ~CP_FLEE;
+					//but at least avoid enemy and pick one that gives cover
+					cpFlags |= (CP_COVER|CP_AVOID_ENEMY);
+				}
+				else if ( cpFlags & CP_AVOID )
+				{//okay, even pick one right by me
+					cpFlags &= ~CP_AVOID;
+				}
+				else
+				{
+					cpFlags = CP_ANY;
+				}
+				//now try again
+				cp = NPC_FindCombatPoint( NPC->r.currentOrigin, NPC->r.currentOrigin, group->enemy->r.currentOrigin, cpFlags|CP_HAS_ROUTE, avoidDist, -1 );
+			} 
+			//see if we got a valid one
+			if ( cp != -1 )
+			{//found a combat point
+				//let others know that someone is now running
+				runner = qtrue;
+				//don't change course again until we get to where we're going
+				TIMER_Set( NPC, "roamTime", Q3_INFINITE );
+				TIMER_Set( NPC, "verifyCP", Q_irand( 1000, 3000 ) );//don't make sure you're in your CP for 1 - 3 seconds
+				NPC_SetCombatPoint( cp );
+				NPC_SetMoveGoal( NPC, level.combatPoints[cp].origin, 8, qtrue, cp, NULL );
+				//okay, try a move right now to see if we can even get there
+
+				//if ( ST_Move() )
+				{//we actually can get to it, so okay to say you're going there.
+					//FIXME: Hmm... any way we can store this move info so we don't have to do it again
+					//		when our turn to think comes up?
+
+					//set us up so others know we're on the move
+					if ( squadState != SQUAD_IDLE )
+					{
+						AI_GroupUpdateSquadstates( group, NPC, squadState );
+					}
+					else if ( cpFlags&CP_FLEE )
+					{//outright running for your life
+						AI_GroupUpdateSquadstates( group, NPC, SQUAD_RETREAT );
+					}
+					else
+					{//any other kind of transition between combat points
+						AI_GroupUpdateSquadstates( group, NPC, SQUAD_TRANSITION );
+					}
+					
+					//unless we're trying to flee, walk slowly
+					if ( !(cpFlags_org&CP_FLEE) )
+					{
+						//ucmd.buttons |= BUTTON_CAREFUL;
+					}
+
+					/*
+					if ( scouting )
+					{//successfully chasing enemy
+						ST_Speech( NPC, SPEECH_CHASE, 0.0f );
+						//don't say this again
+						//group->speechDebounceTime = level.time + 5000;
+					}
+					//flanking:
+					else */if ( cpFlags & CP_FLANK )
+					{
+						if ( group->numGroup > 1 )
+						{
+							NPC_ST_StoreMovementSpeech( SPEECH_OUTFLANK, -1 );
+						}
+					}
+					else 
+					{//okay, let's cheat
+						if ( group->numGroup > 1 )
+						{
+							float	dot = 1.0f;
+							if ( !Q_irand( 0, 3 ) )
+							{//25% of the time, see if we're flanking the enemy
+								vec3_t	eDir2Me, eDir2CP;
+								
+								VectorSubtract( NPC->r.currentOrigin, group->enemy->r.currentOrigin, eDir2Me );
+								VectorNormalize( eDir2Me );
+
+								VectorSubtract( level.combatPoints[NPCInfo->combatPoint].origin, group->enemy->r.currentOrigin, eDir2CP );
+								VectorNormalize( eDir2CP );
+
+								dot = DotProduct( eDir2Me, eDir2CP );
+							}
+							
+							if ( dot < 0.4 )
+							{//flanking!
+								NPC_ST_StoreMovementSpeech( SPEECH_OUTFLANK, -1 );
+							}
+							else if ( !Q_irand( 0, 10 ) )
+							{//regular movement
+								NPC_ST_StoreMovementSpeech( SPEECH_YELL, 0.2f );//was SPEECH_COVER
+							}
+						}
+					}
+					/*
+					else if ( cpFlags & CP_CLOSEST || cpFlags & CP_APPROACH_ENEMY )
+					{
+						if ( group->numGroup > 1 )
+						{
+							NPC_ST_StoreMovementSpeech( SPEECH_CHASE, 0.4f );
+						}
+					}
+					*/
+				}//else: nothing, a failed move should clear the combatPoint and you can try again next frame
+			}
+			else if ( NPCInfo->squadState == SQUAD_SCOUT )
+			{//we couldn't find a combatPoint by the player, so just go after him directly
+				ST_HuntEnemy( NPC );
+				//set me into scout mode
+				AI_GroupUpdateSquadstates( group, NPC, SQUAD_SCOUT );
+				//AI should take care of rest
+			}
+		}
+	}
+
+	RestoreNPCGlobals();
+	return;
+}
+
+/*
+-------------------------
+NPC_BSST_Attack
+-------------------------
+*/
+
+void NPC_BSST_Attack( void )
+{
+	vec3_t	enemyDir, shootDir;
+	float dot;
+
+	//Don't do anything if we're hurt
+	if ( NPC->painDebounceTime > level.time )
+	{
+		NPC_UpdateAngles( qtrue, qtrue );
+		return;
+	}
+
+	//NPC_CheckEnemy( qtrue, qfalse );
+	//If we don't have an enemy, just idle
+	if ( NPC_CheckEnemyExt(qfalse) == qfalse )//!NPC->enemy )//
+	{
+		NPC->enemy = NULL;
+		if( NPC->client->playerTeam == NPCTEAM_PLAYER )
+		{
+			NPC_BSPatrol();
+		}
+		else
+		{
+			NPC_BSST_Patrol();//FIXME: or patrol?
+		}
+		return;
+	}
+
+	//FIXME: put some sort of delay into the guys depending on how they saw you...?
+
+	//Get our group info
+	if ( TIMER_Done( NPC, "interrogating" ) )
+	{
+		AI_GetGroup( NPC );//, 45, 512, NPC->enemy );
+	}
+	else
+	{
+		//FIXME: when done interrogating, I should send out a team alert!
+	}
+
+	if ( NPCInfo->group )
+	{//I belong to a squad of guys - we should *always* have a group
+		if ( !NPCInfo->group->processed )
+		{//I'm the first ent in my group, I'll make the command decisions
+#if	AI_TIMERS
+			int	startTime = GetTime(0);
+#endif//	AI_TIMERS
+			ST_Commander();
+#if	AI_TIMERS
+			int commTime = GetTime ( startTime );
+			if ( commTime > 20 )
+			{
+				gi.Printf( S_COLOR_RED"ERROR: Commander time: %d\n", commTime );
+			}
+			else if ( commTime > 10 )
+			{
+				gi.Printf( S_COLOR_YELLOW"WARNING: Commander time: %d\n", commTime );
+			}
+			else if ( commTime > 2 )
+			{
+				gi.Printf( S_COLOR_GREEN"Commander time: %d\n", commTime );
+			}
+#endif//	AI_TIMERS
+		}
+	}
+	else if ( TIMER_Done( NPC, "flee" ) && NPC_CheckForDanger( NPC_CheckAlertEvents( qtrue, qtrue, -1, qfalse, AEL_DANGER ) ) )
+	{//not already fleeing, and going to run
+		ST_Speech( NPC, SPEECH_COVER, 0 );
+		NPC_UpdateAngles( qtrue, qtrue );
+		return;
+	}
+
+	if ( !NPC->enemy )
+	{//WTF?  somehow we lost our enemy?
+		NPC_BSST_Patrol();//FIXME: or patrol?
+		return;
+	}
+
+	enemyLOS = enemyCS = enemyInFOV = qfalse;
+	move = qtrue;
+	faceEnemy = qfalse;
+	shoot = qfalse;
+	hitAlly = qfalse;
+	VectorClear( impactPos );
+	enemyDist = DistanceSquared( NPC->r.currentOrigin, NPC->enemy->r.currentOrigin );
+
+	VectorSubtract( NPC->enemy->r.currentOrigin, NPC->r.currentOrigin, enemyDir );
+	VectorNormalize( enemyDir );
+	AngleVectors( NPC->client->ps.viewangles, shootDir, NULL, NULL );
+	dot = DotProduct( enemyDir, shootDir );
+	if ( dot > 0.5f ||( enemyDist * (1.0f-dot)) < 10000 )
+	{//enemy is in front of me or they're very close and not behind me
+		enemyInFOV = qtrue;
+	}
+
+	if ( enemyDist < MIN_ROCKET_DIST_SQUARED )//128
+	{//enemy within 128
+		if ( (NPC->client->ps.weapon == WP_FLECHETTE || NPC->client->ps.weapon == WP_REPEATER) && 
+			(NPCInfo->scriptFlags & SCF_ALT_FIRE) )
+		{//shooting an explosive, but enemy too close, switch to primary fire
+			NPCInfo->scriptFlags &= ~SCF_ALT_FIRE;
+			//FIXME: we can never go back to alt-fire this way since, after this, we don't know if we were initially supposed to use alt-fire or not...
+		}
+	}
+	else if ( enemyDist > 65536 )//256 squared
+	{
+		if ( NPC->client->ps.weapon == WP_DISRUPTOR )
+		{//sniping... should be assumed
+			if ( !(NPCInfo->scriptFlags&SCF_ALT_FIRE) )
+			{//use primary fire
+				NPCInfo->scriptFlags |= SCF_ALT_FIRE;
+				//reset fire-timing variables
+				NPC_ChangeWeapon( WP_DISRUPTOR );
+				NPC_UpdateAngles( qtrue, qtrue );
+				return;
+			}
+		}
+	}
+
+	//can we see our target?
+	if ( NPC_ClearLOS4( NPC->enemy ) )
+	{
+		AI_GroupUpdateEnemyLastSeen( NPCInfo->group, NPC->enemy->r.currentOrigin );
+		NPCInfo->enemyLastSeenTime = level.time;
+		enemyLOS = qtrue;
+
+		if ( NPC->client->ps.weapon == WP_NONE )
+		{
+			enemyCS = qfalse;//not true, but should stop us from firing
+			NPC_AimAdjust( -1 );//adjust aim worse longer we have no weapon
+		}
+		else
+		{//can we shoot our target?
+			if ( (NPC->client->ps.weapon == WP_ROCKET_LAUNCHER || (NPC->client->ps.weapon == WP_FLECHETTE && (NPCInfo->scriptFlags&SCF_ALT_FIRE))) && enemyDist < MIN_ROCKET_DIST_SQUARED )//128*128
+			{
+				enemyCS = qfalse;//not true, but should stop us from firing
+				hitAlly = qtrue;//us!
+				//FIXME: if too close, run away!
+			}
+			else if ( enemyInFOV )
+			{//if enemy is FOV, go ahead and check for shooting
+				int hit = NPC_ShotEntity( NPC->enemy, impactPos );
+				gentity_t *hitEnt = &g_entities[hit];
+
+				if ( hit == NPC->enemy->s.number 
+					|| ( hitEnt && hitEnt->client && hitEnt->client->playerTeam == NPC->client->enemyTeam )
+					|| ( hitEnt && hitEnt->takedamage && ((hitEnt->r.svFlags&SVF_GLASS_BRUSH)||hitEnt->health < 40||NPC->s.weapon == WP_EMPLACED_GUN) ) )
+				{//can hit enemy or enemy ally or will hit glass or other minor breakable (or in emplaced gun), so shoot anyway
+					AI_GroupUpdateClearShotTime( NPCInfo->group );
+					enemyCS = qtrue;
+					NPC_AimAdjust( 2 );//adjust aim better longer we have clear shot at enemy
+					VectorCopy( NPC->enemy->r.currentOrigin, NPCInfo->enemyLastSeenLocation );
+				}
+				else
+				{//Hmm, have to get around this bastard
+					NPC_AimAdjust( 1 );//adjust aim better longer we can see enemy
+					ST_ResolveBlockedShot( hit );
+					if ( hitEnt && hitEnt->client && hitEnt->client->playerTeam == NPC->client->playerTeam )
+					{//would hit an ally, don't fire!!!
+						hitAlly = qtrue;
+					}
+					else
+					{//Check and see where our shot *would* hit... if it's not close to the enemy (within 256?), then don't fire
+					}
+				}
+			}
+			else
+			{
+				enemyCS = qfalse;//not true, but should stop us from firing
+			}
+		}
+	}
+	else if ( trap_InPVS( NPC->enemy->r.currentOrigin, NPC->r.currentOrigin ) )
+	{
+		NPCInfo->enemyLastSeenTime = level.time;
+		faceEnemy = qtrue;
+		NPC_AimAdjust( -1 );//adjust aim worse longer we cannot see enemy
+	}
+
+	if ( NPC->client->ps.weapon == WP_NONE )
+	{
+		faceEnemy = qfalse;
+		shoot = qfalse;
+	}
+	else
+	{
+		if ( enemyLOS )
+		{//FIXME: no need to face enemy if we're moving to some other goal and he's too far away to shoot?
+			faceEnemy = qtrue;
+		}
+		if ( enemyCS )
+		{
+			shoot = qtrue;
+		}
+	}
+
+	//Check for movement to take care of
+	ST_CheckMoveState();
+
+	//See if we should override shooting decision with any special considerations
+	ST_CheckFireState();
+
+	if ( faceEnemy )
+	{//face the enemy
+		NPC_FaceEnemy( qtrue );
+	}
+
+	if ( !(NPCInfo->scriptFlags&SCF_CHASE_ENEMIES) )
+	{//not supposed to chase my enemies
+		if ( NPCInfo->goalEntity == NPC->enemy )
+		{//goal is my entity, so don't move
+			move = qfalse;
+		}
+	}
+
+	if ( NPC->client->ps.weaponTime > 0 && NPC->s.weapon == WP_ROCKET_LAUNCHER )
+	{
+		move = qfalse;
+	}
+
+	if ( move )
+	{//move toward goal
+		if ( NPCInfo->goalEntity )//&& ( NPCInfo->goalEntity != NPC->enemy || enemyDist > 10000 ) )//100 squared
+		{
+			move = ST_Move();
+		}
+		else
+		{
+			move = qfalse;
+		}
+	}
+
+	if ( !move )
+	{
+		if ( !TIMER_Done( NPC, "duck" ) )
+		{
+			ucmd.upmove = -127;
+		}
+		//FIXME: what about leaning?
+	}
+	else
+	{//stop ducking!
+		TIMER_Set( NPC, "duck", -1 );
+	}
+
+	if ( !TIMER_Done( NPC, "flee" ) )
+	{//running away
+		faceEnemy = qfalse;
+	}
+
+	//FIXME: check scf_face_move_dir here?
+
+	if ( !faceEnemy )
+	{//we want to face in the dir we're running
+		if ( !move )
+		{//if we haven't moved, we should look in the direction we last looked?
+			VectorCopy( NPC->client->ps.viewangles, NPCInfo->lastPathAngles );
+		}
+		NPCInfo->desiredYaw = NPCInfo->lastPathAngles[YAW];
+		NPCInfo->desiredPitch = 0;
+		NPC_UpdateAngles( qtrue, qtrue );
+		if ( move )
+		{//don't run away and shoot
+			shoot = qfalse;
+		}
+	}
+
+	if ( NPCInfo->scriptFlags & SCF_DONT_FIRE )
+	{
+		shoot = qfalse;
+	}
+
+	if ( NPC->enemy && NPC->enemy->enemy )
+	{
+		if ( NPC->enemy->s.weapon == WP_SABER && NPC->enemy->enemy->s.weapon == WP_SABER )
+		{//don't shoot at an enemy jedi who is fighting another jedi, for fear of injuring one or causing rogue blaster deflections (a la Obi Wan/Vader duel at end of ANH)
+			shoot = qfalse;
+		}
+	}
+	//FIXME: don't shoot right away!
+	if ( NPC->client->ps.weaponTime > 0 )
+	{
+		if ( NPC->s.weapon == WP_ROCKET_LAUNCHER )
+		{
+			if ( !enemyLOS || !enemyCS )
+			{//cancel it
+				NPC->client->ps.weaponTime = 0;
+			}
+			else
+			{//delay our next attempt
+				TIMER_Set( NPC, "attackDelay", Q_irand( 3000, 5000 ) );
+			}
+		}
+	}
+	else if ( shoot )
+	{//try to shoot if it's time
+		if ( TIMER_Done( NPC, "attackDelay" ) )
+		{
+			if( !(NPCInfo->scriptFlags & SCF_FIRE_WEAPON) ) // we've already fired, no need to do it again here
+			{
+				WeaponThink( qtrue );
+			}
+			//NASTY
+			if ( NPC->s.weapon == WP_ROCKET_LAUNCHER 
+				&& (ucmd.buttons&BUTTON_ATTACK) 
+				&& !move
+				&& g_spskill.integer > 1 
+				&& !Q_irand( 0, 3 ) )
+			{//every now and then, shoot a homing rocket
+				ucmd.buttons &= ~BUTTON_ATTACK;
+				ucmd.buttons |= BUTTON_ALT_ATTACK;
+				NPC->client->ps.weaponTime = Q_irand( 1000, 2500 );
+			}
+		}
+	}
+}
+
+void NPC_BSST_Default( void )
+{
+	if( NPCInfo->scriptFlags & SCF_FIRE_WEAPON )
+	{
+		WeaponThink( qtrue );
+	}
+	
+	if( !NPC->enemy )
+	{//don't have an enemy, look for one
+		NPC_BSST_Patrol();
+	}
+	else //if ( NPC->enemy )
+	{//have an enemy
+		NPC_CheckGetNewWeapon();
+		NPC_BSST_Attack();
+	}
+}
diff --git a/codemp/game/NPC_AI_Utils.c b/codemp/game/NPC_AI_Utils.c
new file mode 100644
index 0000000..0c5c6c5
--- /dev/null
+++ b/codemp/game/NPC_AI_Utils.c
@@ -0,0 +1,1139 @@
+// These utilities are meant for strictly non-player, non-team NPCs.  
+// These functions are in their own file because they are only intended
+// for use with NPCs who's logic has been overriden from the original
+// AI code, and who's code resides in files with the AI_ prefix.
+
+#include "b_local.h"
+#include "g_nav.h"
+
+#define	MAX_RADIUS_ENTS		128
+#define	DEFAULT_RADIUS		45
+
+extern vmCvar_t		d_noGroupAI;
+qboolean AI_ValidateGroupMember( AIGroupInfo_t *group, gentity_t *member );
+
+extern void G_TestLine(vec3_t start, vec3_t end, int color, int time);
+
+/*
+-------------------------
+AI_GetGroupSize
+-------------------------
+*/
+
+int	AI_GetGroupSize( vec3_t origin, int radius, team_t playerTeam, gentity_t *avoid )
+{
+	int			radiusEnts[ MAX_RADIUS_ENTS ];
+	gentity_t	*check;
+	vec3_t		mins, maxs;
+	int			numEnts, realCount = 0;
+	int			i;
+	int			j;
+
+	//Setup the bbox to search in
+	for ( i = 0; i < 3; i++ )
+	{
+		mins[i] = origin[i] - radius;
+		maxs[i] = origin[i] + radius;
+	}
+
+	//Get the number of entities in a given space
+	numEnts = trap_EntitiesInBox( mins, maxs, radiusEnts, MAX_RADIUS_ENTS );
+
+	//Cull this list
+	for ( j = 0; j < numEnts; j++ )
+	{
+		check = &g_entities[radiusEnts[j]];
+
+		//Validate clients
+		if ( check->client == NULL )
+			continue;
+
+		//Skip the requested avoid ent if present
+		if ( ( avoid != NULL ) && ( check == avoid ) )
+			continue;
+
+		//Must be on the same team
+		if ( check->client->playerTeam != playerTeam )
+			continue;
+
+		//Must be alive
+		if ( check->health <= 0 )
+			continue;
+
+		realCount++;
+	}
+
+	return realCount;
+}
+
+//Overload
+
+int AI_GetGroupSize2( gentity_t *ent, int radius )
+{
+	if ( ( ent == NULL ) || ( ent->client == NULL ) )
+		return -1;
+
+	return AI_GetGroupSize( ent->r.currentOrigin, radius, ent->client->playerTeam, ent );
+}
+
+extern int NAV_FindClosestWaypointForPoint( gentity_t *ent, vec3_t point );
+int AI_ClosestGroupEntityNumToPoint( AIGroupInfo_t *group, vec3_t point )
+{
+	int	markerWP = WAYPOINT_NONE;
+	int	cost, bestCost = Q3_INFINITE;
+	int	closest = ENTITYNUM_NONE;
+	int i;
+	
+	if ( group == NULL || group->numGroup <= 0 )
+	{
+		return ENTITYNUM_NONE;
+	}
+
+	markerWP = NAV_FindClosestWaypointForPoint( &g_entities[group->member[0].number], point );
+
+	if ( markerWP == WAYPOINT_NONE )
+	{
+		return ENTITYNUM_NONE;
+	}
+
+	for ( i = 0; i < group->numGroup; i++ )
+	{
+		cost = trap_Nav_GetPathCost( group->member[i].waypoint, markerWP );
+		if ( cost < bestCost )
+		{
+			bestCost = cost;
+			closest = group->member[i].number;
+		}
+	}
+
+	return closest;
+}
+
+void AI_SetClosestBuddy( AIGroupInfo_t *group )
+{
+	int	i, j;
+	int	dist, bestDist;
+
+	for ( i = 0; i < group->numGroup; i++ )
+	{
+		group->member[i].closestBuddy = ENTITYNUM_NONE;
+
+		bestDist = Q3_INFINITE;
+		for ( j = 0; j < group->numGroup; j++ )
+		{
+			dist = DistanceSquared( g_entities[group->member[i].number].r.currentOrigin, g_entities[group->member[j].number].r.currentOrigin );
+			if ( dist < bestDist )
+			{
+				bestDist = dist;
+				group->member[i].closestBuddy = group->member[j].number;
+			}
+		}
+	}
+}
+
+void AI_SortGroupByPathCostToEnemy( AIGroupInfo_t *group )
+{
+	AIGroupMember_t bestMembers[MAX_GROUP_MEMBERS];
+	int				i, j, k;
+	qboolean		sort = qfalse;
+
+	if ( group->enemy != NULL )
+	{//FIXME: just use enemy->waypoint?
+		group->enemyWP = NAV_FindClosestWaypointForEnt( group->enemy, WAYPOINT_NONE );
+	}
+	else
+	{
+		group->enemyWP = WAYPOINT_NONE;
+	}
+
+	for ( i = 0; i < group->numGroup; i++ )
+	{
+		if ( group->enemyWP == WAYPOINT_NONE )
+		{//FIXME: just use member->waypoint?
+			group->member[i].waypoint = WAYPOINT_NONE;
+			group->member[i].pathCostToEnemy = Q3_INFINITE;
+		}
+		else
+		{//FIXME: just use member->waypoint?
+			group->member[i].waypoint = NAV_FindClosestWaypointForEnt( group->enemy, WAYPOINT_NONE );
+			if ( group->member[i].waypoint != WAYPOINT_NONE )
+			{
+				group->member[i].pathCostToEnemy = trap_Nav_GetPathCost( group->member[i].waypoint, group->enemyWP );
+				//at least one of us has a path, so do sorting
+				sort = qtrue;
+			}
+			else
+			{
+				group->member[i].pathCostToEnemy = Q3_INFINITE;
+			}
+		}
+	}
+	//Now sort
+	if ( sort )
+	{
+		//initialize bestMembers data
+		for ( j = 0; j < group->numGroup; j++ )
+		{
+			bestMembers[j].number = ENTITYNUM_NONE;
+		}
+
+		for ( i = 0; i < group->numGroup; i++ )
+		{
+			for ( j = 0; j < group->numGroup; j++ )
+			{
+				if ( bestMembers[j].number != ENTITYNUM_NONE )
+				{//slot occupied
+					if ( group->member[i].pathCostToEnemy < bestMembers[j].pathCostToEnemy )
+					{//this guy has a shorter path than the one currenly in this spot, bump him and put myself in here
+						for ( k = group->numGroup; k > j; k++ )
+						{
+							memcpy( &bestMembers[k], &bestMembers[k-1], sizeof( bestMembers[k] ) );
+						}
+						memcpy( &bestMembers[j], &group->member[i], sizeof( bestMembers[j] ) );
+						break;
+					}
+				}
+				else
+				{//slot unoccupied, reached end of list, throw self in here
+					memcpy( &bestMembers[j], &group->member[i], sizeof( bestMembers[j] ) );
+					break;
+				}
+			}
+		}
+
+		//Okay, now bestMembers is a sorted list, just copy it into group->members
+		for ( i = 0; i < group->numGroup; i++ )
+		{
+			memcpy( &group->member[i], &bestMembers[i], sizeof( group->member[i] ) );
+		}
+	}
+}
+
+qboolean AI_FindSelfInPreviousGroup( gentity_t *self )
+{//go through other groups made this frame and see if any of those contain me already
+	int	i, j;
+	for ( i = 0; i < MAX_FRAME_GROUPS; i++ )
+	{
+		if ( level.groups[i].numGroup )//&& level.groups[i].enemy != NULL )
+		{//check this one
+			for ( j = 0; j < level.groups[i].numGroup; j++ )
+			{
+				if ( level.groups[i].member[j].number == self->s.number )
+				{
+					self->NPC->group = &level.groups[i];
+					return qtrue;
+				}
+			}
+		}
+	}
+	return qfalse;
+}
+
+void AI_InsertGroupMember( AIGroupInfo_t *group, gentity_t *member )
+{
+	int i;
+
+	//okay, you know what?  Check this damn group and make sure we're not already in here!
+	for ( i = 0; i < group->numGroup; i++ )
+	{
+		if ( group->member[i].number == member->s.number )
+		{//already in here
+			break;
+		}
+	}
+	if ( i < group->numGroup )
+	{//found him in group already
+	}
+	else
+	{//add him in
+		group->member[group->numGroup++].number = member->s.number;
+		group->numState[member->NPC->squadState]++;
+	}
+	if ( !group->commander || (member->NPC->rank > group->commander->NPC->rank) )
+	{//keep track of highest rank
+		group->commander = member;
+	}
+	member->NPC->group = group;
+}
+
+qboolean AI_TryJoinPreviousGroup( gentity_t *self )
+{//go through other groups made this frame and see if any of those have the same enemy as me... if so, add me in!
+	int	i;
+	for ( i = 0; i < MAX_FRAME_GROUPS; i++ )
+	{
+		if ( level.groups[i].numGroup 
+			&& level.groups[i].numGroup < (MAX_GROUP_MEMBERS - 1) 
+			//&& level.groups[i].enemy != NULL 
+			&& level.groups[i].enemy == self->enemy )
+		{//has members, not full and has my enemy
+			if ( AI_ValidateGroupMember( &level.groups[i], self ) )
+			{//I am a valid member for this group
+				AI_InsertGroupMember( &level.groups[i], self );
+				return qtrue;
+			}
+		}
+	}
+	return qfalse;
+}
+
+qboolean AI_GetNextEmptyGroup( gentity_t *self )
+{
+	int i;
+
+	if ( AI_FindSelfInPreviousGroup( self ) )
+	{//already in one, no need to make a new one
+		return qfalse;
+	}
+
+	if ( AI_TryJoinPreviousGroup( self ) )
+	{//try to just put us in one that already exists
+		return qfalse;
+	}
+	
+	//okay, make a whole new one, then
+	for ( i = 0; i < MAX_FRAME_GROUPS; i++ )
+	{
+		if ( !level.groups[i].numGroup )
+		{//make a new one
+			self->NPC->group = &level.groups[i];
+			return qtrue;
+		}
+	}
+
+	//if ( i >= MAX_FRAME_GROUPS )
+	{//WTF?  Out of groups!
+		self->NPC->group = NULL;
+		return qfalse;
+	}
+}
+
+qboolean AI_ValidateNoEnemyGroupMember( AIGroupInfo_t *group, gentity_t *member )
+{
+	vec3_t center;
+
+	if ( !group )
+	{
+		return qfalse;
+	}
+	if ( group->commander )
+	{
+		VectorCopy( group->commander->r.currentOrigin, center );
+	}
+	else
+	{//hmm, just pick the first member
+		if ( group->member[0].number < 0 || group->member[0].number >= ENTITYNUM_WORLD )
+		{
+			return qfalse;
+		}
+		VectorCopy( g_entities[group->member[0].number].r.currentOrigin, center );
+	}
+	//FIXME: maybe it should be based on the center of the mass of the group, not the commander?
+	if ( DistanceSquared( center, member->r.currentOrigin ) > 147456/*384*384*/ )
+	{
+		return qfalse;
+	}
+	if ( !trap_InPVS( member->r.currentOrigin, center ) )
+	{//not within PVS of the group enemy
+		return qfalse;
+	}
+	return qtrue;
+}
+
+qboolean AI_ValidateGroupMember( AIGroupInfo_t *group, gentity_t *member )
+{
+	//Validate ents
+	if ( member == NULL )
+		return qfalse;
+
+	//Validate clients
+	if ( member->client == NULL )
+		return qfalse;
+
+	//Validate NPCs
+	if ( member->NPC == NULL )
+		return qfalse;
+
+	//must be aware
+	if ( member->NPC->confusionTime > level.time )
+		return qfalse;
+
+	//must be allowed to join groups
+	if ( member->NPC->scriptFlags&SCF_NO_GROUPS )
+		return qfalse;
+
+	//Must not be in another group
+	if ( member->NPC->group != NULL && member->NPC->group != group )
+	{//FIXME: if that group's enemy is mine, why not absorb that group into mine?
+		return qfalse;
+	}
+
+	//Must be alive
+	if ( member->health <= 0 )
+		return qfalse;
+
+	//can't be in an emplaced gun
+//	if( member->s.eFlags & EF_LOCKED_TO_WEAPON )
+//		return qfalse;
+	//rwwFIXMEFIXME: support this flag
+
+	//Must be on the same team
+	if ( member->client->playerTeam != group->team )
+		return qfalse;
+
+	if ( member->client->ps.weapon == WP_SABER ||//!= self->s.weapon )
+		member->client->ps.weapon == WP_THERMAL ||
+		member->client->ps.weapon == WP_DISRUPTOR ||
+		member->client->ps.weapon == WP_EMPLACED_GUN ||
+//		member->client->ps.weapon == WP_BOT_LASER ||		// Probe droid	- Laser blast
+		member->client->ps.weapon == WP_STUN_BATON ||
+		member->client->ps.weapon == WP_TURRET /*||			// turret guns 
+		member->client->ps.weapon == WP_ATST_MAIN ||
+		member->client->ps.weapon == WP_ATST_SIDE ||
+		member->client->ps.weapon == WP_TIE_FIGHTER*/ )
+	{//not really a squad-type guy
+		return qfalse;
+	}
+
+	if ( member->client->NPC_class == CLASS_ATST ||
+		member->client->NPC_class == CLASS_PROBE ||
+		member->client->NPC_class == CLASS_SEEKER ||
+		member->client->NPC_class == CLASS_REMOTE ||
+		member->client->NPC_class == CLASS_SENTRY ||
+		member->client->NPC_class == CLASS_INTERROGATOR ||
+		member->client->NPC_class == CLASS_MINEMONSTER ||
+		member->client->NPC_class == CLASS_HOWLER ||
+		member->client->NPC_class == CLASS_MARK1 ||
+		member->client->NPC_class == CLASS_MARK2 )
+	{//these kinds of enemies don't actually use this group AI
+		return qfalse;
+	}
+
+	//should have same enemy
+	if ( member->enemy != group->enemy )
+	{
+		if ( member->enemy != NULL )
+		{//he's fighting someone else, leave him out
+			return qfalse;
+		}
+		if ( !trap_InPVS( member->r.currentOrigin, group->enemy->r.currentOrigin ) )
+		{//not within PVS of the group enemy
+			return qfalse;
+		}
+	}
+	else if ( group->enemy == NULL )
+	{//if the group is a patrol group, only take those within the room and radius
+		if ( !AI_ValidateNoEnemyGroupMember( group, member ) )
+		{
+			return qfalse;
+		}
+	}
+	//must be actually in combat mode
+	if ( !TIMER_Done( member, "interrogating" ) )
+		return qfalse;
+	//FIXME: need to have a route to enemy and/or clear shot?
+	return qtrue;
+}
+
+/*
+-------------------------
+AI_GetGroup
+-------------------------
+*/
+//#define MAX_WAITERS	128
+void AI_GetGroup( gentity_t *self )
+{
+	int	i;
+	gentity_t	*member;//, *waiter;
+	//int	waiters[MAX_WAITERS];
+
+	if ( !self || !self->NPC )
+	{
+		return;
+	}
+
+	if ( d_noGroupAI.integer )
+	{
+		self->NPC->group = NULL;
+		return;
+	}
+
+	if ( !self->client )
+	{
+		self->NPC->group = NULL;
+		return;
+	}
+
+	if ( self->NPC->scriptFlags&SCF_NO_GROUPS )
+	{
+		self->NPC->group = NULL;
+		return;
+	}
+
+	if ( self->enemy && (!self->enemy->client || (level.time - self->NPC->enemyLastSeenTime > 7000 )))
+	{
+		self->NPC->group = NULL;
+		return;
+	}
+
+	if ( !AI_GetNextEmptyGroup( self ) )
+	{//either no more groups left or we're already in a group built earlier
+		return;
+	}
+
+	//create a new one
+	memset( self->NPC->group, 0, sizeof( AIGroupInfo_t ) );
+
+	self->NPC->group->enemy = self->enemy;
+	self->NPC->group->team = self->client->playerTeam;
+	self->NPC->group->processed = qfalse;
+	self->NPC->group->commander = self;
+	self->NPC->group->memberValidateTime = level.time + 2000;
+	self->NPC->group->activeMemberNum = 0;
+
+	if ( self->NPC->group->enemy )
+	{
+		self->NPC->group->lastSeenEnemyTime = level.time;
+		self->NPC->group->lastClearShotTime = level.time;
+		VectorCopy( self->NPC->group->enemy->r.currentOrigin, self->NPC->group->enemyLastSeenPos );
+	}
+
+//	for ( i = 0, member = &g_entities[0]; i < globals.num_entities ; i++, member++)
+	for ( i = 0; i < level.num_entities ; i++)
+	{
+		member = &g_entities[i];
+
+		if (!member->inuse)
+		{
+			continue;
+		}
+
+		if ( !AI_ValidateGroupMember( self->NPC->group, member ) )
+		{//FIXME: keep track of those who aren't angry yet and see if we should wake them after we assemble the core group
+			continue;
+		}
+		
+		//store it
+		AI_InsertGroupMember( self->NPC->group, member );
+
+		if ( self->NPC->group->numGroup >= (MAX_GROUP_MEMBERS - 1) )
+		{//full
+			break;
+		}
+	}
+
+	/*
+	//now go through waiters and see if any should join the group
+	//NOTE:  Some should hang back and probably not attack, so we can ambush
+	//NOTE: only do this if calling for reinforcements?
+	for ( i = 0; i < numWaiters; i++ )
+	{
+		waiter = &g_entities[waiters[i]];
+	
+		for ( j = 0; j < self->NPC->group->numGroup; j++ )
+		{
+			member = &g_entities[self->NPC->group->member[j];
+
+			if ( trap_InPVS( waiter->r.currentOrigin, member->r.currentOrigin ) )
+			{//this waiter is within PVS of a current member
+			}
+		}
+	}
+	*/
+
+	if ( self->NPC->group->numGroup <= 0 )
+	{//none in group
+		self->NPC->group = NULL;
+		return;
+	}
+
+	AI_SortGroupByPathCostToEnemy( self->NPC->group );
+	AI_SetClosestBuddy( self->NPC->group );
+}
+
+void AI_SetNewGroupCommander( AIGroupInfo_t *group )
+{
+	gentity_t *member = NULL;
+	int i;
+
+	group->commander = NULL;
+	for ( i = 0; i < group->numGroup; i++ )
+	{
+		member = &g_entities[group->member[i].number];
+
+		if ( !group->commander || (member && member->NPC && group->commander->NPC && member->NPC->rank > group->commander->NPC->rank) )
+		{//keep track of highest rank
+			group->commander = member;
+		}
+	}
+}
+
+void AI_DeleteGroupMember( AIGroupInfo_t *group, int memberNum )
+{
+	int i;
+
+	if ( group->commander && group->commander->s.number == group->member[memberNum].number )
+	{
+		group->commander = NULL;
+	}
+	if ( g_entities[group->member[memberNum].number].NPC )
+	{
+		g_entities[group->member[memberNum].number].NPC->group = NULL;
+	}
+	for ( i = memberNum; i < (group->numGroup-1); i++ )
+	{
+		memcpy( &group->member[i], &group->member[i+1], sizeof( group->member[i] ) );
+	}
+	if ( memberNum < group->activeMemberNum )
+	{
+		group->activeMemberNum--;
+		if ( group->activeMemberNum < 0 )
+		{
+			group->activeMemberNum = 0;
+		}
+	}
+	group->numGroup--;
+	if ( group->numGroup < 0 )
+	{
+		group->numGroup = 0;
+	}
+	AI_SetNewGroupCommander( group );
+}
+
+void AI_DeleteSelfFromGroup( gentity_t *self )
+{
+	int i;
+
+	//FIXME: if killed, keep track of how many in group killed?  To affect morale?
+	for ( i = 0; i < self->NPC->group->numGroup; i++ )
+	{
+		if ( self->NPC->group->member[i].number == self->s.number )
+		{
+			AI_DeleteGroupMember( self->NPC->group, i );
+			return;
+		}
+	}
+}
+
+extern void ST_AggressionAdjust( gentity_t *self, int change );
+extern void ST_MarkToCover( gentity_t *self );
+extern void ST_StartFlee( gentity_t *self, gentity_t *enemy, vec3_t dangerPoint, int dangerLevel, int minTime, int maxTime );
+void AI_GroupMemberKilled( gentity_t *self )
+{
+	AIGroupInfo_t *group = self->NPC->group;
+	gentity_t	*member;
+	qboolean	noflee = qfalse;
+	int			i;
+
+	if ( !group )
+	{//what group?
+		return;
+	}
+	if ( !self || !self->NPC || self->NPC->rank < RANK_ENSIGN )
+	{//I'm not an officer, let's not really care for now
+		return;
+	}
+	//temporarily drop group morale for a few seconds
+	group->moraleAdjust -= self->NPC->rank;
+	//go through and drop aggression on my teammates (more cover, worse aim)
+	for ( i = 0; i < group->numGroup; i++ )
+	{
+		member = &g_entities[group->member[i].number];
+		if ( member == self )
+		{
+			continue;
+		}
+		if ( member->NPC->rank > RANK_ENSIGN )
+		{//officers do not panic
+			noflee = qtrue;
+		}
+		else
+		{
+			ST_AggressionAdjust( member, -1 );
+			member->NPC->currentAim -= Q_irand( 0, 10 );//Q_irand( 0, 2);//drop their aim accuracy
+		}
+	}
+	//okay, if I'm the group commander, make everyone else flee
+	if ( group->commander != self )
+	{//I'm not the commander... hmm, should maybe a couple flee... maybe those near me?
+		return;
+	}
+	//now see if there is another of sufficient rank to keep them from fleeing
+	if ( !noflee )
+	{
+		self->NPC->group->speechDebounceTime = 0;
+		for ( i = 0; i < group->numGroup; i++ )
+		{
+			member = &g_entities[group->member[i].number];
+			if ( member == self )
+			{
+				continue;
+			}
+			if ( member->NPC->rank < RANK_ENSIGN )
+			{//grunt
+				if ( group->enemy && DistanceSquared( member->r.currentOrigin, group->enemy->r.currentOrigin ) < 65536/*256*256*/ )
+				{//those close to enemy run away!
+					ST_StartFlee( member, group->enemy, member->r.currentOrigin, AEL_DANGER_GREAT, 3000, 5000 );
+				}
+				else if ( DistanceSquared( member->r.currentOrigin, self->r.currentOrigin ) < 65536/*256*256*/ )
+				{//those close to me run away!
+					ST_StartFlee( member, group->enemy, member->r.currentOrigin, AEL_DANGER_GREAT, 3000, 5000 );
+				}
+				else
+				{//else, maybe just a random chance
+					if ( Q_irand( 0, self->NPC->rank ) > member->NPC->rank )
+					{//lower rank they are, higher rank I am, more likely they are to flee
+						ST_StartFlee( member, group->enemy, member->r.currentOrigin, AEL_DANGER_GREAT, 3000, 5000 );
+					}
+					else
+					{
+						ST_MarkToCover( member );
+					}
+				}
+				member->NPC->currentAim -= Q_irand( 1, 15 ); //Q_irand( 1, 3 );//drop their aim accuracy even more
+			}
+			member->NPC->currentAim -= Q_irand( 1, 15 ); //Q_irand( 1, 3 );//drop their aim accuracy even more
+		}
+	}
+}
+
+void AI_GroupUpdateEnemyLastSeen( AIGroupInfo_t *group, vec3_t spot )
+{
+	if ( !group )
+	{
+		return;
+	}
+	group->lastSeenEnemyTime = level.time;
+	VectorCopy( spot, group->enemyLastSeenPos );
+}
+
+void AI_GroupUpdateClearShotTime( AIGroupInfo_t *group )
+{
+	if ( !group )
+	{
+		return;
+	}
+	group->lastClearShotTime = level.time;
+}
+
+void AI_GroupUpdateSquadstates( AIGroupInfo_t *group, gentity_t *member, int newSquadState )
+{
+	int i;
+
+	if ( !group )
+	{
+		member->NPC->squadState = newSquadState;
+		return;
+	}
+
+	for ( i = 0; i < group->numGroup; i++ )
+	{
+		if ( group->member[i].number == member->s.number )
+		{
+			group->numState[member->NPC->squadState]--;
+			member->NPC->squadState = newSquadState;
+			group->numState[member->NPC->squadState]++;
+			return;
+		}
+	}
+}
+
+qboolean AI_RefreshGroup( AIGroupInfo_t *group )
+{
+	gentity_t	*member;
+	int			i;//, j;
+
+	//see if we should merge with another group
+	for ( i = 0; i < MAX_FRAME_GROUPS; i++ ) 
+	{
+		if ( &level.groups[i] == group )
+		{
+			break;
+		}
+		else
+		{
+			if ( level.groups[i].enemy == group->enemy )
+			{//2 groups with same enemy
+				if ( level.groups[i].numGroup+group->numGroup < (MAX_GROUP_MEMBERS - 1) )
+				{//combining the members would fit in one group
+					qboolean deleteWhenDone = qtrue;
+					int j;
+
+					//combine the members of mine into theirs
+					for ( j = 0; j < group->numGroup; j++ )
+					{
+						member = &g_entities[group->member[j].number];
+						if ( level.groups[i].enemy == NULL )
+						{//special case for groups without enemies, must be in range
+							if ( !AI_ValidateNoEnemyGroupMember( &level.groups[i], member ) )
+							{
+								deleteWhenDone = qfalse;
+								continue;
+							}
+						}
+						//remove this member from this group
+						AI_DeleteGroupMember( group, j );
+						//keep marker at same place since we deleted this guy and shifted everyone up one
+						j--;
+						//add them to the earlier group
+						AI_InsertGroupMember( &level.groups[i], member );
+					}
+					//return and delete this group
+					if ( deleteWhenDone )
+					{
+						return qfalse;
+					}
+				}
+			}
+		}
+	}
+	//clear numStates
+	for ( i = 0; i < NUM_SQUAD_STATES; i++ )
+	{
+		group->numState[i] = 0;
+	}
+
+	//go through group and validate each membership
+	group->commander = NULL;
+	for ( i = 0; i < group->numGroup; i++ )
+	{
+		/*
+		//this checks for duplicate copies of one member in a group
+		for ( j = 0; j < group->numGroup; j++ )
+		{
+			if ( i != j )
+			{
+				if ( group->member[i].number == group->member[j].number )
+				{
+					break;
+				}
+			}
+		}
+		if ( j < group->numGroup )
+		{//found a dupe!
+			gi.Printf( S_COLOR_RED"ERROR: member %s(%d) a duplicate group member!!!\n", g_entities[group->member[i].number].targetname, group->member[i].number );
+			AI_DeleteGroupMember( group, i );
+			i--;
+			continue;
+		}
+		*/
+		member = &g_entities[group->member[i].number];
+
+		//Must be alive
+		if ( member->health <= 0 )
+		{
+			AI_DeleteGroupMember( group, i );
+			//keep marker at same place since we deleted this guy and shifted everyone up one
+			i--;
+		}
+		else if ( group->memberValidateTime < level.time && !AI_ValidateGroupMember( group, member ) )
+		{
+			//remove this one from the group
+			AI_DeleteGroupMember( group, i );
+			//keep marker at same place since we deleted this guy and shifted everyone up one
+			i--;
+		}
+		else
+		{//membership is valid
+			//keep track of squadStates
+			group->numState[member->NPC->squadState]++;
+			if ( !group->commander || member->NPC->rank > group->commander->NPC->rank )
+			{//keep track of highest rank
+				group->commander = member;
+			}
+		}
+	}
+	if ( group->memberValidateTime < level.time )
+	{
+		group->memberValidateTime = level.time + Q_irand( 500, 2500 );
+	}
+	//Now add any new guys as long as we're not full
+	/*
+	for ( i = 0, member = &g_entities[0]; i < globals.num_entities && group->numGroup < (MAX_GROUP_MEMBERS - 1); i++, member++)
+	{
+		if ( !AI_ValidateGroupMember( group, member ) )
+		{//FIXME: keep track of those who aren't angry yet and see if we should wake them after we assemble the core group
+			continue;
+		}
+		if ( member->NPC->group == group )
+		{//DOH, already in our group
+			continue;
+		}
+
+		//store it
+		AI_InsertGroupMember( group, member );
+	}
+	*/
+
+	//calc the morale of this group
+	group->morale = group->moraleAdjust;
+	for ( i = 0; i < group->numGroup; i++ )
+	{
+		member = &g_entities[group->member[i].number];
+		if ( member->NPC->rank < RANK_ENSIGN )
+		{//grunts
+			group->morale++;
+		}
+		else
+		{
+			group->morale += member->NPC->rank;
+		}
+		if ( group->commander && debugNPCAI.integer )
+		{
+			//G_DebugLine( group->commander->r.currentOrigin, member->r.currentOrigin, FRAMETIME, 0x00ff00ff, qtrue );
+			G_TestLine(group->commander->r.currentOrigin, member->r.currentOrigin, 0x00000ff, FRAMETIME);
+		}
+	}
+	if ( group->enemy )
+	{//modify morale based on enemy health and weapon
+		if ( group->enemy->health < 10 )
+		{
+			group->morale += 10;
+		}
+		else if ( group->enemy->health < 25 )
+		{
+			group->morale += 5;
+		}
+		else if ( group->enemy->health < 50 )
+		{
+			group->morale += 2;
+		}
+		switch( group->enemy->s.weapon )
+		{
+		case WP_SABER:
+			group->morale -= 5;
+			break;
+		case WP_BRYAR_PISTOL:
+			group->morale += 3;
+			break;
+		case WP_DISRUPTOR:
+			group->morale += 2;
+			break;
+		case WP_REPEATER:
+			group->morale -= 1;
+			break;
+		case WP_FLECHETTE:
+			group->morale -= 2;
+			break;
+		case WP_ROCKET_LAUNCHER:
+			group->morale -= 10;
+			break;
+		case WP_THERMAL:
+			group->morale -= 5;
+			break;
+		case WP_TRIP_MINE:
+			group->morale -= 3;
+			break;
+		case WP_DET_PACK:
+			group->morale -= 10;
+			break;
+//		case WP_MELEE:			// Any ol' melee attack
+//			group->morale += 20;
+//			break;
+		case WP_STUN_BATON:
+			group->morale += 10;
+			break;
+		case WP_EMPLACED_GUN:
+			group->morale -= 8;
+			break;
+//		case WP_ATST_MAIN:
+//			group->morale -= 8;
+//			break;
+//		case WP_ATST_SIDE:
+//			group->morale -= 20;
+//			break;
+		}
+	}
+	if ( group->moraleDebounce < level.time )
+	{//slowly degrade whatever moraleAdjusters we may have
+		if ( group->moraleAdjust > 0 )
+		{
+			group->moraleAdjust--;
+		}
+		else if ( group->moraleAdjust < 0 )
+		{
+			group->moraleAdjust++;
+		}
+		group->moraleDebounce = level.time + 1000;//FIXME: define?
+	}
+	//mark this group as not having been run this frame
+	group->processed = qfalse;
+
+	return (group->numGroup>0);
+}
+
+void AI_UpdateGroups( void )
+{
+	int i;
+
+	if ( d_noGroupAI.integer )
+	{
+		return;
+	}
+	//Clear all Groups
+	for ( i = 0; i < MAX_FRAME_GROUPS; i++ ) 
+	{
+		if ( !level.groups[i].numGroup || AI_RefreshGroup( &level.groups[i] ) == qfalse )//level.groups[i].enemy == NULL || 
+		{
+			memset( &level.groups[i], 0, sizeof( level.groups[i] ) );
+		}
+	}
+}
+
+qboolean AI_GroupContainsEntNum( AIGroupInfo_t *group, int entNum )
+{
+	int i;
+
+	if ( !group )
+	{
+		return qfalse;
+	}
+	for ( i = 0; i < group->numGroup; i++ )
+	{
+		if ( group->member[i].number == entNum )
+		{
+			return qtrue;
+		}
+	}
+	return qfalse;
+}
+//Overload 
+
+/*
+void AI_GetGroup( AIGroupInfo_t &group, gentity_t *ent, int radius )
+{
+	if ( ent->client == NULL )
+		return;
+
+	vec3_t	temp, angles;
+
+	//FIXME: This is specialized code.. move?
+	if ( ent->enemy )
+	{
+		VectorSubtract( ent->enemy->r.currentOrigin, ent->r.currentOrigin, temp );
+		VectorNormalize( temp );	//FIXME: Needed?
+		vectoangles( temp, angles );
+	}
+	else
+	{
+		VectorCopy( ent->currentAngles, angles );
+	}
+
+	AI_GetGroup( group, ent->r.currentOrigin, ent->currentAngles, DEFAULT_RADIUS, radius, ent->client->playerTeam, ent, ent->enemy );
+}
+*/
+/*
+-------------------------
+AI_CheckEnemyCollision
+-------------------------
+*/
+
+qboolean AI_CheckEnemyCollision( gentity_t *ent, qboolean takeEnemy )
+{
+	navInfo_t	info;
+
+	if ( ent == NULL )
+		return qfalse;
+
+//	if ( ent->svFlags & SVF_LOCKEDENEMY )
+//		return qfalse;
+
+	NAV_GetLastMove( &info );
+
+	//See if we've hit something
+	if ( ( info.blocker ) && ( info.blocker != ent->enemy ) )
+	{
+		if ( ( info.blocker->client ) && ( info.blocker->client->playerTeam == ent->client->enemyTeam ) )
+		{
+			if ( takeEnemy )
+				G_SetEnemy( ent, info.blocker );
+
+			return qtrue;
+		}
+	}
+
+	return qfalse;
+}
+
+/*
+-------------------------
+AI_DistributeAttack
+-------------------------
+*/
+
+#define	MAX_RADIUS_ENTS		128
+
+gentity_t *AI_DistributeAttack( gentity_t *attacker, gentity_t *enemy, team_t team, int threshold )
+{
+	int			radiusEnts[ MAX_RADIUS_ENTS ];
+	gentity_t	*check;
+	int			numEnts;
+	int			numSurrounding;
+	int			i;
+	int			j;
+	vec3_t		mins, maxs;
+
+	//Don't take new targets
+//	if ( NPC->svFlags & SVF_LOCKEDENEMY )
+//		return enemy;
+
+	numSurrounding = AI_GetGroupSize( enemy->r.currentOrigin, 48, team, attacker );
+
+	//First, see if we should look for the player
+	if ( enemy != &g_entities[0] )
+	{
+		//rwwFIXMEFIXME: care about all clients not just 0
+		int	aroundPlayer = AI_GetGroupSize( g_entities[0].r.currentOrigin, 48, team, attacker );
+
+		//See if we're above our threshold
+		if ( aroundPlayer < threshold )
+		{
+			return &g_entities[0];
+		}
+	}
+
+	//See if our current enemy is still ok
+	if ( numSurrounding < threshold )
+		return enemy;
+
+	//Otherwise we need to take a new enemy if possible
+
+	//Setup the bbox to search in
+	for ( i = 0; i < 3; i++ )
+	{
+		mins[i] = enemy->r.currentOrigin[i] - 512;
+		maxs[i] = enemy->r.currentOrigin[i] + 512;
+	}
+
+	//Get the number of entities in a given space
+	numEnts = trap_EntitiesInBox( mins, maxs, radiusEnts, MAX_RADIUS_ENTS );
+
+	//Cull this list
+	for ( j = 0; j < numEnts; j++ )
+	{
+		check = &g_entities[radiusEnts[j]];
+
+		//Validate clients
+		if ( check->client == NULL )
+			continue;
+
+		//Skip the requested avoid ent if present
+		if ( ( check == enemy ) )
+			continue;
+
+		//Must be on the same team
+		if ( check->client->playerTeam != enemy->client->playerTeam )
+			continue;
+
+		//Must be alive
+		if ( check->health <= 0 )
+			continue;
+
+		//Must not be overwhelmed
+		if ( AI_GetGroupSize( check->r.currentOrigin, 48, team, attacker ) > threshold )
+			continue;
+
+		return check;
+	}
+
+	return NULL;
+}
diff --git a/codemp/game/NPC_AI_Wampa.c b/codemp/game/NPC_AI_Wampa.c
new file mode 100644
index 0000000..999a1aa
--- /dev/null
+++ b/codemp/game/NPC_AI_Wampa.c
@@ -0,0 +1,654 @@
+#include "b_local.h"
+#include "g_nav.h"
+
+// These define the working combat range for these suckers
+#define MIN_DISTANCE		48
+#define MIN_DISTANCE_SQR	( MIN_DISTANCE * MIN_DISTANCE )
+
+#define MAX_DISTANCE		1024
+#define MAX_DISTANCE_SQR	( MAX_DISTANCE * MAX_DISTANCE )
+
+#define LSTATE_CLEAR		0
+#define LSTATE_WAITING		1
+
+float enemyDist = 0;
+
+void Wampa_SetBolts( gentity_t *self )
+{
+	if ( self && self->client )
+	{
+		renderInfo_t *ri = &self->client->renderInfo;
+		ri->headBolt = trap_G2API_AddBolt(self->ghoul2, 0, "*head_eyes");
+		//ri->cervicalBolt = trap_G2API_AddBolt(self->ghoul2, 0, "neck_bone" );
+		//ri->chestBolt = trap_G2API_AddBolt(self->ghoul2, 0, "upper_spine");
+		//ri->gutBolt = trap_G2API_AddBolt(self->ghoul2, 0, "mid_spine");
+		ri->torsoBolt = trap_G2API_AddBolt(self->ghoul2, 0, "lower_spine");
+		ri->crotchBolt = trap_G2API_AddBolt(self->ghoul2, 0, "rear_bone");
+		//ri->elbowLBolt = trap_G2API_AddBolt(self->ghoul2, 0, "*l_arm_elbow");
+		//ri->elbowRBolt = trap_G2API_AddBolt(self->ghoul2, 0, "*r_arm_elbow");
+		ri->handLBolt = trap_G2API_AddBolt(self->ghoul2, 0, "*l_hand");
+		ri->handRBolt = trap_G2API_AddBolt(self->ghoul2, 0, "*r_hand");
+		//ri->kneeLBolt = trap_G2API_AddBolt(self->ghoul2, 0, "*hips_l_knee");
+		//ri->kneeRBolt = trap_G2API_AddBolt(self->ghoul2, 0, "*hips_r_knee");
+		ri->footLBolt = trap_G2API_AddBolt(self->ghoul2, 0, "*l_leg_foot");
+		ri->footRBolt = trap_G2API_AddBolt(self->ghoul2, 0, "*r_leg_foot");
+	}
+}
+
+/*
+-------------------------
+NPC_Wampa_Precache
+-------------------------
+*/
+void NPC_Wampa_Precache( void )
+{
+	/*
+	int i;
+	for ( i = 1; i < 4; i ++ )
+	{
+		G_SoundIndex( va("sound/chars/wampa/growl%d.wav", i) );
+	}
+	for ( i = 1; i < 3; i ++ )
+	{
+		G_SoundIndex( va("sound/chars/wampa/snort%d.wav", i) );
+	}
+	*/
+	G_SoundIndex( "sound/chars/rancor/swipehit.wav" );
+	//G_SoundIndex( "sound/chars/wampa/chomp.wav" );
+}
+
+
+/*
+-------------------------
+Wampa_Idle
+-------------------------
+*/
+void Wampa_Idle( void )
+{
+	NPCInfo->localState = LSTATE_CLEAR;
+
+	//If we have somewhere to go, then do that
+	if ( UpdateGoal() )
+	{
+		ucmd.buttons &= ~BUTTON_WALKING;
+		NPC_MoveToGoal( qtrue );
+	}
+}
+
+qboolean Wampa_CheckRoar( gentity_t *self )
+{
+	if ( self->wait < level.time )
+	{
+		self->wait = level.time + Q_irand( 5000, 20000 );
+		NPC_SetAnim( self, SETANIM_BOTH, Q_irand(BOTH_GESTURE1,BOTH_GESTURE2), (SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD) );
+		TIMER_Set( self, "rageTime", self->client->ps.legsTimer );
+		return qtrue;
+	}
+	return qfalse;
+}
+/*
+-------------------------
+Wampa_Patrol
+-------------------------
+*/
+void Wampa_Patrol( void )
+{
+	NPCInfo->localState = LSTATE_CLEAR;
+
+	//If we have somewhere to go, then do that
+	if ( UpdateGoal() )
+	{
+		ucmd.buttons |= BUTTON_WALKING;
+		NPC_MoveToGoal( qtrue );
+	}
+	else
+	{
+		if ( TIMER_Done( NPC, "patrolTime" ))
+		{
+			TIMER_Set( NPC, "patrolTime", crandom() * 5000 + 5000 );
+		}
+	}
+
+	if ( NPC_CheckEnemyExt( qtrue ) == qfalse )
+	{
+		Wampa_Idle();
+		return;
+	}
+	Wampa_CheckRoar( NPC );
+	TIMER_Set( NPC, "lookForNewEnemy", Q_irand( 5000, 15000 ) );
+}
+ 
+/*
+-------------------------
+Wampa_Move
+-------------------------
+*/
+void Wampa_Move( qboolean visible )
+{
+	if ( NPCInfo->localState != LSTATE_WAITING )
+	{
+		NPCInfo->goalEntity = NPC->enemy;
+
+		if ( NPC->enemy )
+		{//pick correct movement speed and anim
+			//run by default
+			ucmd.buttons &= ~BUTTON_WALKING;
+			if ( !TIMER_Done( NPC, "runfar" ) 
+				|| !TIMER_Done( NPC, "runclose" ) )
+			{//keep running with this anim & speed for a bit
+			}
+			else if ( !TIMER_Done( NPC, "walk" ) )
+			{//keep walking for a bit
+				ucmd.buttons |= BUTTON_WALKING;
+			}
+			else if ( visible && enemyDist > 384 && NPCInfo->stats.runSpeed == 180 )
+			{//fast run, all fours
+				NPCInfo->stats.runSpeed = 300;
+				TIMER_Set( NPC, "runfar", Q_irand( 2000, 4000 ) );
+			}
+			else if ( enemyDist > 256 && NPCInfo->stats.runSpeed == 300 )
+			{//slow run, upright
+				NPCInfo->stats.runSpeed = 180;
+				TIMER_Set( NPC, "runclose", Q_irand( 3000, 5000 ) );
+			}
+			else if ( enemyDist < 128 )
+			{//walk
+				NPCInfo->stats.runSpeed = 180;
+				ucmd.buttons |= BUTTON_WALKING;
+				TIMER_Set( NPC, "walk", Q_irand( 4000, 6000 ) );
+			}
+		}
+
+		if ( NPCInfo->stats.runSpeed == 300 )
+		{//need to use the alternate run - hunched over on all fours
+			NPC->client->ps.eFlags2 |= EF2_USE_ALT_ANIM;
+		}
+		NPC_MoveToGoal( qtrue );
+		NPCInfo->goalRadius = MAX_DISTANCE;	// just get us within combat range
+	}
+}
+
+//---------------------------------------------------------
+//extern void G_Knockdown( gentity_t *self, gentity_t *attacker, const vec3_t pushDir, float strength, qboolean breakSaberLock );
+extern void G_Knockdown( gentity_t *victim );
+extern void G_Dismember( gentity_t *ent, gentity_t *enemy, vec3_t point, int limbType, float limbRollBase, float limbPitchBase, int deathAnim, qboolean postDeath );
+extern int NPC_GetEntsNearBolt( int *radiusEnts, float radius, int boltIndex, vec3_t boltOrg );
+
+void Wampa_Slash( int boltIndex, qboolean backhand )
+{
+	int			radiusEntNums[128];
+	int			numEnts;
+	const float	radius = 88;
+	const float	radiusSquared = (radius*radius);
+	int			i;
+	vec3_t		boltOrg;
+	int			damage = (backhand)?Q_irand(10,15):Q_irand(20,30);
+
+	numEnts = NPC_GetEntsNearBolt( radiusEntNums, radius, boltIndex, boltOrg );
+
+	for ( i = 0; i < numEnts; i++ )
+	{
+		gentity_t *radiusEnt = &g_entities[radiusEntNums[i]];
+		if ( !radiusEnt->inuse )
+		{
+			continue;
+		}
+		
+		if ( radiusEnt == NPC )
+		{//Skip the wampa ent
+			continue;
+		}
+		
+		if ( radiusEnt->client == NULL )
+		{//must be a client
+			continue;
+		}
+
+		if ( DistanceSquared( radiusEnt->r.currentOrigin, boltOrg ) <= radiusSquared )
+		{
+			//smack
+			G_Damage( radiusEnt, NPC, NPC, vec3_origin, radiusEnt->r.currentOrigin, damage, ((backhand)?DAMAGE_NO_ARMOR:(DAMAGE_NO_ARMOR|DAMAGE_NO_KNOCKBACK)), MOD_MELEE );
+			if ( backhand )
+			{
+				//actually push the enemy
+				vec3_t pushDir;
+				vec3_t angs;
+				VectorCopy( NPC->client->ps.viewangles, angs );
+				angs[YAW] += flrand( 25, 50 );
+				angs[PITCH] = flrand( -25, -15 );
+				AngleVectors( angs, pushDir, NULL, NULL );
+				if ( radiusEnt->client->NPC_class != CLASS_WAMPA
+					&& radiusEnt->client->NPC_class != CLASS_RANCOR
+					&& radiusEnt->client->NPC_class != CLASS_ATST )
+				{
+					G_Throw( radiusEnt, pushDir, 65 );
+					if ( BG_KnockDownable(&radiusEnt->client->ps) &&
+						radiusEnt->health > 0 && Q_irand( 0, 1 ) )
+					{//do pain on enemy
+						radiusEnt->client->ps.forceHandExtend = HANDEXTEND_KNOCKDOWN;
+						radiusEnt->client->ps.forceDodgeAnim = 0;
+						radiusEnt->client->ps.forceHandExtendTime = level.time + 1100;
+						radiusEnt->client->ps.quickerGetup = qfalse;
+					}
+				}
+			}
+			else if ( radiusEnt->health <= 0 && radiusEnt->client )
+			{//killed them, chance of dismembering
+				if ( !Q_irand( 0, 1 ) )
+				{//bite something off
+					int hitLoc = Q_irand( G2_MODELPART_HEAD, G2_MODELPART_RLEG );
+					if ( hitLoc == G2_MODELPART_HEAD )
+					{
+						NPC_SetAnim( radiusEnt, SETANIM_BOTH, BOTH_DEATH17, SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLD );
+					}
+					else if ( hitLoc == G2_MODELPART_WAIST )
+					{
+						NPC_SetAnim( radiusEnt, SETANIM_BOTH, BOTH_DEATHBACKWARD2, SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLD );
+					}
+					G_Dismember( radiusEnt, NPC, radiusEnt->r.currentOrigin, hitLoc, 90, 0, radiusEnt->client->ps.torsoAnim, qtrue);
+				}
+			}
+			else if ( !Q_irand( 0, 3 ) && radiusEnt->health > 0 )
+			{//one out of every 4 normal hits does a knockdown, too
+				vec3_t pushDir;
+				vec3_t angs;
+				VectorCopy( NPC->client->ps.viewangles, angs );
+				angs[YAW] += flrand( 25, 50 );
+				angs[PITCH] = flrand( -25, -15 );
+				AngleVectors( angs, pushDir, NULL, NULL );
+				G_Knockdown( radiusEnt );
+			}
+			G_Sound( radiusEnt, CHAN_WEAPON, G_SoundIndex( "sound/chars/rancor/swipehit.wav" ) );
+		}
+	}
+}
+
+//------------------------------
+void Wampa_Attack( float distance, qboolean doCharge )
+{
+	if ( !TIMER_Exists( NPC, "attacking" ) )
+	{
+		if ( Q_irand(0, 2) && !doCharge )
+		{//double slash
+			NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_ATTACK1, SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLD );
+			TIMER_Set( NPC, "attack_dmg", 750 );
+		}
+		else if ( doCharge || (distance > 270 && distance < 430 && !Q_irand(0, 1)) )
+		{//leap
+			vec3_t	fwd, yawAng;
+			VectorSet( yawAng, 0, NPC->client->ps.viewangles[YAW], 0 );
+			NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_ATTACK2, SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLD );
+			TIMER_Set( NPC, "attack_dmg", 500 );
+			AngleVectors( yawAng, fwd, NULL, NULL );
+			VectorScale( fwd, distance*1.5f, NPC->client->ps.velocity );
+			NPC->client->ps.velocity[2] = 150;
+			NPC->client->ps.groundEntityNum = ENTITYNUM_NONE;
+		}
+		else
+		{//backhand
+			NPC_SetAnim( NPC, SETANIM_BOTH, BOTH_ATTACK3, SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLD );
+			TIMER_Set( NPC, "attack_dmg", 250 );
+		}
+
+		TIMER_Set( NPC, "attacking", NPC->client->ps.legsTimer + random() * 200 );
+		//allow us to re-evaluate our running speed/anim
+		TIMER_Set( NPC, "runfar", -1 );
+		TIMER_Set( NPC, "runclose", -1 );
+		TIMER_Set( NPC, "walk", -1 );
+	}
+
+	// Need to do delayed damage since the attack animations encapsulate multiple mini-attacks
+
+	if ( TIMER_Done2( NPC, "attack_dmg", qtrue ) )
+	{
+		switch ( NPC->client->ps.legsAnim )
+		{
+		case BOTH_ATTACK1:
+			Wampa_Slash( NPC->client->renderInfo.handRBolt, qfalse );
+			//do second hit
+			TIMER_Set( NPC, "attack_dmg2", 100 );
+			break;
+		case BOTH_ATTACK2:
+			Wampa_Slash( NPC->client->renderInfo.handRBolt, qfalse );
+			TIMER_Set( NPC, "attack_dmg2", 100 );
+			break;
+		case BOTH_ATTACK3:
+			Wampa_Slash( NPC->client->renderInfo.handLBolt, qtrue );
+			break;
+		}
+	}
+	else if ( TIMER_Done2( NPC, "attack_dmg2", qtrue ) )
+	{
+		switch ( NPC->client->ps.legsAnim )
+		{
+		case BOTH_ATTACK1:
+			Wampa_Slash( NPC->client->renderInfo.handLBolt, qfalse );
+			break;
+		case BOTH_ATTACK2:
+			Wampa_Slash( NPC->client->renderInfo.handLBolt, qfalse );
+			break;
+		}
+	}
+
+	// Just using this to remove the attacking flag at the right time
+	TIMER_Done2( NPC, "attacking", qtrue );
+
+	if ( NPC->client->ps.legsAnim == BOTH_ATTACK1 && distance > (NPC->r.maxs[0]+MIN_DISTANCE) )
+	{//okay to keep moving
+		ucmd.buttons |= BUTTON_WALKING;
+		Wampa_Move( 1 );
+	}
+}
+
+//----------------------------------
+void Wampa_Combat( void )
+{
+	// If we cannot see our target or we have somewhere to go, then do that
+	if ( !NPC_ClearLOS( NPC->r.currentOrigin, NPC->enemy->r.currentOrigin ) )
+	{
+		if ( !Q_irand( 0, 10 ) )
+		{
+			if ( Wampa_CheckRoar( NPC ) )
+			{
+				return;
+			}
+		}
+		NPCInfo->combatMove = qtrue;
+		NPCInfo->goalEntity = NPC->enemy;
+		NPCInfo->goalRadius = MAX_DISTANCE;	// just get us within combat range
+
+		Wampa_Move( 0 );
+		return;
+	}
+	else if ( UpdateGoal() )
+	{
+		NPCInfo->combatMove = qtrue;
+		NPCInfo->goalEntity = NPC->enemy;
+		NPCInfo->goalRadius = MAX_DISTANCE;	// just get us within combat range
+
+		Wampa_Move( 1 );
+		return;
+	}
+	else
+	{
+		float		distance = enemyDist = Distance( NPC->r.currentOrigin, NPC->enemy->r.currentOrigin );	
+		qboolean	advance = (qboolean)( distance > (NPC->r.maxs[0]+MIN_DISTANCE) ? qtrue : qfalse  );
+		qboolean	doCharge = qfalse;
+
+		// Sometimes I have problems with facing the enemy I'm attacking, so force the issue so I don't look dumb
+		//FIXME: always seems to face off to the left or right?!!!!
+		NPC_FaceEnemy( qtrue );
+
+
+		if ( advance )
+		{//have to get closer
+			vec3_t	yawOnlyAngles;
+			VectorSet( yawOnlyAngles, 0, NPC->r.currentAngles[YAW], 0 );
+			if ( NPC->enemy->health > 0//enemy still alive
+				&& fabs(distance-350) <= 80 //enemy anywhere from 270 to 430 away
+				&& InFOV3( NPC->enemy->r.currentOrigin, NPC->r.currentOrigin, yawOnlyAngles, 20, 20 ) )//enemy generally in front
+			{//10% chance of doing charge anim
+				if ( !Q_irand( 0, 9 ) )
+				{//go for the charge
+					doCharge = qtrue;
+					advance = qfalse;
+				}
+			}
+		}
+
+		if (( advance || NPCInfo->localState == LSTATE_WAITING ) && TIMER_Done( NPC, "attacking" )) // waiting monsters can't attack
+		{
+			if ( TIMER_Done2( NPC, "takingPain", qtrue ))
+			{
+				NPCInfo->localState = LSTATE_CLEAR;
+			}
+			else
+			{
+				Wampa_Move( 1 );
+			}
+		}
+		else
+		{
+			if ( !Q_irand( 0, 20 ) )
+			{//FIXME: only do this if we just damaged them or vice-versa?
+				if ( Wampa_CheckRoar( NPC ) )
+				{
+					return;
+				}
+			}
+			if ( !Q_irand( 0, 1 ) )
+			{//FIXME: base on skill
+				Wampa_Attack( distance, doCharge );
+			}
+		}
+	}
+}
+
+/*
+-------------------------
+NPC_Wampa_Pain
+-------------------------
+*/
+//void NPC_Wampa_Pain( gentity_t *self, gentity_t *inflictor, gentity_t *other, const vec3_t point, int damage, int mod,int hitLoc ) 
+void NPC_Wampa_Pain( gentity_t *self, gentity_t *attacker, int damage ) 
+{
+	qboolean hitByWampa = qfalse;
+	if ( attacker&&attacker->client&&attacker->client->NPC_class==CLASS_WAMPA )
+	{
+		hitByWampa = qtrue;
+	}
+	if ( attacker 
+		&& attacker->inuse 
+		&& attacker != self->enemy
+		&& !(attacker->flags&FL_NOTARGET) )
+	{
+		if ( (!attacker->s.number&&!Q_irand(0,3))
+			|| !self->enemy
+			|| self->enemy->health == 0
+			|| (self->enemy->client&&self->enemy->client->NPC_class == CLASS_WAMPA)
+			|| (!Q_irand(0, 4 ) && DistanceSquared( attacker->r.currentOrigin, self->r.currentOrigin ) < DistanceSquared( self->enemy->r.currentOrigin, self->r.currentOrigin )) ) 
+		{//if my enemy is dead (or attacked by player) and I'm not still holding/eating someone, turn on the attacker
+			//FIXME: if can't nav to my enemy, take this guy if I can nav to him
+			G_SetEnemy( self, attacker );
+			TIMER_Set( self, "lookForNewEnemy", Q_irand( 5000, 15000 ) );
+			if ( hitByWampa )
+			{//stay mad at this Wampa for 2-5 secs before looking for attacker enemies
+				TIMER_Set( self, "wampaInfight", Q_irand( 2000, 5000 ) );
+			}
+		}
+	}
+	if ( (hitByWampa|| Q_irand( 0, 100 ) < damage )//hit by wampa, hit while holding live victim, or took a lot of damage
+		&& self->client->ps.legsAnim != BOTH_GESTURE1
+		&& self->client->ps.legsAnim != BOTH_GESTURE2
+		&& TIMER_Done( self, "takingPain" ) )
+	{
+		if ( !Wampa_CheckRoar( self ) )
+		{
+			if ( self->client->ps.legsAnim != BOTH_ATTACK1
+				&& self->client->ps.legsAnim != BOTH_ATTACK2
+				&& self->client->ps.legsAnim != BOTH_ATTACK3 )
+			{//cant interrupt one of the big attack anims
+				if ( self->health > 100 || hitByWampa )
+				{
+					TIMER_Remove( self, "attacking" );
+
+					VectorCopy( self->NPC->lastPathAngles, self->s.angles );
+
+					if ( !Q_irand( 0, 1 ) )
+					{
+						NPC_SetAnim( self, SETANIM_BOTH, BOTH_PAIN2, SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLD );
+					}
+					else
+					{
+						NPC_SetAnim( self, SETANIM_BOTH, BOTH_PAIN1, SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLD );
+					}
+					TIMER_Set( self, "takingPain", self->client->ps.legsTimer+Q_irand(0, 500) );
+					//allow us to re-evaluate our running speed/anim
+					TIMER_Set( self, "runfar", -1 );
+					TIMER_Set( self, "runclose", -1 );
+					TIMER_Set( self, "walk", -1 );
+
+					if ( self->NPC )
+					{
+						self->NPC->localState = LSTATE_WAITING;
+					}
+				}
+			}
+		}
+	}
+}
+
+/*
+-------------------------
+NPC_BSWampa_Default
+-------------------------
+*/
+void NPC_BSWampa_Default( void )
+{
+	NPC->client->ps.eFlags2 &= ~EF2_USE_ALT_ANIM;
+	//NORMAL ANIMS
+	//	stand1 = normal stand
+	//	walk1 = normal, non-angry walk
+	//	walk2 = injured
+	//	run1 = far away run
+	//	run2 = close run
+	//VICTIM ANIMS
+	//	grabswipe = melee1 - sweep out and grab
+	//	stand2 attack = attack4 - while holding victim, swipe at him
+	//	walk3_drag = walk5 - walk with drag
+	//	stand2 = hold victim
+	//	stand2to1 = drop victim
+	if ( !TIMER_Done( NPC, "rageTime" ) )
+	{//do nothing but roar first time we see an enemy
+		NPC_FaceEnemy( qtrue );
+		return;
+	}
+	if ( NPC->enemy )
+	{
+		if ( !TIMER_Done(NPC,"attacking") )
+		{//in middle of attack
+			//face enemy
+			NPC_FaceEnemy( qtrue );
+			//continue attack logic
+			enemyDist = Distance( NPC->r.currentOrigin, NPC->enemy->r.currentOrigin );
+			Wampa_Attack( enemyDist, qfalse );
+			return;
+		}
+		else
+		{
+			if ( TIMER_Done(NPC,"angrynoise") )
+			{
+				G_Sound( NPC, CHAN_VOICE, G_SoundIndex( va("sound/chars/wampa/misc/anger%d.wav", Q_irand(1, 2)) ) );
+
+				TIMER_Set( NPC, "angrynoise", Q_irand( 5000, 10000 ) );
+			}
+			//else, if he's in our hand, we eat, else if he's on the ground, we keep attacking his dead body for a while
+			if( NPC->enemy->client && NPC->enemy->client->NPC_class == CLASS_WAMPA )
+			{//got mad at another Wampa, look for a valid enemy
+				if ( TIMER_Done( NPC, "wampaInfight" ) )
+				{
+					NPC_CheckEnemyExt( qtrue );
+				}
+			}
+			else
+			{
+				if ( ValidEnemy( NPC->enemy ) == qfalse )
+				{
+					TIMER_Remove( NPC, "lookForNewEnemy" );//make them look again right now
+					if ( !NPC->enemy->inuse || level.time - NPC->enemy->s.time > Q_irand( 10000, 15000 ) )
+					{//it's been a while since the enemy died, or enemy is completely gone, get bored with him
+						NPC->enemy = NULL;
+						Wampa_Patrol();
+						NPC_UpdateAngles( qtrue, qtrue );
+						//just lost my enemy
+						if ( (NPC->spawnflags&2) )
+						{//search around me if I don't have an enemy
+							NPC_BSSearchStart( NPC->waypoint, BS_SEARCH );
+							NPCInfo->tempBehavior = BS_DEFAULT;
+						}
+						else if ( (NPC->spawnflags&1) )
+						{//wander if I don't have an enemy
+							NPC_BSSearchStart( NPC->waypoint, BS_WANDER );
+							NPCInfo->tempBehavior = BS_DEFAULT;
+						}
+						return;
+					}
+				}
+				if ( TIMER_Done( NPC, "lookForNewEnemy" ) )
+				{
+					gentity_t *newEnemy, *sav_enemy = NPC->enemy;//FIXME: what about NPC->lastEnemy?
+					NPC->enemy = NULL;
+					newEnemy = NPC_CheckEnemy( NPCInfo->confusionTime < level.time, qfalse, qfalse );
+					NPC->enemy = sav_enemy;
+					if ( newEnemy && newEnemy != sav_enemy )
+					{//picked up a new enemy!
+						NPC->lastEnemy = NPC->enemy;
+						G_SetEnemy( NPC, newEnemy );
+						//hold this one for at least 5-15 seconds
+						TIMER_Set( NPC, "lookForNewEnemy", Q_irand( 5000, 15000 ) );
+					}
+					else
+					{//look again in 2-5 secs
+						TIMER_Set( NPC, "lookForNewEnemy", Q_irand( 2000, 5000 ) );
+					}
+				}
+			}
+			Wampa_Combat();
+			return;
+		}
+	}
+	else 
+	{
+		if ( TIMER_Done(NPC,"idlenoise") )
+		{
+			G_Sound( NPC, CHAN_AUTO, G_SoundIndex( "sound/chars/wampa/misc/anger3.wav" ) );
+
+			TIMER_Set( NPC, "idlenoise", Q_irand( 2000, 4000 ) );
+		}
+		if ( (NPC->spawnflags&2) )
+		{//search around me if I don't have an enemy
+			if ( NPCInfo->homeWp == WAYPOINT_NONE )
+			{//no homewap, initialize the search behavior
+				NPC_BSSearchStart( WAYPOINT_NONE, BS_SEARCH );
+				NPCInfo->tempBehavior = BS_DEFAULT;
+			}
+			ucmd.buttons |= BUTTON_WALKING;
+			NPC_BSSearch();//this automatically looks for enemies
+		}
+		else if ( (NPC->spawnflags&1) )
+		{//wander if I don't have an enemy
+			if ( NPCInfo->homeWp == WAYPOINT_NONE )
+			{//no homewap, initialize the wander behavior
+				NPC_BSSearchStart( WAYPOINT_NONE, BS_WANDER );
+				NPCInfo->tempBehavior = BS_DEFAULT;
+			}
+			ucmd.buttons |= BUTTON_WALKING;
+			NPC_BSWander();
+			if ( NPCInfo->scriptFlags & SCF_LOOK_FOR_ENEMIES )
+			{
+				if ( NPC_CheckEnemyExt( qtrue ) == qfalse )
+				{
+					Wampa_Idle();
+				}
+				else
+				{
+					Wampa_CheckRoar( NPC );
+					TIMER_Set( NPC, "lookForNewEnemy", Q_irand( 5000, 15000 ) );
+				}
+			}
+		}
+		else
+		{
+			if ( NPCInfo->scriptFlags & SCF_LOOK_FOR_ENEMIES )
+			{
+				Wampa_Patrol();
+			}
+			else
+			{
+				Wampa_Idle();
+			}
+		}
+	}
+
+	NPC_UpdateAngles( qtrue, qtrue );
+}
diff --git a/codemp/game/NPC_behavior.c b/codemp/game/NPC_behavior.c
new file mode 100644
index 0000000..a52435c
--- /dev/null
+++ b/codemp/game/NPC_behavior.c
@@ -0,0 +1,1748 @@
+//NPC_behavior.cpp
+/*
+FIXME - MCG:
+These all need to make use of the snapshots.  Write something that can look for only specific
+things in a snapshot or just go through the snapshot every frame and save the info in case
+we need it...
+*/
+
+#include "b_local.h"
+#include "g_nav.h"
+#include "../icarus/Q3_Interface.h"
+
+extern	qboolean	showBBoxes;
+extern vec3_t NPCDEBUG_BLUE;
+extern void G_Cube( vec3_t mins, vec3_t maxs, vec3_t color, float alpha );
+extern void NPC_CheckGetNewWeapon( void );
+
+#include "../namespace_begin.h"
+extern qboolean PM_InKnockDown( playerState_t *ps );
+#include "../namespace_end.h"
+
+extern void NPC_AimAdjust( int change );
+extern qboolean NPC_SomeoneLookingAtMe(gentity_t *ent);
+/*
+ void NPC_BSAdvanceFight (void)
+
+Advance towards your captureGoal and shoot anyone you can along the way.
+*/
+void NPC_BSAdvanceFight (void)
+{//FIXME: IMPLEMENT
+//Head to Goal if I can
+
+	//Make sure we're still headed where we want to capture
+	if ( NPCInfo->captureGoal )
+	{//FIXME: if no captureGoal, what do we do?
+		//VectorCopy( NPCInfo->captureGoal->r.currentOrigin, NPCInfo->tempGoal->r.currentOrigin );
+		//NPCInfo->goalEntity = NPCInfo->tempGoal;
+
+		NPC_SetMoveGoal( NPC, NPCInfo->captureGoal->r.currentOrigin, 16, qtrue, -1, NULL );
+
+//		NAV_ClearLastRoute(NPC);
+		NPCInfo->goalTime = level.time + 100000;
+	}
+
+//	NPC_BSRun();
+
+	NPC_CheckEnemy(qtrue, qfalse, qtrue);
+
+	//FIXME: Need melee code
+	if( NPC->enemy )
+	{//See if we can shoot him
+		vec3_t		delta, forward;
+		vec3_t		angleToEnemy;
+		vec3_t		hitspot, muzzle, diff, enemy_org, enemy_head;
+		float		distanceToEnemy;
+		qboolean	attack_ok = qfalse;
+		qboolean	dead_on = qfalse;
+		float		attack_scale = 1.0;
+		float		aim_off;
+		float		max_aim_off = 64;
+
+		//Yaw to enemy
+		VectorMA(NPC->enemy->r.absmin, 0.5, NPC->enemy->r.maxs, enemy_org);
+		CalcEntitySpot( NPC, SPOT_WEAPON, muzzle );
+		
+		VectorSubtract (enemy_org, muzzle, delta);
+		vectoangles ( delta, angleToEnemy );
+		distanceToEnemy = VectorNormalize(delta);
+
+		if(!NPC_EnemyTooFar(NPC->enemy, distanceToEnemy*distanceToEnemy, qtrue))
+		{
+			attack_ok = qtrue;
+		}
+
+		if(attack_ok)
+		{
+			NPC_UpdateShootAngles(angleToEnemy, qfalse, qtrue);
+
+			NPCInfo->enemyLastVisibility = enemyVisibility;
+			enemyVisibility = NPC_CheckVisibility ( NPC->enemy, CHECK_FOV);//CHECK_360|//CHECK_PVS|
+
+			if(enemyVisibility == VIS_FOV)
+			{//He's in our FOV
+				
+				attack_ok = qtrue;
+				CalcEntitySpot( NPC->enemy, SPOT_HEAD, enemy_head);
+
+				if(attack_ok)
+				{
+					trace_t		tr;
+					gentity_t	*traceEnt;
+					//are we gonna hit him if we shoot at his center?
+					trap_Trace ( &tr, muzzle, NULL, NULL, enemy_org, NPC->s.number, MASK_SHOT );
+					traceEnt = &g_entities[tr.entityNum];
+					if( traceEnt != NPC->enemy &&
+						(!traceEnt || !traceEnt->client || !NPC->client->enemyTeam || NPC->client->enemyTeam != traceEnt->client->playerTeam) )
+					{//no, so shoot for the head
+						attack_scale *= 0.75;
+						trap_Trace ( &tr, muzzle, NULL, NULL, enemy_head, NPC->s.number, MASK_SHOT );
+						traceEnt = &g_entities[tr.entityNum];
+					}
+
+					VectorCopy( tr.endpos, hitspot );
+
+					if( traceEnt == NPC->enemy || (traceEnt->client && NPC->client->enemyTeam && NPC->client->enemyTeam == traceEnt->client->playerTeam) )
+					{
+						dead_on = qtrue;
+					}
+					else
+					{
+						attack_scale *= 0.5;
+						if(NPC->client->playerTeam)
+						{
+							if(traceEnt && traceEnt->client && traceEnt->client->playerTeam)
+							{
+								if(NPC->client->playerTeam == traceEnt->client->playerTeam)
+								{//Don't shoot our own team
+									attack_ok = qfalse;
+								}
+							}
+						}
+					}
+				}
+
+				if( attack_ok )
+				{
+					//ok, now adjust pitch aim
+					VectorSubtract (hitspot, muzzle, delta);
+					vectoangles ( delta, angleToEnemy );
+					NPC->NPC->desiredPitch = angleToEnemy[PITCH];
+					NPC_UpdateShootAngles(angleToEnemy, qtrue, qfalse);
+
+					if( !dead_on )
+					{//We're not going to hit him directly, try a suppressing fire
+						//see if where we're going to shoot is too far from his origin
+						AngleVectors (NPCInfo->shootAngles, forward, NULL, NULL);
+						VectorMA ( muzzle, distanceToEnemy, forward, hitspot);
+						VectorSubtract(hitspot, enemy_org, diff);
+						aim_off = VectorLength(diff);
+						if(aim_off > random() * max_aim_off)//FIXME: use aim value to allow poor aim?
+						{
+							attack_scale *= 0.75;
+							//see if where we're going to shoot is too far from his head
+							VectorSubtract(hitspot, enemy_head, diff);
+							aim_off = VectorLength(diff);
+							if(aim_off > random() * max_aim_off)
+							{
+								attack_ok = qfalse;
+							}
+						}
+						attack_scale *= (max_aim_off - aim_off + 1)/max_aim_off;
+					}
+				}
+			}
+		}
+
+		if( attack_ok )
+		{
+			if( NPC_CheckAttack( attack_scale ))
+			{//check aggression to decide if we should shoot
+				enemyVisibility = VIS_SHOOT;
+				WeaponThink(qtrue);
+			}
+			else
+				attack_ok = qfalse;
+		}
+//Don't do this- only for when stationary and trying to shoot an enemy
+//		else
+//			NPC->cantHitEnemyCounter++;
+	}
+	else
+	{//FIXME: 
+		NPC_UpdateShootAngles(NPC->client->ps.viewangles, qtrue, qtrue);
+	}
+
+	if(!ucmd.forwardmove && !ucmd.rightmove)
+	{//We reached our captureGoal
+		if(trap_ICARUS_IsInitialized(NPC->s.number))
+		{
+			trap_ICARUS_TaskIDComplete( NPC, TID_BSTATE );
+		}
+	}
+}
+
+void Disappear(gentity_t *self)
+{
+//	ClientDisconnect(self);
+	self->s.eFlags |= EF_NODRAW;
+	self->think = 0;
+	self->nextthink = -1;
+}
+
+void MakeOwnerInvis (gentity_t *self);
+void BeamOut (gentity_t *self)
+{
+//	gentity_t *tent = G_Spawn();
+	
+/*
+	tent->owner = self;
+	tent->think = MakeOwnerInvis;
+	tent->nextthink = level.time + 1800;
+	//G_AddEvent( ent, EV_PLAYER_TELEPORT, 0 );
+	tent = G_TempEntity( self->client->pcurrentOrigin, EV_PLAYER_TELEPORT );
+*/
+	//fixme: doesn't actually go away!
+	self->nextthink = level.time + 1500;
+	self->think = Disappear;
+	self->client->squadname = NULL;
+	self->client->playerTeam = self->s.teamowner = TEAM_FREE;
+	//self->r.svFlags |= SVF_BEAMING; //this appears unused in SP as well
+}
+
+void NPC_BSCinematic( void ) 
+{
+
+	if( NPCInfo->scriptFlags & SCF_FIRE_WEAPON )
+	{
+		WeaponThink( qtrue );
+	}
+
+	if ( UpdateGoal() )
+	{//have a goalEntity
+		//move toward goal, should also face that goal
+		NPC_MoveToGoal( qtrue );
+	}
+
+	if ( NPCInfo->watchTarget )
+	{//have an entity which we want to keep facing
+		//NOTE: this will override any angles set by NPC_MoveToGoal
+		vec3_t eyes, viewSpot, viewvec, viewangles;
+
+		CalcEntitySpot( NPC, SPOT_HEAD_LEAN, eyes );
+		CalcEntitySpot( NPCInfo->watchTarget, SPOT_HEAD_LEAN, viewSpot );
+
+		VectorSubtract( viewSpot, eyes, viewvec );
+		
+		vectoangles( viewvec, viewangles );
+
+		NPCInfo->lockedDesiredYaw = NPCInfo->desiredYaw = viewangles[YAW];
+		NPCInfo->lockedDesiredPitch = NPCInfo->desiredPitch = viewangles[PITCH];
+	}
+
+	NPC_UpdateAngles( qtrue, qtrue );
+}
+
+void NPC_BSWait( void ) 
+{
+	NPC_UpdateAngles( qtrue, qtrue );
+}
+
+
+void NPC_BSInvestigate (void)
+{
+/*
+	//FIXME: maybe allow this to be set as a tempBState in a script?  Just specify the
+	//investigateGoal, investigateDebounceTime and investigateCount? (Needs a macro)
+	vec3_t		invDir, invAngles, spot;
+	gentity_t	*saveGoal;
+	//BS_INVESTIGATE would turn toward goal, maybe take a couple steps towards it,
+	//look for enemies, then turn away after your investigate counter was down-
+	//investigate counter goes up every time you set it...
+
+	if(level.time > NPCInfo->enemyCheckDebounceTime)
+	{
+		NPCInfo->enemyCheckDebounceTime = level.time + (NPCInfo->stats.vigilance * 1000);
+		NPC_CheckEnemy(qtrue, qfalse);
+		if(NPC->enemy)
+		{//FIXME: do anger script
+			NPCInfo->goalEntity = NPC->enemy;
+//			NAV_ClearLastRoute(NPC);
+			NPCInfo->behaviorState = BS_RUN_AND_SHOOT;
+			NPCInfo->tempBehavior = BS_DEFAULT;
+			NPC_AngerSound();
+			return;
+		}
+	}
+
+	NPC_SetAnim( NPC, SETANIM_TORSO, TORSO_WEAPONREADY3, SETANIM_FLAG_NORMAL );
+
+	if(NPCInfo->stats.vigilance <= 1.0 && NPCInfo->eventOwner)
+	{
+		VectorCopy(NPCInfo->eventOwner->r.currentOrigin, NPCInfo->investigateGoal);
+	}
+
+	saveGoal = NPCInfo->goalEntity;
+	if(	level.time > NPCInfo->walkDebounceTime )
+	{
+		vec3_t	vec;
+
+		VectorSubtract(NPCInfo->investigateGoal, NPC->r.currentOrigin, vec);
+		vec[2] = 0;
+		if(VectorLength(vec) > 64)
+		{
+			if(Q_irand(0, 100) < NPCInfo->investigateCount)
+			{//take a full step
+				//NPCInfo->walkDebounceTime = level.time + 1400;
+				//actually finds length of my BOTH_WALK anim
+				NPCInfo->walkDebounceTime = PM_AnimLength( NPC->client->clientInfo.animFileIndex, BOTH_WALK1 );
+			}
+		}
+	}
+
+	if(	level.time < NPCInfo->walkDebounceTime )
+	{//walk toward investigateGoal
+		
+		/*
+		NPCInfo->goalEntity = NPCInfo->tempGoal;
+//		NAV_ClearLastRoute(NPC);
+		VectorCopy(NPCInfo->investigateGoal, NPCInfo->tempGoal->r.currentOrigin);
+		*/
+
+/*		NPC_SetMoveGoal( NPC, NPCInfo->investigateGoal, 16, qtrue );
+
+		NPC_MoveToGoal( qtrue );
+
+		//FIXME: walk2?
+		NPC_SetAnim(NPC,SETANIM_LEGS,BOTH_WALK1,SETANIM_FLAG_NORMAL);
+
+		ucmd.buttons |= BUTTON_WALKING;
+	}
+	else
+	{
+
+		NPC_SetAnim(NPC,SETANIM_LEGS,BOTH_STAND1,SETANIM_FLAG_NORMAL);
+
+		if(NPCInfo->hlookCount > 30)
+		{
+			if(Q_irand(0, 10) > 7) 
+			{
+				NPCInfo->hlookCount = 0;
+			}
+		}
+		else if(NPCInfo->hlookCount < -30)
+		{
+			if(Q_irand(0, 10) > 7) 
+			{
+				NPCInfo->hlookCount = 0;
+			}
+		}
+		else if(NPCInfo->hlookCount == 0)
+		{
+			NPCInfo->hlookCount = Q_irand(-1, 1);
+		}
+		else if(Q_irand(0, 10) > 7) 
+		{
+			if(NPCInfo->hlookCount > 0)
+			{
+				NPCInfo->hlookCount++;
+			}
+			else//lookCount < 0
+			{
+				NPCInfo->hlookCount--;
+			}
+		}
+
+		if(NPCInfo->vlookCount >= 15)
+		{
+			if(Q_irand(0, 10) > 7) 
+			{
+				NPCInfo->vlookCount = 0;
+			}
+		}
+		else if(NPCInfo->vlookCount <= -15)
+		{
+			if(Q_irand(0, 10) > 7) 
+			{
+				NPCInfo->vlookCount = 0;
+			}
+		}
+		else if(NPCInfo->vlookCount == 0)
+		{
+			NPCInfo->vlookCount = Q_irand(-1, 1);
+		}
+		else if(Q_irand(0, 10) > 8) 
+		{
+			if(NPCInfo->vlookCount > 0)
+			{
+				NPCInfo->vlookCount++;
+			}
+			else//lookCount < 0
+			{
+				NPCInfo->vlookCount--;
+			}
+		}
+
+		//turn toward investigateGoal
+		CalcEntitySpot( NPC, SPOT_HEAD, spot );
+		VectorSubtract(NPCInfo->investigateGoal, spot, invDir);
+		VectorNormalize(invDir);
+		vectoangles(invDir, invAngles);
+		NPCInfo->desiredYaw = AngleNormalize360(invAngles[YAW] + NPCInfo->hlookCount);
+		NPCInfo->desiredPitch = AngleNormalize360(invAngles[PITCH] + NPCInfo->hlookCount);
+	}
+
+	NPC_UpdateAngles(qtrue, qtrue);
+
+	NPCInfo->goalEntity = saveGoal;
+//	NAV_ClearLastRoute(NPC);
+
+	if(level.time > NPCInfo->investigateDebounceTime)
+	{
+		NPCInfo->tempBehavior = BS_DEFAULT;
+	}
+
+	NPC_CheckSoundEvents();
+	*/
+}
+
+qboolean NPC_CheckInvestigate( int alertEventNum )
+{
+	gentity_t	*owner = level.alertEvents[alertEventNum].owner;
+	int		invAdd = level.alertEvents[alertEventNum].level;
+	vec3_t	soundPos;
+	float	soundRad = level.alertEvents[alertEventNum].radius;
+	float	earshot = NPCInfo->stats.earshot;
+
+	VectorCopy( level.alertEvents[alertEventNum].position, soundPos );
+
+	//NOTE: Trying to preserve previous investigation behavior
+	if ( !owner )
+	{
+		return qfalse;
+	}
+
+	if ( owner->s.eType != ET_PLAYER && owner->s.eType != ET_NPC && owner == NPCInfo->goalEntity ) 
+	{
+		return qfalse;
+	}
+
+	if ( owner->s.eFlags & EF_NODRAW ) 
+	{
+		return qfalse;
+	}
+
+	if ( owner->flags & FL_NOTARGET ) 
+	{
+		return qfalse;
+	}
+
+	if ( soundRad < earshot )
+	{
+		return qfalse;
+	}
+
+	//if(!trap_InPVSIgnorePortals(ent->r.currentOrigin, NPC->r.currentOrigin))//should we be able to hear through areaportals?
+	if ( !trap_InPVS( soundPos, NPC->r.currentOrigin ) )
+	{//can hear through doors?
+		return qfalse;
+	}
+
+	if ( owner->client && owner->client->playerTeam && NPC->client->playerTeam && owner->client->playerTeam != NPC->client->playerTeam )
+	{
+		if( (float)NPCInfo->investigateCount >= (NPCInfo->stats.vigilance*200) && owner )
+		{//If investigateCount == 10, just take it as enemy and go
+			if ( ValidEnemy( owner ) )
+			{//FIXME: run angerscript
+				G_SetEnemy( NPC, owner );
+				NPCInfo->goalEntity = NPC->enemy;
+				NPCInfo->goalRadius = 12;
+				NPCInfo->behaviorState = BS_HUNT_AND_KILL;
+				return qtrue;
+			}
+		}
+		else
+		{
+			NPCInfo->investigateCount += invAdd;
+		}
+		//run awakescript
+		G_ActivateBehavior(NPC, BSET_AWAKE);
+
+		/*
+		if ( Q_irand(0, 10) > 7 )
+		{
+			NPC_AngerSound();
+		}
+		*/
+
+		//NPCInfo->hlookCount = NPCInfo->vlookCount = 0;
+		NPCInfo->eventOwner = owner;
+		VectorCopy( soundPos, NPCInfo->investigateGoal );
+		if ( NPCInfo->investigateCount > 20 )
+		{
+			NPCInfo->investigateDebounceTime = level.time + 10000;
+		}
+		else
+		{
+			NPCInfo->investigateDebounceTime = level.time + (NPCInfo->investigateCount*500);
+		}
+		NPCInfo->tempBehavior = BS_INVESTIGATE;
+		return qtrue;
+	}
+
+	return qfalse;
+}
+
+
+/*
+void NPC_BSSleep( void ) 
+*/
+void NPC_BSSleep( void ) 
+{
+	int alertEvent = NPC_CheckAlertEvents( qtrue, qfalse, -1, qfalse, AEL_MINOR );
+
+	//There is an event to look at
+	if ( alertEvent >= 0 )
+	{
+		G_ActivateBehavior(NPC, BSET_AWAKE);
+		return;
+	}
+
+	/*
+	if ( level.time > NPCInfo->enemyCheckDebounceTime )
+	{
+		if ( NPC_CheckSoundEvents() != -1 )
+		{//only 1 alert per second per 0.1 of vigilance
+			NPCInfo->enemyCheckDebounceTime = level.time + (NPCInfo->stats.vigilance * 10000);
+			G_ActivateBehavior(NPC, BSET_AWAKE);
+		}
+	}
+	*/
+}
+
+extern qboolean NPC_MoveDirClear( int forwardmove, int rightmove, qboolean reset );
+void NPC_BSFollowLeader (void)
+{
+	vec3_t		vec;
+	float		leaderDist;
+	visibility_t	leaderVis;
+	int			curAnim;
+
+	if ( !NPC->client->leader )
+	{//ok, stand guard until we find an enemy
+		if( NPCInfo->tempBehavior == BS_HUNT_AND_KILL )
+		{
+			NPCInfo->tempBehavior = BS_DEFAULT;
+		}
+		else
+		{
+			NPCInfo->tempBehavior = BS_STAND_GUARD;
+			NPC_BSStandGuard();
+		}
+		return;
+	}
+
+	if ( !NPC->enemy  )
+	{//no enemy, find one
+		NPC_CheckEnemy( NPCInfo->confusionTime<level.time, qfalse, qtrue );//don't find new enemy if this is tempbehav
+		if ( NPC->enemy )
+		{//just found one
+			NPCInfo->enemyCheckDebounceTime = level.time + Q_irand( 3000, 10000 );
+		}
+		else
+		{
+			if ( !(NPCInfo->scriptFlags&SCF_IGNORE_ALERTS) )
+			{
+				int eventID = NPC_CheckAlertEvents( qtrue, qtrue, -1, qfalse, AEL_MINOR );
+				if ( level.alertEvents[eventID].level >= AEL_SUSPICIOUS && (NPCInfo->scriptFlags&SCF_LOOK_FOR_ENEMIES) )
+				{
+					NPCInfo->lastAlertID = level.alertEvents[eventID].ID;
+					if ( !level.alertEvents[eventID].owner || 
+						!level.alertEvents[eventID].owner->client || 
+						level.alertEvents[eventID].owner->health <= 0 ||
+						level.alertEvents[eventID].owner->client->playerTeam != NPC->client->enemyTeam )
+					{//not an enemy
+					}
+					else
+					{
+						//FIXME: what if can't actually see enemy, don't know where he is... should we make them just become very alert and start looking for him?  Or just let combat AI handle this... (act as if you lost him)
+						G_SetEnemy( NPC, level.alertEvents[eventID].owner );
+						NPCInfo->enemyCheckDebounceTime = level.time + Q_irand( 3000, 10000 );
+						NPCInfo->enemyLastSeenTime = level.time;
+						TIMER_Set( NPC, "attackDelay", Q_irand( 500, 1000 ) );
+					}
+				}
+
+			}
+		}
+		if ( !NPC->enemy )
+		{
+			if ( NPC->client->leader 
+				&& NPC->client->leader->enemy 
+				&& NPC->client->leader->enemy != NPC
+				&& ( (NPC->client->leader->enemy->client&&NPC->client->leader->enemy->client->playerTeam==NPC->client->enemyTeam)
+					||(/*NPC->client->leader->enemy->r.svFlags&SVF_NONNPC_ENEMY*/0&&NPC->client->leader->enemy->alliedTeam==NPC->client->enemyTeam) )
+				&& NPC->client->leader->enemy->health > 0 )
+			{ //rwwFIXMEFIXME: use SVF_NONNPC_ENEMY?
+				G_SetEnemy( NPC, NPC->client->leader->enemy );
+				NPCInfo->enemyCheckDebounceTime = level.time + Q_irand( 3000, 10000 );
+				NPCInfo->enemyLastSeenTime = level.time;
+			}
+		}
+	}
+	else 
+	{
+		if ( NPC->enemy->health <= 0 || (NPC->enemy->flags&FL_NOTARGET) )
+		{
+			G_ClearEnemy( NPC );
+			if ( NPCInfo->enemyCheckDebounceTime > level.time + 1000 )
+			{
+				NPCInfo->enemyCheckDebounceTime = level.time + Q_irand( 1000, 2000 );
+			}
+		}
+		else if ( NPC->client->ps.weapon && NPCInfo->enemyCheckDebounceTime < level.time )
+		{
+			NPC_CheckEnemy( (NPCInfo->confusionTime<level.time||NPCInfo->tempBehavior!=BS_FOLLOW_LEADER), qfalse, qtrue );//don't find new enemy if this is tempbehav
+		}
+	}
+	
+	if ( NPC->enemy && NPC->client->ps.weapon )
+	{//If have an enemy, face him and fire
+		if ( NPC->client->ps.weapon == WP_SABER )//|| NPCInfo->confusionTime>level.time )
+		{//lightsaber user or charmed enemy
+			if ( NPCInfo->tempBehavior != BS_FOLLOW_LEADER )
+			{//not already in a temp bState
+				//go after the guy
+				NPCInfo->tempBehavior = BS_HUNT_AND_KILL;
+				NPC_UpdateAngles(qtrue, qtrue);
+				return;
+			}
+		}
+
+		enemyVisibility = NPC_CheckVisibility ( NPC->enemy, CHECK_FOV|CHECK_SHOOT );//CHECK_360|CHECK_PVS|
+		if ( enemyVisibility > VIS_PVS )
+		{//face
+			vec3_t	enemy_org, muzzle, delta, angleToEnemy;
+			float	distanceToEnemy;
+
+			CalcEntitySpot( NPC->enemy, SPOT_HEAD, enemy_org );
+			NPC_AimWiggle( enemy_org );
+
+			CalcEntitySpot( NPC, SPOT_WEAPON, muzzle );
+			
+			VectorSubtract( enemy_org, muzzle, delta);
+			vectoangles( delta, angleToEnemy );
+			distanceToEnemy = VectorNormalize( delta );
+
+			NPCInfo->desiredYaw = angleToEnemy[YAW];
+			NPCInfo->desiredPitch = angleToEnemy[PITCH];
+			NPC_UpdateFiringAngles( qtrue, qtrue );
+
+			if ( enemyVisibility >= VIS_SHOOT )
+			{//shoot
+				NPC_AimAdjust( 2 );
+				if ( NPC_GetHFOVPercentage( NPC->enemy->r.currentOrigin, NPC->r.currentOrigin, NPC->client->ps.viewangles, NPCInfo->stats.hfov ) > 0.6f 
+					&& NPC_GetHFOVPercentage( NPC->enemy->r.currentOrigin, NPC->r.currentOrigin, NPC->client->ps.viewangles, NPCInfo->stats.vfov ) > 0.5f )
+				{//actually withing our front cone
+					WeaponThink( qtrue );
+				}
+			}
+			else
+			{
+				NPC_AimAdjust( 1 );
+			}
+			
+			//NPC_CheckCanAttack(1.0, qfalse);
+		}
+		else
+		{
+			NPC_AimAdjust( -1 );
+		}
+	}
+	else
+	{//FIXME: combine with vector calc below
+		vec3_t	head, leaderHead, delta, angleToLeader;
+
+		CalcEntitySpot( NPC->client->leader, SPOT_HEAD, leaderHead );
+		CalcEntitySpot( NPC, SPOT_HEAD, head );
+		VectorSubtract (leaderHead, head, delta);
+		vectoangles ( delta, angleToLeader );
+		VectorNormalize(delta);
+		NPC->NPC->desiredYaw = angleToLeader[YAW];
+		NPC->NPC->desiredPitch = angleToLeader[PITCH];
+		
+		NPC_UpdateAngles(qtrue, qtrue);
+	}
+
+	//leader visible?
+	leaderVis = NPC_CheckVisibility( NPC->client->leader, CHECK_PVS|CHECK_360|CHECK_SHOOT );//			ent->e_UseFunc = useF_NULL;
+
+
+	//Follow leader, stay within visibility and a certain distance, maintain a distance from.
+	curAnim = NPC->client->ps.legsAnim;
+	if ( curAnim != BOTH_ATTACK1 && curAnim != BOTH_ATTACK2 && curAnim != BOTH_ATTACK3 && curAnim != BOTH_MELEE1 && curAnim != BOTH_MELEE2 )
+	{//Don't move toward leader if we're in a full-body attack anim
+		//FIXME, use IdealDistance to determine if we need to close distance
+		float	followDist = 96.0f;//FIXME:  If there are enmies, make this larger?
+		float	backupdist, walkdist, minrundist;
+		float	leaderHDist;
+
+		if ( NPCInfo->followDist )
+		{
+			followDist = NPCInfo->followDist;
+		}
+		backupdist = followDist/2.0f;
+		walkdist = followDist*0.83;
+		minrundist = followDist*1.33;
+
+		VectorSubtract(NPC->client->leader->r.currentOrigin, NPC->r.currentOrigin, vec);
+		leaderDist = VectorLength( vec );//FIXME: make this just nav distance?
+		//never get within their radius horizontally
+		vec[2] = 0;
+		leaderHDist = VectorLength( vec );
+		if( leaderHDist > backupdist && (leaderVis != VIS_SHOOT || leaderDist > walkdist) )
+		{//We should close in?
+			NPCInfo->goalEntity = NPC->client->leader;
+
+			NPC_SlideMoveToGoal();
+			if ( leaderVis == VIS_SHOOT && leaderDist < minrundist )
+			{
+				ucmd.buttons |= BUTTON_WALKING;
+			}
+		}
+		else if ( leaderDist < backupdist )
+		{//We should back off?
+			NPCInfo->goalEntity = NPC->client->leader;
+			NPC_SlideMoveToGoal();
+
+			//reversing direction
+			ucmd.forwardmove = -ucmd.forwardmove;
+			ucmd.rightmove   = -ucmd.rightmove;
+			VectorScale( NPC->client->ps.moveDir, -1, NPC->client->ps.moveDir );
+		}//otherwise, stay where we are
+		//check for do not enter and stop if there's one there...
+		if ( ucmd.forwardmove || ucmd.rightmove || VectorCompare( vec3_origin, NPC->client->ps.moveDir ) )
+		{
+			NPC_MoveDirClear( ucmd.forwardmove, ucmd.rightmove, qtrue );
+		}
+	}
+}
+#define	APEX_HEIGHT		200.0f
+#define	PARA_WIDTH		(sqrt(APEX_HEIGHT)+sqrt(APEX_HEIGHT))
+#define	JUMP_SPEED		200.0f
+void NPC_BSJump (void)
+{
+	vec3_t		dir, angles, p1, p2, apex;
+	float		time, height, forward, z, xy, dist, yawError, apexHeight;
+
+	if( !NPCInfo->goalEntity )
+	{//Should have task completed the navgoal
+		return;
+	}
+
+	if ( NPCInfo->jumpState != JS_JUMPING && NPCInfo->jumpState != JS_LANDING )
+	{
+		//Face navgoal
+		VectorSubtract(NPCInfo->goalEntity->r.currentOrigin, NPC->r.currentOrigin, dir);
+		vectoangles(dir, angles);
+		NPCInfo->desiredPitch = NPCInfo->lockedDesiredPitch = AngleNormalize360(angles[PITCH]);
+		NPCInfo->desiredYaw = NPCInfo->lockedDesiredYaw = AngleNormalize360(angles[YAW]);
+	}
+
+	NPC_UpdateAngles ( qtrue, qtrue );
+	yawError = AngleDelta ( NPC->client->ps.viewangles[YAW], NPCInfo->desiredYaw );
+	//We don't really care about pitch here
+
+	switch ( NPCInfo->jumpState )
+	{
+	case JS_FACING:
+		if ( yawError < MIN_ANGLE_ERROR )
+		{//Facing it, Start crouching
+			NPC_SetAnim(NPC, SETANIM_LEGS, BOTH_CROUCH1, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD);
+			NPCInfo->jumpState = JS_CROUCHING;
+		}
+		break;
+	case JS_CROUCHING:
+		if ( NPC->client->ps.legsTimer > 0 )
+		{//Still playing crouching anim
+			return;
+		}
+
+		//Create a parabola
+
+		if ( NPC->r.currentOrigin[2] > NPCInfo->goalEntity->r.currentOrigin[2] )
+		{
+			VectorCopy( NPC->r.currentOrigin, p1 );
+			VectorCopy( NPCInfo->goalEntity->r.currentOrigin, p2 );
+		}
+		else if ( NPC->r.currentOrigin[2] < NPCInfo->goalEntity->r.currentOrigin[2] )
+		{
+			VectorCopy( NPCInfo->goalEntity->r.currentOrigin, p1 );
+			VectorCopy( NPC->r.currentOrigin, p2 );
+		}
+		else
+		{
+			VectorCopy( NPC->r.currentOrigin, p1 );
+			VectorCopy( NPCInfo->goalEntity->r.currentOrigin, p2 );
+		}
+
+		//z = xy*xy
+		VectorSubtract( p2, p1, dir );
+		dir[2] = 0;
+
+		//Get xy and z diffs
+		xy = VectorNormalize( dir );
+		z = p1[2] - p2[2];
+
+		apexHeight = APEX_HEIGHT/2;
+		/*
+		//Determine most desirable apex height
+		apexHeight = (APEX_HEIGHT * PARA_WIDTH/xy) + (APEX_HEIGHT * z/128);
+		if ( apexHeight < APEX_HEIGHT * 0.5 )
+		{
+			apexHeight = APEX_HEIGHT*0.5;
+		}
+		else if ( apexHeight > APEX_HEIGHT * 2 )
+		{
+			apexHeight = APEX_HEIGHT*2;
+		}
+		*/
+
+		//FIXME: length of xy will change curve of parabola, need to account for this
+		//somewhere... PARA_WIDTH
+		
+		z = (sqrt(apexHeight + z) - sqrt(apexHeight));
+
+		assert(z >= 0);
+
+//		Com_Printf("apex is %4.2f percent from p1: ", (xy-z)*0.5/xy*100.0f);
+
+		xy -= z;
+		xy *= 0.5;
+		
+		assert(xy > 0);
+
+		VectorMA( p1, xy, dir, apex );
+		apex[2] += apexHeight;
+	
+		VectorCopy(apex, NPC->pos1);
+		
+		//Now we have the apex, aim for it
+		height = apex[2] - NPC->r.currentOrigin[2];
+		time = sqrt( height / ( .5 * NPC->client->ps.gravity ) );
+		if ( !time ) 
+		{
+//			Com_Printf("ERROR no time in jump\n");
+			return;
+		}
+
+		// set s.origin2 to the push velocity
+		VectorSubtract ( apex, NPC->r.currentOrigin, NPC->client->ps.velocity );
+		NPC->client->ps.velocity[2] = 0;
+		dist = VectorNormalize( NPC->client->ps.velocity );
+
+		forward = dist / time;
+		VectorScale( NPC->client->ps.velocity, forward, NPC->client->ps.velocity );
+
+		NPC->client->ps.velocity[2] = time * NPC->client->ps.gravity;
+
+//		Com_Printf( "%s jumping %s, gravity at %4.0f percent\n", NPC->targetname, vtos(NPC->client->ps.velocity), NPC->client->ps.gravity/8.0f );
+
+		NPC->flags |= FL_NO_KNOCKBACK;
+		NPCInfo->jumpState = JS_JUMPING;
+		//FIXME: jumpsound?
+		break;
+	case JS_JUMPING:
+
+		if ( showBBoxes )
+		{
+			VectorAdd(NPC->r.mins, NPC->pos1, p1);
+			VectorAdd(NPC->r.maxs, NPC->pos1, p2);
+			G_Cube( p1, p2, NPCDEBUG_BLUE, 0.5 );
+		}
+
+		if ( NPC->s.groundEntityNum != ENTITYNUM_NONE)
+		{//Landed, start landing anim
+			//FIXME: if the 
+			VectorClear(NPC->client->ps.velocity);
+			NPC_SetAnim(NPC, SETANIM_BOTH, BOTH_LAND1, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD);
+			NPCInfo->jumpState = JS_LANDING;
+			//FIXME: landsound?
+		}
+		else if ( NPC->client->ps.legsTimer > 0 )
+		{//Still playing jumping anim
+			//FIXME: apply jump velocity here, a couple frames after start, not right away
+			return;
+		}
+		else
+		{//still in air, but done with jump anim, play inair anim
+			NPC_SetAnim(NPC, SETANIM_BOTH, BOTH_INAIR1, SETANIM_FLAG_OVERRIDE);
+		}
+		break;
+	case JS_LANDING:
+		if ( NPC->client->ps.legsTimer > 0 )
+		{//Still playing landing anim
+			return;
+		}
+		else
+		{
+			NPCInfo->jumpState = JS_WAITING;
+
+			
+			//task complete no matter what...  
+			NPC_ClearGoal();
+			NPCInfo->goalTime = level.time;
+			NPCInfo->aiFlags &= ~NPCAI_MOVING;
+			ucmd.forwardmove = 0;
+			NPC->flags &= ~FL_NO_KNOCKBACK;
+			//Return that the goal was reached
+			trap_ICARUS_TaskIDComplete( NPC, TID_MOVE_NAV );
+			
+			//Or should we keep jumping until reached goal?
+			
+			/*
+			NPCInfo->goalEntity = UpdateGoal();
+			if ( !NPCInfo->goalEntity )
+			{
+				NPC->flags &= ~FL_NO_KNOCKBACK;
+				Q3_TaskIDComplete( NPC, TID_MOVE_NAV );
+			}
+			*/
+			
+		}
+		break;
+	case JS_WAITING:
+	default:
+		NPCInfo->jumpState = JS_FACING;
+		break;
+	}
+}
+
+void NPC_BSRemove (void)
+{
+	NPC_UpdateAngles ( qtrue, qtrue );
+	if( !trap_InPVS( NPC->r.currentOrigin, g_entities[0].r.currentOrigin ) )//FIXME: use cg.vieworg?
+	{ //rwwFIXMEFIXME: Care about all clients instead of just 0?
+		G_UseTargets2( NPC, NPC, NPC->target3 );
+		NPC->s.eFlags |= EF_NODRAW;
+		NPC->s.eType = ET_INVISIBLE;
+		NPC->r.contents = 0;
+		NPC->health = 0;
+		NPC->targetname = NULL;
+
+		//Disappear in half a second
+		NPC->think = G_FreeEntity;
+		NPC->nextthink = level.time + FRAMETIME;
+	}//FIXME: else allow for out of FOV???
+}
+
+void NPC_BSSearch (void)
+{
+	NPC_CheckEnemy(qtrue, qfalse, qtrue);
+	//Look for enemies, if find one:
+	if ( NPC->enemy )
+	{
+		if( NPCInfo->tempBehavior == BS_SEARCH )
+		{//if tempbehavior, set tempbehavior to default
+			NPCInfo->tempBehavior = BS_DEFAULT;
+		}
+		else
+		{//if bState, change to run and shoot
+			NPCInfo->behaviorState = BS_HUNT_AND_KILL;
+			NPC_BSRunAndShoot();
+		}
+		return;
+	}
+
+	//FIXME: what if our goalEntity is not NULL and NOT our tempGoal - they must
+	//want us to do something else?  If tempBehavior, just default, else set
+	//to run and shoot...?
+
+	//FIXME: Reimplement
+
+	if ( !NPCInfo->investigateDebounceTime )
+	{//On our way to a tempGoal
+		float	minGoalReachedDistSquared = 32*32;
+		vec3_t	vec;
+
+		//Keep moving toward our tempGoal
+		NPCInfo->goalEntity = NPCInfo->tempGoal;
+
+		VectorSubtract ( NPCInfo->tempGoal->r.currentOrigin, NPC->r.currentOrigin, vec);
+		if ( vec[2] < 24 )
+		{
+			vec[2] = 0;
+		}
+
+		if ( NPCInfo->tempGoal->waypoint != WAYPOINT_NONE )
+		{
+			/*
+			//FIXME: can't get the radius...
+			float	wpRadSq = waypoints[NPCInfo->tempGoal->waypoint].radius * waypoints[NPCInfo->tempGoal->waypoint].radius;
+			if ( minGoalReachedDistSquared > wpRadSq )
+			{
+				minGoalReachedDistSquared = wpRadSq;
+			}
+			*/
+
+			minGoalReachedDistSquared = 32*32;//12*12;
+		}
+
+		if ( VectorLengthSquared( vec ) < minGoalReachedDistSquared )
+		{
+			//Close enough, just got there
+			NPC->waypoint = NAV_FindClosestWaypointForEnt( NPC, WAYPOINT_NONE );
+
+			if ( ( NPCInfo->homeWp == WAYPOINT_NONE ) || ( NPC->waypoint == WAYPOINT_NONE ) )
+			{
+				//Heading for or at an invalid waypoint, get out of this bState
+				if( NPCInfo->tempBehavior == BS_SEARCH )
+				{//if tempbehavior, set tempbehavior to default
+					NPCInfo->tempBehavior = BS_DEFAULT;
+				}
+				else
+				{//if bState, change to stand guard
+					NPCInfo->behaviorState = BS_STAND_GUARD;
+					NPC_BSRunAndShoot();
+				}
+				return;
+			}
+
+			if ( NPC->waypoint == NPCInfo->homeWp )
+			{
+				//Just Reached our homeWp, if this is the first time, run your lostenemyscript
+				if ( NPCInfo->aiFlags & NPCAI_ENROUTE_TO_HOMEWP )
+				{
+					NPCInfo->aiFlags &= ~NPCAI_ENROUTE_TO_HOMEWP;
+					G_ActivateBehavior( NPC, BSET_LOSTENEMY );
+				}
+
+			}
+
+			//Com_Printf("Got there.\n");
+			//Com_Printf("Looking...");
+			if( !Q_irand(0, 1) )
+			{
+				NPC_SetAnim(NPC, SETANIM_BOTH, BOTH_GUARD_LOOKAROUND1, SETANIM_FLAG_NORMAL);
+			}
+			else
+			{
+				NPC_SetAnim(NPC, SETANIM_BOTH, BOTH_GUARD_IDLE1, SETANIM_FLAG_NORMAL);
+			}
+			NPCInfo->investigateDebounceTime = level.time + Q_irand(3000, 10000);
+		}
+		else
+		{
+			NPC_MoveToGoal( qtrue );
+		}
+	}
+	else
+	{
+		//We're there
+		if ( NPCInfo->investigateDebounceTime > level.time )
+		{
+			//Still waiting around for a bit
+			//Turn angles every now and then to look around
+			if ( NPCInfo->tempGoal->waypoint != WAYPOINT_NONE )
+			{
+				if ( !Q_irand( 0, 30 ) )
+				{
+					int	numEdges = trap_Nav_GetNodeNumEdges( NPCInfo->tempGoal->waypoint );
+
+					if ( numEdges != WAYPOINT_NONE )
+					{
+						int branchNum = Q_irand( 0, numEdges - 1 );
+
+						vec3_t	branchPos, lookDir;
+
+						int nextWp = trap_Nav_GetNodeEdge( NPCInfo->tempGoal->waypoint, branchNum );
+						trap_Nav_GetNodePosition( nextWp, branchPos );
+
+						VectorSubtract( branchPos, NPCInfo->tempGoal->r.currentOrigin, lookDir );
+						NPCInfo->desiredYaw = AngleNormalize360( vectoyaw( lookDir ) + flrand( -45, 45 ) );
+					}
+
+					//pick an angle +-45 degrees off of the dir of a random branch
+					//from NPCInfo->tempGoal->waypoint
+					//int branch = Q_irand( 0, (waypoints[NPCInfo->tempGoal->waypoint].numNeighbors - 1) );
+					//int	nextWp = waypoints[NPCInfo->tempGoal->waypoint].nextWaypoint[branch][NPC->client->moveType];
+					//vec3_t	lookDir;
+
+					//VectorSubtract( waypoints[nextWp].origin, NPCInfo->tempGoal->r.currentOrigin, lookDir );
+					//Look in that direction +- 45 degrees
+					//NPCInfo->desiredYaw = AngleNormalize360( vectoyaw( lookDir ) + Q_flrand( -45, 45 ) );
+				}
+			}
+			//Com_Printf(".");
+		}
+		else
+		{//Just finished waiting
+			NPC->waypoint = NAV_FindClosestWaypointForEnt( NPC, WAYPOINT_NONE );
+			
+			if ( NPC->waypoint == NPCInfo->homeWp )
+			{
+				int	numEdges = trap_Nav_GetNodeNumEdges( NPCInfo->tempGoal->waypoint );
+
+				if ( numEdges != WAYPOINT_NONE )
+				{
+					int branchNum = Q_irand( 0, numEdges - 1 );
+
+					int nextWp = trap_Nav_GetNodeEdge( NPCInfo->homeWp, branchNum );
+					trap_Nav_GetNodePosition( nextWp, NPCInfo->tempGoal->r.currentOrigin );
+					NPCInfo->tempGoal->waypoint = nextWp;
+				}
+
+				/*
+				//Pick a random branch
+				int branch = Q_irand( 0, (waypoints[NPCInfo->homeWp].numNeighbors - 1) );
+				int	nextWp = waypoints[NPCInfo->homeWp].nextWaypoint[branch][NPC->client->moveType];
+
+				VectorCopy( waypoints[nextWp].origin, NPCInfo->tempGoal->r.currentOrigin );
+				NPCInfo->tempGoal->waypoint = nextWp;
+				//Com_Printf("\nHeading for wp %d...\n", waypoints[NPCInfo->homeWp].nextWaypoint[branch][NPC->client->moveType]);
+				*/
+			}
+			else
+			{//At a branch, so return home
+				trap_Nav_GetNodePosition( NPCInfo->homeWp, NPCInfo->tempGoal->r.currentOrigin );
+				NPCInfo->tempGoal->waypoint = NPCInfo->homeWp;
+				/*
+				VectorCopy( waypoints[NPCInfo->homeWp].origin, NPCInfo->tempGoal->r.currentOrigin );
+				NPCInfo->tempGoal->waypoint = NPCInfo->homeWp;
+				//Com_Printf("\nHeading for wp %d...\n", NPCInfo->homeWp);
+				*/
+			}
+
+			NPCInfo->investigateDebounceTime = 0;
+			//Start moving toward our tempGoal
+			NPCInfo->goalEntity = NPCInfo->tempGoal;
+			NPC_MoveToGoal( qtrue );
+		}
+	}
+
+	NPC_UpdateAngles( qtrue, qtrue );
+}
+
+/*
+-------------------------
+NPC_BSSearchStart
+-------------------------
+*/
+
+void NPC_BSSearchStart( int homeWp, bState_t bState )
+{
+	//FIXME: Reimplement
+	if ( homeWp == WAYPOINT_NONE )
+	{
+		homeWp = NAV_FindClosestWaypointForEnt( NPC, WAYPOINT_NONE );
+		if( NPC->waypoint == WAYPOINT_NONE )
+		{
+			NPC->waypoint = homeWp;
+		}
+	}
+	NPCInfo->homeWp = homeWp;
+	NPCInfo->tempBehavior = bState;
+	NPCInfo->aiFlags |= NPCAI_ENROUTE_TO_HOMEWP;
+	NPCInfo->investigateDebounceTime = 0;
+	trap_Nav_GetNodePosition( homeWp, NPCInfo->tempGoal->r.currentOrigin );
+	NPCInfo->tempGoal->waypoint = homeWp;
+	//Com_Printf("\nHeading for wp %d...\n", NPCInfo->homeWp);
+}
+
+/*
+-------------------------
+NPC_BSNoClip
+
+  Use in extreme circumstances only
+-------------------------
+*/
+
+void NPC_BSNoClip ( void )
+{
+	if ( UpdateGoal() )
+	{
+		vec3_t	dir, forward, right, angles, up = {0, 0, 1};
+		float	fDot, rDot, uDot;
+
+		VectorSubtract( NPCInfo->goalEntity->r.currentOrigin, NPC->r.currentOrigin, dir );
+		
+		vectoangles( dir, angles );
+		NPCInfo->desiredYaw = angles[YAW];
+
+		AngleVectors( NPC->r.currentAngles, forward, right, NULL );
+
+		VectorNormalize( dir );
+
+		fDot = DotProduct(forward, dir) * 127;
+		rDot = DotProduct(right, dir) * 127;
+		uDot = DotProduct(up, dir) * 127;
+
+		ucmd.forwardmove = floor(fDot);
+		ucmd.rightmove = floor(rDot);
+		ucmd.upmove = floor(uDot);
+	}
+	else
+	{
+		//Cut velocity?
+		VectorClear( NPC->client->ps.velocity );
+	}
+
+	NPC_UpdateAngles( qtrue, qtrue );
+}
+
+void NPC_BSWander (void)
+{//FIXME: don't actually go all the way to the next waypoint, just move in fits and jerks...?
+	if ( !NPCInfo->investigateDebounceTime )
+	{//Starting out
+		float	minGoalReachedDistSquared = 64;//32*32;
+		vec3_t	vec;
+
+		//Keep moving toward our tempGoal
+		NPCInfo->goalEntity = NPCInfo->tempGoal;
+
+		VectorSubtract ( NPCInfo->tempGoal->r.currentOrigin, NPC->r.currentOrigin, vec);
+
+		if ( NPCInfo->tempGoal->waypoint != WAYPOINT_NONE )
+		{
+			minGoalReachedDistSquared = 64;
+		}
+
+		if ( VectorLengthSquared( vec ) < minGoalReachedDistSquared )
+		{
+			//Close enough, just got there
+			NPC->waypoint = NAV_FindClosestWaypointForEnt( NPC, WAYPOINT_NONE );
+
+			if( !Q_irand(0, 1) )
+			{
+				NPC_SetAnim(NPC, SETANIM_BOTH, BOTH_GUARD_LOOKAROUND1, SETANIM_FLAG_NORMAL);
+			}
+			else
+			{
+				NPC_SetAnim(NPC, SETANIM_BOTH, BOTH_GUARD_IDLE1, SETANIM_FLAG_NORMAL);
+			}
+			//Just got here, so Look around for a while
+			NPCInfo->investigateDebounceTime = level.time + Q_irand(3000, 10000);
+		}
+		else
+		{
+			//Keep moving toward goal
+			NPC_MoveToGoal( qtrue );
+		}
+	}
+	else
+	{
+		//We're there
+		if ( NPCInfo->investigateDebounceTime > level.time )
+		{
+			//Still waiting around for a bit
+			//Turn angles every now and then to look around
+			if ( NPCInfo->tempGoal->waypoint != WAYPOINT_NONE )
+			{
+				if ( !Q_irand( 0, 30 ) )
+				{
+					int	numEdges = trap_Nav_GetNodeNumEdges( NPCInfo->tempGoal->waypoint );
+
+					if ( numEdges != WAYPOINT_NONE )
+					{
+						int branchNum = Q_irand( 0, numEdges - 1 );
+
+						vec3_t	branchPos, lookDir;
+
+						int	nextWp = trap_Nav_GetNodeEdge( NPCInfo->tempGoal->waypoint, branchNum );
+						trap_Nav_GetNodePosition( nextWp, branchPos );
+
+						VectorSubtract( branchPos, NPCInfo->tempGoal->r.currentOrigin, lookDir );
+						NPCInfo->desiredYaw = AngleNormalize360( vectoyaw( lookDir ) + flrand( -45, 45 ) );
+					}
+				}
+			}
+		}
+		else
+		{//Just finished waiting
+			NPC->waypoint = NAV_FindClosestWaypointForEnt( NPC, WAYPOINT_NONE );
+			
+			if ( NPC->waypoint != WAYPOINT_NONE )
+			{
+				int	numEdges = trap_Nav_GetNodeNumEdges( NPC->waypoint );
+
+				if ( numEdges != WAYPOINT_NONE )
+				{
+					int branchNum = Q_irand( 0, numEdges - 1 );
+
+					int nextWp = trap_Nav_GetNodeEdge( NPC->waypoint, branchNum );
+					trap_Nav_GetNodePosition( nextWp, NPCInfo->tempGoal->r.currentOrigin );
+					NPCInfo->tempGoal->waypoint = nextWp;
+				}
+
+				NPCInfo->investigateDebounceTime = 0;
+				//Start moving toward our tempGoal
+				NPCInfo->goalEntity = NPCInfo->tempGoal;
+				NPC_MoveToGoal( qtrue );
+			}
+		}
+	}
+
+	NPC_UpdateAngles( qtrue, qtrue );
+}
+
+/*
+void NPC_BSFaceLeader (void)
+{
+	vec3_t	head, leaderHead, delta, angleToLeader;
+
+	if ( !NPC->client->leader )
+	{//uh.... okay.
+		return;
+	}
+
+	CalcEntitySpot( NPC->client->leader, SPOT_HEAD, leaderHead );
+	CalcEntitySpot( NPC, SPOT_HEAD, head );
+	VectorSubtract( leaderHead, head, delta );
+	vectoangles( delta, angleToLeader );
+	VectorNormalize( delta );
+	NPC->NPC->desiredYaw = angleToLeader[YAW];
+	NPC->NPC->desiredPitch = angleToLeader[PITCH];
+	
+	NPC_UpdateAngles(qtrue, qtrue);
+}
+*/
+/*
+-------------------------
+NPC_BSFlee
+-------------------------
+*/
+extern void G_AddVoiceEvent( gentity_t *self, int event, int speakDebounceTime );
+extern void WP_DropWeapon( gentity_t *dropper, vec3_t velocity );
+extern void ChangeWeapon( gentity_t *ent, int newWeapon );
+void NPC_Surrender( void )
+{//FIXME: say "don't shoot!" if we weren't already surrendering
+	if ( NPC->client->ps.weaponTime || PM_InKnockDown( &NPC->client->ps ) )
+	{
+		return;
+	}
+	if ( NPC->s.weapon != WP_NONE && 
+		NPC->s.weapon != WP_STUN_BATON &&
+		NPC->s.weapon != WP_SABER )
+	{
+		//WP_DropWeapon( NPC, NULL ); //rwwFIXMEFIXME: Do this (gonna need a system for notifying client of removal)
+	}
+	if ( NPCInfo->surrenderTime < level.time - 5000 )
+	{//haven't surrendered for at least 6 seconds, tell them what you're doing
+		//FIXME: need real dialogue EV_SURRENDER
+		NPCInfo->blockedSpeechDebounceTime = 0;//make sure we say this
+		G_AddVoiceEvent( NPC, Q_irand( EV_PUSHED1, EV_PUSHED3 ), 3000 );
+	}
+//	NPC_SetAnim( NPC, SETANIM_TORSO, TORSO_SURRENDER_START, SETANIM_FLAG_HOLD|SETANIM_FLAG_OVERRIDE );
+//	NPC->client->ps.torsoTimer = 1000;
+	NPCInfo->surrenderTime = level.time + 1000;//stay surrendered for at least 1 second
+	//FIXME: while surrendering, make a big sight/sound alert? Or G_AlertTeam?
+}
+
+qboolean NPC_CheckSurrender( void )
+{
+	if ( !trap_ICARUS_TaskIDPending( NPC, TID_MOVE_NAV ) 
+		&& NPC->client->ps.groundEntityNum != ENTITYNUM_NONE 
+		&& !NPC->client->ps.weaponTime && !PM_InKnockDown( &NPC->client->ps )
+		&& NPC->enemy && NPC->enemy->client && NPC->enemy->enemy == NPC && NPC->enemy->s.weapon != WP_NONE && NPC->enemy->s.weapon != WP_STUN_BATON 
+		&& NPC->enemy->health > 20 && NPC->enemy->painDebounceTime < level.time - 3000 && NPC->enemy->client->ps.fd.forcePowerDebounce[FP_SABER_DEFENSE] < level.time - 1000 )
+	{//don't surrender if scripted to run somewhere or if we're in the air or if we're busy or if we don't have an enemy or if the enemy is not mad at me or is hurt or not a threat or busy being attacked
+		//FIXME: even if not in a group, don't surrender if there are other enemies in the PVS and within a certain range?
+		if ( NPC->s.weapon != WP_ROCKET_LAUNCHER 
+			&& NPC->s.weapon != WP_REPEATER
+			&& NPC->s.weapon != WP_FLECHETTE
+			&& NPC->s.weapon != WP_SABER )
+		{//jedi and heavy weapons guys never surrender
+			//FIXME: rework all this logic into some orderly fashion!!!
+			if ( NPC->s.weapon != WP_NONE )
+			{//they have a weapon so they'd have to drop it to surrender
+				//don't give up unless low on health
+				if ( NPC->health > 25 /*|| NPC->health >= NPC->max_health*/ )
+				{ //rwwFIXMEFIXME: Keep max health not a ps state?
+					return qfalse;
+				}
+				//if ( g_crosshairEntNum == NPC->s.number && NPC->painDebounceTime > level.time )
+				if (NPC_SomeoneLookingAtMe(NPC) && NPC->painDebounceTime > level.time)
+				{//if he just shot me, always give up
+					//fall through
+				}
+				else
+				{//don't give up unless facing enemy and he's very close
+					if ( !InFOV( NPC->enemy, NPC, 60, 30 ) )
+					{//I'm not looking at them
+						return qfalse;
+					}
+					else if ( DistanceSquared( NPC->r.currentOrigin, NPC->enemy->r.currentOrigin ) < 65536/*256*256*/ )
+					{//they're not close
+						return qfalse;
+					}
+					else if ( !trap_InPVS( NPC->r.currentOrigin, NPC->enemy->r.currentOrigin ) )
+					{//they're not in the same room
+						return qfalse;
+					}
+				}
+			}
+			//fixme: this logic keeps making npc's randomly surrender
+			/*
+			if ( NPCInfo->group && NPCInfo->group->numGroup <= 1 )
+			{//I'm alone but I was in a group//FIXME: surrender anyway if just melee or no weap?
+				if ( NPC->s.weapon == WP_NONE 
+					//NPC has a weapon
+					|| (NPC->enemy && NPC->enemy->s.number < MAX_CLIENTS)
+					|| (NPC->enemy->s.weapon == WP_SABER&&NPC->enemy->client&&!NPC->enemy->client->ps.saberHolstered)
+					|| (NPC->enemy->NPC && NPC->enemy->NPC->group && NPC->enemy->NPC->group->numGroup > 2) )
+				{//surrender only if have no weapon or fighting a player or jedi or if we are outnumbered at least 3 to 1
+					if ( (NPC->enemy && NPC->enemy->s.number < MAX_CLIENTS) )
+					{//player is the guy I'm running from
+						//if ( g_crosshairEntNum == NPC->s.number )
+						if (NPC_SomeoneLookingAtMe(NPC))
+						{//give up if player is aiming at me
+							NPC_Surrender();
+							NPC_UpdateAngles( qtrue, qtrue );
+							return qtrue;
+						}
+						else if ( NPC->enemy->s.weapon == WP_SABER )
+						{//player is using saber
+							if ( InFOV( NPC, NPC->enemy, 60, 30 ) )
+							{//they're looking at me
+								if ( DistanceSquared( NPC->r.currentOrigin, NPC->enemy->r.currentOrigin ) < 16384 )
+								{//they're close
+									if ( trap_InPVS( NPC->r.currentOrigin, NPC->enemy->r.currentOrigin ) )
+									{//they're in the same room
+										NPC_Surrender();
+										NPC_UpdateAngles( qtrue, qtrue );
+										return qtrue;
+									}
+								}
+							}
+						}
+					}
+					else if ( NPC->enemy )
+					{//???
+						//should NPC's surrender to others?
+						if ( InFOV( NPC, NPC->enemy, 30, 30 ) )
+						{//they're looking at me
+							if ( DistanceSquared( NPC->r.currentOrigin, NPC->enemy->r.currentOrigin ) < 4096 )
+							{//they're close
+								if ( trap_InPVS( NPC->r.currentOrigin, NPC->enemy->r.currentOrigin ) )
+								{//they're in the same room
+									//FIXME: should player-team NPCs not fire on surrendered NPCs?
+									NPC_Surrender();
+									NPC_UpdateAngles( qtrue, qtrue );
+									return qtrue;
+								}
+							}
+						}
+					}
+				}
+			}
+			*/
+		}
+	}
+	return qfalse;
+}
+
+void NPC_BSFlee( void )
+{//FIXME: keep checking for danger
+	gentity_t *goal;
+
+	if ( TIMER_Done( NPC, "flee" ) && NPCInfo->tempBehavior == BS_FLEE )
+	{
+		NPCInfo->tempBehavior = BS_DEFAULT;
+		NPCInfo->squadState = SQUAD_IDLE;
+		//FIXME: should we set some timer to make him stay in this spot for a bit, 
+		//so he doesn't just suddenly turn around and come back at the enemy?
+		//OR, just stop running toward goal for last second or so of flee?
+	}
+	if ( NPC_CheckSurrender() )
+	{
+		return;
+	}
+	goal = NPCInfo->goalEntity;
+	if ( !goal )
+	{
+		goal = NPCInfo->lastGoalEntity;
+		if ( !goal )
+		{//???!!!
+			goal = NPCInfo->tempGoal;
+		}
+	}
+
+	if ( goal )
+	{
+		qboolean moved;
+		qboolean reverseCourse = qtrue;
+
+		//FIXME: if no weapon, find one and run to pick it up?
+
+		//Let's try to find a waypoint that gets me away from this thing
+		if ( NPC->waypoint == WAYPOINT_NONE )
+		{
+			NPC->waypoint = NAV_GetNearestNode( NPC, NPC->lastWaypoint );
+		}
+		if ( NPC->waypoint != WAYPOINT_NONE )
+		{
+			int	numEdges = trap_Nav_GetNodeNumEdges( NPC->waypoint );
+
+			if ( numEdges != WAYPOINT_NONE )
+			{
+				vec3_t	dangerDir;
+				int		nextWp;
+				int		branchNum;
+
+				VectorSubtract( NPCInfo->investigateGoal, NPC->r.currentOrigin, dangerDir );
+				VectorNormalize( dangerDir );
+
+				for ( branchNum = 0; branchNum < numEdges; branchNum++ )
+				{
+					vec3_t	branchPos, runDir;
+
+					nextWp = trap_Nav_GetNodeEdge( NPC->waypoint, branchNum );
+					trap_Nav_GetNodePosition( nextWp, branchPos );
+
+					VectorSubtract( branchPos, NPC->r.currentOrigin, runDir );
+					VectorNormalize( runDir );
+					if ( DotProduct( runDir, dangerDir ) > flrand( 0, 0.5 ) )
+					{//don't run toward danger
+						continue;
+					}
+					//FIXME: don't want to ping-pong back and forth
+					NPC_SetMoveGoal( NPC, branchPos, 0, qtrue, -1, NULL );
+					reverseCourse = qfalse;
+					break;
+				}
+			}
+		}
+
+		moved = NPC_MoveToGoal( qfalse );//qtrue? (do try to move straight to (away from) goal)
+
+		if ( NPC->s.weapon == WP_NONE && (moved == qfalse || reverseCourse) )
+		{//No weapon and no escape route... Just cower?  Need anim.
+			NPC_Surrender();
+			NPC_UpdateAngles( qtrue, qtrue );
+			return;
+		}
+		//If our move failed, then just run straight away from our goal
+		//FIXME: We really shouldn't do this.
+		if ( moved == qfalse )
+		{
+			vec3_t	dir;
+			float	dist;
+			if ( reverseCourse )
+			{
+				VectorSubtract( NPC->r.currentOrigin, goal->r.currentOrigin, dir );
+			}
+			else
+			{
+				VectorSubtract( goal->r.currentOrigin, NPC->r.currentOrigin, dir );
+			}
+			NPCInfo->distToGoal	= dist = VectorNormalize( dir );
+			NPCInfo->desiredYaw = vectoyaw( dir );
+			NPCInfo->desiredPitch = 0;
+			ucmd.forwardmove = 127;
+		}
+		else if ( reverseCourse )
+		{
+			//ucmd.forwardmove *= -1;
+			//ucmd.rightmove *= -1;
+			//VectorScale( NPC->client->ps.moveDir, -1, NPC->client->ps.moveDir );
+			NPCInfo->desiredYaw *= -1;
+		}
+		//FIXME: can stop after a safe distance?
+		//ucmd.upmove = 0;
+		ucmd.buttons &= ~BUTTON_WALKING;
+		//FIXME: what do we do once we've gotten to our goal?
+	}
+	NPC_UpdateAngles( qtrue, qtrue );
+
+	NPC_CheckGetNewWeapon();
+}
+
+void NPC_StartFlee( gentity_t *enemy, vec3_t dangerPoint, int dangerLevel, int fleeTimeMin, int fleeTimeMax )
+{
+	int cp = -1;
+
+	if ( trap_ICARUS_TaskIDPending( NPC, TID_MOVE_NAV ) )
+	{//running somewhere that a script requires us to go, don't interrupt that!
+		return;
+	}
+
+	//if have a fleescript, run that instead
+	if ( G_ActivateBehavior( NPC, BSET_FLEE ) )
+	{
+		return;
+	}
+	//FIXME: play a flee sound?  Appropriate to situation?
+	if ( enemy )
+	{
+		G_SetEnemy( NPC, enemy );
+	}
+	
+	//FIXME: if don't have a weapon, find nearest one we have a route to and run for it?
+	if ( dangerLevel > AEL_DANGER || NPC->s.weapon == WP_NONE || ((!NPCInfo->group || NPCInfo->group->numGroup <= 1) && NPC->health <= 10 ) )
+	{//IF either great danger OR I have no weapon OR I'm alone and low on health, THEN try to find a combat point out of PVS
+		cp = NPC_FindCombatPoint( NPC->r.currentOrigin, NPC->r.currentOrigin, dangerPoint, CP_COVER|CP_AVOID|CP_HAS_ROUTE|CP_NO_PVS, 128, -1 );
+	}
+	//FIXME: still happens too often...
+	if ( cp == -1 )
+	{//okay give up on the no PVS thing
+		cp = NPC_FindCombatPoint( NPC->r.currentOrigin, NPC->r.currentOrigin, dangerPoint, CP_COVER|CP_AVOID|CP_HAS_ROUTE, 128, -1 );
+		if ( cp == -1 )
+		{//okay give up on the avoid
+			cp = NPC_FindCombatPoint( NPC->r.currentOrigin, NPC->r.currentOrigin, dangerPoint, CP_COVER|CP_HAS_ROUTE, 128, -1 );
+			if ( cp == -1 )
+			{//okay give up on the cover
+				cp = NPC_FindCombatPoint( NPC->r.currentOrigin, NPC->r.currentOrigin, dangerPoint, CP_HAS_ROUTE, 128, -1 );
+			}
+		}
+	}
+
+	//see if we got a valid one
+	if ( cp != -1 )
+	{//found a combat point
+		NPC_SetCombatPoint( cp );
+		NPC_SetMoveGoal( NPC, level.combatPoints[cp].origin, 8, qtrue, cp, NULL );
+		NPCInfo->behaviorState = BS_HUNT_AND_KILL;
+		NPCInfo->tempBehavior = BS_DEFAULT;
+	}
+	else
+	{//need to just run like hell!
+		if ( NPC->s.weapon != WP_NONE )
+		{
+			return;//let's just not flee?
+		}
+		else
+		{
+			//FIXME: other evasion AI?  Duck?  Strafe?  Dodge?
+			NPCInfo->tempBehavior = BS_FLEE;
+			//Run straight away from here... FIXME: really want to find farthest waypoint/navgoal from this pos... maybe based on alert event radius?
+			NPC_SetMoveGoal( NPC, dangerPoint, 0, qtrue, -1, NULL );
+			//store the danger point
+			VectorCopy( dangerPoint, NPCInfo->investigateGoal );//FIXME: make a new field for this?
+		}
+	}
+	//FIXME: localize this Timer?
+	TIMER_Set( NPC, "attackDelay", Q_irand( 500, 2500 ) );
+	//FIXME: is this always applicable?
+	NPCInfo->squadState = SQUAD_RETREAT;
+	TIMER_Set( NPC, "flee", Q_irand( fleeTimeMin, fleeTimeMax ) );
+	TIMER_Set( NPC, "panic", Q_irand( 1000, 4000 ) );//how long to wait before trying to nav to a dropped weapon
+	
+	if (NPC->client->NPC_class != CLASS_PROTOCOL)
+	{
+		TIMER_Set( NPC, "duck", 0 );
+	}
+}
+
+void G_StartFlee( gentity_t *self, gentity_t *enemy, vec3_t dangerPoint, int dangerLevel, int fleeTimeMin, int fleeTimeMax )
+{
+	if ( !self->NPC )
+	{//player
+		return;
+	}
+	SaveNPCGlobals();
+	SetNPCGlobals( self );
+
+	NPC_StartFlee( enemy, dangerPoint, dangerLevel, fleeTimeMin, fleeTimeMax );
+
+	RestoreNPCGlobals();
+}
+
+void NPC_BSEmplaced( void )
+{
+	qboolean enemyLOS = qfalse;
+	qboolean enemyCS = qfalse;
+	qboolean faceEnemy = qfalse;
+	qboolean shoot = qfalse;
+	vec3_t	impactPos;
+
+	//Don't do anything if we're hurt
+	if ( NPC->painDebounceTime > level.time )
+	{
+		NPC_UpdateAngles( qtrue, qtrue );
+		return;
+	}
+
+	if( NPCInfo->scriptFlags & SCF_FIRE_WEAPON )
+	{
+		WeaponThink( qtrue );
+	}
+
+	//If we don't have an enemy, just idle
+	if ( NPC_CheckEnemyExt(qfalse) == qfalse )
+	{
+		if ( !Q_irand( 0, 30 ) )
+		{
+			NPCInfo->desiredYaw = NPC->s.angles[1] + Q_irand( -90, 90 );
+		}
+		if ( !Q_irand( 0, 30 ) )
+		{
+			NPCInfo->desiredPitch = Q_irand( -20, 20 );
+		}
+		NPC_UpdateAngles( qtrue, qtrue );
+		return;
+	}
+
+	if ( NPC_ClearLOS4( NPC->enemy ) )
+	{
+		int hit;
+		gentity_t *hitEnt;
+
+		enemyLOS = qtrue;
+
+		hit = NPC_ShotEntity( NPC->enemy, impactPos );
+		hitEnt = &g_entities[hit];
+
+		if ( hit == NPC->enemy->s.number || ( hitEnt && hitEnt->takedamage ) )
+		{//can hit enemy or will hit glass or other minor breakable (or in emplaced gun), so shoot anyway
+			enemyCS = qtrue;
+			NPC_AimAdjust( 2 );//adjust aim better longer we have clear shot at enemy
+			VectorCopy( NPC->enemy->r.currentOrigin, NPCInfo->enemyLastSeenLocation );
+		}
+	}
+/*
+	else if ( trap_InPVS( NPC->enemy->r.currentOrigin, NPC->r.currentOrigin ) )
+	{
+		NPCInfo->enemyLastSeenTime = level.time;
+		faceEnemy = qtrue;
+		NPC_AimAdjust( -1 );//adjust aim worse longer we cannot see enemy
+	}
+*/
+
+	if ( enemyLOS )
+	{//FIXME: no need to face enemy if we're moving to some other goal and he's too far away to shoot?
+		faceEnemy = qtrue;
+	}
+	if ( enemyCS )
+	{
+		shoot = qtrue;
+	}
+
+	if ( faceEnemy )
+	{//face the enemy
+		NPC_FaceEnemy( qtrue );
+	}
+	else
+	{//we want to face in the dir we're running
+		NPC_UpdateAngles( qtrue, qtrue );
+	}
+
+	if ( NPCInfo->scriptFlags & SCF_DONT_FIRE )
+	{
+		shoot = qfalse;
+	}
+
+	if ( NPC->enemy && NPC->enemy->enemy )
+	{
+		if ( NPC->enemy->s.weapon == WP_SABER && NPC->enemy->enemy->s.weapon == WP_SABER )
+		{//don't shoot at an enemy jedi who is fighting another jedi, for fear of injuring one or causing rogue blaster deflections (a la Obi Wan/Vader duel at end of ANH)
+			shoot = qfalse;
+		}
+	}
+	if ( shoot )
+	{//try to shoot if it's time
+		if( !(NPCInfo->scriptFlags & SCF_FIRE_WEAPON) ) // we've already fired, no need to do it again here
+		{
+			WeaponThink( qtrue );
+		}
+	}
+}
diff --git a/codemp/game/NPC_combat.c b/codemp/game/NPC_combat.c
new file mode 100644
index 0000000..e623b3a
--- /dev/null
+++ b/codemp/game/NPC_combat.c
@@ -0,0 +1,3144 @@
+//NPC_combat.cpp
+#include "b_local.h"
+#include "g_nav.h"
+
+extern void G_AddVoiceEvent( gentity_t *self, int event, int speakDebounceTime );
+extern void G_SetEnemy( gentity_t *self, gentity_t *enemy );
+extern qboolean NPC_CheckLookTarget( gentity_t *self );
+extern void NPC_ClearLookTarget( gentity_t *self );
+extern void NPC_Jedi_RateNewEnemy( gentity_t *self, gentity_t *enemy );
+extern int NAV_FindClosestWaypointForPoint2( vec3_t point );
+extern int NAV_GetNearestNode( gentity_t *self, int lastNode );
+extern void G_CreateG2AttachedWeaponModel( gentity_t *ent, const char *weaponModel, int boltNum, int weaponNum );
+extern qboolean PM_DroidMelee( int npc_class );
+
+void ChangeWeapon( gentity_t *ent, int newWeapon );
+
+void G_ClearEnemy (gentity_t *self)
+{
+	NPC_CheckLookTarget( self );
+
+	if ( self->enemy )
+	{
+		if(	self->client && self->client->renderInfo.lookTarget == self->enemy->s.number )
+		{
+			NPC_ClearLookTarget( self );
+		}
+
+		if ( self->NPC && self->enemy == self->NPC->goalEntity )
+		{
+			self->NPC->goalEntity = NULL;
+		}
+		//FIXME: set last enemy?
+	}
+
+	self->enemy = NULL;
+}
+
+/*
+-------------------------
+NPC_AngerAlert
+-------------------------
+*/
+
+#define	ANGER_ALERT_RADIUS			512
+#define	ANGER_ALERT_SOUND_RADIUS	256
+
+void G_AngerAlert( gentity_t *self )
+{
+	if ( self && self->NPC && (self->NPC->scriptFlags&SCF_NO_GROUPS) )
+	{//I'm not a team playa...
+		return;
+	}
+	if ( !TIMER_Done( self, "interrogating" ) )
+	{//I'm interrogating, don't wake everyone else up yet... FIXME: this may never wake everyone else up, though!
+		return;
+	}
+	//FIXME: hmm.... with all the other new alerts now, is this still neccesary or even a good idea...?
+	G_AlertTeam( self, self->enemy, ANGER_ALERT_RADIUS, ANGER_ALERT_SOUND_RADIUS );	
+}
+
+/*
+-------------------------
+G_TeamEnemy
+-------------------------
+*/
+
+qboolean G_TeamEnemy( gentity_t *self )
+{//FIXME: Probably a better way to do this, is a linked list of your teammates already available?
+	int	i;
+	gentity_t	*ent;
+
+	if ( !self->client || self->client->playerTeam == TEAM_FREE )
+	{
+		return qfalse;
+	}
+	if ( self && self->NPC && (self->NPC->scriptFlags&SCF_NO_GROUPS) )
+	{//I'm not a team playa...
+		return qfalse;
+	}
+
+	for( i = 1; i < level.num_entities; i++ )
+	{
+		ent = &g_entities[i];
+
+		if ( ent == self )
+		{
+			continue;
+		}
+
+		if ( ent->health <= 0 )
+		{
+			continue;
+		}
+
+		if ( !ent->client )
+		{
+			continue;
+		}
+
+		if ( ent->client->playerTeam != self->client->playerTeam )
+		{//ent is not on my team
+			continue;
+		}
+
+		if ( ent->enemy )
+		{//they have an enemy
+			if ( !ent->enemy->client || ent->enemy->client->playerTeam != self->client->playerTeam )
+			{//the ent's enemy is either a normal ent or is a player/NPC that is not on my team
+				return qtrue;
+			}
+		}
+	}
+
+	return qfalse;
+}
+
+void G_AttackDelay( gentity_t *self, gentity_t *enemy )
+{
+	if ( enemy && self->client && self->NPC )
+	{//delay their attack based on how far away they're facing from enemy
+		vec3_t		fwd, dir;
+		int			attDelay;
+
+		VectorSubtract( self->client->renderInfo.eyePoint, enemy->r.currentOrigin, dir );//purposely backwards
+		VectorNormalize( dir );
+		AngleVectors( self->client->renderInfo.eyeAngles, fwd, NULL, NULL );
+		//dir[2] = fwd[2] = 0;//ignore z diff?
+		
+		attDelay = (4-g_spskill.integer)*500;//initial: from 1000ms delay on hard to 2000ms delay on easy
+		if ( self->client->playerTeam == NPCTEAM_PLAYER )
+		{//invert
+			attDelay = 2000-attDelay;
+		}
+		attDelay += floor( (DotProduct( fwd, dir )+1.0f) * 2000.0f );//add up to 4000ms delay if they're facing away
+
+		//FIXME: should distance matter, too?
+
+		//Now modify the delay based on NPC_class, weapon, and team
+		//NOTE: attDelay should be somewhere between 1000 to 6000 milliseconds
+		switch ( self->client->NPC_class )
+		{
+		case CLASS_IMPERIAL://they give orders and hang back
+			attDelay += Q_irand( 500, 1500 );
+			break;
+		case CLASS_STORMTROOPER://stormtroopers shoot sooner
+			if ( self->NPC->rank >= RANK_LT )
+			{//officers shoot even sooner
+				attDelay -= Q_irand( 500, 1500 );
+			}
+			else
+			{//normal stormtroopers don't have as fast reflexes as officers
+				attDelay -= Q_irand( 0, 1000 );
+			}
+			break;
+		case CLASS_SWAMPTROOPER://shoot very quickly?  What about guys in water?
+			attDelay -= Q_irand( 1000, 2000 );
+			break;
+		case CLASS_IMPWORKER://they panic, don't fire right away
+			attDelay += Q_irand( 1000, 2500 );
+			break;
+		case CLASS_TRANDOSHAN:
+			attDelay -= Q_irand( 500, 1500 );
+			break;
+		case CLASS_JAN:				
+		case CLASS_LANDO:			
+		case CLASS_PRISONER:
+		case CLASS_REBEL:
+			attDelay -= Q_irand( 500, 1500 );
+			break;
+		case CLASS_GALAKMECH:	
+		case CLASS_ATST:		
+			attDelay -= Q_irand( 1000, 2000 );
+			break;
+		case CLASS_REELO:
+		case CLASS_UGNAUGHT:
+		case CLASS_JAWA:
+			return;
+			break;
+		case CLASS_MINEMONSTER:
+		case CLASS_MURJJ:
+			return;
+			break;
+		case CLASS_INTERROGATOR:
+		case CLASS_PROBE:		
+		case CLASS_MARK1:		
+		case CLASS_MARK2:		
+		case CLASS_SENTRY:		
+			return;
+			break;
+		case CLASS_REMOTE:
+		case CLASS_SEEKER:
+			return;
+			break;
+		/*
+		case CLASS_GRAN:
+		case CLASS_RODIAN:
+		case CLASS_WEEQUAY:
+			break;
+		case CLASS_JEDI:				
+		case CLASS_SHADOWTROOPER:
+		case CLASS_TAVION:
+		case CLASS_REBORN:
+		case CLASS_LUKE:				
+		case CLASS_DESANN:			
+			break;
+		*/
+		}
+
+		switch ( self->s.weapon )
+		{
+		case WP_NONE:
+		case WP_SABER:
+			return;
+			break;
+		case WP_BRYAR_PISTOL:
+			break;
+		case WP_BLASTER:
+			if ( self->NPC->scriptFlags & SCF_ALT_FIRE )
+			{//rapid-fire blasters
+				attDelay += Q_irand( 0, 500 );
+			}
+			else
+			{//regular blaster
+				attDelay -= Q_irand( 0, 500 );
+			}
+			break;
+		case WP_BOWCASTER:
+			attDelay += Q_irand( 0, 500 );
+			break;
+		case WP_REPEATER:
+			if ( !(self->NPC->scriptFlags&SCF_ALT_FIRE) )
+			{//rapid-fire blasters
+				attDelay += Q_irand( 0, 500 );
+			}
+			break;
+		case WP_FLECHETTE:
+			attDelay += Q_irand( 500, 1500 );
+			break;
+		case WP_ROCKET_LAUNCHER:
+			attDelay += Q_irand( 500, 1500 );
+			break;
+//		case WP_BLASTER_PISTOL:	// apparently some enemy only version of the blaster
+//			attDelay -= Q_irand( 500, 1500 );
+//			break;
+			//rwwFIXMEFIXME: Have this weapon for NPCs?
+		case WP_DISRUPTOR://sniper's don't delay?
+			return;
+			break;
+		case WP_THERMAL://grenade-throwing has a built-in delay
+			return;
+			break;
+		case WP_STUN_BATON:			// Any ol' melee attack
+			return;
+			break;
+		case WP_EMPLACED_GUN:
+			return;
+			break;
+		case WP_TURRET:			// turret guns 
+			return;
+			break;
+//		case WP_BOT_LASER:		// Probe droid	- Laser blast
+//			return; //rwwFIXMEFIXME: Have this weapon for NPCs?
+			break;
+		/*
+		case WP_DEMP2:
+			break;
+		case WP_TRIP_MINE:
+			break;
+		case WP_DET_PACK:
+			break;
+		case WP_STUN_BATON:
+			break;
+		case WP_ATST_MAIN:
+			break;
+		case WP_ATST_SIDE:
+			break;
+		case WP_TIE_FIGHTER:
+			break;
+		case WP_RAPID_FIRE_CONC:
+			break;
+		*/
+		}
+
+		if ( self->client->playerTeam == NPCTEAM_PLAYER )
+		{//clamp it
+			if ( attDelay > 2000 )
+			{
+				attDelay = 2000;
+			}
+		}
+
+		//don't shoot right away
+		if ( attDelay > 4000+((2-g_spskill.integer)*3000) )
+		{
+			attDelay = 4000+((2-g_spskill.integer)*3000);
+		}
+		TIMER_Set( self, "attackDelay", attDelay );//Q_irand( 1500, 4500 ) );
+		//don't move right away either
+		if ( attDelay > 4000 )
+		{
+			attDelay = 4000 - Q_irand(500, 1500);
+		}
+		else
+		{
+			attDelay -= Q_irand(500, 1500);
+		}
+
+		TIMER_Set( self, "roamTime", attDelay );//was Q_irand( 1000, 3500 );
+	}
+}
+
+void G_ForceSaberOn(gentity_t *ent)
+{
+	if (ent->client->ps.saberInFlight)
+	{ //alright, can't turn it on now in any case, so forget it.
+		return;
+	}
+
+	if (!ent->client->ps.saberHolstered)
+	{ //it's already on!
+		return;
+	}
+
+	if (ent->client->ps.weapon != WP_SABER)
+	{ //This probably should never happen. But if it does we'll just return without complaining.
+		return;
+	}
+
+	//Well then, turn it on.
+	ent->client->ps.saberHolstered = 0;
+
+	if (ent->client->saber[0].soundOn)
+	{
+		G_Sound(ent, CHAN_AUTO, ent->client->saber[0].soundOn);
+	}
+	if (ent->client->saber[1].soundOn)
+	{
+		G_Sound(ent, CHAN_AUTO, ent->client->saber[1].soundOn);
+	}
+}
+
+
+/*
+-------------------------
+G_SetEnemy
+-------------------------
+*/
+void G_AimSet( gentity_t *self, int aim );
+void G_SetEnemy( gentity_t *self, gentity_t *enemy )
+{
+	int	event = 0;
+	
+	//Must be valid
+	if ( enemy == NULL )
+		return;
+
+	//Must be valid
+	if ( enemy->inuse == 0 )
+	{
+		return;
+	}
+
+	//Don't take the enemy if in notarget
+	if ( enemy->flags & FL_NOTARGET )
+		return;
+
+	if ( !self->NPC )
+	{
+		self->enemy = enemy;
+		return;
+	}
+
+	if ( self->NPC->confusionTime > level.time )
+	{//can't pick up enemies if confused
+		return;
+	}
+
+#ifdef _DEBUG
+	if ( self->s.number )
+	{
+		assert( enemy != self );
+	}
+#endif// _DEBUG
+	
+//	if ( enemy->client && enemy->client->playerTeam == TEAM_DISGUISE )
+//	{//unmask the player
+//		enemy->client->playerTeam = TEAM_PLAYER;
+//	}
+	
+	if ( self->client && self->NPC && enemy->client && enemy->client->playerTeam == self->client->playerTeam )
+	{//Probably a damn script!
+		if ( self->NPC->charmedTime > level.time )
+		{//Probably a damn script!
+			return;
+		}
+	}
+
+	if ( self->NPC && self->client && self->client->ps.weapon == WP_SABER )
+	{
+		//when get new enemy, set a base aggression based on what that enemy is using, how far they are, etc.
+		NPC_Jedi_RateNewEnemy( self, enemy );
+	}
+
+	//NOTE: this is not necessarily true!
+	//self->NPC->enemyLastSeenTime = level.time;
+
+	if ( self->enemy == NULL )
+	{
+		//TEMP HACK: turn on our saber
+		if ( self->health > 0 )
+		{
+			G_ForceSaberOn(self);
+		}
+
+		//FIXME: Have to do this to prevent alert cascading
+		G_ClearEnemy( self );
+		self->enemy = enemy;
+
+		//Special case- if player is being hunted by his own people, set their enemy team correctly
+		if ( self->client->playerTeam == NPCTEAM_PLAYER && enemy->s.number == 0 )
+		{
+			self->client->enemyTeam = NPCTEAM_PLAYER;
+		}
+
+		//If have an anger script, run that instead of yelling
+		if( G_ActivateBehavior( self, BSET_ANGER ) )
+		{
+		}
+		else if ( self->client && enemy->client && self->client->playerTeam != enemy->client->playerTeam )
+		{
+			//FIXME: Use anger when entire team has no enemy.
+			//		 Basically, you're first one to notice enemies
+			//if ( self->forcePushTime < level.time ) // not currently being pushed
+			if (1) //rwwFIXMEFIXME: Set forcePushTime
+			{
+				if ( !G_TeamEnemy( self ) )
+				{//team did not have an enemy previously
+					event = Q_irand(EV_ANGER1, EV_ANGER3);
+				}
+			}
+			
+			if ( event )
+			{//yell
+				G_AddVoiceEvent( self, event, 2000 );
+			}
+		}
+		
+		if ( self->s.weapon == WP_BLASTER || self->s.weapon == WP_REPEATER ||
+			self->s.weapon == WP_THERMAL /*|| self->s.weapon == WP_BLASTER_PISTOL */ //rwwFIXMEFIXME: Blaster pistol useable by npcs?
+			|| self->s.weapon == WP_BOWCASTER )
+		{//Hmm, how about sniper and bowcaster?
+			//When first get mad, aim is bad
+			//Hmm, base on game difficulty, too?  Rank?
+			if ( self->client->playerTeam == NPCTEAM_PLAYER )
+			{
+				G_AimSet( self, Q_irand( self->NPC->stats.aim - (5*(g_spskill.integer)), self->NPC->stats.aim - g_spskill.integer ) );
+			}
+			else
+			{
+				int minErr = 3;
+				int maxErr = 12;
+				if ( self->client->NPC_class == CLASS_IMPWORKER )
+				{
+					minErr = 15;
+					maxErr = 30;
+				}
+				else if ( self->client->NPC_class == CLASS_STORMTROOPER && self->NPC && self->NPC->rank <= RANK_CREWMAN )
+				{
+					minErr = 5;
+					maxErr = 15;
+				}
+
+				G_AimSet( self, Q_irand( self->NPC->stats.aim - (maxErr*(3-g_spskill.integer)), self->NPC->stats.aim - (minErr*(3-g_spskill.integer)) ) );
+			}
+		}
+		
+		//Alert anyone else in the area
+		if ( Q_stricmp( "desperado", self->NPC_type ) != 0 && Q_stricmp( "paladin", self->NPC_type ) != 0 )
+		{//special holodeck enemies exception
+			if ( self->client->ps.fd.forceGripBeingGripped < level.time )
+			{//gripped people can't call for help
+				G_AngerAlert( self );
+			}
+		}
+
+		//Stormtroopers don't fire right away!
+		G_AttackDelay( self, enemy );
+
+		//rwwFIXMEFIXME: Deal with this some other way.
+		/*
+		//FIXME: this is a disgusting hack that is supposed to make the Imperials start with their weapon holstered- need a better way
+		if ( self->client->ps.weapon == WP_NONE && !Q_strncmp( self->NPC_type, "imp", 3 ) && !(self->NPC->scriptFlags & SCF_FORCED_MARCH)  )
+		{
+			if ( self->client->ps.stats[STAT_WEAPONS] & ( 1 << WP_BLASTER ) )
+			{
+				ChangeWeapon( self, WP_BLASTER );
+				self->client->ps.weapon = WP_BLASTER;
+				self->client->ps.weaponstate = WEAPON_READY;
+				G_CreateG2AttachedWeaponModel( self, weaponData[WP_BLASTER].weaponMdl, self->handRBolt, 0 );
+			}
+			else if ( self->client->ps.stats[STAT_WEAPONS] & ( 1 << WP_BLASTER_PISTOL ) )
+			{
+				ChangeWeapon( self, WP_BLASTER_PISTOL );
+				self->client->ps.weapon = WP_BLASTER_PISTOL;
+				self->client->ps.weaponstate = WEAPON_READY;
+				G_CreateG2AttachedWeaponModel( self, weaponData[WP_BLASTER_PISTOL].weaponMdl, self->handRBolt, 0 );
+			}
+		}
+		*/
+		return;
+	}
+	
+	//Otherwise, just picking up another enemy
+
+	if ( event )
+	{
+		G_AddVoiceEvent( self, event, 2000 );
+	}
+
+	//Take the enemy
+	G_ClearEnemy(self);
+	self->enemy = enemy;
+}
+
+/*
+int ChooseBestWeapon( void ) 
+{
+	int		n;
+	int		weapon;
+
+	// check weapons in the NPC's weapon preference order
+	for ( n = 0; n < MAX_WEAPONS; n++ ) 
+	{
+		weapon = NPCInfo->weaponOrder[n];
+
+		if ( weapon == WP_NONE ) 
+		{
+			break;
+		}
+
+		if ( !HaveWeapon( weapon ) ) 
+		{
+			continue;
+		}
+
+		if ( client->ps.ammo[weaponData[weapon].ammoIndex] ) 
+		{
+			return weapon;
+		}
+	}
+
+	// check weapons serially (mainly in case a weapon is not on the NPC's list)
+	for ( weapon = 1; weapon < WP_NUM_WEAPONS; weapon++ ) 
+	{
+		if ( !HaveWeapon( weapon ) ) 
+		{
+			continue;
+		}
+
+		if ( client->ps.ammo[weaponData[weapon].ammoIndex] ) 
+		{
+			return weapon;
+		}
+	}
+
+	return client->ps.weapon;
+}
+*/
+
+void ChangeWeapon( gentity_t *ent, int newWeapon ) 
+{
+	if ( !ent || !ent->client || !ent->NPC )
+	{
+		return;
+	}
+
+	ent->client->ps.weapon = newWeapon;
+	ent->NPC->shotTime = 0;
+	ent->NPC->burstCount = 0;
+	ent->NPC->attackHold = 0;
+	ent->NPC->currentAmmo = ent->client->ps.ammo[weaponData[newWeapon].ammoIndex];
+
+	switch ( newWeapon ) 
+	{
+	case WP_BRYAR_PISTOL://prifle
+		ent->NPC->aiFlags &= ~NPCAI_BURST_WEAPON;
+		ent->NPC->burstSpacing = 1000;//attackdebounce
+		break;
+
+		/*
+	case WP_BLASTER_PISTOL:
+		ent->NPC->aiFlags &= ~NPCAI_BURST_WEAPON;
+	//	ent->NPC->burstSpacing = 1000;//attackdebounce
+		if ( g_spskill.integer == 0 )
+			ent->NPC->burstSpacing = 1000;//attack debounce
+		else if ( g_spskill.integer == 1 )
+			ent->NPC->burstSpacing = 750;//attack debounce
+		else 
+			ent->NPC->burstSpacing = 500;//attack debounce
+		break;
+		*/
+		//rwwFIXMEFIXME: support WP_BLASTER_PISTOL and WP_BOT_LASER
+
+		/*
+	case WP_BOT_LASER://probe attack
+		ent->NPC->aiFlags &= ~NPCAI_BURST_WEAPON;
+	//	ent->NPC->burstSpacing = 600;//attackdebounce
+		if ( g_spskill.integer == 0 )
+			ent->NPC->burstSpacing = 600;//attack debounce
+		else if ( g_spskill.integer == 1 )
+			ent->NPC->burstSpacing = 400;//attack debounce
+		else 
+			ent->NPC->burstSpacing = 200;//attack debounce
+		break;
+		*/
+
+	case WP_SABER:
+		ent->NPC->aiFlags &= ~NPCAI_BURST_WEAPON;
+		ent->NPC->burstSpacing = 0;//attackdebounce
+		break;
+
+	case WP_DISRUPTOR:
+		ent->NPC->aiFlags &= ~NPCAI_BURST_WEAPON;
+		if ( ent->NPC->scriptFlags & SCF_ALT_FIRE )
+		{
+			switch( g_spskill.integer )
+			{
+			case 0:
+				ent->NPC->burstSpacing = 2500;//attackdebounce
+				break;
+			case 1:
+				ent->NPC->burstSpacing = 2000;//attackdebounce
+				break;
+			case 2:
+				ent->NPC->burstSpacing = 1500;//attackdebounce
+				break;
+			}
+		}
+		else
+		{
+			ent->NPC->burstSpacing = 1000;//attackdebounce
+		}
+		break;
+
+	case WP_BOWCASTER:
+		ent->NPC->aiFlags &= ~NPCAI_BURST_WEAPON;
+	//	ent->NPC->burstSpacing = 1000;//attackdebounce
+		if ( g_spskill.integer == 0 )
+			ent->NPC->burstSpacing = 1000;//attack debounce
+		else if ( g_spskill.integer == 1 )
+			ent->NPC->burstSpacing = 750;//attack debounce
+		else 
+			ent->NPC->burstSpacing = 500;//attack debounce
+		break;
+
+	case WP_REPEATER:
+		if ( ent->NPC->scriptFlags & SCF_ALT_FIRE )
+		{
+			ent->NPC->aiFlags &= ~NPCAI_BURST_WEAPON;
+			ent->NPC->burstSpacing = 2000;//attackdebounce
+		}
+		else
+		{
+			ent->NPC->aiFlags |= NPCAI_BURST_WEAPON;
+			ent->NPC->burstMin = 3;
+			ent->NPC->burstMean = 6;
+			ent->NPC->burstMax = 10;
+			if ( g_spskill.integer == 0 )
+				ent->NPC->burstSpacing = 1500;//attack debounce
+			else if ( g_spskill.integer == 1 )
+				ent->NPC->burstSpacing = 1000;//attack debounce
+			else 
+				ent->NPC->burstSpacing = 500;//attack debounce
+		}
+		break;
+
+	case WP_DEMP2:
+		ent->NPC->aiFlags &= ~NPCAI_BURST_WEAPON;
+		ent->NPC->burstSpacing = 1000;//attackdebounce
+		break;
+
+	case WP_FLECHETTE:
+		ent->NPC->aiFlags &= ~NPCAI_BURST_WEAPON;
+		if ( ent->NPC->scriptFlags & SCF_ALT_FIRE )
+		{
+			ent->NPC->burstSpacing = 2000;//attackdebounce
+		}
+		else
+		{
+			ent->NPC->burstSpacing = 1000;//attackdebounce
+		}
+		break;
+
+	case WP_ROCKET_LAUNCHER:
+		ent->NPC->aiFlags &= ~NPCAI_BURST_WEAPON;
+	//	ent->NPC->burstSpacing = 2500;//attackdebounce
+		if ( g_spskill.integer == 0 )
+			ent->NPC->burstSpacing = 2500;//attack debounce
+		else if ( g_spskill.integer == 1 )
+			ent->NPC->burstSpacing = 2000;//attack debounce
+		else 
+			ent->NPC->burstSpacing = 1500;//attack debounce
+		break;
+
+	case WP_THERMAL:
+		ent->NPC->aiFlags &= ~NPCAI_BURST_WEAPON;
+	//	ent->NPC->burstSpacing = 3000;//attackdebounce
+		if ( g_spskill.integer == 0 )
+			ent->NPC->burstSpacing = 3000;//attack debounce
+		else if ( g_spskill.integer == 1 )
+			ent->NPC->burstSpacing = 2500;//attack debounce
+		else 
+			ent->NPC->burstSpacing = 2000;//attack debounce
+		break;
+
+	/*
+	case WP_SABER:
+		ent->NPC->aiFlags |= NPCAI_BURST_WEAPON;
+		ent->NPC->burstMin = 5;//0.5 sec
+		ent->NPC->burstMean = 10;//1 second
+		ent->NPC->burstMax = 20;//3 seconds
+		ent->NPC->burstSpacing = 2000;//2 seconds
+		ent->NPC->attackHold = 1000;//Hold attack button for a 1-second burst
+		break;
+	
+	case WP_TRICORDER:
+		ent->NPC->aiFlags |= NPCAI_BURST_WEAPON;
+		ent->NPC->burstMin = 5;
+		ent->NPC->burstMean = 10;
+		ent->NPC->burstMax = 30;
+		ent->NPC->burstSpacing = 1000;
+		break;
+	*/
+
+	case WP_BLASTER:
+		if ( ent->NPC->scriptFlags & SCF_ALT_FIRE )
+		{
+			ent->NPC->aiFlags |= NPCAI_BURST_WEAPON;
+			ent->NPC->burstMin = 3;
+			ent->NPC->burstMean = 3;
+			ent->NPC->burstMax = 3;
+			if ( g_spskill.integer == 0 )
+				ent->NPC->burstSpacing = 1500;//attack debounce
+			else if ( g_spskill.integer == 1 )
+				ent->NPC->burstSpacing = 1000;//attack debounce
+			else 
+				ent->NPC->burstSpacing = 500;//attack debounce
+		}
+		else
+		{
+			ent->NPC->aiFlags &= ~NPCAI_BURST_WEAPON;
+			if ( g_spskill.integer == 0 )
+				ent->NPC->burstSpacing = 1000;//attack debounce
+			else if ( g_spskill.integer == 1 )
+				ent->NPC->burstSpacing = 750;//attack debounce
+			else 
+				ent->NPC->burstSpacing = 500;//attack debounce
+		//	ent->NPC->burstSpacing = 1000;//attackdebounce
+		}
+		break;
+
+	case WP_STUN_BATON:
+		ent->NPC->aiFlags &= ~NPCAI_BURST_WEAPON;
+		ent->NPC->burstSpacing = 1000;//attackdebounce
+		break;
+
+		/*
+	case WP_ATST_MAIN:
+	case WP_ATST_SIDE:
+		ent->NPC->aiFlags &= ~NPCAI_BURST_WEAPON;
+	//	ent->NPC->burstSpacing = 1000;//attackdebounce
+			if ( g_spskill.integer == 0 )
+				ent->NPC->burstSpacing = 1000;//attack debounce
+			else if ( g_spskill.integer == 1 )
+				ent->NPC->burstSpacing = 750;//attack debounce
+			else 
+				ent->NPC->burstSpacing = 500;//attack debounce
+		break;
+		*/
+		//rwwFIXMEFIXME: support for atst weaps
+
+	case WP_EMPLACED_GUN:
+		//FIXME: give some designer-control over this?
+		if ( ent->client && ent->client->NPC_class == CLASS_REELO )
+		{
+			ent->NPC->aiFlags &= ~NPCAI_BURST_WEAPON;
+			ent->NPC->burstSpacing = 1000;//attack debounce
+	//		if ( g_spskill.integer == 0 )
+	//			ent->NPC->burstSpacing = 300;//attack debounce
+	//		else if ( g_spskill.integer == 1 )
+	//			ent->NPC->burstSpacing = 200;//attack debounce
+	//		else 
+	//			ent->NPC->burstSpacing = 100;//attack debounce
+		}
+		else
+		{
+			ent->NPC->aiFlags |= NPCAI_BURST_WEAPON;
+			ent->NPC->burstMin = 2; // 3 shots, really
+			ent->NPC->burstMean = 2;
+			ent->NPC->burstMax = 2;
+
+			if ( ent->parent ) // if we have an owner, it should be the chair at this point...so query the chair for its shot debounce times, etc.
+			{
+				if ( g_spskill.integer == 0 )
+				{
+					ent->NPC->burstSpacing = ent->parent->wait + 400;//attack debounce
+					ent->NPC->burstMin = ent->NPC->burstMax = 1; // two shots
+				}
+				else if ( g_spskill.integer == 1 )
+				{
+					ent->NPC->burstSpacing = ent->parent->wait + 200;//attack debounce
+				}
+				else 
+				{
+					ent->NPC->burstSpacing = ent->parent->wait;//attack debounce
+				}
+			}
+			else
+			{
+				if ( g_spskill.integer == 0 )
+				{
+					ent->NPC->burstSpacing = 1200;//attack debounce
+					ent->NPC->burstMin = ent->NPC->burstMax = 1; // two shots
+				}
+				else if ( g_spskill.integer == 1 )
+				{
+					ent->NPC->burstSpacing = 1000;//attack debounce
+				}
+				else 
+				{
+					ent->NPC->burstSpacing = 800;//attack debounce
+				}
+			}
+		}
+		break;
+
+	default:
+		ent->NPC->aiFlags &= ~NPCAI_BURST_WEAPON;
+		break;
+	}
+}
+
+void NPC_ChangeWeapon( int newWeapon ) 
+{
+	/*
+	qboolean	changing = qfalse;
+	if ( newWeapon != NPC->client->ps.weapon )
+	{
+		changing = qtrue;
+	}
+	if ( changing && NPC->weaponModel[0] > 9 )
+	{
+		trap_G2API_RemoveGhoul2Model( NPC->ghoul2, NPC->weaponModel[0] );
+	}
+	ChangeWeapon( NPC, newWeapon );
+	if ( changing && NPC->client->ps.weapon != WP_NONE )
+	{
+		if ( NPC->client->ps.weapon == WP_SABER )
+		{
+			G_CreateG2AttachedWeaponModel( NPC, NPC->client->ps.saber[0].model, NPC->handRBolt, 0 );
+			if ( NPC->client->ps.dualSabers )
+			{
+				G_CreateG2AttachedWeaponModel( NPC, NPC->client->ps.saber[1].model, NPC->handLBolt, 0 );
+			}
+		}
+		else
+		{
+			G_CreateG2AttachedWeaponModel( NPC, weaponData[NPC->client->ps.weapon].weaponMdl, NPC->handRBolt, 0 );
+		}
+	}*/
+	//rwwFIXMEFIXME: Change the same way as players, all this stuff is just crazy.
+}
+/*
+void NPC_ApplyWeaponFireDelay(void)
+How long, if at all, in msec the actual fire should delay from the time the attack was started
+*/
+void NPC_ApplyWeaponFireDelay(void)
+{	
+	if ( NPC->attackDebounceTime > level.time )
+	{//Just fired, if attacking again, must be a burst fire, so don't add delay
+		//NOTE: Borg AI uses attackDebounceTime "incorrectly", so this will always return for them!
+		return;
+	}
+	
+	switch(client->ps.weapon)
+	{
+		/*
+	case WP_BOT_LASER:
+		NPCInfo->burstCount = 0;
+		client->ps.weaponTime = 500;
+		break;
+		*/ //rwwFIXMEFIXME: support for this
+
+	case WP_THERMAL:
+		if ( client->ps.clientNum )
+		{//NPCs delay... 
+			//FIXME: player should, too, but would feel weird in 1st person, even though it
+			//			would look right in 3rd person.  Really should have a wind-up anim
+			//			for player as he holds down the fire button to throw, then play
+			//			the actual throw when he lets go...
+			client->ps.weaponTime = 700;
+		}
+		break;
+
+	case WP_STUN_BATON:
+		//if ( !PM_DroidMelee( client->NPC_class ) )
+		if (1) //rwwFIXMEFIXME: ...
+		{//FIXME: should be unique per melee anim
+			client->ps.weaponTime = 300;
+		}
+		break;
+
+	default:
+		client->ps.weaponTime = 0;
+		break;
+	}
+}
+
+/*
+-------------------------
+ShootThink
+-------------------------
+*/
+void ShootThink( void ) 
+{
+	int			delay;
+
+	ucmd.buttons &= ~BUTTON_ATTACK;
+/*
+	if ( enemyVisibility != VIS_SHOOT) 
+		return;
+*/
+
+	if ( client->ps.weapon == WP_NONE )
+		return;
+
+	if ( client->ps.weaponstate != WEAPON_READY && client->ps.weaponstate != WEAPON_FIRING && client->ps.weaponstate != WEAPON_IDLE) 
+		return;
+
+	if ( level.time < NPCInfo->shotTime ) 
+	{
+		return;
+	}
+
+	ucmd.buttons |= BUTTON_ATTACK;
+
+	NPCInfo->currentAmmo = client->ps.ammo[weaponData[client->ps.weapon].ammoIndex];	// checkme
+
+	NPC_ApplyWeaponFireDelay();
+
+	if ( NPCInfo->aiFlags & NPCAI_BURST_WEAPON ) 
+	{
+		if ( !NPCInfo->burstCount ) 
+		{
+			NPCInfo->burstCount = Q_irand( NPCInfo->burstMin, NPCInfo->burstMax );
+			/*
+			NPCInfo->burstCount = erandom( NPCInfo->burstMean );
+			if ( NPCInfo->burstCount < NPCInfo->burstMin ) 
+			{
+				NPCInfo->burstCount = NPCInfo->burstMin;
+			}
+			else if ( NPCInfo->burstCount > NPCInfo->burstMax ) 
+			{
+				NPCInfo->burstCount = NPCInfo->burstMax;
+			}
+			*/
+			delay = 0;
+		}
+		else 
+		{
+			NPCInfo->burstCount--;
+			if ( NPCInfo->burstCount == 0 ) 
+			{
+				delay = NPCInfo->burstSpacing;
+			}
+			else 
+			{
+				delay = 0;
+			}
+		}
+
+		if ( !delay )
+		{
+			// HACK: dirty little emplaced bits, but is done because it would otherwise require some sort of new variable...
+			if ( client->ps.weapon == WP_EMPLACED_GUN )
+			{
+				if ( NPC->parent ) // try and get the debounce values from the chair if we can
+				{
+					if ( g_spskill.integer == 0 )
+					{
+						delay = NPC->parent->random + 150;
+					}
+					else if ( g_spskill.integer == 1 )
+					{
+						delay = NPC->parent->random + 100;
+					}
+					else 
+					{
+						delay = NPC->parent->random;
+					}
+				}
+				else
+				{
+					if ( g_spskill.integer == 0 )
+					{
+						delay = 350;
+					}
+					else if ( g_spskill.integer == 1 )
+					{
+						delay = 300;
+					}
+					else 
+					{
+						delay = 200;
+					}
+				}
+			}
+		}
+	}
+	else 
+	{
+		delay = NPCInfo->burstSpacing;
+	}
+
+	NPCInfo->shotTime = level.time + delay;
+	NPC->attackDebounceTime = level.time + NPC_AttackDebounceForWeapon();
+}
+
+/*
+static void WeaponThink( qboolean inCombat ) 
+FIXME makes this so there's a delay from event that caused us to check to actually doing it
+
+Added: hacks for Borg
+*/
+void WeaponThink( qboolean inCombat ) 
+{
+	if ( client->ps.weaponstate == WEAPON_RAISING || client->ps.weaponstate == WEAPON_DROPPING ) 
+	{
+		ucmd.weapon = client->ps.weapon;
+		ucmd.buttons &= ~BUTTON_ATTACK;
+		return;
+	}
+
+//MCG - Begin
+	//For now, no-one runs out of ammo	
+	if(NPC->client->ps.ammo[ weaponData[client->ps.weapon].ammoIndex ] < 10)	// checkme	
+//	if(NPC->client->ps.ammo[ client->ps.weapon ] < 10)
+	{
+		Add_Ammo (NPC, client->ps.weapon, 100);
+	}
+
+	/*if ( NPC->playerTeam == TEAM_BORG )
+	{//HACK!!!
+		if(!(NPC->client->ps.stats[STAT_WEAPONS] & ( 1 << WP_BORG_WEAPON )))
+			NPC->client->ps.stats[STAT_WEAPONS] |= ( 1 << WP_BORG_WEAPON );
+
+		if ( client->ps.weapon != WP_BORG_WEAPON ) 
+		{
+			NPC_ChangeWeapon( WP_BORG_WEAPON );
+			Add_Ammo (NPC, client->ps.weapon, 10);
+			NPCInfo->currentAmmo = client->ps.ammo[client->ps.weapon];
+		}
+	}
+	else */
+	
+	/*if ( NPC->client->playerTeam == TEAM_SCAVENGERS )
+	{//HACK!!!
+		if(!(NPC->client->ps.stats[STAT_WEAPONS] & ( 1 << WP_BLASTER )))
+			NPC->client->ps.stats[STAT_WEAPONS] |= ( 1 << WP_BLASTER );
+
+		if ( client->ps.weapon != WP_BLASTER )
+			 
+		{
+			NPC_ChangeWeapon( WP_BLASTER );
+			Add_Ammo (NPC, client->ps.weapon, 10);
+//			NPCInfo->currentAmmo = client->ps.ammo[client->ps.weapon];
+			NPCInfo->currentAmmo = client->ps.ammo[weaponData[client->ps.weapon].ammoIndex];	// checkme
+		}
+	}
+	else*/
+//MCG - End
+	{
+		// if the gun in our hands is out of ammo, we need to change
+		/*if ( client->ps.ammo[client->ps.weapon] == 0 ) 
+		{
+			NPCInfo->aiFlags |= NPCAI_CHECK_WEAPON;
+		}
+
+		if ( NPCInfo->aiFlags & NPCAI_CHECK_WEAPON ) 
+		{
+			NPCInfo->aiFlags &= ~NPCAI_CHECK_WEAPON;
+			bestWeapon = ChooseBestWeapon();
+			if ( bestWeapon != client->ps.weapon ) 
+			{
+				NPC_ChangeWeapon( bestWeapon );
+			}
+		}*/
+	}
+
+	ucmd.weapon = client->ps.weapon;
+	ShootThink();
+}
+
+/*
+HaveWeapon
+*/
+
+qboolean HaveWeapon( int weapon ) 
+{
+	return ( client->ps.stats[STAT_WEAPONS] & ( 1 << weapon ) );
+}
+
+qboolean EntIsGlass (gentity_t *check)
+{
+	if(check->classname &&
+		!Q_stricmp("func_breakable", check->classname) &&
+		check->count == 1 && check->health <= 100)
+	{
+		return qtrue;
+	}
+
+	return qfalse;
+}
+
+qboolean ShotThroughGlass (trace_t *tr, gentity_t *target, vec3_t spot, int mask)
+{
+	gentity_t	*hit = &g_entities[ tr->entityNum ];
+	if(hit != target && EntIsGlass(hit))
+	{//ok to shoot through breakable glass
+		int			skip = hit->s.number;
+		vec3_t		muzzle;
+
+		VectorCopy(tr->endpos, muzzle);
+		trap_Trace (tr, muzzle, NULL, NULL, spot, skip, mask );
+		return qtrue;
+	}
+
+	return qfalse;
+}
+
+/*
+CanShoot
+determine if NPC can directly target enemy
+
+this function does not check teams, invulnerability, notarget, etc....
+
+Added: If can't shoot center, try head, if not, see if it's close enough to try anyway.
+*/
+qboolean CanShoot ( gentity_t *ent, gentity_t *shooter ) 
+{
+	trace_t		tr;
+	vec3_t		muzzle;
+	vec3_t		spot, diff;
+	gentity_t	*traceEnt;
+
+	CalcEntitySpot( shooter, SPOT_WEAPON, muzzle );
+	CalcEntitySpot( ent, SPOT_ORIGIN, spot );		//FIXME preferred target locations for some weapons (feet for R/L)
+
+	trap_Trace ( &tr, muzzle, NULL, NULL, spot, shooter->s.number, MASK_SHOT );
+	traceEnt = &g_entities[ tr.entityNum ];
+
+	// point blank, baby!
+	if (tr.startsolid && (shooter->NPC) && (shooter->NPC->touchedByPlayer) ) 
+	{
+		traceEnt = shooter->NPC->touchedByPlayer;
+	}
+	
+	if ( ShotThroughGlass( &tr, ent, spot, MASK_SHOT ) )
+	{
+		traceEnt = &g_entities[ tr.entityNum ];
+	}
+
+	// shot is dead on
+	if ( traceEnt == ent ) 
+	{
+		return qtrue;
+	}
+//MCG - Begin
+	else
+	{//ok, can't hit them in center, try their head
+		CalcEntitySpot( ent, SPOT_HEAD, spot );
+		trap_Trace ( &tr, muzzle, NULL, NULL, spot, shooter->s.number, MASK_SHOT );
+		traceEnt = &g_entities[ tr.entityNum ];
+		if ( traceEnt == ent) 
+		{
+			return qtrue;
+		}
+	}
+
+	//Actually, we should just check to fire in dir we're facing and if it's close enough,
+	//and we didn't hit someone on our own team, shoot
+	VectorSubtract(spot, tr.endpos, diff);
+	if(VectorLength(diff) < random() * 32)
+	{
+		return qtrue;
+	}
+//MCG - End
+	// shot would hit a non-client
+	if ( !traceEnt->client ) 
+	{
+		return qfalse;
+	}
+
+	// shot is blocked by another player
+
+	// he's already dead, so go ahead
+	if ( traceEnt->health <= 0 ) 
+	{
+		return qtrue;
+	}
+
+	// don't deliberately shoot a teammate
+	if ( traceEnt->client && ( traceEnt->client->playerTeam == shooter->client->playerTeam ) ) 
+	{
+		return qfalse;
+	}
+
+	// he's just in the wrong place, go ahead
+	return qtrue;
+}
+
+
+/*
+void NPC_CheckPossibleEnemy( gentity_t *other, visibility_t vis ) 
+
+Added: hacks for scripted NPCs
+*/
+void NPC_CheckPossibleEnemy( gentity_t *other, visibility_t vis ) 
+{
+	// is he is already our enemy?
+	if ( other == NPC->enemy ) 
+		return;
+
+	if ( other->flags & FL_NOTARGET ) 
+		return;
+
+	// we already have an enemy and this guy is in our FOV, see if this guy would be better
+	if ( NPC->enemy && vis == VIS_FOV ) 
+	{
+		if ( NPCInfo->enemyLastSeenTime - level.time < 2000 ) 
+		{
+			return;
+		}
+		if ( enemyVisibility == VIS_UNKNOWN ) 
+		{
+			enemyVisibility = NPC_CheckVisibility ( NPC->enemy, CHECK_360|CHECK_FOV );
+		}
+		if ( enemyVisibility == VIS_FOV ) 
+		{
+			return;
+		}
+	}
+
+	if ( !NPC->enemy )
+	{//only take an enemy if you don't have one yet
+		G_SetEnemy( NPC, other );
+	}
+
+	if ( vis == VIS_FOV ) 
+	{
+		NPCInfo->enemyLastSeenTime = level.time;
+		VectorCopy( other->r.currentOrigin, NPCInfo->enemyLastSeenLocation );
+		NPCInfo->enemyLastHeardTime = 0;
+		VectorClear( NPCInfo->enemyLastHeardLocation );
+	} 
+	else 
+	{
+		NPCInfo->enemyLastSeenTime = 0;
+		VectorClear( NPCInfo->enemyLastSeenLocation );
+		NPCInfo->enemyLastHeardTime = level.time;
+		VectorCopy( other->r.currentOrigin, NPCInfo->enemyLastHeardLocation );
+	}
+}
+
+
+//==========================================
+//MCG Added functions:
+//==========================================
+
+/*
+int NPC_AttackDebounceForWeapon (void)
+
+DOES NOT control how fast you can fire
+Only makes you keep your weapon up after you fire
+
+*/
+int NPC_AttackDebounceForWeapon (void)
+{
+	switch ( NPC->client->ps.weapon ) 
+	{
+/*
+	case WP_BLASTER://scav rifle
+		return 1000;
+		break;
+
+	case WP_BRYAR_PISTOL://prifle
+		return 3000;
+		break;
+
+	case WP_SABER:
+		return 100;
+		break;
+	
+
+	case WP_TRICORDER:
+		return 0;//tricorder
+		break;
+*/
+	case WP_SABER:
+		return 0;
+		break;
+
+		/*
+	case WP_BOT_LASER:
+		
+		if ( g_spskill.integer == 0 )
+			return 2000;
+
+		if ( g_spskill.integer == 1 )
+			return 1500;
+
+		return 1000;
+		break;
+		*/
+		//rwwFIXMEFIXME: support
+	default:
+		return NPCInfo->burstSpacing;//was 100 by default
+		break;
+	}
+}
+
+//FIXME: need a mindist for explosive weapons
+float NPC_MaxDistSquaredForWeapon (void)
+{
+	if(NPCInfo->stats.shootDistance > 0)
+	{//overrides default weapon dist
+		return NPCInfo->stats.shootDistance * NPCInfo->stats.shootDistance;
+	}
+
+	switch ( NPC->s.weapon ) 
+	{
+	case WP_BLASTER://scav rifle
+		return 1024 * 1024;//should be shorter?
+		break;
+
+	case WP_BRYAR_PISTOL://prifle
+		return 1024 * 1024;
+		break;
+
+		/*
+	case WP_BLASTER_PISTOL://prifle
+		return 1024 * 1024;
+		break;
+		*/
+
+	case WP_DISRUPTOR://disruptor
+		if ( NPCInfo->scriptFlags & SCF_ALT_FIRE )
+		{
+			return ( 4096 * 4096 );
+		}
+		else
+		{
+			return 1024 * 1024;
+		}
+		break;
+/*
+	case WP_SABER:
+		return 1024 * 1024;
+		break;
+	
+
+	case WP_TRICORDER:
+		return 0;//tricorder
+		break;
+*/
+	case WP_SABER:
+		if ( NPC->client && NPC->client->saber[0].blade[0].lengthMax )
+		{//FIXME: account for whether enemy and I are heading towards each other!
+			return (NPC->client->saber[0].blade[0].lengthMax + NPC->r.maxs[0]*1.5)*(NPC->client->saber[0].blade[0].lengthMax + NPC->r.maxs[0]*1.5);
+		}
+		else
+		{
+			return 48*48;
+		}
+		break;
+
+	default:
+		return 1024 * 1024;//was 0
+		break;
+	}
+}
+
+/*
+-------------------------
+ValidEnemy
+-------------------------
+*/
+
+qboolean ValidEnemy(gentity_t *ent)
+{
+	if ( ent == NULL )
+		return qfalse;
+
+	if ( ent == NPC )
+		return qfalse;
+
+	//if team_free, maybe everyone is an enemy?
+	//if ( !NPC->client->enemyTeam )
+	//	return qfalse;
+
+	if ( !(ent->flags & FL_NOTARGET) )
+	{
+		if( ent->health > 0 )
+		{
+			if( !ent->client )
+			{
+				return qtrue;
+			}
+			else if ( ent->client->sess.sessionTeam == TEAM_SPECTATOR )
+			{//don't go after spectators
+				return qfalse;
+			}
+			else
+			{
+				int entTeam = TEAM_FREE;
+				if ( ent->NPC && ent->client )
+				{
+					entTeam = ent->client->playerTeam;
+				}
+				else if ( ent->client )
+				{
+					if ( ent->client->sess.sessionTeam == TEAM_BLUE )
+					{
+						entTeam = NPCTEAM_PLAYER;
+					}
+					else if ( ent->client->sess.sessionTeam == TEAM_RED )
+					{
+						entTeam = NPCTEAM_ENEMY;
+					}
+					else
+					{
+						entTeam = NPCTEAM_NEUTRAL;
+					}
+				}
+				if( entTeam == NPCTEAM_FREE 
+					|| NPC->client->enemyTeam == NPCTEAM_FREE 
+					|| entTeam == NPC->client->enemyTeam )
+				{
+					if ( entTeam != NPC->client->playerTeam )
+					{
+						return qtrue;
+					}
+				}
+			}
+		}
+	}
+
+	return qfalse;
+}
+
+qboolean NPC_EnemyTooFar(gentity_t *enemy, float dist, qboolean toShoot)
+{
+	vec3_t	vec;
+
+	
+	if ( !toShoot )
+	{//Not trying to actually press fire button with this check
+		if ( NPC->client->ps.weapon == WP_SABER )
+		{//Just have to get to him
+			return qfalse;
+		}
+	}
+	
+
+	if(!dist)
+	{
+		VectorSubtract(NPC->r.currentOrigin, enemy->r.currentOrigin, vec);
+		dist = VectorLengthSquared(vec);
+	}
+
+	if(dist > NPC_MaxDistSquaredForWeapon())
+		return qtrue;
+
+	return qfalse;
+}
+
+/*
+NPC_PickEnemy
+
+Randomly picks a living enemy from the specified team and returns it
+
+FIXME: For now, you MUST specify an enemy team
+
+If you specify choose closest, it will find only the closest enemy
+
+If you specify checkVis, it will return and enemy that is visible
+
+If you specify findPlayersFirst, it will try to find players first
+
+You can mix and match any of those options (example: find closest visible players first)
+
+FIXME: this should go through the snapshot and find the closest enemy
+*/
+gentity_t *NPC_PickEnemy( gentity_t *closestTo, int enemyTeam, qboolean checkVis, qboolean findPlayersFirst, qboolean findClosest )
+{
+	int			num_choices = 0;
+	int			choice[128];//FIXME: need a different way to determine how many choices?
+	gentity_t	*newenemy = NULL;
+	gentity_t	*closestEnemy = NULL;
+	int			entNum;
+	vec3_t		diff;
+	float		relDist;
+	float		bestDist = Q3_INFINITE;
+	qboolean	failed = qfalse;
+	int			visChecks = (CHECK_360|CHECK_FOV|CHECK_VISRANGE);
+	int			minVis = VIS_FOV;
+
+	if ( enemyTeam == NPCTEAM_NEUTRAL )
+	{
+		return NULL;
+	}
+
+	if ( NPCInfo->behaviorState == BS_STAND_AND_SHOOT || 
+		NPCInfo->behaviorState == BS_HUNT_AND_KILL ) 
+	{//Formations guys don't require inFov to pick up a target
+		//These other behavior states are active battle states and should not
+		//use FOV.  FOV checks are for enemies who are patrolling, guarding, etc.
+		visChecks &= ~CHECK_FOV;
+		minVis = VIS_360;
+	}
+
+	if( findPlayersFirst )
+	{//try to find a player first
+		newenemy = &g_entities[0];
+		if( newenemy->client && !(newenemy->flags & FL_NOTARGET) && !(newenemy->s.eFlags & EF_NODRAW))
+		{
+			if( newenemy->health > 0 )
+			{
+				if( NPC_ValidEnemy( newenemy) )//enemyTeam == TEAM_PLAYER || newenemy->client->playerTeam == enemyTeam || ( enemyTeam == TEAM_PLAYER ) )
+				{//FIXME:  check for range and FOV or vis?
+					if( newenemy != NPC->lastEnemy )
+					{//Make sure we're not just going back and forth here
+						if ( trap_InPVS(newenemy->r.currentOrigin, NPC->r.currentOrigin) )
+						{
+							if(NPCInfo->behaviorState == BS_INVESTIGATE ||	NPCInfo->behaviorState == BS_PATROL)
+							{
+								if(!NPC->enemy)
+								{
+									if(!InVisrange(newenemy))
+									{
+										failed = qtrue;
+									}
+									else if(NPC_CheckVisibility ( newenemy, CHECK_360|CHECK_FOV|CHECK_VISRANGE ) != VIS_FOV)
+									{
+										failed = qtrue;
+									}
+								}
+							}
+
+							if ( !failed )
+							{
+								VectorSubtract( closestTo->r.currentOrigin, newenemy->r.currentOrigin, diff );
+								relDist = VectorLengthSquared(diff);
+								if ( newenemy->client->hiddenDist > 0 )
+								{
+									if( relDist > newenemy->client->hiddenDist*newenemy->client->hiddenDist )
+									{
+										//out of hidden range
+										if ( VectorLengthSquared( newenemy->client->hiddenDir ) )
+										{//They're only hidden from a certain direction, check
+											float	dot;
+											VectorNormalize( diff );
+											dot = DotProduct( newenemy->client->hiddenDir, diff ); 
+											if ( dot > 0.5 )
+											{//I'm not looking in the right dir toward them to see them 
+												failed = qtrue;
+											}
+											else
+											{
+												Debug_Printf(&debugNPCAI, DEBUG_LEVEL_INFO, "%s saw %s trying to hide - hiddenDir %s targetDir %s dot %f\n", NPC->targetname, newenemy->targetname, vtos(newenemy->client->hiddenDir), vtos(diff), dot );
+											}
+										}
+										else
+										{
+											failed = qtrue;
+										}
+									}
+									else
+									{
+										Debug_Printf(&debugNPCAI, DEBUG_LEVEL_INFO, "%s saw %s trying to hide - hiddenDist %f\n", NPC->targetname, newenemy->targetname, newenemy->client->hiddenDist );
+									}
+								}
+
+								if(!failed)
+								{
+									if(findClosest)
+									{
+										if(relDist < bestDist)
+										{
+											if(!NPC_EnemyTooFar(newenemy, relDist, qfalse))
+											{
+												if(checkVis)
+												{
+													if( NPC_CheckVisibility ( newenemy, visChecks ) == minVis )
+													{
+														bestDist = relDist;
+														closestEnemy = newenemy;
+													}
+												}
+												else
+												{
+													bestDist = relDist;
+													closestEnemy = newenemy;
+												}
+											}
+										}
+									}
+									else if(!NPC_EnemyTooFar(newenemy, 0, qfalse))
+									{
+										if(checkVis)
+										{
+											if( NPC_CheckVisibility ( newenemy, CHECK_360|CHECK_FOV|CHECK_VISRANGE ) == VIS_FOV )
+											{
+												choice[num_choices++] = newenemy->s.number;
+											}
+										}
+										else
+										{
+											choice[num_choices++] = newenemy->s.number;
+										}
+									}
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+
+	if (findClosest && closestEnemy)
+	{
+		return closestEnemy;
+	}
+
+	if (num_choices)
+	{
+		return &g_entities[ choice[rand() % num_choices] ];
+	}
+
+	/*
+	//FIXME: used to have an option to look *only* for the player... now...?  Still need it?
+	if ( enemyTeam == TEAM_PLAYER )
+	{//couldn't find the player
+		return NULL;
+	}
+	*/
+
+	num_choices = 0;
+	bestDist = Q3_INFINITE;
+	closestEnemy = NULL;
+
+	for ( entNum = 0; entNum < level.num_entities; entNum++ )
+	{
+		newenemy = &g_entities[entNum];
+
+		if ( newenemy != NPC && (newenemy->client /*|| newenemy->svFlags & SVF_NONNPC_ENEMY*/) && !(newenemy->flags & FL_NOTARGET) && !(newenemy->s.eFlags & EF_NODRAW))
+		{
+			if ( newenemy->health > 0 )
+			{
+				if ( (newenemy->client && NPC_ValidEnemy( newenemy))
+					|| (!newenemy->client && newenemy->alliedTeam == enemyTeam) )
+				{//FIXME:  check for range and FOV or vis?
+					if ( NPC->client->playerTeam == NPCTEAM_PLAYER && enemyTeam == NPCTEAM_PLAYER )
+					{//player allies turning on ourselves?  How?
+						if ( newenemy->s.number )
+						{//only turn on the player, not other player allies
+							continue;
+						}
+					}
+
+					if ( newenemy != NPC->lastEnemy )
+					{//Make sure we're not just going back and forth here
+						if(!trap_InPVS(newenemy->r.currentOrigin, NPC->r.currentOrigin))
+						{
+							continue;
+						}
+
+						if ( NPCInfo->behaviorState == BS_INVESTIGATE || NPCInfo->behaviorState == BS_PATROL )
+						{
+							if ( !NPC->enemy )
+							{
+								if ( !InVisrange( newenemy ) )
+								{
+									continue;
+								}
+								else if ( NPC_CheckVisibility ( newenemy, CHECK_360|CHECK_FOV|CHECK_VISRANGE ) != VIS_FOV )
+								{
+									continue;
+								}
+							}
+						}
+
+						VectorSubtract( closestTo->r.currentOrigin, newenemy->r.currentOrigin, diff );
+						relDist = VectorLengthSquared(diff);
+						if ( newenemy->client && newenemy->client->hiddenDist > 0 )
+						{
+							if( relDist > newenemy->client->hiddenDist*newenemy->client->hiddenDist )
+							{
+								//out of hidden range
+								if ( VectorLengthSquared( newenemy->client->hiddenDir ) )
+								{//They're only hidden from a certain direction, check
+									float	dot;
+
+									VectorNormalize( diff );
+									dot = DotProduct( newenemy->client->hiddenDir, diff ); 
+									if ( dot > 0.5 )
+									{//I'm not looking in the right dir toward them to see them 
+										continue;
+									}
+									else
+									{
+										Debug_Printf(&debugNPCAI, DEBUG_LEVEL_INFO, "%s saw %s trying to hide - hiddenDir %s targetDir %s dot %f\n", NPC->targetname, newenemy->targetname, vtos(newenemy->client->hiddenDir), vtos(diff), dot );
+									}
+								}
+								else
+								{
+									continue;
+								}
+							}
+							else
+							{
+								Debug_Printf(&debugNPCAI, DEBUG_LEVEL_INFO, "%s saw %s trying to hide - hiddenDist %f\n", NPC->targetname, newenemy->targetname, newenemy->client->hiddenDist );
+							}
+						}
+
+						if ( findClosest )
+						{
+							if ( relDist < bestDist )
+							{
+								if ( !NPC_EnemyTooFar( newenemy, relDist, qfalse ) )
+								{
+									if ( checkVis )
+									{
+										//FIXME: NPCs need to be able to pick up other NPCs behind them,
+										//but for now, commented out because it was picking up enemies it shouldn't
+										//if ( NPC_CheckVisibility ( newenemy, CHECK_360|CHECK_VISRANGE ) >= VIS_360 )
+										if ( NPC_CheckVisibility ( newenemy, visChecks ) == minVis )
+										{
+											bestDist = relDist;
+											closestEnemy = newenemy;
+										}
+									}
+									else
+									{
+										bestDist = relDist;
+										closestEnemy = newenemy;
+									}
+								}
+							}
+						}
+						else if ( !NPC_EnemyTooFar( newenemy, 0, qfalse ) )
+						{
+							if ( checkVis )
+							{
+								//if( NPC_CheckVisibility ( newenemy, CHECK_360|CHECK_FOV|CHECK_VISRANGE ) == VIS_FOV )
+								if ( NPC_CheckVisibility ( newenemy, CHECK_360|CHECK_VISRANGE ) >= VIS_360 )
+								{
+									choice[num_choices++] = newenemy->s.number;
+								}
+							}
+							else
+							{
+								choice[num_choices++] = newenemy->s.number;
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+
+	
+	if (findClosest)
+	{//FIXME: you can pick up an enemy around a corner this way.
+		return closestEnemy;
+	}
+
+	if (!num_choices)
+	{
+		return NULL;
+	}
+
+	return &g_entities[ choice[rand() % num_choices] ];
+}
+
+/*
+gentity_t *NPC_PickAlly ( void )
+
+  Simply returns closest visible ally
+*/
+
+gentity_t *NPC_PickAlly ( qboolean facingEachOther, float range, qboolean ignoreGroup, qboolean movingOnly )
+{
+	gentity_t	*ally = NULL;
+	gentity_t	*closestAlly = NULL;
+	int			entNum;
+	vec3_t		diff;
+	float		relDist;
+	float		bestDist = range;
+
+	for ( entNum = 0; entNum < level.num_entities; entNum++ )
+	{
+		ally = &g_entities[entNum];
+
+		if ( ally->client )
+		{
+			if ( ally->health > 0 )
+			{
+				if ( ally->client && ( ally->client->playerTeam == NPC->client->playerTeam ||
+					 NPC->client->playerTeam == NPCTEAM_ENEMY ) )// && ally->client->playerTeam == TEAM_DISGUISE ) ) )
+				{//if on same team or if player is disguised as your team
+					if ( ignoreGroup )
+					{
+						if ( ally == NPC->client->leader )
+						{
+							//reject
+							continue;
+						}
+						if ( ally->client && ally->client->leader && ally->client->leader == NPC )
+						{
+							//reject
+							continue;
+						}
+					}
+
+					if(!trap_InPVS(ally->r.currentOrigin, NPC->r.currentOrigin))
+					{
+						continue;
+					}
+
+					if ( movingOnly && ally->client && NPC->client )
+					{//They have to be moving relative to each other
+						if ( !DistanceSquared( ally->client->ps.velocity, NPC->client->ps.velocity ) )
+						{
+							continue;
+						}
+					}
+
+					VectorSubtract( NPC->r.currentOrigin, ally->r.currentOrigin, diff );
+					relDist = VectorNormalize( diff );
+					if ( relDist < bestDist )
+					{
+						if ( facingEachOther )
+						{
+							vec3_t	vf;
+							float	dot;
+
+							AngleVectors( ally->client->ps.viewangles, vf, NULL, NULL );
+							VectorNormalize(vf);
+							dot = DotProduct(diff, vf);
+
+							if ( dot < 0.5 )
+							{//Not facing in dir to me
+								continue;
+							}
+							//He's facing me, am I facing him?
+							AngleVectors( NPC->client->ps.viewangles, vf, NULL, NULL );
+							VectorNormalize(vf);
+							dot = DotProduct(diff, vf);
+
+							if ( dot > -0.5 )
+							{//I'm not facing opposite of dir to me
+								continue;
+							}
+							//I am facing him
+						}
+
+						if ( NPC_CheckVisibility ( ally, CHECK_360|CHECK_VISRANGE ) >= VIS_360 )
+						{
+							bestDist = relDist;
+							closestAlly = ally;
+						}
+					}
+				}
+			}
+		}
+	}
+
+	
+	return closestAlly;
+}
+
+gentity_t *NPC_CheckEnemy( qboolean findNew, qboolean tooFarOk, qboolean setEnemy )
+{
+	qboolean	forcefindNew = qfalse;
+	gentity_t	*closestTo;
+	gentity_t	*newEnemy = NULL;
+	//FIXME: have a "NPCInfo->persistance" we can set to determine how long to try to shoot
+	//someone we can't hit?  Rather than hard-coded 10?
+
+	//FIXME they shouldn't recognize enemy's death instantly
+
+	//TEMP FIX:
+	//if(NPC->enemy->client)
+	//{
+	//	NPC->enemy->health = NPC->enemy->client->ps.stats[STAT_HEALTH];
+	//}
+
+	if ( NPC->enemy )
+	{
+		if ( !NPC->enemy->inuse )//|| NPC->enemy == NPC )//wtf?  NPCs should never get mad at themselves!
+		{
+			if ( setEnemy )
+			{
+				G_ClearEnemy( NPC );
+			}
+		}
+	}
+
+	//if ( NPC->svFlags & SVF_IGNORE_ENEMIES )
+	if (0) //rwwFIXMEFIXME: support for this flag
+	{//We're ignoring all enemies for now
+		if ( setEnemy )
+		{
+			G_ClearEnemy( NPC );
+		}
+		return NULL;
+	}
+
+	//rwwFIXMEFIXME: support for this flag
+	/*
+	if ( NPC->svFlags & SVF_LOCKEDENEMY )
+	{//keep this enemy until dead
+		if ( NPC->enemy )
+		{
+			if ( (!NPC->NPC && !(NPC->svFlags & SVF_NONNPC_ENEMY) ) || NPC->enemy->health > 0 )
+			{//Enemy never had health (a train or info_not_null, etc) or did and is now dead (NPCs, turrets, etc)
+				return NULL;
+			}
+		}
+		NPC->svFlags &= ~SVF_LOCKEDENEMY;
+	}
+	*/
+
+	if ( NPC->enemy )
+	{
+		if ( NPC_EnemyTooFar(NPC->enemy, 0, qfalse) )
+		{
+			if(findNew)
+			{//See if there is a close one and take it if so, else keep this one
+				forcefindNew = qtrue;
+			}
+			else if(!tooFarOk)//FIXME: don't need this extra bool any more
+			{
+				if ( setEnemy )
+				{
+					G_ClearEnemy( NPC );
+				}
+			}
+		}
+		else if ( !trap_InPVS(NPC->r.currentOrigin, NPC->enemy->r.currentOrigin ) )
+		{//FIXME: should this be a line-of site check?
+			//FIXME: a lot of things check PVS AGAIN when deciding whether 
+			//or not to shoot, redundant!
+			//Should we lose the enemy?
+			//FIXME: if lose enemy, run lostenemyscript
+			if ( NPC->enemy->client && NPC->enemy->client->hiddenDist )
+			{//He ducked into shadow while we weren't looking
+				//Drop enemy and see if we should search for him
+				NPC_LostEnemyDecideChase();
+			}
+			else
+			{//If we're not chasing him, we need to lose him
+				//NOTE: since we no longer have bStates, really, this logic doesn't work, so never give him up
+
+				/*
+				switch( NPCInfo->behaviorState )
+				{
+				case BS_HUNT_AND_KILL:
+					//Okay to lose PVS, we're chasing them
+					break;
+				case BS_RUN_AND_SHOOT:
+				//FIXME: only do this if !(NPCInfo->scriptFlags&SCF_CHASE_ENEMY)
+					//If he's not our goalEntity, we're running somewhere else, so lose him
+					if ( NPC->enemy != NPCInfo->goalEntity )
+					{
+						G_ClearEnemy( NPC );
+					}
+					break;
+				default:
+					//We're not chasing him, so lose him as an enemy
+					G_ClearEnemy( NPC );
+					break;
+				}
+				*/
+			}
+		}
+	}
+
+	if ( NPC->enemy )
+	{
+		if ( NPC->enemy->health <= 0 || NPC->enemy->flags & FL_NOTARGET )
+		{
+			if ( setEnemy )
+			{
+				G_ClearEnemy( NPC );
+			}
+		}
+	}
+
+	closestTo = NPC;
+	//FIXME: check your defendEnt, if you have one, see if their enemy is different 
+	//than yours, or, if they don't have one, pick the closest enemy to THEM?
+	if ( NPCInfo->defendEnt )
+	{//Trying to protect someone
+		if ( NPCInfo->defendEnt->health > 0 )
+		{//Still alive, We presume we're close to them, navigation should handle this?
+			if ( NPCInfo->defendEnt->enemy )
+			{//They were shot or acquired an enemy
+				if ( NPC->enemy != NPCInfo->defendEnt->enemy )
+				{//They have a different enemy, take it!
+					newEnemy = NPCInfo->defendEnt->enemy;
+					if ( setEnemy )
+					{
+						G_SetEnemy( NPC, NPCInfo->defendEnt->enemy );
+					}
+				}
+			}
+			else if ( NPC->enemy == NULL )
+			{//We don't have an enemy, so find closest to defendEnt
+				closestTo = NPCInfo->defendEnt;
+			}
+		}
+	}
+
+	if (!NPC->enemy || ( NPC->enemy && NPC->enemy->health <= 0 ) || forcefindNew )
+	{//FIXME: NPCs that are moving after an enemy should ignore the can't hit enemy counter- that should only be for NPCs that are standing still
+		//NOTE: cantHitEnemyCounter >= 100 means we couldn't hit enemy for a full
+		//	10 seconds, so give up.  This means even if we're chasing him, we would
+		//	try to find another enemy after 10 seconds (assuming the cantHitEnemyCounter
+		//	is allowed to increment in a chasing bState)
+		qboolean	foundenemy = qfalse;
+
+		if(!findNew)
+		{
+			if ( setEnemy )
+			{
+				NPC->lastEnemy = NPC->enemy;
+				G_ClearEnemy(NPC);
+			}
+			return NULL;
+		}
+
+		//If enemy dead or unshootable, look for others on out enemy's team
+		if ( NPC->client->enemyTeam != NPCTEAM_NEUTRAL )
+		{
+			//NOTE:  this only checks vis if can't hit enemy for 10 tries, which I suppose
+			//			means they need to find one that in more than just PVS
+			//newenemy = NPC_PickEnemy( closestTo, NPC->client->enemyTeam, (NPC->cantHitEnemyCounter > 10), qfalse, qtrue );//3rd parm was (NPC->enemyTeam == TEAM_STARFLEET)
+			//For now, made it so you ALWAYS have to check VIS
+			newEnemy = NPC_PickEnemy( closestTo, NPC->client->enemyTeam, qtrue, qfalse, qtrue );//3rd parm was (NPC->enemyTeam == TEAM_STARFLEET)
+			if ( newEnemy )
+			{
+				foundenemy = qtrue;
+				if ( setEnemy )
+				{
+					G_SetEnemy( NPC, newEnemy );
+				}
+			}
+		}
+		
+		if ( !forcefindNew )
+		{
+			if ( !foundenemy )
+			{
+				if ( setEnemy )
+				{
+					NPC->lastEnemy = NPC->enemy;
+					G_ClearEnemy(NPC);
+				}
+			}
+			
+			NPC->cantHitEnemyCounter = 0;
+		}
+		//FIXME: if we can't find any at all, go into INdependant NPC AI, pursue and kill
+	}
+
+	if ( NPC->enemy && NPC->enemy->client ) 
+	{
+		if(NPC->enemy->client->playerTeam)
+		{
+//			assert( NPC->client->playerTeam != NPC->enemy->client->playerTeam);
+			if( NPC->client->playerTeam != NPC->enemy->client->playerTeam )
+			{
+				NPC->client->enemyTeam = NPC->enemy->client->playerTeam;
+			}
+		}
+	}
+	return newEnemy;
+}
+
+/*
+-------------------------
+NPC_ClearShot
+-------------------------
+*/
+
+qboolean NPC_ClearShot( gentity_t *ent )
+{
+	vec3_t	muzzle;
+	trace_t	tr;
+
+	if ( ( NPC == NULL ) || ( ent == NULL ) )
+		return qfalse;
+
+	CalcEntitySpot( NPC, SPOT_WEAPON, muzzle );
+
+	// add aim error
+	// use weapon instead of specific npc types, although you could add certain npc classes if you wanted
+//	if ( NPC->client->playerTeam == TEAM_SCAVENGERS )
+	if( NPC->s.weapon == WP_BLASTER /*|| NPC->s.weapon == WP_BLASTER_PISTOL*/ ) // any other guns to check for?
+	{
+		vec3_t	mins = { -2, -2, -2 };
+		vec3_t	maxs = {  2,  2,  2 };
+
+		trap_Trace ( &tr, muzzle, mins, maxs, ent->r.currentOrigin, NPC->s.number, MASK_SHOT );
+	}
+	else
+	{
+		trap_Trace ( &tr, muzzle, NULL, NULL, ent->r.currentOrigin, NPC->s.number, MASK_SHOT );
+	}
+	
+	if ( tr.startsolid || tr.allsolid )
+	{
+		return qfalse;
+	}
+
+	if ( tr.entityNum == ent->s.number ) 
+		return qtrue;
+	
+	return qfalse;
+}
+
+/*
+-------------------------
+NPC_ShotEntity
+-------------------------
+*/
+
+int NPC_ShotEntity( gentity_t *ent, vec3_t impactPos )
+{
+	vec3_t	muzzle;
+	vec3_t targ;
+	trace_t	tr;
+
+	if ( ( NPC == NULL ) || ( ent == NULL ) )
+		return qfalse;
+
+	if ( NPC->s.weapon == WP_THERMAL )
+	{//thermal aims from slightly above head
+		//FIXME: what about low-angle shots, rolling the thermal under something?
+		vec3_t	angles, forward, end;
+
+		CalcEntitySpot( NPC, SPOT_HEAD, muzzle );
+		VectorSet( angles, 0, NPC->client->ps.viewangles[1], 0 );
+		AngleVectors( angles, forward, NULL, NULL );
+		VectorMA( muzzle, 8, forward, end );
+		end[2] += 24;
+		trap_Trace ( &tr, muzzle, vec3_origin, vec3_origin, end, NPC->s.number, MASK_SHOT );
+		VectorCopy( tr.endpos, muzzle );
+	}
+	else
+	{
+		CalcEntitySpot( NPC, SPOT_WEAPON, muzzle );
+	}
+	CalcEntitySpot( ent, SPOT_CHEST, targ );
+	
+	// add aim error
+	// use weapon instead of specific npc types, although you could add certain npc classes if you wanted
+//	if ( NPC->client->playerTeam == TEAM_SCAVENGERS )
+	if( NPC->s.weapon == WP_BLASTER /*|| NPC->s.weapon == WP_BLASTER_PISTOL*/ ) // any other guns to check for?
+	{
+		vec3_t	mins = { -2, -2, -2 };
+		vec3_t	maxs = {  2,  2,  2 };
+
+		trap_Trace ( &tr, muzzle, mins, maxs, targ, NPC->s.number, MASK_SHOT );
+	}
+	else
+	{
+		trap_Trace ( &tr, muzzle, NULL, NULL, targ, NPC->s.number, MASK_SHOT );
+	}
+	//FIXME: if using a bouncing weapon like the bowcaster, should we check the reflection of the wall, too?
+	if ( impactPos )
+	{//they want to know *where* the hit would be, too
+		VectorCopy( tr.endpos, impactPos );
+	}
+/* // NPCs should be able to shoot even if the muzzle would be inside their target
+	if ( tr.startsolid || tr.allsolid )
+	{
+		return ENTITYNUM_NONE;
+	}
+*/
+	return tr.entityNum;
+}
+
+qboolean NPC_EvaluateShot( int hit, qboolean glassOK )
+{
+	if ( !NPC->enemy )
+	{
+		return qfalse;
+	}
+
+	if ( hit == NPC->enemy->s.number || (&g_entities[hit] != NULL && (g_entities[hit].r.svFlags&SVF_GLASS_BRUSH)) )
+	{//can hit enemy or will hit glass, so shoot anyway
+		return qtrue;
+	}
+	return qfalse;
+}
+
+/*
+NPC_CheckAttack
+
+Simply checks aggression and returns true or false
+*/
+
+qboolean NPC_CheckAttack (float scale)
+{
+	if(!scale)
+		scale = 1.0;
+
+	if(((float)NPCInfo->stats.aggression) * scale < flrand(0, 4))
+	{
+		return qfalse;
+	}
+
+	if(NPCInfo->shotTime > level.time)
+		return qfalse;
+
+	return qtrue;
+}
+
+/*
+NPC_CheckDefend
+
+Simply checks evasion and returns true or false
+*/
+
+qboolean NPC_CheckDefend (float scale)
+{
+	if(!scale)
+		scale = 1.0;
+
+	if((float)(NPCInfo->stats.evasion) > random() * 4 * scale)
+		return qtrue;
+
+	return qfalse;
+}
+
+
+//NOTE: BE SURE TO CHECK PVS BEFORE THIS!
+qboolean NPC_CheckCanAttack (float attack_scale, qboolean stationary)
+{
+	vec3_t		delta, forward;
+	vec3_t		angleToEnemy;
+	vec3_t		hitspot, muzzle, diff, enemy_org;//, enemy_head;
+	float		distanceToEnemy;
+	qboolean	attack_ok = qfalse;
+//	qboolean	duck_ok = qfalse;
+	qboolean	dead_on = qfalse;
+	float		aim_off;
+	float		max_aim_off = 128 - (16 * (float)NPCInfo->stats.aim);
+	trace_t		tr;
+	gentity_t	*traceEnt = NULL;
+
+	if(NPC->enemy->flags & FL_NOTARGET)
+	{
+		return qfalse;
+	}
+
+	//FIXME: only check to see if should duck if that provides cover from the
+	//enemy!!!
+	if(!attack_scale)
+	{
+		attack_scale = 1.0;
+	}
+	//Yaw to enemy
+	CalcEntitySpot( NPC->enemy, SPOT_HEAD, enemy_org );
+	NPC_AimWiggle( enemy_org );
+
+	CalcEntitySpot( NPC, SPOT_WEAPON, muzzle );
+	
+	VectorSubtract (enemy_org, muzzle, delta);
+	vectoangles ( delta, angleToEnemy );
+	distanceToEnemy = VectorNormalize(delta);
+
+	NPC->NPC->desiredYaw = angleToEnemy[YAW];
+	NPC_UpdateFiringAngles(qfalse, qtrue);
+
+	if( NPC_EnemyTooFar(NPC->enemy, distanceToEnemy*distanceToEnemy, qtrue) )
+	{//Too far away?  Do not attack
+		return qfalse;
+	}
+
+	if(client->ps.weaponTime > 0)
+	{//already waiting for a shot to fire
+		NPC->NPC->desiredPitch = angleToEnemy[PITCH];
+		NPC_UpdateFiringAngles(qtrue, qfalse);
+		return qfalse;
+	}
+
+	if(NPCInfo->scriptFlags & SCF_DONT_FIRE)
+	{
+		return qfalse;
+	}
+
+	NPCInfo->enemyLastVisibility = enemyVisibility;
+	//See if they're in our FOV and we have a clear shot to them
+	enemyVisibility = NPC_CheckVisibility ( NPC->enemy, CHECK_360|CHECK_FOV);////CHECK_PVS|
+
+	if(enemyVisibility >= VIS_FOV)
+	{//He's in our FOV
+		
+		attack_ok = qtrue;
+		//CalcEntitySpot( NPC->enemy, SPOT_HEAD, enemy_head);
+
+		//Check to duck
+		if ( NPC->enemy->client )
+		{
+			if ( NPC->enemy->enemy == NPC )
+			{
+				if ( NPC->enemy->client->buttons & BUTTON_ATTACK )
+				{//FIXME: determine if enemy fire angles would hit me or get close
+					if ( NPC_CheckDefend( 1.0 ) )//FIXME: Check self-preservation?  Health?
+					{//duck and don't shoot
+						attack_ok = qfalse;
+						ucmd.upmove = -127;
+					}
+				}
+			}
+		}
+
+		if(attack_ok)
+		{
+			//are we gonna hit him
+			//NEW: use actual forward facing
+			AngleVectors( client->ps.viewangles, forward, NULL, NULL );
+			VectorMA( muzzle, distanceToEnemy, forward, hitspot );
+			trap_Trace( &tr, muzzle, NULL, NULL, hitspot, NPC->s.number, MASK_SHOT );
+			ShotThroughGlass( &tr, NPC->enemy, hitspot, MASK_SHOT );
+			/*
+			//OLD: trace regardless of facing
+			trap_Trace ( &tr, muzzle, NULL, NULL, enemy_org, NPC->s.number, MASK_SHOT );
+			ShotThroughGlass(&tr, NPC->enemy, enemy_org, MASK_SHOT);
+			*/
+
+			traceEnt = &g_entities[tr.entityNum];
+
+			/*
+			if( traceEnt != NPC->enemy &&//FIXME: if someone on our team is in the way, suggest that they duck if possible
+				(!traceEnt || !traceEnt->client || !NPC->client->enemyTeam || NPC->client->enemyTeam != traceEnt->client->playerTeam) )
+			{//no, so shoot for somewhere between the head and torso
+				//NOTE: yes, I know this looks weird, but it works
+				enemy_org[0] += 0.3*Q_flrand(NPC->enemy->r.mins[0], NPC->enemy->r.maxs[0]);
+				enemy_org[1] += 0.3*Q_flrand(NPC->enemy->r.mins[1], NPC->enemy->r.maxs[1]);
+				enemy_org[2] -= NPC->enemy->r.maxs[2]*Q_flrand(0.0f, 1.0f);
+
+				attack_scale *= 0.75;
+				trap_Trace ( &tr, muzzle, NULL, NULL, enemy_org, NPC->s.number, MASK_SHOT );
+				ShotThroughGlass(&tr, NPC->enemy, enemy_org, MASK_SHOT);
+				traceEnt = &g_entities[tr.entityNum];
+			}
+			*/
+
+			VectorCopy( tr.endpos, hitspot );
+
+			if( traceEnt == NPC->enemy || (traceEnt->client && NPC->client->enemyTeam && NPC->client->enemyTeam == traceEnt->client->playerTeam) )
+			{
+				dead_on = qtrue;
+			}
+			else
+			{
+				attack_scale *= 0.5;
+				if(NPC->client->playerTeam)
+				{
+					if(traceEnt && traceEnt->client && traceEnt->client->playerTeam)
+					{
+						if(NPC->client->playerTeam == traceEnt->client->playerTeam)
+						{//Don't shoot our own team
+							attack_ok = qfalse;
+						}
+					}
+				}
+			}
+		}
+
+		if( attack_ok )
+		{
+			//ok, now adjust pitch aim
+			VectorSubtract (hitspot, muzzle, delta);
+			vectoangles ( delta, angleToEnemy );
+			NPC->NPC->desiredPitch = angleToEnemy[PITCH];
+			NPC_UpdateFiringAngles(qtrue, qfalse);
+
+			if( !dead_on )
+			{//We're not going to hit him directly, try a suppressing fire
+				//see if where we're going to shoot is too far from his origin
+				if(traceEnt && (traceEnt->health <= 30 || EntIsGlass(traceEnt)))
+				{//easy to kill - go for it
+					//if(traceEnt->die == ExplodeDeath_Wait && traceEnt->splashDamage)
+					if (0) //rwwFIXMEFIXME: ExplodeDeath_Wait?
+					{//going to explode, don't shoot if close to self
+						VectorSubtract(NPC->r.currentOrigin, traceEnt->r.currentOrigin, diff);
+						if(VectorLengthSquared(diff) < traceEnt->splashRadius*traceEnt->splashRadius)
+						{//Too close to shoot!
+							attack_ok = qfalse;
+						}
+						else 
+						{//Hey, it might kill him, do it!
+							attack_scale *= 2;//
+						}
+					}
+				}
+				else
+				{
+					AngleVectors (client->ps.viewangles, forward, NULL, NULL);
+					VectorMA ( muzzle, distanceToEnemy, forward, hitspot);
+					VectorSubtract(hitspot, enemy_org, diff);
+					aim_off = VectorLength(diff);
+					if(aim_off > random() * max_aim_off)//FIXME: use aim value to allow poor aim?
+					{
+						attack_scale *= 0.75;
+						//see if where we're going to shoot is too far from his head
+						VectorSubtract(hitspot, enemy_org, diff);
+						aim_off = VectorLength(diff);
+						if(aim_off > random() * max_aim_off)
+						{
+							attack_ok = qfalse;
+						}
+					}
+					attack_scale *= (max_aim_off - aim_off + 1)/max_aim_off;
+				}
+			}
+		}
+	}
+	else
+	{//Update pitch anyway
+		NPC->NPC->desiredPitch = angleToEnemy[PITCH];
+		NPC_UpdateFiringAngles(qtrue, qfalse);
+	}
+
+	if( attack_ok )
+	{
+		if( NPC_CheckAttack( attack_scale ))
+		{//check aggression to decide if we should shoot
+			enemyVisibility = VIS_SHOOT;
+			WeaponThink(qtrue);
+		}
+		else
+			attack_ok = qfalse;
+	}
+
+	return attack_ok;
+}
+//========================================================================================
+//OLD id-style hunt and kill
+//========================================================================================
+/*
+IdealDistance
+
+determines what the NPC's ideal distance from it's enemy should
+be in the current situation
+*/
+float IdealDistance ( gentity_t *self ) 
+{
+	float	ideal;
+
+	ideal = 225 - 20 * NPCInfo->stats.aggression;
+	switch ( NPC->s.weapon ) 
+	{
+	case WP_ROCKET_LAUNCHER:
+		ideal += 200;
+		break;
+
+	case WP_THERMAL:
+		ideal += 50;
+		break;
+
+/*	case WP_TRICORDER:
+		ideal = 0;
+		break;
+*/
+	case WP_SABER:
+	case WP_BRYAR_PISTOL:
+//	case WP_BLASTER_PISTOL:
+	case WP_BLASTER:
+	default:
+		break;
+	}
+
+	return ideal;
+}
+
+/*QUAKED point_combat (0.7 0 0.7) (-16 -16 -24) (16 16 32) DUCK FLEE INVESTIGATE SQUAD LEAN SNIPE
+NPCs in bState BS_COMBAT_POINT will find their closest empty combat_point
+
+DUCK - NPC will duck and fire from this point, NOT IMPLEMENTED?
+FLEE - Will choose this point when running
+INVESTIGATE - Will look here if a sound is heard near it
+SQUAD - NOT IMPLEMENTED
+LEAN - Lean-type cover, NOT IMPLEMENTED
+SNIPE - Snipers look for these first, NOT IMPLEMENTED
+*/
+
+void SP_point_combat( gentity_t *self )
+{
+	if(level.numCombatPoints >= MAX_COMBAT_POINTS)
+	{
+#ifndef FINAL_BUILD
+		Com_Printf(S_COLOR_RED"ERROR:  Too many combat points, limit is %d\n", MAX_COMBAT_POINTS);
+#endif
+		G_FreeEntity(self);
+		return;
+	}
+
+	self->s.origin[2] += 0.125;
+	G_SetOrigin(self, self->s.origin);
+	trap_LinkEntity(self);
+
+	if ( G_CheckInSolid( self, qtrue ) )
+	{
+#ifndef FINAL_BUILD
+		Com_Printf( S_COLOR_RED"ERROR: combat point at %s in solid!\n", vtos(self->r.currentOrigin) );
+#endif
+	}
+
+	VectorCopy( self->r.currentOrigin, level.combatPoints[level.numCombatPoints].origin );
+	
+	level.combatPoints[level.numCombatPoints].flags = self->spawnflags;
+	level.combatPoints[level.numCombatPoints].occupied = qfalse;
+
+	level.numCombatPoints++;
+
+	G_FreeEntity(self);
+}
+
+void CP_FindCombatPointWaypoints( void )
+{
+	int i;
+
+	for ( i = 0; i < level.numCombatPoints; i++ )
+	{
+		level.combatPoints[i].waypoint = NAV_FindClosestWaypointForPoint2( level.combatPoints[i].origin );
+#ifndef FINAL_BUILD
+		if ( level.combatPoints[i].waypoint == WAYPOINT_NONE )
+		{
+			Com_Printf( S_COLOR_RED"ERROR: Combat Point at %s has no waypoint!\n", vtos(level.combatPoints[i].origin) );
+		}
+#endif
+	}
+}
+
+
+/*
+-------------------------
+NPC_CollectCombatPoints
+-------------------------
+*/
+typedef struct
+{
+	float dist;
+	int index;
+} combatPt_t;
+static int NPC_CollectCombatPoints( const vec3_t origin, const float radius, combatPt_t *points, const int flags )
+{
+	float	radiusSqr = (radius*radius);
+	float	distance;
+	float	bestDistance = Q3_INFINITE;
+	int		bestPoint = 0;
+	int		numPoints = 0;
+	int		i;
+
+	//Collect all nearest
+	for ( i = 0; i < level.numCombatPoints; i++ )
+	{
+		if (numPoints >= MAX_COMBAT_POINTS)
+		{
+			break;
+		}
+
+		//Must be vacant
+		if ( level.combatPoints[i].occupied == (int) qtrue )
+			continue;
+
+		//If we want a duck space, make sure this is one
+		if ( ( flags & CP_DUCK ) && ( level.combatPoints[i].flags & CPF_DUCK ) )
+			continue;
+
+		//If we want a duck space, make sure this is one
+		if ( ( flags & CP_FLEE ) && ( level.combatPoints[i].flags & CPF_FLEE ) )
+			continue;
+
+		///Make sure this is an investigate combat point
+		if ( ( flags & CP_INVESTIGATE ) && ( level.combatPoints[i].flags & CPF_INVESTIGATE ) )
+			continue;
+		
+		//Squad points are only valid if we're looking for them
+		if ( ( level.combatPoints[i].flags & CPF_SQUAD ) && ( ( flags & CP_SQUAD ) == qfalse ) )
+			continue;
+
+		if ( flags&CP_NO_PVS )
+		{//must not be within PVS of mu current origin
+			if ( trap_InPVS( origin, level.combatPoints[i].origin ) )
+			{
+				continue;
+			}
+		}
+
+		if ( flags&CP_HORZ_DIST_COLL )
+		{
+			distance = 	DistanceHorizontalSquared( origin, level.combatPoints[i].origin );
+		}
+		else
+		{
+			distance = 	DistanceSquared( origin, level.combatPoints[i].origin );
+		}
+
+		if ( distance < radiusSqr )
+		{
+			if (distance < bestDistance)
+			{
+				bestDistance = distance;
+				bestPoint = numPoints;
+			}
+
+			points[numPoints].dist = distance;
+			points[numPoints].index = i;
+			numPoints++;
+		}
+	}
+
+	return numPoints;//bestPoint;
+}
+
+/*
+-------------------------
+NPC_FindCombatPoint
+-------------------------
+*/
+
+#define	MIN_AVOID_DOT				0.75f
+#define MIN_AVOID_DISTANCE			128
+#define MIN_AVOID_DISTANCE_SQUARED	( MIN_AVOID_DISTANCE * MIN_AVOID_DISTANCE )
+#define	CP_COLLECT_RADIUS			512.0f
+
+int NPC_FindCombatPoint( const vec3_t position, const vec3_t avoidPosition, vec3_t enemyPosition, const int flags, const float avoidDist, const int ignorePoint )
+{
+	combatPt_t		points[MAX_COMBAT_POINTS];
+	int				best = -1, cost, bestCost = Q3_INFINITE, waypoint = WAYPOINT_NONE;
+	float			dist;
+	trace_t			tr;
+	float			collRad = CP_COLLECT_RADIUS;
+	int				numPoints;
+	int				j = 0;
+	float			modifiedAvoidDist = avoidDist;
+
+	if ( modifiedAvoidDist <= 0 )
+	{
+		modifiedAvoidDist = MIN_AVOID_DISTANCE_SQUARED;
+	}
+	else
+	{
+		modifiedAvoidDist *= modifiedAvoidDist;
+	}
+
+	if ( (flags & CP_HAS_ROUTE) || (flags & CP_NEAREST) )
+	{//going to be doing macro nav tests
+		if ( NPC->waypoint == WAYPOINT_NONE )
+		{
+			waypoint = NAV_GetNearestNode( NPC, NPC->lastWaypoint );
+		}
+		else
+		{
+			waypoint = NPC->waypoint;
+		}
+	}
+
+	//Collect our nearest points
+	if ( flags & CP_NO_PVS )
+	{//much larger radius since most will be dropped?
+		collRad = CP_COLLECT_RADIUS*4;
+	}
+	numPoints = NPC_CollectCombatPoints( enemyPosition, collRad, points, flags );//position
+
+
+	for ( j = 0; j < numPoints; j++ )
+	{
+		//const int i = (*cpi).second;
+		const int i = points[j].index;
+		const float pdist = points[j].dist;
+
+		//Must not be one we want to ignore
+		if ( i == ignorePoint )
+			continue;
+
+		//FIXME: able to mark certain ones as too dangerous to go to for now?  Like a tripmine/thermal/detpack is near or something?
+		//If we need a cover point, check this point
+		if ( ( flags & CP_COVER ) && ( NPC_ClearLOS( level.combatPoints[i].origin, enemyPosition ) == qtrue ) )//Used to use NPC->enemy
+			continue;
+
+		//Need a clear LOS to our target... and be within shot range to enemy position (FIXME: make this a separate CS_ flag? and pass in a range?)
+		if ( flags & CP_CLEAR )
+		{
+			if ( NPC_ClearLOS3( level.combatPoints[i].origin, NPC->enemy ) == qfalse )
+			{
+				continue;
+			}
+			if ( NPC->s.weapon == WP_THERMAL )
+			{//horizontal
+				dist = DistanceHorizontalSquared( level.combatPoints[i].origin, NPC->enemy->r.currentOrigin );
+			}
+			else
+			{//actual
+				dist = DistanceSquared( level.combatPoints[i].origin, NPC->enemy->r.currentOrigin );
+			}
+			if ( dist > (NPCInfo->stats.visrange*NPCInfo->stats.visrange) )
+			{
+				continue;
+			}
+		}
+
+		//Avoid this position?
+		if ( ( flags & CP_AVOID ) && ( DistanceSquared( level.combatPoints[i].origin, position ) < modifiedAvoidDist ) )//was using MIN_AVOID_DISTANCE_SQUARED, not passed in modifiedAvoidDist
+			continue;
+
+		//Try to find a point closer to the enemy than where we are
+		if ( flags & CP_APPROACH_ENEMY )
+		{
+			if ( flags&CP_HORZ_DIST_COLL )
+			{
+				if ( pdist > DistanceHorizontalSquared( position, enemyPosition ) )
+				{
+					continue;
+				}
+			}
+			else 
+			{
+				if ( pdist > DistanceSquared( position, enemyPosition ) )
+				{
+					continue;
+				}
+			}
+		}
+		//Try to find a point farther from the enemy than where we are
+		if ( flags & CP_RETREAT )
+		{
+			if ( flags&CP_HORZ_DIST_COLL )
+			{
+				if ( pdist < DistanceHorizontalSquared( position, enemyPosition ) )
+				{//it's closer, don't use it
+					continue;
+				}
+			}
+			else
+			{
+				if ( pdist < DistanceSquared( position, enemyPosition ) )
+				{//it's closer, don't use it
+					continue;
+				}
+			}
+		}
+
+		//We want a point on other side of the enemy from current pos
+		if ( flags & CP_FLANK  )
+		{
+			vec3_t	eDir2Me, eDir2CP;
+			float dot;
+			
+			VectorSubtract( position, enemyPosition, eDir2Me );
+			VectorNormalize( eDir2Me );
+
+			VectorSubtract( level.combatPoints[i].origin, enemyPosition, eDir2CP );
+			VectorNormalize( eDir2CP );
+
+			dot = DotProduct( eDir2Me, eDir2CP );
+			
+			//Not far enough behind enemy from current pos
+			if ( dot >= 0.4 )
+				continue;
+		}
+
+		//See if we're trying to avoid our enemy
+		//FIXME: this needs to check for the waypoint you'll be taking to get to that combat point
+		if ( flags & CP_AVOID_ENEMY  )
+		{
+			vec3_t	eDir, gDir;
+			vec3_t	wpOrg;
+			float dot;
+			
+			VectorSubtract( position, enemyPosition, eDir );
+			VectorNormalize( eDir );
+
+			/*
+			NAV_FindClosestWaypointForEnt( NPC, level.combatPoints[i].waypoint );
+			if ( NPC->waypoint != WAYPOINT_NONE && NPC->waypoint != level.combatPoints[i].waypoint )
+			{
+				trap_Nav_GetNodePosition( NPC->waypoint, wpOrg );
+			}
+			else
+			*/
+			{
+				VectorCopy( level.combatPoints[i].origin, wpOrg );
+			}
+			VectorSubtract( position, wpOrg, gDir );
+			VectorNormalize( gDir );
+
+			dot = DotProduct( gDir, eDir );
+			
+			//Don't want to run at enemy
+			if ( dot >= MIN_AVOID_DOT )
+				continue;
+
+			//Can't be too close to the enemy
+			if ( DistanceSquared( wpOrg, enemyPosition ) < modifiedAvoidDist )
+				continue;
+		}
+		
+		//Okay, now make sure it's not blocked
+		trap_Trace( &tr, level.combatPoints[i].origin, NPC->r.mins, NPC->r.maxs, level.combatPoints[i].origin, NPC->s.number, NPC->clipmask );
+		if ( tr.allsolid || tr.startsolid )
+		{
+			continue;
+		}
+
+		//we must have a route to the combat point
+		if ( flags & CP_HAS_ROUTE )
+		{
+			/*
+			if ( level.combatPoints[i].waypoint == WAYPOINT_NONE )
+			{
+				level.combatPoints[i].waypoint = NAV_FindClosestWaypointForPoint( level.combatPoints[i].origin );
+			}
+			*/
+
+			if ( waypoint == WAYPOINT_NONE || level.combatPoints[i].waypoint == WAYPOINT_NONE || trap_Nav_GetBestNodeAltRoute2( waypoint, level.combatPoints[i].waypoint, NODE_NONE ) == WAYPOINT_NONE )
+			{//can't possibly have a route to any OR can't possibly have a route to this one OR don't have a route to this one
+				if ( !NAV_ClearPathToPoint( NPC, NPC->r.mins, NPC->r.maxs, level.combatPoints[i].origin, NPC->clipmask, ENTITYNUM_NONE ) )
+				{//don't even have a clear straight path to this one
+					continue;
+				}
+			}
+		}
+
+		//We want the one with the shortest path from current pos
+		if ( flags & CP_NEAREST && waypoint != WAYPOINT_NONE && level.combatPoints[i].waypoint != WAYPOINT_NONE )
+		{
+			cost = trap_Nav_GetPathCost( waypoint, level.combatPoints[i].waypoint );
+			if ( cost < bestCost )
+			{
+				bestCost = cost;
+				best = i;
+			}
+			continue;
+		}
+
+		//we want the combat point closest to the enemy
+		//if ( flags & CP_CLOSEST )
+		//they are sorted by this distance, so the first one to get this far is the closest
+		return i;
+	}
+
+	return best;
+}
+
+/*
+-------------------------
+NPC_FindSquadPoint
+-------------------------
+*/
+
+int NPC_FindSquadPoint( vec3_t position )
+{
+	float	dist, nearestDist = (float)WORLD_SIZE*(float)WORLD_SIZE;
+	int		nearestPoint = -1;
+	int		i;
+
+	//float			playerDist = DistanceSquared( g_entities[0].currentOrigin, NPC->r.currentOrigin );
+
+	for ( i = 0; i < level.numCombatPoints; i++ )
+	{
+		//Squad points are only valid if we're looking for them
+		if ( ( level.combatPoints[i].flags & CPF_SQUAD ) == qfalse )
+			continue;
+
+		//Must be vacant
+		if ( level.combatPoints[i].occupied == qtrue )
+			continue;
+		
+		dist = DistanceSquared( position, level.combatPoints[i].origin );
+
+		//The point cannot take us past the player
+		//if ( dist > ( playerDist * DotProduct( dirToPlayer, playerDir ) ) )	//FIXME: Retain this
+		//	continue;
+
+		//See if this is closer than the others
+		if ( dist < nearestDist )
+		{
+			nearestPoint = i;
+			nearestDist = dist;
+		}
+	}
+
+	return nearestPoint;
+}
+
+/*
+-------------------------
+NPC_ReserveCombatPoint
+-------------------------
+*/
+
+qboolean NPC_ReserveCombatPoint( int combatPointID )
+{
+	//Make sure it's valid
+	if ( combatPointID > level.numCombatPoints )
+		return qfalse;
+
+	//Make sure it's not already occupied
+	if ( level.combatPoints[combatPointID].occupied )
+		return qfalse;
+
+	//Reserve it
+	level.combatPoints[combatPointID].occupied = qtrue;
+
+	return qtrue;
+}
+
+/*
+-------------------------
+NPC_FreeCombatPoint
+-------------------------
+*/
+
+qboolean NPC_FreeCombatPoint( int combatPointID, qboolean failed )
+{
+	if ( failed )
+	{//remember that this one failed for us
+		NPCInfo->lastFailedCombatPoint = combatPointID;
+	}
+	//Make sure it's valid
+	if ( combatPointID > level.numCombatPoints )
+		return qfalse;
+
+	//Make sure it's currently occupied
+	if ( level.combatPoints[combatPointID].occupied == qfalse )
+		return qfalse;
+
+	//Free it
+	level.combatPoints[combatPointID].occupied = qfalse;
+	
+	return qtrue;
+}
+
+/*
+-------------------------
+NPC_SetCombatPoint
+-------------------------
+*/
+
+qboolean NPC_SetCombatPoint( int combatPointID )
+{
+	//Free a combat point if we already have one
+	if ( NPCInfo->combatPoint != -1 )
+	{
+		NPC_FreeCombatPoint( NPCInfo->combatPoint, qfalse );
+	}
+
+	if ( NPC_ReserveCombatPoint( combatPointID ) == qfalse )
+		return qfalse;
+
+	NPCInfo->combatPoint = combatPointID;
+
+	return qtrue;
+}
+
+extern qboolean CheckItemCanBePickedUpByNPC( gentity_t *item, gentity_t *pickerupper );
+gentity_t *NPC_SearchForWeapons( void )
+{
+	gentity_t *found = g_entities, *bestFound = NULL;
+	float		dist, bestDist = Q3_INFINITE;
+	int i;
+//	for ( found = g_entities; found < &g_entities[globals.num_entities] ; found++)
+	for ( i = 0; i<level.num_entities; i++)
+	{
+//		if ( !found->inuse )
+//		{
+//			continue;
+//		}
+		if(!g_entities[i].inuse)
+			continue;
+		
+		found=&g_entities[i];
+		
+		//FIXME: Also look for ammo_racks that have weapons on them?
+		if ( found->s.eType != ET_ITEM )
+		{
+			continue;
+		}
+		if ( found->item->giType != IT_WEAPON )
+		{
+			continue;
+		}
+		if ( found->s.eFlags & EF_NODRAW )
+		{
+			continue;
+		}
+		if ( CheckItemCanBePickedUpByNPC( found, NPC ) )
+		{
+			if ( trap_InPVS( found->r.currentOrigin, NPC->r.currentOrigin ) )
+			{
+				dist = DistanceSquared( found->r.currentOrigin, NPC->r.currentOrigin );
+				if ( dist < bestDist )
+				{
+					if ( !trap_Nav_GetBestPathBetweenEnts( NPC, found, NF_CLEAR_PATH ) 
+						|| trap_Nav_GetBestNodeAltRoute2( NPC->waypoint, found->waypoint, NODE_NONE ) == WAYPOINT_NONE )
+					{//can't possibly have a route to any OR can't possibly have a route to this one OR don't have a route to this one
+						if ( NAV_ClearPathToPoint( NPC, NPC->r.mins, NPC->r.maxs, found->r.currentOrigin, NPC->clipmask, ENTITYNUM_NONE ) )
+						{//have a clear straight path to this one
+							bestDist = dist;
+							bestFound = found;
+						}
+					}
+					else
+					{//can nav to it
+						bestDist = dist;
+						bestFound = found;
+					}
+				}
+			}
+		}
+	}
+
+	return bestFound;
+}
+
+void NPC_SetPickUpGoal( gentity_t *foundWeap )
+{
+	vec3_t org;
+
+	//NPCInfo->goalEntity = foundWeap;
+	VectorCopy( foundWeap->r.currentOrigin, org );
+	org[2] += 24 - (foundWeap->r.mins[2]*-1);//adjust the origin so that I am on the ground
+	NPC_SetMoveGoal( NPC, org, foundWeap->r.maxs[0]*0.75, qfalse, -1, foundWeap );
+	NPCInfo->tempGoal->waypoint = foundWeap->waypoint;
+	NPCInfo->tempBehavior = BS_DEFAULT;
+	NPCInfo->squadState = SQUAD_TRANSITION;
+}
+
+void NPC_CheckGetNewWeapon( void )
+{
+	if ( NPC->s.weapon == WP_NONE && NPC->enemy )
+	{//if running away because dropped weapon...
+		if ( NPCInfo->goalEntity 
+			&& NPCInfo->goalEntity == NPCInfo->tempGoal
+			&& NPCInfo->goalEntity->enemy
+			&& !NPCInfo->goalEntity->enemy->inuse )
+		{//maybe was running at a weapon that was picked up
+			NPCInfo->goalEntity = NULL;
+		}
+		if ( TIMER_Done( NPC, "panic" ) && NPCInfo->goalEntity == NULL )
+		{//need a weapon, any lying around?
+			gentity_t *foundWeap = NPC_SearchForWeapons();
+			if ( foundWeap )
+			{//try to nav to it
+				/*
+				if ( !trap_Nav_GetBestPathBetweenEnts( NPC, foundWeap, NF_CLEAR_PATH ) 
+					|| trap_Nav_GetBestNodeAltRoute( NPC->waypoint, foundWeap->waypoint ) == WAYPOINT_NONE )
+				{//can't possibly have a route to any OR can't possibly have a route to this one OR don't have a route to this one
+					if ( !NAV_ClearPathToPoint( NPC, NPC->r.mins, NPC->r.maxs, foundWeap->r.currentOrigin, NPC->clipmask, ENTITYNUM_NONE ) )
+					{//don't even have a clear straight path to this one
+					}
+					else
+					{
+						NPC_SetPickUpGoal( foundWeap );
+					}
+				}
+				else
+				*/
+				{
+					NPC_SetPickUpGoal( foundWeap );
+				}
+			}
+		}
+	}
+}
+
+void NPC_AimAdjust( int change )
+{
+	if ( !TIMER_Exists( NPC, "aimDebounce" ) )
+	{
+		int debounce = 500+(3-g_spskill.integer)*100;
+		TIMER_Set( NPC, "aimDebounce", Q_irand( debounce,debounce+1000 ) );
+		//int debounce = 1000+(3-g_spskill.integer)*500;
+		//TIMER_Set( NPC, "aimDebounce", Q_irand( debounce, debounce+2000 ) );
+		return;
+	}
+	if ( TIMER_Done( NPC, "aimDebounce" ) )
+	{
+		int debounce;
+
+		NPCInfo->currentAim += change;
+		if ( NPCInfo->currentAim > NPCInfo->stats.aim )
+		{//can never be better than max aim
+			NPCInfo->currentAim = NPCInfo->stats.aim;
+		}
+		else if ( NPCInfo->currentAim < -30 )
+		{//can never be worse than this
+			NPCInfo->currentAim = -30;
+		}
+
+		//Com_Printf( "%s new aim = %d\n", NPC->NPC_type, NPCInfo->currentAim );
+
+		debounce = 500+(3-g_spskill.integer)*100;
+		TIMER_Set( NPC, "aimDebounce", Q_irand( debounce,debounce+1000 ) );
+		//int debounce = 1000+(3-g_spskill.integer)*500;
+		//TIMER_Set( NPC, "aimDebounce", Q_irand( debounce, debounce+2000 ) );
+	}
+}
+
+void G_AimSet( gentity_t *self, int aim )
+{
+	if ( self->NPC )
+	{
+		int debounce;
+
+		self->NPC->currentAim = aim;
+		//Com_Printf( "%s new aim = %d\n", self->NPC_type, self->NPC->currentAim );
+
+		debounce = 500+(3-g_spskill.integer)*100;
+		TIMER_Set( self, "aimDebounce", Q_irand( debounce,debounce+1000 ) );
+	//	int debounce = 1000+(3-g_spskill.integer)*500;
+	//	TIMER_Set( self, "aimDebounce", Q_irand( debounce,debounce+2000 ) );
+	}
+}
diff --git a/codemp/game/NPC_goal.c b/codemp/game/NPC_goal.c
new file mode 100644
index 0000000..a541eb1
--- /dev/null
+++ b/codemp/game/NPC_goal.c
@@ -0,0 +1,267 @@
+//b_goal.cpp
+#include "b_local.h"
+#include "../icarus/Q3_Interface.h"
+
+extern qboolean FlyingCreature( gentity_t *ent );
+/*
+SetGoal
+*/
+
+void SetGoal( gentity_t *goal, float rating ) 
+{
+	NPCInfo->goalEntity = goal;
+//	NPCInfo->goalEntityNeed = rating;
+	NPCInfo->goalTime = level.time;
+//	NAV_ClearLastRoute(NPC);
+	if ( goal ) 
+	{
+//		Debug_NPCPrintf( NPC, debugNPCAI, DEBUG_LEVEL_INFO, "NPC_SetGoal: %s @ %s (%f)\n", goal->classname, vtos( goal->currentOrigin), rating );
+	}
+	else 
+	{
+//		Debug_NPCPrintf( NPC, debugNPCAI, DEBUG_LEVEL_INFO, "NPC_SetGoal: NONE\n" );
+	}
+}
+
+
+/*
+NPC_SetGoal
+*/
+
+void NPC_SetGoal( gentity_t *goal, float rating ) 
+{
+	if ( goal == NPCInfo->goalEntity ) 
+	{
+		return;
+	}
+
+	if ( !goal ) 
+	{
+//		Debug_NPCPrintf( NPC, debugNPCAI, DEBUG_LEVEL_ERROR, "NPC_SetGoal: NULL goal\n" );
+		return;
+	}
+
+	if ( goal->client ) 
+	{
+//		Debug_NPCPrintf( NPC, debugNPCAI, DEBUG_LEVEL_ERROR, "NPC_SetGoal: goal is a client\n" );
+		return;
+	}
+
+	if ( NPCInfo->goalEntity ) 
+	{
+//		Debug_NPCPrintf( NPC, debugNPCAI, DEBUG_LEVEL_INFO, "NPC_SetGoal: push %s\n", NPCInfo->goalEntity->classname );
+		NPCInfo->lastGoalEntity = NPCInfo->goalEntity;
+//		NPCInfo->lastGoalEntityNeed = NPCInfo->goalEntityNeed;
+	}
+
+	SetGoal( goal, rating );
+}
+
+
+/*
+NPC_ClearGoal
+*/
+
+void NPC_ClearGoal( void ) 
+{
+	gentity_t	*goal;
+
+	if ( !NPCInfo->lastGoalEntity ) 
+	{
+		SetGoal( NULL, 0.0 );
+		return;
+	}
+
+	goal = NPCInfo->lastGoalEntity;
+	NPCInfo->lastGoalEntity = NULL;
+//	NAV_ClearLastRoute(NPC);
+	if ( goal->inuse && !(goal->s.eFlags & EF_NODRAW) ) 
+	{
+//		Debug_NPCPrintf( NPC, debugNPCAI, DEBUG_LEVEL_INFO, "NPC_ClearGoal: pop %s\n", goal->classname );
+		SetGoal( goal, 0 );//, NPCInfo->lastGoalEntityNeed
+		return;
+	}
+
+	SetGoal( NULL, 0.0 );
+}
+
+/*
+-------------------------
+G_BoundsOverlap
+-------------------------
+*/
+
+qboolean G_BoundsOverlap(const vec3_t mins1, const vec3_t maxs1, const vec3_t mins2, const vec3_t maxs2)
+{//NOTE: flush up against counts as overlapping
+	if(mins1[0]>maxs2[0])
+		return qfalse;
+
+	if(mins1[1]>maxs2[1])
+		return qfalse;
+
+	if(mins1[2]>maxs2[2])
+		return qfalse;
+
+	if(maxs1[0]<mins2[0])
+		return qfalse;
+
+	if(maxs1[1]<mins2[1])
+		return qfalse;
+
+	if(maxs1[2]<mins2[2])
+		return qfalse;
+
+	return qtrue;
+}
+
+void NPC_ReachedGoal( void )
+{
+//	Debug_NPCPrintf( NPC, debugNPCAI, DEBUG_LEVEL_INFO, "UpdateGoal: reached goal entity\n" );
+	NPC_ClearGoal();
+	NPCInfo->goalTime = level.time;
+
+//MCG - Begin
+	NPCInfo->aiFlags &= ~NPCAI_MOVING;
+	ucmd.forwardmove = 0;
+	//Return that the goal was reached
+	trap_ICARUS_TaskIDComplete( NPC, TID_MOVE_NAV );
+//MCG - End
+}
+/*
+ReachedGoal
+
+id removed checks against waypoints and is now checking surfaces
+*/
+//qboolean NAV_HitNavGoal( vec3_t point, vec3_t mins, vec3_t maxs, gentity_t *goal, qboolean flying );
+qboolean ReachedGoal( gentity_t *goal ) 
+{
+	//FIXME: For script waypoints, need a special check
+/*
+	int		goalWpNum;
+	vec3_t	vec;
+	//vec3_t	angles;
+	float	delta;
+
+	if ( goal->flags & FL_NAVGOAL )
+	{//waypoint_navgoal
+		return NAV_HitNavGoal( NPC->currentOrigin, NPC->mins, NPC->maxs, goal, FlyingCreature( NPC ) );
+	}
+
+	if ( goal == NPCInfo->tempGoal && !(goal->flags & FL_NAVGOAL)) 
+	{//MUST touch waypoints, even if moving to it
+		//This is odd, it just checks to see if they are on the same
+		//surface and the tempGoal in in the FOV - does NOT check distance!
+		// are we on same surface?
+		
+		//FIXME: NPC->waypoint reset every frame, need to find it first
+		//Should we do that here?  (Still will do it only once per frame)
+		if ( NPC->waypoint >= 0 && NPC->waypoint < num_waypoints )
+		{
+			goalWpNum = NAV_FindWaypointAt ( goal->currentOrigin );
+			if ( NPC->waypoint != goalWpNum ) 
+			{
+				return qfalse;
+			}
+		}
+
+		VectorSubtract ( NPCInfo->tempGoal->currentOrigin, NPC->currentOrigin, vec);
+		//Who cares if it's in our FOV?!
+		/*
+		// is it in our FOV
+		vectoangles ( vec, angles );
+		delta = AngleDelta ( NPC->client->ps.viewangles[YAW], angles[YAW] );
+		if ( fabs ( delta ) > NPCInfo->stats.hfov ) 
+		{
+			return qfalse;
+		}
+		*/
+
+		/*
+		//If in the same waypoint as tempGoal, we're there, right?
+		if ( goal->waypoint >= 0 && goal->waypoint < num_waypoints )
+		{
+			if ( NPC->waypoint == goal->waypoint )
+			{
+				return qtrue;
+			}
+		}
+		*/
+
+/*
+		if ( VectorLengthSquared( vec ) < (64*64) )
+		{//Close enough
+			return qtrue;
+		}
+
+		return qfalse;
+	}
+*/
+	if ( NPCInfo->aiFlags & NPCAI_TOUCHED_GOAL ) 
+	{
+		NPCInfo->aiFlags &= ~NPCAI_TOUCHED_GOAL;
+		return qtrue;
+	}
+/*
+	if ( goal->s.eFlags & EF_NODRAW ) 
+	{
+		goalWpNum = NAV_FindWaypointAt( goal->currentOrigin );
+		if ( NPC->waypoint == goalWpNum ) 
+		{
+			return qtrue;
+		}
+		return qfalse;
+	}
+
+	if(goal->client && goal->health <= 0)
+	{//trying to get to dead guy
+		goalWpNum = NAV_FindWaypointAt( goal->currentOrigin );
+		if ( NPC->waypoint == goalWpNum ) 
+		{
+			VectorSubtract(NPC->currentOrigin, goal->currentOrigin, vec);
+			vec[2] = 0;
+			delta = VectorLengthSquared(vec);
+			if(delta <= 800)
+			{//with 20-30 of other guy's origin
+				return qtrue;
+			}
+		}
+	}
+*/	
+	return NAV_HitNavGoal( NPC->r.currentOrigin, NPC->r.mins, NPC->r.maxs, goal->r.currentOrigin, NPCInfo->goalRadius, FlyingCreature( NPC ) );
+}
+
+/*
+static gentity_t *UpdateGoal( void ) 
+
+Id removed a lot of shit here... doesn't seem to handle waypoints independantly of goalentity
+
+In fact, doesn't seem to be any waypoint info on entities at all any more?
+
+MCG - Since goal is ALWAYS goalEntity, took out a lot of sending goal entity pointers around for no reason
+*/
+
+gentity_t *UpdateGoal( void ) 
+{
+	gentity_t	*goal;
+
+	if ( !NPCInfo->goalEntity ) 
+	{
+		return NULL;
+	}
+
+	if ( !NPCInfo->goalEntity->inuse )
+	{//Somehow freed it, but didn't clear it
+		NPC_ClearGoal();
+		return NULL;
+	}
+
+	goal = NPCInfo->goalEntity;
+
+	if ( ReachedGoal( goal ) ) 
+	{
+		NPC_ReachedGoal();
+		goal = NULL;//so they don't keep trying to move to it
+	}//else if fail, need to tell script so?
+
+	return goal;
+}
diff --git a/codemp/game/NPC_misc.c b/codemp/game/NPC_misc.c
new file mode 100644
index 0000000..34e2d68
--- /dev/null
+++ b/codemp/game/NPC_misc.c
@@ -0,0 +1,73 @@
+//
+// NPC_misc.cpp
+//
+#include "b_local.h"
+#include "q_shared.h"
+
+/*
+Debug_Printf
+*/
+void Debug_Printf (vmCvar_t *cv, int debugLevel, char *fmt, ...)
+{
+	char		*color;
+	va_list		argptr;
+	char		msg[1024];
+
+	if (cv->value < debugLevel)
+		return;
+
+	if (debugLevel == DEBUG_LEVEL_DETAIL)
+		color = S_COLOR_WHITE;
+	else if (debugLevel == DEBUG_LEVEL_INFO)
+		color = S_COLOR_GREEN;
+	else if (debugLevel == DEBUG_LEVEL_WARNING)
+		color = S_COLOR_YELLOW;
+	else if (debugLevel == DEBUG_LEVEL_ERROR)
+		color = S_COLOR_RED;
+	else
+		color = S_COLOR_RED;
+
+	va_start (argptr,fmt);
+	vsprintf (msg, fmt, argptr);
+	va_end (argptr);
+
+	Com_Printf("%s%5i:%s", color, level.time, msg);
+}
+
+
+/*
+Debug_NPCPrintf
+*/
+void Debug_NPCPrintf (gentity_t *printNPC, vmCvar_t *cv, int debugLevel, char *fmt, ...)
+{
+	int			color;
+	va_list		argptr;
+	char		msg[1024];
+
+	if (cv->value < debugLevel)
+	{
+		return;
+	}
+
+//	if ( debugNPCName.string[0] && Q_stricmp( debugNPCName.string, printNPC->targetname) != 0 ) 
+//	{
+//		return;
+//	}
+
+	if (debugLevel == DEBUG_LEVEL_DETAIL)
+		color = COLOR_WHITE;
+	else if (debugLevel == DEBUG_LEVEL_INFO)
+		color = COLOR_GREEN;
+	else if (debugLevel == DEBUG_LEVEL_WARNING)
+		color = COLOR_YELLOW;
+	else if (debugLevel == DEBUG_LEVEL_ERROR)
+		color = COLOR_RED;
+	else
+		color = COLOR_RED;
+
+	va_start (argptr,fmt);
+	vsprintf (msg, fmt, argptr);
+	va_end (argptr);
+
+	Com_Printf ("%c%c%5i (%s) %s", Q_COLOR_ESCAPE, color, level.time, printNPC->targetname, msg);
+}
diff --git a/codemp/game/NPC_move.c b/codemp/game/NPC_move.c
new file mode 100644
index 0000000..3ab12fb
--- /dev/null
+++ b/codemp/game/NPC_move.c
@@ -0,0 +1,505 @@
+//
+// NPC_move.cpp
+//
+#include "b_local.h"
+#include "g_nav.h"
+#include "anims.h"
+
+void G_Cylinder( vec3_t start, vec3_t end, float radius, vec3_t color );
+
+qboolean G_BoundsOverlap(const vec3_t mins1, const vec3_t maxs1, const vec3_t mins2, const vec3_t maxs2);
+int NAV_Steer( gentity_t *self, vec3_t dir, float distance );
+extern int GetTime ( int lastTime );
+
+navInfo_t	frameNavInfo;
+extern qboolean FlyingCreature( gentity_t *ent );
+
+#include "../namespace_begin.h"
+extern qboolean PM_InKnockDown( playerState_t *ps );
+#include "../namespace_end.h"
+
+/*
+-------------------------
+NPC_ClearPathToGoal
+-------------------------
+*/
+
+qboolean NPC_ClearPathToGoal( vec3_t dir, gentity_t *goal )
+{
+	trace_t	trace;
+	float radius, dist, tFrac;
+
+	//FIXME: What does do about area portals?  THIS IS BROKEN
+	//if ( gi.inPVS( NPC->r.currentOrigin, goal->r.currentOrigin ) == qfalse )
+	//	return qfalse;
+
+	//Look ahead and see if we're clear to move to our goal position
+	if ( NAV_CheckAhead( NPC, goal->r.currentOrigin, &trace, ( NPC->clipmask & ~CONTENTS_BODY )|CONTENTS_BOTCLIP ) )
+	{
+		//VectorSubtract( goal->r.currentOrigin, NPC->r.currentOrigin, dir );
+		return qtrue;
+	}
+
+	if (!FlyingCreature(NPC))
+	{
+		//See if we're too far above
+		if ( fabs( NPC->r.currentOrigin[2] - goal->r.currentOrigin[2] ) > 48 )
+			return qfalse;
+	}
+
+	//This is a work around
+	radius = ( NPC->r.maxs[0] > NPC->r.maxs[1] ) ? NPC->r.maxs[0] : NPC->r.maxs[1];
+	dist = Distance( NPC->r.currentOrigin, goal->r.currentOrigin );
+	tFrac = 1.0f - ( radius / dist );
+
+	if ( trace.fraction >= tFrac )
+		return qtrue;
+
+	//See if we're looking for a navgoal
+	if ( goal->flags & FL_NAVGOAL )
+	{
+		//Okay, didn't get all the way there, let's see if we got close enough:
+		if ( NAV_HitNavGoal( trace.endpos, NPC->r.mins, NPC->r.maxs, goal->r.currentOrigin, NPCInfo->goalRadius, FlyingCreature( NPC ) ) )
+		{
+			//VectorSubtract(goal->r.currentOrigin, NPC->r.currentOrigin, dir);
+			return qtrue;
+		}
+	}
+
+	return qfalse;
+}
+
+/*
+-------------------------
+NPC_CheckCombatMove
+-------------------------
+*/
+
+ID_INLINE qboolean NPC_CheckCombatMove( void )
+{
+	//return NPCInfo->combatMove;
+	if ( ( NPCInfo->goalEntity && NPC->enemy && NPCInfo->goalEntity == NPC->enemy ) || ( NPCInfo->combatMove ) )
+	{
+		return qtrue;
+	}
+
+	if ( NPCInfo->goalEntity && NPCInfo->watchTarget )
+	{
+		if ( NPCInfo->goalEntity != NPCInfo->watchTarget )
+		{
+			return qtrue;
+		}
+	}
+
+	return qfalse;
+}
+
+/*
+-------------------------
+NPC_LadderMove
+-------------------------
+*/
+
+static void NPC_LadderMove( vec3_t dir )
+{
+	//FIXME: this doesn't guarantee we're facing ladder
+	//ALSO: Need to be able to get off at top
+	//ALSO: Need to play an anim
+	//ALSO: Need transitionary anims?
+	
+	if ( ( dir[2] > 0 ) || ( dir[2] < 0 && NPC->client->ps.groundEntityNum == ENTITYNUM_NONE ) )
+	{
+		//Set our movement direction
+		ucmd.upmove = (dir[2] > 0) ? 127 : -127;
+
+		//Don't move around on XY
+		ucmd.forwardmove = ucmd.rightmove = 0;
+	}
+}
+
+/*
+-------------------------
+NPC_GetMoveInformation
+-------------------------
+*/
+
+ID_INLINE qboolean NPC_GetMoveInformation( vec3_t dir, float *distance )
+{
+	//NOTENOTE: Use path stacks!
+
+	//Make sure we have somewhere to go
+	if ( NPCInfo->goalEntity == NULL )
+		return qfalse;
+
+	//Get our move info
+	VectorSubtract( NPCInfo->goalEntity->r.currentOrigin, NPC->r.currentOrigin, dir );
+	*distance = VectorNormalize( dir );
+	
+	VectorCopy( NPCInfo->goalEntity->r.currentOrigin, NPCInfo->blockedDest );
+
+	return qtrue;
+}
+
+/*
+-------------------------
+NAV_GetLastMove
+-------------------------
+*/
+
+void NAV_GetLastMove( navInfo_t *info )
+{
+	*info = frameNavInfo;
+}
+
+/*
+-------------------------
+NPC_GetMoveDirection
+-------------------------
+*/
+
+qboolean NPC_GetMoveDirection( vec3_t out, float *distance )
+{
+	vec3_t		angles;
+
+	//Clear the struct
+	memset( &frameNavInfo, 0, sizeof( frameNavInfo ) );
+
+	//Get our movement, if any
+	if ( NPC_GetMoveInformation( frameNavInfo.direction, &frameNavInfo.distance ) == qfalse )
+		return qfalse;
+
+	//Setup the return value
+	*distance = frameNavInfo.distance;
+
+	//For starters
+	VectorCopy( frameNavInfo.direction, frameNavInfo.pathDirection );
+
+	//If on a ladder, move appropriately
+	if ( NPC->watertype & CONTENTS_LADDER )
+	{
+		NPC_LadderMove( frameNavInfo.direction );
+		return qtrue;
+	}
+
+	//Attempt a straight move to goal
+	if ( NPC_ClearPathToGoal( frameNavInfo.direction, NPCInfo->goalEntity ) == qfalse )
+	{
+		//See if we're just stuck
+		if ( NAV_MoveToGoal( NPC, &frameNavInfo ) == WAYPOINT_NONE )
+		{
+			//Can't reach goal, just face
+			vectoangles( frameNavInfo.direction, angles );
+			NPCInfo->desiredYaw	= AngleNormalize360( angles[YAW] );		
+			VectorCopy( frameNavInfo.direction, out );
+			*distance = frameNavInfo.distance;
+			return qfalse;
+		}
+
+		frameNavInfo.flags |= NIF_MACRO_NAV;
+	}
+
+	//Avoid any collisions on the way
+	if ( NAV_AvoidCollision( NPC, NPCInfo->goalEntity, &frameNavInfo ) == qfalse )
+	{
+		//FIXME: Emit a warning, this is a worst case scenario
+		//FIXME: if we have a clear path to our goal (exluding bodies), but then this
+		//			check (against bodies only) fails, shouldn't we fall back 
+		//			to macro navigation?  Like so:
+		if ( !(frameNavInfo.flags&NIF_MACRO_NAV) )
+		{//we had a clear path to goal and didn't try macro nav, but can't avoid collision so try macro nav here
+			//See if we're just stuck
+			if ( NAV_MoveToGoal( NPC, &frameNavInfo ) == WAYPOINT_NONE )
+			{
+				//Can't reach goal, just face
+				vectoangles( frameNavInfo.direction, angles );
+				NPCInfo->desiredYaw	= AngleNormalize360( angles[YAW] );		
+				VectorCopy( frameNavInfo.direction, out );
+				*distance = frameNavInfo.distance;
+				return qfalse;
+			}
+
+			frameNavInfo.flags |= NIF_MACRO_NAV;
+		}
+	}
+
+	//Setup the return values
+	VectorCopy( frameNavInfo.direction, out );
+	*distance = frameNavInfo.distance;
+
+	return qtrue;
+}
+
+/*
+-------------------------
+NPC_GetMoveDirectionAltRoute
+-------------------------
+*/
+extern int	NAVNEW_MoveToGoal( gentity_t *self, navInfo_t *info );
+extern qboolean NAVNEW_AvoidCollision( gentity_t *self, gentity_t *goal, navInfo_t *info, qboolean setBlockedInfo, int blockedMovesLimit );
+qboolean NPC_GetMoveDirectionAltRoute( vec3_t out, float *distance, qboolean tryStraight )
+{
+	vec3_t		angles;
+
+	NPCInfo->aiFlags &= ~NPCAI_BLOCKED;
+
+	//Clear the struct
+	memset( &frameNavInfo, 0, sizeof( frameNavInfo ) );
+
+	//Get our movement, if any
+	if ( NPC_GetMoveInformation( frameNavInfo.direction, &frameNavInfo.distance ) == qfalse )
+		return qfalse;
+
+	//Setup the return value
+	*distance = frameNavInfo.distance;
+
+	//For starters
+	VectorCopy( frameNavInfo.direction, frameNavInfo.pathDirection );
+
+	//If on a ladder, move appropriately
+	if ( NPC->watertype & CONTENTS_LADDER )
+	{
+		NPC_LadderMove( frameNavInfo.direction );
+		return qtrue;
+	}
+
+	//Attempt a straight move to goal
+	if ( !tryStraight || NPC_ClearPathToGoal( frameNavInfo.direction, NPCInfo->goalEntity ) == qfalse )
+	{//blocked
+		//Can't get straight to goal, use macro nav
+		if ( NAVNEW_MoveToGoal( NPC, &frameNavInfo ) == WAYPOINT_NONE )
+		{
+			//Can't reach goal, just face
+			vectoangles( frameNavInfo.direction, angles );
+			NPCInfo->desiredYaw	= AngleNormalize360( angles[YAW] );		
+			VectorCopy( frameNavInfo.direction, out );
+			*distance = frameNavInfo.distance;
+			return qfalse;
+		}
+		//else we are on our way
+		frameNavInfo.flags |= NIF_MACRO_NAV;
+	}
+	else
+	{//we have no architectural problems, see if there are ents inthe way and try to go around them
+		//not blocked
+		if ( d_altRoutes.integer )
+		{//try macro nav
+			navInfo_t	tempInfo;
+			memcpy( &tempInfo, &frameNavInfo, sizeof( tempInfo ) );
+			if ( NAVNEW_AvoidCollision( NPC, NPCInfo->goalEntity, &tempInfo, qtrue, 5 ) == qfalse )
+			{//revert to macro nav
+				//Can't get straight to goal, dump tempInfo and use macro nav
+				if ( NAVNEW_MoveToGoal( NPC, &frameNavInfo ) == WAYPOINT_NONE )
+				{
+					//Can't reach goal, just face
+					vectoangles( frameNavInfo.direction, angles );
+					NPCInfo->desiredYaw	= AngleNormalize360( angles[YAW] );		
+					VectorCopy( frameNavInfo.direction, out );
+					*distance = frameNavInfo.distance;
+					return qfalse;
+				}
+				//else we are on our way
+				frameNavInfo.flags |= NIF_MACRO_NAV;
+			}
+			else
+			{//otherwise, either clear or can avoid
+				memcpy( &frameNavInfo, &tempInfo, sizeof( frameNavInfo ) );
+			}
+		}
+		else
+		{//OR: just give up
+			if ( NAVNEW_AvoidCollision( NPC, NPCInfo->goalEntity, &frameNavInfo, qtrue, 30 ) == qfalse )
+			{//give up
+				return qfalse;
+			}
+		}
+	}
+
+	//Setup the return values
+	VectorCopy( frameNavInfo.direction, out );
+	*distance = frameNavInfo.distance;
+
+	return qtrue;
+}
+
+void G_UcmdMoveForDir( gentity_t *self, usercmd_t *cmd, vec3_t dir )
+{
+	vec3_t	forward, right;
+	float	fDot, rDot;
+
+	AngleVectors( self->r.currentAngles, forward, right, NULL );
+
+	dir[2] = 0;
+	VectorNormalize( dir );
+	//NPCs cheat and store this directly because converting movement into a ucmd loses precision
+	VectorCopy( dir, self->client->ps.moveDir );
+
+	fDot = DotProduct( forward, dir ) * 127.0f;
+	rDot = DotProduct( right, dir ) * 127.0f;
+	//Must clamp this because DotProduct is not guaranteed to return a number within -1 to 1, and that would be bad when we're shoving this into a signed byte
+	if ( fDot > 127.0f )
+	{
+		fDot = 127.0f;
+	}
+	if ( fDot < -127.0f )
+	{
+		fDot = -127.0f;
+	}
+	if ( rDot > 127.0f )
+	{
+		rDot = 127.0f;
+	}
+	if ( rDot < -127.0f )
+	{
+		rDot = -127.0f;
+	}
+	cmd->forwardmove = floor(fDot);
+	cmd->rightmove = floor(rDot);
+
+	/*
+	vec3_t	wishvel;
+	for ( int i = 0 ; i < 3 ; i++ ) 
+	{
+		wishvel[i] = forward[i]*cmd->forwardmove + right[i]*cmd->rightmove;
+	}
+	VectorNormalize( wishvel );
+	if ( !VectorCompare( wishvel, dir ) )
+	{
+		Com_Printf( "PRECISION LOSS: %s != %s\n", vtos(wishvel), vtos(dir) );
+	}
+	*/
+}
+
+/*
+-------------------------
+NPC_MoveToGoal
+
+  Now assumes goal is goalEntity, was no reason for it to be otherwise
+-------------------------
+*/
+#if	AI_TIMERS
+extern int navTime;
+#endif//	AI_TIMERS
+qboolean NPC_MoveToGoal( qboolean tryStraight ) 
+{
+	float	distance;
+	vec3_t	dir;
+
+#if	AI_TIMERS
+	int	startTime = GetTime(0);
+#endif//	AI_TIMERS
+	//If taking full body pain, don't move
+	if ( PM_InKnockDown( &NPC->client->ps ) || ( ( NPC->s.legsAnim >= BOTH_PAIN1 ) && ( NPC->s.legsAnim <= BOTH_PAIN18 ) ) )
+	{
+		return qtrue;
+	}
+
+	/*
+	if( NPC->s.eFlags & EF_LOCKED_TO_WEAPON )
+	{//If in an emplaced gun, never try to navigate!
+		return qtrue;
+	}
+	*/
+	//rwwFIXMEFIXME: emplaced support
+
+	//FIXME: if can't get to goal & goal is a target (enemy), try to find a waypoint that has line of sight to target, at least?
+	//Get our movement direction
+#if 1
+	if ( NPC_GetMoveDirectionAltRoute( dir, &distance, tryStraight ) == qfalse )
+#else
+	if ( NPC_GetMoveDirection( dir, &distance ) == qfalse )
+#endif
+		return qfalse;
+
+	NPCInfo->distToGoal		= distance;
+
+	//Convert the move to angles
+	vectoangles( dir, NPCInfo->lastPathAngles );
+	if ( (ucmd.buttons&BUTTON_WALKING) )
+	{
+		NPC->client->ps.speed = NPCInfo->stats.walkSpeed;
+	}
+	else
+	{
+		NPC->client->ps.speed = NPCInfo->stats.runSpeed;
+	}
+
+	//FIXME: still getting ping-ponging in certain cases... !!!  Nav/avoidance error?  WTF???!!!
+	//If in combat move, then move directly towards our goal
+	if ( NPC_CheckCombatMove() )
+	{//keep current facing
+		G_UcmdMoveForDir( NPC, &ucmd, dir );
+	}
+	else
+	{//face our goal
+		//FIXME: strafe instead of turn if change in dir is small and temporary
+		NPCInfo->desiredPitch	= 0.0f;
+		NPCInfo->desiredYaw		= AngleNormalize360( NPCInfo->lastPathAngles[YAW] );
+		
+		//Pitch towards the goal and also update if flying or swimming
+		if ( (NPC->client->ps.eFlags2&EF2_FLYING) )//moveType == MT_FLYSWIM )
+		{
+			NPCInfo->desiredPitch = AngleNormalize360( NPCInfo->lastPathAngles[PITCH] );
+			
+			if ( dir[2] )
+			{
+				float scale = (dir[2] * distance);
+				if ( scale > 64 )
+				{
+					scale = 64;
+				}
+				else if ( scale < -64 )
+				{
+					scale = -64;
+				}
+				NPC->client->ps.velocity[2] = scale;
+				//NPC->client->ps.velocity[2] = (dir[2] > 0) ? 64 : -64;
+			}
+		}
+
+		//Set any final info
+		ucmd.forwardmove = 127;
+	}
+
+#if	AI_TIMERS
+	navTime += GetTime( startTime );
+#endif//	AI_TIMERS
+	return qtrue;
+}
+
+/*
+-------------------------
+void NPC_SlideMoveToGoal( void )
+
+  Now assumes goal is goalEntity, if want to use tempGoal, you set that before calling the func
+-------------------------
+*/
+qboolean NPC_SlideMoveToGoal( void )
+{
+	float	saveYaw = NPC->client->ps.viewangles[YAW];
+	qboolean ret;
+
+	NPCInfo->combatMove = qtrue;
+	
+	ret = NPC_MoveToGoal( qtrue );
+
+	NPCInfo->desiredYaw	= saveYaw;
+
+	return ret;
+}
+
+
+/*
+-------------------------
+NPC_ApplyRoff
+-------------------------
+*/
+
+void NPC_ApplyRoff(void)
+{
+	BG_PlayerStateToEntityState( &NPC->client->ps, &NPC->s, qfalse );
+	//VectorCopy ( NPC->r.currentOrigin, NPC->lastOrigin );
+	//rwwFIXMEFIXME: Any significance to this?
+
+	// use the precise origin for linking
+	trap_LinkEntity(NPC);
+}
diff --git a/codemp/game/NPC_reactions.c b/codemp/game/NPC_reactions.c
new file mode 100644
index 0000000..42f794f
--- /dev/null
+++ b/codemp/game/NPC_reactions.c
@@ -0,0 +1,1125 @@
+//NPC_reactions.cpp
+#include "b_local.h"
+#include "anims.h"
+#include "w_saber.h"
+
+extern qboolean G_CheckForStrongAttackMomentum( gentity_t *self );
+extern void G_AddVoiceEvent( gentity_t *self, int event, int speakDebounceTime );
+extern void G_SoundOnEnt( gentity_t *ent, soundChannel_t channel, const char *soundPath );
+extern void cgi_S_StartSound( vec3_t origin, int entityNum, int entchannel, sfxHandle_t sfx );
+extern qboolean Q3_TaskIDPending( gentity_t *ent, taskID_t taskType );
+extern qboolean NPC_CheckLookTarget( gentity_t *self );
+extern void NPC_SetLookTarget( gentity_t *self, int entNum, int clearTime );
+extern qboolean Jedi_WaitingAmbush( gentity_t *self );
+extern void Jedi_Ambush( gentity_t *self );
+extern qboolean NPC_SomeoneLookingAtMe(gentity_t *ent);
+
+#include "../namespace_begin.h"
+extern qboolean BG_SaberInSpecialAttack( int anim );
+extern qboolean PM_SpinningSaberAnim( int anim );
+extern qboolean PM_SpinningAnim( int anim );
+extern qboolean PM_InKnockDown( playerState_t *ps );
+extern qboolean BG_FlippingAnim( int anim );
+extern qboolean PM_RollingAnim( int anim );
+extern qboolean PM_InCartwheel( int anim );
+extern qboolean BG_CrouchAnim( int anim );
+#include "../namespace_end.h"
+
+extern int	teamLastEnemyTime[];
+extern int killPlayerTimer;
+
+//float g_crosshairEntDist = Q3_INFINITE;
+//int g_crosshairSameEntTime = 0;
+//int g_crosshairEntNum = ENTITYNUM_NONE;
+//int g_crosshairEntTime = 0;
+
+/*
+-------------------------
+NPC_CheckAttacker
+-------------------------
+*/
+
+static void NPC_CheckAttacker( gentity_t *other, int mod )
+{
+	//FIXME: I don't see anything in here that would stop teammates from taking a teammate
+	//			as an enemy.  Ideally, there would be code before this to prevent that from
+	//			happening, but that is presumptuous.
+	
+	//valid ent - FIXME: a VALIDENT macro would be nice here
+	if ( !other )
+		return;
+
+	if ( other == NPC )
+		return;
+
+	if ( !other->inuse )
+		return;
+
+	//Don't take a target that doesn't want to be
+	if ( other->flags & FL_NOTARGET ) 
+		return;
+
+//	if ( NPC->svFlags & SVF_LOCKEDENEMY )
+//	{//IF LOCKED, CANNOT CHANGE ENEMY!!!!!
+//		return;
+//	}
+	//rwwFIXMEFIXME: support this
+
+	//If we haven't taken a target, just get mad
+	if ( NPC->enemy == NULL )//was using "other", fixed to NPC
+	{
+		G_SetEnemy( NPC, other );
+		return;
+	}
+
+	//we have an enemy, see if he's dead
+	if ( NPC->enemy->health <= 0 )
+	{
+		G_ClearEnemy( NPC );
+		G_SetEnemy( NPC, other );
+		return;
+	}
+
+	//Don't take the same enemy again
+	if ( other == NPC->enemy )
+		return;
+
+	if ( NPC->client->ps.weapon == WP_SABER )
+	{//I'm a jedi
+		if ( mod == MOD_SABER )
+		{//I was hit by a saber  FIXME: what if this was a thrown saber?
+			//always switch to this enemy if I'm a jedi and hit by another saber
+			G_ClearEnemy( NPC );
+			G_SetEnemy( NPC, other );
+			return;
+		}
+	}
+	//Special case player interactions
+	if ( other == &g_entities[0] )
+	{
+		//Account for the skill level to skew the results
+		float	luckThreshold;
+
+		switch ( g_spskill.integer )
+		{
+		//Easiest difficulty, mild chance of picking up the player
+		case 0:
+			luckThreshold = 0.9f;
+			break;
+
+		//Medium difficulty, half-half chance of picking up the player
+		case 1:
+			luckThreshold = 0.5f;
+			break;
+
+		//Hardest difficulty, always turn on attacking player
+		case 2:
+		default:
+			luckThreshold = 0.0f;
+			break;
+		}
+
+		//Randomly pick up the target
+		if ( random() > luckThreshold )
+		{
+			G_ClearEnemy( other );
+			other->enemy = NPC;
+		}
+
+		return;
+	}
+}
+
+void NPC_SetPainEvent( gentity_t *self )
+{
+	if ( !self->NPC || !(self->NPC->aiFlags&NPCAI_DIE_ON_IMPACT) )
+	{
+	// no more borg
+	//	if( self->client->playerTeam != TEAM_BORG )
+	//	{
+			//if ( !Q3_TaskIDPending( self, TID_CHAN_VOICE ) )
+			if (!trap_ICARUS_TaskIDPending(self, TID_CHAN_VOICE) && self->client)
+			{
+				//G_AddEvent( self, EV_PAIN, floor((float)self->health/self->max_health*100.0f) );
+				G_AddEvent( self, EV_PAIN, floor((float)self->health/self->client->ps.stats[STAT_MAX_HEALTH]*100.0f) );
+				//rwwFIXMEFIXME: Do this properly?
+			}
+	//	}
+	}
+}
+
+/*
+-------------------------
+NPC_GetPainChance
+-------------------------
+*/
+
+float NPC_GetPainChance( gentity_t *self, int damage )
+{
+	float pain_chance;
+	if ( !self->enemy )
+	{//surprised, always take pain
+		return 1.0f;
+	}
+
+	if (!self->client)
+	{
+		return 1.0f;
+	}
+
+	//if ( damage > self->max_health/2.0f )
+	if (damage > self->client->ps.stats[STAT_MAX_HEALTH]/2.0f)
+	{
+		return 1.0f;
+	}
+
+	pain_chance = (float)(self->client->ps.stats[STAT_MAX_HEALTH]-self->health)/(self->client->ps.stats[STAT_MAX_HEALTH]*2.0f) + (float)damage/(self->client->ps.stats[STAT_MAX_HEALTH]/2.0f);
+	switch ( g_spskill.integer )
+	{
+	case 0:	//easy
+		//return 0.75f;
+		break;
+
+	case 1://med
+		pain_chance *= 0.5f;
+		//return 0.35f;
+		break;
+
+	case 2://hard
+	default:
+		pain_chance *= 0.1f;
+		//return 0.05f;
+		break;
+	}
+	//Com_Printf( "%s: %4.2f\n", self->NPC_type, pain_chance );
+	return pain_chance;
+}
+
+/*
+-------------------------
+NPC_ChoosePainAnimation
+-------------------------
+*/
+
+#define	MIN_PAIN_TIME	200
+
+extern int G_PickPainAnim( gentity_t *self, vec3_t point, int damage, int hitLoc );
+void NPC_ChoosePainAnimation( gentity_t *self, gentity_t *other, vec3_t point, int damage, int mod, int hitLoc, int voiceEvent )
+{
+	int		pain_anim = -1;
+	float	pain_chance;
+	
+	//If we've already taken pain, then don't take it again
+	if ( level.time < self->painDebounceTime && /*mod != MOD_ELECTROCUTE &&*/ mod != MOD_MELEE ) //rwwFIXMEFIXME: MOD_ELECTROCUTE
+	{//FIXME: if hit while recoving from losing a saber lock, we should still play a pain anim?
+		return;
+	}
+	
+	if ( self->s.weapon == WP_THERMAL && self->client->ps.weaponTime > 0 )
+	{//don't interrupt thermal throwing anim
+		return;
+	}
+	else if ( self->client->NPC_class == CLASS_GALAKMECH )
+	{
+		if ( hitLoc == HL_GENERIC1 )
+		{//hit the antenna!
+			pain_chance = 1.0f;
+		//	self->s.powerups |= ( 1 << PW_SHOCKED );
+		//	self->client->ps.powerups[PW_SHOCKED] = level.time + Q_irand( 500, 2500 );
+			//rwwFIXMEFIXME: support for this
+		}
+	//	else if ( self->client->ps.powerups[PW_GALAK_SHIELD] )
+	//	{//shield up
+	//		return;
+	//	}
+		//rwwFIXMEFIXME: and this
+		else if ( self->health > 200 && damage < 100 )
+		{//have a *lot* of health
+			pain_chance = 0.05f;
+		}
+		else
+		{//the lower my health and greater the damage, the more likely I am to play a pain anim
+			pain_chance = (200.0f-self->health)/100.0f + damage/50.0f;
+		}
+	}
+	else if ( self->client && self->client->playerTeam == NPCTEAM_PLAYER && other && !other->s.number )
+	{//ally shot by player always complains
+		pain_chance = 1.1f;
+	}
+	else 
+	{
+		if ( other && other->s.weapon == WP_SABER || /*mod == MOD_ELECTROCUTE ||*/ mod == MOD_CRUSH/*FIXME:MOD_FORCE_GRIP*/ )
+		{
+			pain_chance = 1.0f;//always take pain from saber
+		}
+		else if ( mod == MOD_MELEE )
+		{//higher in rank (skill) we are, less likely we are to be fazed by a punch
+			pain_chance = 1.0f - ((RANK_CAPTAIN-self->NPC->rank)/(float)RANK_CAPTAIN);
+		}
+		else if ( self->client->NPC_class == CLASS_PROTOCOL )
+		{
+			pain_chance = 1.0f;
+		}
+		else
+		{
+			pain_chance = NPC_GetPainChance( self, damage );
+		}
+		if ( self->client->NPC_class == CLASS_DESANN )
+		{
+			pain_chance *= 0.5f;
+		}
+	}
+
+	//See if we're going to flinch
+	if ( random() < pain_chance )
+	{
+		int animLength;
+
+		//Pick and play our animation
+		if ( self->client->ps.fd.forceGripBeingGripped < level.time )
+		{//not being force-gripped or force-drained
+			if ( /*G_CheckForStrongAttackMomentum( self ) //rwwFIXMEFIXME: Is this needed?
+				||*/ PM_SpinningAnim( self->client->ps.legsAnim )
+				|| BG_SaberInSpecialAttack( self->client->ps.torsoAnim )
+				|| PM_InKnockDown( &self->client->ps )
+				|| PM_RollingAnim( self->client->ps.legsAnim )
+				|| (BG_FlippingAnim( self->client->ps.legsAnim )&&!PM_InCartwheel( self->client->ps.legsAnim )) )
+			{//strong attacks, rolls, knockdowns, flips and spins cannot be interrupted by pain
+			}
+			else
+			{//play an anim
+				int parts;
+
+				if ( self->client->NPC_class == CLASS_GALAKMECH )
+				{//only has 1 for now
+					//FIXME: never plays this, it seems...
+					pain_anim = BOTH_PAIN1;
+				}
+				else if ( mod == MOD_MELEE )
+				{
+					pain_anim = BG_PickAnim( self->localAnimIndex, BOTH_PAIN2, BOTH_PAIN3 );
+				}
+				else if ( self->s.weapon == WP_SABER )
+				{//temp HACK: these are the only 2 pain anims that look good when holding a saber
+					pain_anim = BG_PickAnim( self->localAnimIndex, BOTH_PAIN2, BOTH_PAIN3 );
+				}
+				/*
+				else if ( mod != MOD_ELECTROCUTE )
+				{
+					pain_anim = G_PickPainAnim( self, point, damage, hitLoc );
+				}
+				*/
+
+				if ( pain_anim == -1 )
+				{
+					pain_anim = BG_PickAnim( self->localAnimIndex, BOTH_PAIN1, BOTH_PAIN18 );
+				}
+				self->client->ps.fd.saberAnimLevel = FORCE_LEVEL_1;//next attack must be a quick attack
+				self->client->ps.saberMove = LS_READY;//don't finish whatever saber move you may have been in
+				parts = SETANIM_BOTH;
+				if ( BG_CrouchAnim( self->client->ps.legsAnim ) || PM_InCartwheel( self->client->ps.legsAnim ) )
+				{
+					parts = SETANIM_LEGS;
+				}
+
+				if (pain_anim != -1)
+				{
+					NPC_SetAnim( self, parts, pain_anim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+				}
+			}
+			if ( voiceEvent != -1 )
+			{
+				G_AddVoiceEvent( self, voiceEvent, Q_irand( 2000, 4000 ) );
+			}
+			else
+			{
+				NPC_SetPainEvent( self );
+			}
+		}
+		else
+		{
+			G_AddVoiceEvent( self, Q_irand(EV_CHOKE1, EV_CHOKE3), 0 );
+		}
+		
+		//Setup the timing for it
+		/*
+		if ( mod == MOD_ELECTROCUTE )
+		{
+			self->painDebounceTime = level.time + 4000;
+		}
+		*/
+		animLength = bgAllAnims[self->localAnimIndex].anims[pain_anim].numFrames * fabs((float)(bgHumanoidAnimations[pain_anim].frameLerp));
+
+		self->painDebounceTime = level.time + animLength;
+		self->client->ps.weaponTime = 0;
+	}
+}
+
+/*
+===============
+NPC_Pain
+===============
+*/
+void NPC_Pain(gentity_t *self, gentity_t *attacker, int damage)
+{
+	team_t otherTeam = TEAM_FREE;
+	int		voiceEvent = -1;
+	gentity_t *other = attacker;
+	int mod = gPainMOD;
+	int hitLoc = gPainHitLoc;
+	vec3_t point;
+
+	VectorCopy(gPainPoint, point);
+
+	if ( self->NPC == NULL ) 
+		return;
+
+	if ( other == NULL ) 
+		return;
+
+	//or just remove ->pain in player_die?
+	if ( self->client->ps.pm_type == PM_DEAD )
+		return;
+
+	if ( other == self ) 
+		return;
+
+	//MCG: Ignore damage from your own team for now
+	if ( other->client )
+	{
+		otherTeam = other->client->playerTeam;
+	//	if ( otherTeam == TEAM_DISGUISE )
+	//	{
+	//		otherTeam = TEAM_PLAYER;
+	//	}
+	}
+
+	if ( self->client->playerTeam 
+		&& other->client 
+		&& otherTeam == self->client->playerTeam 
+	/*	&& (!player->client->ps.viewEntity || other->s.number != player->client->ps.viewEntity)*/) 
+	//rwwFIXMEFIXME: Will need modification when player controllable npcs are done
+	{//hit by a teammate
+		if ( other != self->enemy && self != other->enemy )
+		{//we weren't already enemies
+			if ( self->enemy || other->enemy 
+				
+				//|| (other->s.number&&other->s.number!=player->client->ps.viewEntity) 
+				//rwwFIXMEFIXME: same
+
+				/*|| (!other->s.number&&Q_irand( 0, 3 ))*/ )
+			{//if one of us actually has an enemy already, it's okay, just an accident OR wasn't hit by player or someone controlled by player OR player hit ally and didn't get 25% chance of getting mad (FIXME:accumulate anger+base on diff?)
+				//FIXME: player should have to do a certain amount of damage to ally or hit them several times to make them mad
+				//Still run pain and flee scripts
+				if ( self->client && self->NPC )
+				{//Run any pain instructions
+					if ( self->health <= (self->client->ps.stats[STAT_MAX_HEALTH]/3) && G_ActivateBehavior(self, BSET_FLEE) )
+					{
+						
+					}
+					else// if( VALIDSTRING( self->behaviorSet[BSET_PAIN] ) )
+					{
+						G_ActivateBehavior(self, BSET_PAIN);
+					}
+				}
+				if ( damage != -1 )
+				{//-1 == don't play pain anim
+					//Set our proper pain animation
+					if ( Q_irand( 0, 1 ) )
+					{
+						NPC_ChoosePainAnimation( self, other, point, damage, mod, hitLoc, EV_FFWARN );
+					}
+					else
+					{
+						NPC_ChoosePainAnimation( self, other, point, damage, mod, hitLoc, -1 );
+					}
+				}
+				return;
+			}
+			else if ( self->NPC && !other->s.number )//should be assumed, but...
+			{//dammit, stop that!
+				if ( self->NPC->charmedTime )
+				{//mindtricked
+					return;
+				}
+				else if ( self->NPC->ffireCount < 3+((2-g_spskill.integer)*2) )
+				{//not mad enough yet
+					//Com_Printf( "chck: %d < %d\n", self->NPC->ffireCount, 3+((2-g_spskill.integer)*2) );
+					if ( damage != -1 )
+					{//-1 == don't play pain anim
+						//Set our proper pain animation
+						if ( Q_irand( 0, 1 ) )
+						{
+							NPC_ChoosePainAnimation( self, other, point, damage, mod, hitLoc, EV_FFWARN );
+						}
+						else
+						{
+							NPC_ChoosePainAnimation( self, other, point, damage, mod, hitLoc, -1 );
+						}
+					}
+					return;
+				}
+				else if ( G_ActivateBehavior( self, BSET_FFIRE ) )
+				{//we have a specific script to run, so do that instead
+					return;
+				}
+				else
+				{//okay, we're going to turn on our ally, we need to set and lock our enemy and put ourselves in a bstate that lets us attack him (and clear any flags that would stop us)
+					self->NPC->blockedSpeechDebounceTime = 0;
+					voiceEvent = EV_FFTURN;
+					self->NPC->behaviorState = self->NPC->tempBehavior = self->NPC->defaultBehavior = BS_DEFAULT;
+					other->flags &= ~FL_NOTARGET;
+					//self->svFlags &= ~(SVF_IGNORE_ENEMIES|SVF_ICARUS_FREEZE|SVF_NO_COMBAT_SOUNDS);
+					self->r.svFlags &= ~SVF_ICARUS_FREEZE;
+					G_SetEnemy( self, other );
+					//self->svFlags |= SVF_LOCKEDENEMY; //rwwFIXMEFIXME: proper support for these flags.
+					self->NPC->scriptFlags &= ~(SCF_DONT_FIRE|SCF_CROUCHED|SCF_WALKING|SCF_NO_COMBAT_TALK|SCF_FORCED_MARCH);
+					self->NPC->scriptFlags |= (SCF_CHASE_ENEMIES|SCF_NO_MIND_TRICK);
+					//NOTE: we also stop ICARUS altogether
+					//stop_icarus = qtrue;
+					//rwwFIXMEFIXME: stop icarus?
+					if ( !killPlayerTimer )
+					{
+						killPlayerTimer = level.time + 10000;
+					}
+				}
+			}
+		}
+	}
+
+	SaveNPCGlobals();
+	SetNPCGlobals( self );
+
+	//Do extra bits
+	if ( NPCInfo->ignorePain == qfalse )
+	{
+		NPCInfo->confusionTime = 0;//clear any charm or confusion, regardless
+		if ( damage != -1 )
+		{//-1 == don't play pain anim
+			//Set our proper pain animation
+			NPC_ChoosePainAnimation( self, other, point, damage, mod, hitLoc, voiceEvent );
+		}
+		//Check to take a new enemy
+		if ( NPC->enemy != other && NPC != other )
+		{//not already mad at them
+			NPC_CheckAttacker( other, mod );
+		}
+	}
+
+	//Attempt to run any pain instructions
+	if ( self->client && self->NPC )
+	{
+		//FIXME: This needs better heuristics perhaps
+		if(self->health <= (self->client->ps.stats[STAT_MAX_HEALTH]/3) && G_ActivateBehavior(self, BSET_FLEE) )
+		{
+		}
+		else //if( VALIDSTRING( self->behaviorSet[BSET_PAIN] ) )
+		{
+			G_ActivateBehavior(self, BSET_PAIN);
+		}
+	}
+
+	//Attempt to fire any paintargets we might have
+	if( self->paintarget && self->paintarget[0] )
+	{
+		G_UseTargets2(self, other, self->paintarget);
+	}
+
+	RestoreNPCGlobals();
+}
+
+/*
+-------------------------
+NPC_Touch
+-------------------------
+*/
+extern qboolean INV_SecurityKeyGive( gentity_t *target, const char *keyname );
+void NPC_Touch(gentity_t *self, gentity_t *other, trace_t *trace) 
+{
+	if(!self->NPC)
+		return;
+
+	SaveNPCGlobals();
+	SetNPCGlobals( self );
+
+	if ( self->message && self->health <= 0 )
+	{//I am dead and carrying a key
+		//if ( other && player && player->health > 0 && other == player )
+		if (other && other->client && other->s.number < MAX_CLIENTS)
+		{//player touched me
+			/*
+			char *text;
+			qboolean	keyTaken;
+			//give him my key
+			if ( Q_stricmp( "goodie", self->message ) == 0 )
+			{//a goodie key
+				if ( (keyTaken = INV_GoodieKeyGive( other )) == qtrue )
+				{
+					text = "cp @SP_INGAME_TOOK_IMPERIAL_GOODIE_KEY";
+					G_AddEvent( other, EV_ITEM_PICKUP, (FindItemForInventory( INV_GOODIE_KEY )-bg_itemlist) );
+				}
+				else
+				{
+					text = "cp @SP_INGAME_CANT_CARRY_GOODIE_KEY";
+				}
+			}
+			else
+			{//a named security key
+				if ( (keyTaken = INV_SecurityKeyGive( player, self->message )) == qtrue )
+				{
+					text = "cp @SP_INGAME_TOOK_IMPERIAL_SECURITY_KEY";
+					G_AddEvent( other, EV_ITEM_PICKUP, (FindItemForInventory( INV_SECURITY_KEY )-bg_itemlist) );
+				}
+				else
+				{
+					text = "cp @SP_INGAME_CANT_CARRY_SECURITY_KEY";
+				}
+			}
+			*/
+			//rwwFIXMEFIXME: support for goodie/security keys?
+			/*
+			if ( keyTaken )
+			{//remove my key
+				NPC_SetSurfaceOnOff( self, "l_arm_key", 0x00000002 );
+				self->message = NULL;
+				//FIXME: temp pickup sound
+				G_Sound( player, G_SoundIndex( "sound/weapons/key_pkup.wav" ) );
+				//FIXME: need some event to pass to cgame for sound/graphic/message?
+			}
+			//FIXME: temp message
+			gi.SendServerCommand( NULL, text );
+			*/
+		}
+	}
+
+	if ( other->client ) 
+	{//FIXME:  if pushing against another bot, both ucmd.rightmove = 127???
+		//Except if not facing one another...
+		if ( other->health > 0 ) 
+		{
+			NPCInfo->touchedByPlayer = other;
+		}
+
+		if ( other == NPCInfo->goalEntity ) 
+		{
+			NPCInfo->aiFlags |= NPCAI_TOUCHED_GOAL;
+		}
+
+		if( /*!(self->svFlags&SVF_LOCKEDENEMY) && !(self->svFlags&SVF_IGNORE_ENEMIES) &&*/ !(other->flags & FL_NOTARGET) )
+		{
+			if ( self->client->enemyTeam )
+			{//See if we bumped into an enemy
+				if ( other->client->playerTeam == self->client->enemyTeam )
+				{//bumped into an enemy
+					if( NPCInfo->behaviorState != BS_HUNT_AND_KILL && !NPCInfo->tempBehavior )
+					{//MCG - Begin: checking specific BS mode here, this is bad, a HACK
+						//FIXME: not medics?
+						if ( NPC->enemy != other )
+						{//not already mad at them
+							G_SetEnemy( NPC, other );
+						}
+		//				NPCInfo->tempBehavior = BS_HUNT_AND_KILL;
+					}
+				}
+			}
+		}
+
+		//FIXME: do this if player is moving toward me and with a certain dist?
+		/*
+		if ( other->s.number == 0 && self->client->playerTeam == other->client->playerTeam )
+		{
+			VectorAdd( self->client->pushVec, other->client->ps.velocity, self->client->pushVec );
+		}
+		*/
+	}
+	else 
+	{//FIXME: check for SVF_NONNPC_ENEMY flag here?
+		if ( other->health > 0 ) 
+		{
+			//if ( NPC->enemy == other && (other->svFlags&SVF_NONNPC_ENEMY) )
+			if (0) //rwwFIXMEFIXME: Can probably just check if num < MAX_CLIENTS for non-npc enemy stuff
+			{
+				NPCInfo->touchedByPlayer = other;
+			}
+		}
+
+		if ( other == NPCInfo->goalEntity ) 
+		{
+			NPCInfo->aiFlags |= NPCAI_TOUCHED_GOAL;
+		}
+	}
+
+	RestoreNPCGlobals();
+}
+
+/*
+-------------------------
+NPC_TempLookTarget
+-------------------------
+*/
+
+void NPC_TempLookTarget( gentity_t *self, int lookEntNum, int minLookTime, int maxLookTime )
+{
+	if ( !self->client )
+	{
+		return;
+	}
+
+	if ( (self->client->ps.eFlags2&EF2_HELD_BY_MONSTER) )
+	{//lookTarget is set by and to the monster that's holding you, no other operations can change that
+		return;
+	}
+
+	if ( !minLookTime )
+	{
+		minLookTime = 1000;
+	}
+
+	if ( !maxLookTime )
+	{
+		maxLookTime = 1000;
+	}
+
+	if ( !NPC_CheckLookTarget( self ) )
+	{//Not already looking at something else
+		//Look at him for 1 to 3 seconds
+		NPC_SetLookTarget( self, lookEntNum, level.time + Q_irand( minLookTime, maxLookTime ) );
+	}
+}
+
+void NPC_Respond( gentity_t *self, int userNum )
+{
+	int event = -1;
+	/*
+
+	if ( Q_irand( 0, 1 ) )
+	{
+		event = Q_irand(EV_RESPOND1, EV_RESPOND3);
+	}
+	else
+	{
+		event = Q_irand(EV_BUSY1, EV_BUSY3);
+	}
+	*/
+
+	if ( !Q_irand( 0, 1 ) )
+	{//set looktarget to them for a second or two
+		NPC_TempLookTarget( self, userNum, 1000, 3000 );
+	}
+
+	//some last-minute hacked in responses
+	switch ( self->client->NPC_class )
+	{
+	case CLASS_JAN:
+		if ( self->enemy )
+		{
+			if ( !Q_irand( 0, 2 ) )
+			{
+				event = Q_irand( EV_CHASE1, EV_CHASE3 );
+			}
+			else if ( Q_irand( 0, 1 ) )
+			{
+				event = Q_irand( EV_OUTFLANK1, EV_OUTFLANK2 );
+			}
+			else
+			{
+				event = Q_irand( EV_COVER1, EV_COVER5 );
+			}
+		}
+		else if ( !Q_irand( 0, 2 ) )
+		{
+			event = EV_SUSPICIOUS4;
+		}
+		else if ( !Q_irand( 0, 1 ) )
+		{
+			event = EV_SOUND1;
+		}
+		else
+		{
+			event = EV_CONFUSE1;
+		}
+		break;
+	case CLASS_LANDO:
+		if ( self->enemy )
+		{
+			if ( !Q_irand( 0, 2 ) )
+			{
+				event = Q_irand( EV_CHASE1, EV_CHASE3 );
+			}
+			else if ( Q_irand( 0, 1 ) )
+			{
+				event = Q_irand( EV_OUTFLANK1, EV_OUTFLANK2 );
+			}
+			else
+			{
+				event = Q_irand( EV_COVER1, EV_COVER5 );
+			}
+		}
+		else if ( !Q_irand( 0, 6 ) )
+		{
+			event = EV_SIGHT2;
+		}
+		else if ( !Q_irand( 0, 5 ) )
+		{
+			event = EV_GIVEUP4;
+		}
+		else if ( Q_irand( 0, 4 ) > 1 )
+		{
+			event = Q_irand( EV_SOUND1, EV_SOUND3 );
+		}
+		else
+		{
+			event = Q_irand( EV_JDETECTED1, EV_JDETECTED2 );
+		}
+		break;
+	case CLASS_LUKE:
+		if ( self->enemy )
+		{
+			event = EV_COVER1;
+		}
+		else
+		{
+			event = Q_irand( EV_SOUND1, EV_SOUND3 );
+		}
+		break;
+	case CLASS_JEDI:
+		if ( !self->enemy )
+		{
+			/*
+			if ( !(self->svFlags&SVF_IGNORE_ENEMIES) 
+				&& (self->NPC->scriptFlags&SCF_LOOK_FOR_ENEMIES)
+				&& self->client->enemyTeam == TEAM_ENEMY )
+				*/
+			if (0) //rwwFIXMEFIXME: support flags!
+			{
+				event = Q_irand( EV_ANGER1, EV_ANGER3 );
+			}
+			else
+			{
+				event = Q_irand( EV_TAUNT1, EV_TAUNT2 );
+			}
+		}
+		break;
+	case CLASS_PRISONER:
+		if ( self->enemy )
+		{
+			if ( Q_irand( 0, 1 ) )
+			{
+				event = Q_irand( EV_CHASE1, EV_CHASE3 );
+			}
+			else
+			{
+				event = Q_irand( EV_OUTFLANK1, EV_OUTFLANK2 );
+			}
+		}
+		else
+		{
+			event = Q_irand( EV_SOUND1, EV_SOUND3 );
+		}
+		break;
+	case CLASS_REBEL:
+		if ( self->enemy )
+		{
+			if ( !Q_irand( 0, 2 ) )
+			{
+				event = Q_irand( EV_CHASE1, EV_CHASE3 );
+			}
+			else
+			{
+				event = Q_irand( EV_DETECTED1, EV_DETECTED5 );
+			}
+		}
+		else
+		{
+			event = Q_irand( EV_SOUND1, EV_SOUND3 );
+		}
+		break;
+	case CLASS_BESPIN_COP:
+		if ( !Q_stricmp( "bespincop", self->NPC_type ) )
+		{//variant 1
+			if ( self->enemy )
+			{
+				if ( Q_irand( 0, 9 ) > 6 )
+				{
+					event = Q_irand( EV_CHASE1, EV_CHASE3 );
+				}
+				else if ( Q_irand( 0, 6 ) > 4 )
+				{
+					event = Q_irand( EV_OUTFLANK1, EV_OUTFLANK2 );
+				}
+				else
+				{
+					event = Q_irand( EV_COVER1, EV_COVER5 );
+				}
+			}
+			else if ( !Q_irand( 0, 3 ) )
+			{
+				event = Q_irand( EV_SIGHT2, EV_SIGHT3 );
+			}
+			else if ( !Q_irand( 0, 1 ) )
+			{
+				event = Q_irand( EV_SOUND1, EV_SOUND3 );
+			}
+			else if ( !Q_irand( 0, 2 ) )
+			{
+				event = EV_LOST1;
+			}
+			else if ( !Q_irand( 0, 1 ) )
+			{
+				event = EV_ESCAPING2;
+			}
+			else
+			{
+				event = EV_GIVEUP4;
+			}
+		}
+		else
+		{//variant2
+			if ( self->enemy )
+			{
+				if ( Q_irand( 0, 9 ) > 6 )
+				{
+					event = Q_irand( EV_CHASE1, EV_CHASE3 );
+				}
+				else if ( Q_irand( 0, 6 ) > 4 )
+				{
+					event = Q_irand( EV_OUTFLANK1, EV_OUTFLANK2 );
+				}
+				else
+				{
+					event = Q_irand( EV_COVER1, EV_COVER5 );
+				}
+			}
+			else if ( !Q_irand( 0, 3 ) )
+			{
+				event = Q_irand( EV_SIGHT1, EV_SIGHT2 );
+			}
+			else if ( !Q_irand( 0, 1 ) )
+			{
+				event = Q_irand( EV_SOUND1, EV_SOUND3 );
+			}
+			else if ( !Q_irand( 0, 2 ) )
+			{
+				event = EV_LOST1;
+			}
+			else if ( !Q_irand( 0, 1 ) )
+			{
+				event = EV_GIVEUP3;
+			}
+			else
+			{
+				event = EV_CONFUSE1;
+			}
+		}
+		break;
+	case CLASS_R2D2:				// droid
+		G_Sound(self, CHAN_AUTO, G_SoundIndex(va("sound/chars/r2d2/misc/r2d2talk0%d.wav",Q_irand(1, 3))));
+		break;
+	case CLASS_R5D2:				// droid
+		G_Sound(self, CHAN_AUTO, G_SoundIndex(va("sound/chars/r5d2/misc/r5talk%d.wav",Q_irand(1, 4))));
+		break;
+	case CLASS_MOUSE:				// droid
+		G_Sound(self, CHAN_AUTO, G_SoundIndex(va("sound/chars/mouse/misc/mousego%d.wav",Q_irand(1, 3))));
+		break;
+	case CLASS_GONK:				// droid
+		G_Sound(self, CHAN_AUTO, G_SoundIndex(va("sound/chars/gonk/misc/gonktalk%d.wav",Q_irand(1, 2))));
+		break;
+	}
+	
+	if ( event != -1 )
+	{
+		//hack here because we reuse some "combat" and "extra" sounds
+		qboolean addFlag = (self->NPC->scriptFlags&SCF_NO_COMBAT_TALK);
+		self->NPC->scriptFlags &= ~SCF_NO_COMBAT_TALK;
+
+		G_AddVoiceEvent( self, event, 3000 );
+
+		if ( addFlag )
+		{
+			self->NPC->scriptFlags |= SCF_NO_COMBAT_TALK;
+		}
+	}
+}
+
+/*
+-------------------------
+NPC_UseResponse
+-------------------------
+*/
+
+void NPC_UseResponse( gentity_t *self, gentity_t *user, qboolean useWhenDone )
+{
+	if ( !self->NPC || !self->client )
+	{
+		return;
+	}
+
+	if ( user->s.number != 0 )
+	{//not used by the player
+		if ( useWhenDone )
+		{
+			G_ActivateBehavior( self, BSET_USE );
+		}
+		return;
+	}
+
+	if ( user->client && self->client->playerTeam != user->client->playerTeam && self->client->playerTeam != NPCTEAM_NEUTRAL )
+	{//only those on the same team react
+		if ( useWhenDone )
+		{
+			G_ActivateBehavior( self, BSET_USE );
+		}
+		return;
+	}
+
+	if ( self->NPC->blockedSpeechDebounceTime > level.time )
+	{//I'm not responding right now
+		return;
+	}
+
+	/*
+	if ( gi.VoiceVolume[self->s.number] )
+	{//I'm talking already
+		if ( !useWhenDone )
+		{//you're not trying to use me
+			return;
+		}
+	}
+	*/
+	//rwwFIXMEFIXME: Support for this?
+
+	if ( useWhenDone )
+	{
+		G_ActivateBehavior( self, BSET_USE );
+	}
+	else
+	{
+		NPC_Respond( self, user->s.number );
+	}
+}
+
+/*
+-------------------------
+NPC_Use
+-------------------------
+*/
+extern void Add_Batteries( gentity_t *ent, int *count );
+
+void NPC_Use( gentity_t *self, gentity_t *other, gentity_t *activator ) 
+{
+	if (self->client->ps.pm_type == PM_DEAD)
+	{//or just remove ->pain in player_die?
+		return;
+	}
+
+	SaveNPCGlobals();
+	SetNPCGlobals( self );
+
+	if(self->client && self->NPC)
+	{
+		// If this is a vehicle, let the other guy board it. Added 12/14/02 by AReis.
+		if ( self->client->NPC_class == CLASS_VEHICLE )
+		{
+			Vehicle_t *pVeh = self->m_pVehicle;
+
+			if ( pVeh && pVeh->m_pVehicleInfo )
+			{
+				//if I used myself, eject everyone on me
+				if ( other == self )
+				{
+					pVeh->m_pVehicleInfo->EjectAll( pVeh );
+				}
+				// If other is already riding this vehicle (self), eject him.
+				else if ( other->s.owner == self->s.number )
+				{
+					pVeh->m_pVehicleInfo->Eject( pVeh, (bgEntity_t *)other, qfalse );
+				}
+				// Otherwise board this vehicle.
+				else
+				{
+					pVeh->m_pVehicleInfo->Board( pVeh, (bgEntity_t *)other );
+				}
+			}
+		}
+		else if ( Jedi_WaitingAmbush( NPC ) )
+		{
+			Jedi_Ambush( NPC );
+		}
+		//Run any use instructions
+		if ( activator && activator->s.number == 0 && self->client->NPC_class == CLASS_GONK )
+		{
+			// must be using the gonk, so attempt to give battery power.
+			// NOTE: this will steal up to MAX_BATTERIES for the activator, leaving the residual on the gonk for potential later use.
+//			Add_Batteries( activator, &self->client->ps.batteryCharge );
+			//rwwFIXMEFIXME: support for this?
+		}
+		// Not using MEDICs anymore
+/*
+		if ( self->NPC->behaviorState == BS_MEDIC_HIDE && activator->client )
+		{//Heal me NOW, dammit!
+			if ( activator->health < activator->client->ps.stats[STAT_MAX_HEALTH] )
+			{//person needs help
+				if ( self->NPC->eventualGoal != activator )
+				{//not my current patient already
+					NPC_TakePatient( activator );
+					G_ActivateBehavior( self, BSET_USE );
+				}
+			}
+			else if ( !self->enemy && activator->s.number == 0 && !gi.VoiceVolume[self->s.number] && !(self->NPC->scriptFlags&SCF_NO_RESPONSE) )
+			{//I don't have an enemy and I'm not talking and I was used by the player
+				NPC_UseResponse( self, other, qfalse );
+			}
+		}
+*/
+//		else if ( self->behaviorSet[BSET_USE] )
+		if ( self->behaviorSet[BSET_USE] )
+		{
+			NPC_UseResponse( self, other, qtrue );
+		}
+//		else if ( isMedic( self ) )
+//		{//Heal me NOW, dammit!
+//			NPC_TakePatient( activator );
+//		}
+		else if ( !self->enemy 
+			&& activator->s.number == 0 
+			&& /*!gi.VoiceVolume[self->s.number] &&*/ !(self->NPC->scriptFlags&SCF_NO_RESPONSE) )
+			//rwwFIXMEFIXME: voice volume support?
+		{//I don't have an enemy and I'm not talking and I was used by the player
+			NPC_UseResponse( self, other, qfalse );
+		}
+	}
+
+	RestoreNPCGlobals();
+}
+
+void NPC_CheckPlayerAim( void )
+{
+	//FIXME: need appropriate dialogue
+	/*
+	gentity_t *player = &g_entities[0];
+
+	if ( player && player->client && player->client->ps.weapon > (int)(WP_NONE) && player->client->ps.weapon < (int)(WP_TRICORDER) )
+	{//player has a weapon ready
+		if ( g_crosshairEntNum == NPC->s.number && level.time - g_crosshairEntTime < 200 
+			&& g_crosshairSameEntTime >= 3000 && g_crosshairEntDist < 256 )
+		{//if the player holds the crosshair on you for a few seconds
+			//ask them what the fuck they're doing
+			G_AddVoiceEvent( NPC, Q_irand( EV_FF_1A, EV_FF_1C ), 0 );
+		}
+	}
+	*/
+}
+
+void NPC_CheckAllClear( void )
+{
+	//FIXME: need to make this happen only once after losing enemies, not over and over again
+	/*
+	if ( NPC->client && !NPC->enemy && level.time - teamLastEnemyTime[NPC->client->playerTeam] > 10000 )
+	{//Team hasn't seen an enemy in 10 seconds
+		if ( !Q_irand( 0, 2 ) )
+		{
+			G_AddVoiceEvent( NPC, Q_irand(EV_SETTLE1, EV_SETTLE3), 3000 );
+		}
+	}
+	*/
+}
diff --git a/codemp/game/NPC_senses.c b/codemp/game/NPC_senses.c
new file mode 100644
index 0000000..fdbaf6b
--- /dev/null
+++ b/codemp/game/NPC_senses.c
@@ -0,0 +1,934 @@
+//NPC_senses.cpp
+
+#include "b_local.h"
+
+extern int eventClearTime;
+/*
+qboolean G_ClearLineOfSight(const vec3_t point1, const vec3_t point2, int ignore, int clipmask)
+
+returns true if can see from point 1 to 2, even through glass (1 pane)- doesn't work with portals
+*/
+qboolean G_ClearLineOfSight(const vec3_t point1, const vec3_t point2, int ignore, int clipmask)
+{
+	trace_t		tr;
+	gentity_t	*hit;
+
+	trap_Trace ( &tr, point1, NULL, NULL, point2, ignore, clipmask );
+	if ( tr.fraction == 1.0 ) 
+	{
+		return qtrue;
+	}
+
+	hit = &g_entities[ tr.entityNum ];
+	if(EntIsGlass(hit))
+	{
+		vec3_t	newpoint1;
+		VectorCopy(tr.endpos, newpoint1);
+		trap_Trace (&tr, newpoint1, NULL, NULL, point2, hit->s.number, clipmask );
+
+		if ( tr.fraction == 1.0 ) 
+		{
+			return qtrue;
+		}
+	}
+
+	return qfalse;
+}
+
+/*
+CanSee
+determine if NPC can see an entity
+
+This is a straight line trace check.  This function does not look at PVS or FOV,
+or take any AI related factors (for example, the NPC's reaction time) into account
+
+FIXME do we need fat and thin version of this?
+*/
+qboolean CanSee ( gentity_t *ent ) 
+{
+	trace_t		tr;
+	vec3_t		eyes;
+	vec3_t		spot;
+
+	CalcEntitySpot( NPC, SPOT_HEAD_LEAN, eyes );
+
+	CalcEntitySpot( ent, SPOT_ORIGIN, spot );
+	trap_Trace ( &tr, eyes, NULL, NULL, spot, NPC->s.number, MASK_OPAQUE );
+	ShotThroughGlass (&tr, ent, spot, MASK_OPAQUE);
+	if ( tr.fraction == 1.0 ) 
+	{
+		return qtrue;
+	}
+
+	CalcEntitySpot( ent, SPOT_HEAD, spot );
+	trap_Trace ( &tr, eyes, NULL, NULL, spot, NPC->s.number, MASK_OPAQUE );
+	ShotThroughGlass (&tr, ent, spot, MASK_OPAQUE);
+	if ( tr.fraction == 1.0 ) 
+	{
+		return qtrue;
+	}
+
+	CalcEntitySpot( ent, SPOT_LEGS, spot );
+	trap_Trace ( &tr, eyes, NULL, NULL, spot, NPC->s.number, MASK_OPAQUE );
+	ShotThroughGlass (&tr, ent, spot, MASK_OPAQUE);
+	if ( tr.fraction == 1.0 ) 
+	{
+		return qtrue;
+	}
+
+	return qfalse;
+}
+
+qboolean InFront( vec3_t spot, vec3_t from, vec3_t fromAngles, float threshHold )
+{
+	vec3_t	dir, forward, angles;
+	float	dot;
+
+	VectorSubtract( spot, from, dir );
+	dir[2] = 0;
+	VectorNormalize( dir );
+
+	VectorCopy( fromAngles, angles );
+	angles[0] = 0;
+	AngleVectors( angles, forward, NULL, NULL );
+
+	dot = DotProduct( dir, forward );
+
+	return (dot > threshHold);
+}
+
+/*
+InFOV
+
+IDEA: further off to side of FOV range, higher chance of failing even if technically in FOV,
+	keep core of 50% to sides as always succeeding
+*/
+
+//Position compares
+
+qboolean InFOV3( vec3_t spot, vec3_t from, vec3_t fromAngles, int hFOV, int vFOV )
+{
+	vec3_t	deltaVector, angles, deltaAngles;
+
+	VectorSubtract ( spot, from, deltaVector );
+	vectoangles ( deltaVector, angles );
+	
+	deltaAngles[PITCH]	= AngleDelta ( fromAngles[PITCH], angles[PITCH] );
+	deltaAngles[YAW]	= AngleDelta ( fromAngles[YAW], angles[YAW] );
+
+	if ( fabs ( deltaAngles[PITCH] ) <= vFOV && fabs ( deltaAngles[YAW] ) <= hFOV ) 
+	{
+		return qtrue;
+	}
+
+	return qfalse;
+}
+
+//NPC to position
+
+qboolean InFOV2( vec3_t origin, gentity_t *from, int hFOV, int vFOV ) 
+{
+	vec3_t	fromAngles, eyes;
+
+	if( from->client )
+	{
+		VectorCopy(from->client->ps.viewangles, fromAngles);
+	}
+	else
+	{
+		VectorCopy(from->s.angles, fromAngles);
+	}
+
+	CalcEntitySpot( from, SPOT_HEAD, eyes );
+
+	return InFOV3( origin, eyes, fromAngles, hFOV, vFOV );
+}
+
+//Entity to entity
+
+qboolean InFOV ( gentity_t *ent, gentity_t *from, int hFOV, int vFOV ) 
+{
+	vec3_t	eyes;
+	vec3_t	spot;
+	vec3_t	deltaVector;
+	vec3_t	angles, fromAngles;
+	vec3_t	deltaAngles;
+
+	if( from->client )
+	{
+		if( !VectorCompare( from->client->renderInfo.eyeAngles, vec3_origin ) )
+		{//Actual facing of tag_head!
+			//NOTE: Stasis aliens may have a problem with this?
+			VectorCopy( from->client->renderInfo.eyeAngles, fromAngles );
+		}
+		else
+		{
+			VectorCopy( from->client->ps.viewangles, fromAngles );
+		}
+	}
+	else
+	{
+		VectorCopy(from->s.angles, fromAngles);
+	}
+
+	CalcEntitySpot( from, SPOT_HEAD_LEAN, eyes );
+
+	CalcEntitySpot( ent, SPOT_ORIGIN, spot );
+	VectorSubtract ( spot, eyes, deltaVector);
+
+	vectoangles ( deltaVector, angles );
+	deltaAngles[PITCH] = AngleDelta ( fromAngles[PITCH], angles[PITCH] );
+	deltaAngles[YAW] = AngleDelta ( fromAngles[YAW], angles[YAW] );
+	if ( fabs ( deltaAngles[PITCH] ) <= vFOV && fabs ( deltaAngles[YAW] ) <= hFOV ) 
+	{
+		return qtrue;
+	}
+
+	CalcEntitySpot( ent, SPOT_HEAD, spot );
+	VectorSubtract ( spot, eyes, deltaVector);
+	vectoangles ( deltaVector, angles );
+	deltaAngles[PITCH] = AngleDelta ( fromAngles[PITCH], angles[PITCH] );
+	deltaAngles[YAW] = AngleDelta ( fromAngles[YAW], angles[YAW] );
+	if ( fabs ( deltaAngles[PITCH] ) <= vFOV && fabs ( deltaAngles[YAW] ) <= hFOV ) 
+	{
+		return qtrue;
+	}
+
+	CalcEntitySpot( ent, SPOT_LEGS, spot );
+	VectorSubtract ( spot, eyes, deltaVector);
+	vectoangles ( deltaVector, angles );
+	deltaAngles[PITCH] = AngleDelta ( fromAngles[PITCH], angles[PITCH] );
+	deltaAngles[YAW] = AngleDelta ( fromAngles[YAW], angles[YAW] );
+	if ( fabs ( deltaAngles[PITCH] ) <= vFOV && fabs ( deltaAngles[YAW] ) <= hFOV ) 
+	{
+		return qtrue;
+	}
+
+	return qfalse;
+}
+
+qboolean InVisrange ( gentity_t *ent ) 
+{//FIXME: make a calculate visibility for ents that takes into account
+	//lighting, movement, turning, crouch/stand up, other anims, hide brushes, etc.
+	vec3_t	eyes;
+	vec3_t	spot;
+	vec3_t	deltaVector;
+	float	visrange = (NPCInfo->stats.visrange*NPCInfo->stats.visrange);
+
+	CalcEntitySpot( NPC, SPOT_HEAD_LEAN, eyes );
+
+	CalcEntitySpot( ent, SPOT_ORIGIN, spot );
+	VectorSubtract ( spot, eyes, deltaVector);
+
+	/*if(ent->client)
+	{
+		float	vel, avel;
+		if(ent->client->ps.velocity[0] || ent->client->ps.velocity[1] || ent->client->ps.velocity[2])
+		{
+			vel = VectorLength(ent->client->ps.velocity);
+			if(vel > 128)
+			{
+				visrange += visrange * (vel/256);
+			}
+		}
+
+		if(ent->avelocity[0] || ent->avelocity[1] || ent->avelocity[2])
+		{//FIXME: shouldn't they need to have line of sight to you to detect this?
+			avel = VectorLength(ent->avelocity);
+			if(avel > 15)
+			{
+				visrange += visrange * (avel/60);
+			}
+		}
+	}*/
+
+	if(VectorLengthSquared(deltaVector) > visrange)
+	{
+		return qfalse;
+	}
+
+	return qtrue;
+}
+
+/*
+NPC_CheckVisibility
+*/
+
+visibility_t NPC_CheckVisibility ( gentity_t *ent, int flags ) 
+{
+	// flags should never be 0
+	if ( !flags ) 
+	{
+		return VIS_NOT;
+	}
+
+	// check PVS
+	if ( flags & CHECK_PVS ) 
+	{
+		if ( !trap_InPVS ( ent->r.currentOrigin, NPC->r.currentOrigin ) ) 
+		{
+			return VIS_NOT;
+		}
+	}
+	if ( !(flags & (CHECK_360|CHECK_FOV|CHECK_SHOOT)) ) 
+	{
+		return VIS_PVS;
+	}
+
+	// check within visrange
+	if (flags & CHECK_VISRANGE)
+	{
+		if( !InVisrange ( ent ) ) 
+		{
+			return VIS_PVS;
+		}
+	}
+
+	// check 360 degree visibility
+	//Meaning has to be a direct line of site
+	if ( flags & CHECK_360 ) 
+	{
+		if ( !CanSee ( ent ) ) 
+		{
+			return VIS_PVS;
+		}
+	}
+	if ( !(flags & (CHECK_FOV|CHECK_SHOOT)) ) 
+	{
+		return VIS_360;
+	}
+
+	// check FOV
+	if ( flags & CHECK_FOV ) 
+	{
+		if ( !InFOV ( ent, NPC, NPCInfo->stats.hfov, NPCInfo->stats.vfov) ) 
+		{
+			return VIS_360;
+		}
+	}
+
+	if ( !(flags & CHECK_SHOOT) ) 
+	{
+		return VIS_FOV;
+	}
+
+	// check shootability
+	if ( flags & CHECK_SHOOT ) 
+	{
+		if ( !CanShoot ( ent, NPC ) ) 
+		{
+			return VIS_FOV;
+		}
+	}
+
+	return VIS_SHOOT;
+}
+
+/*
+-------------------------
+NPC_CheckSoundEvents
+-------------------------
+*/
+static int G_CheckSoundEvents( gentity_t *self, float maxHearDist, int ignoreAlert, qboolean mustHaveOwner, int minAlertLevel )
+{
+	int	bestEvent = -1;
+	int bestAlert = -1;
+	int	bestTime = -1;
+	int i;
+	float dist, radius;
+
+	maxHearDist *= maxHearDist;
+
+	for ( i = 0; i < level.numAlertEvents; i++ )
+	{
+		//are we purposely ignoring this alert?
+		if ( i == ignoreAlert )
+			continue;
+		//We're only concerned about sounds
+		if ( level.alertEvents[i].type != AET_SOUND )
+			continue;
+		//must be at least this noticable
+		if ( level.alertEvents[i].level < minAlertLevel )
+			continue;
+		//must have an owner?
+		if ( mustHaveOwner && !level.alertEvents[i].owner )
+			continue;
+		//Must be within range
+		dist = DistanceSquared( level.alertEvents[i].position, self->r.currentOrigin );
+
+		//can't hear it
+		if ( dist > maxHearDist )
+			continue;
+
+		radius = level.alertEvents[i].radius * level.alertEvents[i].radius;
+		if ( dist > radius )
+			continue;
+
+		if ( level.alertEvents[i].addLight )
+		{//a quiet sound, must have LOS to hear it
+			if ( G_ClearLOS5( self, level.alertEvents[i].position ) == qfalse )
+			{//no LOS, didn't hear it
+				continue;
+			}
+		}
+
+		//See if this one takes precedence over the previous one
+		if ( level.alertEvents[i].level >= bestAlert //higher alert level
+			|| (level.alertEvents[i].level==bestAlert&&level.alertEvents[i].timestamp >= bestTime) )//same alert level, but this one is newer
+		{//NOTE: equal is better because it's later in the array
+			bestEvent = i;
+			bestAlert = level.alertEvents[i].level;
+			bestTime = level.alertEvents[i].timestamp;
+		}
+	}
+
+	return bestEvent;
+}
+
+float G_GetLightLevel( vec3_t pos, vec3_t fromDir )
+{
+	/*
+	vec3_t	ambient={0}, directed, lightDir;
+
+	cgi_R_GetLighting( pos, ambient, directed, lightDir );
+	lightLevel = VectorLength( ambient ) + (VectorLength( directed )*DotProduct( lightDir, fromDir ));
+	*/
+	float	lightLevel;
+	//rwwFIXMEFIXME: ...this is evil. We can possibly read from the server BSP data, or load the lightmap along
+	//with collision data and whatnot, but is it worth it?
+	lightLevel = 255;
+
+	return lightLevel;
+}
+/*
+-------------------------
+NPC_CheckSightEvents
+-------------------------
+*/
+static int G_CheckSightEvents( gentity_t *self, int hFOV, int vFOV, float maxSeeDist, int ignoreAlert, qboolean mustHaveOwner, int minAlertLevel )
+{
+	int	bestEvent = -1;
+	int bestAlert = -1;
+	int	bestTime = -1;
+	int i;
+	float	dist, radius;
+
+	maxSeeDist *= maxSeeDist;
+	for ( i = 0; i < level.numAlertEvents; i++ )
+	{
+		//are we purposely ignoring this alert?
+		if ( i == ignoreAlert )
+			continue;
+		//We're only concerned about sounds
+		if ( level.alertEvents[i].type != AET_SIGHT )
+			continue;
+		//must be at least this noticable
+		if ( level.alertEvents[i].level < minAlertLevel )
+			continue;
+		//must have an owner?
+		if ( mustHaveOwner && !level.alertEvents[i].owner )
+			continue;
+
+		//Must be within range
+		dist = DistanceSquared( level.alertEvents[i].position, self->r.currentOrigin );
+
+		//can't see it
+		if ( dist > maxSeeDist )
+			continue;
+
+		radius = level.alertEvents[i].radius * level.alertEvents[i].radius;
+		if ( dist > radius )
+			continue;
+
+		//Must be visible
+		if ( InFOV2( level.alertEvents[i].position, self, hFOV, vFOV ) == qfalse )
+			continue;
+
+		if ( G_ClearLOS5( self, level.alertEvents[i].position ) == qfalse )
+			continue;
+
+		//FIXME: possibly have the light level at this point affect the 
+		//			visibility/alert level of this event?  Would also
+		//			need to take into account how bright the event
+		//			itself is.  A lightsaber would stand out more
+		//			in the dark... maybe pass in a light level that
+		//			is added to the actual light level at this position?
+
+		//See if this one takes precedence over the previous one
+		if ( level.alertEvents[i].level >= bestAlert //higher alert level
+			|| (level.alertEvents[i].level==bestAlert&&level.alertEvents[i].timestamp >= bestTime) )//same alert level, but this one is newer
+		{//NOTE: equal is better because it's later in the array
+			bestEvent = i;
+			bestAlert = level.alertEvents[i].level;
+			bestTime = level.alertEvents[i].timestamp;
+		}
+	}
+
+	return bestEvent;
+}
+
+/*
+-------------------------
+NPC_CheckAlertEvents
+
+    NOTE: Should all NPCs create alertEvents too so they can detect each other?
+-------------------------
+*/
+
+int G_CheckAlertEvents( gentity_t *self, qboolean checkSight, qboolean checkSound, float maxSeeDist, float maxHearDist, int ignoreAlert, qboolean mustHaveOwner, int minAlertLevel )
+{
+	int bestSoundEvent = -1;
+	int bestSightEvent = -1;
+	int bestSoundAlert = -1;
+	int bestSightAlert = -1;
+
+	if ( &g_entities[0] == NULL || g_entities[0].health <= 0 )
+	{
+		//player is dead
+		return -1;
+	}
+
+	//get sound event
+	bestSoundEvent = G_CheckSoundEvents( self, maxHearDist, ignoreAlert, mustHaveOwner, minAlertLevel );
+	//get sound event alert level
+	if ( bestSoundEvent >= 0 )
+	{
+		bestSoundAlert = level.alertEvents[bestSoundEvent].level;
+	}
+
+	//get sight event
+	if ( self->NPC )
+	{
+		bestSightEvent = G_CheckSightEvents( self, self->NPC->stats.hfov, self->NPC->stats.vfov, maxSeeDist, ignoreAlert, mustHaveOwner, minAlertLevel );
+	}
+	else
+	{
+		bestSightEvent = G_CheckSightEvents( self, 80, 80, maxSeeDist, ignoreAlert, mustHaveOwner, minAlertLevel );//FIXME: look at cg_view to get more accurate numbers?
+	}
+	//get sight event alert level
+	if ( bestSightEvent >= 0 )
+	{
+		bestSightAlert = level.alertEvents[bestSightEvent].level;
+	}
+
+	//return the one that has a higher alert (or sound if equal)
+	//FIXME:	This doesn't take the distance of the event into account
+
+	if ( bestSightEvent >= 0 && bestSightAlert > bestSoundAlert )
+	{//valid best sight event, more important than the sound event
+		//get the light level of the alert event for this checker
+		vec3_t	eyePoint, sightDir;
+		//get eye point
+		CalcEntitySpot( self, SPOT_HEAD_LEAN, eyePoint );
+		VectorSubtract( level.alertEvents[bestSightEvent].position, eyePoint, sightDir );
+		level.alertEvents[bestSightEvent].light = level.alertEvents[bestSightEvent].addLight + G_GetLightLevel( level.alertEvents[bestSightEvent].position, sightDir );
+		//return the sight event
+		return bestSightEvent;
+	}
+	//return the sound event
+	return bestSoundEvent;
+}
+
+int NPC_CheckAlertEvents( qboolean checkSight, qboolean checkSound, int ignoreAlert, qboolean mustHaveOwner, int minAlertLevel )
+{
+	return G_CheckAlertEvents( NPC, checkSight, checkSound, NPCInfo->stats.visrange, NPCInfo->stats.earshot, ignoreAlert, mustHaveOwner, minAlertLevel );
+}
+
+qboolean G_CheckForDanger( gentity_t *self, int alertEvent )
+{//FIXME: more bStates need to call this?
+	if ( alertEvent == -1 )
+	{
+		return qfalse;
+	}
+
+	if ( level.alertEvents[alertEvent].level >= AEL_DANGER )
+	{//run away!
+		if ( !level.alertEvents[alertEvent].owner || !level.alertEvents[alertEvent].owner->client || (level.alertEvents[alertEvent].owner!=self&&level.alertEvents[alertEvent].owner->client->playerTeam!=self->client->playerTeam) )
+		{
+			if ( self->NPC )
+			{
+				if ( self->NPC->scriptFlags & SCF_DONT_FLEE )
+				{//can't flee
+					return qfalse;
+				}
+				else
+				{
+					NPC_StartFlee( level.alertEvents[alertEvent].owner, level.alertEvents[alertEvent].position, level.alertEvents[alertEvent].level, 3000, 6000 );
+					return qtrue;
+				}
+			}
+			else
+			{
+				return qtrue;
+			}
+		}
+	}
+	return qfalse;
+}
+qboolean NPC_CheckForDanger( int alertEvent )
+{//FIXME: more bStates need to call this?
+	return G_CheckForDanger( NPC, alertEvent );
+}
+
+/*
+-------------------------
+AddSoundEvent
+-------------------------
+*/
+qboolean RemoveOldestAlert( void );
+void AddSoundEvent( gentity_t *owner, vec3_t position, float radius, alertEventLevel_e alertLevel, qboolean needLOS )
+{
+	//FIXME: Handle this in another manner?
+	if ( level.numAlertEvents >= MAX_ALERT_EVENTS )
+	{
+		if ( !RemoveOldestAlert() )
+		{//how could that fail?
+			return;
+		}
+	}
+	
+	if ( owner == NULL && alertLevel < AEL_DANGER )	//allows un-owned danger alerts
+		return;
+
+	//FIXME: if owner is not a player or player ally, and there are no player allies present,
+	//			perhaps we don't need to store the alert... unless we want the player to
+	//			react to enemy alert events in some way?
+
+	VectorCopy( position, level.alertEvents[ level.numAlertEvents ].position );
+
+	level.alertEvents[ level.numAlertEvents ].radius	= radius;
+	level.alertEvents[ level.numAlertEvents ].level		= alertLevel;
+	level.alertEvents[ level.numAlertEvents ].type		= AET_SOUND;
+	level.alertEvents[ level.numAlertEvents ].owner		= owner;
+	if ( needLOS )
+	{//a very low-level sound, when check this sound event, check for LOS
+		level.alertEvents[ level.numAlertEvents ].addLight	= 1;	//will force an LOS trace on this sound
+	}
+	else
+	{
+		level.alertEvents[ level.numAlertEvents ].addLight	= 0;	//will force an LOS trace on this sound
+	}
+	level.alertEvents[ level.numAlertEvents ].ID		= level.curAlertID++;
+	level.alertEvents[ level.numAlertEvents ].timestamp	= level.time;
+
+	level.numAlertEvents++;
+}
+
+/*
+-------------------------
+AddSightEvent
+-------------------------
+*/
+
+void AddSightEvent( gentity_t *owner, vec3_t position, float radius, alertEventLevel_e alertLevel, float addLight )
+{
+	//FIXME: Handle this in another manner?
+	if ( level.numAlertEvents >= MAX_ALERT_EVENTS )
+	{
+		if ( !RemoveOldestAlert() )
+		{//how could that fail?
+			return;
+		}
+	}
+
+	if ( owner == NULL && alertLevel < AEL_DANGER )	//allows un-owned danger alerts
+		return;
+
+	//FIXME: if owner is not a player or player ally, and there are no player allies present,
+	//			perhaps we don't need to store the alert... unless we want the player to
+	//			react to enemy alert events in some way?
+
+	VectorCopy( position, level.alertEvents[ level.numAlertEvents ].position );
+
+	level.alertEvents[ level.numAlertEvents ].radius	= radius;
+	level.alertEvents[ level.numAlertEvents ].level		= alertLevel;
+	level.alertEvents[ level.numAlertEvents ].type		= AET_SIGHT;
+	level.alertEvents[ level.numAlertEvents ].owner		= owner;		
+	level.alertEvents[ level.numAlertEvents ].addLight	= addLight;	//will get added to actual light at that point when it's checked
+	level.alertEvents[ level.numAlertEvents ].ID		= level.curAlertID++;
+	level.alertEvents[ level.numAlertEvents ].timestamp	= level.time;
+
+	level.numAlertEvents++;
+}
+
+/*
+-------------------------
+ClearPlayerAlertEvents
+-------------------------
+*/
+
+void ClearPlayerAlertEvents( void )
+{
+	int curNumAlerts = level.numAlertEvents;
+	int i;
+	//loop through them all (max 32)
+	for ( i = 0; i < curNumAlerts; i++ )
+	{
+		//see if the event is old enough to delete
+		if ( level.alertEvents[i].timestamp && level.alertEvents[i].timestamp + ALERT_CLEAR_TIME < level.time )
+		{//this event has timed out
+			//drop the count
+			level.numAlertEvents--;
+			//shift the rest down
+			if ( level.numAlertEvents > 0 )
+			{//still have more in the array
+				if ( (i+1) < MAX_ALERT_EVENTS )
+				{
+					memmove( &level.alertEvents[i], &level.alertEvents[i+1], sizeof(alertEvent_t)*(MAX_ALERT_EVENTS-(i+1) ) );
+				}
+			}
+			else
+			{//just clear this one... or should we clear the whole array?
+				memset( &level.alertEvents[i], 0, sizeof( alertEvent_t ) );
+			}
+		}
+	}
+	//make sure this never drops below zero... if it does, something very very bad happened
+	assert( level.numAlertEvents >= 0 );
+
+	if ( eventClearTime < level.time )
+	{//this is just a 200ms debouncer so things that generate constant alerts (like corpses and missiles) add an alert every 200 ms
+		eventClearTime = level.time + ALERT_CLEAR_TIME;
+	}
+}
+
+qboolean RemoveOldestAlert( void )
+{
+	int	oldestEvent = -1, oldestTime = Q3_INFINITE;
+	int i;
+	//loop through them all (max 32)
+	for ( i = 0; i < level.numAlertEvents; i++ )
+	{
+		//see if the event is old enough to delete
+		if ( level.alertEvents[i].timestamp < oldestTime )
+		{
+			oldestEvent = i;
+			oldestTime = level.alertEvents[i].timestamp;
+		}
+	}
+	if ( oldestEvent != -1 )
+	{
+		//drop the count
+		level.numAlertEvents--;
+		//shift the rest down
+		if ( level.numAlertEvents > 0 )
+		{//still have more in the array
+			if ( (oldestEvent+1) < MAX_ALERT_EVENTS )
+			{
+				memmove( &level.alertEvents[oldestEvent], &level.alertEvents[oldestEvent+1], sizeof(alertEvent_t)*(MAX_ALERT_EVENTS-(oldestEvent+1) ) );
+			}
+		}
+		else
+		{//just clear this one... or should we clear the whole array?
+			memset( &level.alertEvents[oldestEvent], 0, sizeof( alertEvent_t ) );
+		}
+	}
+	//make sure this never drops below zero... if it does, something very very bad happened
+	assert( level.numAlertEvents >= 0 );
+	//return true is have room for one now
+	return (level.numAlertEvents<MAX_ALERT_EVENTS);
+}
+
+/*
+-------------------------
+G_ClearLOS
+-------------------------
+*/
+
+// Position to position
+qboolean G_ClearLOS( gentity_t *self, const vec3_t start, const vec3_t end )
+{
+	trace_t		tr;
+	int			traceCount = 0;
+	
+	//FIXME: ENTITYNUM_NONE ok?
+	trap_Trace ( &tr, start, NULL, NULL, end, ENTITYNUM_NONE, CONTENTS_OPAQUE/*CONTENTS_SOLID*//*(CONTENTS_SOLID|CONTENTS_MONSTERCLIP)*/ );
+	while ( tr.fraction < 1.0 && traceCount < 3 )
+	{//can see through 3 panes of glass
+		if ( tr.entityNum < ENTITYNUM_WORLD )
+		{
+			if ( &g_entities[tr.entityNum] != NULL && (g_entities[tr.entityNum].r.svFlags&SVF_GLASS_BRUSH) )
+			{//can see through glass, trace again, ignoring me
+				trap_Trace ( &tr, tr.endpos, NULL, NULL, end, tr.entityNum, MASK_OPAQUE );
+				traceCount++;
+				continue;
+			}
+		}
+		return qfalse;
+	}
+
+	if ( tr.fraction == 1.0 ) 
+		return qtrue;
+
+	return qfalse;
+}
+
+//Entity to position
+qboolean G_ClearLOS2( gentity_t *self, gentity_t *ent, const vec3_t end )
+{
+	vec3_t	eyes;
+
+	CalcEntitySpot( ent, SPOT_HEAD_LEAN, eyes );
+
+	return G_ClearLOS( self, eyes, end );
+}
+
+//Position to entity
+qboolean G_ClearLOS3( gentity_t *self, const vec3_t start, gentity_t *ent )
+{
+	vec3_t		spot;
+
+	//Look for the chest first
+	CalcEntitySpot( ent, SPOT_ORIGIN, spot );
+
+	if ( G_ClearLOS( self, start, spot ) )
+		return qtrue;
+
+	//Look for the head next
+	CalcEntitySpot( ent, SPOT_HEAD_LEAN, spot );
+
+	if ( G_ClearLOS( self, start, spot ) )
+		return qtrue;
+
+	return qfalse;
+}
+
+//NPC's eyes to entity
+qboolean G_ClearLOS4( gentity_t *self, gentity_t *ent ) 
+{
+	vec3_t	eyes;
+
+	//Calculate my position
+	CalcEntitySpot( self, SPOT_HEAD_LEAN, eyes );
+	
+	return G_ClearLOS3( self, eyes, ent );
+}
+
+//NPC's eyes to position
+qboolean G_ClearLOS5( gentity_t *self, const vec3_t end )
+{
+	vec3_t	eyes;
+
+	//Calculate the my position
+	CalcEntitySpot( self, SPOT_HEAD_LEAN, eyes );
+	
+	return G_ClearLOS( self, eyes, end );
+}
+
+/*
+-------------------------
+NPC_GetFOVPercentage
+-------------------------
+*/
+
+float NPC_GetHFOVPercentage( vec3_t spot, vec3_t from, vec3_t facing, float hFOV )
+{
+	vec3_t	deltaVector, angles;
+	float	delta;
+
+	VectorSubtract ( spot, from, deltaVector );
+
+	vectoangles ( deltaVector, angles );
+	
+	delta = fabs( AngleDelta ( facing[YAW], angles[YAW] ) );
+
+	if ( delta > hFOV )
+		return 0.0f; 
+
+	return ( ( hFOV - delta ) / hFOV );
+}
+
+/*
+-------------------------
+NPC_GetVFOVPercentage
+-------------------------
+*/
+
+float NPC_GetVFOVPercentage( vec3_t spot, vec3_t from, vec3_t facing, float vFOV )
+{
+	vec3_t	deltaVector, angles;
+	float	delta;
+
+	VectorSubtract ( spot, from, deltaVector );
+
+	vectoangles ( deltaVector, angles );
+	
+	delta = fabs( AngleDelta ( facing[PITCH], angles[PITCH] ) );
+
+	if ( delta > vFOV )
+		return 0.0f; 
+
+	return ( ( vFOV - delta ) / vFOV );
+}
+
+#define MAX_INTEREST_DIST	( 256 * 256 )
+/*
+-------------------------
+NPC_FindLocalInterestPoint 
+-------------------------
+*/
+
+int G_FindLocalInterestPoint( gentity_t *self )
+{
+	int		i, bestPoint = ENTITYNUM_NONE;
+	float	dist, bestDist = Q3_INFINITE;
+	vec3_t	diffVec, eyes;
+
+	CalcEntitySpot( self, SPOT_HEAD_LEAN, eyes );
+	for ( i = 0; i < level.numInterestPoints; i++ )
+	{
+		//Don't ignore portals?  If through a portal, need to look at portal!
+		if ( trap_InPVS( level.interestPoints[i].origin, eyes ) )
+		{
+			VectorSubtract( level.interestPoints[i].origin, eyes, diffVec );
+			if ( (fabs(diffVec[0]) + fabs(diffVec[1])) / 2 < 48 &&
+				fabs(diffVec[2]) > (fabs(diffVec[0]) + fabs(diffVec[1])) / 2 )
+			{//Too close to look so far up or down
+				continue;
+			}
+			dist = VectorLengthSquared( diffVec );
+			//Some priority to more interesting points
+			//dist -= ((int)level.interestPoints[i].lookMode * 5) * ((int)level.interestPoints[i].lookMode * 5);
+			if ( dist < MAX_INTEREST_DIST && dist < bestDist )
+			{
+				if ( G_ClearLineOfSight( eyes, level.interestPoints[i].origin, self->s.number, MASK_OPAQUE ) )
+				{
+					bestDist = dist;
+					bestPoint = i;
+				}
+			}
+		}
+	}
+	if ( bestPoint != ENTITYNUM_NONE && level.interestPoints[bestPoint].target )
+	{
+		G_UseTargets2( self, self, level.interestPoints[bestPoint].target );
+	}
+	return bestPoint;
+}
+
+/*QUAKED target_interest (1 0.8 0.5) (-4 -4 -4) (4 4 4)
+A point that a squadmate will look at if standing still
+
+target - thing to fire when someone looks at this thing
+*/
+
+void SP_target_interest( gentity_t *self )
+{//FIXME: rename point_interest
+	if(level.numInterestPoints >= MAX_INTEREST_POINTS)
+	{
+		Com_Printf("ERROR:  Too many interest points, limit is %d\n", MAX_INTEREST_POINTS);
+		G_FreeEntity(self);
+		return;
+	}
+
+	VectorCopy(self->r.currentOrigin, level.interestPoints[level.numInterestPoints].origin);
+
+	if(self->target && self->target[0])
+	{
+		level.interestPoints[level.numInterestPoints].target = G_NewString( self->target );
+	}
+
+	level.numInterestPoints++;
+
+	G_FreeEntity(self);
+}
diff --git a/codemp/game/NPC_sounds.c b/codemp/game/NPC_sounds.c
new file mode 100644
index 0000000..be5bdbc
--- /dev/null
+++ b/codemp/game/NPC_sounds.c
@@ -0,0 +1,93 @@
+//NPC_sounds.cpp
+#include "b_local.h"
+#include "../icarus/Q3_Interface.h"
+
+/*
+void NPC_AngerSound (void)
+{
+	if(NPCInfo->investigateSoundDebounceTime)
+		return;
+
+	NPCInfo->investigateSoundDebounceTime = 1;
+
+//	switch((int)NPC->client->race)
+//	{
+//	case RACE_KLINGON:
+		//G_Sound(NPC, G_SoundIndex(va("sound/mgtest/klingon/talk%d.wav",	Q_irand(1, 4))));
+//		break;
+//	}
+}
+*/
+
+extern void G_SpeechEvent( gentity_t *self, int event );
+void G_AddVoiceEvent( gentity_t *self, int event, int speakDebounceTime )
+{
+	if ( !self->NPC )
+	{
+		return;
+	}
+
+	if ( !self->client || self->client->ps.pm_type >= PM_DEAD )
+	{
+		return;
+	}
+
+	if ( self->NPC->blockedSpeechDebounceTime > level.time )
+	{
+		return;
+	}
+
+	if ( trap_ICARUS_TaskIDPending( self, TID_CHAN_VOICE ) )
+	{
+		return;
+	}
+
+	
+	if ( (self->NPC->scriptFlags&SCF_NO_COMBAT_TALK) && ( (event >= EV_ANGER1 && event <= EV_VICTORY3) || (event >= EV_CHASE1 && event <= EV_SUSPICIOUS5) ) )//(event < EV_FF_1A || event > EV_FF_3C) && (event < EV_RESPOND1 || event > EV_MISSION3) )
+	{
+		return;
+	}
+	
+	if ( (self->NPC->scriptFlags&SCF_NO_ALERT_TALK) && (event >= EV_GIVEUP1 && event <= EV_SUSPICIOUS5) )
+	{
+		return;
+	}
+	//FIXME: Also needs to check for teammates. Don't want
+	//		everyone babbling at once
+
+	//NOTE: was losing too many speech events, so we do it directly now, screw networking!
+	//G_AddEvent( self, event, 0 );
+	G_SpeechEvent( self, event );
+
+	//won't speak again for 5 seconds (unless otherwise specified)
+	self->NPC->blockedSpeechDebounceTime = level.time + ((speakDebounceTime==0) ? 5000 : speakDebounceTime);
+}
+
+void NPC_PlayConfusionSound( gentity_t *self )
+{
+	if ( self->health > 0 )
+	{
+		if ( self->enemy ||//was mad
+				!TIMER_Done( self, "enemyLastVisible" ) ||//saw something suspicious
+				self->client->renderInfo.lookTarget	== 0//was looking at player
+			)
+		{
+			self->NPC->blockedSpeechDebounceTime = 0;//make sure we say this
+			G_AddVoiceEvent( self, Q_irand( EV_CONFUSE2, EV_CONFUSE3 ), 2000 );
+		}
+		else if ( self->NPC && self->NPC->investigateDebounceTime+self->NPC->pauseTime > level.time )//was checking something out
+		{
+			self->NPC->blockedSpeechDebounceTime = 0;//make sure we say this
+			G_AddVoiceEvent( self, EV_CONFUSE1, 2000 );
+		}
+		//G_AddVoiceEvent( self, Q_irand(EV_CONFUSE1, EV_CONFUSE3), 2000 );
+	}
+	//reset him to be totally unaware again
+	TIMER_Set( self, "enemyLastVisible", 0 );
+	self->NPC->tempBehavior = BS_DEFAULT;
+	
+	//self->NPC->behaviorState = BS_PATROL;
+	G_ClearEnemy( self );//FIXME: or just self->enemy = NULL;?
+
+	self->NPC->investigateCount = 0;
+}
diff --git a/codemp/game/NPC_spawn.c b/codemp/game/NPC_spawn.c
new file mode 100644
index 0000000..5d68ad8
--- /dev/null
+++ b/codemp/game/NPC_spawn.c
@@ -0,0 +1,4239 @@
+//b_spawn.cpp
+//added by MCG
+#include "b_local.h"
+#include "anims.h"
+#include "w_saber.h"
+#include "bg_saga.h"
+#include "bg_vehicles.h"
+#include "g_nav.h"
+
+extern void G_DebugPrint( int level, const char *format, ... );
+
+extern qboolean G_CheckInSolid (gentity_t *self, qboolean fix);
+extern void ClientUserinfoChanged( int clientNum );
+extern qboolean SpotWouldTelefrag2( gentity_t *mover, vec3_t dest );
+extern void Jedi_Cloak( gentity_t *self );
+
+//extern void FX_BorgTeleport( vec3_t org );
+
+extern void Q3_SetParm (int entID, int parmNum, const char *parmValue);
+extern team_t TranslateTeamName( const char *name );
+extern char	*TeamNames[TEAM_NUM_TEAMS];
+
+//extern void CG_ShimmeryThing_Spawner( vec3_t start, vec3_t end, float radius, qboolean taper, int duration );
+
+//extern void NPC_StasisSpawnEffect( gentity_t *ent );
+
+extern void PM_SetTorsoAnimTimer( gentity_t *ent, int *torsoAnimTimer, int time );
+extern void PM_SetLegsAnimTimer( gentity_t *ent, int *legsAnimTimer, int time );
+
+extern void ST_ClearTimers( gentity_t *ent );
+extern void Jedi_ClearTimers( gentity_t *ent );
+extern void NPC_ShadowTrooper_Precache( void );
+extern void NPC_Gonk_Precache( void );
+extern void NPC_Mouse_Precache( void );
+extern void NPC_Seeker_Precache( void );
+extern void NPC_Remote_Precache( void );
+extern void	NPC_R2D2_Precache(void);
+extern void	NPC_R5D2_Precache(void);
+extern void NPC_Probe_Precache(void);
+extern void NPC_Interrogator_Precache(gentity_t *self);
+extern void NPC_MineMonster_Precache( void );
+extern void NPC_Howler_Precache( void );
+extern void NPC_ATST_Precache(void);
+extern void NPC_Sentry_Precache(void);
+extern void NPC_Mark1_Precache(void);
+extern void NPC_Mark2_Precache(void);
+extern void NPC_GalakMech_Precache( void );
+extern void NPC_GalakMech_Init( gentity_t *ent );
+extern void NPC_Protocol_Precache( void );
+extern void Boba_Precache( void );
+extern void NPC_Wampa_Precache( void );
+gentity_t *NPC_SpawnType( gentity_t *ent, char *npc_type, char *targetname, qboolean isVehicle );
+
+extern void Rancor_SetBolts( gentity_t *self );
+extern void Wampa_SetBolts( gentity_t *self );
+
+#define	NSF_DROP_TO_FLOOR	16
+
+// PAIN functions...
+//
+extern void funcBBrushPain				(gentity_t *self, gentity_t *attacker, int damage);
+extern void misc_model_breakable_pain	(gentity_t *self, gentity_t *attacker, int damage);
+extern void NPC_Pain					(gentity_t *self, gentity_t *attacker, int damage);
+extern void station_pain				(gentity_t *self, gentity_t *attacker, int damage);
+extern void func_usable_pain			(gentity_t *self, gentity_t *attacker, int damage);
+extern void NPC_ATST_Pain				(gentity_t *self, gentity_t *attacker, int damage);
+extern void NPC_ST_Pain					(gentity_t *self, gentity_t *attacker, int damage);
+extern void NPC_Jedi_Pain				(gentity_t *self, gentity_t *attacker, int damage);
+extern void NPC_Droid_Pain				(gentity_t *self, gentity_t *attacker, int damage);
+extern void NPC_Probe_Pain				(gentity_t *self, gentity_t *attacker, int damage);
+extern void NPC_MineMonster_Pain		(gentity_t *self, gentity_t *attacker, int damage);
+extern void NPC_Howler_Pain				(gentity_t *self, gentity_t *attacker, int damage);
+extern void NPC_Seeker_Pain				(gentity_t *self, gentity_t *attacker, int damage);
+extern void NPC_Remote_Pain				(gentity_t *self, gentity_t *attacker, int damage);
+extern void emplaced_gun_pain			(gentity_t *self, gentity_t *attacker, int damage);
+extern void NPC_Mark1_Pain				(gentity_t *self, gentity_t *attacker, int damage);
+extern void NPC_GM_Pain				(gentity_t *self, gentity_t *attacker, int damage);
+extern void NPC_Sentry_Pain				(gentity_t *self, gentity_t *attacker, int damage);
+extern void NPC_Mark2_Pain				(gentity_t *self, gentity_t *attacker, int damage);
+extern void PlayerPain					(gentity_t *self, gentity_t *attacker, int damage);
+extern void GasBurst					(gentity_t *self, gentity_t *attacker, int damage);
+extern void CrystalCratePain			(gentity_t *self, gentity_t *attacker, int damage);
+extern void TurretPain					(gentity_t *self, gentity_t *attacker, int damage);
+extern void NPC_Wampa_Pain				(gentity_t *self, gentity_t *attacker, int damage);
+extern void NPC_Rancor_Pain				(gentity_t *self, gentity_t *attacker, int damage);
+
+
+//void HirogenAlpha_Precache( void );
+
+int WP_SetSaberModel( gclient_t *client, class_t npcClass )
+{
+	//rwwFIXMEFIXME: Do something here, need to let the client know.
+	return 1;
+}
+
+/*
+-------------------------
+NPC_PainFunc
+-------------------------
+*/
+typedef void (PAIN_FUNC) (gentity_t *self, gentity_t *attacker, int damage);
+
+PAIN_FUNC *NPC_PainFunc( gentity_t *ent )
+{
+	void (*func)(gentity_t *self, gentity_t *attacker, int damage);
+
+	if ( ent->client->ps.weapon == WP_SABER )
+	{
+		func = NPC_Jedi_Pain;
+	}
+	else
+	{
+		// team no longer indicates race/species, use NPC_class to determine different npc types
+		/*
+		switch ( ent->client->playerTeam )
+		{
+		default:
+			func = painF_NPC_Pain;
+			break;
+		}
+		*/
+		switch( ent->client->NPC_class )
+		{
+		// troopers get special pain
+		case CLASS_STORMTROOPER:
+		case CLASS_SWAMPTROOPER:
+			func = NPC_ST_Pain;
+			break;
+
+		case CLASS_SEEKER:
+			func = NPC_Seeker_Pain;
+			break;
+
+		case CLASS_REMOTE:
+			func = NPC_Remote_Pain;
+			break;
+
+		case CLASS_MINEMONSTER:
+			func = NPC_MineMonster_Pain;
+			break;
+
+		case CLASS_HOWLER:
+			func = NPC_Howler_Pain;
+			break;
+
+		// all other droids, did I miss any?
+		case CLASS_GONK:
+		case CLASS_R2D2:
+		case CLASS_R5D2:
+		case CLASS_MOUSE:
+		case CLASS_PROTOCOL:
+		case CLASS_INTERROGATOR:
+			func = NPC_Droid_Pain;
+			break;
+		case CLASS_PROBE:
+			func = NPC_Probe_Pain;
+			break;
+
+		case CLASS_SENTRY:
+			func = NPC_Sentry_Pain;
+			break;
+		case CLASS_MARK1:
+			func = NPC_Mark1_Pain;
+			break;
+		case CLASS_MARK2:
+			func = NPC_Mark2_Pain;
+			break;
+		case CLASS_ATST:  
+			func = NPC_ATST_Pain;
+			break;
+		case CLASS_GALAKMECH:
+			func = NPC_GM_Pain;
+			break;
+		case CLASS_RANCOR:
+			func = NPC_Rancor_Pain;
+			break;
+		case CLASS_WAMPA:
+			func = NPC_Wampa_Pain;
+			break;
+		// everyone else gets the normal pain func
+		default:
+			func = NPC_Pain;
+			break;
+		}
+
+	}
+
+	return func;
+}
+
+
+/*
+-------------------------
+NPC_TouchFunc
+-------------------------
+*/
+typedef void (TOUCH_FUNC) (gentity_t *self, gentity_t *other, trace_t *trace);
+
+TOUCH_FUNC *NPC_TouchFunc( gentity_t *ent )
+{
+	void (*func)(gentity_t *self, gentity_t *other, trace_t *trace);
+
+	func = NPC_Touch;
+
+	return func;
+}
+
+/*
+-------------------------
+NPC_SetMiscDefaultData
+-------------------------
+*/
+
+extern void G_CreateG2AttachedWeaponModel( gentity_t *ent, const char *weaponModel, int boltNum, int weaponNum );
+void NPC_SetMiscDefaultData( gentity_t *ent )
+{
+	if ( ent->spawnflags & SFB_CINEMATIC )
+	{//if a cinematic guy, default us to wait bState
+		ent->NPC->behaviorState = BS_CINEMATIC;
+	}
+	if ( ent->client->NPC_class == CLASS_BOBAFETT )
+	{//set some stuff, precache
+		Boba_Precache();
+		ent->client->ps.fd.forcePowersKnown |= ( 1 << FP_LEVITATION );
+		ent->client->ps.fd.forcePowerLevel[FP_LEVITATION] = FORCE_LEVEL_3;
+		ent->client->ps.fd.forcePower = 100;
+		ent->NPC->scriptFlags |= (SCF_ALT_FIRE|SCF_NO_GROUPS);
+	}
+	//if ( !Q_stricmp( "atst_vehicle", ent->NPC_type ) )//FIXME: has to be a better, easier way to tell this, no?
+	if (ent->s.NPC_class == CLASS_VEHICLE && ent->m_pVehicle)
+	{
+		ent->s.g2radius = 255;//MAX for this value, was (ent->r.maxs[2]-ent->r.mins[2]), which is 272 or something
+
+		if (ent->m_pVehicle->m_pVehicleInfo->type == VH_WALKER)
+		{
+			ent->mass = 2000;//???
+			ent->flags |= (FL_SHIELDED|FL_NO_KNOCKBACK);
+			ent->pain = NPC_ATST_Pain;
+		}
+		//turn the damn hatch cover on and LEAVE it on
+		trap_G2API_SetSurfaceOnOff( ent->ghoul2, "head_hatchcover", 0/*TURN_ON*/ );
+	}
+	if ( !Q_stricmp( "wampa", ent->NPC_type ) )
+	{//FIXME: extern this into NPC.cfg?
+		Wampa_SetBolts( ent );
+		ent->s.g2radius = 80;//???
+		ent->mass = 300;//???
+		ent->flags |= FL_NO_KNOCKBACK;
+		ent->pain = NPC_Wampa_Pain;
+	}
+	if ( ent->client->NPC_class == CLASS_RANCOR )
+	{
+		Rancor_SetBolts( ent );
+		ent->s.g2radius = 255;//MAX for this value, was (ent->r.maxs[2]-ent->r.mins[2]), which is 272 or something
+		ent->mass = 1000;//???
+		ent->flags |= FL_NO_KNOCKBACK;
+		ent->pain = NPC_Rancor_Pain;
+		ent->health *= 4;
+	}
+	if ( !Q_stricmp( "Yoda", ent->NPC_type ) )
+	{//FIXME: extern this into NPC.cfg?
+		ent->NPC->scriptFlags |= SCF_NO_FORCE;//force powers don't work on him
+	}
+	if ( !Q_stricmp( "emperor", ent->NPC_type ) )
+	{//FIXME: extern this into NPC.cfg?
+		ent->NPC->scriptFlags |= SCF_DONT_FIRE;//so he uses only force powers
+	}
+	//==================
+//	if ( ent->client->ps.saber[0].type != SABER_NONE )
+	if (ent->client->ps.weapon == WP_SABER) //rwwFIXMEFIXME: is this going to work?
+	{//if I'm equipped with a saber, initialize it (them)
+	//	ent->client->ps.SaberDeactivate();
+	//	ent->client->ps.SetSaberLength( 0 );
+		WP_SaberInitBladeData( ent );
+		ent->client->ps.saberHolstered = 2;
+	//	G_CreateG2AttachedWeaponModel( ent, ent->client->ps.saber[0].model, ent->handRBolt, 0 );
+	//	if ( ent->client->ps.dualSabers )
+	//	{
+	//		G_CreateG2AttachedWeaponModel( ent, ent->client->ps.saber[1].model, ent->handLBolt, 1 );
+	//	}
+		Jedi_ClearTimers( ent );
+	}
+	if ( ent->client->ps.fd.forcePowersKnown != 0 )
+	{
+		WP_InitForcePowers( ent );
+		WP_SpawnInitForcePowers(ent); //rww
+	}
+	if ( ent->client->NPC_class == CLASS_SEEKER )
+	{		
+		ent->NPC->defaultBehavior = BS_DEFAULT;
+		ent->client->ps.gravity = 0;
+		ent->NPC->aiFlags |= NPCAI_CUSTOM_GRAVITY;
+		ent->client->ps.eFlags2 |= EF2_FLYING;
+		ent->count = 30; // SEEKER shot ammo count
+	}
+	//***I'm not sure whether I should leave this as a TEAM_ switch, I think NPC_class may be more appropriate - dmv
+	switch(ent->client->playerTeam)
+	{
+	case NPCTEAM_PLAYER:
+		//ent->flags |= FL_NO_KNOCKBACK;
+		if ( ent->client->NPC_class == CLASS_JEDI || ent->client->NPC_class == CLASS_LUKE )
+		{//good jedi
+			ent->client->enemyTeam = NPCTEAM_ENEMY;
+			if ( ent->spawnflags & JSF_AMBUSH )
+			{//ambusher
+				ent->NPC->scriptFlags |= SCF_IGNORE_ALERTS;
+				ent->client->noclip = qtrue;//hang
+			}
+		}
+		else
+		{
+			/*
+			if (ent->client->ps.weapon != WP_NONE)
+			{
+				G_CreateG2AttachedWeaponModel( ent, weaponData[ent->client->ps.weapon].weaponMdl, ent->handRBolt, 0 );
+			}
+			*/
+			switch ( ent->client->ps.weapon )
+			{
+			case WP_BRYAR_PISTOL://FIXME: new weapon: imp blaster pistol
+	//		case WP_BLASTER_PISTOL:
+			case WP_DISRUPTOR:
+			case WP_BOWCASTER:
+			case WP_REPEATER:
+			case WP_DEMP2:
+			case WP_FLECHETTE:
+			case WP_ROCKET_LAUNCHER:
+			default:
+				break;
+			case WP_THERMAL:
+			case WP_BLASTER:
+				//FIXME: health in NPCs.cfg, and not all blaster users are stormtroopers
+				//ent->health = 25;
+				//FIXME: not necc. a ST
+				ST_ClearTimers( ent );
+				if ( ent->NPC->rank >= RANK_LT || ent->client->ps.weapon == WP_THERMAL )
+				{//officers, grenade-throwers use alt-fire
+					//ent->health = 50;
+					//ent->NPC->scriptFlags |= SCF_ALT_FIRE;
+				}
+				break;
+			}
+		}
+		if ( ent->client->NPC_class == CLASS_KYLE || ent->client->NPC_class == CLASS_VEHICLE || (ent->spawnflags & SFB_CINEMATIC) )
+		{
+			ent->NPC->defaultBehavior = BS_CINEMATIC;
+		}
+		else
+		{
+			/*
+			ent->NPC->defaultBehavior = BS_FOLLOW_LEADER;
+			ent->client->leader = &g_entities[0];
+			*/
+		}
+		break;
+
+	case NPCTEAM_NEUTRAL: 
+
+		if ( Q_stricmp( ent->NPC_type, "gonk" ) == 0 ) 
+		{
+			// I guess we generically make them player usable
+			ent->r.svFlags |= SVF_PLAYER_USABLE;
+
+			// Not even sure if we want to give different levels of batteries?  ...Or even that these are the values we'd want to use.
+			/*
+			switch ( g_spskill.integer )
+			{
+			case 0:	//	EASY
+				ent->client->ps.batteryCharge = MAX_BATTERIES * 0.8f; 
+				break;
+			case 1:	//	MEDIUM
+				ent->client->ps.batteryCharge = MAX_BATTERIES * 0.75f; 
+				break;
+			default :
+			case 2:	//	HARD
+				ent->client->ps.batteryCharge = MAX_BATTERIES * 0.5f; 
+				break;
+			}*/
+			//rwwFIXMEFIXME: Make use of this.
+		}
+		break;
+
+	case NPCTEAM_ENEMY:
+		{
+			ent->NPC->defaultBehavior = BS_DEFAULT;
+			if ( ent->client->NPC_class == CLASS_SHADOWTROOPER )
+			{//FIXME: a spawnflag?
+				Jedi_Cloak( ent );
+			}
+		 	if( ent->client->NPC_class == CLASS_TAVION ||
+				ent->client->NPC_class == CLASS_REBORN ||
+				ent->client->NPC_class == CLASS_DESANN ||
+				ent->client->NPC_class == CLASS_SHADOWTROOPER )
+			{
+				ent->client->enemyTeam = NPCTEAM_PLAYER;
+				if ( ent->spawnflags & JSF_AMBUSH )
+				{//ambusher
+					ent->NPC->scriptFlags |= SCF_IGNORE_ALERTS;
+					ent->client->noclip = qtrue;//hang
+				}
+			}
+			else if( ent->client->NPC_class == CLASS_PROBE || ent->client->NPC_class == CLASS_REMOTE ||
+						ent->client->NPC_class == CLASS_INTERROGATOR || ent->client->NPC_class == CLASS_SENTRY)
+			{		
+				ent->NPC->defaultBehavior = BS_DEFAULT;
+				ent->client->ps.gravity = 0;
+				ent->NPC->aiFlags |= NPCAI_CUSTOM_GRAVITY;
+				ent->client->ps.eFlags2 |= EF2_FLYING;
+			}
+			else 
+			{
+		//		G_CreateG2AttachedWeaponModel( ent, weaponData[ent->client->ps.weapon].weaponMdl, ent->handRBolt, 0 );
+				switch ( ent->client->ps.weapon )
+				{
+				case WP_BRYAR_PISTOL:
+					break;
+		//		case WP_BLASTER_PISTOL:
+		//			break;
+				case WP_DISRUPTOR:
+					//Sniper
+					//ent->NPC->scriptFlags |= SCF_ALT_FIRE;//FIXME: use primary fire sometimes?  Up close?  Different class of NPC?
+					break;
+				case WP_BOWCASTER:
+					break;
+				case WP_REPEATER:
+					//machine-gunner
+					break;
+				case WP_DEMP2:
+					break;
+				case WP_FLECHETTE:
+					//shotgunner
+					if ( !Q_stricmp( "stofficeralt", ent->NPC_type ) )
+					{
+						//ent->NPC->scriptFlags |= SCF_ALT_FIRE;
+					}
+					break;
+				case WP_ROCKET_LAUNCHER:
+					break;
+				case WP_THERMAL:
+					//Gran, use main, bouncy fire
+//					ent->NPC->scriptFlags |= SCF_ALT_FIRE;
+					break;
+				case WP_STUN_BATON:
+					break;
+				default:
+				case WP_BLASTER:
+					//FIXME: health in NPCs.cfg, and not all blaster users are stormtroopers
+					//FIXME: not necc. a ST
+					ST_ClearTimers( ent );
+					if ( ent->NPC->rank >= RANK_COMMANDER )
+					{//commanders use alt-fire
+						//ent->NPC->scriptFlags |= SCF_ALT_FIRE;
+					}
+					if ( !Q_stricmp( "rodian2", ent->NPC_type ) )
+					{
+						//ent->NPC->scriptFlags |= SCF_ALT_FIRE;
+					}
+					break;
+				}
+				if ( !Q_stricmp( "galak_mech", ent->NPC_type ) )
+				{//starts with armor
+					NPC_GalakMech_Init( ent );
+				}
+			}
+		}
+		break;
+
+	default:
+		break;
+	}
+
+
+	if ( ent->client->NPC_class == CLASS_SEEKER
+		&& ent->activator )
+	{//assume my teams are already set correctly
+	}
+	else
+	{
+		//for siege, want "bad" npc's allied with the "bad" team
+		if (g_gametype.integer == GT_SIEGE && ent->s.NPC_class != CLASS_VEHICLE)
+		{
+			if (ent->client->enemyTeam == NPCTEAM_PLAYER)
+			{
+				ent->client->sess.sessionTeam = SIEGETEAM_TEAM1;
+			}
+			else if (ent->client->enemyTeam == NPCTEAM_ENEMY)
+			{
+				ent->client->sess.sessionTeam = SIEGETEAM_TEAM2;
+			}
+			else
+			{
+				ent->client->sess.sessionTeam = TEAM_FREE;
+			}
+		}
+	}
+
+	if ( ent->client->NPC_class == CLASS_ATST || ent->client->NPC_class == CLASS_MARK1 ) // chris/steve/kevin requested that the mark1 be shielded also
+	{
+		ent->flags |= (FL_SHIELDED|FL_NO_KNOCKBACK);
+	}
+}
+
+/*
+-------------------------
+NPC_WeaponsForTeam
+-------------------------
+*/
+
+int NPC_WeaponsForTeam( team_t team, int spawnflags, const char *NPC_type )
+{
+	//*** not sure how to handle this, should I pass in class instead of team and go from there? - dmv
+	switch(team)
+	{
+	// no longer exists
+//	case TEAM_BORG:
+//		break;
+
+//	case TEAM_HIROGEN:
+//		if( Q_stricmp( "hirogenalpha", NPC_type ) == 0 )
+//			return ( 1 << WP_BLASTER);
+		//Falls through
+
+//	case TEAM_KLINGON:
+
+		//NOTENOTE: Falls through
+
+//	case TEAM_IMPERIAL:
+	case NPCTEAM_ENEMY:
+		if ( Q_stricmp( "tavion", NPC_type ) == 0 || 
+			Q_strncmp( "reborn", NPC_type, 6 ) == 0 || 
+			Q_stricmp( "desann", NPC_type ) == 0 || 
+			Q_strncmp( "shadowtrooper", NPC_type, 13 ) == 0 )
+			return ( 1 << WP_SABER);
+//			return ( 1 << WP_IMPERIAL_BLADE);
+		//NOTENOTE: Falls through if not a knife user
+
+//	case TEAM_SCAVENGERS:
+//	case TEAM_MALON:
+		//FIXME: default weapon in npc config?
+		if ( Q_strncmp( "stofficer", NPC_type, 9 ) == 0 )
+		{
+			return ( 1 << WP_FLECHETTE);
+		}
+		if ( Q_stricmp( "stcommander", NPC_type ) == 0 )
+		{
+			return ( 1 << WP_REPEATER);
+		}
+		if ( Q_stricmp( "swamptrooper", NPC_type ) == 0 )
+		{
+			return ( 1 << WP_FLECHETTE);
+		}
+		if ( Q_stricmp( "swamptrooper2", NPC_type ) == 0 )
+		{
+			return ( 1 << WP_REPEATER);
+		}
+		if ( Q_stricmp( "rockettrooper", NPC_type ) == 0 )
+		{
+			return ( 1 << WP_ROCKET_LAUNCHER);
+		}
+		if ( Q_strncmp( "shadowtrooper", NPC_type, 13 ) == 0 )
+		{
+			return ( 1 << WP_SABER);//|( 1 << WP_RAPID_CONCUSSION)?
+		}
+		if ( Q_stricmp( "imperial", NPC_type ) == 0 )
+		{
+			//return ( 1 << WP_BLASTER_PISTOL);
+			return ( 1 << WP_BLASTER);
+		}
+		if ( Q_strncmp( "impworker", NPC_type, 9 ) == 0 )
+		{
+			//return ( 1 << WP_BLASTER_PISTOL);
+			return ( 1 << WP_BLASTER);
+		}
+		if ( Q_stricmp( "stormpilot", NPC_type ) == 0 )
+		{
+			//return ( 1 << WP_BLASTER_PISTOL);
+			return ( 1 << WP_BLASTER);
+		}
+		if ( Q_stricmp( "galak", NPC_type ) == 0 )
+		{
+			return ( 1 << WP_BLASTER);
+		}
+		if ( Q_stricmp( "galak_mech", NPC_type ) == 0 )
+		{
+			return ( 1 << WP_REPEATER);
+		}
+		if ( Q_strncmp( "ugnaught", NPC_type, 8 ) == 0 )
+		{
+			return WP_NONE;
+		}
+		if ( Q_stricmp( "granshooter", NPC_type ) == 0 )
+		{
+			return ( 1 << WP_BLASTER);
+		}
+		if ( Q_stricmp( "granboxer", NPC_type ) == 0 )
+		{
+			return ( 1 << WP_STUN_BATON);
+		}
+		if ( Q_strncmp( "gran", NPC_type, 4 ) == 0 )
+		{
+			return (( 1 << WP_THERMAL)|( 1 << WP_STUN_BATON));
+		}
+		if ( Q_stricmp( "rodian", NPC_type ) == 0 )
+		{
+			return ( 1 << WP_DISRUPTOR);
+		}
+		if ( Q_stricmp( "rodian2", NPC_type ) == 0 )
+		{
+			return ( 1 << WP_BLASTER);
+		}
+
+		if (( Q_stricmp( "interrogator",NPC_type) == 0) || ( Q_stricmp( "sentry",NPC_type) == 0) || (Q_strncmp( "protocol",NPC_type,8) == 0) )
+		{
+			return WP_NONE;
+		}
+
+		if ( Q_strncmp( "weequay", NPC_type, 7 ) == 0 )
+		{
+			return ( 1 << WP_BOWCASTER);//|( 1 << WP_STAFF )(FIXME: new weap?)
+		}
+		if ( Q_stricmp( "impofficer", NPC_type ) == 0 )
+		{
+			return ( 1 << WP_BLASTER);
+		}
+		if ( Q_stricmp( "impcommander", NPC_type ) == 0 )
+		{
+			return ( 1 << WP_BLASTER);
+		}
+		if (( Q_stricmp( "probe", NPC_type ) == 0 ) || ( Q_stricmp( "seeker", NPC_type ) == 0 ))
+		{
+			//return ( 1 << WP_BOT_LASER);
+			return 0;
+		}	
+		if ( Q_stricmp( "remote", NPC_type ) == 0 )
+		{
+			//return ( 1 << WP_BOT_LASER );
+			return 0;
+		}	
+		if ( Q_stricmp( "trandoshan", NPC_type ) == 0 )
+		{
+			return (1<<WP_REPEATER);
+		}
+		if ( Q_stricmp( "atst", NPC_type ) == 0 )
+		{
+			//return (( 1 << WP_ATST_MAIN)|( 1 << WP_ATST_SIDE));
+			return 0;
+		}
+		if ( Q_stricmp( "mark1", NPC_type ) == 0 )
+		{
+			//return ( 1 << WP_BOT_LASER);
+			return 0;
+		}
+		if ( Q_stricmp( "mark2", NPC_type ) == 0 )
+		{
+			//return ( 1 << WP_BOT_LASER);
+			return 0;
+		}
+		if ( Q_stricmp( "minemonster", NPC_type ) == 0 )
+		{
+			return (( 1 << WP_STUN_BATON));
+		}
+		if ( Q_stricmp( "howler", NPC_type ) == 0 )
+		{
+			return (( 1 << WP_STUN_BATON));
+		}
+		//Stormtroopers, etc.
+		return ( 1 << WP_BLASTER);
+		break;
+
+	case NPCTEAM_PLAYER:
+		
+//		if(spawnflags & SFB_TRICORDER)
+//			return ( 1 << WP_TRICORDER);
+		
+		if(spawnflags & SFB_RIFLEMAN)
+			return ( 1 << WP_REPEATER);
+		
+		if(spawnflags & SFB_PHASER)
+			//return ( 1 << WP_BLASTER_PISTOL);
+			return ( 1 << WP_BLASTER);
+
+		if ( Q_strncmp( "jedi", NPC_type, 4 ) == 0 || Q_stricmp( "luke", NPC_type ) == 0 )
+			return ( 1 << WP_SABER);
+
+		if ( Q_strncmp( "prisoner", NPC_type, 8 ) == 0 )
+		{
+			return WP_NONE;
+		}
+		if ( Q_strncmp( "bespincop", NPC_type, 9 ) == 0 )
+		{
+			//return ( 1 << WP_BLASTER_PISTOL);
+			return ( 1 << WP_BLASTER);
+		}
+
+		if ( Q_stricmp( "MonMothma", NPC_type ) == 0 )
+		{
+			return WP_NONE;
+		}
+
+		//rebel
+		return ( 1 << WP_BLASTER);
+		break;
+
+	case NPCTEAM_NEUTRAL:
+
+		if ( Q_stricmp( "mark1", NPC_type ) == 0 )
+		{
+			return WP_NONE;
+		}	
+		if ( Q_stricmp( "mark2", NPC_type ) == 0 )
+		{
+			return WP_NONE;
+		}	
+		if ( Q_strncmp( "ugnaught", NPC_type, 8 ) == 0 )
+		{
+			return WP_NONE;
+		}	
+		if ( Q_stricmp( "bartender", NPC_type ) == 0 )
+		{
+			return WP_NONE;
+		}
+		if ( Q_stricmp( "morgankatarn", NPC_type ) == 0 )
+		{
+			return WP_NONE;
+		}
+	
+		break;
+
+	// these no longer exist
+//	case TEAM_FORGE:
+//		return ( 1 << WP_STUN_BATON);
+//		break;
+
+//	case TEAM_STASIS:
+//		return ( 1 << WP_STUN_BATON);
+//		break;
+
+//	case TEAM_PARASITE:
+//		break;
+
+//	case TEAM_8472:
+//		break;
+
+	default:
+		break;
+	}
+
+	return WP_NONE;
+}
+
+extern void ChangeWeapon( gentity_t *ent, int newWeapon );
+
+/*
+-------------------------
+NPC_SetWeapons
+-------------------------
+*/
+
+void NPC_SetWeapons( gentity_t *ent )
+{
+	int			bestWeap = WP_NONE;
+	int			curWeap;
+	int			weapons = NPC_WeaponsForTeam( ent->client->playerTeam, ent->spawnflags, ent->NPC_type );
+
+	ent->client->ps.stats[STAT_WEAPONS] = 0;
+	for ( curWeap = WP_SABER; curWeap < WP_NUM_WEAPONS; curWeap++ )
+	{
+		if ( (weapons & ( 1 << curWeap )) )
+		{
+			ent->client->ps.stats[STAT_WEAPONS] |= ( 1 << curWeap );
+//			RegisterItem( FindItemForWeapon( (weapon_t)(curWeap) ) );	//precache the weapon
+			//rwwFIXMEFIXME: Precache
+			ent->NPC->currentAmmo = ent->client->ps.ammo[weaponData[curWeap].ammoIndex] = 100;//FIXME: max ammo
+
+			if ( bestWeap == WP_SABER )
+			{
+				// still want to register other weapons -- force saber to be best weap
+				continue;
+			}
+
+			if ( curWeap == WP_STUN_BATON )
+			{
+				if ( bestWeap == WP_NONE )
+				{// We'll only consider giving Melee since we haven't found anything better yet.
+					bestWeap = curWeap;
+				}
+			}
+			else if ( curWeap > bestWeap || bestWeap == WP_STUN_BATON )
+			{
+				// This will never override saber as best weap.  Also will override WP_STUN_BATON if something better comes later in the list
+				bestWeap = curWeap;
+			}
+		}
+	}
+
+	ent->client->ps.weapon = bestWeap;
+}
+
+/*
+-------------------------
+NPC_SpawnEffect
+
+  NOTE:  Make sure any effects called here have their models, tga's and sounds precached in
+			CG_RegisterNPCEffects in cg_player.cpp
+-------------------------
+*/
+
+void NPC_SpawnEffect (gentity_t *ent)
+{
+}
+
+//--------------------------------------------------------------
+// NPC_SetFX_SpawnStates
+//
+// Set up any special parms for spawn effects
+//--------------------------------------------------------------
+void NPC_SetFX_SpawnStates( gentity_t *ent )
+{
+	if ( !(ent->NPC->aiFlags&NPCAI_CUSTOM_GRAVITY) )
+	{
+		ent->client->ps.gravity = g_gravity.value;
+	}
+}
+
+/*
+================
+NPC_SpotWouldTelefrag
+
+================
+*/
+qboolean NPC_SpotWouldTelefrag( gentity_t *npc )
+{
+	int			i, num;
+	int			touch[MAX_GENTITIES];
+	gentity_t	*hit;
+	vec3_t		mins, maxs;
+
+	VectorAdd( npc->r.currentOrigin, npc->r.mins, mins );
+	VectorAdd( npc->r.currentOrigin, npc->r.maxs, maxs );
+	num = trap_EntitiesInBox( mins, maxs, touch, MAX_GENTITIES );
+
+	for (i=0 ; i<num ; i++)
+	{
+		hit = &g_entities[touch[i]];
+		//if ( hit->client && hit->client->ps.stats[STAT_HEALTH] > 0 ) {
+		if (hit->inuse 
+			&& hit->client 
+			&& hit->s.number != npc->s.number 
+			&& (hit->r.contents&MASK_NPCSOLID)
+			&& hit->s.number != npc->r.ownerNum
+			&& hit->r.ownerNum != npc->s.number)
+		{
+			return qtrue;
+		}
+
+	}
+
+	return qfalse;
+}
+
+//--------------------------------------------------------------
+void NPC_Begin (gentity_t *ent)
+{
+	vec3_t	spawn_origin, spawn_angles;
+	gclient_t	*client;
+	usercmd_t	ucmd;
+	gentity_t	*spawnPoint = NULL;
+
+	memset( &ucmd, 0, sizeof( ucmd ) );
+
+	if ( !(ent->spawnflags & SFB_NOTSOLID) )
+	{//No NPCs should telefrag
+		if (NPC_SpotWouldTelefrag(ent))
+		{
+			if ( ent->wait < 0 )
+			{//remove yourself
+				G_DebugPrint( WL_DEBUG, "NPC %s could not spawn, firing target3 (%s) and removing self\n", ent->targetname, ent->target3 );
+				//Fire off our target3
+				G_UseTargets2( ent, ent, ent->target3 );
+
+				//Kill us
+				ent->think = G_FreeEntity;
+				ent->nextthink = level.time + 100;
+			}
+			else
+			{
+				G_DebugPrint( WL_DEBUG, "NPC %s could not spawn, waiting %4.2 secs to try again\n", ent->targetname, ent->wait/1000.0f );
+				ent->think = NPC_Begin;
+				ent->nextthink = level.time + ent->wait;//try again in half a second
+			}
+			return;
+		}
+	}
+	//Spawn effect
+	NPC_SpawnEffect( ent );
+
+	VectorCopy( ent->client->ps.origin, spawn_origin);
+	VectorCopy( ent->s.angles, spawn_angles);
+	spawn_angles[YAW] = ent->NPC->desiredYaw;
+
+	client = ent->client;
+
+	// increment the spawncount so the client will detect the respawn
+	client->ps.persistant[PERS_SPAWN_COUNT]++;
+
+	client->airOutTime = level.time + 12000;
+
+	client->ps.clientNum = ent->s.number;
+	// clear entity values
+
+	if ( ent->health )	// Was health supplied in map
+	{
+		client->pers.maxHealth = client->ps.stats[STAT_MAX_HEALTH] = ent->health;
+	}
+	else if ( ent->NPC->stats.health )	// Was health supplied in NPC.cfg?
+	{
+		
+		if ( ent->client->NPC_class != CLASS_REBORN
+			&& ent->client->NPC_class != CLASS_SHADOWTROOPER 
+			//&& ent->client->NPC_class != CLASS_TAVION
+			//&& ent->client->NPC_class != CLASS_DESANN 
+			&& ent->client->NPC_class != CLASS_JEDI )
+		{// up everyone except jedi
+			ent->NPC->stats.health += ent->NPC->stats.health/4 * g_spskill.integer; // 100% on easy, 125% on medium, 150% on hard
+		}
+		
+		client->pers.maxHealth = client->ps.stats[STAT_MAX_HEALTH] = ent->NPC->stats.health;
+	}
+	else
+	{
+		client->pers.maxHealth = client->ps.stats[STAT_MAX_HEALTH] = 100;
+	}
+
+	if ( !Q_stricmp( "rodian", ent->NPC_type ) )
+	{//sniper
+		//NOTE: this will get overridden by any aim settings in their spawnscripts
+		switch ( g_spskill.integer )
+		{
+		case 0:
+			ent->NPC->stats.aim = 1;
+			break;
+		case 1:
+			ent->NPC->stats.aim = Q_irand( 2, 3 );
+			break;
+		case 2:
+			ent->NPC->stats.aim = Q_irand( 3, 4 );
+			break;
+		}
+	}
+	else if ( ent->client->NPC_class == CLASS_STORMTROOPER
+		|| ent->client->NPC_class == CLASS_SWAMPTROOPER
+		|| ent->client->NPC_class == CLASS_IMPWORKER
+		|| !Q_stricmp( "rodian2", ent->NPC_type ) )
+	{//tweak yawspeed for these NPCs based on difficulty
+		switch ( g_spskill.integer )
+		{
+		case 0:
+			ent->NPC->stats.yawSpeed *= 0.75f;
+			if ( ent->client->NPC_class == CLASS_IMPWORKER )
+			{
+				ent->NPC->stats.aim -= Q_irand( 3, 6 );
+			}
+			break;
+		case 1:
+			if ( ent->client->NPC_class == CLASS_IMPWORKER )
+			{
+				ent->NPC->stats.aim -= Q_irand( 2, 4 );
+			}
+			break;
+		case 2:
+			ent->NPC->stats.yawSpeed *= 1.5f;
+			if ( ent->client->NPC_class == CLASS_IMPWORKER )
+			{
+				ent->NPC->stats.aim -= Q_irand( 0, 2 );
+			}
+			break;
+		}
+	}
+	else if ( ent->client->NPC_class == CLASS_REBORN
+		|| ent->client->NPC_class == CLASS_SHADOWTROOPER )
+	{
+		switch ( g_spskill.integer )
+		{
+		case 1:
+			ent->NPC->stats.yawSpeed *= 1.25f;
+			break;
+		case 2:
+			ent->NPC->stats.yawSpeed *= 1.5f;
+			break;
+		}
+	}
+
+
+	ent->s.groundEntityNum = ENTITYNUM_NONE;
+	ent->mass = 10;
+	ent->takedamage = qtrue;
+	ent->inuse = qtrue;
+	ent->classname = "NPC";
+//	if ( ent->client->race == RACE_HOLOGRAM )
+//	{//can shoot through holograms, but not walk through them
+//		ent->contents = CONTENTS_PLAYERCLIP|CONTENTS_MONSTERCLIP|CONTENTS_ITEM;//contents_corspe to make them show up in ID and use traces
+//		ent->clipmask = MASK_NPCSOLID;
+//	} else
+	if(!(ent->spawnflags & SFB_NOTSOLID))
+	{
+		ent->r.contents = CONTENTS_BODY;
+		ent->clipmask = MASK_NPCSOLID;
+	}
+	else
+	{
+		ent->r.contents = 0;
+		ent->clipmask = MASK_NPCSOLID&~CONTENTS_BODY;
+	}
+	/*
+	if(!ent->client->moveType)//Static?
+	{
+		ent->client->moveType = MT_RUNJUMP;
+	}
+	*/
+	//rwwFIXMEFIXME: movetype support
+
+	ent->die = player_die;
+	ent->waterlevel = 0;
+	ent->watertype = 0;
+	ent->client->ps.rocketLockIndex = ENTITYNUM_NONE;
+	ent->client->ps.rocketLockTime = 0;
+	
+	//visible to player and NPCs
+	if ( ent->client->NPC_class != CLASS_R2D2 &&
+		ent->client->NPC_class != CLASS_R5D2 &&
+		ent->client->NPC_class != CLASS_MOUSE &&
+		ent->client->NPC_class != CLASS_GONK &&
+		ent->client->NPC_class != CLASS_PROTOCOL )
+	{
+		ent->flags &= ~FL_NOTARGET;
+	}
+	ent->s.eFlags &= ~EF_NODRAW;
+
+	NPC_SetFX_SpawnStates( ent );
+	
+	//client->ps.friction = 6;
+	//rwwFIXMEFIXME: per ent friction?
+
+	if ( ent->client->ps.weapon == WP_NONE )
+	{//not set by the NPCs.cfg
+		NPC_SetWeapons(ent);
+	}
+	//select the weapon
+	ent->NPC->currentAmmo = ent->client->ps.ammo[weaponData[ent->client->ps.weapon].ammoIndex];
+	ent->client->ps.weaponstate = WEAPON_IDLE;
+	ChangeWeapon( ent, ent->client->ps.weapon );
+
+	VectorCopy( spawn_origin, client->ps.origin );
+
+	// the respawned flag will be cleared after the attack and jump keys come up
+	client->ps.pm_flags |= PMF_RESPAWNED;
+
+	// clear entity state values
+	//ent->s.eType = ET_PLAYER;
+	ent->s.eType = ET_NPC;
+//	ent->s.skinNum = ent - g_entities - 1;	// used as index to get custom models
+
+	VectorCopy (spawn_origin, ent->s.origin);
+//	ent->s.origin[2] += 1;	// make sure off ground
+
+	SetClientViewAngle( ent, spawn_angles );
+	client->renderInfo.lookTarget = ENTITYNUM_NONE;
+
+	if(!(ent->spawnflags & 64))
+	{
+		G_KillBox( ent );
+		trap_LinkEntity (ent);
+	}
+
+	// don't allow full run speed for a bit
+	client->ps.pm_flags |= PMF_TIME_KNOCKBACK;
+	client->ps.pm_time = 100;
+
+	client->respawnTime = level.time;
+	client->inactivityTime = level.time + g_inactivity.value * 1000;
+	client->latched_buttons = 0;
+	if ( ent->s.m_iVehicleNum )
+	{//I'm an NPC in a vehicle (or a vehicle), I already have owner set
+	}
+	else if ( client->NPC_class == CLASS_SEEKER && ent->activator != NULL )
+	{//somebody else "owns" me
+		ent->s.owner = ent->r.ownerNum = ent->activator->s.number;
+	}
+	else
+	{
+		ent->s.owner = ENTITYNUM_NONE;
+	}
+
+	// set default animations
+	if ( ent->client->NPC_class != CLASS_VEHICLE )
+	{
+		NPC_SetAnim( ent, SETANIM_BOTH, BOTH_STAND1, SETANIM_FLAG_NORMAL );
+	}
+
+	if( spawnPoint )
+	{
+		// fire the targets of the spawn point
+		G_UseTargets( spawnPoint, ent );
+	}
+
+	//ICARUS include
+	trap_ICARUS_InitEnt( ent );
+
+//==NPC initialization
+	SetNPCGlobals( ent );
+
+	ent->enemy = NULL;
+	NPCInfo->timeOfDeath = 0;
+	NPCInfo->shotTime = 0;
+	NPC_ClearGoal();
+	NPC_ChangeWeapon( ent->client->ps.weapon );
+
+//==Final NPC initialization
+	ent->pain  = NPC_PainFunc( ent ); //painF_NPC_Pain;
+	ent->touch = NPC_TouchFunc( ent ); //touchF_NPC_Touch;
+//	ent->NPC->side = 1;
+
+	ent->client->ps.ping = ent->NPC->stats.reactions * 50;
+
+	//MCG - Begin: NPC hacks
+	//FIXME: Set the team correctly
+	if (ent->s.NPC_class != CLASS_VEHICLE || g_gametype.integer != GT_SIEGE)
+	{
+		ent->client->ps.persistant[PERS_TEAM] = ent->client->playerTeam;
+	}
+
+	ent->use   = NPC_Use;
+	ent->think = NPC_Think;
+	ent->nextthink = level.time + FRAMETIME + Q_irand(0, 100);
+
+	NPC_SetMiscDefaultData( ent );
+	if ( ent->health <= 0 )
+	{
+		//ORIGINAL ID: health will count down towards max_health
+		ent->health = client->ps.stats[STAT_HEALTH] = ent->client->pers.maxHealth;
+	}
+	else
+	{
+		client->ps.stats[STAT_HEALTH] = ent->health;
+	}
+
+	if (ent->s.shouldtarget)
+	{
+		ent->maxHealth = ent->health;
+		G_ScaleNetHealth(ent);
+	}
+
+	ChangeWeapon( ent, ent->client->ps.weapon );//yes, again... sigh
+
+	if ( !(ent->spawnflags & SFB_STARTINSOLID) )
+	{//Not okay to start in solid
+		G_CheckInSolid( ent, qtrue );
+	}
+	VectorClear( ent->NPC->lastClearOrigin );
+
+	//Run a script if you have one assigned to you
+	if ( G_ActivateBehavior( ent, BSET_SPAWN ) )
+	{
+		trap_ICARUS_MaintainTaskManager(ent->s.number);
+	}
+
+	VectorCopy( ent->r.currentOrigin, ent->client->renderInfo.eyePoint );
+
+	// run a client frame to drop exactly to the floor,
+	// initialize animations and other things
+	memset( &ucmd, 0, sizeof( ucmd ) );
+	//_VectorCopy( client->pers.cmd_angles, ucmd.angles );
+	VectorCopy(client->pers.cmd.angles, ucmd.angles);
+	
+	ent->client->ps.groundEntityNum = ENTITYNUM_NONE;
+
+	if ( ent->NPC->aiFlags & NPCAI_MATCHPLAYERWEAPON )
+	{
+		//G_MatchPlayerWeapon( ent );
+		//rwwFIXMEFIXME: Use this? Probably doesn't really matter for MP.
+	}
+
+	ClientThink( ent->s.number, &ucmd );
+
+	trap_LinkEntity( ent );
+
+	if ( ent->client->playerTeam == NPCTEAM_ENEMY )
+	{//valid enemy spawned
+		if ( !(ent->spawnflags&SFB_CINEMATIC) && ent->NPC->behaviorState != BS_CINEMATIC )
+		{//not a cinematic enemy
+			if ( g_entities[0].client )
+			{
+				//g_entities[0].client->sess.missionStats.enemiesSpawned++;
+				//rwwFIXMEFIXME: Do something here? And this is a rather strange place to be storing
+				//this sort of data.
+			}
+		}
+	}
+	ent->waypoint = ent->NPC->homeWp = WAYPOINT_NONE;
+
+	if ( ent->m_pVehicle )
+	{//a vehicle
+		//check for droidunit
+		if ( ent->m_pVehicle->m_iDroidUnitTag != -1 )
+		{
+			char	*droidNPCType = NULL;
+			gentity_t *droidEnt = NULL;
+			if ( ent->model2 
+				&& ent->model2[0] )
+			{//specified on the NPC_Vehicle spawner ent
+				droidNPCType = ent->model2;
+			}
+			else if ( ent->m_pVehicle->m_pVehicleInfo->droidNPC
+				&& ent->m_pVehicle->m_pVehicleInfo->droidNPC[0] )
+			{//specified in the vehicle's .veh file
+				droidNPCType = ent->m_pVehicle->m_pVehicleInfo->droidNPC;
+			}
+
+			if ( droidNPCType != NULL )
+			{
+				if ( Q_stricmp( "random", droidNPCType ) == 0
+					|| Q_stricmp( "default", droidNPCType ) == 0 )
+				{//use default - R2D2 or R5D2
+					if ( Q_irand( 0, 1 ) )
+					{
+						droidNPCType = "r2d2";
+					}
+					else
+					{
+						droidNPCType = "r5d2";
+					}
+				}
+				droidEnt = NPC_SpawnType( ent, droidNPCType, NULL, qfalse );
+				if ( droidEnt != NULL )
+				{
+					if ( droidEnt->client )
+					{
+						droidEnt->client->ps.m_iVehicleNum =
+							droidEnt->s.m_iVehicleNum =
+							//droidEnt->s.otherEntityNum2 = 
+							droidEnt->s.owner = 
+							droidEnt->r.ownerNum = ent->s.number;
+						ent->m_pVehicle->m_pDroidUnit = (bgEntity_t *)droidEnt;
+						//SP way:
+						//droidEnt->s.m_iVehicleNum = ent->s.number;
+						//droidEnt->owner = ent;
+						VectorCopy( ent->r.currentOrigin, droidEnt->s.origin );
+						VectorCopy( ent->r.currentOrigin, droidEnt->client->ps.origin );
+						G_SetOrigin( droidEnt, droidEnt->s.origin );
+						trap_LinkEntity( droidEnt );
+						VectorCopy( ent->r.currentAngles, droidEnt->s.angles );
+						G_SetAngles( droidEnt, droidEnt->s.angles );
+						if ( droidEnt->NPC )
+						{
+							droidEnt->NPC->desiredYaw = droidEnt->s.angles[YAW];
+							droidEnt->NPC->desiredPitch = droidEnt->s.angles[PITCH];
+						}
+						droidEnt->flags |= FL_UNDYING;
+					}
+					else
+					{//wtf?
+						G_FreeEntity( droidEnt );
+					}
+				}
+			}
+		}
+	}
+}
+
+gNPC_t *gNPCPtrs[MAX_GENTITIES];
+
+gNPC_t *New_NPC_t(int entNum)
+{
+	gNPC_t *ptr;
+
+	if (!gNPCPtrs[entNum])
+	{
+		gNPCPtrs[entNum] = (gNPC_t *)BG_Alloc (sizeof(gNPC_t));
+	}
+		
+	ptr = gNPCPtrs[entNum];
+
+	if (ptr)
+	{
+		// clear it...
+		//
+		memset(ptr, 0, sizeof( *ptr ) );
+	}
+
+	return ptr;
+}
+
+#ifdef _XBOX
+void NPC_NPCPtrsClear(void)
+{
+	for(int i=0; i<MAX_GENTITIES; i++) {
+		gNPCPtrs[i] = NULL;
+	}
+}
+#endif
+
+/*
+-------------------------
+NPC_StasisSpawn_Go
+-------------------------
+*/
+/*	
+qboolean NPC_StasisSpawn_Go( gentity_t *ent )
+{
+	//Setup an owner pointer if we need it
+	if VALIDSTRING( ent->ownername )
+	{
+		ent->parent = G_Find( NULL, FOFS( targetname ), ent->ownername );
+		
+		if ( ( ent->parent ) && ( ent->parent->health <= 0 ) )
+		{//our spawner thing is broken
+			if ( ent->target2 && ent->target2[0] )
+			{
+				//Fire off our target2
+				G_UseTargets2( ent, ent, ent->target2 );
+
+				//Kill us
+				ent->e_ThinkFunc = thinkF_G_FreeEntity;
+				ent->nextthink = level.time + 100;
+			}
+			else
+			{
+				//Try to spawn again in one second
+				ent->e_ThinkFunc = thinkF_NPC_Spawn_Go;
+				ent->nextthink = level.time + 1000;
+			}
+			return qfalse;
+		}
+	}
+
+	//Test for an entity blocking the spawn
+	trace_t	tr;
+	trap_Trace( &tr, ent->r.currentOrigin, ent->r.mins, ent->r.maxs, ent->r.currentOrigin, ent->s.number, MASK_NPCSOLID );
+
+	//Can't have anything in the way
+	if ( tr.allsolid || tr.startsolid )
+	{
+		ent->nextthink = level.time + 1000;
+		return qfalse;
+	}
+
+	return qtrue;
+}
+*/
+void NPC_DefaultScriptFlags( gentity_t *ent )
+{
+	if ( !ent || !ent->NPC )
+	{
+		return;
+	}
+	//Set up default script flags
+	ent->NPC->scriptFlags = (SCF_CHASE_ENEMIES|SCF_LOOK_FOR_ENEMIES);
+}
+/*
+-------------------------
+NPC_Spawn_Go
+-------------------------
+*/
+#include "../namespace_begin.h"
+extern void G_CreateAnimalNPC( Vehicle_t **pVeh, const char *strAnimalType );
+extern void G_CreateSpeederNPC( Vehicle_t **pVeh, const char *strType );
+extern void G_CreateWalkerNPC( Vehicle_t **pVeh, const char *strAnimalType );
+extern void G_CreateFighterNPC( Vehicle_t **pVeh, const char *strType );
+#include "../namespace_end.h"
+
+gentity_t *NPC_Spawn_Do( gentity_t *ent )
+{
+	gentity_t	*newent = NULL;
+	int			index;
+	vec3_t		saveOrg;
+
+/*	//Do extra code for stasis spawners
+	if ( Q_stricmp( ent->classname, "NPC_Stasis" ) == 0 )
+	{
+		if ( NPC_StasisSpawn_Go( ent ) == qfalse )
+			return;
+	}
+*/
+
+	//Test for drop to floor
+	if ( ent->spawnflags & NSF_DROP_TO_FLOOR )
+	{
+		trace_t		tr;
+		vec3_t		bottom;
+
+		VectorCopy( ent->r.currentOrigin, saveOrg );
+		VectorCopy( ent->r.currentOrigin, bottom );
+		bottom[2] = MIN_WORLD_COORD;
+		trap_Trace( &tr, ent->r.currentOrigin, ent->r.mins, ent->r.maxs, bottom, ent->s.number, MASK_NPCSOLID );
+		if ( !tr.allsolid && !tr.startsolid && tr.fraction < 1.0 )
+		{
+			G_SetOrigin( ent, tr.endpos );
+		}
+	}
+
+	//Check the spawner's count
+	if( ent->count != -1 )
+	{
+		ent->count--;
+		
+		if( ent->count <= 0 )
+		{
+			ent->use = 0;//never again
+			//FIXME: why not remove me...?  Because of all the string pointers?  Just do G_NewStrings?
+		}
+	}
+
+	newent = G_Spawn();
+
+	if ( newent == NULL ) 
+	{
+		Com_Printf ( S_COLOR_RED"ERROR: NPC G_Spawn failed\n" );
+		return NULL;
+	}
+	
+	newent->fullName = ent->fullName;
+
+	newent->NPC = New_NPC_t(newent->s.number);	
+	if ( newent->NPC == NULL ) 
+	{		
+		Com_Printf ( S_COLOR_RED"ERROR: NPC G_Alloc NPC failed\n" );		
+		goto finish;
+		return NULL;
+	}	
+
+	//newent->client = (gclient_s *)G_Alloc (sizeof(gclient_s));
+	G_CreateFakeClient(newent->s.number, &newent->client);
+
+	newent->NPC->tempGoal = G_Spawn();
+	
+	if ( newent->NPC->tempGoal == NULL ) 
+	{
+		newent->NPC = NULL;
+		goto finish;
+		return NULL;
+	}
+
+	newent->NPC->tempGoal->classname = "NPC_goal";
+	newent->NPC->tempGoal->parent = newent;
+	newent->NPC->tempGoal->r.svFlags |= SVF_NOCLIENT;
+
+	if ( newent->client == NULL ) 
+	{
+		Com_Printf ( S_COLOR_RED"ERROR: NPC BG_Alloc client failed\n" );
+		goto finish;
+		return NULL;
+	}
+	
+	memset ( newent->client, 0, sizeof(*newent->client) );
+
+	//Assign the pointer for bg entity access
+	newent->playerState = &newent->client->ps;
+
+//==NPC_Connect( newent, net_name );===================================
+
+	if ( ent->NPC_type == NULL ) 
+	{
+		ent->NPC_type = "random";
+	}
+	else
+	{
+		ent->NPC_type = Q_strlwr( G_NewString( ent->NPC_type ) );
+	}
+
+	/*
+	if ( ent->svFlags & SVF_NO_BASIC_SOUNDS )
+	{
+		newent->svFlags |= SVF_NO_BASIC_SOUNDS;
+	}
+	if ( ent->svFlags & SVF_NO_COMBAT_SOUNDS )
+	{
+		newent->svFlags |= SVF_NO_COMBAT_SOUNDS;
+	}
+	if ( ent->svFlags & SVF_NO_EXTRA_SOUNDS )
+	{
+		newent->svFlags |= SVF_NO_EXTRA_SOUNDS;
+	}
+	*/
+	//rwwFIXMEFIXME: Use all these flags?
+	
+	if ( ent->message )
+	{//has a key
+		newent->message = ent->message;//transfer the key name
+		newent->flags |= FL_NO_KNOCKBACK;//don't fall off ledges
+	}
+
+	// If this is a vehicle we need to see what kind it is so we properlly allocate it.
+	if ( Q_stricmp( ent->classname, "NPC_Vehicle" ) == 0 )
+	{
+		// Get the vehicle entry index.
+		int iVehIndex = BG_VehicleGetIndex( ent->NPC_type );
+
+ 		if ( iVehIndex == VEHICLE_NONE )
+		{
+			G_FreeEntity( newent );
+			//get rid of the spawner, too, I guess
+			G_FreeEntity( ent );
+			return NULL;
+		}
+		// NOTE: If you change/add any of these, update NPC_Spawn_f for the new vehicle you
+		// want to be able to spawn in manually.
+
+		// See what kind of vehicle this is and allocate it properly.
+		switch( g_vehicleInfo[iVehIndex].type )
+		{
+			case VH_ANIMAL:
+				// Create the animal (making sure all it's data is initialized).
+				G_CreateAnimalNPC( &newent->m_pVehicle, ent->NPC_type );
+				break;
+			case VH_SPEEDER:
+				// Create the speeder (making sure all it's data is initialized).
+				G_CreateSpeederNPC( &newent->m_pVehicle, ent->NPC_type );
+				break;
+			case VH_FIGHTER:
+				// Create the fighter (making sure all it's data is initialized).
+				G_CreateFighterNPC( &newent->m_pVehicle, ent->NPC_type );
+				break;
+			case VH_WALKER:
+				// Create the walker (making sure all it's data is initialized).
+				G_CreateWalkerNPC( &newent->m_pVehicle, ent->NPC_type );
+				break;
+
+			default:
+				Com_Printf ( S_COLOR_RED "ERROR: Couldn't spawn NPC %s\n", ent->NPC_type );
+				G_FreeEntity( newent );
+				//get rid of the spawner, too, I guess
+				G_FreeEntity( ent );
+				return NULL;
+		}
+
+		assert(newent->m_pVehicle &&
+			newent->m_pVehicle->m_pVehicleInfo &&
+			newent->m_pVehicle->m_pVehicleInfo->Initialize);
+
+		//set up my happy prediction hack
+		newent->m_pVehicle->m_vOrientation = &newent->client->ps.vehOrientation[0];
+
+		// Setup the vehicle.
+		newent->m_pVehicle->m_pParentEntity = (bgEntity_t *)newent;
+		newent->m_pVehicle->m_pVehicleInfo->Initialize( newent->m_pVehicle );
+
+		//cache all the assets
+		newent->m_pVehicle->m_pVehicleInfo->RegisterAssets( newent->m_pVehicle );
+		//set the class
+		newent->client->NPC_class = CLASS_VEHICLE;
+		if ( g_vehicleInfo[iVehIndex].type == VH_FIGHTER )
+		{//FIXME: EXTERN!!!
+			newent->flags |= (FL_NO_KNOCKBACK|FL_SHIELDED|FL_DMG_BY_HEAVY_WEAP_ONLY);//don't get pushed around, blasters bounce off, only damage from heavy weaps
+		}
+		//WTF?!!! Ships spawning in pointing straight down!
+		//set them up to start landed
+		newent->m_pVehicle->m_vOrientation[YAW] = ent->s.angles[YAW];
+		newent->m_pVehicle->m_vOrientation[PITCH] = newent->m_pVehicle->m_vOrientation[ROLL] = 0.0f;
+		G_SetAngles( newent, newent->m_pVehicle->m_vOrientation );
+		SetClientViewAngle( newent, newent->m_pVehicle->m_vOrientation );
+
+		//newent->m_pVehicle->m_ulFlags |= VEH_GEARSOPEN;
+		//why? this would just make it so the initial anim never got played... -rww
+		//There was no initial anim, it would just open the gear even though it's already on the ground (fixed now, made an initial anim)
+		
+		//For SUSPEND spawnflag, the amount of time to drop like a rock after SUSPEND turns off
+		newent->fly_sound_debounce_time = ent->fly_sound_debounce_time;
+
+		//for no-pilot-death delay
+		newent->damage = ent->damage;
+
+		//no-pilot-death distance
+		newent->speed = ent->speed;
+
+		//for veh transfer all healy stuff
+		newent->healingclass = ent->healingclass;
+		newent->healingsound = ent->healingsound;
+		newent->healingrate = ent->healingrate;
+		newent->model2 = ent->model2;//for droidNPC
+	}
+	else
+	{
+		newent->client->ps.weapon = WP_NONE;//init for later check in NPC_Begin
+	}
+    
+	VectorCopy(ent->s.origin, newent->s.origin);
+	VectorCopy(ent->s.origin, newent->client->ps.origin);
+	VectorCopy(ent->s.origin, newent->r.currentOrigin);
+	G_SetOrigin(newent, ent->s.origin);//just to be sure!
+	//NOTE: on vehicles, anything in the .npc file will STOMP data on the NPC that's set by the vehicle
+	if ( !NPC_ParseParms( ent->NPC_type, newent ) )
+	{
+		Com_Printf ( S_COLOR_RED "ERROR: Couldn't spawn NPC %s\n", ent->NPC_type );
+		G_FreeEntity( newent );
+		//get rid of the spawner, too, I guess
+		G_FreeEntity( ent );
+		return NULL;
+	}
+
+	if ( ent->NPC_type )
+	{
+		if ( !Q_stricmp( ent->NPC_type, "kyle" ) )
+		{//FIXME: "player", not Kyle?  Or check NPC_type against player's NPC_type?
+			newent->NPC->aiFlags |= NPCAI_MATCHPLAYERWEAPON;
+		}
+		else if ( !Q_stricmp( ent->NPC_type, "test" ) )
+		{
+			int	n;
+			for ( n = 0; n < 1 ; n++) 
+			{
+				if ( g_entities[n].s.eType != ET_NPC && g_entities[n].client) 
+				{
+					VectorCopy(g_entities[n].s.origin, newent->s.origin);
+					newent->client->playerTeam = newent->s.teamowner = g_entities[n].client->playerTeam;
+					break;
+				}
+			}
+			newent->NPC->defaultBehavior = newent->NPC->behaviorState = BS_WAIT;
+			newent->classname = "NPC";
+	//		newent->svFlags |= SVF_NOPUSH;
+		}
+	}
+//=====================================================================
+	//set the info we want
+	if ( !newent->health )
+	{
+		newent->health = ent->health;
+	}
+	newent->script_targetname = ent->NPC_targetname;
+	newent->targetname = ent->NPC_targetname;
+	newent->target = ent->NPC_target;//death
+	newent->target2 = ent->target2;//knocked out death
+	newent->target3 = ent->target3;//???
+	newent->target4 = ent->target4;//ffire death
+	newent->wait = ent->wait;
+	
+	for( index = BSET_FIRST; index < NUM_BSETS; index++)
+	{
+		if ( ent->behaviorSet[index] )
+		{
+			newent->behaviorSet[index] = ent->behaviorSet[index];
+		}
+	}
+
+	newent->classname = "NPC";
+	newent->NPC_type = ent->NPC_type;
+	trap_UnlinkEntity(newent);
+	
+	VectorCopy(ent->s.angles, newent->s.angles);
+	VectorCopy(ent->s.angles, newent->r.currentAngles);
+	VectorCopy(ent->s.angles, newent->client->ps.viewangles);
+	newent->NPC->desiredYaw =ent->s.angles[YAW];
+	
+	trap_LinkEntity(newent);
+	newent->spawnflags = ent->spawnflags;
+
+	if(ent->paintarget)
+	{	//safe to point at owner's string since memory is never freed during game
+		newent->paintarget = ent->paintarget;
+	}
+	if(ent->opentarget)
+	{
+		newent->opentarget = ent->opentarget;
+	}
+
+//==New stuff=====================================================================
+	newent->s.eType	= ET_NPC;//ET_PLAYER;
+	
+	//FIXME: Call CopyParms
+	if ( ent->parms )
+	{
+		int parmNum;
+
+		for ( parmNum = 0; parmNum < MAX_PARMS; parmNum++ )
+		{
+			if ( ent->parms->parm[parmNum] && ent->parms->parm[parmNum][0] )
+			{
+				Q3_SetParm( newent->s.number, parmNum, ent->parms->parm[parmNum] );
+			}
+		}
+	}
+	//FIXME: copy cameraGroup, store mine in message or other string field
+
+	//set origin
+	newent->s.pos.trType = TR_INTERPOLATE;
+	newent->s.pos.trTime = level.time;
+	VectorCopy( newent->r.currentOrigin, newent->s.pos.trBase );
+	VectorClear( newent->s.pos.trDelta );
+	newent->s.pos.trDuration = 0;
+	//set angles
+	newent->s.apos.trType = TR_INTERPOLATE;
+	newent->s.apos.trTime = level.time;
+	//VectorCopy( newent->r.currentOrigin, newent->s.apos.trBase );
+	//Why was the origin being used as angles? Typo I'm assuming -rww
+	VectorCopy( newent->s.angles, newent->s.apos.trBase );
+
+	VectorClear( newent->s.apos.trDelta );
+	newent->s.apos.trDuration = 0;
+	
+	newent->NPC->combatPoint = -1;
+
+	newent->flags |= FL_NOTARGET;//So he's ignored until he's fully spawned
+	newent->s.eFlags |= EF_NODRAW;//So he's ignored until he's fully spawned
+
+	newent->think = NPC_Begin;
+	newent->nextthink = level.time + FRAMETIME;
+	NPC_DefaultScriptFlags( newent );
+
+	//copy over team variables, too
+	newent->s.shouldtarget = ent->s.shouldtarget;
+	newent->s.teamowner = ent->s.teamowner;
+	newent->alliedTeam = ent->alliedTeam;
+	newent->teamnodmg = ent->teamnodmg;
+	if ( ent->team && ent->team[0] )
+	{//specified team directly?
+		newent->client->sess.sessionTeam = atoi(ent->team);
+	}
+	else if ( newent->s.teamowner != TEAM_FREE )
+	{
+		newent->client->sess.sessionTeam = newent->s.teamowner;
+	}
+	else if ( newent->alliedTeam != TEAM_FREE )
+	{
+		newent->client->sess.sessionTeam = newent->alliedTeam;
+	}
+	else if ( newent->teamnodmg != TEAM_FREE )
+	{
+		newent->client->sess.sessionTeam = newent->teamnodmg;
+	}
+	else
+	{
+		newent->client->sess.sessionTeam = TEAM_FREE;
+	}
+	newent->client->ps.persistant[PERS_TEAM] = newent->client->sess.sessionTeam;
+
+	trap_LinkEntity (newent);
+
+	if(!ent->use)
+	{
+		if( ent->target )
+		{//use any target we're pointed at
+			G_UseTargets ( ent, ent );
+		}
+		if(ent->closetarget)
+		{//last guy should fire this target when he dies
+			newent->target = ent->closetarget;
+		}
+		ent->targetname = NULL;
+		//why not remove me...?  Because of all the string pointers?  Just do G_NewStrings?
+		G_FreeEntity( ent );//bye!
+	}
+
+finish:
+	if ( ent->spawnflags & NSF_DROP_TO_FLOOR )
+	{
+		G_SetOrigin( ent, saveOrg );
+	}
+
+	return newent;
+}
+
+void NPC_Spawn_Go(gentity_t *ent)
+{
+	NPC_Spawn_Do(ent);
+}
+
+/*
+-------------------------
+NPC_StasisSpawnEffect
+-------------------------
+*/
+/*
+void NPC_StasisSpawnEffect( gentity_t *ent )
+{
+	vec3_t		start, end, forward;
+	qboolean	taper;
+
+	//Floor or wall?
+	if ( ent->spawnflags & 1 )
+	{
+		AngleVectors( ent->s.angles, forward, NULL, NULL );
+		VectorMA( ent->r.currentOrigin,  24, forward, end );
+		VectorMA( ent->r.currentOrigin, -20, forward, start );
+		
+		start[2] += 64;
+		
+		taper = qtrue;
+	}
+	else
+	{
+		VectorCopy( ent->r.currentOrigin, start );
+		VectorCopy( start, end );
+		end[2] += 48;
+		taper = qfalse;
+	}
+
+	//Add the effect
+//	CG_ShimmeryThing_Spawner( start, end, 32, qtrue, 1000 );
+}
+*/
+/*
+-------------------------
+NPC_ShySpawn
+-------------------------
+*/
+
+#define SHY_THINK_TIME			1000
+#define SHY_SPAWN_DISTANCE		128
+#define SHY_SPAWN_DISTANCE_SQR	( SHY_SPAWN_DISTANCE * SHY_SPAWN_DISTANCE )
+
+void NPC_ShySpawn( gentity_t *ent )
+{
+	ent->nextthink = level.time + SHY_THINK_TIME;
+	ent->think = NPC_ShySpawn;
+
+	//rwwFIXMEFIXME: Care about other clients not just 0?
+	if ( DistanceSquared( g_entities[0].r.currentOrigin, ent->r.currentOrigin ) <= SHY_SPAWN_DISTANCE_SQR )
+		return;
+
+	if ( (InFOV( ent, &g_entities[0], 80, 64 )) ) // FIXME: hardcoded fov
+		if ( (NPC_ClearLOS2( &g_entities[0], ent->r.currentOrigin )) )
+			return;
+
+	ent->think = 0;
+	ent->nextthink = 0;
+
+	NPC_Spawn_Go( ent );
+}
+
+/*
+-------------------------
+NPC_Spawn
+-------------------------
+*/
+
+void NPC_Spawn ( gentity_t *ent, gentity_t *other, gentity_t *activator )
+{
+	//delay before spawning NPC
+	if( ent->delay )
+	{
+/*		//Stasis does an extra step
+		if ( Q_stricmp( ent->classname, "NPC_Stasis" ) == 0 )
+		{
+			if ( NPC_StasisSpawn_Go( ent ) == qfalse )
+				return;
+		}
+*/
+		if ( ent->spawnflags & 2048 )  // SHY
+		{
+			ent->think = NPC_ShySpawn;
+		}
+		else
+		{
+			ent->think = NPC_Spawn_Go;
+		}
+
+		ent->nextthink = level.time + ent->delay;
+	}
+	else
+	{
+		if ( ent->spawnflags & 2048 )  // SHY
+		{
+			NPC_ShySpawn( ent );
+		}
+		else
+		{
+			NPC_Spawn_Do( ent );
+		}
+	}
+}
+
+/*QUAKED NPC_spawner (1 0 0) (-16 -16 -24) (16 16 40) x x x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+
+NPC_type - name of NPC (in npcs.cfg) to spawn in
+
+targetname - name this NPC goes by for targetting
+target - NPC will fire this when it spawns it's last NPC (should this be when the last NPC it spawned dies?)
+target2 - Fired by stasis spawners when they try to spawn while their spawner model is broken
+target3 - Fired by spawner if they try to spawn and are blocked and have a wait < 0 (removes them)
+
+If targeted, will only spawn a NPC when triggered
+count - how many NPCs to spawn (only if targetted) default = 1
+delay - how long to wait to spawn after used
+wait - if trying to spawn and blocked, how many seconds to wait before trying again (default = 0.5, < 0 = never try again and fire target2)
+
+NPC_targetname - NPC's targetname AND script_targetname
+NPC_target - NPC's target to fire when killed
+NPC_target2 - NPC's target to fire when knocked out
+NPC_target4 - NPC's target to fire when killed by friendly fire
+NPC_type - type of NPC ("Borg" (default), "Xian", etc)
+health - starting health (default = 100)
+
+spawnscript - default script to run once spawned (none by default)
+usescript - default script to run when used (none by default)
+awakescript - default script to run once awoken (none by default)
+angerscript - default script to run once angered (none by default)
+painscript - default script to run when hit (none by default)
+fleescript - default script to run when hit and below 50% health (none by default)
+deathscript - default script to run when killed (none by default)
+These strings can be used to activate behaviors instead of scripts - these are checked
+first and so no scripts should be names with these names:
+    default - 0: whatever
+	idle - 1: Stand around, do abolutely nothing
+	roam - 2: Roam around, collect stuff
+	walk - 3: Crouch-Walk toward their goals
+	run - 4: Run toward their goals
+	standshoot - 5: Stay in one spot and shoot- duck when neccesary
+	standguard - 6: Wait around for an enemy
+	patrol - 7: Follow a path, looking for enemies
+	huntkill - 8: Track down enemies and kill them
+	evade - 9: Run from enemies
+	evadeshoot - 10: Run from enemies, shoot them if they hit you
+	runshoot - 11: Run to your goal and shoot enemy when possible
+	defend - 12: Defend an entity or spot?
+	snipe - 13: Stay hidden, shoot enemy only when have perfect shot and back turned
+	combat - 14: Attack, evade, use cover, move about, etc.  Full combat AI - id NPC code
+	medic - 15: Go for lowest health buddy, hide and heal him.
+	takecover - 16: Find nearest cover from enemies
+	getammo - 17: Go get some ammo
+	advancefight - 18: Go somewhere and fight along the way
+	face - 19: turn until facing desired angles
+	wait - 20: do nothing
+	formation - 21: Maintain a formation
+	crouch - 22: Crouch-walk toward their goals
+
+delay - after spawned or triggered, how many seconds to wait to spawn the NPC
+
+showhealth - set to 1 to show health bar on this entity when crosshair is over it
+
+teamowner - crosshair shows green for this team, red for opposite team
+	0 - none
+	1 - red
+	2 - blue
+
+teamuser - only this team can use this NPC
+	0 - none
+	1 - red
+	2 - blue
+
+teamnodmg - team that NPC does not take damage from (turrets and other auto-defenses that have "alliedTeam" set to this team won't target this NPC)
+	0 - none
+	1 - red
+	2 - blue
+*/
+//void NPC_PrecacheModels ( char *NPCName );
+extern void NPC_PrecacheAnimationCFG( const char *NPC_type );
+void NPC_Precache ( gentity_t *spawner );
+void NPC_PrecacheType( char *NPC_type )
+{
+	gentity_t *fakespawner = G_Spawn();
+	if ( fakespawner )
+	{
+		fakespawner->NPC_type = NPC_type;
+		NPC_Precache( fakespawner );
+		//NOTE: does the spawner have to stay around to send any precached info to the clients...?
+		G_FreeEntity( fakespawner );
+	}
+}
+
+void SP_NPC_spawner( gentity_t *self)
+{
+	int t;
+
+	if (!g_allowNPC.integer)
+	{
+		self->think = G_FreeEntity;
+		self->nextthink = level.time;
+		return;
+	}
+	if ( !self->fullName || !self->fullName[0] )
+	{
+		//FIXME: make an index into an external string table for localization
+		self->fullName = "Humanoid Lifeform";
+	}
+
+	//register/precache the models needed for this NPC, not anymore
+	//self->classname = "NPC_spawner";
+
+	if(!self->count)
+	{
+		self->count = 1;
+	}
+
+	/*
+	{//Stop loading of certain extra sounds
+		static	int	garbage;
+
+		if ( G_SpawnInt( "noBasicSounds", "0", &garbage ) )
+		{
+			self->svFlags |= SVF_NO_BASIC_SOUNDS;
+		}
+		if ( G_SpawnInt( "noCombatSounds", "0", &garbage ) )
+		{
+			self->svFlags |= SVF_NO_COMBAT_SOUNDS;
+		}
+		if ( G_SpawnInt( "noExtraSounds", "0", &garbage ) )
+		{
+			self->svFlags |= SVF_NO_EXTRA_SOUNDS;
+		}
+	}
+	*/
+	//rwwFIXMEFIXME: Use these flags?
+
+	if ( !self->wait )
+	{
+		self->wait = 500;
+	}
+	else
+	{
+		self->wait *= 1000;//1 = 1 msec, 1000 = 1 sec
+	}
+
+	self->delay *= 1000;//1 = 1 msec, 1000 = 1 sec
+
+	G_SpawnInt( "showhealth", "0", &t );
+	if (t)
+	{
+		self->s.shouldtarget = qtrue;
+	}
+	/*
+	if ( self->delay > 0 )
+	{
+		self->svFlags |= SVF_NPC_PRECACHE;
+	}
+	*/
+	//rwwFIXMEFIXME: support for this flag?
+
+	//We have to load the animation.cfg now because spawnscripts are going to want to set anims and we need to know their length and if they're valid
+	NPC_PrecacheAnimationCFG( self->NPC_type );
+
+	//rww - can't cheat and do this on the client like in SP, so I'm doing this.
+	NPC_Precache(self);
+
+	if ( self->targetname )
+	{//Wait for triggering
+		self->use = NPC_Spawn;
+	//	self->svFlags |= SVF_NPC_PRECACHE;//FIXME: precache my weapons somehow?
+
+		//NPC_PrecacheModels( self->NPC_type );
+	}
+	else
+	{
+		//NOTE: auto-spawners never check for shy spawning
+		//if ( spawning )
+		if (1) //just gonna always do this I suppose.
+		{//in entity spawn stage - map starting up
+			self->think = NPC_Spawn_Go;
+			self->nextthink = level.time + START_TIME_REMOVE_ENTS + 50;
+		}
+		else
+		{//else spawn right now
+			NPC_Spawn( self, self, self );
+		}
+	}
+
+	//FIXME: store cameraGroup somewhere else and apply to spawned NPCs' cameraGroup
+	//Or just don't include NPC_spawners in cameraGroupings
+}
+
+extern void G_VehicleSpawn( gentity_t *self );
+/*QUAKED NPC_Vehicle (1 0 0) (-16 -16 -24) (16 16 32) NO_PILOT_DIE SUSPENDED x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+NO_PILOT_DIE - die after certain amount of time of not having a pilot
+SUSPENDED - Fighters: Don't drop until someone gets in it (this only works as long as no-nw has *ever* ridden the vehicle, to simulate ships that are suspended-docked) - note: ships inside trigger_spaces do not drop when unoccupied
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+
+set NPC_type to vehicle name in vehicles.dat
+
+"dropTime" use with SUSPENDED - if set, the vehicle will drop straight down for this number of seconds before flying forward
+"dmg" use with NO_PILOT_DIE - delay in milliseconds for ship to explode if no pilot (default 10000)
+"speed" use with NO_PILOT_DIE - distance for pilot to get away from ship after dismounting before it starts counting down the death timer
+"model2" - if the vehicle can have a droid (has "*droidunit" tag), this NPC will be spawned and placed there - note: game will automatically use the one specified in the .veh file (if any) or, absent that, it will use an R2D2 or R5D2 NPC)
+
+showhealth - set to 1 to show health bar on this entity when crosshair is over it
+
+teamowner - crosshair shows green for this team, red for opposite team
+	0 - none
+	1 - red
+	2 - blue
+
+teamuser - only this team can use this NPC
+	0 - none
+	1 - red
+	2 - blue
+
+teamnodmg - team that NPC does not take damage from (turrets and other auto-defenses that have "alliedTeam" set to this team won't target this NPC)
+	0 - none
+	1 - red
+	2 - blue
+*/
+qboolean NPC_VehiclePrecache( gentity_t *spawner )
+{
+	char *droidNPCType = NULL;
+	//This will precache the vehicle
+	vehicleInfo_t *pVehInfo;
+	int iVehIndex = BG_VehicleGetIndex( spawner->NPC_type );
+ 	if ( iVehIndex == VEHICLE_NONE )
+	{//fixme: error msg?
+		return qfalse;
+	}
+
+	G_ModelIndex(va("$%s", spawner->NPC_type)); //make sure the thing is frickin precached
+	//now cache his model/skin/anim config
+	pVehInfo = &g_vehicleInfo[iVehIndex];
+	if (pVehInfo->model && pVehInfo->model[0])
+	{
+		void *tempG2 = NULL;
+		int skin = 0;
+		if (pVehInfo->skin && pVehInfo->skin[0])
+		{
+			skin = trap_R_RegisterSkin(va("models/players/%s/model_%s.skin", pVehInfo->model, pVehInfo->skin));
+		}
+		trap_G2API_InitGhoul2Model(&tempG2, va("models/players/%s/model.glm", pVehInfo->model), 0, skin, 0, 0, 0);
+		if (tempG2)
+		{ //now, cache the anim config.
+			char GLAName[1024];
+
+			GLAName[0] = 0;
+			trap_G2API_GetGLAName(tempG2, 0, GLAName);
+
+			if (GLAName[0])
+			{
+				char *slash = Q_strrchr( GLAName, '/' );
+				if ( slash )
+				{
+					strcpy(slash, "/animation.cfg");
+
+					BG_ParseAnimationFile(GLAName, NULL, qfalse);
+				}
+			}
+			trap_G2API_CleanGhoul2Models(&tempG2);
+		}
+	}
+
+	//also precache the droid NPC if there is one
+	if ( spawner->model2 
+		&& spawner->model2[0] )
+	{
+		droidNPCType = spawner->model2;
+	}
+	else if ( g_vehicleInfo[iVehIndex].droidNPC
+		&& g_vehicleInfo[iVehIndex].droidNPC[0] )
+	{
+		droidNPCType = g_vehicleInfo[iVehIndex].droidNPC;
+	}
+
+	if ( droidNPCType )
+	{
+		if ( Q_stricmp( "random", droidNPCType ) == 0
+			|| Q_stricmp( "default", droidNPCType ) == 0 )
+		{//precache both r2 and r5, as defaults
+			NPC_PrecacheType( "r2d2" );
+			NPC_PrecacheType( "r5d2" );
+		}
+		else
+		{
+			NPC_PrecacheType( droidNPCType );
+		}
+	}
+	return qtrue;
+}
+
+void NPC_VehicleSpawnUse( gentity_t *self, gentity_t *other, gentity_t *activator )
+{
+	if ( self->delay )
+	{
+		self->think = G_VehicleSpawn;
+		self->nextthink = level.time + self->delay;
+	}
+	else
+	{
+		G_VehicleSpawn( self );
+	}
+}
+
+void SP_NPC_Vehicle( gentity_t *self)
+{
+	float dropTime;
+	int		t;
+	if ( !self->NPC_type )
+	{
+		self->NPC_type = "swoop";
+	}
+
+	if ( !self->classname )
+	{
+		self->classname = "NPC_Vehicle";
+	}
+
+	if ( !self->wait )
+	{
+		self->wait = 500;
+	}
+	else
+	{
+		self->wait *= 1000;//1 = 1 msec, 1000 = 1 sec
+	}
+	self->delay *= 1000;//1 = 1 msec, 1000 = 1 sec
+
+	G_SetOrigin( self, self->s.origin );
+	G_SetAngles( self, self->s.angles );
+	G_SpawnFloat( "dropTime", "0", &dropTime );
+	if ( dropTime )
+	{
+		self->fly_sound_debounce_time = ceil(dropTime*1000.0);
+	}
+	
+	G_SpawnInt( "showhealth", "0", &t );
+	if (t)
+	{
+		self->s.shouldtarget = qtrue;
+	}
+	//FIXME: PRECACHE!!!
+
+	if ( self->targetname )
+	{
+		if ( !NPC_VehiclePrecache( self ) )
+		{//FIXME: err msg?
+			G_FreeEntity( self );
+			return;
+		}
+		self->use = NPC_VehicleSpawnUse;
+	}
+	else
+	{
+		if ( self->delay )
+		{
+			if ( !NPC_VehiclePrecache( self ) )
+			{//FIXME: err msg?
+				G_FreeEntity( self );
+				return;
+			}
+			self->think = G_VehicleSpawn;
+			self->nextthink = level.time + self->delay;
+		}
+		else
+		{
+			G_VehicleSpawn( self );
+		}
+	}
+}
+
+//Characters
+
+//STAR WARS NPCs============================================================================
+/*QUAKED NPC_spawner (1 0 0) (-16 -16 -24) (16 16 32) x x x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+
+targetname - name this NPC goes by for targetting
+target - NPC will fire this when it spawns it's last NPC (should this be when the last NPC it spawned dies?)
+
+If targeted, will only spawn a NPC when triggered
+count - how many NPCs to spawn (only if targetted) default = 1
+
+NPC_type - the name of the NPC (from NPCs.cfg or a from .npc file)
+
+NPC_targetname - NPC's targetname AND script_targetname
+NPC_target - NPC's target to fire when killed
+health - starting health (default = 100)
+playerTeam - Who not to shoot! (default is TEAM_STARFLEET)
+	TEAM_FREE (none) = 0
+	TEAM_RED = 1
+	TEAM_BLUE = 2
+	TEAM_GOLD = 3
+	TEAM_GREEN = 4
+	TEAM_STARFLEET = 5
+	TEAM_BORG = 6
+	TEAM_SCAVENGERS = 7
+	TEAM_STASIS = 8
+	TEAM_NPCS = 9
+	TEAM_HARVESTER, = 10
+	TEAM_FORGE = 11
+enemyTeam - Who to shoot (all but own if not set)
+
+spawnscript - default script to run once spawned (none by default)
+usescript - default script to run when used (none by default)
+awakescript - default script to run once awoken (none by default)
+angerscript - default script to run once angered (none by default)
+painscript - default script to run when hit (none by default)
+fleescript - default script to run when hit and below 50% health (none by default)
+deathscript - default script to run when killed (none by default)
+
+These strings can be used to activate behaviors instead of scripts - these are checked
+first and so no scripts should be names with these names:
+    default - 0: whatever
+	idle - 1: Stand around, do abolutely nothing
+	roam - 2: Roam around, collect stuff
+	walk - 3: Crouch-Walk toward their goals
+	run - 4: Run toward their goals
+	standshoot - 5: Stay in one spot and shoot- duck when neccesary
+	standguard - 6: Wait around for an enemy
+	patrol - 7: Follow a path, looking for enemies
+	huntkill - 8: Track down enemies and kill them
+	evade - 9: Run from enemies
+	evadeshoot - 10: Run from enemies, shoot them if they hit you
+	runshoot - 11: Run to your goal and shoot enemy when possible
+	defend - 12: Defend an entity or spot?
+	snipe - 13: Stay hidden, shoot enemy only when have perfect shot and back turned
+	combat - 14: Attack, evade, use cover, move about, etc.  Full combat AI - id NPC code
+	medic - 15: Go for lowest health buddy, hide and heal him.
+	takecover - 16: Find nearest cover from enemies
+	getammo - 17: Go get some ammo
+	advancefight - 18: Go somewhere and fight along the way
+	face - 19: turn until facing desired angles
+	wait - 20: do nothing
+	formation - 21: Maintain a formation
+	crouch - 22: Crouch-walk toward their goals
+
+delay - after spawned or triggered, how many seconds to wait to spawn the NPC
+*/
+
+//=============================================================================================
+//CHARACTERS
+//=============================================================================================
+
+/*QUAKED NPC_Kyle (1 0 0) (-16 -16 -24) (16 16 32) x RIFLEMAN PHASER TRICORDER DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_Kyle( gentity_t *self)
+{
+	self->NPC_type = "Kyle";
+
+	WP_SetSaberModel( NULL, CLASS_KYLE );
+
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_Lando(1 0 0) (-16 -16 -24) (16 16 40) x x x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_Lando( gentity_t *self)
+{
+	self->NPC_type = "Lando";
+
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_Jan(1 0 0) (-16 -16 -24) (16 16 40) x x x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_Jan( gentity_t *self)
+{
+	self->NPC_type = "Jan";
+
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_Luke(1 0 0) (-16 -16 -24) (16 16 40) x x x x CEILING CINEMATIC NOTSOLID STARTINSOLID SHY
+CEILING - Sticks to the ceiling until he sees an enemy or takes pain
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_Luke( gentity_t *self)
+{
+	self->NPC_type = "Luke";
+
+	WP_SetSaberModel( NULL, CLASS_LUKE );
+
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_MonMothma(1 0 0) (-16 -16 -24) (16 16 40) x x x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_MonMothma( gentity_t *self)
+{
+	self->NPC_type = "MonMothma";
+
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_Tavion (1 0 0) (-16 -16 -24) (16 16 32) x x x x CEILING CINEMATIC NOTSOLID STARTINSOLID SHY
+CEILING - Sticks to the ceiling until he sees an enemy or takes pain
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_Tavion( gentity_t *self)
+{
+	self->NPC_type = "Tavion";
+
+	WP_SetSaberModel( NULL, CLASS_TAVION );
+
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_Tavion_New (1 0 0) (-16 -16 -24) (16 16 32) SCEPTER SITH_SWORD x x CEILING CINEMATIC NOTSOLID STARTINSOLID SHY
+Has a red lightsaber and force powers, uses her saber style from JK2
+
+SCEPTER - Has a red lightsaber and force powers, Ragnos' Scepter in left hand, uses dual saber style and occasionally attacks with Scepter
+SITH_SWORD - Has Ragnos' Sith Sword in right hand and force powers, uses strong style
+CEILING - Sticks to the ceiling until he sees an enemy or takes pain
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_Tavion_New( gentity_t *self)
+{
+	if ( (self->spawnflags&1) )
+	{
+		self->NPC_type = "tavion_scepter";
+	}
+	else if ( (self->spawnflags&2) )
+	{
+		self->NPC_type = "tavion_sith_sword";
+	}
+	else
+	{
+		self->NPC_type = "tavion_new";
+	}
+
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_Alora (1 0 0) (-16 -16 -24) (16 16 32) DUAL x x x CEILING CINEMATIC NOTSOLID STARTINSOLID SHY
+Lightsaber and level 2 force powers, 300 health
+
+DUAL - Dual sabers and level 3 force powers, 500 health
+CEILING - Sticks to the ceiling until he sees an enemy or takes pain
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_Alora( gentity_t *self)
+{
+	if ( (self->spawnflags&1) )
+	{
+		self->NPC_type = "alora_dual";
+	}
+	else
+	{
+		self->NPC_type = "alora";
+	}
+
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_Reborn_New(1 0 0) (-16 -16 -24) (16 16 40) DUAL STAFF WEAK x CEILING CINEMATIC NOTSOLID STARTINSOLID SHY
+
+Reborn is an excellent lightsaber fighter, acrobatic and uses force powers.  Full-length red saber, 200 health.
+
+DUAL - Use 2 shorter sabers
+STAFF - Uses a saber staff
+WEAK - Is a bit less tough
+CEILING - Sticks to the ceiling until he sees an enemy or takes pain
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_Reborn_New( gentity_t *self)
+{
+	if ( !self->NPC_type )
+	{
+		if ( (self->spawnflags&4) )
+		{//weaker guys
+			if ( (self->spawnflags&1) )
+			{
+				self->NPC_type = "reborn_dual2";
+			}
+			else if ( (self->spawnflags&2) )
+			{
+				self->NPC_type = "reborn_staff2";
+			}
+			else
+			{
+				self->NPC_type = "reborn_new2";
+			}
+		}
+		else
+		{
+			if ( (self->spawnflags&1) )
+			{
+				self->NPC_type = "reborn_dual";
+			}
+			else if ( (self->spawnflags&2) )
+			{
+				self->NPC_type = "reborn_staff";
+			}
+			else
+			{
+				self->NPC_type = "reborn_new";
+			}
+		}
+	}
+	
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_Cultist_Saber(1 0 0) (-16 -16 -24) (16 16 40) MED STRONG ALL THROW CEILING CINEMATIC NOTSOLID STARTINSOLID SHY
+Uses a saber and no force powers.  100 health.
+
+default fencer uses fast style - weak, but can attack rapidly.  Good defense.
+
+MED - Uses medium style - average speed and attack strength, average defense.
+STRONG - Uses strong style, slower than others, but can do a lot of damage with one blow.  Weak defense.
+ALL - Knows all 3 styles, switches between them, good defense.
+THROW - can throw their saber (level 2) - reduces their defense some (can use this spawnflag alone or in combination with any *one* of the previous 3 spawnflags)
+
+CEILING - Sticks to the ceiling until he sees an enemy or takes pain
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_Cultist_Saber( gentity_t *self)
+{
+	if ( !self->NPC_type )
+	{
+		if ( (self->spawnflags&1) )
+		{
+			if ( (self->spawnflags&8) )
+			{
+				self->NPC_type = "cultist_saber_med_throw";
+			}
+			else
+			{
+				self->NPC_type = "cultist_saber_med";
+			}
+		}
+		else if ( (self->spawnflags&2) )
+		{
+			if ( (self->spawnflags&8) )
+			{
+				self->NPC_type = "cultist_saber_strong_throw";
+			}
+			else
+			{
+				self->NPC_type = "cultist_saber_strong";
+			}
+		}
+		else if ( (self->spawnflags&2) )
+		{
+			if ( (self->spawnflags&8) )
+			{
+				self->NPC_type = "cultist_saber_all_throw";
+			}
+			else
+			{
+				self->NPC_type = "cultist_saber_all";
+			}
+		}
+		else
+		{
+			if ( (self->spawnflags&8) )
+			{
+				self->NPC_type = "cultist_saber_throw";
+			}
+			else
+			{
+				self->NPC_type = "cultist_saber";
+			}
+		}
+	}
+	
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_Cultist_Saber_Powers(1 0 0) (-16 -16 -24) (16 16 40) MED STRONG ALL THROW CEILING CINEMATIC NOTSOLID STARTINSOLID SHY
+Uses a saber and has a couple low-level powers.  150 health.
+
+default fencer uses fast style - weak, but can attack rapidly.  Good defense.
+
+MED - Uses medium style - average speed and attack strength, average defense.
+STRONG - Uses strong style, slower than others, but can do a lot of damage with one blow.  Weak defense.
+ALL - Knows all 3 styles, switches between them, good defense.
+THROW - can throw their saber (level 2) - reduces their defense some (can use this spawnflag alone or in combination with any *one* of the previous 3 spawnflags)
+
+CEILING - Sticks to the ceiling until he sees an enemy or takes pain
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_Cultist_Saber_Powers( gentity_t *self)
+{
+	if ( !self->NPC_type )
+	{
+		if ( (self->spawnflags&1) )
+		{
+			if ( (self->spawnflags&8) )
+			{
+				self->NPC_type = "cultist_saber_med_throw2";
+			}
+			else
+			{
+				self->NPC_type = "cultist_saber_med2";
+			}
+		}
+		else if ( (self->spawnflags&2) )
+		{
+			if ( (self->spawnflags&8) )
+			{
+				self->NPC_type = "cultist_saber_strong_throw2";
+			}
+			else
+			{
+				self->NPC_type = "cultist_saber_strong2";
+			}
+		}
+		else if ( (self->spawnflags&2) )
+		{
+			if ( (self->spawnflags&8) )
+			{
+				self->NPC_type = "cultist_saber_all_throw2";
+			}
+			else
+			{
+				self->NPC_type = "cultist_saber_all2";
+			}
+		}
+		else
+		{
+			if ( (self->spawnflags&8) )
+			{
+				self->NPC_type = "cultist_saber_throw";
+			}
+			else
+			{
+				self->NPC_type = "cultist_saber2";
+			}
+		}
+	}
+	
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_Cultist(1 0 0) (-16 -16 -24) (16 16 40) SABER GRIP LIGHTNING DRAIN CEILING CINEMATIC NOTSOLID STARTINSOLID SHY
+
+Cultist uses a blaster and force powers.  40 health.
+
+SABER - Uses a saber and no force powers
+GRIP - Uses no weapon and grip, push and pull
+LIGHTNING - Uses no weapon and lightning and push
+DRAIN - Uses no weapons and drain and push
+
+CEILING - Sticks to the ceiling until he sees an enemy or takes pain
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_Cultist( gentity_t *self)
+{
+	if ( !self->NPC_type )
+	{
+		if ( (self->spawnflags&1) )
+		{
+			self->NPC_type = NULL;
+			self->spawnflags = 0;//fast, no throw
+			switch ( Q_irand( 0, 2 ) )
+			{
+			case 0://medium
+				self->spawnflags |= 1;
+				break;
+			case 1://strong
+				self->spawnflags |= 2;
+				break;
+			case 2://all
+				self->spawnflags |= 4;
+				break;
+			}
+			if ( Q_irand( 0, 1 ) )
+			{//throw
+				self->spawnflags |= 8;
+			}
+			SP_NPC_Cultist_Saber( self );
+			return;
+		}
+		else if ( (self->spawnflags&2) )
+		{
+			self->NPC_type = "cultist_grip";
+		}
+		else if ( (self->spawnflags&4) )
+		{
+			self->NPC_type = "cultist_lightning";
+		}
+		else if ( (self->spawnflags&8) )
+		{
+			self->NPC_type = "cultist_drain";
+		}
+		else
+		{
+			self->NPC_type = "cultist";
+		}
+	}
+	
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_Cultist_Commando(1 0 0) (-16 -16 -24) (16 16 40) x x x x CEILING CINEMATIC NOTSOLID STARTINSOLID SHY
+
+Cultist uses dual blaster pistols and force powers.  40 health.
+
+CEILING - Sticks to the ceiling until he sees an enemy or takes pain
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_Cultist_Commando( gentity_t *self)
+{
+	if ( !self->NPC_type )
+	{
+		self->NPC_type = "cultistcommando";
+	}
+	SP_NPC_spawner( self );
+}
+/*QUAKED NPC_Cultist_Destroyer(1 0 0) (-16 -16 -24) (16 16 40) x x x x CEILING CINEMATIC NOTSOLID STARTINSOLID SHY
+
+Cultist has no weapons, runs up to you chanting & building up a Force Destruction blast - when gets to you, screams & explodes
+
+CEILING - Sticks to the ceiling until he sees an enemy or takes pain
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_Cultist_Destroyer( gentity_t *self)
+{
+	self->NPC_type = "cultist";//"cultist_explode";
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_Reelo(1 0 0) (-16 -16 -24) (16 16 40) x x x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_Reelo( gentity_t *self)
+{
+	self->NPC_type = "Reelo";
+
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_Galak(1 0 0) (-16 -16 -24) (16 16 40) MECH x x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+MECH - will be the armored Galak
+
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_Galak( gentity_t *self)
+{
+	if ( self->spawnflags & 1 )
+	{
+		self->NPC_type = "Galak_Mech";
+		NPC_GalakMech_Precache();
+	}
+	else
+	{
+		self->NPC_type = "Galak";
+	}
+
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_Desann(1 0 0) (-16 -16 -24) (16 16 40) x x x x CEILING CINEMATIC NOTSOLID STARTINSOLID SHY
+CEILING - Sticks to the ceiling until he sees an enemy or takes pain
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_Desann( gentity_t *self)
+{
+	self->NPC_type = "Desann";
+
+	WP_SetSaberModel( NULL, CLASS_DESANN );
+
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_Bartender(1 0 0) (-16 -16 -24) (16 16 40) x x x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_Bartender( gentity_t *self)
+{
+	self->NPC_type = "Bartender";
+
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_MorganKatarn(1 0 0) (-16 -16 -24) (16 16 40) x x x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_MorganKatarn( gentity_t *self)
+{
+	self->NPC_type = "MorganKatarn";
+
+	SP_NPC_spawner( self );
+}
+
+//=============================================================================================
+//ALLIES
+//=============================================================================================
+
+/*QUAKED NPC_Jedi(1 0 0) (-16 -16 -24) (16 16 40) TRAINER x x x CEILING CINEMATIC NOTSOLID STARTINSOLID SHY
+TRAINER - Special Jedi- instructor
+CEILING - Sticks to the ceiling until he sees an enemy or takes pain
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+
+Ally Jedi NPC Buddy - tags along with player
+*/
+void SP_NPC_Jedi( gentity_t *self)
+{
+	if(!self->NPC_type)
+	{
+		if ( self->spawnflags & 1 )
+		{
+			self->NPC_type = "jeditrainer";
+		}
+		else 
+		{
+			/*
+			if ( !Q_irand( 0, 2 ) )
+			{
+				self->NPC_type = "JediF";
+			}
+			else 
+			*/if ( Q_irand( 0, 1 ) )
+			{
+				self->NPC_type = "Jedi";
+			}
+			else
+			{
+				self->NPC_type = "Jedi2";
+			}
+		}
+	}
+
+	WP_SetSaberModel( NULL, CLASS_JEDI );
+
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_Prisoner(1 0 0) (-16 -16 -24) (16 16 40) x x x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_Prisoner( gentity_t *self)
+{
+	if(!self->NPC_type)
+	{
+		if ( Q_irand( 0, 1 ) )
+		{
+			self->NPC_type = "Prisoner";
+		}
+		else
+		{
+			self->NPC_type = "Prisoner2";
+		}
+	}
+
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_Rebel(1 0 0) (-16 -16 -24) (16 16 40) x x x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_Rebel( gentity_t *self)
+{
+	if(!self->NPC_type)
+	{
+		if ( Q_irand( 0, 1 ) )
+		{
+			self->NPC_type = "Rebel";
+		}
+		else
+		{
+			self->NPC_type = "Rebel2";
+		}
+	}
+
+	SP_NPC_spawner( self );
+}
+
+//=============================================================================================
+//ENEMIES
+//=============================================================================================
+
+/*QUAKED NPC_Stormtrooper(1 0 0) (-16 -16 -24) (16 16 40) OFFICER COMMANDER ALTOFFICER ROCKET DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+30 health, blaster
+
+OFFICER - 60 health, flechette
+COMMANDER - 60 health, heavy repeater
+ALTOFFICER - 60 health, alt-fire flechette (grenades)
+ROCKET - 60 health, rocket launcher
+
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_Stormtrooper( gentity_t *self)
+{
+	if ( self->spawnflags & 8 )
+	{//rocketer
+		self->NPC_type = "rockettrooper";
+	}
+	else if ( self->spawnflags & 4 )
+	{//alt-officer
+		self->NPC_type = "stofficeralt";
+	}
+	else if ( self->spawnflags & 2 )
+	{//commander
+		self->NPC_type = "stcommander";
+	}
+	else if ( self->spawnflags & 1 )
+	{//officer
+		self->NPC_type = "stofficer";
+	}
+	else
+	{//regular trooper
+		if ( Q_irand( 0, 1 ) )
+		{
+			self->NPC_type = "StormTrooper";
+		}
+		else
+		{
+			self->NPC_type = "StormTrooper2";
+		}
+	}
+
+	SP_NPC_spawner( self );
+}
+void SP_NPC_StormtrooperOfficer( gentity_t *self)
+{
+	self->spawnflags |= 1;
+	SP_NPC_Stormtrooper( self );
+}
+/*QUAKED NPC_Snowtrooper(1 0 0) (-16 -16 -24) (16 16 40) x x x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+30 health, blaster
+
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_Snowtrooper( gentity_t *self)
+{
+	self->NPC_type = "snowtrooper";
+
+	SP_NPC_spawner( self );
+}
+/*QUAKED NPC_Tie_Pilot(1 0 0) (-16 -16 -24) (16 16 40) x x x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+30 health, blaster
+
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_Tie_Pilot( gentity_t *self)
+{
+	self->NPC_type = "stormpilot";
+
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_Ugnaught(1 0 0) (-16 -16 -24) (16 16 40) x x x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_Ugnaught( gentity_t *self)
+{
+	if ( !self->NPC_type )
+	{
+		if ( Q_irand( 0, 1 ) )
+		{
+			self->NPC_type = "Ugnaught";
+		}
+		else
+		{
+			self->NPC_type = "Ugnaught2";
+		}
+	}
+
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_Jawa(1 0 0) (-16 -16 -24) (16 16 40) ARMED x x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+ARMED - starts with the Jawa gun in-hand
+
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_Jawa( gentity_t *self)
+{
+	if ( !self->NPC_type )
+	{
+		if ( (self->spawnflags&1) )
+		{
+			self->NPC_type = "jawa_armed";
+		}
+		else
+		{
+			self->NPC_type = "jawa";
+		}
+	}
+
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_Gran(1 0 0) (-16 -16 -24) (16 16 40) SHOOTER BOXER x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+Uses grenade
+
+SHOOTER - uses blaster instead of 
+BOXER - uses fists only
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_Gran( gentity_t *self)
+{
+	if ( !self->NPC_type )
+	{
+		if ( self->spawnflags & 1 )
+		{
+			self->NPC_type = "granshooter";
+		}
+		else if ( self->spawnflags & 2 )
+		{
+			self->NPC_type = "granboxer";
+		}
+		else
+		{
+			if ( Q_irand( 0, 1 ) )
+			{
+				self->NPC_type = "gran";
+			}
+			else
+			{
+				self->NPC_type = "gran2";
+			}
+		}
+	}
+
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_Rodian(1 0 0) (-16 -16 -24) (16 16 40) BLASTER NO_HIDE x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+BLASTER uses a blaster instead of sniper rifle, different skin
+NO_HIDE (only applicable with snipers) does not duck and hide between shots
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_Rodian( gentity_t *self)
+{
+	if ( !self->NPC_type )
+	{
+		if ( self->spawnflags&1 )
+		{
+			self->NPC_type = "rodian2";
+		}
+		else
+		{
+			self->NPC_type = "rodian";
+		}
+	}
+
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_Weequay(1 0 0) (-16 -16 -24) (16 16 40) x x x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_Weequay( gentity_t *self)
+{
+	if ( !self->NPC_type )
+	{
+		switch ( Q_irand( 0, 3 ) )
+		{
+		case 0:
+			self->NPC_type = "Weequay";
+			break;
+		case 1:
+			self->NPC_type = "Weequay2";
+			break;
+		case 2:
+			self->NPC_type = "Weequay3";
+			break;
+		case 3:
+			self->NPC_type = "Weequay4";
+			break;
+		}
+	}
+
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_Trandoshan(1 0 0) (-16 -16 -24) (16 16 40) x x x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_Trandoshan( gentity_t *self)
+{
+	if ( !self->NPC_type )
+	{
+		self->NPC_type = "Trandoshan";
+	}
+
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_Tusken(1 0 0) (-16 -16 -24) (16 16 40) SNIPER x x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_Tusken( gentity_t *self)
+{
+	if ( !self->NPC_type )
+	{
+		if ( (self->spawnflags&1) )
+		{
+			self->NPC_type = "tuskensniper";
+		}
+		else
+		{
+			self->NPC_type = "tusken";
+		}
+	}
+
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_Noghri(1 0 0) (-16 -16 -24) (16 16 40) x x x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_Noghri( gentity_t *self)
+{
+	if ( !self->NPC_type )
+	{
+		self->NPC_type = "noghri";
+	}
+
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_SwampTrooper(1 0 0) (-16 -16 -24) (16 16 40) REPEATER x x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+REPEATER - Swaptrooper who uses the repeater
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_SwampTrooper( gentity_t *self)
+{
+	if ( !self->NPC_type )
+	{
+		if ( self->spawnflags & 1 )
+		{
+			self->NPC_type = "SwampTrooper2";
+		}
+		else
+		{
+			self->NPC_type = "SwampTrooper";
+		}
+	}
+
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_Imperial(1 0 0) (-16 -16 -24) (16 16 40) OFFICER COMMANDER x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+
+Greyshirt grunt, uses blaster pistol, 20 health.
+
+OFFICER - Brownshirt Officer, uses blaster rifle, 40 health
+COMMANDER - Blackshirt Commander, uses rapid-fire blaster rifle, 80 healt
+
+"message" - if a COMMANDER, turns on his key surface.  This is the name of the key you get when you walk over his body.  This must match the "message" field of the func_security_panel you want this key to open.  Set to "goodie" to have him carrying a goodie key that player can use to operate doors with "GOODIE" spawnflag.
+
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_Imperial( gentity_t *self)
+{
+	if ( !self->NPC_type )
+	{
+		if ( self->spawnflags & 1 )
+		{
+			self->NPC_type = "ImpOfficer";
+		}
+		else if ( self->spawnflags & 2 )
+		{
+			self->NPC_type = "ImpCommander";
+		}
+		else
+		{
+			self->NPC_type = "Imperial";
+		}
+	}
+
+	/*
+	if ( self->message )
+	{//may drop a key, precache the key model and pickup sound
+		G_SoundIndex( "sound/weapons/key_pkup.wav" );
+		if ( !Q_stricmp( "goodie", self->message ) )
+		{
+			RegisterItem( FindItemForInventory( INV_GOODIE_KEY ) );
+		}
+		else
+		{
+			RegisterItem( FindItemForInventory( INV_SECURITY_KEY ) );
+		}
+	}
+	*/
+	//rwwFIXMEFIXME: Allow goodie keys
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_ImpWorker(1 0 0) (-16 -16 -24) (16 16 40) x x x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_ImpWorker( gentity_t *self)
+{
+	if ( !self->NPC_type )
+	{
+		if ( !Q_irand( 0, 2 ) )
+		{
+			self->NPC_type = "ImpWorker";
+		}
+		else if ( Q_irand( 0, 1 ) )
+		{
+			self->NPC_type = "ImpWorker2";
+		}
+		else
+		{
+			self->NPC_type = "ImpWorker3";
+		}
+	}
+
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_BespinCop(1 0 0) (-16 -16 -24) (16 16 40) x x x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_BespinCop( gentity_t *self)
+{
+	if ( !self->NPC_type )
+	{
+		if ( !Q_irand( 0, 1 ) )
+		{
+			self->NPC_type = "BespinCop";
+		}
+		else
+		{
+			self->NPC_type = "BespinCop2";
+		}
+	}
+
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_Reborn(1 0 0) (-16 -16 -24) (16 16 40) FORCE FENCER ACROBAT BOSS CEILING CINEMATIC NOTSOLID STARTINSOLID SHY
+
+Default Reborn is A poor lightsaber fighter, acrobatic and uses no force powers.  Yellow saber, 40 health.
+
+FORCE - Uses force powers but is not the best lightsaber fighter and not acrobatic.  Purple saber, 75 health.
+FENCER - A good lightsaber fighter, but not acrobatic and uses no force powers.  Yellow saber, 100 health.
+ACROBAT - quite acrobatic, but not the best lightsaber fighter and uses no force powers.  Red saber, 100 health.
+BOSS - quite acrobatic, good lightsaber fighter and uses force powers.  Orange saber, 150 health.
+
+NOTE: Saber colors are temporary until they have different by skins to tell them apart
+
+CEILING - Sticks to the ceiling until he sees an enemy or takes pain
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_Reborn( gentity_t *self)
+{
+	if ( !self->NPC_type )
+	{
+		if ( self->spawnflags & 1 )
+		{
+			self->NPC_type = "rebornforceuser";
+		}
+		else if ( self->spawnflags & 2 )
+		{
+			self->NPC_type = "rebornfencer";
+		}
+		else if ( self->spawnflags & 4 )
+		{
+			self->NPC_type = "rebornacrobat";
+		}
+		else if ( self->spawnflags & 8 )
+		{
+			self->NPC_type = "rebornboss";
+		}
+		else
+		{
+			self->NPC_type = "reborn";
+		}
+	}
+	
+	WP_SetSaberModel( NULL, CLASS_REBORN );
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_ShadowTrooper(1 0 0) (-16 -16 -24) (16 16 40) x x x x CEILING CINEMATIC NOTSOLID STARTINSOLID SHY
+CEILING - Sticks to the ceiling until he sees an enemy or takes pain
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_ShadowTrooper( gentity_t *self)
+{
+	if(!self->NPC_type)
+	{
+		if ( !Q_irand( 0, 1 ) )
+		{
+			self->NPC_type = "ShadowTrooper";
+		}
+		else
+		{
+			self->NPC_type = "ShadowTrooper2";
+		}
+	}
+	
+	NPC_ShadowTrooper_Precache();
+	WP_SetSaberModel( NULL, CLASS_SHADOWTROOPER );
+
+	SP_NPC_spawner( self );
+}
+//=============================================================================================
+//MONSTERS
+//=============================================================================================
+
+/*QUAKED NPC_Monster_Murjj (1 0 0) (-12 -12 -24) (12 12 40) x x x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_Monster_Murjj( gentity_t *self)
+{
+	self->NPC_type = "Murjj";
+
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_Monster_Swamp (1 0 0) (-12 -12 -24) (12 12 40) x x x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_Monster_Swamp( gentity_t *self)
+{
+	self->NPC_type = "Swamp";
+
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_Monster_Howler (1 0 0) (-12 -12 -24) (12 12 40) x x x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_Monster_Howler( gentity_t *self)
+{
+	self->NPC_type = "howler";
+
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_MineMonster (1 0 0) (-12 -12 -24) (12 12 40) x x x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_MineMonster( gentity_t *self)
+{
+	self->NPC_type = "minemonster";
+
+	SP_NPC_spawner( self );
+	NPC_MineMonster_Precache();
+}
+
+/*QUAKED NPC_Monster_Claw (1 0 0) (-12 -12 -24) (12 12 40) x x x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_Monster_Claw( gentity_t *self)
+{
+	self->NPC_type = "Claw";
+
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_Monster_Glider (1 0 0) (-12 -12 -24) (12 12 40) x x x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_Monster_Glider( gentity_t *self)
+{
+	self->NPC_type = "Glider";
+
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_Monster_Flier2 (1 0 0) (-12 -12 -24) (12 12 40) x x x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_Monster_Flier2( gentity_t *self)
+{
+	self->NPC_type = "Flier2";
+
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_Monster_Lizard (1 0 0) (-12 -12 -24) (12 12 40) x x x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_Monster_Lizard( gentity_t *self)
+{
+	self->NPC_type = "Lizard";
+
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_Monster_Fish (1 0 0) (-12 -12 -24) (12 12 40) x x x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_Monster_Fish( gentity_t *self)
+{
+	self->NPC_type = "Fish";
+
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_Monster_Wampa (1 0 0) (-12 -12 -24) (12 12 40) WANDER SEARCH x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+WANDER - When I don't have an enemy, I'll just wander the waypoint network aimlessly
+SEARCH - When I don't have an enemy, I'll go back and forth between the nearest waypoints, looking for enemies
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_Monster_Wampa( gentity_t *self)
+{
+	self->NPC_type = "wampa";
+
+	NPC_Wampa_Precache();
+
+	SP_NPC_spawner( self );
+}
+
+/*QUAKED NPC_Monster_Rancor (1 0 0) (-30 -30 -24) (30 30 104) x x x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_Monster_Rancor( gentity_t *self)
+{
+	self->NPC_type = "rancor";
+
+	SP_NPC_spawner( self );
+}
+
+//=============================================================================================
+//DROIDS
+//=============================================================================================
+
+/*QUAKED NPC_Droid_Interrogator (1 0 0) (-12 -12 -24) (12 12 0) x x x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_Droid_Interrogator( gentity_t *self)
+{
+	self->NPC_type = "interrogator";
+
+	SP_NPC_spawner( self );
+
+	NPC_Interrogator_Precache(self);
+}
+
+/*QUAKED NPC_Droid_Probe (1 0 0) (-12 -12 -24) (12 12 40) x x x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+
+Imperial Probe Droid - the multilegged floating droid that Han and Chewie shot on the ice planet Hoth
+*/
+void SP_NPC_Droid_Probe( gentity_t *self)
+{
+	self->NPC_type = "probe";
+
+	SP_NPC_spawner( self );
+
+	NPC_Probe_Precache();
+}
+
+/*QUAKED NPC_Droid_Mark1 (1 0 0) (-36 -36 -24) (36 36 80) x x x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+
+Big walking droid
+
+*/
+void SP_NPC_Droid_Mark1( gentity_t *self)
+{
+	self->NPC_type = "mark1";
+
+	SP_NPC_spawner( self );
+
+	NPC_Mark1_Precache();
+}
+
+/*QUAKED NPC_Droid_Mark2 (1 0 0) (-12 -12 -24) (12 12 40) x x x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+
+Small rolling droid with one gun.
+
+*/
+void SP_NPC_Droid_Mark2( gentity_t *self)
+{
+	self->NPC_type = "mark2";
+
+	SP_NPC_spawner( self );
+
+	NPC_Mark2_Precache();
+}
+
+/*QUAKED NPC_Droid_ATST (1 0 0) (-40 -40 -24) (40 40 248) x x x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+*/
+void SP_NPC_Droid_ATST( gentity_t *self)
+{
+	if ( (self->spawnflags&1) )
+	{
+		self->NPC_type = "atst_vehicle";
+	}
+	else
+	{
+		self->NPC_type = "atst";
+	}
+
+	SP_NPC_spawner( self );
+
+	NPC_ATST_Precache();
+}
+
+/*QUAKED NPC_Droid_Remote (1 0 0) (-12 -12 -24) (12 12 40) x x x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+
+Remote Droid - the floating round droid used by Obi Wan to train Luke about the force while on the Millenium Falcon.
+*/
+void SP_NPC_Droid_Remote( gentity_t *self)
+{
+	self->NPC_type = "remote";
+
+	SP_NPC_spawner( self );
+
+	NPC_Remote_Precache();
+}
+
+/*QUAKED NPC_Droid_Seeker (1 0 0) (-12 -12 -24) (12 12 40) x x x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+
+Seeker Droid - floating round droids that shadow troopers spawn
+*/
+void SP_NPC_Droid_Seeker( gentity_t *self)
+{
+	self->NPC_type = "seeker";
+
+	SP_NPC_spawner( self );
+
+	NPC_Seeker_Precache();
+}
+
+/*QUAKED NPC_Droid_Sentry (1 0 0) (-24 -24 -24) (24 24 40) x x x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+
+Sentry Droid - Large, armored floating Imperial droids with 3 forward-facing gun turrets
+*/
+void SP_NPC_Droid_Sentry( gentity_t *self)
+{
+	self->NPC_type = "sentry";
+
+	SP_NPC_spawner( self );
+
+	NPC_Sentry_Precache();
+}
+
+/*QUAKED NPC_Droid_Gonk (1 0 0) (-12 -12 -24) (12 12 40) x x x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+
+Gonk Droid - the droid that looks like a walking ice machine. Was in the Jawa land crawler, walking around talking to itself.
+
+NOTARGET by default
+*/
+void SP_NPC_Droid_Gonk( gentity_t *self)
+{
+	self->NPC_type = "gonk";
+
+	SP_NPC_spawner( self );
+
+	//precache the Gonk sounds
+	NPC_Gonk_Precache();
+}
+
+/*QUAKED NPC_Droid_Mouse (1 0 0) (-12 -12 -24) (12 12 40) x x x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+
+Mouse Droid - small, box shaped droid, first seen on the Death Star. Chewie yelled at it and it backed up and ran away.
+
+NOTARGET by default
+*/
+void SP_NPC_Droid_Mouse( gentity_t *self)
+{
+	self->NPC_type = "mouse";
+
+	SP_NPC_spawner( self );
+
+	//precache the Mouse sounds
+	NPC_Mouse_Precache();
+
+}
+
+/*QUAKED NPC_Droid_R2D2 (1 0 0) (-12 -12 -24) (12 12 40) IMPERIAL x x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+
+R2D2 Droid - you probably know this one already. 
+
+NOTARGET by default
+*/
+void SP_NPC_Droid_R2D2( gentity_t *self)
+{
+	if ( self->spawnflags&1 )
+	{//imperial skin
+		self->NPC_type = "r2d2_imp";
+	}
+	else
+	{
+		self->NPC_type = "r2d2";
+	}
+
+	SP_NPC_spawner( self );
+
+	NPC_R2D2_Precache();
+}
+
+/*QUAKED NPC_Droid_R5D2 (1 0 0) (-12 -12 -24) (12 12 40) IMPERIAL ALWAYSDIE x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+ALWAYSDIE - won't go into spinning zombie AI when at low health.
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+
+R5D2 Droid - the droid originally chosen by Uncle Owen until it blew a bad motivator, and they took R2D2 instead.
+
+NOTARGET by default
+*/
+void SP_NPC_Droid_R5D2( gentity_t *self)
+{
+	if ( self->spawnflags&1 )
+	{//imperial skin
+		self->NPC_type = "r5d2_imp";
+	}
+	else
+	{
+		self->NPC_type = "r5d2";
+	}
+
+	SP_NPC_spawner( self );
+
+	NPC_R5D2_Precache();
+}
+
+/*QUAKED NPC_Droid_Protocol (1 0 0) (-12 -12 -24) (12 12 40) IMPERIAL x x x DROPTOFLOOR CINEMATIC NOTSOLID STARTINSOLID SHY
+DROPTOFLOOR - NPC can be in air, but will spawn on the closest floor surface below it
+CINEMATIC - Will spawn with no default AI (BS_CINEMATIC)
+NOTSOLID - Starts not solid
+STARTINSOLID - Don't try to fix if spawn in solid
+SHY - Spawner is shy
+
+NOTARGET by default
+*/
+void SP_NPC_Droid_Protocol( gentity_t *self)
+{
+	if ( self->spawnflags&1 )
+	{//imperial skin
+		self->NPC_type = "protocol_imp";
+	}
+	else
+	{
+		self->NPC_type = "protocol";
+	}
+
+	SP_NPC_spawner( self );
+	NPC_Protocol_Precache();
+}
+
+
+//NPC console commands
+/*
+NPC_Spawn_f
+*/
+
+gentity_t *NPC_SpawnType( gentity_t *ent, char *npc_type, char *targetname, qboolean isVehicle ) 
+{
+	gentity_t		*NPCspawner = G_Spawn();
+	vec3_t			forward, end;
+	trace_t			trace;
+
+	if(!NPCspawner)
+	{
+		Com_Printf( S_COLOR_RED"NPC_Spawn Error: Out of entities!\n" );
+		return NULL;
+	}
+
+	NPCspawner->think = G_FreeEntity;
+	NPCspawner->nextthink = level.time + FRAMETIME;
+	
+	if ( !npc_type )
+	{
+		return NULL;
+	}
+
+	if (!npc_type[0])
+	{
+		Com_Printf( S_COLOR_RED"Error, expected one of:\n"S_COLOR_WHITE" NPC spawn [NPC type (from ext_data/NPCs)]\n NPC spawn vehicle [VEH type (from ext_data/vehicles)]\n" );
+		return NULL;
+	}
+
+	if ( !ent || !ent->client )
+	{//screw you, go away
+		return NULL;
+	}
+
+	//rwwFIXMEFIXME: Care about who is issuing this command/other clients besides 0?
+	//Spawn it at spot of first player
+	//FIXME: will gib them!
+	AngleVectors(ent->client->ps.viewangles, forward, NULL, NULL);
+	VectorNormalize(forward);
+	VectorMA(ent->r.currentOrigin, 64, forward, end);
+	trap_Trace(&trace, ent->r.currentOrigin, NULL, NULL, end, 0, MASK_SOLID);
+	VectorCopy(trace.endpos, end);
+	end[2] -= 24;
+	trap_Trace(&trace, trace.endpos, NULL, NULL, end, 0, MASK_SOLID);
+	VectorCopy(trace.endpos, end);
+	end[2] += 24;
+	G_SetOrigin(NPCspawner, end);
+	VectorCopy(NPCspawner->r.currentOrigin, NPCspawner->s.origin);
+	//set the yaw so that they face away from player
+	NPCspawner->s.angles[1] = ent->client->ps.viewangles[1];
+
+	trap_LinkEntity(NPCspawner);
+
+	NPCspawner->NPC_type = G_NewString( npc_type );
+
+	if ( targetname )
+	{
+		NPCspawner->NPC_targetname = G_NewString(targetname);
+	}
+
+	NPCspawner->count = 1;
+
+	NPCspawner->delay = 0;
+
+	//NPCspawner->spawnflags |= SFB_NOTSOLID;
+
+	//NPCspawner->playerTeam = TEAM_FREE;
+	//NPCspawner->behaviorSet[BSET_SPAWN] = "common/guard";
+	
+	if ( isVehicle )
+	{
+		NPCspawner->classname = "NPC_Vehicle";
+	}
+
+	//call precache funcs for James' builds
+	if ( !Q_stricmp( "gonk", NPCspawner->NPC_type))
+	{
+		NPC_Gonk_Precache();
+	}
+	else if ( !Q_stricmp( "mouse", NPCspawner->NPC_type))
+	{
+		NPC_Mouse_Precache();
+	}
+	else if ( !Q_strncmp( "r2d2", NPCspawner->NPC_type, 4))
+	{
+		NPC_R2D2_Precache();
+	}
+	else if ( !Q_stricmp( "atst", NPCspawner->NPC_type))
+	{
+		NPC_ATST_Precache();
+	}
+	else if ( !Q_strncmp( "r5d2", NPCspawner->NPC_type, 4))
+	{
+		NPC_R5D2_Precache();
+	}
+	else if ( !Q_stricmp( "mark1", NPCspawner->NPC_type))
+	{
+		NPC_Mark1_Precache();
+	}
+	else if ( !Q_stricmp( "mark2", NPCspawner->NPC_type))
+	{
+		NPC_Mark2_Precache();
+	}
+	else if ( !Q_stricmp( "interrogator", NPCspawner->NPC_type))
+	{
+		NPC_Interrogator_Precache(NULL);
+	}
+	else if ( !Q_stricmp( "probe", NPCspawner->NPC_type))
+	{
+		NPC_Probe_Precache();
+	}
+	else if ( !Q_stricmp( "seeker", NPCspawner->NPC_type))
+	{
+		NPC_Seeker_Precache();
+	}
+	else if ( !Q_stricmp( "remote", NPCspawner->NPC_type))
+	{
+		NPC_Remote_Precache();
+	}
+	else if ( !Q_strncmp( "shadowtrooper", NPCspawner->NPC_type, 13 ) )
+	{
+		NPC_ShadowTrooper_Precache();
+	}
+	else if ( !Q_stricmp( "minemonster", NPCspawner->NPC_type ))
+	{
+		NPC_MineMonster_Precache();
+	}
+	else if ( !Q_stricmp( "howler", NPCspawner->NPC_type ))
+	{
+		NPC_Howler_Precache();
+	}
+	else if ( !Q_stricmp( "sentry", NPCspawner->NPC_type ))
+	{
+		NPC_Sentry_Precache();
+	}
+	else if ( !Q_stricmp( "protocol", NPCspawner->NPC_type ))
+	{
+		NPC_Protocol_Precache();
+	}
+	else if ( !Q_stricmp( "galak_mech", NPCspawner->NPC_type ))
+	{
+		NPC_GalakMech_Precache();
+	}
+	else if ( !Q_stricmp( "wampa", NPCspawner->NPC_type ))
+	{
+		NPC_Wampa_Precache();
+	}
+
+	return (NPC_Spawn_Do( NPCspawner ));
+}
+
+void NPC_Spawn_f( gentity_t *ent ) 
+{
+	char	npc_type[1024];
+	char	targetname[1024];
+	qboolean	isVehicle = qfalse;
+
+	trap_Argv(2, npc_type, 1024);
+	if ( Q_stricmp( "vehicle", npc_type ) == 0 )
+	{
+		isVehicle = qtrue;
+		trap_Argv(3, npc_type, 1024);
+		trap_Argv(4, targetname, 1024);
+	}
+	else
+	{
+		trap_Argv(3, targetname, 1024);
+	}
+
+	NPC_SpawnType( ent, npc_type, targetname, isVehicle );
+}
+
+/*
+NPC_Kill_f
+*/
+extern stringID_table_t TeamTable[];
+void NPC_Kill_f( void ) 
+{
+	int			n;
+	gentity_t	*player;
+	char		name[1024];
+	team_t		killTeam = TEAM_FREE;
+	qboolean	killNonSF = qfalse;
+
+	trap_Argv(2, name, 1024);
+
+	if ( !name[0] )
+	{
+		Com_Printf( S_COLOR_RED"Error, Expected:\n");
+		Com_Printf( S_COLOR_RED"NPC kill '[NPC targetname]' - kills NPCs with certain targetname\n" );
+		Com_Printf( S_COLOR_RED"or\n" );
+		Com_Printf( S_COLOR_RED"NPC kill 'all' - kills all NPCs\n" );
+		Com_Printf( S_COLOR_RED"or\n" );
+		Com_Printf( S_COLOR_RED"NPC team '[teamname]' - kills all NPCs of a certain team ('nonally' is all but your allies)\n" );
+		return;
+	}
+
+	if ( Q_stricmp( "team", name ) == 0 )
+	{
+		trap_Argv(3, name, 1024);
+
+		if ( !name[0] )
+		{
+			Com_Printf( S_COLOR_RED"NPC_Kill Error: 'npc kill team' requires a team name!\n" );
+			Com_Printf( S_COLOR_RED"Valid team names are:\n");
+			for ( n = (TEAM_FREE + 1); n < TEAM_NUM_TEAMS; n++ )
+			{
+				Com_Printf( S_COLOR_RED"%s\n", TeamNames[n] );
+			}
+			Com_Printf( S_COLOR_RED"nonally - kills all but your teammates\n" );
+			return;
+		}
+
+		if ( Q_stricmp( "nonally", name ) == 0 )
+		{
+			killNonSF = qtrue;
+		}
+		else
+		{
+			killTeam = (team_t)GetIDForString( TeamTable, name );
+
+			if ( killTeam == TEAM_FREE )
+			{
+				Com_Printf( S_COLOR_RED"NPC_Kill Error: team '%s' not recognized\n", name );
+				Com_Printf( S_COLOR_RED"Valid team names are:\n");
+				for ( n = (TEAM_FREE + 1); n < TEAM_NUM_TEAMS; n++ )
+				{
+					Com_Printf( S_COLOR_RED"%s\n", TeamNames[n] );
+				}
+				Com_Printf( S_COLOR_RED"nonally - kills all but your teammates\n" );
+				return;
+			}
+		}
+	}
+
+	for ( n = 1; n < ENTITYNUM_MAX_NORMAL; n++) 
+	{
+		player = &g_entities[n];
+		if (!player->inuse) {
+			continue;
+		}
+		if ( killNonSF )
+		{
+			if ( player )
+			{
+				if ( player->client )
+				{
+					if ( player->client->playerTeam != NPCTEAM_PLAYER )
+					{
+						Com_Printf( S_COLOR_GREEN"Killing NPC %s named %s\n", player->NPC_type, player->targetname );
+						player->health = 0;
+
+						if (player->die && player->client)
+						{
+							player->die(player, player, player, player->client->pers.maxHealth, MOD_UNKNOWN);
+						}
+					}
+				}
+				else if ( player->NPC_type && player->classname && player->classname[0] && Q_stricmp( "NPC_starfleet", player->classname ) != 0 )
+				{//A spawner, remove it
+					Com_Printf( S_COLOR_GREEN"Removing NPC spawner %s with NPC named %s\n", player->NPC_type, player->NPC_targetname );
+					G_FreeEntity( player );
+					//FIXME: G_UseTargets2(player, player, player->NPC_target & player->target);?
+				}
+			}
+		}
+		else if ( player && player->NPC && player->client )
+		{
+			if ( killTeam != TEAM_FREE )
+			{
+				if ( player->client->playerTeam == killTeam )
+				{
+					Com_Printf( S_COLOR_GREEN"Killing NPC %s named %s\n", player->NPC_type, player->targetname );
+					player->health = 0;
+					if (player->die)
+					{
+						player->die(player, player, player, player->client->pers.maxHealth, MOD_UNKNOWN);
+					}
+				}
+			}
+			else if( (player->targetname && Q_stricmp( name, player->targetname ) == 0)
+				|| Q_stricmp( name, "all" ) == 0 )
+			{
+				Com_Printf( S_COLOR_GREEN"Killing NPC %s named %s\n", player->NPC_type, player->targetname );
+				player->health = 0;
+				player->client->ps.stats[STAT_HEALTH] = 0;
+				if (player->die)
+				{
+					player->die(player, player, player, 100, MOD_UNKNOWN);
+				}
+			}
+		}
+		/*
+		else if ( player && (player->svFlags&SVF_NPC_PRECACHE) )
+		{//a spawner
+			Com_Printf( S_COLOR_GREEN"Removing NPC spawner %s named %s\n", player->NPC_type, player->targetname );
+			G_FreeEntity( player );
+		}
+		*/
+		//rwwFIXMEFIXME: should really do something here.
+	}
+}
+
+void NPC_PrintScore( gentity_t *ent )
+{
+	Com_Printf( "%s: %d\n", ent->targetname, ent->client->ps.persistant[PERS_SCORE] );
+}
+
+/*
+Svcmd_NPC_f
+
+parse and dispatch bot commands
+*/
+qboolean	showBBoxes = qfalse;
+void Cmd_NPC_f( gentity_t *ent ) 
+{
+	char	cmd[1024];
+
+	trap_Argv( 1, cmd, 1024 );
+
+	if ( !cmd[0] ) 
+	{
+		Com_Printf( "Valid NPC commands are:\n" );
+		Com_Printf( " spawn [NPC type (from NCPCs.cfg)]\n" );
+		Com_Printf( " kill [NPC targetname] or [all(kills all NPCs)] or 'team [teamname]'\n" );
+		Com_Printf( " showbounds (draws exact bounding boxes of NPCs)\n" );
+		Com_Printf( " score [NPC targetname] (prints number of kills per NPC)\n" );
+	}
+	else if ( Q_stricmp( cmd, "spawn" ) == 0 )
+	{
+		NPC_Spawn_f( ent );
+	}
+	else if ( Q_stricmp( cmd, "kill" ) == 0 ) 
+	{
+		NPC_Kill_f();
+	}
+	else if ( Q_stricmp( cmd, "showbounds" ) == 0 )
+	{//Toggle on and off
+		showBBoxes = showBBoxes ? qfalse : qtrue;
+	}
+	else if ( Q_stricmp ( cmd, "score" ) == 0 )
+	{
+		char		cmd2[1024];
+		gentity_t *ent = NULL;
+
+		trap_Argv(2, cmd2, 1024);
+
+		if ( !cmd2[0] )
+		{//Show the score for all NPCs
+			int i;
+
+			Com_Printf( "SCORE LIST:\n" );
+			for ( i = 0; i < ENTITYNUM_WORLD; i++ )
+			{
+				ent = &g_entities[i];
+				if ( !ent || !ent->client )
+				{
+					continue;
+				}
+				NPC_PrintScore( ent );
+			}
+		}
+		else
+		{
+			if ( (ent = G_Find( NULL, FOFS(targetname), cmd2 )) != NULL && ent->client )
+			{
+				NPC_PrintScore( ent );
+			}
+			else
+			{
+				Com_Printf( "ERROR: NPC score - no such NPC %s\n", cmd2 );
+			}
+		}
+	}
+}
diff --git a/codemp/game/NPC_stats.c b/codemp/game/NPC_stats.c
new file mode 100644
index 0000000..4941402
--- /dev/null
+++ b/codemp/game/NPC_stats.c
@@ -0,0 +1,3307 @@
+//NPC_stats.cpp
+#include "b_local.h"
+#include "b_public.h"
+#include "anims.h"
+#include "../ghoul2/G2.h"
+
+extern qboolean NPCsPrecached;
+
+#include "../namespace_begin.h"
+extern qboolean WP_SaberParseParms( const char *SaberName, saberInfo_t *saber );
+extern void WP_RemoveSaber( saberInfo_t *sabers, int saberNum );
+#include "../namespace_end.h"
+
+stringID_table_t TeamTable[] =
+{
+	ENUM2STRING(NPCTEAM_FREE),			// caution, some code checks a team_t via "if (!team_t_varname)" so I guess this should stay as entry 0, great or what? -slc
+	ENUM2STRING(NPCTEAM_PLAYER),
+	ENUM2STRING(NPCTEAM_ENEMY),
+	ENUM2STRING(NPCTEAM_NEUTRAL),	// most droids are team_neutral, there are some exceptions like Probe,Seeker,Interrogator
+	"",	-1
+};
+
+// this list was made using the model directories, this MUST be in the same order as the CLASS_ enum in teams.h
+stringID_table_t ClassTable[] =
+{
+	ENUM2STRING(CLASS_NONE),				// hopefully this will never be used by an npc), just covering all bases
+	ENUM2STRING(CLASS_ATST),				// technically droid...
+	ENUM2STRING(CLASS_BARTENDER),
+	ENUM2STRING(CLASS_BESPIN_COP),		
+	ENUM2STRING(CLASS_CLAW),
+	ENUM2STRING(CLASS_COMMANDO),
+	ENUM2STRING(CLASS_DESANN),			
+	ENUM2STRING(CLASS_FISH),
+	ENUM2STRING(CLASS_FLIER2),
+	ENUM2STRING(CLASS_GALAK),
+	ENUM2STRING(CLASS_GLIDER),
+	ENUM2STRING(CLASS_GONK),				// droid
+	ENUM2STRING(CLASS_GRAN),
+	ENUM2STRING(CLASS_HOWLER),
+//	ENUM2STRING(CLASS_RANCOR),
+	ENUM2STRING(CLASS_IMPERIAL),
+	ENUM2STRING(CLASS_IMPWORKER),
+	ENUM2STRING(CLASS_INTERROGATOR),		// droid 
+	ENUM2STRING(CLASS_JAN),				
+	ENUM2STRING(CLASS_JEDI),				
+	ENUM2STRING(CLASS_KYLE),
+	ENUM2STRING(CLASS_LANDO),			
+	ENUM2STRING(CLASS_LIZARD),
+	ENUM2STRING(CLASS_LUKE),				
+	ENUM2STRING(CLASS_MARK1),			// droid
+	ENUM2STRING(CLASS_MARK2),			// droid
+	ENUM2STRING(CLASS_GALAKMECH),		// droid
+	ENUM2STRING(CLASS_MINEMONSTER),
+	ENUM2STRING(CLASS_MONMOTHA),			
+	ENUM2STRING(CLASS_MORGANKATARN),
+	ENUM2STRING(CLASS_MOUSE),			// droid
+	ENUM2STRING(CLASS_MURJJ),
+	ENUM2STRING(CLASS_PRISONER),
+	ENUM2STRING(CLASS_PROBE),			// droid
+	ENUM2STRING(CLASS_PROTOCOL),			// droid
+	ENUM2STRING(CLASS_R2D2),				// droid
+	ENUM2STRING(CLASS_R5D2),				// droid
+	ENUM2STRING(CLASS_REBEL),
+	ENUM2STRING(CLASS_REBORN),
+	ENUM2STRING(CLASS_REELO),
+	ENUM2STRING(CLASS_REMOTE),
+	ENUM2STRING(CLASS_RODIAN),
+	ENUM2STRING(CLASS_SEEKER),			// droid
+	ENUM2STRING(CLASS_SENTRY),
+	ENUM2STRING(CLASS_SHADOWTROOPER),
+	ENUM2STRING(CLASS_STORMTROOPER),
+	ENUM2STRING(CLASS_SWAMP),
+	ENUM2STRING(CLASS_SWAMPTROOPER),
+	ENUM2STRING(CLASS_TAVION),
+	ENUM2STRING(CLASS_TRANDOSHAN),
+	ENUM2STRING(CLASS_UGNAUGHT),
+	ENUM2STRING(CLASS_JAWA),
+	ENUM2STRING(CLASS_WEEQUAY),
+	ENUM2STRING(CLASS_BOBAFETT),
+	//ENUM2STRING(CLASS_ROCKETTROOPER),
+	//ENUM2STRING(CLASS_PLAYER),
+	ENUM2STRING(CLASS_VEHICLE),
+	ENUM2STRING(CLASS_RANCOR),
+	ENUM2STRING(CLASS_WAMPA),
+	"",	-1
+};
+
+stringID_table_t BSTable[] =
+{
+	ENUM2STRING(BS_DEFAULT),//# default behavior for that NPC
+	ENUM2STRING(BS_ADVANCE_FIGHT),//# Advance to captureGoal and shoot enemies if you can
+	ENUM2STRING(BS_SLEEP),//# Play awake script when startled by sound
+	ENUM2STRING(BS_FOLLOW_LEADER),//# Follow your leader and shoot any enemies you come across
+	ENUM2STRING(BS_JUMP),//# Face navgoal and jump to it.
+	ENUM2STRING(BS_SEARCH),//# Using current waypoint as a base), search the immediate branches of waypoints for enemies
+	ENUM2STRING(BS_WANDER),//# Wander down random waypoint paths
+	ENUM2STRING(BS_NOCLIP),//# Moves through walls), etc.
+	ENUM2STRING(BS_REMOVE),//# Waits for player to leave PVS then removes itself
+	ENUM2STRING(BS_CINEMATIC),//# Does nothing but face it's angles and move to a goal if it has one
+	//the rest are internal only
+	"",				-1,
+};
+
+#define stringIDExpand(str, strEnum)	str, strEnum, ENUM2STRING(strEnum)
+
+stringID_table_t BSETTable[] =
+{
+	ENUM2STRING(BSET_SPAWN),//# script to use when first spawned
+	ENUM2STRING(BSET_USE),//# script to use when used
+	ENUM2STRING(BSET_AWAKE),//# script to use when awoken/startled
+	ENUM2STRING(BSET_ANGER),//# script to use when aquire an enemy
+	ENUM2STRING(BSET_ATTACK),//# script to run when you attack
+	ENUM2STRING(BSET_VICTORY),//# script to run when you kill someone
+	ENUM2STRING(BSET_LOSTENEMY),//# script to run when you can't find your enemy
+	ENUM2STRING(BSET_PAIN),//# script to use when take pain
+	ENUM2STRING(BSET_FLEE),//# script to use when take pain below 50% of health
+	ENUM2STRING(BSET_DEATH),//# script to use when killed
+	ENUM2STRING(BSET_DELAYED),//# script to run when self->delayScriptTime is reached
+	ENUM2STRING(BSET_BLOCKED),//# script to run when blocked by a friendly NPC or player
+	ENUM2STRING(BSET_BUMPED),//# script to run when bumped into a friendly NPC or player (can set bumpRadius)
+	ENUM2STRING(BSET_STUCK),//# script to run when blocked by a wall
+	ENUM2STRING(BSET_FFIRE),//# script to run when player shoots their own teammates
+	ENUM2STRING(BSET_FFDEATH),//# script to run when player kills a teammate
+	stringIDExpand("", BSET_INVALID),
+	"",				-1,
+};
+
+#include "../namespace_begin.h"
+extern stringID_table_t WPTable[];
+extern stringID_table_t FPTable[];
+#include "../namespace_end.h"
+
+char	*TeamNames[TEAM_NUM_TEAMS] = 
+{
+	"",
+//	"starfleet",
+//	"borg",
+//	"parasite",
+//	"scavengers",
+//	"klingon",
+//	"malon",
+//	"hirogen",
+//	"imperial",
+//	"stasis",
+//	"species8472",
+//	"dreadnought",
+//	"forge",
+//	"disguise",
+//	"player (not valid)"
+	"player",
+	"enemy",
+	"neutral"
+};
+
+// this list was made using the model directories, this MUST be in the same order as the CLASS_ enum in teams.h
+char	*ClassNames[CLASS_NUM_CLASSES] = 
+{
+	"",				// class none
+	"atst",
+	"bartender",
+	"bespin_cop",
+	"claw",
+	"commando",
+	"desann",
+	"fish",
+	"flier2",
+	"galak",
+	"glider",
+	"gonk",			
+	"gran",
+	"howler",
+	"imperial",
+	"impworker",
+	"interrogator",
+	"jan",
+	"jedi",
+	"kyle",
+	"lando",
+	"lizard",
+	"luke",
+	"mark1",
+	"mark2",
+	"galak_mech",
+	"minemonster",
+	"monmotha",
+	"morgankatarn",
+	"mouse",
+	"murjj",
+	"prisoner",
+	"probe",
+	"protocol",
+	"r2d2",
+	"r5d2",
+	"rebel",
+	"reborn",
+	"reelo",
+	"remote",
+	"rodian",
+	"seeker",
+	"sentry",
+	"shadowtrooper",
+	"stormtrooper",
+	"swamp",
+	"swamptrooper",
+	"tavion",
+	"trandoshan",
+	"ugnaught",
+	"weequay",
+	"bobafett",
+	"vehicle",
+	"rancor",
+	"wampa",
+};
+
+
+/*
+NPC_ReactionTime
+*/
+//FIXME use grandom in here
+int NPC_ReactionTime ( void ) 
+{
+	return 200 * ( 6 - NPCInfo->stats.reactions );
+}
+
+//
+// parse support routines
+//
+
+#include "../namespace_begin.h"
+extern qboolean BG_ParseLiteral( const char **data, const char *string );
+#include "../namespace_end.h"
+
+//
+// NPC parameters file : scripts/NPCs.cfg
+//
+#define MAX_NPC_DATA_SIZE 0x20000
+char	NPCParms[MAX_NPC_DATA_SIZE];
+char	NPCFile[MAX_QPATH];
+
+/*
+team_t TranslateTeamName( const char *name ) 
+{
+	int n;
+
+	for ( n = (NPCTEAM_FREE + 1); n < NPCTEAM_NUM_TEAMS; n++ )
+	{
+		if ( Q_stricmp( TeamNames[n], name ) == 0 )
+		{
+			return ((team_t) n);
+		}
+	}
+	
+	return NPCTEAM_FREE;
+}
+
+class_t TranslateClassName( const char *name ) 
+{
+	int n;
+
+	for ( n = (CLASS_NONE + 1); n < CLASS_NUM_CLASSES; n++ )
+	{
+		if ( Q_stricmp( ClassNames[n], name ) == 0 )
+		{
+			return ((class_t) n);
+		}
+	}
+	
+	return CLASS_NONE;  // I hope this never happens, maybe print a warning
+}
+*/
+
+/*
+static race_t TranslateRaceName( const char *name ) 
+{
+	if ( !Q_stricmp( name, "human" ) ) 
+	{
+		return RACE_HUMAN;
+	}
+	return RACE_NONE;
+}
+*/
+/*
+static rank_t TranslateRankName( const char *name ) 
+
+  Should be used to determine pip bolt-ons
+*/
+static rank_t TranslateRankName( const char *name ) 
+{
+	if ( !Q_stricmp( name, "civilian" ) ) 
+	{
+		return RANK_CIVILIAN;
+	}
+
+	if ( !Q_stricmp( name, "crewman" ) ) 
+	{
+		return RANK_CREWMAN;
+	}
+	
+	if ( !Q_stricmp( name, "ensign" ) ) 
+	{
+		return RANK_ENSIGN;
+	}
+	
+	if ( !Q_stricmp( name, "ltjg" ) ) 
+	{
+		return RANK_LT_JG;
+	}
+	
+	if ( !Q_stricmp( name, "lt" ) ) 
+	{
+		return RANK_LT;
+	}
+	
+	if ( !Q_stricmp( name, "ltcomm" ) ) 
+	{
+		return RANK_LT_COMM;
+	}
+	
+	if ( !Q_stricmp( name, "commander" ) ) 
+	{
+		return RANK_COMMANDER;
+	}
+	
+	if ( !Q_stricmp( name, "captain" ) ) 
+	{
+		return RANK_CAPTAIN;
+	}
+
+	return RANK_CIVILIAN;
+}
+
+#include "../namespace_begin.h"
+extern saber_colors_t TranslateSaberColor( const char *name );
+#include "../namespace_end.h"
+
+/* static int MethodNameToNumber( const char *name ) {
+	if ( !Q_stricmp( name, "EXPONENTIAL" ) ) {
+		return METHOD_EXPONENTIAL;
+	}
+	if ( !Q_stricmp( name, "LINEAR" ) ) {
+		return METHOD_LINEAR;
+	}
+	if ( !Q_stricmp( name, "LOGRITHMIC" ) ) {
+		return METHOD_LOGRITHMIC;
+	}
+	if ( !Q_stricmp( name, "ALWAYS" ) ) {
+		return METHOD_ALWAYS;
+	}
+	if ( !Q_stricmp( name, "NEVER" ) ) {
+		return METHOD_NEVER;
+	}
+	return -1;
+}
+
+static int ItemNameToNumber( const char *name, int itemType ) {
+//	int		n;
+
+	for ( n = 0; n < bg_numItems; n++ ) {
+		if ( bg_itemlist[n].type != itemType ) {
+			continue;
+		}
+		if ( Q_stricmp( bg_itemlist[n].classname, name ) == 0 ) {
+			return bg_itemlist[n].tag;
+		}
+	}
+	return -1;
+}
+*/
+
+//rwwFIXMEFIXME: movetypes
+/*
+static int MoveTypeNameToEnum( const char *name ) 
+{
+	if(!Q_stricmp("runjump", name))
+	{
+		return MT_RUNJUMP;
+	}
+	else if(!Q_stricmp("walk", name))
+	{
+		return MT_WALK;
+	}
+	else if(!Q_stricmp("flyswim", name))
+	{
+		return MT_FLYSWIM;
+	}
+	else if(!Q_stricmp("static", name))
+	{
+		return MT_STATIC;
+	}
+
+	return MT_STATIC;
+}
+*/
+
+//#define CONVENIENT_ANIMATION_FILE_DEBUG_THING
+
+#ifdef CONVENIENT_ANIMATION_FILE_DEBUG_THING
+void SpewDebugStuffToFile(animation_t *anims)
+{
+	char BGPAFtext[40000];
+	fileHandle_t f;
+	int i = 0;
+
+	trap_FS_FOpenFile("file_of_debug_stuff_SP.txt", &f, FS_WRITE);
+
+	if (!f)
+	{
+		return;
+	}
+
+	BGPAFtext[0] = 0;
+
+	while (i < MAX_ANIMATIONS)
+	{
+		strcat(BGPAFtext, va("%i %i\n", i, anims[i].frameLerp));
+		i++;
+	}
+
+	trap_FS_Write(BGPAFtext, strlen(BGPAFtext), f);
+	trap_FS_FCloseFile(f);
+}
+#endif
+
+qboolean G_ParseAnimFileSet( const char *filename, const char *animCFG, int *animFileIndex )
+{
+	*animFileIndex = BG_ParseAnimationFile(filename, NULL, qfalse);
+	//if it's humanoid we should have it cached and return it, if it is not it will be loaded (unless it's also cached already)
+
+	if (*animFileIndex == -1)
+	{
+		return qfalse;
+	}
+
+	//I guess this isn't really even needed game-side.
+	//BG_ParseAnimationSndFile(filename, *animFileIndex);
+	return qtrue;
+}
+
+void NPC_PrecacheAnimationCFG( const char *NPC_type )
+{
+#if 0 //rwwFIXMEFIXME: Actually precache stuff here.
+	char	filename[MAX_QPATH];
+	const char	*token;
+	const char	*value;
+	const char	*p;
+	int		junk;
+
+	if ( !Q_stricmp( "random", NPC_type ) )
+	{//sorry, can't precache a random just yet
+		return;
+	}
+
+	p = NPCParms;
+	COM_BeginParseSession(NPCFile);
+
+	// look for the right NPC
+	while ( p ) 
+	{
+		token = COM_ParseExt( &p, qtrue );
+		if ( token[0] == 0 )
+			return;
+
+		if ( !Q_stricmp( token, NPC_type ) ) 
+		{
+			break;
+		}
+
+		SkipBracedSection( &p );
+	}
+
+	if ( !p ) 
+	{
+		return;
+	}
+
+	if ( BG_ParseLiteral( &p, "{" ) ) 
+	{
+		return;
+	}
+
+	// parse the NPC info block
+	while ( 1 ) 
+	{
+		token = COM_ParseExt( &p, qtrue );
+		if ( !token[0] ) 
+		{
+			Com_Printf( S_COLOR_RED"ERROR: unexpected EOF while parsing '%s'\n", NPC_type );
+			return;
+		}
+
+		if ( !Q_stricmp( token, "}" ) ) 
+		{
+			break;
+		}
+
+		// legsmodel
+		if ( !Q_stricmp( token, "legsmodel" ) ) 
+		{
+			if ( COM_ParseString( &p, &value ) ) 
+			{
+				continue;
+			}
+			//must copy data out of this pointer into a different part of memory because the funcs we're about to call will call COM_ParseExt
+			Q_strncpyz( filename, value, sizeof( filename ) );
+			G_ParseAnimFileSet( filename, filename, &junk );
+			return;
+		}
+
+		// playerModel
+		if ( !Q_stricmp( token, "playerModel" ) ) 
+		{
+			if ( COM_ParseString( &p, &value ) ) 
+			{
+				continue;
+			}
+			/*
+			char	animName[MAX_QPATH];
+			char	*GLAName;
+			char	*slash = NULL;
+			char	*strippedName;
+			
+			int handle = gi.G2API_PrecacheGhoul2Model( va( "models/players/%s/model.glm", value ) );
+			if ( handle > 0 )//FIXME: isn't 0 a valid handle?
+			{
+				GLAName = gi.G2API_GetAnimFileNameIndex( handle );
+				if ( GLAName )
+				{
+					Q_strncpyz( animName, GLAName, sizeof( animName ), qtrue );
+					slash = strrchr( animName, '/' );
+					if ( slash )
+					{
+						*slash = 0;
+					}
+					strippedName = COM_SkipPath( animName );
+
+					//must copy data out of this pointer into a different part of memory because the funcs we're about to call will call COM_ParseExt
+					Q_strncpyz( filename, value, sizeof( filename ), qtrue );
+					G_ParseAnimFileSet( value, strippedName, &junk );//qfalse );
+					//FIXME: still not precaching the animsounds.cfg?
+					return;
+				}
+			}
+			*/
+			//rwwFIXMEFIXME: Do this properly.
+		}
+	}
+#endif
+}
+
+extern int NPC_WeaponsForTeam( team_t team, int spawnflags, const char *NPC_type );
+void NPC_PrecacheWeapons( team_t playerTeam, int spawnflags, char *NPCtype )
+{
+	int weapons = NPC_WeaponsForTeam( playerTeam, spawnflags, NPCtype );
+	int curWeap;
+
+	for ( curWeap = WP_SABER; curWeap < WP_NUM_WEAPONS; curWeap++ )
+	{
+		if (weapons & (1 << curWeap))
+		{
+			RegisterItem(BG_FindItemForWeapon((weapon_t)curWeap));
+		}
+	}
+
+#if 0 //rwwFIXMEFIXME: actually precache weapons here
+	int weapons = NPC_WeaponsForTeam( playerTeam, spawnflags, NPCtype );
+	gitem_t	*item;
+	for ( int curWeap = WP_SABER; curWeap < WP_NUM_WEAPONS; curWeap++ )
+	{
+		if ( (weapons & ( 1 << curWeap )) )
+		{
+			item = FindItemForWeapon( ((weapon_t)(curWeap)) );	//precache the weapon
+			CG_RegisterItemSounds( (item-bg_itemlist) );
+			CG_RegisterItemVisuals( (item-bg_itemlist) );
+			//precache the in-hand/in-world ghoul2 weapon model
+
+			char weaponModel[64];
+			
+			strcpy (weaponModel, weaponData[curWeap].weaponMdl);	
+			if (char *spot = strstr(weaponModel, ".md3") ) {
+				*spot = 0;
+				spot = strstr(weaponModel, "_w");//i'm using the in view weapon array instead of scanning the item list, so put the _w back on
+				if (!spot) {
+					strcat (weaponModel, "_w");
+				}
+				strcat (weaponModel, ".glm");	//and change to ghoul2
+			}
+			gi.G2API_PrecacheGhoul2Model( weaponModel ); // correct way is item->world_model
+		}
+	}
+#endif
+}
+
+/*
+void NPC_Precache ( char *NPCName )
+
+Precaches NPC skins, tgas and md3s.
+
+*/
+void NPC_Precache ( gentity_t *spawner )
+{
+	npcteam_t			playerTeam = NPCTEAM_FREE;
+	const char	*token;
+	const char	*value;
+	const char	*p;
+	char	*patch;
+	char	sound[MAX_QPATH];
+	qboolean	md3Model = qfalse;
+	char	playerModel[MAX_QPATH];
+	char	customSkin[MAX_QPATH];
+
+	if ( !Q_stricmp( "random", spawner->NPC_type ) )
+	{//sorry, can't precache a random just yet
+		return;
+	}
+	strcpy(customSkin,"default");
+
+	p = NPCParms;
+	COM_BeginParseSession(NPCFile);
+
+	// look for the right NPC
+	while ( p ) 
+	{
+		token = COM_ParseExt( &p, qtrue );
+		if ( token[0] == 0 )
+			return;
+
+		if ( !Q_stricmp( token, spawner->NPC_type ) ) 
+		{
+			break;
+		}
+
+		SkipBracedSection( &p );
+	}
+
+	if ( !p ) 
+	{
+		return;
+	}
+
+	if ( BG_ParseLiteral( &p, "{" ) ) 
+	{
+		return;
+	}
+
+	// parse the NPC info block
+	while ( 1 ) 
+	{
+		token = COM_ParseExt( &p, qtrue );
+		if ( !token[0] ) 
+		{
+			Com_Printf( S_COLOR_RED"ERROR: unexpected EOF while parsing '%s'\n", spawner->NPC_type );
+			return;
+		}
+
+		if ( !Q_stricmp( token, "}" ) ) 
+		{
+			break;
+		}
+
+		// headmodel
+		if ( !Q_stricmp( token, "headmodel" ) ) 
+		{
+			if ( COM_ParseString( &p, &value ) ) 
+			{
+				continue;
+			}
+
+			if(!Q_stricmp("none", value))
+			{
+			}
+			else
+			{
+				//Q_strncpyz( ri.headModelName, value, sizeof(ri.headModelName), qtrue);
+			}
+			md3Model = qtrue;
+			continue;
+		}
+		
+		// torsomodel
+		if ( !Q_stricmp( token, "torsomodel" ) ) 
+		{
+			if ( COM_ParseString( &p, &value ) ) 
+			{
+				continue;
+			}
+
+			if(!Q_stricmp("none", value))
+			{
+			}
+			else
+			{
+				//Q_strncpyz( ri.torsoModelName, value, sizeof(ri.torsoModelName), qtrue);
+			}
+			md3Model = qtrue;
+			continue;
+		}
+
+		// legsmodel
+		if ( !Q_stricmp( token, "legsmodel" ) ) 
+		{
+			if ( COM_ParseString( &p, &value ) ) 
+			{
+				continue;
+			}
+			//Q_strncpyz( ri.legsModelName, value, sizeof(ri.legsModelName), qtrue);			
+			md3Model = qtrue;
+			continue;
+		}
+
+		// playerModel
+		if ( !Q_stricmp( token, "playerModel" ) ) 
+		{
+			if ( COM_ParseString( &p, &value ) ) 
+			{
+				continue;
+			}
+			Q_strncpyz( playerModel, value, sizeof(playerModel));			
+			md3Model = qfalse;
+			continue;
+		}
+
+		// customSkin
+		if ( !Q_stricmp( token, "customSkin" ) ) 
+		{
+			if ( COM_ParseString( &p, &value ) ) 
+			{
+				continue;
+			}
+			Q_strncpyz( customSkin, value, sizeof(customSkin));			
+			continue;
+		}
+
+		// playerTeam
+		if ( !Q_stricmp( token, "playerTeam" ) ) 
+		{
+			char tk[4096]; //rww - hackilicious!
+
+			if ( COM_ParseString( &p, &value ) ) 
+			{
+				continue;
+			}
+			//playerTeam = TranslateTeamName(value);
+			Com_sprintf(tk, sizeof(tk), "NPC%s", token);
+			playerTeam = (team_t)GetIDForString( TeamTable, tk );
+			continue;
+		}
+
+	
+		// snd
+		if ( !Q_stricmp( token, "snd" ) ) {
+			if ( COM_ParseString( &p, &value ) ) {
+				continue;
+			}
+			//if ( !(spawner->svFlags&SVF_NO_BASIC_SOUNDS) )
+			if (1)
+			{
+				//FIXME: store this in some sound field or parse in the soundTable like the animTable...
+				Q_strncpyz( sound, value, sizeof( sound ) );
+				patch = strstr( sound, "/" );
+				if ( patch ) 
+				{
+					*patch = 0;
+				}
+				spawner->s.csSounds_Std = G_SoundIndex( va("*$%s", sound) );
+			}
+			continue;
+		}
+
+		// sndcombat
+		if ( !Q_stricmp( token, "sndcombat" ) ) {
+			if ( COM_ParseString( &p, &value ) ) {
+				continue;
+			}
+			//if ( !(spawner->svFlags&SVF_NO_COMBAT_SOUNDS) )
+			if (1)
+			{
+				//FIXME: store this in some sound field or parse in the soundTable like the animTable...
+				Q_strncpyz( sound, value, sizeof( sound ) );
+				patch = strstr( sound, "/" );
+				if ( patch ) 
+				{
+					*patch = 0;
+				}
+				spawner->s.csSounds_Combat = G_SoundIndex( va("*$%s", sound) );
+			}
+			continue;
+		}
+		
+		// sndextra
+		if ( !Q_stricmp( token, "sndextra" ) ) {
+			if ( COM_ParseString( &p, &value ) ) {
+				continue;
+			}
+			//if ( !(spawner->svFlags&SVF_NO_EXTRA_SOUNDS) )
+			if (1)
+			{
+				//FIXME: store this in some sound field or parse in the soundTable like the animTable...
+				Q_strncpyz( sound, value, sizeof( sound ) );
+				patch = strstr( sound, "/" );
+				if ( patch ) 
+				{
+					*patch = 0;
+				}
+				spawner->s.csSounds_Extra = G_SoundIndex( va("*$%s", sound) );
+			}
+			continue;
+		}
+
+		// sndjedi
+		if ( !Q_stricmp( token, "sndjedi" ) ) {
+			if ( COM_ParseString( &p, &value ) ) {
+				continue;
+			}
+			//if ( !(spawner->svFlags&SVF_NO_EXTRA_SOUNDS) )
+			if (1)
+			{
+				//FIXME: store this in some sound field or parse in the soundTable like the animTable...
+				Q_strncpyz( sound, value, sizeof( sound ) );
+				patch = strstr( sound, "/" );
+				if ( patch ) 
+				{
+					*patch = 0;
+				}
+				spawner->s.csSounds_Jedi = G_SoundIndex( va("*$%s", sound) );
+			}
+			continue;
+		}
+
+		if (!Q_stricmp(token, "weapon"))
+		{
+			int curWeap;
+
+			if (COM_ParseString(&p, &value))
+			{
+				continue;
+			}
+
+			curWeap = GetIDForString( WPTable, value );
+
+			if (curWeap >= 0 && curWeap < WP_NUM_WEAPONS)
+			{
+				RegisterItem(BG_FindItemForWeapon((weapon_t)curWeap));
+			}
+			continue;
+		}
+	}
+
+	// If we're not a vehicle, then an error here would be valid...
+	if ( !spawner->client || spawner->client->NPC_class != CLASS_VEHICLE )
+	{
+		if ( md3Model )
+		{
+			Com_Printf("MD3 model using NPCs are not supported in MP\n");
+		}
+		else
+		{ //if we have a model/skin then index them so they'll be registered immediately
+			//when the client gets a configstring update.
+			char modelName[MAX_QPATH];
+
+			Com_sprintf(modelName, sizeof(modelName), "models/players/%s/model.glm", playerModel);
+			if (customSkin[0])
+			{ //append it after a *
+				strcat( modelName, va("*%s", customSkin) );
+			}
+
+			G_ModelIndex(modelName);
+		}
+	}
+
+	//precache this NPC's possible weapons
+	NPC_PrecacheWeapons( playerTeam, spawner->spawnflags, spawner->NPC_type );
+
+//	CG_RegisterNPCCustomSounds( &ci );
+//	CG_RegisterNPCEffects( playerTeam );
+	//rwwFIXMEFIXME: same
+	//FIXME: Look for a "sounds" directory and precache death, pain, alert sounds
+}
+
+#if 0
+void NPC_BuildRandom( gentity_t *NPC )
+{
+	int	sex, color, head;
+
+	sex = Q_irand(0, 2);
+	color = Q_irand(0, 2);
+	switch( sex )
+	{
+	case 0://female
+		head = Q_irand(0, 2);
+		switch( head )
+		{
+		default:
+		case 0:
+			Q_strncpyz( NPC->client->renderInfo.headModelName, "garren", sizeof(NPC->client->renderInfo.headModelName), qtrue );
+			break;
+		case 1:
+			Q_strncpyz( NPC->client->renderInfo.headModelName, "garren/salma", sizeof(NPC->client->renderInfo.headModelName), qtrue );
+			break;
+		case 2:
+			Q_strncpyz( NPC->client->renderInfo.headModelName, "garren/mackey", sizeof(NPC->client->renderInfo.headModelName), qtrue );
+			color = Q_irand(3, 5);//torso needs to be afam
+			break;
+		}
+		switch( color )
+		{
+		default:
+		case 0:
+			Q_strncpyz( NPC->client->renderInfo.torsoModelName, "crewfemale/gold", sizeof(NPC->client->renderInfo.torsoModelName), qtrue );
+			break;
+		case 1:
+			Q_strncpyz( NPC->client->renderInfo.torsoModelName, "crewfemale", sizeof(NPC->client->renderInfo.torsoModelName), qtrue );
+			break;
+		case 2:
+			Q_strncpyz( NPC->client->renderInfo.torsoModelName, "crewfemale/blue", sizeof(NPC->client->renderInfo.torsoModelName), qtrue );
+			break;
+		case 3:
+			Q_strncpyz( NPC->client->renderInfo.torsoModelName, "crewfemale/aframG", sizeof(NPC->client->renderInfo.torsoModelName), qtrue );
+			break;
+		case 4:
+			Q_strncpyz( NPC->client->renderInfo.torsoModelName, "crewfemale/aframR", sizeof(NPC->client->renderInfo.torsoModelName), qtrue );
+			break;
+		case 5:
+			Q_strncpyz( NPC->client->renderInfo.torsoModelName, "crewfemale/aframB", sizeof(NPC->client->renderInfo.torsoModelName), qtrue );
+			break;
+		}
+		Q_strncpyz( NPC->client->renderInfo.legsModelName, "crewfemale", sizeof(NPC->client->renderInfo.legsModelName), qtrue );
+		break;
+	default:
+	case 1://male
+	case 2://male
+		head = Q_irand(0, 4);
+		switch( head )
+		{
+		default:
+		case 0:
+			Q_strncpyz( NPC->client->renderInfo.headModelName, "chakotay/nelson", sizeof(NPC->client->renderInfo.headModelName), qtrue );
+			break;
+		case 1:
+			Q_strncpyz( NPC->client->renderInfo.headModelName, "paris/chase", sizeof(NPC->client->renderInfo.headModelName), qtrue );
+			break;
+		case 2:
+			Q_strncpyz( NPC->client->renderInfo.headModelName, "doctor/pasty", sizeof(NPC->client->renderInfo.headModelName), qtrue );
+			break;
+		case 3:
+			Q_strncpyz( NPC->client->renderInfo.headModelName, "kim/durk", sizeof(NPC->client->renderInfo.headModelName), qtrue );
+			break;
+		case 4:
+			Q_strncpyz( NPC->client->renderInfo.headModelName, "paris/kray", sizeof(NPC->client->renderInfo.headModelName), qtrue );
+			break;
+		}
+		switch( color )
+		{
+		default:
+		case 0:
+			Q_strncpyz( NPC->client->renderInfo.torsoModelName, "crewthin/red", sizeof(NPC->client->renderInfo.torsoModelName), qtrue );
+			break;
+		case 1:
+			Q_strncpyz( NPC->client->renderInfo.torsoModelName, "crewthin", sizeof(NPC->client->renderInfo.torsoModelName), qtrue );
+			break;
+		case 2:
+			Q_strncpyz( NPC->client->renderInfo.torsoModelName, "crewthin/blue", sizeof(NPC->client->renderInfo.torsoModelName), qtrue );
+			break;
+			//NOTE: 3 - 5 should be red, gold & blue, afram hands
+		}
+		Q_strncpyz( NPC->client->renderInfo.legsModelName, "crewthin", sizeof(NPC->client->renderInfo.legsModelName), qtrue );
+		break;
+	}
+
+	NPC->s.modelScale[0] = NPC->s.modelScale[1] = NPC->s.modelScale[2] = Q_irand(87, 102)/100.0f;
+//	NPC->client->race = RACE_HUMAN;
+	NPC->NPC->rank = RANK_CREWMAN;
+	NPC->client->playerTeam = NPC->s.teamowner = TEAM_PLAYER;
+	NPC->client->clientInfo.customBasicSoundDir = "kyle";//FIXME: generic default?
+}
+#endif
+
+extern void SetupGameGhoul2Model(gentity_t *ent, char *modelname, char *skinName);
+qboolean NPC_ParseParms( const char *NPCName, gentity_t *NPC ) 
+{
+	const char	*token;
+	const char	*value;
+	const char	*p;
+	int		n;
+	float	f;
+	char	*patch;
+	char	sound[MAX_QPATH];
+	char	playerModel[MAX_QPATH];
+	char	customSkin[MAX_QPATH];
+	renderInfo_t	*ri = &NPC->client->renderInfo;
+	gNPCstats_t		*stats = NULL;
+	qboolean	md3Model = qtrue;
+	char	surfOff[1024];
+	char	surfOn[1024];
+	qboolean parsingPlayer = qfalse;
+	vec3_t playerMins;
+	vec3_t playerMaxs;
+	int npcSaber1 = 0;
+	int npcSaber2 = 0;
+
+	VectorSet(playerMins, -15, -15, DEFAULT_MINS_2);
+	VectorSet(playerMaxs, 15, 15, DEFAULT_MAXS_2);
+
+	strcpy(customSkin,"default");
+	if ( !NPCName || !NPCName[0]) 
+	{
+		NPCName = "Player";
+	}
+
+	if ( !NPC->s.number && NPC->client != NULL )
+	{//player, only want certain data
+		parsingPlayer = qtrue;
+	}
+
+	if ( NPC->NPC )
+	{
+		stats = &NPC->NPC->stats;
+/*
+	NPC->NPC->allWeaponOrder[0]	= WP_BRYAR_PISTOL;
+	NPC->NPC->allWeaponOrder[1]	= WP_SABER;
+	NPC->NPC->allWeaponOrder[2]	= WP_IMOD;
+	NPC->NPC->allWeaponOrder[3]	= WP_SCAVENGER_RIFLE;
+	NPC->NPC->allWeaponOrder[4]	= WP_TRICORDER;
+	NPC->NPC->allWeaponOrder[6]	= WP_NONE;
+	NPC->NPC->allWeaponOrder[6]	= WP_NONE;
+	NPC->NPC->allWeaponOrder[7]	= WP_NONE;
+*/
+		// fill in defaults
+		stats->aggression	= 3;
+		stats->aim			= 3;
+		stats->earshot		= 1024;
+		stats->evasion		= 3;
+		stats->hfov			= 90;
+		stats->intelligence	= 3;
+		stats->move			= 3;
+		stats->reactions	= 3;
+		stats->vfov			= 60;
+		stats->vigilance	= 0.1f;
+		stats->visrange		= 1024;
+
+		stats->health		= 0;
+
+		stats->yawSpeed		= 90;
+		stats->walkSpeed	= 90;
+		stats->runSpeed		= 300;
+		stats->acceleration	= 15;//Increase/descrease speed this much per frame (20fps)
+	}
+	else
+	{
+		stats = NULL;
+	}
+
+	//Set defaults
+	//FIXME: should probably put default torso and head models, but what about enemies
+	//that don't have any- like Stasis?
+	//Q_strncpyz( ri->headModelName,	DEFAULT_HEADMODEL,  sizeof(ri->headModelName),	qtrue);
+	//Q_strncpyz( ri->torsoModelName, DEFAULT_TORSOMODEL, sizeof(ri->torsoModelName),	qtrue);
+	//Q_strncpyz( ri->legsModelName,	DEFAULT_LEGSMODEL,  sizeof(ri->legsModelName),	qtrue);
+	//FIXME: should we have one for weapon too?
+	memset( (char *)surfOff, 0, sizeof(surfOff) );
+	memset( (char *)surfOn, 0, sizeof(surfOn) );
+	
+	/*
+	ri->headYawRangeLeft = 50;
+	ri->headYawRangeRight = 50;
+	ri->headPitchRangeUp = 40;
+	ri->headPitchRangeDown = 50;
+	ri->torsoYawRangeLeft = 60;
+	ri->torsoYawRangeRight = 60;
+	ri->torsoPitchRangeUp = 30;
+	ri->torsoPitchRangeDown = 70;
+	*/
+
+	ri->headYawRangeLeft = 80;
+	ri->headYawRangeRight = 80;
+	ri->headPitchRangeUp = 45;
+	ri->headPitchRangeDown = 45;
+	ri->torsoYawRangeLeft = 60;
+	ri->torsoYawRangeRight = 60;
+	ri->torsoPitchRangeUp = 30;
+	ri->torsoPitchRangeDown = 50;
+
+	VectorCopy(playerMins, NPC->r.mins);
+	VectorCopy(playerMaxs, NPC->r.maxs);
+	NPC->client->ps.crouchheight = CROUCH_MAXS_2;
+	NPC->client->ps.standheight = DEFAULT_MAXS_2;
+
+	//rwwFIXMEFIXME: ...
+	/*
+	NPC->client->moveType		= MT_RUNJUMP;
+
+	NPC->client->dismemberProbHead = 100;
+	NPC->client->dismemberProbArms = 100;
+	NPC->client->dismemberProbHands = 100;
+	NPC->client->dismemberProbWaist = 100;
+	NPC->client->dismemberProbLegs = 100;
+
+	NPC->s.modelScale[0] = NPC->s.modelScale[1] = NPC->s.modelScale[2] = 1.0f;
+	*/
+
+	NPC->client->ps.customRGBA[0]=255;
+	NPC->client->ps.customRGBA[1]=255;
+	NPC->client->ps.customRGBA[2]=255;
+	NPC->client->ps.customRGBA[3]=255;
+
+	if ( !Q_stricmp( "random", NPCName ) )
+	{//Randomly assemble a starfleet guy
+		//NPC_BuildRandom( NPC );
+		Com_Printf("RANDOM NPC NOT SUPPORTED IN MP\n");
+		return qfalse;
+	}
+	else
+	{
+		int fp;
+
+		p = NPCParms;
+		COM_BeginParseSession(NPCFile);
+
+		// look for the right NPC
+		while ( p ) 
+		{
+			token = COM_ParseExt( &p, qtrue );
+			if ( token[0] == 0 )
+			{
+				return qfalse;
+			}
+
+			if ( !Q_stricmp( token, NPCName ) ) 
+			{
+				break;
+			}
+
+			SkipBracedSection( &p );
+		}
+		if ( !p ) 
+		{
+			return qfalse;
+		}
+
+		if ( BG_ParseLiteral( &p, "{" ) ) 
+		{
+			return qfalse;
+		}
+			
+		// parse the NPC info block
+		while ( 1 ) 
+		{
+			token = COM_ParseExt( &p, qtrue );
+			if ( !token[0] ) 
+			{
+				Com_Printf( S_COLOR_RED"ERROR: unexpected EOF while parsing '%s'\n", NPCName );
+				return qfalse;
+			}
+
+			if ( !Q_stricmp( token, "}" ) ) 
+			{
+				break;
+			}
+	//===MODEL PROPERTIES===========================================================
+			// custom color
+			if ( !Q_stricmp( token, "customRGBA" ) ) 
+			{
+				if ( COM_ParseString( &p, &value ) ) 
+				{
+					continue;
+				}
+				if ( !Q_stricmp( value, "random") )
+				{
+					NPC->client->ps.customRGBA[0]=Q_irand(0,255);
+					NPC->client->ps.customRGBA[1]=Q_irand(0,255);
+					NPC->client->ps.customRGBA[2]=Q_irand(0,255);
+					NPC->client->ps.customRGBA[3]=255;
+				} 
+				else 
+				{
+					NPC->client->ps.customRGBA[0]=atoi(value);
+					
+					if ( COM_ParseInt( &p, &n ) ) 
+					{
+						continue;
+					}
+					NPC->client->ps.customRGBA[1]=n;
+					
+					if ( COM_ParseInt( &p, &n ) ) 
+					{
+						continue;
+					}
+					NPC->client->ps.customRGBA[2]=n;
+					
+					if ( COM_ParseInt( &p, &n ) ) 
+					{
+						continue;
+					}
+					NPC->client->ps.customRGBA[3]=n;
+				}
+				continue;
+			}
+
+			// headmodel
+			if ( !Q_stricmp( token, "headmodel" ) ) 
+			{
+				if ( COM_ParseString( &p, &value ) ) 
+				{
+					continue;
+				}
+
+				if(!Q_stricmp("none", value))
+				{
+					//Zero the head clamp range so the torso & legs don't lag behind
+					ri->headYawRangeLeft = 
+					ri->headYawRangeRight = 
+					ri->headPitchRangeUp = 
+					ri->headPitchRangeDown = 0;
+				}
+				continue;
+			}
+			
+			// torsomodel
+			if ( !Q_stricmp( token, "torsomodel" ) ) 
+			{
+				if ( COM_ParseString( &p, &value ) ) 
+				{
+					continue;
+				}
+
+				if(!Q_stricmp("none", value))
+				{
+					//Zero the torso clamp range so the legs don't lag behind
+					ri->torsoYawRangeLeft = 
+					ri->torsoYawRangeRight = 
+					ri->torsoPitchRangeUp = 
+					ri->torsoPitchRangeDown = 0;
+				}
+				continue;
+			}
+
+			// legsmodel
+			if ( !Q_stricmp( token, "legsmodel" ) ) 
+			{
+				if ( COM_ParseString( &p, &value ) ) 
+				{
+					continue;
+				}
+				/*
+				Q_strncpyz( ri->legsModelName, value, sizeof(ri->legsModelName), qtrue);			
+				//Need to do this here to get the right index
+				G_ParseAnimFileSet( ri->legsModelName, ri->legsModelName, &ci->animFileIndex );
+				*/
+				continue;
+			}
+
+			// playerModel
+			if ( !Q_stricmp( token, "playerModel" ) ) 
+			{
+				if ( COM_ParseString( &p, &value ) ) 
+				{
+					continue;
+				}
+				Q_strncpyz( playerModel, value, sizeof(playerModel));			
+				md3Model = qfalse;
+				continue;
+			}
+			
+			// customSkin
+			if ( !Q_stricmp( token, "customSkin" ) ) 
+			{
+				if ( COM_ParseString( &p, &value ) ) 
+				{
+					continue;
+				}
+				Q_strncpyz( customSkin, value, sizeof(customSkin));			
+				continue;
+			}
+
+			// surfOff
+			if ( !Q_stricmp( token, "surfOff" ) ) 
+			{
+				if ( COM_ParseString( &p, &value ) ) 
+				{
+					continue;
+				}
+				if ( surfOff[0] )
+				{
+					Q_strcat( (char *)surfOff, sizeof(surfOff), "," );
+					Q_strcat( (char *)surfOff, sizeof(surfOff), value );
+				}
+				else
+				{
+					Q_strncpyz( surfOff, value, sizeof(surfOff));
+				}
+				continue;
+			}
+			
+			// surfOn
+			if ( !Q_stricmp( token, "surfOn" ) ) 
+			{
+				if ( COM_ParseString( &p, &value ) ) 
+				{
+					continue;
+				}
+				if ( surfOn[0] )
+				{
+					Q_strcat( (char *)surfOn, sizeof(surfOn), "," );
+					Q_strcat( (char *)surfOn, sizeof(surfOn), value );
+				}
+				else
+				{
+					Q_strncpyz( surfOn, value, sizeof(surfOn));
+				}
+				continue;
+			}
+			
+			//headYawRangeLeft
+			if ( !Q_stricmp( token, "headYawRangeLeft" ) ) 
+			{
+				if ( COM_ParseInt( &p, &n ) ) 
+				{
+					SkipRestOfLine( &p );
+					continue;
+				}
+				if ( n < 0 ) 
+				{
+					Com_Printf( S_COLOR_YELLOW"WARNING: bad %s in NPC '%s'\n", token, NPCName );
+					continue;
+				}
+				ri->headYawRangeLeft = n;
+				continue;
+			}
+
+			//headYawRangeRight
+			if ( !Q_stricmp( token, "headYawRangeRight" ) ) 
+			{
+				if ( COM_ParseInt( &p, &n ) ) 
+				{
+					SkipRestOfLine( &p );
+					continue;
+				}
+				if ( n < 0 ) 
+				{
+					Com_Printf( S_COLOR_YELLOW"WARNING: bad %s in NPC '%s'\n", token, NPCName );
+					continue;
+				}
+				ri->headYawRangeRight = n;
+				continue;
+			}
+
+			//headPitchRangeUp
+			if ( !Q_stricmp( token, "headPitchRangeUp" ) ) 
+			{
+				if ( COM_ParseInt( &p, &n ) ) 
+				{
+					SkipRestOfLine( &p );
+					continue;
+				}
+				if ( n < 0 ) 
+				{
+					Com_Printf( S_COLOR_YELLOW"WARNING: bad %s in NPC '%s'\n", token, NPCName );
+					continue;
+				}
+				ri->headPitchRangeUp = n;
+				continue;
+			}
+			
+			//headPitchRangeDown
+			if ( !Q_stricmp( token, "headPitchRangeDown" ) ) 
+			{
+				if ( COM_ParseInt( &p, &n ) ) 
+				{
+					SkipRestOfLine( &p );
+					continue;
+				}
+				if ( n < 0 ) 
+				{
+					Com_Printf( S_COLOR_YELLOW"WARNING: bad %s in NPC '%s'\n", token, NPCName );
+					continue;
+				}
+				ri->headPitchRangeDown = n;
+				continue;
+			}
+
+			//torsoYawRangeLeft
+			if ( !Q_stricmp( token, "torsoYawRangeLeft" ) ) 
+			{
+				if ( COM_ParseInt( &p, &n ) ) 
+				{
+					SkipRestOfLine( &p );
+					continue;
+				}
+				if ( n < 0 ) 
+				{
+					Com_Printf( S_COLOR_YELLOW"WARNING: bad %s in NPC '%s'\n", token, NPCName );
+					continue;
+				}
+				ri->torsoYawRangeLeft = n;
+				continue;
+			}
+
+			//torsoYawRangeRight
+			if ( !Q_stricmp( token, "torsoYawRangeRight" ) ) 
+			{
+				if ( COM_ParseInt( &p, &n ) ) 
+				{
+					SkipRestOfLine( &p );
+					continue;
+				}
+				if ( n < 0 ) 
+				{
+					Com_Printf( S_COLOR_YELLOW"WARNING: bad %s in NPC '%s'\n", token, NPCName );
+					continue;
+				}
+				ri->torsoYawRangeRight = n;
+				continue;
+			}
+
+			//torsoPitchRangeUp
+			if ( !Q_stricmp( token, "torsoPitchRangeUp" ) ) 
+			{
+				if ( COM_ParseInt( &p, &n ) ) 
+				{
+					SkipRestOfLine( &p );
+					continue;
+				}
+				if ( n < 0 ) 
+				{
+					Com_Printf( S_COLOR_YELLOW"WARNING: bad %s in NPC '%s'\n", token, NPCName );
+					continue;
+				}
+				ri->torsoPitchRangeUp = n;
+				continue;
+			}
+
+			//torsoPitchRangeDown
+			if ( !Q_stricmp( token, "torsoPitchRangeDown" ) ) 
+			{
+				if ( COM_ParseInt( &p, &n ) ) 
+				{
+					SkipRestOfLine( &p );
+					continue;
+				}
+				if ( n < 0 ) 
+				{
+					Com_Printf( S_COLOR_YELLOW"WARNING: bad %s in NPC '%s'\n", token, NPCName );
+					continue;
+				}
+				ri->torsoPitchRangeDown = n;
+				continue;
+			}
+
+			// Uniform XYZ scale
+			if ( !Q_stricmp( token, "scale" ) ) 
+			{
+				if ( COM_ParseInt( &p, &n ) ) 
+				{
+					SkipRestOfLine( &p );
+					continue;
+				}
+				if ( n < 0 ) 
+				{
+					Com_Printf(  "bad %s in NPC '%s'\n", token, NPCName );
+					continue;
+				}
+				if (n != 100)
+				{
+					NPC->client->ps.iModelScale = n; //so the client knows
+					if (n >= 1024)
+					{
+						Com_Printf("WARNING: MP does not support scaling up to or over 1024%\n");
+						n = 1023;
+					}
+
+					NPC->modelScale[0] = NPC->modelScale[1] = NPC->modelScale[2] = n/100.0f;
+				}
+				continue;
+			}
+
+			//X scale
+			if ( !Q_stricmp( token, "scaleX" ) ) 
+			{
+				if ( COM_ParseInt( &p, &n ) ) 
+				{
+					SkipRestOfLine( &p );
+					continue;
+				}
+				if ( n < 0 ) 
+				{
+					Com_Printf(  "bad %s in NPC '%s'\n", token, NPCName );
+					continue;
+				}
+				if (n != 100)
+				{
+					Com_Printf("MP doesn't support xyz scaling, use 'scale'.\n");
+					//NPC->s.modelScale[0] = n/100.0f;
+				}
+				continue;
+			}
+
+			//Y scale
+			if ( !Q_stricmp( token, "scaleY" ) ) 
+			{
+				if ( COM_ParseInt( &p, &n ) ) 
+				{
+					SkipRestOfLine( &p );
+					continue;
+				}
+				if ( n < 0 ) 
+				{
+					Com_Printf(  "bad %s in NPC '%s'\n", token, NPCName );
+					continue;
+				}
+				if (n != 100)
+				{
+					Com_Printf("MP doesn't support xyz scaling, use 'scale'.\n");
+					//NPC->s.modelScale[1] = n/100.0f;
+				}
+				continue;
+			}
+
+			//Z scale
+			if ( !Q_stricmp( token, "scaleZ" ) ) 
+			{
+				if ( COM_ParseInt( &p, &n ) ) 
+				{
+					SkipRestOfLine( &p );
+					continue;
+				}
+				if ( n < 0 ) 
+				{
+					Com_Printf(  "bad %s in NPC '%s'\n", token, NPCName );
+					continue;
+				}
+				if (n != 100)
+				{
+					Com_Printf("MP doesn't support xyz scaling, use 'scale'.\n");
+				//	NPC->s.modelScale[2] = n/100.0f;
+				}
+				continue;
+			}
+
+	//===AI STATS=====================================================================
+			if ( !parsingPlayer )
+			{
+				// aggression
+				if ( !Q_stricmp( token, "aggression" ) ) {
+					if ( COM_ParseInt( &p, &n ) ) {
+						SkipRestOfLine( &p );
+						continue;
+					}
+					if ( n < 1 || n > 5 ) {
+						Com_Printf(  "bad %s in NPC '%s'\n", token, NPCName );
+						continue;
+					}
+					if ( NPC->NPC )
+					{
+						stats->aggression = n;
+					}
+					continue;
+				}
+
+				// aim
+				if ( !Q_stricmp( token, "aim" ) ) {
+					if ( COM_ParseInt( &p, &n ) ) {
+						SkipRestOfLine( &p );
+						continue;
+					}
+					if ( n < 1 || n > 5 ) {
+						Com_Printf( "bad %s in NPC '%s'\n", token, NPCName );
+						continue;
+					}
+					if ( NPC->NPC )
+					{
+						stats->aim = n;
+					}
+					continue;
+				}
+
+				// earshot
+				if ( !Q_stricmp( token, "earshot" ) ) {
+					if ( COM_ParseFloat( &p, &f ) ) {
+						SkipRestOfLine( &p );
+						continue;
+					}
+					if ( f < 0.0f ) 
+					{
+						Com_Printf( "bad %s in NPC '%s'\n", token, NPCName );
+						continue;
+					}
+					if ( NPC->NPC )
+					{
+						stats->earshot = f;
+					}
+					continue;
+				}
+
+				// evasion
+				if ( !Q_stricmp( token, "evasion" ) ) 
+				{
+					if ( COM_ParseInt( &p, &n ) ) 
+					{
+						SkipRestOfLine( &p );
+						continue;
+					}
+					if ( n < 1 || n > 5 ) 
+					{
+						Com_Printf( S_COLOR_YELLOW"WARNING: bad %s in NPC '%s'\n", token, NPCName );
+						continue;
+					}
+					if ( NPC->NPC )
+					{
+						stats->evasion = n;
+					}
+					continue;
+				}
+
+				// hfov
+				if ( !Q_stricmp( token, "hfov" ) ) {
+					if ( COM_ParseInt( &p, &n ) ) {
+						SkipRestOfLine( &p );
+						continue;
+					}
+					if ( n < 30 || n > 180 ) {
+						Com_Printf(  "bad %s in NPC '%s'\n", token, NPCName );
+						continue;
+					}
+					if ( NPC->NPC )
+					{
+						stats->hfov = n;// / 2;	//FIXME: Why was this being done?!
+					}
+					continue;
+				}
+
+				// intelligence
+				if ( !Q_stricmp( token, "intelligence" ) ) {
+					if ( COM_ParseInt( &p, &n ) ) {
+						SkipRestOfLine( &p );
+						continue;
+					}
+					if ( n < 1 || n > 5 ) {
+						Com_Printf(  "bad %s in NPC '%s'\n", token, NPCName );
+						continue;
+					}
+					if ( NPC->NPC )
+					{
+						stats->intelligence = n;
+					}
+					continue;
+				}
+				
+				// move
+				if ( !Q_stricmp( token, "move" ) ) {
+					if ( COM_ParseInt( &p, &n ) ) {
+						SkipRestOfLine( &p );
+						continue;
+					}
+					if ( n < 1 || n > 5 ) {
+						Com_Printf(  "bad %s in NPC '%s'\n", token, NPCName );
+						continue;
+					}
+					if ( NPC->NPC )
+					{
+						stats->move = n;
+					}
+					continue;
+				}
+
+				// reactions
+				if ( !Q_stricmp( token, "reactions" ) ) {
+					if ( COM_ParseInt( &p, &n ) ) {
+						SkipRestOfLine( &p );
+						continue;
+					}
+					if ( n < 1 || n > 5 ) {
+						Com_Printf( "bad %s in NPC '%s'\n", token, NPCName );
+						continue;
+					}
+					if ( NPC->NPC )
+					{
+						stats->reactions = n;
+					}
+					continue;
+				}
+
+				// shootDistance
+				if ( !Q_stricmp( token, "shootDistance" ) ) {
+					if ( COM_ParseFloat( &p, &f ) ) {
+						SkipRestOfLine( &p );
+						continue;
+					}
+					if ( f < 0.0f ) 
+					{
+						Com_Printf( "bad %s in NPC '%s'\n", token, NPCName );
+						continue;
+					}
+					if ( NPC->NPC )
+					{
+						stats->shootDistance = f;
+					}
+					continue;
+				}
+
+				// vfov
+				if ( !Q_stricmp( token, "vfov" ) ) {
+					if ( COM_ParseInt( &p, &n ) ) {
+						SkipRestOfLine( &p );
+						continue;
+					}
+					if ( n < 30 || n > 180 ) {
+						Com_Printf(  "bad %s in NPC '%s'\n", token, NPCName );
+						continue;
+					}
+					if ( NPC->NPC )
+					{
+						stats->vfov = n / 2;
+					}
+					continue;
+				}
+
+				// vigilance
+				if ( !Q_stricmp( token, "vigilance" ) ) {
+					if ( COM_ParseFloat( &p, &f ) ) {
+						SkipRestOfLine( &p );
+						continue;
+					}
+					if ( f < 0.0f ) 
+					{
+						Com_Printf( "bad %s in NPC '%s'\n", token, NPCName );
+						continue;
+					}
+					if ( NPC->NPC )
+					{
+						stats->vigilance = f;
+					}
+					continue;
+				}
+
+				// visrange
+				if ( !Q_stricmp( token, "visrange" ) ) {
+					if ( COM_ParseFloat( &p, &f ) ) {
+						SkipRestOfLine( &p );
+						continue;
+					}
+					if ( f < 0.0f ) 
+					{
+						Com_Printf( "bad %s in NPC '%s'\n", token, NPCName );
+						continue;
+					}
+					if ( NPC->NPC )
+					{
+						stats->visrange = f;
+					}
+					continue;
+				}
+
+				// race
+		//		if ( !Q_stricmp( token, "race" ) ) 
+		//		{
+		//			if ( COM_ParseString( &p, &value ) ) 
+		//			{
+		//				continue;
+		//			}
+		//			NPC->client->race = TranslateRaceName(value);
+		//			continue;
+		//		}
+
+				// rank
+				if ( !Q_stricmp( token, "rank" ) ) 
+				{
+					if ( COM_ParseString( &p, &value ) ) 
+					{
+						continue;
+					}
+					if ( NPC->NPC )
+					{
+						NPC->NPC->rank = TranslateRankName(value);
+					}
+					continue;
+				}
+			}
+
+			// health
+			if ( !Q_stricmp( token, "health" ) ) 
+			{
+				if ( COM_ParseInt( &p, &n ) ) 
+				{
+					SkipRestOfLine( &p );
+					continue;
+				}
+				if ( n < 0 ) 
+				{
+					Com_Printf( S_COLOR_YELLOW"WARNING: bad %s in NPC '%s'\n", token, NPCName );
+					continue;
+				}
+				if ( NPC->NPC )
+				{
+					stats->health = n;
+				}
+				else if ( parsingPlayer )
+				{
+					NPC->client->ps.stats[STAT_MAX_HEALTH] = NPC->client->pers.maxHealth = n;
+				}
+				continue;
+			}
+
+			// fullName
+			if ( !Q_stricmp( token, "fullName" ) ) 
+			{
+				if ( COM_ParseString( &p, &value ) ) 
+				{
+					continue;
+				}
+				NPC->fullName = G_NewString(value);
+				continue;
+			}
+
+			// playerTeam
+			if ( !Q_stricmp( token, "playerTeam" ) ) 
+			{
+				char tk[4096]; //rww - hackilicious!
+
+				if ( COM_ParseString( &p, &value ) ) 
+				{
+					continue;
+				}
+				Com_sprintf(tk, sizeof(tk), "NPC%s", token);
+				NPC->client->playerTeam = NPC->s.teamowner = (team_t)GetIDForString( TeamTable, tk );//TranslateTeamName(value);
+				continue;
+			}
+
+			// enemyTeam
+			if ( !Q_stricmp( token, "enemyTeam" ) ) 
+			{
+				char tk[4096]; //rww - hackilicious!
+
+				if ( COM_ParseString( &p, &value ) ) 
+				{
+					continue;
+				}
+				Com_sprintf(tk, sizeof(tk), "NPC%s", token);
+				NPC->client->enemyTeam = (team_t)GetIDForString( TeamTable, tk );//TranslateTeamName(value);
+				continue;
+			}
+
+			// class
+			if ( !Q_stricmp( token, "class" ) ) 
+			{
+				if ( COM_ParseString( &p, &value ) ) 
+				{
+					continue;
+				}
+				NPC->client->NPC_class = (class_t)GetIDForString( ClassTable, value );
+				NPC->s.NPC_class = NPC->client->NPC_class; //we actually only need this value now, but at the moment I don't feel like changing the 200+ references to client->NPC_class.
+
+				// No md3's for vehicles.
+				if ( NPC->client->NPC_class == CLASS_VEHICLE )
+				{
+					if ( !NPC->m_pVehicle )
+					{//you didn't spawn this guy right!
+						Com_Printf ( S_COLOR_RED "ERROR: Tried to spawn a vehicle NPC (%s) without using NPC_Vehicle or 'NPC spawn vehicle <vehiclename>'!!!  Bad, bad, bad!  Shame on you!\n", NPCName );
+						return qfalse;
+					}
+					md3Model = qfalse;
+				}
+
+				continue;
+			}
+
+			// dismemberment probability for head
+			if ( !Q_stricmp( token, "dismemberProbHead" ) ) {
+				if ( COM_ParseInt( &p, &n ) ) {
+					SkipRestOfLine( &p );
+					continue;
+				}
+				if ( n < 0 ) 
+				{
+					Com_Printf( "bad %s in NPC '%s'\n", token, NPCName );
+					continue;
+				}
+				if ( NPC->NPC )
+				{
+				//	NPC->client->dismemberProbHead = n;
+					//rwwFIXMEFIXME: support for this?
+				}
+				continue;
+			}
+
+			// dismemberment probability for arms
+			if ( !Q_stricmp( token, "dismemberProbArms" ) ) {
+				if ( COM_ParseInt( &p, &n ) ) {
+					SkipRestOfLine( &p );
+					continue;
+				}
+				if ( n < 0 ) 
+				{
+					Com_Printf( "bad %s in NPC '%s'\n", token, NPCName );
+					continue;
+				}
+				if ( NPC->NPC )
+				{
+				//	NPC->client->dismemberProbArms = n;
+				}
+				continue;
+			}
+
+			// dismemberment probability for hands
+			if ( !Q_stricmp( token, "dismemberProbHands" ) ) {
+				if ( COM_ParseInt( &p, &n ) ) {
+					SkipRestOfLine( &p );
+					continue;
+				}
+				if ( n < 0 ) 
+				{
+					Com_Printf( "bad %s in NPC '%s'\n", token, NPCName );
+					continue;
+				}
+				if ( NPC->NPC )
+				{
+				//	NPC->client->dismemberProbHands = n;
+				}
+				continue;
+			}
+
+			// dismemberment probability for waist
+			if ( !Q_stricmp( token, "dismemberProbWaist" ) ) {
+				if ( COM_ParseInt( &p, &n ) ) {
+					SkipRestOfLine( &p );
+					continue;
+				}
+				if ( n < 0 ) 
+				{
+					Com_Printf( "bad %s in NPC '%s'\n", token, NPCName );
+					continue;
+				}
+				if ( NPC->NPC )
+				{
+				//	NPC->client->dismemberProbWaist = n;
+				}
+				continue;
+			}
+
+			// dismemberment probability for legs
+			if ( !Q_stricmp( token, "dismemberProbLegs" ) ) {
+				if ( COM_ParseInt( &p, &n ) ) {
+					SkipRestOfLine( &p );
+					continue;
+				}
+				if ( n < 0 ) 
+				{
+					Com_Printf( "bad %s in NPC '%s'\n", token, NPCName );
+					continue;
+				}
+				if ( NPC->NPC )
+				{
+				//	NPC->client->dismemberProbLegs = n;
+				}
+				continue;
+			}
+
+	//===MOVEMENT STATS============================================================
+			
+			if ( !Q_stricmp( token, "width" ) ) 
+			{
+				if ( COM_ParseInt( &p, &n ) ) 
+				{
+					continue;
+				}
+
+				NPC->r.mins[0] = NPC->r.mins[1] = -n;
+				NPC->r.maxs[0] = NPC->r.maxs[1] = n;
+				continue;
+			}
+
+			if ( !Q_stricmp( token, "height" ) ) 
+			{
+				if ( COM_ParseInt( &p, &n ) ) 
+				{
+					continue;
+				}
+				if ( NPC->client->NPC_class == CLASS_VEHICLE
+					&& NPC->m_pVehicle
+					&& NPC->m_pVehicle->m_pVehicleInfo
+					&& NPC->m_pVehicle->m_pVehicleInfo->type == VH_FIGHTER )
+				{//a flying vehicle's origin must be centered in bbox and it should spawn on the ground
+					//trace_t		tr;
+					//vec3_t		bottom;
+					//float		adjust = 32.0f;
+					NPC->r.maxs[2] = NPC->client->ps.standheight = (n/2.0f);
+					NPC->r.mins[2] = -NPC->r.maxs[2];
+					NPC->s.origin[2] += (DEFAULT_MINS_2-NPC->r.mins[2])+0.125f;
+					VectorCopy(NPC->s.origin, NPC->client->ps.origin);
+					VectorCopy(NPC->s.origin, NPC->r.currentOrigin);
+					G_SetOrigin( NPC, NPC->s.origin );
+					trap_LinkEntity(NPC);
+					//now trace down
+					/*
+					VectorCopy( NPC->s.origin, bottom );
+					bottom[2] -= adjust;
+					trap_Trace( &tr, NPC->s.origin, NPC->r.mins, NPC->r.maxs, bottom, NPC->s.number, MASK_NPCSOLID );
+					if ( !tr.allsolid && !tr.startsolid )
+					{
+						G_SetOrigin( NPC, tr.endpos );
+						trap_LinkEntity(NPC);
+					}
+					*/
+				}
+				else
+				{
+					NPC->r.mins[2] = DEFAULT_MINS_2;//Cannot change
+					NPC->r.maxs[2] = NPC->client->ps.standheight = n + DEFAULT_MINS_2;
+				}
+				NPC->radius = n;
+				continue;
+			}
+
+			if ( !Q_stricmp( token, "crouchheight" ) ) 
+			{
+				if ( COM_ParseInt( &p, &n ) ) 
+				{
+					continue;
+				}
+
+				NPC->client->ps.crouchheight = n + DEFAULT_MINS_2;
+				continue;
+			}
+
+			if ( !parsingPlayer )
+			{
+				if ( !Q_stricmp( token, "movetype" ) ) 
+				{
+					if ( COM_ParseString( &p, &value ) ) 
+					{
+						continue;
+					}
+					if ( Q_stricmp( "flyswim", value ) == 0 )
+					{
+						NPC->client->ps.eFlags2 |= EF2_FLYING;
+					}
+					//NPC->client->moveType = (movetype_t)MoveTypeNameToEnum(value);
+					//rwwFIXMEFIXME: support for movetypes
+					continue;
+				}
+					
+				// yawSpeed
+				if ( !Q_stricmp( token, "yawSpeed" ) ) {
+					if ( COM_ParseInt( &p, &n ) ) {
+						SkipRestOfLine( &p );
+						continue;
+					}
+					if ( n <= 0) {
+						Com_Printf(  "bad %s in NPC '%s'\n", token, NPCName );
+						continue;
+					}
+					if ( NPC->NPC )
+					{
+						stats->yawSpeed = ((float)(n));
+					}
+					continue;
+				}
+
+				// walkSpeed
+				if ( !Q_stricmp( token, "walkSpeed" ) ) 
+				{
+					if ( COM_ParseInt( &p, &n ) ) 
+					{
+						SkipRestOfLine( &p );
+						continue;
+					}
+					if ( n < 0 ) 
+					{
+						Com_Printf( S_COLOR_YELLOW"WARNING: bad %s in NPC '%s'\n", token, NPCName );
+						continue;
+					}
+					if ( NPC->NPC )
+					{
+						stats->walkSpeed = n;
+					}
+					continue;
+				}
+				
+				//runSpeed
+				if ( !Q_stricmp( token, "runSpeed" ) ) 
+				{
+					if ( COM_ParseInt( &p, &n ) ) 
+					{
+						SkipRestOfLine( &p );
+						continue;
+					}
+					if ( n < 0 ) 
+					{
+						Com_Printf( S_COLOR_YELLOW"WARNING: bad %s in NPC '%s'\n", token, NPCName );
+						continue;
+					}
+					if ( NPC->NPC )
+					{
+						stats->runSpeed = n;
+					}
+					continue;
+				}
+
+				//acceleration
+				if ( !Q_stricmp( token, "acceleration" ) ) 
+				{
+					if ( COM_ParseInt( &p, &n ) ) 
+					{
+						SkipRestOfLine( &p );
+						continue;
+					}
+					if ( n < 0 ) 
+					{
+						Com_Printf( S_COLOR_YELLOW"WARNING: bad %s in NPC '%s'\n", token, NPCName );
+						continue;
+					}
+					if ( NPC->NPC )
+					{
+						stats->acceleration = n;
+					}
+					continue;
+				}
+				//sex - skip in MP
+				if ( !Q_stricmp( token, "sex" ) ) 
+				{
+					SkipRestOfLine( &p );
+					continue;
+				}
+//===MISC===============================================================================
+				// default behavior
+				if ( !Q_stricmp( token, "behavior" ) ) 
+				{
+					if ( COM_ParseInt( &p, &n ) ) 
+					{
+						SkipRestOfLine( &p );
+						continue;
+					}
+					if ( n < BS_DEFAULT || n >= NUM_BSTATES ) 
+					{
+						Com_Printf( S_COLOR_YELLOW"WARNING: bad %s in NPC '%s'\n", token, NPCName );
+						continue;
+					}
+					if ( NPC->NPC )
+					{
+						NPC->NPC->defaultBehavior = (bState_t)(n);
+					}
+					continue;
+				}
+			}
+
+			// snd
+			if ( !Q_stricmp( token, "snd" ) ) 
+			{
+				if ( COM_ParseString( &p, &value ) ) 
+				{
+					continue;
+				}
+				//if ( !(NPC->svFlags&SVF_NO_BASIC_SOUNDS) )
+				if (1)
+				{
+					//FIXME: store this in some sound field or parse in the soundTable like the animTable...
+					Q_strncpyz( sound, value, sizeof( sound ) );
+					patch = strstr( sound, "/" );
+					if ( patch ) 
+					{
+						*patch = 0;
+					}
+				//	ci->customBasicSoundDir = G_NewString( sound );
+					//rwwFIXMEFIXME: Hooray for violating client server rules
+				}
+				continue;
+			}
+
+			// sndcombat
+			if ( !Q_stricmp( token, "sndcombat" ) ) 
+			{
+				if ( COM_ParseString( &p, &value ) ) 
+				{
+					continue;
+				}
+				//if ( !(NPC->svFlags&SVF_NO_COMBAT_SOUNDS) )
+				if (1)
+				{
+					//FIXME: store this in some sound field or parse in the soundTable like the animTable...
+					Q_strncpyz( sound, value, sizeof( sound ) );
+					patch = strstr( sound, "/" );
+					if ( patch ) 
+					{
+						*patch = 0;
+					}
+				//	ci->customCombatSoundDir = G_NewString( sound );
+				}
+				continue;
+			}
+			
+			// sndextra
+			if ( !Q_stricmp( token, "sndextra" ) ) 
+			{
+				if ( COM_ParseString( &p, &value ) ) 
+				{
+					continue;
+				}
+				//if ( !(NPC->svFlags&SVF_NO_EXTRA_SOUNDS) )
+				if (1)
+				{
+					//FIXME: store this in some sound field or parse in the soundTable like the animTable...
+					Q_strncpyz( sound, value, sizeof( sound ) );
+					patch = strstr( sound, "/" );
+					if ( patch ) 
+					{
+						*patch = 0;
+					}
+				//	ci->customExtraSoundDir = G_NewString( sound );
+				}
+				continue;
+			}
+
+			// sndjedi
+			if ( !Q_stricmp( token, "sndjedi" ) ) 
+			{
+				if ( COM_ParseString( &p, &value ) ) 
+				{
+					continue;
+				}
+				//if ( !(NPC->svFlags&SVF_NO_EXTRA_SOUNDS) )
+				if (1)
+				{
+					//FIXME: store this in some sound field or parse in the soundTable like the animTable...
+					Q_strncpyz( sound, value, sizeof( sound ) );
+					patch = strstr( sound, "/" );
+					if ( patch ) 
+					{
+						*patch = 0;
+					}
+					//ci->customJediSoundDir = G_NewString( sound );
+				}
+				continue;
+			}
+
+			//New NPC/jedi stats:
+			//starting weapon
+			if ( !Q_stricmp( token, "weapon" ) ) 
+			{
+				int weap;
+
+				if ( COM_ParseString( &p, &value ) ) 
+				{
+					continue;
+				}
+				//FIXME: need to precache the weapon, too?  (in above func)
+				weap = GetIDForString( WPTable, value );
+				if ( weap >= WP_NONE && weap <= WP_NUM_WEAPONS )///*WP_BLASTER_PISTOL*/WP_SABER ) //?!
+				{
+					NPC->client->ps.weapon = weap;
+					NPC->client->ps.stats[STAT_WEAPONS] |= ( 1 << NPC->client->ps.weapon );
+					if ( weap > WP_NONE )
+					{
+					//	RegisterItem( FindItemForWeapon( (weapon_t)(NPC->client->ps.weapon) ) );	//precache the weapon
+						NPC->client->ps.ammo[weaponData[NPC->client->ps.weapon].ammoIndex] = 100;//FIXME: max ammo!
+					}
+				}
+				continue;
+			}
+			
+			if ( !parsingPlayer )
+			{
+				//altFire
+				if ( !Q_stricmp( token, "altFire" ) ) 
+				{
+					if ( COM_ParseInt( &p, &n ) ) 
+					{
+						SkipRestOfLine( &p );
+						continue;
+					}
+					if ( NPC->NPC )
+					{
+						if ( n != 0 )
+						{
+							NPC->NPC->scriptFlags |= SCF_ALT_FIRE;
+						}
+					}
+					continue;
+				}
+				//Other unique behaviors/numbers that are currently hardcoded?
+			}
+
+			//force powers
+			fp = GetIDForString( FPTable, token );
+			if ( fp >= FP_FIRST && fp < NUM_FORCE_POWERS )
+			{
+				if ( COM_ParseInt( &p, &n ) ) 
+				{
+					SkipRestOfLine( &p );
+					continue;
+				}
+				//FIXME: need to precache the fx, too?  (in above func)
+				//cap
+				if ( n > 5 )
+				{
+					n = 5;
+				}
+				else if ( n < 0 )
+				{
+					n = 0;
+				}
+				if ( n )
+				{//set
+					NPC->client->ps.fd.forcePowersKnown |= ( 1 << fp );
+				}
+				else
+				{//clear
+					NPC->client->ps.fd.forcePowersKnown &= ~( 1 << fp );
+				}
+				NPC->client->ps.fd.forcePowerLevel[fp] = n;
+				continue;
+			}
+
+			//max force power
+			if ( !Q_stricmp( token, "forcePowerMax" ) ) 
+			{
+				if ( COM_ParseInt( &p, &n ) ) 
+				{
+					SkipRestOfLine( &p );
+					continue;
+				}
+				NPC->client->ps.fd.forcePowerMax = n;
+				continue;
+			}
+
+			//force regen rate - default is 100ms
+			if ( !Q_stricmp( token, "forceRegenRate" ) ) 
+			{
+				if ( COM_ParseInt( &p, &n ) ) 
+				{
+					SkipRestOfLine( &p );
+					continue;
+				}
+				//NPC->client->ps.forcePowerRegenRate = n;
+				//rwwFIXMEFIXME: support this?
+				continue;
+			}
+
+			//force regen amount - default is 1 (points per second)
+			if ( !Q_stricmp( token, "forceRegenAmount" ) ) 
+			{
+				if ( COM_ParseInt( &p, &n ) ) 
+				{
+					SkipRestOfLine( &p );
+					continue;
+				}
+				//NPC->client->ps.forcePowerRegenAmount = n;
+				//rwwFIXMEFIXME: support this?
+				continue;
+			}
+
+			//have a sabers.cfg and just name your saber in your NPCs.cfg/ICARUS script
+			//saber name
+			if ( !Q_stricmp( token, "saber" ) ) 
+			{
+				char *saberName;
+
+				if ( COM_ParseString( &p, &value ) ) 
+				{
+					continue;
+				}
+
+				saberName = (char *)BG_TempAlloc(4096);//G_NewString( value );
+				strcpy(saberName, value);
+
+				WP_SaberParseParms( saberName, &NPC->client->saber[0] );
+				npcSaber1 = G_ModelIndex(va("@%s", saberName));
+
+				BG_TempFree(4096);
+				continue;
+			}
+			
+			//second saber name
+			if ( !Q_stricmp( token, "saber2" ) ) 
+			{
+				if ( COM_ParseString( &p, &value ) ) 
+				{
+					continue;
+				}
+
+				if ( !NPC->client->saber[0].twoHanded )
+				{//can't use a second saber if first one is a two-handed saber...?
+					char *saberName = (char *)BG_TempAlloc(4096);//G_NewString( value );
+					strcpy(saberName, value);
+
+					WP_SaberParseParms( saberName, &NPC->client->saber[1] );
+					if ( NPC->client->saber[1].twoHanded )
+					{//tsk tsk, can't use a twoHanded saber as second saber
+						WP_RemoveSaber( NPC->client->saber, 1 );
+					}
+					else
+					{
+						//NPC->client->ps.dualSabers = qtrue;
+						npcSaber2 = G_ModelIndex(va("@%s", saberName));
+					}
+					BG_TempFree(4096);
+				}
+				continue;
+			}
+
+			// saberColor
+			if ( !Q_stricmp( token, "saberColor" ) ) 
+			{
+				if ( COM_ParseString( &p, &value ) ) 
+				{
+					continue;
+				}
+				if ( NPC->client )
+				{
+					saber_colors_t color = TranslateSaberColor( value );
+					for ( n = 0; n < MAX_BLADES; n++ )
+					{
+						NPC->client->saber[0].blade[n].color = color;
+					}
+				}
+				continue;
+			}
+
+			if ( !Q_stricmp( token, "saberColor2" ) ) 
+			{
+				if ( COM_ParseString( &p, &value ) ) 
+				{
+					continue;
+				}
+				if ( NPC->client )
+				{
+					NPC->client->saber[0].blade[1].color = TranslateSaberColor( value );
+				}
+				continue;
+			}
+
+			if ( !Q_stricmp( token, "saberColor3" ) ) 
+			{
+				if ( COM_ParseString( &p, &value ) ) 
+				{
+					continue;
+				}
+				if ( NPC->client )
+				{
+					NPC->client->saber[0].blade[2].color = TranslateSaberColor( value );
+				}
+				continue;
+			}
+
+			if ( !Q_stricmp( token, "saberColor4" ) ) 
+			{
+				if ( COM_ParseString( &p, &value ) ) 
+				{
+					continue;
+				}
+				if ( NPC->client )
+				{
+					NPC->client->saber[0].blade[3].color = TranslateSaberColor( value );
+				}
+				continue;
+			}
+
+			if ( !Q_stricmp( token, "saberColor5" ) ) 
+			{
+				if ( COM_ParseString( &p, &value ) ) 
+				{
+					continue;
+				}
+				if ( NPC->client )
+				{
+					NPC->client->saber[0].blade[4].color = TranslateSaberColor( value );
+				}
+				continue;
+			}
+
+			if ( !Q_stricmp( token, "saberColor6" ) ) 
+			{
+				if ( COM_ParseString( &p, &value ) ) 
+				{
+					continue;
+				}
+				if ( NPC->client )
+				{
+					NPC->client->saber[0].blade[5].color = TranslateSaberColor( value );
+				}
+				continue;
+			}
+
+			if ( !Q_stricmp( token, "saberColor7" ) ) 
+			{
+				if ( COM_ParseString( &p, &value ) ) 
+				{
+					continue;
+				}
+				if ( NPC->client )
+				{
+					NPC->client->saber[0].blade[6].color = TranslateSaberColor( value );
+				}
+				continue;
+			}
+
+			if ( !Q_stricmp( token, "saberColor8" ) ) 
+			{
+				if ( COM_ParseString( &p, &value ) ) 
+				{
+					continue;
+				}
+				if ( NPC->client )
+				{
+					NPC->client->saber[0].blade[7].color = TranslateSaberColor( value );
+				}
+				continue;
+			}
+
+			if ( !Q_stricmp( token, "saber2Color" ) ) 
+			{
+				if ( COM_ParseString( &p, &value ) ) 
+				{
+					continue;
+				}
+				if ( NPC->client )
+				{
+					saber_colors_t color = TranslateSaberColor( value );
+					for ( n = 0; n < MAX_BLADES; n++ )
+					{
+						NPC->client->saber[1].blade[n].color = color;
+					}
+				}
+				continue;
+			}
+
+			if ( !Q_stricmp( token, "saber2Color2" ) ) 
+			{
+				if ( COM_ParseString( &p, &value ) ) 
+				{
+					continue;
+				}
+				if ( NPC->client )
+				{
+					NPC->client->saber[1].blade[1].color = TranslateSaberColor( value );
+				}
+				continue;
+			}
+
+			if ( !Q_stricmp( token, "saber2Color3" ) ) 
+			{
+				if ( COM_ParseString( &p, &value ) ) 
+				{
+					continue;
+				}
+				if ( NPC->client )
+				{
+					NPC->client->saber[1].blade[2].color = TranslateSaberColor( value );
+				}
+				continue;
+			}
+
+			if ( !Q_stricmp( token, "saber2Color4" ) ) 
+			{
+				if ( COM_ParseString( &p, &value ) ) 
+				{
+					continue;
+				}
+				if ( NPC->client )
+				{
+					NPC->client->saber[1].blade[3].color = TranslateSaberColor( value );
+				}
+				continue;
+			}
+
+			if ( !Q_stricmp( token, "saber2Color5" ) ) 
+			{
+				if ( COM_ParseString( &p, &value ) ) 
+				{
+					continue;
+				}
+				if ( NPC->client )
+				{
+					NPC->client->saber[1].blade[4].color = TranslateSaberColor( value );
+				}
+				continue;
+			}
+
+			if ( !Q_stricmp( token, "saber2Color6" ) ) 
+			{
+				if ( COM_ParseString( &p, &value ) ) 
+				{
+					continue;
+				}
+				if ( NPC->client )
+				{
+					NPC->client->saber[1].blade[5].color = TranslateSaberColor( value );
+				}
+				continue;
+			}
+
+			if ( !Q_stricmp( token, "saber2Color7" ) ) 
+			{
+				if ( COM_ParseString( &p, &value ) ) 
+				{
+					continue;
+				}
+				if ( NPC->client )
+				{
+					NPC->client->saber[1].blade[6].color = TranslateSaberColor( value );
+				}
+				continue;
+			}
+
+			if ( !Q_stricmp( token, "saber2Color8" ) ) 
+			{
+				if ( COM_ParseString( &p, &value ) ) 
+				{
+					continue;
+				}
+				if ( NPC->client )
+				{
+					NPC->client->saber[1].blade[7].color = TranslateSaberColor( value );
+				}
+				continue;
+			}
+
+			//saber length
+			if ( !Q_stricmp( token, "saberLength" ) ) 
+			{
+				if ( COM_ParseFloat( &p, &f ) ) 
+				{
+					SkipRestOfLine( &p );
+					continue;
+				}
+				//cap
+				if ( f < 4.0f )
+				{
+					f = 4.0f;
+				}
+
+				for ( n = 0; n < MAX_BLADES; n++ )
+				{
+					NPC->client->saber[0].blade[n].lengthMax = f;
+				}
+				continue;
+			}
+
+			if ( !Q_stricmp( token, "saberLength2" ) ) 
+			{
+				if ( COM_ParseFloat( &p, &f ) ) 
+				{
+					SkipRestOfLine( &p );
+					continue;
+				}
+				//cap
+				if ( f < 4.0f )
+				{
+					f = 4.0f;
+				}
+				NPC->client->saber[0].blade[1].lengthMax = f;
+				continue;
+			}
+
+			if ( !Q_stricmp( token, "saberLength3" ) ) 
+			{
+				if ( COM_ParseFloat( &p, &f ) ) 
+				{
+					SkipRestOfLine( &p );
+					continue;
+				}
+				//cap
+				if ( f < 4.0f )
+				{
+					f = 4.0f;
+				}
+				NPC->client->saber[0].blade[2].lengthMax = f;
+				continue;
+			}
+
+			if ( !Q_stricmp( token, "saberLength4" ) ) 
+			{
+				if ( COM_ParseFloat( &p, &f ) ) 
+				{
+					SkipRestOfLine( &p );
+					continue;
+				}
+				//cap
+				if ( f < 4.0f )
+				{
+					f = 4.0f;
+				}
+				NPC->client->saber[0].blade[3].lengthMax = f;
+				continue;
+			}
+
+			if ( !Q_stricmp( token, "saberLength5" ) ) 
+			{
+				if ( COM_ParseFloat( &p, &f ) ) 
+				{
+					SkipRestOfLine( &p );
+					continue;
+				}
+				//cap
+				if ( f < 4.0f )
+				{
+					f = 4.0f;
+				}
+				NPC->client->saber[0].blade[4].lengthMax = f;
+				continue;
+			}
+
+			if ( !Q_stricmp( token, "saberLength6" ) ) 
+			{
+				if ( COM_ParseFloat( &p, &f ) ) 
+				{
+					SkipRestOfLine( &p );
+					continue;
+				}
+				//cap
+				if ( f < 4.0f )
+				{
+					f = 4.0f;
+				}
+				NPC->client->saber[0].blade[5].lengthMax = f;
+				continue;
+			}
+
+			if ( !Q_stricmp( token, "saberLength7" ) ) 
+			{
+				if ( COM_ParseFloat( &p, &f ) ) 
+				{
+					SkipRestOfLine( &p );
+					continue;
+				}
+				//cap
+				if ( f < 4.0f )
+				{
+					f = 4.0f;
+				}
+				NPC->client->saber[0].blade[6].lengthMax = f;
+				continue;
+			}
+
+			if ( !Q_stricmp( token, "saberLength8" ) ) 
+			{
+				if ( COM_ParseFloat( &p, &f ) ) 
+				{
+					SkipRestOfLine( &p );
+					continue;
+				}
+				//cap
+				if ( f < 4.0f )
+				{
+					f = 4.0f;
+				}
+				NPC->client->saber[0].blade[7].lengthMax = f;
+				continue;
+			}
+
+			if ( !Q_stricmp( token, "saber2Length" ) ) 
+			{
+				if ( COM_ParseFloat( &p, &f ) ) 
+				{
+					SkipRestOfLine( &p );
+					continue;
+				}
+				//cap
+				if ( f < 4.0f )
+				{
+					f = 4.0f;
+				}
+				for ( n = 0; n < MAX_BLADES; n++ )
+				{
+					NPC->client->saber[1].blade[n].lengthMax = f;
+				}
+				continue;
+			}
+
+			if ( !Q_stricmp( token, "saber2Length2" ) ) 
+			{
+				if ( COM_ParseFloat( &p, &f ) ) 
+				{
+					SkipRestOfLine( &p );
+					continue;
+				}
+				//cap
+				if ( f < 4.0f )
+				{
+					f = 4.0f;
+				}
+				NPC->client->saber[1].blade[1].lengthMax = f;
+				continue;
+			}
+
+			if ( !Q_stricmp( token, "saber2Length3" ) ) 
+			{
+				if ( COM_ParseFloat( &p, &f ) ) 
+				{
+					SkipRestOfLine( &p );
+					continue;
+				}
+				//cap
+				if ( f < 4.0f )
+				{
+					f = 4.0f;
+				}
+				NPC->client->saber[1].blade[2].lengthMax = f;
+				continue;
+			}
+
+			if ( !Q_stricmp( token, "saber2Length4" ) ) 
+			{
+				if ( COM_ParseFloat( &p, &f ) ) 
+				{
+					SkipRestOfLine( &p );
+					continue;
+				}
+				//cap
+				if ( f < 4.0f )
+				{
+					f = 4.0f;
+				}
+				NPC->client->saber[1].blade[3].lengthMax = f;
+				continue;
+			}
+
+			if ( !Q_stricmp( token, "saber2Length5" ) ) 
+			{
+				if ( COM_ParseFloat( &p, &f ) ) 
+				{
+					SkipRestOfLine( &p );
+					continue;
+				}
+				//cap
+				if ( f < 4.0f )
+				{
+					f = 4.0f;
+				}
+				NPC->client->saber[1].blade[4].lengthMax = f;
+				continue;
+			}
+
+			if ( !Q_stricmp( token, "saber2Length6" ) ) 
+			{
+				if ( COM_ParseFloat( &p, &f ) ) 
+				{
+					SkipRestOfLine( &p );
+					continue;
+				}
+				//cap
+				if ( f < 4.0f )
+				{
+					f = 4.0f;
+				}
+				NPC->client->saber[1].blade[5].lengthMax = f;
+				continue;
+			}
+
+			if ( !Q_stricmp( token, "saber2Length7" ) ) 
+			{
+				if ( COM_ParseFloat( &p, &f ) ) 
+				{
+					SkipRestOfLine( &p );
+					continue;
+				}
+				//cap
+				if ( f < 4.0f )
+				{
+					f = 4.0f;
+				}
+				NPC->client->saber[1].blade[6].lengthMax = f;
+				continue;
+			}
+
+			if ( !Q_stricmp( token, "saber2Length8" ) ) 
+			{
+				if ( COM_ParseFloat( &p, &f ) ) 
+				{
+					SkipRestOfLine( &p );
+					continue;
+				}
+				//cap
+				if ( f < 4.0f )
+				{
+					f = 4.0f;
+				}
+				NPC->client->saber[1].blade[7].lengthMax = f;
+				continue;
+			}
+
+			//saber radius
+			if ( !Q_stricmp( token, "saberRadius" ) ) 
+			{
+				if ( COM_ParseFloat( &p, &f ) ) 
+				{
+					SkipRestOfLine( &p );
+					continue;
+				}
+				//cap
+				if ( f < 0.25f )
+				{
+					f = 0.25f;
+				}
+				for ( n = 0; n < MAX_BLADES; n++ )
+				{
+					NPC->client->saber[0].blade[n].radius = f;
+				}
+				continue;
+			}
+
+			if ( !Q_stricmp( token, "saberRadius2" ) ) 
+			{
+				if ( COM_ParseFloat( &p, &f ) ) 
+				{
+					SkipRestOfLine( &p );
+					continue;
+				}
+				//cap
+				if ( f < 0.25f )
+				{
+					f = 0.25f;
+				}
+				NPC->client->saber[0].blade[1].radius = f;
+				continue;
+			}
+
+			if ( !Q_stricmp( token, "saberRadius3" ) ) 
+			{
+				if ( COM_ParseFloat( &p, &f ) ) 
+				{
+					SkipRestOfLine( &p );
+					continue;
+				}
+				//cap
+				if ( f < 0.25f )
+				{
+					f = 0.25f;
+				}
+				NPC->client->saber[0].blade[2].radius = f;
+				continue;
+			}
+
+			if ( !Q_stricmp( token, "saberRadius4" ) ) 
+			{
+				if ( COM_ParseFloat( &p, &f ) ) 
+				{
+					SkipRestOfLine( &p );
+					continue;
+				}
+				//cap
+				if ( f < 0.25f )
+				{
+					f = 0.25f;
+				}
+				NPC->client->saber[0].blade[3].radius = f;
+				continue;
+			}
+
+			if ( !Q_stricmp( token, "saberRadius5" ) ) 
+			{
+				if ( COM_ParseFloat( &p, &f ) ) 
+				{
+					SkipRestOfLine( &p );
+					continue;
+				}
+				//cap
+				if ( f < 0.25f )
+				{
+					f = 0.25f;
+				}
+				NPC->client->saber[0].blade[4].radius = f;
+				continue;
+			}
+
+			if ( !Q_stricmp( token, "saberRadius6" ) ) 
+			{
+				if ( COM_ParseFloat( &p, &f ) ) 
+				{
+					SkipRestOfLine( &p );
+					continue;
+				}
+				//cap
+				if ( f < 0.25f )
+				{
+					f = 0.25f;
+				}
+				NPC->client->saber[0].blade[5].radius = f;
+				continue;
+			}
+
+			if ( !Q_stricmp( token, "saberRadius7" ) ) 
+			{
+				if ( COM_ParseFloat( &p, &f ) ) 
+				{
+					SkipRestOfLine( &p );
+					continue;
+				}
+				//cap
+				if ( f < 0.25f )
+				{
+					f = 0.25f;
+				}
+				NPC->client->saber[0].blade[6].radius = f;
+				continue;
+			}
+
+			if ( !Q_stricmp( token, "saberRadius8" ) ) 
+			{
+				if ( COM_ParseFloat( &p, &f ) ) 
+				{
+					SkipRestOfLine( &p );
+					continue;
+				}
+				//cap
+				if ( f < 0.25f )
+				{
+					f = 0.25f;
+				}
+				NPC->client->saber[0].blade[7].radius = f;
+				continue;
+			}
+
+			if ( !Q_stricmp( token, "saber2Radius" ) ) 
+			{
+				if ( COM_ParseFloat( &p, &f ) ) 
+				{
+					SkipRestOfLine( &p );
+					continue;
+				}
+				//cap
+				if ( f < 0.25f )
+				{
+					f = 0.25f;
+				}
+				for ( n = 0; n < MAX_BLADES; n++ )
+				{
+					NPC->client->saber[1].blade[n].radius = f;
+				}
+				continue;
+			}
+
+			if ( !Q_stricmp( token, "saber2Radius2" ) ) 
+			{
+				if ( COM_ParseFloat( &p, &f ) ) 
+				{
+					SkipRestOfLine( &p );
+					continue;
+				}
+				//cap
+				if ( f < 0.25f )
+				{
+					f = 0.25f;
+				}
+				NPC->client->saber[1].blade[1].radius = f;
+				continue;
+			}
+
+			if ( !Q_stricmp( token, "saber2Radius3" ) ) 
+			{
+				if ( COM_ParseFloat( &p, &f ) ) 
+				{
+					SkipRestOfLine( &p );
+					continue;
+				}
+				//cap
+				if ( f < 0.25f )
+				{
+					f = 0.25f;
+				}
+				NPC->client->saber[1].blade[2].radius = f;
+				continue;
+			}
+
+			if ( !Q_stricmp( token, "saber2Radius4" ) ) 
+			{
+				if ( COM_ParseFloat( &p, &f ) ) 
+				{
+					SkipRestOfLine( &p );
+					continue;
+				}
+				//cap
+				if ( f < 0.25f )
+				{
+					f = 0.25f;
+				}
+				NPC->client->saber[1].blade[3].radius = f;
+				continue;
+			}
+
+			if ( !Q_stricmp( token, "saber2Radius5" ) ) 
+			{
+				if ( COM_ParseFloat( &p, &f ) ) 
+				{
+					SkipRestOfLine( &p );
+					continue;
+				}
+				//cap
+				if ( f < 0.25f )
+				{
+					f = 0.25f;
+				}
+				NPC->client->saber[1].blade[4].radius = f;
+				continue;
+			}
+
+			if ( !Q_stricmp( token, "saber2Radius6" ) ) 
+			{
+				if ( COM_ParseFloat( &p, &f ) ) 
+				{
+					SkipRestOfLine( &p );
+					continue;
+				}
+				//cap
+				if ( f < 0.25f )
+				{
+					f = 0.25f;
+				}
+				NPC->client->saber[1].blade[5].radius = f;
+				continue;
+			}
+
+			if ( !Q_stricmp( token, "saber2Radius7" ) ) 
+			{
+				if ( COM_ParseFloat( &p, &f ) ) 
+				{
+					SkipRestOfLine( &p );
+					continue;
+				}
+				//cap
+				if ( f < 0.25f )
+				{
+					f = 0.25f;
+				}
+				NPC->client->saber[1].blade[6].radius = f;
+				continue;
+			}
+
+			if ( !Q_stricmp( token, "saber2Radius8" ) ) 
+			{
+				if ( COM_ParseFloat( &p, &f ) ) 
+				{
+					SkipRestOfLine( &p );
+					continue;
+				}
+				//cap
+				if ( f < 0.25f )
+				{
+					f = 0.25f;
+				}
+				NPC->client->saber[1].blade[7].radius = f;
+				continue;
+			}
+
+			//ADD:
+			//saber sounds (on, off, loop)
+			//loop sound (like Vader's breathing or droid bleeps, etc.)
+
+			//starting saber style
+			if ( !Q_stricmp( token, "saberStyle" ) ) 
+			{
+				if ( COM_ParseInt( &p, &n ) ) 
+				{
+					SkipRestOfLine( &p );
+					continue;
+				}
+				//cap
+				if ( n < 0 )
+				{
+					n = 0;
+				}
+				else if ( n > 5 )
+				{
+					n = 5;
+				}
+				NPC->client->ps.fd.saberAnimLevel = n;
+				/*
+				if ( parsingPlayer )
+				{
+					cg.saberAnimLevelPending = n;
+				}
+				*/
+				continue;
+			}
+
+			if ( !parsingPlayer )
+			{
+				Com_Printf( "WARNING: unknown keyword '%s' while parsing '%s'\n", token, NPCName );
+			}
+			SkipRestOfLine( &p );
+		}
+	}
+
+/*
+Ghoul2 Insert Start
+*/
+	if ( !md3Model )
+	{
+		qboolean setTypeBack = qfalse;
+
+		if (npcSaber1 == 0)
+		{ //use "kyle" for a default then
+			npcSaber1 = G_ModelIndex("@Kyle");
+			WP_SaberParseParms( "Kyle", &NPC->client->saber[0] );
+		}
+
+		NPC->s.npcSaber1 = npcSaber1;
+		NPC->s.npcSaber2 = npcSaber2;
+
+		if (!customSkin[0])
+		{
+			strcpy(customSkin, "default");
+		}
+
+		if ( NPC->client && NPC->client->NPC_class == CLASS_VEHICLE )
+		{ //vehicles want their names fed in as models
+			//we put the $ in front to indicate a name and not a model
+			strcpy(playerModel, va("$%s", NPCName));
+		}
+		SetupGameGhoul2Model(NPC, playerModel, customSkin);
+
+		if (!NPC->NPC_type)
+		{ //just do this for now so NPC_Precache can see the name.
+			NPC->NPC_type = (char *)NPCName;
+			setTypeBack = qtrue;
+		}
+
+		NPC_Precache(NPC); //this will just soundindex some values for sounds on the client,
+
+		if (setTypeBack)
+		{ //don't want this being set if we aren't ready yet.
+			NPC->NPC_type = NULL;
+		}
+	}
+	else
+	{
+		Com_Printf("MD3 MODEL NPC'S ARE NOT SUPPORTED IN MP!\n");
+		return qfalse;
+	}
+/*
+Ghoul2 Insert End
+*/
+	/*
+	if(	NPCsPrecached )
+	{//Spawning in after initial precache, our models are precached, we just need to set our clientInfo
+		CG_RegisterClientModels( NPC->s.number );
+		CG_RegisterNPCCustomSounds( ci );
+		CG_RegisterNPCEffects( NPC->client->playerTeam );
+	}
+	*/
+	//rwwFIXMEFIXME: Do something here I guess to properly precache stuff.
+
+	return qtrue;
+}
+
+#ifdef _XBOX
+char *npcParseBuffer = NULL;
+#else
+char npcParseBuffer[MAX_NPC_DATA_SIZE];
+#endif
+
+void NPC_LoadParms( void ) 
+{
+	int			len, totallen, npcExtFNLen, mainBlockLen, fileCnt, i;
+//	const char	*filename = "ext_data/NPC2.cfg";
+	char		/**buffer,*/ *holdChar, *marker;
+	char		npcExtensionListBuf[2048];			//	The list of file names read in
+	fileHandle_t f;
+	len = 0;
+
+	//remember where to store the next one
+	totallen = mainBlockLen = len;
+	marker = NPCParms+totallen;
+	*marker = 0;
+
+	//now load in the extra .npc extensions
+	fileCnt = trap_FS_GetFileList("ext_data/NPCs", ".npc", npcExtensionListBuf, sizeof(npcExtensionListBuf) );
+
+#ifdef _XBOX
+	npcParseBuffer = (char *) Z_Malloc(MAX_NPC_DATA_SIZE, TAG_TEMP_WORKSPACE, qfalse, 4);
+#endif
+
+	holdChar = npcExtensionListBuf;
+	for ( i = 0; i < fileCnt; i++, holdChar += npcExtFNLen + 1 ) 
+	{
+		npcExtFNLen = strlen( holdChar );
+
+//		Com_Printf( "Parsing %s\n", holdChar );
+
+		len = trap_FS_FOpenFile(va( "ext_data/NPCs/%s", holdChar), &f, FS_READ);
+
+		if ( len == -1 ) 
+		{
+			Com_Printf( "error reading file\n" );
+		}
+		else
+		{
+			if ( totallen + len >= MAX_NPC_DATA_SIZE ) {
+				G_Error( "NPC extensions (*.npc) are too large" );
+			}
+			trap_FS_Read(npcParseBuffer, len, f);
+			npcParseBuffer[len] = 0;
+
+			strcat( marker, npcParseBuffer );
+			strcat(marker, "\n");
+			trap_FS_FCloseFile(f);
+
+			totallen += len;
+			marker = NPCParms+totallen;
+			//*marker = 0; //rww - make sure this is null or strcat will not append to the correct place
+			//rww  12/19/02-actually the probelm was npcParseBuffer not being nul-term'd, which could cause issues in the strcat too
+		}
+	}
+
+#ifdef _XBOX
+	Z_Free(npcParseBuffer);
+	npcParseBuffer = NULL;
+#endif
+
+}
diff --git a/codemp/game/NPC_utils.c b/codemp/game/NPC_utils.c
new file mode 100644
index 0000000..4e854b1
--- /dev/null
+++ b/codemp/game/NPC_utils.c
@@ -0,0 +1,1782 @@
+//NPC_utils.cpp
+
+#include "b_local.h"
+#include "../icarus/Q3_Interface.h"
+#include "../ghoul2/G2.h"
+
+int	teamNumbers[TEAM_NUM_TEAMS];
+int	teamStrength[TEAM_NUM_TEAMS];
+int	teamCounter[TEAM_NUM_TEAMS];
+
+#define	VALID_ATTACK_CONE	2.0f	//Degrees
+extern void G_DebugPrint( int level, const char *format, ... );
+
+/*
+void CalcEntitySpot ( gentity_t *ent, spot_t spot, vec3_t point ) 
+
+Added: Uses shootAngles if a NPC has them
+
+*/
+void CalcEntitySpot ( const gentity_t *ent, const spot_t spot, vec3_t point ) 
+{
+	vec3_t	forward, up, right;
+	vec3_t	start, end;
+	trace_t	tr;
+
+	if ( !ent )
+	{
+		return;
+	}
+	switch ( spot ) 
+	{
+	case SPOT_ORIGIN:
+		if(VectorCompare(ent->r.currentOrigin, vec3_origin))
+		{//brush
+			VectorSubtract(ent->r.absmax, ent->r.absmin, point);//size
+			VectorMA(ent->r.absmin, 0.5, point, point);
+		}
+		else
+		{
+			VectorCopy ( ent->r.currentOrigin, point );
+		}
+		break;
+
+	case SPOT_CHEST:
+	case SPOT_HEAD:
+		if ( ent->client && VectorLengthSquared( ent->client->renderInfo.eyePoint ) /*&& (ent->client->ps.viewEntity <= 0 || ent->client->ps.viewEntity >= ENTITYNUM_WORLD)*/ )
+		{//Actual tag_head eyespot!
+			//FIXME: Stasis aliens may have a problem here...
+			VectorCopy( ent->client->renderInfo.eyePoint, point );
+			if ( ent->client->NPC_class == CLASS_ATST )
+			{//adjust up some
+				point[2] += 28;//magic number :)
+			}
+			if ( ent->NPC )
+			{//always aim from the center of my bbox, so we don't wiggle when we lean forward or backwards
+				point[0] = ent->r.currentOrigin[0];
+				point[1] = ent->r.currentOrigin[1];
+			}
+			/*
+			else if (ent->s.eType == ET_PLAYER )
+			{
+				SubtractLeanOfs( ent, point );
+			}
+			*/
+		}
+		else
+		{
+			VectorCopy ( ent->r.currentOrigin, point );
+			if ( ent->client ) 
+			{
+				point[2] += ent->client->ps.viewheight;
+			}
+		}
+		if ( spot == SPOT_CHEST && ent->client )
+		{
+			if ( ent->client->NPC_class != CLASS_ATST )
+			{//adjust up some
+				point[2] -= ent->r.maxs[2]*0.2f;
+			}
+		}
+		break;
+
+	case SPOT_HEAD_LEAN:
+		if ( ent->client && VectorLengthSquared( ent->client->renderInfo.eyePoint ) /*&& (ent->client->ps.viewEntity <= 0 || ent->client->ps.viewEntity >= ENTITYNUM_WORLD*/ )
+		{//Actual tag_head eyespot!
+			//FIXME: Stasis aliens may have a problem here...
+			VectorCopy( ent->client->renderInfo.eyePoint, point );
+			if ( ent->client->NPC_class == CLASS_ATST )
+			{//adjust up some
+				point[2] += 28;//magic number :)
+			}
+			if ( ent->NPC )
+			{//always aim from the center of my bbox, so we don't wiggle when we lean forward or backwards
+				point[0] = ent->r.currentOrigin[0];
+				point[1] = ent->r.currentOrigin[1];
+			}
+			/*
+			else if ( ent->s.eType == ET_PLAYER )
+			{
+				SubtractLeanOfs( ent, point );
+			}
+			*/
+			//NOTE: automatically takes leaning into account!
+		}
+		else
+		{
+			VectorCopy ( ent->r.currentOrigin, point );
+			if ( ent->client ) 
+			{
+				point[2] += ent->client->ps.viewheight;
+			}
+			//AddLeanOfs ( ent, point );
+		}
+		break;
+
+	//FIXME: implement...
+	//case SPOT_CHEST:
+		//Returns point 3/4 from tag_torso to tag_head?
+		//break;
+
+	case SPOT_LEGS:
+		VectorCopy ( ent->r.currentOrigin, point );
+		point[2] += (ent->r.mins[2] * 0.5);
+		break;
+
+	case SPOT_WEAPON:
+		if( ent->NPC && !VectorCompare( ent->NPC->shootAngles, vec3_origin ) && !VectorCompare( ent->NPC->shootAngles, ent->client->ps.viewangles ))
+		{
+			AngleVectors( ent->NPC->shootAngles, forward, right, up );
+		}
+		else
+		{
+			AngleVectors( ent->client->ps.viewangles, forward, right, up );
+		}
+		CalcMuzzlePoint( (gentity_t*)ent, forward, right, up, point );
+		//NOTE: automatically takes leaning into account!
+		break;
+
+	case SPOT_GROUND:
+		// if entity is on the ground, just use it's absmin
+		if ( ent->s.groundEntityNum != -1 ) 
+		{
+			VectorCopy( ent->r.currentOrigin, point );
+			point[2] = ent->r.absmin[2];
+			break;
+		}
+
+		// if it is reasonably close to the ground, give the point underneath of it
+		VectorCopy( ent->r.currentOrigin, start );
+		start[2] = ent->r.absmin[2];
+		VectorCopy( start, end );
+		end[2] -= 64;
+		trap_Trace( &tr, start, ent->r.mins, ent->r.maxs, end, ent->s.number, MASK_PLAYERSOLID );
+		if ( tr.fraction < 1.0 ) 
+		{
+			VectorCopy( tr.endpos, point);
+			break;
+		}
+
+		// otherwise just use the origin
+		VectorCopy( ent->r.currentOrigin, point );
+		break;
+
+	default:
+		VectorCopy ( ent->r.currentOrigin, point );
+		break;
+	}
+}
+
+
+//===================================================================================
+
+/*
+qboolean NPC_UpdateAngles ( qboolean doPitch, qboolean doYaw ) 
+
+Added: option to do just pitch or just yaw
+
+Does not include "aim" in it's calculations
+
+FIXME: stop compressing angles into shorts!!!!
+*/
+qboolean NPC_UpdateAngles ( qboolean doPitch, qboolean doYaw ) 
+{
+#if 1
+
+	float		error;
+	float		decay;
+	float		targetPitch = 0;
+	float		targetYaw = 0;
+	float		yawSpeed;
+	qboolean	exact = qtrue;
+
+	// if angle changes are locked; just keep the current angles
+	// aimTime isn't even set anymore... so this code was never reached, but I need a way to lock NPC's yaw, so instead of making a new SCF_ flag, just use the existing render flag... - dmv
+	if ( !NPC->enemy && ( (level.time < NPCInfo->aimTime) /*|| NPC->client->renderInfo.renderFlags & RF_LOCKEDANGLE*/) ) 
+	{
+		if(doPitch)
+			targetPitch = NPCInfo->lockedDesiredPitch;
+
+		if(doYaw)
+			targetYaw = NPCInfo->lockedDesiredYaw;
+	}
+	else 
+	{
+		// we're changing the lockedDesired Pitch/Yaw below so it's lost it's original meaning, get rid of the lock flag
+	//	NPC->client->renderInfo.renderFlags &= ~RF_LOCKEDANGLE;
+
+		if(doPitch)
+		{
+			targetPitch = NPCInfo->desiredPitch;
+			NPCInfo->lockedDesiredPitch = NPCInfo->desiredPitch;
+		}
+
+		if(doYaw)
+		{
+			targetYaw = NPCInfo->desiredYaw;
+			NPCInfo->lockedDesiredYaw = NPCInfo->desiredYaw;
+		}			
+	}
+
+	if ( NPC->s.weapon == WP_EMPLACED_GUN )
+	{
+		// FIXME: this seems to do nothing, actually...
+		yawSpeed = 20;
+	}
+	else
+	{
+		yawSpeed = NPCInfo->stats.yawSpeed;
+	}
+
+	if ( NPC->s.weapon == WP_SABER && NPC->client->ps.fd.forcePowersActive&(1<<FP_SPEED) )
+	{
+		char buf[128];
+		float tFVal = 0;
+
+		trap_Cvar_VariableStringBuffer("timescale", buf, sizeof(buf));
+
+		tFVal = atof(buf);
+
+		yawSpeed *= 1.0f/tFVal;
+	}
+	
+	if( doYaw )
+	{
+		// decay yaw error
+		error = AngleDelta ( NPC->client->ps.viewangles[YAW], targetYaw );
+		if( fabs(error) > MIN_ANGLE_ERROR )
+		{
+			if ( error ) 
+			{
+				exact = qfalse;
+
+				decay = 60.0 + yawSpeed * 3;
+				decay *= 50.0f / 1000.0f;//msec
+
+				if ( error < 0.0 ) 
+				{
+					error += decay;
+					if ( error > 0.0 ) 
+					{
+						error = 0.0;
+					}
+				}
+				else 
+				{
+					error -= decay;
+					if ( error < 0.0 ) 
+					{
+						error = 0.0;
+					}
+				}
+			}
+		}
+		
+		ucmd.angles[YAW] = ANGLE2SHORT( targetYaw + error ) - client->ps.delta_angles[YAW];
+	}
+
+	//FIXME: have a pitchSpeed?
+	if( doPitch )
+	{
+		// decay pitch error
+		error = AngleDelta ( NPC->client->ps.viewangles[PITCH], targetPitch );
+		if ( fabs(error) > MIN_ANGLE_ERROR )
+		{
+			if ( error ) 
+			{
+				exact = qfalse;
+
+				decay = 60.0 + yawSpeed * 3;
+				decay *= 50.0f / 1000.0f;//msec
+
+				if ( error < 0.0 ) 
+				{
+					error += decay;
+					if ( error > 0.0 ) 
+					{
+						error = 0.0;
+					}
+				}
+				else 
+				{
+					error -= decay;
+					if ( error < 0.0 ) 
+					{
+						error = 0.0;
+					}
+				}
+			}
+		}
+
+		ucmd.angles[PITCH] = ANGLE2SHORT( targetPitch + error ) - client->ps.delta_angles[PITCH];
+	}
+
+	ucmd.angles[ROLL] = ANGLE2SHORT ( NPC->client->ps.viewangles[ROLL] ) - client->ps.delta_angles[ROLL];
+
+	if ( exact && trap_ICARUS_TaskIDPending( NPC, TID_ANGLE_FACE ) )
+	{
+		trap_ICARUS_TaskIDComplete( NPC, TID_ANGLE_FACE );
+	}
+	return exact;
+
+#else
+
+	float		error;
+	float		decay;
+	float		targetPitch = 0;
+	float		targetYaw = 0;
+	float		yawSpeed;
+	//float		runningMod = NPCInfo->currentSpeed/100.0f;
+	qboolean	exact = qtrue;
+	qboolean	doSound = qfalse;
+
+	// if angle changes are locked; just keep the current angles
+	if ( level.time < NPCInfo->aimTime ) 
+	{
+		if(doPitch)
+			targetPitch = NPCInfo->lockedDesiredPitch;
+		if(doYaw)
+			targetYaw = NPCInfo->lockedDesiredYaw;
+	}
+	else 
+	{
+		if(doPitch)
+			targetPitch = NPCInfo->desiredPitch;
+		if(doYaw)
+			targetYaw = NPCInfo->desiredYaw;
+
+//		NPCInfo->aimTime = level.time + 250;
+		if(doPitch)
+			NPCInfo->lockedDesiredPitch = NPCInfo->desiredPitch;
+		if(doYaw)
+			NPCInfo->lockedDesiredYaw = NPCInfo->desiredYaw;
+	}
+
+	yawSpeed = NPCInfo->stats.yawSpeed;
+
+	if(doYaw)
+	{
+		// decay yaw error
+		error = AngleDelta ( NPC->client->ps.viewangles[YAW], targetYaw );
+		if( fabs(error) > MIN_ANGLE_ERROR )
+		{
+			/*
+			if(NPC->client->playerTeam == TEAM_BORG&&
+				NPCInfo->behaviorState != BS_FACE&&NPCInfo->tempBehavior!= BS_FACE)
+			{//HACK - borg turn more jittery
+				if ( error ) 
+				{
+					exact = qfalse;
+
+					decay = 60.0 + yawSpeed * 3;
+					decay *= 50.0 / 1000.0;//msec
+					//Snap to
+					if(fabs(error) > 10)
+					{
+						if(random() > 0.6)
+						{
+							doSound = qtrue;
+						}
+					}
+
+					if ( error < 0.0)//-10.0 ) 
+					{
+						error += decay;
+						if ( error > 0.0 ) 
+						{
+							error = 0.0;
+						}
+					}
+					else if ( error > 0.0)//10.0 ) 
+					{
+						error -= decay;
+						if ( error < 0.0 ) 
+						{
+							error = 0.0;
+						}
+					}
+				}
+			}
+			else*/
+			
+			if ( error ) 
+			{
+				exact = qfalse;
+
+				decay = 60.0 + yawSpeed * 3;
+				decay *= 50.0 / 1000.0;//msec
+
+				if ( error < 0.0 ) 
+				{
+					error += decay;
+					if ( error > 0.0 ) 
+					{
+						error = 0.0;
+					}
+				}
+				else 
+				{
+					error -= decay;
+					if ( error < 0.0 ) 
+					{
+						error = 0.0;
+					}
+				}
+			}
+		}
+		ucmd.angles[YAW] = ANGLE2SHORT( targetYaw + error ) - client->ps.delta_angles[YAW];
+	}
+
+	//FIXME: have a pitchSpeed?
+	if(doPitch)
+	{
+		// decay pitch error
+		error = AngleDelta ( NPC->client->ps.viewangles[PITCH], targetPitch );
+		if ( fabs(error) > MIN_ANGLE_ERROR )
+		{
+			/*
+			if(NPC->client->playerTeam == TEAM_BORG&&
+				NPCInfo->behaviorState != BS_FACE&&NPCInfo->tempBehavior!= BS_FACE)
+			{//HACK - borg turn more jittery
+				if ( error ) 
+				{
+					exact = qfalse;
+
+					decay = 60.0 + yawSpeed * 3;
+					decay *= 50.0 / 1000.0;//msec
+					//Snap to
+					if(fabs(error) > 10)
+					{
+						if(random() > 0.6)
+						{
+							doSound = qtrue;
+						}
+					}
+
+					if ( error < 0.0)//-10.0 ) 
+					{
+						error += decay;
+						if ( error > 0.0 ) 
+						{
+							error = 0.0;
+						}
+					}
+					else if ( error > 0.0)//10.0 ) 
+					{
+						error -= decay;
+						if ( error < 0.0 ) 
+						{
+							error = 0.0;
+						}
+					}
+				}
+			}
+			else*/
+			
+			if ( error ) 
+			{
+				exact = qfalse;
+
+				decay = 60.0 + yawSpeed * 3;
+				decay *= 50.0 / 1000.0;//msec
+
+				if ( error < 0.0 ) 
+				{
+					error += decay;
+					if ( error > 0.0 ) 
+					{
+						error = 0.0;
+					}
+				}
+				else 
+				{
+					error -= decay;
+					if ( error < 0.0 ) 
+					{
+						error = 0.0;
+					}
+				}
+			}
+		}
+		ucmd.angles[PITCH] = ANGLE2SHORT( targetPitch + error ) - client->ps.delta_angles[PITCH];
+	}
+
+	ucmd.angles[ROLL] = ANGLE2SHORT ( NPC->client->ps.viewangles[ROLL] ) - client->ps.delta_angles[ROLL];
+
+	/*
+	if(doSound)
+	{
+		G_Sound(NPC, G_SoundIndex(va("sound/enemies/borg/borgservo%d.wav", Q_irand(1, 8))));
+	}
+	*/
+
+	return exact;
+
+#endif
+
+}
+
+void NPC_AimWiggle( vec3_t enemy_org )
+{
+	//shoot for somewhere between the head and torso
+	//NOTE: yes, I know this looks weird, but it works
+	if ( NPCInfo->aimErrorDebounceTime < level.time )
+	{
+		NPCInfo->aimOfs[0] = 0.3*flrand(NPC->enemy->r.mins[0], NPC->enemy->r.maxs[0]);
+		NPCInfo->aimOfs[1] = 0.3*flrand(NPC->enemy->r.mins[1], NPC->enemy->r.maxs[1]);
+		if ( NPC->enemy->r.maxs[2] > 0 )
+		{
+			NPCInfo->aimOfs[2] = NPC->enemy->r.maxs[2]*flrand(0.0f, -1.0f);
+		}
+	}
+	VectorAdd( enemy_org, NPCInfo->aimOfs, enemy_org );
+}
+
+/*
+qboolean NPC_UpdateFiringAngles ( qboolean doPitch, qboolean doYaw ) 
+
+  Includes aim when determining angles - so they don't always hit...
+  */
+qboolean NPC_UpdateFiringAngles ( qboolean doPitch, qboolean doYaw ) 
+{
+
+#if 0
+
+	float		diff;
+	float		error;
+	float		targetPitch = 0;
+	float		targetYaw = 0;
+	qboolean	exact = qtrue;
+
+	if ( level.time < NPCInfo->aimTime ) 
+	{
+		if( doPitch )
+			targetPitch = NPCInfo->lockedDesiredPitch;
+
+		if( doYaw )
+			targetYaw = NPCInfo->lockedDesiredYaw;
+	}
+	else 
+	{
+		if( doPitch )
+		{
+			targetPitch = NPCInfo->desiredPitch;
+			NPCInfo->lockedDesiredPitch = NPCInfo->desiredPitch;
+		}
+
+		if( doYaw )
+		{
+			targetYaw = NPCInfo->desiredYaw;
+			NPCInfo->lockedDesiredYaw = NPCInfo->desiredYaw;
+		}			
+	}
+
+	if( doYaw )
+	{
+		// add yaw error based on NPCInfo->aim value
+		error = ((float)(6 - NPCInfo->stats.aim)) * flrand(-1, 1);
+
+		if(Q_irand(0, 1))
+			error *= -1;
+
+		diff = AngleDelta ( NPC->client->ps.viewangles[YAW], targetYaw );
+
+		if ( diff )
+			exact = qfalse;
+		
+		ucmd.angles[YAW] = ANGLE2SHORT( targetYaw + diff + error ) - client->ps.delta_angles[YAW];
+	}
+
+	if( doPitch )
+	{
+		// add pitch error based on NPCInfo->aim value
+		error = ((float)(6 - NPCInfo->stats.aim)) * flrand(-1, 1);
+
+		diff = AngleDelta ( NPC->client->ps.viewangles[PITCH], targetPitch );
+
+		if ( diff )
+			exact = qfalse;
+		
+		ucmd.angles[PITCH] = ANGLE2SHORT( targetPitch + diff + error ) - client->ps.delta_angles[PITCH];
+	}
+
+	ucmd.angles[ROLL] = ANGLE2SHORT ( NPC->client->ps.viewangles[ROLL] ) - client->ps.delta_angles[ROLL];
+
+	return exact;
+	
+#else
+
+	float		error, diff;
+	float		decay;
+	float		targetPitch = 0;
+	float		targetYaw = 0;
+	qboolean	exact = qtrue;
+
+	// if angle changes are locked; just keep the current angles
+	if ( level.time < NPCInfo->aimTime ) 
+	{
+		if(doPitch)
+			targetPitch = NPCInfo->lockedDesiredPitch;
+		if(doYaw)
+			targetYaw = NPCInfo->lockedDesiredYaw;
+	}
+	else 
+	{
+		if(doPitch)
+			targetPitch = NPCInfo->desiredPitch;
+		if(doYaw)
+			targetYaw = NPCInfo->desiredYaw;
+
+//		NPCInfo->aimTime = level.time + 250;
+		if(doPitch)
+			NPCInfo->lockedDesiredPitch = NPCInfo->desiredPitch;
+		if(doYaw)
+			NPCInfo->lockedDesiredYaw = NPCInfo->desiredYaw;
+	}
+
+	if ( NPCInfo->aimErrorDebounceTime < level.time )
+	{
+		if ( Q_irand(0, 1 ) )
+		{
+			NPCInfo->lastAimErrorYaw = ((float)(6 - NPCInfo->stats.aim)) * flrand(-1, 1);
+		}
+		if ( Q_irand(0, 1 ) )
+		{
+			NPCInfo->lastAimErrorPitch = ((float)(6 - NPCInfo->stats.aim)) * flrand(-1, 1);
+		}
+		NPCInfo->aimErrorDebounceTime = level.time + Q_irand(250, 2000);
+	}
+
+	if(doYaw)
+	{
+		// decay yaw diff
+		diff = AngleDelta ( NPC->client->ps.viewangles[YAW], targetYaw );
+		
+		if ( diff) 
+		{
+			exact = qfalse;
+
+			decay = 60.0 + 80.0;
+			decay *= 50.0f / 1000.0f;//msec
+			if ( diff < 0.0 ) 
+			{
+				diff += decay;
+				if ( diff > 0.0 ) 
+				{
+					diff = 0.0;
+				}
+			}
+			else 
+			{
+				diff -= decay;
+				if ( diff < 0.0 ) 
+				{
+					diff = 0.0;
+				}
+			}
+		}
+				
+		// add yaw error based on NPCInfo->aim value
+		error = NPCInfo->lastAimErrorYaw;
+
+		/*
+		if(Q_irand(0, 1))
+		{
+			error *= -1;
+		}
+		*/
+
+		ucmd.angles[YAW] = ANGLE2SHORT( targetYaw + diff + error ) - client->ps.delta_angles[YAW];
+	}
+
+	if(doPitch)
+	{
+		// decay pitch diff
+		diff = AngleDelta ( NPC->client->ps.viewangles[PITCH], targetPitch );
+		if ( diff) 
+		{
+			exact = qfalse;
+
+			decay = 60.0 + 80.0;
+			decay *= 50.0f / 1000.0f;//msec
+			if ( diff < 0.0 ) 
+			{
+				diff += decay;
+				if ( diff > 0.0 ) 
+				{
+					diff = 0.0;
+				}
+			}
+			else 
+			{
+				diff -= decay;
+				if ( diff < 0.0 ) 
+				{
+					diff = 0.0;
+				}
+			}
+		}
+		
+		error = NPCInfo->lastAimErrorPitch;
+
+		ucmd.angles[PITCH] = ANGLE2SHORT( targetPitch + diff + error ) - client->ps.delta_angles[PITCH];
+	}
+
+	ucmd.angles[ROLL] = ANGLE2SHORT ( NPC->client->ps.viewangles[ROLL] ) - client->ps.delta_angles[ROLL];
+
+	return exact;
+
+#endif
+
+}
+//===================================================================================
+
+/*
+static void NPC_UpdateShootAngles (vec3_t angles, qboolean doPitch, qboolean doYaw ) 
+
+Does update angles on shootAngles
+*/
+
+void NPC_UpdateShootAngles (vec3_t angles, qboolean doPitch, qboolean doYaw ) 
+{//FIXME: shoot angles either not set right or not used!
+	float		error;
+	float		decay;
+	float		targetPitch = 0;
+	float		targetYaw = 0;
+
+	if(doPitch)
+		targetPitch = angles[PITCH];
+	if(doYaw)
+		targetYaw = angles[YAW];
+
+
+	if(doYaw)
+	{
+		// decay yaw error
+		error = AngleDelta ( NPCInfo->shootAngles[YAW], targetYaw );
+		if ( error ) 
+		{
+			decay = 60.0 + 80.0 * NPCInfo->stats.aim;
+			decay *= 100.0f / 1000.0f;//msec
+			if ( error < 0.0 ) 
+			{
+				error += decay;
+				if ( error > 0.0 ) 
+				{
+					error = 0.0;
+				}
+			}
+			else 
+			{
+				error -= decay;
+				if ( error < 0.0 ) 
+				{
+					error = 0.0;
+				}
+			}
+		}
+		NPCInfo->shootAngles[YAW] = targetYaw + error;
+	}
+
+	if(doPitch)
+	{
+		// decay pitch error
+		error = AngleDelta ( NPCInfo->shootAngles[PITCH], targetPitch );
+		if ( error ) 
+		{
+			decay = 60.0 + 80.0 * NPCInfo->stats.aim;
+			decay *= 100.0f / 1000.0f;//msec
+			if ( error < 0.0 ) 
+			{
+				error += decay;
+				if ( error > 0.0 ) 
+				{
+					error = 0.0;
+				}
+			}
+			else 
+			{
+				error -= decay;
+				if ( error < 0.0 ) 
+				{
+					error = 0.0;
+				}
+			}
+		}
+		NPCInfo->shootAngles[PITCH] = targetPitch + error;
+	}
+}
+
+/*
+void SetTeamNumbers (void)
+
+Sets the number of living clients on each team
+
+FIXME: Does not account for non-respawned players!
+FIXME: Don't include medics?
+*/
+void SetTeamNumbers (void)
+{
+	gentity_t	*found;
+	int			i;
+
+	for( i = 0; i < TEAM_NUM_TEAMS; i++ )
+	{
+		teamNumbers[i] = 0;
+		teamStrength[i] = 0;
+	}
+
+	for( i = 0; i < 1 ; i++ )
+	{
+		found = &g_entities[i];
+
+		if( found->client )
+		{
+			if( found->health > 0 )//FIXME: or if a player!
+			{
+				teamNumbers[found->client->playerTeam]++;
+				teamStrength[found->client->playerTeam] += found->health;
+			}
+		}
+	}
+
+	for( i = 0; i < TEAM_NUM_TEAMS; i++ )
+	{//Get the average health
+		teamStrength[i] = floor( ((float)(teamStrength[i])) / ((float)(teamNumbers[i])) );
+	}
+}
+
+extern stringID_table_t BSTable[];
+extern stringID_table_t BSETTable[];
+qboolean G_ActivateBehavior (gentity_t *self, int bset )
+{
+	bState_t	bSID = (bState_t)-1;
+	char *bs_name = NULL;
+
+	if ( !self )
+	{
+		return qfalse;
+	}
+
+	bs_name = self->behaviorSet[bset];
+	
+	if( !(VALIDSTRING( bs_name )) )
+	{
+		return qfalse;
+	}
+
+	if ( self->NPC )
+	{
+		bSID = (bState_t)(GetIDForString( BSTable, bs_name ));
+	}
+
+	if(bSID > -1)
+	{
+		self->NPC->tempBehavior = BS_DEFAULT;
+		self->NPC->behaviorState = bSID;
+	}
+	else
+	{
+		/*
+		char			newname[MAX_FILENAME_LENGTH];		
+		sprintf((char *) &newname, "%s/%s", Q3_SCRIPT_DIR, bs_name );
+		*/
+		
+		//FIXME: between here and actually getting into the ICARUS_RunScript function, the stack gets blown!
+		//if ( ( ICARUS_entFilter == -1 ) || ( ICARUS_entFilter == self->s.number ) )
+		if (0)
+		{
+			G_DebugPrint( WL_VERBOSE, "%s attempting to run bSet %s (%s)\n", self->targetname, GetStringForID( BSETTable, bset ), bs_name );
+		}
+		trap_ICARUS_RunScript( self, va( "%s/%s", Q3_SCRIPT_DIR, bs_name ) );
+	}
+	return qtrue;
+}
+
+
+/*
+=============================================================================
+
+	Extended Functions
+
+=============================================================================
+*/
+
+//rww - special system for sync'ing bone angles between client and server.
+void NPC_SetBoneAngles(gentity_t *ent, char *bone, vec3_t angles)
+{
+#ifdef _XBOX
+	byte *thebone = &ent->s.boneIndex1;
+	byte *firstFree = NULL;
+#else
+	int *thebone = &ent->s.boneIndex1;
+	int *firstFree = NULL;
+#endif
+	int i = 0;
+	int boneIndex = G_BoneIndex(bone);
+	int flags, up, right, forward;
+	vec3_t *boneVector = &ent->s.boneAngles1;
+	vec3_t *freeBoneVec = NULL;
+
+	while (thebone)
+	{
+		if (!*thebone && !firstFree)
+		{ //if the value is 0 then this index is clear, we can use it if we don't find the bone we want already existing.
+			firstFree = thebone;
+			freeBoneVec = boneVector;
+		}
+		else if (*thebone)
+		{
+			if (*thebone == boneIndex)
+			{ //this is it
+				break;
+			}
+		}
+
+		switch (i)
+		{
+		case 0:
+			thebone = &ent->s.boneIndex2;
+			boneVector = &ent->s.boneAngles2;
+			break;
+		case 1:
+			thebone = &ent->s.boneIndex3;
+			boneVector = &ent->s.boneAngles3;
+			break;
+		case 2:
+			thebone = &ent->s.boneIndex4;
+			boneVector = &ent->s.boneAngles4;
+			break;
+		default:
+			thebone = NULL;
+			boneVector = NULL;
+			break;
+		}
+
+		i++;
+	}
+
+	if (!thebone)
+	{ //didn't find it, create it
+		if (!firstFree)
+		{ //no free bones.. can't do a thing then.
+			Com_Printf("WARNING: NPC has no free bone indexes\n");
+			return;
+		}
+
+		thebone = firstFree;
+
+		*thebone = boneIndex;
+		boneVector = freeBoneVec;
+	}
+
+	//If we got here then we have a vector and an index.
+
+	//Copy the angles over the vector in the entitystate, so we can use the corresponding index
+	//to set the bone angles on the client.
+	VectorCopy(angles, *boneVector);
+
+	//Now set the angles on our server instance if we have one.
+
+	if (!ent->ghoul2)
+	{
+		return;
+	}
+
+	flags = BONE_ANGLES_POSTMULT;
+	up = POSITIVE_X;
+	right = NEGATIVE_Y;
+	forward = NEGATIVE_Z;
+
+	//first 3 bits is forward, second 3 bits is right, third 3 bits is up
+	ent->s.boneOrient = ((forward)|(right<<3)|(up<<6));
+
+	trap_G2API_SetBoneAngles(ent->ghoul2, 0, bone, angles, flags, up, right, forward, NULL, 100, level.time);
+}
+
+//rww - and another method of automatically managing surface status for the client and server at once
+#define TURN_ON				0x00000000
+#define TURN_OFF			0x00000100
+
+void NPC_SetSurfaceOnOff(gentity_t *ent, const char *surfaceName, int surfaceFlags)
+{
+	int i = 0;
+	qboolean foundIt = qfalse;
+
+	while (i < BG_NUM_TOGGLEABLE_SURFACES && bgToggleableSurfaces[i])
+	{
+		if (!Q_stricmp(surfaceName, bgToggleableSurfaces[i]))
+		{ //got it
+			foundIt = qtrue;
+			break;
+		}
+		i++;
+	}
+
+	if (!foundIt)
+	{
+		Com_Printf("WARNING: Tried to toggle NPC surface that isn't in toggleable surface list (%s)\n", surfaceName);
+		return;
+	}
+
+	if (surfaceFlags == TURN_ON)
+	{ //Make sure the entitystate values reflect this surface as on now.
+		ent->s.surfacesOn |= (1 << i);
+		ent->s.surfacesOff &= ~(1 << i);
+	}
+	else
+	{ //Otherwise make sure they're off.
+		ent->s.surfacesOn &= ~(1 << i);
+		ent->s.surfacesOff |= (1 << i);
+	}
+
+	if (!ent->ghoul2)
+	{
+		return;
+	}
+
+	trap_G2API_SetSurfaceOnOff(ent->ghoul2, surfaceName, surfaceFlags);
+}
+
+//rww - cheap check to see if an armed client is looking in our general direction
+qboolean NPC_SomeoneLookingAtMe(gentity_t *ent)
+{
+	int i = 0;
+	gentity_t *pEnt;
+
+	while (i < MAX_CLIENTS)
+	{
+		pEnt = &g_entities[i];
+
+		if (pEnt && pEnt->inuse && pEnt->client && pEnt->client->sess.sessionTeam != TEAM_SPECTATOR &&
+			!(pEnt->client->ps.pm_flags & PMF_FOLLOW) && pEnt->s.weapon != WP_NONE)
+		{
+			if (trap_InPVS(ent->r.currentOrigin, pEnt->r.currentOrigin))
+			{
+				if (InFOV( ent, pEnt, 30, 30 ))
+				{ //I'm in a 30 fov or so cone from this player.. that's enough I guess.
+					return qtrue;
+				}
+			}
+		}
+
+		i++;
+	}
+
+	return qfalse;
+}
+
+qboolean NPC_ClearLOS( const vec3_t start, const vec3_t end )
+{
+	return G_ClearLOS( NPC, start, end );
+}
+qboolean NPC_ClearLOS5( const vec3_t end )
+{
+	return G_ClearLOS5( NPC, end );
+}
+qboolean NPC_ClearLOS4( gentity_t *ent ) 
+{
+	return G_ClearLOS4( NPC, ent );
+}
+qboolean NPC_ClearLOS3( const vec3_t start, gentity_t *ent )
+{
+	return G_ClearLOS3( NPC, start, ent );
+}
+qboolean NPC_ClearLOS2( gentity_t *ent, const vec3_t end )
+{
+	return G_ClearLOS2( NPC, ent, end );
+}
+
+/*
+-------------------------
+NPC_ValidEnemy
+-------------------------
+*/
+
+qboolean NPC_ValidEnemy( gentity_t *ent )
+{
+	int entTeam = TEAM_FREE;
+	//Must be a valid pointer
+	if ( ent == NULL )
+		return qfalse;
+
+	//Must not be me
+	if ( ent == NPC )
+		return qfalse;
+
+	//Must not be deleted
+	if ( ent->inuse == qfalse )
+		return qfalse;
+
+	//Must be alive
+	if ( ent->health <= 0 )
+		return qfalse;
+
+	//In case they're in notarget mode
+	if ( ent->flags & FL_NOTARGET )
+		return qfalse;
+
+	//Must be an NPC
+	if ( ent->client == NULL )
+	{
+	//	if ( ent->svFlags&SVF_NONNPC_ENEMY )
+		if (ent->s.eType != ET_NPC)
+		{//still potentially valid
+			if ( ent->alliedTeam == NPC->client->playerTeam )
+			{
+				return qfalse;
+			}
+			else
+			{
+				return qtrue;
+			}
+		}
+		else
+		{
+			return qfalse;
+		}
+	}
+	else if ( ent->client && ent->client->sess.sessionTeam == TEAM_SPECTATOR )
+	{//don't go after spectators
+		return qfalse;
+	}
+	if ( ent->NPC && ent->client )
+	{
+		entTeam = ent->client->playerTeam;
+	}
+	else if ( ent->client )
+	{
+		if (g_gametype.integer < GT_TEAM)
+		{
+			entTeam = NPCTEAM_PLAYER;
+		}
+		else
+		{
+			if ( ent->client->sess.sessionTeam == TEAM_BLUE )
+			{
+				entTeam = NPCTEAM_PLAYER;
+			}
+			else if ( ent->client->sess.sessionTeam == TEAM_RED )
+			{
+				entTeam = NPCTEAM_ENEMY;
+			}
+			else
+			{
+				entTeam = NPCTEAM_NEUTRAL;
+			}
+		}
+	}
+	//Can't be on the same team
+	if ( ent->client->playerTeam == NPC->client->playerTeam )
+		return qfalse;
+
+	//if haven't seen him in a while, give up
+	//if ( NPCInfo->enemyLastSeenTime != 0 && level.time - NPCInfo->enemyLastSeenTime > 7000 )//FIXME: make a stat?
+	//	return qfalse;
+	if ( entTeam == NPC->client->enemyTeam //simplest case: they're on my enemy team
+		|| (NPC->client->enemyTeam == NPCTEAM_FREE && ent->client->NPC_class != NPC->client->NPC_class )//I get mad at anyone and this guy isn't the same class as me
+		|| (ent->client->NPC_class == CLASS_WAMPA && ent->enemy )//a rampaging wampa
+		|| (ent->client->NPC_class == CLASS_RANCOR && ent->enemy )//a rampaging rancor
+		|| (entTeam == NPCTEAM_FREE && ent->client->enemyTeam == NPCTEAM_FREE && ent->enemy && ent->enemy->client && (ent->enemy->client->playerTeam == NPC->client->playerTeam||(ent->enemy->client->playerTeam != NPCTEAM_ENEMY&&NPC->client->playerTeam==NPCTEAM_PLAYER))) //enemy is a rampaging non-aligned creature who is attacking someone on our team or a non-enemy (this last condition is used only if we're a good guy - in effect, we protect the innocent)
+		)
+	{
+		return qtrue;
+	}
+
+	return qfalse;
+}
+
+/*
+-------------------------
+NPC_TargetVisible
+-------------------------
+*/
+
+qboolean NPC_TargetVisible( gentity_t *ent )
+{
+	//Make sure we're in a valid range
+	if ( DistanceSquared( ent->r.currentOrigin, NPC->r.currentOrigin ) > ( NPCInfo->stats.visrange * NPCInfo->stats.visrange ) )
+		return qfalse;
+
+	//Check our FOV
+	if ( InFOV( ent, NPC, NPCInfo->stats.hfov, NPCInfo->stats.vfov ) == qfalse )
+		return qfalse;
+
+	//Check for sight
+	if ( NPC_ClearLOS4( ent ) == qfalse )
+		return qfalse;
+
+	return qtrue;
+}
+
+/*
+-------------------------
+NPC_GetCheckDelta
+-------------------------
+*/
+
+/*
+#define	CHECK_TIME_BASE				250
+#define CHECK_TIME_BASE_SQUARED		( CHECK_TIME_BASE * CHECK_TIME_BASE )
+
+static int NPC_GetCheckDelta( void )
+{
+	if ( NPC_ValidEnemy( NPC->enemy ) == qfalse )
+	{
+		int distance = DistanceSquared( NPC->r.currentOrigin, g_entities[0].currentOrigin );
+
+		distance /= CHECK_TIME_BASE_SQUARED;
+
+		return ( CHECK_TIME_BASE * distance );
+	}
+
+	return 0;
+}
+*/
+
+/*
+-------------------------
+NPC_FindNearestEnemy
+-------------------------
+*/
+
+#define	MAX_RADIUS_ENTS			256	//NOTE: This can cause entities to be lost
+#define NEAR_DEFAULT_RADIUS		256
+
+int NPC_FindNearestEnemy( gentity_t *ent )
+{
+	int			iradiusEnts[ MAX_RADIUS_ENTS ];
+	gentity_t	*radEnt;
+	vec3_t		mins, maxs;
+	int			nearestEntID = -1;
+	float		nearestDist = (float)WORLD_SIZE*(float)WORLD_SIZE;
+	float		distance;
+	int			numEnts, numChecks = 0;
+	int			i;
+
+	//Setup the bbox to search in
+	for ( i = 0; i < 3; i++ )
+	{
+		mins[i] = ent->r.currentOrigin[i] - NPCInfo->stats.visrange;
+		maxs[i] = ent->r.currentOrigin[i] + NPCInfo->stats.visrange;
+	}
+
+	//Get a number of entities in a given space
+	numEnts = trap_EntitiesInBox( mins, maxs, iradiusEnts, MAX_RADIUS_ENTS );
+
+	for ( i = 0; i < numEnts; i++ )
+	{
+		radEnt = &g_entities[iradiusEnts[i]];
+		//Don't consider self
+		if ( radEnt == ent )
+			continue;
+
+		//Must be valid
+		if ( NPC_ValidEnemy( radEnt ) == qfalse )
+			continue;
+
+		numChecks++;
+		//Must be visible
+		if ( NPC_TargetVisible( radEnt ) == qfalse )
+			continue;
+
+		distance = DistanceSquared( ent->r.currentOrigin, radEnt->r.currentOrigin );
+
+		//Found one closer to us
+		if ( distance < nearestDist )
+		{
+			nearestEntID = radEnt->s.number;
+			nearestDist = distance;
+		}
+	}
+
+	return nearestEntID;
+}
+
+/*
+-------------------------
+NPC_PickEnemyExt
+-------------------------
+*/
+
+gentity_t *NPC_PickEnemyExt( qboolean checkAlerts )
+{
+	//Check for Hazard Team status and remove this check
+	/*
+	if ( NPC->client->playerTeam != TEAM_STARFLEET )
+	{
+		//If we've found the player, return it
+		if ( NPC_FindPlayer() )
+			return &g_entities[0];
+	}
+	*/
+
+	//If we've asked for the closest enemy
+	int entID = NPC_FindNearestEnemy( NPC );
+
+	//If we have a valid enemy, use it
+	if ( entID >= 0 )
+		return &g_entities[entID];
+
+	if ( checkAlerts )
+	{
+		int alertEvent = NPC_CheckAlertEvents( qtrue, qtrue, -1, qtrue, AEL_DISCOVERED );
+
+		//There is an event to look at
+		if ( alertEvent >= 0 )
+		{
+			alertEvent_t *event = &level.alertEvents[alertEvent];
+
+			//Don't pay attention to our own alerts
+			if ( event->owner == NPC )
+				return NULL;
+
+			if ( event->level >= AEL_DISCOVERED )
+			{
+				//If it's the player, attack him
+				if ( event->owner == &g_entities[0] )
+					return event->owner;
+
+				//If it's on our team, then take its enemy as well
+				if ( ( event->owner->client ) && ( event->owner->client->playerTeam == NPC->client->playerTeam ) )
+					return event->owner->enemy;
+			}
+		}
+	}
+
+	return NULL;
+}
+
+/*
+-------------------------
+NPC_FindPlayer
+-------------------------
+*/
+
+qboolean NPC_FindPlayer( void )
+{
+	return NPC_TargetVisible( &g_entities[0] );
+}
+
+/*
+-------------------------
+NPC_CheckPlayerDistance
+-------------------------
+*/
+
+static qboolean NPC_CheckPlayerDistance( void )
+{
+	return qfalse;//MOOT in MP
+	/*
+	float distance;
+
+	//Make sure we have an enemy
+	if ( NPC->enemy == NULL )
+		return qfalse;
+
+	//Only do this for non-players
+	if ( NPC->enemy->s.number == 0 )
+		return qfalse;
+
+	//must be set up to get mad at player
+	if ( !NPC->client || NPC->client->enemyTeam != NPCTEAM_PLAYER )
+		return qfalse;
+
+	//Must be within our FOV
+	if ( InFOV( &g_entities[0], NPC, NPCInfo->stats.hfov, NPCInfo->stats.vfov ) == qfalse )
+		return qfalse;
+
+	distance = DistanceSquared( NPC->r.currentOrigin, NPC->enemy->r.currentOrigin );
+
+	if ( distance > DistanceSquared( NPC->r.currentOrigin, g_entities[0].r.currentOrigin ) )
+	{ //rwwFIXMEFIXME: care about all clients not just client 0
+		G_SetEnemy( NPC, &g_entities[0] );
+		return qtrue;
+	}
+
+	return qfalse;
+	*/
+}
+
+/*
+-------------------------
+NPC_FindEnemy
+-------------------------
+*/
+
+qboolean NPC_FindEnemy( qboolean checkAlerts )
+{
+	gentity_t *newenemy;
+
+	//We're ignoring all enemies for now
+	//if( NPC->svFlags & SVF_IGNORE_ENEMIES )
+	if (0) //rwwFIXMEFIXME: support for flag
+	{
+		G_ClearEnemy( NPC );
+		return qfalse;
+	}
+
+	//we can't pick up any enemies for now
+	if( NPCInfo->confusionTime > level.time )
+	{
+		return qfalse;
+	}
+
+	//Don't want a new enemy
+	//rwwFIXMEFIXME: support for locked enemy
+	//if ( ( ValidEnemy( NPC->enemy ) ) && ( NPC->svFlags & SVF_LOCKEDENEMY ) )
+	//	return qtrue;
+
+	//See if the player is closer than our current enemy
+	if ( NPC_CheckPlayerDistance() )
+	{
+		return qtrue;
+	}
+
+	//Otherwise, turn off the flag
+//	NPC->svFlags &= ~SVF_LOCKEDENEMY;
+	//See if the player is closer than our current enemy
+	if ( NPC->client->NPC_class != CLASS_RANCOR 
+		&& NPC->client->NPC_class != CLASS_WAMPA
+		//&& NPC->client->NPC_class != CLASS_SAND_CREATURE
+		&& NPC_CheckPlayerDistance() )
+	{//rancors, wampas & sand creatures don't care if player is closer, they always go with closest
+		return qtrue;
+	}
+
+	//If we've gotten here alright, then our target it still valid
+	if ( NPC_ValidEnemy( NPC->enemy ) )
+		return qtrue;
+
+	newenemy = NPC_PickEnemyExt( checkAlerts );
+
+	//if we found one, take it as the enemy
+	if( NPC_ValidEnemy( newenemy ) )
+	{
+		G_SetEnemy( NPC, newenemy );
+		return qtrue;
+	}
+
+	return qfalse;
+}
+
+/*
+-------------------------
+NPC_CheckEnemyExt
+-------------------------
+*/
+
+qboolean NPC_CheckEnemyExt( qboolean checkAlerts )
+{
+	//Make sure we're ready to think again
+/*
+	if ( NPCInfo->enemyCheckDebounceTime > level.time )
+		return qfalse;
+
+	//Get our next think time
+	NPCInfo->enemyCheckDebounceTime = level.time + NPC_GetCheckDelta();
+
+	//Attempt to find an enemy
+	return NPC_FindEnemy();
+*/
+	return NPC_FindEnemy( checkAlerts );
+}
+
+/*
+-------------------------
+NPC_FacePosition
+-------------------------
+*/
+
+qboolean NPC_FacePosition( vec3_t position, qboolean doPitch )
+{
+	vec3_t		muzzle;
+	vec3_t		angles;
+	float		yawDelta;
+	qboolean	facing = qtrue;
+
+	//Get the positions
+	if ( NPC->client && (NPC->client->NPC_class == CLASS_RANCOR || NPC->client->NPC_class == CLASS_WAMPA) )// || NPC->client->NPC_class == CLASS_SAND_CREATURE) )
+	{
+		CalcEntitySpot( NPC, SPOT_ORIGIN, muzzle );
+		muzzle[2] += NPC->r.maxs[2] * 0.75f;
+	}
+	else if ( NPC->client && NPC->client->NPC_class == CLASS_GALAKMECH )
+	{
+		CalcEntitySpot( NPC, SPOT_WEAPON, muzzle );
+	}
+	else
+	{
+		CalcEntitySpot( NPC, SPOT_HEAD_LEAN, muzzle );//SPOT_HEAD
+	}
+
+	//Find the desired angles
+	GetAnglesForDirection( muzzle, position, angles );
+
+	NPCInfo->desiredYaw		= AngleNormalize360( angles[YAW] );
+	NPCInfo->desiredPitch	= AngleNormalize360( angles[PITCH] );
+
+	if ( NPC->enemy && NPC->enemy->client && NPC->enemy->client->NPC_class == CLASS_ATST )
+	{
+		// FIXME: this is kind of dumb, but it was the easiest way to get it to look sort of ok
+		NPCInfo->desiredYaw	+= flrand( -5, 5 ) + sin( level.time * 0.004f ) * 7;
+		NPCInfo->desiredPitch += flrand( -2, 2 );
+	}
+	//Face that yaw
+	NPC_UpdateAngles( qtrue, qtrue );
+
+	//Find the delta between our goal and our current facing
+	yawDelta = AngleNormalize360( NPCInfo->desiredYaw - ( SHORT2ANGLE( ucmd.angles[YAW] + client->ps.delta_angles[YAW] ) ) );
+	
+	//See if we are facing properly
+	if ( fabs( yawDelta ) > VALID_ATTACK_CONE )
+		facing = qfalse;
+
+	if ( doPitch )
+	{
+		//Find the delta between our goal and our current facing
+		float currentAngles = ( SHORT2ANGLE( ucmd.angles[PITCH] + client->ps.delta_angles[PITCH] ) );
+		float pitchDelta = NPCInfo->desiredPitch - currentAngles;
+		
+		//See if we are facing properly
+		if ( fabs( pitchDelta ) > VALID_ATTACK_CONE )
+			facing = qfalse;
+	}
+
+	return facing;
+}
+
+/*
+-------------------------
+NPC_FaceEntity
+-------------------------
+*/
+
+qboolean NPC_FaceEntity( gentity_t *ent, qboolean doPitch )
+{
+	vec3_t		entPos;
+
+	//Get the positions
+	CalcEntitySpot( ent, SPOT_HEAD_LEAN, entPos );
+
+	return NPC_FacePosition( entPos, doPitch );
+}
+
+/*
+-------------------------
+NPC_FaceEnemy
+-------------------------
+*/
+
+qboolean NPC_FaceEnemy( qboolean doPitch )
+{
+	if ( NPC == NULL )
+		return qfalse;
+
+	if ( NPC->enemy == NULL )
+		return qfalse;
+
+	return NPC_FaceEntity( NPC->enemy, doPitch );
+}
+
+/*
+-------------------------
+NPC_CheckCanAttackExt
+-------------------------
+*/
+
+qboolean NPC_CheckCanAttackExt( void )
+{
+	//We don't want them to shoot
+	if( NPCInfo->scriptFlags & SCF_DONT_FIRE )
+		return qfalse;
+
+	//Turn to face
+	if ( NPC_FaceEnemy( qtrue ) == qfalse )
+		return qfalse;
+
+	//Must have a clear line of sight to the target
+	if ( NPC_ClearShot( NPC->enemy ) == qfalse )
+		return qfalse;
+
+	return qtrue;
+}
+
+/*
+-------------------------
+NPC_ClearLookTarget
+-------------------------
+*/
+
+void NPC_ClearLookTarget( gentity_t *self )
+{
+	if ( !self->client )
+	{
+		return;
+	}
+
+	if ( (self->client->ps.eFlags2&EF2_HELD_BY_MONSTER) )
+	{//lookTarget is set by and to the monster that's holding you, no other operations can change that
+		return;
+	}
+
+	self->client->renderInfo.lookTarget = ENTITYNUM_NONE;//ENTITYNUM_WORLD;
+	self->client->renderInfo.lookTargetClearTime = 0;
+}
+
+/*
+-------------------------
+NPC_SetLookTarget
+-------------------------
+*/
+void NPC_SetLookTarget( gentity_t *self, int entNum, int clearTime )
+{
+	if ( !self->client )
+	{
+		return;
+	}
+
+	if ( (self->client->ps.eFlags2&EF2_HELD_BY_MONSTER) )
+	{//lookTarget is set by and to the monster that's holding you, no other operations can change that
+		return;
+	}
+
+	self->client->renderInfo.lookTarget = entNum;
+	self->client->renderInfo.lookTargetClearTime = clearTime;
+}
+
+/*
+-------------------------
+NPC_CheckLookTarget
+-------------------------
+*/
+qboolean NPC_CheckLookTarget( gentity_t *self )
+{
+	if ( self->client )
+	{
+		if ( self->client->renderInfo.lookTarget >= 0 && self->client->renderInfo.lookTarget < ENTITYNUM_WORLD )
+		{//within valid range
+			if ( (&g_entities[self->client->renderInfo.lookTarget] == NULL) || !g_entities[self->client->renderInfo.lookTarget].inuse )
+			{//lookTarget not inuse or not valid anymore
+				NPC_ClearLookTarget( self );
+			}
+			else if ( self->client->renderInfo.lookTargetClearTime && self->client->renderInfo.lookTargetClearTime < level.time )
+			{//Time to clear lookTarget
+				NPC_ClearLookTarget( self );
+			}
+			else if ( g_entities[self->client->renderInfo.lookTarget].client && self->enemy && (&g_entities[self->client->renderInfo.lookTarget] != self->enemy) )
+			{//should always look at current enemy if engaged in battle... FIXME: this could override certain scripted lookTargets...???
+				NPC_ClearLookTarget( self );
+			}
+			else
+			{
+				return qtrue;
+			}
+		}
+	}
+
+	return qfalse;
+}
+
+/*
+-------------------------
+NPC_CheckCharmed
+-------------------------
+*/
+extern void G_AddVoiceEvent( gentity_t *self, int event, int speakDebounceTime );
+void NPC_CheckCharmed( void )
+{
+	if ( NPCInfo->charmedTime && NPCInfo->charmedTime < level.time && NPC->client )
+	{//we were charmed, set us back!
+		NPC->client->playerTeam = NPC->genericValue1;
+		NPC->client->enemyTeam = NPC->genericValue2;
+		NPC->s.teamowner = NPC->genericValue3;
+
+		NPC->client->leader = NULL;
+		if ( NPCInfo->tempBehavior == BS_FOLLOW_LEADER )
+		{
+			NPCInfo->tempBehavior = BS_DEFAULT;
+		}
+		G_ClearEnemy( NPC );
+		NPCInfo->charmedTime = 0;
+		//say something to let player know you've snapped out of it
+		G_AddVoiceEvent( NPC, Q_irand(EV_CONFUSE1, EV_CONFUSE3), 2000 );
+	}
+}
+
+void G_GetBoltPosition( gentity_t *self, int boltIndex, vec3_t pos, int modelIndex )
+{
+	mdxaBone_t	boltMatrix;
+	vec3_t		result, angles;
+	
+	if (!self || !self->inuse)
+	{
+		return;
+	}
+
+	if (self->client)
+	{ //clients don't actually even keep r.currentAngles maintained
+		VectorSet(angles, 0, self->client->ps.viewangles[YAW], 0);
+	}
+	else
+	{
+		VectorSet(angles, 0, self->r.currentAngles[YAW], 0);
+	}
+
+	if ( /*!self || ...haha (sorry, i'm tired)*/ !self->ghoul2 )
+	{
+		return;
+	}
+
+	trap_G2API_GetBoltMatrix( self->ghoul2, modelIndex, 
+				boltIndex,
+				&boltMatrix, angles, self->r.currentOrigin, level.time,
+				NULL, self->modelScale );
+	if ( pos )
+	{
+		BG_GiveMeVectorFromMatrix( &boltMatrix, ORIGIN, result );
+		VectorCopy( result, pos );
+	}
+}
+
+float NPC_EntRangeFromBolt( gentity_t *targEnt, int boltIndex )
+{
+	vec3_t	org;
+
+	if ( !targEnt )
+	{
+		return Q3_INFINITE;
+	}
+
+	G_GetBoltPosition( NPC, boltIndex, org, 0 );
+
+	return (Distance( targEnt->r.currentOrigin, org ));
+}
+
+float NPC_EnemyRangeFromBolt( int boltIndex )
+{
+	return (NPC_EntRangeFromBolt( NPC->enemy, boltIndex ));
+}
+
+int NPC_GetEntsNearBolt( int *radiusEnts, float radius, int boltIndex, vec3_t boltOrg )
+{
+	vec3_t		mins, maxs;
+	int			i;
+
+	//get my handRBolt's position
+	vec3_t	org;
+
+	G_GetBoltPosition( NPC, boltIndex, org, 0 );
+
+	VectorCopy( org, boltOrg );
+
+	//Setup the bbox to search in
+	for ( i = 0; i < 3; i++ )
+	{
+		mins[i] = boltOrg[i] - radius;
+		maxs[i] = boltOrg[i] + radius;
+	}
+
+	//Get the number of entities in a given space
+	return (trap_EntitiesInBox( mins, maxs, radiusEnts, 128 ));
+}
diff --git a/codemp/game/SpeederNPC.c b/codemp/game/SpeederNPC.c
new file mode 100644
index 0000000..05cde9e
--- /dev/null
+++ b/codemp/game/SpeederNPC.c
@@ -0,0 +1,1134 @@
+// leave this line at the top for all g_xxxx.cpp files...
+#include "g_headers.h"
+
+//seems to be a compiler bug, it doesn't clean out the #ifdefs between dif-compiles
+//or something, so the headers spew errors on these defs from the previous compile.
+//this fixes that. -rww
+#ifdef _JK2MP
+//get rid of all the crazy defs we added for this file
+#undef currentAngles
+#undef currentOrigin
+#undef mins
+#undef maxs
+#undef legsAnimTimer
+#undef torsoAnimTimer
+#undef bool
+#undef false
+#undef true
+
+#undef sqrtf
+#undef Q_flrand
+
+#undef MOD_EXPLOSIVE
+#endif
+
+#ifdef _JK2 //SP does not have this preprocessor for game like MP does
+#ifndef _JK2MP
+#define _JK2MP
+#endif
+#endif
+
+#ifndef _JK2MP //if single player
+#ifndef QAGAME //I don't think we have a QAGAME define
+#define QAGAME //but define it cause in sp we're always in the game
+#endif
+#endif
+
+#ifdef QAGAME //including game headers on cgame is FORBIDDEN ^_^
+#include "g_local.h"
+#elif defined _JK2MP
+#include "bg_public.h"
+#endif
+
+#ifndef _JK2MP
+#include "g_functions.h"
+#include "g_vehicles.h"
+#include "..\game\wp_saber.h"
+#else
+#include "bg_vehicles.h"
+#endif
+
+#ifdef _JK2MP
+//this is really horrible, but it works! just be sure not to use any locals or anything
+//with these names (exluding bool, false, true). -rww
+#define currentAngles r.currentAngles
+#define currentOrigin r.currentOrigin
+#define mins r.mins
+#define maxs r.maxs
+#define legsAnimTimer legsTimer
+#define torsoAnimTimer torsoTimer
+#define bool qboolean
+#define false qfalse
+#define true qtrue
+
+#define sqrtf sqrt
+#define Q_flrand flrand
+
+#define MOD_EXPLOSIVE MOD_SUICIDE
+#else
+#define bgEntity_t gentity_t
+extern void NPC_SetAnim(gentity_t	*ent,int setAnimParts,int anim,int setAnimFlags, int iBlend);
+#endif
+
+extern float DotToSpot( vec3_t spot, vec3_t from, vec3_t fromAngles );
+#ifdef QAGAME //SP or gameside MP
+extern vmCvar_t	cg_thirdPersonAlpha;
+extern vec3_t playerMins;
+extern vec3_t playerMaxs;
+extern cvar_t	*g_speederControlScheme;
+extern void ChangeWeapon( gentity_t *ent, int newWeapon );
+extern void PM_SetAnim(pmove_t	*pm,int setAnimParts,int anim,int setAnimFlags, int blendTime);
+extern int PM_AnimLength( int index, animNumber_t anim );
+#endif
+
+#ifdef _JK2MP
+
+#include "../namespace_begin.h"
+
+extern void BG_SetAnim(playerState_t *ps, animation_t *animations, int setAnimParts,int anim,int setAnimFlags, int blendTime);
+extern int BG_GetTime(void);
+extern qboolean BG_SabersOff( playerState_t *ps );
+#endif
+
+//Alright, actually, most of this file is shared between game and cgame for MP.
+//I would like to keep it this way, so when modifying for SP please keep in
+//mind the bgEntity restrictions imposed. -rww
+
+#define	STRAFERAM_DURATION	8
+#define	STRAFERAM_ANGLE		8
+
+
+#ifndef _JK2MP
+bool	VEH_StartStrafeRam(Vehicle_t *pVeh, bool Right)
+{
+	if (!(pVeh->m_ulFlags&VEH_STRAFERAM))
+	{
+		float	speed = VectorLength(pVeh->m_pParentEntity->client->ps.velocity);
+		if (speed>400.0f)
+		{
+			// Compute Pos3
+			//--------------
+			vec3_t	right;
+			AngleVectors(pVeh->m_vOrientation, 0, right, 0);
+ 			VectorMA(pVeh->m_pParentEntity->client->ps.velocity, (Right)?( speed):(-speed), right, pVeh->m_pParentEntity->pos3);
+
+			pVeh->m_ulFlags				|= VEH_STRAFERAM;
+			parentPS->hackingTime		 = (Right)?(STRAFERAM_DURATION):(-STRAFERAM_DURATION);
+
+			if (pVeh->m_iSoundDebounceTimer<level.time && Q_irand(0,1)==0)
+			{
+				int	shiftSound = Q_irand(1,4);
+				switch (shiftSound)
+				{
+				case 1: shiftSound=pVeh->m_pVehicleInfo->soundShift1; break;
+				case 2: shiftSound=pVeh->m_pVehicleInfo->soundShift2; break;
+				case 3: shiftSound=pVeh->m_pVehicleInfo->soundShift3; break;
+				case 4: shiftSound=pVeh->m_pVehicleInfo->soundShift4; break;
+				}
+				if (shiftSound)
+				{
+					pVeh->m_iSoundDebounceTimer = level.time + Q_irand(1000, 4000);
+					G_SoundIndexOnEnt( pVeh->m_pParentEntity, CHAN_AUTO, shiftSound);
+				}
+			}
+			return true;
+		}
+	}
+	return false;
+}
+#else
+bool	VEH_StartStrafeRam(Vehicle_t *pVeh, bool Right, int Duration)
+{
+	return false;
+}
+#endif
+
+
+#ifdef QAGAME //game-only.. for now
+// Like a think or move command, this updates various vehicle properties.
+bool Update( Vehicle_t *pVeh, const usercmd_t *pUcmd )
+{
+	if ( !g_vehicleInfo[VEHICLE_BASE].Update( pVeh, pUcmd ) )
+	{
+		return false;
+	}
+
+	// See whether this vehicle should be exploding.
+	if ( pVeh->m_iDieTime != 0 )
+	{
+		pVeh->m_pVehicleInfo->DeathUpdate( pVeh );
+	}
+
+	// Update move direction.
+#ifndef _JK2MP //this makes prediction unhappy, and rightfully so.
+	gentity_t *parent = (gentity_t *)pVeh->m_pParentEntity;
+
+	if ( pVeh->m_ulFlags & VEH_FLYING )
+	{
+		vec3_t vVehAngles;
+		VectorSet(vVehAngles, 0, pVeh->m_vOrientation[YAW], 0 );
+		AngleVectors( vVehAngles, parent->client->ps.moveDir, NULL, NULL );
+	}
+	else
+	{
+		vec3_t vVehAngles;
+		VectorSet(vVehAngles, pVeh->m_vOrientation[PITCH], pVeh->m_vOrientation[YAW], 0 );
+		AngleVectors( vVehAngles, parent->client->ps.moveDir, NULL, NULL );
+	}
+
+	// Check For A Strafe Ram
+	//------------------------
+	if (!(pVeh->m_ulFlags&VEH_STRAFERAM) && !(pVeh->m_ulFlags&VEH_FLYING))
+	{
+		// Started A Strafe
+		//------------------
+		if (pVeh->m_ucmd.rightmove && !parentPS->hackingTime)
+		{
+			parentPS->hackingTime = (pVeh->m_ucmd.rightmove>0)?(level.time):(-1*level.time);
+		}
+
+		// Ended A Strafe
+		//----------------
+		else if (!pVeh->m_ucmd.rightmove && parentPS->hackingTime)
+		{
+			// If It Was A Short Burst, Start The Strafe Ram
+			//-----------------------------------------------
+			if ((level.time - abs(parentPS->hackingTime))<300)
+			{
+				if (!VEH_StartStrafeRam(pVeh, (parentPS->hackingTime>0)))
+				{
+					parentPS->hackingTime = 0;
+				}
+			}
+
+			// Otherwise, Clear The Timer
+			//----------------------------
+			else
+			{
+				parentPS->hackingTime = 0;
+			}
+		}
+	}
+
+	// If Currently In A StrafeRam, Check To See If It Is Done (Timed Out)
+	//---------------------------------------------------------------------
+  	else if (!parentPS->hackingTime)
+	{
+		pVeh->m_ulFlags &=~VEH_STRAFERAM;
+	}
+
+
+	// Exhaust Effects Start And Stop When The Accelerator Is Pressed
+	//----------------------------------------------------------------
+	if (pVeh->m_pVehicleInfo->iExhaustFX)
+	{
+		// Start It On Each Exhaust Bolt
+		//-------------------------------
+		if (pVeh->m_ucmd.forwardmove && !(pVeh->m_ulFlags&VEH_ACCELERATORON))
+		{
+			pVeh->m_ulFlags |= VEH_ACCELERATORON;
+			for (int i=0; (i<MAX_VEHICLE_EXHAUSTS && pVeh->m_iExhaustTag[i]!=-1); i++)
+			{
+				G_PlayEffect(pVeh->m_pVehicleInfo->iExhaustFX, parent->playerModel, pVeh->m_iExhaustTag[i], parent->s.number, parent->currentOrigin, 1,	qtrue);
+			}
+		}
+
+		// Stop It On Each Exhaust Bolt
+		//------------------------------
+		else if (!pVeh->m_ucmd.forwardmove && (pVeh->m_ulFlags&VEH_ACCELERATORON))
+		{
+			pVeh->m_ulFlags &=~VEH_ACCELERATORON;
+			for (int i=0; (i<MAX_VEHICLE_EXHAUSTS && pVeh->m_iExhaustTag[i]!=-1); i++)
+			{
+				G_StopEffect(pVeh->m_pVehicleInfo->iExhaustFX, parent->playerModel, pVeh->m_iExhaustTag[i], parent->s.number);
+			}
+		}
+	}
+
+	if (!(pVeh->m_ulFlags&VEH_ARMORLOW) && (pVeh->m_iArmor <= pVeh->m_pVehicleInfo->armor/3))
+	{
+		pVeh->m_ulFlags |= VEH_ARMORLOW;
+
+	}
+
+	// Armor Gone Effects (Fire)
+	//---------------------------
+	if (pVeh->m_pVehicleInfo->iArmorGoneFX)
+	{
+		if (!(pVeh->m_ulFlags&VEH_ARMORGONE) && (pVeh->m_iArmor <= 0))
+		{
+			pVeh->m_ulFlags |= VEH_ARMORGONE;
+			G_PlayEffect(pVeh->m_pVehicleInfo->iArmorGoneFX, parent->playerModel, parent->crotchBolt, parent->s.number, parent->currentOrigin, 1, qtrue);
+			parent->s.loopSound = G_SoundIndex( "sound/vehicles/common/fire_lp.wav" );
+		}
+	}
+#endif
+
+	return true;
+}
+#endif //QAGAME
+
+//MP RULE - ALL PROCESSMOVECOMMANDS FUNCTIONS MUST BE BG-COMPATIBLE!!!
+//If you really need to violate this rule for SP, then use ifdefs.
+//By BG-compatible, I mean no use of game-specific data - ONLY use
+//stuff available in the MP bgEntity (in SP, the bgEntity is #defined
+//as a gentity, but the MP-compatible access restrictions are based
+//on the bgEntity structure in the MP codebase) -rww
+// ProcessMoveCommands the Vehicle.
+static void ProcessMoveCommands( Vehicle_t *pVeh )
+{
+	/************************************************************************************/
+	/*	BEGIN	Here is where we move the vehicle (forward or back or whatever). BEGIN	*/
+	/************************************************************************************/
+	//Client sets ucmds and such for speed alterations
+	float speedInc, speedIdleDec, speedIdle, speedIdleAccel, speedMin, speedMax;
+	playerState_t *parentPS;
+	playerState_t *pilotPS = NULL;
+	int	curTime;
+
+#ifdef _JK2MP
+	parentPS = pVeh->m_pParentEntity->playerState;
+	if (pVeh->m_pPilot)
+	{
+		pilotPS = pVeh->m_pPilot->playerState;
+	}
+#else
+	parentPS = &pVeh->m_pParentEntity->client->ps;
+	if (pVeh->m_pPilot)
+	{
+		pilotPS = &pVeh->m_pPilot->client->ps;
+	}
+#endif
+
+
+	// If we're flying, make us accelerate at 40% (about half) acceleration rate, and restore the pitch
+	// to origin (straight) position (at 5% increments). 
+	if ( pVeh->m_ulFlags & VEH_FLYING ) 
+	{
+		speedInc = pVeh->m_pVehicleInfo->acceleration * pVeh->m_fTimeModifier * 0.4f;
+	}
+#ifdef _JK2MP
+	else if ( !parentPS->m_iVehicleNum )
+#else
+	else if ( !pVeh->m_pVehicleInfo->Inhabited( pVeh ) )
+#endif
+	{//drifts to a stop
+		speedInc = 0;
+		//pVeh->m_ucmd.forwardmove = 127;
+	}
+	else
+	{
+		speedInc = pVeh->m_pVehicleInfo->acceleration * pVeh->m_fTimeModifier;
+	}
+	speedIdleDec = pVeh->m_pVehicleInfo->decelIdle * pVeh->m_fTimeModifier;
+
+#ifndef _JK2MP//SP
+	curTime = level.time;
+#elif QAGAME//MP GAME
+	curTime = level.time;
+#elif CGAME//MP CGAME
+	//FIXME: pass in ucmd?  Not sure if this is reliable...
+	curTime = pm->cmd.serverTime;
+#endif
+
+
+
+	if ( (pVeh->m_pPilot /*&& (pilotPS->weapon == WP_NONE || pilotPS->weapon == WP_MELEE )*/ &&
+		(pVeh->m_ucmd.buttons & BUTTON_ALT_ATTACK) && pVeh->m_pVehicleInfo->turboSpeed)
+		/*||
+		(parentPS && parentPS->electrifyTime > curTime && pVeh->m_pVehicleInfo->turboSpeed)*/ //make them go!
+		)
+	{
+		if ( (parentPS && parentPS->electrifyTime > curTime) ||
+			 (pVeh->m_pPilot->playerState &&
+			  (pVeh->m_pPilot->playerState->weapon == WP_MELEE ||
+			  (pVeh->m_pPilot->playerState->weapon == WP_SABER && BG_SabersOff( pVeh->m_pPilot->playerState ) ))) )
+		{
+			if ((curTime - pVeh->m_iTurboTime)>pVeh->m_pVehicleInfo->turboRecharge)
+			{
+				pVeh->m_iTurboTime = (curTime + pVeh->m_pVehicleInfo->turboDuration);
+				if (pVeh->m_pVehicleInfo->iTurboStartFX)
+				{
+					int i;
+					for (i=0; (i<MAX_VEHICLE_EXHAUSTS && pVeh->m_iExhaustTag[i]!=-1); i++)
+					{
+#ifdef QAGAME
+						if (pVeh->m_pParentEntity &&
+							pVeh->m_pParentEntity->ghoul2 &&
+							pVeh->m_pParentEntity->playerState)
+						{ //fine, I'll use a tempent for this, but only because it's played only once at the start of a turbo.
+							vec3_t boltOrg, boltDir;
+							mdxaBone_t boltMatrix;
+
+							VectorSet(boltDir, 0.0f, pVeh->m_pParentEntity->playerState->viewangles[YAW], 0.0f);
+
+							trap_G2API_GetBoltMatrix(pVeh->m_pParentEntity->ghoul2, 0, pVeh->m_iExhaustTag[i], &boltMatrix, boltDir, pVeh->m_pParentEntity->playerState->origin, level.time, NULL, pVeh->m_pParentEntity->modelScale);
+							BG_GiveMeVectorFromMatrix(&boltMatrix, ORIGIN, boltOrg);
+							BG_GiveMeVectorFromMatrix(&boltMatrix, ORIGIN, boltDir);
+							G_PlayEffectID(pVeh->m_pVehicleInfo->iTurboStartFX, boltOrg, boltDir);
+						}
+#endif
+					}
+				}
+				parentPS->speed = pVeh->m_pVehicleInfo->turboSpeed;	// Instantly Jump To Turbo Speed
+			}
+		}
+	}
+
+	// Slide Breaking
+	if (pVeh->m_ulFlags&VEH_SLIDEBREAKING)
+	{
+		if (pVeh->m_ucmd.forwardmove>=0 
+#ifndef _JK2MP
+			|| ((level.time - pVeh->m_pParentEntity->lastMoveTime)>500)
+#endif
+			)
+		{
+			pVeh->m_ulFlags &= ~VEH_SLIDEBREAKING;
+		}
+		parentPS->speed = 0;
+	}
+	else if (
+		(curTime > pVeh->m_iTurboTime) && 
+		!(pVeh->m_ulFlags&VEH_FLYING) && 
+		pVeh->m_ucmd.forwardmove<0 && 
+		fabs(pVeh->m_vOrientation[ROLL])>25.0f)
+	{
+		pVeh->m_ulFlags |= VEH_SLIDEBREAKING;
+	}
+
+
+	if ( curTime < pVeh->m_iTurboTime )
+	{
+		speedMax = pVeh->m_pVehicleInfo->turboSpeed;
+		if (parentPS)
+		{
+			parentPS->eFlags |= EF_JETPACK_ACTIVE;
+		}
+	}
+	else
+	{
+		speedMax = pVeh->m_pVehicleInfo->speedMax;
+		if (parentPS)
+		{
+			parentPS->eFlags &= ~EF_JETPACK_ACTIVE;
+		}
+	}
+
+
+	speedIdle = pVeh->m_pVehicleInfo->speedIdle;
+	speedIdleAccel = pVeh->m_pVehicleInfo->accelIdle * pVeh->m_fTimeModifier;
+	speedMin = pVeh->m_pVehicleInfo->speedMin;
+
+	if ( parentPS->speed || parentPS->groundEntityNum == ENTITYNUM_NONE  ||
+		 pVeh->m_ucmd.forwardmove || pVeh->m_ucmd.upmove > 0 )
+	{ 
+		if ( pVeh->m_ucmd.forwardmove > 0 && speedInc )
+		{
+			parentPS->speed += speedInc;
+		}
+		else if ( pVeh->m_ucmd.forwardmove < 0 )
+		{
+			if ( parentPS->speed > speedIdle )
+			{
+				parentPS->speed -= speedInc;
+			}
+			else if ( parentPS->speed > speedMin )
+			{
+				parentPS->speed -= speedIdleDec;
+			}
+		}
+		// No input, so coast to stop.
+		else if ( parentPS->speed > 0.0f )
+		{
+			parentPS->speed -= speedIdleDec;
+			if ( parentPS->speed < 0.0f )
+			{
+				parentPS->speed = 0.0f;
+			}
+		}
+		else if ( parentPS->speed < 0.0f )
+		{
+			parentPS->speed += speedIdleDec;
+			if ( parentPS->speed > 0.0f )
+			{
+				parentPS->speed = 0.0f;
+			}
+		}
+	}
+	else
+	{
+		if ( !pVeh->m_pVehicleInfo->strafePerc 
+#ifdef _JK2MP
+			|| (0 && pVeh->m_pParentEntity->s.number < MAX_CLIENTS) )
+#else
+			|| (!g_speederControlScheme->value && !pVeh->m_pParentEntity->s.number) )
+#endif
+		{//if in a strafe-capable vehicle, clear strafing unless using alternate control scheme
+			//pVeh->m_ucmd.rightmove = 0;
+		}
+	}
+
+	if ( parentPS->speed > speedMax )
+	{
+		parentPS->speed = speedMax;
+	}
+	else if ( parentPS->speed < speedMin )
+	{
+		parentPS->speed = speedMin;
+	}
+
+	if (parentPS && parentPS->electrifyTime > curTime)
+	{
+		parentPS->speed *= (pVeh->m_fTimeModifier/60.0f);
+	}
+
+
+	/********************************************************************************/
+	/*	END Here is where we move the vehicle (forward or back or whatever). END	*/
+	/********************************************************************************/
+}
+
+//MP RULE - ALL PROCESSORIENTCOMMANDS FUNCTIONS MUST BE BG-COMPATIBLE!!!
+//If you really need to violate this rule for SP, then use ifdefs.
+//By BG-compatible, I mean no use of game-specific data - ONLY use
+//stuff available in the MP bgEntity (in SP, the bgEntity is #defined
+//as a gentity, but the MP-compatible access restrictions are based
+//on the bgEntity structure in the MP codebase) -rww
+//Oh, and please, use "< MAX_CLIENTS" to check for "player" and not
+//"!s.number", this is a universal check that will work for both SP
+//and MP. -rww
+// ProcessOrientCommands the Vehicle.
+#ifdef _JK2MP //temp hack til mp speeder controls are sorted -rww
+extern void AnimalProcessOri(Vehicle_t *pVeh);
+#endif
+void ProcessOrientCommands( Vehicle_t *pVeh )
+{
+	/********************************************************************************/
+	/*	BEGIN	Here is where make sure the vehicle is properly oriented.	BEGIN	*/
+	/********************************************************************************/
+	playerState_t *riderPS;
+	playerState_t *parentPS;
+
+#ifdef _JK2MP
+	float angDif;
+
+	if (pVeh->m_pPilot)
+	{
+		riderPS = pVeh->m_pPilot->playerState;
+	}
+	else
+	{
+		riderPS = pVeh->m_pParentEntity->playerState;
+	}
+	parentPS = pVeh->m_pParentEntity->playerState;
+
+	//pVeh->m_vOrientation[YAW] = 0.0f;//riderPS->viewangles[YAW];
+	angDif = AngleSubtract(pVeh->m_vOrientation[YAW], riderPS->viewangles[YAW]);
+	if (parentPS && parentPS->speed)
+	{
+		float s = parentPS->speed;
+		float maxDif = pVeh->m_pVehicleInfo->turningSpeed*4.0f; //magic number hackery
+		if (s < 0.0f)
+		{
+			s = -s;
+		}
+		angDif *= s/pVeh->m_pVehicleInfo->speedMax;
+		if (angDif > maxDif)
+		{
+			angDif = maxDif;
+		}
+		else if (angDif < -maxDif)
+		{
+			angDif = -maxDif;
+		}
+		pVeh->m_vOrientation[YAW] = AngleNormalize180(pVeh->m_vOrientation[YAW] - angDif*(pVeh->m_fTimeModifier*0.2f));
+
+		if (parentPS->electrifyTime > pm->cmd.serverTime)
+		{ //do some crazy stuff
+			pVeh->m_vOrientation[YAW] += (sin(pm->cmd.serverTime/1000.0f)*3.0f)*pVeh->m_fTimeModifier;
+		}
+	}
+
+#else
+ 	gentity_t *rider = pVeh->m_pParentEntity->owner;
+	if ( !rider || !rider->client )
+	{
+		riderPS = &pVeh->m_pParentEntity->client->ps;
+	}
+	else
+	{
+		riderPS = &rider->client->ps;
+	}
+	parentPS = &pVeh->m_pParentEntity->client->ps;
+
+	if (pVeh->m_ulFlags & VEH_FLYING)
+	{
+		pVeh->m_vOrientation[YAW] += pVeh->m_vAngularVelocity;
+	}
+	else if (
+		(pVeh->m_ulFlags & VEH_SLIDEBREAKING) ||	// No Angles Control While Out Of Control 
+		(pVeh->m_ulFlags & VEH_OUTOFCONTROL) 		// No Angles Control While Out Of Control 
+		)
+	{
+		// Any ability to change orientation?
+	}
+	else if (
+		(pVeh->m_ulFlags & VEH_STRAFERAM)			// No Angles Control While Strafe Ramming
+		)
+	{
+		if (parentPS->hackingTime>0)
+		{
+			parentPS->hackingTime--;
+			pVeh->m_vOrientation[ROLL] += (parentPS->hackingTime<( STRAFERAM_DURATION/2))?(-STRAFERAM_ANGLE):( STRAFERAM_ANGLE);
+		}
+		else if (pVeh->hackingTime<0)
+		{
+			parentPS->hackingTime++;
+			pVeh->m_vOrientation[ROLL] += (parentPS->hackingTime>(-STRAFERAM_DURATION/2))?( STRAFERAM_ANGLE):(-STRAFERAM_ANGLE);
+		}
+	}
+	else
+	{
+		pVeh->m_vOrientation[YAW] = riderPS->viewangles[YAW];
+	}
+#endif
+
+	/********************************************************************************/
+	/*	END	Here is where make sure the vehicle is properly oriented.	END			*/
+	/********************************************************************************/
+}
+
+#ifdef QAGAME
+
+extern void PM_SetAnim(pmove_t	*pm,int setAnimParts,int anim,int setAnimFlags, int blendTime);
+extern int PM_AnimLength( int index, animNumber_t anim );
+
+// This function makes sure that the vehicle is properly animated.
+void AnimateVehicle( Vehicle_t *pVeh )
+{
+}
+
+#endif //QAGAME
+
+//rest of file is shared
+
+#ifndef	_JK2MP
+extern void CG_ChangeWeapon( int num );
+#endif
+
+
+#ifndef _JK2MP
+extern void G_StartMatrixEffect( gentity_t *ent, int meFlags = 0, int length = 1000, float timeScale = 0.0f, int spinTime = 0 );
+#endif
+
+
+//NOTE NOTE NOTE NOTE NOTE NOTE
+//I want to keep this function BG too, because it's fairly generic already, and it
+//would be nice to have proper prediction of animations. -rww
+// This function makes sure that the rider's in this vehicle are properly animated.
+void AnimateRiders( Vehicle_t *pVeh )
+{
+	animNumber_t Anim = BOTH_VS_IDLE;
+	float fSpeedPercToMax;
+	int iFlags = SETANIM_FLAG_NORMAL, iBlend = 300;
+	playerState_t *pilotPS;
+	playerState_t *parentPS;
+	int curTime;
+
+
+	// Boarding animation.
+	if ( pVeh->m_iBoarding != 0 )
+	{
+		// We've just started moarding, set the amount of time it will take to finish moarding.
+		if ( pVeh->m_iBoarding < 0 )
+		{
+			int iAnimLen;
+
+			// Boarding from left...
+			if ( pVeh->m_iBoarding == -1 )
+			{
+				Anim = BOTH_VS_MOUNT_L;
+			}
+			else if ( pVeh->m_iBoarding == -2 )
+			{
+				Anim = BOTH_VS_MOUNT_R;
+			}
+			else if ( pVeh->m_iBoarding == -3 )
+			{
+				Anim = BOTH_VS_MOUNTJUMP_L;
+			}
+			else if ( pVeh->m_iBoarding == VEH_MOUNT_THROW_LEFT)
+			{
+				iBlend = 0;
+				Anim = BOTH_VS_MOUNTTHROW_R;
+			}
+			else if ( pVeh->m_iBoarding == VEH_MOUNT_THROW_RIGHT)
+			{
+				iBlend = 0;
+				Anim = BOTH_VS_MOUNTTHROW_L;
+			}
+
+			// Set the delay time (which happens to be the time it takes for the animation to complete).
+			// NOTE: Here I made it so the delay is actually 40% (0.4f) of the animation time.
+#ifdef _JK2MP
+			iAnimLen = BG_AnimLength( pVeh->m_pPilot->localAnimIndex, Anim ) * 0.4f;
+			pVeh->m_iBoarding = BG_GetTime() + iAnimLen;
+#else
+ 			iAnimLen = PM_AnimLength( pVeh->m_pPilot->client->clientInfo.animFileIndex, Anim );// * 0.4f;
+			if (pVeh->m_iBoarding!=VEH_MOUNT_THROW_LEFT && pVeh->m_iBoarding!=VEH_MOUNT_THROW_RIGHT)
+			{
+				pVeh->m_iBoarding = level.time + (iAnimLen*0.4f);
+			}
+			else
+			{
+				pVeh->m_iBoarding = level.time + iAnimLen;
+			}
+#endif
+			// Set the animation, which won't be interrupted until it's completed.
+			// TODO: But what if he's killed? Should the animation remain persistant???
+			iFlags = SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLD;
+			
+#ifdef _JK2MP
+			BG_SetAnim(pVeh->m_pPilot->playerState, bgAllAnims[pVeh->m_pPilot->localAnimIndex].anims,
+				SETANIM_BOTH, Anim, iFlags, iBlend);
+#else
+			NPC_SetAnim( pVeh->m_pPilot, SETANIM_BOTH, Anim, iFlags, iBlend );
+			if (pVeh->m_pOldPilot)
+			{
+				iAnimLen = PM_AnimLength( pVeh->m_pPilot->client->clientInfo.animFileIndex, BOTH_VS_MOUNTTHROWEE);
+				NPC_SetAnim( pVeh->m_pOldPilot, SETANIM_BOTH, BOTH_VS_MOUNTTHROWEE, iFlags, iBlend );
+			}
+#endif
+		}
+
+#ifndef _JK2MP
+		if (pVeh->m_pOldPilot && pVeh->m_pOldPilot->client->ps.torsoAnimTimer<=0)
+		{
+			if (Q_irand(0, player->count)==0)
+			{
+				player->count++;
+ 				player->lastEnemy = pVeh->m_pOldPilot;
+				G_StartMatrixEffect(player, MEF_LOOK_AT_ENEMY|MEF_NO_RANGEVAR|MEF_NO_VERTBOB|MEF_NO_SPIN, 1000);
+			}
+
+ 			gentity_t*	oldPilot = pVeh->m_pOldPilot;
+			pVeh->m_pVehicleInfo->Eject(pVeh, pVeh->m_pOldPilot, qtrue);		// will set pointer to zero
+
+			// Kill Him
+			//----------
+			oldPilot->client->noRagTime = -1;	// no ragdoll for you
+			G_Damage(oldPilot, pVeh->m_pPilot, pVeh->m_pPilot, pVeh->m_pPilot->currentAngles, pVeh->m_pPilot->currentOrigin, 1000, 0, MOD_CRUSH);
+
+			// Compute THe Throw Direction As Backwards From The Vehicle's Velocity
+			//----------------------------------------------------------------------
+			vec3_t		throwDir;
+			VectorScale(pVeh->m_pParentEntity->client->ps.velocity, -1.0f, throwDir);
+			VectorNormalize(throwDir);
+			throwDir[2] += 0.3f;	// up a little
+
+			// Now Throw Him Out
+			//-------------------
+			G_Throw(oldPilot, throwDir, VectorLength(pVeh->m_pParentEntity->client->ps.velocity)/10.0f);
+			NPC_SetAnim(oldPilot, SETANIM_BOTH, BOTH_DEATHBACKWARD1, SETANIM_FLAG_OVERRIDE, iBlend );
+		}
+#endif
+
+		return;
+	}
+
+#ifdef _JK2MP //fixme
+	if (1) return;
+#endif
+
+#ifdef _JK2MP
+	pilotPS = pVeh->m_pPilot->playerState;
+	parentPS = pVeh->m_pPilot->playerState;
+#else
+	pilotPS = &pVeh->m_pPilot->client->ps;
+	parentPS = &pVeh->m_pParentEntity->client->ps;
+#endif
+
+#ifndef _JK2MP//SP
+	curTime = level.time;
+#elif QAGAME//MP GAME
+	curTime = level.time;
+#elif CGAME//MP CGAME
+	//FIXME: pass in ucmd?  Not sure if this is reliable...
+	curTime = pm->cmd.serverTime;
+#endif
+
+	// Percentage of maximum speed relative to current speed.
+	fSpeedPercToMax = parentPS->speed / pVeh->m_pVehicleInfo->speedMax;
+
+	// Going in reverse...
+#ifdef _JK2MP
+	if ( pVeh->m_ucmd.forwardmove < 0 && !(pVeh->m_ulFlags & VEH_SLIDEBREAKING))
+#else
+	if ( fSpeedPercToMax < -0.018f && !(pVeh->m_ulFlags & VEH_SLIDEBREAKING))
+#endif
+	{
+		Anim = BOTH_VS_REV;
+		iBlend = 500;
+	}
+	else 
+	{
+		bool		HasWeapon	= ((pilotPS->weapon != WP_NONE) && (pilotPS->weapon != WP_MELEE));
+		bool		Attacking	= (HasWeapon && !!(pVeh->m_ucmd.buttons&BUTTON_ATTACK));
+#ifdef _JK2MP //fixme: flying tends to spaz out a lot
+		bool		Flying		= false;
+		bool		Crashing	= false;
+#else
+		bool		Flying		= !!(pVeh->m_ulFlags & VEH_FLYING);
+		bool		Crashing	= !!(pVeh->m_ulFlags & VEH_CRASHING);
+#endif
+		bool		Right		= (pVeh->m_ucmd.rightmove>0);
+		bool		Left		= (pVeh->m_ucmd.rightmove<0);
+		bool		Turbo		= (curTime<pVeh->m_iTurboTime);
+		EWeaponPose	WeaponPose	= WPOSE_NONE;
+
+
+		// Remove Crashing Flag
+		//----------------------
+		pVeh->m_ulFlags &= ~VEH_CRASHING;
+
+
+		// Put Away Saber When It Is Not Active
+		//--------------------------------------
+#ifndef _JK2MP
+		if (HasWeapon && (Turbo || (pilotPS->weapon==WP_SABER && !pilotPS->SaberActive())))
+		{
+			if (pVeh->m_pPilot->s.number<MAX_CLIENTS)
+			{
+				CG_ChangeWeapon(WP_NONE);
+			}
+
+			pVeh->m_pPilot->client->ps.weapon = WP_NONE;
+			G_RemoveWeaponModels(pVeh->m_pPilot);
+		}
+#endif
+
+		// Don't Interrupt Attack Anims
+		//------------------------------
+#ifdef _JK2MP
+		if (pilotPS->weaponTime>0)
+		{
+			return;
+		}
+#else		
+		if (pilotPS->torsoAnim>=BOTH_VS_ATL_S && pilotPS->torsoAnim<=BOTH_VS_ATF_G)
+		{
+			float		bodyCurrent	  = 0.0f;
+			int			bodyEnd		  = 0;
+			if (!!gi.G2API_GetBoneAnimIndex(&pVeh->m_pPilot->ghoul2[pVeh->m_pPilot->playerModel], pVeh->m_pPilot->rootBone, level.time, &bodyCurrent, NULL, &bodyEnd, NULL, NULL, NULL))
+			{
+				if (bodyCurrent<=((float)(bodyEnd)-1.5f))
+				{
+					return;
+				}
+			}
+		}
+#endif
+
+		// Compute The Weapon Pose
+		//--------------------------
+		if (pilotPS->weapon==WP_BLASTER)
+		{
+			WeaponPose = WPOSE_BLASTER;
+		}
+		else if (pilotPS->weapon==WP_SABER)
+		{
+			if ( (pVeh->m_ulFlags&VEH_SABERINLEFTHAND) && pilotPS->torsoAnim==BOTH_VS_ATL_TO_R_S)
+			{
+				pVeh->m_ulFlags	&= ~VEH_SABERINLEFTHAND;
+			}
+			if (!(pVeh->m_ulFlags&VEH_SABERINLEFTHAND) && pilotPS->torsoAnim==BOTH_VS_ATR_TO_L_S)
+			{
+				pVeh->m_ulFlags	|=  VEH_SABERINLEFTHAND;
+			}
+			WeaponPose = (pVeh->m_ulFlags&VEH_SABERINLEFTHAND)?(WPOSE_SABERLEFT):(WPOSE_SABERRIGHT);
+		}
+		
+
+ 		if (Attacking && WeaponPose)
+		{// Attack!
+			iBlend	= 100;
+ 			iFlags	= SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD|SETANIM_FLAG_RESTART;
+	
+			// Auto Aiming
+			//===============================================
+			if (!Left && !Right)		// Allow player strafe keys to override
+			{
+#ifndef _JK2MP
+				if (pVeh->m_pPilot->enemy)
+				{
+					vec3_t	toEnemy;
+					float	toEnemyDistance;
+					vec3_t	actorRight;
+					float	actorRightDot;
+
+					VectorSubtract(pVeh->m_pPilot->currentOrigin, pVeh->m_pPilot->enemy->currentOrigin, toEnemy);
+					toEnemyDistance = VectorNormalize(toEnemy);
+
+					AngleVectors(pVeh->m_pParentEntity->currentAngles, 0, actorRight, 0);
+					actorRightDot = DotProduct(toEnemy, actorRight);
+
+	 				if (fabsf(actorRightDot)>0.5f || pilotPS->weapon==WP_SABER)
+					{
+						Left	= (actorRightDot>0.0f);
+						Right	= !Left;
+					}
+					else
+					{
+						Right = Left = false;
+					}
+				}
+				else 
+#endif
+				if (pilotPS->weapon==WP_SABER && !Left && !Right)
+				{
+					Left = (WeaponPose==WPOSE_SABERLEFT);
+					Right	= !Left;
+				}
+			}
+
+
+			if (Left)
+			{// Attack Left
+				switch(WeaponPose)
+				{
+				case WPOSE_BLASTER:		Anim = BOTH_VS_ATL_G;		break;
+				case WPOSE_SABERLEFT:	Anim = BOTH_VS_ATL_S;		break;
+				case WPOSE_SABERRIGHT:	Anim = BOTH_VS_ATR_TO_L_S;	break;
+				default:				assert(0);
+				}
+			}
+			else if (Right)
+			{// Attack Right
+				switch(WeaponPose)
+				{
+				case WPOSE_BLASTER:		Anim = BOTH_VS_ATR_G;		break;
+				case WPOSE_SABERLEFT:	Anim = BOTH_VS_ATL_TO_R_S;	break;
+				case WPOSE_SABERRIGHT:	Anim = BOTH_VS_ATR_S;		break;
+				default:				assert(0);
+				}
+			}
+			else
+			{// Attack Ahead
+				switch(WeaponPose)
+				{
+				case WPOSE_BLASTER:		Anim = BOTH_VS_ATF_G;		break;
+				default:				assert(0);
+				}
+			}
+
+		}
+		else if (Left && pVeh->m_ucmd.buttons&BUTTON_USE)
+		{// Look To The Left Behind
+			iBlend	= 400;
+			iFlags	= SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLD;
+			switch(WeaponPose)
+			{
+			case WPOSE_SABERLEFT:	Anim = BOTH_VS_IDLE_SL;		break;
+			case WPOSE_SABERRIGHT:	Anim = BOTH_VS_IDLE_SR;		break;
+			default:				Anim = BOTH_VS_LOOKLEFT;
+			}
+		}
+		else if (Right && pVeh->m_ucmd.buttons&BUTTON_USE)
+		{// Look To The Right Behind
+			iBlend	= 400;
+			iFlags	= SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLD;
+			switch(WeaponPose)
+			{
+			case WPOSE_SABERLEFT:	Anim = BOTH_VS_IDLE_SL;		break;
+			case WPOSE_SABERRIGHT:	Anim = BOTH_VS_IDLE_SR;		break;
+			default:				Anim = BOTH_VS_LOOKRIGHT;
+			}
+		}
+		else if (Turbo)
+		{// Kicked In Turbo
+			iBlend	= 50;
+			iFlags	= SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLDLESS;
+			Anim	= BOTH_VS_TURBO;
+		}
+		else if (Flying)
+		{// Off the ground in a jump
+			iBlend	= 800;
+			iFlags	= SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLD;
+
+			switch(WeaponPose)
+			{
+			case WPOSE_NONE:		Anim = BOTH_VS_AIR;			break;
+			case WPOSE_BLASTER:		Anim = BOTH_VS_AIR_G;		break;
+			case WPOSE_SABERLEFT:	Anim = BOTH_VS_AIR_SL;		break;
+			case WPOSE_SABERRIGHT:	Anim = BOTH_VS_AIR_SR;		break;
+			default:				assert(0);
+			}
+		}
+		else if (Crashing)
+		{// Hit the ground!
+			iBlend	= 100;
+			iFlags	= SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLDLESS;
+
+			switch(WeaponPose)
+			{
+			case WPOSE_NONE:		Anim = BOTH_VS_LAND;		break;
+			case WPOSE_BLASTER:		Anim = BOTH_VS_LAND_G;		break;
+			case WPOSE_SABERLEFT:	Anim = BOTH_VS_LAND_SL;		break;
+			case WPOSE_SABERRIGHT:	Anim = BOTH_VS_LAND_SR;		break;
+			default:				assert(0);
+			}
+		}
+		else
+		{// No Special Moves
+			iBlend	= 300;
+ 			iFlags	= SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLDLESS;
+
+			if (pVeh->m_vOrientation[ROLL] <= -20)
+			{// Lean Left
+				switch(WeaponPose)
+				{
+				case WPOSE_NONE:		Anim = BOTH_VS_LEANL;			break;
+				case WPOSE_BLASTER:		Anim = BOTH_VS_LEANL_G;			break;
+				case WPOSE_SABERLEFT:	Anim = BOTH_VS_LEANL_SL;		break;
+				case WPOSE_SABERRIGHT:	Anim = BOTH_VS_LEANL_SR;		break;
+				default:				assert(0);
+				}
+			}
+			else if (pVeh->m_vOrientation[ROLL] >= 20)
+			{// Lean Right
+				switch(WeaponPose)
+				{
+				case WPOSE_NONE:		Anim = BOTH_VS_LEANR;			break;
+				case WPOSE_BLASTER:		Anim = BOTH_VS_LEANR_G;			break;
+				case WPOSE_SABERLEFT:	Anim = BOTH_VS_LEANR_SL;		break;
+				case WPOSE_SABERRIGHT:	Anim = BOTH_VS_LEANR_SR;		break;
+				default:				assert(0);
+				}
+			}
+			else
+			{// No Lean
+				switch(WeaponPose)
+				{
+				case WPOSE_NONE:		Anim = BOTH_VS_IDLE;			break;
+				case WPOSE_BLASTER:		Anim = BOTH_VS_IDLE_G;			break;
+				case WPOSE_SABERLEFT:	Anim = BOTH_VS_IDLE_SL;			break;
+				case WPOSE_SABERRIGHT:	Anim = BOTH_VS_IDLE_SR;			break;
+				default:				assert(0);
+				}
+			}
+		}// No Special Moves
+	}// Going backwards?
+
+#ifdef _JK2MP
+	iFlags &= ~SETANIM_FLAG_OVERRIDE;
+	if (pVeh->m_pPilot->playerState->torsoAnim == Anim)
+	{
+		pVeh->m_pPilot->playerState->torsoTimer = BG_AnimLength(pVeh->m_pPilot->localAnimIndex, Anim);
+	}
+	if (pVeh->m_pPilot->playerState->legsAnim == Anim)
+	{
+		pVeh->m_pPilot->playerState->legsTimer = BG_AnimLength(pVeh->m_pPilot->localAnimIndex, Anim);
+	}
+	BG_SetAnim(pVeh->m_pPilot->playerState, bgAllAnims[pVeh->m_pPilot->localAnimIndex].anims,
+		SETANIM_BOTH, Anim, iFlags|SETANIM_FLAG_HOLD, iBlend);
+#else
+	NPC_SetAnim( pVeh->m_pPilot, SETANIM_BOTH, Anim, iFlags, iBlend );
+#endif
+}
+
+#ifndef QAGAME
+void AttachRidersGeneric( Vehicle_t *pVeh );
+#endif
+
+void G_SetSpeederVehicleFunctions( vehicleInfo_t *pVehInfo )
+{
+#ifdef QAGAME
+	pVehInfo->AnimateVehicle			=		AnimateVehicle;
+	pVehInfo->AnimateRiders				=		AnimateRiders;
+//	pVehInfo->ValidateBoard				=		ValidateBoard;
+//	pVehInfo->SetParent					=		SetParent;
+//	pVehInfo->SetPilot					=		SetPilot;
+//	pVehInfo->AddPassenger				=		AddPassenger;
+//	pVehInfo->Animate					=		Animate;
+//	pVehInfo->Board						=		Board;
+//	pVehInfo->Eject						=		Eject;
+//	pVehInfo->EjectAll					=		EjectAll;
+//	pVehInfo->StartDeathDelay			=		StartDeathDelay;
+//	pVehInfo->DeathUpdate				=		DeathUpdate;
+//	pVehInfo->RegisterAssets			=		RegisterAssets;
+//	pVehInfo->Initialize				=		Initialize;
+	pVehInfo->Update					=		Update;
+//	pVehInfo->UpdateRider				=		UpdateRider;
+#endif
+
+	//shared
+	pVehInfo->ProcessMoveCommands		=		ProcessMoveCommands;
+	pVehInfo->ProcessOrientCommands		=		ProcessOrientCommands;
+
+#ifndef QAGAME //cgame prediction attachment func
+	pVehInfo->AttachRiders				=		AttachRidersGeneric;
+#endif
+//	pVehInfo->AttachRiders				=		AttachRiders;
+//	pVehInfo->Ghost						=		Ghost;
+//	pVehInfo->UnGhost					=		UnGhost;
+//	pVehInfo->Inhabited					=		Inhabited;
+}
+
+// Following is only in game, not in namespace
+#ifdef _JK2MP
+#include "../namespace_end.h"
+#endif
+
+#ifdef QAGAME
+extern void G_AllocateVehicleObject(Vehicle_t **pVeh);
+#endif
+
+#ifdef _JK2MP
+#include "../namespace_begin.h"
+#endif
+
+// Create/Allocate a new Animal Vehicle (initializing it as well).
+void G_CreateSpeederNPC( Vehicle_t **pVeh, const char *strType )
+{
+#ifdef _JK2MP
+#ifdef QAGAME
+	//these will remain on entities on the client once allocated because the pointer is
+	//never stomped. on the server, however, when an ent is freed, the entity struct is
+	//memset to 0, so this memory would be lost..
+    G_AllocateVehicleObject(pVeh);
+#else
+	if (!*pVeh)
+	{ //only allocate a new one if we really have to
+		(*pVeh) = (Vehicle_t *) BG_Alloc( sizeof(Vehicle_t) );
+	}
+#endif
+	memset(*pVeh, 0, sizeof(Vehicle_t));
+	(*pVeh)->m_pVehicleInfo = &g_vehicleInfo[BG_VehicleGetIndex( strType )];
+#else
+	// Allocate the Vehicle.
+	(*pVeh) = (Vehicle_t *) gi.Malloc( sizeof(Vehicle_t), TAG_G_ALLOC, qtrue );
+	(*pVeh)->m_pVehicleInfo = &g_vehicleInfo[BG_VehicleGetIndex( strType )];
+#endif
+}
+
+#ifdef _JK2MP
+
+#include "../namespace_end.h"
+
+//get rid of all the crazy defs we added for this file
+#undef currentAngles
+#undef currentOrigin
+#undef mins
+#undef maxs
+#undef legsAnimTimer
+#undef torsoAnimTimer
+#undef bool
+#undef false
+#undef true
+
+#undef sqrtf
+#undef Q_flrand
+
+#undef MOD_EXPLOSIVE
+#endif
diff --git a/codemp/game/WalkerNPC.c b/codemp/game/WalkerNPC.c
new file mode 100644
index 0000000..bec9e13
--- /dev/null
+++ b/codemp/game/WalkerNPC.c
@@ -0,0 +1,636 @@
+// leave this line at the top for all g_xxxx.cpp files...
+#include "g_headers.h"
+
+//seems to be a compiler bug, it doesn't clean out the #ifdefs between dif-compiles
+//or something, so the headers spew errors on these defs from the previous compile.
+//this fixes that. -rww
+#ifdef _JK2MP
+//get rid of all the crazy defs we added for this file
+#undef currentAngles
+#undef currentOrigin
+#undef mins
+#undef maxs
+#undef legsAnimTimer
+#undef torsoAnimTimer
+#undef bool
+#undef false
+#undef true
+
+#undef sqrtf
+#undef Q_flrand
+
+#undef MOD_EXPLOSIVE
+#endif
+
+#ifdef _JK2 //SP does not have this preprocessor for game like MP does
+#ifndef _JK2MP
+#define _JK2MP
+#endif
+#endif
+
+#ifndef _JK2MP //if single player
+#ifndef QAGAME //I don't think we have a QAGAME define
+#define QAGAME //but define it cause in sp we're always in the game
+#endif
+#endif
+
+#ifdef QAGAME //including game headers on cgame is FORBIDDEN ^_^
+#include "g_local.h"
+#elif defined _JK2MP
+#include "bg_public.h"
+#endif
+
+#ifndef _JK2MP
+#include "g_functions.h"
+#include "g_vehicles.h"
+#else
+#include "bg_vehicles.h"
+#endif
+
+#ifdef _JK2MP
+//this is really horrible, but it works! just be sure not to use any locals or anything
+//with these names (exluding bool, false, true). -rww
+#define currentAngles r.currentAngles
+#define currentOrigin r.currentOrigin
+#define mins r.mins
+#define maxs r.maxs
+#define legsAnimTimer legsTimer
+#define torsoAnimTimer torsoTimer
+#define bool qboolean
+#define false qfalse
+#define true qtrue
+
+#define sqrtf sqrt
+#define Q_flrand flrand
+
+#define MOD_EXPLOSIVE MOD_SUICIDE
+#else
+#define bgEntity_t gentity_t
+#endif
+
+#ifdef QAGAME //we only want a few of these functions for BG
+
+extern float DotToSpot( vec3_t spot, vec3_t from, vec3_t fromAngles );
+extern vmCvar_t	cg_thirdPersonAlpha;
+extern vec3_t playerMins;
+extern vec3_t playerMaxs;
+extern cvar_t	*g_speederControlScheme;
+extern void PM_SetAnim(pmove_t	*pm,int setAnimParts,int anim,int setAnimFlags, int blendTime);
+extern int PM_AnimLength( int index, animNumber_t anim );
+extern void Vehicle_SetAnim(gentity_t *ent,int setAnimParts,int anim,int setAnimFlags, int iBlend);
+extern void G_Knockdown( gentity_t *self, gentity_t *attacker, const vec3_t pushDir, float strength, qboolean breakSaberLock );
+extern void G_VehicleTrace( trace_t *results, const vec3_t start, const vec3_t tMins, const vec3_t tMaxs, const vec3_t end, int passEntityNum, int contentmask );
+
+static void RegisterAssets( Vehicle_t *pVeh )
+{
+	//atst uses turret weapon
+#ifdef _JK2MP
+	RegisterItem(BG_FindItemForWeapon(WP_TURRET));
+#else
+	// PUT SOMETHING HERE...
+#endif
+
+	//call the standard RegisterAssets now
+	g_vehicleInfo[VEHICLE_BASE].RegisterAssets( pVeh );
+}
+
+// Like a think or move command, this updates various vehicle properties.
+/*
+static bool Update( Vehicle_t *pVeh, const usercmd_t *pUcmd )
+{
+	return g_vehicleInfo[VEHICLE_BASE].Update( pVeh, pUcmd );
+}
+*/
+
+// Board this Vehicle (get on). The first entity to board an empty vehicle becomes the Pilot.
+static bool Board( Vehicle_t *pVeh, bgEntity_t *pEnt )
+{
+	if ( !g_vehicleInfo[VEHICLE_BASE].Board( pVeh, pEnt ) )
+		return false;
+
+	// Set the board wait time (they won't be able to do anything, including getting off, for this amount of time).
+	pVeh->m_iBoarding = level.time + 1500;
+
+	return true;
+}
+#endif //QAGAME
+
+#ifdef _JK2MP
+#include "../namespace_begin.h"
+#endif
+
+//MP RULE - ALL PROCESSMOVECOMMANDS FUNCTIONS MUST BE BG-COMPATIBLE!!!
+//If you really need to violate this rule for SP, then use ifdefs.
+//By BG-compatible, I mean no use of game-specific data - ONLY use
+//stuff available in the MP bgEntity (in SP, the bgEntity is #defined
+//as a gentity, but the MP-compatible access restrictions are based
+//on the bgEntity structure in the MP codebase) -rww
+// ProcessMoveCommands the Vehicle.
+static void ProcessMoveCommands( Vehicle_t *pVeh )
+{
+	/************************************************************************************/
+	/*	BEGIN	Here is where we move the vehicle (forward or back or whatever). BEGIN	*/
+	/************************************************************************************/
+
+	//Client sets ucmds and such for speed alterations
+	float speedInc, speedIdleDec, speedIdle, speedIdleAccel, speedMin, speedMax;
+	float fWalkSpeedMax;
+	bgEntity_t *parent = pVeh->m_pParentEntity;
+#ifdef _JK2MP
+	playerState_t *parentPS = parent->playerState;
+#else
+	playerState_t *parentPS = &parent->client->ps;
+#endif
+
+	speedIdleDec = pVeh->m_pVehicleInfo->decelIdle * pVeh->m_fTimeModifier;
+	speedMax = pVeh->m_pVehicleInfo->speedMax;
+
+	speedIdle = pVeh->m_pVehicleInfo->speedIdle;
+	speedIdleAccel = pVeh->m_pVehicleInfo->accelIdle * pVeh->m_fTimeModifier;
+	speedMin = pVeh->m_pVehicleInfo->speedMin;
+
+#ifdef _JK2MP
+	if ( !parentPS->m_iVehicleNum  )
+#else
+	if ( !pVeh->m_pVehicleInfo->Inhabited( pVeh ) )
+#endif
+	{//drifts to a stop
+		speedInc = speedIdle * pVeh->m_fTimeModifier;
+		VectorClear( parentPS->moveDir );
+		//m_ucmd.forwardmove = 127;
+		parentPS->speed = 0;
+	}
+	else
+	{
+		speedInc = pVeh->m_pVehicleInfo->acceleration * pVeh->m_fTimeModifier;
+	}
+
+	if ( parentPS->speed || parentPS->groundEntityNum == ENTITYNUM_NONE  ||
+		 pVeh->m_ucmd.forwardmove || pVeh->m_ucmd.upmove > 0 )
+	{ 
+		if ( pVeh->m_ucmd.forwardmove > 0 && speedInc )
+		{
+			parentPS->speed += speedInc;
+		}
+		else if ( pVeh->m_ucmd.forwardmove < 0 )
+		{
+			if ( parentPS->speed > speedIdle )
+			{
+				parentPS->speed -= speedInc;
+			}
+			else if ( parentPS->speed > speedMin )
+			{
+				parentPS->speed -= speedIdleDec;
+			}
+		}
+		// No input, so coast to stop.
+		else if ( parentPS->speed > 0.0f )
+		{
+			parentPS->speed -= speedIdleDec;
+			if ( parentPS->speed < 0.0f )
+			{
+				parentPS->speed = 0.0f;
+			}
+		}
+		else if ( parentPS->speed < 0.0f )
+		{
+			parentPS->speed += speedIdleDec;
+			if ( parentPS->speed > 0.0f )
+			{
+				parentPS->speed = 0.0f;
+			}
+		}
+	}
+	else
+	{
+		if ( pVeh->m_ucmd.forwardmove < 0 )
+		{
+			pVeh->m_ucmd.forwardmove = 0;
+		}
+		if ( pVeh->m_ucmd.upmove < 0 )
+		{
+			pVeh->m_ucmd.upmove = 0;
+		}
+
+		pVeh->m_ucmd.rightmove = 0;
+
+		/*if ( !pVeh->m_pVehicleInfo->strafePerc 
+			|| (!g_speederControlScheme->value && !parent->s.number) )
+		{//if in a strafe-capable vehicle, clear strafing unless using alternate control scheme
+			pVeh->m_ucmd.rightmove = 0;
+		}*/
+	}
+
+	if (parentPS && parentPS->electrifyTime > pm->cmd.serverTime)
+	{
+		speedMax *= 0.5f;
+	}
+
+	fWalkSpeedMax = speedMax * 0.275f;
+	if ( pVeh->m_ucmd.buttons & BUTTON_WALKING && parentPS->speed > fWalkSpeedMax )
+	{
+		parentPS->speed = fWalkSpeedMax;
+	}
+	else if ( parentPS->speed > speedMax )
+	{
+		parentPS->speed = speedMax;
+	}
+	else if ( parentPS->speed < speedMin )
+	{
+		parentPS->speed = speedMin;
+	}
+
+	if (parentPS->stats[STAT_HEALTH] <= 0)
+	{ //don't keep moving while you're dying!
+		parentPS->speed = 0;
+	}
+
+	/********************************************************************************/
+	/*	END Here is where we move the vehicle (forward or back or whatever). END	*/
+	/********************************************************************************/
+}
+
+#ifdef _JK2MP
+void WalkerYawAdjust(Vehicle_t *pVeh, playerState_t *riderPS, playerState_t *parentPS)
+{
+	float angDif = AngleSubtract(pVeh->m_vOrientation[YAW], riderPS->viewangles[YAW]);
+
+	if (parentPS && parentPS->speed)
+	{
+		float s = parentPS->speed;
+		float maxDif = pVeh->m_pVehicleInfo->turningSpeed*1.5f; //magic number hackery
+
+		if (s < 0.0f)
+		{
+			s = -s;
+		}
+		angDif *= s/pVeh->m_pVehicleInfo->speedMax;
+		if (angDif > maxDif)
+		{
+			angDif = maxDif;
+		}
+		else if (angDif < -maxDif)
+		{
+			angDif = -maxDif;
+		}
+		pVeh->m_vOrientation[YAW] = AngleNormalize180(pVeh->m_vOrientation[YAW] - angDif*(pVeh->m_fTimeModifier*0.2f));
+	}
+}
+
+/*
+void WalkerPitchAdjust(Vehicle_t *pVeh, playerState_t *riderPS, playerState_t *parentPS)
+{
+	float angDif = AngleSubtract(pVeh->m_vOrientation[PITCH], riderPS->viewangles[PITCH]);
+
+	if (parentPS && parentPS->speed)
+	{
+		float s = parentPS->speed;
+		float maxDif = pVeh->m_pVehicleInfo->turningSpeed*0.8f; //magic number hackery
+
+		if (s < 0.0f)
+		{
+			s = -s;
+		}
+		angDif *= s/pVeh->m_pVehicleInfo->speedMax;
+		if (angDif > maxDif)
+		{
+			angDif = maxDif;
+		}
+		else if (angDif < -maxDif)
+		{
+			angDif = -maxDif;
+		}
+		pVeh->m_vOrientation[PITCH] = AngleNormalize360(pVeh->m_vOrientation[PITCH] - angDif*(pVeh->m_fTimeModifier*0.2f));
+	}
+}
+*/
+#endif
+
+//MP RULE - ALL PROCESSORIENTCOMMANDS FUNCTIONS MUST BE BG-COMPATIBLE!!!
+//If you really need to violate this rule for SP, then use ifdefs.
+//By BG-compatible, I mean no use of game-specific data - ONLY use
+//stuff available in the MP bgEntity (in SP, the bgEntity is #defined
+//as a gentity, but the MP-compatible access restrictions are based
+//on the bgEntity structure in the MP codebase) -rww
+// ProcessOrientCommands the Vehicle.
+static void ProcessOrientCommands( Vehicle_t *pVeh )
+{
+	/********************************************************************************/
+	/*	BEGIN	Here is where make sure the vehicle is properly oriented.	BEGIN	*/
+	/********************************************************************************/
+	float speed;
+	bgEntity_t *parent = pVeh->m_pParentEntity;
+	playerState_t *parentPS, *riderPS;
+
+#ifdef _JK2MP
+	bgEntity_t *rider = NULL;
+	if (parent->s.owner != ENTITYNUM_NONE)
+	{
+		rider = PM_BGEntForNum(parent->s.owner); //&g_entities[parent->r.ownerNum];
+	}
+#else
+	gentity_t *rider = parent->owner;
+#endif
+
+#ifdef _JK2MP
+	if ( !rider )
+#else
+	if ( !rider || !rider->client )
+#endif
+	{
+		rider = parent;
+	}
+
+#ifdef _JK2MP
+	parentPS = parent->playerState;
+	riderPS = rider->playerState;
+#else
+	parentPS = &parent->client->ps;
+	riderPS = &rider->client->ps;
+#endif
+
+	speed = VectorLength( parentPS->velocity );
+
+	// If the player is the rider...
+	if ( rider->s.number < MAX_CLIENTS )
+	{//FIXME: use the vehicle's turning stat in this calc
+#ifdef _JK2MP
+		WalkerYawAdjust(pVeh, riderPS, parentPS);
+		//FighterPitchAdjust(pVeh, riderPS, parentPS);
+		pVeh->m_vOrientation[PITCH] = riderPS->viewangles[PITCH];
+#else
+		pVeh->m_vOrientation[YAW] = riderPS->viewangles[YAW];
+		pVeh->m_vOrientation[PITCH] = riderPS->viewangles[PITCH];
+#endif
+	}
+	else
+	{
+		float turnSpeed = pVeh->m_pVehicleInfo->turningSpeed;
+		if ( !pVeh->m_pVehicleInfo->turnWhenStopped 
+			&& !parentPS->speed )//FIXME: or !pVeh->m_ucmd.forwardmove?
+		{//can't turn when not moving
+			//FIXME: or ramp up to max turnSpeed?
+			turnSpeed = 0.0f;
+		}
+#ifdef _JK2MP
+		if (rider->s.eType == ET_NPC)
+#else
+		if ( !rider || rider->NPC )
+#endif
+		{//help NPCs out some
+			turnSpeed *= 2.0f;
+#ifdef _JK2MP
+			if (parentPS->speed > 200.0f)
+#else
+			if ( parent->client->ps.speed > 200.0f )
+#endif
+			{
+				turnSpeed += turnSpeed * parentPS->speed/200.0f*0.05f;
+			}
+		}
+		turnSpeed *= pVeh->m_fTimeModifier;
+
+		//default control scheme: strafing turns, mouselook aims
+		if ( pVeh->m_ucmd.rightmove < 0 )
+		{
+			pVeh->m_vOrientation[YAW] += turnSpeed;
+		}
+		else if ( pVeh->m_ucmd.rightmove > 0 )
+		{
+			pVeh->m_vOrientation[YAW] -= turnSpeed;
+		}
+
+		if ( pVeh->m_pVehicleInfo->malfunctionArmorLevel && pVeh->m_iArmor <= pVeh->m_pVehicleInfo->malfunctionArmorLevel )
+		{//damaged badly
+		}
+	}
+
+	/********************************************************************************/
+	/*	END	Here is where make sure the vehicle is properly oriented.	END			*/
+	/********************************************************************************/
+}
+
+#ifdef QAGAME //back to our game-only functions
+// This function makes sure that the vehicle is properly animated.
+static void AnimateVehicle( Vehicle_t *pVeh )
+{
+	animNumber_t Anim = BOTH_STAND1; 
+	int iFlags = SETANIM_FLAG_NORMAL, iBlend = 300;
+	gentity_t *parent = (gentity_t *)pVeh->m_pParentEntity;
+	float fSpeedPercToMax;
+
+	// We're dead (boarding is reused here so I don't have to make another variable :-).
+	if ( parent->health <= 0 ) 
+	{
+		/*
+		if ( pVeh->m_iBoarding != -999 )	// Animate the death just once!
+		{
+			pVeh->m_iBoarding = -999;
+			iFlags = SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLD; 
+
+			// FIXME! Why do you keep repeating over and over!!?!?!? Bastard!
+			//Vehicle_SetAnim( parent, SETANIM_LEGS, BOTH_VT_DEATH1, iFlags, iBlend );
+		}
+		*/
+		return;
+	}
+
+// Following is redundant to g_vehicles.c
+//	if ( pVeh->m_iBoarding )
+//	{
+//		//we have no boarding anim
+//		if (pVeh->m_iBoarding < level.time)
+//		{ //we are on now
+//			pVeh->m_iBoarding = 0;
+//		}
+//		else
+//		{
+//			return;
+//		}
+//	}
+
+	// Percentage of maximum speed relative to current speed.
+	//float fSpeed = VectorLength( client->ps.velocity );
+	fSpeedPercToMax = parent->client->ps.speed / pVeh->m_pVehicleInfo->speedMax; 
+
+	// If we're moving...
+	if ( fSpeedPercToMax > 0.0f ) //fSpeedPercToMax >= 0.85f )
+	{  
+		float fYawDelta;
+
+		iBlend = 300;
+		iFlags = SETANIM_FLAG_OVERRIDE;
+		fYawDelta = pVeh->m_vPrevOrientation[YAW] - pVeh->m_vOrientation[YAW];
+
+		// NOTE: Mikes suggestion for fixing the stuttering walk (left/right) is to maintain the
+		// current frame between animations. I have no clue how to do this and have to work on other
+		// stuff so good luck to him :-p AReis
+
+		// If we're walking (or our speed is less than .275%)...
+		if ( ( pVeh->m_ucmd.buttons & BUTTON_WALKING ) || fSpeedPercToMax < 0.275f )
+		{ 
+			// Make them lean if we're turning.
+			/*if ( fYawDelta < -0.0001f )
+			{
+				Anim = BOTH_VT_WALK_FWD_L;
+			}
+			else if ( fYawDelta > 0.0001 )
+			{
+				Anim = BOTH_VT_WALK_FWD_R;
+			}
+			else*/
+			{
+				Anim = BOTH_WALK1;
+			}
+		}
+		// otherwise we're running.
+		else
+		{
+			// Make them lean if we're turning.
+			/*if ( fYawDelta < -0.0001f )
+			{
+				Anim = BOTH_VT_RUN_FWD_L;
+			}
+			else if ( fYawDelta > 0.0001 )
+			{
+				Anim = BOTH_VT_RUN_FWD_R;
+			}
+			else*/
+			{
+				Anim = BOTH_RUN1;
+			}
+		}
+	}
+	else
+	{
+		// Going in reverse...
+		if ( fSpeedPercToMax < -0.018f )
+		{
+			iFlags = SETANIM_FLAG_NORMAL;
+			Anim = BOTH_WALKBACK1;
+			iBlend = 500;
+		}
+		else
+		{
+			//int iChance = Q_irand( 0, 20000 ); 
+
+			// Every once in a while buck or do a different idle...
+			iFlags = SETANIM_FLAG_NORMAL | SETANIM_FLAG_RESTART | SETANIM_FLAG_HOLD; 
+			iBlend = 600;
+#ifdef _JK2MP
+			if (parent->client->ps.m_iVehicleNum)
+#else
+			if ( pVeh->m_pVehicleInfo->Inhabited( pVeh ) )
+#endif
+			{//occupado
+				Anim = BOTH_STAND1;
+			}
+			else
+			{//wide open for you, baby
+				Anim = BOTH_STAND2;
+			}
+		}
+	}
+
+	Vehicle_SetAnim( parent, SETANIM_LEGS, Anim, iFlags, iBlend );
+}
+
+//rwwFIXMEFIXME: This is all going to have to be predicted I think, or it will feel awful
+//and lagged
+#endif //QAGAME
+
+#ifndef QAGAME
+void AttachRidersGeneric( Vehicle_t *pVeh );
+#endif
+
+//on the client this function will only set up the process command funcs
+void G_SetWalkerVehicleFunctions( vehicleInfo_t *pVehInfo )
+{
+#ifdef QAGAME
+	pVehInfo->AnimateVehicle			=		AnimateVehicle;
+//	pVehInfo->AnimateRiders				=		AnimateRiders;
+//	pVehInfo->ValidateBoard				=		ValidateBoard;
+//	pVehInfo->SetParent					=		SetParent;
+//	pVehInfo->SetPilot					=		SetPilot;
+//	pVehInfo->AddPassenger				=		AddPassenger;
+//	pVehInfo->Animate					=		Animate;
+	pVehInfo->Board						=		Board;
+//	pVehInfo->Eject						=		Eject;
+//	pVehInfo->EjectAll					=		EjectAll;
+//	pVehInfo->StartDeathDelay			=		StartDeathDelay;
+//	pVehInfo->DeathUpdate				=		DeathUpdate;
+	pVehInfo->RegisterAssets			=		RegisterAssets;
+//	pVehInfo->Initialize				=		Initialize;
+//	pVehInfo->Update					=		Update;
+//	pVehInfo->UpdateRider				=		UpdateRider;
+#endif //QAGAME
+	pVehInfo->ProcessMoveCommands		=		ProcessMoveCommands;
+	pVehInfo->ProcessOrientCommands		=		ProcessOrientCommands;
+
+#ifndef QAGAME //cgame prediction attachment func
+	pVehInfo->AttachRiders				=		AttachRidersGeneric;
+#endif
+//	pVehInfo->AttachRiders				=		AttachRiders;
+//	pVehInfo->Ghost						=		Ghost;
+//	pVehInfo->UnGhost					=		UnGhost;
+//	pVehInfo->Inhabited					=		Inhabited;
+}
+
+// Following is only in game, not in namespace
+#ifdef _JK2MP
+#include "../namespace_end.h"
+#endif
+
+#ifdef QAGAME
+extern void G_AllocateVehicleObject(Vehicle_t **pVeh);
+#endif
+
+#ifdef _JK2MP
+#include "../namespace_begin.h"
+#endif
+
+// Create/Allocate a new Animal Vehicle (initializing it as well).
+//this is a BG function too in MP so don't un-bg-compatibilify it -rww
+void G_CreateWalkerNPC( Vehicle_t **pVeh, const char *strAnimalType )
+{
+	// Allocate the Vehicle.
+#ifdef _JK2MP
+#ifdef QAGAME
+	//these will remain on entities on the client once allocated because the pointer is
+	//never stomped. on the server, however, when an ent is freed, the entity struct is
+	//memset to 0, so this memory would be lost..
+    G_AllocateVehicleObject(pVeh);
+#else
+	if (!*pVeh)
+	{ //only allocate a new one if we really have to
+		(*pVeh) = (Vehicle_t *) BG_Alloc( sizeof(Vehicle_t) );
+	}
+#endif
+	memset(*pVeh, 0, sizeof(Vehicle_t));
+	(*pVeh)->m_pVehicleInfo = &g_vehicleInfo[BG_VehicleGetIndex( strAnimalType )];
+#else
+	(*pVeh) = (Vehicle_t *) gi.Malloc( sizeof(Vehicle_t), TAG_G_ALLOC, qtrue );
+	(*pVeh)->m_pVehicleInfo = &g_vehicleInfo[BG_VehicleGetIndex( strAnimalType )];
+#endif
+}
+
+#ifdef _JK2MP
+
+#include "../namespace_end.h"
+
+//get rid of all the crazy defs we added for this file
+#undef currentAngles
+#undef currentOrigin
+#undef mins
+#undef maxs
+#undef legsAnimTimer
+#undef torsoAnimTimer
+#undef bool
+#undef false
+#undef true
+
+#undef sqrtf
+#undef Q_flrand
+
+#undef MOD_EXPLOSIVE
+#endif
diff --git a/codemp/game/ai.h b/codemp/game/ai.h
new file mode 100644
index 0000000..e61c8fb
--- /dev/null
+++ b/codemp/game/ai.h
@@ -0,0 +1,126 @@
+#ifndef __AI__
+#define __AI__
+
+//Distance ratings
+typedef enum
+{
+	DIST_MELEE,
+	DIST_LONG,
+} distance_e;
+
+//Attack types
+typedef enum
+{
+	ATTACK_MELEE,
+	ATTACK_RANGE,
+} attack_e;
+
+enum
+{
+	SQUAD_IDLE,					//No target found, waiting
+	SQUAD_STAND_AND_SHOOT,		//Standing in position and shoot (no cover)
+	SQUAD_RETREAT,				//Running away from combat
+	SQUAD_COVER,				//Under protective cover
+	SQUAD_TRANSITION,			//Moving between points, not firing
+	SQUAD_POINT,				//On point, laying down suppressive fire
+	SQUAD_SCOUT,				//Poking out to draw enemy
+	NUM_SQUAD_STATES,
+};
+
+//sigh... had to move in here for groupInfo
+typedef enum //# rank_e
+{
+	RANK_CIVILIAN,
+	RANK_CREWMAN,
+	RANK_ENSIGN,
+	RANK_LT_JG,
+	RANK_LT,
+	RANK_LT_COMM,
+	RANK_COMMANDER,
+	RANK_CAPTAIN
+} rank_t;
+
+qboolean NPC_CheckPlayerTeamStealth( void );
+
+//AI_GRENADIER
+void NPC_BSGrenadier_Default( void );
+
+//AI_SNIPER
+void NPC_BSSniper_Default( void );
+
+//AI_STORMTROOPER
+void NPC_BSST_Investigate( void );
+void NPC_BSST_Default( void );
+void NPC_BSST_Sleep( void );
+
+//AI_JEDI
+void NPC_BSJedi_Investigate( void );
+void NPC_BSJedi_Default( void );
+void NPC_BSJedi_FollowLeader( void );
+
+// AI_DROID
+void NPC_BSDroid_Default( void );
+
+// AI_ImperialProbe
+void NPC_BSImperialProbe_Default( void );
+
+// AI_atst
+void NPC_BSATST_Default( void );
+
+void NPC_BSInterrogator_Default( void );
+
+// AI Mark 1
+void NPC_BSMark1_Default( void );
+
+// AI Mark 2
+void NPC_BSMark2_Default( void );
+
+
+void NPC_BSMineMonster_Default( void );
+void NPC_BSHowler_Default( void );
+void NPC_BSRancor_Default( void );
+
+//Utilities
+//Group AI
+#define	MAX_FRAME_GROUPS	32
+// !!!!!!!!!! LOADSAVE-affecting structure !!!!!!!!!!
+typedef struct AIGroupMember_s
+{
+	int	number;
+	int waypoint;
+	int pathCostToEnemy;
+	int	closestBuddy;
+} AIGroupMember_t;
+
+#define MAX_GROUP_MEMBERS 32
+// !!!!!!!!!! LOADSAVE-affecting structure !!!!!!!!!!
+typedef struct AIGroupInfo_s
+{
+	int			numGroup;
+	qboolean	processed;
+	team_t		team;
+	gentity_t	*enemy;
+	int			enemyWP;
+	int			speechDebounceTime;
+	int			lastClearShotTime;
+	int			lastSeenEnemyTime;
+	int			morale;
+	int			moraleAdjust;
+	int			moraleDebounce;
+	int			memberValidateTime;
+	int			activeMemberNum;
+	gentity_t	*commander;
+	vec3_t		enemyLastSeenPos;
+	int			numState[ NUM_SQUAD_STATES ];
+	AIGroupMember_t member[ MAX_GROUP_MEMBERS ];
+} AIGroupInfo_t;
+
+int	AI_GetGroupSize( vec3_t origin, int radius, team_t playerTeam, gentity_t *avoid );
+int AI_GetGroupSize2( gentity_t *ent, int radius );
+
+void AI_GetGroup( gentity_t *self );
+
+qboolean AI_CheckEnemyCollision( gentity_t *ent, qboolean takeEnemy );
+gentity_t *AI_DistributeAttack( gentity_t *attacker, gentity_t *enemy, team_t team, int threshold );
+
+#endif	//__AI__
diff --git a/codemp/game/ai_main.c b/codemp/game/ai_main.c
new file mode 100644
index 0000000..6f416b9
--- /dev/null
+++ b/codemp/game/ai_main.c
@@ -0,0 +1,7642 @@
+// Copyright (C) 1999-2000 Id Software, Inc.
+//
+
+/*****************************************************************************
+ * name:		ai_main.c
+ *
+ * desc:		Quake3 bot AI
+ *
+ * $Archive: /MissionPack/code/game/ai_main.c $
+ * $Author: osman $ 
+ * $Revision: 1.5 $
+ * $Modtime: 6/06/01 1:11p $
+ * $Date: 2003/03/15 23:43:59 $
+ *
+ *****************************************************************************/
+
+
+#include "g_local.h"
+#include "q_shared.h"
+#include "botlib.h"		//bot lib interface
+#include "be_aas.h"
+#include "be_ea.h"
+#include "be_ai_char.h"
+#include "be_ai_chat.h"
+#include "be_ai_gen.h"
+#include "be_ai_goal.h"
+#include "be_ai_move.h"
+#include "be_ai_weap.h"
+//
+#include "ai_main.h"
+#include "w_saber.h"
+//
+#include "chars.h"
+#include "inv.h"
+#include "syn.h"
+
+/*
+#define BOT_CTF_DEBUG	1
+*/
+
+#define MAX_PATH		144
+
+#define BOT_THINK_TIME	0
+
+//bot states
+bot_state_t	*botstates[MAX_CLIENTS];
+//number of bots
+int numbots;
+//floating point time
+float floattime;
+//time to do a regular update
+float regularupdate_time;
+//
+
+//for siege:
+extern int rebel_attackers;
+extern int imperial_attackers;
+
+boteventtracker_t gBotEventTracker[MAX_CLIENTS];
+
+//rww - new bot cvars..
+vmCvar_t bot_forcepowers;
+vmCvar_t bot_forgimmick;
+vmCvar_t bot_honorableduelacceptance;
+vmCvar_t bot_pvstype;
+vmCvar_t bot_normgpath;
+#ifndef FINAL_BUILD
+vmCvar_t bot_getinthecarrr;
+#endif
+
+#ifdef _DEBUG
+vmCvar_t bot_nogoals;
+vmCvar_t bot_debugmessages;
+#endif
+
+vmCvar_t bot_attachments;
+vmCvar_t bot_camp;
+
+vmCvar_t bot_wp_info;
+vmCvar_t bot_wp_edit;
+vmCvar_t bot_wp_clearweight;
+vmCvar_t bot_wp_distconnect;
+vmCvar_t bot_wp_visconnect;
+//end rww
+
+wpobject_t *flagRed;
+wpobject_t *oFlagRed;
+wpobject_t *flagBlue;
+wpobject_t *oFlagBlue;
+
+gentity_t *eFlagRed;
+gentity_t *droppedRedFlag;
+gentity_t *eFlagBlue;
+gentity_t *droppedBlueFlag;
+
+char *ctfStateNames[] = {
+	"CTFSTATE_NONE",
+	"CTFSTATE_ATTACKER",
+	"CTFSTATE_DEFENDER",
+	"CTFSTATE_RETRIEVAL",
+	"CTFSTATE_GUARDCARRIER",
+	"CTFSTATE_GETFLAGHOME",
+	"CTFSTATE_MAXCTFSTATES"
+};
+
+char *ctfStateDescriptions[] = {
+	"I'm not occupied",
+	"I'm attacking the enemy's base",
+	"I'm defending our base",
+	"I'm getting our flag back",
+	"I'm escorting our flag carrier",
+	"I've got the enemy's flag"
+};
+
+char *siegeStateDescriptions[] = {
+	"I'm not occupied",
+	"I'm attemtping to complete the current objective",
+	"I'm preventing the enemy from completing their objective"
+};
+
+char *teamplayStateDescriptions[] = {
+	"I'm not occupied",
+	"I'm following my squad commander",
+	"I'm assisting my commanding",
+	"I'm attempting to regroup and form a new squad"
+};
+
+void BotStraightTPOrderCheck(gentity_t *ent, int ordernum, bot_state_t *bs)
+{
+	switch (ordernum)
+	{
+	case 0:
+		if (bs->squadLeader == ent)
+		{
+			bs->teamplayState = 0;
+			bs->squadLeader = NULL;
+		}
+		break;
+	case TEAMPLAYSTATE_FOLLOWING:
+		bs->teamplayState = ordernum;
+		bs->isSquadLeader = 0;
+		bs->squadLeader = ent;
+		bs->wpDestSwitchTime = 0;
+		break;
+	case TEAMPLAYSTATE_ASSISTING:
+		bs->teamplayState = ordernum;
+		bs->isSquadLeader = 0;
+		bs->squadLeader = ent;
+		bs->wpDestSwitchTime = 0;
+		break;
+	default:
+		bs->teamplayState = ordernum;
+		break;
+	}
+}
+
+void BotSelectWeapon(int client, int weapon)
+{
+	if (weapon <= WP_NONE)
+	{
+//		assert(0);
+		return;
+	}
+	trap_EA_SelectWeapon(client, weapon);
+}
+
+void BotReportStatus(bot_state_t *bs)
+{
+	if (g_gametype.integer == GT_TEAM)
+	{
+		trap_EA_SayTeam(bs->client, teamplayStateDescriptions[bs->teamplayState]);
+	}
+	else if (g_gametype.integer == GT_SIEGE)
+	{
+		trap_EA_SayTeam(bs->client, siegeStateDescriptions[bs->siegeState]);
+	}
+	else if (g_gametype.integer == GT_CTF || g_gametype.integer == GT_CTY)
+	{
+		trap_EA_SayTeam(bs->client, ctfStateDescriptions[bs->ctfState]);
+	}
+}
+
+//accept a team order from a player
+void BotOrder(gentity_t *ent, int clientnum, int ordernum)
+{
+	int stateMin = 0;
+	int stateMax = 0;
+	int i = 0;
+
+	if (!ent || !ent->client || !ent->client->sess.teamLeader)
+	{
+		return;
+	}
+
+	if (clientnum != -1 && !botstates[clientnum])
+	{
+		return;
+	}
+
+	if (clientnum != -1 && !OnSameTeam(ent, &g_entities[clientnum]))
+	{
+		return;
+	}
+
+	if (g_gametype.integer != GT_CTF && g_gametype.integer != GT_CTY && g_gametype.integer != GT_SIEGE &&
+		g_gametype.integer != GT_TEAM)
+	{
+		return;
+	}
+
+	if (g_gametype.integer == GT_CTF || g_gametype.integer == GT_CTY)
+	{
+		stateMin = CTFSTATE_NONE;
+		stateMax = CTFSTATE_MAXCTFSTATES;
+	}
+	else if (g_gametype.integer == GT_SIEGE)
+	{
+		stateMin = SIEGESTATE_NONE;
+		stateMax = SIEGESTATE_MAXSIEGESTATES;
+	}
+	else if (g_gametype.integer == GT_TEAM)
+	{
+		stateMin = TEAMPLAYSTATE_NONE;
+		stateMax = TEAMPLAYSTATE_MAXTPSTATES;
+	}
+
+	if ((ordernum < stateMin && ordernum != -1) || ordernum >= stateMax)
+	{
+		return;
+	}
+
+	if (clientnum != -1)
+	{
+		if (ordernum == -1)
+		{
+			BotReportStatus(botstates[clientnum]);
+		}
+		else
+		{
+			BotStraightTPOrderCheck(ent, ordernum, botstates[clientnum]);
+			botstates[clientnum]->state_Forced = ordernum;
+			botstates[clientnum]->chatObject = ent;
+			botstates[clientnum]->chatAltObject = NULL;
+			if (BotDoChat(botstates[clientnum], "OrderAccepted", 1))
+			{
+				botstates[clientnum]->chatTeam = 1;
+			}
+		}
+	}
+	else
+	{
+		while (i < MAX_CLIENTS)
+		{
+			if (botstates[i] && OnSameTeam(ent, &g_entities[i]))
+			{
+				if (ordernum == -1)
+				{
+					BotReportStatus(botstates[i]);
+				}
+				else
+				{
+					BotStraightTPOrderCheck(ent, ordernum, botstates[i]);
+					botstates[i]->state_Forced = ordernum;
+					botstates[i]->chatObject = ent;
+					botstates[i]->chatAltObject = NULL;
+					if (BotDoChat(botstates[i], "OrderAccepted", 0))
+					{
+						botstates[i]->chatTeam = 1;
+					}
+				}
+			}
+
+			i++;
+		}
+	}
+}
+
+//See if bot is mindtricked by the client in question
+int BotMindTricked(int botClient, int enemyClient)
+{
+	forcedata_t *fd;
+
+	if (!g_entities[enemyClient].client)
+	{
+		return 0;
+	}
+	
+	fd = &g_entities[enemyClient].client->ps.fd;
+
+	if (!fd)
+	{
+		return 0;
+	}
+
+	if (botClient > 47)
+	{
+		if (fd->forceMindtrickTargetIndex4 & (1 << (botClient-48)))
+		{
+			return 1;
+		}
+	}
+	else if (botClient > 31)
+	{
+		if (fd->forceMindtrickTargetIndex3 & (1 << (botClient-32)))
+		{
+			return 1;
+		}
+	}
+	else if (botClient > 15)
+	{
+		if (fd->forceMindtrickTargetIndex2 & (1 << (botClient-16)))
+		{
+			return 1;
+		}
+	}
+	else
+	{
+		if (fd->forceMindtrickTargetIndex & (1 << botClient))
+		{
+			return 1;
+		}
+	}
+
+	return 0;
+}
+
+int BotGetWeaponRange(bot_state_t *bs);
+int PassLovedOneCheck(bot_state_t *bs, gentity_t *ent);
+
+void ExitLevel( void );
+
+void QDECL BotAI_Print(int type, char *fmt, ...) { return; }
+
+qboolean WP_ForcePowerUsable( gentity_t *self, forcePowers_t forcePower );
+
+int IsTeamplay(void)
+{
+	if ( g_gametype.integer < GT_TEAM )
+	{
+		return 0;
+	}
+
+	return 1;
+}
+
+/*
+==================
+BotAI_GetClientState
+==================
+*/
+int BotAI_GetClientState( int clientNum, playerState_t *state ) {
+	gentity_t	*ent;
+
+	ent = &g_entities[clientNum];
+	if ( !ent->inuse ) {
+		return qfalse;
+	}
+	if ( !ent->client ) {
+		return qfalse;
+	}
+
+	memcpy( state, &ent->client->ps, sizeof(playerState_t) );
+	return qtrue;
+}
+
+/*
+==================
+BotAI_GetEntityState
+==================
+*/
+int BotAI_GetEntityState( int entityNum, entityState_t *state ) {
+	gentity_t	*ent;
+
+	ent = &g_entities[entityNum];
+	memset( state, 0, sizeof(entityState_t) );
+	if (!ent->inuse) return qfalse;
+	if (!ent->r.linked) return qfalse;
+	if (ent->r.svFlags & SVF_NOCLIENT) return qfalse;
+	memcpy( state, &ent->s, sizeof(entityState_t) );
+	return qtrue;
+}
+
+/*
+==================
+BotAI_GetSnapshotEntity
+==================
+*/
+int BotAI_GetSnapshotEntity( int clientNum, int sequence, entityState_t *state ) {
+	int		entNum;
+
+	entNum = trap_BotGetSnapshotEntity( clientNum, sequence );
+	if ( entNum == -1 ) {
+		memset(state, 0, sizeof(entityState_t));
+		return -1;
+	}
+
+	BotAI_GetEntityState( entNum, state );
+
+	return sequence + 1;
+}
+
+/*
+==============
+BotEntityInfo
+==============
+*/
+void BotEntityInfo(int entnum, aas_entityinfo_t *info) {
+	trap_AAS_EntityInfo(entnum, info);
+}
+
+/*
+==============
+NumBots
+==============
+*/
+int NumBots(void) {
+	return numbots;
+}
+
+/*
+==============
+AngleDifference
+==============
+*/
+float AngleDifference(float ang1, float ang2) {
+	float diff;
+
+	diff = ang1 - ang2;
+	if (ang1 > ang2) {
+		if (diff > 180.0) diff -= 360.0;
+	}
+	else {
+		if (diff < -180.0) diff += 360.0;
+	}
+	return diff;
+}
+
+/*
+==============
+BotChangeViewAngle
+==============
+*/
+float BotChangeViewAngle(float angle, float ideal_angle, float speed) {
+	float move;
+
+	angle = AngleMod(angle);
+	ideal_angle = AngleMod(ideal_angle);
+	if (angle == ideal_angle) return angle;
+	move = ideal_angle - angle;
+	if (ideal_angle > angle) {
+		if (move > 180.0) move -= 360.0;
+	}
+	else {
+		if (move < -180.0) move += 360.0;
+	}
+	if (move > 0) {
+		if (move > speed) move = speed;
+	}
+	else {
+		if (move < -speed) move = -speed;
+	}
+	return AngleMod(angle + move);
+}
+
+/*
+==============
+BotChangeViewAngles
+==============
+*/
+void BotChangeViewAngles(bot_state_t *bs, float thinktime) {
+	float diff, factor, maxchange, anglespeed, disired_speed;
+	int i;
+
+	if (bs->ideal_viewangles[PITCH] > 180) bs->ideal_viewangles[PITCH] -= 360;
+	
+	if (bs->currentEnemy && bs->frame_Enemy_Vis)
+	{
+		if (bs->settings.skill <= 1)
+		{
+			factor = (bs->skills.turnspeed_combat*0.4f)*bs->settings.skill;
+		}
+		else if (bs->settings.skill <= 2)
+		{
+			factor = (bs->skills.turnspeed_combat*0.6f)*bs->settings.skill;
+		}
+		else if (bs->settings.skill <= 3)
+		{
+			factor = (bs->skills.turnspeed_combat*0.8f)*bs->settings.skill;
+		}
+		else
+		{
+			factor = bs->skills.turnspeed_combat*bs->settings.skill;
+		}
+	}
+	else
+	{
+		factor = bs->skills.turnspeed;
+	}
+
+	if (factor > 1)
+	{
+		factor = 1;
+	}
+	if (factor < 0.001)
+	{
+		factor = 0.001f;
+	}
+
+	maxchange = bs->skills.maxturn;
+
+	//if (maxchange < 240) maxchange = 240;
+	maxchange *= thinktime;
+	for (i = 0; i < 2; i++) {
+		bs->viewangles[i] = AngleMod(bs->viewangles[i]);
+		bs->ideal_viewangles[i] = AngleMod(bs->ideal_viewangles[i]);
+		diff = AngleDifference(bs->viewangles[i], bs->ideal_viewangles[i]);
+		disired_speed = diff * factor;
+		bs->viewanglespeed[i] += (bs->viewanglespeed[i] - disired_speed);
+		if (bs->viewanglespeed[i] > 180) bs->viewanglespeed[i] = maxchange;
+		if (bs->viewanglespeed[i] < -180) bs->viewanglespeed[i] = -maxchange;
+		anglespeed = bs->viewanglespeed[i];
+		if (anglespeed > maxchange) anglespeed = maxchange;
+		if (anglespeed < -maxchange) anglespeed = -maxchange;
+		bs->viewangles[i] += anglespeed;
+		bs->viewangles[i] = AngleMod(bs->viewangles[i]);
+		bs->viewanglespeed[i] *= 0.45 * (1 - factor);
+	}
+	if (bs->viewangles[PITCH] > 180) bs->viewangles[PITCH] -= 360;
+	trap_EA_View(bs->client, bs->viewangles);
+}
+
+/*
+==============
+BotInputToUserCommand
+==============
+*/
+void BotInputToUserCommand(bot_input_t *bi, usercmd_t *ucmd, int delta_angles[3], int time, int useTime) {
+	vec3_t angles, forward, right;
+	short temp;
+	int j;
+
+	//clear the whole structure
+	memset(ucmd, 0, sizeof(usercmd_t));
+	//
+	//Com_Printf("dir = %f %f %f speed = %f\n", bi->dir[0], bi->dir[1], bi->dir[2], bi->speed);
+	//the duration for the user command in milli seconds
+	ucmd->serverTime = time;
+	//
+	if (bi->actionflags & ACTION_DELAYEDJUMP) {
+		bi->actionflags |= ACTION_JUMP;
+		bi->actionflags &= ~ACTION_DELAYEDJUMP;
+	}
+	//set the buttons
+	if (bi->actionflags & ACTION_RESPAWN) ucmd->buttons = BUTTON_ATTACK;
+	if (bi->actionflags & ACTION_ATTACK) ucmd->buttons |= BUTTON_ATTACK;
+	if (bi->actionflags & ACTION_ALT_ATTACK) ucmd->buttons |= BUTTON_ALT_ATTACK;
+//	if (bi->actionflags & ACTION_TALK) ucmd->buttons |= BUTTON_TALK;
+	if (bi->actionflags & ACTION_GESTURE) ucmd->buttons |= BUTTON_GESTURE;
+	if (bi->actionflags & ACTION_USE) ucmd->buttons |= BUTTON_USE_HOLDABLE;
+	if (bi->actionflags & ACTION_WALK) ucmd->buttons |= BUTTON_WALKING;
+
+	if (bi->actionflags & ACTION_FORCEPOWER) ucmd->buttons |= BUTTON_FORCEPOWER;
+
+	if (useTime < level.time && Q_irand(1, 10) < 5)
+	{ //for now just hit use randomly in case there's something useable around
+		ucmd->buttons |= BUTTON_USE;
+	}
+#if 0
+// Here's an interesting bit.  The bots in TA used buttons to do additional gestures.
+// I ripped them out because I didn't want too many buttons given the fact that I was already adding some for JK2.
+// We can always add some back in if we want though.
+	if (bi->actionflags & ACTION_AFFIRMATIVE) ucmd->buttons |= BUTTON_AFFIRMATIVE;
+	if (bi->actionflags & ACTION_NEGATIVE) ucmd->buttons |= BUTTON_NEGATIVE;
+	if (bi->actionflags & ACTION_GETFLAG) ucmd->buttons |= BUTTON_GETFLAG;
+	if (bi->actionflags & ACTION_GUARDBASE) ucmd->buttons |= BUTTON_GUARDBASE;
+	if (bi->actionflags & ACTION_PATROL) ucmd->buttons |= BUTTON_PATROL;
+	if (bi->actionflags & ACTION_FOLLOWME) ucmd->buttons |= BUTTON_FOLLOWME;
+#endif //0
+
+	if (bi->weapon == WP_NONE)
+	{
+#ifdef _DEBUG
+//		Com_Printf("WARNING: Bot tried to use WP_NONE!\n");
+#endif
+		bi->weapon = WP_BRYAR_PISTOL;
+	}
+
+	//
+	ucmd->weapon = bi->weapon;
+	//set the view angles
+	//NOTE: the ucmd->angles are the angles WITHOUT the delta angles
+	ucmd->angles[PITCH] = ANGLE2SHORT(bi->viewangles[PITCH]);
+	ucmd->angles[YAW] = ANGLE2SHORT(bi->viewangles[YAW]);
+	ucmd->angles[ROLL] = ANGLE2SHORT(bi->viewangles[ROLL]);
+	//subtract the delta angles
+	for (j = 0; j < 3; j++) {
+		temp = ucmd->angles[j] - delta_angles[j];
+		ucmd->angles[j] = temp;
+	}
+	//NOTE: movement is relative to the REAL view angles
+	//get the horizontal forward and right vector
+	//get the pitch in the range [-180, 180]
+	if (bi->dir[2]) angles[PITCH] = bi->viewangles[PITCH];
+	else angles[PITCH] = 0;
+	angles[YAW] = bi->viewangles[YAW];
+	angles[ROLL] = 0;
+	AngleVectors(angles, forward, right, NULL);
+	//bot input speed is in the range [0, 400]
+	bi->speed = bi->speed * 127 / 400;
+	//set the view independent movement
+	ucmd->forwardmove = DotProduct(forward, bi->dir) * bi->speed;
+	ucmd->rightmove = DotProduct(right, bi->dir) * bi->speed;
+	ucmd->upmove = abs((int)(forward[2])) * bi->dir[2] * bi->speed;
+	//normal keyboard movement
+	if (bi->actionflags & ACTION_MOVEFORWARD) ucmd->forwardmove += 127;
+	if (bi->actionflags & ACTION_MOVEBACK) ucmd->forwardmove -= 127;
+	if (bi->actionflags & ACTION_MOVELEFT) ucmd->rightmove -= 127;
+	if (bi->actionflags & ACTION_MOVERIGHT) ucmd->rightmove += 127;
+	//jump/moveup
+	if (bi->actionflags & ACTION_JUMP) ucmd->upmove += 127;
+	//crouch/movedown
+	if (bi->actionflags & ACTION_CROUCH) ucmd->upmove -= 127;
+	//
+	//Com_Printf("forward = %d right = %d up = %d\n", ucmd.forwardmove, ucmd.rightmove, ucmd.upmove);
+	//Com_Printf("ucmd->serverTime = %d\n", ucmd->serverTime);
+}
+
+/*
+==============
+BotUpdateInput
+==============
+*/
+void BotUpdateInput(bot_state_t *bs, int time, int elapsed_time) {
+	bot_input_t bi;
+	int j;
+
+	//add the delta angles to the bot's current view angles
+	for (j = 0; j < 3; j++) {
+		bs->viewangles[j] = AngleMod(bs->viewangles[j] + SHORT2ANGLE(bs->cur_ps.delta_angles[j]));
+	}
+	//change the bot view angles
+	BotChangeViewAngles(bs, (float) elapsed_time / 1000);
+	//retrieve the bot input
+	trap_EA_GetInput(bs->client, (float) time / 1000, &bi);
+	//respawn hack
+	if (bi.actionflags & ACTION_RESPAWN) {
+		if (bs->lastucmd.buttons & BUTTON_ATTACK) bi.actionflags &= ~(ACTION_RESPAWN|ACTION_ATTACK);
+	}
+	//convert the bot input to a usercmd
+	BotInputToUserCommand(&bi, &bs->lastucmd, bs->cur_ps.delta_angles, time, bs->noUseTime);
+	//subtract the delta angles
+	for (j = 0; j < 3; j++) {
+		bs->viewangles[j] = AngleMod(bs->viewangles[j] - SHORT2ANGLE(bs->cur_ps.delta_angles[j]));
+	}
+}
+
+/*
+==============
+BotAIRegularUpdate
+==============
+*/
+void BotAIRegularUpdate(void) {
+	if (regularupdate_time < FloatTime()) {
+		trap_BotUpdateEntityItems();
+		regularupdate_time = FloatTime() + 0.3;
+	}
+}
+
+/*
+==============
+RemoveColorEscapeSequences
+==============
+*/
+void RemoveColorEscapeSequences( char *text ) {
+	int i, l;
+
+	l = 0;
+	for ( i = 0; text[i]; i++ ) {
+		if (Q_IsColorString(&text[i])) {
+			i++;
+			continue;
+		}
+		if (text[i] > 0x7E)
+			continue;
+		text[l++] = text[i];
+	}
+	text[l] = '\0';
+}
+
+
+/*
+==============
+BotAI
+==============
+*/
+int BotAI(int client, float thinktime) {
+	bot_state_t *bs;
+	char buf[1024], *args;
+	int j;
+#ifdef _DEBUG
+	int start = 0;
+	int end = 0;
+#endif
+
+	trap_EA_ResetInput(client);
+	//
+	bs = botstates[client];
+	if (!bs || !bs->inuse) {
+		BotAI_Print(PRT_FATAL, "BotAI: client %d is not setup\n", client);
+		return qfalse;
+	}
+
+	//retrieve the current client state
+	BotAI_GetClientState( client, &bs->cur_ps );
+
+	//retrieve any waiting server commands
+	while( trap_BotGetServerCommand(client, buf, sizeof(buf)) ) {
+		//have buf point to the command and args to the command arguments
+		args = strchr( buf, ' ');
+		if (!args) continue;
+		*args++ = '\0';
+
+		//remove color espace sequences from the arguments
+		RemoveColorEscapeSequences( args );
+
+		if (!Q_stricmp(buf, "cp "))
+			{ /*CenterPrintf*/ }
+		else if (!Q_stricmp(buf, "cs"))
+			{ /*ConfigStringModified*/ }
+		else if (!Q_stricmp(buf, "scores"))
+			{ /*FIXME: parse scores?*/ }
+		else if (!Q_stricmp(buf, "clientLevelShot"))
+			{ /*ignore*/ }
+	}
+	//add the delta angles to the bot's current view angles
+	for (j = 0; j < 3; j++) {
+		bs->viewangles[j] = AngleMod(bs->viewangles[j] + SHORT2ANGLE(bs->cur_ps.delta_angles[j]));
+	}
+	//increase the local time of the bot
+	bs->ltime += thinktime;
+	//
+	bs->thinktime = thinktime;
+	//origin of the bot
+	VectorCopy(bs->cur_ps.origin, bs->origin);
+	//eye coordinates of the bot
+	VectorCopy(bs->cur_ps.origin, bs->eye);
+	bs->eye[2] += bs->cur_ps.viewheight;
+	//get the area the bot is in
+
+#ifdef _DEBUG
+	start = trap_Milliseconds();
+#endif
+	StandardBotAI(bs, thinktime);
+#ifdef _DEBUG
+	end = trap_Milliseconds();
+
+	trap_Cvar_Update(&bot_debugmessages);
+
+	if (bot_debugmessages.integer)
+	{
+		Com_Printf("Single AI frametime: %i\n", (end - start));
+	}
+#endif
+
+	//subtract the delta angles
+	for (j = 0; j < 3; j++) {
+		bs->viewangles[j] = AngleMod(bs->viewangles[j] - SHORT2ANGLE(bs->cur_ps.delta_angles[j]));
+	}
+	//everything was ok
+	return qtrue;
+}
+
+/*
+==================
+BotScheduleBotThink
+==================
+*/
+void BotScheduleBotThink(void) {
+	int i, botnum;
+
+	botnum = 0;
+
+	for( i = 0; i < MAX_CLIENTS; i++ ) {
+		if( !botstates[i] || !botstates[i]->inuse ) {
+			continue;
+		}
+		//initialize the bot think residual time
+		botstates[i]->botthink_residual = BOT_THINK_TIME * botnum / numbots;
+		botnum++;
+	}
+}
+
+int PlayersInGame(void)
+{
+	int i = 0;
+	gentity_t *ent;
+	int pl = 0;
+
+	while (i < MAX_CLIENTS)
+	{
+		ent = &g_entities[i];
+
+		if (ent && ent->client && ent->client->pers.connected == CON_CONNECTED)
+		{
+			pl++;
+		}
+
+		i++;
+	}
+
+	return pl;
+}
+
+/*
+==============
+BotAISetupClient
+==============
+*/
+int BotAISetupClient(int client, struct bot_settings_s *settings, qboolean restart) {
+	bot_state_t *bs;
+
+	if (!botstates[client]) botstates[client] = (bot_state_t *) B_Alloc(sizeof(bot_state_t)); //G_Alloc(sizeof(bot_state_t));
+																			  //rww - G_Alloc bad! B_Alloc good.
+
+	memset(botstates[client], 0, sizeof(bot_state_t));
+
+	bs = botstates[client];
+
+	if (bs && bs->inuse) {
+		BotAI_Print(PRT_FATAL, "BotAISetupClient: client %d already setup\n", client);
+		return qfalse;
+	}
+
+	memcpy(&bs->settings, settings, sizeof(bot_settings_t));
+
+	bs->client = client; //need to know the client number before doing personality stuff
+
+	//initialize weapon weight defaults..
+	bs->botWeaponWeights[WP_NONE] = 0;
+	bs->botWeaponWeights[WP_STUN_BATON] = 1;
+	bs->botWeaponWeights[WP_SABER] = 10;
+	bs->botWeaponWeights[WP_BRYAR_PISTOL] = 11;
+	bs->botWeaponWeights[WP_BLASTER] = 12;
+	bs->botWeaponWeights[WP_DISRUPTOR] = 13;
+	bs->botWeaponWeights[WP_BOWCASTER] = 14;
+	bs->botWeaponWeights[WP_REPEATER] = 15;
+	bs->botWeaponWeights[WP_DEMP2] = 16;
+	bs->botWeaponWeights[WP_FLECHETTE] = 17;
+	bs->botWeaponWeights[WP_ROCKET_LAUNCHER] = 18;
+	bs->botWeaponWeights[WP_THERMAL] = 14;
+	bs->botWeaponWeights[WP_TRIP_MINE] = 0;
+	bs->botWeaponWeights[WP_DET_PACK] = 0;
+	bs->botWeaponWeights[WP_MELEE] = 1;
+
+	BotUtilizePersonality(bs);
+
+	if (g_gametype.integer == GT_DUEL || g_gametype.integer == GT_POWERDUEL)
+	{
+		bs->botWeaponWeights[WP_SABER] = 13;
+	}
+
+	//allocate a goal state
+	bs->gs = trap_BotAllocGoalState(client);
+
+	//allocate a weapon state
+	bs->ws = trap_BotAllocWeaponState();
+
+	bs->inuse = qtrue;
+	bs->entitynum = client;
+	bs->setupcount = 4;
+	bs->entergame_time = FloatTime();
+	bs->ms = trap_BotAllocMoveState();
+	numbots++;
+
+	//NOTE: reschedule the bot thinking
+	BotScheduleBotThink();
+
+	if (PlayersInGame())
+	{ //don't talk to yourself
+		BotDoChat(bs, "GeneralGreetings", 0);
+	}
+
+	return qtrue;
+}
+
+/*
+==============
+BotAIShutdownClient
+==============
+*/
+int BotAIShutdownClient(int client, qboolean restart) {
+	bot_state_t *bs;
+
+	bs = botstates[client];
+	if (!bs || !bs->inuse) {
+		//BotAI_Print(PRT_ERROR, "BotAIShutdownClient: client %d already shutdown\n", client);
+		return qfalse;
+	}
+
+	trap_BotFreeMoveState(bs->ms);
+	//free the goal state`			
+	trap_BotFreeGoalState(bs->gs);
+	//free the weapon weights
+	trap_BotFreeWeaponState(bs->ws);
+	//
+	//clear the bot state
+	memset(bs, 0, sizeof(bot_state_t));
+	//set the inuse flag to qfalse
+	bs->inuse = qfalse;
+	//there's one bot less
+	numbots--;
+	//everything went ok
+	return qtrue;
+}
+
+/*
+==============
+BotResetState
+
+called when a bot enters the intermission or observer mode and
+when the level is changed
+==============
+*/
+void BotResetState(bot_state_t *bs) {
+	int client, entitynum, inuse;
+	int movestate, goalstate, weaponstate;
+	bot_settings_t settings;
+	playerState_t ps;							//current player state
+	float entergame_time;
+
+	//save some things that should not be reset here
+	memcpy(&settings, &bs->settings, sizeof(bot_settings_t));
+	memcpy(&ps, &bs->cur_ps, sizeof(playerState_t));
+	inuse = bs->inuse;
+	client = bs->client;
+	entitynum = bs->entitynum;
+	movestate = bs->ms;
+	goalstate = bs->gs;
+	weaponstate = bs->ws;
+	entergame_time = bs->entergame_time;
+	//reset the whole state
+	memset(bs, 0, sizeof(bot_state_t));
+	//copy back some state stuff that should not be reset
+	bs->ms = movestate;
+	bs->gs = goalstate;
+	bs->ws = weaponstate;
+	memcpy(&bs->cur_ps, &ps, sizeof(playerState_t));
+	memcpy(&bs->settings, &settings, sizeof(bot_settings_t));
+	bs->inuse = inuse;
+	bs->client = client;
+	bs->entitynum = entitynum;
+	bs->entergame_time = entergame_time;
+	//reset several states
+	if (bs->ms) trap_BotResetMoveState(bs->ms);
+	if (bs->gs) trap_BotResetGoalState(bs->gs);
+	if (bs->ws) trap_BotResetWeaponState(bs->ws);
+	if (bs->gs) trap_BotResetAvoidGoals(bs->gs);
+	if (bs->ms) trap_BotResetAvoidReach(bs->ms);
+}
+
+/*
+==============
+BotAILoadMap
+==============
+*/
+int BotAILoadMap( int restart ) {
+	int			i;
+
+	for (i = 0; i < MAX_CLIENTS; i++) {
+		if (botstates[i] && botstates[i]->inuse) {
+			BotResetState( botstates[i] );
+			botstates[i]->setupcount = 4;
+		}
+	}
+
+	return qtrue;
+}
+
+//rww - bot ai
+
+//standard visibility check
+int OrgVisible(vec3_t org1, vec3_t org2, int ignore)
+{
+	trace_t tr;
+
+	trap_Trace(&tr, org1, NULL, NULL, org2, ignore, MASK_SOLID);
+
+	if (tr.fraction == 1)
+	{
+		return 1;
+	}
+
+	return 0;
+}
+
+//special waypoint visibility check
+int WPOrgVisible(gentity_t *bot, vec3_t org1, vec3_t org2, int ignore)
+{
+	trace_t tr;
+	gentity_t *ownent;
+
+	trap_Trace(&tr, org1, NULL, NULL, org2, ignore, MASK_SOLID);
+
+	if (tr.fraction == 1)
+	{
+		trap_Trace(&tr, org1, NULL, NULL, org2, ignore, MASK_PLAYERSOLID);
+
+		if (tr.fraction != 1 && tr.entityNum != ENTITYNUM_NONE && g_entities[tr.entityNum].s.eType == ET_SPECIAL)
+		{
+			if (g_entities[tr.entityNum].parent && g_entities[tr.entityNum].parent->client)
+			{
+				ownent = g_entities[tr.entityNum].parent;
+
+				if (OnSameTeam(bot, ownent) || bot->s.number == ownent->s.number)
+				{
+					return 1;
+				}
+			}
+			return 2;
+		}
+
+		return 1;
+	}
+
+	return 0;
+}
+
+//visibility check with hull trace
+int OrgVisibleBox(vec3_t org1, vec3_t mins, vec3_t maxs, vec3_t org2, int ignore)
+{
+	trace_t tr;
+
+	if (g_RMG.integer)
+	{
+		trap_Trace(&tr, org1, NULL, NULL, org2, ignore, MASK_SOLID);
+	}
+	else
+	{
+		trap_Trace(&tr, org1, mins, maxs, org2, ignore, MASK_SOLID);
+	}
+
+	if (tr.fraction == 1 && !tr.startsolid && !tr.allsolid)
+	{
+		return 1;
+	}
+
+	return 0;
+}
+
+//see if there's a func_* ent under the given pos.
+//kind of badly done, but this shouldn't happen
+//often.
+int CheckForFunc(vec3_t org, int ignore)
+{
+	gentity_t *fent;
+	vec3_t under;
+	trace_t tr;
+
+	VectorCopy(org, under);
+
+	under[2] -= 64;
+
+	trap_Trace(&tr, org, NULL, NULL, under, ignore, MASK_SOLID);
+
+	if (tr.fraction == 1)
+	{
+		return 0;
+	}
+
+	fent = &g_entities[tr.entityNum];
+
+	if (!fent)
+	{
+		return 0;
+	}
+
+	if (strstr(fent->classname, "func_"))
+	{
+		return 1; //there's a func brush here
+	}
+
+	return 0;
+}
+
+//perform pvs check based on rmg or not
+qboolean BotPVSCheck( const vec3_t p1, const vec3_t p2 )
+{
+	if (g_RMG.integer && bot_pvstype.integer)
+	{
+		vec3_t subPoint;
+		VectorSubtract(p1, p2, subPoint);
+
+		if (VectorLength(subPoint) > 5000)
+		{
+			return qfalse;
+		}
+		return qtrue;
+	}
+
+	return trap_InPVS(p1, p2);
+}
+
+//get the index to the nearest visible waypoint in the global trail
+int GetNearestVisibleWP(vec3_t org, int ignore)
+{
+	int i;
+	float bestdist;
+	float flLen;
+	int bestindex;
+	vec3_t a, mins, maxs;
+
+	i = 0;
+	if (g_RMG.integer)
+	{
+		bestdist = 300;
+	}
+	else
+	{
+		bestdist = 800;//99999;
+				   //don't trace over 800 units away to avoid GIANT HORRIBLE SPEED HITS ^_^
+	}
+	bestindex = -1;
+
+	mins[0] = -15;
+	mins[1] = -15;
+	mins[2] = -1;
+	maxs[0] = 15;
+	maxs[1] = 15;
+	maxs[2] = 1;
+
+	while (i < gWPNum)
+	{
+		if (gWPArray[i] && gWPArray[i]->inuse)
+		{
+			VectorSubtract(org, gWPArray[i]->origin, a);
+			flLen = VectorLength(a);
+
+			if (flLen < bestdist && (g_RMG.integer || BotPVSCheck(org, gWPArray[i]->origin)) && OrgVisibleBox(org, mins, maxs, gWPArray[i]->origin, ignore))
+			{
+				bestdist = flLen;
+				bestindex = i;
+			}
+		}
+
+		i++;
+	}
+
+	return bestindex;
+}
+
+//wpDirection
+//0 == FORWARD
+//1 == BACKWARD
+
+//see if this is a valid waypoint to pick up in our
+//current state (whatever that may be)
+int PassWayCheck(bot_state_t *bs, int windex)
+{
+	if (!gWPArray[windex] || !gWPArray[windex]->inuse)
+	{ //bad point index
+		return 0;
+	}
+
+	if (g_RMG.integer)
+	{
+		if ((gWPArray[windex]->flags & WPFLAG_RED_FLAG) ||
+			(gWPArray[windex]->flags & WPFLAG_BLUE_FLAG))
+		{ //red or blue flag, we'd like to get here
+			return 1;
+		}
+	}
+
+	if (bs->wpDirection && (gWPArray[windex]->flags & WPFLAG_ONEWAY_FWD))
+	{ //we're not travelling in a direction on the trail that will allow us to pass this point
+		return 0;
+	}
+	else if (!bs->wpDirection && (gWPArray[windex]->flags & WPFLAG_ONEWAY_BACK))
+	{ //we're not travelling in a direction on the trail that will allow us to pass this point
+		return 0;
+	}
+
+	if (bs->wpCurrent && gWPArray[windex]->forceJumpTo &&
+		gWPArray[windex]->origin[2] > (bs->wpCurrent->origin[2]+64) &&
+		bs->cur_ps.fd.forcePowerLevel[FP_LEVITATION] < gWPArray[windex]->forceJumpTo)
+	{ //waypoint requires force jump level greater than our current one to pass
+		return 0;
+	}
+
+	return 1;
+}
+
+//tally up the distance between two waypoints
+float TotalTrailDistance(int start, int end, bot_state_t *bs)
+{
+	int beginat;
+	int endat;
+	float distancetotal;
+
+	distancetotal = 0;
+
+	if (start > end)
+	{
+		beginat = end;
+		endat = start;
+	}
+	else
+	{
+		beginat = start;
+		endat = end;
+	}
+
+	while (beginat < endat)
+	{
+		if (beginat >= gWPNum || !gWPArray[beginat] || !gWPArray[beginat]->inuse)
+		{ //invalid waypoint index
+			return -1;
+		}
+
+		if (!g_RMG.integer)
+		{
+			if ((end > start && gWPArray[beginat]->flags & WPFLAG_ONEWAY_BACK) ||
+				(start > end && gWPArray[beginat]->flags & WPFLAG_ONEWAY_FWD))
+			{ //a one-way point, this means this path cannot be travelled to the final point
+				return -1;
+			}
+		}
+	
+#if 0 //disabled force jump checks for now
+		if (gWPArray[beginat]->forceJumpTo)
+		{
+			if (gWPArray[beginat-1] && gWPArray[beginat-1]->origin[2]+64 < gWPArray[beginat]->origin[2])
+			{
+				gdif = gWPArray[beginat]->origin[2] - gWPArray[beginat-1]->origin[2];
+			}
+
+			if (gdif)
+			{
+				if (bs && bs->cur_ps.fd.forcePowerLevel[FP_LEVITATION] < gWPArray[beginat]->forceJumpTo)
+				{
+					return -1;
+				}
+			}
+		}
+		
+		if (bs->wpCurrent && gWPArray[windex]->forceJumpTo &&
+			gWPArray[windex]->origin[2] > (bs->wpCurrent->origin[2]+64) &&
+			bs->cur_ps.fd.forcePowerLevel[FP_LEVITATION] < gWPArray[windex]->forceJumpTo)
+		{
+			return -1;
+		}
+#endif
+
+		distancetotal += gWPArray[beginat]->disttonext;
+
+		beginat++;
+	}
+
+	return distancetotal;
+}
+
+//see if there's a route shorter than our current one to get
+//to the final destination we currently desire
+void CheckForShorterRoutes(bot_state_t *bs, int newwpindex)
+{
+	float bestlen;
+	float checklen;
+	int bestindex;
+	int i;
+	int fj;
+
+	i = 0;
+	fj = 0;
+
+	if (!bs->wpDestination)
+	{
+		return;
+	}
+
+	//set our traversal direction based on the index of the point
+	if (newwpindex < bs->wpDestination->index)
+	{
+		bs->wpDirection = 0;
+	}
+	else if (newwpindex > bs->wpDestination->index)
+	{
+		bs->wpDirection = 1;
+	}
+
+	//can't switch again yet
+	if (bs->wpSwitchTime > level.time)
+	{
+		return;
+	}
+
+	//no neighboring points to check off of
+	if (!gWPArray[newwpindex]->neighbornum)
+	{
+		return;
+	}
+
+	//get the trail distance for our wp
+	bestindex = newwpindex;
+	bestlen = TotalTrailDistance(newwpindex, bs->wpDestination->index, bs);
+
+	while (i < gWPArray[newwpindex]->neighbornum)
+	{ //now go through the neighbors and check the distance to the desired point from each neighbor
+		checklen = TotalTrailDistance(gWPArray[newwpindex]->neighbors[i].num, bs->wpDestination->index, bs);
+
+		if (checklen < bestlen-64 || bestlen == -1)
+		{ //this path covers less distance, let's take it instead
+			if (bs->cur_ps.fd.forcePowerLevel[FP_LEVITATION] >= gWPArray[newwpindex]->neighbors[i].forceJumpTo)
+			{
+				bestlen = checklen;
+				bestindex = gWPArray[newwpindex]->neighbors[i].num;
+
+				if (gWPArray[newwpindex]->neighbors[i].forceJumpTo)
+				{
+					fj = gWPArray[newwpindex]->neighbors[i].forceJumpTo;
+				}
+				else
+				{
+					fj = 0;
+				}
+			}
+		}
+
+		i++;
+	}
+
+	if (bestindex != newwpindex && bestindex != -1)
+	{ //we found a path we want to switch to, let's do it
+		bs->wpCurrent = gWPArray[bestindex];
+		bs->wpSwitchTime = level.time + 3000;
+
+		if (fj)
+		{ //do we have to force jump to get to this neighbor?
+#ifndef FORCEJUMP_INSTANTMETHOD
+			bs->forceJumpChargeTime = level.time + 1000;
+			bs->beStill = level.time + 1000;
+			bs->forceJumping = bs->forceJumpChargeTime;
+#else
+			bs->beStill = level.time + 500;
+			bs->jumpTime = level.time + fj*1200;
+			bs->jDelay = level.time + 200;
+			bs->forceJumping = bs->jumpTime;
+#endif
+		}
+	}
+}
+
+//check for flags on the waypoint we're currently travelling to
+//and perform the desired behavior based on the flag
+void WPConstantRoutine(bot_state_t *bs)
+{
+	if (!bs->wpCurrent)
+	{
+		return;
+	}
+
+	if (bs->wpCurrent->flags & WPFLAG_DUCK)
+	{ //duck while travelling to this point
+		bs->duckTime = level.time + 100;
+	}
+
+#ifndef FORCEJUMP_INSTANTMETHOD
+	if (bs->wpCurrent->flags & WPFLAG_JUMP)
+	{ //jump while travelling to this point
+		float heightDif = (bs->wpCurrent->origin[2] - bs->origin[2]+16);
+
+		if (bs->origin[2]+16 >= bs->wpCurrent->origin[2])
+		{ //don't need to jump, we're already higher than this point
+			heightDif = 0;
+		}
+
+		if (heightDif > 40 && (bs->cur_ps.fd.forcePowersKnown & (1 << FP_LEVITATION)) && (bs->cur_ps.fd.forceJumpCharge < (forceJumpStrength[bs->cur_ps.fd.forcePowerLevel[FP_LEVITATION]]-100) || bs->cur_ps.groundEntityNum == ENTITYNUM_NONE))
+		{ //alright, let's jump
+			bs->forceJumpChargeTime = level.time + 1000;
+			if (bs->cur_ps.groundEntityNum != ENTITYNUM_NONE && bs->jumpPrep < (level.time-300))
+			{
+				bs->jumpPrep = level.time + 700;
+			}
+			bs->beStill = level.time + 300;
+			bs->jumpTime = 0;
+
+			if (bs->wpSeenTime < (level.time + 600))
+			{
+				bs->wpSeenTime = level.time + 600;
+			}
+		}
+		else if (heightDif > 64 && !(bs->cur_ps.fd.forcePowersKnown & (1 << FP_LEVITATION)))
+		{ //this point needs force jump to reach and we don't have it
+			//Kill the current point and turn around
+			bs->wpCurrent = NULL;
+			if (bs->wpDirection)
+			{
+				bs->wpDirection = 0;
+			}
+			else
+			{
+				bs->wpDirection = 1;
+			}
+
+			return;
+		}
+	}
+#endif
+
+	if (bs->wpCurrent->forceJumpTo)
+	{
+#ifdef FORCEJUMP_INSTANTMETHOD
+		if (bs->origin[2]+16 < bs->wpCurrent->origin[2])
+		{
+			bs->jumpTime = level.time + 100;
+		}
+#else
+		float heightDif = (bs->wpCurrent->origin[2] - bs->origin[2]+16);
+
+		if (bs->origin[2]+16 >= bs->wpCurrent->origin[2])
+		{ //then why exactly would we be force jumping?
+			heightDif = 0;
+		}
+
+		if (bs->cur_ps.fd.forceJumpCharge < (forceJumpStrength[bs->cur_ps.fd.forcePowerLevel[FP_LEVITATION]]-100))
+		{
+			bs->forceJumpChargeTime = level.time + 200;
+		}
+#endif
+	}
+}
+
+//check if our ctf state is to guard the base
+qboolean BotCTFGuardDuty(bot_state_t *bs)
+{
+	if (g_gametype.integer != GT_CTF &&
+		g_gametype.integer != GT_CTY)
+	{
+		return qfalse;
+	}
+
+	if (bs->ctfState == CTFSTATE_DEFENDER)
+	{
+		return qtrue;
+	}
+
+	return qfalse;
+}
+
+//when we reach the waypoint we are travelling to,
+//this function will be called. We will perform any
+//checks for flags on the current wp and activate
+//any "touch" events based on that.
+void WPTouchRoutine(bot_state_t *bs)
+{
+	int lastNum;
+
+	if (!bs->wpCurrent)
+	{
+		return;
+	}
+
+	bs->wpTravelTime = level.time + 10000;
+
+	if (bs->wpCurrent->flags & WPFLAG_NOMOVEFUNC)
+	{ //don't try to use any nearby map objects for a little while
+		bs->noUseTime = level.time + 4000;
+	}
+
+#ifdef FORCEJUMP_INSTANTMETHOD
+	if ((bs->wpCurrent->flags & WPFLAG_JUMP) && bs->wpCurrent->forceJumpTo)
+	{ //jump if we're flagged to but not if this indicates a force jump point. Force jumping is
+	  //handled elsewhere.
+		bs->jumpTime = level.time + 100;
+	}
+#else
+	if ((bs->wpCurrent->flags & WPFLAG_JUMP) && !bs->wpCurrent->forceJumpTo)
+	{ //jump if we're flagged to but not if this indicates a force jump point. Force jumping is
+	  //handled elsewhere.
+		bs->jumpTime = level.time + 100;
+	}
+#endif
+
+	if (bs->isCamper && bot_camp.integer && (BotIsAChickenWuss(bs) || BotCTFGuardDuty(bs) || bs->isCamper == 2) && ((bs->wpCurrent->flags & WPFLAG_SNIPEORCAMP) || (bs->wpCurrent->flags & WPFLAG_SNIPEORCAMPSTAND)) &&
+		bs->cur_ps.weapon != WP_SABER && bs->cur_ps.weapon != WP_MELEE && bs->cur_ps.weapon != WP_STUN_BATON)
+	{ //if we're a camper and a chicken then camp
+		if (bs->wpDirection)
+		{
+			lastNum = bs->wpCurrent->index+1;
+		}
+		else
+		{
+			lastNum = bs->wpCurrent->index-1;
+		}
+
+		if (gWPArray[lastNum] && gWPArray[lastNum]->inuse && gWPArray[lastNum]->index && bs->isCamping < level.time)
+		{
+			bs->isCamping = level.time + rand()%15000 + 30000;
+			bs->wpCamping = bs->wpCurrent;
+			bs->wpCampingTo = gWPArray[lastNum];
+
+			if (bs->wpCurrent->flags & WPFLAG_SNIPEORCAMPSTAND)
+			{
+				bs->campStanding = qtrue;
+			}
+			else
+			{
+				bs->campStanding = qfalse;
+			}
+		}
+
+	}
+	else if ((bs->cur_ps.weapon == WP_SABER || bs->cur_ps.weapon == WP_STUN_BATON || bs->cur_ps.weapon == WP_MELEE) &&
+		bs->isCamping > level.time)
+	{ //don't snipe/camp with a melee weapon, that would be silly
+		bs->isCamping = 0;
+		bs->wpCampingTo = NULL;
+		bs->wpCamping = NULL;
+	}
+
+	if (bs->wpDestination)
+	{
+		if (bs->wpCurrent->index == bs->wpDestination->index)
+		{
+			bs->wpDestination = NULL;
+
+			if (bs->runningLikeASissy)
+			{ //this obviously means we're scared and running, so we'll want to keep our navigational priorities less delayed
+				bs->destinationGrabTime = level.time + 500;
+			}
+			else
+			{
+				bs->destinationGrabTime = level.time + 3500;
+			}
+		}
+		else
+		{
+			CheckForShorterRoutes(bs, bs->wpCurrent->index);
+		}
+	}
+}
+
+//could also slowly lerp toward, but for now
+//just copying straight over.
+void MoveTowardIdealAngles(bot_state_t *bs)
+{
+	VectorCopy(bs->goalAngles, bs->ideal_viewangles);
+}
+
+#define BOT_STRAFE_AVOIDANCE
+
+#ifdef BOT_STRAFE_AVOIDANCE
+#define STRAFEAROUND_RIGHT			1
+#define STRAFEAROUND_LEFT			2
+
+//do some trace checks for strafing to get an idea of where we
+//are and if we should move to avoid obstacles.
+int BotTrace_Strafe(bot_state_t *bs, vec3_t traceto)
+{
+	vec3_t playerMins = {-15, -15, /*DEFAULT_MINS_2*/-8};
+	vec3_t playerMaxs = {15, 15, DEFAULT_MAXS_2};
+	vec3_t from, to;
+	vec3_t dirAng, dirDif;
+	vec3_t forward, right;
+	trace_t tr;
+
+	if (bs->cur_ps.groundEntityNum == ENTITYNUM_NONE)
+	{ //don't do this in the air, it can be.. dangerous.
+		return 0;
+	}
+
+	VectorSubtract(traceto, bs->origin, dirAng);
+	VectorNormalize(dirAng);
+	vectoangles(dirAng, dirAng);
+
+	if (AngleDifference(bs->viewangles[YAW], dirAng[YAW]) > 60 ||
+		AngleDifference(bs->viewangles[YAW], dirAng[YAW]) < -60)
+	{ //If we aren't facing the direction we're going here, then we've got enough excuse to be too stupid to strafe around anyway
+		return 0;
+	}
+
+	VectorCopy(bs->origin, from);
+	VectorCopy(traceto, to);
+
+	VectorSubtract(to, from, dirDif);
+	VectorNormalize(dirDif);
+	vectoangles(dirDif, dirDif);
+
+	AngleVectors(dirDif, forward, 0, 0);
+
+	to[0] = from[0] + forward[0]*32;
+	to[1] = from[1] + forward[1]*32;
+	to[2] = from[2] + forward[2]*32;
+
+	trap_Trace(&tr, from, playerMins, playerMaxs, to, bs->client, MASK_PLAYERSOLID);
+
+	if (tr.fraction == 1)
+	{
+		return 0;
+	}
+
+	AngleVectors(dirAng, 0, right, 0);
+
+	from[0] += right[0]*32;
+	from[1] += right[1]*32;
+	from[2] += right[2]*16;
+
+	to[0] += right[0]*32;
+	to[1] += right[1]*32;
+	to[2] += right[2]*32;
+
+	trap_Trace(&tr, from, playerMins, playerMaxs, to, bs->client, MASK_PLAYERSOLID);
+
+	if (tr.fraction == 1)
+	{
+		return STRAFEAROUND_RIGHT;
+	}
+
+	from[0] -= right[0]*64;
+	from[1] -= right[1]*64;
+	from[2] -= right[2]*64;
+
+	to[0] -= right[0]*64;
+	to[1] -= right[1]*64;
+	to[2] -= right[2]*64;
+
+	trap_Trace(&tr, from, playerMins, playerMaxs, to, bs->client, MASK_PLAYERSOLID);
+
+	if (tr.fraction == 1)
+	{
+		return STRAFEAROUND_LEFT;
+	}
+
+	return 0;
+}
+#endif
+
+//Similar to the trace check, but we want to trace to see
+//if there's anything we can jump over.
+int BotTrace_Jump(bot_state_t *bs, vec3_t traceto)
+{
+	vec3_t mins, maxs, a, fwd, traceto_mod, tracefrom_mod;
+	trace_t tr;
+	int orTr;
+
+	VectorSubtract(traceto, bs->origin, a);
+	vectoangles(a, a);
+
+	AngleVectors(a, fwd, NULL, NULL);
+
+	traceto_mod[0] = bs->origin[0] + fwd[0]*4;
+	traceto_mod[1] = bs->origin[1] + fwd[1]*4;
+	traceto_mod[2] = bs->origin[2] + fwd[2]*4;
+
+	mins[0] = -15;
+	mins[1] = -15;
+	mins[2] = -18;
+	maxs[0] = 15;
+	maxs[1] = 15;
+	maxs[2] = 32;
+
+	trap_Trace(&tr, bs->origin, mins, maxs, traceto_mod, bs->client, MASK_PLAYERSOLID);
+
+	if (tr.fraction == 1)
+	{
+		return 0;
+	}
+
+	orTr = tr.entityNum;
+
+	VectorCopy(bs->origin, tracefrom_mod);
+
+	tracefrom_mod[2] += 41;
+	traceto_mod[2] += 41;
+
+	mins[0] = -15;
+	mins[1] = -15;
+	mins[2] = 0;
+	maxs[0] = 15;
+	maxs[1] = 15;
+	maxs[2] = 8;
+
+	trap_Trace(&tr, tracefrom_mod, mins, maxs, traceto_mod, bs->client, MASK_PLAYERSOLID);
+
+	if (tr.fraction == 1)
+	{
+		if (orTr >= 0 && orTr < MAX_CLIENTS && botstates[orTr] && botstates[orTr]->jumpTime > level.time)
+		{
+			return 0; //so bots don't try to jump over each other at the same time
+		}
+
+		if (bs->currentEnemy && bs->currentEnemy->s.number == orTr && (BotGetWeaponRange(bs) == BWEAPONRANGE_SABER || BotGetWeaponRange(bs) == BWEAPONRANGE_MELEE))
+		{
+			return 0;
+		}
+
+		return 1;
+	}
+
+	return 0;
+}
+
+//And yet another check to duck under any obstacles.
+int BotTrace_Duck(bot_state_t *bs, vec3_t traceto)
+{
+	vec3_t mins, maxs, a, fwd, traceto_mod, tracefrom_mod;
+	trace_t tr;
+
+	VectorSubtract(traceto, bs->origin, a);
+	vectoangles(a, a);
+
+	AngleVectors(a, fwd, NULL, NULL);
+
+	traceto_mod[0] = bs->origin[0] + fwd[0]*4;
+	traceto_mod[1] = bs->origin[1] + fwd[1]*4;
+	traceto_mod[2] = bs->origin[2] + fwd[2]*4;
+
+	mins[0] = -15;
+	mins[1] = -15;
+	mins[2] = -23;
+	maxs[0] = 15;
+	maxs[1] = 15;
+	maxs[2] = 8;
+
+	trap_Trace(&tr, bs->origin, mins, maxs, traceto_mod, bs->client, MASK_PLAYERSOLID);
+
+	if (tr.fraction != 1)
+	{
+		return 0;
+	}
+
+	VectorCopy(bs->origin, tracefrom_mod);
+
+	tracefrom_mod[2] += 31;//33;
+	traceto_mod[2] += 31;//33;
+
+	mins[0] = -15;
+	mins[1] = -15;
+	mins[2] = 0;
+	maxs[0] = 15;
+	maxs[1] = 15;
+	maxs[2] = 32;
+
+	trap_Trace(&tr, tracefrom_mod, mins, maxs, traceto_mod, bs->client, MASK_PLAYERSOLID);
+
+	if (tr.fraction != 1)
+	{
+		return 1;
+	}
+
+	return 0;
+}
+
+//check of the potential enemy is a valid one
+int PassStandardEnemyChecks(bot_state_t *bs, gentity_t *en)
+{
+	if (!bs || !en)
+	{ //shouldn't happen
+		return 0;
+	}
+
+	if (!en->client)
+	{ //not a client, don't care about him
+		return 0;
+	}
+
+	if (en->health < 1)
+	{ //he's already dead
+		return 0;
+	}
+
+	if (!en->takedamage)
+	{ //a client that can't take damage?
+		return 0;
+	}
+
+	if (bs->doingFallback &&
+		(gLevelFlags & LEVELFLAG_IGNOREINFALLBACK))
+	{ //we screwed up in our nav routines somewhere and we've reverted to a fallback state to
+		//try to get back on the trail. If the level specifies to ignore enemies in this state,
+		//then ignore them.
+		return 0;
+	}
+
+	if (en->client->ps.pm_type == PM_INTERMISSION ||
+		en->client->ps.pm_type == PM_SPECTATOR ||
+		en->client->sess.sessionTeam == TEAM_SPECTATOR)
+	{ //don't attack spectators
+		return 0;
+	}
+
+	if (!en->client->pers.connected)
+	{ //a "zombie" client?
+		return 0;
+	}
+
+	if (!en->s.solid)
+	{ //shouldn't happen
+		return 0;
+	}
+
+	if (bs->client == en->s.number)
+	{ //don't attack yourself
+		return 0;
+	}
+
+	if (OnSameTeam(&g_entities[bs->client], en))
+	{ //don't attack teammates
+		return 0;
+	}
+
+	if (BotMindTricked(bs->client, en->s.number))
+	{
+		if (bs->currentEnemy && bs->currentEnemy->s.number == en->s.number)
+		{ //if mindtricked by this enemy, then be less "aware" of them, even though
+			//we know they're there.
+			vec3_t vs;
+			float vLen = 0;
+
+			VectorSubtract(bs->origin, en->client->ps.origin, vs);
+			vLen = VectorLength(vs);
+
+			if (vLen > 64 /*&& (level.time - en->client->dangerTime) > 150*/)
+			{
+				return 0;
+			}
+		}
+	}
+
+	if (en->client->ps.duelInProgress && en->client->ps.duelIndex != bs->client)
+	{ //don't attack duelists unless you're dueling them
+		return 0;
+	}
+
+	if (bs->cur_ps.duelInProgress && en->s.number != bs->cur_ps.duelIndex)
+	{ //ditto, the other way around
+		return 0;
+	}
+
+	if (g_gametype.integer == GT_JEDIMASTER && !en->client->ps.isJediMaster && !bs->cur_ps.isJediMaster)
+	{ //rules for attacking non-JM in JM mode
+		vec3_t vs;
+		float vLen = 0;
+
+		if (!g_friendlyFire.integer)
+		{ //can't harm non-JM in JM mode if FF is off
+			return 0;
+		}
+
+		VectorSubtract(bs->origin, en->client->ps.origin, vs);
+		vLen = VectorLength(vs);
+
+		if (vLen > 350)
+		{
+			return 0;
+		}
+	}
+
+	return 1;
+}
+
+//Notifies the bot that he has taken damage from "attacker".
+void BotDamageNotification(gclient_t *bot, gentity_t *attacker)
+{
+	bot_state_t *bs;
+	bot_state_t *bs_a;
+	int i;
+
+	if (!bot || !attacker || !attacker->client)
+	{
+		return;
+	}
+
+	if (bot->ps.clientNum >= MAX_CLIENTS)
+	{ //an NPC.. do nothing for them.
+		return;
+	}
+
+	if (attacker->s.number >= MAX_CLIENTS)
+	{ //if attacker is an npc also don't care I suppose.
+		return;
+	}
+
+	bs_a = botstates[attacker->s.number];
+
+	if (bs_a)
+	{ //if the client attacking us is a bot as well
+		bs_a->lastAttacked = &g_entities[bot->ps.clientNum];
+		i = 0;
+
+		while (i < MAX_CLIENTS)
+		{
+			if (botstates[i] &&
+				i != bs_a->client &&
+				botstates[i]->lastAttacked == &g_entities[bot->ps.clientNum])
+			{
+				botstates[i]->lastAttacked = NULL;
+			}
+
+			i++;
+		}
+	}
+	else //got attacked by a real client, so no one gets rights to lastAttacked
+	{
+		i = 0;
+
+		while (i < MAX_CLIENTS)
+		{
+			if (botstates[i] &&
+				botstates[i]->lastAttacked == &g_entities[bot->ps.clientNum])
+			{
+				botstates[i]->lastAttacked = NULL;
+			}
+
+			i++;
+		}
+	}
+
+	bs = botstates[bot->ps.clientNum];
+
+	if (!bs)
+	{
+		return;
+	}
+
+	bs->lastHurt = attacker;
+
+	if (bs->currentEnemy)
+	{ //we don't care about the guy attacking us if we have an enemy already
+		return;
+	}
+
+	if (!PassStandardEnemyChecks(bs, attacker))
+	{ //the person that hurt us is not a valid enemy
+		return;
+	}
+
+	if (PassLovedOneCheck(bs, attacker))
+	{ //the person that hurt us is the one we love!
+		bs->currentEnemy = attacker;
+		bs->enemySeenTime = level.time + ENEMY_FORGET_MS;
+	}
+}
+
+//perform cheap "hearing" checks based on the event catching
+//system
+int BotCanHear(bot_state_t *bs, gentity_t *en, float endist)
+{
+	float minlen;
+
+	if (!en || !en->client)
+	{
+		return 0;
+	}
+
+	if (en && en->client && en->client->ps.otherSoundTime > level.time)
+	{ //they made a noise in recent time
+		minlen = en->client->ps.otherSoundLen;
+		goto checkStep;
+	}
+
+	if (en && en->client && en->client->ps.footstepTime > level.time)
+	{ //they made a footstep
+		minlen = 256;
+		goto checkStep;
+	}
+
+	if (gBotEventTracker[en->s.number].eventTime < level.time)
+	{ //no recent events to check
+		return 0;
+	}
+
+	switch(gBotEventTracker[en->s.number].events[gBotEventTracker[en->s.number].eventSequence & (MAX_PS_EVENTS-1)])
+	{ //did the last event contain a sound?
+	case EV_GLOBAL_SOUND:
+		minlen = 256;
+		break;
+	case EV_FIRE_WEAPON:
+	case EV_ALT_FIRE:
+	case EV_SABER_ATTACK:
+		minlen = 512;
+		break;
+	case EV_STEP_4:
+	case EV_STEP_8:
+	case EV_STEP_12:
+	case EV_STEP_16:
+	case EV_FOOTSTEP:
+	case EV_FOOTSTEP_METAL:
+	case EV_FOOTWADE:
+		minlen = 256;
+		break;
+	case EV_JUMP:
+	case EV_ROLL:
+		minlen = 256;
+		break;
+	default:
+		minlen = 999999;
+		break;
+	}
+checkStep:
+	if (BotMindTricked(bs->client, en->s.number))
+	{ //if mindtricked by this person, cut down on the minlen so they can't "hear" as well
+		minlen /= 4;
+	}
+
+	if (endist <= minlen)
+	{ //we heard it
+		return 1;
+	}
+
+	return 0;
+}
+
+//check for new events
+void UpdateEventTracker(void)
+{
+	int i;
+
+	i = 0;
+
+	while (i < MAX_CLIENTS)
+	{
+		if (gBotEventTracker[i].eventSequence != level.clients[i].ps.eventSequence)
+		{ //updated event
+			gBotEventTracker[i].eventSequence = level.clients[i].ps.eventSequence;
+			gBotEventTracker[i].events[0] = level.clients[i].ps.events[0];
+			gBotEventTracker[i].events[1] = level.clients[i].ps.events[1];
+			gBotEventTracker[i].eventTime = level.time + 0.5;
+		}
+
+		i++;
+	}
+}
+
+//check if said angles are within our fov
+int InFieldOfVision(vec3_t viewangles, float fov, vec3_t angles)
+{
+	int i;
+	float diff, angle;
+
+	for (i = 0; i < 2; i++)
+	{
+		angle = AngleMod(viewangles[i]);
+		angles[i] = AngleMod(angles[i]);
+		diff = angles[i] - angle;
+		if (angles[i] > angle)
+		{
+			if (diff > 180.0)
+			{
+				diff -= 360.0;
+			}
+		}
+		else
+		{
+			if (diff < -180.0)
+			{
+				diff += 360.0;
+			}
+		}
+		if (diff > 0)
+		{
+			if (diff > fov * 0.5)
+			{
+				return 0;
+			}
+		}
+		else
+		{
+			if (diff < -fov * 0.5)
+			{
+				return 0;
+			}
+		}
+	}
+	return 1;
+}
+
+//We cannot hurt the ones we love. Unless of course this
+//function says we can.
+int PassLovedOneCheck(bot_state_t *bs, gentity_t *ent)
+{
+	int i;
+	bot_state_t *loved;
+
+	if (!bs->lovednum)
+	{
+		return 1;
+	}
+
+	if (g_gametype.integer == GT_DUEL || g_gametype.integer == GT_POWERDUEL)
+	{ //There is no love in 1-on-1
+		return 1;
+	}
+
+	i = 0;
+
+	if (!botstates[ent->s.number])
+	{ //not a bot
+		return 1;
+	}
+
+	if (!bot_attachments.integer)
+	{
+		return 1;
+	}
+
+	loved = botstates[ent->s.number];
+
+	while (i < bs->lovednum)
+	{
+		if (strcmp(level.clients[loved->client].pers.netname, bs->loved[i].name) == 0)
+		{
+			if (!IsTeamplay() && bs->loved[i].level < 2)
+			{ //if FFA and level of love is not greater than 1, just don't care
+				return 1;
+			}
+			else if (IsTeamplay() && !OnSameTeam(&g_entities[bs->client], &g_entities[loved->client]) && bs->loved[i].level < 2)
+			{ //is teamplay, but not on same team and level < 2
+				return 1;
+			}
+			else
+			{
+				return 0;
+			}
+		}
+
+		i++;
+	}
+
+	return 1;
+}
+
+qboolean G_ThereIsAMaster(void);
+
+//standard check to find a new enemy.
+int ScanForEnemies(bot_state_t *bs)
+{
+	vec3_t a;
+	float distcheck;
+	float closest;
+	int bestindex;
+	int i;
+	float hasEnemyDist = 0;
+	qboolean noAttackNonJM = qfalse;
+
+	closest = 999999;
+	i = 0;
+	bestindex = -1;
+
+	if (bs->currentEnemy)
+	{ //only switch to a new enemy if he's significantly closer
+		hasEnemyDist = bs->frame_Enemy_Len;
+	}
+
+	if (bs->currentEnemy && bs->currentEnemy->client &&
+		bs->currentEnemy->client->ps.isJediMaster)
+	{ //The Jedi Master must die.
+		return -1;
+	}
+
+	if (g_gametype.integer == GT_JEDIMASTER)
+	{
+		if (G_ThereIsAMaster() && !bs->cur_ps.isJediMaster)
+		{ //if friendly fire is on in jedi master we can attack people that bug us
+			if (!g_friendlyFire.integer)
+			{
+				noAttackNonJM = qtrue;
+			}
+			else
+			{
+				closest = 128; //only get mad at people if they get close enough to you to anger you, or hurt you
+			}
+		}
+	}
+
+	while (i <= MAX_CLIENTS)
+	{
+		if (i != bs->client && g_entities[i].client && !OnSameTeam(&g_entities[bs->client], &g_entities[i]) && PassStandardEnemyChecks(bs, &g_entities[i]) && BotPVSCheck(g_entities[i].client->ps.origin, bs->eye) && PassLovedOneCheck(bs, &g_entities[i]))
+		{
+			VectorSubtract(g_entities[i].client->ps.origin, bs->eye, a);
+			distcheck = VectorLength(a);
+			vectoangles(a, a);
+
+			if (g_entities[i].client->ps.isJediMaster)
+			{ //make us think the Jedi Master is close so we'll attack him above all
+				distcheck = 1;
+			}
+
+			if (distcheck < closest && ((InFieldOfVision(bs->viewangles, 90, a) && !BotMindTricked(bs->client, i)) || BotCanHear(bs, &g_entities[i], distcheck)) && OrgVisible(bs->eye, g_entities[i].client->ps.origin, -1))
+			{
+				if (BotMindTricked(bs->client, i))
+				{
+					if (distcheck < 256 || (level.time - g_entities[i].client->dangerTime) < 100)
+					{
+						if (!hasEnemyDist || distcheck < (hasEnemyDist - 128))
+						{ //if we have an enemy, only switch to closer if he is 128+ closer to avoid flipping out
+							if (!noAttackNonJM || g_entities[i].client->ps.isJediMaster)
+							{
+								closest = distcheck;
+								bestindex = i;
+							}
+						}
+					}
+				}
+				else
+				{
+					if (!hasEnemyDist || distcheck < (hasEnemyDist - 128))
+					{ //if we have an enemy, only switch to closer if he is 128+ closer to avoid flipping out
+						if (!noAttackNonJM || g_entities[i].client->ps.isJediMaster)
+						{
+							closest = distcheck;
+							bestindex = i;
+						}
+					}
+				}
+			}
+		}
+		i++;
+	}
+	
+	return bestindex;
+}
+
+int WaitingForNow(bot_state_t *bs, vec3_t goalpos)
+{ //checks if the bot is doing something along the lines of waiting for an elevator to raise up
+	vec3_t xybot, xywp, a;
+
+	if (!bs->wpCurrent)
+	{
+		return 0;
+	}
+
+	if ((int)goalpos[0] != (int)bs->wpCurrent->origin[0] ||
+		(int)goalpos[1] != (int)bs->wpCurrent->origin[1] ||
+		(int)goalpos[2] != (int)bs->wpCurrent->origin[2])
+	{
+		return 0;
+	}
+
+	VectorCopy(bs->origin, xybot);
+	VectorCopy(bs->wpCurrent->origin, xywp);
+
+	xybot[2] = 0;
+	xywp[2] = 0;
+
+	VectorSubtract(xybot, xywp, a);
+
+	if (VectorLength(a) < 16 && bs->frame_Waypoint_Len > 100)
+	{
+		if (CheckForFunc(bs->origin, bs->client))
+		{
+			return 1; //we're probably standing on an elevator and riding up/down. Or at least we hope so.
+		}
+	}
+	else if (VectorLength(a) < 64 && bs->frame_Waypoint_Len > 64 &&
+		CheckForFunc(bs->origin, bs->client))
+	{
+		bs->noUseTime = level.time + 2000;
+	}
+
+	return 0;
+}
+
+//get an ideal distance for us to be at in relation to our opponent
+//based on our weapon.
+int BotGetWeaponRange(bot_state_t *bs)
+{
+	switch (bs->cur_ps.weapon)
+	{
+	case WP_STUN_BATON:
+	case WP_MELEE:
+		return BWEAPONRANGE_MELEE;
+	case WP_SABER:
+		return BWEAPONRANGE_SABER;
+	case WP_BRYAR_PISTOL:
+		return BWEAPONRANGE_MID;
+	case WP_BLASTER:
+		return BWEAPONRANGE_MID;
+	case WP_DISRUPTOR:
+		return BWEAPONRANGE_MID;
+	case WP_BOWCASTER:
+		return BWEAPONRANGE_LONG;
+	case WP_REPEATER:
+		return BWEAPONRANGE_MID;
+	case WP_DEMP2:
+		return BWEAPONRANGE_LONG;
+	case WP_FLECHETTE:
+		return BWEAPONRANGE_LONG;
+	case WP_ROCKET_LAUNCHER:
+		return BWEAPONRANGE_LONG;
+	case WP_THERMAL:
+		return BWEAPONRANGE_LONG;
+	case WP_TRIP_MINE:
+		return BWEAPONRANGE_LONG;
+	case WP_DET_PACK:
+		return BWEAPONRANGE_LONG;
+	default:
+		return BWEAPONRANGE_MID;
+	}
+}
+
+//see if we want to run away from the opponent for whatever reason
+int BotIsAChickenWuss(bot_state_t *bs)
+{
+	int bWRange;
+
+	if (gLevelFlags & LEVELFLAG_IMUSTNTRUNAWAY)
+	{ //The level says we mustn't run away!
+		return 0;
+	}
+
+	if (g_gametype.integer == GT_SINGLE_PLAYER)
+	{ //"coop" (not really)
+		return 0;
+	}
+
+	if (g_gametype.integer == GT_JEDIMASTER && !bs->cur_ps.isJediMaster)
+	{ //Then you may know no fear.
+		//Well, unless he's strong.
+		if (bs->currentEnemy && bs->currentEnemy->client &&
+			bs->currentEnemy->client->ps.isJediMaster &&
+			bs->currentEnemy->health > 40 &&
+			bs->cur_ps.weapon < WP_ROCKET_LAUNCHER)
+		{ //explosive weapons are most effective against the Jedi Master
+			goto jmPass;
+		}
+		return 0;
+	}
+
+	if (g_gametype.integer == GT_CTF && bs->currentEnemy && bs->currentEnemy->client)
+	{
+		if (bs->currentEnemy->client->ps.powerups[PW_REDFLAG] ||
+			bs->currentEnemy->client->ps.powerups[PW_BLUEFLAG])
+		{ //don't be afraid of flag carriers, they must die!
+			return 0;
+		}
+	}
+
+jmPass:
+	if (bs->chickenWussCalculationTime > level.time)
+	{
+		return 2; //don't want to keep going between two points...
+	}
+
+	if (bs->cur_ps.fd.forcePowersActive & (1 << FP_RAGE))
+	{ //don't run while raging
+		return 0;
+	}
+
+	if (g_gametype.integer == GT_JEDIMASTER && !bs->cur_ps.isJediMaster)
+	{ //be frightened of the jedi master? I guess in this case.
+		return 1;
+	}
+
+	bs->chickenWussCalculationTime = level.time + MAX_CHICKENWUSS_TIME;
+
+	if (g_entities[bs->client].health < BOT_RUN_HEALTH)
+	{ //we're low on health, let's get away
+		return 1;
+	}
+
+	bWRange = BotGetWeaponRange(bs);
+
+	if (bWRange == BWEAPONRANGE_MELEE || bWRange == BWEAPONRANGE_SABER)
+	{
+		if (bWRange != BWEAPONRANGE_SABER || !bs->saberSpecialist)
+		{ //run away if we're using melee, or if we're using a saber and not a "saber specialist"
+			return 1;
+		}
+	}
+
+	if (bs->cur_ps.weapon == WP_BRYAR_PISTOL)
+	{ //the bryar is a weak weapon, so just try to find a new one if it's what you're having to use
+		return 1;
+	}
+
+	if (bs->currentEnemy && bs->currentEnemy->client &&
+		bs->currentEnemy->client->ps.weapon == WP_SABER &&
+		bs->frame_Enemy_Len < 512 && bs->cur_ps.weapon != WP_SABER)
+	{ //if close to an enemy with a saber and not using a saber, then try to back off
+		return 1;
+	}
+
+	if ((level.time-bs->cur_ps.electrifyTime) < 16000)
+	{ //lightning is dangerous.
+		return 1;
+	}
+
+	//didn't run, reset the timer
+	bs->chickenWussCalculationTime = 0;
+
+	return 0;
+}
+
+//look for "bad things". bad things include detpacks, thermal detonators,
+//and other dangerous explodey items.
+gentity_t *GetNearestBadThing(bot_state_t *bs)
+{
+	int i = 0;
+	float glen;
+	vec3_t hold;
+	int bestindex = 0;
+	float bestdist = 800; //if not within a radius of 800, it's no threat anyway
+	int foundindex = 0;
+	float factor = 0;
+	gentity_t *ent;
+	trace_t tr;
+
+	while (i < level.num_entities)
+	{
+		ent = &g_entities[i];
+
+		if ( (ent &&
+			!ent->client &&
+			ent->inuse &&
+			ent->damage &&
+			/*(ent->s.weapon == WP_THERMAL || ent->s.weapon == WP_FLECHETTE)*/
+			ent->s.weapon &&
+			ent->splashDamage) ||
+			(ent &&
+			ent->genericValue5 == 1000 &&
+			ent->inuse &&
+			ent->health > 0 &&
+			ent->genericValue3 != bs->client &&
+			g_entities[ent->genericValue3].client && !OnSameTeam(&g_entities[bs->client], &g_entities[ent->genericValue3])) )
+		{ //try to escape from anything with a non-0 s.weapon and non-0 damage. This hopefully only means dangerous projectiles.
+		  //Or a sentry gun if bolt_Head == 1000. This is a terrible hack, yes.
+			VectorSubtract(bs->origin, ent->r.currentOrigin, hold);
+			glen = VectorLength(hold);
+
+			if (ent->s.weapon != WP_THERMAL && ent->s.weapon != WP_FLECHETTE &&
+				ent->s.weapon != WP_DET_PACK && ent->s.weapon != WP_TRIP_MINE)
+			{
+				factor = 0.5;
+
+				if (ent->s.weapon && glen <= 256 && bs->settings.skill > 2)
+				{ //it's a projectile so push it away
+					bs->doForcePush = level.time + 700;
+					//G_Printf("PUSH PROJECTILE\n");
+				}
+			}
+			else
+			{
+				factor = 1;
+			}
+
+			if (ent->s.weapon == WP_ROCKET_LAUNCHER &&
+				(ent->r.ownerNum == bs->client ||
+				(ent->r.ownerNum > 0 && ent->r.ownerNum < MAX_CLIENTS &&
+				g_entities[ent->r.ownerNum].client && OnSameTeam(&g_entities[bs->client], &g_entities[ent->r.ownerNum]))) )
+			{ //don't be afraid of your own rockets or your teammates' rockets
+				factor = 0;
+			}
+
+			if (glen < bestdist*factor && BotPVSCheck(bs->origin, ent->s.pos.trBase))
+			{
+				trap_Trace(&tr, bs->origin, NULL, NULL, ent->s.pos.trBase, bs->client, MASK_SOLID);
+
+				if (tr.fraction == 1 || tr.entityNum == ent->s.number)
+				{
+					bestindex = i;
+					bestdist = glen;
+					foundindex = 1;
+				}
+			}
+		}
+
+		if (ent && !ent->client && ent->inuse && ent->damage && ent->s.weapon && ent->r.ownerNum < MAX_CLIENTS && ent->r.ownerNum >= 0)
+		{ //if we're in danger of a projectile belonging to someone and don't have an enemy, set the enemy to them
+			gentity_t *projOwner = &g_entities[ent->r.ownerNum];
+
+			if (projOwner && projOwner->inuse && projOwner->client)
+			{
+				if (!bs->currentEnemy)
+				{
+					if (PassStandardEnemyChecks(bs, projOwner))
+					{
+						if (PassLovedOneCheck(bs, projOwner))
+						{
+							VectorSubtract(bs->origin, ent->r.currentOrigin, hold);
+							glen = VectorLength(hold);
+
+							if (glen < 512)
+							{
+								bs->currentEnemy = projOwner;
+								bs->enemySeenTime = level.time + ENEMY_FORGET_MS;
+							}
+						}
+					}
+				}
+			}
+		}
+
+		i++;
+	}
+
+	if (foundindex)
+	{
+		bs->dontGoBack = level.time + 1500;
+		return &g_entities[bestindex];
+	}
+	else
+	{
+		return NULL;
+	}
+}
+
+//Keep our CTF priorities on defending our team's flag
+int BotDefendFlag(bot_state_t *bs)
+{
+	wpobject_t *flagPoint;
+	vec3_t a;
+
+	if (level.clients[bs->client].sess.sessionTeam == TEAM_RED)
+	{
+		flagPoint = flagRed;
+	}
+	else if (level.clients[bs->client].sess.sessionTeam == TEAM_BLUE)
+	{
+		flagPoint = flagBlue;
+	}
+	else
+	{
+		return 0;
+	}
+
+	if (!flagPoint)
+	{
+		return 0;
+	}
+
+	VectorSubtract(bs->origin, flagPoint->origin, a);
+
+	if (VectorLength(a) > BASE_GUARD_DISTANCE)
+	{
+		bs->wpDestination = flagPoint;
+	}
+
+	return 1;
+}
+
+//Keep our CTF priorities on getting the other team's flag
+int BotGetEnemyFlag(bot_state_t *bs)
+{
+	wpobject_t *flagPoint;
+	vec3_t a;
+
+	if (level.clients[bs->client].sess.sessionTeam == TEAM_RED)
+	{
+		flagPoint = flagBlue;
+	}
+	else if (level.clients[bs->client].sess.sessionTeam == TEAM_BLUE)
+	{
+		flagPoint = flagRed;
+	}
+	else
+	{
+		return 0;
+	}
+
+	if (!flagPoint)
+	{
+		return 0;
+	}
+
+	VectorSubtract(bs->origin, flagPoint->origin, a);
+
+	if (VectorLength(a) > BASE_GETENEMYFLAG_DISTANCE)
+	{
+		bs->wpDestination = flagPoint;
+	}
+
+	return 1;
+}
+
+//Our team's flag is gone, so try to get it back
+int BotGetFlagBack(bot_state_t *bs)
+{
+	int i = 0;
+	int myFlag = 0;
+	int foundCarrier = 0;
+	int tempInt = 0;
+	gentity_t *ent = NULL;
+	vec3_t usethisvec;
+
+	if (level.clients[bs->client].sess.sessionTeam == TEAM_RED)
+	{
+		myFlag = PW_REDFLAG;
+	}
+	else
+	{
+		myFlag = PW_BLUEFLAG;
+	}
+
+	while (i < MAX_CLIENTS)
+	{
+		ent = &g_entities[i];
+
+		if (ent && ent->client && ent->client->ps.powerups[myFlag] && !OnSameTeam(&g_entities[bs->client], ent))
+		{
+			foundCarrier = 1;
+			break;
+		}
+
+		i++;
+	}
+
+	if (!foundCarrier)
+	{
+		return 0;
+	}
+
+	if (!ent)
+	{
+		return 0;
+	}
+
+	if (bs->wpDestSwitchTime < level.time)
+	{
+		if (ent->client)
+		{
+			VectorCopy(ent->client->ps.origin, usethisvec);
+		}
+		else
+		{
+			VectorCopy(ent->s.origin, usethisvec);
+		}
+
+		tempInt = GetNearestVisibleWP(usethisvec, 0);
+
+		if (tempInt != -1 && TotalTrailDistance(bs->wpCurrent->index, tempInt, bs) != -1)
+		{
+			bs->wpDestination = gWPArray[tempInt];
+			bs->wpDestSwitchTime = level.time + Q_irand(1000, 5000);
+		}
+	}
+
+	return 1;
+}
+
+//Someone else on our team has the enemy flag, so try to get
+//to their assistance
+int BotGuardFlagCarrier(bot_state_t *bs)
+{
+	int i = 0;
+	int enemyFlag = 0;
+	int foundCarrier = 0;
+	int tempInt = 0;
+	gentity_t *ent = NULL;
+	vec3_t usethisvec;
+
+	if (level.clients[bs->client].sess.sessionTeam == TEAM_RED)
+	{
+		enemyFlag = PW_BLUEFLAG;
+	}
+	else
+	{
+		enemyFlag = PW_REDFLAG;
+	}
+
+	while (i < MAX_CLIENTS)
+	{
+		ent = &g_entities[i];
+
+		if (ent && ent->client && ent->client->ps.powerups[enemyFlag] && OnSameTeam(&g_entities[bs->client], ent))
+		{
+			foundCarrier = 1;
+			break;
+		}
+
+		i++;
+	}
+
+	if (!foundCarrier)
+	{
+		return 0;
+	}
+
+	if (!ent)
+	{
+		return 0;
+	}
+
+	if (bs->wpDestSwitchTime < level.time)
+	{
+		if (ent->client)
+		{
+			VectorCopy(ent->client->ps.origin, usethisvec);
+		}
+		else
+		{
+			VectorCopy(ent->s.origin, usethisvec);
+		}
+
+		tempInt = GetNearestVisibleWP(usethisvec, 0);
+
+		if (tempInt != -1 && TotalTrailDistance(bs->wpCurrent->index, tempInt, bs) != -1)
+		{
+			bs->wpDestination = gWPArray[tempInt];
+			bs->wpDestSwitchTime = level.time + Q_irand(1000, 5000);
+		}
+	}
+
+	return 1;
+}
+
+//We have the flag, let's get it home.
+int BotGetFlagHome(bot_state_t *bs)
+{
+	wpobject_t *flagPoint;
+	vec3_t a;
+
+	if (level.clients[bs->client].sess.sessionTeam == TEAM_RED)
+	{
+		flagPoint = flagRed;
+	}
+	else if (level.clients[bs->client].sess.sessionTeam == TEAM_BLUE)
+	{
+		flagPoint = flagBlue;
+	}
+	else
+	{
+		return 0;
+	}
+
+	if (!flagPoint)
+	{
+		return 0;
+	}
+
+	VectorSubtract(bs->origin, flagPoint->origin, a);
+
+	if (VectorLength(a) > BASE_FLAGWAIT_DISTANCE)
+	{
+		bs->wpDestination = flagPoint;
+	}
+
+	return 1;
+}
+
+void GetNewFlagPoint(wpobject_t *wp, gentity_t *flagEnt, int team)
+{ //get the nearest possible waypoint to the flag since it's not in its original position
+	int i = 0;
+	vec3_t a, mins, maxs;
+	float bestdist;
+	float testdist;
+	int bestindex = 0;
+	int foundindex = 0;
+	trace_t tr;
+
+	mins[0] = -15;
+	mins[1] = -15;
+	mins[2] = -5;
+	maxs[0] = 15;
+	maxs[1] = 15;
+	maxs[2] = 5;
+
+	VectorSubtract(wp->origin, flagEnt->s.pos.trBase, a);
+
+	bestdist = VectorLength(a);
+
+	if (bestdist <= WP_KEEP_FLAG_DIST)
+	{
+		trap_Trace(&tr, wp->origin, mins, maxs, flagEnt->s.pos.trBase, flagEnt->s.number, MASK_SOLID);
+
+		if (tr.fraction == 1)
+		{ //this point is good
+			return;
+		}
+	}
+
+	while (i < gWPNum)
+	{
+		VectorSubtract(gWPArray[i]->origin, flagEnt->s.pos.trBase, a);
+		testdist = VectorLength(a);
+
+		if (testdist < bestdist)
+		{
+			trap_Trace(&tr, gWPArray[i]->origin, mins, maxs, flagEnt->s.pos.trBase, flagEnt->s.number, MASK_SOLID);
+
+			if (tr.fraction == 1)
+			{
+				foundindex = 1;
+				bestindex = i;
+				bestdist = testdist;
+			}
+		}
+
+		i++;
+	}
+
+	if (foundindex)
+	{
+		if (team == TEAM_RED)
+		{
+			flagRed = gWPArray[bestindex];
+		}
+		else
+		{
+			flagBlue = gWPArray[bestindex];
+		}
+	}
+}
+
+//See if our CTF state should take priority in our nav routines
+int CTFTakesPriority(bot_state_t *bs)
+{
+	gentity_t *ent = NULL;
+	int enemyFlag = 0;
+	int myFlag = 0;
+	int enemyHasOurFlag = 0;
+	int weHaveEnemyFlag = 0;
+	int numOnMyTeam = 0;
+	int numOnEnemyTeam = 0;
+	int numAttackers = 0;
+	int numDefenders = 0;
+	int i = 0;
+	int idleWP;
+	int dosw = 0;
+	wpobject_t *dest_sw = NULL;
+#ifdef BOT_CTF_DEBUG
+	vec3_t t;
+
+	G_Printf("CTFSTATE: %s\n", ctfStateNames[bs->ctfState]);
+#endif
+
+	if (g_gametype.integer != GT_CTF && g_gametype.integer != GT_CTY)
+	{
+		return 0;
+	}
+
+	if (bs->cur_ps.weapon == WP_BRYAR_PISTOL &&
+		(level.time - bs->lastDeadTime) < BOT_MAX_WEAPON_GATHER_TIME)
+	{ //get the nearest weapon laying around base before heading off for battle
+		idleWP = GetBestIdleGoal(bs);
+
+		if (idleWP != -1 && gWPArray[idleWP] && gWPArray[idleWP]->inuse)
+		{
+			if (bs->wpDestSwitchTime < level.time)
+			{
+				bs->wpDestination = gWPArray[idleWP];
+			}
+			return 1;
+		}
+	}
+	else if (bs->cur_ps.weapon == WP_BRYAR_PISTOL &&
+		(level.time - bs->lastDeadTime) < BOT_MAX_WEAPON_CHASE_CTF &&
+		bs->wpDestination && bs->wpDestination->weight)
+	{
+		dest_sw = bs->wpDestination;
+		dosw = 1;
+	}
+
+	if (level.clients[bs->client].sess.sessionTeam == TEAM_RED)
+	{
+		myFlag = PW_REDFLAG;
+	}
+	else
+	{
+		myFlag = PW_BLUEFLAG;
+	}
+
+	if (level.clients[bs->client].sess.sessionTeam == TEAM_RED)
+	{
+		enemyFlag = PW_BLUEFLAG;
+	}
+	else
+	{
+		enemyFlag = PW_REDFLAG;
+	}
+
+	if (!flagRed || !flagBlue ||
+		!flagRed->inuse || !flagBlue->inuse ||
+		!eFlagRed || !eFlagBlue)
+	{
+		return 0;
+	}
+
+#ifdef BOT_CTF_DEBUG
+	VectorCopy(flagRed->origin, t);
+	t[2] += 128;
+	G_TestLine(flagRed->origin, t, 0x0000ff, 500);
+
+	VectorCopy(flagBlue->origin, t);
+	t[2] += 128;
+	G_TestLine(flagBlue->origin, t, 0x0000ff, 500);
+#endif
+
+	if (droppedRedFlag && (droppedRedFlag->flags & FL_DROPPED_ITEM))
+	{
+		GetNewFlagPoint(flagRed, droppedRedFlag, TEAM_RED);
+	}
+	else
+	{
+		flagRed = oFlagRed;
+	}
+
+	if (droppedBlueFlag && (droppedBlueFlag->flags & FL_DROPPED_ITEM))
+	{
+		GetNewFlagPoint(flagBlue, droppedBlueFlag, TEAM_BLUE);
+	}
+	else
+	{
+		flagBlue = oFlagBlue;
+	}
+
+	if (!bs->ctfState)
+	{
+		return 0;
+	}
+
+	i = 0;
+
+	while (i < MAX_CLIENTS)
+	{
+		ent = &g_entities[i];
+
+		if (ent && ent->client)
+		{
+			if (ent->client->ps.powerups[enemyFlag] && OnSameTeam(&g_entities[bs->client], ent))
+			{
+				weHaveEnemyFlag = 1;
+			}
+			else if (ent->client->ps.powerups[myFlag] && !OnSameTeam(&g_entities[bs->client], ent))
+			{
+				enemyHasOurFlag = 1;
+			}
+
+			if (OnSameTeam(&g_entities[bs->client], ent))
+			{
+				numOnMyTeam++;
+			}
+			else
+			{
+				numOnEnemyTeam++;
+			}
+
+			if (botstates[ent->s.number])
+			{
+				if (botstates[ent->s.number]->ctfState == CTFSTATE_ATTACKER ||
+					botstates[ent->s.number]->ctfState == CTFSTATE_RETRIEVAL)
+				{
+					numAttackers++;
+				}
+				else
+				{
+					numDefenders++;
+				}
+			}
+			else
+			{ //assume real players to be attackers in our logic
+				numAttackers++;
+			}
+		}
+		i++;
+	}
+
+	if (bs->cur_ps.powerups[enemyFlag])
+	{
+		if ((numOnMyTeam < 2 || !numAttackers) && enemyHasOurFlag)
+		{
+			bs->ctfState = CTFSTATE_RETRIEVAL;
+		}
+		else
+		{
+			bs->ctfState = CTFSTATE_GETFLAGHOME;
+		}
+	}
+	else if (bs->ctfState == CTFSTATE_GETFLAGHOME)
+	{
+		bs->ctfState = 0;
+	}
+
+	if (bs->state_Forced)
+	{
+		bs->ctfState = bs->state_Forced;
+	}
+
+	if (bs->ctfState == CTFSTATE_DEFENDER)
+	{
+		if (BotDefendFlag(bs))
+		{
+			goto success;
+		}
+	}
+
+	if (bs->ctfState == CTFSTATE_ATTACKER)
+	{
+		if (BotGetEnemyFlag(bs))
+		{
+			goto success;
+		}
+	}
+
+	if (bs->ctfState == CTFSTATE_RETRIEVAL)
+	{
+		if (BotGetFlagBack(bs))
+		{
+			goto success;
+		}
+		else
+		{ //can't find anyone on another team being a carrier, so ignore this priority
+			bs->ctfState = 0;
+		}
+	}
+
+	if (bs->ctfState == CTFSTATE_GUARDCARRIER)
+	{
+		if (BotGuardFlagCarrier(bs))
+		{
+			goto success;
+		}
+		else
+		{ //can't find anyone on our team being a carrier, so ignore this priority
+			bs->ctfState = 0;
+		}
+	}
+
+	if (bs->ctfState == CTFSTATE_GETFLAGHOME)
+	{
+		if (BotGetFlagHome(bs))
+		{
+			goto success;
+		}
+	}
+
+	return 0;
+
+success:
+	if (dosw)
+	{ //allow ctf code to run, but if after a particular item then keep going after it
+		bs->wpDestination = dest_sw;
+	}
+
+	return 1;
+}
+
+int EntityVisibleBox(vec3_t org1, vec3_t mins, vec3_t maxs, vec3_t org2, int ignore, int ignore2)
+{
+	trace_t tr;
+
+	trap_Trace(&tr, org1, mins, maxs, org2, ignore, MASK_SOLID);
+
+	if (tr.fraction == 1 && !tr.startsolid && !tr.allsolid)
+	{
+		return 1;
+	}
+	else if (tr.entityNum != ENTITYNUM_NONE && tr.entityNum == ignore2)
+	{
+		return 1;
+	}
+
+	return 0;
+}
+
+//Get the closest objective for siege and go after it
+int Siege_TargetClosestObjective(bot_state_t *bs, int flag)
+{
+	int i = 0;
+	int bestindex = -1;
+	float testdistance = 0;
+	float bestdistance = 999999999;
+	gentity_t *goalent;
+	vec3_t a, dif;
+	vec3_t mins, maxs;
+
+	mins[0] = -1;
+	mins[1] = -1;
+	mins[2] = -1;
+
+	maxs[0] = 1;
+	maxs[1] = 1;
+	maxs[2] = 1;
+
+	if ( bs->wpDestination && (bs->wpDestination->flags & flag) && bs->wpDestination->associated_entity != ENTITYNUM_NONE &&
+		 &g_entities[bs->wpDestination->associated_entity] && g_entities[bs->wpDestination->associated_entity].use )
+	{
+		goto hasPoint;
+	}
+
+	while (i < gWPNum)
+	{
+		if ( gWPArray[i] && gWPArray[i]->inuse && (gWPArray[i]->flags & flag) && gWPArray[i]->associated_entity != ENTITYNUM_NONE &&
+			 &g_entities[gWPArray[i]->associated_entity] && g_entities[gWPArray[i]->associated_entity].use )
+		{
+			VectorSubtract(gWPArray[i]->origin, bs->origin, a);
+			testdistance = VectorLength(a);
+
+			if (testdistance < bestdistance)
+			{
+				bestdistance = testdistance;
+				bestindex = i;
+			}
+		}
+
+		i++;
+	}
+
+	if (bestindex != -1)
+	{
+		bs->wpDestination = gWPArray[bestindex];
+	}
+	else
+	{
+		return 0;
+	}
+hasPoint:
+	goalent = &g_entities[bs->wpDestination->associated_entity];
+
+	if (!goalent)
+	{
+		return 0;
+	}
+
+	VectorSubtract(bs->origin, bs->wpDestination->origin, a);
+
+	testdistance = VectorLength(a);
+
+	dif[0] = (goalent->r.absmax[0]+goalent->r.absmin[0])/2;
+	dif[1] = (goalent->r.absmax[1]+goalent->r.absmin[1])/2;
+	dif[2] = (goalent->r.absmax[2]+goalent->r.absmin[2])/2;
+	//brush models can have tricky origins, so this is our hacky method of getting the center point
+
+	if (goalent->takedamage && testdistance < BOT_MIN_SIEGE_GOAL_SHOOT &&
+		EntityVisibleBox(bs->origin, mins, maxs, dif, bs->client, goalent->s.number))
+	{
+		bs->shootGoal = goalent;
+		bs->touchGoal = NULL;
+	}
+	else if (goalent->use && testdistance < BOT_MIN_SIEGE_GOAL_TRAVEL)
+	{
+		bs->shootGoal = NULL;
+		bs->touchGoal = goalent;
+	}
+	else
+	{ //don't know how to handle this goal object!
+		bs->shootGoal = NULL;
+		bs->touchGoal = NULL;
+	}
+
+	if (BotGetWeaponRange(bs) == BWEAPONRANGE_MELEE ||
+		BotGetWeaponRange(bs) == BWEAPONRANGE_SABER)
+	{
+		bs->shootGoal = NULL; //too risky
+	}
+
+	if (bs->touchGoal)
+	{
+		//G_Printf("Please, master, let me touch it!\n");
+		VectorCopy(dif, bs->goalPosition);
+	}
+
+	return 1;
+}
+
+void Siege_DefendFromAttackers(bot_state_t *bs)
+{ //this may be a little cheap, but the best way to find our defending point is probably
+  //to just find the nearest person on the opposing team since they'll most likely
+  //be on offense in this situation
+	int wpClose = -1;
+	int i = 0;
+	float testdist = 999999;
+	int bestindex = -1;
+	float bestdist = 999999;
+	gentity_t *ent;
+	vec3_t a;
+
+	while (i < MAX_CLIENTS)
+	{
+		ent = &g_entities[i];
+
+		if (ent && ent->client && ent->client->sess.sessionTeam != g_entities[bs->client].client->sess.sessionTeam &&
+			ent->health > 0 && ent->client->sess.sessionTeam != TEAM_SPECTATOR)
+		{
+			VectorSubtract(ent->client->ps.origin, bs->origin, a);
+
+			testdist = VectorLength(a);
+
+			if (testdist < bestdist)
+			{
+				bestindex = i;
+				bestdist = testdist;
+			}
+		}
+
+		i++;
+	}
+
+	if (bestindex == -1)
+	{
+		return;
+	}
+
+	wpClose = GetNearestVisibleWP(g_entities[bestindex].client->ps.origin, -1);	
+
+	if (wpClose != -1 && gWPArray[wpClose] && gWPArray[wpClose]->inuse)
+	{
+		bs->wpDestination = gWPArray[wpClose];
+		bs->destinationGrabTime = level.time + 10000;
+	}
+}
+
+//how many defenders on our team?
+int Siege_CountDefenders(bot_state_t *bs)
+{
+	int i = 0;
+	int num = 0;
+	gentity_t *ent;
+	bot_state_t *bot;
+
+	while (i < MAX_CLIENTS)
+	{
+		ent = &g_entities[i];
+		bot = botstates[i];
+
+		if (ent && ent->client && bot)
+		{
+			if (bot->siegeState == SIEGESTATE_DEFENDER &&
+				ent->client->sess.sessionTeam == g_entities[bs->client].client->sess.sessionTeam)
+			{
+				num++;
+			}
+		}
+
+		i++;
+	}
+
+	return num;
+}
+
+//how many other players on our team?
+int Siege_CountTeammates(bot_state_t *bs)
+{
+	int i = 0;
+	int num = 0;
+	gentity_t *ent;
+
+	while (i < MAX_CLIENTS)
+	{
+		ent = &g_entities[i];
+
+		if (ent && ent->client)
+		{
+			if (ent->client->sess.sessionTeam == g_entities[bs->client].client->sess.sessionTeam)
+			{
+				num++;
+			}
+		}
+
+		i++;
+	}
+
+	return num;
+}
+
+//see if siege objective completion should take priority in our
+//nav routines.
+int SiegeTakesPriority(bot_state_t *bs)
+{
+	int attacker;
+	int flagForDefendableObjective;
+	int flagForAttackableObjective;
+	int defenders, teammates;
+	int idleWP;
+	wpobject_t *dest_sw = NULL;
+	int dosw = 0;
+	gclient_t *bcl;
+	vec3_t dif;
+	trace_t tr;
+
+	if (g_gametype.integer != GT_SIEGE)
+	{
+		return 0;
+	}
+
+	bcl = g_entities[bs->client].client;
+
+	if (!bcl)
+	{
+		return 0;
+	}
+
+	if (bs->cur_ps.weapon == WP_BRYAR_PISTOL &&
+		(level.time - bs->lastDeadTime) < BOT_MAX_WEAPON_GATHER_TIME)
+	{ //get the nearest weapon laying around base before heading off for battle
+		idleWP = GetBestIdleGoal(bs);
+
+		if (idleWP != -1 && gWPArray[idleWP] && gWPArray[idleWP]->inuse)
+		{
+			if (bs->wpDestSwitchTime < level.time)
+			{
+				bs->wpDestination = gWPArray[idleWP];
+			}
+			return 1;
+		}
+	}
+	else if (bs->cur_ps.weapon == WP_BRYAR_PISTOL &&
+		(level.time - bs->lastDeadTime) < BOT_MAX_WEAPON_CHASE_TIME &&
+		bs->wpDestination && bs->wpDestination->weight)
+	{
+		dest_sw = bs->wpDestination;
+		dosw = 1;
+	}
+
+	if (bcl->sess.sessionTeam == SIEGETEAM_TEAM1)
+	{
+		attacker = imperial_attackers;
+		flagForDefendableObjective = WPFLAG_SIEGE_REBELOBJ;
+		flagForAttackableObjective = WPFLAG_SIEGE_IMPERIALOBJ;
+	}
+	else
+	{
+		attacker = rebel_attackers;
+		flagForDefendableObjective = WPFLAG_SIEGE_IMPERIALOBJ;
+		flagForAttackableObjective = WPFLAG_SIEGE_REBELOBJ;
+	}
+
+	if (attacker)
+	{
+		bs->siegeState = SIEGESTATE_ATTACKER;
+	}
+	else
+	{
+		bs->siegeState = SIEGESTATE_DEFENDER;
+		defenders = Siege_CountDefenders(bs);
+		teammates = Siege_CountTeammates(bs);
+
+		if (defenders > teammates/3 && teammates > 1)
+		{ //devote around 1/4 of our team to completing our own side goals even if we're a defender.
+		  //If we have no side goals we will realize that later on and join the defenders
+			bs->siegeState = SIEGESTATE_ATTACKER;
+		}
+	}
+
+	if (bs->state_Forced)
+	{
+		bs->siegeState = bs->state_Forced;
+	}
+
+	if (bs->siegeState == SIEGESTATE_ATTACKER)
+	{
+		if (!Siege_TargetClosestObjective(bs, flagForAttackableObjective))
+		{ //looks like we have no goals other than to keep the other team from completing objectives
+			Siege_DefendFromAttackers(bs);
+			if (bs->shootGoal)
+			{
+				dif[0] = (bs->shootGoal->r.absmax[0]+bs->shootGoal->r.absmin[0])/2;
+				dif[1] = (bs->shootGoal->r.absmax[1]+bs->shootGoal->r.absmin[1])/2;
+				dif[2] = (bs->shootGoal->r.absmax[2]+bs->shootGoal->r.absmin[2])/2;
+				
+				if (!BotPVSCheck(bs->origin, dif))
+				{
+					bs->shootGoal = NULL;
+				}
+				else
+				{
+					trap_Trace(&tr, bs->origin, NULL, NULL, dif, bs->client, MASK_SOLID);
+
+					if (tr.fraction != 1 && tr.entityNum != bs->shootGoal->s.number)
+					{
+						bs->shootGoal = NULL;
+					}
+				}
+			}
+		}
+	}
+	else if (bs->siegeState == SIEGESTATE_DEFENDER)
+	{
+		Siege_DefendFromAttackers(bs);
+		if (bs->shootGoal)
+		{
+			dif[0] = (bs->shootGoal->r.absmax[0]+bs->shootGoal->r.absmin[0])/2;
+			dif[1] = (bs->shootGoal->r.absmax[1]+bs->shootGoal->r.absmin[1])/2;
+			dif[2] = (bs->shootGoal->r.absmax[2]+bs->shootGoal->r.absmin[2])/2;
+				
+			if (!BotPVSCheck(bs->origin, dif))
+			{
+				bs->shootGoal = NULL;
+			}
+			else
+			{
+				trap_Trace(&tr, bs->origin, NULL, NULL, dif, bs->client, MASK_SOLID);
+
+				if (tr.fraction != 1 && tr.entityNum != bs->shootGoal->s.number)
+				{
+					bs->shootGoal = NULL;
+				}
+			}
+		}
+	}
+	else
+	{ //get busy!
+		Siege_TargetClosestObjective(bs, flagForAttackableObjective);
+		if (bs->shootGoal)
+		{
+			dif[0] = (bs->shootGoal->r.absmax[0]+bs->shootGoal->r.absmin[0])/2;
+			dif[1] = (bs->shootGoal->r.absmax[1]+bs->shootGoal->r.absmin[1])/2;
+			dif[2] = (bs->shootGoal->r.absmax[2]+bs->shootGoal->r.absmin[2])/2;
+				
+			if (!BotPVSCheck(bs->origin, dif))
+			{
+				bs->shootGoal = NULL;
+			}
+			else
+			{
+				trap_Trace(&tr, bs->origin, NULL, NULL, dif, bs->client, MASK_SOLID);
+
+				if (tr.fraction != 1 && tr.entityNum != bs->shootGoal->s.number)
+				{
+					bs->shootGoal = NULL;
+				}
+			}
+		}
+	}
+
+	if (dosw)
+	{ //allow siege objective code to run, but if after a particular item then keep going after it
+		bs->wpDestination = dest_sw;
+	}
+
+	return 1;
+}
+
+//see if jedi master priorities should take priority in our nav
+//routines.
+int JMTakesPriority(bot_state_t *bs)
+{
+	int i = 0;
+	int wpClose = -1;
+	gentity_t *theImportantEntity = NULL;
+
+	if (g_gametype.integer != GT_JEDIMASTER)
+	{
+		return 0;
+	}
+
+	if (bs->cur_ps.isJediMaster)
+	{
+		return 0;
+	}
+
+	//jmState becomes the index for the one who carries the saber. If jmState is -1 then the saber is currently
+	//without an owner
+	bs->jmState = -1;
+
+	while (i < MAX_CLIENTS)
+	{
+		if (g_entities[i].client && g_entities[i].inuse &&
+			g_entities[i].client->ps.isJediMaster)
+		{
+			bs->jmState = i;
+			break;
+		}
+
+		i++;
+	}
+
+	if (bs->jmState != -1)
+	{
+		theImportantEntity = &g_entities[bs->jmState];
+	}
+	else
+	{
+		theImportantEntity = gJMSaberEnt;
+	}
+
+	if (theImportantEntity && theImportantEntity->inuse && bs->destinationGrabTime < level.time)
+	{
+		if (theImportantEntity->client)
+		{
+			wpClose = GetNearestVisibleWP(theImportantEntity->client->ps.origin, theImportantEntity->s.number);	
+		}
+		else
+		{
+			wpClose = GetNearestVisibleWP(theImportantEntity->r.currentOrigin, theImportantEntity->s.number);	
+		}
+
+		if (wpClose != -1 && gWPArray[wpClose] && gWPArray[wpClose]->inuse)
+		{
+			/*
+			Com_Printf("BOT GRABBED IDEAL JM LOCATION\n");
+			if (bs->wpDestination != gWPArray[wpClose])
+			{
+				Com_Printf("IDEAL WAS NOT ALREADY IDEAL\n");
+
+				if (!bs->wpDestination)
+				{
+					Com_Printf("IDEAL WAS NULL\n");
+				}
+			}
+			*/
+			bs->wpDestination = gWPArray[wpClose];
+			bs->destinationGrabTime = level.time + 4000;
+		}
+	}
+
+	return 1;
+}
+
+//see if we already have an item/powerup/etc. that is associated
+//with this waypoint.
+int BotHasAssociated(bot_state_t *bs, wpobject_t *wp)
+{
+	gentity_t *as;
+
+	if (wp->associated_entity == ENTITYNUM_NONE)
+	{ //make it think this is an item we have so we don't go after nothing
+		return 1;
+	}
+
+	as = &g_entities[wp->associated_entity];
+
+	if (!as || !as->item)
+	{
+		return 0;
+	}
+
+	if (as->item->giType == IT_WEAPON)
+	{
+		if (bs->cur_ps.stats[STAT_WEAPONS] & (1 << as->item->giTag))
+		{
+			return 1;
+		}
+
+		return 0;
+	}
+	else if (as->item->giType == IT_HOLDABLE)
+	{
+		if (bs->cur_ps.stats[STAT_HOLDABLE_ITEMS] & (1 << as->item->giTag))
+		{
+			return 1;
+		}
+
+		return 0;
+	}
+	else if (as->item->giType == IT_POWERUP)
+	{
+		if (bs->cur_ps.powerups[as->item->giTag])
+		{
+			return 1;
+		}
+
+		return 0;
+	}
+	else if (as->item->giType == IT_AMMO)
+	{
+		if (bs->cur_ps.ammo[as->item->giTag] > 10) //hack
+		{
+			return 1;
+		}
+
+		return 0;
+	}
+
+	return 0;
+}
+
+//we don't really have anything we want to do right now,
+//let's just find the best thing to do given the current
+//situation.
+int GetBestIdleGoal(bot_state_t *bs)
+{
+	int i = 0;
+	int highestweight = 0;
+	int desiredindex = -1;
+	int dist_to_weight = 0;
+	int traildist;
+
+	if (!bs->wpCurrent)
+	{
+		return -1;
+	}
+
+	if (bs->isCamper != 2)
+	{
+		if (bs->randomNavTime < level.time)
+		{
+			if (Q_irand(1, 10) < 5)
+			{
+				bs->randomNav = 1;
+			}
+			else
+			{
+				bs->randomNav = 0;
+			}
+			
+			bs->randomNavTime = level.time + Q_irand(5000, 15000);
+		}
+	}
+
+	if (bs->randomNav)
+	{ //stop looking for items and/or camping on them
+		return -1;
+	}
+
+	while (i < gWPNum)
+	{
+		if (gWPArray[i] &&
+			gWPArray[i]->inuse &&
+			(gWPArray[i]->flags & WPFLAG_GOALPOINT) &&
+			gWPArray[i]->weight > highestweight &&
+			!BotHasAssociated(bs, gWPArray[i]))
+		{
+			traildist = TotalTrailDistance(bs->wpCurrent->index, i, bs);
+
+			if (traildist != -1)
+			{
+				dist_to_weight = (int)traildist/10000;
+				dist_to_weight = (gWPArray[i]->weight)-dist_to_weight;
+
+				if (dist_to_weight > highestweight)
+				{
+					highestweight = dist_to_weight;
+					desiredindex = i;
+				}
+			}
+		}
+
+		i++;
+	}
+
+	return desiredindex;
+}
+
+//go through the list of possible priorities for navigating
+//and work out the best destination point.
+void GetIdealDestination(bot_state_t *bs)
+{
+	int tempInt, cWPIndex, bChicken, idleWP;
+	float distChange, plusLen, minusLen;
+	vec3_t usethisvec, a;
+	gentity_t *badthing;
+
+#ifdef _DEBUG
+	trap_Cvar_Update(&bot_nogoals);
+
+	if (bot_nogoals.integer)
+	{
+		return;
+	}
+#endif
+
+	if (!bs->wpCurrent)
+	{
+		return;
+	}
+
+	if ((level.time - bs->escapeDirTime) > 4000)
+	{
+		badthing = GetNearestBadThing(bs);
+	}
+	else
+	{
+		badthing = NULL;
+	}
+
+	if (badthing && badthing->inuse &&
+		badthing->health > 0 && badthing->takedamage)
+	{
+		bs->dangerousObject = badthing;
+	}
+	else
+	{
+		bs->dangerousObject = NULL;
+	}
+
+	if (!badthing && bs->wpDestIgnoreTime > level.time)
+	{
+		return;
+	}
+
+	if (!badthing && bs->dontGoBack > level.time)
+	{
+		if (bs->wpDestination)
+		{
+			bs->wpStoreDest = bs->wpDestination;
+		}
+		bs->wpDestination = NULL;
+		return;
+	}
+	else if (!badthing && bs->wpStoreDest)
+	{ //after we finish running away, switch back to our original destination
+		bs->wpDestination = bs->wpStoreDest;
+		bs->wpStoreDest = NULL;
+	}
+
+	if (badthing && bs->wpCamping)
+	{
+		bs->wpCamping = NULL;
+	}
+
+	if (bs->wpCamping)
+	{
+		bs->wpDestination = bs->wpCamping;
+		return;
+	}
+
+	if (!badthing && CTFTakesPriority(bs))
+	{
+		if (bs->ctfState)
+		{
+			bs->runningToEscapeThreat = 1;
+		}
+		return;
+	}
+	else if (!badthing && SiegeTakesPriority(bs))
+	{
+		if (bs->siegeState)
+		{
+			bs->runningToEscapeThreat = 1;
+		}
+		return;
+	}
+	else if (!badthing && JMTakesPriority(bs))
+	{
+		bs->runningToEscapeThreat = 1;
+	}
+
+	if (badthing)
+	{
+		bs->runningLikeASissy = level.time + 100;
+
+		if (bs->wpDestination)
+		{
+			bs->wpStoreDest = bs->wpDestination;
+		}
+		bs->wpDestination = NULL;
+
+		if (bs->wpDirection)
+		{
+			tempInt = bs->wpCurrent->index+1;
+		}
+		else
+		{
+			tempInt = bs->wpCurrent->index-1;
+		}
+
+		if (gWPArray[tempInt] && gWPArray[tempInt]->inuse && bs->escapeDirTime < level.time)
+		{
+			VectorSubtract(badthing->s.pos.trBase, bs->wpCurrent->origin, a);
+			plusLen = VectorLength(a);
+			VectorSubtract(badthing->s.pos.trBase, gWPArray[tempInt]->origin, a);
+			minusLen = VectorLength(a);
+
+			if (plusLen < minusLen)
+			{
+				if (bs->wpDirection)
+				{
+					bs->wpDirection = 0;
+				}
+				else
+				{
+					bs->wpDirection = 1;
+				}
+
+				bs->wpCurrent = gWPArray[tempInt];
+
+				bs->escapeDirTime = level.time + Q_irand(500, 1000);//Q_irand(1000, 1400);
+
+				//G_Printf("Escaping from scary bad thing [%s]\n", badthing->classname);
+			}
+		}
+		//G_Printf("Run away run away run away!\n");
+		return;
+	}
+
+	distChange = 0; //keep the compiler from complaining
+
+	tempInt = BotGetWeaponRange(bs);
+
+	if (tempInt == BWEAPONRANGE_MELEE)
+	{
+		distChange = 1;
+	}
+	else if (tempInt == BWEAPONRANGE_SABER)
+	{
+		distChange = 1;
+	}
+	else if (tempInt == BWEAPONRANGE_MID)
+	{
+		distChange = 128;
+	}
+	else if (tempInt == BWEAPONRANGE_LONG)
+	{
+		distChange = 300;
+	}
+
+	if (bs->revengeEnemy && bs->revengeEnemy->health > 0 &&
+		bs->revengeEnemy->client && (bs->revengeEnemy->client->pers.connected == CA_ACTIVE || bs->revengeEnemy->client->pers.connected == CA_AUTHORIZING))
+	{ //if we hate someone, always try to get to them
+		if (bs->wpDestSwitchTime < level.time)
+		{
+			if (bs->revengeEnemy->client)
+			{
+				VectorCopy(bs->revengeEnemy->client->ps.origin, usethisvec);
+			}
+			else
+			{
+				VectorCopy(bs->revengeEnemy->s.origin, usethisvec);
+			}
+
+			tempInt = GetNearestVisibleWP(usethisvec, 0);
+
+			if (tempInt != -1 && TotalTrailDistance(bs->wpCurrent->index, tempInt, bs) != -1)
+			{
+				bs->wpDestination = gWPArray[tempInt];
+				bs->wpDestSwitchTime = level.time + Q_irand(5000, 10000);
+			}
+		}
+	}
+	else if (bs->squadLeader && bs->squadLeader->health > 0 &&
+		bs->squadLeader->client && (bs->squadLeader->client->pers.connected == CA_ACTIVE || bs->squadLeader->client->pers.connected == CA_AUTHORIZING))
+	{
+		if (bs->wpDestSwitchTime < level.time)
+		{
+			if (bs->squadLeader->client)
+			{
+				VectorCopy(bs->squadLeader->client->ps.origin, usethisvec);
+			}
+			else
+			{
+				VectorCopy(bs->squadLeader->s.origin, usethisvec);
+			}
+
+			tempInt = GetNearestVisibleWP(usethisvec, 0);
+
+			if (tempInt != -1 && TotalTrailDistance(bs->wpCurrent->index, tempInt, bs) != -1)
+			{
+				bs->wpDestination = gWPArray[tempInt];
+				bs->wpDestSwitchTime = level.time + Q_irand(5000, 10000);
+			}
+		}
+	}
+	else if (bs->currentEnemy)
+	{
+		if (bs->currentEnemy->client)
+		{
+			VectorCopy(bs->currentEnemy->client->ps.origin, usethisvec);
+		}
+		else
+		{
+			VectorCopy(bs->currentEnemy->s.origin, usethisvec);
+		}
+
+		bChicken = BotIsAChickenWuss(bs);
+		bs->runningToEscapeThreat = bChicken;
+
+		if (bs->frame_Enemy_Len < distChange || (bChicken && bChicken != 2))
+		{
+			cWPIndex = bs->wpCurrent->index;
+
+			if (bs->frame_Enemy_Len > 400)
+			{ //good distance away, start running toward a good place for an item or powerup or whatever
+				idleWP = GetBestIdleGoal(bs);
+
+				if (idleWP != -1 && gWPArray[idleWP] && gWPArray[idleWP]->inuse)
+				{
+					bs->wpDestination = gWPArray[idleWP];
+				}
+			}
+			else if (gWPArray[cWPIndex-1] && gWPArray[cWPIndex-1]->inuse &&
+				gWPArray[cWPIndex+1] && gWPArray[cWPIndex+1]->inuse)
+			{
+				VectorSubtract(gWPArray[cWPIndex+1]->origin, usethisvec, a);
+				plusLen = VectorLength(a);
+				VectorSubtract(gWPArray[cWPIndex-1]->origin, usethisvec, a);
+				minusLen = VectorLength(a);
+
+				if (minusLen > plusLen)
+				{
+					bs->wpDestination = gWPArray[cWPIndex-1];
+				}
+				else
+				{
+					bs->wpDestination = gWPArray[cWPIndex+1];
+				}
+			}
+		}
+		else if (bChicken != 2 && bs->wpDestSwitchTime < level.time)
+		{
+			tempInt = GetNearestVisibleWP(usethisvec, 0);
+
+			if (tempInt != -1 && TotalTrailDistance(bs->wpCurrent->index, tempInt, bs) != -1)
+			{
+				bs->wpDestination = gWPArray[tempInt];
+
+				if (g_gametype.integer == GT_SINGLE_PLAYER)
+				{ //be more aggressive
+					bs->wpDestSwitchTime = level.time + Q_irand(300, 1000);
+				}
+				else
+				{
+					bs->wpDestSwitchTime = level.time + Q_irand(1000, 5000);
+				}
+			}
+		}
+	}
+
+	if (!bs->wpDestination && bs->wpDestSwitchTime < level.time)
+	{
+		//G_Printf("I need something to do\n");
+		idleWP = GetBestIdleGoal(bs);
+
+		if (idleWP != -1 && gWPArray[idleWP] && gWPArray[idleWP]->inuse)
+		{
+			bs->wpDestination = gWPArray[idleWP];
+		}
+	}
+}
+
+//commander CTF AI - tell other bots in the so-called
+//"squad" what to do.
+void CommanderBotCTFAI(bot_state_t *bs)
+{
+	int i = 0;
+	gentity_t *ent;
+	int squadmates = 0;
+	gentity_t *squad[MAX_CLIENTS];
+	int defendAttackPriority = 0; //0 == attack, 1 == defend
+	int guardDefendPriority = 0; //0 == defend, 1 == guard
+	int attackRetrievePriority = 0; //0 == retrieve, 1 == attack
+	int myFlag = 0;
+	int enemyFlag = 0;
+	int enemyHasOurFlag = 0;
+	int weHaveEnemyFlag = 0;
+	int numOnMyTeam = 0;
+	int numOnEnemyTeam = 0;
+	int numAttackers = 0;
+	int numDefenders = 0;
+
+	if (level.clients[bs->client].sess.sessionTeam == TEAM_RED)
+	{
+		myFlag = PW_REDFLAG;
+	}
+	else
+	{
+		myFlag = PW_BLUEFLAG;
+	}
+
+	if (level.clients[bs->client].sess.sessionTeam == TEAM_RED)
+	{
+		enemyFlag = PW_BLUEFLAG;
+	}
+	else
+	{
+		enemyFlag = PW_REDFLAG;
+	}
+
+	while (i < MAX_CLIENTS)
+	{
+		ent = &g_entities[i];
+
+		if (ent && ent->client)
+		{
+			if (ent->client->ps.powerups[enemyFlag] && OnSameTeam(&g_entities[bs->client], ent))
+			{
+				weHaveEnemyFlag = 1;
+			}
+			else if (ent->client->ps.powerups[myFlag] && !OnSameTeam(&g_entities[bs->client], ent))
+			{
+				enemyHasOurFlag = 1;
+			}
+
+			if (OnSameTeam(&g_entities[bs->client], ent))
+			{
+				numOnMyTeam++;
+			}
+			else
+			{
+				numOnEnemyTeam++;
+			}
+
+			if (botstates[ent->s.number])
+			{
+				if (botstates[ent->s.number]->ctfState == CTFSTATE_ATTACKER ||
+					botstates[ent->s.number]->ctfState == CTFSTATE_RETRIEVAL)
+				{
+					numAttackers++;
+				}
+				else
+				{
+					numDefenders++;
+				}
+			}
+			else
+			{ //assume real players to be attackers in our logic
+				numAttackers++;
+			}
+		}
+		i++;
+	}
+
+	i = 0;
+
+	while (i < MAX_CLIENTS)
+	{
+		ent = &g_entities[i];
+
+		if (ent && ent->client && botstates[i] && botstates[i]->squadLeader && botstates[i]->squadLeader->s.number == bs->client && i != bs->client)
+		{
+			squad[squadmates] = ent;
+			squadmates++;
+		}
+
+		i++;
+	}
+
+	squad[squadmates] = &g_entities[bs->client];
+	squadmates++;
+
+	i = 0;
+
+	if (enemyHasOurFlag && !weHaveEnemyFlag)
+	{ //start off with an attacker instead of a retriever if we don't have the enemy flag yet so that they can't capture it first.
+	  //after that we focus on getting our flag back.
+		attackRetrievePriority = 1;
+	}
+
+	while (i < squadmates)
+	{
+		if (squad[i] && squad[i]->client && botstates[squad[i]->s.number])
+		{
+			if (botstates[squad[i]->s.number]->ctfState != CTFSTATE_GETFLAGHOME)
+			{ //never tell a bot to stop trying to bring the flag to the base
+				if (defendAttackPriority)
+				{
+					if (weHaveEnemyFlag)
+					{
+						if (guardDefendPriority)
+						{
+							botstates[squad[i]->s.number]->ctfState = CTFSTATE_GUARDCARRIER;
+							guardDefendPriority = 0;
+						}
+						else
+						{
+							botstates[squad[i]->s.number]->ctfState = CTFSTATE_DEFENDER;
+							guardDefendPriority = 1;
+						}
+					}
+					else
+					{
+						botstates[squad[i]->s.number]->ctfState = CTFSTATE_DEFENDER;
+					}
+					defendAttackPriority = 0;
+				}
+				else
+				{
+					if (enemyHasOurFlag)
+					{
+						if (attackRetrievePriority)
+						{
+							botstates[squad[i]->s.number]->ctfState = CTFSTATE_ATTACKER;
+							attackRetrievePriority = 0;
+						}
+						else
+						{
+							botstates[squad[i]->s.number]->ctfState = CTFSTATE_RETRIEVAL;
+							attackRetrievePriority = 1;
+						}
+					}
+					else
+					{
+						botstates[squad[i]->s.number]->ctfState = CTFSTATE_ATTACKER;
+					}
+					defendAttackPriority = 1;
+				}
+			}
+			else if ((numOnMyTeam < 2 || !numAttackers) && enemyHasOurFlag)
+			{ //I'm the only one on my team who will attack and the enemy has my flag, I have to go after him
+				botstates[squad[i]->s.number]->ctfState = CTFSTATE_RETRIEVAL;
+			}
+		}
+
+		i++;
+	}
+}
+
+//similar to ctf ai, for siege
+void CommanderBotSiegeAI(bot_state_t *bs)
+{
+	int i = 0;
+	int squadmates = 0;
+	int commanded = 0;
+	int teammates = 0;
+	gentity_t *squad[MAX_CLIENTS];
+	gentity_t *ent;
+	bot_state_t *bst;
+
+	while (i < MAX_CLIENTS)
+	{
+		ent = &g_entities[i];
+
+		if (ent && ent->client && OnSameTeam(&g_entities[bs->client], ent) && botstates[ent->s.number])
+		{
+			bst = botstates[ent->s.number];
+
+			if (bst && !bst->isSquadLeader && !bst->state_Forced)
+			{
+				squad[squadmates] = ent;
+				squadmates++;
+			}
+			else if (bst && !bst->isSquadLeader && bst->state_Forced)
+			{ //count them as commanded
+				commanded++;
+			}
+		}
+
+		if (ent && ent->client && OnSameTeam(&g_entities[bs->client], ent))
+		{
+			teammates++;
+		}
+
+		i++;
+	}
+	
+	if (!squadmates)
+	{
+		return;
+	}
+
+	//tell squad mates to do what I'm doing, up to half of team, let the other half make their own decisions
+	i = 0;
+
+	while (i < squadmates && squad[i])
+	{
+		bst = botstates[squad[i]->s.number];
+
+		if (commanded > teammates/2)
+		{
+			break;
+		}
+
+		if (bst)
+		{
+			bst->state_Forced = bs->siegeState;
+			bst->siegeState = bs->siegeState;
+			commanded++;
+		}
+
+		i++;
+	}
+}
+
+//teamplay ffa squad ai
+void BotDoTeamplayAI(bot_state_t *bs)
+{
+	if (bs->state_Forced)
+	{
+		bs->teamplayState = bs->state_Forced;
+	}
+
+	if (bs->teamplayState == TEAMPLAYSTATE_REGROUP)
+	{ //force to find a new leader
+		bs->squadLeader = NULL;
+		bs->isSquadLeader = 0;
+	}
+}
+
+//like ctf and siege commander ai, instruct the squad
+void CommanderBotTeamplayAI(bot_state_t *bs)
+{
+	int i = 0;
+	int squadmates = 0;
+	int teammates = 0;
+	int teammate_indanger = -1;
+	int teammate_helped = 0;
+	int foundsquadleader = 0;
+	int worsthealth = 50;
+	gentity_t *squad[MAX_CLIENTS];
+	gentity_t *ent;
+	bot_state_t *bst;
+
+	while (i < MAX_CLIENTS)
+	{
+		ent = &g_entities[i];
+
+		if (ent && ent->client && OnSameTeam(&g_entities[bs->client], ent) && botstates[ent->s.number])
+		{
+			bst = botstates[ent->s.number];
+
+			if (foundsquadleader && bst && bst->isSquadLeader)
+			{ //never more than one squad leader
+				bst->isSquadLeader = 0;
+			}
+
+			if (bst && !bst->isSquadLeader)
+			{
+				squad[squadmates] = ent;
+				squadmates++;
+			}
+			else if (bst)
+			{
+				foundsquadleader = 1;
+			}
+		}
+
+		if (ent && ent->client && OnSameTeam(&g_entities[bs->client], ent))
+		{
+			teammates++;
+
+			if (ent->health < worsthealth)
+			{
+				teammate_indanger = ent->s.number;
+				worsthealth = ent->health;
+			}
+		}
+
+		i++;
+	}
+	
+	if (!squadmates)
+	{
+		return;
+	}
+
+	i = 0;
+
+	while (i < squadmates && squad[i])
+	{
+		bst = botstates[squad[i]->s.number];
+
+		if (bst && !bst->state_Forced)
+		{ //only order if this guy is not being ordered directly by the real player team leader
+			if (teammate_indanger >= 0 && !teammate_helped)
+			{ //send someone out to help whoever needs help most at the moment
+				bst->teamplayState = TEAMPLAYSTATE_ASSISTING;
+				bst->squadLeader = &g_entities[teammate_indanger];
+				teammate_helped = 1;
+			}
+			else if ((teammate_indanger == -1 || teammate_helped) && bst->teamplayState == TEAMPLAYSTATE_ASSISTING)
+			{ //no teammates need help badly, but this guy is trying to help them anyway, so stop
+				bst->teamplayState = TEAMPLAYSTATE_FOLLOWING;
+				bst->squadLeader = &g_entities[bs->client];
+			}
+
+			if (bs->squadRegroupInterval < level.time && Q_irand(1, 10) < 5)
+			{ //every so often tell the squad to regroup for the sake of variation
+				if (bst->teamplayState == TEAMPLAYSTATE_FOLLOWING)
+				{
+					bst->teamplayState = TEAMPLAYSTATE_REGROUP;
+				}
+
+				bs->isSquadLeader = 0;
+				bs->squadCannotLead = level.time + 500;
+				bs->squadRegroupInterval = level.time + Q_irand(45000, 65000);
+			}
+		}
+
+		i++;
+	}	
+}
+
+//pick which commander ai to use based on gametype
+void CommanderBotAI(bot_state_t *bs)
+{
+	if (g_gametype.integer == GT_CTF || g_gametype.integer == GT_CTY)
+	{
+		CommanderBotCTFAI(bs);
+	}
+	else if (g_gametype.integer == GT_SIEGE)
+	{
+		CommanderBotSiegeAI(bs);
+	}
+	else if (g_gametype.integer == GT_TEAM)
+	{
+		CommanderBotTeamplayAI(bs);
+	}
+}
+
+//close range combat routines
+void MeleeCombatHandling(bot_state_t *bs)
+{
+	vec3_t usethisvec;
+	vec3_t downvec;
+	vec3_t midorg;
+	vec3_t a;
+	vec3_t fwd;
+	vec3_t mins, maxs;
+	trace_t tr;
+	int en_down;
+	int me_down;
+	int mid_down;
+
+	if (!bs->currentEnemy)
+	{
+		return;
+	}
+
+	if (bs->currentEnemy->client)
+	{
+		VectorCopy(bs->currentEnemy->client->ps.origin, usethisvec);
+	}
+	else
+	{
+		VectorCopy(bs->currentEnemy->s.origin, usethisvec);
+	}
+
+	if (bs->meleeStrafeTime < level.time)
+	{
+		if (bs->meleeStrafeDir)
+		{
+			bs->meleeStrafeDir = 0;
+		}
+		else
+		{
+			bs->meleeStrafeDir = 1;
+		}
+
+		bs->meleeStrafeTime = level.time + Q_irand(500, 1800);
+	}
+
+	mins[0] = -15;
+	mins[1] = -15;
+	mins[2] = -24;
+	maxs[0] = 15;
+	maxs[1] = 15;
+	maxs[2] = 32;
+
+	VectorCopy(usethisvec, downvec);
+	downvec[2] -= 4096;
+
+	trap_Trace(&tr, usethisvec, mins, maxs, downvec, -1, MASK_SOLID);
+
+	en_down = (int)tr.endpos[2];
+
+	VectorCopy(bs->origin, downvec);
+	downvec[2] -= 4096;
+
+	trap_Trace(&tr, bs->origin, mins, maxs, downvec, -1, MASK_SOLID);
+
+	me_down = (int)tr.endpos[2];
+
+	VectorSubtract(usethisvec, bs->origin, a);
+	vectoangles(a, a);
+	AngleVectors(a, fwd, NULL, NULL);
+
+	midorg[0] = bs->origin[0] + fwd[0]*bs->frame_Enemy_Len/2;
+	midorg[1] = bs->origin[1] + fwd[1]*bs->frame_Enemy_Len/2;
+	midorg[2] = bs->origin[2] + fwd[2]*bs->frame_Enemy_Len/2;
+
+	VectorCopy(midorg, downvec);
+	downvec[2] -= 4096;
+
+	trap_Trace(&tr, midorg, mins, maxs, downvec, -1, MASK_SOLID);
+
+	mid_down = (int)tr.endpos[2];
+
+	if (me_down == en_down &&
+		en_down == mid_down)
+	{
+		VectorCopy(usethisvec, bs->goalPosition);
+	}
+}
+
+//saber combat routines (it's simple, but it works)
+void SaberCombatHandling(bot_state_t *bs)
+{
+	vec3_t usethisvec;
+	vec3_t downvec;
+	vec3_t midorg;
+	vec3_t a;
+	vec3_t fwd;
+	vec3_t mins, maxs;
+	trace_t tr;
+	int en_down;
+	int me_down;
+	int mid_down;
+
+	if (!bs->currentEnemy)
+	{
+		return;
+	}
+
+	if (bs->currentEnemy->client)
+	{
+		VectorCopy(bs->currentEnemy->client->ps.origin, usethisvec);
+	}
+	else
+	{
+		VectorCopy(bs->currentEnemy->s.origin, usethisvec);
+	}
+
+	if (bs->meleeStrafeTime < level.time)
+	{
+		if (bs->meleeStrafeDir)
+		{
+			bs->meleeStrafeDir = 0;
+		}
+		else
+		{
+			bs->meleeStrafeDir = 1;
+		}
+
+		bs->meleeStrafeTime = level.time + Q_irand(500, 1800);
+	}
+
+	mins[0] = -15;
+	mins[1] = -15;
+	mins[2] = -24;
+	maxs[0] = 15;
+	maxs[1] = 15;
+	maxs[2] = 32;
+
+	VectorCopy(usethisvec, downvec);
+	downvec[2] -= 4096;
+
+	trap_Trace(&tr, usethisvec, mins, maxs, downvec, -1, MASK_SOLID);
+
+	en_down = (int)tr.endpos[2];
+
+	if (tr.startsolid || tr.allsolid)
+	{
+		en_down = 1;
+		me_down = 2;
+	}
+	else
+	{
+		VectorCopy(bs->origin, downvec);
+		downvec[2] -= 4096;
+
+		trap_Trace(&tr, bs->origin, mins, maxs, downvec, -1, MASK_SOLID);
+
+		me_down = (int)tr.endpos[2];
+
+		if (tr.startsolid || tr.allsolid)
+		{
+			en_down = 1;
+			me_down = 2;
+		}
+	}
+
+	VectorSubtract(usethisvec, bs->origin, a);
+	vectoangles(a, a);
+	AngleVectors(a, fwd, NULL, NULL);
+
+	midorg[0] = bs->origin[0] + fwd[0]*bs->frame_Enemy_Len/2;
+	midorg[1] = bs->origin[1] + fwd[1]*bs->frame_Enemy_Len/2;
+	midorg[2] = bs->origin[2] + fwd[2]*bs->frame_Enemy_Len/2;
+
+	VectorCopy(midorg, downvec);
+	downvec[2] -= 4096;
+
+	trap_Trace(&tr, midorg, mins, maxs, downvec, -1, MASK_SOLID);
+
+	mid_down = (int)tr.endpos[2];
+
+	if (me_down == en_down &&
+		en_down == mid_down)
+	{
+		if (usethisvec[2] > (bs->origin[2]+32) &&
+			bs->currentEnemy->client &&
+			bs->currentEnemy->client->ps.groundEntityNum == ENTITYNUM_NONE)
+		{
+			bs->jumpTime = level.time + 100;
+		}
+
+		if (bs->frame_Enemy_Len > 128)
+		{ //be ready to attack
+			bs->saberDefending = 0;
+			bs->saberDefendDecideTime = level.time + Q_irand(1000, 2000);
+		}
+		else
+		{
+			if (bs->saberDefendDecideTime < level.time)
+			{
+				if (bs->saberDefending)
+				{
+					bs->saberDefending = 0;
+				}
+				else
+				{
+					bs->saberDefending = 1;
+				}
+
+				bs->saberDefendDecideTime = level.time + Q_irand(500, 2000);
+			}
+		}
+
+		if (bs->frame_Enemy_Len < 54)
+		{
+			VectorCopy(bs->origin, bs->goalPosition);
+			bs->saberBFTime = 0;
+		}
+		else
+		{
+			VectorCopy(usethisvec, bs->goalPosition);
+		}
+
+		if (bs->currentEnemy && bs->currentEnemy->client)
+		{
+			if (!BG_SaberInSpecial(bs->currentEnemy->client->ps.saberMove) && bs->frame_Enemy_Len > 90 && bs->saberBFTime > level.time && bs->saberBTime > level.time && bs->beStill < level.time && bs->saberSTime < level.time)
+			{
+				bs->beStill = level.time + Q_irand(500, 1000);
+				bs->saberSTime = level.time + Q_irand(1200, 1800);
+			}
+			else if (bs->currentEnemy->client->ps.weapon == WP_SABER && bs->frame_Enemy_Len < 80 && (Q_irand(1, 10) < 8 && bs->saberBFTime < level.time) || bs->saberBTime > level.time || BG_SaberInKata(bs->currentEnemy->client->ps.saberMove) || bs->currentEnemy->client->ps.saberMove == LS_SPINATTACK || bs->currentEnemy->client->ps.saberMove == LS_SPINATTACK_DUAL)
+			{
+				vec3_t vs;
+				vec3_t groundcheck;
+				int idealDist;
+				int checkIncr = 0;
+
+				VectorSubtract(bs->origin, usethisvec, vs);
+				VectorNormalize(vs);
+
+				if (BG_SaberInKata(bs->currentEnemy->client->ps.saberMove) || bs->currentEnemy->client->ps.saberMove == LS_SPINATTACK || bs->currentEnemy->client->ps.saberMove == LS_SPINATTACK_DUAL)
+				{
+					idealDist = 256;
+				}
+				else
+				{
+					idealDist = 64;
+				}
+
+				while (checkIncr < idealDist)
+				{
+					bs->goalPosition[0] = bs->origin[0] + vs[0]*checkIncr;
+					bs->goalPosition[1] = bs->origin[1] + vs[1]*checkIncr;
+					bs->goalPosition[2] = bs->origin[2] + vs[2]*checkIncr;
+
+					if (bs->saberBTime < level.time)
+					{
+						bs->saberBFTime = level.time + Q_irand(900, 1300);
+						bs->saberBTime = level.time + Q_irand(300, 700);
+					}
+
+					VectorCopy(bs->goalPosition, groundcheck);
+
+					groundcheck[2] -= 64;
+
+					trap_Trace(&tr, bs->goalPosition, NULL, NULL, groundcheck, bs->client, MASK_SOLID);
+					
+					if (tr.fraction == 1.0f)
+					{ //don't back off of a ledge
+						VectorCopy(usethisvec, bs->goalPosition);
+						break;
+					}
+					checkIncr += 64;
+				}
+			}
+			else if (bs->currentEnemy->client->ps.weapon == WP_SABER && bs->frame_Enemy_Len >= 75)
+			{
+				bs->saberBFTime = level.time + Q_irand(700, 1300);
+				bs->saberBTime = 0;
+			}
+		}
+
+		/*AngleVectors(bs->viewangles, NULL, fwd, NULL);
+
+		if (bs->meleeStrafeDir)
+		{
+			bs->goalPosition[0] += fwd[0]*16;
+			bs->goalPosition[1] += fwd[1]*16;
+			bs->goalPosition[2] += fwd[2]*16;
+		}
+		else
+		{
+			bs->goalPosition[0] -= fwd[0]*16;
+			bs->goalPosition[1] -= fwd[1]*16;
+			bs->goalPosition[2] -= fwd[2]*16;
+		}*/
+	}
+	else if (bs->frame_Enemy_Len <= 56)
+	{
+		bs->doAttack = 1;
+		bs->saberDefending = 0;
+	}
+}
+
+//should we be "leading" our aim with this weapon? And if
+//so, by how much?
+float BotWeaponCanLead(bot_state_t *bs)
+{
+	int weap = bs->cur_ps.weapon;
+
+	if (weap == WP_BRYAR_PISTOL)
+	{
+		return 0.5;
+	}
+	if (weap == WP_BLASTER)
+	{
+		return 0.35;
+	}
+	if (weap == WP_BOWCASTER)
+	{
+		return 0.5;
+	}
+	if (weap == WP_REPEATER)
+	{
+		return 0.45;
+	}
+	if (weap == WP_THERMAL)
+	{
+		return 0.5;
+	}
+	if (weap == WP_DEMP2)
+	{
+		return 0.35;
+	}
+	if (weap == WP_ROCKET_LAUNCHER)
+	{
+		return 0.7;
+	}
+	
+	return 0;
+}
+
+//offset the desired view angles with aim leading in mind
+void BotAimLeading(bot_state_t *bs, vec3_t headlevel, float leadAmount)
+{
+	int x;
+	vec3_t predictedSpot;
+	vec3_t movementVector;
+	vec3_t a, ang;
+	float vtotal;
+
+	if (!bs->currentEnemy ||
+		!bs->currentEnemy->client)
+	{
+		return;
+	}
+
+	if (!bs->frame_Enemy_Len)
+	{
+		return;
+	}
+
+	vtotal = 0;
+
+	if (bs->currentEnemy->client->ps.velocity[0] < 0)
+	{
+		vtotal += -bs->currentEnemy->client->ps.velocity[0];
+	}
+	else
+	{
+		vtotal += bs->currentEnemy->client->ps.velocity[0];
+	}
+
+	if (bs->currentEnemy->client->ps.velocity[1] < 0)
+	{
+		vtotal += -bs->currentEnemy->client->ps.velocity[1];
+	}
+	else
+	{
+		vtotal += bs->currentEnemy->client->ps.velocity[1];
+	}
+
+	if (bs->currentEnemy->client->ps.velocity[2] < 0)
+	{
+		vtotal += -bs->currentEnemy->client->ps.velocity[2];
+	}
+	else
+	{
+		vtotal += bs->currentEnemy->client->ps.velocity[2];
+	}
+
+	//G_Printf("Leadin target with a velocity total of %f\n", vtotal);
+
+	VectorCopy(bs->currentEnemy->client->ps.velocity, movementVector);
+
+	VectorNormalize(movementVector);
+
+	x = bs->frame_Enemy_Len*leadAmount; //hardly calculated with an exact science, but it works
+
+	if (vtotal > 400)
+	{
+		vtotal = 400;
+	}
+
+	if (vtotal)
+	{
+		x = (bs->frame_Enemy_Len*0.9)*leadAmount*(vtotal*0.0012); //hardly calculated with an exact science, but it works
+	}
+	else
+	{
+		x = (bs->frame_Enemy_Len*0.9)*leadAmount; //hardly calculated with an exact science, but it works
+	}
+
+	predictedSpot[0] = headlevel[0] + (movementVector[0]*x);
+	predictedSpot[1] = headlevel[1] + (movementVector[1]*x);
+	predictedSpot[2] = headlevel[2] + (movementVector[2]*x);
+
+	VectorSubtract(predictedSpot, bs->eye, a);
+	vectoangles(a, ang);
+	VectorCopy(ang, bs->goalAngles);
+}
+
+//wobble our aim around based on our sk1llz
+void BotAimOffsetGoalAngles(bot_state_t *bs)
+{
+	int i;
+	float accVal;
+	i = 0;
+
+	if (bs->skills.perfectaim)
+	{
+		return;
+	}
+
+	if (bs->aimOffsetTime > level.time)
+	{
+		if (bs->aimOffsetAmtYaw)
+		{
+			bs->goalAngles[YAW] += bs->aimOffsetAmtYaw;
+		}
+
+		if (bs->aimOffsetAmtPitch)
+		{
+			bs->goalAngles[PITCH] += bs->aimOffsetAmtPitch;
+		}
+		
+		while (i <= 2)
+		{
+			if (bs->goalAngles[i] > 360)
+			{
+				bs->goalAngles[i] -= 360;
+			}
+
+			if (bs->goalAngles[i] < 0)
+			{
+				bs->goalAngles[i] += 360;
+			}
+
+			i++;
+		}
+		return;
+	}
+
+	accVal = bs->skills.accuracy/bs->settings.skill;
+
+	if (bs->currentEnemy && BotMindTricked(bs->client, bs->currentEnemy->s.number))
+	{ //having to judge where they are by hearing them, so we should be quite inaccurate here
+		accVal *= 7;
+
+		if (accVal < 30)
+		{
+			accVal = 30;
+		}
+	}
+
+	if (bs->revengeEnemy && bs->revengeHateLevel &&
+		bs->currentEnemy == bs->revengeEnemy)
+	{ //bot becomes more skilled as anger level raises
+		accVal = accVal/bs->revengeHateLevel;
+	}
+
+	if (bs->currentEnemy && bs->frame_Enemy_Vis)
+	{ //assume our goal is aiming at the enemy, seeing as he's visible and all
+		if (!bs->currentEnemy->s.pos.trDelta[0] &&
+			!bs->currentEnemy->s.pos.trDelta[1] &&
+			!bs->currentEnemy->s.pos.trDelta[2])
+		{
+			accVal = 0; //he's not even moving, so he shouldn't really be hard to hit.
+		}
+		else
+		{
+			accVal += accVal*0.25; //if he's moving he's this much harder to hit
+		}
+
+		if (g_entities[bs->client].s.pos.trDelta[0] ||
+			g_entities[bs->client].s.pos.trDelta[1] ||
+			g_entities[bs->client].s.pos.trDelta[2])
+		{
+			accVal += accVal*0.15; //make it somewhat harder to aim if we're moving also
+		}
+	}
+
+	if (accVal > 90)
+	{
+		accVal = 90;
+	}
+	if (accVal < 1)
+	{
+		accVal = 0;
+	}
+
+	if (!accVal)
+	{
+		bs->aimOffsetAmtYaw = 0;
+		bs->aimOffsetAmtPitch = 0;
+		return;
+	}
+
+	if (rand()%10 <= 5)
+	{
+		bs->aimOffsetAmtYaw = rand()%(int)accVal;
+	}
+	else
+	{
+		bs->aimOffsetAmtYaw = -(rand()%(int)accVal);
+	}
+
+	if (rand()%10 <= 5)
+	{
+		bs->aimOffsetAmtPitch = rand()%(int)accVal;
+	}
+	else
+	{
+		bs->aimOffsetAmtPitch = -(rand()%(int)accVal);
+	}
+
+	bs->aimOffsetTime = level.time + rand()%500 + 200;
+}
+
+//do we want to alt fire with this weapon?
+int ShouldSecondaryFire(bot_state_t *bs)
+{
+	int weap;
+	int dif;
+	float rTime;
+
+	weap = bs->cur_ps.weapon;
+
+	if (bs->cur_ps.ammo[weaponData[weap].ammoIndex] < weaponData[weap].altEnergyPerShot)
+	{
+		return 0;
+	}
+
+	if (bs->cur_ps.weaponstate == WEAPON_CHARGING_ALT && bs->cur_ps.weapon == WP_ROCKET_LAUNCHER)
+	{
+		float heldTime = (level.time - bs->cur_ps.weaponChargeTime);
+
+		rTime = bs->cur_ps.rocketLockTime;
+
+		if (rTime < 1)
+		{
+			rTime = bs->cur_ps.rocketLastValidTime;
+		}
+
+		if (heldTime > 5000)
+		{ //just give up and release it if we can't manage a lock in 5 seconds
+			return 2;
+		}
+
+		if (rTime > 0)
+		{
+			dif = ( level.time - rTime ) / ( 1200.0f / 16.0f );
+			
+			if (dif >= 10)
+			{
+				return 2;
+			}
+			else if (bs->frame_Enemy_Len > 250)
+			{
+				return 1;
+			}
+		}
+		else if (bs->frame_Enemy_Len > 250)
+		{
+			return 1;
+		}
+	}
+	else if ((bs->cur_ps.weaponstate == WEAPON_CHARGING_ALT) && (level.time - bs->cur_ps.weaponChargeTime) > bs->altChargeTime)
+	{
+		return 2;
+	}
+	else if (bs->cur_ps.weaponstate == WEAPON_CHARGING_ALT)
+	{
+		return 1;
+	}
+
+	if (weap == WP_BRYAR_PISTOL && bs->frame_Enemy_Len < 300)
+	{
+		return 1;
+	}
+	else if (weap == WP_BOWCASTER && bs->frame_Enemy_Len > 300)
+	{
+		return 1;
+	}
+	else if (weap == WP_REPEATER && bs->frame_Enemy_Len < 600 && bs->frame_Enemy_Len > 250)
+	{
+		return 1;
+	}
+	else if (weap == WP_BLASTER && bs->frame_Enemy_Len < 300)
+	{
+		return 1;
+	}
+	else if (weap == WP_ROCKET_LAUNCHER && bs->frame_Enemy_Len > 250)
+	{
+		return 1;
+	}
+
+	return 0;
+}
+
+//standard weapon combat routines
+int CombatBotAI(bot_state_t *bs, float thinktime)
+{
+	vec3_t eorg, a;
+	int secFire;
+	float fovcheck;
+
+	if (!bs->currentEnemy)
+	{
+		return 0;
+	}
+
+	if (bs->currentEnemy->client)
+	{
+		VectorCopy(bs->currentEnemy->client->ps.origin, eorg);
+	}
+	else
+	{
+		VectorCopy(bs->currentEnemy->s.origin, eorg);
+	}
+
+	VectorSubtract(eorg, bs->eye, a);
+	vectoangles(a, a);
+
+	if (BotGetWeaponRange(bs) == BWEAPONRANGE_SABER)
+	{
+		if (bs->frame_Enemy_Len <= SABER_ATTACK_RANGE)
+		{
+			bs->doAttack = 1;
+		}
+	}
+	else if (BotGetWeaponRange(bs) == BWEAPONRANGE_MELEE)
+	{
+		if (bs->frame_Enemy_Len <= MELEE_ATTACK_RANGE)
+		{
+			bs->doAttack = 1;
+		}
+	}
+	else
+	{
+		if (bs->cur_ps.weapon == WP_THERMAL || bs->cur_ps.weapon == WP_ROCKET_LAUNCHER)
+		{ //be careful with the hurty weapons
+			fovcheck = 40;
+
+			if (bs->cur_ps.weaponstate == WEAPON_CHARGING_ALT &&
+				bs->cur_ps.weapon == WP_ROCKET_LAUNCHER)
+			{ //if we're charging the weapon up then we can hold fire down within a normal fov
+				fovcheck = 60;
+			}
+		}
+		else
+		{
+			fovcheck = 60;
+		}
+
+		if (bs->cur_ps.weaponstate == WEAPON_CHARGING ||
+			bs->cur_ps.weaponstate == WEAPON_CHARGING_ALT)
+		{
+			fovcheck = 160;
+		}
+
+		if (bs->frame_Enemy_Len < 128)
+		{
+			fovcheck *= 2;
+		}
+
+		if (InFieldOfVision(bs->viewangles, fovcheck, a))
+		{
+			if (bs->cur_ps.weapon == WP_THERMAL)
+			{
+				if (((level.time - bs->cur_ps.weaponChargeTime) < (bs->frame_Enemy_Len*2) &&
+					(level.time - bs->cur_ps.weaponChargeTime) < 4000 &&
+					bs->frame_Enemy_Len > 64) ||
+					(bs->cur_ps.weaponstate != WEAPON_CHARGING &&
+					bs->cur_ps.weaponstate != WEAPON_CHARGING_ALT))
+				{
+					if (bs->cur_ps.weaponstate != WEAPON_CHARGING && bs->cur_ps.weaponstate != WEAPON_CHARGING_ALT)
+					{
+						if (bs->frame_Enemy_Len > 512 && bs->frame_Enemy_Len < 800)
+						{
+							bs->doAltAttack = 1;
+							//bs->doAttack = 1;
+						}
+						else
+						{
+							bs->doAttack = 1;
+							//bs->doAltAttack = 1;
+						}
+					}
+
+					if (bs->cur_ps.weaponstate == WEAPON_CHARGING)
+					{
+						bs->doAttack = 1;
+					}
+					else if (bs->cur_ps.weaponstate == WEAPON_CHARGING_ALT)
+					{
+						bs->doAltAttack = 1;
+					}
+				}
+			}
+			else
+			{
+				secFire = ShouldSecondaryFire(bs);
+
+				if (bs->cur_ps.weaponstate != WEAPON_CHARGING_ALT &&
+					bs->cur_ps.weaponstate != WEAPON_CHARGING)
+				{
+					bs->altChargeTime = Q_irand(500, 1000);
+				}
+
+				if (secFire == 1)
+				{
+					bs->doAltAttack = 1;
+				}
+				else if (!secFire)
+				{
+					if (bs->cur_ps.weapon != WP_THERMAL)
+					{
+						if (bs->cur_ps.weaponstate != WEAPON_CHARGING ||
+							bs->altChargeTime > (level.time - bs->cur_ps.weaponChargeTime))
+						{
+							bs->doAttack = 1;
+						}
+					}
+					else
+					{
+						bs->doAttack = 1;
+					}
+				}
+
+				if (secFire == 2)
+				{ //released a charge
+					return 1;
+				}
+			}
+		}
+	}
+
+	return 0;
+}
+
+//we messed up and got off the normal path, let's fall
+//back to jumping around and turning in random
+//directions off walls to see if we can get back to a
+//good place.
+int BotFallbackNavigation(bot_state_t *bs)
+{
+	vec3_t b_angle, fwd, trto, mins, maxs;
+	trace_t tr;
+
+	if (bs->currentEnemy && bs->frame_Enemy_Vis)
+	{
+		return 2; //we're busy
+	}
+
+	mins[0] = -15;
+	mins[1] = -15;
+	mins[2] = 0;
+	maxs[0] = 15;
+	maxs[1] = 15;
+	maxs[2] = 32;
+
+	bs->goalAngles[PITCH] = 0;
+	bs->goalAngles[ROLL] = 0;
+
+	VectorCopy(bs->goalAngles, b_angle);
+
+	AngleVectors(b_angle, fwd, NULL, NULL);
+
+	trto[0] = bs->origin[0] + fwd[0]*16;
+	trto[1] = bs->origin[1] + fwd[1]*16;
+	trto[2] = bs->origin[2] + fwd[2]*16;
+
+	trap_Trace(&tr, bs->origin, mins, maxs, trto, ENTITYNUM_NONE, MASK_SOLID);
+
+	if (tr.fraction == 1)
+	{
+		VectorCopy(trto, bs->goalPosition);
+		return 1; //success!
+	}
+	else
+	{
+		bs->goalAngles[YAW] = rand()%360;
+	}
+
+	return 0;
+}
+
+int BotTryAnotherWeapon(bot_state_t *bs)
+{ //out of ammo, resort to the first weapon we come across that has ammo
+	int i;
+
+	i = 1;
+
+	while (i < WP_NUM_WEAPONS)
+	{
+		if (bs->cur_ps.ammo[weaponData[i].ammoIndex] >= weaponData[i].energyPerShot &&
+			(bs->cur_ps.stats[STAT_WEAPONS] & (1 << i)))
+		{
+			bs->virtualWeapon = i;
+			BotSelectWeapon(bs->client, i);
+			//bs->cur_ps.weapon = i;
+			//level.clients[bs->client].ps.weapon = i;
+			return 1;
+		}
+
+		i++;
+	}
+
+	if (bs->cur_ps.weapon != 1 && bs->virtualWeapon != 1)
+	{ //should always have this.. shouldn't we?
+		bs->virtualWeapon = 1;
+		BotSelectWeapon(bs->client, 1);
+		//bs->cur_ps.weapon = 1;
+		//level.clients[bs->client].ps.weapon = 1;
+		return 1;
+	}
+
+	return 0;
+}
+
+//is this weapon available to us?
+qboolean BotWeaponSelectable(bot_state_t *bs, int weapon)
+{
+	if (weapon == WP_NONE)
+	{
+		return qfalse;
+	}
+
+	if (bs->cur_ps.ammo[weaponData[weapon].ammoIndex] >= weaponData[weapon].energyPerShot &&
+		(bs->cur_ps.stats[STAT_WEAPONS] & (1 << weapon)))
+	{
+		return qtrue;
+	}
+	
+	return qfalse;
+}
+
+//select the best weapon we can
+int BotSelectIdealWeapon(bot_state_t *bs)
+{
+	int i;
+	int bestweight = -1;
+	int bestweapon = 0;
+
+	i = 0;
+
+	while (i < WP_NUM_WEAPONS)
+	{
+		if (bs->cur_ps.ammo[weaponData[i].ammoIndex] >= weaponData[i].energyPerShot &&
+			bs->botWeaponWeights[i] > bestweight &&
+			(bs->cur_ps.stats[STAT_WEAPONS] & (1 << i)))
+		{
+			if (i == WP_THERMAL)
+			{ //special case..
+				if (bs->currentEnemy && bs->frame_Enemy_Len < 700)
+				{
+					bestweight = bs->botWeaponWeights[i];
+					bestweapon = i;
+				}
+			}
+			else
+			{
+				bestweight = bs->botWeaponWeights[i];
+				bestweapon = i;
+			}
+		}
+
+		i++;
+	}
+
+	if ( bs->currentEnemy && bs->frame_Enemy_Len < 300 &&
+		(bestweapon == WP_BRYAR_PISTOL || bestweapon == WP_BLASTER || bestweapon == WP_BOWCASTER) &&
+		(bs->cur_ps.stats[STAT_WEAPONS] & (1 << WP_SABER)) )
+	{
+		bestweapon = WP_SABER;
+		bestweight = 1;
+	}
+
+	if ( bs->currentEnemy && bs->frame_Enemy_Len > 300 &&
+		bs->currentEnemy->client && bs->currentEnemy->client->ps.weapon != WP_SABER &&
+		(bestweapon == WP_SABER) )
+	{ //if the enemy is far away, and we have our saber selected, see if we have any good distance weapons instead
+		if (BotWeaponSelectable(bs, WP_DISRUPTOR))
+		{
+			bestweapon = WP_DISRUPTOR;
+			bestweight = 1;
+		}
+		else if (BotWeaponSelectable(bs, WP_ROCKET_LAUNCHER))
+		{
+			bestweapon = WP_ROCKET_LAUNCHER;
+			bestweight = 1;
+		}
+		else if (BotWeaponSelectable(bs, WP_BOWCASTER))
+		{
+			bestweapon = WP_BOWCASTER;
+			bestweight = 1;
+		}
+		else if (BotWeaponSelectable(bs, WP_BLASTER))
+		{
+			bestweapon = WP_BLASTER;
+			bestweight = 1;
+		}
+		else if (BotWeaponSelectable(bs, WP_REPEATER))
+		{
+			bestweapon = WP_REPEATER;
+			bestweight = 1;
+		}
+		else if (BotWeaponSelectable(bs, WP_DEMP2))
+		{
+			bestweapon = WP_DEMP2;
+			bestweight = 1;
+		}
+	}
+
+	//assert(bs->cur_ps.weapon > 0 && bestweapon > 0);
+
+	if (bestweight != -1 && bs->cur_ps.weapon != bestweapon && bs->virtualWeapon != bestweapon)
+	{
+		bs->virtualWeapon = bestweapon;
+		BotSelectWeapon(bs->client, bestweapon);
+		//bs->cur_ps.weapon = bestweapon;
+		//level.clients[bs->client].ps.weapon = bestweapon;
+		return 1;
+	}
+
+	//assert(bs->cur_ps.weapon > 0);
+
+	return 0;
+}
+
+//check/select the chosen weapon
+int BotSelectChoiceWeapon(bot_state_t *bs, int weapon, int doselection)
+{ //if !doselection then bot will only check if he has the specified weapon and return 1 (yes) or 0 (no)
+	int i;
+	int hasit = 0;
+
+	i = 0;
+
+	while (i < WP_NUM_WEAPONS)
+	{
+		if (bs->cur_ps.ammo[weaponData[i].ammoIndex] > weaponData[i].energyPerShot &&
+			i == weapon &&
+			(bs->cur_ps.stats[STAT_WEAPONS] & (1 << i)))
+		{
+			hasit = 1;
+			break;
+		}
+
+		i++;
+	}
+
+	if (hasit && bs->cur_ps.weapon != weapon && doselection && bs->virtualWeapon != weapon)
+	{
+		bs->virtualWeapon = weapon;
+		BotSelectWeapon(bs->client, weapon);
+		//bs->cur_ps.weapon = weapon;
+		//level.clients[bs->client].ps.weapon = weapon;
+		return 2;
+	}
+
+	if (hasit)
+	{
+		return 1;
+	}
+
+	return 0;
+}
+
+//override our standard weapon choice with a melee weapon
+int BotSelectMelee(bot_state_t *bs)
+{
+	if (bs->cur_ps.weapon != 1 && bs->virtualWeapon != 1)
+	{
+		bs->virtualWeapon = 1;
+		BotSelectWeapon(bs->client, 1);
+		//bs->cur_ps.weapon = 1;
+		//level.clients[bs->client].ps.weapon = 1;
+		return 1;
+	}
+
+	return 0;
+}
+
+//See if we our in love with the potential bot.
+int GetLoveLevel(bot_state_t *bs, bot_state_t *love)
+{
+	int i = 0;
+	const char *lname = NULL;
+
+	if (g_gametype.integer == GT_DUEL || g_gametype.integer == GT_POWERDUEL)
+	{ //There is no love in 1-on-1
+		return 0;
+	}
+
+	if (!bs || !love || !g_entities[love->client].client)
+	{
+		return 0;
+	}
+
+	if (!bs->lovednum)
+	{
+		return 0;
+	}
+
+	if (!bot_attachments.integer)
+	{
+		return 1;
+	}
+
+	lname = g_entities[love->client].client->pers.netname;
+
+	if (!lname)
+	{
+		return 0;
+	}
+
+	while (i < bs->lovednum)
+	{
+		if (strcmp(bs->loved[i].name, lname) == 0)
+		{
+			return bs->loved[i].level;
+		}
+
+		i++;
+	}
+
+	return 0;
+}
+
+//Our loved one was killed. We must become infuriated!
+void BotLovedOneDied(bot_state_t *bs, bot_state_t *loved, int lovelevel)
+{
+	if (!loved->lastHurt || !loved->lastHurt->client ||
+		loved->lastHurt->s.number == loved->client)
+	{
+		return;
+	}
+
+	if (g_gametype.integer == GT_DUEL || g_gametype.integer == GT_POWERDUEL)
+	{ //There is no love in 1-on-1
+		return;
+	}
+
+	if (!IsTeamplay())
+	{
+		if (lovelevel < 2)
+		{
+			return;
+		}
+	}
+	else if (OnSameTeam(&g_entities[bs->client], loved->lastHurt))
+	{ //don't hate teammates no matter what
+		return;
+	}
+
+	if (loved->client == loved->lastHurt->s.number)
+	{
+		return;
+	}
+
+	if (bs->client == loved->lastHurt->s.number)
+	{ //oops!
+		return;
+	}
+	
+	if (!bot_attachments.integer)
+	{
+		return;
+	}
+
+	if (!PassLovedOneCheck(bs, loved->lastHurt))
+	{ //a loved one killed a loved one.. you cannot hate them
+		bs->chatObject = loved->lastHurt;
+		bs->chatAltObject = &g_entities[loved->client];
+		BotDoChat(bs, "LovedOneKilledLovedOne", 0);
+		return;
+	}
+
+	if (bs->revengeEnemy == loved->lastHurt)
+	{
+		if (bs->revengeHateLevel < bs->loved_death_thresh)
+		{
+			bs->revengeHateLevel++;
+
+			if (bs->revengeHateLevel == bs->loved_death_thresh)
+			{
+				//broke into the highest anger level
+				//CHAT: Hatred section
+				bs->chatObject = loved->lastHurt;
+				bs->chatAltObject = NULL;
+				BotDoChat(bs, "Hatred", 1);
+			}
+		}
+	}
+	else if (bs->revengeHateLevel < bs->loved_death_thresh-1)
+	{ //only switch hatred if we don't hate the existing revenge-enemy too much
+		//CHAT: BelovedKilled section
+		bs->chatObject = &g_entities[loved->client];
+		bs->chatAltObject = loved->lastHurt;
+		BotDoChat(bs, "BelovedKilled", 0);
+		bs->revengeHateLevel = 0;
+		bs->revengeEnemy = loved->lastHurt;
+	}
+}
+
+void BotDeathNotify(bot_state_t *bs)
+{ //in case someone has an emotional attachment to us, we'll notify them
+	int i = 0;
+	int ltest = 0;
+
+	while (i < MAX_CLIENTS)
+	{
+		if (botstates[i] && botstates[i]->lovednum)
+		{
+			ltest = 0;
+			while (ltest < botstates[i]->lovednum)
+			{
+				if (strcmp(level.clients[bs->client].pers.netname, botstates[i]->loved[ltest].name) == 0)
+				{
+					BotLovedOneDied(botstates[i], bs, botstates[i]->loved[ltest].level);
+					break;
+				}
+
+				ltest++;
+			}
+		}
+
+		i++;
+	}
+}
+
+//perform strafe trace checks
+void StrafeTracing(bot_state_t *bs)
+{
+	vec3_t mins, maxs;
+	vec3_t right, rorg, drorg;
+	trace_t tr;
+
+	mins[0] = -15;
+	mins[1] = -15;
+	//mins[2] = -24;
+	mins[2] = -22;
+	maxs[0] = 15;
+	maxs[1] = 15;
+	maxs[2] = 32;
+
+	AngleVectors(bs->viewangles, NULL, right, NULL);
+
+	if (bs->meleeStrafeDir)
+	{
+		rorg[0] = bs->origin[0] - right[0]*32;
+		rorg[1] = bs->origin[1] - right[1]*32;
+		rorg[2] = bs->origin[2] - right[2]*32;
+	}
+	else
+	{
+		rorg[0] = bs->origin[0] + right[0]*32;
+		rorg[1] = bs->origin[1] + right[1]*32;
+		rorg[2] = bs->origin[2] + right[2]*32;
+	}
+
+	trap_Trace(&tr, bs->origin, mins, maxs, rorg, bs->client, MASK_SOLID);
+
+	if (tr.fraction != 1)
+	{
+		bs->meleeStrafeDisable = level.time + Q_irand(500, 1500);
+	}
+
+	VectorCopy(rorg, drorg);
+
+	drorg[2] -= 32;
+
+	trap_Trace(&tr, rorg, NULL, NULL, drorg, bs->client, MASK_SOLID);
+
+	if (tr.fraction == 1)
+	{ //this may be a dangerous ledge, so don't strafe over it just in case
+		bs->meleeStrafeDisable = level.time + Q_irand(500, 1500);
+	}
+}
+
+//doing primary weapon fire
+int PrimFiring(bot_state_t *bs)
+{
+	if (bs->cur_ps.weaponstate != WEAPON_CHARGING &&
+		bs->doAttack)
+	{
+		return 1;
+	}
+
+	if (bs->cur_ps.weaponstate == WEAPON_CHARGING &&
+		!bs->doAttack)
+	{
+		return 1;
+	}
+
+	return 0;
+}
+
+//should we keep our primary weapon from firing?
+int KeepPrimFromFiring(bot_state_t *bs)
+{
+	if (bs->cur_ps.weaponstate != WEAPON_CHARGING &&
+		bs->doAttack)
+	{
+		bs->doAttack = 0;
+	}
+
+	if (bs->cur_ps.weaponstate == WEAPON_CHARGING &&
+		!bs->doAttack)
+	{
+		bs->doAttack = 1;
+	}
+
+	return 0;
+}
+
+//doing secondary weapon fire
+int AltFiring(bot_state_t *bs)
+{
+	if (bs->cur_ps.weaponstate != WEAPON_CHARGING_ALT &&
+		bs->doAltAttack)
+	{
+		return 1;
+	}
+
+	if (bs->cur_ps.weaponstate == WEAPON_CHARGING_ALT &&
+		!bs->doAltAttack)
+	{
+		return 1;
+	}
+
+	return 0;
+}
+
+//should we keep our alt from firing?
+int KeepAltFromFiring(bot_state_t *bs)
+{
+	if (bs->cur_ps.weaponstate != WEAPON_CHARGING_ALT &&
+		bs->doAltAttack)
+	{
+		bs->doAltAttack = 0;
+	}
+
+	if (bs->cur_ps.weaponstate == WEAPON_CHARGING_ALT &&
+		!bs->doAltAttack)
+	{
+		bs->doAltAttack = 1;
+	}
+
+	return 0;
+}
+
+//Try not to shoot our friends in the back. Or in the face. Or anywhere, really.
+gentity_t *CheckForFriendInLOF(bot_state_t *bs)
+{
+	vec3_t fwd;
+	vec3_t trfrom, trto;
+	vec3_t mins, maxs;
+	gentity_t *trent;
+	trace_t tr;
+
+	mins[0] = -3;
+	mins[1] = -3;
+	mins[2] = -3;
+
+	maxs[0] = 3;
+	maxs[1] = 3;
+	maxs[2] = 3;
+
+	AngleVectors(bs->viewangles, fwd, NULL, NULL);
+
+	VectorCopy(bs->eye, trfrom);
+
+	trto[0] = trfrom[0] + fwd[0]*2048;
+	trto[1] = trfrom[1] + fwd[1]*2048;
+	trto[2] = trfrom[2] + fwd[2]*2048;
+
+	trap_Trace(&tr, trfrom, mins, maxs, trto, bs->client, MASK_PLAYERSOLID);
+
+	if (tr.fraction != 1 && tr.entityNum <= MAX_CLIENTS)
+	{
+		trent = &g_entities[tr.entityNum];
+
+		if (trent && trent->client)
+		{
+			if (IsTeamplay() && OnSameTeam(&g_entities[bs->client], trent))
+			{
+				return trent;
+			}
+
+			if (botstates[trent->s.number] && GetLoveLevel(bs, botstates[trent->s.number]) > 1)
+			{
+				return trent;
+			}
+		}
+	}
+
+	return NULL;
+}
+
+void BotScanForLeader(bot_state_t *bs)
+{ //bots will only automatically obtain a leader if it's another bot using this method.
+	int i = 0;
+	gentity_t *ent;
+
+	if (bs->isSquadLeader)
+	{
+		return;
+	}
+
+	while (i < MAX_CLIENTS)
+	{
+		ent = &g_entities[i];
+
+		if (ent && ent->client && botstates[i] && botstates[i]->isSquadLeader && bs->client != i)
+		{
+			if (OnSameTeam(&g_entities[bs->client], ent))
+			{
+				bs->squadLeader = ent;
+				break;
+			}
+			if (GetLoveLevel(bs, botstates[i]) > 1 && !IsTeamplay())
+			{ //ignore love status regarding squad leaders if we're in teamplay
+				bs->squadLeader = ent;
+				break;
+			}
+		}
+
+		i++;
+	}
+}
+
+//w3rd to the p33pz.
+void BotReplyGreetings(bot_state_t *bs)
+{
+	int i = 0;
+	int numhello = 0;
+
+	while (i < MAX_CLIENTS)
+	{
+		if (botstates[i] &&
+			botstates[i]->canChat &&
+			i != bs->client)
+		{
+			botstates[i]->chatObject = &g_entities[bs->client];
+			botstates[i]->chatAltObject = NULL;
+			if (BotDoChat(botstates[i], "ResponseGreetings", 0))
+			{
+				numhello++;
+			}
+		}
+
+		if (numhello > 3)
+		{ //don't let more than 4 bots say hello at once
+			return;
+		}
+
+		i++;
+	}
+}
+
+//try to move in to grab a nearby flag
+void CTFFlagMovement(bot_state_t *bs)
+{
+	int diddrop = 0;
+	gentity_t *desiredDrop = NULL;
+	vec3_t a, mins, maxs;
+	trace_t tr;
+
+	mins[0] = -15;
+	mins[1] = -15;
+	mins[2] = -7;
+	maxs[0] = 15;
+	maxs[1] = 15;
+	maxs[2] = 7;
+
+	if (bs->wantFlag && (bs->wantFlag->flags & FL_DROPPED_ITEM))
+	{
+		if (bs->staticFlagSpot[0] == bs->wantFlag->s.pos.trBase[0] &&
+			bs->staticFlagSpot[1] == bs->wantFlag->s.pos.trBase[1] &&
+			bs->staticFlagSpot[2] == bs->wantFlag->s.pos.trBase[2])
+		{
+			VectorSubtract(bs->origin, bs->wantFlag->s.pos.trBase, a);
+
+			if (VectorLength(a) <= BOT_FLAG_GET_DISTANCE)
+			{
+				VectorCopy(bs->wantFlag->s.pos.trBase, bs->goalPosition);
+				return;
+			}
+			else
+			{
+				bs->wantFlag = NULL;
+			}
+		}
+		else
+		{
+			bs->wantFlag = NULL;
+		}
+	}
+	else if (bs->wantFlag)
+	{
+		bs->wantFlag = NULL;
+	}
+
+	if (flagRed && flagBlue)
+	{
+		if (bs->wpDestination == flagRed ||
+			bs->wpDestination == flagBlue)
+		{
+			if (bs->wpDestination == flagRed && droppedRedFlag && (droppedRedFlag->flags & FL_DROPPED_ITEM) && droppedRedFlag->classname && strcmp(droppedRedFlag->classname, "freed") != 0)
+			{
+				desiredDrop = droppedRedFlag;
+				diddrop = 1;
+			}
+			if (bs->wpDestination == flagBlue && droppedBlueFlag && (droppedBlueFlag->flags & FL_DROPPED_ITEM) && droppedBlueFlag->classname && strcmp(droppedBlueFlag->classname, "freed") != 0)
+			{
+				desiredDrop = droppedBlueFlag;
+				diddrop = 1;
+			}
+
+			if (diddrop && desiredDrop)
+			{
+				VectorSubtract(bs->origin, desiredDrop->s.pos.trBase, a);
+
+				if (VectorLength(a) <= BOT_FLAG_GET_DISTANCE)
+				{
+					trap_Trace(&tr, bs->origin, mins, maxs, desiredDrop->s.pos.trBase, bs->client, MASK_SOLID);
+
+					if (tr.fraction == 1 || tr.entityNum == desiredDrop->s.number)
+					{
+						VectorCopy(desiredDrop->s.pos.trBase, bs->goalPosition);
+						VectorCopy(desiredDrop->s.pos.trBase, bs->staticFlagSpot);
+						return;
+					}
+				}
+			}
+		}
+	}
+}
+
+//see if we want to make our detpacks blow up
+void BotCheckDetPacks(bot_state_t *bs)
+{
+	gentity_t *dp = NULL;
+	gentity_t *myDet = NULL;
+	vec3_t a;
+	float enLen;
+	float myLen;
+
+	while ( (dp = G_Find( dp, FOFS(classname), "detpack") ) != NULL )
+	{
+		if (dp && dp->parent && dp->parent->s.number == bs->client)
+		{
+			myDet = dp;
+			break;
+		}
+	}
+
+	if (!myDet)
+	{
+		return;
+	}
+
+	if (!bs->currentEnemy || !bs->currentEnemy->client || !bs->frame_Enemy_Vis)
+	{ //require the enemy to be visilbe just to be fair..
+
+		//unless..
+		if (bs->currentEnemy && bs->currentEnemy->client &&
+			(level.time - bs->plantContinue) < 5000)
+		{ //it's a fresh plant (within 5 seconds) so we should be able to guess
+			goto stillmadeit;
+		}
+		return;
+	}
+
+stillmadeit:
+
+	VectorSubtract(bs->currentEnemy->client->ps.origin, myDet->s.pos.trBase, a);
+	enLen = VectorLength(a);
+
+	VectorSubtract(bs->origin, myDet->s.pos.trBase, a);
+	myLen = VectorLength(a);
+
+	if (enLen > myLen)
+	{
+		return;
+	}
+
+	if (enLen < BOT_PLANT_BLOW_DISTANCE && OrgVisible(bs->currentEnemy->client->ps.origin, myDet->s.pos.trBase, bs->currentEnemy->s.number))
+	{ //we could just call the "blow all my detpacks" function here, but I guess that's cheating.
+		bs->plantKillEmAll = level.time + 500;
+	}
+}
+
+//see if it would be beneficial at this time to use one of our inv items
+int BotUseInventoryItem(bot_state_t *bs)
+{
+	if (bs->cur_ps.stats[STAT_HOLDABLE_ITEMS] & (1 << HI_MEDPAC))
+	{
+		if (g_entities[bs->client].health <= 75)
+		{
+			bs->cur_ps.stats[STAT_HOLDABLE_ITEM] = BG_GetItemIndexByTag(HI_MEDPAC, IT_HOLDABLE);
+			goto wantuseitem;
+		}
+	}
+	if (bs->cur_ps.stats[STAT_HOLDABLE_ITEMS] & (1 << HI_MEDPAC_BIG))
+	{
+		if (g_entities[bs->client].health <= 50)
+		{
+			bs->cur_ps.stats[STAT_HOLDABLE_ITEM] = BG_GetItemIndexByTag(HI_MEDPAC_BIG, IT_HOLDABLE);
+			goto wantuseitem;
+		}
+	}
+	if (bs->cur_ps.stats[STAT_HOLDABLE_ITEMS] & (1 << HI_SEEKER))
+	{
+		if (bs->currentEnemy && bs->frame_Enemy_Vis)
+		{
+			bs->cur_ps.stats[STAT_HOLDABLE_ITEM] = BG_GetItemIndexByTag(HI_SEEKER, IT_HOLDABLE);
+			goto wantuseitem;
+		}
+	}
+	if (bs->cur_ps.stats[STAT_HOLDABLE_ITEMS] & (1 << HI_SENTRY_GUN))
+	{
+		if (bs->currentEnemy && bs->frame_Enemy_Vis)
+		{
+			bs->cur_ps.stats[STAT_HOLDABLE_ITEM] = BG_GetItemIndexByTag(HI_SENTRY_GUN, IT_HOLDABLE);
+			goto wantuseitem;
+		}
+	}
+	if (bs->cur_ps.stats[STAT_HOLDABLE_ITEMS] & (1 << HI_SHIELD))
+	{
+		if (bs->currentEnemy && bs->frame_Enemy_Vis && bs->runningToEscapeThreat)
+		{ //this will (hopefully) result in the bot placing the shield down while facing
+		  //the enemy and running away
+			bs->cur_ps.stats[STAT_HOLDABLE_ITEM] = BG_GetItemIndexByTag(HI_SHIELD, IT_HOLDABLE);
+			goto wantuseitem;
+		}
+	}
+
+	return 0;
+
+wantuseitem:
+	level.clients[bs->client].ps.stats[STAT_HOLDABLE_ITEM] = bs->cur_ps.stats[STAT_HOLDABLE_ITEM];
+
+	return 1;
+}
+
+//trace forward to see if we can plant a detpack or something
+int BotSurfaceNear(bot_state_t *bs)
+{
+	trace_t tr;
+	vec3_t fwd;
+
+	AngleVectors(bs->viewangles, fwd, NULL, NULL);
+
+	fwd[0] = bs->origin[0]+(fwd[0]*64);
+	fwd[1] = bs->origin[1]+(fwd[1]*64);
+	fwd[2] = bs->origin[2]+(fwd[2]*64);
+
+	trap_Trace(&tr, bs->origin, NULL, NULL, fwd, bs->client, MASK_SOLID);
+
+	if (tr.fraction != 1)
+	{
+		return 1;
+	}
+
+	return 0;
+}
+
+//could we block projectiles from the weapon potentially with a light saber?
+int BotWeaponBlockable(int weapon)
+{
+	switch (weapon)
+	{
+	case WP_STUN_BATON:
+	case WP_MELEE:
+		return 0;
+	case WP_DISRUPTOR:
+		return 0;
+	case WP_DEMP2:
+		return 0;
+	case WP_ROCKET_LAUNCHER:
+		return 0;
+	case WP_THERMAL:
+		return 0;
+	case WP_TRIP_MINE:
+		return 0;
+	case WP_DET_PACK:
+		return 0;
+	default:
+		return 1;
+	}
+}
+
+void Cmd_EngageDuel_f(gentity_t *ent);
+void Cmd_ToggleSaber_f(gentity_t *ent);
+
+//movement overrides
+void Bot_SetForcedMovement(int bot, int forward, int right, int up)
+{
+	bot_state_t *bs;
+
+	bs = botstates[bot];
+
+	if (!bs)
+	{ //not a bot
+		return;
+	}
+
+	if (forward != -1)
+	{
+		if (bs->forceMove_Forward)
+		{
+			bs->forceMove_Forward = 0;
+		}
+		else
+		{
+			bs->forceMove_Forward = forward;
+		}
+	}
+	if (right != -1)
+	{
+		if (bs->forceMove_Right)
+		{
+			bs->forceMove_Right = 0;
+		}
+		else
+		{
+			bs->forceMove_Right = right;
+		}
+	}
+	if (up != -1)
+	{
+		if (bs->forceMove_Up)
+		{
+			bs->forceMove_Up = 0;
+		}
+		else
+		{
+			bs->forceMove_Up = up;
+		}
+	}
+}
+
+//the main AI loop.
+//please don't be too frightened.
+void StandardBotAI(bot_state_t *bs, float thinktime)
+{
+	int wp, enemy;
+	int desiredIndex;
+	int goalWPIndex;
+	int doingFallback = 0;
+	int fjHalt;
+	vec3_t a, ang, headlevel, eorg, noz_x, noz_y, dif, a_fo;
+	float reaction;
+	float bLeadAmount;
+	int meleestrafe = 0;
+	int useTheForce = 0;
+	int forceHostile = 0;
+	int cBAI = 0;
+	gentity_t *friendInLOF = 0;
+	float mLen;
+	int visResult = 0;
+	int selResult = 0;
+	int mineSelect = 0;
+	int detSelect = 0;
+	vec3_t preFrameGAngles;
+
+	if (gDeactivated)
+	{
+		bs->wpCurrent = NULL;
+		bs->currentEnemy = NULL;
+		bs->wpDestination = NULL;
+		bs->wpDirection = 0;
+		return;
+	}
+
+	if (g_entities[bs->client].inuse &&
+		g_entities[bs->client].client &&
+		g_entities[bs->client].client->sess.sessionTeam == TEAM_SPECTATOR)
+	{
+		bs->wpCurrent = NULL;
+		bs->currentEnemy = NULL;
+		bs->wpDestination = NULL;
+		bs->wpDirection = 0;
+		return;
+	}
+
+
+#ifndef FINAL_BUILD
+	if (bot_getinthecarrr.integer)
+	{ //stupid vehicle debug, I tire of having to connect another client to test passengers.
+		gentity_t *botEnt = &g_entities[bs->client];
+
+		if (botEnt->inuse && botEnt->client && botEnt->client->ps.m_iVehicleNum)
+		{ //in a vehicle, so...
+			bs->noUseTime = level.time + 5000;
+
+			if (bot_getinthecarrr.integer != 2)
+			{
+				trap_EA_MoveForward(bs->client);
+
+				if (bot_getinthecarrr.integer == 3)
+				{ //use alt fire
+					trap_EA_Alt_Attack(bs->client);
+				}
+			}
+		}
+		else
+		{ //find one, get in
+			int i = 0;
+			gentity_t *vehicle = NULL;
+			//find the nearest, manned vehicle
+			while (i < MAX_GENTITIES)
+			{
+				vehicle = &g_entities[i];
+
+				if (vehicle->inuse && vehicle->client && vehicle->s.eType == ET_NPC &&
+					vehicle->s.NPC_class == CLASS_VEHICLE && vehicle->m_pVehicle &&
+					(vehicle->client->ps.m_iVehicleNum || bot_getinthecarrr.integer == 2))
+				{ //ok, this is a vehicle, and it has a pilot/passengers
+					break;
+				}
+				i++;
+			}
+			if (i != MAX_GENTITIES && vehicle)
+			{ //broke before end so we must've found something
+				vec3_t v;
+
+				VectorSubtract(vehicle->client->ps.origin, bs->origin, v);
+				VectorNormalize(v);
+				vectoangles(v, bs->goalAngles);
+				MoveTowardIdealAngles(bs);
+				trap_EA_Move(bs->client, v, 5000.0f);
+
+				if (bs->noUseTime < (level.time-400))
+				{
+					bs->noUseTime = level.time + 500;
+				}
+			}
+		}
+
+		return;
+	}
+#endif
+
+	if (bot_forgimmick.integer)
+	{
+		bs->wpCurrent = NULL;
+		bs->currentEnemy = NULL;
+		bs->wpDestination = NULL;
+		bs->wpDirection = 0;
+
+		if (bot_forgimmick.integer == 2)
+		{ //for debugging saber stuff, this is handy
+			trap_EA_Attack(bs->client);
+		}
+
+		if (bot_forgimmick.integer == 3)
+		{ //for testing cpu usage moving around rmg terrain without AI
+			vec3_t mdir;
+
+			VectorSubtract(bs->origin, vec3_origin, mdir);
+			VectorNormalize(mdir);
+			trap_EA_Attack(bs->client);
+			trap_EA_Move(bs->client, mdir, 5000);
+		}
+
+		if (bot_forgimmick.integer == 4)
+		{ //constantly move toward client 0
+			if (g_entities[0].client && g_entities[0].inuse)
+			{
+				vec3_t mdir;
+
+				VectorSubtract(g_entities[0].client->ps.origin, bs->origin, mdir);
+				VectorNormalize(mdir);
+				trap_EA_Move(bs->client, mdir, 5000);
+			}
+		}
+
+		if (bs->forceMove_Forward)
+		{
+			if (bs->forceMove_Forward > 0)
+			{
+				trap_EA_MoveForward(bs->client);
+			}
+			else
+			{
+				trap_EA_MoveBack(bs->client);
+			}
+		}
+		if (bs->forceMove_Right)
+		{
+			if (bs->forceMove_Right > 0)
+			{
+				trap_EA_MoveRight(bs->client);
+			}
+			else
+			{
+				trap_EA_MoveLeft(bs->client);
+			}
+		}
+		if (bs->forceMove_Up)
+		{
+			trap_EA_Jump(bs->client);
+		}
+		return;
+	}
+
+	if (!bs->lastDeadTime)
+	{ //just spawned in?
+		bs->lastDeadTime = level.time;
+	}
+
+	if (g_entities[bs->client].health < 1)
+	{
+		bs->lastDeadTime = level.time;
+
+		if (!bs->deathActivitiesDone && bs->lastHurt && bs->lastHurt->client && bs->lastHurt->s.number != bs->client)
+		{
+			BotDeathNotify(bs);
+			if (PassLovedOneCheck(bs, bs->lastHurt))
+			{
+				//CHAT: Died
+				bs->chatObject = bs->lastHurt;
+				bs->chatAltObject = NULL;
+				BotDoChat(bs, "Died", 0);
+			}
+			else if (!PassLovedOneCheck(bs, bs->lastHurt) &&
+				botstates[bs->lastHurt->s.number] &&
+				PassLovedOneCheck(botstates[bs->lastHurt->s.number], &g_entities[bs->client]))
+			{ //killed by a bot that I love, but that does not love me
+				bs->chatObject = bs->lastHurt;
+				bs->chatAltObject = NULL;
+				BotDoChat(bs, "KilledOnPurposeByLove", 0);
+			}
+
+			bs->deathActivitiesDone = 1;
+		}
+		
+		bs->wpCurrent = NULL;
+		bs->currentEnemy = NULL;
+		bs->wpDestination = NULL;
+		bs->wpCamping = NULL;
+		bs->wpCampingTo = NULL;
+		bs->wpStoreDest = NULL;
+		bs->wpDestIgnoreTime = 0;
+		bs->wpDestSwitchTime = 0;
+		bs->wpSeenTime = 0;
+		bs->wpDirection = 0;
+
+		if (rand()%10 < 5 &&
+			(!bs->doChat || bs->chatTime < level.time))
+		{
+			trap_EA_Attack(bs->client);
+		}
+
+		return;
+	}
+
+	VectorCopy(bs->goalAngles, preFrameGAngles);
+
+	bs->doAttack = 0;
+	bs->doAltAttack = 0;
+	//reset the attack states
+
+	if (bs->isSquadLeader)
+	{
+		CommanderBotAI(bs);
+	}
+	else
+	{
+		BotDoTeamplayAI(bs);
+	}
+
+	if (!bs->currentEnemy)
+	{
+		bs->frame_Enemy_Vis = 0;
+	}
+
+	if (bs->revengeEnemy && bs->revengeEnemy->client &&
+		bs->revengeEnemy->client->pers.connected != CA_ACTIVE && bs->revengeEnemy->client->pers.connected != CA_AUTHORIZING)
+	{
+		bs->revengeEnemy = NULL;
+		bs->revengeHateLevel = 0;
+	}
+
+	if (bs->currentEnemy && bs->currentEnemy->client &&
+		bs->currentEnemy->client->pers.connected != CA_ACTIVE && bs->currentEnemy->client->pers.connected != CA_AUTHORIZING)
+	{
+		bs->currentEnemy = NULL;
+	}
+
+	fjHalt = 0;
+
+#ifndef FORCEJUMP_INSTANTMETHOD
+	if (bs->forceJumpChargeTime > level.time)
+	{
+		useTheForce = 1;
+		forceHostile = 0;
+	}
+
+	if (bs->currentEnemy && bs->currentEnemy->client && bs->frame_Enemy_Vis && bs->forceJumpChargeTime < level.time)
+#else
+	if (bs->currentEnemy && bs->currentEnemy->client && bs->frame_Enemy_Vis)
+#endif
+	{
+		VectorSubtract(bs->currentEnemy->client->ps.origin, bs->eye, a_fo);
+		vectoangles(a_fo, a_fo);
+
+		//do this above all things
+		if ((bs->cur_ps.fd.forcePowersKnown & (1 << FP_PUSH)) && (bs->doForcePush > level.time || bs->cur_ps.fd.forceGripBeingGripped > level.time) && level.clients[bs->client].ps.fd.forcePower > forcePowerNeeded[level.clients[bs->client].ps.fd.forcePowerLevel[FP_PUSH]][FP_PUSH] /*&& InFieldOfVision(bs->viewangles, 50, a_fo)*/)
+		{
+			level.clients[bs->client].ps.fd.forcePowerSelected = FP_PUSH;
+			useTheForce = 1;
+			forceHostile = 1;
+		}
+		else if (bs->cur_ps.fd.forceSide == FORCE_DARKSIDE)
+		{ //try dark side powers
+		  //in order of priority top to bottom
+			if ((bs->cur_ps.fd.forcePowersKnown & (1 << FP_GRIP)) && (bs->cur_ps.fd.forcePowersActive & (1 << FP_GRIP)) && InFieldOfVision(bs->viewangles, 50, a_fo))
+			{ //already gripping someone, so hold it
+				level.clients[bs->client].ps.fd.forcePowerSelected = FP_GRIP;
+				useTheForce = 1;
+				forceHostile = 1;
+			}
+			else if ((bs->cur_ps.fd.forcePowersKnown & (1 << FP_LIGHTNING)) && bs->frame_Enemy_Len < FORCE_LIGHTNING_RADIUS && level.clients[bs->client].ps.fd.forcePower > 50 && InFieldOfVision(bs->viewangles, 50, a_fo))
+			{
+				level.clients[bs->client].ps.fd.forcePowerSelected = FP_LIGHTNING;
+				useTheForce = 1;
+				forceHostile = 1;
+			}
+			else if ((bs->cur_ps.fd.forcePowersKnown & (1 << FP_GRIP)) && bs->frame_Enemy_Len < MAX_GRIP_DISTANCE && level.clients[bs->client].ps.fd.forcePower > forcePowerNeeded[level.clients[bs->client].ps.fd.forcePowerLevel[FP_GRIP]][FP_GRIP] && InFieldOfVision(bs->viewangles, 50, a_fo))
+			{
+				level.clients[bs->client].ps.fd.forcePowerSelected = FP_GRIP;
+				useTheForce = 1;
+				forceHostile = 1;
+			}
+			else if ((bs->cur_ps.fd.forcePowersKnown & (1 << FP_RAGE)) && g_entities[bs->client].health < 25 && level.clients[bs->client].ps.fd.forcePower > forcePowerNeeded[level.clients[bs->client].ps.fd.forcePowerLevel[FP_RAGE]][FP_RAGE])
+			{
+				level.clients[bs->client].ps.fd.forcePowerSelected = FP_RAGE;
+				useTheForce = 1;
+				forceHostile = 0;
+			}
+			else if ((bs->cur_ps.fd.forcePowersKnown & (1 << FP_DRAIN)) && bs->frame_Enemy_Len < MAX_DRAIN_DISTANCE && level.clients[bs->client].ps.fd.forcePower > 50 && InFieldOfVision(bs->viewangles, 50, a_fo) && bs->currentEnemy->client->ps.fd.forcePower > 10 && bs->currentEnemy->client->ps.fd.forceSide == FORCE_LIGHTSIDE)
+			{
+				level.clients[bs->client].ps.fd.forcePowerSelected = FP_DRAIN;
+				useTheForce = 1;
+				forceHostile = 1;
+			}
+		}
+		else if (bs->cur_ps.fd.forceSide == FORCE_LIGHTSIDE)
+		{ //try light side powers
+			if ((bs->cur_ps.fd.forcePowersKnown & (1 << FP_ABSORB)) && bs->cur_ps.fd.forceGripCripple &&
+				 level.clients[bs->client].ps.fd.forcePower > forcePowerNeeded[level.clients[bs->client].ps.fd.forcePowerLevel[FP_ABSORB]][FP_ABSORB])
+			{ //absorb to get out
+				level.clients[bs->client].ps.fd.forcePowerSelected = FP_ABSORB;
+				useTheForce = 1;
+				forceHostile = 0;
+			}
+			else if ((bs->cur_ps.fd.forcePowersKnown & (1 << FP_ABSORB)) && bs->cur_ps.electrifyTime >= level.time &&
+				 level.clients[bs->client].ps.fd.forcePower > forcePowerNeeded[level.clients[bs->client].ps.fd.forcePowerLevel[FP_ABSORB]][FP_ABSORB])
+			{ //absorb lightning
+				level.clients[bs->client].ps.fd.forcePowerSelected = FP_ABSORB;
+				useTheForce = 1;
+				forceHostile = 0;
+			}
+			else if ((bs->cur_ps.fd.forcePowersKnown & (1 << FP_TELEPATHY)) && bs->frame_Enemy_Len < MAX_TRICK_DISTANCE && level.clients[bs->client].ps.fd.forcePower > forcePowerNeeded[level.clients[bs->client].ps.fd.forcePowerLevel[FP_TELEPATHY]][FP_TELEPATHY] && InFieldOfVision(bs->viewangles, 50, a_fo) && !(bs->currentEnemy->client->ps.fd.forcePowersActive & (1 << FP_SEE)))
+			{
+				level.clients[bs->client].ps.fd.forcePowerSelected = FP_TELEPATHY;
+				useTheForce = 1;
+				forceHostile = 1;
+			}
+			else if ((bs->cur_ps.fd.forcePowersKnown & (1 << FP_ABSORB)) && g_entities[bs->client].health < 75 && bs->currentEnemy->client->ps.fd.forceSide == FORCE_DARKSIDE && level.clients[bs->client].ps.fd.forcePower > forcePowerNeeded[level.clients[bs->client].ps.fd.forcePowerLevel[FP_ABSORB]][FP_ABSORB])
+			{
+				level.clients[bs->client].ps.fd.forcePowerSelected = FP_ABSORB;
+				useTheForce = 1;
+				forceHostile = 0;
+			}
+			else if ((bs->cur_ps.fd.forcePowersKnown & (1 << FP_PROTECT)) && g_entities[bs->client].health < 35 && level.clients[bs->client].ps.fd.forcePower > forcePowerNeeded[level.clients[bs->client].ps.fd.forcePowerLevel[FP_PROTECT]][FP_PROTECT])
+			{
+				level.clients[bs->client].ps.fd.forcePowerSelected = FP_PROTECT;
+				useTheForce = 1;
+				forceHostile = 0;
+			}
+		}
+
+		if (!useTheForce)
+		{ //try neutral powers
+			if ((bs->cur_ps.fd.forcePowersKnown & (1 << FP_PUSH)) && bs->cur_ps.fd.forceGripBeingGripped > level.time && level.clients[bs->client].ps.fd.forcePower > forcePowerNeeded[level.clients[bs->client].ps.fd.forcePowerLevel[FP_PUSH]][FP_PUSH] && InFieldOfVision(bs->viewangles, 50, a_fo))
+			{
+				level.clients[bs->client].ps.fd.forcePowerSelected = FP_PUSH;
+				useTheForce = 1;
+				forceHostile = 1;
+			}
+			else if ((bs->cur_ps.fd.forcePowersKnown & (1 << FP_SPEED)) && g_entities[bs->client].health < 25 && level.clients[bs->client].ps.fd.forcePower > forcePowerNeeded[level.clients[bs->client].ps.fd.forcePowerLevel[FP_SPEED]][FP_SPEED])
+			{
+				level.clients[bs->client].ps.fd.forcePowerSelected = FP_SPEED;
+				useTheForce = 1;
+				forceHostile = 0;
+			}
+			else if ((bs->cur_ps.fd.forcePowersKnown & (1 << FP_SEE)) && BotMindTricked(bs->client, bs->currentEnemy->s.number) && level.clients[bs->client].ps.fd.forcePower > forcePowerNeeded[level.clients[bs->client].ps.fd.forcePowerLevel[FP_SEE]][FP_SEE])
+			{
+				level.clients[bs->client].ps.fd.forcePowerSelected = FP_SEE;
+				useTheForce = 1;
+				forceHostile = 0;
+			}
+			else if ((bs->cur_ps.fd.forcePowersKnown & (1 << FP_PULL)) && bs->frame_Enemy_Len < 256 && level.clients[bs->client].ps.fd.forcePower > 75 && InFieldOfVision(bs->viewangles, 50, a_fo))
+			{
+				level.clients[bs->client].ps.fd.forcePowerSelected = FP_PULL;
+				useTheForce = 1;
+				forceHostile = 1;
+			}
+		}
+	}
+
+	if (!useTheForce)
+	{ //try powers that we don't care if we have an enemy for
+		if ((bs->cur_ps.fd.forcePowersKnown & (1 << FP_HEAL)) && g_entities[bs->client].health < 50 && level.clients[bs->client].ps.fd.forcePower > forcePowerNeeded[level.clients[bs->client].ps.fd.forcePowerLevel[FP_HEAL]][FP_HEAL] && bs->cur_ps.fd.forcePowerLevel[FP_HEAL] > FORCE_LEVEL_1)
+		{
+			level.clients[bs->client].ps.fd.forcePowerSelected = FP_HEAL;
+			useTheForce = 1;
+			forceHostile = 0;
+		}
+		else if ((bs->cur_ps.fd.forcePowersKnown & (1 << FP_HEAL)) && g_entities[bs->client].health < 50 && level.clients[bs->client].ps.fd.forcePower > forcePowerNeeded[level.clients[bs->client].ps.fd.forcePowerLevel[FP_HEAL]][FP_HEAL] && !bs->currentEnemy && bs->isCamping > level.time)
+		{ //only meditate and heal if we're camping
+			level.clients[bs->client].ps.fd.forcePowerSelected = FP_HEAL;
+			useTheForce = 1;
+			forceHostile = 0;
+		}
+	}
+
+	if (useTheForce && forceHostile)
+	{
+		if (bs->currentEnemy && bs->currentEnemy->client &&
+			!ForcePowerUsableOn(&g_entities[bs->client], bs->currentEnemy, level.clients[bs->client].ps.fd.forcePowerSelected))
+		{
+			useTheForce = 0;
+			forceHostile = 0;
+		}
+	}
+
+	doingFallback = 0;
+
+	bs->deathActivitiesDone = 0;
+
+	if (BotUseInventoryItem(bs))
+	{
+		if (rand()%10 < 5)
+		{
+			trap_EA_Use(bs->client);
+		}
+	}
+
+	if (bs->cur_ps.ammo[weaponData[bs->cur_ps.weapon].ammoIndex] < weaponData[bs->cur_ps.weapon].energyPerShot)
+	{
+		if (BotTryAnotherWeapon(bs))
+		{
+			return;
+		}
+	}
+	else
+	{
+		if (bs->currentEnemy && bs->lastVisibleEnemyIndex == bs->currentEnemy->s.number &&
+			bs->frame_Enemy_Vis && bs->forceWeaponSelect /*&& bs->plantContinue < level.time*/)
+		{
+			bs->forceWeaponSelect = 0;
+		}
+
+		if (bs->plantContinue > level.time)
+		{
+			bs->doAttack = 1;
+			bs->destinationGrabTime = 0;
+		}
+
+		if (!bs->forceWeaponSelect && bs->cur_ps.hasDetPackPlanted && bs->plantKillEmAll > level.time)
+		{
+			bs->forceWeaponSelect = WP_DET_PACK;
+		}
+
+		if (bs->forceWeaponSelect)
+		{
+			selResult = BotSelectChoiceWeapon(bs, bs->forceWeaponSelect, 1);
+		}
+
+		if (selResult)
+		{
+			if (selResult == 2)
+			{ //newly selected
+				return;
+			}
+		}
+		else if (BotSelectIdealWeapon(bs))
+		{
+			return;
+		}
+	}
+	/*if (BotSelectMelee(bs))
+	{
+		return;
+	}*/
+
+	reaction = bs->skills.reflex/bs->settings.skill;
+
+	if (reaction < 0)
+	{
+		reaction = 0;
+	}
+	if (reaction > 2000)
+	{
+		reaction = 2000;
+	}
+
+	if (!bs->currentEnemy)
+	{
+		bs->timeToReact = level.time + reaction;
+	}
+
+	if (bs->cur_ps.weapon == WP_DET_PACK && bs->cur_ps.hasDetPackPlanted && bs->plantKillEmAll > level.time)
+	{
+		bs->doAltAttack = 1;
+	}
+
+	if (bs->wpCamping)
+	{
+		if (bs->isCamping < level.time)
+		{
+			bs->wpCamping = NULL;
+			bs->isCamping = 0;
+		}
+
+		if (bs->currentEnemy && bs->frame_Enemy_Vis)
+		{
+			bs->wpCamping = NULL;
+			bs->isCamping = 0;
+		}
+	}
+
+	if (bs->wpCurrent &&
+		(bs->wpSeenTime < level.time || bs->wpTravelTime < level.time))
+	{
+		bs->wpCurrent = NULL;
+	}
+
+	if (bs->currentEnemy)
+	{
+		if (bs->enemySeenTime < level.time ||
+			!PassStandardEnemyChecks(bs, bs->currentEnemy))
+		{
+			if (bs->revengeEnemy == bs->currentEnemy &&
+				bs->currentEnemy->health < 1 &&
+				bs->lastAttacked && bs->lastAttacked == bs->currentEnemy)
+			{
+				//CHAT: Destroyed hated one [KilledHatedOne section]
+				bs->chatObject = bs->revengeEnemy;
+				bs->chatAltObject = NULL;
+				BotDoChat(bs, "KilledHatedOne", 1);
+				bs->revengeEnemy = NULL;
+				bs->revengeHateLevel = 0;
+			}
+			else if (bs->currentEnemy->health < 1 && PassLovedOneCheck(bs, bs->currentEnemy) &&
+				bs->lastAttacked && bs->lastAttacked == bs->currentEnemy)
+			{
+				//CHAT: Killed
+				bs->chatObject = bs->currentEnemy;
+				bs->chatAltObject = NULL;
+				BotDoChat(bs, "Killed", 0);
+			}
+
+			bs->currentEnemy = NULL;
+		}
+	}
+
+	if (bot_honorableduelacceptance.integer)
+	{
+		if (bs->currentEnemy && bs->currentEnemy->client &&
+			bs->cur_ps.weapon == WP_SABER &&
+			g_privateDuel.integer &&
+			bs->frame_Enemy_Vis &&
+			bs->frame_Enemy_Len < 400 &&
+			bs->currentEnemy->client->ps.weapon == WP_SABER &&
+			bs->currentEnemy->client->ps.saberHolstered)
+		{
+			vec3_t e_ang_vec;
+
+			VectorSubtract(bs->currentEnemy->client->ps.origin, bs->eye, e_ang_vec);
+
+			if (InFieldOfVision(bs->viewangles, 100, e_ang_vec))
+			{ //Our enemy has his saber holstered and has challenged us to a duel, so challenge him back
+				if (!bs->cur_ps.saberHolstered)
+				{
+					Cmd_ToggleSaber_f(&g_entities[bs->client]);
+				}
+				else
+				{
+					if (bs->currentEnemy->client->ps.duelIndex == bs->client &&
+						bs->currentEnemy->client->ps.duelTime > level.time &&
+						!bs->cur_ps.duelInProgress)
+					{
+						Cmd_EngageDuel_f(&g_entities[bs->client]);
+					}
+				}
+
+				bs->doAttack = 0;
+				bs->doAltAttack = 0;
+				bs->botChallengingTime = level.time + 100;
+				bs->beStill = level.time + 100;
+			}
+		}
+	}
+	//Apparently this "allows you to cheese" when fighting against bots. I'm not sure why you'd want to con bots
+	//into an easy kill, since they're bots and all. But whatever.
+
+	if (!bs->wpCurrent)
+	{
+		wp = GetNearestVisibleWP(bs->origin, bs->client);
+
+		if (wp != -1)
+		{
+			bs->wpCurrent = gWPArray[wp];
+			bs->wpSeenTime = level.time + 1500;
+			bs->wpTravelTime = level.time + 10000; //never take more than 10 seconds to travel to a waypoint
+		}
+	}
+
+	if (bs->enemySeenTime < level.time || !bs->frame_Enemy_Vis || !bs->currentEnemy ||
+		(bs->currentEnemy /*&& bs->cur_ps.weapon == WP_SABER && bs->frame_Enemy_Len > 300*/))
+	{
+		enemy = ScanForEnemies(bs);
+
+		if (enemy != -1)
+		{
+			bs->currentEnemy = &g_entities[enemy];
+			bs->enemySeenTime = level.time + ENEMY_FORGET_MS;
+		}
+	}
+
+	if (!bs->squadLeader && !bs->isSquadLeader)
+	{
+		BotScanForLeader(bs);
+	}
+
+	if (!bs->squadLeader && bs->squadCannotLead < level.time)
+	{ //if still no leader after scanning, then become a squad leader
+		bs->isSquadLeader = 1;
+	}
+
+	if (bs->isSquadLeader && bs->squadLeader)
+	{ //we don't follow anyone if we are a leader
+		bs->squadLeader = NULL;
+	}
+
+	//ESTABLISH VISIBILITIES AND DISTANCES FOR THE WHOLE FRAME HERE
+	if (bs->wpCurrent)
+	{
+		if (g_RMG.integer)
+		{ //this is somewhat hacky, but in RMG we don't really care about vertical placement because points are scattered across only the terrain.
+			vec3_t vecB, vecC;
+
+			vecB[0] = bs->origin[0];
+			vecB[1] = bs->origin[1];
+			vecB[2] = bs->origin[2];
+
+			vecC[0] = bs->wpCurrent->origin[0];
+			vecC[1] = bs->wpCurrent->origin[1];
+			vecC[2] = vecB[2];
+
+
+			VectorSubtract(vecC, vecB, a);
+		}
+		else
+		{
+			VectorSubtract(bs->wpCurrent->origin, bs->origin, a);
+		}
+		bs->frame_Waypoint_Len = VectorLength(a);
+
+		visResult = WPOrgVisible(&g_entities[bs->client], bs->origin, bs->wpCurrent->origin, bs->client);
+
+		if (visResult == 2)
+		{
+			bs->frame_Waypoint_Vis = 0;
+			bs->wpSeenTime = 0;
+			bs->wpDestination = NULL;
+			bs->wpDestIgnoreTime = level.time + 5000;
+
+			if (bs->wpDirection)
+			{
+				bs->wpDirection = 0;
+			}
+			else
+			{
+				bs->wpDirection = 1;
+			}
+		}
+		else if (visResult)
+		{
+			bs->frame_Waypoint_Vis = 1;
+		}
+		else
+		{
+			bs->frame_Waypoint_Vis = 0;
+		}
+	}
+
+	if (bs->currentEnemy)
+	{
+		if (bs->currentEnemy->client)
+		{
+			VectorCopy(bs->currentEnemy->client->ps.origin, eorg);
+			eorg[2] += bs->currentEnemy->client->ps.viewheight;
+		}
+		else
+		{
+			VectorCopy(bs->currentEnemy->s.origin, eorg);
+		}
+
+		VectorSubtract(eorg, bs->eye, a);
+		bs->frame_Enemy_Len = VectorLength(a);
+
+		if (OrgVisible(bs->eye, eorg, bs->client))
+		{
+			bs->frame_Enemy_Vis = 1;
+			VectorCopy(eorg, bs->lastEnemySpotted);
+			VectorCopy(bs->origin, bs->hereWhenSpotted);
+			bs->lastVisibleEnemyIndex = bs->currentEnemy->s.number;
+			//VectorCopy(bs->eye, bs->lastEnemySpotted);
+			bs->hitSpotted = 0;
+		}
+		else
+		{
+			bs->frame_Enemy_Vis = 0;
+		}
+	}
+	else
+	{
+		bs->lastVisibleEnemyIndex = ENTITYNUM_NONE;
+	}
+	//END
+
+	if (bs->frame_Enemy_Vis)
+	{
+		bs->enemySeenTime = level.time + ENEMY_FORGET_MS;
+	}
+
+	if (bs->wpCurrent)
+	{
+		int wpTouchDist = BOT_WPTOUCH_DISTANCE;
+		WPConstantRoutine(bs);
+
+		if (!bs->wpCurrent)
+		{ //WPConstantRoutine has the ability to nullify the waypoint if it fails certain checks, so..
+			return;
+		}
+
+		if (bs->wpCurrent->flags & WPFLAG_WAITFORFUNC)
+		{
+			if (!CheckForFunc(bs->wpCurrent->origin, -1))
+			{
+				bs->beStill = level.time + 500; //no func brush under.. wait
+			}
+		}
+		if (bs->wpCurrent->flags & WPFLAG_NOMOVEFUNC)
+		{
+			if (CheckForFunc(bs->wpCurrent->origin, -1))
+			{
+				bs->beStill = level.time + 500; //func brush under.. wait
+			}
+		}
+
+		if (bs->frame_Waypoint_Vis || (bs->wpCurrent->flags & WPFLAG_NOVIS))
+		{
+			if (g_RMG.integer)
+			{
+				bs->wpSeenTime = level.time + 5000; //if we lose sight of the point, we have 1.5 seconds to regain it before we drop it
+			}
+			else
+			{
+				bs->wpSeenTime = level.time + 1500; //if we lose sight of the point, we have 1.5 seconds to regain it before we drop it
+			}
+		}
+		VectorCopy(bs->wpCurrent->origin, bs->goalPosition);
+		if (bs->wpDirection)
+		{
+			goalWPIndex = bs->wpCurrent->index-1;
+		}
+		else
+		{
+			goalWPIndex = bs->wpCurrent->index+1;
+		}
+
+		if (bs->wpCamping)
+		{
+			VectorSubtract(bs->wpCampingTo->origin, bs->origin, a);
+			vectoangles(a, ang);
+			VectorCopy(ang, bs->goalAngles);
+
+			VectorSubtract(bs->origin, bs->wpCamping->origin, a);
+			if (VectorLength(a) < 64)
+			{
+				VectorCopy(bs->wpCamping->origin, bs->goalPosition);
+				bs->beStill = level.time + 1000;
+
+				if (!bs->campStanding)
+				{
+					bs->duckTime = level.time + 1000;
+				}
+			}
+		}
+		else if (gWPArray[goalWPIndex] && gWPArray[goalWPIndex]->inuse &&
+			!(gLevelFlags & LEVELFLAG_NOPOINTPREDICTION))
+		{
+			VectorSubtract(gWPArray[goalWPIndex]->origin, bs->origin, a);
+			vectoangles(a, ang);
+			VectorCopy(ang, bs->goalAngles);
+		}
+		else
+		{
+			VectorSubtract(bs->wpCurrent->origin, bs->origin, a);
+			vectoangles(a, ang);
+			VectorCopy(ang, bs->goalAngles);
+		}
+
+		if (bs->destinationGrabTime < level.time /*&& (!bs->wpDestination || (bs->currentEnemy && bs->frame_Enemy_Vis))*/)
+		{
+			GetIdealDestination(bs);
+		}
+		
+		if (bs->wpCurrent && bs->wpDestination)
+		{
+			if (TotalTrailDistance(bs->wpCurrent->index, bs->wpDestination->index, bs) == -1)
+			{
+				bs->wpDestination = NULL;
+				bs->destinationGrabTime = level.time + 10000;
+			}
+		}
+
+		if (g_RMG.integer)
+		{
+			if (bs->frame_Waypoint_Vis)
+			{
+				if (bs->wpCurrent && !bs->wpCurrent->flags)
+				{
+					wpTouchDist *= 3;
+				}
+			}
+		}
+
+		if (bs->frame_Waypoint_Len < wpTouchDist || (g_RMG.integer && bs->frame_Waypoint_Len < wpTouchDist*2))
+		{
+			WPTouchRoutine(bs);
+
+			if (!bs->wpDirection)
+			{
+				desiredIndex = bs->wpCurrent->index+1;
+			}
+			else
+			{
+				desiredIndex = bs->wpCurrent->index-1;
+			}
+
+			if (gWPArray[desiredIndex] &&
+				gWPArray[desiredIndex]->inuse &&
+				desiredIndex < gWPNum &&
+				desiredIndex >= 0 &&
+				PassWayCheck(bs, desiredIndex))
+			{
+				bs->wpCurrent = gWPArray[desiredIndex];
+			}
+			else
+			{
+				if (bs->wpDestination)
+				{
+					bs->wpDestination = NULL;
+					bs->destinationGrabTime = level.time + 10000;
+				}
+
+				if (bs->wpDirection)
+				{
+					bs->wpDirection = 0;
+				}
+				else
+				{
+					bs->wpDirection = 1;
+				}
+			}
+		}
+	}
+	else //We can't find a waypoint, going to need a fallback routine.
+	{
+		/*if (g_gametype.integer == GT_DUEL)*/
+		{ //helps them get out of messy situations
+			/*if ((level.time - bs->forceJumpChargeTime) > 3500)
+			{
+				bs->forceJumpChargeTime = level.time + 2000;
+				trap_EA_MoveForward(bs->client);
+			}
+			*/
+			bs->jumpTime = level.time + 1500;
+			bs->jumpHoldTime = level.time + 1500;
+			bs->jDelay = 0;
+		}
+		doingFallback = BotFallbackNavigation(bs);
+	}
+
+	if (g_RMG.integer)
+	{ //for RMG if the bot sticks around an area too long, jump around randomly some to spread to a new area (horrible hacky method)
+		vec3_t vSubDif;
+
+		VectorSubtract(bs->origin, bs->lastSignificantAreaChange, vSubDif);
+		if (VectorLength(vSubDif) > 1500)
+		{
+			VectorCopy(bs->origin, bs->lastSignificantAreaChange);
+			bs->lastSignificantChangeTime = level.time + 20000;
+		}
+
+		if (bs->lastSignificantChangeTime < level.time)
+		{
+			bs->iHaveNoIdeaWhereIAmGoing = level.time + 17000;
+		}
+	}
+
+	if (bs->iHaveNoIdeaWhereIAmGoing > level.time && !bs->currentEnemy)
+	{
+		VectorCopy(preFrameGAngles, bs->goalAngles);
+		bs->wpCurrent = NULL;
+		bs->wpSwitchTime = level.time + 150;
+		doingFallback = BotFallbackNavigation(bs);
+		bs->jumpTime = level.time + 150;
+		bs->jumpHoldTime = level.time + 150;
+		bs->jDelay = 0;
+		bs->lastSignificantChangeTime = level.time + 25000;
+	}
+
+	if (bs->wpCurrent && g_RMG.integer)
+	{
+		qboolean doJ = qfalse;
+
+		if (bs->wpCurrent->origin[2]-192 > bs->origin[2])
+		{
+			doJ = qtrue;
+		}
+		else if ((bs->wpTravelTime - level.time) < 5000 && bs->wpCurrent->origin[2]-64 > bs->origin[2])
+		{
+			doJ = qtrue;
+		}
+		else if ((bs->wpTravelTime - level.time) < 7000 && (bs->wpCurrent->flags & WPFLAG_RED_FLAG))
+		{
+			if ((level.time - bs->jumpTime) > 200)
+			{
+				bs->jumpTime = level.time + 100;
+				bs->jumpHoldTime = level.time + 100;
+				bs->jDelay = 0;
+			}
+		}
+		else if ((bs->wpTravelTime - level.time) < 7000 && (bs->wpCurrent->flags & WPFLAG_BLUE_FLAG))
+		{
+			if ((level.time - bs->jumpTime) > 200)
+			{
+				bs->jumpTime = level.time + 100;
+				bs->jumpHoldTime = level.time + 100;
+				bs->jDelay = 0;
+			}
+		}
+		else if (bs->wpCurrent->index > 0)
+		{
+			if ((bs->wpTravelTime - level.time) < 7000)
+			{
+				if ((gWPArray[bs->wpCurrent->index-1]->flags & WPFLAG_RED_FLAG) ||
+					(gWPArray[bs->wpCurrent->index-1]->flags & WPFLAG_BLUE_FLAG))
+				{
+					if ((level.time - bs->jumpTime) > 200)
+					{
+						bs->jumpTime = level.time + 100;
+						bs->jumpHoldTime = level.time + 100;
+						bs->jDelay = 0;
+					}
+				}
+			}
+		}
+
+		if (doJ)
+		{
+			bs->jumpTime = level.time + 1500;
+			bs->jumpHoldTime = level.time + 1500;
+			bs->jDelay = 0;
+		}
+	}
+
+	if (doingFallback)
+	{
+		bs->doingFallback = qtrue;
+	}
+	else
+	{
+		bs->doingFallback = qfalse;
+	}
+
+	if (bs->timeToReact < level.time && bs->currentEnemy && bs->enemySeenTime > level.time + (ENEMY_FORGET_MS - (ENEMY_FORGET_MS*0.2)))
+	{
+		if (bs->frame_Enemy_Vis)
+		{
+			cBAI = CombatBotAI(bs, thinktime);
+		}
+		else if (bs->cur_ps.weaponstate == WEAPON_CHARGING_ALT)
+		{ //keep charging in case we see him again before we lose track of him
+			bs->doAltAttack = 1;
+		}
+		else if (bs->cur_ps.weaponstate == WEAPON_CHARGING)
+		{ //keep charging in case we see him again before we lose track of him
+			bs->doAttack = 1;
+		}
+
+		if (bs->destinationGrabTime > level.time + 100)
+		{
+			bs->destinationGrabTime = level.time + 100; //assures that we will continue staying within a general area of where we want to be in a combat situation
+		}
+
+		if (bs->currentEnemy->client)
+		{
+			VectorCopy(bs->currentEnemy->client->ps.origin, headlevel);
+			headlevel[2] += bs->currentEnemy->client->ps.viewheight;
+		}
+		else
+		{
+			VectorCopy(bs->currentEnemy->client->ps.origin, headlevel);
+		}
+
+		if (!bs->frame_Enemy_Vis)
+		{
+			//if (!bs->hitSpotted && VectorLength(a) > 256)
+			if (OrgVisible(bs->eye, bs->lastEnemySpotted, -1))
+			{
+				VectorCopy(bs->lastEnemySpotted, headlevel);
+				VectorSubtract(headlevel, bs->eye, a);
+				vectoangles(a, ang);
+				VectorCopy(ang, bs->goalAngles);
+
+				if (bs->cur_ps.weapon == WP_FLECHETTE &&
+					bs->cur_ps.weaponstate == WEAPON_READY &&
+					bs->currentEnemy && bs->currentEnemy->client)
+				{
+					mLen = VectorLength(a) > 128;
+					if (mLen > 128 && mLen < 1024)
+					{
+						VectorSubtract(bs->currentEnemy->client->ps.origin, bs->lastEnemySpotted, a);
+
+						if (VectorLength(a) < 300)
+						{
+							bs->doAltAttack = 1;
+						}
+					}
+				}
+			}
+		}
+		else
+		{
+			bLeadAmount = BotWeaponCanLead(bs);
+			if ((bs->skills.accuracy/bs->settings.skill) <= 8 &&
+				bLeadAmount)
+			{
+				BotAimLeading(bs, headlevel, bLeadAmount);
+			}
+			else
+			{
+				VectorSubtract(headlevel, bs->eye, a);
+				vectoangles(a, ang);
+				VectorCopy(ang, bs->goalAngles);
+			}
+
+			BotAimOffsetGoalAngles(bs);
+		}
+	}
+
+	if (bs->cur_ps.saberInFlight)
+	{
+		bs->saberThrowTime = level.time + Q_irand(4000, 10000);
+	}
+
+	if (bs->currentEnemy)
+	{
+		if (BotGetWeaponRange(bs) == BWEAPONRANGE_SABER)
+		{
+			int saberRange = SABER_ATTACK_RANGE;
+
+			VectorSubtract(bs->currentEnemy->client->ps.origin, bs->eye, a_fo);
+			vectoangles(a_fo, a_fo);
+
+			if (bs->saberPowerTime < level.time)
+			{ //Don't just use strong attacks constantly, switch around a bit
+				if (Q_irand(1, 10) <= 5)
+				{
+					bs->saberPower = qtrue;
+				}
+				else
+				{
+					bs->saberPower = qfalse;
+				}
+
+				bs->saberPowerTime = level.time + Q_irand(3000, 15000);
+			}
+
+			if ( g_entities[bs->client].client->ps.fd.saberAnimLevel != SS_STAFF
+				&& g_entities[bs->client].client->ps.fd.saberAnimLevel != SS_DUAL )
+			{
+				if (bs->currentEnemy->health > 75 
+					&& g_entities[bs->client].client->ps.fd.forcePowerLevel[FP_SABER_OFFENSE] > 2)
+				{
+					if (g_entities[bs->client].client->ps.fd.saberAnimLevel != SS_STRONG 
+						&& bs->saberPower)
+					{ //if we are up against someone with a lot of health and we have a strong attack available, then h4q them
+						Cmd_SaberAttackCycle_f(&g_entities[bs->client]);
+					}
+				}
+				else if (bs->currentEnemy->health > 40 
+					&& g_entities[bs->client].client->ps.fd.forcePowerLevel[FP_SABER_OFFENSE] > 1)
+				{
+					if (g_entities[bs->client].client->ps.fd.saberAnimLevel != SS_MEDIUM)
+					{ //they're down on health a little, use level 2 if we can
+						Cmd_SaberAttackCycle_f(&g_entities[bs->client]);
+					}
+				}
+				else
+				{
+					if (g_entities[bs->client].client->ps.fd.saberAnimLevel != SS_FAST)
+					{ //they've gone below 40 health, go at them with quick attacks
+						Cmd_SaberAttackCycle_f(&g_entities[bs->client]);
+					}
+				}
+			}
+
+			if (g_gametype.integer == GT_SINGLE_PLAYER)
+			{
+				saberRange *= 3;
+			}
+
+			if (bs->frame_Enemy_Len <= saberRange)
+			{
+				SaberCombatHandling(bs);
+
+				if (bs->frame_Enemy_Len < 80)
+				{
+					meleestrafe = 1;
+				}
+			}
+			else if (bs->saberThrowTime < level.time && !bs->cur_ps.saberInFlight &&
+				(bs->cur_ps.fd.forcePowersKnown & (1 << FP_SABERTHROW)) &&
+				InFieldOfVision(bs->viewangles, 30, a_fo) &&
+				bs->frame_Enemy_Len < BOT_SABER_THROW_RANGE &&
+				bs->cur_ps.fd.saberAnimLevel != SS_STAFF)
+			{
+				bs->doAltAttack = 1;
+				bs->doAttack = 0;
+			}
+			else if (bs->cur_ps.saberInFlight && bs->frame_Enemy_Len > 300 && bs->frame_Enemy_Len < BOT_SABER_THROW_RANGE)
+			{
+				bs->doAltAttack = 1;
+				bs->doAttack = 0;
+			}
+		}
+		else if (BotGetWeaponRange(bs) == BWEAPONRANGE_MELEE)
+		{
+			if (bs->frame_Enemy_Len <= MELEE_ATTACK_RANGE)
+			{
+				MeleeCombatHandling(bs);
+				meleestrafe = 1;
+			}
+		}
+	}
+
+	if (doingFallback && bs->currentEnemy) //just stand and fire if we have no idea where we are
+	{
+		VectorCopy(bs->origin, bs->goalPosition);
+	}
+
+	if (bs->forceJumping > level.time)
+	{
+		VectorCopy(bs->origin, noz_x);
+		VectorCopy(bs->goalPosition, noz_y);
+
+		noz_x[2] = noz_y[2];
+
+		VectorSubtract(noz_x, noz_y, noz_x);
+
+		if (VectorLength(noz_x) < 32)
+		{
+			fjHalt = 1;
+		}
+	}
+
+	if (bs->doChat && bs->chatTime > level.time && (!bs->currentEnemy || !bs->frame_Enemy_Vis))
+	{
+		return;
+	}
+	else if (bs->doChat && bs->currentEnemy && bs->frame_Enemy_Vis)
+	{
+		//bs->chatTime = level.time + bs->chatTime_stored;
+		bs->doChat = 0; //do we want to keep the bot waiting to chat until after the enemy is gone?
+		bs->chatTeam = 0;
+	}
+	else if (bs->doChat && bs->chatTime <= level.time)
+	{
+		if (bs->chatTeam)
+		{
+			trap_EA_SayTeam(bs->client, bs->currentChat);
+			bs->chatTeam = 0;
+		}
+		else
+		{
+			trap_EA_Say(bs->client, bs->currentChat);
+		}
+		if (bs->doChat == 2)
+		{
+			BotReplyGreetings(bs);
+		}
+		bs->doChat = 0;
+	}
+
+	CTFFlagMovement(bs);
+
+	if (/*bs->wpDestination &&*/ bs->shootGoal &&
+		/*bs->wpDestination->associated_entity == bs->shootGoal->s.number &&*/
+		bs->shootGoal->health > 0 && bs->shootGoal->takedamage)
+	{
+		dif[0] = (bs->shootGoal->r.absmax[0]+bs->shootGoal->r.absmin[0])/2;
+		dif[1] = (bs->shootGoal->r.absmax[1]+bs->shootGoal->r.absmin[1])/2;
+		dif[2] = (bs->shootGoal->r.absmax[2]+bs->shootGoal->r.absmin[2])/2;
+
+		if (!bs->currentEnemy || bs->frame_Enemy_Len > 256)
+		{ //if someone is close then don't stop shooting them for this
+			VectorSubtract(dif, bs->eye, a);
+			vectoangles(a, a);
+			VectorCopy(a, bs->goalAngles);
+
+			if (InFieldOfVision(bs->viewangles, 30, a) &&
+				EntityVisibleBox(bs->origin, NULL, NULL, dif, bs->client, bs->shootGoal->s.number))
+			{
+				bs->doAttack = 1;
+			}
+		}
+	}
+
+	if (bs->cur_ps.hasDetPackPlanted)
+	{ //check if our enemy gets near it and detonate if he does
+		BotCheckDetPacks(bs);
+	}
+	else if (bs->currentEnemy && bs->lastVisibleEnemyIndex == bs->currentEnemy->s.number && !bs->frame_Enemy_Vis && bs->plantTime < level.time &&
+		!bs->doAttack && !bs->doAltAttack)
+	{
+		VectorSubtract(bs->origin, bs->hereWhenSpotted, a);
+
+		if (bs->plantDecided > level.time || (bs->frame_Enemy_Len < BOT_PLANT_DISTANCE*2 && VectorLength(a) < BOT_PLANT_DISTANCE))
+		{
+			mineSelect = BotSelectChoiceWeapon(bs, WP_TRIP_MINE, 0);
+			detSelect = BotSelectChoiceWeapon(bs, WP_DET_PACK, 0);
+			if (bs->cur_ps.hasDetPackPlanted)
+			{
+				detSelect = 0;
+			}
+
+			if (bs->plantDecided > level.time && bs->forceWeaponSelect &&
+				bs->cur_ps.weapon == bs->forceWeaponSelect)
+			{
+				bs->doAttack = 1;
+				bs->plantDecided = 0;
+				bs->plantTime = level.time + BOT_PLANT_INTERVAL;
+				bs->plantContinue = level.time + 500;
+				bs->beStill = level.time + 500;
+			}
+			else if (mineSelect || detSelect)
+			{
+				if (BotSurfaceNear(bs))
+				{
+					if (!mineSelect)
+					{ //if no mines use detpacks, otherwise use mines
+						mineSelect = WP_DET_PACK;
+					}
+					else
+					{
+						mineSelect = WP_TRIP_MINE;
+					}
+
+					detSelect = BotSelectChoiceWeapon(bs, mineSelect, 1);
+
+					if (detSelect && detSelect != 2)
+					{ //We have it and it is now our weapon
+						bs->plantDecided = level.time + 1000;
+						bs->forceWeaponSelect = mineSelect;
+						return;
+					}
+					else if (detSelect == 2)
+					{
+						bs->forceWeaponSelect = mineSelect;
+						return;
+					}
+				}
+			}
+		}
+	}
+	else if (bs->plantContinue < level.time)
+	{
+		bs->forceWeaponSelect = 0;
+	}
+
+	if (g_gametype.integer == GT_JEDIMASTER && !bs->cur_ps.isJediMaster && bs->jmState == -1 && gJMSaberEnt && gJMSaberEnt->inuse)
+	{
+		vec3_t saberLen;
+		float fSaberLen = 0;
+
+		VectorSubtract(bs->origin, gJMSaberEnt->r.currentOrigin, saberLen);
+		fSaberLen = VectorLength(saberLen);
+
+		if (fSaberLen < 256)
+		{
+			if (OrgVisible(bs->origin, gJMSaberEnt->r.currentOrigin, bs->client))
+			{
+				VectorCopy(gJMSaberEnt->r.currentOrigin, bs->goalPosition);
+			}
+		}
+	}
+
+	if (bs->beStill < level.time && !WaitingForNow(bs, bs->goalPosition) && !fjHalt)
+	{
+		VectorSubtract(bs->goalPosition, bs->origin, bs->goalMovedir);
+		VectorNormalize(bs->goalMovedir);
+
+		if (bs->jumpTime > level.time && bs->jDelay < level.time &&
+			level.clients[bs->client].pers.cmd.upmove > 0)
+		{
+		//	trap_EA_Move(bs->client, bs->origin, 5000);
+			bs->beStill = level.time + 200;
+		}
+		else
+		{
+			trap_EA_Move(bs->client, bs->goalMovedir, 5000);
+		}
+
+		if (meleestrafe)
+		{
+			StrafeTracing(bs);
+		}
+
+		if (bs->meleeStrafeDir && meleestrafe && bs->meleeStrafeDisable < level.time)
+		{
+			trap_EA_MoveRight(bs->client);
+		}
+		else if (meleestrafe && bs->meleeStrafeDisable < level.time)
+		{
+			trap_EA_MoveLeft(bs->client);
+		}
+
+		if (BotTrace_Jump(bs, bs->goalPosition))
+		{
+			bs->jumpTime = level.time + 100;
+		}
+		else if (BotTrace_Duck(bs, bs->goalPosition))
+		{
+			bs->duckTime = level.time + 100;
+		}
+#ifdef BOT_STRAFE_AVOIDANCE
+		else
+		{
+			int strafeAround = BotTrace_Strafe(bs, bs->goalPosition);
+
+			if (strafeAround == STRAFEAROUND_RIGHT)
+			{
+				trap_EA_MoveRight(bs->client);
+			}
+			else if (strafeAround == STRAFEAROUND_LEFT)
+			{
+				trap_EA_MoveLeft(bs->client);
+			}
+		}
+#endif
+	}
+
+#ifndef FORCEJUMP_INSTANTMETHOD
+	if (bs->forceJumpChargeTime > level.time)
+	{
+		bs->jumpTime = 0;
+	}
+#endif
+
+	if (bs->jumpPrep > level.time)
+	{
+		bs->forceJumpChargeTime = 0;
+	}
+
+	if (bs->forceJumpChargeTime > level.time)
+	{
+		bs->jumpHoldTime = ((bs->forceJumpChargeTime - level.time)/2) + level.time;
+		bs->forceJumpChargeTime = 0;
+	}
+
+	if (bs->jumpHoldTime > level.time)
+	{
+		bs->jumpTime = bs->jumpHoldTime;
+	}
+
+	if (bs->jumpTime > level.time && bs->jDelay < level.time)
+	{
+		if (bs->jumpHoldTime > level.time)
+		{
+			trap_EA_Jump(bs->client);
+			if (bs->wpCurrent)
+			{
+				if ((bs->wpCurrent->origin[2] - bs->origin[2]) < 64)
+				{
+					trap_EA_MoveForward(bs->client);
+				}
+			}
+			else
+			{
+				trap_EA_MoveForward(bs->client);
+			}
+			if (g_entities[bs->client].client->ps.groundEntityNum == ENTITYNUM_NONE)
+			{
+				g_entities[bs->client].client->ps.pm_flags |= PMF_JUMP_HELD;
+			}
+		}
+		else if (!(bs->cur_ps.pm_flags & PMF_JUMP_HELD))
+		{
+			trap_EA_Jump(bs->client);
+		}
+	}
+
+	if (bs->duckTime > level.time)
+	{
+		trap_EA_Crouch(bs->client);
+	}
+
+	if ( bs->dangerousObject && bs->dangerousObject->inuse && bs->dangerousObject->health > 0 &&
+		bs->dangerousObject->takedamage && (!bs->frame_Enemy_Vis || !bs->currentEnemy) &&
+		(BotGetWeaponRange(bs) == BWEAPONRANGE_MID || BotGetWeaponRange(bs) == BWEAPONRANGE_LONG) &&
+		bs->cur_ps.weapon != WP_DET_PACK && bs->cur_ps.weapon != WP_TRIP_MINE &&
+		!bs->shootGoal )
+	{
+		float danLen;
+
+		VectorSubtract(bs->dangerousObject->r.currentOrigin, bs->eye, a);
+
+		danLen = VectorLength(a);
+
+		if (danLen > 256)
+		{
+			vectoangles(a, a);
+			VectorCopy(a, bs->goalAngles);
+
+			if (Q_irand(1, 10) < 5)
+			{
+				bs->goalAngles[YAW] += Q_irand(0, 3);
+				bs->goalAngles[PITCH] += Q_irand(0, 3);
+			}
+			else
+			{
+				bs->goalAngles[YAW] -= Q_irand(0, 3);
+				bs->goalAngles[PITCH] -= Q_irand(0, 3);
+			}
+
+			if (InFieldOfVision(bs->viewangles, 30, a) &&
+				EntityVisibleBox(bs->origin, NULL, NULL, bs->dangerousObject->r.currentOrigin, bs->client, bs->dangerousObject->s.number))
+			{
+				bs->doAttack = 1;
+			}			
+		}
+	}
+
+	if (PrimFiring(bs) ||
+		AltFiring(bs))
+	{
+		friendInLOF = CheckForFriendInLOF(bs);
+
+		if (friendInLOF)
+		{
+			if (PrimFiring(bs))
+			{
+				KeepPrimFromFiring(bs);
+			}
+			if (AltFiring(bs))
+			{
+				KeepAltFromFiring(bs);
+			}
+			if (useTheForce && forceHostile)
+			{
+				useTheForce = 0;
+			}
+
+			if (!useTheForce && friendInLOF->client)
+			{ //we have a friend here and are not currently using force powers, see if we can help them out
+				if (friendInLOF->health <= 50 && level.clients[bs->client].ps.fd.forcePower > forcePowerNeeded[level.clients[bs->client].ps.fd.forcePowerLevel[FP_TEAM_HEAL]][FP_TEAM_HEAL])
+				{
+					level.clients[bs->client].ps.fd.forcePowerSelected = FP_TEAM_HEAL;
+					useTheForce = 1;
+					forceHostile = 0;
+				}
+				else if (friendInLOF->client->ps.fd.forcePower <= 50 && level.clients[bs->client].ps.fd.forcePower > forcePowerNeeded[level.clients[bs->client].ps.fd.forcePowerLevel[FP_TEAM_FORCE]][FP_TEAM_FORCE])
+				{
+					level.clients[bs->client].ps.fd.forcePowerSelected = FP_TEAM_FORCE;
+					useTheForce = 1;
+					forceHostile = 0;
+				}
+			}
+		}
+	}
+	else if (g_gametype.integer >= GT_TEAM)
+	{ //still check for anyone to help..
+		friendInLOF = CheckForFriendInLOF(bs);
+
+		if (!useTheForce && friendInLOF)
+		{
+			if (friendInLOF->health <= 50 && level.clients[bs->client].ps.fd.forcePower > forcePowerNeeded[level.clients[bs->client].ps.fd.forcePowerLevel[FP_TEAM_HEAL]][FP_TEAM_HEAL])
+			{
+				level.clients[bs->client].ps.fd.forcePowerSelected = FP_TEAM_HEAL;
+				useTheForce = 1;
+				forceHostile = 0;
+			}
+			else if (friendInLOF->client->ps.fd.forcePower <= 50 && level.clients[bs->client].ps.fd.forcePower > forcePowerNeeded[level.clients[bs->client].ps.fd.forcePowerLevel[FP_TEAM_FORCE]][FP_TEAM_FORCE])
+			{
+				level.clients[bs->client].ps.fd.forcePowerSelected = FP_TEAM_FORCE;
+				useTheForce = 1;
+				forceHostile = 0;
+			}
+		}
+	}
+
+	if (bs->doAttack && bs->cur_ps.weapon == WP_DET_PACK &&
+		bs->cur_ps.hasDetPackPlanted)
+	{ //maybe a bit hackish, but bots only want to plant one of these at any given time to avoid complications
+		bs->doAttack = 0;
+	}
+
+	if (bs->doAttack && bs->cur_ps.weapon == WP_SABER &&
+		bs->saberDefending && bs->currentEnemy && bs->currentEnemy->client &&
+		BotWeaponBlockable(bs->currentEnemy->client->ps.weapon) )
+	{
+		bs->doAttack = 0;
+	}
+
+	if (bs->cur_ps.saberLockTime > level.time)
+	{
+		if (rand()%10 < 5)
+		{
+			bs->doAttack = 1;
+		}
+		else
+		{
+			bs->doAttack = 0;
+		}
+	}
+
+	if (bs->botChallengingTime > level.time)
+	{
+		bs->doAttack = 0;
+		bs->doAltAttack = 0;
+	}
+
+	if (bs->cur_ps.weapon == WP_SABER &&
+		bs->cur_ps.saberInFlight &&
+		!bs->cur_ps.saberEntityNum)
+	{ //saber knocked away, keep trying to get it back
+		bs->doAttack = 1;
+		bs->doAltAttack = 0;
+	}
+
+	if (bs->doAttack)
+	{
+		trap_EA_Attack(bs->client);
+	}
+	else if (bs->doAltAttack)
+	{
+		trap_EA_Alt_Attack(bs->client);
+	}
+
+	if (useTheForce && forceHostile && bs->botChallengingTime > level.time)
+	{
+		useTheForce = qfalse;
+	}
+
+	if (useTheForce)
+	{
+#ifndef FORCEJUMP_INSTANTMETHOD
+		if (bs->forceJumpChargeTime > level.time)
+		{
+			level.clients[bs->client].ps.fd.forcePowerSelected = FP_LEVITATION;
+			trap_EA_ForcePower(bs->client);
+		}
+		else
+		{
+#endif
+			if (bot_forcepowers.integer && !g_forcePowerDisable.integer)
+			{
+				trap_EA_ForcePower(bs->client);
+			}
+#ifndef FORCEJUMP_INSTANTMETHOD
+		}
+#endif
+	}
+
+	MoveTowardIdealAngles(bs);
+}
+
+int gUpdateVars = 0;
+
+/*
+==================
+BotAIStartFrame
+==================
+*/
+int BotAIStartFrame(int time) {
+	int i;
+	int elapsed_time, thinktime;
+	static int local_time;
+	static int botlib_residual;
+	static int lastbotthink_time;
+
+	if (gUpdateVars < level.time)
+	{
+		trap_Cvar_Update(&bot_pvstype);
+		trap_Cvar_Update(&bot_camp);
+		trap_Cvar_Update(&bot_attachments);
+		trap_Cvar_Update(&bot_forgimmick);
+		trap_Cvar_Update(&bot_honorableduelacceptance);
+#ifndef FINAL_BUILD
+		trap_Cvar_Update(&bot_getinthecarrr);
+#endif
+		gUpdateVars = level.time + 1000;
+	}
+
+	G_CheckBotSpawn();
+
+	//rww - addl bot frame functions
+	if (gBotEdit)
+	{
+		trap_Cvar_Update(&bot_wp_info);
+		BotWaypointRender();
+	}
+
+	UpdateEventTracker();
+	//end rww
+
+	//cap the bot think time
+	//if the bot think time changed we should reschedule the bots
+	if (BOT_THINK_TIME != lastbotthink_time) {
+		lastbotthink_time = BOT_THINK_TIME;
+		BotScheduleBotThink();
+	}
+
+	elapsed_time = time - local_time;
+	local_time = time;
+
+	if (elapsed_time > BOT_THINK_TIME) thinktime = elapsed_time;
+	else thinktime = BOT_THINK_TIME;
+
+	// execute scheduled bot AI
+	for( i = 0; i < MAX_CLIENTS; i++ ) {
+		if( !botstates[i] || !botstates[i]->inuse ) {
+			continue;
+		}
+		//
+		botstates[i]->botthink_residual += elapsed_time;
+		//
+		if ( botstates[i]->botthink_residual >= thinktime ) {
+			botstates[i]->botthink_residual -= thinktime;
+
+			if (g_entities[i].client->pers.connected == CON_CONNECTED) {
+				BotAI(i, (float) thinktime / 1000);
+			}
+		}
+	}
+
+	// execute bot user commands every frame
+	for( i = 0; i < MAX_CLIENTS; i++ ) {
+		if( !botstates[i] || !botstates[i]->inuse ) {
+			continue;
+		}
+		if( g_entities[i].client->pers.connected != CON_CONNECTED ) {
+			continue;
+		}
+
+		BotUpdateInput(botstates[i], time, elapsed_time);
+		trap_BotUserCommand(botstates[i]->client, &botstates[i]->lastucmd);
+	}
+
+	return qtrue;
+}
+
+/*
+==============
+BotAISetup
+==============
+*/
+int BotAISetup( int restart ) {
+	//rww - new bot cvars..
+	trap_Cvar_Register(&bot_forcepowers, "bot_forcepowers", "1", CVAR_CHEAT);
+	trap_Cvar_Register(&bot_forgimmick, "bot_forgimmick", "0", CVAR_CHEAT);
+	trap_Cvar_Register(&bot_honorableduelacceptance, "bot_honorableduelacceptance", "0", CVAR_CHEAT);
+	trap_Cvar_Register(&bot_pvstype, "bot_pvstype", "1", CVAR_CHEAT);
+#ifndef FINAL_BUILD
+	trap_Cvar_Register(&bot_getinthecarrr, "bot_getinthecarrr", "0", 0);
+#endif
+
+#ifdef _DEBUG
+	trap_Cvar_Register(&bot_nogoals, "bot_nogoals", "0", CVAR_CHEAT);
+	trap_Cvar_Register(&bot_debugmessages, "bot_debugmessages", "0", CVAR_CHEAT);
+#endif
+
+	trap_Cvar_Register(&bot_attachments, "bot_attachments", "1", 0);
+	trap_Cvar_Register(&bot_camp, "bot_camp", "1", 0);
+
+	trap_Cvar_Register(&bot_wp_info, "bot_wp_info", "1", 0);
+	trap_Cvar_Register(&bot_wp_edit, "bot_wp_edit", "0", CVAR_CHEAT);
+	trap_Cvar_Register(&bot_wp_clearweight, "bot_wp_clearweight", "1", 0);
+	trap_Cvar_Register(&bot_wp_distconnect, "bot_wp_distconnect", "1", 0);
+	trap_Cvar_Register(&bot_wp_visconnect, "bot_wp_visconnect", "1", 0);
+
+	trap_Cvar_Update(&bot_forcepowers);
+	//end rww
+
+	//if the game is restarted for a tournament
+	if (restart) {
+		return qtrue;
+	}
+
+	//initialize the bot states
+	memset( botstates, 0, sizeof(botstates) );
+
+	if (!trap_BotLibSetup())
+	{
+		return qfalse; //wts?!
+	}
+
+	return qtrue;
+}
+
+/*
+==============
+BotAIShutdown
+==============
+*/
+int BotAIShutdown( int restart ) {
+
+	int i;
+
+	//if the game is restarted for a tournament
+	if ( restart ) {
+		//shutdown all the bots in the botlib
+		for (i = 0; i < MAX_CLIENTS; i++) {
+			if (botstates[i] && botstates[i]->inuse) {
+				BotAIShutdownClient(botstates[i]->client, restart);
+			}
+		}
+		//don't shutdown the bot library
+	}
+	else {
+		trap_BotLibShutdown();
+	}
+	return qtrue;
+}
+
diff --git a/codemp/game/ai_main.h b/codemp/game/ai_main.h
new file mode 100644
index 0000000..a9fe329
--- /dev/null
+++ b/codemp/game/ai_main.h
@@ -0,0 +1,411 @@
+#include "bg_saga.h"
+
+#define DEFAULT_FORCEPOWERS		"5-1-000000000000000000"
+
+//#define FORCEJUMP_INSTANTMETHOD 1
+
+#ifdef _XBOX	// No bot has more than 150 bytes of chat right now
+#define MAX_CHAT_BUFFER_SIZE 256
+#else
+#define MAX_CHAT_BUFFER_SIZE 8192
+#endif
+#define MAX_CHAT_LINE_SIZE 128
+
+#define TABLE_BRANCH_DISTANCE 32
+#define MAX_NODETABLE_SIZE 16384
+
+#define MAX_LOVED_ONES 4
+#define MAX_ATTACHMENT_NAME 64
+
+#define MAX_FORCE_INFO_SIZE 2048
+
+#define WPFLAG_JUMP				0x00000010 //jump when we hit this
+#define WPFLAG_DUCK				0x00000020 //duck while moving around here
+#define WPFLAG_NOVIS			0x00000400 //go here for a bit even with no visibility
+#define WPFLAG_SNIPEORCAMPSTAND	0x00000800 //a good position to snipe or camp - stand
+#define WPFLAG_WAITFORFUNC		0x00001000 //wait for a func brushent under this point before moving here
+#define WPFLAG_SNIPEORCAMP		0x00002000 //a good position to snipe or camp - crouch
+#define WPFLAG_ONEWAY_FWD		0x00004000 //can only go forward on the trial from here (e.g. went over a ledge)
+#define WPFLAG_ONEWAY_BACK		0x00008000 //can only go backward on the trail from here
+#define WPFLAG_GOALPOINT		0x00010000 //make it a goal to get here.. goal points will be decided by setting "weight" values
+#define WPFLAG_RED_FLAG			0x00020000 //red flag
+#define WPFLAG_BLUE_FLAG		0x00040000 //blue flag
+#define WPFLAG_SIEGE_REBELOBJ	0x00080000 //rebel siege objective
+#define WPFLAG_SIEGE_IMPERIALOBJ	0x00100000 //imperial siege objective
+#define WPFLAG_NOMOVEFUNC		0x00200000 //don't move over if a func is under
+
+#define WPFLAG_CALCULATED		0x00400000 //don't calculate it again
+#define WPFLAG_NEVERONEWAY		0x00800000 //never flag it as one-way
+
+#define LEVELFLAG_NOPOINTPREDICTION			1 //don't take waypoint beyond current into account when adjusting path view angles
+#define LEVELFLAG_IGNOREINFALLBACK			2 //ignore enemies when in a fallback navigation routine
+#define LEVELFLAG_IMUSTNTRUNAWAY			4 //don't be scared
+
+#define WP_KEEP_FLAG_DIST			128
+
+#define BWEAPONRANGE_MELEE			1
+#define BWEAPONRANGE_MID			2
+#define BWEAPONRANGE_LONG			3
+#define BWEAPONRANGE_SABER			4
+
+#define MELEE_ATTACK_RANGE			256
+#define SABER_ATTACK_RANGE			128
+#define MAX_CHICKENWUSS_TIME		10000 //wait 10 secs between checking which run-away path to take
+
+#define BOT_RUN_HEALTH				40
+#define BOT_WPTOUCH_DISTANCE		32
+#define ENEMY_FORGET_MS				10000
+//if our enemy isn't visible within 10000ms (aprx 10sec) then "forget" about him and treat him like every other threat, but still look for
+//more immediate threats while main enemy is not visible
+
+#define BOT_PLANT_DISTANCE			256 //plant if within this radius from the last spotted enemy position
+#define BOT_PLANT_INTERVAL			15000 //only plant once per 15 seconds at max
+#define BOT_PLANT_BLOW_DISTANCE		256 //blow det packs if enemy is within this radius and I am further away than the enemy
+
+#define BOT_MAX_WEAPON_GATHER_TIME	1000 //spend a max of 1 second after spawn issuing orders to gather weapons before attacking enemy base
+#define BOT_MAX_WEAPON_CHASE_TIME	15000 //time to spend gathering the weapon before persuing the enemy base (in case it takes longer than expected)
+
+#define BOT_MAX_WEAPON_CHASE_CTF	5000 //time to spend gathering the weapon before persuing the enemy base (in case it takes longer than expected) [ctf-only]
+
+#define BOT_MIN_SIEGE_GOAL_SHOOT		1024
+#define BOT_MIN_SIEGE_GOAL_TRAVEL	128
+
+#define BASE_GUARD_DISTANCE			256 //guarding the flag
+#define BASE_FLAGWAIT_DISTANCE		256 //has the enemy flag and is waiting in his own base for his flag to be returned
+#define BASE_GETENEMYFLAG_DISTANCE	256 //waiting around to get the enemy's flag
+
+#define BOT_FLAG_GET_DISTANCE		256
+
+#define BOT_SABER_THROW_RANGE		800
+
+typedef enum
+{
+	CTFSTATE_NONE,
+	CTFSTATE_ATTACKER,
+	CTFSTATE_DEFENDER,
+	CTFSTATE_RETRIEVAL,
+	CTFSTATE_GUARDCARRIER,
+	CTFSTATE_GETFLAGHOME,
+	CTFSTATE_MAXCTFSTATES
+} bot_ctf_state_t;
+
+typedef enum
+{
+	SIEGESTATE_NONE,
+	SIEGESTATE_ATTACKER,
+	SIEGESTATE_DEFENDER,
+	SIEGESTATE_MAXSIEGESTATES
+} bot_siege_state_t;
+
+typedef enum
+{
+	TEAMPLAYSTATE_NONE,
+	TEAMPLAYSTATE_FOLLOWING,
+	TEAMPLAYSTATE_ASSISTING,
+	TEAMPLAYSTATE_REGROUP,
+	TEAMPLAYSTATE_MAXTPSTATES
+} bot_teamplay_state_t;
+
+typedef struct botattachment_s
+{
+	int level;
+	char name[MAX_ATTACHMENT_NAME];
+} botattachment_t;
+
+typedef struct nodeobject_s
+{
+	vec3_t origin;
+//	int index;
+	float weight;
+	int flags;
+#ifdef _XBOX
+	short	neighbornum;
+	short	inuse;
+#else
+	int neighbornum;
+	int inuse;
+#endif
+} nodeobject_t;
+
+typedef struct boteventtracker_s
+{
+	int			eventSequence;
+	int			events[MAX_PS_EVENTS];
+	float		eventTime;
+} boteventtracker_t;
+
+typedef struct botskills_s
+{
+	int					reflex;
+	float				accuracy;
+	float				turnspeed;
+	float				turnspeed_combat;
+	float				maxturn;
+	int					perfectaim;
+} botskills_t;
+
+//bot state
+typedef struct bot_state_s
+{
+	int inuse;										//true if this state is used by a bot client
+	int botthink_residual;							//residual for the bot thinks
+	int client;										//client number of the bot
+	int entitynum;									//entity number of the bot
+	playerState_t cur_ps;							//current player state
+	usercmd_t lastucmd;								//usercmd from last frame
+	bot_settings_t settings;						//several bot settings
+	float thinktime;								//time the bot thinks this frame
+	vec3_t origin;									//origin of the bot
+	vec3_t velocity;								//velocity of the bot
+	vec3_t eye;										//eye coordinates of the bot
+	int setupcount;									//true when the bot has just been setup
+	float ltime;									//local bot time
+	float entergame_time;							//time the bot entered the game
+	int ms;											//move state of the bot
+	int gs;											//goal state of the bot
+	int ws;											//weapon state of the bot
+	vec3_t viewangles;								//current view angles
+	vec3_t ideal_viewangles;						//ideal view angles
+	vec3_t viewanglespeed;
+
+	//rww - new AI values
+	gentity_t			*currentEnemy;
+	gentity_t			*revengeEnemy;
+
+	gentity_t			*squadLeader;
+
+	gentity_t			*lastHurt;
+	gentity_t			*lastAttacked;
+
+	gentity_t			*wantFlag;
+
+	gentity_t			*touchGoal;
+	gentity_t			*shootGoal;
+
+	gentity_t			*dangerousObject;
+
+	vec3_t				staticFlagSpot;
+
+	int					revengeHateLevel;
+	int					isSquadLeader;
+
+	int					squadRegroupInterval;
+	int					squadCannotLead;
+
+	int					lastDeadTime;
+
+	wpobject_t			*wpCurrent;
+	wpobject_t			*wpDestination;
+	wpobject_t			*wpStoreDest;
+	vec3_t				goalAngles;
+	vec3_t				goalMovedir;
+	vec3_t				goalPosition;
+
+	vec3_t				lastEnemySpotted;
+	vec3_t				hereWhenSpotted;
+	int					lastVisibleEnemyIndex;
+	int					hitSpotted;
+
+	int					wpDirection;
+
+	float				destinationGrabTime;
+	float				wpSeenTime;
+	float				wpTravelTime;
+	float				wpDestSwitchTime;
+	float				wpSwitchTime;
+	float				wpDestIgnoreTime;
+
+	float				timeToReact;
+
+	float				enemySeenTime;
+
+	float				chickenWussCalculationTime;
+
+	float				beStill;
+	float				duckTime;
+	float				jumpTime;
+	float				jumpHoldTime;
+	float				jumpPrep;
+	float				forceJumping;
+	float				jDelay;
+
+	float				aimOffsetTime;
+	float				aimOffsetAmtYaw;
+	float				aimOffsetAmtPitch;
+
+	float				frame_Waypoint_Len;
+	int					frame_Waypoint_Vis;
+	float				frame_Enemy_Len;
+	int					frame_Enemy_Vis;
+
+	int					isCamper;
+	float				isCamping;
+	wpobject_t			*wpCamping;
+	wpobject_t			*wpCampingTo;
+	qboolean			campStanding;
+
+	int					randomNavTime;
+	int					randomNav;
+
+	int					saberSpecialist;
+
+	int					canChat;
+	int					chatFrequency;
+	char				currentChat[MAX_CHAT_LINE_SIZE];
+	float				chatTime;
+	float				chatTime_stored;
+	int					doChat;
+	int					chatTeam;
+	gentity_t			*chatObject;
+	gentity_t			*chatAltObject;
+
+	float				meleeStrafeTime;
+	int					meleeStrafeDir;
+	float				meleeStrafeDisable;
+
+	int					altChargeTime;
+
+	float				escapeDirTime;
+
+	float				dontGoBack;
+
+	int					doAttack;
+	int					doAltAttack;
+
+	int					forceWeaponSelect;
+	int					virtualWeapon;
+
+	int					plantTime;
+	int					plantDecided;
+	int					plantContinue;
+	int					plantKillEmAll;
+
+	int					runningLikeASissy;
+	int					runningToEscapeThreat;
+
+	//char				chatBuffer[MAX_CHAT_BUFFER_SIZE];
+	//Since we're once again not allocating bot structs dynamically,
+	//shoving a 64k chat buffer into one is a bad thing.
+
+	botskills_t			skills;
+
+	botattachment_t		loved[MAX_LOVED_ONES];
+	int					lovednum;
+
+	int					loved_death_thresh;
+
+	int					deathActivitiesDone;
+
+	float				botWeaponWeights[WP_NUM_WEAPONS];
+
+	int					ctfState;
+
+	int					siegeState;
+
+	int					teamplayState;
+
+	int					jmState;
+
+	int					state_Forced; //set by player ordering menu
+
+	int					saberDefending;
+	int					saberDefendDecideTime;
+	int					saberBFTime;
+	int					saberBTime;
+	int					saberSTime;
+	int					saberThrowTime;
+
+	qboolean			saberPower;
+	int					saberPowerTime;
+
+	int					botChallengingTime;
+
+	char				forceinfo[MAX_FORCE_INFO_SIZE];
+
+#ifndef FORCEJUMP_INSTANTMETHOD
+	int					forceJumpChargeTime;
+#endif
+
+	int					doForcePush;
+
+	int					noUseTime;
+	qboolean			doingFallback;
+
+	int					iHaveNoIdeaWhereIAmGoing;
+	vec3_t				lastSignificantAreaChange;
+	int					lastSignificantChangeTime;
+
+	int					forceMove_Forward;
+	int					forceMove_Right;
+	int					forceMove_Up;
+	//end rww
+} bot_state_t;
+
+void *B_TempAlloc(int size);
+void B_TempFree(int size);
+
+void *B_Alloc(int size);
+void B_Free(void *ptr);
+
+//resets the whole bot state
+void BotResetState(bot_state_t *bs);
+//returns the number of bots in the game
+int NumBots(void);
+
+void BotUtilizePersonality(bot_state_t *bs);
+int BotDoChat(bot_state_t *bs, char *section, int always);
+void StandardBotAI(bot_state_t *bs, float thinktime);
+void BotWaypointRender(void);
+int OrgVisibleBox(vec3_t org1, vec3_t mins, vec3_t maxs, vec3_t org2, int ignore);
+int BotIsAChickenWuss(bot_state_t *bs);
+int GetNearestVisibleWP(vec3_t org, int ignore);
+int GetBestIdleGoal(bot_state_t *bs);
+
+char *ConcatArgs( int start );
+
+extern vmCvar_t bot_forcepowers;
+extern vmCvar_t bot_forgimmick;
+extern vmCvar_t bot_honorableduelacceptance;
+#ifdef _DEBUG
+extern vmCvar_t bot_nogoals;
+extern vmCvar_t bot_debugmessages;
+#endif
+
+extern vmCvar_t bot_attachments;
+extern vmCvar_t bot_camp;
+
+extern vmCvar_t bot_wp_info;
+extern vmCvar_t bot_wp_edit;
+extern vmCvar_t bot_wp_clearweight;
+extern vmCvar_t bot_wp_distconnect;
+extern vmCvar_t bot_wp_visconnect;
+
+extern wpobject_t *flagRed;
+extern wpobject_t *oFlagRed;
+extern wpobject_t *flagBlue;
+extern wpobject_t *oFlagBlue;
+
+extern gentity_t *eFlagRed;
+extern gentity_t *eFlagBlue;
+
+extern char gBotChatBuffer[MAX_CLIENTS][MAX_CHAT_BUFFER_SIZE];
+extern float gWPRenderTime;
+extern float gDeactivated;
+extern float gBotEdit;
+extern int gWPRenderedFrame;
+
+#include "../namespace_begin.h"
+extern wpobject_t *gWPArray[MAX_WPARRAY_SIZE];
+extern int gWPNum;
+#include "../namespace_end.h"
+
+extern int gLastPrintedIndex;
+#ifndef _XBOX
+extern nodeobject_t nodetable[MAX_NODETABLE_SIZE];
+#endif
+extern int nodenum;
+
+extern int gLevelFlags;
+
+extern float floattime;
+#define FloatTime() floattime
diff --git a/codemp/game/ai_util.c b/codemp/game/ai_util.c
new file mode 100644
index 0000000..7947ae4
--- /dev/null
+++ b/codemp/game/ai_util.c
@@ -0,0 +1,867 @@
+#include "g_local.h"
+#include "q_shared.h"
+#include "botlib.h"
+#include "ai_main.h"
+
+#ifdef BOT_ZMALLOC
+#define MAX_BALLOC 8192
+
+void *BAllocList[MAX_BALLOC];
+#endif
+
+char gBotChatBuffer[MAX_CLIENTS][MAX_CHAT_BUFFER_SIZE];
+
+void *B_TempAlloc(int size)
+{
+	return BG_TempAlloc(size);
+}
+
+void B_TempFree(int size)
+{
+	BG_TempFree(size);
+}
+
+
+void *B_Alloc(int size)
+{
+#ifdef BOT_ZMALLOC
+	void *ptr = NULL;
+	int i = 0;
+
+#ifdef BOTMEMTRACK
+	int free = 0;
+	int used = 0;
+
+	while (i < MAX_BALLOC)
+	{
+		if (!BAllocList[i])
+		{
+			free++;
+		}
+		else
+		{
+			used++;
+		}
+
+		i++;
+	}
+
+	G_Printf("Allocations used: %i\nFree allocation slots: %i\n", used, free);
+
+	i = 0;
+#endif
+
+	ptr = trap_BotGetMemoryGame(size);
+
+	while (i < MAX_BALLOC)
+	{
+		if (!BAllocList[i])
+		{
+			BAllocList[i] = ptr;
+			break;
+		}
+		i++;
+	}
+
+	if (i == MAX_BALLOC)
+	{
+		//If this happens we'll have to rely on this chunk being freed manually with B_Free, which it hopefully will be
+#ifdef DEBUG
+		G_Printf("WARNING: MAXIMUM B_ALLOC ALLOCATIONS EXCEEDED\n");
+#endif
+	}
+
+	return ptr;
+#else
+
+	return BG_Alloc(size);
+
+#endif
+}
+
+void B_Free(void *ptr)
+{
+#ifdef BOT_ZMALLOC
+	int i = 0;
+
+#ifdef BOTMEMTRACK
+	int free = 0;
+	int used = 0;
+
+	while (i < MAX_BALLOC)
+	{
+		if (!BAllocList[i])
+		{
+			free++;
+		}
+		else
+		{
+			used++;
+		}
+
+		i++;
+	}
+
+	G_Printf("Allocations used: %i\nFree allocation slots: %i\n", used, free);
+
+	i = 0;
+#endif
+
+	while (i < MAX_BALLOC)
+	{
+		if (BAllocList[i] == ptr)
+		{
+			BAllocList[i] = NULL;
+			break;
+		}
+
+		i++;
+	}
+
+	if (i == MAX_BALLOC)
+	{
+		//Likely because the limit was exceeded and we're now freeing the chunk manually as we hoped would happen
+#ifdef DEBUG
+		G_Printf("WARNING: Freeing allocation which is not in the allocation structure\n");
+#endif
+	}
+
+	trap_BotFreeMemoryGame(ptr);
+#endif
+}
+
+void B_InitAlloc(void)
+{
+#ifdef BOT_ZMALLOC
+	memset(BAllocList, 0, sizeof(BAllocList));
+#endif
+
+	memset(gWPArray, 0, sizeof(gWPArray));
+}
+
+void B_CleanupAlloc(void)
+{
+#ifdef BOT_ZMALLOC
+	int i = 0;
+
+	while (i < MAX_BALLOC)
+	{
+		if (BAllocList[i])
+		{
+			trap_BotFreeMemoryGame(BAllocList[i]);
+			BAllocList[i] = NULL;
+		}
+
+		i++;
+	}
+#endif
+}
+
+int GetValueGroup(char *buf, char *group, char *outbuf)
+{
+	char *place, *placesecond;
+	int iplace;
+	int failure;
+	int i;
+	int startpoint, startletter;
+	int subg = 0;
+
+	i = 0;
+
+	iplace = 0;
+
+	place = strstr(buf, group);
+
+	if (!place)
+	{
+		return 0;
+	}
+
+	startpoint = place - buf + strlen(group) + 1;
+	startletter = (place - buf) - 1;
+
+	failure = 0;
+
+	while (buf[startpoint+1] != '{' || buf[startletter] != '\n')
+	{
+		placesecond = strstr(place+1, group);
+
+		if (placesecond)
+		{
+			startpoint += (placesecond - place);
+			startletter += (placesecond - place);
+			place = placesecond;
+		}
+		else
+		{
+			failure = 1;
+			break;
+		}
+	}
+
+	if (failure)
+	{
+		return 0;
+	}
+
+	//we have found the proper group name if we made it here, so find the opening brace and read into the outbuf
+	//until hitting the end brace
+
+	while (buf[startpoint] != '{')
+	{
+		startpoint++;
+	}
+
+	startpoint++;
+
+	while (buf[startpoint] != '}' || subg)
+	{
+		if (buf[startpoint] == '{')
+		{
+			subg++;
+		}
+		else if (buf[startpoint] == '}')
+		{
+			subg--;
+		}
+		outbuf[i] = buf[startpoint];
+		i++;
+		startpoint++;
+	}
+	outbuf[i] = '\0';
+
+	return 1;
+}
+
+int GetPairedValue(char *buf, char *key, char *outbuf)
+{
+	char *place, *placesecond;
+	int startpoint, startletter;
+	int i, found;
+
+	if (!buf || !key || !outbuf)
+	{
+		return 0;
+	}
+
+	i = 0;
+
+	while (buf[i] && buf[i] != '\0')
+	{
+		if (buf[i] == '/')
+		{
+			if (buf[i+1] && buf[i+1] != '\0' && buf[i+1] == '/')
+			{
+				while (buf[i] != '\n')
+				{
+					buf[i] = '/';
+					i++;
+				}
+			}
+		}
+		i++;
+	}
+
+	place = strstr(buf, key);
+
+	if (!place)
+	{
+		return 0;
+	}
+	//tab == 9
+	startpoint = place - buf + strlen(key);
+	startletter = (place - buf) - 1;
+
+	found = 0;
+
+	while (!found)
+	{
+		if (startletter == 0 || !buf[startletter] || buf[startletter] == '\0' || buf[startletter] == 9 || buf[startletter] == ' ' || buf[startletter] == '\n')
+		{
+			if (buf[startpoint] == '\0' || buf[startpoint] == 9 || buf[startpoint] == ' ' || buf[startpoint] == '\n')
+			{
+				found = 1;
+				break;
+			}
+		}
+
+		placesecond = strstr(place+1, key);
+
+		if (placesecond)
+		{
+			startpoint += placesecond - place;
+			startletter += placesecond - place;
+			place = placesecond;
+		}
+		else
+		{
+			place = NULL;
+			break;
+		}
+
+	}
+
+	if (!found || !place || !buf[startpoint] || buf[startpoint] == '\0')
+	{
+		return 0;
+	}
+
+	while (buf[startpoint] == ' ' || buf[startpoint] == 9 || buf[startpoint] == '\n')
+	{
+		startpoint++;
+	}
+
+	i = 0;
+
+	while (buf[startpoint] && buf[startpoint] != '\0' && buf[startpoint] != '\n')
+	{
+		outbuf[i] = buf[startpoint];
+		i++;
+		startpoint++;
+	}
+
+	outbuf[i] = '\0';
+
+	return 1;
+}
+
+int BotDoChat(bot_state_t *bs, char *section, int always)
+{
+	char *chatgroup;
+	int rVal;
+	int inc_1;
+	int inc_2;
+	int inc_n;
+	int lines;
+	int checkedline;
+	int getthisline;
+	gentity_t *cobject;
+
+	if (!bs->canChat)
+	{
+		return 0;
+	}
+
+	if (bs->doChat)
+	{ //already have a chat scheduled
+		return 0;
+	}
+
+	if (trap_Cvar_VariableIntegerValue("se_language"))
+	{ //no chatting unless English.
+		return 0;
+	}
+
+	if (Q_irand(1, 10) > bs->chatFrequency && !always)
+	{
+		return 0;
+	}
+
+	bs->chatTeam = 0;
+
+	chatgroup = (char *)B_TempAlloc(MAX_CHAT_BUFFER_SIZE);
+
+	rVal = GetValueGroup(gBotChatBuffer[bs->client], section, chatgroup);
+
+	if (!rVal) //the bot has no group defined for the specified chat event
+	{
+		B_TempFree(MAX_CHAT_BUFFER_SIZE); //chatgroup
+		return 0;
+	}
+
+	inc_1 = 0;
+	inc_2 = 2;
+
+	while (chatgroup[inc_2] && chatgroup[inc_2] != '\0')
+	{
+		if (chatgroup[inc_2] != 13 && chatgroup[inc_2] != 9)
+		{
+			chatgroup[inc_1] = chatgroup[inc_2];
+			inc_1++;
+		}
+		inc_2++;
+	}
+	chatgroup[inc_1] = '\0';
+
+	inc_1 = 0;
+
+	lines = 0;
+
+	while (chatgroup[inc_1] && chatgroup[inc_1] != '\0')
+	{
+		if (chatgroup[inc_1] == '\n')
+		{
+			lines++;
+		}
+		inc_1++;
+	}
+
+	if (!lines)
+	{
+		B_TempFree(MAX_CHAT_BUFFER_SIZE); //chatgroup
+		return 0;
+	}
+
+	getthisline = Q_irand(0, (lines+1));
+
+	if (getthisline < 1)
+	{
+		getthisline = 1;
+	}
+	if (getthisline > lines)
+	{
+		getthisline = lines;
+	}
+
+	checkedline = 1;
+
+	inc_1 = 0;
+
+	while (checkedline != getthisline)
+	{
+		if (chatgroup[inc_1] && chatgroup[inc_1] != '\0')
+		{
+			if (chatgroup[inc_1] == '\n')
+			{
+				inc_1++;
+				checkedline++;
+			}
+		}
+
+		if (checkedline == getthisline)
+		{
+			break;
+		}
+
+		inc_1++;
+	}
+
+	//we're at the starting position of the desired line here
+	inc_2 = 0;
+
+	while (chatgroup[inc_1] != '\n')
+	{
+		chatgroup[inc_2] = chatgroup[inc_1];
+		inc_2++;
+		inc_1++;
+	}
+	chatgroup[inc_2] = '\0';
+
+	//trap_EA_Say(bs->client, chatgroup);
+	inc_1 = 0;
+	inc_2 = 0;
+
+	if (strlen(chatgroup) > MAX_CHAT_LINE_SIZE)
+	{
+		B_TempFree(MAX_CHAT_BUFFER_SIZE); //chatgroup
+		return 0;
+	}
+
+	while (chatgroup[inc_1])
+	{
+		if (chatgroup[inc_1] == '%' && chatgroup[inc_1+1] != '%')
+		{
+			inc_1++;
+
+			if (chatgroup[inc_1] == 's' && bs->chatObject)
+			{
+				cobject = bs->chatObject;
+			}
+			else if (chatgroup[inc_1] == 'a' && bs->chatAltObject)
+			{
+				cobject = bs->chatAltObject;
+			}
+			else
+			{
+				cobject = NULL;
+			}
+
+			if (cobject && cobject->client)
+			{
+				inc_n = 0;
+
+				while (cobject->client->pers.netname[inc_n])
+				{
+					bs->currentChat[inc_2] = cobject->client->pers.netname[inc_n];
+					inc_2++;
+					inc_n++;
+				}
+				inc_2--; //to make up for the auto-increment below
+			}
+		}
+		else
+		{
+			bs->currentChat[inc_2] = chatgroup[inc_1];
+		}
+		inc_2++;
+		inc_1++;
+	}
+	bs->currentChat[inc_2] = '\0';
+
+	if (strcmp(section, "GeneralGreetings") == 0)
+	{
+		bs->doChat = 2;
+	}
+	else
+	{
+		bs->doChat = 1;
+	}
+	bs->chatTime_stored = (strlen(bs->currentChat)*45)+Q_irand(1300, 1500);
+	bs->chatTime = level.time + bs->chatTime_stored;
+
+	B_TempFree(MAX_CHAT_BUFFER_SIZE); //chatgroup
+
+	return 1;
+}
+
+void ParseEmotionalAttachments(bot_state_t *bs, char *buf)
+{
+	int i = 0;
+	int i_c = 0;
+	char tbuf[16];
+
+	while (buf[i] && buf[i] != '}')
+	{
+		while (buf[i] == ' ' || buf[i] == '{' || buf[i] == 9 || buf[i] == 13 || buf[i] == '\n')
+		{
+			i++;
+		}
+
+		if (buf[i] && buf[i] != '}')
+		{
+			i_c = 0;
+			while (buf[i] != '{' && buf[i] != 9 && buf[i] != 13 && buf[i] != '\n')
+			{
+				bs->loved[bs->lovednum].name[i_c] = buf[i];
+				i_c++;
+				i++;
+			}
+			bs->loved[bs->lovednum].name[i_c] = '\0';
+
+			while (buf[i] == ' ' || buf[i] == '{' || buf[i] == 9 || buf[i] == 13 || buf[i] == '\n')
+			{
+				i++;
+			}
+
+			i_c = 0;
+
+			while (buf[i] != '{' && buf[i] != 9 && buf[i] != 13 && buf[i] != '\n')
+			{
+				tbuf[i_c] = buf[i];
+				i_c++;
+				i++;
+			}
+			tbuf[i_c] = '\0';
+
+			bs->loved[bs->lovednum].level = atoi(tbuf);
+
+			bs->lovednum++;
+		}
+		else
+		{
+			break;
+		}
+
+		if (bs->lovednum >= MAX_LOVED_ONES)
+		{
+			return;
+		}
+
+		i++;
+	}
+}
+
+int ReadChatGroups(bot_state_t *bs, char *buf)
+{
+	char *cgroupbegin;
+	int cgbplace;
+	int i;
+
+	cgroupbegin = strstr(buf, "BEGIN_CHAT_GROUPS");
+
+	if (!cgroupbegin)
+	{
+		return 0;
+	}
+
+	if (strlen(cgroupbegin) >= MAX_CHAT_BUFFER_SIZE)
+	{
+		G_Printf(S_COLOR_RED "Error: Personality chat section exceeds max size\n");
+		return 0;
+	}
+
+	cgbplace = cgroupbegin - buf+1;
+
+	while (buf[cgbplace] != '\n')
+	{
+		cgbplace++;
+	}
+
+	i = 0;
+
+	while (buf[cgbplace] && buf[cgbplace] != '\0')
+	{
+		gBotChatBuffer[bs->client][i] = buf[cgbplace];
+		i++;
+		cgbplace++;
+	}
+
+	gBotChatBuffer[bs->client][i] = '\0';
+
+	return 1;
+}
+
+void BotUtilizePersonality(bot_state_t *bs)
+{
+	fileHandle_t f;
+	int len, rlen;
+	int failed;
+	int i;
+	//char buf[131072];
+	char *buf = (char *)B_TempAlloc(131072);
+	char *readbuf, *group;
+
+	len = trap_FS_FOpenFile(bs->settings.personalityfile, &f, FS_READ);
+
+	failed = 0;
+
+	if (!f)
+	{
+		G_Printf(S_COLOR_RED "Error: Specified personality not found\n");
+		B_TempFree(131072); //buf
+		return;
+	}
+
+	if (len >= 131072)
+	{
+		G_Printf(S_COLOR_RED "Personality file exceeds maximum length\n");
+		B_TempFree(131072); //buf
+		return;
+	}
+
+	trap_FS_Read(buf, len, f);
+
+	rlen = len;
+
+	while (len < 131072)
+	{ //kill all characters after the file length, since sometimes FS_Read doesn't do that entirely (or so it seems)
+		buf[len] = '\0';
+		len++;
+	}
+
+	len = rlen;
+
+	readbuf = (char *)B_TempAlloc(1024);
+	group = (char *)B_TempAlloc(65536);
+
+	if (!GetValueGroup(buf, "GeneralBotInfo", group))
+	{
+		G_Printf(S_COLOR_RED "Personality file contains no GeneralBotInfo group\n");
+		failed = 1; //set failed so we know to set everything to default values
+	}
+
+	if (!failed && GetPairedValue(group, "reflex", readbuf))
+	{
+		bs->skills.reflex = atoi(readbuf);
+	}
+	else
+	{
+		bs->skills.reflex = 100; //default
+	}
+
+	if (!failed && GetPairedValue(group, "accuracy", readbuf))
+	{
+		bs->skills.accuracy = atof(readbuf);
+	}
+	else
+	{
+		bs->skills.accuracy = 10; //default
+	}
+
+	if (!failed && GetPairedValue(group, "turnspeed", readbuf))
+	{
+		bs->skills.turnspeed = atof(readbuf);
+	}
+	else
+	{
+		bs->skills.turnspeed = 0.01f; //default
+	}
+
+	if (!failed && GetPairedValue(group, "turnspeed_combat", readbuf))
+	{
+		bs->skills.turnspeed_combat = atof(readbuf);
+	}
+	else
+	{
+		bs->skills.turnspeed_combat = 0.05f; //default
+	}
+
+	if (!failed && GetPairedValue(group, "maxturn", readbuf))
+	{
+		bs->skills.maxturn = atof(readbuf);
+	}
+	else
+	{
+		bs->skills.maxturn = 360; //default
+	}
+
+	if (!failed && GetPairedValue(group, "perfectaim", readbuf))
+	{
+		bs->skills.perfectaim = atoi(readbuf);
+	}
+	else
+	{
+		bs->skills.perfectaim = 0; //default
+	}
+
+	if (!failed && GetPairedValue(group, "chatability", readbuf))
+	{
+		bs->canChat = atoi(readbuf);
+	}
+	else
+	{
+		bs->canChat = 0; //default
+	}
+
+	if (!failed && GetPairedValue(group, "chatfrequency", readbuf))
+	{
+		bs->chatFrequency = atoi(readbuf);
+	}
+	else
+	{
+		bs->chatFrequency = 5; //default
+	}
+
+	if (!failed && GetPairedValue(group, "hatelevel", readbuf))
+	{
+		bs->loved_death_thresh = atoi(readbuf);
+	}
+	else
+	{
+		bs->loved_death_thresh = 3; //default
+	}
+
+	if (!failed && GetPairedValue(group, "camper", readbuf))
+	{
+		bs->isCamper = atoi(readbuf);
+	}
+	else
+	{
+		bs->isCamper = 0; //default
+	}
+
+	if (!failed && GetPairedValue(group, "saberspecialist", readbuf))
+	{
+		bs->saberSpecialist = atoi(readbuf);
+	}
+	else
+	{
+		bs->saberSpecialist = 0; //default
+	}
+
+	if (!failed && GetPairedValue(group, "forceinfo", readbuf))
+	{
+		Com_sprintf(bs->forceinfo, sizeof(bs->forceinfo), "%s\0", readbuf);
+	}
+	else
+	{
+		Com_sprintf(bs->forceinfo, sizeof(bs->forceinfo), "%s\0", DEFAULT_FORCEPOWERS);
+	}
+
+	i = 0;
+
+	while (i < MAX_CHAT_BUFFER_SIZE)
+	{ //clear out the chat buffer for this bot
+		gBotChatBuffer[bs->client][i] = '\0';
+		i++;
+	}
+
+	if (bs->canChat)
+	{
+		if (!ReadChatGroups(bs, buf))
+		{
+			bs->canChat = 0;
+		}
+	}
+
+	if (GetValueGroup(buf, "BotWeaponWeights", group))
+	{
+		if (GetPairedValue(group, "WP_STUN_BATON", readbuf))
+		{
+			bs->botWeaponWeights[WP_STUN_BATON] = atoi(readbuf);
+			bs->botWeaponWeights[WP_MELEE] = bs->botWeaponWeights[WP_STUN_BATON];
+		}
+
+		if (GetPairedValue(group, "WP_SABER", readbuf))
+		{
+			bs->botWeaponWeights[WP_SABER] = atoi(readbuf);
+		}
+
+		if (GetPairedValue(group, "WP_BRYAR_PISTOL", readbuf))
+		{
+			bs->botWeaponWeights[WP_BRYAR_PISTOL] = atoi(readbuf);
+		}
+
+		if (GetPairedValue(group, "WP_BLASTER", readbuf))
+		{
+			bs->botWeaponWeights[WP_BLASTER] = atoi(readbuf);
+		}
+
+		if (GetPairedValue(group, "WP_DISRUPTOR", readbuf))
+		{
+			bs->botWeaponWeights[WP_DISRUPTOR] = atoi(readbuf);
+		}
+
+		if (GetPairedValue(group, "WP_BOWCASTER", readbuf))
+		{
+			bs->botWeaponWeights[WP_BOWCASTER] = atoi(readbuf);
+		}
+
+		if (GetPairedValue(group, "WP_REPEATER", readbuf))
+		{
+			bs->botWeaponWeights[WP_REPEATER] = atoi(readbuf);
+		}
+
+		if (GetPairedValue(group, "WP_DEMP2", readbuf))
+		{
+			bs->botWeaponWeights[WP_DEMP2] = atoi(readbuf);
+		}
+
+		if (GetPairedValue(group, "WP_FLECHETTE", readbuf))
+		{
+			bs->botWeaponWeights[WP_FLECHETTE] = atoi(readbuf);
+		}
+
+		if (GetPairedValue(group, "WP_ROCKET_LAUNCHER", readbuf))
+		{
+			bs->botWeaponWeights[WP_ROCKET_LAUNCHER] = atoi(readbuf);
+		}
+
+		if (GetPairedValue(group, "WP_THERMAL", readbuf))
+		{
+			bs->botWeaponWeights[WP_THERMAL] = atoi(readbuf);
+		}
+
+		if (GetPairedValue(group, "WP_TRIP_MINE", readbuf))
+		{
+			bs->botWeaponWeights[WP_TRIP_MINE] = atoi(readbuf);
+		}
+
+		if (GetPairedValue(group, "WP_DET_PACK", readbuf))
+		{
+			bs->botWeaponWeights[WP_DET_PACK] = atoi(readbuf);
+		}
+	}
+
+	bs->lovednum = 0;
+
+	if (GetValueGroup(buf, "EmotionalAttachments", group))
+	{
+		ParseEmotionalAttachments(bs, group);
+	}
+
+	B_TempFree(131072); //buf
+	B_TempFree(1024); //readbuf
+	B_TempFree(65536); //group
+	trap_FS_FCloseFile(f);
+}
diff --git a/codemp/game/ai_wpnav.c b/codemp/game/ai_wpnav.c
new file mode 100644
index 0000000..5c446d2
--- /dev/null
+++ b/codemp/game/ai_wpnav.c
@@ -0,0 +1,3813 @@
+#include "g_local.h"
+#include "q_shared.h"
+#include "botlib.h"
+#include "ai_main.h"
+
+float gWPRenderTime = 0;
+float gDeactivated = 0;
+float gBotEdit = 0;
+int gWPRenderedFrame = 0;
+
+#include "../namespace_begin.h"
+wpobject_t *gWPArray[MAX_WPARRAY_SIZE];
+int gWPNum = 0;
+#include "../namespace_end.h"
+
+int gLastPrintedIndex = -1;
+
+#ifndef _XBOX
+nodeobject_t nodetable[MAX_NODETABLE_SIZE];
+int nodenum; //so we can connect broken trails
+#endif
+
+int gLevelFlags = 0;
+
+char *GetFlagStr( int flags )
+{
+	char *flagstr;
+	int i;
+
+	flagstr = (char *)B_TempAlloc(128);
+	i = 0;
+
+	if (!flags)
+	{
+		strcpy(flagstr, "none\0");
+		goto fend;
+	}
+
+	if (flags & WPFLAG_JUMP)
+	{
+		flagstr[i] = 'j';
+		i++;
+	}
+
+	if (flags & WPFLAG_DUCK)
+	{
+		flagstr[i] = 'd';
+		i++;
+	}
+
+	if (flags & WPFLAG_SNIPEORCAMPSTAND)
+	{
+		flagstr[i] = 'c';
+		i++;
+	}
+
+	if (flags & WPFLAG_WAITFORFUNC)
+	{
+		flagstr[i] = 'f';
+		i++;
+	}
+
+	if (flags & WPFLAG_SNIPEORCAMP)
+	{
+		flagstr[i] = 's';
+		i++;
+	}
+
+	if (flags & WPFLAG_ONEWAY_FWD)
+	{
+		flagstr[i] = 'x';
+		i++;
+	}
+
+	if (flags & WPFLAG_ONEWAY_BACK)
+	{
+		flagstr[i] = 'y';
+		i++;
+	}
+
+	if (flags & WPFLAG_GOALPOINT)
+	{
+		flagstr[i] = 'g';
+		i++;
+	}
+
+	if (flags & WPFLAG_NOVIS)
+	{
+		flagstr[i] = 'n';
+		i++;
+	}
+
+	if (flags & WPFLAG_NOMOVEFUNC)
+	{
+		flagstr[i] = 'm';
+		i++;
+	}
+
+	if (flags & WPFLAG_RED_FLAG)
+	{
+		if (i)
+		{
+			flagstr[i] = ' ';
+			i++;
+		}
+		flagstr[i] = 'r';
+		i++;
+		flagstr[i] = 'e';
+		i++;
+		flagstr[i] = 'd';
+		i++;
+		flagstr[i] = ' ';
+		i++;
+		flagstr[i] = 'f';
+		i++;
+		flagstr[i] = 'l';
+		i++;
+		flagstr[i] = 'a';
+		i++;
+		flagstr[i] = 'g';
+		i++;
+	}
+
+	if (flags & WPFLAG_BLUE_FLAG)
+	{
+		if (i)
+		{
+			flagstr[i] = ' ';
+			i++;
+		}
+		flagstr[i] = 'b';
+		i++;
+		flagstr[i] = 'l';
+		i++;
+		flagstr[i] = 'u';
+		i++;
+		flagstr[i] = 'e';
+		i++;
+		flagstr[i] = ' ';
+		i++;
+		flagstr[i] = 'f';
+		i++;
+		flagstr[i] = 'l';
+		i++;
+		flagstr[i] = 'a';
+		i++;
+		flagstr[i] = 'g';
+		i++;
+	}
+
+	if (flags & WPFLAG_SIEGE_IMPERIALOBJ)
+	{
+		if (i)
+		{
+			flagstr[i] = ' ';
+			i++;
+		}
+		flagstr[i] = 's';
+		i++;
+		flagstr[i] = 'a';
+		i++;
+		flagstr[i] = 'g';
+		i++;
+		flagstr[i] = 'a';
+		i++;
+		flagstr[i] = '_';
+		i++;
+		flagstr[i] = 'i';
+		i++;
+		flagstr[i] = 'm';
+		i++;
+		flagstr[i] = 'p';
+		i++;
+	}
+
+	if (flags & WPFLAG_SIEGE_REBELOBJ)
+	{
+		if (i)
+		{
+			flagstr[i] = ' ';
+			i++;
+		}
+		flagstr[i] = 's';
+		i++;
+		flagstr[i] = 'a';
+		i++;
+		flagstr[i] = 'g';
+		i++;
+		flagstr[i] = 'a';
+		i++;
+		flagstr[i] = '_';
+		i++;
+		flagstr[i] = 'r';
+		i++;
+		flagstr[i] = 'e';
+		i++;
+		flagstr[i] = 'b';
+		i++;
+	}
+
+	flagstr[i] = '\0';
+
+	if (i == 0)
+	{
+		strcpy(flagstr, "unknown\0");
+	}
+
+fend:
+	return flagstr;
+}
+
+void G_TestLine(vec3_t start, vec3_t end, int color, int time)
+{
+	gentity_t *te;
+
+	te = G_TempEntity( start, EV_TESTLINE );
+	VectorCopy(start, te->s.origin);
+	VectorCopy(end, te->s.origin2);
+	te->s.time2 = time;
+	te->s.weapon = color;
+	te->r.svFlags |= SVF_BROADCAST;
+}
+
+void BotWaypointRender(void)
+{
+	int i, n;
+	int inc_checker;
+	int bestindex;
+	int gotbestindex;
+	float bestdist;
+	float checkdist;
+	gentity_t *plum;
+	gentity_t *viewent;
+	char *flagstr;
+	vec3_t a;
+
+	if (!gBotEdit)
+	{
+		return;
+	}
+
+	bestindex = 0;
+
+	if (gWPRenderTime > level.time)
+	{
+		goto checkprint;
+	}
+
+	gWPRenderTime = level.time + 100;
+
+	i = gWPRenderedFrame;
+	inc_checker = gWPRenderedFrame;
+
+	while (i < gWPNum)
+	{
+		if (gWPArray[i] && gWPArray[i]->inuse)
+		{
+			plum = G_TempEntity( gWPArray[i]->origin, EV_SCOREPLUM );
+			plum->r.svFlags |= SVF_BROADCAST;
+			plum->s.time = i;
+			
+			n = 0;
+
+			while (n < gWPArray[i]->neighbornum)
+			{
+				if (gWPArray[i]->neighbors[n].forceJumpTo && gWPArray[gWPArray[i]->neighbors[n].num])
+				{
+					G_TestLine(gWPArray[i]->origin, gWPArray[gWPArray[i]->neighbors[n].num]->origin, 0x0000ff, 5000);
+				}
+				n++;
+			}
+
+			gWPRenderedFrame++;
+		}
+		else
+		{
+			gWPRenderedFrame = 0;
+			break;
+		}
+
+		if ((i - inc_checker) > 4)
+		{
+			break; //don't render too many at once
+		}
+		i++;
+	}
+
+	if (i >= gWPNum)
+	{
+		gWPRenderTime = level.time + 1500; //wait a bit after we finish doing the whole trail
+		gWPRenderedFrame = 0;
+	}
+
+checkprint:
+
+	if (!bot_wp_info.value)
+	{
+		return;
+	}
+
+	viewent = &g_entities[0]; //only show info to the first client
+
+	if (!viewent || !viewent->client)
+	{ //client isn't in the game yet?
+		return;
+	}
+
+	bestdist = 256; //max distance for showing point info
+	gotbestindex = 0;
+
+	i = 0;
+
+	while (i < gWPNum)
+	{
+		if (gWPArray[i] && gWPArray[i]->inuse)
+		{
+			VectorSubtract(viewent->client->ps.origin, gWPArray[i]->origin, a);
+
+			checkdist = VectorLength(a);
+
+			if (checkdist < bestdist)
+			{
+				bestdist = checkdist;
+				bestindex = i;
+				gotbestindex = 1;
+			}
+		}
+		i++;
+	}
+
+	if (gotbestindex && bestindex != gLastPrintedIndex)
+	{
+		flagstr = GetFlagStr(gWPArray[bestindex]->flags);
+		gLastPrintedIndex = bestindex;
+		G_Printf(S_COLOR_YELLOW "Waypoint %i\nFlags - %i (%s) (w%f)\nOrigin - (%i %i %i)\n", (int)(gWPArray[bestindex]->index), (int)(gWPArray[bestindex]->flags), flagstr, gWPArray[bestindex]->weight, (int)(gWPArray[bestindex]->origin[0]), (int)(gWPArray[bestindex]->origin[1]), (int)(gWPArray[bestindex]->origin[2]));
+		//GetFlagStr allocates 128 bytes for this, if it's changed then obviously this must be as well
+		B_TempFree(128); //flagstr
+
+		plum = G_TempEntity( gWPArray[bestindex]->origin, EV_SCOREPLUM );
+		plum->r.svFlags |= SVF_BROADCAST;
+		plum->s.time = bestindex; //render it once
+	}
+	else if (!gotbestindex)
+	{
+		gLastPrintedIndex = -1;
+	}
+}
+
+void TransferWPData(int from, int to)
+{
+	if (!gWPArray[to])
+	{
+		gWPArray[to] = (wpobject_t *)B_Alloc(sizeof(wpobject_t));
+	}
+
+	if (!gWPArray[to])
+	{
+		G_Printf(S_COLOR_RED "FATAL ERROR: Could not allocated memory for waypoint\n");
+	}
+
+	gWPArray[to]->flags = gWPArray[from]->flags;
+	gWPArray[to]->weight = gWPArray[from]->weight;
+	gWPArray[to]->associated_entity = gWPArray[from]->associated_entity;
+	gWPArray[to]->disttonext = gWPArray[from]->disttonext;
+	gWPArray[to]->forceJumpTo = gWPArray[from]->forceJumpTo;
+	gWPArray[to]->index = to;
+	gWPArray[to]->inuse = gWPArray[from]->inuse;
+	VectorCopy(gWPArray[from]->origin, gWPArray[to]->origin);
+}
+
+void CreateNewWP(vec3_t origin, int flags)
+{
+	if (gWPNum >= MAX_WPARRAY_SIZE)
+	{
+		if (!g_RMG.integer)
+		{
+			G_Printf(S_COLOR_YELLOW "Warning: Waypoint limit hit (%i)\n", MAX_WPARRAY_SIZE);
+		}
+		return;
+	}
+
+	if (!gWPArray[gWPNum])
+	{
+		gWPArray[gWPNum] = (wpobject_t *)B_Alloc(sizeof(wpobject_t));
+	}
+
+	if (!gWPArray[gWPNum])
+	{
+		G_Printf(S_COLOR_RED "ERROR: Could not allocated memory for waypoint\n");
+	}
+
+	gWPArray[gWPNum]->flags = flags;
+	gWPArray[gWPNum]->weight = 0; //calculated elsewhere
+	gWPArray[gWPNum]->associated_entity = ENTITYNUM_NONE; //set elsewhere
+	gWPArray[gWPNum]->forceJumpTo = 0;
+	gWPArray[gWPNum]->disttonext = 0; //calculated elsewhere
+	gWPArray[gWPNum]->index = gWPNum;
+	gWPArray[gWPNum]->inuse = 1;
+	VectorCopy(origin, gWPArray[gWPNum]->origin);
+	gWPNum++;
+}
+
+void CreateNewWP_FromObject(wpobject_t *wp)
+{
+	int i;
+
+	if (gWPNum >= MAX_WPARRAY_SIZE)
+	{
+		return;
+	}
+
+	if (!gWPArray[gWPNum])
+	{
+		gWPArray[gWPNum] = (wpobject_t *)B_Alloc(sizeof(wpobject_t));
+	}
+
+	if (!gWPArray[gWPNum])
+	{
+		G_Printf(S_COLOR_RED "ERROR: Could not allocated memory for waypoint\n");
+	}
+
+	gWPArray[gWPNum]->flags = wp->flags;
+	gWPArray[gWPNum]->weight = wp->weight;
+	gWPArray[gWPNum]->associated_entity = wp->associated_entity;
+	gWPArray[gWPNum]->disttonext = wp->disttonext;
+	gWPArray[gWPNum]->forceJumpTo = wp->forceJumpTo;
+	gWPArray[gWPNum]->index = gWPNum;
+	gWPArray[gWPNum]->inuse = 1;
+	VectorCopy(wp->origin, gWPArray[gWPNum]->origin);
+	gWPArray[gWPNum]->neighbornum = wp->neighbornum;
+
+	i = wp->neighbornum;
+
+	while (i >= 0)
+	{
+		gWPArray[gWPNum]->neighbors[i].num = wp->neighbors[i].num;
+		gWPArray[gWPNum]->neighbors[i].forceJumpTo = wp->neighbors[i].forceJumpTo;
+
+		i--;
+	}
+
+	if (gWPArray[gWPNum]->flags & WPFLAG_RED_FLAG)
+	{
+		flagRed = gWPArray[gWPNum];
+		oFlagRed = flagRed;
+	}
+	else if (gWPArray[gWPNum]->flags & WPFLAG_BLUE_FLAG)
+	{
+		flagBlue = gWPArray[gWPNum];
+		oFlagBlue = flagBlue;
+	}
+
+	gWPNum++;
+}
+
+void RemoveWP(void)
+{
+	if (gWPNum <= 0)
+	{
+		return;
+	}
+
+	gWPNum--;
+
+	if (!gWPArray[gWPNum] || !gWPArray[gWPNum]->inuse)
+	{
+		return;
+	}
+
+	//B_Free((wpobject_t *)gWPArray[gWPNum]);
+	if (gWPArray[gWPNum])
+	{
+		memset( gWPArray[gWPNum], 0, sizeof(gWPArray[gWPNum]) );
+	}
+
+	//gWPArray[gWPNum] = NULL;
+
+	if (gWPArray[gWPNum])
+	{
+		gWPArray[gWPNum]->inuse = 0;
+	}
+}
+
+void RemoveAllWP(void)
+{
+	while(gWPNum) {
+		RemoveWP();
+	}
+}
+
+void RemoveWP_InTrail(int afterindex)
+{
+	int foundindex;
+	int foundanindex;
+	int didchange;
+	int i;
+
+	foundindex = 0;
+	foundanindex = 0;
+	didchange = 0;
+	i = 0;
+
+	if (afterindex < 0 || afterindex >= gWPNum)
+	{
+		G_Printf(S_COLOR_YELLOW "Waypoint number %i does not exist\n", afterindex);
+		return;
+	}
+
+	while (i < gWPNum)
+	{
+		if (gWPArray[i] && gWPArray[i]->inuse && gWPArray[i]->index == afterindex)
+		{
+			foundindex = i;
+			foundanindex = 1;
+			break;
+		}
+
+		i++;
+	}
+
+	if (!foundanindex)
+	{
+		G_Printf(S_COLOR_YELLOW "Waypoint index %i should exist, but does not (?)\n", afterindex);
+		return;
+	}
+
+	i = 0;
+
+	while (i <= gWPNum)
+	{
+		if (gWPArray[i] && gWPArray[i]->index == foundindex)
+		{
+			//B_Free(gWPArray[i]);
+
+			//Keep reusing the memory
+			memset( gWPArray[i], 0, sizeof(gWPArray[i]) );
+
+			//gWPArray[i] = NULL;
+			gWPArray[i]->inuse = 0;
+			didchange = 1;
+		}
+		else if (gWPArray[i] && didchange)
+		{
+			TransferWPData(i, i-1);
+			//B_Free(gWPArray[i]);
+
+			//Keep reusing the memory
+			memset( gWPArray[i], 0, sizeof(gWPArray[i]) );
+
+			//gWPArray[i] = NULL;
+			gWPArray[i]->inuse = 0;
+		}
+
+		i++;
+	}
+	gWPNum--;
+}
+
+int CreateNewWP_InTrail(vec3_t origin, int flags, int afterindex)
+{
+	int foundindex;
+	int foundanindex;
+	int i;
+
+	foundindex = 0;
+	foundanindex = 0;
+	i = 0;
+
+	if (gWPNum >= MAX_WPARRAY_SIZE)
+	{
+		if (!g_RMG.integer)
+		{
+			G_Printf(S_COLOR_YELLOW "Warning: Waypoint limit hit (%i)\n", MAX_WPARRAY_SIZE);
+		}
+		return 0;
+	}
+
+	if (afterindex < 0 || afterindex >= gWPNum)
+	{
+		G_Printf(S_COLOR_YELLOW "Waypoint number %i does not exist\n", afterindex);
+		return 0;
+	}
+
+	while (i < gWPNum)
+	{
+		if (gWPArray[i] && gWPArray[i]->inuse && gWPArray[i]->index == afterindex)
+		{
+			foundindex = i;
+			foundanindex = 1;
+			break;
+		}
+
+		i++;
+	}
+
+	if (!foundanindex)
+	{
+		G_Printf(S_COLOR_YELLOW "Waypoint index %i should exist, but does not (?)\n", afterindex);
+		return 0;
+	}
+
+	i = gWPNum;
+
+	while (i >= 0)
+	{
+		if (gWPArray[i] && gWPArray[i]->inuse && gWPArray[i]->index != foundindex)
+		{
+			TransferWPData(i, i+1);
+		}
+		else if (gWPArray[i] && gWPArray[i]->inuse && gWPArray[i]->index == foundindex)
+		{
+			i++;
+
+			if (!gWPArray[i])
+			{
+				gWPArray[i] = (wpobject_t *)B_Alloc(sizeof(wpobject_t));
+			}
+
+			gWPArray[i]->flags = flags;
+			gWPArray[i]->weight = 0; //calculated elsewhere
+			gWPArray[i]->associated_entity = ENTITYNUM_NONE; //set elsewhere
+			gWPArray[i]->disttonext = 0; //calculated elsewhere
+			gWPArray[i]->forceJumpTo = 0;
+			gWPArray[i]->index = i;
+			gWPArray[i]->inuse = 1;
+			VectorCopy(origin, gWPArray[i]->origin);
+			gWPNum++;
+			break;
+		}
+
+		i--;
+	}
+
+	return 1;
+}
+
+int CreateNewWP_InsertUnder(vec3_t origin, int flags, int afterindex)
+{
+	int foundindex;
+	int foundanindex;
+	int i;
+
+	foundindex = 0;
+	foundanindex = 0;
+	i = 0;
+
+	if (gWPNum >= MAX_WPARRAY_SIZE)
+	{
+		if (!g_RMG.integer)
+		{
+			G_Printf(S_COLOR_YELLOW "Warning: Waypoint limit hit (%i)\n", MAX_WPARRAY_SIZE);
+		}
+		return 0;
+	}
+
+	if (afterindex < 0 || afterindex >= gWPNum)
+	{
+		G_Printf(S_COLOR_YELLOW "Waypoint number %i does not exist\n", afterindex);
+		return 0;
+	}
+
+	while (i < gWPNum)
+	{
+		if (gWPArray[i] && gWPArray[i]->inuse && gWPArray[i]->index == afterindex)
+		{
+			foundindex = i;
+			foundanindex = 1;
+			break;
+		}
+
+		i++;
+	}
+
+	if (!foundanindex)
+	{
+		G_Printf(S_COLOR_YELLOW "Waypoint index %i should exist, but does not (?)\n", afterindex);
+		return 0;
+	}
+
+	i = gWPNum;
+
+	while (i >= 0)
+	{
+		if (gWPArray[i] && gWPArray[i]->inuse && gWPArray[i]->index != foundindex)
+		{
+			TransferWPData(i, i+1);
+		}
+		else if (gWPArray[i] && gWPArray[i]->inuse && gWPArray[i]->index == foundindex)
+		{
+			//i++;
+			TransferWPData(i, i+1);
+
+			if (!gWPArray[i])
+			{
+				gWPArray[i] = (wpobject_t *)B_Alloc(sizeof(wpobject_t));
+			}
+
+			gWPArray[i]->flags = flags;
+			gWPArray[i]->weight = 0; //calculated elsewhere
+			gWPArray[i]->associated_entity = ENTITYNUM_NONE; //set elsewhere
+			gWPArray[i]->disttonext = 0; //calculated elsewhere
+			gWPArray[i]->forceJumpTo = 0;
+			gWPArray[i]->index = i;
+			gWPArray[i]->inuse = 1;
+			VectorCopy(origin, gWPArray[i]->origin);
+			gWPNum++;
+			break;
+		}
+
+		i--;
+	}
+
+	return 1;
+}
+
+void TeleportToWP(gentity_t *pl, int afterindex)
+{
+	int foundindex;
+	int foundanindex;
+	int i;
+
+	if (!pl || !pl->client)
+	{
+		return;
+	}
+
+	foundindex = 0;
+	foundanindex = 0;
+	i = 0;
+
+	if (afterindex < 0 || afterindex >= gWPNum)
+	{
+		G_Printf(S_COLOR_YELLOW "Waypoint number %i does not exist\n", afterindex);
+		return;
+	}
+
+	while (i < gWPNum)
+	{
+		if (gWPArray[i] && gWPArray[i]->inuse && gWPArray[i]->index == afterindex)
+		{
+			foundindex = i;
+			foundanindex = 1;
+			break;
+		}
+
+		i++;
+	}
+
+	if (!foundanindex)
+	{
+		G_Printf(S_COLOR_YELLOW "Waypoint index %i should exist, but does not (?)\n", afterindex);
+		return;
+	}
+
+	VectorCopy(gWPArray[foundindex]->origin, pl->client->ps.origin);
+
+	return;
+}
+
+void WPFlagsModify(int wpnum, int flags)
+{
+	if (wpnum < 0 || wpnum >= gWPNum || !gWPArray[wpnum] || !gWPArray[wpnum]->inuse)
+	{
+		G_Printf(S_COLOR_YELLOW "WPFlagsModify: Waypoint %i does not exist\n", wpnum);
+		return;
+	}
+
+	gWPArray[wpnum]->flags = flags;
+}
+
+static int NotWithinRange(int base, int extent)
+{
+	if (extent > base && base+5 >= extent)
+	{
+		return 0;
+	}
+
+	if (extent < base && base-5 <= extent)
+	{
+		return 0;
+	}
+
+	return 1;
+}
+
+#ifndef _XBOX
+int NodeHere(vec3_t spot)
+{
+	int i;
+
+	i = 0;
+
+	while (i < nodenum)
+	{
+		if ((int)nodetable[i].origin[0] == (int)spot[0] &&
+			(int)nodetable[i].origin[1] == (int)spot[1])
+		{
+			if ((int)nodetable[i].origin[2] == (int)spot[2] ||
+				((int)nodetable[i].origin[2] < (int)spot[2] && (int)nodetable[i].origin[2]+5 > (int)spot[2]) ||
+				((int)nodetable[i].origin[2] > (int)spot[2] && (int)nodetable[i].origin[2]-5 < (int)spot[2]))
+			{
+				return 1;
+			}
+		}
+		i++;
+	}
+
+	return 0;
+}
+#endif
+
+int CanGetToVector(vec3_t org1, vec3_t org2, vec3_t mins, vec3_t maxs)
+{
+	trace_t tr;
+
+	trap_Trace(&tr, org1, mins, maxs, org2, ENTITYNUM_NONE, MASK_SOLID);
+
+	if (tr.fraction == 1 && !tr.startsolid && !tr.allsolid)
+	{
+		return 1;
+	}
+
+	return 0;
+}
+
+#if 0
+int CanGetToVectorTravel(vec3_t org1, vec3_t org2, vec3_t mins, vec3_t maxs)
+{
+	trace_t tr;
+	vec3_t a, ang, fwd;
+	vec3_t midpos, dmid;
+	float startheight, midheight, fLen;
+
+	mins[2] = -13;
+	maxs[2] = 13;
+
+	trap_Trace(&tr, org1, mins, maxs, org2, ENTITYNUM_NONE, MASK_SOLID);
+
+	if (tr.fraction != 1 || tr.startsolid || tr.allsolid)
+	{
+		return 0;
+	}
+
+	VectorSubtract(org2, org1, a);
+
+	vectoangles(a, ang);
+
+	AngleVectors(ang, fwd, NULL, NULL);
+
+	fLen = VectorLength(a)/2;
+
+	midpos[0] = org1[0] + fwd[0]*fLen;
+	midpos[1] = org1[1] + fwd[1]*fLen;
+	midpos[2] = org1[2] + fwd[2]*fLen;
+
+	VectorCopy(org1, dmid);
+	dmid[2] -= 1024;
+
+	trap_Trace(&tr, midpos, NULL, NULL, dmid, ENTITYNUM_NONE, MASK_SOLID);
+
+	startheight = org1[2] - tr.endpos[2];
+
+	VectorCopy(midpos, dmid);
+	dmid[2] -= 1024;
+
+	trap_Trace(&tr, midpos, NULL, NULL, dmid, ENTITYNUM_NONE, MASK_SOLID);
+
+	if (tr.startsolid || tr.allsolid)
+	{
+		return 1;
+	}
+
+	midheight = midpos[2] - tr.endpos[2];
+
+	if (midheight > startheight*2)
+	{
+		return 0; //too steep of a drop.. can't go on
+	}
+
+	return 1;
+}
+#else
+int CanGetToVectorTravel(vec3_t org1, vec3_t moveTo, vec3_t mins, vec3_t maxs)
+//int ExampleAnimEntMove(gentity_t *self, vec3_t moveTo, float stepSize)
+{
+	trace_t tr;
+	vec3_t stepTo;
+	vec3_t stepSub;
+	vec3_t stepGoal;
+	vec3_t workingOrg;
+	vec3_t lastIncrement;
+	vec3_t finalMeasure;
+	float stepSize = 0;
+	float measureLength = 0;
+	int didMove = 0;
+	int traceMask = MASK_PLAYERSOLID;
+	qboolean initialDone = qfalse;
+
+	VectorCopy(org1, workingOrg);
+	VectorCopy(org1, lastIncrement);
+
+	VectorCopy(moveTo, stepTo);
+	stepTo[2] = workingOrg[2];
+
+	VectorSubtract(stepTo, workingOrg, stepSub);
+	stepSize = VectorLength(stepSub); //make the step size the length of the original positions without Z
+
+	VectorNormalize(stepSub);
+
+	while (!initialDone || didMove)
+	{
+		initialDone = qtrue;
+		didMove = 0;
+
+		stepGoal[0] = workingOrg[0] + stepSub[0]*stepSize;
+		stepGoal[1] = workingOrg[1] + stepSub[1]*stepSize;
+		stepGoal[2] = workingOrg[2] + stepSub[2]*stepSize;
+
+		trap_Trace(&tr, workingOrg, mins, maxs, stepGoal, ENTITYNUM_NONE, traceMask);
+
+		if (!tr.startsolid && !tr.allsolid && tr.fraction)
+		{
+			vec3_t vecSub;
+			VectorSubtract(workingOrg, tr.endpos, vecSub);
+
+			if (VectorLength(vecSub) > (stepSize/2))
+			{
+				workingOrg[0] = tr.endpos[0];
+				workingOrg[1] = tr.endpos[1];
+				//trap_LinkEntity(self);
+				didMove = 1;
+			}
+		}
+		
+		if (didMove != 1)
+		{ //stair check
+			vec3_t trFrom;
+			vec3_t trTo;
+			vec3_t trDir;
+			vec3_t vecMeasure;
+
+			VectorCopy(tr.endpos, trFrom);
+			trFrom[2] += 16;
+
+			VectorSubtract(/*tr.endpos*/stepGoal, workingOrg, trDir);
+			VectorNormalize(trDir);
+			trTo[0] = tr.endpos[0] + trDir[0]*2;
+			trTo[1] = tr.endpos[1] + trDir[1]*2;
+			trTo[2] = tr.endpos[2] + trDir[2]*2;
+			trTo[2] += 16;
+
+			VectorSubtract(trFrom, trTo, vecMeasure);
+
+			if (VectorLength(vecMeasure) > 1)
+			{
+				trap_Trace(&tr, trFrom, mins, maxs, trTo, ENTITYNUM_NONE, traceMask);
+
+				if (!tr.startsolid && !tr.allsolid && tr.fraction == 1)
+				{ //clear trace here, probably up a step
+					vec3_t trDown;
+					vec3_t trUp;
+					VectorCopy(tr.endpos, trUp);
+					VectorCopy(tr.endpos, trDown);
+					trDown[2] -= 16;
+
+					trap_Trace(&tr, trFrom, mins, maxs, trTo, ENTITYNUM_NONE, traceMask);
+
+					if (!tr.startsolid && !tr.allsolid)
+					{ //plop us down on the step after moving up
+						VectorCopy(tr.endpos, workingOrg);
+						//trap_LinkEntity(self);
+						didMove = 1;
+					}
+				}
+			}
+		}
+
+		VectorSubtract(lastIncrement, workingOrg, finalMeasure);
+		measureLength = VectorLength(finalMeasure);
+
+		if (!measureLength)
+		{ //no progress, break out. If last movement was a sucess didMove will equal 1.
+			break;
+		}
+
+		stepSize -= measureLength; //subtract the progress distance from the step size so we don't overshoot the mark.
+		if (stepSize <= 0)
+		{
+			break;
+		}
+
+		VectorCopy(workingOrg, lastIncrement);
+	}
+
+	return didMove;
+}
+#endif
+
+#ifndef _XBOX
+int ConnectTrail(int startindex, int endindex, qboolean behindTheScenes)
+{
+	int foundit;
+	int cancontinue;
+	int i;
+	int failsafe;
+	int successnodeindex;
+	int insertindex;
+	int prenodestart;
+	byte extendednodes[MAX_NODETABLE_SIZE]; //for storing checked nodes and not trying to extend them each a bazillion times
+	float fvecmeas;
+	float baseheight;
+	float branchDistance;
+	float maxDistFactor = 256;
+	vec3_t a;
+	vec3_t startplace, starttrace;
+	vec3_t mins, maxs;
+	vec3_t testspot;
+	vec3_t validspotpos;
+	trace_t tr;
+
+	if (g_RMG.integer)
+	{ //this might be temporary. Or not.
+		if (!(gWPArray[startindex]->flags & WPFLAG_NEVERONEWAY) &&
+			!(gWPArray[endindex]->flags & WPFLAG_NEVERONEWAY))
+		{
+			gWPArray[startindex]->flags |= WPFLAG_ONEWAY_FWD;
+			gWPArray[endindex]->flags |= WPFLAG_ONEWAY_BACK;
+		}
+		return 0;
+	}
+
+	if (!g_RMG.integer)
+	{
+		branchDistance = TABLE_BRANCH_DISTANCE;
+	}
+	else
+	{
+		branchDistance = 512; //be less precise here, terrain is fairly broad, and we don't want to take an hour precalculating
+	}
+
+	if (g_RMG.integer)
+	{
+		maxDistFactor = 700;
+	}
+
+	mins[0] = -15;
+	mins[1] = -15;
+	mins[2] = 0;
+	maxs[0] = 15;
+	maxs[1] = 15;
+	maxs[2] = 0;
+
+	nodenum = 0;
+	foundit = 0;
+
+	i = 0;
+
+	successnodeindex = 0;
+
+	while (i < MAX_NODETABLE_SIZE) //clear it out before using it
+	{
+		nodetable[i].flags = 0;
+//		nodetable[i].index = 0;
+		nodetable[i].inuse = 0;
+		nodetable[i].neighbornum = 0;
+		nodetable[i].origin[0] = 0;
+		nodetable[i].origin[1] = 0;
+		nodetable[i].origin[2] = 0;
+		nodetable[i].weight = 0;
+
+		extendednodes[i] = 0;
+
+		i++;
+	}
+
+	i = 0;
+
+	if (!behindTheScenes)
+	{
+		G_Printf(S_COLOR_YELLOW "Point %i is not connected to %i - Repairing...\n", startindex, endindex);
+	}
+
+	VectorCopy(gWPArray[startindex]->origin, startplace);
+
+	VectorCopy(startplace, starttrace);
+
+	starttrace[2] -= 4096;
+
+	trap_Trace(&tr, startplace, NULL, NULL, starttrace, ENTITYNUM_NONE, MASK_SOLID);
+
+	baseheight = startplace[2] - tr.endpos[2];
+
+	cancontinue = 1;
+
+	VectorCopy(startplace, nodetable[nodenum].origin);
+	nodetable[nodenum].weight = 1;
+	nodetable[nodenum].inuse = 1;
+//	nodetable[nodenum].index = nodenum;
+	nodenum++;
+
+	while (nodenum < MAX_NODETABLE_SIZE && !foundit && cancontinue)
+	{
+		if (g_RMG.integer)
+		{ //adjust the branch distance dynamically depending on the distance from the start and end points.
+			vec3_t startDist;
+			vec3_t endDist;
+			float startDistf;
+			float endDistf;
+
+			VectorSubtract(nodetable[nodenum-1].origin, gWPArray[startindex]->origin, startDist);
+			VectorSubtract(nodetable[nodenum-1].origin, gWPArray[endindex]->origin, endDist);
+
+			startDistf = VectorLength(startDist);
+			endDistf = VectorLength(endDist);
+
+			if (startDistf < 64 || endDistf < 64)
+			{
+				branchDistance = 64;
+			}
+			else if (startDistf < 128 || endDistf < 128)
+			{
+				branchDistance = 128;
+			}
+			else if (startDistf < 256 || endDistf < 256)
+			{
+				branchDistance = 256;
+			}
+			else if (startDistf < 512 || endDistf < 512)
+			{
+				branchDistance = 512;
+			}
+			else
+			{
+				branchDistance = 800;
+			}
+		}
+		cancontinue = 0;
+		i = 0;
+		prenodestart = nodenum;
+
+		while (i < prenodestart)
+		{
+			if (extendednodes[i] != 1)
+			{
+				VectorSubtract(gWPArray[endindex]->origin, nodetable[i].origin, a);
+				fvecmeas = VectorLength(a);
+
+				if (fvecmeas < 128 && CanGetToVector(gWPArray[endindex]->origin, nodetable[i].origin, mins, maxs))
+				{
+					foundit = 1;
+					successnodeindex = i;
+					break;
+				}
+
+				VectorCopy(nodetable[i].origin, testspot);
+				testspot[0] += branchDistance;
+
+				VectorCopy(testspot, starttrace);
+
+				starttrace[2] -= 4096;
+
+				trap_Trace(&tr, testspot, NULL, NULL, starttrace, ENTITYNUM_NONE, MASK_SOLID);
+
+				testspot[2] = tr.endpos[2]+baseheight;
+
+				if (!NodeHere(testspot) && !tr.startsolid && !tr.allsolid && CanGetToVector(nodetable[i].origin, testspot, mins, maxs))
+				{
+					VectorCopy(testspot, nodetable[nodenum].origin);
+					nodetable[nodenum].inuse = 1;
+//					nodetable[nodenum].index = nodenum;
+					nodetable[nodenum].weight = nodetable[i].weight+1;
+					nodetable[nodenum].neighbornum = i;
+					if ((nodetable[i].origin[2] - nodetable[nodenum].origin[2]) > 50)
+					{ //if there's a big drop, make sure we know we can't just magically fly back up
+						nodetable[nodenum].flags = WPFLAG_ONEWAY_FWD;
+					}
+					nodenum++;
+					cancontinue = 1;
+				}
+
+				if (nodenum >= MAX_NODETABLE_SIZE)
+				{
+					break; //failure
+				}
+
+				VectorCopy(nodetable[i].origin, testspot);
+				testspot[0] -= branchDistance;
+
+				VectorCopy(testspot, starttrace);
+
+				starttrace[2] -= 4096;
+
+				trap_Trace(&tr, testspot, NULL, NULL, starttrace, ENTITYNUM_NONE, MASK_SOLID);
+
+				testspot[2] = tr.endpos[2]+baseheight;
+
+				if (!NodeHere(testspot) && !tr.startsolid && !tr.allsolid && CanGetToVector(nodetable[i].origin, testspot, mins, maxs))
+				{
+					VectorCopy(testspot, nodetable[nodenum].origin);
+					nodetable[nodenum].inuse = 1;
+//					nodetable[nodenum].index = nodenum;
+					nodetable[nodenum].weight = nodetable[i].weight+1;
+					nodetable[nodenum].neighbornum = i;
+					if ((nodetable[i].origin[2] - nodetable[nodenum].origin[2]) > 50)
+					{ //if there's a big drop, make sure we know we can't just magically fly back up
+						nodetable[nodenum].flags = WPFLAG_ONEWAY_FWD;
+					}
+					nodenum++;
+					cancontinue = 1;
+				}
+
+				if (nodenum >= MAX_NODETABLE_SIZE)
+				{
+					break; //failure
+				}
+
+				VectorCopy(nodetable[i].origin, testspot);
+				testspot[1] += branchDistance;
+
+				VectorCopy(testspot, starttrace);
+
+				starttrace[2] -= 4096;
+
+				trap_Trace(&tr, testspot, NULL, NULL, starttrace, ENTITYNUM_NONE, MASK_SOLID);
+
+				testspot[2] = tr.endpos[2]+baseheight;
+
+				if (!NodeHere(testspot) && !tr.startsolid && !tr.allsolid && CanGetToVector(nodetable[i].origin, testspot, mins, maxs))
+				{
+					VectorCopy(testspot, nodetable[nodenum].origin);
+					nodetable[nodenum].inuse = 1;
+//					nodetable[nodenum].index = nodenum;
+					nodetable[nodenum].weight = nodetable[i].weight+1;
+					nodetable[nodenum].neighbornum = i;
+					if ((nodetable[i].origin[2] - nodetable[nodenum].origin[2]) > 50)
+					{ //if there's a big drop, make sure we know we can't just magically fly back up
+						nodetable[nodenum].flags = WPFLAG_ONEWAY_FWD;
+					}
+					nodenum++;
+					cancontinue = 1;
+				}
+
+				if (nodenum >= MAX_NODETABLE_SIZE)
+				{
+					break; //failure
+				}
+
+				VectorCopy(nodetable[i].origin, testspot);
+				testspot[1] -= branchDistance;
+
+				VectorCopy(testspot, starttrace);
+
+				starttrace[2] -= 4096;
+
+				trap_Trace(&tr, testspot, NULL, NULL, starttrace, ENTITYNUM_NONE, MASK_SOLID);
+
+				testspot[2] = tr.endpos[2]+baseheight;
+
+				if (!NodeHere(testspot) && !tr.startsolid && !tr.allsolid && CanGetToVector(nodetable[i].origin, testspot, mins, maxs))
+				{
+					VectorCopy(testspot, nodetable[nodenum].origin);
+					nodetable[nodenum].inuse = 1;
+//					nodetable[nodenum].index = nodenum;
+					nodetable[nodenum].weight = nodetable[i].weight+1;
+					nodetable[nodenum].neighbornum = i;
+					if ((nodetable[i].origin[2] - nodetable[nodenum].origin[2]) > 50)
+					{ //if there's a big drop, make sure we know we can't just magically fly back up
+						nodetable[nodenum].flags = WPFLAG_ONEWAY_FWD;
+					}
+					nodenum++;
+					cancontinue = 1;
+				}
+
+				if (nodenum >= MAX_NODETABLE_SIZE)
+				{
+					break; //failure
+				}
+
+				extendednodes[i] = 1;
+			}
+
+			i++;
+		}
+	}
+
+	if (!foundit)
+	{
+#ifndef _DEBUG //if debug just always print this.
+		if (!behindTheScenes)
+#endif
+		{
+			G_Printf(S_COLOR_RED "Could not link %i to %i, unreachable by node branching.\n", startindex, endindex);
+		}
+		gWPArray[startindex]->flags |= WPFLAG_ONEWAY_FWD;
+		gWPArray[endindex]->flags |= WPFLAG_ONEWAY_BACK;
+		if (!behindTheScenes)
+		{
+			G_Printf(S_COLOR_YELLOW "Since points cannot be connected, point %i has been flagged as only-forward and point %i has been flagged as only-backward.\n", startindex, endindex);
+		}
+
+		/*while (nodenum >= 0)
+		{
+			if (nodetable[nodenum].origin[0] || nodetable[nodenum].origin[1] || nodetable[nodenum].origin[2])
+			{
+				CreateNewWP(nodetable[nodenum].origin, nodetable[nodenum].flags);
+			}
+
+			nodenum--;
+		}*/
+		//The above code transfers nodes into the "rendered" waypoint array. Strictly for debugging.
+
+		if (!behindTheScenes)
+		{ //just use what we have if we're auto-pathing the level
+			return 0;
+		}
+		else
+		{
+			vec3_t endDist;
+			int nCount = 0;
+			int idealNode = -1;
+			float bestDist = 0;
+			float testDist;
+
+			if (nodenum <= 10)
+			{ //not enough to even really bother.
+				return 0;
+			}
+
+			//Since it failed, find whichever node is closest to the desired end.
+			while (nCount < nodenum)
+			{
+				VectorSubtract(nodetable[nCount].origin, gWPArray[endindex]->origin, endDist);
+				testDist = VectorLength(endDist);
+				if (idealNode == -1)
+				{
+					idealNode = nCount;
+					bestDist = testDist;
+					nCount++;
+					continue;
+				}
+
+				if (testDist < bestDist)
+				{
+					idealNode = nCount;
+					bestDist = testDist;
+				}
+
+				nCount++;
+			}
+
+			if (idealNode == -1)
+			{
+				return 0;
+			}
+
+			successnodeindex = idealNode;
+		}
+	}
+
+	i = successnodeindex;
+	insertindex = startindex;
+	failsafe = 0;
+	VectorCopy(gWPArray[startindex]->origin, validspotpos);
+
+	while (failsafe < MAX_NODETABLE_SIZE && i < MAX_NODETABLE_SIZE && i >= 0)
+	{
+		VectorSubtract(validspotpos, nodetable[i].origin, a);
+		if (!nodetable[nodetable[i].neighbornum].inuse || !CanGetToVectorTravel(validspotpos, /*nodetable[nodetable[i].neighbornum].origin*/nodetable[i].origin, mins, maxs) || VectorLength(a) > maxDistFactor || (!CanGetToVectorTravel(validspotpos, gWPArray[endindex]->origin, mins, maxs) && CanGetToVectorTravel(nodetable[i].origin, gWPArray[endindex]->origin, mins, maxs)) )
+		{
+			nodetable[i].flags |= WPFLAG_CALCULATED;
+			if (!CreateNewWP_InTrail(nodetable[i].origin, nodetable[i].flags, insertindex))
+			{
+				if (!behindTheScenes)
+				{
+					G_Printf(S_COLOR_RED "Could not link %i to %i, waypoint limit hit.\n", startindex, endindex);
+				}
+				return 0;
+			}
+
+			VectorCopy(nodetable[i].origin, validspotpos);
+		}
+
+		if (i == 0)
+		{
+			break;
+		}
+
+		i = nodetable[i].neighbornum;
+
+		failsafe++;
+	}
+
+	if (!behindTheScenes)
+	{
+		G_Printf(S_COLOR_YELLOW "Finished connecting %i to %i.\n", startindex, endindex);
+	}
+
+	return 1;
+}
+#endif
+
+int OpposingEnds(int start, int end)
+{
+	if (!gWPArray[start] || !gWPArray[start]->inuse || !gWPArray[end] || !gWPArray[end]->inuse)
+	{
+		return 0;
+	}
+
+	if ((gWPArray[start]->flags & WPFLAG_ONEWAY_FWD) &&
+		(gWPArray[end]->flags & WPFLAG_ONEWAY_BACK))
+	{
+		return 1;
+	}
+
+	return 0;
+}
+
+int DoorBlockingSection(int start, int end)
+{ //if a door blocks the trail, we'll just have to assume the points on each side are in visibility when it's open
+	trace_t tr;
+	gentity_t *testdoor;
+	int start_trace_index;
+
+	if (!gWPArray[start] || !gWPArray[start]->inuse || !gWPArray[end] || !gWPArray[end]->inuse)
+	{
+		return 0;
+	}
+
+	trap_Trace(&tr, gWPArray[start]->origin, NULL, NULL, gWPArray[end]->origin, ENTITYNUM_NONE, MASK_SOLID);
+
+	if (tr.fraction == 1)
+	{
+		return 0;
+	}
+
+	testdoor = &g_entities[tr.entityNum];
+
+	if (!testdoor)
+	{
+		return 0;
+	}
+
+	if (!strstr(testdoor->classname, "func_"))
+	{
+		return 0;
+	}
+
+	start_trace_index = tr.entityNum;
+
+	trap_Trace(&tr, gWPArray[end]->origin, NULL, NULL, gWPArray[start]->origin, ENTITYNUM_NONE, MASK_SOLID);
+
+	if (tr.fraction == 1)
+	{
+		return 0;
+	}
+
+	if (start_trace_index == tr.entityNum)
+	{
+		return 1;
+	}
+
+	return 0;
+}
+
+#ifndef _XBOX
+int RepairPaths(qboolean behindTheScenes)
+{
+	int i;
+	int preAmount = 0;
+	int ctRet;
+	vec3_t a;
+	float maxDistFactor = 400;
+
+	if (!gWPNum)
+	{
+		return 0;
+	}
+
+	if (g_RMG.integer)
+	{
+		maxDistFactor = 800; //higher tolerance here.
+	}
+
+	i = 0;
+
+	preAmount = gWPNum;
+
+	trap_Cvar_Update(&bot_wp_distconnect);
+	trap_Cvar_Update(&bot_wp_visconnect);
+
+	while (i < gWPNum)
+	{
+		if (gWPArray[i] && gWPArray[i]->inuse && gWPArray[i+1] && gWPArray[i+1]->inuse)
+		{
+			VectorSubtract(gWPArray[i]->origin, gWPArray[i+1]->origin, a);
+
+			if (!(gWPArray[i+1]->flags & WPFLAG_NOVIS) &&
+				!(gWPArray[i+1]->flags & WPFLAG_JUMP) && //don't calculate on jump points because they might not always want to be visible (in cases of force jumping)
+				!(gWPArray[i]->flags & WPFLAG_CALCULATED) && //don't calculate it again
+				!OpposingEnds(i, i+1) &&
+				((bot_wp_distconnect.value && VectorLength(a) > maxDistFactor) || (!OrgVisible(gWPArray[i]->origin, gWPArray[i+1]->origin, ENTITYNUM_NONE) && bot_wp_visconnect.value) ) &&
+				!DoorBlockingSection(i, i+1))
+			{
+				ctRet = ConnectTrail(i, i+1, behindTheScenes);
+
+				if (gWPNum >= MAX_WPARRAY_SIZE)
+				{ //Bad!
+					gWPNum = MAX_WPARRAY_SIZE;
+					break;
+				}
+
+				/*if (!ctRet)
+				{
+					return 0;
+				}*/ //we still want to write it..
+			}
+		}
+
+		i++;
+	}
+
+	return 1;
+}
+#endif
+
+int OrgVisibleCurve(vec3_t org1, vec3_t mins, vec3_t maxs, vec3_t org2, int ignore)
+{
+	trace_t tr;
+	vec3_t evenorg1;
+
+	VectorCopy(org1, evenorg1);
+	evenorg1[2] = org2[2];
+
+	trap_Trace(&tr, evenorg1, mins, maxs, org2, ignore, MASK_SOLID);
+
+	if (tr.fraction == 1 && !tr.startsolid && !tr.allsolid)
+	{
+		trap_Trace(&tr, evenorg1, mins, maxs, org1, ignore, MASK_SOLID);
+
+		if (tr.fraction == 1 && !tr.startsolid && !tr.allsolid)
+		{
+			return 1;
+		}
+	}
+
+	return 0;
+}
+
+int CanForceJumpTo(int baseindex, int testingindex, float distance)
+{
+	float heightdif;
+	vec3_t xy_base, xy_test, v, mins, maxs;
+	wpobject_t *wpBase = gWPArray[baseindex];
+	wpobject_t *wpTest = gWPArray[testingindex];
+
+	mins[0] = -15;
+	mins[1] = -15;
+	mins[2] = -15; //-1
+	maxs[0] = 15;
+	maxs[1] = 15;
+	maxs[2] = 15; //1
+
+	if (!wpBase || !wpBase->inuse || !wpTest || !wpTest->inuse)
+	{
+		return 0;
+	}
+
+	if (distance > 400)
+	{
+		return 0;
+	}
+
+	VectorCopy(wpBase->origin, xy_base);
+	VectorCopy(wpTest->origin, xy_test);
+
+	xy_base[2] = xy_test[2];
+
+	VectorSubtract(xy_base, xy_test, v);
+
+	if (VectorLength(v) > MAX_NEIGHBOR_LINK_DISTANCE)
+	{
+		return 0;
+	}
+
+	if ((int)wpBase->origin[2] < (int)wpTest->origin[2])
+	{
+		heightdif = wpTest->origin[2] - wpBase->origin[2];
+	}
+	else
+	{
+		return 0; //err..
+	}
+
+	if (heightdif < 128)
+	{ //don't bother..
+		return 0;
+	}
+
+	if (heightdif > 512)
+	{ //too high
+		return 0;
+	}
+
+	if (!OrgVisibleCurve(wpBase->origin, mins, maxs, wpTest->origin, ENTITYNUM_NONE))
+	{
+		return 0;
+	}
+
+	if (heightdif > 400)
+	{
+		return 3;
+	}
+	else if (heightdif > 256)
+	{
+		return 2;
+	}
+	else
+	{
+		return 1;
+	}
+}
+
+void CalculatePaths(void)
+{
+	int i;
+	int c;
+	int forceJumpable;
+	int maxNeighborDist = MAX_NEIGHBOR_LINK_DISTANCE;
+	float nLDist;
+	vec3_t a;
+	vec3_t mins, maxs;
+
+	if (!gWPNum)
+	{
+		return;
+	}
+
+	if (g_RMG.integer)
+	{
+		maxNeighborDist = DEFAULT_GRID_SPACING + (DEFAULT_GRID_SPACING*0.5);
+	}
+
+	mins[0] = -15;
+	mins[1] = -15;
+	mins[2] = -15; //-1
+	maxs[0] = 15;
+	maxs[1] = 15;
+	maxs[2] = 15; //1
+
+	//now clear out all the neighbor data before we recalculate
+	i = 0;
+
+	while (i < gWPNum)
+	{
+		if (gWPArray[i] && gWPArray[i]->inuse && gWPArray[i]->neighbornum)
+		{
+			while (gWPArray[i]->neighbornum >= 0)
+			{
+				gWPArray[i]->neighbors[gWPArray[i]->neighbornum].num = 0;
+				gWPArray[i]->neighbors[gWPArray[i]->neighbornum].forceJumpTo = 0;
+				gWPArray[i]->neighbornum--;
+			}
+			gWPArray[i]->neighbornum = 0;
+		}
+
+		i++;
+	}
+
+	i = 0;
+
+	while (i < gWPNum)
+	{
+		if (gWPArray[i] && gWPArray[i]->inuse)
+		{
+			c = 0;
+
+			while (c < gWPNum)
+			{
+				if (gWPArray[c] && gWPArray[c]->inuse && i != c &&
+					NotWithinRange(i, c))
+				{
+					VectorSubtract(gWPArray[i]->origin, gWPArray[c]->origin, a);
+
+					nLDist = VectorLength(a);
+					forceJumpable = CanForceJumpTo(i, c, nLDist);
+
+					if ((nLDist < maxNeighborDist || forceJumpable) &&
+						((int)gWPArray[i]->origin[2] == (int)gWPArray[c]->origin[2] || forceJumpable) &&
+						(OrgVisibleBox(gWPArray[i]->origin, mins, maxs, gWPArray[c]->origin, ENTITYNUM_NONE) || forceJumpable))
+					{
+						gWPArray[i]->neighbors[gWPArray[i]->neighbornum].num = c;
+						if (forceJumpable && ((int)gWPArray[i]->origin[2] != (int)gWPArray[c]->origin[2] || nLDist < maxNeighborDist))
+						{
+							gWPArray[i]->neighbors[gWPArray[i]->neighbornum].forceJumpTo = 999;//forceJumpable; //FJSR
+						}
+						else
+						{
+							gWPArray[i]->neighbors[gWPArray[i]->neighbornum].forceJumpTo = 0;
+						}
+						gWPArray[i]->neighbornum++;
+					}
+
+					if (gWPArray[i]->neighbornum >= MAX_NEIGHBOR_SIZE)
+					{
+						break;
+					}
+				}
+				c++;
+			}
+		}
+		i++;
+	}
+}
+
+gentity_t *GetObjectThatTargets(gentity_t *ent)
+{
+	gentity_t *next = NULL;
+
+	if (!ent->targetname)
+	{
+		return NULL;
+	}
+
+	next = G_Find( next, FOFS(target), ent->targetname );
+
+	if (next)
+	{
+		return next;
+	}
+
+	return NULL;
+}
+
+void CalculateSiegeGoals(void)
+{
+	int i = 0;
+	int looptracker = 0;
+	int wpindex = 0;
+	vec3_t dif;
+	gentity_t *ent;
+	gentity_t *tent = NULL, *t2ent = NULL;
+
+	while (i < level.num_entities)
+	{
+		ent = &g_entities[i];
+
+		tent = NULL;
+
+		if (ent && ent->classname && strcmp(ent->classname, "info_siege_objective") == 0)
+		{
+			tent = ent;
+			t2ent = GetObjectThatTargets(tent);
+			looptracker = 0;
+
+			while (t2ent && looptracker < 2048)
+			{ //looptracker keeps us from getting stuck in case something is set up weird on this map
+				tent = t2ent;
+				t2ent = GetObjectThatTargets(tent);
+				looptracker++;
+			}
+
+			if (looptracker >= 2048)
+			{ //something unpleasent has happened
+				tent = NULL;
+				break;
+			}
+		}
+
+		if (tent && ent && tent != ent)
+		{ //tent should now be the object attached to the mission objective
+			dif[0] = (tent->r.absmax[0]+tent->r.absmin[0])/2;
+			dif[1] = (tent->r.absmax[1]+tent->r.absmin[1])/2;
+			dif[2] = (tent->r.absmax[2]+tent->r.absmin[2])/2;
+
+			wpindex = GetNearestVisibleWP(dif, tent->s.number);
+
+			if (wpindex != -1 && gWPArray[wpindex] && gWPArray[wpindex]->inuse)
+			{ //found the waypoint nearest the center of this objective-related object
+				if (ent->side == SIEGETEAM_TEAM1)
+				{
+					gWPArray[wpindex]->flags |= WPFLAG_SIEGE_IMPERIALOBJ;
+				}
+				else
+				{
+					gWPArray[wpindex]->flags |= WPFLAG_SIEGE_REBELOBJ;
+				}
+
+				gWPArray[wpindex]->associated_entity = tent->s.number;
+			}
+		}
+
+		i++;
+	}
+}
+
+float botGlobalNavWeaponWeights[WP_NUM_WEAPONS] =
+{
+	0,//WP_NONE,
+
+	0,//WP_STUN_BATON,
+	0,//WP_MELEE
+	0,//WP_SABER,				 // NOTE: lots of code assumes this is the first weapon (... which is crap) so be careful -Ste.
+	0,//WP_BRYAR_PISTOL,
+	3,//WP_BLASTER,
+	5,//WP_DISRUPTOR,
+	4,//WP_BOWCASTER,
+	6,//WP_REPEATER,
+	7,//WP_DEMP2,
+	8,//WP_FLECHETTE,
+	9,//WP_ROCKET_LAUNCHER,
+	3,//WP_THERMAL,
+	3,//WP_TRIP_MINE,
+	3,//WP_DET_PACK,
+	0//WP_EMPLACED_GUN,
+};
+
+int GetNearestVisibleWPToItem(vec3_t org, int ignore)
+{
+	int i;
+	float bestdist;
+	float flLen;
+	int bestindex;
+	vec3_t a, mins, maxs;
+
+	i = 0;
+	bestdist = 64; //has to be less than 64 units to the item or it isn't safe enough
+	bestindex = -1;
+
+	mins[0] = -15;
+	mins[1] = -15;
+	mins[2] = 0;
+	maxs[0] = 15;
+	maxs[1] = 15;
+	maxs[2] = 0;
+
+	while (i < gWPNum)
+	{
+		if (gWPArray[i] && gWPArray[i]->inuse &&
+			gWPArray[i]->origin[2]-15 < org[2] &&
+			gWPArray[i]->origin[2]+15 > org[2])
+		{
+			VectorSubtract(org, gWPArray[i]->origin, a);
+			flLen = VectorLength(a);
+
+			if (flLen < bestdist && trap_InPVS(org, gWPArray[i]->origin) && OrgVisibleBox(org, mins, maxs, gWPArray[i]->origin, ignore))
+			{
+				bestdist = flLen;
+				bestindex = i;
+			}
+		}
+
+		i++;
+	}
+
+	return bestindex;
+}
+
+void CalculateWeightGoals(void)
+{ //set waypoint weights depending on weapon and item placement
+	int i = 0;
+	int wpindex = 0;
+	gentity_t *ent;
+	float weight;
+
+	trap_Cvar_Update(&bot_wp_clearweight);
+
+	if (bot_wp_clearweight.integer)
+	{ //if set then flush out all weight/goal values before calculating them again
+		while (i < gWPNum)
+		{
+			if (gWPArray[i] && gWPArray[i]->inuse)
+			{
+				gWPArray[i]->weight = 0;
+
+				if (gWPArray[i]->flags & WPFLAG_GOALPOINT)
+				{
+					gWPArray[i]->flags -= WPFLAG_GOALPOINT;
+				}
+			}
+
+			i++;
+		}
+	}
+
+	i = 0;
+
+	while (i < level.num_entities)
+	{
+		ent = &g_entities[i];
+
+		weight = 0;
+
+		if (ent && ent->classname)
+		{
+			if (strcmp(ent->classname, "item_seeker") == 0)
+			{
+				weight = 2;
+			}
+			else if (strcmp(ent->classname, "item_shield") == 0)
+			{
+				weight = 2;
+			}
+			else if (strcmp(ent->classname, "item_medpac") == 0)
+			{
+				weight = 2;
+			}
+			else if (strcmp(ent->classname, "item_sentry_gun") == 0)
+			{
+				weight = 2;
+			}
+			else if (strcmp(ent->classname, "item_force_enlighten_dark") == 0)
+			{
+				weight = 5;
+			}
+			else if (strcmp(ent->classname, "item_force_enlighten_light") == 0)
+			{
+				weight = 5;
+			}
+			else if (strcmp(ent->classname, "item_force_boon") == 0)
+			{
+				weight = 5;
+			}
+			else if (strcmp(ent->classname, "item_ysalimari") == 0)
+			{
+				weight = 2;
+			}
+			else if (strstr(ent->classname, "weapon_") && ent->item)
+			{
+				weight = botGlobalNavWeaponWeights[ent->item->giTag];
+			}
+			else if (ent->item && ent->item->giType == IT_AMMO)
+			{
+				weight = 3;
+			}
+		}
+
+		if (ent && weight)
+		{
+			wpindex = GetNearestVisibleWPToItem(ent->s.pos.trBase, ent->s.number);
+
+			if (wpindex != -1 && gWPArray[wpindex] && gWPArray[wpindex]->inuse)
+			{ //found the waypoint nearest the center of this object
+				gWPArray[wpindex]->weight = weight;
+				gWPArray[wpindex]->flags |= WPFLAG_GOALPOINT;
+				gWPArray[wpindex]->associated_entity = ent->s.number;
+			}
+		}
+
+		i++;
+	}
+}
+
+void CalculateJumpRoutes(void)
+{
+	int i = 0;
+	float nheightdif = 0;
+	float pheightdif = 0;
+
+	while (i < gWPNum)
+	{
+		if (gWPArray[i] && gWPArray[i]->inuse)
+		{
+			if (gWPArray[i]->flags & WPFLAG_JUMP)
+			{
+				nheightdif = 0;
+				pheightdif = 0;
+
+				gWPArray[i]->forceJumpTo = 0;
+
+				if (gWPArray[i-1] && gWPArray[i-1]->inuse && (gWPArray[i-1]->origin[2]+16) < gWPArray[i]->origin[2])
+				{
+					nheightdif = (gWPArray[i]->origin[2] - gWPArray[i-1]->origin[2]);
+				}
+
+				if (gWPArray[i+1] && gWPArray[i+1]->inuse && (gWPArray[i+1]->origin[2]+16) < gWPArray[i]->origin[2])
+				{
+					pheightdif = (gWPArray[i]->origin[2] - gWPArray[i+1]->origin[2]);
+				}
+
+				if (nheightdif > pheightdif)
+				{
+					pheightdif = nheightdif;
+				}
+
+				if (pheightdif)
+				{
+					if (pheightdif > 500)
+					{
+						gWPArray[i]->forceJumpTo = 999; //FORCE_LEVEL_3; //FJSR
+					}
+					else if (pheightdif > 256)
+					{
+						gWPArray[i]->forceJumpTo = 999; //FORCE_LEVEL_2; //FJSR
+					}
+					else if (pheightdif > 128)
+					{
+						gWPArray[i]->forceJumpTo = 999; //FORCE_LEVEL_1; //FJSR
+					}
+				}
+			}
+		}
+
+		i++;
+	}
+}
+
+int LoadPathData(const char *filename)
+{
+	fileHandle_t f;
+	char *fileString;
+	char *currentVar;
+	char *routePath;
+	wpobject_t thiswp;
+	int len;
+	int i, i_cv;
+	int nei_num;
+
+	i = 0;
+	i_cv = 0;
+
+	routePath = (char *)B_TempAlloc(1024);
+
+	Com_sprintf(routePath, 1024, "botroutes/%s.wnt\0", filename);
+
+	len = trap_FS_FOpenFile(routePath, &f, FS_READ);
+
+	B_TempFree(1024); //routePath
+
+	if (!f)
+	{
+		G_Printf(S_COLOR_YELLOW "Bot route data not found for %s\n", filename);
+		return 2;
+	}
+
+	if (len >= 524288)
+	{
+		G_Printf(S_COLOR_RED "Route file exceeds maximum length\n");
+		return 0;
+	}
+
+	fileString = (char *)B_TempAlloc(524288);
+	currentVar = (char *)B_TempAlloc(2048);
+
+	trap_FS_Read(fileString, len, f);
+
+	if (fileString[i] == 'l')
+	{ //contains a "levelflags" entry..
+		char readLFlags[64];
+		i_cv = 0;
+
+		while (fileString[i] != ' ')
+		{
+			i++;
+		}
+		i++;
+		while (fileString[i] != '\n')
+		{
+			readLFlags[i_cv] = fileString[i];
+			i_cv++;
+			i++;
+		}
+		readLFlags[i_cv] = 0;
+		i++;
+
+		gLevelFlags = atoi(readLFlags);
+	}
+	else
+	{
+		gLevelFlags = 0;
+	}
+
+	while (i < len)
+	{
+		i_cv = 0;
+
+		thiswp.index = 0;
+		thiswp.flags = 0;
+		thiswp.inuse = 0;
+		thiswp.neighbornum = 0;
+		thiswp.origin[0] = 0;
+		thiswp.origin[1] = 0;
+		thiswp.origin[2] = 0;
+		thiswp.weight = 0;
+		thiswp.associated_entity = ENTITYNUM_NONE;
+		thiswp.forceJumpTo = 0;
+		thiswp.disttonext = 0;
+		nei_num = 0;
+
+		while (nei_num < MAX_NEIGHBOR_SIZE)
+		{
+			thiswp.neighbors[nei_num].num = 0;
+			thiswp.neighbors[nei_num].forceJumpTo = 0;
+
+			nei_num++;
+		}
+		
+		while (fileString[i] != ' ')
+		{
+			currentVar[i_cv] = fileString[i];
+			i_cv++;
+			i++;
+		}
+		currentVar[i_cv] = '\0';
+
+		thiswp.index = atoi(currentVar);
+
+		i_cv = 0;
+		i++;
+
+		while (fileString[i] != ' ')
+		{
+			currentVar[i_cv] = fileString[i];
+			i_cv++;
+			i++;
+		}
+		currentVar[i_cv] = '\0';
+
+		thiswp.flags = atoi(currentVar);
+
+		i_cv = 0;
+		i++;
+
+		while (fileString[i] != ' ')
+		{
+			currentVar[i_cv] = fileString[i];
+			i_cv++;
+			i++;
+		}
+		currentVar[i_cv] = '\0';
+
+		thiswp.weight = atof(currentVar);
+
+		i_cv = 0;
+		i++;
+		i++;
+
+		while (fileString[i] != ' ')
+		{
+			currentVar[i_cv] = fileString[i];
+			i_cv++;
+			i++;
+		}
+		currentVar[i_cv] = '\0';
+
+		thiswp.origin[0] = atof(currentVar);
+
+		i_cv = 0;
+		i++;
+
+		while (fileString[i] != ' ')
+		{
+			currentVar[i_cv] = fileString[i];
+			i_cv++;
+			i++;
+		}
+		currentVar[i_cv] = '\0';
+
+		thiswp.origin[1] = atof(currentVar);
+
+		i_cv = 0;
+		i++;
+
+		while (fileString[i] != ')')
+		{
+			currentVar[i_cv] = fileString[i];
+			i_cv++;
+			i++;
+		}
+		currentVar[i_cv] = '\0';
+
+		thiswp.origin[2] = atof(currentVar);
+
+		i += 4;
+
+		while (fileString[i] != '}')
+		{
+			i_cv = 0;
+			while (fileString[i] != ' ' && fileString[i] != '-')
+			{
+				currentVar[i_cv] = fileString[i];
+				i_cv++;
+				i++;
+			}
+			currentVar[i_cv] = '\0';
+
+			thiswp.neighbors[thiswp.neighbornum].num = atoi(currentVar);
+
+			if (fileString[i] == '-')
+			{
+				i_cv = 0;
+				i++;
+
+				while (fileString[i] != ' ')
+				{
+					currentVar[i_cv] = fileString[i];
+					i_cv++;
+					i++;
+				}
+				currentVar[i_cv] = '\0';
+
+				thiswp.neighbors[thiswp.neighbornum].forceJumpTo = 999; //atoi(currentVar); //FJSR
+			}
+			else
+			{
+				thiswp.neighbors[thiswp.neighbornum].forceJumpTo = 0;
+			}
+
+			thiswp.neighbornum++;
+
+			i++;
+		}
+
+		i_cv = 0;
+		i++;
+		i++;
+
+		while (fileString[i] != '\n')
+		{
+			currentVar[i_cv] = fileString[i];
+			i_cv++;
+			i++;
+		}
+		currentVar[i_cv] = '\0';
+
+		thiswp.disttonext = atof(currentVar);
+
+		CreateNewWP_FromObject(&thiswp);
+		i++;
+	}
+
+	B_TempFree(524288); //fileString
+	B_TempFree(2048); //currentVar
+
+	trap_FS_FCloseFile(f);
+
+	if (g_gametype.integer == GT_SIEGE)
+	{
+		CalculateSiegeGoals();
+	}
+
+	CalculateWeightGoals();
+	//calculate weights for idle activity goals when
+	//the bot has absolutely nothing else to do
+
+	CalculateJumpRoutes();
+	//Look at jump points and mark them as requiring
+	//force jumping as needed
+
+	return 1;
+}
+
+void FlagObjects(void)
+{
+	int i = 0, bestindex = 0, found = 0;
+	float bestdist = 999999, tlen = 0;
+	gentity_t *flag_red, *flag_blue, *ent;
+	vec3_t a, mins, maxs;
+	trace_t tr;
+
+	flag_red = NULL;
+	flag_blue = NULL;
+
+	mins[0] = -15;
+	mins[1] = -15;
+	mins[2] = -5;
+	maxs[0] = 15;
+	maxs[1] = 15;
+	maxs[2] = 5;
+
+	while (i < level.num_entities)
+	{
+		ent = &g_entities[i];
+
+		if (ent && ent->inuse && ent->classname)
+		{
+			if (!flag_red && strcmp(ent->classname, "team_CTF_redflag") == 0)
+			{
+				flag_red = ent;
+			}
+			else if (!flag_blue && strcmp(ent->classname, "team_CTF_blueflag") == 0)
+			{
+				flag_blue = ent;
+			}
+
+			if (flag_red && flag_blue)
+			{
+				break;
+			}
+		}
+
+		i++;
+	}
+
+	i = 0;
+
+	if (!flag_red || !flag_blue)
+	{
+		return;
+	}
+
+	while (i < gWPNum)
+	{
+		if (gWPArray[i] && gWPArray[i]->inuse)
+		{
+			VectorSubtract(flag_red->s.pos.trBase, gWPArray[i]->origin, a);
+			tlen = VectorLength(a);
+
+			if (tlen < bestdist)
+			{
+				trap_Trace(&tr, flag_red->s.pos.trBase, mins, maxs, gWPArray[i]->origin, flag_red->s.number, MASK_SOLID);
+
+				if (tr.fraction == 1 || tr.entityNum == flag_red->s.number)
+				{
+					bestdist = tlen;
+					bestindex = i;
+					found = 1;
+				}
+			}
+
+		}
+
+		i++;
+	}
+
+	if (found)
+	{
+		gWPArray[bestindex]->flags |= WPFLAG_RED_FLAG;
+		flagRed = gWPArray[bestindex];
+		oFlagRed = flagRed;
+		eFlagRed = flag_red;
+	}
+
+	bestdist = 999999;
+	bestindex = 0;
+	found = 0;
+	i = 0;
+
+	while (i < gWPNum)
+	{
+		if (gWPArray[i] && gWPArray[i]->inuse)
+		{
+			VectorSubtract(flag_blue->s.pos.trBase, gWPArray[i]->origin, a);
+			tlen = VectorLength(a);
+
+			if (tlen < bestdist)
+			{
+				trap_Trace(&tr, flag_blue->s.pos.trBase, mins, maxs, gWPArray[i]->origin, flag_blue->s.number, MASK_SOLID);
+
+				if (tr.fraction == 1 || tr.entityNum == flag_blue->s.number)
+				{
+					bestdist = tlen;
+					bestindex = i;
+					found = 1;
+				}
+			}
+
+		}
+
+		i++;
+	}
+
+	if (found)
+	{
+		gWPArray[bestindex]->flags |= WPFLAG_BLUE_FLAG;
+		flagBlue = gWPArray[bestindex];
+		oFlagBlue = flagBlue;
+		eFlagBlue = flag_blue;
+	}
+}
+
+#ifndef _XBOX
+int SavePathData(const char *filename)
+{
+	fileHandle_t f;
+	char *fileString;
+	char *storeString;
+	char *routePath;
+	vec3_t a;
+	float flLen;
+	int i, s, n;
+
+	fileString = NULL;
+	i = 0;
+	s = 0;
+
+	if (!gWPNum)
+	{
+		return 0;
+	}
+
+	routePath = (char *)B_TempAlloc(1024);
+
+	Com_sprintf(routePath, 1024, "botroutes/%s.wnt\0", filename);
+
+	trap_FS_FOpenFile(routePath, &f, FS_WRITE);
+
+	B_TempFree(1024); //routePath
+
+	if (!f)
+	{
+		G_Printf(S_COLOR_RED "ERROR: Could not open file to write path data\n");
+		return 0;
+	}
+
+	if (!RepairPaths(qfalse)) //check if we can see all waypoints from the last. If not, try to branch over.
+	{
+		trap_FS_FCloseFile(f);
+		return 0;
+	}
+
+	CalculatePaths(); //make everything nice and connected before saving
+
+	FlagObjects(); //currently only used for flagging waypoints nearest CTF flags
+
+	fileString = (char *)B_TempAlloc(524288);
+	storeString = (char *)B_TempAlloc(4096);
+
+	Com_sprintf(fileString, 524288, "%i %i %f (%f %f %f) { ", gWPArray[i]->index, gWPArray[i]->flags, gWPArray[i]->weight, gWPArray[i]->origin[0], gWPArray[i]->origin[1], gWPArray[i]->origin[2]);
+
+	n = 0;
+
+	while (n < gWPArray[i]->neighbornum)
+	{
+		if (gWPArray[i]->neighbors[n].forceJumpTo)
+		{
+			Com_sprintf(storeString, 4096, "%s%i-%i ", storeString, gWPArray[i]->neighbors[n].num, gWPArray[i]->neighbors[n].forceJumpTo);
+		}
+		else
+		{
+			Com_sprintf(storeString, 4096, "%s%i ", storeString, gWPArray[i]->neighbors[n].num);
+		}
+		n++;
+	}
+
+	if (gWPArray[i+1] && gWPArray[i+1]->inuse && gWPArray[i+1]->index)
+	{
+		VectorSubtract(gWPArray[i]->origin, gWPArray[i+1]->origin, a);
+		flLen = VectorLength(a);
+	}
+	else
+	{
+		flLen = 0;
+	}
+
+	gWPArray[i]->disttonext = flLen;
+
+	Com_sprintf(fileString, 524288, "%s} %f\n", fileString, flLen);
+
+	i++;
+
+	while (i < gWPNum)
+	{
+		//sprintf(fileString, "%s%i %i %f (%f %f %f) { ", fileString, gWPArray[i]->index, gWPArray[i]->flags, gWPArray[i]->weight, gWPArray[i]->origin[0], gWPArray[i]->origin[1], gWPArray[i]->origin[2]);
+		Com_sprintf(storeString, 4096, "%i %i %f (%f %f %f) { ", gWPArray[i]->index, gWPArray[i]->flags, gWPArray[i]->weight, gWPArray[i]->origin[0], gWPArray[i]->origin[1], gWPArray[i]->origin[2]);
+
+		n = 0;
+
+		while (n < gWPArray[i]->neighbornum)
+		{
+			if (gWPArray[i]->neighbors[n].forceJumpTo)
+			{
+				Com_sprintf(storeString, 4096, "%s%i-%i ", storeString, gWPArray[i]->neighbors[n].num, gWPArray[i]->neighbors[n].forceJumpTo);
+			}
+			else
+			{
+				Com_sprintf(storeString, 4096, "%s%i ", storeString, gWPArray[i]->neighbors[n].num);
+			}
+			n++;
+		}
+
+		if (gWPArray[i+1] && gWPArray[i+1]->inuse && gWPArray[i+1]->index)
+		{
+			VectorSubtract(gWPArray[i]->origin, gWPArray[i+1]->origin, a);
+			flLen = VectorLength(a);
+		}
+		else
+		{
+			flLen = 0;
+		}
+
+		gWPArray[i]->disttonext = flLen;
+
+		Com_sprintf(storeString, 4096, "%s} %f\n", storeString, flLen);
+
+		strcat(fileString, storeString);
+
+		i++;
+	}
+
+	trap_FS_Write(fileString, strlen(fileString), f);
+
+	B_TempFree(524288); //fileString
+	B_TempFree(4096); //storeString
+
+	trap_FS_FCloseFile(f);
+
+	G_Printf("Path data has been saved and updated. You may need to restart the level for some things to be properly calculated.\n");
+
+	return 1;
+}
+#endif
+
+//#define PAINFULLY_DEBUGGING_THROUGH_VM
+
+#define MAX_SPAWNPOINT_ARRAY 64
+int gSpawnPointNum = 0;
+gentity_t *gSpawnPoints[MAX_SPAWNPOINT_ARRAY];
+
+#ifndef _XBOX
+int G_NearestNodeToPoint(vec3_t point)
+{ //gets the node on the entire grid which is nearest to the specified coordinates.
+	vec3_t vSub;
+	int bestIndex = -1;
+	int i = 0;
+	float bestDist = 0;
+	float testDist = 0;
+
+	while (i < nodenum)
+	{
+		VectorSubtract(nodetable[i].origin, point, vSub);
+		testDist = VectorLength(vSub);
+
+		if (bestIndex == -1)
+		{
+			bestIndex = i;
+			bestDist = testDist;
+
+			i++;
+			continue;
+		}
+
+		if (testDist < bestDist)
+		{
+			bestIndex = i;
+			bestDist = testDist;
+		}
+		i++;
+	}
+
+	return bestIndex;
+}
+#endif
+
+#ifndef _XBOX
+void G_NodeClearForNext(void)
+{ //reset nodes for the next trail connection.
+	int i = 0;
+
+	while (i < nodenum)
+	{
+		nodetable[i].flags = 0;
+		nodetable[i].weight = 99999;
+
+		i++;
+	}
+}
+
+void G_NodeClearFlags(void)
+{ //only clear out flags so nodes can be reused.
+	int i = 0;
+
+	while (i < nodenum)
+	{
+		nodetable[i].flags = 0;
+
+		i++;
+	}
+}
+
+int G_NodeMatchingXY(float x, float y)
+{ //just get the first unflagged node with the matching x,y coordinates.
+	int i = 0;
+
+	while (i < nodenum)
+	{
+		if (nodetable[i].origin[0] == x &&
+			nodetable[i].origin[1] == y &&
+			!nodetable[i].flags)
+		{
+			return i;
+		}
+
+		i++;
+	}
+
+	return -1;
+}
+
+int G_NodeMatchingXY_BA(int x, int y, int final)
+{ //return the node with the lowest weight that matches the specified x,y coordinates.
+	int i = 0;
+	int bestindex = -1;
+	float bestWeight = 9999;
+
+	while (i < nodenum)
+	{
+		if ((int)nodetable[i].origin[0] == x &&
+			(int)nodetable[i].origin[1] == y &&
+			!nodetable[i].flags &&
+			((nodetable[i].weight < bestWeight) || (i == final)))
+		{
+			if (i == final)
+			{
+				return i;
+			}
+			bestindex = i;
+			bestWeight = nodetable[i].weight;
+		}
+
+		i++;
+	}
+
+	return bestindex;
+}
+
+int G_RecursiveConnection(int start, int end, int weight, qboolean traceCheck, float baseHeight)
+{
+	int indexDirections[4]; //0 == down, 1 == up, 2 == left, 3 == right
+	int recursiveIndex = -1;
+	int i = 0;
+	int passWeight = weight;
+	vec2_t givenXY;
+	trace_t tr;
+
+	passWeight++;
+	nodetable[start].weight = passWeight;
+
+	givenXY[0] = nodetable[start].origin[0];
+	givenXY[1] = nodetable[start].origin[1];
+	givenXY[0] -= DEFAULT_GRID_SPACING;
+	indexDirections[0] = G_NodeMatchingXY(givenXY[0], givenXY[1]);
+
+	givenXY[0] = nodetable[start].origin[0];
+	givenXY[1] = nodetable[start].origin[1];
+	givenXY[0] += DEFAULT_GRID_SPACING;
+	indexDirections[1] = G_NodeMatchingXY(givenXY[0], givenXY[1]);
+
+	givenXY[0] = nodetable[start].origin[0];
+	givenXY[1] = nodetable[start].origin[1];
+	givenXY[1] -= DEFAULT_GRID_SPACING;
+	indexDirections[2] = G_NodeMatchingXY(givenXY[0], givenXY[1]);
+
+	givenXY[0] = nodetable[start].origin[0];
+	givenXY[1] = nodetable[start].origin[1];
+	givenXY[1] += DEFAULT_GRID_SPACING;
+	indexDirections[3] = G_NodeMatchingXY(givenXY[0], givenXY[1]);
+
+	i = 0;
+	while (i < 4)
+	{
+		if (indexDirections[i] == end)
+		{ //we've connected all the way to the destination.
+			return indexDirections[i];
+		}
+
+		if (indexDirections[i] != -1 && nodetable[indexDirections[i]].flags)
+		{ //this point is already used, so it's not valid.
+			indexDirections[i] = -1;
+		}
+		else if (indexDirections[i] != -1)
+		{ //otherwise mark it as used.
+			nodetable[indexDirections[i]].flags = 1;
+		}
+
+		if (indexDirections[i] != -1 && traceCheck)
+		{ //if we care about trace visibility between nodes, perform the check and mark as not valid if the trace isn't clear.
+			trap_Trace(&tr, nodetable[start].origin, NULL, NULL, nodetable[indexDirections[i]].origin, ENTITYNUM_NONE, CONTENTS_SOLID);
+
+			if (tr.fraction != 1)
+			{
+				indexDirections[i] = -1;
+			}
+		}
+
+		if (indexDirections[i] != -1)
+		{ //it's still valid, so keep connecting via this point.
+			recursiveIndex = G_RecursiveConnection(indexDirections[i], end, passWeight, traceCheck, baseHeight);
+		}
+
+		if (recursiveIndex != -1)
+		{ //the result of the recursive check was valid, so return it.
+			return recursiveIndex;
+		}
+
+		i++;
+	}
+
+	return recursiveIndex;
+}
+
+#ifdef DEBUG_NODE_FILE
+void G_DebugNodeFile()
+{
+	fileHandle_t f;
+	int i = 0;
+	float placeX;
+	char fileString[131072];
+	gentity_t *terrain = G_Find( NULL, FOFS(classname), "terrain" );
+
+	fileString[0] = 0;
+
+	placeX = terrain->r.absmin[0];
+
+	while (i < nodenum)
+	{
+		strcat(fileString, va("%i-%f ", i, nodetable[i].weight));
+		placeX += DEFAULT_GRID_SPACING;
+
+		if (placeX >= terrain->r.absmax[0])
+		{
+			strcat(fileString, "\n");
+			placeX = terrain->r.absmin[0];
+		}
+		i++;
+	}
+
+	trap_FS_FOpenFile("ROUTEDEBUG.txt", &f, FS_WRITE);
+	trap_FS_Write(fileString, strlen(fileString), f);
+	trap_FS_FCloseFile(f);
+}
+#endif
+
+#endif
+//#define ASCII_ART_DEBUG
+//#define ASCII_ART_NODE_DEBUG
+
+#ifdef ASCII_ART_DEBUG
+
+#define ALLOWABLE_DEBUG_FILE_SIZE 1048576
+
+void CreateAsciiTableRepresentation()
+{ //Draw a text grid of the entire waypoint array (useful for debugging final waypoint placement)
+	fileHandle_t f;
+	int i = 0;
+	int sP = 0;
+	int placeX;
+	int placeY;
+	int oldX;
+	int oldY;
+	char fileString[ALLOWABLE_DEBUG_FILE_SIZE];
+	char bChr = '+';
+	gentity_t *terrain = G_Find( NULL, FOFS(classname), "terrain" );
+
+	placeX = terrain->r.absmin[0];
+	placeY = terrain->r.absmin[1];
+
+	oldX = placeX-1;
+	oldY = placeY-1;
+
+	while (placeY < terrain->r.absmax[1])
+	{
+		while (placeX < terrain->r.absmax[0])
+		{
+			qboolean gotit = qfalse;
+
+			i = 0;
+			while (i < gWPNum)
+			{
+				if (((int)gWPArray[i]->origin[0] <= placeX && (int)gWPArray[i]->origin[0] > oldX) &&
+					((int)gWPArray[i]->origin[1] <= placeY && (int)gWPArray[i]->origin[1] > oldY))
+				{
+					gotit = qtrue;
+					break;
+				}
+				i++;
+			}
+
+			if (gotit)
+			{
+				if (gWPArray[i]->flags & WPFLAG_ONEWAY_FWD)
+				{
+					bChr = 'F';
+				}
+				else if (gWPArray[i]->flags & WPFLAG_ONEWAY_BACK)
+				{
+					bChr = 'B';
+				}
+				else
+				{
+					bChr = '+';
+				}
+
+				if (gWPArray[i]->index < 10)
+				{
+					fileString[sP] = bChr;
+					fileString[sP+1] = '0';
+					fileString[sP+2] = '0';
+					fileString[sP+3] = va("%i", gWPArray[i]->index)[0];
+				}
+				else if (gWPArray[i]->index < 100)
+				{
+					char *vastore = va("%i", gWPArray[i]->index);
+
+					fileString[sP] = bChr;
+					fileString[sP+1] = '0';
+					fileString[sP+2] = vastore[0];
+					fileString[sP+3] = vastore[1];
+				}
+				else if (gWPArray[i]->index < 1000)
+				{
+					char *vastore = va("%i", gWPArray[i]->index);
+
+					fileString[sP] = bChr;
+					fileString[sP+1] = vastore[0];
+					fileString[sP+2] = vastore[1];
+					fileString[sP+3] = vastore[2];
+				}
+				else
+				{
+					fileString[sP] = 'X';
+					fileString[sP+1] = 'X';
+					fileString[sP+2] = 'X';
+					fileString[sP+3] = 'X';
+				}
+			}
+			else
+			{
+				fileString[sP] = '-';
+				fileString[sP+1] = '-';
+				fileString[sP+2] = '-';
+				fileString[sP+3] = '-';
+			}
+
+			sP += 4;
+
+			if (sP >= ALLOWABLE_DEBUG_FILE_SIZE-16)
+			{
+				break;
+			}
+			oldX = placeX;
+			placeX += DEFAULT_GRID_SPACING;
+		}
+
+		placeX = terrain->r.absmin[0];
+		oldX = placeX-1;
+		fileString[sP] = '\n';
+		sP++;
+
+		if (sP >= ALLOWABLE_DEBUG_FILE_SIZE-16)
+		{
+			break;
+		}
+
+		oldY = placeY;
+		placeY += DEFAULT_GRID_SPACING;
+	}
+
+	fileString[sP] = 0;
+
+	trap_FS_FOpenFile("ROUTEDRAWN.txt", &f, FS_WRITE);
+	trap_FS_Write(fileString, strlen(fileString), f);
+	trap_FS_FCloseFile(f);
+}
+
+void CreateAsciiNodeTableRepresentation(int start, int end)
+{ //draw a text grid of a single node path, from point A to Z.
+	fileHandle_t f;
+	int i = 0;
+	int sP = 0;
+	int placeX;
+	int placeY;
+	int oldX;
+	int oldY;
+	char fileString[ALLOWABLE_DEBUG_FILE_SIZE];
+	gentity_t *terrain = G_Find( NULL, FOFS(classname), "terrain" );
+
+	placeX = terrain->r.absmin[0];
+	placeY = terrain->r.absmin[1];
+
+	oldX = placeX-1;
+	oldY = placeY-1;
+
+	while (placeY < terrain->r.absmax[1])
+	{
+		while (placeX < terrain->r.absmax[0])
+		{
+			qboolean gotit = qfalse;
+
+			i = 0;
+			while (i < nodenum)
+			{
+				if (((int)nodetable[i].origin[0] <= placeX && (int)nodetable[i].origin[0] > oldX) &&
+					((int)nodetable[i].origin[1] <= placeY && (int)nodetable[i].origin[1] > oldY))
+				{
+					gotit = qtrue;
+					break;
+				}
+				i++;
+			}
+
+			if (gotit)
+			{
+				if (i == start)
+				{ //beginning of the node trail
+					fileString[sP] = 'A';
+					fileString[sP+1] = 'A';
+					fileString[sP+2] = 'A';
+					fileString[sP+3] = 'A';
+				}
+				else if (i == end)
+				{ //destination of the node trail
+					fileString[sP] = 'Z';
+					fileString[sP+1] = 'Z';
+					fileString[sP+2] = 'Z';
+					fileString[sP+3] = 'Z';
+				}
+				else if (nodetable[i].weight < 10)
+				{
+					fileString[sP] = '+';
+					fileString[sP+1] = '0';
+					fileString[sP+2] = '0';
+					fileString[sP+3] = va("%f", nodetable[i].weight)[0];
+				}
+				else if (nodetable[i].weight < 100)
+				{
+					char *vastore = va("%f", nodetable[i].weight);
+
+					fileString[sP] = '+';
+					fileString[sP+1] = '0';
+					fileString[sP+2] = vastore[0];
+					fileString[sP+3] = vastore[1];
+				}
+				else if (nodetable[i].weight < 1000)
+				{
+					char *vastore = va("%f", nodetable[i].weight);
+
+					fileString[sP] = '+';
+					fileString[sP+1] = vastore[0];
+					fileString[sP+2] = vastore[1];
+					fileString[sP+3] = vastore[2];
+				}
+				else
+				{
+					fileString[sP] = 'X';
+					fileString[sP+1] = 'X';
+					fileString[sP+2] = 'X';
+					fileString[sP+3] = 'X';
+				}
+			}
+			else
+			{
+				fileString[sP] = '-';
+				fileString[sP+1] = '-';
+				fileString[sP+2] = '-';
+				fileString[sP+3] = '-';
+			}
+
+			sP += 4;
+
+			if (sP >= ALLOWABLE_DEBUG_FILE_SIZE-16)
+			{
+				break;
+			}
+			oldX = placeX;
+			placeX += DEFAULT_GRID_SPACING;
+		}
+
+		placeX = terrain->r.absmin[0];
+		oldX = placeX-1;
+		fileString[sP] = '\n';
+		sP++;
+
+		if (sP >= ALLOWABLE_DEBUG_FILE_SIZE-16)
+		{
+			break;
+		}
+
+		oldY = placeY;
+		placeY += DEFAULT_GRID_SPACING;
+	}
+
+	fileString[sP] = 0;
+
+	trap_FS_FOpenFile("ROUTEDRAWN.txt", &f, FS_WRITE);
+	trap_FS_Write(fileString, strlen(fileString), f);
+	trap_FS_FCloseFile(f);
+}
+#endif
+
+#ifndef _XBOX
+qboolean G_BackwardAttachment(int start, int finalDestination, int insertAfter)
+{ //After creating a node path between 2 points, this function links the 2 points with actual waypoint data.
+	int indexDirections[4]; //0 == down, 1 == up, 2 == left, 3 == right
+	int i = 0;
+	int lowestWeight = 9999;
+	int desiredIndex = -1;
+	vec2_t givenXY;
+
+	givenXY[0] = nodetable[start].origin[0];
+	givenXY[1] = nodetable[start].origin[1];
+	givenXY[0] -= DEFAULT_GRID_SPACING;
+	indexDirections[0] = G_NodeMatchingXY_BA(givenXY[0], givenXY[1], finalDestination);
+
+	givenXY[0] = nodetable[start].origin[0];
+	givenXY[1] = nodetable[start].origin[1];
+	givenXY[0] += DEFAULT_GRID_SPACING;
+	indexDirections[1] = G_NodeMatchingXY_BA(givenXY[0], givenXY[1], finalDestination);
+
+	givenXY[0] = nodetable[start].origin[0];
+	givenXY[1] = nodetable[start].origin[1];
+	givenXY[1] -= DEFAULT_GRID_SPACING;
+	indexDirections[2] = G_NodeMatchingXY_BA(givenXY[0], givenXY[1], finalDestination);
+
+	givenXY[0] = nodetable[start].origin[0];
+	givenXY[1] = nodetable[start].origin[1];
+	givenXY[1] += DEFAULT_GRID_SPACING;
+	indexDirections[3] = G_NodeMatchingXY_BA(givenXY[0], givenXY[1], finalDestination);
+
+	while (i < 4)
+	{
+		if (indexDirections[i] != -1)
+		{
+			if (indexDirections[i] == finalDestination)
+			{ //hooray, we've found the original point and linked all the way back to it.
+				CreateNewWP_InsertUnder(nodetable[start].origin, 0, insertAfter);
+				CreateNewWP_InsertUnder(nodetable[indexDirections[i]].origin, 0, insertAfter);
+				return qtrue;
+			}
+
+			if (nodetable[indexDirections[i]].weight < lowestWeight && nodetable[indexDirections[i]].weight && !nodetable[indexDirections[i]].flags /*&& (nodetable[indexDirections[i]].origin[2]-64 < nodetable[start].origin[2])*/)
+			{
+				desiredIndex = indexDirections[i];
+				lowestWeight = nodetable[indexDirections[i]].weight;
+			}
+		}
+		i++;
+	}
+
+	if (desiredIndex != -1)
+	{ //Create a waypoint here, and then recursively call this function for the next neighbor with the lowest weight.
+		if (gWPNum < 3900)
+		{
+			CreateNewWP_InsertUnder(nodetable[start].origin, 0, insertAfter);
+		}
+		else
+		{
+#ifdef PAINFULLY_DEBUGGING_THROUGH_VM
+			Com_Printf("WAYPOINTS FULL\n");
+#endif
+			return qfalse;
+		}
+
+		nodetable[start].flags = 1;
+		return G_BackwardAttachment(desiredIndex, finalDestination, insertAfter);
+	}
+
+	return qfalse;
+}
+
+
+#ifdef _DEBUG
+#define PATH_TIME_DEBUG
+#endif
+
+void G_RMGPathing(void)
+{ //Generate waypoint information on-the-fly for the random mission.
+	float placeX, placeY, placeZ;
+	int i = 0;
+	int gridSpacing = DEFAULT_GRID_SPACING;
+	int nearestIndex = 0;
+	int nearestIndexForNext = 0;
+#ifdef PATH_TIME_DEBUG
+	int startTime = 0;
+	int endTime = 0;
+#endif
+	vec3_t downVec, trMins, trMaxs;
+	trace_t tr;
+	gentity_t *terrain = G_Find( NULL, FOFS(classname), "terrain" );
+
+	if (!terrain || !terrain->inuse || terrain->s.eType != ET_TERRAIN)
+	{
+		G_Printf("Error: RMG with no terrain!\n");
+		return;
+	}
+
+#ifdef PATH_TIME_DEBUG
+	startTime = trap_Milliseconds();
+#endif
+
+	nodenum = 0;
+	memset(&nodetable, 0, sizeof(nodetable));
+
+	VectorSet(trMins, -15, -15, DEFAULT_MINS_2);
+	VectorSet(trMaxs, 15, 15, DEFAULT_MAXS_2);
+
+	placeX = terrain->r.absmin[0];
+	placeY = terrain->r.absmin[1];
+	placeZ = terrain->r.absmax[2]-400;
+
+	//skim through the entirety of the terrain limits and drop nodes, removing
+	//nodes that start in solid or fall too high on the terrain.
+	while (placeY < terrain->r.absmax[1])
+	{
+		if (nodenum >= MAX_NODETABLE_SIZE)
+		{
+			break;
+		}
+
+		while (placeX < terrain->r.absmax[0])
+		{
+			if (nodenum >= MAX_NODETABLE_SIZE)
+			{
+				break;
+			}
+
+			nodetable[nodenum].origin[0] = placeX;
+			nodetable[nodenum].origin[1] = placeY;
+			nodetable[nodenum].origin[2] = placeZ;
+
+			VectorCopy(nodetable[nodenum].origin, downVec);
+			downVec[2] -= 3000;
+			trap_Trace(&tr, nodetable[nodenum].origin, trMins, trMaxs, downVec, ENTITYNUM_NONE, MASK_SOLID);
+
+			if ((tr.entityNum >= ENTITYNUM_WORLD || g_entities[tr.entityNum].s.eType == ET_TERRAIN) && tr.endpos[2] < terrain->r.absmin[2]+750)
+			{ //only drop nodes on terrain directly
+				VectorCopy(tr.endpos, nodetable[nodenum].origin);
+				nodenum++;
+			}
+			else
+			{
+				VectorClear(nodetable[nodenum].origin);
+			}
+
+			placeX += gridSpacing;
+		}
+
+		placeX = terrain->r.absmin[0];
+		placeY += gridSpacing;
+	}
+
+#ifdef PAINFULLY_DEBUGGING_THROUGH_VM
+	Com_Printf("NODE GRID PLACED ON TERRAIN\n");
+#endif
+
+	G_NodeClearForNext();
+
+	//The grid has been placed down, now use it to connect the points in the level.
+	while (i < gSpawnPointNum-1)
+	{
+		if (!gSpawnPoints[i] || !gSpawnPoints[i]->inuse || !gSpawnPoints[i+1] || !gSpawnPoints[i+1]->inuse)
+		{
+			i++;
+			continue;
+		}
+
+		nearestIndex = G_NearestNodeToPoint(gSpawnPoints[i]->s.origin);
+		nearestIndexForNext = G_NearestNodeToPoint(gSpawnPoints[i+1]->s.origin);
+
+#ifdef PAINFULLY_DEBUGGING_THROUGH_VM
+		Com_Printf("%i GOT %i INDEX WITH %i INDEX FOR NEXT\n", nearestIndex, nearestIndexForNext);
+#endif
+
+		if (nearestIndex == -1 || nearestIndexForNext == -1)
+		{ //Looks like there is no grid data near one of the points. Ideally, this will never happen.
+			i++;
+			continue;
+		}
+
+		if (nearestIndex == nearestIndexForNext)
+		{ //Two spawn points on top of each other? We don't need to do both points, keep going until the next differs.
+			i++;
+			continue;
+		}
+
+		//So, nearestIndex is now the node for the spawn point we're on, and nearestIndexForNext is the
+		//node we want to get to from here.
+
+		//For now I am going to branch out mindlessly, but I will probably want to use some sort of A* algorithm
+		//here to lessen the time taken.
+		if (G_RecursiveConnection(nearestIndex, nearestIndexForNext, 0, qtrue, terrain->r.absmin[2]) != nearestIndexForNext)
+		{ //failed to branch to where we want. Oh well, try it without trace checks.
+			G_NodeClearForNext();
+
+#ifdef PAINFULLY_DEBUGGING_THROUGH_VM
+			Com_Printf("FAILED RECURSIVE WITH TRACES\n");
+#endif
+
+			if (G_RecursiveConnection(nearestIndex, nearestIndexForNext, 0, qfalse, terrain->r.absmin[2]) != nearestIndexForNext)
+			{ //still failed somehow. Just disregard this point.
+#ifdef PAINFULLY_DEBUGGING_THROUGH_VM
+				Com_Printf("FAILED RECURSIVE -WITHOUT- TRACES (?!?!)\n");
+#endif
+				G_NodeClearForNext();
+				i++;
+				continue;
+			}
+		}
+
+		//Now our node array is set up so that highest reasonable weight is the destination node, and 2 is next to the original index,
+		//so trace back to that point.
+		G_NodeClearFlags();
+
+#ifdef ASCII_ART_DEBUG
+#ifdef ASCII_ART_NODE_DEBUG
+		CreateAsciiNodeTableRepresentation(nearestIndex, nearestIndexForNext);
+#endif
+#endif
+		if (G_BackwardAttachment(nearestIndexForNext, nearestIndex, gWPNum-1))
+		{ //successfully connected the trail from nearestIndex to nearestIndexForNext
+			if (gSpawnPoints[i+1]->inuse && gSpawnPoints[i+1]->item &&
+				gSpawnPoints[i+1]->item->giType == IT_TEAM)
+			{ //This point is actually a CTF flag.
+				if (gSpawnPoints[i+1]->item->giTag == PW_REDFLAG || gSpawnPoints[i+1]->item->giTag == PW_BLUEFLAG)
+				{ //Place a waypoint on the flag next in the trail, so the nearest grid point will link to it.
+					CreateNewWP_InsertUnder(gSpawnPoints[i+1]->s.origin, WPFLAG_NEVERONEWAY, gWPNum-1);
+				}
+			}
+
+#ifdef PAINFULLY_DEBUGGING_THROUGH_VM
+			Com_Printf("BACKWARD ATTACHMENT %i SUCCESS\n", i);
+#endif
+		}
+		else
+		{
+#ifdef PAINFULLY_DEBUGGING_THROUGH_VM
+			Com_Printf("BACKWARD ATTACHMENT FAILED\n");
+#endif
+			break;
+		}
+
+#ifdef DEBUG_NODE_FILE
+		G_DebugNodeFile();
+#endif
+
+		G_NodeClearForNext();
+		i++;
+	}
+
+#ifdef PAINFULLY_DEBUGGING_THROUGH_VM
+	Com_Printf("FINISHED RMG AUTOPATH\n");
+#endif
+
+#ifdef PAINFULLY_DEBUGGING_THROUGH_VM
+	Com_Printf("BEGINNING PATH REPAIR...\n");
+#endif
+	RepairPaths(qtrue); //this has different behaviour for RMG and will just flag all points one way that don't trace to each other.
+#ifdef PAINFULLY_DEBUGGING_THROUGH_VM
+	Com_Printf("FINISHED PATH REPAIR.\n");
+#endif
+
+#ifdef PATH_TIME_DEBUG
+	endTime = trap_Milliseconds();
+
+	G_Printf("Total routing time taken: %ims\n", (endTime - startTime));
+#endif
+
+#ifdef ASCII_ART_DEBUG
+	CreateAsciiTableRepresentation();
+#endif
+}
+#endif
+
+#ifndef _XBOX
+void BeginAutoPathRoutine(void)
+{ //Called for RMG levels.
+	int i = 0;
+	gentity_t *ent = NULL;
+	vec3_t v;
+
+	gSpawnPointNum = 0;
+
+	CreateNewWP(vec3_origin, 0); //create a dummy waypoint to insert under
+
+	while (i < level.num_entities)
+	{
+		ent = &g_entities[i];
+
+		if (ent && ent->inuse && ent->classname && ent->classname[0] && !Q_stricmp(ent->classname, "info_player_deathmatch"))
+		{
+			if (ent->s.origin[2] < 1280)
+			{ //h4x
+				gSpawnPoints[gSpawnPointNum] = ent;
+				gSpawnPointNum++;
+			}
+		}
+		else if (ent && ent->inuse && ent->item && ent->item->giType == IT_TEAM &&
+			(ent->item->giTag == PW_REDFLAG || ent->item->giTag == PW_BLUEFLAG))
+		{ //also make it path to flags in CTF.
+			gSpawnPoints[gSpawnPointNum] = ent;
+			gSpawnPointNum++;
+		}
+
+		i++;
+	}
+
+	if (gSpawnPointNum < 1)
+	{
+		return;
+	}
+
+	G_RMGPathing();
+#ifdef PAINFULLY_DEBUGGING_THROUGH_VM
+	Com_Printf("LINKING PATHS...\n");
+#endif
+	
+	//rww - Using a faster in-engine version because we're having to wait for this stuff to get done as opposed to just saving it once.
+	trap_Bot_UpdateWaypoints(gWPNum, gWPArray);
+	trap_Bot_CalculatePaths(g_RMG.integer);
+	//CalculatePaths(); //make everything nice and connected
+
+#ifdef PAINFULLY_DEBUGGING_THROUGH_VM
+	Com_Printf("FINISHED LINKING PATHS.\n");
+#endif
+
+#ifdef PAINFULLY_DEBUGGING_THROUGH_VM
+	Com_Printf("FLAGGING OBJECTS...\n");
+#endif
+	FlagObjects(); //currently only used for flagging waypoints nearest CTF flags
+#ifdef PAINFULLY_DEBUGGING_THROUGH_VM
+	Com_Printf("FINISHED FLAGGING OBJECTS.\n");
+#endif
+
+#ifdef PAINFULLY_DEBUGGING_THROUGH_VM
+	Com_Printf("CALCULATING WAYPOINT DISTANCES...\n");
+#endif
+	i = 0;
+
+	while (i < gWPNum-1)
+	{ //disttonext is normally set on save, and when a file is loaded. For RMG we must do it after calc'ing.
+		VectorSubtract(gWPArray[i]->origin, gWPArray[i+1]->origin, v);
+		gWPArray[i]->disttonext = VectorLength(v);
+		i++;
+	}
+#ifdef PAINFULLY_DEBUGGING_THROUGH_VM
+	Com_Printf("FINISHED CALCULATING.\n");
+#endif
+
+#ifdef PAINFULLY_DEBUGGING_THROUGH_VM
+	Com_Printf("FINAL STEP...\n");
+#endif
+	RemoveWP(); //remove the dummy point at the end of the trail
+#ifdef PAINFULLY_DEBUGGING_THROUGH_VM
+	Com_Printf("COMPLETE.\n");
+#endif
+
+#ifdef PAINFULLY_DEBUGGING_THROUGH_VM
+	if (gWPNum >= 4096-1)
+	{
+		Com_Printf("%i waypoints say that YOU ARE A TERRIBLE MAN.\n", gWPNum);
+	}
+#endif
+}
+
+#endif
+extern vmCvar_t bot_normgpath;
+
+void LoadPath_ThisLevel(void)
+{
+	vmCvar_t	mapname;
+	int			i = 0;
+	gentity_t	*ent = NULL;
+
+	trap_Cvar_Register( &mapname, "mapname", "", CVAR_SERVERINFO | CVAR_ROM );
+
+	if (g_RMG.integer)
+	{ //If RMG, generate the path on-the-fly
+#ifdef _XBOX
+		assert(0);
+#else
+		trap_Cvar_Register(&bot_normgpath, "bot_normgpath", "1", CVAR_CHEAT);
+		//note: This is disabled for now as I'm using standard bot nav
+		//on premade terrain levels.
+
+		if (!bot_normgpath.integer)
+		{ //autopath the random map
+			BeginAutoPathRoutine();
+		}
+		else
+		{ //try loading standard nav data
+			LoadPathData(mapname.string);
+		}
+
+		gLevelFlags |= LEVELFLAG_NOPOINTPREDICTION;
+#endif
+	}
+	else
+	{
+		if (LoadPathData(mapname.string) == 2)
+		{
+			//enter "edit" mode if cheats enabled?
+		}
+	}
+
+	trap_Cvar_Update(&bot_wp_edit);
+
+	if (bot_wp_edit.value)
+	{
+		gBotEdit = 1;
+	}
+	else
+	{
+		gBotEdit = 0;
+	}
+
+	//set the flag entities
+	while (i < level.num_entities)
+	{
+		ent = &g_entities[i];
+
+		if (ent && ent->inuse && ent->classname)
+		{
+			if (!eFlagRed && strcmp(ent->classname, "team_CTF_redflag") == 0)
+			{
+				eFlagRed = ent;
+			}
+			else if (!eFlagBlue && strcmp(ent->classname, "team_CTF_blueflag") == 0)
+			{
+				eFlagBlue = ent;
+			}
+
+			if (eFlagRed && eFlagBlue)
+			{
+				break;
+			}
+		}
+
+		i++;
+	}
+
+#ifdef PAINFULLY_DEBUGGING_THROUGH_VM
+	Com_Printf("BOT PATHING IS COMPLETE.\n");
+#endif
+}
+
+gentity_t *GetClosestSpawn(gentity_t *ent)
+{
+	gentity_t	*spawn;
+	gentity_t	*closestSpawn = NULL;
+	float		closestDist = -1;
+	int			i = MAX_CLIENTS;
+
+	spawn = NULL;
+
+	while (i < level.num_entities)
+	{
+		spawn = &g_entities[i];
+
+		if (spawn && spawn->inuse && (!Q_stricmp(spawn->classname, "info_player_start") || !Q_stricmp(spawn->classname, "info_player_deathmatch")) )
+		{
+			float checkDist;
+			vec3_t vSub;
+
+			VectorSubtract(ent->client->ps.origin, spawn->r.currentOrigin, vSub);
+			checkDist = VectorLength(vSub);
+
+			if (closestDist == -1 || checkDist < closestDist)
+			{
+				closestSpawn = spawn;
+				closestDist = checkDist;
+			}
+		}
+
+		i++;
+	}
+
+	return closestSpawn;
+}
+
+gentity_t *GetNextSpawnInIndex(gentity_t *currentSpawn)
+{
+	gentity_t	*spawn;
+	gentity_t	*nextSpawn = NULL;
+	int			i = currentSpawn->s.number+1;
+
+	spawn = NULL;
+
+	while (i < level.num_entities)
+	{
+		spawn = &g_entities[i];
+
+		if (spawn && spawn->inuse && (!Q_stricmp(spawn->classname, "info_player_start") || !Q_stricmp(spawn->classname, "info_player_deathmatch")) )
+		{
+			nextSpawn = spawn;
+			break;
+		}
+
+		i++;
+	}
+
+	if (!nextSpawn)
+	{ //loop back around to 0
+		i = MAX_CLIENTS;
+
+		while (i < level.num_entities)
+		{
+			spawn = &g_entities[i];
+
+			if (spawn && spawn->inuse && (!Q_stricmp(spawn->classname, "info_player_start") || !Q_stricmp(spawn->classname, "info_player_deathmatch")) )
+			{
+				nextSpawn = spawn;
+				break;
+			}
+
+			i++;
+		}
+	}
+
+	return nextSpawn;
+}
+
+int AcceptBotCommand(char *cmd, gentity_t *pl)
+{
+	int OptionalArgument, i;
+	int FlagsFromArgument;
+	char *OptionalSArgument, *RequiredSArgument;
+#ifndef _XBOX
+	vmCvar_t mapname;
+#endif
+
+	if (!gBotEdit)
+	{
+		return 0;
+	}
+
+	OptionalArgument = 0;
+	i = 0;
+	FlagsFromArgument = 0;
+	OptionalSArgument = NULL;
+	RequiredSArgument = NULL;
+
+	//if a waypoint editing related command is issued, bots will deactivate.
+	//once bot_wp_save is issued and the trail is recalculated, bots will activate again.
+
+	if (!pl || !pl->client)
+	{
+		return 0;
+	}
+
+	if (Q_stricmp (cmd, "bot_wp_cmdlist") == 0) //lists all the bot waypoint commands.
+	{
+		G_Printf(S_COLOR_YELLOW "bot_wp_add" S_COLOR_WHITE " - Add a waypoint (optional int parameter will insert the point after the specified waypoint index in a trail)\n\n");
+		G_Printf(S_COLOR_YELLOW "bot_wp_rem" S_COLOR_WHITE " - Remove a waypoint (removes last unless waypoint index is specified as a parameter)\n\n");
+		G_Printf(S_COLOR_YELLOW "bot_wp_addflagged" S_COLOR_WHITE " - Same as wp_add, but adds a flagged point (type bot_wp_addflagged for help)\n\n");
+		G_Printf(S_COLOR_YELLOW "bot_wp_switchflags" S_COLOR_WHITE " - Switches flags on an existing waypoint (type bot_wp_switchflags for help)\n\n");
+		G_Printf(S_COLOR_YELLOW "bot_wp_tele" S_COLOR_WHITE " - Teleport yourself to the specified waypoint's location\n");
+		G_Printf(S_COLOR_YELLOW "bot_wp_killoneways" S_COLOR_WHITE " - Removes oneway (backward and forward) flags on all waypoints in the level\n\n");
+		G_Printf(S_COLOR_YELLOW "bot_wp_save" S_COLOR_WHITE " - Saves all waypoint data into a file for later use\n");
+
+		return 1;
+	}
+
+	if (Q_stricmp (cmd, "bot_wp_add") == 0)
+	{
+		gDeactivated = 1;
+		OptionalSArgument = ConcatArgs( 1 );
+
+		if (OptionalSArgument)
+		{
+			OptionalArgument = atoi(OptionalSArgument);
+		}
+
+		if (OptionalSArgument && OptionalSArgument[0])
+		{
+			CreateNewWP_InTrail(pl->client->ps.origin, 0, OptionalArgument);
+		}
+		else
+		{
+			CreateNewWP(pl->client->ps.origin, 0);
+		}
+		return 1;
+	}
+
+	if (Q_stricmp (cmd, "bot_wp_rem") == 0)
+	{
+		gDeactivated = 1;
+
+		OptionalSArgument = ConcatArgs( 1 );
+
+		if (OptionalSArgument)
+		{
+			OptionalArgument = atoi(OptionalSArgument);
+		}
+
+		if (OptionalSArgument && OptionalSArgument[0])
+		{
+			RemoveWP_InTrail(OptionalArgument);
+		}
+		else
+		{
+			RemoveWP();
+		}
+
+		return 1;
+	}
+
+	if (Q_stricmp (cmd, "bot_wp_tele") == 0)
+	{
+		gDeactivated = 1;
+		OptionalSArgument = ConcatArgs( 1 );
+
+		if (OptionalSArgument)
+		{
+			OptionalArgument = atoi(OptionalSArgument);
+		}
+
+		if (OptionalSArgument && OptionalSArgument[0])
+		{
+			TeleportToWP(pl, OptionalArgument);
+		}
+		else
+		{
+			G_Printf(S_COLOR_YELLOW "You didn't specify an index. Assuming last.\n");
+			TeleportToWP(pl, gWPNum-1);
+		}
+		return 1;
+	}
+
+	if (Q_stricmp (cmd, "bot_wp_spawntele") == 0)
+	{
+		gentity_t *closestSpawn = GetClosestSpawn(pl);
+
+		if (!closestSpawn)
+		{ //There should always be a spawn point..
+			return 1;
+		}
+
+		closestSpawn = GetNextSpawnInIndex(closestSpawn);
+
+		if (closestSpawn)
+		{
+			VectorCopy(closestSpawn->r.currentOrigin, pl->client->ps.origin);
+		}
+		return 1;
+	}
+
+	if (Q_stricmp (cmd, "bot_wp_addflagged") == 0)
+	{
+		gDeactivated = 1;
+
+		RequiredSArgument = ConcatArgs( 1 );
+
+		if (!RequiredSArgument || !RequiredSArgument[0])
+		{
+			G_Printf(S_COLOR_YELLOW "Flag string needed for bot_wp_addflagged\nj - Jump point\nd - Duck point\nc - Snipe or camp standing\nf - Wait for func\nm - Do not move to when func is under\ns - Snipe or camp\nx - Oneway, forward\ny - Oneway, back\ng - Mission goal\nn - No visibility\nExample (for a point the bot would jump at, and reverse on when traveling a trail backwards):\nbot_wp_addflagged jx\n");
+			return 1;
+		}
+
+		while (RequiredSArgument[i])
+		{
+			if (RequiredSArgument[i] == 'j')
+			{
+				FlagsFromArgument |= WPFLAG_JUMP;
+			}
+			else if (RequiredSArgument[i] == 'd')
+			{
+				FlagsFromArgument |= WPFLAG_DUCK;
+			}
+			else if (RequiredSArgument[i] == 'c')
+			{
+				FlagsFromArgument |= WPFLAG_SNIPEORCAMPSTAND;
+			}
+			else if (RequiredSArgument[i] == 'f')
+			{
+				FlagsFromArgument |= WPFLAG_WAITFORFUNC;
+			}
+			else if (RequiredSArgument[i] == 's')
+			{
+				FlagsFromArgument |= WPFLAG_SNIPEORCAMP;
+			}
+			else if (RequiredSArgument[i] == 'x')
+			{
+				FlagsFromArgument |= WPFLAG_ONEWAY_FWD;
+			}
+			else if (RequiredSArgument[i] == 'y')
+			{
+				FlagsFromArgument |= WPFLAG_ONEWAY_BACK;
+			}
+			else if (RequiredSArgument[i] == 'g')
+			{
+				FlagsFromArgument |= WPFLAG_GOALPOINT;
+			}
+			else if (RequiredSArgument[i] == 'n')
+			{
+				FlagsFromArgument |= WPFLAG_NOVIS;
+			}
+			else if (RequiredSArgument[i] == 'm')
+			{
+				FlagsFromArgument |= WPFLAG_NOMOVEFUNC;
+			}
+
+			i++;
+		}
+
+		OptionalSArgument = ConcatArgs( 2 );
+
+		if (OptionalSArgument)
+		{
+			OptionalArgument = atoi(OptionalSArgument);
+		}
+
+		if (OptionalSArgument && OptionalSArgument[0])
+		{
+			CreateNewWP_InTrail(pl->client->ps.origin, FlagsFromArgument, OptionalArgument);
+		}
+		else
+		{
+			CreateNewWP(pl->client->ps.origin, FlagsFromArgument);
+		}
+		return 1;
+	}
+
+	if (Q_stricmp (cmd, "bot_wp_switchflags") == 0)
+	{
+		gDeactivated = 1;
+
+		RequiredSArgument = ConcatArgs( 1 );
+
+		if (!RequiredSArgument || !RequiredSArgument[0])
+		{
+			G_Printf(S_COLOR_YELLOW "Flag string needed for bot_wp_switchflags\nType bot_wp_addflagged for a list of flags and their corresponding characters, or use 0 for no flags.\nSyntax: bot_wp_switchflags <flags> <n>\n");
+			return 1;
+		}
+
+		while (RequiredSArgument[i])
+		{
+			if (RequiredSArgument[i] == 'j')
+			{
+				FlagsFromArgument |= WPFLAG_JUMP;
+			}
+			else if (RequiredSArgument[i] == 'd')
+			{
+				FlagsFromArgument |= WPFLAG_DUCK;
+			}
+			else if (RequiredSArgument[i] == 'c')
+			{
+				FlagsFromArgument |= WPFLAG_SNIPEORCAMPSTAND;
+			}
+			else if (RequiredSArgument[i] == 'f')
+			{
+				FlagsFromArgument |= WPFLAG_WAITFORFUNC;
+			}
+			else if (RequiredSArgument[i] == 's')
+			{
+				FlagsFromArgument |= WPFLAG_SNIPEORCAMP;
+			}
+			else if (RequiredSArgument[i] == 'x')
+			{
+				FlagsFromArgument |= WPFLAG_ONEWAY_FWD;
+			}
+			else if (RequiredSArgument[i] == 'y')
+			{
+				FlagsFromArgument |= WPFLAG_ONEWAY_BACK;
+			}
+			else if (RequiredSArgument[i] == 'g')
+			{
+				FlagsFromArgument |= WPFLAG_GOALPOINT;
+			}
+			else if (RequiredSArgument[i] == 'n')
+			{
+				FlagsFromArgument |= WPFLAG_NOVIS;
+			}
+			else if (RequiredSArgument[i] == 'm')
+			{
+				FlagsFromArgument |= WPFLAG_NOMOVEFUNC;
+			}
+
+			i++;
+		}
+
+		OptionalSArgument = ConcatArgs( 2 );
+
+		if (OptionalSArgument)
+		{
+			OptionalArgument = atoi(OptionalSArgument);
+		}
+
+		if (OptionalSArgument && OptionalSArgument[0])
+		{
+			WPFlagsModify(OptionalArgument, FlagsFromArgument);
+		}
+		else
+		{
+			G_Printf(S_COLOR_YELLOW "Waypoint number (to modify) needed for bot_wp_switchflags\nSyntax: bot_wp_switchflags <flags> <n>\n");
+		}
+		return 1;
+	}
+
+	if (Q_stricmp (cmd, "bot_wp_killoneways") == 0)
+	{
+		i = 0;
+
+		while (i < gWPNum)
+		{
+			if (gWPArray[i] && gWPArray[i]->inuse)
+			{
+				if (gWPArray[i]->flags & WPFLAG_ONEWAY_FWD)
+				{
+					gWPArray[i]->flags -= WPFLAG_ONEWAY_FWD;
+				}
+				if (gWPArray[i]->flags & WPFLAG_ONEWAY_BACK)
+				{
+					gWPArray[i]->flags -= WPFLAG_ONEWAY_BACK;
+				}
+			}
+
+			i++;
+		}
+
+		return 1;
+	}
+
+#ifndef _XBOX
+	if (Q_stricmp (cmd, "bot_wp_save") == 0)
+	{
+		gDeactivated = 0;
+		trap_Cvar_Register( &mapname, "mapname", "", CVAR_SERVERINFO | CVAR_ROM );
+		SavePathData(mapname.string);
+		return 1;
+	}
+#endif
+
+	return 0;
+}
diff --git a/codemp/game/anims.h b/codemp/game/anims.h
new file mode 100644
index 0000000..7fb3e15
--- /dev/null
+++ b/codemp/game/anims.h
@@ -0,0 +1,1797 @@
+#ifndef __ANIMS_H__
+#define __ANIMS_H__
+// playerAnimations
+
+
+typedef enum //# animNumber_e
+{
+	//=================================================
+	//HEAD ANIMS
+	//=================================================
+	//# #sep Head-only anims
+	FACE_TALK0,			//# silent
+	FACE_TALK1,			//# quiet
+	FACE_TALK2,			//# semi-quiet
+	FACE_TALK3,			//# semi-loud
+	FACE_TALK4,			//# loud
+	FACE_ALERT,				//# 
+	FACE_SMILE,				//# 
+	FACE_FROWN,				//# 
+	FACE_DEAD,				//# 
+
+	//=================================================
+	//ANIMS IN WHICH UPPER AND LOWER OBJECTS ARE IN MD3
+	//=================================================
+	//# #sep BOTH_ DEATHS
+	BOTH_DEATH1,		//# First Death anim
+	BOTH_DEATH2,			//# Second Death anim
+	BOTH_DEATH3,			//# Third Death anim
+	BOTH_DEATH4,			//# Fourth Death anim
+	BOTH_DEATH5,			//# Fifth Death anim
+	BOTH_DEATH6,			//# Sixth Death anim
+	BOTH_DEATH7,			//# Seventh Death anim
+	BOTH_DEATH8,			//# 
+	BOTH_DEATH9,			//# 
+	BOTH_DEATH10,			//# 
+	BOTH_DEATH11,			//#
+	BOTH_DEATH12,			//# 
+	BOTH_DEATH13,			//# 
+	BOTH_DEATH14,			//# 
+	BOTH_DEATH15,			//# 
+	BOTH_DEATH16,			//# 
+	BOTH_DEATH17,			//# 
+	BOTH_DEATH18,			//# 
+	BOTH_DEATH19,			//# 
+	BOTH_DEATH20,			//# 
+	BOTH_DEATH21,			//# 
+	BOTH_DEATH22,			//# 
+	BOTH_DEATH23,			//# 
+	BOTH_DEATH24,			//# 
+	BOTH_DEATH25,			//# 
+
+	BOTH_DEATHFORWARD1,		//# First Death in which they get thrown forward
+	BOTH_DEATHFORWARD2,		//# Second Death in which they get thrown forward
+	BOTH_DEATHFORWARD3,		//# Tavion's falling in cin# 23
+	BOTH_DEATHBACKWARD1,	//# First Death in which they get thrown backward
+	BOTH_DEATHBACKWARD2,	//# Second Death in which they get thrown backward
+
+	BOTH_DEATH1IDLE,		//# Idle while close to death
+	BOTH_LYINGDEATH1,		//# Death to play when killed lying down
+	BOTH_STUMBLEDEATH1,		//# Stumble forward and fall face first death
+	BOTH_FALLDEATH1,		//# Fall forward off a high cliff and splat death - start
+	BOTH_FALLDEATH1INAIR,	//# Fall forward off a high cliff and splat death - loop
+	BOTH_FALLDEATH1LAND,	//# Fall forward off a high cliff and splat death - hit bottom
+	BOTH_DEATH_ROLL,		//# Death anim from a roll
+	BOTH_DEATH_FLIP,		//# Death anim from a flip
+	BOTH_DEATH_SPIN_90_R,	//# Death anim when facing 90 degrees right
+	BOTH_DEATH_SPIN_90_L,	//# Death anim when facing 90 degrees left
+	BOTH_DEATH_SPIN_180,	//# Death anim when facing backwards
+	BOTH_DEATH_LYING_UP,	//# Death anim when lying on back
+	BOTH_DEATH_LYING_DN,	//# Death anim when lying on front
+	BOTH_DEATH_FALLING_DN,	//# Death anim when falling on face
+	BOTH_DEATH_FALLING_UP,	//# Death anim when falling on back
+	BOTH_DEATH_CROUCHED,	//# Death anim when crouched
+	//# #sep BOTH_ DEAD POSES # Should be last frame of corresponding previous anims
+	BOTH_DEAD1,				//# First Death finished pose
+	BOTH_DEAD2,				//# Second Death finished pose
+	BOTH_DEAD3,				//# Third Death finished pose
+	BOTH_DEAD4,				//# Fourth Death finished pose
+	BOTH_DEAD5,				//# Fifth Death finished pose
+	BOTH_DEAD6,				//# Sixth Death finished pose
+	BOTH_DEAD7,				//# Seventh Death finished pose
+	BOTH_DEAD8,				//# 
+	BOTH_DEAD9,				//# 
+	BOTH_DEAD10,			//# 
+	BOTH_DEAD11,			//#
+	BOTH_DEAD12,			//# 
+	BOTH_DEAD13,			//# 
+	BOTH_DEAD14,			//# 
+	BOTH_DEAD15,			//# 
+	BOTH_DEAD16,			//# 
+	BOTH_DEAD17,			//# 
+	BOTH_DEAD18,			//# 
+	BOTH_DEAD19,			//# 
+	BOTH_DEAD20,			//# 
+	BOTH_DEAD21,			//# 
+	BOTH_DEAD22,			//# 
+	BOTH_DEAD23,			//# 
+	BOTH_DEAD24,			//# 
+	BOTH_DEAD25,			//# 
+	BOTH_DEADFORWARD1,		//# First thrown forward death finished pose
+	BOTH_DEADFORWARD2,		//# Second thrown forward death finished pose
+	BOTH_DEADBACKWARD1,		//# First thrown backward death finished pose
+	BOTH_DEADBACKWARD2,		//# Second thrown backward death finished pose
+	BOTH_LYINGDEAD1,		//# Killed lying down death finished pose
+	BOTH_STUMBLEDEAD1,		//# Stumble forward death finished pose
+	BOTH_FALLDEAD1LAND,		//# Fall forward and splat death finished pose
+	//# #sep BOTH_ DEAD TWITCH/FLOP # React to being shot from death poses
+	BOTH_DEADFLOP1,		//# React to being shot from First Death finished pose
+	BOTH_DEADFLOP2,		//# React to being shot from Second Death finished pose
+	BOTH_DISMEMBER_HEAD1,	//#
+	BOTH_DISMEMBER_TORSO1,	//#
+	BOTH_DISMEMBER_LLEG,	//#
+	BOTH_DISMEMBER_RLEG,	//#
+	BOTH_DISMEMBER_RARM,	//#
+	BOTH_DISMEMBER_LARM,	//#
+	//# #sep BOTH_ PAINS
+	BOTH_PAIN1,				//# First take pain anim
+	BOTH_PAIN2,				//# Second take pain anim
+	BOTH_PAIN3,				//# Third take pain anim
+	BOTH_PAIN4,				//# Fourth take pain anim
+	BOTH_PAIN5,				//# Fifth take pain anim - from behind
+	BOTH_PAIN6,				//# Sixth take pain anim - from behind
+	BOTH_PAIN7,				//# Seventh take pain anim - from behind
+	BOTH_PAIN8,				//# Eigth take pain anim - from behind
+	BOTH_PAIN9,				//# 
+	BOTH_PAIN10,			//# 
+	BOTH_PAIN11,			//# 
+	BOTH_PAIN12,			//# 
+	BOTH_PAIN13,			//# 
+	BOTH_PAIN14,			//# 
+	BOTH_PAIN15,			//# 
+	BOTH_PAIN16,			//# 
+	BOTH_PAIN17,			//# 
+	BOTH_PAIN18,			//# 
+
+	//# #sep BOTH_ ATTACKS
+	BOTH_ATTACK1,			//# Attack with stun baton
+	BOTH_ATTACK2,			//# Attack with one-handed pistol
+	BOTH_ATTACK3,			//# Attack with blaster rifle
+	BOTH_ATTACK4,			//# Attack with disruptor
+	BOTH_ATTACK5,			//# Another Rancor Attack
+	BOTH_ATTACK6,			//# Yet Another Rancor Attack
+	BOTH_ATTACK7,			//# Yet Another Rancor Attack
+	BOTH_ATTACK10,			//# Attack with thermal det
+	BOTH_ATTACK11,			//# "Attack" with tripmine and detpack
+	BOTH_MELEE1,			//# First melee attack
+	BOTH_MELEE2,			//# Second melee attack
+	BOTH_THERMAL_READY,		//# pull back with thermal
+	BOTH_THERMAL_THROW,		//# throw thermal
+	//* #sep BOTH_ SABER ANIMS
+	//Saber attack anims - power level 1
+	BOTH_A1_T__B_,	//# Fast weak vertical attack top to bottom
+	BOTH_A1__L__R,	//# Fast weak horizontal attack left to right
+	BOTH_A1__R__L,	//# Fast weak horizontal attack right to left
+	BOTH_A1_TL_BR,	//# Fast weak diagonal attack top left to botom right
+	BOTH_A1_BR_TL,	//# Fast weak diagonal attack top left to botom right
+	BOTH_A1_BL_TR,	//# Fast weak diagonal attack bottom left to top right
+	BOTH_A1_TR_BL,	//# Fast weak diagonal attack bottom left to right
+	//Saber Arc and Spin Transitions
+	BOTH_T1_BR__R,	//# Fast arc bottom right to right
+	BOTH_T1_BR_TL,	//# Fast weak spin bottom right to top left
+	BOTH_T1_BR__L,	//# Fast weak spin bottom right to left
+	BOTH_T1_BR_BL,	//# Fast weak spin bottom right to bottom left
+	BOTH_T1__R_TR,	//# Fast arc right to top right
+	BOTH_T1__R_TL,	//# Fast arc right to top left
+	BOTH_T1__R__L,	//# Fast weak spin right to left
+	BOTH_T1__R_BL,	//# Fast weak spin right to bottom left
+	BOTH_T1_TR_BR,	//# Fast arc top right to bottom right
+	BOTH_T1_TR_TL,	//# Fast arc top right to top left
+	BOTH_T1_TR__L,	//# Fast arc top right to left
+	BOTH_T1_TR_BL,	//# Fast weak spin top right to bottom left
+	BOTH_T1_T__BR,	//# Fast arc top to bottom right
+	BOTH_T1_T___R,	//# Fast arc top to right
+	BOTH_T1_T__TR,	//# Fast arc top to top right
+	BOTH_T1_T__TL,	//# Fast arc top to top left
+	BOTH_T1_T___L,	//# Fast arc top to left
+	BOTH_T1_T__BL,	//# Fast arc top to bottom left
+	BOTH_T1_TL_BR,	//# Fast weak spin top left to bottom right
+	BOTH_T1_TL_BL,	//# Fast arc top left to bottom left
+	BOTH_T1__L_BR,	//# Fast weak spin left to bottom right
+	BOTH_T1__L__R,	//# Fast weak spin left to right
+	BOTH_T1__L_TL,	//# Fast arc left to top left
+	BOTH_T1_BL_BR,	//# Fast weak spin bottom left to bottom right
+	BOTH_T1_BL__R,	//# Fast weak spin bottom left to right
+	BOTH_T1_BL_TR,	//# Fast weak spin bottom left to top right
+	BOTH_T1_BL__L,	//# Fast arc bottom left to left
+	//Saber Arc Transitions that use existing animations played backwards
+	BOTH_T1_BR_TR,	//# Fast arc bottom right to top right		(use: BOTH_T1_TR_BR)
+	BOTH_T1_BR_T_,	//# Fast arc bottom right to top			(use: BOTH_T1_T__BR)
+	BOTH_T1__R_BR,	//# Fast arc right to bottom right			(use: BOTH_T1_BR__R)
+	BOTH_T1__R_T_,	//# Fast ar right to top				(use: BOTH_T1_T___R)
+	BOTH_T1_TR__R,	//# Fast arc top right to right			(use: BOTH_T1__R_TR)
+	BOTH_T1_TR_T_,	//# Fast arc top right to top				(use: BOTH_T1_T__TR)
+	BOTH_T1_TL__R,	//# Fast arc top left to right			(use: BOTH_T1__R_TL)
+	BOTH_T1_TL_TR,	//# Fast arc top left to top right			(use: BOTH_T1_TR_TL)
+	BOTH_T1_TL_T_,	//# Fast arc top left to top				(use: BOTH_T1_T__TL)
+	BOTH_T1_TL__L,	//# Fast arc top left to left				(use: BOTH_T1__L_TL)
+	BOTH_T1__L_TR,	//# Fast arc left to top right			(use: BOTH_T1_TR__L)
+	BOTH_T1__L_T_,	//# Fast arc left to top				(use: BOTH_T1_T___L)
+	BOTH_T1__L_BL,	//# Fast arc left to bottom left			(use: BOTH_T1_BL__L)
+	BOTH_T1_BL_T_,	//# Fast arc bottom left to top			(use: BOTH_T1_T__BL)
+	BOTH_T1_BL_TL,	//# Fast arc bottom left to top left		(use: BOTH_T1_TL_BL)
+	//Saber Attack Start Transitions
+	BOTH_S1_S1_T_,	//# Fast plain transition from stance1 to top-to-bottom Fast weak attack
+	BOTH_S1_S1__L,	//# Fast plain transition from stance1 to left-to-right Fast weak attack
+	BOTH_S1_S1__R,	//# Fast plain transition from stance1 to right-to-left Fast weak attack
+	BOTH_S1_S1_TL,	//# Fast plain transition from stance1 to top-left-to-bottom-right Fast weak attack
+	BOTH_S1_S1_BR,	//# Fast plain transition from stance1 to bottom-right-to-top-left Fast weak attack
+	BOTH_S1_S1_BL,	//# Fast plain transition from stance1 to bottom-left-to-top-right Fast weak attack
+	BOTH_S1_S1_TR,	//# Fast plain transition from stance1 to top-right-to-bottom-left Fast weak attack
+	//Saber Attack Return Transitions
+	BOTH_R1_B__S1,	//# Fast plain transition from top-to-bottom Fast weak attack to stance1
+	BOTH_R1__L_S1,	//# Fast plain transition from left-to-right Fast weak attack to stance1
+	BOTH_R1__R_S1,	//# Fast plain transition from right-to-left Fast weak attack to stance1
+	BOTH_R1_TL_S1,	//# Fast plain transition from top-left-to-bottom-right Fast weak attack to stance1
+	BOTH_R1_BR_S1,	//# Fast plain transition from bottom-right-to-top-left Fast weak attack to stance1
+	BOTH_R1_BL_S1,	//# Fast plain transition from bottom-left-to-top-right Fast weak attack to stance1
+	BOTH_R1_TR_S1,	//# Fast plain transition from top-right-to-bottom-left Fast weak attack
+	//Saber Attack Bounces (first 4 frames of an attack, played backwards)
+	BOTH_B1_BR___,	//# Bounce-back if attack from BR is blocked
+	BOTH_B1__R___,	//# Bounce-back if attack from R is blocked
+	BOTH_B1_TR___,	//# Bounce-back if attack from TR is blocked
+	BOTH_B1_T____,	//# Bounce-back if attack from T is blocked
+	BOTH_B1_TL___,	//# Bounce-back if attack from TL is blocked
+	BOTH_B1__L___,	//# Bounce-back if attack from L is blocked
+	BOTH_B1_BL___,	//# Bounce-back if attack from BL is blocked
+	//Saber Attack Deflections (last 4 frames of an attack)
+	BOTH_D1_BR___,	//# Deflection toward BR
+	BOTH_D1__R___,	//# Deflection toward R
+	BOTH_D1_TR___,	//# Deflection toward TR
+	BOTH_D1_TL___,	//# Deflection toward TL
+	BOTH_D1__L___,	//# Deflection toward L
+	BOTH_D1_BL___,	//# Deflection toward BL
+	BOTH_D1_B____,	//# Deflection toward B
+	//Saber attack anims - power level 2
+	BOTH_A2_T__B_,	//# Fast weak vertical attack top to bottom
+	BOTH_A2__L__R,	//# Fast weak horizontal attack left to right
+	BOTH_A2__R__L,	//# Fast weak horizontal attack right to left
+	BOTH_A2_TL_BR,	//# Fast weak diagonal attack top left to botom right
+	BOTH_A2_BR_TL,	//# Fast weak diagonal attack top left to botom right
+	BOTH_A2_BL_TR,	//# Fast weak diagonal attack bottom left to top right
+	BOTH_A2_TR_BL,	//# Fast weak diagonal attack bottom left to right
+	//Saber Arc and Spin Transitions
+	BOTH_T2_BR__R,	//# Fast arc bottom right to right
+	BOTH_T2_BR_TL,	//# Fast weak spin bottom right to top left
+	BOTH_T2_BR__L,	//# Fast weak spin bottom right to left
+	BOTH_T2_BR_BL,	//# Fast weak spin bottom right to bottom left
+	BOTH_T2__R_TR,	//# Fast arc right to top right
+	BOTH_T2__R_TL,	//# Fast arc right to top left
+	BOTH_T2__R__L,	//# Fast weak spin right to left
+	BOTH_T2__R_BL,	//# Fast weak spin right to bottom left
+	BOTH_T2_TR_BR,	//# Fast arc top right to bottom right
+	BOTH_T2_TR_TL,	//# Fast arc top right to top left
+	BOTH_T2_TR__L,	//# Fast arc top right to left
+	BOTH_T2_TR_BL,	//# Fast weak spin top right to bottom left
+	BOTH_T2_T__BR,	//# Fast arc top to bottom right
+	BOTH_T2_T___R,	//# Fast arc top to right
+	BOTH_T2_T__TR,	//# Fast arc top to top right
+	BOTH_T2_T__TL,	//# Fast arc top to top left
+	BOTH_T2_T___L,	//# Fast arc top to left
+	BOTH_T2_T__BL,	//# Fast arc top to bottom left
+	BOTH_T2_TL_BR,	//# Fast weak spin top left to bottom right
+	BOTH_T2_TL_BL,	//# Fast arc top left to bottom left
+	BOTH_T2__L_BR,	//# Fast weak spin left to bottom right
+	BOTH_T2__L__R,	//# Fast weak spin left to right
+	BOTH_T2__L_TL,	//# Fast arc left to top left
+	BOTH_T2_BL_BR,	//# Fast weak spin bottom left to bottom right
+	BOTH_T2_BL__R,	//# Fast weak spin bottom left to right
+	BOTH_T2_BL_TR,	//# Fast weak spin bottom left to top right
+	BOTH_T2_BL__L,	//# Fast arc bottom left to left
+	//Saber Arc Transitions that use existing animations played backwards
+	BOTH_T2_BR_TR,	//# Fast arc bottom right to top right		(use: BOTH_T2_TR_BR)
+	BOTH_T2_BR_T_,	//# Fast arc bottom right to top			(use: BOTH_T2_T__BR)
+	BOTH_T2__R_BR,	//# Fast arc right to bottom right			(use: BOTH_T2_BR__R)
+	BOTH_T2__R_T_,	//# Fast ar right to top				(use: BOTH_T2_T___R)
+	BOTH_T2_TR__R,	//# Fast arc top right to right			(use: BOTH_T2__R_TR)
+	BOTH_T2_TR_T_,	//# Fast arc top right to top				(use: BOTH_T2_T__TR)
+	BOTH_T2_TL__R,	//# Fast arc top left to right			(use: BOTH_T2__R_TL)
+	BOTH_T2_TL_TR,	//# Fast arc top left to top right			(use: BOTH_T2_TR_TL)
+	BOTH_T2_TL_T_,	//# Fast arc top left to top				(use: BOTH_T2_T__TL)
+	BOTH_T2_TL__L,	//# Fast arc top left to left				(use: BOTH_T2__L_TL)
+	BOTH_T2__L_TR,	//# Fast arc left to top right			(use: BOTH_T2_TR__L)
+	BOTH_T2__L_T_,	//# Fast arc left to top				(use: BOTH_T2_T___L)
+	BOTH_T2__L_BL,	//# Fast arc left to bottom left			(use: BOTH_T2_BL__L)
+	BOTH_T2_BL_T_,	//# Fast arc bottom left to top			(use: BOTH_T2_T__BL)
+	BOTH_T2_BL_TL,	//# Fast arc bottom left to top left		(use: BOTH_T2_TL_BL)
+	//Saber Attack Start Transitions
+	BOTH_S2_S1_T_,	//# Fast plain transition from stance1 to top-to-bottom Fast weak attack
+	BOTH_S2_S1__L,	//# Fast plain transition from stance1 to left-to-right Fast weak attack
+	BOTH_S2_S1__R,	//# Fast plain transition from stance1 to right-to-left Fast weak attack
+	BOTH_S2_S1_TL,	//# Fast plain transition from stance1 to top-left-to-bottom-right Fast weak attack
+	BOTH_S2_S1_BR,	//# Fast plain transition from stance1 to bottom-right-to-top-left Fast weak attack
+	BOTH_S2_S1_BL,	//# Fast plain transition from stance1 to bottom-left-to-top-right Fast weak attack
+	BOTH_S2_S1_TR,	//# Fast plain transition from stance1 to top-right-to-bottom-left Fast weak attack
+	//Saber Attack Return Transitions
+	BOTH_R2_B__S1,	//# Fast plain transition from top-to-bottom Fast weak attack to stance1
+	BOTH_R2__L_S1,	//# Fast plain transition from left-to-right Fast weak attack to stance1
+	BOTH_R2__R_S1,	//# Fast plain transition from right-to-left Fast weak attack to stance1
+	BOTH_R2_TL_S1,	//# Fast plain transition from top-left-to-bottom-right Fast weak attack to stance1
+	BOTH_R2_BR_S1,	//# Fast plain transition from bottom-right-to-top-left Fast weak attack to stance1
+	BOTH_R2_BL_S1,	//# Fast plain transition from bottom-left-to-top-right Fast weak attack to stance1
+	BOTH_R2_TR_S1,	//# Fast plain transition from top-right-to-bottom-left Fast weak attack
+	//Saber Attack Bounces (first 4 frames of an attack, played backwards)
+	BOTH_B2_BR___,	//# Bounce-back if attack from BR is blocked
+	BOTH_B2__R___,	//# Bounce-back if attack from R is blocked
+	BOTH_B2_TR___,	//# Bounce-back if attack from TR is blocked
+	BOTH_B2_T____,	//# Bounce-back if attack from T is blocked
+	BOTH_B2_TL___,	//# Bounce-back if attack from TL is blocked
+	BOTH_B2__L___,	//# Bounce-back if attack from L is blocked
+	BOTH_B2_BL___,	//# Bounce-back if attack from BL is blocked
+	//Saber Attack Deflections (last 4 frames of an attack)
+	BOTH_D2_BR___,	//# Deflection toward BR
+	BOTH_D2__R___,	//# Deflection toward R
+	BOTH_D2_TR___,	//# Deflection toward TR
+	BOTH_D2_TL___,	//# Deflection toward TL
+	BOTH_D2__L___,	//# Deflection toward L
+	BOTH_D2_BL___,	//# Deflection toward BL
+	BOTH_D2_B____,	//# Deflection toward B
+	//Saber attack anims - power level 3
+	BOTH_A3_T__B_,	//# Fast weak vertical attack top to bottom
+	BOTH_A3__L__R,	//# Fast weak horizontal attack left to right
+	BOTH_A3__R__L,	//# Fast weak horizontal attack right to left
+	BOTH_A3_TL_BR,	//# Fast weak diagonal attack top left to botom right
+	BOTH_A3_BR_TL,	//# Fast weak diagonal attack top left to botom right
+	BOTH_A3_BL_TR,	//# Fast weak diagonal attack bottom left to top right
+	BOTH_A3_TR_BL,	//# Fast weak diagonal attack bottom left to right
+	//Saber Arc and Spin Transitions
+	BOTH_T3_BR__R,	//# Fast arc bottom right to right
+	BOTH_T3_BR_TL,	//# Fast weak spin bottom right to top left
+	BOTH_T3_BR__L,	//# Fast weak spin bottom right to left
+	BOTH_T3_BR_BL,	//# Fast weak spin bottom right to bottom left
+	BOTH_T3__R_TR,	//# Fast arc right to top right
+	BOTH_T3__R_TL,	//# Fast arc right to top left
+	BOTH_T3__R__L,	//# Fast weak spin right to left
+	BOTH_T3__R_BL,	//# Fast weak spin right to bottom left
+	BOTH_T3_TR_BR,	//# Fast arc top right to bottom right
+	BOTH_T3_TR_TL,	//# Fast arc top right to top left
+	BOTH_T3_TR__L,	//# Fast arc top right to left
+	BOTH_T3_TR_BL,	//# Fast weak spin top right to bottom left
+	BOTH_T3_T__BR,	//# Fast arc top to bottom right
+	BOTH_T3_T___R,	//# Fast arc top to right
+	BOTH_T3_T__TR,	//# Fast arc top to top right
+	BOTH_T3_T__TL,	//# Fast arc top to top left
+	BOTH_T3_T___L,	//# Fast arc top to left
+	BOTH_T3_T__BL,	//# Fast arc top to bottom left
+	BOTH_T3_TL_BR,	//# Fast weak spin top left to bottom right
+	BOTH_T3_TL_BL,	//# Fast arc top left to bottom left
+	BOTH_T3__L_BR,	//# Fast weak spin left to bottom right
+	BOTH_T3__L__R,	//# Fast weak spin left to right
+	BOTH_T3__L_TL,	//# Fast arc left to top left
+	BOTH_T3_BL_BR,	//# Fast weak spin bottom left to bottom right
+	BOTH_T3_BL__R,	//# Fast weak spin bottom left to right
+	BOTH_T3_BL_TR,	//# Fast weak spin bottom left to top right
+	BOTH_T3_BL__L,	//# Fast arc bottom left to left
+	//Saber Arc Transitions that use existing animations played backwards
+	BOTH_T3_BR_TR,	//# Fast arc bottom right to top right		(use: BOTH_T3_TR_BR)
+	BOTH_T3_BR_T_,	//# Fast arc bottom right to top			(use: BOTH_T3_T__BR)
+	BOTH_T3__R_BR,	//# Fast arc right to bottom right			(use: BOTH_T3_BR__R)
+	BOTH_T3__R_T_,	//# Fast ar right to top				(use: BOTH_T3_T___R)
+	BOTH_T3_TR__R,	//# Fast arc top right to right			(use: BOTH_T3__R_TR)
+	BOTH_T3_TR_T_,	//# Fast arc top right to top				(use: BOTH_T3_T__TR)
+	BOTH_T3_TL__R,	//# Fast arc top left to right			(use: BOTH_T3__R_TL)
+	BOTH_T3_TL_TR,	//# Fast arc top left to top right			(use: BOTH_T3_TR_TL)
+	BOTH_T3_TL_T_,	//# Fast arc top left to top				(use: BOTH_T3_T__TL)
+	BOTH_T3_TL__L,	//# Fast arc top left to left				(use: BOTH_T3__L_TL)
+	BOTH_T3__L_TR,	//# Fast arc left to top right			(use: BOTH_T3_TR__L)
+	BOTH_T3__L_T_,	//# Fast arc left to top				(use: BOTH_T3_T___L)
+	BOTH_T3__L_BL,	//# Fast arc left to bottom left			(use: BOTH_T3_BL__L)
+	BOTH_T3_BL_T_,	//# Fast arc bottom left to top			(use: BOTH_T3_T__BL)
+	BOTH_T3_BL_TL,	//# Fast arc bottom left to top left		(use: BOTH_T3_TL_BL)
+	//Saber Attack Start Transitions
+	BOTH_S3_S1_T_,	//# Fast plain transition from stance1 to top-to-bottom Fast weak attack
+	BOTH_S3_S1__L,	//# Fast plain transition from stance1 to left-to-right Fast weak attack
+	BOTH_S3_S1__R,	//# Fast plain transition from stance1 to right-to-left Fast weak attack
+	BOTH_S3_S1_TL,	//# Fast plain transition from stance1 to top-left-to-bottom-right Fast weak attack
+	BOTH_S3_S1_BR,	//# Fast plain transition from stance1 to bottom-right-to-top-left Fast weak attack
+	BOTH_S3_S1_BL,	//# Fast plain transition from stance1 to bottom-left-to-top-right Fast weak attack
+	BOTH_S3_S1_TR,	//# Fast plain transition from stance1 to top-right-to-bottom-left Fast weak attack
+	//Saber Attack Return Transitions
+	BOTH_R3_B__S1,	//# Fast plain transition from top-to-bottom Fast weak attack to stance1
+	BOTH_R3__L_S1,	//# Fast plain transition from left-to-right Fast weak attack to stance1
+	BOTH_R3__R_S1,	//# Fast plain transition from right-to-left Fast weak attack to stance1
+	BOTH_R3_TL_S1,	//# Fast plain transition from top-left-to-bottom-right Fast weak attack to stance1
+	BOTH_R3_BR_S1,	//# Fast plain transition from bottom-right-to-top-left Fast weak attack to stance1
+	BOTH_R3_BL_S1,	//# Fast plain transition from bottom-left-to-top-right Fast weak attack to stance1
+	BOTH_R3_TR_S1,	//# Fast plain transition from top-right-to-bottom-left Fast weak attack
+	//Saber Attack Bounces (first 4 frames of an attack, played backwards)
+	BOTH_B3_BR___,	//# Bounce-back if attack from BR is blocked
+	BOTH_B3__R___,	//# Bounce-back if attack from R is blocked
+	BOTH_B3_TR___,	//# Bounce-back if attack from TR is blocked
+	BOTH_B3_T____,	//# Bounce-back if attack from T is blocked
+	BOTH_B3_TL___,	//# Bounce-back if attack from TL is blocked
+	BOTH_B3__L___,	//# Bounce-back if attack from L is blocked
+	BOTH_B3_BL___,	//# Bounce-back if attack from BL is blocked
+	//Saber Attack Deflections (last 4 frames of an attack)
+	BOTH_D3_BR___,	//# Deflection toward BR
+	BOTH_D3__R___,	//# Deflection toward R
+	BOTH_D3_TR___,	//# Deflection toward TR
+	BOTH_D3_TL___,	//# Deflection toward TL
+	BOTH_D3__L___,	//# Deflection toward L
+	BOTH_D3_BL___,	//# Deflection toward BL
+	BOTH_D3_B____,	//# Deflection toward B
+	//Saber attack anims - power level 4  - Desann's
+	BOTH_A4_T__B_,	//# Fast weak vertical attack top to bottom
+	BOTH_A4__L__R,	//# Fast weak horizontal attack left to right
+	BOTH_A4__R__L,	//# Fast weak horizontal attack right to left
+	BOTH_A4_TL_BR,	//# Fast weak diagonal attack top left to botom right
+	BOTH_A4_BR_TL,	//# Fast weak diagonal attack top left to botom right
+	BOTH_A4_BL_TR,	//# Fast weak diagonal attack bottom left to top right
+	BOTH_A4_TR_BL,	//# Fast weak diagonal attack bottom left to right
+	//Saber Arc and Spin Transitions
+	BOTH_T4_BR__R,	//# Fast arc bottom right to right
+	BOTH_T4_BR_TL,	//# Fast weak spin bottom right to top left
+	BOTH_T4_BR__L,	//# Fast weak spin bottom right to left
+	BOTH_T4_BR_BL,	//# Fast weak spin bottom right to bottom left
+	BOTH_T4__R_TR,	//# Fast arc right to top right
+	BOTH_T4__R_TL,	//# Fast arc right to top left
+	BOTH_T4__R__L,	//# Fast weak spin right to left
+	BOTH_T4__R_BL,	//# Fast weak spin right to bottom left
+	BOTH_T4_TR_BR,	//# Fast arc top right to bottom right
+	BOTH_T4_TR_TL,	//# Fast arc top right to top left
+	BOTH_T4_TR__L,	//# Fast arc top right to left
+	BOTH_T4_TR_BL,	//# Fast weak spin top right to bottom left
+	BOTH_T4_T__BR,	//# Fast arc top to bottom right
+	BOTH_T4_T___R,	//# Fast arc top to right
+	BOTH_T4_T__TR,	//# Fast arc top to top right
+	BOTH_T4_T__TL,	//# Fast arc top to top left
+	BOTH_T4_T___L,	//# Fast arc top to left
+	BOTH_T4_T__BL,	//# Fast arc top to bottom left
+	BOTH_T4_TL_BR,	//# Fast weak spin top left to bottom right
+	BOTH_T4_TL_BL,	//# Fast arc top left to bottom left
+	BOTH_T4__L_BR,	//# Fast weak spin left to bottom right
+	BOTH_T4__L__R,	//# Fast weak spin left to right
+	BOTH_T4__L_TL,	//# Fast arc left to top left
+	BOTH_T4_BL_BR,	//# Fast weak spin bottom left to bottom right
+	BOTH_T4_BL__R,	//# Fast weak spin bottom left to right
+	BOTH_T4_BL_TR,	//# Fast weak spin bottom left to top right
+	BOTH_T4_BL__L,	//# Fast arc bottom left to left
+	//Saber Arc Transitions that use existing animations played backwards
+	BOTH_T4_BR_TR,	//# Fast arc bottom right to top right		(use: BOTH_T4_TR_BR)
+	BOTH_T4_BR_T_,	//# Fast arc bottom right to top			(use: BOTH_T4_T__BR)
+	BOTH_T4__R_BR,	//# Fast arc right to bottom right			(use: BOTH_T4_BR__R)
+	BOTH_T4__R_T_,	//# Fast ar right to top				(use: BOTH_T4_T___R)
+	BOTH_T4_TR__R,	//# Fast arc top right to right			(use: BOTH_T4__R_TR)
+	BOTH_T4_TR_T_,	//# Fast arc top right to top				(use: BOTH_T4_T__TR)
+	BOTH_T4_TL__R,	//# Fast arc top left to right			(use: BOTH_T4__R_TL)
+	BOTH_T4_TL_TR,	//# Fast arc top left to top right			(use: BOTH_T4_TR_TL)
+	BOTH_T4_TL_T_,	//# Fast arc top left to top				(use: BOTH_T4_T__TL)
+	BOTH_T4_TL__L,	//# Fast arc top left to left				(use: BOTH_T4__L_TL)
+	BOTH_T4__L_TR,	//# Fast arc left to top right			(use: BOTH_T4_TR__L)
+	BOTH_T4__L_T_,	//# Fast arc left to top				(use: BOTH_T4_T___L)
+	BOTH_T4__L_BL,	//# Fast arc left to bottom left			(use: BOTH_T4_BL__L)
+	BOTH_T4_BL_T_,	//# Fast arc bottom left to top			(use: BOTH_T4_T__BL)
+	BOTH_T4_BL_TL,	//# Fast arc bottom left to top left		(use: BOTH_T4_TL_BL)
+	//Saber Attack Start Transitions
+	BOTH_S4_S1_T_,	//# Fast plain transition from stance1 to top-to-bottom Fast weak attack
+	BOTH_S4_S1__L,	//# Fast plain transition from stance1 to left-to-right Fast weak attack
+	BOTH_S4_S1__R,	//# Fast plain transition from stance1 to right-to-left Fast weak attack
+	BOTH_S4_S1_TL,	//# Fast plain transition from stance1 to top-left-to-bottom-right Fast weak attack
+	BOTH_S4_S1_BR,	//# Fast plain transition from stance1 to bottom-right-to-top-left Fast weak attack
+	BOTH_S4_S1_BL,	//# Fast plain transition from stance1 to bottom-left-to-top-right Fast weak attack
+	BOTH_S4_S1_TR,	//# Fast plain transition from stance1 to top-right-to-bottom-left Fast weak attack
+	//Saber Attack Return Transitions
+	BOTH_R4_B__S1,	//# Fast plain transition from top-to-bottom Fast weak attack to stance1
+	BOTH_R4__L_S1,	//# Fast plain transition from left-to-right Fast weak attack to stance1
+	BOTH_R4__R_S1,	//# Fast plain transition from right-to-left Fast weak attack to stance1
+	BOTH_R4_TL_S1,	//# Fast plain transition from top-left-to-bottom-right Fast weak attack to stance1
+	BOTH_R4_BR_S1,	//# Fast plain transition from bottom-right-to-top-left Fast weak attack to stance1
+	BOTH_R4_BL_S1,	//# Fast plain transition from bottom-left-to-top-right Fast weak attack to stance1
+	BOTH_R4_TR_S1,	//# Fast plain transition from top-right-to-bottom-left Fast weak attack
+	//Saber Attack Bounces (first 4 frames of an attack, played backwards)
+	BOTH_B4_BR___,	//# Bounce-back if attack from BR is blocked
+	BOTH_B4__R___,	//# Bounce-back if attack from R is blocked
+	BOTH_B4_TR___,	//# Bounce-back if attack from TR is blocked
+	BOTH_B4_T____,	//# Bounce-back if attack from T is blocked
+	BOTH_B4_TL___,	//# Bounce-back if attack from TL is blocked
+	BOTH_B4__L___,	//# Bounce-back if attack from L is blocked
+	BOTH_B4_BL___,	//# Bounce-back if attack from BL is blocked
+	//Saber Attack Deflections (last 4 frames of an attack)
+	BOTH_D4_BR___,	//# Deflection toward BR
+	BOTH_D4__R___,	//# Deflection toward R
+	BOTH_D4_TR___,	//# Deflection toward TR
+	BOTH_D4_TL___,	//# Deflection toward TL
+	BOTH_D4__L___,	//# Deflection toward L
+	BOTH_D4_BL___,	//# Deflection toward BL
+	BOTH_D4_B____,	//# Deflection toward B
+	//Saber attack anims - power level 5  - Tavion's
+	BOTH_A5_T__B_,	//# Fast weak vertical attack top to bottom
+	BOTH_A5__L__R,	//# Fast weak horizontal attack left to right
+	BOTH_A5__R__L,	//# Fast weak horizontal attack right to left
+	BOTH_A5_TL_BR,	//# Fast weak diagonal attack top left to botom right
+	BOTH_A5_BR_TL,	//# Fast weak diagonal attack top left to botom right
+	BOTH_A5_BL_TR,	//# Fast weak diagonal attack bottom left to top right
+	BOTH_A5_TR_BL,	//# Fast weak diagonal attack bottom left to right
+	//Saber Arc and Spin Transitions
+	BOTH_T5_BR__R,	//# Fast arc bottom right to right
+	BOTH_T5_BR_TL,	//# Fast weak spin bottom right to top left
+	BOTH_T5_BR__L,	//# Fast weak spin bottom right to left
+	BOTH_T5_BR_BL,	//# Fast weak spin bottom right to bottom left
+	BOTH_T5__R_TR,	//# Fast arc right to top right
+	BOTH_T5__R_TL,	//# Fast arc right to top left
+	BOTH_T5__R__L,	//# Fast weak spin right to left
+	BOTH_T5__R_BL,	//# Fast weak spin right to bottom left
+	BOTH_T5_TR_BR,	//# Fast arc top right to bottom right
+	BOTH_T5_TR_TL,	//# Fast arc top right to top left
+	BOTH_T5_TR__L,	//# Fast arc top right to left
+	BOTH_T5_TR_BL,	//# Fast weak spin top right to bottom left
+	BOTH_T5_T__BR,	//# Fast arc top to bottom right
+	BOTH_T5_T___R,	//# Fast arc top to right
+	BOTH_T5_T__TR,	//# Fast arc top to top right
+	BOTH_T5_T__TL,	//# Fast arc top to top left
+	BOTH_T5_T___L,	//# Fast arc top to left
+	BOTH_T5_T__BL,	//# Fast arc top to bottom left
+	BOTH_T5_TL_BR,	//# Fast weak spin top left to bottom right
+	BOTH_T5_TL_BL,	//# Fast arc top left to bottom left
+	BOTH_T5__L_BR,	//# Fast weak spin left to bottom right
+	BOTH_T5__L__R,	//# Fast weak spin left to right
+	BOTH_T5__L_TL,	//# Fast arc left to top left
+	BOTH_T5_BL_BR,	//# Fast weak spin bottom left to bottom right
+	BOTH_T5_BL__R,	//# Fast weak spin bottom left to right
+	BOTH_T5_BL_TR,	//# Fast weak spin bottom left to top right
+	BOTH_T5_BL__L,	//# Fast arc bottom left to left
+	//Saber Arc Transitions that use existing animations played backwards
+	BOTH_T5_BR_TR,	//# Fast arc bottom right to top right		(use: BOTH_T5_TR_BR)
+	BOTH_T5_BR_T_,	//# Fast arc bottom right to top			(use: BOTH_T5_T__BR)
+	BOTH_T5__R_BR,	//# Fast arc right to bottom right			(use: BOTH_T5_BR__R)
+	BOTH_T5__R_T_,	//# Fast ar right to top				(use: BOTH_T5_T___R)
+	BOTH_T5_TR__R,	//# Fast arc top right to right			(use: BOTH_T5__R_TR)
+	BOTH_T5_TR_T_,	//# Fast arc top right to top				(use: BOTH_T5_T__TR)
+	BOTH_T5_TL__R,	//# Fast arc top left to right			(use: BOTH_T5__R_TL)
+	BOTH_T5_TL_TR,	//# Fast arc top left to top right			(use: BOTH_T5_TR_TL)
+	BOTH_T5_TL_T_,	//# Fast arc top left to top				(use: BOTH_T5_T__TL)
+	BOTH_T5_TL__L,	//# Fast arc top left to left				(use: BOTH_T5__L_TL)
+	BOTH_T5__L_TR,	//# Fast arc left to top right			(use: BOTH_T5_TR__L)
+	BOTH_T5__L_T_,	//# Fast arc left to top				(use: BOTH_T5_T___L)
+	BOTH_T5__L_BL,	//# Fast arc left to bottom left			(use: BOTH_T5_BL__L)
+	BOTH_T5_BL_T_,	//# Fast arc bottom left to top			(use: BOTH_T5_T__BL)
+	BOTH_T5_BL_TL,	//# Fast arc bottom left to top left		(use: BOTH_T5_TL_BL)
+	//Saber Attack Start Transitions
+	BOTH_S5_S1_T_,	//# Fast plain transition from stance1 to top-to-bottom Fast weak attack
+	BOTH_S5_S1__L,	//# Fast plain transition from stance1 to left-to-right Fast weak attack
+	BOTH_S5_S1__R,	//# Fast plain transition from stance1 to right-to-left Fast weak attack
+	BOTH_S5_S1_TL,	//# Fast plain transition from stance1 to top-left-to-bottom-right Fast weak attack
+	BOTH_S5_S1_BR,	//# Fast plain transition from stance1 to bottom-right-to-top-left Fast weak attack
+	BOTH_S5_S1_BL,	//# Fast plain transition from stance1 to bottom-left-to-top-right Fast weak attack
+	BOTH_S5_S1_TR,	//# Fast plain transition from stance1 to top-right-to-bottom-left Fast weak attack
+	//Saber Attack Return Transitions
+	BOTH_R5_B__S1,	//# Fast plain transition from top-to-bottom Fast weak attack to stance1
+	BOTH_R5__L_S1,	//# Fast plain transition from left-to-right Fast weak attack to stance1
+	BOTH_R5__R_S1,	//# Fast plain transition from right-to-left Fast weak attack to stance1
+	BOTH_R5_TL_S1,	//# Fast plain transition from top-left-to-bottom-right Fast weak attack to stance1
+	BOTH_R5_BR_S1,	//# Fast plain transition from bottom-right-to-top-left Fast weak attack to stance1
+	BOTH_R5_BL_S1,	//# Fast plain transition from bottom-left-to-top-right Fast weak attack to stance1
+	BOTH_R5_TR_S1,	//# Fast plain transition from top-right-to-bottom-left Fast weak attack
+	//Saber Attack Bounces (first 4 frames of an attack, played backwards)
+	BOTH_B5_BR___,	//# Bounce-back if attack from BR is blocked
+	BOTH_B5__R___,	//# Bounce-back if attack from R is blocked
+	BOTH_B5_TR___,	//# Bounce-back if attack from TR is blocked
+	BOTH_B5_T____,	//# Bounce-back if attack from T is blocked
+	BOTH_B5_TL___,	//# Bounce-back if attack from TL is blocked
+	BOTH_B5__L___,	//# Bounce-back if attack from L is blocked
+	BOTH_B5_BL___,	//# Bounce-back if attack from BL is blocked
+	//Saber Attack Deflections (last 4 frames of an attack)
+	BOTH_D5_BR___,	//# Deflection toward BR
+	BOTH_D5__R___,	//# Deflection toward R
+	BOTH_D5_TR___,	//# Deflection toward TR
+	BOTH_D5_TL___,	//# Deflection toward TL
+	BOTH_D5__L___,	//# Deflection toward L
+	BOTH_D5_BL___,	//# Deflection toward BL
+	BOTH_D5_B____,	//# Deflection toward B
+	//Saber attack anims - power level 6
+	BOTH_A6_T__B_,	//# Fast weak vertical attack top to bottom
+	BOTH_A6__L__R,	//# Fast weak horizontal attack left to right
+	BOTH_A6__R__L,	//# Fast weak horizontal attack right to left
+	BOTH_A6_TL_BR,	//# Fast weak diagonal attack top left to botom right
+	BOTH_A6_BR_TL,	//# Fast weak diagonal attack top left to botom right
+	BOTH_A6_BL_TR,	//# Fast weak diagonal attack bottom left to top right
+	BOTH_A6_TR_BL,	//# Fast weak diagonal attack bottom left to right
+	//Saber Arc and Spin Transitions
+	BOTH_T6_BR__R,	//# Fast arc bottom right to right
+	BOTH_T6_BR_TL,	//# Fast weak spin bottom right to top left
+	BOTH_T6_BR__L,	//# Fast weak spin bottom right to left
+	BOTH_T6_BR_BL,	//# Fast weak spin bottom right to bottom left
+	BOTH_T6__R_TR,	//# Fast arc right to top right
+	BOTH_T6__R_TL,	//# Fast arc right to top left
+	BOTH_T6__R__L,	//# Fast weak spin right to left
+	BOTH_T6__R_BL,	//# Fast weak spin right to bottom left
+	BOTH_T6_TR_BR,	//# Fast arc top right to bottom right
+	BOTH_T6_TR_TL,	//# Fast arc top right to top left
+	BOTH_T6_TR__L,	//# Fast arc top right to left
+	BOTH_T6_TR_BL,	//# Fast weak spin top right to bottom left
+	BOTH_T6_T__BR,	//# Fast arc top to bottom right
+	BOTH_T6_T___R,	//# Fast arc top to right
+	BOTH_T6_T__TR,	//# Fast arc top to top right
+	BOTH_T6_T__TL,	//# Fast arc top to top left
+	BOTH_T6_T___L,	//# Fast arc top to left
+	BOTH_T6_T__BL,	//# Fast arc top to bottom left
+	BOTH_T6_TL_BR,	//# Fast weak spin top left to bottom right
+	BOTH_T6_TL_BL,	//# Fast arc top left to bottom left
+	BOTH_T6__L_BR,	//# Fast weak spin left to bottom right
+	BOTH_T6__L__R,	//# Fast weak spin left to right
+	BOTH_T6__L_TL,	//# Fast arc left to top left
+	BOTH_T6_BL_BR,	//# Fast weak spin bottom left to bottom right
+	BOTH_T6_BL__R,	//# Fast weak spin bottom left to right
+	BOTH_T6_BL_TR,	//# Fast weak spin bottom left to top right
+	BOTH_T6_BL__L,	//# Fast arc bottom left to left
+	//Saber Arc Transitions that use existing animations played backwards
+	BOTH_T6_BR_TR,	//# Fast arc bottom right to top right		(use: BOTH_T6_TR_BR)
+	BOTH_T6_BR_T_,	//# Fast arc bottom right to top			(use: BOTH_T6_T__BR)
+	BOTH_T6__R_BR,	//# Fast arc right to bottom right			(use: BOTH_T6_BR__R)
+	BOTH_T6__R_T_,	//# Fast ar right to top				(use: BOTH_T6_T___R)
+	BOTH_T6_TR__R,	//# Fast arc top right to right			(use: BOTH_T6__R_TR)
+	BOTH_T6_TR_T_,	//# Fast arc top right to top				(use: BOTH_T6_T__TR)
+	BOTH_T6_TL__R,	//# Fast arc top left to right			(use: BOTH_T6__R_TL)
+	BOTH_T6_TL_TR,	//# Fast arc top left to top right			(use: BOTH_T6_TR_TL)
+	BOTH_T6_TL_T_,	//# Fast arc top left to top				(use: BOTH_T6_T__TL)
+	BOTH_T6_TL__L,	//# Fast arc top left to left				(use: BOTH_T6__L_TL)
+	BOTH_T6__L_TR,	//# Fast arc left to top right			(use: BOTH_T6_TR__L)
+	BOTH_T6__L_T_,	//# Fast arc left to top				(use: BOTH_T6_T___L)
+	BOTH_T6__L_BL,	//# Fast arc left to bottom left			(use: BOTH_T6_BL__L)
+	BOTH_T6_BL_T_,	//# Fast arc bottom left to top			(use: BOTH_T6_T__BL)
+	BOTH_T6_BL_TL,	//# Fast arc bottom left to top left		(use: BOTH_T6_TL_BL)
+	//Saber Attack Start Transitions
+	BOTH_S6_S6_T_,	//# Fast plain transition from stance1 to top-to-bottom Fast weak attack
+	BOTH_S6_S6__L,	//# Fast plain transition from stance1 to left-to-right Fast weak attack
+	BOTH_S6_S6__R,	//# Fast plain transition from stance1 to right-to-left Fast weak attack
+	BOTH_S6_S6_TL,	//# Fast plain transition from stance1 to top-left-to-bottom-right Fast weak attack
+	BOTH_S6_S6_BR,	//# Fast plain transition from stance1 to bottom-right-to-top-left Fast weak attack
+	BOTH_S6_S6_BL,	//# Fast plain transition from stance1 to bottom-left-to-top-right Fast weak attack
+	BOTH_S6_S6_TR,	//# Fast plain transition from stance1 to top-right-to-bottom-left Fast weak attack
+	//Saber Attack Return Transitions
+	BOTH_R6_B__S6,	//# Fast plain transition from top-to-bottom Fast weak attack to stance1
+	BOTH_R6__L_S6,	//# Fast plain transition from left-to-right Fast weak attack to stance1
+	BOTH_R6__R_S6,	//# Fast plain transition from right-to-left Fast weak attack to stance1
+	BOTH_R6_TL_S6,	//# Fast plain transition from top-left-to-bottom-right Fast weak attack to stance1
+	BOTH_R6_BR_S6,	//# Fast plain transition from bottom-right-to-top-left Fast weak attack to stance1
+	BOTH_R6_BL_S6,	//# Fast plain transition from bottom-left-to-top-right Fast weak attack to stance1
+	BOTH_R6_TR_S6,	//# Fast plain transition from top-right-to-bottom-left Fast weak attack
+	//Saber Attack Bounces (first 4 frames of an attack, played backwards)
+	BOTH_B6_BR___,	//# Bounce-back if attack from BR is blocked
+	BOTH_B6__R___,	//# Bounce-back if attack from R is blocked
+	BOTH_B6_TR___,	//# Bounce-back if attack from TR is blocked
+	BOTH_B6_T____,	//# Bounce-back if attack from T is blocked
+	BOTH_B6_TL___,	//# Bounce-back if attack from TL is blocked
+	BOTH_B6__L___,	//# Bounce-back if attack from L is blocked
+	BOTH_B6_BL___,	//# Bounce-back if attack from BL is blocked
+	//Saber Attack Deflections (last 4 frames of an attack)
+	BOTH_D6_BR___,	//# Deflection toward BR
+	BOTH_D6__R___,	//# Deflection toward R
+	BOTH_D6_TR___,	//# Deflection toward TR
+	BOTH_D6_TL___,	//# Deflection toward TL
+	BOTH_D6__L___,	//# Deflection toward L
+	BOTH_D6_BL___,	//# Deflection toward BL
+	BOTH_D6_B____,	//# Deflection toward B
+	//Saber attack anims - power level 7
+	BOTH_A7_T__B_,	//# Fast weak vertical attack top to bottom
+	BOTH_A7__L__R,	//# Fast weak horizontal attack left to right
+	BOTH_A7__R__L,	//# Fast weak horizontal attack right to left
+	BOTH_A7_TL_BR,	//# Fast weak diagonal attack top left to botom right
+	BOTH_A7_BR_TL,	//# Fast weak diagonal attack top left to botom right
+	BOTH_A7_BL_TR,	//# Fast weak diagonal attack bottom left to top right
+	BOTH_A7_TR_BL,	//# Fast weak diagonal attack bottom left to right
+	//Saber Arc and Spin Transitions
+	BOTH_T7_BR__R,	//# Fast arc bottom right to right
+	BOTH_T7_BR_TL,	//# Fast weak spin bottom right to top left
+	BOTH_T7_BR__L,	//# Fast weak spin bottom right to left
+	BOTH_T7_BR_BL,	//# Fast weak spin bottom right to bottom left
+	BOTH_T7__R_TR,	//# Fast arc right to top right
+	BOTH_T7__R_TL,	//# Fast arc right to top left
+	BOTH_T7__R__L,	//# Fast weak spin right to left
+	BOTH_T7__R_BL,	//# Fast weak spin right to bottom left
+	BOTH_T7_TR_BR,	//# Fast arc top right to bottom right
+	BOTH_T7_TR_TL,	//# Fast arc top right to top left
+	BOTH_T7_TR__L,	//# Fast arc top right to left
+	BOTH_T7_TR_BL,	//# Fast weak spin top right to bottom left
+	BOTH_T7_T__BR,	//# Fast arc top to bottom right
+	BOTH_T7_T___R,	//# Fast arc top to right
+	BOTH_T7_T__TR,	//# Fast arc top to top right
+	BOTH_T7_T__TL,	//# Fast arc top to top left
+	BOTH_T7_T___L,	//# Fast arc top to left
+	BOTH_T7_T__BL,	//# Fast arc top to bottom left
+	BOTH_T7_TL_BR,	//# Fast weak spin top left to bottom right
+	BOTH_T7_TL_BL,	//# Fast arc top left to bottom left
+	BOTH_T7__L_BR,	//# Fast weak spin left to bottom right
+	BOTH_T7__L__R,	//# Fast weak spin left to right
+	BOTH_T7__L_TL,	//# Fast arc left to top left
+	BOTH_T7_BL_BR,	//# Fast weak spin bottom left to bottom right
+	BOTH_T7_BL__R,	//# Fast weak spin bottom left to right
+	BOTH_T7_BL_TR,	//# Fast weak spin bottom left to top right
+	BOTH_T7_BL__L,	//# Fast arc bottom left to left
+	//Saber Arc Transitions that use existing animations played backwards
+	BOTH_T7_BR_TR,	//# Fast arc bottom right to top right		(use: BOTH_T7_TR_BR)
+	BOTH_T7_BR_T_,	//# Fast arc bottom right to top			(use: BOTH_T7_T__BR)
+	BOTH_T7__R_BR,	//# Fast arc right to bottom right			(use: BOTH_T7_BR__R)
+	BOTH_T7__R_T_,	//# Fast ar right to top				(use: BOTH_T7_T___R)
+	BOTH_T7_TR__R,	//# Fast arc top right to right			(use: BOTH_T7__R_TR)
+	BOTH_T7_TR_T_,	//# Fast arc top right to top				(use: BOTH_T7_T__TR)
+	BOTH_T7_TL__R,	//# Fast arc top left to right			(use: BOTH_T7__R_TL)
+	BOTH_T7_TL_TR,	//# Fast arc top left to top right			(use: BOTH_T7_TR_TL)
+	BOTH_T7_TL_T_,	//# Fast arc top left to top				(use: BOTH_T7_T__TL)
+	BOTH_T7_TL__L,	//# Fast arc top left to left				(use: BOTH_T7__L_TL)
+	BOTH_T7__L_TR,	//# Fast arc left to top right			(use: BOTH_T7_TR__L)
+	BOTH_T7__L_T_,	//# Fast arc left to top				(use: BOTH_T7_T___L)
+	BOTH_T7__L_BL,	//# Fast arc left to bottom left			(use: BOTH_T7_BL__L)
+	BOTH_T7_BL_T_,	//# Fast arc bottom left to top			(use: BOTH_T7_T__BL)
+	BOTH_T7_BL_TL,	//# Fast arc bottom left to top left		(use: BOTH_T7_TL_BL)
+	//Saber Attack Start Transitions
+	BOTH_S7_S7_T_,	//# Fast plain transition from stance1 to top-to-bottom Fast weak attack
+	BOTH_S7_S7__L,	//# Fast plain transition from stance1 to left-to-right Fast weak attack
+	BOTH_S7_S7__R,	//# Fast plain transition from stance1 to right-to-left Fast weak attack
+	BOTH_S7_S7_TL,	//# Fast plain transition from stance1 to top-left-to-bottom-right Fast weak attack
+	BOTH_S7_S7_BR,	//# Fast plain transition from stance1 to bottom-right-to-top-left Fast weak attack
+	BOTH_S7_S7_BL,	//# Fast plain transition from stance1 to bottom-left-to-top-right Fast weak attack
+	BOTH_S7_S7_TR,	//# Fast plain transition from stance1 to top-right-to-bottom-left Fast weak attack
+	//Saber Attack Return Transitions
+	BOTH_R7_B__S7,	//# Fast plain transition from top-to-bottom Fast weak attack to stance1
+	BOTH_R7__L_S7,	//# Fast plain transition from left-to-right Fast weak attack to stance1
+	BOTH_R7__R_S7,	//# Fast plain transition from right-to-left Fast weak attack to stance1
+	BOTH_R7_TL_S7,	//# Fast plain transition from top-left-to-bottom-right Fast weak attack to stance1
+	BOTH_R7_BR_S7,	//# Fast plain transition from bottom-right-to-top-left Fast weak attack to stance1
+	BOTH_R7_BL_S7,	//# Fast plain transition from bottom-left-to-top-right Fast weak attack to stance1
+	BOTH_R7_TR_S7,	//# Fast plain transition from top-right-to-bottom-left Fast weak attack
+	//Saber Attack Bounces (first 4 frames of an attack, played backwards)
+	BOTH_B7_BR___,	//# Bounce-back if attack from BR is blocked
+	BOTH_B7__R___,	//# Bounce-back if attack from R is blocked
+	BOTH_B7_TR___,	//# Bounce-back if attack from TR is blocked
+	BOTH_B7_T____,	//# Bounce-back if attack from T is blocked
+	BOTH_B7_TL___,	//# Bounce-back if attack from TL is blocked
+	BOTH_B7__L___,	//# Bounce-back if attack from L is blocked
+	BOTH_B7_BL___,	//# Bounce-back if attack from BL is blocked
+	//Saber Attack Deflections (last 4 frames of an attack)
+	BOTH_D7_BR___,	//# Deflection toward BR
+	BOTH_D7__R___,	//# Deflection toward R
+	BOTH_D7_TR___,	//# Deflection toward TR
+	BOTH_D7_TL___,	//# Deflection toward TL
+	BOTH_D7__L___,	//# Deflection toward L
+	BOTH_D7_BL___,	//# Deflection toward BL
+	BOTH_D7_B____,	//# Deflection toward B
+	//Saber parry anims
+	BOTH_P1_S1_T_,	//# Block shot/saber top
+	BOTH_P1_S1_TR,	//# Block shot/saber top right
+	BOTH_P1_S1_TL,	//# Block shot/saber top left
+	BOTH_P1_S1_BL,	//# Block shot/saber bottom left
+	BOTH_P1_S1_BR,	//# Block shot/saber bottom right
+	//Saber knockaway
+	BOTH_K1_S1_T_,	//# knockaway saber top
+	BOTH_K1_S1_TR,	//# knockaway saber top right
+	BOTH_K1_S1_TL,	//# knockaway saber top left
+	BOTH_K1_S1_BL,	//# knockaway saber bottom left
+	BOTH_K1_S1_B_,	//# knockaway saber bottom
+	BOTH_K1_S1_BR,	//# knockaway saber bottom right
+	//Saber attack knocked away
+	BOTH_V1_BR_S1,	//# BR attack knocked away
+	BOTH_V1__R_S1,	//# R attack knocked away
+	BOTH_V1_TR_S1,	//# TR attack knocked away
+	BOTH_V1_T__S1,	//# T attack knocked away
+	BOTH_V1_TL_S1,	//# TL attack knocked away
+	BOTH_V1__L_S1,	//# L attack knocked away
+	BOTH_V1_BL_S1,	//# BL attack knocked away
+	BOTH_V1_B__S1,	//# B attack knocked away
+	//Saber parry broken
+	BOTH_H1_S1_T_,	//# saber knocked down from top parry
+	BOTH_H1_S1_TR,	//# saber knocked down-left from TR parry
+	BOTH_H1_S1_TL,	//# saber knocked down-right from TL parry
+	BOTH_H1_S1_BL,	//# saber knocked up-right from BL parry
+	BOTH_H1_S1_B_,	//# saber knocked up over head from ready?
+	BOTH_H1_S1_BR,	//# saber knocked up-left from BR parry
+	//Dual Saber parry anims
+	BOTH_P6_S6_T_,	//# Block shot/saber top
+	BOTH_P6_S6_TR,	//# Block shot/saber top right
+	BOTH_P6_S6_TL,	//# Block shot/saber top left
+	BOTH_P6_S6_BL,	//# Block shot/saber bottom left
+	BOTH_P6_S6_BR,	//# Block shot/saber bottom right
+	//Dual Saber knockaway
+	BOTH_K6_S6_T_,	//# knockaway saber top
+	BOTH_K6_S6_TR,	//# knockaway saber top right
+	BOTH_K6_S6_TL,	//# knockaway saber top left
+	BOTH_K6_S6_BL,	//# knockaway saber bottom left
+	BOTH_K6_S6_B_,	//# knockaway saber bottom
+	BOTH_K6_S6_BR,	//# knockaway saber bottom right
+	//Dual Saber attack knocked away
+	BOTH_V6_BR_S6,	//# BR attack knocked away
+	BOTH_V6__R_S6,	//# R attack knocked away
+	BOTH_V6_TR_S6,	//# TR attack knocked away
+	BOTH_V6_T__S6,	//# T attack knocked away
+	BOTH_V6_TL_S6,	//# TL attack knocked away
+	BOTH_V6__L_S6,	//# L attack knocked away
+	BOTH_V6_BL_S6,	//# BL attack knocked away
+	BOTH_V6_B__S6,	//# B attack knocked away
+	//Dual Saber parry broken
+	BOTH_H6_S6_T_,	//# saber knocked down from top parry
+	BOTH_H6_S6_TR,	//# saber knocked down-left from TR parry
+	BOTH_H6_S6_TL,	//# saber knocked down-right from TL parry
+	BOTH_H6_S6_BL,	//# saber knocked up-right from BL parry
+	BOTH_H6_S6_B_,	//# saber knocked up over head from ready?
+	BOTH_H6_S6_BR,	//# saber knocked up-left from BR parry
+	//SaberStaff parry anims
+	BOTH_P7_S7_T_,	//# Block shot/saber top
+	BOTH_P7_S7_TR,	//# Block shot/saber top right
+	BOTH_P7_S7_TL,	//# Block shot/saber top left
+	BOTH_P7_S7_BL,	//# Block shot/saber bottom left
+	BOTH_P7_S7_BR,	//# Block shot/saber bottom right
+	//SaberStaff knockaway
+	BOTH_K7_S7_T_,	//# knockaway saber top
+	BOTH_K7_S7_TR,	//# knockaway saber top right
+	BOTH_K7_S7_TL,	//# knockaway saber top left
+	BOTH_K7_S7_BL,	//# knockaway saber bottom left
+	BOTH_K7_S7_B_,	//# knockaway saber bottom
+	BOTH_K7_S7_BR,	//# knockaway saber bottom right
+	//SaberStaff attack knocked away
+	BOTH_V7_BR_S7,	//# BR attack knocked away
+	BOTH_V7__R_S7,	//# R attack knocked away
+	BOTH_V7_TR_S7,	//# TR attack knocked away
+	BOTH_V7_T__S7,	//# T attack knocked away
+	BOTH_V7_TL_S7,	//# TL attack knocked away
+	BOTH_V7__L_S7,	//# L attack knocked away
+	BOTH_V7_BL_S7,	//# BL attack knocked away
+	BOTH_V7_B__S7,	//# B attack knocked away
+	//SaberStaff parry broken
+	BOTH_H7_S7_T_,	//# saber knocked down from top parry
+	BOTH_H7_S7_TR,	//# saber knocked down-left from TR parry
+	BOTH_H7_S7_TL,	//# saber knocked down-right from TL parry
+	BOTH_H7_S7_BL,	//# saber knocked up-right from BL parry
+	BOTH_H7_S7_B_,	//# saber knocked up over head from ready?
+	BOTH_H7_S7_BR,	//# saber knocked up-left from BR parry
+	//Sabers locked anims
+	//* #sep BOTH_ SABER LOCKED ANIMS
+	//BOTH_(DL, S, ST)_(DL, S, ST)_(T, S)_(L, B, SB)_1(_W, _L)
+//===Single locks==================================================================
+//SINGLE vs. DUAL
+	//side locks - I'm using a single and they're using dual
+	BOTH_LK_S_DL_S_B_1_L,	//normal break I lost
+	BOTH_LK_S_DL_S_B_1_W,	//normal break I won
+	BOTH_LK_S_DL_S_L_1,		//lock if I'm using single vs. a dual
+	BOTH_LK_S_DL_S_SB_1_L,	//super break I lost
+	BOTH_LK_S_DL_S_SB_1_W,	//super break I won
+	//top locks
+	BOTH_LK_S_DL_T_B_1_L,	//normal break I lost
+	BOTH_LK_S_DL_T_B_1_W,	//normal break I won
+	BOTH_LK_S_DL_T_L_1,		//lock if I'm using single vs. a dual
+	BOTH_LK_S_DL_T_SB_1_L,	//super break I lost
+	BOTH_LK_S_DL_T_SB_1_W,	//super break I won
+//SINGLE vs. STAFF
+	//side locks
+	BOTH_LK_S_ST_S_B_1_L,	//normal break I lost
+	BOTH_LK_S_ST_S_B_1_W,	//normal break I won
+	BOTH_LK_S_ST_S_L_1,		//lock if I'm using single vs. a staff
+	BOTH_LK_S_ST_S_SB_1_L,	//super break I lost
+	BOTH_LK_S_ST_S_SB_1_W,	//super break I won
+	//top locks
+	BOTH_LK_S_ST_T_B_1_L,	//normal break I lost
+	BOTH_LK_S_ST_T_B_1_W,	//normal break I won
+	BOTH_LK_S_ST_T_L_1,		//lock if I'm using single vs. a staff
+	BOTH_LK_S_ST_T_SB_1_L,	//super break I lost
+	BOTH_LK_S_ST_T_SB_1_W,	//super break I won
+//SINGLE vs. SINGLE
+	//side locks
+	BOTH_LK_S_S_S_B_1_L,	//normal break I lost
+	BOTH_LK_S_S_S_B_1_W,	//normal break I won
+	BOTH_LK_S_S_S_L_1,		//lock if I'm using single vs. a single and I initiated
+	BOTH_LK_S_S_S_SB_1_L,	//super break I lost
+	BOTH_LK_S_S_S_SB_1_W,	//super break I won
+	//top locks
+	BOTH_LK_S_S_T_B_1_L,	//normal break I lost
+	BOTH_LK_S_S_T_B_1_W,	//normal break I won
+	BOTH_LK_S_S_T_L_1,		//lock if I'm using single vs. a single and I initiated
+	BOTH_LK_S_S_T_SB_1_L,	//super break I lost
+	BOTH_LK_S_S_T_SB_1_W,	//super break I won
+//===Dual Saber locks==================================================================
+//DUAL vs. DUAL	
+	//side locks
+	BOTH_LK_DL_DL_S_B_1_L,	//normal break I lost
+	BOTH_LK_DL_DL_S_B_1_W,	//normal break I won
+	BOTH_LK_DL_DL_S_L_1,	//lock if I'm using dual vs. dual and I initiated
+	BOTH_LK_DL_DL_S_SB_1_L,	//super break I lost
+	BOTH_LK_DL_DL_S_SB_1_W,	//super break I won
+	//top locks
+	BOTH_LK_DL_DL_T_B_1_L,	//normal break I lost
+	BOTH_LK_DL_DL_T_B_1_W,	//normal break I won
+	BOTH_LK_DL_DL_T_L_1,	//lock if I'm using dual vs. dual and I initiated
+	BOTH_LK_DL_DL_T_SB_1_L,	//super break I lost
+	BOTH_LK_DL_DL_T_SB_1_W,	//super break I won
+//DUAL vs. STAFF
+	//side locks
+	BOTH_LK_DL_ST_S_B_1_L,	//normal break I lost
+	BOTH_LK_DL_ST_S_B_1_W,	//normal break I won
+	BOTH_LK_DL_ST_S_L_1,	//lock if I'm using dual vs. a staff
+	BOTH_LK_DL_ST_S_SB_1_L,	//super break I lost
+	BOTH_LK_DL_ST_S_SB_1_W,	//super break I won
+	//top locks
+	BOTH_LK_DL_ST_T_B_1_L,	//normal break I lost
+	BOTH_LK_DL_ST_T_B_1_W,	//normal break I won
+	BOTH_LK_DL_ST_T_L_1,	//lock if I'm using dual vs. a staff
+	BOTH_LK_DL_ST_T_SB_1_L,	//super break I lost
+	BOTH_LK_DL_ST_T_SB_1_W,	//super break I won
+//DUAL vs. SINGLE
+	//side locks
+	BOTH_LK_DL_S_S_B_1_L,	//normal break I lost
+	BOTH_LK_DL_S_S_B_1_W,	//normal break I won
+	BOTH_LK_DL_S_S_L_1,		//lock if I'm using dual vs. a single
+	BOTH_LK_DL_S_S_SB_1_L,	//super break I lost
+	BOTH_LK_DL_S_S_SB_1_W,	//super break I won
+	//top locks
+	BOTH_LK_DL_S_T_B_1_L,	//normal break I lost
+	BOTH_LK_DL_S_T_B_1_W,	//normal break I won
+	BOTH_LK_DL_S_T_L_1,		//lock if I'm using dual vs. a single
+	BOTH_LK_DL_S_T_SB_1_L,	//super break I lost
+	BOTH_LK_DL_S_T_SB_1_W,	//super break I won
+//===Saber Staff locks==================================================================
+//STAFF vs. DUAL
+	//side locks
+	BOTH_LK_ST_DL_S_B_1_L,	//normal break I lost
+	BOTH_LK_ST_DL_S_B_1_W,	//normal break I won
+	BOTH_LK_ST_DL_S_L_1,	//lock if I'm using staff vs. dual
+	BOTH_LK_ST_DL_S_SB_1_L,	//super break I lost
+	BOTH_LK_ST_DL_S_SB_1_W,	//super break I won
+	//top locks
+	BOTH_LK_ST_DL_T_B_1_L,	//normal break I lost
+	BOTH_LK_ST_DL_T_B_1_W,	//normal break I won
+	BOTH_LK_ST_DL_T_L_1,	//lock if I'm using staff vs. dual
+	BOTH_LK_ST_DL_T_SB_1_L,	//super break I lost
+	BOTH_LK_ST_DL_T_SB_1_W,	//super break I won
+//STAFF vs. STAFF
+	//side locks
+	BOTH_LK_ST_ST_S_B_1_L,	//normal break I lost
+	BOTH_LK_ST_ST_S_B_1_W,	//normal break I won
+	BOTH_LK_ST_ST_S_L_1,	//lock if I'm using staff vs. a staff and I initiated
+	BOTH_LK_ST_ST_S_SB_1_L,	//super break I lost
+	BOTH_LK_ST_ST_S_SB_1_W,	//super break I won
+	//top locks
+	BOTH_LK_ST_ST_T_B_1_L,	//normal break I lost
+	BOTH_LK_ST_ST_T_B_1_W,	//normal break I won
+	BOTH_LK_ST_ST_T_L_1,	//lock if I'm using staff vs. a staff and I initiated
+	BOTH_LK_ST_ST_T_SB_1_L,	//super break I lost
+	BOTH_LK_ST_ST_T_SB_1_W,	//super break I won
+//STAFF vs. SINGLE
+	//side locks
+	BOTH_LK_ST_S_S_B_1_L,	//normal break I lost
+	BOTH_LK_ST_S_S_B_1_W,	//normal break I won
+	BOTH_LK_ST_S_S_L_1,		//lock if I'm using staff vs. a single
+	BOTH_LK_ST_S_S_SB_1_L,	//super break I lost
+	BOTH_LK_ST_S_S_SB_1_W,	//super break I won
+	//top locks
+	BOTH_LK_ST_S_T_B_1_L,	//normal break I lost
+	BOTH_LK_ST_S_T_B_1_W,	//normal break I won
+	BOTH_LK_ST_S_T_L_1,		//lock if I'm using staff vs. a single
+	BOTH_LK_ST_S_T_SB_1_L,	//super break I lost
+	BOTH_LK_ST_S_T_SB_1_W,	//super break I won
+//Special cases for same saber style vs. each other (won't fit in nice 5-anim size lists above)
+	BOTH_LK_S_S_S_L_2,		//lock if I'm using single vs. a single and other intitiated
+	BOTH_LK_S_S_T_L_2,		//lock if I'm using single vs. a single and other initiated
+	BOTH_LK_DL_DL_S_L_2,	//lock if I'm using dual vs. dual and other initiated
+	BOTH_LK_DL_DL_T_L_2,	//lock if I'm using dual vs. dual and other initiated
+	BOTH_LK_ST_ST_S_L_2,	//lock if I'm using staff vs. a staff and other initiated
+	BOTH_LK_ST_ST_T_L_2,	//lock if I'm using staff vs. a staff and other initiated
+//===End Saber locks==================================================================
+	//old locks
+	BOTH_BF2RETURN,	//#
+	BOTH_BF2BREAK,	//#
+	BOTH_BF2LOCK,	//#
+	BOTH_BF1RETURN,	//#
+	BOTH_BF1BREAK,	//#
+	BOTH_BF1LOCK,	//#
+	BOTH_CWCIRCLE_R2__R_S1,	//#
+	BOTH_CCWCIRCLE_R2__L_S1,	//#
+	BOTH_CWCIRCLE_A2__L__R,	//#
+	BOTH_CCWCIRCLE_A2__R__L,	//#
+	BOTH_CWCIRCLEBREAK,	//#
+	BOTH_CCWCIRCLEBREAK,	//#
+	BOTH_CWCIRCLELOCK,	//#
+	BOTH_CCWCIRCLELOCK,	//#
+	//other saber anims
+	//* #sep BOTH_ SABER MISC ANIMS
+	BOTH_SABERFAST_STANCE,
+	BOTH_SABERSLOW_STANCE,
+	BOTH_SABERDUAL_STANCE,
+	BOTH_SABERSTAFF_STANCE,
+	BOTH_A2_STABBACK1,		//# Stab saber backward
+	BOTH_ATTACK_BACK,		//# Swing around backwards and attack
+	BOTH_JUMPFLIPSLASHDOWN1,//#
+	BOTH_JUMPFLIPSTABDOWN,//#
+	BOTH_FORCELEAP2_T__B_,//#
+	BOTH_LUNGE2_B__T_,//#
+	BOTH_CROUCHATTACKBACK1,//#
+	//New specials for JKA:
+	BOTH_JUMPATTACK6,//#
+	BOTH_JUMPATTACK7,//#
+	BOTH_SPINATTACK6,//#
+	BOTH_SPINATTACK7,//#
+	BOTH_S1_S6,//#	From stand1 to saberdual stance - turning on your dual sabers
+	BOTH_S6_S1,//#	From dualstaff stance to stand1 - turning off your dual sabers
+	BOTH_S1_S7,//#	From stand1 to saberstaff stance - turning on your saberstaff
+	BOTH_S7_S1,//#	From saberstaff stance to stand1 - turning off your saberstaff
+	BOTH_FORCELONGLEAP_START,
+	BOTH_FORCELONGLEAP_ATTACK,
+	BOTH_FORCELONGLEAP_LAND,
+	BOTH_FORCEWALLRUNFLIP_START,
+	BOTH_FORCEWALLRUNFLIP_END,
+	BOTH_FORCEWALLRUNFLIP_ALT,
+	BOTH_FORCEWALLREBOUND_FORWARD,
+	BOTH_FORCEWALLREBOUND_LEFT,
+	BOTH_FORCEWALLREBOUND_BACK,
+	BOTH_FORCEWALLREBOUND_RIGHT,
+	BOTH_FORCEWALLHOLD_FORWARD,
+	BOTH_FORCEWALLHOLD_LEFT,
+	BOTH_FORCEWALLHOLD_BACK,
+	BOTH_FORCEWALLHOLD_RIGHT,
+	BOTH_FORCEWALLRELEASE_FORWARD,
+	BOTH_FORCEWALLRELEASE_LEFT,
+	BOTH_FORCEWALLRELEASE_BACK,
+	BOTH_FORCEWALLRELEASE_RIGHT,
+	BOTH_A7_KICK_F,
+	BOTH_A7_KICK_B,
+	BOTH_A7_KICK_R,
+	BOTH_A7_KICK_L,
+	BOTH_A7_KICK_S,
+	BOTH_A7_KICK_BF,
+	BOTH_A7_KICK_BF_STOP,
+	BOTH_A7_KICK_RL,
+	BOTH_A7_KICK_F_AIR,
+	BOTH_A7_KICK_B_AIR,
+	BOTH_A7_KICK_R_AIR,
+	BOTH_A7_KICK_L_AIR,
+	BOTH_FLIP_ATTACK7,
+	BOTH_FLIP_HOLD7,
+	BOTH_FLIP_LAND,
+	BOTH_PULL_IMPALE_STAB,
+	BOTH_PULL_IMPALE_SWING,
+	BOTH_PULLED_INAIR_B,
+	BOTH_PULLED_INAIR_F,
+	BOTH_STABDOWN,
+	BOTH_STABDOWN_STAFF,
+	BOTH_STABDOWN_DUAL,
+	BOTH_A6_SABERPROTECT,
+	BOTH_A7_SOULCAL,
+	BOTH_A1_SPECIAL,
+	BOTH_A2_SPECIAL,
+	BOTH_A3_SPECIAL,
+	BOTH_ROLL_STAB,
+
+	//# #sep BOTH_ STANDING
+	BOTH_STAND1,			//# Standing idle, no weapon, hands down
+	BOTH_STAND1IDLE1,		//# Random standing idle
+	BOTH_STAND2,			//# Standing idle with a saber
+	BOTH_STAND2IDLE1,		//# Random standing idle
+	BOTH_STAND2IDLE2,		//# Random standing idle
+	BOTH_STAND3,			//# Standing idle with 2-handed weapon
+	BOTH_STAND3IDLE1,		//# Random standing idle
+	BOTH_STAND4,			//# hands clasp behind back
+	BOTH_STAND5,			//# standing idle, no weapon, hand down, back straight
+	BOTH_STAND5IDLE1,		//# Random standing idle
+	BOTH_STAND6,			//# one handed, gun at side, relaxed stand
+	BOTH_STAND8,			//# both hands on hips (male)
+	BOTH_STAND1TO2,			//# Transition from stand1 to stand2
+	BOTH_STAND2TO1,			//# Transition from stand2 to stand1
+	BOTH_STAND2TO4,			//# Transition from stand2 to stand4
+	BOTH_STAND4TO2,			//# Transition from stand4 to stand2
+	BOTH_STAND4TOATTACK2,	//# relaxed stand to 1-handed pistol ready
+	BOTH_STANDUP2,			//# Luke standing up from his meditation platform (cin # 37)
+	BOTH_STAND5TOSIT3,		//# transition from stand 5 to sit 3
+	BOTH_STAND1TOSTAND5,	//# Transition from stand1 to stand5
+	BOTH_STAND5TOSTAND1,	//# Transition from stand5 to stand1
+	BOTH_STAND5TOAIM,		//# Transition of Kye aiming his gun at Desann (cin #9) 
+	BOTH_STAND5STARTLEDLOOKLEFT,	//# Kyle turning to watch the bridge drop (cin #9) 
+	BOTH_STARTLEDLOOKLEFTTOSTAND5,	//# Kyle returning to stand 5 from watching the bridge drop (cin #9) 
+	BOTH_STAND5TOSTAND8,	//# Transition from stand5 to stand8
+	BOTH_STAND7TOSTAND8,	//# Tavion putting hands on back of chair (cin #11)
+	BOTH_STAND8TOSTAND5,	//# Transition from stand8 to stand5
+	BOTH_STAND9,			//# Kyle's standing idle, no weapon, hands down
+	BOTH_STAND9IDLE1,		//# Kyle's random standing idle
+	BOTH_STAND5SHIFTWEIGHT,	//# Weightshift from stand5 to side and back to stand5
+	BOTH_STAND5SHIFTWEIGHTSTART,	//# From stand5 to side
+	BOTH_STAND5SHIFTWEIGHTSTOP,		//# From side to stand5
+	BOTH_STAND5TURNLEFTSTART,		//# Start turning left from stand5
+	BOTH_STAND5TURNLEFTSTOP,		//# Stop turning left from stand5
+	BOTH_STAND5TURNRIGHTSTART,		//# Start turning right from stand5
+	BOTH_STAND5TURNRIGHTSTOP,		//# Stop turning right from stand5
+	BOTH_STAND5LOOK180LEFTSTART,	//# Start looking over left shoulder (cin #17)
+	BOTH_STAND5LOOK180LEFTSTOP,	//# Stop looking over left shoulder (cin #17)
+
+	BOTH_CONSOLE1START,		//# typing at a console
+	BOTH_CONSOLE1,			//# typing at a console
+	BOTH_CONSOLE1STOP,		//# typing at a console
+	BOTH_CONSOLE2START,		//# typing at a console with comm link in hand (cin #5) 
+	BOTH_CONSOLE2,			//# typing at a console with comm link in hand (cin #5) 
+	BOTH_CONSOLE2STOP,		//# typing at a console with comm link in hand (cin #5) 
+	BOTH_CONSOLE2HOLDCOMSTART,	//# lean in to type at console while holding comm link in hand (cin #5) 
+	BOTH_CONSOLE2HOLDCOMSTOP,	//# lean away after typing at console while holding comm link in hand (cin #5) 
+
+	BOTH_GUARD_LOOKAROUND1,	//# Cradling weapon and looking around
+	BOTH_GUARD_IDLE1,		//# Cradling weapon and standing
+	BOTH_GESTURE1,			//# Generic gesture, non-specific
+	BOTH_GESTURE2,			//# Generic gesture, non-specific
+	BOTH_WALK1TALKCOMM1,	//# Talking into coom link while walking
+	BOTH_TALK1,				//# Generic talk anim
+	BOTH_TALK2,				//# Generic talk anim
+	BOTH_TALKCOMM1START,	//# Start talking into a comm link
+	BOTH_TALKCOMM1,			//# Talking into a comm link
+	BOTH_TALKCOMM1STOP,		//# Stop talking into a comm link
+	BOTH_TALKGESTURE1,		//# Generic talk anim
+	
+	BOTH_HEADTILTLSTART,		//# Head tilt to left
+	BOTH_HEADTILTLSTOP,			//# Head tilt to left
+	BOTH_HEADTILTRSTART,		//# Head tilt to right
+	BOTH_HEADTILTRSTOP,			//# Head tilt to right
+	BOTH_HEADNOD,				//# Head shake YES
+	BOTH_HEADSHAKE,				//# Head shake NO
+	BOTH_SIT2HEADTILTLSTART,	//# Head tilt to left from seated position 2
+	BOTH_SIT2HEADTILTLSTOP,		//# Head tilt to left from seated position 2
+ 
+	BOTH_REACH1START,		//# Monmothma reaching for crystal
+	BOTH_REACH1STOP,		//# Monmothma reaching for crystal
+
+	BOTH_COME_ON1,				//# Jan gesturing to Kyle (cin #32a)
+	BOTH_STEADYSELF1,			//# Jan trying to keep footing (cin #32a)
+	BOTH_STEADYSELF1END,		//# Return hands to side from STEADSELF1 Kyle (cin#5)
+	BOTH_SILENCEGESTURE1,		//# Luke silencing Kyle with a raised hand (cin #37)
+	BOTH_REACHFORSABER1,		//# Luke holding hand out for Kyle's saber (cin #37)
+	BOTH_SABERKILLER1,			//# Tavion about to strike Jan with saber (cin #9)
+	BOTH_SABERKILLEE1,			//# Jan about to be struck by Tavion with saber (cin #9)
+	BOTH_HUGGER1,			//# Kyle hugging Jan (cin #29)
+	BOTH_HUGGERSTOP1,		//# Kyle stop hugging Jan but don't let her go (cin #29)
+	BOTH_HUGGEE1,			//# Jan being hugged (cin #29)
+	BOTH_HUGGEESTOP1,		//# Jan stop being hugged but don't let go (cin #29)
+
+	BOTH_SABERTHROW1START,		//# Desann throwing his light saber (cin #26)
+	BOTH_SABERTHROW1STOP,		//# Desann throwing his light saber (cin #26)
+	BOTH_SABERTHROW2START,		//# Kyle throwing his light saber (cin #32)
+	BOTH_SABERTHROW2STOP,		//# Kyle throwing his light saber (cin #32)
+
+	//# #sep BOTH_ SITTING/CROUCHING
+	BOTH_SIT1,				//# Normal chair sit.
+	BOTH_SIT2,				//# Lotus position.
+	BOTH_SIT3,				//# Sitting in tired position, elbows on knees
+
+	BOTH_SIT2TOSTAND5,		//# Transition from sit 2 to stand 5
+	BOTH_STAND5TOSIT2,		//# Transition from stand 5 to sit 2
+	BOTH_SIT2TOSIT4,		//# Trans from sit2 to sit4 (cin #12) Luke leaning back from lotus position.
+	BOTH_SIT3TOSTAND5,		//# transition from sit 3 to stand 5
+
+	BOTH_CROUCH1,			//# Transition from standing to crouch
+	BOTH_CROUCH1IDLE,		//# Crouching idle
+	BOTH_CROUCH1WALK,		//# Walking while crouched
+	BOTH_CROUCH1WALKBACK,	//# Walking while crouched
+	BOTH_UNCROUCH1,			//# Transition from crouch to standing
+	BOTH_CROUCH2TOSTAND1,	//# going from crouch2 to stand1
+	BOTH_CROUCH3,			//# Desann crouching down to Kyle (cin 9)
+	BOTH_UNCROUCH3,			//# Desann uncrouching down to Kyle (cin 9)
+	BOTH_CROUCH4,			//# Slower version of crouch1 for cinematics
+	BOTH_UNCROUCH4,			//# Slower version of uncrouch1 for cinematics
+
+	BOTH_GUNSIT1,			//# sitting on an emplaced gun.
+
+	// Swoop Vehicle animations.
+	//* #sep BOTH_ SWOOP ANIMS
+	BOTH_VS_MOUNT_L,			//# Mount from left		
+	BOTH_VS_DISMOUNT_L,			//# Dismount to left		
+	BOTH_VS_MOUNT_R,			//# Mount from  right (symmetry)		
+	BOTH_VS_DISMOUNT_R,			//# DISMOUNT TO  RIGHT (SYMMETRY)		
+
+	BOTH_VS_MOUNTJUMP_L,		//#
+	BOTH_VS_MOUNTTHROW,			//# Land on an occupied vehicle & throw off current pilot
+	BOTH_VS_MOUNTTHROW_L,		//# Land on an occupied vehicle & throw off current pilot
+	BOTH_VS_MOUNTTHROW_R,		//# Land on an occupied vehicle & throw off current pilot
+	BOTH_VS_MOUNTTHROWEE,		//# Current pilot getting thrown off by another guy
+
+	BOTH_VS_LOOKLEFT,			//# Turn & Look behind and to the left (no weapon)		
+	BOTH_VS_LOOKRIGHT,			//# Turn & Look behind and to the right (no weapon)		
+
+	BOTH_VS_TURBO,				//# Hit The Turbo Button
+
+	BOTH_VS_REV,				//# Player looks back as swoop reverses		
+
+	BOTH_VS_AIR,				//# Player stands up when swoop is airborn		
+	BOTH_VS_AIR_G,				//# "" with Gun
+	BOTH_VS_AIR_SL,				//# "" with Saber Left
+	BOTH_VS_AIR_SR,				//# "" with Saber Right
+
+	BOTH_VS_LAND,				//# Player bounces down when swoop lands		
+	BOTH_VS_LAND_G,				//#  "" with Gun
+	BOTH_VS_LAND_SL,			//#  "" with Saber Left
+	BOTH_VS_LAND_SR,			//#  "" with Saber Right
+
+	BOTH_VS_IDLE,				//# Sit
+	BOTH_VS_IDLE_G,				//# Sit (gun)
+	BOTH_VS_IDLE_SL,			//# Sit (saber left)		
+	BOTH_VS_IDLE_SR,			//# Sit (saber right)		
+
+	BOTH_VS_LEANL,				//# Lean left
+	BOTH_VS_LEANL_G,			//# Lean left (gun)		
+	BOTH_VS_LEANL_SL,			//# Lean left (saber left)		
+	BOTH_VS_LEANL_SR,			//# Lean left (saber right)		
+
+	BOTH_VS_LEANR,				//# Lean right		
+	BOTH_VS_LEANR_G,			//# Lean right (gun)		
+	BOTH_VS_LEANR_SL,			//# Lean right (saber left)		
+	BOTH_VS_LEANR_SR,			//# Lean right (saber right)		
+				
+	BOTH_VS_ATL_S,				//# Attack left with saber		
+	BOTH_VS_ATR_S,				//# Attack right with saber		
+	BOTH_VS_ATR_TO_L_S,			//# Attack toss saber from right to left hand
+	BOTH_VS_ATL_TO_R_S,			//# Attack toss saber from left to right hand
+	BOTH_VS_ATR_G,				//# Attack right with gun (90)		
+	BOTH_VS_ATL_G,				//# Attack left with gun (90)		
+	BOTH_VS_ATF_G,				//# Attack forward with gun		
+
+	BOTH_VS_PAIN1,				//# Pain
+
+	// Added 12/04/02 by Aurelio.
+	//* #sep BOTH_ TAUNTAUN ANIMS
+	BOTH_VT_MOUNT_L,		//# Mount from left	
+	BOTH_VT_MOUNT_R,		//# Mount from right
+	BOTH_VT_MOUNT_B,		//# Mount from air, behind
+	BOTH_VT_DISMOUNT,		//# Dismount for tauntaun
+	BOTH_VT_DISMOUNT_L,		//# Dismount to tauntauns left	
+	BOTH_VT_DISMOUNT_R,		//# Dismount to tauntauns right (symmetry)	
+
+	BOTH_VT_WALK_FWD,		//# Walk forward	
+	BOTH_VT_WALK_REV,		//# Walk backward	
+	BOTH_VT_WALK_FWD_L,		//# walk lean left
+	BOTH_VT_WALK_FWD_R,		//# Walk lean right
+	BOTH_VT_RUN_FWD,		//# Run forward	
+	BOTH_VT_RUN_REV,		//# Look backwards while running (not weapon specific)	
+	BOTH_VT_RUN_FWD_L,		//# Run lean left
+	BOTH_VT_RUN_FWD_R,		//# Run lean right
+
+	BOTH_VT_SLIDEF,			//# Tauntaun slides forward with abrupt stop	
+	BOTH_VT_AIR,			//# Tauntaun jump	
+	BOTH_VT_ATB,			//# Tauntaun tail swipe	
+	BOTH_VT_PAIN1,			//# Pain	
+	BOTH_VT_DEATH1,			//# Die	
+	BOTH_VT_STAND,			//# Stand still and breath	
+	BOTH_VT_BUCK,			//# Tauntaun bucking loop animation	
+
+	BOTH_VT_LAND,			//# Player bounces down when tauntaun lands	
+	BOTH_VT_TURBO,			//# Hit The Turbo Button
+	BOTH_VT_IDLE_SL,		//# Sit (saber left)		
+	BOTH_VT_IDLE_SR,		//# Sit (saber right)		
+
+	BOTH_VT_IDLE,			//# Sit with no weapon selected	
+	BOTH_VT_IDLE1,			//# Sit with no weapon selected	
+	BOTH_VT_IDLE_S,			//# Sit with saber selected	
+	BOTH_VT_IDLE_G,			//# Sit with gun selected	
+	BOTH_VT_IDLE_T,			//# Sit with thermal grenade selected
+
+	BOTH_VT_ATL_S,			//# Attack left with saber	
+	BOTH_VT_ATR_S,			//# Attack right with saber	
+	BOTH_VT_ATR_TO_L_S,		//# Attack toss saber from right to left hand
+	BOTH_VT_ATL_TO_R_S,		//# Attack toss saber from left to right hand
+	BOTH_VT_ATR_G,			//# Attack right with gun (90)	
+	BOTH_VT_ATL_G,			//# Attack left with gun (90)	
+	BOTH_VT_ATF_G,			//# Attack forward with gun	
+
+
+	// Added 2/26/02 by Aurelio.
+	//* #sep BOTH_ FIGHTER ANIMS
+	BOTH_GEARS_OPEN,
+	BOTH_GEARS_CLOSE,
+	BOTH_WINGS_OPEN,
+	BOTH_WINGS_CLOSE,
+
+	BOTH_DEATH14_UNGRIP,	//# Desann's end death (cin #35)
+	BOTH_DEATH14_SITUP,		//# Tavion sitting up after having been thrown (cin #23)
+	BOTH_KNEES1,			//# Tavion on her knees
+	BOTH_KNEES2,			//# Tavion on her knees looking down
+	BOTH_KNEES2TO1,			//# Transition of KNEES2 to KNEES1
+
+	//# #sep BOTH_ MOVING
+	BOTH_WALK1,				//# Normal walk
+	BOTH_WALK2,				//# Normal walk
+	BOTH_WALK_STAFF,		//# Walk with saberstaff turned on
+	BOTH_WALKBACK_STAFF,	//# Walk backwards with saberstaff turned on
+	BOTH_WALK_DUAL,			//# Walk with dual turned on
+	BOTH_WALKBACK_DUAL,		//# Walk backwards with dual turned on
+	BOTH_WALK5,				//# Tavion taunting Kyle (cin 22)
+	BOTH_WALK6,				//# Slow walk for Luke (cin 12)
+	BOTH_WALK7,				//# Fast walk
+	BOTH_RUN1,				//# Full run
+	BOTH_RUN1START,			//# Start into full run1
+	BOTH_RUN1STOP,			//# Stop from full run1
+	BOTH_RUN2,				//# Full run
+	BOTH_RUN1TORUN2,		//# Wampa run anim transition
+	BOTH_RUN2TORUN1,		//# Wampa run anim transition
+	BOTH_RUN4,				//# Jawa Run
+	BOTH_RUN_STAFF,			//# Run with saberstaff turned on
+	BOTH_RUNBACK_STAFF,		//# Run backwards with saberstaff turned on
+	BOTH_RUN_DUAL,			//# Run with dual turned on
+	BOTH_RUNBACK_DUAL,		//# Run backwards with dual turned on
+	BOTH_STRAFE_LEFT1,		//# Sidestep left, should loop
+	BOTH_STRAFE_RIGHT1,		//# Sidestep right, should loop
+	BOTH_RUNSTRAFE_LEFT1,	//# Sidestep left, should loop
+	BOTH_RUNSTRAFE_RIGHT1,	//# Sidestep right, should loop
+	BOTH_TURN_LEFT1,		//# Turn left, should loop
+	BOTH_TURN_RIGHT1,		//# Turn right, should loop
+	BOTH_TURNSTAND1,		//# Turn from STAND1 position
+	BOTH_TURNSTAND2,		//# Turn from STAND2 position
+	BOTH_TURNSTAND3,		//# Turn from STAND3 position
+	BOTH_TURNSTAND4,		//# Turn from STAND4 position
+	BOTH_TURNSTAND5,		//# Turn from STAND5 position
+	BOTH_TURNCROUCH1,		//# Turn from CROUCH1 position
+
+	BOTH_WALKBACK1,			//# Walk1 backwards
+	BOTH_WALKBACK2,			//# Walk2 backwards
+	BOTH_RUNBACK1,			//# Run1 backwards
+	BOTH_RUNBACK2,			//# Run1 backwards
+	
+	//# #sep BOTH_ JUMPING
+	BOTH_JUMP1,				//# Jump - wind-up and leave ground
+	BOTH_INAIR1,			//# In air loop (from jump)
+	BOTH_LAND1,				//# Landing (from in air loop)
+	BOTH_LAND2,				//# Landing Hard (from a great height)
+
+	BOTH_JUMPBACK1,			//# Jump backwards - wind-up and leave ground
+	BOTH_INAIRBACK1,		//# In air loop (from jump back)
+	BOTH_LANDBACK1,			//# Landing backwards(from in air loop)
+
+	BOTH_JUMPLEFT1,			//# Jump left - wind-up and leave ground
+	BOTH_INAIRLEFT1,		//# In air loop (from jump left)
+	BOTH_LANDLEFT1,			//# Landing left(from in air loop)
+
+	BOTH_JUMPRIGHT1,		//# Jump right - wind-up and leave ground
+	BOTH_INAIRRIGHT1,		//# In air loop (from jump right)
+	BOTH_LANDRIGHT1,		//# Landing right(from in air loop)
+
+	BOTH_FORCEJUMP1,		//# Jump - wind-up and leave ground
+	BOTH_FORCEINAIR1,		//# In air loop (from jump)
+	BOTH_FORCELAND1,		//# Landing (from in air loop)
+
+	BOTH_FORCEJUMPBACK1,	//# Jump backwards - wind-up and leave ground
+	BOTH_FORCEINAIRBACK1,	//# In air loop (from jump back)
+	BOTH_FORCELANDBACK1,	//# Landing backwards(from in air loop)
+
+	BOTH_FORCEJUMPLEFT1,	//# Jump left - wind-up and leave ground
+	BOTH_FORCEINAIRLEFT1,	//# In air loop (from jump left)
+	BOTH_FORCELANDLEFT1,	//# Landing left(from in air loop)
+
+	BOTH_FORCEJUMPRIGHT1,	//# Jump right - wind-up and leave ground
+	BOTH_FORCEINAIRRIGHT1,	//# In air loop (from jump right)
+	BOTH_FORCELANDRIGHT1,	//# Landing right(from in air loop)
+	//# #sep BOTH_ ACROBATICS
+	BOTH_FLIP_F,			//# Flip forward
+	BOTH_FLIP_B,			//# Flip backwards
+	BOTH_FLIP_L,			//# Flip left
+	BOTH_FLIP_R,			//# Flip right
+
+	BOTH_ROLL_F,			//# Roll forward
+	BOTH_ROLL_B,			//# Roll backward
+	BOTH_ROLL_L,			//# Roll left
+	BOTH_ROLL_R,			//# Roll right
+
+	BOTH_HOP_F,				//# quickstep forward
+	BOTH_HOP_B,				//# quickstep backwards
+	BOTH_HOP_L,				//# quickstep left
+	BOTH_HOP_R,				//# quickstep right
+
+	BOTH_DODGE_FL,			//# lean-dodge forward left
+	BOTH_DODGE_FR,			//# lean-dodge forward right
+	BOTH_DODGE_BL,			//# lean-dodge backwards left
+	BOTH_DODGE_BR,			//# lean-dodge backwards right
+	BOTH_DODGE_L,			//# lean-dodge left
+	BOTH_DODGE_R,			//# lean-dodge right
+	BOTH_DODGE_HOLD_FL,			//# lean-dodge pose forward left
+	BOTH_DODGE_HOLD_FR,			//# lean-dodge pose forward right
+	BOTH_DODGE_HOLD_BL,			//# lean-dodge pose backwards left
+	BOTH_DODGE_HOLD_BR,			//# lean-dodge pose backwards right
+	BOTH_DODGE_HOLD_L,			//# lean-dodge pose left
+	BOTH_DODGE_HOLD_R,			//# lean-dodge pose right
+
+	//MP taunt anims
+	BOTH_ENGAGETAUNT,
+	BOTH_BOW,
+	BOTH_MEDITATE,
+	BOTH_MEDITATE_END,
+	BOTH_SHOWOFF_FAST,
+	BOTH_SHOWOFF_MEDIUM,
+	BOTH_SHOWOFF_STRONG,
+	BOTH_SHOWOFF_DUAL,
+	BOTH_SHOWOFF_STAFF,
+	BOTH_VICTORY_FAST,
+	BOTH_VICTORY_MEDIUM,
+	BOTH_VICTORY_STRONG,
+	BOTH_VICTORY_DUAL,
+	BOTH_VICTORY_STAFF,
+	//other saber/acro anims
+	BOTH_ARIAL_LEFT,		//# 
+	BOTH_ARIAL_RIGHT,		//# 
+	BOTH_CARTWHEEL_LEFT,	//# 
+	BOTH_CARTWHEEL_RIGHT,	//# 
+	BOTH_FLIP_LEFT,			//# 
+	BOTH_FLIP_BACK1,		//# 
+	BOTH_FLIP_BACK2,		//# 
+	BOTH_FLIP_BACK3,		//# 
+	BOTH_BUTTERFLY_LEFT,	//# 
+	BOTH_BUTTERFLY_RIGHT,	//# 
+	BOTH_WALL_RUN_RIGHT,	//# 
+	BOTH_WALL_RUN_RIGHT_FLIP,//#
+	BOTH_WALL_RUN_RIGHT_STOP,//# 
+	BOTH_WALL_RUN_LEFT,		//# 
+	BOTH_WALL_RUN_LEFT_FLIP,//#
+	BOTH_WALL_RUN_LEFT_STOP,//# 
+	BOTH_WALL_FLIP_RIGHT,	//# 
+	BOTH_WALL_FLIP_LEFT,	//# 
+	BOTH_KNOCKDOWN1,		//# knocked backwards
+	BOTH_KNOCKDOWN2,		//# knocked backwards hard
+	BOTH_KNOCKDOWN3,		//#	knocked forwards
+	BOTH_KNOCKDOWN4,		//# knocked backwards from crouch
+	BOTH_KNOCKDOWN5,		//# dupe of 3 - will be removed
+	BOTH_GETUP1,			//#
+	BOTH_GETUP2,			//#
+	BOTH_GETUP3,			//#
+	BOTH_GETUP4,			//#
+	BOTH_GETUP5,			//#
+	BOTH_GETUP_CROUCH_F1,	//#
+	BOTH_GETUP_CROUCH_B1,	//#
+	BOTH_FORCE_GETUP_F1,	//#
+	BOTH_FORCE_GETUP_F2,	//#
+	BOTH_FORCE_GETUP_B1,	//#
+	BOTH_FORCE_GETUP_B2,	//#
+	BOTH_FORCE_GETUP_B3,	//#
+	BOTH_FORCE_GETUP_B4,	//#
+	BOTH_FORCE_GETUP_B5,	//#
+	BOTH_FORCE_GETUP_B6,	//#
+	BOTH_GETUP_BROLL_B,	//#
+	BOTH_GETUP_BROLL_F,	//#
+	BOTH_GETUP_BROLL_L,	//#
+	BOTH_GETUP_BROLL_R,	//#
+	BOTH_GETUP_FROLL_B,	//#
+	BOTH_GETUP_FROLL_F,	//#
+	BOTH_GETUP_FROLL_L,	//#
+	BOTH_GETUP_FROLL_R,	//#
+	BOTH_WALL_FLIP_BACK1,	//#
+	BOTH_WALL_FLIP_BACK2,	//#
+	BOTH_SPIN1,				//#
+	BOTH_CEILING_CLING,		//# clinging to ceiling
+	BOTH_CEILING_DROP,		//# dropping from ceiling cling
+
+	//TESTING
+	BOTH_FJSS_TR_BL,		//# jump spin slash tr to bl
+	BOTH_FJSS_TL_BR,		//# jump spin slash bl to tr
+	BOTH_RIGHTHANDCHOPPEDOFF,//#
+	BOTH_DEFLECTSLASH__R__L_FIN,//#
+	BOTH_BASHED1,//#
+	BOTH_ARIAL_F1,//#
+	BOTH_BUTTERFLY_FR1,//#
+	BOTH_BUTTERFLY_FL1,//#
+
+	//NEW SABER/JEDI/FORCE ANIMS
+	BOTH_BACK_FLIP_UP,	//# back flip up Bonus Animation!!!!	
+	BOTH_LOSE_SABER,	//# player losing saber (pulled from hand by force pull 4 - Kyle?)
+	BOTH_STAFF_TAUNT,	//# taunt saberstaff			
+	BOTH_DUAL_TAUNT,		//# taunt dual
+	BOTH_A6_FB,				//# dual attack front/back		
+	BOTH_A6_LR,				//# dual attack left/right
+	BOTH_A7_HILT,			//# saber knock (alt + stand still)
+	//Alora			
+	BOTH_ALORA_SPIN,		//#jump spin attack	death ballet	
+	BOTH_ALORA_FLIP_1,		//# gymnast move 1		
+	BOTH_ALORA_FLIP_2,		//# gymnast move 2		
+	BOTH_ALORA_FLIP_3,		//# gymnast move3		
+	BOTH_ALORA_FLIP_B,		//# gymnast move back		
+	BOTH_ALORA_SPIN_THROW,	//# dual saber throw		
+	BOTH_ALORA_SPIN_SLASH,	//# spin slash	special bonus animation!! :)	
+	BOTH_ALORA_TAUNT,		//# special taunt
+	//Rosh (Kothos battle)			
+	BOTH_ROSH_PAIN,	//# hurt animation (exhausted)		
+	BOTH_ROSH_HEAL,	//# healed/rejuvenated		
+	//Tavion			
+	BOTH_TAVION_SCEPTERGROUND, //# stabbing ground with sith sword shoots electricity everywhere
+	BOTH_TAVION_SWORDPOWER,//# Tavion doing the He-Man(tm) thing
+	BOTH_SCEPTER_START,	//#Point scepter and attack start
+	BOTH_SCEPTER_HOLD,	//#Point scepter and attack hold
+	BOTH_SCEPTER_STOP,	//#Point scepter and attack stop
+	//Kyle Boss			
+	BOTH_KYLE_GRAB,		//# grab
+	BOTH_KYLE_MISS,		//# miss
+	BOTH_KYLE_PA_1,		//# hold 1
+	BOTH_PLAYER_PA_1,	//# player getting held 1
+	BOTH_KYLE_PA_2,		//# hold 2
+	BOTH_PLAYER_PA_2,	//# player getting held 2
+	BOTH_PLAYER_PA_FLY,	//# player getting knocked back from punch at end of hold 1
+	BOTH_KYLE_PA_3,		//# hold 3
+	BOTH_PLAYER_PA_3,	//# player getting held 3
+	BOTH_PLAYER_PA_3_FLY,//# player getting thrown at end of hold 3
+	//Rancor
+	BOTH_BUCK_RIDER,	//# Rancor bucks when someone is on him
+	//WAMPA Grabbing enemy
+	BOTH_HOLD_START,	//#
+	BOTH_HOLD_MISS,	//#
+	BOTH_HOLD_IDLE,	//#
+	BOTH_HOLD_END,	//#
+	BOTH_HOLD_ATTACK,	//#
+	BOTH_HOLD_SNIFF,	//# Sniff the guy you're holding
+	BOTH_HOLD_DROP,		//# just drop 'em
+	//BEING GRABBED BY WAMPA
+	BOTH_GRABBED,	//#
+	BOTH_RELEASED,	//#
+	BOTH_HANG_IDLE,	//#
+	BOTH_HANG_ATTACK,	//#
+	BOTH_HANG_PAIN,	//#
+
+	//# #sep BOTH_ MISC MOVEMENT
+	BOTH_HIT1,				//# Kyle hit by crate in cin #9
+	BOTH_LADDER_UP1,		//# Climbing up a ladder with rungs at 16 unit intervals
+	BOTH_LADDER_DWN1,		//# Climbing down a ladder with rungs at 16 unit intervals
+	BOTH_LADDER_IDLE,		//#	Just sitting on the ladder
+
+	//# #sep BOTH_ FLYING IDLE
+	BOTH_FLY_SHIELDED,		//# For sentry droid, shields in
+
+	//# #sep BOTH_ SWIMMING
+	BOTH_SWIM_IDLE1,		//# Swimming Idle 1
+	BOTH_SWIMFORWARD,		//# Swim forward loop
+	BOTH_SWIMBACKWARD,		//# Swim backward loop
+
+	//# #sep BOTH_ LYING
+	BOTH_SLEEP1,			//# laying on back-rknee up-rhand on torso
+	BOTH_SLEEP6START,		//# Kyle leaning back to sleep (cin 20)
+	BOTH_SLEEP6STOP,		//# Kyle waking up and shaking his head (cin 21)
+	BOTH_SLEEP1GETUP,		//# alarmed and getting up out of sleep1 pose to stand
+	BOTH_SLEEP1GETUP2,		//# 
+
+	BOTH_CHOKE1START,		//# tavion in force grip choke
+	BOTH_CHOKE1STARTHOLD,	//# loop of tavion in force grip choke
+	BOTH_CHOKE1,			//# tavion in force grip choke
+
+	BOTH_CHOKE2,			//# tavion recovering from force grip choke
+	BOTH_CHOKE3,			//# left-handed choke (for people still holding a weapon)
+
+	//# #sep BOTH_ HUNTER-SEEKER BOT-SPECIFIC
+	BOTH_POWERUP1,			//# Wakes up
+
+	BOTH_TURNON,			//# Protocol Droid wakes up
+	BOTH_TURNOFF,			//# Protocol Droid shuts off
+
+	BOTH_BUTTON1,			//# Single button push with right hand
+	BOTH_BUTTON2,			//# Single button push with left finger
+	BOTH_BUTTON_HOLD,		//# Single button hold with left hand
+	BOTH_BUTTON_RELEASE,	//# Single button release with left hand
+
+	//# JEDI-SPECIFIC
+	//# #sep BOTH_ FORCE ANIMS
+	BOTH_RESISTPUSH,		//# plant yourself to resist force push/pulls.
+	BOTH_FORCEPUSH,			//# Use off-hand to do force power.
+	BOTH_FORCEPULL,			//# Use off-hand to do force power.
+	BOTH_MINDTRICK1,			//# Use off-hand to do mind trick
+	BOTH_MINDTRICK2,			//# Use off-hand to do distraction
+	BOTH_FORCELIGHTNING,		//# Use off-hand to do lightning
+	BOTH_FORCELIGHTNING_START,	//# Use off-hand to do lightning - start
+	BOTH_FORCELIGHTNING_HOLD,	//# Use off-hand to do lightning - hold
+	BOTH_FORCELIGHTNING_RELEASE,//# Use off-hand to do lightning - release
+	BOTH_FORCEHEAL_START,		//# Healing meditation pose start
+	BOTH_FORCEHEAL_STOP,		//# Healing meditation pose end
+	BOTH_FORCEHEAL_QUICK,		//# Healing meditation gesture
+	BOTH_SABERPULL,			//# Use off-hand to do force power.
+	BOTH_FORCEGRIP1,		//# force-gripping (no anim?)
+	BOTH_FORCEGRIP3,		//# force-gripping (right hand)
+	BOTH_FORCEGRIP3THROW,	//# throwing while force-gripping (right hand)
+	BOTH_FORCEGRIP_HOLD,	//# Use off-hand to do grip - hold
+	BOTH_FORCEGRIP_RELEASE,//# Use off-hand to do grip - release
+	BOTH_TOSS1,				//# throwing to left after force gripping
+	BOTH_TOSS2,				//# throwing to right after force gripping
+	//NEW force anims for JKA:
+	BOTH_FORCE_RAGE,
+	BOTH_FORCE_2HANDEDLIGHTNING,
+	BOTH_FORCE_2HANDEDLIGHTNING_START,
+	BOTH_FORCE_2HANDEDLIGHTNING_HOLD,
+	BOTH_FORCE_2HANDEDLIGHTNING_RELEASE,
+	BOTH_FORCE_DRAIN,
+	BOTH_FORCE_DRAIN_START,
+	BOTH_FORCE_DRAIN_HOLD,
+	BOTH_FORCE_DRAIN_RELEASE,
+	BOTH_FORCE_DRAIN_GRAB_START,
+	BOTH_FORCE_DRAIN_GRAB_HOLD,
+	BOTH_FORCE_DRAIN_GRAB_END,
+	BOTH_FORCE_DRAIN_GRABBED,
+	BOTH_FORCE_ABSORB,
+	BOTH_FORCE_ABSORB_START,
+	BOTH_FORCE_ABSORB_END,
+	BOTH_FORCE_PROTECT,
+	BOTH_FORCE_PROTECT_FAST,
+
+	BOTH_WIND,
+
+	BOTH_STAND_TO_KNEEL,
+	BOTH_KNEEL_TO_STAND,
+
+	BOTH_TUSKENATTACK1,
+	BOTH_TUSKENATTACK2,
+	BOTH_TUSKENATTACK3,
+	BOTH_TUSKENLUNGE1,
+	BOTH_TUSKENTAUNT1,
+
+	BOTH_COWER1_START,		//# cower start
+	BOTH_COWER1,			//# cower loop
+	BOTH_COWER1_STOP,		//# cower stop
+	BOTH_SONICPAIN_START,
+	BOTH_SONICPAIN_HOLD,
+	BOTH_SONICPAIN_END,
+
+	//new anim slots per Jarrod's request
+	BOTH_STAND10,
+	BOTH_STAND10_TALK1,
+	BOTH_STAND10_TALK2,
+	BOTH_STAND10TOSTAND1,
+
+	BOTH_STAND1_TALK1,
+	BOTH_STAND1_TALK2,
+	BOTH_STAND1_TALK3,
+
+	BOTH_SIT4,
+	BOTH_SIT5,
+	BOTH_SIT5_TALK1,
+	BOTH_SIT5_TALK2,
+	BOTH_SIT5_TALK3,
+
+	BOTH_SIT6,
+	BOTH_SIT7,
+
+	//=================================================
+	//ANIMS IN WHICH ONLY THE UPPER OBJECTS ARE IN MD3
+	//=================================================
+	//# #sep TORSO_ WEAPON-RELATED
+	TORSO_DROPWEAP1,		//# Put weapon away
+	TORSO_DROPWEAP4,		//# Put weapon away
+	TORSO_RAISEWEAP1,		//# Draw Weapon
+	TORSO_RAISEWEAP4,		//# Draw Weapon
+	TORSO_WEAPONREADY1,		//# Ready to fire stun baton
+	TORSO_WEAPONREADY2,		//# Ready to fire one-handed blaster pistol
+	TORSO_WEAPONREADY3,		//# Ready to fire blaster rifle
+	TORSO_WEAPONREADY4,		//# Ready to fire sniper rifle
+	TORSO_WEAPONREADY10,	//# Ready to fire thermal det
+	TORSO_WEAPONIDLE2,		//# Holding one-handed blaster
+	TORSO_WEAPONIDLE3,		//# Holding blaster rifle
+	TORSO_WEAPONIDLE4,		//# Holding sniper rifle
+	TORSO_WEAPONIDLE10,		//# Holding thermal det
+
+	//# #sep TORSO_ MISC
+	TORSO_SURRENDER_START,	//# arms up
+	TORSO_SURRENDER_STOP,	//# arms back down
+
+	TORSO_CHOKING1,			//# TEMP
+
+	TORSO_HANDSIGNAL1,
+	TORSO_HANDSIGNAL2,
+	TORSO_HANDSIGNAL3,
+	TORSO_HANDSIGNAL4,
+	TORSO_HANDSIGNAL5,
+
+
+	//=================================================
+	//ANIMS IN WHICH ONLY THE LOWER OBJECTS ARE IN MD3
+	//=================================================
+	//# #sep Legs-only anims
+	LEGS_TURN1,				//# What legs do when you turn your lower body to match your upper body facing
+	LEGS_TURN2,				//# Leg turning from stand2
+	LEGS_LEAN_LEFT1,		//# Lean left
+	LEGS_LEAN_RIGHT1,		//# Lean Right
+	LEGS_CHOKING1,			//# TEMP
+	LEGS_LEFTUP1,			//# On a slope with left foot 4 higher than right
+	LEGS_LEFTUP2,			//# On a slope with left foot 8 higher than right
+	LEGS_LEFTUP3,			//# On a slope with left foot 12 higher than right
+	LEGS_LEFTUP4,			//# On a slope with left foot 16 higher than right
+	LEGS_LEFTUP5,			//# On a slope with left foot 20 higher than right
+	LEGS_RIGHTUP1,			//# On a slope with RIGHT foot 4 higher than left
+	LEGS_RIGHTUP2,			//# On a slope with RIGHT foot 8 higher than left
+	LEGS_RIGHTUP3,			//# On a slope with RIGHT foot 12 higher than left
+	LEGS_RIGHTUP4,			//# On a slope with RIGHT foot 16 higher than left
+	LEGS_RIGHTUP5,			//# On a slope with RIGHT foot 20 higher than left
+	LEGS_S1_LUP1,
+	LEGS_S1_LUP2,
+	LEGS_S1_LUP3,
+	LEGS_S1_LUP4,
+	LEGS_S1_LUP5,
+	LEGS_S1_RUP1,
+	LEGS_S1_RUP2,
+	LEGS_S1_RUP3,
+	LEGS_S1_RUP4,
+	LEGS_S1_RUP5,
+	LEGS_S3_LUP1,
+	LEGS_S3_LUP2,
+	LEGS_S3_LUP3,
+	LEGS_S3_LUP4,
+	LEGS_S3_LUP5,
+	LEGS_S3_RUP1,
+	LEGS_S3_RUP2,
+	LEGS_S3_RUP3,
+	LEGS_S3_RUP4,
+	LEGS_S3_RUP5,
+	LEGS_S4_LUP1,
+	LEGS_S4_LUP2,
+	LEGS_S4_LUP3,
+	LEGS_S4_LUP4,
+	LEGS_S4_LUP5,
+	LEGS_S4_RUP1,
+	LEGS_S4_RUP2,
+	LEGS_S4_RUP3,
+	LEGS_S4_RUP4,
+	LEGS_S4_RUP5,
+	LEGS_S5_LUP1,
+	LEGS_S5_LUP2,
+	LEGS_S5_LUP3,
+	LEGS_S5_LUP4,
+	LEGS_S5_LUP5,
+	LEGS_S5_RUP1,
+	LEGS_S5_RUP2,
+	LEGS_S5_RUP3,
+	LEGS_S5_RUP4,
+	LEGS_S5_RUP5,
+	LEGS_S6_LUP1,
+	LEGS_S6_LUP2,
+	LEGS_S6_LUP3,
+	LEGS_S6_LUP4,
+	LEGS_S6_LUP5,
+	LEGS_S6_RUP1,
+	LEGS_S6_RUP2,
+	LEGS_S6_RUP3,
+	LEGS_S6_RUP4,
+	LEGS_S6_RUP5,
+	LEGS_S7_LUP1,
+	LEGS_S7_LUP2,
+	LEGS_S7_LUP3,
+	LEGS_S7_LUP4,
+	LEGS_S7_LUP5,
+	LEGS_S7_RUP1,
+	LEGS_S7_RUP2,
+	LEGS_S7_RUP3,
+	LEGS_S7_RUP4,
+	LEGS_S7_RUP5,
+
+	//New anim as per Jarrod's request
+	LEGS_TURN180,
+
+	//======================================================
+	//cinematic anims
+	//======================================================
+	//# #sep BOTH_ CINEMATIC-ONLY
+	BOTH_CIN_1,		//# Level specific cinematic 1
+	BOTH_CIN_2,		//# Level specific cinematic 2
+	BOTH_CIN_3,		//# Level specific cinematic 3
+	BOTH_CIN_4,		//# Level specific cinematic 4
+	BOTH_CIN_5,		//# Level specific cinematic 5
+	BOTH_CIN_6,		//# Level specific cinematic 6
+	BOTH_CIN_7,		//# Level specific cinematic 7
+	BOTH_CIN_8,		//# Level specific cinematic 8
+	BOTH_CIN_9,		//# Level specific cinematic 9
+	BOTH_CIN_10,		//# Level specific cinematic 10
+	BOTH_CIN_11,		//# Level specific cinematic 11
+	BOTH_CIN_12,		//# Level specific cinematic 12
+	BOTH_CIN_13,		//# Level specific cinematic 13
+	BOTH_CIN_14,		//# Level specific cinematic 14
+	BOTH_CIN_15,		//# Level specific cinematic 15
+	BOTH_CIN_16,		//# Level specific cinematic 16
+	BOTH_CIN_17,		//# Level specific cinematic 17
+	BOTH_CIN_18,		//# Level specific cinematic 18
+	BOTH_CIN_19,		//# Level specific cinematic 19
+	BOTH_CIN_20,		//# Level specific cinematic 20
+	BOTH_CIN_21,		//# Level specific cinematic 21
+	BOTH_CIN_22,		//# Level specific cinematic 22
+	BOTH_CIN_23,		//# Level specific cinematic 23
+	BOTH_CIN_24,		//# Level specific cinematic 24
+	BOTH_CIN_25,		//# Level specific cinematic 25
+	BOTH_CIN_26,		//# Level specific cinematic 
+	BOTH_CIN_27,		//# Level specific cinematic 
+	BOTH_CIN_28,		//# Level specific cinematic 
+	BOTH_CIN_29,		//# Level specific cinematic 
+	BOTH_CIN_30,		//# Level specific cinematic 
+	BOTH_CIN_31,		//# Level specific cinematic 
+	BOTH_CIN_32,		//# Level specific cinematic 
+	BOTH_CIN_33,		//# Level specific cinematic 
+	BOTH_CIN_34,		//# Level specific cinematic 
+	BOTH_CIN_35,		//# Level specific cinematic 
+	BOTH_CIN_36,		//# Level specific cinematic 
+	BOTH_CIN_37,		//# Level specific cinematic 
+	BOTH_CIN_38,		//# Level specific cinematic 
+	BOTH_CIN_39,		//# Level specific cinematic 
+	BOTH_CIN_40,		//# Level specific cinematic 
+	BOTH_CIN_41,		//# Level specific cinematic 
+	BOTH_CIN_42,		//# Level specific cinematic 
+	BOTH_CIN_43,		//# Level specific cinematic 
+	BOTH_CIN_44,		//# Level specific cinematic 
+	BOTH_CIN_45,		//# Level specific cinematic 
+	BOTH_CIN_46,		//# Level specific cinematic 
+	BOTH_CIN_47,		//# Level specific cinematic 
+	BOTH_CIN_48,		//# Level specific cinematic 
+	BOTH_CIN_49,		//# Level specific cinematic 
+	BOTH_CIN_50,		//# Level specific cinematic
+
+	//# #eol
+	MAX_ANIMATIONS,
+	MAX_TOTALANIMATIONS,
+} animNumber_t;
+
+#define SABER_ANIM_GROUP_SIZE (BOTH_A2_T__B_ - BOTH_A1_T__B_)
+
+
+#endif// #ifndef __ANIMS_H__
+
diff --git a/codemp/game/asm2mak.cfg b/codemp/game/asm2mak.cfg
new file mode 100644
index 0000000..70269b4
--- /dev/null
+++ b/codemp/game/asm2mak.cfg
@@ -0,0 +1,34 @@
+;Do not add whitespaces outside the value quotes or change the formatting. The parser is sensitive.
+game:
+{
+ReleaseFolder="../Release/JK2game"
+CompileFlags="-A -DQ3_VM -DMISSIONPACK -DQAGAME -D_FINAL -S -Wf-target=bytecode -Wf-g -I..\game -I..\cgame -I..\ui"
+SysMaker="g_public.h g_syscalls.c vm/g_syscalls.asm"
+StripPrepend="vm/"
+CompileFolder="vm"
+SkipFile="g_syscalls"
+OverridePath="bg_lib,../game/bg_lib"
+OverridePath="bg_misc,../game/bg_misc"
+OverridePath="bg_panimate,../game/bg_panimate"
+OverridePath="bg_pmove,../game/bg_pmove"
+OverridePath="bg_saber,../game/bg_saber"
+OverridePath="bg_saberLoad,../game/bg_saberLoad"
+OverridePath="bg_saga,../game/bg_saga"
+OverridePath="bg_vehicleLoad,../game/bg_vehicleLoad"
+OverridePath="bg_weapons,../game/bg_weapons"
+OverridePath="q_math,../game/q_math"
+OverridePath="q_shared,../game/q_shared"
+OverridePath="ui_shared,../ui/ui_shared"
+OverrideDep="bg_lib,../game/bg_lib.c"
+OverrideDep="bg_misc,../Release/JK2game/bg_misc.obj"
+OverrideDep="bg_panimate,../Release/JK2game/bg_panimate.obj"
+OverrideDep="bg_pmove,../Release/JK2game/bg_pmove.obj"
+OverrideDep="bg_saber,../Release/JK2game/bg_saber.obj"
+OverrideDep="bg_saberLoad,../Release/JK2game/bg_saberLoad.obj"
+OverrideDep="bg_saga,../Release/JK2game/bg_saga.obj"
+OverrideDep="bg_vehicleLoad,../Release/JK2game/bg_vehicleLoad.obj"
+OverrideDep="bg_weapons,../Release/JK2game/bg_weapons.obj"
+OverrideDep="q_math,../Release/JK2game/q_math.obj"
+OverrideDep="q_shared,../Release/JK2game/q_shared.obj"
+OverrideDep="ui_shared,../Release/ui/ui_shared.obj"
+}
diff --git a/codemp/game/b_local.h b/codemp/game/b_local.h
new file mode 100644
index 0000000..3af1de0
--- /dev/null
+++ b/codemp/game/b_local.h
@@ -0,0 +1,329 @@
+//B_local.h
+//re-added by MCG
+#ifndef __B_LOCAL_H__
+#define __B_LOCAL_H__
+
+#include "g_local.h"
+#include "b_public.h"
+#include "say.h"
+
+#include "ai.h"
+
+#define	AI_TIMERS 0//turn on to see print-outs of AI/nav timing
+//
+// Navigation susbsystem
+//
+
+#define NAVF_DUCK			0x00000001
+#define NAVF_JUMP			0x00000002
+#define NAVF_HOLD			0x00000004
+#define NAVF_SLOW			0x00000008
+
+#define DEBUG_LEVEL_DETAIL	4
+#define DEBUG_LEVEL_INFO	3
+#define DEBUG_LEVEL_WARNING	2
+#define DEBUG_LEVEL_ERROR	1
+#define DEBUG_LEVEL_NONE	0
+
+#define MAX_GOAL_REACHED_DIST_SQUARED	256//16 squared
+#define MIN_ANGLE_ERROR 0.01f
+
+#define MIN_ROCKET_DIST_SQUARED 16384//128*128
+//
+// NPC.cpp
+//
+// ai debug cvars
+void SetNPCGlobals( gentity_t *ent );
+void SaveNPCGlobals(void);
+void RestoreNPCGlobals(void);
+extern vmCvar_t		debugNPCAI;			// used to print out debug info about the NPC AI
+extern vmCvar_t		debugNPCFreeze;		// set to disable NPC ai and temporarily freeze them in place
+extern vmCvar_t		debugNPCAimingBeam;
+extern vmCvar_t		debugBreak;
+extern vmCvar_t		debugNoRoam;
+extern vmCvar_t		d_JediAI;
+extern vmCvar_t		d_saberCombat;
+
+extern void NPC_Think ( gentity_t *self);
+
+//NPC_reactions.cpp
+extern void NPC_Pain(gentity_t *self, gentity_t *attacker, int damage);
+extern void NPC_Touch( gentity_t *self, gentity_t *other, trace_t *trace );
+extern void NPC_Use( gentity_t *self, gentity_t *other, gentity_t *activator );
+extern float NPC_GetPainChance( gentity_t *self, int damage );
+
+//
+// NPC_misc.cpp
+//
+extern void Debug_Printf( vmCvar_t *cv, int level, char *fmt, ... );
+extern void Debug_NPCPrintf( gentity_t *printNPC, vmCvar_t *cv, int debugLevel, char *fmt, ... );
+
+//MCG - Begin============================================================
+//NPC_ai variables - shared by NPC.cpp andf the following modules
+extern gentity_t	*NPC;
+extern gNPC_t		*NPCInfo;
+extern gclient_t	*client;
+extern usercmd_t	ucmd;
+extern visibility_t	enemyVisibility;
+
+//AI_Default
+extern qboolean NPC_CheckInvestigate( int alertEventNum );
+extern qboolean NPC_StandTrackAndShoot (gentity_t *NPC, qboolean canDuck);
+extern void NPC_BSIdle( void );
+extern void NPC_BSPointShoot(qboolean shoot);
+extern void NPC_BSStandGuard (void);
+extern void NPC_BSPatrol (void);
+extern void NPC_BSHuntAndKill (void);
+extern void NPC_BSStandAndShoot (void);
+extern void NPC_BSRunAndShoot (void);
+extern void NPC_BSWait( void );
+extern void NPC_BSDefault( void );
+
+//NPC_behavior
+extern void NPC_BSAdvanceFight (void);
+extern void NPC_BSInvestigate (void);
+extern void NPC_BSSleep( void );
+extern void NPC_BSFlee (void);
+extern void NPC_BSFollowLeader (void);
+extern void NPC_BSJump (void);
+extern void NPC_BSRemove (void);
+extern void NPC_BSSearch (void);
+extern void NPC_BSSearchStart (int	homeWp, bState_t bState);
+extern void NPC_BSWander (void);
+extern void NPC_BSFlee( void );
+extern void NPC_StartFlee( gentity_t *enemy, vec3_t dangerPoint, int dangerLevel, int fleeTimeMin, int fleeTimeMax );
+extern void G_StartFlee( gentity_t *self, gentity_t *enemy, vec3_t dangerPoint, int dangerLevel, int fleeTimeMin, int fleeTimeMax );
+
+//NPC_combat
+extern int ChooseBestWeapon( void );
+extern void NPC_ChangeWeapon( int newWeapon );
+extern void ShootThink( void );
+extern void WeaponThink( qboolean inCombat );
+extern qboolean HaveWeapon( int weapon );
+extern qboolean CanShoot ( gentity_t *ent, gentity_t *shooter );
+extern void NPC_CheckPossibleEnemy( gentity_t *other, visibility_t vis );
+extern gentity_t *NPC_PickEnemy (gentity_t *closestTo, int enemyTeam, qboolean checkVis, qboolean findPlayersFirst, qboolean findClosest);
+extern gentity_t *NPC_CheckEnemy (qboolean findNew, qboolean tooFarOk, qboolean setEnemy ); //setEnemy = qtrue
+extern qboolean NPC_CheckAttack (float scale);
+extern qboolean NPC_CheckDefend (float scale);
+extern qboolean NPC_CheckCanAttack (float attack_scale, qboolean stationary);
+extern int NPC_AttackDebounceForWeapon (void);
+extern qboolean EntIsGlass (gentity_t *check);
+extern qboolean ShotThroughGlass (trace_t *tr, gentity_t *target, vec3_t spot, int mask);
+extern qboolean ValidEnemy (gentity_t *ent);
+extern void G_ClearEnemy (gentity_t *self);
+extern gentity_t *NPC_PickAlly ( qboolean facingEachOther, float range, qboolean ignoreGroup, qboolean movingOnly );
+extern void NPC_LostEnemyDecideChase(void);
+extern float NPC_MaxDistSquaredForWeapon( void );
+extern qboolean NPC_EvaluateShot( int hit, qboolean glassOK );
+extern int NPC_ShotEntity( gentity_t *ent, vec3_t impactPos ); //impactedPos = NULL
+
+//NPC_formation
+extern qboolean NPC_SlideMoveToGoal (void);
+extern float NPC_FindClosestTeammate (gentity_t *self);
+extern void NPC_CalcClosestFormationSpot(gentity_t *self);
+extern void G_MaintainFormations (gentity_t *self);
+extern void NPC_BSFormation (void);
+extern void NPC_CreateFormation (gentity_t *self);
+extern void NPC_DropFormation (gentity_t *self);
+extern void NPC_ReorderFormation (gentity_t *self);
+extern void NPC_InsertIntoFormation (gentity_t *self);
+extern void NPC_DeleteFromFormation (gentity_t *self);
+
+#define COLLISION_RADIUS 32
+#define NUM_POSITIONS 30
+
+//NPC spawnflags
+#define SFB_SMALLHULL	1
+
+#define SFB_RIFLEMAN	2
+#define SFB_OLDBORG		2//Borg
+#define SFB_PHASER		4
+#define SFB_GUN			4//Borg
+#define	SFB_TRICORDER	8
+#define	SFB_TASER		8//Borg
+#define	SFB_DRILL		16//Borg
+
+#define	SFB_CINEMATIC	32
+#define	SFB_NOTSOLID	64
+#define	SFB_STARTINSOLID 128
+
+//NPC_goal
+extern void SetGoal( gentity_t *goal, float rating );
+extern void NPC_SetGoal( gentity_t *goal, float rating );
+extern void NPC_ClearGoal( void );
+extern void NPC_ReachedGoal( void );
+extern qboolean ReachedGoal( gentity_t *goal );
+extern gentity_t *UpdateGoal( void );
+extern qboolean NPC_ClearPathToGoal(vec3_t dir, gentity_t *goal);
+extern qboolean NPC_MoveToGoal( qboolean tryStraight );
+
+//NPC_reactions
+
+//NPC_senses
+#define	ALERT_CLEAR_TIME	200
+#define CHECK_PVS		1
+#define CHECK_360		2
+#define CHECK_FOV		4
+#define CHECK_SHOOT		8
+#define CHECK_VISRANGE	16
+extern qboolean CanSee ( gentity_t *ent );
+extern qboolean InFOV ( gentity_t *ent, gentity_t *from, int hFOV, int vFOV );
+extern qboolean InFOV2( vec3_t origin, gentity_t *from, int hFOV, int vFOV );
+extern qboolean InFOV3( vec3_t spot, vec3_t from, vec3_t fromAngles, int hFOV, int vFOV );
+extern visibility_t NPC_CheckVisibility ( gentity_t *ent, int flags );
+extern qboolean InVisrange ( gentity_t *ent );
+
+//NPC_sounds
+//extern void NPC_AngerSound(void);
+
+//NPC_spawn
+extern void NPC_Spawn ( gentity_t *ent, gentity_t *other, gentity_t *activator );
+
+//NPC_stats
+extern int NPC_ReactionTime ( void );
+extern qboolean NPC_ParseParms( const char *NPCName, gentity_t *NPC );
+extern void NPC_LoadParms( void );
+
+//NPC_utils
+extern int	teamNumbers[TEAM_NUM_TEAMS];
+extern int	teamStrength[TEAM_NUM_TEAMS];
+extern int	teamCounter[TEAM_NUM_TEAMS];
+extern void CalcEntitySpot ( const gentity_t *ent, const spot_t spot, vec3_t point );
+extern qboolean NPC_UpdateAngles ( qboolean doPitch, qboolean doYaw );
+extern void NPC_UpdateShootAngles (vec3_t angles, qboolean doPitch, qboolean doYaw );
+extern qboolean NPC_UpdateFiringAngles ( qboolean doPitch, qboolean doYaw );
+extern void SetTeamNumbers (void);
+extern qboolean G_ActivateBehavior (gentity_t *self, int bset );
+extern void NPC_AimWiggle( vec3_t enemy_org );
+extern void NPC_SetLookTarget( gentity_t *self, int entNum, int clearTime );
+
+//g_nav.cpp
+extern int NAV_FindClosestWaypointForEnt (gentity_t *ent, int targWp);
+extern qboolean NAV_CheckAhead( gentity_t *self, vec3_t end, trace_t *trace, int clipmask );
+
+//NPC_combat
+extern float IdealDistance ( gentity_t *self );
+
+//g_squad
+extern void NPC_SetSayState (gentity_t *self, gentity_t *to, int saying);
+
+//g_utils
+extern qboolean G_CheckInSolid (gentity_t *self, qboolean fix);
+
+//MCG - End============================================================
+
+// NPC.cpp
+extern void NPC_SetAnim(gentity_t *ent, int type, int anim, int priority);
+extern qboolean NPC_EnemyTooFar(gentity_t *enemy, float dist, qboolean toShoot);
+
+// ==================================================================
+
+//rww - special system for sync'ing bone angles between client and server.
+void NPC_SetBoneAngles(gentity_t *ent, char *bone, vec3_t angles);
+
+//rww - and another method of automatically managing surface status for the client and server at once
+void NPC_SetSurfaceOnOff(gentity_t *ent, const char *surfaceName, int surfaceFlags);
+
+extern qboolean NPC_ClearLOS( const vec3_t start, const vec3_t end );
+extern qboolean NPC_ClearLOS5( const vec3_t end );
+extern qboolean NPC_ClearLOS4( gentity_t *ent ) ;
+extern qboolean NPC_ClearLOS3( const vec3_t start, gentity_t *ent );
+extern qboolean NPC_ClearLOS2( gentity_t *ent, const vec3_t end );
+
+extern qboolean NPC_ClearShot( gentity_t *ent );
+
+extern int NPC_FindCombatPoint( const vec3_t position, const vec3_t avoidPosition, vec3_t enemyPosition, const int flags, const float avoidDist, const int ignorePoint ); //ignorePoint = -1
+
+
+extern qboolean NPC_ReserveCombatPoint( int combatPointID );
+extern qboolean NPC_FreeCombatPoint( int combatPointID, qboolean failed ); //failed = qfalse
+extern qboolean NPC_SetCombatPoint( int combatPointID );
+
+#define	CP_ANY			0			//No flags
+#define	CP_COVER		0x00000001	//The enemy cannot currently shoot this position
+#define CP_CLEAR		0x00000002	//This cover point has a clear shot to the enemy
+#define CP_FLEE			0x00000004	//This cover point is marked as a flee point
+#define CP_DUCK			0x00000008	//This cover point is marked as a duck point
+#define CP_NEAREST		0x00000010	//Find the nearest combat point
+#define CP_AVOID_ENEMY	0x00000020	//Avoid our enemy
+#define CP_INVESTIGATE	0x00000040	//A special point worth enemy investigation if searching
+#define	CP_SQUAD		0x00000080	//Squad path
+#define	CP_AVOID		0x00000100	//Avoid supplied position
+#define	CP_APPROACH_ENEMY 0x00000200	//Try to get closer to enemy
+#define	CP_CLOSEST		0x00000400	//Take the closest combatPoint to the enemy that's available
+#define	CP_FLANK		0x00000800	//Pick a combatPoint behind the enemy
+#define	CP_HAS_ROUTE	0x00001000	//Pick a combatPoint that we have a route to
+#define	CP_SNIPE		0x00002000	//Pick a combatPoint that is marked as a sniper spot
+#define	CP_SAFE			0x00004000	//Pick a combatPoint that is not have dangerTime
+#define	CP_HORZ_DIST_COLL 0x00008000	//Collect combat points within *horizontal* dist
+#define	CP_NO_PVS		0x00010000	//A combat point out of the PVS of enemy pos
+#define	CP_RETREAT		0x00020000	//Try to get farther from enemy
+
+#define CPF_NONE		0
+#define	CPF_DUCK		0x00000001
+#define	CPF_FLEE		0x00000002
+#define	CPF_INVESTIGATE	0x00000004
+#define	CPF_SQUAD		0x00000008
+#define	CPF_LEAN		0x00000010
+#define	CPF_SNIPE		0x00000020
+
+#define	MAX_COMBAT_POINT_CHECK	32
+
+extern qboolean NPC_ValidEnemy( gentity_t *ent );
+extern qboolean NPC_CheckEnemyExt( qboolean checkAlerts ); //checkAlerts = qfalse
+extern qboolean NPC_FindPlayer( void );
+extern qboolean NPC_CheckCanAttackExt( void );
+
+extern int NPC_CheckAlertEvents( qboolean checkSight, qboolean checkSound, int ignoreAlert, qboolean mustHaveOwner, int minAlertLevel ); //ignoreAlert = -1, mustHaveOwner = qfalse, minAlertLevel = AEL_MINOR
+extern qboolean NPC_CheckForDanger( int alertEvent );
+extern void G_AlertTeam( gentity_t *victim, gentity_t *attacker, float radius, float soundDist );
+
+extern int NPC_FindSquadPoint( vec3_t position );
+
+extern void ClearPlayerAlertEvents( void );
+
+extern qboolean G_BoundsOverlap(const vec3_t mins1, const vec3_t maxs1, const vec3_t mins2, const vec3_t maxs2);
+extern qboolean NAV_HitNavGoal( vec3_t point, vec3_t mins, vec3_t maxs, vec3_t dest, int radius, qboolean flying );
+
+extern void NPC_SetMoveGoal( gentity_t *ent, vec3_t point, int radius, qboolean isNavGoal, int combatPoint, gentity_t *targetEnt ); //isNavGoal = qfalse, combatPoint = -1, targetEnt = NULL
+
+extern qboolean NAV_ClearPathToPoint(gentity_t *self, vec3_t pmins, vec3_t pmaxs, vec3_t point, int clipmask, int okToHitEnt );
+extern void NPC_ApplyWeaponFireDelay(void);
+
+//NPC_FaceXXX suite
+extern qboolean NPC_FacePosition( vec3_t position, qboolean doPitch ); //doPitch = qtrue
+extern qboolean NPC_FaceEntity( gentity_t *ent, qboolean doPitch ); //doPitch = qtrue
+extern qboolean NPC_FaceEnemy( qboolean doPitch ); //doPitch = qtrue
+
+//Skill level cvar
+extern vmCvar_t	g_spskill;
+
+#define	NIF_NONE		0x00000000
+#define	NIF_FAILED		0x00000001	//failed to find a way to the goal
+#define	NIF_MACRO_NAV	0x00000002	//using macro navigation
+#define	NIF_COLLISION	0x00000004	//resolving collision with an entity
+#define NIF_BLOCKED		0x00000008	//blocked from moving
+
+/*
+-------------------------
+struct navInfo_s
+-------------------------
+*/
+
+typedef struct navInfo_s
+{
+	gentity_t	*blocker;
+	vec3_t		direction;
+	vec3_t		pathDirection;
+	float		distance;
+	trace_t		trace;
+	int			flags;
+} navInfo_t;
+
+extern int	NAV_MoveToGoal( gentity_t *self, navInfo_t *info );
+extern void NAV_GetLastMove( navInfo_t *info );
+extern qboolean NAV_AvoidCollision( gentity_t *self, gentity_t *goal, navInfo_t *info );
+
+
+#endif
diff --git a/codemp/game/b_public.h b/codemp/game/b_public.h
new file mode 100644
index 0000000..4828537
--- /dev/null
+++ b/codemp/game/b_public.h
@@ -0,0 +1,355 @@
+#ifndef __B_PUBLIC_H__
+#define __B_PUBLIC_H__
+
+#include "ai.h"
+
+#define NPCAI_CHECK_WEAPON		0x00000001
+#define NPCAI_BURST_WEAPON		0x00000002
+#define NPCAI_MOVING			0x00000004
+#define NPCAI_TOUCHED_GOAL		0x00000008
+#define NPCAI_PUSHED			0x00000010
+#define NPCAI_NO_COLL_AVOID		0x00000020
+#define NPCAI_BLOCKED			0x00000040
+#define NPCAI_OFF_PATH			0x00000100
+#define NPCAI_IN_SQUADPOINT		0x00000200
+#define NPCAI_STRAIGHT_TO_DESTPOS	0x00000400
+#define NPCAI_NO_SLOWDOWN		0x00001000
+#define NPCAI_LOST				0x00002000	//Can't nav to his goal
+#define NPCAI_SHIELDS			0x00004000	//Has shields, borg can adapt
+#define NPCAI_GREET_ALLIES		0x00008000	//Say hi to nearby allies
+#define NPCAI_FORM_TELE_NAV		0x00010000	//Tells formation people to use nav info to get to 
+#define NPCAI_ENROUTE_TO_HOMEWP 0x00020000	//Lets us know to run our lostenemyscript when we get to homeWp
+#define NPCAI_MATCHPLAYERWEAPON 0x00040000	//Match the player's weapon except when it changes during cinematics
+#define NPCAI_DIE_ON_IMPACT		0x00100000	//Next time you crashland, die!
+#define NPCAI_CUSTOM_GRAVITY	0x00200000	//Don't use g_gravity, I fly!
+
+//Script flags
+#define	SCF_CROUCHED		0x00000001	//Force ucmd.upmove to be -127
+#define	SCF_WALKING			0x00000002	//Force BUTTON_WALKING to be pressed
+#define	SCF_MORELIGHT		0x00000004	//NPC will have a minlight of 96
+#define	SCF_LEAN_RIGHT		0x00000008	//Force rightmove+BUTTON_USE
+#define	SCF_LEAN_LEFT		0x00000010	//Force leftmove+BUTTON_USE
+#define	SCF_RUNNING			0x00000020	//Takes off walking button, overrides SCF_WALKING
+#define	SCF_ALT_FIRE		0x00000040	//Force to use alt-fire when firing
+#define	SCF_NO_RESPONSE		0x00000080	//NPC will not do generic responses to being used
+#define	SCF_FFDEATH			0x00000100	//Just tells player_die to run the friendly fire deathscript
+#define	SCF_NO_COMBAT_TALK	0x00000200	//NPC will not use their generic combat chatter stuff
+#define	SCF_CHASE_ENEMIES	0x00000400	//NPC chase enemies - FIXME: right now this is synonymous with using combat points... should it be?
+#define	SCF_LOOK_FOR_ENEMIES	0x00000800	//NPC be on the lookout for enemies
+#define	SCF_FACE_MOVE_DIR	0x00001000	//NPC face direction it's moving - FIXME: not really implemented right now
+#define	SCF_IGNORE_ALERTS	0x00002000	//NPC ignore alert events
+#define SCF_DONT_FIRE		0x00004000	//NPC won't shoot
+#define	SCF_DONT_FLEE		0x00008000	//NPC never flees
+#define	SCF_FORCED_MARCH	0x00010000	//NPC that the player must aim at to make him walk
+#define	SCF_NO_GROUPS		0x00020000	//NPC cannot alert groups or be part of a group
+#define	SCF_FIRE_WEAPON		0x00040000	//NPC will fire his (her) weapon
+#define	SCF_NO_MIND_TRICK	0x00080000	//Not succeptible to mind tricks
+#define	SCF_USE_CP_NEAREST	0x00100000	//Will use combat point close to it, not next to player or try and flank player
+#define	SCF_NO_FORCE		0x00200000	//Not succeptible to force powers
+#define	SCF_NO_FALLTODEATH	0x00400000	//NPC will not scream and tumble and fall to hit death over large drops
+#define	SCF_NO_ACROBATICS	0x00800000	//Jedi won't jump, roll or cartwheel
+#define	SCF_USE_SUBTITLES	0x01000000	//Regardless of subtitle setting, this NPC will display subtitles when it speaks lines
+#define	SCF_NO_ALERT_TALK	0x02000000	//Will not say alert sounds, but still can be woken up by alerts
+
+//#ifdef __DEBUG
+
+//Debug flag definitions
+
+#define	AID_IDLE		0x00000000	//Nothing is happening
+#define AID_ACQUIRED	0x00000001	//A target has been found
+#define AID_LOST		0x00000002	//Alert, but no target is in sight
+#define AID_CONFUSED	0x00000004	//Is unable to come up with a course of action
+#define AID_LOSTPATH	0x00000008	//Cannot make a valid movement due to lack of connections
+
+//#endif //__DEBUG
+
+//extern qboolean showWaypoints;
+
+typedef enum {VIS_UNKNOWN, VIS_NOT, VIS_PVS, VIS_360, VIS_FOV, VIS_SHOOT} visibility_t;
+typedef enum {SPOT_ORIGIN, SPOT_CHEST, SPOT_HEAD, SPOT_HEAD_LEAN, SPOT_WEAPON, SPOT_LEGS, SPOT_GROUND} spot_t;
+
+typedef enum //# lookMode_e
+{
+	LM_ENT = 0,
+	LM_INTEREST
+} lookMode_t;
+
+typedef enum //# jumpState_e
+{
+	JS_WAITING = 0,
+	JS_FACING,
+	JS_CROUCHING,
+	JS_JUMPING,
+	JS_LANDING
+} jumpState_t;
+
+typedef struct gNPCstats_e
+{//Stats, loaded in, and can be set by scripts
+	//AI
+	int		aggression;			//			"
+	int		aim;				//			"
+	float	earshot;			//			"
+	int		evasion;			//			"
+	int		hfov;				// horizontal field of view
+	int		intelligence;		//			"
+	int		move;				//			"
+	int		reactions;			// 1-5, higher is better
+	float	shootDistance;		//Maximum range- overrides range set for weapon if nonzero
+	int		vfov;				// vertical field of view
+	float	vigilance;			//			"
+	float	visrange;			//			"
+	//Movement
+	int		runSpeed;
+	int		walkSpeed;
+	float	yawSpeed;			// 1 - whatever, default is 50
+	int		health;
+	int		acceleration;
+} gNPCstats_t;
+
+// NOTE!!!  If you add any ptr fields into this structure could you please tell me so I can update the load/save code?
+//	so far the only things I've got to cope with are a bunch of gentity_t*'s, but tell me if any more get added -slc
+//
+
+#define	MAX_ENEMY_POS_LAG	2400
+#define	ENEMY_POS_LAG_INTERVAL	100
+#define	ENEMY_POS_LAG_STEPS	(MAX_ENEMY_POS_LAG/ENEMY_POS_LAG_INTERVAL)
+typedef struct 
+{
+	//FIXME: Put in playerInfo or something
+	int			timeOfDeath;			//FIXME do we really need both of these
+	gentity_t	*touchedByPlayer;
+
+	visibility_t	enemyLastVisibility;
+
+	int			aimTime;
+	float		desiredYaw;
+	float		desiredPitch;
+	float		lockedDesiredYaw;
+	float		lockedDesiredPitch;
+	gentity_t	*aimingBeam;		// debugging aid
+
+	vec3_t		enemyLastSeenLocation;
+	int			enemyLastSeenTime;
+	vec3_t		enemyLastHeardLocation;
+	int			enemyLastHeardTime;
+	int			lastAlertID;		//unique ID
+
+	int			eFlags;
+	int			aiFlags;
+
+	int			currentAmmo;		// this sucks, need to find a better way
+	int			shotTime;
+	int			burstCount;
+	int			burstMin;
+	int			burstMean;
+	int			burstMax;
+	int			burstSpacing;
+	int			attackHold;
+	int			attackHoldTime;
+	vec3_t		shootAngles;		//Angles to where bot is shooting - fixme: make he torso turn to reflect these
+
+	//extra character info
+	rank_t		rank;		//for pips
+
+	//Behavior state info
+	bState_t	behaviorState;	//determines what actions he should be doing
+	bState_t	defaultBehavior;//State bot will default to if none other set
+	bState_t	tempBehavior;//While valid, overrides other behavior
+
+	qboolean	ignorePain;		//only play pain scripts when take pain
+
+	int			duckDebounceTime;//Keeps them ducked for a certain time
+	int			walkDebounceTime;
+	int			enemyCheckDebounceTime;
+	int			investigateDebounceTime;
+	int			investigateCount;
+	vec3_t		investigateGoal;
+	int			investigateSoundDebounceTime;
+	int			greetingDebounceTime;//when we can greet someone next
+	gentity_t	*eventOwner;
+	
+	//bState-specific fields
+	gentity_t	*coverTarg;
+	jumpState_t	jumpState;
+	float		followDist;
+
+	// goal, navigation & pathfinding
+	gentity_t	*tempGoal;			// used for locational goals (player's last seen/heard position)
+	gentity_t	*goalEntity;
+	gentity_t	*lastGoalEntity;
+	gentity_t	*eventualGoal;
+	gentity_t	*captureGoal;		//Where we should try to capture
+	gentity_t	*defendEnt;			//Who we're trying to protect
+	gentity_t	*greetEnt;			//Who we're greeting
+	int			goalTime;	//FIXME: This is never actually used
+	qboolean	straightToGoal;	//move straight at navgoals
+	float		distToGoal;
+	int			navTime;
+	int			blockingEntNum;
+	int			blockedSpeechDebounceTime;
+	int			lastSideStepSide;
+	int			sideStepHoldTime;
+	int			homeWp;
+	AIGroupInfo_t	*group;
+
+	vec3_t		lastPathAngles;		//So we know which way to face generally when we stop
+
+	//stats
+	gNPCstats_t	stats;
+	int			aimErrorDebounceTime;
+	float		lastAimErrorYaw;
+	float		lastAimErrorPitch;
+	vec3_t		aimOfs;
+	int			currentAim;
+	int			currentAggression;
+
+	//scriptflags
+	int			scriptFlags;//in b_local.h
+
+	//moveInfo
+	int			desiredSpeed;
+	int			currentSpeed;
+	char		last_forwardmove;
+	char		last_rightmove;
+	vec3_t		lastClearOrigin;
+	int			consecutiveBlockedMoves;
+	int			blockedDebounceTime;
+	int			shoveCount;
+	vec3_t		blockedDest;
+
+	//
+	int			combatPoint;//NPCs in bState BS_COMBAT_POINT will find their closest empty combat_point
+	int			lastFailedCombatPoint;//NPCs in bState BS_COMBAT_POINT will find their closest empty combat_point
+	int			movementSpeech;	//what to say when you first successfully move
+	float		movementSpeechChance;//how likely you are to say it
+
+	//Testing physics at 20fps
+	int			nextBStateThink;
+	usercmd_t	last_ucmd;
+
+	//
+	//JWEIER ADDITIONS START
+
+	qboolean	combatMove;
+	int			goalRadius;
+
+	//FIXME: These may be redundant
+	
+	/*
+	int			weaponTime;		//Time until refire is valid
+	int			jumpTime;
+	*/
+	int			pauseTime;		//Time to stand still
+	int			standTime;
+
+	int			localState;		//Tracking information local to entity
+	int			squadState;		//Tracking information for team level interaction
+
+	//JWEIER ADDITIONS END
+	//
+
+	int			confusionTime;	//Doesn't respond to alerts or pick up enemies (unless shot) until this time is up
+	int			charmedTime;	//charmed to enemy team
+	int			controlledTime;	//controlled by player
+	int			surrenderTime;	//Hands up
+
+	//Lagging enemy position - FIXME: seems awful wasteful...
+	vec3_t		enemyLaggedPos[ENEMY_POS_LAG_STEPS];
+
+	gentity_t	*watchTarget;	//for BS_CINEMATIC, keeps facing this ent
+
+	int			ffireCount;		//sigh... you'd think I'd be able to find a way to do this without having to use 3 int fields, but...
+	int			ffireDebounce;	
+	int			ffireFadeDebounce;
+} gNPC_t;
+
+void G_SquadPathsInit(void);
+void NPC_InitGame( void );
+void G_LoadBoltOns( void );
+void Svcmd_NPC_f( void );
+void NAV_DebugShowWaypoints (void);
+void NAV_DebugShowBoxes (void);
+void NAV_DebugShowSquadPaths (void);
+/*
+void Bot_InitGame( void );
+void Bot_InitPreSpawn( void );
+void Bot_InitPostSpawn( void );
+void Bot_Shutdown( void );
+void Bot_Think( gentity_t *ent, int msec );
+void Bot_Connect( gentity_t *bot, char *botName );
+void Bot_Begin( gentity_t *bot );
+void Bot_Disconnect( gentity_t *bot );
+void Svcmd_Bot_f( void );
+void Nav_ItemSpawn( gentity_t *ent, int remaining );
+*/
+
+//
+// This section should be moved to QFILES.H
+//
+/*
+#define NAVFILE_ID			(('I')+('N'<<8)+('A'<<16)+('V'<<24))
+#define NAVFILE_VERSION		6
+
+typedef struct {
+	unsigned	id;
+	unsigned	version;
+	unsigned	checksum;
+	unsigned	surfaceCount;
+	unsigned	edgeCount;
+} navheader_t;
+
+
+#define MAX_SURFACES	4096
+
+#define NSF_PUSH			0x00000001
+#define NSF_WATERLEVEL1		0x00000002
+#define NSF_WATERLEVEL2		0x00000004
+#define NSF_WATER_NOAIR		0x00000008
+#define NSF_DUCK			0x00000010
+#define NSF_PAIN			0x00000020
+#define NSF_TELEPORTER		0x00000040
+#define NSF_PLATHIGH		0x00000080
+#define NSF_PLATLOW			0x00000100
+#define NSF_DOOR_FLOOR		0x00000200
+#define NSF_DOOR_SHOOT		0x00000400
+#define NSF_DOOR_BUTTON		0x00000800
+#define NSF_BUTTON			0x00001000
+
+typedef struct {
+	vec3_t		origin;
+	vec2_t		absmin;
+	vec2_t		absmax;
+	int			parm;
+	unsigned	flags;
+	unsigned	edgeCount;
+	unsigned	edgeIndex;
+} nsurface_t;
+
+
+#define NEF_DUCK			0x00000001
+#define NEF_JUMP			0x00000002
+#define NEF_HOLD			0x00000004
+#define NEF_WALK			0x00000008
+#define NEF_RUN				0x00000010
+#define NEF_NOAIRMOVE		0x00000020
+#define NEF_LEFTGROUND		0x00000040
+#define NEF_PLAT			0x00000080
+#define NEF_FALL1			0x00000100
+#define NEF_FALL2			0x00000200
+#define NEF_DOOR_SHOOT		0x00000400
+#define NEF_DOOR_BUTTON		0x00000800
+#define NEF_BUTTON			0x00001000
+
+typedef struct {
+	vec3_t		origin;
+	vec2_t		absmin;		// region within this surface that is the portal to the other surface
+	vec2_t		absmax;
+	int			surfaceNum;
+	unsigned	flags;		// jump, prerequisite button, will take falling damage, etc...
+	float		cost;
+	int			dirIndex;
+	vec3_t		endSpot;
+	int			parm;
+} nedge_t;
+*/
+#endif
diff --git a/codemp/game/be_aas.h b/codemp/game/be_aas.h
new file mode 100644
index 0000000..f5c053a
--- /dev/null
+++ b/codemp/game/be_aas.h
@@ -0,0 +1,205 @@
+// Copyright (C) 1999-2000 Id Software, Inc.
+//
+
+/*****************************************************************************
+ * name:		be_aas.h
+ *
+ * desc:		Area Awareness System, stuff exported to the AI
+ *
+ * $Archive: /source/code/botlib/be_aas.h $
+ * $Author: osman $ 
+ * $Revision: 1.4 $
+ * $Modtime: 10/05/99 3:32p $
+ * $Date: 2003/03/15 23:43:59 $
+ *
+ *****************************************************************************/
+
+#ifndef MAX_STRINGFIELD
+#define MAX_STRINGFIELD				80
+#endif
+
+//travel flags
+#define TFL_INVALID				0x00000001	//traveling temporary not possible
+#define TFL_WALK				0x00000002	//walking
+#define TFL_CROUCH				0x00000004	//crouching
+#define TFL_BARRIERJUMP			0x00000008	//jumping onto a barrier
+#define TFL_JUMP				0x00000010	//jumping
+#define TFL_LADDER				0x00000020	//climbing a ladder
+#define TFL_WALKOFFLEDGE		0x00000080	//walking of a ledge
+#define TFL_SWIM				0x00000100	//swimming
+#define TFL_WATERJUMP			0x00000200	//jumping out of the water
+#define TFL_TELEPORT			0x00000400	//teleporting
+#define TFL_ELEVATOR			0x00000800	//elevator
+#define TFL_ROCKETJUMP			0x00001000	//rocket jumping
+#define TFL_BFGJUMP				0x00002000	//bfg jumping
+#define TFL_GRAPPLEHOOK			0x00004000	//grappling hook
+#define TFL_DOUBLEJUMP			0x00008000	//double jump
+#define TFL_RAMPJUMP			0x00010000	//ramp jump
+#define TFL_STRAFEJUMP			0x00020000	//strafe jump
+#define TFL_JUMPPAD				0x00040000	//jump pad
+#define TFL_AIR					0x00080000	//travel through air
+#define TFL_WATER				0x00100000	//travel through water
+#define TFL_SLIME				0x00200000	//travel through slime
+#define TFL_LAVA				0x00400000	//travel through lava
+#define TFL_DONOTENTER			0x00800000	//travel through donotenter area
+#define TFL_FUNCBOB				0x01000000	//func bobbing
+#define TFL_FLIGHT				0x02000000	//flight
+#define TFL_BRIDGE				0x04000000	//move over a bridge
+//
+#define TFL_NOTTEAM1			0x08000000	//not team 1
+#define TFL_NOTTEAM2			0x10000000	//not team 2
+
+//default travel flags
+#define TFL_DEFAULT	TFL_WALK|TFL_CROUCH|TFL_BARRIERJUMP|\
+	TFL_JUMP|TFL_LADDER|\
+	TFL_WALKOFFLEDGE|TFL_SWIM|TFL_WATERJUMP|\
+	TFL_TELEPORT|TFL_ELEVATOR|\
+	TFL_AIR|TFL_WATER|TFL_JUMPPAD|TFL_FUNCBOB
+
+typedef enum
+{
+	SOLID_NOT,			// no interaction with other objects
+	SOLID_TRIGGER,		// only touch when inside, after moving
+	SOLID_BBOX,			// touch on edge
+	SOLID_BSP			// bsp clip, touch on edge
+} solid_t;
+
+//a trace is returned when a box is swept through the AAS world
+typedef struct aas_trace_s
+{
+	qboolean	startsolid;	// if true, the initial point was in a solid area
+	float		fraction;	// time completed, 1.0 = didn't hit anything
+	vec3_t		endpos;		// final position
+	int			ent;		// entity blocking the trace
+	int			lastarea;	// last area the trace was in (zero if none)
+	int			area;		// area blocking the trace (zero if none)
+	int			planenum;	// number of the plane that was hit
+} aas_trace_t;
+
+/* Defined in botlib.h
+
+//bsp_trace_t hit surface
+typedef struct bsp_surface_s
+{
+	char name[16];
+	int flags;
+	int value;
+} bsp_surface_t;
+
+//a trace is returned when a box is swept through the BSP world
+typedef struct bsp_trace_s
+{
+	qboolean		allsolid;	// if true, plane is not valid
+	qboolean		startsolid;	// if true, the initial point was in a solid area
+	float			fraction;	// time completed, 1.0 = didn't hit anything
+	vec3_t			endpos;		// final position
+	cplane_t		plane;		// surface normal at impact
+	float			exp_dist;	// expanded plane distance
+	int				sidenum;	// number of the brush side hit
+	bsp_surface_t	surface;	// hit surface
+	int				contents;	// contents on other side of surface hit
+	int				ent;		// number of entity hit
+} bsp_trace_t;
+//
+*/
+
+//entity info
+typedef struct aas_entityinfo_s
+{
+	int		valid;			// true if updated this frame
+	int		type;			// entity type
+	int		flags;			// entity flags
+	float	ltime;			// local time
+	float	update_time;	// time between last and current update
+	int		number;			// number of the entity
+	vec3_t	origin;			// origin of the entity
+	vec3_t	angles;			// angles of the model
+	vec3_t	old_origin;		// for lerping
+	vec3_t	lastvisorigin;	// last visible origin
+	vec3_t	mins;			// bounding box minimums
+	vec3_t	maxs;			// bounding box maximums
+	int		groundent;		// ground entity
+	int		solid;			// solid type
+	int		modelindex;		// model used
+	int		modelindex2;	// weapons, CTF flags, etc
+	int		frame;			// model frame number
+	int		event;			// impulse events -- muzzle flashes, footsteps, etc
+	int		eventParm;		// even parameter
+	int		powerups;		// bit flags
+	int		weapon;			// determines weapon and flash model, etc
+	int		legsAnim;		// current legs anim
+	int		torsoAnim;		// current torso anim
+} aas_entityinfo_t;
+
+// area info
+typedef struct aas_areainfo_s
+{
+	int contents;
+	int flags;
+	int presencetype;
+	int cluster;
+	vec3_t mins;
+	vec3_t maxs;
+	vec3_t center;
+} aas_areainfo_t;
+
+// client movement prediction stop events, stop as soon as:
+#define SE_NONE					0
+#define SE_HITGROUND			1		// the ground is hit
+#define SE_LEAVEGROUND			2		// there's no ground
+#define SE_ENTERWATER			4		// water is entered
+#define SE_ENTERSLIME			8		// slime is entered
+#define SE_ENTERLAVA			16		// lava is entered
+#define SE_HITGROUNDDAMAGE		32		// the ground is hit with damage
+#define SE_GAP					64		// there's a gap
+#define SE_TOUCHJUMPPAD			128		// touching a jump pad area
+#define SE_TOUCHTELEPORTER		256		// touching teleporter
+#define SE_ENTERAREA			512		// the given stoparea is entered
+#define SE_HITGROUNDAREA		1024	// a ground face in the area is hit
+#define SE_HITBOUNDINGBOX		2048	// hit the specified bounding box
+#define SE_TOUCHCLUSTERPORTAL	4096	// touching a cluster portal
+
+typedef struct aas_clientmove_s
+{
+	vec3_t endpos;			//position at the end of movement prediction
+	int endarea;			//area at end of movement prediction
+	vec3_t velocity;		//velocity at the end of movement prediction
+	aas_trace_t trace;		//last trace
+	int presencetype;		//presence type at end of movement prediction
+	int stopevent;			//event that made the prediction stop
+	int endcontents;		//contents at the end of movement prediction
+	float time;				//time predicted ahead
+	int frames;				//number of frames predicted ahead
+} aas_clientmove_t;
+
+// alternate route goals
+#define ALTROUTEGOAL_ALL				1
+#define ALTROUTEGOAL_CLUSTERPORTALS		2
+#define ALTROUTEGOAL_VIEWPORTALS		4
+
+typedef struct aas_altroutegoal_s
+{
+	vec3_t origin;
+	int areanum;
+	unsigned short starttraveltime;
+	unsigned short goaltraveltime;
+	unsigned short extratraveltime;
+} aas_altroutegoal_t;
+
+// route prediction stop events
+#define RSE_NONE				0
+#define RSE_NOROUTE				1	//no route to goal
+#define RSE_USETRAVELTYPE		2	//stop as soon as on of the given travel types is used
+#define RSE_ENTERCONTENTS		4	//stop when entering the given contents
+#define RSE_ENTERAREA			8	//stop when entering the given area
+
+typedef struct aas_predictroute_s
+{
+	vec3_t endpos;			//position at the end of movement prediction
+	int endarea;			//area at end of movement prediction
+	int stopevent;			//event that made the prediction stop
+	int endcontents;		//contents at the end of movement prediction
+	int endtravelflags;		//end travel flags
+	int numareas;			//number of areas predicted ahead
+	int time;				//time predicted ahead (in hundreth of a sec)
+} aas_predictroute_t;
diff --git a/codemp/game/be_ai_char.h b/codemp/game/be_ai_char.h
new file mode 100644
index 0000000..d3bdf4f
--- /dev/null
+++ b/codemp/game/be_ai_char.h
@@ -0,0 +1,32 @@
+// Copyright (C) 1999-2000 Id Software, Inc.
+//
+
+/*****************************************************************************
+ * name:		be_ai_char.h
+ *
+ * desc:		bot characters
+ *
+ * $Archive: /source/code/botlib/be_ai_char.h $
+ * $Author: osman $ 
+ * $Revision: 1.4 $
+ * $Modtime: 10/05/99 3:32p $
+ * $Date: 2003/03/15 23:43:59 $
+ *
+ *****************************************************************************/
+
+//loads a bot character from a file
+int BotLoadCharacter(char *charfile, float skill);
+//frees a bot character
+void BotFreeCharacter(int character);
+//returns a float characteristic
+float Characteristic_Float(int character, int index);
+//returns a bounded float characteristic
+float Characteristic_BFloat(int character, int index, float min, float max);
+//returns an integer characteristic
+int Characteristic_Integer(int character, int index);
+//returns a bounded integer characteristic
+int Characteristic_BInteger(int character, int index, int min, int max);
+//returns a string characteristic
+void Characteristic_String(int character, int index, char *buf, int size);
+//free cached bot characters
+void BotShutdownCharacters(void);
diff --git a/codemp/game/be_ai_chat.h b/codemp/game/be_ai_chat.h
new file mode 100644
index 0000000..2db4e7e
--- /dev/null
+++ b/codemp/game/be_ai_chat.h
@@ -0,0 +1,97 @@
+// Copyright (C) 1999-2000 Id Software, Inc.
+//
+/*****************************************************************************
+ * name:		be_ai_chat.h
+ *
+ * desc:		char AI
+ *
+ * $Archive: /source/code/botlib/be_ai_chat.h $
+ * $Author: osman $ 
+ * $Revision: 1.4 $
+ * $Modtime: 10/05/99 3:32p $
+ * $Date: 2003/03/15 23:43:59 $
+ *
+ *****************************************************************************/
+
+#define MAX_MESSAGE_SIZE		256
+#define MAX_CHATTYPE_NAME		32
+#define MAX_MATCHVARIABLES		8
+
+#define CHAT_GENDERLESS			0
+#define CHAT_GENDERFEMALE		1
+#define CHAT_GENDERMALE			2
+
+#define CHAT_ALL					0
+#define CHAT_TEAM					1
+#define CHAT_TELL					2
+
+//a console message
+typedef struct bot_consolemessage_s
+{
+	int handle;
+	float time;									//message time
+	int type;									//message type
+	char message[MAX_MESSAGE_SIZE];				//message
+	struct bot_consolemessage_s *prev, *next;	//prev and next in list
+} bot_consolemessage_t;
+
+//match variable
+typedef struct bot_matchvariable_s
+{
+	char offset;
+	int length;
+} bot_matchvariable_t;
+//returned to AI when a match is found
+typedef struct bot_match_s
+{
+	char string[MAX_MESSAGE_SIZE];
+	int type;
+	int subtype;
+	bot_matchvariable_t variables[MAX_MATCHVARIABLES];
+} bot_match_t;
+
+//setup the chat AI
+int BotSetupChatAI(void);
+//shutdown the chat AI
+void BotShutdownChatAI(void);
+//returns the handle to a newly allocated chat state
+int BotAllocChatState(void);
+//frees the chatstate
+void BotFreeChatState(int handle);
+//adds a console message to the chat state
+void BotQueueConsoleMessage(int chatstate, int type, char *message);
+//removes the console message from the chat state
+void BotRemoveConsoleMessage(int chatstate, int handle);
+//returns the next console message from the state
+int BotNextConsoleMessage(int chatstate, bot_consolemessage_t *cm);
+//returns the number of console messages currently stored in the state
+int BotNumConsoleMessages(int chatstate);
+//selects a chat message of the given type
+void BotInitialChat(int chatstate, char *type, int mcontext, char *var0, char *var1, char *var2, char *var3, char *var4, char *var5, char *var6, char *var7);
+//returns the number of initial chat messages of the given type
+int BotNumInitialChats(int chatstate, char *type);
+//find and select a reply for the given message
+int BotReplyChat(int chatstate, char *message, int mcontext, int vcontext, char *var0, char *var1, char *var2, char *var3, char *var4, char *var5, char *var6, char *var7);
+//returns the length of the currently selected chat message
+int BotChatLength(int chatstate);
+//enters the selected chat message
+void BotEnterChat(int chatstate, int clientto, int sendto);
+//get the chat message ready to be output
+void BotGetChatMessage(int chatstate, char *buf, int size);
+//checks if the first string contains the second one, returns index into first string or -1 if not found
+int StringContains(char *str1, char *str2, int casesensitive);
+//finds a match for the given string using the match templates
+int BotFindMatch(char *str, bot_match_t *match, unsigned long int context);
+//returns a variable from a match
+void BotMatchVariable(bot_match_t *match, int variable, char *buf, int size);
+//unify all the white spaces in the string
+void UnifyWhiteSpaces(char *string);
+//replace all the context related synonyms in the string
+void BotReplaceSynonyms(char *string, unsigned long int context);
+//loads a chat file for the chat state
+int BotLoadChatFile(int chatstate, char *chatfile, char *chatname);
+//store the gender of the bot in the chat state
+void BotSetChatGender(int chatstate, int gender);
+//store the bot name in the chat state
+void BotSetChatName(int chatstate, char *name, int client);
+
diff --git a/codemp/game/be_ai_gen.h b/codemp/game/be_ai_gen.h
new file mode 100644
index 0000000..8335c3d
--- /dev/null
+++ b/codemp/game/be_ai_gen.h
@@ -0,0 +1,17 @@
+// Copyright (C) 1999-2000 Id Software, Inc.
+//
+
+/*****************************************************************************
+ * name:		be_ai_gen.h
+ *
+ * desc:		genetic selection
+ *
+ * $Archive: /source/code/botlib/be_ai_gen.h $
+ * $Author: osman $ 
+ * $Revision: 1.4 $
+ * $Modtime: 10/05/99 3:32p $
+ * $Date: 2003/03/15 23:44:00 $
+ *
+ *****************************************************************************/
+
+int GeneticParentsAndChildSelection(int numranks, float *ranks, int *parent1, int *parent2, int *child);
diff --git a/codemp/game/be_ai_goal.h b/codemp/game/be_ai_goal.h
new file mode 100644
index 0000000..5a4c239
--- /dev/null
+++ b/codemp/game/be_ai_goal.h
@@ -0,0 +1,102 @@
+// Copyright (C) 1999-2000 Id Software, Inc.
+//
+/*****************************************************************************
+ * name:		be_ai_goal.h
+ *
+ * desc:		goal AI
+ *
+ * $Archive: /source/code/botlib/be_ai_goal.h $
+ * $Author: osman $ 
+ * $Revision: 1.4 $
+ * $Modtime: 10/05/99 3:32p $
+ * $Date: 2003/03/15 23:44:00 $
+ *
+ *****************************************************************************/
+
+#define MAX_AVOIDGOALS			256
+#define MAX_GOALSTACK			8
+
+#define GFL_NONE				0
+#define GFL_ITEM				1
+#define GFL_ROAM				2
+#define GFL_DROPPED				4
+
+//a bot goal
+typedef struct bot_goal_s
+{
+	vec3_t origin;				//origin of the goal
+	int areanum;				//area number of the goal
+	vec3_t mins, maxs;			//mins and maxs of the goal
+	int entitynum;				//number of the goal entity
+	int number;					//goal number
+	int flags;					//goal flags
+	int iteminfo;				//item information
+} bot_goal_t;
+
+//reset the whole goal state, but keep the item weights
+void BotResetGoalState(int goalstate);
+//reset avoid goals
+void BotResetAvoidGoals(int goalstate);
+//remove the goal with the given number from the avoid goals
+void BotRemoveFromAvoidGoals(int goalstate, int number);
+//push a goal onto the goal stack
+void BotPushGoal(int goalstate, bot_goal_t *goal);
+//pop a goal from the goal stack
+void BotPopGoal(int goalstate);
+//empty the bot's goal stack
+void BotEmptyGoalStack(int goalstate);
+//dump the avoid goals
+void BotDumpAvoidGoals(int goalstate);
+//dump the goal stack
+void BotDumpGoalStack(int goalstate);
+//get the name name of the goal with the given number
+void BotGoalName(int number, char *name, int size);
+//get the top goal from the stack
+int BotGetTopGoal(int goalstate, bot_goal_t *goal);
+//get the second goal on the stack
+int BotGetSecondGoal(int goalstate, bot_goal_t *goal);
+//choose the best long term goal item for the bot
+int BotChooseLTGItem(int goalstate, vec3_t origin, int *inventory, int travelflags);
+//choose the best nearby goal item for the bot
+//the item may not be further away from the current bot position than maxtime
+//also the travel time from the nearby goal towards the long term goal may not
+//be larger than the travel time towards the long term goal from the current bot position
+int BotChooseNBGItem(int goalstate, vec3_t origin, int *inventory, int travelflags,
+							bot_goal_t *ltg, float maxtime);
+//returns true if the bot touches the goal
+int BotTouchingGoal(vec3_t origin, bot_goal_t *goal);
+//returns true if the goal should be visible but isn't
+int BotItemGoalInVisButNotVisible(int viewer, vec3_t eye, vec3_t viewangles, bot_goal_t *goal);
+//search for a goal for the given classname, the index can be used
+//as a start point for the search when multiple goals are available with that same classname
+int BotGetLevelItemGoal(int index, char *classname, bot_goal_t *goal);
+//get the next camp spot in the map
+int BotGetNextCampSpotGoal(int num, bot_goal_t *goal);
+//get the map location with the given name
+int BotGetMapLocationGoal(char *name, bot_goal_t *goal);
+//returns the avoid goal time
+float BotAvoidGoalTime(int goalstate, int number);
+//set the avoid goal time
+void BotSetAvoidGoalTime(int goalstate, int number, float avoidtime);
+//initializes the items in the level
+void BotInitLevelItems(void);
+//regularly update dynamic entity items (dropped weapons, flags etc.)
+void BotUpdateEntityItems(void);
+//interbreed the goal fuzzy logic
+void BotInterbreedGoalFuzzyLogic(int parent1, int parent2, int child);
+//save the goal fuzzy logic to disk
+void BotSaveGoalFuzzyLogic(int goalstate, char *filename);
+//mutate the goal fuzzy logic
+void BotMutateGoalFuzzyLogic(int goalstate, float range);
+//loads item weights for the bot
+int BotLoadItemWeights(int goalstate, char *filename);
+//frees the item weights of the bot
+void BotFreeItemWeights(int goalstate);
+//returns the handle of a newly allocated goal state
+int BotAllocGoalState(int client);
+//free the given goal state
+void BotFreeGoalState(int handle);
+//setup the goal AI
+int BotSetupGoalAI(void);
+//shut down the goal AI
+void BotShutdownGoalAI(void);
diff --git a/codemp/game/be_ai_move.h b/codemp/game/be_ai_move.h
new file mode 100644
index 0000000..f429506
--- /dev/null
+++ b/codemp/game/be_ai_move.h
@@ -0,0 +1,126 @@
+// Copyright (C) 1999-2000 Id Software, Inc.
+//
+
+/*****************************************************************************
+ * name:		be_ai_move.h
+ *
+ * desc:		movement AI
+ *
+ * $Archive: /source/code/botlib/be_ai_move.h $
+ * $Author: osman $ 
+ * $Revision: 1.4 $
+ * $Modtime: 10/05/99 3:32p $
+ * $Date: 2003/03/15 23:44:00 $
+ *
+ *****************************************************************************/
+
+//movement types
+#define MOVE_WALK						1
+#define MOVE_CROUCH						2
+#define MOVE_JUMP						4
+#define MOVE_GRAPPLE					8
+#define MOVE_ROCKETJUMP					16
+#define MOVE_BFGJUMP					32
+//move flags
+#define MFL_BARRIERJUMP					1		//bot is performing a barrier jump
+#define MFL_ONGROUND					2		//bot is in the ground
+#define MFL_SWIMMING					4		//bot is swimming
+#define MFL_AGAINSTLADDER				8		//bot is against a ladder
+#define MFL_WATERJUMP					16		//bot is waterjumping
+#define MFL_TELEPORTED					32		//bot is being teleported
+#define MFL_GRAPPLEPULL					64		//bot is being pulled by the grapple
+#define MFL_ACTIVEGRAPPLE				128		//bot is using the grapple hook
+#define MFL_GRAPPLERESET				256		//bot has reset the grapple
+#define MFL_WALK						512		//bot should walk slowly
+// move result flags
+#define MOVERESULT_MOVEMENTVIEW			1		//bot uses view for movement
+#define MOVERESULT_SWIMVIEW				2		//bot uses view for swimming
+#define MOVERESULT_WAITING				4		//bot is waiting for something
+#define MOVERESULT_MOVEMENTVIEWSET		8		//bot has set the view in movement code
+#define MOVERESULT_MOVEMENTWEAPON		16		//bot uses weapon for movement
+#define MOVERESULT_ONTOPOFOBSTACLE		32		//bot is ontop of obstacle
+#define MOVERESULT_ONTOPOF_FUNCBOB		64		//bot is ontop of a func_bobbing
+#define MOVERESULT_ONTOPOF_ELEVATOR		128		//bot is ontop of an elevator (func_plat)
+#define MOVERESULT_BLOCKEDBYAVOIDSPOT	256		//bot is blocked by an avoid spot
+//
+#define MAX_AVOIDREACH					1
+#define MAX_AVOIDSPOTS					32
+// avoid spot types
+#define AVOID_CLEAR						0		//clear all avoid spots
+#define AVOID_ALWAYS					1		//avoid always
+#define AVOID_DONTBLOCK					2		//never totally block
+// restult types
+#define RESULTTYPE_ELEVATORUP			1		//elevator is up
+#define RESULTTYPE_WAITFORFUNCBOBBING	2		//waiting for func bobbing to arrive
+#define RESULTTYPE_BADGRAPPLEPATH		4		//grapple path is obstructed
+#define RESULTTYPE_INSOLIDAREA			8		//stuck in solid area, this is bad
+
+//structure used to initialize the movement state
+//the or_moveflags MFL_ONGROUND, MFL_TELEPORTED and MFL_WATERJUMP come from the playerstate
+typedef struct bot_initmove_s
+{
+	vec3_t origin;				//origin of the bot
+	vec3_t velocity;			//velocity of the bot
+	vec3_t viewoffset;			//view offset
+	int entitynum;				//entity number of the bot
+	int client;					//client number of the bot
+	float thinktime;			//time the bot thinks
+	int presencetype;			//presencetype of the bot
+	vec3_t viewangles;			//view angles of the bot
+	int or_moveflags;			//values ored to the movement flags
+} bot_initmove_t;
+
+//NOTE: the ideal_viewangles are only valid if MFL_MOVEMENTVIEW is set
+typedef struct bot_moveresult_s
+{
+	int failure;				//true if movement failed all together
+	int type;					//failure or blocked type
+	int blocked;				//true if blocked by an entity
+	int blockentity;			//entity blocking the bot
+	int traveltype;				//last executed travel type
+	int flags;					//result flags
+	int weapon;					//weapon used for movement
+	vec3_t movedir;				//movement direction
+	vec3_t ideal_viewangles;	//ideal viewangles for the movement
+} bot_moveresult_t;
+
+// bk001204: from code/botlib/be_ai_move.c
+// TTimo 04/12/2001 was moved here to avoid dup defines
+typedef struct bot_avoidspot_s
+{
+	vec3_t origin;
+	float radius;
+	int type;
+} bot_avoidspot_t;
+
+//resets the whole move state
+void BotResetMoveState(int movestate);
+//moves the bot to the given goal
+void BotMoveToGoal(bot_moveresult_t *result, int movestate, bot_goal_t *goal, int travelflags);
+//moves the bot in the specified direction using the specified type of movement
+int BotMoveInDirection(int movestate, vec3_t dir, float speed, int type);
+//reset avoid reachability
+void BotResetAvoidReach(int movestate);
+//resets the last avoid reachability
+void BotResetLastAvoidReach(int movestate);
+//returns a reachability area if the origin is in one
+int BotReachabilityArea(vec3_t origin, int client);
+//view target based on movement
+int BotMovementViewTarget(int movestate, bot_goal_t *goal, int travelflags, float lookahead, vec3_t target);
+//predict the position of a player based on movement towards a goal
+int BotPredictVisiblePosition(vec3_t origin, int areanum, bot_goal_t *goal, int travelflags, vec3_t target);
+//returns the handle of a newly allocated movestate
+int BotAllocMoveState(void);
+//frees the movestate with the given handle
+void BotFreeMoveState(int handle);
+//initialize movement state before performing any movement
+void BotInitMoveState(int handle, bot_initmove_t *initmove);
+//add a spot to avoid (if type == AVOID_CLEAR all spots are removed)
+void BotAddAvoidSpot(int movestate, vec3_t origin, float radius, int type);
+//must be called every map change
+void BotSetBrushModelTypes(void);
+//setup movement AI
+int BotSetupMoveAI(void);
+//shutdown movement AI
+void BotShutdownMoveAI(void);
+
diff --git a/codemp/game/be_ai_weap.h b/codemp/game/be_ai_weap.h
new file mode 100644
index 0000000..09f2e15
--- /dev/null
+++ b/codemp/game/be_ai_weap.h
@@ -0,0 +1,88 @@
+// Copyright (C) 1999-2000 Id Software, Inc.
+//
+
+/*****************************************************************************
+ * name:		be_ai_weap.h
+ *
+ * desc:		weapon AI
+ *
+ * $Archive: /source/code/botlib/be_ai_weap.h $
+ * $Author: osman $ 
+ * $Revision: 1.4 $
+ * $Modtime: 10/05/99 3:32p $
+ * $Date: 2003/03/15 23:44:00 $
+ *
+ *****************************************************************************/
+
+//projectile flags
+#define PFL_WINDOWDAMAGE			1		//projectile damages through window
+#define PFL_RETURN					2		//set when projectile returns to owner
+//weapon flags
+#define WFL_FIRERELEASED			1		//set when projectile is fired with key-up event
+//damage types
+#define DAMAGETYPE_IMPACT			1		//damage on impact
+#define DAMAGETYPE_RADIAL			2		//radial damage
+#define DAMAGETYPE_VISIBLE			4		//damage to all entities visible to the projectile
+
+typedef struct projectileinfo_s
+{
+	char name[MAX_STRINGFIELD];
+	char model[MAX_STRINGFIELD];
+	int flags;
+	float gravity;
+	int damage;
+	float radius;
+	int visdamage;
+	int damagetype;
+	int healthinc;
+	float push;
+	float detonation;
+	float bounce;
+	float bouncefric;
+	float bouncestop;
+} projectileinfo_t;
+
+typedef struct weaponinfo_s
+{
+	int valid;					//true if the weapon info is valid
+	int number;									//number of the weapon
+	char name[MAX_STRINGFIELD];
+	char model[MAX_STRINGFIELD];
+	int level;
+	int weaponindex;
+	int flags;
+	char projectile[MAX_STRINGFIELD];
+	int numprojectiles;
+	float hspread;
+	float vspread;
+	float speed;
+	float acceleration;
+	vec3_t recoil;
+	vec3_t offset;
+	vec3_t angleoffset;
+	float extrazvelocity;
+	int ammoamount;
+	int ammoindex;
+	float activate;
+	float reload;
+	float spinup;
+	float spindown;
+	projectileinfo_t proj;						//pointer to the used projectile
+} weaponinfo_t;
+
+//setup the weapon AI
+int BotSetupWeaponAI(void);
+//shut down the weapon AI
+void BotShutdownWeaponAI(void);
+//returns the best weapon to fight with
+int BotChooseBestFightWeapon(int weaponstate, int *inventory);
+//returns the information of the current weapon
+void BotGetWeaponInfo(int weaponstate, int weapon, weaponinfo_t *weaponinfo);
+//loads the weapon weights
+int BotLoadWeaponWeights(int weaponstate, char *filename);
+//returns a handle to a newly allocated weapon state
+int BotAllocWeaponState(void);
+//frees the weapon state
+void BotFreeWeaponState(int weaponstate);
+//resets the whole weapon state
+void BotResetWeaponState(int weaponstate);
diff --git a/codemp/game/be_ea.h b/codemp/game/be_ea.h
new file mode 100644
index 0000000..fb9918f
--- /dev/null
+++ b/codemp/game/be_ea.h
@@ -0,0 +1,52 @@
+// Copyright (C) 1999-2000 Id Software, Inc.
+//
+
+/*****************************************************************************
+ * name:		be_ea.h
+ *
+ * desc:		elementary actions
+ *
+ * $Archive: /source/code/botlib/be_ea.h $
+ * $Author: osman $ 
+ * $Revision: 1.4 $
+ * $Modtime: 10/05/99 3:32p $
+ * $Date: 2003/03/15 23:44:00 $
+ *
+ *****************************************************************************/
+
+//ClientCommand elementary actions
+void EA_Say(int client, char *str);
+void EA_SayTeam(int client, char *str);
+void EA_Command(int client, char *command );
+
+void EA_Action(int client, int action);
+void EA_Crouch(int client);
+void EA_Walk(int client);
+void EA_MoveUp(int client);
+void EA_MoveDown(int client);
+void EA_MoveForward(int client);
+void EA_MoveBack(int client);
+void EA_MoveLeft(int client);
+void EA_MoveRight(int client);
+void EA_Attack(int client);
+void EA_Alt_Attack(int client);
+void EA_ForcePower(int client);
+void EA_Respawn(int client);
+void EA_Talk(int client);
+void EA_Gesture(int client);
+void EA_Use(int client);
+
+//regular elementary actions
+void EA_SelectWeapon(int client, int weapon);
+void EA_Jump(int client);
+void EA_DelayedJump(int client);
+void EA_Move(int client, vec3_t dir, float speed);
+void EA_View(int client, vec3_t viewangles);
+
+//send regular input to the server
+void EA_EndRegular(int client, float thinktime);
+void EA_GetInput(int client, float thinktime, bot_input_t *input);
+void EA_ResetInput(int client);
+//setup and shutdown routines
+int EA_Setup(void);
+void EA_Shutdown(void);
diff --git a/codemp/game/bg_g2_utils.c b/codemp/game/bg_g2_utils.c
new file mode 100644
index 0000000..a3384ef
--- /dev/null
+++ b/codemp/game/bg_g2_utils.c
@@ -0,0 +1,124 @@
+// Copyright (C) 1999-2000 Id Software, Inc.
+//
+// bg_g2_utils.c -- both games misc functions, all completely stateless
+
+#include "q_shared.h"
+#include "bg_public.h"
+#include "bg_strap.h"
+
+#ifdef QAGAME
+#include "g_local.h"
+#endif
+
+#ifdef UI_EXPORTS
+#include "../ui/ui_local.h"
+#endif
+
+#ifndef UI_EXPORTS
+#ifndef QAGAME
+#include "../cgame/cg_local.h"
+#endif
+#endif
+
+#include "../namespace_begin.h"
+
+void BG_AttachToRancor( void *ghoul2,
+					   float rancYaw,
+					   vec3_t rancOrigin,
+					   int time,
+					   qhandle_t *modelList, 
+					   vec3_t modelScale,
+					   qboolean inMouth,
+					   vec3_t out_origin,
+					   vec3_t out_angles,
+					   vec3_t out_axis[3] )
+{
+	mdxaBone_t	boltMatrix;
+	int boltIndex;
+	vec3_t rancAngles;
+	vec3_t temp_angles;
+	// Getting the bolt here
+	if ( inMouth )
+	{//in mouth
+		boltIndex = trap_G2API_AddBolt(ghoul2, 0, "jaw_bone");
+	}
+	else
+	{//in right hand
+		boltIndex = trap_G2API_AddBolt(ghoul2, 0, "*r_hand");
+	}
+	VectorSet( rancAngles, 0, rancYaw, 0 );
+	trap_G2API_GetBoltMatrix( ghoul2, 0, boltIndex, 
+			&boltMatrix, rancAngles, rancOrigin, time,
+			modelList, modelScale );
+	// Storing ent position, bolt position, and bolt axis
+	if ( out_origin )
+	{
+		BG_GiveMeVectorFromMatrix( &boltMatrix, ORIGIN, out_origin );
+	}
+	if ( out_axis )
+	{
+		if ( inMouth )
+		{//in mouth
+			BG_GiveMeVectorFromMatrix( &boltMatrix, POSITIVE_Z, out_axis[0] );
+			BG_GiveMeVectorFromMatrix( &boltMatrix, NEGATIVE_Y, out_axis[1] );
+			BG_GiveMeVectorFromMatrix( &boltMatrix, NEGATIVE_X, out_axis[2] );
+		}
+		else
+		{//in hand
+			BG_GiveMeVectorFromMatrix( &boltMatrix, NEGATIVE_Y, out_axis[0] );
+			BG_GiveMeVectorFromMatrix( &boltMatrix, POSITIVE_X, out_axis[1] );
+			BG_GiveMeVectorFromMatrix( &boltMatrix, POSITIVE_Z, out_axis[2] );
+		}
+		//FIXME: this is messing up our axis and turning us inside-out?
+		if ( out_angles )
+		{
+			vectoangles( out_axis[0], out_angles );
+			vectoangles( out_axis[2], temp_angles );
+			out_angles[ROLL] = -temp_angles[PITCH];
+		}
+	}
+	else if ( out_angles )
+	{
+		vec3_t temp_axis[3];
+		if ( inMouth )
+		{//in mouth
+			BG_GiveMeVectorFromMatrix( &boltMatrix, POSITIVE_Z, temp_axis[0] );
+			BG_GiveMeVectorFromMatrix( &boltMatrix, NEGATIVE_X, temp_axis[2] );
+		}
+		else
+		{//in hand
+			BG_GiveMeVectorFromMatrix( &boltMatrix, NEGATIVE_Y, temp_axis[0] );
+			BG_GiveMeVectorFromMatrix( &boltMatrix, POSITIVE_Z, temp_axis[2] );
+		}
+		//FIXME: this is messing up our axis and turning us inside-out?
+		vectoangles( temp_axis[0], out_angles );
+		vectoangles( temp_axis[2], temp_angles );
+		out_angles[ROLL] = -temp_angles[PITCH];
+	}
+}
+
+#define	MAX_VARIANTS 8
+qboolean BG_GetRootSurfNameWithVariant( void *ghoul2, const char *rootSurfName, char *returnSurfName, int returnSize )
+{
+	if ( !ghoul2 || !trap_G2API_GetSurfaceRenderStatus( ghoul2, 0, rootSurfName ) )
+	{//see if the basic name without variants is on
+		Q_strncpyz( returnSurfName, rootSurfName, returnSize );
+		return qtrue;
+	}
+	else
+	{//check variants
+		int i;
+		for ( i = 0; i < MAX_VARIANTS; i++ )
+		{
+			Com_sprintf( returnSurfName, returnSize, "%s%c", rootSurfName, 'a'+i );
+			if ( !trap_G2API_GetSurfaceRenderStatus( ghoul2, 0, returnSurfName ) )
+			{
+				return qtrue;
+			}
+		}
+	}
+	Q_strncpyz( returnSurfName, rootSurfName, returnSize );
+	return qfalse;
+}
+
+#include "../namespace_end.h"
diff --git a/codemp/game/bg_lib.c b/codemp/game/bg_lib.c
new file mode 100644
index 0000000..e0bb530
--- /dev/null
+++ b/codemp/game/bg_lib.c
@@ -0,0 +1,1318 @@
+// Copyright (C) 1999-2000 Id Software, Inc.
+//
+// Copyright (C) 1999-2000 Id Software, Inc.
+//
+// bg_lib,c -- standard C library replacement routines used by code
+// compiled for the virtual machine
+
+#include "q_shared.h"
+
+/*-
+ * Copyright (c) 1992, 1993
+ *	The Regents of the University of California.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *	This product includes software developed by the University of
+ *	California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#if defined(LIBC_SCCS) && !defined(lint)
+#if 0
+static char sccsid[] = "@(#)qsort.c	8.1 (Berkeley) 6/4/93";
+#endif
+static const char rcsid[] =
+	"$Id: bg_lib.c,v 1.4 2003/03/15 23:44:00 osman Exp $";
+#endif /* LIBC_SCCS and not lint */
+
+// bk001127 - needed for DLL's
+#if !defined( Q3_VM )
+typedef int		 cmp_t(const void *, const void *);
+#endif
+
+static char* med3(char *, char *, char *, cmp_t *);
+static void	 swapfunc(char *, char *, int, int);
+
+#ifndef min
+#define min(a, b)	(a) < (b) ? a : b
+#endif
+
+/*
+ * Qsort routine from Bentley & McIlroy's "Engineering a Sort Function".
+ */
+#define swapcode(TYPE, parmi, parmj, n) { 		\
+	long i = (n) / sizeof (TYPE); 			\
+	register TYPE *pi = (TYPE *) (parmi); 		\
+	register TYPE *pj = (TYPE *) (parmj); 		\
+	do { 						\
+		register TYPE	t = *pi;		\
+		*pi++ = *pj;				\
+		*pj++ = t;				\
+        } while (--i > 0);				\
+}
+
+#define SWAPINIT(a, es) swaptype = ((char *)a - (char *)0) % sizeof(long) || \
+	es % sizeof(long) ? 2 : es == sizeof(long)? 0 : 1;
+
+static void swapfunc( char* a, char* b, int n, int swaptype)
+{
+	if(swaptype <= 1)
+		swapcode(long, a, b, n)
+	else
+		swapcode(char, a, b, n)
+}
+
+#define swap(a, b)					\
+	if (swaptype == 0) {				\
+		long t = *(long *)(a);			\
+		*(long *)(a) = *(long *)(b);		\
+		*(long *)(b) = t;			\
+	} else						\
+		swapfunc(a, b, es, swaptype)
+
+#define vecswap(a, b, n) 	if ((n) > 0) swapfunc(a, b, n, swaptype)
+
+static char *med3(char* a, char* b, char* c, cmp_t* cmp)
+{
+	return cmp(a, b) < 0 ?
+	       (cmp(b, c) < 0 ? b : (cmp(a, c) < 0 ? c : a ))
+              :(cmp(b, c) > 0 ? b : (cmp(a, c) < 0 ? a : c ));
+}
+
+void qsort( void* a, size_t n, size_t es, cmp_t* cmp)
+{
+	char *pa, *pb, *pc, *pd, *pl, *pm, *pn;
+	int d, r, swaptype, swap_cnt;
+
+loop:	SWAPINIT(a, es);
+	swap_cnt = 0;
+	if (n < 7) {
+		for (pm = (char *)a + es; pm < (char *)a + n * es; pm += es)
+			for (pl = pm; pl > (char *)a && cmp(pl - es, pl) > 0;
+			     pl -= es)
+				swap(pl, pl - es);
+		return;
+	}
+	pm = (char *)a + (n / 2) * es;
+	if (n > 7) {
+		pl = a;
+		pn = (char *)a + (n - 1) * es;
+		if (n > 40) {
+			d = (n / 8) * es;
+			pl = med3(pl, pl + d, pl + 2 * d, cmp);
+			pm = med3(pm - d, pm, pm + d, cmp);
+			pn = med3(pn - 2 * d, pn - d, pn, cmp);
+		}
+		pm = med3(pl, pm, pn, cmp);
+	}
+	swap(a, pm);
+	pa = pb = (char *)a + es;
+
+	pc = pd = (char *)a + (n - 1) * es;
+	for (;;) {
+		while (pb <= pc && (r = cmp(pb, a)) <= 0) {
+			if (r == 0) {
+				swap_cnt = 1;
+				swap(pa, pb);
+				pa += es;
+			}
+			pb += es;
+		}
+		while (pb <= pc && (r = cmp(pc, a)) >= 0) {
+			if (r == 0) {
+				swap_cnt = 1;
+				swap(pc, pd);
+				pd -= es;
+			}
+			pc -= es;
+		}
+		if (pb > pc)
+			break;
+		swap(pb, pc);
+		swap_cnt = 1;
+		pb += es;
+		pc -= es;
+	}
+	if (swap_cnt == 0) {  /* Switch to insertion sort */
+		for (pm = (char *)a + es; pm < (char *)a + n * es; pm += es)
+			for (pl = pm; pl > (char *)a && cmp(pl - es, pl) > 0;
+			     pl -= es)
+				swap(pl, pl - es);
+		return;
+	}
+
+	pn = (char *)a + n * es;
+	r = min(pa - (char *)a, pb - pa);
+	vecswap(a, pb - r, r);
+	r = min(pd - pc, pn - pd - es);
+	vecswap(pb, pn - r, r);
+	if ((r = pb - pa) > es)
+		qsort(a, r / es, es, cmp);
+	if ((r = pd - pc) > es) {
+		/* Iterate rather than recurse to save stack space */
+		a = pn - r;
+		n = r / es;
+		goto loop;
+	}
+/*		qsort(pn - r, r / es, es, cmp);*/
+}
+
+//==================================================================================
+
+
+// this file is excluded from release builds because of intrinsics
+
+// bk001211 - gcc errors on compiling strcpy:  parse error before `__extension__'
+#if defined ( Q3_VM )
+
+size_t strlen( const char *string ) {
+	const char	*s;
+
+	s = string;
+	while ( *s ) {
+		s++;
+	}
+	return s - string;
+}
+
+
+char *strcat( char *strDestination, const char *strSource ) {
+	char	*s;
+
+	s = strDestination;
+	while ( *s ) {
+		s++;
+	}
+	while ( *strSource ) {
+		*s++ = *strSource++;
+	}
+	*s = 0;
+	return strDestination;
+}
+
+char *strcpy( char *strDestination, const char *strSource ) {
+	char *s;
+
+	s = strDestination;
+	while ( *strSource ) {
+		*s++ = *strSource++;
+	}
+	*s = 0;
+	return strDestination;
+}
+
+
+int strcmp( const char *string1, const char *string2 ) {
+	while ( *string1 == *string2 && *string1 && *string2 ) {
+		string1++;
+		string2++;
+	}
+	return *string1 - *string2;
+}
+
+
+char *strchr( const char *string, int c ) {
+	while ( *string ) {
+		if ( *string == c ) {
+			return ( char * )string;
+		}
+		string++;
+	}
+	return (char *)0;
+}
+
+char *strstr( const char *string, const char *strCharSet ) {
+	while ( *string ) {
+		int		i;
+
+		for ( i = 0 ; strCharSet[i] ; i++ ) {
+			if ( string[i] != strCharSet[i] ) {
+				break;
+			}
+		}
+		if ( !strCharSet[i] ) {
+			return (char *)string;
+		}
+		string++;
+	}
+	return (char *)0;
+}
+#endif // bk001211
+
+// bk001120 - presumably needed for Mac
+//#if !defined(_MSC_VER) && !defined(__linux__)
+// bk001127 - undid undo
+#if defined ( Q3_VM )
+int tolower( int c ) {
+	if ( c >= 'A' && c <= 'Z' ) {
+		c += 'a' - 'A';
+	}
+	return c;
+}
+
+
+int toupper( int c ) {
+	if ( c >= 'a' && c <= 'z' ) {
+		c += 'A' - 'a';
+	}
+	return c;
+}
+
+#endif
+//#ifndef _MSC_VER
+
+void *memmove( void *dest, const void *src, size_t count ) {
+	int		i;
+
+	if ( dest > src ) {
+		for ( i = count-1 ; i >= 0 ; i-- ) {
+			((char *)dest)[i] = ((char *)src)[i];
+		}
+	} else {
+		for ( i = 0 ; i < count ; i++ ) {
+			((char *)dest)[i] = ((char *)src)[i];
+		}
+	}
+	return dest;
+}
+
+
+#if 0
+
+double floor( double x ) {
+	return (int)(x + 0x40000000) - 0x40000000;
+}
+
+void *memset( void *dest, int c, size_t count ) {
+	while ( count-- ) {
+		((char *)dest)[count] = c;
+	}
+	return dest;
+}
+
+void *memcpy( void *dest, const void *src, size_t count ) {
+	while ( count-- ) {
+		((char *)dest)[count] = ((char *)src)[count];
+	}
+	return dest;
+}
+
+char *strncpy( char *strDest, const char *strSource, size_t count ) {
+	char	*s;
+
+	s = strDest;
+	while ( *strSource && count ) {
+		*s++ = *strSource++;
+		count--;
+	}
+	while ( count-- ) {
+		*s++ = 0;
+	}
+	return strDest;
+}
+
+double sqrt( double x ) {
+	float	y;
+	float	delta;
+	float	maxError;
+
+	if ( x <= 0 ) {
+		return 0;
+	}
+
+	// initial guess
+	y = x / 2;
+
+	// refine
+	maxError = x * 0.001;
+
+	do {
+		delta = ( y * y ) - x;
+		y -= delta / ( 2 * y );
+	} while ( delta > maxError || delta < -maxError );
+
+	return y;
+}
+
+
+float sintable[1024] = {
+0.000000,0.001534,0.003068,0.004602,0.006136,0.007670,0.009204,0.010738,
+0.012272,0.013805,0.015339,0.016873,0.018407,0.019940,0.021474,0.023008,
+0.024541,0.026075,0.027608,0.029142,0.030675,0.032208,0.033741,0.035274,
+0.036807,0.038340,0.039873,0.041406,0.042938,0.044471,0.046003,0.047535,
+0.049068,0.050600,0.052132,0.053664,0.055195,0.056727,0.058258,0.059790,
+0.061321,0.062852,0.064383,0.065913,0.067444,0.068974,0.070505,0.072035,
+0.073565,0.075094,0.076624,0.078153,0.079682,0.081211,0.082740,0.084269,
+0.085797,0.087326,0.088854,0.090381,0.091909,0.093436,0.094963,0.096490,
+0.098017,0.099544,0.101070,0.102596,0.104122,0.105647,0.107172,0.108697,
+0.110222,0.111747,0.113271,0.114795,0.116319,0.117842,0.119365,0.120888,
+0.122411,0.123933,0.125455,0.126977,0.128498,0.130019,0.131540,0.133061,
+0.134581,0.136101,0.137620,0.139139,0.140658,0.142177,0.143695,0.145213,
+0.146730,0.148248,0.149765,0.151281,0.152797,0.154313,0.155828,0.157343,
+0.158858,0.160372,0.161886,0.163400,0.164913,0.166426,0.167938,0.169450,
+0.170962,0.172473,0.173984,0.175494,0.177004,0.178514,0.180023,0.181532,
+0.183040,0.184548,0.186055,0.187562,0.189069,0.190575,0.192080,0.193586,
+0.195090,0.196595,0.198098,0.199602,0.201105,0.202607,0.204109,0.205610,
+0.207111,0.208612,0.210112,0.211611,0.213110,0.214609,0.216107,0.217604,
+0.219101,0.220598,0.222094,0.223589,0.225084,0.226578,0.228072,0.229565,
+0.231058,0.232550,0.234042,0.235533,0.237024,0.238514,0.240003,0.241492,
+0.242980,0.244468,0.245955,0.247442,0.248928,0.250413,0.251898,0.253382,
+0.254866,0.256349,0.257831,0.259313,0.260794,0.262275,0.263755,0.265234,
+0.266713,0.268191,0.269668,0.271145,0.272621,0.274097,0.275572,0.277046,
+0.278520,0.279993,0.281465,0.282937,0.284408,0.285878,0.287347,0.288816,
+0.290285,0.291752,0.293219,0.294685,0.296151,0.297616,0.299080,0.300543,
+0.302006,0.303468,0.304929,0.306390,0.307850,0.309309,0.310767,0.312225,
+0.313682,0.315138,0.316593,0.318048,0.319502,0.320955,0.322408,0.323859,
+0.325310,0.326760,0.328210,0.329658,0.331106,0.332553,0.334000,0.335445,
+0.336890,0.338334,0.339777,0.341219,0.342661,0.344101,0.345541,0.346980,
+0.348419,0.349856,0.351293,0.352729,0.354164,0.355598,0.357031,0.358463,
+0.359895,0.361326,0.362756,0.364185,0.365613,0.367040,0.368467,0.369892,
+0.371317,0.372741,0.374164,0.375586,0.377007,0.378428,0.379847,0.381266,
+0.382683,0.384100,0.385516,0.386931,0.388345,0.389758,0.391170,0.392582,
+0.393992,0.395401,0.396810,0.398218,0.399624,0.401030,0.402435,0.403838,
+0.405241,0.406643,0.408044,0.409444,0.410843,0.412241,0.413638,0.415034,
+0.416430,0.417824,0.419217,0.420609,0.422000,0.423390,0.424780,0.426168,
+0.427555,0.428941,0.430326,0.431711,0.433094,0.434476,0.435857,0.437237,
+0.438616,0.439994,0.441371,0.442747,0.444122,0.445496,0.446869,0.448241,
+0.449611,0.450981,0.452350,0.453717,0.455084,0.456449,0.457813,0.459177,
+0.460539,0.461900,0.463260,0.464619,0.465976,0.467333,0.468689,0.470043,
+0.471397,0.472749,0.474100,0.475450,0.476799,0.478147,0.479494,0.480839,
+0.482184,0.483527,0.484869,0.486210,0.487550,0.488889,0.490226,0.491563,
+0.492898,0.494232,0.495565,0.496897,0.498228,0.499557,0.500885,0.502212,
+0.503538,0.504863,0.506187,0.507509,0.508830,0.510150,0.511469,0.512786,
+0.514103,0.515418,0.516732,0.518045,0.519356,0.520666,0.521975,0.523283,
+0.524590,0.525895,0.527199,0.528502,0.529804,0.531104,0.532403,0.533701,
+0.534998,0.536293,0.537587,0.538880,0.540171,0.541462,0.542751,0.544039,
+0.545325,0.546610,0.547894,0.549177,0.550458,0.551738,0.553017,0.554294,
+0.555570,0.556845,0.558119,0.559391,0.560662,0.561931,0.563199,0.564466,
+0.565732,0.566996,0.568259,0.569521,0.570781,0.572040,0.573297,0.574553,
+0.575808,0.577062,0.578314,0.579565,0.580814,0.582062,0.583309,0.584554,
+0.585798,0.587040,0.588282,0.589521,0.590760,0.591997,0.593232,0.594466,
+0.595699,0.596931,0.598161,0.599389,0.600616,0.601842,0.603067,0.604290,
+0.605511,0.606731,0.607950,0.609167,0.610383,0.611597,0.612810,0.614022,
+0.615232,0.616440,0.617647,0.618853,0.620057,0.621260,0.622461,0.623661,
+0.624859,0.626056,0.627252,0.628446,0.629638,0.630829,0.632019,0.633207,
+0.634393,0.635578,0.636762,0.637944,0.639124,0.640303,0.641481,0.642657,
+0.643832,0.645005,0.646176,0.647346,0.648514,0.649681,0.650847,0.652011,
+0.653173,0.654334,0.655493,0.656651,0.657807,0.658961,0.660114,0.661266,
+0.662416,0.663564,0.664711,0.665856,0.667000,0.668142,0.669283,0.670422,
+0.671559,0.672695,0.673829,0.674962,0.676093,0.677222,0.678350,0.679476,
+0.680601,0.681724,0.682846,0.683965,0.685084,0.686200,0.687315,0.688429,
+0.689541,0.690651,0.691759,0.692866,0.693971,0.695075,0.696177,0.697278,
+0.698376,0.699473,0.700569,0.701663,0.702755,0.703845,0.704934,0.706021,
+0.707107,0.708191,0.709273,0.710353,0.711432,0.712509,0.713585,0.714659,
+0.715731,0.716801,0.717870,0.718937,0.720003,0.721066,0.722128,0.723188,
+0.724247,0.725304,0.726359,0.727413,0.728464,0.729514,0.730563,0.731609,
+0.732654,0.733697,0.734739,0.735779,0.736817,0.737853,0.738887,0.739920,
+0.740951,0.741980,0.743008,0.744034,0.745058,0.746080,0.747101,0.748119,
+0.749136,0.750152,0.751165,0.752177,0.753187,0.754195,0.755201,0.756206,
+0.757209,0.758210,0.759209,0.760207,0.761202,0.762196,0.763188,0.764179,
+0.765167,0.766154,0.767139,0.768122,0.769103,0.770083,0.771061,0.772036,
+0.773010,0.773983,0.774953,0.775922,0.776888,0.777853,0.778817,0.779778,
+0.780737,0.781695,0.782651,0.783605,0.784557,0.785507,0.786455,0.787402,
+0.788346,0.789289,0.790230,0.791169,0.792107,0.793042,0.793975,0.794907,
+0.795837,0.796765,0.797691,0.798615,0.799537,0.800458,0.801376,0.802293,
+0.803208,0.804120,0.805031,0.805940,0.806848,0.807753,0.808656,0.809558,
+0.810457,0.811355,0.812251,0.813144,0.814036,0.814926,0.815814,0.816701,
+0.817585,0.818467,0.819348,0.820226,0.821103,0.821977,0.822850,0.823721,
+0.824589,0.825456,0.826321,0.827184,0.828045,0.828904,0.829761,0.830616,
+0.831470,0.832321,0.833170,0.834018,0.834863,0.835706,0.836548,0.837387,
+0.838225,0.839060,0.839894,0.840725,0.841555,0.842383,0.843208,0.844032,
+0.844854,0.845673,0.846491,0.847307,0.848120,0.848932,0.849742,0.850549,
+0.851355,0.852159,0.852961,0.853760,0.854558,0.855354,0.856147,0.856939,
+0.857729,0.858516,0.859302,0.860085,0.860867,0.861646,0.862424,0.863199,
+0.863973,0.864744,0.865514,0.866281,0.867046,0.867809,0.868571,0.869330,
+0.870087,0.870842,0.871595,0.872346,0.873095,0.873842,0.874587,0.875329,
+0.876070,0.876809,0.877545,0.878280,0.879012,0.879743,0.880471,0.881197,
+0.881921,0.882643,0.883363,0.884081,0.884797,0.885511,0.886223,0.886932,
+0.887640,0.888345,0.889048,0.889750,0.890449,0.891146,0.891841,0.892534,
+0.893224,0.893913,0.894599,0.895284,0.895966,0.896646,0.897325,0.898001,
+0.898674,0.899346,0.900016,0.900683,0.901349,0.902012,0.902673,0.903332,
+0.903989,0.904644,0.905297,0.905947,0.906596,0.907242,0.907886,0.908528,
+0.909168,0.909806,0.910441,0.911075,0.911706,0.912335,0.912962,0.913587,
+0.914210,0.914830,0.915449,0.916065,0.916679,0.917291,0.917901,0.918508,
+0.919114,0.919717,0.920318,0.920917,0.921514,0.922109,0.922701,0.923291,
+0.923880,0.924465,0.925049,0.925631,0.926210,0.926787,0.927363,0.927935,
+0.928506,0.929075,0.929641,0.930205,0.930767,0.931327,0.931884,0.932440,
+0.932993,0.933544,0.934093,0.934639,0.935184,0.935726,0.936266,0.936803,
+0.937339,0.937872,0.938404,0.938932,0.939459,0.939984,0.940506,0.941026,
+0.941544,0.942060,0.942573,0.943084,0.943593,0.944100,0.944605,0.945107,
+0.945607,0.946105,0.946601,0.947094,0.947586,0.948075,0.948561,0.949046,
+0.949528,0.950008,0.950486,0.950962,0.951435,0.951906,0.952375,0.952842,
+0.953306,0.953768,0.954228,0.954686,0.955141,0.955594,0.956045,0.956494,
+0.956940,0.957385,0.957826,0.958266,0.958703,0.959139,0.959572,0.960002,
+0.960431,0.960857,0.961280,0.961702,0.962121,0.962538,0.962953,0.963366,
+0.963776,0.964184,0.964590,0.964993,0.965394,0.965793,0.966190,0.966584,
+0.966976,0.967366,0.967754,0.968139,0.968522,0.968903,0.969281,0.969657,
+0.970031,0.970403,0.970772,0.971139,0.971504,0.971866,0.972226,0.972584,
+0.972940,0.973293,0.973644,0.973993,0.974339,0.974684,0.975025,0.975365,
+0.975702,0.976037,0.976370,0.976700,0.977028,0.977354,0.977677,0.977999,
+0.978317,0.978634,0.978948,0.979260,0.979570,0.979877,0.980182,0.980485,
+0.980785,0.981083,0.981379,0.981673,0.981964,0.982253,0.982539,0.982824,
+0.983105,0.983385,0.983662,0.983937,0.984210,0.984480,0.984749,0.985014,
+0.985278,0.985539,0.985798,0.986054,0.986308,0.986560,0.986809,0.987057,
+0.987301,0.987544,0.987784,0.988022,0.988258,0.988491,0.988722,0.988950,
+0.989177,0.989400,0.989622,0.989841,0.990058,0.990273,0.990485,0.990695,
+0.990903,0.991108,0.991311,0.991511,0.991710,0.991906,0.992099,0.992291,
+0.992480,0.992666,0.992850,0.993032,0.993212,0.993389,0.993564,0.993737,
+0.993907,0.994075,0.994240,0.994404,0.994565,0.994723,0.994879,0.995033,
+0.995185,0.995334,0.995481,0.995625,0.995767,0.995907,0.996045,0.996180,
+0.996313,0.996443,0.996571,0.996697,0.996820,0.996941,0.997060,0.997176,
+0.997290,0.997402,0.997511,0.997618,0.997723,0.997825,0.997925,0.998023,
+0.998118,0.998211,0.998302,0.998390,0.998476,0.998559,0.998640,0.998719,
+0.998795,0.998870,0.998941,0.999011,0.999078,0.999142,0.999205,0.999265,
+0.999322,0.999378,0.999431,0.999481,0.999529,0.999575,0.999619,0.999660,
+0.999699,0.999735,0.999769,0.999801,0.999831,0.999858,0.999882,0.999905,
+0.999925,0.999942,0.999958,0.999971,0.999981,0.999989,0.999995,0.999999
+};
+
+double sin( double x ) {
+	int	index;
+	int	quad;
+
+	index = 1024 * x / (M_PI * 0.5);
+	quad = ( index >> 10 ) & 3;
+	index &= 1023;
+	switch ( quad ) {
+	case 0:
+		return sintable[index];
+	case 1:
+		return sintable[1023-index];
+	case 2:
+		return -sintable[index];
+	case 3:
+		return -sintable[1023-index];
+	}
+	return 0;
+}
+
+
+double cos( double x ) {
+	int	index;
+	int	quad;
+
+	index = 1024 * x / (M_PI * 0.5);
+	quad = ( index >> 10 ) & 3;
+	index &= 1023;
+	switch ( quad ) {
+	case 3:
+		return sintable[index];
+	case 0:
+		return sintable[1023-index];
+	case 1:
+		return -sintable[index];
+	case 2:
+		return -sintable[1023-index];
+	}
+	return 0;
+}
+
+
+/*
+void create_acostable( void ) {
+	int i;
+	FILE *fp;
+	float a;
+
+	fp = fopen("c:\\acostable.txt", "w");
+	fprintf(fp, "float acostable[] = {");
+	for (i = 0; i < 1024; i++) {
+		if (!(i & 7))
+			fprintf(fp, "\n");
+		a = acos( (float) -1 + i / 512 );
+		fprintf(fp, "%1.8f,", a);
+	}
+	fprintf(fp, "\n}\n");
+	fclose(fp);
+}
+*/
+
+float acostable[] = {
+3.14159265,3.07908248,3.05317551,3.03328655,3.01651113,3.00172442,2.98834964,2.97604422,
+2.96458497,2.95381690,2.94362719,2.93393068,2.92466119,2.91576615,2.90720289,2.89893629,
+2.89093699,2.88318015,2.87564455,2.86831188,2.86116621,2.85419358,2.84738169,2.84071962,
+2.83419760,2.82780691,2.82153967,2.81538876,2.80934770,2.80341062,2.79757211,2.79182724,
+2.78617145,2.78060056,2.77511069,2.76969824,2.76435988,2.75909250,2.75389319,2.74875926,
+2.74368816,2.73867752,2.73372510,2.72882880,2.72398665,2.71919677,2.71445741,2.70976688,
+2.70512362,2.70052613,2.69597298,2.69146283,2.68699438,2.68256642,2.67817778,2.67382735,
+2.66951407,2.66523692,2.66099493,2.65678719,2.65261279,2.64847088,2.64436066,2.64028133,
+2.63623214,2.63221238,2.62822133,2.62425835,2.62032277,2.61641398,2.61253138,2.60867440,
+2.60484248,2.60103507,2.59725167,2.59349176,2.58975488,2.58604053,2.58234828,2.57867769,
+2.57502832,2.57139977,2.56779164,2.56420354,2.56063509,2.55708594,2.55355572,2.55004409,
+2.54655073,2.54307530,2.53961750,2.53617701,2.53275354,2.52934680,2.52595650,2.52258238,
+2.51922417,2.51588159,2.51255441,2.50924238,2.50594525,2.50266278,2.49939476,2.49614096,
+2.49290115,2.48967513,2.48646269,2.48326362,2.48007773,2.47690482,2.47374472,2.47059722,
+2.46746215,2.46433933,2.46122860,2.45812977,2.45504269,2.45196720,2.44890314,2.44585034,
+2.44280867,2.43977797,2.43675809,2.43374890,2.43075025,2.42776201,2.42478404,2.42181622,
+2.41885841,2.41591048,2.41297232,2.41004380,2.40712480,2.40421521,2.40131491,2.39842379,
+2.39554173,2.39266863,2.38980439,2.38694889,2.38410204,2.38126374,2.37843388,2.37561237,
+2.37279910,2.36999400,2.36719697,2.36440790,2.36162673,2.35885335,2.35608768,2.35332964,
+2.35057914,2.34783610,2.34510044,2.34237208,2.33965094,2.33693695,2.33423003,2.33153010,
+2.32883709,2.32615093,2.32347155,2.32079888,2.31813284,2.31547337,2.31282041,2.31017388,
+2.30753373,2.30489988,2.30227228,2.29965086,2.29703556,2.29442632,2.29182309,2.28922580,
+2.28663439,2.28404881,2.28146900,2.27889490,2.27632647,2.27376364,2.27120637,2.26865460,
+2.26610827,2.26356735,2.26103177,2.25850149,2.25597646,2.25345663,2.25094195,2.24843238,
+2.24592786,2.24342836,2.24093382,2.23844420,2.23595946,2.23347956,2.23100444,2.22853408,
+2.22606842,2.22360742,2.22115104,2.21869925,2.21625199,2.21380924,2.21137096,2.20893709,
+2.20650761,2.20408248,2.20166166,2.19924511,2.19683280,2.19442469,2.19202074,2.18962092,
+2.18722520,2.18483354,2.18244590,2.18006225,2.17768257,2.17530680,2.17293493,2.17056692,
+2.16820274,2.16584236,2.16348574,2.16113285,2.15878367,2.15643816,2.15409630,2.15175805,
+2.14942338,2.14709226,2.14476468,2.14244059,2.14011997,2.13780279,2.13548903,2.13317865,
+2.13087163,2.12856795,2.12626757,2.12397047,2.12167662,2.11938600,2.11709859,2.11481435,
+2.11253326,2.11025530,2.10798044,2.10570867,2.10343994,2.10117424,2.09891156,2.09665185,
+2.09439510,2.09214129,2.08989040,2.08764239,2.08539725,2.08315496,2.08091550,2.07867884,
+2.07644495,2.07421383,2.07198545,2.06975978,2.06753681,2.06531651,2.06309887,2.06088387,
+2.05867147,2.05646168,2.05425445,2.05204979,2.04984765,2.04764804,2.04545092,2.04325628,
+2.04106409,2.03887435,2.03668703,2.03450211,2.03231957,2.03013941,2.02796159,2.02578610,
+2.02361292,2.02144204,2.01927344,2.01710710,2.01494300,2.01278113,2.01062146,2.00846399,
+2.00630870,2.00415556,2.00200457,1.99985570,1.99770895,1.99556429,1.99342171,1.99128119,
+1.98914271,1.98700627,1.98487185,1.98273942,1.98060898,1.97848051,1.97635399,1.97422942,
+1.97210676,1.96998602,1.96786718,1.96575021,1.96363511,1.96152187,1.95941046,1.95730088,
+1.95519310,1.95308712,1.95098292,1.94888050,1.94677982,1.94468089,1.94258368,1.94048818,
+1.93839439,1.93630228,1.93421185,1.93212308,1.93003595,1.92795046,1.92586659,1.92378433,
+1.92170367,1.91962459,1.91754708,1.91547113,1.91339673,1.91132385,1.90925250,1.90718266,
+1.90511432,1.90304746,1.90098208,1.89891815,1.89685568,1.89479464,1.89273503,1.89067683,
+1.88862003,1.88656463,1.88451060,1.88245794,1.88040664,1.87835668,1.87630806,1.87426076,
+1.87221477,1.87017008,1.86812668,1.86608457,1.86404371,1.86200412,1.85996577,1.85792866,
+1.85589277,1.85385809,1.85182462,1.84979234,1.84776125,1.84573132,1.84370256,1.84167495,
+1.83964848,1.83762314,1.83559892,1.83357582,1.83155381,1.82953289,1.82751305,1.82549429,
+1.82347658,1.82145993,1.81944431,1.81742973,1.81541617,1.81340362,1.81139207,1.80938151,
+1.80737194,1.80536334,1.80335570,1.80134902,1.79934328,1.79733848,1.79533460,1.79333164,
+1.79132959,1.78932843,1.78732817,1.78532878,1.78333027,1.78133261,1.77933581,1.77733985,
+1.77534473,1.77335043,1.77135695,1.76936428,1.76737240,1.76538132,1.76339101,1.76140148,
+1.75941271,1.75742470,1.75543743,1.75345090,1.75146510,1.74948002,1.74749565,1.74551198,
+1.74352900,1.74154672,1.73956511,1.73758417,1.73560389,1.73362426,1.73164527,1.72966692,
+1.72768920,1.72571209,1.72373560,1.72175971,1.71978441,1.71780969,1.71583556,1.71386199,
+1.71188899,1.70991653,1.70794462,1.70597325,1.70400241,1.70203209,1.70006228,1.69809297,
+1.69612416,1.69415584,1.69218799,1.69022062,1.68825372,1.68628727,1.68432127,1.68235571,
+1.68039058,1.67842588,1.67646160,1.67449772,1.67253424,1.67057116,1.66860847,1.66664615,
+1.66468420,1.66272262,1.66076139,1.65880050,1.65683996,1.65487975,1.65291986,1.65096028,
+1.64900102,1.64704205,1.64508338,1.64312500,1.64116689,1.63920905,1.63725148,1.63529416,
+1.63333709,1.63138026,1.62942366,1.62746728,1.62551112,1.62355517,1.62159943,1.61964388,
+1.61768851,1.61573332,1.61377831,1.61182346,1.60986877,1.60791422,1.60595982,1.60400556,
+1.60205142,1.60009739,1.59814349,1.59618968,1.59423597,1.59228235,1.59032882,1.58837536,
+1.58642196,1.58446863,1.58251535,1.58056211,1.57860891,1.57665574,1.57470259,1.57274945,
+1.57079633,1.56884320,1.56689007,1.56493692,1.56298375,1.56103055,1.55907731,1.55712403,
+1.55517069,1.55321730,1.55126383,1.54931030,1.54735668,1.54540297,1.54344917,1.54149526,
+1.53954124,1.53758710,1.53563283,1.53367843,1.53172389,1.52976919,1.52781434,1.52585933,
+1.52390414,1.52194878,1.51999323,1.51803748,1.51608153,1.51412537,1.51216900,1.51021240,
+1.50825556,1.50629849,1.50434117,1.50238360,1.50042576,1.49846765,1.49650927,1.49455060,
+1.49259163,1.49063237,1.48867280,1.48671291,1.48475270,1.48279215,1.48083127,1.47887004,
+1.47690845,1.47494650,1.47298419,1.47102149,1.46905841,1.46709493,1.46513106,1.46316677,
+1.46120207,1.45923694,1.45727138,1.45530538,1.45333893,1.45137203,1.44940466,1.44743682,
+1.44546850,1.44349969,1.44153038,1.43956057,1.43759024,1.43561940,1.43364803,1.43167612,
+1.42970367,1.42773066,1.42575709,1.42378296,1.42180825,1.41983295,1.41785705,1.41588056,
+1.41390346,1.41192573,1.40994738,1.40796840,1.40598877,1.40400849,1.40202755,1.40004594,
+1.39806365,1.39608068,1.39409701,1.39211264,1.39012756,1.38814175,1.38615522,1.38416795,
+1.38217994,1.38019117,1.37820164,1.37621134,1.37422025,1.37222837,1.37023570,1.36824222,
+1.36624792,1.36425280,1.36225684,1.36026004,1.35826239,1.35626387,1.35426449,1.35226422,
+1.35026307,1.34826101,1.34625805,1.34425418,1.34224937,1.34024364,1.33823695,1.33622932,
+1.33422072,1.33221114,1.33020059,1.32818904,1.32617649,1.32416292,1.32214834,1.32013273,
+1.31811607,1.31609837,1.31407960,1.31205976,1.31003885,1.30801684,1.30599373,1.30396951,
+1.30194417,1.29991770,1.29789009,1.29586133,1.29383141,1.29180031,1.28976803,1.28773456,
+1.28569989,1.28366400,1.28162688,1.27958854,1.27754894,1.27550809,1.27346597,1.27142257,
+1.26937788,1.26733189,1.26528459,1.26323597,1.26118602,1.25913471,1.25708205,1.25502803,
+1.25297262,1.25091583,1.24885763,1.24679802,1.24473698,1.24267450,1.24061058,1.23854519,
+1.23647833,1.23440999,1.23234015,1.23026880,1.22819593,1.22612152,1.22404557,1.22196806,
+1.21988898,1.21780832,1.21572606,1.21364219,1.21155670,1.20946958,1.20738080,1.20529037,
+1.20319826,1.20110447,1.19900898,1.19691177,1.19481283,1.19271216,1.19060973,1.18850553,
+1.18639955,1.18429178,1.18218219,1.18007079,1.17795754,1.17584244,1.17372548,1.17160663,
+1.16948589,1.16736324,1.16523866,1.16311215,1.16098368,1.15885323,1.15672081,1.15458638,
+1.15244994,1.15031147,1.14817095,1.14602836,1.14388370,1.14173695,1.13958808,1.13743709,
+1.13528396,1.13312866,1.13097119,1.12881153,1.12664966,1.12448556,1.12231921,1.12015061,
+1.11797973,1.11580656,1.11363107,1.11145325,1.10927308,1.10709055,1.10490563,1.10271831,
+1.10052856,1.09833638,1.09614174,1.09394462,1.09174500,1.08954287,1.08733820,1.08513098,
+1.08292118,1.08070879,1.07849378,1.07627614,1.07405585,1.07183287,1.06960721,1.06737882,
+1.06514770,1.06291382,1.06067715,1.05843769,1.05619540,1.05395026,1.05170226,1.04945136,
+1.04719755,1.04494080,1.04268110,1.04041841,1.03815271,1.03588399,1.03361221,1.03133735,
+1.02905939,1.02677830,1.02449407,1.02220665,1.01991603,1.01762219,1.01532509,1.01302471,
+1.01072102,1.00841400,1.00610363,1.00378986,1.00147268,0.99915206,0.99682798,0.99450039,
+0.99216928,0.98983461,0.98749636,0.98515449,0.98280898,0.98045980,0.97810691,0.97575030,
+0.97338991,0.97102573,0.96865772,0.96628585,0.96391009,0.96153040,0.95914675,0.95675912,
+0.95436745,0.95197173,0.94957191,0.94716796,0.94475985,0.94234754,0.93993099,0.93751017,
+0.93508504,0.93265556,0.93022170,0.92778341,0.92534066,0.92289341,0.92044161,0.91798524,
+0.91552424,0.91305858,0.91058821,0.90811309,0.90563319,0.90314845,0.90065884,0.89816430,
+0.89566479,0.89316028,0.89065070,0.88813602,0.88561619,0.88309116,0.88056088,0.87802531,
+0.87548438,0.87293806,0.87038629,0.86782901,0.86526619,0.86269775,0.86012366,0.85754385,
+0.85495827,0.85236686,0.84976956,0.84716633,0.84455709,0.84194179,0.83932037,0.83669277,
+0.83405893,0.83141877,0.82877225,0.82611928,0.82345981,0.82079378,0.81812110,0.81544172,
+0.81275556,0.81006255,0.80736262,0.80465570,0.80194171,0.79922057,0.79649221,0.79375655,
+0.79101352,0.78826302,0.78550497,0.78273931,0.77996593,0.77718475,0.77439569,0.77159865,
+0.76879355,0.76598029,0.76315878,0.76032891,0.75749061,0.75464376,0.75178826,0.74892402,
+0.74605092,0.74316887,0.74027775,0.73737744,0.73446785,0.73154885,0.72862033,0.72568217,
+0.72273425,0.71977644,0.71680861,0.71383064,0.71084240,0.70784376,0.70483456,0.70181469,
+0.69878398,0.69574231,0.69268952,0.68962545,0.68654996,0.68346288,0.68036406,0.67725332,
+0.67413051,0.67099544,0.66784794,0.66468783,0.66151492,0.65832903,0.65512997,0.65191753,
+0.64869151,0.64545170,0.64219789,0.63892987,0.63564741,0.63235028,0.62903824,0.62571106,
+0.62236849,0.61901027,0.61563615,0.61224585,0.60883911,0.60541564,0.60197515,0.59851735,
+0.59504192,0.59154856,0.58803694,0.58450672,0.58095756,0.57738911,0.57380101,0.57019288,
+0.56656433,0.56291496,0.55924437,0.55555212,0.55183778,0.54810089,0.54434099,0.54055758,
+0.53675018,0.53291825,0.52906127,0.52517867,0.52126988,0.51733431,0.51337132,0.50938028,
+0.50536051,0.50131132,0.49723200,0.49312177,0.48897987,0.48480547,0.48059772,0.47635573,
+0.47207859,0.46776530,0.46341487,0.45902623,0.45459827,0.45012983,0.44561967,0.44106652,
+0.43646903,0.43182577,0.42713525,0.42239588,0.41760600,0.41276385,0.40786755,0.40291513,
+0.39790449,0.39283339,0.38769946,0.38250016,0.37723277,0.37189441,0.36648196,0.36099209,
+0.35542120,0.34976542,0.34402054,0.33818204,0.33224495,0.32620390,0.32005298,0.31378574,
+0.30739505,0.30087304,0.29421096,0.28739907,0.28042645,0.27328078,0.26594810,0.25841250,
+0.25065566,0.24265636,0.23438976,0.22582651,0.21693146,0.20766198,0.19796546,0.18777575,
+0.17700769,0.16554844,0.15324301,0.13986823,0.12508152,0.10830610,0.08841715,0.06251018,
+}
+
+double acos( double x ) {
+	int index;
+
+	if (x < -1)
+		x = -1;
+	if (x > 1)
+		x = 1;
+	index = (float) (1.0 + x) * 511.9;
+	return acostable[index];
+}
+
+double atan2( double y, double x ) {
+	float	base;
+	float	temp;
+	float	dir;
+	float	test;
+	int		i;
+
+	if ( x < 0 ) {
+		if ( y >= 0 ) {
+			// quad 1
+			base = M_PI / 2;
+			temp = x;
+			x = y;
+			y = -temp;
+		} else {
+			// quad 2
+			base = M_PI;
+			x = -x;
+			y = -y;
+		}
+	} else {
+		if ( y < 0 ) {
+			// quad 3
+			base = 3 * M_PI / 2;
+			temp = x;
+			x = -y;
+			y = temp;
+		}
+	}
+
+	if ( y > x ) {
+		base += M_PI/2;
+		temp = x;
+		x = y;
+		y = temp;
+		dir = -1;
+	} else {
+		dir = 1;
+	}
+
+	// calcualte angle in octant 0
+	if ( x == 0 ) {
+		return base;
+	}
+	y /= x;
+
+	for ( i = 0 ; i < 512 ; i++ ) {
+		test = sintable[i] / sintable[1023-i];
+		if ( test > y ) {
+			break;
+		}
+	}
+
+	return base + dir * i * ( M_PI/2048); 
+}
+
+
+#endif
+
+#ifdef Q3_VM
+// bk001127 - guarded this tan replacement 
+// ld: undefined versioned symbol name tan@@GLIBC_2.0
+double tan( double x ) {
+	return sin(x) / cos(x);
+}
+#endif
+
+
+static int randSeed = 0;
+
+void	srand( unsigned seed ) {
+	randSeed = seed;
+}
+
+int		rand( void ) {
+	randSeed = (69069 * randSeed + 1);
+	return randSeed & 0x7fff;
+}
+
+double atof( const char *string ) {
+	float sign;
+	float value;
+	int		c;
+
+
+	// skip whitespace
+	while ( *string <= ' ' ) {
+		if ( !*string ) {
+			return 0;
+		}
+		string++;
+	}
+
+	// check sign
+	switch ( *string ) {
+	case '+':
+		string++;
+		sign = 1;
+		break;
+	case '-':
+		string++;
+		sign = -1;
+		break;
+	default:
+		sign = 1;
+		break;
+	}
+
+	// read digits
+	value = 0;
+	c = string[0];
+	if ( c != '.' ) {
+		do {
+			c = *string++;
+			if ( c < '0' || c > '9' ) {
+				break;
+			}
+			c -= '0';
+			value = value * 10 + c;
+		} while ( 1 );
+	} else {
+		string++;
+	}
+
+	// check for decimal point
+	if ( c == '.' ) {
+		double fraction;
+
+		fraction = 0.1;
+		do {
+			c = *string++;
+			if ( c < '0' || c > '9' ) {
+				break;
+			}
+			c -= '0';
+			value += c * fraction;
+			fraction *= 0.1;
+		} while ( 1 );
+
+	}
+
+	// not handling 10e10 notation...
+
+	return value * sign;
+}
+
+double _atof( const char **stringPtr ) {
+	const char	*string;
+	float sign;
+	float value;
+	int		c = '0'; // bk001211 - uninitialized use possible
+
+	string = *stringPtr;
+
+	// skip whitespace
+	while ( *string <= ' ' ) {
+		if ( !*string ) {
+			*stringPtr = string;
+			return 0;
+		}
+		string++;
+	}
+
+	// check sign
+	switch ( *string ) {
+	case '+':
+		string++;
+		sign = 1;
+		break;
+	case '-':
+		string++;
+		sign = -1;
+		break;
+	default:
+		sign = 1;
+		break;
+	}
+
+	// read digits
+	value = 0;
+	if ( string[0] != '.' ) {
+		do {
+			c = *string++;
+			if ( c < '0' || c > '9' ) {
+				break;
+			}
+			c -= '0';
+			value = value * 10 + c;
+		} while ( 1 );
+	}
+
+	// check for decimal point
+	if ( c == '.' ) {
+		double fraction;
+
+		fraction = 0.1;
+		do {
+			c = *string++;
+			if ( c < '0' || c > '9' ) {
+				break;
+			}
+			c -= '0';
+			value += c * fraction;
+			fraction *= 0.1;
+		} while ( 1 );
+
+	}
+
+	// not handling 10e10 notation...
+	*stringPtr = string;
+
+	return value * sign;
+}
+
+
+// bk001120 - presumably needed for Mac
+//#if !defined ( _MSC_VER ) && ! defined ( __linux__ )
+
+// bk001127 - undid undo
+#if defined ( Q3_VM )
+int atoi( const char *string ) {
+	int		sign;
+	int		value;
+	int		c;
+
+
+	// skip whitespace
+	while ( *string <= ' ' ) {
+		if ( !*string ) {
+			return 0;
+		}
+		string++;
+	}
+
+	// check sign
+	switch ( *string ) {
+	case '+':
+		string++;
+		sign = 1;
+		break;
+	case '-':
+		string++;
+		sign = -1;
+		break;
+	default:
+		sign = 1;
+		break;
+	}
+
+	// read digits
+	value = 0;
+	do {
+		c = *string++;
+		if ( c < '0' || c > '9' ) {
+			break;
+		}
+		c -= '0';
+		value = value * 10 + c;
+	} while ( 1 );
+
+	// not handling 10e10 notation...
+
+	return value * sign;
+}
+
+
+int _atoi( const char **stringPtr ) {
+	int		sign;
+	int		value;
+	int		c;
+	const char	*string;
+
+	string = *stringPtr;
+
+	// skip whitespace
+	while ( *string <= ' ' ) {
+		if ( !*string ) {
+			return 0;
+		}
+		string++;
+	}
+
+	// check sign
+	switch ( *string ) {
+	case '+':
+		string++;
+		sign = 1;
+		break;
+	case '-':
+		string++;
+		sign = -1;
+		break;
+	default:
+		sign = 1;
+		break;
+	}
+
+	// read digits
+	value = 0;
+	do {
+		c = *string++;
+		if ( c < '0' || c > '9' ) {
+			break;
+		}
+		c -= '0';
+		value = value * 10 + c;
+	} while ( 1 );
+
+	// not handling 10e10 notation...
+
+	*stringPtr = string;
+
+	return value * sign;
+}
+
+int abs( int n ) {
+	return n < 0 ? -n : n;
+}
+
+double fabs( double x ) {
+	return x < 0 ? -x : x;
+}
+
+
+
+//=========================================================
+
+
+#define ALT			0x00000001		/* alternate form */
+#define HEXPREFIX	0x00000002		/* add 0x or 0X prefix */
+#define LADJUST		0x00000004		/* left adjustment */
+#define LONGDBL		0x00000008		/* long double */
+#define LONGINT		0x00000010		/* long integer */
+#define QUADINT		0x00000020		/* quad integer */
+#define SHORTINT	0x00000040		/* short integer */
+#define ZEROPAD		0x00000080		/* zero (as opposed to blank) pad */
+#define FPT			0x00000100		/* floating point number */
+
+#define to_digit(c)		((c) - '0')
+#define is_digit(c)		((unsigned)to_digit(c) <= 9)
+#define to_char(n)		((n) + '0')
+
+void AddInt( char **buf_p, int val, int width, int flags ) {
+	char	text[32];
+	int		digits;
+	int		signedVal;
+	char	*buf;
+
+	digits = 0;
+	signedVal = val;
+	if ( val < 0 ) {
+		val = -val;
+	}
+	do {
+		text[digits++] = '0' + val % 10;
+		val /= 10;
+	} while ( val );
+
+	if ( signedVal < 0 ) {
+		text[digits++] = '-';
+	}
+
+	buf = *buf_p;
+
+	if( !( flags & LADJUST ) ) {
+		while ( digits < width ) {
+			*buf++ = ( flags & ZEROPAD ) ? '0' : ' ';
+			width--;
+		}
+	}
+
+	while ( digits-- ) {
+		*buf++ = text[digits];
+		width--;
+	}
+
+	if( flags & LADJUST ) {
+		while ( width-- ) {
+			*buf++ = ( flags & ZEROPAD ) ? '0' : ' ';
+		}
+	}
+
+	*buf_p = buf;
+}
+
+void AddFloat( char **buf_p, float fval, int width, int prec ) {
+	char	text[32];
+	int		digits;
+	float	signedVal;
+	char	*buf;
+	int		val;
+
+	// get the sign
+	signedVal = fval;
+	if ( fval < 0 ) {
+		fval = -fval;
+	}
+
+	// write the float number
+	digits = 0;
+	val = (int)fval;
+	do {
+		text[digits++] = '0' + val % 10;
+		val /= 10;
+	} while ( val );
+
+	if ( signedVal < 0 ) {
+		text[digits++] = '-';
+	}
+
+	buf = *buf_p;
+
+	while ( digits < width ) {
+		*buf++ = ' ';
+		width--;
+	}
+
+	while ( digits-- ) {
+		*buf++ = text[digits];
+	}
+
+	*buf_p = buf;
+
+	if (prec < 0)
+		prec = 6;
+	// write the fraction
+	digits = 0;
+	while (digits < prec) {
+		fval -= (int) fval;
+		fval *= 10.0;
+		val = (int) fval;
+		text[digits++] = '0' + val % 10;
+	}
+
+	if (digits > 0) {
+		buf = *buf_p;
+		*buf++ = '.';
+		for (prec = 0; prec < digits; prec++) {
+			*buf++ = text[prec];
+		}
+		*buf_p = buf;
+	}
+}
+
+
+void AddString( char **buf_p, char *string, int width, int prec ) {
+	int		size;
+	char	*buf;
+
+	buf = *buf_p;
+
+	if ( string == NULL ) {
+		string = "(null)";
+		prec = -1;
+	}
+
+	if ( prec >= 0 ) {
+		for( size = 0; size < prec; size++ ) {
+			if( string[size] == '\0' ) {
+				break;
+			}
+		}
+	}
+	else {
+		size = strlen( string );
+	}
+
+	width -= size;
+
+	while( size-- ) {
+		*buf++ = *string++;
+	}
+
+	while( width-- > 0 ) {
+		*buf++ = ' ';
+	}
+
+	*buf_p = buf;
+}
+
+/*
+vsprintf
+
+I'm not going to support a bunch of the more arcane stuff in here
+just to keep it simpler.  For example, the '*' and '$' are not
+currently supported.  I've tried to make it so that it will just
+parse and ignore formats we don't support.
+*/
+int vsprintf( char *buffer, const char *fmt, va_list argptr ) {
+	int		*arg;
+	char	*buf_p;
+	char	ch;
+	int		flags;
+	int		width;
+	int		prec;
+	int		n;
+	char	sign;
+
+	buf_p = buffer;
+	arg = (int *)argptr;
+
+	while( qtrue ) {
+		// run through the format string until we hit a '%' or '\0'
+		for ( ch = *fmt; (ch = *fmt) != '\0' && ch != '%'; fmt++ ) {
+			*buf_p++ = ch;
+		}
+		if ( ch == '\0' ) {
+			goto done;
+		}
+
+		// skip over the '%'
+		fmt++;
+
+		// reset formatting state
+		flags = 0;
+		width = 0;
+		prec = -1;
+		sign = '\0';
+
+rflag:
+		ch = *fmt++;
+reswitch:
+		switch( ch ) {
+		case '-':
+			flags |= LADJUST;
+			goto rflag;
+		case '.':
+			n = 0;
+			while( is_digit( ( ch = *fmt++ ) ) ) {
+				n = 10 * n + ( ch - '0' );
+			}
+			prec = n < 0 ? -1 : n;
+			goto reswitch;
+		case '0':
+			flags |= ZEROPAD;
+			goto rflag;
+		case '1':
+		case '2':
+		case '3':
+		case '4':
+		case '5':
+		case '6':
+		case '7':
+		case '8':
+		case '9':
+			n = 0;
+			do {
+				n = 10 * n + ( ch - '0' );
+				ch = *fmt++;
+			} while( is_digit( ch ) );
+			width = n;
+			goto reswitch;
+		case 'c':
+			*buf_p++ = (char)*arg;
+			arg++;
+			break;
+		case 'd':
+		case 'i':
+			AddInt( &buf_p, *arg, width, flags );
+			arg++;
+			break;
+		case 'f':
+			AddFloat( &buf_p, *(double *)arg, width, prec );
+#ifdef __LCC__
+			arg += 1;	// everything is 32 bit in my compiler
+#else
+			arg += 2;
+#endif
+			break;
+		case 's':
+			AddString( &buf_p, (char *)*arg, width, prec );
+			arg++;
+			break;
+		case '%':
+			*buf_p++ = ch;
+			break;
+		default:
+			*buf_p++ = (char)*arg;
+			arg++;
+			break;
+		}
+	}
+
+done:
+	*buf_p = 0;
+	return buf_p - buffer;
+}
+
+
+/* this is really crappy */
+int sscanf( const char *buffer, const char *fmt, ... ) {
+	int		cmd;
+	int		**arg;
+	int		count;
+
+	arg = (int **)&fmt + 1;
+	count = 0;
+
+	while ( *fmt ) {
+		if ( fmt[0] != '%' ) {
+			fmt++;
+			continue;
+		}
+
+		cmd = fmt[1];
+		fmt += 2;
+
+		switch ( cmd ) {
+		case 'i':
+		case 'd':
+		case 'u':
+			**arg = _atoi( &buffer );
+			break;
+		case 'f':
+			*(float *)*arg = _atof( &buffer );
+			break;
+		}
+		arg++;
+	}
+
+	return count;
+}
+
+#endif
diff --git a/codemp/game/bg_lib.h b/codemp/game/bg_lib.h
new file mode 100644
index 0000000..41f3fc1
--- /dev/null
+++ b/codemp/game/bg_lib.h
@@ -0,0 +1,70 @@
+// bg_lib.h -- standard C library replacement routines used by code
+// compiled for the virtual machine
+
+// This file is NOT included on native builds
+
+typedef int size_t;
+
+typedef char *  va_list;
+#define _INTSIZEOF(n)   ( (sizeof(n) + sizeof(int) - 1) & ~(sizeof(int) - 1) )
+#define va_start(ap,v)  ( ap = (va_list)&v + _INTSIZEOF(v) )
+#define va_arg(ap,t)    ( *(t *)((ap += _INTSIZEOF(t)) - _INTSIZEOF(t)) )
+#define va_end(ap)      ( ap = (va_list)0 )
+
+#define CHAR_BIT      8         /* number of bits in a char */
+#define SCHAR_MIN   (-128)      /* minimum signed char value */
+#define SCHAR_MAX     127       /* maximum signed char value */
+#define UCHAR_MAX     0xff      /* maximum unsigned char value */
+
+#define SHRT_MIN    (-32768)        /* minimum (signed) short value */
+#define SHRT_MAX      32767         /* maximum (signed) short value */
+#define USHRT_MAX     0xffff        /* maximum unsigned short value */
+#define INT_MIN     (-2147483647 - 1) /* minimum (signed) int value */
+#define INT_MAX       2147483647    /* maximum (signed) int value */
+#define UINT_MAX      0xffffffff    /* maximum unsigned int value */
+#define LONG_MIN    (-2147483647L - 1) /* minimum (signed) long value */
+#define LONG_MAX      2147483647L   /* maximum (signed) long value */
+#define ULONG_MAX     0xffffffffUL  /* maximum unsigned long value */
+
+// Misc functions
+typedef int cmp_t(const void *, const void *);
+void qsort(void *a, size_t n, size_t es, cmp_t *cmp);
+void	srand( unsigned seed );
+int		rand( void );
+
+// String functions
+size_t strlen( const char *string );
+char *strcat( char *strDestination, const char *strSource );
+char *strcpy( char *strDestination, const char *strSource );
+int strcmp( const char *string1, const char *string2 );
+char *strchr( const char *string, int c );
+char *strstr( const char *string, const char *strCharSet );
+char *strncpy( char *strDest, const char *strSource, size_t count );
+int tolower( int c );
+int toupper( int c );
+
+double atof( const char *string );
+double _atof( const char **stringPtr );
+int atoi( const char *string );
+int _atoi( const char **stringPtr );
+
+int vsprintf( char *buffer, const char *fmt, va_list argptr );
+int sscanf( const char *buffer, const char *fmt, ... );
+
+// Memory functions
+void *memmove( void *dest, const void *src, size_t count );
+void *memset( void *dest, int c, size_t count );
+void *memcpy( void *dest, const void *src, size_t count );
+
+// Math functions
+double ceil( double x );
+double floor( double x );
+double sqrt( double x );
+double sin( double x );
+double cos( double x );
+double atan2( double y, double x );
+double tan( double x );
+int abs( int n );
+double fabs( double x );
+double acos( double x );
+
diff --git a/codemp/game/bg_local.h b/codemp/game/bg_local.h
new file mode 100644
index 0000000..d19e587
--- /dev/null
+++ b/codemp/game/bg_local.h
@@ -0,0 +1,109 @@
+// Copyright (C) 1999-2000 Id Software, Inc.
+//
+// bg_local.h -- local definitions for the bg (both games) files
+
+#define	MIN_WALK_NORMAL	0.7f		// can't walk on very steep slopes
+
+#define	TIMER_LAND		130
+#define	TIMER_GESTURE	(34*66+50)
+
+#define	OVERCLIP		1.001f
+
+// all of the locals will be zeroed before each
+// pmove, just to make damn sure we don't have
+// any differences when running on client or server
+typedef struct 
+{
+	vec3_t		forward, right, up;
+	float		frametime;
+
+	int			msec;
+
+	qboolean	walking;
+	qboolean	groundPlane;
+	trace_t		groundTrace;
+
+	float		impactSpeed;
+
+	vec3_t		previous_origin;
+	vec3_t		previous_velocity;
+	int			previous_waterlevel;
+} pml_t;
+
+#include "../namespace_begin.h"
+
+extern	pml_t		pml;
+
+// movement parameters
+extern	float	pm_stopspeed;
+extern	float	pm_duckScale;
+extern	float	pm_swimScale;
+extern	float	pm_wadeScale;
+
+extern	float	pm_accelerate;
+extern	float	pm_airaccelerate;
+extern	float	pm_wateraccelerate;
+extern	float	pm_flyaccelerate;
+
+extern	float	pm_friction;
+extern	float	pm_waterfriction;
+extern	float	pm_flightfriction;
+
+extern	int		c_pmove;
+
+extern int forcePowerNeeded[NUM_FORCE_POWER_LEVELS][NUM_FORCE_POWERS];
+
+// Had to add these here because there was no file access within the BG right now.
+int		trap_FS_FOpenFile( const char *qpath, fileHandle_t *f, fsMode_t mode );
+void	trap_FS_Read( void *buffer, int len, fileHandle_t f );
+void	trap_FS_Write( const void *buffer, int len, fileHandle_t f );
+void	trap_FS_FCloseFile( fileHandle_t f );
+#include "../namespace_end.h"
+
+//PM anim utility functions:
+#include "../namespace_begin.h"
+qboolean PM_SaberInParry( int move );
+qboolean PM_SaberInKnockaway( int move );
+qboolean PM_SaberInReflect( int move );
+qboolean PM_SaberInStart( int move );
+qboolean PM_InSaberAnim( int anim );
+qboolean PM_InKnockDown( playerState_t *ps );
+qboolean PM_PainAnim( int anim );
+qboolean PM_JumpingAnim( int anim );
+qboolean PM_LandingAnim( int anim );
+qboolean PM_SpinningAnim( int anim );
+qboolean PM_InOnGroundAnim ( int anim );
+qboolean PM_InRollComplete( playerState_t *ps, int anim );
+
+int PM_AnimLength( int index, animNumber_t anim );
+
+int PM_GetSaberStance(void);
+float PM_GroundDistance(void);
+qboolean PM_SomeoneInFront(trace_t *tr);
+saberMoveName_t PM_SaberFlipOverAttackMove(void);
+saberMoveName_t PM_SaberJumpAttackMove( void );
+
+void PM_ClipVelocity( vec3_t in, vec3_t normal, vec3_t out, float overbounce );
+void PM_AddTouchEnt( int entityNum );
+void PM_AddEvent( int newEvent );
+
+qboolean	PM_SlideMove( qboolean gravity );
+void		PM_StepSlideMove( qboolean gravity );
+
+void PM_StartTorsoAnim( int anim );
+void PM_ContinueLegsAnim( int anim );
+void PM_ForceLegsAnim( int anim );
+
+void PM_BeginWeaponChange( int weapon );
+void PM_FinishWeaponChange( void );
+
+void PM_SetAnim(int setAnimParts,int anim,int setAnimFlags, int blendTime);
+
+void PM_WeaponLightsaber(void);
+void PM_SetSaberMove(short newMove);
+
+void PM_SetForceJumpZStart(float value);
+
+void BG_CycleInven(playerState_t *ps, int direction);
+
+#include "../namespace_end.h"
diff --git a/codemp/game/bg_misc.c b/codemp/game/bg_misc.c
new file mode 100644
index 0000000..2efcdf9
--- /dev/null
+++ b/codemp/game/bg_misc.c
@@ -0,0 +1,3404 @@
+// Copyright (C) 1999-2000 Id Software, Inc.
+//
+// bg_misc.c -- both games misc functions, all completely stateless
+
+#include "q_shared.h"
+#include "bg_public.h"
+#include "bg_strap.h"
+
+#ifdef QAGAME
+#include "g_local.h"
+#endif
+
+#ifdef UI_EXPORTS
+#include "../ui/ui_local.h"
+#endif
+
+#ifndef UI_EXPORTS
+#ifndef QAGAME
+#include "../cgame/cg_local.h"
+#endif
+#endif
+
+#ifdef _XBOX
+extern void *Z_Malloc(int iSize, memtag_t eTag, qboolean bZeroit, int iAlign);
+extern void Z_Free(void *pvAddress);
+#endif
+
+#ifdef QAGAME
+extern void Q3_SetParm (int entID, int parmNum, const char *parmValue);
+#endif
+
+#include "../namespace_begin.h"
+
+const char *bgToggleableSurfaces[BG_NUM_TOGGLEABLE_SURFACES] = 
+{
+	"l_arm_key",					//0
+	"torso_canister1",
+	"torso_canister2",
+	"torso_canister3",
+	"torso_tube1",
+	"torso_tube2",					//5
+	"torso_tube3",
+	"torso_tube4",
+	"torso_tube5",
+	"torso_tube6",
+	"r_arm",						//10
+	"l_arm",
+	"torso_shield",
+	"torso_galaktorso",
+	"torso_collar",
+//	"torso_eyes_mouth",				//15
+//	"torso_galakhead",
+//	"torso_galakface",
+//	"torso_antenna_base_cap",
+//	"torso_antenna",
+//	"l_arm_augment",				//20
+//	"l_arm_middle",
+//	"l_arm_wrist",
+//	"r_arm_middle", //yeah.. galak's surf stuff is no longer auto, sorry! need the space for vehicle surfs.
+	"r_wing1",						//15
+	"r_wing2",
+	"l_wing1",
+	"l_wing2",
+	"r_gear",
+	"l_gear",						//20
+	"nose",
+	"blah4",
+	"blah5",
+	"l_hand",
+	"r_hand",						//25
+	"helmet",
+	"head",
+	"head_concussion_charger",
+	"head_light_blaster_cann",		//29
+	NULL
+};
+
+const int bgToggleableSurfaceDebris[BG_NUM_TOGGLEABLE_SURFACES] =
+{
+	0,					//0
+	0,
+	0,
+	0,
+	0,
+	0,					//5
+	0,
+	0,
+	0,
+	0,
+	0,					//10
+	0,
+	0,
+	0,
+	0, //>= 2 means it should create a flame trail when destroyed (for vehicles)
+	3,					//15
+	5, //rwing2
+	4,
+	6, //lwing2
+	0, //rgear
+	0, //lgear			//20
+	7, //nose
+	0, //blah
+	0, //blah
+	0,
+	0,					//25
+	0,
+	0,
+	0,
+	0,					//29
+	-1
+};
+
+const char	*bg_customSiegeSoundNames[MAX_CUSTOM_SIEGE_SOUNDS] = 
+{
+	"*att_attack",
+	"*att_primary",
+	"*att_second",
+	"*def_guns",
+	"*def_position",
+	"*def_primary",
+	"*def_second",
+	"*reply_coming",
+	"*reply_go",
+	"*reply_no",
+	"*reply_stay",
+	"*reply_yes",
+	"*req_assist",
+	"*req_demo",
+	"*req_hvy",
+	"*req_medic",
+	"*req_sup",
+	"*req_tech",
+	"*spot_air",
+	"*spot_defenses",
+	"*spot_emplaced",
+	"*spot_sniper",
+	"*spot_troops",
+	"*tac_cover",
+	"*tac_fallback",
+	"*tac_follow",
+	"*tac_hold",
+	"*tac_split",
+	"*tac_together",
+	NULL
+};
+
+//rww - not putting @ in front of these because
+//we don't need them in a cgame StringEd lookup.
+//Let me know if this causes problems, pat.
+char *forceMasteryLevels[NUM_FORCE_MASTERY_LEVELS] = 
+{
+	"MASTERY0",	//"Uninitiated",	// FORCE_MASTERY_UNINITIATED,
+	"MASTERY1",	//"Initiate",		// FORCE_MASTERY_INITIATE,
+	"MASTERY2",	//"Padawan",		// FORCE_MASTERY_PADAWAN,
+	"MASTERY3",	//"Jedi",			// FORCE_MASTERY_JEDI,
+	"MASTERY4",	//"Jedi Adept",		// FORCE_MASTERY_JEDI_GUARDIAN,
+	"MASTERY5",	//"Jedi Guardian",	// FORCE_MASTERY_JEDI_ADEPT,
+	"MASTERY6",	//"Jedi Knight",	// FORCE_MASTERY_JEDI_KNIGHT,
+	"MASTERY7",	//"Jedi Master"		// FORCE_MASTERY_JEDI_MASTER,
+};
+
+int forceMasteryPoints[NUM_FORCE_MASTERY_LEVELS] =
+{
+	0,		// FORCE_MASTERY_UNINITIATED,
+	5,		// FORCE_MASTERY_INITIATE,
+	10,		// FORCE_MASTERY_PADAWAN,
+	20,		// FORCE_MASTERY_JEDI,
+	30,		// FORCE_MASTERY_JEDI_GUARDIAN,
+	50,		// FORCE_MASTERY_JEDI_ADEPT,
+	75,		// FORCE_MASTERY_JEDI_KNIGHT,
+	100		// FORCE_MASTERY_JEDI_MASTER,
+};
+
+int bgForcePowerCost[NUM_FORCE_POWERS][NUM_FORCE_POWER_LEVELS] = //0 == neutral
+{
+	{	0,	2,	4,	6	},	// Heal			// FP_HEAL
+	{	0,	0,	2,	6	},	// Jump			//FP_LEVITATION,//hold/duration
+	{	0,	2,	4,	6	},	// Speed		//FP_SPEED,//duration
+	{	0,	1,	3,	6	},	// Push			//FP_PUSH,//hold/duration
+	{	0,	1,	3,	6	},	// Pull			//FP_PULL,//hold/duration
+	{	0,	4,	6,	8	},	// Mind Trick	//FP_TELEPATHY,//instant
+	{	0,	1,	3,	6	},	// Grip			//FP_GRIP,//hold/duration
+	{	0,	2,	5,	8	},	// Lightning	//FP_LIGHTNING,//hold/duration
+	{	0,	4,	6,	8	},	// Dark Rage	//FP_RAGE,//duration
+	{	0,	2,	5,	8	},	// Protection	//FP_PROTECT,//duration
+	{	0,	1,	3,	6	},	// Absorb		//FP_ABSORB,//duration
+	{	0,	1,	3,	6	},	// Team Heal	//FP_TEAM_HEAL,//instant
+	{	0,	1,	3,	6	},	// Team Force	//FP_TEAM_FORCE,//instant
+	{	0,	2,	4,	6	},	// Drain		//FP_DRAIN,//hold/duration
+	{	0,	2,	5,	8	},	// Sight		//FP_SEE,//duration
+	{	0,	1,	5,	8	},	// Saber Attack	//FP_SABER_OFFENSE,
+	{	0,	1,	5,	8	},	// Saber Defend	//FP_SABER_DEFENSE,
+	{	0,	4,	6,	8	}	// Saber Throw	//FP_SABERTHROW,
+	//NUM_FORCE_POWERS
+};
+
+int forcePowerSorted[NUM_FORCE_POWERS] = 
+{ //rww - always use this order when drawing force powers for any reason
+	FP_TELEPATHY,
+	FP_HEAL,
+	FP_ABSORB,
+	FP_PROTECT,
+	FP_TEAM_HEAL,
+	FP_LEVITATION,
+	FP_SPEED,
+	FP_PUSH,
+	FP_PULL,
+	FP_SEE,
+	FP_LIGHTNING,
+	FP_DRAIN,
+	FP_RAGE,
+	FP_GRIP,
+	FP_TEAM_FORCE,
+	FP_SABER_OFFENSE,
+	FP_SABER_DEFENSE,
+	FP_SABERTHROW
+};
+
+int forcePowerDarkLight[NUM_FORCE_POWERS] = //0 == neutral
+{ //nothing should be usable at rank 0..
+	FORCE_LIGHTSIDE,//FP_HEAL,//instant
+	0,//FP_LEVITATION,//hold/duration
+	0,//FP_SPEED,//duration
+	0,//FP_PUSH,//hold/duration
+	0,//FP_PULL,//hold/duration
+	FORCE_LIGHTSIDE,//FP_TELEPATHY,//instant
+	FORCE_DARKSIDE,//FP_GRIP,//hold/duration
+	FORCE_DARKSIDE,//FP_LIGHTNING,//hold/duration
+	FORCE_DARKSIDE,//FP_RAGE,//duration
+	FORCE_LIGHTSIDE,//FP_PROTECT,//duration
+	FORCE_LIGHTSIDE,//FP_ABSORB,//duration
+	FORCE_LIGHTSIDE,//FP_TEAM_HEAL,//instant
+	FORCE_DARKSIDE,//FP_TEAM_FORCE,//instant
+	FORCE_DARKSIDE,//FP_DRAIN,//hold/duration
+	0,//FP_SEE,//duration
+	0,//FP_SABER_OFFENSE,
+	0,//FP_SABER_DEFENSE,
+	0//FP_SABERTHROW,
+		//NUM_FORCE_POWERS
+};
+
+int WeaponReadyAnim[WP_NUM_WEAPONS] =
+{
+	TORSO_DROPWEAP1,//WP_NONE,
+
+	TORSO_WEAPONREADY3,//WP_STUN_BATON,
+	TORSO_WEAPONREADY3,//WP_MELEE,
+	BOTH_STAND2,//WP_SABER,
+	TORSO_WEAPONREADY2,//WP_BRYAR_PISTOL,
+	TORSO_WEAPONREADY3,//WP_BLASTER,
+	TORSO_WEAPONREADY3,//TORSO_WEAPONREADY4,//WP_DISRUPTOR,
+	TORSO_WEAPONREADY3,//TORSO_WEAPONREADY5,//WP_BOWCASTER,
+	TORSO_WEAPONREADY3,//TORSO_WEAPONREADY6,//WP_REPEATER,
+	TORSO_WEAPONREADY3,//TORSO_WEAPONREADY7,//WP_DEMP2,
+	TORSO_WEAPONREADY3,//TORSO_WEAPONREADY8,//WP_FLECHETTE,
+	TORSO_WEAPONREADY3,//TORSO_WEAPONREADY9,//WP_ROCKET_LAUNCHER,
+	TORSO_WEAPONREADY10,//WP_THERMAL,
+	TORSO_WEAPONREADY10,//TORSO_WEAPONREADY11,//WP_TRIP_MINE,
+	TORSO_WEAPONREADY10,//TORSO_WEAPONREADY12,//WP_DET_PACK,
+	TORSO_WEAPONREADY3,//WP_CONCUSSION
+	TORSO_WEAPONREADY2,//WP_BRYAR_OLD,
+
+	//NOT VALID (e.g. should never really be used):
+	BOTH_STAND1,//WP_EMPLACED_GUN,
+	TORSO_WEAPONREADY1//WP_TURRET,
+};
+
+int WeaponReadyLegsAnim[WP_NUM_WEAPONS] =
+{
+	BOTH_STAND1,//WP_NONE,
+
+	BOTH_STAND1,//WP_STUN_BATON,
+	BOTH_STAND1,//WP_MELEE,
+	BOTH_STAND2,//WP_SABER,
+	BOTH_STAND1,//WP_BRYAR_PISTOL,
+	BOTH_STAND1,//WP_BLASTER,
+	BOTH_STAND1,//TORSO_WEAPONREADY4,//WP_DISRUPTOR,
+	BOTH_STAND1,//TORSO_WEAPONREADY5,//WP_BOWCASTER,
+	BOTH_STAND1,//TORSO_WEAPONREADY6,//WP_REPEATER,
+	BOTH_STAND1,//TORSO_WEAPONREADY7,//WP_DEMP2,
+	BOTH_STAND1,//TORSO_WEAPONREADY8,//WP_FLECHETTE,
+	BOTH_STAND1,//TORSO_WEAPONREADY9,//WP_ROCKET_LAUNCHER,
+	BOTH_STAND1,//WP_THERMAL,
+	BOTH_STAND1,//TORSO_WEAPONREADY11,//WP_TRIP_MINE,
+	BOTH_STAND1,//TORSO_WEAPONREADY12,//WP_DET_PACK,
+	BOTH_STAND1,//WP_CONCUSSION
+	BOTH_STAND1,//WP_BRYAR_OLD,
+
+	//NOT VALID (e.g. should never really be used):
+	BOTH_STAND1,//WP_EMPLACED_GUN,
+	BOTH_STAND1//WP_TURRET,
+};
+
+int WeaponAttackAnim[WP_NUM_WEAPONS] =
+{
+	BOTH_ATTACK1,//WP_NONE, //(shouldn't happen)
+
+	BOTH_ATTACK3,//WP_STUN_BATON,
+	BOTH_ATTACK3,//WP_MELEE,
+	BOTH_STAND2,//WP_SABER, //(has its own handling)
+	BOTH_ATTACK2,//WP_BRYAR_PISTOL,
+	BOTH_ATTACK3,//WP_BLASTER,
+	BOTH_ATTACK3,//BOTH_ATTACK4,//WP_DISRUPTOR,
+	BOTH_ATTACK3,//BOTH_ATTACK5,//WP_BOWCASTER,
+	BOTH_ATTACK3,//BOTH_ATTACK6,//WP_REPEATER,
+	BOTH_ATTACK3,//BOTH_ATTACK7,//WP_DEMP2,
+	BOTH_ATTACK3,//BOTH_ATTACK8,//WP_FLECHETTE,
+	BOTH_ATTACK3,//BOTH_ATTACK9,//WP_ROCKET_LAUNCHER,
+	BOTH_THERMAL_THROW,//WP_THERMAL,
+	BOTH_ATTACK3,//BOTH_ATTACK11,//WP_TRIP_MINE,
+	BOTH_ATTACK3,//BOTH_ATTACK12,//WP_DET_PACK,
+	BOTH_ATTACK2,//WP_BRYAR_OLD,
+
+	//NOT VALID (e.g. should never really be used):
+	BOTH_STAND1,//WP_EMPLACED_GUN,
+	BOTH_ATTACK1//WP_TURRET,
+};
+
+qboolean BG_FileExists(const char *fileName)
+{
+	if (fileName && fileName[0])
+	{
+		int fh = 0;
+		trap_FS_FOpenFile(fileName, &fh, FS_READ);
+		if (fh > 0)
+		{
+			trap_FS_FCloseFile(fh);
+			return qtrue;
+		}
+	}
+
+	return qfalse;
+}
+
+#ifndef UI_EXPORTS //don't need this stuff in the ui
+
+// Following functions don't need to be in namespace, they're already
+// different per-module
+#include "../namespace_end.h"
+
+#ifdef QAGAME
+char *G_NewString( const char *string );
+#else
+char *CG_NewString( const char *string );
+#endif
+
+#include "../namespace_begin.h"
+
+/*
+===============
+BG_ParseField
+
+Takes a key/value pair and sets the binary values
+in a gentity/centity/whatever the hell you want
+===============
+*/
+
+void BG_ParseField( BG_field_t *l_fields, const char *key, const char *value, byte *ent )
+{
+	BG_field_t	*f;
+	byte	*b;
+	float	v;
+	vec3_t	vec;
+
+	for ( f=l_fields ; f->name ; f++ ) {
+		if ( !Q_stricmp(f->name, key) ) {
+			// found it
+			b = (byte *)ent;
+
+			switch( f->type ) {
+			case F_LSTRING:
+#ifdef QAGAME
+				*(char **)(b+f->ofs) = G_NewString (value);
+#else
+				*(char **)(b+f->ofs) = CG_NewString (value);
+#endif
+				break;
+			case F_VECTOR:
+				sscanf (value, "%f %f %f", &vec[0], &vec[1], &vec[2]);
+				((float *)(b+f->ofs))[0] = vec[0];
+				((float *)(b+f->ofs))[1] = vec[1];
+				((float *)(b+f->ofs))[2] = vec[2];
+				break;
+			case F_INT:
+				*(int *)(b+f->ofs) = atoi(value);
+				break;
+			case F_FLOAT:
+				*(float *)(b+f->ofs) = atof(value);
+				break;
+			case F_ANGLEHACK:
+				v = atof(value);
+				((float *)(b+f->ofs))[0] = 0;
+				((float *)(b+f->ofs))[1] = v;
+				((float *)(b+f->ofs))[2] = 0;
+				break;
+#ifdef QAGAME
+			case F_PARM1:
+			case F_PARM2:
+			case F_PARM3:
+			case F_PARM4:
+			case F_PARM5:
+			case F_PARM6:
+			case F_PARM7:
+			case F_PARM8:
+			case F_PARM9:
+			case F_PARM10:
+			case F_PARM11:
+			case F_PARM12:
+			case F_PARM13:
+			case F_PARM14:
+			case F_PARM15:
+			case F_PARM16:
+				Q3_SetParm( ((gentity_t *)(ent))->s.number, (f->type - F_PARM1), (char *) value );
+				break;
+#endif
+			default:
+			case F_IGNORE:
+				break;
+			}
+			return;
+		}
+	}
+}
+
+#endif
+
+/*
+================
+BG_LegalizedForcePowers
+
+The magical function to end all functions.
+This will take the force power string in powerOut and parse through it, then legalize
+it based on the supposed rank and spit it into powerOut, returning true if it was legal
+to begin with and false if not.
+fpDisabled is actually only expected (needed) from the server, because the ui disables
+force power selection anyway when force powers are disabled on the server.
+================
+*/
+qboolean BG_LegalizedForcePowers(char *powerOut, int maxRank, qboolean freeSaber, int teamForce, int gametype, int fpDisabled)
+{
+	char powerBuf[128];
+	char readBuf[128];
+	qboolean maintainsValidity = qtrue;
+	int powerLen = strlen(powerOut);
+	int i = 0;
+	int c = 0;
+	int allowedPoints = 0;
+	int usedPoints = 0;
+	int countDown = 0;
+	
+	int final_Side;
+	int final_Powers[NUM_FORCE_POWERS];
+
+	if (powerLen >= 128)
+	{ //This should not happen. If it does, this is obviously a bogus string.
+		//They can have this string. Because I said so.
+		strcpy(powerBuf, "7-1-032330000000001333");
+		maintainsValidity = qfalse;
+	}
+	else
+	{
+		strcpy(powerBuf, powerOut); //copy it as the original
+	}
+
+	//first of all, print the max rank into the string as the rank
+	strcpy(powerOut, va("%i-", maxRank));
+
+	while (i < 128 && powerBuf[i] && powerBuf[i] != '-')
+	{
+		i++;
+	}
+	i++;
+	while (i < 128 && powerBuf[i] && powerBuf[i] != '-')
+	{
+		readBuf[c] = powerBuf[i];
+		c++;
+		i++;
+	}
+	readBuf[c] = 0;
+	i++;
+	//at this point, readBuf contains the intended side
+	final_Side = atoi(readBuf);
+
+	if (final_Side != FORCE_LIGHTSIDE &&
+		final_Side != FORCE_DARKSIDE)
+	{ //Not a valid side. You will be dark. Because I said so. (this is something that should never actually happen unless you purposely feed in an invalid config)
+		final_Side = FORCE_DARKSIDE;
+		maintainsValidity = qfalse;
+	}
+
+	if (teamForce)
+	{ //If we are under force-aligned teams, make sure we're on the right side.
+		if (final_Side != teamForce)
+		{
+			final_Side = teamForce;
+			//maintainsValidity = qfalse;
+			//Not doing this, for now. Let them join the team with their filtered powers.
+		}
+	}
+
+	//Now we have established a valid rank, and a valid side.
+	//Read the force powers in, and cut them down based on the various rules supplied.
+	c = 0;
+	while (i < 128 && powerBuf[i] && powerBuf[i] != '\n' && c < NUM_FORCE_POWERS)
+	{
+		readBuf[0] = powerBuf[i];
+		readBuf[1] = 0;
+		final_Powers[c] = atoi(readBuf);
+		c++;
+		i++;
+	}
+
+	//final_Powers now contains all the stuff from the string
+	//Set the maximum allowed points used based on the max rank level, and count the points actually used.
+	allowedPoints = forceMasteryPoints[maxRank];
+
+	i = 0;
+	while (i < NUM_FORCE_POWERS)
+	{ //if this power doesn't match the side we're on, then 0 it now.
+		if (final_Powers[i] &&
+			forcePowerDarkLight[i] &&
+			forcePowerDarkLight[i] != final_Side)
+		{
+			final_Powers[i] = 0;
+			//This is only likely to happen with g_forceBasedTeams. Let it slide.
+		}
+
+		if ( final_Powers[i] &&
+			(fpDisabled & (1 << i)) )
+		{ //if this power is disabled on the server via said server option, then we don't get it.
+			final_Powers[i] = 0;
+		}
+
+		i++;
+	}
+
+	if (gametype < GT_TEAM)
+	{ //don't bother with team powers then
+		final_Powers[FP_TEAM_HEAL] = 0;
+		final_Powers[FP_TEAM_FORCE] = 0;
+	}
+
+	usedPoints = 0;
+	i = 0;
+	while (i < NUM_FORCE_POWERS)
+	{
+		countDown = 0;
+
+		countDown = final_Powers[i];
+
+		while (countDown > 0)
+		{
+			usedPoints += bgForcePowerCost[i][countDown]; //[fp index][fp level]
+			//if this is jump, or we have a free saber and it's offense or defense, take the level back down on level 1
+			if ( countDown == 1 &&
+				((i == FP_LEVITATION) ||
+				 (i == FP_SABER_OFFENSE && freeSaber) ||
+				 (i == FP_SABER_DEFENSE && freeSaber)) )
+			{
+				usedPoints -= bgForcePowerCost[i][countDown];
+			}
+			countDown--;
+		}
+
+		i++;
+	}
+
+	if (usedPoints > allowedPoints)
+	{ //Time to do the fancy stuff. (meaning, slowly cut parts off while taking a guess at what is most or least important in the config)
+		int attemptedCycles = 0;
+		int powerCycle = 2;
+		int minPow = 0;
+		
+		if (freeSaber)
+		{
+			minPow = 1;
+		}
+
+		maintainsValidity = qfalse;
+
+		while (usedPoints > allowedPoints)
+		{
+			c = 0;
+
+			while (c < NUM_FORCE_POWERS && usedPoints > allowedPoints)
+			{
+				if (final_Powers[c] && final_Powers[c] < powerCycle)
+				{ //kill in order of lowest powers, because the higher powers are probably more important
+					if (c == FP_SABER_OFFENSE &&
+						(final_Powers[FP_SABER_DEFENSE] > minPow || final_Powers[FP_SABERTHROW] > 0))
+					{ //if we're on saber attack, only suck it down if we have no def or throw either
+						int whichOne = FP_SABERTHROW; //first try throw
+
+						if (!final_Powers[whichOne])
+						{
+							whichOne = FP_SABER_DEFENSE; //if no throw, drain defense
+						}
+
+						while (final_Powers[whichOne] > 0 && usedPoints > allowedPoints)
+						{
+							if ( final_Powers[whichOne] > 1 ||
+								( (whichOne != FP_SABER_OFFENSE || !freeSaber) &&
+								  (whichOne != FP_SABER_DEFENSE || !freeSaber) ) )
+							{ //don't take attack or defend down on level 1 still, if it's free
+								usedPoints -= bgForcePowerCost[whichOne][final_Powers[whichOne]];
+								final_Powers[whichOne]--;
+							}
+							else
+							{
+								break;
+							}
+						}
+					}
+					else
+					{
+						while (final_Powers[c] > 0 && usedPoints > allowedPoints)
+						{
+							if ( final_Powers[c] > 1 ||
+								((c != FP_LEVITATION) &&
+								(c != FP_SABER_OFFENSE || !freeSaber) &&
+								(c != FP_SABER_DEFENSE || !freeSaber)) )
+							{
+								usedPoints -= bgForcePowerCost[c][final_Powers[c]];
+								final_Powers[c]--;
+							}
+							else
+							{
+								break;
+							}
+						}
+					}
+				}
+
+				c++;
+			}
+
+			powerCycle++;
+			attemptedCycles++;
+
+			if (attemptedCycles > NUM_FORCE_POWERS)
+			{ //I think this should be impossible. But just in case.
+				break;
+			}
+		}
+
+		if (usedPoints > allowedPoints)
+		{ //Still? Fine then.. we will kill all of your powers, except the freebies.
+			i = 0;
+
+			while (i < NUM_FORCE_POWERS)
+			{
+				final_Powers[i] = 0;
+				if (i == FP_LEVITATION ||
+					(i == FP_SABER_OFFENSE && freeSaber) ||
+					(i == FP_SABER_DEFENSE && freeSaber))
+				{
+					final_Powers[i] = 1;
+				}
+				i++;
+			}
+			usedPoints = 0;
+		}
+	}
+
+	if (freeSaber)
+	{
+		if (final_Powers[FP_SABER_OFFENSE] < 1)
+		{
+			final_Powers[FP_SABER_OFFENSE] = 1;
+		}
+		if (final_Powers[FP_SABER_DEFENSE] < 1)
+		{
+			final_Powers[FP_SABER_DEFENSE] = 1;
+		}
+	}
+	if (final_Powers[FP_LEVITATION] < 1)
+	{
+		final_Powers[FP_LEVITATION] = 1;
+	}
+
+	i = 0;
+	while (i < NUM_FORCE_POWERS)
+	{
+		if (final_Powers[i] > FORCE_LEVEL_3)
+		{
+			final_Powers[i] = FORCE_LEVEL_3;
+		}
+		i++;
+	}
+
+	if (fpDisabled)
+	{ //If we specifically have attack or def disabled, force them up to level 3. It's the way
+	  //things work for the case of all powers disabled.
+	  //If jump is disabled, down-cap it to level 1. Otherwise don't do a thing.
+		if (fpDisabled & (1 << FP_LEVITATION))
+		{
+			final_Powers[FP_LEVITATION] = 1;
+		}
+		if (fpDisabled & (1 << FP_SABER_OFFENSE))
+		{
+			final_Powers[FP_SABER_OFFENSE] = 3;
+		}
+		if (fpDisabled & (1 << FP_SABER_DEFENSE))
+		{
+			final_Powers[FP_SABER_DEFENSE] = 3;
+		}
+	}
+
+	if (final_Powers[FP_SABER_OFFENSE] < 1)
+	{
+		final_Powers[FP_SABER_DEFENSE] = 0;
+		final_Powers[FP_SABERTHROW] = 0;
+	}
+
+	//We finally have all the force powers legalized and stored locally.
+	//Put them all into the string and return the result. We already have
+	//the rank there, so print the side and the powers now.
+	Q_strcat(powerOut, 128, va("%i-", final_Side));
+
+	i = strlen(powerOut);
+	c = 0;
+	while (c < NUM_FORCE_POWERS)
+	{
+		strcpy(readBuf, va("%i", final_Powers[c]));
+		powerOut[i] = readBuf[0];
+		c++;
+		i++;
+	}
+	powerOut[i] = 0;
+
+	return maintainsValidity;
+}
+
+#ifdef __LCC__
+// given a boltmatrix, return in vec a normalised vector for the axis requested in flags
+void BG_GiveMeVectorFromMatrix(mdxaBone_t *boltMatrix, int flags, vec3_t vec)
+{
+	switch (flags)
+	{
+	case ORIGIN:
+		vec[0] = boltMatrix->matrix[0][3];
+		vec[1] = boltMatrix->matrix[1][3];
+		vec[2] = boltMatrix->matrix[2][3];
+		break;
+	case POSITIVE_Y:
+		vec[0] = boltMatrix->matrix[0][1];
+		vec[1] = boltMatrix->matrix[1][1];
+		vec[2] = boltMatrix->matrix[2][1];
+ 		break;
+	case POSITIVE_X:
+		vec[0] = boltMatrix->matrix[0][0];
+		vec[1] = boltMatrix->matrix[1][0];
+		vec[2] = boltMatrix->matrix[2][0];
+		break;
+	case POSITIVE_Z:
+		vec[0] = boltMatrix->matrix[0][2];
+		vec[1] = boltMatrix->matrix[1][2];
+		vec[2] = boltMatrix->matrix[2][2];
+		break;
+	case NEGATIVE_Y:
+		vec[0] = -boltMatrix->matrix[0][1];
+		vec[1] = -boltMatrix->matrix[1][1];
+		vec[2] = -boltMatrix->matrix[2][1];
+		break;
+	case NEGATIVE_X:
+		vec[0] = -boltMatrix->matrix[0][0];
+		vec[1] = -boltMatrix->matrix[1][0];
+		vec[2] = -boltMatrix->matrix[2][0];
+		break;
+	case NEGATIVE_Z:
+		vec[0] = -boltMatrix->matrix[0][2];
+		vec[1] = -boltMatrix->matrix[1][2];
+		vec[2] = -boltMatrix->matrix[2][2];
+		break;
+	}
+}
+#endif
+
+/*QUAKED item_***** ( 0 0 0 ) (-16 -16 -16) (16 16 16) suspended
+DO NOT USE THIS CLASS, IT JUST HOLDS GENERAL INFORMATION.
+The suspended flag will allow items to hang in the air, otherwise they are dropped to the next surface.
+
+If an item is the target of another entity, it will not spawn in until fired.
+
+An item fires all of its targets when it is picked up.  If the toucher can't carry it, the targets won't be fired.
+
+"notfree" if set to 1, don't spawn in free for all games
+"notteam" if set to 1, don't spawn in team games
+"notsingle" if set to 1, don't spawn in single player games
+"wait"	override the default wait before respawning.  -1 = never respawn automatically, which can be used with targeted spawning.
+"random" random number of plus or minus seconds varied from the respawn time
+"count" override quantity or duration on most items.
+*/
+
+gitem_t	bg_itemlist[] = 
+{
+	{
+		NULL,				// classname	
+		NULL,				// pickup_sound
+		{	NULL,			// world_model[0]
+			NULL,			// world_model[1]
+			0, 0} ,			// world_model[2],[3]
+		NULL,				// view_model
+/* icon */		NULL,		// icon
+/* pickup */	//NULL,		// pickup_name
+		0,					// quantity
+		0,					// giType (IT_*)
+		0,					// giTag
+/* precache */ "",			// precaches
+/* sounds */ "",			// sounds
+		""					// description
+	},	// leave index 0 alone
+
+	//
+	// Pickups
+	//
+
+/*QUAKED item_shield_sm_instant (.3 .3 1) (-16 -16 -16) (16 16 16) suspended
+Instant shield pickup, restores 25
+*/
+	{
+		"item_shield_sm_instant", 
+		"sound/player/pickupshield.wav",
+        { "models/map_objects/mp/psd_sm.md3",
+		0, 0, 0},
+/* view */		NULL,			
+/* icon */		"gfx/mp/small_shield",
+/* pickup *///	"Shield Small",
+		25,
+		IT_ARMOR,
+		1, //special for shield - max on pickup is maxhealth*tag, thus small shield goes up to 100 shield
+/* precache */ "",
+/* sounds */ ""
+		""					// description
+	},
+
+/*QUAKED item_shield_lrg_instant (.3 .3 1) (-16 -16 -16) (16 16 16) suspended
+Instant shield pickup, restores 100
+*/
+	{
+		"item_shield_lrg_instant", 
+		"sound/player/pickupshield.wav",
+        { "models/map_objects/mp/psd.md3",
+		0, 0, 0},
+/* view */		NULL,			
+/* icon */		"gfx/mp/large_shield",
+/* pickup *///	"Shield Large",
+		100,
+		IT_ARMOR,
+		2, //special for shield - max on pickup is maxhealth*tag, thus large shield goes up to 200 shield
+/* precache */ "",
+/* sounds */ "",
+		""					// description
+	},
+
+/*QUAKED item_medpak_instant (.3 .3 1) (-16 -16 -16) (16 16 16) suspended
+Instant medpack pickup, heals 25
+*/
+	{
+		"item_medpak_instant",
+		"sound/player/pickuphealth.wav",
+        { "models/map_objects/mp/medpac.md3", 
+		0, 0, 0 },
+/* view */		NULL,			
+/* icon */		"gfx/hud/i_icon_medkit",
+/* pickup *///	"Medpack",
+		25,
+		IT_HEALTH,
+		0,
+/* precache */ "",
+/* sounds */ "",
+		""					// description
+	},
+
+
+	//
+	// ITEMS
+	//
+
+/*QUAKED item_seeker (.3 .3 1) (-8 -8 -0) (8 8 16) suspended
+30 seconds of seeker drone
+*/
+	{
+		"item_seeker", 
+		"sound/weapons/w_pkup.wav",
+		{ "models/items/remote.md3", 
+		0, 0, 0} ,
+/* view */		NULL,			
+/* icon */		"gfx/hud/i_icon_seeker",
+/* pickup *///	"Seeker Drone",
+		120,
+		IT_HOLDABLE,
+		HI_SEEKER,
+/* precache */ "",
+/* sounds */ "",
+		"@MENUS_AN_ATTACK_DRONE_SIMILAR"					// description
+	},
+
+/*QUAKED item_shield (.3 .3 1) (-8 -8 -0) (8 8 16) suspended
+Portable shield
+*/
+	{
+		"item_shield", 
+		"sound/weapons/w_pkup.wav",
+		{ "models/map_objects/mp/shield.md3", 
+		0, 0, 0} ,
+/* view */		NULL,			
+/* icon */		"gfx/hud/i_icon_shieldwall",
+/* pickup *///	"Forcefield",
+		120,
+		IT_HOLDABLE,
+		HI_SHIELD,
+/* precache */ "",
+/* sounds */ "sound/weapons/detpack/stick.wav sound/movers/doors/forcefield_on.wav sound/movers/doors/forcefield_off.wav sound/movers/doors/forcefield_lp.wav sound/effects/bumpfield.wav",
+		"@MENUS_THIS_STATIONARY_ENERGY"					// description
+	},
+
+/*QUAKED item_medpac (.3 .3 1) (-8 -8 -0) (8 8 16) suspended
+Bacta canister pickup, heals 25 on use
+*/
+	{
+		"item_medpac",	//should be item_bacta
+		"sound/weapons/w_pkup.wav",
+		{ "models/map_objects/mp/bacta.md3", 
+		0, 0, 0} ,
+/* view */		NULL,			
+/* icon */		"gfx/hud/i_icon_bacta",
+/* pickup *///	"Bacta Canister",
+		25,
+		IT_HOLDABLE,
+		HI_MEDPAC,
+/* precache */ "",
+/* sounds */ "",
+		"@SP_INGAME_BACTA_DESC"					// description
+	},
+
+/*QUAKED item_medpac_big (.3 .3 1) (-8 -8 -0) (8 8 16) suspended
+Big bacta canister pickup, heals 50 on use
+*/
+	{
+		"item_medpac_big",	//should be item_bacta
+		"sound/weapons/w_pkup.wav",
+		{ "models/items/big_bacta.md3", 
+		0, 0, 0} ,
+/* view */		NULL,			
+/* icon */		"gfx/hud/i_icon_big_bacta",
+/* pickup *///	"Bacta Canister",
+		25,
+		IT_HOLDABLE,
+		HI_MEDPAC_BIG,
+/* precache */ "",
+/* sounds */ "",
+		"@SP_INGAME_BACTA_DESC"					// description
+	},
+
+/*QUAKED item_binoculars (.3 .3 1) (-8 -8 -0) (8 8 16) suspended
+These will be standard equipment on the player - DO NOT PLACE
+*/
+	{
+		"item_binoculars", 
+		"sound/weapons/w_pkup.wav",
+		{ "models/items/binoculars.md3", 
+		0, 0, 0} ,
+/* view */		NULL,			
+/* icon */		"gfx/hud/i_icon_zoom",
+/* pickup *///	"Binoculars",
+		60,
+		IT_HOLDABLE,
+		HI_BINOCULARS,
+/* precache */ "",
+/* sounds */ "",
+		"@SP_INGAME_LA_GOGGLES_DESC"					// description
+	},
+
+/*QUAKED item_sentry_gun (.3 .3 1) (-8 -8 -0) (8 8 16) suspended
+Sentry gun inventory pickup.
+*/
+	{
+		"item_sentry_gun", 
+		"sound/weapons/w_pkup.wav",
+		{ "models/items/psgun.glm", 
+		0, 0, 0} ,
+/* view */		NULL,			
+/* icon */		"gfx/hud/i_icon_sentrygun",
+/* pickup *///	"Sentry Gun",
+		120,
+		IT_HOLDABLE,
+		HI_SENTRY_GUN,
+/* precache */ "",
+/* sounds */ "",
+		"@MENUS_THIS_DEADLY_WEAPON_IS"					// description
+	},
+
+/*QUAKED item_jetpack (.3 .3 1) (-8 -8 -0) (8 8 16) suspended
+Do not place.
+*/
+	{
+		"item_jetpack", 
+		"sound/weapons/w_pkup.wav",
+		{ "models/items/psgun.glm", //FIXME: no model
+		0, 0, 0} ,
+/* view */		NULL,			
+/* icon */		"gfx/hud/i_icon_jetpack",
+/* pickup *///	"Sentry Gun",
+		120,
+		IT_HOLDABLE,
+		HI_JETPACK,
+/* precache */ "effects/boba/jet.efx",
+/* sounds */ "sound/chars/boba/JETON.wav sound/chars/boba/JETHOVER.wav sound/effects/fire_lp.wav",
+		"@MENUS_JETPACK_DESC"					// description
+	},
+
+/*QUAKED item_healthdisp (.3 .3 1) (-8 -8 -0) (8 8 16) suspended
+Do not place. For siege classes ONLY.
+*/
+	{
+		"item_healthdisp", 
+		"sound/weapons/w_pkup.wav",
+		{ "models/map_objects/mp/bacta.md3", //replace me
+		0, 0, 0} ,
+/* view */		NULL,			
+/* icon */		"gfx/hud/i_icon_healthdisp",
+/* pickup *///	"Sentry Gun",
+		120,
+		IT_HOLDABLE,
+		HI_HEALTHDISP,
+/* precache */ "",
+/* sounds */ "",
+		""					// description
+	},
+
+/*QUAKED item_ammodisp (.3 .3 1) (-8 -8 -0) (8 8 16) suspended
+Do not place. For siege classes ONLY.
+*/
+	{
+		"item_ammodisp", 
+		"sound/weapons/w_pkup.wav",
+		{ "models/map_objects/mp/bacta.md3", //replace me
+		0, 0, 0} ,
+/* view */		NULL,			
+/* icon */		"gfx/hud/i_icon_ammodisp",
+/* pickup *///	"Sentry Gun",
+		120,
+		IT_HOLDABLE,
+		HI_AMMODISP,
+/* precache */ "",
+/* sounds */ "",
+		""					// description
+	},
+
+/*QUAKED item_eweb_holdable (.3 .3 1) (-8 -8 -0) (8 8 16) suspended
+Do not place. For siege classes ONLY.
+*/
+	{
+		"item_eweb_holdable", 
+		"sound/interface/shieldcon_empty",
+		{ "models/map_objects/hoth/eweb_model.glm",
+		0, 0, 0} ,
+/* view */		NULL,			
+/* icon */		"gfx/hud/i_icon_eweb",
+/* pickup *///	"Sentry Gun",
+		120,
+		IT_HOLDABLE,
+		HI_EWEB,
+/* precache */ "",
+/* sounds */ "",
+		"@MENUS_EWEB_DESC"					// description
+	},
+
+/*QUAKED item_seeker (.3 .3 1) (-8 -8 -0) (8 8 16) suspended
+30 seconds of seeker drone
+*/
+	{
+		"item_cloak", 
+		"sound/weapons/w_pkup.wav",
+		{ "models/items/psgun.glm", //FIXME: no model
+		0, 0, 0} ,
+/* view */		NULL,			
+/* icon */		"gfx/hud/i_icon_cloak",
+/* pickup *///	"Seeker Drone",
+		120,
+		IT_HOLDABLE,
+		HI_CLOAK,
+/* precache */ "",
+/* sounds */ "",
+		"@MENUS_CLOAK_DESC"					// description
+	},
+
+/*QUAKED item_force_enlighten_light (.3 .3 1) (-16 -16 -16) (16 16 16) suspended
+Adds one rank to all Force powers temporarily. Only light jedi can use.
+*/
+	{
+		"item_force_enlighten_light",
+		"sound/player/enlightenment.wav",
+		{ "models/map_objects/mp/jedi_enlightenment.md3", 
+		0, 0, 0} ,
+/* view */		NULL,			
+/* icon */		"gfx/hud/mpi_jlight",
+/* pickup *///	"Light Force Enlightenment",
+		25,
+		IT_POWERUP,
+		PW_FORCE_ENLIGHTENED_LIGHT,
+/* precache */ "",
+/* sounds */ "",
+		""					// description
+	},
+
+/*QUAKED item_force_enlighten_dark (.3 .3 1) (-16 -16 -16) (16 16 16) suspended
+Adds one rank to all Force powers temporarily. Only dark jedi can use.
+*/
+	{
+		"item_force_enlighten_dark",
+		"sound/player/enlightenment.wav",
+		{ "models/map_objects/mp/dk_enlightenment.md3", 
+		0, 0, 0} ,
+/* view */		NULL,			
+/* icon */		"gfx/hud/mpi_dklight",
+/* pickup *///	"Dark Force Enlightenment",
+		25,
+		IT_POWERUP,
+		PW_FORCE_ENLIGHTENED_DARK,
+/* precache */ "",
+/* sounds */ "",
+		""					// description
+	},
+
+/*QUAKED item_force_boon (.3 .3 1) (-16 -16 -16) (16 16 16) suspended
+Unlimited Force Pool for a short time.
+*/
+	{
+		"item_force_boon",
+		"sound/player/boon.wav",
+		{ "models/map_objects/mp/force_boon.md3", 
+		0, 0, 0} ,
+/* view */		NULL,			
+/* icon */		"gfx/hud/mpi_fboon",
+/* pickup *///	"Force Boon",
+		25,
+		IT_POWERUP,
+		PW_FORCE_BOON,
+/* precache */ "",
+/* sounds */ "",
+		""					// description
+	},
+
+/*QUAKED item_ysalimari (.3 .3 1) (-16 -16 -16) (16 16 16) suspended
+A small lizard carried on the player, which prevents the possessor from using any Force power.  However, he is unaffected by any Force power.
+*/
+	{
+		"item_ysalimari",
+		"sound/player/ysalimari.wav",
+		{ "models/map_objects/mp/ysalimari.md3", 
+		0, 0, 0} ,
+/* view */		NULL,			
+/* icon */		"gfx/hud/mpi_ysamari",
+/* pickup *///	"Ysalamiri",
+		25,
+		IT_POWERUP,
+		PW_YSALAMIRI,
+/* precache */ "",
+/* sounds */ "",
+		""					// description
+	},
+
+	//
+	// WEAPONS 
+	//
+
+/*QUAKED weapon_stun_baton (.3 .3 1) (-16 -16 -16) (16 16 16) suspended
+Don't place this
+*/
+	{
+		"weapon_stun_baton", 
+		"sound/weapons/w_pkup.wav",
+        { "models/weapons2/stun_baton/baton_w.glm", 
+		0, 0, 0},
+/* view */		"models/weapons2/stun_baton/baton.md3", 
+/* icon */		"gfx/hud/w_icon_stunbaton",
+/* pickup *///	"Stun Baton",
+		100,
+		IT_WEAPON,
+		WP_STUN_BATON,
+/* precache */ "",
+/* sounds */ "",
+		""					// description
+	},
+
+/*QUAKED weapon_melee (.3 .3 1) (-16 -16 -16) (16 16 16) suspended
+Don't place this
+*/
+	{
+		"weapon_melee", 
+		"sound/weapons/w_pkup.wav",
+        { "models/weapons2/stun_baton/baton_w.glm", 
+		0, 0, 0},
+/* view */		"models/weapons2/stun_baton/baton.md3", 
+/* icon */		"gfx/hud/w_icon_melee",
+/* pickup *///	"Stun Baton",
+		100,
+		IT_WEAPON,
+		WP_MELEE,
+/* precache */ "",
+/* sounds */ "",
+		"@MENUS_MELEE_DESC"					// description
+	},
+
+/*QUAKED weapon_saber (.3 .3 1) (-16 -16 -16) (16 16 16) suspended
+Don't place this
+*/
+	{
+		"weapon_saber", 
+		"sound/weapons/w_pkup.wav",
+        { "models/weapons2/saber/saber_w.glm",
+		0, 0, 0},
+/* view */		"models/weapons2/saber/saber_w.md3",
+/* icon */		"gfx/hud/w_icon_lightsaber",
+/* pickup *///	"Lightsaber",
+		100,
+		IT_WEAPON,
+		WP_SABER,
+/* precache */ "",
+/* sounds */ "",
+		"@MENUS_AN_ELEGANT_WEAPON_FOR"				// description
+	},
+
+/*QUAKED weapon_bryar_pistol (.3 .3 1) (-16 -16 -16) (16 16 16) suspended
+Don't place this
+*/
+	{
+		//"weapon_bryar_pistol", 
+		"weapon_blaster_pistol", 
+		"sound/weapons/w_pkup.wav",
+        { "models/weapons2/blaster_pistol/blaster_pistol_w.glm",//"models/weapons2/briar_pistol/briar_pistol_w.glm", 
+		0, 0, 0},
+/* view */		"models/weapons2/blaster_pistol/blaster_pistol.md3",//"models/weapons2/briar_pistol/briar_pistol.md3", 
+/* icon */		"gfx/hud/w_icon_blaster_pistol",//"gfx/hud/w_icon_rifle",
+/* pickup *///	"Bryar Pistol",
+		100,
+		IT_WEAPON,
+		WP_BRYAR_PISTOL,
+/* precache */ "",
+/* sounds */ "",
+		"@MENUS_BLASTER_PISTOL_DESC"					// description
+	},
+
+/*QUAKED weapon_concussion_rifle (.3 .3 1) (-16 -16 -16) (16 16 16) suspended
+*/
+	{
+		"weapon_concussion_rifle", 
+		"sound/weapons/w_pkup.wav",
+        { "models/weapons2/concussion/c_rifle_w.glm", 
+		0, 0, 0},
+/* view */		"models/weapons2/concussion/c_rifle.md3", 
+/* icon */		"gfx/hud/w_icon_c_rifle",//"gfx/hud/w_icon_rifle",
+/* pickup *///	"Concussion Rifle",
+		50,
+		IT_WEAPON,
+		WP_CONCUSSION,
+/* precache */ "",
+/* sounds */ "",
+		"@MENUS_CONC_RIFLE_DESC"					// description
+	},
+
+/*QUAKED weapon_bryar_pistol_old (.3 .3 1) (-16 -16 -16) (16 16 16) suspended
+Don't place this
+*/
+	{
+		"weapon_bryar_pistol", 
+		"sound/weapons/w_pkup.wav",
+        { "models/weapons2/briar_pistol/briar_pistol_w.glm", 
+		0, 0, 0},
+/* view */		"models/weapons2/briar_pistol/briar_pistol.md3", 
+/* icon */		"gfx/hud/w_icon_briar",//"gfx/hud/w_icon_rifle",
+/* pickup *///	"Bryar Pistol",
+		100,
+		IT_WEAPON,
+		WP_BRYAR_OLD,
+/* precache */ "",
+/* sounds */ "",
+		"@SP_INGAME_BLASTER_PISTOL"					// description
+	},
+
+/*QUAKED weapon_blaster (.3 .3 1) (-16 -16 -16) (16 16 16) suspended
+*/
+	{
+		"weapon_blaster", 
+		"sound/weapons/w_pkup.wav",
+        { "models/weapons2/blaster_r/blaster_w.glm", 
+		0, 0, 0},
+/* view */		"models/weapons2/blaster_r/blaster.md3", 
+/* icon */		"gfx/hud/w_icon_blaster",
+/* pickup *///	"E11 Blaster Rifle",
+		100,
+		IT_WEAPON,
+		WP_BLASTER,
+/* precache */ "",
+/* sounds */ "",
+		"@MENUS_THE_PRIMARY_WEAPON_OF"				// description
+	},
+
+/*QUAKED weapon_disruptor (.3 .3 1) (-16 -16 -16) (16 16 16) suspended
+*/
+	{
+		"weapon_disruptor",
+		"sound/weapons/w_pkup.wav",
+        { "models/weapons2/disruptor/disruptor_w.glm", 
+		0, 0, 0},
+/* view */		"models/weapons2/disruptor/disruptor.md3", 
+/* icon */		"gfx/hud/w_icon_disruptor",
+/* pickup *///	"Tenloss Disruptor Rifle",
+		100,
+		IT_WEAPON,
+		WP_DISRUPTOR,
+/* precache */ "",
+/* sounds */ "",
+		"@MENUS_THIS_NEFARIOUS_WEAPON"					// description
+	},
+
+/*QUAKED weapon_bowcaster (.3 .3 1) (-16 -16 -16) (16 16 16) suspended
+*/
+	{
+		"weapon_bowcaster",
+		"sound/weapons/w_pkup.wav",
+        { "models/weapons2/bowcaster/bowcaster_w.glm", 
+		0, 0, 0},
+/* view */		"models/weapons2/bowcaster/bowcaster.md3", 
+/* icon */		"gfx/hud/w_icon_bowcaster",
+/* pickup *///	"Wookiee Bowcaster",
+		100,
+		IT_WEAPON,
+		WP_BOWCASTER,
+/* precache */ "",
+/* sounds */ "",
+		"@MENUS_THIS_ARCHAIC_LOOKING"					// description
+	},
+
+/*QUAKED weapon_repeater (.3 .3 1) (-16 -16 -16) (16 16 16) suspended
+*/
+	{
+		"weapon_repeater", 
+		"sound/weapons/w_pkup.wav",
+        { "models/weapons2/heavy_repeater/heavy_repeater_w.glm", 
+		0, 0, 0},
+/* view */		"models/weapons2/heavy_repeater/heavy_repeater.md3", 
+/* icon */		"gfx/hud/w_icon_repeater",
+/* pickup *///	"Imperial Heavy Repeater",
+		100,
+		IT_WEAPON,
+		WP_REPEATER,
+/* precache */ "",
+/* sounds */ "",
+		"@MENUS_THIS_DESTRUCTIVE_PROJECTILE"					// description
+	},
+
+/*QUAKED weapon_demp2 (.3 .3 1) (-16 -16 -16) (16 16 16) suspended
+NOTENOTE This weapon is not yet complete.  Don't place it.
+*/
+	{
+		"weapon_demp2", 
+		"sound/weapons/w_pkup.wav",
+        { "models/weapons2/demp2/demp2_w.glm", 
+		0, 0, 0},
+/* view */		"models/weapons2/demp2/demp2.md3", 
+/* icon */		"gfx/hud/w_icon_demp2",
+/* pickup *///	"DEMP2",
+		100,
+		IT_WEAPON,
+		WP_DEMP2,
+/* precache */ "",
+/* sounds */ "",
+		"@MENUS_COMMONLY_REFERRED_TO"					// description
+	},
+
+/*QUAKED weapon_flechette (.3 .3 1) (-16 -16 -16) (16 16 16) suspended
+*/
+	{
+		"weapon_flechette", 
+		"sound/weapons/w_pkup.wav",
+        { "models/weapons2/golan_arms/golan_arms_w.glm", 
+		0, 0, 0},
+/* view */		"models/weapons2/golan_arms/golan_arms.md3", 
+/* icon */		"gfx/hud/w_icon_flechette",
+/* pickup *///	"Golan Arms Flechette",
+		100,
+		IT_WEAPON,
+		WP_FLECHETTE,
+/* precache */ "",
+/* sounds */ "",
+		"@MENUS_WIDELY_USED_BY_THE_CORPORATE"					// description
+	},
+
+/*QUAKED weapon_rocket_launcher (.3 .3 1) (-16 -16 -16) (16 16 16) suspended
+*/
+	{
+		"weapon_rocket_launcher",
+		"sound/weapons/w_pkup.wav",
+        { "models/weapons2/merr_sonn/merr_sonn_w.glm", 
+		0, 0, 0},
+/* view */		"models/weapons2/merr_sonn/merr_sonn.md3", 
+/* icon */		"gfx/hud/w_icon_merrsonn",
+/* pickup *///	"Merr-Sonn Missile System",
+		3,
+		IT_WEAPON,
+		WP_ROCKET_LAUNCHER,
+/* precache */ "",
+/* sounds */ "",
+		"@MENUS_THE_PLX_2M_IS_AN_EXTREMELY"					// description
+	},
+
+/*QUAKED ammo_thermal (.3 .3 1) (-16 -16 -16) (16 16 16) suspended
+*/
+	{
+		"ammo_thermal",
+		"sound/weapons/w_pkup.wav",
+        { "models/weapons2/thermal/thermal_pu.md3", 
+		"models/weapons2/thermal/thermal_w.glm", 0, 0},
+/* view */		"models/weapons2/thermal/thermal.md3", 
+/* icon */		"gfx/hud/w_icon_thermal",
+/* pickup *///	"Thermal Detonators",
+		4,
+		IT_AMMO,
+		AMMO_THERMAL,
+/* precache */ "",
+/* sounds */ "",
+		"@MENUS_THE_THERMAL_DETONATOR"					// description
+	},
+
+/*QUAKED ammo_tripmine (.3 .3 1) (-16 -16 -16) (16 16 16) suspended
+*/
+	{
+		"ammo_tripmine", 
+		"sound/weapons/w_pkup.wav",
+        { "models/weapons2/laser_trap/laser_trap_pu.md3", 
+		"models/weapons2/laser_trap/laser_trap_w.glm", 0, 0},
+/* view */		"models/weapons2/laser_trap/laser_trap.md3", 
+/* icon */		"gfx/hud/w_icon_tripmine",
+/* pickup *///	"Trip Mines",
+		3,
+		IT_AMMO,
+		AMMO_TRIPMINE,
+/* precache */ "",
+/* sounds */ "",
+		"@MENUS_TRIP_MINES_CONSIST_OF"					// description
+	},
+
+/*QUAKED ammo_detpack (.3 .3 1) (-16 -16 -16) (16 16 16) suspended
+*/
+	{
+		"ammo_detpack", 
+		"sound/weapons/w_pkup.wav",
+        { "models/weapons2/detpack/det_pack_pu.md3", "models/weapons2/detpack/det_pack_proj.glm", "models/weapons2/detpack/det_pack_w.glm", 0},
+/* view */		"models/weapons2/detpack/det_pack.md3", 
+/* icon */		"gfx/hud/w_icon_detpack",
+/* pickup *///	"Det Packs",
+		3,
+		IT_AMMO,
+		AMMO_DETPACK,
+/* precache */ "",
+/* sounds */ "",
+		"@MENUS_A_DETONATION_PACK_IS"					// description
+	},
+
+/*QUAKED weapon_thermal (.3 .3 1) (-16 -16 -16) (16 16 16) suspended
+*/
+	{
+		"weapon_thermal",
+		"sound/weapons/w_pkup.wav",
+        { "models/weapons2/thermal/thermal_w.glm", "models/weapons2/thermal/thermal_pu.md3",
+		0, 0 },
+/* view */		"models/weapons2/thermal/thermal.md3", 
+/* icon */		"gfx/hud/w_icon_thermal",
+/* pickup *///	"Thermal Detonator",
+		4,
+		IT_WEAPON,
+		WP_THERMAL,
+/* precache */ "",
+/* sounds */ "",
+		"@MENUS_THE_THERMAL_DETONATOR"					// description
+	},
+
+/*QUAKED weapon_trip_mine (.3 .3 1) (-16 -16 -16) (16 16 16) suspended
+*/
+	{
+		"weapon_trip_mine", 
+		"sound/weapons/w_pkup.wav",
+        { "models/weapons2/laser_trap/laser_trap_w.glm", "models/weapons2/laser_trap/laser_trap_pu.md3",
+		0, 0},
+/* view */		"models/weapons2/laser_trap/laser_trap.md3", 
+/* icon */		"gfx/hud/w_icon_tripmine",
+/* pickup *///	"Trip Mine",
+		3,
+		IT_WEAPON,
+		WP_TRIP_MINE,
+/* precache */ "",
+/* sounds */ "",
+		"@MENUS_TRIP_MINES_CONSIST_OF"					// description
+	},
+
+/*QUAKED weapon_det_pack (.3 .3 1) (-16 -16 -16) (16 16 16) suspended
+*/
+	{
+		"weapon_det_pack", 
+		"sound/weapons/w_pkup.wav",
+        { "models/weapons2/detpack/det_pack_proj.glm", "models/weapons2/detpack/det_pack_pu.md3", "models/weapons2/detpack/det_pack_w.glm", 0},
+/* view */		"models/weapons2/detpack/det_pack.md3", 
+/* icon */		"gfx/hud/w_icon_detpack",
+/* pickup *///	"Det Pack",
+		3,
+		IT_WEAPON,
+		WP_DET_PACK,
+/* precache */ "",
+/* sounds */ "",
+		"@MENUS_A_DETONATION_PACK_IS"					// description
+	},
+
+/*QUAKED weapon_emplaced (.3 .3 1) (-16 -16 -16) (16 16 16) suspended
+*/
+	{
+		"weapon_emplaced", 
+		"sound/weapons/w_pkup.wav",
+        { "models/weapons2/blaster_r/blaster_w.glm", 
+		0, 0, 0},
+/* view */		"models/weapons2/blaster_r/blaster.md3", 
+/* icon */		"gfx/hud/w_icon_blaster",
+/* pickup *///	"Emplaced Gun",
+		50,
+		IT_WEAPON,
+		WP_EMPLACED_GUN,
+/* precache */ "",
+/* sounds */ "",
+		""					// description
+	},
+
+
+//NOTE: This is to keep things from messing up because the turret weapon type isn't real
+	{
+		"weapon_turretwp", 
+		"sound/weapons/w_pkup.wav",
+        { "models/weapons2/blaster_r/blaster_w.glm", 
+		0, 0, 0},
+/* view */		"models/weapons2/blaster_r/blaster.md3", 
+/* icon */		"gfx/hud/w_icon_blaster",
+/* pickup *///	"Turret Gun",
+		50,
+		IT_WEAPON,
+		WP_TURRET,
+/* precache */ "",
+/* sounds */ "",
+		""					// description
+	},
+
+	//
+	// AMMO ITEMS
+	//
+
+/*QUAKED ammo_force (.3 .3 1) (-16 -16 -16) (16 16 16) suspended
+Don't place this
+*/
+	{
+		"ammo_force",
+		"sound/player/pickupenergy.wav",
+        { "models/items/energy_cell.md3", 
+		0, 0, 0},
+/* view */		NULL,			
+/* icon */		"gfx/hud/w_icon_blaster",
+/* pickup *///	"Force??",
+		100,
+		IT_AMMO,
+		AMMO_FORCE,
+/* precache */ "",
+/* sounds */ "",
+		""					// description
+	},
+
+/*QUAKED ammo_blaster (.3 .3 1) (-16 -16 -16) (16 16 16) suspended
+Ammo for the Bryar and Blaster pistols.
+*/
+	{
+		"ammo_blaster",
+		"sound/player/pickupenergy.wav",
+        { "models/items/energy_cell.md3", 
+		0, 0, 0},
+/* view */		NULL,			
+/* icon */		"gfx/hud/i_icon_battery",
+/* pickup *///	"Blaster Pack",
+		100,
+		IT_AMMO,
+		AMMO_BLASTER,
+/* precache */ "",
+/* sounds */ "",
+		""					// description
+	},
+
+/*QUAKED ammo_powercell (.3 .3 1) (-16 -16 -16) (16 16 16) suspended
+Ammo for Tenloss Disruptor, Wookie Bowcaster, and the Destructive Electro Magnetic Pulse (demp2 ) guns
+*/
+	{
+		"ammo_powercell",
+		"sound/player/pickupenergy.wav",
+        { "models/items/power_cell.md3", 
+		0, 0, 0},
+/* view */		NULL,			
+/* icon */		"gfx/mp/ammo_power_cell",
+/* pickup *///	"Power Cell",
+		100,
+		IT_AMMO,
+		AMMO_POWERCELL,
+/* precache */ "",
+/* sounds */ "",
+		""					// description
+	},
+
+/*QUAKED ammo_metallic_bolts (.3 .3 1) (-16 -16 -16) (16 16 16) suspended
+Ammo for Imperial Heavy Repeater and the Golan Arms Flechette
+*/
+	{
+		"ammo_metallic_bolts",
+		"sound/player/pickupenergy.wav",
+        { "models/items/metallic_bolts.md3", 
+		0, 0, 0},
+/* view */		NULL,			
+/* icon */		"gfx/mp/ammo_metallic_bolts",
+/* pickup *///	"Metallic Bolts",
+		100,
+		IT_AMMO,
+		AMMO_METAL_BOLTS,
+/* precache */ "",
+/* sounds */ "",
+		""					// description
+	},
+
+/*QUAKED ammo_rockets (.3 .3 1) (-16 -16 -16) (16 16 16) suspended
+Ammo for Merr-Sonn portable missile launcher
+*/
+	{
+		"ammo_rockets",
+		"sound/player/pickupenergy.wav",
+        { "models/items/rockets.md3", 
+		0, 0, 0},
+/* view */		NULL,			
+/* icon */		"gfx/mp/ammo_rockets",
+/* pickup *///	"Rockets",
+		3,
+		IT_AMMO,
+		AMMO_ROCKETS,
+/* precache */ "",
+/* sounds */ "",
+		""					// description
+	},
+
+/*QUAKED ammo_all (.3 .3 1) (-16 -16 -16) (16 16 16) suspended
+DO NOT PLACE in a map, this is only for siege classes that have ammo
+dispensing ability
+*/
+	{
+		"ammo_all",
+		"sound/player/pickupenergy.wav",
+        { "models/items/battery.md3",  //replace me
+		0, 0, 0},
+/* view */		NULL,			
+/* icon */		"gfx/mp/ammo_rockets", //replace me
+/* pickup *///	"Rockets",
+		0,
+		IT_AMMO,
+		-1,
+/* precache */ "",
+/* sounds */ "",
+		""					// description
+	},
+
+	//
+	// POWERUP ITEMS
+	//
+/*QUAKED team_CTF_redflag (1 0 0) (-16 -16 -16) (16 16 16)
+Only in CTF games
+*/
+	{
+		"team_CTF_redflag",
+		NULL,
+        { "models/flags/r_flag.md3",
+		"models/flags/r_flag_ysal.md3", 0, 0 },
+/* view */		NULL,			
+/* icon */		"gfx/hud/mpi_rflag",
+/* pickup *///	"Red Flag",
+		0,
+		IT_TEAM,
+		PW_REDFLAG,
+/* precache */ "",
+/* sounds */ "",
+		""					// description
+	},
+
+/*QUAKED team_CTF_blueflag (0 0 1) (-16 -16 -16) (16 16 16)
+Only in CTF games
+*/
+	{
+		"team_CTF_blueflag",
+		NULL,
+        { "models/flags/b_flag.md3",
+		"models/flags/b_flag_ysal.md3", 0, 0 },
+/* view */		NULL,			
+/* icon */		"gfx/hud/mpi_bflag",
+/* pickup *///	"Blue Flag",
+		0,
+		IT_TEAM,
+		PW_BLUEFLAG,
+/* precache */ "",
+/* sounds */ "",
+		""					// description
+	},
+
+	//
+	// PERSISTANT POWERUP ITEMS
+	//
+
+	/*QUAKED team_CTF_neutralflag (0 0 1) (-16 -16 -16) (16 16 16)
+Only in One Flag CTF games
+*/
+	{
+		"team_CTF_neutralflag",
+		NULL,
+        { "models/flags/n_flag.md3",
+		0, 0, 0 },
+/* view */		NULL,			
+/* icon */		"icons/iconf_neutral1",
+/* pickup *///	"Neutral Flag",
+		0,
+		IT_TEAM,
+		PW_NEUTRALFLAG,
+/* precache */ "",
+/* sounds */ "",
+		""					// description
+	},
+
+	{
+		"item_redcube",
+		"sound/player/pickupenergy.wav",
+        { "models/powerups/orb/r_orb.md3",
+		0, 0, 0 },
+/* view */		NULL,			
+/* icon */		"icons/iconh_rorb",
+/* pickup *///	"Red Cube",
+		0,
+		IT_TEAM,
+		0,
+/* precache */ "",
+/* sounds */ "",
+		""					// description
+	},
+
+	{
+		"item_bluecube",
+		"sound/player/pickupenergy.wav",
+        { "models/powerups/orb/b_orb.md3",
+		0, 0, 0 },
+/* view */		NULL,			
+/* icon */		"icons/iconh_borb",
+/* pickup *///	"Blue Cube",
+		0,
+		IT_TEAM,
+		0,
+/* precache */ "",
+/* sounds */ "",
+		""					// description
+	},
+
+	// end of list marker
+	{NULL}
+};
+
+int		bg_numItems = sizeof(bg_itemlist) / sizeof(bg_itemlist[0]) - 1;
+
+float vectoyaw( const vec3_t vec ) {
+	float	yaw;
+	
+	if (vec[YAW] == 0 && vec[PITCH] == 0) {
+		yaw = 0;
+	} else {
+		if (vec[PITCH]) {
+			yaw = ( atan2( vec[YAW], vec[PITCH]) * 180 / M_PI );
+		} else if (vec[YAW] > 0) {
+			yaw = 90;
+		} else {
+			yaw = 270;
+		}
+		if (yaw < 0) {
+			yaw += 360;
+		}
+	}
+
+	return yaw;
+}
+
+qboolean BG_HasYsalamiri(int gametype, playerState_t *ps)
+{
+	if (gametype == GT_CTY &&
+		(ps->powerups[PW_REDFLAG] || ps->powerups[PW_BLUEFLAG]))
+	{
+		return qtrue;
+	}
+
+	if (ps->powerups[PW_YSALAMIRI])
+	{
+		return qtrue;
+	}
+
+	return qfalse;
+}
+
+qboolean BG_CanUseFPNow(int gametype, playerState_t *ps, int time, forcePowers_t power)
+{
+	if (BG_HasYsalamiri(gametype, ps))
+	{
+		return qfalse;
+	}
+
+	if ( ps->forceRestricted || ps->trueNonJedi )
+	{
+		return qfalse;
+	}
+
+	if (ps->weapon == WP_EMPLACED_GUN)
+	{ //can't use any of your powers while on an emplaced weapon
+		return qfalse;
+	}
+
+	if (ps->m_iVehicleNum)
+	{ //can't use powers while riding a vehicle (this may change, I don't know)
+		return qfalse;
+	}
+
+	if (ps->duelInProgress)
+	{
+		if (power != FP_SABER_OFFENSE && power != FP_SABER_DEFENSE && /*power != FP_SABERTHROW &&*/
+			power != FP_LEVITATION)
+		{
+			if (!ps->saberLockFrame || power != FP_PUSH)
+			{
+				return qfalse;
+			}
+		}
+	}
+
+	if (ps->saberLockFrame || ps->saberLockTime > time)
+	{
+		if (power != FP_PUSH)
+		{
+			return qfalse;
+		}
+	}
+
+	if (ps->fallingToDeath)
+	{
+		return qfalse;
+	}
+
+	if ((ps->brokenLimbs & (1 << BROKENLIMB_RARM)) ||
+		(ps->brokenLimbs & (1 << BROKENLIMB_LARM)))
+	{ //powers we can't use with a broken arm
+        switch (power)
+		{
+		case FP_PUSH:
+		case FP_PULL:
+		case FP_GRIP:
+		case FP_LIGHTNING:
+		case FP_DRAIN:
+			return qfalse;
+		default:
+			break;
+		}
+	}
+
+	return qtrue;
+}
+
+/*
+==============
+BG_FindItemForPowerup
+==============
+*/
+gitem_t	*BG_FindItemForPowerup( powerup_t pw ) {
+	int		i;
+
+	for ( i = 0 ; i < bg_numItems ; i++ ) {
+		if ( (bg_itemlist[i].giType == IT_POWERUP || 
+					bg_itemlist[i].giType == IT_TEAM) && 
+			bg_itemlist[i].giTag == pw ) {
+			return &bg_itemlist[i];
+		}
+	}
+
+	return NULL;
+}
+
+
+/*
+==============
+BG_FindItemForHoldable
+==============
+*/
+gitem_t	*BG_FindItemForHoldable( holdable_t pw ) {
+	int		i;
+
+	for ( i = 0 ; i < bg_numItems ; i++ ) {
+		if ( bg_itemlist[i].giType == IT_HOLDABLE && bg_itemlist[i].giTag == pw ) {
+			return &bg_itemlist[i];
+		}
+	}
+
+	Com_Error( ERR_DROP, "HoldableItem not found" );
+
+	return NULL;
+}
+
+
+/*
+===============
+BG_FindItemForWeapon
+
+===============
+*/
+gitem_t	*BG_FindItemForWeapon( weapon_t weapon ) {
+	gitem_t	*it;
+	
+	for ( it = bg_itemlist + 1 ; it->classname ; it++) {
+		if ( it->giType == IT_WEAPON && it->giTag == weapon ) {
+			return it;
+		}
+	}
+
+	Com_Error( ERR_DROP, "Couldn't find item for weapon %i", weapon);
+	return NULL;
+}
+
+/*
+===============
+BG_FindItemForAmmo
+
+===============
+*/
+gitem_t	*BG_FindItemForAmmo( ammo_t ammo ) {
+	gitem_t	*it;
+	
+	for ( it = bg_itemlist + 1 ; it->classname ; it++) {
+		if ( it->giType == IT_AMMO && it->giTag == ammo ) {
+			return it;
+		}
+	}
+
+	Com_Error( ERR_DROP, "Couldn't find item for ammo %i", ammo);
+	return NULL;
+}
+
+/*
+===============
+BG_FindItem
+
+===============
+*/
+gitem_t	*BG_FindItem( const char *classname ) {
+	gitem_t	*it;
+	
+	for ( it = bg_itemlist + 1 ; it->classname ; it++ ) {
+		if ( !Q_stricmp( it->classname, classname) )
+			return it;
+	}
+
+	return NULL;
+}
+
+/*
+============
+BG_PlayerTouchesItem
+
+Items can be picked up without actually touching their physical bounds to make
+grabbing them easier
+============
+*/
+qboolean	BG_PlayerTouchesItem( playerState_t *ps, entityState_t *item, int atTime ) {
+	vec3_t		origin;
+
+	BG_EvaluateTrajectory( &item->pos, atTime, origin );
+
+	// we are ignoring ducked differences here
+	if ( ps->origin[0] - origin[0] > 44
+		|| ps->origin[0] - origin[0] < -50
+		|| ps->origin[1] - origin[1] > 36
+		|| ps->origin[1] - origin[1] < -36
+		|| ps->origin[2] - origin[2] > 36
+		|| ps->origin[2] - origin[2] < -36 ) {
+		return qfalse;
+	}
+
+	return qtrue;
+}
+
+int BG_ProperForceIndex(int power)
+{
+	int i = 0;
+
+	while (i < NUM_FORCE_POWERS)
+	{
+		if (forcePowerSorted[i] == power)
+		{
+			return i;
+		}
+
+		i++;
+	}
+
+	return -1;
+}
+
+void BG_CycleForce(playerState_t *ps, int direction)
+{
+	int i = ps->fd.forcePowerSelected;
+	int x = i;
+	int presel = i;
+	int foundnext = -1;
+
+	if (!ps->fd.forcePowersKnown & (1 << x) ||
+		x >= NUM_FORCE_POWERS ||
+		x == -1)
+	{ //apparently we have no valid force powers
+		return;
+	}
+
+	x = BG_ProperForceIndex(x);
+	presel = x;
+
+	if (direction == 1)
+	{ //get the next power
+		x++;
+	}
+	else
+	{ //get the previous power
+		x--;
+	}
+
+	if (x >= NUM_FORCE_POWERS)
+	{ //cycled off the end.. cycle around to the first
+		x = 0;
+	}
+	if (x < 0)
+	{ //cycled off the beginning.. cycle around to the last
+		x = NUM_FORCE_POWERS-1;
+	}
+
+	i = forcePowerSorted[x]; //the "sorted" value of this power
+
+	while (x != presel)
+	{ //loop around to the current force power
+		if (ps->fd.forcePowersKnown & (1 << i) && i != ps->fd.forcePowerSelected)
+		{ //we have the force power
+			if (i != FP_LEVITATION &&
+				i != FP_SABER_OFFENSE &&
+				i != FP_SABER_DEFENSE &&
+				i != FP_SABERTHROW)
+			{ //it's selectable
+				foundnext = i;
+				break;
+			}
+		}
+
+		if (direction == 1)
+		{ //next
+			x++;
+		}
+		else
+		{ //previous
+			x--;
+		}
+	
+		if (x >= NUM_FORCE_POWERS)
+		{ //loop around
+			x = 0;
+		}
+		if (x < 0)
+		{ //loop around
+			x = NUM_FORCE_POWERS-1;
+		}
+
+		i = forcePowerSorted[x]; //set to the sorted value again
+	}
+
+	if (foundnext != -1)
+	{ //found one, select it
+		ps->fd.forcePowerSelected = foundnext;
+	}
+}
+
+int BG_GetItemIndexByTag(int tag, int type)
+{ //Get the itemlist index from the tag and type
+	int i = 0;
+
+	while (i < bg_numItems)
+	{
+		if (bg_itemlist[i].giTag == tag &&
+			bg_itemlist[i].giType == type)
+		{
+			return i;
+		}
+
+		i++;
+	}
+
+	return 0;
+}
+
+//yeah..
+qboolean BG_IsItemSelectable(playerState_t *ps, int item)
+{
+	if (item == HI_HEALTHDISP || item == HI_AMMODISP ||
+		item == HI_JETPACK)
+	{
+		return qfalse;
+	}
+	return qtrue;
+}
+
+void BG_CycleInven(playerState_t *ps, int direction)
+{
+	int i;
+	int dontFreeze = 0;
+	int original;
+
+	i = bg_itemlist[ps->stats[STAT_HOLDABLE_ITEM]].giTag;
+	original = i;
+
+	if (direction == 1)
+	{ //next
+		i++;
+		if (i == HI_NUM_HOLDABLE)
+		{
+			i = 1;
+		}
+	}
+	else
+	{ //previous
+		i--;
+		if (i == 0)
+		{
+			i = HI_NUM_HOLDABLE-1;
+		}
+	}
+
+	while (i != original)
+	{ //go in a full loop until hitting something, if hit nothing then select nothing
+		if (ps->stats[STAT_HOLDABLE_ITEMS] & (1 << i))
+		{ //we have it, select it.
+			if (BG_IsItemSelectable(ps, i))
+			{
+				ps->stats[STAT_HOLDABLE_ITEM] = BG_GetItemIndexByTag(i, IT_HOLDABLE);
+				break;
+			}
+		}
+
+		if (direction == 1)
+		{ //next
+			i++;
+		}
+		else
+		{ //previous
+			i--;
+		}
+
+		if (i <= 0)
+		{ //wrap around to the last
+			i = HI_NUM_HOLDABLE-1;
+		}
+		else if (i >= HI_NUM_HOLDABLE)
+		{ //wrap around to the first
+			i = 1;
+		}
+
+		dontFreeze++;
+		if (dontFreeze >= 32)
+		{ //yeah, sure, whatever (it's 2 am and I'm paranoid and can't frickin think)
+			break;
+		}
+	}
+}
+
+/*
+================
+BG_CanItemBeGrabbed
+
+Returns false if the item should not be picked up.
+This needs to be the same for client side prediction and server use.
+================
+*/
+qboolean BG_CanItemBeGrabbed( int gametype, const entityState_t *ent, const playerState_t *ps ) {
+	gitem_t	*item;
+
+	if ( ent->modelindex < 1 || ent->modelindex >= bg_numItems ) {
+		Com_Error( ERR_DROP, "BG_CanItemBeGrabbed: index out of range" );
+	}
+
+	item = &bg_itemlist[ent->modelindex];
+
+	if ( ps )
+	{
+		if ( ps->trueJedi )
+		{//force powers and saber only
+			if ( item->giType != IT_TEAM //not a flag
+				&& item->giType != IT_ARMOR//not shields
+				&& (item->giType != IT_WEAPON || item->giTag != WP_SABER)//not a saber
+				&& (item->giType != IT_HOLDABLE || item->giTag != HI_SEEKER)//not a seeker
+				&& (item->giType != IT_POWERUP || item->giTag == PW_YSALAMIRI) )//not a force pick-up
+			{
+				return qfalse;
+			}
+		}
+		else if ( ps->trueNonJedi )
+		{//can't pick up force powerups
+			if ( (item->giType == IT_POWERUP && item->giTag != PW_YSALAMIRI) //if a powerup, can only can pick up ysalamiri
+				|| (item->giType == IT_HOLDABLE && item->giTag == HI_SEEKER)//if holdable, cannot pick up seeker 
+				|| (item->giType == IT_WEAPON && item->giTag == WP_SABER ) )//or if it's a saber
+			{
+				return qfalse;
+			}
+		}
+		if ( ps->isJediMaster && item && (item->giType == IT_WEAPON || item->giType == IT_AMMO))
+		{//jedi master cannot pick up weapons
+			return qfalse;
+		}
+		if ( ps->duelInProgress )
+		{ //no picking stuff up while in a duel, no matter what the type is
+			return qfalse;
+		}
+	}
+	else
+	{//safety return since below code assumes a non-null ps
+		return qfalse;
+	}
+
+	switch( item->giType ) {
+	case IT_WEAPON:
+		if (ent->generic1 == ps->clientNum && ent->powerups)
+		{
+			return qfalse;
+		}
+		if (!(ent->eFlags & EF_DROPPEDWEAPON) && (ps->stats[STAT_WEAPONS] & (1 << item->giTag)) &&
+			item->giTag != WP_THERMAL && item->giTag != WP_TRIP_MINE && item->giTag != WP_DET_PACK)
+		{ //weaponstay stuff.. if this isn't dropped, and you already have it, you don't get it.
+			return qfalse;
+		}
+		if (item->giTag == WP_THERMAL || item->giTag == WP_TRIP_MINE || item->giTag == WP_DET_PACK)
+		{ //check to see if full on ammo for this, if so, then..
+			int ammoIndex = weaponData[item->giTag].ammoIndex;
+			if (ps->ammo[ammoIndex] >= ammoData[ammoIndex].max)
+			{ //don't need it
+				return qfalse;
+			}
+		}
+		return qtrue;	// weapons are always picked up
+
+	case IT_AMMO:
+		if (item->giTag == -1)
+		{ //special case for "all ammo" packs
+			return qtrue;
+		}
+		if ( ps->ammo[item->giTag] >= ammoData[item->giTag].max) {
+			return qfalse;		// can't hold any more
+		}
+		return qtrue;
+
+	case IT_ARMOR:
+		if ( ps->stats[STAT_ARMOR] >= ps->stats[STAT_MAX_HEALTH]/* * item->giTag*/ ) {
+			return qfalse;
+		}
+		return qtrue;
+
+	case IT_HEALTH:
+		// small and mega healths will go over the max, otherwise
+		// don't pick up if already at max
+		if ((ps->fd.forcePowersActive & (1 << FP_RAGE)))
+		{
+			return qfalse;
+		}
+
+		if ( item->quantity == 5 || item->quantity == 100 ) {
+			if ( ps->stats[STAT_HEALTH] >= ps->stats[STAT_MAX_HEALTH] * 2 ) {
+				return qfalse;
+			}
+			return qtrue;
+		}
+
+		if ( ps->stats[STAT_HEALTH] >= ps->stats[STAT_MAX_HEALTH] ) {
+			return qfalse;
+		}
+		return qtrue;
+
+	case IT_POWERUP:
+		if (ps && (ps->powerups[PW_YSALAMIRI]))
+		{
+			if (item->giTag != PW_YSALAMIRI)
+			{
+				return qfalse;
+			}
+		}
+		return qtrue;	// powerups are always picked up
+
+	case IT_TEAM: // team items, such as flags
+		if( gametype == GT_CTF || gametype == GT_CTY ) {
+			// ent->modelindex2 is non-zero on items if they are dropped
+			// we need to know this because we can pick up our dropped flag (and return it)
+			// but we can't pick up our flag at base
+			if (ps->persistant[PERS_TEAM] == TEAM_RED) {
+				if (item->giTag == PW_BLUEFLAG ||
+					(item->giTag == PW_REDFLAG && ent->modelindex2) ||
+					(item->giTag == PW_REDFLAG && ps->powerups[PW_BLUEFLAG]) )
+					return qtrue;
+			} else if (ps->persistant[PERS_TEAM] == TEAM_BLUE) {
+				if (item->giTag == PW_REDFLAG ||
+					(item->giTag == PW_BLUEFLAG && ent->modelindex2) ||
+					(item->giTag == PW_BLUEFLAG && ps->powerups[PW_REDFLAG]) )
+					return qtrue;
+			}
+		}
+
+		return qfalse;
+
+	case IT_HOLDABLE:
+		if ( ps->stats[STAT_HOLDABLE_ITEMS] & (1 << item->giTag))
+		{
+			return qfalse;
+		}
+		return qtrue;
+
+        case IT_BAD:
+            Com_Error( ERR_DROP, "BG_CanItemBeGrabbed: IT_BAD" );
+        default:
+#ifndef Q3_VM
+#ifndef NDEBUG // bk0001204
+          Com_Printf("BG_CanItemBeGrabbed: unknown enum %d\n", item->giType );
+#endif
+#endif
+         break;
+	}
+
+	return qfalse;
+}
+
+//======================================================================
+
+/*
+================
+BG_EvaluateTrajectory
+
+================
+*/
+void BG_EvaluateTrajectory( const trajectory_t *tr, int atTime, vec3_t result ) {
+	float		deltaTime;
+	float		phase;
+
+	switch( tr->trType ) {
+	case TR_STATIONARY:
+	case TR_INTERPOLATE:
+		VectorCopy( tr->trBase, result );
+		break;
+	case TR_LINEAR:
+		deltaTime = ( atTime - tr->trTime ) * 0.001;	// milliseconds to seconds
+		VectorMA( tr->trBase, deltaTime, tr->trDelta, result );
+		break;
+	case TR_SINE:
+		deltaTime = ( atTime - tr->trTime ) / (float) tr->trDuration;
+		phase = sin( deltaTime * M_PI * 2 );
+		VectorMA( tr->trBase, phase, tr->trDelta, result );
+		break;
+	case TR_LINEAR_STOP:
+		if ( atTime > tr->trTime + tr->trDuration ) {
+			atTime = tr->trTime + tr->trDuration;
+		}
+		deltaTime = ( atTime - tr->trTime ) * 0.001;	// milliseconds to seconds
+		if ( deltaTime < 0 ) {
+			deltaTime = 0;
+		}
+		VectorMA( tr->trBase, deltaTime, tr->trDelta, result );
+		break;
+	case TR_NONLINEAR_STOP:
+		if ( atTime > tr->trTime + tr->trDuration ) 
+		{
+			atTime = tr->trTime + tr->trDuration;
+		}
+		//new slow-down at end
+		if ( atTime - tr->trTime > tr->trDuration || atTime - tr->trTime <= 0  )
+		{
+			deltaTime = 0;
+		}
+		else
+		{//FIXME: maybe scale this somehow?  So that it starts out faster and stops faster?
+			deltaTime = tr->trDuration*0.001f*((float)cos( DEG2RAD(90.0f - (90.0f*((float)atTime-tr->trTime)/(float)tr->trDuration)) ));
+		}
+		VectorMA( tr->trBase, deltaTime, tr->trDelta, result );
+		break;
+	case TR_GRAVITY:
+		deltaTime = ( atTime - tr->trTime ) * 0.001;	// milliseconds to seconds
+		VectorMA( tr->trBase, deltaTime, tr->trDelta, result );
+		result[2] -= 0.5 * DEFAULT_GRAVITY * deltaTime * deltaTime;		// FIXME: local gravity...
+		break;
+	default:
+#ifdef QAGAME
+		Com_Error( ERR_DROP, "BG_EvaluateTrajectory: [GAME SIDE] unknown trType: %i", tr->trType );
+#else
+		Com_Error( ERR_DROP, "BG_EvaluateTrajectory: [CLIENTGAME SIDE] unknown trType: %i", tr->trType );
+#endif
+		break;
+	}
+}
+
+/*
+================
+BG_EvaluateTrajectoryDelta
+
+For determining velocity at a given time
+================
+*/
+void BG_EvaluateTrajectoryDelta( const trajectory_t *tr, int atTime, vec3_t result ) {
+	float	deltaTime;
+	float	phase;
+
+	switch( tr->trType ) {
+	case TR_STATIONARY:
+	case TR_INTERPOLATE:
+		VectorClear( result );
+		break;
+	case TR_LINEAR:
+		VectorCopy( tr->trDelta, result );
+		break;
+	case TR_SINE:
+		deltaTime = ( atTime - tr->trTime ) / (float) tr->trDuration;
+		phase = cos( deltaTime * M_PI * 2 );	// derivative of sin = cos
+		phase *= 0.5;
+		VectorScale( tr->trDelta, phase, result );
+		break;
+	case TR_LINEAR_STOP:
+		if ( atTime > tr->trTime + tr->trDuration ) {
+			VectorClear( result );
+			return;
+		}
+		VectorCopy( tr->trDelta, result );
+		break;
+	case TR_NONLINEAR_STOP:
+		if ( atTime - tr->trTime > tr->trDuration || atTime - tr->trTime <= 0  )
+		{
+			VectorClear( result );
+			return;
+		}
+		deltaTime = tr->trDuration*0.001f*((float)cos( DEG2RAD(90.0f - (90.0f*((float)atTime-tr->trTime)/(float)tr->trDuration)) ));
+		VectorScale( tr->trDelta, deltaTime, result );
+		break;
+	case TR_GRAVITY:
+		deltaTime = ( atTime - tr->trTime ) * 0.001;	// milliseconds to seconds
+		VectorCopy( tr->trDelta, result );
+		result[2] -= DEFAULT_GRAVITY * deltaTime;		// FIXME: local gravity...
+		break;
+	default:
+		Com_Error( ERR_DROP, "BG_EvaluateTrajectoryDelta: unknown trType: %i", tr->trTime );
+		break;
+	}
+}
+
+char *eventnames[] = {
+	"EV_NONE",
+
+	"EV_CLIENTJOIN",
+
+	"EV_FOOTSTEP",
+	"EV_FOOTSTEP_METAL",
+	"EV_FOOTSPLASH",
+	"EV_FOOTWADE",
+	"EV_SWIM",
+
+	"EV_STEP_4",
+	"EV_STEP_8",
+	"EV_STEP_12",
+	"EV_STEP_16",
+
+	"EV_FALL",
+
+	"EV_JUMP_PAD",			// boing sound at origin", jump sound on player
+
+	"EV_GHOUL2_MARK",			//create a projectile impact mark on something with a client-side g2 instance.
+
+	"EV_GLOBAL_DUEL",
+	"EV_PRIVATE_DUEL",
+
+	"EV_JUMP",
+	"EV_ROLL",
+	"EV_WATER_TOUCH",	// foot touches
+	"EV_WATER_LEAVE",	// foot leaves
+	"EV_WATER_UNDER",	// head touches
+	"EV_WATER_CLEAR",	// head leaves
+
+	"EV_ITEM_PICKUP",			// normal item pickups are predictable
+	"EV_GLOBAL_ITEM_PICKUP",	// powerup / team sounds are broadcast to everyone
+
+	"EV_VEH_FIRE",
+
+	"EV_NOAMMO",
+	"EV_CHANGE_WEAPON",
+	"EV_FIRE_WEAPON",
+	"EV_ALT_FIRE",
+	"EV_SABER_ATTACK",
+	"EV_SABER_HIT",
+	"EV_SABER_BLOCK",
+	"EV_SABER_CLASHFLARE",
+	"EV_SABER_UNHOLSTER",
+	"EV_BECOME_JEDIMASTER",
+	"EV_DISRUPTOR_MAIN_SHOT",
+	"EV_DISRUPTOR_SNIPER_SHOT",
+	"EV_DISRUPTOR_SNIPER_MISS",
+	"EV_DISRUPTOR_HIT",
+	"EV_DISRUPTOR_ZOOMSOUND",
+
+	"EV_PREDEFSOUND",
+
+	"EV_TEAM_POWER",
+
+	"EV_SCREENSHAKE",
+	
+	"EV_LOCALTIMER",
+
+	"EV_USE",			// +Use key
+
+	"EV_USE_ITEM0",
+	"EV_USE_ITEM1",
+	"EV_USE_ITEM2",
+	"EV_USE_ITEM3",
+	"EV_USE_ITEM4",
+	"EV_USE_ITEM5",
+	"EV_USE_ITEM6",
+	"EV_USE_ITEM7",
+	"EV_USE_ITEM8",
+	"EV_USE_ITEM9",
+	"EV_USE_ITEM10",
+	"EV_USE_ITEM11",
+	"EV_USE_ITEM12",
+	"EV_USE_ITEM13",
+	"EV_USE_ITEM14",
+	"EV_USE_ITEM15",
+
+	"EV_ITEMUSEFAIL",
+
+	"EV_ITEM_RESPAWN",
+	"EV_ITEM_POP",
+	"EV_PLAYER_TELEPORT_IN",
+	"EV_PLAYER_TELEPORT_OUT",
+
+	"EV_GRENADE_BOUNCE",		// eventParm will be the soundindex
+	"EV_MISSILE_STICK",
+
+	"EV_PLAY_EFFECT",
+	"EV_PLAY_EFFECT_ID", //finally gave in and added it..
+	"EV_PLAY_PORTAL_EFFECT_ID",
+
+	"EV_PLAYDOORSOUND",
+	"EV_PLAYDOORLOOPSOUND",
+	"EV_BMODEL_SOUND",
+
+	"EV_MUTE_SOUND",
+	"EV_VOICECMD_SOUND",
+	"EV_GENERAL_SOUND",
+	"EV_GLOBAL_SOUND",		// no attenuation
+	"EV_GLOBAL_TEAM_SOUND",
+	"EV_ENTITY_SOUND",
+
+	"EV_PLAY_ROFF",
+
+	"EV_GLASS_SHATTER",
+	"EV_DEBRIS",
+	"EV_MISC_MODEL_EXP",
+
+	"EV_CONC_ALT_IMPACT",
+
+	"EV_MISSILE_HIT",
+	"EV_MISSILE_MISS",
+	"EV_MISSILE_MISS_METAL",
+	"EV_BULLET",				// otherEntity is the shooter
+
+	"EV_PAIN",
+	"EV_DEATH1",
+	"EV_DEATH2",
+	"EV_DEATH3",
+	"EV_OBITUARY",
+
+	"EV_POWERUP_QUAD",
+	"EV_POWERUP_BATTLESUIT",
+	//"EV_POWERUP_REGEN",
+
+	"EV_FORCE_DRAINED",
+
+	"EV_GIB_PLAYER",			// gib a previously living player
+	"EV_SCOREPLUM",			// score plum
+
+	"EV_CTFMESSAGE",
+
+	"EV_BODYFADE",
+
+	"EV_SIEGE_ROUNDOVER",
+	"EV_SIEGE_OBJECTIVECOMPLETE",
+
+	"EV_DESTROY_GHOUL2_INSTANCE",
+
+	"EV_DESTROY_WEAPON_MODEL",
+
+	"EV_GIVE_NEW_RANK",
+	"EV_SET_FREE_SABER",
+	"EV_SET_FORCE_DISABLE",
+
+	"EV_WEAPON_CHARGE",
+	"EV_WEAPON_CHARGE_ALT",
+
+	"EV_SHIELD_HIT",
+
+	"EV_DEBUG_LINE",
+	"EV_TESTLINE",
+	"EV_STOPLOOPINGSOUND",
+	"EV_STARTLOOPINGSOUND",
+	"EV_TAUNT",
+//fixme, added a bunch that aren't here!
+};
+
+/*
+===============
+BG_AddPredictableEventToPlayerstate
+
+Handles the sequence numbers
+===============
+*/
+
+//void	trap_Cvar_VariableStringBuffer( const char *var_name, char *buffer, int bufsize );
+
+void BG_AddPredictableEventToPlayerstate( int newEvent, int eventParm, playerState_t *ps ) {
+
+#ifdef _DEBUG
+	{
+		static vmCvar_t		showEvents;
+		static qboolean		isRegistered = qfalse;
+
+		if (!isRegistered)
+		{
+			trap_Cvar_Register(&showEvents, "showevents", "0", 0);
+			isRegistered = qtrue;
+		}
+
+		if ( showEvents.integer != 0 ) {
+#ifdef QAGAME
+			Com_Printf(" game event svt %5d -> %5d: num = %20s parm %d\n", ps->pmove_framecount/*ps->commandTime*/, ps->eventSequence, eventnames[newEvent], eventParm);
+#else
+			Com_Printf("Cgame event svt %5d -> %5d: num = %20s parm %d\n", ps->pmove_framecount/*ps->commandTime*/, ps->eventSequence, eventnames[newEvent], eventParm);
+#endif
+		}
+	}
+#endif
+	ps->events[ps->eventSequence & (MAX_PS_EVENTS-1)] = newEvent;
+	ps->eventParms[ps->eventSequence & (MAX_PS_EVENTS-1)] = eventParm;
+	ps->eventSequence++;
+}
+
+/*
+========================
+BG_TouchJumpPad
+========================
+*/
+void BG_TouchJumpPad( playerState_t *ps, entityState_t *jumppad ) {
+	vec3_t	angles;
+	float p;
+	int effectNum;
+
+	// spectators don't use jump pads
+	if ( ps->pm_type != PM_NORMAL && ps->pm_type != PM_JETPACK && ps->pm_type != PM_FLOAT ) {
+		return;
+	}
+
+	// if we didn't hit this same jumppad the previous frame
+	// then don't play the event sound again if we are in a fat trigger
+	if ( ps->jumppad_ent != jumppad->number ) {
+
+		vectoangles( jumppad->origin2, angles);
+		p = fabs( AngleNormalize180( angles[PITCH] ) );
+		if( p < 45 ) {
+			effectNum = 0;
+		} else {
+			effectNum = 1;
+		}
+	}
+	// remember hitting this jumppad this frame
+	ps->jumppad_ent = jumppad->number;
+	ps->jumppad_frame = ps->pmove_framecount;
+	// give the player the velocity from the jumppad
+	VectorCopy( jumppad->origin2, ps->velocity );
+}
+
+/*
+=================
+BG_EmplacedView
+
+Shared code for emplaced angle gun constriction
+=================
+*/
+int BG_EmplacedView(vec3_t baseAngles, vec3_t angles, float *newYaw, float constraint)
+{
+	float dif = AngleSubtract(baseAngles[YAW], angles[YAW]);
+
+	if (dif > constraint ||
+		dif < -constraint)
+	{
+		float amt;
+
+		if (dif > constraint)
+		{
+			amt = (dif-constraint);
+			dif = constraint;
+		}
+		else if (dif < -constraint)
+		{
+			amt = (dif+constraint);
+			dif = -constraint;
+		}
+		else
+		{
+			amt = 0.0f;
+		}
+
+		*newYaw = AngleSubtract(angles[YAW], -dif);
+
+		if (amt > 1.0f || amt < -1.0f)
+		{ //significant, force the view
+			return 2;
+		}
+		else
+		{ //just a little out of range
+			return 1;
+		}
+	}
+
+	return 0;
+}
+
+//To see if the client is trying to use one of the included skins not meant for MP.
+//I don't much care for hardcoded strings, but this seems the best way to go.
+qboolean BG_IsValidCharacterModel(const char *modelName, const char *skinName)
+{
+	if (!Q_stricmp(modelName, "kyle"))
+	{
+		if (!Q_stricmp(skinName, "fpls"))
+		{
+			return qfalse;
+		}
+		else if (!Q_stricmp(skinName, "fpls2"))
+		{
+			return qfalse;
+		}
+		else if (!Q_stricmp(skinName, "fpls3"))
+		{
+			return qfalse;
+		}
+	}
+	return qtrue;
+}
+
+qboolean BG_ValidateSkinForTeam( const char *modelName, char *skinName, int team, float *colors )
+{
+	char trunc[6];
+	int i = 0;
+	while (i < 5)
+	{
+		trunc[i] = modelName[i];
+		i++;
+	}
+	trunc[i] = 0;
+
+	if (!Q_stricmp(trunc, "jedi_"))
+	{ //argh, it's a custom player skin!
+		if (team == TEAM_RED && colors)
+		{
+			colors[0] = 1.0f;
+			colors[1] = 0.0f;
+			colors[2] = 0.0f;
+		}
+		else if (team == TEAM_BLUE && colors)
+		{
+			colors[0] = 0.0f;
+			colors[1] = 0.0f;
+			colors[2] = 1.0f;
+		}
+		return qtrue;
+	}
+
+	if (team == TEAM_RED)
+	{
+		if ( Q_stricmp( "red", skinName ) != 0 )
+		{//not "red"
+			if ( Q_stricmp( "blue", skinName ) == 0
+				|| Q_stricmp( "default", skinName ) == 0
+				|| strchr(skinName, '|')//a multi-skin playerModel
+				|| !BG_IsValidCharacterModel(modelName, skinName) )
+			{
+				Q_strncpyz(skinName, "red", MAX_QPATH);
+				return qfalse;
+			}
+			else
+			{//need to set it to red
+				int len = strlen( skinName );
+				if ( len < 3 )
+				{//too short to be "red"
+					Q_strcat(skinName, MAX_QPATH, "_red");
+				}
+				else
+				{
+					char	*start = &skinName[len-3];
+					if ( Q_strncmp( "red", start, 3 ) != 0 )
+					{//doesn't already end in "red"
+						if ( len+4 >= MAX_QPATH )
+						{//too big to append "_red"
+							Q_strncpyz(skinName, "red", MAX_QPATH);
+							return qfalse;
+						}
+						else
+						{
+							Q_strcat(skinName, MAX_QPATH, "_red");
+						}
+					}
+				}
+				//if file does not exist, set to "red"
+				if ( !BG_FileExists( va( "models/players/%s/model_%s.skin", modelName, skinName ) ) )
+				{
+					Q_strncpyz(skinName, "red", MAX_QPATH);
+				}
+				return qfalse;
+			}
+		}
+
+	}
+	else if (team == TEAM_BLUE)
+	{
+		if ( Q_stricmp( "blue", skinName ) != 0 )
+		{
+			if ( Q_stricmp( "red", skinName ) == 0
+				|| Q_stricmp( "default", skinName ) == 0
+				|| strchr(skinName, '|')//a multi-skin playerModel
+				|| !BG_IsValidCharacterModel(modelName, skinName) )
+			{
+				Q_strncpyz(skinName, "blue", MAX_QPATH);
+				return qfalse;
+			}
+			else
+			{//need to set it to blue
+				int len = strlen( skinName );
+				if ( len < 4 )
+				{//too short to be "blue"
+					Q_strcat(skinName, MAX_QPATH, "_blue");
+				}
+				else 
+				{
+					char	*start = &skinName[len-4];
+					if ( Q_strncmp( "blue", start, 4 ) != 0 )
+					{//doesn't already end in "blue"
+						if ( len+5 >= MAX_QPATH )
+						{//too big to append "_blue"
+							Q_strncpyz(skinName, "blue", MAX_QPATH);
+							return qfalse;
+						}
+						else
+						{
+							Q_strcat(skinName, MAX_QPATH, "_blue");
+						}
+					}
+				}
+				//if file does not exist, set to "blue"
+				if ( !BG_FileExists( va( "models/players/%s/model_%s.skin", modelName, skinName ) ) )
+				{
+					Q_strncpyz(skinName, "blue", MAX_QPATH);
+				}
+				return qfalse;
+			}
+		}
+	}
+	return qtrue;
+}
+
+/*
+========================
+BG_PlayerStateToEntityState
+
+This is done after each set of usercmd_t on the server,
+and after local prediction on the client
+========================
+*/
+void BG_PlayerStateToEntityState( playerState_t *ps, entityState_t *s, qboolean snap ) {
+	int		i;
+
+	if ( ps->pm_type == PM_INTERMISSION || ps->pm_type == PM_SPECTATOR ) {
+		s->eType = ET_INVISIBLE;
+	} else if ( ps->stats[STAT_HEALTH] <= GIB_HEALTH ) {
+		s->eType = ET_INVISIBLE;
+	} else {
+		s->eType = ET_PLAYER;
+	}
+
+	s->number = ps->clientNum;
+
+	s->pos.trType = TR_INTERPOLATE;
+	VectorCopy( ps->origin, s->pos.trBase );
+	if ( snap ) {
+		SnapVector( s->pos.trBase );
+	}
+	// set the trDelta for flag direction
+	VectorCopy( ps->velocity, s->pos.trDelta );
+
+	s->apos.trType = TR_INTERPOLATE;
+	VectorCopy( ps->viewangles, s->apos.trBase );
+	if ( snap ) {
+		SnapVector( s->apos.trBase );
+	}
+
+	s->trickedentindex = ps->fd.forceMindtrickTargetIndex;
+	s->trickedentindex2 = ps->fd.forceMindtrickTargetIndex2;
+	s->trickedentindex3 = ps->fd.forceMindtrickTargetIndex3;
+	s->trickedentindex4 = ps->fd.forceMindtrickTargetIndex4;
+
+	s->forceFrame = ps->saberLockFrame;
+
+	s->emplacedOwner = ps->electrifyTime;
+
+	s->speed = ps->speed;
+
+	s->genericenemyindex = ps->genericEnemyIndex;
+
+	s->activeForcePass = ps->activeForcePass;
+
+	s->angles2[YAW] = ps->movementDir;
+	s->legsAnim = ps->legsAnim;
+	s->torsoAnim = ps->torsoAnim;
+
+	s->legsFlip = ps->legsFlip;
+	s->torsoFlip = ps->torsoFlip;
+
+	s->clientNum = ps->clientNum;		// ET_PLAYER looks here instead of at number
+										// so corpses can also reference the proper config
+	s->eFlags = ps->eFlags;
+	s->eFlags2 = ps->eFlags2;
+
+	s->saberInFlight = ps->saberInFlight;
+	s->saberEntityNum = ps->saberEntityNum;
+	s->saberMove = ps->saberMove;
+	s->forcePowersActive = ps->fd.forcePowersActive;
+
+	if (ps->duelInProgress)
+	{
+		s->bolt1 = 1;
+	}
+	else
+	{
+		s->bolt1 = 0;
+	}
+
+	s->otherEntityNum2 = ps->emplacedIndex;
+
+	s->saberHolstered = ps->saberHolstered;
+
+	if (ps->genericEnemyIndex != -1)
+	{
+		s->eFlags |= EF_SEEKERDRONE;
+	}
+
+	if ( ps->stats[STAT_HEALTH] <= 0 ) {
+		s->eFlags |= EF_DEAD;
+	} else {
+		s->eFlags &= ~EF_DEAD;
+	}
+
+	if ( ps->externalEvent ) {
+		s->event = ps->externalEvent;
+		s->eventParm = ps->externalEventParm;
+	} else if ( ps->entityEventSequence < ps->eventSequence ) {
+		int		seq;
+
+		if ( ps->entityEventSequence < ps->eventSequence - MAX_PS_EVENTS) {
+			ps->entityEventSequence = ps->eventSequence - MAX_PS_EVENTS;
+		}
+		seq = ps->entityEventSequence & (MAX_PS_EVENTS-1);
+		s->event = ps->events[ seq ] | ( ( ps->entityEventSequence & 3 ) << 8 );
+		s->eventParm = ps->eventParms[ seq ];
+		ps->entityEventSequence++;
+	}
+
+
+	s->weapon = ps->weapon;
+	s->groundEntityNum = ps->groundEntityNum;
+
+	s->powerups = 0;
+	for ( i = 0 ; i < MAX_POWERUPS ; i++ ) {
+		if ( ps->powerups[ i ] ) {
+			s->powerups |= 1 << i;
+		}
+	}
+
+	s->loopSound = ps->loopSound;
+	s->generic1 = ps->generic1;
+
+	//NOT INCLUDED IN ENTITYSTATETOPLAYERSTATE:
+	s->modelindex2 = ps->weaponstate;
+	s->constantLight = ps->weaponChargeTime;
+
+	VectorCopy(ps->lastHitLoc, s->origin2);
+
+	s->isJediMaster = ps->isJediMaster;
+
+	s->time2 = ps->holocronBits;
+
+	s->fireflag = ps->fd.saberAnimLevel;
+
+	s->heldByClient = ps->heldByClient;
+	s->ragAttach = ps->ragAttach;
+
+	s->iModelScale = ps->iModelScale;
+
+	s->brokenLimbs = ps->brokenLimbs;
+
+	s->hasLookTarget = ps->hasLookTarget;
+	s->lookTarget = ps->lookTarget;
+
+	s->customRGBA[0] = ps->customRGBA[0];
+	s->customRGBA[1] = ps->customRGBA[1];
+	s->customRGBA[2] = ps->customRGBA[2];
+	s->customRGBA[3] = ps->customRGBA[3];
+
+	s->m_iVehicleNum = ps->m_iVehicleNum;
+}
+
+/*
+========================
+BG_PlayerStateToEntityStateExtraPolate
+
+This is done after each set of usercmd_t on the server,
+and after local prediction on the client
+========================
+*/
+void BG_PlayerStateToEntityStateExtraPolate( playerState_t *ps, entityState_t *s, int time, qboolean snap ) {
+	int		i;
+
+	if ( ps->pm_type == PM_INTERMISSION || ps->pm_type == PM_SPECTATOR ) {
+		s->eType = ET_INVISIBLE;
+	} else if ( ps->stats[STAT_HEALTH] <= GIB_HEALTH ) {
+		s->eType = ET_INVISIBLE;
+	} else {
+		s->eType = ET_PLAYER;
+	}
+
+	s->number = ps->clientNum;
+
+	s->pos.trType = TR_LINEAR_STOP;
+	VectorCopy( ps->origin, s->pos.trBase );
+	if ( snap ) {
+		SnapVector( s->pos.trBase );
+	}
+	// set the trDelta for flag direction and linear prediction
+	VectorCopy( ps->velocity, s->pos.trDelta );
+	// set the time for linear prediction
+	s->pos.trTime = time;
+	// set maximum extra polation time
+	s->pos.trDuration = 50; // 1000 / sv_fps (default = 20)
+
+	s->apos.trType = TR_INTERPOLATE;
+	VectorCopy( ps->viewangles, s->apos.trBase );
+	if ( snap ) {
+		SnapVector( s->apos.trBase );
+	}
+
+	s->trickedentindex = ps->fd.forceMindtrickTargetIndex;
+	s->trickedentindex2 = ps->fd.forceMindtrickTargetIndex2;
+	s->trickedentindex3 = ps->fd.forceMindtrickTargetIndex3;
+	s->trickedentindex4 = ps->fd.forceMindtrickTargetIndex4;
+
+	s->forceFrame = ps->saberLockFrame;
+
+	s->emplacedOwner = ps->electrifyTime;
+
+	s->speed = ps->speed;
+
+	s->genericenemyindex = ps->genericEnemyIndex;
+
+	s->activeForcePass = ps->activeForcePass;
+
+	s->angles2[YAW] = ps->movementDir;
+	s->legsAnim = ps->legsAnim;
+	s->torsoAnim = ps->torsoAnim;
+
+	s->legsFlip = ps->legsFlip;
+	s->torsoFlip = ps->torsoFlip;
+
+	s->clientNum = ps->clientNum;		// ET_PLAYER looks here instead of at number
+										// so corpses can also reference the proper config
+	s->eFlags = ps->eFlags;
+	s->eFlags2 = ps->eFlags2;
+
+	s->saberInFlight = ps->saberInFlight;
+	s->saberEntityNum = ps->saberEntityNum;
+	s->saberMove = ps->saberMove;
+	s->forcePowersActive = ps->fd.forcePowersActive;
+
+	if (ps->duelInProgress)
+	{
+		s->bolt1 = 1;
+	}
+	else
+	{
+		s->bolt1 = 0;
+	}
+
+	s->otherEntityNum2 = ps->emplacedIndex;
+
+	s->saberHolstered = ps->saberHolstered;
+
+	if (ps->genericEnemyIndex != -1)
+	{
+		s->eFlags |= EF_SEEKERDRONE;
+	}
+
+	if ( ps->stats[STAT_HEALTH] <= 0 ) {
+		s->eFlags |= EF_DEAD;
+	} else {
+		s->eFlags &= ~EF_DEAD;
+	}
+
+	if ( ps->externalEvent ) {
+		s->event = ps->externalEvent;
+		s->eventParm = ps->externalEventParm;
+	} else if ( ps->entityEventSequence < ps->eventSequence ) {
+		int		seq;
+
+		if ( ps->entityEventSequence < ps->eventSequence - MAX_PS_EVENTS) {
+			ps->entityEventSequence = ps->eventSequence - MAX_PS_EVENTS;
+		}
+		seq = ps->entityEventSequence & (MAX_PS_EVENTS-1);
+		s->event = ps->events[ seq ] | ( ( ps->entityEventSequence & 3 ) << 8 );
+		s->eventParm = ps->eventParms[ seq ];
+		ps->entityEventSequence++;
+	}
+	s->weapon = ps->weapon;
+	s->groundEntityNum = ps->groundEntityNum;
+
+	s->powerups = 0;
+	for ( i = 0 ; i < MAX_POWERUPS ; i++ ) {
+		if ( ps->powerups[ i ] ) {
+			s->powerups |= 1 << i;
+		}
+	}
+
+	s->loopSound = ps->loopSound;
+	s->generic1 = ps->generic1;
+
+	//NOT INCLUDED IN ENTITYSTATETOPLAYERSTATE:
+	s->modelindex2 = ps->weaponstate;
+	s->constantLight = ps->weaponChargeTime;
+
+	VectorCopy(ps->lastHitLoc, s->origin2);
+
+	s->isJediMaster = ps->isJediMaster;
+
+	s->time2 = ps->holocronBits;
+
+	s->fireflag = ps->fd.saberAnimLevel;
+
+	s->heldByClient = ps->heldByClient;
+	s->ragAttach = ps->ragAttach;
+
+	s->iModelScale = ps->iModelScale;
+
+	s->brokenLimbs = ps->brokenLimbs;
+
+	s->hasLookTarget = ps->hasLookTarget;
+	s->lookTarget = ps->lookTarget;
+
+	s->customRGBA[0] = ps->customRGBA[0];
+	s->customRGBA[1] = ps->customRGBA[1];
+	s->customRGBA[2] = ps->customRGBA[2];
+	s->customRGBA[3] = ps->customRGBA[3];
+
+	s->m_iVehicleNum = ps->m_iVehicleNum;
+}
+
+/*
+=============================================================================
+
+PLAYER ANGLES
+
+=============================================================================
+*/
+
+//perform the appropriate model precache routine
+#ifdef QAGAME //game
+extern int trap_G2API_InitGhoul2Model(void **ghoul2Ptr, const char *fileName, int modelIndex, qhandle_t customSkin,
+						  qhandle_t customShader, int modelFlags, int lodBias); //exists on game/cgame/ui, only used on game
+extern void trap_G2API_CleanGhoul2Models(void **ghoul2Ptr); //exists on game/cgame/ui, only used on game
+#else //cgame/ui
+extern qhandle_t trap_R_RegisterModel( const char *name ); //exists on cgame/ui
+#endif
+//game/cgame/ui
+extern qhandle_t trap_R_RegisterSkin( const char *name ); //exists on game/cgame/ui
+
+int BG_ModelCache(const char *modelName, const char *skinName)
+{
+#ifdef QAGAME
+	void *g2 = NULL;
+
+	if (skinName && skinName[0])
+	{
+		trap_R_RegisterSkin(skinName);
+	}
+
+	//I could hook up a precache ghoul2 function, but oh well, this works
+	trap_G2API_InitGhoul2Model(&g2, modelName, 0, 0, 0, 0, 0);
+	if (g2)
+	{ //now get rid of it
+		trap_G2API_CleanGhoul2Models(&g2);
+	}
+	return 0;
+#else
+	if (skinName && skinName[0])
+	{
+		trap_R_RegisterSkin(skinName);
+	}
+	return trap_R_RegisterModel(modelName);
+#endif
+}
+
+#ifdef _XBOX	// Hacky BG_Alloc replacement
+
+// This file claims to be stateless. Yeah, right. Regardless, I'm not setting
+// aside 5.5 MB of static buffers for this crap. Let's use Z_Malloc. Of course,
+// we still need to deal with the fact that any code using BG_Malloc is almost
+// certainly leaking memory like a sieve.
+
+// Dave addendum - TAG_BG_ALLOC is entirely freed when the level starts.
+void *BG_Alloc ( int size )
+{
+	return Z_Malloc(size, TAG_BG_ALLOC, qfalse, 4);
+}
+
+void *BG_AllocUnaligned ( int size )
+{
+	// Ignore the unaligned hint, this function isn't called anyway
+	return Z_Malloc(size, TAG_BG_ALLOC, qfalse, 4);
+}
+
+// Because the interface to BG_TempAlloc/BG_TempFree is brain-dead, we need
+// to remember our last few temporary allocations performed.
+#define MAX_TEMP_ALLOCS	3
+static void	*tempAllocPointers[MAX_TEMP_ALLOCS] = { 0 };
+static int	tempAllocSizes[MAX_TEMP_ALLOCS] = { 0 };
+
+void *BG_TempAlloc( int size )
+{
+	int i;
+
+	// Do we have a free spot?
+	for (i = 0; i < MAX_TEMP_ALLOCS; ++i)
+		if (!tempAllocPointers[i])
+			break;
+
+	if (i == MAX_TEMP_ALLOCS)
+	{
+		assert(!"No space for TempAlloc -> Increase MAX_TEMP_ALLOCS");
+		return NULL;
+	}
+
+	tempAllocPointers[i] = Z_Malloc(size, TAG_TEMP_WORKSPACE, qfalse, 4);
+	tempAllocSizes[i] = size;
+
+	return tempAllocPointers[i];
+}
+
+void BG_TempFree( int size )
+{
+	int i;
+
+	// Find the allocation
+	for (i = MAX_TEMP_ALLOCS - 1; i >= 0; --i)
+		if (tempAllocPointers[i] && (tempAllocSizes[i] == size))
+			break;
+
+	if (i < 0)
+	{
+		assert(!"BG_TempFree doesn't match a call to BG_TempAlloc");
+		return;
+	}
+
+	Z_Free(tempAllocPointers[i]);
+	tempAllocPointers[i] = 0;
+	tempAllocSizes[i] = 0;
+
+	return;
+}
+
+char *BG_StringAlloc ( const char *source )
+{
+	char *dest;
+
+	dest = (char *) BG_Alloc ( strlen ( source ) + 1 );
+	strcpy ( dest, source );
+	return dest;
+}
+
+qboolean BG_OutOfMemory ( void )
+{
+	// Never called
+	return qfalse;
+}
+
+#else // _XBOX
+
+#ifdef QAGAME
+#define MAX_POOL_SIZE	3000000 //1024000
+#elif defined CGAME //don't need as much for cgame stuff. 2mb will be fine.
+#define MAX_POOL_SIZE	2048000
+#else //And for the ui the only thing we'll be using this for anyway is allocating anim data for g2 menu models
+#define MAX_POOL_SIZE	512000
+#endif
+
+//I am using this for all the stuff like NPC client structures on server/client and
+//non-humanoid animations as well until/if I can get dynamic memory working properly
+//with casted datatypes, which is why it is so large.
+
+
+static char		bg_pool[MAX_POOL_SIZE];
+static int		bg_poolSize = 0;
+static int		bg_poolTail = MAX_POOL_SIZE;
+
+void *BG_Alloc ( int size )
+{
+	bg_poolSize = ((bg_poolSize + 0x00000003) & 0xfffffffc);
+
+	if (bg_poolSize + size > bg_poolTail)
+	{
+		Com_Error( ERR_DROP, "BG_Alloc: buffer exceeded tail (%d > %d)", bg_poolSize + size, bg_poolTail);
+		return 0;
+	}
+
+	bg_poolSize += size;
+
+	return &bg_pool[bg_poolSize-size];
+}
+
+void *BG_AllocUnaligned ( int size )
+{
+	if (bg_poolSize + size > bg_poolTail)
+	{
+		Com_Error( ERR_DROP, "BG_AllocUnaligned: buffer exceeded tail (%d > %d)", bg_poolSize + size, bg_poolTail);
+		return 0;
+	}
+
+	bg_poolSize += size;
+
+	return &bg_pool[bg_poolSize-size];
+}
+
+void *BG_TempAlloc( int size )
+{
+	size = ((size + 0x00000003) & 0xfffffffc);
+
+	if (bg_poolTail - size < bg_poolSize)
+	{
+		Com_Error( ERR_DROP, "BG_TempAlloc: buffer exceeded head (%d > %d)", bg_poolTail - size, bg_poolSize);
+		return 0;
+	}
+
+	bg_poolTail -= size;
+
+	return &bg_pool[bg_poolTail];
+}
+
+void BG_TempFree( int size )
+{
+	size = ((size + 0x00000003) & 0xfffffffc);
+
+	if (bg_poolTail+size > MAX_POOL_SIZE)
+	{
+		Com_Error( ERR_DROP, "BG_TempFree: tail greater than size (%d > %d)", bg_poolTail+size, MAX_POOL_SIZE );
+	}
+
+	bg_poolTail += size;
+}
+
+char *BG_StringAlloc ( const char *source )
+{
+	char *dest;
+
+	dest = BG_Alloc ( strlen ( source ) + 1 );
+	strcpy ( dest, source );
+	return dest;
+}
+
+qboolean BG_OutOfMemory ( void )
+{
+	return bg_poolSize >= MAX_POOL_SIZE;
+}
+
+#endif // _XBOX && QAGAME
+
+#include "../namespace_end.h"
diff --git a/codemp/game/bg_panimate.c b/codemp/game/bg_panimate.c
new file mode 100644
index 0000000..e73a979
--- /dev/null
+++ b/codemp/game/bg_panimate.c
@@ -0,0 +1,2957 @@
+// BG_PAnimate.c
+
+#include "q_shared.h"
+#include "bg_public.h"
+#include "bg_strap.h"
+#include "bg_local.h"
+#include "anims.h"
+#include "../cgame/animtable.h"
+#ifdef QAGAME
+#include "g_local.h"
+#endif
+
+#ifdef CGAME
+#include "../namespace_begin.h"
+extern sfxHandle_t trap_S_RegisterSound( const char *sample);
+extern int trap_FX_RegisterEffect( const char *file);
+#include "../namespace_end.h"
+#endif
+
+/*
+==============================================================================
+BEGIN: Animation utility functions (sequence checking)
+==============================================================================
+*/
+//Called regardless of pm validity:
+
+// VVFIXME - Most of these functions are totally stateless and stupid. Don't
+// need multiple copies of this, but it's much easier (and less likely to
+// break in the future) if I keep separate namespace versions now.
+#include "../namespace_begin.h"
+
+qboolean BG_SaberStanceAnim( int anim )
+{
+	switch ( anim )
+	{
+	case BOTH_STAND1://not really a saberstance anim, actually... "saber off" stance
+	case BOTH_STAND2://single-saber, medium style
+	case BOTH_SABERFAST_STANCE://single-saber, fast style
+	case BOTH_SABERSLOW_STANCE://single-saber, strong style
+	case BOTH_SABERSTAFF_STANCE://saber staff style
+	case BOTH_SABERDUAL_STANCE://dual saber style
+		return qtrue;
+		break;
+	}
+	return qfalse;
+}
+
+qboolean BG_CrouchAnim( int anim )
+{
+	switch ( anim )
+	{
+	case BOTH_SIT1:				//# Normal chair sit.
+	case BOTH_SIT2:				//# Lotus position.
+	case BOTH_SIT3:				//# Sitting in tired position: elbows on knees
+	case BOTH_CROUCH1:			//# Transition from standing to crouch
+	case BOTH_CROUCH1IDLE:		//# Crouching idle
+	case BOTH_CROUCH1WALK:		//# Walking while crouched
+	case BOTH_CROUCH1WALKBACK:	//# Walking while crouched
+	case BOTH_CROUCH2TOSTAND1:	//# going from crouch2 to stand1
+	case BOTH_CROUCH3:			//# Desann crouching down to Kyle (cin 9)
+	case BOTH_KNEES1:			//# Tavion on her knees
+	case BOTH_CROUCHATTACKBACK1://FIXME: not if in middle of anim?
+	case BOTH_ROLL_STAB:
+		return qtrue;
+		break;
+	}
+	return qfalse;
+}
+
+qboolean BG_InSpecialJump( int anim )
+{
+	switch ( (anim) )
+	{
+	case BOTH_WALL_RUN_RIGHT:
+	case BOTH_WALL_RUN_RIGHT_STOP:
+	case BOTH_WALL_RUN_RIGHT_FLIP:
+	case BOTH_WALL_RUN_LEFT:
+	case BOTH_WALL_RUN_LEFT_STOP:
+	case BOTH_WALL_RUN_LEFT_FLIP:
+	case BOTH_WALL_FLIP_RIGHT:
+	case BOTH_WALL_FLIP_LEFT:
+	case BOTH_FLIP_BACK1:
+	case BOTH_FLIP_BACK2:
+	case BOTH_FLIP_BACK3:
+	case BOTH_WALL_FLIP_BACK1:
+	case BOTH_BUTTERFLY_LEFT:
+	case BOTH_BUTTERFLY_RIGHT:
+	case BOTH_BUTTERFLY_FL1:
+	case BOTH_BUTTERFLY_FR1:
+	case BOTH_FJSS_TR_BL:
+	case BOTH_FJSS_TL_BR:
+	case BOTH_FORCELEAP2_T__B_:
+	case BOTH_JUMPFLIPSLASHDOWN1://#
+	case BOTH_JUMPFLIPSTABDOWN://#
+	case BOTH_JUMPATTACK6:
+	case BOTH_JUMPATTACK7:
+	case BOTH_ARIAL_LEFT:
+	case BOTH_ARIAL_RIGHT:
+	case BOTH_ARIAL_F1:
+	case BOTH_CARTWHEEL_LEFT:
+	case BOTH_CARTWHEEL_RIGHT:
+
+	case BOTH_FORCELONGLEAP_START:
+	case BOTH_FORCELONGLEAP_ATTACK:
+	case BOTH_FORCEWALLRUNFLIP_START:
+	case BOTH_FORCEWALLRUNFLIP_END:
+	case BOTH_FORCEWALLRUNFLIP_ALT:
+	case BOTH_FLIP_ATTACK7:
+	case BOTH_FLIP_HOLD7:
+	case BOTH_FLIP_LAND:
+	case BOTH_A7_SOULCAL:
+		return qtrue;
+	}
+	if ( BG_InReboundJump( anim ) )
+	{
+		return qtrue;
+	}
+	if ( BG_InReboundHold( anim ) )
+	{
+		return qtrue;
+	}
+	if ( BG_InReboundRelease( anim ) )
+	{
+		return qtrue;
+	}
+	if ( BG_InBackFlip( anim ) )
+	{
+		return qtrue;
+	}
+	return qfalse;
+}
+
+qboolean BG_InSaberStandAnim( int anim )
+{
+	switch ( (anim) )
+	{
+	case BOTH_SABERFAST_STANCE:
+	case BOTH_STAND2:
+	case BOTH_SABERSLOW_STANCE:
+	case BOTH_SABERDUAL_STANCE:
+	case BOTH_SABERSTAFF_STANCE:
+		return qtrue;
+	default:
+		return qfalse;
+	}
+}
+
+qboolean BG_InReboundJump( int anim )
+{
+	switch ( anim )
+	{
+	case BOTH_FORCEWALLREBOUND_FORWARD:
+	case BOTH_FORCEWALLREBOUND_LEFT:
+	case BOTH_FORCEWALLREBOUND_BACK:
+	case BOTH_FORCEWALLREBOUND_RIGHT:
+		return qtrue;
+		break;
+	}
+	return qfalse;
+}
+
+qboolean BG_InReboundHold( int anim )
+{
+	switch ( anim )
+	{
+	case BOTH_FORCEWALLHOLD_FORWARD:
+	case BOTH_FORCEWALLHOLD_LEFT:
+	case BOTH_FORCEWALLHOLD_BACK:
+	case BOTH_FORCEWALLHOLD_RIGHT:
+		return qtrue;
+		break;
+	}
+	return qfalse;
+}
+
+qboolean BG_InReboundRelease( int anim )
+{
+	switch ( anim )
+	{
+	case BOTH_FORCEWALLRELEASE_FORWARD:
+	case BOTH_FORCEWALLRELEASE_LEFT:
+	case BOTH_FORCEWALLRELEASE_BACK:
+	case BOTH_FORCEWALLRELEASE_RIGHT:
+		return qtrue;
+		break;
+	}
+	return qfalse;
+}
+
+qboolean BG_InBackFlip( int anim )
+{
+	switch ( anim )
+	{
+	case BOTH_FLIP_BACK1:
+	case BOTH_FLIP_BACK2:
+	case BOTH_FLIP_BACK3:
+		return qtrue;
+		break;
+	}
+	return qfalse;
+}
+
+qboolean BG_DirectFlippingAnim( int anim )
+{
+	switch ( (anim) )
+	{
+	case BOTH_FLIP_F:			//# Flip forward
+	case BOTH_FLIP_B:			//# Flip backwards
+	case BOTH_FLIP_L:			//# Flip left
+	case BOTH_FLIP_R:			//# Flip right
+		return qtrue;
+		break;
+	}
+
+	return qfalse;
+}
+
+qboolean BG_SaberInAttack( int move )
+{
+	if ( move >= LS_A_TL2BR && move <= LS_A_T2B )
+	{
+		return qtrue;
+	}
+	switch ( move )
+	{
+	case LS_A_BACK:
+	case LS_A_BACK_CR:
+	case LS_A_BACKSTAB:
+	case LS_ROLL_STAB:
+	case LS_A_LUNGE:
+	case LS_A_JUMP_T__B_:
+	case LS_A_FLIP_STAB:
+	case LS_A_FLIP_SLASH:
+	case LS_JUMPATTACK_DUAL:
+	case LS_JUMPATTACK_ARIAL_LEFT:
+	case LS_JUMPATTACK_ARIAL_RIGHT:
+	case LS_JUMPATTACK_CART_LEFT:
+	case LS_JUMPATTACK_CART_RIGHT:
+	case LS_JUMPATTACK_STAFF_LEFT:
+	case LS_JUMPATTACK_STAFF_RIGHT:
+	case LS_BUTTERFLY_LEFT:
+	case LS_BUTTERFLY_RIGHT:
+	case LS_A_BACKFLIP_ATK:
+	case LS_SPINATTACK_DUAL:
+	case LS_SPINATTACK:
+	case LS_LEAP_ATTACK:
+	case LS_SWOOP_ATTACK_RIGHT:
+	case LS_SWOOP_ATTACK_LEFT:
+	case LS_TAUNTAUN_ATTACK_RIGHT:
+	case LS_TAUNTAUN_ATTACK_LEFT:
+	case LS_KICK_F:
+	case LS_KICK_B:
+	case LS_KICK_R:
+	case LS_KICK_L:
+	case LS_KICK_S:
+	case LS_KICK_BF:
+	case LS_KICK_RL:
+	case LS_KICK_F_AIR:
+	case LS_KICK_B_AIR:
+	case LS_KICK_R_AIR:
+	case LS_KICK_L_AIR:
+	case LS_STABDOWN:
+	case LS_STABDOWN_STAFF:
+	case LS_STABDOWN_DUAL:
+	case LS_DUAL_SPIN_PROTECT:
+	case LS_STAFF_SOULCAL:
+	case LS_A1_SPECIAL:
+	case LS_A2_SPECIAL:
+	case LS_A3_SPECIAL:
+	case LS_UPSIDE_DOWN_ATTACK:
+	case LS_PULL_ATTACK_STAB:
+	case LS_PULL_ATTACK_SWING:
+	case LS_SPINATTACK_ALORA:
+	case LS_DUAL_FB:
+	case LS_DUAL_LR:
+	case LS_HILT_BASH:
+		return qtrue;
+		break;
+	}
+	return qfalse;
+}
+
+qboolean BG_SaberInKata( int saberMove )
+{
+	switch ( saberMove )
+	{
+	case LS_A1_SPECIAL:
+	case LS_A2_SPECIAL:
+	case LS_A3_SPECIAL:
+	case LS_DUAL_SPIN_PROTECT:
+	case LS_STAFF_SOULCAL:
+		return qtrue;
+	}
+	return qfalse;
+}
+
+qboolean BG_InKataAnim(int anim)
+{
+	switch (anim)
+	{
+	case BOTH_A6_SABERPROTECT:
+	case BOTH_A7_SOULCAL:
+	case BOTH_A1_SPECIAL:
+	case BOTH_A2_SPECIAL:
+	case BOTH_A3_SPECIAL:
+		return qtrue;
+	}
+	return qfalse;
+}
+
+qboolean BG_SaberInSpecial( int move )
+{
+	switch( move )
+	{
+	case LS_A_BACK:
+	case LS_A_BACK_CR:
+	case LS_A_BACKSTAB:
+	case LS_ROLL_STAB:
+	case LS_A_LUNGE:
+	case LS_A_JUMP_T__B_:
+	case LS_A_FLIP_STAB:
+	case LS_A_FLIP_SLASH:
+	case LS_JUMPATTACK_DUAL:
+	case LS_JUMPATTACK_ARIAL_LEFT:
+	case LS_JUMPATTACK_ARIAL_RIGHT:
+	case LS_JUMPATTACK_CART_LEFT:
+	case LS_JUMPATTACK_CART_RIGHT:
+	case LS_JUMPATTACK_STAFF_LEFT:
+	case LS_JUMPATTACK_STAFF_RIGHT:
+	case LS_BUTTERFLY_LEFT:
+	case LS_BUTTERFLY_RIGHT:
+	case LS_A_BACKFLIP_ATK:
+	case LS_SPINATTACK_DUAL:
+	case LS_SPINATTACK:
+	case LS_LEAP_ATTACK:
+	case LS_SWOOP_ATTACK_RIGHT:
+	case LS_SWOOP_ATTACK_LEFT:
+	case LS_TAUNTAUN_ATTACK_RIGHT:
+	case LS_TAUNTAUN_ATTACK_LEFT:
+	case LS_KICK_F:
+	case LS_KICK_B:
+	case LS_KICK_R:
+	case LS_KICK_L:
+	case LS_KICK_S:
+	case LS_KICK_BF:
+	case LS_KICK_RL:
+	case LS_KICK_F_AIR:
+	case LS_KICK_B_AIR:
+	case LS_KICK_R_AIR:
+	case LS_KICK_L_AIR:
+	case LS_STABDOWN:
+	case LS_STABDOWN_STAFF:
+	case LS_STABDOWN_DUAL:
+	case LS_DUAL_SPIN_PROTECT:
+	case LS_STAFF_SOULCAL:
+	case LS_A1_SPECIAL:
+	case LS_A2_SPECIAL:
+	case LS_A3_SPECIAL:
+	case LS_UPSIDE_DOWN_ATTACK:
+	case LS_PULL_ATTACK_STAB:
+	case LS_PULL_ATTACK_SWING:
+	case LS_SPINATTACK_ALORA:
+	case LS_DUAL_FB:
+	case LS_DUAL_LR:
+	case LS_HILT_BASH:
+		return qtrue;
+	}
+	return qfalse;
+}
+
+qboolean BG_KickMove( int move )
+{
+	switch( move )
+	{
+	case LS_KICK_F:
+	case LS_KICK_B:
+	case LS_KICK_R:
+	case LS_KICK_L:
+	case LS_KICK_S:
+	case LS_KICK_BF:
+	case LS_KICK_RL:
+	case LS_KICK_F_AIR:
+	case LS_KICK_B_AIR:
+	case LS_KICK_R_AIR:
+	case LS_KICK_L_AIR:
+	case LS_HILT_BASH:
+		return qtrue;
+	}
+	return qfalse;
+}
+
+qboolean BG_SaberInIdle( int move )
+{
+	switch ( move )
+	{
+	case LS_NONE:
+	case LS_READY:
+	case LS_DRAW:
+	case LS_PUTAWAY:
+		return qtrue;
+		break;
+	}
+	return qfalse;
+}
+
+qboolean BG_InExtraDefenseSaberMove( int move )
+{
+	switch ( move )
+	{
+	case LS_SPINATTACK_DUAL:
+	case LS_SPINATTACK:
+	case LS_DUAL_SPIN_PROTECT:
+	case LS_STAFF_SOULCAL:
+	case LS_A1_SPECIAL:
+	case LS_A2_SPECIAL:
+	case LS_A3_SPECIAL:
+	case LS_JUMPATTACK_DUAL:
+		return qtrue;
+		break;
+	}
+	return qfalse;
+}
+
+qboolean BG_FlippingAnim( int anim )
+{
+	switch ( anim )
+	{
+	case BOTH_FLIP_F:			//# Flip forward
+	case BOTH_FLIP_B:			//# Flip backwards
+	case BOTH_FLIP_L:			//# Flip left
+	case BOTH_FLIP_R:			//# Flip right
+	case BOTH_WALL_RUN_RIGHT_FLIP:
+	case BOTH_WALL_RUN_LEFT_FLIP:
+	case BOTH_WALL_FLIP_RIGHT:
+	case BOTH_WALL_FLIP_LEFT:
+	case BOTH_FLIP_BACK1:
+	case BOTH_FLIP_BACK2:
+	case BOTH_FLIP_BACK3:
+	case BOTH_WALL_FLIP_BACK1:
+	//Not really flips, but...
+	case BOTH_WALL_RUN_RIGHT:
+	case BOTH_WALL_RUN_LEFT:
+	case BOTH_WALL_RUN_RIGHT_STOP:
+	case BOTH_WALL_RUN_LEFT_STOP:
+	case BOTH_BUTTERFLY_LEFT:
+	case BOTH_BUTTERFLY_RIGHT:
+	case BOTH_BUTTERFLY_FL1:
+	case BOTH_BUTTERFLY_FR1:
+	//
+	case BOTH_ARIAL_LEFT:
+	case BOTH_ARIAL_RIGHT:
+	case BOTH_ARIAL_F1:
+	case BOTH_CARTWHEEL_LEFT:
+	case BOTH_CARTWHEEL_RIGHT:
+	case BOTH_JUMPFLIPSLASHDOWN1:
+	case BOTH_JUMPFLIPSTABDOWN:
+	case BOTH_JUMPATTACK6:
+	case BOTH_JUMPATTACK7:
+	//JKA
+	case BOTH_FORCEWALLRUNFLIP_END:
+	case BOTH_FORCEWALLRUNFLIP_ALT:
+	case BOTH_FLIP_ATTACK7:
+	case BOTH_A7_SOULCAL:
+		return qtrue;
+		break;
+	}
+	return qfalse;
+}
+
+qboolean BG_SpinningSaberAnim( int anim )
+{
+	switch ( anim )
+	{
+	//level 1 - FIXME: level 1 will have *no* spins
+	case BOTH_T1_BR_BL:
+	case BOTH_T1__R__L:
+	case BOTH_T1__R_BL:
+	case BOTH_T1_TR_BL:
+	case BOTH_T1_BR_TL:
+	case BOTH_T1_BR__L:
+	case BOTH_T1_TL_BR:
+	case BOTH_T1__L_BR:
+	case BOTH_T1__L__R:
+	case BOTH_T1_BL_BR:
+	case BOTH_T1_BL__R:
+	case BOTH_T1_BL_TR:
+	//level 2
+	case BOTH_T2_BR__L:
+	case BOTH_T2_BR_BL:
+	case BOTH_T2__R_BL:
+	case BOTH_T2__L_BR:
+	case BOTH_T2_BL_BR:
+	case BOTH_T2_BL__R:
+	//level 3
+	case BOTH_T3_BR__L:
+	case BOTH_T3_BR_BL:
+	case BOTH_T3__R_BL:
+	case BOTH_T3__L_BR:
+	case BOTH_T3_BL_BR:
+	case BOTH_T3_BL__R:
+	//level 4
+	case BOTH_T4_BR__L:
+	case BOTH_T4_BR_BL:
+	case BOTH_T4__R_BL:
+	case BOTH_T4__L_BR:
+	case BOTH_T4_BL_BR:
+	case BOTH_T4_BL__R:
+	//level 5
+	case BOTH_T5_BR_BL:
+	case BOTH_T5__R__L:
+	case BOTH_T5__R_BL:
+	case BOTH_T5_TR_BL:
+	case BOTH_T5_BR_TL:
+	case BOTH_T5_BR__L:
+	case BOTH_T5_TL_BR:
+	case BOTH_T5__L_BR:
+	case BOTH_T5__L__R:
+	case BOTH_T5_BL_BR:
+	case BOTH_T5_BL__R:
+	case BOTH_T5_BL_TR:
+	//level 6
+	case BOTH_T6_BR_TL:
+	case BOTH_T6__R_TL:
+	case BOTH_T6__R__L:
+	case BOTH_T6__R_BL:
+	case BOTH_T6_TR_TL:
+	case BOTH_T6_TR__L:
+	case BOTH_T6_TR_BL:
+	case BOTH_T6_T__TL:
+	case BOTH_T6_T__BL:
+	case BOTH_T6_TL_BR:
+	case BOTH_T6__L_BR:
+	case BOTH_T6__L__R:
+	case BOTH_T6_TL__R:
+	case BOTH_T6_TL_TR:
+	case BOTH_T6__L_TR:
+	case BOTH_T6__L_T_:
+	case BOTH_T6_BL_T_:
+	case BOTH_T6_BR__L:
+	case BOTH_T6_BR_BL:
+	case BOTH_T6_BL_BR:
+	case BOTH_T6_BL__R:
+	case BOTH_T6_BL_TR:
+	//level 7
+	case BOTH_T7_BR_TL:
+	case BOTH_T7_BR__L:
+	case BOTH_T7_BR_BL:
+	case BOTH_T7__R__L:
+	case BOTH_T7__R_BL:
+	case BOTH_T7_TR__L:
+	case BOTH_T7_T___R:
+	case BOTH_T7_TL_BR:
+	case BOTH_T7__L_BR:
+	case BOTH_T7__L__R:
+	case BOTH_T7_BL_BR:
+	case BOTH_T7_BL__R:
+	case BOTH_T7_BL_TR:
+	case BOTH_T7_TL_TR:
+	case BOTH_T7_T__BR:
+	case BOTH_T7__L_TR:
+	case BOTH_V7_BL_S7:
+	//special
+	//case BOTH_A2_STABBACK1:
+	case BOTH_ATTACK_BACK:
+	case BOTH_CROUCHATTACKBACK1:
+	case BOTH_BUTTERFLY_LEFT:
+	case BOTH_BUTTERFLY_RIGHT:
+	case BOTH_FJSS_TR_BL:
+	case BOTH_FJSS_TL_BR:
+	case BOTH_JUMPFLIPSLASHDOWN1:
+	case BOTH_JUMPFLIPSTABDOWN:
+		return qtrue;
+		break;
+	}
+	return qfalse;
+}
+
+qboolean BG_SaberInSpecialAttack( int anim )
+{
+	switch ( anim )
+	{
+	case BOTH_A2_STABBACK1:
+	case BOTH_ATTACK_BACK:
+	case BOTH_CROUCHATTACKBACK1:
+	case BOTH_ROLL_STAB:
+	case BOTH_BUTTERFLY_LEFT:
+	case BOTH_BUTTERFLY_RIGHT:
+	case BOTH_BUTTERFLY_FL1:
+	case BOTH_BUTTERFLY_FR1:
+	case BOTH_FJSS_TR_BL:
+	case BOTH_FJSS_TL_BR:
+	case BOTH_LUNGE2_B__T_:
+	case BOTH_FORCELEAP2_T__B_:
+	case BOTH_JUMPFLIPSLASHDOWN1://#
+	case BOTH_JUMPFLIPSTABDOWN://#
+	case BOTH_JUMPATTACK6:
+	case BOTH_JUMPATTACK7:
+	case BOTH_SPINATTACK6:
+	case BOTH_SPINATTACK7:
+	case BOTH_FORCELONGLEAP_ATTACK:
+	case BOTH_VS_ATR_S:
+	case BOTH_VS_ATL_S:
+	case BOTH_VT_ATR_S:
+	case BOTH_VT_ATL_S:
+	case BOTH_A7_KICK_F:
+	case BOTH_A7_KICK_B:
+	case BOTH_A7_KICK_R:
+	case BOTH_A7_KICK_L:
+	case BOTH_A7_KICK_S:
+	case BOTH_A7_KICK_BF:
+	case BOTH_A7_KICK_RL:
+	case BOTH_A7_KICK_F_AIR:
+	case BOTH_A7_KICK_B_AIR:
+	case BOTH_A7_KICK_R_AIR:
+	case BOTH_A7_KICK_L_AIR:
+	case BOTH_STABDOWN:
+	case BOTH_STABDOWN_STAFF:
+	case BOTH_STABDOWN_DUAL:
+	case BOTH_A6_SABERPROTECT:
+	case BOTH_A7_SOULCAL:
+	case BOTH_A1_SPECIAL:
+	case BOTH_A2_SPECIAL:
+	case BOTH_A3_SPECIAL:
+	case BOTH_FLIP_ATTACK7:
+	case BOTH_PULL_IMPALE_STAB:
+	case BOTH_PULL_IMPALE_SWING:
+	case BOTH_ALORA_SPIN_SLASH:
+	case BOTH_A6_FB:
+	case BOTH_A6_LR:	
+	case BOTH_A7_HILT:
+		return qtrue;
+	}
+	return qfalse;
+}
+
+qboolean BG_KickingAnim( int anim )
+{
+	switch ( anim )
+	{
+	case BOTH_A7_KICK_F:
+	case BOTH_A7_KICK_B:
+	case BOTH_A7_KICK_R:
+	case BOTH_A7_KICK_L:
+	case BOTH_A7_KICK_S:
+	case BOTH_A7_KICK_BF:
+	case BOTH_A7_KICK_RL:
+	case BOTH_A7_KICK_F_AIR:
+	case BOTH_A7_KICK_B_AIR:
+	case BOTH_A7_KICK_R_AIR:
+	case BOTH_A7_KICK_L_AIR:
+	case BOTH_A7_HILT:
+	//NOT kicks, but do kick traces anyway
+	case BOTH_GETUP_BROLL_B:
+	case BOTH_GETUP_BROLL_F:
+	case BOTH_GETUP_FROLL_B:
+	case BOTH_GETUP_FROLL_F:
+		return qtrue;
+		break;
+	}
+	return qfalse;
+}
+
+int BG_InGrappleMove(int anim)
+{
+	switch (anim)
+	{
+	case BOTH_KYLE_GRAB:
+	case BOTH_KYLE_MISS:
+		return 1; //grabbing at someone
+	case BOTH_KYLE_PA_1:
+	case BOTH_KYLE_PA_2:
+		return 2; //beating the shit out of someone
+	case BOTH_PLAYER_PA_1:
+	case BOTH_PLAYER_PA_2:
+	case BOTH_PLAYER_PA_FLY:
+		return 3; //getting the shit beaten out of you
+		break;
+	}
+
+	return 0;
+}
+
+int BG_BrokenParryForAttack( int move )
+{
+	//Our attack was knocked away by a knockaway parry
+	//FIXME: need actual anims for this
+	//FIXME: need to know which side of the saber was hit!  For now, we presume the saber gets knocked away from the center
+	switch ( saberMoveData[move].startQuad )
+	{
+	case Q_B:
+		return LS_V1_B_;
+		break;
+	case Q_BR:
+		return LS_V1_BR;
+		break;
+	case Q_R:
+		return LS_V1__R;
+		break;
+	case Q_TR:
+		return LS_V1_TR;
+		break;
+	case Q_T:
+		return LS_V1_T_;
+		break;
+	case Q_TL:
+		return LS_V1_TL;
+		break;
+	case Q_L:
+		return LS_V1__L;
+		break;
+	case Q_BL:
+		return LS_V1_BL;
+		break;
+	}
+	return LS_NONE;
+}
+
+int BG_BrokenParryForParry( int move )
+{
+	//FIXME: need actual anims for this
+	//FIXME: need to know which side of the saber was hit!  For now, we presume the saber gets knocked away from the center
+	switch ( move )
+	{
+	case LS_PARRY_UP:
+		//Hmm... since we don't know what dir the hit came from, randomly pick knock down or knock back
+		if ( Q_irand( 0, 1 ) )
+		{
+			return LS_H1_B_;
+		}
+		else
+		{
+			return LS_H1_T_;
+		}
+		break;
+	case LS_PARRY_UR:
+		return LS_H1_TR;
+		break;
+	case LS_PARRY_UL:
+		return LS_H1_TL;
+		break;
+	case LS_PARRY_LR:
+		return LS_H1_BR;
+		break;
+	case LS_PARRY_LL:
+		return LS_H1_BL;
+		break;
+	case LS_READY:
+		return LS_H1_B_;//???
+		break;
+	}
+	return LS_NONE;
+}
+
+int BG_KnockawayForParry( int move )
+{
+	//FIXME: need actual anims for this
+	//FIXME: need to know which side of the saber was hit!  For now, we presume the saber gets knocked away from the center
+	switch ( move )
+	{
+	case BLOCKED_TOP://LS_PARRY_UP:
+		return LS_K1_T_;//push up
+		break;
+	case BLOCKED_UPPER_RIGHT://LS_PARRY_UR:
+	default://case LS_READY:
+		return LS_K1_TR;//push up, slightly to right
+		break;
+	case BLOCKED_UPPER_LEFT://LS_PARRY_UL:
+		return LS_K1_TL;//push up and to left
+		break;
+	case BLOCKED_LOWER_RIGHT://LS_PARRY_LR:
+		return LS_K1_BR;//push down and to left
+		break;
+	case BLOCKED_LOWER_LEFT://LS_PARRY_LL:
+		return LS_K1_BL;//push down and to right
+		break;
+	}
+	//return LS_NONE;
+}
+
+qboolean BG_InRoll( playerState_t *ps, int anim )
+{
+	switch ( (anim) )
+	{
+	case BOTH_GETUP_BROLL_B:
+	case BOTH_GETUP_BROLL_F:
+	case BOTH_GETUP_BROLL_L:
+	case BOTH_GETUP_BROLL_R:
+	case BOTH_GETUP_FROLL_B:
+	case BOTH_GETUP_FROLL_F:
+	case BOTH_GETUP_FROLL_L:
+	case BOTH_GETUP_FROLL_R:
+	case BOTH_ROLL_F:
+	case BOTH_ROLL_B:
+	case BOTH_ROLL_R:
+	case BOTH_ROLL_L:
+		if ( ps->legsTimer > 0 )
+		{
+			return qtrue;
+		}
+		break;
+	}
+	return qfalse;
+}
+
+qboolean BG_InSpecialDeathAnim( int anim )
+{
+	switch( anim )
+	{
+	case BOTH_DEATH_ROLL:		//# Death anim from a roll
+	case BOTH_DEATH_FLIP:		//# Death anim from a flip
+	case BOTH_DEATH_SPIN_90_R:	//# Death anim when facing 90 degrees right
+	case BOTH_DEATH_SPIN_90_L:	//# Death anim when facing 90 degrees left
+	case BOTH_DEATH_SPIN_180:	//# Death anim when facing backwards
+	case BOTH_DEATH_LYING_UP:	//# Death anim when lying on back
+	case BOTH_DEATH_LYING_DN:	//# Death anim when lying on front
+	case BOTH_DEATH_FALLING_DN:	//# Death anim when falling on face
+	case BOTH_DEATH_FALLING_UP:	//# Death anim when falling on back
+	case BOTH_DEATH_CROUCHED:	//# Death anim when crouched
+		return qtrue;
+		break;
+	default:
+		return qfalse;
+		break;
+	}
+}
+
+qboolean BG_InDeathAnim ( int anim )
+{//Purposely does not cover stumbledeath and falldeath...
+	switch( anim )
+	{
+	case BOTH_DEATH1:		//# First Death anim
+	case BOTH_DEATH2:			//# Second Death anim
+	case BOTH_DEATH3:			//# Third Death anim
+	case BOTH_DEATH4:			//# Fourth Death anim
+	case BOTH_DEATH5:			//# Fifth Death anim
+	case BOTH_DEATH6:			//# Sixth Death anim
+	case BOTH_DEATH7:			//# Seventh Death anim
+	case BOTH_DEATH8:			//# 
+	case BOTH_DEATH9:			//# 
+	case BOTH_DEATH10:			//# 
+	case BOTH_DEATH11:			//#
+	case BOTH_DEATH12:			//# 
+	case BOTH_DEATH13:			//# 
+	case BOTH_DEATH14:			//# 
+	case BOTH_DEATH14_UNGRIP:	//# Desann's end death (cin #35)
+	case BOTH_DEATH14_SITUP:		//# Tavion sitting up after having been thrown (cin #23)
+	case BOTH_DEATH15:			//# 
+	case BOTH_DEATH16:			//# 
+	case BOTH_DEATH17:			//# 
+	case BOTH_DEATH18:			//# 
+	case BOTH_DEATH19:			//# 
+	case BOTH_DEATH20:			//# 
+	case BOTH_DEATH21:			//# 
+	case BOTH_DEATH22:			//# 
+	case BOTH_DEATH23:			//# 
+	case BOTH_DEATH24:			//# 
+	case BOTH_DEATH25:			//# 
+
+	case BOTH_DEATHFORWARD1:		//# First Death in which they get thrown forward
+	case BOTH_DEATHFORWARD2:		//# Second Death in which they get thrown forward
+	case BOTH_DEATHFORWARD3:		//# Tavion's falling in cin# 23
+	case BOTH_DEATHBACKWARD1:	//# First Death in which they get thrown backward
+	case BOTH_DEATHBACKWARD2:	//# Second Death in which they get thrown backward
+
+	case BOTH_DEATH1IDLE:		//# Idle while close to death
+	case BOTH_LYINGDEATH1:		//# Death to play when killed lying down
+	case BOTH_STUMBLEDEATH1:		//# Stumble forward and fall face first death
+	case BOTH_FALLDEATH1:		//# Fall forward off a high cliff and splat death - start
+	case BOTH_FALLDEATH1INAIR:	//# Fall forward off a high cliff and splat death - loop
+	case BOTH_FALLDEATH1LAND:	//# Fall forward off a high cliff and splat death - hit bottom
+	//# #sep case BOTH_ DEAD POSES # Should be last frame of corresponding previous anims
+	case BOTH_DEAD1:				//# First Death finished pose
+	case BOTH_DEAD2:				//# Second Death finished pose
+	case BOTH_DEAD3:				//# Third Death finished pose
+	case BOTH_DEAD4:				//# Fourth Death finished pose
+	case BOTH_DEAD5:				//# Fifth Death finished pose
+	case BOTH_DEAD6:				//# Sixth Death finished pose
+	case BOTH_DEAD7:				//# Seventh Death finished pose
+	case BOTH_DEAD8:				//# 
+	case BOTH_DEAD9:				//# 
+	case BOTH_DEAD10:			//# 
+	case BOTH_DEAD11:			//#
+	case BOTH_DEAD12:			//# 
+	case BOTH_DEAD13:			//# 
+	case BOTH_DEAD14:			//# 
+	case BOTH_DEAD15:			//# 
+	case BOTH_DEAD16:			//# 
+	case BOTH_DEAD17:			//# 
+	case BOTH_DEAD18:			//# 
+	case BOTH_DEAD19:			//# 
+	case BOTH_DEAD20:			//# 
+	case BOTH_DEAD21:			//# 
+	case BOTH_DEAD22:			//# 
+	case BOTH_DEAD23:			//# 
+	case BOTH_DEAD24:			//# 
+	case BOTH_DEAD25:			//# 
+	case BOTH_DEADFORWARD1:		//# First thrown forward death finished pose
+	case BOTH_DEADFORWARD2:		//# Second thrown forward death finished pose
+	case BOTH_DEADBACKWARD1:		//# First thrown backward death finished pose
+	case BOTH_DEADBACKWARD2:		//# Second thrown backward death finished pose
+	case BOTH_LYINGDEAD1:		//# Killed lying down death finished pose
+	case BOTH_STUMBLEDEAD1:		//# Stumble forward death finished pose
+	case BOTH_FALLDEAD1LAND:		//# Fall forward and splat death finished pose
+	//# #sep case BOTH_ DEAD TWITCH/FLOP # React to being shot from death poses
+	case BOTH_DEADFLOP1:		//# React to being shot from First Death finished pose
+	case BOTH_DEADFLOP2:		//# React to being shot from Second Death finished pose
+	case BOTH_DISMEMBER_HEAD1:	//#
+	case BOTH_DISMEMBER_TORSO1:	//#
+	case BOTH_DISMEMBER_LLEG:	//#
+	case BOTH_DISMEMBER_RLEG:	//#
+	case BOTH_DISMEMBER_RARM:	//#
+	case BOTH_DISMEMBER_LARM:	//#
+		return qtrue;
+		break;
+	default:
+		return BG_InSpecialDeathAnim( anim );
+		break;
+	}
+}
+
+qboolean BG_InKnockDownOnly( int anim )
+{
+	switch ( anim )
+	{
+	case BOTH_KNOCKDOWN1:
+	case BOTH_KNOCKDOWN2:
+	case BOTH_KNOCKDOWN3:
+	case BOTH_KNOCKDOWN4:
+	case BOTH_KNOCKDOWN5:
+		return qtrue;
+	}
+	return qfalse;
+}
+
+qboolean BG_InSaberLockOld( int anim )
+{
+	switch ( anim )
+	{
+	case BOTH_BF2LOCK:
+	case BOTH_BF1LOCK:
+	case BOTH_CWCIRCLELOCK:
+	case BOTH_CCWCIRCLELOCK:
+		return qtrue;
+	}
+	return qfalse;
+}
+
+qboolean BG_InSaberLock( int anim ) 
+{
+	switch ( anim )
+	{
+	case BOTH_LK_S_DL_S_L_1:		//lock if I'm using single vs. a dual
+	case BOTH_LK_S_DL_T_L_1:		//lock if I'm using single vs. a dual
+	case BOTH_LK_S_ST_S_L_1:		//lock if I'm using single vs. a staff
+	case BOTH_LK_S_ST_T_L_1:		//lock if I'm using single vs. a staff
+	case BOTH_LK_S_S_S_L_1:		//lock if I'm using single vs. a single and I initiated
+	case BOTH_LK_S_S_T_L_1:		//lock if I'm using single vs. a single and I initiated
+	case BOTH_LK_DL_DL_S_L_1:	//lock if I'm using dual vs. dual and I initiated
+	case BOTH_LK_DL_DL_T_L_1:	//lock if I'm using dual vs. dual and I initiated
+	case BOTH_LK_DL_ST_S_L_1:	//lock if I'm using dual vs. a staff
+	case BOTH_LK_DL_ST_T_L_1:	//lock if I'm using dual vs. a staff
+	case BOTH_LK_DL_S_S_L_1:		//lock if I'm using dual vs. a single
+	case BOTH_LK_DL_S_T_L_1:		//lock if I'm using dual vs. a single
+	case BOTH_LK_ST_DL_S_L_1:	//lock if I'm using staff vs. dual
+	case BOTH_LK_ST_DL_T_L_1:	//lock if I'm using staff vs. dual
+	case BOTH_LK_ST_ST_S_L_1:	//lock if I'm using staff vs. a staff and I initiated
+	case BOTH_LK_ST_ST_T_L_1:	//lock if I'm using staff vs. a staff and I initiated
+	case BOTH_LK_ST_S_S_L_1:		//lock if I'm using staff vs. a single
+	case BOTH_LK_ST_S_T_L_1:		//lock if I'm using staff vs. a single
+	case BOTH_LK_S_S_S_L_2:
+	case BOTH_LK_S_S_T_L_2:
+	case BOTH_LK_DL_DL_S_L_2:
+	case BOTH_LK_DL_DL_T_L_2:
+	case BOTH_LK_ST_ST_S_L_2:
+	case BOTH_LK_ST_ST_T_L_2:
+		return qtrue;
+		break;
+	default:
+		return BG_InSaberLockOld( anim );
+		break;
+	}
+	//return qfalse;
+}
+
+//Called only where pm is valid (not all require pm, but some do):
+qboolean PM_InCartwheel( int anim )
+{
+	switch ( anim )
+	{
+	case BOTH_ARIAL_LEFT:
+	case BOTH_ARIAL_RIGHT:
+	case BOTH_ARIAL_F1:
+	case BOTH_CARTWHEEL_LEFT:
+	case BOTH_CARTWHEEL_RIGHT:
+		return qtrue;
+		break;
+	}
+	return qfalse;
+}
+
+qboolean BG_InKnockDownOnGround( playerState_t *ps )
+{
+	switch ( ps->legsAnim )
+	{
+	case BOTH_KNOCKDOWN1:
+	case BOTH_KNOCKDOWN2:
+	case BOTH_KNOCKDOWN3:
+	case BOTH_KNOCKDOWN4:
+	case BOTH_KNOCKDOWN5:
+	case BOTH_RELEASED:
+		//if ( PM_AnimLength( g_entities[ps->clientNum].client->clientInfo.animFileIndex, (animNumber_t)ps->legsAnim ) - ps->legsAnimTimer > 300 )
+		{//at end of fall down anim
+			return qtrue;
+		}
+		break;
+	case BOTH_GETUP1:
+	case BOTH_GETUP2:
+	case BOTH_GETUP3:
+	case BOTH_GETUP4:
+	case BOTH_GETUP5:
+	case BOTH_GETUP_CROUCH_F1:
+	case BOTH_GETUP_CROUCH_B1:
+	case BOTH_FORCE_GETUP_F1:
+	case BOTH_FORCE_GETUP_F2:
+	case BOTH_FORCE_GETUP_B1:
+	case BOTH_FORCE_GETUP_B2:
+	case BOTH_FORCE_GETUP_B3:
+	case BOTH_FORCE_GETUP_B4:
+	case BOTH_FORCE_GETUP_B5:
+	case BOTH_FORCE_GETUP_B6:
+		if ( BG_AnimLength( 0, (animNumber_t)ps->legsAnim ) - ps->legsTimer < 500 )
+		{//at beginning of getup anim
+			return qtrue;
+		}
+		break;
+	case BOTH_GETUP_BROLL_B:
+	case BOTH_GETUP_BROLL_F:
+	case BOTH_GETUP_BROLL_L:
+	case BOTH_GETUP_BROLL_R:
+	case BOTH_GETUP_FROLL_B:
+	case BOTH_GETUP_FROLL_F:
+	case BOTH_GETUP_FROLL_L:
+	case BOTH_GETUP_FROLL_R:
+		if ( BG_AnimLength( 0, (animNumber_t)ps->legsAnim ) - ps->legsTimer < 500 )
+		{//at beginning of getup anim
+			return qtrue;
+		}
+		break;
+	case BOTH_LK_DL_ST_T_SB_1_L:
+		if ( ps->legsTimer < 1000 )
+		{
+			return qtrue;
+		}
+		break;
+	case BOTH_PLAYER_PA_3_FLY:
+		if ( ps->legsTimer < 300 )
+		{
+			return qtrue;
+		}
+		break;
+	}
+	return qfalse;
+}
+
+qboolean BG_StabDownAnim( int anim )
+{
+	switch ( anim )
+	{
+	case BOTH_STABDOWN:
+	case BOTH_STABDOWN_STAFF:
+	case BOTH_STABDOWN_DUAL:
+		return qtrue;
+	}
+	return qfalse;
+}
+
+int PM_SaberBounceForAttack( int move )
+{
+	switch ( saberMoveData[move].startQuad )
+	{
+	case Q_B:
+	case Q_BR:
+		return LS_B1_BR;
+		break;
+	case Q_R:
+		return LS_B1__R;
+		break;
+	case Q_TR:
+		return LS_B1_TR;
+		break;
+	case Q_T:
+		return LS_B1_T_;
+		break;
+	case Q_TL:
+		return LS_B1_TL;
+		break;
+	case Q_L:
+		return LS_B1__L;
+		break;
+	case Q_BL:
+		return LS_B1_BL;
+		break;
+	}
+	return LS_NONE;
+}
+
+int PM_SaberDeflectionForQuad( int quad )
+{
+	switch ( quad )
+	{
+	case Q_B:
+		return LS_D1_B_;
+		break;
+	case Q_BR:
+		return LS_D1_BR;
+		break;
+	case Q_R:
+		return LS_D1__R;
+		break;
+	case Q_TR:
+		return LS_D1_TR;
+		break;
+	case Q_T:
+		return LS_D1_T_;
+		break;
+	case Q_TL:
+		return LS_D1_TL;
+		break;
+	case Q_L:
+		return LS_D1__L;
+		break;
+	case Q_BL:
+		return LS_D1_BL;
+		break;
+	}
+	return LS_NONE;
+}
+
+qboolean PM_SaberInDeflect( int move )
+{
+	if ( move >= LS_D1_BR && move <= LS_D1_B_ )
+	{
+		return qtrue;
+	}
+	return qfalse;
+}
+
+qboolean PM_SaberInParry( int move )
+{
+	if ( move >= LS_PARRY_UP && move <= LS_PARRY_LL )
+	{
+		return qtrue;
+	}
+	return qfalse;
+}
+
+qboolean PM_SaberInKnockaway( int move )
+{
+	if ( move >= LS_K1_T_ && move <= LS_K1_BL )
+	{
+		return qtrue;
+	}
+	return qfalse;
+}
+
+qboolean PM_SaberInReflect( int move )
+{
+	if ( move >= LS_REFLECT_UP && move <= LS_REFLECT_LL )
+	{
+		return qtrue;
+	}
+	return qfalse;
+}
+
+qboolean PM_SaberInStart( int move )
+{
+	if ( move >= LS_S_TL2BR && move <= LS_S_T2B )
+	{
+		return qtrue;
+	}
+	return qfalse;
+}
+
+qboolean PM_SaberInReturn( int move )
+{
+	if ( move >= LS_R_TL2BR && move <= LS_R_T2B )
+	{
+		return qtrue;
+	}
+	return qfalse;
+}
+
+qboolean BG_SaberInReturn( int move )
+{
+	return PM_SaberInReturn( move );
+}
+
+qboolean PM_InSaberAnim( int anim )
+{
+	if ( (anim) >= BOTH_A1_T__B_ && (anim) <= BOTH_H1_S1_BR )
+	{
+		return qtrue;
+	}
+	return qfalse;
+}
+
+qboolean PM_InKnockDown( playerState_t *ps )
+{
+	switch ( (ps->legsAnim) )
+	{
+	case BOTH_KNOCKDOWN1:
+	case BOTH_KNOCKDOWN2:
+	case BOTH_KNOCKDOWN3:
+	case BOTH_KNOCKDOWN4:
+	case BOTH_KNOCKDOWN5:
+		return qtrue;
+		break;
+	case BOTH_GETUP1:
+	case BOTH_GETUP2:
+	case BOTH_GETUP3:
+	case BOTH_GETUP4:
+	case BOTH_GETUP5:
+	case BOTH_FORCE_GETUP_F1:
+	case BOTH_FORCE_GETUP_F2:
+	case BOTH_FORCE_GETUP_B1:
+	case BOTH_FORCE_GETUP_B2:
+	case BOTH_FORCE_GETUP_B3:
+	case BOTH_FORCE_GETUP_B4:
+	case BOTH_FORCE_GETUP_B5:
+	case BOTH_GETUP_BROLL_B:
+	case BOTH_GETUP_BROLL_F:
+	case BOTH_GETUP_BROLL_L:
+	case BOTH_GETUP_BROLL_R:
+	case BOTH_GETUP_FROLL_B:
+	case BOTH_GETUP_FROLL_F:
+	case BOTH_GETUP_FROLL_L:
+	case BOTH_GETUP_FROLL_R:
+		if ( ps->legsTimer )
+		{
+			return qtrue;
+		}
+		break;
+	}
+	return qfalse;
+}
+
+qboolean PM_PainAnim( int anim )
+{
+	switch ( (anim) )
+	{
+		case BOTH_PAIN1:				//# First take pain anim
+		case BOTH_PAIN2:				//# Second take pain anim
+		case BOTH_PAIN3:				//# Third take pain anim
+		case BOTH_PAIN4:				//# Fourth take pain anim
+		case BOTH_PAIN5:				//# Fifth take pain anim - from behind
+		case BOTH_PAIN6:				//# Sixth take pain anim - from behind
+		case BOTH_PAIN7:				//# Seventh take pain anim - from behind
+		case BOTH_PAIN8:				//# Eigth take pain anim - from behind
+		case BOTH_PAIN9:				//# 
+		case BOTH_PAIN10:			//# 
+		case BOTH_PAIN11:			//# 
+		case BOTH_PAIN12:			//# 
+		case BOTH_PAIN13:			//# 
+		case BOTH_PAIN14:			//# 
+		case BOTH_PAIN15:			//# 
+		case BOTH_PAIN16:			//# 
+		case BOTH_PAIN17:			//# 
+		case BOTH_PAIN18:			//# 
+		return qtrue;
+		break;
+	}
+	return qfalse;
+}
+
+qboolean PM_JumpingAnim( int anim )
+{
+	switch ( (anim) )
+	{
+		case BOTH_JUMP1:				//# Jump - wind-up and leave ground
+		case BOTH_INAIR1:			//# In air loop (from jump)
+		case BOTH_LAND1:				//# Landing (from in air loop)
+		case BOTH_LAND2:				//# Landing Hard (from a great height)
+		case BOTH_JUMPBACK1:			//# Jump backwards - wind-up and leave ground
+		case BOTH_INAIRBACK1:		//# In air loop (from jump back)
+		case BOTH_LANDBACK1:			//# Landing backwards(from in air loop)
+		case BOTH_JUMPLEFT1:			//# Jump left - wind-up and leave ground
+		case BOTH_INAIRLEFT1:		//# In air loop (from jump left)
+		case BOTH_LANDLEFT1:			//# Landing left(from in air loop)
+		case BOTH_JUMPRIGHT1:		//# Jump right - wind-up and leave ground
+		case BOTH_INAIRRIGHT1:		//# In air loop (from jump right)
+		case BOTH_LANDRIGHT1:		//# Landing right(from in air loop)
+		case BOTH_FORCEJUMP1:				//# Jump - wind-up and leave ground
+		case BOTH_FORCEINAIR1:			//# In air loop (from jump)
+		case BOTH_FORCELAND1:				//# Landing (from in air loop)
+		case BOTH_FORCEJUMPBACK1:			//# Jump backwards - wind-up and leave ground
+		case BOTH_FORCEINAIRBACK1:		//# In air loop (from jump back)
+		case BOTH_FORCELANDBACK1:			//# Landing backwards(from in air loop)
+		case BOTH_FORCEJUMPLEFT1:			//# Jump left - wind-up and leave ground
+		case BOTH_FORCEINAIRLEFT1:		//# In air loop (from jump left)
+		case BOTH_FORCELANDLEFT1:			//# Landing left(from in air loop)
+		case BOTH_FORCEJUMPRIGHT1:		//# Jump right - wind-up and leave ground
+		case BOTH_FORCEINAIRRIGHT1:		//# In air loop (from jump right)
+		case BOTH_FORCELANDRIGHT1:		//# Landing right(from in air loop)
+		return qtrue;
+		break;
+	}
+	return qfalse;
+}
+
+qboolean PM_LandingAnim( int anim )
+{
+	switch ( (anim) )
+	{
+		case BOTH_LAND1:				//# Landing (from in air loop)
+		case BOTH_LAND2:				//# Landing Hard (from a great height)
+		case BOTH_LANDBACK1:			//# Landing backwards(from in air loop)
+		case BOTH_LANDLEFT1:			//# Landing left(from in air loop)
+		case BOTH_LANDRIGHT1:		//# Landing right(from in air loop)
+		case BOTH_FORCELAND1:		//# Landing (from in air loop)
+		case BOTH_FORCELANDBACK1:	//# Landing backwards(from in air loop)
+		case BOTH_FORCELANDLEFT1:	//# Landing left(from in air loop)
+		case BOTH_FORCELANDRIGHT1:	//# Landing right(from in air loop)
+		return qtrue;
+		break;
+	}
+	return qfalse;
+}
+
+qboolean PM_SpinningAnim( int anim )
+{
+	/*
+	switch ( anim )
+	{
+	//FIXME: list any other spinning anims
+	default:
+		break;
+	}
+	*/
+	return BG_SpinningSaberAnim( anim );
+}
+
+qboolean PM_InOnGroundAnim ( int anim )
+{
+	switch( anim )
+	{
+	case BOTH_DEAD1:
+	case BOTH_DEAD2:
+	case BOTH_DEAD3:
+	case BOTH_DEAD4:
+	case BOTH_DEAD5:
+	case BOTH_DEADFORWARD1:
+	case BOTH_DEADBACKWARD1:
+	case BOTH_DEADFORWARD2:
+	case BOTH_DEADBACKWARD2:
+	case BOTH_LYINGDEATH1:
+	case BOTH_LYINGDEAD1:
+	case BOTH_SLEEP1:			//# laying on back-rknee up-rhand on torso
+	case BOTH_KNOCKDOWN1:		//# 
+	case BOTH_KNOCKDOWN2:		//# 
+	case BOTH_KNOCKDOWN3:		//# 
+	case BOTH_KNOCKDOWN4:		//# 
+	case BOTH_KNOCKDOWN5:		//# 
+	case BOTH_GETUP1:
+	case BOTH_GETUP2:
+	case BOTH_GETUP3:
+	case BOTH_GETUP4:
+	case BOTH_GETUP5:
+	case BOTH_GETUP_CROUCH_F1:
+	case BOTH_GETUP_CROUCH_B1:
+	case BOTH_FORCE_GETUP_F1:
+	case BOTH_FORCE_GETUP_F2:
+	case BOTH_FORCE_GETUP_B1:
+	case BOTH_FORCE_GETUP_B2:
+	case BOTH_FORCE_GETUP_B3:
+	case BOTH_FORCE_GETUP_B4:
+	case BOTH_FORCE_GETUP_B5:
+	case BOTH_FORCE_GETUP_B6:
+	case BOTH_GETUP_BROLL_B:
+	case BOTH_GETUP_BROLL_F:
+	case BOTH_GETUP_BROLL_L:
+	case BOTH_GETUP_BROLL_R:
+	case BOTH_GETUP_FROLL_B:
+	case BOTH_GETUP_FROLL_F:
+	case BOTH_GETUP_FROLL_L:
+	case BOTH_GETUP_FROLL_R:
+		return qtrue;
+		break;
+	}
+
+	return qfalse;
+}
+
+qboolean PM_InRollComplete( playerState_t *ps, int anim )
+{
+	switch ( (anim) )
+	{
+	case BOTH_ROLL_F:
+	case BOTH_ROLL_B:
+	case BOTH_ROLL_R:
+	case BOTH_ROLL_L:
+		if ( ps->legsTimer < 1 )
+		{
+			return qtrue;
+		}
+		break;
+	}
+	return qfalse;
+}
+
+qboolean PM_CanRollFromSoulCal( playerState_t *ps )
+{
+	if ( ps->legsAnim == BOTH_A7_SOULCAL
+		&& ps->legsTimer < 700
+		&& ps->legsTimer > 250 )
+	{
+		return qtrue;
+	}
+	return qfalse;
+}
+
+qboolean BG_SuperBreakLoseAnim( int anim )
+{
+	switch ( anim )
+	{
+	case BOTH_LK_S_DL_S_SB_1_L:	//super break I lost
+	case BOTH_LK_S_DL_T_SB_1_L:	//super break I lost
+	case BOTH_LK_S_ST_S_SB_1_L:	//super break I lost
+	case BOTH_LK_S_ST_T_SB_1_L:	//super break I lost
+	case BOTH_LK_S_S_S_SB_1_L:	//super break I lost
+	case BOTH_LK_S_S_T_SB_1_L:	//super break I lost
+	case BOTH_LK_DL_DL_S_SB_1_L:	//super break I lost
+	case BOTH_LK_DL_DL_T_SB_1_L:	//super break I lost
+	case BOTH_LK_DL_ST_S_SB_1_L:	//super break I lost
+	case BOTH_LK_DL_ST_T_SB_1_L:	//super break I lost
+	case BOTH_LK_DL_S_S_SB_1_L:	//super break I lost
+	case BOTH_LK_DL_S_T_SB_1_L:	//super break I lost
+	case BOTH_LK_ST_DL_S_SB_1_L:	//super break I lost
+	case BOTH_LK_ST_DL_T_SB_1_L:	//super break I lost
+	case BOTH_LK_ST_ST_S_SB_1_L:	//super break I lost
+	case BOTH_LK_ST_ST_T_SB_1_L:	//super break I lost
+	case BOTH_LK_ST_S_S_SB_1_L:	//super break I lost
+	case BOTH_LK_ST_S_T_SB_1_L:	//super break I lost
+		return qtrue;
+		break;
+	}
+	return qfalse;
+}
+
+qboolean BG_SuperBreakWinAnim( int anim )
+{
+	switch ( anim )
+	{
+	case BOTH_LK_S_DL_S_SB_1_W:	//super break I won
+	case BOTH_LK_S_DL_T_SB_1_W:	//super break I won
+	case BOTH_LK_S_ST_S_SB_1_W:	//super break I won
+	case BOTH_LK_S_ST_T_SB_1_W:	//super break I won
+	case BOTH_LK_S_S_S_SB_1_W:	//super break I won
+	case BOTH_LK_S_S_T_SB_1_W:	//super break I won
+	case BOTH_LK_DL_DL_S_SB_1_W:	//super break I won
+	case BOTH_LK_DL_DL_T_SB_1_W:	//super break I won
+	case BOTH_LK_DL_ST_S_SB_1_W:	//super break I won
+	case BOTH_LK_DL_ST_T_SB_1_W:	//super break I won
+	case BOTH_LK_DL_S_S_SB_1_W:	//super break I won
+	case BOTH_LK_DL_S_T_SB_1_W:	//super break I won
+	case BOTH_LK_ST_DL_S_SB_1_W:	//super break I won
+	case BOTH_LK_ST_DL_T_SB_1_W:	//super break I won
+	case BOTH_LK_ST_ST_S_SB_1_W:	//super break I won
+	case BOTH_LK_ST_ST_T_SB_1_W:	//super break I won
+	case BOTH_LK_ST_S_S_SB_1_W:	//super break I won
+	case BOTH_LK_ST_S_T_SB_1_W:	//super break I won
+		return qtrue;
+		break;
+	}
+	return qfalse;
+}
+
+
+qboolean BG_SaberLockBreakAnim( int anim )
+{
+	switch ( anim )
+	{
+	case BOTH_BF1BREAK:
+	case BOTH_BF2BREAK:
+	case BOTH_CWCIRCLEBREAK:
+	case BOTH_CCWCIRCLEBREAK:
+	case BOTH_LK_S_DL_S_B_1_L:	//normal break I lost
+	case BOTH_LK_S_DL_S_B_1_W:	//normal break I won
+	case BOTH_LK_S_DL_T_B_1_L:	//normal break I lost
+	case BOTH_LK_S_DL_T_B_1_W:	//normal break I won
+	case BOTH_LK_S_ST_S_B_1_L:	//normal break I lost
+	case BOTH_LK_S_ST_S_B_1_W:	//normal break I won
+	case BOTH_LK_S_ST_T_B_1_L:	//normal break I lost
+	case BOTH_LK_S_ST_T_B_1_W:	//normal break I won
+	case BOTH_LK_S_S_S_B_1_L:	//normal break I lost
+	case BOTH_LK_S_S_S_B_1_W:	//normal break I won
+	case BOTH_LK_S_S_T_B_1_L:	//normal break I lost
+	case BOTH_LK_S_S_T_B_1_W:	//normal break I won
+	case BOTH_LK_DL_DL_S_B_1_L:	//normal break I lost
+	case BOTH_LK_DL_DL_S_B_1_W:	//normal break I won
+	case BOTH_LK_DL_DL_T_B_1_L:	//normal break I lost
+	case BOTH_LK_DL_DL_T_B_1_W:	//normal break I won
+	case BOTH_LK_DL_ST_S_B_1_L:	//normal break I lost
+	case BOTH_LK_DL_ST_S_B_1_W:	//normal break I won
+	case BOTH_LK_DL_ST_T_B_1_L:	//normal break I lost
+	case BOTH_LK_DL_ST_T_B_1_W:	//normal break I won
+	case BOTH_LK_DL_S_S_B_1_L:	//normal break I lost
+	case BOTH_LK_DL_S_S_B_1_W:	//normal break I won
+	case BOTH_LK_DL_S_T_B_1_L:	//normal break I lost
+	case BOTH_LK_DL_S_T_B_1_W:	//normal break I won
+	case BOTH_LK_ST_DL_S_B_1_L:	//normal break I lost
+	case BOTH_LK_ST_DL_S_B_1_W:	//normal break I won
+	case BOTH_LK_ST_DL_T_B_1_L:	//normal break I lost
+	case BOTH_LK_ST_DL_T_B_1_W:	//normal break I won
+	case BOTH_LK_ST_ST_S_B_1_L:	//normal break I lost
+	case BOTH_LK_ST_ST_S_B_1_W:	//normal break I won
+	case BOTH_LK_ST_ST_T_B_1_L:	//normal break I lost
+	case BOTH_LK_ST_ST_T_B_1_W:	//normal break I won
+	case BOTH_LK_ST_S_S_B_1_L:	//normal break I lost
+	case BOTH_LK_ST_S_S_B_1_W:	//normal break I won
+	case BOTH_LK_ST_S_T_B_1_L:	//normal break I lost
+	case BOTH_LK_ST_S_T_B_1_W:	//normal break I won
+		return qtrue;
+		break;
+	}
+	return (BG_SuperBreakLoseAnim(anim)||BG_SuperBreakWinAnim(anim));
+}
+
+
+qboolean BG_FullBodyTauntAnim( int anim )
+{
+	switch ( anim )
+	{
+	case BOTH_GESTURE1:
+	case BOTH_DUAL_TAUNT:
+	case BOTH_STAFF_TAUNT:
+	case BOTH_BOW:
+	case BOTH_MEDITATE:
+	case BOTH_SHOWOFF_FAST:
+	case BOTH_SHOWOFF_MEDIUM:
+	case BOTH_SHOWOFF_STRONG:
+	case BOTH_SHOWOFF_DUAL:
+	case BOTH_SHOWOFF_STAFF:
+	case BOTH_VICTORY_FAST:
+	case BOTH_VICTORY_MEDIUM:
+	case BOTH_VICTORY_STRONG:
+	case BOTH_VICTORY_DUAL:
+	case BOTH_VICTORY_STAFF:
+		return qtrue;
+		break;
+	}
+	return qfalse;
+}
+
+
+/*
+=============
+BG_AnimLength
+
+Get the "length" of an anim given the local anim index (which skeleton)
+and anim number. Obviously does not take things like the length of the
+anim while force speeding (as an example) and whatnot into account.
+=============
+*/
+int BG_AnimLength( int index, animNumber_t anim )
+{
+	if (anim >= MAX_ANIMATIONS)
+	{
+		return -1;
+	}
+	
+	return bgAllAnims[index].anims[anim].numFrames * fabs((float)(bgAllAnims[index].anims[anim].frameLerp));
+}
+
+//just use whatever pm->animations is
+int PM_AnimLength( int index, animNumber_t anim )
+{
+	if (anim >= MAX_ANIMATIONS || !pm->animations)
+	{
+		return -1;
+	}
+	if ( anim < 0 )
+	{
+		Com_Error(ERR_DROP,"ERROR: anim %d < 0\n", anim );
+	}
+	return pm->animations[anim].numFrames * fabs((float)(pm->animations[anim].frameLerp));
+}
+
+void PM_DebugLegsAnim(int anim)
+{
+	int oldAnim = (pm->ps->legsAnim);
+	int newAnim = (anim);
+
+	if (oldAnim < MAX_TOTALANIMATIONS && oldAnim >= BOTH_DEATH1 &&
+		newAnim < MAX_TOTALANIMATIONS && newAnim >= BOTH_DEATH1)
+	{
+		Com_Printf("OLD: %s\n", animTable[oldAnim]);
+		Com_Printf("NEW: %s\n", animTable[newAnim]);
+	}
+}
+
+qboolean PM_SaberInTransition( int move )
+{
+	if ( move >= LS_T1_BR__R && move <= LS_T1_BL__L )
+	{
+		return qtrue;
+	}
+	return qfalse;
+}
+
+qboolean BG_SaberInTransitionAny( int move )
+{
+	if ( PM_SaberInStart( move ) )
+	{
+		return qtrue;
+	}
+	else if ( PM_SaberInTransition( move ) )
+	{
+		return qtrue;
+	}
+	else if ( PM_SaberInReturn( move ) )
+	{
+		return qtrue;
+	}
+	return qfalse;
+}
+
+/*
+==============================================================================
+END: Animation utility functions (sequence checking)
+==============================================================================
+*/
+
+void BG_FlipPart(playerState_t *ps, int part)
+{
+	if (part == SETANIM_TORSO)
+	{
+		if (ps->torsoFlip)
+		{
+			ps->torsoFlip = qfalse;
+		}
+		else
+		{
+			ps->torsoFlip = qtrue;
+		}
+	}
+	else if (part == SETANIM_LEGS)
+	{
+		if (ps->legsFlip)
+		{
+			ps->legsFlip = qfalse;
+		}
+		else
+		{
+			ps->legsFlip = qtrue;
+		}
+	}
+}
+
+#ifdef Q3_VM
+char		BGPAFtext[60000];
+#endif
+qboolean	BGPAFtextLoaded = qfalse;
+animation_t	bgHumanoidAnimations[MAX_TOTALANIMATIONS]; //humanoid animations are the only ones that are statically allocated.
+
+//#define CONVENIENT_ANIMATION_FILE_DEBUG_THING
+
+#ifdef CONVENIENT_ANIMATION_FILE_DEBUG_THING
+void SpewDebugStuffToFile()
+{
+	fileHandle_t f;
+	int i = 0;
+
+	trap_FS_FOpenFile("file_of_debug_stuff_MP.txt", &f, FS_WRITE);
+
+	if (!f)
+	{
+		return;
+	}
+
+	BGPAFtext[0] = 0;
+
+	while (i < MAX_ANIMATIONS)
+	{
+		strcat(BGPAFtext, va("%i %i\n", i, bgHumanoidAnimations[i].frameLerp));
+		i++;
+	}
+
+	trap_FS_Write(BGPAFtext, strlen(BGPAFtext), f);
+	trap_FS_FCloseFile(f);
+}
+#endif
+
+bgLoadedAnim_t bgAllAnims[MAX_ANIM_FILES];
+int bgNumAllAnims = 2; //start off at 2, because 0 will always be assigned to humanoid, and 1 will always be rockettrooper
+
+//ALWAYS call on game/cgame init
+void BG_InitAnimsets(void)
+{
+	memset(&bgAllAnims, 0, sizeof(bgAllAnims));
+	BGPAFtextLoaded = qfalse;	// VVFIXME - The PC doesn't seem to need this, but why?
+}
+
+//ALWAYS call on game/cgame shutdown
+void BG_ClearAnimsets(void)
+{
+	/*
+	int i = 1;
+
+	while (i < bgNumAllAnims)
+	{
+		if (bgAllAnims[i].anims)
+		{
+			strap_TrueFree((void **)&bgAllAnims[i].anims);
+		}
+		i++;
+	}
+	*/
+}
+
+animation_t *BG_AnimsetAlloc(void)
+{
+	assert (bgNumAllAnims < MAX_ANIM_FILES);
+	bgAllAnims[bgNumAllAnims].anims = (animation_t *) BG_Alloc(sizeof(animation_t)*MAX_TOTALANIMATIONS);
+
+	return bgAllAnims[bgNumAllAnims].anims;
+}
+
+void BG_AnimsetFree(animation_t *animset)
+{
+	/*
+	if (!animset)
+	{
+		return;
+	}
+
+	strap_TrueFree((void **)&animset);
+
+#ifdef _DEBUG
+	if (animset)
+	{
+		assert(!"Failed to free anim set");
+	}
+#endif
+	*/
+}
+
+#ifndef QAGAME //none of this is actually needed serverside. Could just be moved to cgame code but it's here since it
+			   //used to tie in a lot with the anim loading stuff.
+stringID_table_t animEventTypeTable[MAX_ANIM_EVENTS+1] = 
+{
+	ENUM2STRING(AEV_SOUND),			//# animID AEV_SOUND framenum soundpath randomlow randomhi chancetoplay
+	ENUM2STRING(AEV_FOOTSTEP),		//# animID AEV_FOOTSTEP framenum footstepType
+	ENUM2STRING(AEV_EFFECT),		//# animID AEV_EFFECT framenum effectpath boltName
+	ENUM2STRING(AEV_FIRE),			//# animID AEV_FIRE framenum altfire chancetofire
+	ENUM2STRING(AEV_MOVE),			//# animID AEV_MOVE framenum forwardpush rightpush uppush
+	ENUM2STRING(AEV_SOUNDCHAN),		//# animID AEV_SOUNDCHAN framenum CHANNEL soundpath randomlow randomhi chancetoplay 
+	//must be terminated
+	NULL,-1
+};
+
+stringID_table_t footstepTypeTable[NUM_FOOTSTEP_TYPES+1] = 
+{
+	ENUM2STRING(FOOTSTEP_R),
+	ENUM2STRING(FOOTSTEP_L),
+	ENUM2STRING(FOOTSTEP_HEAVY_R),
+	ENUM2STRING(FOOTSTEP_HEAVY_L),
+	//must be terminated
+	NULL,-1
+};
+
+int CheckAnimFrameForEventType( animevent_t *animEvents, int keyFrame, animEventType_t eventType )
+{
+	int i;
+
+	for ( i = 0; i < MAX_ANIM_EVENTS; i++ )
+	{
+		if ( animEvents[i].keyFrame == keyFrame )
+		{//there is an animevent on this frame already
+			if ( animEvents[i].eventType == eventType )
+			{//and it is of the same type
+				return i;
+			}
+		}
+	}
+	//nope
+	return -1;
+}
+
+void ParseAnimationEvtBlock(const char *aeb_filename, animevent_t *animEvents, animation_t *animations, int *i,const char **text_p) 
+{
+	const char		*token;
+	int				num, n, animNum, keyFrame, lowestVal, highestVal, curAnimEvent, lastAnimEvent = 0;
+	animEventType_t	eventType;
+	char			stringData[MAX_QPATH];
+
+	// get past starting bracket
+	while(1) 
+	{
+		token = COM_Parse( text_p );
+		if ( !Q_stricmp( token, "{" ) ) 
+		{
+			break;
+		}
+	}
+
+	//NOTE: instead of a blind increment, increase the index
+	//			this way if we have an event on an anim that already
+	//			has an event of that type, it stomps it
+
+	// read information for each frame
+	while ( 1 ) 
+	{
+		if ( lastAnimEvent >= MAX_ANIM_EVENTS )
+		{
+			Com_Error( ERR_DROP, "ParseAnimationEvtBlock: number events in animEvent file %s > MAX_ANIM_EVENTS(%i)", aeb_filename, MAX_ANIM_EVENTS );
+			return;
+		}
+		// Get base frame of sequence
+		token = COM_Parse( text_p );
+		if ( !token || !token[0]) 
+		{
+			break;
+		}
+
+		if ( !Q_stricmp( token, "}" ) )		// At end of block 
+		{
+			break;
+		}
+
+		//Compare to same table as animations used 
+		//	so we don't have to use actual numbers for animation first frames,
+		//	just need offsets.
+		//This way when animation numbers change, this table won't have to be updated,
+		//	at least not much.
+		animNum = GetIDForString(animTable, token);
+		if(animNum == -1)
+		{//Unrecognized ANIM ENUM name, or we're skipping this line, keep going till you get a good one
+			Com_Printf(S_COLOR_YELLOW"WARNING: Unknown token %s in animEvent file %s\n", token, aeb_filename );
+			while (token[0])
+			{
+				token = COM_ParseExt( text_p, qfalse );	//returns empty string when next token is EOL
+			}
+			continue;
+		}
+
+		if ( animations[animNum].numFrames == 0 )
+		{//we don't use this anim
+			Com_Printf(S_COLOR_YELLOW"WARNING: %s animevents.cfg: anim %s not used by this model\n", aeb_filename, token);
+			//skip this entry
+			SkipRestOfLine( text_p );
+			continue;
+		}
+
+		token = COM_Parse( text_p );
+		eventType = (animEventType_t)GetIDForString(animEventTypeTable, token);
+		if ( eventType == AEV_NONE || eventType == -1 )
+		{//Unrecognized ANIM EVENT TYOE, or we're skipping this line, keep going till you get a good one
+			//Com_Printf(S_COLOR_YELLOW"WARNING: Unknown token %s in animEvent file %s\n", token, aeb_filename );
+			continue;
+		}
+
+		//set our start frame
+		keyFrame = animations[animNum].firstFrame;
+		// Get offset to frame within sequence
+		token = COM_Parse( text_p );
+		if ( !token ) 
+		{
+			break;
+		}
+		keyFrame += atoi( token );
+
+		//see if this frame already has an event of this type on it, if so, overwrite it
+		curAnimEvent = CheckAnimFrameForEventType( animEvents, keyFrame, eventType );
+		if ( curAnimEvent == -1 )
+		{//this anim frame doesn't already have an event of this type on it
+			curAnimEvent = lastAnimEvent;
+		}
+
+		//now that we know which event index we're going to plug the data into, start doing it
+		animEvents[curAnimEvent].eventType = eventType;
+		animEvents[curAnimEvent].keyFrame = keyFrame;
+
+		//now read out the proper data based on the type
+		switch ( animEvents[curAnimEvent].eventType )
+		{
+		case AEV_SOUNDCHAN:		//# animID AEV_SOUNDCHAN framenum CHANNEL soundpath randomlow randomhi chancetoplay
+			token = COM_Parse( text_p );
+			if ( !token ) 
+			{
+				break;
+			}
+			if ( stricmp( token, "CHAN_VOICE_ATTEN" ) == 0 )
+			{
+				animEvents[curAnimEvent].eventData[AED_SOUNDCHANNEL] = CHAN_VOICE_ATTEN;
+			}
+			else if ( stricmp( token, "CHAN_VOICE_GLOBAL" ) == 0 )
+			{
+				animEvents[curAnimEvent].eventData[AED_SOUNDCHANNEL] = CHAN_VOICE_GLOBAL;
+			}
+			else if ( stricmp( token, "CHAN_ANNOUNCER" ) == 0 )
+			{
+				animEvents[curAnimEvent].eventData[AED_SOUNDCHANNEL] = CHAN_ANNOUNCER;
+			}
+			else if ( stricmp( token, "CHAN_BODY" ) == 0 )
+			{
+				animEvents[curAnimEvent].eventData[AED_SOUNDCHANNEL] = CHAN_BODY;
+			}
+			else if ( stricmp( token, "CHAN_WEAPON" ) == 0 )
+			{
+				animEvents[curAnimEvent].eventData[AED_SOUNDCHANNEL] = CHAN_WEAPON;
+			}
+			else if ( stricmp( token, "CHAN_VOICE" ) == 0 )
+			{
+				animEvents[curAnimEvent].eventData[AED_SOUNDCHANNEL] = CHAN_VOICE;
+			} 
+			else
+			{
+				animEvents[curAnimEvent].eventData[AED_SOUNDCHANNEL] = CHAN_AUTO;
+			}
+			//fall through to normal sound
+		case AEV_SOUND:			//# animID AEV_SOUND framenum soundpath randomlow randomhi chancetoplay
+			//get soundstring
+			token = COM_Parse( text_p );
+			if ( !token ) 
+			{
+				break;
+			}		
+			strcpy(stringData, token);
+			//get lowest value
+			token = COM_Parse( text_p );
+			if ( !token ) 
+			{//WARNING!  BAD TABLE!
+				break;
+			}
+			lowestVal = atoi( token );
+			//get highest value
+			token = COM_Parse( text_p );
+			if ( !token ) 
+			{//WARNING!  BAD TABLE!
+				break;
+			}
+			highestVal = atoi( token );
+			//Now precache all the sounds
+			//NOTE: If we can be assured sequential handles, we can store sound indices
+			//		instead of strings, unfortunately, if these sounds were previously
+			//		registered, we cannot be guaranteed sequential indices.  Thus an array
+			if(lowestVal && highestVal)
+			{
+				//assert(highestVal - lowestVal < MAX_RANDOM_ANIM_SOUNDS);
+				if ((highestVal-lowestVal) >= MAX_RANDOM_ANIM_SOUNDS)
+				{
+					highestVal = lowestVal + (MAX_RANDOM_ANIM_SOUNDS-1);
+				}
+				for ( n = lowestVal, num = AED_SOUNDINDEX_START; n <= highestVal && num <= AED_SOUNDINDEX_END; n++, num++ )
+				{
+					if (stringData[0] == '*')
+					{ //FIXME? Would be nice to make custom sounds work with animEvents.
+						animEvents[curAnimEvent].eventData[num] = 0;
+					}
+					else
+					{
+						animEvents[curAnimEvent].eventData[num] = trap_S_RegisterSound( va( stringData, n ) );
+					}
+				}
+				animEvents[curAnimEvent].eventData[AED_SOUND_NUMRANDOMSNDS] = num - 1;
+			}
+			else
+			{
+				if (stringData[0] == '*')
+				{ //FIXME? Would be nice to make custom sounds work with animEvents.
+					animEvents[curAnimEvent].eventData[AED_SOUNDINDEX_START] = 0;
+				}
+				else
+				{
+					animEvents[curAnimEvent].eventData[AED_SOUNDINDEX_START] = trap_S_RegisterSound( stringData );
+				}
+#ifndef FINAL_BUILD
+				if ( !animEvents[curAnimEvent].eventData[AED_SOUNDINDEX_START] &&
+					 stringData[0] != '*')
+				{//couldn't register it - file not found
+					Com_Printf( S_COLOR_RED "ParseAnimationSndBlock: sound %s does not exist (animevents.cfg %s)!\n", stringData, aeb_filename );
+				}
+#endif
+				animEvents[curAnimEvent].eventData[AED_SOUND_NUMRANDOMSNDS] = 0;
+			}
+			//get probability
+			token = COM_Parse( text_p );
+			if ( !token ) 
+			{//WARNING!  BAD TABLE!
+				break;
+			}
+			animEvents[curAnimEvent].eventData[AED_SOUND_PROBABILITY] = atoi( token );
+			break;
+		case AEV_FOOTSTEP:		//# animID AEV_FOOTSTEP framenum footstepType
+			//get footstep type
+			token = COM_Parse( text_p );
+			if ( !token ) 
+			{
+				break;
+			}		
+			animEvents[curAnimEvent].eventData[AED_FOOTSTEP_TYPE] = GetIDForString(footstepTypeTable, token);
+			//get probability
+			token = COM_Parse( text_p );
+			if ( !token ) 
+			{//WARNING!  BAD TABLE!
+				break;
+			}
+			animEvents[curAnimEvent].eventData[AED_FOOTSTEP_PROBABILITY] = atoi( token );
+			break;
+		case AEV_EFFECT:		//# animID AEV_EFFECT framenum effectpath boltName
+			//get effect index
+			token = COM_Parse( text_p );
+			if ( !token ) 
+			{
+				break;
+			}
+			animEvents[curAnimEvent].eventData[AED_EFFECTINDEX] = trap_FX_RegisterEffect( token );
+			//get bolt index
+			token = COM_Parse( text_p );
+			if ( !token ) 
+			{
+				break;
+			}		
+			if ( Q_stricmp( "none", token ) != 0 && Q_stricmp( "NULL", token ) != 0 )
+			{//actually are specifying a bolt to use
+				if (!animEvents[curAnimEvent].stringData)
+				{ //eh, whatever. no dynamic stuff, so this will do.
+					animEvents[curAnimEvent].stringData = (char *) BG_Alloc(2048);
+				}
+				strcpy(animEvents[curAnimEvent].stringData, token);
+			}
+			//NOTE: this string will later be used to add a bolt and store the index, as below:
+			//animEvent->eventData[AED_BOLTINDEX] = gi.G2API_AddBolt( &cent->gent->ghoul2[cent->gent->playerModel], animEvent->stringData );
+			//get probability
+			token = COM_Parse( text_p );
+			if ( !token ) 
+			{//WARNING!  BAD TABLE!
+				break;
+			}
+			animEvents[curAnimEvent].eventData[AED_EFFECT_PROBABILITY] = atoi( token );
+			break;
+		case AEV_FIRE:			//# animID AEV_FIRE framenum altfire chancetofire
+			//get altfire
+			token = COM_Parse( text_p );
+			if ( !token ) 
+			{//WARNING!  BAD TABLE!
+				break;
+			}
+			animEvents[curAnimEvent].eventData[AED_FIRE_ALT] = atoi( token );
+			//get probability
+			token = COM_Parse( text_p );
+			if ( !token ) 
+			{//WARNING!  BAD TABLE!
+				break;
+			}
+			animEvents[curAnimEvent].eventData[AED_FIRE_PROBABILITY] = atoi( token );
+			break;
+		case AEV_MOVE:			//# animID AEV_MOVE framenum forwardpush rightpush uppush
+			//get forward push
+			token = COM_Parse( text_p );
+			if ( !token ) 
+			{//WARNING!  BAD TABLE!
+				break;
+			}
+			animEvents[curAnimEvent].eventData[AED_MOVE_FWD] = atoi( token );
+			//get right push
+			token = COM_Parse( text_p );
+			if ( !token ) 
+			{//WARNING!  BAD TABLE!
+				break;
+			}
+			animEvents[curAnimEvent].eventData[AED_MOVE_RT] = atoi( token );
+			//get upwards push
+			token = COM_Parse( text_p );
+			if ( !token ) 
+			{//WARNING!  BAD TABLE!
+				break;
+			}
+			animEvents[curAnimEvent].eventData[AED_MOVE_UP] = atoi( token );
+			break;
+		default:				//unknown?
+			SkipRestOfLine( text_p );
+			continue;
+			break;
+		}
+
+		if ( curAnimEvent == lastAnimEvent )
+		{
+			lastAnimEvent++;
+		}
+	}	
+}
+
+/*
+======================
+BG_ParseAnimationEvtFile
+
+Read a configuration file containing animation events
+models/players/kyle/animevents.cfg, etc
+
+This file's presence is not required
+
+======================
+*/
+bgLoadedEvents_t bgAllEvents[MAX_ANIM_FILES];
+int bgNumAnimEvents = 1;
+static int bg_animParseIncluding = 0;
+int BG_ParseAnimationEvtFile( const char *as_filename, int animFileIndex, int eventFileIndex ) 
+{
+	const char	*text_p;
+	int			len;
+	const char	*token;
+	char		text[80000];
+	char		sfilename[MAX_QPATH];
+	fileHandle_t	f;
+	int			i, j, upper_i, lower_i;
+	int				usedIndex = -1;
+	animevent_t	*legsAnimEvents;
+	animevent_t	*torsoAnimEvents;
+	animation_t		*animations;
+	int				forcedIndex;
+	
+	assert(animFileIndex < MAX_ANIM_FILES);
+	assert(eventFileIndex < MAX_ANIM_FILES);
+
+	if (eventFileIndex == -1)
+	{
+		forcedIndex = 0;
+	}
+	else
+	{
+		forcedIndex = eventFileIndex;
+	}
+
+	if (bg_animParseIncluding <= 0)
+	{ //if we should be parsing an included file, skip this part
+		if ( bgAllEvents[forcedIndex].eventsParsed )
+		{//already cached this one
+			return forcedIndex;
+		}
+	}
+
+	legsAnimEvents = bgAllEvents[forcedIndex].legsAnimEvents;
+	torsoAnimEvents = bgAllEvents[forcedIndex].torsoAnimEvents;
+	animations = bgAllAnims[animFileIndex].anims;
+
+	if (bg_animParseIncluding <= 0)
+	{ //if we should be parsing an included file, skip this part
+		//Go through and see if this filename is already in the table.
+		i = 0;
+		while (i < bgNumAnimEvents && forcedIndex != 0)
+		{
+			if (!Q_stricmp(as_filename, bgAllEvents[i].filename))
+			{ //looks like we have it already.
+				return i;
+			}
+			i++;
+		}
+	}
+
+	// Load and parse animevents.cfg file
+	Com_sprintf( sfilename, sizeof( sfilename ), "%sanimevents.cfg", as_filename );
+
+	if (bg_animParseIncluding <= 0)
+	{ //should already be done if we're including
+		//initialize anim event array
+		for( i = 0; i < MAX_ANIM_EVENTS; i++ )
+		{
+			//Type of event
+			torsoAnimEvents[i].eventType = AEV_NONE;
+			legsAnimEvents[i].eventType = AEV_NONE;
+			//Frame to play event on
+			torsoAnimEvents[i].keyFrame = -1;	
+			legsAnimEvents[i].keyFrame = -1;
+			//we allow storage of one string, temporarily (in case we have to look up an index later, then make sure to set stringData to NULL so we only do the look-up once)
+			torsoAnimEvents[i].stringData = NULL;
+			legsAnimEvents[i].stringData = NULL;
+			//Unique IDs, can be soundIndex of sound file to play OR effect index or footstep type, etc.
+			for ( j = 0; j < AED_ARRAY_SIZE; j++ )
+			{
+				torsoAnimEvents[i].eventData[j] = -1;
+				legsAnimEvents[i].eventData[j] = -1;
+			}
+		}
+	}
+
+	// load the file
+	len = trap_FS_FOpenFile( sfilename, &f, FS_READ );
+	if ( len <= 0 ) 
+	{//no file
+		goto fin;
+	}
+	if ( len >= sizeof( text ) - 1 ) 
+	{
+		trap_FS_FCloseFile(f);
+#ifndef FINAL_BUILD
+		Com_Error(ERR_DROP, "File %s too long\n", sfilename );
+#else
+		Com_Printf( "File %s too long\n", sfilename );
+#endif
+		goto fin;
+	}
+
+	trap_FS_Read( text, len, f );
+	text[len] = 0;
+	trap_FS_FCloseFile( f );
+
+	// parse the text
+	text_p = text;
+	upper_i =0;
+	lower_i =0;
+
+	// read information for batches of sounds (UPPER or LOWER)
+	while ( 1 ) 
+	{
+		// Get base frame of sequence
+		token = COM_Parse( &text_p );
+		if ( !token || !token[0] ) 
+		{
+			break;
+		}
+
+		if ( !Q_stricmp(token,"include") )	// grab from another animevents.cfg
+		{//NOTE: you REALLY should NOT do this after the main block of UPPERSOUNDS and LOWERSOUNDS
+			const char	*include_filename = COM_Parse( &text_p );
+			if ( include_filename != NULL )
+			{
+				char fullIPath[MAX_QPATH];
+				strcpy(fullIPath, va("models/players/%s/", include_filename));
+				bg_animParseIncluding++;
+				BG_ParseAnimationEvtFile( fullIPath, animFileIndex, forcedIndex );
+				bg_animParseIncluding--;
+			}
+		}
+
+		if ( !Q_stricmp(token,"UPPEREVENTS") )	// A batch of upper sounds
+		{
+			ParseAnimationEvtBlock( as_filename, torsoAnimEvents, animations, &upper_i, &text_p ); 
+		}
+
+		else if ( !Q_stricmp(token,"LOWEREVENTS") )	// A batch of lower sounds
+		{
+			ParseAnimationEvtBlock( as_filename, legsAnimEvents, animations, &lower_i, &text_p ); 
+		}
+	}
+
+	usedIndex = forcedIndex;
+fin:
+	//Mark this anim set so that we know we tried to load he sounds, don't care if the load failed
+	if (bg_animParseIncluding <= 0)
+	{ //if we should be parsing an included file, skip this part
+		bgAllEvents[forcedIndex].eventsParsed = qtrue;
+		strcpy(bgAllEvents[forcedIndex].filename, as_filename);
+		if (forcedIndex)
+		{
+			bgNumAnimEvents++;
+		}
+	}
+
+	return usedIndex;
+}
+#endif
+
+/*
+======================
+BG_ParseAnimationFile
+
+Read a configuration file containing animation coutns and rates
+models/players/visor/animation.cfg, etc
+
+======================
+*/
+int BG_ParseAnimationFile(const char *filename, animation_t *animset, qboolean isHumanoid) 
+{
+	char		*text_p;
+	int			len;
+	int			i;
+	char		*token;
+	float		fps;
+	int			skip;
+	int			usedIndex = -1;
+	int			nextIndex = bgNumAllAnims;
+	qboolean	dynAlloc = qfalse;
+	qboolean	wasLoaded = qfalse;
+#ifndef Q3_VM
+	char		BGPAFtext[60000];
+#endif
+
+	fileHandle_t	f;
+	int				animNum;
+
+	if (!isHumanoid)
+	{
+		i = 0;
+		while (i < bgNumAllAnims)
+		{ //see if it's been loaded already
+			if (!Q_stricmp(bgAllAnims[i].filename, filename))
+			{
+				animset = bgAllAnims[i].anims;
+				return i; //alright, we already have it.
+			}
+			i++;
+		}
+
+		//Looks like it has not yet been loaded. Allocate space for the anim set if we need to, and continue along.
+		if (!animset)
+		{
+			if (strstr(filename, "players/_humanoid/"))
+			{ //then use the static humanoid set.
+				animset = bgHumanoidAnimations;
+				nextIndex = 0;
+			}
+			else if (strstr(filename, "players/rockettrooper/"))
+			{ //rockettrooper always index 1
+				nextIndex = 1;
+				animset = BG_AnimsetAlloc();
+				dynAlloc = qtrue; //so we know to free this memory in case we have to return early. Don't want any leaks.
+
+				if (!animset)
+				{
+					assert(!"Anim set alloc failed!");
+					return -1;
+				}
+			}
+			else
+			{
+				animset = BG_AnimsetAlloc();
+				dynAlloc = qtrue; //so we know to free this memory in case we have to return early. Don't want any leaks.
+
+				if (!animset)
+				{
+					assert(!"Anim set alloc failed!");
+					return -1;
+				}
+			}
+		}
+	}
+#ifdef _DEBUG
+	else
+	{
+		assert(animset);
+	}
+#endif
+
+	// load the file
+	if (!BGPAFtextLoaded || !isHumanoid)
+	{ //rww - We are always using the same animation config now. So only load it once.
+		len = trap_FS_FOpenFile( filename, &f, FS_READ );
+		if ( (len <= 0) || (len >= sizeof( BGPAFtext ) - 1) ) 
+		{
+			if (dynAlloc)
+			{
+				BG_AnimsetFree(animset);
+			}
+			if (len > 0)
+			{
+				Com_Error(ERR_DROP, "%s exceeds the allowed game-side animation buffer!", filename);
+			}
+			return -1;
+		}
+
+		trap_FS_Read( BGPAFtext, len, f );
+		BGPAFtext[len] = 0;
+		trap_FS_FCloseFile( f );
+	}
+	else
+	{
+		if (dynAlloc)
+		{
+			assert(!"Should not have allocated dynamically for humanoid");
+			BG_AnimsetFree(animset);
+		}
+		return 0; //humanoid index
+	}
+
+	// parse the text
+	text_p = BGPAFtext;
+	skip = 0;	// quiet the compiler warning
+
+	//FIXME: have some way of playing anims backwards... negative numFrames?
+
+	//initialize anim array so that from 0 to MAX_ANIMATIONS, set default values of 0 1 0 100
+	for(i = 0; i < MAX_ANIMATIONS; i++)
+	{
+		animset[i].firstFrame = 0;
+		animset[i].numFrames = 0;
+		animset[i].loopFrames = -1;
+		animset[i].frameLerp = 100;
+	}
+
+	// read information for each frame
+	while(1) 
+	{
+		token = COM_Parse( (const char **)(&text_p) );
+
+		if ( !token || !token[0]) 
+		{
+			break;
+		}
+
+		animNum = GetIDForString(animTable, token);
+		if(animNum == -1)
+		{
+//#ifndef FINAL_BUILD
+#ifdef _DEBUG
+			Com_Printf(S_COLOR_RED"WARNING: Unknown token %s in %s\n", token, filename);
+			while (token[0])
+			{
+				token = COM_ParseExt( (const char **) &text_p, qfalse );	//returns empty string when next token is EOL
+			}
+#endif
+			continue;
+		}
+
+		token = COM_Parse( (const char **)(&text_p) );
+		if ( !token ) 
+		{
+			break;
+		}
+		animset[animNum].firstFrame = atoi( token );
+
+		token = COM_Parse( (const char **)(&text_p) );
+		if ( !token ) 
+		{
+			break;
+		}
+		animset[animNum].numFrames = atoi( token );
+
+		token = COM_Parse( (const char **)(&text_p) );
+		if ( !token ) 
+		{
+			break;
+		}
+		animset[animNum].loopFrames = atoi( token );
+
+		token = COM_Parse( (const char **)(&text_p) );
+		if ( !token ) 
+		{
+			break;
+		}
+		fps = atof( token );
+		if ( fps == 0 ) 
+		{
+			fps = 1;//Don't allow divide by zero error
+		}
+		if ( fps < 0 )
+		{//backwards
+			animset[animNum].frameLerp = floor(1000.0f / fps);
+		}
+		else
+		{
+			animset[animNum].frameLerp = ceil(1000.0f / fps);
+		}
+	}
+/*
+#ifdef _DEBUG
+	//Check the array, and print the ones that have nothing in them.
+	for(i = 0; i < MAX_ANIMATIONS; i++)
+	{	
+		if (animTable[i].name != NULL)		// This animation reference exists.
+		{
+			if (animset[i].firstFrame <= 0 && animset[i].numFrames <=0)
+			{	// This is an empty animation reference.
+				Com_Printf("***ANIMTABLE reference #%d (%s) is empty!\n", i, animTable[i].name);
+			}
+		}
+	}
+#endif // _DEBUG
+*/
+#ifdef CONVENIENT_ANIMATION_FILE_DEBUG_THING
+	SpewDebugStuffToFile();
+#endif
+
+	wasLoaded = BGPAFtextLoaded;
+
+	if (isHumanoid)
+	{
+		bgAllAnims[0].anims = animset;
+		strcpy(bgAllAnims[0].filename, filename);
+		BGPAFtextLoaded = qtrue;
+
+		usedIndex = 0;
+	}
+	else
+	{
+		bgAllAnims[nextIndex].anims = animset;
+		strcpy(bgAllAnims[nextIndex].filename, filename);
+
+		usedIndex = bgNumAllAnims;
+
+		if (nextIndex > 1)
+		{ //don't bother increasing the number if this ended up as a humanoid/rockettrooper load.
+			bgNumAllAnims++;
+		}
+		else
+		{
+			BGPAFtextLoaded = qtrue;
+			usedIndex = nextIndex;
+		}
+	}
+
+	/*
+	if (!wasLoaded && BGPAFtextLoaded)
+	{ //just loaded humanoid skel - we always want the rockettrooper to be after it, in slot 1
+#ifdef _DEBUG
+		assert(BG_ParseAnimationFile("models/players/rockettrooper/animation.cfg", NULL, qfalse) == 1);
+#else
+		BG_ParseAnimationFile("models/players/rockettrooper/animation.cfg", NULL, qfalse);
+#endif
+	}
+	*/
+
+	return usedIndex;
+}
+
+/*
+===================
+LEGS Animations
+Base animation for overall body
+===================
+*/
+static void BG_StartLegsAnim( playerState_t *ps, int anim )
+{
+	if ( ps->pm_type >= PM_DEAD )
+	{
+		assert(!BG_InDeathAnim(anim));
+		//please let me know if this assert fires on you (ideally before you close/ignore it) -rww
+
+		//vehicles are allowed to do this.. IF it's a vehicle death anim
+		if (ps->clientNum < MAX_CLIENTS || anim != BOTH_VT_DEATH1)
+		{
+			return;
+		}
+	}
+	if ( ps->legsTimer > 0 )
+	{
+		return;		// a high priority animation is running
+	}
+
+	if (ps->legsAnim == anim)
+	{
+		BG_FlipPart(ps, SETANIM_LEGS);
+	}
+#ifdef QAGAME
+	else if (g_entities[ps->clientNum].s.legsAnim == anim)
+	{ //toggled anim to one anim then back to the one we were at previously in
+		//one frame, indicating that anim should be restarted.
+		BG_FlipPart(ps, SETANIM_LEGS);
+	}
+#endif
+	ps->legsAnim = anim;
+
+	/*
+	if ( pm->debugLevel ) {
+		Com_Printf("%d:  StartLegsAnim %d, on client#%d\n", pm->cmd.serverTime, anim, pm->ps->clientNum);
+	}
+	*/
+}
+
+void PM_ContinueLegsAnim( int anim ) {
+	if ( ( pm->ps->legsAnim ) == anim ) {
+		return;
+	}
+	if ( pm->ps->legsTimer > 0 ) {
+		return;		// a high priority animation is running
+	}
+
+	BG_StartLegsAnim( pm->ps, anim );
+}
+
+void PM_ForceLegsAnim( int anim) {
+	if (BG_InSpecialJump(pm->ps->legsAnim) &&
+		pm->ps->legsTimer > 0 &&
+		!BG_InSpecialJump(anim))
+	{
+		return;
+	}
+
+	if (BG_InRoll(pm->ps, pm->ps->legsAnim) &&
+		pm->ps->legsTimer > 0 &&
+		!BG_InRoll(pm->ps, anim))
+	{
+		return;
+	}
+
+	pm->ps->legsTimer = 0;
+	BG_StartLegsAnim( pm->ps, anim );
+}
+
+
+
+/*
+===================
+TORSO Animations
+Override animations for upper body
+===================
+*/
+void BG_StartTorsoAnim( playerState_t *ps, int anim )
+{
+	if ( ps->pm_type >= PM_DEAD )
+	{
+		assert(!BG_InDeathAnim(anim));
+		//please let me know if this assert fires on you (ideally before you close/ignore it) -rww
+		return;
+	}
+
+	if (ps->torsoAnim == anim)
+	{
+		BG_FlipPart(ps, SETANIM_TORSO);
+	}
+#ifdef QAGAME
+	else if (g_entities[ps->clientNum].s.torsoAnim == anim)
+	{ //toggled anim to one anim then back to the one we were at previously in
+		//one frame, indicating that anim should be restarted.
+		BG_FlipPart(ps, SETANIM_TORSO);
+	}
+#endif
+	ps->torsoAnim = anim;
+}
+
+void PM_StartTorsoAnim( int anim )
+{
+    BG_StartTorsoAnim(pm->ps, anim);
+}
+
+
+/*
+-------------------------
+PM_SetLegsAnimTimer
+-------------------------
+*/
+void BG_SetLegsAnimTimer(playerState_t *ps, int time)
+{
+	ps->legsTimer = time;
+
+	if (ps->legsTimer < 0 && time != -1 )
+	{//Cap timer to 0 if was counting down, but let it be -1 if that was intentional.  NOTENOTE Yeah this seems dumb, but it mirrors SP.
+		ps->legsTimer = 0;
+	}
+}
+
+void PM_SetLegsAnimTimer(int time)
+{
+	BG_SetLegsAnimTimer(pm->ps, time);
+}
+
+/*
+-------------------------
+PM_SetTorsoAnimTimer
+-------------------------
+*/
+void BG_SetTorsoAnimTimer(playerState_t *ps, int time )
+{
+	ps->torsoTimer = time;
+
+	if (ps->torsoTimer < 0 && time != -1 )
+	{//Cap timer to 0 if was counting down, but let it be -1 if that was intentional.  NOTENOTE Yeah this seems dumb, but it mirrors SP.
+		ps->torsoTimer = 0;
+	}
+}
+
+void PM_SetTorsoAnimTimer(int time )
+{
+	BG_SetTorsoAnimTimer(pm->ps, time);
+}
+
+void BG_SaberStartTransAnim( int saberAnimLevel, int anim, float *animSpeed, int broken )
+{
+	if ( ( (anim) >= BOTH_T1_BR__R && 
+		(anim) <= BOTH_T1_BL_TL ) ||
+		( (anim) >= BOTH_T2_BR__R && 
+		(anim) <= BOTH_T2_BL_TL ) ||
+		( (anim) >= BOTH_T3_BR__R && 
+		(anim) <= BOTH_T3_BL_TL ) )
+	{
+		if ( saberAnimLevel == FORCE_LEVEL_1 )
+		{
+			*animSpeed *= 1.5f;
+		}
+		else if ( saberAnimLevel == FORCE_LEVEL_3 )
+		{
+			*animSpeed *= 0.75f;
+		}
+
+		if (broken & (1<<BROKENLIMB_RARM))
+		{
+			*animSpeed *= 0.5f;
+		}
+		else if (broken & (1<<BROKENLIMB_LARM))
+		{
+			*animSpeed *= 0.65f;
+		}
+	}
+	else if (broken && PM_InSaberAnim(anim))
+	{
+		if (broken & (1<<BROKENLIMB_RARM))
+		{
+			*animSpeed *= 0.5f;
+		}
+		else if (broken & (1<<BROKENLIMB_LARM))
+		{
+			*animSpeed *= 0.65f;
+		}
+	}
+}
+
+/*
+-------------------------
+PM_SetAnimFinal
+-------------------------
+*/
+qboolean PM_RunningAnim( int anim );
+qboolean PM_WalkingAnim( int anim );
+
+void BG_SetAnimFinal(playerState_t *ps, animation_t *animations,
+					 int setAnimParts,int anim,int setAnimFlags,
+					 int blendTime)		// default blendTime=350
+{
+	float editAnimSpeed = 1;
+
+	if (!animations)
+	{
+		return;
+	}
+
+	assert(anim > -1);
+	assert(animations[anim].firstFrame > 0 || animations[anim].numFrames > 0);
+
+	//NOTE: Setting blendTime here breaks actual blending..
+	blendTime = 0;
+
+	BG_SaberStartTransAnim(ps->fd.saberAnimLevel, anim, &editAnimSpeed, ps->brokenLimbs);
+
+	// Set torso anim
+	if (setAnimParts & SETANIM_TORSO)
+	{
+		// Don't reset if it's already running the anim
+		if( !(setAnimFlags & SETANIM_FLAG_RESTART) && (ps->torsoAnim) == anim )
+		{
+			goto setAnimLegs;
+		}
+		// or if a more important anim is running
+		if( !(setAnimFlags & SETANIM_FLAG_OVERRIDE) && ((ps->torsoTimer > 0)||(ps->torsoTimer == -1)) )
+		{	
+			goto setAnimLegs;
+		}
+
+		BG_StartTorsoAnim(ps, anim);
+
+		if (setAnimFlags & SETANIM_FLAG_HOLD)
+		{
+			if (setAnimFlags & SETANIM_FLAG_HOLDLESS)
+			{	// Make sure to only wait in full 1/20 sec server frame intervals.
+				int dur;
+				int speedDif;
+				
+				dur = (animations[anim].numFrames-1) * fabs((float)(animations[anim].frameLerp));
+				speedDif = dur - (dur * editAnimSpeed);
+				dur += speedDif;
+				if (dur > 1)
+				{
+					ps->torsoTimer = dur-1;
+				}
+				else
+				{
+					ps->torsoTimer = fabs((float)(animations[anim].frameLerp));
+				}
+			}
+			else
+			{
+				ps->torsoTimer = ((animations[anim].numFrames ) * fabs((float)(animations[anim].frameLerp)));
+			}
+
+			if (ps->fd.forcePowersActive & (1 << FP_RAGE))
+			{
+				ps->torsoTimer /= 1.7;
+			}
+		}
+	}
+
+setAnimLegs:
+	// Set legs anim
+	if (setAnimParts & SETANIM_LEGS)
+	{
+		// Don't reset if it's already running the anim
+		if( !(setAnimFlags & SETANIM_FLAG_RESTART) && (ps->legsAnim) == anim )
+		{
+			goto setAnimDone;
+		}
+		// or if a more important anim is running
+		if( !(setAnimFlags & SETANIM_FLAG_OVERRIDE) && ((ps->legsTimer > 0)||(ps->legsTimer == -1)) )
+		{	
+			goto setAnimDone;
+		}
+
+		BG_StartLegsAnim(ps, anim);
+
+		if (setAnimFlags & SETANIM_FLAG_HOLD)
+		{
+			if (setAnimFlags & SETANIM_FLAG_HOLDLESS)
+			{	// Make sure to only wait in full 1/20 sec server frame intervals.
+				int dur;
+				int speedDif;
+				
+				dur = (animations[anim].numFrames-1) * fabs((float)(animations[anim].frameLerp));
+				speedDif = dur - (dur * editAnimSpeed);
+				dur += speedDif;
+				if (dur > 1)
+				{
+					ps->legsTimer = dur-1;
+				}
+				else
+				{
+					ps->legsTimer = fabs((float)(animations[anim].frameLerp));
+				}
+			}
+			else
+			{
+				ps->legsTimer = ((animations[anim].numFrames ) * fabs((float)(animations[anim].frameLerp)));
+			}
+
+			if (PM_RunningAnim(anim) ||
+				PM_WalkingAnim(anim)) //these guys are ok, they don't actually reference pm
+			{
+				if (ps->fd.forcePowersActive & (1 << FP_RAGE))
+				{
+					ps->legsTimer /= 1.3;
+				}
+				else if (ps->fd.forcePowersActive & (1 << FP_SPEED))
+				{
+					ps->legsTimer /= 1.7;
+				}
+			}
+		}
+	}
+
+setAnimDone:
+	return;
+}
+
+void PM_SetAnimFinal(int setAnimParts,int anim,int setAnimFlags,
+					 int blendTime)		// default blendTime=350
+{
+	BG_SetAnimFinal(pm->ps, pm->animations, setAnimParts, anim, setAnimFlags, blendTime);
+}
+
+
+qboolean BG_HasAnimation(int animIndex, int animation)
+{
+	animation_t *animations;
+
+	//must be a valid anim number
+	if ( animation < 0 || animation >= MAX_ANIMATIONS )
+	{
+		return qfalse;
+	}
+
+	//Must have a file index entry
+	if( animIndex < 0 || animIndex > bgNumAllAnims )
+		return qfalse;
+
+	animations = bgAllAnims[animIndex].anims;
+
+	//No frames, no anim
+	if ( animations[animation].numFrames == 0 )
+		return qfalse;
+
+	//Has the sequence
+	return qtrue;
+}
+
+int BG_PickAnim( int animIndex, int minAnim, int maxAnim )
+{
+	int anim;
+	int count = 0;
+
+	do
+	{
+		anim = Q_irand(minAnim, maxAnim);
+		count++;
+	}
+	while ( !BG_HasAnimation( animIndex, anim ) && count < 1000 );
+
+	if (count == 1000)
+	{ //guess we just don't have a death anim then.
+		return -1;
+	}
+
+	return anim;
+}
+
+//I want to be able to use this on a playerstate even when we are not the focus
+//of a pmove too so I have ported it to true BGishness.
+//Please do not reference pm in this function or any functions that it calls,
+//or I will cry. -rww
+void BG_SetAnim(playerState_t *ps, animation_t *animations, int setAnimParts,int anim,int setAnimFlags, int blendTime)
+{
+	if (!animations)
+	{
+		animations = bgAllAnims[0].anims;
+	}
+
+	if (animations[anim].firstFrame == 0 && animations[anim].numFrames == 0)
+	{
+		if (anim == BOTH_RUNBACK1 ||
+			anim == BOTH_WALKBACK1 ||
+			anim == BOTH_RUN1)
+		{ //hack for droids
+			anim = BOTH_WALK2;
+		}
+
+		if (animations[anim].firstFrame == 0 && animations[anim].numFrames == 0)
+		{ //still? Just return then I guess.
+			return;
+		}
+	}
+
+	/*
+	if (BG_InSpecialJump(anim))
+	{
+		setAnimFlags |= SETANIM_FLAG_RESTART;
+	}
+	*/
+	//Don't know why I put this here originally but it's messing stuff up now and it isn't needed.
+
+//	if (BG_InRoll(ps, ps->legsAnim))
+//	{ //never interrupt a roll
+//		return;
+//	}
+
+	if (setAnimFlags&SETANIM_FLAG_OVERRIDE)
+	{
+		if (setAnimParts & SETANIM_TORSO)
+		{
+			if( (setAnimFlags & SETANIM_FLAG_RESTART) || (ps->torsoAnim) != anim )
+			{
+				BG_SetTorsoAnimTimer(ps, 0);
+			}
+		}
+		if (setAnimParts & SETANIM_LEGS)
+		{
+			if( (setAnimFlags & SETANIM_FLAG_RESTART) || (ps->legsAnim) != anim )
+			{
+				BG_SetLegsAnimTimer(ps, 0);
+			}
+		}
+	}
+
+	BG_SetAnimFinal(ps, animations, setAnimParts, anim, setAnimFlags, blendTime);
+}
+
+void PM_SetAnim(int setAnimParts,int anim,int setAnimFlags, int blendTime)
+{	
+	BG_SetAnim(pm->ps, pm->animations, setAnimParts, anim, setAnimFlags, blendTime);
+}
+
+#include "../namespace_end.h"		// End of animation utilities
diff --git a/codemp/game/bg_pmove.c b/codemp/game/bg_pmove.c
new file mode 100644
index 0000000..02bd437
--- /dev/null
+++ b/codemp/game/bg_pmove.c
@@ -0,0 +1,10868 @@
+// Copyright (C) 1999-2000 Id Software, Inc.
+//
+// bg_pmove.c -- both games player movement code
+// takes a playerstate and a usercmd as input and returns a modifed playerstate
+
+#include "q_shared.h"
+#include "bg_public.h"
+#include "bg_local.h"
+#include "bg_strap.h"
+#include "../ghoul2/G2.h"
+
+#ifdef QAGAME
+#include "g_local.h" //ahahahahhahahaha@$!$!
+#endif
+
+#define MAX_WEAPON_CHARGE_TIME 5000
+
+#ifdef QAGAME
+extern void G_CheapWeaponFire(int entNum, int ev);
+extern qboolean TryGrapple(gentity_t *ent); //g_cmds.c
+extern void trap_FX_PlayEffect( const char *file, vec3_t org, vec3_t fwd, int vol, int rad );
+#endif
+
+#include "../namespace_begin.h"
+extern qboolean BG_FullBodyTauntAnim( int anim );
+extern float PM_WalkableGroundDistance(void);
+extern qboolean PM_GroundSlideOkay( float zNormal );
+
+pmove_t		*pm;
+pml_t		pml;
+
+bgEntity_t *pm_entSelf = NULL;
+bgEntity_t *pm_entVeh = NULL;
+
+qboolean gPMDoSlowFall = qfalse;
+
+qboolean pm_cancelOutZoom = qfalse;
+
+// movement parameters
+float	pm_stopspeed = 100.0f;
+float	pm_duckScale = 0.50f;
+float	pm_swimScale = 0.50f;
+float	pm_wadeScale = 0.70f;
+
+float	pm_vehicleaccelerate = 36.0f;
+float	pm_accelerate = 10.0f;
+float	pm_airaccelerate = 1.0f;
+float	pm_wateraccelerate = 4.0f;
+float	pm_flyaccelerate = 8.0f;
+
+float	pm_friction = 6.0f;
+float	pm_waterfriction = 1.0f;
+float	pm_flightfriction = 3.0f;
+float	pm_spectatorfriction = 5.0f;
+
+int		c_pmove = 0;
+
+float forceSpeedLevels[4] = 
+{
+	1, //rank 0?
+	1.25,
+	1.5,
+	1.75
+};
+
+int forcePowerNeeded[NUM_FORCE_POWER_LEVELS][NUM_FORCE_POWERS] = 
+{
+	{ //nothing should be usable at rank 0..
+		999,//FP_HEAL,//instant
+		999,//FP_LEVITATION,//hold/duration
+		999,//FP_SPEED,//duration
+		999,//FP_PUSH,//hold/duration
+		999,//FP_PULL,//hold/duration
+		999,//FP_TELEPATHY,//instant
+		999,//FP_GRIP,//hold/duration
+		999,//FP_LIGHTNING,//hold/duration
+		999,//FP_RAGE,//duration
+		999,//FP_PROTECT,//duration
+		999,//FP_ABSORB,//duration
+		999,//FP_TEAM_HEAL,//instant
+		999,//FP_TEAM_FORCE,//instant
+		999,//FP_DRAIN,//hold/duration
+		999,//FP_SEE,//duration
+		999,//FP_SABER_OFFENSE,
+		999,//FP_SABER_DEFENSE,
+		999//FP_SABERTHROW,
+		//NUM_FORCE_POWERS
+	},
+	{
+		65,//FP_HEAL,//instant //was 25, but that was way too little
+		10,//FP_LEVITATION,//hold/duration
+		50,//FP_SPEED,//duration
+		20,//FP_PUSH,//hold/duration
+		20,//FP_PULL,//hold/duration
+		20,//FP_TELEPATHY,//instant
+		30,//FP_GRIP,//hold/duration
+		1,//FP_LIGHTNING,//hold/duration
+		50,//FP_RAGE,//duration
+		50,//FP_PROTECT,//duration
+		50,//FP_ABSORB,//duration
+		50,//FP_TEAM_HEAL,//instant
+		50,//FP_TEAM_FORCE,//instant
+		20,//FP_DRAIN,//hold/duration
+		20,//FP_SEE,//duration
+		0,//FP_SABER_OFFENSE,
+		2,//FP_SABER_DEFENSE,
+		20//FP_SABERTHROW,
+		//NUM_FORCE_POWERS
+	},
+	{
+		60,//FP_HEAL,//instant
+		10,//FP_LEVITATION,//hold/duration
+		50,//FP_SPEED,//duration
+		20,//FP_PUSH,//hold/duration
+		20,//FP_PULL,//hold/duration
+		20,//FP_TELEPATHY,//instant
+		30,//FP_GRIP,//hold/duration
+		1,//FP_LIGHTNING,//hold/duration
+		50,//FP_RAGE,//duration
+		25,//FP_PROTECT,//duration
+		25,//FP_ABSORB,//duration
+		33,//FP_TEAM_HEAL,//instant
+		33,//FP_TEAM_FORCE,//instant
+		20,//FP_DRAIN,//hold/duration
+		20,//FP_SEE,//duration
+		0,//FP_SABER_OFFENSE,
+		1,//FP_SABER_DEFENSE,
+		20//FP_SABERTHROW,
+		//NUM_FORCE_POWERS
+	},
+	{
+		50,//FP_HEAL,//instant //You get 5 points of health.. for 50 force points!
+		10,//FP_LEVITATION,//hold/duration
+		50,//FP_SPEED,//duration
+		20,//FP_PUSH,//hold/duration
+		20,//FP_PULL,//hold/duration
+		20,//FP_TELEPATHY,//instant
+		60,//FP_GRIP,//hold/duration
+		1,//FP_LIGHTNING,//hold/duration
+		50,//FP_RAGE,//duration
+		10,//FP_PROTECT,//duration
+		10,//FP_ABSORB,//duration
+		25,//FP_TEAM_HEAL,//instant
+		25,//FP_TEAM_FORCE,//instant
+		20,//FP_DRAIN,//hold/duration
+		20,//FP_SEE,//duration
+		0,//FP_SABER_OFFENSE,
+		0,//FP_SABER_DEFENSE,
+		20//FP_SABERTHROW,
+		//NUM_FORCE_POWERS
+	}
+};
+
+float forceJumpHeight[NUM_FORCE_POWER_LEVELS] = 
+{
+	32,//normal jump (+stepheight+crouchdiff = 66)
+	96,//(+stepheight+crouchdiff = 130)
+	192,//(+stepheight+crouchdiff = 226)
+	384//(+stepheight+crouchdiff = 418)
+};
+
+float forceJumpStrength[NUM_FORCE_POWER_LEVELS] = 
+{
+	JUMP_VELOCITY,//normal jump
+	420,
+	590,
+	840
+};
+
+//rww - Get a pointer to the bgEntity by the index
+bgEntity_t *PM_BGEntForNum( int num )
+{
+	bgEntity_t *ent;
+
+	if (!pm)
+	{
+		assert(!"You cannot call PM_BGEntForNum outside of pm functions!");
+		return NULL;
+	}
+
+	if (!pm->baseEnt)
+	{
+		assert(!"Base entity address not set");
+		return NULL;
+	}
+
+	if (!pm->entSize)
+	{
+		assert(!"sizeof(ent) is 0, impossible (not set?)");
+		return NULL;
+	}
+
+	assert(num >= 0 && num < MAX_GENTITIES);
+
+    ent = (bgEntity_t *)((byte *)pm->baseEnt + pm->entSize*(num));
+
+	return ent;
+}
+
+qboolean BG_SabersOff( playerState_t *ps )
+{
+	if ( !ps->saberHolstered )
+	{
+		return qfalse;
+	}
+	if ( ps->fd.saberAnimLevelBase == SS_DUAL
+		|| ps->fd.saberAnimLevelBase == SS_STAFF )
+	{
+		if ( ps->saberHolstered < 2 )
+		{
+			return qfalse;
+		}
+	}
+	return qtrue;
+}
+
+qboolean BG_KnockDownable(playerState_t *ps)
+{
+	if (!ps)
+	{ //just for safety
+		return qfalse;
+	}
+
+	if (ps->m_iVehicleNum)
+	{ //riding a vehicle, don't knock me down
+		return qfalse;
+	}
+
+	if (ps->emplacedIndex)
+	{ //using emplaced gun or eweb, can't be knocked down
+		return qfalse;
+	}
+
+	//ok, I guess?
+	return qtrue;
+}
+
+//I should probably just do a global inline sometime.
+#ifndef __LCC__
+#define PM_INLINE ID_INLINE
+#else
+#define PM_INLINE //none
+#endif
+
+//hacky assumption check, assume any client non-humanoid is a rocket trooper
+qboolean PM_INLINE PM_IsRocketTrooper(void)
+{
+	/*
+	if (pm->ps->clientNum < MAX_CLIENTS &&
+		pm->gametype == GT_SIEGE &&
+		pm->nonHumanoid)
+	{
+		return qtrue;
+	}
+	*/
+
+	return qfalse;
+}
+
+int PM_GetSaberStance(void)
+{
+	int anim = BOTH_STAND2;
+
+	if (!pm->ps->saberEntityNum)
+	{ //lost it
+		return BOTH_STAND1;
+	}
+
+	if ( BG_SabersOff( pm->ps ) )
+	{
+		return BOTH_STAND1;
+	}
+
+	switch ( pm->ps->fd.saberAnimLevel )
+	{
+	case SS_DUAL:
+		anim = BOTH_SABERDUAL_STANCE;
+		break;
+	case SS_STAFF:
+		anim = BOTH_SABERSTAFF_STANCE;
+		break;
+	case FORCE_LEVEL_1:
+	case FORCE_LEVEL_5:
+		anim = BOTH_SABERFAST_STANCE;
+		break;
+	case FORCE_LEVEL_3:
+		anim = BOTH_SABERSLOW_STANCE;
+		break;
+	case FORCE_LEVEL_0:
+	case FORCE_LEVEL_2:
+	case FORCE_LEVEL_4:
+	default:
+		anim = BOTH_STAND2;
+		break;
+	}
+	return anim;
+}
+
+qboolean PM_DoSlowFall(void)
+{
+	if ( ( (pm->ps->legsAnim) == BOTH_WALL_RUN_RIGHT || (pm->ps->legsAnim) == BOTH_WALL_RUN_LEFT ) && pm->ps->legsTimer > 500 )
+	{
+		return qtrue;
+	}
+
+	return qfalse;
+}
+
+//begin vehicle functions crudely ported from sp -rww
+/*
+====================================================================
+void pitch_roll_for_slope (edict_t *forwhom, vec3_t *slope, vec3_t storeAngles )
+
+MG
+
+This will adjust the pitch and roll of a monster to match
+a given slope - if a non-'0 0 0' slope is passed, it will
+use that value, otherwise it will use the ground underneath
+the monster.  If it doesn't find a surface, it does nothinh\g
+and returns.
+====================================================================
+*/
+
+void PM_pitch_roll_for_slope( bgEntity_t *forwhom, vec3_t pass_slope, vec3_t storeAngles )
+{
+	vec3_t	slope;
+	vec3_t	nvf, ovf, ovr, startspot, endspot, new_angles = { 0, 0, 0 };
+	float	pitch, mod, dot;
+
+	//if we don't have a slope, get one
+	if( !pass_slope || VectorCompare( vec3_origin, pass_slope ) )
+	{
+		trace_t trace;
+
+		VectorCopy( pm->ps->origin, startspot );
+		startspot[2] += pm->mins[2] + 4;
+		VectorCopy( startspot, endspot );
+		endspot[2] -= 300;
+		pm->trace( &trace, pm->ps->origin, vec3_origin, vec3_origin, endspot, forwhom->s.number, MASK_SOLID );
+//		if(trace_fraction>0.05&&forwhom.movetype==MOVETYPE_STEP)
+//			forwhom.flags(-)FL_ONGROUND;
+
+		if ( trace.fraction >= 1.0 )
+			return;
+
+		if( !( &trace.plane ) )
+			return;
+
+		if ( VectorCompare( vec3_origin, trace.plane.normal ) )
+			return;
+
+		VectorCopy( trace.plane.normal, slope );
+	}
+	else
+	{
+		VectorCopy( pass_slope, slope );
+	}
+
+	if ( forwhom->s.NPC_class == CLASS_VEHICLE )
+	{//special code for vehicles
+		Vehicle_t *pVeh = forwhom->m_pVehicle;
+		vec3_t tempAngles;
+
+		tempAngles[PITCH] = tempAngles[ROLL] = 0;
+		tempAngles[YAW] = pVeh->m_vOrientation[YAW];
+		AngleVectors( tempAngles, ovf, ovr, NULL );
+	}
+	else
+	{
+		AngleVectors( pm->ps->viewangles, ovf, ovr, NULL );
+	}
+
+	vectoangles( slope, new_angles );
+	pitch = new_angles[PITCH] + 90;
+	new_angles[ROLL] = new_angles[PITCH] = 0;
+
+	AngleVectors( new_angles, nvf, NULL, NULL );
+
+	mod = DotProduct( nvf, ovr );
+
+	if ( mod<0 )
+		mod = -1;
+	else
+		mod = 1;
+
+	dot = DotProduct( nvf, ovf );
+
+	if ( storeAngles )
+	{
+		storeAngles[PITCH] = dot * pitch;
+		storeAngles[ROLL] = ((1-Q_fabs(dot)) * pitch * mod);
+	}
+	else //if ( forwhom->client )
+	{
+		float oldmins2;
+
+		pm->ps->viewangles[PITCH] = dot * pitch;
+		pm->ps->viewangles[ROLL] = ((1-Q_fabs(dot)) * pitch * mod);
+		oldmins2 = pm->mins[2];
+		pm->mins[2] = -24 + 12 * fabs(pm->ps->viewangles[PITCH])/180.0f;
+		//FIXME: if it gets bigger, move up
+		if ( oldmins2 > pm->mins[2] )
+		{//our mins is now lower, need to move up
+			//FIXME: trace?
+			pm->ps->origin[2] += (oldmins2 - pm->mins[2]);
+			//forwhom->currentOrigin[2] = forwhom->client->ps.origin[2];
+			//gi.linkentity( forwhom );
+		}
+	}
+	/*
+	else
+	{
+		forwhom->currentAngles[PITCH] = dot * pitch;
+		forwhom->currentAngles[ROLL] = ((1-Q_fabs(dot)) * pitch * mod);
+	}
+	*/
+}
+
+#define		FLY_NONE	0
+#define		FLY_NORMAL	1
+#define		FLY_VEHICLE	2
+#define		FLY_HOVER	3
+static int pm_flying = FLY_NONE;
+
+void PM_SetSpecialMoveValues (void)
+{
+	bgEntity_t *pEnt;
+	
+	if (pm->ps->clientNum < MAX_CLIENTS)
+	{ //we know that real players aren't vehs
+		pm_flying = FLY_NONE;
+		return;
+	}
+
+	//default until we decide otherwise
+	pm_flying = FLY_NONE;
+
+	pEnt = pm_entSelf;
+
+	if ( pEnt )
+	{
+		if ( (pm->ps->eFlags2&EF2_FLYING) )// pm->gent->client->moveType == MT_FLYSWIM )
+		{
+			pm_flying = FLY_NORMAL;
+		}
+		else if ( pEnt->s.NPC_class == CLASS_VEHICLE )
+		{
+			if ( pEnt->m_pVehicle->m_pVehicleInfo->type == VH_FIGHTER )
+			{
+				pm_flying = FLY_VEHICLE;
+			}
+			else if ( pEnt->m_pVehicle->m_pVehicleInfo->hoverHeight > 0 )
+			{
+				pm_flying = FLY_HOVER;
+			}
+		}
+	}
+}
+
+static void PM_SetVehicleAngles( vec3_t normal )
+{
+	bgEntity_t *pEnt = pm_entSelf;
+	Vehicle_t *pVeh;
+	vec3_t	vAngles;
+	float vehicleBankingSpeed;
+	float pitchBias;
+	int i;
+
+	if ( !pEnt || pEnt->s.NPC_class != CLASS_VEHICLE )
+	{
+		return;
+	}
+
+	pVeh = pEnt->m_pVehicle;
+	
+	//float	curVehicleBankingSpeed;
+	vehicleBankingSpeed = (pVeh->m_pVehicleInfo->bankingSpeed*32.0f)*pml.frametime;//0.25f
+
+	if ( vehicleBankingSpeed <= 0 
+		|| ( pVeh->m_pVehicleInfo->pitchLimit == 0 && pVeh->m_pVehicleInfo->rollLimit == 0 ) )
+	{//don't bother, this vehicle doesn't bank
+		return;
+	}
+	//FIXME: do 3 traces to define a plane and use that... smoothes it out some, too...
+	//pitch_roll_for_slope( pm->gent, normal, vAngles );
+	//FIXME: maybe have some pitch control in water and/or air?
+	
+	if ( pVeh->m_pVehicleInfo->type == VH_FIGHTER )
+	{
+		pitchBias = 0.0f;
+	}
+	else
+	{
+		//FIXME: gravity does not matter in SPACE!!!
+		//center of gravity affects pitch in air/water (FIXME: what about roll?)
+		pitchBias = 90.0f*pVeh->m_pVehicleInfo->centerOfGravity[0];//if centerOfGravity is all the way back (-1.0f), vehicle pitches up 90 degrees when in air
+	}
+
+	VectorClear( vAngles );
+	if ( pm->waterlevel > 0 )
+	{//in water
+		//view pitch has some influence when in water
+		//FIXME: take center of gravity into account?
+		vAngles[PITCH] += (pm->ps->viewangles[PITCH]-vAngles[PITCH])*0.75f + (pitchBias*0.5);
+	}
+	else if ( normal )
+	{//have a valid surface below me
+		PM_pitch_roll_for_slope( pEnt, normal, vAngles );
+		if ( (pml.groundTrace.contents&(CONTENTS_WATER|CONTENTS_SLIME|CONTENTS_LAVA)) )
+		{//on water
+			//view pitch has some influence when on a fluid surface
+			//FIXME: take center of gravity into account
+			vAngles[PITCH] += (pm->ps->viewangles[PITCH]-vAngles[PITCH])*0.5f + (pitchBias*0.5f);
+		}
+	}
+	else
+	{//in air, let pitch match view...?
+		//FIXME: take center of gravity into account
+		vAngles[PITCH] = pm->ps->viewangles[PITCH]*0.5f + pitchBias;
+		//don't bank so fast when in the air
+		vehicleBankingSpeed *= (0.125f*pml.frametime);
+	}
+	//NOTE: if angles are flat and we're moving through air (not on ground),
+	//		then pitch/bank?
+	if ( pVeh->m_pVehicleInfo->rollLimit > 0 )
+	{
+		//roll when banking
+		vec3_t	velocity;
+		float	speed;
+		VectorCopy( pm->ps->velocity, velocity );
+		velocity[2] = 0.0f;
+		speed = VectorNormalize( velocity );
+		if ( speed > 32.0f || speed < -32.0f ) 
+		{
+			vec3_t	rt, tempVAngles;
+			float	side;
+			float	dp;
+
+			// Magic number fun!  Speed is used for banking, so modulate the speed by a sine wave
+			//FIXME: this banks too early
+			speed *= sin( (150 + pml.frametime) * 0.003 );
+
+			// Clamp to prevent harsh rolling
+			if ( speed > 60 )
+				speed = 60;
+
+			VectorCopy( pVeh->m_vOrientation, tempVAngles );
+			tempVAngles[ROLL] = 0;
+			AngleVectors( tempVAngles, NULL, rt, NULL );
+			dp = DotProduct( velocity, rt );
+			side = speed * dp;
+			vAngles[ROLL] -= side;
+		}
+	}
+
+	//cap
+	if ( pVeh->m_pVehicleInfo->pitchLimit != -1 )
+	{
+		if ( vAngles[PITCH] > pVeh->m_pVehicleInfo->pitchLimit )
+		{
+			vAngles[PITCH] = pVeh->m_pVehicleInfo->pitchLimit;
+		}
+		else if ( vAngles[PITCH] < -pVeh->m_pVehicleInfo->pitchLimit )
+		{
+			vAngles[PITCH] = -pVeh->m_pVehicleInfo->pitchLimit;
+		}
+	}
+
+	if ( vAngles[ROLL] > pVeh->m_pVehicleInfo->rollLimit )
+	{
+		vAngles[ROLL] = pVeh->m_pVehicleInfo->rollLimit;
+	}
+	else if ( vAngles[ROLL] < -pVeh->m_pVehicleInfo->rollLimit )
+	{
+		vAngles[ROLL] = -pVeh->m_pVehicleInfo->rollLimit;
+	}
+	
+	//do it
+	for ( i = 0; i < 3; i++ )
+	{
+		if ( i == YAW )
+		{//yawing done elsewhere
+			continue;
+		}
+		//bank faster the higher the difference is
+		/*
+		else if ( i == PITCH )
+		{
+			curVehicleBankingSpeed = vehicleBankingSpeed*fabs(AngleNormalize180(AngleSubtract( vAngles[PITCH], pVeh->m_vOrientation[PITCH] )))/(g_vehicleInfo[pm->ps->vehicleIndex].pitchLimit/2.0f);
+		}
+		else if ( i == ROLL )
+		{
+			curVehicleBankingSpeed = vehicleBankingSpeed*fabs(AngleNormalize180(AngleSubtract( vAngles[ROLL], pVeh->m_vOrientation[ROLL] )))/(g_vehicleInfo[pm->ps->vehicleIndex].rollLimit/2.0f);
+		}
+
+		if ( curVehicleBankingSpeed )
+		*/
+		{
+			if ( pVeh->m_vOrientation[i] >= vAngles[i] + vehicleBankingSpeed )
+			{
+				pVeh->m_vOrientation[i] -= vehicleBankingSpeed;
+			}
+			else if ( pVeh->m_vOrientation[i] <= vAngles[i] - vehicleBankingSpeed )
+			{
+				pVeh->m_vOrientation[i] += vehicleBankingSpeed;
+			}
+			else
+			{
+				pVeh->m_vOrientation[i] = vAngles[i];
+			}
+		}
+	}
+}
+
+#ifndef QAGAME
+extern vmCvar_t cg_paused;
+#endif
+
+void BG_ExternThisSoICanRecompileInDebug( Vehicle_t *pVeh, playerState_t *riderPS )
+{
+/*
+	float pitchSubtract, pitchDelta, yawDelta;
+	//Com_Printf( S_COLOR_RED"PITCH: %4.2f, YAW: %4.2f, ROLL: %4.2f\n", riderPS->viewangles[0],riderPS->viewangles[1],riderPS->viewangles[2]);
+	yawDelta = AngleSubtract(riderPS->viewangles[YAW],pVeh->m_vPrevRiderViewAngles[YAW]);
+#ifndef QAGAME
+	if ( !cg_paused.integer )
+	{
+		//Com_Printf( "%d - yawDelta %4.2f\n", pm->cmd.serverTime, yawDelta );
+	}
+#endif
+	yawDelta *= (4.0f*pVeh->m_fTimeModifier);
+	pVeh->m_vOrientation[ROLL] -= yawDelta;
+
+	pitchDelta = AngleSubtract(riderPS->viewangles[PITCH],pVeh->m_vPrevRiderViewAngles[PITCH]);
+	pitchDelta *= (2.0f*pVeh->m_fTimeModifier);
+	pitchSubtract = pitchDelta * (fabs(pVeh->m_vOrientation[ROLL])/90.0f);
+	pVeh->m_vOrientation[PITCH] += pitchDelta-pitchSubtract;
+	if ( pVeh->m_vOrientation[ROLL] > 0 )
+	{
+		pVeh->m_vOrientation[YAW] += pitchSubtract;
+	}
+	else
+	{
+		pVeh->m_vOrientation[YAW] -= pitchSubtract;
+	}
+	pVeh->m_vOrientation[PITCH] = AngleNormalize180( pVeh->m_vOrientation[PITCH] );
+	pVeh->m_vOrientation[YAW] = AngleNormalize360( pVeh->m_vOrientation[YAW] );
+	pVeh->m_vOrientation[ROLL] = AngleNormalize180( pVeh->m_vOrientation[ROLL] );
+
+	VectorCopy( riderPS->viewangles, pVeh->m_vPrevRiderViewAngles );
+*/
+}
+
+void BG_VehicleTurnRateForSpeed( Vehicle_t *pVeh, float speed, float *mPitchOverride, float *mYawOverride )
+{
+	if ( pVeh && pVeh->m_pVehicleInfo )
+	{
+		float speedFrac = 1.0f;
+		if ( pVeh->m_pVehicleInfo->speedDependantTurning )
+		{
+			if ( pVeh->m_LandTrace.fraction >= 1.0f 
+				|| pVeh->m_LandTrace.plane.normal[2] < MIN_LANDING_SLOPE  )
+			{
+				speedFrac = (speed/(pVeh->m_pVehicleInfo->speedMax*0.75f));
+				if ( speedFrac < 0.25f )
+				{
+					speedFrac = 0.25f;
+				}
+				else if ( speedFrac > 1.0f )
+				{
+					speedFrac = 1.0f;
+				}
+			}
+		}
+		if ( pVeh->m_pVehicleInfo->mousePitch )
+		{
+			*mPitchOverride = pVeh->m_pVehicleInfo->mousePitch*speedFrac;
+		}
+		if ( pVeh->m_pVehicleInfo->mouseYaw )
+		{
+			*mYawOverride = pVeh->m_pVehicleInfo->mouseYaw*speedFrac;
+		}
+	}
+}
+
+#include "../namespace_end.h"
+
+// Following couple things don't belong in the DLL namespace!
+#ifdef QAGAME
+typedef struct gentity_s gentity_t;
+gentity_t *G_PlayEffectID(const int fxID, vec3_t org, vec3_t ang);
+#endif
+
+#include "../namespace_begin.h"
+
+static void PM_GroundTraceMissed( void );
+void PM_HoverTrace( void )
+{
+	Vehicle_t *pVeh;
+	float hoverHeight;
+	vec3_t		point, vAng, fxAxis[3];
+	trace_t		*trace;
+	float relativeWaterLevel;
+
+	bgEntity_t *pEnt = pm_entSelf;
+	if ( !pEnt || pEnt->s.NPC_class != CLASS_VEHICLE )
+	{
+		return;
+	}
+
+	pVeh = pEnt->m_pVehicle;
+	hoverHeight = pVeh->m_pVehicleInfo->hoverHeight;
+	trace = &pml.groundTrace;
+
+	pml.groundPlane = qfalse;
+
+	//relativeWaterLevel = (pm->ps->waterheight - (pm->ps->origin[2]+pm->mins[2]));
+	relativeWaterLevel = pm->waterlevel; //I.. guess this works
+	if ( pm->waterlevel && relativeWaterLevel >= 0 )
+	{//in water
+		if ( pVeh->m_pVehicleInfo->bouyancy <= 0.0f )
+		{//sink like a rock
+		}
+		else
+		{//rise up
+			float floatHeight = (pVeh->m_pVehicleInfo->bouyancy * ((pm->maxs[2]-pm->mins[2])*0.5f)) - (hoverHeight*0.5f);//1.0f should make you float half-in, half-out of water
+			if ( relativeWaterLevel > floatHeight )
+			{//too low, should rise up
+				pm->ps->velocity[2] += (relativeWaterLevel - floatHeight) * pVeh->m_fTimeModifier;
+			}
+		}
+		//if ( pm->ps->waterheight < pm->ps->origin[2]+pm->maxs[2] )
+		if (pm->waterlevel <= 1)
+		{//part of us is sticking out of water
+			if ( fabs(pm->ps->velocity[0]) + fabs(pm->ps->velocity[1]) > 100 )
+			{//moving at a decent speed
+				if ( Q_irand( pml.frametime, 100 ) >= 50 )
+				{//splash
+					vec3_t wakeOrg;
+
+					vAng[PITCH] = vAng[ROLL] = 0;
+					vAng[YAW] = pVeh->m_vOrientation[YAW];
+					AngleVectors( vAng, fxAxis[2], fxAxis[1], fxAxis[0] );
+					VectorCopy( pm->ps->origin, wakeOrg );
+					//wakeOrg[2] = pm->ps->waterheight;
+					if (pm->waterlevel >= 2)
+					{
+						wakeOrg[2] = pm->ps->origin[2]+16;
+					}
+					else
+					{
+						wakeOrg[2] = pm->ps->origin[2];
+					}
+#ifdef QAGAME //yeah, this is kind of crappy and makes no use of prediction whatsoever
+					if ( pVeh->m_pVehicleInfo->iWakeFX )
+					{
+						//G_PlayEffectID( pVeh->m_pVehicleInfo->iWakeFX, wakeOrg, fxAxis[0] );
+						//tempent use bad!
+						G_AddEvent((gentity_t *)pEnt, EV_PLAY_EFFECT_ID, pVeh->m_pVehicleInfo->iWakeFX);
+					}
+#endif
+				}
+			}
+		}
+	}
+	else
+	{
+		int traceContents;
+		float minNormal = (float)MIN_WALK_NORMAL;
+		minNormal = pVeh->m_pVehicleInfo->maxSlope;
+
+		point[0] = pm->ps->origin[0];
+		point[1] = pm->ps->origin[1];
+		point[2] = pm->ps->origin[2] - hoverHeight;
+
+		//FIXME: check for water, too?  If over water, go slower and make wave effect
+		//		If *in* water, go really slow and use bouyancy stat to determine how far below surface to float
+
+		//NOTE: if bouyancy is 2.0f or higher, you float over water like it's solid ground.
+		//		if it's 1.0f, you sink halfway into water.  If it's 0, you sink...
+		traceContents = pm->tracemask;
+		if ( pVeh->m_pVehicleInfo->bouyancy >= 2.0f )
+		{//sit on water
+			traceContents |= (CONTENTS_WATER|CONTENTS_SLIME|CONTENTS_LAVA);
+		}
+		pm->trace( trace, pm->ps->origin, pm->mins, pm->maxs, point, pm->ps->clientNum, traceContents );
+		if (trace->plane.normal[0] > 0.5f || trace->plane.normal[0] < -0.5f ||
+			trace->plane.normal[1] > 0.5f || trace->plane.normal[1] < -0.5f)
+		{ //steep slanted hill, don't go up it.
+			float d = fabs(trace->plane.normal[0]);
+			float e = fabs(trace->plane.normal[1]);
+			if (e > d)
+			{
+				d = e;
+			}
+			pm->ps->velocity[2] = -300.0f*d;
+		}
+		else if ( trace->plane.normal[2] >= minNormal ) 
+		{//not a steep slope, so push us up
+			if ( trace->fraction < 1.0f )
+			{//push up off ground
+				float hoverForce = pVeh->m_pVehicleInfo->hoverStrength;
+				if ( trace->fraction > 0.5f )
+				{
+					pm->ps->velocity[2] += (1.0f-trace->fraction)*hoverForce*pVeh->m_fTimeModifier;
+				}
+				else
+				{
+					pm->ps->velocity[2] += (0.5f-(trace->fraction*trace->fraction))*hoverForce*2.0f*pVeh->m_fTimeModifier;
+				}
+				if ( (trace->contents&(CONTENTS_WATER|CONTENTS_SLIME|CONTENTS_LAVA)) )
+				{//hovering on water, make a spash if moving
+					if ( fabs(pm->ps->velocity[0]) + fabs(pm->ps->velocity[1]) > 100 )
+					{//moving at a decent speed
+						if ( Q_irand( pml.frametime, 100 ) >= 50 )
+						{//splash
+							vAng[PITCH] = vAng[ROLL] = 0;
+							vAng[YAW] = pVeh->m_vOrientation[YAW];
+							AngleVectors( vAng, fxAxis[2], fxAxis[1], fxAxis[0] );
+#ifdef QAGAME
+							if ( pVeh->m_pVehicleInfo->iWakeFX )
+							{
+								G_PlayEffectID( pVeh->m_pVehicleInfo->iWakeFX, trace->endpos, fxAxis[0] );
+							}
+#endif
+						}
+					}
+				}
+				pml.groundPlane = qtrue;
+			}
+		}
+	}
+	if ( pml.groundPlane )
+	{
+		PM_SetVehicleAngles( pml.groundTrace.plane.normal );
+		// We're on the ground.
+		pVeh->m_ulFlags &= ~VEH_FLYING;
+
+		pVeh->m_vAngularVelocity = 0.0f;
+	}
+	else
+	{
+		PM_SetVehicleAngles( NULL );
+		// We're flying in the air.
+		pVeh->m_ulFlags |= VEH_FLYING;
+		//groundTrace
+
+		if (pVeh->m_vAngularVelocity==0.0f)
+		{
+			pVeh->m_vAngularVelocity = pVeh->m_vOrientation[YAW] - pVeh->m_vPrevOrientation[YAW];
+			if (pVeh->m_vAngularVelocity<-15.0f)
+			{
+				pVeh->m_vAngularVelocity = -15.0f;
+			}
+			if (pVeh->m_vAngularVelocity> 15.0f)
+			{
+				pVeh->m_vAngularVelocity =  15.0f;
+			}
+		}
+		//pVeh->m_vAngularVelocity *= 0.95f;		// Angular Velocity Decays Over Time
+		if (pVeh->m_vAngularVelocity > 0.0f)
+		{
+			pVeh->m_vAngularVelocity -= pml.frametime;
+			if (pVeh->m_vAngularVelocity < 0.0f)
+			{
+				pVeh->m_vAngularVelocity = 0.0f;
+			}
+		}
+		else if (pVeh->m_vAngularVelocity < 0.0f)
+		{
+			pVeh->m_vAngularVelocity += pml.frametime;
+			if (pVeh->m_vAngularVelocity > 0.0f)
+			{
+				pVeh->m_vAngularVelocity = 0.0f;
+			}
+		}
+	}
+	PM_GroundTraceMissed();
+}
+//end vehicle functions crudely ported from sp -rww
+
+/*
+===============
+PM_AddEvent
+
+===============
+*/
+void PM_AddEvent( int newEvent ) {
+	BG_AddPredictableEventToPlayerstate( newEvent, 0, pm->ps );
+}
+
+void PM_AddEventWithParm( int newEvent, int parm ) 
+{
+	BG_AddPredictableEventToPlayerstate( newEvent, parm, pm->ps );
+}
+
+/*
+===============
+PM_AddTouchEnt
+===============
+*/
+void PM_AddTouchEnt( int entityNum ) {
+	int		i;
+
+	if ( entityNum == ENTITYNUM_WORLD ) {
+		return;
+	}
+	if ( pm->numtouch == MAXTOUCH ) {
+		return;
+	}
+
+	// see if it is already added
+	for ( i = 0 ; i < pm->numtouch ; i++ ) {
+		if ( pm->touchents[ i ] == entityNum ) {
+			return;
+		}
+	}
+
+	// add it
+	pm->touchents[pm->numtouch] = entityNum;
+	pm->numtouch++;
+}
+
+
+/*
+==================
+PM_ClipVelocity
+
+Slide off of the impacting surface
+==================
+*/
+void PM_ClipVelocity( vec3_t in, vec3_t normal, vec3_t out, float overbounce ) {
+	float	backoff;
+	float	change;
+	float	oldInZ;
+	int		i;
+	
+	if ( (pm->ps->pm_flags&PMF_STUCK_TO_WALL) )
+	{//no sliding!
+		VectorCopy( in, out );
+		return;
+	}
+	oldInZ = in[2];
+
+	backoff = DotProduct (in, normal);
+	
+	if ( backoff < 0 ) {
+		backoff *= overbounce;
+	} else {
+		backoff /= overbounce;
+	}
+
+	for ( i=0 ; i<3 ; i++ ) {
+		change = normal[i]*backoff;
+		out[i] = in[i] - change;
+	}
+	if ( pm->stepSlideFix )
+	{
+		if ( pm->ps->clientNum < MAX_CLIENTS//normal player
+			&& pm->ps->groundEntityNum != ENTITYNUM_NONE//on the ground
+			&& normal[2] < MIN_WALK_NORMAL )//sliding against a steep slope
+		{//if walking on the ground, don't slide up slopes that are too steep to walk on
+			out[2] = oldInZ;
+		}
+	}
+}
+
+
+/*
+==================
+PM_Friction
+
+Handles both ground friction and water friction
+==================
+*/
+static void PM_Friction( void ) {
+	vec3_t	vec;
+	float	*vel;
+	float	speed, newspeed, control;
+	float	drop;
+	bgEntity_t *pEnt = NULL;
+	
+	vel = pm->ps->velocity;
+	
+	VectorCopy( vel, vec );
+	if ( pml.walking ) {
+		vec[2] = 0;	// ignore slope movement
+	}
+
+	speed = VectorLength(vec);
+	if (speed < 1) {
+		vel[0] = 0;
+		vel[1] = 0;		// allow sinking underwater
+		if (pm->ps->pm_type == PM_SPECTATOR)
+		{
+			vel[2] = 0;
+		}
+		// FIXME: still have z friction underwater?
+		return;
+	}
+
+	drop = 0;
+
+	if (pm->ps->clientNum >= MAX_CLIENTS)
+	{
+		pEnt = pm_entSelf;
+	}
+
+	// apply ground friction, even if on ladder
+	if (pm_flying != FLY_VEHICLE &&
+		pEnt &&
+		pEnt->s.NPC_class == CLASS_VEHICLE &&
+		pEnt->m_pVehicle &&
+		pEnt->m_pVehicle->m_pVehicleInfo->type != VH_ANIMAL &&
+		pEnt->m_pVehicle->m_pVehicleInfo->type != VH_WALKER &&
+		pEnt->m_pVehicle->m_pVehicleInfo->friction )
+	{
+		float friction = pEnt->m_pVehicle->m_pVehicleInfo->friction;
+		if ( !(pm->ps->pm_flags & PMF_TIME_KNOCKBACK) /*&& !(pm->ps->pm_flags & PMF_TIME_NOFRICTION)*/ ) 
+		{
+			control = speed < pm_stopspeed ? pm_stopspeed : speed;
+			drop += control*friction*pml.frametime;
+			/*
+			if ( Flying == FLY_HOVER )
+			{
+				if ( pm->cmd.rightmove )
+				{//if turning, increase friction
+					control *= 2.0f;
+				}
+				if ( pm->ps->groundEntityNum < ENTITYNUM_NONE ) 
+				{//on the ground
+					drop += control*friction*pml.frametime;
+				}
+				else if ( pml.groundPlane )
+				{//on a slope
+					drop += control*friction*2.0f*pml.frametime;
+				}
+				else
+				{//in air
+					drop += control*2.0f*friction*pml.frametime;
+				}
+			}
+			*/
+		}
+	}
+	else if ( pm_flying != FLY_NORMAL && pm_flying != FLY_VEHICLE )
+	{
+		// apply ground friction
+		if ( pm->waterlevel <= 1 ) {
+			if ( pml.walking && !(pml.groundTrace.surfaceFlags & SURF_SLICK) ) {
+				// if getting knocked back, no friction
+				if ( ! (pm->ps->pm_flags & PMF_TIME_KNOCKBACK) ) {
+					control = speed < pm_stopspeed ? pm_stopspeed : speed;
+					drop += control*pm_friction*pml.frametime;
+				}
+			}
+		}
+	}
+
+	if ( pm_flying == FLY_VEHICLE )
+	{
+		if ( !(pm->ps->pm_flags & PMF_TIME_KNOCKBACK) ) 
+		{
+			control = speed;// < pm_stopspeed ? pm_stopspeed : speed;
+			drop += control*pm_friction*pml.frametime;
+		}
+	}
+
+	// apply water friction even if just wading
+	if ( pm->waterlevel ) {
+		drop += speed*pm_waterfriction*pm->waterlevel*pml.frametime;
+	}
+	// If on a client then there is no friction
+	else if ( pm->ps->groundEntityNum < MAX_CLIENTS )
+	{
+		drop = 0;
+	}
+
+	if ( pm->ps->pm_type == PM_SPECTATOR || pm->ps->pm_type == PM_FLOAT )
+	{
+		if (pm->ps->pm_type == PM_FLOAT)
+		{ //almost no friction while floating
+			drop += speed*0.1*pml.frametime;
+		}
+		else
+		{
+			drop += speed*pm_spectatorfriction*pml.frametime;
+		}
+	}
+
+	// scale the velocity
+	newspeed = speed - drop;
+	if (newspeed < 0) {
+		newspeed = 0;
+	}
+	newspeed /= speed;
+
+	vel[0] = vel[0] * newspeed;
+	vel[1] = vel[1] * newspeed;
+	vel[2] = vel[2] * newspeed;
+}
+
+
+/*
+==============
+PM_Accelerate
+
+Handles user intended acceleration
+==============
+*/
+static void PM_Accelerate( vec3_t wishdir, float wishspeed, float accel )
+{
+	if (pm->gametype != GT_SIEGE 
+		|| pm->ps->m_iVehicleNum 
+		|| pm->ps->clientNum >= MAX_CLIENTS 
+		|| pm->ps->pm_type != PM_NORMAL)
+	{ //standard method, allows "bunnyhopping" and whatnot
+		int			i;
+		float		addspeed, accelspeed, currentspeed;
+
+		currentspeed = DotProduct (pm->ps->velocity, wishdir);
+		addspeed = wishspeed - currentspeed;
+		if (addspeed <= 0 && pm->ps->clientNum < MAX_CLIENTS) {
+			return;
+		}
+
+		if (addspeed < 0)
+		{
+			accelspeed = (-accel)*pml.frametime*wishspeed;
+			if (accelspeed < addspeed) {
+				accelspeed = addspeed;
+			}
+		}
+		else
+		{
+			accelspeed = accel*pml.frametime*wishspeed;
+			if (accelspeed > addspeed) {
+				accelspeed = addspeed;
+			}
+		}
+
+		for (i=0 ; i<3 ; i++) {
+			pm->ps->velocity[i] += accelspeed*wishdir[i];	
+		}
+	}
+	else
+	{ //use the proper way for siege
+		vec3_t		wishVelocity;
+		vec3_t		pushDir;
+		float		pushLen;
+		float		canPush;
+
+		VectorScale( wishdir, wishspeed, wishVelocity );
+		VectorSubtract( wishVelocity, pm->ps->velocity, pushDir );
+		pushLen = VectorNormalize( pushDir );
+
+		canPush = accel*pml.frametime*wishspeed;
+		if (canPush > pushLen) {
+			canPush = pushLen;
+		}
+
+		VectorMA( pm->ps->velocity, canPush, pushDir, pm->ps->velocity );
+	}
+}
+
+
+
+/*
+============
+PM_CmdScale
+
+Returns the scale factor to apply to cmd movements
+This allows the clients to use axial -127 to 127 values for all directions
+without getting a sqrt(2) distortion in speed.
+============
+*/
+static float PM_CmdScale( usercmd_t *cmd ) {
+	int		max;
+	float	total;
+	float	scale;
+	int		umove = 0; //cmd->upmove;
+			//don't factor upmove into scaling speed
+
+	max = abs( cmd->forwardmove );
+	if ( abs( cmd->rightmove ) > max ) {
+		max = abs( cmd->rightmove );
+	}
+	if ( abs( umove ) > max ) {
+		max = abs( umove );
+	}
+	if ( !max ) {
+		return 0;
+	}
+
+	total = sqrt( (float)(cmd->forwardmove * cmd->forwardmove
+		+ cmd->rightmove * cmd->rightmove + umove * umove) );
+	scale = (float)pm->ps->speed * max / ( 127.0 * total );
+
+	return scale;
+}
+
+
+/*
+================
+PM_SetMovementDir
+
+Determine the rotation of the legs reletive
+to the facing dir
+================
+*/
+static void PM_SetMovementDir( void ) {
+	if ( pm->cmd.forwardmove || pm->cmd.rightmove ) {
+		if ( pm->cmd.rightmove == 0 && pm->cmd.forwardmove > 0 ) {
+			pm->ps->movementDir = 0;
+		} else if ( pm->cmd.rightmove < 0 && pm->cmd.forwardmove > 0 ) {
+			pm->ps->movementDir = 1;
+		} else if ( pm->cmd.rightmove < 0 && pm->cmd.forwardmove == 0 ) {
+			pm->ps->movementDir = 2;
+		} else if ( pm->cmd.rightmove < 0 && pm->cmd.forwardmove < 0 ) {
+			pm->ps->movementDir = 3;
+		} else if ( pm->cmd.rightmove == 0 && pm->cmd.forwardmove < 0 ) {
+			pm->ps->movementDir = 4;
+		} else if ( pm->cmd.rightmove > 0 && pm->cmd.forwardmove < 0 ) {
+			pm->ps->movementDir = 5;
+		} else if ( pm->cmd.rightmove > 0 && pm->cmd.forwardmove == 0 ) {
+			pm->ps->movementDir = 6;
+		} else if ( pm->cmd.rightmove > 0 && pm->cmd.forwardmove > 0 ) {
+			pm->ps->movementDir = 7;
+		}
+	} else {
+		// if they aren't actively going directly sideways,
+		// change the animation to the diagonal so they
+		// don't stop too crooked
+		if ( pm->ps->movementDir == 2 ) {
+			pm->ps->movementDir = 1;
+		} else if ( pm->ps->movementDir == 6 ) {
+			pm->ps->movementDir = 7;
+		} 
+	}
+}
+
+#define METROID_JUMP 1
+
+qboolean PM_ForceJumpingUp(void)
+{
+	if ( !(pm->ps->fd.forcePowersActive&(1<<FP_LEVITATION)) && pm->ps->fd.forceJumpCharge )
+	{//already jumped and let go
+		return qfalse;
+	}
+
+	if ( BG_InSpecialJump( pm->ps->legsAnim ) )
+	{
+		return qfalse;
+	}
+
+	if (BG_SaberInSpecial(pm->ps->saberMove))
+	{
+		return qfalse;
+	}
+
+	if (BG_SaberInSpecialAttack(pm->ps->legsAnim))
+	{
+		return qfalse;
+	}
+
+	if (BG_HasYsalamiri(pm->gametype, pm->ps))
+	{
+		return qfalse;
+	}
+
+	if (!BG_CanUseFPNow(pm->gametype, pm->ps, pm->cmd.serverTime, FP_LEVITATION))
+	{
+		return qfalse;
+	}
+
+	if ( pm->ps->groundEntityNum == ENTITYNUM_NONE && //in air
+		(pm->ps->pm_flags & PMF_JUMP_HELD) && //jumped
+		pm->ps->fd.forcePowerLevel[FP_LEVITATION] > FORCE_LEVEL_0 && //force-jump capable
+		pm->ps->velocity[2] > 0 )//going up
+	{
+		return qtrue;
+	}
+	return qfalse;
+}
+
+static void PM_JumpForDir( void )
+{
+	int anim = BOTH_JUMP1;
+	if ( pm->cmd.forwardmove > 0 ) 
+	{
+		anim = BOTH_JUMP1;
+		pm->ps->pm_flags &= ~PMF_BACKWARDS_JUMP;
+	} 
+	else if ( pm->cmd.forwardmove < 0 )
+	{
+		anim = BOTH_JUMPBACK1;
+		pm->ps->pm_flags |= PMF_BACKWARDS_JUMP;
+	}
+	else if ( pm->cmd.rightmove > 0 ) 
+	{
+		anim = BOTH_JUMPRIGHT1;
+		pm->ps->pm_flags &= ~PMF_BACKWARDS_JUMP;
+	}
+	else if ( pm->cmd.rightmove < 0 ) 
+	{
+		anim = BOTH_JUMPLEFT1;
+		pm->ps->pm_flags &= ~PMF_BACKWARDS_JUMP;
+	}
+	else
+	{
+		anim = BOTH_JUMP1;
+		pm->ps->pm_flags &= ~PMF_BACKWARDS_JUMP;
+	}
+	if(!BG_InDeathAnim(pm->ps->legsAnim))
+	{
+		PM_SetAnim(SETANIM_LEGS,anim,SETANIM_FLAG_OVERRIDE, 100);
+	}
+}
+
+void PM_SetPMViewAngle(playerState_t *ps, vec3_t angle, usercmd_t *ucmd)
+{
+	int			i;
+
+	for (i=0 ; i<3 ; i++)
+	{ // set the delta angle
+		int		cmdAngle;
+
+		cmdAngle = ANGLE2SHORT(angle[i]);
+		ps->delta_angles[i] = cmdAngle - ucmd->angles[i];
+	}
+	VectorCopy (angle, ps->viewangles);
+}
+
+qboolean PM_AdjustAngleForWallRun( playerState_t *ps, usercmd_t *ucmd, qboolean doMove )
+{
+	if (( (ps->legsAnim) == BOTH_WALL_RUN_RIGHT || (ps->legsAnim) == BOTH_WALL_RUN_LEFT ) && ps->legsTimer > 500 )
+	{//wall-running and not at end of anim
+		//stick to wall, if there is one
+		vec3_t	fwd, rt, traceTo, mins, maxs, fwdAngles;
+		trace_t	trace;
+		float	dist, yawAdjust;
+
+		VectorSet(mins, -15, -15, 0);
+		VectorSet(maxs, 15, 15, 24);
+		VectorSet(fwdAngles, 0, pm->ps->viewangles[YAW], 0);
+
+		AngleVectors( fwdAngles, fwd, rt, NULL );
+		if ( (ps->legsAnim) == BOTH_WALL_RUN_RIGHT )
+		{
+			dist = 128;
+			yawAdjust = -90;
+		}
+		else
+		{
+			dist = -128;
+			yawAdjust = 90;
+		}
+		VectorMA( ps->origin, dist, rt, traceTo );
+		
+		pm->trace( &trace, ps->origin, mins, maxs, traceTo, ps->clientNum, MASK_PLAYERSOLID );
+
+		if ( trace.fraction < 1.0f 
+			&& (trace.plane.normal[2] >= 0.0f && trace.plane.normal[2] <= 0.4f) )//&& ent->client->ps.groundEntityNum == ENTITYNUM_NONE )
+		{
+			trace_t	trace2;
+			vec3_t traceTo2;
+			vec3_t	wallRunFwd, wallRunAngles;
+			
+			VectorClear( wallRunAngles );
+			wallRunAngles[YAW] = vectoyaw( trace.plane.normal )+yawAdjust;
+			AngleVectors( wallRunAngles, wallRunFwd, NULL, NULL );
+
+			VectorMA( pm->ps->origin, 32, wallRunFwd, traceTo2 );
+			pm->trace( &trace2, pm->ps->origin, mins, maxs, traceTo2, pm->ps->clientNum, MASK_PLAYERSOLID );
+			if ( trace2.fraction < 1.0f && DotProduct( trace2.plane.normal, wallRunFwd ) <= -0.999f )
+			{//wall we can't run on in front of us
+				trace.fraction = 1.0f;//just a way to get it to kick us off the wall below
+			}
+		} 
+
+		if ( trace.fraction < 1.0f 
+			&& (trace.plane.normal[2] >= 0.0f&&trace.plane.normal[2] <= 0.4f/*MAX_WALL_RUN_Z_NORMAL*/) )
+		{//still a wall there
+			if ( (ps->legsAnim) == BOTH_WALL_RUN_RIGHT )
+			{
+				ucmd->rightmove = 127;
+			}
+			else
+			{
+				ucmd->rightmove = -127;
+			}
+			if ( ucmd->upmove < 0 )
+			{
+				ucmd->upmove = 0;
+			}
+			//make me face perpendicular to the wall
+			ps->viewangles[YAW] = vectoyaw( trace.plane.normal )+yawAdjust;
+
+			PM_SetPMViewAngle(ps, ps->viewangles, ucmd);
+
+			ucmd->angles[YAW] = ANGLE2SHORT( ps->viewangles[YAW] ) - ps->delta_angles[YAW];
+			if ( doMove )
+			{
+				//push me forward
+				float	zVel = ps->velocity[2];
+				if ( ps->legsTimer > 500 )
+				{//not at end of anim yet
+					float speed = 175;
+					if ( ucmd->forwardmove < 0 )
+					{//slower
+						speed = 100;
+					}
+					else if ( ucmd->forwardmove > 0 )
+					{
+						speed = 250;//running speed
+					}
+					VectorScale( fwd, speed, ps->velocity );
+				}
+				ps->velocity[2] = zVel;//preserve z velocity
+				//pull me toward the wall, too
+				VectorMA( ps->velocity, dist, rt, ps->velocity );
+			}
+			ucmd->forwardmove = 0;
+			return qtrue;
+		}
+		else if ( doMove )
+		{//stop it
+			if ( (ps->legsAnim) == BOTH_WALL_RUN_RIGHT )
+			{
+				PM_SetAnim(SETANIM_BOTH, BOTH_WALL_RUN_RIGHT_STOP, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD, 0);
+			}
+			else if ( (ps->legsAnim) == BOTH_WALL_RUN_LEFT )
+			{
+				PM_SetAnim(SETANIM_BOTH, BOTH_WALL_RUN_LEFT_STOP, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD, 0);
+			}
+		}
+	}
+
+	return qfalse;
+}
+
+qboolean PM_AdjustAnglesForWallRunUpFlipAlt( usercmd_t *ucmd )
+{
+//	ucmd->angles[PITCH] = ANGLE2SHORT( pm->ps->viewangles[PITCH] ) - pm->ps->delta_angles[PITCH];
+//	ucmd->angles[YAW] = ANGLE2SHORT( pm->ps->viewangles[YAW] ) - pm->ps->delta_angles[YAW];
+	PM_SetPMViewAngle(pm->ps, pm->ps->viewangles, ucmd);
+	return qtrue;
+}
+
+qboolean PM_AdjustAngleForWallRunUp( playerState_t *ps, usercmd_t *ucmd, qboolean doMove )
+{
+	if ( ps->legsAnim == BOTH_FORCEWALLRUNFLIP_START )
+	{//wall-running up
+		//stick to wall, if there is one
+		vec3_t	fwd, traceTo, mins, maxs, fwdAngles;
+		trace_t	trace;
+		float	dist = 128;
+
+		VectorSet(mins, -15,-15,0);
+		VectorSet(maxs, 15,15,24);
+		VectorSet(fwdAngles, 0, pm->ps->viewangles[YAW], 0);
+
+		AngleVectors( fwdAngles, fwd, NULL, NULL );
+		VectorMA( ps->origin, dist, fwd, traceTo );
+		pm->trace( &trace, ps->origin, mins, maxs, traceTo, ps->clientNum, MASK_PLAYERSOLID );
+		if ( trace.fraction > 0.5f )
+		{//hmm, some room, see if there's a floor right here
+			trace_t	trace2;
+			vec3_t	top, bottom;
+
+			VectorCopy( trace.endpos, top );
+			top[2] += (pm->mins[2]*-1) + 4.0f;
+			VectorCopy( top, bottom );
+			bottom[2] -= 64.0f;
+			pm->trace( &trace2, top, pm->mins, pm->maxs, bottom, ps->clientNum, MASK_PLAYERSOLID );
+			if ( !trace2.allsolid 
+				&& !trace2.startsolid 
+				&& trace2.fraction < 1.0f 
+				&& trace2.plane.normal[2] > 0.7f )//slope we can stand on
+			{//cool, do the alt-flip and land on whetever it is we just scaled up
+				VectorScale( fwd, 100, pm->ps->velocity );
+				pm->ps->velocity[2] += 400;
+				PM_SetAnim(SETANIM_BOTH, BOTH_FORCEWALLRUNFLIP_ALT, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD, 0);
+				pm->ps->pm_flags |= PMF_JUMP_HELD;
+				//ent->client->ps.pm_flags |= PMF_JUMPING|PMF_SLOW_MO_FALL;
+				//ent->client->ps.forcePowersActive |= (1<<FP_LEVITATION);
+				//G_AddEvent( ent, EV_JUMP, 0 );
+				PM_AddEvent(EV_JUMP);
+				ucmd->upmove = 0;
+				return qfalse;
+			}
+		}
+
+		if ( //ucmd->upmove <= 0 && 
+			ps->legsTimer > 0 &&
+			ucmd->forwardmove > 0 &&
+			trace.fraction < 1.0f && 
+			(trace.plane.normal[2] >= 0.0f&&trace.plane.normal[2]<=0.4f/*MAX_WALL_RUN_Z_NORMAL*/) )
+		{//still a vertical wall there
+			//make sure there's not a ceiling above us!
+			trace_t	trace2;
+			VectorCopy( ps->origin, traceTo );
+			traceTo[2] += 64;
+			pm->trace( &trace2, ps->origin, mins, maxs, traceTo, ps->clientNum, MASK_PLAYERSOLID );
+			if ( trace2.fraction < 1.0f )
+			{//will hit a ceiling, so force jump-off right now
+				//NOTE: hits any entity or clip brush in the way, too, not just architecture!
+			}
+			else
+			{//all clear, keep going
+				//FIXME: don't pull around 90 turns
+				//FIXME: simulate stepping up steps here, somehow?
+				ucmd->forwardmove = 127;
+				if ( ucmd->upmove < 0 )
+				{
+					ucmd->upmove = 0;
+				}
+				//make me face the wall
+				ps->viewangles[YAW] = vectoyaw( trace.plane.normal )+180;
+				PM_SetPMViewAngle(ps, ps->viewangles, ucmd);
+				/*
+				if ( ent->client->ps.viewEntity <= 0 || ent->client->ps.viewEntity >= ENTITYNUM_WORLD )
+				{//don't clamp angles when looking through a viewEntity
+					SetClientViewAngle( ent, ent->client->ps.viewangles );
+				}
+				*/
+				ucmd->angles[YAW] = ANGLE2SHORT( ps->viewangles[YAW] ) - ps->delta_angles[YAW];
+				//if ( ent->s.number || !player_locked )
+				if (1) //aslkfhsakf
+				{
+					if ( doMove )
+					{
+						//pull me toward the wall
+						VectorScale( trace.plane.normal, -dist*trace.fraction, ps->velocity );
+						//push me up
+						if ( ps->legsTimer > 200 )
+						{//not at end of anim yet
+							float speed = 300;
+							/*
+							if ( ucmd->forwardmove < 0 )
+							{//slower
+								speed = 100;
+							}
+							else if ( ucmd->forwardmove > 0 )
+							{
+								speed = 250;//running speed
+							}
+							*/
+							ps->velocity[2] = speed;//preserve z velocity
+						}
+					}
+				}
+				ucmd->forwardmove = 0;
+				return qtrue;
+			}
+		}
+		//failed!
+		if ( doMove )
+		{//stop it
+			VectorScale( fwd, -300.0f, ps->velocity );
+			ps->velocity[2] += 200;
+			//NPC_SetAnim( ent, SETANIM_BOTH, BOTH_FORCEWALLRUNFLIP_END, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+			//why?!?#?#@!%$R@$KR#F:Hdl;asfm
+			PM_SetAnim(SETANIM_BOTH, BOTH_FORCEWALLRUNFLIP_END, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD, 0);
+			ps->pm_flags |= PMF_JUMP_HELD;
+			//ent->client->ps.pm_flags |= PMF_JUMPING|PMF_SLOW_MO_FALL;
+
+			//FIXME do I need this in mp?
+			//ent->client->ps.forcePowersActive |= (1<<FP_LEVITATION);
+			PM_AddEvent(EV_JUMP);
+			ucmd->upmove = 0;
+			//return qtrue;
+		}
+	}
+	return qfalse;
+}
+
+#define	JUMP_OFF_WALL_SPEED	200.0f
+//nice...
+static float BG_ForceWallJumpStrength( void )
+{
+	return (forceJumpStrength[FORCE_LEVEL_3]/2.5f);
+}
+
+qboolean PM_AdjustAngleForWallJump( playerState_t *ps, usercmd_t *ucmd, qboolean doMove )
+{
+	if ( ( ( BG_InReboundJump( ps->legsAnim ) || BG_InReboundHold( ps->legsAnim ) )
+			&& ( BG_InReboundJump( ps->torsoAnim ) || BG_InReboundHold( ps->torsoAnim ) ) )
+		|| (pm->ps->pm_flags&PMF_STUCK_TO_WALL) )
+	{//hugging wall, getting ready to jump off
+		//stick to wall, if there is one
+		vec3_t	checkDir, traceTo, mins, maxs, fwdAngles;
+		trace_t	trace;
+		float	dist = 128.0f, yawAdjust;
+
+		VectorSet(mins, pm->mins[0],pm->mins[1],0);
+		VectorSet(maxs, pm->maxs[0],pm->maxs[1],24);
+		VectorSet(fwdAngles, 0, pm->ps->viewangles[YAW], 0);
+
+		switch ( ps->legsAnim )
+		{
+		case BOTH_FORCEWALLREBOUND_RIGHT:
+		case BOTH_FORCEWALLHOLD_RIGHT:
+			AngleVectors( fwdAngles, NULL, checkDir, NULL );
+			yawAdjust = -90;
+			break;
+		case BOTH_FORCEWALLREBOUND_LEFT:
+		case BOTH_FORCEWALLHOLD_LEFT:
+			AngleVectors( fwdAngles, NULL, checkDir, NULL );
+			VectorScale( checkDir, -1, checkDir );
+			yawAdjust = 90;
+			break;
+		case BOTH_FORCEWALLREBOUND_FORWARD:
+		case BOTH_FORCEWALLHOLD_FORWARD:
+			AngleVectors( fwdAngles, checkDir, NULL, NULL );
+			yawAdjust = 180;
+			break;
+		case BOTH_FORCEWALLREBOUND_BACK:
+		case BOTH_FORCEWALLHOLD_BACK:
+			AngleVectors( fwdAngles, checkDir, NULL, NULL );
+			VectorScale( checkDir, -1, checkDir );
+			yawAdjust = 0;
+			break;
+		default:
+			//WTF???
+			pm->ps->pm_flags &= ~PMF_STUCK_TO_WALL;
+			return qfalse;
+			break;
+		}
+		if ( pm->debugMelee )
+		{//uber-skillz
+			if ( ucmd->upmove > 0 )
+			{//hold on until you let go manually
+				if ( BG_InReboundHold( ps->legsAnim ) )
+				{//keep holding
+					if ( ps->legsTimer < 150 )
+					{
+						ps->legsTimer = 150;
+					}
+				}
+				else
+				{//if got to hold part of anim, play hold anim
+					if ( ps->legsTimer <= 300 )
+					{
+						ps->saberHolstered = 2;
+						PM_SetAnim( SETANIM_BOTH, BOTH_FORCEWALLRELEASE_FORWARD+(ps->legsAnim-BOTH_FORCEWALLHOLD_FORWARD), SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD, 0 );
+						ps->legsTimer = ps->torsoTimer = 150;
+					}
+				}
+			}
+		}
+		VectorMA( ps->origin, dist, checkDir, traceTo );
+		pm->trace( &trace, ps->origin, mins, maxs, traceTo, ps->clientNum, MASK_PLAYERSOLID );
+		if ( //ucmd->upmove <= 0 && 
+			ps->legsTimer > 100 &&
+			trace.fraction < 1.0f && 
+			fabs(trace.plane.normal[2]) <= 0.2f/*MAX_WALL_GRAB_SLOPE*/ )
+		{//still a vertical wall there
+			//FIXME: don't pull around 90 turns
+			/*
+			if ( ent->s.number || !player_locked )
+			{
+				ucmd->forwardmove = 127;
+			}
+			*/
+			if ( ucmd->upmove < 0 )
+			{
+				ucmd->upmove = 0;
+			}
+			//align me to the wall
+			ps->viewangles[YAW] = vectoyaw( trace.plane.normal )+yawAdjust;
+			PM_SetPMViewAngle(ps, ps->viewangles, ucmd);
+			/*
+			if ( ent->client->ps.viewEntity <= 0 || ent->client->ps.viewEntity >= ENTITYNUM_WORLD )
+			{//don't clamp angles when looking through a viewEntity
+				SetClientViewAngle( ent, ent->client->ps.viewangles );
+			}
+			*/
+			ucmd->angles[YAW] = ANGLE2SHORT( ps->viewangles[YAW] ) - ps->delta_angles[YAW];
+			//if ( ent->s.number || !player_locked )
+			if (1)
+			{
+				if ( doMove )
+				{
+					//pull me toward the wall
+					VectorScale( trace.plane.normal, -128.0f, ps->velocity );
+				}
+			}
+			ucmd->upmove = 0;
+			ps->pm_flags |= PMF_STUCK_TO_WALL;
+			return qtrue;
+		}
+		else if ( doMove 
+			&& (ps->pm_flags&PMF_STUCK_TO_WALL))
+		{//jump off
+			//push off of it!
+			ps->pm_flags &= ~PMF_STUCK_TO_WALL;
+			ps->velocity[0] = ps->velocity[1] = 0;
+			VectorScale( checkDir, -JUMP_OFF_WALL_SPEED, ps->velocity );
+			ps->velocity[2] = BG_ForceWallJumpStrength();
+			ps->pm_flags |= PMF_JUMP_HELD;//PMF_JUMPING|PMF_JUMP_HELD;
+			//G_SoundOnEnt( ent, CHAN_BODY, "sound/weapons/force/jump.wav" );
+			ps->fd.forceJumpSound = 1; //this is a stupid thing, i should fix it.
+			//ent->client->ps.forcePowersActive |= (1<<FP_LEVITATION);
+			if (ps->origin[2] < ps->fd.forceJumpZStart)
+			{
+				ps->fd.forceJumpZStart = ps->origin[2];
+			}
+			//FIXME do I need this?
+
+			BG_ForcePowerDrain( ps, FP_LEVITATION, 10 );
+			//no control for half a second
+			ps->pm_flags |= PMF_TIME_KNOCKBACK;
+			ps->pm_time = 500;
+			ucmd->forwardmove = 0;
+			ucmd->rightmove = 0;
+			ucmd->upmove = 127;
+
+			if ( BG_InReboundHold( ps->legsAnim ) )
+			{//if was in hold pose, release now
+				PM_SetAnim( SETANIM_BOTH, BOTH_FORCEWALLRELEASE_FORWARD+(ps->legsAnim-BOTH_FORCEWALLHOLD_FORWARD), SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD, 0 );
+			}
+			else
+			{
+				//PM_JumpForDir();
+				PM_SetAnim(SETANIM_LEGS,BOTH_FORCEJUMP1,SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD|SETANIM_FLAG_RESTART, 0);
+			}
+
+			//return qtrue;
+		}
+	}
+	ps->pm_flags &= ~PMF_STUCK_TO_WALL;
+	return qfalse;
+}
+
+//Set the height for when a force jump was started. If it's 0, nuge it up (slight hack to prevent holding jump over slopes)
+void PM_SetForceJumpZStart(float value)
+{
+	pm->ps->fd.forceJumpZStart = value;
+	if (!pm->ps->fd.forceJumpZStart)
+	{
+		pm->ps->fd.forceJumpZStart -= 0.1;
+	}
+}
+
+float forceJumpHeightMax[NUM_FORCE_POWER_LEVELS] = 
+{
+	66,//normal jump (32+stepheight(18)+crouchdiff(24) = 74)
+	130,//(96+stepheight(18)+crouchdiff(24) = 138)
+	226,//(192+stepheight(18)+crouchdiff(24) = 234)
+	418//(384+stepheight(18)+crouchdiff(24) = 426)
+};
+
+void PM_GrabWallForJump( int anim )
+{//NOTE!!! assumes an appropriate anim is being passed in!!!
+	PM_SetAnim( SETANIM_BOTH, anim, SETANIM_FLAG_RESTART|SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD, 0 );
+	PM_AddEvent( EV_JUMP );//make sound for grab
+	pm->ps->pm_flags |= PMF_STUCK_TO_WALL;
+}
+
+/*
+=============
+PM_CheckJump
+=============
+*/
+static qboolean PM_CheckJump( void ) 
+{
+	if (pm->ps->clientNum >= MAX_CLIENTS)
+	{
+		bgEntity_t *pEnt = pm_entSelf;
+
+		if (pEnt->s.eType == ET_NPC &&
+			pEnt->s.NPC_class == CLASS_VEHICLE)
+		{ //no!
+			return qfalse;
+		}
+	}
+
+	if (pm->ps->forceHandExtend == HANDEXTEND_KNOCKDOWN ||
+		pm->ps->forceHandExtend == HANDEXTEND_PRETHROWN ||
+		pm->ps->forceHandExtend == HANDEXTEND_POSTTHROWN)
+	{
+		return qfalse;
+	}
+
+	if (pm->ps->pm_type == PM_JETPACK)
+	{ //there's no actual jumping while we jetpack
+		return qfalse;
+	}
+
+	//Don't allow jump until all buttons are up
+	if ( pm->ps->pm_flags & PMF_RESPAWNED ) {
+		return qfalse;		
+	}
+
+	if ( PM_InKnockDown( pm->ps ) || BG_InRoll( pm->ps, pm->ps->legsAnim ) ) 
+	{//in knockdown
+		return qfalse;		
+	}
+
+	if (pm->ps->groundEntityNum != ENTITYNUM_NONE || pm->ps->origin[2] < pm->ps->fd.forceJumpZStart)
+	{
+		pm->ps->fd.forcePowersActive &= ~(1<<FP_LEVITATION);
+	}
+
+	if (pm->ps->fd.forcePowersActive & (1 << FP_LEVITATION))
+	{ //Force jump is already active.. continue draining power appropriately until we land.
+		if (pm->ps->fd.forcePowerDebounce[FP_LEVITATION] < pm->cmd.serverTime)
+		{
+			if ( pm->gametype == GT_DUEL 
+				|| pm->gametype == GT_POWERDUEL )
+			{//jump takes less power
+				BG_ForcePowerDrain( pm->ps, FP_LEVITATION, 1 );
+			}
+			else
+			{
+				BG_ForcePowerDrain( pm->ps, FP_LEVITATION, 5 );
+			}
+			if (pm->ps->fd.forcePowerLevel[FP_LEVITATION] >= FORCE_LEVEL_2)
+			{
+				pm->ps->fd.forcePowerDebounce[FP_LEVITATION] = pm->cmd.serverTime + 300;
+			}
+			else
+			{
+				pm->ps->fd.forcePowerDebounce[FP_LEVITATION] = pm->cmd.serverTime + 200;
+			}
+		}
+	}
+
+	if (pm->ps->forceJumpFlip)
+	{ //Forced jump anim
+		int anim = BOTH_FORCEINAIR1;
+		int	parts = SETANIM_BOTH;
+
+		if ( pm->cmd.forwardmove > 0 )
+		{
+			anim = BOTH_FLIP_F;
+		}
+		else if ( pm->cmd.forwardmove < 0 )
+		{
+			anim = BOTH_FLIP_B;
+		}
+		else if ( pm->cmd.rightmove > 0 )
+		{
+			anim = BOTH_FLIP_R;
+		}
+		else if ( pm->cmd.rightmove < 0 )
+		{
+			anim = BOTH_FLIP_L;
+		}
+		if ( pm->ps->weaponTime )
+		{//FIXME: really only care if we're in a saber attack anim...
+			parts = SETANIM_LEGS;
+		}
+
+		PM_SetAnim( parts, anim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD, 150 );
+		pm->ps->forceJumpFlip = qfalse;
+		return qtrue;
+	}
+#if METROID_JUMP
+	if ( pm->waterlevel < 2 ) 
+	{
+		if ( pm->ps->gravity > 0 )
+		{//can't do this in zero-G
+			if ( PM_ForceJumpingUp() )
+			{//holding jump in air
+				float curHeight = pm->ps->origin[2] - pm->ps->fd.forceJumpZStart;
+				//check for max force jump level and cap off & cut z vel
+				if ( ( curHeight<=forceJumpHeight[0] ||//still below minimum jump height
+						(pm->ps->fd.forcePower&&pm->cmd.upmove>=10) ) &&////still have force power available and still trying to jump up 
+					curHeight < forceJumpHeight[pm->ps->fd.forcePowerLevel[FP_LEVITATION]] &&
+					pm->ps->fd.forceJumpZStart)//still below maximum jump height
+				{//can still go up
+					if ( curHeight > forceJumpHeight[0] )
+					{//passed normal jump height  *2?
+						if ( !(pm->ps->fd.forcePowersActive&(1<<FP_LEVITATION)) )//haven't started forcejump yet
+						{
+							//start force jump
+							pm->ps->fd.forcePowersActive |= (1<<FP_LEVITATION);
+							pm->ps->fd.forceJumpSound = 1;
+							//play flip
+							if ((pm->cmd.forwardmove || pm->cmd.rightmove) && //pushing in a dir
+								(pm->ps->legsAnim) != BOTH_FLIP_F &&//not already flipping
+								(pm->ps->legsAnim) != BOTH_FLIP_B &&
+								(pm->ps->legsAnim) != BOTH_FLIP_R &&
+								(pm->ps->legsAnim) != BOTH_FLIP_L )
+							{ 
+								int anim = BOTH_FORCEINAIR1;
+								int	parts = SETANIM_BOTH;
+
+								if ( pm->cmd.forwardmove > 0 )
+								{
+									anim = BOTH_FLIP_F;
+								}
+								else if ( pm->cmd.forwardmove < 0 )
+								{
+									anim = BOTH_FLIP_B;
+								}
+								else if ( pm->cmd.rightmove > 0 )
+								{
+									anim = BOTH_FLIP_R;
+								}
+								else if ( pm->cmd.rightmove < 0 )
+								{
+									anim = BOTH_FLIP_L;
+								}
+								if ( pm->ps->weaponTime )
+								{
+									parts = SETANIM_LEGS;
+								}
+
+								PM_SetAnim( parts, anim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD, 150 );
+							}
+							else if ( pm->ps->fd.forcePowerLevel[FP_LEVITATION] > FORCE_LEVEL_1 )
+							{
+								vec3_t facingFwd, facingRight, facingAngles;
+								int	anim = -1;
+								float dotR, dotF;
+								
+								VectorSet(facingAngles, 0, pm->ps->viewangles[YAW], 0);
+
+								AngleVectors( facingAngles, facingFwd, facingRight, NULL );
+								dotR = DotProduct( facingRight, pm->ps->velocity );
+								dotF = DotProduct( facingFwd, pm->ps->velocity );
+
+								if ( fabs(dotR) > fabs(dotF) * 1.5 )
+								{
+									if ( dotR > 150 )
+									{
+										anim = BOTH_FORCEJUMPRIGHT1;
+									}
+									else if ( dotR < -150 )
+									{
+										anim = BOTH_FORCEJUMPLEFT1;
+									}
+								}
+								else
+								{
+									if ( dotF > 150 )
+									{
+										anim = BOTH_FORCEJUMP1;
+									}
+									else if ( dotF < -150 )
+									{
+										anim = BOTH_FORCEJUMPBACK1;
+									}
+								}
+								if ( anim != -1 )
+								{
+									int parts = SETANIM_BOTH;
+									if ( pm->ps->weaponTime )
+									{//FIXME: really only care if we're in a saber attack anim...
+										parts = SETANIM_LEGS;
+									}
+
+									PM_SetAnim( parts, anim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD, 150 );
+								}
+							}
+						}
+						else
+						{ //jump is already active (the anim has started)
+							if ( pm->ps->legsTimer < 1 )
+							{//not in the middle of a legsAnim
+								int anim = (pm->ps->legsAnim);
+								int newAnim = -1;
+								switch ( anim )
+								{
+								case BOTH_FORCEJUMP1:
+									newAnim = BOTH_FORCELAND1;//BOTH_FORCEINAIR1;
+									break;
+								case BOTH_FORCEJUMPBACK1:
+									newAnim = BOTH_FORCELANDBACK1;//BOTH_FORCEINAIRBACK1;
+									break;
+								case BOTH_FORCEJUMPLEFT1:
+									newAnim = BOTH_FORCELANDLEFT1;//BOTH_FORCEINAIRLEFT1;
+									break;
+								case BOTH_FORCEJUMPRIGHT1:
+									newAnim = BOTH_FORCELANDRIGHT1;//BOTH_FORCEINAIRRIGHT1;
+									break;
+								}
+								if ( newAnim != -1 )
+								{
+									int parts = SETANIM_BOTH;
+									if ( pm->ps->weaponTime )
+									{
+										parts = SETANIM_LEGS;
+									}
+
+									PM_SetAnim( parts, newAnim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD, 150 );
+								}
+							}
+						}
+					}
+
+					//need to scale this down, start with height velocity (based on max force jump height) and scale down to regular jump vel
+					pm->ps->velocity[2] = (forceJumpHeight[pm->ps->fd.forcePowerLevel[FP_LEVITATION]]-curHeight)/forceJumpHeight[pm->ps->fd.forcePowerLevel[FP_LEVITATION]]*forceJumpStrength[pm->ps->fd.forcePowerLevel[FP_LEVITATION]];//JUMP_VELOCITY;
+					pm->ps->velocity[2] /= 10;
+					pm->ps->velocity[2] += JUMP_VELOCITY;
+					pm->ps->pm_flags |= PMF_JUMP_HELD;
+				}
+				else if ( curHeight > forceJumpHeight[0] && curHeight < forceJumpHeight[pm->ps->fd.forcePowerLevel[FP_LEVITATION]] - forceJumpHeight[0] )
+				{//still have some headroom, don't totally stop it
+					if ( pm->ps->velocity[2] > JUMP_VELOCITY )
+					{
+						pm->ps->velocity[2] = JUMP_VELOCITY;
+					}
+				}
+				else
+				{
+					//pm->ps->velocity[2] = 0;
+					//rww - changed for the sake of balance in multiplayer
+
+					if ( pm->ps->velocity[2] > JUMP_VELOCITY )
+					{
+						pm->ps->velocity[2] = JUMP_VELOCITY;
+					}
+				}
+				pm->cmd.upmove = 0;
+				return qfalse;
+			}
+		}
+	}
+
+#endif
+
+	//Not jumping
+	if ( pm->cmd.upmove < 10 && pm->ps->groundEntityNum != ENTITYNUM_NONE) {
+		return qfalse;
+	}
+
+	// must wait for jump to be released
+	if ( pm->ps->pm_flags & PMF_JUMP_HELD ) 
+	{
+		// clear upmove so cmdscale doesn't lower running speed
+		pm->cmd.upmove = 0;
+		return qfalse;
+	}
+
+	if ( pm->ps->gravity <= 0 )
+	{//in low grav, you push in the dir you're facing as long as there is something behind you to shove off of
+		vec3_t	forward, back;
+		trace_t	trace;
+
+		AngleVectors( pm->ps->viewangles, forward, NULL, NULL );
+		VectorMA( pm->ps->origin, -8, forward, back );
+		pm->trace( &trace, pm->ps->origin, pm->mins, pm->maxs, back, pm->ps->clientNum, pm->tracemask );
+
+		if ( trace.fraction <= 1.0f )
+		{
+			VectorMA( pm->ps->velocity, JUMP_VELOCITY*2, forward, pm->ps->velocity );
+			PM_SetAnim(SETANIM_LEGS,BOTH_FORCEJUMP1,SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD|SETANIM_FLAG_RESTART, 150);
+		}//else no surf close enough to push off of
+		pm->cmd.upmove = 0;
+	}
+	else if ( pm->cmd.upmove > 0 && pm->waterlevel < 2 &&
+		pm->ps->fd.forcePowerLevel[FP_LEVITATION] > FORCE_LEVEL_0 &&
+		!(pm->ps->pm_flags&PMF_JUMP_HELD) &&
+		(pm->ps->weapon == WP_SABER || pm->ps->weapon == WP_MELEE) &&
+		!PM_IsRocketTrooper() &&
+		!BG_HasYsalamiri(pm->gametype, pm->ps) &&
+		BG_CanUseFPNow(pm->gametype, pm->ps, pm->cmd.serverTime, FP_LEVITATION) )
+	{
+		if ( pm->ps->groundEntityNum != ENTITYNUM_NONE )
+		{//on the ground
+			//check for left-wall and right-wall special jumps
+			int anim = -1;
+			float	vertPush = 0;
+			if ( pm->cmd.rightmove > 0 && pm->ps->fd.forcePowerLevel[FP_LEVITATION] > FORCE_LEVEL_1 )
+			{//strafing right
+				if ( pm->cmd.forwardmove > 0 )
+				{//wall-run
+					vertPush = forceJumpStrength[FORCE_LEVEL_2]/2.0f;
+					anim = BOTH_WALL_RUN_RIGHT;
+				}
+				else if ( pm->cmd.forwardmove == 0 )
+				{//wall-flip
+					vertPush = forceJumpStrength[FORCE_LEVEL_2]/2.25f;
+					anim = BOTH_WALL_FLIP_RIGHT;
+				}
+			}
+			else if ( pm->cmd.rightmove < 0 && pm->ps->fd.forcePowerLevel[FP_LEVITATION] > FORCE_LEVEL_1 )
+			{//strafing left
+				if ( pm->cmd.forwardmove > 0 )
+				{//wall-run
+					vertPush = forceJumpStrength[FORCE_LEVEL_2]/2.0f;
+					anim = BOTH_WALL_RUN_LEFT;
+				}
+				else if ( pm->cmd.forwardmove == 0 )
+				{//wall-flip
+					vertPush = forceJumpStrength[FORCE_LEVEL_2]/2.25f;
+					anim = BOTH_WALL_FLIP_LEFT;
+				}
+			}
+			else if ( pm->cmd.forwardmove < 0 && !(pm->cmd.buttons&BUTTON_ATTACK) )
+			{//backflip
+				vertPush = JUMP_VELOCITY;
+				anim = BOTH_FLIP_BACK1;//BG_PickAnim( BOTH_FLIP_BACK1, BOTH_FLIP_BACK3 );
+			}
+
+			vertPush += 128; //give them an extra shove
+
+			if ( anim != -1 )
+			{
+				vec3_t fwd, right, traceto, mins, maxs, fwdAngles;
+				vec3_t	idealNormal={0}, wallNormal={0};
+				trace_t	trace;
+				qboolean doTrace = qfalse;
+				int contents = MASK_SOLID;//MASK_PLAYERSOLID;
+
+				VectorSet(mins, pm->mins[0],pm->mins[1],0);
+				VectorSet(maxs, pm->maxs[0],pm->maxs[1],24);
+				VectorSet(fwdAngles, 0, pm->ps->viewangles[YAW], 0);
+
+				memset(&trace, 0, sizeof(trace)); //to shut the compiler up
+
+				AngleVectors( fwdAngles, fwd, right, NULL );
+
+				//trace-check for a wall, if necc.
+				switch ( anim )
+				{
+				case BOTH_WALL_FLIP_LEFT:
+					//NOTE: purposely falls through to next case!
+				case BOTH_WALL_RUN_LEFT:
+					doTrace = qtrue;
+					VectorMA( pm->ps->origin, -16, right, traceto );
+					break;
+
+				case BOTH_WALL_FLIP_RIGHT:
+					//NOTE: purposely falls through to next case!
+				case BOTH_WALL_RUN_RIGHT:
+					doTrace = qtrue;
+					VectorMA( pm->ps->origin, 16, right, traceto );
+					break;
+
+				case BOTH_WALL_FLIP_BACK1:
+					doTrace = qtrue;
+					VectorMA( pm->ps->origin, 16, fwd, traceto );
+					break;
+				}
+
+				if ( doTrace )
+				{
+					pm->trace( &trace, pm->ps->origin, mins, maxs, traceto, pm->ps->clientNum, contents );
+					VectorCopy( trace.plane.normal, wallNormal );
+					VectorNormalize( wallNormal );
+					VectorSubtract( pm->ps->origin, traceto, idealNormal );
+					VectorNormalize( idealNormal );
+				}
+
+				if ( !doTrace || (trace.fraction < 1.0f && (trace.entityNum < MAX_CLIENTS || DotProduct(wallNormal,idealNormal) > 0.7)) )
+				{//there is a wall there.. or hit a client
+					if ( (anim != BOTH_WALL_RUN_LEFT 
+							&& anim != BOTH_WALL_RUN_RIGHT
+							&& anim != BOTH_FORCEWALLRUNFLIP_START) 
+						|| (wallNormal[2] >= 0.0f&&wallNormal[2]<=0.4f/*MAX_WALL_RUN_Z_NORMAL*/) )
+					{//wall-runs can only run on perfectly flat walls, sorry. 
+						int parts;
+						//move me to side
+						if ( anim == BOTH_WALL_FLIP_LEFT )
+						{
+							pm->ps->velocity[0] = pm->ps->velocity[1] = 0;
+							VectorMA( pm->ps->velocity, 150, right, pm->ps->velocity );
+						}
+						else if ( anim == BOTH_WALL_FLIP_RIGHT )
+						{
+							pm->ps->velocity[0] = pm->ps->velocity[1] = 0;
+							VectorMA( pm->ps->velocity, -150, right, pm->ps->velocity );
+						}
+						else if ( anim == BOTH_FLIP_BACK1 
+							|| anim == BOTH_FLIP_BACK2 
+							|| anim == BOTH_FLIP_BACK3 
+							|| anim == BOTH_WALL_FLIP_BACK1 )
+						{
+							pm->ps->velocity[0] = pm->ps->velocity[1] = 0;
+							VectorMA( pm->ps->velocity, -150, fwd, pm->ps->velocity );
+						}
+
+						/*
+						if ( doTrace && anim != BOTH_WALL_RUN_LEFT && anim != BOTH_WALL_RUN_RIGHT )
+						{
+							if (trace.entityNum < MAX_CLIENTS)
+							{
+								pm->ps->forceKickFlip = trace.entityNum+1; //let the server know that this person gets kicked by this client
+							}
+						}
+						*/
+
+						//up
+						if ( vertPush )
+						{
+							pm->ps->velocity[2] = vertPush;
+							pm->ps->fd.forcePowersActive |= (1 << FP_LEVITATION);
+						}
+						//animate me
+						parts = SETANIM_LEGS;
+						if ( anim == BOTH_BUTTERFLY_LEFT )
+						{
+							parts = SETANIM_BOTH;
+							pm->cmd.buttons&=~BUTTON_ATTACK;
+							pm->ps->saberMove = LS_NONE;
+						}
+						else if ( !pm->ps->weaponTime )
+						{
+							parts = SETANIM_BOTH;
+						}
+						PM_SetAnim( parts, anim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD, 0 );
+						if ( anim == BOTH_BUTTERFLY_LEFT )
+						{
+							pm->ps->weaponTime = pm->ps->torsoTimer;
+						}
+						PM_SetForceJumpZStart(pm->ps->origin[2]);//so we don't take damage if we land at same height
+						pm->ps->pm_flags |= PMF_JUMP_HELD;
+						pm->cmd.upmove = 0;
+						pm->ps->fd.forceJumpSound = 1;
+					}
+				}
+			}
+		}
+		else 
+		{//in the air
+			int legsAnim = pm->ps->legsAnim;
+
+			if ( legsAnim == BOTH_WALL_RUN_LEFT || legsAnim == BOTH_WALL_RUN_RIGHT )
+			{//running on a wall
+				vec3_t right, traceto, mins, maxs, fwdAngles;
+				trace_t	trace;
+				int		anim = -1;
+
+				VectorSet(mins, pm->mins[0], pm->mins[0], 0);
+				VectorSet(maxs, pm->maxs[0], pm->maxs[0], 24);
+				VectorSet(fwdAngles, 0, pm->ps->viewangles[YAW], 0);
+
+				AngleVectors( fwdAngles, NULL, right, NULL );
+
+				if ( legsAnim == BOTH_WALL_RUN_LEFT )
+				{
+					if ( pm->ps->legsTimer > 400 )
+					{//not at the end of the anim
+						float animLen = PM_AnimLength( 0, (animNumber_t)BOTH_WALL_RUN_LEFT );
+						if ( pm->ps->legsTimer < animLen - 400 )
+						{//not at start of anim
+							VectorMA( pm->ps->origin, -16, right, traceto );
+							anim = BOTH_WALL_RUN_LEFT_FLIP;
+						}
+					}
+				}
+				else if ( legsAnim == BOTH_WALL_RUN_RIGHT )
+				{
+					if ( pm->ps->legsTimer > 400 )
+					{//not at the end of the anim
+						float animLen = PM_AnimLength( 0, (animNumber_t)BOTH_WALL_RUN_RIGHT );
+						if ( pm->ps->legsTimer < animLen - 400 )
+						{//not at start of anim
+							VectorMA( pm->ps->origin, 16, right, traceto );
+							anim = BOTH_WALL_RUN_RIGHT_FLIP;
+						}
+					}
+				}
+				if ( anim != -1 )
+				{
+					pm->trace( &trace, pm->ps->origin, mins, maxs, traceto, pm->ps->clientNum, CONTENTS_SOLID|CONTENTS_BODY );
+					if ( trace.fraction < 1.0f )
+					{//flip off wall
+						int parts = 0;
+
+						if ( anim == BOTH_WALL_RUN_LEFT_FLIP )
+						{
+							pm->ps->velocity[0] *= 0.5f;
+							pm->ps->velocity[1] *= 0.5f;
+							VectorMA( pm->ps->velocity, 150, right, pm->ps->velocity );
+						}
+						else if ( anim == BOTH_WALL_RUN_RIGHT_FLIP )
+						{
+							pm->ps->velocity[0] *= 0.5f;
+							pm->ps->velocity[1] *= 0.5f;
+							VectorMA( pm->ps->velocity, -150, right, pm->ps->velocity );
+						}
+						parts = SETANIM_LEGS;
+						if ( !pm->ps->weaponTime )
+						{
+							parts = SETANIM_BOTH;
+						}
+						PM_SetAnim( parts, anim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD, 0 );
+						pm->cmd.upmove = 0;
+					}
+				}
+				if ( pm->cmd.upmove != 0 )
+				{//jump failed, so don't try to do normal jump code, just return
+					return qfalse;
+				}
+			}
+			//NEW JKA
+			else if ( pm->ps->legsAnim == BOTH_FORCEWALLRUNFLIP_START )
+			{
+				vec3_t fwd, traceto, mins, maxs, fwdAngles;
+				trace_t	trace;
+				int		anim = -1;
+				float animLen;
+
+				VectorSet(mins, pm->mins[0], pm->mins[0], 0.0f);
+				VectorSet(maxs, pm->maxs[0], pm->maxs[0], 24.0f);
+				//hmm, did you mean [1] and [1]?
+				VectorSet(fwdAngles, 0, pm->ps->viewangles[YAW], 0.0f);
+				AngleVectors( fwdAngles, fwd, NULL, NULL );
+
+				assert(pm_entSelf); //null pm_entSelf would be a Bad Thing<tm>
+				animLen = BG_AnimLength( pm_entSelf->localAnimIndex, BOTH_FORCEWALLRUNFLIP_START );
+				if ( pm->ps->legsTimer < animLen - 400 )
+				{//not at start of anim
+					VectorMA( pm->ps->origin, 16, fwd, traceto );
+					anim = BOTH_FORCEWALLRUNFLIP_END;
+				}
+				if ( anim != -1 )
+				{
+					pm->trace( &trace, pm->ps->origin, mins, maxs, traceto, pm->ps->clientNum, CONTENTS_SOLID|CONTENTS_BODY );
+					if ( trace.fraction < 1.0f )
+					{//flip off wall
+						int parts = SETANIM_LEGS;
+
+						pm->ps->velocity[0] *= 0.5f;
+						pm->ps->velocity[1] *= 0.5f;
+						VectorMA( pm->ps->velocity, -300, fwd, pm->ps->velocity );
+						pm->ps->velocity[2] += 200;
+						if ( !pm->ps->weaponTime )
+						{//not attacking, set anim on both
+							parts = SETANIM_BOTH;
+						}
+						PM_SetAnim( parts, anim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD, 0 );
+						//FIXME: do damage to traceEnt, like above?
+						//pm->ps->pm_flags |= PMF_JUMPING|PMF_SLOW_MO_FALL;
+						//ha ha, so silly with your silly jumpy fally flags.
+						pm->cmd.upmove = 0;
+						PM_AddEvent( EV_JUMP );
+					}
+				}
+				if ( pm->cmd.upmove != 0 )
+				{//jump failed, so don't try to do normal jump code, just return
+					return qfalse;
+				}
+			}
+			/*
+			else if ( pm->cmd.forwardmove > 0 //pushing forward
+				&& pm->ps->fd.forcePowerLevel[FP_LEVITATION] > FORCE_LEVEL_1
+				&& pm->ps->velocity[2] > 200
+				&& PM_GroundDistance() <= 80 //unfortunately we do not have a happy ground timer like SP (this would use up more bandwidth if we wanted prediction workign right), so we'll just use the actual ground distance.
+				&& !BG_InSpecialJump(pm->ps->legsAnim))
+			{//run up wall, flip backwards
+				vec3_t fwd, traceto, mins, maxs, fwdAngles;
+				trace_t	trace;
+				vec3_t	idealNormal;
+
+				VectorSet(mins, pm->mins[0],pm->mins[1],pm->mins[2]);
+				VectorSet(maxs, pm->maxs[0],pm->maxs[1],pm->maxs[2]);
+				VectorSet(fwdAngles, 0, pm->ps->viewangles[YAW], 0);
+
+				AngleVectors( fwdAngles, fwd, NULL, NULL );
+				VectorMA( pm->ps->origin, 32, fwd, traceto );
+
+				pm->trace( &trace, pm->ps->origin, mins, maxs, traceto, pm->ps->clientNum, MASK_PLAYERSOLID );//FIXME: clip brushes too?
+				VectorSubtract( pm->ps->origin, traceto, idealNormal );
+				VectorNormalize( idealNormal );
+				
+				if ( trace.fraction < 1.0f )
+				{//there is a wall there
+					int parts = SETANIM_LEGS;
+
+					pm->ps->velocity[0] = pm->ps->velocity[1] = 0;
+					VectorMA( pm->ps->velocity, -150, fwd, pm->ps->velocity );
+					pm->ps->velocity[2] += 128;
+
+					if ( !pm->ps->weaponTime )
+					{
+						parts = SETANIM_BOTH;
+					}
+					PM_SetAnim( parts, BOTH_WALL_FLIP_BACK1, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD, 0 );
+
+					pm->ps->legsTimer -= 600; //I force this anim to play to the end to prevent landing on your head and suddenly flipping over.
+											  //It is a bit too long at the end though, so I'll just shorten it.
+
+					PM_SetForceJumpZStart(pm->ps->origin[2]);//so we don't take damage if we land at same height
+					pm->cmd.upmove = 0;
+					pm->ps->fd.forceJumpSound = 1;
+					BG_ForcePowerDrain( pm->ps, FP_LEVITATION, 5 );
+
+					if (trace.entityNum < MAX_CLIENTS)
+					{
+						pm->ps->forceKickFlip = trace.entityNum+1; //let the server know that this person gets kicked by this client
+					}
+				}
+			}
+			*/
+			else if ( pm->cmd.forwardmove > 0 //pushing forward
+				&& pm->ps->fd.forceRageRecoveryTime < pm->cmd.serverTime	//not in a force Rage recovery period
+				&& pm->ps->fd.forcePowerLevel[FP_LEVITATION] > FORCE_LEVEL_1 
+				&& PM_WalkableGroundDistance() <= 80 //unfortunately we do not have a happy ground timer like SP (this would use up more bandwidth if we wanted prediction workign right), so we'll just use the actual ground distance.
+				&& (pm->ps->legsAnim == BOTH_JUMP1 || pm->ps->legsAnim == BOTH_INAIR1 ) )//not in a flip or spin or anything
+			{//run up wall, flip backwards
+				//FIXME: have to be moving... make sure it's opposite the wall... or at least forward?
+				int wallWalkAnim = BOTH_WALL_FLIP_BACK1;
+				int parts = SETANIM_LEGS;
+				int contents = MASK_SOLID;//MASK_PLAYERSOLID;//CONTENTS_SOLID;
+				//qboolean kick = qtrue;
+				if ( pm->ps->fd.forcePowerLevel[FP_LEVITATION] > FORCE_LEVEL_2 )
+				{
+					wallWalkAnim = BOTH_FORCEWALLRUNFLIP_START;
+					parts = SETANIM_BOTH;
+					//kick = qfalse;
+				}
+				else
+				{
+					if ( !pm->ps->weaponTime )
+					{
+						parts = SETANIM_BOTH;
+					}
+				}
+				//if ( PM_HasAnimation( pm->gent, wallWalkAnim ) )
+				if (1) //sure, we have it! Because I SAID SO.
+				{
+					vec3_t fwd, traceto, mins, maxs, fwdAngles;
+					trace_t	trace;
+					vec3_t	idealNormal;
+					bgEntity_t *traceEnt;
+
+					VectorSet(mins, pm->mins[0], pm->mins[1], 0.0f);
+					VectorSet(maxs, pm->maxs[0], pm->maxs[1], 24.0f);
+					VectorSet(fwdAngles, 0, pm->ps->viewangles[YAW], 0.0f);
+
+					AngleVectors( fwdAngles, fwd, NULL, NULL );
+					VectorMA( pm->ps->origin, 32, fwd, traceto );
+
+					pm->trace( &trace, pm->ps->origin, mins, maxs, traceto, pm->ps->clientNum, contents );//FIXME: clip brushes too?
+					VectorSubtract( pm->ps->origin, traceto, idealNormal );
+					VectorNormalize( idealNormal );
+					traceEnt = PM_BGEntForNum(trace.entityNum);
+					
+					if ( trace.fraction < 1.0f
+						&&((trace.entityNum<ENTITYNUM_WORLD&&traceEnt&&traceEnt->s.solid!=SOLID_BMODEL)||DotProduct(trace.plane.normal,idealNormal)>0.7) )
+					{//there is a wall there
+						pm->ps->velocity[0] = pm->ps->velocity[1] = 0;
+						if ( wallWalkAnim == BOTH_FORCEWALLRUNFLIP_START )
+						{
+							pm->ps->velocity[2] = forceJumpStrength[FORCE_LEVEL_3]/2.0f;
+						}
+						else
+						{
+							VectorMA( pm->ps->velocity, -150, fwd, pm->ps->velocity );
+							pm->ps->velocity[2] += 150.0f;
+						}
+						//animate me
+						PM_SetAnim( parts, wallWalkAnim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD, 0 );
+//						pm->ps->pm_flags |= PMF_JUMPING|PMF_SLOW_MO_FALL;
+						//again with the flags!
+						//G_SoundOnEnt( pm->gent, CHAN_BODY, "sound/weapons/force/jump.wav" );
+						//yucky!
+						PM_SetForceJumpZStart(pm->ps->origin[2]);//so we don't take damage if we land at same height
+						pm->cmd.upmove = 0;
+						pm->ps->fd.forceJumpSound = 1;
+						BG_ForcePowerDrain( pm->ps, FP_LEVITATION, 5 );
+
+						//kick if jumping off an ent
+						/*
+						if ( kick && traceEnt && (traceEnt->s.eType == ET_PLAYER || traceEnt->s.eType == ET_NPC) )
+						{ //kick that thang!
+							pm->ps->forceKickFlip = traceEnt->s.number+1;
+						}
+						*/
+						pm->cmd.rightmove = pm->cmd.forwardmove= 0;
+					}
+				}
+			}
+			else if ( (!BG_InSpecialJump( legsAnim )//not in a special jump anim 
+						||BG_InReboundJump( legsAnim )//we're already in a rebound
+						||BG_InBackFlip( legsAnim ) )//a backflip (needed so you can jump off a wall behind you)
+					//&& pm->ps->velocity[2] <= 0 
+					&& pm->ps->velocity[2] > -1200 //not falling down very fast
+					&& !(pm->ps->pm_flags&PMF_JUMP_HELD)//have to have released jump since last press
+					&& (pm->cmd.forwardmove||pm->cmd.rightmove)//pushing in a direction
+					//&& pm->ps->forceRageRecoveryTime < pm->cmd.serverTime	//not in a force Rage recovery period
+					&& pm->ps->fd.forcePowerLevel[FP_LEVITATION] > FORCE_LEVEL_2//level 3 jump or better
+					//&& WP_ForcePowerAvailable( pm->gent, FP_LEVITATION, 10 )//have enough force power to do another one
+					&& BG_CanUseFPNow(pm->gametype, pm->ps, pm->cmd.serverTime, FP_LEVITATION)
+					&& (pm->ps->origin[2]-pm->ps->fd.forceJumpZStart) < (forceJumpHeightMax[FORCE_LEVEL_3]-(BG_ForceWallJumpStrength()/2.0f)) //can fit at least one more wall jump in (yes, using "magic numbers"... for now)
+					//&& (pm->ps->legsAnim == BOTH_JUMP1 || pm->ps->legsAnim == BOTH_INAIR1 ) )//not in a flip or spin or anything
+					)
+			{//see if we're pushing at a wall and jump off it if so
+				//FIXME: make sure we have enough force power
+				//FIXME: check  to see if we can go any higher
+				//FIXME: limit to a certain number of these in a row?
+				//FIXME: maybe don't require a ucmd direction, just check all 4?
+				//FIXME: should stick to the wall for a second, then push off...
+				vec3_t checkDir, traceto, mins, maxs, fwdAngles;
+				trace_t	trace;
+				vec3_t	idealNormal;
+				int		anim = -1;
+
+				VectorSet(mins, pm->mins[0], pm->mins[1], 0.0f);
+				VectorSet(maxs, pm->maxs[0], pm->maxs[1], 24.0f);
+				VectorSet(fwdAngles, 0, pm->ps->viewangles[YAW], 0.0f);
+
+				if ( pm->cmd.rightmove )
+				{
+					if ( pm->cmd.rightmove > 0 )
+					{
+						anim = BOTH_FORCEWALLREBOUND_RIGHT;
+						AngleVectors( fwdAngles, NULL, checkDir, NULL );
+					}
+					else if ( pm->cmd.rightmove < 0 )
+					{
+						anim = BOTH_FORCEWALLREBOUND_LEFT;
+						AngleVectors( fwdAngles, NULL, checkDir, NULL );
+						VectorScale( checkDir, -1, checkDir );
+					}
+				}
+				else if ( pm->cmd.forwardmove > 0 )
+				{
+					anim = BOTH_FORCEWALLREBOUND_FORWARD;
+					AngleVectors( fwdAngles, checkDir, NULL, NULL );
+				}
+				else if ( pm->cmd.forwardmove < 0 )
+				{
+					anim = BOTH_FORCEWALLREBOUND_BACK;
+					AngleVectors( fwdAngles, checkDir, NULL, NULL );
+					VectorScale( checkDir, -1, checkDir );
+				}
+				if ( anim != -1 )
+				{//trace in the dir we're pushing in and see if there's a vertical wall there
+					bgEntity_t *traceEnt;
+
+					VectorMA( pm->ps->origin, 8, checkDir, traceto );
+					pm->trace( &trace, pm->ps->origin, mins, maxs, traceto, pm->ps->clientNum, CONTENTS_SOLID );//FIXME: clip brushes too?
+					VectorSubtract( pm->ps->origin, traceto, idealNormal );
+					VectorNormalize( idealNormal );
+					traceEnt = PM_BGEntForNum(trace.entityNum);
+					if ( trace.fraction < 1.0f
+						&&fabs(trace.plane.normal[2]) <= 0.2f/*MAX_WALL_GRAB_SLOPE*/
+						&&((trace.entityNum<ENTITYNUM_WORLD&&traceEnt&&traceEnt->s.solid!=SOLID_BMODEL)||DotProduct(trace.plane.normal,idealNormal)>0.7) )
+					{//there is a wall there
+						float dot = DotProduct( pm->ps->velocity, trace.plane.normal );
+						if ( dot < 1.0f )
+						{//can't be heading *away* from the wall!
+							//grab it!
+							PM_GrabWallForJump( anim );
+						}
+					}
+				}
+			}
+			else
+			{
+				//FIXME: if in a butterfly, kick people away?
+			}
+			//END NEW JKA
+		}
+	}
+
+	/*
+	if ( pm->cmd.upmove > 0 
+		&& (pm->ps->weapon == WP_SABER || pm->ps->weapon == WP_MELEE)
+		&& !PM_IsRocketTrooper()
+		&& (pm->ps->weaponTime > 0||pm->cmd.buttons&BUTTON_ATTACK) )
+	{//okay, we just jumped and we're in an attack
+		if ( !BG_InRoll( pm->ps, pm->ps->legsAnim )
+			&& !PM_InKnockDown( pm->ps )
+			&& !BG_InDeathAnim(pm->ps->legsAnim)
+			&& !BG_FlippingAnim( pm->ps->legsAnim )
+			&& !PM_SpinningAnim( pm->ps->legsAnim )
+			&& !BG_SaberInSpecialAttack( pm->ps->torsoAnim )
+			&& ( BG_SaberInAttack( pm->ps->saberMove ) ) )
+		{//not in an anim we shouldn't interrupt
+			//see if it's not too late to start a special jump-attack
+			float animLength = PM_AnimLength( 0, (animNumber_t)pm->ps->torsoAnim );
+			if ( animLength - pm->ps->torsoTimer < 500 )
+			{//just started the saberMove
+				//check for special-case jump attacks
+				if ( pm->ps->fd.saberAnimLevel == FORCE_LEVEL_2 )
+				{//using medium attacks
+					if (PM_GroundDistance() < 32 &&
+						!BG_InSpecialJump(pm->ps->legsAnim))
+					{ //FLIP AND DOWNWARD ATTACK
+						//trace_t tr;
+
+						//if (PM_SomeoneInFront(&tr))
+						{
+							PM_SetSaberMove(PM_SaberFlipOverAttackMove());
+							pml.groundPlane = qfalse;
+							pml.walking = qfalse;
+							pm->ps->pm_flags |= PMF_JUMP_HELD;
+							pm->ps->groundEntityNum = ENTITYNUM_NONE;
+							VectorClear(pml.groundTrace.plane.normal);
+
+							pm->ps->weaponTime = pm->ps->torsoTimer;
+						}
+					}
+				}
+				else if ( pm->ps->fd.saberAnimLevel == FORCE_LEVEL_3 )
+				{//using strong attacks
+					if ( pm->cmd.forwardmove > 0 && //going forward
+						(pm->cmd.buttons & BUTTON_ATTACK) && //must be holding attack still
+						PM_GroundDistance() < 32 &&
+						!BG_InSpecialJump(pm->ps->legsAnim))
+					{//strong attack: jump-hack
+						PM_SetSaberMove( PM_SaberJumpAttackMove() );
+						pml.groundPlane = qfalse;
+						pml.walking = qfalse;
+						pm->ps->pm_flags |= PMF_JUMP_HELD;
+						pm->ps->groundEntityNum = ENTITYNUM_NONE;
+						VectorClear(pml.groundTrace.plane.normal);
+
+						pm->ps->weaponTime = pm->ps->torsoTimer;
+					}
+				}
+			}
+		}
+	}
+	*/
+	if ( pm->ps->groundEntityNum == ENTITYNUM_NONE )
+	{
+		return qfalse;
+	}
+	if ( pm->cmd.upmove > 0 )
+	{//no special jumps
+		pm->ps->velocity[2] = JUMP_VELOCITY;
+		PM_SetForceJumpZStart(pm->ps->origin[2]);//so we don't take damage if we land at same height
+		pm->ps->pm_flags |= PMF_JUMP_HELD;
+	}
+
+	//Jumping
+	pml.groundPlane = qfalse;
+	pml.walking = qfalse;
+	pm->ps->pm_flags |= PMF_JUMP_HELD;
+	pm->ps->groundEntityNum = ENTITYNUM_NONE;
+	PM_SetForceJumpZStart(pm->ps->origin[2]);
+
+	PM_AddEvent( EV_JUMP );
+
+	//Set the animations
+	if ( pm->ps->gravity > 0 && !BG_InSpecialJump( pm->ps->legsAnim ) )
+	{
+		PM_JumpForDir();
+	}
+
+	return qtrue;
+}
+/*
+=============
+PM_CheckWaterJump
+=============
+*/
+static qboolean	PM_CheckWaterJump( void ) {
+	vec3_t	spot;
+	int		cont;
+	vec3_t	flatforward;
+
+	if (pm->ps->pm_time) {
+		return qfalse;
+	}
+
+	// check for water jump
+	if ( pm->waterlevel != 2 ) {
+		return qfalse;
+	}
+
+	flatforward[0] = pml.forward[0];
+	flatforward[1] = pml.forward[1];
+	flatforward[2] = 0;
+	VectorNormalize (flatforward);
+
+	VectorMA (pm->ps->origin, 30, flatforward, spot);
+	spot[2] += 4;
+	cont = pm->pointcontents (spot, pm->ps->clientNum );
+	if ( !(cont & CONTENTS_SOLID) ) {
+		return qfalse;
+	}
+
+	spot[2] += 16;
+	cont = pm->pointcontents (spot, pm->ps->clientNum );
+	if ( cont ) {
+		return qfalse;
+	}
+
+	// jump out of water
+	VectorScale (pml.forward, 200, pm->ps->velocity);
+	pm->ps->velocity[2] = 350;
+
+	pm->ps->pm_flags |= PMF_TIME_WATERJUMP;
+	pm->ps->pm_time = 2000;
+
+	return qtrue;
+}
+
+//============================================================================
+
+
+/*
+===================
+PM_WaterJumpMove
+
+Flying out of the water
+===================
+*/
+static void PM_WaterJumpMove( void ) {
+	// waterjump has no control, but falls
+
+	PM_StepSlideMove( qtrue );
+
+	pm->ps->velocity[2] -= pm->ps->gravity * pml.frametime;
+	if (pm->ps->velocity[2] < 0) {
+		// cancel as soon as we are falling down again
+		pm->ps->pm_flags &= ~PMF_ALL_TIMES;
+		pm->ps->pm_time = 0;
+	}
+}
+
+/*
+===================
+PM_WaterMove
+
+===================
+*/
+static void PM_WaterMove( void ) {
+	int		i;
+	vec3_t	wishvel;
+	float	wishspeed;
+	vec3_t	wishdir;
+	float	scale;
+	float	vel;
+
+	if ( PM_CheckWaterJump() ) {
+		PM_WaterJumpMove();
+		return;
+	}
+#if 0
+	// jump = head for surface
+	if ( pm->cmd.upmove >= 10 ) {
+		if (pm->ps->velocity[2] > -300) {
+			if ( pm->watertype == CONTENTS_WATER ) {
+				pm->ps->velocity[2] = 100;
+			} else if (pm->watertype == CONTENTS_SLIME) {
+				pm->ps->velocity[2] = 80;
+			} else {
+				pm->ps->velocity[2] = 50;
+			}
+		}
+	}
+#endif
+	PM_Friction ();
+
+	scale = PM_CmdScale( &pm->cmd );
+	//
+	// user intentions
+	//
+	if ( !scale ) {
+		wishvel[0] = 0;
+		wishvel[1] = 0;
+		wishvel[2] = -60;		// sink towards bottom
+	} else {
+		for (i=0 ; i<3 ; i++)
+			wishvel[i] = scale * pml.forward[i]*pm->cmd.forwardmove + scale * pml.right[i]*pm->cmd.rightmove;
+
+		wishvel[2] += scale * pm->cmd.upmove;
+	}
+
+	VectorCopy (wishvel, wishdir);
+	wishspeed = VectorNormalize(wishdir);
+
+	if ( wishspeed > pm->ps->speed * pm_swimScale ) {
+		wishspeed = pm->ps->speed * pm_swimScale;
+	}
+
+	PM_Accelerate (wishdir, wishspeed, pm_wateraccelerate);
+
+	// make sure we can go up slopes easily under water
+	if ( pml.groundPlane && DotProduct( pm->ps->velocity, pml.groundTrace.plane.normal ) < 0 ) {
+		vel = VectorLength(pm->ps->velocity);
+		// slide along the ground plane
+		PM_ClipVelocity (pm->ps->velocity, pml.groundTrace.plane.normal, 
+			pm->ps->velocity, OVERCLIP );
+
+		VectorNormalize(pm->ps->velocity);
+		VectorScale(pm->ps->velocity, vel, pm->ps->velocity);
+	}
+
+	PM_SlideMove( qfalse );
+}
+
+/*
+===================
+PM_FlyVehicleMove
+
+===================
+*/
+static void PM_FlyVehicleMove( void ) 
+{
+	int		i;
+	vec3_t	wishvel;
+	float	wishspeed;
+	vec3_t	wishdir;
+	float	scale;
+	float	zVel;
+	float	fmove = 0.0f, smove = 0.0f;
+
+	// We don't use these here because we pre-calculate the movedir in the vehicle update anyways, and if
+	// you leave this, you get strange motion during boarding (the player can move the vehicle).
+	//fmove = pm->cmd.forwardmove;
+	//smove = pm->cmd.rightmove;
+
+	// normal slowdown
+	if ( pm->ps->gravity && pm->ps->velocity[2] < 0 && pm->ps->groundEntityNum == ENTITYNUM_NONE )
+	{//falling
+		zVel = pm->ps->velocity[2];
+		PM_Friction ();
+		pm->ps->velocity[2] = zVel;
+	}
+	else
+	{
+		PM_Friction ();
+		if ( pm->ps->velocity[2] < 0 && pm->ps->groundEntityNum != ENTITYNUM_NONE )
+		{
+			pm->ps->velocity[2] = 0;	// ignore slope movement
+		}
+	}
+
+	scale = PM_CmdScale( &pm->cmd );
+
+	// Get The WishVel And WishSpeed
+	//-------------------------------   
+	if ( pm->ps->clientNum >= MAX_CLIENTS )
+	{//NPC
+		
+		// If The UCmds Were Set, But Never Converted Into A MoveDir, Then Make The WishDir From UCmds
+		//--------------------------------------------------------------------------------------------
+		if ((fmove!=0.0f || smove!=0.0f) &&	VectorCompare(pm->ps->moveDir, vec3_origin))
+		{
+			//gi.Printf("Generating MoveDir\n");
+			for ( i = 0 ; i < 3 ; i++ ) 
+			{
+				wishvel[i] = pml.forward[i]*fmove + pml.right[i]*smove;
+			}
+
+			VectorCopy( wishvel, wishdir );
+			wishspeed = VectorNormalize(wishdir);
+			wishspeed *= scale;
+		}
+		// Otherwise, Use The Move Dir
+		//-----------------------------
+		else
+		{
+			wishspeed = pm->ps->speed;
+			VectorScale( pm->ps->moveDir, pm->ps->speed, wishvel );
+			VectorCopy( pm->ps->moveDir, wishdir );
+		}
+	}
+	else
+	{
+		for ( i = 0 ; i < 3 ; i++ ) {
+			wishvel[i] = pml.forward[i]*fmove + pml.right[i]*smove;
+		}
+		// when going up or down slopes the wish velocity should Not be zero
+	//	wishvel[2] = 0;
+
+		VectorCopy (wishvel, wishdir);
+		wishspeed = VectorNormalize(wishdir);
+		wishspeed *= scale;
+	}
+
+	// Handle negative speed.
+	if ( wishspeed < 0 )
+	{
+		wishspeed = wishspeed * -1.0f;
+		VectorScale( wishvel, -1.0f, wishvel );
+		VectorScale( wishdir, -1.0f, wishdir );
+	}
+
+	VectorCopy( wishvel, wishdir );
+	wishspeed = VectorNormalize( wishdir );
+
+	PM_Accelerate( wishdir, wishspeed, 100 );
+
+	PM_StepSlideMove( 1 );
+}
+
+/*
+===================
+PM_FlyMove
+
+Only with the flight powerup
+===================
+*/
+static void PM_FlyMove( void ) {
+	int		i;
+	vec3_t	wishvel;
+	float	wishspeed;
+	vec3_t	wishdir;
+	float	scale;
+
+	// normal slowdown
+	PM_Friction ();
+
+	scale = PM_CmdScale( &pm->cmd );
+	
+	if ( pm->ps->pm_type == PM_SPECTATOR && pm->cmd.buttons & BUTTON_ALT_ATTACK) {
+		//turbo boost
+		scale *= 10;
+	}
+
+	//
+	// user intentions
+	//
+	if ( !scale ) {
+		wishvel[0] = 0;
+		wishvel[1] = 0;
+		wishvel[2] = pm->ps->speed * (pm->cmd.upmove/127.0f);
+	} else {
+		for (i=0 ; i<3 ; i++) {
+			wishvel[i] = scale * pml.forward[i]*pm->cmd.forwardmove + scale * pml.right[i]*pm->cmd.rightmove;
+		}
+
+		wishvel[2] += scale * pm->cmd.upmove;
+	}
+
+	VectorCopy (wishvel, wishdir);
+	wishspeed = VectorNormalize(wishdir);
+
+	PM_Accelerate (wishdir, wishspeed, pm_flyaccelerate);
+
+	PM_StepSlideMove( qfalse );
+}
+
+
+/*
+===================
+PM_AirMove
+
+===================
+*/
+static void PM_AirMove( void ) {
+	int			i;
+	vec3_t		wishvel;
+	float		fmove, smove;
+	vec3_t		wishdir;
+	float		wishspeed;
+	float		scale;
+	float		accelerate;
+	usercmd_t	cmd;
+	Vehicle_t	*pVeh = NULL;
+
+	if (pm->ps->clientNum >= MAX_CLIENTS)
+	{
+		bgEntity_t	*pEnt = pm_entSelf;
+
+		if ( pEnt && pEnt->s.NPC_class == CLASS_VEHICLE )
+		{
+			pVeh = pEnt->m_pVehicle;
+		}
+	}
+
+	if (pm->ps->pm_type != PM_SPECTATOR)
+	{
+#if METROID_JUMP
+		PM_CheckJump();
+#else
+		if (pm->ps->fd.forceJumpZStart &&
+			pm->ps->forceJumpFlip)
+		{
+			PM_CheckJump();
+		}
+#endif
+	}
+	PM_Friction();
+
+	fmove = pm->cmd.forwardmove;
+	smove = pm->cmd.rightmove;
+
+	cmd = pm->cmd;
+	scale = PM_CmdScale( &cmd );
+
+	// set the movementDir so clients can rotate the legs for strafing
+	PM_SetMovementDir();
+
+	// project moves down to flat plane
+	pml.forward[2] = 0;
+	pml.right[2] = 0;
+	VectorNormalize (pml.forward);
+	VectorNormalize (pml.right);
+
+	if ( pVeh && pVeh->m_pVehicleInfo->hoverHeight > 0 )
+	{//in a hovering vehicle, have air control
+		if ( 1 )
+		{
+			wishspeed = pm->ps->speed;
+			VectorScale( pm->ps->moveDir, pm->ps->speed, wishvel );
+			VectorCopy( pm->ps->moveDir, wishdir );
+			scale = 1.0f;
+		}
+#if 0
+		else
+		{
+			float controlMod = 1.0f;
+			if ( pml.groundPlane )
+			{//on a slope of some kind, shouldn't have much control and should slide a lot
+				controlMod = pml.groundTrace.plane.normal[2];
+			}
+
+			vec3_t	vfwd, vrt;
+			vec3_t	vAngles;
+
+			VectorCopy( pVeh->m_vOrientation, vAngles );
+			vAngles[ROLL] = 0;//since we're a hovercraft, we really don't want to stafe up into the air if we're banking
+			AngleVectors( vAngles, vfwd, vrt, NULL );
+
+			float speed = pm->ps->speed;
+			float strafeSpeed = 0;
+
+			if ( fmove < 0 )
+			{//going backwards
+				if ( speed < 0 )
+				{//speed is negative, but since our command is reverse, make speed positive
+					speed = fabs( speed );
+					/*
+					if ( pml.groundPlane )
+					{//on a slope, still have some control
+						speed = fabs( speed );
+					}
+					else
+					{//can't reverse in air
+						speed = 0;
+					}
+					*/
+				}
+				else if ( speed > 0 )
+				{//trying to move back but speed is still positive, so keep moving forward (we'll slow down eventually)
+					speed = 0;
+				}
+			}
+
+			if ( pm->ps->clientNum < MAX_CLIENTS )
+			{//do normal adding to wishvel
+				VectorScale( vfwd, speed*controlMod*(fmove/127.0f), wishvel );
+				//just add strafing
+				if ( pVeh->m_pVehicleInfo->strafePerc )
+				{//we can strafe
+					if ( smove )
+					{//trying to strafe
+						float minSpeed = pVeh->m_pVehicleInfo->speedMax * 0.5f * pVeh->m_pVehicleInfo->strafePerc;
+						strafeSpeed = fabs(DotProduct( pm->ps->velocity, vfwd ))*pVeh->m_pVehicleInfo->strafePerc;
+						if ( strafeSpeed < minSpeed )
+						{
+							strafeSpeed = minSpeed;
+						}
+						strafeSpeed *= controlMod*((float)(smove))/127.0f;
+						if ( strafeSpeed < 0 )
+						{//pm_accelerate does not understand negative numbers
+							strafeSpeed *= -1;
+							VectorScale( vrt, -1, vrt );
+						}
+						//now just add it to actual velocity
+						PM_Accelerate( vrt, strafeSpeed, pVeh->m_pVehicleInfo->traction );
+					}
+				}
+			}
+			else
+			{
+				if ( pVeh->m_pVehicleInfo->strafePerc )
+				{//we can strafe
+					if ( pm->ps->clientNum )
+					{//alternate control scheme: can strafe
+						if ( smove )
+						{
+							/*
+							if ( fmove > 0 )
+							{//actively accelerating
+								strafeSpeed = pm->ps->speed;
+							}
+							else
+							{//not stepping on accelerator, only strafe based on magnitude of current forward velocity
+								strafeSpeed = fabs(DotProduct( pm->ps->velocity, vfwd ));
+							}
+							*/
+							strafeSpeed = ((float)(smove))/127.0f;
+						}
+					}
+				}
+				//strafing takes away from forward speed
+				VectorScale( vfwd, (fmove/127.0f)*(1.0f-pVeh->m_pVehicleInfo->strafePerc), wishvel );
+				if ( strafeSpeed )
+				{
+					VectorMA( wishvel, strafeSpeed*pVeh->m_pVehicleInfo->strafePerc, vrt, wishvel );
+				}
+				VectorNormalize( wishvel );
+				VectorScale( wishvel, speed*controlMod, wishvel );
+			}
+		}
+#endif
+	}
+	else if ( gPMDoSlowFall )
+	{//no air-control
+		VectorClear( wishvel );
+	}
+	else if (pm->ps->pm_type == PM_JETPACK)
+	{ //reduced air control while not jetting
+		for ( i = 0 ; i < 2 ; i++ )
+		{
+			wishvel[i] = pml.forward[i]*fmove + pml.right[i]*smove;
+		}
+		wishvel[2] = 0;
+
+		if (pm->cmd.upmove <= 0)
+		{
+            VectorScale(wishvel, 0.8f, wishvel);
+		}
+		else
+		{ //if we are jetting then we have more control than usual
+            VectorScale(wishvel, 2.0f, wishvel);
+		}
+	}
+	else
+	{
+		for ( i = 0 ; i < 2 ; i++ )
+		{
+			wishvel[i] = pml.forward[i]*fmove + pml.right[i]*smove;
+		}
+		wishvel[2] = 0;
+	}
+
+	VectorCopy (wishvel, wishdir);
+	wishspeed = VectorNormalize(wishdir);
+	wishspeed *= scale;
+
+	accelerate = pm_airaccelerate;
+	if ( pVeh && pVeh->m_pVehicleInfo->type == VH_SPEEDER )
+	{//speeders have more control in air
+		//in mid-air
+		accelerate = pVeh->m_pVehicleInfo->traction;
+		if ( pml.groundPlane )
+		{//on a slope of some kind, shouldn't have much control and should slide a lot
+			accelerate *= 0.5f;
+		}
+	}
+	// not on ground, so little effect on velocity
+	PM_Accelerate (wishdir, wishspeed, accelerate);
+
+	// we may have a ground plane that is very steep, even
+	// though we don't have a groundentity
+	// slide along the steep plane
+	if ( pml.groundPlane ) 
+	{
+		if ( !(pm->ps->pm_flags&PMF_STUCK_TO_WALL) )
+		{//don't slide when stuck to a wall
+			if ( PM_GroundSlideOkay( pml.groundTrace.plane.normal[2] ) )
+			{
+				PM_ClipVelocity (pm->ps->velocity, pml.groundTrace.plane.normal, 
+					pm->ps->velocity, OVERCLIP );
+			}
+		}
+	}
+
+	if ( (pm->ps->pm_flags&PMF_STUCK_TO_WALL) )
+	{//no grav when stuck to wall
+		PM_StepSlideMove( qfalse );
+	}
+	else
+	{
+		PM_StepSlideMove( qtrue );
+	}
+}
+
+/*
+===================
+PM_WalkMove
+
+===================
+*/
+static void PM_WalkMove( void ) {
+	int			i;
+	vec3_t		wishvel;
+	float		fmove, smove;
+	vec3_t		wishdir;
+	float		wishspeed = 0.0f;
+	float		scale;
+	usercmd_t	cmd;
+	float		accelerate;
+	float		vel;
+	qboolean	npcMovement = qfalse;
+
+	if ( pm->waterlevel > 2 && DotProduct( pml.forward, pml.groundTrace.plane.normal ) > 0 ) {
+		// begin swimming
+		PM_WaterMove();
+		return;
+	}
+
+
+	if (pm->ps->pm_type != PM_SPECTATOR)
+	{
+		if ( PM_CheckJump () ) {
+			// jumped away
+			if ( pm->waterlevel > 1 ) {
+				PM_WaterMove();
+			} else {
+				PM_AirMove();
+			}
+			return;
+		}
+	}
+
+	PM_Friction ();
+
+	fmove = pm->cmd.forwardmove;
+	smove = pm->cmd.rightmove;
+
+	cmd = pm->cmd;
+	scale = PM_CmdScale( &cmd );
+
+	// set the movementDir so clients can rotate the legs for strafing
+	PM_SetMovementDir();
+
+	// project moves down to flat plane
+	pml.forward[2] = 0;
+	pml.right[2] = 0;
+
+	// project the forward and right directions onto the ground plane
+	PM_ClipVelocity (pml.forward, pml.groundTrace.plane.normal, pml.forward, OVERCLIP );
+	PM_ClipVelocity (pml.right, pml.groundTrace.plane.normal, pml.right, OVERCLIP );
+	//
+	VectorNormalize (pml.forward);
+	VectorNormalize (pml.right);
+
+	// Get The WishVel And WishSpeed
+	//-------------------------------  
+	if ( pm->ps->clientNum >= MAX_CLIENTS && !VectorCompare( pm->ps->moveDir, vec3_origin ) )
+	{//NPC
+		bgEntity_t *pEnt = pm_entSelf;
+
+		if (pEnt && pEnt->s.NPC_class == CLASS_VEHICLE)
+		{
+			// If The UCmds Were Set, But Never Converted Into A MoveDir, Then Make The WishDir From UCmds
+			//--------------------------------------------------------------------------------------------
+			if ((fmove!=0.0f || smove!=0.0f) &&	VectorCompare(pm->ps->moveDir, vec3_origin))
+			{
+				//gi.Printf("Generating MoveDir\n");
+				for ( i = 0 ; i < 3 ; i++ ) 
+				{
+					wishvel[i] = pml.forward[i]*fmove + pml.right[i]*smove;
+				}
+
+				VectorCopy( wishvel, wishdir );
+				wishspeed = VectorNormalize(wishdir);
+				wishspeed *= scale;
+			}
+			// Otherwise, Use The Move Dir
+			//-----------------------------
+			else
+			{
+				//wishspeed = pm->ps->speed;
+				VectorScale( pm->ps->moveDir, pm->ps->speed, wishvel );
+				VectorCopy (wishvel, wishdir);
+				wishspeed = VectorNormalize(wishdir);
+			}
+
+			npcMovement = qtrue;
+		}
+	}
+
+	if (!npcMovement)
+	{
+		for ( i = 0 ; i < 3 ; i++ ) {
+			wishvel[i] = pml.forward[i]*fmove + pml.right[i]*smove;
+		}
+		// when going up or down slopes the wish velocity should Not be zero
+
+		VectorCopy (wishvel, wishdir);
+		wishspeed = VectorNormalize(wishdir);
+		wishspeed *= scale;
+	}
+
+	// clamp the speed lower if ducking
+	if ( pm->ps->pm_flags & PMF_DUCKED ) {
+		if ( wishspeed > pm->ps->speed * pm_duckScale ) {
+			wishspeed = pm->ps->speed * pm_duckScale;
+		}
+	}
+	else if ( (pm->ps->pm_flags & PMF_ROLLING) && !BG_InRoll(pm->ps, pm->ps->legsAnim) &&
+		!PM_InRollComplete(pm->ps, pm->ps->legsAnim))
+	{
+		if ( wishspeed > pm->ps->speed * pm_duckScale ) {
+			wishspeed = pm->ps->speed * pm_duckScale;
+		}
+	}
+
+	// clamp the speed lower if wading or walking on the bottom
+	if ( pm->waterlevel ) {
+		float	waterScale;
+
+		waterScale = pm->waterlevel / 3.0;
+		waterScale = 1.0 - ( 1.0 - pm_swimScale ) * waterScale;
+		if ( wishspeed > pm->ps->speed * waterScale ) {
+			wishspeed = pm->ps->speed * waterScale;
+		}
+	}
+
+	// when a player gets hit, they temporarily lose
+	// full control, which allows them to be moved a bit
+	if ( pm_flying == FLY_HOVER )
+	{
+		accelerate = pm_vehicleaccelerate;
+	}
+	else if ( ( pml.groundTrace.surfaceFlags & SURF_SLICK ) || pm->ps->pm_flags & PMF_TIME_KNOCKBACK )
+	{
+		accelerate = pm_airaccelerate;
+	}
+	else
+	{
+		accelerate = pm_accelerate;
+	}
+
+	PM_Accelerate (wishdir, wishspeed, accelerate);
+	/*
+	if (pm->ps->clientNum >= MAX_CLIENTS)
+	{
+#ifdef QAGAME
+		Com_Printf("^1S: %f, %f\n", wishspeed, pm->ps->speed);
+#else
+		Com_Printf("^2C: %f, %f\n", wishspeed, pm->ps->speed);
+#endif
+	}
+	*/
+
+	//Com_Printf("velocity = %1.1f %1.1f %1.1f\n", pm->ps->velocity[0], pm->ps->velocity[1], pm->ps->velocity[2]);
+	//Com_Printf("velocity1 = %1.1f\n", VectorLength(pm->ps->velocity));
+
+	if ( ( pml.groundTrace.surfaceFlags & SURF_SLICK ) || pm->ps->pm_flags & PMF_TIME_KNOCKBACK )
+	{
+		pm->ps->velocity[2] -= pm->ps->gravity * pml.frametime;
+	}
+
+	vel = VectorLength(pm->ps->velocity);
+
+	// slide along the ground plane
+	PM_ClipVelocity (pm->ps->velocity, pml.groundTrace.plane.normal, 
+		pm->ps->velocity, OVERCLIP );
+
+	// don't decrease velocity when going up or down a slope
+	VectorNormalize(pm->ps->velocity);
+	VectorScale(pm->ps->velocity, vel, pm->ps->velocity);
+
+	// don't do anything if standing still
+	if (!pm->ps->velocity[0] && !pm->ps->velocity[1]) {
+		return;
+	}
+
+	PM_StepSlideMove( qfalse );
+
+	//Com_Printf("velocity2 = %1.1f\n", VectorLength(pm->ps->velocity));
+}
+
+
+/*
+==============
+PM_DeadMove
+==============
+*/
+static void PM_DeadMove( void ) {
+	float	forward;
+
+	if ( !pml.walking ) {
+		return;
+	}
+
+	// extra friction
+
+	forward = VectorLength (pm->ps->velocity);
+	forward -= 20;
+	if ( forward <= 0 ) {
+		VectorClear (pm->ps->velocity);
+	} else {
+		VectorNormalize (pm->ps->velocity);
+		VectorScale (pm->ps->velocity, forward, pm->ps->velocity);
+	}
+}
+
+
+/*
+===============
+PM_NoclipMove
+===============
+*/
+static void PM_NoclipMove( void ) {
+	float	speed, drop, friction, control, newspeed;
+	int			i;
+	vec3_t		wishvel;
+	float		fmove, smove;
+	vec3_t		wishdir;
+	float		wishspeed;
+	float		scale;
+
+	pm->ps->viewheight = DEFAULT_VIEWHEIGHT;
+
+	// friction
+
+	speed = VectorLength (pm->ps->velocity);
+	if (speed < 1)
+	{
+		VectorCopy (vec3_origin, pm->ps->velocity);
+	}
+	else
+	{
+		drop = 0;
+
+		friction = pm_friction*1.5;	// extra friction
+		control = speed < pm_stopspeed ? pm_stopspeed : speed;
+		drop += control*friction*pml.frametime;
+
+		// scale the velocity
+		newspeed = speed - drop;
+		if (newspeed < 0)
+			newspeed = 0;
+		newspeed /= speed;
+
+		VectorScale (pm->ps->velocity, newspeed, pm->ps->velocity);
+	}
+
+	// accelerate
+	scale = PM_CmdScale( &pm->cmd );
+	if (pm->cmd.buttons & BUTTON_ATTACK) {	//turbo boost
+		scale *= 10;
+	}
+	if (pm->cmd.buttons & BUTTON_ALT_ATTACK) {	//turbo boost
+		scale *= 10;
+	}
+
+	fmove = pm->cmd.forwardmove;
+	smove = pm->cmd.rightmove;
+	
+	for (i=0 ; i<3 ; i++)
+		wishvel[i] = pml.forward[i]*fmove + pml.right[i]*smove;
+	wishvel[2] += pm->cmd.upmove;
+
+	VectorCopy (wishvel, wishdir);
+	wishspeed = VectorNormalize(wishdir);
+	wishspeed *= scale;
+
+	PM_Accelerate( wishdir, wishspeed, pm_accelerate );
+
+	// move
+	VectorMA (pm->ps->origin, pml.frametime, pm->ps->velocity, pm->ps->origin);
+}
+
+//============================================================================
+
+/*
+================
+PM_FootstepForSurface
+
+Returns an event number apropriate for the groundsurface
+================
+*/
+static int PM_FootstepForSurface( void )
+{
+	if ( pml.groundTrace.surfaceFlags & SURF_NOSTEPS ) 
+	{
+		return 0;
+	}
+	return ( pml.groundTrace.surfaceFlags & MATERIAL_MASK );
+}
+
+extern qboolean PM_CanRollFromSoulCal( playerState_t *ps );
+static int PM_TryRoll( void )
+{
+	trace_t	trace;
+	int		anim = -1;
+	vec3_t fwd, right, traceto, mins, maxs, fwdAngles;
+
+	if ( BG_SaberInAttack( pm->ps->saberMove ) || BG_SaberInSpecialAttack( pm->ps->torsoAnim ) 
+		|| BG_SpinningSaberAnim( pm->ps->legsAnim ) 
+		|| PM_SaberInStart( pm->ps->saberMove ) )
+	{//attacking or spinning (or, if player, starting an attack)
+		if ( PM_CanRollFromSoulCal( pm->ps ) )
+		{//hehe
+		}
+		else
+		{
+			return 0;
+		}
+	}
+
+	if ((pm->ps->weapon != WP_SABER && pm->ps->weapon != WP_MELEE) ||
+		PM_IsRocketTrooper() ||
+		BG_HasYsalamiri(pm->gametype, pm->ps) ||
+		!BG_CanUseFPNow(pm->gametype, pm->ps, pm->cmd.serverTime, FP_LEVITATION))
+	{ //Not using saber, or can't use jump
+		return 0;
+	}
+
+	VectorSet(mins, pm->mins[0],pm->mins[1],pm->mins[2]+STEPSIZE);
+	VectorSet(maxs, pm->maxs[0],pm->maxs[1],pm->ps->crouchheight);
+
+	VectorSet(fwdAngles, 0, pm->ps->viewangles[YAW], 0);
+
+	AngleVectors( fwdAngles, fwd, right, NULL );
+
+	if ( pm->cmd.forwardmove )
+	{ //check forward/backward rolls
+		if ( pm->ps->pm_flags & PMF_BACKWARDS_RUN ) 
+		{
+			anim = BOTH_ROLL_B;
+			VectorMA( pm->ps->origin, -64, fwd, traceto );
+		}
+		else
+		{
+			anim = BOTH_ROLL_F;
+			VectorMA( pm->ps->origin, 64, fwd, traceto );
+		}
+	}
+	else if ( pm->cmd.rightmove > 0 )
+	{ //right
+		anim = BOTH_ROLL_R;
+		VectorMA( pm->ps->origin, 64, right, traceto );
+	}
+	else if ( pm->cmd.rightmove < 0 )
+	{ //left
+		anim = BOTH_ROLL_L;
+		VectorMA( pm->ps->origin, -64, right, traceto );
+	}
+
+	if ( anim != -1 )
+	{ //We want to roll. Perform a trace to see if we can, and if so, send us into one.
+		pm->trace( &trace, pm->ps->origin, mins, maxs, traceto, pm->ps->clientNum, CONTENTS_SOLID );
+		if ( trace.fraction >= 1.0f )
+		{
+			pm->ps->saberMove = LS_NONE;
+			return anim;
+		}
+	}
+	return 0;
+}
+
+#ifdef QAGAME
+static void PM_CrashLandEffect( void )
+{
+	float delta;
+	if ( pm->waterlevel )
+	{
+		return;
+	}
+	delta = fabs(pml.previous_velocity[2])/10;//VectorLength( pml.previous_velocity );?
+	if ( delta >= 30 ) 
+	{
+		vec3_t bottom;
+		int	effectID = -1;
+		int material = (pml.groundTrace.surfaceFlags&MATERIAL_MASK);
+		VectorSet( bottom, pm->ps->origin[0],pm->ps->origin[1],pm->ps->origin[2]+pm->mins[2]+1 );
+		switch ( material )
+		{
+		case MATERIAL_MUD:
+			effectID = EFFECT_LANDING_MUD;
+			break;
+		case MATERIAL_SAND:			
+			effectID = EFFECT_LANDING_SAND;
+			break;
+		case MATERIAL_DIRT:
+			effectID = EFFECT_LANDING_DIRT;
+			break;
+		case MATERIAL_SNOW:			
+			effectID = EFFECT_LANDING_SNOW;
+			break;
+		case MATERIAL_GRAVEL:
+			effectID = EFFECT_LANDING_GRAVEL;
+			break;
+		}
+
+		if ( effectID != -1 )
+		{
+			G_PlayEffect( effectID, bottom, pml.groundTrace.plane.normal );
+		}
+	}
+}
+#endif
+/*
+=================
+PM_CrashLand
+
+Check for hard landings that generate sound events
+=================
+*/
+static void PM_CrashLand( void ) {
+	float		delta;
+	float		dist;
+	float		vel, acc;
+	float		t;
+	float		a, b, c, den;
+	qboolean	didRoll = qfalse;
+
+	// calculate the exact velocity on landing
+	dist = pm->ps->origin[2] - pml.previous_origin[2];
+	vel = pml.previous_velocity[2];
+	acc = -pm->ps->gravity;
+
+	a = acc / 2;
+	b = vel;
+	c = -dist;
+
+	den =  b * b - 4 * a * c;
+	if ( den < 0 ) {
+		pm->ps->inAirAnim = qfalse;
+		return;
+	}
+	t = (-b - sqrt( den ) ) / ( 2 * a );
+
+	delta = vel + t * acc;
+	delta = delta*delta * 0.0001;
+
+#ifdef QAGAME
+	PM_CrashLandEffect();
+#endif
+	// ducking while falling doubles damage
+	if ( pm->ps->pm_flags & PMF_DUCKED ) {
+		delta *= 2;
+	}
+
+	if (pm->ps->legsAnim == BOTH_A7_KICK_F_AIR ||
+		pm->ps->legsAnim == BOTH_A7_KICK_B_AIR ||
+		pm->ps->legsAnim == BOTH_A7_KICK_R_AIR ||
+		pm->ps->legsAnim == BOTH_A7_KICK_L_AIR)
+	{
+		int landAnim = -1;
+		switch ( pm->ps->legsAnim )
+		{
+		case BOTH_A7_KICK_F_AIR:
+			landAnim = BOTH_FORCELAND1;
+			break;
+		case BOTH_A7_KICK_B_AIR:
+			landAnim = BOTH_FORCELANDBACK1;
+			break;
+		case BOTH_A7_KICK_R_AIR:
+			landAnim = BOTH_FORCELANDRIGHT1;
+			break;
+		case BOTH_A7_KICK_L_AIR:
+			landAnim = BOTH_FORCELANDLEFT1;
+			break;
+		}
+		if ( landAnim != -1 )
+		{
+			if ( pm->ps->torsoAnim == pm->ps->legsAnim )
+			{
+				PM_SetAnim(SETANIM_BOTH, landAnim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD, 0);
+			}
+			else
+			{
+				PM_SetAnim(SETANIM_LEGS, landAnim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD, 0);
+			}
+		}
+	}
+	else if (pm->ps->legsAnim == BOTH_FORCEJUMPLEFT1 ||
+			pm->ps->legsAnim == BOTH_FORCEJUMPRIGHT1 ||
+			pm->ps->legsAnim == BOTH_FORCEJUMPBACK1 ||
+			pm->ps->legsAnim == BOTH_FORCEJUMP1)
+	{
+		int fjAnim;
+		switch (pm->ps->legsAnim)
+		{
+		case BOTH_FORCEJUMPLEFT1:
+			fjAnim = BOTH_LANDLEFT1;
+			break;
+		case BOTH_FORCEJUMPRIGHT1:
+			fjAnim = BOTH_LANDRIGHT1;
+			break;
+		case BOTH_FORCEJUMPBACK1:
+			fjAnim = BOTH_LANDBACK1;
+			break;
+		default:
+			fjAnim = BOTH_LAND1;
+			break;
+		}
+		PM_SetAnim(SETANIM_BOTH, fjAnim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD, 0);
+	}
+	// decide which landing animation to use
+	else if (!BG_InRoll(pm->ps, pm->ps->legsAnim) && pm->ps->inAirAnim && !pm->ps->m_iVehicleNum)
+	{ //only play a land animation if we transitioned into an in-air animation while off the ground
+		if (!BG_SaberInSpecial(pm->ps->saberMove))
+		{
+			if ( pm->ps->pm_flags & PMF_BACKWARDS_JUMP ) {
+				PM_ForceLegsAnim( BOTH_LANDBACK1 );
+			} else {
+				PM_ForceLegsAnim( BOTH_LAND1 );
+			}
+		}
+	}
+
+	if (pm->ps->weapon != WP_SABER && pm->ps->weapon != WP_MELEE && !PM_IsRocketTrooper())
+	{ //saber handles its own anims
+		//This will push us back into our weaponready stance from the land anim.
+		if (pm->ps->weapon == WP_DISRUPTOR && pm->ps->zoomMode == 1)
+		{
+			PM_StartTorsoAnim( TORSO_WEAPONREADY4 );
+		}
+		else
+		{
+			if (pm->ps->weapon == WP_EMPLACED_GUN)
+			{
+				PM_StartTorsoAnim( BOTH_GUNSIT1 );
+			}
+			else
+			{
+				PM_StartTorsoAnim( WeaponReadyAnim[pm->ps->weapon] );
+			}
+		}
+	}
+
+	if (!BG_InSpecialJump(pm->ps->legsAnim) ||
+		pm->ps->legsTimer < 1 ||
+		(pm->ps->legsAnim) == BOTH_WALL_RUN_LEFT ||
+		(pm->ps->legsAnim) == BOTH_WALL_RUN_RIGHT)
+	{ //Only set the timer if we're in an anim that can be interrupted (this would not be, say, a flip)
+		if (!BG_InRoll(pm->ps, pm->ps->legsAnim) && pm->ps->inAirAnim)
+		{
+			if (!BG_SaberInSpecial(pm->ps->saberMove) || pm->ps->weapon != WP_SABER)
+			{
+				if (pm->ps->legsAnim != BOTH_FORCELAND1 &&
+					pm->ps->legsAnim != BOTH_FORCELANDBACK1 &&
+					pm->ps->legsAnim != BOTH_FORCELANDRIGHT1 &&
+					pm->ps->legsAnim != BOTH_FORCELANDLEFT1)
+				{ //don't override if we have started a force land
+					pm->ps->legsTimer = TIMER_LAND;
+				}
+			}
+		}
+	}
+
+	pm->ps->inAirAnim = qfalse;
+
+	if (pm->ps->m_iVehicleNum)
+	{ //don't do fall stuff while on a vehicle
+		return;
+	}
+
+	// never take falling damage if completely underwater
+	if ( pm->waterlevel == 3 ) {
+		return;
+	}
+
+	// reduce falling damage if there is standing water
+	if ( pm->waterlevel == 2 ) {
+		delta *= 0.25;
+	}
+	if ( pm->waterlevel == 1 ) {
+		delta *= 0.5;
+	}
+
+	if ( delta < 1 ) {
+		return;
+	}
+
+	if ( pm->ps->pm_flags & PMF_DUCKED ) 
+	{
+		if( delta >= 2 && !PM_InOnGroundAnim( pm->ps->legsAnim ) && !PM_InKnockDown( pm->ps ) && !BG_InRoll(pm->ps, pm->ps->legsAnim) &&
+			pm->ps->forceHandExtend == HANDEXTEND_NONE )
+		{//roll!
+			int anim = PM_TryRoll();
+
+			if (PM_InRollComplete(pm->ps, pm->ps->legsAnim))
+			{
+				anim = 0;
+				pm->ps->legsTimer = 0;
+				pm->ps->legsAnim = 0;
+				PM_SetAnim(SETANIM_BOTH,BOTH_LAND1,SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD, 150);
+				pm->ps->legsTimer = TIMER_LAND;
+			}
+
+			if ( anim )
+			{//absorb some impact
+				pm->ps->legsTimer = 0;
+				delta /= 3; // /= 2 just cancels out the above delta *= 2 when landing while crouched, the roll itself should absorb a little damage
+				pm->ps->legsAnim = 0;
+				if (pm->ps->torsoAnim == BOTH_A7_SOULCAL)
+				{ //get out of it on torso
+					pm->ps->torsoTimer = 0;
+				}
+				PM_SetAnim(SETANIM_BOTH,anim,SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD, 150);
+				didRoll = qtrue;
+			}
+		}
+	}
+
+	// SURF_NODAMAGE is used for bounce pads where you don't ever
+	// want to take damage or play a crunch sound
+	if ( !(pml.groundTrace.surfaceFlags & SURF_NODAMAGE) )  {
+		if (delta > 7)
+		{
+			int delta_send = (int)delta;
+
+			if (delta_send > 600)
+			{ //will never need to know any value above this
+				delta_send = 600;
+			}
+
+			if (pm->ps->fd.forceJumpZStart)
+			{
+				if ((int)pm->ps->origin[2] >= (int)pm->ps->fd.forceJumpZStart)
+				{ //was force jumping, landed on higher or same level as when force jump was started
+					if (delta_send > 8)
+					{
+						delta_send = 8;
+					}
+				}
+				else
+				{
+					if (delta_send > 8)
+					{
+						int dif = ((int)pm->ps->fd.forceJumpZStart - (int)pm->ps->origin[2]);
+						int dmgLess = (forceJumpHeight[pm->ps->fd.forcePowerLevel[FP_LEVITATION]] - dif);
+
+						if (dmgLess < 0)
+						{
+							dmgLess = 0;
+						}
+
+						delta_send -= (dmgLess*0.3);
+
+						if (delta_send < 8)
+						{
+							delta_send = 8;
+						}
+
+						//Com_Printf("Damage sub: %i\n", (int)((dmgLess*0.1)));
+					}
+				}
+			}
+
+			if (didRoll)
+			{ //Add the appropriate event..
+				PM_AddEventWithParm( EV_ROLL, delta_send );
+			}
+			else
+			{
+				PM_AddEventWithParm( EV_FALL, delta_send );
+			}
+		}
+		else
+		{
+			if (didRoll)
+			{
+				PM_AddEventWithParm( EV_ROLL, 0 );
+			}
+			else
+			{
+				PM_AddEventWithParm( EV_FOOTSTEP, PM_FootstepForSurface() );
+			}
+		}
+	}
+
+	// make sure velocity resets so we don't bounce back up again in case we miss the clear elsewhere
+	pm->ps->velocity[2] = 0;
+
+	// start footstep cycle over
+	pm->ps->bobCycle = 0;
+}
+
+/*
+=============
+PM_CorrectAllSolid
+=============
+*/
+static int PM_CorrectAllSolid( trace_t *trace ) {
+	int			i, j, k;
+	vec3_t		point;
+
+	if ( pm->debugLevel ) {
+		Com_Printf("%i:allsolid\n", c_pmove);
+	}
+
+	// jitter around
+	for (i = -1; i <= 1; i++) {
+		for (j = -1; j <= 1; j++) {
+			for (k = -1; k <= 1; k++) {
+				VectorCopy(pm->ps->origin, point);
+				point[0] += (float) i;
+				point[1] += (float) j;
+				point[2] += (float) k;
+				pm->trace (trace, point, pm->mins, pm->maxs, point, pm->ps->clientNum, pm->tracemask);
+				if ( !trace->allsolid ) {
+					point[0] = pm->ps->origin[0];
+					point[1] = pm->ps->origin[1];
+					point[2] = pm->ps->origin[2] - 0.25;
+
+					pm->trace (trace, pm->ps->origin, pm->mins, pm->maxs, point, pm->ps->clientNum, pm->tracemask);
+					pml.groundTrace = *trace;
+					return qtrue;
+				}
+			}
+		}
+	}
+
+	pm->ps->groundEntityNum = ENTITYNUM_NONE;
+	pml.groundPlane = qfalse;
+	pml.walking = qfalse;
+
+	return qfalse;
+}
+
+/*
+=============
+PM_GroundTraceMissed
+
+The ground trace didn't hit a surface, so we are in freefall
+=============
+*/
+static void PM_GroundTraceMissed( void ) {
+	trace_t		trace;
+	vec3_t		point;
+
+	//rww - don't want to do this when handextend_choke, because you can be standing on the ground
+	//while still holding your throat.
+	if ( pm->ps->pm_type == PM_FLOAT ) 
+	{
+		//we're assuming this is because you're being choked
+		int parts = SETANIM_LEGS;
+
+		//rww - also don't use SETANIM_FLAG_HOLD, it will cause the legs to float around a bit before going into
+		//a proper anim even when on the ground.
+		PM_SetAnim(parts, BOTH_CHOKE3, SETANIM_FLAG_OVERRIDE, 100);
+	}
+	else if ( pm->ps->pm_type == PM_JETPACK ) 
+	{//jetpacking
+		//rww - also don't use SETANIM_FLAG_HOLD, it will cause the legs to float around a bit before going into
+		//a proper anim even when on the ground.
+		//PM_SetAnim(SETANIM_LEGS,BOTH_FORCEJUMP1,SETANIM_FLAG_OVERRIDE, 100);
+	}
+	//If the anim is choke3, act like we just went into the air because we aren't in a float
+	else if ( pm->ps->groundEntityNum != ENTITYNUM_NONE || (pm->ps->legsAnim) == BOTH_CHOKE3 ) 
+	{
+		// we just transitioned into freefall
+		if ( pm->debugLevel ) {
+			Com_Printf("%i:lift\n", c_pmove);
+		}
+
+		// if they aren't in a jumping animation and the ground is a ways away, force into it
+		// if we didn't do the trace, the player would be backflipping down staircases
+		VectorCopy( pm->ps->origin, point );
+		point[2] -= 64;
+
+		pm->trace (&trace, pm->ps->origin, pm->mins, pm->maxs, point, pm->ps->clientNum, pm->tracemask);
+		if ( trace.fraction == 1.0 || pm->ps->pm_type == PM_FLOAT ) {
+			if ( pm->ps->velocity[2] <= 0 && !(pm->ps->pm_flags&PMF_JUMP_HELD))
+			{
+				//PM_SetAnim(SETANIM_LEGS,BOTH_INAIR1,SETANIM_FLAG_OVERRIDE, 100);
+				PM_SetAnim(SETANIM_LEGS,BOTH_INAIR1,0, 100);
+				pm->ps->pm_flags &= ~PMF_BACKWARDS_JUMP;
+			}
+			else if ( pm->cmd.forwardmove >= 0 ) 
+			{
+				PM_SetAnim(SETANIM_LEGS,BOTH_JUMP1,SETANIM_FLAG_OVERRIDE, 100);
+				pm->ps->pm_flags &= ~PMF_BACKWARDS_JUMP;
+			} 
+			else 
+			{
+				PM_SetAnim(SETANIM_LEGS,BOTH_JUMPBACK1,SETANIM_FLAG_OVERRIDE, 100);
+				pm->ps->pm_flags |= PMF_BACKWARDS_JUMP;
+			}
+
+			pm->ps->inAirAnim = qtrue;
+		}
+	}
+	else if (!pm->ps->inAirAnim)
+	{
+		// if they aren't in a jumping animation and the ground is a ways away, force into it
+		// if we didn't do the trace, the player would be backflipping down staircases
+		VectorCopy( pm->ps->origin, point );
+		point[2] -= 64;
+
+		pm->trace (&trace, pm->ps->origin, pm->mins, pm->maxs, point, pm->ps->clientNum, pm->tracemask);
+		if ( trace.fraction == 1.0 || pm->ps->pm_type == PM_FLOAT )
+		{
+			pm->ps->inAirAnim = qtrue;
+		}
+	}
+
+	if (PM_InRollComplete(pm->ps, pm->ps->legsAnim))
+	{ //Client won't catch an animation restart because it only checks frame against incoming frame, so if you roll when you land after rolling
+	  //off of something it won't replay the roll anim unless we switch it off in the air. This fixes that.
+		PM_SetAnim(SETANIM_BOTH,BOTH_INAIR1,SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD, 150);
+		pm->ps->inAirAnim = qtrue;
+	}
+
+	pm->ps->groundEntityNum = ENTITYNUM_NONE;
+	pml.groundPlane = qfalse;
+	pml.walking = qfalse;
+}
+
+
+/*
+=============
+PM_GroundTrace
+=============
+*/
+static void PM_GroundTrace( void ) {
+	vec3_t		point;
+	trace_t		trace;
+	float minNormal = (float)MIN_WALK_NORMAL;
+
+	if ( pm->ps->clientNum >= MAX_CLIENTS)
+	{
+		bgEntity_t *pEnt = pm_entSelf;
+
+		if (pEnt && pEnt->s.NPC_class == CLASS_VEHICLE)
+		{
+			minNormal = pEnt->m_pVehicle->m_pVehicleInfo->maxSlope;
+		}
+	}
+
+	point[0] = pm->ps->origin[0];
+	point[1] = pm->ps->origin[1];
+	point[2] = pm->ps->origin[2] - 0.25;
+
+	pm->trace (&trace, pm->ps->origin, pm->mins, pm->maxs, point, pm->ps->clientNum, pm->tracemask);
+	pml.groundTrace = trace;
+
+	// do something corrective if the trace starts in a solid...
+	if ( trace.allsolid ) {
+		if ( !PM_CorrectAllSolid(&trace) )
+			return;
+	}
+
+	if (pm->ps->pm_type == PM_FLOAT || pm->ps->pm_type == PM_JETPACK)
+	{
+		PM_GroundTraceMissed();
+		pml.groundPlane = qfalse;
+		pml.walking = qfalse;
+		return;
+	}
+
+	// if the trace didn't hit anything, we are in free fall
+	if ( trace.fraction == 1.0 ) {
+		PM_GroundTraceMissed();
+		pml.groundPlane = qfalse;
+		pml.walking = qfalse;
+		return;
+	}
+
+	// check if getting thrown off the ground
+	if ( pm->ps->velocity[2] > 0 && DotProduct( pm->ps->velocity, trace.plane.normal ) > 10 ) {
+		if ( pm->debugLevel ) {
+			Com_Printf("%i:kickoff\n", c_pmove);
+		}
+		// go into jump animation
+		if ( pm->cmd.forwardmove >= 0 ) {
+			PM_ForceLegsAnim( BOTH_JUMP1 );
+			pm->ps->pm_flags &= ~PMF_BACKWARDS_JUMP;
+		} else {
+			PM_ForceLegsAnim( BOTH_JUMPBACK1 );
+			pm->ps->pm_flags |= PMF_BACKWARDS_JUMP;
+		}
+
+		pm->ps->groundEntityNum = ENTITYNUM_NONE;
+		pml.groundPlane = qfalse;
+		pml.walking = qfalse;
+		return;
+	}
+	
+	// slopes that are too steep will not be considered onground
+	if ( trace.plane.normal[2] < minNormal ) {
+		if ( pm->debugLevel ) {
+			Com_Printf("%i:steep\n", c_pmove);
+		}
+		pm->ps->groundEntityNum = ENTITYNUM_NONE;
+		pml.groundPlane = qtrue;
+		pml.walking = qfalse;
+		return;
+	}
+
+	pml.groundPlane = qtrue;
+	pml.walking = qtrue;
+
+	// hitting solid ground will end a waterjump
+	if (pm->ps->pm_flags & PMF_TIME_WATERJUMP)
+	{
+		pm->ps->pm_flags &= ~(PMF_TIME_WATERJUMP | PMF_TIME_LAND);
+		pm->ps->pm_time = 0;
+	}
+
+	if ( pm->ps->groundEntityNum == ENTITYNUM_NONE ) {
+		// just hit the ground
+		if ( pm->debugLevel ) {
+			Com_Printf("%i:Land\n", c_pmove);
+		}
+		
+		PM_CrashLand();
+
+#ifdef QAGAME
+		if (pm->ps->clientNum < MAX_CLIENTS &&
+			!pm->ps->m_iVehicleNum &&
+			trace.entityNum < ENTITYNUM_WORLD &&
+			trace.entityNum >= MAX_CLIENTS &&
+			!pm->ps->zoomMode &&
+			pm_entSelf)
+		{ //check if we landed on a vehicle
+			gentity_t *trEnt = &g_entities[trace.entityNum];
+			if (trEnt->inuse && trEnt->client && trEnt->s.eType == ET_NPC && trEnt->s.NPC_class == CLASS_VEHICLE &&
+				!trEnt->client->ps.m_iVehicleNum &&
+				trEnt->m_pVehicle &&
+				trEnt->m_pVehicle->m_pVehicleInfo->type != VH_WALKER &&
+				trEnt->m_pVehicle->m_pVehicleInfo->type != VH_FIGHTER)
+			{ //it's a vehicle alright, let's board it.. if it's not an atst or ship
+				if (!BG_SaberInSpecial(pm->ps->saberMove) &&
+					pm->ps->forceHandExtend == HANDEXTEND_NONE &&
+					pm->ps->weaponTime <= 0)
+				{
+					gentity_t *servEnt = (gentity_t *)pm_entSelf;
+					if (g_gametype.integer < GT_TEAM ||
+						!trEnt->alliedTeam ||
+						(trEnt->alliedTeam == servEnt->client->sess.sessionTeam))
+					{ //not belonging to a team, or client is on same team
+						trEnt->m_pVehicle->m_pVehicleInfo->Board(trEnt->m_pVehicle, pm_entSelf);
+					}
+				}
+			}
+		}
+#endif
+
+		// don't do landing time if we were just going down a slope
+		if ( pml.previous_velocity[2] < -200 ) {
+			// don't allow another jump for a little while
+			pm->ps->pm_flags |= PMF_TIME_LAND;
+			pm->ps->pm_time = 250;
+		}
+	}
+
+	pm->ps->groundEntityNum = trace.entityNum;
+	pm->ps->lastOnGround = pm->cmd.serverTime;
+
+	PM_AddTouchEnt( trace.entityNum );	
+}
+
+
+/*
+=============
+PM_SetWaterLevel
+=============
+*/
+static void PM_SetWaterLevel( void ) {
+	vec3_t		point;
+	int			cont;
+	int			sample1;
+	int			sample2;
+
+	//
+	// get waterlevel, accounting for ducking
+	//
+	pm->waterlevel = 0;
+	pm->watertype = 0;
+
+	point[0] = pm->ps->origin[0];
+	point[1] = pm->ps->origin[1];
+	point[2] = pm->ps->origin[2] + MINS_Z + 1;	
+	cont = pm->pointcontents( point, pm->ps->clientNum );
+
+	if ( cont & MASK_WATER ) {
+		sample2 = pm->ps->viewheight - MINS_Z;
+		sample1 = sample2 / 2;
+
+		pm->watertype = cont;
+		pm->waterlevel = 1;
+		point[2] = pm->ps->origin[2] + MINS_Z + sample1;
+		cont = pm->pointcontents (point, pm->ps->clientNum );
+		if ( cont & MASK_WATER ) {
+			pm->waterlevel = 2;
+			point[2] = pm->ps->origin[2] + MINS_Z + sample2;
+			cont = pm->pointcontents (point, pm->ps->clientNum );
+			if ( cont & MASK_WATER ){
+				pm->waterlevel = 3;
+			}
+		}
+	}
+
+}
+
+qboolean PM_CheckDualForwardJumpDuck( void )
+{
+	qboolean resized = qfalse;
+	if ( pm->ps->legsAnim == BOTH_JUMPATTACK6 )
+	{
+		//dynamically reduce bounding box to let character sail over heads of enemies
+		if ( ( pm->ps->legsTimer >= 1450
+				&& PM_AnimLength( 0, BOTH_JUMPATTACK6 ) - pm->ps->legsTimer >= 400 ) 
+			||(pm->ps->legsTimer >= 400
+				&& PM_AnimLength( 0, BOTH_JUMPATTACK6 ) - pm->ps->legsTimer >= 1100 ) )
+		{//in a part of the anim that we're pretty much sideways in, raise up the mins
+			pm->mins[2] = 0;
+			pm->ps->pm_flags |= PMF_FIX_MINS;
+			resized = qtrue;
+		}
+	}
+	return resized;
+}
+
+void PM_CheckFixMins( void )
+{
+	if ( (pm->ps->pm_flags&PMF_FIX_MINS) )// pm->mins[2] > DEFAULT_MINS_2 )
+	{//drop the mins back down
+		//do a trace to make sure it's okay
+		trace_t	trace;
+		vec3_t end, curMins, curMaxs;
+	
+		VectorSet( end, pm->ps->origin[0], pm->ps->origin[1], pm->ps->origin[2]+MINS_Z ); 
+		VectorSet( curMins, pm->mins[0], pm->mins[1], 0 ); 
+		VectorSet( curMaxs, pm->maxs[0], pm->maxs[1], pm->ps->standheight ); 
+
+		pm->trace( &trace, pm->ps->origin, curMins, curMaxs, end, pm->ps->clientNum, pm->tracemask );
+		if ( !trace.allsolid && !trace.startsolid )
+		{//should never start in solid
+			if ( trace.fraction >= 1.0f )
+			{//all clear
+				//drop the bottom of my bbox back down
+				pm->mins[2] = MINS_Z;
+				pm->ps->pm_flags &= ~PMF_FIX_MINS;
+			}
+			else
+			{//move me up so the bottom of my bbox will be where the trace ended, at least
+				//need to trace up, too
+				float updist = ((1.0f-trace.fraction) * -MINS_Z);
+				end[2] = pm->ps->origin[2]+updist; 
+				pm->trace( &trace, pm->ps->origin, curMins, curMaxs, end, pm->ps->clientNum, pm->tracemask );
+				if ( !trace.allsolid && !trace.startsolid )
+				{//should never start in solid
+					if ( trace.fraction >= 1.0f )
+					{//all clear
+						//move me up
+						pm->ps->origin[2] += updist;
+						//drop the bottom of my bbox back down
+						pm->mins[2] = MINS_Z;
+						pm->ps->pm_flags &= ~PMF_FIX_MINS;
+					}
+					else
+					{//crap, no room to expand, so just crouch us
+						if ( pm->ps->legsAnim != BOTH_JUMPATTACK6
+							|| pm->ps->legsTimer <= 200 )
+						{//at the end of the anim, and we can't leave ourselves like this
+							//so drop the maxs, put the mins back and move us up
+							pm->maxs[2] += MINS_Z;
+							pm->ps->origin[2] -= MINS_Z;
+							pm->mins[2] = MINS_Z;
+							//this way we'll be in a crouch when we're done
+							if ( pm->ps->legsAnim == BOTH_JUMPATTACK6 )
+							{
+								pm->ps->legsTimer = pm->ps->torsoTimer = 0;
+							}
+							pm->ps->pm_flags |= PMF_DUCKED;
+							//FIXME: do we need to set a crouch anim here?
+							pm->ps->pm_flags &= ~PMF_FIX_MINS;
+						}
+					}
+				}//crap, stuck
+			}
+		}//crap, stuck!
+	}
+}
+
+/*
+==============
+PM_CheckDuck
+
+Sets mins, maxs, and pm->ps->viewheight
+==============
+*/
+static void PM_CheckDuck (void)
+{
+	trace_t	trace;
+
+	if ( pm->ps->m_iVehicleNum > 0 && pm->ps->m_iVehicleNum < ENTITYNUM_NONE )
+	{//riding a vehicle or are a vehicle
+		//no ducking or rolling when on a vehicle
+		//right?  not even on ones that you just ride on top of?
+		pm->ps->pm_flags &= ~PMF_DUCKED;
+		pm->ps->pm_flags &= ~PMF_ROLLING;
+		//NOTE: we don't clear the pm->cmd.upmove here because 
+		//the vehicle code may need it later... but, for riders,
+		//it should have already been copied over to the vehicle, right?
+
+		if (pm->ps->clientNum >= MAX_CLIENTS)
+		{
+			return;
+		}
+		if (pm_entVeh && pm_entVeh->m_pVehicle &&
+			(pm_entVeh->m_pVehicle->m_pVehicleInfo->type == VH_SPEEDER ||
+			 pm_entVeh->m_pVehicle->m_pVehicleInfo->type == VH_ANIMAL))
+		{
+			trace_t solidTr;
+
+			pm->mins[0] = -16;
+			pm->mins[1] = -16;
+			pm->mins[2] = MINS_Z;
+
+			pm->maxs[0] = 16;
+			pm->maxs[1] = 16;
+			pm->maxs[2] = pm->ps->standheight;//DEFAULT_MAXS_2;
+			pm->ps->viewheight = DEFAULT_VIEWHEIGHT;
+
+			pm->trace (&solidTr, pm->ps->origin, pm->mins, pm->maxs, pm->ps->origin, pm->ps->m_iVehicleNum, pm->tracemask);
+			if (solidTr.startsolid || solidTr.allsolid || solidTr.fraction != 1.0f)
+			{ //whoops, can't fit here. Down to 0!
+				VectorClear(pm->mins);
+				VectorClear(pm->maxs);
+#ifdef QAGAME
+				{
+					gentity_t *me = &g_entities[pm->ps->clientNum];
+					if (me->inuse && me->client)
+					{ //yeah, this is a really terrible hack.
+						me->client->solidHack = level.time + 200;
+					}
+				}
+#endif
+			}
+		}
+	}
+	else
+	{
+		if (pm->ps->clientNum < MAX_CLIENTS)
+		{
+			pm->mins[0] = -15;
+			pm->mins[1] = -15;
+
+			pm->maxs[0] = 15;
+			pm->maxs[1] = 15;
+		}
+
+		if ( PM_CheckDualForwardJumpDuck() )
+		{//special anim resizing us
+		}
+		else
+		{
+			PM_CheckFixMins();
+
+			if ( !pm->mins[2] )
+			{
+				pm->mins[2] = MINS_Z;
+			}
+		}
+
+		if (pm->ps->pm_type == PM_DEAD && pm->ps->clientNum < MAX_CLIENTS)
+		{
+			pm->maxs[2] = -8;
+			pm->ps->viewheight = DEAD_VIEWHEIGHT;
+			return;
+		}
+
+		if (BG_InRoll(pm->ps, pm->ps->legsAnim) && !BG_KickingAnim(pm->ps->legsAnim))
+		{
+			pm->maxs[2] = pm->ps->crouchheight; //CROUCH_MAXS_2;
+			pm->ps->viewheight = DEFAULT_VIEWHEIGHT;
+			pm->ps->pm_flags &= ~PMF_DUCKED;
+			pm->ps->pm_flags |= PMF_ROLLING;
+			return;
+		}
+		else if (pm->ps->pm_flags & PMF_ROLLING)
+		{
+			// try to stand up
+			pm->maxs[2] = pm->ps->standheight;//DEFAULT_MAXS_2;
+			pm->trace (&trace, pm->ps->origin, pm->mins, pm->maxs, pm->ps->origin, pm->ps->clientNum, pm->tracemask );
+			if (!trace.allsolid)
+				pm->ps->pm_flags &= ~PMF_ROLLING;
+		}
+		else if (pm->cmd.upmove < 0 ||
+			pm->ps->forceHandExtend == HANDEXTEND_KNOCKDOWN ||
+			pm->ps->forceHandExtend == HANDEXTEND_PRETHROWN ||
+			pm->ps->forceHandExtend == HANDEXTEND_POSTTHROWN)
+		{	// duck
+			pm->ps->pm_flags |= PMF_DUCKED;
+		}
+		else
+		{	// stand up if possible 
+			if (pm->ps->pm_flags & PMF_DUCKED)
+			{
+				// try to stand up
+				pm->maxs[2] = pm->ps->standheight;//DEFAULT_MAXS_2;
+				pm->trace (&trace, pm->ps->origin, pm->mins, pm->maxs, pm->ps->origin, pm->ps->clientNum, pm->tracemask );
+				if (!trace.allsolid)
+					pm->ps->pm_flags &= ~PMF_DUCKED;
+			}
+		}
+	}
+
+	if (pm->ps->pm_flags & PMF_DUCKED)
+	{
+		pm->maxs[2] = pm->ps->crouchheight;//CROUCH_MAXS_2;
+		pm->ps->viewheight = CROUCH_VIEWHEIGHT;
+	}
+	else if (pm->ps->pm_flags & PMF_ROLLING)
+	{
+		pm->maxs[2] = pm->ps->crouchheight;//CROUCH_MAXS_2;
+		pm->ps->viewheight = DEFAULT_VIEWHEIGHT;
+	}
+	else
+	{
+		pm->maxs[2] = pm->ps->standheight;//DEFAULT_MAXS_2;
+		pm->ps->viewheight = DEFAULT_VIEWHEIGHT;
+	}
+}
+
+
+
+//===================================================================
+
+
+
+/*
+==============
+PM_Use
+
+Generates a use event
+==============
+*/
+#define USE_DELAY 2000
+
+void PM_Use( void ) 
+{
+	if ( pm->ps->useTime > 0 )
+		pm->ps->useTime -= 100;//pm->cmd.msec;
+
+	if ( pm->ps->useTime > 0 ) {
+		return;
+	}
+
+	if ( ! (pm->cmd.buttons & BUTTON_USE ) )
+	{
+		pm->useEvent = 0;
+		pm->ps->useTime = 0;
+		return;
+	}
+
+	pm->useEvent = EV_USE;
+	pm->ps->useTime = USE_DELAY;
+}
+
+qboolean PM_WalkingAnim( int anim )
+{
+	switch ( anim )
+	{
+	case BOTH_WALK1:				//# Normal walk
+	case BOTH_WALK2:				//# Normal walk with saber
+	case BOTH_WALK_STAFF:			//# Normal walk with staff
+	case BOTH_WALK_DUAL:			//# Normal walk with staff
+	case BOTH_WALK5:				//# Tavion taunting Kyle (cin 22)
+	case BOTH_WALK6:				//# Slow walk for Luke (cin 12)
+	case BOTH_WALK7:				//# Fast walk
+	case BOTH_WALKBACK1:			//# Walk1 backwards
+	case BOTH_WALKBACK2:			//# Walk2 backwards
+	case BOTH_WALKBACK_STAFF:		//# Walk backwards with staff
+	case BOTH_WALKBACK_DUAL:		//# Walk backwards with dual
+		return qtrue;
+		break;
+	}
+	return qfalse;
+}
+
+qboolean PM_RunningAnim( int anim )
+{
+	switch ( (anim) )
+	{
+	case BOTH_RUN1:			
+	case BOTH_RUN2:			
+	case BOTH_RUN_STAFF:
+	case BOTH_RUN_DUAL:
+	case BOTH_RUNBACK1:			
+	case BOTH_RUNBACK2:			
+	case BOTH_RUNBACK_STAFF:			
+	case BOTH_RUNBACK_DUAL:
+	case BOTH_RUN1START:			//# Start into full run1
+	case BOTH_RUN1STOP:			//# Stop from full run1
+	case BOTH_RUNSTRAFE_LEFT1:	//# Sidestep left: should loop
+	case BOTH_RUNSTRAFE_RIGHT1:	//# Sidestep right: should loop
+		return qtrue;
+		break;
+	}
+	return qfalse;
+}
+
+qboolean PM_SwimmingAnim( int anim )
+{
+	switch ( anim )
+	{
+	case BOTH_SWIM_IDLE1:		//# Swimming Idle 1
+	case BOTH_SWIMFORWARD:		//# Swim forward loop
+	case BOTH_SWIMBACKWARD:		//# Swim backward loop
+		return qtrue;
+		break;
+	}
+	return qfalse;
+}
+
+qboolean PM_RollingAnim( int anim )
+{
+	switch ( anim )
+	{
+	case BOTH_ROLL_F:			//# Roll forward
+	case BOTH_ROLL_B:			//# Roll backward
+	case BOTH_ROLL_L:			//# Roll left
+	case BOTH_ROLL_R:			//# Roll right
+		return qtrue;
+		break;
+	}
+	return qfalse;
+}
+
+void PM_AnglesForSlope( const float yaw, const vec3_t slope, vec3_t angles )
+{
+	vec3_t	nvf, ovf, ovr, new_angles;
+	float	pitch, mod, dot;
+
+	VectorSet( angles, 0, yaw, 0 );
+	AngleVectors( angles, ovf, ovr, NULL );
+
+	vectoangles( slope, new_angles );
+	pitch = new_angles[PITCH] + 90;
+	new_angles[ROLL] = new_angles[PITCH] = 0;
+
+	AngleVectors( new_angles, nvf, NULL, NULL );
+
+	mod = DotProduct( nvf, ovr );
+
+	if ( mod < 0 )
+		mod = -1;
+	else
+		mod = 1;
+
+	dot = DotProduct( nvf, ovf );
+
+	angles[YAW] = 0;
+	angles[PITCH] = dot * pitch;
+	angles[ROLL] = ((1-Q_fabs(dot)) * pitch * mod);
+}
+
+void PM_FootSlopeTrace( float *pDiff, float *pInterval )
+{
+	vec3_t	footLOrg, footROrg, footLBot, footRBot;
+	vec3_t footLPoint, footRPoint;
+	vec3_t footMins, footMaxs;
+	vec3_t footLSlope, footRSlope;
+
+	trace_t	trace;
+	float	diff, interval;
+
+	mdxaBone_t	boltMatrix;
+	vec3_t		G2Angles;
+	
+	VectorSet(G2Angles, 0, pm->ps->viewangles[YAW], 0);
+
+	interval = 4;//?
+
+	strap_G2API_GetBoltMatrix( pm->ghoul2, 0, pm->g2Bolts_LFoot, 
+			&boltMatrix, G2Angles, pm->ps->origin, pm->cmd.serverTime, 
+					NULL, pm->modelScale );
+	footLPoint[0] = boltMatrix.matrix[0][3];
+	footLPoint[1] = boltMatrix.matrix[1][3];
+	footLPoint[2] = boltMatrix.matrix[2][3];
+	
+	strap_G2API_GetBoltMatrix( pm->ghoul2, 0, pm->g2Bolts_RFoot, 
+					&boltMatrix, G2Angles, pm->ps->origin, pm->cmd.serverTime, 
+					NULL, pm->modelScale );
+	footRPoint[0] = boltMatrix.matrix[0][3];
+	footRPoint[1] = boltMatrix.matrix[1][3];
+	footRPoint[2] = boltMatrix.matrix[2][3];
+
+	//get these on the cgame and store it, save ourselves a ghoul2 construct skel call
+	VectorCopy( footLPoint, footLOrg );
+	VectorCopy( footRPoint, footROrg );
+
+	//step 2: adjust foot tag z height to bottom of bbox+1
+	footLOrg[2] = pm->ps->origin[2] + pm->mins[2] + 1;
+	footROrg[2] = pm->ps->origin[2] + pm->mins[2] + 1;
+	VectorSet( footLBot, footLOrg[0], footLOrg[1], footLOrg[2] - interval*10 );
+	VectorSet( footRBot, footROrg[0], footROrg[1], footROrg[2] - interval*10 );
+
+	//step 3: trace down from each, find difference
+	VectorSet( footMins, -3, -3, 0 );
+	VectorSet( footMaxs, 3, 3, 1 );
+
+	pm->trace( &trace, footLOrg, footMins, footMaxs, footLBot, pm->ps->clientNum, pm->tracemask );
+	VectorCopy( trace.endpos, footLBot );
+	VectorCopy( trace.plane.normal, footLSlope );
+
+	pm->trace( &trace, footROrg, footMins, footMaxs, footRBot, pm->ps->clientNum, pm->tracemask );
+	VectorCopy( trace.endpos, footRBot );
+	VectorCopy( trace.plane.normal, footRSlope );
+
+	diff = footLBot[2] - footRBot[2];
+
+	if ( pDiff != NULL )
+	{
+		*pDiff = diff;
+	}
+	if ( pInterval != NULL )
+	{
+		*pInterval = interval;
+	}
+}
+
+qboolean BG_InSlopeAnim( int anim )
+{
+	switch ( anim )
+	{
+	case LEGS_LEFTUP1:			//# On a slope with left foot 4 higher than right
+	case LEGS_LEFTUP2:			//# On a slope with left foot 8 higher than right
+	case LEGS_LEFTUP3:			//# On a slope with left foot 12 higher than right
+	case LEGS_LEFTUP4:			//# On a slope with left foot 16 higher than right
+	case LEGS_LEFTUP5:			//# On a slope with left foot 20 higher than right
+	case LEGS_RIGHTUP1:			//# On a slope with RIGHT foot 4 higher than left
+	case LEGS_RIGHTUP2:			//# On a slope with RIGHT foot 8 higher than left
+	case LEGS_RIGHTUP3:			//# On a slope with RIGHT foot 12 higher than left
+	case LEGS_RIGHTUP4:			//# On a slope with RIGHT foot 16 higher than left
+	case LEGS_RIGHTUP5:			//# On a slope with RIGHT foot 20 higher than left
+	case LEGS_S1_LUP1:
+	case LEGS_S1_LUP2:
+	case LEGS_S1_LUP3:
+	case LEGS_S1_LUP4:
+	case LEGS_S1_LUP5:
+	case LEGS_S1_RUP1:
+	case LEGS_S1_RUP2:
+	case LEGS_S1_RUP3:
+	case LEGS_S1_RUP4:
+	case LEGS_S1_RUP5:
+	case LEGS_S3_LUP1:
+	case LEGS_S3_LUP2:
+	case LEGS_S3_LUP3:
+	case LEGS_S3_LUP4:
+	case LEGS_S3_LUP5:
+	case LEGS_S3_RUP1:
+	case LEGS_S3_RUP2:
+	case LEGS_S3_RUP3:
+	case LEGS_S3_RUP4:
+	case LEGS_S3_RUP5:
+	case LEGS_S4_LUP1:
+	case LEGS_S4_LUP2:
+	case LEGS_S4_LUP3:
+	case LEGS_S4_LUP4:
+	case LEGS_S4_LUP5:
+	case LEGS_S4_RUP1:
+	case LEGS_S4_RUP2:
+	case LEGS_S4_RUP3:
+	case LEGS_S4_RUP4:
+	case LEGS_S4_RUP5:
+	case LEGS_S5_LUP1:
+	case LEGS_S5_LUP2:
+	case LEGS_S5_LUP3:
+	case LEGS_S5_LUP4:
+	case LEGS_S5_LUP5:
+	case LEGS_S5_RUP1:
+	case LEGS_S5_RUP2:
+	case LEGS_S5_RUP3:
+	case LEGS_S5_RUP4:
+	case LEGS_S5_RUP5:
+		return qtrue;
+		break;
+	}
+	return qfalse;
+}
+
+#define	SLOPE_RECALC_INT 100
+
+qboolean PM_AdjustStandAnimForSlope( void )
+{
+	float	diff;
+	float	interval;
+	int		destAnim;
+	int		legsAnim;
+	#define SLOPERECALCVAR pm->ps->slopeRecalcTime //this is purely convenience
+
+	if (!pm->ghoul2)
+	{ //probably just changed models and not quite in sync yet
+		return qfalse;
+	}
+
+	if ( pm->g2Bolts_LFoot == -1 || pm->g2Bolts_RFoot == -1 )
+	{//need these bolts!
+		return qfalse;
+	}
+
+	//step 1: find the 2 foot tags
+	PM_FootSlopeTrace( &diff, &interval );
+
+	//step 4: based on difference, choose one of the left/right slope-match intervals
+	if ( diff >= interval*5 )
+	{
+		destAnim = LEGS_LEFTUP5;
+	}
+	else if ( diff >= interval*4 )
+	{
+		destAnim = LEGS_LEFTUP4;
+	}
+	else if ( diff >= interval*3 )
+	{
+		destAnim = LEGS_LEFTUP3;
+	}
+	else if ( diff >= interval*2 )
+	{
+		destAnim = LEGS_LEFTUP2;
+	}
+	else if ( diff >= interval )
+	{
+		destAnim = LEGS_LEFTUP1;
+	}
+	else if ( diff <= interval*-5 )
+	{
+		destAnim = LEGS_RIGHTUP5;
+	}
+	else if ( diff <= interval*-4 )
+	{
+		destAnim = LEGS_RIGHTUP4;
+	}
+	else if ( diff <= interval*-3 )
+	{
+		destAnim = LEGS_RIGHTUP3;
+	}
+	else if ( diff <= interval*-2 )
+	{
+		destAnim = LEGS_RIGHTUP2;
+	}
+	else if ( diff <= interval*-1 )
+	{
+		destAnim = LEGS_RIGHTUP1;
+	}
+	else
+	{
+		return qfalse;
+	}
+
+	legsAnim = pm->ps->legsAnim;
+	//adjust for current legs anim
+	switch ( legsAnim )
+	{
+	case BOTH_STAND1:
+
+	case LEGS_S1_LUP1:
+	case LEGS_S1_LUP2:
+	case LEGS_S1_LUP3:
+	case LEGS_S1_LUP4:
+	case LEGS_S1_LUP5:
+	case LEGS_S1_RUP1:
+	case LEGS_S1_RUP2:
+	case LEGS_S1_RUP3:
+	case LEGS_S1_RUP4:
+	case LEGS_S1_RUP5:
+		destAnim = LEGS_S1_LUP1 + (destAnim-LEGS_LEFTUP1);
+		break;
+	case BOTH_STAND2:
+	case BOTH_SABERFAST_STANCE:
+	case BOTH_SABERSLOW_STANCE:
+	case BOTH_CROUCH1IDLE:
+	case BOTH_CROUCH1:
+	case LEGS_LEFTUP1:			//# On a slope with left foot 4 higher than right
+	case LEGS_LEFTUP2:			//# On a slope with left foot 8 higher than right
+	case LEGS_LEFTUP3:			//# On a slope with left foot 12 higher than right
+	case LEGS_LEFTUP4:			//# On a slope with left foot 16 higher than right
+	case LEGS_LEFTUP5:			//# On a slope with left foot 20 higher than right
+	case LEGS_RIGHTUP1:			//# On a slope with RIGHT foot 4 higher than left
+	case LEGS_RIGHTUP2:			//# On a slope with RIGHT foot 8 higher than left
+	case LEGS_RIGHTUP3:			//# On a slope with RIGHT foot 12 higher than left
+	case LEGS_RIGHTUP4:			//# On a slope with RIGHT foot 16 higher than left
+	case LEGS_RIGHTUP5:			//# On a slope with RIGHT foot 20 higher than left
+		//fine
+		break;
+	case BOTH_STAND3:
+	case LEGS_S3_LUP1:
+	case LEGS_S3_LUP2:
+	case LEGS_S3_LUP3:
+	case LEGS_S3_LUP4:
+	case LEGS_S3_LUP5:
+	case LEGS_S3_RUP1:
+	case LEGS_S3_RUP2:
+	case LEGS_S3_RUP3:
+	case LEGS_S3_RUP4:
+	case LEGS_S3_RUP5:
+		destAnim = LEGS_S3_LUP1 + (destAnim-LEGS_LEFTUP1);
+		break;
+	case BOTH_STAND4:
+	case LEGS_S4_LUP1:
+	case LEGS_S4_LUP2:
+	case LEGS_S4_LUP3:
+	case LEGS_S4_LUP4:
+	case LEGS_S4_LUP5:
+	case LEGS_S4_RUP1:
+	case LEGS_S4_RUP2:
+	case LEGS_S4_RUP3:
+	case LEGS_S4_RUP4:
+	case LEGS_S4_RUP5:
+		destAnim = LEGS_S4_LUP1 + (destAnim-LEGS_LEFTUP1);
+		break;
+	case BOTH_STAND5:
+	case LEGS_S5_LUP1:
+	case LEGS_S5_LUP2:
+	case LEGS_S5_LUP3:
+	case LEGS_S5_LUP4:
+	case LEGS_S5_LUP5:
+	case LEGS_S5_RUP1:
+	case LEGS_S5_RUP2:
+	case LEGS_S5_RUP3:
+	case LEGS_S5_RUP4:
+	case LEGS_S5_RUP5:
+		destAnim = LEGS_S5_LUP1 + (destAnim-LEGS_LEFTUP1);
+		break;
+	case BOTH_STAND6:
+	default:
+		return qfalse;
+		break;
+	}
+
+	//step 5: based on the chosen interval and the current legsAnim, pick the correct anim
+	//step 6: increment/decrement to the dest anim, not instant
+	if ( (legsAnim >= LEGS_LEFTUP1 && legsAnim <= LEGS_LEFTUP5)
+		|| (legsAnim >= LEGS_S1_LUP1 && legsAnim <= LEGS_S1_LUP5)
+		|| (legsAnim >= LEGS_S3_LUP1 && legsAnim <= LEGS_S3_LUP5)
+		|| (legsAnim >= LEGS_S4_LUP1 && legsAnim <= LEGS_S4_LUP5)
+		|| (legsAnim >= LEGS_S5_LUP1 && legsAnim <= LEGS_S5_LUP5) )
+	{//already in left-side up
+		if ( destAnim > legsAnim && SLOPERECALCVAR < pm->cmd.serverTime )
+		{
+			legsAnim++;
+			SLOPERECALCVAR = pm->cmd.serverTime + SLOPE_RECALC_INT;
+		}
+		else if ( destAnim < legsAnim && SLOPERECALCVAR < pm->cmd.serverTime )
+		{
+			legsAnim--;
+			SLOPERECALCVAR = pm->cmd.serverTime + SLOPE_RECALC_INT;
+		}
+		else //if (SLOPERECALCVAR < pm->cmd.serverTime)
+		{
+			legsAnim = destAnim;
+		}
+
+		destAnim = legsAnim;
+	}
+	else if ( (legsAnim >= LEGS_RIGHTUP1 && legsAnim <= LEGS_RIGHTUP5) 
+		|| (legsAnim >= LEGS_S1_RUP1 && legsAnim <= LEGS_S1_RUP5)
+		|| (legsAnim >= LEGS_S3_RUP1 && legsAnim <= LEGS_S3_RUP5)
+		|| (legsAnim >= LEGS_S4_RUP1 && legsAnim <= LEGS_S4_RUP5)
+		|| (legsAnim >= LEGS_S5_RUP1 && legsAnim <= LEGS_S5_RUP5) )
+	{//already in right-side up
+		if ( destAnim > legsAnim && SLOPERECALCVAR < pm->cmd.serverTime )
+		{
+			legsAnim++;
+			SLOPERECALCVAR = pm->cmd.serverTime + SLOPE_RECALC_INT;
+		}
+		else if ( destAnim < legsAnim && SLOPERECALCVAR < pm->cmd.serverTime )
+		{
+			legsAnim--;
+			SLOPERECALCVAR = pm->cmd.serverTime + SLOPE_RECALC_INT;
+		}
+		else //if (SLOPERECALCVAR < pm->cmd.serverTime)
+		{
+			legsAnim = destAnim;
+		}
+		
+		destAnim = legsAnim;
+	}
+	else
+	{//in a stand of some sort?
+		switch ( legsAnim )
+		{
+		case BOTH_STAND1:
+		case TORSO_WEAPONREADY1:
+		case TORSO_WEAPONREADY2:
+		case TORSO_WEAPONREADY3:
+		case TORSO_WEAPONREADY10:
+
+			if ( destAnim >= LEGS_S1_LUP1 && destAnim <= LEGS_S1_LUP5 )
+			{//going into left side up
+				destAnim = LEGS_S1_LUP1;
+				SLOPERECALCVAR = pm->cmd.serverTime + SLOPE_RECALC_INT;
+			}
+			else if ( destAnim >= LEGS_S1_RUP1 && destAnim <= LEGS_S1_RUP5 )
+			{//going into right side up
+				destAnim = LEGS_S1_RUP1;
+				SLOPERECALCVAR = pm->cmd.serverTime + SLOPE_RECALC_INT;
+			}
+			else
+			{//will never get here
+				return qfalse;
+			}
+			break;
+		case BOTH_STAND2:
+		case BOTH_SABERFAST_STANCE:
+		case BOTH_SABERSLOW_STANCE:
+		case BOTH_CROUCH1IDLE:
+			if ( destAnim >= LEGS_LEFTUP1 && destAnim <= LEGS_LEFTUP5 )
+			{//going into left side up
+				destAnim = LEGS_LEFTUP1;
+				SLOPERECALCVAR = pm->cmd.serverTime + SLOPE_RECALC_INT;
+			}
+			else if ( destAnim >= LEGS_RIGHTUP1 && destAnim <= LEGS_RIGHTUP5 )
+			{//going into right side up
+				destAnim = LEGS_RIGHTUP1;
+				SLOPERECALCVAR = pm->cmd.serverTime + SLOPE_RECALC_INT;
+			}
+			else
+			{//will never get here
+				return qfalse;
+			}
+			break;
+		case BOTH_STAND3:
+			if ( destAnim >= LEGS_S3_LUP1 && destAnim <= LEGS_S3_LUP5 )
+			{//going into left side up
+				destAnim = LEGS_S3_LUP1;
+				SLOPERECALCVAR = pm->cmd.serverTime + SLOPE_RECALC_INT;
+			}
+			else if ( destAnim >= LEGS_S3_RUP1 && destAnim <= LEGS_S3_RUP5 )
+			{//going into right side up
+				destAnim = LEGS_S3_RUP1;
+				SLOPERECALCVAR = pm->cmd.serverTime + SLOPE_RECALC_INT;
+			}
+			else
+			{//will never get here
+				return qfalse;
+			}
+			break;
+		case BOTH_STAND4:
+			if ( destAnim >= LEGS_S4_LUP1 && destAnim <= LEGS_S4_LUP5 )
+			{//going into left side up
+				destAnim = LEGS_S4_LUP1;
+				SLOPERECALCVAR = pm->cmd.serverTime + SLOPE_RECALC_INT;
+			}
+			else if ( destAnim >= LEGS_S4_RUP1 && destAnim <= LEGS_S4_RUP5 )
+			{//going into right side up
+				destAnim = LEGS_S4_RUP1;
+				SLOPERECALCVAR = pm->cmd.serverTime + SLOPE_RECALC_INT;
+			}
+			else
+			{//will never get here
+				return qfalse;
+			}
+			break;
+		case BOTH_STAND5:
+			if ( destAnim >= LEGS_S5_LUP1 && destAnim <= LEGS_S5_LUP5 )
+			{//going into left side up
+				destAnim = LEGS_S5_LUP1;
+				SLOPERECALCVAR = pm->cmd.serverTime + SLOPE_RECALC_INT;
+			}
+			else if ( destAnim >= LEGS_S5_RUP1 && destAnim <= LEGS_S5_RUP5 )
+			{//going into right side up
+				destAnim = LEGS_S5_RUP1;
+				SLOPERECALCVAR = pm->cmd.serverTime + SLOPE_RECALC_INT;
+			}
+			else
+			{//will never get here
+				return qfalse;
+			}
+			break;
+		case BOTH_STAND6:
+		default:
+			return qfalse;
+			break;
+		}
+	}
+	//step 7: set the anim
+	//PM_SetAnim( SETANIM_LEGS, destAnim, SETANIM_FLAG_NORMAL, 100 );
+	PM_ContinueLegsAnim(destAnim);
+
+	return qtrue;
+}
+
+extern int WeaponReadyLegsAnim[WP_NUM_WEAPONS];
+
+//rww - slowly back out of slope leg anims, to prevent skipping between slope anims and general jittering
+int PM_LegsSlopeBackTransition(int desiredAnim)
+{
+	int anim = pm->ps->legsAnim;
+	int resultingAnim = desiredAnim;
+
+	switch ( anim )
+	{
+	case LEGS_LEFTUP2:			//# On a slope with left foot 8 higher than right
+	case LEGS_LEFTUP3:			//# On a slope with left foot 12 higher than right
+	case LEGS_LEFTUP4:			//# On a slope with left foot 16 higher than right
+	case LEGS_LEFTUP5:			//# On a slope with left foot 20 higher than right
+	case LEGS_RIGHTUP2:			//# On a slope with RIGHT foot 8 higher than left
+	case LEGS_RIGHTUP3:			//# On a slope with RIGHT foot 12 higher than left
+	case LEGS_RIGHTUP4:			//# On a slope with RIGHT foot 16 higher than left
+	case LEGS_RIGHTUP5:			//# On a slope with RIGHT foot 20 higher than left
+	case LEGS_S1_LUP2:
+	case LEGS_S1_LUP3:
+	case LEGS_S1_LUP4:
+	case LEGS_S1_LUP5:
+	case LEGS_S1_RUP2:
+	case LEGS_S1_RUP3:
+	case LEGS_S1_RUP4:
+	case LEGS_S1_RUP5:
+	case LEGS_S3_LUP2:
+	case LEGS_S3_LUP3:
+	case LEGS_S3_LUP4:
+	case LEGS_S3_LUP5:
+	case LEGS_S3_RUP2:
+	case LEGS_S3_RUP3:
+	case LEGS_S3_RUP4:
+	case LEGS_S3_RUP5:
+	case LEGS_S4_LUP2:
+	case LEGS_S4_LUP3:
+	case LEGS_S4_LUP4:
+	case LEGS_S4_LUP5:
+	case LEGS_S4_RUP2:
+	case LEGS_S4_RUP3:
+	case LEGS_S4_RUP4:
+	case LEGS_S4_RUP5:
+	case LEGS_S5_LUP2:
+	case LEGS_S5_LUP3:
+	case LEGS_S5_LUP4:
+	case LEGS_S5_LUP5:
+	case LEGS_S5_RUP2:
+	case LEGS_S5_RUP3:
+	case LEGS_S5_RUP4:
+	case LEGS_S5_RUP5:
+		if (pm->ps->slopeRecalcTime < pm->cmd.serverTime)
+		{
+			resultingAnim = anim-1;
+			pm->ps->slopeRecalcTime = pm->cmd.serverTime + 8;//SLOPE_RECALC_INT;
+		}
+		else
+		{
+			resultingAnim = anim;
+		}
+		VectorClear(pm->ps->velocity);
+		break;
+	}
+
+	return resultingAnim;
+}
+
+/*
+===============
+PM_Footsteps
+===============
+*/
+static void PM_Footsteps( void ) {
+	float		bobmove;
+	int			old;
+	qboolean	footstep;
+	int			setAnimFlags = 0;
+
+	if ( (PM_InSaberAnim( (pm->ps->legsAnim) ) && !BG_SpinningSaberAnim( (pm->ps->legsAnim) )) 
+		|| (pm->ps->legsAnim) == BOTH_STAND1 
+		|| (pm->ps->legsAnim) == BOTH_STAND1TO2 
+		|| (pm->ps->legsAnim) == BOTH_STAND2TO1 
+		|| (pm->ps->legsAnim) == BOTH_STAND2 
+		|| (pm->ps->legsAnim) == BOTH_SABERFAST_STANCE
+		|| (pm->ps->legsAnim) == BOTH_SABERSLOW_STANCE
+		|| (pm->ps->legsAnim) == BOTH_BUTTON_HOLD
+		|| (pm->ps->legsAnim) == BOTH_BUTTON_RELEASE
+		|| PM_LandingAnim( (pm->ps->legsAnim) ) 
+		|| PM_PainAnim( (pm->ps->legsAnim) ))
+	{//legs are in a saber anim, and not spinning, be sure to override it
+		setAnimFlags |= SETANIM_FLAG_OVERRIDE;
+	}
+
+	//
+	// calculate speed and cycle to be used for
+	// all cyclic walking effects
+	//
+	pm->xyspeed = sqrt( pm->ps->velocity[0] * pm->ps->velocity[0]
+		+  pm->ps->velocity[1] * pm->ps->velocity[1] );
+
+	if (pm->ps->saberMove == LS_SPINATTACK)
+	{
+		PM_ContinueLegsAnim( pm->ps->torsoAnim );
+	}
+	else if ( pm->ps->groundEntityNum == ENTITYNUM_NONE ) {
+
+		// airborne leaves position in cycle intact, but doesn't advance
+		if ( pm->waterlevel > 1 )
+		{
+			if (pm->xyspeed > 60)
+			{
+				PM_ContinueLegsAnim( BOTH_SWIMFORWARD );
+			}
+			else
+			{
+				PM_ContinueLegsAnim( BOTH_SWIM_IDLE1 );
+			}
+		}
+		return;
+	}
+	// if not trying to move
+	else if ( !pm->cmd.forwardmove && !pm->cmd.rightmove ) {
+		if (  pm->xyspeed < 5 ) {
+			pm->ps->bobCycle = 0;	// start at beginning of cycle again
+			if ( pm->ps->clientNum >= MAX_CLIENTS &&
+				pm_entSelf &&
+				pm_entSelf->s.NPC_class == CLASS_RANCOR )
+			{
+				if ( (pm->ps->eFlags2&EF2_USE_ALT_ANIM) )
+				{//holding someone
+					PM_ContinueLegsAnim( BOTH_STAND4 );
+					//PM_SetAnim(pm,SETANIM_LEGS,BOTH_STAND4,SETANIM_FLAG_NORMAL);
+				}
+				else if ( (pm->ps->eFlags2&EF2_ALERTED) )
+				{//have an enemy or have had one since we spawned
+					PM_ContinueLegsAnim( BOTH_STAND2 );
+					//PM_SetAnim(pm,SETANIM_LEGS,BOTH_STAND2,SETANIM_FLAG_NORMAL);
+				}
+				else
+				{//just stand there
+					PM_ContinueLegsAnim( BOTH_STAND1 );
+					//PM_SetAnim(pm,SETANIM_LEGS,BOTH_STAND1,SETANIM_FLAG_NORMAL);
+				}
+			}
+			else if ( pm->ps->clientNum >= MAX_CLIENTS &&
+				pm_entSelf &&
+				pm_entSelf->s.NPC_class == CLASS_WAMPA )
+			{
+				if ( (pm->ps->eFlags2&EF2_USE_ALT_ANIM) )
+				{//holding a victim
+					PM_ContinueLegsAnim( BOTH_STAND2 );
+					//PM_SetAnim(pm,SETANIM_LEGS,BOTH_STAND2,SETANIM_FLAG_NORMAL);
+				}
+				else
+				{//not holding a victim
+					PM_ContinueLegsAnim( BOTH_STAND1 );
+					//PM_SetAnim(pm,SETANIM_LEGS,BOTH_STAND1,SETANIM_FLAG_NORMAL);
+				}
+			}
+			else if ( (pm->ps->pm_flags & PMF_DUCKED) || (pm->ps->pm_flags & PMF_ROLLING) ) {
+				if ((pm->ps->legsAnim) != BOTH_CROUCH1IDLE)
+				{
+					PM_SetAnim(SETANIM_LEGS, BOTH_CROUCH1IDLE, setAnimFlags, 100);
+				}
+				else
+				{
+					PM_ContinueLegsAnim( BOTH_CROUCH1IDLE );
+				}
+			} else {
+				if (pm->ps->weapon == WP_DISRUPTOR && pm->ps->zoomMode == 1)
+				{
+					///????  continue legs anim on a torso anim...??!!!
+					//yeah.. the anim has a valid pose for the legs, it uses it (you can't move while using disruptor)
+					PM_ContinueLegsAnim( TORSO_WEAPONREADY4 );
+				}
+				else
+				{
+					if (pm->ps->weapon == WP_SABER && BG_SabersOff( pm->ps ) )
+					{
+						if (!PM_AdjustStandAnimForSlope())
+						{
+							//PM_ContinueLegsAnim( BOTH_STAND1 );
+							PM_ContinueLegsAnim(PM_LegsSlopeBackTransition(BOTH_STAND1));
+						}
+					}
+					else
+					{
+						if (pm->ps->weapon != WP_SABER || !PM_AdjustStandAnimForSlope())
+						{
+							if (pm->ps->weapon == WP_SABER)
+							{
+								PM_ContinueLegsAnim(PM_LegsSlopeBackTransition(PM_GetSaberStance()));
+							}
+							else
+							{
+								PM_ContinueLegsAnim(PM_LegsSlopeBackTransition(WeaponReadyLegsAnim[pm->ps->weapon]));
+							}
+						}
+					}
+				}
+			}
+		}
+		return;
+	}
+	
+
+	footstep = qfalse;
+
+	if (pm->ps->saberMove == LS_SPINATTACK)
+	{
+		bobmove = 0.2f;
+		PM_ContinueLegsAnim( pm->ps->torsoAnim );
+	}
+	else if ( pm->ps->pm_flags & PMF_DUCKED )
+	{
+		int rolled = 0;
+
+		bobmove = 0.5;	// ducked characters bob much faster
+
+		if ( ( PM_RunningAnim( pm->ps->legsAnim ) || PM_CanRollFromSoulCal( pm->ps ) ) &&
+			!BG_InRoll(pm->ps, pm->ps->legsAnim) )
+		{//roll!
+			rolled = PM_TryRoll();
+		}
+		if ( !rolled )
+		{ //if the roll failed or didn't attempt, do standard crouching anim stuff.
+			if ( pm->ps->pm_flags & PMF_BACKWARDS_RUN ) {
+				if ((pm->ps->legsAnim) != BOTH_CROUCH1WALKBACK)
+				{
+					PM_SetAnim(SETANIM_LEGS, BOTH_CROUCH1WALKBACK, setAnimFlags, 100);
+				}
+				else
+				{
+					PM_ContinueLegsAnim( BOTH_CROUCH1WALKBACK );
+				}
+			}
+			else {
+				if ((pm->ps->legsAnim) != BOTH_CROUCH1WALK)
+				{
+					PM_SetAnim(SETANIM_LEGS, BOTH_CROUCH1WALK, setAnimFlags, 100);
+				}
+				else
+				{
+					PM_ContinueLegsAnim( BOTH_CROUCH1WALK );
+				}
+			}
+		}
+		else
+		{ //otherwise send us into the roll
+			pm->ps->legsTimer = 0;
+			pm->ps->legsAnim = 0;
+			PM_SetAnim(SETANIM_BOTH,rolled,SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD, 150);
+			PM_AddEventWithParm( EV_ROLL, 0 );
+			pm->maxs[2] = pm->ps->crouchheight;//CROUCH_MAXS_2;
+			pm->ps->viewheight = DEFAULT_VIEWHEIGHT;
+			pm->ps->pm_flags &= ~PMF_DUCKED;
+			pm->ps->pm_flags |= PMF_ROLLING;
+		}
+	}
+	else if ((pm->ps->pm_flags & PMF_ROLLING) && !BG_InRoll(pm->ps, pm->ps->legsAnim) &&
+		!PM_InRollComplete(pm->ps, pm->ps->legsAnim))
+	{
+		bobmove = 0.5;	// ducked characters bob much faster
+
+		if ( pm->ps->pm_flags & PMF_BACKWARDS_RUN )
+		{
+			if ((pm->ps->legsAnim) != BOTH_CROUCH1WALKBACK)
+			{
+				PM_SetAnim(SETANIM_LEGS, BOTH_CROUCH1WALKBACK, setAnimFlags, 100);
+			}
+			else
+			{
+				PM_ContinueLegsAnim( BOTH_CROUCH1WALKBACK );
+			}
+		}
+		else
+		{
+			if ((pm->ps->legsAnim) != BOTH_CROUCH1WALK)
+			{
+				PM_SetAnim(SETANIM_LEGS, BOTH_CROUCH1WALK, setAnimFlags, 100);
+			}
+			else
+			{
+				PM_ContinueLegsAnim( BOTH_CROUCH1WALK );
+			}
+		}
+	}
+	else
+	{
+		int desiredAnim = -1;
+
+		if ((pm->ps->legsAnim == BOTH_FORCELAND1 ||
+			pm->ps->legsAnim == BOTH_FORCELANDBACK1 ||
+			pm->ps->legsAnim == BOTH_FORCELANDRIGHT1 ||
+			pm->ps->legsAnim == BOTH_FORCELANDLEFT1) &&
+			pm->ps->legsTimer > 0)
+		{ //let it finish first
+			bobmove = 0.2f;
+		}
+		else if ( !( pm->cmd.buttons & BUTTON_WALKING ) )
+		{//running
+			bobmove = 0.4f;	// faster speeds bob faster
+			if ( pm->ps->clientNum >= MAX_CLIENTS &&
+				pm_entSelf &&
+				pm_entSelf->s.NPC_class == CLASS_WAMPA )
+			{
+				if ( (pm->ps->eFlags2&EF2_USE_ALT_ANIM) )
+				{//full on run, on all fours
+					desiredAnim = BOTH_RUN1;
+				}
+				else
+				{//regular, upright run
+					desiredAnim = BOTH_RUN2;
+				}
+			}
+			else if ( pm->ps->clientNum >= MAX_CLIENTS &&
+				pm_entSelf &&
+				pm_entSelf->s.NPC_class == CLASS_RANCOR )
+			{//no run anims
+				if ( (pm->ps->pm_flags&PMF_BACKWARDS_RUN) )
+				{
+					desiredAnim = BOTH_WALKBACK1;
+				}
+				else
+				{
+					desiredAnim = BOTH_WALK1;
+				}
+			}
+			else if ( pm->ps->pm_flags & PMF_BACKWARDS_RUN )
+			{
+				switch (pm->ps->fd.saberAnimLevel)
+				{
+				case SS_STAFF:
+					if ( pm->ps->saberHolstered > 1 ) 
+					{//saber off
+						desiredAnim = BOTH_RUNBACK1;
+					}
+					else
+					{
+						//desiredAnim = BOTH_RUNBACK_STAFF;
+						//hmm.. stuff runback anim is pretty messed up for some reason.
+						desiredAnim = BOTH_RUNBACK2;
+					}
+					break;
+				case SS_DUAL:
+					if ( pm->ps->saberHolstered > 1 ) 
+					{//sabers off
+						desiredAnim = BOTH_RUNBACK1;
+					}
+					else
+					{
+						//desiredAnim = BOTH_RUNBACK_DUAL;
+						//and so is the dual
+						desiredAnim = BOTH_RUNBACK2;
+					}
+					break;
+				default:
+					if ( pm->ps->saberHolstered ) 
+					{//saber off
+						desiredAnim = BOTH_RUNBACK1;
+					}
+					else
+					{
+						desiredAnim = BOTH_RUNBACK2;
+					}
+					break;
+				}
+			}
+			else
+			{
+				switch (pm->ps->fd.saberAnimLevel)
+				{
+				case SS_STAFF:
+					if ( pm->ps->saberHolstered > 1 )
+					{//blades off
+						desiredAnim = BOTH_RUN1;
+					}
+					else if ( pm->ps->saberHolstered == 1 )
+					{//1 blade on
+						desiredAnim = BOTH_RUN2;
+					}
+					else
+					{
+						if (pm->ps->fd.forcePowersActive & (1<<FP_SPEED))
+						{
+							desiredAnim = BOTH_RUN1;
+						}
+						else
+						{
+							desiredAnim = BOTH_RUN_STAFF;
+						}
+					}
+					break;
+				case SS_DUAL:
+					if ( pm->ps->saberHolstered > 1 )
+					{//blades off
+						desiredAnim = BOTH_RUN1;
+					}
+					else if ( pm->ps->saberHolstered == 1 )
+					{//1 saber on
+						desiredAnim = BOTH_RUN2;
+					}
+					else
+					{
+						desiredAnim = BOTH_RUN_DUAL;
+					}
+					break;
+				default:
+					if ( pm->ps->saberHolstered )
+					{//saber off
+						desiredAnim = BOTH_RUN1;
+					}
+					else
+					{
+						desiredAnim = BOTH_RUN2;
+					}
+					break;
+				}
+			}
+			footstep = qtrue;
+		}
+		else
+		{
+			bobmove = 0.2f;	// walking bobs slow
+			if ( pm->ps->pm_flags & PMF_BACKWARDS_RUN )
+			{
+				switch (pm->ps->fd.saberAnimLevel)
+				{
+				case SS_STAFF:
+					if ( pm->ps->saberHolstered > 1 )
+					{
+						desiredAnim = BOTH_WALKBACK1;
+					}
+					else if ( pm->ps->saberHolstered )
+					{
+						desiredAnim = BOTH_WALKBACK2;
+					}
+					else
+					{
+						desiredAnim = BOTH_WALKBACK_STAFF;
+					}
+					break;
+				case SS_DUAL:
+					if ( pm->ps->saberHolstered > 1 )
+					{
+						desiredAnim = BOTH_WALKBACK1;
+					}
+					else if ( pm->ps->saberHolstered )
+					{
+						desiredAnim = BOTH_WALKBACK2;
+					}
+					else
+					{
+						desiredAnim = BOTH_WALKBACK_DUAL;
+					}
+					break;
+				default:
+					if ( pm->ps->saberHolstered )
+					{
+						desiredAnim = BOTH_WALKBACK1;
+					}
+					else
+					{
+						desiredAnim = BOTH_WALKBACK2;
+					}
+					break;
+				}
+			}
+			else
+			{
+				if ( BG_SabersOff( pm->ps ) )
+				{
+					desiredAnim = BOTH_WALK1;
+				}
+				else
+				{
+					switch (pm->ps->fd.saberAnimLevel)
+					{
+					case SS_STAFF:
+						if ( pm->ps->saberHolstered > 1 )
+						{
+							desiredAnim = BOTH_WALK1;
+						}
+						else if ( pm->ps->saberHolstered )
+						{
+							desiredAnim = BOTH_WALK2;
+						}
+						else
+						{
+							desiredAnim = BOTH_WALK_STAFF;
+						}
+						break;
+					case SS_DUAL:
+						if ( pm->ps->saberHolstered > 1 )
+						{
+							desiredAnim = BOTH_WALK1;
+						}
+						else if ( pm->ps->saberHolstered )
+						{
+							desiredAnim = BOTH_WALK2;
+						}
+						else
+						{
+							desiredAnim = BOTH_WALK_DUAL;
+						}
+						break;
+					default:
+						if ( pm->ps->saberHolstered )
+						{
+							desiredAnim = BOTH_WALK1;
+						}
+						else
+						{
+							desiredAnim = BOTH_WALK2;
+						}
+						break;
+					}
+				}
+			}
+		}
+
+		if (desiredAnim != -1)
+		{
+			int ires = PM_LegsSlopeBackTransition(desiredAnim);
+
+			if ((pm->ps->legsAnim) != desiredAnim && ires == desiredAnim)
+			{
+				PM_SetAnim(SETANIM_LEGS, desiredAnim, setAnimFlags, 100);
+			}
+			else
+			{
+				PM_ContinueLegsAnim(ires);
+			}
+		}
+	}
+
+	// check for footstep / splash sounds
+	old = pm->ps->bobCycle;
+	pm->ps->bobCycle = (int)( old + bobmove * pml.msec ) & 255;
+
+	// if we just crossed a cycle boundary, play an apropriate footstep event
+	if ( ( ( old + 64 ) ^ ( pm->ps->bobCycle + 64 ) ) & 128 )
+	{
+		pm->ps->footstepTime = pm->cmd.serverTime + 300;
+		if ( pm->waterlevel == 1 ) {
+			// splashing
+			PM_AddEvent( EV_FOOTSPLASH );
+		} else if ( pm->waterlevel == 2 ) {
+			// wading / swimming at surface
+			PM_AddEvent( EV_SWIM );
+		} else if ( pm->waterlevel == 3 ) {
+			// no sound when completely underwater
+		}
+	}
+}
+
+/*
+==============
+PM_WaterEvents
+
+Generate sound events for entering and leaving water
+==============
+*/
+static void PM_WaterEvents( void ) {		// FIXME?
+#ifdef QAGAME
+	qboolean impact_splash = qfalse;
+#endif
+	//
+	// if just entered a water volume, play a sound
+	//
+	if (!pml.previous_waterlevel && pm->waterlevel) {
+#ifdef QAGAME
+		if ( VectorLengthSquared( pm->ps->velocity ) > 40000 )
+		{
+			impact_splash = qtrue;
+		}
+#endif
+		PM_AddEvent( EV_WATER_TOUCH );
+	}
+
+	//
+	// if just completely exited a water volume, play a sound
+	//
+	if (pml.previous_waterlevel && !pm->waterlevel) {
+#ifdef QAGAME
+		if ( VectorLengthSquared( pm->ps->velocity ) > 40000 )
+		{
+			impact_splash = qtrue;
+		}
+#endif
+		PM_AddEvent( EV_WATER_LEAVE );
+	}
+
+#ifdef QAGAME
+	if ( impact_splash )
+	{
+		//play the splash effect
+		trace_t	tr;
+		vec3_t	start, end;
+
+
+		VectorCopy( pm->ps->origin, start );
+		VectorCopy( pm->ps->origin, end );
+
+		// FIXME: set start and end better
+		start[2] += 10;
+		end[2] -= 40;
+
+		pm->trace( &tr, start, vec3_origin, vec3_origin, end, pm->ps->clientNum, MASK_WATER );
+
+		if ( tr.fraction < 1.0f )
+		{
+			if ( (tr.contents&CONTENTS_LAVA) )
+			{
+				G_PlayEffect( EFFECT_LAVA_SPLASH, tr.endpos, tr.plane.normal );
+			}
+			else if ( (tr.contents&CONTENTS_SLIME) )
+			{
+				G_PlayEffect( EFFECT_ACID_SPLASH, tr.endpos, tr.plane.normal );
+			}
+			else //must be water
+			{
+				G_PlayEffect( EFFECT_WATER_SPLASH, tr.endpos, tr.plane.normal );
+			}
+		}
+	}
+#endif
+
+	//
+	// check for head just going under water
+	//
+	if (pml.previous_waterlevel != 3 && pm->waterlevel == 3) {
+		PM_AddEvent( EV_WATER_UNDER );
+	}
+
+	//
+	// check for head just coming out of water
+	//
+	if (pml.previous_waterlevel == 3 && pm->waterlevel != 3) {
+		PM_AddEvent( EV_WATER_CLEAR );
+	}
+}
+
+
+/*
+===============
+PM_BeginWeaponChange
+===============
+*/
+void PM_BeginWeaponChange( int weapon ) {
+	if ( weapon <= WP_NONE || weapon >= WP_NUM_WEAPONS ) {
+		return;
+	}
+
+	if ( !( pm->ps->stats[STAT_WEAPONS] & ( 1 << weapon ) ) ) {
+		return;
+	}
+	
+	if ( pm->ps->weaponstate == WEAPON_DROPPING ) {
+		return;
+	}
+
+	// turn of any kind of zooming when weapon switching.
+	if (pm->ps->zoomMode)
+	{
+		pm->ps->zoomMode = 0;
+		pm->ps->zoomTime = pm->ps->commandTime;
+	}
+
+	PM_AddEventWithParm( EV_CHANGE_WEAPON, weapon );
+	pm->ps->weaponstate = WEAPON_DROPPING;
+	pm->ps->weaponTime += 200;
+	//PM_StartTorsoAnim( TORSO_DROPWEAP1 );
+	PM_SetAnim(SETANIM_TORSO, TORSO_DROPWEAP1, SETANIM_FLAG_OVERRIDE, 0);
+}
+
+
+/*
+===============
+PM_FinishWeaponChange
+===============
+*/
+void PM_FinishWeaponChange( void ) {
+	int		weapon;
+
+	weapon = pm->cmd.weapon;
+	if ( weapon < WP_NONE || weapon >= WP_NUM_WEAPONS ) {
+		weapon = WP_NONE;
+	}
+
+	if ( !( pm->ps->stats[STAT_WEAPONS] & ( 1 << weapon ) ) ) {
+		weapon = WP_NONE;
+	}
+
+	if (weapon == WP_SABER)
+	{
+		PM_SetSaberMove(LS_DRAW);
+	}
+	else
+	{
+		//PM_StartTorsoAnim( TORSO_RAISEWEAP1);
+		PM_SetAnim(SETANIM_TORSO, TORSO_RAISEWEAP1, SETANIM_FLAG_OVERRIDE, 0);
+	}
+	pm->ps->weapon = weapon;
+	pm->ps->weaponstate = WEAPON_RAISING;
+	pm->ps->weaponTime += 250;
+}
+
+void PM_RocketLock( float lockDist, qboolean vehicleLock )
+{
+	// Not really a charge weapon, but we still want to delay fire until the button comes up so that we can
+	//	implement our alt-fire locking stuff
+	vec3_t		ang;
+	trace_t		tr;
+	
+	vec3_t muzzleOffPoint, muzzlePoint, forward, right, up;
+
+	if ( vehicleLock )
+	{
+		AngleVectors( pm->ps->viewangles, forward, right, up );
+		VectorCopy( pm->ps->origin, muzzlePoint );
+		VectorMA( muzzlePoint, lockDist, forward, ang );
+	}
+	else
+	{
+		AngleVectors( pm->ps->viewangles, forward, right, up );
+
+		AngleVectors(pm->ps->viewangles, ang, NULL, NULL);
+
+		VectorCopy( pm->ps->origin, muzzlePoint );
+		VectorCopy(WP_MuzzlePoint[WP_ROCKET_LAUNCHER], muzzleOffPoint);
+
+		VectorMA(muzzlePoint, muzzleOffPoint[0], forward, muzzlePoint);
+		VectorMA(muzzlePoint, muzzleOffPoint[1], right, muzzlePoint);
+		muzzlePoint[2] += pm->ps->viewheight + muzzleOffPoint[2];
+		ang[0] = muzzlePoint[0] + ang[0]*lockDist;
+		ang[1] = muzzlePoint[1] + ang[1]*lockDist;
+		ang[2] = muzzlePoint[2] + ang[2]*lockDist;
+	}
+
+
+	pm->trace(&tr, muzzlePoint, NULL, NULL, ang, pm->ps->clientNum, MASK_PLAYERSOLID);
+
+	if (tr.fraction != 1 && tr.entityNum < ENTITYNUM_NONE && tr.entityNum != pm->ps->clientNum)
+	{
+		bgEntity_t *bgEnt = PM_BGEntForNum(tr.entityNum);
+		if ( bgEnt && (bgEnt->s.powerups&PW_CLOAKED) )
+		{
+			pm->ps->rocketLockIndex = ENTITYNUM_NONE;
+			pm->ps->rocketLockTime = 0;
+		}
+		else if (bgEnt && (bgEnt->s.eType == ET_PLAYER || bgEnt->s.eType == ET_NPC))
+		{
+			if (pm->ps->rocketLockIndex == ENTITYNUM_NONE)
+			{
+				pm->ps->rocketLockIndex = tr.entityNum;
+				pm->ps->rocketLockTime = pm->cmd.serverTime;
+			}
+			else if (pm->ps->rocketLockIndex != tr.entityNum && pm->ps->rocketTargetTime < pm->cmd.serverTime)
+			{
+				pm->ps->rocketLockIndex = tr.entityNum;
+				pm->ps->rocketLockTime = pm->cmd.serverTime;
+			}
+			else if (pm->ps->rocketLockIndex == tr.entityNum)
+			{
+				if (pm->ps->rocketLockTime == -1)
+				{
+					pm->ps->rocketLockTime = pm->ps->rocketLastValidTime;
+				}
+			}
+
+			if (pm->ps->rocketLockIndex == tr.entityNum)
+			{
+				pm->ps->rocketTargetTime = pm->cmd.serverTime + 500;
+			}
+		}
+		else if (!vehicleLock)
+		{
+			if (pm->ps->rocketTargetTime < pm->cmd.serverTime)
+			{
+				pm->ps->rocketLockIndex = ENTITYNUM_NONE;
+				pm->ps->rocketLockTime = 0;
+			}
+		}
+	}
+	else if (pm->ps->rocketTargetTime < pm->cmd.serverTime)
+	{
+		pm->ps->rocketLockIndex = ENTITYNUM_NONE;
+		pm->ps->rocketLockTime = 0;
+	}
+	else
+	{
+		if (pm->ps->rocketLockTime != -1)
+		{
+			pm->ps->rocketLastValidTime = pm->ps->rocketLockTime;
+		}
+		pm->ps->rocketLockTime = -1;
+	}
+}
+
+//---------------------------------------
+static qboolean PM_DoChargedWeapons( qboolean vehicleRocketLock, bgEntity_t *veh )
+//---------------------------------------
+{
+	qboolean	charging = qfalse,
+				altFire = qfalse;
+
+	if ( vehicleRocketLock )
+	{
+		if ( (pm->cmd.buttons&(BUTTON_ATTACK|BUTTON_ALT_ATTACK)) )
+		{//actually charging
+			if ( veh 
+				&& veh->m_pVehicle )
+			{//just make sure we have this veh info
+				if ( ( (pm->cmd.buttons&BUTTON_ATTACK)
+						&&g_vehWeaponInfo[veh->m_pVehicle->m_pVehicleInfo->weapon[0].ID].fHoming
+						&&pm->ps->ammo[0]>=g_vehWeaponInfo[veh->m_pVehicle->m_pVehicleInfo->weapon[0].ID].iAmmoPerShot )
+						|| 
+					( (pm->cmd.buttons&BUTTON_ALT_ATTACK)
+						&&g_vehWeaponInfo[veh->m_pVehicle->m_pVehicleInfo->weapon[1].ID].fHoming
+						&&pm->ps->ammo[1]>=g_vehWeaponInfo[veh->m_pVehicle->m_pVehicleInfo->weapon[1].ID].iAmmoPerShot ) )
+				{//pressing the appropriate fire button for the lock-on/charging weapon
+					PM_RocketLock(16384, qtrue);
+					charging = qtrue;
+				}
+				if ( pm->cmd.buttons & BUTTON_ALT_ATTACK )
+				{
+					altFire = qtrue;
+				}
+			}
+		}
+		//else, let go and should fire now
+	}
+	else
+	{
+		// If you want your weapon to be a charging weapon, just set this bit up
+		switch( pm->ps->weapon )
+		{
+		//------------------
+		case WP_BRYAR_PISTOL:
+
+			// alt-fire charges the weapon
+			//if ( pm->gametype == GT_SIEGE )
+			if (1)
+			{
+				if ( pm->cmd.buttons & BUTTON_ALT_ATTACK )
+				{
+					charging = qtrue;
+					altFire = qtrue;
+				}
+			}
+			break;
+
+		case WP_CONCUSSION:
+			if ( pm->cmd.buttons & BUTTON_ALT_ATTACK )
+			{
+				altFire = qtrue;
+			}
+			break;
+
+		case WP_BRYAR_OLD:
+
+			// alt-fire charges the weapon
+			if ( pm->cmd.buttons & BUTTON_ALT_ATTACK )
+			{
+				charging = qtrue;
+				altFire = qtrue;
+			}
+			break;
+		
+		//------------------
+		case WP_BOWCASTER:
+
+			// primary fire charges the weapon
+			if ( pm->cmd.buttons & BUTTON_ATTACK )
+			{
+				charging = qtrue;
+			}
+			break;
+		
+		//------------------
+		case WP_ROCKET_LAUNCHER:
+			if ( (pm->cmd.buttons & BUTTON_ALT_ATTACK) 
+				&& pm->ps->ammo[weaponData[pm->ps->weapon].ammoIndex] >= weaponData[pm->ps->weapon].altEnergyPerShot )
+			{
+				PM_RocketLock(2048,qfalse);
+				charging = qtrue;
+				altFire = qtrue;
+			}
+			break;
+
+		//------------------
+		case WP_THERMAL:
+
+			if ( pm->cmd.buttons & BUTTON_ALT_ATTACK )
+			{
+				altFire = qtrue; // override default of not being an alt-fire
+				charging = qtrue;
+			}
+			else if ( pm->cmd.buttons & BUTTON_ATTACK )
+			{
+				charging = qtrue;
+			}
+			break;
+
+		case WP_DEMP2:
+			if ( pm->cmd.buttons & BUTTON_ALT_ATTACK )
+			{
+				altFire = qtrue; // override default of not being an alt-fire
+				charging = qtrue;
+			}
+			break;
+
+		case WP_DISRUPTOR:
+			if ((pm->cmd.buttons & BUTTON_ATTACK) &&
+				pm->ps->zoomMode == 1 &&
+				pm->ps->zoomLocked)
+			{
+				if (!pm->cmd.forwardmove &&
+					!pm->cmd.rightmove &&
+					pm->cmd.upmove <= 0)
+				{
+					charging = qtrue;
+					altFire = qtrue;
+				}
+				else
+				{
+					charging = qfalse;
+					altFire = qfalse;
+				}
+			}
+
+			if (pm->ps->zoomMode != 1 &&
+				pm->ps->weaponstate == WEAPON_CHARGING_ALT)
+			{
+				pm->ps->weaponstate = WEAPON_READY;
+				charging = qfalse;
+				altFire = qfalse;
+			}
+
+		} // end switch
+	}
+
+	// set up the appropriate weapon state based on the button that's down.  
+	//	Note that we ALWAYS return if charging is set ( meaning the buttons are still down )
+	if ( charging )
+	{
+		if ( altFire )
+		{
+			if ( pm->ps->weaponstate != WEAPON_CHARGING_ALT )
+			{
+				// charge isn't started, so do it now
+				pm->ps->weaponstate = WEAPON_CHARGING_ALT;
+				pm->ps->weaponChargeTime = pm->cmd.serverTime;
+				pm->ps->weaponChargeSubtractTime = pm->cmd.serverTime + weaponData[pm->ps->weapon].altChargeSubTime;
+
+#ifdef _DEBUG
+				Com_Printf("Starting charge\n");
+#endif
+				assert(pm->ps->weapon > WP_NONE);
+				BG_AddPredictableEventToPlayerstate(EV_WEAPON_CHARGE_ALT, pm->ps->weapon, pm->ps);
+			}
+
+			if ( vehicleRocketLock )
+			{//check vehicle ammo
+				if ( veh && pm->ps->ammo[1] < g_vehWeaponInfo[veh->m_pVehicle->m_pVehicleInfo->weapon[1].ID].iAmmoPerShot )
+				{
+					pm->ps->weaponstate = WEAPON_CHARGING_ALT;
+					goto rest;
+				}
+			}
+			else if (pm->ps->ammo[weaponData[pm->ps->weapon].ammoIndex] < (weaponData[pm->ps->weapon].altChargeSub+weaponData[pm->ps->weapon].altEnergyPerShot))
+			{
+				pm->ps->weaponstate = WEAPON_CHARGING_ALT;
+
+				goto rest;
+			}
+			else if ((pm->cmd.serverTime - pm->ps->weaponChargeTime) < weaponData[pm->ps->weapon].altMaxCharge)
+			{
+				if (pm->ps->weaponChargeSubtractTime < pm->cmd.serverTime)
+				{
+					pm->ps->ammo[weaponData[pm->ps->weapon].ammoIndex] -= weaponData[pm->ps->weapon].altChargeSub;
+					pm->ps->weaponChargeSubtractTime = pm->cmd.serverTime + weaponData[pm->ps->weapon].altChargeSubTime;
+				}
+			}
+		}
+		else
+		{
+			if ( pm->ps->weaponstate != WEAPON_CHARGING )
+			{
+				// charge isn't started, so do it now
+				pm->ps->weaponstate = WEAPON_CHARGING;
+				pm->ps->weaponChargeTime = pm->cmd.serverTime;
+				pm->ps->weaponChargeSubtractTime = pm->cmd.serverTime + weaponData[pm->ps->weapon].chargeSubTime;
+
+#ifdef _DEBUG
+				Com_Printf("Starting charge\n");
+#endif
+				BG_AddPredictableEventToPlayerstate(EV_WEAPON_CHARGE, pm->ps->weapon, pm->ps);
+			}
+
+			if ( vehicleRocketLock )
+			{
+				if ( veh && pm->ps->ammo[0] < g_vehWeaponInfo[veh->m_pVehicle->m_pVehicleInfo->weapon[0].ID].iAmmoPerShot )
+				{//check vehicle ammo
+					pm->ps->weaponstate = WEAPON_CHARGING;
+					goto rest;
+				}
+			}
+			else if (pm->ps->ammo[weaponData[pm->ps->weapon].ammoIndex] < (weaponData[pm->ps->weapon].chargeSub+weaponData[pm->ps->weapon].energyPerShot))
+			{
+				pm->ps->weaponstate = WEAPON_CHARGING;
+
+				goto rest;
+			}
+			else if ((pm->cmd.serverTime - pm->ps->weaponChargeTime) < weaponData[pm->ps->weapon].maxCharge)
+			{
+				if (pm->ps->weaponChargeSubtractTime < pm->cmd.serverTime)
+				{
+					pm->ps->ammo[weaponData[pm->ps->weapon].ammoIndex] -= weaponData[pm->ps->weapon].chargeSub;
+					pm->ps->weaponChargeSubtractTime = pm->cmd.serverTime + weaponData[pm->ps->weapon].chargeSubTime;
+				}
+			}
+		}
+
+		return qtrue; // short-circuit rest of weapon code
+	}
+rest:
+	// Only charging weapons should be able to set these states...so....
+	//	let's see which fire mode we need to set up now that the buttons are up
+	if ( pm->ps->weaponstate == WEAPON_CHARGING )
+	{
+		// weapon has a charge, so let us do an attack
+#ifdef _DEBUG
+		Com_Printf("Firing.  Charge time=%d\n", pm->cmd.serverTime - pm->ps->weaponChargeTime);
+#endif
+
+		// dumb, but since we shoot a charged weapon on button-up, we need to repress this button for now
+		pm->cmd.buttons |= BUTTON_ATTACK;
+		pm->ps->eFlags |= EF_FIRING;
+	}
+	else if ( pm->ps->weaponstate == WEAPON_CHARGING_ALT )
+	{
+		// weapon has a charge, so let us do an alt-attack
+#ifdef _DEBUG
+		Com_Printf("Firing.  Charge time=%d\n", pm->cmd.serverTime - pm->ps->weaponChargeTime);
+#endif
+
+		// dumb, but since we shoot a charged weapon on button-up, we need to repress this button for now
+		pm->cmd.buttons |= BUTTON_ALT_ATTACK;
+		pm->ps->eFlags |= (EF_FIRING|EF_ALT_FIRING);
+	}
+
+	return qfalse; // continue with the rest of the weapon code
+}
+
+
+#define BOWCASTER_CHARGE_UNIT	200.0f	// bowcaster charging gives us one more unit every 200ms--if you change this, you'll have to do the same in g_weapon
+#define BRYAR_CHARGE_UNIT		200.0f	// bryar charging gives us one more unit every 200ms--if you change this, you'll have to do the same in g_weapon
+
+int PM_ItemUsable(playerState_t *ps, int forcedUse)
+{
+	vec3_t fwd, fwdorg, dest, pos;
+	vec3_t yawonly;
+	vec3_t mins, maxs;
+	vec3_t trtest;
+	trace_t tr;
+
+	if (ps->m_iVehicleNum)
+	{
+		return 0;
+	}
+
+	if (ps->pm_flags & PMF_USE_ITEM_HELD)
+	{ //force to let go first
+		return 0;
+	}
+
+	if (ps->duelInProgress)
+	{ //not allowed to use holdables while in a private duel.
+		return 0;
+	}
+
+	if (!forcedUse)
+	{
+		forcedUse = bg_itemlist[ps->stats[STAT_HOLDABLE_ITEM]].giTag;
+	}
+
+	if (!BG_IsItemSelectable(ps, forcedUse))
+	{
+		return 0;
+	}
+
+	switch (forcedUse)
+	{
+	case HI_MEDPAC:
+	case HI_MEDPAC_BIG:
+		if (ps->stats[STAT_HEALTH] >= ps->stats[STAT_MAX_HEALTH])
+		{
+			return 0;
+		}
+		if (ps->stats[STAT_HEALTH] <= 0 ||
+			(ps->eFlags & EF_DEAD))
+		{
+			return 0;
+		}
+
+		return 1;
+	case HI_SEEKER:
+		if (ps->eFlags & EF_SEEKERDRONE)
+		{
+			PM_AddEventWithParm(EV_ITEMUSEFAIL, SEEKER_ALREADYDEPLOYED);
+			return 0;
+		}
+
+		return 1;
+	case HI_SENTRY_GUN:
+		if (ps->fd.sentryDeployed)
+		{
+			PM_AddEventWithParm(EV_ITEMUSEFAIL, SENTRY_ALREADYPLACED);
+			return 0;
+		}
+
+		yawonly[ROLL] = 0;
+		yawonly[PITCH] = 0;
+		yawonly[YAW] = ps->viewangles[YAW];
+
+		VectorSet( mins, -8, -8, 0 );
+		VectorSet( maxs, 8, 8, 24 );
+
+		AngleVectors(yawonly, fwd, NULL, NULL);
+
+		fwdorg[0] = ps->origin[0] + fwd[0]*64;
+		fwdorg[1] = ps->origin[1] + fwd[1]*64;
+		fwdorg[2] = ps->origin[2] + fwd[2]*64;
+
+		trtest[0] = fwdorg[0] + fwd[0]*16;
+		trtest[1] = fwdorg[1] + fwd[1]*16;
+		trtest[2] = fwdorg[2] + fwd[2]*16;
+
+		pm->trace(&tr, ps->origin, mins, maxs, trtest, ps->clientNum, MASK_PLAYERSOLID);
+
+		if ((tr.fraction != 1 && tr.entityNum != ps->clientNum) || tr.startsolid || tr.allsolid)
+		{
+			PM_AddEventWithParm(EV_ITEMUSEFAIL, SENTRY_NOROOM);
+			return 0;
+		}
+
+		return 1;
+	case HI_SHIELD:
+		mins[0] = -8;
+		mins[1] = -8;
+		mins[2] = 0;
+
+		maxs[0] = 8;
+		maxs[1] = 8;
+		maxs[2] = 8;
+
+		AngleVectors (ps->viewangles, fwd, NULL, NULL);
+		fwd[2] = 0;
+		VectorMA(ps->origin, 64, fwd, dest);
+		pm->trace(&tr, ps->origin, mins, maxs, dest, ps->clientNum, MASK_SHOT );
+		if (tr.fraction > 0.9 && !tr.startsolid && !tr.allsolid)
+		{
+			VectorCopy(tr.endpos, pos);
+			VectorSet( dest, pos[0], pos[1], pos[2] - 4096 );
+			pm->trace( &tr, pos, mins, maxs, dest, ps->clientNum, MASK_SOLID );
+			if ( !tr.startsolid && !tr.allsolid )
+			{
+				return 1;
+			}
+		}
+		PM_AddEventWithParm(EV_ITEMUSEFAIL, SHIELD_NOROOM);
+		return 0;
+	case HI_JETPACK: //check for stuff here?
+		return 1;
+	case HI_HEALTHDISP:
+		return 1;
+	case HI_AMMODISP:
+		return 1;
+	case HI_EWEB:
+		return 1;
+	case HI_CLOAK: //check for stuff here?
+		return 1;
+	default:
+		return 1;
+	}
+}
+
+//cheesy vehicle weapon hackery
+qboolean PM_CanSetWeaponAnims(void)
+{
+    if (pm->ps->m_iVehicleNum)
+	{
+		return qfalse;
+	}
+
+	return qtrue;
+}
+
+//perform player anim overrides while on vehicle.
+extern int PM_irand_timesync(int val1, int val2);
+void PM_VehicleWeaponAnimate(void)
+{
+	bgEntity_t *veh = pm_entVeh;
+	Vehicle_t *pVeh;
+	int iFlags = 0, iBlend = 0, Anim = -1;
+
+	if (!veh ||
+		!veh->m_pVehicle ||
+		!veh->m_pVehicle->m_pPilot ||
+		!veh->m_pVehicle->m_pPilot->playerState ||
+		pm->ps->clientNum != veh->m_pVehicle->m_pPilot->playerState->clientNum)
+	{ //make sure the vehicle exists, and its pilot is this player
+		return;
+	}
+
+	pVeh = veh->m_pVehicle;
+
+	if (pVeh->m_pVehicleInfo->type == VH_WALKER ||
+		pVeh->m_pVehicleInfo->type == VH_FIGHTER)
+	{ //slightly hacky I guess, but whatever.
+		return;
+	}
+backAgain:
+	// If they're firing, play the right fire animation.
+	if ( pm->cmd.buttons & ( BUTTON_ATTACK | BUTTON_ALT_ATTACK ) )
+	{
+		iFlags = SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLD;
+		iBlend = 200;
+
+		switch ( pm->ps->weapon )
+		{
+			case WP_SABER:
+				if ( pm->cmd.buttons & BUTTON_ALT_ATTACK )
+				{ //don't do anything.. I guess.
+					pm->cmd.buttons &= ~BUTTON_ALT_ATTACK;
+					goto backAgain;
+				}
+				// If we're already in an attack animation, leave (let it continue).
+				if (pm->ps->torsoTimer <= 0)
+				{ //we'll be starting a new attack
+					PM_AddEvent(EV_SABER_ATTACK);
+				}
+
+				//just set it to something so we have a proper trail. This is a stupid
+				//hack (much like the rest of this function)
+				pm->ps->saberMove = LS_R_TL2BR;
+
+				if ( pm->ps->torsoTimer > 0 && (pm->ps->torsoAnim == BOTH_VS_ATR_S ||
+						pm->ps->torsoAnim == BOTH_VS_ATL_S) )
+				{
+					/*
+					//FIXME: no need to even call the PM_SetAnim at all in this case
+					Anim = (animNumber_t)pm->ps->torsoAnim;
+					iFlags = SETANIM_FLAG_NORMAL;
+					break;
+					*/
+					return;
+				}
+
+				// Start the attack.
+				if ( pm->cmd.rightmove > 0 )	//right side attack
+				{
+					Anim = BOTH_VS_ATR_S;
+				}
+				else if ( pm->cmd.rightmove < 0 )	//left-side attack
+				{
+					Anim = BOTH_VS_ATL_S;
+				}
+				else	//random
+				{
+					//FIXME: alternate back and forth or auto-aim?
+					//if ( !Q_irand( 0, 1 ) )
+					if (!PM_irand_timesync(0, 1))
+					{
+						Anim = BOTH_VS_ATR_S;
+					}
+					else
+					{
+						Anim = BOTH_VS_ATL_S;
+					}
+				}
+
+				if (pm->ps->torsoTimer <= 0)
+				{ //restart the anim if we are already in it (and finished)
+					iFlags |= SETANIM_FLAG_RESTART;
+				}
+				break;
+
+			case WP_BLASTER:
+				// Override the shoot anim.
+				if ( pm->ps->torsoAnim == BOTH_ATTACK3 )
+				{
+					if ( pm->cmd.rightmove > 0 )			//right side attack
+					{
+						Anim = BOTH_VS_ATR_G;
+					}
+					else if ( pm->cmd.rightmove < 0 )	//left side
+					{
+						Anim = BOTH_VS_ATL_G;
+					}
+					else	//frontal
+					{
+						Anim = BOTH_VS_ATF_G;
+					}
+				}
+				break;
+
+			default:
+				Anim = BOTH_VS_IDLE;
+				break;
+		}
+	}
+	else if (veh->playerState && veh->playerState->speed < 0 &&
+		pVeh->m_pVehicleInfo->type == VH_ANIMAL)
+	{ //tauntaun is going backwards
+		Anim = BOTH_VT_WALK_REV;
+		iBlend = 600;
+	}
+	else if (veh->playerState && veh->playerState->speed < 0 &&
+		pVeh->m_pVehicleInfo->type == VH_SPEEDER)
+	{ //speeder is going backwards
+		Anim = BOTH_VS_REV;
+		iBlend = 600;
+	}
+	// They're not firing so play the Idle for the weapon.
+	else
+	{
+		iFlags = SETANIM_FLAG_NORMAL;
+
+		switch ( pm->ps->weapon )
+		{
+			case WP_SABER:
+				if ( BG_SabersOff( pm->ps ) )
+				{ //saber holstered, normal idle
+					Anim = BOTH_VS_IDLE;
+				}
+				// In the Air.
+				//else if ( pVeh->m_ulFlags & VEH_FLYING )
+				else if (0)
+				{
+					iBlend = 800;
+					Anim = BOTH_VS_AIR_G;
+					iFlags = SETANIM_FLAG_OVERRIDE;
+				}
+				// Crashing.
+				//else if ( pVeh->m_ulFlags & VEH_CRASHING )
+				else if (0)
+				{
+					pVeh->m_ulFlags &= ~VEH_CRASHING;	// Remove the flag, we are doing the animation.
+					iBlend = 800;
+					Anim = BOTH_VS_LAND_SR;
+					iFlags = SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLD;
+				}
+				else
+				{
+					Anim = BOTH_VS_IDLE_SR;
+				}
+				break;
+
+			case WP_BLASTER:
+				// In the Air.
+				//if ( pVeh->m_ulFlags & VEH_FLYING )
+				if (0)
+				{
+					iBlend = 800;
+					Anim = BOTH_VS_AIR_G;
+					iFlags = SETANIM_FLAG_OVERRIDE;
+				}
+				// Crashing.
+				//else if ( pVeh->m_ulFlags & VEH_CRASHING )
+				else if (0)
+				{
+					pVeh->m_ulFlags &= ~VEH_CRASHING;	// Remove the flag, we are doing the animation.
+					iBlend = 800;
+					Anim = BOTH_VS_LAND_G;
+					iFlags = SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLD;
+				}
+				else
+				{
+					Anim = BOTH_VS_IDLE_G;
+				}
+				break;
+
+			default:
+				Anim = BOTH_VS_IDLE;
+				break;
+		}
+	}
+
+	if (Anim != -1)
+	{ //override it
+		if (pVeh->m_pVehicleInfo->type == VH_ANIMAL)
+		{ //agh.. remap anims for the tauntaun
+			switch (Anim)
+			{
+			case BOTH_VS_IDLE:
+				if (veh->playerState && veh->playerState->speed > 0)
+				{
+					if (veh->playerState->speed > pVeh->m_pVehicleInfo->speedMax)
+					{ //turbo
+						Anim = BOTH_VT_TURBO;
+					}
+					else
+					{
+						Anim = BOTH_VT_RUN_FWD;
+					}
+				}
+				else
+				{
+					Anim = BOTH_VT_IDLE;
+				}
+				break;
+			case BOTH_VS_ATR_S:
+				Anim = BOTH_VT_ATR_S;
+				break;
+			case BOTH_VS_ATL_S:
+				Anim = BOTH_VT_ATL_S;
+				break;
+			case BOTH_VS_ATR_G:
+                Anim = BOTH_VT_ATR_G;
+				break;
+			case BOTH_VS_ATL_G:
+				Anim = BOTH_VT_ATL_G;
+				break;
+			case BOTH_VS_ATF_G:
+				Anim = BOTH_VT_ATF_G;
+				break;
+			case BOTH_VS_IDLE_SL:
+				Anim = BOTH_VT_IDLE_S;
+				break;
+			case BOTH_VS_IDLE_SR:
+				Anim = BOTH_VT_IDLE_S;
+				break;
+			case BOTH_VS_IDLE_G:
+				Anim = BOTH_VT_IDLE_G;
+				break;
+
+			//should not happen for tauntaun:
+			case BOTH_VS_AIR_G:
+			case BOTH_VS_LAND_SL:
+			case BOTH_VS_LAND_SR:
+			case BOTH_VS_LAND_G:
+				return;
+			default:
+				break;
+			}
+		}
+
+		PM_SetAnim(SETANIM_BOTH, Anim, iFlags, iBlend);
+	}
+}
+
+/*
+==============
+PM_Weapon
+
+Generates weapon events and modifes the weapon counter
+==============
+*/
+extern int PM_KickMoveForConditions(void);
+static void PM_Weapon( void )
+{
+	int		addTime;
+	int amount;
+	int		killAfterItem = 0;
+	bgEntity_t *veh = NULL;
+	qboolean vehicleRocketLock = qfalse;
+
+#ifdef QAGAME
+	if (pm->ps->clientNum >= MAX_CLIENTS &&
+		pm->ps->weapon == WP_NONE &&
+		pm->cmd.weapon == WP_NONE &&
+		pm_entSelf)
+	{ //npc with no weapon
+		gentity_t *gent = (gentity_t *)pm_entSelf;
+		if (gent->inuse && gent->client &&
+			!gent->localAnimIndex)
+		{ //humanoid
+			pm->ps->torsoAnim = pm->ps->legsAnim;
+			pm->ps->torsoTimer = pm->ps->legsTimer;
+			return;
+		}
+	}
+#endif
+
+	if (!pm->ps->emplacedIndex &&
+		pm->ps->weapon == WP_EMPLACED_GUN)
+	{ //oh no!
+		int i = 0;
+		int weap = -1;
+
+		while (i < WP_NUM_WEAPONS)
+		{
+			if ((pm->ps->stats[STAT_WEAPONS] & (1 << i)) && i != WP_NONE)
+			{ //this one's good
+				weap = i;
+				break;
+			}
+			i++;
+		}
+
+		if (weap != -1)
+		{
+			pm->cmd.weapon = weap;
+			pm->ps->weapon = weap;
+			return;
+		}
+	}
+
+	if (pm_entSelf->s.NPC_class!=CLASS_VEHICLE
+		&&pm->ps->m_iVehicleNum)
+	{ //riding a vehicle
+		veh = pm_entVeh;
+		if ( veh &&
+			(veh->m_pVehicle && veh->m_pVehicle->m_pVehicleInfo->type == VH_WALKER || veh->m_pVehicle && veh->m_pVehicle->m_pVehicleInfo->type == VH_FIGHTER) )
+		{//riding a walker/fighter
+			//keep saber off, do no weapon stuff at all!
+			pm->ps->saberHolstered = 2;
+#ifdef QAGAME
+			pm->cmd.buttons &= ~(BUTTON_ATTACK|BUTTON_ALT_ATTACK);
+#else
+			if ( g_vehWeaponInfo[veh->m_pVehicle->m_pVehicleInfo->weapon[0].ID].fHoming
+				||  g_vehWeaponInfo[veh->m_pVehicle->m_pVehicleInfo->weapon[1].ID].fHoming )
+			{//our vehicle uses a rocket launcher, so do the normal checks
+				vehicleRocketLock = qtrue;
+				pm->cmd.buttons &= ~BUTTON_ATTACK;
+			}
+			else
+			{
+				pm->cmd.buttons &= ~(BUTTON_ATTACK|BUTTON_ALT_ATTACK);
+			}
+#endif
+		}
+	}
+
+	if (pm->ps->weapon != WP_DISRUPTOR //not using disruptor
+		&& pm->ps->weapon != WP_ROCKET_LAUNCHER//not using rocket launcher
+		&& pm->ps->weapon != WP_THERMAL//not using thermals
+		&& !pm->ps->m_iVehicleNum )//not a vehicle or in a vehicle
+	{ //check for exceeding max charge time if not using disruptor or rocket launcher or thermals
+		if ( pm->ps->weaponstate == WEAPON_CHARGING_ALT )
+		{
+			int timeDif = (pm->cmd.serverTime - pm->ps->weaponChargeTime);
+
+			if (timeDif > MAX_WEAPON_CHARGE_TIME)
+			{
+				pm->cmd.buttons &= ~BUTTON_ALT_ATTACK;
+			}
+		}
+
+		if ( pm->ps->weaponstate == WEAPON_CHARGING )
+		{
+			int timeDif = (pm->cmd.serverTime - pm->ps->weaponChargeTime);
+
+			if (timeDif > MAX_WEAPON_CHARGE_TIME)
+			{
+				pm->cmd.buttons &= ~BUTTON_ATTACK;
+			}
+		}
+	}
+
+	if (pm->ps->forceHandExtend == HANDEXTEND_WEAPONREADY &&
+		PM_CanSetWeaponAnims())
+	{ //reset into weapon stance
+		if (pm->ps->weapon != WP_SABER && pm->ps->weapon != WP_MELEE && !PM_IsRocketTrooper())
+		{ //saber handles its own anims
+			if (pm->ps->weapon == WP_DISRUPTOR && pm->ps->zoomMode == 1)
+			{
+				//PM_StartTorsoAnim( TORSO_WEAPONREADY4 );
+				PM_StartTorsoAnim( TORSO_RAISEWEAP1);
+			}
+			else
+			{
+				if (pm->ps->weapon == WP_EMPLACED_GUN)
+				{
+					PM_StartTorsoAnim( BOTH_GUNSIT1 );
+				}
+				else
+				{
+					//PM_StartTorsoAnim( WeaponReadyAnim[pm->ps->weapon] );
+					PM_StartTorsoAnim( TORSO_RAISEWEAP1);
+				}
+			}
+		}
+
+		//we now go into a weapon raise anim after every force hand extend.
+		//this is so that my holster-view-weapon-when-hand-extend stuff works.
+		pm->ps->weaponstate = WEAPON_RAISING;
+		pm->ps->weaponTime += 250;
+
+		pm->ps->forceHandExtend = HANDEXTEND_NONE;
+	}
+	else if (pm->ps->forceHandExtend != HANDEXTEND_NONE)
+	{ //nothing else should be allowed to happen during this time, including weapon fire
+		int desiredAnim = 0;
+		qboolean seperateOnTorso = qfalse;
+		qboolean playFullBody = qfalse;
+		int desiredOnTorso = 0;
+
+		switch(pm->ps->forceHandExtend)
+		{
+		case HANDEXTEND_FORCEPUSH:
+			desiredAnim = BOTH_FORCEPUSH;
+			break;
+		case HANDEXTEND_FORCEPULL:
+			desiredAnim = BOTH_FORCEPULL;
+			break;
+		case HANDEXTEND_FORCE_HOLD:
+			if ( (pm->ps->fd.forcePowersActive&(1<<FP_GRIP)) )
+			{//gripping
+				desiredAnim = BOTH_FORCEGRIP_HOLD;
+			}
+			else if ( (pm->ps->fd.forcePowersActive&(1<<FP_LIGHTNING)) )
+			{//lightning
+				if ( pm->ps->weapon == WP_MELEE
+					&& pm->ps->activeForcePass > FORCE_LEVEL_2 )
+				{//2-handed lightning
+					desiredAnim = BOTH_FORCE_2HANDEDLIGHTNING_HOLD;
+				}
+				else
+				{
+					desiredAnim = BOTH_FORCELIGHTNING_HOLD;
+				}
+			}
+			else if ( (pm->ps->fd.forcePowersActive&(1<<FP_DRAIN)) )
+			{//draining
+				desiredAnim = BOTH_FORCEGRIP_HOLD;
+			}
+			else
+			{//???
+				desiredAnim = BOTH_FORCEGRIP_HOLD;
+			}
+			break;
+		case HANDEXTEND_SABERPULL:
+			desiredAnim = BOTH_SABERPULL;
+			break;
+		case HANDEXTEND_CHOKE:
+			desiredAnim = BOTH_CHOKE3; //left-handed choke
+			break;
+		case HANDEXTEND_DODGE:
+			desiredAnim = pm->ps->forceDodgeAnim;
+			break;
+		case HANDEXTEND_KNOCKDOWN:
+			if (pm->ps->forceDodgeAnim)
+			{
+				if (pm->ps->forceDodgeAnim > 4)
+				{ //this means that we want to play a sepereate anim on the torso
+					int originalDAnim = pm->ps->forceDodgeAnim-8; //-8 is the original legs anim
+					if (originalDAnim == 2)
+					{
+						desiredAnim = BOTH_FORCE_GETUP_B1;
+					}
+					else if (originalDAnim == 3)
+					{
+						desiredAnim = BOTH_FORCE_GETUP_B3;
+					}
+					else
+					{
+						desiredAnim = BOTH_GETUP1;
+					}
+
+					//now specify the torso anim
+					seperateOnTorso = qtrue;
+					desiredOnTorso = BOTH_FORCEPUSH;
+				}
+				else if (pm->ps->forceDodgeAnim == 2)
+				{
+					desiredAnim = BOTH_FORCE_GETUP_B1;
+				}
+				else if (pm->ps->forceDodgeAnim == 3)
+				{
+					desiredAnim = BOTH_FORCE_GETUP_B3;
+				}
+				else
+				{
+					desiredAnim = BOTH_GETUP1;
+				}
+			}
+			else
+			{
+				desiredAnim = BOTH_KNOCKDOWN1;
+			}
+			break;
+		case HANDEXTEND_DUELCHALLENGE:
+			desiredAnim = BOTH_ENGAGETAUNT;
+			break;
+		case HANDEXTEND_TAUNT:
+			desiredAnim = pm->ps->forceDodgeAnim;
+			if ( desiredAnim != BOTH_ENGAGETAUNT 
+				&& VectorCompare( pm->ps->velocity, vec3_origin )
+				&& pm->ps->groundEntityNum != ENTITYNUM_NONE ) 
+			{
+				playFullBody = qtrue;
+			}
+			break;
+		case HANDEXTEND_PRETHROW:
+			desiredAnim = BOTH_A3_TL_BR;
+			playFullBody = qtrue;
+			break;
+		case HANDEXTEND_POSTTHROW:
+			desiredAnim = BOTH_D3_TL___;
+			playFullBody = qtrue;
+			break;
+		case HANDEXTEND_PRETHROWN:
+			desiredAnim = BOTH_KNEES1;
+			playFullBody = qtrue;
+			break;
+		case HANDEXTEND_POSTTHROWN:
+			if (pm->ps->forceDodgeAnim)
+			{
+				desiredAnim = BOTH_FORCE_GETUP_F2;
+			}
+			else
+			{
+				desiredAnim = BOTH_KNOCKDOWN5;
+			}
+			playFullBody = qtrue;
+			break;
+		case HANDEXTEND_DRAGGING:
+			desiredAnim = BOTH_B1_BL___;
+			break;
+		case HANDEXTEND_JEDITAUNT:
+			desiredAnim = BOTH_GESTURE1;
+			//playFullBody = qtrue;
+			break;
+			//Hmm... maybe use these, too?
+			//BOTH_FORCEHEAL_QUICK //quick heal (SP level 2 & 3)
+			//BOTH_MINDTRICK1 // wave (maybe for mind trick 2 & 3 - whole area, and for force seeing)
+			//BOTH_MINDTRICK2 // tap (maybe for mind trick 1 - one person)
+			//BOTH_FORCEGRIP_START //start grip
+			//BOTH_FORCEGRIP_HOLD //hold grip
+			//BOTH_FORCEGRIP_RELEASE //release grip
+			//BOTH_FORCELIGHTNING //quick lightning burst (level 1)
+			//BOTH_FORCELIGHTNING_START //start lightning
+			//BOTH_FORCELIGHTNING_HOLD //hold lightning
+			//BOTH_FORCELIGHTNING_RELEASE //release lightning
+		default:
+			desiredAnim = BOTH_FORCEPUSH;
+			break;
+		}
+
+		if (!seperateOnTorso)
+		{ //of seperateOnTorso, handle it after setting the legs
+			PM_SetAnim(SETANIM_TORSO, desiredAnim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD, 100);
+			pm->ps->torsoTimer = 1;
+		}
+
+		if (playFullBody)
+		{ //sorry if all these exceptions are getting confusing. This one just means play on both legs and torso.
+			PM_SetAnim(SETANIM_BOTH, desiredAnim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD, 100);
+			pm->ps->legsTimer = pm->ps->torsoTimer = 1;
+		}
+		else if (pm->ps->forceHandExtend == HANDEXTEND_DODGE || pm->ps->forceHandExtend == HANDEXTEND_KNOCKDOWN ||
+			(pm->ps->forceHandExtend == HANDEXTEND_CHOKE && pm->ps->groundEntityNum == ENTITYNUM_NONE) )
+		{ //special case, play dodge anim on whole body, choke anim too if off ground
+			if (seperateOnTorso)
+			{
+				PM_SetAnim(SETANIM_LEGS, desiredAnim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD, 100);
+				pm->ps->legsTimer = 1;
+
+				PM_SetAnim(SETANIM_TORSO, desiredOnTorso, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD, 100);
+				pm->ps->torsoTimer = 1;
+			}
+			else
+			{
+				PM_SetAnim(SETANIM_LEGS, desiredAnim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD, 100);
+				pm->ps->legsTimer = 1;
+			}
+		}
+
+		return;
+	}
+
+	if (BG_InSpecialJump(pm->ps->legsAnim) ||
+		BG_InRoll(pm->ps, pm->ps->legsAnim) ||
+		PM_InRollComplete(pm->ps, pm->ps->legsAnim))
+	{
+		/*
+		if (pm->cmd.weapon != WP_MELEE &&
+			pm->ps->weapon != WP_MELEE &&
+			(pm->ps->stats[STAT_WEAPONS] & (1<<WP_SABER)))
+		{ //it's alright also if we are melee
+			pm->cmd.weapon = WP_SABER;
+			pm->ps->weapon = WP_SABER;
+		}
+		*/
+		if (pm->ps->weaponTime < pm->ps->legsTimer)
+		{
+			pm->ps->weaponTime = pm->ps->legsTimer;
+		}
+	}
+
+	if (pm->ps->duelInProgress)
+	{
+		pm->cmd.weapon = WP_SABER;
+		pm->ps->weapon = WP_SABER;
+
+		if (pm->ps->duelTime >= pm->cmd.serverTime)
+		{
+			pm->cmd.upmove = 0;
+			pm->cmd.forwardmove = 0;
+			pm->cmd.rightmove = 0;
+		}
+	}
+
+	if (pm->ps->weapon == WP_SABER && pm->ps->saberMove != LS_READY && pm->ps->saberMove != LS_NONE)
+	{
+		pm->cmd.weapon = WP_SABER; //don't allow switching out mid-attack
+	}
+
+	if (pm->ps->weapon == WP_SABER)
+	{
+		//rww - we still need the item stuff, so we won't return immediately
+		PM_WeaponLightsaber();
+		killAfterItem = 1;
+	}
+	else if (pm->ps->weapon != WP_EMPLACED_GUN)
+	{
+		pm->ps->saberHolstered = 0;
+	}
+
+	if (PM_CanSetWeaponAnims())
+	{
+		if (pm->ps->weapon == WP_THERMAL ||
+			pm->ps->weapon == WP_TRIP_MINE ||
+			pm->ps->weapon == WP_DET_PACK)
+		{
+			if (pm->ps->weapon == WP_THERMAL)
+			{
+				if ((pm->ps->torsoAnim) == WeaponAttackAnim[pm->ps->weapon] &&
+					(pm->ps->weaponTime-200) <= 0)
+				{
+					PM_StartTorsoAnim( WeaponReadyAnim[pm->ps->weapon] );
+				}
+			}
+			else
+			{
+				if ((pm->ps->torsoAnim) == WeaponAttackAnim[pm->ps->weapon] &&
+					(pm->ps->weaponTime-700) <= 0)
+				{
+					PM_StartTorsoAnim( WeaponReadyAnim[pm->ps->weapon] );
+				}
+			}
+		}
+	}
+
+	// don't allow attack until all buttons are up
+	if ( pm->ps->pm_flags & PMF_RESPAWNED ) {
+		return;
+	}
+
+	// ignore if spectator
+	if ( pm->ps->clientNum < MAX_CLIENTS && pm->ps->persistant[PERS_TEAM] == TEAM_SPECTATOR ) {
+			return;
+	}
+
+	// check for dead player
+	if ( pm->ps->stats[STAT_HEALTH] <= 0 ) {
+		pm->ps->weapon = WP_NONE;
+		return;
+	}
+
+	// check for item using
+	if ( pm->cmd.buttons & BUTTON_USE_HOLDABLE ) {
+		if ( ! ( pm->ps->pm_flags & PMF_USE_ITEM_HELD ) ) {
+
+			if (pm_entSelf->s.NPC_class!=CLASS_VEHICLE
+				&& pm->ps->m_iVehicleNum)
+			{//riding a vehicle, can't use holdable items, this button operates as the weapon link/unlink toggle
+				return;
+			}
+
+			if (!pm->ps->stats[STAT_HOLDABLE_ITEM])
+			{
+				return;
+			}
+
+			if (!PM_ItemUsable(pm->ps, 0))
+			{
+				pm->ps->pm_flags |= PMF_USE_ITEM_HELD;
+				return;
+			}
+			else
+			{
+				if (pm->ps->stats[STAT_HOLDABLE_ITEMS] & (1 << bg_itemlist[pm->ps->stats[STAT_HOLDABLE_ITEM]].giTag))
+				{
+					if (bg_itemlist[pm->ps->stats[STAT_HOLDABLE_ITEM]].giTag != HI_BINOCULARS &&
+						bg_itemlist[pm->ps->stats[STAT_HOLDABLE_ITEM]].giTag != HI_JETPACK &&
+						bg_itemlist[pm->ps->stats[STAT_HOLDABLE_ITEM]].giTag != HI_HEALTHDISP &&
+						bg_itemlist[pm->ps->stats[STAT_HOLDABLE_ITEM]].giTag != HI_AMMODISP &&
+						bg_itemlist[pm->ps->stats[STAT_HOLDABLE_ITEM]].giTag != HI_CLOAK &&
+						bg_itemlist[pm->ps->stats[STAT_HOLDABLE_ITEM]].giTag != HI_EWEB)
+					{ //never use up the binoculars or jetpack or dispensers or cloak or ...
+						pm->ps->stats[STAT_HOLDABLE_ITEMS] -= (1 << bg_itemlist[pm->ps->stats[STAT_HOLDABLE_ITEM]].giTag);
+					}
+				}
+				else
+				{
+					return; //this should not happen...
+				}
+
+				pm->ps->pm_flags |= PMF_USE_ITEM_HELD;
+				PM_AddEvent( EV_USE_ITEM0 + bg_itemlist[pm->ps->stats[STAT_HOLDABLE_ITEM]].giTag );
+
+				if (bg_itemlist[pm->ps->stats[STAT_HOLDABLE_ITEM]].giTag != HI_BINOCULARS &&
+					bg_itemlist[pm->ps->stats[STAT_HOLDABLE_ITEM]].giTag != HI_JETPACK &&
+					bg_itemlist[pm->ps->stats[STAT_HOLDABLE_ITEM]].giTag != HI_HEALTHDISP &&
+					bg_itemlist[pm->ps->stats[STAT_HOLDABLE_ITEM]].giTag != HI_AMMODISP &&
+					bg_itemlist[pm->ps->stats[STAT_HOLDABLE_ITEM]].giTag != HI_CLOAK &&
+					bg_itemlist[pm->ps->stats[STAT_HOLDABLE_ITEM]].giTag != HI_EWEB)
+				{
+					pm->ps->stats[STAT_HOLDABLE_ITEM] = 0;
+					BG_CycleInven(pm->ps, 1);
+				}
+			}
+			return;
+		}
+	} else {
+		pm->ps->pm_flags &= ~PMF_USE_ITEM_HELD;
+	}
+
+	/*
+	if (pm->ps->weapon == WP_SABER || pm->ps->weapon == WP_MELEE)
+	{ //we can't toggle zoom while using saber (for obvious reasons) so make sure it's always off
+		pm->ps->zoomMode = 0;
+		pm->ps->zoomFov = 0;
+		pm->ps->zoomLocked = qfalse;
+		pm->ps->zoomLockTime = 0;
+	}
+	*/
+
+	if (killAfterItem)
+	{
+		return;
+	}
+
+	// make weapon function
+	if ( pm->ps->weaponTime > 0 ) {
+		pm->ps->weaponTime -= pml.msec;
+	}
+
+	if (pm->ps->isJediMaster && pm->ps->emplacedIndex)
+	{
+		pm->ps->emplacedIndex = 0;
+		pm->ps->saberHolstered = 0;
+	}
+
+	if (pm->ps->duelInProgress && pm->ps->emplacedIndex)
+	{
+		pm->ps->emplacedIndex = 0;
+		pm->ps->saberHolstered = 0;
+	}
+
+	if (pm->ps->weapon == WP_EMPLACED_GUN && pm->ps->emplacedIndex)
+	{
+		pm->cmd.weapon = WP_EMPLACED_GUN; //No switch for you!
+		PM_StartTorsoAnim( BOTH_GUNSIT1 );
+	}
+
+	if (pm->ps->isJediMaster || pm->ps->duelInProgress || pm->ps->trueJedi)
+	{
+		pm->cmd.weapon = WP_SABER;
+		pm->ps->weapon = WP_SABER;
+
+		if (pm->ps->isJediMaster || pm->ps->trueJedi)
+		{
+			pm->ps->stats[STAT_WEAPONS] = (1 << WP_SABER);
+		}
+	}
+
+	amount = weaponData[pm->ps->weapon].energyPerShot;
+
+	// take an ammo away if not infinite
+	if ( pm->ps->weapon != WP_NONE &&
+		pm->ps->weapon == pm->cmd.weapon &&
+		(pm->ps->weaponTime <= 0 || pm->ps->weaponstate != WEAPON_FIRING) )
+	{
+		if ( pm->ps->clientNum < MAX_CLIENTS && pm->ps->ammo[ weaponData[pm->ps->weapon].ammoIndex ] != -1 )
+		{
+			// enough energy to fire this weapon?
+			if (pm->ps->ammo[weaponData[pm->ps->weapon].ammoIndex] < weaponData[pm->ps->weapon].energyPerShot &&
+				pm->ps->ammo[weaponData[pm->ps->weapon].ammoIndex] < weaponData[pm->ps->weapon].altEnergyPerShot) 
+			{ //the weapon is out of ammo essentially because it cannot fire primary or secondary, so do the switch
+			  //regardless of if the player is attacking or not
+				PM_AddEventWithParm( EV_NOAMMO, WP_NUM_WEAPONS+pm->ps->weapon );
+
+				if (pm->ps->weaponTime < 500)
+				{
+					pm->ps->weaponTime += 500;
+				}
+				return;
+			}
+
+			if (pm->ps->weapon == WP_DET_PACK && !pm->ps->hasDetPackPlanted && pm->ps->ammo[weaponData[pm->ps->weapon].ammoIndex] < 1)
+			{
+				PM_AddEventWithParm( EV_NOAMMO, WP_NUM_WEAPONS+pm->ps->weapon );
+
+				if (pm->ps->weaponTime < 500)
+				{
+					pm->ps->weaponTime += 500;
+				}
+				return;
+			}
+		}
+	}
+
+	// check for weapon change
+	// can't change if weapon is firing, but can change
+	// again if lowering or raising
+	if ( pm->ps->weaponTime <= 0 || pm->ps->weaponstate != WEAPON_FIRING ) {
+		if ( pm->ps->weapon != pm->cmd.weapon ) {
+			PM_BeginWeaponChange( pm->cmd.weapon );
+		}
+	}
+
+	if ( pm->ps->weaponTime > 0 ) {
+		return;
+	}
+
+	if (pm->ps->weapon == WP_DISRUPTOR &&
+		pm->ps->zoomMode == 1)
+	{
+		if (pm_cancelOutZoom)
+		{
+			pm->ps->zoomMode = 0;
+			pm->ps->zoomFov = 0;
+			pm->ps->zoomLocked = qfalse;
+			pm->ps->zoomLockTime = 0;
+			PM_AddEvent( EV_DISRUPTOR_ZOOMSOUND );
+			return;
+		}
+
+		if (pm->cmd.forwardmove ||
+			pm->cmd.rightmove ||
+			pm->cmd.upmove > 0)
+		{
+			return;
+		}
+	}
+
+	// change weapon if time
+	if ( pm->ps->weaponstate == WEAPON_DROPPING ) {
+		PM_FinishWeaponChange();
+		return;
+	}
+
+	if ( pm->ps->weaponstate == WEAPON_RAISING ) {
+		pm->ps->weaponstate = WEAPON_READY;
+		if (PM_CanSetWeaponAnims())
+		{
+			if ( pm->ps->weapon == WP_SABER )
+			{
+				PM_StartTorsoAnim( PM_GetSaberStance() );
+			}
+			else if (pm->ps->weapon == WP_MELEE || PM_IsRocketTrooper())
+			{
+				PM_StartTorsoAnim( pm->ps->legsAnim );
+			}
+			else
+			{
+				if (pm->ps->weapon == WP_DISRUPTOR && pm->ps->zoomMode == 1)
+				{
+					PM_StartTorsoAnim( TORSO_WEAPONREADY4 );
+				}
+				else
+				{
+					if (pm->ps->weapon == WP_EMPLACED_GUN)
+					{
+						PM_StartTorsoAnim( BOTH_GUNSIT1 );
+					}
+					else
+					{
+						PM_StartTorsoAnim( WeaponReadyAnim[pm->ps->weapon] );
+					}
+				}
+			}
+		}
+		return;
+	}
+
+	if (PM_CanSetWeaponAnims() &&
+		!PM_IsRocketTrooper() &&
+		pm->ps->weaponstate == WEAPON_READY && pm->ps->weaponTime <= 0 &&
+		(pm->ps->weapon >= WP_BRYAR_PISTOL || pm->ps->weapon == WP_STUN_BATON) &&
+		pm->ps->torsoTimer <= 0 &&
+		(pm->ps->torsoAnim) != WeaponReadyAnim[pm->ps->weapon] &&
+		pm->ps->torsoAnim != TORSO_WEAPONIDLE3 &&
+		pm->ps->weapon != WP_EMPLACED_GUN)
+	{
+		PM_StartTorsoAnim( WeaponReadyAnim[pm->ps->weapon] );
+	}
+	else if (PM_CanSetWeaponAnims() &&
+		pm->ps->weapon == WP_MELEE)
+	{
+		if (pm->ps->weaponTime <= 0 &&
+			pm->ps->forceHandExtend == HANDEXTEND_NONE)
+		{
+			int desTAnim = pm->ps->legsAnim;
+
+			if (desTAnim == BOTH_STAND1 ||
+				desTAnim == BOTH_STAND2)
+			{ //remap the standard standing anims for melee stance
+				desTAnim = BOTH_STAND6;
+			}
+
+			if (!(pm->cmd.buttons & (BUTTON_ATTACK|BUTTON_ALT_ATTACK)))
+			{ //don't do this while holding attack
+				if (pm->ps->torsoAnim != desTAnim)
+				{
+					PM_StartTorsoAnim( desTAnim );
+				}
+			}
+		}
+	}
+	else if (PM_CanSetWeaponAnims() && PM_IsRocketTrooper())
+	{
+		int desTAnim = pm->ps->legsAnim;
+
+		if (!(pm->cmd.buttons & (BUTTON_ATTACK|BUTTON_ALT_ATTACK)))
+		{ //don't do this while holding attack
+			if (pm->ps->torsoAnim != desTAnim)
+			{
+				PM_StartTorsoAnim( desTAnim );
+			}
+		}
+	}
+
+	if (((pm->ps->torsoAnim) == TORSO_WEAPONREADY4 ||
+		(pm->ps->torsoAnim) == BOTH_ATTACK4) &&
+		(pm->ps->weapon != WP_DISRUPTOR || pm->ps->zoomMode != 1))
+	{
+		if (pm->ps->weapon == WP_EMPLACED_GUN)
+		{
+			PM_StartTorsoAnim( BOTH_GUNSIT1 );
+		}
+		else if (PM_CanSetWeaponAnims())
+		{
+			PM_StartTorsoAnim( WeaponReadyAnim[pm->ps->weapon] );
+		}
+	}
+	else if (((pm->ps->torsoAnim) != TORSO_WEAPONREADY4 &&
+		(pm->ps->torsoAnim) != BOTH_ATTACK4) &&
+		PM_CanSetWeaponAnims() &&
+		(pm->ps->weapon == WP_DISRUPTOR && pm->ps->zoomMode == 1))
+	{
+		PM_StartTorsoAnim( TORSO_WEAPONREADY4 );
+	}
+
+	if (pm->ps->clientNum >= MAX_CLIENTS &&
+		pm_entSelf &&
+		pm_entSelf->s.NPC_class == CLASS_VEHICLE)
+	{//we are a vehicle
+		veh = pm_entSelf;
+	}
+	if ( veh 
+		&& veh->m_pVehicle )
+	{
+		if ( g_vehWeaponInfo[veh->m_pVehicle->m_pVehicleInfo->weapon[0].ID].fHoming
+			|| g_vehWeaponInfo[veh->m_pVehicle->m_pVehicleInfo->weapon[1].ID].fHoming )
+		{//don't clear the rocket locking ever?
+			vehicleRocketLock = qtrue;
+		}
+	}
+
+	if ( !vehicleRocketLock )
+	{
+		if (pm->ps->weapon != WP_ROCKET_LAUNCHER)
+		{
+			if (pm_entSelf->s.NPC_class!=CLASS_VEHICLE
+				&&pm->ps->m_iVehicleNum)
+			{//riding a vehicle, the vehicle will tell me my rocketlock stuff...
+			}
+			else
+			{
+				pm->ps->rocketLockIndex = ENTITYNUM_NONE;
+				pm->ps->rocketLockTime = 0;
+				pm->ps->rocketTargetTime = 0;
+			}
+		}
+	}
+
+	if ( PM_DoChargedWeapons(vehicleRocketLock, veh))
+	{
+		// In some cases the charged weapon code may want us to short circuit the rest of the firing code
+		return;
+	}
+
+	// check for fire
+	if ( ! (pm->cmd.buttons & (BUTTON_ATTACK|BUTTON_ALT_ATTACK))) 
+	{
+		pm->ps->weaponTime = 0;
+		pm->ps->weaponstate = WEAPON_READY;
+		return;
+	}
+
+	if (pm->ps->weapon == WP_EMPLACED_GUN)
+	{
+		addTime = weaponData[pm->ps->weapon].fireTime;
+		pm->ps->weaponTime += addTime;
+		if ( (pm->cmd.buttons & BUTTON_ALT_ATTACK) )
+		{
+			PM_AddEvent( EV_ALT_FIRE );
+		}
+		else
+		{
+			PM_AddEvent( EV_FIRE_WEAPON );
+		}
+		return;
+	}
+	else if (pm->ps->m_iVehicleNum
+		&& pm_entSelf->s.NPC_class==CLASS_VEHICLE)
+	{ //a vehicle NPC that has a pilot
+		pm->ps->weaponstate = WEAPON_FIRING;
+		pm->ps->weaponTime += 100;
+#ifdef QAGAME //hack, only do it game-side. vehicle weapons don't really need predicting I suppose.
+		if ( (pm->cmd.buttons & BUTTON_ALT_ATTACK) )
+		{
+			G_CheapWeaponFire(pm->ps->clientNum, EV_ALT_FIRE);
+		}
+		else
+		{
+			G_CheapWeaponFire(pm->ps->clientNum, EV_FIRE_WEAPON);
+		}
+#endif
+		/*
+		addTime = weaponData[WP_EMPLACED_GUN].fireTime;
+		pm->ps->weaponTime += addTime;
+		if ( (pm->cmd.buttons & BUTTON_ALT_ATTACK) )
+		{
+			PM_AddEvent( EV_ALT_FIRE );
+		}
+		else
+		{
+			PM_AddEvent( EV_FIRE_WEAPON );
+		}
+		*/
+		return;
+	}
+
+	if (pm->ps->weapon == WP_DISRUPTOR &&
+		(pm->cmd.buttons & BUTTON_ALT_ATTACK) &&
+		!pm->ps->zoomLocked)
+	{
+		return;
+	}
+
+	if (pm->ps->weapon == WP_DISRUPTOR &&
+		(pm->cmd.buttons & BUTTON_ALT_ATTACK) &&
+		pm->ps->zoomMode == 2)
+	{ //can't use disruptor secondary while zoomed binoculars
+		return;
+	}
+
+	if (pm->ps->weapon == WP_DISRUPTOR && pm->ps->zoomMode == 1)
+	{
+		PM_StartTorsoAnim( BOTH_ATTACK4 );
+	}
+	else if (pm->ps->weapon == WP_MELEE)
+	{ //special anims for standard melee attacks
+		//Alternate between punches and use the anim length as weapon time.
+		if (!pm->ps->m_iVehicleNum)
+		{ //if riding a vehicle don't do this stuff at all
+			if (pm->debugMelee &&
+				(pm->cmd.buttons & BUTTON_ATTACK) &&
+				(pm->cmd.buttons & BUTTON_ALT_ATTACK))
+			{ //ok, grapple time
+#if 0 //eh, I want to try turning the saber off, but can't do that reliably for prediction..
+				qboolean icandoit = qtrue;
+				if (pm->ps->weaponTime > 0)
+				{ //weapon busy
+					icandoit = qfalse;
+				}
+				if (pm->ps->forceHandExtend != HANDEXTEND_NONE)
+				{ //force power or knockdown or something
+					icandoit = qfalse;
+				}
+				if (pm->ps->weapon != WP_SABER && pm->ps->weapon != WP_MELEE)
+				{
+					icandoit = qfalse;
+				}
+
+				if (icandoit)
+				{
+					//G_SetAnim(ent, &ent->client->pers.cmd, SETANIM_BOTH, BOTH_KYLE_GRAB, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD, 0);
+					PM_SetAnim(SETANIM_BOTH, BOTH_KYLE_GRAB, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD, 0);
+					if (pm->ps->torsoAnim == BOTH_KYLE_GRAB)
+					{ //providing the anim set succeeded..
+						pm->ps->torsoTimer += 500; //make the hand stick out a little longer than it normally would
+						if (pm->ps->legsAnim == pm->ps->torsoAnim)
+						{
+							pm->ps->legsTimer = pm->ps->torsoTimer;
+						}
+						pm->ps->weaponTime = pm->ps->torsoTimer;
+						return;
+					}
+				}
+#else
+	#ifdef QAGAME
+				if (pm_entSelf)
+				{
+					if (TryGrapple((gentity_t *)pm_entSelf))
+					{
+						return;
+					}
+				}
+	#else
+				return;
+	#endif
+#endif
+			}
+			else if (pm->debugMelee &&
+				(pm->cmd.buttons & BUTTON_ALT_ATTACK))
+			{ //kicks
+				if (!BG_KickingAnim(pm->ps->torsoAnim) &&
+					!BG_KickingAnim(pm->ps->legsAnim))
+				{
+					int kickMove = PM_KickMoveForConditions();
+					if (kickMove == LS_HILT_BASH)
+					{ //yeah.. no hilt to bash with!
+						kickMove = LS_KICK_F;
+					}
+
+					if (kickMove != -1)
+					{
+						if ( pm->ps->groundEntityNum == ENTITYNUM_NONE )
+						{//if in air, convert kick to an in-air kick
+							float gDist = PM_GroundDistance();
+							//let's only allow air kicks if a certain distance from the ground
+							//it's silly to be able to do them right as you land.
+							//also looks wrong to transition from a non-complete flip anim...
+							if ((!BG_FlippingAnim( pm->ps->legsAnim ) || pm->ps->legsTimer <= 0) &&
+								gDist > 64.0f && //strict minimum
+								gDist > (-pm->ps->velocity[2])-64.0f //make sure we are high to ground relative to downward velocity as well
+								)
+							{
+								switch ( kickMove )
+								{
+								case LS_KICK_F:
+									kickMove = LS_KICK_F_AIR;
+									break;
+								case LS_KICK_B:
+									kickMove = LS_KICK_B_AIR;
+									break;
+								case LS_KICK_R:
+									kickMove = LS_KICK_R_AIR;
+									break;
+								case LS_KICK_L:
+									kickMove = LS_KICK_L_AIR;
+									break;
+								default: //oh well, can't do any other kick move while in-air
+									kickMove = -1;
+									break;
+								}
+							}
+							else
+							{ //off ground, but too close to ground
+								kickMove = -1;
+							}
+						}
+					}
+
+					if (kickMove != -1)
+					{
+						int kickAnim = saberMoveData[kickMove].animToUse;
+
+						if (kickAnim != -1)
+						{
+							PM_SetAnim(SETANIM_BOTH, kickAnim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD, 0);
+							if (pm->ps->legsAnim == kickAnim)
+							{
+								pm->ps->weaponTime = pm->ps->legsTimer;
+								return;
+							}
+						}
+					}
+				}
+
+				//if got here then no move to do so put torso into leg idle or whatever
+				if (pm->ps->torsoAnim != pm->ps->legsAnim)
+				{
+					PM_SetAnim(SETANIM_BOTH, pm->ps->legsAnim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD, 0);
+				}
+				pm->ps->weaponTime = 0;
+				return;
+			}
+			else
+			{ //just punch
+				int desTAnim = BOTH_MELEE1;
+				if (pm->ps->torsoAnim == BOTH_MELEE1)
+				{
+					desTAnim = BOTH_MELEE2;
+				}
+				PM_StartTorsoAnim( desTAnim );
+
+				if (pm->ps->torsoAnim == desTAnim)
+				{
+					pm->ps->weaponTime = pm->ps->torsoTimer;
+				}
+			}
+		}
+	}
+	else
+	{
+		PM_StartTorsoAnim( WeaponAttackAnim[pm->ps->weapon] );
+	}
+
+	if ( pm->cmd.buttons & BUTTON_ALT_ATTACK )
+	{
+		amount = weaponData[pm->ps->weapon].altEnergyPerShot;
+	}
+	else
+	{
+		amount = weaponData[pm->ps->weapon].energyPerShot;
+	}
+
+	pm->ps->weaponstate = WEAPON_FIRING;
+
+	// take an ammo away if not infinite
+	if ( pm->ps->clientNum < MAX_CLIENTS && pm->ps->ammo[ weaponData[pm->ps->weapon].ammoIndex ] != -1 )
+	{
+		// enough energy to fire this weapon?
+		if ((pm->ps->ammo[weaponData[pm->ps->weapon].ammoIndex] - amount) >= 0) 
+		{
+			pm->ps->ammo[weaponData[pm->ps->weapon].ammoIndex] -= amount;
+		}
+		else	// Not enough energy
+		{
+			// Switch weapons
+			if (pm->ps->weapon != WP_DET_PACK || !pm->ps->hasDetPackPlanted)
+			{
+				PM_AddEventWithParm( EV_NOAMMO, WP_NUM_WEAPONS+pm->ps->weapon );
+				if (pm->ps->weaponTime < 500)
+				{
+					pm->ps->weaponTime += 500;
+				}
+			}
+			return;
+		}
+	}
+
+	if ( pm->cmd.buttons & BUTTON_ALT_ATTACK ) 	{
+		//if ( pm->ps->weapon == WP_BRYAR_PISTOL && pm->gametype != GT_SIEGE )
+		if (0)
+		{ //kind of a hack for now
+			PM_AddEvent( EV_FIRE_WEAPON );
+			addTime = weaponData[pm->ps->weapon].fireTime;
+		}
+		else if (pm->ps->weapon == WP_DISRUPTOR && pm->ps->zoomMode != 1)
+		{
+			PM_AddEvent( EV_FIRE_WEAPON );
+			addTime = weaponData[pm->ps->weapon].fireTime;
+		}
+		else
+		{
+			if (pm->ps->weapon != WP_MELEE ||
+				!pm->ps->m_iVehicleNum)
+			{ //do not fire melee events at all when on vehicle
+				PM_AddEvent( EV_ALT_FIRE );
+			}
+			addTime = weaponData[pm->ps->weapon].altFireTime;
+		}
+	}
+	else {
+		if (pm->ps->weapon != WP_MELEE ||
+			!pm->ps->m_iVehicleNum)
+		{ //do not fire melee events at all when on vehicle
+			PM_AddEvent( EV_FIRE_WEAPON );
+		}
+		addTime = weaponData[pm->ps->weapon].fireTime;
+		if ( pm->gametype == GT_SIEGE && pm->ps->weapon == WP_DET_PACK )
+		{	// were far too spammy before?  So says Rick.
+			addTime *= 2;
+		}
+	}
+
+	/*
+	if ( pm->ps->powerups[PW_HASTE] ) {
+		addTime /= 1.3;
+	}
+	*/
+
+	if (pm->ps->fd.forcePowersActive & (1 << FP_RAGE))
+	{
+		addTime *= 0.75;
+	}
+	else if (pm->ps->fd.forceRageRecoveryTime > pm->cmd.serverTime)
+	{
+		addTime *= 1.5;
+	}
+
+	pm->ps->weaponTime += addTime;
+}
+
+/*
+================
+PM_Animate
+================
+*/
+
+static void PM_Animate( void ) {
+	if ( pm->cmd.buttons & BUTTON_GESTURE ) {
+		if (pm->ps->m_iVehicleNum)
+		{ //eh, fine, clear it
+			if (pm->ps->forceHandExtendTime < pm->cmd.serverTime)
+			{
+				pm->ps->forceHandExtend = HANDEXTEND_NONE;
+			}
+		}
+
+		if ( pm->ps->torsoTimer < 1 && pm->ps->forceHandExtend == HANDEXTEND_NONE &&
+			pm->ps->legsTimer < 1 && pm->ps->weaponTime < 1 && pm->ps->saberLockTime < pm->cmd.serverTime) {
+
+			pm->ps->forceHandExtend = HANDEXTEND_TAUNT;
+
+			//FIXME: random taunt anims?
+			pm->ps->forceDodgeAnim = BOTH_ENGAGETAUNT;
+
+			pm->ps->forceHandExtendTime = pm->cmd.serverTime + 1000;
+			
+			//pm->ps->weaponTime = 100;
+
+			PM_AddEvent( EV_TAUNT );
+		}
+#if 0
+// Here's an interesting bit.  The bots in TA used buttons to do additional gestures.
+// I ripped them out because I didn't want too many buttons given the fact that I was already adding some for JK2.
+// We can always add some back in if we want though.
+	} else if ( pm->cmd.buttons & BUTTON_GETFLAG ) {
+		if ( pm->ps->torsoTimer == 0 ) {
+			PM_StartTorsoAnim( TORSO_GETFLAG );
+			pm->ps->torsoTimer = 600;	//TIMER_GESTURE;
+		}
+	} else if ( pm->cmd.buttons & BUTTON_GUARDBASE ) {
+		if ( pm->ps->torsoTimer == 0 ) {
+			PM_StartTorsoAnim( TORSO_GUARDBASE );
+			pm->ps->torsoTimer = 600;	//TIMER_GESTURE;
+		}
+	} else if ( pm->cmd.buttons & BUTTON_PATROL ) {
+		if ( pm->ps->torsoTimer == 0 ) {
+			PM_StartTorsoAnim( TORSO_PATROL );
+			pm->ps->torsoTimer = 600;	//TIMER_GESTURE;
+		}
+	} else if ( pm->cmd.buttons & BUTTON_FOLLOWME ) {
+		if ( pm->ps->torsoTimer == 0 ) {
+			PM_StartTorsoAnim( TORSO_FOLLOWME );
+			pm->ps->torsoTimer = 600;	//TIMER_GESTURE;
+		}
+	} else if ( pm->cmd.buttons & BUTTON_AFFIRMATIVE ) {
+		if ( pm->ps->torsoTimer == 0 ) {
+			PM_StartTorsoAnim( TORSO_AFFIRMATIVE);
+			pm->ps->torsoTimer = 600;	//TIMER_GESTURE;
+		}
+	} else if ( pm->cmd.buttons & BUTTON_NEGATIVE ) {
+		if ( pm->ps->torsoTimer == 0 ) {
+			PM_StartTorsoAnim( TORSO_NEGATIVE );
+			pm->ps->torsoTimer = 600;	//TIMER_GESTURE;
+		}
+#endif //
+	}
+}
+
+
+/*
+================
+PM_DropTimers
+================
+*/
+static void PM_DropTimers( void ) {
+	// drop misc timing counter
+	if ( pm->ps->pm_time ) {
+		if ( pml.msec >= pm->ps->pm_time ) {
+			pm->ps->pm_flags &= ~PMF_ALL_TIMES;
+			pm->ps->pm_time = 0;
+		} else {
+			pm->ps->pm_time -= pml.msec;
+		}
+	}
+
+	// drop animation counter
+	if ( pm->ps->legsTimer > 0 ) {
+		pm->ps->legsTimer -= pml.msec;
+		if ( pm->ps->legsTimer < 0 ) {
+			pm->ps->legsTimer = 0;
+		}
+	}
+
+	if ( pm->ps->torsoTimer > 0 ) {
+		pm->ps->torsoTimer -= pml.msec;
+		if ( pm->ps->torsoTimer < 0 ) {
+			pm->ps->torsoTimer = 0;
+		}
+	}
+}
+
+// Following function is stateless (at the moment). And hoisting it out
+// of the namespace here is easier than fixing all the places it's used,
+// which includes files that are also compiled in SP. We do need to make
+// sure we only get one copy in the linker, though.
+
+#include "../namespace_end.h"
+
+#if !defined(_XBOX) || defined(QAGAME)
+extern	vmCvar_t	bg_fighterAltControl;
+qboolean BG_UnrestrainedPitchRoll( playerState_t *ps, Vehicle_t *pVeh )
+{
+	if ( bg_fighterAltControl.integer
+		&& ps->clientNum < MAX_CLIENTS //real client
+		&& ps->m_iVehicleNum//in a vehicle
+		&& pVeh //valid vehicle data pointer
+		&& pVeh->m_pVehicleInfo//valid vehicle info
+		&& pVeh->m_pVehicleInfo->type == VH_FIGHTER )//fighter
+		//FIXME: specify per vehicle instead of assuming true for all fighters
+		//FIXME: map/server setting?
+	{//can roll and pitch without limitation!
+		return qtrue;
+	}
+	return qfalse;
+}
+#else
+extern qboolean BG_UnrestrainedPitchRoll( playerState_t *ps, Vehicle_t *pVeh );
+#endif
+
+#include "../namespace_begin.h"
+
+/*
+================
+PM_UpdateViewAngles
+
+This can be used as another entry point when only the viewangles
+are being updated isntead of a full move
+================
+*/
+void PM_UpdateViewAngles( playerState_t *ps, const usercmd_t *cmd ) {
+	short		temp;
+	int		i;
+
+	if ( ps->pm_type == PM_INTERMISSION || ps->pm_type == PM_SPINTERMISSION) {
+		return;		// no view changes at all
+	}
+
+	if ( ps->pm_type != PM_SPECTATOR && ps->stats[STAT_HEALTH] <= 0 ) {
+		return;		// no view changes at all
+	}
+
+	// circularly clamp the angles with deltas
+	for (i=0 ; i<3 ; i++) {
+		temp = cmd->angles[i] + ps->delta_angles[i];
+		if ( pm_entVeh 
+			&& pm_entVeh->m_pVehicle
+			&& pm_entVeh->m_pVehicle->m_pVehicleInfo
+			&& pm_entVeh->m_pVehicle->m_pVehicleInfo->type == VH_FIGHTER
+			&& (cmd->serverTime-pm_entVeh->playerState->hyperSpaceTime) >= HYPERSPACE_TIME )
+		{//in a vehicle and not hyperspacing
+			if ( i == PITCH ) 
+			{
+				int pitchClamp = ANGLE2SHORT(AngleNormalize180(pm_entVeh->m_pVehicle->m_vPrevRiderViewAngles[PITCH]+10.0f));
+				// don't let the player look up or down more than 22.5 degrees
+				if ( temp > pitchClamp ) 
+				{
+					ps->delta_angles[i] = pitchClamp - cmd->angles[i];
+					temp = pitchClamp;
+				} 
+				else if ( temp < -pitchClamp ) 
+				{
+					ps->delta_angles[i] = -pitchClamp - cmd->angles[i];
+					temp = -pitchClamp;
+				}
+			}
+			if ( i == YAW ) 
+			{
+				int yawClamp = ANGLE2SHORT(AngleNormalize180(pm_entVeh->m_pVehicle->m_vPrevRiderViewAngles[YAW]+10.0f));
+				// don't let the player look left or right more than 22.5 degrees
+				if ( temp > yawClamp ) 
+				{
+					ps->delta_angles[i] = yawClamp - cmd->angles[i];
+					temp = yawClamp;
+				}
+				else if ( temp < -yawClamp ) 
+				{
+					ps->delta_angles[i] = -yawClamp - cmd->angles[i];
+					temp = -yawClamp;
+				}
+			}
+		}
+		else
+		{
+			if ( i == PITCH ) {
+				// don't let the player look up or down more than 90 degrees
+				if ( temp > 16000 ) {
+					ps->delta_angles[i] = 16000 - cmd->angles[i];
+					temp = 16000;
+				} else if ( temp < -16000 ) {
+					ps->delta_angles[i] = -16000 - cmd->angles[i];
+					temp = -16000;
+				}
+			}
+		}
+		ps->viewangles[i] = SHORT2ANGLE(temp);
+	}
+}
+
+/*
+void PM_UpdateViewAngles( playerState_t *ps, const usercmd_t *cmd ) {
+	short		temp;
+	int		i;
+	float	rootPitch = 0, pitchMin=-90, pitchMax=90, yawMin=0, yawMax=0, lockedYawValue = 0;	//just to shut up warnings
+	qboolean	lockedYaw = qfalse, clamped = qfalse;
+	bgEntity_t *vehEnt = NULL;
+
+	if ( ps->pm_type == PM_INTERMISSION || ps->pm_type == PM_SPINTERMISSION) {
+		return;		// no view changes at all
+	}
+
+	if ( ps->pm_type != PM_SPECTATOR && ps->stats[STAT_HEALTH] <= 0 ) {
+		return;		// no view changes at all
+	}
+
+	// If we're a vehicle, or we're riding a vehicle...?
+	if ( ps->m_iVehicleNum )
+	{
+		if ( ps->clientNum < MAX_CLIENTS )
+		{ //player riding vehicle
+			vehEnt = PM_BGEntForNum(ps->m_iVehicleNum);
+		}
+		else
+		{ //vehicle with player pilot
+			vehEnt = PM_BGEntForNum(ps->clientNum);
+		}
+		if ( vehEnt )
+		{//there is a vehicle
+			Vehicle_t *pVeh = vehEnt->m_pVehicle;
+			if ( pVeh && pVeh->m_pVehicleInfo )
+			{
+				// There is a vehicle...
+				if ( pVeh->m_pVehicleInfo->type != VH_ANIMAL )
+				{//animals just turn normally, no clamping
+					if ( pVeh->m_pVehicleInfo->type == VH_FIGHTER )
+					{
+						rootPitch = pVeh->m_vOrientation[PITCH];//gent->owner->client->ps.vehicleAngles[PITCH];//???  what if goes over 90 when add the min/max?
+						if ( pVeh->m_pVehicleInfo->pitchLimit == -1 )
+						{
+							pitchMax = 180;
+						}
+						else
+						{
+							pitchMax = pVeh->m_pVehicleInfo->pitchLimit;
+						}
+						pitchMin = -pitchMax;
+					}
+					else
+					{
+						lockedYawValue = 0;//gent->owner->client->ps.vehicleAngles[YAW];
+						lockedYaw = qtrue;
+						yawMax = pVeh->m_pVehicleInfo->lookYaw;
+						yawMin = -yawMax;
+						rootPitch = 0;//gent->owner->client->ps.vehicleAngles[PITCH];//???  what if goes over 90 when add the min/max?
+						pitchMax = pVeh->m_pVehicleInfo->lookPitch;
+						pitchMin = -pitchMax;
+					}
+				}
+			}
+		}
+	}
+	if ( 1 )
+	{
+		const short pitchClampMin = ANGLE2SHORT(rootPitch+pitchMin);
+		const short pitchClampMax = ANGLE2SHORT(rootPitch+pitchMax);
+		const short yawClampMin = ANGLE2SHORT(lockedYawValue+yawMin);
+		const short yawClampMax = ANGLE2SHORT(lockedYawValue+yawMax);
+		for (i=0 ; i<3 ; i++) 
+		{
+			temp = cmd->angles[i] + ps->delta_angles[i];
+			if ( i == PITCH ) 
+			{
+				//FIXME get this limit from the NPCs stats?
+				// don't let the player look up or down more than 90 degrees
+				if ( temp > pitchClampMax ) 
+				{
+					ps->delta_angles[i] = (pitchClampMax - cmd->angles[i]) & 0xffff;	//& clamp to short
+					temp = pitchClampMax;
+					clamped = qtrue;
+				} 
+				else if ( temp < pitchClampMin ) 
+				{
+					ps->delta_angles[i] = (pitchClampMin - cmd->angles[i]) & 0xffff;	//& clamp to short
+					temp = pitchClampMin;
+					clamped = qtrue;
+				}
+			}
+			if ( i == YAW && lockedYaw ) 
+			{
+				//FIXME get this limit from the NPCs stats?
+				// don't let the player look up or down more than 90 degrees
+				if ( temp > yawClampMax ) 
+				{
+					ps->delta_angles[i] = (yawClampMax - cmd->angles[i]) & 0xffff;	//& clamp to short
+					temp = yawClampMax;
+					clamped = qtrue;
+				} 
+				else if ( temp < yawClampMin ) 
+				{
+					ps->delta_angles[i] = (yawClampMin - cmd->angles[i]) & 0xffff;	//& clamp to short
+					temp = yawClampMin;
+					clamped = qtrue;
+				}
+				ps->viewangles[i] = SHORT2ANGLE(temp);
+			}
+			else
+			{
+				ps->viewangles[i] = SHORT2ANGLE(temp);
+			}
+		}
+	}
+	else
+	{
+		// circularly clamp the angles with deltas
+		for (i=0 ; i<3 ; i++) {
+			temp = cmd->angles[i] + ps->delta_angles[i];
+			if ( i == PITCH ) {
+				// don't let the player look up or down more than 90 degrees
+				if ( temp > 16000 ) {
+					ps->delta_angles[i] = 16000 - cmd->angles[i];
+					temp = 16000;
+				} else if ( temp < -16000 ) {
+					ps->delta_angles[i] = -16000 - cmd->angles[i];
+					temp = -16000;
+				}
+			}
+			ps->viewangles[i] = SHORT2ANGLE(temp);
+		}
+	}
+
+}
+*/
+
+//-------------------------------------------
+void PM_AdjustAttackStates( pmove_t *pm )
+//-------------------------------------------
+{
+	int amount;
+
+	if (pm_entSelf->s.NPC_class!=CLASS_VEHICLE
+		&&pm->ps->m_iVehicleNum)
+	{ //riding a vehicle
+		bgEntity_t *veh = pm_entVeh;
+		if ( veh &&
+			(veh->m_pVehicle && (veh->m_pVehicle->m_pVehicleInfo->type == VH_WALKER || veh->m_pVehicle && veh->m_pVehicle->m_pVehicleInfo->type == VH_FIGHTER)) )
+		{//riding a walker/fighter
+			//not firing, ever
+			pm->ps->eFlags &= ~(EF_FIRING|EF_ALT_FIRING);
+			return;
+		}
+	}
+	// get ammo usage
+	if ( pm->cmd.buttons & BUTTON_ALT_ATTACK )
+	{
+		amount = pm->ps->ammo[weaponData[ pm->ps->weapon ].ammoIndex] - weaponData[pm->ps->weapon].altEnergyPerShot;
+	}
+	else
+	{
+		amount = pm->ps->ammo[weaponData[ pm->ps->weapon ].ammoIndex] - weaponData[pm->ps->weapon].energyPerShot;
+	}
+
+	// disruptor alt-fire should toggle the zoom mode, but only bother doing this for the player?
+	if ( pm->ps->weapon == WP_DISRUPTOR && pm->ps->weaponstate == WEAPON_READY )
+	{
+		if ( !(pm->ps->eFlags & EF_ALT_FIRING) && (pm->cmd.buttons & BUTTON_ALT_ATTACK) /*&&
+			pm->cmd.upmove <= 0 && !pm->cmd.forwardmove && !pm->cmd.rightmove*/)
+		{
+			// We just pressed the alt-fire key
+			if ( !pm->ps->zoomMode && pm->ps->pm_type != PM_DEAD )
+			{
+				// not already zooming, so do it now
+				pm->ps->zoomMode = 1;
+				pm->ps->zoomLocked = qfalse;
+				pm->ps->zoomFov = 80.0f;//cg_fov.value;
+				pm->ps->zoomLockTime = pm->cmd.serverTime + 50;
+				PM_AddEvent(EV_DISRUPTOR_ZOOMSOUND);
+			}
+			else if (pm->ps->zoomMode == 1 && pm->ps->zoomLockTime < pm->cmd.serverTime)
+			{ //check for == 1 so we can't turn binoculars off with disruptor alt fire
+				// already zooming, so must be wanting to turn it off
+				pm->ps->zoomMode = 0;
+				pm->ps->zoomTime = pm->ps->commandTime;
+				pm->ps->zoomLocked = qfalse;
+				PM_AddEvent(EV_DISRUPTOR_ZOOMSOUND);
+				pm->ps->weaponTime = 1000;
+			}
+		}
+		else if ( !(pm->cmd.buttons & BUTTON_ALT_ATTACK ) && pm->ps->zoomLockTime < pm->cmd.serverTime)
+		{
+			// Not pressing zoom any more
+			if ( pm->ps->zoomMode )
+			{
+				if (pm->ps->zoomMode == 1 && !pm->ps->zoomLocked)
+				{ //approximate what level the client should be zoomed at based on how long zoom was held
+					pm->ps->zoomFov = ((pm->cmd.serverTime+50) - pm->ps->zoomLockTime) * 0.035f;
+					if (pm->ps->zoomFov > 50)
+					{
+						pm->ps->zoomFov = 50;
+					}
+					if (pm->ps->zoomFov < 1)
+					{
+						pm->ps->zoomFov = 1;
+					}
+				}
+				// were zooming in, so now lock the zoom
+				pm->ps->zoomLocked = qtrue;
+			}
+		}
+		//This seemed like a good idea, but apparently it confuses people. So disabled for now.
+		/*
+		else if (!(pm->ps->eFlags & EF_ALT_FIRING) && (pm->cmd.buttons & BUTTON_ALT_ATTACK) &&
+			(pm->cmd.upmove > 0 || pm->cmd.forwardmove || pm->cmd.rightmove))
+		{ //if you try to zoom while moving, just convert it into a primary attack
+			pm->cmd.buttons &= ~BUTTON_ALT_ATTACK;
+			pm->cmd.buttons |= BUTTON_ATTACK;
+		}
+		*/
+
+		/*
+		if (pm->cmd.upmove > 0 || pm->cmd.forwardmove || pm->cmd.rightmove)
+		{
+			if (pm->ps->zoomMode == 1 && pm->ps->zoomLockTime < pm->cmd.serverTime)
+			{ //check for == 1 so we can't turn binoculars off with disruptor alt fire
+				pm->ps->zoomMode = 0;
+				pm->ps->zoomTime = pm->ps->commandTime;
+				pm->ps->zoomLocked = qfalse;
+				PM_AddEvent(EV_DISRUPTOR_ZOOMSOUND);
+			}
+		}
+		*/
+
+		if ( pm->cmd.buttons & BUTTON_ATTACK )
+		{
+			// If we are zoomed, we should switch the ammo usage to the alt-fire, otherwise, we'll
+			//	just use whatever ammo was selected from above
+			if ( pm->ps->zoomMode )
+			{
+				amount = pm->ps->ammo[weaponData[ pm->ps->weapon ].ammoIndex] - 
+							weaponData[pm->ps->weapon].altEnergyPerShot;
+			}
+		}
+		else
+		{
+			// alt-fire button pressing doesn't use any ammo
+			amount = 0;
+		}
+	}
+	/*
+	else if (pm->ps->weapon == WP_DISRUPTOR) //still perform certain checks, even if the weapon is not ready
+	{
+		if (pm->cmd.upmove > 0 || pm->cmd.forwardmove || pm->cmd.rightmove)
+		{
+			if (pm->ps->zoomMode == 1 && pm->ps->zoomLockTime < pm->cmd.serverTime)
+			{ //check for == 1 so we can't turn binoculars off with disruptor alt fire
+				pm->ps->zoomMode = 0;
+				pm->ps->zoomTime = pm->ps->commandTime;
+				pm->ps->zoomLocked = qfalse;
+				PM_AddEvent(EV_DISRUPTOR_ZOOMSOUND);
+			}
+		}
+	}
+	*/
+
+	// set the firing flag for continuous beam weapons, saber will fire even if out of ammo
+	if ( !(pm->ps->pm_flags & PMF_RESPAWNED) && 
+			pm->ps->pm_type != PM_INTERMISSION && 
+			( pm->cmd.buttons & (BUTTON_ATTACK|BUTTON_ALT_ATTACK)) && 
+			( amount >= 0 || pm->ps->weapon == WP_SABER ))
+	{
+		if ( pm->cmd.buttons & BUTTON_ALT_ATTACK )
+		{
+			pm->ps->eFlags |= EF_ALT_FIRING;
+		}
+		else
+		{
+			pm->ps->eFlags &= ~EF_ALT_FIRING;
+		}
+
+		// This flag should always get set, even when alt-firing
+		pm->ps->eFlags |= EF_FIRING;
+	} 
+	else 
+	{
+		// Clear 'em out
+		pm->ps->eFlags &= ~(EF_FIRING|EF_ALT_FIRING);
+	}
+
+	// disruptor should convert a main fire to an alt-fire if the gun is currently zoomed
+	if ( pm->ps->weapon == WP_DISRUPTOR)
+	{
+		if ( pm->cmd.buttons & BUTTON_ATTACK && pm->ps->zoomMode == 1 && pm->ps->zoomLocked)
+		{
+			// converting the main fire to an alt-fire
+			pm->cmd.buttons |= BUTTON_ALT_ATTACK;
+			pm->ps->eFlags |= EF_ALT_FIRING;
+		}
+		else if ( pm->cmd.buttons & BUTTON_ALT_ATTACK && pm->ps->zoomMode == 1 && pm->ps->zoomLocked)
+		{
+			pm->cmd.buttons &= ~BUTTON_ALT_ATTACK;
+			pm->ps->eFlags &= ~EF_ALT_FIRING;
+		}
+	}
+}
+
+void BG_CmdForRoll( playerState_t *ps, int anim, usercmd_t *pCmd )
+{
+	switch ( (anim) )
+	{
+	case BOTH_ROLL_F:
+		pCmd->forwardmove = 127;
+		pCmd->rightmove = 0;
+		break;
+	case BOTH_ROLL_B:
+		pCmd->forwardmove = -127;
+		pCmd->rightmove = 0;
+		break;
+	case BOTH_ROLL_R:
+		pCmd->forwardmove = 0;
+		pCmd->rightmove = 127;
+		break;
+	case BOTH_ROLL_L:
+		pCmd->forwardmove = 0;
+		pCmd->rightmove = -127;
+		break;
+	case BOTH_GETUP_BROLL_R:
+		pCmd->forwardmove = 0;
+		pCmd->rightmove = 48;
+		//NOTE: speed is 400
+		break;
+
+	case BOTH_GETUP_FROLL_R:
+		if ( ps->legsTimer <= 250 )
+		{//end of anim
+			pCmd->forwardmove = pCmd->rightmove = 0;
+		}
+		else
+		{
+			pCmd->forwardmove = 0;
+			pCmd->rightmove = 48;
+			//NOTE: speed is 400
+		}
+		break;
+
+	case BOTH_GETUP_BROLL_L:
+		pCmd->forwardmove = 0;
+		pCmd->rightmove = -48;
+		//NOTE: speed is 400
+		break;
+
+	case BOTH_GETUP_FROLL_L:
+		if ( ps->legsTimer <= 250 )
+		{//end of anim
+			pCmd->forwardmove = pCmd->rightmove = 0;
+		}
+		else
+		{
+			pCmd->forwardmove = 0;
+			pCmd->rightmove = -48;
+			//NOTE: speed is 400
+		}
+		break;
+
+	case BOTH_GETUP_BROLL_B:
+		if ( ps->torsoTimer <= 250 )
+		{//end of anim
+			pCmd->forwardmove = pCmd->rightmove = 0;
+		}
+		else if ( PM_AnimLength( 0, (animNumber_t)ps->legsAnim ) - ps->torsoTimer < 350 )
+		{//beginning of anim
+			pCmd->forwardmove = pCmd->rightmove = 0;
+		}
+		else
+		{
+			//FIXME: ramp down over length of anim
+			pCmd->forwardmove = -64;
+			pCmd->rightmove = 0;
+			//NOTE: speed is 400
+		}
+		break;
+
+	case BOTH_GETUP_FROLL_B:
+		if ( ps->torsoTimer <= 100 )
+		{//end of anim
+			pCmd->forwardmove = pCmd->rightmove = 0;
+		}
+		else if ( PM_AnimLength( 0, (animNumber_t)ps->legsAnim ) - ps->torsoTimer < 200 )
+		{//beginning of anim
+			pCmd->forwardmove = pCmd->rightmove = 0;
+		}
+		else
+		{
+			//FIXME: ramp down over length of anim
+			pCmd->forwardmove = -64;
+			pCmd->rightmove = 0;
+			//NOTE: speed is 400
+		}
+		break;
+
+	case BOTH_GETUP_BROLL_F:
+		if ( ps->torsoTimer <= 550 )
+		{//end of anim
+			pCmd->forwardmove = pCmd->rightmove = 0;
+		}
+		else if ( PM_AnimLength( 0, (animNumber_t)ps->legsAnim ) - ps->torsoTimer < 150 )
+		{//beginning of anim
+			pCmd->forwardmove = pCmd->rightmove = 0;
+		}
+		else
+		{
+			pCmd->forwardmove = 64;
+			pCmd->rightmove = 0;
+			//NOTE: speed is 400
+		}
+		break;
+
+	case BOTH_GETUP_FROLL_F:
+		if ( ps->torsoTimer <= 100 )
+		{//end of anim
+			pCmd->forwardmove = pCmd->rightmove = 0;
+		}
+		else
+		{
+			//FIXME: ramp down over length of anim
+			pCmd->forwardmove = 64;
+			pCmd->rightmove = 0;
+			//NOTE: speed is 400
+		}
+		break;
+	}
+	pCmd->upmove = 0;
+}
+
+qboolean PM_SaberInTransition( int move );
+
+void BG_AdjustClientSpeed(playerState_t *ps, usercmd_t *cmd, int svTime)
+{
+	if (ps->clientNum >= MAX_CLIENTS)
+	{
+		bgEntity_t *bgEnt = pm_entSelf;
+
+		if (bgEnt && bgEnt->s.NPC_class == CLASS_VEHICLE)
+		{ //vehicles manage their own speed
+			return;
+		}
+	}
+
+	//For prediction, always reset speed back to the last known server base speed
+	//If we didn't do this, under lag we'd eventually dwindle speed down to 0 even though
+	//that would not be the correct predicted value.
+	ps->speed = ps->basespeed;
+
+	if (ps->forceHandExtend == HANDEXTEND_DODGE)
+	{
+		ps->speed = 0;
+	}
+
+	if (ps->forceHandExtend == HANDEXTEND_KNOCKDOWN ||
+		ps->forceHandExtend == HANDEXTEND_PRETHROWN ||
+		ps->forceHandExtend == HANDEXTEND_POSTTHROWN)
+	{
+		ps->speed = 0;
+	}
+
+
+	if ( cmd->forwardmove < 0 && !(cmd->buttons&BUTTON_WALKING) && pm->ps->groundEntityNum != ENTITYNUM_NONE )
+	{//running backwards is slower than running forwards (like SP)
+		ps->speed *= 0.75;
+	}
+
+	if (ps->fd.forcePowersActive & (1 << FP_GRIP))
+	{
+		ps->speed *= 0.4;
+	}
+
+	if (ps->fd.forcePowersActive & (1 << FP_SPEED))
+	{
+		ps->speed *= 1.7;
+	}
+	else if (ps->fd.forcePowersActive & (1 << FP_RAGE))
+	{
+		ps->speed *= 1.3;
+	}
+	else if (ps->fd.forceRageRecoveryTime > svTime)
+	{
+		ps->speed *= 0.75;
+	}
+
+	if (pm->ps->weapon == WP_DISRUPTOR &&
+		pm->ps->zoomMode == 1 && pm->ps->zoomLockTime < pm->cmd.serverTime)
+	{
+		ps->speed *= 0.5f;
+	}
+
+
+	if (ps->fd.forceGripCripple)
+	{
+		if (ps->fd.forcePowersActive & (1 << FP_RAGE))
+		{
+			ps->speed *= 0.9;
+		}
+		else if (ps->fd.forcePowersActive & (1 << FP_SPEED))
+		{ //force speed will help us escape
+			ps->speed *= 0.8;
+		}
+		else
+		{
+			ps->speed *= 0.2;
+		}
+	}
+
+	if ( BG_SaberInAttack( ps->saberMove ) && cmd->forwardmove < 0 )
+	{//if running backwards while attacking, don't run as fast.
+		switch( ps->fd.saberAnimLevel )
+		{
+		case FORCE_LEVEL_1:
+			ps->speed *= 0.75f;
+			break;
+		case FORCE_LEVEL_2:
+		case SS_DUAL:
+		case SS_STAFF:
+			ps->speed *= 0.60f;
+			break;
+		case FORCE_LEVEL_3:
+			ps->speed *= 0.45f;
+			break;
+		default:
+			break;
+		}
+	}
+	else if ( BG_SpinningSaberAnim( ps->legsAnim ) )
+	{
+		if (ps->fd.saberAnimLevel == FORCE_LEVEL_3)
+		{
+			ps->speed *= 0.3f;
+		}
+		else
+		{
+			ps->speed *= 0.5f;
+		}
+	}
+	else if ( ps->weapon == WP_SABER && BG_SaberInAttack( ps->saberMove ) )
+	{//if attacking with saber while running, drop your speed
+		switch( ps->fd.saberAnimLevel )
+		{
+		case FORCE_LEVEL_2:
+		case SS_DUAL:
+		case SS_STAFF:
+			ps->speed *= 0.85f;
+			break;
+		case FORCE_LEVEL_3:
+			ps->speed *= 0.55f;
+			break;
+		default:
+			break;
+		}
+	}
+	else if (ps->weapon == WP_SABER && ps->fd.saberAnimLevel == FORCE_LEVEL_3 &&
+		PM_SaberInTransition(ps->saberMove))
+	{ //Now, we want to even slow down in transitions for level 3 (since it has chains and stuff now)
+		if (cmd->forwardmove < 0)
+		{
+			ps->speed *= 0.4f;
+		}
+		else
+		{
+			ps->speed *= 0.6f;
+		}
+	}
+
+	if ( BG_InRoll( ps, ps->legsAnim ) && ps->speed > 50 )
+	{ //can't roll unless you're able to move normally
+		if ((ps->legsAnim) == BOTH_ROLL_B)
+		{ //backwards roll is pretty fast, should also be slower
+			if (ps->legsTimer > 800)
+			{
+				ps->speed = ps->legsTimer/2.5;
+			}
+			else
+			{
+				ps->speed = ps->legsTimer/6.0;//450;
+			}
+		}
+		else
+		{
+			if (ps->legsTimer > 800)
+			{
+				ps->speed = ps->legsTimer/1.5;//450;
+			}
+			else
+			{
+				ps->speed = ps->legsTimer/5.0;//450;
+			}
+		}
+		if (ps->speed > 600)
+		{
+			ps->speed = 600;
+		}
+		//Automatically slow down as the roll ends.
+	}
+}
+
+qboolean BG_InRollAnim( entityState_t *cent )
+{
+	switch ( (cent->legsAnim) )
+	{
+	case BOTH_ROLL_F:
+	case BOTH_ROLL_B:
+	case BOTH_ROLL_R:
+	case BOTH_ROLL_L:
+		return qtrue;
+	}
+	return qfalse;
+}
+
+qboolean BG_InKnockDown( int anim )
+{
+	switch ( (anim) )
+	{
+	case BOTH_KNOCKDOWN1:
+	case BOTH_KNOCKDOWN2:
+	case BOTH_KNOCKDOWN3:
+	case BOTH_KNOCKDOWN4:
+	case BOTH_KNOCKDOWN5:
+		return qtrue;
+		break;
+	case BOTH_GETUP1:
+	case BOTH_GETUP2:
+	case BOTH_GETUP3:
+	case BOTH_GETUP4:
+	case BOTH_GETUP5:
+	case BOTH_FORCE_GETUP_F1:
+	case BOTH_FORCE_GETUP_F2:
+	case BOTH_FORCE_GETUP_B1:
+	case BOTH_FORCE_GETUP_B2:
+	case BOTH_FORCE_GETUP_B3:
+	case BOTH_FORCE_GETUP_B4:
+	case BOTH_FORCE_GETUP_B5:
+	case BOTH_GETUP_BROLL_B:
+	case BOTH_GETUP_BROLL_F:
+	case BOTH_GETUP_BROLL_L:
+	case BOTH_GETUP_BROLL_R:
+	case BOTH_GETUP_FROLL_B:
+	case BOTH_GETUP_FROLL_F:
+	case BOTH_GETUP_FROLL_L:
+	case BOTH_GETUP_FROLL_R:
+		return qtrue;
+		break;
+	}
+	return qfalse;
+}
+
+qboolean BG_InRollES( entityState_t *ps, int anim )
+{
+	switch ( (anim) )
+	{
+	case BOTH_ROLL_F:
+	case BOTH_ROLL_B:
+	case BOTH_ROLL_R:
+	case BOTH_ROLL_L:
+		return qtrue;
+		break;
+	}
+	return qfalse;
+}
+
+void BG_IK_MoveArm(void *ghoul2, int lHandBolt, int time, entityState_t *ent, int basePose, vec3_t desiredPos, qboolean *ikInProgress,
+					 vec3_t origin, vec3_t angles, vec3_t scale, int blendTime, qboolean forceHalt)
+{
+	mdxaBone_t lHandMatrix;
+	vec3_t lHand;
+	vec3_t torg;
+	float distToDest;
+
+	if (!ghoul2)
+	{
+		return;
+	}
+
+	assert(bgHumanoidAnimations[basePose].firstFrame > 0);
+
+	if (!*ikInProgress && !forceHalt)
+	{
+		int baseposeAnim = basePose;
+		sharedSetBoneIKStateParams_t ikP;
+
+		//restrict the shoulder joint
+		//VectorSet(ikP.pcjMins,-50.0f,-80.0f,-15.0f);
+		//VectorSet(ikP.pcjMaxs,15.0f,40.0f,15.0f);
+
+		//for now, leaving it unrestricted, but restricting elbow joint.
+		//This lets us break the arm however we want in order to fling people
+		//in throws, and doesn't look bad.
+		VectorSet(ikP.pcjMins,0,0,0);
+		VectorSet(ikP.pcjMaxs,0,0,0);
+
+		//give the info on our entity.
+		ikP.blendTime = blendTime;
+		VectorCopy(origin, ikP.origin);
+		VectorCopy(angles, ikP.angles);
+		ikP.angles[PITCH] = 0;
+		ikP.pcjOverrides = 0;
+		ikP.radius = 10.0f;
+		VectorCopy(scale, ikP.scale);
+		
+		//base pose frames for the limb
+		ikP.startFrame = bgHumanoidAnimations[baseposeAnim].firstFrame + bgHumanoidAnimations[baseposeAnim].numFrames;
+		ikP.endFrame = bgHumanoidAnimations[baseposeAnim].firstFrame + bgHumanoidAnimations[baseposeAnim].numFrames;
+
+		ikP.forceAnimOnBone = qfalse; //let it use existing anim if it's the same as this one.
+
+		//we want to call with a null bone name first. This will init all of the
+		//ik system stuff on the g2 instance, because we need ragdoll effectors
+		//in order for our pcj's to know how to angle properly.
+		if (!strap_G2API_SetBoneIKState(ghoul2, time, NULL, IKS_DYNAMIC, &ikP))
+		{
+			assert(!"Failed to init IK system for g2 instance!");
+		}
+
+		//Now, create our IK bone state.
+		if (strap_G2API_SetBoneIKState(ghoul2, time, "lhumerus", IKS_DYNAMIC, &ikP))
+		{
+			//restrict the elbow joint
+			VectorSet(ikP.pcjMins,-90.0f,-20.0f,-20.0f);
+			VectorSet(ikP.pcjMaxs,30.0f,20.0f,-20.0f);
+
+			if (strap_G2API_SetBoneIKState(ghoul2, time, "lradius", IKS_DYNAMIC, &ikP))
+			{ //everything went alright.
+				*ikInProgress = qtrue;
+			}
+		}
+	}
+
+	if (*ikInProgress && !forceHalt)
+	{ //actively update our ik state.
+		sharedIKMoveParams_t ikM;
+		sharedRagDollUpdateParams_t tuParms;
+		vec3_t tAngles;
+
+		//set the argument struct up
+		VectorCopy(desiredPos, ikM.desiredOrigin); //we want the bone to move here.. if possible
+
+		VectorCopy(angles, tAngles);
+		tAngles[PITCH] = tAngles[ROLL] = 0;
+
+		strap_G2API_GetBoltMatrix(ghoul2, 0, lHandBolt, &lHandMatrix, tAngles, origin, time, 0, scale);
+		//Get the point position from the matrix.
+		lHand[0] = lHandMatrix.matrix[0][3];
+		lHand[1] = lHandMatrix.matrix[1][3];
+		lHand[2] = lHandMatrix.matrix[2][3];
+
+		VectorSubtract(lHand, desiredPos, torg);
+		distToDest = VectorLength(torg);
+
+		//closer we are, more we want to keep updated.
+		//if we're far away we don't want to be too fast or we'll start twitching all over.
+		if (distToDest < 2)
+		{ //however if we're this close we want very precise movement
+			ikM.movementSpeed = 0.4f;
+		}
+		else if (distToDest < 16)
+		{
+			ikM.movementSpeed = 0.9f;//8.0f;
+		}
+		else if (distToDest < 32)
+		{
+			ikM.movementSpeed = 0.8f;//4.0f;
+		}
+		else if (distToDest < 64)
+		{
+			ikM.movementSpeed = 0.7f;//2.0f;
+		}
+		else
+		{
+			ikM.movementSpeed = 0.6f;
+		}
+		VectorCopy(origin, ikM.origin); //our position in the world.
+
+		ikM.boneName[0] = 0;
+		if (strap_G2API_IKMove(ghoul2, time, &ikM))
+		{
+			//now do the standard model animate stuff with ragdoll update params.
+			VectorCopy(angles, tuParms.angles);
+			tuParms.angles[PITCH] = 0;
+
+			VectorCopy(origin, tuParms.position);
+			VectorCopy(scale, tuParms.scale);
+
+			tuParms.me = ent->number;
+			VectorClear(tuParms.velocity);
+
+			strap_G2API_AnimateG2Models(ghoul2, time, &tuParms);
+		}
+		else
+		{
+			*ikInProgress = qfalse;
+		}
+	}
+	else if (*ikInProgress)
+	{ //kill it
+		float cFrame, animSpeed;
+		int sFrame, eFrame, flags;
+
+		strap_G2API_SetBoneIKState(ghoul2, time, "lhumerus", IKS_NONE, NULL);
+		strap_G2API_SetBoneIKState(ghoul2, time, "lradius", IKS_NONE, NULL);
+		
+		//then reset the angles/anims on these PCJs
+		strap_G2API_SetBoneAngles(ghoul2, 0, "lhumerus", vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, NULL, 0, time);
+		strap_G2API_SetBoneAngles(ghoul2, 0, "lradius", vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, NULL, 0, time);
+
+		//Get the anim/frames that the pelvis is on exactly, and match the left arm back up with them again.
+		strap_G2API_GetBoneAnim(ghoul2, "pelvis", (const int)time, &cFrame, &sFrame, &eFrame, &flags, &animSpeed, 0, 0);
+		strap_G2API_SetBoneAnim(ghoul2, 0, "lhumerus", sFrame, eFrame, flags, animSpeed, time, sFrame, 300);
+		strap_G2API_SetBoneAnim(ghoul2, 0, "lradius", sFrame, eFrame, flags, animSpeed, time, sFrame, 300);
+
+		//And finally, get rid of all the ik state effector data by calling with null bone name (similar to how we init it).
+		strap_G2API_SetBoneIKState(ghoul2, time, NULL, IKS_NONE, NULL);
+		
+		*ikInProgress = qfalse;
+	}
+}
+
+//Adjust the head/neck desired angles
+void BG_UpdateLookAngles( int lookingDebounceTime, vec3_t lastHeadAngles, int time, vec3_t lookAngles, float lookSpeed, float minPitch, float maxPitch, float minYaw, float maxYaw, float minRoll, float maxRoll )
+{
+	static const float fFrameInter = 0.1f;
+	static vec3_t oldLookAngles;
+	static vec3_t lookAnglesDiff;
+	static int ang;
+
+	if ( lookingDebounceTime > time )
+	{
+		//clamp so don't get "Exorcist" effect
+		if ( lookAngles[PITCH] > maxPitch )
+		{
+			lookAngles[PITCH] = maxPitch;
+		}
+		else if ( lookAngles[PITCH] < minPitch )
+		{
+			lookAngles[PITCH] = minPitch;
+		}
+		if ( lookAngles[YAW] > maxYaw )
+		{
+			lookAngles[YAW] = maxYaw;
+		}
+		else if ( lookAngles[YAW] < minYaw )
+		{
+			lookAngles[YAW] = minYaw;
+		}
+		if ( lookAngles[ROLL] > maxRoll )
+		{
+			lookAngles[ROLL] = maxRoll;
+		}
+		else if ( lookAngles[ROLL] < minRoll )
+		{
+			lookAngles[ROLL] = minRoll;
+		}
+
+		//slowly lerp to this new value
+		//Remember last headAngles
+		VectorCopy( lastHeadAngles, oldLookAngles );
+		VectorSubtract( lookAngles, oldLookAngles, lookAnglesDiff );
+
+		for ( ang = 0; ang < 3; ang++ )
+		{
+			lookAnglesDiff[ang] = AngleNormalize180( lookAnglesDiff[ang] );
+		}
+
+		if( VectorLengthSquared( lookAnglesDiff ) )
+		{
+			lookAngles[PITCH] = AngleNormalize180( oldLookAngles[PITCH]+(lookAnglesDiff[PITCH]*fFrameInter*lookSpeed) );
+			lookAngles[YAW] = AngleNormalize180( oldLookAngles[YAW]+(lookAnglesDiff[YAW]*fFrameInter*lookSpeed) );
+			lookAngles[ROLL] = AngleNormalize180( oldLookAngles[ROLL]+(lookAnglesDiff[ROLL]*fFrameInter*lookSpeed) );
+		}
+	}
+	//Remember current lookAngles next time
+	VectorCopy( lookAngles, lastHeadAngles );
+}
+
+//for setting visual look (headturn) angles
+static void BG_G2ClientNeckAngles( void *ghoul2, int time, const vec3_t lookAngles, vec3_t headAngles, vec3_t neckAngles, vec3_t thoracicAngles, vec3_t headClampMinAngles, vec3_t headClampMaxAngles )
+{
+	vec3_t	lA;
+	VectorCopy( lookAngles, lA );
+	//clamp the headangles (which should now be relative to the cervical (neck) angles
+	if ( lA[PITCH] < headClampMinAngles[PITCH] )
+	{
+		lA[PITCH] = headClampMinAngles[PITCH];
+	}
+	else if ( lA[PITCH] > headClampMaxAngles[PITCH] )
+	{
+		lA[PITCH] = headClampMaxAngles[PITCH];
+	}
+
+	if ( lA[YAW] < headClampMinAngles[YAW] )
+	{
+		lA[YAW] = headClampMinAngles[YAW];
+	}
+	else if ( lA[YAW] > headClampMaxAngles[YAW] )
+	{
+		lA[YAW] = headClampMaxAngles[YAW];
+	}
+
+	if ( lA[ROLL] < headClampMinAngles[ROLL] )
+	{
+		lA[ROLL] = headClampMinAngles[ROLL];
+	}
+	else if ( lA[ROLL] > headClampMaxAngles[ROLL] )
+	{
+		lA[ROLL] = headClampMaxAngles[ROLL];
+	}
+
+	//split it up between the neck and cranium
+	if ( thoracicAngles[PITCH] )
+	{//already been set above, blend them
+		thoracicAngles[PITCH] = (thoracicAngles[PITCH] + (lA[PITCH] * 0.4)) * 0.5f;
+	}
+	else
+	{
+		thoracicAngles[PITCH] = lA[PITCH] * 0.4;
+	}
+	if ( thoracicAngles[YAW] )
+	{//already been set above, blend them
+		thoracicAngles[YAW] = (thoracicAngles[YAW] + (lA[YAW] * 0.1)) * 0.5f;
+	}
+	else
+	{
+		thoracicAngles[YAW] = lA[YAW] * 0.1;
+	}
+	if ( thoracicAngles[ROLL] )
+	{//already been set above, blend them
+		thoracicAngles[ROLL] = (thoracicAngles[ROLL] + (lA[ROLL] * 0.1)) * 0.5f;
+	}
+	else
+	{
+		thoracicAngles[ROLL] = lA[ROLL] * 0.1;
+	}
+
+	neckAngles[PITCH] = lA[PITCH] * 0.2f;
+	neckAngles[YAW] = lA[YAW] * 0.3f;
+	neckAngles[ROLL] = lA[ROLL] * 0.3f;
+
+	headAngles[PITCH] = lA[PITCH] * 0.4;
+	headAngles[YAW] = lA[YAW] * 0.6;
+	headAngles[ROLL] = lA[ROLL] * 0.6;
+
+	/* //non-applicable SP code
+	if ( G_RidingVehicle( cent->gent ) )// && type == VH_SPEEDER ?
+	{//aim torso forward too
+		headAngles[YAW] = neckAngles[YAW] = thoracicAngles[YAW] = 0;
+	}
+	*/
+
+	strap_G2API_SetBoneAngles(ghoul2, 0, "cranium", headAngles, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, 0, 0, time); 
+	strap_G2API_SetBoneAngles(ghoul2, 0, "cervical", neckAngles, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, 0, 0, time); 
+	strap_G2API_SetBoneAngles(ghoul2, 0, "thoracic", thoracicAngles, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, 0, 0, time); 
+}
+
+//rww - Finally decided to convert all this stuff to BG form.
+static void BG_G2ClientSpineAngles( void *ghoul2, int motionBolt, vec3_t cent_lerpOrigin, vec3_t cent_lerpAngles, entityState_t *cent,
+							int time, vec3_t viewAngles, int ciLegs, int ciTorso, const vec3_t angles, vec3_t thoracicAngles,
+							vec3_t ulAngles, vec3_t llAngles, vec3_t modelScale, float *tPitchAngle, float *tYawAngle, int *corrTime )
+{
+	qboolean doCorr = qfalse;
+
+	//*tPitchAngle = viewAngles[PITCH];
+	viewAngles[YAW] = AngleDelta( cent_lerpAngles[YAW], angles[YAW] );
+	//*tYawAngle = viewAngles[YAW];
+
+#if 1
+	if ( !BG_FlippingAnim( cent->legsAnim ) &&
+		!BG_SpinningSaberAnim( cent->legsAnim ) &&
+		!BG_SpinningSaberAnim( cent->torsoAnim ) &&
+		!BG_InSpecialJump( cent->legsAnim ) &&
+		!BG_InSpecialJump( cent->torsoAnim ) &&
+		!BG_InDeathAnim(cent->legsAnim) &&
+		!BG_InDeathAnim(cent->torsoAnim) &&
+		!BG_InRollES(cent, cent->legsAnim) &&
+		!BG_InRollAnim(cent) &&
+		!BG_SaberInSpecial(cent->saberMove) &&
+		!BG_SaberInSpecialAttack(cent->torsoAnim) &&
+		!BG_SaberInSpecialAttack(cent->legsAnim) &&
+
+		!BG_InKnockDown(cent->torsoAnim) &&
+		!BG_InKnockDown(cent->legsAnim) &&
+		!BG_InKnockDown(ciTorso) &&
+		!BG_InKnockDown(ciLegs) &&
+
+		!BG_FlippingAnim( ciLegs ) &&
+		!BG_SpinningSaberAnim( ciLegs ) &&
+		!BG_SpinningSaberAnim( ciTorso ) &&
+		!BG_InSpecialJump( ciLegs ) &&
+		!BG_InSpecialJump( ciTorso ) &&
+		!BG_InDeathAnim(ciLegs) &&
+		!BG_InDeathAnim(ciTorso) &&
+		!BG_SaberInSpecialAttack(ciTorso) &&
+		!BG_SaberInSpecialAttack(ciLegs) &&
+
+		!(cent->eFlags & EF_DEAD) &&
+		(cent->legsAnim) != (cent->torsoAnim) &&
+		(ciLegs) != (ciTorso) &&
+		!cent->m_iVehicleNum)
+	{
+		doCorr = qtrue;
+	}
+#else
+	if ( ((!BG_FlippingAnim( cent->legsAnim ) 
+		&& !BG_SpinningSaberAnim( cent->legsAnim ) 
+		&& !BG_SpinningSaberAnim( cent->torsoAnim )
+		&& (cent->legsAnim) != (cent->torsoAnim)) //NOTE: presumes your legs & torso are on the same frame, though they *should* be because PM_SetAnimFinal tries to keep them in synch
+		||
+		(!BG_FlippingAnim( ciLegs ) 
+		&& !BG_SpinningSaberAnim( ciLegs ) 
+		&& !BG_SpinningSaberAnim( ciTorso )
+		&& (ciLegs) != (ciTorso)))
+		||
+		ciLegs != cent->legsAnim
+		||
+		ciTorso != cent->torsoAnim)
+	{
+		doCorr = qtrue;
+		*corrTime = time + 1000; //continue correcting for a second after to smooth things out. SP doesn't need this for whatever reason but I can't find a way around it.
+	}
+	else if (*corrTime >= time)
+	{
+		if (!BG_FlippingAnim( cent->legsAnim ) 
+			&& !BG_SpinningSaberAnim( cent->legsAnim ) 
+			&& !BG_SpinningSaberAnim( cent->torsoAnim )
+			&& !BG_FlippingAnim( ciLegs ) 
+			&& !BG_SpinningSaberAnim( ciLegs ) 
+			&& !BG_SpinningSaberAnim( ciTorso ))
+		{
+			doCorr = qtrue;
+		}
+	}
+#endif
+
+	if (doCorr)
+	{//FIXME: no need to do this if legs and torso on are same frame
+		//adjust for motion offset
+		mdxaBone_t	boltMatrix;
+		vec3_t		motionFwd, motionAngles;
+		vec3_t		motionRt, tempAng;
+		int			ang;
+
+		strap_G2API_GetBoltMatrix_NoRecNoRot( ghoul2, 0, motionBolt, &boltMatrix, vec3_origin, cent_lerpOrigin, time, 0, modelScale);
+		//BG_GiveMeVectorFromMatrix( &boltMatrix, NEGATIVE_Y, motionFwd );
+		motionFwd[0] = -boltMatrix.matrix[0][1];
+		motionFwd[1] = -boltMatrix.matrix[1][1];
+		motionFwd[2] = -boltMatrix.matrix[2][1];
+
+		vectoangles( motionFwd, motionAngles );
+
+		//BG_GiveMeVectorFromMatrix( &boltMatrix, NEGATIVE_X, motionRt );
+		motionRt[0] = -boltMatrix.matrix[0][0];
+		motionRt[1] = -boltMatrix.matrix[1][0];
+		motionRt[2] = -boltMatrix.matrix[2][0];
+
+		vectoangles( motionRt, tempAng );
+		motionAngles[ROLL] = -tempAng[PITCH];
+
+		for ( ang = 0; ang < 3; ang++ )
+		{
+			viewAngles[ang] = AngleNormalize180( viewAngles[ang] - AngleNormalize180( motionAngles[ang] ) );
+		}
+	}
+
+	//distribute the angles differently up the spine
+	//NOTE: each of these distributions must add up to 1.0f
+	thoracicAngles[PITCH] = viewAngles[PITCH]*0.20f;
+	llAngles[PITCH] = viewAngles[PITCH]*0.40f;
+	ulAngles[PITCH] = viewAngles[PITCH]*0.40f;
+
+	thoracicAngles[YAW] = viewAngles[YAW]*0.20f;
+	ulAngles[YAW] = viewAngles[YAW]*0.35f;
+	llAngles[YAW] = viewAngles[YAW]*0.45f;
+
+	thoracicAngles[ROLL] = viewAngles[ROLL]*0.20f;
+	ulAngles[ROLL] = viewAngles[ROLL]*0.35f;
+	llAngles[ROLL] = viewAngles[ROLL]*0.45f;
+}
+
+/*
+==================
+CG_SwingAngles
+==================
+*/
+static float BG_SwingAngles( float destination, float swingTolerance, float clampTolerance,
+					float speed, float *angle, qboolean *swinging, int frametime ) {
+	float	swing;
+	float	move;
+	float	scale;
+
+	if ( !*swinging ) {
+		// see if a swing should be started
+		swing = AngleSubtract( *angle, destination );
+		if ( swing > swingTolerance || swing < -swingTolerance ) {
+			*swinging = qtrue;
+		}
+	}
+
+	if ( !*swinging ) {
+		return 0;
+	}
+	
+	// modify the speed depending on the delta
+	// so it doesn't seem so linear
+	swing = AngleSubtract( destination, *angle );
+	scale = fabs( swing );
+	if ( scale < swingTolerance * 0.5 ) {
+		scale = 0.5;
+	} else if ( scale < swingTolerance ) {
+		scale = 1.0;
+	} else {
+		scale = 2.0;
+	}
+
+	// swing towards the destination angle
+	if ( swing >= 0 ) {
+		move = frametime * scale * speed;
+		if ( move >= swing ) {
+			move = swing;
+			*swinging = qfalse;
+		}
+		*angle = AngleMod( *angle + move );
+	} else if ( swing < 0 ) {
+		move = frametime * scale * -speed;
+		if ( move <= swing ) {
+			move = swing;
+			*swinging = qfalse;
+		}
+		*angle = AngleMod( *angle + move );
+	}
+
+	// clamp to no more than tolerance
+	swing = AngleSubtract( destination, *angle );
+	if ( swing > clampTolerance ) {
+		*angle = AngleMod( destination - (clampTolerance - 1) );
+	} else if ( swing < -clampTolerance ) {
+		*angle = AngleMod( destination + (clampTolerance - 1) );
+	}
+
+	return swing;
+}
+
+//#define BONE_BASED_LEG_ANGLES
+
+//I apologize for this function
+qboolean BG_InRoll2( entityState_t *es )
+{
+	switch ( (es->legsAnim) )
+	{
+	case BOTH_GETUP_BROLL_B:
+	case BOTH_GETUP_BROLL_F:
+	case BOTH_GETUP_BROLL_L:
+	case BOTH_GETUP_BROLL_R:
+	case BOTH_GETUP_FROLL_B:
+	case BOTH_GETUP_FROLL_F:
+	case BOTH_GETUP_FROLL_L:
+	case BOTH_GETUP_FROLL_R:
+	case BOTH_ROLL_F:
+	case BOTH_ROLL_B:
+	case BOTH_ROLL_R:
+	case BOTH_ROLL_L:
+		return qtrue;
+		break;
+	}
+	return qfalse;
+}
+
+
+extern qboolean BG_SaberLockBreakAnim( int anim ); //bg_panimate.c
+void BG_G2PlayerAngles(void *ghoul2, int motionBolt, entityState_t *cent, int time, vec3_t cent_lerpOrigin,
+					   vec3_t cent_lerpAngles, vec3_t legs[3], vec3_t legsAngles, qboolean *tYawing,
+					   qboolean *tPitching, qboolean *lYawing, float *tYawAngle, float *tPitchAngle,
+					   float *lYawAngle, int frametime, vec3_t turAngles, vec3_t modelScale, int ciLegs,
+					   int ciTorso, int *corrTime, vec3_t lookAngles, vec3_t lastHeadAngles, int lookTime,
+					   entityState_t *emplaced, int *crazySmoothFactor)
+{
+	int					adddir = 0;
+	static int			dir;
+	static int			i;
+	static int			movementOffsets[8] = { 0, 22, 45, -22, 0, 22, -45, -22 };
+	float				degrees_negative = 0;
+	float				degrees_positive = 0;
+	static float		dif;
+	static float		dest;
+	static float		speed; //, speed_dif, speed_desired;
+	static const float	lookSpeed = 1.5f;
+#ifdef BONE_BASED_LEG_ANGLES
+	static float		legBoneYaw;
+#endif
+	static vec3_t		eyeAngles;
+	static vec3_t		neckAngles;
+	static vec3_t		velocity;
+	static vec3_t		torsoAngles, headAngles;
+	static vec3_t		velPos, velAng;
+	static vec3_t		ulAngles, llAngles, viewAngles, angles, thoracicAngles = {0,0,0};
+	static vec3_t		headClampMinAngles = {-25,-55,-10}, headClampMaxAngles = {50,50,10};
+
+	if ( cent->m_iVehicleNum || cent->forceFrame || BG_SaberLockBreakAnim(cent->legsAnim) || BG_SaberLockBreakAnim(cent->torsoAnim) )
+	{ //a vehicle or riding a vehicle - in either case we don't need to be in here
+		vec3_t forcedAngles;
+
+		VectorClear(forcedAngles);
+		forcedAngles[YAW] = cent_lerpAngles[YAW];
+		forcedAngles[ROLL] = cent_lerpAngles[ROLL];
+		AnglesToAxis( forcedAngles, legs );
+		VectorCopy(forcedAngles, legsAngles);
+
+		if (cent->number < MAX_CLIENTS)
+		{
+			strap_G2API_SetBoneAngles(ghoul2, 0, "lower_lumbar", vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, 0, 0, time); 
+			strap_G2API_SetBoneAngles(ghoul2, 0, "upper_lumbar", vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, 0, 0, time); 
+			strap_G2API_SetBoneAngles(ghoul2, 0, "cranium", vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, 0, 0, time); 
+			strap_G2API_SetBoneAngles(ghoul2, 0, "thoracic", vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, 0, 0, time); 
+			strap_G2API_SetBoneAngles(ghoul2, 0, "cervical", vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, 0, 0, time); 
+		}
+		return;
+	}
+
+	if ((time+2000) < *corrTime)
+	{
+		*corrTime = 0;
+	}
+
+	VectorCopy( cent_lerpAngles, headAngles );
+	headAngles[YAW] = AngleMod( headAngles[YAW] );
+	VectorClear( legsAngles );
+	VectorClear( torsoAngles );
+	// --------- yaw -------------
+
+	// allow yaw to drift a bit
+	if ((( cent->legsAnim ) != BOTH_STAND1) || 
+			( cent->torsoAnim ) != WeaponReadyAnim[cent->weapon]  ) 
+	{
+		// if not standing still, always point all in the same direction
+		//cent->pe.torso.yawing = qtrue;	// always center
+		*tYawing = qtrue;
+		//cent->pe.torso.pitching = qtrue;	// always center
+		*tPitching = qtrue;
+		//cent->pe.legs.yawing = qtrue;	// always center
+		*lYawing = qtrue;
+	}
+
+	// adjust legs for movement dir
+	if ( cent->eFlags & EF_DEAD ) {
+		// don't let dead bodies twitch
+		dir = 0;
+	} else {
+		dir = cent->angles2[YAW];
+		if ( dir < 0 || dir > 7 ) {
+			Com_Error( ERR_DROP, "Bad player movement angle (%i)", dir );
+		}
+	}
+
+	torsoAngles[YAW] = headAngles[YAW];
+
+	//for now, turn torso instantly and let the legs swing to follow
+	*tYawAngle = torsoAngles[YAW];
+
+	// --------- pitch -------------
+
+	VectorCopy( cent->pos.trDelta, velocity );
+
+	if (BG_InRoll2(cent))
+	{ //don't affect angles based on vel then
+		VectorClear(velocity);
+	}
+	else if (cent->weapon == WP_SABER &&
+		BG_SaberInSpecial(cent->saberMove))
+	{
+		VectorClear(velocity);
+	}
+
+	speed = VectorNormalize( velocity );
+
+	if (!speed)
+	{
+		torsoAngles[YAW] = headAngles[YAW];
+	}
+
+	// only show a fraction of the pitch angle in the torso
+	if ( headAngles[PITCH] > 180 ) {
+		dest = (-360 + headAngles[PITCH]) * 0.75;
+	} else {
+		dest = headAngles[PITCH] * 0.75;
+	}
+
+	if (cent->m_iVehicleNum)
+	{ //swing instantly on vehicles
+		*tPitchAngle = dest;
+	}
+	else
+	{
+		BG_SwingAngles( dest, 15, 30, 0.1, tPitchAngle, tPitching, frametime );
+	}
+	torsoAngles[PITCH] = *tPitchAngle;
+
+	// --------- roll -------------
+
+	if ( speed ) {
+		vec3_t	axis[3];
+		float	side;
+
+		speed *= 0.05;
+
+		AnglesToAxis( legsAngles, axis );
+		side = speed * DotProduct( velocity, axis[1] );
+		legsAngles[ROLL] -= side;
+
+		side = speed * DotProduct( velocity, axis[0] );
+		legsAngles[PITCH] += side;
+	}
+
+	//legsAngles[YAW] = headAngles[YAW] + (movementOffsets[ dir ]*speed_dif);
+
+	//rww - crazy velocity-based leg angle calculation
+	legsAngles[YAW] = headAngles[YAW];
+	velPos[0] = cent_lerpOrigin[0] + velocity[0];
+	velPos[1] = cent_lerpOrigin[1] + velocity[1];
+	velPos[2] = cent_lerpOrigin[2];// + velocity[2];
+
+	if ( cent->groundEntityNum == ENTITYNUM_NONE ||
+		 cent->forceFrame ||
+		 (cent->weapon == WP_EMPLACED_GUN && emplaced) )
+	{ //off the ground, no direction-based leg angles (same if in saberlock)
+		VectorCopy(cent_lerpOrigin, velPos);
+	}
+
+	VectorSubtract(cent_lerpOrigin, velPos, velAng);
+
+	if (!VectorCompare(velAng, vec3_origin))
+	{
+		vectoangles(velAng, velAng);
+
+		if (velAng[YAW] <= legsAngles[YAW])
+		{
+			degrees_negative = (legsAngles[YAW] - velAng[YAW]);
+			degrees_positive = (360 - legsAngles[YAW]) + velAng[YAW];
+		}
+		else
+		{
+			degrees_negative = legsAngles[YAW] + (360 - velAng[YAW]);
+			degrees_positive = (velAng[YAW] - legsAngles[YAW]);
+		}
+
+		if ( degrees_negative < degrees_positive )
+		{
+			dif = degrees_negative;
+			adddir = 0;
+		}
+		else
+		{
+			dif = degrees_positive;
+			adddir = 1;
+		}
+
+		if (dif > 90)
+		{
+			dif = (180 - dif);
+		}
+
+		if (dif > 60)
+		{
+			dif = 60;
+		}
+
+		//Slight hack for when playing is running backward
+		if (dir == 3 || dir == 5)
+		{
+			dif = -dif;
+		}
+
+		if (adddir)
+		{
+			legsAngles[YAW] -= dif;
+		}
+		else
+		{
+			legsAngles[YAW] += dif;
+		}
+	}
+
+	if (cent->m_iVehicleNum)
+	{ //swing instantly on vehicles
+		*lYawAngle = legsAngles[YAW];
+	}
+	else
+	{
+		BG_SwingAngles( legsAngles[YAW], /*40*/0, 90, 0.65, lYawAngle, lYawing, frametime );
+	}
+	legsAngles[YAW] = *lYawAngle;
+
+	/*
+	// pain twitch
+	CG_AddPainTwitch( cent, torsoAngles );
+	*/
+
+	legsAngles[ROLL] = 0;
+	torsoAngles[ROLL] = 0;
+
+//	VectorCopy(legsAngles, turAngles);
+
+	// pull the angles back out of the hierarchial chain
+	AnglesSubtract( headAngles, torsoAngles, headAngles );
+	AnglesSubtract( torsoAngles, legsAngles, torsoAngles );
+
+	legsAngles[PITCH] = 0;
+
+	if (cent->heldByClient)
+	{ //keep the base angles clear when doing the IK stuff, it doesn't compensate for it.
+	  //rwwFIXMEFIXME: Store leg angles off and add them to all the fed in angles for G2 functions?
+		VectorClear(legsAngles);
+		legsAngles[YAW] = cent_lerpAngles[YAW];
+	}
+
+#ifdef BONE_BASED_LEG_ANGLES
+	legBoneYaw = legsAngles[YAW];
+	VectorClear(legsAngles);
+	legsAngles[YAW] = cent_lerpAngles[YAW];
+#endif
+
+	VectorCopy(legsAngles, turAngles);
+
+	AnglesToAxis( legsAngles, legs );
+
+	VectorCopy( cent_lerpAngles, viewAngles );
+	viewAngles[YAW] = viewAngles[ROLL] = 0;
+	viewAngles[PITCH] *= 0.5;
+
+	VectorSet( angles, 0, legsAngles[1], 0 );
+
+	angles[0] = legsAngles[0];
+	if ( angles[0] > 30 )
+	{
+		angles[0] = 30;
+	}
+	else if ( angles[0] < -30 )
+	{
+		angles[0] = -30;
+	}
+
+	if (cent->weapon == WP_EMPLACED_GUN &&
+		emplaced)
+	{ //if using an emplaced gun, then we want to make sure we're angled to "hold" it right
+		vec3_t facingAngles;
+
+		VectorSubtract(emplaced->pos.trBase, cent_lerpOrigin, facingAngles);
+		vectoangles(facingAngles, facingAngles);
+
+		if (emplaced->weapon == WP_NONE)
+		{ //e-web
+			VectorCopy(facingAngles, legsAngles);
+			AnglesToAxis( legsAngles, legs );
+		}
+		else
+		{ //misc emplaced
+			float dif = AngleSubtract(cent_lerpAngles[YAW], facingAngles[YAW]);
+
+			/*
+			if (emplaced->weapon == WP_NONE)
+			{ //offset is a little bit different for the e-web
+				dif -= 16.0f;
+			}
+			*/
+
+			VectorSet(facingAngles, -16.0f, -dif, 0.0f);
+
+			if (cent->legsAnim == BOTH_STRAFE_LEFT1 || cent->legsAnim == BOTH_STRAFE_RIGHT1)
+			{ //try to adjust so it doesn't look wrong
+				if (crazySmoothFactor)
+				{ //want to smooth a lot during this because it chops around and looks like ass
+					*crazySmoothFactor = time + 1000;
+				}
+
+				BG_G2ClientSpineAngles(ghoul2, motionBolt, cent_lerpOrigin, cent_lerpAngles, cent, time,
+					viewAngles, ciLegs, ciTorso, angles, thoracicAngles, ulAngles, llAngles, modelScale,
+					tPitchAngle, tYawAngle, corrTime);
+				strap_G2API_SetBoneAngles(ghoul2, 0, "lower_lumbar", llAngles, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, 0, 0, time); 
+				strap_G2API_SetBoneAngles(ghoul2, 0, "upper_lumbar", ulAngles, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, 0, 0, time); 
+				strap_G2API_SetBoneAngles(ghoul2, 0, "cranium", vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, 0, 0, time); 
+
+				VectorAdd(facingAngles, thoracicAngles, facingAngles);
+
+				if (cent->legsAnim == BOTH_STRAFE_LEFT1)
+				{ //this one needs some further correction
+					facingAngles[YAW] -= 32.0f;
+				}
+			}
+			else
+			{
+				//strap_G2API_SetBoneAngles(ghoul2, 0, "lower_lumbar", vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, 0, 0, time); 
+				//strap_G2API_SetBoneAngles(ghoul2, 0, "upper_lumbar", vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, 0, 0, time); 
+				strap_G2API_SetBoneAngles(ghoul2, 0, "cranium", vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, 0, 0, time);
+			}
+
+			VectorScale(facingAngles, 0.6f, facingAngles);
+			strap_G2API_SetBoneAngles(ghoul2, 0, "lower_lumbar", vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, 0, 0, time); 
+			VectorScale(facingAngles, 0.8f, facingAngles);
+			strap_G2API_SetBoneAngles(ghoul2, 0, "upper_lumbar", facingAngles, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, 0, 0, time); 
+			VectorScale(facingAngles, 0.8f, facingAngles);
+			strap_G2API_SetBoneAngles(ghoul2, 0, "thoracic", facingAngles, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, 0, 0, time); 
+
+			//Now we want the head angled toward where we are facing
+			VectorSet(facingAngles, 0.0f, dif, 0.0f);
+			VectorScale(facingAngles, 0.6f, facingAngles);
+			strap_G2API_SetBoneAngles(ghoul2, 0, "cervical", facingAngles, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, 0, 0, time); 
+
+			return; //don't have to bother with the rest then
+		}
+	}
+
+	BG_G2ClientSpineAngles(ghoul2, motionBolt, cent_lerpOrigin, cent_lerpAngles, cent, time,
+		viewAngles, ciLegs, ciTorso, angles, thoracicAngles, ulAngles, llAngles, modelScale,
+		tPitchAngle, tYawAngle, corrTime);
+
+	VectorCopy(cent_lerpAngles, eyeAngles);
+
+	for ( i = 0; i < 3; i++ )
+	{
+		lookAngles[i] = AngleNormalize180( lookAngles[i] );
+		eyeAngles[i] = AngleNormalize180( eyeAngles[i] );
+	}
+	AnglesSubtract( lookAngles, eyeAngles, lookAngles );
+
+	BG_UpdateLookAngles(lookTime, lastHeadAngles, time, lookAngles, lookSpeed, -50.0f, 50.0f, -70.0f, 70.0f, -30.0f, 30.0f);
+
+	BG_G2ClientNeckAngles(ghoul2, time, lookAngles, headAngles, neckAngles, thoracicAngles, headClampMinAngles, headClampMaxAngles);
+
+#ifdef BONE_BASED_LEG_ANGLES
+	{
+		vec3_t bLAngles;
+		VectorClear(bLAngles);
+		bLAngles[ROLL] = AngleNormalize180((legBoneYaw - cent_lerpAngles[YAW]));
+		strap_G2API_SetBoneAngles(ghoul2, 0, "model_root", bLAngles, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, 0, 0, time); 
+
+		if (!llAngles[YAW])
+		{
+			llAngles[YAW] -= bLAngles[ROLL];
+		}
+	}
+#endif
+	strap_G2API_SetBoneAngles(ghoul2, 0, "lower_lumbar", llAngles, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, 0, 0, time); 
+	strap_G2API_SetBoneAngles(ghoul2, 0, "upper_lumbar", ulAngles, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, 0, 0, time); 
+	strap_G2API_SetBoneAngles(ghoul2, 0, "thoracic", thoracicAngles, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, 0, 0, time); 
+	//strap_G2API_SetBoneAngles(ghoul2, 0, "cervical", vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, 0, 0, time);
+}
+
+void BG_G2ATSTAngles(void *ghoul2, int time, vec3_t cent_lerpAngles )
+{//																							up			right		fwd
+	strap_G2API_SetBoneAngles(ghoul2, 0, "thoracic", cent_lerpAngles, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, 0, 0, time); 
+}
+
+static qboolean PM_AdjustAnglesForDualJumpAttack( playerState_t *ps, usercmd_t *ucmd )
+{
+	//ucmd->angles[PITCH] = ANGLE2SHORT( ps->viewangles[PITCH] ) - ps->delta_angles[PITCH];
+	//ucmd->angles[YAW] = ANGLE2SHORT( ps->viewangles[YAW] ) - ps->delta_angles[YAW];
+	return qtrue;
+}
+
+#ifdef __LCC__
+static void PM_CmdForSaberMoves(usercmd_t *ucmd)
+#else
+static ID_INLINE void PM_CmdForSaberMoves(usercmd_t *ucmd)
+#endif
+{
+	//DUAL FORWARD+JUMP+ATTACK
+	if ( ( pm->ps->legsAnim == BOTH_JUMPATTACK6
+			&& pm->ps->saberMove == LS_JUMPATTACK_DUAL )
+		|| ( pm->ps->legsAnim == BOTH_BUTTERFLY_FL1 
+			&& pm->ps->saberMove == LS_JUMPATTACK_STAFF_LEFT ) 
+		|| ( pm->ps->legsAnim == BOTH_BUTTERFLY_FR1 
+			&& pm->ps->saberMove == LS_JUMPATTACK_STAFF_RIGHT )
+		|| ( pm->ps->legsAnim == BOTH_BUTTERFLY_RIGHT
+			&& pm->ps->saberMove == LS_BUTTERFLY_RIGHT ) 
+		|| ( pm->ps->legsAnim == BOTH_BUTTERFLY_LEFT 
+			&& pm->ps->saberMove == LS_BUTTERFLY_LEFT ) )
+	{
+		int aLen = PM_AnimLength(0, BOTH_JUMPATTACK6);
+
+		ucmd->forwardmove = ucmd->rightmove = ucmd->upmove = 0;
+
+		if ( pm->ps->legsAnim == BOTH_JUMPATTACK6 )
+		{ //dual stance attack
+			if ( pm->ps->legsTimer >= 100 //not at end
+				&& (aLen - pm->ps->legsTimer) >= 250 ) //not in beginning
+			{ //middle of anim
+				//push forward
+				ucmd->forwardmove = 127;
+			}
+
+			if ( (pm->ps->legsTimer >= 900 //not at end
+					&& aLen - pm->ps->legsTimer >= 950 ) //not in beginning
+				|| ( pm->ps->legsTimer >= 1600 
+					&& aLen - pm->ps->legsTimer >= 400 ) ) //not in beginning
+			{ //one of the two jumps
+				if ( pm->ps->groundEntityNum != ENTITYNUM_NONE )
+				{ //still on ground?
+					if ( pm->ps->groundEntityNum >= MAX_CLIENTS )
+					{
+						//jump!
+						pm->ps->velocity[2] = 250;//400;
+						pm->ps->fd.forceJumpZStart = pm->ps->origin[2];//so we don't take damage if we land at same height
+						//pm->ps->pm_flags |= PMF_JUMPING;
+						//FIXME: NPCs yell?
+						PM_AddEvent(EV_JUMP);
+						//G_SoundOnEnt( ent, CHAN_BODY, "sound/weapons/force/jump.wav" );
+					}
+				}
+				else
+				{ //FIXME: if this is the second jump, maybe we should just stop the anim?
+				}
+			}
+		}
+		else
+		{ //saberstaff attacks
+			int aLen = PM_AnimLength(0, (animNumber_t)pm->ps->legsAnim);
+			float lenMin = 1700.0f;
+			float lenMax = 1800.0f;
+
+			if (pm->ps->legsAnim == BOTH_BUTTERFLY_LEFT)
+			{
+				lenMin = 1200.0f;
+				lenMax = 1400.0f;
+			}
+
+			//FIXME: don't slide off people/obstacles?
+			if ( pm->ps->legsAnim == BOTH_BUTTERFLY_RIGHT
+				|| pm->ps->legsAnim == BOTH_BUTTERFLY_LEFT )
+			{
+				if ( pm->ps->legsTimer > 450 )
+				{
+					switch ( pm->ps->legsAnim )
+					{
+						case BOTH_BUTTERFLY_LEFT:
+							ucmd->rightmove = -127;
+							break;
+						case BOTH_BUTTERFLY_RIGHT:
+							ucmd->rightmove = 127;
+							break;
+						default:
+							break;
+					}
+				}
+			}
+			else
+			{
+				if ( pm->ps->legsTimer >= 100 //not at end
+					&& aLen - pm->ps->legsTimer >= 250 )//not in beginning
+				{//middle of anim
+					//push forward
+					ucmd->forwardmove = 127;
+				}
+			}
+			
+			if ( pm->ps->legsTimer >= lenMin && pm->ps->legsTimer < lenMax )     
+			{//one of the two jumps
+				if ( pm->ps->groundEntityNum != ENTITYNUM_NONE )
+				{//still on ground?
+					//jump!
+					if (pm->ps->legsAnim == BOTH_BUTTERFLY_LEFT)
+					{
+						pm->ps->velocity[2] = 350;
+					}
+					else
+					{
+						pm->ps->velocity[2] = 250;
+					}
+					pm->ps->fd.forceJumpZStart = pm->ps->origin[2];//so we don't take damage if we land at same height
+					//pm->ps->pm_flags |= PMF_JUMPING;//|PMF_SLOW_MO_FALL;
+					//FIXME: NPCs yell?
+					PM_AddEvent(EV_JUMP);
+					//G_SoundOnEnt( ent, CHAN_BODY, "sound/weapons/force/jump.wav" );
+				}
+				else
+				{//FIXME: if this is the second jump, maybe we should just stop the anim?
+				}
+			}
+		}
+
+		if ( pm->ps->groundEntityNum == ENTITYNUM_NONE )
+		{//can only turn when your feet hit the ground
+			if (PM_AdjustAnglesForDualJumpAttack(pm->ps, ucmd))
+			{
+				PM_SetPMViewAngle(pm->ps, pm->ps->viewangles, ucmd);
+			}
+		}
+		//rwwFIXMEFIXME: Bother with bbox resizing like sp?
+	}
+	//STAFF BACK+JUMP+ATTACK
+	else if (pm->ps->saberMove == LS_A_BACKFLIP_ATK &&
+		pm->ps->legsAnim == BOTH_JUMPATTACK7)
+	{
+		int aLen = PM_AnimLength(0, BOTH_JUMPATTACK7);
+
+		if ( pm->ps->legsTimer > 800 //not at end
+			&& aLen - pm->ps->legsTimer >= 400 )//not in beginning
+		{//middle of anim
+			if ( pm->ps->groundEntityNum != ENTITYNUM_NONE )
+			{//still on ground?
+				vec3_t yawAngles, backDir;
+
+				//push backwards some?
+				VectorSet( yawAngles, 0, pm->ps->viewangles[YAW]+180, 0 );
+				AngleVectors( yawAngles, backDir, 0, 0 );
+				VectorScale( backDir, 100, pm->ps->velocity );
+
+				//jump!
+				pm->ps->velocity[2] = 300;
+				pm->ps->fd.forceJumpZStart = pm->ps->origin[2]; //so we don't take damage if we land at same height
+				//pm->ps->pm_flags |= PMF_JUMPING;//|PMF_SLOW_MO_FALL;
+
+				//FIXME: NPCs yell?
+				PM_AddEvent(EV_JUMP);
+				//G_SoundOnEnt( ent, CHAN_BODY, "sound/weapons/force/jump.wav" );
+				ucmd->upmove = 0; //clear any actual jump command
+			}
+		}
+		ucmd->forwardmove = ucmd->rightmove = ucmd->upmove = 0;
+	}
+	//STAFF/DUAL SPIN ATTACK
+	else if (pm->ps->saberMove == LS_SPINATTACK ||
+		pm->ps->saberMove == LS_SPINATTACK_DUAL)
+	{
+		ucmd->forwardmove = ucmd->rightmove = ucmd->upmove = 0;
+		//lock their viewangles during these attacks.
+		PM_SetPMViewAngle(pm->ps, pm->ps->viewangles, ucmd);
+	}
+}
+
+//constrain him based on the angles of his vehicle and the caps
+void PM_VehicleViewAngles(playerState_t *ps, bgEntity_t *veh, usercmd_t *ucmd)
+{
+	Vehicle_t *pVeh = veh->m_pVehicle;
+	qboolean setAngles = qtrue;
+	vec3_t clampMin;
+	vec3_t clampMax;
+	int i;
+
+	if ( veh->m_pVehicle->m_pPilot 
+		&& veh->m_pVehicle->m_pPilot->s.number == ps->clientNum )
+	{//set the pilot's viewangles to the vehicle's viewangles
+		if ( 1 )//!BG_UnrestrainedPitchRoll( ps, veh->m_pVehicle ) )
+		{//only if not if doing special free-roll/pitch control
+			setAngles = qtrue;
+			clampMin[PITCH] = -pVeh->m_pVehicleInfo->lookPitch;
+			clampMax[PITCH] = pVeh->m_pVehicleInfo->lookPitch;
+			clampMin[YAW] = clampMax[YAW] = 0;
+			clampMin[ROLL] = clampMax[ROLL] = -1;
+		}
+	}
+	else 
+	{
+		//NOTE: passengers can look around freely, UNLESS they're controlling a turret!
+		for ( i = 0; i < MAX_VEHICLE_TURRETS; i++ )
+		{
+			if ( veh->m_pVehicle->m_pVehicleInfo->turret[i].passengerNum == ps->generic1 )
+			{//this turret is my station
+				setAngles = qtrue;
+				clampMin[PITCH] = veh->m_pVehicle->m_pVehicleInfo->turret[i].pitchClampUp;
+				clampMax[PITCH] = veh->m_pVehicle->m_pVehicleInfo->turret[i].pitchClampDown;
+				clampMin[YAW] = veh->m_pVehicle->m_pVehicleInfo->turret[i].yawClampRight;
+				clampMax[YAW] = veh->m_pVehicle->m_pVehicleInfo->turret[i].yawClampLeft;
+				clampMin[ROLL] = clampMax[ROLL] = 0;
+				break;
+			}
+		}
+	}
+	if ( setAngles )
+	{
+		for ( i = 0; i < 3; i++ )
+		{//clamp viewangles
+			if ( clampMin[i] == -1 || clampMax[i] == -1 )
+			{//no clamp
+			}
+			else if ( !clampMin[i] && !clampMax[i] )
+			{//no allowance
+				//ps->viewangles[i] = veh->playerState->viewangles[i];
+			}
+			else
+			{//allowance
+				if (ps->viewangles[i] > clampMax[i])
+				{
+					ps->viewangles[i] = clampMax[i];
+				}
+				else if (ps->viewangles[i] < clampMin[i])
+				{
+					ps->viewangles[i] = clampMin[i];
+				}
+			}
+		}
+
+		PM_SetPMViewAngle(ps, ps->viewangles, ucmd);
+	}
+}
+
+/*
+//constrain him based on the angles of his vehicle and the caps
+void PM_VehicleViewAngles(playerState_t *ps, bgEntity_t *veh, usercmd_t *ucmd)
+{
+	Vehicle_t *pVeh = veh->m_pVehicle;
+
+	//now set the viewangles to the vehicle's directly
+	ps->viewangles[YAW] = veh->playerState->viewangles[YAW];
+
+	//constrain the viewangles pitch based on the vehicle properties
+	if ( !pVeh->m_pVehicleInfo->lookPitch )
+	{//not allowed to look up & down!  ....???
+		ps->viewangles[PITCH] = veh->playerState->viewangles[PITCH];
+	}
+	else
+	{//clamp
+		if (ps->viewangles[PITCH] > pVeh->m_pVehicleInfo->lookPitch)
+		{
+			ps->viewangles[PITCH] = pVeh->m_pVehicleInfo->lookPitch;
+		}
+		else if (ps->viewangles[PITCH] < -pVeh->m_pVehicleInfo->lookPitch)
+		{
+			ps->viewangles[PITCH] = -pVeh->m_pVehicleInfo->lookPitch;
+		}
+	}
+
+	PM_SetPMViewAngle(ps, ps->viewangles, ucmd);
+}
+*/
+//see if a weapon is ok to use on a vehicle
+qboolean PM_WeaponOkOnVehicle( int weapon )
+{
+	//FIXME: check g_vehicleInfo for our vehicle?
+	switch ( weapon )
+	{
+	//case WP_NONE:
+	case WP_MELEE:
+	case WP_SABER:
+	case WP_BLASTER:
+	//case WP_THERMAL:
+		return qtrue;
+		break;
+	}
+	return qfalse;
+}
+
+//do we have a weapon that's ok for using on the vehicle?
+int PM_GetOkWeaponForVehicle(void)
+{
+	int i = 0;
+
+	while (i < WP_NUM_WEAPONS)
+	{
+		if ((pm->ps->stats[STAT_WEAPONS] & (1 << i)) &&
+			PM_WeaponOkOnVehicle(i))
+		{ //this one's good
+			return i;
+		}
+
+		i++;
+	}
+
+	//oh dear!
+	//assert(!"No valid veh weaps");
+	return -1;
+}
+
+//force the vehicle to turn and travel to its forced destination point
+void PM_VehForcedTurning(bgEntity_t *veh)
+{
+	bgEntity_t *dst = PM_BGEntForNum(veh->playerState->vehTurnaroundIndex);
+	float pitchD, yawD;
+	vec3_t dir;
+
+	if (!veh || !veh->m_pVehicle)
+	{
+		return;
+	}
+
+	if (!dst)
+	{ //can't find dest ent?
+		return;
+	}
+
+	pm->cmd.upmove = veh->m_pVehicle->m_ucmd.upmove = 127;
+	pm->cmd.forwardmove = veh->m_pVehicle->m_ucmd.forwardmove = 0;
+	pm->cmd.rightmove = veh->m_pVehicle->m_ucmd.rightmove = 0;
+
+	VectorSubtract(dst->s.origin, veh->playerState->origin, dir);
+	vectoangles(dir, dir);
+
+	yawD = AngleSubtract(pm->ps->viewangles[YAW], dir[YAW]);
+	pitchD = AngleSubtract(pm->ps->viewangles[PITCH], dir[PITCH]);
+
+	yawD *= 0.6f*pml.frametime;
+	pitchD *= 0.6f*pml.frametime;
+
+	veh->playerState->viewangles[YAW] = AngleSubtract(veh->playerState->viewangles[YAW], yawD);
+	veh->playerState->viewangles[PITCH] = AngleSubtract(veh->playerState->viewangles[PITCH], pitchD);
+	pm->ps->viewangles[YAW] = veh->playerState->viewangles[YAW];
+	pm->ps->viewangles[PITCH] = 0;
+
+	PM_SetPMViewAngle(pm->ps, pm->ps->viewangles, &pm->cmd);
+	PM_SetPMViewAngle(veh->playerState, veh->playerState->viewangles, &pm->cmd);
+	VectorClear( veh->m_pVehicle->m_vPrevRiderViewAngles );
+	veh->m_pVehicle->m_vPrevRiderViewAngles[YAW] = AngleNormalize180(pm->ps->viewangles[YAW]);
+}
+
+void PM_VehFaceHyperspacePoint(bgEntity_t *veh)
+{
+
+	if (!veh || !veh->m_pVehicle)
+	{
+		return;
+	}
+	else
+	{
+		float timeFrac = ((float)(pm->cmd.serverTime-veh->playerState->hyperSpaceTime))/HYPERSPACE_TIME;
+		float	turnRate, aDelta;
+		int		i, matchedAxes = 0;
+
+		pm->cmd.upmove = veh->m_pVehicle->m_ucmd.upmove = 127;
+		pm->cmd.forwardmove = veh->m_pVehicle->m_ucmd.forwardmove = 0;
+		pm->cmd.rightmove = veh->m_pVehicle->m_ucmd.rightmove = 0;
+		
+		turnRate = (90.0f*pml.frametime);
+		for ( i = 0; i < 3; i++ )
+		{
+			aDelta = AngleSubtract(veh->playerState->hyperSpaceAngles[i], veh->m_pVehicle->m_vOrientation[i]);
+			if ( fabs( aDelta ) < turnRate )
+			{//all is good
+				veh->playerState->viewangles[i] = veh->playerState->hyperSpaceAngles[i];
+				matchedAxes++;
+			}
+			else
+			{
+				aDelta = AngleSubtract(veh->playerState->hyperSpaceAngles[i], veh->playerState->viewangles[i]);
+				if ( fabs( aDelta ) < turnRate )
+				{
+					veh->playerState->viewangles[i] = veh->playerState->hyperSpaceAngles[i];
+				}
+				else if ( aDelta > 0 )
+				{
+					if ( i == YAW )
+					{
+						veh->playerState->viewangles[i] = AngleNormalize360( veh->playerState->viewangles[i]+turnRate );
+					}
+					else
+					{
+						veh->playerState->viewangles[i] = AngleNormalize180( veh->playerState->viewangles[i]+turnRate );
+					}
+				}
+				else
+				{
+					if ( i == YAW )
+					{
+						veh->playerState->viewangles[i] = AngleNormalize360( veh->playerState->viewangles[i]-turnRate );
+					}
+					else
+					{
+						veh->playerState->viewangles[i] = AngleNormalize180( veh->playerState->viewangles[i]-turnRate );
+					}
+				}
+			}
+		}
+
+		pm->ps->viewangles[YAW] = veh->playerState->viewangles[YAW];
+		pm->ps->viewangles[PITCH] = 0.0f;
+
+		PM_SetPMViewAngle(pm->ps, pm->ps->viewangles, &pm->cmd);
+		PM_SetPMViewAngle(veh->playerState, veh->playerState->viewangles, &pm->cmd);
+		VectorClear( veh->m_pVehicle->m_vPrevRiderViewAngles );
+		veh->m_pVehicle->m_vPrevRiderViewAngles[YAW] = AngleNormalize180(pm->ps->viewangles[YAW]);
+		
+		if ( timeFrac < HYPERSPACE_TELEPORT_FRAC )
+		{//haven't gone through yet
+			if ( matchedAxes < 3 )
+			{//not facing the right dir yet
+				//keep hyperspace time up to date
+				veh->playerState->hyperSpaceTime += pml.msec;
+			}
+			else if ( !(veh->playerState->eFlags2&EF2_HYPERSPACE))
+			{//flag us as ready to hyperspace!
+				veh->playerState->eFlags2 |= EF2_HYPERSPACE;
+			}
+		}
+	}
+}
+
+void BG_VehicleAdjustBBoxForOrientation( Vehicle_t *veh, vec3_t origin, vec3_t mins, vec3_t maxs,
+										int clientNum, int tracemask,
+										void (*localTrace)(trace_t *results, const vec3_t start, const vec3_t mins, const vec3_t maxs, const vec3_t end, int passEntityNum, int contentMask))
+{
+	if ( !veh 
+		|| !veh->m_pVehicleInfo->length 
+		|| !veh->m_pVehicleInfo->width 
+		|| !veh->m_pVehicleInfo->height )
+		//|| veh->m_LandTrace.fraction < 1.0f )
+	{
+		return;
+	}
+	else if ( veh->m_pVehicleInfo->type != VH_FIGHTER 
+		//&& veh->m_pVehicleInfo->type != VH_SPEEDER 
+		&& veh->m_pVehicleInfo->type != VH_FLIER )
+	{//only those types of vehicles have dynamic bboxes, the rest just use a static bbox
+		VectorSet( maxs, veh->m_pVehicleInfo->width/2.0f, veh->m_pVehicleInfo->width/2.0f, veh->m_pVehicleInfo->height+DEFAULT_MINS_2 );
+		VectorSet( mins, veh->m_pVehicleInfo->width/-2.0f, veh->m_pVehicleInfo->width/-2.0f, DEFAULT_MINS_2 );
+		return;
+	}
+	else
+	{
+		vec3_t	axis[3], point[8];
+		vec3_t	newMins, newMaxs;
+		int		curAxis = 0, i;
+		trace_t trace;
+
+		AnglesToAxis( veh->m_vOrientation, axis );
+		VectorMA( origin, veh->m_pVehicleInfo->length/2.0f, axis[0], point[0] );
+		VectorMA( origin, -veh->m_pVehicleInfo->length/2.0f, axis[0], point[1] );
+		//extrapolate each side up and down
+		VectorMA( point[0], veh->m_pVehicleInfo->height/2.0f, axis[2], point[0] );
+		VectorMA( point[0], -veh->m_pVehicleInfo->height, axis[2], point[2] );
+		VectorMA( point[1], veh->m_pVehicleInfo->height/2.0f, axis[2], point[1] );
+		VectorMA( point[1], -veh->m_pVehicleInfo->height, axis[2], point[3] );
+
+		VectorMA( origin, veh->m_pVehicleInfo->width/2.0f, axis[1], point[4] );
+		VectorMA( origin, -veh->m_pVehicleInfo->width/2.0f, axis[1], point[5] );
+		//extrapolate each side up and down
+		VectorMA( point[4], veh->m_pVehicleInfo->height/2.0f, axis[2], point[4] );
+		VectorMA( point[4], -veh->m_pVehicleInfo->height, axis[2], point[6] );
+		VectorMA( point[5], veh->m_pVehicleInfo->height/2.0f, axis[2], point[5] );
+		VectorMA( point[5], -veh->m_pVehicleInfo->height, axis[2], point[7] );
+		/*
+		VectorMA( origin, veh->m_pVehicleInfo->height/2.0f, axis[2], point[4] );
+		VectorMA( origin, -veh->m_pVehicleInfo->height/2.0f, axis[2], point[5] );
+		*/
+		//Now inflate a bbox around these points
+		VectorCopy( origin, newMins );
+		VectorCopy( origin, newMaxs );
+		for ( curAxis = 0; curAxis < 3; curAxis++ )
+		{
+			for ( i = 0; i < 8; i++ )
+			{
+				if ( point[i][curAxis] > newMaxs[curAxis] )
+				{
+					newMaxs[curAxis] = point[i][curAxis];
+				}
+				else if ( point[i][curAxis] < newMins[curAxis] )
+				{
+					newMins[curAxis] = point[i][curAxis];
+				}
+			}
+		}
+		VectorSubtract( newMins, origin, newMins );
+		VectorSubtract( newMaxs, origin, newMaxs );
+		//now see if that's a valid way to be
+		if (localTrace)
+		{
+			localTrace( &trace, origin, newMins, newMaxs, origin, clientNum, tracemask );
+		}
+		else
+		{ //don't care about solid stuff then
+			trace.startsolid = trace.allsolid = 0;
+		}
+		if ( !trace.startsolid && !trace.allsolid )
+		{//let's use it!
+			VectorCopy( newMins, mins );
+			VectorCopy( newMaxs, maxs );
+		}
+		//else: just use the last one, I guess...?
+		//FIXME: make it as close as possible?  Or actually prevent the change in m_vOrientation?  Or push away from anything we hit?
+	}
+}
+/*
+================
+PmoveSingle
+
+================
+*/
+extern void trap_SnapVector( float *v );
+extern int BG_EmplacedView(vec3_t baseAngles, vec3_t angles, float *newYaw, float constraint);
+extern qboolean BG_FighterUpdate(Vehicle_t *pVeh, const usercmd_t *pUcmd, vec3_t trMins, vec3_t trMaxs, float gravity,
+					  void (*traceFunc)( trace_t *results, const vec3_t start, const vec3_t lmins, const vec3_t lmaxs, const vec3_t end, int passEntityNum, int contentMask )); //FighterNPC.c
+
+#define JETPACK_HOVER_HEIGHT	64
+
+//#define _TESTING_VEH_PREDICTION
+
+void PM_MoveForKata(usercmd_t *ucmd)
+{
+	if ( pm->ps->legsAnim == BOTH_A7_SOULCAL
+		&& pm->ps->saberMove == LS_STAFF_SOULCAL )
+	{//forward spinning staff attack
+		ucmd->upmove = 0;
+
+		if ( PM_CanRollFromSoulCal( pm->ps ) )
+		{
+			ucmd->upmove = -127;
+			ucmd->rightmove = 0;
+			if (ucmd->forwardmove < 0)
+			{
+				ucmd->forwardmove = 0;
+			}
+		}
+		else
+		{
+			ucmd->rightmove = 0;
+			//FIXME: don't slide off people/obstacles?
+			if ( pm->ps->legsTimer >= 2750 )
+			{//not at end
+				//push forward
+				ucmd->forwardmove = 64;
+			}
+			else
+			{
+				ucmd->forwardmove = 0;
+			}
+		}
+		if ( pm->ps->legsTimer >= 2650 
+			&& pm->ps->legsTimer < 2850 )     
+		{//the jump
+			if ( pm->ps->groundEntityNum != ENTITYNUM_NONE )
+			{//still on ground?
+				//jump!
+				pm->ps->velocity[2] = 250;
+				pm->ps->fd.forceJumpZStart = pm->ps->origin[2];//so we don't take damage if we land at same height
+			//	pm->ps->pm_flags |= PMF_JUMPING;//|PMF_SLOW_MO_FALL;
+				//FIXME: NPCs yell?
+				PM_AddEvent(EV_JUMP);
+			}
+		}
+	}
+	else if (pm->ps->legsAnim == BOTH_A2_SPECIAL)
+	{ //medium kata
+		pm->cmd.rightmove = 0;
+		pm->cmd.upmove = 0;
+		if (pm->ps->legsTimer < 2700 && pm->ps->legsTimer > 2300)
+		{
+			pm->cmd.forwardmove = 127;
+		}
+		else if (pm->ps->legsTimer < 900 && pm->ps->legsTimer > 500)
+		{
+			pm->cmd.forwardmove = 127;
+		}
+		else
+		{
+			pm->cmd.forwardmove = 0;
+		}
+	}
+	else if (pm->ps->legsAnim == BOTH_A3_SPECIAL)
+	{ //strong kata
+		pm->cmd.rightmove = 0;
+		pm->cmd.upmove = 0;
+		if (pm->ps->legsTimer < 1700 && pm->ps->legsTimer > 1000)
+		{
+			pm->cmd.forwardmove = 127;
+		}
+		else
+		{
+			pm->cmd.forwardmove = 0;
+		}
+	}
+	else
+	{
+		pm->cmd.forwardmove = 0;
+		pm->cmd.rightmove = 0;
+		pm->cmd.upmove = 0;
+	}
+}
+
+void PmoveSingle (pmove_t *pmove) {
+	qboolean stiffenedUp = qfalse;
+	float gDist = 0;
+	qboolean noAnimate = qfalse;
+	int savedGravity = 0;
+
+	pm = pmove;
+
+	if (pm->ps->emplacedIndex)
+	{
+		if (pm->cmd.buttons & BUTTON_ALT_ATTACK)
+		{ //hackerrific.
+			pm->cmd.buttons &= ~BUTTON_ALT_ATTACK;
+			pm->cmd.buttons |= BUTTON_ATTACK;
+		}
+	}
+
+	//set up these "global" bg ents
+	pm_entSelf = PM_BGEntForNum(pm->ps->clientNum);
+	if (pm->ps->m_iVehicleNum)
+	{
+		if (pm->ps->clientNum < MAX_CLIENTS)
+		{ //player riding vehicle
+			pm_entVeh = PM_BGEntForNum(pm->ps->m_iVehicleNum);
+		}
+		else
+		{ //vehicle with player pilot
+			pm_entVeh = PM_BGEntForNum(pm->ps->m_iVehicleNum-1);
+		}
+	}
+	else
+	{ //no vehicle ent
+		pm_entVeh = NULL;
+	}
+
+	gPMDoSlowFall = PM_DoSlowFall();
+
+	// this counter lets us debug movement problems with a journal
+	// by setting a conditional breakpoint fot the previous frame
+	c_pmove++;
+
+	// clear results
+	pm->numtouch = 0;
+	pm->watertype = 0;
+	pm->waterlevel = 0;
+
+	if (PM_IsRocketTrooper())
+	{ //kind of nasty, don't let them crouch or anything if nonhumanoid (probably a rockettrooper)
+		if (pm->cmd.upmove < 0)
+		{
+			pm->cmd.upmove = 0;
+		}
+	}
+
+	if (pm->ps->pm_type == PM_FLOAT)
+	{ //You get no control over where you go in grip movement
+		stiffenedUp = qtrue;
+	}
+	else if (pm->ps->eFlags & EF_DISINTEGRATION)
+	{
+		stiffenedUp = qtrue;
+	}
+	else if ( BG_SaberLockBreakAnim( pm->ps->legsAnim )
+		|| BG_SaberLockBreakAnim( pm->ps->torsoAnim ) 
+		|| pm->ps->saberLockTime >= pm->cmd.serverTime )
+	{//can't move or turn
+		stiffenedUp = qtrue;
+		PM_SetPMViewAngle(pm->ps, pm->ps->viewangles, &pm->cmd);
+	}
+	else if ( pm->ps->saberMove == LS_A_BACK || pm->ps->saberMove == LS_A_BACK_CR ||
+		pm->ps->saberMove == LS_A_BACKSTAB || pm->ps->saberMove == LS_A_FLIP_STAB ||
+		pm->ps->saberMove == LS_A_FLIP_SLASH || pm->ps->saberMove == LS_A_JUMP_T__B_ ||
+		pm->ps->saberMove == LS_DUAL_LR || pm->ps->saberMove == LS_DUAL_FB)
+	{
+		if (pm->ps->legsAnim == BOTH_JUMPFLIPSTABDOWN ||
+			pm->ps->legsAnim == BOTH_JUMPFLIPSLASHDOWN1)
+		{ //flipover medium stance attack
+			if (pm->ps->legsTimer < 1600 && pm->ps->legsTimer > 900)
+			{
+				pm->ps->viewangles[YAW] += pml.frametime*240.0f;
+				PM_SetPMViewAngle(pm->ps, pm->ps->viewangles, &pm->cmd);
+			}
+		}
+		stiffenedUp = qtrue;
+	}
+	else if ((pm->ps->legsAnim) == (BOTH_A2_STABBACK1) ||
+		(pm->ps->legsAnim) == (BOTH_ATTACK_BACK) ||
+		(pm->ps->legsAnim) == (BOTH_CROUCHATTACKBACK1) ||
+		(pm->ps->legsAnim) == (BOTH_FORCELEAP2_T__B_) ||
+		(pm->ps->legsAnim) == (BOTH_JUMPFLIPSTABDOWN) ||
+		(pm->ps->legsAnim) == (BOTH_JUMPFLIPSLASHDOWN1))
+	{
+		stiffenedUp = qtrue;
+	}
+	else if (pm->ps->legsAnim == BOTH_ROLL_STAB)
+	{
+		stiffenedUp = qtrue;
+		PM_SetPMViewAngle(pm->ps, pm->ps->viewangles, &pm->cmd);
+	}
+	else if (pm->ps->heldByClient)
+	{
+		stiffenedUp = qtrue;
+	}
+	else if (BG_KickMove(pm->ps->saberMove) || BG_KickingAnim(pm->ps->legsAnim))
+	{
+		stiffenedUp = qtrue;
+	}
+	else if (BG_InGrappleMove(pm->ps->torsoAnim))
+	{
+		stiffenedUp = qtrue;
+		PM_SetPMViewAngle(pm->ps, pm->ps->viewangles, &pm->cmd);
+	}
+	else if ( pm->ps->saberMove == LS_STABDOWN_DUAL ||
+			pm->ps->saberMove == LS_STABDOWN_STAFF ||
+			pm->ps->saberMove == LS_STABDOWN)
+	{//FIXME: need to only move forward until we bump into our target...?
+		if (pm->ps->legsTimer < 800)
+		{ //freeze movement near end of anim
+			stiffenedUp = qtrue;
+			PM_SetPMViewAngle(pm->ps, pm->ps->viewangles, &pm->cmd);
+		}
+		else
+		{ //force forward til then
+            pm->cmd.rightmove = 0;
+			pm->cmd.upmove = 0;
+			pm->cmd.forwardmove = 64;
+		}
+	}
+	else if (pm->ps->saberMove == LS_PULL_ATTACK_STAB ||
+		pm->ps->saberMove == LS_PULL_ATTACK_SWING)
+	{
+		stiffenedUp = qtrue;
+	}
+	else if (BG_SaberInKata(pm->ps->saberMove) ||
+			 BG_InKataAnim(pm->ps->torsoAnim) ||
+			 BG_InKataAnim(pm->ps->legsAnim))
+	{
+		PM_MoveForKata(&pm->cmd);
+	}
+	else if ( BG_FullBodyTauntAnim( pm->ps->legsAnim )
+		&& BG_FullBodyTauntAnim( pm->ps->torsoAnim ) )
+	{
+		if ( (pm->cmd.buttons&BUTTON_ATTACK)
+			|| (pm->cmd.buttons&BUTTON_ALT_ATTACK)
+			|| (pm->cmd.buttons&BUTTON_FORCEPOWER)
+			|| (pm->cmd.buttons&BUTTON_FORCEGRIP)
+			|| (pm->cmd.buttons&BUTTON_FORCE_LIGHTNING)
+			|| (pm->cmd.buttons&BUTTON_FORCE_DRAIN)
+			|| pm->cmd.upmove )
+		{//stop the anim
+			if ( pm->ps->legsAnim == BOTH_MEDITATE
+				&& pm->ps->torsoAnim == BOTH_MEDITATE )
+			{
+				PM_SetAnim( SETANIM_BOTH, BOTH_MEDITATE_END, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD, 0 );
+			}
+			else
+			{
+				pm->ps->legsTimer = pm->ps->torsoTimer = 0;
+			}
+			if ( pm->ps->forceHandExtend == HANDEXTEND_TAUNT )
+			{
+				pm->ps->forceHandExtend = 0;
+			}
+		}
+		else 
+		{
+			if ( pm->ps->legsAnim == BOTH_MEDITATE )
+			{
+				if ( pm->ps->legsTimer < 100 )
+				{
+					pm->ps->legsTimer = 100;
+				}
+			}
+			if ( pm->ps->torsoAnim == BOTH_MEDITATE )
+			{
+				if ( pm->ps->torsoTimer < 100 )
+				{
+					pm->ps->legsTimer = 100;
+				}
+				pm->ps->forceHandExtend = HANDEXTEND_TAUNT;
+				pm->ps->forceHandExtendTime = pm->cmd.serverTime + 100;
+			}
+			if ( pm->ps->legsTimer > 0 || pm->ps->torsoTimer > 0 )
+			{
+				stiffenedUp = qtrue;
+				PM_SetPMViewAngle(pm->ps, pm->ps->viewangles, &pm->cmd);
+				pm->cmd.rightmove = 0;
+				pm->cmd.upmove = 0;
+				pm->cmd.forwardmove = 0;
+				pm->cmd.buttons = 0;
+			}
+		}
+	}
+	else if ( pm->ps->legsAnim == BOTH_MEDITATE_END 
+		&& pm->ps->legsTimer > 0 )
+	{
+		stiffenedUp = qtrue;
+		PM_SetPMViewAngle(pm->ps, pm->ps->viewangles, &pm->cmd);
+        pm->cmd.rightmove = 0;
+		pm->cmd.upmove = 0;
+		pm->cmd.forwardmove = 0;
+		pm->cmd.buttons = 0;
+	}
+	else if (pm->ps->legsAnim == BOTH_FORCELAND1 ||
+		pm->ps->legsAnim == BOTH_FORCELANDBACK1 ||
+		pm->ps->legsAnim == BOTH_FORCELANDRIGHT1 ||
+		pm->ps->legsAnim == BOTH_FORCELANDLEFT1) 
+	{ //can't move while in a force land
+		stiffenedUp = qtrue;
+	}
+
+	if ( pm->ps->saberMove == LS_A_LUNGE )
+	{//can't move during lunge
+		pm->cmd.rightmove = pm->cmd.upmove = 0;
+		if ( pm->ps->legsTimer > 500 )
+		{
+			pm->cmd.forwardmove = 127;
+		}
+		else
+		{
+			pm->cmd.forwardmove = 0;
+		}
+	}
+
+	if ( pm->ps->saberMove == LS_A_JUMP_T__B_ )
+	{//can't move during leap
+		if ( pm->ps->groundEntityNum != ENTITYNUM_NONE )
+		{//hit the ground
+			pm->cmd.forwardmove = 0;
+		}
+		pm->cmd.rightmove = pm->cmd.upmove = 0;
+	}
+
+#if 0
+	if ((pm->ps->legsAnim) == BOTH_KISSER1LOOP ||
+		(pm->ps->legsAnim) == BOTH_KISSEE1LOOP)
+	{
+		stiffenedUp = qtrue;
+	}
+#endif
+
+	if (pm->ps->emplacedIndex)
+	{
+		if (pm->cmd.forwardmove < 0 || PM_GroundDistance() > 32.0f)
+		{
+			pm->ps->emplacedIndex = 0;
+			pm->ps->saberHolstered = 0;
+		}
+		else
+		{
+			stiffenedUp = qtrue;
+		}
+	}
+
+	/*
+	if (pm->ps->weapon == WP_DISRUPTOR && pm->ps->weaponstate == WEAPON_CHARGING_ALT)
+	{ //not allowed to move while charging the disruptor
+		pm->cmd.forwardmove = 0;
+		pm->cmd.rightmove = 0;
+		if (pm->cmd.upmove > 0)
+		{
+			pm->cmd.upmove = 0;
+		}
+	}
+	*/
+
+	if (pm->ps->weapon == WP_DISRUPTOR && pm->ps->weaponstate == WEAPON_CHARGING_ALT)
+	{ //not allowed to move while charging the disruptor
+		if (pm->cmd.forwardmove ||
+			pm->cmd.rightmove ||
+			pm->cmd.upmove > 0)
+		{ //get out
+			pm->ps->weaponstate = WEAPON_READY;
+			pm->ps->weaponTime = 1000;
+			PM_AddEventWithParm(EV_WEAPON_CHARGE, WP_DISRUPTOR); //cut the weapon charge sound
+			pm->cmd.upmove = 0;
+		}
+	}
+	else if (pm->ps->weapon == WP_DISRUPTOR && pm->ps->zoomMode == 1)
+	{ //can't jump
+		if (pm->cmd.upmove > 0)
+		{
+			pm->cmd.upmove = 0;
+		}
+	}
+
+	if (stiffenedUp)
+	{
+		pm->cmd.forwardmove = 0;
+		pm->cmd.rightmove = 0;
+		pm->cmd.upmove = 0;
+	}
+
+	if (pm->ps->fd.forceGripCripple)
+	{ //don't let attack or alt attack if being gripped I guess
+		pm->cmd.buttons &= ~BUTTON_ATTACK;
+		pm->cmd.buttons &= ~BUTTON_ALT_ATTACK;
+	}
+
+	if ( BG_InRoll( pm->ps, pm->ps->legsAnim ) )
+	{ //can't roll unless you're able to move normally
+		BG_CmdForRoll( pm->ps, pm->ps->legsAnim, &pm->cmd );
+	}
+
+	PM_CmdForSaberMoves(&pm->cmd);
+
+	BG_AdjustClientSpeed(pm->ps, &pm->cmd, pm->cmd.serverTime);
+
+	if ( pm->ps->stats[STAT_HEALTH] <= 0 ) {
+		pm->tracemask &= ~CONTENTS_BODY;	// corpses can fly through bodies
+	}
+
+	// make sure walking button is clear if they are running, to avoid
+	// proxy no-footsteps cheats
+	if ( abs( pm->cmd.forwardmove ) > 64 || abs( pm->cmd.rightmove ) > 64 ) {
+		pm->cmd.buttons &= ~BUTTON_WALKING;
+	}
+
+	// set the talk balloon flag
+	if ( pm->cmd.buttons & BUTTON_TALK ) {
+		pm->ps->eFlags |= EF_TALK;
+	} else {
+		pm->ps->eFlags &= ~EF_TALK;
+	}
+
+	pm_cancelOutZoom = qfalse;
+	if (pm->ps->weapon == WP_DISRUPTOR &&
+		pm->ps->zoomMode == 1)
+	{
+		if ((pm->cmd.buttons & BUTTON_ALT_ATTACK) &&
+			!(pm->cmd.buttons & BUTTON_ATTACK) &&
+			pm->ps->zoomLocked)
+		{
+			pm_cancelOutZoom = qtrue;
+		}
+	}
+	// In certain situations, we may want to control which attack buttons are pressed and what kind of functionality
+	//	is attached to them
+	PM_AdjustAttackStates( pm );
+
+	// clear the respawned flag if attack and use are cleared
+	if ( pm->ps->stats[STAT_HEALTH] > 0 && 
+		!( pm->cmd.buttons & (BUTTON_ATTACK | BUTTON_USE_HOLDABLE) ) ) {
+		pm->ps->pm_flags &= ~PMF_RESPAWNED;
+	}
+
+	// if talk button is down, dissallow all other input
+	// this is to prevent any possible intercept proxy from
+	// adding fake talk balloons
+	if ( pmove->cmd.buttons & BUTTON_TALK ) {
+		// keep the talk button set tho for when the cmd.serverTime > 66 msec
+		// and the same cmd is used multiple times in Pmove
+		pmove->cmd.buttons = BUTTON_TALK;
+		pmove->cmd.forwardmove = 0;
+		pmove->cmd.rightmove = 0;
+		pmove->cmd.upmove = 0;
+	}
+
+	// clear all pmove local vars
+	memset (&pml, 0, sizeof(pml));
+
+	// determine the time
+	pml.msec = pmove->cmd.serverTime - pm->ps->commandTime;
+	if ( pml.msec < 1 ) {
+		pml.msec = 1;
+	} else if ( pml.msec > 200 ) {
+		pml.msec = 200;
+	}
+
+	/*
+	if (pm->ps->clientNum >= MAX_CLIENTS)
+	{
+#ifdef QAGAME
+		Com_Printf( "^1 SERVER N%i msec %d\n", pm->ps->clientNum, pml.msec );
+#else
+		Com_Printf( "^2 CLIENT N%i msec %d\n", pm->ps->clientNum, pml.msec );
+#endif
+	}
+	*/
+
+	pm->ps->commandTime = pmove->cmd.serverTime;
+
+	// save old org in case we get stuck
+	VectorCopy (pm->ps->origin, pml.previous_origin);
+
+	// save old velocity for crashlanding
+	VectorCopy (pm->ps->velocity, pml.previous_velocity);
+
+	pml.frametime = pml.msec * 0.001;
+
+	if (pm->ps->clientNum >= MAX_CLIENTS &&
+		pm_entSelf &&
+		pm_entSelf->s.NPC_class == CLASS_VEHICLE)
+	{ //we are a vehicle
+		bgEntity_t *veh = pm_entSelf;
+		assert( veh && veh->m_pVehicle);
+		if ( veh && veh->m_pVehicle )
+		{
+			veh->m_pVehicle->m_fTimeModifier = pml.frametime*60.0f;
+		}
+	}
+	else if (pm_entSelf->s.NPC_class!=CLASS_VEHICLE
+		&&pm->ps->m_iVehicleNum)
+	{
+		bgEntity_t *veh = pm_entVeh;
+
+		if (veh && veh->playerState &&
+			(pm->cmd.serverTime-veh->playerState->hyperSpaceTime) < HYPERSPACE_TIME)
+		{ //going into hyperspace, turn to face the right angles
+            PM_VehFaceHyperspacePoint(veh);
+		}
+		else if (veh && veh->playerState &&
+			veh->playerState->vehTurnaroundIndex &&
+			veh->playerState->vehTurnaroundTime > pm->cmd.serverTime)
+		{ //riding this vehicle, turn my view too
+            PM_VehForcedTurning(veh);
+		}
+	}
+
+	if ( pm->ps->legsAnim == BOTH_FORCEWALLRUNFLIP_ALT &&
+		pm->ps->legsTimer > 0 )
+	{
+		vec3_t vFwd, fwdAng;
+		VectorSet(fwdAng, 0.0f, pm->ps->viewangles[YAW], 0.0f);
+
+		AngleVectors( fwdAng, vFwd, NULL, NULL );
+		if ( pm->ps->groundEntityNum == ENTITYNUM_NONE )
+		{
+			float savZ = pm->ps->velocity[2];
+			VectorScale( vFwd, 100, pm->ps->velocity );
+			pm->ps->velocity[2] = savZ;
+		}
+		pm->cmd.forwardmove = pm->cmd.rightmove = pm->cmd.upmove = 0;
+		PM_AdjustAnglesForWallRunUpFlipAlt( &pm->cmd );
+	}
+
+//	PM_AdjustAngleForWallRun(pm->ps, &pm->cmd, qtrue);
+//	PM_AdjustAnglesForStabDown( pm->ps, &pm->cmd );
+	PM_AdjustAngleForWallJump( pm->ps, &pm->cmd, qtrue );
+	PM_AdjustAngleForWallRunUp( pm->ps, &pm->cmd, qtrue );
+	PM_AdjustAngleForWallRun( pm->ps, &pm->cmd, qtrue );
+
+	if (pm->ps->saberMove == LS_A_JUMP_T__B_ || pm->ps->saberMove == LS_A_LUNGE ||
+		pm->ps->saberMove == LS_A_BACK_CR || pm->ps->saberMove == LS_A_BACK ||
+		pm->ps->saberMove == LS_A_BACKSTAB)
+	{
+		PM_SetPMViewAngle(pm->ps, pm->ps->viewangles, &pm->cmd);
+	}
+
+#if 0
+	if ((pm->ps->legsAnim) == BOTH_KISSER1LOOP ||
+		(pm->ps->legsAnim) == BOTH_KISSEE1LOOP)
+	{
+		pm->ps->viewangles[PITCH] = 0;
+		PM_SetPMViewAngle(pm->ps, pm->ps->viewangles, &pm->cmd);
+	}
+#endif
+
+	PM_SetSpecialMoveValues();
+
+	// update the viewangles
+	PM_UpdateViewAngles( pm->ps, &pm->cmd );
+
+	AngleVectors (pm->ps->viewangles, pml.forward, pml.right, pml.up);
+
+	if ( pm->cmd.upmove < 10 && !(pm->ps->pm_flags & PMF_STUCK_TO_WALL)) {
+		// not holding jump
+		pm->ps->pm_flags &= ~PMF_JUMP_HELD;
+	}
+
+	// decide if backpedaling animations should be used
+	if ( pm->cmd.forwardmove < 0 ) {
+		pm->ps->pm_flags |= PMF_BACKWARDS_RUN;
+	} else if ( pm->cmd.forwardmove > 0 || ( pm->cmd.forwardmove == 0 && pm->cmd.rightmove ) ) {
+		pm->ps->pm_flags &= ~PMF_BACKWARDS_RUN;
+	}
+
+	if ( pm->ps->pm_type >= PM_DEAD ) {
+		pm->cmd.forwardmove = 0;
+		pm->cmd.rightmove = 0;
+		pm->cmd.upmove = 0;
+	}
+
+	/*
+	if (pm->ps->fd.saberAnimLevel == SS_STAFF &&
+		(pm->cmd.buttons & BUTTON_ALT_ATTACK) &&
+		pm->cmd.upmove > 0)
+	{ //this is how you do kick-for-condition
+		pm->cmd.upmove = 0;
+		pm->ps->pm_flags |= PMF_JUMP_HELD;
+	}
+	*/
+
+	if (pm->ps->saberLockTime >= pm->cmd.serverTime)
+	{
+		pm->cmd.upmove = 0;
+		pm->cmd.forwardmove = 0;//50;
+		pm->cmd.rightmove = 0;//*= 0.1;
+	}
+
+	if ( pm->ps->pm_type == PM_SPECTATOR ) {
+		PM_CheckDuck ();
+		if (!pm->noSpecMove)
+		{
+			PM_FlyMove ();
+		}
+		PM_DropTimers ();
+		return;
+	}
+
+	if ( pm->ps->pm_type == PM_NOCLIP ) {
+		if (pm->ps->clientNum < MAX_CLIENTS)
+		{
+			PM_NoclipMove ();
+			PM_DropTimers ();
+			return;
+		}
+	}
+
+	if (pm->ps->pm_type == PM_FREEZE) {
+		return;		// no movement at all
+	}
+
+	if ( pm->ps->pm_type == PM_INTERMISSION || pm->ps->pm_type == PM_SPINTERMISSION) {
+		return;		// no movement at all
+	}
+
+	// set watertype, and waterlevel
+	PM_SetWaterLevel();
+	pml.previous_waterlevel = pmove->waterlevel;
+
+	// set mins, maxs, and viewheight
+	PM_CheckDuck ();
+
+	if (pm->ps->pm_type == PM_JETPACK)
+	{
+		gDist = PM_GroundDistance();
+		savedGravity = pm->ps->gravity;
+
+		if (gDist < JETPACK_HOVER_HEIGHT+64)
+		{
+			pm->ps->gravity *= 0.1f;
+		}
+		else
+		{
+			pm->ps->gravity *= 0.25f;
+		}
+	}
+	else if (gPMDoSlowFall)
+	{
+		savedGravity = pm->ps->gravity;
+		pm->ps->gravity *= 0.5;
+	}
+
+	//if we're in jetpack mode then see if we should be jetting around
+	if (pm->ps->pm_type == PM_JETPACK)
+	{
+		if (pm->cmd.rightmove > 0)
+		{
+			PM_ContinueLegsAnim(BOTH_INAIRRIGHT1);
+		}
+		else if (pm->cmd.rightmove < 0)
+		{
+            PM_ContinueLegsAnim(BOTH_INAIRLEFT1);
+		}
+		else if (pm->cmd.forwardmove > 0)
+		{
+			PM_ContinueLegsAnim(BOTH_INAIR1);
+		}
+		else if (pm->cmd.forwardmove < 0)
+		{
+			PM_ContinueLegsAnim(BOTH_INAIRBACK1);
+		}
+		else
+		{
+			PM_ContinueLegsAnim(BOTH_INAIR1);
+		}
+
+		if (pm->ps->weapon == WP_SABER &&
+			BG_SpinningSaberAnim( pm->ps->legsAnim ))
+		{ //make him stir around since he shouldn't have any real control when spinning
+			pm->ps->velocity[0] += Q_irand(-100, 100);
+			pm->ps->velocity[1] += Q_irand(-100, 100);
+		}
+
+		if (pm->cmd.upmove > 0 && pm->ps->velocity[2] < 256)
+		{ //cap upward velocity off at 256. Seems reasonable.
+			float addIn = 12.0f;
+
+/*
+			//Add based on our distance to the ground if we're already travelling upward
+			if (pm->ps->velocity[2] > 0)
+			{
+				while (gDist > 64)
+				{ //subtract 1 for every 64 units off the ground we get
+					addIn--;
+
+					gDist -= 64;
+
+					if (addIn <= 0)
+					{ //break out if we're not even going to add anything
+						break;
+					}
+				}
+			}
+*/			
+			if (pm->ps->velocity[2] > 0)
+			{
+				addIn = 12.0f - (gDist / 64.0f);
+			}
+
+			if (addIn > 0.0f)
+			{
+				pm->ps->velocity[2] += addIn;
+			}
+
+			pm->ps->eFlags |= EF_JETPACK_FLAMING; //going up
+		}
+		else
+		{
+			pm->ps->eFlags &= ~EF_JETPACK_FLAMING; //idling
+
+			if (pm->ps->velocity[2] < 256)
+			{
+				if (pm->ps->velocity[2] < -100)
+				{
+					pm->ps->velocity[2] = -100;
+				}
+				if (gDist < JETPACK_HOVER_HEIGHT)
+				{ //make sure we're always hovering off the ground somewhat while jetpack is active
+					pm->ps->velocity[2] += 2;
+				}
+			}
+		}
+	}
+
+	if (pm->ps->clientNum >= MAX_CLIENTS &&
+		pm_entSelf && pm_entSelf->m_pVehicle)
+	{ //Now update our mins/maxs to match our m_vOrientation based on our length, width & height
+		BG_VehicleAdjustBBoxForOrientation( pm_entSelf->m_pVehicle, pm->ps->origin, pm->mins, pm->maxs, pm->ps->clientNum, pm->tracemask, pm->trace );
+	}
+
+	// set groundentity
+	PM_GroundTrace();
+	if ( pm_flying == FLY_HOVER )
+	{//never stick to the ground
+		PM_HoverTrace();
+	}
+
+	if ( pm->ps->groundEntityNum != ENTITYNUM_NONE )
+	{//on ground
+		pm->ps->fd.forceJumpZStart = 0;
+	}
+
+	if ( pm->ps->pm_type == PM_DEAD ) {
+		if (pm->ps->clientNum >= MAX_CLIENTS &&
+			pm_entSelf &&
+			pm_entSelf->s.NPC_class == CLASS_VEHICLE &&
+			pm_entSelf->m_pVehicle->m_pVehicleInfo->type != VH_ANIMAL)
+		{//vehicles don't use deadmove
+		}
+		else
+		{
+			PM_DeadMove ();
+		}
+	}
+
+	PM_DropTimers();
+
+#ifdef _TESTING_VEH_PREDICTION
+#ifndef QAGAME
+	{
+		vec3_t blah;
+		VectorMA(pm->ps->origin, 128.0f, pm->ps->moveDir, blah);
+		CG_TestLine(pm->ps->origin, blah, 1, 0x0000ff, 1);
+
+		VectorMA(pm->ps->origin, 1.0f, pm->ps->velocity, blah);
+		CG_TestLine(pm->ps->origin, blah, 1, 0xff0000, 1);
+	}
+#endif
+#endif
+
+	if (pm_entSelf->s.NPC_class!=CLASS_VEHICLE
+		&&pm->ps->m_iVehicleNum)
+	{ //a player riding a vehicle
+		bgEntity_t *veh = pm_entVeh;
+
+		if ( veh && veh->m_pVehicle &&
+			(veh->m_pVehicle->m_pVehicleInfo->type == VH_WALKER || veh->m_pVehicle->m_pVehicleInfo->type == VH_FIGHTER) )
+		{//*sigh*, until we get forced weapon-switching working?
+			pm->cmd.buttons &= ~(BUTTON_ATTACK|BUTTON_ALT_ATTACK);
+			pm->ps->eFlags &= ~(EF_FIRING|EF_ALT_FIRING);
+			//pm->cmd.weapon = pm->ps->weapon;
+		}
+	}
+
+	if (!pm->ps->m_iVehicleNum &&
+		pm_entSelf->s.NPC_class!=CLASS_VEHICLE&&
+		pm_entSelf->s.NPC_class!=CLASS_RANCOR&&
+		pm->ps->groundEntityNum < ENTITYNUM_WORLD &&
+		pm->ps->groundEntityNum >= MAX_CLIENTS)
+	{ //I am a player client, not riding on a vehicle, and potentially standing on an NPC
+		bgEntity_t *pEnt = PM_BGEntForNum(pm->ps->groundEntityNum);
+
+		if (pEnt && pEnt->s.eType == ET_NPC &&
+			pEnt->s.NPC_class != CLASS_VEHICLE) //don't bounce on vehicles
+		{ //this is actually an NPC, let's try to bounce of its head to make sure we can't just stand around on top of it.
+			if (pm->ps->velocity[2] < 270)
+			{ //try forcing velocity up and also force him to jump
+				pm->ps->velocity[2] = 270; //seems reasonable
+				pm->cmd.upmove = 127;
+			}
+		}
+#ifdef QAGAME
+		else if ( !pm->ps->zoomMode &&
+			pm_entSelf //I exist
+			&& pEnt->m_pVehicle )//ent has a vehicle
+		{
+			gentity_t *gEnt = (gentity_t*)pEnt;
+			if ( gEnt->client
+				&& !gEnt->client->ps.m_iVehicleNum //vehicle is empty
+				&& (gEnt->spawnflags&2) )//SUSPENDED
+			{//it's a vehicle, see if we should get in it
+				//if land on an empty, suspended vehicle, get in it
+				pEnt->m_pVehicle->m_pVehicleInfo->Board( pEnt->m_pVehicle, (bgEntity_t *)pm_entSelf );
+			}
+		}
+#endif
+	}
+
+	if (pm->ps->clientNum >= MAX_CLIENTS &&
+		pm_entSelf &&
+		pm_entSelf->s.NPC_class == CLASS_VEHICLE)
+	{ //we are a vehicle
+		bgEntity_t *veh = pm_entSelf;
+
+		assert(veh && veh->playerState && veh->m_pVehicle && veh->s.number >= MAX_CLIENTS);
+
+		if (veh->m_pVehicle->m_pVehicleInfo->type != VH_FIGHTER)
+		{ //kind of hacky, don't want to do this for flying vehicles
+			veh->m_pVehicle->m_vOrientation[PITCH] = pm->ps->viewangles[PITCH];
+		}
+
+		if (!pm->ps->m_iVehicleNum)
+		{ //no one is driving, just update and get out
+#ifdef QAGAME
+			veh->m_pVehicle->m_pVehicleInfo->Update(veh->m_pVehicle, &pm->cmd);
+		    veh->m_pVehicle->m_pVehicleInfo->Animate(veh->m_pVehicle);
+#endif
+		}
+		else
+		{
+			bgEntity_t *self = pm_entVeh;
+#ifdef QAGAME
+			int i = 0;
+#endif
+
+			assert(self && self->playerState && self->s.number < MAX_CLIENTS);
+
+			if (pm->ps->pm_type == PM_DEAD &&
+				(veh->m_pVehicle->m_ulFlags & VEH_CRASHING))
+			{
+				veh->m_pVehicle->m_ulFlags &= ~VEH_CRASHING;
+			}
+
+			if (self->playerState->m_iVehicleNum)
+			{ //only do it if they still have a vehicle (didn't get ejected this update or something)
+				PM_VehicleViewAngles(self->playerState, veh, &veh->m_pVehicle->m_ucmd);
+			}
+
+#ifdef QAGAME
+			veh->m_pVehicle->m_pVehicleInfo->Update(veh->m_pVehicle, &veh->m_pVehicle->m_ucmd);
+			veh->m_pVehicle->m_pVehicleInfo->Animate(veh->m_pVehicle);
+
+			veh->m_pVehicle->m_pVehicleInfo->UpdateRider(veh->m_pVehicle, self, &veh->m_pVehicle->m_ucmd);
+			//update the passengers
+			while (i < veh->m_pVehicle->m_iNumPassengers)
+			{
+				if (veh->m_pVehicle->m_ppPassengers[i])
+				{
+					gentity_t *thePassenger = (gentity_t *)veh->m_pVehicle->m_ppPassengers[i]; //yes, this is, in fact, ass.
+					if (thePassenger->inuse && thePassenger->client)
+					{
+						veh->m_pVehicle->m_pVehicleInfo->UpdateRider(veh->m_pVehicle, veh->m_pVehicle->m_ppPassengers[i], &thePassenger->client->pers.cmd);
+					}
+				}
+				i++;
+			}
+#else
+			if (!veh->playerState->vehBoarding )//|| veh->m_pVehicle->m_pVehicleInfo->type == VH_FIGHTER)
+			{
+				if (veh->m_pVehicle->m_pVehicleInfo->type == VH_FIGHTER)
+				{ //client must explicitly call this for prediction
+					BG_FighterUpdate(veh->m_pVehicle, &veh->m_pVehicle->m_ucmd, pm->mins, pm->maxs, self->playerState->gravity, pm->trace);
+				}
+
+				if (veh->m_pVehicle->m_iBoarding == 0)
+				{
+					vec3_t vRollAng;
+
+					//make sure we are set as its pilot cgame side
+					veh->m_pVehicle->m_pPilot = self;
+
+					// Keep track of the old orientation.
+					VectorCopy( veh->m_pVehicle->m_vOrientation, veh->m_pVehicle->m_vPrevOrientation );
+
+					veh->m_pVehicle->m_pVehicleInfo->ProcessOrientCommands(veh->m_pVehicle);
+					PM_SetPMViewAngle(veh->playerState, veh->m_pVehicle->m_vOrientation, &veh->m_pVehicle->m_ucmd);
+					veh->m_pVehicle->m_pVehicleInfo->ProcessMoveCommands(veh->m_pVehicle);
+
+					vRollAng[YAW] = self->playerState->viewangles[YAW];
+					vRollAng[PITCH] = self->playerState->viewangles[PITCH];
+					vRollAng[ROLL] = veh->m_pVehicle->m_vOrientation[ROLL];
+					PM_SetPMViewAngle(self->playerState, vRollAng, &pm->cmd);
+
+					// Setup the move direction.
+					if ( veh->m_pVehicle->m_pVehicleInfo->type == VH_FIGHTER )
+					{
+						AngleVectors( veh->m_pVehicle->m_vOrientation, veh->playerState->moveDir, NULL, NULL ); 
+					}
+					else
+					{
+						vec3_t vVehAngles;
+
+						VectorSet(vVehAngles, 0, veh->m_pVehicle->m_vOrientation[YAW], 0);
+						AngleVectors( vVehAngles, veh->playerState->moveDir, NULL, NULL ); 
+					}
+				}
+			}
+			/*
+			else
+			{
+				veh->playerState->speed = 0.0f;
+				PM_SetPMViewAngle(self->playerState, veh->playerState->viewangles, &veh->m_pVehicle->m_ucmd);
+			}
+			*/
+			else if (veh->playerState)
+			{
+				veh->playerState->speed = 0.0f;
+				if (veh->m_pVehicle)
+				{
+					PM_SetPMViewAngle(self->playerState, veh->m_pVehicle->m_vOrientation, &pm->cmd);
+					PM_SetPMViewAngle(veh->playerState, veh->m_pVehicle->m_vOrientation, &pm->cmd);
+				}
+			}
+#endif
+		}
+		noAnimate = qtrue;
+	}
+
+	if (pm_entSelf->s.NPC_class!=CLASS_VEHICLE
+		&&pm->ps->m_iVehicleNum)
+	{//don't even run physics on a player if he's on a vehicle - he goes where the vehicle goes
+	}
+	else
+	{ //don't even run physics on a player if he's on a vehicle - he goes where the vehicle goes
+		if (pm->ps->pm_type == PM_FLOAT
+			||pm_flying == FLY_NORMAL)
+		{
+			PM_FlyMove ();
+		}
+		else if ( pm_flying == FLY_VEHICLE )
+		{
+			PM_FlyVehicleMove();
+		}
+		else
+		{
+			if (pm->ps->pm_flags & PMF_TIME_WATERJUMP) {
+				PM_WaterJumpMove();
+			} else if ( pm->waterlevel > 1 ) {
+				// swimming
+				PM_WaterMove();
+			} else if ( pml.walking ) {
+				// walking on ground
+				PM_WalkMove();
+			} else {
+				// airborne
+				PM_AirMove();
+			}
+		}
+	}
+
+	if (!noAnimate)
+	{
+		PM_Animate();
+	}
+
+	// set groundentity, watertype, and waterlevel
+	PM_GroundTrace();
+	if ( pm_flying == FLY_HOVER )
+	{//never stick to the ground
+		PM_HoverTrace();
+	}
+	PM_SetWaterLevel();
+	if (pm->cmd.forcesel != -1 && (pm->ps->fd.forcePowersKnown & (1 << pm->cmd.forcesel)))
+	{
+		pm->ps->fd.forcePowerSelected = pm->cmd.forcesel;
+	}
+	if (pm->cmd.invensel != -1 && (pm->ps->stats[STAT_HOLDABLE_ITEMS] & (1 << pm->cmd.invensel)))
+	{
+		pm->ps->stats[STAT_HOLDABLE_ITEM] = BG_GetItemIndexByTag(pm->cmd.invensel, IT_HOLDABLE);
+	}
+
+	if (pm->ps->m_iVehicleNum 
+		/*&&pm_entSelf->s.NPC_class!=CLASS_VEHICLE*/
+		&& pm->ps->clientNum < MAX_CLIENTS)
+	{//a client riding a vehicle
+		if ( (pm->ps->eFlags&EF_NODRAW) )
+		{//inside the vehicle, do nothing
+		}
+		else if (!PM_WeaponOkOnVehicle(pm->cmd.weapon) || !PM_WeaponOkOnVehicle(pm->ps->weapon))
+		{ //this weapon is not legal for the vehicle, force to our current one
+            if (!PM_WeaponOkOnVehicle(pm->ps->weapon))
+			{ //uh-oh!
+				int weap = PM_GetOkWeaponForVehicle();
+
+				if (weap != -1)
+				{
+					pm->cmd.weapon = weap;
+					pm->ps->weapon = weap;
+				}
+			}
+			else
+			{
+				pm->cmd.weapon = pm->ps->weapon;
+			}
+		}
+	}
+
+	if (!pm->ps->m_iVehicleNum //not a vehicle and not riding one
+		|| pm_entSelf->s.NPC_class==CLASS_VEHICLE //you are a vehicle NPC
+		|| (!(pm->ps->eFlags&EF_NODRAW)&&PM_WeaponOkOnVehicle(pm->cmd.weapon)) )//you're not inside the vehicle and the weapon you're holding can be used when riding this vehicle
+	{ //only run weapons if a valid weapon is selected
+		// weapons
+		PM_Weapon();
+	}
+
+	PM_Use();
+
+	if (!pm->ps->m_iVehicleNum &&
+		(pm->ps->clientNum < MAX_CLIENTS ||
+		!pm_entSelf ||
+		pm_entSelf->s.NPC_class != CLASS_VEHICLE))
+	{ //don't do this if we're on a vehicle, or we are one
+		// footstep events / legs animations
+		PM_Footsteps();
+	}
+
+	// entering / leaving water splashes
+	PM_WaterEvents();
+
+	// snap some parts of playerstate to save network bandwidth
+	trap_SnapVector( pm->ps->velocity );
+
+ 	if (pm->ps->pm_type == PM_JETPACK || gPMDoSlowFall )
+	{
+		pm->ps->gravity = savedGravity;
+	}
+
+	if (//pm->ps->m_iVehicleNum &&
+		pm->ps->clientNum >= MAX_CLIENTS &&
+		pm_entSelf &&
+		pm_entSelf->s.NPC_class == CLASS_VEHICLE)
+	{ //a vehicle with passengers
+		bgEntity_t *veh;
+		
+		veh = pm_entSelf;
+
+		assert(veh->m_pVehicle);
+
+		//this could be kind of "inefficient" because it's called after every passenger pmove too.
+		//Maybe instead of AttachRiders we should have each rider call attach for himself?
+		if (veh->m_pVehicle && veh->ghoul2)
+		{
+			veh->m_pVehicle->m_pVehicleInfo->AttachRiders( veh->m_pVehicle );
+		}
+	}
+
+	if (pm_entSelf->s.NPC_class!=CLASS_VEHICLE
+		&& pm->ps->m_iVehicleNum)
+	{ //riding a vehicle, see if we should do some anim overrides
+		PM_VehicleWeaponAnimate();
+	}
+}
+
+
+/*
+================
+Pmove
+
+Can be called by either the server or the client
+================
+*/
+void Pmove (pmove_t *pmove) {
+	int			finalTime;
+
+	finalTime = pmove->cmd.serverTime;
+
+	if ( finalTime < pmove->ps->commandTime ) {
+		return;	// should not happen
+	}
+
+	if ( finalTime > pmove->ps->commandTime + 1000 ) {
+		pmove->ps->commandTime = finalTime - 1000;
+	}
+
+	if (pmove->ps->fallingToDeath)
+	{
+		pmove->cmd.forwardmove = 0;
+		pmove->cmd.rightmove = 0;
+		pmove->cmd.upmove = 0;
+		pmove->cmd.buttons = 0;
+	}
+
+	pmove->ps->pmove_framecount = (pmove->ps->pmove_framecount+1) & ((1<<PS_PMOVEFRAMECOUNTBITS)-1);
+
+	// chop the move up if it is too long, to prevent framerate
+	// dependent behavior
+	while ( pmove->ps->commandTime != finalTime ) {
+		int		msec;
+
+		msec = finalTime - pmove->ps->commandTime;
+
+		if ( pmove->pmove_fixed ) {
+			if ( msec > pmove->pmove_msec ) {
+				msec = pmove->pmove_msec;
+			}
+		}
+		else {
+			if ( msec > 66 ) {
+				msec = 66;
+			}
+		}
+		pmove->cmd.serverTime = pmove->ps->commandTime + msec;
+		
+		PmoveSingle( pmove );
+		
+		if ( pmove->ps->pm_flags & PMF_JUMP_HELD ) {
+			pmove->cmd.upmove = 20;
+		}
+	}
+}
+
+#include "../namespace_end.h"
diff --git a/codemp/game/bg_public.h b/codemp/game/bg_public.h
new file mode 100644
index 0000000..af6a4cb
--- /dev/null
+++ b/codemp/game/bg_public.h
@@ -0,0 +1,1670 @@
+// Copyright (C) 1999-2000 Id Software, Inc.
+//
+// bg_public.h -- definitions shared by both the server game and client game modules
+
+// because games can change separately from the main system version, we need a
+// second version that must match between game and cgame
+
+#ifndef __BG_PUBLIC_H__
+#define __BG_PUBLIC_H__
+
+#include "bg_weapons.h"
+#include "anims.h"
+#include "bg_vehicles.h"
+
+//these two defs are shared now because we do clientside ent parsing
+#define	MAX_SPAWN_VARS			64
+#define	MAX_SPAWN_VARS_CHARS	4096
+
+
+#define	GAME_VERSION		"basejk-1"
+
+#define	STEPSIZE		18
+
+#define	DEFAULT_GRAVITY		800
+#define	GIB_HEALTH			-40
+#define ARMOR_PROTECTION		0.50 // Shields only stop 50% of armor-piercing dmg
+#define ARMOR_REDUCTION_FACTOR	0.50 // Certain damage doesn't take off armor as efficiently
+
+#define	JUMP_VELOCITY		225//270
+
+#define	MAX_ITEMS			256
+
+#define	RANK_TIED_FLAG		0x4000
+
+#define	ITEM_RADIUS			15		// item sizes are needed for client side pickup detection
+
+#define	SCORE_NOT_PRESENT	-9999	// for the CS_SCORES[12] when only one player is present
+
+#define	VOTE_TIME			30000	// 30 seconds before vote times out
+
+#define DEFAULT_MINS_2		-24
+#define DEFAULT_MAXS_2		40
+#define CROUCH_MAXS_2		16
+#define	STANDARD_VIEWHEIGHT_OFFSET -4
+
+#define	MINS_Z				-24
+#define	DEFAULT_VIEWHEIGHT	(DEFAULT_MAXS_2+STANDARD_VIEWHEIGHT_OFFSET)//26
+#define CROUCH_VIEWHEIGHT	(CROUCH_MAXS_2+STANDARD_VIEWHEIGHT_OFFSET)//12
+#define	DEAD_VIEWHEIGHT		-16
+
+#define MAX_CLIENT_SCORE_SEND 20
+
+//
+// config strings are a general means of communicating variable length strings
+// from the server to all connected clients.
+//
+
+// CS_SERVERINFO and CS_SYSTEMINFO are defined in q_shared.h
+#define	CS_MUSIC				2
+#define	CS_MESSAGE				3		// from the map worldspawn's message field
+#define	CS_MOTD					4		// g_motd string for server message of the day
+#define	CS_WARMUP				5		// server time when the match will be restarted
+#define	CS_SCORES1				6
+#define	CS_SCORES2				7
+#define CS_VOTE_TIME			8
+#define CS_VOTE_STRING			9
+#define	CS_VOTE_YES				10
+#define	CS_VOTE_NO				11
+
+#define CS_TEAMVOTE_TIME		12
+#define CS_TEAMVOTE_STRING		14
+#define	CS_TEAMVOTE_YES			16
+#define	CS_TEAMVOTE_NO			18
+
+#define	CS_GAME_VERSION			20
+#define	CS_LEVEL_START_TIME		21		// so the timer only shows the current level
+#define	CS_INTERMISSION			22		// when 1, fraglimit/timelimit has been hit and intermission will start in a second or two
+#define CS_FLAGSTATUS			23		// string indicating flag status in CTF
+#define CS_SHADERSTATE			24
+#define CS_BOTINFO				25
+
+#define	CS_ITEMS				27		// string of 0's and 1's that tell which items are present
+
+#define CS_CLIENT_JEDIMASTER	28		// current jedi master
+#define CS_CLIENT_DUELWINNER	29		// current duel round winner - needed for printing at top of scoreboard
+#define CS_CLIENT_DUELISTS		30		// client numbers for both current duelists. Needed for a number of client-side things.
+#define CS_CLIENT_DUELHEALTHS	31		// nmckenzie: DUEL_HEALTH.  Hopefully adding this cs is safe and good?
+#define CS_GLOBAL_AMBIENT_SET	32
+
+#define CS_AMBIENT_SET			37
+
+#define CS_SIEGE_STATE			(CS_AMBIENT_SET+MAX_AMBIENT_SETS)
+#define CS_SIEGE_OBJECTIVES		(CS_SIEGE_STATE+1)
+#define CS_SIEGE_TIMEOVERRIDE	(CS_SIEGE_OBJECTIVES+1)
+#define CS_SIEGE_WINTEAM		(CS_SIEGE_TIMEOVERRIDE+1)
+#define CS_SIEGE_ICONS			(CS_SIEGE_WINTEAM+1)
+
+#define	CS_MODELS				(CS_SIEGE_ICONS+1)
+#define	CS_SKYBOXORG			(CS_MODELS+MAX_MODELS)		//rww - skybox info
+#define	CS_SOUNDS				(CS_SKYBOXORG+1)
+#define CS_ICONS				(CS_SOUNDS+MAX_SOUNDS)
+#define	CS_PLAYERS				(CS_ICONS+MAX_ICONS)
+/*
+Ghoul2 Insert Start
+*/
+#define CS_G2BONES				(CS_PLAYERS+MAX_CLIENTS)
+//rww - used to be CS_CHARSKINS, but I have eliminated the need for that.
+/*
+Ghoul2 Insert End
+*/
+#define CS_LOCATIONS			(CS_G2BONES+MAX_G2BONES)
+#define CS_PARTICLES			(CS_LOCATIONS+MAX_LOCATIONS) 
+#define CS_EFFECTS				(CS_PARTICLES+MAX_LOCATIONS)
+#define	CS_LIGHT_STYLES			(CS_EFFECTS + MAX_FX)
+
+//rwwRMG - added:
+#define CS_TERRAINS				(CS_LIGHT_STYLES + (MAX_LIGHT_STYLES*3))
+#define CS_BSP_MODELS			(CS_TERRAINS + MAX_TERRAINS)
+
+#define CS_MAX					(CS_BSP_MODELS + MAX_SUB_BSP)
+
+#if (CS_MAX) > MAX_CONFIGSTRINGS
+#error overflow: (CS_MAX) > MAX_CONFIGSTRINGS
+#endif
+
+typedef enum {
+	G2_MODELPART_HEAD = 10,
+	G2_MODELPART_WAIST,
+	G2_MODELPART_LARM,
+	G2_MODELPART_RARM,
+	G2_MODELPART_RHAND,
+	G2_MODELPART_LLEG,
+	G2_MODELPART_RLEG
+} g2ModelParts_t;
+
+#define G2_MODEL_PART	50
+
+#define BG_NUM_TOGGLEABLE_SURFACES 31
+
+#define MAX_CUSTOM_SIEGE_SOUNDS 30
+
+#include "../namespace_begin.h"
+extern const char *bg_customSiegeSoundNames[MAX_CUSTOM_SIEGE_SOUNDS];
+
+extern const char *bgToggleableSurfaces[BG_NUM_TOGGLEABLE_SURFACES];
+extern const int bgToggleableSurfaceDebris[BG_NUM_TOGGLEABLE_SURFACES];
+#include "../namespace_end.h"
+
+typedef enum {
+	HANDEXTEND_NONE = 0,
+	HANDEXTEND_FORCEPUSH,
+	HANDEXTEND_FORCEPULL,
+	HANDEXTEND_FORCE_HOLD,
+	HANDEXTEND_SABERPULL,
+	HANDEXTEND_CHOKE, //use handextend priorities to choke someone being gripped
+	HANDEXTEND_WEAPONREADY,
+	HANDEXTEND_DODGE,
+	HANDEXTEND_KNOCKDOWN,
+	HANDEXTEND_DUELCHALLENGE,
+	HANDEXTEND_TAUNT,
+
+	HANDEXTEND_PRETHROW,
+	HANDEXTEND_POSTTHROW,
+	HANDEXTEND_PRETHROWN,
+	HANDEXTEND_POSTTHROWN,
+
+	HANDEXTEND_DRAGGING,
+
+	HANDEXTEND_JEDITAUNT,
+} forceHandAnims_t;
+
+typedef enum
+{
+	BROKENLIMB_NONE = 0,
+	BROKENLIMB_LARM,
+	BROKENLIMB_RARM,
+	NUM_BROKENLIMBS
+} brokenLimb_t;
+
+//for supplier class items
+#define TOSS_DEBOUNCE_TIME				5000
+
+typedef enum {
+	GT_FFA,				// free for all
+	GT_HOLOCRON,		// holocron ffa
+	GT_JEDIMASTER,		// jedi master
+	GT_DUEL,		// one on one tournament
+	GT_POWERDUEL,
+	GT_SINGLE_PLAYER,	// single player ffa
+
+	//-- team games go after this --
+
+	GT_TEAM,			// team deathmatch
+	GT_SIEGE,			// siege
+	GT_CTF,				// capture the flag
+	GT_CTY,
+	GT_MAX_GAME_TYPE
+};
+typedef int gametype_t;
+
+typedef enum { GENDER_MALE, GENDER_FEMALE, GENDER_NEUTER } gender_t;
+
+extern vec3_t WP_MuzzlePoint[WP_NUM_WEAPONS];
+
+#include "../namespace_begin.h"
+extern int forcePowerSorted[NUM_FORCE_POWERS];
+#include "../namespace_end.h"
+
+typedef enum
+{
+	SABERLOCK_TOP,
+	SABERLOCK_SIDE,
+	SABERLOCK_LOCK,
+	SABERLOCK_BREAK,
+	SABERLOCK_SUPERBREAK,
+	SABERLOCK_WIN,
+	SABERLOCK_LOSE
+};
+
+typedef enum
+{
+	DIR_RIGHT,
+	DIR_LEFT,
+	DIR_FRONT,
+	DIR_BACK
+};
+
+/*
+===================================================================================
+
+PMOVE MODULE
+
+The pmove code takes a player_state_t and a usercmd_t and generates a new player_state_t
+and some other output data.  Used for local prediction on the client game and true
+movement on the server game.
+===================================================================================
+*/
+
+
+#pragma pack(push, 1)
+typedef struct animation_s {
+	unsigned short		firstFrame;
+	unsigned short		numFrames;
+	short				frameLerp;			// msec between frames
+	//initialLerp is abs(frameLerp)
+	signed char			loopFrames;			// 0 to numFrames
+} animation_t;
+#pragma pack(pop)
+
+#include "../namespace_begin.h"
+extern qboolean			BGPAFtextLoaded;
+extern animation_t		bgHumanoidAnimations[MAX_TOTALANIMATIONS];
+#include "../namespace_end.h"
+
+#define MAX_ANIM_FILES	16
+#define MAX_ANIM_EVENTS 300
+
+typedef enum
+{
+	FOOTSTEP_R,
+	FOOTSTEP_L,
+	FOOTSTEP_HEAVY_R,
+	FOOTSTEP_HEAVY_L,
+	NUM_FOOTSTEP_TYPES
+} footstepType_t;
+
+extern stringID_table_t animEventTypeTable[MAX_ANIM_EVENTS+1];
+extern stringID_table_t footstepTypeTable[NUM_FOOTSTEP_TYPES+1];
+
+//size of Anim eventData array...
+#define MAX_RANDOM_ANIM_SOUNDS		4
+#define	AED_ARRAY_SIZE				(MAX_RANDOM_ANIM_SOUNDS+3)
+//indices for AEV_SOUND data
+#define	AED_SOUNDINDEX_START		0
+#define	AED_SOUNDINDEX_END			(MAX_RANDOM_ANIM_SOUNDS-1)
+#define	AED_SOUND_NUMRANDOMSNDS		(MAX_RANDOM_ANIM_SOUNDS)
+#define	AED_SOUND_PROBABILITY		(MAX_RANDOM_ANIM_SOUNDS+1)
+//indices for AEV_SOUNDCHAN data
+#define	AED_SOUNDCHANNEL			(MAX_RANDOM_ANIM_SOUNDS+2)
+//indices for AEV_FOOTSTEP data
+#define	AED_FOOTSTEP_TYPE			0
+#define	AED_FOOTSTEP_PROBABILITY	1
+//indices for AEV_EFFECT data
+#define	AED_EFFECTINDEX				0
+#define	AED_BOLTINDEX				1
+#define	AED_EFFECT_PROBABILITY		2
+#define	AED_MODELINDEX				3
+//indices for AEV_FIRE data
+#define	AED_FIRE_ALT				0
+#define	AED_FIRE_PROBABILITY		1
+//indices for AEV_MOVE data
+#define	AED_MOVE_FWD				0
+#define	AED_MOVE_RT					1
+#define	AED_MOVE_UP					2
+
+typedef enum
+{//NOTENOTE:  Be sure to update animEventTypeTable and ParseAnimationEvtBlock(...) if you change this enum list!
+	AEV_NONE,
+	AEV_SOUND,		//# animID AEV_SOUND framenum soundpath randomlow randomhi chancetoplay
+	AEV_FOOTSTEP,	//# animID AEV_FOOTSTEP framenum footstepType chancetoplay
+	AEV_EFFECT,		//# animID AEV_EFFECT framenum effectpath boltName chancetoplay
+	AEV_FIRE,		//# animID AEV_FIRE framenum altfire chancetofire
+	AEV_MOVE,		//# animID AEV_MOVE framenum forwardpush rightpush uppush
+	AEV_SOUNDCHAN,  //# animID AEV_SOUNDCHAN framenum CHANNEL soundpath randomlow randomhi chancetoplay 
+	AEV_NUM_AEV
+} animEventType_t;
+
+typedef struct animevent_s 
+{
+	animEventType_t	eventType;
+	unsigned short	keyFrame;			//Frame to play event on
+	signed short	eventData[AED_ARRAY_SIZE];	//Unique IDs, can be soundIndex of sound file to play OR effect index or footstep type, etc.
+	char			*stringData;		//we allow storage of one string, temporarily (in case we have to look up an index later, then make sure to set stringData to NULL so we only do the look-up once)
+} animevent_t;
+
+typedef struct
+{
+	char			filename[MAX_QPATH];
+	animation_t		*anims;
+//	animsounds_t	torsoAnimSnds[MAX_ANIM_SOUNDS];
+//	animsounds_t	legsAnimSnds[MAX_ANIM_SOUNDS];
+//	qboolean		soundsCached;
+} bgLoadedAnim_t;
+
+typedef struct
+{
+	char			filename[MAX_QPATH];
+	animevent_t		torsoAnimEvents[MAX_ANIM_EVENTS];
+	animevent_t		legsAnimEvents[MAX_ANIM_EVENTS];
+	qboolean		eventsParsed;
+} bgLoadedEvents_t;
+
+#include "../namespace_begin.h"
+
+extern bgLoadedAnim_t bgAllAnims[MAX_ANIM_FILES];
+
+//In SP this is shared in with the anim stuff, and humanoid anim sets can be loaded
+//multiple times just for the sake of sounds being different. We probably wouldn't
+//care normally but since we're working in VMs we have to do everything possible to
+//cut memory cost.
+//On the bright side this also means we're cutting a rather large size out of
+//required game-side memory.
+#ifndef QAGAME
+extern bgLoadedEvents_t bgAllEvents[MAX_ANIM_FILES];
+extern int bgNumAnimEvents;
+#endif
+
+#include "../namespace_end.h"
+
+typedef enum {
+	PM_NORMAL,		// can accelerate and turn
+	PM_JETPACK,		// special jetpack movement
+	PM_FLOAT,		// float with no gravity in general direction of velocity (intended for gripping)
+	PM_NOCLIP,		// noclip movement
+	PM_SPECTATOR,	// still run into walls
+	PM_DEAD,		// no acceleration or turning, but free falling
+	PM_FREEZE,		// stuck in place with no control
+	PM_INTERMISSION,	// no movement or status bar
+	PM_SPINTERMISSION	// no movement or status bar
+} pmtype_t;
+
+typedef enum {
+	WEAPON_READY, 
+	WEAPON_RAISING,
+	WEAPON_DROPPING,
+	WEAPON_FIRING,
+	WEAPON_CHARGING,
+	WEAPON_CHARGING_ALT,
+	WEAPON_IDLE, //lowered		// NOTENOTE Added with saber
+} weaponstate_t;
+
+
+typedef enum {
+	FORCE_MASTERY_UNINITIATED,
+	FORCE_MASTERY_INITIATE,
+	FORCE_MASTERY_PADAWAN,
+	FORCE_MASTERY_JEDI,
+	FORCE_MASTERY_JEDI_GUARDIAN,
+	FORCE_MASTERY_JEDI_ADEPT,
+	FORCE_MASTERY_JEDI_KNIGHT,
+	FORCE_MASTERY_JEDI_MASTER,
+	NUM_FORCE_MASTERY_LEVELS
+};
+
+#include "../namespace_begin.h"
+extern char *forceMasteryLevels[NUM_FORCE_MASTERY_LEVELS];
+extern int forceMasteryPoints[NUM_FORCE_MASTERY_LEVELS];
+
+extern int bgForcePowerCost[NUM_FORCE_POWERS][NUM_FORCE_POWER_LEVELS];
+#include "../namespace_end.h"
+
+// pmove->pm_flags
+#define	PMF_DUCKED			1
+#define	PMF_JUMP_HELD		2
+#define PMF_ROLLING			4
+#define	PMF_BACKWARDS_JUMP	8		// go into backwards land
+#define	PMF_BACKWARDS_RUN	16		// coast down to backwards run
+#define	PMF_TIME_LAND		32		// pm_time is time before rejump
+#define	PMF_TIME_KNOCKBACK	64		// pm_time is an air-accelerate only time
+#define	PMF_FIX_MINS		128		// mins have been brought up, keep tracing down to fix them
+#define	PMF_TIME_WATERJUMP	256		// pm_time is waterjump
+#define	PMF_RESPAWNED		512		// clear after attack and jump buttons come up
+#define	PMF_USE_ITEM_HELD	1024
+#define PMF_UPDATE_ANIM		2048	// The server updated the animation, the pmove should set the ghoul2 anim to match.
+#define PMF_FOLLOW			4096	// spectate following another player
+#define PMF_SCOREBOARD		8192	// spectate as a scoreboard
+#define PMF_STUCK_TO_WALL	16384	// grabbing a wall
+
+#define	PMF_ALL_TIMES	(PMF_TIME_WATERJUMP|PMF_TIME_LAND|PMF_TIME_KNOCKBACK)
+
+#define	MAXTOUCH	32
+
+typedef struct bgEntity_s
+{
+	entityState_t	s;
+	playerState_t	*playerState;
+	Vehicle_t		*m_pVehicle; //vehicle data
+	void			*ghoul2; //g2 instance
+	int				localAnimIndex; //index locally (game/cgame) to anim data for this skel
+	vec3_t			modelScale; //needed for g2 collision
+
+	//Data type(s) must directly correspond to the head of the gentity and centity structures
+} bgEntity_t;
+
+typedef struct {
+	// state (in / out)
+	playerState_t	*ps;
+
+	//rww - shared ghoul2 stuff (not actually the same data, but hey)
+	void		*ghoul2;
+	int			g2Bolts_LFoot;
+	int			g2Bolts_RFoot;
+	vec3_t		modelScale;
+
+	//hacky bool so we know if we're dealing with a nonhumanoid (which is probably a rockettrooper)
+	qboolean	nonHumanoid;
+
+	// command (in)
+	usercmd_t	cmd;
+	int			tracemask;			// collide against these types of surfaces
+	int			debugLevel;			// if set, diagnostic output will be printed
+	qboolean	noFootsteps;		// if the game is setup for no footsteps by the server
+	qboolean	gauntletHit;		// true if a gauntlet attack would actually hit something
+
+	int			framecount;
+
+	// results (out)
+	int			numtouch;
+	int			touchents[MAXTOUCH];
+
+	int			useEvent;
+
+	vec3_t		mins, maxs;			// bounding box size
+
+	int			watertype;
+	int			waterlevel;
+
+	int			gametype;
+
+	int			debugMelee;
+	int			stepSlideFix;
+	int			noSpecMove;
+
+	animation_t	*animations;
+
+	float		xyspeed;
+
+	// for fixed msec Pmove
+	int			pmove_fixed;
+	int			pmove_msec;
+
+	// callbacks to test the world
+	// these will be different functions during game and cgame
+	void		(*trace)( trace_t *results, const vec3_t start, const vec3_t mins, const vec3_t maxs, const vec3_t end, int passEntityNum, int contentMask );
+	int			(*pointcontents)( const vec3_t point, int passEntityNum );
+
+	int			checkDuelLoss;
+
+	//rww - bg entitystate access method
+	bgEntity_t	*baseEnt; //base address of the entity array (g_entities or cg_entities)
+	int			entSize; //size of the struct (gentity_t or centity_t) so things can be dynamic
+} pmove_t;
+
+#include "../namespace_begin.h"
+
+extern	pmove_t		*pm;
+
+#define SETANIM_TORSO 1
+#define SETANIM_LEGS  2
+#define SETANIM_BOTH  SETANIM_TORSO|SETANIM_LEGS//3
+
+#define SETANIM_FLAG_NORMAL		0//Only set if timer is 0
+#define SETANIM_FLAG_OVERRIDE	1//Override previous
+#define SETANIM_FLAG_HOLD		2//Set the new timer
+#define SETANIM_FLAG_RESTART	4//Allow restarting the anim if playing the same one (weapon fires)
+#define SETANIM_FLAG_HOLDLESS	8//Set the new timer
+
+
+// if a full pmove isn't done on the client, you can just update the angles
+void PM_UpdateViewAngles( playerState_t *ps, const usercmd_t *cmd );
+void Pmove (pmove_t *pmove);
+
+#include "../namespace_end.h"
+
+//===================================================================================
+
+
+// player_state->stats[] indexes
+// NOTE: may not have more than 16
+typedef enum {
+	STAT_HEALTH,
+	STAT_HOLDABLE_ITEM,
+	STAT_HOLDABLE_ITEMS,
+	STAT_PERSISTANT_POWERUP,
+	//MAKE SURE STAT_WEAPONS REMAINS 4!!!!
+	//There is a hardcoded reference in msg.cpp to send it in 32 bits -rww
+	STAT_WEAPONS = 4,					// 16 bit fields
+	STAT_ARMOR,				
+	STAT_DEAD_YAW,					// look this direction when dead (FIXME: get rid of?)
+	STAT_CLIENTS_READY,				// bit mask of clients wishing to exit the intermission (FIXME: configstring?)
+	STAT_MAX_HEALTH					// health / armor limit, changable by handicap
+} statIndex_t;
+
+
+// player_state->persistant[] indexes
+// these fields are the only part of player_state that isn't
+// cleared on respawn
+// NOTE: may not have more than 16
+typedef enum {
+	PERS_SCORE,						// !!! MUST NOT CHANGE, SERVER AND GAME BOTH REFERENCE !!!
+	PERS_HITS,						// total points damage inflicted so damage beeps can sound on change
+	PERS_RANK,						// player rank or team rank
+	PERS_TEAM,						// player team
+	PERS_SPAWN_COUNT,				// incremented every respawn
+	PERS_PLAYEREVENTS,				// 16 bits that can be flipped for events
+	PERS_ATTACKER,					// clientnum of last damage inflicter
+	PERS_ATTACKEE_ARMOR,			// health/armor of last person we attacked
+	PERS_KILLED,					// count of the number of times you died
+	// player awards tracking
+	PERS_IMPRESSIVE_COUNT,			// two railgun hits in a row
+	PERS_EXCELLENT_COUNT,			// two successive kills in a short amount of time
+	PERS_DEFEND_COUNT,				// defend awards
+	PERS_ASSIST_COUNT,				// assist awards
+	PERS_GAUNTLET_FRAG_COUNT,		// kills with the guantlet
+	PERS_CAPTURES					// captures
+} persEnum_t;
+
+
+// entityState_t->eFlags
+#define	EF_G2ANIMATING			(1<<0)		//perform g2 bone anims based on torsoAnim and legsAnim, works for ET_GENERAL -rww
+#define	EF_DEAD					(1<<1)		// don't draw a foe marker over players with EF_DEAD
+//#define	EF_BOUNCE_SHRAPNEL		(1<<2)		// special shrapnel flag
+//do not use eflags for server-only things, it wastes bandwidth -rww
+#define EF_RADAROBJECT			(1<<2)		// display on team radar
+
+#define	EF_TELEPORT_BIT			(1<<3)		// toggled every time the origin abruptly changes
+
+#define	EF_SHADER_ANIM			(1<<4)		// Animating shader (by s.frame)
+
+#define EF_PLAYER_EVENT			(1<<5)
+//#define	EF_BOUNCE				(1<<5)		// for missiles
+//#define	EF_BOUNCE_HALF			(1<<6)		// for missiles
+//these aren't even referenced in bg or client code and do not need to be eFlags, so I
+//am using these flags for rag stuff -rww
+
+#define EF_RAG					(1<<6)		//ragdoll him even if he's alive
+
+
+#define EF_PERMANENT			(1<<7)		// rww - I am claiming this. (for permanent entities)
+
+#define	EF_NODRAW				(1<<8)		// may have an event, but no model (unspawned items)
+#define	EF_FIRING				(1<<9)		// for lightning gun
+#define EF_ALT_FIRING			(1<<10)		// for alt-fires, mostly for lightning guns though
+#define	EF_JETPACK_ACTIVE		(1<<11)		//jetpack is activated
+
+#define EF_NOT_USED_1			(1<<12)		// not used
+
+#define	EF_TALK					(1<<13)		// draw a talk balloon
+#define	EF_CONNECTION			(1<<14)		// draw a connection trouble sprite
+#define	EF_NOT_USED_6			(1<<15)		// not used
+
+#define	EF_NOT_USED_2			(1<<16)		// not used
+#define	EF_NOT_USED_3			(1<<17)		// not used
+#define	EF_NOT_USED_4			(1<<18)		// not used
+
+#define	EF_BODYPUSH				(1<<19)		//rww - claiming this for fullbody push effect
+
+#define	EF_DOUBLE_AMMO			(1<<20)		// Hacky way to get around ammo max
+#define EF_SEEKERDRONE			(1<<21)		// show seeker drone floating around head
+#define EF_MISSILE_STICK		(1<<22)		// missiles that stick to the wall.
+#define EF_ITEMPLACEHOLDER		(1<<23)		// item effect
+#define EF_SOUNDTRACKER			(1<<24)		// sound position needs to be updated in relation to another entity
+#define EF_DROPPEDWEAPON		(1<<25)		// it's a dropped weapon
+#define EF_DISINTEGRATION		(1<<26)		// being disintegrated by the disruptor
+#define EF_INVULNERABLE			(1<<27)		// just spawned in or whatever, so is protected
+
+#define EF_CLIENTSMOOTH			(1<<28)		// standard lerporigin smooth override on client
+
+#define EF_JETPACK				(1<<29)		//rww - wearing a jetpack
+#define EF_JETPACK_FLAMING		(1<<30)		//rww - jetpack fire effect
+
+#define	EF_NOT_USED_5			(1<<31)		// not used
+
+//These new EF2_??? flags were added for NPCs, they really should not be used often.
+//NOTE: we only allow 10 of these!
+#define	EF2_HELD_BY_MONSTER		(1<<0)		// Being held by something, like a Rancor or a Wampa
+#define	EF2_USE_ALT_ANIM		(1<<1)		// For certain special runs/stands for creatures like the Rancor and Wampa whose runs/stands are conditional
+#define	EF2_ALERTED				(1<<2)		// For certain special anims, for Rancor: means you've had an enemy, so use the more alert stand
+#define	EF2_GENERIC_NPC_FLAG	(1<<3)		// So far, used for Rancor...
+#define	EF2_FLYING				(1<<4)		// Flying FIXME: only used on NPCs doesn't *really* have to be passed over, does it?
+#define	EF2_HYPERSPACE			(1<<5)		// Used to both start the hyperspace effect on the predicted client and to let the vehicle know it can now jump into hyperspace (after turning to face the proper angle)
+#define	EF2_BRACKET_ENTITY		(1<<6)		// Draw as bracketed
+#define	EF2_SHIP_DEATH			(1<<7)		// "died in ship" mode
+#define	EF2_NOT_USED_1			(1<<8)		// not used
+
+
+typedef enum {
+	EFFECT_NONE = 0,
+	EFFECT_SMOKE,
+	EFFECT_EXPLOSION,
+	EFFECT_EXPLOSION_PAS,
+	EFFECT_SPARK_EXPLOSION,
+	EFFECT_EXPLOSION_TRIPMINE,
+	EFFECT_EXPLOSION_DETPACK,
+	EFFECT_EXPLOSION_FLECHETTE,
+	EFFECT_STUNHIT,
+	EFFECT_EXPLOSION_DEMP2ALT,
+	EFFECT_EXPLOSION_TURRET,
+	EFFECT_SPARKS,
+	EFFECT_WATER_SPLASH,
+	EFFECT_ACID_SPLASH,
+	EFFECT_LAVA_SPLASH,
+	EFFECT_LANDING_MUD,
+	EFFECT_LANDING_SAND,
+	EFFECT_LANDING_DIRT,
+	EFFECT_LANDING_SNOW,
+	EFFECT_LANDING_GRAVEL,
+	EFFECT_MAX
+} effectTypes_t;
+
+// NOTE: may not have more than 16
+typedef enum {
+	PW_NONE,
+
+	PW_QUAD,
+	PW_BATTLESUIT,
+	PW_PULL,
+	//PW_INVIS, //rww - removed
+	//PW_REGEN, //rww - removed
+	//PW_FLIGHT, //rww - removed
+
+	PW_REDFLAG,
+	PW_BLUEFLAG,
+	PW_NEUTRALFLAG,
+
+	PW_SHIELDHIT,
+
+	//PW_SCOUT, //rww - removed
+	//PW_GUARD, //rww - removed
+	//PW_DOUBLER, //rww - removed
+	//PW_AMMOREGEN, //rww - removed
+	PW_SPEEDBURST,
+	PW_DISINT_4,
+	PW_SPEED,
+	PW_CLOAKED,
+	PW_FORCE_ENLIGHTENED_LIGHT,
+	PW_FORCE_ENLIGHTENED_DARK,
+	PW_FORCE_BOON,
+	PW_YSALAMIRI,
+
+	PW_NUM_POWERUPS
+
+};
+typedef int powerup_t;
+
+typedef enum {
+	HI_NONE,
+
+	HI_SEEKER,
+	HI_SHIELD,
+	HI_MEDPAC,
+	HI_MEDPAC_BIG,
+	HI_BINOCULARS,
+	HI_SENTRY_GUN,
+	HI_JETPACK,
+
+	HI_HEALTHDISP,
+	HI_AMMODISP,
+	HI_EWEB,
+	HI_CLOAK,
+
+	HI_NUM_HOLDABLE
+};
+typedef int holdable_t;
+
+
+typedef enum {
+	CTFMESSAGE_FRAGGED_FLAG_CARRIER,
+	CTFMESSAGE_FLAG_RETURNED,
+	CTFMESSAGE_PLAYER_RETURNED_FLAG,
+	CTFMESSAGE_PLAYER_CAPTURED_FLAG,
+	CTFMESSAGE_PLAYER_GOT_FLAG
+} ctfMsg_t;
+
+// reward sounds (stored in ps->persistant[PERS_PLAYEREVENTS])
+#define	PLAYEREVENT_DENIEDREWARD		0x0001
+#define	PLAYEREVENT_GAUNTLETREWARD		0x0002
+
+// entityState_t->event values
+// entity events are for effects that take place reletive
+// to an existing entities origin.  Very network efficient.
+
+// two bits at the top of the entityState->event field
+// will be incremented with each change in the event so
+// that an identical event started twice in a row can
+// be distinguished.  And off the value with ~EV_EVENT_BITS
+// to retrieve the actual event number
+#define	EV_EVENT_BIT1		0x00000100
+#define	EV_EVENT_BIT2		0x00000200
+#define	EV_EVENT_BITS		(EV_EVENT_BIT1|EV_EVENT_BIT2)
+
+#define	EVENT_VALID_MSEC	300
+
+typedef enum
+{
+	PDSOUND_NONE,
+	PDSOUND_PROTECTHIT,
+	PDSOUND_PROTECT,
+	PDSOUND_ABSORBHIT,
+	PDSOUND_ABSORB,
+	PDSOUND_FORCEJUMP,
+	PDSOUND_FORCEGRIP
+} pdSounds_t;
+
+typedef enum {
+	EV_NONE,
+
+	EV_CLIENTJOIN,
+
+	EV_FOOTSTEP,
+	EV_FOOTSTEP_METAL,
+	EV_FOOTSPLASH,
+	EV_FOOTWADE,
+	EV_SWIM,
+
+	EV_STEP_4,
+	EV_STEP_8,
+	EV_STEP_12,
+	EV_STEP_16,
+
+	EV_FALL,
+
+	EV_JUMP_PAD,			// boing sound at origin, jump sound on player
+
+	EV_GHOUL2_MARK,			//create a projectile impact mark on something with a client-side g2 instance.
+
+	EV_GLOBAL_DUEL,
+	EV_PRIVATE_DUEL,
+
+	EV_JUMP,
+	EV_ROLL,
+	EV_WATER_TOUCH,	// foot touches
+	EV_WATER_LEAVE,	// foot leaves
+	EV_WATER_UNDER,	// head touches
+	EV_WATER_CLEAR,	// head leaves
+
+	EV_ITEM_PICKUP,			// normal item pickups are predictable
+	EV_GLOBAL_ITEM_PICKUP,	// powerup / team sounds are broadcast to everyone
+
+	EV_VEH_FIRE,
+
+	EV_NOAMMO,
+	EV_CHANGE_WEAPON,
+	EV_FIRE_WEAPON,
+	EV_ALT_FIRE,
+	EV_SABER_ATTACK,
+	EV_SABER_HIT,
+	EV_SABER_BLOCK,
+	EV_SABER_CLASHFLARE,
+	EV_SABER_UNHOLSTER,
+	EV_BECOME_JEDIMASTER,
+	EV_DISRUPTOR_MAIN_SHOT,
+	EV_DISRUPTOR_SNIPER_SHOT,
+	EV_DISRUPTOR_SNIPER_MISS,
+	EV_DISRUPTOR_HIT,
+	EV_DISRUPTOR_ZOOMSOUND,
+
+	EV_PREDEFSOUND,
+
+	EV_TEAM_POWER,
+
+	EV_SCREENSHAKE,
+
+	EV_LOCALTIMER,
+
+	EV_USE,			// +Use key
+
+	EV_USE_ITEM0,
+	EV_USE_ITEM1,
+	EV_USE_ITEM2,
+	EV_USE_ITEM3,
+	EV_USE_ITEM4,
+	EV_USE_ITEM5,
+	EV_USE_ITEM6,
+	EV_USE_ITEM7,
+	EV_USE_ITEM8,
+	EV_USE_ITEM9,
+	EV_USE_ITEM10,
+	EV_USE_ITEM11,
+	EV_USE_ITEM12,
+	EV_USE_ITEM13,
+	EV_USE_ITEM14,
+	EV_USE_ITEM15,
+
+	EV_ITEMUSEFAIL,
+
+	EV_ITEM_RESPAWN,
+	EV_ITEM_POP,
+	EV_PLAYER_TELEPORT_IN,
+	EV_PLAYER_TELEPORT_OUT,
+
+	EV_GRENADE_BOUNCE,		// eventParm will be the soundindex
+	EV_MISSILE_STICK,		// eventParm will be the soundindex
+
+	EV_PLAY_EFFECT,
+	EV_PLAY_EFFECT_ID,
+	EV_PLAY_PORTAL_EFFECT_ID,
+
+	EV_PLAYDOORSOUND,
+	EV_PLAYDOORLOOPSOUND,
+	EV_BMODEL_SOUND,
+
+	EV_MUTE_SOUND,
+	EV_VOICECMD_SOUND,
+	EV_GENERAL_SOUND,
+	EV_GLOBAL_SOUND,		// no attenuation
+	EV_GLOBAL_TEAM_SOUND,
+	EV_ENTITY_SOUND,
+
+	EV_PLAY_ROFF,
+
+	EV_GLASS_SHATTER,
+	EV_DEBRIS,
+	EV_MISC_MODEL_EXP,
+
+	EV_CONC_ALT_IMPACT,
+
+	EV_MISSILE_HIT,
+	EV_MISSILE_MISS,
+	EV_MISSILE_MISS_METAL,
+	EV_BULLET,				// otherEntity is the shooter
+
+	EV_PAIN,
+	EV_DEATH1,
+	EV_DEATH2,
+	EV_DEATH3,
+	EV_OBITUARY,
+
+	EV_POWERUP_QUAD,
+	EV_POWERUP_BATTLESUIT,
+	//EV_POWERUP_REGEN,
+
+	EV_FORCE_DRAINED,
+
+	EV_GIB_PLAYER,			// gib a previously living player
+	EV_SCOREPLUM,			// score plum
+
+	EV_CTFMESSAGE,
+
+	EV_BODYFADE,
+
+	EV_SIEGE_ROUNDOVER,
+	EV_SIEGE_OBJECTIVECOMPLETE,
+
+	EV_DESTROY_GHOUL2_INSTANCE,
+
+	EV_DESTROY_WEAPON_MODEL,
+
+	EV_GIVE_NEW_RANK,
+	EV_SET_FREE_SABER,
+	EV_SET_FORCE_DISABLE,
+
+	EV_WEAPON_CHARGE,
+	EV_WEAPON_CHARGE_ALT,
+
+	EV_SHIELD_HIT,
+
+	EV_DEBUG_LINE,
+	EV_TESTLINE,
+	EV_STOPLOOPINGSOUND,
+	EV_STARTLOOPINGSOUND,
+	EV_TAUNT,
+
+	//rww - Begin NPC sound events
+	EV_ANGER1,	//Say when acquire an enemy when didn't have one before
+	EV_ANGER2,
+	EV_ANGER3,
+
+	EV_VICTORY1,	//Say when killed an enemy
+	EV_VICTORY2,
+	EV_VICTORY3,
+
+	EV_CONFUSE1,	//Say when confused
+	EV_CONFUSE2,
+	EV_CONFUSE3,
+
+	EV_PUSHED1,		//Say when pushed
+	EV_PUSHED2,
+	EV_PUSHED3,
+
+	EV_CHOKE1,		//Say when choking
+	EV_CHOKE2,
+	EV_CHOKE3,
+
+	EV_FFWARN,		//ffire founds
+	EV_FFTURN,
+	//extra sounds for ST
+	EV_CHASE1,
+	EV_CHASE2,
+	EV_CHASE3,
+	EV_COVER1,
+	EV_COVER2,
+	EV_COVER3,
+	EV_COVER4,
+	EV_COVER5,
+	EV_DETECTED1,
+	EV_DETECTED2,
+	EV_DETECTED3,
+	EV_DETECTED4,
+	EV_DETECTED5,
+	EV_LOST1,
+	EV_OUTFLANK1,
+	EV_OUTFLANK2,
+	EV_ESCAPING1,
+	EV_ESCAPING2,
+	EV_ESCAPING3,
+	EV_GIVEUP1,
+	EV_GIVEUP2,
+	EV_GIVEUP3,
+	EV_GIVEUP4,
+	EV_LOOK1,
+	EV_LOOK2,
+	EV_SIGHT1,
+	EV_SIGHT2,
+	EV_SIGHT3,
+	EV_SOUND1,
+	EV_SOUND2,
+	EV_SOUND3,
+	EV_SUSPICIOUS1,
+	EV_SUSPICIOUS2,
+	EV_SUSPICIOUS3,
+	EV_SUSPICIOUS4,
+	EV_SUSPICIOUS5,
+	//extra sounds for Jedi
+	EV_COMBAT1,
+	EV_COMBAT2,
+	EV_COMBAT3,
+	EV_JDETECTED1,
+	EV_JDETECTED2,
+	EV_JDETECTED3,
+	EV_TAUNT1,
+	EV_TAUNT2,
+	EV_TAUNT3,
+	EV_JCHASE1,
+	EV_JCHASE2,
+	EV_JCHASE3,
+	EV_JLOST1,
+	EV_JLOST2,
+	EV_JLOST3,
+	EV_DEFLECT1,
+	EV_DEFLECT2,
+	EV_DEFLECT3,
+	EV_GLOAT1,
+	EV_GLOAT2,
+	EV_GLOAT3,
+	EV_PUSHFAIL,
+
+	EV_SIEGESPEC,
+	
+} entity_event_t;			// There is a maximum of 256 events (8 bits transmission, 2 high bits for uniqueness)
+
+
+typedef enum {
+	GTS_RED_CAPTURE,
+	GTS_BLUE_CAPTURE,
+	GTS_RED_RETURN,
+	GTS_BLUE_RETURN,
+	GTS_RED_TAKEN,
+	GTS_BLUE_TAKEN,
+	GTS_REDTEAM_SCORED,
+	GTS_BLUETEAM_SCORED,
+	GTS_REDTEAM_TOOK_LEAD,
+	GTS_BLUETEAM_TOOK_LEAD,
+	GTS_TEAMS_ARE_TIED
+} global_team_sound_t;
+
+
+
+typedef enum {
+	TEAM_FREE,
+	TEAM_RED,
+	TEAM_BLUE,
+	TEAM_SPECTATOR,
+
+	TEAM_NUM_TEAMS
+};
+typedef int team_t;
+
+typedef enum {
+	DUELTEAM_FREE,
+	DUELTEAM_LONE,
+	DUELTEAM_DOUBLE,
+
+	DUELTEAM_SINGLE,		// for regular duel matches (not power duel)
+} duelTeam_t;
+
+// Time between location updates
+#define TEAM_LOCATION_UPDATE_TIME		1000
+
+// How many players on the overlay
+#define TEAM_MAXOVERLAY		32
+
+//team task
+typedef enum {
+	TEAMTASK_NONE,
+	TEAMTASK_OFFENSE, 
+	TEAMTASK_DEFENSE,
+	TEAMTASK_PATROL,
+	TEAMTASK_FOLLOW,
+	TEAMTASK_RETRIEVE,
+	TEAMTASK_ESCORT,
+	TEAMTASK_CAMP
+} teamtask_t;
+
+// means of death
+typedef enum {
+	MOD_UNKNOWN,
+	MOD_STUN_BATON,
+	MOD_MELEE,
+	MOD_SABER,
+	MOD_BRYAR_PISTOL,
+	MOD_BRYAR_PISTOL_ALT,
+	MOD_BLASTER,
+	MOD_TURBLAST,
+	MOD_DISRUPTOR,
+	MOD_DISRUPTOR_SPLASH,
+	MOD_DISRUPTOR_SNIPER,
+	MOD_BOWCASTER,
+	MOD_REPEATER,
+	MOD_REPEATER_ALT,
+	MOD_REPEATER_ALT_SPLASH,
+	MOD_DEMP2,
+	MOD_DEMP2_ALT,
+	MOD_FLECHETTE,
+	MOD_FLECHETTE_ALT_SPLASH,
+	MOD_ROCKET,
+	MOD_ROCKET_SPLASH,
+	MOD_ROCKET_HOMING,
+	MOD_ROCKET_HOMING_SPLASH,
+	MOD_THERMAL,
+	MOD_THERMAL_SPLASH,
+	MOD_TRIP_MINE_SPLASH,
+	MOD_TIMED_MINE_SPLASH,
+	MOD_DET_PACK_SPLASH,
+	MOD_VEHICLE,
+	MOD_CONC,
+	MOD_CONC_ALT,
+	MOD_FORCE_DARK,
+	MOD_SENTRY,
+	MOD_WATER,
+	MOD_SLIME,
+	MOD_LAVA,
+	MOD_CRUSH,
+	MOD_TELEFRAG,
+	MOD_FALLING,
+	MOD_SUICIDE,
+	MOD_TARGET_LASER,
+	MOD_TRIGGER_HURT,
+	MOD_TEAM_CHANGE,
+	//AURELIO: when/if you put this back in, remember to make a case for it in all the other places where
+	//mod's are checked. Also, it probably isn't the most elegant solution for what you want - just add
+	//a frag back to the player after you call the player_die (and keep a local of his pre-death score to
+	//make sure he actually lost points, there may be cases where you don't lose points on changing teams
+	//or suiciding, and so you would actually be giving him a point) -Rich
+	// I put it back in for now, if it becomes a problem we'll work around it later (it shouldn't though)...
+	MOD_MAX
+} meansOfDeath_t;
+
+
+//---------------------------------------------------------
+
+// gitem_t->type
+typedef enum {
+	IT_BAD,
+	IT_WEAPON,				// EFX: rotate + upscale + minlight
+	IT_AMMO,				// EFX: rotate
+	IT_ARMOR,				// EFX: rotate + minlight
+	IT_HEALTH,				// EFX: static external sphere + rotating internal
+	IT_POWERUP,				// instant on, timer based
+							// EFX: rotate + external ring that rotates
+	IT_HOLDABLE,			// single use, holdable item
+							// EFX: rotate + bob
+	IT_PERSISTANT_POWERUP,
+	IT_TEAM
+};
+typedef int itemType_t;
+
+#define MAX_ITEM_MODELS 4
+
+typedef struct gitem_s {
+	char		*classname;	// spawning name
+	char		*pickup_sound;
+	char		*world_model[MAX_ITEM_MODELS];
+	char		*view_model;
+	char		*icon;
+//	char		*pickup_name;	// for printing on pickup
+
+	int			quantity;		// for ammo how much, or duration of powerup
+	itemType_t  giType;			// IT_* flags
+
+	int			giTag;
+
+	char		*precaches;		// string of all models and images this item will use
+	char		*sounds;		// string of all sounds this item will use
+	char		*description;
+} gitem_t;
+
+// included in both the game dll and the client
+#include "../namespace_begin.h"
+
+extern	gitem_t	bg_itemlist[];
+extern	int		bg_numItems;
+
+float vectoyaw( const vec3_t vec );
+
+gitem_t	*BG_FindItem( const char *classname );
+gitem_t	*BG_FindItemForWeapon( weapon_t weapon );
+gitem_t	*BG_FindItemForPowerup( powerup_t pw );
+gitem_t	*BG_FindItemForHoldable( holdable_t pw );
+#define	ITEM_INDEX(x) ((x)-bg_itemlist)
+
+qboolean	BG_CanItemBeGrabbed( int gametype, const entityState_t *ent, const playerState_t *ps );
+
+#include "../namespace_end.h"
+
+
+#define SABER_BLOCK_DUR 150		// number of milliseconds a block animation should take.
+
+
+
+// g_dmflags->integer flags
+#define	DF_NO_FALLING			8
+#define DF_FIXED_FOV			16
+#define	DF_NO_FOOTSTEPS			32
+
+//rwwRMG - added in CONTENTS_TERRAIN
+// content masks
+#define	MASK_ALL				(-1)
+#define	MASK_SOLID				(CONTENTS_SOLID|CONTENTS_TERRAIN)
+#define	MASK_PLAYERSOLID		(CONTENTS_SOLID|CONTENTS_PLAYERCLIP|CONTENTS_BODY|CONTENTS_TERRAIN)
+#define	MASK_NPCSOLID			(CONTENTS_SOLID|CONTENTS_MONSTERCLIP|CONTENTS_BODY|CONTENTS_TERRAIN)
+#define	MASK_DEADSOLID			(CONTENTS_SOLID|CONTENTS_PLAYERCLIP|CONTENTS_TERRAIN)
+#define	MASK_WATER				(CONTENTS_WATER|CONTENTS_LAVA|CONTENTS_SLIME)
+#define	MASK_OPAQUE				(CONTENTS_SOLID|CONTENTS_SLIME|CONTENTS_LAVA|CONTENTS_TERRAIN)
+#define	MASK_SHOT				(CONTENTS_SOLID|CONTENTS_BODY|CONTENTS_CORPSE|CONTENTS_TERRAIN)
+
+
+// ET_FX States (stored in modelindex2)
+
+#define	FX_STATE_OFF			0
+#define FX_STATE_ONE_SHOT		1
+#define FX_STATE_ONE_SHOT_LIMIT	10
+#define FX_STATE_CONTINUOUS		20
+
+//
+// entityState_t->eType
+//
+typedef enum {
+	ET_GENERAL,
+	ET_PLAYER,
+	ET_ITEM,
+	ET_MISSILE,
+	ET_SPECIAL,				// rww - force fields
+	ET_HOLOCRON,			// rww - holocron icon displays
+	ET_MOVER,
+	ET_BEAM,
+	ET_PORTAL,
+	ET_SPEAKER,
+	ET_PUSH_TRIGGER,
+	ET_TELEPORT_TRIGGER,
+	ET_INVISIBLE,
+	ET_NPC,					// ghoul2 player-like entity
+	ET_TEAM,
+	ET_BODY,
+	ET_TERRAIN,
+	ET_FX,
+
+	ET_EVENTS				// any of the EV_* events can be added freestanding
+							// by setting eType to ET_EVENTS + eventNum
+							// this avoids having to set eFlags and eventNum
+} entityType_t;
+
+
+
+
+//
+// fields are needed for spawning from the entity string
+//
+//I moved these from g_spawn.c because the entity parsing stuff is semi-shared now -rww
+#undef _GAME_SIDE
+
+#ifdef QAGAME
+#define _GAME_SIDE
+#elif defined CGAME
+#define _GAME_SIDE
+#endif
+
+#ifdef _GAME_SIDE
+typedef enum {
+	F_INT, 
+	F_FLOAT,
+	F_LSTRING,			// string on disk, pointer in memory, TAG_LEVEL
+	F_GSTRING,			// string on disk, pointer in memory, TAG_GAME
+	F_VECTOR,
+	F_ANGLEHACK,
+	F_ENTITY,			// index on disk, pointer in memory
+	F_ITEM,				// index on disk, pointer in memory
+	F_CLIENT,			// index on disk, pointer in memory
+	F_PARM1,			// Special case for parms
+	F_PARM2,			// Special case for parms
+	F_PARM3,			// Special case for parms
+	F_PARM4,			// Special case for parms
+	F_PARM5,			// Special case for parms
+	F_PARM6,			// Special case for parms
+	F_PARM7,			// Special case for parms
+	F_PARM8,			// Special case for parms
+	F_PARM9,			// Special case for parms
+	F_PARM10,			// Special case for parms
+	F_PARM11,			// Special case for parms
+	F_PARM12,			// Special case for parms
+	F_PARM13,			// Special case for parms
+	F_PARM14,			// Special case for parms
+	F_PARM15,			// Special case for parms
+	F_PARM16,			// Special case for parms
+	F_IGNORE
+} fieldtype_t;
+
+
+
+
+typedef struct
+{
+	char	*name;
+	int		ofs;
+	fieldtype_t	type;
+	int		flags;
+} BG_field_t;
+
+
+
+#endif
+
+
+
+
+// Okay, here lies the much-dreaded Pat-created FSM movement chart...  Heretic II strikes again!
+// Why am I inflicting this on you?  Well, it's better than hardcoded states.
+// Ideally this will be replaced with an external file or more sophisticated move-picker
+// once the game gets out of prototype stage.
+
+// rww - Moved all this to bg_public so that we can access the saberMoveData stuff on the cgame
+// which is currently used for determining if a saber trail should be rendered in a given frame
+#ifdef LS_NONE
+#undef LS_NONE
+#endif
+
+typedef enum {
+	// Invalid, or saber not armed
+	LS_NONE		= 0,
+
+	// General movements with saber
+	LS_READY,
+	LS_DRAW,
+	LS_PUTAWAY,
+
+	// Attacks
+	LS_A_TL2BR,//4
+	LS_A_L2R,
+	LS_A_BL2TR,
+	LS_A_BR2TL,
+	LS_A_R2L,
+	LS_A_TR2BL,
+	LS_A_T2B,
+	LS_A_BACKSTAB,
+	LS_A_BACK,
+	LS_A_BACK_CR,
+	LS_ROLL_STAB,
+	LS_A_LUNGE,
+	LS_A_JUMP_T__B_,
+	LS_A_FLIP_STAB,
+	LS_A_FLIP_SLASH,
+	LS_JUMPATTACK_DUAL,
+	LS_JUMPATTACK_ARIAL_LEFT,
+	LS_JUMPATTACK_ARIAL_RIGHT,
+	LS_JUMPATTACK_CART_LEFT,
+	LS_JUMPATTACK_CART_RIGHT,
+	LS_JUMPATTACK_STAFF_LEFT,
+	LS_JUMPATTACK_STAFF_RIGHT,
+	LS_BUTTERFLY_LEFT,
+	LS_BUTTERFLY_RIGHT,
+	LS_A_BACKFLIP_ATK,
+	LS_SPINATTACK_DUAL,
+	LS_SPINATTACK,
+	LS_LEAP_ATTACK,
+	LS_SWOOP_ATTACK_RIGHT,
+	LS_SWOOP_ATTACK_LEFT,
+	LS_TAUNTAUN_ATTACK_RIGHT,
+	LS_TAUNTAUN_ATTACK_LEFT,
+	LS_KICK_F,
+	LS_KICK_B,
+	LS_KICK_R,
+	LS_KICK_L,
+	LS_KICK_S,
+	LS_KICK_BF,
+	LS_KICK_RL,
+	LS_KICK_F_AIR,
+	LS_KICK_B_AIR,
+	LS_KICK_R_AIR,
+	LS_KICK_L_AIR,
+	LS_STABDOWN,
+	LS_STABDOWN_STAFF,
+	LS_STABDOWN_DUAL,
+	LS_DUAL_SPIN_PROTECT,
+	LS_STAFF_SOULCAL,
+	LS_A1_SPECIAL,
+	LS_A2_SPECIAL,
+	LS_A3_SPECIAL,
+	LS_UPSIDE_DOWN_ATTACK,
+	LS_PULL_ATTACK_STAB,
+	LS_PULL_ATTACK_SWING,
+	LS_SPINATTACK_ALORA,
+	LS_DUAL_FB,
+	LS_DUAL_LR,
+	LS_HILT_BASH,
+
+	//starts
+	LS_S_TL2BR,//26
+	LS_S_L2R,
+	LS_S_BL2TR,//# Start of attack chaining to SLASH LR2UL
+	LS_S_BR2TL,//# Start of attack chaining to SLASH LR2UL
+	LS_S_R2L,
+	LS_S_TR2BL,
+	LS_S_T2B,
+
+	//returns
+	LS_R_TL2BR,//33
+	LS_R_L2R,
+	LS_R_BL2TR,
+	LS_R_BR2TL,
+	LS_R_R2L,
+	LS_R_TR2BL,
+	LS_R_T2B,
+
+	//transitions
+	LS_T1_BR__R,//40
+	LS_T1_BR_TR,
+	LS_T1_BR_T_,
+	LS_T1_BR_TL,
+	LS_T1_BR__L,
+	LS_T1_BR_BL,
+	LS_T1__R_BR,//46
+	LS_T1__R_TR,
+	LS_T1__R_T_,
+	LS_T1__R_TL,
+	LS_T1__R__L,
+	LS_T1__R_BL,
+	LS_T1_TR_BR,//52
+	LS_T1_TR__R,
+	LS_T1_TR_T_,
+	LS_T1_TR_TL,
+	LS_T1_TR__L,
+	LS_T1_TR_BL,
+	LS_T1_T__BR,//58
+	LS_T1_T___R,
+	LS_T1_T__TR,
+	LS_T1_T__TL,
+	LS_T1_T___L,
+	LS_T1_T__BL,
+	LS_T1_TL_BR,//64
+	LS_T1_TL__R,
+	LS_T1_TL_TR,
+	LS_T1_TL_T_,
+	LS_T1_TL__L,
+	LS_T1_TL_BL,
+	LS_T1__L_BR,//70
+	LS_T1__L__R,
+	LS_T1__L_TR,
+	LS_T1__L_T_,
+	LS_T1__L_TL,
+	LS_T1__L_BL,
+	LS_T1_BL_BR,//76
+	LS_T1_BL__R,
+	LS_T1_BL_TR,
+	LS_T1_BL_T_,
+	LS_T1_BL_TL,
+	LS_T1_BL__L,
+
+	//Bounces
+	LS_B1_BR,
+	LS_B1__R,
+	LS_B1_TR,
+	LS_B1_T_,
+	LS_B1_TL,
+	LS_B1__L,
+	LS_B1_BL,
+
+	//Deflected attacks
+	LS_D1_BR,
+	LS_D1__R,
+	LS_D1_TR,
+	LS_D1_T_,
+	LS_D1_TL,
+	LS_D1__L,
+	LS_D1_BL,
+	LS_D1_B_,
+
+	//Reflected attacks
+	LS_V1_BR,
+	LS_V1__R,
+	LS_V1_TR,
+	LS_V1_T_,
+	LS_V1_TL,
+	LS_V1__L,
+	LS_V1_BL,
+	LS_V1_B_,
+
+	// Broken parries
+	LS_H1_T_,//
+	LS_H1_TR,
+	LS_H1_TL,
+	LS_H1_BR,
+	LS_H1_B_,
+	LS_H1_BL,
+
+	// Knockaways
+	LS_K1_T_,//
+	LS_K1_TR,
+	LS_K1_TL,
+	LS_K1_BR,
+	LS_K1_BL,
+
+	// Parries
+	LS_PARRY_UP,//
+	LS_PARRY_UR,
+	LS_PARRY_UL,
+	LS_PARRY_LR,
+	LS_PARRY_LL,
+
+	// Projectile Reflections
+	LS_REFLECT_UP,//
+	LS_REFLECT_UR,
+	LS_REFLECT_UL,
+	LS_REFLECT_LR,
+	LS_REFLECT_LL,
+
+	LS_MOVE_MAX//
+};
+typedef int saberMoveName_t;
+
+typedef enum {
+	Q_BR,
+	Q_R,
+	Q_TR,
+	Q_T,
+	Q_TL,
+	Q_L,
+	Q_BL,
+	Q_B,
+	Q_NUM_QUADS
+} saberQuadrant_t;
+
+typedef struct
+{
+	char *name;
+	int animToUse;
+	int	startQuad;
+	int	endQuad;
+	unsigned animSetFlags;
+	int blendTime;
+	int blocking;
+	saberMoveName_t chain_idle;			// What move to call if the attack button is not pressed at the end of this anim
+	saberMoveName_t chain_attack;		// What move to call if the attack button (and nothing else) is pressed
+	qboolean trailLength;
+} saberMoveData_t;
+
+#include "../namespace_begin.h"
+
+extern saberMoveData_t	saberMoveData[LS_MOVE_MAX];
+
+bgEntity_t *PM_BGEntForNum( int num );
+qboolean BG_KnockDownable(playerState_t *ps);
+qboolean BG_LegalizedForcePowers(char *powerOut, int maxRank, qboolean freeSaber, int teamForce, int gametype, int fpDisabled);
+
+#include "../namespace_end.h"
+
+#ifdef __LCC__ //can't inline it then, it is declared over in bg_misc in this case
+void BG_GiveMeVectorFromMatrix(mdxaBone_t *boltMatrix, int flags, vec3_t vec);
+#else
+// given a boltmatrix, return in vec a normalised vector for the axis requested in flags
+static ID_INLINE void BG_GiveMeVectorFromMatrix(mdxaBone_t *boltMatrix, int flags, vec3_t vec)
+{
+	switch (flags)
+	{
+	case ORIGIN:
+		vec[0] = boltMatrix->matrix[0][3];
+		vec[1] = boltMatrix->matrix[1][3];
+		vec[2] = boltMatrix->matrix[2][3];
+		break;
+	case POSITIVE_Y:
+		vec[0] = boltMatrix->matrix[0][1];
+		vec[1] = boltMatrix->matrix[1][1];
+		vec[2] = boltMatrix->matrix[2][1];
+ 		break;
+	case POSITIVE_X:
+		vec[0] = boltMatrix->matrix[0][0];
+		vec[1] = boltMatrix->matrix[1][0];
+		vec[2] = boltMatrix->matrix[2][0];
+		break;
+	case POSITIVE_Z:
+		vec[0] = boltMatrix->matrix[0][2];
+		vec[1] = boltMatrix->matrix[1][2];
+		vec[2] = boltMatrix->matrix[2][2];
+		break;
+	case NEGATIVE_Y:
+		vec[0] = -boltMatrix->matrix[0][1];
+		vec[1] = -boltMatrix->matrix[1][1];
+		vec[2] = -boltMatrix->matrix[2][1];
+		break;
+	case NEGATIVE_X:
+		vec[0] = -boltMatrix->matrix[0][0];
+		vec[1] = -boltMatrix->matrix[1][0];
+		vec[2] = -boltMatrix->matrix[2][0];
+		break;
+	case NEGATIVE_Z:
+		vec[0] = -boltMatrix->matrix[0][2];
+		vec[1] = -boltMatrix->matrix[1][2];
+		vec[2] = -boltMatrix->matrix[2][2];
+		break;
+	}
+}
+#endif
+
+#include "../namespace_begin.h"
+
+void BG_IK_MoveArm(void *ghoul2, int lHandBolt, int time, entityState_t *ent, int basePose, vec3_t desiredPos, qboolean *ikInProgress,
+					 vec3_t origin, vec3_t angles, vec3_t scale, int blendTime, qboolean forceHalt);
+
+void BG_G2PlayerAngles(void *ghoul2, int motionBolt, entityState_t *cent, int time, vec3_t cent_lerpOrigin,
+					   vec3_t cent_lerpAngles, vec3_t legs[3], vec3_t legsAngles, qboolean *tYawing,
+					   qboolean *tPitching, qboolean *lYawing, float *tYawAngle, float *tPitchAngle,
+					   float *lYawAngle, int frametime, vec3_t turAngles, vec3_t modelScale, int ciLegs,
+					   int ciTorso, int *corrTime, vec3_t lookAngles, vec3_t lastHeadAngles, int lookTime,
+					   entityState_t *emplaced, int *crazySmoothFactor);
+void BG_G2ATSTAngles(void *ghoul2, int time, vec3_t cent_lerpAngles );
+
+//BG anim utility functions:
+
+int BG_AnimLength( int index, animNumber_t anim );
+
+qboolean BG_InSpecialJump( int anim );
+qboolean BG_InSaberStandAnim( int anim );
+qboolean BG_InReboundJump( int anim );
+qboolean BG_InReboundHold( int anim );
+qboolean BG_InReboundRelease( int anim );
+qboolean BG_InBackFlip( int anim );
+qboolean BG_DirectFlippingAnim( int anim );
+qboolean BG_SaberInAttack( int move );
+qboolean BG_SaberInSpecial( int move );
+qboolean BG_KickMove( int move );
+qboolean BG_SaberInIdle( int move );
+qboolean BG_FlippingAnim( int anim );
+qboolean BG_SpinningSaberAnim( int anim );
+qboolean BG_SaberInSpecialAttack( int anim );
+qboolean BG_SaberInKata( int saberMove );
+qboolean BG_InKataAnim(int anim);
+qboolean BG_KickingAnim( int anim );
+int BG_InGrappleMove(int anim);
+int BG_BrokenParryForAttack( int move );
+int BG_BrokenParryForParry( int move );
+int BG_KnockawayForParry( int move );
+qboolean BG_InRoll( playerState_t *ps, int anim );
+qboolean BG_InDeathAnim( int anim );
+qboolean BG_InSaberLockOld( int anim );
+qboolean BG_InSaberLock( int anim );
+
+void BG_SaberStartTransAnim( int saberAnimLevel, int anim, float *animSpeed, int broken );
+
+void BG_ForcePowerDrain( playerState_t *ps, forcePowers_t forcePower, int overrideAmt );
+
+void	BG_EvaluateTrajectory( const trajectory_t *tr, int atTime, vec3_t result );
+void	BG_EvaluateTrajectoryDelta( const trajectory_t *tr, int atTime, vec3_t result );
+
+void	BG_AddPredictableEventToPlayerstate( int newEvent, int eventParm, playerState_t *ps );
+
+void	BG_TouchJumpPad( playerState_t *ps, entityState_t *jumppad );
+
+void	BG_PlayerStateToEntityState( playerState_t *ps, entityState_t *s, qboolean snap );
+void	BG_PlayerStateToEntityStateExtraPolate( playerState_t *ps, entityState_t *s, int time, qboolean snap );
+
+qboolean	BG_PlayerTouchesItem( playerState_t *ps, entityState_t *item, int atTime );
+
+void	BG_InitAnimsets(void);
+void	BG_ClearAnimsets(void);
+int		BG_ParseAnimationFile(const char *filename, animation_t *animSet, qboolean isHumanoid);
+#ifndef QAGAME
+int		BG_ParseAnimationEvtFile( const char *as_filename, int animFileIndex, int eventFileIndex );
+#endif
+
+qboolean BG_HasAnimation(int animIndex, int animation);
+int		BG_PickAnim( int animIndex, int minAnim, int maxAnim );
+
+int BG_GetItemIndexByTag(int tag, int type);
+
+qboolean BG_IsItemSelectable(playerState_t *ps, int item);
+
+qboolean BG_HasYsalamiri(int gametype, playerState_t *ps);
+qboolean BG_CanUseFPNow(int gametype, playerState_t *ps, int time, forcePowers_t power);
+
+void *BG_Alloc ( int size );
+void *BG_AllocUnaligned ( int size );
+void *BG_TempAlloc( int size );
+void BG_TempFree( int size );
+char *BG_StringAlloc ( const char *source );
+qboolean BG_OutOfMemory ( void );
+
+void BG_BLADE_ActivateTrail ( bladeInfo_t *blade, float duration );
+void BG_BLADE_DeactivateTrail ( bladeInfo_t *blade, float duration );
+void BG_SI_Activate( saberInfo_t *saber );
+void BG_SI_Deactivate( saberInfo_t *saber );
+void BG_SI_BladeActivate( saberInfo_t *saber, int iBlade, qboolean bActive );
+qboolean BG_SI_Active(saberInfo_t *saber);
+void BG_SI_SetLength( saberInfo_t *saber, float length );
+void BG_SI_SetDesiredLength(saberInfo_t *saber, float len, int bladeNum);
+void BG_SI_SetLengthGradual( saberInfo_t *saber, int time );
+float BG_SI_Length(saberInfo_t *saber);
+float BG_SI_LengthMax(saberInfo_t *saber);
+void BG_SI_ActivateTrail ( saberInfo_t *saber, float duration );
+void BG_SI_DeactivateTrail ( saberInfo_t *saber, float duration );
+extern void BG_AttachToRancor( void *ghoul2,float rancYaw,vec3_t rancOrigin,int time,qhandle_t *modelList,vec3_t modelScale,qboolean inMouth,vec3_t out_origin,vec3_t out_angles,vec3_t out_axis[3] );
+
+extern int WeaponReadyAnim[WP_NUM_WEAPONS];
+extern int WeaponAttackAnim[WP_NUM_WEAPONS];
+
+extern int forcePowerDarkLight[NUM_FORCE_POWERS];
+
+#include "../namespace_end.h"
+
+#define ARENAS_PER_TIER		4
+#define MAX_ARENAS			1024
+#define	MAX_ARENAS_TEXT		8192
+
+#define MAX_BOTS			1024
+#define MAX_BOTS_TEXT		8192
+
+#define	HYPERSPACE_TIME				4000 //For hyperspace triggers
+#define	HYPERSPACE_TELEPORT_FRAC	0.75f
+#define	HYPERSPACE_SPEED			10000.0f//was 30000
+#define	HYPERSPACE_TURN_RATE		45.0f
+
+#endif //__BG_PUBLIC_H__
diff --git a/codemp/game/bg_saber.c b/codemp/game/bg_saber.c
new file mode 100644
index 0000000..3301739
--- /dev/null
+++ b/codemp/game/bg_saber.c
@@ -0,0 +1,3687 @@
+#include "q_shared.h"
+#include "bg_public.h"
+#include "bg_local.h"
+#include "w_saber.h"
+
+#include "../namespace_begin.h"
+extern qboolean BG_SabersOff( playerState_t *ps );
+
+int PM_irand_timesync(int val1, int val2)
+{
+	int i;
+
+	i = (val1-1) + (Q_random( &pm->cmd.serverTime )*(val2 - val1)) + 1;
+	if (i < val1)
+	{
+		i = val1;
+	}
+	if (i > val2)
+	{
+		i = val2;
+	}
+
+	return i;
+}
+
+void BG_ForcePowerDrain( playerState_t *ps, forcePowers_t forcePower, int overrideAmt )
+{
+	//take away the power
+	int	drain = overrideAmt;
+
+	/*
+	if (ps->powerups[PW_FORCE_BOON])
+	{
+		return;
+	}
+	*/
+	//No longer grant infinite force with boon.
+
+	if ( !drain )
+	{
+		drain = forcePowerNeeded[ps->fd.forcePowerLevel[forcePower]][forcePower];
+	}
+	if ( !drain )
+	{
+		return;
+	}
+
+	if (forcePower == FP_LEVITATION)
+	{ //special case
+		int jumpDrain = 0;
+
+		if (ps->velocity[2] > 250)
+		{
+			jumpDrain = 20;
+		}
+		else if (ps->velocity[2] > 200)
+		{
+			jumpDrain = 16;
+		}
+		else if (ps->velocity[2] > 150)
+		{
+			jumpDrain = 12;
+		}
+		else if (ps->velocity[2] > 100)
+		{
+			jumpDrain = 8;
+		}
+		else if (ps->velocity[2] > 50)
+		{
+			jumpDrain = 6;
+		}
+		else if (ps->velocity[2] > 0)
+		{
+			jumpDrain = 4;
+		}
+
+		if (jumpDrain)
+		{
+			if (ps->fd.forcePowerLevel[FP_LEVITATION])
+			{ //don't divide by 0!
+				jumpDrain /= ps->fd.forcePowerLevel[FP_LEVITATION];
+			}
+		}
+
+		ps->fd.forcePower -= jumpDrain;
+		if ( ps->fd.forcePower < 0 )
+		{
+			ps->fd.forcePower = 0;
+		}
+
+		return;
+	}
+
+	ps->fd.forcePower -= drain;
+	if ( ps->fd.forcePower < 0 )
+	{
+		ps->fd.forcePower = 0;
+	}
+}
+
+qboolean BG_EnoughForcePowerForMove( int cost )
+{
+	if ( pm->ps->fd.forcePower < cost )
+	{
+		PM_AddEvent( EV_NOAMMO );
+		return qfalse;
+	}
+
+	return qtrue;
+}
+
+// Silly, but I'm replacing these macros so they are shorter!
+#define AFLAG_IDLE	(SETANIM_FLAG_NORMAL)
+#define AFLAG_ACTIVE (SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD | SETANIM_FLAG_HOLDLESS)
+#define AFLAG_WAIT (SETANIM_FLAG_HOLD | SETANIM_FLAG_HOLDLESS)
+#define AFLAG_FINISH (SETANIM_FLAG_HOLD)
+
+//FIXME: add the alternate anims for each style?
+saberMoveData_t	saberMoveData[LS_MOVE_MAX] = {//							NB:randomized
+	// name			anim(do all styles?)startQ	endQ	setanimflag		blend,	blocking	chain_idle		chain_attack	trailLen
+	{"None",		BOTH_STAND1,		Q_R,	Q_R,	AFLAG_IDLE,		350,	BLK_NO,		LS_NONE,		LS_NONE,		0	},	// LS_NONE		= 0,
+
+	// General movements with saber
+	{"Ready",		BOTH_STAND2,		Q_R,	Q_R,	AFLAG_IDLE,		350,	BLK_WIDE,	LS_READY,		LS_S_R2L,		0	},	// LS_READY,
+	{"Draw",		BOTH_STAND1TO2,		Q_R,	Q_R,	AFLAG_FINISH,	350,	BLK_NO,		LS_READY,		LS_S_R2L,		0	},	// LS_DRAW,
+	{"Putaway",		BOTH_STAND2TO1,		Q_R,	Q_R,	AFLAG_FINISH,	350,	BLK_NO,		LS_READY,		LS_S_R2L,		0	},	// LS_PUTAWAY,
+
+	// Attacks
+	//UL2LR
+	{"TL2BR Att",	BOTH_A1_TL_BR,		Q_TL,	Q_BR,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_R_TL2BR,		LS_R_TL2BR,		200	},	// LS_A_TL2BR
+	//SLASH LEFT
+	{"L2R Att",		BOTH_A1__L__R,		Q_L,	Q_R,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_R_L2R,		LS_R_L2R,		200 },	// LS_A_L2R
+	//LL2UR
+	{"BL2TR Att",	BOTH_A1_BL_TR,		Q_BL,	Q_TR,	AFLAG_ACTIVE,	50,		BLK_TIGHT,	LS_R_BL2TR,		LS_R_BL2TR,		200	},	// LS_A_BL2TR
+	//LR2UL
+	{"BR2TL Att",	BOTH_A1_BR_TL,		Q_BR,	Q_TL,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_R_BR2TL,		LS_R_BR2TL,		200	},	// LS_A_BR2TL
+	//SLASH RIGHT
+	{"R2L Att",		BOTH_A1__R__L,		Q_R,	Q_L,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_R_R2L,		LS_R_R2L,		200 },// LS_A_R2L
+	//UR2LL
+	{"TR2BL Att",	BOTH_A1_TR_BL,		Q_TR,	Q_BL,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_R_TR2BL,		LS_R_TR2BL,		200	},	// LS_A_TR2BL
+	//SLASH DOWN
+	{"T2B Att",		BOTH_A1_T__B_,		Q_T,	Q_B,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_R_T2B,		LS_R_T2B,		200	},	// LS_A_T2B
+	//special attacks
+	{"Back Stab",	BOTH_A2_STABBACK1,	Q_R,	Q_R,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_READY,		LS_READY,		200	},	// LS_A_BACKSTAB
+	{"Back Att",	BOTH_ATTACK_BACK,	Q_R,	Q_R,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_READY,		LS_READY,		200	},	// LS_A_BACK
+	{"CR Back Att",	BOTH_CROUCHATTACKBACK1,Q_R,	Q_R,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_READY,		LS_READY,		200	},	// LS_A_BACK_CR
+	{"RollStab",	BOTH_ROLL_STAB,		Q_R,	Q_R,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_READY,		LS_READY,		200	},	// LS_ROLL_STAB
+	{"Lunge Att",	BOTH_LUNGE2_B__T_,	Q_B,	Q_T,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_READY,		LS_READY,		200	},	// LS_A_LUNGE
+	{"Jump Att",	BOTH_FORCELEAP2_T__B_,Q_T,	Q_B,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_READY,		LS_READY,		200	},	// LS_A_JUMP_T__B_
+	{"Flip Stab",	BOTH_JUMPFLIPSTABDOWN,Q_R,	Q_T,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_READY,		LS_T1_T___R,	200	},	// LS_A_FLIP_STAB
+	{"Flip Slash",	BOTH_JUMPFLIPSLASHDOWN1,Q_L,Q_R,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_READY,		LS_T1__R_T_,	200	},	// LS_A_FLIP_SLASH
+	{"DualJump Atk",BOTH_JUMPATTACK6,	Q_R,	Q_BL,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_READY,		LS_T1_BL_TR,	200	},	// LS_JUMPATTACK_DUAL
+
+	{"DualJumpAtkL_A",BOTH_ARIAL_LEFT,	Q_R,	Q_TL,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_READY,		LS_A_TL2BR,		200	},	// LS_JUMPATTACK_ARIAL_LEFT
+	{"DualJumpAtkR_A",BOTH_ARIAL_RIGHT,	Q_R,	Q_TR,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_READY,		LS_A_TR2BL,		200	},	// LS_JUMPATTACK_ARIAL_RIGHT
+
+	{"DualJumpAtkL_A",BOTH_CARTWHEEL_LEFT,	Q_R,Q_TL,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_READY,		LS_T1_TL_BR,	200	},	// LS_JUMPATTACK_CART_LEFT
+	{"DualJumpAtkR_A",BOTH_CARTWHEEL_RIGHT,	Q_R,Q_TR,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_READY,		LS_T1_TR_BL,	200	},	// LS_JUMPATTACK_CART_RIGHT
+	
+	{"DualJumpAtkLStaff", BOTH_BUTTERFLY_FL1,Q_R,Q_L,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_READY,		LS_T1__L__R,	200	},	// LS_JUMPATTACK_STAFF_LEFT
+	{"DualJumpAtkRStaff", BOTH_BUTTERFLY_FR1,Q_R,Q_R,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_READY,		LS_T1__R__L,	200	},	// LS_JUMPATTACK_STAFF_RIGHT
+
+	{"ButterflyLeft", BOTH_BUTTERFLY_LEFT,Q_R,Q_L,		AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_READY,		LS_T1__L__R,	200	},	// LS_BUTTERFLY_LEFT
+	{"ButterflyRight", BOTH_BUTTERFLY_RIGHT,Q_R,Q_R,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_READY,		LS_T1__R__L,	200	},	// LS_BUTTERFLY_RIGHT
+	
+	{"BkFlip Atk",	BOTH_JUMPATTACK7,	Q_B,	Q_T,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_READY,		LS_T1_T___R,	200	},	// LS_A_BACKFLIP_ATK
+	{"DualSpinAtk",	BOTH_SPINATTACK6,	Q_R,	Q_R,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_READY,		LS_READY,		200	},	// LS_SPINATTACK_DUAL
+	{"StfSpinAtk",	BOTH_SPINATTACK7,	Q_L,	Q_R,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_READY,		LS_READY,		200	},	// LS_SPINATTACK
+	{"LngLeapAtk",	BOTH_FORCELONGLEAP_ATTACK,Q_R,Q_L,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_READY,		LS_READY,		200	},	// LS_LEAP_ATTACK
+	{"SwoopAtkR",	BOTH_VS_ATR_S,		Q_R,	Q_T,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_READY,		LS_READY,		200	},	// LS_SWOOP_ATTACK_RIGHT
+	{"SwoopAtkL",	BOTH_VS_ATL_S,		Q_L,	Q_T,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_READY,		LS_READY,		200	},	// LS_SWOOP_ATTACK_LEFT
+	{"TauntaunAtkR",BOTH_VT_ATR_S,		Q_R,	Q_T,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_READY,		LS_READY,		200	},	// LS_TAUNTAUN_ATTACK_RIGHT
+	{"TauntaunAtkL",BOTH_VT_ATL_S,		Q_L,	Q_T,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_READY,		LS_READY,		200	},	// LS_TAUNTAUN_ATTACK_LEFT
+	{"StfKickFwd",	BOTH_A7_KICK_F,		Q_R,	Q_R,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_READY,		LS_S_R2L,		200	},	// LS_KICK_F
+	{"StfKickBack",	BOTH_A7_KICK_B,		Q_R,	Q_R,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_READY,		LS_S_R2L,		200	},	// LS_KICK_B
+	{"StfKickRight",BOTH_A7_KICK_R,		Q_R,	Q_R,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_READY,		LS_S_R2L,		200	},	// LS_KICK_R
+	{"StfKickLeft",	BOTH_A7_KICK_L,		Q_R,	Q_R,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_READY,		LS_S_R2L,		200	},	// LS_KICK_L
+	{"StfKickSpin",	BOTH_A7_KICK_S,		Q_R,	Q_R,	AFLAG_ACTIVE,	100,	BLK_NO,		LS_READY,		LS_S_R2L,		200	},	// LS_KICK_S
+	{"StfKickBkFwd",BOTH_A7_KICK_BF,	Q_R,	Q_R,	AFLAG_ACTIVE,	100,	BLK_NO,		LS_READY,		LS_S_R2L,		200	},	// LS_KICK_BF
+	{"StfKickSplit",BOTH_A7_KICK_RL,	Q_R,	Q_R,	AFLAG_ACTIVE,	100,	BLK_NO,		LS_READY,		LS_S_R2L,		200	},	// LS_KICK_RL
+	{"StfKickFwdAir",BOTH_A7_KICK_F_AIR,Q_R,	Q_R,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_READY,		LS_S_R2L,		200	},	// LS_KICK_F_AIR
+	{"StfKickBackAir",BOTH_A7_KICK_B_AIR,Q_R,	Q_R,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_READY,		LS_S_R2L,		200	},	// LS_KICK_B_AIR
+	{"StfKickRightAir",BOTH_A7_KICK_R_AIR,Q_R,	Q_R,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_READY,		LS_S_R2L,		200	},	// LS_KICK_R_AIR
+	{"StfKickLeftAir",BOTH_A7_KICK_L_AIR,Q_R,	Q_R,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_READY,		LS_S_R2L,		200	},	// LS_KICK_L_AIR
+	{"StabDown",	BOTH_STABDOWN,		Q_R,	Q_R,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_READY,		LS_S_R2L,		200	},	// LS_STABDOWN
+	{"StabDownStf",	BOTH_STABDOWN_STAFF,Q_R,	Q_R,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_READY,		LS_S_R2L,		200	},	// LS_STABDOWN_STAFF
+	{"StabDownDual",BOTH_STABDOWN_DUAL,	Q_R,	Q_R,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_READY,		LS_S_R2L,		200	},	// LS_STABDOWN_DUAL
+	{"dualspinprot",BOTH_A6_SABERPROTECT,Q_R,	Q_R,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_READY,		LS_READY,		500	},	// LS_DUAL_SPIN_PROTECT
+	{"StfSoulCal",	BOTH_A7_SOULCAL,	Q_R,	Q_R,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_READY,		LS_READY,		500	},	// LS_STAFF_SOULCAL
+	{"specialfast",	BOTH_A1_SPECIAL,	Q_R,	Q_R,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_READY,		LS_READY,		2000},	// LS_A1_SPECIAL
+	{"specialmed",	BOTH_A2_SPECIAL,	Q_R,	Q_R,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_READY,		LS_READY,		2000},	// LS_A2_SPECIAL
+	{"specialstr",	BOTH_A3_SPECIAL,	Q_R,	Q_R,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_READY,		LS_READY,		2000},	// LS_A3_SPECIAL
+	{"upsidedwnatk",BOTH_FLIP_ATTACK7,	Q_R,	Q_R,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_READY,		LS_READY,		200},	// LS_UPSIDE_DOWN_ATTACK
+	{"pullatkstab",	BOTH_PULL_IMPALE_STAB,Q_R,	Q_R,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_READY,		LS_READY,		200},	// LS_PULL_ATTACK_STAB
+	{"pullatkswing",BOTH_PULL_IMPALE_SWING,Q_R,	Q_R,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_READY,		LS_READY,		200},	// LS_PULL_ATTACK_SWING
+	{"AloraSpinAtk",BOTH_ALORA_SPIN_SLASH,Q_R,	Q_R,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_READY,		LS_READY,		200	},	// LS_SPINATTACK_ALORA
+	{"Dual FB Atk",	BOTH_A6_FB,			Q_R,	Q_R,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_READY,		LS_READY,		200	},	// LS_DUAL_FB
+	{"Dual LR Atk",	BOTH_A6_LR,			Q_R,	Q_R,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_READY,		LS_READY,		200 },	// LS_DUAL_LR
+	{"StfHiltBash",	BOTH_A7_HILT,		Q_R,	Q_R,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_READY,		LS_READY,		200	},	// LS_HILT_BASH
+
+	//starts
+	{"TL2BR St",	BOTH_S1_S1_TL,		Q_R,	Q_TL,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_A_TL2BR,		LS_A_TL2BR,		200	},	// LS_S_TL2BR
+	{"L2R St",		BOTH_S1_S1__L,		Q_R,	Q_L,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_A_L2R,		LS_A_L2R,		200	},	// LS_S_L2R
+	{"BL2TR St",	BOTH_S1_S1_BL,		Q_R,	Q_BL,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_A_BL2TR,		LS_A_BL2TR,		200	},	// LS_S_BL2TR
+	{"BR2TL St",	BOTH_S1_S1_BR,		Q_R,	Q_BR,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_A_BR2TL,		LS_A_BR2TL,		200	},	// LS_S_BR2TL
+	{"R2L St",		BOTH_S1_S1__R,		Q_R,	Q_R,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_A_R2L,		LS_A_R2L,		200	},	// LS_S_R2L
+	{"TR2BL St",	BOTH_S1_S1_TR,		Q_R,	Q_TR,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_A_TR2BL,		LS_A_TR2BL,		200	},	// LS_S_TR2BL
+	{"T2B St",		BOTH_S1_S1_T_,		Q_R,	Q_T,	AFLAG_ACTIVE,	100,	BLK_TIGHT,	LS_A_T2B,		LS_A_T2B,		200	},	// LS_S_T2B
+	
+	//returns
+	{"TL2BR Ret",	BOTH_R1_BR_S1,		Q_BR,	Q_R,	AFLAG_FINISH,	100,	BLK_TIGHT,	LS_READY,		LS_READY,		200	},	// LS_R_TL2BR
+	{"L2R Ret",		BOTH_R1__R_S1,		Q_R,	Q_R,	AFLAG_FINISH,	100,	BLK_TIGHT,	LS_READY,		LS_READY,		200	},	// LS_R_L2R
+	{"BL2TR Ret",	BOTH_R1_TR_S1,		Q_TR,	Q_R,	AFLAG_FINISH,	100,	BLK_TIGHT,	LS_READY,		LS_READY,		200	},	// LS_R_BL2TR
+	{"BR2TL Ret",	BOTH_R1_TL_S1,		Q_TL,	Q_R,	AFLAG_FINISH,	100,	BLK_TIGHT,	LS_READY,		LS_READY,		200	},	// LS_R_BR2TL
+	{"R2L Ret",		BOTH_R1__L_S1,		Q_L,	Q_R,	AFLAG_FINISH,	100,	BLK_TIGHT,	LS_READY,		LS_READY,		200	},	// LS_R_R2L
+	{"TR2BL Ret",	BOTH_R1_BL_S1,		Q_BL,	Q_R,	AFLAG_FINISH,	100,	BLK_TIGHT,	LS_READY,		LS_READY,		200	},	// LS_R_TR2BL
+	{"T2B Ret",		BOTH_R1_B__S1,		Q_B,	Q_R,	AFLAG_FINISH,	100,	BLK_TIGHT,	LS_READY,		LS_READY,		200	},	// LS_R_T2B
+
+	//Transitions
+	{"BR2R Trans",	BOTH_T1_BR__R,		Q_BR,	Q_R,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_L2R,		LS_A_R2L,		150	},	//# Fast arc bottom right to right
+	{"BR2TR Trans",	BOTH_T1_BR_TR,		Q_BR,	Q_TR,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_BL2TR,		LS_A_TR2BL,		150	},	//# Fast arc bottom right to top right		(use: BOTH_T1_TR_BR)
+	{"BR2T Trans",	BOTH_T1_BR_T_,		Q_BR,	Q_T,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_BL2TR,		LS_A_T2B,		150	},	//# Fast arc bottom right to top			(use: BOTH_T1_T__BR)
+	{"BR2TL Trans",	BOTH_T1_BR_TL,		Q_BR,	Q_TL,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_BR2TL,		LS_A_TL2BR,		150	},	//# Fast weak spin bottom right to top left
+	{"BR2L Trans",	BOTH_T1_BR__L,		Q_BR,	Q_L,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_R2L,		LS_A_L2R,		150	},	//# Fast weak spin bottom right to left
+	{"BR2BL Trans",	BOTH_T1_BR_BL,		Q_BR,	Q_BL,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_TR2BL,		LS_A_BL2TR,		150	},	//# Fast weak spin bottom right to bottom left
+	{"R2BR Trans",	BOTH_T1__R_BR,		Q_R,	Q_BR,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_TL2BR,		LS_A_BR2TL,		150	},	//# Fast arc right to bottom right			(use: BOTH_T1_BR__R)
+	{"R2TR Trans",	BOTH_T1__R_TR,		Q_R,	Q_TR,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_BL2TR,		LS_A_TR2BL,		150	},	//# Fast arc right to top right
+	{"R2T Trans",	BOTH_T1__R_T_,		Q_R,	Q_T,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_BL2TR,		LS_A_T2B,		150	},	//# Fast ar right to top				(use: BOTH_T1_T___R)
+	{"R2TL Trans",	BOTH_T1__R_TL,		Q_R,	Q_TL,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_BR2TL,		LS_A_TL2BR,		150	},	//# Fast arc right to top left
+	{"R2L Trans",	BOTH_T1__R__L,		Q_R,	Q_L,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_R2L,		LS_A_L2R,		150	},	//# Fast weak spin right to left
+	{"R2BL Trans",	BOTH_T1__R_BL,		Q_R,	Q_BL,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_TR2BL,		LS_A_BL2TR,		150	},	//# Fast weak spin right to bottom left
+	{"TR2BR Trans",	BOTH_T1_TR_BR,		Q_TR,	Q_BR,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_TL2BR,		LS_A_BR2TL,		150	},	//# Fast arc top right to bottom right
+	{"TR2R Trans",	BOTH_T1_TR__R,		Q_TR,	Q_R,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_L2R,		LS_A_R2L,		150	},	//# Fast arc top right to right			(use: BOTH_T1__R_TR)
+	{"TR2T Trans",	BOTH_T1_TR_T_,		Q_TR,	Q_T,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_BL2TR,		LS_A_T2B,		150	},	//# Fast arc top right to top				(use: BOTH_T1_T__TR)
+	{"TR2TL Trans",	BOTH_T1_TR_TL,		Q_TR,	Q_TL,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_BR2TL,		LS_A_TL2BR,		150	},	//# Fast arc top right to top left
+	{"TR2L Trans",	BOTH_T1_TR__L,		Q_TR,	Q_L,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_R2L,		LS_A_L2R,		150	},	//# Fast arc top right to left
+	{"TR2BL Trans",	BOTH_T1_TR_BL,		Q_TR,	Q_BL,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_TR2BL,		LS_A_BL2TR,		150	},	//# Fast weak spin top right to bottom left
+	{"T2BR Trans",	BOTH_T1_T__BR,		Q_T,	Q_BR,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_TL2BR,		LS_A_BR2TL,		150	},	//# Fast arc top to bottom right
+	{"T2R Trans",	BOTH_T1_T___R,		Q_T,	Q_R,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_L2R,		LS_A_R2L,		150	},	//# Fast arc top to right
+	{"T2TR Trans",	BOTH_T1_T__TR,		Q_T,	Q_TR,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_BL2TR,		LS_A_TR2BL,		150	},	//# Fast arc top to top right
+	{"T2TL Trans",	BOTH_T1_T__TL,		Q_T,	Q_TL,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_BR2TL,		LS_A_TL2BR,		150	},	//# Fast arc top to top left
+	{"T2L Trans",	BOTH_T1_T___L,		Q_T,	Q_L,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_R2L,		LS_A_L2R,		150	},	//# Fast arc top to left
+	{"T2BL Trans",	BOTH_T1_T__BL,		Q_T,	Q_BL,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_TR2BL,		LS_A_BL2TR,		150	},	//# Fast arc top to bottom left
+	{"TL2BR Trans",	BOTH_T1_TL_BR,		Q_TL,	Q_BR,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_TL2BR,		LS_A_BR2TL,		150	},	//# Fast weak spin top left to bottom right
+	{"TL2R Trans",	BOTH_T1_TL__R,		Q_TL,	Q_R,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_L2R,		LS_A_R2L,		150	},	//# Fast arc top left to right			(use: BOTH_T1__R_TL)
+	{"TL2TR Trans",	BOTH_T1_TL_TR,		Q_TL,	Q_TR,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_BL2TR,		LS_A_TR2BL,		150	},	//# Fast arc top left to top right			(use: BOTH_T1_TR_TL)
+	{"TL2T Trans",	BOTH_T1_TL_T_,		Q_TL,	Q_T,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_BL2TR,		LS_A_T2B,		150	},	//# Fast arc top left to top				(use: BOTH_T1_T__TL)
+	{"TL2L Trans",	BOTH_T1_TL__L,		Q_TL,	Q_L,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_R2L,		LS_A_L2R,		150	},	//# Fast arc top left to left				(use: BOTH_T1__L_TL)
+	{"TL2BL Trans",	BOTH_T1_TL_BL,		Q_TL,	Q_BL,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_TR2BL,		LS_A_BL2TR,		150	},	//# Fast arc top left to bottom left
+	{"L2BR Trans",	BOTH_T1__L_BR,		Q_L,	Q_BR,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_TL2BR,		LS_A_BR2TL,		150	},	//# Fast weak spin left to bottom right
+	{"L2R Trans",	BOTH_T1__L__R,		Q_L,	Q_R,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_L2R,		LS_A_R2L,		150	},	//# Fast weak spin left to right
+	{"L2TR Trans",	BOTH_T1__L_TR,		Q_L,	Q_TR,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_BL2TR,		LS_A_TR2BL,		150	},	//# Fast arc left to top right			(use: BOTH_T1_TR__L)
+	{"L2T Trans",	BOTH_T1__L_T_,		Q_L,	Q_T,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_BL2TR,		LS_A_T2B,		150	},	//# Fast arc left to top				(use: BOTH_T1_T___L)
+	{"L2TL Trans",	BOTH_T1__L_TL,		Q_L,	Q_TL,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_BR2TL,		LS_A_TL2BR,		150	},	//# Fast arc left to top left
+	{"L2BL Trans",	BOTH_T1__L_BL,		Q_L,	Q_BL,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_TR2BL,		LS_A_BL2TR,		150	},	//# Fast arc left to bottom left			(use: BOTH_T1_BL__L)
+	{"BL2BR Trans",	BOTH_T1_BL_BR,		Q_BL,	Q_BR,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_TL2BR,		LS_A_BR2TL,		150	},	//# Fast weak spin bottom left to bottom right
+	{"BL2R Trans",	BOTH_T1_BL__R,		Q_BL,	Q_R,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_L2R,		LS_A_R2L,		150	},	//# Fast weak spin bottom left to right
+	{"BL2TR Trans",	BOTH_T1_BL_TR,		Q_BL,	Q_TR,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_BL2TR,		LS_A_TR2BL,		150	},	//# Fast weak spin bottom left to top right
+	{"BL2T Trans",	BOTH_T1_BL_T_,		Q_BL,	Q_T,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_BL2TR,		LS_A_T2B,		150	},	//# Fast arc bottom left to top			(use: BOTH_T1_T__BL)
+	{"BL2TL Trans",	BOTH_T1_BL_TL,		Q_BL,	Q_TL,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_BR2TL,		LS_A_TL2BR,		150	},	//# Fast arc bottom left to top left		(use: BOTH_T1_TL_BL)
+	{"BL2L Trans",	BOTH_T1_BL__L,		Q_BL,	Q_L,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_R2L,		LS_A_L2R,		150	},	//# Fast arc bottom left to left
+
+	//Bounces
+	{"Bounce BR",	BOTH_B1_BR___,		Q_BR,	Q_BR,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_TL2BR,		LS_T1_BR_TR,	150	},	
+	{"Bounce R",	BOTH_B1__R___,		Q_R,	Q_R,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_L2R,		LS_T1__R__L,	150	},	
+	{"Bounce TR",	BOTH_B1_TR___,		Q_TR,	Q_TR,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_BL2TR,		LS_T1_TR_TL,	150	},	
+	{"Bounce T",	BOTH_B1_T____,		Q_T,	Q_T,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_BL2TR,		LS_T1_T__BL,	150	},	
+	{"Bounce TL",	BOTH_B1_TL___,		Q_TL,	Q_TL,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_BR2TL,		LS_T1_TL_TR,	150	},	
+	{"Bounce L",	BOTH_B1__L___,		Q_L,	Q_L,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_R2L,		LS_T1__L__R,	150	},	
+	{"Bounce BL",	BOTH_B1_BL___,		Q_BL,	Q_BL,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_TR2BL,		LS_T1_BL_TR,	150	},	
+
+	//Deflected attacks (like bounces, but slide off enemy saber, not straight back)
+	{"Deflect BR",	BOTH_D1_BR___,		Q_BR,	Q_BR,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_TL2BR,		LS_T1_BR_TR,	150	},	
+	{"Deflect R",	BOTH_D1__R___,		Q_R,	Q_R,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_L2R,		LS_T1__R__L,	150	},	
+	{"Deflect TR",	BOTH_D1_TR___,		Q_TR,	Q_TR,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_BL2TR,		LS_T1_TR_TL,	150	},	
+	{"Deflect T",	BOTH_B1_T____,		Q_T,	Q_T,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_BL2TR,		LS_T1_T__BL,	150	},	
+	{"Deflect TL",	BOTH_D1_TL___,		Q_TL,	Q_TL,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_BR2TL,		LS_T1_TL_TR,	150	},	
+	{"Deflect L",	BOTH_D1__L___,		Q_L,	Q_L,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_R2L,		LS_T1__L__R,	150	},	
+	{"Deflect BL",	BOTH_D1_BL___,		Q_BL,	Q_BL,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_TR2BL,		LS_T1_BL_TR,	150	},	
+	{"Deflect B",	BOTH_D1_B____,		Q_B,	Q_B,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_R_BL2TR,		LS_T1_T__BL,	150	},	
+
+	//Reflected attacks
+	{"Reflected BR",BOTH_V1_BR_S1,		Q_BR,	Q_BR,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_READY,		LS_READY,	150	},//	LS_V1_BR
+	{"Reflected R",	BOTH_V1__R_S1,		Q_R,	Q_R,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_READY,		LS_READY,	150	},//	LS_V1__R
+	{"Reflected TR",BOTH_V1_TR_S1,		Q_TR,	Q_TR,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_READY,		LS_READY,	150	},//	LS_V1_TR
+	{"Reflected T",	BOTH_V1_T__S1,		Q_T,	Q_T,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_READY,		LS_READY,	150	},//	LS_V1_T_
+	{"Reflected TL",BOTH_V1_TL_S1,		Q_TL,	Q_TL,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_READY,		LS_READY,	150	},//	LS_V1_TL
+	{"Reflected L",	BOTH_V1__L_S1,		Q_L,	Q_L,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_READY,		LS_READY,	150	},//	LS_V1__L
+	{"Reflected BL",BOTH_V1_BL_S1,		Q_BL,	Q_BL,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_READY,		LS_READY,	150	},//	LS_V1_BL
+	{"Reflected B",	BOTH_V1_B__S1,		Q_B,	Q_B,	AFLAG_ACTIVE,	100,	BLK_NO,	LS_READY,		LS_READY,	150	},//	LS_V1_B_
+
+	// Broken parries
+	{"BParry Top",	BOTH_H1_S1_T_,		Q_T,	Q_B,	AFLAG_ACTIVE,	50,		BLK_NO,	LS_READY,		LS_READY,		150	},	// LS_PARRY_UP,
+	{"BParry UR",	BOTH_H1_S1_TR,		Q_TR,	Q_BL,	AFLAG_ACTIVE,	50,		BLK_NO,	LS_READY,		LS_READY,		150	},	// LS_PARRY_UR,
+	{"BParry UL",	BOTH_H1_S1_TL,		Q_TL,	Q_BR,	AFLAG_ACTIVE,	50,		BLK_NO,	LS_READY,		LS_READY,		150	},	// LS_PARRY_UL,
+	{"BParry LR",	BOTH_H1_S1_BL,		Q_BL,	Q_TR,	AFLAG_ACTIVE,	50,		BLK_NO,	LS_READY,		LS_READY,		150	},	// LS_PARRY_LR,
+	{"BParry Bot",	BOTH_H1_S1_B_,		Q_B,	Q_T,	AFLAG_ACTIVE,	50,		BLK_NO,	LS_READY,		LS_READY,		150	},	// LS_PARRY_LL
+	{"BParry LL",	BOTH_H1_S1_BR,		Q_BR,	Q_TL,	AFLAG_ACTIVE,	50,		BLK_NO,	LS_READY,		LS_READY,		150	},	// LS_PARRY_LL
+
+	// Knockaways
+	{"Knock Top",	BOTH_K1_S1_T_,		Q_R,	Q_T,	AFLAG_ACTIVE,	50,		BLK_WIDE,	LS_R_BL2TR,		LS_T1_T__BR,		150	},	// LS_PARRY_UP,
+	{"Knock UR",	BOTH_K1_S1_TR,		Q_R,	Q_TR,	AFLAG_ACTIVE,	50,		BLK_WIDE,	LS_R_BL2TR,		LS_T1_TR__R,		150	},	// LS_PARRY_UR,
+	{"Knock UL",	BOTH_K1_S1_TL,		Q_R,	Q_TL,	AFLAG_ACTIVE,	50,		BLK_WIDE,	LS_R_BR2TL,		LS_T1_TL__L,		150	},	// LS_PARRY_UL,
+	{"Knock LR",	BOTH_K1_S1_BL,		Q_R,	Q_BL,	AFLAG_ACTIVE,	50,		BLK_WIDE,	LS_R_TL2BR,		LS_T1_BL_TL,		150	},	// LS_PARRY_LR,
+	{"Knock LL",	BOTH_K1_S1_BR,		Q_R,	Q_BR,	AFLAG_ACTIVE,	50,		BLK_WIDE,	LS_R_TR2BL,		LS_T1_BR_TR,		150	},	// LS_PARRY_LL
+
+	// Parry
+	{"Parry Top",	BOTH_P1_S1_T_,		Q_R,	Q_T,	AFLAG_ACTIVE,	50,		BLK_WIDE,	LS_R_BL2TR,		LS_A_T2B,		150	},	// LS_PARRY_UP,
+	{"Parry UR",	BOTH_P1_S1_TR,		Q_R,	Q_TL,	AFLAG_ACTIVE,	50,		BLK_WIDE,	LS_R_BL2TR,		LS_A_TR2BL,		150	},	// LS_PARRY_UR,
+	{"Parry UL",	BOTH_P1_S1_TL,		Q_R,	Q_TR,	AFLAG_ACTIVE,	50,		BLK_WIDE,	LS_R_BR2TL,		LS_A_TL2BR,		150	},	// LS_PARRY_UL,
+	{"Parry LR",	BOTH_P1_S1_BL,		Q_R,	Q_BR,	AFLAG_ACTIVE,	50,		BLK_WIDE,	LS_R_TL2BR,		LS_A_BR2TL,		150	},	// LS_PARRY_LR,
+	{"Parry LL",	BOTH_P1_S1_BR,		Q_R,	Q_BL,	AFLAG_ACTIVE,	50,		BLK_WIDE,	LS_R_TR2BL,		LS_A_BL2TR,		150	},	// LS_PARRY_LL
+
+	// Reflecting a missile
+	{"Reflect Top",	BOTH_P1_S1_T_,		Q_R,	Q_T,	AFLAG_ACTIVE,	50,		BLK_WIDE,	LS_R_BL2TR,		LS_A_T2B,		300	},	// LS_PARRY_UP,
+	{"Reflect UR",	BOTH_P1_S1_TL,		Q_R,	Q_TR,	AFLAG_ACTIVE,	50,		BLK_WIDE,	LS_R_BR2TL,		LS_A_TL2BR,		300	},	// LS_PARRY_UR,
+	{"Reflect UL",	BOTH_P1_S1_TR,		Q_R,	Q_TL,	AFLAG_ACTIVE,	50,		BLK_WIDE,	LS_R_BL2TR,		LS_A_TR2BL,		300	},	// LS_PARRY_UL,
+	{"Reflect LR",	BOTH_P1_S1_BR,		Q_R,	Q_BL,	AFLAG_ACTIVE,	50,		BLK_WIDE,	LS_R_TR2BL,		LS_A_BL2TR,		300	},	// LS_PARRY_LR
+	{"Reflect LL",	BOTH_P1_S1_BL,		Q_R,	Q_BR,	AFLAG_ACTIVE,	50,		BLK_WIDE,	LS_R_TL2BR,		LS_A_BR2TL,		300	},	// LS_PARRY_LL,
+};
+
+
+int transitionMove[Q_NUM_QUADS][Q_NUM_QUADS] = 
+{
+	LS_NONE,	//Can't transition to same pos!
+	LS_T1_BR__R,//40
+	LS_T1_BR_TR,
+	LS_T1_BR_T_,
+	LS_T1_BR_TL,
+	LS_T1_BR__L,
+	LS_T1_BR_BL,
+	LS_NONE,	//No transitions to bottom, and no anims start there, so shouldn't need any
+	LS_T1__R_BR,//46
+	LS_NONE,	//Can't transition to same pos!
+	LS_T1__R_TR,
+	LS_T1__R_T_,
+	LS_T1__R_TL,
+	LS_T1__R__L,
+	LS_T1__R_BL,
+	LS_NONE,	//No transitions to bottom, and no anims start there, so shouldn't need any
+	LS_T1_TR_BR,//52
+	LS_T1_TR__R,
+	LS_NONE,	//Can't transition to same pos!
+	LS_T1_TR_T_,
+	LS_T1_TR_TL,
+	LS_T1_TR__L,
+	LS_T1_TR_BL,
+	LS_NONE,	//No transitions to bottom, and no anims start there, so shouldn't need any
+	LS_T1_T__BR,//58
+	LS_T1_T___R,
+	LS_T1_T__TR,
+	LS_NONE,	//Can't transition to same pos!
+	LS_T1_T__TL,
+	LS_T1_T___L,
+	LS_T1_T__BL,
+	LS_NONE,	//No transitions to bottom, and no anims start there, so shouldn't need any
+	LS_T1_TL_BR,//64
+	LS_T1_TL__R,
+	LS_T1_TL_TR,
+	LS_T1_TL_T_,
+	LS_NONE,	//Can't transition to same pos!
+	LS_T1_TL__L,
+	LS_T1_TL_BL,
+	LS_NONE,	//No transitions to bottom, and no anims start there, so shouldn't need any
+	LS_T1__L_BR,//70
+	LS_T1__L__R,
+	LS_T1__L_TR,
+	LS_T1__L_T_,
+	LS_T1__L_TL,
+	LS_NONE,	//Can't transition to same pos!
+	LS_T1__L_BL,
+	LS_NONE,	//No transitions to bottom, and no anims start there, so shouldn't need any
+	LS_T1_BL_BR,//76
+	LS_T1_BL__R,
+	LS_T1_BL_TR,
+	LS_T1_BL_T_,
+	LS_T1_BL_TL,
+	LS_T1_BL__L,
+	LS_NONE,	//Can't transition to same pos!
+	LS_NONE,	//No transitions to bottom, and no anims start there, so shouldn't need any
+	LS_T1_BL_BR,//NOTE: there are no transitions from bottom, so re-use the bottom right transitions
+	LS_T1_BR__R,
+	LS_T1_BR_TR,
+	LS_T1_BR_T_,
+	LS_T1_BR_TL,
+	LS_T1_BR__L,
+	LS_T1_BR_BL,
+	LS_NONE		//No transitions to bottom, and no anims start there, so shouldn't need any
+};
+
+saberMoveName_t PM_AttackMoveForQuad( int quad )
+{
+	switch ( quad )
+	{
+	case Q_B:
+	case Q_BR:
+		return LS_A_BR2TL;
+		break;
+	case Q_R:
+		return LS_A_R2L;
+		break;
+	case Q_TR:
+		return LS_A_TR2BL;
+		break;
+	case Q_T:
+		return LS_A_T2B;
+		break;
+	case Q_TL:
+		return LS_A_TL2BR;
+		break;
+	case Q_L:
+		return LS_A_L2R;
+		break;
+	case Q_BL:
+		return LS_A_BL2TR;
+		break;
+	}
+	return LS_NONE;
+}
+
+qboolean PM_SaberKataDone(int curmove, int newmove);
+
+int PM_SaberAnimTransitionAnim( int curmove, int newmove )
+{
+	int retmove = newmove;
+	if ( curmove == LS_READY )
+	{//just standing there
+		switch ( newmove )
+		{
+		case LS_A_TL2BR:
+		case LS_A_L2R:
+		case LS_A_BL2TR:
+		case LS_A_BR2TL:
+		case LS_A_R2L:
+		case LS_A_TR2BL:
+		case LS_A_T2B:
+			//transition is the start
+			retmove = LS_S_TL2BR + (newmove-LS_A_TL2BR);
+			break;
+		}
+	}
+	else
+	{
+		switch ( newmove )
+		{
+		//transitioning to ready pose
+		case LS_READY:
+			switch ( curmove )
+			{
+			//transitioning from an attack
+			case LS_A_TL2BR:
+			case LS_A_L2R:
+			case LS_A_BL2TR:
+			case LS_A_BR2TL:
+			case LS_A_R2L:
+			case LS_A_TR2BL:
+			case LS_A_T2B:
+				//transition is the return
+				retmove = LS_R_TL2BR + (newmove-LS_A_TL2BR);
+				break;
+			}
+			break;
+		//transitioning to an attack
+		case LS_A_TL2BR:
+		case LS_A_L2R:
+		case LS_A_BL2TR:
+		case LS_A_BR2TL:
+		case LS_A_R2L:
+		case LS_A_TR2BL:
+		case LS_A_T2B:
+			if ( newmove == curmove )
+			{
+				//going into an attack
+				if ( PM_SaberKataDone( curmove, newmove ) )
+				{//done with this kata, must return to ready before attack again
+					retmove = LS_R_TL2BR + (newmove-LS_A_TL2BR);
+				}
+				else
+				{//okay to chain to another attack
+					retmove = transitionMove[saberMoveData[curmove].endQuad][saberMoveData[newmove].startQuad];
+				}
+			}
+			else if ( saberMoveData[curmove].endQuad == saberMoveData[newmove].startQuad )
+			{//new move starts from same quadrant
+				retmove = newmove;
+			}
+			else
+			{
+				switch ( curmove )
+				{
+				//transitioning from an attack
+				case LS_A_TL2BR:
+				case LS_A_L2R:
+				case LS_A_BL2TR:
+				case LS_A_BR2TL:
+				case LS_A_R2L:
+				case LS_A_TR2BL:
+				case LS_A_T2B:
+				case LS_D1_BR:
+				case LS_D1__R:
+				case LS_D1_TR:
+				case LS_D1_T_:
+				case LS_D1_TL:
+				case LS_D1__L:
+				case LS_D1_BL:
+				case LS_D1_B_:
+					retmove = transitionMove[saberMoveData[curmove].endQuad][saberMoveData[newmove].startQuad];
+					break;
+				//transitioning from a return
+				case LS_R_TL2BR:
+				case LS_R_L2R:
+				case LS_R_BL2TR:
+				case LS_R_BR2TL:
+				case LS_R_R2L:
+				case LS_R_TR2BL:
+				case LS_R_T2B:
+				//transitioning from a bounce
+				/*
+				case LS_BOUNCE_UL2LL:
+				case LS_BOUNCE_LL2UL:
+				case LS_BOUNCE_L2LL:
+				case LS_BOUNCE_L2UL:
+				case LS_BOUNCE_UR2LR:
+				case LS_BOUNCE_LR2UR:
+				case LS_BOUNCE_R2LR:
+				case LS_BOUNCE_R2UR:
+				case LS_BOUNCE_TOP:
+				case LS_OVER_UR2UL:
+				case LS_OVER_UL2UR:
+				case LS_BOUNCE_UR:
+				case LS_BOUNCE_UL:
+				case LS_BOUNCE_LR:
+				case LS_BOUNCE_LL:
+				*/
+				//transitioning from a parry/reflection/knockaway/broken parry
+				case LS_PARRY_UP:
+				case LS_PARRY_UR:
+				case LS_PARRY_UL:
+				case LS_PARRY_LR:
+				case LS_PARRY_LL:
+				case LS_REFLECT_UP:
+				case LS_REFLECT_UR:
+				case LS_REFLECT_UL:
+				case LS_REFLECT_LR:
+				case LS_REFLECT_LL:
+				case LS_K1_T_:
+				case LS_K1_TR:
+				case LS_K1_TL:
+				case LS_K1_BR:
+				case LS_K1_BL:
+				case LS_V1_BR:
+				case LS_V1__R:
+				case LS_V1_TR:
+				case LS_V1_T_:
+				case LS_V1_TL:
+				case LS_V1__L:
+				case LS_V1_BL:
+				case LS_V1_B_:
+				case LS_H1_T_:
+				case LS_H1_TR:
+				case LS_H1_TL:
+				case LS_H1_BR:
+				case LS_H1_BL:
+					retmove = transitionMove[saberMoveData[curmove].endQuad][saberMoveData[newmove].startQuad];
+					break;
+				//NB: transitioning from transitions is fine
+				}
+			}
+			break;
+		//transitioning to any other anim is not supported
+		}
+	}
+
+	if ( retmove == LS_NONE )
+	{
+		return newmove;
+	}
+
+	return retmove;
+}
+
+extern qboolean BG_InKnockDown( int anim );
+saberMoveName_t PM_CheckStabDown( void )
+{
+	vec3_t faceFwd, facingAngles;
+	vec3_t fwd;
+	bgEntity_t *ent = NULL;
+	trace_t tr;
+	//yeah, vm's may complain, but.. who cares!
+	vec3_t trmins = {-15, -15, -15};
+	vec3_t trmaxs = {15, 15, 15};
+
+	if ( pm->ps->groundEntityNum == ENTITYNUM_NONE )
+	{//sorry must be on ground!
+		return LS_NONE;
+	}
+	if ( pm->ps->clientNum < MAX_CLIENTS )
+	{//player
+		pm->ps->velocity[2] = 0;
+		pm->cmd.upmove = 0;
+	}
+
+	VectorSet(facingAngles, 0, pm->ps->viewangles[YAW], 0);
+	AngleVectors( facingAngles, faceFwd, NULL, NULL );
+
+	//FIXME: need to only move forward until we bump into our target...?
+	VectorMA(pm->ps->origin, 164.0f, faceFwd, fwd);
+
+	pm->trace(&tr, pm->ps->origin, trmins, trmaxs, fwd, pm->ps->clientNum, MASK_PLAYERSOLID);
+
+	if (tr.entityNum < ENTITYNUM_WORLD)
+	{
+		ent = PM_BGEntForNum(tr.entityNum);
+	}
+
+	if ( ent &&
+		(ent->s.eType == ET_PLAYER || ent->s.eType == ET_NPC) &&
+		BG_InKnockDown( ent->s.legsAnim ) )
+	{//guy is on the ground below me, do a top-down attack
+		if ( pm->ps->fd.saberAnimLevel == SS_DUAL )
+		{
+			return LS_STABDOWN_DUAL;
+		}
+		else if ( pm->ps->fd.saberAnimLevel == SS_STAFF )
+		{
+			return LS_STABDOWN_STAFF;
+		}
+		else
+		{
+			return LS_STABDOWN;
+		}
+	}
+	return LS_NONE;
+}
+
+int PM_SaberMoveQuadrantForMovement( usercmd_t *ucmd )
+{
+	if ( ucmd->rightmove > 0 )
+	{//moving right
+		if ( ucmd->forwardmove > 0 )
+		{//forward right = TL2BR slash
+			return Q_TL;
+		}
+		else if ( ucmd->forwardmove < 0 )
+		{//backward right = BL2TR uppercut
+			return Q_BL;
+		}
+		else
+		{//just right is a left slice
+			return Q_L;
+		}
+	}
+	else if ( ucmd->rightmove < 0 )
+	{//moving left
+		if ( ucmd->forwardmove > 0 )
+		{//forward left = TR2BL slash
+			return Q_TR;
+		}
+		else if ( ucmd->forwardmove < 0 )
+		{//backward left = BR2TL uppercut
+			return Q_BR;
+		}
+		else
+		{//just left is a right slice
+			return Q_R;
+		}
+	}
+	else
+	{//not moving left or right
+		if ( ucmd->forwardmove > 0 )
+		{//forward= T2B slash
+			return Q_T;
+		}
+		else if ( ucmd->forwardmove < 0 )
+		{//backward= T2B slash	//or B2T uppercut?
+			return Q_T;
+		}
+		else
+		{//Not moving at all
+			return Q_R;
+		}
+	}
+}
+
+//===================================================================
+qboolean PM_SaberInBounce( int move )
+{
+	if ( move >= LS_B1_BR && move <= LS_B1_BL )
+	{
+		return qtrue;
+	}
+	if ( move >= LS_D1_BR && move <= LS_D1_BL )
+	{
+		return qtrue;
+	}
+	return qfalse;
+}
+
+qboolean PM_SaberInTransition( int move );
+
+int saberMoveTransitionAngle[Q_NUM_QUADS][Q_NUM_QUADS] = 
+{
+	0,//Q_BR,Q_BR,
+	45,//Q_BR,Q_R,
+	90,//Q_BR,Q_TR,
+	135,//Q_BR,Q_T,
+	180,//Q_BR,Q_TL,
+	215,//Q_BR,Q_L,
+	270,//Q_BR,Q_BL,
+	45,//Q_BR,Q_B,
+	45,//Q_R,Q_BR,
+	0,//Q_R,Q_R,
+	45,//Q_R,Q_TR,
+	90,//Q_R,Q_T,
+	135,//Q_R,Q_TL,
+	180,//Q_R,Q_L,
+	215,//Q_R,Q_BL,
+	90,//Q_R,Q_B,
+	90,//Q_TR,Q_BR,
+	45,//Q_TR,Q_R,
+	0,//Q_TR,Q_TR,
+	45,//Q_TR,Q_T,
+	90,//Q_TR,Q_TL,
+	135,//Q_TR,Q_L,
+	180,//Q_TR,Q_BL,
+	135,//Q_TR,Q_B,
+	135,//Q_T,Q_BR,
+	90,//Q_T,Q_R,
+	45,//Q_T,Q_TR,
+	0,//Q_T,Q_T,
+	45,//Q_T,Q_TL,
+	90,//Q_T,Q_L,
+	135,//Q_T,Q_BL,
+	180,//Q_T,Q_B,
+	180,//Q_TL,Q_BR,
+	135,//Q_TL,Q_R,
+	90,//Q_TL,Q_TR,
+	45,//Q_TL,Q_T,
+	0,//Q_TL,Q_TL,
+	45,//Q_TL,Q_L,
+	90,//Q_TL,Q_BL,
+	135,//Q_TL,Q_B,
+	215,//Q_L,Q_BR,
+	180,//Q_L,Q_R,
+	135,//Q_L,Q_TR,
+	90,//Q_L,Q_T,
+	45,//Q_L,Q_TL,
+	0,//Q_L,Q_L,
+	45,//Q_L,Q_BL,
+	90,//Q_L,Q_B,
+	270,//Q_BL,Q_BR,
+	215,//Q_BL,Q_R,
+	180,//Q_BL,Q_TR,
+	135,//Q_BL,Q_T,
+	90,//Q_BL,Q_TL,
+	45,//Q_BL,Q_L,
+	0,//Q_BL,Q_BL,
+	45,//Q_BL,Q_B,
+	45,//Q_B,Q_BR,
+	90,//Q_B,Q_R,
+	135,//Q_B,Q_TR,
+	180,//Q_B,Q_T,
+	135,//Q_B,Q_TL,
+	90,//Q_B,Q_L,
+	45,//Q_B,Q_BL,
+	0//Q_B,Q_B,
+};
+
+int PM_SaberAttackChainAngle( int move1, int move2 )
+{
+	if ( move1 == -1 || move2 == -1 )
+	{
+		return -1;
+	}
+	return saberMoveTransitionAngle[saberMoveData[move1].endQuad][saberMoveData[move2].startQuad];
+}
+
+qboolean PM_SaberKataDone(int curmove, int newmove)
+{
+	if (pm->ps->m_iVehicleNum)
+	{ //never continue kata on vehicle
+		if (pm->ps->saberAttackChainCount > 0)
+		{
+			return qtrue;
+		}
+	}
+
+	if ( pm->ps->fd.saberAnimLevel == SS_DESANN || pm->ps->fd.saberAnimLevel == SS_TAVION )
+	{//desann and tavion can link up as many attacks as they want
+		return qfalse;
+	}
+
+	if ( pm->ps->fd.saberAnimLevel == SS_STAFF )
+	{
+		//TEMP: for now, let staff attacks infinitely chain
+		return qfalse;
+	}
+	else if ( pm->ps->fd.saberAnimLevel == SS_DUAL )
+	{
+		//TEMP: for now, let staff attacks infinitely chain
+		return qfalse;
+	}
+	else if ( pm->ps->fd.saberAnimLevel == FORCE_LEVEL_3 )
+	{
+		if ( curmove == LS_NONE || newmove == LS_NONE )
+		{
+			if ( pm->ps->fd.saberAnimLevel >= FORCE_LEVEL_3 && pm->ps->saberAttackChainCount > PM_irand_timesync( 0, 1 ) )
+			{
+				return qtrue;
+			}
+		}
+		else if ( pm->ps->saberAttackChainCount > PM_irand_timesync( 2, 3 ) )
+		{
+			return qtrue;
+		}
+		else if ( pm->ps->saberAttackChainCount > 0 )
+		{
+			int chainAngle = PM_SaberAttackChainAngle( curmove, newmove );
+			if ( chainAngle < 135 || chainAngle > 215 )
+			{//if trying to chain to a move that doesn't continue the momentum
+				return qtrue;
+			}
+			else if ( chainAngle == 180 )
+			{//continues the momentum perfectly, allow it to chain 66% of the time
+				if ( pm->ps->saberAttackChainCount > 1 )
+				{
+					return qtrue;
+				}
+			}
+			else
+			{//would continue the movement somewhat, 50% chance of continuing
+				if ( pm->ps->saberAttackChainCount > 2 )
+				{
+					return qtrue;
+				}
+			}
+		}
+	}
+	else 
+	{//Perhaps have chainAngle influence fast and medium chains as well? For now, just do level 3.
+		if (newmove == LS_A_TL2BR ||
+			newmove == LS_A_L2R ||
+			newmove == LS_A_BL2TR ||
+			newmove == LS_A_BR2TL ||
+			newmove == LS_A_R2L ||
+			newmove == LS_A_TR2BL )
+		{ //lower chaining tolerance for spinning saber anims
+			int chainTolerance;
+
+			if (pm->ps->fd.saberAnimLevel == FORCE_LEVEL_1)
+			{
+				chainTolerance = 5;
+			}
+			else
+			{
+				chainTolerance = 3;
+			}
+
+			if (pm->ps->saberAttackChainCount >= chainTolerance && PM_irand_timesync(1, pm->ps->saberAttackChainCount) > chainTolerance)
+			{
+				return qtrue;
+			}
+		}
+		if ( pm->ps->fd.saberAnimLevel == FORCE_LEVEL_2 && pm->ps->saberAttackChainCount > PM_irand_timesync( 2, 5 ) )
+		{
+			return qtrue;
+		}
+	}
+	return qfalse;
+}
+
+void PM_SetAnimFrame( playerState_t *gent, int frame, qboolean torso, qboolean legs )
+{
+	gent->saberLockFrame = frame;
+}
+
+int PM_SaberLockWinAnim( qboolean victory, qboolean superBreak )
+{
+	int winAnim = -1;
+	switch ( pm->ps->torsoAnim )
+	{
+/*
+	default:
+#ifndef FINAL_BUILD
+		Com_Printf( S_COLOR_RED"ERROR-PM_SaberLockBreak: %s not in saberlock anim, anim = (%d)%s\n", pm->gent->NPC_type, pm->ps->torsoAnim, animTable[pm->ps->torsoAnim].name );
+#endif
+*/
+	case BOTH_BF2LOCK:
+		if ( superBreak )
+		{
+			winAnim = BOTH_LK_S_S_T_SB_1_W;
+		}
+		else if ( !victory )
+		{
+			winAnim = BOTH_BF1BREAK;
+		}
+		else
+		{
+			pm->ps->saberMove = LS_A_T2B;
+			winAnim = BOTH_A3_T__B_;
+		}
+		break;
+	case BOTH_BF1LOCK:
+		if ( superBreak )
+		{
+			winAnim = BOTH_LK_S_S_T_SB_1_W;
+		}
+		else if ( !victory )
+		{
+			winAnim = BOTH_KNOCKDOWN4;
+		}
+		else
+		{
+			pm->ps->saberMove = LS_K1_T_;
+			winAnim = BOTH_K1_S1_T_;
+		}
+		break;
+	case BOTH_CWCIRCLELOCK:
+		if ( superBreak )
+		{
+			winAnim = BOTH_LK_S_S_S_SB_1_W;
+		}
+		else if ( !victory )
+		{
+			pm->ps->saberMove = LS_V1_BL;//pm->ps->saberBounceMove = 
+			pm->ps->saberBlocked = BLOCKED_PARRY_BROKEN;
+			winAnim = BOTH_V1_BL_S1;
+		}
+		else
+		{
+			winAnim = BOTH_CWCIRCLEBREAK;
+		}
+		break;
+	case BOTH_CCWCIRCLELOCK:
+		if ( superBreak )
+		{
+			winAnim = BOTH_LK_S_S_S_SB_1_W;
+		}
+		else if ( !victory )
+		{
+			pm->ps->saberMove = LS_V1_BR;//pm->ps->saberBounceMove = 
+			pm->ps->saberBlocked = BLOCKED_PARRY_BROKEN;
+			winAnim = BOTH_V1_BR_S1;
+		}
+		else
+		{
+			winAnim = BOTH_CCWCIRCLEBREAK;
+		}
+		break;
+	default:
+		//must be using new system:
+		break;
+	}
+	if ( winAnim != -1 )
+	{
+		PM_SetAnim( SETANIM_BOTH, winAnim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD, 0 );
+		pm->ps->weaponTime = pm->ps->torsoTimer;
+		pm->ps->saberBlocked = BLOCKED_NONE;
+		pm->ps->weaponstate = WEAPON_FIRING;
+		/*
+		if ( superBreak 
+			&& winAnim != BOTH_LK_ST_DL_T_SB_1_W )
+		{//going to attack with saber, do a saber trail
+			pm->ps->SaberActivateTrail( 200 );
+		}
+		*/
+	}
+	return winAnim;
+}
+
+#ifdef QAGAME //including game headers on cgame is FORBIDDEN ^_^
+
+// Need to avoid nesting namespaces!
+#include "../namespace_end.h"
+
+#include "g_local.h"
+extern void NPC_SetAnim(gentity_t *ent, int setAnimParts, int anim, int setAnimFlags);
+extern gentity_t g_entities[];
+
+#include "../namespace_begin.h"
+
+#endif
+int PM_SaberLockLoseAnim( playerState_t *genemy, qboolean victory, qboolean superBreak )
+{ 
+	int loseAnim = -1;
+	switch ( genemy->torsoAnim )
+	{
+/*
+	default:
+#ifndef FINAL_BUILD
+		Com_Printf( S_COLOR_RED"ERROR-PM_SaberLockBreak: %s not in saberlock anim, anim = (%d)%s\n", genemy->NPC_type, genemy->client->ps.torsoAnim, animTable[genemy->client->ps.torsoAnim].name );
+#endif
+*/
+	case BOTH_BF2LOCK:
+		if ( superBreak )
+		{
+			loseAnim = BOTH_LK_S_S_T_SB_1_L;
+		}
+		else if ( !victory )
+		{
+			loseAnim = BOTH_BF1BREAK;
+		}
+		else
+		{
+			if ( !victory )
+			{//no-one won
+				genemy->saberMove = LS_K1_T_;
+				loseAnim = BOTH_K1_S1_T_;
+			}
+			else
+			{//FIXME: this anim needs to transition back to ready when done
+				loseAnim = BOTH_BF1BREAK;
+			}
+		}
+		break;
+	case BOTH_BF1LOCK:
+		if ( superBreak )
+		{
+			loseAnim = BOTH_LK_S_S_T_SB_1_L;
+		}
+		else if ( !victory )
+		{
+			loseAnim = BOTH_KNOCKDOWN4;
+		}
+		else
+		{
+			if ( !victory )
+			{//no-one won
+				genemy->saberMove = LS_A_T2B;
+				loseAnim = BOTH_A3_T__B_;
+			}
+			else
+			{
+				loseAnim = BOTH_KNOCKDOWN4;
+			}
+		}
+		break;
+	case BOTH_CWCIRCLELOCK:
+		if ( superBreak )
+		{
+			loseAnim = BOTH_LK_S_S_S_SB_1_L;
+		}
+		else if ( !victory )
+		{
+			genemy->saberMove = LS_V1_BL;//genemy->saberBounceMove = 
+			genemy->saberBlocked = BLOCKED_PARRY_BROKEN;
+			loseAnim = BOTH_V1_BL_S1;
+		}
+		else
+		{
+			if ( !victory )
+			{//no-one won
+				loseAnim = BOTH_CCWCIRCLEBREAK;
+			}
+			else
+			{
+				genemy->saberMove = LS_V1_BL;//genemy->saberBounceMove = 
+				genemy->saberBlocked = BLOCKED_PARRY_BROKEN;
+				loseAnim = BOTH_V1_BL_S1;
+				/*
+				genemy->client->ps.saberMove = genemy->client->ps.saberBounceMove = LS_H1_BR;
+				genemy->client->ps.saberBlocked = BLOCKED_PARRY_BROKEN;
+				loseAnim = BOTH_H1_S1_BL;
+				*/
+			}
+		}
+		break;
+	case BOTH_CCWCIRCLELOCK:
+		if ( superBreak )
+		{
+			loseAnim = BOTH_LK_S_S_S_SB_1_L;
+		}
+		else if ( !victory )
+		{
+			genemy->saberMove = LS_V1_BR;//genemy->saberBounceMove = 
+			genemy->saberBlocked = BLOCKED_PARRY_BROKEN;
+			loseAnim = BOTH_V1_BR_S1;
+		}
+		else
+		{
+			if ( !victory )
+			{//no-one won
+				loseAnim = BOTH_CWCIRCLEBREAK;
+			}
+			else
+			{
+				genemy->saberMove = LS_V1_BR;//genemy->saberBounceMove = 
+				genemy->saberBlocked = BLOCKED_PARRY_BROKEN;
+				loseAnim = BOTH_V1_BR_S1;
+				/*
+				genemy->client->ps.saberMove = genemy->client->ps.saberBounceMove = LS_H1_BL;
+				genemy->client->ps.saberBlocked = BLOCKED_PARRY_BROKEN;
+				loseAnim = BOTH_H1_S1_BR;
+				*/
+			}
+		}
+		break;
+	}
+	if ( loseAnim != -1 )
+	{
+#ifdef QAGAME
+		NPC_SetAnim( &g_entities[genemy->clientNum], SETANIM_BOTH, loseAnim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+		genemy->weaponTime = genemy->torsoTimer;// + 250;
+#endif
+		genemy->saberBlocked = BLOCKED_NONE;
+		genemy->weaponstate = WEAPON_READY;
+	}
+	return loseAnim;
+}
+
+int PM_SaberLockResultAnim( playerState_t *duelist, qboolean superBreak, qboolean won )
+{
+	int baseAnim = duelist->torsoAnim;
+	switch ( baseAnim )
+	{
+	case BOTH_LK_S_S_S_L_2:		//lock if I'm using single vs. a single and other intitiated
+		baseAnim = BOTH_LK_S_S_S_L_1;
+		break;
+	case BOTH_LK_S_S_T_L_2:		//lock if I'm using single vs. a single and other initiated
+		baseAnim = BOTH_LK_S_S_T_L_1;
+		break;
+	case BOTH_LK_DL_DL_S_L_2:	//lock if I'm using dual vs. dual and other initiated
+		baseAnim = BOTH_LK_DL_DL_S_L_1;
+		break;
+	case BOTH_LK_DL_DL_T_L_2:	//lock if I'm using dual vs. dual and other initiated
+		baseAnim = BOTH_LK_DL_DL_T_L_1;
+		break;
+	case BOTH_LK_ST_ST_S_L_2:	//lock if I'm using staff vs. a staff and other initiated
+		baseAnim = BOTH_LK_ST_ST_S_L_1;
+		break;
+	case BOTH_LK_ST_ST_T_L_2:	//lock if I'm using staff vs. a staff and other initiated
+		baseAnim = BOTH_LK_ST_ST_T_L_1;
+		break;
+	}
+	//what kind of break?
+	if ( !superBreak )
+	{ 
+		baseAnim -= 2;
+	}
+	else if ( superBreak )
+	{
+		baseAnim += 1;
+	}
+	else
+	{//WTF?  Not a valid result
+		return -1;
+	}
+	//win or lose?
+	if ( won )
+	{
+		baseAnim += 1;
+	}
+
+	//play the anim and hold it
+#ifdef QAGAME
+	//server-side: set it on the other guy, too
+	if ( duelist->clientNum == pm->ps->clientNum )
+	{//me
+		PM_SetAnim( SETANIM_BOTH, baseAnim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD, 0 );
+	}
+	else
+	{//other guy
+		NPC_SetAnim( &g_entities[duelist->clientNum], SETANIM_BOTH, baseAnim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+	}
+#else
+	PM_SetAnim( SETANIM_BOTH, baseAnim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD, 0 );
+#endif
+
+	if ( superBreak
+		&& !won )
+	{//if you lose a superbreak, you're defenseless
+		/*
+		//Taken care of in SetSaberBoxSize()
+		//make saberent not block
+		gentity_t *saberent = &g_entities[duelist->client->ps.saberEntityNum];
+		if ( saberent )
+		{
+			VectorClear(saberent->mins);
+			VectorClear(saberent->maxs);
+			G_SetOrigin(saberent, duelist->currentOrigin);
+		}
+		*/
+#ifdef QAGAME
+		if ( 1 )
+#else
+		if ( duelist->clientNum == pm->ps->clientNum )
+#endif
+		{
+			//set sabermove to none
+			duelist->saberMove = LS_NONE;
+			//Hold the anim a little longer than it is
+			duelist->torsoTimer += 250;
+		}
+	}
+
+#ifdef QAGAME
+	if ( 1 )
+#else
+	if ( duelist->clientNum == pm->ps->clientNum )
+#endif
+	{
+		//no attacking during this anim
+		duelist->weaponTime = duelist->torsoTimer;
+		duelist->saberBlocked = BLOCKED_NONE;
+		/*
+		if ( superBreak
+			&& won
+			&& baseAnim != BOTH_LK_ST_DL_T_SB_1_W )
+		{//going to attack with saber, do a saber trail
+			duelist->client->ps.SaberActivateTrail( 200 );
+		}
+		*/
+	}
+	return baseAnim;
+}
+
+void PM_SaberLockBreak( playerState_t *genemy, qboolean victory, int strength )
+{
+	int	winAnim = BOTH_STAND1, loseAnim = BOTH_STAND1;
+	//qboolean punishLoser = qfalse;
+	qboolean noKnockdown = qfalse;
+	qboolean singleVsSingle = qtrue;
+	qboolean superBreak = (strength+pm->ps->saberLockHits > Q_irand(2,4));
+
+	winAnim = PM_SaberLockWinAnim( victory, superBreak );
+	if ( winAnim != -1 )
+	{//a single vs. single break
+		loseAnim = PM_SaberLockLoseAnim( genemy, victory, superBreak );
+	}
+	else
+	{//must be a saberlock that's not between single and single...
+		singleVsSingle = qfalse;
+		winAnim = PM_SaberLockResultAnim( pm->ps, superBreak, qtrue );
+		pm->ps->weaponstate = WEAPON_FIRING;
+		loseAnim = PM_SaberLockResultAnim( genemy, superBreak, qfalse );
+		genemy->weaponstate = WEAPON_READY;
+	}
+
+	if ( victory )
+	{ //someone lost the lock, so punish them by knocking them down
+		if ( pm->ps->saberLockHits && !superBreak )
+		{//there was some over-power in the win, but not enough to superbreak
+			vec3_t oppDir;
+
+			int strength = 8;
+
+			VectorSubtract(genemy->origin, pm->ps->origin, oppDir);
+			VectorNormalize(oppDir);
+
+			if (noKnockdown)
+			{
+				if (!genemy->saberEntityNum)
+				{ //if he has already lost his saber then just knock him down
+					noKnockdown = qfalse;
+				}
+			}
+
+			if (!noKnockdown && BG_KnockDownable(genemy))
+			{
+				genemy->forceHandExtend = HANDEXTEND_KNOCKDOWN;
+				genemy->forceHandExtendTime = pm->cmd.serverTime + 1100;
+				genemy->forceDodgeAnim = 0; //this toggles between 1 and 0, when it's 1 we should play the get up anim
+
+				genemy->otherKiller = pm->ps->clientNum;
+				genemy->otherKillerTime = pm->cmd.serverTime + 5000;
+				genemy->otherKillerDebounceTime = pm->cmd.serverTime + 100;
+
+				genemy->velocity[0] = oppDir[0]*(strength*40);
+				genemy->velocity[1] = oppDir[1]*(strength*40);
+				genemy->velocity[2] = 100;
+			}
+
+			pm->checkDuelLoss = genemy->clientNum+1;
+
+			pm->ps->saberEventFlags |= SEF_LOCK_WON;
+		}
+	}
+	else
+	{ //If no one lost, then shove each player away from the other
+		vec3_t oppDir;
+
+		int strength = 4;
+
+		VectorSubtract(genemy->origin, pm->ps->origin, oppDir);
+		VectorNormalize(oppDir);
+		genemy->velocity[0] = oppDir[0]*(strength*40);
+		genemy->velocity[1] = oppDir[1]*(strength*40);
+		genemy->velocity[2] = 150;
+
+		VectorSubtract(pm->ps->origin, genemy->origin, oppDir);
+		VectorNormalize(oppDir);
+		pm->ps->velocity[0] = oppDir[0]*(strength*40);
+		pm->ps->velocity[1] = oppDir[1]*(strength*40);
+		pm->ps->velocity[2] = 150;
+
+		genemy->forceHandExtend = HANDEXTEND_WEAPONREADY;
+	}
+
+	pm->ps->weaponTime = 0;
+	genemy->weaponTime = 0;
+
+	pm->ps->saberLockTime = genemy->saberLockTime = 0;
+	pm->ps->saberLockFrame = genemy->saberLockFrame = 0;
+	pm->ps->saberLockEnemy = genemy->saberLockEnemy = 0;
+
+	pm->ps->forceHandExtend = HANDEXTEND_WEAPONREADY;
+
+	PM_AddEvent( EV_JUMP );
+	if ( !victory )
+	{//no-one won
+		BG_AddPredictableEventToPlayerstate(EV_JUMP, 0, genemy);
+	}
+	else
+	{
+		if ( PM_irand_timesync( 0, 1 ) )
+		{
+			BG_AddPredictableEventToPlayerstate(EV_JUMP, PM_irand_timesync( 0, 75 ), genemy);
+		}
+	}
+}
+
+qboolean BG_CheckIncrementLockAnim( int anim, int winOrLose )
+{
+	qboolean increment = qfalse;//???
+	//RULE: if you are the first style in the lock anim, you advance from LOSING position to WINNING position
+	//		if you are the second style in the lock anim, you advance from WINNING position to LOSING position
+	switch ( anim )
+	{
+	//increment to win:
+	case BOTH_LK_DL_DL_S_L_1:	//lock if I'm using dual vs. dual and I initiated
+	case BOTH_LK_DL_DL_S_L_2:	//lock if I'm using dual vs. dual and other initiated
+	case BOTH_LK_DL_DL_T_L_1:	//lock if I'm using dual vs. dual and I initiated
+	case BOTH_LK_DL_DL_T_L_2:	//lock if I'm using dual vs. dual and other initiated
+	case BOTH_LK_DL_S_S_L_1:		//lock if I'm using dual vs. a single
+	case BOTH_LK_DL_S_T_L_1:		//lock if I'm using dual vs. a single
+	case BOTH_LK_DL_ST_S_L_1:	//lock if I'm using dual vs. a staff
+	case BOTH_LK_DL_ST_T_L_1:	//lock if I'm using dual vs. a staff
+	case BOTH_LK_S_S_S_L_1:		//lock if I'm using single vs. a single and I initiated
+	case BOTH_LK_S_S_T_L_2:		//lock if I'm using single vs. a single and other initiated
+	case BOTH_LK_ST_S_S_L_1:		//lock if I'm using staff vs. a single
+	case BOTH_LK_ST_S_T_L_1:		//lock if I'm using staff vs. a single
+	case BOTH_LK_ST_ST_T_L_1:	//lock if I'm using staff vs. a staff and I initiated
+	case BOTH_LK_ST_ST_T_L_2:	//lock if I'm using staff vs. a staff and other initiated
+		if ( winOrLose == SABERLOCK_WIN )
+		{
+			increment = qtrue;
+		}
+		else
+		{
+			increment = qfalse;
+		}
+		break;
+
+	//decrement to win:
+	case BOTH_LK_S_DL_S_L_1:		//lock if I'm using single vs. a dual
+	case BOTH_LK_S_DL_T_L_1:		//lock if I'm using single vs. a dual
+	case BOTH_LK_S_S_S_L_2:		//lock if I'm using single vs. a single and other intitiated
+	case BOTH_LK_S_S_T_L_1:		//lock if I'm using single vs. a single and I initiated
+	case BOTH_LK_S_ST_S_L_1:		//lock if I'm using single vs. a staff
+	case BOTH_LK_S_ST_T_L_1:		//lock if I'm using single vs. a staff
+	case BOTH_LK_ST_DL_S_L_1:	//lock if I'm using staff vs. dual
+	case BOTH_LK_ST_DL_T_L_1:	//lock if I'm using staff vs. dual
+	case BOTH_LK_ST_ST_S_L_1:	//lock if I'm using staff vs. a staff and I initiated
+	case BOTH_LK_ST_ST_S_L_2:	//lock if I'm using staff vs. a staff and other initiated
+		if ( winOrLose == SABERLOCK_WIN )
+		{
+			increment = qfalse;
+		}
+		else
+		{
+			increment = qtrue;
+		}
+		break;
+	default:
+		break;
+	}
+	return increment;
+}
+
+extern qboolean ValidAnimFileIndex ( int index );
+void PM_SaberLocked( void )
+{
+	int	remaining = 0;
+	playerState_t *genemy;
+	bgEntity_t *eGenemy = PM_BGEntForNum(pm->ps->saberLockEnemy);
+
+	if (!eGenemy)
+	{
+		return;
+	}
+
+	genemy = eGenemy->playerState;
+
+	if ( !genemy )
+	{
+		return;
+	}
+	/*if ( ( (pm->ps->torsoAnim) == BOTH_BF2LOCK ||
+			(pm->ps->torsoAnim) == BOTH_BF1LOCK ||
+			(pm->ps->torsoAnim) == BOTH_CWCIRCLELOCK ||
+			(pm->ps->torsoAnim) == BOTH_CCWCIRCLELOCK )
+		&& ( (genemy->torsoAnim) == BOTH_BF2LOCK ||
+			(genemy->torsoAnim) == BOTH_BF1LOCK ||
+			(genemy->torsoAnim) == BOTH_CWCIRCLELOCK ||
+			(genemy->torsoAnim) == BOTH_CCWCIRCLELOCK )
+		)
+		*/ //yeah..
+	if (pm->ps->saberLockFrame &&
+		genemy->saberLockFrame &&
+		BG_InSaberLock(pm->ps->torsoAnim) &&
+		BG_InSaberLock(genemy->torsoAnim))
+	{
+		float dist = 0;
+
+		pm->ps->torsoTimer = 0;
+		pm->ps->weaponTime = 0;
+		genemy->torsoTimer = 0;
+		genemy->weaponTime = 0;
+
+		dist = DistanceSquared(pm->ps->origin,genemy->origin);
+		if ( dist < 64 || dist > 6400 )
+		{//between 8 and 80 from each other
+			PM_SaberLockBreak( genemy, qfalse, 0 );
+			return;
+		}
+		/*
+		//NOTE: time-out is handled around where PM_SaberLocked is called
+		if ( pm->ps->saberLockTime <= pm->cmd.serverTime + 500 )
+		{//lock just ended
+			PM_SaberLockBreak( genemy, qfalse, 0 );
+			return;
+		}
+		*/
+		if ( pm->ps->saberLockAdvance )
+		{//holding attack
+			animation_t *anim;
+			float		currentFrame;
+			int			curFrame;
+			int			strength = 1;
+
+			pm->ps->saberLockAdvance = qfalse;
+
+			anim = &pm->animations[pm->ps->torsoAnim];
+
+			currentFrame = pm->ps->saberLockFrame;
+
+			strength = pm->ps->fd.forcePowerLevel[FP_SABER_OFFENSE]+1;
+
+			//advance/decrement my frame number
+			if ( BG_InSaberLockOld( pm->ps->torsoAnim ) )
+			{ //old locks
+				if ( (pm->ps->torsoAnim) == BOTH_CCWCIRCLELOCK ||
+					(pm->ps->torsoAnim) == BOTH_BF2LOCK )
+				{
+					curFrame = floor( currentFrame )-strength;
+					//drop my frame one
+					if ( curFrame <= anim->firstFrame )
+					{//I won!  Break out
+						PM_SaberLockBreak( genemy, qtrue, strength );
+						return;
+					}
+					else
+					{
+						PM_SetAnimFrame( pm->ps, curFrame, qtrue, qtrue );
+						remaining = curFrame-anim->firstFrame;
+					}
+				}
+				else
+				{
+					curFrame = ceil( currentFrame )+strength;
+					//advance my frame one
+					if ( curFrame >= anim->firstFrame+anim->numFrames )
+					{//I won!  Break out
+						PM_SaberLockBreak( genemy, qtrue, strength );
+						return;
+					}
+					else
+					{
+						PM_SetAnimFrame( pm->ps, curFrame, qtrue, qtrue );
+						remaining = anim->firstFrame+anim->numFrames-curFrame;
+					}
+				}
+			}
+			else
+			{ //new locks
+				if ( BG_CheckIncrementLockAnim( pm->ps->torsoAnim, SABERLOCK_WIN ) )
+				{
+					curFrame = ceil( currentFrame )+strength;
+					//advance my frame one
+					if ( curFrame >= anim->firstFrame+anim->numFrames )
+					{//I won!  Break out
+						PM_SaberLockBreak( genemy, qtrue, strength );
+						return;
+					}
+					else
+					{
+						PM_SetAnimFrame( pm->ps, curFrame, qtrue, qtrue );
+						remaining = anim->firstFrame+anim->numFrames-curFrame;
+					}
+				}
+				else
+				{
+					curFrame = floor( currentFrame )-strength;
+					//drop my frame one
+					if ( curFrame <= anim->firstFrame )
+					{//I won!  Break out
+						PM_SaberLockBreak( genemy, qtrue, strength );
+						return;
+					}
+					else
+					{
+						PM_SetAnimFrame( pm->ps, curFrame, qtrue, qtrue );
+						remaining = curFrame-anim->firstFrame;
+					}
+				}
+			}
+			if ( !PM_irand_timesync( 0, 2 ) )
+			{
+				PM_AddEvent( EV_JUMP );
+			}
+			//advance/decrement enemy frame number
+			anim = &pm->animations[(genemy->torsoAnim)];
+
+			if ( BG_InSaberLockOld( genemy->torsoAnim ) )
+			{
+				if ( (genemy->torsoAnim) == BOTH_CWCIRCLELOCK ||
+					(genemy->torsoAnim) == BOTH_BF1LOCK )
+				{
+					if ( !PM_irand_timesync( 0, 2 ) )
+					{
+						BG_AddPredictableEventToPlayerstate(EV_PAIN, floor((float)80/100*100.0f), genemy);
+					}
+					PM_SetAnimFrame( genemy, anim->firstFrame+remaining, qtrue, qtrue );
+				}
+				else
+				{
+					PM_SetAnimFrame( genemy, anim->firstFrame+anim->numFrames-remaining, qtrue, qtrue );
+				}
+			}
+			else
+			{//new locks
+				if ( BG_CheckIncrementLockAnim( genemy->torsoAnim, SABERLOCK_LOSE ) )
+				{
+					if ( !PM_irand_timesync( 0, 2 ) )
+					{
+						BG_AddPredictableEventToPlayerstate(EV_PAIN, floor((float)80/100*100.0f), genemy);
+					}
+					PM_SetAnimFrame( genemy, anim->firstFrame+anim->numFrames-remaining, qtrue, qtrue );
+				}
+				else
+				{
+					PM_SetAnimFrame( genemy, anim->firstFrame+remaining, qtrue, qtrue );
+				}
+			}
+		}
+	}
+	else
+	{//something broke us out of it
+		PM_SaberLockBreak( genemy, qfalse, 0 );
+	}
+}
+
+qboolean PM_SaberInBrokenParry( int move )
+{
+	if ( move >= LS_V1_BR && move <= LS_V1_B_ )
+	{
+		return qtrue;
+	}
+	if ( move >= LS_H1_T_ && move <= LS_H1_BL )
+	{
+		return qtrue;
+	}
+	return qfalse;
+}
+
+
+int PM_BrokenParryForParry( int move )
+{
+	switch ( move )
+	{
+	case LS_PARRY_UP:
+		return LS_H1_T_;
+		break;
+	case LS_PARRY_UR:
+		return LS_H1_TR;
+		break;
+	case LS_PARRY_UL:
+		return LS_H1_TL;
+		break;
+	case LS_PARRY_LR:
+		return LS_H1_BL;
+		break;
+	case LS_PARRY_LL:
+		return LS_H1_BR;
+		break;
+	case LS_READY:
+		return LS_H1_B_;
+		break;
+	}
+	return LS_NONE;
+}
+
+#define BACK_STAB_DISTANCE 128
+
+qboolean PM_CanBackstab(void)
+{
+	trace_t tr;
+	vec3_t flatAng;
+	vec3_t fwd, back;
+	vec3_t trmins = {-15, -15, -8};
+	vec3_t trmaxs = {15, 15, 8};
+
+	VectorCopy(pm->ps->viewangles, flatAng);
+	flatAng[PITCH] = 0;
+
+	AngleVectors(flatAng, fwd, 0, 0);
+
+	back[0] = pm->ps->origin[0] - fwd[0]*BACK_STAB_DISTANCE;
+	back[1] = pm->ps->origin[1] - fwd[1]*BACK_STAB_DISTANCE;
+	back[2] = pm->ps->origin[2] - fwd[2]*BACK_STAB_DISTANCE;
+
+	pm->trace(&tr, pm->ps->origin, trmins, trmaxs, back, pm->ps->clientNum, MASK_PLAYERSOLID);
+
+	if (tr.fraction != 1.0 && tr.entityNum >= 0 && tr.entityNum < ENTITYNUM_NONE)
+	{
+		bgEntity_t *bgEnt = PM_BGEntForNum(tr.entityNum);
+
+		if (bgEnt && (bgEnt->s.eType == ET_PLAYER || bgEnt->s.eType == ET_NPC))
+		{
+			return qtrue;
+		}
+	}
+
+	return qfalse;
+}
+
+saberMoveName_t PM_SaberFlipOverAttackMove(void)
+{ 
+	vec3_t fwdAngles, jumpFwd;
+//	float zDiff = 0;
+//	playerState_t *psData;
+//	bgEntity_t *bgEnt;
+
+	VectorCopy( pm->ps->viewangles, fwdAngles );
+	fwdAngles[PITCH] = fwdAngles[ROLL] = 0;
+	AngleVectors( fwdAngles, jumpFwd, NULL, NULL );
+	VectorScale( jumpFwd, 150, pm->ps->velocity );//was 50
+	pm->ps->velocity[2] = 400;
+
+	/*
+	bgEnt = PM_BGEntForNum(tr->entityNum);
+
+	if (!bgEnt)
+	{
+		return LS_A_FLIP_STAB;
+	}
+
+    psData = bgEnt->playerState;
+
+	//go higher for enemies higher than you, lower for those lower than you
+	if (psData)
+	{
+		zDiff = psData->origin[2] - pm->ps->origin[2];
+	}
+	else
+	{
+		zDiff = 0;
+	}
+	pm->ps->velocity[2] += (zDiff)*1.5f;
+
+	//clamp to decent-looking values
+	if ( zDiff <= 0 && pm->ps->velocity[2] < 200 )
+	{//if we're on same level, don't let me jump so low, I clip into the ground
+		pm->ps->velocity[2] = 200;
+	}
+	else if ( pm->ps->velocity[2] < 100 )
+	{
+		pm->ps->velocity[2] = 100;
+	}
+	else if ( pm->ps->velocity[2] > 400 )
+	{
+		pm->ps->velocity[2] = 400;
+	}
+	*/
+
+	PM_SetForceJumpZStart(pm->ps->origin[2]);//so we don't take damage if we land at same height
+
+	PM_AddEvent( EV_JUMP );
+	pm->ps->fd.forceJumpSound = 1;
+	pm->cmd.upmove = 0;
+
+	/*
+	if ( PM_irand_timesync( 0, 1 ) )
+	{
+		return LS_A_FLIP_STAB;
+	}
+	else
+	*/
+	{
+		return LS_A_FLIP_SLASH;
+	}
+}
+
+int PM_SaberBackflipAttackMove( void )
+{
+	pm->cmd.upmove = 127;
+	pm->ps->velocity[2] = 500;
+	return LS_A_BACKFLIP_ATK;
+}
+
+int PM_SaberDualJumpAttackMove( void )
+{
+	//FIXME: to make this move easier to execute, should be allowed to do it 
+	//		after you've already started your jump... but jump is delayed in
+	//		this anim, so how do we undo the jump?
+	pm->cmd.upmove = 0;//no jump just yet
+	return LS_JUMPATTACK_DUAL;
+}
+
+#define FLIPHACK_DISTANCE 200
+
+qboolean PM_SomeoneInFront(trace_t *tr)
+{ //Also a very simplified version of the sp counterpart
+	vec3_t flatAng;
+	vec3_t fwd, back;
+	vec3_t trmins = {-15, -15, -8};
+	vec3_t trmaxs = {15, 15, 8};
+
+	VectorCopy(pm->ps->viewangles, flatAng);
+	flatAng[PITCH] = 0;
+
+	AngleVectors(flatAng, fwd, 0, 0);
+
+	back[0] = pm->ps->origin[0] + fwd[0]*FLIPHACK_DISTANCE;
+	back[1] = pm->ps->origin[1] + fwd[1]*FLIPHACK_DISTANCE;
+	back[2] = pm->ps->origin[2] + fwd[2]*FLIPHACK_DISTANCE;
+
+	pm->trace(tr, pm->ps->origin, trmins, trmaxs, back, pm->ps->clientNum, MASK_PLAYERSOLID);
+
+	if (tr->fraction != 1.0 && tr->entityNum >= 0 && tr->entityNum < ENTITYNUM_NONE)
+	{
+		bgEntity_t *bgEnt = PM_BGEntForNum(tr->entityNum);
+
+		if (bgEnt && (bgEnt->s.eType == ET_PLAYER || bgEnt->s.eType == ET_NPC))
+		{
+			return qtrue;
+		}
+	}
+
+	return qfalse;
+}
+
+saberMoveName_t PM_SaberLungeAttackMove( void )
+{
+	vec3_t fwdAngles, jumpFwd;
+
+	VectorCopy( pm->ps->viewangles, fwdAngles );
+	fwdAngles[PITCH] = fwdAngles[ROLL] = 0;
+	//do the lunge
+	AngleVectors( fwdAngles, jumpFwd, NULL, NULL );
+	VectorScale( jumpFwd, 150, pm->ps->velocity );
+	PM_AddEvent( EV_JUMP );
+
+	return LS_A_LUNGE;
+}
+
+saberMoveName_t PM_SaberJumpAttackMove( void )
+{
+	vec3_t fwdAngles, jumpFwd;
+
+	VectorCopy( pm->ps->viewangles, fwdAngles );
+	fwdAngles[PITCH] = fwdAngles[ROLL] = 0;
+	AngleVectors( fwdAngles, jumpFwd, NULL, NULL );
+	VectorScale( jumpFwd, 300, pm->ps->velocity );
+	pm->ps->velocity[2] = 280;
+	PM_SetForceJumpZStart(pm->ps->origin[2]);//so we don't take damage if we land at same height
+
+	PM_AddEvent( EV_JUMP );
+	pm->ps->fd.forceJumpSound = 1;
+	pm->cmd.upmove = 0;
+
+	return LS_A_JUMP_T__B_;
+}
+
+float PM_GroundDistance(void)
+{
+	trace_t tr;
+	vec3_t down;
+
+	VectorCopy(pm->ps->origin, down);
+
+	down[2] -= 4096;
+
+	pm->trace(&tr, pm->ps->origin, pm->mins, pm->maxs, down, pm->ps->clientNum, MASK_SOLID);
+
+	VectorSubtract(pm->ps->origin, tr.endpos, down);
+
+	return VectorLength(down);
+}
+
+float PM_WalkableGroundDistance(void)
+{
+	trace_t tr;
+	vec3_t down;
+
+	VectorCopy(pm->ps->origin, down);
+
+	down[2] -= 4096;
+
+	pm->trace(&tr, pm->ps->origin, pm->mins, pm->maxs, down, pm->ps->clientNum, MASK_SOLID);
+
+	if ( tr.plane.normal[2] < MIN_WALK_NORMAL )
+	{//can't stand on this plane
+		return 4096;
+	}
+
+	VectorSubtract(pm->ps->origin, tr.endpos, down);
+
+	return VectorLength(down);
+}
+
+qboolean BG_SaberInTransitionAny( int move );
+static qboolean PM_CanDoDualDoubleAttacks(void)
+{
+	if (BG_SaberInSpecialAttack(pm->ps->torsoAnim) ||
+		BG_SaberInSpecialAttack(pm->ps->legsAnim))
+	{
+		return qfalse;
+	}
+	return qtrue;
+}
+
+static qboolean PM_CheckEnemyPresence( int dir, float radius )
+{ //anyone in this dir?
+	vec3_t angles;
+	vec3_t checkDir;
+	vec3_t tTo;
+	vec3_t tMins, tMaxs;
+	trace_t tr;
+	const float tSize = 12.0f;
+	//sp uses a bbox ent list check, but.. that's not so easy/fast to
+	//do in predicted code. So I'll just do a single box trace in the proper direction,
+	//and take whatever is first hit.
+
+	VectorSet(tMins, -tSize, -tSize, -tSize);
+	VectorSet(tMaxs, tSize, tSize, tSize);
+
+	VectorCopy(pm->ps->viewangles, angles);
+	angles[PITCH] = 0.0f;
+
+	switch( dir )
+	{
+	case DIR_RIGHT:
+		AngleVectors( angles, NULL, checkDir, NULL );
+		break;
+	case DIR_LEFT:
+		AngleVectors( angles, NULL, checkDir, NULL );
+		VectorScale( checkDir, -1, checkDir );
+		break;
+	case DIR_FRONT:
+		AngleVectors( angles, checkDir, NULL, NULL );
+		break;
+	case DIR_BACK:
+		AngleVectors( angles, checkDir, NULL, NULL );
+		VectorScale( checkDir, -1, checkDir );
+		break;
+	}
+
+	VectorMA(pm->ps->origin, radius, checkDir, tTo);
+	pm->trace(&tr, pm->ps->origin, tMins, tMaxs, tTo, pm->ps->clientNum, MASK_PLAYERSOLID);
+
+	if (tr.fraction != 1.0f && tr.entityNum < ENTITYNUM_WORLD)
+	{ //let's see who we hit
+		bgEntity_t *bgEnt = PM_BGEntForNum(tr.entityNum);
+
+		if (bgEnt &&
+			(bgEnt->s.eType == ET_PLAYER || bgEnt->s.eType == ET_NPC))
+		{ //this guy can be considered an "enemy"... if he is on the same team, oh well. can't bg-check that (without a whole lot of hassle).
+			return qtrue;
+		}
+	}
+
+	//no one in the trace
+	return qfalse;
+}
+
+#define SABER_ALT_ATTACK_POWER		50//75?
+#define SABER_ALT_ATTACK_POWER_LR	10//30?
+#define SABER_ALT_ATTACK_POWER_FB	25//30/50?
+
+extern qboolean PM_SaberInReturn( int move ); //bg_panimate.c
+saberMoveName_t PM_CheckPullAttack( void )
+{
+#if 0 //disabling these for MP, they aren't useful
+	if (!(pm->cmd.buttons & BUTTON_ATTACK))
+	{
+		return LS_NONE;
+	}
+
+	if ( (pm->ps->saberMove == LS_READY||PM_SaberInReturn(pm->ps->saberMove)||PM_SaberInReflect(pm->ps->saberMove))//ready
+		//&& (pm->ps->clientNum < MAX_CLIENTS||PM_ControlledByPlayer())//PLAYER ONLY
+		&& pm->ps->fd.saberAnimLevel >= SS_FAST//single saber styles - FIXME: Tavion?
+		&& pm->ps->fd.saberAnimLevel <= SS_STRONG//single saber styles - FIXME: Tavion?
+		//&& G_TryingPullAttack( pm->gent, &pm->cmd, qfalse )
+		//&& pm->ps->fd.forcePowerLevel[FP_PULL] 
+		//rwwFIXMEFIXME: rick has the damn msg.cpp file checked out exclusively so I can't update the bloody psf to send this for prediction
+		&& pm->ps->powerups[PW_DISINT_4] > pm->cmd.serverTime
+		&& !(pm->ps->fd.forcePowersActive & (1<<FP_GRIP))
+		&& pm->ps->powerups[PW_PULL] > pm->cmd.serverTime
+		//&& pm->cmd.forwardmove<0//pulling back
+		&& (pm->cmd.buttons&BUTTON_ATTACK)//attacking
+		&& BG_EnoughForcePowerForMove( SABER_ALT_ATTACK_POWER_FB ) )//pm->ps->forcePower >= SABER_ALT_ATTACK_POWER_FB//have enough power
+	{//FIXME: some NPC logic to do this?
+		qboolean doMove = qtrue;
+//		if ( g_saberNewControlScheme->integer
+//			|| g_crosshairEntNum < ENTITYNUM_WORLD )//in old control scheme, there has to be someone there
+		{	
+			saberMoveName_t pullAttackMove = LS_NONE;
+			if ( pm->ps->fd.saberAnimLevel == SS_FAST )
+			{
+				pullAttackMove = LS_PULL_ATTACK_STAB;
+			}
+			else
+			{
+				pullAttackMove = LS_PULL_ATTACK_SWING;
+			}
+
+			/*
+			if ( g_crosshairEntNum < ENTITYNUM_WORLD 
+				&& pm->gent && pm->gent->client )
+			{
+				gentity_t *targEnt = &g_entities[g_crosshairEntNum];
+				if ( targEnt->client
+					&& targEnt->health > 0
+					//FIXME: check other things like in knockdown, saberlock, uninterruptable anims, etc.
+					&& !PM_InOnGroundAnim( &targEnt->client->ps )
+					&& !PM_LockedAnim( targEnt->client->ps.legsAnim ) 
+					&& !PM_SuperBreakLoseAnim( targEnt->client->ps.legsAnim )
+					&& !PM_SuperBreakWinAnim( targEnt->client->ps.legsAnim )
+					&& targEnt->client->ps.saberLockTime <= 0
+					&& WP_ForceThrowable( targEnt, targEnt, pm->gent, qtrue, 1.0f, 0.0f, NULL ) )
+				{
+					if ( !g_saberNewControlScheme->integer )
+					{//in old control scheme, make sure they're close or far enough away for the move we'll be doing
+						float targDist = Distance( targEnt->currentOrigin, pm->ps->origin );
+						if ( pullAttackMove == LS_PULL_ATTACK_STAB )
+						{//must be closer than 512
+							if ( targDist > 384.0f )
+							{
+								return LS_NONE;
+							}
+						}
+						else//if ( pullAttackMove == LS_PULL_ATTACK_SWING )
+						{//must be farther than 256
+							if ( targDist > 512.0f )
+							{
+								return LS_NONE;
+							}
+							if ( targDist < 192.0f )
+							{
+								return LS_NONE;
+							}
+						}
+					}
+
+					vec3_t targAngles = {0,targEnt->client->ps.viewangles[YAW],0};
+					if ( InFront( pm->ps->origin, targEnt->currentOrigin, targAngles ) )
+					{
+						NPC_SetAnim( targEnt, SETANIM_BOTH, BOTH_PULLED_INAIR_F, SETANIM_FLAG_OVERRIDE, SETANIM_FLAG_HOLD );
+					}
+					else
+					{
+						NPC_SetAnim( targEnt, SETANIM_BOTH, BOTH_PULLED_INAIR_B, SETANIM_FLAG_OVERRIDE, SETANIM_FLAG_HOLD );
+					}
+					//hold the anim until I'm with done pull anim
+					targEnt->client->ps.legsAnimTimer = targEnt->client->ps.torsoAnimTimer = PM_AnimLength( pm->gent->client->clientInfo.animFileIndex, (animNumber_t)saberMoveData[pullAttackMove].animToUse );
+					//set pullAttackTime
+					pm->gent->client->ps.pullAttackTime = targEnt->client->ps.pullAttackTime = level.time+targEnt->client->ps.legsAnimTimer;
+					//make us know about each other
+					pm->gent->client->ps.pullAttackEntNum = g_crosshairEntNum;
+					targEnt->client->ps.pullAttackEntNum = pm->ps->clientNum;
+					//do effect and sound on me
+					pm->ps->powerups[PW_FORCE_PUSH] = level.time + 1000;
+					if ( pm->gent )
+					{
+						G_Sound( pm->gent, G_SoundIndex( "sound/weapons/force/pull.wav" ) );
+					}
+					doMove = qtrue;
+				}
+			}
+			*/
+			if ( doMove )
+			{
+				BG_ForcePowerDrain(pm->ps, FP_GRIP, SABER_ALT_ATTACK_POWER_FB );
+				return pullAttackMove;
+			}
+		}
+	}
+#endif
+	return LS_NONE;
+}
+
+qboolean PM_InSecondaryStyle( void )
+{
+	if ( pm->ps->fd.saberAnimLevelBase == SS_STAFF 
+		|| pm->ps->fd.saberAnimLevelBase == SS_DUAL )
+	{
+		if ( pm->ps->fd.saberAnimLevel != pm->ps->fd.saberAnimLevelBase )
+		{
+			return qtrue;
+		}
+	}
+	return qfalse;
+}
+
+saberMoveName_t PM_SaberAttackForMovement(saberMoveName_t curmove)
+{
+	saberMoveName_t newmove = LS_NONE;
+	qboolean noSpecials = PM_InSecondaryStyle();
+
+	if ( pm->cmd.rightmove > 0 )
+	{//moving right
+		if ( !noSpecials
+			&& pm->ps->velocity[2] > 20.0f //pm->ps->groundEntityNum != ENTITYNUM_NONE//on ground
+			&& (pm->cmd.buttons&BUTTON_ATTACK)//hitting attack
+			&& PM_GroundDistance() < 70.0f //not too high above ground
+			&& ( pm->cmd.upmove > 0 || (pm->ps->pm_flags & PMF_JUMP_HELD) )//focus-holding player
+			&& BG_EnoughForcePowerForMove( SABER_ALT_ATTACK_POWER_LR ) )//have enough power
+		{//cartwheel right
+			vec3_t right, fwdAngles;
+
+			VectorSet(fwdAngles, 0.0f, pm->ps->viewangles[YAW], 0.0f);
+			
+			BG_ForcePowerDrain(pm->ps, FP_GRIP, SABER_ALT_ATTACK_POWER_LR);
+
+			AngleVectors( fwdAngles, NULL, right, NULL );
+			pm->ps->velocity[0] = pm->ps->velocity[1] = 0.0f; 
+			VectorMA( pm->ps->velocity, 190.0f, right, pm->ps->velocity );
+			if ( pm->ps->fd.saberAnimLevel == SS_STAFF )
+			{
+				newmove = LS_BUTTERFLY_RIGHT;
+				pm->ps->velocity[2] = 350.0f;
+			}
+			else
+			{
+				//PM_SetJumped( JUMP_VELOCITY, qtrue );
+				PM_AddEvent( EV_JUMP );
+				pm->ps->velocity[2] = 300.0f;
+
+				//if ( !Q_irand( 0, 1 ) )
+				//if (PM_GroundDistance() >= 25.0f)
+				if (1)
+				{
+					newmove = LS_JUMPATTACK_ARIAL_RIGHT;
+				}
+				else
+				{
+					newmove = LS_JUMPATTACK_CART_RIGHT;
+				}
+			}
+		}
+		else if ( pm->cmd.forwardmove > 0 )
+		{//forward right = TL2BR slash
+			newmove = LS_A_TL2BR;
+		}
+		else if ( pm->cmd.forwardmove < 0 )
+		{//backward right = BL2TR uppercut
+			newmove = LS_A_BL2TR;
+		}
+		else
+		{//just right is a left slice
+			newmove = LS_A_L2R;
+		}
+	}
+	else if ( pm->cmd.rightmove < 0 )
+	{//moving left
+		if ( !noSpecials
+			&& pm->ps->velocity[2] > 20.0f //pm->ps->groundEntityNum != ENTITYNUM_NONE//on ground
+			&& (pm->cmd.buttons&BUTTON_ATTACK)//hitting attack
+			&& PM_GroundDistance() < 70.0f //not too high above ground
+			&& ( pm->cmd.upmove > 0 || (pm->ps->pm_flags & PMF_JUMP_HELD) )//focus-holding player
+			&& BG_EnoughForcePowerForMove( SABER_ALT_ATTACK_POWER_LR ) )//have enough power
+		{//cartwheel left
+			vec3_t right, fwdAngles;
+
+			VectorSet(fwdAngles, 0.0f, pm->ps->viewangles[YAW], 0.0f);
+			
+			BG_ForcePowerDrain(pm->ps, FP_GRIP, SABER_ALT_ATTACK_POWER_LR);
+
+			AngleVectors( fwdAngles, NULL, right, NULL );
+			pm->ps->velocity[0] = pm->ps->velocity[1] = 0.0f; 
+			VectorMA( pm->ps->velocity, -190.0f, right, pm->ps->velocity );
+			if ( pm->ps->fd.saberAnimLevel == SS_STAFF )
+			{
+				newmove = LS_BUTTERFLY_LEFT;
+				pm->ps->velocity[2] = 250.0f;
+			}
+			else
+			{
+				//PM_SetJumped( JUMP_VELOCITY, qtrue );
+				PM_AddEvent( EV_JUMP );
+				pm->ps->velocity[2] = 350.0f;
+
+				//if ( !Q_irand( 0, 1 ) )
+				//if (PM_GroundDistance() >= 25.0f)
+				if (1)
+				{
+					newmove = LS_JUMPATTACK_ARIAL_LEFT;
+				}
+				else
+				{
+					newmove = LS_JUMPATTACK_CART_LEFT;
+				}
+			}
+		}
+		else if ( pm->cmd.forwardmove > 0 )
+		{//forward left = TR2BL slash
+			newmove = LS_A_TR2BL;
+		}
+		else if ( pm->cmd.forwardmove < 0 )
+		{//backward left = BR2TL uppercut
+			newmove = LS_A_BR2TL;
+		}
+		else
+		{//just left is a right slice
+			newmove = LS_A_R2L;
+		}
+	}
+	else
+	{//not moving left or right
+		if ( pm->cmd.forwardmove > 0 )
+		{//forward= T2B slash
+			if (!noSpecials&&
+				(pm->ps->fd.saberAnimLevel == SS_DUAL || pm->ps->fd.saberAnimLevel == SS_STAFF) &&
+				pm->ps->fd.forceRageRecoveryTime < pm->cmd.serverTime &&
+				//pm->ps->fd.forcePowerLevel[FP_LEVITATION] > FORCE_LEVEL_1 &&
+				(pm->ps->groundEntityNum != ENTITYNUM_NONE || PM_GroundDistance() <= 40) &&
+				pm->ps->velocity[2] >= 0 &&
+				(pm->cmd.upmove > 0 || pm->ps->pm_flags & PMF_JUMP_HELD) &&
+				!BG_SaberInTransitionAny(pm->ps->saberMove) &&
+				!BG_SaberInAttack(pm->ps->saberMove) &&
+				pm->ps->weaponTime <= 0 &&
+				pm->ps->forceHandExtend == HANDEXTEND_NONE &&
+				(pm->cmd.buttons & BUTTON_ATTACK)&&
+				BG_EnoughForcePowerForMove(SABER_ALT_ATTACK_POWER_FB) )
+			{ //DUAL/STAFF JUMP ATTACK
+				BG_ForcePowerDrain(pm->ps, FP_GRIP, SABER_ALT_ATTACK_POWER_FB);
+				if (pm->ps->fd.saberAnimLevel == SS_DUAL)
+				{
+					newmove = PM_SaberDualJumpAttackMove();
+				}
+				else
+				{
+					//rwwFIXMEFIXME I don't like randomness for this sort of thing, gives people reason to
+					//complain combat is unpredictable. Maybe do something more clever to determine
+					//if we should do a left or right?
+					/*
+					if (PM_irand_timesync(0, 1))
+					{
+						newmove = LS_JUMPATTACK_STAFF_LEFT;
+					}
+					else
+					*/
+					{
+						newmove = LS_JUMPATTACK_STAFF_RIGHT;
+					}
+				}
+			}
+			else if (!noSpecials&&
+				pm->ps->fd.saberAnimLevel == SS_MEDIUM &&
+				pm->ps->velocity[2] > 100 &&
+				PM_GroundDistance() < 32 &&
+				!BG_InSpecialJump(pm->ps->legsAnim) &&
+				!BG_SaberInSpecialAttack(pm->ps->torsoAnim)&&
+				BG_EnoughForcePowerForMove(SABER_ALT_ATTACK_POWER_FB))
+			{ //FLIP AND DOWNWARD ATTACK
+				//trace_t tr;
+
+				//if (PM_SomeoneInFront(&tr))
+				{
+					newmove = PM_SaberFlipOverAttackMove();
+					BG_ForcePowerDrain(pm->ps, FP_GRIP, SABER_ALT_ATTACK_POWER_FB);
+				}
+			}
+			else if (!noSpecials&&
+				pm->ps->fd.saberAnimLevel == SS_STRONG &&
+				pm->ps->velocity[2] > 100 &&
+				PM_GroundDistance() < 32 &&
+				!BG_InSpecialJump(pm->ps->legsAnim) &&
+				!BG_SaberInSpecialAttack(pm->ps->torsoAnim)&&
+				BG_EnoughForcePowerForMove( SABER_ALT_ATTACK_POWER_FB ))
+			{ //DFA
+				//trace_t tr;
+
+				//if (PM_SomeoneInFront(&tr))
+				{
+					newmove = PM_SaberJumpAttackMove();
+					BG_ForcePowerDrain(pm->ps, FP_GRIP, SABER_ALT_ATTACK_POWER_FB);
+				}
+			}
+			else if ((pm->ps->fd.saberAnimLevel == SS_FAST || pm->ps->fd.saberAnimLevel == SS_DUAL || pm->ps->fd.saberAnimLevel == SS_STAFF) &&
+				pm->ps->groundEntityNum != ENTITYNUM_NONE &&
+				(pm->ps->pm_flags & PMF_DUCKED) &&
+				pm->ps->weaponTime <= 0 &&
+				!BG_SaberInSpecialAttack(pm->ps->torsoAnim)&&
+				BG_EnoughForcePowerForMove(SABER_ALT_ATTACK_POWER_FB))
+			{ //LUNGE (weak)
+				BG_ForcePowerDrain(pm->ps, FP_GRIP, SABER_ALT_ATTACK_POWER_FB);
+				if (pm->ps->fd.saberAnimLevel == FORCE_LEVEL_1)
+				{
+					newmove = PM_SaberLungeAttackMove();
+				}
+				else if ( !noSpecials && pm->ps->fd.saberAnimLevel == SS_STAFF)
+				{
+					newmove = LS_SPINATTACK;
+				}
+				else if ( !noSpecials )
+				{
+					newmove = LS_SPINATTACK_DUAL;
+				}
+			}
+			else if ( !noSpecials )
+			{
+				saberMoveName_t stabDownMove = PM_CheckStabDown();
+				if (stabDownMove != LS_NONE 
+					&& BG_EnoughForcePowerForMove(SABER_ALT_ATTACK_POWER_FB))
+				{
+					newmove = stabDownMove;
+					BG_ForcePowerDrain(pm->ps, FP_GRIP, SABER_ALT_ATTACK_POWER_FB);
+				}
+				else
+				{
+					newmove = LS_A_T2B;
+				}
+			}
+		}
+		else if ( pm->cmd.forwardmove < 0 )
+		{//backward= T2B slash//B2T uppercut?
+			if (!noSpecials&&
+				pm->ps->fd.saberAnimLevel == SS_STAFF &&
+				pm->ps->fd.forceRageRecoveryTime < pm->cmd.serverTime &&
+				pm->ps->fd.forcePowerLevel[FP_LEVITATION] > FORCE_LEVEL_1 &&
+				(pm->ps->groundEntityNum != ENTITYNUM_NONE || PM_GroundDistance() <= 40) &&
+				pm->ps->velocity[2] >= 0 &&
+				(pm->cmd.upmove > 0 || pm->ps->pm_flags & PMF_JUMP_HELD) &&
+				!BG_SaberInTransitionAny(pm->ps->saberMove) &&
+				!BG_SaberInAttack(pm->ps->saberMove) &&
+				pm->ps->weaponTime <= 0 &&
+				pm->ps->forceHandExtend == HANDEXTEND_NONE &&
+				(pm->cmd.buttons & BUTTON_ATTACK))
+			{ //BACKFLIP ATTACK
+				newmove = PM_SaberBackflipAttackMove();
+			}
+			else if (PM_CanBackstab() && !BG_SaberInSpecialAttack(pm->ps->torsoAnim))
+			{ //BACKSTAB (attack varies by level)
+				if (pm->ps->fd.saberAnimLevel >= FORCE_LEVEL_2 && pm->ps->fd.saberAnimLevel != SS_STAFF)
+				{//medium and higher attacks
+					if ( (pm->ps->pm_flags&PMF_DUCKED) || pm->cmd.upmove < 0 )
+					{
+						newmove = LS_A_BACK_CR;
+					}
+					else
+					{
+						newmove = LS_A_BACK;
+					}
+				}
+				else
+				{ //weak attack
+					newmove = LS_A_BACKSTAB;
+				}
+			}
+			else
+			{
+				newmove = LS_A_T2B;
+			}
+		}
+		else if ( PM_SaberInBounce( curmove ) )
+		{//bounces should go to their default attack if you don't specify a direction but are attacking
+			newmove = saberMoveData[curmove].chain_attack;
+
+			if ( PM_SaberKataDone(curmove, newmove) )
+			{
+				newmove = saberMoveData[curmove].chain_idle;
+			}
+			else
+			{
+				newmove = saberMoveData[curmove].chain_attack;
+			}
+		}
+		else if ( curmove == LS_READY )
+		{//Not moving at all, shouldn't have gotten here...?
+			//for now, just pick a random attack
+			//newmove = Q_irand( LS_A_TL2BR, LS_A_T2B );
+			//rww - If we don't seed with a "common" value, the client and server will get mismatched
+			//prediction values. Under laggy conditions this will cause the appearance of rapid swing
+			//sequence changes.
+
+			newmove = LS_A_T2B; //decided we don't like random attacks when idle, use an overhead instead.
+		}
+	}
+
+	if (pm->ps->fd.saberAnimLevel == SS_DUAL)
+	{
+		if ( ( newmove == LS_A_R2L || newmove == LS_S_R2L
+					|| newmove == LS_A_L2R  || newmove == LS_S_L2R )
+			&& PM_CanDoDualDoubleAttacks()
+			&& PM_CheckEnemyPresence( DIR_RIGHT, 100.0f )
+			&& PM_CheckEnemyPresence( DIR_LEFT, 100.0f ) )
+		{//enemy both on left and right
+			newmove = LS_DUAL_LR;
+			//probably already moved, but...
+			pm->cmd.rightmove = 0;
+		}
+		else if ( (newmove == LS_A_T2B || newmove == LS_S_T2B
+					|| newmove == LS_A_BACK || newmove == LS_A_BACK_CR )
+			&& PM_CanDoDualDoubleAttacks()
+			&& PM_CheckEnemyPresence( DIR_FRONT, 100.0f )
+			&& PM_CheckEnemyPresence( DIR_BACK, 100.0f ) )
+		{//enemy both in front and back
+			newmove = LS_DUAL_FB;
+			//probably already moved, but...
+			pm->cmd.forwardmove = 0;
+		}
+	}
+
+	return newmove;
+}
+
+int PM_KickMoveForConditions(void)
+{
+	int kickMove = -1;
+
+	//FIXME: only if FP_SABER_OFFENSE >= 3
+	if ( pm->cmd.rightmove )
+	{//kick to side
+		if ( pm->cmd.rightmove > 0 )
+		{//kick right
+			kickMove = LS_KICK_R;
+		}
+		else
+		{//kick left
+			kickMove = LS_KICK_L;
+		}
+		pm->cmd.rightmove = 0;
+	}
+	else if ( pm->cmd.forwardmove )
+	{//kick front/back
+		if ( pm->cmd.forwardmove > 0 )
+		{//kick fwd
+			/*
+			if (pm->ps->groundEntityNum != ENTITYNUM_NONE &&
+				PM_CheckEnemyPresence( DIR_FRONT, 64.0f ))
+			{
+				kickMove = LS_HILT_BASH;
+			}
+			else
+			*/
+			{
+				kickMove = LS_KICK_F;
+			}
+		}
+		else
+		{//kick back
+			kickMove = LS_KICK_B;
+		}
+		pm->cmd.forwardmove = 0;
+	}
+	else
+	{
+		//if (pm->cmd.buttons & BUTTON_ATTACK)
+		//if (pm->ps->pm_flags & PMF_JUMP_HELD)
+		if (0)
+		{ //ok, let's try some fancy kicks
+			//qboolean is actually of type int anyway, but just for safeness.
+			int front = (int)PM_CheckEnemyPresence( DIR_FRONT, 100.0f );
+			int back = (int)PM_CheckEnemyPresence( DIR_BACK, 100.0f );
+			int right = (int)PM_CheckEnemyPresence( DIR_RIGHT, 100.0f );
+			int left = (int)PM_CheckEnemyPresence( DIR_LEFT, 100.0f );
+			int numEnemy = front+back+right+left;
+
+			if (numEnemy >= 3 ||
+				((!right || !left) && numEnemy >= 2))
+			{ //> 2 enemies near, or, >= 2 enemies near and they are not to the right and left.
+                kickMove = LS_KICK_S;
+			}
+			else if (right && left)
+			{ //enemies on both sides
+				kickMove = LS_KICK_RL;
+			}
+			else
+			{ //oh well, just do a forward kick
+				kickMove = LS_KICK_F;
+			}
+
+			pm->cmd.upmove = 0;
+		}
+	}
+
+	return kickMove;
+}
+
+qboolean BG_InSlopeAnim( int anim );
+qboolean PM_RunningAnim( int anim );
+
+qboolean PM_SaberMoveOkayForKata( void )
+{
+	if ( pm->ps->saberMove == LS_READY
+		|| PM_SaberInStart( pm->ps->saberMove ) )
+	{
+		return qtrue;
+	}
+	else
+	{
+		return qfalse;
+	}
+}
+
+qboolean PM_CanDoKata( void )
+{
+	if ( PM_InSecondaryStyle() )
+	{
+		return qfalse;
+	}
+	if ( !pm->ps->saberInFlight//not throwing saber
+		&& PM_SaberMoveOkayForKata()
+		&& !BG_SaberInKata(pm->ps->saberMove)
+		&& !BG_InKataAnim(pm->ps->legsAnim)
+		&& !BG_InKataAnim(pm->ps->torsoAnim)
+		/*
+		&& pm->ps->saberAnimLevel >= SS_FAST//fast, med or strong style
+		&& pm->ps->saberAnimLevel <= SS_STRONG//FIXME: Tavion, too?
+		*/
+		&& pm->ps->groundEntityNum != ENTITYNUM_NONE//not in the air
+		&& (pm->cmd.buttons&BUTTON_ATTACK)//pressing attack
+		&& (pm->cmd.buttons&BUTTON_ALT_ATTACK)//pressing alt attack
+		&& !pm->cmd.forwardmove//not moving f/b
+		&& !pm->cmd.rightmove//not moving r/l
+		&& pm->cmd.upmove <= 0//not jumping...?
+		&& BG_EnoughForcePowerForMove(SABER_ALT_ATTACK_POWER) )// have enough power
+	{//FIXME: check rage, etc...
+		return qtrue;
+	}
+	return qfalse;
+}
+
+qboolean PM_CheckAltKickAttack( void )
+{
+	if ( (pm->cmd.buttons&BUTTON_ALT_ATTACK) 
+		//&& (!(pm->ps->pm_flags&PMF_ALT_ATTACK_HELD)||PM_SaberInReturn(pm->ps->saberMove))
+		&& (!BG_FlippingAnim(pm->ps->legsAnim)||pm->ps->legsTimer<=250)
+		&& (pm->ps->fd.saberAnimLevel == SS_STAFF/*||!pm->ps->saber[0].throwable*/) && !pm->ps->saberHolstered )
+	{
+		return qtrue;
+	}
+	return qfalse;
+}
+
+int bg_parryDebounce[NUM_FORCE_POWER_LEVELS] =
+{
+	500,//if don't even have defense, can't use defense!
+	300,
+	150,
+	50
+};
+
+qboolean PM_SaberPowerCheck(void)
+{
+	if (pm->ps->saberInFlight)
+	{ //so we don't keep doing stupid force out thing while guiding saber.
+		if (pm->ps->fd.forcePower > forcePowerNeeded[pm->ps->fd.forcePowerLevel[FP_SABERTHROW]][FP_SABERTHROW])
+		{
+			return qtrue;
+		}
+	}
+	else
+	{
+		return BG_EnoughForcePowerForMove(forcePowerNeeded[pm->ps->fd.forcePowerLevel[FP_SABERTHROW]][FP_SABERTHROW]);
+	}
+
+	return qfalse;
+}
+
+/*
+=================
+PM_WeaponLightsaber
+
+Consults a chart to choose what to do with the lightsaber.
+While this is a little different than the Quake 3 code, there is no clean way of using the Q3 code for this kind of thing.
+=================
+*/
+// Ultimate goal is to set the sabermove to the proper next location
+// Note that if the resultant animation is NONE, then the animation is essentially "idle", and is set in WP_TorsoAnim
+qboolean PM_WalkingAnim( int anim );
+qboolean PM_SwimmingAnim( int anim );
+int PM_SaberBounceForAttack( int move );
+qboolean BG_SuperBreakLoseAnim( int anim );
+qboolean BG_SuperBreakWinAnim( int anim );
+void PM_WeaponLightsaber(void)
+{
+	int			addTime,amount;
+	qboolean	delayed_fire = qfalse;
+	int			anim=-1, curmove, newmove=LS_NONE;
+
+	qboolean checkOnlyWeap = qfalse;
+
+	if ( PM_InKnockDown( pm->ps ) || BG_InRoll( pm->ps, pm->ps->legsAnim ))
+	{//in knockdown
+		// make weapon function
+		if ( pm->ps->weaponTime > 0 ) {
+			pm->ps->weaponTime -= pml.msec;
+			if ( pm->ps->weaponTime <= 0 )
+			{
+				pm->ps->weaponTime = 0;
+			}
+		}
+		if ( pm->ps->legsAnim == BOTH_ROLL_F 
+			&& pm->ps->legsTimer <= 250 )
+		{
+			if ( (pm->cmd.buttons&BUTTON_ATTACK) )
+			{
+				if ( BG_EnoughForcePowerForMove(SABER_ALT_ATTACK_POWER_FB) && !pm->ps->saberInFlight )
+				{
+					//make sure the saber is on for this move!
+					if ( pm->ps->saberHolstered == 2 )
+					{//all the way off
+						pm->ps->saberHolstered = 0;
+						PM_AddEvent(EV_SABER_UNHOLSTER);
+					}
+					PM_SetSaberMove( LS_ROLL_STAB );
+					BG_ForcePowerDrain(pm->ps, FP_GRIP, SABER_ALT_ATTACK_POWER_FB);
+				}
+			}
+		}
+		return;
+	}
+
+ 	if ( pm->ps->saberLockTime > pm->cmd.serverTime )
+	{
+		pm->ps->saberMove = LS_NONE;
+		PM_SaberLocked();
+		return;
+	}
+	else
+	{
+		if ( /*( (pm->ps->torsoAnim) == BOTH_BF2LOCK ||
+				(pm->ps->torsoAnim) == BOTH_BF1LOCK ||
+				(pm->ps->torsoAnim) == BOTH_CWCIRCLELOCK ||
+				(pm->ps->torsoAnim) == BOTH_CCWCIRCLELOCK ||*/
+				pm->ps->saberLockFrame
+			)
+		{
+			if (pm->ps->saberLockEnemy < ENTITYNUM_NONE &&
+				pm->ps->saberLockEnemy >= 0)
+			{
+				bgEntity_t *bgEnt;
+				playerState_t *en;
+
+				bgEnt = PM_BGEntForNum(pm->ps->saberLockEnemy);
+
+				if (bgEnt)
+				{
+					en = bgEnt->playerState;
+
+					if (en)
+					{
+						PM_SaberLockBreak(en, qfalse, 0);
+						return;
+					}
+				}
+			}
+
+			if (/* ( (pm->ps->torsoAnim) == BOTH_BF2LOCK ||
+					(pm->ps->torsoAnim) == BOTH_BF1LOCK ||
+					(pm->ps->torsoAnim) == BOTH_CWCIRCLELOCK ||
+					(pm->ps->torsoAnim) == BOTH_CCWCIRCLELOCK ||*/
+					pm->ps->saberLockFrame
+				)
+			{
+				pm->ps->torsoTimer = 0;
+				PM_SetAnim(SETANIM_TORSO,BOTH_STAND1,SETANIM_FLAG_OVERRIDE, 100);
+				pm->ps->saberLockFrame = 0;
+			}
+		}
+	}
+
+	if ( BG_KickingAnim( pm->ps->legsAnim ) ||
+		BG_KickingAnim( pm->ps->torsoAnim ))
+	{
+		if ( pm->ps->legsTimer > 0 )
+		{//you're kicking, no interruptions
+			return;
+		}
+		//done?  be immeditately ready to do an attack
+		pm->ps->saberMove = LS_READY;
+		pm->ps->weaponTime = 0;
+	}
+
+	if ( BG_SuperBreakLoseAnim( pm->ps->torsoAnim )
+		|| BG_SuperBreakWinAnim( pm->ps->torsoAnim ) )
+	{
+		if ( pm->ps->torsoTimer > 0 )
+		{//never interrupt these
+			return;
+		}
+	}
+
+	if (BG_SabersOff( pm->ps ))
+	{
+		if (pm->ps->saberMove != LS_READY)
+		{
+			PM_SetSaberMove( LS_READY );
+		}
+
+		if ((pm->ps->legsAnim) != (pm->ps->torsoAnim) && !BG_InSlopeAnim(pm->ps->legsAnim) &&
+			pm->ps->torsoTimer <= 0)
+		{
+			PM_SetAnim(SETANIM_TORSO,(pm->ps->legsAnim),SETANIM_FLAG_OVERRIDE, 100);
+		}
+		else if (BG_InSlopeAnim(pm->ps->legsAnim) && pm->ps->torsoTimer <= 0)
+		{
+			PM_SetAnim(SETANIM_TORSO,PM_GetSaberStance(),SETANIM_FLAG_OVERRIDE, 100);
+		}
+
+		if (pm->ps->weaponTime < 1 && ((pm->cmd.buttons & BUTTON_ALT_ATTACK) || (pm->cmd.buttons & BUTTON_ATTACK)))
+		{
+			if (pm->ps->duelTime < pm->cmd.serverTime)
+			{
+				if (!pm->ps->m_iVehicleNum)
+				{ //don't let em unholster the saber by attacking while on vehicle
+					pm->ps->saberHolstered = 0;
+					PM_AddEvent(EV_SABER_UNHOLSTER);
+				}
+				else
+				{
+					pm->cmd.buttons &= ~BUTTON_ALT_ATTACK;
+					pm->cmd.buttons &= ~BUTTON_ATTACK;
+				}
+			}
+		}
+
+		if ( pm->ps->weaponTime > 0 )
+		{
+			pm->ps->weaponTime -= pml.msec;
+		}
+
+		checkOnlyWeap = qtrue;
+		goto weapChecks;
+	}
+
+	if (!pm->ps->saberEntityNum && pm->ps->saberInFlight)
+	{ //this means our saber has been knocked away
+		/*
+		if (pm->ps->saberMove != LS_READY)
+		{
+			PM_SetSaberMove( LS_READY );
+		}
+
+		if ((pm->ps->legsAnim) != (pm->ps->torsoAnim) && !BG_InSlopeAnim(pm->ps->legsAnim))
+		{
+			PM_SetAnim(SETANIM_TORSO,(pm->ps->legsAnim),SETANIM_FLAG_OVERRIDE, 100);
+		}
+
+		if (BG_InSaberStandAnim(pm->ps->torsoAnim) || pm->ps->torsoAnim == BOTH_SABERPULL)
+		{
+			PM_SetAnim(SETANIM_TORSO,BOTH_STAND1,SETANIM_FLAG_OVERRIDE, 100);
+		}
+
+		return;
+		*/
+		//Old method, don't want to do this now because we want to finish up reflected attacks and things
+		//if our saber is pried out of our hands from one.
+		if ( pm->ps->fd.saberAnimLevel == SS_DUAL )
+		{
+			if ( pm->ps->saberHolstered > 1 )
+			{
+				pm->ps->saberHolstered = 1;
+			}
+		}
+		else
+		{
+			pm->cmd.buttons &= ~BUTTON_ATTACK;
+		}
+		pm->cmd.buttons &= ~BUTTON_ALT_ATTACK;
+	}
+
+	if ( (pm->cmd.buttons & BUTTON_ALT_ATTACK) )
+	{ //might as well just check for a saber throw right here
+		if (pm->ps->fd.saberAnimLevel == SS_STAFF)
+		{ //kick instead of doing a throw 
+			//if in a saber attack return anim, can interrupt it with a kick
+			if ( pm->ps->weaponTime > 0//can't fire yet
+				&& PM_SaberInReturn( pm->ps->saberMove )//in a saber return move - FIXME: what about transitions?
+				//&& pm->ps->weaponTime <= 250//should be able to fire soon
+				//&& pm->ps->torsoTimer <= 250//torso almost done
+				&& pm->ps->saberBlocked == BLOCKED_NONE//not interacting with any other saber
+				&& !(pm->cmd.buttons&BUTTON_ATTACK) )//not trying to swing the saber
+			{
+				if ( (pm->cmd.forwardmove||pm->cmd.rightmove)//trying to kick in a specific direction
+					&& PM_CheckAltKickAttack() )//trying to do a kick
+				{//allow them to do the kick now!
+					int kickMove = PM_KickMoveForConditions();
+					if (kickMove != -1)
+					{
+						pm->ps->weaponTime = 0;
+						PM_SetSaberMove( kickMove );
+						return;
+					}
+				}
+			}
+		}
+		else if ( pm->ps->weaponTime < 1&&
+				pm->ps->saberCanThrow &&
+				//pm->ps->fd.forcePower >= forcePowerNeeded[pm->ps->fd.forcePowerLevel[FP_SABERTHROW]][FP_SABERTHROW] &&
+				!BG_HasYsalamiri(pm->gametype, pm->ps) &&
+				BG_CanUseFPNow(pm->gametype, pm->ps, pm->cmd.serverTime, FP_SABERTHROW) &&
+				pm->ps->fd.forcePowerLevel[FP_SABERTHROW] > 0 &&
+				PM_SaberPowerCheck() )
+		{
+			trace_t sabTr;
+			vec3_t	fwd, minFwd, sabMins, sabMaxs;
+
+			VectorSet( sabMins, SABERMINS_X, SABERMINS_Y, SABERMINS_Z );
+			VectorSet( sabMaxs, SABERMAXS_X, SABERMAXS_Y, SABERMAXS_Z );
+
+			AngleVectors( pm->ps->viewangles, fwd, NULL, NULL );
+			VectorMA( pm->ps->origin, SABER_MIN_THROW_DIST, fwd, minFwd );
+
+			pm->trace(&sabTr, pm->ps->origin, sabMins, sabMaxs, minFwd, pm->ps->clientNum, MASK_PLAYERSOLID);
+
+			if ( sabTr.allsolid || sabTr.startsolid || sabTr.fraction < 1.0f )
+			{//not enough room to throw
+			}
+			else
+			{//throw it
+				//This will get set to false again once the saber makes it back to its owner game-side
+				if (!pm->ps->saberInFlight)
+				{
+					pm->ps->fd.forcePower -= forcePowerNeeded[pm->ps->fd.forcePowerLevel[FP_SABERTHROW]][FP_SABERTHROW];
+				}
+
+				pm->ps->saberInFlight = qtrue;
+			}
+		}
+	}
+	
+	if ( pm->ps->saberInFlight && pm->ps->saberEntityNum )
+	{//guiding saber
+		if ( (pm->ps->fd.saberAnimLevel != SS_DUAL //not using 2 sabers
+			  || pm->ps->saberHolstered //left one off - FIXME: saberHolstered 1 should be left one off, 0 should be both on, 2 should be both off
+			  || (!(pm->cmd.buttons&BUTTON_ATTACK)//not trying to start an attack AND...
+				  && (pm->ps->torsoAnim == BOTH_SABERDUAL_STANCE//not already attacking
+					  || pm->ps->torsoAnim == BOTH_SABERPULL//not already attacking
+					  || pm->ps->torsoAnim == BOTH_STAND1//not already attacking
+					  || PM_RunningAnim( pm->ps->torsoAnim ) //not already attacking
+					  || PM_WalkingAnim( pm->ps->torsoAnim ) //not already attacking
+					  || PM_JumpingAnim( pm->ps->torsoAnim )//not already attacking
+					  || PM_SwimmingAnim( pm->ps->torsoAnim ))//not already attacking
+				)
+			  )
+			)
+		{
+			PM_SetAnim(SETANIM_TORSO, BOTH_SABERPULL, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD, 100);
+			pm->ps->torsoTimer = 1;
+			return;
+		}
+	}
+
+   // don't allow attack until all buttons are up
+	//This is bad. It freezes the attack state and the animations if you hold the button after respawning, and it looks strange.
+	/*
+	if ( pm->ps->pm_flags & PMF_RESPAWNED ) {
+		return;
+	}
+	*/
+
+	// check for dead player
+	if ( pm->ps->stats[STAT_HEALTH] <= 0 ) {
+		return;
+	}
+
+	/*
+
+	if (pm->ps->weaponstate == WEAPON_READY ||
+		pm->ps->weaponstate == WEAPON_IDLE)
+	{
+		if (pm->ps->saberMove != LS_READY && pm->ps->weaponTime <= 0 && !pm->ps->saberBlocked)
+		{
+			PM_SetSaberMove( LS_READY );
+		}
+	}
+
+	if(PM_RunningAnim(pm->ps->torsoAnim))
+	{
+		if ((pm->ps->torsoAnim) != (pm->ps->legsAnim))
+		{
+			PM_SetAnim(SETANIM_TORSO,(pm->ps->legsAnim),SETANIM_FLAG_OVERRIDE, 100);
+		}
+	}
+	*/
+
+	// make weapon function
+	if ( pm->ps->weaponTime > 0 )
+	{
+		//check for special pull move while busy
+		saberMoveName_t pullmove = PM_CheckPullAttack();
+		if (pullmove != LS_NONE)
+		{
+			pm->ps->weaponTime = 0;
+			pm->ps->torsoTimer = 0;
+			pm->ps->legsTimer = 0;
+			pm->ps->forceHandExtend = HANDEXTEND_NONE;
+			pm->ps->weaponstate = WEAPON_READY;
+			PM_SetSaberMove(pullmove);
+			return;
+		}
+
+		pm->ps->weaponTime -= pml.msec;
+
+		//This was stupid and didn't work right. Looks like things are fine without it.
+	//	if (pm->ps->saberBlocked && pm->ps->torsoAnim != saberMoveData[pm->ps->saberMove].animToUse)
+	//	{ //rww - keep him in the blocking pose until he can attack again
+	//		PM_SetAnim(SETANIM_TORSO,saberMoveData[pm->ps->saberMove].animToUse,saberMoveData[pm->ps->saberMove].animSetFlags|SETANIM_FLAG_HOLD, saberMoveData[pm->ps->saberMove].blendTime);
+	//		return;
+	//	}
+	}
+	else
+	{
+		pm->ps->weaponstate = WEAPON_READY;
+	}
+
+	// Now we react to a block action by the player's lightsaber.
+	if ( pm->ps->saberBlocked )
+	{
+		if ( pm->ps->saberBlocked >= BLOCKED_UPPER_RIGHT 
+			&& pm->ps->saberBlocked < BLOCKED_UPPER_RIGHT_PROJ)
+		{//hold the parry for a bit
+			pm->ps->weaponTime = bg_parryDebounce[pm->ps->fd.forcePowerLevel[FP_SABER_DEFENSE]]+200;
+		}
+		switch ( pm->ps->saberBlocked )
+		{
+			case BLOCKED_BOUNCE_MOVE:
+				{ //act as a bounceMove and reset the saberMove instead of using a seperate value for it
+					pm->ps->torsoTimer = 0;
+					PM_SetSaberMove( pm->ps->saberMove );
+					pm->ps->weaponTime = pm->ps->torsoTimer;
+					pm->ps->saberBlocked = 0;
+				}
+				break;
+			case BLOCKED_PARRY_BROKEN:
+				//whatever parry we were is in now broken, play the appropriate knocked-away anim
+				{
+					int nextMove;
+
+					if ( PM_SaberInBrokenParry( pm->ps->saberMove ) )
+					{//already have one...?
+						nextMove = pm->ps->saberMove;
+					}
+					else
+					{
+						nextMove = PM_BrokenParryForParry( pm->ps->saberMove );
+					}
+					if ( nextMove != LS_NONE )
+					{
+						PM_SetSaberMove( nextMove );
+						pm->ps->weaponTime = pm->ps->torsoTimer;
+					}
+					else
+					{//Maybe in a knockaway?
+					}
+				}
+				break;
+			case BLOCKED_ATK_BOUNCE:
+				// If there is absolutely no blocked move in the chart, don't even mess with the animation.
+				// OR if we are already in a block or parry.
+				if (pm->ps->saberMove >= LS_T1_BR__R)
+				{//an actual bounce?  Other bounces before this are actually transitions?
+					pm->ps->saberBlocked = BLOCKED_NONE;
+				}
+				else
+				{
+					int bounceMove;
+
+					if ( PM_SaberInBounce( pm->ps->saberMove ) || !BG_SaberInAttack( pm->ps->saberMove ) )
+					{
+						if ( pm->cmd.buttons & BUTTON_ATTACK )
+						{//transition to a new attack
+							int newQuad = PM_SaberMoveQuadrantForMovement( &pm->cmd );
+							while ( newQuad == saberMoveData[pm->ps->saberMove].startQuad )
+							{//player is still in same attack quad, don't repeat that attack because it looks bad, 
+								//FIXME: try to pick one that might look cool?
+								//newQuad = Q_irand( Q_BR, Q_BL );
+								newQuad = PM_irand_timesync( Q_BR, Q_BL );
+								//FIXME: sanity check, just in case?
+							}//else player is switching up anyway, take the new attack dir
+							bounceMove = transitionMove[saberMoveData[pm->ps->saberMove].startQuad][newQuad];
+						}
+						else
+						{//return to ready
+							if ( saberMoveData[pm->ps->saberMove].startQuad == Q_T )
+							{
+								bounceMove = LS_R_BL2TR;
+							}
+							else if ( saberMoveData[pm->ps->saberMove].startQuad < Q_T )
+							{
+								bounceMove = LS_R_TL2BR+saberMoveData[pm->ps->saberMove].startQuad-Q_BR;
+							}
+							else// if ( saberMoveData[pm->ps->saberMove].startQuad > Q_T )
+							{
+								bounceMove = LS_R_BR2TL+saberMoveData[pm->ps->saberMove].startQuad-Q_TL;
+							}
+						}
+					}
+					else
+					{//start the bounce
+						bounceMove = PM_SaberBounceForAttack( (saberMoveName_t)pm->ps->saberMove );
+					}
+
+					PM_SetSaberMove( bounceMove );
+
+					pm->ps->weaponTime = pm->ps->torsoTimer;//+saberMoveData[bounceMove].blendTime+SABER_BLOCK_DUR;
+
+				}
+				break;
+			case BLOCKED_UPPER_RIGHT:
+				PM_SetSaberMove( LS_PARRY_UR );
+				break;
+			case BLOCKED_UPPER_RIGHT_PROJ:
+				PM_SetSaberMove( LS_REFLECT_UR );
+				break;
+			case BLOCKED_UPPER_LEFT:
+				PM_SetSaberMove( LS_PARRY_UL );
+				break;
+			case BLOCKED_UPPER_LEFT_PROJ:
+				PM_SetSaberMove( LS_REFLECT_UL );
+				break;
+			case BLOCKED_LOWER_RIGHT:
+				PM_SetSaberMove( LS_PARRY_LR );
+				break;
+			case BLOCKED_LOWER_RIGHT_PROJ:
+				PM_SetSaberMove( LS_REFLECT_LR );
+				break;
+			case BLOCKED_LOWER_LEFT:
+				PM_SetSaberMove( LS_PARRY_LL );
+				break;
+			case BLOCKED_LOWER_LEFT_PROJ:
+				PM_SetSaberMove( LS_REFLECT_LL);
+				break;
+			case BLOCKED_TOP:
+				PM_SetSaberMove( LS_PARRY_UP );
+				break;
+			case BLOCKED_TOP_PROJ:
+				PM_SetSaberMove( LS_REFLECT_UP );
+				break;
+			default:
+				pm->ps->saberBlocked = BLOCKED_NONE;
+				break;
+		}
+		if ( pm->ps->saberBlocked >= BLOCKED_UPPER_RIGHT 
+			&& pm->ps->saberBlocked < BLOCKED_UPPER_RIGHT_PROJ)
+		{//hold the parry for a bit
+			if ( pm->ps->torsoTimer < pm->ps->weaponTime )
+			{
+				pm->ps->torsoTimer = pm->ps->weaponTime;
+			}
+		}
+
+		//what the? I don't know why I was doing this.
+		/*
+		if (pm->ps->saberBlocked != BLOCKED_ATK_BOUNCE && pm->ps->saberBlocked != BLOCKED_PARRY_BROKEN && pm->ps->weaponTime < 1)
+		{
+			pm->ps->torsoTimer = SABER_BLOCK_DUR;
+			pm->ps->weaponTime = pm->ps->torsoTimer;
+		}
+		*/
+
+		//clear block
+		pm->ps->saberBlocked = 0;
+
+		// Charging is like a lead-up before attacking again.  This is an appropriate use, or we can create a new weaponstate for blocking
+		pm->ps->weaponstate = WEAPON_READY;
+
+		// Done with block, so stop these active weapon branches.
+		return;
+	}
+
+weapChecks:
+	if (pm->ps->saberEntityNum)
+	{ //only check if we have our saber with us
+		// check for weapon change
+		// can't change if weapon is firing, but can change again if lowering or raising
+		//if ( pm->ps->weaponTime <= 0 || pm->ps->weaponstate != WEAPON_FIRING ) {
+		if (pm->ps->weaponTime <= 0 && pm->ps->torsoTimer <= 0)
+		{
+			if ( pm->ps->weapon != pm->cmd.weapon ) {
+				PM_BeginWeaponChange( pm->cmd.weapon );
+			}
+		}
+	}
+
+	if ( PM_CanDoKata() )
+	{
+		//FIXME: make sure to turn on saber(s)!
+		switch ( pm->ps->fd.saberAnimLevel )
+		{
+		case SS_FAST:
+		case SS_TAVION:
+			PM_SetSaberMove( LS_A1_SPECIAL );
+			break;
+		case SS_MEDIUM:
+			PM_SetSaberMove( LS_A2_SPECIAL );
+			break;
+		case SS_STRONG:
+		case SS_DESANN:
+			PM_SetSaberMove( LS_A3_SPECIAL );
+			break;
+		case SS_DUAL:
+			PM_SetSaberMove( LS_DUAL_SPIN_PROTECT );//PM_CheckDualSpinProtect();
+			break;
+		case SS_STAFF:
+			PM_SetSaberMove( LS_STAFF_SOULCAL );
+			break;
+		}
+		pm->ps->weaponstate = WEAPON_FIRING;
+		//G_DrainPowerForSpecialMove( pm->gent, FP_SABER_OFFENSE, SABER_ALT_ATTACK_POWER );//FP_SPEED, SINGLE_SPECIAL_POWER );
+		BG_ForcePowerDrain(pm->ps, FP_GRIP, SABER_ALT_ATTACK_POWER);
+		return;
+	}
+
+	if ( pm->ps->weaponTime > 0 ) 
+	{
+		return;
+	}
+
+	// *********************************************************
+	// WEAPON_DROPPING
+	// *********************************************************
+
+	// change weapon if time
+	if ( pm->ps->weaponstate == WEAPON_DROPPING ) {
+		PM_FinishWeaponChange();
+		return;
+	}
+
+	// *********************************************************
+	// WEAPON_RAISING
+	// *********************************************************
+
+	if ( pm->ps->weaponstate == WEAPON_RAISING ) 
+	{//Just selected the weapon
+		pm->ps->weaponstate = WEAPON_IDLE;
+		if((pm->ps->legsAnim) == BOTH_WALK1 )
+		{
+			PM_SetAnim(SETANIM_TORSO,BOTH_WALK1,SETANIM_FLAG_NORMAL, 100);
+		}
+		else if((pm->ps->legsAnim) == BOTH_RUN1 )
+		{
+			PM_SetAnim(SETANIM_TORSO,BOTH_RUN1,SETANIM_FLAG_NORMAL, 100);
+		}
+		else if((pm->ps->legsAnim) == BOTH_RUN2 )
+		{
+			PM_SetAnim(SETANIM_TORSO,BOTH_RUN2,SETANIM_FLAG_NORMAL, 100);
+		}
+		else if( pm->ps->legsAnim == BOTH_RUN_STAFF)
+		{
+			PM_SetAnim(SETANIM_TORSO,BOTH_RUN_STAFF,SETANIM_FLAG_NORMAL, 100);
+		}
+		else if( pm->ps->legsAnim == BOTH_RUN_DUAL)
+		{
+			PM_SetAnim(SETANIM_TORSO,BOTH_RUN_DUAL,SETANIM_FLAG_NORMAL, 100);
+		}
+		else if((pm->ps->legsAnim) == BOTH_WALK1 )
+		{
+			PM_SetAnim(SETANIM_TORSO,BOTH_WALK1,SETANIM_FLAG_NORMAL, 100);
+		}
+		else if( pm->ps->legsAnim == BOTH_WALK2)
+		{
+			PM_SetAnim(SETANIM_TORSO,BOTH_WALK2,SETANIM_FLAG_NORMAL, 100);
+		}
+		else if( pm->ps->legsAnim == BOTH_WALK_STAFF)
+		{
+			PM_SetAnim(SETANIM_TORSO,BOTH_WALK_STAFF,SETANIM_FLAG_NORMAL, 100);
+		}
+		else if( pm->ps->legsAnim == BOTH_WALK_DUAL)
+		{
+			PM_SetAnim(SETANIM_TORSO,BOTH_WALK_DUAL,SETANIM_FLAG_NORMAL, 100);
+		}
+		else
+		{
+			PM_SetAnim(SETANIM_TORSO,PM_GetSaberStance(),SETANIM_FLAG_NORMAL, 100);
+		}
+
+		if (pm->ps->weaponstate == WEAPON_RAISING)
+		{
+			return;
+		}
+
+	}
+
+	if (checkOnlyWeap)
+	{
+		return;
+	}
+
+	// *********************************************************
+	// Check for WEAPON ATTACK
+	// *********************************************************
+	if (pm->ps->fd.saberAnimLevel == SS_STAFF &&
+		(pm->cmd.buttons & BUTTON_ALT_ATTACK))
+	{ //ok, try a kick I guess.
+		int kickMove = -1;
+
+		if ( !BG_KickingAnim(pm->ps->torsoAnim) &&
+			!BG_KickingAnim(pm->ps->legsAnim) &&
+			!BG_InRoll(pm->ps, pm->ps->legsAnim) &&
+//			!BG_KickMove( pm->ps->saberMove )//not already in a kick
+			pm->ps->saberMove == LS_READY
+			&& !(pm->ps->pm_flags&PMF_DUCKED)//not ducked
+			&& (pm->cmd.upmove >= 0 ) //not trying to duck
+			)//&& pm->ps->groundEntityNum != ENTITYNUM_NONE)
+		{//player kicks
+			kickMove = PM_KickMoveForConditions();
+		}
+
+		if (kickMove != -1)
+		{
+			if ( pm->ps->groundEntityNum == ENTITYNUM_NONE )
+			{//if in air, convert kick to an in-air kick
+				float gDist = PM_GroundDistance();
+				//let's only allow air kicks if a certain distance from the ground
+				//it's silly to be able to do them right as you land.
+				//also looks wrong to transition from a non-complete flip anim...
+				if ((!BG_FlippingAnim( pm->ps->legsAnim ) || pm->ps->legsTimer <= 0) &&
+					gDist > 64.0f && //strict minimum
+					gDist > (-pm->ps->velocity[2])-64.0f //make sure we are high to ground relative to downward velocity as well
+					)
+				{
+					switch ( kickMove )
+					{
+					case LS_KICK_F:
+						kickMove = LS_KICK_F_AIR;
+						break;
+					case LS_KICK_B:
+						kickMove = LS_KICK_B_AIR;
+						break;
+					case LS_KICK_R:
+						kickMove = LS_KICK_R_AIR;
+						break;
+					case LS_KICK_L:
+						kickMove = LS_KICK_L_AIR;
+						break;
+					default: //oh well, can't do any other kick move while in-air
+						kickMove = -1;
+						break;
+					}
+				}
+				else
+				{//leave it as a normal kick unless we're too high up
+					if ( gDist > 128.0f || pm->ps->velocity[2] >= 0 )
+					{ //off ground, but too close to ground
+						kickMove = -1;
+					}
+				}
+			}
+
+			if (kickMove != -1)
+			{
+				PM_SetSaberMove( kickMove );
+				return;
+			}
+		}
+	}
+
+	//this is never a valid regular saber attack button
+	pm->cmd.buttons &= ~BUTTON_ALT_ATTACK;
+
+	if(!delayed_fire)
+	{
+		// Start with the current move, and cross index it with the current control states.
+		if ( pm->ps->saberMove > LS_NONE && pm->ps->saberMove < LS_MOVE_MAX )
+		{
+			curmove = pm->ps->saberMove;
+		}
+		else
+		{
+			curmove = LS_READY;
+		}
+
+		if ( curmove == LS_A_JUMP_T__B_ || pm->ps->torsoAnim == BOTH_FORCELEAP2_T__B_ )
+		{//must transition back to ready from this anim
+			newmove = LS_R_T2B;
+		}
+		// check for fire
+		else if ( !(pm->cmd.buttons & (BUTTON_ATTACK|BUTTON_ALT_ATTACK)) )
+		{//not attacking
+			pm->ps->weaponTime = 0;
+			
+			if ( pm->ps->weaponTime > 0 )
+			{//Still firing
+				pm->ps->weaponstate = WEAPON_FIRING;
+			}
+			else if ( pm->ps->weaponstate != WEAPON_READY )
+			{
+				pm->ps->weaponstate = WEAPON_IDLE;
+			}
+			//Check for finishing an anim if necc.
+			if ( curmove >= LS_S_TL2BR && curmove <= LS_S_T2B )
+			{//started a swing, must continue from here
+				newmove = LS_A_TL2BR + (curmove-LS_S_TL2BR);
+			}
+			else if ( curmove >= LS_A_TL2BR && curmove <= LS_A_T2B )
+			{//finished an attack, must continue from here
+				newmove = LS_R_TL2BR + (curmove-LS_A_TL2BR);
+			}
+			else if ( PM_SaberInTransition( curmove ) )
+			{//in a transition, must play sequential attack
+				newmove = saberMoveData[curmove].chain_attack;
+			}
+			else if ( PM_SaberInBounce( curmove ) )
+			{//in a bounce
+				newmove = saberMoveData[curmove].chain_idle;//oops, not attacking, so don't chain
+			}
+			else
+			{//FIXME: what about returning from a parry?
+				//PM_SetSaberMove( LS_READY );
+				//if ( pm->ps->saberBlockingTime > pm->cmd.serverTime )
+				{
+					PM_SetSaberMove( LS_READY );
+				}
+				return;
+			}
+		}
+
+		// ***************************************************
+		// Pressing attack, so we must look up the proper attack move.
+
+		if ( pm->ps->weaponTime > 0 )
+		{	// Last attack is not yet complete.
+			pm->ps->weaponstate = WEAPON_FIRING;
+			return;
+		}
+		else
+		{
+			int	both = qfalse;
+			if ( pm->ps->torsoAnim == BOTH_FORCELONGLEAP_ATTACK
+				|| pm->ps->torsoAnim == BOTH_FORCELONGLEAP_LAND )
+			{//can't attack in these anims
+				return;
+			}
+			else if ( pm->ps->torsoAnim == BOTH_FORCELONGLEAP_START )
+			{//only 1 attack you can do from this anim
+				if ( pm->ps->torsoTimer >= 200 )
+				{//hit it early enough to do the attack
+					PM_SetSaberMove( LS_LEAP_ATTACK );
+				}
+				return;
+			}
+			if ( curmove >= LS_PARRY_UP && curmove <= LS_REFLECT_LL )
+			{//from a parry or reflection, can go directly into an attack
+				switch ( saberMoveData[curmove].endQuad )
+				{
+				case Q_T:
+					newmove = LS_A_T2B;
+					break;
+				case Q_TR:
+					newmove = LS_A_TR2BL;
+					break;
+				case Q_TL:
+					newmove = LS_A_TL2BR;
+					break;
+				case Q_BR:
+					newmove = LS_A_BR2TL;
+					break;
+				case Q_BL:
+					newmove = LS_A_BL2TR;
+					break;
+				//shouldn't be a parry that ends at L, R or B
+				}
+			}
+
+			if ( newmove != LS_NONE )
+			{//have a valid, final LS_ move picked, so skip findingt he transition move and just get the anim
+				anim = saberMoveData[newmove].animToUse;
+			}
+
+			//FIXME: diagonal dirs use the figure-eight attacks from ready pose?
+			if ( anim == -1 )
+			{
+				//FIXME: take FP_SABER_OFFENSE into account here somehow?
+				if ( PM_SaberInTransition( curmove ) )
+				{//in a transition, must play sequential attack
+					newmove = saberMoveData[curmove].chain_attack;
+				}
+				else if ( curmove >= LS_S_TL2BR && curmove <= LS_S_T2B )
+				{//started a swing, must continue from here
+					newmove = LS_A_TL2BR + (curmove-LS_S_TL2BR);
+				}
+				else if ( PM_SaberInBrokenParry( curmove ) )
+				{//broken parries must always return to ready
+					newmove = LS_READY;
+				}
+				else//if ( pm->cmd.buttons&BUTTON_ATTACK && !(pm->ps->pm_flags&PMF_ATTACK_HELD) )//only do this if just pressed attack button?
+				{//get attack move from movement command
+					/*
+					if ( PM_SaberKataDone() )
+					{//we came from a bounce and cannot chain to another attack because our kata is done
+						newmove = saberMoveData[curmove].chain_idle;
+					}
+					else */
+					newmove = PM_SaberAttackForMovement( curmove );
+					if ( (PM_SaberInBounce( curmove )||PM_SaberInBrokenParry( curmove ))
+						&& saberMoveData[newmove].startQuad == saberMoveData[curmove].endQuad )
+					{//this attack would be a repeat of the last (which was blocked), so don't actually use it, use the default chain attack for this bounce
+						newmove = saberMoveData[curmove].chain_attack;
+					}
+
+					if ( PM_SaberKataDone( curmove, newmove ) )
+					{//cannot chain this time
+						newmove = saberMoveData[curmove].chain_idle;
+					}
+				}
+				/*
+				if ( newmove == LS_NONE )
+				{//FIXME: should we allow this?  Are there some anims that you should never be able to chain into an attack?
+					//only curmove that might get in here is LS_NONE, LS_DRAW, LS_PUTAWAY and the LS_R_ returns... all of which are in Q_R
+					newmove = PM_AttackMoveForQuad( saberMoveData[curmove].endQuad );
+				}
+				*/
+				if ( newmove != LS_NONE )
+				{
+					//Now get the proper transition move
+					newmove = PM_SaberAnimTransitionAnim( curmove, newmove );
+					anim = saberMoveData[newmove].animToUse;
+				}
+			}
+
+			if (anim == -1)
+			{//not side-stepping, pick neutral anim
+				// Add randomness for prototype?
+				newmove = saberMoveData[curmove].chain_attack;
+
+				anim= saberMoveData[newmove].animToUse;
+
+				if ( !pm->cmd.forwardmove && !pm->cmd.rightmove && pm->cmd.upmove >= 0 && pm->ps->groundEntityNum != ENTITYNUM_NONE )
+				{//not moving at all, so set the anim on entire body
+					both = qtrue;
+				}
+			
+			}
+
+			if ( anim == -1)
+			{
+				switch ( pm->ps->legsAnim )
+				{
+				case BOTH_WALK1:
+				case BOTH_WALK2:
+				case BOTH_WALK_STAFF:
+				case BOTH_WALK_DUAL:
+				case BOTH_WALKBACK1:
+				case BOTH_WALKBACK2:
+				case BOTH_WALKBACK_STAFF:
+				case BOTH_WALKBACK_DUAL:
+				case BOTH_RUN1:
+				case BOTH_RUN2:
+				case BOTH_RUN_STAFF:
+				case BOTH_RUN_DUAL:
+				case BOTH_RUNBACK1:
+				case BOTH_RUNBACK2:
+				case BOTH_RUNBACK_STAFF:
+					anim = pm->ps->legsAnim;
+					break;
+				default:
+					anim = PM_GetSaberStance();
+					break;
+				}
+
+//				if (PM_RunningAnim(anim) && !pm->cmd.forwardmove && !pm->cmd.rightmove)
+//				{ //semi-hacky (if not moving on x-y and still playing the running anim, force the player out of it)
+//					anim = PM_GetSaberStance();
+//				}
+				newmove = LS_READY;
+			}
+
+			PM_SetSaberMove( newmove );
+
+			if ( both && pm->ps->torsoAnim == anim )
+			{
+				PM_SetAnim(SETANIM_LEGS,anim,SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD, 100);
+			}
+
+			//don't fire again until anim is done
+			pm->ps->weaponTime = pm->ps->torsoTimer;
+		}
+	}
+
+	// *********************************************************
+	// WEAPON_FIRING
+	// *********************************************************
+
+	pm->ps->weaponstate = WEAPON_FIRING;
+
+	amount = weaponData[pm->ps->weapon].energyPerShot;
+
+	addTime = pm->ps->weaponTime;
+
+	pm->ps->saberAttackSequence = pm->ps->torsoAnim;
+	if ( !addTime )
+	{
+		addTime = weaponData[pm->ps->weapon].fireTime;
+	}
+	pm->ps->weaponTime = addTime;
+}
+
+void PM_SetSaberMove(short newMove)
+{
+	unsigned int setflags = saberMoveData[newMove].animSetFlags;
+	int	anim = saberMoveData[newMove].animToUse;
+	int parts = SETANIM_TORSO;
+
+	if ( newMove == LS_READY || newMove == LS_A_FLIP_STAB || newMove == LS_A_FLIP_SLASH )
+	{//finished with a kata (or in a special move) reset attack counter
+		pm->ps->saberAttackChainCount = 0;
+	}
+	else if ( BG_SaberInAttack( newMove ) )
+	{//continuing with a kata, increment attack counter
+		pm->ps->saberAttackChainCount++;
+	}
+
+	if (pm->ps->saberAttackChainCount > 16)
+	{ //for the sake of being able to send the value over the net within a reasonable bit count
+		pm->ps->saberAttackChainCount = 16;
+	}
+
+	if ( newMove == LS_DRAW )
+	{
+		if ( pm->ps->fd.saberAnimLevel == SS_STAFF )
+		{
+			anim = BOTH_S1_S7;
+		}
+		else if ( pm->ps->fd.saberAnimLevel == SS_DUAL )
+		{
+			anim = BOTH_S1_S6;
+		}
+	}
+	else if ( newMove == LS_PUTAWAY )
+	{
+		if ( pm->ps->fd.saberAnimLevel == SS_STAFF )
+		{
+			anim = BOTH_S7_S1;
+		}
+		else if ( pm->ps->fd.saberAnimLevel == SS_DUAL )
+		{
+			anim = BOTH_S6_S1;
+		}
+	}
+	else if ( pm->ps->fd.saberAnimLevel == SS_STAFF && newMove >= LS_S_TL2BR && newMove < LS_REFLECT_LL )
+	{//staff has an entirely new set of anims, besides special attacks
+		//FIXME: include ready and draw/putaway?
+		//FIXME: get hand-made bounces and deflections?
+		if ( newMove >= LS_V1_BR && newMove <= LS_REFLECT_LL )
+		{//there aren't 1-7, just 1, 6 and 7, so just set it
+			anim = BOTH_P7_S7_T_ + (anim-BOTH_P1_S1_T_);//shift it up to the proper set
+		}
+		else
+		{//add the appropriate animLevel
+			anim += (pm->ps->fd.saberAnimLevel-FORCE_LEVEL_1) * SABER_ANIM_GROUP_SIZE;
+		}
+	}
+	else if ( pm->ps->fd.saberAnimLevel == SS_DUAL && newMove >= LS_S_TL2BR && newMove < LS_REFLECT_LL )
+	{ //akimbo has an entirely new set of anims, besides special attacks
+		//FIXME: include ready and draw/putaway?
+		//FIXME: get hand-made bounces and deflections?
+		if ( newMove >= LS_V1_BR && newMove <= LS_REFLECT_LL )
+		{//there aren't 1-7, just 1, 6 and 7, so just set it
+			anim = BOTH_P6_S6_T_ + (anim-BOTH_P1_S1_T_);//shift it up to the proper set
+		}
+		else
+		{//add the appropriate animLevel
+			anim += (pm->ps->fd.saberAnimLevel-FORCE_LEVEL_1) * SABER_ANIM_GROUP_SIZE;
+		}
+	}
+	/*
+	else if ( newMove == LS_DRAW && pm->ps->SaberStaff() )
+	{//hold saber out front as we turn it on
+		//FIXME: need a real "draw" anim for this (and put-away)
+		anim = BOTH_SABERSTAFF_STANCE;
+	}
+	*/
+	else if ( pm->ps->fd.saberAnimLevel > FORCE_LEVEL_1 &&
+		 !BG_SaberInIdle( newMove ) && !PM_SaberInParry( newMove ) && !PM_SaberInKnockaway( newMove ) && !PM_SaberInBrokenParry( newMove ) && !PM_SaberInReflect( newMove ) && !BG_SaberInSpecial(newMove))
+	{//readies, parries and reflections have only 1 level 
+		anim += (pm->ps->fd.saberAnimLevel-FORCE_LEVEL_1) * SABER_ANIM_GROUP_SIZE;
+	}
+
+	// If the move does the same animation as the last one, we need to force a restart...
+	if ( saberMoveData[pm->ps->saberMove].animToUse == anim && newMove > LS_PUTAWAY)
+	{
+		setflags |= SETANIM_FLAG_RESTART;
+	}
+
+	//saber torso anims should always be highest priority (4/12/02 - for special anims only)
+	if (!pm->ps->m_iVehicleNum)
+	{ //if not riding a vehicle
+		if (BG_SaberInSpecial(newMove))
+		{
+			setflags |= SETANIM_FLAG_OVERRIDE;
+		}
+		/*
+		if ( newMove == LS_A_LUNGE 
+			|| newMove == LS_A_JUMP_T__B_ 
+			|| newMove == LS_A_BACKSTAB
+			|| newMove == LS_A_BACK
+			|| newMove == LS_A_BACK_CR
+			|| newMove == LS_A_FLIP_STAB
+			|| newMove == LS_A_FLIP_SLASH
+			|| newMove == LS_JUMPATTACK_DUAL
+			|| newMove == LS_A_BACKFLIP_ATK)
+		{
+			setflags |= SETANIM_FLAG_OVERRIDE;
+		}
+		*/
+	}
+	if ( BG_InSaberStandAnim(anim) || anim == BOTH_STAND1 )
+	{
+		anim = (pm->ps->legsAnim);
+
+		if ((anim >= BOTH_STAND1 && anim <= BOTH_STAND4TOATTACK2) ||
+			(anim >= TORSO_DROPWEAP1 && anim <= TORSO_WEAPONIDLE10))
+		{ //If standing then use the special saber stand anim
+			anim = PM_GetSaberStance();
+		}
+
+		if (pm->ps->pm_flags & PMF_DUCKED)
+		{ //Playing torso walk anims while crouched makes you look like a monkey
+			anim = PM_GetSaberStance();
+		}
+
+		if (anim == BOTH_WALKBACK1 || anim == BOTH_WALKBACK2 || anim == BOTH_WALK1)
+		{ //normal stance when walking backward so saber doesn't look like it's cutting through leg
+			anim = PM_GetSaberStance();
+		}
+
+		if (BG_InSlopeAnim( anim ))
+		{
+			anim = PM_GetSaberStance();
+		}
+
+		parts = SETANIM_TORSO;
+	}
+
+	if (!pm->ps->m_iVehicleNum)
+	{ //if not riding a vehicle
+		if (newMove == LS_JUMPATTACK_ARIAL_RIGHT ||
+				newMove == LS_JUMPATTACK_ARIAL_LEFT)
+		{ //force only on legs
+			parts = SETANIM_LEGS;
+		}
+		else if ( newMove == LS_A_LUNGE 
+				|| newMove == LS_A_JUMP_T__B_ 
+				|| newMove == LS_A_BACKSTAB
+				|| newMove == LS_A_BACK
+				|| newMove == LS_A_BACK_CR
+				|| newMove == LS_ROLL_STAB
+				|| newMove == LS_A_FLIP_STAB
+				|| newMove == LS_A_FLIP_SLASH
+				|| newMove == LS_JUMPATTACK_DUAL
+				|| newMove == LS_JUMPATTACK_ARIAL_LEFT
+				|| newMove == LS_JUMPATTACK_ARIAL_RIGHT
+				|| newMove == LS_JUMPATTACK_CART_LEFT
+				|| newMove == LS_JUMPATTACK_CART_RIGHT
+				|| newMove == LS_JUMPATTACK_STAFF_LEFT
+				|| newMove == LS_JUMPATTACK_STAFF_RIGHT
+				|| newMove == LS_A_BACKFLIP_ATK
+				|| newMove == LS_STABDOWN
+				|| newMove == LS_STABDOWN_STAFF
+				|| newMove == LS_STABDOWN_DUAL
+				|| newMove == LS_DUAL_SPIN_PROTECT
+				|| newMove == LS_STAFF_SOULCAL
+				|| newMove == LS_A1_SPECIAL
+				|| newMove == LS_A2_SPECIAL
+				|| newMove == LS_A3_SPECIAL
+				|| newMove == LS_UPSIDE_DOWN_ATTACK
+				|| newMove == LS_PULL_ATTACK_STAB
+				|| newMove == LS_PULL_ATTACK_SWING
+				|| BG_KickMove( newMove ) )
+		{
+			parts = SETANIM_BOTH;
+		}
+		else if ( BG_SpinningSaberAnim( anim ) )
+		{//spins must be played on entire body
+			parts = SETANIM_BOTH;
+		}
+		else if ( (!pm->cmd.forwardmove&&!pm->cmd.rightmove&&!pm->cmd.upmove))
+		{//not trying to run, duck or jump
+			if ( !BG_FlippingAnim( pm->ps->legsAnim ) && 
+				!BG_InRoll( pm->ps, pm->ps->legsAnim ) && 
+				!PM_InKnockDown( pm->ps ) && 
+				!PM_JumpingAnim( pm->ps->legsAnim ) &&
+				!BG_InSpecialJump( pm->ps->legsAnim ) &&
+				anim != PM_GetSaberStance() &&
+				pm->ps->groundEntityNum != ENTITYNUM_NONE &&
+				!(pm->ps->pm_flags & PMF_DUCKED))
+			{
+				parts = SETANIM_BOTH;
+			}
+			else if ( !(pm->ps->pm_flags & PMF_DUCKED) 
+				&& ( newMove == LS_SPINATTACK_DUAL || newMove == LS_SPINATTACK ) )
+			{
+				parts = SETANIM_BOTH;
+			}
+		}
+
+		PM_SetAnim(parts, anim, setflags, saberMoveData[newMove].blendTime);
+		if (parts != SETANIM_LEGS &&
+			(pm->ps->legsAnim == BOTH_ARIAL_LEFT ||
+			pm->ps->legsAnim == BOTH_ARIAL_RIGHT))
+		{
+			if (pm->ps->legsTimer > pm->ps->torsoTimer)
+			{
+				pm->ps->legsTimer = pm->ps->torsoTimer;
+			}
+		}
+
+	}
+
+	if ( (pm->ps->torsoAnim) == anim )
+	{//successfully changed anims
+	//special check for *starting* a saber swing
+		//playing at attack
+		if ( BG_SaberInAttack( newMove ) || BG_SaberInSpecialAttack( anim ) )
+		{
+			if ( pm->ps->saberMove != newMove )
+			{//wasn't playing that attack before
+				if ( newMove != LS_KICK_F
+					&& newMove != LS_KICK_B
+					&& newMove != LS_KICK_R
+					&& newMove != LS_KICK_L
+					&& newMove != LS_KICK_F_AIR
+					&& newMove != LS_KICK_B_AIR
+					&& newMove != LS_KICK_R_AIR
+					&& newMove != LS_KICK_L_AIR )
+				{
+                    PM_AddEvent(EV_SABER_ATTACK);
+				}
+
+				if (pm->ps->brokenLimbs)
+				{ //randomly make pain sounds with a broken arm because we are suffering.
+					int iFactor = -1;
+
+					if (pm->ps->brokenLimbs & (1<<BROKENLIMB_RARM))
+					{ //You're using it more. So it hurts more.
+						iFactor = 5;
+					}
+					else if (pm->ps->brokenLimbs & (1<<BROKENLIMB_LARM))
+					{
+						iFactor = 10;
+					}
+
+					if (iFactor != -1)
+					{
+						if ( !PM_irand_timesync( 0, iFactor ) )
+						{
+							BG_AddPredictableEventToPlayerstate(EV_PAIN, PM_irand_timesync( 1, 100 ), pm->ps);
+						}
+					}
+				}
+			}
+		}
+
+		if (BG_SaberInSpecial(newMove) &&
+			pm->ps->weaponTime < pm->ps->torsoTimer)
+		{ //rww 01-02-03 - I think this will solve the issue of special attacks being interruptable, hopefully without side effects
+			pm->ps->weaponTime = pm->ps->torsoTimer;
+		}
+
+		pm->ps->saberMove = newMove;
+		pm->ps->saberBlocking = saberMoveData[newMove].blocking;
+
+		pm->ps->torsoAnim = anim;
+
+		if (pm->ps->weaponTime <= 0)
+		{
+			pm->ps->saberBlocked = BLOCKED_NONE;
+		}
+	}
+}
+
+#include "../namespace_end.h"
diff --git a/codemp/game/bg_saberLoad.c b/codemp/game/bg_saberLoad.c
new file mode 100644
index 0000000..1a42396
--- /dev/null
+++ b/codemp/game/bg_saberLoad.c
@@ -0,0 +1,1164 @@
+//bg_saberLoad.c
+#include "q_shared.h"
+#include "bg_public.h"
+#include "bg_local.h"
+#include "w_saber.h"
+
+//Could use strap stuff but I don't particularly care at the moment anyway.
+#include "../namespace_begin.h"
+extern int	trap_FS_FOpenFile( const char *qpath, fileHandle_t *f, fsMode_t mode );
+extern void	trap_FS_Read( void *buffer, int len, fileHandle_t f );
+extern void	trap_FS_Write( const void *buffer, int len, fileHandle_t f );
+extern void	trap_FS_FCloseFile( fileHandle_t f );
+extern int	trap_FS_GetFileList(  const char *path, const char *extension, char *listbuf, int bufsize );
+extern qhandle_t trap_R_RegisterSkin( const char *name );
+#include "../namespace_end.h"
+
+
+#ifdef QAGAME
+extern int G_SoundIndex( const char *name );
+#elif defined CGAME
+#include "../namespace_begin.h"
+sfxHandle_t trap_S_RegisterSound( const char *sample);
+#include "../namespace_end.h"
+#endif
+
+#include "../namespace_begin.h"
+
+int BG_SoundIndex(char *sound)
+{
+#ifdef QAGAME
+	return G_SoundIndex(sound);
+#elif defined CGAME
+	return trap_S_RegisterSound(sound);
+#endif
+}
+
+extern stringID_table_t FPTable[];
+
+#define MAX_SABER_DATA_SIZE 0x10000
+static char SaberParms[MAX_SABER_DATA_SIZE];
+
+stringID_table_t SaberTable[] =
+{
+	ENUM2STRING(SABER_NONE),
+	ENUM2STRING(SABER_SINGLE),
+	ENUM2STRING(SABER_STAFF),
+	ENUM2STRING(SABER_BROAD),
+	ENUM2STRING(SABER_PRONG),
+	ENUM2STRING(SABER_DAGGER),
+	ENUM2STRING(SABER_ARC),
+	ENUM2STRING(SABER_SAI),
+	ENUM2STRING(SABER_CLAW),
+	ENUM2STRING(SABER_LANCE),
+	ENUM2STRING(SABER_STAR),
+	ENUM2STRING(SABER_TRIDENT),
+	"",	-1
+};
+
+//Also used in npc code
+qboolean BG_ParseLiteral( const char **data, const char *string ) 
+{
+	const char	*token;
+
+	token = COM_ParseExt( data, qtrue );
+	if ( token[0] == 0 ) 
+	{
+		Com_Printf( "unexpected EOF\n" );
+		return qtrue;
+	}
+
+	if ( Q_stricmp( token, string ) ) 
+	{
+		Com_Printf( "required string '%s' missing\n", string );
+		return qtrue;
+	}
+
+	return qfalse;
+}
+
+saber_colors_t TranslateSaberColor( const char *name ) 
+{
+	if ( !Q_stricmp( name, "red" ) ) 
+	{
+		return SABER_RED;
+	}
+	if ( !Q_stricmp( name, "orange" ) ) 
+	{
+		return SABER_ORANGE;
+	}
+	if ( !Q_stricmp( name, "yellow" ) ) 
+	{
+		return SABER_YELLOW;
+	}
+	if ( !Q_stricmp( name, "green" ) ) 
+	{
+		return SABER_GREEN;
+	}
+	if ( !Q_stricmp( name, "blue" ) ) 
+	{
+		return SABER_BLUE;
+	}
+	if ( !Q_stricmp( name, "purple" ) ) 
+	{
+		return SABER_PURPLE;
+	}
+	if ( !Q_stricmp( name, "random" ) ) 
+	{
+		return ((saber_colors_t)(Q_irand( SABER_ORANGE, SABER_PURPLE )));
+	}
+	return SABER_BLUE;
+}
+
+saber_styles_t TranslateSaberStyle( const char *name ) 
+{
+	if ( !Q_stricmp( name, "fast" ) ) 
+	{
+		return SS_FAST;
+	}
+	if ( !Q_stricmp( name, "medium" ) ) 
+	{
+		return SS_MEDIUM;
+	}
+	if ( !Q_stricmp( name, "strong" ) ) 
+	{
+		return SS_STRONG;
+	}
+	if ( !Q_stricmp( name, "desann" ) ) 
+	{
+		return SS_DESANN;
+	}
+	if ( !Q_stricmp( name, "tavion" ) ) 
+	{
+		return SS_TAVION;
+	}
+	if ( !Q_stricmp( name, "dual" ) ) 
+	{
+		return SS_DUAL;
+	}
+	if ( !Q_stricmp( name, "staff" ) ) 
+	{
+		return SS_STAFF;
+	}
+	return SS_NONE;
+}
+
+void WP_SaberSetDefaults( saberInfo_t *saber )
+{
+	int i;
+
+	//Set defaults so that, if it fails, there's at least something there
+	for ( i = 0; i < MAX_BLADES; i++ )
+	{
+		saber->blade[i].color = SABER_RED;
+		saber->blade[i].radius = SABER_RADIUS_STANDARD;
+		saber->blade[i].lengthMax = 32;
+	}
+
+	strcpy(saber->name, "default");
+	strcpy(saber->fullName, "lightsaber");
+	strcpy(saber->model, "models/weapons2/saber_reborn/saber_w.glm");
+	saber->skin = 0;
+	saber->soundOn = BG_SoundIndex( "sound/weapons/saber/enemy_saber_on.wav" );
+	saber->soundLoop = BG_SoundIndex( "sound/weapons/saber/saberhum3.wav" );
+	saber->soundOff = BG_SoundIndex( "sound/weapons/saber/enemy_saber_off.wav" );
+	saber->numBlades = 1;
+	saber->type = SABER_SINGLE;
+	saber->style = SS_NONE;
+	saber->maxChain = 0;//0 = use default behavior
+	saber->lockable = qtrue;
+	saber->throwable = qtrue;
+	saber->disarmable = qtrue;
+	saber->activeBlocking = qtrue;
+	saber->twoHanded = qfalse;
+	saber->forceRestrictions = 0;
+	saber->lockBonus = 0;
+	saber->parryBonus = 0;
+	saber->breakParryBonus = 0;
+	saber->disarmBonus = 0;
+	saber->singleBladeStyle = SS_NONE;//makes it so that you use a different style if you only have the first blade active
+	saber->singleBladeThrowable = qfalse;//makes it so that you can throw this saber if only the first blade is on
+//	saber->brokenSaber1 = NULL;//if saber is actually hit by another saber, it can be cut in half/broken and will be replaced with this saber in your right hand
+//	saber->brokenSaber2 = NULL;//if saber is actually hit by another saber, it can be cut in half/broken and will be replaced with this saber in your left hand
+	saber->returnDamage = qfalse;//when returning from a saber throw, it keeps spinning and doing damage
+}
+
+#define DEFAULT_SABER "Kyle"
+
+qboolean WP_SaberParseParms( const char *SaberName, saberInfo_t *saber ) 
+{
+	const char	*token;
+	const char	*value;
+	const char	*p;
+	char	useSaber[1024];
+	float	f;
+	int		n;
+	qboolean	triedDefault = qfalse;
+
+	if ( !saber ) 
+	{
+		return qfalse;
+	}
+	
+	//Set defaults so that, if it fails, there's at least something there
+	WP_SaberSetDefaults( saber );
+
+	if ( !SaberName || !SaberName[0] ) 
+	{
+		strcpy(useSaber, DEFAULT_SABER); //default
+		triedDefault = qtrue;
+	}
+	else
+	{
+		strcpy(useSaber, SaberName);
+	}
+
+	//try to parse it out
+	p = SaberParms;
+	COM_BeginParseSession("saberinfo");
+
+	// look for the right saber
+	while ( p )
+	{
+		token = COM_ParseExt( &p, qtrue );
+		if ( token[0] == 0 )
+		{
+			if (!triedDefault)
+			{ //fall back to default and restart, should always be there
+				p = SaberParms;
+				COM_BeginParseSession("saberinfo");
+				strcpy(useSaber, DEFAULT_SABER);
+				triedDefault = qtrue;
+			}
+			else
+			{
+				return qfalse;
+			}
+		}
+
+		if ( !Q_stricmp( token, useSaber ) ) 
+		{
+			break;
+		}
+
+		SkipBracedSection( &p );
+	}
+	if ( !p ) 
+	{ //even the default saber isn't found?
+		return qfalse;
+	}
+
+	//got the name we're using for sure
+	strcpy(saber->name, useSaber);
+
+	if ( BG_ParseLiteral( &p, "{" ) ) 
+	{
+		return qfalse;
+	}
+		
+	// parse the saber info block
+	while ( 1 ) 
+	{
+		token = COM_ParseExt( &p, qtrue );
+		if ( !token[0] ) 
+		{
+			Com_Printf( S_COLOR_RED"ERROR: unexpected EOF while parsing '%s'\n", useSaber );
+			return qfalse;
+		}
+
+		if ( !Q_stricmp( token, "}" ) ) 
+		{
+			break;
+		}
+
+		//saber fullName
+		if ( !Q_stricmp( token, "name" ) ) 
+		{
+			if ( COM_ParseString( &p, &value ) ) 
+			{
+				continue;
+			}
+			strcpy(saber->fullName, value);
+			continue;
+		}
+
+		//saber type
+		if ( !Q_stricmp( token, "saberType" ) ) 
+		{
+			int saberType;
+
+			if ( COM_ParseString( &p, &value ) ) 
+			{
+				continue;
+			}
+			saberType = GetIDForString( SaberTable, value );
+			if ( saberType >= SABER_SINGLE && saberType <= NUM_SABERS )
+			{
+				saber->type = (saberType_t)saberType;
+			}
+			continue;
+		}
+
+		//saber hilt
+		if ( !Q_stricmp( token, "saberModel" ) ) 
+		{
+			if ( COM_ParseString( &p, &value ) ) 
+			{
+				continue;
+			}
+			strcpy(saber->model, value);
+			continue;
+		}
+
+		if ( !Q_stricmp( token, "customSkin" ) )
+		{
+			if ( COM_ParseString( &p, &value ) ) 
+			{
+				continue;
+			}
+			saber->skin = trap_R_RegisterSkin(value);
+			continue;
+		}
+
+		//on sound
+		if ( !Q_stricmp( token, "soundOn" ) ) 
+		{
+			if ( COM_ParseString( &p, &value ) ) 
+			{
+				continue;
+			}
+			saber->soundOn = BG_SoundIndex( (char *)value );
+			continue;
+		}
+
+		//loop sound
+		if ( !Q_stricmp( token, "soundLoop" ) ) 
+		{
+			if ( COM_ParseString( &p, &value ) ) 
+			{
+				continue;
+			}
+			saber->soundLoop = BG_SoundIndex( (char *)value );
+			continue;
+		}
+
+		//off sound
+		if ( !Q_stricmp( token, "soundOff" ) ) 
+		{
+			if ( COM_ParseString( &p, &value ) ) 
+			{
+				continue;
+			}
+			saber->soundOff = BG_SoundIndex( (char *)value );
+			continue;
+		}
+
+		if ( !Q_stricmp( token, "numBlades" ) ) 
+		{
+			if ( COM_ParseInt( &p, &n ) ) 
+			{
+				SkipRestOfLine( &p );
+				continue;
+			}
+			if ( n < 1 || n >= MAX_BLADES )
+			{
+				Com_Error(ERR_DROP, "WP_SaberParseParms: saber %s has illegal number of blades (%d) max: %d", useSaber, n, MAX_BLADES );
+				continue;
+			}
+			saber->numBlades = n;
+			continue;
+		}
+
+		// saberColor
+		if ( !Q_stricmpn( token, "saberColor", 10 ) ) 
+		{
+			if (strlen(token)==10)
+			{
+				n = -1;
+			}
+			else if (strlen(token)==11)
+			{
+				n = atoi(&token[10])-1;
+				if (n > 7 || n < 1 )
+				{
+					Com_Printf( S_COLOR_YELLOW"WARNING: bad saberColor '%s' in %s\n", token, useSaber );
+					continue;
+				}
+			}
+			else
+			{
+				Com_Printf( S_COLOR_YELLOW"WARNING: bad saberColor '%s' in %s\n", token, useSaber );
+				continue;
+			}
+
+			if ( COM_ParseString( &p, &value ) )	//read the color
+			{
+				continue;
+			}
+
+			if (n==-1)
+			{//NOTE: this fills in the rest of the blades with the same color by default
+				saber_colors_t color = TranslateSaberColor( value );
+				for ( n = 0; n < MAX_BLADES; n++ )
+				{
+					saber->blade[n].color = color;
+				}
+			} else 
+			{
+				saber->blade[n].color = TranslateSaberColor( value );
+			}
+			continue;
+		}
+
+		//saber length
+		if ( !Q_stricmpn( token, "saberLength", 11 ) ) 
+		{
+			if (strlen(token)==11)
+			{
+				n = -1;
+			}
+			else if (strlen(token)==12)
+			{
+				n = atoi(&token[11])-1;
+				if (n > 7 || n < 1 )
+				{
+					Com_Printf( S_COLOR_YELLOW"WARNING: bad saberLength '%s' in %s\n", token, useSaber );
+					continue;
+				}
+			}
+			else
+			{
+				Com_Printf( S_COLOR_YELLOW"WARNING: bad saberLength '%s' in %s\n", token, useSaber );
+				continue;
+			}
+
+			if ( COM_ParseFloat( &p, &f ) ) 
+			{
+				SkipRestOfLine( &p );
+				continue;
+			}
+			//cap
+			if ( f < 4.0f )
+			{
+				f = 4.0f;
+			}
+
+			if (n==-1)
+			{//NOTE: this fills in the rest of the blades with the same length by default
+				for ( n = 0; n < MAX_BLADES; n++ )
+				{
+					saber->blade[n].lengthMax = f;
+				}
+			}
+			else
+			{
+				saber->blade[n].lengthMax = f;
+			}
+			continue;
+		}
+
+		//blade radius
+		if ( !Q_stricmpn( token, "saberRadius", 11 ) ) 
+		{
+			if (strlen(token)==11)
+			{
+				n = -1;
+			}
+			else if (strlen(token)==12)
+			{
+				n = atoi(&token[11])-1;
+				if (n > 7 || n < 1 )
+				{
+					Com_Printf( S_COLOR_YELLOW"WARNING: bad saberRadius '%s' in %s\n", token, useSaber );
+					continue;
+				}
+			}
+			else
+			{
+				Com_Printf( S_COLOR_YELLOW"WARNING: bad saberRadius '%s' in %s\n", token, useSaber );
+				continue;
+			}
+
+			if ( COM_ParseFloat( &p, &f ) ) 
+			{
+				SkipRestOfLine( &p );
+				continue;
+			}
+			//cap
+			if ( f < 0.25f )
+			{
+				f = 0.25f;
+			}
+			if (n==-1)
+			{//NOTE: this fills in the rest of the blades with the same length by default
+				for ( n = 0; n < MAX_BLADES; n++ )
+				{
+					saber->blade[n].radius = f;
+				}
+			}
+			else
+			{
+				saber->blade[n].radius = f;
+			}
+			continue;
+		}
+
+		//locked saber style
+		if ( !Q_stricmp( token, "saberStyle" ) ) 
+		{
+			if ( COM_ParseString( &p, &value ) ) 
+			{
+				continue;
+			}
+			saber->style = TranslateSaberStyle( value );
+			continue;
+		}
+
+		//maxChain
+		if ( !Q_stricmp( token, "maxChain" ) ) 
+		{
+			if ( COM_ParseInt( &p, &n ) ) 
+			{
+				SkipRestOfLine( &p );
+				continue;
+			}
+			saber->maxChain = n;
+			continue;
+		}
+
+		//lockable
+		if ( !Q_stricmp( token, "lockable" ) ) 
+		{
+			if ( COM_ParseInt( &p, &n ) ) 
+			{
+				SkipRestOfLine( &p );
+				continue;
+			}
+			saber->lockable = ((qboolean)(n!=0));
+			continue;
+		}
+
+		//throwable
+		if ( !Q_stricmp( token, "throwable" ) ) 
+		{
+			if ( COM_ParseInt( &p, &n ) ) 
+			{
+				SkipRestOfLine( &p );
+				continue;
+			}
+			saber->throwable = ((qboolean)(n!=0));
+			continue;
+		}
+
+		//disarmable
+		if ( !Q_stricmp( token, "disarmable" ) ) 
+		{
+			if ( COM_ParseInt( &p, &n ) ) 
+			{
+				SkipRestOfLine( &p );
+				continue;
+			}
+			saber->disarmable = ((qboolean)(n!=0));
+			continue;
+		}
+
+		//active blocking
+		if ( !Q_stricmp( token, "blocking" ) ) 
+		{
+			if ( COM_ParseInt( &p, &n ) ) 
+			{
+				SkipRestOfLine( &p );
+				continue;
+			}
+			saber->activeBlocking = ((qboolean)(n!=0));
+			continue;
+		}
+
+		//twoHanded
+		if ( !Q_stricmp( token, "twoHanded" ) ) 
+		{
+			if ( COM_ParseInt( &p, &n ) ) 
+			{
+				SkipRestOfLine( &p );
+				continue;
+			}
+			saber->twoHanded = ((qboolean)(n!=0));
+			continue;
+		}
+
+		//force power restrictions
+		if ( !Q_stricmp( token, "forceRestrict" ) ) 
+		{
+			int fp;
+
+			if ( COM_ParseString( &p, &value ) ) 
+			{
+				continue;
+			}
+			fp = GetIDForString( FPTable, value );
+			if ( fp >= FP_FIRST && fp < NUM_FORCE_POWERS )
+			{
+				saber->forceRestrictions |= (1<<fp);
+			}
+			continue;
+		}
+
+		//lockBonus
+		if ( !Q_stricmp( token, "lockBonus" ) ) 
+		{
+			if ( COM_ParseInt( &p, &n ) ) 
+			{
+				SkipRestOfLine( &p );
+				continue;
+			}
+			saber->lockBonus = n;
+			continue;
+		}
+
+		//parryBonus
+		if ( !Q_stricmp( token, "parryBonus" ) ) 
+		{
+			if ( COM_ParseInt( &p, &n ) ) 
+			{
+				SkipRestOfLine( &p );
+				continue;
+			}
+			saber->parryBonus = n;
+			continue;
+		}
+
+		//breakParryBonus
+		if ( !Q_stricmp( token, "breakParryBonus" ) ) 
+		{
+			if ( COM_ParseInt( &p, &n ) ) 
+			{
+				SkipRestOfLine( &p );
+				continue;
+			}
+			saber->breakParryBonus = n;
+			continue;
+		}
+
+		//disarmBonus
+		if ( !Q_stricmp( token, "disarmBonus" ) ) 
+		{
+			if ( COM_ParseInt( &p, &n ) ) 
+			{
+				SkipRestOfLine( &p );
+				continue;
+			}
+			saber->disarmBonus = n;
+			continue;
+		}
+
+		//single blade saber style
+		if ( !Q_stricmp( token, "singleBladeStyle" ) ) 
+		{
+			if ( COM_ParseString( &p, &value ) ) 
+			{
+				continue;
+			}
+			saber->singleBladeStyle = TranslateSaberStyle( value );
+			continue;
+		}
+
+		//single blade throwable
+		if ( !Q_stricmp( token, "singleBladeThrowable" ) ) 
+		{
+			if ( COM_ParseInt( &p, &n ) ) 
+			{
+				SkipRestOfLine( &p );
+				continue;
+			}
+			saber->singleBladeThrowable = ((qboolean)(n!=0));
+			continue;
+		}
+
+		//broken replacement saber1 (right hand)
+		if ( !Q_stricmp( token, "brokenSaber1" ) ) 
+		{
+			if ( COM_ParseString( &p, &value ) ) 
+			{
+				continue;
+			}
+			//saber->brokenSaber1 = G_NewString( value );
+			continue;
+		}
+		
+		//broken replacement saber2 (left hand)
+		if ( !Q_stricmp( token, "brokenSaber2" ) ) 
+		{
+			if ( COM_ParseString( &p, &value ) ) 
+			{
+				continue;
+			}
+			//saber->brokenSaber2 = G_NewString( value );
+			continue;
+		}
+
+		//spins and does damage on return from saberthrow
+		if ( !Q_stricmp( token, "returnDamage" ) ) 
+		{
+			if ( COM_ParseInt( &p, &n ) ) 
+			{
+				SkipRestOfLine( &p );
+				continue;
+			}
+			saber->returnDamage = ((qboolean)(n!=0));
+			continue;
+		}
+
+		if ( !Q_stricmp( token, "notInMP" ) ) 
+		{//ignore this
+			SkipRestOfLine( &p );
+			continue;
+		}
+		//FIXME: saber sounds (on, off, loop)
+
+#ifdef _DEBUG
+		Com_Printf( "WARNING: unknown keyword '%s' while parsing '%s'\n", token, useSaber );
+#endif
+		SkipRestOfLine( &p );
+	}
+
+	//FIXME: precache the saberModel(s)?
+
+	return qtrue;
+}
+
+qboolean WP_SaberParseParm( const char *saberName, const char *parmname, char *saberData ) 
+{
+	const char	*token;
+	const char	*value;
+	const char	*p;
+
+	if ( !saberName || !saberName[0] ) 
+	{
+		return qfalse;
+	}
+
+	//try to parse it out
+	p = SaberParms;
+	COM_BeginParseSession("saberinfo");
+
+	// look for the right saber
+	while ( p )
+	{
+		token = COM_ParseExt( &p, qtrue );
+		if ( token[0] == 0 )
+		{
+			return qfalse;
+		}
+
+		if ( !Q_stricmp( token, saberName ) ) 
+		{
+			break;
+		}
+
+		SkipBracedSection( &p );
+	}
+	if ( !p ) 
+	{
+		return qfalse;
+	}
+
+	if ( BG_ParseLiteral( &p, "{" ) ) 
+	{
+		return qfalse;
+	}
+		
+	// parse the saber info block
+	while ( 1 ) 
+	{
+		token = COM_ParseExt( &p, qtrue );
+		if ( !token[0] ) 
+		{
+			Com_Printf( S_COLOR_RED"ERROR: unexpected EOF while parsing '%s'\n", saberName );
+			return qfalse;
+		}
+
+		if ( !Q_stricmp( token, "}" ) ) 
+		{
+			break;
+		}
+
+		if ( !Q_stricmp( token, parmname ) ) 
+		{
+			if ( COM_ParseString( &p, &value ) ) 
+			{
+				continue;
+			}
+			strcpy( saberData, value );
+			return qtrue;
+		}
+
+		SkipRestOfLine( &p );
+		continue;
+	}
+
+	return qfalse;
+}
+
+qboolean WP_SaberValidForPlayerInMP( const char *saberName )
+{
+	char allowed [8]={0};
+	if ( !WP_SaberParseParm( saberName, "notInMP", allowed ) )
+	{//not defined, default is yes
+		return qtrue;
+	}
+	if ( !allowed[0] )
+	{//not defined, default is yes
+		return qtrue;
+	}
+	else
+	{//return value
+		return ((qboolean)(atoi(allowed)==0));
+	}
+}
+
+void WP_RemoveSaber( saberInfo_t *sabers, int saberNum )
+{
+	if ( !sabers )
+	{
+		return;
+	}
+	//reset everything for this saber just in case
+	WP_SaberSetDefaults( &sabers[saberNum] );
+
+	strcpy(sabers[saberNum].name, "none");
+	sabers[saberNum].model[0] = 0;
+
+	//ent->client->ps.dualSabers = qfalse;
+	BG_SI_Deactivate(&sabers[saberNum]);
+	BG_SI_SetLength(&sabers[saberNum], 0.0f);
+//	if ( ent->weaponModel[saberNum] > 0 )
+//	{
+//		gi.G2API_RemoveGhoul2Model( ent->ghoul2, ent->weaponModel[saberNum] );
+//		ent->weaponModel[saberNum] = -1;
+//	}
+//	if ( saberNum == 1 )
+//	{
+//		ent->client->ps.dualSabers = qfalse;
+//	}
+}
+
+void WP_SetSaber( int entNum, saberInfo_t *sabers, int saberNum, const char *saberName )
+{
+	if ( !sabers )
+	{
+		return;
+	}
+	if ( Q_stricmp( "none", saberName ) == 0 || Q_stricmp( "remove", saberName ) == 0 )
+	{
+		if (saberNum != 0)
+		{ //can't remove saber 0 ever
+			WP_RemoveSaber( sabers, saberNum );
+		}
+		return;
+	}
+
+	if ( entNum < MAX_CLIENTS &&
+		!WP_SaberValidForPlayerInMP( saberName ) )
+	{
+		WP_SaberParseParms( "Kyle", &sabers[saberNum] );//get saber info
+	}
+	else
+	{
+		WP_SaberParseParms( saberName, &sabers[saberNum] );//get saber info
+	}
+	if (sabers[1].twoHanded)
+	{//not allowed to use a 2-handed saber as second saber
+		WP_RemoveSaber( sabers, 1 );
+		return;
+	}
+	else if (sabers[0].twoHanded &&
+		sabers[1].model[0])
+	{ //you can't use a two-handed saber with a second saber, so remove saber 2
+		WP_RemoveSaber( sabers, 1 );
+		return;
+	}
+}
+
+void WP_SaberSetColor( saberInfo_t *sabers, int saberNum, int bladeNum, char *colorName )
+{
+	if ( !sabers )
+	{
+		return;
+	}
+	sabers[saberNum].blade[bladeNum].color = TranslateSaberColor( colorName );
+}
+
+static char bgSaberParseTBuffer[MAX_SABER_DATA_SIZE];
+
+void WP_SaberLoadParms( void ) 
+{
+	int			len, totallen, saberExtFNLen, mainBlockLen, fileCnt, i;
+	//const char	*filename = "ext_data/sabers.cfg";
+	char		*holdChar, *marker;
+	char		saberExtensionListBuf[2048];			//	The list of file names read in
+	fileHandle_t	f;
+
+	len = 0;
+
+	//remember where to store the next one
+	totallen = mainBlockLen = len;
+	marker = SaberParms+totallen;
+	*marker = 0;
+
+	//now load in the extra .sab extensions
+	fileCnt = trap_FS_GetFileList("ext_data/sabers", ".sab", saberExtensionListBuf, sizeof(saberExtensionListBuf) );
+
+	holdChar = saberExtensionListBuf;
+	for ( i = 0; i < fileCnt; i++, holdChar += saberExtFNLen + 1 ) 
+	{
+		saberExtFNLen = strlen( holdChar );
+
+		len = trap_FS_FOpenFile(va( "ext_data/sabers/%s", holdChar), &f, FS_READ);
+
+		if ( len == -1 ) 
+		{
+			Com_Printf( "error reading file\n" );
+		}
+		else
+		{
+			if ( (totallen + len + 1/*for the endline*/) >= MAX_SABER_DATA_SIZE ) {
+				Com_Error(ERR_DROP, "Saber extensions (*.sab) are too large" );
+			}
+
+			trap_FS_Read(bgSaberParseTBuffer, len, f);
+			bgSaberParseTBuffer[len] = 0;
+
+			Q_strcat( marker, MAX_SABER_DATA_SIZE-totallen, bgSaberParseTBuffer );
+			trap_FS_FCloseFile(f);
+
+			//get around the stupid problem of not having an endline at the bottom
+			//of a sab file -rww
+			Q_strcat(marker, MAX_SABER_DATA_SIZE-totallen, "\n");
+			len++;
+
+			totallen += len;
+			marker = SaberParms+totallen;
+		}
+	}
+}
+
+/*
+rww -
+The following were struct functions in SP. Of course
+we can't have that in this codebase so I'm having to
+externalize them. Which is why this probably seems
+structured a bit oddly. But it's to make porting stuff
+easier on myself. SI indicates it was under saberinfo,
+and BLADE indicates it was under bladeinfo.
+*/
+
+//---------------------------------------
+void BG_BLADE_ActivateTrail ( bladeInfo_t *blade, float duration )
+{
+	blade->trail.inAction = qtrue;
+	blade->trail.duration = duration;
+}
+
+void BG_BLADE_DeactivateTrail ( bladeInfo_t *blade, float duration )
+{
+	blade->trail.inAction = qfalse;
+	blade->trail.duration = duration;
+}
+//---------------------------------------
+void BG_SI_Activate( saberInfo_t *saber )
+{
+	int i;
+
+	for ( i = 0; i < saber->numBlades; i++ )
+	{
+		saber->blade[i].active = qtrue;
+	}
+}
+
+void BG_SI_Deactivate( saberInfo_t *saber )
+{
+	int i;
+
+	for ( i = 0; i < saber->numBlades; i++ )
+	{
+		saber->blade[i].active = qfalse;
+	}
+}
+
+// Description: Activate a specific Blade of this Saber.
+// Created: 10/03/02 by Aurelio Reis, Modified: 10/03/02 by Aurelio Reis.
+//	[in]		int iBlade		Which Blade to activate.
+//	[in]		bool bActive	Whether to activate it (default true), or deactivate it (false).
+//	[return]	void
+void BG_SI_BladeActivate( saberInfo_t *saber, int iBlade, qboolean bActive )
+{
+	// Validate blade ID/Index.
+	if ( iBlade < 0 || iBlade >= saber->numBlades )
+		return;
+
+	saber->blade[iBlade].active = bActive;
+}
+
+qboolean BG_SI_Active(saberInfo_t *saber) 
+{
+	int i;
+
+	for ( i = 0; i < saber->numBlades; i++ )
+	{
+		if ( saber->blade[i].active )
+		{
+			return qtrue;
+		}
+	}
+	return qfalse;
+}
+
+void BG_SI_SetLength( saberInfo_t *saber, float length )
+{
+	int i;
+
+	for ( i = 0; i < saber->numBlades; i++ )
+	{
+		saber->blade[i].length = length;
+	}
+}
+
+//not in sp, added it for my own convenience
+void BG_SI_SetDesiredLength(saberInfo_t *saber, float len, int bladeNum )
+{
+	int i, startBlade = 0, maxBlades = saber->numBlades;
+
+	if ( bladeNum >= 0 && bladeNum < saber->numBlades)
+	{//doing this on a specific blade
+		startBlade = bladeNum;
+		maxBlades = bladeNum+1;
+	}
+	for (i = startBlade; i < maxBlades; i++)
+	{
+		saber->blade[i].desiredLength = len;
+	}
+}
+
+//also not in sp, added it for my own convenience
+void BG_SI_SetLengthGradual(saberInfo_t *saber, int time)
+{
+	int i;
+	float amt, dLen;
+
+	for (i = 0; i < saber->numBlades; i++)
+	{
+		dLen = saber->blade[i].desiredLength;
+
+		if (dLen == -1)
+		{ //assume we want max blade len
+			dLen = saber->blade[i].lengthMax;
+		}
+
+		if (saber->blade[i].length == dLen)
+		{
+			continue;
+		}
+
+		if (saber->blade[i].length == saber->blade[i].lengthMax ||
+			saber->blade[i].length == 0)
+		{
+			saber->blade[i].extendDebounce = time;
+			if (saber->blade[i].length == 0)
+			{
+				saber->blade[i].length++;
+			}
+			else
+			{
+				saber->blade[i].length--;
+			}
+		}
+
+		amt = (time - saber->blade[i].extendDebounce)*0.01;
+
+		if (amt < 0.2f)
+		{
+			amt = 0.2f;
+		}
+
+		if (saber->blade[i].length < dLen)
+		{
+			saber->blade[i].length += amt;
+
+			if (saber->blade[i].length > dLen)
+			{
+				saber->blade[i].length = dLen;
+			}
+			if (saber->blade[i].length > saber->blade[i].lengthMax)
+			{
+				saber->blade[i].length = saber->blade[i].lengthMax;
+			}
+		}
+		else if (saber->blade[i].length > dLen)
+		{
+			saber->blade[i].length -= amt;
+
+			if (saber->blade[i].length < dLen)
+			{
+				saber->blade[i].length = dLen;
+			}
+			if (saber->blade[i].length < 0)
+			{
+				saber->blade[i].length = 0;
+			}
+		}
+	}
+}
+
+float BG_SI_Length(saberInfo_t *saber) 
+{//return largest length
+	int len1 = 0;
+	int i;
+
+	for ( i = 0; i < saber->numBlades; i++ )
+	{
+		if ( saber->blade[i].length > len1 )
+		{
+			len1 = saber->blade[i].length; 
+		}
+	}
+	return len1;
+}
+
+float BG_SI_LengthMax(saberInfo_t *saber) 
+{ 
+	int len1 = 0;
+	int i;
+
+	for ( i = 0; i < saber->numBlades; i++ )
+	{
+		if ( saber->blade[i].lengthMax > len1 )
+		{
+			len1 = saber->blade[i].lengthMax; 
+		}
+	}
+	return len1;
+}
+
+void BG_SI_ActivateTrail ( saberInfo_t *saber, float duration )
+{
+	int i;
+
+	for ( i = 0; i < saber->numBlades; i++ )
+	{
+		//saber->blade[i].ActivateTrail( duration );
+		BG_BLADE_ActivateTrail(&saber->blade[i], duration);
+	}
+}
+
+void BG_SI_DeactivateTrail ( saberInfo_t *saber, float duration )
+{
+	int i;
+
+	for ( i = 0; i < saber->numBlades; i++ )
+	{
+		//saber->blade[i].DeactivateTrail( duration );
+		BG_BLADE_DeactivateTrail(&saber->blade[i], duration);
+	}
+}
+
+#include "../namespace_end.h"
diff --git a/codemp/game/bg_saga.c b/codemp/game/bg_saga.c
new file mode 100644
index 0000000..fa843a2
--- /dev/null
+++ b/codemp/game/bg_saga.c
@@ -0,0 +1,1507 @@
+// Copyright (C) 2000-2002 Raven Software, Inc.
+//
+/*****************************************************************************
+ * name:		bg_saga.c
+ *
+ * desc:		Siege module, shared for game, cgame, and ui.
+ *
+ * $Author: osman $ 
+ * $Revision: 1.9 $
+ *
+ *****************************************************************************/
+#include "q_shared.h"
+#include "bg_saga.h"
+#include "bg_weapons.h"
+#include "bg_public.h"
+
+#define SIEGECHAR_TAB 9 //perhaps a bit hacky, but I don't think there's any define existing for "tab"
+
+//Could use strap stuff but I don't particularly care at the moment anyway.
+#include "../namespace_begin.h"
+
+extern int	trap_FS_FOpenFile( const char *qpath, fileHandle_t *f, fsMode_t mode );
+extern void	trap_FS_Read( void *buffer, int len, fileHandle_t f );
+extern void	trap_FS_Write( const void *buffer, int len, fileHandle_t f );
+extern void	trap_FS_FCloseFile( fileHandle_t f );
+extern int	trap_FS_GetFileList(  const char *path, const char *extension, char *listbuf, int bufsize );
+
+#ifndef QAGAME //cgame, ui
+qhandle_t	trap_R_RegisterShaderNoMip( const char *name );
+#endif
+
+char		siege_info[MAX_SIEGE_INFO_SIZE];
+int			siege_valid = 0;
+
+siegeTeam_t *team1Theme = NULL;
+siegeTeam_t *team2Theme = NULL;
+
+siegeClass_t bgSiegeClasses[MAX_SIEGE_CLASSES];
+int bgNumSiegeClasses = 0;
+
+siegeTeam_t bgSiegeTeams[MAX_SIEGE_TEAMS];
+int bgNumSiegeTeams = 0;
+
+//class flags
+stringID_table_t bgSiegeClassFlagNames[] =
+{
+	ENUM2STRING(CFL_MORESABERDMG),
+	ENUM2STRING(CFL_STRONGAGAINSTPHYSICAL),
+	ENUM2STRING(CFL_FASTFORCEREGEN),
+	ENUM2STRING(CFL_STATVIEWER),
+	ENUM2STRING(CFL_HEAVYMELEE),
+	ENUM2STRING(CFL_SINGLE_ROCKET),
+	ENUM2STRING(CFL_CUSTOMSKEL),
+	ENUM2STRING(CFL_EXTRA_AMMO),
+	"", -1
+};
+
+//saber stances
+stringID_table_t StanceTable[] =
+{
+	ENUM2STRING(SS_NONE),
+	ENUM2STRING(SS_FAST),
+	ENUM2STRING(SS_MEDIUM),
+	ENUM2STRING(SS_STRONG),
+	ENUM2STRING(SS_DESANN),
+	ENUM2STRING(SS_TAVION),
+	ENUM2STRING(SS_DUAL),
+	ENUM2STRING(SS_STAFF),
+	"", 0
+};
+
+//Weapon and force power tables are also used in NPC parsing code and some other places.
+stringID_table_t WPTable[] =
+{
+	"NULL",WP_NONE,
+	// Player weapons
+	ENUM2STRING(WP_STUN_BATON),
+	ENUM2STRING(WP_MELEE),
+	ENUM2STRING(WP_SABER),
+	ENUM2STRING(WP_BRYAR_PISTOL),
+	"WP_BLASTER_PISTOL", WP_BRYAR_PISTOL,
+	ENUM2STRING(WP_BLASTER),
+	ENUM2STRING(WP_DISRUPTOR),
+	ENUM2STRING(WP_BOWCASTER),
+	ENUM2STRING(WP_REPEATER),
+	ENUM2STRING(WP_DEMP2),
+	ENUM2STRING(WP_FLECHETTE),
+	ENUM2STRING(WP_ROCKET_LAUNCHER),
+	ENUM2STRING(WP_THERMAL),
+	ENUM2STRING(WP_TRIP_MINE),
+	ENUM2STRING(WP_DET_PACK),
+	ENUM2STRING(WP_CONCUSSION),
+	ENUM2STRING(WP_BRYAR_OLD),
+	ENUM2STRING(WP_EMPLACED_GUN),
+	ENUM2STRING(WP_TURRET),
+	"", 0
+};
+
+stringID_table_t FPTable[] =
+{
+	ENUM2STRING(FP_HEAL),
+	ENUM2STRING(FP_LEVITATION),
+	ENUM2STRING(FP_SPEED),
+	ENUM2STRING(FP_PUSH),
+	ENUM2STRING(FP_PULL),
+	ENUM2STRING(FP_TELEPATHY),
+	ENUM2STRING(FP_GRIP),
+	ENUM2STRING(FP_LIGHTNING),
+	ENUM2STRING(FP_RAGE),
+	ENUM2STRING(FP_PROTECT),
+	ENUM2STRING(FP_ABSORB),
+	ENUM2STRING(FP_TEAM_HEAL),
+	ENUM2STRING(FP_TEAM_FORCE),
+	ENUM2STRING(FP_DRAIN),
+	ENUM2STRING(FP_SEE),
+	ENUM2STRING(FP_SABER_OFFENSE),
+	ENUM2STRING(FP_SABER_DEFENSE),
+	ENUM2STRING(FP_SABERTHROW),
+	"",	-1
+};
+
+stringID_table_t HoldableTable[] =
+{
+	ENUM2STRING(HI_NONE),
+
+	ENUM2STRING(HI_SEEKER),
+	ENUM2STRING(HI_SHIELD),
+	ENUM2STRING(HI_MEDPAC),
+	ENUM2STRING(HI_MEDPAC_BIG),
+	ENUM2STRING(HI_BINOCULARS),
+	ENUM2STRING(HI_SENTRY_GUN),
+	ENUM2STRING(HI_JETPACK),
+	ENUM2STRING(HI_HEALTHDISP),
+	ENUM2STRING(HI_AMMODISP),
+	ENUM2STRING(HI_EWEB),
+	ENUM2STRING(HI_CLOAK),
+
+	"", -1
+};
+
+stringID_table_t PowerupTable[] =
+{
+	ENUM2STRING(PW_NONE),
+	ENUM2STRING(PW_QUAD),
+	ENUM2STRING(PW_BATTLESUIT),
+	ENUM2STRING(PW_PULL),
+	ENUM2STRING(PW_REDFLAG),
+	ENUM2STRING(PW_BLUEFLAG),
+	ENUM2STRING(PW_NEUTRALFLAG),
+	ENUM2STRING(PW_SHIELDHIT),
+	ENUM2STRING(PW_SPEEDBURST),
+	ENUM2STRING(PW_DISINT_4),
+	ENUM2STRING(PW_SPEED),
+	ENUM2STRING(PW_CLOAKED),
+	ENUM2STRING(PW_FORCE_ENLIGHTENED_LIGHT),
+	ENUM2STRING(PW_FORCE_ENLIGHTENED_DARK),
+	ENUM2STRING(PW_FORCE_BOON),
+	ENUM2STRING(PW_YSALAMIRI),
+
+	"", -1
+};
+
+
+//======================================
+//Parsing functions
+//======================================
+void BG_SiegeStripTabs(char *buf)
+{
+	int i = 0;
+	int i_r = 0;
+
+	while (buf[i])
+	{
+		if (buf[i] != SIEGECHAR_TAB)
+		{ //not a tab, just stick it in
+			buf[i_r] = buf[i];
+		}
+		else
+		{ //If it's a tab, convert it to a space.
+			buf[i_r] = ' ';
+		}
+
+		i_r++;
+		i++;
+	}
+
+	buf[i_r] = '\0';
+}
+
+int BG_SiegeGetValueGroup(char *buf, char *group, char *outbuf)
+{
+	int i = 0;
+	int j;
+	char checkGroup[4096];
+	qboolean isGroup;
+	int parseGroups = 0;
+
+	while (buf[i])
+	{
+		if (buf[i] != ' ' && buf[i] != '{' && buf[i] != '}' && buf[i] != '\n' && buf[i] != '\r' && buf[i] != SIEGECHAR_TAB)
+		{ //we're on a valid character
+			if (buf[i] == '/' &&
+				buf[i+1] == '/')
+			{ //this is a comment, so skip over it
+				while (buf[i] && buf[i] != '\n' && buf[i] != '\r' && buf[i] != SIEGECHAR_TAB)
+				{
+					i++;
+				}
+			}
+			else
+			{ //parse to the next space/endline/eos and check this value against our group value.
+				j = 0;
+
+				while (buf[i] != ' ' && buf[i] != '\n' && buf[i] != '\r' && buf[i] != SIEGECHAR_TAB && buf[i] != '{' && buf[i])
+				{
+					if (buf[i] == '/' && buf[i+1] == '/')
+					{ //hit a comment, break out.
+						break;
+					}
+
+					checkGroup[j] = buf[i];
+					j++;
+					i++;
+				}
+				checkGroup[j] = 0;
+
+				//Make sure this is a group as opposed to a globally defined value.
+				if (buf[i] == '/' && buf[i+1] == '/')
+				{ //stopped on a comment, so first parse to the end of it.
+                    while (buf[i] && buf[i] != '\n' && buf[i] != '\r')
+					{
+						i++;
+					}
+					while (buf[i] == '\n' || buf[i] == '\r')
+					{
+						i++;
+					}
+				}
+
+				if (!buf[i])
+				{
+					Com_Error(ERR_DROP, "Unexpected EOF while looking for group '%s'", group);
+				}
+
+				isGroup = qfalse;
+
+				while (buf[i] && buf[i] == ' ' || buf[i] == SIEGECHAR_TAB || buf[i] == '\n' || buf[i] == '\r')
+				{ //parse to the next valid character
+					i++;
+				}
+
+				if (buf[i] == '{')
+				{ //if the next valid character is an opening bracket, then this is indeed a group
+					isGroup = qtrue;
+				}
+
+				//Is this the one we want?
+				if (isGroup && !Q_stricmp(checkGroup, group))
+				{ //guess so. Parse until we hit the { indicating the beginning of the group.
+					while (buf[i] != '{' && buf[i])
+					{
+						i++;
+					}
+
+					if (buf[i])
+					{ //We're at the start of the group now, so parse to the closing bracket.
+						j = 0;
+
+						parseGroups = 0;
+
+						while ((buf[i] != '}' || parseGroups) && buf[i])
+						{
+							if (buf[i] == '{')
+							{ //increment for the opening bracket.
+								parseGroups++;
+							}
+							else if (buf[i] == '}')
+							{ //decrement for the closing bracket
+								parseGroups--;
+							}
+
+							if (parseGroups < 0)
+							{ //Syntax error, I guess.
+								Com_Error(ERR_DROP, "Found a closing bracket without an opening bracket while looking for group '%s'", group);
+							}
+
+							if ((buf[i] != '{' || parseGroups > 1) &&
+								(buf[i] != '}' || parseGroups > 0))
+							{ //don't put the start and end brackets for this group into the output buffer
+								outbuf[j] = buf[i];
+								j++;
+							}
+
+							if (buf[i] == '}' && !parseGroups)
+							{ //Alright, we can break out now.
+								break;
+							}
+
+							i++;
+						}
+						outbuf[j] = 0;
+
+						//Verify that we ended up on the closing bracket.
+						if (buf[i] != '}')
+						{
+							Com_Error(ERR_DROP, "Group '%s' is missing a closing bracket", group);
+						}
+
+						//Strip the tabs so we're friendly for value parsing.
+						BG_SiegeStripTabs(outbuf);
+
+						return 1; //we got it, so return 1.
+					}
+					else
+					{
+						Com_Error(ERR_DROP, "Error parsing group in file, unexpected EOF before opening bracket while looking for group '%s'", group);
+					}
+				}
+				else if (!isGroup)
+				{ //if it wasn't a group, parse to the end of the line
+					while (buf[i] && buf[i] != '\n' && buf[i] != '\r')
+					{
+						i++;
+					}
+				}
+				else
+				{ //this was a group but we not the one we wanted to find, so parse by it.
+					parseGroups = 0;
+
+					while (buf[i] && (buf[i] != '}' || parseGroups))
+					{
+						if (buf[i] == '{')
+						{
+							parseGroups++;
+						}
+						else if (buf[i] == '}')
+						{
+							parseGroups--;
+						}
+
+						if (parseGroups < 0)
+						{ //Syntax error, I guess.
+							Com_Error(ERR_DROP, "Found a closing bracket without an opening bracket while looking for group '%s'", group);
+						}
+
+						if (buf[i] == '}' && !parseGroups)
+						{ //Alright, we can break out now.
+							break;
+						}
+
+						i++;
+					}
+
+					if (buf[i] != '}')
+					{
+						Com_Error(ERR_DROP, "Found an opening bracket without a matching closing bracket while looking for group '%s'", group);
+					}
+
+					i++;
+				}
+			}
+		}
+		else if (buf[i] == '{')
+		{ //we're in a group that isn't the one we want, so parse to the end.
+			parseGroups = 0;
+
+			while (buf[i] && (buf[i] != '}' || parseGroups))
+			{
+				if (buf[i] == '{')
+				{
+					parseGroups++;
+				}
+				else if (buf[i] == '}')
+				{
+					parseGroups--;
+				}
+
+				if (parseGroups < 0)
+				{ //Syntax error, I guess.
+					Com_Error(ERR_DROP, "Found a closing bracket without an opening bracket while looking for group '%s'", group);
+				}
+
+				if (buf[i] == '}' && !parseGroups)
+				{ //Alright, we can break out now.
+					break;
+				}
+
+				i++;
+			}
+
+			if (buf[i] != '}')
+			{
+				Com_Error(ERR_DROP, "Found an opening bracket without a matching closing bracket while looking for group '%s'", group);
+			}
+		}
+
+		if (!buf[i])
+		{
+			break;
+		}
+		i++;
+	}
+
+	return 0; //guess we never found it.
+}
+
+int BG_SiegeGetPairedValue(char *buf, char *key, char *outbuf)
+{
+	int i = 0;
+	int j;
+	int k;
+	char checkKey[4096];
+
+	while (buf[i])
+	{
+		if (buf[i] != ' ' && buf[i] != '{' && buf[i] != '}' && buf[i] != '\n' && buf[i] != '\r')
+		{ //we're on a valid character
+			if (buf[i] == '/' &&
+				buf[i+1] == '/')
+			{ //this is a comment, so skip over it
+				while (buf[i] && buf[i] != '\n' && buf[i] != '\r')
+				{
+					i++;
+				}
+			}
+			else
+			{ //parse to the next space/endline/eos and check this value against our key value.
+				j = 0;
+
+				while (buf[i] != ' ' && buf[i] != '\n' && buf[i] != '\r' && buf[i] != SIEGECHAR_TAB && buf[i])
+				{
+					if (buf[i] == '/' && buf[i+1] == '/')
+					{ //hit a comment, break out.
+						break;
+					}
+
+					checkKey[j] = buf[i];
+					j++;
+					i++;
+				}
+				checkKey[j] = 0;
+
+				k = i;
+
+				while (buf[k] && (buf[k] == ' ' || buf[k] == '\n' || buf[k] == '\r'))
+				{
+					k++;
+				}
+
+				if (buf[k] == '{')
+				{ //this is not the start of a value but rather of a group. We don't want to look in subgroups so skip over the whole thing.
+					int openB = 0;
+
+					while (buf[i] && (buf[i] != '}' || openB))
+					{
+						if (buf[i] == '{')
+						{
+							openB++;
+						}
+						else if (buf[i] == '}')
+						{
+							openB--;
+						}
+
+						if (openB < 0)
+						{
+							Com_Error(ERR_DROP, "Unexpected closing bracket (too many) while parsing to end of group '%s'", checkKey);
+						}
+
+						if (buf[i] == '}' && !openB)
+						{ //this is the end of the group
+							break;
+						}
+						i++;
+					}
+
+					if (buf[i] == '}')
+					{
+						i++;
+					}
+				}
+				else
+				{
+					//Is this the one we want?
+					if (buf[i] != '/' || buf[i+1] != '/')
+					{ //make sure we didn't stop on a comment, if we did then this is considered an error in the file.
+						if (!Q_stricmp(checkKey, key))
+						{ //guess so. Parse along to the next valid character, then put that into the output buffer and return 1.
+							while ((buf[i] == ' ' || buf[i] == '\n' || buf[i] == '\r' || buf[i] == SIEGECHAR_TAB) && buf[i])
+							{
+								i++;
+							}
+
+							if (buf[i])
+							{ //We're at the start of the value now.
+								qboolean parseToQuote = qfalse;
+
+								if (buf[i] == '\"')
+								{ //if the value is in quotes, then stop at the next quote instead of ' '
+									i++;
+									parseToQuote = qtrue;
+								}
+
+								j = 0;
+								while ( ((!parseToQuote && buf[i] != ' ' && buf[i] != '\n' && buf[i] != '\r') || (parseToQuote && buf[i] != '\"')) )
+								{
+									if (buf[i] == '/' &&
+										buf[i+1] == '/')
+									{ //hit a comment after the value? This isn't an ideal way to be writing things, but we'll support it anyway.
+										break;
+									}
+									outbuf[j] = buf[i];
+									j++;
+									i++;
+
+									if (!buf[i])
+									{
+										if (parseToQuote)
+										{
+											Com_Error(ERR_DROP, "Unexpected EOF while looking for endquote, error finding paired value for '%s'", key);
+										}
+										else
+										{
+											Com_Error(ERR_DROP, "Unexpected EOF while looking for space or endline, error finding paired value for '%s'", key);
+										}
+									}
+								}
+								outbuf[j] = 0;
+
+								return 1; //we got it, so return 1.
+							}
+							else
+							{
+								Com_Error(ERR_DROP, "Error parsing file, unexpected EOF while looking for valud '%s'", key);
+							}
+						}
+						else
+						{ //if that wasn't the desired key, then make sure we parse to the end of the line, so we don't mistake a value for a key
+							while (buf[i] && buf[i] != '\n')
+							{
+								i++;
+							}
+						}
+					}
+					else
+					{
+						Com_Error(ERR_DROP, "Error parsing file, found comment, expected value for '%s'", key);
+					}
+				}
+			}
+		}
+
+		if (!buf[i])
+		{
+			break;
+		}
+		i++;
+	}
+
+	return 0; //guess we never found it.
+}
+//======================================
+//End parsing functions
+//======================================
+
+
+//======================================
+//Class loading functions
+//======================================
+void BG_SiegeTranslateForcePowers(char *buf, siegeClass_t *siegeClass)
+{
+	char checkPower[1024];
+	char checkLevel[256];
+	int l = 0;
+	int k = 0;
+	int j = 0;
+	int i = 0;
+	int parsedLevel = 0;
+	qboolean allPowers = qfalse;
+	qboolean noPowers = qfalse;
+
+	if (!Q_stricmp(buf, "FP_ALL"))
+	{ //this is a special case, just give us all the powers on level 3
+		allPowers = qtrue;
+	}
+
+	if (buf[0] == '0' && !buf[1])
+	{ //no powers then
+		noPowers = qtrue;
+	}
+
+	//First clear out the powers, or in the allPowers case, give us all level 3.
+	while (i < NUM_FORCE_POWERS)
+	{
+		if (allPowers)
+		{
+			siegeClass->forcePowerLevels[i] = FORCE_LEVEL_3;
+		}
+		else
+		{
+			siegeClass->forcePowerLevels[i] = 0;
+		}
+		i++;
+	}
+
+	if (allPowers || noPowers)
+	{ //we're done now then.
+		return;
+	}
+
+	i = 0;
+	while (buf[i])
+	{ //parse through the list which is seperated by |, and add all the weapons into a bitflag
+		if (buf[i] != ' ' && buf[i] != '|')
+		{
+			j = 0;
+
+			while (buf[i] && buf[i] != ' ' && buf[i] != '|' && buf[i] != ',')
+			{
+				checkPower[j] = buf[i];
+				j++;
+				i++;
+			}
+			checkPower[j] = 0;
+
+			if (buf[i] == ',')
+			{ //parse the power level
+				i++;
+				l = 0;
+				while (buf[i] && buf[i] != ' ' && buf[i] != '|')
+				{
+					checkLevel[l] = buf[i];
+					l++;
+					i++;
+				}
+				checkLevel[l] = 0;
+				parsedLevel = atoi(checkLevel);
+
+				//keep sane limits on the powers
+				if (parsedLevel < 0)
+				{
+					parsedLevel = 0;
+				}
+				if (parsedLevel > FORCE_LEVEL_5)
+				{
+					parsedLevel = FORCE_LEVEL_5;
+				}
+			}
+			else
+			{ //if it's not there, assume level 3 I guess.
+				parsedLevel = 3;
+			}
+
+			if (checkPower[0])
+			{ //Got the name, compare it against the weapon table strings.
+				k = 0;
+
+				if (!Q_stricmp(checkPower, "FP_JUMP"))
+				{ //haqery
+                    strcpy(checkPower, "FP_LEVITATION");
+				}
+
+				while (FPTable[k].id != -1 && FPTable[k].name[0])
+				{
+					if (!Q_stricmp(checkPower, FPTable[k].name))
+					{ //found it, add the weapon into the weapons value
+						siegeClass->forcePowerLevels[k] = parsedLevel;
+						break;
+					}
+					k++;
+				}
+			}
+		}
+
+		if (!buf[i])
+		{
+			break;
+		}
+		i++;
+	}
+}
+
+//Used for the majority of generic val parsing stuff. buf should be the value string,
+//table should be the appropriate string/id table. If bitflag is qtrue then the
+//values are accumulated into a bitflag. If bitflag is qfalse then the first value
+//is returned as a directly corresponding id and no further parsing is done.
+int BG_SiegeTranslateGenericTable(char *buf, stringID_table_t *table, qboolean bitflag)
+{
+	int items = 0;
+	char checkItem[1024];
+	int i = 0;
+	int j = 0;
+	int k = 0;
+
+	if (buf[0] == '0' && !buf[1])
+	{ //special case, no items.
+		return 0;
+	}
+
+	while (buf[i])
+	{ //Using basically the same parsing method as we do for weapons and forcepowers.
+		if (buf[i] != ' ' && buf[i] != '|')
+		{
+			j = 0;
+
+			while (buf[i] && buf[i] != ' ' && buf[i] != '|')
+			{
+				checkItem[j] = buf[i];
+				j++;
+				i++;
+			}
+			checkItem[j] = 0;
+
+			if (checkItem[0])
+			{
+				k = 0;
+
+                while (table[k].name && table[k].name[0])
+				{ //go through the list and check the parsed flag name against the hardcoded names
+					if (!Q_stricmp(checkItem, table[k].name))
+					{ //Got it, so add the value into our items value.
+						if (bitflag)
+						{
+							items |= (1 << table[k].id);
+						}
+						else
+						{ //return the value directly then.
+							return table[k].id;
+						}
+						break;
+					}
+					k++;
+				}
+			}
+		}
+
+		if (!buf[i])
+		{
+			break;
+		}
+
+		i++;
+	}
+	return items;
+}
+
+char *classTitles[SPC_MAX] =
+{
+"infantry",			// SPC_INFANTRY
+"vanguard",			// SPC_VANGUARD
+"support",			// SPC_SUPPORT
+"jedi_general",		// SPC_JEDI
+"demolitionist",	// SPC_DEMOLITIONIST
+"heavy_weapons",	// SPC_HEAVY_WEAPONS
+};
+
+
+void BG_SiegeParseClassFile(const char *filename, siegeClassDesc_t *descBuffer)
+{
+	fileHandle_t f;
+	int len;
+	int i;
+	char classInfo[4096];
+	char parseBuf[4096];
+
+	len = trap_FS_FOpenFile(filename, &f, FS_READ);
+
+	if (!f || len >= 4096)
+	{
+		return;
+	}
+
+	trap_FS_Read(classInfo, len, f);
+
+	trap_FS_FCloseFile(f);
+
+	classInfo[len] = 0;
+
+	//first get the description if we have a buffer for it
+	if (descBuffer)
+	{
+		if (!BG_SiegeGetPairedValue(classInfo, "description", descBuffer->desc))
+		{
+			strcpy(descBuffer->desc, "DESCRIPTION UNAVAILABLE");
+		}
+
+		//Hit this assert?  Memory has already been trashed.  Increase
+		//SIEGE_CLASS_DESC_LEN.
+		assert(strlen(descBuffer->desc) < SIEGE_CLASS_DESC_LEN);
+	}
+
+	BG_SiegeGetValueGroup(classInfo, "ClassInfo", classInfo);
+
+	//Parse name
+	if (BG_SiegeGetPairedValue(classInfo, "name", parseBuf))
+	{
+		strcpy(bgSiegeClasses[bgNumSiegeClasses].name, parseBuf);
+	}
+	else
+	{
+		Com_Error(ERR_DROP, "Siege class without name entry");
+	}
+
+	//Parse forced model
+	if (BG_SiegeGetPairedValue(classInfo, "model", parseBuf))
+	{
+		strcpy(bgSiegeClasses[bgNumSiegeClasses].forcedModel, parseBuf);
+	}
+	else
+	{ //It's ok if there isn't one, it's optional.
+		bgSiegeClasses[bgNumSiegeClasses].forcedModel[0] = 0;
+	}
+
+	//Parse forced skin
+	if (BG_SiegeGetPairedValue(classInfo, "skin", parseBuf))
+	{
+		strcpy(bgSiegeClasses[bgNumSiegeClasses].forcedSkin, parseBuf);
+	}
+	else
+	{ //It's ok if there isn't one, it's optional.
+		bgSiegeClasses[bgNumSiegeClasses].forcedSkin[0] = 0;
+	}
+
+	//Parse first saber
+	if (BG_SiegeGetPairedValue(classInfo, "saber1", parseBuf))
+	{
+		strcpy(bgSiegeClasses[bgNumSiegeClasses].saber1, parseBuf);
+	}
+	else
+	{ //It's ok if there isn't one, it's optional.
+		bgSiegeClasses[bgNumSiegeClasses].saber1[0] = 0;
+	}
+
+	//Parse second saber
+	if (BG_SiegeGetPairedValue(classInfo, "saber2", parseBuf))
+	{
+		strcpy(bgSiegeClasses[bgNumSiegeClasses].saber2, parseBuf);
+	}
+	else
+	{ //It's ok if there isn't one, it's optional.
+		bgSiegeClasses[bgNumSiegeClasses].saber2[0] = 0;
+	}
+
+	//Parse forced saber stance
+	if (BG_SiegeGetPairedValue(classInfo, "saberstyle", parseBuf))
+	{
+		bgSiegeClasses[bgNumSiegeClasses].saberStance = BG_SiegeTranslateGenericTable(parseBuf, StanceTable, qtrue);
+	}
+	else
+	{ //It's ok if there isn't one, it's optional.
+		bgSiegeClasses[bgNumSiegeClasses].saberStance = 0;
+	}
+
+	//Parse forced saber color
+	if (BG_SiegeGetPairedValue(classInfo, "sabercolor", parseBuf))
+	{
+		bgSiegeClasses[bgNumSiegeClasses].forcedSaberColor = atoi(parseBuf);
+		bgSiegeClasses[bgNumSiegeClasses].hasForcedSaberColor = qtrue;
+	}
+	else
+	{ //It's ok if there isn't one, it's optional.
+		bgSiegeClasses[bgNumSiegeClasses].hasForcedSaberColor = qfalse;
+	}
+
+	//Parse forced saber2 color
+	if (BG_SiegeGetPairedValue(classInfo, "saber2color", parseBuf))
+	{
+		bgSiegeClasses[bgNumSiegeClasses].forcedSaber2Color = atoi(parseBuf);
+		bgSiegeClasses[bgNumSiegeClasses].hasForcedSaber2Color = qtrue;
+	}
+	else
+	{ //It's ok if there isn't one, it's optional.
+		bgSiegeClasses[bgNumSiegeClasses].hasForcedSaber2Color = qfalse;
+	}
+
+	//Parse weapons
+	if (BG_SiegeGetPairedValue(classInfo, "weapons", parseBuf))
+	{
+		bgSiegeClasses[bgNumSiegeClasses].weapons = BG_SiegeTranslateGenericTable(parseBuf, WPTable, qtrue);
+	}
+	else
+	{
+		Com_Error(ERR_DROP, "Siege class without weapons entry");
+	}
+
+	if (!(bgSiegeClasses[bgNumSiegeClasses].weapons & (1 << WP_SABER)))
+	{ //make sure it has melee if there's no saber
+		bgSiegeClasses[bgNumSiegeClasses].weapons |= (1 << WP_MELEE);
+
+		//always give them this too if they are not a saber user
+		//bgSiegeClasses[bgNumSiegeClasses].weapons |= (1 << WP_BRYAR_PISTOL);
+	}
+
+	//Parse forcepowers
+	if (BG_SiegeGetPairedValue(classInfo, "forcepowers", parseBuf))
+	{
+		BG_SiegeTranslateForcePowers(parseBuf, &bgSiegeClasses[bgNumSiegeClasses]);
+	}
+	else
+	{ //fine, clear out the powers.
+		i = 0;
+		while (i < NUM_FORCE_POWERS)
+		{
+			bgSiegeClasses[bgNumSiegeClasses].forcePowerLevels[i] = 0;
+			i++;
+		}
+	}
+
+	//Parse classflags
+	if (BG_SiegeGetPairedValue(classInfo, "classflags", parseBuf))
+	{
+		bgSiegeClasses[bgNumSiegeClasses].classflags = BG_SiegeTranslateGenericTable(parseBuf, bgSiegeClassFlagNames, qtrue);
+	}
+	else
+	{ //fine, we'll 0 it.
+		bgSiegeClasses[bgNumSiegeClasses].classflags = 0;
+	}
+
+	//Parse maxhealth
+	if (BG_SiegeGetPairedValue(classInfo, "maxhealth", parseBuf))
+	{
+		bgSiegeClasses[bgNumSiegeClasses].maxhealth = atoi(parseBuf);
+	}
+	else
+	{ //It's alright, just default to 100 then.
+		bgSiegeClasses[bgNumSiegeClasses].maxhealth = 100;
+	}
+
+	//Parse starthealth
+	if (BG_SiegeGetPairedValue(classInfo, "starthealth", parseBuf))
+	{
+		bgSiegeClasses[bgNumSiegeClasses].starthealth = atoi(parseBuf);
+	}
+	else
+	{ //It's alright, just default to 100 then.
+		bgSiegeClasses[bgNumSiegeClasses].starthealth = 100;
+	}
+
+
+	//Parse startarmor
+	if (BG_SiegeGetPairedValue(classInfo, "maxarmor", parseBuf))
+	{
+		bgSiegeClasses[bgNumSiegeClasses].maxarmor = atoi(parseBuf);
+	}
+	else
+	{ //It's alright, just default to 0 then.
+		bgSiegeClasses[bgNumSiegeClasses].maxarmor = 0;
+	}
+
+	//Parse startarmor
+	if (BG_SiegeGetPairedValue(classInfo, "startarmor", parseBuf))
+	{
+		bgSiegeClasses[bgNumSiegeClasses].startarmor = atoi(parseBuf);
+		if (!bgSiegeClasses[bgNumSiegeClasses].maxarmor)
+		{ //if they didn't specify a damn max armor then use this.
+			bgSiegeClasses[bgNumSiegeClasses].maxarmor = bgSiegeClasses[bgNumSiegeClasses].startarmor;
+		}
+	}
+	else
+	{ //default to maxarmor.
+		bgSiegeClasses[bgNumSiegeClasses].startarmor = bgSiegeClasses[bgNumSiegeClasses].maxarmor;
+	}
+
+	//Parse speed (this is a multiplier value)
+	if (BG_SiegeGetPairedValue(classInfo, "speed", parseBuf))
+	{
+		bgSiegeClasses[bgNumSiegeClasses].speed = atof(parseBuf);
+	}
+	else
+	{ //It's alright, just default to 1 then.
+		bgSiegeClasses[bgNumSiegeClasses].speed = 1.0f;
+	}
+
+	//Parse shader for ui to use
+	if (BG_SiegeGetPairedValue(classInfo, "uishader", parseBuf))
+	{
+#ifdef QAGAME
+		bgSiegeClasses[bgNumSiegeClasses].uiPortraitShader = 0;
+		memset(bgSiegeClasses[bgNumSiegeClasses].uiPortrait,0,sizeof(bgSiegeClasses[bgNumSiegeClasses].uiPortrait));
+#elif defined CGAME
+		bgSiegeClasses[bgNumSiegeClasses].uiPortraitShader = 0;
+		memset(bgSiegeClasses[bgNumSiegeClasses].uiPortrait,0,sizeof(bgSiegeClasses[bgNumSiegeClasses].uiPortrait));
+#else //ui
+		bgSiegeClasses[bgNumSiegeClasses].uiPortraitShader = trap_R_RegisterShaderNoMip(parseBuf);
+		memcpy(bgSiegeClasses[bgNumSiegeClasses].uiPortrait,parseBuf,sizeof(bgSiegeClasses[bgNumSiegeClasses].uiPortrait));
+#endif
+	}
+	else
+	{ //I guess this is an essential.. we don't want to render bad shaders or anything.
+		Com_Error(ERR_DROP, "Siege class without uishader entry");
+	}
+
+	//Parse shader for ui to use
+	if (BG_SiegeGetPairedValue(classInfo, "class_shader", parseBuf))
+	{
+#ifdef QAGAME
+		bgSiegeClasses[bgNumSiegeClasses].classShader = 0;
+#else //cgame, ui
+		bgSiegeClasses[bgNumSiegeClasses].classShader = trap_R_RegisterShaderNoMip(parseBuf);
+		assert( bgSiegeClasses[bgNumSiegeClasses].classShader );
+		if ( !bgSiegeClasses[bgNumSiegeClasses].classShader )
+		{
+			//Com_Error( ERR_DROP, "ERROR: could not find class_shader %s for class %s\n", parseBuf, bgSiegeClasses[bgNumSiegeClasses].name );
+			Com_Printf( "ERROR: could not find class_shader %s for class %s\n", parseBuf, bgSiegeClasses[bgNumSiegeClasses].name );
+		}
+		// A very hacky way to determine class . . . 
+		else
+#endif
+		{
+			// Find the base player class based on the icon name - very bad, I know.
+			int titleLength,i,arrayTitleLength;
+			char *holdBuf;
+
+			titleLength = strlen(parseBuf);
+			for (i=0;i<SPC_MAX;i++)
+			{
+				// Back up 
+				arrayTitleLength = strlen(classTitles[i]);
+				if (arrayTitleLength>titleLength)	// Too long
+				{
+					break;
+				}
+
+				holdBuf = parseBuf + ( titleLength - arrayTitleLength);
+				if (!strcmp(holdBuf,classTitles[i]))
+				{
+					bgSiegeClasses[bgNumSiegeClasses].playerClass = i;
+					break;
+				}
+			}
+
+			// In case the icon name doesn't match up
+			if (i>=SPC_MAX)
+			{
+				bgSiegeClasses[bgNumSiegeClasses].playerClass = SPC_INFANTRY;
+			}
+		}
+	}
+	else
+	{ //No entry!  Bad bad bad
+		//Com_Error( ERR_DROP, "ERROR: no class_shader defined for class %s\n", bgSiegeClasses[bgNumSiegeClasses].name );
+		Com_Printf( "ERROR: no class_shader defined for class %s\n", bgSiegeClasses[bgNumSiegeClasses].name );
+	}
+
+	//Parse holdable items to use
+	if (BG_SiegeGetPairedValue(classInfo, "holdables", parseBuf))
+	{
+		bgSiegeClasses[bgNumSiegeClasses].invenItems = BG_SiegeTranslateGenericTable(parseBuf, HoldableTable, qtrue);
+	}
+	else
+	{ //Just don't start out with any then.
+		bgSiegeClasses[bgNumSiegeClasses].invenItems = 0;
+	}
+
+	//Parse powerups to use
+	if (BG_SiegeGetPairedValue(classInfo, "powerups", parseBuf))
+	{
+		bgSiegeClasses[bgNumSiegeClasses].powerups = BG_SiegeTranslateGenericTable(parseBuf, PowerupTable, qtrue);
+	}
+	else
+	{ //Just don't start out with any then.
+		bgSiegeClasses[bgNumSiegeClasses].powerups = 0;
+	}
+
+	//A successful read.
+	bgNumSiegeClasses++;
+}
+
+// Count the number of like base classes
+int BG_SiegeCountBaseClass(const int team, const short classIndex)
+{
+	int count = 0,i;
+	siegeTeam_t *stm;
+
+	stm = BG_SiegeFindThemeForTeam(team);
+	if (!stm)
+	{
+		return(0);
+
+	}
+
+	for (i=0;i<stm->numClasses;i++)
+	{
+
+		if (stm->classes[i]->playerClass == classIndex)
+		{
+			count++;
+		}
+	}
+	return(count);
+}
+
+char *BG_GetUIPortraitFile(const int team, const short classIndex, const short cntIndex)
+{
+	int count = 0,i;
+	siegeTeam_t *stm;
+
+	stm = BG_SiegeFindThemeForTeam(team);
+	if (!stm)
+	{
+		return(0);
+
+	}
+
+	// Loop through all the classes for this team
+	for (i=0;i<stm->numClasses;i++)
+	{
+		// does it match the base class?
+		if (stm->classes[i]->playerClass == classIndex)
+		{
+			if (count==cntIndex)
+			{
+				return(stm->classes[i]->uiPortrait);
+			}
+			++count;
+		}
+	}
+
+	return(0);
+}
+
+int BG_GetUIPortrait(const int team, const short classIndex, const short cntIndex)
+{
+	int count = 0,i;
+	siegeTeam_t *stm;
+
+	stm = BG_SiegeFindThemeForTeam(team);
+	if (!stm)
+	{
+		return(0);
+
+	}
+
+	// Loop through all the classes for this team
+	for (i=0;i<stm->numClasses;i++)
+	{
+		// does it match the base class?
+		if (stm->classes[i]->playerClass == classIndex)
+		{
+			if (count==cntIndex)
+			{
+				return(stm->classes[i]->uiPortraitShader);
+			}
+			++count;
+		}
+	}
+
+	return(0);
+}
+
+// This is really getting ugly - looking to get the base class (within a class) based on the index passed in
+siegeClass_t *BG_GetClassOnBaseClass(const int team, const short classIndex, const short cntIndex)
+{
+	int count = 0,i;
+	siegeTeam_t *stm;
+
+	stm = BG_SiegeFindThemeForTeam(team);
+	if (!stm)
+	{
+		return(0);
+	}
+
+	// Loop through all the classes for this team
+	for (i=0;i<stm->numClasses;i++)
+	{
+		// does it match the base class?
+		if (stm->classes[i]->playerClass == classIndex)
+		{
+			if (count==cntIndex)
+			{
+				return(stm->classes[i]);
+			}
+			++count;
+		}
+	}
+
+	return(0);
+}
+
+void BG_SiegeLoadClasses(siegeClassDesc_t *descBuffer)
+{
+	int numFiles;
+	int filelen;
+	char filelist[4096];
+	char filename[MAX_QPATH];
+	char* fileptr;
+	int i;
+
+	bgNumSiegeClasses = 0;
+
+	numFiles = trap_FS_GetFileList("ext_data/Siege/Classes", ".scl", filelist, 4096 );
+	fileptr = filelist;
+
+	for (i = 0; i < numFiles; i++, fileptr += filelen+1)
+	{
+		filelen = strlen(fileptr);
+		strcpy(filename, "ext_data/Siege/Classes/");
+		strcat(filename, fileptr);
+
+		if (descBuffer)
+		{
+			BG_SiegeParseClassFile(filename, &descBuffer[i]);
+		}
+		else
+		{
+			BG_SiegeParseClassFile(filename, NULL);
+		}
+	}
+}
+//======================================
+//End class loading functions
+//======================================
+
+
+//======================================
+//Team loading functions
+//======================================
+siegeClass_t *BG_SiegeFindClassByName(const char *classname)
+{
+	int i = 0;
+
+	while (i < bgNumSiegeClasses)
+	{
+		if (!Q_stricmp(bgSiegeClasses[i].name, classname))
+		{ //found it
+			return &bgSiegeClasses[i];
+		}
+		i++;
+	}
+
+	return NULL;
+}
+
+void BG_SiegeParseTeamFile(const char *filename)
+{
+	fileHandle_t f;
+	int len;
+	char teamInfo[2048];
+	char parseBuf[1024];
+	char lookString[256];
+	int i = 1;
+	qboolean success = qtrue;
+
+	len = trap_FS_FOpenFile(filename, &f, FS_READ);
+
+	if (!f || len >= 2048)
+	{
+		return;
+	}
+
+	trap_FS_Read(teamInfo, len, f);
+
+	trap_FS_FCloseFile(f);
+
+	teamInfo[len] = 0;
+
+	if (BG_SiegeGetPairedValue(teamInfo, "name", parseBuf))
+	{
+		strcpy(bgSiegeTeams[bgNumSiegeTeams].name, parseBuf);
+	}
+	else
+	{
+		Com_Error(ERR_DROP, "Siege team with no name definition");
+	}
+
+//I don't entirely like doing things this way but it's the easiest way.
+#ifdef CGAME
+	if (BG_SiegeGetPairedValue(teamInfo, "FriendlyShader", parseBuf))
+	{
+		bgSiegeTeams[bgNumSiegeTeams].friendlyShader = trap_R_RegisterShaderNoMip(parseBuf);
+	}
+#else
+	bgSiegeTeams[bgNumSiegeTeams].friendlyShader = 0;
+#endif
+
+	bgSiegeTeams[bgNumSiegeTeams].numClasses = 0;
+
+	if (BG_SiegeGetValueGroup(teamInfo, "Classes", teamInfo))
+	{
+		while (success && i < MAX_SIEGE_CLASSES)
+		{ //keep checking for group values named class# up to MAX_SIEGE_CLASSES until we can't find one.
+			strcpy(lookString, va("class%i", i));
+
+			success = BG_SiegeGetPairedValue(teamInfo, lookString, parseBuf);
+
+			if (!success)
+			{
+				break;
+			}
+
+			bgSiegeTeams[bgNumSiegeTeams].classes[bgSiegeTeams[bgNumSiegeTeams].numClasses] = BG_SiegeFindClassByName(parseBuf);
+
+			if (!bgSiegeTeams[bgNumSiegeTeams].classes[bgSiegeTeams[bgNumSiegeTeams].numClasses])
+			{
+				Com_Error(ERR_DROP, "Invalid class specified: '%s'", parseBuf);
+			}
+
+			bgSiegeTeams[bgNumSiegeTeams].numClasses++;
+
+			i++;
+		}
+	}
+
+	if (!bgSiegeTeams[bgNumSiegeTeams].numClasses)
+	{
+		Com_Error(ERR_DROP, "Team defined with no allowable classes\n");
+	}
+
+	//If we get here then it was a success, so increment the team number
+	bgNumSiegeTeams++;
+}
+
+void BG_SiegeLoadTeams(void)
+{
+	int numFiles;
+	int filelen;
+	char filelist[4096];
+	char filename[MAX_QPATH];
+	char* fileptr;
+	int i;
+
+	bgNumSiegeTeams = 0;
+
+	numFiles = trap_FS_GetFileList("ext_data/Siege/Teams", ".team", filelist, 4096 );
+	fileptr = filelist;
+
+	for (i = 0; i < numFiles; i++, fileptr += filelen+1)
+	{
+		filelen = strlen(fileptr);
+		strcpy(filename, "ext_data/Siege/Teams/");
+		strcat(filename, fileptr);
+		BG_SiegeParseTeamFile(filename);
+	}
+}
+//======================================
+//End team loading functions
+//======================================
+
+
+//======================================
+//Misc/utility functions
+//======================================
+siegeTeam_t *BG_SiegeFindThemeForTeam(int team)
+{
+	if (team == SIEGETEAM_TEAM1)
+	{
+		return team1Theme;
+	}
+	else if (team == SIEGETEAM_TEAM2)
+	{
+		return team2Theme;
+	}
+
+    return NULL;
+}
+
+#ifndef UI_EXPORTS //only for game/cgame
+//precache all the sabers for the active classes for the team
+extern qboolean WP_SaberParseParms( const char *SaberName, saberInfo_t *saber ); //bg_saberLoad.cpp
+extern int BG_ModelCache(const char *modelName, const char *skinName); //bg_misc.c
+
+void BG_PrecacheSabersForSiegeTeam(int team)
+{
+	siegeTeam_t *t;
+	saberInfo_t saber;
+	char *saberName;
+	int sNum;
+
+	t = BG_SiegeFindThemeForTeam(team);
+
+	if (t)
+	{
+		int i = 0;
+
+		while (i < t->numClasses)
+		{
+			sNum = 0;
+
+			while (sNum < MAX_SABERS)
+			{
+				switch (sNum)
+				{
+				case 0:
+					saberName = &t->classes[i]->saber1[0];
+					break;
+				case 1:
+					saberName = &t->classes[i]->saber2[0];
+					break;
+				default:
+					saberName = NULL;
+					break;
+				}
+
+				if (saberName && saberName[0])
+				{
+					WP_SaberParseParms(saberName, &saber);
+					if (!Q_stricmp(saberName, saber.name))
+					{ //found the matching saber
+						if (saber.model[0])
+						{
+							BG_ModelCache(saber.model, NULL);
+						}
+					}
+				}
+
+				sNum++;
+			}
+
+			i++;
+		}
+	}
+}
+#endif
+
+qboolean BG_SiegeCheckClassLegality(int team, char *classname)
+{
+	siegeTeam_t **teamPtr = NULL;
+	int i = 0;
+
+	if (team == SIEGETEAM_TEAM1)
+	{
+		teamPtr = &team1Theme;
+	}
+	else if (team == SIEGETEAM_TEAM2)
+	{
+		teamPtr = &team2Theme;
+	}
+	else
+	{ //spectator? Whatever, you're legal then.
+		return qtrue;
+	}
+
+	if (!teamPtr || !(*teamPtr))
+	{ //Well, guess the class is ok, seeing as there is no team theme to begin with.
+		return qtrue;
+	}
+
+	//See if the class is listed on the team
+	while (i < (*teamPtr)->numClasses)
+	{
+		if (!Q_stricmp(classname, (*teamPtr)->classes[i]->name))
+		{ //found it, so it's alright
+			return qtrue;
+		}
+		i++;
+	}
+
+	//Didn't find it, so copy the name of the first valid class over it.
+	strcpy(classname, (*teamPtr)->classes[0]->name);
+
+	return qfalse;
+}
+
+siegeTeam_t *BG_SiegeFindTeamForTheme(char *themeName)
+{
+	int i = 0;
+
+	while (i < bgNumSiegeTeams)
+	{
+		if (bgSiegeTeams[i].name &&
+			!Q_stricmp(bgSiegeTeams[i].name, themeName))
+		{ //this is what we're looking for
+			return &bgSiegeTeams[i];
+		}
+
+		i++;
+	}
+
+	return NULL;
+}
+
+void BG_SiegeSetTeamTheme(int team, char *themeName)
+{
+	siegeTeam_t **teamPtr = NULL;
+
+	if (team == SIEGETEAM_TEAM1)
+	{
+		teamPtr = &team1Theme;
+	}
+	else
+	{
+		teamPtr = &team2Theme;
+	}
+
+	(*teamPtr) = BG_SiegeFindTeamForTheme(themeName);
+}
+
+int BG_SiegeFindClassIndexByName(const char *classname)
+{
+	int i = 0;
+
+	while (i < bgNumSiegeClasses)
+	{
+		if (!Q_stricmp(bgSiegeClasses[i].name, classname))
+		{ //found it
+			return i;
+		}
+		i++;
+	}
+
+	return -1;
+}
+//======================================
+//End misc/utility functions
+//======================================
+
+#include "../namespace_end.h"
diff --git a/codemp/game/bg_saga.h b/codemp/game/bg_saga.h
new file mode 100644
index 0000000..ae05781
--- /dev/null
+++ b/codemp/game/bg_saga.h
@@ -0,0 +1,115 @@
+#define		MAX_SIEGE_INFO_SIZE					16384
+
+#define		SIEGETEAM_TEAM1						1 //e.g. TEAM_RED
+#define		SIEGETEAM_TEAM2						2 //e.g. TEAM_BLUE
+
+#define		SIEGE_POINTS_OBJECTIVECOMPLETED		20
+#define		SIEGE_POINTS_FINALOBJECTIVECOMPLETED	30
+#define		SIEGE_POINTS_TEAMWONROUND			10
+
+#define		SIEGE_ROUND_BEGIN_TIME				5000 //delay 5 secs after players are in game.
+
+#define		MAX_SIEGE_CLASSES					128 //up to 128 classes
+#define		MAX_SIEGE_CLASSES_PER_TEAM			16
+
+#define		MAX_SIEGE_TEAMS						16 //up to 16 diffent teams
+
+#define		MAX_EXDATA_ENTS_TO_SEND				MAX_CLIENTS //max number of extended data for ents to send
+
+// The basic siege player classes
+typedef enum
+{
+	SPC_INFANTRY = 0,
+	SPC_VANGUARD,
+	SPC_SUPPORT,
+	SPC_JEDI,
+	SPC_DEMOLITIONIST,
+	SPC_HEAVY_WEAPONS,
+	SPC_MAX
+} siegePlayerClassFlags_t;
+
+typedef enum
+{
+	CFL_MORESABERDMG = 0,
+	CFL_STRONGAGAINSTPHYSICAL,
+	CFL_FASTFORCEREGEN,
+	CFL_STATVIEWER,
+	CFL_HEAVYMELEE,
+	CFL_SINGLE_ROCKET,//has only 1 rocket to use with rocketlauncher
+	CFL_CUSTOMSKEL, //class uses a custom skeleton, be sure to load on server etc
+	CFL_EXTRA_AMMO
+} siegeClassFlags_t;
+
+
+#ifdef _XBOX
+#define SIEGE_CLASS_DESC_LEN  512
+#else
+#define SIEGE_CLASS_DESC_LEN  4096
+#endif
+typedef struct
+{
+	char		desc[SIEGE_CLASS_DESC_LEN];
+} siegeClassDesc_t;
+
+typedef struct
+{
+	char		name[512];
+	char		forcedModel[256];
+	char		forcedSkin[256];
+	char		saber1[64];
+	char		saber2[64];
+	int			saberStance;
+	int			weapons;
+	int			forcePowerLevels[NUM_FORCE_POWERS];
+	int			classflags;
+	int			maxhealth;
+	int			starthealth;
+	int			maxarmor;
+	int			startarmor;
+	float		speed;
+	qboolean	hasForcedSaberColor;
+	int			forcedSaberColor;
+	qboolean	hasForcedSaber2Color;
+	int			forcedSaber2Color;
+	int			invenItems;
+	int			powerups;
+	int			uiPortraitShader;
+	char		uiPortrait[256];
+	int			classShader;
+	short		playerClass;		// SPC_INFANTRY . .. 
+} siegeClass_t;
+
+typedef struct
+{
+	char		name[512];
+	siegeClass_t	*classes[MAX_SIEGE_CLASSES_PER_TEAM];
+	int			numClasses;
+	int			friendlyShader;
+} siegeTeam_t;
+
+#include "../namespace_begin.h"
+
+extern siegeClass_t bgSiegeClasses[MAX_SIEGE_CLASSES];
+extern int bgNumSiegeClasses;
+
+extern siegeTeam_t bgSiegeTeams[MAX_SIEGE_TEAMS];
+extern int bgNumSiegeTeams;
+
+int BG_SiegeGetValueGroup(char *buf, char *group, char *outbuf);
+int BG_SiegeGetPairedValue(char *buf, char *key, char *outbuf);
+void BG_SiegeStripTabs(char *buf);
+
+void BG_SiegeLoadClasses(siegeClassDesc_t *descBuffer);
+void BG_SiegeLoadTeams(void);
+
+siegeTeam_t *BG_SiegeFindThemeForTeam(int team);
+void BG_PrecacheSabersForSiegeTeam(int team);
+siegeClass_t *BG_SiegeFindClassByName(const char *classname);
+qboolean BG_SiegeCheckClassLegality(int team, char *classname);
+void BG_SiegeSetTeamTheme(int team, char *themeName);
+int BG_SiegeFindClassIndexByName(const char *classname);
+
+extern char	siege_info[MAX_SIEGE_INFO_SIZE];
+extern int	siege_valid;
+
+#include "../namespace_end.h"
diff --git a/codemp/game/bg_slidemove.c b/codemp/game/bg_slidemove.c
new file mode 100644
index 0000000..ba49bdb
--- /dev/null
+++ b/codemp/game/bg_slidemove.c
@@ -0,0 +1,1071 @@
+// Copyright (C) 1999-2000 Id Software, Inc.
+//
+// bg_slidemove.c -- part of bg_pmove functionality
+
+#include "q_shared.h"
+#include "bg_public.h"
+#include "bg_local.h"
+
+#ifdef QAGAME //yeah, this is kind of bad
+#include "g_local.h"
+#endif
+
+/*
+
+input: origin, velocity, bounds, groundPlane, trace function
+
+output: origin, velocity, impacts, stairup boolean
+
+*/
+
+
+//do vehicle impact stuff
+// slight rearrangement by BTO (VV) so that we only have one namespace include
+#ifdef QAGAME
+extern void G_FlyVehicleSurfaceDestruction(gentity_t *veh, trace_t *trace, int magnitude, qboolean force ); //g_vehicle.c
+extern qboolean G_CanBeEnemy(gentity_t *self, gentity_t *enemy); //w_saber.c
+#endif
+
+extern qboolean BG_UnrestrainedPitchRoll( playerState_t *ps, Vehicle_t *pVeh );
+
+#include "../namespace_begin.h"
+
+extern bgEntity_t *pm_entSelf;
+extern bgEntity_t *pm_entVeh;
+
+//vehicle impact stuff continued...
+#ifndef QAGAME //kind of hacky
+extern void trap_FX_PlayEffectID( int id, vec3_t org, vec3_t fwd, int vol, int rad );
+#endif
+
+#ifdef QAGAME
+extern qboolean FighterIsLanded( Vehicle_t *pVeh, playerState_t *parentPS );
+#endif
+
+extern void PM_SetPMViewAngle(playerState_t *ps, vec3_t angle, usercmd_t *ucmd);
+
+#define MAX_IMPACT_TURN_ANGLE 45.0f
+void PM_VehicleImpact(bgEntity_t *pEnt, trace_t *trace)
+{
+	// See if the vehicle has crashed into the ground.
+	Vehicle_t *pSelfVeh = pEnt->m_pVehicle;
+	float magnitude = VectorLength( pm->ps->velocity ) * pSelfVeh->m_pVehicleInfo->mass / 50.0f;
+	qboolean forceSurfDestruction = qfalse;
+#ifdef QAGAME
+	gentity_t *hitEnt = trace!=NULL?&g_entities[trace->entityNum]:NULL;
+
+	if (!hitEnt || 
+		(pSelfVeh && pSelfVeh->m_pPilot &&
+		hitEnt && hitEnt->s.eType == ET_MISSILE && hitEnt->inuse &&
+		hitEnt->r.ownerNum == pSelfVeh->m_pPilot->s.number)
+		)
+	{ 
+		return;
+	}
+
+	if ( pSelfVeh//I have a vehicle struct
+		&& pSelfVeh->m_iRemovedSurfaces )//vehicle has bits removed
+	{//spiralling to our deaths, explode on any solid impact
+		if ( hitEnt->s.NPC_class == CLASS_VEHICLE )
+		{//hit another vehicle, explode!
+			//Give credit to whoever got me into this death spiral state
+			gentity_t *parent = (gentity_t *)pSelfVeh->m_pParentEntity;
+			gentity_t *killer = NULL;
+			if (parent->client->ps.otherKiller < ENTITYNUM_WORLD &&
+				parent->client->ps.otherKillerTime > level.time)
+			{
+				gentity_t *potentialKiller = &g_entities[parent->client->ps.otherKiller];
+
+				if (potentialKiller->inuse && potentialKiller->client)
+				{ //he's valid I guess
+					killer = potentialKiller;
+				}
+			}
+			//FIXME: damage hitEnt, some, too?  Our explosion should hurt them some, but...
+			G_Damage( (gentity_t *)pEnt, killer, killer, NULL, pm->ps->origin, 999999, DAMAGE_NO_ARMOR, MOD_FALLING );//FIXME: MOD_IMPACT
+			return;
+		}
+		else if ( !VectorCompare( trace->plane.normal, vec3_origin )
+			&& (trace->entityNum == ENTITYNUM_WORLD || hitEnt->r.bmodel ) )
+		{//have a valid hit plane and we hit a solid brush
+			vec3_t	moveDir;
+			float	impactDot;
+			VectorCopy( pm->ps->velocity, moveDir );
+			VectorNormalize( moveDir );
+			impactDot = DotProduct( moveDir, trace->plane.normal );
+			if ( impactDot <= -0.7f )//hit rather head-on and hard
+			{// Just DIE now
+				//Give credit to whoever got me into this death spiral state
+				gentity_t *parent = (gentity_t *)pSelfVeh->m_pParentEntity;
+				gentity_t *killer = NULL;
+				if (parent->client->ps.otherKiller < ENTITYNUM_WORLD &&
+					parent->client->ps.otherKillerTime > level.time)
+				{
+					gentity_t *potentialKiller = &g_entities[parent->client->ps.otherKiller];
+
+					if (potentialKiller->inuse && potentialKiller->client)
+					{ //he's valid I guess
+						killer = potentialKiller;
+					}
+				}
+				G_Damage( (gentity_t *)pEnt, killer, killer, NULL, pm->ps->origin, 999999, DAMAGE_NO_ARMOR, MOD_FALLING );//FIXME: MOD_IMPACT
+				return;
+			}
+		}
+	}
+	
+	if ( trace->entityNum < ENTITYNUM_WORLD
+		&& hitEnt->s.eType == ET_MOVER
+		&& hitEnt->s.apos.trType != TR_STATIONARY//rotating
+		&& (hitEnt->spawnflags&16) //IMPACT
+		&& Q_stricmp( "func_rotating", hitEnt->classname ) == 0 )
+	{//hit a func_rotating that is supposed to destroy anything it touches!
+		//guarantee the hit will happen, thereby taking off a piece of the ship
+		forceSurfDestruction = qtrue;
+	}
+	else if ( (fabs(pm->ps->velocity[0])+fabs(pm->ps->velocity[1])) < 100.0f
+		&& pm->ps->velocity[2] > -100.0f )
+#else
+	if ( (fabs(pm->ps->velocity[0])+fabs(pm->ps->velocity[1])) < 100.0f
+		&& pm->ps->velocity[2] > -100.0f )
+#endif
+		/*
+	if ( (pSelfVeh->m_ulFlags&VEH_GEARSOPEN) 
+		&& trace->plane.normal[2] > 0.7f
+		&& fabs(pSelfVeh->m_vOrientation[PITCH]) < 0.2f
+		&& fabs(pSelfVeh->m_vOrientation[ROLL]) < 0.2f )*/
+	{//we're landing, we're cool
+		//FIXME: some sort of landing "thump", not the impactFX
+		/*
+		if ( pSelfVeh->m_pVehicleInfo->iImpactFX )
+		{
+			vec3_t up = {0,0,1};
+#ifdef QAGAME
+			G_PlayEffectID( pSelfVeh->m_pVehicleInfo->iImpactFX, pm->ps->origin, up );
+#else
+			trap_FX_PlayEffectID( pSelfVeh->m_pVehicleInfo->iImpactFX, pm->ps->origin, up, -1, -1 );
+#endif
+		}
+		*/
+		//this was annoying me -rww
+		//FIXME: this shouldn't even be getting called when the vehicle is at rest!
+#ifdef QAGAME
+		if (hitEnt && (hitEnt->s.eType == ET_PLAYER || hitEnt->s.eType == ET_NPC) && pSelfVeh->m_pVehicleInfo->type == VH_FIGHTER)
+		{ //always smack players
+		}
+		else
+#endif
+		{
+			return;
+		}
+	}
+	if ( pSelfVeh &&
+		(pSelfVeh->m_pVehicleInfo->type == VH_SPEEDER || pSelfVeh->m_pVehicleInfo->type == VH_FIGHTER) && //this is kind of weird on tauntauns and atst's..
+		(magnitude >= 100||forceSurfDestruction) )
+	{
+		if ( pEnt->m_pVehicle->m_iHitDebounce < pm->cmd.serverTime 
+			|| forceSurfDestruction )
+		{//a bit of a hack, may conflict with getting shot, but...
+			//FIXME: impact sound and effect should be gotten from g_vehicleInfo...?
+			//FIXME: should pass in trace.endpos and trace.plane.normal
+			vec3_t	vehUp;
+#ifndef QAGAME
+			bgEntity_t *hitEnt;
+#endif
+
+			if ( trace && !pSelfVeh->m_iRemovedSurfaces && !forceSurfDestruction )
+			{
+				qboolean turnFromImpact = qfalse, turnHitEnt = qfalse;
+				float l = pm->ps->speed*0.5f;
+				vec3_t	bounceDir;
+#ifndef QAGAME
+				bgEntity_t *hitEnt = PM_BGEntForNum(trace->entityNum);
+#endif
+				if ( (trace->entityNum == ENTITYNUM_WORLD || hitEnt->s.solid == SOLID_BMODEL)//bounce off any brush
+					 && !VectorCompare(trace->plane.normal, vec3_origin) )//have a valid plane to bounce off of
+				{ //bounce off in the opposite direction of the impact
+					if (pSelfVeh->m_pVehicleInfo->type == VH_SPEEDER)
+					{
+						pm->ps->speed *= pml.frametime;
+						VectorCopy(trace->plane.normal, bounceDir);
+					}
+					else if ( trace->plane.normal[2] >= MIN_LANDING_SLOPE//flat enough to land on
+						&& pSelfVeh->m_LandTrace.fraction < 1.0f //ground present
+						&& pm->ps->speed <= MIN_LANDING_SPEED )
+					{//could land here, don't bounce off, in fact, return altogether!
+						return;
+					}
+					else
+					{
+						if (pSelfVeh->m_pVehicleInfo->type == VH_FIGHTER)
+						{
+							turnFromImpact = qtrue;
+						}
+						VectorCopy(trace->plane.normal, bounceDir);
+					}
+				}
+				else if ( pSelfVeh->m_pVehicleInfo->type == VH_FIGHTER )
+				{//check for impact with another fighter
+#ifndef QAGAME
+					bgEntity_t *hitEnt = PM_BGEntForNum(trace->entityNum);
+#endif
+					if ( hitEnt->s.NPC_class == CLASS_VEHICLE
+						&& hitEnt->m_pVehicle 
+						&& hitEnt->m_pVehicle->m_pVehicleInfo
+						&& hitEnt->m_pVehicle->m_pVehicleInfo->type == VH_FIGHTER )
+					{//two vehicles hit each other, turn away from the impact
+						turnFromImpact = qtrue;
+						turnHitEnt = qtrue;
+#ifndef QAGAME
+						VectorSubtract( pm->ps->origin, hitEnt->s.origin, bounceDir );
+#else
+						VectorSubtract( pm->ps->origin, hitEnt->r.currentOrigin, bounceDir );
+#endif
+						VectorNormalize( bounceDir );
+					}
+				}
+				if ( turnFromImpact )
+				{//bounce off impact surf and turn away
+					vec3_t	pushDir={0}, turnAwayAngles, turnDelta;
+					float	turnStrength, pitchTurnStrength, yawTurnStrength;
+					vec3_t	moveDir;
+					float bounceDot, turnDivider;
+					//bounce
+					if ( !turnHitEnt )
+					{//hit wall
+						VectorScale(bounceDir, (pm->ps->speed*0.25f/pSelfVeh->m_pVehicleInfo->mass), pushDir);
+					}
+					else
+					{//hit another fighter
+#ifndef QAGAME
+						VectorScale( bounceDir, (pm->ps->speed+hitEnt->s.speed)*0.5f, bounceDir );
+#else
+						if ( hitEnt->client )
+						{
+							VectorScale( bounceDir, (pm->ps->speed+hitEnt->client->ps.speed)*0.5f, pushDir );
+						}
+						else
+						{
+							VectorScale( bounceDir, (pm->ps->speed+hitEnt->s.speed)*0.5f, pushDir );
+						}
+#endif
+						VectorScale(pushDir, (l/pSelfVeh->m_pVehicleInfo->mass), pushDir);
+						VectorScale(pushDir, 0.1f, pushDir);
+					}
+					VectorNormalize2( pm->ps->velocity, moveDir );
+					bounceDot = DotProduct( moveDir, bounceDir )*-1;
+					if ( bounceDot < 0.1f )
+					{
+						bounceDot = 0.1f;
+					}
+					VectorScale( pushDir, bounceDot, pushDir );
+					VectorAdd(pm->ps->velocity, pushDir, pm->ps->velocity);
+					//turn
+					turnDivider = (pSelfVeh->m_pVehicleInfo->mass/400.0f);
+					if ( turnHitEnt )
+					{//don't turn as much when hit another ship
+						turnDivider *= 4.0f;
+					}
+					if ( turnDivider < 0.5f )
+					{
+						turnDivider = 0.5f;
+					}
+					turnStrength = (magnitude/2000.0f);
+					if ( turnStrength < 0.1f )
+					{
+						turnStrength = 0.1f;
+					}
+					else if ( turnStrength > 2.0f )
+					{
+						turnStrength = 2.0f;
+					}
+					//get the angles we are going to turn towards
+					vectoangles( bounceDir, turnAwayAngles );
+					//get the delta from our current angles to those new angles
+					AnglesSubtract( turnAwayAngles, pSelfVeh->m_vOrientation, turnDelta );
+					//now do pitch
+					if ( !bounceDir[2] )
+					{//shouldn't be any pitch
+					}
+					else
+					{
+						pitchTurnStrength = turnStrength*turnDelta[PITCH];
+						if ( pitchTurnStrength > MAX_IMPACT_TURN_ANGLE )
+						{
+							pitchTurnStrength = MAX_IMPACT_TURN_ANGLE;
+						}
+						else if ( pitchTurnStrength < -MAX_IMPACT_TURN_ANGLE )
+						{
+							pitchTurnStrength = -MAX_IMPACT_TURN_ANGLE;
+						}
+						//pSelfVeh->m_vOrientation[PITCH] = AngleNormalize180(pSelfVeh->m_vOrientation[PITCH]+pitchTurnStrength/turnDivider*pSelfVeh->m_fTimeModifier);
+						pSelfVeh->m_vFullAngleVelocity[PITCH] = AngleNormalize180(pSelfVeh->m_vOrientation[PITCH]+pitchTurnStrength/turnDivider*pSelfVeh->m_fTimeModifier);
+					}
+					//now do yaw
+					if ( !bounceDir[0] 
+						&& !bounceDir[1] )
+					{//shouldn't be any yaw
+					}
+					else
+					{
+						yawTurnStrength = turnStrength*turnDelta[YAW];
+						if ( yawTurnStrength > MAX_IMPACT_TURN_ANGLE )
+						{
+							yawTurnStrength = MAX_IMPACT_TURN_ANGLE;
+						}
+						else if ( yawTurnStrength < -MAX_IMPACT_TURN_ANGLE )
+						{
+							yawTurnStrength = -MAX_IMPACT_TURN_ANGLE;
+						}
+						//pSelfVeh->m_vOrientation[ROLL] = AngleNormalize180(pSelfVeh->m_vOrientation[ROLL]-yawTurnStrength/turnDivider*pSelfVeh->m_fTimeModifier);
+						pSelfVeh->m_vFullAngleVelocity[ROLL] = AngleNormalize180(pSelfVeh->m_vOrientation[ROLL]-yawTurnStrength/turnDivider*pSelfVeh->m_fTimeModifier);
+					}
+					/*
+					PM_SetPMViewAngle(pm->ps, pSelfVeh->m_vOrientation, &pSelfVeh->m_ucmd);
+					if ( pm_entVeh )
+					{//I'm a vehicle, so pm_entVeh is actually my pilot
+						bgEntity_t *pilot = pm_entVeh;
+						if ( !BG_UnrestrainedPitchRoll( pilot->playerState, pSelfVeh ) )
+						{
+							//set the rider's viewangles to the vehicle's viewangles
+							PM_SetPMViewAngle(pilot->playerState, pSelfVeh->m_vOrientation, &pSelfVeh->m_ucmd);
+						}
+					}
+					*/
+#ifdef QAGAME//server-side, turn the guy we hit away from us, too
+					if ( turnHitEnt//make the other guy turn and get pushed
+						&& hitEnt->client //must be a valid client
+						&& !FighterIsLanded( hitEnt->m_pVehicle, &hitEnt->client->ps )//but not if landed
+						&& !(hitEnt->spawnflags&2) )//and not if suspended
+					{
+						l = hitEnt->client->ps.speed;
+						//now bounce *them* away and turn them
+						//flip the bounceDir
+						VectorScale( bounceDir, -1, bounceDir );
+						//do bounce
+						VectorScale( bounceDir, (pm->ps->speed+l)*0.5f, pushDir );
+						VectorScale(pushDir, (l*0.5f/hitEnt->m_pVehicle->m_pVehicleInfo->mass), pushDir);
+						VectorNormalize2( hitEnt->client->ps.velocity, moveDir );
+						bounceDot = DotProduct( moveDir, bounceDir )*-1;
+						if ( bounceDot < 0.1f )
+						{
+							bounceDot = 0.1f;
+						}
+						VectorScale( pushDir, bounceDot, pushDir );
+						VectorAdd(hitEnt->client->ps.velocity, pushDir, hitEnt->client->ps.velocity);
+						//turn
+						turnDivider = (hitEnt->m_pVehicle->m_pVehicleInfo->mass/400.0f);
+						if ( turnHitEnt )
+						{//don't turn as much when hit another ship
+							turnDivider *= 4.0f;
+						}
+						if ( turnDivider < 0.5f )
+						{
+							turnDivider = 0.5f;
+						}
+						//get the angles we are going to turn towards
+						vectoangles( bounceDir, turnAwayAngles );
+						//get the delta from our current angles to those new angles
+						AnglesSubtract( turnAwayAngles, hitEnt->m_pVehicle->m_vOrientation, turnDelta );
+						//now do pitch
+						if ( !bounceDir[2] )
+						{//shouldn't be any pitch
+						}
+						else
+						{
+							pitchTurnStrength = turnStrength*turnDelta[PITCH];
+							if ( pitchTurnStrength > MAX_IMPACT_TURN_ANGLE )
+							{
+								pitchTurnStrength = MAX_IMPACT_TURN_ANGLE;
+							}
+							else if ( pitchTurnStrength < -MAX_IMPACT_TURN_ANGLE )
+							{
+								pitchTurnStrength = -MAX_IMPACT_TURN_ANGLE;
+							}
+							//hitEnt->m_pVehicle->m_vOrientation[PITCH] = AngleNormalize180(hitEnt->m_pVehicle->m_vOrientation[PITCH]+pitchTurnStrength/turnDivider*pSelfVeh->m_fTimeModifier);
+							hitEnt->m_pVehicle->m_vFullAngleVelocity[PITCH] = AngleNormalize180(hitEnt->m_pVehicle->m_vOrientation[PITCH]+pitchTurnStrength/turnDivider*pSelfVeh->m_fTimeModifier);
+						}
+						//now do yaw
+						if ( !bounceDir[0] 
+							&& !bounceDir[1] )
+						{//shouldn't be any yaw
+						}
+						else
+						{
+							yawTurnStrength = turnStrength*turnDelta[YAW];
+							if ( yawTurnStrength > MAX_IMPACT_TURN_ANGLE )
+							{
+								yawTurnStrength = MAX_IMPACT_TURN_ANGLE;
+							}
+							else if ( yawTurnStrength < -MAX_IMPACT_TURN_ANGLE )
+							{
+								yawTurnStrength = -MAX_IMPACT_TURN_ANGLE;
+							}
+							//hitEnt->m_pVehicle->m_vOrientation[ROLL] = AngleNormalize180(hitEnt->m_pVehicle->m_vOrientation[ROLL]-yawTurnStrength/turnDivider*pSelfVeh->m_fTimeModifier);
+							hitEnt->m_pVehicle->m_vFullAngleVelocity[ROLL] = AngleNormalize180(hitEnt->m_pVehicle->m_vOrientation[ROLL]-yawTurnStrength/turnDivider*pSelfVeh->m_fTimeModifier);
+						}
+						//NOTE: will these angle changes stick or will they be stomped 
+						//		when the vehicle goes through its own update and re-grabs 
+						//		its angles from its pilot...?  Should we do a 
+						//		SetClientViewAngles on the pilot?
+						/*
+						SetClientViewAngle( hitEnt, hitEnt->m_pVehicle->m_vOrientation );
+						if ( hitEnt->m_pVehicle->m_pPilot 
+							&& ((gentity_t *)hitEnt->m_pVehicle->m_pPilot)->client )
+						{
+							SetClientViewAngle( (gentity_t *)hitEnt->m_pVehicle->m_pPilot, hitEnt->m_pVehicle->m_vOrientation );
+						}
+						*/
+					}
+#endif
+				}
+			}
+
+#ifdef QAGAME
+			if (!hitEnt)
+			{
+				return;
+			}
+
+			AngleVectors( pSelfVeh->m_vOrientation, NULL, NULL, vehUp );
+			if ( pSelfVeh->m_pVehicleInfo->iImpactFX )
+			{
+				//G_PlayEffectID( pSelfVeh->m_pVehicleInfo->iImpactFX, pm->ps->origin, vehUp );
+				//tempent use bad!
+				G_AddEvent((gentity_t *)pEnt, EV_PLAY_EFFECT_ID, pSelfVeh->m_pVehicleInfo->iImpactFX);
+			}
+			pEnt->m_pVehicle->m_iHitDebounce = pm->cmd.serverTime + 200;
+			magnitude /= pSelfVeh->m_pVehicleInfo->toughness * 50.0f; 
+
+			if (hitEnt && (hitEnt->s.eType != ET_TERRAIN || !(hitEnt->spawnflags & 1) || pSelfVeh->m_pVehicleInfo->type == VH_FIGHTER))
+			{ //don't damage the vehicle from terrain that doesn't want to damage vehicles
+				if (pSelfVeh->m_pVehicleInfo->type == VH_FIGHTER)
+				{ //increase the damage...
+					float mult = (pSelfVeh->m_vOrientation[PITCH]*0.1f);
+					if (mult < 1.0f)
+					{
+						mult = 1.0f;
+					}
+					if (hitEnt->inuse && hitEnt->takedamage)
+					{ //if the other guy takes damage, don't hurt us a lot for ramming him
+						//unless it's a vehicle, then we get 1.5 times damage
+						if (hitEnt->s.eType == ET_NPC &&
+							hitEnt->s.NPC_class == CLASS_VEHICLE &&
+							hitEnt->m_pVehicle)
+						{
+							mult = 1.5f;
+						}
+						else
+						{
+							mult = 0.5f;
+						}
+					}
+
+					magnitude *= mult;
+				}
+				pSelfVeh->m_iLastImpactDmg = magnitude;
+				//FIXME: what about proper death credit to the guy who shot you down?
+				//FIXME: actually damage part of the ship that impacted?
+				G_Damage( (gentity_t *)pEnt, NULL, NULL, NULL, pm->ps->origin, magnitude*5, DAMAGE_NO_ARMOR, MOD_FALLING );//FIXME: MOD_IMPACT
+
+				if (pSelfVeh->m_pVehicleInfo->surfDestruction)
+				{
+					G_FlyVehicleSurfaceDestruction((gentity_t *)pEnt, trace, magnitude, forceSurfDestruction );
+				}
+
+				pSelfVeh->m_ulFlags |= VEH_CRASHING;
+			}
+
+			if (hitEnt &&
+				hitEnt->inuse &&
+				hitEnt->takedamage)
+			{ //damage this guy because we hit him
+				float pmult = 1.0f;
+				int finalD;
+				gentity_t *attackEnt;
+
+				if ( (hitEnt->s.eType == ET_PLAYER && hitEnt->s.number < MAX_CLIENTS) ||
+					 (hitEnt->s.eType == ET_NPC && hitEnt->s.NPC_class != CLASS_VEHICLE) )
+				{ //probably a humanoid, or something
+					if (pSelfVeh->m_pVehicleInfo->type == VH_FIGHTER)
+					{ //player die good.. if me fighter
+						pmult = 2000.0f;
+					}
+					else
+					{
+						pmult = 40.0f;
+					}
+
+					if (hitEnt->client &&
+						BG_KnockDownable(&hitEnt->client->ps) &&
+						G_CanBeEnemy((gentity_t *)pEnt, hitEnt))
+					{ //smash!
+						if (hitEnt->client->ps.forceHandExtend != HANDEXTEND_KNOCKDOWN)
+						{
+							hitEnt->client->ps.forceHandExtend = HANDEXTEND_KNOCKDOWN;
+							hitEnt->client->ps.forceHandExtendTime = pm->cmd.serverTime + 1100;
+							hitEnt->client->ps.forceDodgeAnim = 0; //this toggles between 1 and 0, when it's 1 we should play the get up anim
+						}
+
+						hitEnt->client->ps.otherKiller = pEnt->s.number;
+						hitEnt->client->ps.otherKillerTime = pm->cmd.serverTime + 5000;
+						hitEnt->client->ps.otherKillerDebounceTime = pm->cmd.serverTime + 100;
+
+						//add my velocity into his to force him along in the correct direction from impact
+						VectorAdd(hitEnt->client->ps.velocity, pm->ps->velocity, hitEnt->client->ps.velocity);
+						//upward thrust
+						hitEnt->client->ps.velocity[2] += 200.0f;
+					}
+				}
+
+				if (pSelfVeh->m_pPilot)
+				{
+					attackEnt = (gentity_t *)pSelfVeh->m_pPilot;
+				}
+				else
+				{
+					attackEnt = (gentity_t *)pEnt;
+				}
+
+				finalD = magnitude*pmult;
+				if (finalD < 1)
+				{
+					finalD = 1;
+				}
+				G_Damage( hitEnt, attackEnt, attackEnt, NULL, pm->ps->origin, finalD, 0, MOD_MELEE );//FIXME: MOD_IMPACT
+			}
+#else	//this is gonna result in "double effects" for the client doing the prediction.
+		//it doesn't look bad though. could just use predicted events, but I'm too lazy.
+			hitEnt = PM_BGEntForNum(trace->entityNum);
+
+			if (!hitEnt || hitEnt->s.owner != pEnt->s.number)
+			{ //don't hit your own missiles!
+				AngleVectors( pSelfVeh->m_vOrientation, NULL, NULL, vehUp );
+				pEnt->m_pVehicle->m_iHitDebounce = pm->cmd.serverTime + 200;
+				trap_FX_PlayEffectID( pSelfVeh->m_pVehicleInfo->iImpactFX, pm->ps->origin, vehUp, -1, -1 );
+
+				pSelfVeh->m_ulFlags |= VEH_CRASHING;
+			}
+#endif
+		}
+	}
+}
+
+qboolean PM_GroundSlideOkay( float zNormal )
+{
+	if ( zNormal > 0 )
+	{
+		if ( pm->ps->velocity[2] > 0 )
+		{
+			if ( pm->ps->legsAnim == BOTH_WALL_RUN_RIGHT
+				|| pm->ps->legsAnim == BOTH_WALL_RUN_LEFT 
+				|| pm->ps->legsAnim == BOTH_WALL_RUN_RIGHT_STOP
+				|| pm->ps->legsAnim == BOTH_WALL_RUN_LEFT_STOP 
+				|| pm->ps->legsAnim == BOTH_FORCEWALLRUNFLIP_START 
+				|| pm->ps->legsAnim == BOTH_FORCELONGLEAP_START
+				|| pm->ps->legsAnim == BOTH_FORCELONGLEAP_ATTACK
+				|| pm->ps->legsAnim == BOTH_FORCELONGLEAP_LAND
+				|| BG_InReboundJump( pm->ps->legsAnim ))
+			{
+				return qfalse;
+			}
+		}
+	}
+	return qtrue;
+}
+
+/*
+===============
+qboolean PM_ClientImpact( trace_t *trace, qboolean damageSelf )
+
+===============
+*/
+#ifdef QAGAME
+extern void Client_CheckImpactBBrush( gentity_t *self, gentity_t *other );
+qboolean PM_ClientImpact( trace_t *trace )
+{
+	//don't try to predict this
+	gentity_t	*traceEnt;
+	int			otherEntityNum = trace->entityNum;
+
+	if ( !pm_entSelf )
+	{
+		return qfalse;
+	}
+
+	if ( otherEntityNum >= ENTITYNUM_WORLD )
+	{
+		return qfalse;
+	}
+
+	traceEnt = &g_entities[otherEntityNum];
+
+	if( VectorLength( pm->ps->velocity ) >= 100 
+		&& pm_entSelf->s.NPC_class != CLASS_VEHICLE
+		&& pm->ps->lastOnGround+100 < level.time )
+		//&& pm->ps->groundEntityNum == ENTITYNUM_NONE )
+	{
+		Client_CheckImpactBBrush( (gentity_t *)(pm_entSelf), &g_entities[otherEntityNum] );
+	}
+
+	if ( !traceEnt 
+		|| !(traceEnt->r.contents&pm->tracemask) )
+	{//it's dead or not in my way anymore, don't clip against it
+		return qtrue;
+	}
+
+	return qfalse;
+}
+#endif
+
+/*
+==================
+PM_SlideMove
+
+Returns qtrue if the velocity was clipped in some way
+==================
+*/
+#define	MAX_CLIP_PLANES	5
+qboolean	PM_SlideMove( qboolean gravity ) {
+	int			bumpcount, numbumps;
+	vec3_t		dir;
+	float		d;
+	int			numplanes;
+	vec3_t		normal, planes[MAX_CLIP_PLANES];
+	vec3_t		primal_velocity;
+	vec3_t		clipVelocity;
+	int			i, j, k;
+	trace_t	trace;
+	vec3_t		end;
+	float		time_left;
+	float		into;
+	vec3_t		endVelocity;
+	vec3_t		endClipVelocity;
+	//qboolean	damageSelf = qtrue;
+	
+	numbumps = 4;
+
+	VectorCopy (pm->ps->velocity, primal_velocity);
+
+	if ( gravity ) {
+		VectorCopy( pm->ps->velocity, endVelocity );
+		endVelocity[2] -= pm->ps->gravity * pml.frametime;
+		pm->ps->velocity[2] = ( pm->ps->velocity[2] + endVelocity[2] ) * 0.5;
+		primal_velocity[2] = endVelocity[2];
+		if ( pml.groundPlane ) {
+			if ( PM_GroundSlideOkay( pml.groundTrace.plane.normal[2] ) )
+			{// slide along the ground plane
+				PM_ClipVelocity (pm->ps->velocity, pml.groundTrace.plane.normal, 
+					pm->ps->velocity, OVERCLIP );
+			}
+		}
+	}
+
+	time_left = pml.frametime;
+
+	// never turn against the ground plane
+	if ( pml.groundPlane ) {
+		numplanes = 1;
+		VectorCopy( pml.groundTrace.plane.normal, planes[0] );
+		if ( !PM_GroundSlideOkay( planes[0][2] ) )
+		{
+			planes[0][2] = 0;
+			VectorNormalize( planes[0] );
+		}
+	} else {
+		numplanes = 0;
+	}
+
+	// never turn against original velocity
+	VectorNormalize2( pm->ps->velocity, planes[numplanes] );
+	numplanes++;
+
+	for ( bumpcount=0 ; bumpcount < numbumps ; bumpcount++ ) {
+
+		// calculate position we are trying to move to
+		VectorMA( pm->ps->origin, time_left, pm->ps->velocity, end );
+
+		// see if we can make it there
+		pm->trace ( &trace, pm->ps->origin, pm->mins, pm->maxs, end, pm->ps->clientNum, pm->tracemask);
+
+		if (trace.allsolid) {
+			// entity is completely trapped in another solid
+			pm->ps->velocity[2] = 0;	// don't build up falling damage, but allow sideways acceleration
+			return qtrue;
+		}
+
+		if (trace.fraction > 0) {
+			// actually covered some distance
+			VectorCopy (trace.endpos, pm->ps->origin);
+		}
+
+		if (trace.fraction == 1) {
+			 break;		// moved the entire distance
+		}
+
+		// save entity for contact
+		PM_AddTouchEnt( trace.entityNum );
+
+		if (pm->ps->clientNum >= MAX_CLIENTS)
+		{
+			bgEntity_t *pEnt = pm_entSelf;
+
+			if (pEnt && pEnt->s.eType == ET_NPC && pEnt->s.NPC_class == CLASS_VEHICLE &&
+				pEnt->m_pVehicle)
+			{ //do vehicle impact stuff then
+				PM_VehicleImpact(pEnt, &trace);
+			}
+		}
+#ifdef QAGAME
+		else
+		{
+			if ( PM_ClientImpact( &trace ) )
+			{
+				continue;
+			}
+		}
+#endif
+
+		time_left -= time_left * trace.fraction;
+
+		if (numplanes >= MAX_CLIP_PLANES) {
+			// this shouldn't really happen
+			VectorClear( pm->ps->velocity );
+			return qtrue;
+		}
+
+		VectorCopy( trace.plane.normal, normal );
+
+		if ( !PM_GroundSlideOkay( normal[2] ) )
+		{//wall-running
+			//never push up off a sloped wall
+			normal[2] = 0;
+			VectorNormalize( normal );
+		}
+		//
+		// if this is the same plane we hit before, nudge velocity
+		// out along it, which fixes some epsilon issues with
+		// non-axial planes
+		//
+		if ( !(pm->ps->pm_flags&PMF_STUCK_TO_WALL) )
+		{//no sliding if stuck to wall!
+			for ( i = 0 ; i < numplanes ; i++ ) {
+				if ( VectorCompare( normal, planes[i] ) ) {//DotProduct( normal, planes[i] ) > 0.99 ) {
+					VectorAdd( normal, pm->ps->velocity, pm->ps->velocity );
+					break;
+				}
+			}
+			if ( i < numplanes ) {
+				continue;
+			}
+		}
+		VectorCopy (normal, planes[numplanes]);
+		numplanes++;
+
+		//
+		// modify velocity so it parallels all of the clip planes
+		//
+
+		// find a plane that it enters
+		for ( i = 0 ; i < numplanes ; i++ ) {
+			into = DotProduct( pm->ps->velocity, planes[i] );
+			if ( into >= 0.1 ) {
+				continue;		// move doesn't interact with the plane
+			}
+
+			// see how hard we are hitting things
+			if ( -into > pml.impactSpeed ) {
+				pml.impactSpeed = -into;
+			}
+
+			// slide along the plane
+			PM_ClipVelocity (pm->ps->velocity, planes[i], clipVelocity, OVERCLIP );
+
+			// slide along the plane
+			PM_ClipVelocity (endVelocity, planes[i], endClipVelocity, OVERCLIP );
+
+			// see if there is a second plane that the new move enters
+			for ( j = 0 ; j < numplanes ; j++ ) {
+				if ( j == i ) {
+					continue;
+				}
+				if ( DotProduct( clipVelocity, planes[j] ) >= 0.1 ) {
+					continue;		// move doesn't interact with the plane
+				}
+
+				// try clipping the move to the plane
+				PM_ClipVelocity( clipVelocity, planes[j], clipVelocity, OVERCLIP );
+				PM_ClipVelocity( endClipVelocity, planes[j], endClipVelocity, OVERCLIP );
+
+				// see if it goes back into the first clip plane
+				if ( DotProduct( clipVelocity, planes[i] ) >= 0 ) {
+					continue;
+				}
+
+				// slide the original velocity along the crease
+				CrossProduct (planes[i], planes[j], dir);
+				VectorNormalize( dir );
+				d = DotProduct( dir, pm->ps->velocity );
+				VectorScale( dir, d, clipVelocity );
+
+				CrossProduct (planes[i], planes[j], dir);
+				VectorNormalize( dir );
+				d = DotProduct( dir, endVelocity );
+				VectorScale( dir, d, endClipVelocity );
+
+				// see if there is a third plane the the new move enters
+				for ( k = 0 ; k < numplanes ; k++ ) {
+					if ( k == i || k == j ) {
+						continue;
+					}
+					if ( DotProduct( clipVelocity, planes[k] ) >= 0.1 ) {
+						continue;		// move doesn't interact with the plane
+					}
+
+					// stop dead at a triple plane interaction
+					VectorClear( pm->ps->velocity );
+					return qtrue;
+				}
+			}
+
+			// if we have fixed all interactions, try another move
+			VectorCopy( clipVelocity, pm->ps->velocity );
+			VectorCopy( endClipVelocity, endVelocity );
+			break;
+		}
+	}
+
+	if ( gravity ) {
+		VectorCopy( endVelocity, pm->ps->velocity );
+	}
+
+	// don't change velocity if in a timer (FIXME: is this correct?)
+	if ( pm->ps->pm_time ) {
+		VectorCopy( primal_velocity, pm->ps->velocity );
+	}
+
+	return ( bumpcount != 0 );
+}
+
+/*
+==================
+PM_StepSlideMove
+
+==================
+*/
+void PM_StepSlideMove( qboolean gravity ) { 
+	vec3_t		start_o, start_v;
+	vec3_t		down_o, down_v;
+	trace_t		trace;
+//	float		down_dist, up_dist;
+//	vec3_t		delta, delta2;
+	vec3_t		up, down;
+	float		stepSize;
+	qboolean	isGiant = qfalse;
+	bgEntity_t	*pEnt;
+	qboolean skipStep = qfalse;
+
+	VectorCopy (pm->ps->origin, start_o);
+	VectorCopy (pm->ps->velocity, start_v);
+
+	if ( BG_InReboundHold( pm->ps->legsAnim ) )
+	{
+		gravity = qfalse;
+	}
+
+	if ( PM_SlideMove( gravity ) == 0 ) {
+		return;		// we got exactly where we wanted to go first try	
+	}
+
+	pEnt = pm_entSelf;
+
+	if (pm->ps->clientNum >= MAX_CLIENTS)
+	{
+		if (pEnt && pEnt->s.NPC_class == CLASS_VEHICLE &&
+			pEnt->m_pVehicle && pEnt->m_pVehicle->m_pVehicleInfo->hoverHeight > 0)
+		{
+			return;
+		}
+	}
+
+	VectorCopy(start_o, down);
+	down[2] -= STEPSIZE;
+	pm->trace (&trace, start_o, pm->mins, pm->maxs, down, pm->ps->clientNum, pm->tracemask);
+	VectorSet(up, 0, 0, 1);
+	// never step up when you still have up velocity
+	if ( pm->ps->velocity[2] > 0 && (trace.fraction == 1.0 ||
+										DotProduct(trace.plane.normal, up) < 0.7))
+	{
+		return;
+	}
+
+	VectorCopy (pm->ps->origin, down_o);
+	VectorCopy (pm->ps->velocity, down_v);
+
+	VectorCopy (start_o, up);
+
+	if (pm->ps->clientNum >= MAX_CLIENTS)
+	{
+		// apply ground friction, even if on ladder
+		if (pEnt &&
+			pEnt->s.NPC_class == CLASS_ATST ||
+				(pEnt->s.NPC_class == CLASS_VEHICLE &&
+					pEnt->m_pVehicle &&
+					pEnt->m_pVehicle->m_pVehicleInfo->type == VH_WALKER)
+			)
+		{//AT-STs can step high
+			up[2] += 66.0f;
+			isGiant = qtrue;
+		}
+		else if ( pEnt && pEnt->s.NPC_class == CLASS_RANCOR )
+		{//also can step up high
+			up[2] += 64.0f;
+			isGiant = qtrue;
+		}
+		else
+		{
+			up[2] += STEPSIZE;
+		}
+	}
+	else
+	{
+		up[2] += STEPSIZE;
+	}
+
+	// test the player position if they were a stepheight higher
+	pm->trace (&trace, start_o, pm->mins, pm->maxs, up, pm->ps->clientNum, pm->tracemask);
+	if ( trace.allsolid ) {
+		if ( pm->debugLevel ) {
+			Com_Printf("%i:bend can't step\n", c_pmove);
+		}
+		return;		// can't step up
+	}
+
+	stepSize = trace.endpos[2] - start_o[2];
+	// try slidemove from this position
+	VectorCopy (trace.endpos, pm->ps->origin);
+	VectorCopy (start_v, pm->ps->velocity);
+
+	PM_SlideMove( gravity );
+
+	// push down the final amount
+	VectorCopy (pm->ps->origin, down);
+	down[2] -= stepSize;
+	pm->trace (&trace, pm->ps->origin, pm->mins, pm->maxs, down, pm->ps->clientNum, pm->tracemask);
+
+	if ( pm->stepSlideFix )
+	{
+		if ( pm->ps->clientNum < MAX_CLIENTS
+			&& trace.plane.normal[2] < MIN_WALK_NORMAL )
+		{//normal players cannot step up slopes that are too steep to walk on!
+			vec3_t stepVec;
+			//okay, the step up ends on a slope that it too steep to step up onto,
+			//BUT:
+			//If the step looks like this:
+			//  (B)\__
+			//        \_____(A)
+			//Then it might still be okay, so we figure out the slope of the entire move
+			//from (A) to (B) and if that slope is walk-upabble, then it's okay
+			VectorSubtract( trace.endpos, down_o, stepVec );
+			VectorNormalize( stepVec ); 
+			if ( stepVec[2] > (1.0f-MIN_WALK_NORMAL) )
+			{
+				skipStep = qtrue;
+			}
+		}
+	}
+
+	if ( !trace.allsolid 
+		&& !skipStep ) //normal players cannot step up slopes that are too steep to walk on!
+	{ 
+		if ( pm->ps->clientNum >= MAX_CLIENTS//NPC
+			&& isGiant 
+			&& trace.entityNum < MAX_CLIENTS
+			&& pEnt 
+			&& pEnt->s.NPC_class == CLASS_RANCOR )
+		{//Rancor don't step on clients
+			if ( pm->stepSlideFix )
+			{
+				VectorCopy (down_o, pm->ps->origin);
+				VectorCopy (down_v, pm->ps->velocity);
+			}
+			else
+			{
+				VectorCopy (start_o, pm->ps->origin);
+				VectorCopy (start_v, pm->ps->velocity);
+			}
+		}
+		/*
+		else if ( pm->ps->clientNum >= MAX_CLIENTS//NPC
+			&& isGiant 
+			&& trace.entityNum < MAX_CLIENTS
+			&& pEnt 
+			&& pEnt->s.NPC_class == CLASS_ATST 
+			&& OnSameTeam( pEnt, traceEnt) )
+		{//NPC AT-ST's don't step up on allies
+			VectorCopy (start_o, pm->ps->origin);
+			VectorCopy (start_v, pm->ps->velocity);
+		}
+		*/
+		else
+		{
+			VectorCopy (trace.endpos, pm->ps->origin);
+			if ( pm->stepSlideFix )
+			{
+				if ( trace.fraction < 1.0 ) {
+					PM_ClipVelocity( pm->ps->velocity, trace.plane.normal, pm->ps->velocity, OVERCLIP );
+				}
+			}
+		}
+	}
+	else
+	{
+		if ( pm->stepSlideFix )
+		{
+			VectorCopy (down_o, pm->ps->origin);
+			VectorCopy (down_v, pm->ps->velocity);
+		}
+	}
+	if ( !pm->stepSlideFix )
+	{
+		if ( trace.fraction < 1.0 ) {
+			PM_ClipVelocity( pm->ps->velocity, trace.plane.normal, pm->ps->velocity, OVERCLIP );
+		}
+	}
+
+#if 0
+	// if the down trace can trace back to the original position directly, don't step
+	pm->trace( &trace, pm->ps->origin, pm->mins, pm->maxs, start_o, pm->ps->clientNum, pm->tracemask);
+	if ( trace.fraction == 1.0 ) {
+		// use the original move
+		VectorCopy (down_o, pm->ps->origin);
+		VectorCopy (down_v, pm->ps->velocity);
+		if ( pm->debugLevel ) {
+			Com_Printf("%i:bend\n", c_pmove);
+		}
+	} else 
+#endif
+	{
+		// use the step move
+		float	delta;
+
+		delta = pm->ps->origin[2] - start_o[2];
+		if ( delta > 2 ) {
+			if ( delta < 7 ) {
+				PM_AddEvent( EV_STEP_4 );
+			} else if ( delta < 11 ) {
+				PM_AddEvent( EV_STEP_8 );
+			} else if ( delta < 15 ) {
+				PM_AddEvent( EV_STEP_12 );
+			} else {
+				PM_AddEvent( EV_STEP_16 );
+			}
+		}
+		if ( pm->debugLevel ) {
+			Com_Printf("%i:stepped\n", c_pmove);
+		}
+	}
+}
+
+#include "../namespace_end.h"
+
diff --git a/codemp/game/bg_strap.h b/codemp/game/bg_strap.h
new file mode 100644
index 0000000..893ece7
--- /dev/null
+++ b/codemp/game/bg_strap.h
@@ -0,0 +1,38 @@
+//rww - shared trap call system
+#include "q_shared.h"
+#include "bg_public.h"
+
+#include "../namespace_begin.h"
+
+qboolean strap_G2API_GetBoltMatrix(void *ghoul2, const int modelIndex, const int boltIndex, mdxaBone_t *matrix,
+								const vec3_t angles, const vec3_t position, const int frameNum, qhandle_t *modelList, vec3_t scale);
+
+qboolean strap_G2API_GetBoltMatrix_NoReconstruct(void *ghoul2, const int modelIndex, const int boltIndex, mdxaBone_t *matrix,
+								const vec3_t angles, const vec3_t position, const int frameNum, qhandle_t *modelList, vec3_t scale);
+
+qboolean strap_G2API_GetBoltMatrix_NoRecNoRot(void *ghoul2, const int modelIndex, const int boltIndex, mdxaBone_t *matrix,
+								const vec3_t angles, const vec3_t position, const int frameNum, qhandle_t *modelList, vec3_t scale);
+
+qboolean strap_G2API_SetBoneAngles(void *ghoul2, int modelIndex, const char *boneName, const vec3_t angles, const int flags,
+								const int up, const int right, const int forward, qhandle_t *modelList,
+								int blendTime , int currentTime );
+
+qboolean strap_G2API_SetBoneAnim(void *ghoul2, const int modelIndex, const char *boneName, const int startFrame, const int endFrame,
+							  const int flags, const float animSpeed, const int currentTime, const float setFrame , const int blendTime );
+
+qboolean strap_G2API_GetBoneAnim(void *ghoul2, const char *boneName, const int currentTime, float *currentFrame,
+						   int *startFrame, int *endFrame, int *flags, float *animSpeed, int *modelList, const int modelIndex);
+
+void strap_G2API_SetRagDoll(void *ghoul2, sharedRagDollParams_t *params);
+
+void strap_G2API_AnimateG2Models(void *ghoul2, int time, sharedRagDollUpdateParams_t *params);
+
+qboolean strap_G2API_SetBoneIKState(void *ghoul2, int time, const char *boneName, int ikState, sharedSetBoneIKStateParams_t *params);
+
+qboolean strap_G2API_IKMove(void *ghoul2, int time, sharedIKMoveParams_t *params);
+
+void strap_TrueMalloc(void **ptr, int size);
+
+void strap_TrueFree(void **ptr);
+
+#include "../namespace_end.h"
diff --git a/codemp/game/bg_vehicleLoad.c b/codemp/game/bg_vehicleLoad.c
new file mode 100644
index 0000000..865da19
--- /dev/null
+++ b/codemp/game/bg_vehicleLoad.c
@@ -0,0 +1,1668 @@
+//bg_vehicleLoad.c
+
+#ifdef _JK2 //SP does not have this preprocessor for game like MP does
+#ifndef _JK2MP
+#define _JK2MP
+#endif
+#endif
+
+#ifdef _JK2MP
+	#include "q_shared.h"
+	#include "bg_public.h"
+	#include "bg_vehicles.h"
+	#include "bg_weapons.h"
+
+	//Could use strap stuff but I don't particularly care at the moment anyway.
+#include "../namespace_begin.h"
+	extern int	trap_FS_FOpenFile( const char *qpath, fileHandle_t *f, fsMode_t mode );
+	extern void	trap_FS_Read( void *buffer, int len, fileHandle_t f );
+	extern void	trap_FS_Write( const void *buffer, int len, fileHandle_t f );
+	extern void	trap_FS_FCloseFile( fileHandle_t f );
+	extern int	trap_FS_GetFileList(  const char *path, const char *extension, char *listbuf, int bufsize );
+#include "../namespace_end.h"
+#else
+	#include "g_local.h"
+	#define QAGAME
+#endif
+
+
+#ifdef _JK2MP
+#ifndef QAGAME
+#ifndef CGAME
+#define WE_ARE_IN_THE_UI
+#include "../ui/ui_local.h"
+#endif
+#endif
+#endif
+
+#ifndef _JK2MP
+#include "..\Ratl\string_vs.h"
+#endif
+
+#ifdef QAGAME
+extern void G_SetSharedVehicleFunctions( vehicleInfo_t *pVehInfo );
+extern int G_ModelIndex( const char *name );
+extern int G_SoundIndex( const char *name );
+	#ifdef _JK2MP
+		extern int G_EffectIndex( const char *name );
+	#endif
+#elif CGAME
+#include "../namespace_begin.h"
+extern qhandle_t	trap_R_RegisterModel( const char *name );			// returns rgb axis if not found
+extern qhandle_t	trap_R_RegisterSkin( const char *name );			// returns all white if not found
+extern qhandle_t	trap_R_RegisterShader( const char *name );
+extern qhandle_t	trap_R_RegisterShaderNoMip( const char *name );
+extern int			trap_FX_RegisterEffect(const char *file);
+extern sfxHandle_t	trap_S_RegisterSound( const char *sample);		// returns buzz if not found
+#include "../namespace_end.h"
+#else//UI
+#include "../namespace_begin.h"
+extern qhandle_t	trap_R_RegisterModel( const char *name );			// returns rgb axis if not found
+extern qhandle_t	trap_R_RegisterSkin( const char *name );			// returns all white if not found
+extern qhandle_t	trap_R_RegisterShader( const char *name );			// returns all white if not found
+extern qhandle_t	trap_R_RegisterShaderNoMip( const char *name );			// returns all white if not found
+extern sfxHandle_t	trap_S_RegisterSound( const char *sample);		// returns buzz if not found
+#include "../namespace_end.h"
+#endif
+
+extern stringID_table_t animTable [MAX_ANIMATIONS+1];
+
+// These buffers are filled in with the same contents and then just read from in
+// a few places. We only need one copy on Xbox.
+#define MAX_VEH_WEAPON_DATA_SIZE 0x4000
+#define MAX_VEHICLE_DATA_SIZE 0x10000
+
+#if !defined(_XBOX) || defined(QAGAME)
+	char	VehWeaponParms[MAX_VEH_WEAPON_DATA_SIZE];
+	char	VehicleParms[MAX_VEHICLE_DATA_SIZE];
+
+void BG_ClearVehicleParseParms(void)
+{
+	//You can't strcat to these forever without clearing them!
+	VehWeaponParms[0] = 0;
+	VehicleParms[0] = 0;
+}
+
+#else
+	extern char VehWeaponParms[MAX_VEH_WEAPON_DATA_SIZE];
+	extern char VehicleParms[MAX_VEHICLE_DATA_SIZE];
+#endif
+
+#ifdef _JK2MP
+#include "../namespace_begin.h"
+#endif
+
+#ifndef WE_ARE_IN_THE_UI
+//These funcs are actually shared in both projects
+extern void G_SetAnimalVehicleFunctions( vehicleInfo_t *pVehInfo );
+extern void G_SetSpeederVehicleFunctions( vehicleInfo_t *pVehInfo );
+extern void G_SetWalkerVehicleFunctions( vehicleInfo_t *pVehInfo );
+extern void G_SetFighterVehicleFunctions( vehicleInfo_t *pVehInfo );
+#endif
+
+vehWeaponInfo_t g_vehWeaponInfo[MAX_VEH_WEAPONS];
+int		numVehicleWeapons = 1;//first one is null/default
+
+vehicleInfo_t g_vehicleInfo[MAX_VEHICLES];
+int		numVehicles = 0;//first one is null/default
+
+void BG_VehicleLoadParms( void );
+
+typedef enum {
+	VF_IGNORE,
+	VF_INT,
+	VF_FLOAT,
+	VF_LSTRING,	// string on disk, pointer in memory, TAG_LEVEL
+	VF_VECTOR,
+	VF_BOOL,
+	VF_VEHTYPE,
+	VF_ANIM,
+	VF_WEAPON,	// take string, resolve into index into VehWeaponParms
+	VF_MODEL,	// take the string, get the G_ModelIndex
+	VF_MODEL_CLIENT,	// (cgame only) take the string, get the G_ModelIndex
+	VF_EFFECT,	// take the string, get the G_EffectIndex
+	VF_EFFECT_CLIENT,	// (cgame only) take the string, get the index
+	VF_SHADER,	// (cgame only) take the string, call trap_R_RegisterShader
+	VF_SHADER_NOMIP,// (cgame only) take the string, call trap_R_RegisterShaderNoMip
+	VF_SOUND,	// take the string, get the G_SoundIndex
+	VF_SOUND_CLIENT	// (cgame only) take the string, get the index
+} vehFieldType_t;
+
+typedef struct
+{
+	char	*name;
+	int		ofs;
+	vehFieldType_t	type;
+} vehField_t;
+
+vehField_t vehWeaponFields[NUM_VWEAP_PARMS] = 
+{
+	{"name", VWFOFS(name), VF_LSTRING},	//unique name of the vehicle
+	{"projectile", VWFOFS(bIsProjectile), VF_BOOL},	//traceline or entity?
+	{"hasGravity", VWFOFS(bHasGravity), VF_BOOL},	//if a projectile, drops
+	{"ionWeapon", VWFOFS(bIonWeapon), VF_BOOL},	//disables ship shields and sends them out of control
+	{"saberBlockable", VWFOFS(bSaberBlockable), VF_BOOL},	//lightsabers can deflect this projectile
+	{"muzzleFX", VWFOFS(iMuzzleFX), VF_EFFECT_CLIENT},	//index of Muzzle Effect
+	{"model", VWFOFS(iModel), VF_MODEL_CLIENT},	//handle to the model used by this projectile
+	{"shotFX", VWFOFS(iShotFX), VF_EFFECT_CLIENT},	//index of Shot Effect
+	{"impactFX", VWFOFS(iImpactFX), VF_EFFECT_CLIENT},	//index of Impact Effect
+	{"g2MarkShader", VWFOFS(iG2MarkShaderHandle), VF_SHADER},	//index of shader to use for G2 marks made on other models when hit by this projectile
+	{"g2MarkSize", VWFOFS(fG2MarkSize), VF_FLOAT},	//size (diameter) of the ghoul2 mark
+	{"loopSound", VWFOFS(iLoopSound), VF_SOUND_CLIENT},	//index of loopSound
+	{"speed", VWFOFS(fSpeed), VF_FLOAT},		//speed of projectile/range of traceline
+	{"homing", VWFOFS(fHoming), VF_FLOAT},		//0.0 = not homing, 0.5 = half vel to targ, half cur vel, 1.0 = all vel to targ
+	{"lockOnTime", VWFOFS(iLockOnTime), VF_INT},	//0 = no lock time needed, else # of ms needed to lock on
+	{"damage", VWFOFS(iDamage), VF_INT},		//damage done when traceline or projectile directly hits target
+	{"splashDamage", VWFOFS(iSplashDamage), VF_INT},//damage done to ents in splashRadius of end of traceline or projectile origin on impact
+	{"splashRadius", VWFOFS(fSplashRadius), VF_FLOAT},//radius that ent must be in to take splashDamage (linear fall-off)
+	{"ammoPerShot", VWFOFS(iAmmoPerShot), VF_INT},//how much "ammo" each shot takes
+	{"health", VWFOFS(iHealth), VF_INT},		//if non-zero, projectile can be shot, takes this much damage before being destroyed
+	{"width", VWFOFS(fWidth), VF_FLOAT},		//width of traceline or bounding box of projecile (non-rotating!)
+	{"height", VWFOFS(fHeight), VF_FLOAT},		//height of traceline or bounding box of projecile (non-rotating!)
+	{"lifetime", VWFOFS(iLifeTime), VF_INT},	//removes itself after this amount of time
+	{"explodeOnExpire", VWFOFS(bExplodeOnExpire), VF_BOOL},	//when iLifeTime is up, explodes rather than simply removing itself
+};
+
+static qboolean BG_ParseVehWeaponParm( vehWeaponInfo_t *vehWeapon, char *parmName, char *pValue )
+{
+	int		i;
+	vec3_t	vec;
+	byte	*b = (byte *)vehWeapon;
+	int		_iFieldsRead = 0;
+	vehicleType_t vehType;
+	char	value[1024];
+
+	Q_strncpyz( value, pValue, sizeof(value) );
+
+	// Loop through possible parameters
+	for ( i = 0; i < NUM_VWEAP_PARMS; i++ )
+	{
+		if ( vehWeaponFields[i].name && !Q_stricmp( vehWeaponFields[i].name, parmName ) )
+		{
+			// found it
+			switch( vehWeaponFields[i].type ) 
+			{
+			case VF_INT:
+				*(int *)(b+vehWeaponFields[i].ofs) = atoi(value);
+				break;
+			case VF_FLOAT:
+				*(float *)(b+vehWeaponFields[i].ofs) = atof(value);
+				break;
+			case VF_LSTRING:	// string on disk, pointer in memory, TAG_LEVEL
+				if (!*(char **)(b+vehWeaponFields[i].ofs))
+				{ //just use 1024 bytes in case we want to write over the string
+#ifdef _JK2MP
+					*(char **)(b+vehWeaponFields[i].ofs) = (char *)BG_Alloc(1024);//(char *)BG_Alloc(strlen(value));
+					strcpy(*(char **)(b+vehWeaponFields[i].ofs), value);
+#else
+					(*(char **)(b+vehWeaponFields[i].ofs)) = G_NewString( value );
+#endif
+				}
+				
+				break;
+			case VF_VECTOR:
+				_iFieldsRead = sscanf (value, "%f %f %f", &vec[0], &vec[1], &vec[2]);
+				assert(_iFieldsRead==3 );
+				if (_iFieldsRead!=3)
+				{
+					Com_Printf (S_COLOR_YELLOW"BG_ParseVehWeaponParm: VEC3 sscanf() failed to read 3 floats ('angle' key bug?)\n");
+				}
+				((float *)(b+vehWeaponFields[i].ofs))[0] = vec[0];
+				((float *)(b+vehWeaponFields[i].ofs))[1] = vec[1];
+				((float *)(b+vehWeaponFields[i].ofs))[2] = vec[2];
+				break;
+			case VF_BOOL:
+				*(qboolean *)(b+vehWeaponFields[i].ofs) = (qboolean)(atof(value)!=0);
+				break;
+			case VF_VEHTYPE:
+				vehType = (vehicleType_t)GetIDForString( VehicleTable, value );
+				*(vehicleType_t *)(b+vehWeaponFields[i].ofs) = vehType;
+				break;
+			case VF_ANIM:
+				{
+					int anim = GetIDForString( animTable, value );
+					*(int *)(b+vehWeaponFields[i].ofs) = anim;
+				}
+				break;
+			case VF_WEAPON:	// take string, resolve into index into VehWeaponParms
+				//*(int *)(b+vehWeaponFields[i].ofs) = VEH_VehWeaponIndexForName( value );
+				break;
+			case VF_MODEL:// take the string, get the G_ModelIndex
+#ifdef QAGAME
+				*(int *)(b+vehWeaponFields[i].ofs) = G_ModelIndex( value );
+#else
+				*(int *)(b+vehWeaponFields[i].ofs) = trap_R_RegisterModel( value );
+#endif
+				break;
+			case VF_MODEL_CLIENT:	// (MP cgame only) take the string, get the G_ModelIndex
+#ifndef _JK2MP
+				*(int *)(b+vehWeaponFields[i].ofs) = G_ModelIndex( value );
+#elif QAGAME
+				//*(int *)(b+vehWeaponFields[i].ofs) = G_ModelIndex( value );
+#else
+				*(int *)(b+vehWeaponFields[i].ofs) = trap_R_RegisterModel( value );
+#endif
+				break;
+			case VF_EFFECT:	// take the string, get the G_EffectIndex
+#ifdef QAGAME
+				*(int *)(b+vehWeaponFields[i].ofs) = G_EffectIndex( value );
+#elif CGAME
+				*(int *)(b+vehWeaponFields[i].ofs) = trap_FX_RegisterEffect( value );
+#endif
+				break;
+			case VF_EFFECT_CLIENT:	// (MP cgame only) take the string, get the index
+#ifndef _JK2MP
+				*(int *)(b+vehWeaponFields[i].ofs) = G_EffectIndex( value );
+#elif QAGAME
+				//*(int *)(b+vehWeaponFields[i].ofs) = G_EffectIndex( value );
+#elif CGAME
+				*(int *)(b+vehWeaponFields[i].ofs) = trap_FX_RegisterEffect( value );
+#endif
+				break;
+			case VF_SHADER:	// (cgame only) take the string, call trap_R_RegisterShader
+#ifdef WE_ARE_IN_THE_UI
+				*(int *)(b+vehWeaponFields[i].ofs) = trap_R_RegisterShaderNoMip( value );
+#elif CGAME
+				*(int *)(b+vehWeaponFields[i].ofs) = trap_R_RegisterShader( value );
+#endif
+				break;
+			case VF_SHADER_NOMIP:// (cgame only) take the string, call trap_R_RegisterShaderNoMip
+#ifndef QAGAME
+				*(int *)(b+vehWeaponFields[i].ofs) = trap_R_RegisterShaderNoMip( value );
+#endif
+				break;
+			case VF_SOUND:	// take the string, get the G_SoundIndex
+#ifdef QAGAME
+				*(int *)(b+vehWeaponFields[i].ofs) = G_SoundIndex( value );
+#else
+				*(int *)(b+vehWeaponFields[i].ofs) = trap_S_RegisterSound( value );
+#endif
+				break;
+			case VF_SOUND_CLIENT:	// (MP cgame only) take the string, get the index
+#ifndef _JK2MP
+				*(int *)(b+vehWeaponFields[i].ofs) = G_SoundIndex( value );
+#elif QAGAME
+				//*(int *)(b+vehWeaponFields[i].ofs) = G_SoundIndex( value );
+#else
+				*(int *)(b+vehWeaponFields[i].ofs) = trap_S_RegisterSound( value );
+#endif
+				break;
+			default:
+				//Unknown type?
+				return qfalse;
+				break;
+			}
+			break;
+		}
+	}
+	if ( i == NUM_VWEAP_PARMS )
+	{
+        return qfalse;
+	}
+	else
+	{
+		return qtrue;
+	}
+}
+
+int VEH_LoadVehWeapon( const char *vehWeaponName )
+{//load up specified vehWeapon and save in array: g_vehWeaponInfo
+	const char	*token;
+	char		parmName[128];//we'll assume that no parm name is longer than 128
+	char		*value;
+	const char	*p;
+	vehWeaponInfo_t	*vehWeapon = NULL;
+
+	//BG_VehWeaponSetDefaults( &g_vehWeaponInfo[0] );//set the first vehicle to default data
+
+	//try to parse data out
+	p = VehWeaponParms;
+
+#ifdef _JK2MP
+	COM_BeginParseSession("vehWeapons");
+#else
+	COM_BeginParseSession();
+#endif
+
+	vehWeapon = &g_vehWeaponInfo[numVehicleWeapons];
+	// look for the right vehicle weapon
+	while ( p ) 
+	{
+		token = COM_ParseExt( &p, qtrue );
+		if ( token[0] == 0 )
+		{
+			return qfalse;
+		}
+
+		if ( !Q_stricmp( token, vehWeaponName ) ) 
+		{
+			break;
+		}
+
+		SkipBracedSection( &p );
+	}
+	if ( !p ) 
+	{
+		return qfalse;
+	}
+
+	token = COM_ParseExt( &p, qtrue );
+	if ( token[0] == 0 )
+	{//barf
+		return VEH_WEAPON_NONE;
+	}
+
+	if ( Q_stricmp( token, "{" ) != 0 ) 
+	{
+		return VEH_WEAPON_NONE;
+	}
+	
+	// parse the vehWeapon info block
+	while ( 1 ) 
+	{
+		SkipRestOfLine( &p );
+		token = COM_ParseExt( &p, qtrue );
+		if ( !token[0] ) 
+		{
+			Com_Printf( S_COLOR_RED"ERROR: unexpected EOF while parsing Vehicle Weapon '%s'\n", vehWeaponName );
+			return VEH_WEAPON_NONE;
+		}
+
+		if ( !Q_stricmp( token, "}" ) ) 
+		{
+			break;
+		}
+		Q_strncpyz( parmName, token, sizeof(parmName) );
+		value = COM_ParseExt( &p, qtrue );
+		if ( !value || !value[0] )
+		{
+			Com_Printf( S_COLOR_RED"ERROR: Vehicle Weapon token '%s' has no value!\n", parmName );
+		}
+		else
+		{
+			if ( !BG_ParseVehWeaponParm( vehWeapon, parmName, value ) )
+			{
+				Com_Printf( S_COLOR_RED"ERROR: Unknown Vehicle Weapon key/value pair '%s','%s'!\n", parmName, value );
+			}
+		}
+	}
+	if ( vehWeapon->fHoming )
+	{//all lock-on weapons use these 2 sounds
+#ifdef QAGAME
+		//Hmm, no need fo have server register this, is there?
+		//G_SoundIndex( "sound/weapons/torpedo/tick.wav" );
+		//G_SoundIndex( "sound/weapons/torpedo/lock.wav" );
+#elif CGAME
+		trap_S_RegisterSound( "sound/vehicles/weapons/common/tick.wav" );
+		trap_S_RegisterSound( "sound/vehicles/weapons/common/lock.wav" );
+		trap_S_RegisterSound( "sound/vehicles/common/lockalarm1.wav" );
+		trap_S_RegisterSound( "sound/vehicles/common/lockalarm2.wav" );
+		trap_S_RegisterSound( "sound/vehicles/common/lockalarm3.wav" );
+#else
+		trap_S_RegisterSound( "sound/vehicles/weapons/common/tick.wav" );
+		trap_S_RegisterSound( "sound/vehicles/weapons/common/lock.wav" );
+		trap_S_RegisterSound( "sound/vehicles/common/lockalarm1.wav" );
+		trap_S_RegisterSound( "sound/vehicles/common/lockalarm2.wav" );
+		trap_S_RegisterSound( "sound/vehicles/common/lockalarm3.wav" );
+#endif
+	}
+	return (numVehicleWeapons++);
+}
+
+int VEH_VehWeaponIndexForName( const char *vehWeaponName )
+{
+	int vw;
+	if ( !vehWeaponName || !vehWeaponName[0] )
+	{
+		Com_Printf( S_COLOR_RED"ERROR: Trying to read Vehicle Weapon with no name!\n" );
+		return VEH_WEAPON_NONE;
+	}
+	for ( vw = VEH_WEAPON_BASE; vw < numVehicleWeapons; vw++ )
+	{
+		if ( g_vehWeaponInfo[vw].name
+			&& Q_stricmp( g_vehWeaponInfo[vw].name, vehWeaponName ) == 0 )
+		{//already loaded this one
+			return vw;
+		}
+	}
+	//haven't loaded it yet
+	if ( vw >= MAX_VEH_WEAPONS )
+	{//no more room!
+		Com_Printf( S_COLOR_RED"ERROR: Too many Vehicle Weapons (max 16), aborting load on %s!\n", vehWeaponName );
+		return VEH_WEAPON_NONE;
+	}
+	//we have room for another one, load it up and return the index
+	//HMM... should we not even load the .vwp file until we want to?
+	vw = VEH_LoadVehWeapon( vehWeaponName );
+	if ( vw == VEH_WEAPON_NONE )
+	{
+		Com_Printf( S_COLOR_RED"ERROR: Could not find Vehicle Weapon %s!\n", vehWeaponName );
+	}
+	return vw;
+}
+
+vehField_t vehicleFields[] = 
+{
+	{"name", VFOFS(name), VF_LSTRING},	//unique name of the vehicle
+
+	//general data
+	{"type", VFOFS(type), VF_VEHTYPE},	//what kind of vehicle
+	{"numHands", VFOFS(numHands), VF_INT},	//if 2 hands, no weapons, if 1 hand, can use 1-handed weapons, if 0 hands, can use 2-handed weapons
+	{"lookPitch", VFOFS(lookPitch), VF_FLOAT},	//How far you can look up and down off the forward of the vehicle
+	{"lookYaw", VFOFS(lookYaw), VF_FLOAT},	//How far you can look left and right off the forward of the vehicle
+	{"length", VFOFS(length), VF_FLOAT},		//how long it is - used for body length traces when turning/moving?
+	{"width", VFOFS(width), VF_FLOAT},		//how wide it is - used for body length traces when turning/moving?
+	{"height", VFOFS(height), VF_FLOAT},		//how tall it is - used for body length traces when turning/moving?
+	{"centerOfGravity", VFOFS(centerOfGravity), VF_VECTOR},//offset from origin: {forward, right, up} as a modifier on that dimension (-1.0f is all the way back, 1.0f is all the way forward)
+
+	//speed stats
+	{"speedMax", VFOFS(speedMax), VF_FLOAT},		//top speed
+	{"turboSpeed", VFOFS(turboSpeed), VF_FLOAT},	//turbo speed
+	{"speedMin", VFOFS(speedMin), VF_FLOAT},		//if < 0, can go in reverse
+	{"speedIdle", VFOFS(speedIdle), VF_FLOAT},		//what speed it drifts to when no accel/decel input is given
+	{"accelIdle", VFOFS(accelIdle), VF_FLOAT},		//if speedIdle > 0, how quickly it goes up to that speed
+	{"acceleration", VFOFS(acceleration), VF_FLOAT},	//when pressing on accelerator
+	{"decelIdle", VFOFS(decelIdle), VF_FLOAT},		//when giving no input, how quickly it drops to speedIdle
+	{"throttleSticks", VFOFS(throttleSticks), VF_BOOL},//if true, speed stays at whatever you accel/decel to, unless you turbo or brake
+	{"strafePerc", VFOFS(strafePerc), VF_FLOAT},		//multiplier on current speed for strafing.  If 1.0f, you can strafe at the same speed as you're going forward, 0.5 is half, 0 is no strafing
+
+	//handling stats
+	{"bankingSpeed", VFOFS(bankingSpeed), VF_FLOAT},	//how quickly it pitches and rolls (not under player control)
+	{"pitchLimit", VFOFS(pitchLimit), VF_FLOAT},		//how far it can roll forward or backward
+	{"rollLimit", VFOFS(rollLimit), VF_FLOAT},		//how far it can roll to either side
+	{"braking", VFOFS(braking), VF_FLOAT},		//when pressing on decelerator
+	{"mouseYaw", VFOFS(mouseYaw), VF_FLOAT},			// The mouse yaw override.
+	{"mousePitch", VFOFS(mousePitch), VF_FLOAT},			// The mouse yaw override.
+	{"turningSpeed", VFOFS(turningSpeed), VF_FLOAT},	//how quickly you can turn
+	{"turnWhenStopped", VFOFS(turnWhenStopped), VF_BOOL},//whether or not you can turn when not moving
+	{"traction", VFOFS(traction), VF_FLOAT},		//how much your command input affects velocity
+	{"friction", VFOFS(friction), VF_FLOAT},		//how much velocity is cut on its own
+	{"maxSlope", VFOFS(maxSlope), VF_FLOAT},		//the max slope that it can go up with control
+	{"speedDependantTurning", VFOFS(speedDependantTurning), VF_BOOL},//vehicle turns faster the faster it's going
+	
+	//durability stats
+	{"mass", VFOFS(mass), VF_INT},			//for momentum and impact force (player mass is 10)
+	{"armor", VFOFS(armor), VF_INT},			//total points of damage it can take
+	{"shields", VFOFS(shields), VF_INT},			//energy shield damage points
+	{"shieldRechargeMS", VFOFS(shieldRechargeMS), VF_INT},//energy shield milliseconds per point recharged
+	{"toughness", VFOFS(toughness), VF_FLOAT},		//modifies incoming damage, 1.0 is normal, 0.5 is half, etc.  Simulates being made of tougher materials/construction
+	{"malfunctionArmorLevel", VFOFS(malfunctionArmorLevel), VF_INT},//when armor drops to or below this point, start malfunctioning
+	{"surfDestruction", VFOFS(surfDestruction), VF_INT},
+
+	//visuals & sounds
+	{"model", VFOFS(model), VF_LSTRING},			//what model to use - if make it an NPC's primary model, don't need this?
+	{"skin", VFOFS(skin), VF_LSTRING},				//what skin to use - if make it an NPC's primary model, don't need this?
+	{"g2radius", VFOFS(g2radius), VF_INT},			//render radius (really diameter, but...) for the ghoul2 model
+	{"riderAnim", VFOFS(riderAnim), VF_ANIM},		//what animation the rider uses
+	{"droidNPC", VFOFS(droidNPC), VF_LSTRING},		//NPC to attach to *droidunit tag (if it exists in the model)
+
+#ifdef _JK2MP
+	{"radarIcon", VFOFS(radarIconHandle), VF_SHADER_NOMIP},		//what icon to show on radar in MP
+	{"dmgIndicFrame", VFOFS(dmgIndicFrameHandle), VF_SHADER_NOMIP},	//what image to use for the frame of the damage indicator
+	{"dmgIndicShield", VFOFS(dmgIndicShieldHandle), VF_SHADER_NOMIP},//what image to use for the shield of the damage indicator
+	{"dmgIndicBackground", VFOFS(dmgIndicBackgroundHandle), VF_SHADER_NOMIP},//what image to use for the background of the damage indicator
+	{"icon_front", VFOFS(iconFrontHandle), VF_SHADER_NOMIP},	//what image to use for the front of the ship on the damage indicator
+	{"icon_back", VFOFS(iconBackHandle), VF_SHADER_NOMIP},		//what image to use for the back of the ship on the damage indicator
+	{"icon_right", VFOFS(iconRightHandle), VF_SHADER_NOMIP},	//what image to use for the right of the ship on the damage indicator
+	{"icon_left", VFOFS(iconLeftHandle), VF_SHADER_NOMIP},		//what image to use for the left of the ship on the damage indicator
+	{"crosshairShader", VFOFS(crosshairShaderHandle), VF_SHADER_NOMIP},	//what image to use as the crosshair
+	{"shieldShader", VFOFS(shieldShaderHandle), VF_SHADER},		//What shader to use when drawing the shield shell
+
+	//individual "area" health -rww
+	{"health_front", VFOFS(health_front), VF_INT},
+	{"health_back", VFOFS(health_back), VF_INT},
+	{"health_right", VFOFS(health_right), VF_INT},
+	{"health_left", VFOFS(health_left), VF_INT},
+#else
+	{"radarIcon", 0, VF_IGNORE},		//what icon to show on radar in MP
+#endif
+
+	{"soundOn",			VFOFS(soundOn),			VF_SOUND},//sound to play when get on it
+	{"soundOff",		VFOFS(soundOff),		VF_SOUND},//sound to play when get off
+	{"soundLoop",		VFOFS(soundLoop),		VF_SOUND},//sound to loop while riding it
+	{"soundTakeOff",	VFOFS(soundTakeOff),	VF_SOUND},//sound to play when ship takes off
+	{"soundEngineStart",VFOFS(soundEngineStart),VF_SOUND_CLIENT},//sound to play when ship's thrusters first activate
+	{"soundSpin",		VFOFS(soundSpin),		VF_SOUND},//sound to loop while spiraling out of control
+	{"soundTurbo",		VFOFS(soundTurbo),		VF_SOUND},//sound to play when turbo/afterburner kicks in
+	{"soundHyper",		VFOFS(soundHyper),		VF_SOUND_CLIENT},//sound to play when hits hyperspace
+	{"soundLand",		VFOFS(soundLand),		VF_SOUND},//sound to play when ship lands
+	{"soundFlyBy",		VFOFS(soundFlyBy),		VF_SOUND_CLIENT},//sound to play when they buzz you
+	{"soundFlyBy2",		VFOFS(soundFlyBy2),		VF_SOUND_CLIENT},//alternate sound to play when they buzz you
+	{"soundShift1",		VFOFS(soundShift1),		VF_SOUND},//sound to play when changing speeds
+	{"soundShift2",		VFOFS(soundShift2),		VF_SOUND},//sound to play when changing speeds
+	{"soundShift3",		VFOFS(soundShift3),		VF_SOUND},//sound to play when changing speeds
+	{"soundShift4",		VFOFS(soundShift4),		VF_SOUND},//sound to play when changing speeds
+
+	{"exhaustFX", VFOFS(iExhaustFX), VF_EFFECT_CLIENT},		//exhaust effect, played from "*exhaust" bolt(s)
+	{"turboFX", VFOFS(iTurboFX), VF_EFFECT_CLIENT},		//turbo exhaust effect, played from "*exhaust" bolt(s) when ship is in "turbo" mode
+	{"turboStartFX", VFOFS(iTurboStartFX), VF_EFFECT},		//turbo start effect, played from "*exhaust" bolt(s) when ship is in "turbo" mode
+	{"trailFX", VFOFS(iTrailFX), VF_EFFECT_CLIENT},		//trail effect, played from "*trail" bolt(s)
+	{"impactFX", VFOFS(iImpactFX), VF_EFFECT_CLIENT},		//impact effect, for when it bumps into something
+	{"explodeFX", VFOFS(iExplodeFX), VF_EFFECT},		//explosion effect, for when it blows up (should have the sound built into explosion effect)
+	{"wakeFX", VFOFS(iWakeFX), VF_EFFECT_CLIENT},		//effect it makes when going across water
+	{"dmgFX", VFOFS(iDmgFX), VF_EFFECT_CLIENT},		//effect to play on damage from a weapon or something
+#ifdef _JK2MP
+	{"injureFX", VFOFS(iInjureFX), VF_EFFECT_CLIENT}, //effect to play on partially damaged ship surface
+	{"noseFX", VFOFS(iNoseFX), VF_EFFECT_CLIENT},		//effect for nose piece flying away when blown off
+	{"lwingFX", VFOFS(iLWingFX), VF_EFFECT_CLIENT},		//effect for left wing piece flying away when blown off
+	{"rwingFX", VFOFS(iRWingFX), VF_EFFECT_CLIENT},		//effect for right wing piece flying away when blown off
+#else
+	{"armorLowFX", VFOFS(iArmorLowFX), VF_EFFECT_CLIENT},		//effect to play on damage from a weapon or something
+	{"armorGoneFX", VFOFS(iArmorGoneFX), VF_EFFECT_CLIENT},		//effect to play on damage from a weapon or something
+#endif
+
+	// Weapon stuff:
+	{"weap1", VFOFS(weapon[0].ID), VF_WEAPON},	//weapon used when press fire
+	{"weap2", VFOFS(weapon[1].ID), VF_WEAPON},//weapon used when press alt-fire
+	// The delay between shots for this weapon.
+	{"weap1Delay", VFOFS(weapon[0].delay), VF_INT},
+	{"weap2Delay", VFOFS(weapon[1].delay), VF_INT},
+	// Whether or not all the muzzles for each weapon can be linked together (linked delay = weapon delay * number of muzzles linked!)
+	{"weap1Link", VFOFS(weapon[0].linkable), VF_INT},
+	{"weap2Link", VFOFS(weapon[1].linkable), VF_INT},
+	// Whether or not to auto-aim the projectiles at the thing under the crosshair when we fire
+	{"weap1Aim", VFOFS(weapon[0].aimCorrect), VF_BOOL},
+	{"weap2Aim", VFOFS(weapon[1].aimCorrect), VF_BOOL},
+	//maximum ammo
+	{"weap1AmmoMax", VFOFS(weapon[0].ammoMax), VF_INT},
+	{"weap2AmmoMax", VFOFS(weapon[1].ammoMax), VF_INT},
+	//ammo recharge rate - milliseconds per unit (minimum of 100, which is 10 ammo per second)
+	{"weap1AmmoRechargeMS", VFOFS(weapon[0].ammoRechargeMS), VF_INT},
+	{"weap2AmmoRechargeMS", VFOFS(weapon[1].ammoRechargeMS), VF_INT},
+	//sound to play when out of ammo (plays default "no ammo" sound if none specified)
+	{"weap1SoundNoAmmo", VFOFS(weapon[0].soundNoAmmo), VF_SOUND_CLIENT},//sound to play when try to fire weapon 1 with no ammo
+	{"weap2SoundNoAmmo", VFOFS(weapon[1].soundNoAmmo), VF_SOUND_CLIENT},//sound to play when try to fire weapon 2 with no ammo
+	
+	// Which weapon a muzzle fires (has to match one of the weapons this vehicle has).
+	{"weapMuzzle1", VFOFS(weapMuzzle[0]), VF_WEAPON},
+	{"weapMuzzle2", VFOFS(weapMuzzle[1]), VF_WEAPON},
+	{"weapMuzzle3", VFOFS(weapMuzzle[2]), VF_WEAPON},
+	{"weapMuzzle4", VFOFS(weapMuzzle[3]), VF_WEAPON},
+	{"weapMuzzle5", VFOFS(weapMuzzle[4]), VF_WEAPON},
+	{"weapMuzzle6", VFOFS(weapMuzzle[5]), VF_WEAPON},
+	{"weapMuzzle7", VFOFS(weapMuzzle[6]), VF_WEAPON},
+	{"weapMuzzle8", VFOFS(weapMuzzle[7]), VF_WEAPON},
+	{"weapMuzzle9", VFOFS(weapMuzzle[8]), VF_WEAPON},
+	{"weapMuzzle10", VFOFS(weapMuzzle[9]), VF_WEAPON},
+
+	// The max height before this ship (?) starts (auto)landing.
+	{"landingHeight", VFOFS(landingHeight), VF_FLOAT},
+
+	//other misc stats
+	{"gravity", VFOFS(gravity), VF_INT},			//normal is 800
+	{"hoverHeight", VFOFS(hoverHeight), VF_FLOAT},	//if 0, it's a ground vehicle
+	{"hoverStrength", VFOFS(hoverStrength), VF_FLOAT},	//how hard it pushes off ground when less than hover height... causes "bounce", like shocks
+	{"waterProof", VFOFS(waterProof), VF_BOOL},		//can drive underwater if it has to
+	{"bouyancy", VFOFS(bouyancy), VF_FLOAT},		//when in water, how high it floats (1 is neutral bouyancy)
+	{"fuelMax", VFOFS(fuelMax), VF_INT},		//how much fuel it can hold (capacity)
+	{"fuelRate", VFOFS(fuelRate), VF_INT},		//how quickly is uses up fuel
+	{"turboDuration", VFOFS(turboDuration), VF_INT},		//how long turbo lasts
+	{"turboRecharge", VFOFS(turboRecharge), VF_INT},		//how long turbo takes to recharge
+	{"visibility", VFOFS(visibility), VF_INT},		//for sight alerts
+	{"loudness", VFOFS(loudness), VF_INT},		//for sound alerts
+	{"explosionRadius", VFOFS(explosionRadius), VF_FLOAT},//range of explosion
+	{"explosionDamage", VFOFS(explosionDamage), VF_INT},//damage of explosion
+
+	//new stuff
+	{"maxPassengers", VFOFS(maxPassengers), VF_INT},	// The max number of passengers this vehicle may have (Default = 0).
+	{"hideRider", VFOFS(hideRider), VF_BOOL},			// rider (and passengers?) should not be drawn
+	{"killRiderOnDeath", VFOFS(killRiderOnDeath), VF_BOOL},//if rider is on vehicle when it dies, they should die
+	{"flammable", VFOFS(flammable), VF_BOOL},			//whether or not the vehicle should catch on fire before it explodes
+	{"explosionDelay", VFOFS(explosionDelay), VF_INT},	//how long the vehicle should be on fire/dying before it explodes
+	//camera stuff
+	{"cameraOverride", VFOFS(cameraOverride), VF_BOOL},//override the third person camera with the below values - normal is 0 (off)
+	{"cameraRange", VFOFS(cameraRange), VF_FLOAT},		//how far back the camera should be - normal is 80
+	{"cameraVertOffset", VFOFS(cameraVertOffset), VF_FLOAT},//how high over the vehicle origin the camera should be - normal is 16
+	{"cameraHorzOffset", VFOFS(cameraHorzOffset), VF_FLOAT},//how far to left/right (negative/positive) of of the vehicle origin the camera should be - normal is 0
+	{"cameraPitchOffset", VFOFS(cameraPitchOffset), VF_FLOAT},//a modifier on the camera's pitch (up/down angle) to the vehicle - normal is 0
+	{"cameraFOV", VFOFS(cameraFOV), VF_FLOAT},			//third person camera FOV, default is 80
+	{"cameraAlpha", VFOFS(cameraAlpha), VF_FLOAT},		//fade out the vehicle to this alpha (0.1-1.0f) if it's in the way of the crosshair
+	{"cameraPitchDependantVertOffset", VFOFS(cameraPitchDependantVertOffset), VF_BOOL},		//use the hacky AT-ST pitch dependant vertical offset
+//===TURRETS===========================================================================
+	//Turret 1
+	{"turret1Weap", VFOFS(turret[0].iWeapon), VF_WEAPON},
+	{"turret1Delay", VFOFS(turret[0].iDelay), VF_INT},
+	{"turret1AmmoMax", VFOFS(turret[0].iAmmoMax), VF_INT},
+	{"turret1AmmoRechargeMS", VFOFS(turret[0].iAmmoRechargeMS), VF_INT},
+	{"turret1YawBone", VFOFS(turret[0].yawBone), VF_LSTRING},
+	{"turret1PitchBone", VFOFS(turret[0].pitchBone), VF_LSTRING},
+	{"turret1YawAxis", VFOFS(turret[0].yawAxis), VF_INT},
+	{"turret1PitchAxis", VFOFS(turret[0].pitchAxis), VF_INT},
+	{"turret1ClampYawL", VFOFS(turret[0].yawClampLeft), VF_FLOAT},	//how far the turret is allowed to turn left
+	{"turret1ClampYawR", VFOFS(turret[0].yawClampRight), VF_FLOAT},	//how far the turret is allowed to turn right
+	{"turret1ClampPitchU", VFOFS(turret[0].pitchClampUp), VF_FLOAT},	//how far the turret is allowed to title up
+	{"turret1ClampPitchD", VFOFS(turret[0].pitchClampDown), VF_FLOAT}, //how far the turret is allowed to tilt down
+	{"turret1Muzzle1", VFOFS(turret[0].iMuzzle[0]), VF_INT},
+	{"turret1Muzzle2", VFOFS(turret[0].iMuzzle[1]), VF_INT},
+	{"turret1TurnSpeed", VFOFS(turret[0].fTurnSpeed), VF_FLOAT},
+	{"turret1AI", VFOFS(turret[0].bAI), VF_BOOL},
+	{"turret1AILead", VFOFS(turret[0].bAILead), VF_BOOL},
+	{"turret1AIRange", VFOFS(turret[0].fAIRange), VF_FLOAT},
+	{"turret1PassengerNum", VFOFS(turret[0].passengerNum), VF_INT},//which number passenger can control this turret
+	{"turret1GunnerViewTag", VFOFS(turret[0].gunnerViewTag), VF_LSTRING},
+	
+	//Turret 2
+	{"turret2Weap", VFOFS(turret[1].iWeapon), VF_WEAPON},
+	{"turret2Delay", VFOFS(turret[1].iDelay), VF_INT},
+	{"turret2AmmoMax", VFOFS(turret[1].iAmmoMax), VF_INT},
+	{"turret2AmmoRechargeMS", VFOFS(turret[1].iAmmoRechargeMS), VF_INT},
+	{"turret2YawBone", VFOFS(turret[1].yawBone), VF_LSTRING},
+	{"turret2PitchBone", VFOFS(turret[1].pitchBone), VF_LSTRING},
+	{"turret2YawAxis", VFOFS(turret[1].yawAxis), VF_INT},
+	{"turret2PitchAxis", VFOFS(turret[1].pitchAxis), VF_INT},
+	{"turret2ClampYawL", VFOFS(turret[1].yawClampLeft), VF_FLOAT},	//how far the turret is allowed to turn left
+	{"turret2ClampYawR", VFOFS(turret[1].yawClampRight), VF_FLOAT},	//how far the turret is allowed to turn right
+	{"turret2ClampPitchU", VFOFS(turret[1].pitchClampUp), VF_FLOAT},	//how far the turret is allowed to title up
+	{"turret2ClampPitchD", VFOFS(turret[1].pitchClampDown), VF_FLOAT}, //how far the turret is allowed to tilt down
+	{"turret2Muzzle1", VFOFS(turret[1].iMuzzle[0]), VF_INT},
+	{"turret2Muzzle2", VFOFS(turret[1].iMuzzle[1]), VF_INT},
+	{"turret2TurnSpeed", VFOFS(turret[1].fTurnSpeed), VF_FLOAT},
+	{"turret2AI", VFOFS(turret[1].bAI), VF_BOOL},
+	{"turret2AILead", VFOFS(turret[1].bAILead), VF_BOOL},
+	{"turret2AIRange", VFOFS(turret[1].fAIRange), VF_FLOAT},
+	{"turret2PassengerNum", VFOFS(turret[1].passengerNum), VF_INT},//which number passenger can control this turret
+	{"turret2GunnerViewTag", VFOFS(turret[1].gunnerViewTag), VF_LSTRING},
+//===END TURRETS===========================================================================
+	//terminating entry
+	{0, -1, VF_INT}
+};
+
+stringID_table_t VehicleTable[VH_NUM_VEHICLES+1] =
+{
+	ENUM2STRING(VH_NONE),
+	ENUM2STRING(VH_WALKER),		//something you ride inside of, it walks like you, like an AT-ST
+	ENUM2STRING(VH_FIGHTER),	//something you fly inside of, like an X-Wing or TIE fighter
+	ENUM2STRING(VH_SPEEDER),	//something you ride on that hovers, like a speeder or swoop
+	ENUM2STRING(VH_ANIMAL),		//animal you ride on top of that walks, like a tauntaun
+	ENUM2STRING(VH_FLIER),		//animal you ride on top of that flies, like a giant mynoc?
+	0,	-1
+};
+
+// Setup the shared functions (one's that all vehicles would generally use).
+void BG_SetSharedVehicleFunctions( vehicleInfo_t *pVehInfo )
+{
+#ifdef QAGAME
+	//only do the whole thing if we're on game
+	G_SetSharedVehicleFunctions(pVehInfo);
+#endif
+
+#ifndef WE_ARE_IN_THE_UI
+	switch( pVehInfo->type )
+	{
+		case VH_SPEEDER:
+			G_SetSpeederVehicleFunctions( pVehInfo );
+			break;
+		case VH_ANIMAL:
+			G_SetAnimalVehicleFunctions( pVehInfo );
+			break;
+		case VH_FIGHTER:
+			G_SetFighterVehicleFunctions( pVehInfo );
+			break;
+		case VH_WALKER:
+			G_SetWalkerVehicleFunctions( pVehInfo );
+			break;
+	}
+#endif
+}
+
+void BG_VehicleSetDefaults( vehicleInfo_t *vehicle )
+{
+	memset(vehicle, 0, sizeof(vehicleInfo_t));
+/*
+#if _JK2MP
+	if (!vehicle->name)
+	{
+		vehicle->name = (char *)BG_Alloc(1024);
+	}
+	strcpy(vehicle->name, "default");
+#else
+	vehicle->name = G_NewString( "default" );
+#endif
+
+	//general data
+	vehicle->type = VH_SPEEDER;				//what kind of vehicle
+	//FIXME: no saber or weapons if numHands = 2, should switch to speeder weapon, no attack anim on player
+	vehicle->numHands = 0;					//if 2 hands, no weapons, if 1 hand, can use 1-handed weapons, if 0 hands, can use 2-handed weapons
+	vehicle->lookPitch = 0;				//How far you can look up and down off the forward of the vehicle
+	vehicle->lookYaw = 5;					//How far you can look left and right off the forward of the vehicle
+	vehicle->length = 0;					//how long it is - used for body length traces when turning/moving?
+	vehicle->width = 0;						//how wide it is - used for body length traces when turning/moving?
+	vehicle->height = 0;					//how tall it is - used for body length traces when turning/moving?
+	VectorClear( vehicle->centerOfGravity );//offset from origin: {forward, right, up} as a modifier on that dimension (-1.0f is all the way back, 1.0f is all the way forward)
+
+	//speed stats - note: these are DESIRED speed, not actual current speed/velocity
+	vehicle->speedMax = VEH_DEFAULT_SPEED_MAX;	//top speed
+	vehicle->turboSpeed = 0;					//turboBoost
+	vehicle->speedMin = 0;						//if < 0, can go in reverse
+	vehicle->speedIdle = 0;						//what speed it drifts to when no accel/decel input is given
+	vehicle->accelIdle = 0;						//if speedIdle > 0, how quickly it goes up to that speed
+	vehicle->acceleration = VEH_DEFAULT_ACCEL;	//when pressing on accelerator (1/2 this when going in reverse)
+	vehicle->decelIdle = VEH_DEFAULT_DECEL;		//when giving no input, how quickly it desired speed drops to speedIdle
+	vehicle->strafePerc = VEH_DEFAULT_STRAFE_PERC;//multiplier on current speed for strafing.  If 1.0f, you can strafe at the same speed as you're going forward, 0.5 is half, 0 is no strafing
+
+	//handling stats
+	vehicle->bankingSpeed = VEH_DEFAULT_BANKING_SPEED;	//how quickly it pitches and rolls (not under player control)
+	vehicle->rollLimit = VEH_DEFAULT_ROLL_LIMIT;		//how far it can roll to either side
+	vehicle->pitchLimit = VEH_DEFAULT_PITCH_LIMIT;		//how far it can pitch forward or backward
+	vehicle->braking = VEH_DEFAULT_BRAKING;				//when pressing on decelerator (backwards)
+	vehicle->turningSpeed = VEH_DEFAULT_TURNING_SPEED;	//how quickly you can turn
+	vehicle->turnWhenStopped = qfalse;					//whether or not you can turn when not moving	
+	vehicle->traction = VEH_DEFAULT_TRACTION;			//how much your command input affects velocity
+	vehicle->friction = VEH_DEFAULT_FRICTION;			//how much velocity is cut on its own
+	vehicle->maxSlope = VEH_DEFAULT_MAX_SLOPE;			//the max slope that it can go up with control
+
+	//durability stats
+	vehicle->mass = VEH_DEFAULT_MASS;			//for momentum and impact force (player mass is 10)
+	vehicle->armor = VEH_DEFAULT_MAX_ARMOR;		//total points of damage it can take
+	vehicle->toughness = VEH_DEFAULT_TOUGHNESS;	//modifies incoming damage, 1.0 is normal, 0.5 is half, etc.  Simulates being made of tougher materials/construction
+	vehicle->malfunctionArmorLevel = 0;			//when armor drops to or below this point, start malfunctioning
+
+	//visuals & sounds
+	//vehicle->model = "models/map_objects/ships/swoop.md3";	//what model to use - if make it an NPC's primary model, don't need this?
+	if (!vehicle->model)
+	{
+		vehicle->model = (char *)BG_Alloc(1024);
+	}
+	strcpy(vehicle->model, "models/map_objects/ships/swoop.md3");
+
+	vehicle->modelIndex = 0;							//set internally, not until this vehicle is spawned into the level
+	vehicle->skin = NULL;								//what skin to use - if make it an NPC's primary model, don't need this?
+	vehicle->riderAnim = BOTH_GUNSIT1;					//what animation the rider uses
+
+	vehicle->soundOn = NULL;							//sound to play when get on it
+	vehicle->soundLoop = NULL;							//sound to loop while riding it
+	vehicle->soundOff = NULL;							//sound to play when get off
+	vehicle->exhaustFX = NULL;							//exhaust effect, played from "*exhaust" bolt(s)
+	vehicle->trailFX = NULL;							//trail effect, played from "*trail" bolt(s)
+	vehicle->impactFX = NULL;							//explosion effect, for when it blows up (should have the sound built into explosion effect)
+	vehicle->explodeFX = NULL;							//explosion effect, for when it blows up (should have the sound built into explosion effect)
+	vehicle->wakeFX = NULL;								//effect itmakes when going across water
+
+	//other misc stats
+	vehicle->gravity = VEH_DEFAULT_GRAVITY;				//normal is 800
+	vehicle->hoverHeight = 0;//VEH_DEFAULT_HOVER_HEIGHT;	//if 0, it's a ground vehicle
+	vehicle->hoverStrength = 0;//VEH_DEFAULT_HOVER_STRENGTH;//how hard it pushes off ground when less than hover height... causes "bounce", like shocks
+	vehicle->waterProof = qtrue;						//can drive underwater if it has to
+	vehicle->bouyancy = 1.0f;							//when in water, how high it floats (1 is neutral bouyancy)
+	vehicle->fuelMax = 1000;							//how much fuel it can hold (capacity)
+	vehicle->fuelRate = 1;								//how quickly is uses up fuel
+	vehicle->visibility = VEH_DEFAULT_VISIBILITY;		//radius for sight alerts
+	vehicle->loudness = VEH_DEFAULT_LOUDNESS;			//radius for sound alerts
+	vehicle->explosionRadius = VEH_DEFAULT_EXP_RAD;
+	vehicle->explosionDamage = VEH_DEFAULT_EXP_DMG;
+	vehicle->maxPassengers = 0;
+
+	//new stuff
+	vehicle->hideRider = qfalse;						// rider (and passengers?) should not be drawn
+	vehicle->killRiderOnDeath = qfalse;					//if rider is on vehicle when it dies, they should die
+	vehicle->flammable = qfalse;						//whether or not the vehicle should catch on fire before it explodes
+	vehicle->explosionDelay = 0;						//how long the vehicle should be on fire/dying before it explodes
+	//camera stuff
+	vehicle->cameraOverride = qfalse;					//whether or not to use all of the following 3rd person camera override values
+	vehicle->cameraRange = 0.0f;						//how far back the camera should be - normal is 80
+	vehicle->cameraVertOffset = 0.0f;					//how high over the vehicle origin the camera should be - normal is 16
+	vehicle->cameraHorzOffset = 0.0f;					//how far to left/right (negative/positive) of of the vehicle origin the camera should be - normal is 0
+	vehicle->cameraPitchOffset = 0.0f;					//a modifier on the camera's pitch (up/down angle) to the vehicle - normal is 0
+	vehicle->cameraFOV = 0.0f;							//third person camera FOV, default is 80
+	vehicle->cameraAlpha = qfalse;						//fade out the vehicle if it's in the way of the crosshair
+*/
+}
+
+void BG_VehicleClampData( vehicleInfo_t *vehicle )
+{//sanity check and clamp the vehicle's data
+	int		i;
+
+	for ( i = 0; i < 3; i++ )
+	{
+		if ( vehicle->centerOfGravity[i] > 1.0f )
+		{
+			vehicle->centerOfGravity[i] = 1.0f;
+		}
+		else if ( vehicle->centerOfGravity[i] < -1.0f )
+		{
+			vehicle->centerOfGravity[i] = -1.0f;
+		}
+	}
+
+	// Validate passenger max.
+	if ( vehicle->maxPassengers > VEH_MAX_PASSENGERS )
+	{
+		vehicle->maxPassengers = VEH_MAX_PASSENGERS;
+	}
+	else if ( vehicle->maxPassengers < 0 )
+	{
+		vehicle->maxPassengers = 0;
+	}
+}
+
+static qboolean BG_ParseVehicleParm( vehicleInfo_t *vehicle, char *parmName, char *pValue )
+{
+	int		i;
+	vec3_t	vec;
+	byte	*b = (byte *)vehicle;
+	int		_iFieldsRead = 0;
+	vehicleType_t vehType;
+	char value[1024];
+
+	Q_strncpyz( value, pValue, sizeof(value) );
+
+	// Loop through possible parameters
+	for ( i = 0; vehicleFields[i].ofs != -1; i++ )
+	{
+		if ( !Q_stricmp( vehicleFields[i].name, parmName ) )
+		{
+			// found it
+			switch( vehicleFields[i].type ) 
+			{
+			case VF_IGNORE:
+				break;
+			case VF_INT:
+				*(int *)(b+vehicleFields[i].ofs) = atoi(value);
+				break;
+			case VF_FLOAT:
+				*(float *)(b+vehicleFields[i].ofs) = atof(value);
+				break;
+			case VF_LSTRING:	// string on disk, pointer in memory, TAG_LEVEL
+				if (!*(char **)(b+vehicleFields[i].ofs))
+				{ //just use 128 bytes in case we want to write over the string
+#ifdef _JK2MP
+					*(char **)(b+vehicleFields[i].ofs) = (char *)BG_Alloc(128);//(char *)BG_Alloc(strlen(value));
+					strcpy(*(char **)(b+vehicleFields[i].ofs), value);
+#else
+					(*(char **)(b+vehicleFields[i].ofs)) = G_NewString( value );
+#endif
+				}
+				
+				break;
+			case VF_VECTOR:
+				_iFieldsRead = sscanf (value, "%f %f %f", &vec[0], &vec[1], &vec[2]);
+				assert(_iFieldsRead==3 );
+				if (_iFieldsRead!=3)
+				{
+					Com_Printf (S_COLOR_YELLOW"BG_ParseVehicleParm: VEC3 sscanf() failed to read 3 floats ('angle' key bug?)\n");
+				}
+				((float *)(b+vehWeaponFields[i].ofs))[0] = vec[0];
+				((float *)(b+vehWeaponFields[i].ofs))[1] = vec[1];
+				((float *)(b+vehWeaponFields[i].ofs))[2] = vec[2];
+				break;
+			case VF_BOOL:
+				*(qboolean *)(b+vehicleFields[i].ofs) = (qboolean)(atof(value)!=0);
+				break;
+			case VF_VEHTYPE:
+				vehType = (vehicleType_t)GetIDForString( VehicleTable, value );
+				*(vehicleType_t *)(b+vehicleFields[i].ofs) = vehType;
+				break;
+			case VF_ANIM:
+				{
+					int anim = GetIDForString( animTable, value );
+					*(int *)(b+vehicleFields[i].ofs) = anim;
+				}
+				break;
+			case VF_WEAPON:	// take string, resolve into index into VehWeaponParms
+				*(int *)(b+vehicleFields[i].ofs) = VEH_VehWeaponIndexForName( value );
+				break;
+			case VF_MODEL:	// take the string, get the G_ModelIndex
+#ifdef QAGAME
+				*(int *)(b+vehicleFields[i].ofs) = G_ModelIndex( value );
+#else
+				*(int *)(b+vehicleFields[i].ofs) = trap_R_RegisterModel( value );
+#endif
+				break;
+			case VF_MODEL_CLIENT:	// (MP cgame only) take the string, get the G_ModelIndex
+#ifndef _JK2MP
+				*(int *)(b+vehicleFields[i].ofs) = G_ModelIndex( value );
+#elif QAGAME
+				//*(int *)(b+vehicleFields[i].ofs) = G_ModelIndex( value );
+#else
+				*(int *)(b+vehicleFields[i].ofs) = trap_R_RegisterModel( value );
+#endif
+				break;
+			case VF_EFFECT:	// take the string, get the G_EffectIndex
+#ifdef QAGAME
+				*(int *)(b+vehicleFields[i].ofs) = G_EffectIndex( value );
+#elif CGAME
+				*(int *)(b+vehicleFields[i].ofs) = trap_FX_RegisterEffect( value );
+#endif
+				break;
+			case VF_EFFECT_CLIENT:	// (MP cgame only) take the string, get the G_EffectIndex
+#ifndef _JK2MP
+				*(int *)(b+vehicleFields[i].ofs) = G_EffectIndex( value );
+#elif QAGAME
+				//*(int *)(b+vehicleFields[i].ofs) = G_EffectIndex( value );
+#elif CGAME
+				*(int *)(b+vehicleFields[i].ofs) = trap_FX_RegisterEffect( value );
+#endif
+				break;
+			case VF_SHADER:	// (cgame only) take the string, call trap_R_RegisterShader
+#ifdef WE_ARE_IN_THE_UI
+				*(int *)(b+vehicleFields[i].ofs) = trap_R_RegisterShaderNoMip( value );
+#elif CGAME
+				*(int *)(b+vehicleFields[i].ofs) = trap_R_RegisterShader( value );
+#endif
+				break;
+			case VF_SHADER_NOMIP:// (cgame only) take the string, call trap_R_RegisterShaderNoMip
+#ifndef QAGAME
+				*(int *)(b+vehicleFields[i].ofs) = trap_R_RegisterShaderNoMip( value );
+#endif
+				break;
+			case VF_SOUND:	// take the string, get the G_SoundIndex
+#ifdef QAGAME
+				*(int *)(b+vehicleFields[i].ofs) = G_SoundIndex( value );
+#else
+				*(int *)(b+vehicleFields[i].ofs) = trap_S_RegisterSound( value );
+#endif
+				break;
+			case VF_SOUND_CLIENT:	// (MP cgame only) take the string, get the G_SoundIndex
+#ifndef _JK2MP
+				*(int *)(b+vehicleFields[i].ofs) = G_SoundIndex( value );
+#elif QAGAME
+				//*(int *)(b+vehicleFields[i].ofs) = G_SoundIndex( value );
+#else
+				*(int *)(b+vehicleFields[i].ofs) = trap_S_RegisterSound( value );
+#endif
+				break;
+			default:
+				//Unknown type?
+				return qfalse;
+				break;
+			}
+			break;
+		}
+	}
+	if ( vehicleFields[i].ofs == -1 )
+	{
+        return qfalse;
+	}
+	else
+	{
+		return qtrue;
+	}
+}
+
+int VEH_LoadVehicle( const char *vehicleName )
+{//load up specified vehicle and save in array: g_vehicleInfo
+	const char	*token;
+	//we'll assume that no parm name is longer than 128
+	char		parmName[128] = { 0 };
+	char		weap1[128] = { 0 }, weap2[128] = { 0 };
+	char		weapMuzzle1[128] = { 0 };
+	char		weapMuzzle2[128] = { 0 };
+	char		weapMuzzle3[128] = { 0 };
+	char		weapMuzzle4[128] = { 0 };
+	char		weapMuzzle5[128] = { 0 };
+	char		weapMuzzle6[128] = { 0 };
+	char		weapMuzzle7[128] = { 0 };
+	char		weapMuzzle8[128] = { 0 };
+	char		weapMuzzle9[128] = { 0 };
+	char		weapMuzzle10[128] = { 0 };
+	char		*value = NULL;
+	const char	*p = NULL;
+	vehicleInfo_t	*vehicle = NULL;
+
+	// Load the vehicle parms if no vehicles have been loaded yet.
+	if ( numVehicles == 0 ) 
+	{
+		BG_VehicleLoadParms();
+	}
+
+	//try to parse data out
+	p = VehicleParms;
+
+#ifdef _JK2MP
+	COM_BeginParseSession("vehicles");
+#else
+	COM_BeginParseSession();
+#endif
+
+	vehicle = &g_vehicleInfo[numVehicles];
+	// look for the right vehicle
+	while ( p ) 
+	{
+		token = COM_ParseExt( &p, qtrue );
+		if ( token[0] == 0 )
+		{
+			return VEHICLE_NONE;
+		}
+
+		if ( !Q_stricmp( token, vehicleName ) ) 
+		{
+			break;
+		}
+
+		SkipBracedSection( &p );
+	}
+
+	if ( !p )
+	{
+		return VEHICLE_NONE;
+	}
+
+	token = COM_ParseExt( &p, qtrue );
+	if ( token[0] == 0 )
+	{//barf
+		return VEHICLE_NONE;
+	}
+
+	if ( Q_stricmp( token, "{" ) != 0 ) 
+	{
+		return VEHICLE_NONE;
+	}
+	
+	BG_VehicleSetDefaults( vehicle );
+	// parse the vehicle info block
+	while ( 1 ) 
+	{
+		SkipRestOfLine( &p );
+		token = COM_ParseExt( &p, qtrue );
+		if ( !token[0] ) 
+		{
+			Com_Printf( S_COLOR_RED"ERROR: unexpected EOF while parsing Vehicle '%s'\n", vehicleName );
+			return VEHICLE_NONE;
+		}
+
+		if ( !Q_stricmp( token, "}" ) ) 
+		{
+			break;
+		}
+		Q_strncpyz( parmName, token, sizeof(parmName) );
+		value = COM_ParseExt( &p, qtrue );
+		if ( !value || !value[0] )
+		{
+			Com_Printf( S_COLOR_RED"ERROR: Vehicle token '%s' has no value!\n", parmName );
+		}
+		else if ( Q_stricmp( "weap1", parmName ) == 0 )
+		{//hmm, store this off because we don't want to call another one of these text parsing routines while we're in the middle of one...
+			Q_strncpyz( weap1, value, sizeof(weap1) );
+		}
+		else if ( Q_stricmp( "weap2", parmName ) == 0 )
+		{//hmm, store this off because we don't want to call another one of these text parsing routines while we're in the middle of one...
+			Q_strncpyz( weap2, value, sizeof(weap2) );
+		}
+		else if ( Q_stricmp( "weapMuzzle1", parmName ) == 0 )
+		{//hmm, store this off because we don't want to call another one of these text parsing routines while we're in the middle of one...
+			Q_strncpyz( weapMuzzle1, value, sizeof(weapMuzzle1) );
+		}
+		else if ( Q_stricmp( "weapMuzzle2", parmName ) == 0 )
+		{//hmm, store this off because we don't want to call another one of these text parsing routines while we're in the middle of one...
+			Q_strncpyz( weapMuzzle2, value, sizeof(weapMuzzle2) );
+		}
+		else if ( Q_stricmp( "weapMuzzle3", parmName ) == 0 )
+		{//hmm, store this off because we don't want to call another one of these text parsing routines while we're in the middle of one...
+			Q_strncpyz( weapMuzzle3, value, sizeof(weapMuzzle3) );
+		}
+		else if ( Q_stricmp( "weapMuzzle4", parmName ) == 0 )
+		{//hmm, store this off because we don't want to call another one of these text parsing routines while we're in the middle of one...
+			Q_strncpyz( weapMuzzle4, value, sizeof(weapMuzzle4) );
+		}
+		else if ( Q_stricmp( "weapMuzzle5", parmName ) == 0 )
+		{//hmm, store this off because we don't want to call another one of these text parsing routines while we're in the middle of one...
+			Q_strncpyz( weapMuzzle5, value, sizeof(weapMuzzle5) );
+		}
+		else if ( Q_stricmp( "weapMuzzle6", parmName ) == 0 )
+		{//hmm, store this off because we don't want to call another one of these text parsing routines while we're in the middle of one...
+			Q_strncpyz( weapMuzzle6, value, sizeof(weapMuzzle6) );
+		}
+		else if ( Q_stricmp( "weapMuzzle7", parmName ) == 0 )
+		{//hmm, store this off because we don't want to call another one of these text parsing routines while we're in the middle of one...
+			Q_strncpyz( weapMuzzle7, value, sizeof(weapMuzzle7) );
+		}
+		else if ( Q_stricmp( "weapMuzzle8", parmName ) == 0 )
+		{//hmm, store this off because we don't want to call another one of these text parsing routines while we're in the middle of one...
+			Q_strncpyz( weapMuzzle8, value, sizeof(weapMuzzle8) );
+		}
+		else if ( Q_stricmp( "weapMuzzle9", parmName ) == 0 )
+		{//hmm, store this off because we don't want to call another one of these text parsing routines while we're in the middle of one...
+			Q_strncpyz( weapMuzzle9, value, sizeof(weapMuzzle9) );
+		}
+		else if ( Q_stricmp( "weapMuzzle10", parmName ) == 0 )
+		{//hmm, store this off because we don't want to call another one of these text parsing routines while we're in the middle of one...
+			Q_strncpyz( weapMuzzle10, value, sizeof(weapMuzzle10) );
+		}
+		else
+		{
+			if ( !BG_ParseVehicleParm( vehicle, parmName, value ) )
+			{
+#ifndef FINAL_BUILD
+				Com_Printf( S_COLOR_RED"ERROR: Unknown Vehicle key/value pair '%s', '%s'!\n", parmName, value );
+#endif
+			}
+		}
+	}
+	//NOW: if we have any weapons, go ahead and load them
+	if ( weap1[0] )
+	{
+		if ( !BG_ParseVehicleParm( vehicle, "weap1", weap1 ) )
+		{
+#ifndef FINAL_BUILD
+			Com_Printf( S_COLOR_RED"ERROR: Unknown Vehicle key/value pair 'weap1', '%s'!\n", weap1 );
+#endif
+		}
+	}
+	if ( weap2[0] )
+	{
+		if ( !BG_ParseVehicleParm( vehicle, "weap2", weap2 ) )
+		{
+#ifndef FINAL_BUILD
+			Com_Printf( S_COLOR_RED"ERROR: Unknown Vehicle key/value pair 'weap2', '%s'!\n", weap2 );
+#endif
+		}
+	}
+	if ( weapMuzzle1[0] )
+	{
+		if ( !BG_ParseVehicleParm( vehicle, "weapMuzzle1", weapMuzzle1 ) )
+		{
+#ifndef FINAL_BUILD
+			Com_Printf( S_COLOR_RED"ERROR: Unknown Vehicle key/value pair 'weapMuzzle1', '%s'!\n", weapMuzzle1 );
+#endif
+		}
+	}
+	if ( weapMuzzle2[0] )
+	{
+		if ( !BG_ParseVehicleParm( vehicle, "weapMuzzle2", weapMuzzle2 ) )
+		{
+#ifndef FINAL_BUILD
+			Com_Printf( S_COLOR_RED"ERROR: Unknown Vehicle key/value pair 'weapMuzzle2', '%s'!\n", weapMuzzle2 );
+#endif
+		}
+	}
+	if ( weapMuzzle3[0] )
+	{
+		if ( !BG_ParseVehicleParm( vehicle, "weapMuzzle3", weapMuzzle3 ) )
+		{
+#ifndef FINAL_BUILD
+			Com_Printf( S_COLOR_RED"ERROR: Unknown Vehicle key/value pair 'weapMuzzle3', '%s'!\n", weapMuzzle3 );
+#endif
+		}
+	}
+	if ( weapMuzzle4[0] )
+	{
+		if ( !BG_ParseVehicleParm( vehicle, "weapMuzzle4", weapMuzzle4 ) )
+		{
+#ifndef FINAL_BUILD
+			Com_Printf( S_COLOR_RED"ERROR: Unknown Vehicle key/value pair 'weapMuzzle4', '%s'!\n", weapMuzzle4 );
+#endif
+		}
+	}
+	if ( weapMuzzle5[0] )
+	{
+		if ( !BG_ParseVehicleParm( vehicle, "weapMuzzle5", weapMuzzle5 ) )
+		{
+#ifndef FINAL_BUILD
+			Com_Printf( S_COLOR_RED"ERROR: Unknown Vehicle key/value pair 'weapMuzzle5', '%s'!\n", weapMuzzle5 );
+#endif
+		}
+	}
+	if ( weapMuzzle6[0] )
+	{
+		if ( !BG_ParseVehicleParm( vehicle, "weapMuzzle6", weapMuzzle6 ) )
+		{
+#ifndef FINAL_BUILD
+			Com_Printf( S_COLOR_RED"ERROR: Unknown Vehicle key/value pair 'weapMuzzle6', '%s'!\n", weapMuzzle6 );
+#endif
+		}
+	}
+	if ( weapMuzzle7[0] )
+	{
+		if ( !BG_ParseVehicleParm( vehicle, "weapMuzzle7", weapMuzzle7 ) )
+		{
+#ifndef FINAL_BUILD
+			Com_Printf( S_COLOR_RED"ERROR: Unknown Vehicle key/value pair 'weapMuzzle7', '%s'!\n", weapMuzzle7 );
+#endif
+		}
+	}
+	if ( weapMuzzle8[0] )
+	{
+		if ( !BG_ParseVehicleParm( vehicle, "weapMuzzle8", weapMuzzle8 ) )
+		{
+#ifndef FINAL_BUILD
+			Com_Printf( S_COLOR_RED"ERROR: Unknown Vehicle key/value pair 'weapMuzzle8', '%s'!\n", weapMuzzle8 );
+#endif
+		}
+	}
+	if ( weapMuzzle9[0] )
+	{
+		if ( !BG_ParseVehicleParm( vehicle, "weapMuzzle9", weapMuzzle9 ) )
+		{
+#ifndef FINAL_BUILD
+			Com_Printf( S_COLOR_RED"ERROR: Unknown Vehicle key/value pair 'weapMuzzle9', '%s'!\n", weapMuzzle9 );
+#endif
+		}
+	}
+	if ( weapMuzzle10[0] )
+	{
+		if ( !BG_ParseVehicleParm( vehicle, "weapMuzzle10", weapMuzzle10 ) )
+		{
+#ifndef FINAL_BUILD
+			Com_Printf( S_COLOR_RED"ERROR: Unknown Vehicle key/value pair 'weapMuzzle10', '%s'!\n", weapMuzzle10 );
+#endif
+		}
+	}
+
+#ifdef _JK2MP
+	//let's give these guys some defaults
+	if (!vehicle->health_front)
+	{
+		vehicle->health_front = vehicle->armor/4;
+	}
+	if (!vehicle->health_back)
+	{
+		vehicle->health_back = vehicle->armor/4;
+	}
+	if (!vehicle->health_right)
+	{
+		vehicle->health_right = vehicle->armor/4;
+	}
+	if (!vehicle->health_left)
+	{
+		vehicle->health_left = vehicle->armor/4;
+	}
+#endif
+
+	if ( vehicle->model )
+	{
+#ifdef QAGAME
+		vehicle->modelIndex = G_ModelIndex( va( "models/players/%s/model.glm", vehicle->model ) );
+#else
+		vehicle->modelIndex = trap_R_RegisterModel( va( "models/players/%s/model.glm", vehicle->model ) );
+#endif
+	}
+
+#ifndef _JK2MP
+	//SP
+	if ( vehicle->skin
+		&& vehicle->skin[0] )
+	{
+		ratl::string_vs<256>			skins(vehicle->skin);
+		for (ratl::string_vs<256>::tokenizer i = skins.begin("|"); i!=skins.end(); i++)
+		{
+			//this will just turn off surfs if there is a *off shader on a surf, the skin will actually get thrown away when cgame starts
+			gi.RE_RegisterSkin( va( "models/players/%s/model_%s.skin", vehicle->model, *i) );
+			//this is for the server-side call, it will propgate down to cgame with configstrings and register it at the same time as all the other skins for ghoul2 models
+			G_SkinIndex( va( "models/players/%s/model_%s.skin", vehicle->model, *i) );
+		}
+	}
+	else
+	{
+		//this will just turn off surfs if there is a *off shader on a surf, the skin will actually get thrown away when cgame starts
+		gi.RE_RegisterSkin( va( "models/players/%s/model_default.skin", vehicle->model) );
+		//this is for the server-side call, it will propgate down to cgame with configstrings and register it at the same time as all the other skins for ghoul2 models
+		G_SkinIndex( va( "models/players/%s/model_default.skin", vehicle->model) );
+	}
+#else
+#ifndef QAGAME
+	if ( vehicle->skin
+		&& vehicle->skin[0] )
+	{
+		trap_R_RegisterSkin( va( "models/players/%s/model_%s.skin", vehicle->model, vehicle->skin) );
+	}
+#endif
+#endif
+	//sanity check and clamp the vehicle's data
+	BG_VehicleClampData( vehicle );
+	// Setup the shared function pointers.
+	BG_SetSharedVehicleFunctions( vehicle );
+	//misc effects... FIXME: not even used in MP, are they?
+	if ( vehicle->explosionDamage )
+	{
+#ifdef QAGAME
+		G_EffectIndex( "ships/ship_explosion_mark" );
+#elif CGAME
+		trap_FX_RegisterEffect( "ships/ship_explosion_mark" );
+#endif
+	}
+	if ( vehicle->flammable )
+	{
+#ifdef QAGAME
+		G_SoundIndex( "sound/vehicles/common/fire_lp.wav" );
+#elif CGAME
+		trap_S_RegisterSound( "sound/vehicles/common/fire_lp.wav" );
+#else
+		trap_S_RegisterSound( "sound/vehicles/common/fire_lp.wav" );
+#endif
+	}
+
+	if ( vehicle->hoverHeight > 0 )
+	{
+#ifndef _JK2MP
+		G_EffectIndex( "ships/swoop_dust" );
+#elif QAGAME
+		G_EffectIndex( "ships/swoop_dust" );
+#elif CGAME
+		trap_FX_RegisterEffect( "ships/swoop_dust" );
+#endif
+	}
+
+#ifdef QAGAME
+	G_EffectIndex( "volumetric/black_smoke" );
+	G_EffectIndex( "ships/fire" );
+	G_SoundIndex( "sound/vehicles/common/release.wav" );
+#elif CGAME
+	trap_R_RegisterShader( "gfx/menus/radar/bracket" );
+	trap_R_RegisterShaderNoMip( "gfx/menus/radar/asteroid" );
+	trap_S_RegisterSound( "sound/vehicles/common/impactalarm.wav" );
+	trap_S_RegisterSound( "sound/vehicles/common/linkweaps.wav" );
+	trap_S_RegisterSound( "sound/vehicles/common/release.wav" );
+	trap_FX_RegisterEffect("effects/ships/dest_burning.efx");
+	trap_FX_RegisterEffect("effects/ships/dest_destroyed.efx");
+	trap_FX_RegisterEffect( "volumetric/black_smoke" );
+	trap_FX_RegisterEffect( "ships/fire" );
+	trap_FX_RegisterEffect("ships/hyperspace_stars");
+
+	if ( vehicle->hideRider )
+	{
+		trap_R_RegisterShaderNoMip( "gfx/menus/radar/circle_base" );
+		trap_R_RegisterShaderNoMip( "gfx/menus/radar/circle_base_frame" );
+		trap_R_RegisterShaderNoMip( "gfx/menus/radar/circle_base_shield" );
+	}
+#endif
+
+	return (numVehicles++);
+}
+
+int VEH_VehicleIndexForName( const char *vehicleName )
+{
+	int v;
+	if ( !vehicleName || !vehicleName[0] )
+	{
+		Com_Printf( S_COLOR_RED"ERROR: Trying to read Vehicle with no name!\n" );
+		return VEHICLE_NONE;
+	}
+	for (  v = VEHICLE_BASE; v < numVehicles; v++ )
+	{
+		if ( g_vehicleInfo[v].name
+			&& Q_stricmp( g_vehicleInfo[v].name, vehicleName ) == 0 )
+		{//already loaded this one
+			return v;
+		}
+	}
+	//haven't loaded it yet
+	if ( v >= MAX_VEHICLES )
+	{//no more room!
+		Com_Printf( S_COLOR_RED"ERROR: Too many Vehicles (max 64), aborting load on %s!\n", vehicleName );
+		return VEHICLE_NONE;
+	}
+	//we have room for another one, load it up and return the index
+	//HMM... should we not even load the .veh file until we want to?
+	v = VEH_LoadVehicle( vehicleName ); 
+ 	if ( v == VEHICLE_NONE )
+	{
+		Com_Printf( S_COLOR_RED"ERROR: Could not find Vehicle %s!\n", vehicleName );
+	}
+	return v;
+}
+
+void BG_VehWeaponLoadParms( void ) 
+{
+	int			len, totallen, vehExtFNLen, mainBlockLen, fileCnt, i;
+	char		*holdChar, *marker;
+	char		vehWeaponExtensionListBuf[2048];			//	The list of file names read in
+	fileHandle_t	f;
+	char		*tempReadBuffer;
+
+	len = 0;
+
+	//remember where to store the next one
+	totallen = mainBlockLen = len;
+	marker = VehWeaponParms+totallen;
+	*marker = 0;
+
+	//now load in the extra .veh extensions
+#ifdef _JK2MP
+	fileCnt = trap_FS_GetFileList("ext_data/vehicles/weapons", ".vwp", vehWeaponExtensionListBuf, sizeof(vehWeaponExtensionListBuf) );
+#else
+	fileCnt = gi.FS_GetFileList("ext_data/vehicles/weapons", ".vwp", vehWeaponExtensionListBuf, sizeof(vehWeaponExtensionListBuf) );
+#endif
+
+	holdChar = vehWeaponExtensionListBuf;
+
+#ifdef _JK2MP
+	tempReadBuffer = (char *)BG_TempAlloc(MAX_VEH_WEAPON_DATA_SIZE);
+#else
+	tempReadBuffer = (char *)gi.Malloc( MAX_VEH_WEAPON_DATA_SIZE, TAG_G_ALLOC, qtrue );
+#endif
+	
+	// NOTE: Not use TempAlloc anymore...
+	//Make ABSOLUTELY CERTAIN that BG_Alloc/etc. is not used before
+	//the subsequent BG_TempFree or the pool will be screwed. 
+
+	for ( i = 0; i < fileCnt; i++, holdChar += vehExtFNLen + 1 ) 
+	{
+		vehExtFNLen = strlen( holdChar );
+
+//		Com_Printf( "Parsing %s\n", holdChar );
+
+#ifdef _JK2MP
+		len = trap_FS_FOpenFile(va( "ext_data/vehicles/weapons/%s", holdChar), &f, FS_READ);
+#else
+//		len = gi.FS_ReadFile( va( "ext_data/vehicles/weapons/%s", holdChar), (void **) &buffer );
+		len = gi.FS_FOpenFile(va( "ext_data/vehicles/weapons/%s", holdChar), &f, FS_READ);
+#endif
+
+		if ( len == -1 ) 
+		{
+			Com_Printf( "error reading file\n" );
+		}
+		else
+		{
+#ifdef _JK2MP
+			trap_FS_Read(tempReadBuffer, len, f);
+			tempReadBuffer[len] = 0;
+#else
+			gi.FS_Read(tempReadBuffer, len, f);
+			tempReadBuffer[len] = 0;
+#endif
+
+			// Don't let it end on a } because that should be a stand-alone token.
+			if ( totallen && *(marker-1) == '}' )
+			{
+				strcat( marker, " " );
+				totallen++;
+				marker++; 
+			}
+
+			if ( totallen + len >= MAX_VEH_WEAPON_DATA_SIZE ) {
+				Com_Error(ERR_DROP, "Vehicle Weapon extensions (*.vwp) are too large" );
+			}
+			strcat( marker, tempReadBuffer );
+#ifdef _JK2MP
+			trap_FS_FCloseFile( f );
+#else
+			gi.FS_FCloseFile( f );
+#endif
+
+			totallen += len;
+			marker = VehWeaponParms+totallen;
+		}
+	}
+
+#ifdef _JK2MP
+	BG_TempFree(MAX_VEH_WEAPON_DATA_SIZE);
+#else
+	gi.Free(tempReadBuffer);	tempReadBuffer = NULL;
+#endif
+}
+
+void BG_VehicleLoadParms( void ) 
+{//HMM... only do this if there's a vehicle on the level?
+	int			len, totallen, vehExtFNLen, mainBlockLen, fileCnt, i;
+//	const char	*filename = "ext_data/vehicles.dat";
+	char		*holdChar, *marker;
+	char		vehExtensionListBuf[2048];			//	The list of file names read in
+	fileHandle_t	f;
+	char		*tempReadBuffer;
+
+	len = 0;
+
+	//remember where to store the next one
+	totallen = mainBlockLen = len;
+	marker = VehicleParms+totallen;
+	*marker = 0;
+
+	//now load in the extra .veh extensions
+#ifdef _JK2MP
+	fileCnt = trap_FS_GetFileList("ext_data/vehicles", ".veh", vehExtensionListBuf, sizeof(vehExtensionListBuf) );
+#else
+	fileCnt = gi.FS_GetFileList("ext_data/vehicles", ".veh", vehExtensionListBuf, sizeof(vehExtensionListBuf) );
+#endif
+
+	holdChar = vehExtensionListBuf;
+
+#ifdef _JK2MP
+	tempReadBuffer = (char *)BG_TempAlloc(MAX_VEHICLE_DATA_SIZE);
+#else
+	tempReadBuffer = (char *)gi.Malloc( MAX_VEHICLE_DATA_SIZE, TAG_G_ALLOC, qtrue );
+#endif
+	
+	// NOTE: Not use TempAlloc anymore...
+	//Make ABSOLUTELY CERTAIN that BG_Alloc/etc. is not used before
+	//the subsequent BG_TempFree or the pool will be screwed. 
+
+	for ( i = 0; i < fileCnt; i++, holdChar += vehExtFNLen + 1 ) 
+	{
+		vehExtFNLen = strlen( holdChar );
+
+//		Com_Printf( "Parsing %s\n", holdChar );
+
+#ifdef _JK2MP
+		len = trap_FS_FOpenFile(va( "ext_data/vehicles/%s", holdChar), &f, FS_READ);
+#else
+//		len = gi.FS_ReadFile( va( "ext_data/vehicles/%s", holdChar), (void **) &buffer );
+		len = gi.FS_FOpenFile(va( "ext_data/vehicles/%s", holdChar), &f, FS_READ);
+#endif
+
+		if ( len == -1 ) 
+		{
+			Com_Printf( "error reading file\n" );
+		}
+		else
+		{
+#ifdef _JK2MP
+			trap_FS_Read(tempReadBuffer, len, f);
+			tempReadBuffer[len] = 0;
+#else
+			gi.FS_Read(tempReadBuffer, len, f);
+			tempReadBuffer[len] = 0;
+#endif
+
+			// Don't let it end on a } because that should be a stand-alone token.
+			if ( totallen && *(marker-1) == '}' )
+			{
+				strcat( marker, " " );
+				totallen++;
+				marker++; 
+			}
+
+			if ( totallen + len >= MAX_VEHICLE_DATA_SIZE ) {
+				Com_Error(ERR_DROP, "Vehicle extensions (*.veh) are too large" );
+			}
+			strcat( marker, tempReadBuffer );
+#ifdef _JK2MP
+			trap_FS_FCloseFile( f );
+#else
+			gi.FS_FCloseFile( f );
+#endif
+
+			totallen += len;
+			marker = VehicleParms+totallen;
+		}
+	}
+
+#ifdef _JK2MP
+	BG_TempFree(MAX_VEHICLE_DATA_SIZE);
+#else
+	gi.Free(tempReadBuffer);	tempReadBuffer = NULL;
+#endif
+	
+	numVehicles = 1;//first one is null/default
+	//set the first vehicle to default data
+	BG_VehicleSetDefaults( &g_vehicleInfo[VEHICLE_BASE] );
+	//sanity check and clamp the vehicle's data
+	BG_VehicleClampData( &g_vehicleInfo[VEHICLE_BASE] );
+	// Setup the shared function pointers.
+	BG_SetSharedVehicleFunctions( &g_vehicleInfo[VEHICLE_BASE] );
+
+	//Load the Vehicle Weapons data, too
+	BG_VehWeaponLoadParms();
+}
+
+int BG_VehicleGetIndex( const char *vehicleName )
+{
+	return (VEH_VehicleIndexForName( vehicleName ));
+}
+
+//We get the vehicle name passed in as modelname
+//with a $ in front of it.
+//we are expected to then get the model for the
+//vehicle and stomp over modelname with it.
+void BG_GetVehicleModelName(char *modelname)
+{
+	char *vehName = &modelname[1];
+	int vIndex = BG_VehicleGetIndex(vehName);
+	assert(modelname[0] == '$');
+	
+	if (vIndex == VEHICLE_NONE)
+	{
+		Com_Error(ERR_DROP, "BG_GetVehicleModelName:  couldn't find vehicle %s", vehName);
+	}
+
+    strcpy(modelname, g_vehicleInfo[vIndex].model);	
+}
+
+void BG_GetVehicleSkinName(char *skinname)
+{
+	char *vehName = &skinname[1];
+	int vIndex = BG_VehicleGetIndex(vehName);
+	assert(skinname[0] == '$');
+	
+	if (vIndex == VEHICLE_NONE)
+	{
+		Com_Error(ERR_DROP, "BG_GetVehicleSkinName:  couldn't find vehicle %s", vehName);
+	}
+
+    if ( !g_vehicleInfo[vIndex].skin 
+		|| !g_vehicleInfo[vIndex].skin[0] )
+	{
+		skinname[0] = 0;
+	}
+	else
+	{
+		strcpy(skinname, g_vehicleInfo[vIndex].skin);	
+	}
+}
+
+#ifdef _JK2MP
+#ifndef WE_ARE_IN_THE_UI
+//so cgame can assign the function pointer for the vehicle attachment without having to
+//bother with all the other funcs that don't really exist cgame-side.
+extern int BG_GetTime(void);
+extern int trap_G2API_AddBolt(void *ghoul2, int modelIndex, const char *boneName);
+extern qboolean trap_G2API_GetBoltMatrix(void *ghoul2, const int modelIndex, const int boltIndex, mdxaBone_t *matrix,
+								const vec3_t angles, const vec3_t position, const int frameNum, qhandle_t *modelList, vec3_t scale);
+void AttachRidersGeneric( Vehicle_t *pVeh )
+{
+	// If we have a pilot, attach him to the driver tag.
+	if ( pVeh->m_pPilot )
+	{
+		mdxaBone_t boltMatrix;
+		vec3_t	yawOnlyAngles;
+		bgEntity_t *parent = pVeh->m_pParentEntity;
+		bgEntity_t *pilot = pVeh->m_pPilot;
+		int crotchBolt = trap_G2API_AddBolt(parent->ghoul2, 0, "*driver");
+
+		assert(parent->playerState);
+
+		VectorSet(yawOnlyAngles, 0, parent->playerState->viewangles[YAW], 0);
+
+		// Get the driver tag.
+		trap_G2API_GetBoltMatrix( parent->ghoul2, 0, crotchBolt, &boltMatrix,
+								yawOnlyAngles, parent->playerState->origin,
+								BG_GetTime(), NULL, parent->modelScale );
+		BG_GiveMeVectorFromMatrix( &boltMatrix, ORIGIN, pilot->playerState->origin );
+	}
+}
+#endif
+
+#include "../namespace_end.h"
+
+#endif // _JK2MP
+
diff --git a/codemp/game/bg_vehicles.h b/codemp/game/bg_vehicles.h
new file mode 100644
index 0000000..a2559f6
--- /dev/null
+++ b/codemp/game/bg_vehicles.h
@@ -0,0 +1,628 @@
+#ifndef __BG_VEHICLES_H
+#define __BG_VEHICLES_H
+
+#include "q_shared.h"
+
+typedef struct Vehicle_s Vehicle_t;
+typedef struct bgEntity_s bgEntity_t;
+
+typedef enum
+{
+	VH_NONE = 0,	//0 just in case anyone confuses VH_NONE and VEHICLE_NONE below
+	VH_WALKER,		//something you ride inside of, it walks like you, like an AT-ST
+	VH_FIGHTER,		//something you fly inside of, like an X-Wing or TIE fighter
+	VH_SPEEDER,		//something you ride on that hovers, like a speeder or swoop
+	VH_ANIMAL,		//animal you ride on top of that walks, like a tauntaun
+	VH_FLIER,		//animal you ride on top of that flies, like a giant mynoc?
+	VH_NUM_VEHICLES
+} vehicleType_t;
+
+typedef enum	
+{
+	WPOSE_NONE	= 0,
+	WPOSE_BLASTER,
+	WPOSE_SABERLEFT,
+	WPOSE_SABERRIGHT,
+} EWeaponPose;
+
+#include "../namespace_begin.h"
+extern stringID_table_t VehicleTable[VH_NUM_VEHICLES+1];
+#include "../namespace_end.h"
+
+//===========================================================================================================
+//START VEHICLE WEAPONS
+//===========================================================================================================
+typedef struct
+{
+//*** IMPORTANT!!! *** the number of variables in the vehWeaponStats_t struct (including all elements of arrays) must be reflected by NUM_VWEAP_PARMS!!!
+//*** IMPORTANT!!! *** vWeapFields table correponds to this structure!
+	char	*name;
+	qboolean	bIsProjectile;	//traceline or entity?
+	qboolean	bHasGravity;	//if a projectile, drops
+	qboolean	bIonWeapon;//disables ship shields and sends them out of control
+	qboolean	bSaberBlockable;//lightsabers can deflect this projectile
+	int		iMuzzleFX;	//index of Muzzle Effect
+	int		iModel;		//handle to the model used by this projectile
+	int		iShotFX;	//index of Shot Effect
+	int		iImpactFX;	//index of Impact Effect
+	int		iG2MarkShaderHandle;	//index of shader to use for G2 marks made on other models when hit by this projectile
+	float	fG2MarkSize;//size (diameter) of the ghoul2 mark
+	int		iLoopSound;	//index of loopSound
+	float	fSpeed;		//speed of projectile/range of traceline
+	float	fHoming;		//0.0 = not homing, 0.5 = half vel to targ, half cur vel, 1.0 = all vel to targ
+	int		iLockOnTime;	//0 = no lock time needed, else # of ms needed to lock on
+	int		iDamage;		//damage done when traceline or projectile directly hits target
+	int		iSplashDamage;//damage done to ents in splashRadius of end of traceline or projectile origin on impact
+	float	fSplashRadius;//radius that ent must be in to take splashDamage (linear fall-off)
+	int		iAmmoPerShot;	//how much "ammo" each shot takes
+	int		iHealth;		//if non-zero, projectile can be shot, takes this much damage before being destroyed
+	float	fWidth;		//width of traceline or bounding box of projecile (non-rotating!)
+	float	fHeight;		//height of traceline or bounding box of projecile (non-rotating!)
+	int		iLifeTime;	//removes itself after this amount of time
+	qboolean	bExplodeOnExpire;	//when iLifeTime is up, explodes rather than simply removing itself
+} vehWeaponInfo_t;
+//NOTE: this MUST stay up to date with the number of variables in the vehFields table!!!
+#define NUM_VWEAP_PARMS	24
+
+#define	VWFOFS(x) ((int)&(((vehWeaponInfo_t *)0)->x))
+
+#define MAX_VEH_WEAPONS	16	//sigh... no more than 16 different vehicle weapons
+#define VEH_WEAPON_BASE	0
+#define VEH_WEAPON_NONE	-1
+
+#include "../namespace_begin.h"
+extern vehWeaponInfo_t g_vehWeaponInfo[MAX_VEH_WEAPONS];
+extern int	numVehicleWeapons;
+#include "../namespace_end.h"
+
+//===========================================================================================================
+//END VEHICLE WEAPONS
+//===========================================================================================================
+
+#define		MAX_VEHICLE_MUZZLES			12
+#define		MAX_VEHICLE_EXHAUSTS		12
+#define		MAX_VEHICLE_WEAPONS			2
+#define		MAX_VEHICLE_TURRETS			2
+#define		MAX_VEHICLE_TURRET_MUZZLES	2
+
+typedef struct
+{
+	int			iWeapon;	//what vehWeaponInfo index to use
+	int			iDelay;		//delay between turret muzzle shots
+	int			iAmmoMax;	//how much ammo it has
+	int			iAmmoRechargeMS;	//how many MS between every point of recharged ammo
+	char		*yawBone;	//bone on ship that this turret uses to yaw
+	char		*pitchBone;	//bone on ship that this turret uses to pitch
+	int			yawAxis;	//axis on yawBone to which we should to apply the yaw angles
+	int			pitchAxis;	//axis on pitchBone to which we should to apply the pitch angles
+	float		yawClampLeft;	//how far the turret is allowed to turn left
+	float		yawClampRight;	//how far the turret is allowed to turn right
+	float		pitchClampUp;	//how far the turret is allowed to title up
+	float		pitchClampDown; //how far the turret is allowed to tilt down
+	int			iMuzzle[MAX_VEHICLE_TURRET_MUZZLES];//iMuzzle-1 = index of ship's muzzle to fire this turret's 1st and 2nd shots from
+	char		*gunnerViewTag;//Where to put the view origin of the gunner (name)
+	float		fTurnSpeed;	//how quickly the turret can turn
+	qboolean	bAI;	//whether or not the turret auto-targets enemies when it's not manned
+	qboolean	bAILead;//whether
+	float		fAIRange;	//how far away the AI will look for enemies
+	int			passengerNum;//which passenger, if any, has control of this turret (overrides AI)
+} turretStats_t;
+
+typedef struct
+{
+//*** IMPORTANT!!! *** See note at top of next structure!!! ***
+	// Weapon stuff.
+	int			ID;//index into the weapon data
+	// The delay between shots for each weapon.
+	int			delay;
+	// Whether or not all the muzzles for each weapon can be linked together (linked delay = weapon delay * number of muzzles linked!)
+	int			linkable;
+	// Whether or not to auto-aim the projectiles/tracelines at the thing under the crosshair when we fire
+	qboolean	aimCorrect;
+	//maximum ammo
+	int			ammoMax;
+	//ammo recharge rate - milliseconds per unit (minimum of 100, which is 10 ammo per second)
+	int			ammoRechargeMS;
+	//sound to play when out of ammo (plays default "no ammo" sound if none specified)
+	int			soundNoAmmo;
+} vehWeaponStats_t;
+
+typedef struct
+{
+//*** IMPORTANT!!! *** vehFields table correponds to this structure!
+	char		*name;	//unique name of the vehicle
+
+	//general data
+	vehicleType_t	type;	//what kind of vehicle
+	int			numHands;	//if 2 hands, no weapons, if 1 hand, can use 1-handed weapons, if 0 hands, can use 2-handed weapons
+	float		lookPitch;	//How far you can look up and down off the forward of the vehicle
+	float		lookYaw;	//How far you can look left and right off the forward of the vehicle
+	float		length;		//how long it is - used for body length traces when turning/moving?
+	float		width;		//how wide it is - used for body length traces when turning/moving?
+	float		height;		//how tall it is - used for body length traces when turning/moving?
+	vec3_t		centerOfGravity;//offset from origin: {forward, right, up} as a modifier on that dimension (-1.0f is all the way back, 1.0f is all the way forward)
+
+	//speed stats
+	float		speedMax;		//top speed
+	float		turboSpeed;		//turbo speed
+	float		speedMin;		//if < 0, can go in reverse
+	float		speedIdle;		//what speed it drifts to when no accel/decel input is given
+	float		accelIdle;		//if speedIdle > 0, how quickly it goes up to that speed
+	float		acceleration;	//when pressing on accelerator
+	float		decelIdle;		//when giving no input, how quickly it drops to speedIdle
+	float		throttleSticks;	//if true, speed stays at whatever you accel/decel to, unless you turbo or brake
+	float		strafePerc;		//multiplier on current speed for strafing.  If 1.0f, you can strafe at the same speed as you're going forward, 0.5 is half, 0 is no strafing
+
+	//handling stats
+	float		bankingSpeed;	//how quickly it pitches and rolls (not under player control)
+	float		rollLimit;		//how far it can roll to either side
+	float		pitchLimit;		//how far it can roll forward or backward
+	float		braking;		//when pressing on decelerator
+	float		mouseYaw;		// The mouse yaw override.
+	float		mousePitch;		// The mouse pitch override.
+	float		turningSpeed;	//how quickly you can turn
+	qboolean	turnWhenStopped;//whether or not you can turn when not moving
+	float		traction;		//how much your command input affects velocity
+	float		friction;		//how much velocity is cut on its own
+	float		maxSlope;		//the max slope that it can go up with control
+	qboolean	speedDependantTurning;//vehicle turns faster the faster it's going
+
+	//durability stats
+	int			mass;			//for momentum and impact force (player mass is 10)
+	int			armor;			//total points of damage it can take
+	int			shields;		//energy shield damage points
+	int			shieldRechargeMS;//energy shield milliseconds per point recharged
+	float		toughness;		//modifies incoming damage, 1.0 is normal, 0.5 is half, etc.  Simulates being made of tougher materials/construction
+	int			malfunctionArmorLevel;//when armor drops to or below this point, start malfunctioning
+	int			surfDestruction; //can parts of this thing be torn off on impact? -rww
+
+	//individual "area" health -rww
+	int			health_front;
+	int			health_back;
+	int			health_right;
+	int			health_left;
+
+	//visuals & sounds
+	char		*model;			//what model to use - if make it an NPC's primary model, don't need this?
+	char		*skin;			//what skin to use - if make it an NPC's primary model, don't need this?
+	int			g2radius;		//render radius for the ghoul2 model
+	int			riderAnim;		//what animation the rider uses
+	int			radarIconHandle;//what icon to show on radar in MP
+	int			dmgIndicFrameHandle;//what image to use for the frame of the damage indicator
+	int			dmgIndicShieldHandle;//what image to use for the shield of the damage indicator
+	int			dmgIndicBackgroundHandle;//what image to use for the background of the damage indicator
+	int			iconFrontHandle;//what image to use for the front of the ship on the damage indicator
+	int			iconBackHandle;	//what image to use for the back of the ship on the damage indicator
+	int			iconRightHandle;//what image to use for the right of the ship on the damage indicator
+	int			iconLeftHandle;	//what image to use for the left of the ship on the damage indicator
+	int			crosshairShaderHandle;//what image to use for the left of the ship on the damage indicator
+	int			shieldShaderHandle;//What shader to use when drawing the shield shell
+	char		*droidNPC;		//NPC to attach to *droidunit tag (if it exists in the model)
+
+	int			soundOn;		//sound to play when get on it
+	int			soundTakeOff;	//sound to play when ship takes off
+	int			soundEngineStart;//sound to play when ship's thrusters first activate
+	int			soundLoop;		//sound to loop while riding it
+	int			soundSpin;		//sound to loop while spiraling out of control
+	int			soundTurbo;		//sound to play when turbo/afterburner kicks in
+	int			soundHyper;		//sound to play when ship lands
+	int			soundLand;		//sound to play when ship lands
+	int			soundOff;		//sound to play when get off
+	int			soundFlyBy;		//sound to play when they buzz you
+	int			soundFlyBy2;	//alternate sound to play when they buzz you
+	int			soundShift1;	//sound to play when accelerating
+	int			soundShift2;	//sound to play when accelerating
+	int			soundShift3;	//sound to play when decelerating
+	int			soundShift4;	//sound to play when decelerating
+
+	int			iExhaustFX;		//exhaust effect, played from "*exhaust" bolt(s)
+	int			iTurboFX;		//turbo exhaust effect, played from "*exhaust" bolt(s) when ship is in "turbo" mode
+	int			iTurboStartFX;	//turbo begin effect, played from "*exhaust" bolts when "turbo" mode begins
+	int			iTrailFX;		//trail effect, played from "*trail" bolt(s)
+	int			iImpactFX;		//impact effect, for when it bumps into something
+	int			iExplodeFX;		//explosion effect, for when it blows up (should have the sound built into explosion effect)
+	int			iWakeFX;			//effect it makes when going across water
+	int			iDmgFX;			//effect to play on damage from a weapon or something
+	int			iInjureFX;
+	int			iNoseFX;		//effect for nose piece flying away when blown off
+	int			iLWingFX;		//effect for left wing piece flying away when blown off
+	int			iRWingFX;		//effect for right wing piece flying away when blown off
+
+	//Weapon stats
+	vehWeaponStats_t	weapon[MAX_VEHICLE_WEAPONS];
+
+	// Which weapon a muzzle fires (has to match one of the weapons this vehicle has). So 1 would be weapon 1,
+	// 2 would be weapon 2 and so on.
+	int			weapMuzzle[MAX_VEHICLE_MUZZLES];
+	
+	//turrets (if any) on the vehicle
+	turretStats_t	turret[MAX_VEHICLE_TURRETS];
+
+	// The max height before this ship (?) starts (auto)landing.
+	float		landingHeight;
+
+	//other misc stats
+	int			gravity;		//normal is 800
+	float		hoverHeight;	//if 0, it's a ground vehicle
+	float		hoverStrength;	//how hard it pushes off ground when less than hover height... causes "bounce", like shocks
+	qboolean	waterProof;		//can drive underwater if it has to
+	float		bouyancy;		//when in water, how high it floats (1 is neutral bouyancy)
+	int			fuelMax;		//how much fuel it can hold (capacity)
+	int			fuelRate;		//how quickly is uses up fuel
+	int			turboDuration;	//how long turbo lasts
+	int			turboRecharge;	//how long turbo takes to recharge
+	int			visibility;		//for sight alerts
+	int			loudness;		//for sound alerts
+	float		explosionRadius;//range of explosion
+	int			explosionDamage;//damage of explosion
+
+	int			maxPassengers;	// The max number of passengers this vehicle may have (Default = 0).
+	qboolean	hideRider;		// rider (and passengers?) should not be drawn
+	qboolean	killRiderOnDeath;//if rider is on vehicle when it dies, they should die
+	qboolean	flammable;		//whether or not the vehicle should catch on fire before it explodes
+	int			explosionDelay;	//how long the vehicle should be on fire/dying before it explodes
+	//camera stuff
+	qboolean	cameraOverride;	//whether or not to use all of the following 3rd person camera override values
+	float		cameraRange;	//how far back the camera should be - normal is 80
+	float		cameraVertOffset;//how high over the vehicle origin the camera should be - normal is 16
+	float		cameraHorzOffset;//how far to left/right (negative/positive) of of the vehicle origin the camera should be - normal is 0
+	float		cameraPitchOffset;//a modifier on the camera's pitch (up/down angle) to the vehicle - normal is 0
+	float		cameraFOV;		//third person camera FOV, default is 80
+	float		cameraAlpha;	//fade out the vehicle to this alpha (0.1-1.0f) if it's in the way of the crosshair
+	qboolean	cameraPitchDependantVertOffset;//use the hacky AT-ST pitch dependant vertical offset
+
+	//NOTE: some info on what vehicle weapon to use?  Like ATST or TIE bomber or TIE fighter or X-Wing...?
+
+//===VEH_PARM_MAX========================================================================
+//*** IMPORTANT!!! *** vehFields table correponds to this structure!
+
+//THE FOLLOWING FIELDS are not in the vehFields table because they are internal variables, not read in from the .veh file
+	int			modelIndex;		//set internally, not until this vehicle is spawned into the level
+
+	// NOTE: Please note that most of this stuff has been converted from C++ classes to generic C.
+	// This part of the structure is used to simulate inheritance for vehicles. The basic idea is that all vehicle use
+	// this vehicle interface since they declare their own functions and assign the function pointer to the
+	// corresponding function. Meanwhile, the base logic can still call the appropriate functions. In C++ talk all
+	// of these functions (pointers) are pure virtuals and this is an abstract base class (although it cannot be
+	// inherited from, only contained and reimplemented (through an object and a setup function respectively)). -AReis
+
+	// Makes sure that the vehicle is properly animated.
+	void (*AnimateVehicle)( Vehicle_t *pVeh );
+
+	// Makes sure that the rider's in this vehicle are properly animated.
+	void (*AnimateRiders)( Vehicle_t *pVeh );
+
+	// Determine whether this entity is able to board this vehicle or not.
+	qboolean (*ValidateBoard)( Vehicle_t *pVeh, bgEntity_t *pEnt );
+
+	// Set the parent entity of this Vehicle NPC.
+	void (*SetParent)( Vehicle_t *pVeh, bgEntity_t *pParentEntity );
+
+	// Add a pilot to the vehicle.
+	void (*SetPilot)( Vehicle_t *pVeh, bgEntity_t *pPilot );
+
+	// Add a passenger to the vehicle (false if we're full).
+	qboolean (*AddPassenger)( Vehicle_t *pVeh );
+
+	// Animate the vehicle and it's riders.
+	void (*Animate)( Vehicle_t *pVeh );
+
+	// Board this Vehicle (get on). The first entity to board an empty vehicle becomes the Pilot.
+	qboolean (*Board)( Vehicle_t *pVeh, bgEntity_t *pEnt );
+
+	// Eject an entity from the vehicle.
+	qboolean (*Eject)( Vehicle_t *pVeh, bgEntity_t *pEnt, qboolean forceEject );
+
+	// Eject all the inhabitants of this vehicle.
+	qboolean (*EjectAll)( Vehicle_t *pVeh );	
+
+	// Start a delay until the vehicle dies.
+	void (*StartDeathDelay)( Vehicle_t *pVeh, int iDelayTime );
+
+	// Update death sequence.
+	void (*DeathUpdate)( Vehicle_t *pVeh );
+	
+	// Register all the assets used by this vehicle.
+	void (*RegisterAssets)( Vehicle_t *pVeh );
+	
+	// Initialize the vehicle (should be called by Spawn?).
+	qboolean (*Initialize)( Vehicle_t *pVeh );
+
+	// Like a think or move command, this updates various vehicle properties.
+	qboolean (*Update)( Vehicle_t *pVeh, const usercmd_t *pUcmd );
+
+	// Update the properties of a Rider (that may reflect what happens to the vehicle).
+	//
+	//	[return]		bool			True if still in vehicle, false if otherwise.
+	qboolean (*UpdateRider)( Vehicle_t *pVeh, bgEntity_t *pRider, usercmd_t *pUcmd );
+
+	// ProcessMoveCommands the Vehicle.
+	void (*ProcessMoveCommands)( Vehicle_t *pVeh );
+
+	// ProcessOrientCommands the Vehicle.
+	void (*ProcessOrientCommands)( Vehicle_t *pVeh );
+	
+	// Attachs all the riders of this vehicle to their appropriate position/tag (*driver, *pass1, *pass2, whatever...).
+	void (*AttachRiders)( Vehicle_t *pVeh );
+
+	// Make someone invisible and un-collidable.
+	void (*Ghost)( Vehicle_t *pVeh, bgEntity_t *pEnt );
+
+	// Make someone visible and collidable.
+	void (*UnGhost)( Vehicle_t *pVeh, bgEntity_t *pEnt );
+
+	// Get the pilot of this vehicle.
+	const bgEntity_t *(*GetPilot)( Vehicle_t *pVeh );
+
+	// Whether this vehicle is currently inhabited (by anyone) or not.
+	qboolean (*Inhabited)( Vehicle_t *pVeh );
+} vehicleInfo_t;
+
+
+#define	VFOFS(x) ((int)&(((vehicleInfo_t *)0)->x))
+
+#define MAX_VEHICLES	16	//sigh... no more than 64 individual vehicles
+#define VEHICLE_BASE	0
+#define VEHICLE_NONE	-1
+
+#include "../namespace_begin.h"
+extern vehicleInfo_t g_vehicleInfo[MAX_VEHICLES];
+extern int	numVehicles;
+#include "../namespace_end.h"
+
+#define VEH_DEFAULT_SPEED_MAX		800.0f
+#define VEH_DEFAULT_ACCEL			10.0f
+#define VEH_DEFAULT_DECEL			10.0f
+#define VEH_DEFAULT_STRAFE_PERC		0.5f
+#define VEH_DEFAULT_BANKING_SPEED	0.5f
+#define VEH_DEFAULT_ROLL_LIMIT		60.0f
+#define VEH_DEFAULT_PITCH_LIMIT		90.0f
+#define VEH_DEFAULT_BRAKING			10.0f
+#define VEH_DEFAULT_TURNING_SPEED	1.0f
+#define VEH_DEFAULT_TRACTION		8.0f
+#define VEH_DEFAULT_FRICTION		1.0f
+#define VEH_DEFAULT_MAX_SLOPE		0.85f
+#define VEH_DEFAULT_MASS			200
+#define VEH_DEFAULT_MAX_ARMOR		200
+#define VEH_DEFAULT_TOUGHNESS		2.5f
+#define VEH_DEFAULT_GRAVITY			800
+#define VEH_DEFAULT_HOVER_HEIGHT	64.0f
+#define VEH_DEFAULT_HOVER_STRENGTH	10.0f
+#define VEH_DEFAULT_VISIBILITY		0
+#define VEH_DEFAULT_LOUDNESS		0
+#define VEH_DEFAULT_EXP_RAD			400.0f
+#define VEH_DEFAULT_EXP_DMG			1000
+#define VEH_MAX_PASSENGERS			10
+
+#define MAX_STRAFE_TIME				2000.0f//FIXME: extern?
+#define	MIN_LANDING_SPEED			200//equal to or less than this and close to ground = auto-slow-down to land
+#define	MIN_LANDING_SLOPE			0.8f//must be pretty flat to land on the surf
+
+#define VEH_MOUNT_THROW_LEFT		-5
+#define	VEH_MOUNT_THROW_RIGHT		-6
+
+
+typedef enum
+{
+	VEH_EJECT_LEFT, 
+	VEH_EJECT_RIGHT, 
+	VEH_EJECT_FRONT, 
+	VEH_EJECT_REAR, 
+	VEH_EJECT_TOP, 
+	VEH_EJECT_BOTTOM
+};
+
+// Vehicle flags.
+typedef enum
+{
+	VEH_NONE = 0, VEH_FLYING = 0x00000001, VEH_CRASHING = 0x00000002,
+	VEH_LANDING = 0x00000004, VEH_BUCKING = 0x00000010, VEH_WINGSOPEN = 0x00000020,
+	VEH_GEARSOPEN = 0x00000040, VEH_SLIDEBREAKING = 0x00000080, VEH_SPINNING = 0x00000100,
+	VEH_OUTOFCONTROL = 0x00000200,
+	VEH_SABERINLEFTHAND = 0x00000400
+} vehFlags_t;
+
+//defines for impact damage surface stuff
+#define	SHIPSURF_FRONT		0
+#define	SHIPSURF_BACK		1
+#define	SHIPSURF_RIGHT		2
+#define	SHIPSURF_LEFT		3
+
+#define	SHIPSURF_DAMAGE_FRONT_LIGHT		0
+#define	SHIPSURF_DAMAGE_BACK_LIGHT		1
+#define	SHIPSURF_DAMAGE_RIGHT_LIGHT		2
+#define	SHIPSURF_DAMAGE_LEFT_LIGHT		3
+#define	SHIPSURF_DAMAGE_FRONT_HEAVY		4
+#define	SHIPSURF_DAMAGE_BACK_HEAVY		5
+#define	SHIPSURF_DAMAGE_RIGHT_HEAVY		6
+#define	SHIPSURF_DAMAGE_LEFT_HEAVY		7
+
+//generic part bits
+#define SHIPSURF_BROKEN_A	(1<<0) //gear 1
+#define SHIPSURF_BROKEN_B	(1<<1) //gear 1
+#define SHIPSURF_BROKEN_C	(1<<2) //wing 1
+#define SHIPSURF_BROKEN_D	(1<<3) //wing 2
+#define SHIPSURF_BROKEN_E	(1<<4) //wing 3
+#define SHIPSURF_BROKEN_F	(1<<5) //wing 4
+#define SHIPSURF_BROKEN_G	(1<<6) //front
+
+typedef struct
+{
+	//linked firing mode
+	qboolean	linked;//weapon 1's muzzles are in linked firing mode
+	//current weapon ammo
+	int			ammo;
+	//debouncer for ammo recharge
+	int			lastAmmoInc;
+	//which muzzle will fire next
+	int			nextMuzzle;
+} vehWeaponStatus_t;
+
+typedef struct
+{
+	//current weapon ammo
+	int			ammo;
+	//debouncer for ammo recharge
+	int			lastAmmoInc;
+	//which muzzle will fire next
+	int			nextMuzzle;
+	//which entity they're after
+	int			enemyEntNum;
+	//how long to hold on to our current enemy
+	int			enemyHoldTime;
+} vehTurretStatus_t;
+// This is the implementation of the vehicle interface and any of the other variables needed. This
+// is what actually represents a vehicle. -AReis.
+typedef struct Vehicle_s
+{
+	// The entity who pilots/drives this vehicle.
+	// NOTE: This is redundant (since m_pParentEntity->owner _should_ be the pilot). This makes things clearer though.
+	bgEntity_t *m_pPilot;
+
+	int m_iPilotTime; //if spawnflag to die without pilot and this < level.time then die.
+	int m_iPilotLastIndex; //index to last pilot
+	qboolean m_bHasHadPilot; //qtrue once the vehicle gets its first pilot
+
+	// The passengers of this vehicle.
+	//bgEntity_t **m_ppPassengers;
+	bgEntity_t *m_ppPassengers[VEH_MAX_PASSENGERS];
+
+	//the droid unit NPC for this vehicle, if any
+	bgEntity_t *m_pDroidUnit;
+
+	// The number of passengers currently in this vehicle.
+	int m_iNumPassengers;
+
+	// The entity from which this NPC comes from.
+	bgEntity_t *m_pParentEntity;
+
+	// If not zero, how long to wait before we can do anything with the vehicle (we're getting on still).
+	// -1 = board from left, -2 = board from right, -3 = jump/quick board.  -4 & -5 = throw off existing pilot
+	int		m_iBoarding;
+
+	// Used to check if we've just started the boarding process
+	qboolean	m_bWasBoarding;
+
+	// The speed the vehicle maintains while boarding occurs (often zero)
+	vec3_t	m_vBoardingVelocity;
+
+	// Time modifier (must only be used in ProcessMoveCommands() and ProcessOrientCommands() and is updated in Update()).
+	float m_fTimeModifier;
+
+	// Ghoul2 Animation info.
+	//int m_iDriverTag;
+	int m_iLeftExhaustTag;
+	int m_iRightExhaustTag;
+	int m_iGun1Tag;
+	int m_iGun1Bone;
+	int m_iLeftWingBone;
+	int m_iRightWingBone;
+
+	int m_iExhaustTag[MAX_VEHICLE_EXHAUSTS];
+	int m_iMuzzleTag[MAX_VEHICLE_MUZZLES];
+	int m_iDroidUnitTag;
+	int	m_iGunnerViewTag[MAX_VEHICLE_TURRETS];//Where to put the view origin of the gunner (index)
+
+	//this stuff is a little bit different from SP, because I am lazy -rww
+	int m_iMuzzleTime[MAX_VEHICLE_MUZZLES];
+	// These are updated every frame and represent the current position and direction for the specific muzzle.
+	vec3_t m_vMuzzlePos[MAX_VEHICLE_MUZZLES], m_vMuzzleDir[MAX_VEHICLE_MUZZLES];
+
+	// This is how long to wait before being able to fire a specific muzzle again. This is based on the firing rate
+	// so that a firing rate of 10 rounds/sec would make this value initially 100 miliseconds. 
+	int m_iMuzzleWait[MAX_VEHICLE_MUZZLES];
+
+	// The user commands structure.
+	usercmd_t m_ucmd;
+
+	// The direction an entity will eject from the vehicle towards.
+	int m_EjectDir;
+
+	// Flags that describe the vehicles behavior.
+	unsigned long m_ulFlags;
+
+	// NOTE: Vehicle Type ID, Orientation, and Armor MUST be transmitted over the net.
+
+	// The ID of the type of vehicle this is.
+	int m_iVehicleTypeID;
+
+	// Current angles of this vehicle.
+	//vec3_t		m_vOrientation;
+	float		*m_vOrientation;
+	//Yeah, since we use the SP code for vehicles, I want to use this value, but I'm going
+	//to make it a pointer to a vec3_t in the playerstate for prediction's sake. -rww
+
+	// How long you have strafed left or right (increments every frame that you strafe to right, decrements every frame you strafe left)
+	int			m_fStrafeTime;	
+
+	// Previous angles of this vehicle.
+	vec3_t		m_vPrevOrientation;
+
+	// Previous viewangles of the rider
+	vec3_t		m_vPrevRiderViewAngles;
+
+	// When control is lost on a speeder, current angular velocity is stored here and applied until landing
+	float		m_vAngularVelocity;
+
+	vec3_t		m_vFullAngleVelocity;
+
+	// Current armor and shields of your vehicle (explodes if armor to 0).
+	int			m_iArmor;	//hull strength - STAT_HEALTH on NPC
+	int			m_iShields;	//energy shielding - STAT_ARMOR on NPC
+
+	//mp-specific
+	int			m_iHitDebounce;
+
+	// Timer for all cgame-FX...? ex: exhaust?
+	int			m_iLastFXTime; 
+
+	// When to die.
+	int			m_iDieTime;
+
+	// This pointer is to a valid VehicleInfo (which could be an animal, speeder, fighter, whatever). This
+	// contains the functions actually used to do things to this specific kind of vehicle as well as shared
+	// information (max speed, type, etc...).
+	vehicleInfo_t *m_pVehicleInfo;
+
+	// This trace tells us if we're within landing height.
+	trace_t m_LandTrace;
+
+	// TEMP: The wing angles (used to animate it).
+	vec3_t m_vWingAngles;
+
+	//amount of damage done last impact
+	int			m_iLastImpactDmg;
+
+	//bitflag of surfaces that have broken off
+	int			m_iRemovedSurfaces;
+	
+	int			m_iDmgEffectTime;
+
+	// the last time this vehicle fired a turbo burst
+	int			m_iTurboTime;
+
+	//how long it should drop like a rock for after freed from SUSPEND
+	int			m_iDropTime;
+
+	int			m_iSoundDebounceTimer;
+
+	//last time we incremented the shields
+	int			lastShieldInc;
+
+	//so we don't hold it down and toggle it back and forth
+	qboolean	linkWeaponToggleHeld;
+
+	//info about our weapons (linked, ammo, etc.)
+	vehWeaponStatus_t	weaponStatus[MAX_VEHICLE_WEAPONS];
+	vehTurretStatus_t	turretStatus[MAX_VEHICLE_TURRETS];
+
+	//the guy who was previously the pilot
+	bgEntity_t *	m_pOldPilot;
+
+} Vehicle_t;
+
+#include "../namespace_begin.h"
+extern int BG_VehicleGetIndex( const char *vehicleName );
+#include "../namespace_end.h"
+
+#endif	// __BG_VEHICLES_H
diff --git a/codemp/game/bg_weapons.c b/codemp/game/bg_weapons.c
new file mode 100644
index 0000000..45edd51
--- /dev/null
+++ b/codemp/game/bg_weapons.c
@@ -0,0 +1,402 @@
+// Copyright (C) 2001-2002 Raven Software
+//
+// bg_weapons.c -- part of bg_pmove functionality
+
+#include "q_shared.h"
+#include "bg_public.h"
+#include "bg_local.h"
+
+// Muzzle point table...
+vec3_t WP_MuzzlePoint[WP_NUM_WEAPONS] = 
+{//	Fwd,	right,	up.
+	{0,		0,		0	},	// WP_NONE,
+	{0	,	8,		0	},	// WP_STUN_BATON,
+	{0	,	8,		0	},	// WP_MELEE,
+	{8	,	16,		0	},	// WP_SABER,				 
+	{12,	6,		-6	},	// WP_BRYAR_PISTOL,
+	{12,	6,		-6	},	// WP_BLASTER,
+	{12,	6,		-6	},	// WP_DISRUPTOR,
+	{12,	2,		-6	},	// WP_BOWCASTER,
+	{12,	4.5,	-6	},	// WP_REPEATER,
+	{12,	6,		-6	},	// WP_DEMP2,
+	{12,	6,		-6	},	// WP_FLECHETTE,
+	{12,	8,		-4	},	// WP_ROCKET_LAUNCHER,
+	{12,	0,		-4	},	// WP_THERMAL,
+	{12,	0,		-10	},	// WP_TRIP_MINE,
+	{12,	0,		-4	},	// WP_DET_PACK,
+	{12,	6,		-6	},	// WP_CONCUSSION
+	{12,	6,		-6	},	// WP_BRYAR_OLD,
+};
+
+weaponData_t weaponData[WP_NUM_WEAPONS] = 
+{
+	{	// WP_NONE
+//		"No Weapon",			//	char	classname[32];		// Spawning name
+		AMMO_NONE,				//	int		ammoIndex;			// Index to proper ammo slot
+		0,						//	int		ammoLow;			// Count when ammo is low
+		0,						//	int		energyPerShot;		// Amount of energy used per shot
+		0,						//	int		fireTime;			// Amount of time between firings
+		0,						//	int		range;				// Range of weapon
+		0,						//	int		altEnergyPerShot;	// Amount of energy used for alt-fire
+		0,						//	int		altFireTime;		// Amount of time between alt-firings
+		0,						//	int		altRange;			// Range of alt-fire
+		0,						//	int		chargeSubTime;		// ms interval for subtracting ammo during charge
+		0,						//	int		altChargeSubTime;	// above for secondary
+		0,						//	int		chargeSub;			// amount to subtract during charge on each interval
+		0,						//int		altChargeSub;		// above for secondary
+		0,						//	int		maxCharge;			// stop subtracting once charged for this many ms
+		0						//	int		altMaxCharge;		// above for secondary
+	},
+	{	// WP_STUN_BATON
+//		"Stun Baton",			//	char	classname[32];		// Spawning name
+		AMMO_NONE,				//	int		ammoIndex;			// Index to proper ammo slot
+		5,						//	int		ammoLow;			// Count when ammo is low
+		0,						//	int		energyPerShot;		// Amount of energy used per shot
+		400,					//	int		fireTime;			// Amount of time between firings
+		8192,					//	int		range;				// Range of weapon
+		0,						//	int		altEnergyPerShot;	// Amount of energy used for alt-fire
+		400,					//	int		altFireTime;		// Amount of time between alt-firings
+		8192,					//	int		altRange;			// Range of alt-fire
+		0,						//	int		chargeSubTime;		// ms interval for subtracting ammo during charge
+		0,						//	int		altChargeSubTime;	// above for secondary
+		0,						//	int		chargeSub;			// amount to subtract during charge on each interval
+		0,						//int		altChargeSub;		// above for secondary
+		0,						//	int		maxCharge;			// stop subtracting once charged for this many ms
+		0						//	int		altMaxCharge;		// above for secondary
+	},
+	{	// WP_MELEE
+//		"Melee",			//	char	classname[32];		// Spawning name
+		AMMO_NONE,				//	int		ammoIndex;			// Index to proper ammo slot
+		5,						//	int		ammoLow;			// Count when ammo is low
+		0,						//	int		energyPerShot;		// Amount of energy used per shot
+		400,					//	int		fireTime;			// Amount of time between firings
+		8192,					//	int		range;				// Range of weapon
+		0,						//	int		altEnergyPerShot;	// Amount of energy used for alt-fire
+		400,					//	int		altFireTime;		// Amount of time between alt-firings
+		8192,					//	int		altRange;			// Range of alt-fire
+		0,						//	int		chargeSubTime;		// ms interval for subtracting ammo during charge
+		0,						//	int		altChargeSubTime;	// above for secondary
+		0,						//	int		chargeSub;			// amount to subtract during charge on each interval
+		0,						//int		altChargeSub;		// above for secondary
+		0,						//	int		maxCharge;			// stop subtracting once charged for this many ms
+		0						//	int		altMaxCharge;		// above for secondary
+	},
+	{	// WP_SABER,
+//		"Lightsaber",			//	char	classname[32];		// Spawning name
+		AMMO_NONE,				//	int		ammoIndex;			// Index to proper ammo slot
+		5,						//	int		ammoLow;			// Count when ammo is low
+		0,						//	int		energyPerShot;		// Amount of energy used per shot
+		100,					//	int		fireTime;			// Amount of time between firings
+		8192,					//	int		range;				// Range of weapon
+		0,						//	int		altEnergyPerShot;	// Amount of energy used for alt-fire
+		100,					//	int		altFireTime;		// Amount of time between alt-firings
+		8192,					//	int		altRange;			// Range of alt-fire
+		0,						//	int		chargeSubTime;		// ms interval for subtracting ammo during charge
+		0,						//	int		altChargeSubTime;	// above for secondary
+		0,						//	int		chargeSub;			// amount to subtract during charge on each interval
+		0,						//int		altChargeSub;		// above for secondary
+		0,						//	int		maxCharge;			// stop subtracting once charged for this many ms
+		0						//	int		altMaxCharge;		// above for secondary
+	},
+	{	// WP_BRYAR_PISTOL,
+//		"Bryar Pistol",			//	char	classname[32];		// Spawning name
+		AMMO_BLASTER,			//	int		ammoIndex;			// Index to proper ammo slot
+		0,//15,						//	int		ammoLow;			// Count when ammo is low
+		0,//2,						//	int		energyPerShot;		// Amount of energy used per shot
+		800,//400,					//	int		fireTime;			// Amount of time between firings
+		8192,					//	int		range;				// Range of weapon
+		0,//2,						//	int		altEnergyPerShot;	// Amount of energy used for alt-fire
+		800,//400,					//	int		altFireTime;		// Amount of time between alt-firings
+		8192,					//	int		altRange;			// Range of alt-fire
+		0,						//	int		chargeSubTime;		// ms interval for subtracting ammo during charge
+		0,//200,					//	int		altChargeSubTime;	// above for secondary
+		0,						//	int		chargeSub;			// amount to subtract during charge on each interval
+		0,//1,						//int		altChargeSub;		// above for secondary
+		0,						//	int		maxCharge;			// stop subtracting once charged for this many ms
+		0,//1500					//	int		altMaxCharge;		// above for secondary
+	},
+	{	// WP_BLASTER
+//		"E11 Blaster Rifle",	//	char	classname[32];		// Spawning name
+		AMMO_BLASTER,			//	int		ammoIndex;			// Index to proper ammo slot
+		5,						//	int		ammoLow;			// Count when ammo is low
+		2,						//	int		energyPerShot;		// Amount of energy used per shot
+		350,					//	int		fireTime;			// Amount of time between firings
+		8192,					//	int		range;				// Range of weapon
+		3,						//	int		altEnergyPerShot;	// Amount of energy used for alt-fire
+		150,					//	int		altFireTime;		// Amount of time between alt-firings
+		8192,					//	int		altRange;			// Range of alt-fire
+		0,						//	int		chargeSubTime;		// ms interval for subtracting ammo during charge
+		0,						//	int		altChargeSubTime;	// above for secondary
+		0,						//	int		chargeSub;			// amount to subtract during charge on each interval
+		0,						//int		altChargeSub;		// above for secondary
+		0,						//	int		maxCharge;			// stop subtracting once charged for this many ms
+		0						//	int		altMaxCharge;		// above for secondary
+	},
+	{	// WP_DISRUPTOR
+//		"Tenloss Disruptor Rifle",//	char	classname[32];		// Spawning name
+		AMMO_POWERCELL,			//	int		ammoIndex;			// Index to proper ammo slot
+		5,						//	int		ammoLow;			// Count when ammo is low
+		5,						//	int		energyPerShot;		// Amount of energy used per shot
+		600,					//	int		fireTime;			// Amount of time between firings
+		8192,					//	int		range;				// Range of weapon
+		6,						//	int		altEnergyPerShot;	// Amount of energy used for alt-fire
+		1300,					//	int		altFireTime;		// Amount of time between alt-firings
+		8192,					//	int		altRange;			// Range of alt-fire
+		0,						//	int		chargeSubTime;		// ms interval for subtracting ammo during charge
+		200,					//	int		altChargeSubTime;	// above for secondary
+		0,						//	int		chargeSub;			// amount to subtract during charge on each interval
+		3,						//int		altChargeSub;		// above for secondary
+		0,						//	int		maxCharge;			// stop subtracting once charged for this many ms
+		1700					//	int		altMaxCharge;		// above for secondary
+	},
+	{	// WP_BOWCASTER
+//		"Wookiee Bowcaster",		//	char	classname[32];		// Spawning name
+		AMMO_POWERCELL,			//	int		ammoIndex;			// Index to proper ammo slot
+		5,						//	int		ammoLow;			// Count when ammo is low
+		5,						//	int		energyPerShot;		// Amount of energy used per shot
+		1000,					//	int		fireTime;			// Amount of time between firings
+		8192,					//	int		range;				// Range of weapon
+		5,						//	int		altEnergyPerShot;	// Amount of energy used for alt-fire
+		750,					//	int		altFireTime;		// Amount of time between alt-firings
+		8192,					//	int		altRange;			// Range of alt-fire
+		400,						//	int		chargeSubTime;		// ms interval for subtracting ammo during charge
+		0,					//	int		altChargeSubTime;	// above for secondary
+		5,						//	int		chargeSub;			// amount to subtract during charge on each interval
+		0,						//int		altChargeSub;		// above for secondary
+		1700,						//	int		maxCharge;			// stop subtracting once charged for this many ms
+		0					//	int		altMaxCharge;		// above for secondary
+	},
+	{	// WP_REPEATER
+//		"Imperial Heavy Repeater",//	char	classname[32];		// Spawning name
+		AMMO_METAL_BOLTS,		//	int		ammoIndex;			// Index to proper ammo slot
+		5,						//	int		ammoLow;			// Count when ammo is low
+		1,						//	int		energyPerShot;		// Amount of energy used per shot
+		100,					//	int		fireTime;			// Amount of time between firings
+		8192,					//	int		range;				// Range of weapon
+		15,						//	int		altEnergyPerShot;	// Amount of energy used for alt-fire
+		800,					//	int		altFireTime;		// Amount of time between alt-firings
+		8192,					//	int		altRange;			// Range of alt-fire
+		0,						//	int		chargeSubTime;		// ms interval for subtracting ammo during charge
+		0,						//	int		altChargeSubTime;	// above for secondary
+		0,						//	int		chargeSub;			// amount to subtract during charge on each interval
+		0,						//int		altChargeSub;		// above for secondary
+		0,						//	int		maxCharge;			// stop subtracting once charged for this many ms
+		0						//	int		altMaxCharge;		// above for secondary
+	},
+	{	// WP_DEMP2
+//		"DEMP2",				//	char	classname[32];		// Spawning name
+		AMMO_POWERCELL,			//	int		ammoIndex;			// Index to proper ammo slot
+		5,						//	int		ammoLow;			// Count when ammo is low
+		8,						//	int		energyPerShot;		// Amount of energy used per shot
+		500,					//	int		fireTime;			// Amount of time between firings
+		8192,					//	int		range;				// Range of weapon
+		6,						//	int		altEnergyPerShot;	// Amount of energy used for alt-fire
+		900,						//	int		altFireTime;		// Amount of time between alt-firings
+		8192,					//	int		altRange;			// Range of alt-fire
+		0,						//	int		chargeSubTime;		// ms interval for subtracting ammo during charge
+		250,					//	int		altChargeSubTime;	// above for secondary
+		0,						//	int		chargeSub;			// amount to subtract during charge on each interval
+		3,						//	int		altChargeSub;		// above for secondary
+		0,						//	int		maxCharge;			// stop subtracting once charged for this many ms
+		2100					//	int		altMaxCharge;		// above for secondary
+	},
+	{	// WP_FLECHETTE
+//		"Golan Arms Flechette",	//	char	classname[32];		// Spawning name
+		AMMO_METAL_BOLTS,		//	int		ammoIndex;			// Index to proper ammo slot
+		5,						//	int		ammoLow;			// Count when ammo is low
+		10,						//	int		energyPerShot;		// Amount of energy used per shot
+		700,					//	int		fireTime;			// Amount of time between firings
+		8192,					//	int		range;				// Range of weapon
+		15,						//	int		altEnergyPerShot;	// Amount of energy used for alt-fire
+		800,					//	int		altFireTime;		// Amount of time between alt-firings
+		8192,					//	int		altRange;			// Range of alt-fire
+		0,						//	int		chargeSubTime;		// ms interval for subtracting ammo during charge
+		0,						//	int		altChargeSubTime;	// above for secondary
+		0,						//	int		chargeSub;			// amount to subtract during charge on each interval
+		0,						//int		altChargeSub;		// above for secondary
+		0,						//	int		maxCharge;			// stop subtracting once charged for this many ms
+		0						//	int		altMaxCharge;		// above for secondary
+	},
+	{	// WP_ROCKET_LAUNCHER
+//		"Merr-Sonn Missile System",	//	char	classname[32];		// Spawning name
+		AMMO_ROCKETS,			//	int		ammoIndex;			// Index to proper ammo slot
+		5,						//	int		ammoLow;			// Count when ammo is low
+		1,						//	int		energyPerShot;		// Amount of energy used per shot
+		900,					//	int		fireTime;			// Amount of time between firings
+		8192,					//	int		range;				// Range of weapon
+		2,						//	int		altEnergyPerShot;	// Amount of energy used for alt-fire
+		1200,					//	int		altFireTime;		// Amount of time between alt-firings
+		8192,					//	int		altRange;			// Range of alt-fire
+		0,						//	int		chargeSubTime;		// ms interval for subtracting ammo during charge
+		0,						//	int		altChargeSubTime;	// above for secondary
+		0,						//	int		chargeSub;			// amount to subtract during charge on each interval
+		0,						//int		altChargeSub;		// above for secondary
+		0,						//	int		maxCharge;			// stop subtracting once charged for this many ms
+		0						//	int		altMaxCharge;		// above for secondary
+	},
+	{	// WP_THERMAL
+//		"Thermal Detonator",	//	char	classname[32];		// Spawning name
+		AMMO_THERMAL,				//	int		ammoIndex;			// Index to proper ammo slot
+		0,						//	int		ammoLow;			// Count when ammo is low
+		1,						//	int		energyPerShot;		// Amount of energy used per shot
+		800,					//	int		fireTime;			// Amount of time between firings
+		8192,					//	int		range;				// Range of weapon
+		1,						//	int		altEnergyPerShot;	// Amount of energy used for alt-fire
+		400,					//	int		altFireTime;		// Amount of time between alt-firings
+		8192,					//	int		altRange;			// Range of alt-fire
+		0,						//	int		chargeSubTime;		// ms interval for subtracting ammo during charge
+		0,						//	int		altChargeSubTime;	// above for secondary
+		0,						//	int		chargeSub;			// amount to subtract during charge on each interval
+		0,						//int		altChargeSub;		// above for secondary
+		0,						//	int		maxCharge;			// stop subtracting once charged for this many ms
+		0						//	int		altMaxCharge;		// above for secondary
+	},
+	{	// WP_TRIP_MINE
+//		"Trip Mine",			//	char	classname[32];		// Spawning name
+		AMMO_TRIPMINE,				//	int		ammoIndex;			// Index to proper ammo slot
+		0,						//	int		ammoLow;			// Count when ammo is low
+		1,						//	int		energyPerShot;		// Amount of energy used per shot
+		800,					//	int		fireTime;			// Amount of time between firings
+		8192,					//	int		range;				// Range of weapon
+		1,						//	int		altEnergyPerShot;	// Amount of energy used for alt-fire
+		400,					//	int		altFireTime;		// Amount of time between alt-firings
+		8192,					//	int		altRange;			// Range of alt-fire
+		0,						//	int		chargeSubTime;		// ms interval for subtracting ammo during charge
+		0,						//	int		altChargeSubTime;	// above for secondary
+		0,						//	int		chargeSub;			// amount to subtract during charge on each interval
+		0,						//int		altChargeSub;		// above for secondary
+		0,						//	int		maxCharge;			// stop subtracting once charged for this many ms
+		0						//	int		altMaxCharge;		// above for secondary
+	},
+	{	// WP_DET_PACK
+//		"Det Pack",				//	char	classname[32];		// Spawning name
+		AMMO_DETPACK,				//	int		ammoIndex;			// Index to proper ammo slot
+		0,						//	int		ammoLow;			// Count when ammo is low
+		1,						//	int		energyPerShot;		// Amount of energy used per shot
+		800,					//	int		fireTime;			// Amount of time between firings
+		8192,					//	int		range;				// Range of weapon
+		0,						//	int		altEnergyPerShot;	// Amount of energy used for alt-fire
+		400,					//	int		altFireTime;		// Amount of time between alt-firings
+		8192,					//	int		altRange;			// Range of alt-fire
+		0,						//	int		chargeSubTime;		// ms interval for subtracting ammo during charge
+		0,						//	int		altChargeSubTime;	// above for secondary
+		0,						//	int		chargeSub;			// amount to subtract during charge on each interval
+		0,						//int		altChargeSub;		// above for secondary
+		0,						//	int		maxCharge;			// stop subtracting once charged for this many ms
+		0						//	int		altMaxCharge;		// above for secondary
+	},
+	{	// WP_CONCUSSION
+//		"Concussion Rifle",		//	char	classname[32];		// Spawning name
+		AMMO_METAL_BOLTS,		//	int		ammoIndex;			// Index to proper ammo slot
+		40,						//	int		ammoLow;			// Count when ammo is low
+		40,						//	int		energyPerShot;		// Amount of energy used per shot
+		800,					//	int		fireTime;			// Amount of time between firings
+		8192,					//	int		range;				// Range of weapon
+		50,						//	int		altEnergyPerShot;	// Amount of energy used for alt-fire
+		1200,					//	int		altFireTime;		// Amount of time between alt-firings
+		8192,					//	int		altRange;			// Range of alt-fire
+		0,						//	int		chargeSubTime;		// ms interval for subtracting ammo during charge
+		0,						//	int		altChargeSubTime;	// above for secondary
+		0,						//	int		chargeSub;			// amount to subtract during charge on each interval
+		0,						//	int		altChargeSub;		// above for secondary
+		0,						//	int		maxCharge;			// stop subtracting once charged for this many ms
+		0						//	int		altMaxCharge;		// above for secondary
+	},
+	{	// WP_BRYAR_OLD,
+//		"Bryar Pistol",			//	char	classname[32];		// Spawning name
+		AMMO_BLASTER,			//	int		ammoIndex;			// Index to proper ammo slot
+		15,						//	int		ammoLow;			// Count when ammo is low
+		2,						//	int		energyPerShot;		// Amount of energy used per shot
+		400,					//	int		fireTime;			// Amount of time between firings
+		8192,					//	int		range;				// Range of weapon
+		2,						//	int		altEnergyPerShot;	// Amount of energy used for alt-fire
+		400,					//	int		altFireTime;		// Amount of time between alt-firings
+		8192,					//	int		altRange;			// Range of alt-fire
+		0,						//	int		chargeSubTime;		// ms interval for subtracting ammo during charge
+		200,					//	int		altChargeSubTime;	// above for secondary
+		0,						//	int		chargeSub;			// amount to subtract during charge on each interval
+		1,						//int		altChargeSub;		// above for secondary
+		0,						//	int		maxCharge;			// stop subtracting once charged for this many ms
+		1500					//	int		altMaxCharge;		// above for secondary
+	},
+	{	// WP_EMPLCACED_GUN
+//		"Emplaced Gun",			//	char	classname[32];		// Spawning name
+		/*AMMO_BLASTER*/0,			//	int		ammoIndex;			// Index to proper ammo slot
+		/*5*/0,						//	int		ammoLow;			// Count when ammo is low
+		/*2*/0,						//	int		energyPerShot;		// Amount of energy used per shot
+		100,					//	int		fireTime;			// Amount of time between firings
+		8192,					//	int		range;				// Range of weapon
+		/*3*/0,						//	int		altEnergyPerShot;	// Amount of energy used for alt-fire
+		100,					//	int		altFireTime;		// Amount of time between alt-firings
+		8192,					//	int		altRange;			// Range of alt-fire
+		0,						//	int		chargeSubTime;		// ms interval for subtracting ammo during charge
+		0,						//	int		altChargeSubTime;	// above for secondary
+		0,						//	int		chargeSub;			// amount to subtract during charge on each interval
+		0,						//int		altChargeSub;		// above for secondary
+		0,						//	int		maxCharge;			// stop subtracting once charged for this many ms
+		0						//	int		altMaxCharge;		// above for secondary
+	},
+	{	// WP_TURRET - NOTE NOT ACTUALLY USEABLE BY PLAYER!
+//		"Emplaced Gun",			//	char	classname[32];		// Spawning name
+		/*AMMO_BLASTER*/0,			//	int		ammoIndex;			// Index to proper ammo slot
+		/*5*/0,						//	int		ammoLow;			// Count when ammo is low
+		/*2*/0,						//	int		energyPerShot;		// Amount of energy used per shot
+		0,					//	int		fireTime;			// Amount of time between firings
+		0,					//	int		range;				// Range of weapon
+		/*3*/0,						//	int		altEnergyPerShot;	// Amount of energy used for alt-fire
+		0,					//	int		altFireTime;		// Amount of time between alt-firings
+		0,					//	int		altRange;			// Range of alt-fire
+		0,						//	int		chargeSubTime;		// ms interval for subtracting ammo during charge
+		0,						//	int		altChargeSubTime;	// above for secondary
+		0,						//	int		chargeSub;			// amount to subtract during charge on each interval
+		0,						//int		altChargeSub;		// above for secondary
+		0,						//	int		maxCharge;			// stop subtracting once charged for this many ms
+		0						//	int		altMaxCharge;		// above for secondary
+	}
+};
+
+ammoData_t ammoData[AMMO_MAX] = 
+{
+	{	// AMMO_NONE
+//		"",				//	char	icon[32];	// Name of ammo icon file
+		0				//	int		max;		// Max amount player can hold of ammo
+	},
+	{	// AMMO_FORCE
+//		"",				//	char	icon[32];	// Name of ammo icon file
+		100				//	int		max;		// Max amount player can hold of ammo
+	},
+	{	// AMMO_BLASTER
+//		"",				//	char	icon[32];	// Name of ammo icon file
+		300				//	int		max;		// Max amount player can hold of ammo
+	},
+	{	// AMMO_POWERCELL
+//		"",				//	char	icon[32];	// Name of ammo icon file
+		300				//	int		max;		// Max amount player can hold of ammo
+	},
+	{	// AMMO_METAL_BOLTS
+//		"",				//	char	icon[32];	// Name of ammo icon file
+		300				//	int		max;		// Max amount player can hold of ammo
+	},
+	{	// AMMO_ROCKETS
+//		"",				//	char	icon[32];	// Name of ammo icon file
+		25				//	int		max;		// Max amount player can hold of ammo
+	},
+	{	// AMMO_EMPLACED
+//		"",				//	char	icon[32];	// Name of ammo icon file
+		800				//	int		max;		// Max amount player can hold of ammo
+	},
+	{	// AMMO_THERMAL
+//		"",				//	char	icon[32];	// Name of ammo icon file
+		10				//	int		max;		// Max amount player can hold of ammo
+	},
+	{	// AMMO_TRIPMINE
+//		"",				//	char	icon[32];	// Name of ammo icon file
+		10				//	int		max;		// Max amount player can hold of ammo
+	},
+	{	// AMMO_DETPACK
+//		"",				//	char	icon[32];	// Name of ammo icon file
+		10				//	int		max;		// Max amount player can hold of ammo
+	}
+};
+
+
diff --git a/codemp/game/bg_weapons.h b/codemp/game/bg_weapons.h
new file mode 100644
index 0000000..a96bacf
--- /dev/null
+++ b/codemp/game/bg_weapons.h
@@ -0,0 +1,113 @@
+// Filename:-	bg_weapons.h
+//
+// This crosses both client and server.  It could all be crammed into bg_public, but isolation of this type of data is best.
+
+#ifndef __WEAPONS_H__
+#define __WEAPONS_H__
+
+typedef enum {
+	WP_NONE,
+
+	WP_STUN_BATON,
+	WP_MELEE,
+	WP_SABER,
+	WP_BRYAR_PISTOL,
+	WP_BLASTER,
+	WP_DISRUPTOR,
+	WP_BOWCASTER,
+	WP_REPEATER,
+	WP_DEMP2,
+	WP_FLECHETTE,
+	WP_ROCKET_LAUNCHER,
+	WP_THERMAL,
+	WP_TRIP_MINE,
+	WP_DET_PACK,
+	WP_CONCUSSION,
+	WP_BRYAR_OLD,
+	WP_EMPLACED_GUN,
+	WP_TURRET,
+
+//	WP_GAUNTLET,
+//	WP_MACHINEGUN,			// Bryar
+//	WP_SHOTGUN,				// Blaster
+//	WP_GRENADE_LAUNCHER,	// Thermal
+//	WP_LIGHTNING,			// 
+//	WP_RAILGUN,				// 
+//	WP_GRAPPLING_HOOK,
+
+	WP_NUM_WEAPONS
+};
+typedef int weapon_t;
+
+//anything > this will be considered not player useable
+#define LAST_USEABLE_WEAPON			WP_BRYAR_OLD
+
+typedef enum //# ammo_e
+{
+	AMMO_NONE,
+	AMMO_FORCE,		// AMMO_PHASER
+	AMMO_BLASTER,	// AMMO_STARFLEET,
+	AMMO_POWERCELL,	// AMMO_ALIEN,
+	AMMO_METAL_BOLTS,
+	AMMO_ROCKETS,
+	AMMO_EMPLACED,
+	AMMO_THERMAL,
+	AMMO_TRIPMINE,
+	AMMO_DETPACK,
+	AMMO_MAX
+} ammo_t;
+
+
+typedef struct weaponData_s
+{
+//	char	classname[32];		// Spawning name
+
+	int		ammoIndex;			// Index to proper ammo slot
+	int		ammoLow;			// Count when ammo is low
+
+	int		energyPerShot;		// Amount of energy used per shot
+	int		fireTime;			// Amount of time between firings
+	int		range;				// Range of weapon
+	
+	int		altEnergyPerShot;	// Amount of energy used for alt-fire
+	int		altFireTime;		// Amount of time between alt-firings
+	int		altRange;			// Range of alt-fire
+
+	int		chargeSubTime;		// ms interval for subtracting ammo during charge
+	int		altChargeSubTime;	// above for secondary
+
+	int		chargeSub;			// amount to subtract during charge on each interval
+	int		altChargeSub;		// above for secondary
+
+	int		maxCharge;			// stop subtracting once charged for this many ms
+	int		altMaxCharge;		// above for secondary
+} weaponData_t;
+
+
+typedef struct  ammoData_s
+{
+//	char	icon[32];	// Name of ammo icon file
+	int		max;		// Max amount player can hold of ammo
+} ammoData_t;
+
+
+extern weaponData_t weaponData[WP_NUM_WEAPONS];
+extern ammoData_t ammoData[AMMO_MAX];
+
+
+// Specific weapon information
+
+#define FIRST_WEAPON		WP_BRYAR_PISTOL		// this is the first weapon for next and prev weapon switching
+#define MAX_PLAYER_WEAPONS	WP_NUM_WEAPONS-1	// this is the max you can switch to and get with the give all.
+
+
+#define DEFAULT_SHOTGUN_SPREAD	700
+#define DEFAULT_SHOTGUN_COUNT	11
+
+#define	LIGHTNING_RANGE		768
+
+
+
+
+
+#endif//#ifndef __WEAPONS_H__
diff --git a/codemp/game/botlib.h b/codemp/game/botlib.h
new file mode 100644
index 0000000..9430495
--- /dev/null
+++ b/codemp/game/botlib.h
@@ -0,0 +1,508 @@
+// Copyright (C) 1999-2000 Id Software, Inc.
+//
+/*****************************************************************************
+ * name:		botlib.h
+ *
+ * desc:		bot AI library
+ *
+ * $Archive: /source/code/game/botai.h $
+ * $Author: osman $ 
+ * $Revision: 1.4 $
+ * $Modtime: 03/01/00 3:32p $
+ * $Date: 2003/03/15 23:44:00 $
+ *
+ *****************************************************************************/
+
+#define	BOTLIB_API_VERSION		2
+
+struct aas_clientmove_s;
+struct aas_entityinfo_s;
+struct aas_areainfo_s;
+struct aas_altroutegoal_s;
+struct aas_predictroute_s;
+struct bot_consolemessage_s;
+struct bot_match_s;
+struct bot_goal_s;
+struct bot_moveresult_s;
+struct bot_initmove_s;
+struct weaponinfo_s;
+
+#define BOTFILESBASEFOLDER		"botfiles"
+//debug line colors
+#define LINECOLOR_NONE			-1
+#define LINECOLOR_RED			1//0xf2f2f0f0L
+#define LINECOLOR_GREEN			2//0xd0d1d2d3L
+#define LINECOLOR_BLUE			3//0xf3f3f1f1L
+#define LINECOLOR_YELLOW		4//0xdcdddedfL
+#define LINECOLOR_ORANGE		5//0xe0e1e2e3L
+
+//Print types
+#define PRT_MESSAGE				1
+#define PRT_WARNING				2
+#define PRT_ERROR				3
+#define PRT_FATAL				4
+#define PRT_EXIT				5
+
+//console message types
+#define CMS_NORMAL				0
+#define CMS_CHAT				1
+
+//botlib error codes
+#define BLERR_NOERROR					0	//no error
+#define BLERR_LIBRARYNOTSETUP			1	//library not setup
+#define BLERR_INVALIDENTITYNUMBER		2	//invalid entity number
+#define BLERR_NOAASFILE					3	//no AAS file available
+#define BLERR_CANNOTOPENAASFILE			4	//cannot open AAS file
+#define BLERR_WRONGAASFILEID			5	//incorrect AAS file id
+#define BLERR_WRONGAASFILEVERSION		6	//incorrect AAS file version
+#define BLERR_CANNOTREADAASLUMP			7	//cannot read AAS file lump
+#define BLERR_CANNOTLOADICHAT			8	//cannot load initial chats
+#define BLERR_CANNOTLOADITEMWEIGHTS		9	//cannot load item weights
+#define BLERR_CANNOTLOADITEMCONFIG		10	//cannot load item config
+#define BLERR_CANNOTLOADWEAPONWEIGHTS	11	//cannot load weapon weights
+#define BLERR_CANNOTLOADWEAPONCONFIG	12	//cannot load weapon config
+
+//action flags
+#define ACTION_ATTACK			0x0000001
+#define ACTION_USE				0x0000002
+#define ACTION_RESPAWN			0x0000008
+#define ACTION_JUMP				0x0000010
+#define ACTION_MOVEUP			0x0000020
+#define ACTION_CROUCH			0x0000080
+#define ACTION_MOVEDOWN			0x0000100
+#define ACTION_MOVEFORWARD		0x0000200
+#define ACTION_MOVEBACK			0x0000800
+#define ACTION_MOVELEFT			0x0001000
+#define ACTION_MOVERIGHT		0x0002000
+#define ACTION_DELAYEDJUMP		0x0008000
+#define ACTION_TALK				0x0010000
+#define ACTION_GESTURE			0x0020000
+#define ACTION_WALK				0x0080000
+#define ACTION_FORCEPOWER		0x0100000
+#define ACTION_ALT_ATTACK		0x0200000
+/*
+#define ACTION_AFFIRMATIVE		0x0100000
+#define ACTION_NEGATIVE			0x0200000
+#define ACTION_GETFLAG			0x0800000
+#define ACTION_GUARDBASE		0x1000000
+#define ACTION_PATROL			0x2000000
+#define ACTION_FOLLOWME			0x8000000
+*/
+
+//the bot input, will be converted to an usercmd_t
+typedef struct bot_input_s
+{
+	float thinktime;		//time since last output (in seconds)
+	vec3_t dir;				//movement direction
+	float speed;			//speed in the range [0, 400]
+	vec3_t viewangles;		//the view angles
+	int actionflags;		//one of the ACTION_? flags
+	int weapon;				//weapon to use
+} bot_input_t;
+
+#ifndef BSPTRACE
+
+#define BSPTRACE
+
+//bsp_trace_t hit surface
+typedef struct bsp_surface_s
+{
+	char name[16];
+	int flags;
+	int value;
+} bsp_surface_t;
+
+//remove the bsp_trace_s structure definition l8r on
+//a trace is returned when a box is swept through the world
+typedef struct bsp_trace_s
+{
+	qboolean		allsolid;	// if true, plane is not valid
+	qboolean		startsolid;	// if true, the initial point was in a solid area
+	float			fraction;	// time completed, 1.0 = didn't hit anything
+	vec3_t			endpos;		// final position
+	cplane_t		plane;		// surface normal at impact
+	float			exp_dist;	// expanded plane distance
+	int				sidenum;	// number of the brush side hit
+	bsp_surface_t	surface;	// the hit point surface
+	int				contents;	// contents on other side of surface hit
+	int				ent;		// number of entity hit
+} bsp_trace_t;
+
+#endif	// BSPTRACE
+
+//entity state
+typedef struct bot_entitystate_s
+{
+	int		type;			// entity type
+	int		flags;			// entity flags
+	vec3_t	origin;			// origin of the entity
+	vec3_t	angles;			// angles of the model
+	vec3_t	old_origin;		// for lerping
+	vec3_t	mins;			// bounding box minimums
+	vec3_t	maxs;			// bounding box maximums
+	int		groundent;		// ground entity
+	int		solid;			// solid type
+	int		modelindex;		// model used
+	int		modelindex2;	// weapons, CTF flags, etc
+	int		frame;			// model frame number
+	int		event;			// impulse events -- muzzle flashes, footsteps, etc
+	int		eventParm;		// even parameter
+	int		powerups;		// bit flags
+	int		weapon;			// determines weapon and flash model, etc
+	int		legsAnim;
+	int		torsoAnim;
+} bot_entitystate_t;
+
+//bot AI library exported functions
+typedef struct botlib_import_s
+{
+	//print messages from the bot library
+	void		(QDECL *Print)(int type, char *fmt, ...);
+	//trace a bbox through the world
+	void		(*Trace)(bsp_trace_t *trace, vec3_t start, vec3_t mins, vec3_t maxs, vec3_t end, int passent, int contentmask);
+	//trace a bbox against a specific entity
+	void		(*EntityTrace)(bsp_trace_t *trace, vec3_t start, vec3_t mins, vec3_t maxs, vec3_t end, int entnum, int contentmask);
+	//retrieve the contents at the given point
+	int			(*PointContents)(vec3_t point);
+	//check if the point is in potential visible sight
+	int			(*inPVS)(vec3_t p1, vec3_t p2);
+	//retrieve the BSP entity data lump
+	char		*(*BSPEntityData)(void);
+	//
+	void		(*BSPModelMinsMaxsOrigin)(int modelnum, vec3_t angles, vec3_t mins, vec3_t maxs, vec3_t origin);
+	//send a bot client command
+	void		(*BotClientCommand)(int client, char *command);
+	//memory allocation
+	void		*(*GetMemory)(int size);		// allocate from Zone
+	void		(*FreeMemory)(void *ptr);		// free memory from Zone
+	int			(*AvailableMemory)(void);		// available Zone memory
+	void		*(*HunkAlloc)(int size);		// allocate from hunk
+	//file system access
+	int			(*FS_FOpenFile)( const char *qpath, fileHandle_t *file, fsMode_t mode );
+	int			(*FS_Read)( void *buffer, int len, fileHandle_t f );
+	int			(*FS_Write)( const void *buffer, int len, fileHandle_t f );
+	void		(*FS_FCloseFile)( fileHandle_t f );
+	int			(*FS_Seek)( fileHandle_t f, long offset, int origin );
+	//debug visualisation stuff
+	int			(*DebugLineCreate)(void);
+	void		(*DebugLineDelete)(int line);
+	void		(*DebugLineShow)(int line, vec3_t start, vec3_t end, int color);
+	//
+	int			(*DebugPolygonCreate)(int color, int numPoints, vec3_t *points);
+	void		(*DebugPolygonDelete)(int id);
+} botlib_import_t;
+
+typedef struct aas_export_s
+{
+	//-----------------------------------
+	// be_aas_entity.h
+	//-----------------------------------
+	void		(*AAS_EntityInfo)(int entnum, struct aas_entityinfo_s *info);
+	//-----------------------------------
+	// be_aas_main.h
+	//-----------------------------------
+	int			(*AAS_Initialized)(void);
+	void		(*AAS_PresenceTypeBoundingBox)(int presencetype, vec3_t mins, vec3_t maxs);
+	float		(*AAS_Time)(void);
+	//--------------------------------------------
+	// be_aas_sample.c
+	//--------------------------------------------
+	int			(*AAS_PointAreaNum)(vec3_t point);
+	int			(*AAS_PointReachabilityAreaIndex)( vec3_t point );
+	int			(*AAS_TraceAreas)(vec3_t start, vec3_t end, int *areas, vec3_t *points, int maxareas);
+	int			(*AAS_BBoxAreas)(vec3_t absmins, vec3_t absmaxs, int *areas, int maxareas);
+	int			(*AAS_AreaInfo)( int areanum, struct aas_areainfo_s *info );
+	//--------------------------------------------
+	// be_aas_bspq3.c
+	//--------------------------------------------
+	int			(*AAS_PointContents)(vec3_t point);
+	int			(*AAS_NextBSPEntity)(int ent);
+	int			(*AAS_ValueForBSPEpairKey)(int ent, char *key, char *value, int size);
+	int			(*AAS_VectorForBSPEpairKey)(int ent, char *key, vec3_t v);
+	int			(*AAS_FloatForBSPEpairKey)(int ent, char *key, float *value);
+	int			(*AAS_IntForBSPEpairKey)(int ent, char *key, int *value);
+	//--------------------------------------------
+	// be_aas_reach.c
+	//--------------------------------------------
+	int			(*AAS_AreaReachability)(int areanum);
+	//--------------------------------------------
+	// be_aas_route.c
+	//--------------------------------------------
+	int			(*AAS_AreaTravelTimeToGoalArea)(int areanum, vec3_t origin, int goalareanum, int travelflags);
+	int			(*AAS_EnableRoutingArea)(int areanum, int enable);
+	int			(*AAS_PredictRoute)(struct aas_predictroute_s *route, int areanum, vec3_t origin,
+							int goalareanum, int travelflags, int maxareas, int maxtime,
+							int stopevent, int stopcontents, int stoptfl, int stopareanum);
+	//--------------------------------------------
+	// be_aas_altroute.c
+	//--------------------------------------------
+	int			(*AAS_AlternativeRouteGoals)(vec3_t start, int startareanum, vec3_t goal, int goalareanum, int travelflags,
+										struct aas_altroutegoal_s *altroutegoals, int maxaltroutegoals,
+										int type);
+	//--------------------------------------------
+	// be_aas_move.c
+	//--------------------------------------------
+	int			(*AAS_Swimming)(vec3_t origin);
+	int			(*AAS_PredictClientMovement)(struct aas_clientmove_s *move,
+											int entnum, vec3_t origin,
+											int presencetype, int onground,
+											vec3_t velocity, vec3_t cmdmove,
+											int cmdframes,
+											int maxframes, float frametime,
+											int stopevent, int stopareanum, int visualize);
+} aas_export_t;
+
+typedef struct ea_export_s
+{
+	//ClientCommand elementary actions
+	void	(*EA_Command)(int client, char *command );
+	void	(*EA_Say)(int client, char *str);
+	void	(*EA_SayTeam)(int client, char *str);
+	//
+	void	(*EA_Action)(int client, int action);
+	void	(*EA_Gesture)(int client);
+	void	(*EA_Talk)(int client);
+	void	(*EA_Attack)(int client);
+	void	(*EA_Use)(int client);
+	void	(*EA_Respawn)(int client);
+	void	(*EA_MoveUp)(int client);
+	void	(*EA_MoveDown)(int client);
+	void	(*EA_MoveForward)(int client);
+	void	(*EA_MoveBack)(int client);
+	void	(*EA_MoveLeft)(int client);
+	void	(*EA_MoveRight)(int client);
+	void	(*EA_Crouch)(int client);
+	void	(*EA_Alt_Attack)(int client);
+	void	(*EA_ForcePower)(int client);
+
+	void	(*EA_SelectWeapon)(int client, int weapon);
+	void	(*EA_Jump)(int client);
+	void	(*EA_DelayedJump)(int client);
+	void	(*EA_Move)(int client, vec3_t dir, float speed);
+	void	(*EA_View)(int client, vec3_t viewangles);
+	//send regular input to the server
+	void	(*EA_EndRegular)(int client, float thinktime);
+	void	(*EA_GetInput)(int client, float thinktime, bot_input_t *input);
+	void	(*EA_ResetInput)(int client);
+} ea_export_t;
+
+typedef struct ai_export_s
+{
+	//-----------------------------------
+	// be_ai_char.h
+	//-----------------------------------
+	int		(*BotLoadCharacter)(char *charfile, float skill);
+	void	(*BotFreeCharacter)(int character);
+	float	(*Characteristic_Float)(int character, int index);
+	float	(*Characteristic_BFloat)(int character, int index, float min, float max);
+	int		(*Characteristic_Integer)(int character, int index);
+	int		(*Characteristic_BInteger)(int character, int index, int min, int max);
+	void	(*Characteristic_String)(int character, int index, char *buf, int size);
+	//-----------------------------------
+	// be_ai_chat.h
+	//-----------------------------------
+	int		(*BotAllocChatState)(void);
+	void	(*BotFreeChatState)(int handle);
+	void	(*BotQueueConsoleMessage)(int chatstate, int type, char *message);
+	void	(*BotRemoveConsoleMessage)(int chatstate, int handle);
+	int		(*BotNextConsoleMessage)(int chatstate, struct bot_consolemessage_s *cm);
+	int		(*BotNumConsoleMessages)(int chatstate);
+	void	(*BotInitialChat)(int chatstate, char *type, int mcontext, char *var0, char *var1, char *var2, char *var3, char *var4, char *var5, char *var6, char *var7);
+	int		(*BotNumInitialChats)(int chatstate, char *type);
+	int		(*BotReplyChat)(int chatstate, char *message, int mcontext, int vcontext, char *var0, char *var1, char *var2, char *var3, char *var4, char *var5, char *var6, char *var7);
+	int		(*BotChatLength)(int chatstate);
+	void	(*BotEnterChat)(int chatstate, int client, int sendto);
+	void	(*BotGetChatMessage)(int chatstate, char *buf, int size);
+	int		(*StringContains)(char *str1, char *str2, int casesensitive);
+	int		(*BotFindMatch)(char *str, struct bot_match_s *match, unsigned long int context);
+	void	(*BotMatchVariable)(struct bot_match_s *match, int variable, char *buf, int size);
+	void	(*UnifyWhiteSpaces)(char *string);
+	void	(*BotReplaceSynonyms)(char *string, unsigned long int context);
+	int		(*BotLoadChatFile)(int chatstate, char *chatfile, char *chatname);
+	void	(*BotSetChatGender)(int chatstate, int gender);
+	void	(*BotSetChatName)(int chatstate, char *name, int client);
+	//-----------------------------------
+	// be_ai_goal.h
+	//-----------------------------------
+	void	(*BotResetGoalState)(int goalstate);
+	void	(*BotResetAvoidGoals)(int goalstate);
+	void	(*BotRemoveFromAvoidGoals)(int goalstate, int number);
+	void	(*BotPushGoal)(int goalstate, struct bot_goal_s *goal);
+	void	(*BotPopGoal)(int goalstate);
+	void	(*BotEmptyGoalStack)(int goalstate);
+	void	(*BotDumpAvoidGoals)(int goalstate);
+	void	(*BotDumpGoalStack)(int goalstate);
+	void	(*BotGoalName)(int number, char *name, int size);
+	int		(*BotGetTopGoal)(int goalstate, struct bot_goal_s *goal);
+	int		(*BotGetSecondGoal)(int goalstate, struct bot_goal_s *goal);
+	int		(*BotChooseLTGItem)(int goalstate, vec3_t origin, int *inventory, int travelflags);
+	int		(*BotChooseNBGItem)(int goalstate, vec3_t origin, int *inventory, int travelflags,
+								struct bot_goal_s *ltg, float maxtime);
+	int		(*BotTouchingGoal)(vec3_t origin, struct bot_goal_s *goal);
+	int		(*BotItemGoalInVisButNotVisible)(int viewer, vec3_t eye, vec3_t viewangles, struct bot_goal_s *goal);
+	int		(*BotGetLevelItemGoal)(int index, char *classname, struct bot_goal_s *goal);
+	int		(*BotGetNextCampSpotGoal)(int num, struct bot_goal_s *goal);
+	int		(*BotGetMapLocationGoal)(char *name, struct bot_goal_s *goal);
+	float	(*BotAvoidGoalTime)(int goalstate, int number);
+	void	(*BotSetAvoidGoalTime)(int goalstate, int number, float avoidtime);
+	void	(*BotInitLevelItems)(void);
+	void	(*BotUpdateEntityItems)(void);
+	int		(*BotLoadItemWeights)(int goalstate, char *filename);
+	void	(*BotFreeItemWeights)(int goalstate);
+	void	(*BotInterbreedGoalFuzzyLogic)(int parent1, int parent2, int child);
+	void	(*BotSaveGoalFuzzyLogic)(int goalstate, char *filename);
+	void	(*BotMutateGoalFuzzyLogic)(int goalstate, float range);
+	int		(*BotAllocGoalState)(int client);
+	void	(*BotFreeGoalState)(int handle);
+	//-----------------------------------
+	// be_ai_move.h
+	//-----------------------------------
+	void	(*BotResetMoveState)(int movestate);
+	void	(*BotMoveToGoal)(struct bot_moveresult_s *result, int movestate, struct bot_goal_s *goal, int travelflags);
+	int		(*BotMoveInDirection)(int movestate, vec3_t dir, float speed, int type);
+	void	(*BotResetAvoidReach)(int movestate);
+	void	(*BotResetLastAvoidReach)(int movestate);
+	int		(*BotReachabilityArea)(vec3_t origin, int testground);
+	int		(*BotMovementViewTarget)(int movestate, struct bot_goal_s *goal, int travelflags, float lookahead, vec3_t target);
+	int		(*BotPredictVisiblePosition)(vec3_t origin, int areanum, struct bot_goal_s *goal, int travelflags, vec3_t target);
+	int		(*BotAllocMoveState)(void);
+	void	(*BotFreeMoveState)(int handle);
+	void	(*BotInitMoveState)(int handle, struct bot_initmove_s *initmove);
+	void	(*BotAddAvoidSpot)(int movestate, vec3_t origin, float radius, int type);
+	//-----------------------------------
+	// be_ai_weap.h
+	//-----------------------------------
+	int		(*BotChooseBestFightWeapon)(int weaponstate, int *inventory);
+	void	(*BotGetWeaponInfo)(int weaponstate, int weapon, struct weaponinfo_s *weaponinfo);
+	int		(*BotLoadWeaponWeights)(int weaponstate, char *filename);
+	int		(*BotAllocWeaponState)(void);
+	void	(*BotFreeWeaponState)(int weaponstate);
+	void	(*BotResetWeaponState)(int weaponstate);
+	//-----------------------------------
+	// be_ai_gen.h
+	//-----------------------------------
+	int		(*GeneticParentsAndChildSelection)(int numranks, float *ranks, int *parent1, int *parent2, int *child);
+} ai_export_t;
+
+//bot AI library imported functions
+typedef struct botlib_export_s
+{
+	//Area Awareness System functions
+	aas_export_t aas;
+	//Elementary Action functions
+	ea_export_t ea;
+	//AI functions
+	ai_export_t ai;
+	//setup the bot library, returns BLERR_
+	int (*BotLibSetup)(void);
+	//shutdown the bot library, returns BLERR_
+	int (*BotLibShutdown)(void);
+	//sets a library variable returns BLERR_
+	int (*BotLibVarSet)(char *var_name, char *value);
+	//gets a library variable returns BLERR_
+	int (*BotLibVarGet)(char *var_name, char *value, int size);
+
+	//sets a C-like define returns BLERR_
+	int (*PC_AddGlobalDefine)(char *string);
+	int (*PC_LoadSourceHandle)(const char *filename);
+	int (*PC_FreeSourceHandle)(int handle);
+	int (*PC_ReadTokenHandle)(int handle, pc_token_t *pc_token);
+	int (*PC_SourceFileAndLine)(int handle, char *filename, int *line);
+	int (*PC_LoadGlobalDefines)(const char* filename );
+	void (*PC_RemoveAllGlobalDefines) ( void );
+
+	//start a frame in the bot library
+	int (*BotLibStartFrame)(float time);
+	//load a new map in the bot library
+	int (*BotLibLoadMap)(const char *mapname);
+	//entity updates
+	int (*BotLibUpdateEntity)(int ent, bot_entitystate_t *state);
+	//just for testing
+	int (*Test)(int parm0, char *parm1, vec3_t parm2, vec3_t parm3);
+} botlib_export_t;
+
+//linking of bot library
+botlib_export_t *GetBotLibAPI( int apiVersion, botlib_import_t *import );
+
+/* Library variables:
+
+name:						default:			module(s):			description:
+
+"basedir"					""					l_utils.c			base directory
+"gamedir"					""					l_utils.c			game directory
+"cddir"						""					l_utils.c			CD directory
+
+"log"						"0"					l_log.c				enable/disable creating a log file
+"maxclients"				"4"					be_interface.c		maximum number of clients
+"maxentities"				"1024"				be_interface.c		maximum number of entities
+"bot_developer"				"0"					be_interface.c		bot developer mode
+
+"phys_friction"				"6"					be_aas_move.c		ground friction
+"phys_stopspeed"			"100"				be_aas_move.c		stop speed
+"phys_gravity"				"800"				be_aas_move.c		gravity value
+"phys_waterfriction"		"1"					be_aas_move.c		water friction
+"phys_watergravity"			"400"				be_aas_move.c		gravity in water
+"phys_maxvelocity"			"320"				be_aas_move.c		maximum velocity
+"phys_maxwalkvelocity"		"320"				be_aas_move.c		maximum walk velocity
+"phys_maxcrouchvelocity"	"100"				be_aas_move.c		maximum crouch velocity
+"phys_maxswimvelocity"		"150"				be_aas_move.c		maximum swim velocity
+"phys_walkaccelerate"		"10"				be_aas_move.c		walk acceleration
+"phys_airaccelerate"		"1"					be_aas_move.c		air acceleration
+"phys_swimaccelerate"		"4"					be_aas_move.c		swim acceleration
+"phys_maxstep"				"18"				be_aas_move.c		maximum step height
+"phys_maxsteepness"			"0.7"				be_aas_move.c		maximum floor steepness
+"phys_maxbarrier"			"32"				be_aas_move.c		maximum barrier height
+"phys_maxwaterjump"			"19"				be_aas_move.c		maximum waterjump height
+"phys_jumpvel"				"270"				be_aas_move.c		jump z velocity
+"phys_falldelta5"			"40"				be_aas_move.c
+"phys_falldelta10"			"60"				be_aas_move.c
+"rs_waterjump"				"400"				be_aas_move.c
+"rs_teleport"				"50"				be_aas_move.c
+"rs_barrierjump"			"100"				be_aas_move.c
+"rs_startcrouch"			"300"				be_aas_move.c
+"rs_startgrapple"			"500"				be_aas_move.c
+"rs_startwalkoffledge"		"70"				be_aas_move.c
+"rs_startjump"				"300"				be_aas_move.c
+"rs_rocketjump"				"500"				be_aas_move.c
+"rs_bfgjump"				"500"				be_aas_move.c
+"rs_jumppad"				"250"				be_aas_move.c
+"rs_aircontrolledjumppad"	"300"				be_aas_move.c
+"rs_funcbob"				"300"				be_aas_move.c
+"rs_startelevator"			"50"				be_aas_move.c
+"rs_falldamage5"			"300"				be_aas_move.c
+"rs_falldamage10"			"500"				be_aas_move.c
+"rs_maxjumpfallheight"		"450"				be_aas_move.c
+
+"max_aaslinks"				"4096"				be_aas_sample.c		maximum links in the AAS
+"max_routingcache"			"4096"				be_aas_route.c		maximum routing cache size in KB
+"forceclustering"			"0"					be_aas_main.c		force recalculation of clusters
+"forcereachability"			"0"					be_aas_main.c		force recalculation of reachabilities
+"forcewrite"				"0"					be_aas_main.c		force writing of aas file
+"aasoptimize"				"0"					be_aas_main.c		enable aas optimization
+"sv_mapChecksum"			"0"					be_aas_main.c		BSP file checksum
+"bot_visualizejumppads"		"0"					be_aas_reach.c		visualize jump pads
+
+"bot_reloadcharacters"		"0"					-					reload bot character files
+"ai_gametype"				"0"					be_ai_goal.c		game type
+"droppedweight"				"1000"				be_ai_goal.c		additional dropped item weight
+"weapindex_rocketlauncher"	"5"					be_ai_move.c		rl weapon index for rocket jumping
+"weapindex_bfg10k"			"9"					be_ai_move.c		bfg weapon index for bfg jumping
+"weapindex_grapple"			"10"				be_ai_move.c		grapple weapon index for grappling
+"entitytypemissile"			"3"					be_ai_move.c		ET_MISSILE
+"offhandgrapple"			"0"					be_ai_move.c		enable off hand grapple hook
+"cmd_grappleon"				"grappleon"			be_ai_move.c		command to activate off hand grapple
+"cmd_grappleoff"			"grappleoff"		be_ai_move.c		command to deactivate off hand grapple
+"itemconfig"				"items.c"			be_ai_goal.c		item configuration file
+"weaponconfig"				"weapons.c"			be_ai_weap.c		weapon configuration file
+"synfile"					"syn.c"				be_ai_chat.c		file with synonyms
+"rndfile"					"rnd.c"				be_ai_chat.c		file with random strings
+"matchfile"					"match.c"			be_ai_chat.c		file with match strings
+"nochat"					"0"					be_ai_chat.c		disable chats
+"max_messages"				"1024"				be_ai_chat.c		console message heap size
+"max_weaponinfo"			"32"				be_ai_weap.c		maximum number of weapon info
+"max_projectileinfo"		"32"				be_ai_weap.c		maximum number of projectile info
+"max_iteminfo"				"256"				be_ai_goal.c		maximum number of item info
+"max_levelitems"			"256"				be_ai_goal.c		maximum number of level items
+
+*/
+
diff --git a/codemp/game/chars.h b/codemp/game/chars.h
new file mode 100644
index 0000000..45682a3
--- /dev/null
+++ b/codemp/game/chars.h
@@ -0,0 +1,124 @@
+// Copyright (C) 1999-2000 Id Software, Inc.
+//
+//===========================================================================
+//
+// Name:			chars.h
+// Function:		bot characteristics
+// Programmer:		Mr Elusive (MrElusive@idsoftware.com)
+// Last update:		1999-09-08
+// Tab Size:		4 (real tabs)
+//===========================================================================
+
+
+//========================================================
+//========================================================
+//name
+#define CHARACTERISTIC_NAME							0	//string
+//gender of the bot
+#define CHARACTERISTIC_GENDER						1	//string ("male", "female", "it")
+//attack skill
+// >  0.0 && <  0.2 = don't move
+// >  0.3 && <  1.0 = aim at enemy during retreat
+// >  0.0 && <  0.4 = only move forward/backward
+// >= 0.4 && <  1.0 = circle strafing
+// >  0.7 && <  1.0 = random strafe direction change
+#define CHARACTERISTIC_ATTACK_SKILL					2	//float [0, 1]
+//weapon weight file
+#define CHARACTERISTIC_WEAPONWEIGHTS				3	//string
+//view angle difference to angle change factor
+#define CHARACTERISTIC_VIEW_FACTOR					4	//float <0, 1]
+//maximum view angle change
+#define CHARACTERISTIC_VIEW_MAXCHANGE				5	//float [1, 360]
+//reaction time in seconds
+#define CHARACTERISTIC_REACTIONTIME					6	//float [0, 5]
+//accuracy when aiming
+#define CHARACTERISTIC_AIM_ACCURACY					7	//float [0, 1]
+//weapon specific aim accuracy
+#define CHARACTERISTIC_AIM_ACCURACY_MACHINEGUN		8	//float [0, 1]
+#define CHARACTERISTIC_AIM_ACCURACY_SHOTGUN			9	//float [0, 1]
+#define CHARACTERISTIC_AIM_ACCURACY_ROCKETLAUNCHER	10	//float [0, 1]
+#define CHARACTERISTIC_AIM_ACCURACY_GRENADELAUNCHER	11	//float [0, 1]
+#define CHARACTERISTIC_AIM_ACCURACY_LIGHTNING		12
+#define CHARACTERISTIC_AIM_ACCURACY_PLASMAGUN		13	//float [0, 1]
+#define CHARACTERISTIC_AIM_ACCURACY_RAILGUN			14
+#define CHARACTERISTIC_AIM_ACCURACY_BFG10K			15	//float [0, 1]
+//skill when aiming
+// >  0.0 && <  0.9 = aim is affected by enemy movement
+// >  0.4 && <= 0.8 = enemy linear leading
+// >  0.8 && <= 1.0 = enemy exact movement leading
+// >  0.5 && <= 1.0 = prediction shots when enemy is not visible
+// >  0.6 && <= 1.0 = splash damage by shooting nearby geometry
+#define CHARACTERISTIC_AIM_SKILL					16	//float [0, 1]
+//weapon specific aim skill
+#define CHARACTERISTIC_AIM_SKILL_ROCKETLAUNCHER		17	//float [0, 1]
+#define CHARACTERISTIC_AIM_SKILL_GRENADELAUNCHER	18	//float [0, 1]
+#define CHARACTERISTIC_AIM_SKILL_PLASMAGUN			19	//float [0, 1]
+#define CHARACTERISTIC_AIM_SKILL_BFG10K				20	//float [0, 1]
+//========================================================
+//chat
+//========================================================
+//file with chats
+#define CHARACTERISTIC_CHAT_FILE					21	//string
+//name of the chat character
+#define CHARACTERISTIC_CHAT_NAME					22	//string
+//characters per minute type speed
+#define CHARACTERISTIC_CHAT_CPM						23	//integer [1, 4000]
+//tendency to insult/praise
+#define CHARACTERISTIC_CHAT_INSULT					24	//float [0, 1]
+//tendency to chat misc
+#define CHARACTERISTIC_CHAT_MISC					25	//float [0, 1]
+//tendency to chat at start or end of level
+#define CHARACTERISTIC_CHAT_STARTENDLEVEL			26	//float [0, 1]
+//tendency to chat entering or exiting the game
+#define CHARACTERISTIC_CHAT_ENTEREXITGAME			27	//float [0, 1]
+//tendency to chat when killed someone
+#define CHARACTERISTIC_CHAT_KILL					28	//float [0, 1]
+//tendency to chat when died
+#define CHARACTERISTIC_CHAT_DEATH					29	//float [0, 1]
+//tendency to chat when enemy suicides
+#define CHARACTERISTIC_CHAT_ENEMYSUICIDE			30	//float [0, 1]
+//tendency to chat when hit while talking
+#define CHARACTERISTIC_CHAT_HITTALKING				31	//float [0, 1]
+//tendency to chat when bot was hit but didn't dye
+#define CHARACTERISTIC_CHAT_HITNODEATH				32	//float [0, 1]
+//tendency to chat when bot hit the enemy but enemy didn't dye
+#define CHARACTERISTIC_CHAT_HITNOKILL				33	//float [0, 1]
+//tendency to randomly chat
+#define CHARACTERISTIC_CHAT_RANDOM					34	//float [0, 1]
+//tendency to reply
+#define CHARACTERISTIC_CHAT_REPLY					35	//float [0, 1]
+//========================================================
+//movement
+//========================================================
+//tendency to crouch
+#define CHARACTERISTIC_CROUCHER						36	//float [0, 1]
+//tendency to jump
+#define CHARACTERISTIC_JUMPER						37	//float [0, 1]
+//tendency to walk
+#define CHARACTERISTIC_WALKER						48	//float [0, 1]
+//tendency to jump using a weapon
+#define CHARACTERISTIC_WEAPONJUMPING				38	//float [0, 1]
+//tendency to use the grapple hook when available
+#define CHARACTERISTIC_GRAPPLE_USER					39	//float [0, 1]	//use this!!
+//========================================================
+//goal
+//========================================================
+//item weight file
+#define CHARACTERISTIC_ITEMWEIGHTS					40	//string
+//the aggression of the bot
+#define CHARACTERISTIC_AGGRESSION					41	//float [0, 1]
+//the self preservation of the bot (rockets near walls etc.)
+#define CHARACTERISTIC_SELFPRESERVATION				42	//float [0, 1]
+//how likely the bot is to take revenge
+#define CHARACTERISTIC_VENGEFULNESS					43	//float [0, 1]	//use this!!
+//tendency to camp
+#define CHARACTERISTIC_CAMPER						44	//float [0, 1]
+//========================================================
+//========================================================
+//tendency to get easy frags
+#define CHARACTERISTIC_EASY_FRAGGER					45	//float [0, 1]
+//how alert the bot is (view distance)
+#define CHARACTERISTIC_ALERTNESS					46	//float [0, 1]
+//how much the bot fires it's weapon
+#define CHARACTERISTIC_FIRETHROTTLE					47	//float [0, 1]
+
diff --git a/codemp/game/g_ICARUScb.c b/codemp/game/g_ICARUScb.c
new file mode 100644
index 0000000..bbbf72c
--- /dev/null
+++ b/codemp/game/g_ICARUScb.c
@@ -0,0 +1,5794 @@
+//====================================================================================
+//
+//rww - ICARUS callback file, all that can be handled within vm's is handled in here.
+//
+//====================================================================================
+
+#include "q_shared.h"
+#include "bg_public.h"
+#include "b_local.h"
+#include "../icarus/Q3_Interface.h"
+#include "../icarus/Q3_Registers.h"
+#include "g_nav.h"
+
+#include "../namespace_begin.h"
+qboolean BG_SabersOff( playerState_t *ps );
+#include "../namespace_end.h"
+
+extern stringID_table_t BSTable[];
+
+//This is a hack I guess. It's because we can't include the file this enum is in
+//unless we're using cpp. But we need it for the interpreter stuff.
+//In any case, DO NOT modify this enum.
+
+// Hack++
+// This code is compiled as C++ on Xbox. We could try and rig something above
+// so that we only get the C version of the includes (no full Icarus) in that
+// scenario, but I think we'll just try to leave this out instead.
+#ifndef _XBOX
+#ifndef __linux__
+enum
+{
+	TK_EOF = -1,
+	TK_UNDEFINED,
+	TK_COMMENT,
+	TK_EOL,
+	TK_CHAR,
+	TK_STRING,
+	TK_INT,
+	TK_INTEGER = TK_INT,
+	TK_FLOAT,
+	TK_IDENTIFIER,
+	TK_USERDEF,
+};
+#endif
+#endif
+
+#include "../icarus/interpreter.h"
+
+extern stringID_table_t animTable [MAX_ANIMATIONS+1];
+
+stringID_table_t setTable[] =
+{
+	ENUM2STRING(SET_SPAWNSCRIPT),//0
+	ENUM2STRING(SET_USESCRIPT),
+	ENUM2STRING(SET_AWAKESCRIPT),
+	ENUM2STRING(SET_ANGERSCRIPT),
+	ENUM2STRING(SET_ATTACKSCRIPT),
+	ENUM2STRING(SET_VICTORYSCRIPT),
+	ENUM2STRING(SET_PAINSCRIPT),
+	ENUM2STRING(SET_FLEESCRIPT),
+	ENUM2STRING(SET_DEATHSCRIPT),
+	ENUM2STRING(SET_DELAYEDSCRIPT),
+	ENUM2STRING(SET_BLOCKEDSCRIPT),
+	ENUM2STRING(SET_FFIRESCRIPT),
+	ENUM2STRING(SET_FFDEATHSCRIPT),
+	ENUM2STRING(SET_MINDTRICKSCRIPT),
+	ENUM2STRING(SET_NO_MINDTRICK),
+	ENUM2STRING(SET_ORIGIN),
+	ENUM2STRING(SET_TELEPORT_DEST),
+	ENUM2STRING(SET_ANGLES),
+	ENUM2STRING(SET_XVELOCITY),
+	ENUM2STRING(SET_YVELOCITY),
+	ENUM2STRING(SET_ZVELOCITY),
+	ENUM2STRING(SET_Z_OFFSET),
+	ENUM2STRING(SET_ENEMY),
+	ENUM2STRING(SET_LEADER),
+	ENUM2STRING(SET_NAVGOAL),
+	ENUM2STRING(SET_ANIM_UPPER),
+	ENUM2STRING(SET_ANIM_LOWER),
+	ENUM2STRING(SET_ANIM_BOTH),
+	ENUM2STRING(SET_ANIM_HOLDTIME_LOWER),
+	ENUM2STRING(SET_ANIM_HOLDTIME_UPPER),
+	ENUM2STRING(SET_ANIM_HOLDTIME_BOTH),
+	ENUM2STRING(SET_PLAYER_TEAM),
+	ENUM2STRING(SET_ENEMY_TEAM),
+	ENUM2STRING(SET_BEHAVIOR_STATE),
+	ENUM2STRING(SET_BEHAVIOR_STATE),
+	ENUM2STRING(SET_HEALTH),
+	ENUM2STRING(SET_ARMOR),
+	ENUM2STRING(SET_DEFAULT_BSTATE),
+	ENUM2STRING(SET_CAPTURE),
+	ENUM2STRING(SET_DPITCH),
+	ENUM2STRING(SET_DYAW),
+	ENUM2STRING(SET_EVENT),
+	ENUM2STRING(SET_TEMP_BSTATE),
+	ENUM2STRING(SET_COPY_ORIGIN),
+	ENUM2STRING(SET_VIEWTARGET),
+	ENUM2STRING(SET_WEAPON),
+	ENUM2STRING(SET_ITEM),
+	ENUM2STRING(SET_WALKSPEED),
+	ENUM2STRING(SET_RUNSPEED),
+	ENUM2STRING(SET_YAWSPEED),
+	ENUM2STRING(SET_AGGRESSION),
+	ENUM2STRING(SET_AIM),
+	ENUM2STRING(SET_FRICTION),
+	ENUM2STRING(SET_GRAVITY),
+	ENUM2STRING(SET_IGNOREPAIN),
+	ENUM2STRING(SET_IGNOREENEMIES),
+	ENUM2STRING(SET_IGNOREALERTS),
+	ENUM2STRING(SET_DONTSHOOT),
+	ENUM2STRING(SET_DONTFIRE),
+	ENUM2STRING(SET_LOCKED_ENEMY),
+	ENUM2STRING(SET_NOTARGET),
+	ENUM2STRING(SET_LEAN),
+	ENUM2STRING(SET_CROUCHED),
+	ENUM2STRING(SET_WALKING),
+	ENUM2STRING(SET_RUNNING),
+	ENUM2STRING(SET_CHASE_ENEMIES),
+	ENUM2STRING(SET_LOOK_FOR_ENEMIES),
+	ENUM2STRING(SET_FACE_MOVE_DIR),
+	ENUM2STRING(SET_ALT_FIRE),
+	ENUM2STRING(SET_DONT_FLEE),
+	ENUM2STRING(SET_FORCED_MARCH),
+	ENUM2STRING(SET_NO_RESPONSE),
+	ENUM2STRING(SET_NO_COMBAT_TALK),
+	ENUM2STRING(SET_NO_ALERT_TALK),
+	ENUM2STRING(SET_UNDYING),
+	ENUM2STRING(SET_TREASONED),
+	ENUM2STRING(SET_DISABLE_SHADER_ANIM),
+	ENUM2STRING(SET_SHADER_ANIM),
+	ENUM2STRING(SET_INVINCIBLE),
+	ENUM2STRING(SET_NOAVOID),
+	ENUM2STRING(SET_SHOOTDIST),
+	ENUM2STRING(SET_TARGETNAME),
+	ENUM2STRING(SET_TARGET),
+	ENUM2STRING(SET_TARGET2),
+	ENUM2STRING(SET_LOCATION),
+	ENUM2STRING(SET_PAINTARGET),
+	ENUM2STRING(SET_TIMESCALE),
+	ENUM2STRING(SET_VISRANGE),
+	ENUM2STRING(SET_EARSHOT),
+	ENUM2STRING(SET_VIGILANCE),
+	ENUM2STRING(SET_HFOV),
+	ENUM2STRING(SET_VFOV),
+	ENUM2STRING(SET_DELAYSCRIPTTIME),
+	ENUM2STRING(SET_FORWARDMOVE),
+	ENUM2STRING(SET_RIGHTMOVE),
+	ENUM2STRING(SET_LOCKYAW),
+	ENUM2STRING(SET_SOLID),
+	ENUM2STRING(SET_CAMERA_GROUP),
+	ENUM2STRING(SET_CAMERA_GROUP_Z_OFS),
+	ENUM2STRING(SET_CAMERA_GROUP_TAG),
+	ENUM2STRING(SET_LOOK_TARGET),
+	ENUM2STRING(SET_ADDRHANDBOLT_MODEL),
+	ENUM2STRING(SET_REMOVERHANDBOLT_MODEL),
+	ENUM2STRING(SET_ADDLHANDBOLT_MODEL),
+	ENUM2STRING(SET_REMOVELHANDBOLT_MODEL),
+	ENUM2STRING(SET_FACEAUX),
+	ENUM2STRING(SET_FACEBLINK),
+	ENUM2STRING(SET_FACEBLINKFROWN),
+	ENUM2STRING(SET_FACEFROWN),
+	ENUM2STRING(SET_FACENORMAL),
+	ENUM2STRING(SET_FACEEYESCLOSED),
+	ENUM2STRING(SET_FACEEYESOPENED),
+	ENUM2STRING(SET_SCROLLTEXT),
+	ENUM2STRING(SET_LCARSTEXT),
+	ENUM2STRING(SET_SCROLLTEXTCOLOR),
+	ENUM2STRING(SET_CAPTIONTEXTCOLOR),
+	ENUM2STRING(SET_CENTERTEXTCOLOR),
+	ENUM2STRING(SET_PLAYER_USABLE),
+	ENUM2STRING(SET_STARTFRAME),
+	ENUM2STRING(SET_ENDFRAME),
+	ENUM2STRING(SET_ANIMFRAME),
+	ENUM2STRING(SET_LOOP_ANIM),
+	ENUM2STRING(SET_INTERFACE),
+	ENUM2STRING(SET_SHIELDS),
+	ENUM2STRING(SET_NO_KNOCKBACK),
+	ENUM2STRING(SET_INVISIBLE),
+	ENUM2STRING(SET_VAMPIRE),
+	ENUM2STRING(SET_FORCE_INVINCIBLE),
+	ENUM2STRING(SET_GREET_ALLIES),
+	ENUM2STRING(SET_PLAYER_LOCKED),
+	ENUM2STRING(SET_LOCK_PLAYER_WEAPONS),
+	ENUM2STRING(SET_NO_IMPACT_DAMAGE),
+	ENUM2STRING(SET_PARM1),
+	ENUM2STRING(SET_PARM2),
+	ENUM2STRING(SET_PARM3),
+	ENUM2STRING(SET_PARM4),
+	ENUM2STRING(SET_PARM5),
+	ENUM2STRING(SET_PARM6),
+	ENUM2STRING(SET_PARM7),
+	ENUM2STRING(SET_PARM8),
+	ENUM2STRING(SET_PARM9),
+	ENUM2STRING(SET_PARM10),
+	ENUM2STRING(SET_PARM11),
+	ENUM2STRING(SET_PARM12),
+	ENUM2STRING(SET_PARM13),
+	ENUM2STRING(SET_PARM14),
+	ENUM2STRING(SET_PARM15),
+	ENUM2STRING(SET_PARM16),
+	ENUM2STRING(SET_DEFEND_TARGET),
+	ENUM2STRING(SET_WAIT),
+	ENUM2STRING(SET_COUNT),
+	ENUM2STRING(SET_SHOT_SPACING),
+	ENUM2STRING(SET_VIDEO_PLAY),
+	ENUM2STRING(SET_VIDEO_FADE_IN),
+	ENUM2STRING(SET_VIDEO_FADE_OUT),
+	ENUM2STRING(SET_REMOVE_TARGET),
+	ENUM2STRING(SET_LOADGAME),
+	ENUM2STRING(SET_MENU_SCREEN),
+	ENUM2STRING(SET_OBJECTIVE_SHOW),
+	ENUM2STRING(SET_OBJECTIVE_HIDE),
+	ENUM2STRING(SET_OBJECTIVE_SUCCEEDED),
+	ENUM2STRING(SET_OBJECTIVE_FAILED),
+	ENUM2STRING(SET_MISSIONFAILED),
+	ENUM2STRING(SET_TACTICAL_SHOW),
+	ENUM2STRING(SET_TACTICAL_HIDE),
+	ENUM2STRING(SET_FOLLOWDIST),
+	ENUM2STRING(SET_SCALE),
+	ENUM2STRING(SET_OBJECTIVE_CLEARALL),
+	ENUM2STRING(SET_MISSIONSTATUSTEXT),
+	ENUM2STRING(SET_WIDTH),
+	ENUM2STRING(SET_CLOSINGCREDITS),
+	ENUM2STRING(SET_SKILL),
+	ENUM2STRING(SET_MISSIONSTATUSTIME),
+	ENUM2STRING(SET_FULLNAME),
+	ENUM2STRING(SET_FORCE_HEAL_LEVEL),
+	ENUM2STRING(SET_FORCE_JUMP_LEVEL),
+	ENUM2STRING(SET_FORCE_SPEED_LEVEL),
+	ENUM2STRING(SET_FORCE_PUSH_LEVEL),
+	ENUM2STRING(SET_FORCE_PULL_LEVEL),
+	ENUM2STRING(SET_FORCE_MINDTRICK_LEVEL),
+	ENUM2STRING(SET_FORCE_GRIP_LEVEL),
+	ENUM2STRING(SET_FORCE_LIGHTNING_LEVEL),
+	ENUM2STRING(SET_SABER_THROW),
+	ENUM2STRING(SET_SABER_DEFENSE),
+	ENUM2STRING(SET_SABER_OFFENSE),
+	ENUM2STRING(SET_VIEWENTITY),
+	ENUM2STRING(SET_WATCHTARGET),
+	ENUM2STRING(SET_SABERACTIVE),
+	ENUM2STRING(SET_ADJUST_AREA_PORTALS),
+	ENUM2STRING(SET_DMG_BY_HEAVY_WEAP_ONLY),
+	ENUM2STRING(SET_SHIELDED),
+	ENUM2STRING(SET_NO_GROUPS),
+	ENUM2STRING(SET_FIRE_WEAPON),
+	ENUM2STRING(SET_INACTIVE),
+	ENUM2STRING(SET_FUNC_USABLE_VISIBLE),
+	ENUM2STRING(SET_MISSION_STATUS_SCREEN),
+	ENUM2STRING(SET_END_SCREENDISSOLVE),
+	ENUM2STRING(SET_LOOPSOUND),
+	ENUM2STRING(SET_ICARUS_FREEZE),
+	ENUM2STRING(SET_ICARUS_UNFREEZE),
+	ENUM2STRING(SET_USE_CP_NEAREST),
+	ENUM2STRING(SET_MORELIGHT),
+	ENUM2STRING(SET_CINEMATIC_SKIPSCRIPT),
+	ENUM2STRING(SET_NO_FORCE),
+	ENUM2STRING(SET_NO_FALLTODEATH),
+	ENUM2STRING(SET_DISMEMBERABLE),
+	ENUM2STRING(SET_NO_ACROBATICS),
+	ENUM2STRING(SET_MUSIC_STATE),
+	ENUM2STRING(SET_USE_SUBTITLES),
+	ENUM2STRING(SET_CLEAN_DAMAGING_ENTS),
+	ENUM2STRING(SET_HUD),
+
+//FIXME: add BOTH_ attributes here too
+	"",	SET_,
+};
+
+void Q3_TaskIDClear( int *taskID )
+{
+	*taskID = -1;
+}
+
+void G_DebugPrint( int level, const char *format, ... )
+{
+	va_list		argptr;
+	char		text[1024];
+
+	//Don't print messages they don't want to see
+	//if ( g_ICARUSDebug->integer < level )
+	if (g_developer.integer != 2)
+		return;
+
+	va_start (argptr, format);
+	vsprintf (text, format, argptr);
+	va_end (argptr);
+
+	//Add the color formatting
+	switch ( level )
+	{
+		case WL_ERROR:
+			Com_Printf ( S_COLOR_RED"ERROR: %s", text );
+			break;
+		
+		case WL_WARNING:
+			Com_Printf ( S_COLOR_YELLOW"WARNING: %s", text );
+			break;
+		
+		case WL_DEBUG:
+			{
+				int		entNum;
+				char	*buffer;
+
+				sscanf( text, "%d", &entNum );
+
+				//if ( ( ICARUS_entFilter >= 0 ) && ( ICARUS_entFilter != entNum ) )
+				//	return;
+
+				buffer = (char *) text;
+				buffer += 5;
+
+				if ( ( entNum < 0 ) || ( entNum > MAX_GENTITIES ) )
+					entNum = 0;
+
+				Com_Printf ( S_COLOR_BLUE"DEBUG: %s(%d): %s\n", g_entities[entNum].script_targetname, entNum, buffer );
+				break;
+			}
+		default:
+		case WL_VERBOSE:
+			Com_Printf ( S_COLOR_GREEN"INFO: %s", text );
+			break;
+	}
+}
+
+/*
+-------------------------
+Q3_GetAnimLower
+-------------------------
+*/
+static char *Q3_GetAnimLower( gentity_t *ent )
+{
+	int anim = 0;
+
+	if ( ent->client == NULL )
+	{
+		G_DebugPrint( WL_WARNING, "Q3_GetAnimLower: attempted to read animation state off non-client!\n" );
+		return NULL;
+	}
+
+	anim = ent->client->ps.legsAnim;
+
+	return (char *)animTable[anim].name;
+}
+
+/*
+-------------------------
+Q3_GetAnimUpper
+-------------------------
+*/
+static char *Q3_GetAnimUpper( gentity_t *ent )
+{
+	int anim = 0;
+
+	if ( ent->client == NULL )
+	{
+		G_DebugPrint( WL_WARNING, "Q3_GetAnimUpper: attempted to read animation state off non-client!\n" );
+		return NULL;
+	}
+
+	anim = ent->client->ps.torsoAnim;
+
+	return (char *)animTable[anim].name;
+}
+
+/*
+-------------------------
+Q3_GetAnimBoth
+-------------------------
+*/
+static char *Q3_GetAnimBoth( gentity_t *ent )
+{
+ 	char	*lowerName, *upperName;
+
+	lowerName = Q3_GetAnimLower( ent );
+	upperName = Q3_GetAnimUpper( ent );
+
+	if ( !lowerName || !lowerName[0] )
+	{
+		G_DebugPrint( WL_WARNING, "Q3_GetAnimBoth: NULL legs animation string found!\n" );
+		return NULL;
+	}
+
+	if ( !upperName || !upperName[0] )
+	{
+		G_DebugPrint( WL_WARNING, "Q3_GetAnimBoth: NULL torso animation string found!\n" );
+		return NULL;
+	}
+
+	if ( Q_stricmp( lowerName, upperName ) )
+	{
+#ifdef _DEBUG	// sigh, cut down on tester reports that aren't important
+		G_DebugPrint( WL_WARNING, "Q3_GetAnimBoth: legs and torso animations did not match : returning legs\n" );
+#endif
+	}
+
+	return lowerName;
+}
+
+int Q3_PlaySound( int taskID, int entID, const char *name, const char *channel )
+{
+	gentity_t		*ent = &g_entities[entID];
+	char			finalName[MAX_QPATH];
+	soundChannel_t	voice_chan = CHAN_VOICE; // set a default so the compiler doesn't bitch
+	qboolean		type_voice = qfalse;
+	int				soundHandle;
+	qboolean		bBroadcast;
+
+	Q_strncpyz( finalName, name, MAX_QPATH );
+	Q_strupr(finalName);
+	//G_AddSexToMunroString( finalName, qtrue );
+
+	COM_StripExtension( (const char *)finalName, finalName );
+
+	soundHandle = G_SoundIndex( (char *) finalName );
+	bBroadcast = qfalse;
+
+	if ( ( Q_stricmp( channel, "CHAN_ANNOUNCER" ) == 0 ) || (ent->classname && Q_stricmp("target_scriptrunner", ent->classname ) == 0) ) {
+		bBroadcast = qtrue;
+	}
+
+
+	// moved here from further down so I can easily check channel-type without code dup...
+	//
+	if ( Q_stricmp( channel, "CHAN_VOICE" ) == 0 )
+	{
+		voice_chan = CHAN_VOICE;
+		type_voice = qtrue;
+	}
+	else if ( Q_stricmp( channel, "CHAN_VOICE_ATTEN" ) == 0 )
+	{
+		voice_chan = CHAN_AUTO;//CHAN_VOICE_ATTEN;
+		type_voice = qtrue;
+	}
+	else if ( Q_stricmp( channel, "CHAN_VOICE_GLOBAL" ) == 0 ) // this should broadcast to everyone, put only casue animation on G_SoundOnEnt...
+	{
+		voice_chan = CHAN_AUTO;//CHAN_VOICE_GLOBAL;
+		type_voice = qtrue;
+		bBroadcast = qtrue;
+	}
+
+	// if we're in-camera, check for skipping cinematic and ifso, no subtitle print (since screen is not being
+	//	updated anyway during skipping). This stops leftover subtitles being left onscreen after unskipping.
+	//
+	/*
+	if (!in_camera ||
+		(!g_skippingcin || !g_skippingcin->integer)
+		)	// paranoia towards project end <g>
+	{
+		// Text on
+		// certain NPC's we always want to use subtitles regardless of subtitle setting
+		if (g_subtitles->integer == 1 || (ent->NPC && (ent->NPC->scriptFlags & SCF_USE_SUBTITLES) ) ) // Show all text
+		{
+			if ( in_camera)	// Cinematic
+			{					
+				trap_SendServerCommand( -1, va("ct \"%s\" %i", finalName, soundHandle) );
+			}
+			else //if (precacheWav[i].speaker==SP_NONE)	//  lower screen text
+			{
+				sharedEntity_t		*ent2 = SV_GentityNum(0);
+				// the numbers in here were either the original ones Bob entered (350), or one arrived at from checking the distance Chell stands at in stasis2 by the computer core that was submitted as a bug report...
+				//
+				if (bBroadcast || (DistanceSquared(ent->currentOrigin, ent2->currentOrigin) < ((voice_chan == CHAN_VOICE_ATTEN)?(350 * 350):(1200 * 1200)) ) )
+				{
+					trap_SendServerCommand( -1, va("ct \"%s\" %i", finalName, soundHandle) );
+				}
+			}
+		}
+		// Cinematic only
+		else if (g_subtitles->integer == 2) // Show only talking head text and CINEMATIC
+		{
+			if ( in_camera)	// Cinematic text
+			{							
+				trap_SendServerCommand( -1, va("ct \"%s\" %i", finalName, soundHandle));
+			}
+		}
+
+	}
+	*/
+
+	if ( type_voice )
+	{
+		char buf[128];
+		float tFVal = 0;
+
+		trap_Cvar_VariableStringBuffer("timescale", buf, sizeof(buf));
+
+		tFVal = atof(buf);
+
+
+		if ( tFVal > 1.0f )
+		{//Skip the damn sound!
+			return qtrue;
+		}
+		else
+		{
+			//This the voice channel
+			G_Sound( ent, voice_chan, G_SoundIndex((char *) finalName) );
+		}
+		//Remember we're waiting for this
+		trap_ICARUS_TaskIDSet( ent, TID_CHAN_VOICE, taskID );
+
+		return qfalse;
+	}
+
+	if ( bBroadcast )
+	{//Broadcast the sound
+		gentity_t	*te;
+
+		te = G_TempEntity( ent->r.currentOrigin, EV_GLOBAL_SOUND );
+		te->s.eventParm = soundHandle;
+		te->r.svFlags |= SVF_BROADCAST;
+	}
+	else
+	{
+		G_Sound( ent, CHAN_AUTO, soundHandle );
+	}
+
+	return qtrue;
+}
+
+/*
+-------------------------
+Q3_Play
+-------------------------
+*/
+void Q3_Play( int taskID, int entID, const char *type, const char *name )
+{
+	gentity_t *ent = &g_entities[entID];
+
+	if ( !Q_stricmp( type, "PLAY_ROFF" ) )
+	{
+		// Try to load the requested ROFF
+		ent->roffid = trap_ROFF_Cache((char*)name);
+		if ( ent->roffid )
+		{
+			ent->roffname = G_NewString( name );
+
+			// Start the roff from the beginning
+			//ent->roff_ctr = 0;
+
+			//Save this off for later
+			trap_ICARUS_TaskIDSet( ent, TID_MOVE_NAV, taskID );
+
+			// Let the ROFF playing start.
+			//ent->next_roff_time = level.time;
+
+			//rww - Maybe use pos1 and pos2? I don't think we need to care if these values are sent across the net.
+			// These need to be initialised up front...
+			//VectorCopy( ent->r.currentOrigin, ent->pos1 );
+			//VectorCopy( ent->r.currentAngles, ent->pos2 );
+			VectorCopy( ent->r.currentOrigin, ent->s.origin2 );
+			VectorCopy( ent->r.currentAngles, ent->s.angles2 );
+			
+			trap_LinkEntity( ent );
+
+			trap_ROFF_Play(ent->s.number, ent->roffid, qtrue);
+		}
+	}
+}
+
+/*
+=============
+anglerCallback
+
+Utility function
+=============
+*/
+void anglerCallback( gentity_t *ent )
+{
+	//Complete the task
+	trap_ICARUS_TaskIDComplete( ent, TID_ANGLE_FACE );
+
+	//Set the currentAngles, clear all movement
+	VectorMA( ent->s.apos.trBase, (ent->s.apos.trDuration*0.001f), ent->s.apos.trDelta, ent->r.currentAngles );
+	VectorCopy( ent->r.currentAngles, ent->s.apos.trBase );
+	VectorClear( ent->s.apos.trDelta );
+	ent->s.apos.trDuration = 1;
+	ent->s.apos.trType = TR_STATIONARY;
+	ent->s.apos.trTime = level.time;
+
+	//Stop thinking
+	ent->reached = 0;
+	if ( ent->think == anglerCallback )
+	{
+		ent->think = 0;
+	}
+
+	//link
+	trap_LinkEntity( ent );
+}
+
+void MatchTeam( gentity_t *teamLeader, int moverState, int time );
+void Blocked_Mover( gentity_t *ent, gentity_t *other );
+
+/*
+=============
+moverCallback
+
+Utility function
+=============
+*/
+void moverCallback( gentity_t *ent )
+{	//complete the task
+	trap_ICARUS_TaskIDComplete( ent, TID_MOVE_NAV );
+	
+	// play sound
+	ent->s.loopSound = 0;//stop looping sound
+	ent->s.loopIsSoundset = qfalse;
+	G_PlayDoorSound( ent, BMS_END );//play end sound
+
+	if ( ent->moverState == MOVER_1TO2 ) 
+	{//reached open
+		// reached pos2
+		MatchTeam( ent, MOVER_POS2, level.time );
+		//SetMoverState( ent, MOVER_POS2, level.time );
+	} 
+	else if ( ent->moverState == MOVER_2TO1 ) 
+	{//reached closed
+		MatchTeam( ent, MOVER_POS1, level.time );
+		//SetMoverState( ent, MOVER_POS1, level.time );
+	}
+
+	if ( ent->blocked == Blocked_Mover )
+	{
+		ent->blocked = 0;
+	}
+
+//	if ( !Q_stricmp( "misc_model_breakable", ent->classname ) && ent->physicsBounce )
+//	{//a gravity-affected model
+//		misc_model_breakable_gravity_init( ent, qfalse );
+//	}
+}
+
+void Blocked_Mover( gentity_t *ent, gentity_t *other )
+{
+	// remove anything other than a client -- no longer the case
+
+	// don't remove security keys or goodie keys
+	if ( (other->s.eType == ET_ITEM) )
+	{
+		// should we be doing anything special if a key blocks it... move it somehow..?
+	}
+	// if your not a client, or your a dead client remove yourself...
+	else if ( other->s.number && (!other->client || (other->client && other->health <= 0 && other->r.contents == CONTENTS_CORPSE && !other->message)) )
+	{
+		//if ( !other->taskManager || !other->taskManager->IsRunning() )
+		{
+			// if an item or weapon can we do a little explosion..?
+			G_FreeEntity( other );
+			return;
+		}
+	}
+
+	if ( ent->damage ) {
+		G_Damage( other, ent, ent, NULL, NULL, ent->damage, 0, MOD_CRUSH );
+	}
+}
+
+/*
+=============
+moveAndRotateCallback
+
+Utility function
+=============
+*/
+void moveAndRotateCallback( gentity_t *ent )
+{
+	//stop turning
+	anglerCallback( ent );
+	//stop moving
+	moverCallback( ent );
+}
+
+/*
+=============
+Q3_Lerp2Start
+
+Lerps the origin of an entity to its starting position
+=============
+*/
+void Q3_Lerp2Start( int entID, int taskID, float duration )
+{
+	gentity_t	*ent = &g_entities[entID];
+
+	if(!ent)
+	{	
+		G_DebugPrint( WL_WARNING, "Q3_Lerp2Start: invalid entID %d\n", entID);
+		return;
+	}
+	
+	if ( ent->client || Q_stricmp(ent->classname, "target_scriptrunner") == 0 )
+	{
+		G_DebugPrint( WL_ERROR, "Q3_Lerp2Start: ent %d is NOT a mover!\n", entID);
+		return;
+	}
+
+	if ( ent->s.eType != ET_MOVER )
+	{
+		ent->s.eType = ET_MOVER;
+	}
+
+	//FIXME: set up correctly!!!
+	ent->moverState = MOVER_2TO1;
+	ent->s.eType = ET_MOVER;
+	ent->reached = moverCallback;		//Callsback the the completion of the move
+	if ( ent->damage )
+	{
+		ent->blocked = Blocked_Mover;
+	}
+
+	ent->s.pos.trDuration = duration * 10;	//In seconds
+	ent->s.pos.trTime = level.time;
+	
+	trap_ICARUS_TaskIDSet( ent, TID_MOVE_NAV, taskID );
+	// starting sound
+	G_PlayDoorLoopSound( ent );
+	G_PlayDoorSound( ent, BMS_START );	//??
+
+	trap_LinkEntity( ent );
+}
+
+/*
+=============
+Q3_Lerp2End
+
+Lerps the origin of an entity to its ending position
+=============
+*/
+void Q3_Lerp2End( int entID, int taskID, float duration )
+{
+	gentity_t	*ent = &g_entities[entID];
+
+	if(!ent)
+	{
+		G_DebugPrint( WL_WARNING, "Q3_Lerp2End: invalid entID %d\n", entID);
+		return;
+	}
+	
+	if ( ent->client || Q_stricmp(ent->classname, "target_scriptrunner") == 0 )
+	{
+		G_DebugPrint( WL_ERROR, "Q3_Lerp2End: ent %d is NOT a mover!\n", entID);
+		return;
+	}
+
+	if ( ent->s.eType != ET_MOVER )
+	{
+		ent->s.eType = ET_MOVER;
+	}
+
+	//FIXME: set up correctly!!!
+	ent->moverState = MOVER_1TO2;
+	ent->s.eType = ET_MOVER;
+	ent->reached = moverCallback;		//Callsback the the completion of the move
+	if ( ent->damage )
+	{
+		ent->blocked = Blocked_Mover;
+	}
+
+	ent->s.pos.trDuration = duration * 10;	//In seconds
+	ent->s.time = level.time;
+	
+	trap_ICARUS_TaskIDSet( ent, TID_MOVE_NAV, taskID );
+	// starting sound
+	G_PlayDoorLoopSound( ent );
+	G_PlayDoorSound( ent, BMS_START );	//??
+
+	trap_LinkEntity( ent );
+}
+
+void InitMoverTrData( gentity_t *ent );
+
+/*
+=============
+Q3_Lerp2Pos
+
+Lerps the origin and angles of an entity to the destination values
+
+=============
+*/
+void Q3_Lerp2Pos( int taskID, int entID, vec3_t origin, vec3_t angles, float duration )
+{
+	gentity_t	*ent = &g_entities[entID];
+	vec3_t		ang;
+	int			i;
+	moverState_t moverState;
+
+	if(!ent)
+	{
+		G_DebugPrint( WL_WARNING, "Q3_Lerp2Pos: invalid entID %d\n", entID);
+		return;
+	}
+	
+	if ( ent->client || Q_stricmp(ent->classname, "target_scriptrunner") == 0 )
+	{
+		G_DebugPrint( WL_ERROR, "Q3_Lerp2Pos: ent %d is NOT a mover!\n", entID);
+		return;
+	}
+
+	if ( ent->s.eType != ET_MOVER )
+	{
+		ent->s.eType = ET_MOVER;
+	}
+
+	//Don't allow a zero duration
+	if ( duration == 0 )
+		duration = 1;
+
+	//
+	// Movement
+
+	moverState = ent->moverState;
+
+	if ( moverState == MOVER_POS1 || moverState == MOVER_2TO1 )
+	{
+		VectorCopy( ent->r.currentOrigin, ent->pos1 );
+		VectorCopy( origin, ent->pos2 );
+
+		moverState = MOVER_1TO2;
+	}
+	else
+	{
+		VectorCopy( ent->r.currentOrigin, ent->pos2 );
+		VectorCopy( origin, ent->pos1 );
+
+		moverState = MOVER_2TO1;
+	}
+
+	InitMoverTrData( ent );
+
+	ent->s.pos.trDuration = duration;
+
+	// start it going
+	MatchTeam( ent, moverState, level.time );
+	//SetMoverState( ent, moverState, level.time );
+
+	//Only do the angles if specified
+	if ( angles != NULL )
+	{
+		//
+		// Rotation
+
+		for ( i = 0; i < 3; i++ )
+		{
+			ang[i] = AngleDelta( angles[i], ent->r.currentAngles[i] );
+			ent->s.apos.trDelta[i] = ( ang[i] / ( duration * 0.001f ) );
+		}
+
+		VectorCopy( ent->r.currentAngles, ent->s.apos.trBase );
+
+		if ( ent->alt_fire )
+		{
+			ent->s.apos.trType = TR_LINEAR_STOP;
+		}
+		else
+		{
+			ent->s.apos.trType = TR_NONLINEAR_STOP;
+		}
+		ent->s.apos.trDuration = duration;
+
+		ent->s.apos.trTime = level.time;
+
+		ent->reached = moveAndRotateCallback;
+		trap_ICARUS_TaskIDSet( ent, TID_ANGLE_FACE, taskID );
+	}
+	else
+	{
+		//Setup the last bits of information
+		ent->reached = moverCallback;
+	}
+
+	if ( ent->damage )
+	{
+		ent->blocked = Blocked_Mover;
+	}
+
+	trap_ICARUS_TaskIDSet( ent, TID_MOVE_NAV, taskID );
+	// starting sound
+	G_PlayDoorLoopSound( ent );
+	G_PlayDoorSound( ent, BMS_START );	//??
+
+	trap_LinkEntity( ent );
+}
+
+/*
+=============
+Q3_LerpAngles
+
+Lerps the angles to the destination value
+=============
+*/
+void Q3_Lerp2Angles( int taskID, int entID, vec3_t angles, float duration )
+{
+	gentity_t	*ent = &g_entities[entID];
+	vec3_t		ang;
+	int			i;
+
+	if(!ent)
+	{
+		G_DebugPrint( WL_WARNING, "Q3_Lerp2Angles: invalid entID %d\n", entID);
+		return;
+	}
+	
+	if ( ent->client || Q_stricmp(ent->classname, "target_scriptrunner") == 0 )
+	{
+		G_DebugPrint( WL_ERROR, "Q3_Lerp2Angles: ent %d is NOT a mover!\n", entID);
+		return;
+	}
+
+	//If we want an instant move, don't send 0...
+	ent->s.apos.trDuration = (duration>0) ? duration : 1;
+
+	for ( i = 0; i < 3; i++ )
+	{
+		ang [i] = AngleSubtract( angles[i], ent->r.currentAngles[i]);
+		ent->s.apos.trDelta[i] = ( ang[i] / ( ent->s.apos.trDuration * 0.001f ) );
+	}
+
+	VectorCopy( ent->r.currentAngles, ent->s.apos.trBase );
+
+	if ( ent->alt_fire )
+	{
+		ent->s.apos.trType = TR_LINEAR_STOP;
+	}
+	else
+	{
+		ent->s.apos.trType = TR_NONLINEAR_STOP;
+	}
+
+	ent->s.apos.trTime = level.time;
+	
+	trap_ICARUS_TaskIDSet( ent, TID_ANGLE_FACE, taskID );
+
+	//ent->e_ReachedFunc = reachedF_NULL;
+	ent->think = anglerCallback;
+	ent->nextthink = level.time + duration;
+
+	trap_LinkEntity( ent );
+}
+
+/*
+=============
+Q3_GetTag
+
+Gets the value of a tag by the give name
+=============
+*/
+int	Q3_GetTag( int entID, const char *name, int lookup, vec3_t info )
+{
+	gentity_t	*ent = &g_entities[entID];
+
+	if (!ent->inuse)
+	{
+		assert(0);
+		return 0;
+	}
+
+	switch ( lookup )
+	{
+	case TYPE_ORIGIN:
+		return TAG_GetOrigin( ent->ownername, name, info );
+		break;
+
+	case TYPE_ANGLES:
+		return TAG_GetAngles( ent->ownername, name, info );
+		break;	
+	}
+
+	return 0;
+}
+
+//-----------------------------------------------
+
+/*
+============
+Q3_Use
+
+Uses an entity
+============
+*/
+void Q3_Use( int entID, const char *target )
+{
+	gentity_t	*ent  = &g_entities[entID];
+	
+	if ( !ent )
+	{
+		G_DebugPrint( WL_WARNING, "Q3_Use: invalid entID %d\n", entID);
+		return;
+	}
+
+	if( !target || !target[0] )
+	{
+		G_DebugPrint( WL_WARNING, "Q3_Use: string is NULL!\n" );
+		return;
+	}
+
+	G_UseTargets2(ent, ent, target);
+}
+
+/*
+============
+Q3_Kill
+  Description	: 
+  Return type	: void 
+  Argument		:  int entID
+  Argument		: const char *name
+============
+*/
+void Q3_Kill( int entID, const char *name )
+{
+	gentity_t	*ent = &g_entities[entID];
+	gentity_t	*victim = NULL;
+	int			o_health;
+
+	if( !Q_stricmp( name, "self") )
+	{
+		victim = ent;
+	}
+	else if( !Q_stricmp( name, "enemy" ) )
+	{
+		victim = ent->enemy;
+	}
+	else
+	{
+		victim = G_Find (NULL, FOFS(targetname), (char *) name );
+	}
+
+	if ( !victim )
+	{
+		G_DebugPrint( WL_WARNING, "Q3_Kill: can't find %s\n", name);
+		return;
+	}
+
+	//rww - I guess this would only apply to NPCs anyway. I'm not going to bother.
+	//if ( victim == ent )
+	//{//don't ICARUS_FreeEnt me, I'm in the middle of a script!  (FIXME: shouldn't ICARUS handle this internally?)
+	//	victim->svFlags |= SVF_KILLED_SELF;
+	//}
+
+	o_health = victim->health;
+	victim->health = 0;
+	if ( victim->client )
+	{
+		victim->flags |= FL_NO_KNOCKBACK;
+	}
+	//G_SetEnemy(victim, ent);
+	if( victim->die != NULL )	// check can be omitted
+	{
+		//GEntity_DieFunc( victim, NULL, NULL, o_health, MOD_UNKNOWN );
+		victim->die(victim, victim, victim, o_health, MOD_UNKNOWN);
+	}
+}
+
+/*
+============
+Q3_RemoveEnt
+  Description	: 
+  Return type	: void 
+  Argument		: sharedEntity_t *victim
+============
+*/
+void Q3_RemoveEnt( gentity_t *victim )
+{
+	if( victim->client )
+	{
+		if ( victim->s.eType != ET_NPC )
+		{
+			G_DebugPrint( WL_WARNING, "Q3_RemoveEnt: You can't remove clients in MP!\n" );
+			assert(0); //can't remove clients in MP
+		}
+		else
+		{//remove the NPC
+			if ( victim->client->NPC_class == CLASS_VEHICLE )
+			{//eject everyone out of a vehicle that's about to remove itself
+				Vehicle_t *pVeh = victim->m_pVehicle;
+				if ( pVeh && pVeh->m_pVehicleInfo )
+				{
+					pVeh->m_pVehicleInfo->EjectAll( pVeh );
+				}
+			}
+			victim->think = G_FreeEntity;
+			victim->nextthink = level.time + 100;
+		}
+		/*
+		//ClientDisconnect(ent);
+		victim->s.eFlags |= EF_NODRAW;
+		victim->s.eType = ET_INVISIBLE;
+		victim->contents = 0;
+		victim->health = 0;
+		victim->targetname = NULL;
+
+		if ( victim->NPC && victim->NPC->tempGoal != NULL )
+		{
+			G_FreeEntity( victim->NPC->tempGoal );
+			victim->NPC->tempGoal = NULL;
+		}
+		if ( victim->client->ps.saberEntityNum != ENTITYNUM_NONE && victim->client->ps.saberEntityNum > 0 )
+		{
+			if ( g_entities[victim->client->ps.saberEntityNum].inuse )
+			{
+				G_FreeEntity( &g_entities[victim->client->ps.saberEntityNum] );
+			}
+			victim->client->ps.saberEntityNum = ENTITYNUM_NONE;
+		}
+		//Disappear in half a second
+		victim->e_ThinkFunc = thinkF_G_FreeEntity;
+		victim->nextthink = level.time + 500;
+		return;
+		*/
+	}
+	else
+	{
+		victim->think = G_FreeEntity;
+		victim->nextthink = level.time + 100;
+	}
+}
+
+
+/*
+============
+Q3_Remove
+  Description	: 
+  Return type	: void 
+  Argument		:  int entID
+  Argument		: const char *name
+============
+*/
+void Q3_Remove( int entID, const char *name )
+{
+	gentity_t *ent = &g_entities[entID];
+	gentity_t	*victim = NULL;
+
+	if( !Q_stricmp( "self", name ) )
+	{
+		victim = ent;
+		if ( !victim )
+		{
+			G_DebugPrint( WL_WARNING, "Q3_Remove: can't find %s\n", name );
+			return;
+		}
+		Q3_RemoveEnt( victim );
+	}
+	else if( !Q_stricmp( "enemy", name ) )
+	{
+		victim = ent->enemy;
+		if ( !victim )
+		{
+			G_DebugPrint( WL_WARNING, "Q3_Remove: can't find %s\n", name );
+			return;
+		}
+		Q3_RemoveEnt( victim );
+	}
+	else
+	{
+		victim = G_Find( NULL, FOFS(targetname), (char *) name );
+		if ( !victim )
+		{
+			G_DebugPrint( WL_WARNING, "Q3_Remove: can't find %s\n", name );
+			return;
+		}
+
+		while ( victim )
+		{
+			Q3_RemoveEnt( victim );
+			victim = G_Find( victim, FOFS(targetname), (char *) name );
+		}
+	}
+}
+
+/*
+=================================================
+
+  Get / Set Functions
+
+=================================================
+*/
+
+/*
+============
+Q3_GetFloat
+  Description	: 
+  Return type	: int 
+  Argument		:  int entID
+  Argument		: int type
+  Argument		: const char *name
+  Argument		: float *value
+============
+*/
+int Q3_GetFloat( int entID, int type, const char *name, float *value )
+{
+	gentity_t	*ent = &g_entities[entID];
+	int toGet = 0;
+
+	if ( !ent )
+	{
+		return 0;
+	}
+
+	toGet = GetIDForString( setTable, name );	//FIXME: May want to make a "getTable" as well
+	//FIXME: I'm getting really sick of these huge switch statements!
+
+	//NOTENOTE: return true if the value was correctly obtained
+	switch ( toGet )
+	{
+	case SET_PARM1:
+	case SET_PARM2:
+	case SET_PARM3:
+	case SET_PARM4:
+	case SET_PARM5:
+	case SET_PARM6:
+	case SET_PARM7:
+	case SET_PARM8:
+	case SET_PARM9:
+	case SET_PARM10:
+	case SET_PARM11:
+	case SET_PARM12:
+	case SET_PARM13:
+	case SET_PARM14:
+	case SET_PARM15:
+	case SET_PARM16:
+		if (ent->parms == NULL)
+		{
+			G_DebugPrint( WL_ERROR, "GET_PARM: %s %s did not have any parms set!\n", ent->classname, ent->targetname );
+			return 0;	// would prefer qfalse, but I'm fitting in with what's here <sigh>
+		}
+		*value = atof( ent->parms->parm[toGet - SET_PARM1] );
+		break;
+	
+	case SET_COUNT:
+		*value = ent->count;
+		break;
+
+	case SET_HEALTH:
+		*value = ent->health;
+		break;
+
+	case SET_SKILL:
+		return 0;
+		break;
+
+	case SET_XVELOCITY://## %f="0.0" # Velocity along X axis
+		if ( ent->client == NULL )
+		{
+			G_DebugPrint( WL_WARNING, "Q3_GetFloat: SET_XVELOCITY, %s not a client\n", ent->targetname );
+			return 0;
+		}
+		*value = ent->client->ps.velocity[0];
+		break;
+
+	case SET_YVELOCITY://## %f="0.0" # Velocity along Y axis
+		if ( ent->client == NULL )
+		{
+			G_DebugPrint( WL_WARNING, "Q3_GetFloat: SET_YVELOCITY, %s not a client\n", ent->targetname );
+			return 0;
+		}
+		*value = ent->client->ps.velocity[1];
+		break;
+
+	case SET_ZVELOCITY://## %f="0.0" # Velocity along Z axis
+		if ( ent->client == NULL )
+		{
+			G_DebugPrint( WL_WARNING, "Q3_GetFloat: SET_ZVELOCITY, %s not a client\n", ent->targetname );
+			return 0;
+		}
+		*value = ent->client->ps.velocity[2];
+		break;
+
+	case SET_Z_OFFSET:
+		*value = ent->r.currentOrigin[2] - ent->s.origin[2];
+		break;
+
+	case SET_DPITCH://## %f="0.0" # Pitch for NPC to turn to
+		return 0;
+		break;
+
+	case SET_DYAW://## %f="0.0" # Yaw for NPC to turn to
+		return 0;
+		break;
+
+	case SET_WIDTH://## %f="0.0" # Width of NPC bounding box
+		*value = ent->r.mins[0];
+		break;
+	case SET_TIMESCALE://## %f="0.0" # Speed-up slow down game (0 - 1.0)
+		return 0;
+		break;
+	case SET_CAMERA_GROUP_Z_OFS://## %s="NULL" # all ents with this cameraGroup will be focused on
+		return 0;
+		break;
+
+	case SET_VISRANGE://## %f="0.0" # How far away NPC can see
+		return 0;
+		break;
+
+	case SET_EARSHOT://## %f="0.0" # How far an NPC can hear
+		return 0;
+		break;
+
+	case SET_VIGILANCE://## %f="0.0" # How often to look for enemies (0 - 1.0)
+		return 0;
+		break;
+
+	case SET_GRAVITY://## %f="0.0" # Change this ent's gravity - 800 default
+		*value = g_gravity.value;
+		break;
+
+	case SET_FACEEYESCLOSED:
+	case SET_FACEEYESOPENED:
+	case SET_FACEAUX:		//## %f="0.0" # Set face to Aux expression for number of seconds
+	case SET_FACEBLINK:		//## %f="0.0" # Set face to Blink expression for number of seconds
+	case SET_FACEBLINKFROWN:	//## %f="0.0" # Set face to Blinkfrown expression for number of seconds
+	case SET_FACEFROWN:		//## %f="0.0" # Set face to Frown expression for number of seconds
+	case SET_FACENORMAL:		//## %f="0.0" # Set face to Normal expression for number of seconds
+		G_DebugPrint( WL_WARNING, "Q3_GetFloat: SET_FACE___ not implemented\n" );
+		return 0;
+		break;
+	case SET_WAIT:		//## %f="0.0" # Change an entity's wait field
+		*value = ent->wait;
+		break;
+	case SET_FOLLOWDIST:		//## %f="0.0" # How far away to stay from leader in BS_FOLLOW_LEADER
+		return 0;
+		break;
+	//# #sep ints
+	case SET_ANIM_HOLDTIME_LOWER://## %d="0" # Hold lower anim for number of milliseconds
+		if ( ent->client == NULL )
+		{
+			G_DebugPrint( WL_WARNING, "Q3_GetFloat: SET_ANIM_HOLDTIME_LOWER, %s not a client\n", ent->targetname );
+			return 0;
+		}
+		*value = ent->client->ps.legsTimer;
+		break;
+	case SET_ANIM_HOLDTIME_UPPER://## %d="0" # Hold upper anim for number of milliseconds
+		if ( ent->client == NULL )
+		{
+			G_DebugPrint( WL_WARNING, "Q3_GetFloat: SET_ANIM_HOLDTIME_UPPER, %s not a client\n", ent->targetname );
+			return 0;
+		}
+		*value = ent->client->ps.torsoTimer;
+		break;
+	case SET_ANIM_HOLDTIME_BOTH://## %d="0" # Hold lower and upper anims for number of milliseconds
+		G_DebugPrint( WL_WARNING, "Q3_GetFloat: SET_ANIM_HOLDTIME_BOTH not implemented\n" );
+		return 0;
+		break;
+	case SET_ARMOR://## %d="0" # Change armor
+		if ( ent->client == NULL )
+		{
+			G_DebugPrint( WL_WARNING, "Q3_GetFloat: SET_ARMOR, %s not a client\n", ent->targetname );
+			return 0;
+		}
+		*value = ent->client->ps.stats[STAT_ARMOR];
+		break;
+	case SET_WALKSPEED://## %d="0" # Change walkSpeed
+		return 0;
+		break;
+	case SET_RUNSPEED://## %d="0" # Change runSpeed
+		return 0;
+		break;
+	case SET_YAWSPEED://## %d="0" # Change yawSpeed
+		return 0;
+		break;
+	case SET_AGGRESSION://## %d="0" # Change aggression 1-5
+		return 0;
+		break;
+	case SET_AIM://## %d="0" # Change aim 1-5
+		return 0;
+		break;
+	case SET_FRICTION://## %d="0" # Change ent's friction - 6 default
+		return 0;
+		break;
+	case SET_SHOOTDIST://## %d="0" # How far the ent can shoot - 0 uses weapon
+		return 0;
+		break;
+	case SET_HFOV://## %d="0" # Horizontal field of view
+		return 0;
+		break;
+	case SET_VFOV://## %d="0" # Vertical field of view
+		return 0;
+		break;
+	case SET_DELAYSCRIPTTIME://## %d="0" # How many seconds to wait before running delayscript
+		return 0;
+		break;
+	case SET_FORWARDMOVE://## %d="0" # NPC move forward -127(back) to 127
+		return 0;
+		break;
+	case SET_RIGHTMOVE://## %d="0" # NPC move right -127(left) to 127
+		return 0;
+		break;
+	case SET_STARTFRAME:	//## %d="0" # frame to start animation sequence on
+		return 0;
+		break;
+	case SET_ENDFRAME:	//## %d="0" # frame to end animation sequence on
+		return 0;
+		break;
+	case SET_ANIMFRAME:	//## %d="0" # of current frame
+		return 0;
+		break;
+
+	case SET_SHOT_SPACING://## %d="1000" # Time between shots for an NPC - reset to defaults when changes weapon
+		return 0;
+		break;
+	case SET_MISSIONSTATUSTIME://## %d="0" # Amount of time until Mission Status should be shown after death
+		return 0;
+		break;
+	//# #sep booleans
+	case SET_IGNOREPAIN://## %t="BOOL_TYPES" # Do not react to pain
+		return 0;
+		break;
+	case SET_IGNOREENEMIES://## %t="BOOL_TYPES" # Do not acquire enemies
+		return 0;
+		break;
+	case SET_IGNOREALERTS://## Do not get enemy set by allies in area(ambush)
+		return 0;
+		break;
+	case SET_DONTSHOOT://## %t="BOOL_TYPES" # Others won't shoot you
+		return 0;
+		break;
+	case SET_NOTARGET://## %t="BOOL_TYPES" # Others won't pick you as enemy
+		*value = (ent->flags&FL_NOTARGET);
+		break;
+	case SET_DONTFIRE://## %t="BOOL_TYPES" # Don't fire your weapon
+		return 0;
+		break;
+
+	case SET_LOCKED_ENEMY://## %t="BOOL_TYPES" # Keep current enemy until dead
+		return 0;
+		break;
+	case SET_CROUCHED://## %t="BOOL_TYPES" # Force NPC to crouch
+		return 0;
+		break;
+	case SET_WALKING://## %t="BOOL_TYPES" # Force NPC to move at walkSpeed
+		return 0;
+		break;
+	case SET_RUNNING://## %t="BOOL_TYPES" # Force NPC to move at runSpeed
+		return 0;
+		break;
+	case SET_CHASE_ENEMIES://## %t="BOOL_TYPES" # NPC will chase after enemies
+		return 0;
+		break;
+	case SET_LOOK_FOR_ENEMIES://## %t="BOOL_TYPES" # NPC will be on the lookout for enemies
+		return 0;
+		break;
+	case SET_FACE_MOVE_DIR://## %t="BOOL_TYPES" # NPC will face in the direction it's moving
+		return 0;
+		break;
+	case SET_FORCED_MARCH://## %t="BOOL_TYPES" # Force NPC to move at runSpeed
+		return 0;
+		break;
+	case SET_UNDYING://## %t="BOOL_TYPES" # Can take damage down to 1 but not die
+		return 0;
+		break;
+	case SET_NOAVOID://## %t="BOOL_TYPES" # Will not avoid other NPCs or architecture
+		return 0;
+		break;
+
+	case SET_SOLID://## %t="BOOL_TYPES" # Make yourself notsolid or solid
+		*value = ent->r.contents;
+		break;
+	case SET_PLAYER_USABLE://## %t="BOOL_TYPES" # Can be activateby the player's "use" button
+		*value = (ent->r.svFlags&SVF_PLAYER_USABLE);
+		break;
+	case SET_LOOP_ANIM://## %t="BOOL_TYPES" # For non-NPCs: loop your animation sequence
+		return 0;
+		break;
+	case SET_INTERFACE://## %t="BOOL_TYPES" # Player interface on/off
+		G_DebugPrint( WL_WARNING, "Q3_GetFloat: SET_INTERFACE not implemented\n" );
+		return 0;
+		break;
+	case SET_SHIELDS://## %t="BOOL_TYPES" # NPC has no shields (Borg do not adapt)
+		return 0;
+		break;
+	case SET_INVISIBLE://## %t="BOOL_TYPES" # Makes an NPC not solid and not visible
+		*value = (ent->s.eFlags&EF_NODRAW);
+		break;
+	case SET_VAMPIRE://## %t="BOOL_TYPES" # Makes an NPC not solid and not visible
+		return 0;
+		break;
+	case SET_FORCE_INVINCIBLE://## %t="BOOL_TYPES" # Makes an NPC not solid and not visible
+		return 0;
+		break;
+	case SET_GREET_ALLIES://## %t="BOOL_TYPES" # Makes an NPC greet teammates
+		return 0;
+		break;
+	case SET_VIDEO_FADE_IN://## %t="BOOL_TYPES" # Makes video playback fade in
+		G_DebugPrint( WL_WARNING, "Q3_GetFloat: SET_VIDEO_FADE_IN not implemented\n" );
+		return 0;
+		break;
+	case SET_VIDEO_FADE_OUT://## %t="BOOL_TYPES" # Makes video playback fade out
+		G_DebugPrint( WL_WARNING, "Q3_GetFloat: SET_VIDEO_FADE_OUT not implemented\n" );
+		return 0;
+		break;
+	case SET_PLAYER_LOCKED://## %t="BOOL_TYPES" # Makes it so player cannot move
+		return 0;
+		break;
+	case SET_LOCK_PLAYER_WEAPONS://## %t="BOOL_TYPES" # Makes it so player cannot switch weapons
+		return 0;
+		break;
+	case SET_NO_IMPACT_DAMAGE://## %t="BOOL_TYPES" # Makes it so player cannot switch weapons
+		return 0;
+		break;
+	case SET_NO_KNOCKBACK://## %t="BOOL_TYPES" # Stops this ent from taking knockback from weapons
+		*value = (ent->flags&FL_NO_KNOCKBACK);
+		break;
+	case SET_ALT_FIRE://## %t="BOOL_TYPES" # Force NPC to use altfire when shooting
+		return 0;
+		break;
+	case SET_NO_RESPONSE://## %t="BOOL_TYPES" # NPCs will do generic responses when this is on (usescripts override generic responses as well)
+		return 0;
+		break;
+	case SET_INVINCIBLE://## %t="BOOL_TYPES" # Completely unkillable
+		*value = (ent->flags&FL_GODMODE);
+		break;
+	case SET_MISSIONSTATUSACTIVE:	//# Turns on Mission Status Screen
+		return 0;
+		break;
+	case SET_NO_COMBAT_TALK://## %t="BOOL_TYPES" # NPCs will not do their combat talking noises when this is on
+		return 0;
+		break;
+	case SET_NO_ALERT_TALK://## %t="BOOL_TYPES" # NPCs will not do their combat talking noises when this is on
+		return 0;
+		break;
+	case SET_USE_CP_NEAREST://## %t="BOOL_TYPES" # NPCs will use their closest combat points, not try and find ones next to the player, or flank player
+		return 0;
+		break;
+	case SET_DISMEMBERABLE://## %t="BOOL_TYPES" # NPC will not be affected by force powers
+		return 0;
+		break;
+	case SET_NO_FORCE:
+		return 0;
+		break;
+	case SET_NO_ACROBATICS:
+		return 0;
+		break;
+	case SET_USE_SUBTITLES:
+		return 0;
+		break;
+	case SET_NO_FALLTODEATH://## %t="BOOL_TYPES" # NPC will not be affected by force powers
+		return 0;
+		break;
+	case SET_MORELIGHT://## %t="BOOL_TYPES" # NPCs will use their closest combat points, not try and find ones next to the player, or flank player
+		return 0;
+		break;
+	case SET_TREASONED://## %t="BOOL_TYPES" # Player has turned on his own- scripts will stop: NPCs will turn on him and level changes load the brig
+		return 0;
+		break;
+	case SET_DISABLE_SHADER_ANIM:	//## %t="BOOL_TYPES" # Shaders won't animate
+		return 0;
+		break;
+	case SET_SHADER_ANIM:	//## %t="BOOL_TYPES" # Shader will be under frame control
+		return 0;
+		break;
+
+	default:
+		if ( trap_ICARUS_VariableDeclared( name ) != VTYPE_FLOAT )
+			return 0;
+
+		return trap_ICARUS_GetFloatVariable( name, value );
+	}
+
+	return 1;
+}
+
+
+/*
+============
+Q3_GetVector
+  Description	: 
+  Return type	: int 
+  Argument		:  int entID
+  Argument		: int type
+  Argument		: const char *name
+  Argument		: vec3_t value
+============
+*/
+int Q3_GetVector( int entID, int type, const char *name, vec3_t value )
+{
+	gentity_t	*ent = &g_entities[entID];
+	int toGet = 0;
+	if ( !ent )
+	{
+		return 0;
+	}
+
+	toGet = GetIDForString( setTable, name );	//FIXME: May want to make a "getTable" as well
+	//FIXME: I'm getting really sick of these huge switch statements!
+
+	//NOTENOTE: return true if the value was correctly obtained
+	switch ( toGet )
+	{
+	case SET_PARM1:
+	case SET_PARM2:
+	case SET_PARM3:
+	case SET_PARM4:
+	case SET_PARM5:
+	case SET_PARM6:
+	case SET_PARM7:
+	case SET_PARM8:
+	case SET_PARM9:
+	case SET_PARM10:
+	case SET_PARM11:
+	case SET_PARM12:
+	case SET_PARM13:
+	case SET_PARM14:
+	case SET_PARM15:
+	case SET_PARM16:
+		sscanf( ent->parms->parm[toGet - SET_PARM1], "%f %f %f", &value[0], &value[1], &value[2] );
+		break;
+
+	case SET_ORIGIN:
+		VectorCopy(ent->r.currentOrigin, value);
+		break;
+
+	case SET_ANGLES:
+		VectorCopy(ent->r.currentAngles, value);
+		break;
+	
+	case SET_TELEPORT_DEST://## %v="0.0 0.0 0.0" # Set origin here as soon as the area is clear
+		G_DebugPrint( WL_WARNING, "Q3_GetVector: SET_TELEPORT_DEST not implemented\n" );
+		return 0;
+		break;
+
+	default:
+
+		if ( trap_ICARUS_VariableDeclared( name ) != VTYPE_VECTOR )
+			return 0;
+
+		return trap_ICARUS_GetVectorVariable( name, value );
+	}
+
+	return 1;
+}
+
+/*
+============
+Q3_GetString
+  Description	: 
+  Return type	: int 
+  Argument		:  int entID
+  Argument		: int type
+  Argument		: const char *name
+  Argument		: char **value
+============
+*/
+int Q3_GetString( int entID, int type, const char *name, char **value )
+{
+	gentity_t	*ent = &g_entities[entID];
+	int toGet = 0;
+	if ( !ent )
+	{
+		return 0;
+	}
+
+	toGet = GetIDForString( setTable, name );	//FIXME: May want to make a "getTable" as well
+
+	switch ( toGet )
+	{
+	case SET_ANIM_BOTH:
+		*value = (char *) Q3_GetAnimBoth( ent );
+
+		if ( !value || !value[0] )
+			return 0;
+
+		break;
+
+	case SET_PARM1:
+	case SET_PARM2:
+	case SET_PARM3:
+	case SET_PARM4:
+	case SET_PARM5:
+	case SET_PARM6:
+	case SET_PARM7:
+	case SET_PARM8:
+	case SET_PARM9:
+	case SET_PARM10:
+	case SET_PARM11:
+	case SET_PARM12:
+	case SET_PARM13:
+	case SET_PARM14:
+	case SET_PARM15:
+	case SET_PARM16:
+		if ( ent->parms )
+		{
+			*value = (char *) ent->parms->parm[toGet - SET_PARM1];
+		}
+		else
+		{
+			G_DebugPrint( WL_WARNING, "Q3_GetString: invalid ent %s has no parms!\n", ent->targetname );
+			return 0;
+		}
+		break;
+
+	case SET_TARGET:
+		*value = (char *) ent->target;
+		break;
+
+	case SET_LOCATION:
+		return 0;
+		break;
+
+	//# #sep Scripts and other file paths
+	case SET_SPAWNSCRIPT://## %s="NULL" !!"W:\game\base\scripts\!!#*.txt" # Script to run when spawned //0 - do not change these, these are equal to BSET_SPAWN, etc
+		*value = ent->behaviorSet[BSET_SPAWN];
+		break;
+	case SET_USESCRIPT://## %s="NULL" !!"W:\game\base\scripts\!!#*.txt" # Script to run when used
+		*value = ent->behaviorSet[BSET_USE];
+		break;
+	case SET_AWAKESCRIPT://## %s="NULL" !!"W:\game\base\scripts\!!#*.txt" # Script to run when startled
+		*value = ent->behaviorSet[BSET_AWAKE];
+		break;
+	case SET_ANGERSCRIPT://## %s="NULL" !!"W:\game\base\scripts\!!#*.txt" # Script run when find an enemy for the first time
+		*value = ent->behaviorSet[BSET_ANGER];
+		break;
+	case SET_ATTACKSCRIPT://## %s="NULL" !!"W:\game\base\scripts\!!#*.txt" # Script to run when you shoot
+		*value = ent->behaviorSet[BSET_ATTACK];
+		break;
+	case SET_VICTORYSCRIPT://## %s="NULL" !!"W:\game\base\scripts\!!#*.txt" # Script to run when killed someone
+		*value = ent->behaviorSet[BSET_VICTORY];
+		break;
+	case SET_LOSTENEMYSCRIPT://## %s="NULL" !!"W:\game\base\scripts\!!#*.txt" # Script to run when you can't find your enemy
+		*value = ent->behaviorSet[BSET_LOSTENEMY];
+		break;
+	case SET_PAINSCRIPT://## %s="NULL" !!"W:\game\base\scripts\!!#*.txt" # Script to run when hit
+		*value = ent->behaviorSet[BSET_PAIN];
+		break;
+	case SET_FLEESCRIPT://## %s="NULL" !!"W:\game\base\scripts\!!#*.txt" # Script to run when hit and low health
+		*value = ent->behaviorSet[BSET_FLEE];
+		break;
+	case SET_DEATHSCRIPT://## %s="NULL" !!"W:\game\base\scripts\!!#*.txt" # Script to run when killed
+		*value = ent->behaviorSet[BSET_DEATH];
+		break;
+	case SET_DELAYEDSCRIPT://## %s="NULL" !!"W:\game\base\scripts\!!#*.txt" # Script to run after a delay
+		*value = ent->behaviorSet[BSET_DELAYED];
+		break;
+	case SET_BLOCKEDSCRIPT://## %s="NULL" !!"W:\game\base\scripts\!!#*.txt" # Script to run when blocked by teammate
+		*value = ent->behaviorSet[BSET_BLOCKED];
+		break;
+	case SET_FFIRESCRIPT://## %s="NULL" !!"W:\game\base\scripts\!!#*.txt" # Script to run when player has shot own team repeatedly
+		*value = ent->behaviorSet[BSET_FFIRE];
+		break;
+	case SET_FFDEATHSCRIPT://## %s="NULL" !!"W:\game\base\scripts\!!#*.txt" # Script to run when player kills a teammate
+		*value = ent->behaviorSet[BSET_FFDEATH];
+		break;
+
+	//# #sep Standard strings
+	case SET_ENEMY://## %s="NULL" # Set enemy by targetname
+		return 0;
+		break;
+	case SET_LEADER://## %s="NULL" # Set for BS_FOLLOW_LEADER
+		return 0;
+		break;
+	case SET_CAPTURE://## %s="NULL" # Set captureGoal by targetname
+		return 0;
+		break;
+
+	case SET_TARGETNAME://## %s="NULL" # Set/change your targetname
+		*value = ent->targetname;
+		break;
+	case SET_PAINTARGET://## %s="NULL" # Set/change what to use when hit
+		return 0;
+		break;
+	case SET_CAMERA_GROUP://## %s="NULL" # all ents with this cameraGroup will be focused on
+		return 0;
+		break;
+	case SET_CAMERA_GROUP_TAG://## %s="NULL" # all ents with this cameraGroup will be focused on
+		return 0;
+		break;
+	case SET_LOOK_TARGET://## %s="NULL" # object for NPC to look at
+		G_DebugPrint( WL_WARNING, "Q3_GetString: SET_LOOK_TARGET, NOT SUPPORTED IN MULTIPLAYER\n" );
+		break;
+	case SET_TARGET2://## %s="NULL" # Set/change your target2: on NPC's: this fires when they're knocked out by the red hypo
+		return 0;
+		break;
+
+	case SET_REMOVE_TARGET://## %s="NULL" # Target that is fired when someone completes the BS_REMOVE behaviorState
+		return 0;
+		break;
+	case SET_WEAPON:
+		return 0;
+		break;
+
+	case SET_ITEM:
+		return 0;
+		break;
+	case SET_MUSIC_STATE:
+		return 0;
+		break;
+	//The below cannot be gotten
+	case SET_NAVGOAL://## %s="NULL" # *Move to this navgoal then continue script
+		G_DebugPrint( WL_WARNING, "Q3_GetString: SET_NAVGOAL not implemented\n" );
+		return 0;
+		break;
+	case SET_VIEWTARGET://## %s="NULL" # Set angles toward ent by targetname
+		G_DebugPrint( WL_WARNING, "Q3_GetString: SET_VIEWTARGET not implemented\n" );
+		return 0;
+		break;
+	case SET_WATCHTARGET://## %s="NULL" # Set angles toward ent by targetname
+		return 0;
+		break;
+	case SET_VIEWENTITY:
+		G_DebugPrint( WL_WARNING, "Q3_GetString: SET_VIEWENTITY not implemented\n" );
+		return 0;
+		break;
+	case SET_CAPTIONTEXTCOLOR:	//## %s=""  # Color of text RED:WHITE:BLUE: YELLOW
+		G_DebugPrint( WL_WARNING, "Q3_GetString: SET_CAPTIONTEXTCOLOR not implemented\n" );
+		return 0;
+		break;
+	case SET_CENTERTEXTCOLOR:	//## %s=""  # Color of text RED:WHITE:BLUE: YELLOW
+		G_DebugPrint( WL_WARNING, "Q3_GetString: SET_CENTERTEXTCOLOR not implemented\n" );
+		return 0;
+		break;
+	case SET_SCROLLTEXTCOLOR:	//## %s=""  # Color of text RED:WHITE:BLUE: YELLOW
+		G_DebugPrint( WL_WARNING, "Q3_GetString: SET_SCROLLTEXTCOLOR not implemented\n" );
+		return 0;
+		break;
+	case SET_COPY_ORIGIN://## %s="targetname"  # Copy the origin of the ent with targetname to your origin
+		G_DebugPrint( WL_WARNING, "Q3_GetString: SET_COPY_ORIGIN not implemented\n" );
+		return 0;
+		break;
+	case SET_DEFEND_TARGET://## %s="targetname"  # This NPC will attack the target NPC's enemies
+		G_DebugPrint( WL_WARNING, "Q3_GetString: SET_COPY_ORIGIN not implemented\n" );
+		return 0;
+		break;
+	case SET_VIDEO_PLAY://## %s="filename" !!"W:\game\base\video\!!#*.roq" # Play a Video (inGame)
+		G_DebugPrint( WL_WARNING, "Q3_GetString: SET_VIDEO_PLAY not implemented\n" );
+		return 0;
+		break;
+	case SET_LOADGAME://## %s="exitholodeck" # Load the savegame that was auto-saved when you started the holodeck
+		G_DebugPrint( WL_WARNING, "Q3_GetString: SET_LOADGAME not implemented\n" );
+		return 0;
+		break;
+	case SET_LOCKYAW://## %s="off"  # Lock legs to a certain yaw angle (or "off" or "auto" uses current)
+		G_DebugPrint( WL_WARNING, "Q3_GetString: SET_LOCKYAW not implemented\n" );
+		return 0;
+		break;
+	case SET_SCROLLTEXT:	//## %s="" # key of text string to print
+		G_DebugPrint( WL_WARNING, "Q3_GetString: SET_SCROLLTEXT not implemented\n" );
+		return 0;
+		break;
+	case SET_LCARSTEXT:	//## %s="" # key of text string to print in LCARS frame
+		G_DebugPrint( WL_WARNING, "Q3_GetString: SET_LCARSTEXT not implemented\n" );
+		return 0;
+		break;
+
+	case SET_FULLNAME://## %s="NULL" # Set/change your targetname
+		*value = ent->fullName;
+		break;
+	default:
+
+		if ( trap_ICARUS_VariableDeclared( name ) != VTYPE_STRING )
+			return 0;
+
+		return trap_ICARUS_GetStringVariable( name, (const char *) *value );
+	}
+
+	return 1;
+}
+
+/*
+============
+MoveOwner
+  Description	: 
+  Return type	: void 
+  Argument		: sharedEntity_t *self
+============
+*/
+qboolean SpotWouldTelefrag2( gentity_t *mover, vec3_t dest );
+void MoveOwner( gentity_t *self )
+{
+	gentity_t *owner = &g_entities[self->r.ownerNum];
+
+	self->nextthink = level.time + FRAMETIME;
+	self->think = G_FreeEntity;
+
+	if ( !owner || !owner->inuse )
+	{
+		return;
+	}
+
+	if ( SpotWouldTelefrag2( owner, self->r.currentOrigin ) )
+	{
+		self->think = MoveOwner;
+	}
+	else
+	{
+		G_SetOrigin( owner, self->r.currentOrigin );
+		trap_ICARUS_TaskIDComplete( owner, TID_MOVE_NAV );
+	}
+}
+
+/*
+=============
+Q3_SetTeleportDest
+
+Copies passed origin to ent running script once there is nothing there blocking the spot
+=============
+*/
+static qboolean Q3_SetTeleportDest( int entID, vec3_t org )
+{
+	gentity_t	*teleEnt = &g_entities[entID];
+
+	if ( teleEnt )
+	{
+		if ( SpotWouldTelefrag2( teleEnt, org ) )
+		{
+			gentity_t *teleporter = G_Spawn();
+
+			G_SetOrigin( teleporter, org );
+			teleporter->r.ownerNum = teleEnt->s.number;
+
+			teleporter->think = MoveOwner;
+			teleporter->nextthink = level.time + FRAMETIME;
+			
+			return qfalse;
+		}
+		else
+		{
+			G_SetOrigin( teleEnt, org );
+		}
+	}
+
+	return qtrue;
+}
+
+/*
+=============
+Q3_SetOrigin
+
+Sets the origin of an entity directly
+=============
+*/
+static void Q3_SetOrigin( int entID, vec3_t origin )
+{
+	gentity_t	*ent = &g_entities[entID];
+
+	if ( !ent )
+	{
+		G_DebugPrint( WL_WARNING, "Q3_SetOrigin: bad ent %d\n", entID);
+		return;
+	}
+
+	trap_UnlinkEntity (ent);
+
+	if(ent->client)
+	{
+		VectorCopy(origin, ent->client->ps.origin);
+		VectorCopy(origin, ent->r.currentOrigin);
+		ent->client->ps.origin[2] += 1;
+
+		VectorClear (ent->client->ps.velocity);
+		ent->client->ps.pm_time = 160;		// hold time
+		ent->client->ps.pm_flags |= PMF_TIME_KNOCKBACK;
+		
+		ent->client->ps.eFlags ^= EF_TELEPORT_BIT;
+
+//		G_KillBox (ent);
+	}
+	else
+	{
+		G_SetOrigin( ent, origin );
+	}
+
+	trap_LinkEntity( ent );
+}
+
+/*
+=============
+Q3_SetCopyOrigin
+
+Copies origin of found ent into ent running script
+=============`
+*/
+static void Q3_SetCopyOrigin( int entID, const char *name )
+{
+	gentity_t	*found = G_Find( NULL, FOFS(targetname), (char *) name);
+
+	if(found)
+	{
+		Q3_SetOrigin( entID, found->r.currentOrigin );
+		SetClientViewAngle( &g_entities[entID], found->s.angles );
+	}
+	else
+	{
+		G_DebugPrint( WL_WARNING, "Q3_SetCopyOrigin: ent %s not found!\n", name);
+	}
+}
+
+/*
+=============
+Q3_SetVelocity
+
+Set the velocity of an entity directly
+=============
+*/
+static void Q3_SetVelocity( int entID, int axis, float speed )
+{
+	gentity_t	*found = &g_entities[entID];
+	//FIXME: Not supported
+	if(!found)
+	{
+		G_DebugPrint( WL_WARNING, "Q3_SetVelocity invalid entID %d\n", entID);
+		return;
+	}
+
+	if(!found->client)
+	{
+		G_DebugPrint( WL_WARNING, "Q3_SetVelocity: not a client %d\n", entID);
+		return;
+	}
+
+	//FIXME: add or set?
+	found->client->ps.velocity[axis] += speed;
+
+	found->client->ps.pm_time = 500;
+	found->client->ps.pm_flags |= PMF_TIME_KNOCKBACK;
+}
+
+/*
+=============
+Q3_SetAngles
+
+Sets the angles of an entity directly
+=============
+*/
+static void Q3_SetAngles( int entID, vec3_t angles )
+{
+	gentity_t	*ent = &g_entities[entID];
+
+
+	if ( !ent )
+	{
+		G_DebugPrint( WL_WARNING, "Q3_SetAngles: bad ent %d\n", entID);
+		return;
+	}
+
+	if (ent->client)
+	{
+		SetClientViewAngle( ent, angles );
+	}
+	else
+	{
+		VectorCopy( angles, ent->s.angles );
+	}
+	trap_LinkEntity( ent );
+}
+
+/*
+=============
+Q3_Lerp2Origin
+
+Lerps the origin to the destination value
+=============
+*/
+void Q3_Lerp2Origin( int taskID, int entID, vec3_t origin, float duration )
+{
+	gentity_t	*ent = &g_entities[entID];
+	moverState_t moverState;
+
+	if(!ent)
+	{
+		G_DebugPrint( WL_WARNING, "Q3_Lerp2Origin: invalid entID %d\n", entID);
+		return;
+	}
+	
+	if ( ent->client || Q_stricmp(ent->classname, "target_scriptrunner") == 0 )
+	{
+		G_DebugPrint( WL_ERROR, "Q3_Lerp2Origin: ent %d is NOT a mover!\n", entID);
+		return;
+	}
+
+	if ( ent->s.eType != ET_MOVER )
+	{
+		ent->s.eType = ET_MOVER;
+	}
+
+	moverState = ent->moverState;
+
+	if ( moverState == MOVER_POS1 || moverState == MOVER_2TO1 )
+	{
+		VectorCopy( ent->r.currentOrigin, ent->pos1 );
+		VectorCopy( origin, ent->pos2 );
+
+		moverState = MOVER_1TO2;
+	}
+	else if ( moverState == MOVER_POS2 || moverState == MOVER_1TO2 )
+	{
+		VectorCopy( ent->r.currentOrigin, ent->pos2 );
+		VectorCopy( origin, ent->pos1 );
+
+		moverState = MOVER_2TO1;
+	}
+
+	InitMoverTrData( ent );	//FIXME: This will probably break normal things that are being moved...
+
+	ent->s.pos.trDuration = duration;
+
+	// start it going
+	MatchTeam( ent, moverState, level.time );
+	//SetMoverState( ent, moverState, level.time );
+
+	ent->reached = moverCallback;
+	if ( ent->damage )
+	{
+		ent->blocked = Blocked_Mover;
+	}
+	if ( taskID != -1 )
+	{
+		trap_ICARUS_TaskIDSet( ent, TID_MOVE_NAV, taskID );
+	}
+	// starting sound
+	G_PlayDoorLoopSound( ent );//start looping sound
+	G_PlayDoorSound( ent, BMS_START );	//play start sound
+
+	trap_LinkEntity( ent );
+}
+
+static void Q3_SetOriginOffset( int entID, int axis, float offset )
+{	
+	gentity_t	*ent = &g_entities[entID];
+	vec3_t origin;
+	float duration;
+
+	if(!ent)
+	{
+		G_DebugPrint( WL_WARNING, "Q3_SetOriginOffset: invalid entID %d\n", entID);
+		return;
+	}
+	
+	if ( ent->client || Q_stricmp(ent->classname, "target_scriptrunner") == 0 )
+	{
+		G_DebugPrint( WL_ERROR, "Q3_SetOriginOffset: ent %d is NOT a mover!\n", entID);
+		return;
+	}
+
+	VectorCopy( ent->s.origin, origin );
+	origin[axis] += offset;
+	duration = 0;
+	if ( ent->speed )
+	{
+		duration = fabs(offset)/fabs(ent->speed)*1000.0f;
+	}
+	Q3_Lerp2Origin( -1, entID, origin, duration );
+}
+
+/*
+============
+SetLowerAnim
+  Description	: 
+  Return type	: static void 
+  Argument		:  int entID
+  Argument		: int animID
+============
+*/
+static void SetLowerAnim( int entID, int animID)
+{
+	gentity_t	*ent  = &g_entities[entID];
+
+	if ( !ent )
+	{
+		G_DebugPrint( WL_WARNING, "SetLowerAnim: invalid entID %d\n", entID);
+		return;
+	}
+
+	if ( !ent->client )
+	{
+		G_DebugPrint( WL_ERROR, "SetLowerAnim: ent %d is NOT a player or NPC!\n", entID);
+		return;
+	}
+
+	G_SetAnim(ent,NULL,SETANIM_LEGS,animID,SETANIM_FLAG_RESTART|SETANIM_FLAG_HOLD|SETANIM_FLAG_OVERRIDE,0);
+}
+
+/*
+============
+SetUpperAnim 
+  Description	: 
+  Return type	: static void 
+  Argument		:  int entID
+  Argument		: int animID
+============
+*/
+static void SetUpperAnim ( int entID, int animID)
+{
+	gentity_t	*ent  = &g_entities[entID];
+
+	if ( !ent )
+	{
+		G_DebugPrint( WL_WARNING, "SetUpperAnim: invalid entID %d\n", entID);
+		return;
+	}
+
+	if ( !ent->client )
+	{
+		G_DebugPrint( WL_ERROR, "SetLowerAnim: ent %d is NOT a player or NPC!\n", entID);
+		return;
+	}
+
+	G_SetAnim(ent,NULL,SETANIM_TORSO,animID,SETANIM_FLAG_RESTART|SETANIM_FLAG_HOLD|SETANIM_FLAG_OVERRIDE,0);
+}
+
+/*
+=============
+Q3_SetAnimUpper
+
+Sets the upper animation of an entity
+=============
+*/
+static qboolean Q3_SetAnimUpper( int entID, const char *anim_name )
+{
+	int			animID = 0;
+
+	animID = GetIDForString( animTable, anim_name );
+
+	if( animID == -1 )
+	{
+		G_DebugPrint( WL_WARNING, "Q3_SetAnimUpper: unknown animation sequence '%s'\n", anim_name );
+		return qfalse;
+	}
+
+	/*
+	if ( !PM_HasAnimation( SV_GentityNum(entID), animID ) )
+	{
+		return qfalse;
+	}
+	*/
+
+	SetUpperAnim( entID, animID );
+	return qtrue;
+}
+
+/*
+=============
+Q3_SetAnimLower
+
+Sets the lower animation of an entity
+=============
+*/
+static qboolean Q3_SetAnimLower( int entID, const char *anim_name )
+{
+	int			animID = 0;
+
+	//FIXME: Setting duck anim does not actually duck!
+
+	animID = GetIDForString( animTable, anim_name );
+
+	if( animID == -1 )
+	{
+		G_DebugPrint( WL_WARNING, "Q3_SetAnimLower: unknown animation sequence '%s'\n", anim_name );
+		return qfalse;
+	}
+	
+	/*
+	if ( !PM_HasAnimation( SV_GentityNum(entID), animID ) )
+	{
+		return qfalse;
+	}
+	*/
+
+	SetLowerAnim( entID, animID );
+	return qtrue;
+}
+
+/*
+============
+Q3_SetAnimHoldTime
+  Description	: 
+  Return type	: static void 
+  Argument		:  int entID
+  Argument		: int int_data
+  Argument		: qboolean lower
+============
+*/
+static void Q3_SetAnimHoldTime( int entID, int int_data, qboolean lower )
+{
+	G_DebugPrint( WL_WARNING, "Q3_SetAnimHoldTime is not currently supported in MP\n");
+	/*
+	gentity_t	*ent  = &g_entities[entID];
+
+	if ( !ent )
+	{
+		G_DebugPrint( WL_WARNING, "Q3_SetAnimHoldTime: invalid entID %d\n", entID);
+		return;
+	}
+
+	if ( !ent->client )
+	{
+		G_DebugPrint( WL_ERROR, "Q3_SetAnimHoldTime: ent %d is NOT a player or NPC!\n", entID);
+		return;
+	}
+	
+	if(lower)
+	{
+		PM_SetLegsAnimTimer( ent, &ent->client->ps.legsAnimTimer, int_data );
+	}
+	else
+	{
+		PM_SetTorsoAnimTimer( ent, &ent->client->ps.torsoAnimTimer, int_data );
+	}
+	*/
+}
+
+/*
+============
+Q3_SetHealth
+  Description	: 
+  Return type	: static void 
+  Argument		:  int entID
+  Argument		: int data
+============
+*/
+static void Q3_SetHealth( int entID, int data )
+{
+	gentity_t	*ent  = &g_entities[entID];
+
+	if ( !ent )
+	{
+		G_DebugPrint( WL_WARNING, "Q3_SetHealth: invalid entID %d\n", entID);
+		return;
+	}
+	
+	if ( data < 0 )
+	{
+		data = 0;
+	}
+
+	ent->health = data;
+
+	if(!ent->client)
+	{
+		return;
+	}
+
+	ent->client->ps.stats[STAT_HEALTH] = data;
+
+	if ( ent->client->ps.stats[STAT_HEALTH] > ent->client->ps.stats[STAT_MAX_HEALTH] )
+	{
+		ent->health = ent->client->ps.stats[STAT_HEALTH] = ent->client->ps.stats[STAT_MAX_HEALTH];
+	}
+	if ( data == 0 )
+	{
+		ent->health = 1;
+		if ( ent->client->sess.sessionTeam == TEAM_SPECTATOR )
+		{ //this would be silly
+			return;
+		}
+
+		ent->flags &= ~FL_GODMODE;
+		ent->client->ps.stats[STAT_HEALTH] = ent->health = -999;
+		player_die (ent, ent, ent, 100000, MOD_FALLING);
+	}
+}
+
+
+/*
+============
+Q3_SetArmor
+  Description	: 
+  Return type	: static void 
+  Argument		:  int entID
+  Argument		: int data
+============
+*/
+static void Q3_SetArmor( int entID, int data )
+{
+	gentity_t	*ent  = &g_entities[entID];
+
+	if ( !ent )
+	{
+		G_DebugPrint( WL_WARNING, "Q3_SetArmor: invalid entID %d\n", entID);
+		return;
+	}
+	
+	if(!ent->client)
+	{
+		return;
+	}
+
+	ent->client->ps.stats[STAT_ARMOR] = data;
+	if ( ent->client->ps.stats[STAT_ARMOR] > ent->client->ps.stats[STAT_MAX_HEALTH] )
+	{
+		ent->client->ps.stats[STAT_ARMOR] = ent->client->ps.stats[STAT_MAX_HEALTH];
+	}
+}
+
+
+/*
+============
+Q3_SetBState
+  Description	: 
+  Return type	: static qboolean 
+  Argument		:  int entID
+  Argument		: const char *bs_name
+FIXME: this should be a general NPC wrapper function 
+	that is called ANY time	a bState is changed...
+============
+*/
+static qboolean Q3_SetBState( int entID, const char *bs_name )
+{
+	gentity_t	*ent  = &g_entities[entID];
+	bState_t	bSID;
+
+	if ( !ent )
+	{
+		G_DebugPrint( WL_WARNING, "Q3_SetBState: invalid entID %d\n", entID);
+		return qtrue;
+	}
+	
+	if ( !ent->NPC )
+	{
+		G_DebugPrint( WL_ERROR, "Q3_SetBState: '%s' is not an NPC\n", ent->targetname );
+		return qtrue;//ok to complete
+	}
+
+	bSID = (bState_t)(GetIDForString( BSTable, bs_name ));
+	if ( bSID > -1 )
+	{
+		if ( bSID == BS_SEARCH || bSID == BS_WANDER )
+		{
+			//FIXME: Reimplement
+			
+			if( ent->waypoint != WAYPOINT_NONE )
+			{
+				NPC_BSSearchStart( ent->waypoint, bSID );
+			}
+			else
+			{
+				ent->waypoint = NAV_FindClosestWaypointForEnt( ent, WAYPOINT_NONE );
+
+				if( ent->waypoint != WAYPOINT_NONE )
+				{
+					NPC_BSSearchStart( ent->waypoint, bSID );
+				}
+				/*else if( ent->lastWaypoint >=0 && ent->lastWaypoint < num_waypoints )
+				{
+					NPC_BSSearchStart( ent->lastWaypoint, bSID );
+				}
+				else if( ent->lastValidWaypoint >=0 && ent->lastValidWaypoint < num_waypoints )
+				{
+					NPC_BSSearchStart( ent->lastValidWaypoint, bSID );
+				}*/
+				else
+				{
+					G_DebugPrint( WL_ERROR, "Q3_SetBState: '%s' is not in a valid waypoint to search from!\n", ent->targetname );
+					return qtrue;
+				}
+			}
+		}
+		
+
+		ent->NPC->tempBehavior = BS_DEFAULT;//need to clear any temp behaviour
+		if ( ent->NPC->behaviorState == BS_NOCLIP && bSID != BS_NOCLIP )
+		{//need to rise up out of the floor after noclipping
+			ent->r.currentOrigin[2] += 0.125;
+			G_SetOrigin( ent, ent->r.currentOrigin );
+		}
+		ent->NPC->behaviorState = bSID;
+		if ( bSID == BS_DEFAULT )
+		{
+			ent->NPC->defaultBehavior = bSID;
+		}
+	}
+
+	ent->NPC->aiFlags &= ~NPCAI_TOUCHED_GOAL;
+
+//	if ( bSID == BS_FLY )
+//	{//FIXME: need a set bState wrapper
+//		ent->client->moveType = MT_FLYSWIM;
+//	}
+//	else
+	{
+		//FIXME: these are presumptions!
+		//Q3_SetGravity( entID, g_gravity->value );
+		//ent->client->moveType = MT_RUNJUMP;
+	}
+
+	if ( bSID == BS_NOCLIP )
+	{
+		ent->client->noclip = qtrue;
+	}
+	else
+	{
+		ent->client->noclip = qfalse;
+	}
+
+/*
+	if ( bSID == BS_FACE || bSID == BS_POINT_AND_SHOOT || bSID == BS_FACE_ENEMY )
+	{
+		ent->NPC->aimTime = level.time + 5 * 1000;//try for 5 seconds
+		return qfalse;//need to wait for task complete message
+	}
+*/
+
+//	if ( bSID == BS_SNIPER || bSID == BS_ADVANCE_FIGHT )
+	if ( bSID == BS_ADVANCE_FIGHT )
+	{
+		return qfalse;//need to wait for task complete message
+	}
+
+/*
+	if ( bSID == BS_SHOOT || bSID == BS_POINT_AND_SHOOT )
+	{//Let them shoot right NOW
+		ent->NPC->shotTime = ent->attackDebounceTime = level.time;
+	}
+*/
+	if ( bSID == BS_JUMP )
+	{
+		ent->NPC->jumpState = JS_FACING;
+	}
+
+	return qtrue;//ok to complete
+}
+
+
+/*
+============
+Q3_SetTempBState
+  Description	: 
+  Return type	: static qboolean 
+  Argument		:  int entID
+  Argument		: const char *bs_name
+============
+*/
+static qboolean Q3_SetTempBState( int entID, const char *bs_name )
+{
+	gentity_t	*ent  = &g_entities[entID];
+	bState_t	bSID;
+
+	if ( !ent )
+	{
+		G_DebugPrint( WL_WARNING, "Q3_SetTempBState: invalid entID %d\n", entID);
+		return qtrue;
+	}
+	
+	if ( !ent->NPC )
+	{
+		G_DebugPrint( WL_ERROR, "Q3_SetTempBState: '%s' is not an NPC\n", ent->targetname );
+		return qtrue;//ok to complete
+	}
+
+	bSID = (bState_t)(GetIDForString( BSTable, bs_name ));
+	if ( bSID > -1 )
+	{
+		ent->NPC->tempBehavior = bSID;
+	}
+
+/*
+	if ( bSID == BS_FACE || bSID == BS_POINT_AND_SHOOT || bSID == BS_FACE_ENEMY )
+	{
+		ent->NPC->aimTime = level.time + 5 * 1000;//try for 5 seconds
+		return qfalse;//need to wait for task complete message
+	}
+*/
+
+/*
+	if ( bSID == BS_SHOOT || bSID == BS_POINT_AND_SHOOT )
+	{//Let them shoot right NOW
+		ent->NPC->shotTime = ent->attackDebounceTime = level.time;
+	}
+*/
+	return qtrue;//ok to complete
+}
+
+
+/*
+============
+Q3_SetDefaultBState
+  Description	: 
+  Return type	: static void 
+  Argument		:  int entID
+  Argument		: const char *bs_name
+============
+*/
+static void Q3_SetDefaultBState( int entID, const char *bs_name )
+{
+	gentity_t	*ent  = &g_entities[entID];
+	bState_t	bSID;
+
+	if ( !ent )
+	{
+		G_DebugPrint( WL_WARNING, "Q3_SetDefaultBState: invalid entID %d\n", entID);
+		return;
+	}
+	
+	if ( !ent->NPC )
+	{
+		G_DebugPrint( WL_ERROR, "Q3_SetDefaultBState: '%s' is not an NPC\n", ent->targetname );
+		return;
+	}
+
+	bSID = (bState_t)(GetIDForString( BSTable, bs_name ));
+	if ( bSID > -1 )
+	{
+		ent->NPC->defaultBehavior = bSID;
+	}
+}
+
+
+/*
+============
+Q3_SetDPitch
+  Description	: 
+  Return type	: static void 
+  Argument		:  int entID
+  Argument		: float data
+============
+*/
+static void Q3_SetDPitch( int entID, float data )
+{
+	G_DebugPrint( WL_WARNING, "Q3_SetDPitch: NOT SUPPORTED IN MP\n");
+	return;
+}
+
+
+/*
+============
+Q3_SetDYaw
+  Description	: 
+  Return type	: static void 
+  Argument		:  int entID
+  Argument		: float data
+============
+*/
+static void Q3_SetDYaw( int entID, float data )
+{
+	G_DebugPrint( WL_WARNING, "Q3_SetDYaw: NOT SUPPORTED IN MP\n");
+	return;
+}
+
+
+/*
+============
+Q3_SetShootDist
+  Description	: 
+  Return type	: static void 
+  Argument		:  int entID
+  Argument		: float data
+============
+*/
+static void Q3_SetShootDist( int entID, float data )
+{
+	G_DebugPrint( WL_WARNING, "Q3_SetShootDist: NOT SUPPORTED IN MP\n");
+	return;
+}
+
+
+/*
+============
+Q3_SetVisrange
+  Description	: 
+  Return type	: static void 
+  Argument		:  int entID
+  Argument		: float data
+============
+*/
+static void Q3_SetVisrange( int entID, float data )
+{
+	G_DebugPrint( WL_WARNING, "Q3_SetVisrange: NOT SUPPORTED IN MP\n");
+	return;
+}
+
+
+/*
+============
+Q3_SetEarshot
+  Description	: 
+  Return type	: static void 
+  Argument		:  int entID
+  Argument		: float data
+============
+*/
+static void Q3_SetEarshot( int entID, float data )
+{
+	G_DebugPrint( WL_WARNING, "Q3_SetEarshot: NOT SUPPORTED IN MP\n");
+	return;
+}
+
+
+/*
+============
+Q3_SetVigilance
+  Description	: 
+  Return type	: static void 
+  Argument		:  int entID
+  Argument		: float data
+============
+*/
+static void Q3_SetVigilance( int entID, float data )
+{
+	G_DebugPrint( WL_WARNING, "Q3_SetVigilance: NOT SUPPORTED IN MP\n");
+	return;
+}
+
+
+/*
+============
+Q3_SetVFOV
+  Description	: 
+  Return type	: static void 
+  Argument		:  int entID
+  Argument		: int data
+============
+*/
+static void Q3_SetVFOV( int entID, int data )
+{
+	G_DebugPrint( WL_WARNING, "Q3_SetVFOV: NOT SUPPORTED IN MP\n");
+	return;
+}
+
+
+/*
+============
+Q3_SetHFOV
+  Description	: 
+  Return type	: static void 
+  Argument		:  int entID
+  Argument		: int data
+============
+*/
+static void Q3_SetHFOV( int entID, int data )
+{
+	G_DebugPrint( WL_WARNING, "Q3_SetHFOV: NOT SUPPORTED IN MP\n");
+	return;
+}
+
+
+/*
+============
+Q3_SetWidth
+  Description	: 
+  Return type	: static void 
+  Argument		:  int entID
+  Argument		: float data
+============
+*/
+static void Q3_SetWidth( int entID, int data )
+{
+	G_DebugPrint( WL_WARNING, "Q3_SetWidth: NOT SUPPORTED IN MP\n");
+	return;
+}
+
+/*
+============
+Q3_SetTimeScale
+  Description	: 
+  Return type	: static void 
+  Argument		:  int entID
+  Argument		: const char *data
+============
+*/
+static void Q3_SetTimeScale( int entID, const char *data )
+{
+	trap_Cvar_Set("timescale", data);
+}
+
+
+/*
+============
+Q3_SetInvisible
+  Description	: 
+  Return type	: static void 
+  Argument		:  int entID
+  Argument		: qboolean invisible
+============
+*/
+static void Q3_SetInvisible( int entID, qboolean invisible )
+{
+	gentity_t	*self  = &g_entities[entID];
+
+	if ( !self )
+	{
+		G_DebugPrint( WL_WARNING, "Q3_SetInvisible: invalid entID %d\n", entID);
+		return;
+	}
+	
+	if ( invisible )
+	{
+		self->s.eFlags |= EF_NODRAW;
+		if ( self->client )
+		{
+			self->client->ps.eFlags |= EF_NODRAW;
+		}
+		self->r.contents = 0;
+	}
+	else
+	{
+		self->s.eFlags &= ~EF_NODRAW;
+		if ( self->client )
+		{
+			self->client->ps.eFlags &= ~EF_NODRAW;
+		}
+	}
+}
+
+/*
+============
+Q3_SetVampire
+  Description	: 
+  Return type	: static void 
+  Argument		:  int entID
+  Argument		: qboolean vampire
+============
+*/
+static void Q3_SetVampire( int entID, qboolean vampire )
+{
+	G_DebugPrint( WL_WARNING, "Q3_SetVampire: NOT SUPPORTED IN MP\n");
+	return;
+}
+/*
+============
+Q3_SetGreetAllies
+  Description	: 
+  Return type	: static void 
+  Argument		:  int entID
+  Argument		: qboolean greet
+============
+*/
+static void Q3_SetGreetAllies( int entID, qboolean greet )
+{
+	G_DebugPrint( WL_WARNING, "Q3_SetGreetAllies: NOT SUPPORTED IN MP\n");
+	return;
+}
+
+
+/*
+============
+Q3_SetViewTarget 
+  Description	: 
+  Return type	: static void 
+  Argument		: int entID
+  Argument		: const char *name
+============
+*/
+static void Q3_SetViewTarget (int entID, const char *name)
+{
+	G_DebugPrint( WL_WARNING, "Q3_SetViewTarget: NOT SUPPORTED IN MP\n");
+	return;
+}
+
+
+/*
+============
+Q3_SetWatchTarget 
+  Description	: 
+  Return type	: static void 
+  Argument		: int entID
+  Argument		: const char *name
+============
+*/
+static void Q3_SetWatchTarget (int entID, const char *name)
+{
+	G_DebugPrint( WL_WARNING, "Q3_SetWatchTarget: NOT SUPPORTED IN MP\n");
+	return;
+}
+
+void Q3_SetLoopSound(int entID, const char *name)
+{
+	sfxHandle_t	index;
+	gentity_t	*self  = &g_entities[entID];
+
+	if ( Q_stricmp( "NULL", name ) == 0 || Q_stricmp( "NONE", name )==0)
+	{
+		self->s.loopSound = 0;
+		self->s.loopIsSoundset = qfalse;
+		return;
+	}
+
+	index = G_SoundIndex( (char*)name );
+
+	if (index)
+	{
+		self->s.loopSound = index;
+		self->s.loopIsSoundset = qfalse;
+	}
+	else
+	{
+		G_DebugPrint( WL_WARNING, "Q3_SetLoopSound: can't find sound file: '%s'\n", name );
+	}
+}
+
+void Q3_SetICARUSFreeze( int entID, const char *name, qboolean freeze )
+{
+	gentity_t	*self  = G_Find( NULL, FOFS(targetname), name );
+	if ( !self )
+	{//hmm, targetname failed, try script_targetname?
+		self = G_Find( NULL, FOFS(script_targetname), name );
+	}
+
+	if ( !self )
+	{
+		G_DebugPrint( WL_WARNING, "Q3_SetICARUSFreeze: invalid ent %s\n", name);
+		return;
+	}
+	
+	if ( freeze )
+	{
+		self->r.svFlags |= SVF_ICARUS_FREEZE;
+	}
+	else
+	{
+		self->r.svFlags &= ~SVF_ICARUS_FREEZE;
+	}
+}
+
+/*
+============
+Q3_SetViewEntity
+  Description	: 
+  Return type	: static void 
+  Argument		: int entID
+  Argument		: const char *name
+============
+*/
+void Q3_SetViewEntity(int entID, const char *name)
+{
+	G_DebugPrint( WL_WARNING, "Q3_SetViewEntity currently unsupported in MP, ask if you need it.\n");
+}
+
+/*
+============
+Q3_SetWeapon 
+  Description	: 
+  Return type	: static void 
+  Argument		: int entID
+  Argument		: const char *wp_name
+============
+*/
+static void Q3_SetWeapon (int entID, const char *wp_name)
+{
+	G_DebugPrint( WL_WARNING, "Q3_SetWeapon currently unsupported in MP, ask if you need it.\n");
+}
+
+/*
+============
+Q3_SetItem 
+  Description	: 
+  Return type	: static void 
+  Argument		: int entID
+  Argument		: const char *wp_name
+============
+*/
+static void Q3_SetItem (int entID, const char *item_name)
+{ //rww - unused in mp
+	G_DebugPrint( WL_WARNING, "Q3_SetItem: NOT SUPPORTED IN MP\n");
+	return;
+}
+
+
+
+/*
+============
+Q3_SetWalkSpeed 
+  Description	: 
+  Return type	: static void 
+  Argument		: int entID
+  Argument		: int int_data
+============
+*/
+static void Q3_SetWalkSpeed (int entID, int int_data)
+{
+	G_DebugPrint( WL_WARNING, "Q3_SetWalkSpeed: NOT SUPPORTED IN MP\n");
+	return;
+}
+
+
+/*
+============
+Q3_SetRunSpeed 
+  Description	: 
+  Return type	: static void 
+  Argument		: int entID
+  Argument		: int int_data
+============
+*/
+static void Q3_SetRunSpeed (int entID, int int_data)
+{
+	G_DebugPrint( WL_WARNING, "Q3_SetRunSpeed: NOT SUPPORTED IN MP\n");
+	return;
+}
+
+
+/*
+============
+Q3_SetYawSpeed 
+  Description	: 
+  Return type	: static void 
+  Argument		: int entID
+  Argument		: float float_data
+============
+*/
+static void Q3_SetYawSpeed (int entID, float float_data)
+{
+	G_DebugPrint( WL_WARNING, "Q3_SetYawSpeed: NOT SUPPORTED IN MP\n");
+	return;
+}
+
+
+/*
+============
+Q3_SetAggression
+  Description	: 
+  Return type	: static void 
+  Argument		: int entID
+  Argument		: int int_data
+============
+*/
+static void Q3_SetAggression(int entID, int int_data)
+{
+	G_DebugPrint( WL_WARNING, "Q3_SetAggression: NOT SUPPORTED IN MP\n");
+	return;
+}
+
+
+/*
+============
+Q3_SetAim
+  Description	: 
+  Return type	: static void 
+  Argument		: int entID
+  Argument		: int int_data
+============
+*/
+static void Q3_SetAim(int entID, int int_data)
+{
+	G_DebugPrint( WL_WARNING, "Q3_SetAim: NOT SUPPORTED IN MP\n");
+	return;
+}
+
+
+/*
+============
+Q3_SetFriction
+  Description	: 
+  Return type	: static void 
+  Argument		: int entID
+  Argument		: int int_data
+============
+*/
+static void Q3_SetFriction(int entID, int int_data)
+{
+	gentity_t	*self  = &g_entities[entID];
+
+	if ( !self )
+	{
+		G_DebugPrint( WL_WARNING, "Q3_SetFriction: invalid entID %d\n", entID);
+		return;
+	}
+	
+	if ( !self->client )
+	{
+		G_DebugPrint( WL_ERROR, "Q3_SetFriction: '%s' is not an NPC/player!\n", self->targetname );
+		return;
+	}
+
+	G_DebugPrint( WL_WARNING, "Q3_SetFriction currently unsupported in MP\n");
+//	self->client->ps.friction = int_data;
+}
+
+
+/*
+============
+Q3_SetGravity
+  Description	: 
+  Return type	: static void 
+  Argument		: int entID
+  Argument		: float float_data
+============
+*/
+static void Q3_SetGravity(int entID, float float_data)
+{
+	gentity_t	*self  = &g_entities[entID];
+
+	if ( !self )
+	{
+		G_DebugPrint( WL_WARNING, "Q3_SetGravity: invalid entID %d\n", entID);
+		return;
+	}
+	
+	if ( !self->client )
+	{
+		G_DebugPrint( WL_ERROR, "Q3_SetGravity: '%s' is not an NPC/player!\n", self->targetname );
+		return;
+	}
+
+	//FIXME: what if we want to return them to normal global gravity?
+	if ( self->NPC )
+	{
+		self->NPC->aiFlags |= NPCAI_CUSTOM_GRAVITY;
+	}
+	self->client->ps.gravity = float_data;
+}
+
+
+/*
+============
+Q3_SetWait
+  Description	: 
+  Return type	: static void 
+  Argument		: int entID
+  Argument		: float float_data
+============
+*/
+static void Q3_SetWait(int entID, float float_data)
+{
+	gentity_t	*self  = &g_entities[entID];
+
+	if ( !self )
+	{
+		G_DebugPrint( WL_WARNING, "Q3_SetWait: invalid entID %d\n", entID);
+		return;
+	}
+	
+	self->wait = float_data;
+}
+
+
+static void Q3_SetShotSpacing(int entID, int int_data)
+{
+	G_DebugPrint( WL_WARNING, "Q3_SetShotSpacing: NOT SUPPORTED IN MP\n");
+	return;
+}
+
+/*
+============
+Q3_SetFollowDist
+  Description	: 
+  Return type	: static void 
+  Argument		: int entID
+  Argument		: float float_data
+============
+*/
+static void Q3_SetFollowDist(int entID, float float_data)
+{
+	G_DebugPrint( WL_WARNING, "Q3_SetFollowDist: NOT SUPPORTED IN MP\n");
+	return;
+}
+
+
+/*
+============
+Q3_SetScale
+  Description	: 
+  Return type	: static void 
+  Argument		: int entID
+  Argument		: float float_data
+============
+*/
+static void Q3_SetScale(int entID, float float_data)
+{
+	gentity_t	*self  = &g_entities[entID];
+
+	if ( !self )
+	{
+		G_DebugPrint( WL_WARNING, "Q3_SetScale: invalid entID %d\n", entID);
+		return;
+	}
+	
+	if (self->client)
+	{
+		self->client->ps.iModelScale = float_data*100.0f;
+	}
+	else
+	{
+		self->s.iModelScale = float_data*100.0f;
+	}
+}
+
+/*
+============
+Q3_GameSideCheckStringCounterIncrement
+  Description	: 
+  Return type	: static float 
+  Argument		: const char *string
+============
+*/
+static float Q3_GameSideCheckStringCounterIncrement( const char *string )
+{
+	char	*numString;
+	float	val = 0.0f;
+
+	if ( string[0] == '+' )
+	{//We want to increment whatever the value is by whatever follows the +
+		if ( string[1] )
+		{
+			numString = (char *)&string[1];
+			val = atof( numString );
+		}
+	}
+	else if ( string[0] == '-' )
+	{//we want to decrement
+		if ( string[1] )
+		{
+			numString = (char *)&string[1];
+			val = atof( numString ) * -1;
+		}
+	}
+
+	return val;
+}
+
+/*
+============
+Q3_SetCount
+  Description	: 
+  Return type	: static void 
+  Argument		: int entID
+  Argument		: const char *data
+============
+*/
+static void Q3_SetCount(int entID, const char *data)
+{
+	gentity_t	*self  = &g_entities[entID];
+	float		val = 0.0f;
+
+	//FIXME: use FOFS() stuff here to make a generic entity field setting?
+	if ( !self )
+	{
+		G_DebugPrint( WL_WARNING, "Q3_SetCount: invalid entID %d\n", entID);
+		return;
+	}
+	
+	if ( (val = Q3_GameSideCheckStringCounterIncrement( data )) )
+	{
+		self->count += (int)(val);
+	}
+	else
+	{
+		self->count = atoi((char *) data);
+	}
+}
+
+
+/*
+============
+Q3_SetTargetName 
+  Description	: 
+  Return type	: static void 
+  Argument		: int entID
+  Argument		: const char *targetname
+============
+*/
+static void Q3_SetTargetName (int entID, const char *targetname)
+{
+	gentity_t	*self  = &g_entities[entID];
+
+	if ( !self )
+	{
+		G_DebugPrint( WL_WARNING, "Q3_SetTargetName: invalid entID %d\n", entID);
+		return;
+	}
+
+	if(!Q_stricmp("NULL", ((char *)targetname)))
+	{
+		self->targetname = NULL;
+	}
+	else
+	{
+		self->targetname = G_NewString( targetname );
+	}
+}
+
+
+/*
+============
+Q3_SetTarget 
+  Description	: 
+  Return type	: static void 
+  Argument		: int entID
+  Argument		: const char *target
+============
+*/
+static void Q3_SetTarget (int entID, const char *target)
+{
+	gentity_t	*self  = &g_entities[entID];
+
+	if ( !self )
+	{
+		G_DebugPrint( WL_WARNING, "Q3_SetTarget: invalid entID %d\n", entID);
+		return;
+	}
+
+	if(!Q_stricmp("NULL", ((char *)target)))
+	{
+		self->target = NULL;
+	}
+	else
+	{
+		self->target = G_NewString( target );
+	}
+}
+
+/*
+============
+Q3_SetTarget2
+  Description	: 
+  Return type	: static void 
+  Argument		: int entID
+  Argument		: const char *target
+============
+*/
+static void Q3_SetTarget2 (int entID, const char *target2)
+{
+	G_DebugPrint( WL_WARNING, "Q3_SetTarget2 does not exist in MP\n");
+	/*
+	sharedEntity_t	*self  = SV_GentityNum(entID);
+
+	if ( !self )
+	{
+		G_DebugPrint( WL_WARNING, "Q3_SetTarget2: invalid entID %d\n", entID);
+		return;
+	}
+
+	if(!Q_stricmp("NULL", ((char *)target2)))
+	{
+		self->target2 = NULL;
+	}
+	else
+	{
+		self->target2 = G_NewString( target2 );
+	}
+	*/
+}
+/*
+============
+Q3_SetRemoveTarget 
+  Description	: 
+  Return type	: static void 
+  Argument		: int entID
+  Argument		: const char *target
+============
+*/
+static void Q3_SetRemoveTarget (int entID, const char *target)
+{
+	G_DebugPrint( WL_WARNING, "Q3_SetRemoveTarget: NOT SUPPORTED IN MP\n");
+	return;
+}
+
+
+/*
+============
+Q3_SetPainTarget 
+  Description	: 
+  Return type	: void 
+  Argument		: int entID
+  Argument		: const char *targetname
+============
+*/
+static void Q3_SetPainTarget (int entID, const char *targetname)
+{
+	G_DebugPrint( WL_WARNING, "Q3_SetPainTarget: NOT SUPPORTED IN MP\n");
+	/*
+	sharedEntity_t	*self  = SV_GentityNum(entID);
+
+	if ( !self )
+	{
+		G_DebugPrint( WL_WARNING, "Q3_SetPainTarget: invalid entID %d\n", entID);
+		return;
+	}
+
+	if(Q_stricmp("NULL", ((char *)targetname)) == 0)
+	{
+		self->paintarget = NULL;
+	}
+	else
+	{
+		self->paintarget = G_NewString((char *)targetname);
+	}
+	*/
+}
+
+/*
+============
+Q3_SetFullName 
+  Description	: 
+  Return type	: static void 
+  Argument		: int entID
+  Argument		: const char *fullName
+============
+*/
+static void Q3_SetFullName (int entID, const char *fullName)
+{
+	gentity_t	*self  = &g_entities[entID];
+
+	if ( !self )
+	{
+		G_DebugPrint( WL_WARNING, "Q3_SetFullName: invalid entID %d\n", entID);
+		return;
+	}
+
+	if(!Q_stricmp("NULL", ((char *)fullName)))
+	{
+		self->fullName = NULL;
+	}
+	else
+	{
+		self->fullName = G_NewString( fullName );
+	}
+}
+
+static void Q3_SetMusicState( const char *dms )
+{
+	G_DebugPrint( WL_WARNING, "Q3_SetMusicState: NOT SUPPORTED IN MP\n");
+	return;
+}
+
+static void Q3_SetForcePowerLevel ( int entID, int forcePower, int forceLevel )
+{
+	G_DebugPrint( WL_WARNING, "Q3_SetForcePowerLevel: NOT SUPPORTED IN MP\n");
+	return;
+}
+/*
+============
+Q3_SetParm
+  Description	: 
+  Return type	: void 
+  Argument		: int entID
+  Argument		: int parmNum
+  Argument		: const char *parmValue
+============
+*/
+void Q3_SetParm (int entID, int parmNum, const char *parmValue)
+{
+	gentity_t	*ent = &g_entities[entID];
+	float		val;
+
+	if ( !ent )
+	{
+		G_DebugPrint( WL_WARNING, "Q3_SetParm: invalid entID %d\n", entID);
+		return;
+	}
+
+	if ( parmNum < 0 || parmNum >= MAX_PARMS )
+	{
+		G_DebugPrint( WL_WARNING, "SET_PARM: parmNum %d out of range!\n", parmNum );
+		return;
+	}
+
+	if( !ent->parms )
+	{
+		ent->parms = (parms_t *)G_Alloc( sizeof(parms_t) );
+		memset( ent->parms, 0, sizeof(parms_t) );
+	}
+
+	if ( (val = Q3_GameSideCheckStringCounterIncrement( parmValue )) )
+	{
+		val += atof( ent->parms->parm[parmNum] );
+		Com_sprintf( ent->parms->parm[parmNum], sizeof(ent->parms->parm), "%f", val );
+	}
+	else
+	{//Just copy the string
+		//copy only 16 characters
+		strncpy( ent->parms->parm[parmNum], parmValue, sizeof(ent->parms->parm[0]) );
+		//set the last charcter to null in case we had to truncate their passed string
+		if ( ent->parms->parm[parmNum][sizeof(ent->parms->parm[0]) - 1] != 0 )
+		{//Tried to set a string that is too long
+			ent->parms->parm[parmNum][sizeof(ent->parms->parm[0]) - 1] = 0;
+			G_DebugPrint( WL_WARNING, "SET_PARM: parm%d string too long, truncated to '%s'!\n", parmNum, ent->parms->parm[parmNum] );
+		}
+	}
+}
+
+
+
+/*
+=============
+Q3_SetCaptureGoal
+
+Sets the capture spot goal of an entity
+=============
+*/
+static void Q3_SetCaptureGoal( int entID, const char *name )
+{
+	G_DebugPrint( WL_WARNING, "Q3_SetCaptureGoal: NOT SUPPORTED IN MP\n");
+	return;
+}
+
+/*
+=============
+Q3_SetEvent
+
+?
+=============
+*/
+static void Q3_SetEvent( int entID, const char *event_name )
+{ //rwwFIXMEFIXME: Use in MP?
+	G_DebugPrint( WL_WARNING, "Q3_SetEvent: NOT SUPPORTED IN MP (may be in future, ask if needed)\n");
+	return;
+}
+
+/*
+============
+Q3_SetIgnorePain
+
+?
+============
+*/
+static void Q3_SetIgnorePain( int entID, qboolean data)
+{
+	G_DebugPrint( WL_WARNING, "Q3_SetIgnorePain: NOT SUPPORTED IN MP\n");
+	return;
+}
+
+/*
+============
+Q3_SetIgnoreEnemies
+
+?
+============
+*/
+static void Q3_SetIgnoreEnemies( int entID, qboolean data)
+{
+	G_DebugPrint( WL_WARNING, "Q3_SetIgnoreEnemies: NOT SUPPORTED IN MP\n");
+	return;
+}
+
+/*
+============
+Q3_SetIgnoreAlerts
+
+?
+============
+*/
+static void Q3_SetIgnoreAlerts( int entID, qboolean data)
+{
+	G_DebugPrint( WL_WARNING, "Q3_SetIgnoreAlerts: NOT SUPPORTED IN MP\n");
+	return;
+}
+
+
+/*
+============
+Q3_SetNoTarget
+
+?
+============
+*/
+static void Q3_SetNoTarget( int entID, qboolean data)
+{
+	gentity_t	*ent  = &g_entities[entID];
+
+	if ( !ent )
+	{
+		G_DebugPrint( WL_WARNING, "Q3_SetNoTarget: invalid entID %d\n", entID);
+		return;
+	}
+
+	if(data)
+		ent->flags |= FL_NOTARGET;
+	else
+		ent->flags &= ~FL_NOTARGET;
+}
+
+/*
+============
+Q3_SetDontShoot
+
+?
+============
+*/
+static void Q3_SetDontShoot( int entID, qboolean add)
+{
+	G_DebugPrint( WL_WARNING, "Q3_SetDontShoot: NOT SUPPORTED IN MP\n");
+	return;
+}
+
+/*
+============
+Q3_SetDontFire
+
+?
+============
+*/
+static void Q3_SetDontFire( int entID, qboolean add)
+{
+	G_DebugPrint( WL_WARNING, "Q3_SetDontFire: NOT SUPPORTED IN MP\n");
+	return;
+}
+
+/*
+============
+Q3_SetFireWeapon
+
+?
+============
+*/
+static void Q3_SetFireWeapon(int entID, qboolean add)
+{
+	G_DebugPrint( WL_WARNING, "Q3_SetFireWeapon: NOT SUPPORTED IN MP\n");
+	return;
+}
+
+
+/*
+============
+Q3_SetInactive
+
+?
+============
+*/
+static void Q3_SetInactive(int entID, qboolean add)
+{
+	gentity_t	*ent  = &g_entities[entID];
+
+	if ( !ent )
+	{
+		G_DebugPrint( WL_WARNING, "Q3_SetInactive: invalid entID %d\n", entID);
+		return;
+	}
+	
+	if(add)
+	{
+		ent->flags |= FL_INACTIVE;
+	}
+	else
+	{
+		ent->flags &= ~FL_INACTIVE;
+	}
+}
+
+/*
+============
+Q3_SetFuncUsableVisible
+
+?
+============
+*/
+static void Q3_SetFuncUsableVisible(int entID, qboolean visible )
+{
+	gentity_t	*ent  = &g_entities[entID];
+
+	if ( !ent )
+	{
+		G_DebugPrint( WL_WARNING, "Q3_SetFuncUsableVisible: invalid entID %d\n", entID);
+		return;
+	}
+	
+	// Yeah, I know that this doesn't even do half of what the func_usable use code does, but if I've got two things on top of each other...and only
+	//	one is visible at a time....and neither can ever be used......and finally, the shader on it has the shader_anim stuff going on....It doesn't seem
+	//	like I can easily use the other version without nasty side effects.
+	if( visible )
+	{
+		ent->r.svFlags &= ~SVF_NOCLIENT;
+		ent->s.eFlags &= ~EF_NODRAW;
+	}
+	else
+	{
+		ent->r.svFlags |= SVF_NOCLIENT;
+		ent->s.eFlags |= EF_NODRAW;
+	}
+}
+
+/*
+============
+Q3_SetLockedEnemy
+
+?
+============
+*/
+static void Q3_SetLockedEnemy ( int entID, qboolean locked)
+{
+	G_DebugPrint( WL_WARNING, "Q3_SetLockedEnemy: NOT SUPPORTED IN MP\n");
+	return;
+}
+
+char cinematicSkipScript[1024];
+
+/*
+============
+Q3_SetCinematicSkipScript
+
+============
+*/
+static void Q3_SetCinematicSkipScript( char *scriptname )
+{
+	G_DebugPrint( WL_WARNING, "Q3_SetCinematicSkipScript: NOT SUPPORTED IN MP\n");
+	return;
+}
+
+/*
+============
+Q3_SetNoMindTrick
+
+?
+============
+*/
+static void Q3_SetNoMindTrick( int entID, qboolean add)
+{
+	G_DebugPrint( WL_WARNING, "Q3_SetNoMindTrick: NOT SUPPORTED IN MP\n");
+	return;
+}
+
+/*
+============
+Q3_SetCrouched
+
+?
+============
+*/
+static void Q3_SetCrouched( int entID, qboolean add)
+{
+	G_DebugPrint( WL_WARNING, "Q3_SetCrouched: NOT SUPPORTED IN MP\n");
+	return;
+}
+
+/*
+============
+Q3_SetWalking
+
+?
+============
+*/
+static void Q3_SetWalking( int entID, qboolean add)
+{
+	G_DebugPrint( WL_WARNING, "Q3_SetWalking: NOT SUPPORTED IN MP\n");
+	return;
+}
+
+/*
+============
+Q3_SetRunning
+
+?
+============
+*/
+static void Q3_SetRunning( int entID, qboolean add)
+{
+	G_DebugPrint( WL_WARNING, "Q3_SetRunning: NOT SUPPORTED IN MP\n");
+	return;
+}
+
+/*
+============
+Q3_SetForcedMarch
+
+?
+============
+*/
+static void Q3_SetForcedMarch( int entID, qboolean add)
+{
+	G_DebugPrint( WL_WARNING, "Q3_SetForcedMarch: NOT SUPPORTED IN MP\n");
+	return;
+}
+/*
+============
+Q3_SetChaseEnemies
+
+indicates whether the npc should chase after an enemy 
+============
+*/
+static void Q3_SetChaseEnemies( int entID, qboolean add)
+{
+	G_DebugPrint( WL_WARNING, "Q3_SetChaseEnemies: NOT SUPPORTED IN MP\n");
+	return;
+}
+
+/*
+============
+Q3_SetLookForEnemies
+
+if set npc will be on the look out for potential enemies
+if not set, npc will ignore enemies
+============
+*/
+static void Q3_SetLookForEnemies( int entID, qboolean add)
+{
+	G_DebugPrint( WL_WARNING, "Q3_SetLookForEnemies: NOT SUPPORTED IN MP\n");
+	return;
+}
+
+/*
+============
+Q3_SetFaceMoveDir
+
+============
+*/
+static void Q3_SetFaceMoveDir( int entID, qboolean add)
+{
+	G_DebugPrint( WL_WARNING, "Q3_SetFaceMoveDir: NOT SUPPORTED IN MP\n");
+	return;
+}
+
+/*
+============
+Q3_SetAltFire
+
+?
+============
+*/
+static void Q3_SetAltFire( int entID, qboolean add)
+{
+	G_DebugPrint( WL_WARNING, "Q3_SetAltFire: NOT SUPPORTED IN MP\n");
+	return;
+}
+
+/*
+============
+Q3_SetDontFlee
+
+?
+============
+*/
+static void Q3_SetDontFlee( int entID, qboolean add)
+{
+	G_DebugPrint( WL_WARNING, "Q3_SetDontFlee: NOT SUPPORTED IN MP\n");
+	return;
+}
+
+/*
+============
+Q3_SetNoResponse
+
+?
+============
+*/
+static void Q3_SetNoResponse( int entID, qboolean add)
+{
+	G_DebugPrint( WL_WARNING, "Q3_SetNoResponse: NOT SUPPORTED IN MP\n");
+	return;
+}
+
+/*
+============
+Q3_SetCombatTalk
+
+?
+============
+*/
+static void Q3_SetCombatTalk( int entID, qboolean add)
+{
+	G_DebugPrint( WL_WARNING, "Q3_SetCombatTalk: NOT SUPPORTED IN MP\n");
+	return;
+}
+
+/*
+============
+Q3_SetAlertTalk
+
+?
+============
+*/
+static void Q3_SetAlertTalk( int entID, qboolean add)
+{
+	G_DebugPrint( WL_WARNING, "Q3_SetAlertTalk: NOT SUPPORTED IN MP\n");
+	return;
+}
+
+/*
+============
+Q3_SetUseCpNearest
+
+?
+============
+*/
+static void Q3_SetUseCpNearest( int entID, qboolean add)
+{
+	G_DebugPrint( WL_WARNING, "Q3_SetUseCpNearest: NOT SUPPORTED IN MP\n");
+	return;
+}
+
+/*
+============
+Q3_SetNoForce
+
+?
+============
+*/
+static void Q3_SetNoForce( int entID, qboolean add)
+{
+	G_DebugPrint( WL_WARNING, "Q3_SetNoForce: NOT SUPPORTED IN MP\n");
+	return;
+}
+
+/*
+============
+Q3_SetNoAcrobatics
+
+?
+============
+*/
+static void Q3_SetNoAcrobatics( int entID, qboolean add)
+{
+	G_DebugPrint( WL_WARNING, "Q3_SetNoAcrobatics: NOT SUPPORTED IN MP\n");
+	return;
+}
+
+/*
+============
+Q3_SetUseSubtitles
+
+?
+============
+*/
+static void Q3_SetUseSubtitles( int entID, qboolean add)
+{
+	G_DebugPrint( WL_WARNING, "Q3_SetUseSubtitles: NOT SUPPORTED IN MP\n");
+	return;
+}
+
+/*
+============
+Q3_SetNoFallToDeath
+
+?
+============
+*/
+static void Q3_SetNoFallToDeath( int entID, qboolean add)
+{
+	G_DebugPrint( WL_WARNING, "Q3_SetNoFallToDeath: NOT SUPPORTED IN MP\n");
+	return;
+}
+
+/*
+============
+Q3_SetDismemberable
+
+?
+============
+*/
+static void Q3_SetDismemberable( int entID, qboolean dismemberable)
+{
+	G_DebugPrint( WL_WARNING, "Q3_SetDismemberable: NOT SUPPORTED IN MP\n");
+	return;
+}
+
+
+/*
+============
+Q3_SetMoreLight
+
+?
+============
+*/
+static void Q3_SetMoreLight( int entID, qboolean add )
+{
+	G_DebugPrint( WL_WARNING, "Q3_SetMoreLight: NOT SUPPORTED IN MP\n");
+	return;
+}
+
+/*
+============
+Q3_SetUndying
+
+?
+============
+*/
+static void Q3_SetUndying( int entID, qboolean undying)
+{
+	G_DebugPrint( WL_WARNING, "Q3_SetUndying: NOT SUPPORTED IN MP\n");
+	return;
+}
+
+/*
+============
+Q3_SetInvincible
+
+?
+============
+*/
+static void Q3_SetInvincible( int entID, qboolean invincible)
+{
+	G_DebugPrint( WL_WARNING, "Q3_SetInvicible: NOT SUPPORTED IN MP\n");
+	return;
+}
+/*
+============
+Q3_SetForceInvincible
+  Description	: 
+  Return type	: static void 
+  Argument		:  int entID
+  Argument		: qboolean forceInv
+============
+*/
+static void Q3_SetForceInvincible( int entID, qboolean forceInv )
+{
+	G_DebugPrint( WL_WARNING, "Q3_SetForceInvicible: NOT SUPPORTED IN MP\n");
+	return;
+}
+
+/*
+============
+Q3_SetNoAvoid
+
+?
+============
+*/
+static void Q3_SetNoAvoid( int entID, qboolean noAvoid)
+{
+	G_DebugPrint( WL_WARNING, "Q3_SetNoAvoid: NOT SUPPORTED IN MP\n");
+	return;
+}
+
+/*
+============
+SolidifyOwner
+  Description	: 
+  Return type	: void 
+  Argument		: sharedEntity_t *self
+============
+*/
+void SolidifyOwner( gentity_t *self )
+{
+	int oldContents;
+	gentity_t *owner = &g_entities[self->r.ownerNum];
+
+	self->nextthink = level.time + FRAMETIME;
+	self->think = G_FreeEntity;
+
+	if ( !owner || !owner->inuse )
+	{
+		return;
+	}
+
+	oldContents = owner->r.contents;
+	owner->r.contents = CONTENTS_BODY;
+	if ( SpotWouldTelefrag2( owner, owner->r.currentOrigin ) )
+	{
+		owner->r.contents = oldContents;
+		self->think = SolidifyOwner;
+	}
+	else
+	{
+		trap_ICARUS_TaskIDComplete( owner, TID_RESIZE );
+	}
+}
+
+
+/*
+============
+Q3_SetSolid
+
+?
+============
+*/
+static qboolean Q3_SetSolid( int entID, qboolean solid)
+{
+	gentity_t	*ent  = &g_entities[entID];
+	
+	if ( !ent || !ent->inuse )
+	{
+		G_DebugPrint( WL_WARNING, "Q3_SetSolid: invalid entID %d\n", entID);
+		return qtrue;
+	}
+
+	if ( solid )
+	{//FIXME: Presumption
+		int oldContents = ent->r.contents;
+		ent->r.contents = CONTENTS_BODY;
+		if ( SpotWouldTelefrag2( ent, ent->r.currentOrigin ) )
+		{
+			gentity_t *solidifier = G_Spawn();
+
+			solidifier->r.ownerNum = ent->s.number;
+
+			solidifier->think = SolidifyOwner;
+			solidifier->nextthink = level.time + FRAMETIME;
+			
+			ent->r.contents = oldContents;
+			return qfalse;
+		}
+		ent->clipmask |= CONTENTS_BODY;
+	}
+	else
+	{//FIXME: Presumption
+		if ( ent->s.eFlags & EF_NODRAW )
+		{//We're invisible too, so set contents to none
+			ent->r.contents = 0;
+		}
+		else
+		{
+			ent->r.contents = CONTENTS_CORPSE;
+		}
+	}
+	return qtrue;
+}
+
+/*
+============
+Q3_SetForwardMove
+
+?
+============
+*/
+static void Q3_SetForwardMove( int entID, int fmoveVal)
+{
+	gentity_t	*ent  = &g_entities[entID];
+
+	if ( !ent )
+	{
+		G_DebugPrint( WL_WARNING, "Q3_SetForwardMove: invalid entID %d\n", entID);
+		return;
+	}
+
+	if ( !ent->client )
+	{
+		G_DebugPrint( WL_ERROR, "Q3_SetForwardMove: '%s' is not an NPC/player!\n", ent->targetname );
+		return;
+	}
+
+	G_DebugPrint( WL_WARNING, "Q3_SetForwardMove: NOT SUPPORTED IN MP\n");
+	//ent->client->forced_forwardmove = fmoveVal;
+}
+
+/*
+============
+Q3_SetRightMove
+
+?
+============
+*/
+static void Q3_SetRightMove( int entID, int rmoveVal)
+{
+	gentity_t	*ent  = &g_entities[entID];
+
+	if ( !ent )
+	{
+		G_DebugPrint( WL_WARNING, "Q3_SetRightMove: invalid entID %d\n", entID);
+		return;
+	}
+
+	if ( !ent->client )
+	{
+		G_DebugPrint( WL_ERROR, "Q3_SetRightMove: '%s' is not an NPC/player!\n", ent->targetname );
+		return;
+	}
+
+	G_DebugPrint( WL_WARNING, "Q3_SetRightMove: NOT SUPPORTED IN MP\n");
+	//ent->client->forced_rightmove = rmoveVal;
+}
+
+/*
+============
+Q3_SetLockAngle
+
+?
+============
+*/
+static void Q3_SetLockAngle( int entID, const char *lockAngle)
+{
+	gentity_t	*ent  = &g_entities[entID];
+
+	if ( !ent )
+	{
+		G_DebugPrint( WL_WARNING, "Q3_SetLockAngle: invalid entID %d\n", entID);
+		return;
+	}
+
+	if ( !ent->client )
+	{
+		G_DebugPrint( WL_ERROR, "Q3_SetLockAngle: '%s' is not an NPC/player!\n", ent->targetname );
+		return;
+	}
+
+	G_DebugPrint( WL_WARNING, "Q3_SetLockAngle is not currently available. Ask if you really need it.\n");
+	/*
+	if(Q_stricmp("off", lockAngle) == 0)
+	{//free it
+		ent->client->renderInfo.renderFlags &= ~RF_LOCKEDANGLE;
+	}
+	else
+	{
+		ent->client->renderInfo.renderFlags |= RF_LOCKEDANGLE;
+
+		
+		if(Q_stricmp("auto", lockAngle) == 0)
+		{//use current yaw
+			ent->client->renderInfo.lockYaw = ent->client->ps.viewangles[YAW];
+		}
+		else
+		{//specified yaw
+			ent->client->renderInfo.lockYaw = atof((char *)lockAngle);
+		}
+	}
+	*/
+}
+
+
+/*
+============
+Q3_CameraGroup
+
+?
+============
+*/
+static void Q3_CameraGroup( int entID, char *camG)
+{
+	G_DebugPrint( WL_WARNING, "Q3_CameraGroup: NOT SUPPORTED IN MP\n");
+	return;
+}
+
+/*
+============
+Q3_CameraGroupZOfs
+
+?
+============
+*/
+static void Q3_CameraGroupZOfs( float camGZOfs )
+{
+	G_DebugPrint( WL_WARNING, "Q3_CameraGroupZOfs: NOT SUPPORTED IN MP\n");
+	return;
+}
+/*
+============
+Q3_CameraGroup
+
+?
+============
+*/
+static void Q3_CameraGroupTag( char *camGTag )
+{
+	G_DebugPrint( WL_WARNING, "Q3_CameraGroupTag: NOT SUPPORTED IN MP\n");
+	return;
+}
+
+/*
+============
+Q3_RemoveRHandModel
+============
+*/
+static void Q3_RemoveRHandModel( int entID, char *addModel)
+{
+	G_DebugPrint( WL_WARNING, "Q3_RemoveRHandModel: NOT SUPPORTED IN MP\n");
+}
+
+/*
+============
+Q3_AddRHandModel
+============
+*/
+static void Q3_AddRHandModel( int entID, char *addModel)
+{
+	G_DebugPrint( WL_WARNING, "Q3_AddRHandModel: NOT SUPPORTED IN MP\n");
+}
+
+/*
+============
+Q3_AddLHandModel
+============
+*/
+static void Q3_AddLHandModel( int entID, char *addModel)
+{
+	G_DebugPrint( WL_WARNING, "Q3_AddLHandModel: NOT SUPPORTED IN MP\n");
+}
+
+/*
+============
+Q3_RemoveLHandModel
+============
+*/
+static void Q3_RemoveLHandModel( int entID, char *addModel)
+{
+	G_DebugPrint( WL_WARNING, "Q3_RemoveLHandModel: NOT SUPPORTED IN MP\n");
+}
+
+/*
+============
+Q3_LookTarget
+
+?
+============
+*/
+static void Q3_LookTarget( int entID, char *targetName)
+{
+	G_DebugPrint( WL_WARNING, "Q3_LookTarget: NOT SUPPORTED IN MP\n");
+	return;
+}
+
+/*
+============
+Q3_Face
+
+?
+============
+*/
+static void Q3_Face( int entID,int expression, float holdtime)
+{
+	G_DebugPrint( WL_WARNING, "Q3_Face: NOT SUPPORTED IN MP\n");
+}
+
+/*
+============
+Q3_SetLocation
+  Description	: 
+  Return type	: qboolean 
+  Argument		:  int entID
+  Argument		: const char *location
+============
+*/
+static qboolean Q3_SetLocation( int entID, const char *location )
+{
+	G_DebugPrint( WL_WARNING, "Q3_SetLocation: NOT SUPPORTED IN MP\n");
+	return qtrue;
+}
+
+/*
+============
+Q3_SetPlayerLocked
+  Description	: 
+  Return type	: void 
+  Argument		:  int entID
+  Argument		: qboolean locked
+============
+*/
+qboolean	player_locked = qfalse;
+static void Q3_SetPlayerLocked( int entID, qboolean locked )
+{
+	G_DebugPrint( WL_WARNING, "Q3_SetPlayerLocked: NOT SUPPORTED IN MP\n");
+}
+
+/*
+============
+Q3_SetLockPlayerWeapons
+  Description	: 
+  Return type	: void 
+  Argument		:  int entID
+  Argument		: qboolean locked
+============
+*/
+static void Q3_SetLockPlayerWeapons( int entID, qboolean locked )
+{
+	G_DebugPrint( WL_WARNING, "Q3_SetLockPlayerWeapons: NOT SUPPORTED IN MP\n");
+}
+
+
+/*
+============
+Q3_SetNoImpactDamage
+  Description	: 
+  Return type	: void 
+  Argument		:  int entID
+  Argument		: qboolean locked
+============
+*/
+static void Q3_SetNoImpactDamage( int entID, qboolean noImp )
+{
+	G_DebugPrint( WL_WARNING, "Q3_SetNoImpactDamage: NOT SUPPORTED IN MP\n");
+}
+
+/*
+============
+Q3_SetBehaviorSet
+
+?
+============
+*/
+static qboolean Q3_SetBehaviorSet( int entID, int toSet, const char *scriptname)
+{
+	gentity_t	*ent  = &g_entities[entID];
+	bSet_t		bSet = BSET_INVALID;
+
+	if ( !ent )
+	{
+		G_DebugPrint( WL_WARNING, "Q3_SetBehaviorSet: invalid entID %d\n", entID);
+		return qfalse;
+	}
+
+	switch(toSet)
+	{
+	case SET_SPAWNSCRIPT:
+		bSet = BSET_SPAWN;
+		break;
+	case SET_USESCRIPT:
+		bSet = BSET_USE;
+		break;
+	case SET_AWAKESCRIPT:
+		bSet = BSET_AWAKE;
+		break;
+	case SET_ANGERSCRIPT:
+		bSet = BSET_ANGER;
+		break;
+	case SET_ATTACKSCRIPT:
+		bSet = BSET_ATTACK;
+		break;
+	case SET_VICTORYSCRIPT:
+		bSet = BSET_VICTORY;
+		break;
+	case SET_LOSTENEMYSCRIPT:
+		bSet = BSET_LOSTENEMY;
+		break;
+	case SET_PAINSCRIPT:
+		bSet = BSET_PAIN;
+		break;
+	case SET_FLEESCRIPT:
+		bSet = BSET_FLEE;
+		break;
+	case SET_DEATHSCRIPT:
+		bSet = BSET_DEATH;
+		break;
+	case SET_DELAYEDSCRIPT:
+		bSet = BSET_DELAYED;
+		break;
+	case SET_BLOCKEDSCRIPT:
+		bSet = BSET_BLOCKED;
+		break;
+	case SET_FFIRESCRIPT:
+		bSet = BSET_FFIRE;
+		break;
+	case SET_FFDEATHSCRIPT:
+		bSet = BSET_FFDEATH;
+		break;
+	case SET_MINDTRICKSCRIPT:
+		bSet = BSET_MINDTRICK;
+		break;
+	}
+
+	if(bSet < BSET_SPAWN || bSet >= NUM_BSETS)
+	{
+		return qfalse;
+	}
+
+	if(!Q_stricmp("NULL", scriptname))
+	{
+		if ( ent->behaviorSet[bSet] != NULL )
+		{
+//			gi.TagFree( ent->behaviorSet[bSet] );
+		}
+
+		ent->behaviorSet[bSet] = NULL;
+		//memset( &ent->behaviorSet[bSet], 0, sizeof(ent->behaviorSet[bSet]) );
+	}
+	else
+	{
+		if ( scriptname )
+		{
+			if ( ent->behaviorSet[bSet] != NULL )
+			{
+//				gi.TagFree( ent->behaviorSet[bSet] );
+			}
+			
+			ent->behaviorSet[bSet] = G_NewString( (char *) scriptname );	//FIXME: This really isn't good...
+		}
+
+		//ent->behaviorSet[bSet] = scriptname;
+		//strncpy( (char *) &ent->behaviorSet[bSet], scriptname, MAX_BSET_LENGTH );
+	}
+	return qtrue;
+}
+
+/*
+============
+Q3_SetDelayScriptTime
+
+?
+============
+*/
+static void Q3_SetDelayScriptTime(int entID, int delayTime)
+{
+	G_DebugPrint( WL_WARNING, "Q3_SetDelayScriptTime: NOT SUPPORTED IN MP\n");
+}
+
+	
+
+
+/*
+============
+Q3_SetPlayerUsable
+  Description	: 
+  Return type	: void 
+  Argument		:  int entID
+  Argument		: qboolean usable
+============
+*/
+static void Q3_SetPlayerUsable( int entID, qboolean usable )
+{
+	gentity_t	*ent  = &g_entities[entID];
+
+	if ( !ent )
+	{
+		G_DebugPrint( WL_WARNING, "Q3_SetPlayerUsable: invalid entID %d\n", entID);
+		return;
+	}
+
+	if(usable)
+	{
+		ent->r.svFlags |= SVF_PLAYER_USABLE;
+	}
+	else
+	{
+		ent->r.svFlags &= ~SVF_PLAYER_USABLE;
+	}
+}
+
+/*
+============
+Q3_SetDisableShaderAnims
+  Description	: 
+  Return type	: static void 
+  Argument		:  int entID
+  Argument		: int disabled
+============
+*/
+static void Q3_SetDisableShaderAnims( int entID, int disabled )
+{
+	G_DebugPrint( WL_WARNING, "Q3_SetDisableShaderAnims: NOT SUPPORTED IN MP\n");
+	return;
+}
+
+/*
+============
+Q3_SetShaderAnim
+  Description	: 
+  Return type	: static void 
+  Argument		:  int entID
+  Argument		: int disabled
+============
+*/
+static void Q3_SetShaderAnim( int entID, int disabled )
+{
+	G_DebugPrint( WL_WARNING, "Q3_SetShaderAnim: NOT SUPPORTED IN MP\n");
+	return;
+}
+
+/*
+============
+Q3_SetStartFrame
+  Description	: 
+  Return type	: static void 
+  Argument		:  int entID
+  Argument		: int startFrame
+============
+*/
+static void Q3_SetStartFrame( int entID, int startFrame )
+{
+	G_DebugPrint( WL_WARNING, "Q3_SetStartFrame: NOT SUPPORTED IN MP\n");
+}
+
+
+/*
+============
+Q3_SetEndFrame
+  Description	: 
+  Return type	: static void 
+  Argument		:  int entID
+  Argument		: int endFrame
+============
+*/
+static void Q3_SetEndFrame( int entID, int endFrame )
+{
+	G_DebugPrint( WL_WARNING, "Q3_SetEndFrame: NOT SUPPORTED IN MP\n");
+}
+
+/*
+============
+Q3_SetAnimFrame
+  Description	: 
+  Return type	: static void 
+  Argument		:  int entID
+  Argument		: int startFrame
+============
+*/
+static void Q3_SetAnimFrame( int entID, int animFrame )
+{
+	G_DebugPrint( WL_WARNING, "Q3_SetAnimFrame: NOT SUPPORTED IN MP\n");
+}
+
+/*
+============
+Q3_SetLoopAnim
+  Description	: 
+  Return type	: void 
+  Argument		:  int entID
+  Argument		: qboolean loopAnim
+============
+*/
+static void Q3_SetLoopAnim( int entID, qboolean loopAnim )
+{
+	G_DebugPrint( WL_WARNING, "Q3_SetLoopAnim: NOT SUPPORTED IN MP\n");
+}
+
+
+/*
+============
+Q3_SetShields
+  Description	: 
+  Return type	: void 
+  Argument		:  int entID
+  Argument		: qboolean shields
+============
+*/
+static void Q3_SetShields( int entID, qboolean shields )
+{
+	G_DebugPrint( WL_WARNING, "Q3_SetShields: NOT SUPPORTED IN MP\n");
+	return;
+}
+
+/*
+============
+Q3_SetSaberActive
+  Description	: 
+  Return type	: void 
+  Argument		:  int entID
+  Argument		: qboolean shields
+============
+*/
+static void Q3_SetSaberActive( int entID, qboolean active )
+{
+	gentity_t *ent = &g_entities[entID];
+
+	if (!ent || !ent->inuse)
+	{
+		return;
+	}
+
+	if (!ent->client)
+	{
+		G_DebugPrint( WL_WARNING, "Q3_SetSaberActive: %d is not a client\n", entID);
+	}
+
+	//fixme: Take into account player being in state where saber won't toggle? For now we simply won't care.
+	if (!ent->client->ps.saberHolstered && active)
+	{
+		Cmd_ToggleSaber_f(ent);
+	}
+	else if (BG_SabersOff( &ent->client->ps ) && !active)
+	{
+		Cmd_ToggleSaber_f(ent);
+	}
+}
+
+/*
+============
+Q3_SetNoKnockback
+  Description	: 
+  Return type	: void 
+  Argument		:  int entID
+  Argument		: qboolean noKnockback
+============
+*/
+static void Q3_SetNoKnockback( int entID, qboolean noKnockback )
+{
+	gentity_t	*ent  = &g_entities[entID];
+
+	if ( !ent )
+	{
+		G_DebugPrint( WL_WARNING, "Q3_SetNoKnockback: invalid entID %d\n", entID);
+		return;
+	}
+
+	if ( noKnockback )
+	{
+		ent->flags |= FL_NO_KNOCKBACK;
+	}
+	else
+	{
+		ent->flags &= ~FL_NO_KNOCKBACK;
+	}
+}
+
+/*
+============
+Q3_SetCleanDamagingEnts
+  Description	: 
+  Return type	: void 
+============
+*/
+static void Q3_SetCleanDamagingEnts( void )
+{
+	G_DebugPrint( WL_WARNING, "Q3_SetCleanDamagingEnts: NOT SUPPORTED IN MP\n");
+	return;
+}
+
+vec4_t textcolor_caption;
+vec4_t textcolor_center;
+vec4_t textcolor_scroll;
+
+/*
+-------------------------
+SetTextColor
+-------------------------
+*/
+static void SetTextColor ( vec4_t textcolor,const char *color)
+{
+	G_DebugPrint( WL_WARNING, "SetTextColor: NOT SUPPORTED IN MP\n");
+	return;
+}
+
+/*
+=============
+Q3_SetCaptionTextColor
+
+Change color text prints in
+=============
+*/
+static void Q3_SetCaptionTextColor ( const char *color)
+{
+	SetTextColor(textcolor_caption,color);
+}
+
+/*
+=============
+Q3_SetCenterTextColor
+
+Change color text prints in
+=============
+*/
+static void Q3_SetCenterTextColor ( const char *color)
+{
+	SetTextColor(textcolor_center,color);
+}
+
+/*
+=============
+Q3_SetScrollTextColor
+
+Change color text prints in
+=============
+*/
+static void Q3_SetScrollTextColor ( const char *color)
+{
+	SetTextColor(textcolor_scroll,color);
+}
+
+/*
+=============
+Q3_ScrollText
+
+Prints a message in the center of the screen
+=============
+*/
+static void Q3_ScrollText ( const char *id)
+{
+	G_DebugPrint( WL_WARNING, "Q3_ScrollText: NOT SUPPORTED IN MP\n");
+	//trap_SendServerCommand( -1, va("st \"%s\"", id));
+
+	return;
+}
+
+/*
+=============
+Q3_LCARSText
+
+Prints a message in the center of the screen giving it an LCARS frame around it
+=============
+*/
+static void Q3_LCARSText ( const char *id)
+{
+	G_DebugPrint( WL_WARNING, "Q3_ScrollText: NOT SUPPORTED IN MP\n");
+	//trap_SendServerCommand( -1, va("lt \"%s\"", id));
+
+	return;
+}
+
+void UnLockDoors(gentity_t *const ent);
+void LockDoors(gentity_t *const ent);
+
+//returns qtrue if it got to the end, otherwise qfalse.
+qboolean Q3_Set( int taskID, int entID, const char *type_name, const char *data )
+{
+	gentity_t	*ent = &g_entities[entID];
+	float		float_data;
+	int			int_data, toSet;
+	vec3_t		vector_data;
+
+	//Set this for callbacks
+	toSet = GetIDForString( setTable, type_name );
+
+	//TODO: Throw in a showscript command that will list each command and what they're doing...
+	//		maybe as simple as printing that line of the script to the console preceeded by the person's name?
+	//		showscript can take any number of targetnames or "all"?  Groupname?
+	switch ( toSet )
+	{
+	case SET_ORIGIN:
+		sscanf( data, "%f %f %f", &vector_data[0], &vector_data[1], &vector_data[2] );
+		G_SetOrigin( ent, vector_data );
+		if ( Q_strncmp( "NPC_", ent->classname, 4 ) == 0 )
+		{//hack for moving spawners
+			VectorCopy( vector_data, ent->s.origin);
+		}
+		break;
+
+	case SET_TELEPORT_DEST:
+		sscanf( data, "%f %f %f", &vector_data[0], &vector_data[1], &vector_data[2] );
+		if ( !Q3_SetTeleportDest( entID, vector_data ) )
+		{
+			trap_ICARUS_TaskIDSet( ent, TID_MOVE_NAV, taskID );
+			return qfalse;
+		}
+		break;
+
+	case SET_COPY_ORIGIN:
+		Q3_SetCopyOrigin( entID, (char *) data );
+		break;
+
+	case SET_ANGLES:
+		//Q3_SetAngles( entID, *(vec3_t *) data);
+		sscanf( data, "%f %f %f", &vector_data[0], &vector_data[1], &vector_data[2] );
+		Q3_SetAngles( entID, vector_data);
+		break;
+
+	case SET_XVELOCITY:
+		float_data = atof((char *) data);
+		Q3_SetVelocity( entID, 0, float_data);
+		break;
+	
+	case SET_YVELOCITY:
+		float_data = atof((char *) data);
+		Q3_SetVelocity( entID, 1, float_data);
+		break;
+
+	case SET_ZVELOCITY:
+		float_data = atof((char *) data);
+		Q3_SetVelocity( entID, 2, float_data);
+		break;
+
+	case SET_Z_OFFSET:
+		float_data = atof((char *) data);
+		Q3_SetOriginOffset( entID, 2, float_data);
+		break;
+
+	case SET_ENEMY:
+		G_DebugPrint( WL_WARNING, "Q3_SetEnemy: NOT SUPPORTED IN MP\n");
+		break;
+
+	case SET_LEADER:
+		G_DebugPrint( WL_WARNING, "Q3_SetLeader: NOT SUPPORTED IN MP\n");
+		break;
+
+	case SET_NAVGOAL:
+		G_DebugPrint( WL_WARNING, "Q3_SetNavGoal: NOT SUPPORTED IN MP\n");
+		break;
+
+	case SET_ANIM_UPPER:
+		if ( Q3_SetAnimUpper( entID, (char *) data ) )
+		{
+			Q3_TaskIDClear( &ent->taskID[TID_ANIM_BOTH] );//We only want to wait for the top
+			trap_ICARUS_TaskIDSet( ent, TID_ANIM_UPPER, taskID );
+			return qfalse;	//Don't call it back
+		}
+		break;
+
+	case SET_ANIM_LOWER:
+		if ( Q3_SetAnimLower( entID, (char *) data ) )
+		{
+			Q3_TaskIDClear( &ent->taskID[TID_ANIM_BOTH] );//We only want to wait for the bottom
+			trap_ICARUS_TaskIDSet( ent, TID_ANIM_LOWER, taskID );
+			return qfalse;	//Don't call it back
+		}
+		break;
+
+	case SET_ANIM_BOTH:
+		{
+			int	both = 0;
+			if ( Q3_SetAnimUpper( entID, (char *) data ) )
+			{
+				trap_ICARUS_TaskIDSet( ent, TID_ANIM_UPPER, taskID );
+				both++;
+			}
+			else
+			{
+				G_DebugPrint( WL_ERROR, "Q3_SetAnimUpper: %s does not have anim %s!\n", ent->targetname, (char *)data );
+			}
+			if ( Q3_SetAnimLower( entID, (char *) data ) )
+			{
+				trap_ICARUS_TaskIDSet( ent, TID_ANIM_LOWER, taskID );
+				both++;
+			}
+			else
+			{
+				G_DebugPrint( WL_ERROR, "Q3_SetAnimLower: %s does not have anim %s!\n", ent->targetname, (char *)data );
+			}
+			if ( both >= 2 )
+			{
+				trap_ICARUS_TaskIDSet( ent, TID_ANIM_BOTH, taskID );
+			}
+			if ( both )
+			{
+				return qfalse;	//Don't call it back
+			}
+		}
+		break;
+	
+	case SET_ANIM_HOLDTIME_LOWER:
+		int_data = atoi((char *) data);
+		Q3_SetAnimHoldTime( entID, int_data, qtrue );
+		Q3_TaskIDClear( &ent->taskID[TID_ANIM_BOTH] );//We only want to wait for the bottom
+		trap_ICARUS_TaskIDSet( ent, TID_ANIM_LOWER, taskID );
+		return qfalse;	//Don't call it back
+		break;
+
+	case SET_ANIM_HOLDTIME_UPPER:
+		int_data = atoi((char *) data);
+		Q3_SetAnimHoldTime( entID, int_data, qfalse );
+		Q3_TaskIDClear( &ent->taskID[TID_ANIM_BOTH] );//We only want to wait for the top
+		trap_ICARUS_TaskIDSet( ent, TID_ANIM_UPPER, taskID );
+		return qfalse;	//Don't call it back
+		break;
+
+	case SET_ANIM_HOLDTIME_BOTH:
+		int_data = atoi((char *) data);
+		Q3_SetAnimHoldTime( entID, int_data, qfalse );
+		Q3_SetAnimHoldTime( entID, int_data, qtrue );
+		trap_ICARUS_TaskIDSet( ent, TID_ANIM_BOTH, taskID );
+		trap_ICARUS_TaskIDSet( ent, TID_ANIM_UPPER, taskID );
+		trap_ICARUS_TaskIDSet( ent, TID_ANIM_LOWER, taskID );
+		return qfalse;	//Don't call it back
+		break;
+
+	case SET_PLAYER_TEAM:
+		G_DebugPrint( WL_WARNING, "Q3_SetPlayerTeam: Not in MP ATM, let a programmer (ideally Rich) know if you need it\n");
+		break;
+
+	case SET_ENEMY_TEAM:
+		G_DebugPrint( WL_WARNING, "Q3_SetEnemyTeam: NOT SUPPORTED IN MP\n");
+		break;
+
+	case SET_HEALTH:
+		int_data = atoi((char *) data);
+		Q3_SetHealth( entID, int_data );
+		break;
+
+	case SET_ARMOR:
+		int_data = atoi((char *) data);
+		Q3_SetArmor( entID, int_data );
+		break;
+
+	case SET_BEHAVIOR_STATE:
+		if( !Q3_SetBState( entID, (char *) data ) )
+		{
+			trap_ICARUS_TaskIDSet( ent, TID_BSTATE, taskID );
+			return qfalse;//don't complete
+		}
+		break;
+
+	case SET_DEFAULT_BSTATE:
+		Q3_SetDefaultBState( entID, (char *) data );
+		break;
+
+	case SET_TEMP_BSTATE:
+		if( !Q3_SetTempBState( entID, (char *) data ) )
+		{
+			trap_ICARUS_TaskIDSet( ent, TID_BSTATE, taskID );
+			return qfalse;//don't complete
+		}
+		break;
+
+	case SET_CAPTURE:
+		Q3_SetCaptureGoal( entID, (char *) data );
+		break;
+
+	case SET_DPITCH://FIXME: make these set tempBehavior to BS_FACE and await completion?  Or set lockedDesiredPitch/Yaw and aimTime?
+		float_data = atof((char *) data);
+		Q3_SetDPitch( entID, float_data );
+		trap_ICARUS_TaskIDSet( ent, TID_ANGLE_FACE, taskID );
+		return qfalse;
+		break;
+
+	case SET_DYAW:
+		float_data = atof((char *) data);
+		Q3_SetDYaw( entID, float_data );
+		trap_ICARUS_TaskIDSet( ent, TID_ANGLE_FACE, taskID );
+		return qfalse;
+		break;
+
+	case SET_EVENT:
+		Q3_SetEvent( entID, (char *) data );
+		break;
+
+	case SET_VIEWTARGET:
+		Q3_SetViewTarget( entID, (char *) data );
+		trap_ICARUS_TaskIDSet( ent, TID_ANGLE_FACE, taskID );
+		return qfalse;
+		break;
+
+	case SET_WATCHTARGET:
+		Q3_SetWatchTarget( entID, (char *) data );
+		break;
+
+	case SET_VIEWENTITY:
+		Q3_SetViewEntity( entID, (char *) data );
+		break;
+
+	case SET_LOOPSOUND:
+		Q3_SetLoopSound( entID, (char *) data );
+		break;
+
+	case SET_ICARUS_FREEZE:
+	case SET_ICARUS_UNFREEZE:
+		Q3_SetICARUSFreeze( entID, (char *) data, (qboolean)(toSet==SET_ICARUS_FREEZE) );
+		break;
+
+	case SET_WEAPON:
+		Q3_SetWeapon ( entID, (char *) data);
+		break;
+
+	case SET_ITEM:
+		Q3_SetItem ( entID, (char *) data);
+		break;
+
+	case SET_WALKSPEED:
+		int_data = atoi((char *) data);
+		Q3_SetWalkSpeed ( entID, int_data);
+		break;
+
+	case SET_RUNSPEED:
+		int_data = atoi((char *) data);
+		Q3_SetRunSpeed ( entID, int_data);
+		break;
+
+	case SET_WIDTH:
+		int_data = atoi((char *) data);
+		Q3_SetWidth( entID, int_data );
+		return qfalse;
+		break;
+
+	case SET_YAWSPEED:
+		float_data = atof((char *) data);
+		Q3_SetYawSpeed ( entID, float_data);
+		break;
+
+	case SET_AGGRESSION:
+		int_data = atoi((char *) data);
+		Q3_SetAggression ( entID, int_data);
+		break;
+
+	case SET_AIM:
+		int_data = atoi((char *) data);
+		Q3_SetAim ( entID, int_data);
+		break;
+
+	case SET_FRICTION:
+		int_data = atoi((char *) data);
+		Q3_SetFriction ( entID, int_data);
+		break;
+
+	case SET_GRAVITY:
+		float_data = atof((char *) data);
+		Q3_SetGravity ( entID, float_data);
+		break;
+
+	case SET_WAIT:
+		float_data = atof((char *) data);
+		Q3_SetWait( entID, float_data);
+		break;
+
+	case SET_FOLLOWDIST:
+		float_data = atof((char *) data);
+		Q3_SetFollowDist( entID, float_data);
+		break;
+
+	case SET_SCALE:
+		float_data = atof((char *) data);
+		Q3_SetScale( entID, float_data);
+		break;
+
+	case SET_COUNT:
+		Q3_SetCount( entID, (char *) data);
+		break;
+
+	case SET_SHOT_SPACING:
+		int_data = atoi((char *) data);
+		Q3_SetShotSpacing( entID, int_data );
+		break;
+
+	case SET_IGNOREPAIN:
+		if(!Q_stricmp("true", ((char *)data)))
+			Q3_SetIgnorePain( entID, qtrue);
+		else if(!Q_stricmp("false", ((char *)data)))
+			Q3_SetIgnorePain( entID, qfalse);
+		break;
+
+	case SET_IGNOREENEMIES:
+		if(!Q_stricmp("true", ((char *)data)))
+			Q3_SetIgnoreEnemies( entID, qtrue);
+		else if(!Q_stricmp("false", ((char *)data)))
+			Q3_SetIgnoreEnemies( entID, qfalse);
+		break;
+
+	case SET_IGNOREALERTS:
+		if(!Q_stricmp("true", ((char *)data)))
+			Q3_SetIgnoreAlerts( entID, qtrue);
+		else if(!Q_stricmp("false", ((char *)data)))
+			Q3_SetIgnoreAlerts( entID, qfalse);
+		break;
+		
+	case SET_DONTSHOOT:
+		if(!Q_stricmp("true", ((char *)data)))
+			Q3_SetDontShoot( entID, qtrue);
+		else if(!Q_stricmp("false", ((char *)data)))
+			Q3_SetDontShoot( entID, qfalse);
+		break;
+	
+	case SET_DONTFIRE:
+		if(!Q_stricmp("true", ((char *)data)))
+			Q3_SetDontFire( entID, qtrue);
+		else if(!Q_stricmp("false", ((char *)data)))
+			Q3_SetDontFire( entID, qfalse);
+		break;
+
+	case SET_LOCKED_ENEMY:
+		if(!Q_stricmp("true", ((char *)data)))
+			Q3_SetLockedEnemy( entID, qtrue);
+		else if(!Q_stricmp("false", ((char *)data)))
+			Q3_SetLockedEnemy( entID, qfalse);
+		break;
+
+	case SET_NOTARGET:
+		if(!Q_stricmp("true", ((char *)data)))
+			Q3_SetNoTarget( entID, qtrue);
+		else if(!Q_stricmp("false", ((char *)data)))
+			Q3_SetNoTarget( entID, qfalse);
+		break;
+
+	case SET_LEAN:
+		G_DebugPrint( WL_WARNING, "SET_LEAN NOT SUPPORTED IN MP\n" );
+		break;
+
+	case SET_SHOOTDIST:
+		float_data = atof((char *) data);
+		Q3_SetShootDist( entID, float_data );
+		break;
+
+	case SET_TIMESCALE:
+		Q3_SetTimeScale( entID, (char *) data );
+		break;
+
+	case SET_VISRANGE:
+		float_data = atof((char *) data);
+		Q3_SetVisrange( entID, float_data );
+		break;
+	
+	case SET_EARSHOT:
+		float_data = atof((char *) data);
+		Q3_SetEarshot( entID, float_data );
+		break;
+	
+	case SET_VIGILANCE:
+		float_data = atof((char *) data);
+		Q3_SetVigilance( entID, float_data );
+		break;
+	
+	case SET_VFOV:
+		int_data = atoi((char *) data);
+		Q3_SetVFOV( entID, int_data );
+		break;
+
+	case SET_HFOV:
+		int_data = atoi((char *) data);
+		Q3_SetHFOV( entID, int_data );
+		break;
+
+	case SET_TARGETNAME:
+		Q3_SetTargetName( entID, (char *) data );
+		break;
+
+	case SET_TARGET:
+		Q3_SetTarget( entID, (char *) data );
+		break;
+
+	case SET_TARGET2:
+		Q3_SetTarget2( entID, (char *) data );
+		break;
+	
+	case SET_LOCATION:
+		if ( !Q3_SetLocation( entID, (char *) data ) )
+		{
+			trap_ICARUS_TaskIDSet( ent, TID_LOCATION, taskID );
+			return qfalse;
+		}
+		break;
+
+	case SET_PAINTARGET:
+		Q3_SetPainTarget( entID, (char *) data );
+		break;
+
+	case SET_DEFEND_TARGET:
+		G_DebugPrint( WL_WARNING, "Q3_SetDefendTarget unimplemented\n", entID );
+		//Q3_SetEnemy( entID, (char *) data);
+		break;
+
+	case SET_PARM1:
+	case SET_PARM2:
+	case SET_PARM3:
+	case SET_PARM4:
+	case SET_PARM5:
+	case SET_PARM6:
+	case SET_PARM7:
+	case SET_PARM8:
+	case SET_PARM9:
+	case SET_PARM10:
+	case SET_PARM11:
+	case SET_PARM12:
+	case SET_PARM13:
+	case SET_PARM14:
+	case SET_PARM15:
+	case SET_PARM16:
+		Q3_SetParm( entID, (toSet-SET_PARM1), (char *) data );
+		break;
+
+	case SET_SPAWNSCRIPT:
+	case SET_USESCRIPT:
+	case SET_AWAKESCRIPT:
+	case SET_ANGERSCRIPT:
+	case SET_ATTACKSCRIPT:
+	case SET_VICTORYSCRIPT:
+	case SET_PAINSCRIPT:
+	case SET_FLEESCRIPT:
+	case SET_DEATHSCRIPT:
+	case SET_DELAYEDSCRIPT:
+	case SET_BLOCKEDSCRIPT:
+	case SET_FFIRESCRIPT:
+	case SET_FFDEATHSCRIPT:
+	case SET_MINDTRICKSCRIPT:
+		if( !Q3_SetBehaviorSet(entID, toSet, (char *) data) )
+			G_DebugPrint( WL_ERROR, "Q3_SetBehaviorSet: Invalid bSet %s\n", type_name );
+		break;
+
+	case SET_NO_MINDTRICK:
+		if(!Q_stricmp("true", ((char *)data)))
+			Q3_SetNoMindTrick( entID, qtrue);
+		else
+			Q3_SetNoMindTrick( entID, qfalse);
+		break;
+
+	case SET_CINEMATIC_SKIPSCRIPT :
+		Q3_SetCinematicSkipScript((char *) data);
+		break;
+
+
+	case SET_DELAYSCRIPTTIME:
+		int_data = atoi((char *) data);
+		Q3_SetDelayScriptTime( entID, int_data );
+		break;
+
+	case SET_CROUCHED:
+		if(!Q_stricmp("true", ((char *)data)))
+			Q3_SetCrouched( entID, qtrue);
+		else
+			Q3_SetCrouched( entID, qfalse);
+		break;
+
+	case SET_WALKING:
+		if(!Q_stricmp("true", ((char *)data)))
+			Q3_SetWalking( entID, qtrue);	
+		else
+			Q3_SetWalking( entID, qfalse);	
+		break;
+
+	case SET_RUNNING:
+		if(!Q_stricmp("true", ((char *)data)))
+			Q3_SetRunning( entID, qtrue);	
+		else
+			Q3_SetRunning( entID, qfalse);	
+		break;
+
+	case SET_CHASE_ENEMIES:
+		if(!Q_stricmp("true", ((char *)data)))
+			Q3_SetChaseEnemies( entID, qtrue);	
+		else
+			Q3_SetChaseEnemies( entID, qfalse);	
+		break;
+
+	case SET_LOOK_FOR_ENEMIES:
+		if(!Q_stricmp("true", ((char *)data)))
+			Q3_SetLookForEnemies( entID, qtrue);	
+		else
+			Q3_SetLookForEnemies( entID, qfalse);	
+		break;
+
+	case SET_FACE_MOVE_DIR:
+		if(!Q_stricmp("true", ((char *)data)))
+			Q3_SetFaceMoveDir( entID, qtrue);	
+		else
+			Q3_SetFaceMoveDir( entID, qfalse);	
+		break;
+
+	case SET_ALT_FIRE:
+		if(!Q_stricmp("true", ((char *)data)))
+			Q3_SetAltFire( entID, qtrue);	
+		else
+			Q3_SetAltFire( entID, qfalse);	
+		break;
+
+	case SET_DONT_FLEE:
+		if(!Q_stricmp("true", ((char *)data)))
+			Q3_SetDontFlee( entID, qtrue);	
+		else
+			Q3_SetDontFlee( entID, qfalse);	
+		break;
+
+	case SET_FORCED_MARCH:
+		if(!Q_stricmp("true", ((char *)data)))
+			Q3_SetForcedMarch( entID, qtrue);	
+		else
+			Q3_SetForcedMarch( entID, qfalse);	
+		break;
+
+	case SET_NO_RESPONSE:
+		if(!Q_stricmp("true", ((char *)data)))
+			Q3_SetNoResponse( entID, qtrue);	
+		else
+			Q3_SetNoResponse( entID, qfalse);	
+		break;
+
+	case SET_NO_COMBAT_TALK:
+		if(!Q_stricmp("true", ((char *)data)))
+			Q3_SetCombatTalk( entID, qtrue);	
+		else
+			Q3_SetCombatTalk( entID, qfalse);	
+		break;
+
+	case SET_NO_ALERT_TALK:
+		if(!Q_stricmp("true", ((char *)data)))
+			Q3_SetAlertTalk( entID, qtrue);	
+		else
+			Q3_SetAlertTalk( entID, qfalse);	
+		break;
+
+	case SET_USE_CP_NEAREST:
+		if(!Q_stricmp("true", ((char *)data)))
+			Q3_SetUseCpNearest( entID, qtrue);	
+		else
+			Q3_SetUseCpNearest( entID, qfalse);	
+		break;
+
+	case SET_NO_FORCE:
+		if(!Q_stricmp("true", ((char *)data)))
+			Q3_SetNoForce( entID, qtrue);	
+		else
+			Q3_SetNoForce( entID, qfalse);	
+		break;
+
+	case SET_NO_ACROBATICS:
+		if(!Q_stricmp("true", ((char *)data)))
+			Q3_SetNoAcrobatics( entID, qtrue);	
+		else
+			Q3_SetNoAcrobatics( entID, qfalse);	
+		break;
+
+	case SET_USE_SUBTITLES:
+		if(!Q_stricmp("true", ((char *)data)))
+			Q3_SetUseSubtitles( entID, qtrue);	
+		else
+			Q3_SetUseSubtitles( entID, qfalse);	
+		break;
+
+	case SET_NO_FALLTODEATH:
+		if(!Q_stricmp("true", ((char *)data)))
+			Q3_SetNoFallToDeath( entID, qtrue);	
+		else
+			Q3_SetNoFallToDeath( entID, qfalse);	
+		break;
+
+	case SET_DISMEMBERABLE:
+		if(!Q_stricmp("true", ((char *)data)))
+			Q3_SetDismemberable( entID, qtrue);	
+		else
+			Q3_SetDismemberable( entID, qfalse);	
+		break;
+
+	case SET_MORELIGHT:
+		if(!Q_stricmp("true", ((char *)data)))
+			Q3_SetMoreLight( entID, qtrue);	
+		else
+			Q3_SetMoreLight( entID, qfalse);	
+		break;
+
+
+	case SET_TREASONED:
+		G_DebugPrint( WL_VERBOSE, "SET_TREASONED is disabled, do not use\n" );
+		/*
+		G_TeamRetaliation( NULL, SV_GentityNum(0), qfalse );
+		ffireLevel = FFIRE_LEVEL_RETALIATION;
+		*/
+		break;
+
+	case SET_UNDYING:
+		if(!Q_stricmp("true", ((char *)data)))
+			Q3_SetUndying( entID, qtrue);	
+		else
+			Q3_SetUndying( entID, qfalse);	
+		break;
+
+	case SET_INVINCIBLE:
+		if(!Q_stricmp("true", ((char *)data)))
+			Q3_SetInvincible( entID, qtrue);	
+		else
+			Q3_SetInvincible( entID, qfalse);	
+		break;
+
+	case SET_NOAVOID:
+		if(!Q_stricmp("true", ((char *)data)))
+			Q3_SetNoAvoid( entID, qtrue);	
+		else
+			Q3_SetNoAvoid( entID, qfalse);	
+		break;
+
+	case SET_SOLID:
+		if(!Q_stricmp("true", ((char *)data)))
+		{
+			if ( !Q3_SetSolid( entID, qtrue) )
+			{
+				trap_ICARUS_TaskIDSet( ent, TID_RESIZE, taskID );
+				return qfalse;
+			}
+		}
+		else
+		{
+			Q3_SetSolid( entID, qfalse);
+		}
+		break;
+
+	case SET_INVISIBLE:
+		if( !Q_stricmp("true", ((char *)data)) )
+			Q3_SetInvisible( entID, qtrue );
+		else
+			Q3_SetInvisible( entID, qfalse );
+		break;
+
+	case SET_VAMPIRE:
+		if( !Q_stricmp("true", ((char *)data)) )
+			Q3_SetVampire( entID, qtrue );
+		else
+			Q3_SetVampire( entID, qfalse );
+		break;
+
+	case SET_FORCE_INVINCIBLE:
+		if( !Q_stricmp("true", ((char *)data)) )
+			Q3_SetForceInvincible( entID, qtrue );
+		else
+			Q3_SetForceInvincible( entID, qfalse );
+		break;
+
+	case SET_GREET_ALLIES:
+		if( !Q_stricmp("true", ((char *)data)) )
+			Q3_SetGreetAllies( entID, qtrue );
+		else
+			Q3_SetGreetAllies( entID, qfalse );
+		break;
+
+	case SET_PLAYER_LOCKED:
+		if( !Q_stricmp("true", ((char *)data)) )
+			Q3_SetPlayerLocked( entID, qtrue );
+		else
+			Q3_SetPlayerLocked( entID, qfalse );
+		break;
+		
+	case SET_LOCK_PLAYER_WEAPONS:
+		if( !Q_stricmp("true", ((char *)data)) )
+			Q3_SetLockPlayerWeapons( entID, qtrue );
+		else
+			Q3_SetLockPlayerWeapons( entID, qfalse );
+		break;
+
+	case SET_NO_IMPACT_DAMAGE:
+		if( !Q_stricmp("true", ((char *)data)) )
+			Q3_SetNoImpactDamage( entID, qtrue );
+		else
+			Q3_SetNoImpactDamage( entID, qfalse );
+		break;
+
+	case SET_FORWARDMOVE:
+		int_data = atoi((char *) data);
+		Q3_SetForwardMove( entID, int_data);	
+		break;
+
+	case SET_RIGHTMOVE:
+		int_data = atoi((char *) data);
+		Q3_SetRightMove( entID, int_data);	
+		break;
+
+	case SET_LOCKYAW:
+		Q3_SetLockAngle( entID, data);	
+		break;
+	
+	case SET_CAMERA_GROUP:
+		Q3_CameraGroup(entID, (char *)data);
+		break;
+	case SET_CAMERA_GROUP_Z_OFS:
+		float_data = atof((char *) data);
+		Q3_CameraGroupZOfs( float_data );
+		break;
+	case SET_CAMERA_GROUP_TAG:
+		Q3_CameraGroupTag( (char *)data );
+		break;
+
+	//FIXME: put these into camera commands
+	case SET_LOOK_TARGET:
+		Q3_LookTarget(entID, (char *)data);
+		break;
+
+	case SET_ADDRHANDBOLT_MODEL:
+		Q3_AddRHandModel(entID, (char *)data);
+		break;
+
+	case SET_REMOVERHANDBOLT_MODEL:
+		Q3_RemoveRHandModel(entID, (char *)data);
+		break;
+
+	case SET_ADDLHANDBOLT_MODEL:
+		Q3_AddLHandModel(entID, (char *)data);
+		break;
+
+	case SET_REMOVELHANDBOLT_MODEL:
+		Q3_RemoveLHandModel(entID, (char *)data);
+		break;
+
+	case SET_FACEEYESCLOSED:
+	case SET_FACEEYESOPENED:
+	case SET_FACEAUX:
+	case SET_FACEBLINK:
+	case SET_FACEBLINKFROWN:
+	case SET_FACEFROWN:
+	case SET_FACENORMAL:
+		float_data = atof((char *) data);
+		Q3_Face(entID, toSet, float_data);
+		break;
+
+	case SET_SCROLLTEXT:
+		Q3_ScrollText( (char *)data );	
+		break;
+
+	case SET_LCARSTEXT:
+		Q3_LCARSText( (char *)data );	
+		break;
+
+	case SET_CAPTIONTEXTCOLOR:
+		Q3_SetCaptionTextColor ( (char *)data );	
+		break;
+	case SET_CENTERTEXTCOLOR:
+		Q3_SetCenterTextColor ( (char *)data );	
+		break;
+	case SET_SCROLLTEXTCOLOR:
+		Q3_SetScrollTextColor ( (char *)data );	
+		break;
+
+	case SET_PLAYER_USABLE:
+		if(!Q_stricmp("true", ((char *)data)))
+		{
+			Q3_SetPlayerUsable(entID, qtrue);
+		}
+		else
+		{
+			Q3_SetPlayerUsable(entID, qfalse);
+		}
+		break;
+
+	case SET_STARTFRAME:
+		int_data = atoi((char *) data);
+		Q3_SetStartFrame(entID, int_data);
+		break;
+	
+	case SET_ENDFRAME:
+		int_data = atoi((char *) data);
+		Q3_SetEndFrame(entID, int_data);
+
+		trap_ICARUS_TaskIDSet( ent, TID_ANIM_BOTH, taskID );
+		return qfalse;
+		break;
+
+	case SET_ANIMFRAME:
+		int_data = atoi((char *) data);
+		Q3_SetAnimFrame(entID, int_data);
+		return qfalse;
+		break;
+		
+	case SET_LOOP_ANIM:
+		if(!Q_stricmp("true", ((char *)data)))
+		{
+			Q3_SetLoopAnim(entID, qtrue);
+		}
+		else
+		{
+			Q3_SetLoopAnim(entID, qfalse);
+		}
+		break;
+
+	case SET_INTERFACE:
+		G_DebugPrint( WL_WARNING, "Q3_SetInterface: NOT SUPPORTED IN MP\n");
+
+		break;
+
+	case SET_SHIELDS:
+		if(!Q_stricmp("true", ((char *)data)))
+		{
+			Q3_SetShields(entID, qtrue);
+		}
+		else
+		{
+			Q3_SetShields(entID, qfalse);
+		}
+		break;
+	
+	case SET_SABERACTIVE:
+		if(!Q_stricmp("true", ((char *)data)))
+		{
+			Q3_SetSaberActive( entID, qtrue );
+		}
+		else
+		{
+			Q3_SetSaberActive( entID, qfalse );
+		}
+		break;
+
+	case SET_ADJUST_AREA_PORTALS:
+		G_DebugPrint( WL_WARNING, "Q3_SetAdjustAreaPortals: NOT SUPPORTED IN MP\n");
+		break;
+	
+	case SET_DMG_BY_HEAVY_WEAP_ONLY:
+		G_DebugPrint( WL_WARNING, "Q3_SetDmgByHeavyWeapOnly: NOT SUPPORTED IN MP\n");
+		break;
+
+	case SET_SHIELDED:
+		G_DebugPrint( WL_WARNING, "Q3_SetShielded: NOT SUPPORTED IN MP\n");
+		break;
+
+	case SET_NO_GROUPS:
+		G_DebugPrint( WL_WARNING, "Q3_SetNoGroups: NOT SUPPORTED IN MP\n");
+		break;
+
+	case SET_FIRE_WEAPON:
+		if(!Q_stricmp("true", ((char *)data)))
+		{
+			Q3_SetFireWeapon( entID, qtrue);
+		}
+		else if(!Q_stricmp("false", ((char *)data)))
+		{
+			Q3_SetFireWeapon( entID, qfalse);
+		}
+		break;
+
+	case SET_INACTIVE:
+		if(!Q_stricmp("true", ((char *)data)))
+		{
+			Q3_SetInactive( entID, qtrue);
+		}
+		else if(!Q_stricmp("false", ((char *)data)))
+		{
+			Q3_SetInactive( entID, qfalse);
+		}
+		else if(!Q_stricmp("unlocked", ((char *)data)))
+		{
+			UnLockDoors(&g_entities[entID]);
+		}
+		else if(!Q_stricmp("locked", ((char *)data)))
+		{
+			LockDoors(&g_entities[entID]);
+		}
+		break;
+	case SET_END_SCREENDISSOLVE:
+		G_DebugPrint( WL_WARNING, "SET_END_SCREENDISSOLVE: NOT SUPPORTED IN MP\n");
+		break;
+
+	case SET_MISSION_STATUS_SCREEN:
+		//Cvar_Set("cg_missionstatusscreen", "1");
+		G_DebugPrint( WL_WARNING, "SET_MISSION_STATUS_SCREEN: NOT SUPPORTED IN MP\n");
+		break;
+
+	case SET_FUNC_USABLE_VISIBLE:
+		if(!Q_stricmp("true", ((char *)data)))
+		{
+			Q3_SetFuncUsableVisible( entID, qtrue);
+		}
+		else if(!Q_stricmp("false", ((char *)data)))
+		{
+			Q3_SetFuncUsableVisible( entID, qfalse);
+		}
+		break;
+
+	case SET_NO_KNOCKBACK:
+		if(!Q_stricmp("true", ((char *)data)))
+		{
+			Q3_SetNoKnockback(entID, qtrue);
+		}
+		else
+		{
+			Q3_SetNoKnockback(entID, qfalse);
+		}
+		break;
+
+	case SET_VIDEO_PLAY:
+		// don't do this check now, James doesn't want a scripted cinematic to also skip any Video cinematics as well,
+		//	the "timescale" and "skippingCinematic" cvars will be set back to normal in the Video code, so doing a
+		//	skip will now only skip one section of a multiple-part story (eg VOY1 bridge sequence)
+		//
+//		if ( g_timescale->value <= 1.0f )
+		{
+			G_DebugPrint( WL_WARNING, "SET_VIDEO_PLAY: NOT SUPPORTED IN MP\n");
+			//SV_SendConsoleCommand( va("inGameCinematic %s\n", (char *)data) );
+		}
+		break;
+
+	case SET_VIDEO_FADE_IN:
+		G_DebugPrint( WL_WARNING, "SET_VIDEO_FADE_IN: NOT SUPPORTED IN MP\n");
+		break;
+
+	case SET_VIDEO_FADE_OUT:
+		G_DebugPrint( WL_WARNING, "SET_VIDEO_FADE_OUT: NOT SUPPORTED IN MP\n");
+		break;
+	case SET_REMOVE_TARGET:
+		Q3_SetRemoveTarget( entID, (const char *) data );
+		break;
+
+	case SET_LOADGAME:
+		//gi.SendConsoleCommand( va("load %s\n", (const char *) data ) );
+		G_DebugPrint( WL_WARNING, "SET_LOADGAME: NOT SUPPORTED IN MP\n");
+		break;
+
+	case SET_MENU_SCREEN:
+		//UI_SetActiveMenu( (const char *) data );
+		break;
+
+	case SET_OBJECTIVE_SHOW:
+		G_DebugPrint( WL_WARNING, "SET_OBJECTIVE_SHOW: NOT SUPPORTED IN MP\n");
+		break;
+	case SET_OBJECTIVE_HIDE:
+		G_DebugPrint( WL_WARNING, "SET_OBJECTIVE_HIDE: NOT SUPPORTED IN MP\n");
+		break;
+	case SET_OBJECTIVE_SUCCEEDED:
+		G_DebugPrint( WL_WARNING, "SET_OBJECTIVE_SUCCEEDED: NOT SUPPORTED IN MP\n");
+		break;
+	case SET_OBJECTIVE_FAILED:
+		G_DebugPrint( WL_WARNING, "SET_OBJECTIVE_FAILED: NOT SUPPORTED IN MP\n");
+		break;
+
+	case SET_OBJECTIVE_CLEARALL:
+		G_DebugPrint( WL_WARNING, "SET_OBJECTIVE_CLEARALL: NOT SUPPORTED IN MP\n");
+		break;
+
+	case SET_MISSIONFAILED:
+		G_DebugPrint( WL_WARNING, "SET_MISSIONFAILED: NOT SUPPORTED IN MP\n");
+		break;
+
+	case SET_MISSIONSTATUSTEXT:
+		G_DebugPrint( WL_WARNING, "SET_MISSIONSTATUSTEXT: NOT SUPPORTED IN MP\n");
+		break;
+		
+	case SET_MISSIONSTATUSTIME:
+		G_DebugPrint( WL_WARNING, "SET_MISSIONSTATUSTIME: NOT SUPPORTED IN MP\n");
+		break;
+
+	case SET_CLOSINGCREDITS:
+		G_DebugPrint( WL_WARNING, "SET_CLOSINGCREDITS: NOT SUPPORTED IN MP\n");
+		break;
+
+	case SET_SKILL:
+//		//can never be set
+		break;
+
+	case SET_FULLNAME:
+		Q3_SetFullName( entID, (char *) data );
+		break;
+
+	case SET_DISABLE_SHADER_ANIM:
+		if(!Q_stricmp("true", ((char *)data)))
+		{
+			Q3_SetDisableShaderAnims( entID, qtrue);
+		}
+		else
+		{
+			Q3_SetDisableShaderAnims( entID, qfalse);
+		}
+		break;
+
+	case SET_SHADER_ANIM:
+		if(!Q_stricmp("true", ((char *)data)))
+		{
+			Q3_SetShaderAnim( entID, qtrue);
+		}
+		else
+		{
+			Q3_SetShaderAnim( entID, qfalse);
+		}
+		break;
+
+	case SET_MUSIC_STATE:
+		Q3_SetMusicState( (char *) data );
+		break;
+
+	case SET_CLEAN_DAMAGING_ENTS:
+		Q3_SetCleanDamagingEnts();
+		break;
+
+	case SET_HUD:
+		G_DebugPrint( WL_WARNING, "SET_HUD: NOT SUPPORTED IN MP\n");
+		break;
+
+	case SET_FORCE_HEAL_LEVEL:
+	case SET_FORCE_JUMP_LEVEL:
+	case SET_FORCE_SPEED_LEVEL:
+	case SET_FORCE_PUSH_LEVEL:
+	case SET_FORCE_PULL_LEVEL:
+	case SET_FORCE_MINDTRICK_LEVEL:
+	case SET_FORCE_GRIP_LEVEL:
+	case SET_FORCE_LIGHTNING_LEVEL:
+	case SET_SABER_THROW:
+	case SET_SABER_DEFENSE:
+	case SET_SABER_OFFENSE:
+		int_data = atoi((char *) data);
+		Q3_SetForcePowerLevel( entID, (toSet-SET_FORCE_HEAL_LEVEL), int_data );
+		break;
+	
+	default:
+		//G_DebugPrint( WL_ERROR, "Q3_Set: '%s' is not a valid set field\n", type_name );
+		trap_ICARUS_SetVar( taskID, entID, type_name, data );
+		break;
+	}
+
+	return qtrue;
+}
diff --git a/codemp/game/g_ICARUScb.h b/codemp/game/g_ICARUScb.h
new file mode 100644
index 0000000..acaa246
--- /dev/null
+++ b/codemp/game/g_ICARUScb.h
@@ -0,0 +1,15 @@
+int Q3_PlaySound( int taskID, int entID, const char *name, const char *channel );
+qboolean Q3_Set( int taskID, int entID, const char *type_name, const char *data );
+void Q3_Lerp2Pos( int taskID, int entID, vec3_t origin, vec3_t angles, float duration );
+void Q3_Lerp2Origin( int taskID, int entID, vec3_t origin, float duration );
+void Q3_Lerp2Angles( int taskID, int entID, vec3_t angles, float duration );
+int Q3_GetTag( int entID, const char *name, int lookup, vec3_t info );
+void Q3_Lerp2Start( int entID, int taskID, float duration );
+void Q3_Lerp2End( int entID, int taskID, float duration );
+void Q3_Use( int entID, const char *target );
+void Q3_Kill( int entID, const char *name );
+void Q3_Remove( int entID, const char *name );
+void Q3_Play( int taskID, int entID, const char *type, const char *name );
+int Q3_GetFloat( int entID, int type, const char *name, float *value );
+int Q3_GetVector( int entID, int type, const char *name, vec3_t value );
+int Q3_GetString( int entID, int type, const char *name, char **value );
diff --git a/codemp/game/g_active.c b/codemp/game/g_active.c
new file mode 100644
index 0000000..22e2c58
--- /dev/null
+++ b/codemp/game/g_active.c
@@ -0,0 +1,3765 @@
+// Copyright (C) 1999-2000 Id Software, Inc.
+//
+
+#include "g_local.h"
+#include "bg_saga.h"
+
+extern void Jedi_Cloak( gentity_t *self );
+extern void Jedi_Decloak( gentity_t *self );
+
+#include "../namespace_begin.h"
+qboolean PM_SaberInTransition( int move );
+qboolean PM_SaberInStart( int move );
+qboolean PM_SaberInReturn( int move );
+#include "../namespace_end.h"
+qboolean saberCheckKnockdown_DuelLoss(gentity_t *saberent, gentity_t *saberOwner, gentity_t *other);
+
+extern vmCvar_t g_saberLockRandomNess;
+
+void P_SetTwitchInfo(gclient_t	*client)
+{
+	client->ps.painTime = level.time;
+	client->ps.painDirection ^= 1;
+}
+
+/*
+===============
+G_DamageFeedback
+
+Called just before a snapshot is sent to the given player.
+Totals up all damage and generates both the player_state_t
+damage values to that client for pain blends and kicks, and
+global pain sound events for all clients.
+===============
+*/
+void P_DamageFeedback( gentity_t *player ) {
+	gclient_t	*client;
+	float	count;
+	vec3_t	angles;
+
+	client = player->client;
+	if ( client->ps.pm_type == PM_DEAD ) {
+		return;
+	}
+
+	// total points of damage shot at the player this frame
+	count = client->damage_blood + client->damage_armor;
+	if ( count == 0 ) {
+		return;		// didn't take any damage
+	}
+
+	if ( count > 255 ) {
+		count = 255;
+	}
+
+	// send the information to the client
+
+	// world damage (falling, slime, etc) uses a special code
+	// to make the blend blob centered instead of positional
+	if ( client->damage_fromWorld ) {
+		client->ps.damagePitch = 255;
+		client->ps.damageYaw = 255;
+
+		client->damage_fromWorld = qfalse;
+	} else {
+		vectoangles( client->damage_from, angles );
+		client->ps.damagePitch = angles[PITCH]/360.0 * 256;
+		client->ps.damageYaw = angles[YAW]/360.0 * 256;
+
+		//cap them since we can't send negative values in here across the net
+		if (client->ps.damagePitch < 0)
+		{
+			client->ps.damagePitch = 0;
+		}
+		if (client->ps.damageYaw < 0)
+		{
+			client->ps.damageYaw = 0;
+		}
+	}
+
+	// play an apropriate pain sound
+	if ( (level.time > player->pain_debounce_time) && !(player->flags & FL_GODMODE) && !(player->s.eFlags & EF_DEAD) ) {
+
+		// don't do more than two pain sounds a second
+		// nmckenzie: also don't make him loud and whiny if he's only getting nicked.
+		if ( level.time - client->ps.painTime < 500 || count < 10) {
+			return;
+		}
+		P_SetTwitchInfo(client);
+		player->pain_debounce_time = level.time + 700;
+		
+		G_AddEvent( player, EV_PAIN, player->health );
+		client->ps.damageEvent++;
+
+		if (client->damage_armor && !client->damage_blood)
+		{
+			client->ps.damageType = 1; //pure shields
+		}
+		else if (client->damage_armor)
+		{
+			client->ps.damageType = 2; //shields and health
+		}
+		else
+		{
+			client->ps.damageType = 0; //pure health
+		}
+	}
+
+
+	client->ps.damageCount = count;
+
+	//
+	// clear totals
+	//
+	client->damage_blood = 0;
+	client->damage_armor = 0;
+	client->damage_knockback = 0;
+}
+
+
+
+/*
+=============
+P_WorldEffects
+
+Check for lava / slime contents and drowning
+=============
+*/
+void P_WorldEffects( gentity_t *ent ) {
+	qboolean	envirosuit;
+	int			waterlevel;
+
+	if ( ent->client->noclip ) {
+		ent->client->airOutTime = level.time + 12000;	// don't need air
+		return;
+	}
+
+	waterlevel = ent->waterlevel;
+
+	envirosuit = ent->client->ps.powerups[PW_BATTLESUIT] > level.time;
+
+	//
+	// check for drowning
+	//
+	if ( waterlevel == 3 ) {
+		// envirosuit give air
+		if ( envirosuit ) {
+			ent->client->airOutTime = level.time + 10000;
+		}
+
+		// if out of air, start drowning
+		if ( ent->client->airOutTime < level.time) {
+			// drown!
+			ent->client->airOutTime += 1000;
+			if ( ent->health > 0 ) {
+				// take more damage the longer underwater
+				ent->damage += 2;
+				if (ent->damage > 15)
+					ent->damage = 15;
+
+				// play a gurp sound instead of a normal pain sound
+				if (ent->health <= ent->damage) {
+					G_Sound(ent, CHAN_VOICE, G_SoundIndex(/*"*drown.wav"*/"sound/player/gurp1.wav"));
+				} else if (rand()&1) {
+					G_Sound(ent, CHAN_VOICE, G_SoundIndex("sound/player/gurp1.wav"));
+				} else {
+					G_Sound(ent, CHAN_VOICE, G_SoundIndex("sound/player/gurp2.wav"));
+				}
+
+				// don't play a normal pain sound
+				ent->pain_debounce_time = level.time + 200;
+
+				G_Damage (ent, NULL, NULL, NULL, NULL, 
+					ent->damage, DAMAGE_NO_ARMOR, MOD_WATER);
+			}
+		}
+	} else {
+		ent->client->airOutTime = level.time + 12000;
+		ent->damage = 2;
+	}
+
+	//
+	// check for sizzle damage (move to pmove?)
+	//
+	if (waterlevel && 
+		(ent->watertype&(CONTENTS_LAVA|CONTENTS_SLIME)) ) {
+		if (ent->health > 0
+			&& ent->pain_debounce_time <= level.time	) {
+
+			if ( envirosuit ) {
+				G_AddEvent( ent, EV_POWERUP_BATTLESUIT, 0 );
+			} else {
+				if (ent->watertype & CONTENTS_LAVA) {
+					G_Damage (ent, NULL, NULL, NULL, NULL, 
+						30*waterlevel, 0, MOD_LAVA);
+				}
+
+				if (ent->watertype & CONTENTS_SLIME) {
+					G_Damage (ent, NULL, NULL, NULL, NULL, 
+						10*waterlevel, 0, MOD_SLIME);
+				}
+			}
+		}
+	}
+}
+
+
+
+
+
+//==============================================================
+extern void G_ApplyKnockback( gentity_t *targ, vec3_t newDir, float knockback );
+void DoImpact( gentity_t *self, gentity_t *other, qboolean damageSelf )
+{
+	float magnitude, my_mass;
+	vec3_t	velocity;
+	int cont;
+	qboolean easyBreakBrush = qtrue;
+
+	if( self->client )
+	{
+		VectorCopy( self->client->ps.velocity, velocity );
+		if( !self->mass )
+		{
+			my_mass = 10;
+		}
+		else
+		{
+			my_mass = self->mass;
+		}
+	}
+	else 
+	{
+		VectorCopy( self->s.pos.trDelta, velocity );
+		if ( self->s.pos.trType == TR_GRAVITY )
+		{
+			velocity[2] -= 0.25f * g_gravity.value;
+		}
+		if( !self->mass )
+		{
+			my_mass = 1;
+		}
+		else if ( self->mass <= 10 )
+		{
+			my_mass = 10;
+		}
+		else
+		{
+			my_mass = self->mass;///10;
+		}
+	}
+
+	magnitude = VectorLength( velocity ) * my_mass / 10;
+
+	/*
+	if(pointcontents(self.absmax)==CONTENT_WATER)//FIXME: or other watertypes
+		magnitude/=3;							//water absorbs 2/3 velocity
+
+	if(self.classname=="barrel"&&self.aflag)//rolling barrels are made for impacts!
+		magnitude*=3;
+
+	if(self.frozen>0&&magnitude<300&&self.flags&FL_ONGROUND&&loser==world&&self.velocity_z<-20&&self.last_onground+0.3<time)
+		magnitude=300;
+	*/
+	if ( other->material == MAT_GLASS 
+		|| other->material == MAT_GLASS_METAL 
+		|| other->material == MAT_GRATE1
+		|| ((other->flags&FL_BBRUSH)&&(other->spawnflags&8/*THIN*/))
+		|| (other->r.svFlags&SVF_GLASS_BRUSH) )
+	{
+		easyBreakBrush = qtrue;
+	}
+
+	if ( !self->client || self->client->ps.lastOnGround+300<level.time || ( self->client->ps.lastOnGround+100 < level.time && easyBreakBrush ) )
+	{
+		vec3_t dir1, dir2;
+		float force = 0, dot;
+
+		if ( easyBreakBrush )
+			magnitude *= 2;
+
+		//damage them
+		if ( magnitude >= 100 && other->s.number < ENTITYNUM_WORLD )
+		{
+			VectorCopy( velocity, dir1 );
+			VectorNormalize( dir1 );
+			if( VectorCompare( other->r.currentOrigin, vec3_origin ) )
+			{//a brush with no origin
+				VectorCopy ( dir1, dir2 );
+			}
+			else
+			{
+				VectorSubtract( other->r.currentOrigin, self->r.currentOrigin, dir2 );
+				VectorNormalize( dir2 );
+			}
+
+			dot = DotProduct( dir1, dir2 );
+
+			if ( dot >= 0.2 )
+			{
+				force = dot;
+			}
+			else
+			{
+				force = 0;
+			}
+
+			force *= (magnitude/50);
+
+			cont = trap_PointContents( other->r.absmax, other->s.number );
+			if( (cont&CONTENTS_WATER) )//|| (self.classname=="barrel"&&self.aflag))//FIXME: or other watertypes
+			{
+				force /= 3;							//water absorbs 2/3 velocity
+			}
+
+			/*
+			if(self.frozen>0&&force>10)
+				force=10;
+			*/
+
+			if( ( force >= 1 && other->s.number != 0 ) || force >= 10)
+			{
+	/*			
+				dprint("Damage other (");
+				dprint(loser.classname);
+				dprint("): ");
+				dprint(ftos(force));
+				dprint("\n");
+	*/
+				if ( other->r.svFlags & SVF_GLASS_BRUSH )
+				{
+					other->splashRadius = (float)(self->r.maxs[0] - self->r.mins[0])/4.0f;
+				}
+				if ( other->takedamage )
+				{
+					G_Damage( other, self, self, velocity, self->r.currentOrigin, force, DAMAGE_NO_ARMOR, MOD_CRUSH);//FIXME: MOD_IMPACT
+				}
+				else
+				{
+					G_ApplyKnockback( other, dir2, force );
+				}
+			}
+		}
+
+		if ( damageSelf && self->takedamage )
+		{
+			//Now damage me
+			//FIXME: more lenient falling damage, especially for when driving a vehicle
+			if ( self->client && self->client->ps.fd.forceJumpZStart )
+			{//we were force-jumping
+				if ( self->r.currentOrigin[2] >= self->client->ps.fd.forceJumpZStart )
+				{//we landed at same height or higher than we landed
+					magnitude = 0;
+				}
+				else
+				{//FIXME: take off some of it, at least?
+					magnitude = (self->client->ps.fd.forceJumpZStart-self->r.currentOrigin[2])/3;
+				}
+			}
+			//if(self.classname!="monster_mezzoman"&&self.netname!="spider")//Cats always land on their feet
+				if( ( magnitude >= 100 + self->health && self->s.number != 0 && self->s.weapon != WP_SABER ) || ( magnitude >= 700 ) )//&& self.safe_time < level.time ))//health here is used to simulate structural integrity
+				{
+					if ( (self->s.weapon == WP_SABER || self->s.number == 0) && self->client && self->client->ps.groundEntityNum < ENTITYNUM_NONE && magnitude < 1000 )
+					{//players and jedi take less impact damage
+						//allow for some lenience on high falls
+						magnitude /= 2;
+						/*
+						if ( self.absorb_time >= time )//crouching on impact absorbs 1/2 the damage
+						{
+							magnitude/=2;
+						}
+						*/
+					}
+					magnitude /= 40;
+					magnitude = magnitude - force/2;//If damage other, subtract half of that damage off of own injury
+					if ( magnitude >= 1 )
+					{
+		//FIXME: Put in a thingtype impact sound function
+		/*					
+						dprint("Damage self (");
+						dprint(self.classname);
+						dprint("): ");
+						dprint(ftos(magnitude));
+						dprint("\n");
+		*/
+						/*
+						if ( self.classname=="player_sheep "&& self.flags&FL_ONGROUND && self.velocity_z > -50 )
+							return;
+						*/
+						G_Damage( self, NULL, NULL, NULL, self->r.currentOrigin, magnitude/2, DAMAGE_NO_ARMOR, MOD_FALLING );//FIXME: MOD_IMPACT
+					}
+				}
+		}
+
+		//FIXME: slow my velocity some?
+
+		// NOTENOTE We don't use lastimpact as of yet
+//		self->lastImpact = level.time;
+
+		/*
+		if(self.flags&FL_ONGROUND)
+			self.last_onground=time;
+		*/
+	}
+}
+
+void Client_CheckImpactBBrush( gentity_t *self, gentity_t *other )
+{
+	if ( !other || !other->inuse )
+	{
+		return;
+	}
+	if (!self || !self->inuse || !self->client ||
+		self->client->tempSpectate >= level.time ||
+		self->client->sess.sessionTeam == TEAM_SPECTATOR)
+	{ //hmm.. let's not let spectators ram into breakables.
+		return;
+	}
+
+	/*
+	if (BG_InSpecialJump(self->client->ps.legsAnim))
+	{ //don't do this either, qa says it creates "balance issues"
+		return;
+	}
+	*/
+
+	if ( other->material == MAT_GLASS 
+		|| other->material == MAT_GLASS_METAL 
+		|| other->material == MAT_GRATE1
+		|| ((other->flags&FL_BBRUSH)&&(other->spawnflags&8/*THIN*/))
+		|| ((other->flags&FL_BBRUSH)&&(other->health<=10))
+		|| (other->r.svFlags&SVF_GLASS_BRUSH) )
+	{//clients only do impact damage against easy-break breakables
+		DoImpact( self, other, qfalse );
+	}
+}
+
+
+/*
+===============
+G_SetClientSound
+===============
+*/
+void G_SetClientSound( gentity_t *ent ) {
+	if (ent->client && ent->client->isHacking)
+	{ //loop hacking sound
+		ent->client->ps.loopSound = level.snd_hack;
+		ent->s.loopIsSoundset = qfalse;
+	}
+	else if (ent->client && ent->client->isMedHealed > level.time)
+	{ //loop healing sound
+		ent->client->ps.loopSound = level.snd_medHealed;
+		ent->s.loopIsSoundset = qfalse;
+	}
+	else if (ent->client && ent->client->isMedSupplied > level.time)
+	{ //loop supplying sound
+		ent->client->ps.loopSound = level.snd_medSupplied;
+		ent->s.loopIsSoundset = qfalse;
+	}
+	else if (ent->waterlevel && (ent->watertype&(CONTENTS_LAVA|CONTENTS_SLIME)) ) {
+		ent->client->ps.loopSound = level.snd_fry;
+		ent->s.loopIsSoundset = qfalse;
+	} else {
+		ent->client->ps.loopSound = 0;
+		ent->s.loopIsSoundset = qfalse;
+	}
+}
+
+
+
+//==============================================================
+
+/*
+==============
+ClientImpacts
+==============
+*/
+void ClientImpacts( gentity_t *ent, pmove_t *pm ) {
+	int		i, j;
+	trace_t	trace;
+	gentity_t	*other;
+
+	memset( &trace, 0, sizeof( trace ) );
+	for (i=0 ; i<pm->numtouch ; i++) {
+		for (j=0 ; j<i ; j++) {
+			if (pm->touchents[j] == pm->touchents[i] ) {
+				break;
+			}
+		}
+		if (j != i) {
+			continue;	// duplicated
+		}
+		other = &g_entities[ pm->touchents[i] ];
+
+		if ( ( ent->r.svFlags & SVF_BOT ) && ( ent->touch ) ) {
+			ent->touch( ent, other, &trace );
+		}
+
+		if ( !other->touch ) {
+			continue;
+		}
+
+		other->touch( other, ent, &trace );
+	}
+
+}
+
+/*
+============
+G_TouchTriggers
+
+Find all trigger entities that ent's current position touches.
+Spectators will only interact with teleporters.
+============
+*/
+void	G_TouchTriggers( gentity_t *ent ) {
+	int			i, num;
+	int			touch[MAX_GENTITIES];
+	gentity_t	*hit;
+	trace_t		trace;
+	vec3_t		mins, maxs;
+	static vec3_t	range = { 40, 40, 52 };
+
+	if ( !ent->client ) {
+		return;
+	}
+
+	// dead clients don't activate triggers!
+	if ( ent->client->ps.stats[STAT_HEALTH] <= 0 ) {
+		return;
+	}
+
+	VectorSubtract( ent->client->ps.origin, range, mins );
+	VectorAdd( ent->client->ps.origin, range, maxs );
+
+	num = trap_EntitiesInBox( mins, maxs, touch, MAX_GENTITIES );
+
+	// can't use ent->r.absmin, because that has a one unit pad
+	VectorAdd( ent->client->ps.origin, ent->r.mins, mins );
+	VectorAdd( ent->client->ps.origin, ent->r.maxs, maxs );
+
+	for ( i=0 ; i<num ; i++ ) {
+		hit = &g_entities[touch[i]];
+
+		if ( !hit->touch && !ent->touch ) {
+			continue;
+		}
+		if ( !( hit->r.contents & CONTENTS_TRIGGER ) ) {
+			continue;
+		}
+
+		// ignore most entities if a spectator
+		if ( ent->client->sess.sessionTeam == TEAM_SPECTATOR ) {
+			if ( hit->s.eType != ET_TELEPORT_TRIGGER &&
+				// this is ugly but adding a new ET_? type will
+				// most likely cause network incompatibilities
+				hit->touch != Touch_DoorTrigger) {
+				continue;
+			}
+		}
+
+		// use seperate code for determining if an item is picked up
+		// so you don't have to actually contact its bounding box
+		if ( hit->s.eType == ET_ITEM ) {
+			if ( !BG_PlayerTouchesItem( &ent->client->ps, &hit->s, level.time ) ) {
+				continue;
+			}
+		} else {
+			if ( !trap_EntityContact( mins, maxs, hit ) ) {
+				continue;
+			}
+		}
+
+		memset( &trace, 0, sizeof(trace) );
+
+		if ( hit->touch ) {
+			hit->touch (hit, ent, &trace);
+		}
+
+		if ( ( ent->r.svFlags & SVF_BOT ) && ( ent->touch ) ) {
+			ent->touch( ent, hit, &trace );
+		}
+	}
+
+	// if we didn't touch a jump pad this pmove frame
+	if ( ent->client->ps.jumppad_frame != ent->client->ps.pmove_framecount ) {
+		ent->client->ps.jumppad_frame = 0;
+		ent->client->ps.jumppad_ent = 0;
+	}
+}
+
+
+/*
+============
+G_MoverTouchTriggers
+
+Find all trigger entities that ent's current position touches.
+Spectators will only interact with teleporters.
+============
+*/
+void G_MoverTouchPushTriggers( gentity_t *ent, vec3_t oldOrg ) 
+{
+	int			i, num;
+	float		step, stepSize, dist;
+	int			touch[MAX_GENTITIES];
+	gentity_t	*hit;
+	trace_t		trace;
+	vec3_t		mins, maxs, dir, size, checkSpot;
+	const vec3_t	range = { 40, 40, 52 };
+
+	// non-moving movers don't hit triggers!
+	if ( !VectorLengthSquared( ent->s.pos.trDelta ) ) 
+	{
+		return;
+	}
+
+	VectorSubtract( ent->r.mins, ent->r.maxs, size );
+	stepSize = VectorLength( size );
+	if ( stepSize < 1 )
+	{
+		stepSize = 1;
+	}
+
+	VectorSubtract( ent->r.currentOrigin, oldOrg, dir );
+	dist = VectorNormalize( dir );
+	for ( step = 0; step <= dist; step += stepSize )
+	{
+		VectorMA( ent->r.currentOrigin, step, dir, checkSpot );
+		VectorSubtract( checkSpot, range, mins );
+		VectorAdd( checkSpot, range, maxs );
+
+		num = trap_EntitiesInBox( mins, maxs, touch, MAX_GENTITIES );
+
+		// can't use ent->r.absmin, because that has a one unit pad
+		VectorAdd( checkSpot, ent->r.mins, mins );
+		VectorAdd( checkSpot, ent->r.maxs, maxs );
+
+		for ( i=0 ; i<num ; i++ ) 
+		{
+			hit = &g_entities[touch[i]];
+
+			if ( hit->s.eType != ET_PUSH_TRIGGER )
+			{
+				continue;
+			}
+
+			if ( hit->touch == NULL ) 
+			{
+				continue;
+			}
+
+			if ( !( hit->r.contents & CONTENTS_TRIGGER ) ) 
+			{
+				continue;
+			}
+
+
+			if ( !trap_EntityContact( mins, maxs, hit ) ) 
+			{
+				continue;
+			}
+
+			memset( &trace, 0, sizeof(trace) );
+
+			if ( hit->touch != NULL ) 
+			{
+				hit->touch(hit, ent, &trace);
+			}
+		}
+	}
+}
+
+/*
+=================
+SpectatorThink
+=================
+*/
+void SpectatorThink( gentity_t *ent, usercmd_t *ucmd ) {
+	pmove_t	pm;
+	gclient_t	*client;
+
+	client = ent->client;
+
+	if ( client->sess.spectatorState != SPECTATOR_FOLLOW ) {
+		client->ps.pm_type = PM_SPECTATOR;
+		client->ps.speed = 400;	// faster than normal
+		client->ps.basespeed = 400;
+
+		//hmm, shouldn't have an anim if you're a spectator, make sure
+		//it gets cleared.
+		client->ps.legsAnim = 0;
+		client->ps.legsTimer = 0;
+		client->ps.torsoAnim = 0;
+		client->ps.torsoTimer = 0;
+
+		// set up for pmove
+		memset (&pm, 0, sizeof(pm));
+		pm.ps = &client->ps;
+		pm.cmd = *ucmd;
+		pm.tracemask = MASK_PLAYERSOLID & ~CONTENTS_BODY;	// spectators can fly through bodies
+		pm.trace = trap_Trace;
+		pm.pointcontents = trap_PointContents;
+
+		pm.noSpecMove = g_noSpecMove.integer;
+
+		pm.animations = NULL;
+		pm.nonHumanoid = qfalse;
+
+		//Set up bg entity data
+		pm.baseEnt = (bgEntity_t *)g_entities;
+		pm.entSize = sizeof(gentity_t);
+
+		// perform a pmove
+		Pmove (&pm);
+		// save results of pmove
+		VectorCopy( client->ps.origin, ent->s.origin );
+
+		if (ent->client->tempSpectate < level.time)
+		{
+			G_TouchTriggers( ent );
+		}
+		trap_UnlinkEntity( ent );
+	}
+
+	client->oldbuttons = client->buttons;
+	client->buttons = ucmd->buttons;
+
+	if (client->tempSpectate < level.time)
+	{
+		// attack button cycles through spectators
+		if ( ( client->buttons & BUTTON_ATTACK ) && ! ( client->oldbuttons & BUTTON_ATTACK ) ) {
+			Cmd_FollowCycle_f( ent, 1 );
+		}
+
+		if (client->sess.spectatorState == SPECTATOR_FOLLOW && (ucmd->upmove > 0))
+		{ //jump now removes you from follow mode
+			StopFollowing(ent);
+		}
+	}
+}
+
+
+
+/*
+=================
+ClientInactivityTimer
+
+Returns qfalse if the client is dropped
+=================
+*/
+qboolean ClientInactivityTimer( gclient_t *client ) {
+	if ( ! g_inactivity.integer ) {
+		// give everyone some time, so if the operator sets g_inactivity during
+		// gameplay, everyone isn't kicked
+		client->inactivityTime = level.time + 60 * 1000;
+		client->inactivityWarning = qfalse;
+	} else if ( client->pers.cmd.forwardmove || 
+		client->pers.cmd.rightmove || 
+		client->pers.cmd.upmove ||
+		(client->pers.cmd.buttons & (BUTTON_ATTACK|BUTTON_ALT_ATTACK)) ) {
+		client->inactivityTime = level.time + g_inactivity.integer * 1000;
+		client->inactivityWarning = qfalse;
+	} else if ( !client->pers.localClient ) {
+		if ( level.time > client->inactivityTime ) {
+			trap_DropClient( client - level.clients, "Dropped due to inactivity" );
+			return qfalse;
+		}
+		if ( level.time > client->inactivityTime - 10000 && !client->inactivityWarning ) {
+			client->inactivityWarning = qtrue;
+			trap_SendServerCommand( client - level.clients, "cp \"Ten seconds until inactivity drop!\n\"" );
+		}
+	}
+	return qtrue;
+}
+
+/*
+==================
+ClientTimerActions
+
+Actions that happen once a second
+==================
+*/
+void ClientTimerActions( gentity_t *ent, int msec ) {
+	gclient_t	*client;
+
+	client = ent->client;
+	client->timeResidual += msec;
+
+	while ( client->timeResidual >= 1000 ) 
+	{
+		client->timeResidual -= 1000;
+
+		// count down health when over max
+		if ( ent->health > client->ps.stats[STAT_MAX_HEALTH] ) {
+			ent->health--;
+		}
+
+		// count down armor when over max
+		if ( client->ps.stats[STAT_ARMOR] > client->ps.stats[STAT_MAX_HEALTH] ) {
+			client->ps.stats[STAT_ARMOR]--;
+		}
+	}
+}
+
+/*
+====================
+ClientIntermissionThink
+====================
+*/
+void ClientIntermissionThink( gclient_t *client ) {
+	client->ps.eFlags &= ~EF_TALK;
+	client->ps.eFlags &= ~EF_FIRING;
+
+	// the level will exit when everyone wants to or after timeouts
+
+	// swap and latch button actions
+	client->oldbuttons = client->buttons;
+	client->buttons = client->pers.cmd.buttons;
+	if ( client->buttons & ( BUTTON_ATTACK | BUTTON_USE_HOLDABLE ) & ( client->oldbuttons ^ client->buttons ) ) {
+		// this used to be an ^1 but once a player says ready, it should stick
+		client->readyToExit = 1;
+	}
+}
+
+extern void NPC_SetAnim(gentity_t	*ent,int setAnimParts,int anim,int setAnimFlags);
+void G_VehicleAttachDroidUnit( gentity_t *vehEnt )
+{
+	if ( vehEnt && vehEnt->m_pVehicle && vehEnt->m_pVehicle->m_pDroidUnit != NULL )
+	{
+		gentity_t *droidEnt = (gentity_t *)vehEnt->m_pVehicle->m_pDroidUnit;
+		mdxaBone_t boltMatrix;
+		vec3_t	fwd;
+
+		trap_G2API_GetBoltMatrix(vehEnt->ghoul2, 0, vehEnt->m_pVehicle->m_iDroidUnitTag, &boltMatrix, vehEnt->r.currentAngles, vehEnt->r.currentOrigin, level.time,
+			NULL, vehEnt->modelScale);
+		BG_GiveMeVectorFromMatrix(&boltMatrix, ORIGIN, droidEnt->r.currentOrigin);
+		BG_GiveMeVectorFromMatrix(&boltMatrix, NEGATIVE_Y, fwd);
+		vectoangles( fwd, droidEnt->r.currentAngles );
+		
+		if ( droidEnt->client )
+		{
+			VectorCopy( droidEnt->r.currentAngles, droidEnt->client->ps.viewangles );
+			VectorCopy( droidEnt->r.currentOrigin, droidEnt->client->ps.origin );
+		}
+
+		G_SetOrigin( droidEnt, droidEnt->r.currentOrigin );
+		trap_LinkEntity( droidEnt );
+		
+		if ( droidEnt->NPC )
+		{
+			NPC_SetAnim( droidEnt, SETANIM_BOTH, BOTH_STAND2, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+		}
+	}
+}
+
+//called gameside only from pmove code (convenience)
+void G_CheapWeaponFire(int entNum, int ev)
+{
+	gentity_t *ent = &g_entities[entNum];
+	
+	if (!ent->inuse || !ent->client)
+	{
+		return;
+	}
+
+	switch (ev)
+	{
+		case EV_FIRE_WEAPON:
+			if (ent->m_pVehicle && ent->m_pVehicle->m_pVehicleInfo->type == VH_SPEEDER &&
+				ent->client && ent->client->ps.m_iVehicleNum)
+			{ //a speeder with a pilot
+				gentity_t *rider = &g_entities[ent->client->ps.m_iVehicleNum-1];
+				if (rider->inuse && rider->client)
+				{ //pilot is valid...
+                    if (rider->client->ps.weapon != WP_MELEE &&
+						(rider->client->ps.weapon != WP_SABER || !rider->client->ps.saberHolstered))
+					{ //can only attack on speeder when using melee or when saber is holstered
+						break;
+					}
+				}
+			}
+
+			FireWeapon( ent, qfalse );
+			ent->client->dangerTime = level.time;
+			ent->client->ps.eFlags &= ~EF_INVULNERABLE;
+			ent->client->invulnerableTimer = 0;
+			break;
+		case EV_ALT_FIRE:
+			FireWeapon( ent, qtrue );
+			ent->client->dangerTime = level.time;
+			ent->client->ps.eFlags &= ~EF_INVULNERABLE;
+			ent->client->invulnerableTimer = 0;
+			break;
+	}
+}
+
+/*
+================
+ClientEvents
+
+Events will be passed on to the clients for presentation,
+but any server game effects are handled here
+================
+*/
+#include "../namespace_begin.h"
+qboolean BG_InKnockDownOnly( int anim );
+#include "../namespace_end.h"
+
+void ClientEvents( gentity_t *ent, int oldEventSequence ) {
+	int		i;//, j;
+	int		event;
+	gclient_t *client;
+	int		damage;
+	vec3_t	dir;
+//	vec3_t	origin, angles;
+//	qboolean	fired;
+//	gitem_t *item;
+//	gentity_t *drop;
+
+	client = ent->client;
+
+	if ( oldEventSequence < client->ps.eventSequence - MAX_PS_EVENTS ) {
+		oldEventSequence = client->ps.eventSequence - MAX_PS_EVENTS;
+	}
+	for ( i = oldEventSequence ; i < client->ps.eventSequence ; i++ ) {
+		event = client->ps.events[ i & (MAX_PS_EVENTS-1) ];
+
+		switch ( event ) {
+		case EV_FALL:
+		case EV_ROLL:
+			{
+				int delta = client->ps.eventParms[ i & (MAX_PS_EVENTS-1) ];
+				qboolean knockDownage = qfalse;
+
+				if (ent->client && ent->client->ps.fallingToDeath)
+				{
+					break;
+				}
+
+				if ( ent->s.eType != ET_PLAYER )
+				{
+					break;		// not in the player model
+				}
+				
+				if ( g_dmflags.integer & DF_NO_FALLING )
+				{
+					break;
+				}
+
+				if (BG_InKnockDownOnly(ent->client->ps.legsAnim))
+				{
+					if (delta <= 14)
+					{
+						break;
+					}
+					knockDownage = qtrue;
+				}
+				else
+				{
+					if (delta <= 44)
+					{
+						break;
+					}
+				}
+
+				if (knockDownage)
+				{
+					damage = delta*1; //you suffer for falling unprepared. A lot. Makes throws and things useful, and more realistic I suppose.
+				}
+				else
+				{
+					if (g_gametype.integer == GT_SIEGE &&
+						delta > 60)
+					{ //longer falls hurt more
+						damage = delta*1; //good enough for now, I guess
+					}
+					else
+					{
+						damage = delta*0.16; //good enough for now, I guess
+					}
+				}
+
+				VectorSet (dir, 0, 0, 1);
+				ent->pain_debounce_time = level.time + 200;	// no normal pain sound
+				G_Damage (ent, NULL, NULL, NULL, NULL, damage, DAMAGE_NO_ARMOR, MOD_FALLING);
+
+				if (ent->health < 1)
+				{
+					G_Sound(ent, CHAN_AUTO, G_SoundIndex( "sound/player/fallsplat.wav" ));
+				}
+			}
+			break;
+		case EV_FIRE_WEAPON:
+			FireWeapon( ent, qfalse );
+			ent->client->dangerTime = level.time;
+			ent->client->ps.eFlags &= ~EF_INVULNERABLE;
+			ent->client->invulnerableTimer = 0;
+			break;
+
+		case EV_ALT_FIRE:
+			FireWeapon( ent, qtrue );
+			ent->client->dangerTime = level.time;
+			ent->client->ps.eFlags &= ~EF_INVULNERABLE;
+			ent->client->invulnerableTimer = 0;
+			break;
+
+		case EV_SABER_ATTACK:
+			ent->client->dangerTime = level.time;
+			ent->client->ps.eFlags &= ~EF_INVULNERABLE;
+			ent->client->invulnerableTimer = 0;
+			break;
+
+		//rww - Note that these must be in the same order (ITEM#-wise) as they are in holdable_t
+		case EV_USE_ITEM1: //seeker droid
+			ItemUse_Seeker(ent);
+			break;
+		case EV_USE_ITEM2: //shield
+			ItemUse_Shield(ent);
+			break;
+		case EV_USE_ITEM3: //medpack
+			ItemUse_MedPack(ent);
+			break;
+		case EV_USE_ITEM4: //big medpack
+			ItemUse_MedPack_Big(ent);
+			break;
+		case EV_USE_ITEM5: //binoculars
+			ItemUse_Binoculars(ent);
+			break;
+		case EV_USE_ITEM6: //sentry gun
+			ItemUse_Sentry(ent);
+			break;
+		case EV_USE_ITEM7: //jetpack
+			ItemUse_Jetpack(ent);
+			break;
+		case EV_USE_ITEM8: //health disp
+			//ItemUse_UseDisp(ent, HI_HEALTHDISP);
+			break;
+		case EV_USE_ITEM9: //ammo disp
+			//ItemUse_UseDisp(ent, HI_AMMODISP);
+			break;
+		case EV_USE_ITEM10: //eweb
+			ItemUse_UseEWeb(ent);
+			break;
+		case EV_USE_ITEM11: //cloak
+			ItemUse_UseCloak(ent);
+			break;
+		default:
+			break;
+		}
+	}
+
+}
+
+/*
+==============
+SendPendingPredictableEvents
+==============
+*/
+void SendPendingPredictableEvents( playerState_t *ps ) {
+	gentity_t *t;
+	int event, seq;
+	int extEvent, number;
+
+	// if there are still events pending
+	if ( ps->entityEventSequence < ps->eventSequence ) {
+		// create a temporary entity for this event which is sent to everyone
+		// except the client who generated the event
+		seq = ps->entityEventSequence & (MAX_PS_EVENTS-1);
+		event = ps->events[ seq ] | ( ( ps->entityEventSequence & 3 ) << 8 );
+		// set external event to zero before calling BG_PlayerStateToEntityState
+		extEvent = ps->externalEvent;
+		ps->externalEvent = 0;
+		// create temporary entity for event
+		t = G_TempEntity( ps->origin, event );
+		number = t->s.number;
+		BG_PlayerStateToEntityState( ps, &t->s, qtrue );
+		t->s.number = number;
+		t->s.eType = ET_EVENTS + event;
+		t->s.eFlags |= EF_PLAYER_EVENT;
+		t->s.otherEntityNum = ps->clientNum;
+		// send to everyone except the client who generated the event
+		t->r.svFlags |= SVF_NOTSINGLECLIENT;
+		t->r.singleClient = ps->clientNum;
+		// set back external event
+		ps->externalEvent = extEvent;
+	}
+}
+
+/*
+==================
+G_UpdateClientBroadcasts
+
+Determines whether this client should be broadcast to any other clients.  
+A client is broadcast when another client is using force sight or is
+==================
+*/
+#define MAX_JEDIMASTER_DISTANCE	2500
+#define MAX_JEDIMASTER_FOV		100
+
+#define MAX_SIGHT_DISTANCE		1500
+#define MAX_SIGHT_FOV			100
+
+static void G_UpdateForceSightBroadcasts ( gentity_t *self )
+{
+	int i;
+
+	// Any clients with force sight on should see this client
+	for ( i = 0; i < level.numConnectedClients; i ++ )
+	{
+		gentity_t *ent = &g_entities[level.sortedClients[i]];
+		float	  dist;
+		vec3_t	  angles;
+	
+		if ( ent == self )
+		{
+			continue;
+		}
+
+		// Not using force sight so we shouldnt broadcast to this one
+		if ( !(ent->client->ps.fd.forcePowersActive & (1<<FP_SEE) ) )
+		{
+			continue;
+		}
+
+		VectorSubtract( self->client->ps.origin, ent->client->ps.origin, angles );
+		dist = VectorLengthSquared ( angles );
+		vectoangles ( angles, angles );
+
+		// Too far away then just forget it
+		if ( dist > MAX_SIGHT_DISTANCE * MAX_SIGHT_DISTANCE )
+		{
+			continue;
+		}
+		
+		// If not within the field of view then forget it
+		if ( !InFieldOfVision ( ent->client->ps.viewangles, MAX_SIGHT_FOV, angles ) )
+		{
+			break;
+		}
+
+		// Turn on the broadcast bit for the master and since there is only one
+		// master we are done
+		self->r.broadcastClients[ent->s.clientNum/32] |= (1 << (ent->s.clientNum%32));
+	
+		break;
+	}
+}
+
+static void G_UpdateJediMasterBroadcasts ( gentity_t *self )
+{
+	int i;
+
+	// Not jedi master mode then nothing to do
+	if ( g_gametype.integer != GT_JEDIMASTER )
+	{
+		return;
+	}
+
+	// This client isnt the jedi master so it shouldnt broadcast
+	if ( !self->client->ps.isJediMaster )
+	{
+		return;
+	}
+
+	// Broadcast ourself to all clients within range
+	for ( i = 0; i < level.numConnectedClients; i ++ )
+	{
+		gentity_t *ent = &g_entities[level.sortedClients[i]];
+		float	  dist;
+		vec3_t	  angles;
+
+		if ( ent == self )
+		{
+			continue;
+		}
+
+		VectorSubtract( self->client->ps.origin, ent->client->ps.origin, angles );
+		dist = VectorLengthSquared ( angles );
+		vectoangles ( angles, angles );
+
+		// Too far away then just forget it
+		if ( dist > MAX_JEDIMASTER_DISTANCE * MAX_JEDIMASTER_DISTANCE )
+		{
+			continue;
+		}
+		
+		// If not within the field of view then forget it
+		if ( !InFieldOfVision ( ent->client->ps.viewangles, MAX_JEDIMASTER_FOV, angles ) )
+		{
+			continue;
+		}
+
+		// Turn on the broadcast bit for the master and since there is only one
+		// master we are done
+		self->r.broadcastClients[ent->s.clientNum/32] |= (1 << (ent->s.clientNum%32));
+	}
+}
+
+void G_UpdateClientBroadcasts ( gentity_t *self )
+{
+	// Clear all the broadcast bits for this client
+	memset ( self->r.broadcastClients, 0, sizeof ( self->r.broadcastClients ) );
+
+	// The jedi master is broadcast to everyone in range
+	G_UpdateJediMasterBroadcasts ( self );
+
+	// Anyone with force sight on should see this client
+	G_UpdateForceSightBroadcasts ( self );
+}
+
+void G_AddPushVecToUcmd( gentity_t *self, usercmd_t *ucmd )
+{
+	vec3_t	forward, right, moveDir;
+	float	pushSpeed, fMove, rMove;
+
+	if ( !self->client )
+	{
+		return;
+	}
+	pushSpeed = VectorLengthSquared(self->client->pushVec);
+	if(!pushSpeed)
+	{//not being pushed
+		return;
+	}
+
+	AngleVectors(self->client->ps.viewangles, forward, right, NULL);
+	VectorScale(forward, ucmd->forwardmove/127.0f * self->client->ps.speed, moveDir);
+	VectorMA(moveDir, ucmd->rightmove/127.0f * self->client->ps.speed, right, moveDir);
+	//moveDir is now our intended move velocity
+
+	VectorAdd(moveDir, self->client->pushVec, moveDir);
+	self->client->ps.speed = VectorNormalize(moveDir);
+	//moveDir is now our intended move velocity plus our push Vector
+
+	fMove = 127.0 * DotProduct(forward, moveDir);
+	rMove = 127.0 * DotProduct(right, moveDir);
+	ucmd->forwardmove = floor(fMove);//If in the same dir , will be positive
+	ucmd->rightmove = floor(rMove);//If in the same dir , will be positive
+
+	if ( self->client->pushVecTime < level.time )
+	{
+		VectorClear( self->client->pushVec );
+	}
+}
+
+qboolean G_StandingAnim( int anim )
+{//NOTE: does not check idles or special (cinematic) stands
+	switch ( anim )
+	{
+	case BOTH_STAND1:
+	case BOTH_STAND2:
+	case BOTH_STAND3:
+	case BOTH_STAND4:
+		return qtrue;
+		break;
+	}
+	return qfalse;
+}
+
+qboolean G_ActionButtonPressed(int buttons)
+{
+	if (buttons & BUTTON_ATTACK)
+	{
+		return qtrue;
+	}
+	else if (buttons & BUTTON_USE_HOLDABLE)
+	{
+		return qtrue;
+	}
+	else if (buttons & BUTTON_GESTURE)
+	{
+		return qtrue;
+	}
+	else if (buttons & BUTTON_USE)
+	{
+		return qtrue;
+	}
+	else if (buttons & BUTTON_FORCEGRIP)
+	{
+		return qtrue;
+	}
+	else if (buttons & BUTTON_ALT_ATTACK)
+	{
+		return qtrue;
+	}
+	else if (buttons & BUTTON_FORCEPOWER)
+	{
+		return qtrue;
+	}
+	else if (buttons & BUTTON_FORCE_LIGHTNING)
+	{
+		return qtrue;
+	}
+	else if (buttons & BUTTON_FORCE_DRAIN)
+	{
+		return qtrue;
+	}
+
+	return qfalse;
+}
+
+void G_CheckClientIdle( gentity_t *ent, usercmd_t *ucmd ) 
+{
+	vec3_t viewChange;
+	qboolean actionPressed;
+	int buttons;
+
+	if ( !ent || !ent->client || ent->health <= 0 || ent->client->ps.stats[STAT_HEALTH] <= 0 ||
+		ent->client->sess.sessionTeam == TEAM_SPECTATOR || (ent->client->ps.pm_flags & PMF_FOLLOW))
+	{
+		return;
+	}
+
+	buttons = ucmd->buttons;
+
+	if (ent->r.svFlags & SVF_BOT)
+	{ //they press use all the time..
+		buttons &= ~BUTTON_USE;
+	}
+	actionPressed = G_ActionButtonPressed(buttons);
+
+	VectorSubtract(ent->client->ps.viewangles, ent->client->idleViewAngles, viewChange);
+	if ( !VectorCompare( vec3_origin, ent->client->ps.velocity ) 
+		|| actionPressed || ucmd->forwardmove || ucmd->rightmove || ucmd->upmove 
+		|| !G_StandingAnim( ent->client->ps.legsAnim ) 
+		|| (ent->health+ent->client->ps.stats[STAT_ARMOR]) != ent->client->idleHealth
+		|| VectorLength(viewChange) > 10
+		|| ent->client->ps.legsTimer > 0
+		|| ent->client->ps.torsoTimer > 0
+		|| ent->client->ps.weaponTime > 0
+		|| ent->client->ps.weaponstate == WEAPON_CHARGING
+		|| ent->client->ps.weaponstate == WEAPON_CHARGING_ALT
+		|| ent->client->ps.zoomMode
+		|| (ent->client->ps.weaponstate != WEAPON_READY && ent->client->ps.weapon != WP_SABER)
+		|| ent->client->ps.forceHandExtend != HANDEXTEND_NONE
+		|| ent->client->ps.saberBlocked != BLOCKED_NONE
+		|| ent->client->ps.saberBlocking >= level.time
+		|| ent->client->ps.weapon == WP_MELEE
+		|| (ent->client->ps.weapon != ent->client->pers.cmd.weapon && ent->s.eType != ET_NPC))
+	{//FIXME: also check for turning?
+		qboolean brokeOut = qfalse;
+
+		if ( !VectorCompare( vec3_origin, ent->client->ps.velocity ) 
+			|| actionPressed || ucmd->forwardmove || ucmd->rightmove || ucmd->upmove 
+			|| (ent->health+ent->client->ps.stats[STAT_ARMOR]) != ent->client->idleHealth
+			|| ent->client->ps.zoomMode
+			|| (ent->client->ps.weaponstate != WEAPON_READY && ent->client->ps.weapon != WP_SABER)
+			|| (ent->client->ps.weaponTime > 0 && ent->client->ps.weapon == WP_SABER)
+			|| ent->client->ps.weaponstate == WEAPON_CHARGING
+			|| ent->client->ps.weaponstate == WEAPON_CHARGING_ALT
+			|| ent->client->ps.forceHandExtend != HANDEXTEND_NONE
+			|| ent->client->ps.saberBlocked != BLOCKED_NONE
+			|| ent->client->ps.saberBlocking >= level.time
+			|| ent->client->ps.weapon == WP_MELEE
+			|| (ent->client->ps.weapon != ent->client->pers.cmd.weapon && ent->s.eType != ET_NPC))
+		{
+			//if in an idle, break out
+			switch ( ent->client->ps.legsAnim )
+			{
+			case BOTH_STAND1IDLE1:
+			case BOTH_STAND2IDLE1:
+			case BOTH_STAND2IDLE2:
+			case BOTH_STAND3IDLE1:
+			case BOTH_STAND5IDLE1:
+				ent->client->ps.legsTimer = 0;
+				brokeOut = qtrue;
+				break;
+			}
+			switch ( ent->client->ps.torsoAnim )
+			{
+			case BOTH_STAND1IDLE1:
+			case BOTH_STAND2IDLE1:
+			case BOTH_STAND2IDLE2:
+			case BOTH_STAND3IDLE1:
+			case BOTH_STAND5IDLE1:
+				ent->client->ps.torsoTimer = 0;
+				ent->client->ps.weaponTime = 0;
+				ent->client->ps.saberMove = LS_READY;
+				brokeOut = qtrue;
+				break;
+			}
+		}
+		//
+		ent->client->idleHealth = (ent->health+ent->client->ps.stats[STAT_ARMOR]);
+		VectorCopy(ent->client->ps.viewangles, ent->client->idleViewAngles);
+		if ( ent->client->idleTime < level.time )
+		{
+			ent->client->idleTime = level.time;
+		}
+
+		if (brokeOut &&
+			(ent->client->ps.weaponstate == WEAPON_CHARGING || ent->client->ps.weaponstate == WEAPON_CHARGING_ALT))
+		{
+			ent->client->ps.torsoAnim = TORSO_RAISEWEAP1;
+		}
+	}
+	else if ( level.time - ent->client->idleTime > 5000 )
+	{//been idle for 5 seconds
+		int	idleAnim = -1;
+		switch ( ent->client->ps.legsAnim )
+		{
+		case BOTH_STAND1:
+			idleAnim = BOTH_STAND1IDLE1;
+			break;
+		case BOTH_STAND2:
+			idleAnim = BOTH_STAND2IDLE1;//Q_irand(BOTH_STAND2IDLE1,BOTH_STAND2IDLE2);
+			break;
+		case BOTH_STAND3:
+			idleAnim = BOTH_STAND3IDLE1;
+			break;
+		case BOTH_STAND5:
+			idleAnim = BOTH_STAND5IDLE1;
+			break;
+		}
+
+		if (idleAnim == BOTH_STAND2IDLE1 && Q_irand(1, 10) <= 5)
+		{
+			idleAnim = BOTH_STAND2IDLE2;
+		}
+
+		if ( idleAnim != -1 && /*PM_HasAnimation( ent, idleAnim )*/idleAnim > 0 && idleAnim < MAX_ANIMATIONS )
+		{
+			G_SetAnim(ent, ucmd, SETANIM_BOTH, idleAnim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD, 0);
+
+			//don't idle again after this anim for a while
+			//ent->client->idleTime = level.time + PM_AnimLength( ent->client->clientInfo.animFileIndex, (animNumber_t)idleAnim ) + Q_irand( 0, 2000 );
+			ent->client->idleTime = level.time + ent->client->ps.legsTimer + Q_irand( 0, 2000 );
+		}
+	}
+}
+
+void NPC_Accelerate( gentity_t *ent, qboolean fullWalkAcc, qboolean fullRunAcc )
+{
+	if ( !ent->client || !ent->NPC )
+	{
+		return;
+	}
+
+	if ( !ent->NPC->stats.acceleration )
+	{//No acceleration means just start and stop
+		ent->NPC->currentSpeed = ent->NPC->desiredSpeed;
+	}
+	//FIXME:  in cinematics always accel/decel?
+	else if ( ent->NPC->desiredSpeed <= ent->NPC->stats.walkSpeed )
+	{//Only accelerate if at walkSpeeds
+		if ( ent->NPC->desiredSpeed > ent->NPC->currentSpeed + ent->NPC->stats.acceleration )
+		{
+			//ent->client->ps.friction = 0;
+			ent->NPC->currentSpeed += ent->NPC->stats.acceleration;
+		}
+		else if ( ent->NPC->desiredSpeed > ent->NPC->currentSpeed )
+		{
+			//ent->client->ps.friction = 0;
+			ent->NPC->currentSpeed = ent->NPC->desiredSpeed;
+		}
+		else if ( fullWalkAcc && ent->NPC->desiredSpeed < ent->NPC->currentSpeed - ent->NPC->stats.acceleration )
+		{//decelerate even when walking
+			ent->NPC->currentSpeed -= ent->NPC->stats.acceleration;
+		}
+		else if ( ent->NPC->desiredSpeed < ent->NPC->currentSpeed )
+		{//stop on a dime
+			ent->NPC->currentSpeed = ent->NPC->desiredSpeed;
+		}
+	}
+	else//  if ( ent->NPC->desiredSpeed > ent->NPC->stats.walkSpeed )
+	{//Only decelerate if at runSpeeds
+		if ( fullRunAcc && ent->NPC->desiredSpeed > ent->NPC->currentSpeed + ent->NPC->stats.acceleration )
+		{//Accelerate to runspeed
+			//ent->client->ps.friction = 0;
+			ent->NPC->currentSpeed += ent->NPC->stats.acceleration;
+		}
+		else if ( ent->NPC->desiredSpeed > ent->NPC->currentSpeed )
+		{//accelerate instantly
+			//ent->client->ps.friction = 0;
+			ent->NPC->currentSpeed = ent->NPC->desiredSpeed;
+		}
+		else if ( fullRunAcc && ent->NPC->desiredSpeed < ent->NPC->currentSpeed - ent->NPC->stats.acceleration )
+		{
+			ent->NPC->currentSpeed -= ent->NPC->stats.acceleration;
+		}
+		else if ( ent->NPC->desiredSpeed < ent->NPC->currentSpeed )
+		{
+			ent->NPC->currentSpeed = ent->NPC->desiredSpeed;
+		}
+	}
+}
+
+/*
+-------------------------
+NPC_GetWalkSpeed
+-------------------------
+*/
+
+static int NPC_GetWalkSpeed( gentity_t *ent )
+{
+	int	walkSpeed = 0;
+
+	if ( ( ent->client == NULL ) || ( ent->NPC == NULL ) )
+		return 0;
+
+	switch ( ent->client->playerTeam )
+	{
+	case NPCTEAM_PLAYER:	//To shutup compiler, will add entries later (this is stub code)
+	default:
+		walkSpeed = ent->NPC->stats.walkSpeed;
+		break;
+	}
+
+	return walkSpeed;
+}
+
+/*
+-------------------------
+NPC_GetRunSpeed
+-------------------------
+*/
+static int NPC_GetRunSpeed( gentity_t *ent )
+{
+	int	runSpeed = 0;
+
+	if ( ( ent->client == NULL ) || ( ent->NPC == NULL ) )
+		return 0;
+/*
+	switch ( ent->client->playerTeam )
+	{
+	case TEAM_BORG:
+		runSpeed = ent->NPC->stats.runSpeed;
+		runSpeed += BORG_RUN_INCR * (g_spskill->integer%3);
+		break;
+
+	case TEAM_8472:
+		runSpeed = ent->NPC->stats.runSpeed;
+		runSpeed += SPECIES_RUN_INCR * (g_spskill->integer%3);
+		break;
+
+	case TEAM_STASIS:
+		runSpeed = ent->NPC->stats.runSpeed;
+		runSpeed += STASIS_RUN_INCR * (g_spskill->integer%3);
+		break;
+
+	case TEAM_BOTS:
+		runSpeed = ent->NPC->stats.runSpeed;
+		break;
+
+	default:
+		runSpeed = ent->NPC->stats.runSpeed;
+		break;
+	}
+*/
+	// team no longer indicates species/race.  Use NPC_class to adjust speed for specific npc types
+	switch( ent->client->NPC_class)
+	{
+	case CLASS_PROBE:	// droid cases here to shut-up compiler
+	case CLASS_GONK:
+	case CLASS_R2D2:
+	case CLASS_R5D2:
+	case CLASS_MARK1:
+	case CLASS_MARK2:
+	case CLASS_PROTOCOL:
+	case CLASS_ATST: // hmm, not really your average droid
+	case CLASS_MOUSE:
+	case CLASS_SEEKER:
+	case CLASS_REMOTE:
+		runSpeed = ent->NPC->stats.runSpeed;
+		break;
+
+	default:
+		runSpeed = ent->NPC->stats.runSpeed*1.3f; //rww - seems to slow in MP for some reason.
+		break;
+	}
+
+	return runSpeed;
+}
+
+//Seems like a slightly less than ideal method for this, could it be done on the client?
+extern qboolean FlyingCreature( gentity_t *ent );
+void G_CheckMovingLoopingSounds( gentity_t *ent, usercmd_t *ucmd )
+{
+	if ( ent->client )
+	{
+		if ( (ent->NPC&&!VectorCompare( vec3_origin, ent->client->ps.moveDir ))//moving using moveDir
+			|| ucmd->forwardmove || ucmd->rightmove//moving using ucmds
+			|| (ucmd->upmove&&FlyingCreature( ent ))//flier using ucmds to move
+			|| (FlyingCreature( ent )&&!VectorCompare( vec3_origin, ent->client->ps.velocity )&&ent->health>0))//flier using velocity to move
+		{
+			switch( ent->client->NPC_class )
+			{
+			case CLASS_R2D2:
+				ent->s.loopSound = G_SoundIndex( "sound/chars/r2d2/misc/r2_move_lp.wav" );
+				break;
+			case CLASS_R5D2:
+				ent->s.loopSound = G_SoundIndex( "sound/chars/r2d2/misc/r2_move_lp2.wav" );
+				break;
+			case CLASS_MARK2:
+				ent->s.loopSound = G_SoundIndex( "sound/chars/mark2/misc/mark2_move_lp" );
+				break;
+			case CLASS_MOUSE:
+				ent->s.loopSound = G_SoundIndex( "sound/chars/mouse/misc/mouse_lp" );
+				break;
+			case CLASS_PROBE:
+				ent->s.loopSound = G_SoundIndex( "sound/chars/probe/misc/probedroidloop" );
+			}
+		}
+		else
+		{//not moving under your own control, stop loopSound
+			if ( ent->client->NPC_class == CLASS_R2D2 || ent->client->NPC_class == CLASS_R5D2 
+					|| ent->client->NPC_class == CLASS_MARK2 || ent->client->NPC_class == CLASS_MOUSE 
+					|| ent->client->NPC_class == CLASS_PROBE )
+			{
+				ent->s.loopSound = 0;
+			}
+		}
+	}
+}
+
+void G_HeldByMonster( gentity_t *ent, usercmd_t **ucmd )
+{
+	if ( ent 
+		&& ent->client
+		&& ent->client->ps.hasLookTarget )//NOTE: lookTarget is an entity number, so this presumes that client 0 is NOT a Rancor...
+	{
+		gentity_t *monster = &g_entities[ent->client->ps.lookTarget];
+		if ( monster && monster->client )
+		{
+			//take the monster's waypoint as your own
+			ent->waypoint = monster->waypoint;
+			if ( monster->s.NPC_class == CLASS_RANCOR )
+			{//only possibility right now, may add Wampa and Sand Creature later
+				BG_AttachToRancor( monster->ghoul2, //ghoul2 info
+					monster->r.currentAngles[YAW],
+					monster->r.currentOrigin,
+					level.time,
+					NULL,
+					monster->modelScale,
+					(monster->client->ps.eFlags2&EF2_GENERIC_NPC_FLAG),
+					ent->client->ps.origin,
+					ent->client->ps.viewangles,
+					NULL );
+			}
+			VectorClear( ent->client->ps.velocity );
+			G_SetOrigin( ent, ent->client->ps.origin );
+			SetClientViewAngle( ent, ent->client->ps.viewangles );
+			G_SetAngles( ent, ent->client->ps.viewangles );
+			trap_LinkEntity( ent );//redundant?
+		}
+	}
+	// don't allow movement, weapon switching, and most kinds of button presses
+	(*ucmd)->forwardmove = 0;
+	(*ucmd)->rightmove = 0;
+	(*ucmd)->upmove = 0;
+}
+
+typedef enum
+{
+	TAUNT_TAUNT = 0,
+	TAUNT_BOW,
+	TAUNT_MEDITATE,
+	TAUNT_FLOURISH,
+	TAUNT_GLOAT
+};
+
+void G_SetTauntAnim( gentity_t *ent, int taunt )
+{
+	if (ent->client->pers.cmd.upmove ||
+		ent->client->pers.cmd.forwardmove ||
+		ent->client->pers.cmd.rightmove)
+	{ //hack, don't do while moving
+		return;
+	}
+	if ( taunt != TAUNT_TAUNT )
+	{//normal taunt always allowed
+		if ( g_gametype.integer != GT_DUEL
+			&& g_gametype.integer != GT_POWERDUEL )
+		{//no taunts unless in Duel
+			return;
+		}
+	}
+	if ( ent->client->ps.torsoTimer < 1 
+		&& ent->client->ps.forceHandExtend == HANDEXTEND_NONE 
+		&& ent->client->ps.legsTimer < 1 
+		&& ent->client->ps.weaponTime < 1 
+		&& ent->client->ps.saberLockTime < level.time )
+	{
+		int anim = -1;
+		switch ( taunt )
+		{
+		case TAUNT_TAUNT:
+			if ( ent->client->ps.weapon != WP_SABER )
+			{
+				anim = BOTH_ENGAGETAUNT;
+			}
+			else
+			{
+				switch ( ent->client->ps.fd.saberAnimLevel )
+				{
+				case SS_FAST:
+				case SS_TAVION:
+					if ( ent->client->ps.saberHolstered == 1 
+						&& ent->client->saber[1].model 
+						&& ent->client->saber[1].model[0] )
+					{//turn off second saber
+						G_Sound( ent, CHAN_WEAPON, ent->client->saber[1].soundOff );
+					}
+					else if ( ent->client->ps.saberHolstered == 0 )
+					{//turn off first
+						G_Sound( ent, CHAN_WEAPON, ent->client->saber[0].soundOff );
+					}
+					ent->client->ps.saberHolstered = 2;
+					anim = BOTH_GESTURE1;
+					break;
+				case SS_MEDIUM:
+				case SS_STRONG:
+				case SS_DESANN:
+					anim = BOTH_ENGAGETAUNT;
+					break;
+				case SS_DUAL:
+					if ( ent->client->ps.saberHolstered == 1 
+						&& ent->client->saber[1].model 
+						&& ent->client->saber[1].model[0] )
+					{//turn on second saber
+						G_Sound( ent, CHAN_WEAPON, ent->client->saber[1].soundOn );
+					}
+					else if ( ent->client->ps.saberHolstered == 2 )
+					{//turn on first
+						G_Sound( ent, CHAN_WEAPON, ent->client->saber[0].soundOn );
+					}
+					ent->client->ps.saberHolstered = 0;
+					anim = BOTH_DUAL_TAUNT;
+					break;
+				case SS_STAFF:
+					if ( ent->client->ps.saberHolstered > 0 )
+					{//turn on all blades
+						G_Sound( ent, CHAN_WEAPON, ent->client->saber[0].soundOn );
+					}
+					ent->client->ps.saberHolstered = 0;
+					anim = BOTH_STAFF_TAUNT;
+					break;
+				}
+			}
+			break;
+		case TAUNT_BOW:
+			anim = BOTH_BOW;
+			if ( ent->client->ps.saberHolstered == 1 
+				&& ent->client->saber[1].model 
+				&& ent->client->saber[1].model[0] )
+			{//turn off second saber
+				G_Sound( ent, CHAN_WEAPON, ent->client->saber[1].soundOff );
+			}
+			else if ( ent->client->ps.saberHolstered == 0 )
+			{//turn off first
+				G_Sound( ent, CHAN_WEAPON, ent->client->saber[0].soundOff );
+			}
+			ent->client->ps.saberHolstered = 2;
+			break;
+		case TAUNT_MEDITATE:
+			anim = BOTH_MEDITATE;
+			if ( ent->client->ps.saberHolstered == 1 
+				&& ent->client->saber[1].model 
+				&& ent->client->saber[1].model[0] )
+			{//turn off second saber
+				G_Sound( ent, CHAN_WEAPON, ent->client->saber[1].soundOff );
+			}
+			else if ( ent->client->ps.saberHolstered == 0 )
+			{//turn off first
+				G_Sound( ent, CHAN_WEAPON, ent->client->saber[0].soundOff );
+			}
+			ent->client->ps.saberHolstered = 2;
+			break;
+		case TAUNT_FLOURISH:
+			if ( ent->client->ps.weapon == WP_SABER )
+			{
+				if ( ent->client->ps.saberHolstered == 1 
+					&& ent->client->saber[1].model 
+					&& ent->client->saber[1].model[0] )
+				{//turn on second saber
+					G_Sound( ent, CHAN_WEAPON, ent->client->saber[1].soundOn );
+				}
+				else if ( ent->client->ps.saberHolstered == 2 )
+				{//turn on first
+					G_Sound( ent, CHAN_WEAPON, ent->client->saber[0].soundOn );
+				}
+				ent->client->ps.saberHolstered = 0;
+				switch ( ent->client->ps.fd.saberAnimLevel )
+				{
+				case SS_FAST:
+				case SS_TAVION:
+					anim = BOTH_SHOWOFF_FAST;
+					break;
+				case SS_MEDIUM:
+					anim = BOTH_SHOWOFF_MEDIUM;
+					break;
+				case SS_STRONG:
+				case SS_DESANN:
+					anim = BOTH_SHOWOFF_STRONG;
+					break;
+				case SS_DUAL:
+					anim = BOTH_SHOWOFF_DUAL;
+					break;
+				case SS_STAFF:
+					anim = BOTH_SHOWOFF_STAFF;
+					break;
+				}
+			}
+			break;
+		case TAUNT_GLOAT:
+			switch ( ent->client->ps.fd.saberAnimLevel )
+			{
+			case SS_FAST:
+			case SS_TAVION:
+				anim = BOTH_VICTORY_FAST;
+				break;
+			case SS_MEDIUM:
+				anim = BOTH_VICTORY_MEDIUM;
+				break;
+			case SS_STRONG:
+			case SS_DESANN:
+				if ( ent->client->ps.saberHolstered )
+				{//turn on first
+					G_Sound( ent, CHAN_WEAPON, ent->client->saber[0].soundOn );
+				}
+				ent->client->ps.saberHolstered = 0;
+				anim = BOTH_VICTORY_STRONG;
+				break;
+			case SS_DUAL:
+				if ( ent->client->ps.saberHolstered == 1 
+					&& ent->client->saber[1].model 
+					&& ent->client->saber[1].model[0] )
+				{//turn on second saber
+					G_Sound( ent, CHAN_WEAPON, ent->client->saber[1].soundOn );
+				}
+				else if ( ent->client->ps.saberHolstered == 2 )
+				{//turn on first
+					G_Sound( ent, CHAN_WEAPON, ent->client->saber[0].soundOn );
+				}
+				ent->client->ps.saberHolstered = 0;
+				anim = BOTH_VICTORY_DUAL;
+				break;
+			case SS_STAFF:
+				if ( ent->client->ps.saberHolstered )
+				{//turn on first
+					G_Sound( ent, CHAN_WEAPON, ent->client->saber[0].soundOn );
+				}
+				ent->client->ps.saberHolstered = 0;
+				anim = BOTH_VICTORY_STAFF;
+				break;
+			}
+			break;
+		}
+		if ( anim != -1 )
+		{
+			if ( ent->client->ps.groundEntityNum != ENTITYNUM_NONE ) 
+			{
+				ent->client->ps.forceHandExtend = HANDEXTEND_TAUNT;
+				ent->client->ps.forceDodgeAnim = anim;
+				ent->client->ps.forceHandExtendTime = level.time + BG_AnimLength(ent->localAnimIndex, (animNumber_t)anim);
+			}
+			if ( taunt != TAUNT_MEDITATE 
+				&& taunt != TAUNT_BOW )
+			{//no sound for meditate or bow
+				G_AddEvent( ent, EV_TAUNT, taunt );
+			}
+		}
+	}
+}
+
+/*
+==============
+ClientThink
+
+This will be called once for each client frame, which will
+usually be a couple times for each server frame on fast clients.
+
+If "g_synchronousClients 1" is set, this will be called exactly
+once for each server frame, which makes for smooth demo recording.
+==============
+*/
+void ClientThink_real( gentity_t *ent ) {
+	gclient_t	*client;
+	pmove_t		pm;
+	int			oldEventSequence;
+	int			msec;
+	usercmd_t	*ucmd;
+	qboolean	isNPC = qfalse;
+	qboolean	controlledByPlayer = qfalse;
+	qboolean	killJetFlags = qtrue;
+
+	client = ent->client;
+
+	if (ent->s.eType == ET_NPC)
+	{
+		isNPC = qtrue;
+	}
+
+	// don't think if the client is not yet connected (and thus not yet spawned in)
+	if (client->pers.connected != CON_CONNECTED && !isNPC) {
+		return;
+	}
+
+	// This code was moved here from clientThink to fix a problem with g_synchronousClients 
+	// being set to 1 when in vehicles. 
+	if ( ent->s.number < MAX_CLIENTS && ent->client->ps.m_iVehicleNum )
+	{//driving a vehicle
+		if (g_entities[ent->client->ps.m_iVehicleNum].client)
+		{
+			gentity_t *veh = &g_entities[ent->client->ps.m_iVehicleNum];
+
+			if (veh->m_pVehicle &&
+				veh->m_pVehicle->m_pPilot == (bgEntity_t *)ent)
+			{ //only take input from the pilot...
+				veh->client->ps.commandTime = ent->client->ps.commandTime;
+				memcpy(&veh->m_pVehicle->m_ucmd, &ent->client->pers.cmd, sizeof(usercmd_t));
+				if ( veh->m_pVehicle->m_ucmd.buttons & BUTTON_TALK )
+				{ //forced input if "chat bubble" is up
+					veh->m_pVehicle->m_ucmd.buttons = BUTTON_TALK;
+					veh->m_pVehicle->m_ucmd.forwardmove = 0;
+					veh->m_pVehicle->m_ucmd.rightmove = 0;
+					veh->m_pVehicle->m_ucmd.upmove = 0;
+				}
+			}
+		}
+	}
+
+	if (!(client->ps.pm_flags & PMF_FOLLOW))
+	{
+		if (g_gametype.integer == GT_SIEGE &&
+			client->siegeClass != -1 &&
+			bgSiegeClasses[client->siegeClass].saberStance)
+		{ //the class says we have to use this stance set.
+			if (!(bgSiegeClasses[client->siegeClass].saberStance & (1 << client->ps.fd.saberAnimLevel)))
+			{ //the current stance is not in the bitmask, so find the first one that is.
+				int i = SS_FAST;
+
+				while (i < SS_NUM_SABER_STYLES)
+				{
+					if (bgSiegeClasses[client->siegeClass].saberStance & (1 << i))
+					{
+						if (i == SS_DUAL 
+							&& client->ps.saberHolstered == 1 )
+						{//one saber should be off, adjust saberAnimLevel accordinly
+							client->ps.fd.saberAnimLevelBase = i;
+							client->ps.fd.saberAnimLevel = SS_FAST;
+							client->ps.fd.saberDrawAnimLevel = client->ps.fd.saberAnimLevel;
+						}
+						else if ( i == SS_STAFF
+							&& client->ps.saberHolstered == 1 
+							&& client->saber[0].singleBladeStyle != SS_NONE)
+						{//one saber or blade should be off, adjust saberAnimLevel accordinly
+							client->ps.fd.saberAnimLevelBase = i;
+							client->ps.fd.saberAnimLevel = client->saber[0].singleBladeStyle;
+							client->ps.fd.saberDrawAnimLevel = client->ps.fd.saberAnimLevel;
+						}
+						else
+						{
+							client->ps.fd.saberAnimLevelBase = client->ps.fd.saberAnimLevel = i;
+							client->ps.fd.saberDrawAnimLevel = i;
+						}
+						break;
+					}
+
+					i++;
+				}
+			}
+		}
+		else if (client->saber[0].model[0] && client->saber[1].model[0])
+		{ //with two sabs always use akimbo style
+			client->ps.fd.saberAnimLevelBase = SS_DUAL;
+			if ( client->ps.saberHolstered == 1 )
+			{//one saber should be off, adjust saberAnimLevel accordinly
+				client->ps.fd.saberAnimLevel = SS_FAST;
+				client->ps.fd.saberDrawAnimLevel = client->ps.fd.saberAnimLevel;
+			}
+			else
+			{
+				client->ps.fd.saberAnimLevelBase = client->ps.fd.saberAnimLevel = SS_DUAL;
+				client->ps.fd.saberDrawAnimLevel = client->ps.fd.saberAnimLevel;
+			}
+		}
+		else if (client->saber[0].style == SS_STAFF)
+		{ //then always use the staff style
+			client->ps.fd.saberAnimLevelBase = SS_STAFF;
+			if ( client->ps.saberHolstered == 1 
+				&& client->saber[0].singleBladeStyle != SS_NONE)
+			{//one blade should be off, adjust saberAnimLevel accordinly
+				client->ps.fd.saberAnimLevel = client->saber[0].singleBladeStyle;
+				client->ps.fd.saberDrawAnimLevel = client->ps.fd.saberAnimLevel;
+			}
+			else
+			{
+				client->ps.fd.saberAnimLevel = SS_STAFF;
+				client->ps.fd.saberDrawAnimLevel = client->ps.fd.saberAnimLevel;
+			}
+		}
+	}
+
+	// mark the time, so the connection sprite can be removed
+	ucmd = &ent->client->pers.cmd;
+
+	if ( client && (client->ps.eFlags2&EF2_HELD_BY_MONSTER) )
+	{
+		G_HeldByMonster( ent, &ucmd );
+	}
+
+	// sanity check the command time to prevent speedup cheating
+	if ( ucmd->serverTime > level.time + 200 ) {
+		ucmd->serverTime = level.time + 200;
+//		G_Printf("serverTime <<<<<\n" );
+	}
+	if ( ucmd->serverTime < level.time - 1000 ) {
+		ucmd->serverTime = level.time - 1000;
+//		G_Printf("serverTime >>>>>\n" );
+	} 
+
+	if (isNPC && (ucmd->serverTime - client->ps.commandTime) < 1)
+	{
+		ucmd->serverTime = client->ps.commandTime + 100;
+	}
+
+	msec = ucmd->serverTime - client->ps.commandTime;
+	// following others may result in bad times, but we still want
+	// to check for follow toggles
+	if ( msec < 1 && client->sess.spectatorState != SPECTATOR_FOLLOW ) {
+		return;
+	}
+
+	if ( msec > 200 ) {
+		msec = 200;
+	}
+
+	if ( pmove_msec.integer < 8 ) {
+		trap_Cvar_Set("pmove_msec", "8");
+	}
+	else if (pmove_msec.integer > 33) {
+		trap_Cvar_Set("pmove_msec", "33");
+	}
+
+	if ( pmove_fixed.integer || client->pers.pmoveFixed ) {
+		ucmd->serverTime = ((ucmd->serverTime + pmove_msec.integer-1) / pmove_msec.integer) * pmove_msec.integer;
+		//if (ucmd->serverTime - client->ps.commandTime <= 0)
+		//	return;
+	}
+
+	//
+	// check for exiting intermission
+	//
+	if ( level.intermissiontime ) {
+		ClientIntermissionThink( client );
+		return;
+	}
+
+	// spectators don't do much
+	if ( client->sess.sessionTeam == TEAM_SPECTATOR || client->tempSpectate > level.time ) {
+		if ( client->sess.spectatorState == SPECTATOR_SCOREBOARD ) {
+			return;
+		}
+		SpectatorThink( ent, ucmd );
+		return;
+	}
+
+	if (ent && ent->client && (ent->client->ps.eFlags & EF_INVULNERABLE))
+	{
+		if (ent->client->invulnerableTimer <= level.time)
+		{
+			ent->client->ps.eFlags &= ~EF_INVULNERABLE;
+		}
+	}
+
+	if (ent->s.eType != ET_NPC)
+	{
+		// check for inactivity timer, but never drop the local client of a non-dedicated server
+		if ( !ClientInactivityTimer( client ) ) {
+			return;
+		}
+	}
+
+	//Check if we should have a fullbody push effect around the player
+	if (client->pushEffectTime > level.time)
+	{
+		client->ps.eFlags |= EF_BODYPUSH;
+	}
+	else if (client->pushEffectTime)
+	{
+		client->pushEffectTime = 0;
+		client->ps.eFlags &= ~EF_BODYPUSH;
+	}
+
+	if (client->ps.stats[STAT_HOLDABLE_ITEMS] & (1 << HI_JETPACK))
+	{
+		client->ps.eFlags |= EF_JETPACK;
+	}
+	else
+	{
+		client->ps.eFlags &= ~EF_JETPACK;
+	}
+
+	if ( client->noclip ) {
+		client->ps.pm_type = PM_NOCLIP;
+	} else if ( client->ps.eFlags & EF_DISINTEGRATION ) {
+		client->ps.pm_type = PM_NOCLIP;
+	} else if ( client->ps.stats[STAT_HEALTH] <= 0 ) {
+		client->ps.pm_type = PM_DEAD;
+	} else {
+		if (client->ps.forceGripChangeMovetype)
+		{
+			client->ps.pm_type = client->ps.forceGripChangeMovetype;
+		}
+		else
+		{
+			if (client->jetPackOn)
+			{
+				client->ps.pm_type = PM_JETPACK;
+				client->ps.eFlags |= EF_JETPACK_ACTIVE;
+				killJetFlags = qfalse;
+			}
+			else
+			{
+				client->ps.pm_type = PM_NORMAL;
+			}
+		}
+	}
+
+	if (killJetFlags)
+	{
+		client->ps.eFlags &= ~EF_JETPACK_ACTIVE;
+		client->ps.eFlags &= ~EF_JETPACK_FLAMING;
+	}
+
+#define	SLOWDOWN_DIST	128.0f
+#define	MIN_NPC_SPEED	16.0f
+
+	if (client->bodyGrabIndex != ENTITYNUM_NONE)
+	{
+		gentity_t *grabbed = &g_entities[client->bodyGrabIndex];
+
+		if (!grabbed->inuse || grabbed->s.eType != ET_BODY ||
+			(grabbed->s.eFlags & EF_DISINTEGRATION) ||
+			(grabbed->s.eFlags & EF_NODRAW))
+		{
+			if (grabbed->inuse && grabbed->s.eType == ET_BODY)
+			{
+				grabbed->s.ragAttach = 0;
+			}
+			client->bodyGrabIndex = ENTITYNUM_NONE;
+		}
+		else
+		{
+			mdxaBone_t rhMat;
+			vec3_t rhOrg, tAng;
+			vec3_t bodyDir;
+			float bodyDist;
+
+			ent->client->ps.forceHandExtend = HANDEXTEND_DRAGGING;
+
+			if (ent->client->ps.forceHandExtendTime < level.time + 500)
+			{
+				ent->client->ps.forceHandExtendTime = level.time + 1000;
+			}
+
+			VectorSet(tAng, 0, ent->client->ps.viewangles[YAW], 0);
+			trap_G2API_GetBoltMatrix(ent->ghoul2, 0, 0, &rhMat, tAng, ent->client->ps.origin, level.time,
+				NULL, ent->modelScale); //0 is always going to be right hand bolt
+			BG_GiveMeVectorFromMatrix(&rhMat, ORIGIN, rhOrg);
+
+			VectorSubtract(rhOrg, grabbed->r.currentOrigin, bodyDir);
+			bodyDist = VectorLength(bodyDir);
+
+			if (bodyDist > 40.0f)
+			{ //can no longer reach
+				grabbed->s.ragAttach = 0;
+				client->bodyGrabIndex = ENTITYNUM_NONE;
+			}
+			else if (bodyDist > 24.0f)
+			{
+				bodyDir[2] = 0; //don't want it floating
+				//VectorScale(bodyDir, 0.1f, bodyDir);
+				VectorAdd(grabbed->epVelocity, bodyDir, grabbed->epVelocity);
+				G_Sound(grabbed, CHAN_AUTO, G_SoundIndex("sound/player/roll1.wav"));
+			}
+		}
+	}
+	else if (ent->client->ps.forceHandExtend == HANDEXTEND_DRAGGING)
+	{
+		ent->client->ps.forceHandExtend = HANDEXTEND_WEAPONREADY;
+	}
+
+	if (ent->NPC && ent->s.NPC_class != CLASS_VEHICLE) //vehicles manage their own speed
+	{
+		//FIXME: swoop should keep turning (and moving forward?) for a little bit?
+		if ( ent->NPC->combatMove == qfalse )
+		{
+			//if ( !(ucmd->buttons & BUTTON_USE) )
+			if (1)
+			{//Not leaning
+				qboolean Flying = (ucmd->upmove && (ent->client->ps.eFlags2&EF2_FLYING));//ent->client->moveType == MT_FLYSWIM);
+				qboolean Climbing = (ucmd->upmove && ent->watertype&CONTENTS_LADDER );
+
+				//client->ps.friction = 6;
+
+				if ( ucmd->forwardmove || ucmd->rightmove || Flying )
+				{
+					//if ( ent->NPC->behaviorState != BS_FORMATION )
+					{//In - Formation NPCs set thier desiredSpeed themselves
+						if ( ucmd->buttons & BUTTON_WALKING )
+						{
+							ent->NPC->desiredSpeed = NPC_GetWalkSpeed( ent );//ent->NPC->stats.walkSpeed;
+						}
+						else//running
+						{
+							ent->NPC->desiredSpeed = NPC_GetRunSpeed( ent );//ent->NPC->stats.runSpeed;
+						}
+
+						if ( ent->NPC->currentSpeed >= 80 && !controlledByPlayer )
+						{//At higher speeds, need to slow down close to stuff
+							//Slow down as you approach your goal
+						//	if ( ent->NPC->distToGoal < SLOWDOWN_DIST && client->race != RACE_BORG && !(ent->NPC->aiFlags&NPCAI_NO_SLOWDOWN) )//128
+							if ( ent->NPC->distToGoal < SLOWDOWN_DIST && !(ent->NPC->aiFlags&NPCAI_NO_SLOWDOWN) )//128
+							{
+								if ( ent->NPC->desiredSpeed > MIN_NPC_SPEED )
+								{
+									float slowdownSpeed = ((float)ent->NPC->desiredSpeed) * ent->NPC->distToGoal / SLOWDOWN_DIST;
+
+									ent->NPC->desiredSpeed = ceil(slowdownSpeed);
+									if ( ent->NPC->desiredSpeed < MIN_NPC_SPEED )
+									{//don't slow down too much
+										ent->NPC->desiredSpeed = MIN_NPC_SPEED;
+									}
+								}
+							}
+						}
+					}
+				}
+				else if ( Climbing )
+				{
+					ent->NPC->desiredSpeed = ent->NPC->stats.walkSpeed;
+				}
+				else
+				{//We want to stop
+					ent->NPC->desiredSpeed = 0;
+				}
+
+				NPC_Accelerate( ent, qfalse, qfalse );
+
+				if ( ent->NPC->currentSpeed <= 24 && ent->NPC->desiredSpeed < ent->NPC->currentSpeed )
+				{//No-one walks this slow
+					client->ps.speed = ent->NPC->currentSpeed = 0;//Full stop
+					ucmd->forwardmove = 0;
+					ucmd->rightmove = 0;
+				}
+				else
+				{
+					if ( ent->NPC->currentSpeed <= ent->NPC->stats.walkSpeed )
+					{//Play the walkanim
+						ucmd->buttons |= BUTTON_WALKING;
+					}
+					else
+					{
+						ucmd->buttons &= ~BUTTON_WALKING;
+					}
+
+					if ( ent->NPC->currentSpeed > 0 )
+					{//We should be moving
+						if ( Climbing || Flying )
+						{
+							if ( !ucmd->upmove )
+							{//We need to force them to take a couple more steps until stopped
+								ucmd->upmove = ent->NPC->last_ucmd.upmove;//was last_upmove;
+							}
+						}
+						else if ( !ucmd->forwardmove && !ucmd->rightmove )
+						{//We need to force them to take a couple more steps until stopped
+							ucmd->forwardmove = ent->NPC->last_ucmd.forwardmove;//was last_forwardmove;
+							ucmd->rightmove = ent->NPC->last_ucmd.rightmove;//was last_rightmove;
+						}
+					}
+
+					client->ps.speed = ent->NPC->currentSpeed;
+				//	if ( player && player->client && player->client->ps.viewEntity == ent->s.number )
+				//	{
+				//	}
+				//	else
+					//rwwFIXMEFIXME: do this and also check for all real client
+					if (1)
+					{
+						//Slow down on turns - don't orbit!!!
+						float turndelta = 0; 
+						// if the NPC is locked into a Yaw, we want to check the lockedDesiredYaw...otherwise the NPC can't walk backwards, because it always thinks it trying to turn according to desiredYaw
+						//if( client->renderInfo.renderFlags & RF_LOCKEDANGLE ) // yeah I know the RF_ flag is a pretty ugly hack...
+						if (0) //rwwFIXMEFIXME: ...
+						{	
+							turndelta = (180 - fabs( AngleDelta( ent->r.currentAngles[YAW], ent->NPC->lockedDesiredYaw ) ))/180;
+						}
+						else
+						{
+							turndelta = (180 - fabs( AngleDelta( ent->r.currentAngles[YAW], ent->NPC->desiredYaw ) ))/180;
+						}
+												
+						if ( turndelta < 0.75f )
+						{
+							client->ps.speed = 0;
+						}
+						else if ( ent->NPC->distToGoal < 100 && turndelta < 1.0 )
+						{//Turn is greater than 45 degrees or closer than 100 to goal
+							client->ps.speed = floor(((float)(client->ps.speed))*turndelta);
+						}
+					}
+				}
+			}
+		}
+		else
+		{	
+			ent->NPC->desiredSpeed = ( ucmd->buttons & BUTTON_WALKING ) ? NPC_GetWalkSpeed( ent ) : NPC_GetRunSpeed( ent );
+
+			client->ps.speed = ent->NPC->desiredSpeed;
+		}
+
+		if (ucmd->buttons & BUTTON_WALKING)
+		{ //sort of a hack I guess since MP handles walking differently from SP (has some proxy cheat prevention methods)
+			if (ent->client->ps.speed > 64)
+			{
+				ent->client->ps.speed = 64;
+			}
+
+			if (ucmd->forwardmove > 64)
+			{
+				ucmd->forwardmove = ent->client->ps.speed;				
+			}
+			else if (ucmd->forwardmove < -64)
+			{
+				ucmd->forwardmove = -ent->client->ps.speed;
+			}
+			
+			if (ucmd->rightmove > 64)
+			{
+				ucmd->rightmove = ent->client->ps.speed;
+			}
+			else if ( ucmd->rightmove < -64)
+			{
+				ucmd->rightmove = -ent->client->ps.speed;
+			}
+
+			ent->client->ps.speed = ent->client->ps.basespeed = NPC_GetRunSpeed( ent );
+		}
+		client->ps.basespeed = client->ps.speed;
+	}
+	else if (!client->ps.m_iVehicleNum &&
+		(!ent->NPC || ent->s.NPC_class != CLASS_VEHICLE)) //if riding a vehicle it will manage our speed and such
+	{
+		// set speed
+		client->ps.speed = g_speed.value;
+
+		//Check for a siege class speed multiplier
+		if (g_gametype.integer == GT_SIEGE &&
+			client->siegeClass != -1)
+		{
+			client->ps.speed *= bgSiegeClasses[client->siegeClass].speed;
+		}
+
+		if (client->bodyGrabIndex != ENTITYNUM_NONE)
+		{ //can't go nearly as fast when dragging a body around
+			client->ps.speed *= 0.2f;
+		}
+
+		client->ps.basespeed = client->ps.speed;
+	}
+
+	if ( !ent->NPC || !(ent->NPC->aiFlags&NPCAI_CUSTOM_GRAVITY) )
+	{//use global gravity
+		if (ent->NPC && ent->s.NPC_class == CLASS_VEHICLE &&
+			ent->m_pVehicle && ent->m_pVehicle->m_pVehicleInfo->gravity)
+		{ //use custom veh gravity
+			client->ps.gravity = ent->m_pVehicle->m_pVehicleInfo->gravity;
+		}
+		else
+		{
+			if (ent->client->inSpaceIndex && ent->client->inSpaceIndex != ENTITYNUM_NONE)
+			{ //in space, so no gravity...
+				client->ps.gravity = 1.0f;
+				if (ent->s.number < MAX_CLIENTS)
+				{
+					VectorScale(client->ps.velocity, 0.8f, client->ps.velocity);
+				}
+			}
+			else
+			{
+				if (client->ps.eFlags2 & EF2_SHIP_DEATH)
+				{ //float there
+					VectorClear(client->ps.velocity);
+					client->ps.gravity = 1.0f;
+				}
+				else
+				{
+					client->ps.gravity = g_gravity.value;
+				}
+			}
+		}
+	}
+
+	if (ent->client->ps.duelInProgress)
+	{
+		gentity_t *duelAgainst = &g_entities[ent->client->ps.duelIndex];
+
+		//Keep the time updated, so once this duel ends this player can't engage in a duel for another
+		//10 seconds. This will give other people a chance to engage in duels in case this player wants
+		//to engage again right after he's done fighting and someone else is waiting.
+		ent->client->ps.fd.privateDuelTime = level.time + 10000;
+
+		if (ent->client->ps.duelTime < level.time)
+		{
+			//Bring out the sabers
+			if (ent->client->ps.weapon == WP_SABER 
+				&& ent->client->ps.saberHolstered 
+				&& ent->client->ps.duelTime )
+			{
+				ent->client->ps.saberHolstered = 0;
+
+				if (ent->client->saber[0].soundOn)
+				{
+					G_Sound(ent, CHAN_AUTO, ent->client->saber[0].soundOn);
+				}
+				if (ent->client->saber[1].soundOn)
+				{
+					G_Sound(ent, CHAN_AUTO, ent->client->saber[1].soundOn);
+				}
+
+				G_AddEvent(ent, EV_PRIVATE_DUEL, 2);
+
+				ent->client->ps.duelTime = 0;
+			}
+
+			if (duelAgainst 
+				&& duelAgainst->client 
+				&& duelAgainst->inuse 
+				&& duelAgainst->client->ps.weapon == WP_SABER 
+				&& duelAgainst->client->ps.saberHolstered 
+				&& duelAgainst->client->ps.duelTime)
+			{
+				duelAgainst->client->ps.saberHolstered = 0;
+
+				if (duelAgainst->client->saber[0].soundOn)
+				{
+					G_Sound(duelAgainst, CHAN_AUTO, duelAgainst->client->saber[0].soundOn);
+				}
+				if (duelAgainst->client->saber[1].soundOn)
+				{
+					G_Sound(duelAgainst, CHAN_AUTO, duelAgainst->client->saber[1].soundOn);
+				}
+
+				G_AddEvent(duelAgainst, EV_PRIVATE_DUEL, 2);
+
+				duelAgainst->client->ps.duelTime = 0;
+			}
+		}
+		else
+		{
+			client->ps.speed = 0;
+			client->ps.basespeed = 0;
+			ucmd->forwardmove = 0;
+			ucmd->rightmove = 0;
+			ucmd->upmove = 0;
+		}
+
+		if (!duelAgainst || !duelAgainst->client || !duelAgainst->inuse ||
+			duelAgainst->client->ps.duelIndex != ent->s.number)
+		{
+			ent->client->ps.duelInProgress = 0;
+			G_AddEvent(ent, EV_PRIVATE_DUEL, 0);
+		}
+		else if (duelAgainst->health < 1 || duelAgainst->client->ps.stats[STAT_HEALTH] < 1)
+		{
+			ent->client->ps.duelInProgress = 0;
+			duelAgainst->client->ps.duelInProgress = 0;
+
+			G_AddEvent(ent, EV_PRIVATE_DUEL, 0);
+			G_AddEvent(duelAgainst, EV_PRIVATE_DUEL, 0);
+
+			//Winner gets full health.. providing he's still alive
+			if (ent->health > 0 && ent->client->ps.stats[STAT_HEALTH] > 0)
+			{
+				if (ent->health < ent->client->ps.stats[STAT_MAX_HEALTH])
+				{
+					ent->client->ps.stats[STAT_HEALTH] = ent->health = ent->client->ps.stats[STAT_MAX_HEALTH];
+				}
+
+				if (g_spawnInvulnerability.integer)
+				{
+					ent->client->ps.eFlags |= EF_INVULNERABLE;
+					ent->client->invulnerableTimer = level.time + g_spawnInvulnerability.integer;
+				}
+			}
+
+			/*
+			trap_SendServerCommand( ent-g_entities, va("print \"%s %s\n\"", ent->client->pers.netname, G_GetStringEdString("MP_SVGAME", "PLDUELWINNER")) );
+			trap_SendServerCommand( duelAgainst-g_entities, va("print \"%s %s\n\"", ent->client->pers.netname, G_GetStringEdString("MP_SVGAME", "PLDUELWINNER")) );
+			*/
+			//Private duel announcements are now made globally because we only want one duel at a time.
+			if (ent->health > 0 && ent->client->ps.stats[STAT_HEALTH] > 0)
+			{
+				trap_SendServerCommand( -1, va("cp \"%s %s %s!\n\"", ent->client->pers.netname, G_GetStringEdString("MP_SVGAME", "PLDUELWINNER"), duelAgainst->client->pers.netname) );
+			}
+			else
+			{ //it was a draw, because we both managed to die in the same frame
+				trap_SendServerCommand( -1, va("cp \"%s\n\"", G_GetStringEdString("MP_SVGAME", "PLDUELTIE")) );
+			}
+		}
+		else
+		{
+			vec3_t vSub;
+			float subLen = 0;
+
+			VectorSubtract(ent->client->ps.origin, duelAgainst->client->ps.origin, vSub);
+			subLen = VectorLength(vSub);
+
+			if (subLen >= 1024)
+			{
+				ent->client->ps.duelInProgress = 0;
+				duelAgainst->client->ps.duelInProgress = 0;
+
+				G_AddEvent(ent, EV_PRIVATE_DUEL, 0);
+				G_AddEvent(duelAgainst, EV_PRIVATE_DUEL, 0);
+
+				trap_SendServerCommand( -1, va("print \"%s\n\"", G_GetStringEdString("MP_SVGAME", "PLDUELSTOP")) );
+			}
+		}
+	}
+
+	if (ent->client->doingThrow > level.time)
+	{
+		gentity_t *throwee = &g_entities[ent->client->throwingIndex];
+
+		if (!throwee->inuse || !throwee->client || throwee->health < 1 ||
+			throwee->client->sess.sessionTeam == TEAM_SPECTATOR ||
+			(throwee->client->ps.pm_flags & PMF_FOLLOW) ||
+			throwee->client->throwingIndex != ent->s.number)
+		{
+			ent->client->doingThrow = 0;
+			ent->client->ps.forceHandExtend = HANDEXTEND_NONE;
+
+			if (throwee->inuse && throwee->client)
+			{
+				throwee->client->ps.heldByClient = 0;
+				throwee->client->beingThrown = 0;
+
+				if (throwee->client->ps.forceHandExtend != HANDEXTEND_POSTTHROWN)
+				{
+					throwee->client->ps.forceHandExtend = HANDEXTEND_NONE;
+				}
+			}
+		}
+	}
+
+	if (ent->client->beingThrown > level.time)
+	{
+		gentity_t *thrower = &g_entities[ent->client->throwingIndex];
+
+		if (!thrower->inuse || !thrower->client || thrower->health < 1 ||
+			thrower->client->sess.sessionTeam == TEAM_SPECTATOR ||
+			(thrower->client->ps.pm_flags & PMF_FOLLOW) ||
+			thrower->client->throwingIndex != ent->s.number)
+		{
+			ent->client->ps.heldByClient = 0;
+			ent->client->beingThrown = 0;
+
+			if (ent->client->ps.forceHandExtend != HANDEXTEND_POSTTHROWN)
+			{
+				ent->client->ps.forceHandExtend = HANDEXTEND_NONE;
+			}
+
+			if (thrower->inuse && thrower->client)
+			{
+				thrower->client->doingThrow = 0;
+				thrower->client->ps.forceHandExtend = HANDEXTEND_NONE;
+			}
+		}
+		else if (thrower->inuse && thrower->client && thrower->ghoul2 &&
+			trap_G2_HaveWeGhoul2Models(thrower->ghoul2))
+		{
+#if 0
+			int lHandBolt = trap_G2API_AddBolt(thrower->ghoul2, 0, "*l_hand");
+			int pelBolt = trap_G2API_AddBolt(thrower->ghoul2, 0, "pelvis");
+
+
+			if (lHandBolt != -1 && pelBolt != -1)
+#endif
+			{
+				float pDif = 40.0f;
+				vec3_t boltOrg, pBoltOrg;
+				vec3_t tAngles;
+				vec3_t vDif;
+				vec3_t entDir, otherAngles;
+				vec3_t fwd, right;
+
+				//Always look at the thrower.
+				VectorSubtract( thrower->client->ps.origin, ent->client->ps.origin, entDir );
+				VectorCopy( ent->client->ps.viewangles, otherAngles );
+				otherAngles[YAW] = vectoyaw( entDir );
+				SetClientViewAngle( ent, otherAngles );
+
+				VectorCopy(thrower->client->ps.viewangles, tAngles);
+				tAngles[PITCH] = tAngles[ROLL] = 0;
+
+				//Get the direction between the pelvis and position of the hand
+#if 0
+				mdxaBone_t boltMatrix, pBoltMatrix;
+
+				trap_G2API_GetBoltMatrix(thrower->ghoul2, 0, lHandBolt, &boltMatrix, tAngles, thrower->client->ps.origin, level.time, 0, thrower->modelScale);
+				boltOrg[0] = boltMatrix.matrix[0][3];
+				boltOrg[1] = boltMatrix.matrix[1][3];
+				boltOrg[2] = boltMatrix.matrix[2][3];
+
+				trap_G2API_GetBoltMatrix(thrower->ghoul2, 0, pelBolt, &pBoltMatrix, tAngles, thrower->client->ps.origin, level.time, 0, thrower->modelScale);
+				pBoltOrg[0] = pBoltMatrix.matrix[0][3];
+				pBoltOrg[1] = pBoltMatrix.matrix[1][3];
+				pBoltOrg[2] = pBoltMatrix.matrix[2][3];
+#else //above tends to not work once in a while, for various reasons I suppose.
+				VectorCopy(thrower->client->ps.origin, pBoltOrg);
+				AngleVectors(tAngles, fwd, right, 0);
+				boltOrg[0] = pBoltOrg[0] + fwd[0]*8 + right[0]*pDif;
+				boltOrg[1] = pBoltOrg[1] + fwd[1]*8 + right[1]*pDif;
+				boltOrg[2] = pBoltOrg[2];
+#endif
+				//G_TestLine(boltOrg, pBoltOrg, 0x0000ff, 50);
+
+				VectorSubtract(ent->client->ps.origin, boltOrg, vDif);
+				if (VectorLength(vDif) > 32.0f && (thrower->client->doingThrow - level.time) < 4500)
+				{ //the hand is too far away, and can no longer hold onto us, so escape.
+					ent->client->ps.heldByClient = 0;
+					ent->client->beingThrown = 0;
+					thrower->client->doingThrow = 0;
+
+					thrower->client->ps.forceHandExtend = HANDEXTEND_NONE;
+					G_EntitySound( thrower, CHAN_VOICE, G_SoundIndex("*pain25.wav") );
+
+					ent->client->ps.forceDodgeAnim = 2;
+					ent->client->ps.forceHandExtend = HANDEXTEND_KNOCKDOWN;
+					ent->client->ps.forceHandExtendTime = level.time + 500;
+					ent->client->ps.velocity[2] = 400;
+					G_PreDefSound(ent->client->ps.origin, PDSOUND_FORCEJUMP);
+				}
+				else if ((client->beingThrown - level.time) < 4000)
+				{ //step into the next part of the throw, and go flying back
+					float vScale = 400.0f;
+					ent->client->ps.forceHandExtend = HANDEXTEND_POSTTHROWN;
+					ent->client->ps.forceHandExtendTime = level.time + 1200;
+					ent->client->ps.forceDodgeAnim = 0;
+
+					thrower->client->ps.forceHandExtend = HANDEXTEND_POSTTHROW;
+					thrower->client->ps.forceHandExtendTime = level.time + 200;
+
+					ent->client->ps.heldByClient = 0;
+
+					ent->client->ps.heldByClient = 0;
+					ent->client->beingThrown = 0;
+					thrower->client->doingThrow = 0;
+
+					AngleVectors(thrower->client->ps.viewangles, vDif, 0, 0);
+					ent->client->ps.velocity[0] = vDif[0]*vScale;
+					ent->client->ps.velocity[1] = vDif[1]*vScale;
+					ent->client->ps.velocity[2] = 400;
+
+					G_EntitySound( ent, CHAN_VOICE, G_SoundIndex("*pain100.wav") );
+					G_EntitySound( thrower, CHAN_VOICE, G_SoundIndex("*jump1.wav") );
+
+					//Set the thrower as the "other killer", so if we die from fall/impact damage he is credited.
+					ent->client->ps.otherKiller = thrower->s.number;
+					ent->client->ps.otherKillerTime = level.time + 8000;
+					ent->client->ps.otherKillerDebounceTime = level.time + 100;
+				}
+				else
+				{ //see if we can move to be next to the hand.. if it's not clear, break the throw.
+					vec3_t intendedOrigin;
+					trace_t tr;
+					trace_t tr2;
+
+					VectorSubtract(boltOrg, pBoltOrg, vDif);
+					VectorNormalize(vDif);
+
+					VectorClear(ent->client->ps.velocity);
+					intendedOrigin[0] = pBoltOrg[0] + vDif[0]*pDif;
+					intendedOrigin[1] = pBoltOrg[1] + vDif[1]*pDif;
+					intendedOrigin[2] = thrower->client->ps.origin[2];
+
+					trap_Trace(&tr, intendedOrigin, ent->r.mins, ent->r.maxs, intendedOrigin, ent->s.number, ent->clipmask);
+					trap_Trace(&tr2, ent->client->ps.origin, ent->r.mins, ent->r.maxs, intendedOrigin, ent->s.number, CONTENTS_SOLID);
+
+					if (tr.fraction == 1.0 && !tr.startsolid && tr2.fraction == 1.0 && !tr2.startsolid)
+					{
+						VectorCopy(intendedOrigin, ent->client->ps.origin);
+						
+						if ((client->beingThrown - level.time) < 4800)
+						{
+							ent->client->ps.heldByClient = thrower->s.number+1;
+						}
+					}
+					else
+					{ //if the guy can't be put here then it's time to break the throw off.
+						ent->client->ps.heldByClient = 0;
+						ent->client->beingThrown = 0;
+						thrower->client->doingThrow = 0;
+
+						thrower->client->ps.forceHandExtend = HANDEXTEND_NONE;
+						G_EntitySound( thrower, CHAN_VOICE, G_SoundIndex("*pain25.wav") );
+
+						ent->client->ps.forceDodgeAnim = 2;
+						ent->client->ps.forceHandExtend = HANDEXTEND_KNOCKDOWN;
+						ent->client->ps.forceHandExtendTime = level.time + 500;
+						ent->client->ps.velocity[2] = 400;
+						G_PreDefSound(ent->client->ps.origin, PDSOUND_FORCEJUMP);
+					}
+				}
+			}
+		}
+	}
+	else if (ent->client->ps.heldByClient)
+	{
+		ent->client->ps.heldByClient = 0;
+	}
+
+	/*
+	if ( client->ps.powerups[PW_HASTE] ) {
+		client->ps.speed *= 1.3;
+	}
+	*/
+
+	//Will probably never need this again, since we have g2 properly serverside now.
+	//But just in case.
+	/*
+	if (client->ps.usingATST && ent->health > 0)
+	{ //we have special shot clip boxes as an ATST
+		ent->r.contents |= CONTENTS_NOSHOT;
+		ATST_ManageDamageBoxes(ent);
+	}
+	else
+	{
+		ent->r.contents &= ~CONTENTS_NOSHOT;
+		client->damageBoxHandle_Head = 0;
+		client->damageBoxHandle_RLeg = 0;
+		client->damageBoxHandle_LLeg = 0;
+	}
+	*/
+
+	//rww - moved this stuff into the pmove code so that it's predicted properly
+	//BG_AdjustClientSpeed(&client->ps, &client->pers.cmd, level.time);
+
+	// set up for pmove
+	oldEventSequence = client->ps.eventSequence;
+
+	memset (&pm, 0, sizeof(pm));
+
+	if ( ent->flags & FL_FORCE_GESTURE ) {
+		ent->flags &= ~FL_FORCE_GESTURE;
+		ent->client->pers.cmd.buttons |= BUTTON_GESTURE;
+	}
+
+	if (ent->client && ent->client->ps.fallingToDeath &&
+		(level.time - FALL_FADE_TIME) > ent->client->ps.fallingToDeath)
+	{ //die!
+		if (ent->health > 0)
+		{
+			gentity_t *otherKiller = ent;
+			if (ent->client->ps.otherKillerTime > level.time &&
+				ent->client->ps.otherKiller != ENTITYNUM_NONE)
+			{
+				otherKiller = &g_entities[ent->client->ps.otherKiller];
+
+				if (!otherKiller->inuse)
+				{
+					otherKiller = ent;
+				}
+			}
+			G_Damage(ent, otherKiller, otherKiller, NULL, ent->client->ps.origin, 9999, DAMAGE_NO_PROTECTION, MOD_FALLING);
+			//player_die(ent, ent, ent, 100000, MOD_FALLING);
+	//		if (!ent->NPC)
+	//		{
+	//			respawn(ent);
+	//		}
+	//		ent->client->ps.fallingToDeath = 0;
+
+			G_MuteSound(ent->s.number, CHAN_VOICE); //stop screaming, because you are dead!
+		}
+	}
+
+	if (ent->client->ps.otherKillerTime > level.time &&
+		ent->client->ps.groundEntityNum != ENTITYNUM_NONE &&
+		ent->client->ps.otherKillerDebounceTime < level.time)
+	{
+		ent->client->ps.otherKillerTime = 0;
+		ent->client->ps.otherKiller = ENTITYNUM_NONE;
+	}
+	else if (ent->client->ps.otherKillerTime > level.time &&
+		ent->client->ps.groundEntityNum == ENTITYNUM_NONE)
+	{
+		if (ent->client->ps.otherKillerDebounceTime < (level.time + 100))
+		{
+			ent->client->ps.otherKillerDebounceTime = level.time + 100;
+		}
+	}
+
+//	WP_ForcePowersUpdate( ent, msec, ucmd); //update any active force powers
+//	WP_SaberPositionUpdate(ent, ucmd); //check the server-side saber point, do apprioriate server-side actions (effects are cs-only)
+
+	//NOTE: can't put USE here *before* PMove!!
+	if ( ent->client->ps.useDelay > level.time 
+		&& ent->client->ps.m_iVehicleNum )
+	{//when in a vehicle, debounce the use...
+		ucmd->buttons &= ~BUTTON_USE;
+	}
+
+	//FIXME: need to do this before check to avoid walls and cliffs (or just cliffs?)
+	G_AddPushVecToUcmd( ent, ucmd );
+
+	//play/stop any looping sounds tied to controlled movement
+	G_CheckMovingLoopingSounds( ent, ucmd );
+
+	pm.ps = &client->ps;
+	pm.cmd = *ucmd;
+	if ( pm.ps->pm_type == PM_DEAD ) {
+		pm.tracemask = MASK_PLAYERSOLID & ~CONTENTS_BODY;
+	}
+	else if ( ent->r.svFlags & SVF_BOT ) {
+		pm.tracemask = MASK_PLAYERSOLID | CONTENTS_MONSTERCLIP;
+	}
+	else {
+		pm.tracemask = MASK_PLAYERSOLID;
+	}
+	pm.trace = trap_Trace;
+	pm.pointcontents = trap_PointContents;
+	pm.debugLevel = g_debugMove.integer;
+	pm.noFootsteps = ( g_dmflags.integer & DF_NO_FOOTSTEPS ) > 0;
+
+	pm.pmove_fixed = pmove_fixed.integer | client->pers.pmoveFixed;
+	pm.pmove_msec = pmove_msec.integer;
+
+	pm.animations = bgAllAnims[ent->localAnimIndex].anims;//NULL;
+
+	//rww - bgghoul2
+	pm.ghoul2 = NULL;
+
+#ifdef _DEBUG
+	if (g_disableServerG2.integer)
+	{
+
+	}
+	else
+#endif
+	if (ent->ghoul2)
+	{
+		if (ent->localAnimIndex > 1)
+		{ //if it isn't humanoid then we will be having none of this.
+			pm.ghoul2 = NULL;
+		}
+		else
+		{
+			pm.ghoul2 = ent->ghoul2;
+			pm.g2Bolts_LFoot = trap_G2API_AddBolt(ent->ghoul2, 0, "*l_leg_foot");
+			pm.g2Bolts_RFoot = trap_G2API_AddBolt(ent->ghoul2, 0, "*r_leg_foot");
+		}
+	}
+
+	//point the saber data to the right place
+#if 0
+	k = 0;
+	while (k < MAX_SABERS)
+	{
+		if (ent->client->saber[k].model[0])
+		{
+			pm.saber[k] = &ent->client->saber[k];
+		}
+		else
+		{
+			pm.saber[k] = NULL;
+		}
+		k++;
+	}
+#endif
+
+	//I'll just do this every frame in case the scale changes in realtime (don't need to update the g2 inst for that)
+	VectorCopy(ent->modelScale, pm.modelScale);
+	//rww end bgghoul2
+
+	pm.gametype = g_gametype.integer;
+	pm.debugMelee = g_debugMelee.integer;
+	pm.stepSlideFix = g_stepSlideFix.integer;
+
+	pm.noSpecMove = g_noSpecMove.integer;
+
+	pm.nonHumanoid = (ent->localAnimIndex > 0);
+
+	VectorCopy( client->ps.origin, client->oldOrigin );
+
+	/*
+	if (level.intermissionQueued != 0 && g_singlePlayer.integer) {
+		if ( level.time - level.intermissionQueued >= 1000  ) {
+			pm.cmd.buttons = 0;
+			pm.cmd.forwardmove = 0;
+			pm.cmd.rightmove = 0;
+			pm.cmd.upmove = 0;
+			if ( level.time - level.intermissionQueued >= 2000 && level.time - level.intermissionQueued <= 2500 ) {
+				trap_SendConsoleCommand( EXEC_APPEND, "centerview\n");
+			}
+			ent->client->ps.pm_type = PM_SPINTERMISSION;
+		}
+	}
+	*/
+
+	//Set up bg entity data
+	pm.baseEnt = (bgEntity_t *)g_entities;
+	pm.entSize = sizeof(gentity_t);
+
+	if (ent->client->ps.saberLockTime > level.time)
+	{
+		gentity_t *blockOpp = &g_entities[ent->client->ps.saberLockEnemy];
+
+		if (blockOpp && blockOpp->inuse && blockOpp->client)
+		{
+			vec3_t lockDir, lockAng;
+
+			//VectorClear( ent->client->ps.velocity );
+			VectorSubtract( blockOpp->r.currentOrigin, ent->r.currentOrigin, lockDir );
+			//lockAng[YAW] = vectoyaw( defDir );
+			vectoangles(lockDir, lockAng);
+			SetClientViewAngle( ent, lockAng );
+		}
+
+		if ( ent->client->ps.saberLockHitCheckTime < level.time )
+		{//have moved to next frame since last lock push
+			ent->client->ps.saberLockHitCheckTime = level.time;//so we don't push more than once per server frame
+			if ( ( ent->client->buttons & BUTTON_ATTACK ) && ! ( ent->client->oldbuttons & BUTTON_ATTACK ) )
+			{
+				if ( ent->client->ps.saberLockHitIncrementTime < level.time )
+				{//have moved to next frame since last saberlock attack button press
+					int lockHits = 0;
+					ent->client->ps.saberLockHitIncrementTime = level.time;//so we don't register an attack key press more than once per server frame
+					//NOTE: FP_SABER_OFFENSE level already taken into account in PM_SaberLocked
+					if ( (ent->client->ps.fd.forcePowersActive&(1<<FP_RAGE)) )
+					{//raging: push harder
+						lockHits = 1+ent->client->ps.fd.forcePowerLevel[FP_RAGE];
+					}
+					else
+					{//normal attack
+						switch ( ent->client->ps.fd.saberAnimLevel )
+						{
+						case SS_FAST:
+							lockHits = 1;
+							break;
+						case SS_MEDIUM:
+						case SS_TAVION:
+						case SS_DUAL:
+						case SS_STAFF:
+							lockHits = 2;
+							break;
+						case SS_STRONG:
+						case SS_DESANN:
+							lockHits = 3;
+							break;
+						}
+					}
+					if ( ent->client->ps.fd.forceRageRecoveryTime > level.time 
+						&& Q_irand( 0, 1 ) )
+					{//finished raging: weak
+						lockHits -= 1;
+					}
+					lockHits += ent->client->saber[0].lockBonus;
+					if ( ent->client->saber[1].model
+						&& ent->client->saber[1].model[0]
+						&& !ent->client->ps.saberHolstered )
+					{
+						lockHits += ent->client->saber[1].lockBonus;
+					}
+					ent->client->ps.saberLockHits += lockHits;
+					if ( g_saberLockRandomNess.integer )
+					{
+						ent->client->ps.saberLockHits += Q_irand( 0, g_saberLockRandomNess.integer );
+						if ( ent->client->ps.saberLockHits < 0 )
+						{
+							ent->client->ps.saberLockHits = 0;
+						}
+					}
+				}
+			}
+			if ( ent->client->ps.saberLockHits > 0 )
+			{
+				if ( !ent->client->ps.saberLockAdvance )
+				{
+					ent->client->ps.saberLockHits--;
+				}
+				ent->client->ps.saberLockAdvance = qtrue;
+			}
+		}
+	}
+	else
+	{
+		ent->client->ps.saberLockFrame = 0;
+		//check for taunt
+		if ( (pm.cmd.generic_cmd == GENCMD_ENGAGE_DUEL) && (g_gametype.integer == GT_DUEL || g_gametype.integer == GT_POWERDUEL) )
+		{//already in a duel, make it a taunt command
+			pm.cmd.buttons |= BUTTON_GESTURE;
+		}
+	}
+
+	if (ent->s.number >= MAX_CLIENTS)
+	{
+		VectorCopy(ent->r.mins, pm.mins);
+		VectorCopy(ent->r.maxs, pm.maxs);
+#if 1
+		if (ent->s.NPC_class == CLASS_VEHICLE &&
+			ent->m_pVehicle )
+		{
+			if ( ent->m_pVehicle->m_pPilot)
+			{ //vehicles want to use their last pilot ucmd I guess
+				if ((level.time - ent->m_pVehicle->m_ucmd.serverTime) > 2000)
+				{ //Previous owner disconnected, maybe
+					ent->m_pVehicle->m_ucmd.serverTime = level.time;
+					ent->client->ps.commandTime = level.time-100;
+					msec = 100;
+				}
+
+				memcpy(&pm.cmd, &ent->m_pVehicle->m_ucmd, sizeof(usercmd_t));
+				
+				//no veh can strafe
+				pm.cmd.rightmove = 0;
+				//no crouching or jumping!
+				pm.cmd.upmove = 0;
+
+				//NOTE: button presses were getting lost!
+				assert(g_entities[ent->m_pVehicle->m_pPilot->s.number].client);
+				pm.cmd.buttons = (g_entities[ent->m_pVehicle->m_pPilot->s.number].client->pers.cmd.buttons&(BUTTON_ATTACK|BUTTON_ALT_ATTACK));
+			}
+			if ( ent->m_pVehicle->m_pVehicleInfo->type == VH_WALKER )
+			{
+				if ( ent->client->ps.groundEntityNum != ENTITYNUM_NONE )
+				{//ATST crushes anything underneath it
+					gentity_t	*under = &g_entities[ent->client->ps.groundEntityNum];
+					if ( under && under->health && under->takedamage )
+					{
+						vec3_t	down = {0,0,-1};
+						//FIXME: we'll be doing traces down from each foot, so we'll have a real impact origin
+						G_Damage( under, ent, ent, down, under->r.currentOrigin, 100, 0, MOD_CRUSH );
+					}
+				}
+			}
+		}
+#endif
+	}
+
+	Pmove (&pm);
+
+	if (ent->client->solidHack)
+	{
+		if (ent->client->solidHack > level.time)
+		{ //whee!
+			ent->r.contents = 0;
+		}
+		else
+		{
+			ent->r.contents = CONTENTS_BODY;
+			ent->client->solidHack = 0;
+		}
+	}
+	
+	if ( ent->NPC )
+	{
+		VectorCopy( ent->client->ps.viewangles, ent->r.currentAngles );
+	}
+
+	if (pm.checkDuelLoss)
+	{
+		if (pm.checkDuelLoss > 0 && (pm.checkDuelLoss <= MAX_CLIENTS || (pm.checkDuelLoss < (MAX_GENTITIES-1) && g_entities[pm.checkDuelLoss-1].s.eType == ET_NPC) ) )
+		{
+			gentity_t *clientLost = &g_entities[pm.checkDuelLoss-1];
+
+			if (clientLost && clientLost->inuse && clientLost->client && Q_irand(0, 40) > clientLost->health)
+			{
+				vec3_t attDir;
+				VectorSubtract(ent->client->ps.origin, clientLost->client->ps.origin, attDir);
+				VectorNormalize(attDir);
+
+				VectorClear(clientLost->client->ps.velocity);
+				clientLost->client->ps.forceHandExtend = HANDEXTEND_NONE;
+				clientLost->client->ps.forceHandExtendTime = 0;
+
+				gGAvoidDismember = 1;
+				G_Damage(clientLost, ent, ent, attDir, clientLost->client->ps.origin, 9999, DAMAGE_NO_PROTECTION, MOD_SABER);
+
+				if (clientLost->health < 1)
+				{
+					gGAvoidDismember = 2;
+					G_CheckForDismemberment(clientLost, ent, clientLost->client->ps.origin, 999, (clientLost->client->ps.legsAnim), qfalse);
+				}
+
+				gGAvoidDismember = 0;
+			}
+			else if (clientLost && clientLost->inuse && clientLost->client &&
+				clientLost->client->ps.forceHandExtend != HANDEXTEND_KNOCKDOWN && clientLost->client->ps.saberEntityNum)
+			{ //if we didn't knock down it was a circle lock. So as punishment, make them lose their saber and go into a proper anim
+				saberCheckKnockdown_DuelLoss(&g_entities[clientLost->client->ps.saberEntityNum], clientLost, ent);
+			}
+		}
+
+		pm.checkDuelLoss = 0;
+	}
+
+	if (pm.cmd.generic_cmd &&
+		(pm.cmd.generic_cmd != ent->client->lastGenCmd || ent->client->lastGenCmdTime < level.time))
+	{
+		ent->client->lastGenCmd = pm.cmd.generic_cmd;
+		if (pm.cmd.generic_cmd != GENCMD_FORCE_THROW &&
+			pm.cmd.generic_cmd != GENCMD_FORCE_PULL)
+		{ //these are the only two where you wouldn't care about a delay between
+			ent->client->lastGenCmdTime = level.time + 300; //default 100ms debounce between issuing the same command.
+		}
+
+		switch(pm.cmd.generic_cmd)
+		{
+		case 0:
+			break;
+		case GENCMD_SABERSWITCH:
+			Cmd_ToggleSaber_f(ent);
+			break;
+		case GENCMD_ENGAGE_DUEL:
+			if ( g_gametype.integer == GT_DUEL || g_gametype.integer == GT_POWERDUEL )
+			{//already in a duel, made it a taunt command
+			}
+			else
+			{
+				Cmd_EngageDuel_f(ent);
+			}
+			break;
+		case GENCMD_FORCE_HEAL:
+			ForceHeal(ent);
+			break;
+		case GENCMD_FORCE_SPEED:
+			ForceSpeed(ent, 0);
+			break;
+		case GENCMD_FORCE_THROW:
+			ForceThrow(ent, qfalse);
+			break;
+		case GENCMD_FORCE_PULL:
+			ForceThrow(ent, qtrue);
+			break;
+		case GENCMD_FORCE_DISTRACT:
+			ForceTelepathy(ent);
+			break;
+		case GENCMD_FORCE_RAGE:
+			ForceRage(ent);
+			break;
+		case GENCMD_FORCE_PROTECT:
+			ForceProtect(ent);
+			break;
+		case GENCMD_FORCE_ABSORB:
+			ForceAbsorb(ent);
+			break;
+		case GENCMD_FORCE_HEALOTHER:
+			ForceTeamHeal(ent);
+			break;
+		case GENCMD_FORCE_FORCEPOWEROTHER:
+			ForceTeamForceReplenish(ent);
+			break;
+		case GENCMD_FORCE_SEEING:
+			ForceSeeing(ent);
+			break;
+		case GENCMD_USE_SEEKER:
+			if ( (ent->client->ps.stats[STAT_HOLDABLE_ITEMS] & (1 << HI_SEEKER)) &&
+				G_ItemUsable(&ent->client->ps, HI_SEEKER) )
+			{
+				ItemUse_Seeker(ent);
+				G_AddEvent(ent, EV_USE_ITEM0+HI_SEEKER, 0);
+				ent->client->ps.stats[STAT_HOLDABLE_ITEMS] &= ~(1 << HI_SEEKER);
+			}
+			break;
+		case GENCMD_USE_FIELD:
+			if ( (ent->client->ps.stats[STAT_HOLDABLE_ITEMS] & (1 << HI_SHIELD)) &&
+				G_ItemUsable(&ent->client->ps, HI_SHIELD) )
+			{
+				ItemUse_Shield(ent);
+				G_AddEvent(ent, EV_USE_ITEM0+HI_SHIELD, 0);
+				ent->client->ps.stats[STAT_HOLDABLE_ITEMS] &= ~(1 << HI_SHIELD);
+			}
+			break;
+		case GENCMD_USE_BACTA:
+			if ( (ent->client->ps.stats[STAT_HOLDABLE_ITEMS] & (1 << HI_MEDPAC)) &&
+				G_ItemUsable(&ent->client->ps, HI_MEDPAC) )
+			{
+				ItemUse_MedPack(ent);
+				G_AddEvent(ent, EV_USE_ITEM0+HI_MEDPAC, 0);
+				ent->client->ps.stats[STAT_HOLDABLE_ITEMS] &= ~(1 << HI_MEDPAC);
+			}
+			break;
+		case GENCMD_USE_BACTABIG:
+			if ( (ent->client->ps.stats[STAT_HOLDABLE_ITEMS] & (1 << HI_MEDPAC_BIG)) &&
+				G_ItemUsable(&ent->client->ps, HI_MEDPAC_BIG) )
+			{
+				ItemUse_MedPack_Big(ent);
+				G_AddEvent(ent, EV_USE_ITEM0+HI_MEDPAC_BIG, 0);
+				ent->client->ps.stats[STAT_HOLDABLE_ITEMS] &= ~(1 << HI_MEDPAC_BIG);
+			}
+			break;
+		case GENCMD_USE_ELECTROBINOCULARS:
+			if ( (ent->client->ps.stats[STAT_HOLDABLE_ITEMS] & (1 << HI_BINOCULARS)) &&
+				G_ItemUsable(&ent->client->ps, HI_BINOCULARS) )
+			{
+				ItemUse_Binoculars(ent);
+				if (ent->client->ps.zoomMode == 0)
+				{
+					G_AddEvent(ent, EV_USE_ITEM0+HI_BINOCULARS, 1);
+				}
+				else
+				{
+					G_AddEvent(ent, EV_USE_ITEM0+HI_BINOCULARS, 2);
+				}
+			}
+			break;
+		case GENCMD_ZOOM:
+			if ( (ent->client->ps.stats[STAT_HOLDABLE_ITEMS] & (1 << HI_BINOCULARS)) &&
+				G_ItemUsable(&ent->client->ps, HI_BINOCULARS) )
+			{
+				ItemUse_Binoculars(ent);
+				if (ent->client->ps.zoomMode == 0)
+				{
+					G_AddEvent(ent, EV_USE_ITEM0+HI_BINOCULARS, 1);
+				}
+				else
+				{
+					G_AddEvent(ent, EV_USE_ITEM0+HI_BINOCULARS, 2);
+				}
+			}
+			break;
+		case GENCMD_USE_SENTRY:
+			if ( (ent->client->ps.stats[STAT_HOLDABLE_ITEMS] & (1 << HI_SENTRY_GUN)) &&
+				G_ItemUsable(&ent->client->ps, HI_SENTRY_GUN) )
+			{
+				ItemUse_Sentry(ent);
+				G_AddEvent(ent, EV_USE_ITEM0+HI_SENTRY_GUN, 0);
+				ent->client->ps.stats[STAT_HOLDABLE_ITEMS] &= ~(1 << HI_SENTRY_GUN);
+			}
+			break;
+		case GENCMD_USE_JETPACK:
+			if ( (ent->client->ps.stats[STAT_HOLDABLE_ITEMS] & (1 << HI_JETPACK)) &&
+				G_ItemUsable(&ent->client->ps, HI_JETPACK) )
+			{
+				ItemUse_Jetpack(ent);
+				G_AddEvent(ent, EV_USE_ITEM0+HI_JETPACK, 0);
+				/*
+				if (ent->client->ps.zoomMode == 0)
+				{
+					G_AddEvent(ent, EV_USE_ITEM0+HI_BINOCULARS, 1);
+				}
+				else
+				{
+					G_AddEvent(ent, EV_USE_ITEM0+HI_BINOCULARS, 2);
+				}
+				*/
+			}
+			break;
+		case GENCMD_USE_HEALTHDISP:
+			if ( (ent->client->ps.stats[STAT_HOLDABLE_ITEMS] & (1 << HI_HEALTHDISP)) &&
+				G_ItemUsable(&ent->client->ps, HI_HEALTHDISP) )
+			{
+				//ItemUse_UseDisp(ent, HI_HEALTHDISP);
+				G_AddEvent(ent, EV_USE_ITEM0+HI_HEALTHDISP, 0);
+			}
+			break;
+		case GENCMD_USE_AMMODISP:
+			if ( (ent->client->ps.stats[STAT_HOLDABLE_ITEMS] & (1 << HI_AMMODISP)) &&
+				G_ItemUsable(&ent->client->ps, HI_AMMODISP) )
+			{
+				//ItemUse_UseDisp(ent, HI_AMMODISP);
+				G_AddEvent(ent, EV_USE_ITEM0+HI_AMMODISP, 0);
+			}
+			break;
+		case GENCMD_USE_EWEB:
+			if ( (ent->client->ps.stats[STAT_HOLDABLE_ITEMS] & (1 << HI_EWEB)) &&
+				G_ItemUsable(&ent->client->ps, HI_EWEB) )
+			{
+				ItemUse_UseEWeb(ent);
+				G_AddEvent(ent, EV_USE_ITEM0+HI_EWEB, 0);
+			}
+			break;
+		case GENCMD_USE_CLOAK:
+			if ( (ent->client->ps.stats[STAT_HOLDABLE_ITEMS] & (1 << HI_CLOAK)) &&
+				G_ItemUsable(&ent->client->ps, HI_CLOAK) )
+			{
+				if ( ent->client->ps.powerups[PW_CLOAKED] )
+				{//decloak
+					Jedi_Decloak( ent );
+				}
+				else
+				{//cloak
+					Jedi_Cloak( ent );
+				}
+			}
+			break;
+		case GENCMD_SABERATTACKCYCLE:
+			Cmd_SaberAttackCycle_f(ent);
+			break;
+		case GENCMD_TAUNT:
+			G_SetTauntAnim( ent, TAUNT_TAUNT );
+			break;
+		case GENCMD_BOW:
+			G_SetTauntAnim( ent, TAUNT_BOW );
+			break;
+		case GENCMD_MEDITATE:
+			G_SetTauntAnim( ent, TAUNT_MEDITATE );
+			break;
+		case GENCMD_FLOURISH:
+			G_SetTauntAnim( ent, TAUNT_FLOURISH );
+			break;
+		case GENCMD_GLOAT:
+			G_SetTauntAnim( ent, TAUNT_GLOAT );
+			break;
+		default:
+			break;
+		}
+	}
+
+	// save results of pmove
+	if ( ent->client->ps.eventSequence != oldEventSequence ) {
+		ent->eventTime = level.time;
+	}
+	if (g_smoothClients.integer) {
+		BG_PlayerStateToEntityStateExtraPolate( &ent->client->ps, &ent->s, ent->client->ps.commandTime, qfalse );
+		//rww - 12-03-02 - Don't snap the origin of players! It screws prediction all up.
+	}
+	else {
+		BG_PlayerStateToEntityState( &ent->client->ps, &ent->s, qfalse );
+	}
+
+	if (isNPC)
+	{
+		ent->s.eType = ET_NPC;
+	}
+
+	SendPendingPredictableEvents( &ent->client->ps );
+
+	if ( !( ent->client->ps.eFlags & EF_FIRING ) ) {
+		client->fireHeld = qfalse;		// for grapple
+	}
+
+	// use the snapped origin for linking so it matches client predicted versions
+	VectorCopy( ent->s.pos.trBase, ent->r.currentOrigin );
+
+	if (ent->s.eType != ET_NPC ||
+		ent->s.NPC_class != CLASS_VEHICLE ||
+		!ent->m_pVehicle ||
+		!ent->m_pVehicle->m_iRemovedSurfaces)
+	{ //let vehicles that are getting broken apart do their own crazy sizing stuff
+		VectorCopy (pm.mins, ent->r.mins);
+		VectorCopy (pm.maxs, ent->r.maxs);
+	}
+
+	ent->waterlevel = pm.waterlevel;
+	ent->watertype = pm.watertype;
+
+	// execute client events
+	ClientEvents( ent, oldEventSequence );
+
+	if ( pm.useEvent )
+	{
+		//TODO: Use
+//		TryUse( ent );
+	}
+	if ((ent->client->pers.cmd.buttons & BUTTON_USE) && ent->client->ps.useDelay < level.time)
+	{
+		TryUse(ent);
+		ent->client->ps.useDelay = level.time + 100;
+	}
+
+	// link entity now, after any personal teleporters have been used
+	trap_LinkEntity (ent);
+	if ( !ent->client->noclip ) {
+		G_TouchTriggers( ent );
+	}
+
+	// NOTE: now copy the exact origin over otherwise clients can be snapped into solid
+	VectorCopy( ent->client->ps.origin, ent->r.currentOrigin );
+
+	//test for solid areas in the AAS file
+//	BotTestAAS(ent->r.currentOrigin);
+
+	// touch other objects
+	ClientImpacts( ent, &pm );
+
+	// save results of triggers and client events
+	if (ent->client->ps.eventSequence != oldEventSequence) {
+		ent->eventTime = level.time;
+	}
+
+	// swap and latch button actions
+	client->oldbuttons = client->buttons;
+	client->buttons = ucmd->buttons;
+	client->latched_buttons |= client->buttons & ~client->oldbuttons;
+
+//	G_VehicleAttachDroidUnit( ent );
+
+	// Did we kick someone in our pmove sequence?
+	if (client->ps.forceKickFlip)
+	{
+		gentity_t *faceKicked = &g_entities[client->ps.forceKickFlip-1];
+
+		if (faceKicked && faceKicked->client && (!OnSameTeam(ent, faceKicked) || g_friendlyFire.integer) &&
+			(!faceKicked->client->ps.duelInProgress || faceKicked->client->ps.duelIndex == ent->s.number) &&
+			(!ent->client->ps.duelInProgress || ent->client->ps.duelIndex == faceKicked->s.number))
+		{
+			if ( faceKicked && faceKicked->client && faceKicked->health && faceKicked->takedamage )
+			{//push them away and do pain
+				vec3_t oppDir;
+				int strength = (int)VectorNormalize2( client->ps.velocity, oppDir );
+
+				strength *= 0.05;
+
+				VectorScale( oppDir, -1, oppDir );
+
+				G_Damage( faceKicked, ent, ent, oppDir, client->ps.origin, strength, DAMAGE_NO_ARMOR, MOD_MELEE );
+
+				if ( faceKicked->client->ps.weapon != WP_SABER ||
+					 faceKicked->client->ps.fd.saberAnimLevel != FORCE_LEVEL_3 ||
+					 (!BG_SaberInAttack(faceKicked->client->ps.saberMove) && !PM_SaberInStart(faceKicked->client->ps.saberMove) && !PM_SaberInReturn(faceKicked->client->ps.saberMove) && !PM_SaberInTransition(faceKicked->client->ps.saberMove)) )
+				{
+					if (faceKicked->health > 0 &&
+						faceKicked->client->ps.stats[STAT_HEALTH] > 0 &&
+						faceKicked->client->ps.forceHandExtend != HANDEXTEND_KNOCKDOWN)
+					{
+						if (BG_KnockDownable(&faceKicked->client->ps) && Q_irand(1, 10) <= 3)
+						{ //only actually knock over sometimes, but always do velocity hit
+							faceKicked->client->ps.forceHandExtend = HANDEXTEND_KNOCKDOWN;
+							faceKicked->client->ps.forceHandExtendTime = level.time + 1100;
+							faceKicked->client->ps.forceDodgeAnim = 0; //this toggles between 1 and 0, when it's 1 we should play the get up anim
+						}
+
+						faceKicked->client->ps.otherKiller = ent->s.number;
+						faceKicked->client->ps.otherKillerTime = level.time + 5000;
+						faceKicked->client->ps.otherKillerDebounceTime = level.time + 100;
+
+						faceKicked->client->ps.velocity[0] = oppDir[0]*(strength*40);
+						faceKicked->client->ps.velocity[1] = oppDir[1]*(strength*40);
+						faceKicked->client->ps.velocity[2] = 200;
+					}
+				}
+
+				G_Sound( faceKicked, CHAN_AUTO, G_SoundIndex( va("sound/weapons/melee/punch%d", Q_irand(1, 4)) ) );
+			}
+		}
+
+		client->ps.forceKickFlip = 0;
+	}
+
+	// check for respawning
+	if ( client->ps.stats[STAT_HEALTH] <= 0 
+		&& !(client->ps.eFlags2&EF2_HELD_BY_MONSTER)//can't respawn while being eaten
+		&& ent->s.eType != ET_NPC ) {
+		// wait for the attack button to be pressed
+		if ( level.time > client->respawnTime && !gDoSlowMoDuel ) {
+			// forcerespawn is to prevent users from waiting out powerups
+			int forceRes = g_forcerespawn.integer;
+
+			if (g_gametype.integer == GT_POWERDUEL)
+			{
+				forceRes = 1;
+			}
+			else if (g_gametype.integer == GT_SIEGE &&
+				g_siegeRespawn.integer)
+			{ //wave respawning on
+				forceRes = 1;
+			}
+
+			if ( forceRes > 0 && 
+				( level.time - client->respawnTime ) > forceRes * 1000 ) {
+				respawn( ent );
+				return;
+			}
+		
+			// pressing attack or use is the normal respawn method
+			if ( ucmd->buttons & ( BUTTON_ATTACK | BUTTON_USE_HOLDABLE ) ) {
+				respawn( ent );
+			}
+		}
+		else if (gDoSlowMoDuel)
+		{
+			client->respawnTime = level.time + 1000;
+		}
+		return;
+	}
+
+	// perform once-a-second actions
+	ClientTimerActions( ent, msec );
+
+	G_UpdateClientBroadcasts ( ent );
+
+	//try some idle anims on ent if getting no input and not moving for some time
+	G_CheckClientIdle( ent, ucmd );
+
+	// This code was moved here from clientThink to fix a problem with g_synchronousClients 
+	// being set to 1 when in vehicles. 
+	if ( ent->s.number < MAX_CLIENTS && ent->client->ps.m_iVehicleNum )
+	{//driving a vehicle
+		//run it
+		if (g_entities[ent->client->ps.m_iVehicleNum].inuse && g_entities[ent->client->ps.m_iVehicleNum].client)
+		{
+			ClientThink(ent->client->ps.m_iVehicleNum, &g_entities[ent->client->ps.m_iVehicleNum].m_pVehicle->m_ucmd);
+		}
+		else
+		{ //vehicle no longer valid?
+			ent->client->ps.m_iVehicleNum = 0;
+		}
+	}
+
+}
+
+/*
+==================
+G_CheckClientTimeouts
+
+Checks whether a client has exceded any timeouts and act accordingly
+==================
+*/
+void G_CheckClientTimeouts ( gentity_t *ent )
+{
+	// Only timeout supported right now is the timeout to spectator mode
+	if ( !g_timeouttospec.integer )
+	{
+		return;
+	}
+
+	// Already a spectator, no need to boot them to spectator
+	if ( ent->client->sess.sessionTeam == TEAM_SPECTATOR )
+	{
+		return;
+	}
+
+	// See how long its been since a command was received by the client and if its 
+	// longer than the timeout to spectator then force this client into spectator mode
+	if ( level.time - ent->client->pers.cmd.serverTime > g_timeouttospec.integer * 1000 )
+	{
+		SetTeam ( ent, "spectator" );
+	}
+}
+
+/*
+==================
+ClientThink
+
+A new command has arrived from the client
+==================
+*/
+void ClientThink( int clientNum,usercmd_t *ucmd ) {
+	gentity_t *ent;
+
+	ent = g_entities + clientNum;
+	if (clientNum < MAX_CLIENTS)
+	{
+		trap_GetUsercmd( clientNum, &ent->client->pers.cmd );
+	}
+
+	// mark the time we got info, so we can display the
+	// phone jack if they don't get any for a while
+	ent->client->lastCmdTime = level.time;
+
+	if (ucmd)
+	{
+		ent->client->pers.cmd = *ucmd;
+	}
+
+/* 	This was moved to clientthink_real, but since its sort of a risky change i left it here for 
+    now as a more concrete reference - BSD
+  
+	if ( clientNum < MAX_CLIENTS
+		&& ent->client->ps.m_iVehicleNum )
+	{//driving a vehicle
+		if (g_entities[ent->client->ps.m_iVehicleNum].client)
+		{
+			gentity_t *veh = &g_entities[ent->client->ps.m_iVehicleNum];
+
+			if (veh->m_pVehicle &&
+				veh->m_pVehicle->m_pPilot == (bgEntity_t *)ent)
+			{ //only take input from the pilot...
+				veh->client->ps.commandTime = ent->client->ps.commandTime;
+				memcpy(&veh->m_pVehicle->m_ucmd, &ent->client->pers.cmd, sizeof(usercmd_t));
+				if ( veh->m_pVehicle->m_ucmd.buttons & BUTTON_TALK )
+				{ //forced input if "chat bubble" is up
+					veh->m_pVehicle->m_ucmd.buttons = BUTTON_TALK;
+					veh->m_pVehicle->m_ucmd.forwardmove = 0;
+					veh->m_pVehicle->m_ucmd.rightmove = 0;
+					veh->m_pVehicle->m_ucmd.upmove = 0;
+				}
+			}
+		}
+	}
+*/
+	if ( !(ent->r.svFlags & SVF_BOT) && !g_synchronousClients.integer ) {
+		ClientThink_real( ent );
+	}
+	// vehicles are clients and when running synchronous they still need to think here
+	// so special case them.
+	else if ( clientNum >= MAX_CLIENTS ) {
+		ClientThink_real( ent );
+	}
+
+/*	This was moved to clientthink_real, but since its sort of a risky change i left it here for 
+    now as a more concrete reference - BSD
+    
+	if ( clientNum < MAX_CLIENTS
+		&& ent->client->ps.m_iVehicleNum )
+	{//driving a vehicle
+		//run it
+		if (g_entities[ent->client->ps.m_iVehicleNum].inuse &&
+			g_entities[ent->client->ps.m_iVehicleNum].client)
+		{
+			ClientThink(ent->client->ps.m_iVehicleNum, &g_entities[ent->client->ps.m_iVehicleNum].m_pVehicle->m_ucmd);
+		}
+		else
+		{ //vehicle no longer valid?
+			ent->client->ps.m_iVehicleNum = 0;
+		}
+	}
+*/
+}
+
+
+void G_RunClient( gentity_t *ent ) {
+	if ( !(ent->r.svFlags & SVF_BOT) && !g_synchronousClients.integer ) {
+		return;
+	}
+	ent->client->pers.cmd.serverTime = level.time;
+	ClientThink_real( ent );
+}
+
+
+/*
+==================
+SpectatorClientEndFrame
+
+==================
+*/
+void SpectatorClientEndFrame( gentity_t *ent ) {
+	gclient_t	*cl;
+
+	if (ent->s.eType == ET_NPC)
+	{
+		assert(0);
+		return;
+	}
+
+	// if we are doing a chase cam or a remote view, grab the latest info
+	if ( ent->client->sess.spectatorState == SPECTATOR_FOLLOW ) {
+		int		clientNum;//, flags;
+
+		clientNum = ent->client->sess.spectatorClient;
+
+		// team follow1 and team follow2 go to whatever clients are playing
+		if ( clientNum == -1 ) {
+			clientNum = level.follow1;
+		} else if ( clientNum == -2 ) {
+			clientNum = level.follow2;
+		}
+		if ( clientNum >= 0 ) {
+			cl = &level.clients[ clientNum ];
+			if ( cl->pers.connected == CON_CONNECTED && cl->sess.sessionTeam != TEAM_SPECTATOR ) {
+				//flags = (cl->mGameFlags & ~(PSG_VOTED | PSG_TEAMVOTED)) | (ent->client->mGameFlags & (PSG_VOTED | PSG_TEAMVOTED));
+				//ent->client->mGameFlags = flags;
+				ent->client->ps.eFlags = cl->ps.eFlags;
+				ent->client->ps = cl->ps;
+				ent->client->ps.pm_flags |= PMF_FOLLOW;
+				return;
+			} else {
+				// drop them to free spectators unless they are dedicated camera followers
+				if ( ent->client->sess.spectatorClient >= 0 ) {
+					ent->client->sess.spectatorState = SPECTATOR_FREE;
+					ClientBegin( ent->client - level.clients, qtrue );
+				}
+			}
+		}
+	}
+
+	if ( ent->client->sess.spectatorState == SPECTATOR_SCOREBOARD ) {
+		ent->client->ps.pm_flags |= PMF_SCOREBOARD;
+	} else {
+		ent->client->ps.pm_flags &= ~PMF_SCOREBOARD;
+	}
+}
+
+/*
+==============
+ClientEndFrame
+
+Called at the end of each server frame for each connected client
+A fast client will have multiple ClientThink for each ClientEdFrame,
+while a slow client may have multiple ClientEndFrame between ClientThink.
+==============
+*/
+void ClientEndFrame( gentity_t *ent ) {
+	int			i;
+	clientPersistant_t	*pers;
+	qboolean isNPC = qfalse;
+
+	if (ent->s.eType == ET_NPC)
+	{
+		isNPC = qtrue;
+	}
+
+	if ( ent->client->sess.sessionTeam == TEAM_SPECTATOR ) {
+		SpectatorClientEndFrame( ent );
+		return;
+	}
+
+	pers = &ent->client->pers;
+
+	// turn off any expired powerups
+	for ( i = 0 ; i < MAX_POWERUPS ; i++ ) {
+		if ( ent->client->ps.powerups[ i ] < level.time ) {
+			ent->client->ps.powerups[ i ] = 0;
+		}
+	}
+
+	// save network bandwidth
+#if 0
+	if ( !g_synchronousClients->integer && (ent->client->ps.pm_type == PM_NORMAL || ent->client->ps.pm_type == PM_JETPACK || ent->client->ps.pm_type == PM_FLOAT) ) {
+		// FIXME: this must change eventually for non-sync demo recording
+		VectorClear( ent->client->ps.viewangles );
+	}
+#endif
+
+	//
+	// If the end of unit layout is displayed, don't give
+	// the player any normal movement attributes
+	//
+	if ( level.intermissiontime ) {
+		return;
+	}
+
+	// burn from lava, etc
+	P_WorldEffects (ent);
+
+	// apply all the damage taken this frame
+	P_DamageFeedback (ent);
+
+	// add the EF_CONNECTION flag if we haven't gotten commands recently
+	if ( level.time - ent->client->lastCmdTime > 1000 ) {
+		ent->s.eFlags |= EF_CONNECTION;
+	} else {
+		ent->s.eFlags &= ~EF_CONNECTION;
+	}
+
+	ent->client->ps.stats[STAT_HEALTH] = ent->health;	// FIXME: get rid of ent->health...
+
+	G_SetClientSound (ent);
+
+	// set the latest infor
+	if (g_smoothClients.integer) {
+		BG_PlayerStateToEntityStateExtraPolate( &ent->client->ps, &ent->s, ent->client->ps.commandTime, qfalse );
+		//rww - 12-03-02 - Don't snap the origin of players! It screws prediction all up.
+	}
+	else {
+		BG_PlayerStateToEntityState( &ent->client->ps, &ent->s, qfalse );
+	}
+
+	if (isNPC)
+	{
+		ent->s.eType = ET_NPC;
+	}
+
+	SendPendingPredictableEvents( &ent->client->ps );
+
+	// set the bit for the reachability area the client is currently in
+//	i = trap_AAS_PointReachabilityAreaIndex( ent->client->ps.origin );
+//	ent->client->areabits[i >> 3] |= 1 << (i & 7);
+}
+
+
diff --git a/codemp/game/g_arenas.c b/codemp/game/g_arenas.c
new file mode 100644
index 0000000..fa6aebc
--- /dev/null
+++ b/codemp/game/g_arenas.c
@@ -0,0 +1,343 @@
+// Copyright (C) 1999-2000 Id Software, Inc.
+//
+//
+// g_arenas.c
+//
+
+#include "g_local.h"
+
+
+gentity_t	*podium1;
+gentity_t	*podium2;
+gentity_t	*podium3;
+
+
+/*
+==================
+UpdateTournamentInfo
+==================
+*/
+void UpdateTournamentInfo( void ) {
+	int			i;
+	gentity_t	*player;
+	int			playerClientNum;
+	int			n, accuracy, perfect,	msglen;
+	int			buflen;
+	int			score1, score2;
+	qboolean	won;
+	char		buf[32];
+	char		msg[MAX_STRING_CHARS];
+
+	// find the real player
+	player = NULL;
+	for (i = 0; i < level.maxclients; i++ ) {
+		player = &g_entities[i];
+		if ( !player->inuse ) {
+			continue;
+		}
+		if ( !( player->r.svFlags & SVF_BOT ) ) {
+			break;
+		}
+	}
+	// this should never happen!
+	if ( !player || i == level.maxclients ) {
+		return;
+	}
+	playerClientNum = i;
+
+	CalculateRanks();
+
+	if ( level.clients[playerClientNum].sess.sessionTeam == TEAM_SPECTATOR ) {
+		Com_sprintf( msg, sizeof(msg), "postgame %i %i 0 0 0 0 0 0 0 0 0 0 0", level.numNonSpectatorClients, playerClientNum );
+	}
+	else {
+		if( player->client->accuracy_shots ) {
+			accuracy = player->client->accuracy_hits * 100 / player->client->accuracy_shots;
+		}
+		else {
+			accuracy = 0;
+		}
+		won = qfalse;
+		if (g_gametype.integer >= GT_CTF) {
+			score1 = level.teamScores[TEAM_RED];
+			score2 = level.teamScores[TEAM_BLUE];
+			if (level.clients[playerClientNum].sess.sessionTeam	== TEAM_RED) {
+				won = (level.teamScores[TEAM_RED] > level.teamScores[TEAM_BLUE]);
+			} else {
+				won = (level.teamScores[TEAM_BLUE] > level.teamScores[TEAM_RED]);
+			}
+		} else {
+			if (&level.clients[playerClientNum] == &level.clients[ level.sortedClients[0] ]) {
+				won = qtrue;
+				score1 = level.clients[ level.sortedClients[0] ].ps.persistant[PERS_SCORE];
+				score2 = level.clients[ level.sortedClients[1] ].ps.persistant[PERS_SCORE];
+			} else {
+				score2 = level.clients[ level.sortedClients[0] ].ps.persistant[PERS_SCORE];
+				score1 = level.clients[ level.sortedClients[1] ].ps.persistant[PERS_SCORE];
+			}
+		}
+		if (won && player->client->ps.persistant[PERS_KILLED] == 0) {
+			perfect = 1;
+		} else {
+			perfect = 0;
+		}
+		Com_sprintf( msg, sizeof(msg), "postgame %i %i %i %i %i %i %i %i %i %i %i %i %i %i", level.numNonSpectatorClients, playerClientNum, accuracy,
+			player->client->ps.persistant[PERS_IMPRESSIVE_COUNT], player->client->ps.persistant[PERS_EXCELLENT_COUNT],player->client->ps.persistant[PERS_DEFEND_COUNT],
+			player->client->ps.persistant[PERS_ASSIST_COUNT], player->client->ps.persistant[PERS_GAUNTLET_FRAG_COUNT], player->client->ps.persistant[PERS_SCORE],
+			perfect, score1, score2, level.time, player->client->ps.persistant[PERS_CAPTURES] );
+	}
+
+	msglen = strlen( msg );
+	for( i = 0; i < level.numNonSpectatorClients; i++ ) {
+		n = level.sortedClients[i];
+		Com_sprintf( buf, sizeof(buf), " %i %i %i", n, level.clients[n].ps.persistant[PERS_RANK], level.clients[n].ps.persistant[PERS_SCORE] );
+		buflen = strlen( buf );
+		if( msglen + buflen + 1 >= sizeof(msg) ) {
+			break;
+		}
+		strcat( msg, buf );
+	}
+	trap_SendConsoleCommand( EXEC_APPEND, msg );
+}
+
+
+/*
+static gentity_t *SpawnModelOnVictoryPad( gentity_t *pad, vec3_t offset, gentity_t *ent, int place ) {
+	gentity_t	*body;
+	vec3_t		vec;
+	vec3_t		f, r, u;
+
+	body = G_Spawn();
+	if ( !body ) {
+		G_Printf( S_COLOR_RED "ERROR: out of gentities\n" );
+		return NULL;
+	}
+
+	body->classname = ent->client->pers.netname;
+	body->client = ent->client;
+	body->s = ent->s;
+	body->s.eType = ET_PLAYER;		// could be ET_INVISIBLE
+	body->s.eFlags = 0;				// clear EF_TALK, etc
+	body->s.powerups = 0;			// clear powerups
+	body->s.loopSound = 0;			// clear lava burning
+	body->s.number = body - g_entities;
+	body->timestamp = level.time;
+	body->physicsObject = qtrue;
+	body->physicsBounce = 0;		// don't bounce
+	body->s.event = 0;
+	body->s.pos.trType = TR_STATIONARY;
+	body->s.groundEntityNum = ENTITYNUM_WORLD;
+	body->s.legsAnim = WeaponReadyAnim[ent->s.weapon];
+	body->s.torsoAnim = WeaponReadyAnim[ent->s.weapon];
+	if( body->s.weapon == WP_NONE ) {
+		body->s.weapon = WP_BRYAR_PISTOL;
+	}
+	if( body->s.weapon == WP_SABER) {
+		body->s.torsoAnim = BOTH_STAND2;
+	}
+	body->s.event = 0;
+	body->r.svFlags = ent->r.svFlags;
+	VectorCopy (ent->r.mins, body->r.mins);
+	VectorCopy (ent->r.maxs, body->r.maxs);
+	VectorCopy (ent->r.absmin, body->r.absmin);
+	VectorCopy (ent->r.absmax, body->r.absmax);
+	body->clipmask = CONTENTS_SOLID | CONTENTS_PLAYERCLIP;
+	body->r.contents = CONTENTS_BODY;
+	body->r.ownerNum = ent->r.ownerNum;
+	body->takedamage = qfalse;
+
+	VectorSubtract( level.intermission_origin, pad->r.currentOrigin, vec );
+	vectoangles( vec, body->s.apos.trBase );
+	body->s.apos.trBase[PITCH] = 0;
+	body->s.apos.trBase[ROLL] = 0;
+
+	AngleVectors( body->s.apos.trBase, f, r, u );
+	VectorMA( pad->r.currentOrigin, offset[0], f, vec );
+	VectorMA( vec, offset[1], r, vec );
+	VectorMA( vec, offset[2], u, vec );
+
+	G_SetOrigin( body, vec );
+
+	trap_LinkEntity (body);
+
+	body->count = place;
+
+	return body;
+}
+
+
+static void CelebrateStop( gentity_t *player ) {
+	int		anim;
+
+	if( player->s.weapon == WP_SABER) {
+		anim = BOTH_STAND2;
+	}
+	else {
+		anim = WeaponReadyAnim[player->s.weapon];
+	}
+	player->s.torsoAnim = ( ( player->s.torsoAnim & ANIM_TOGGLEBIT ) ^ ANIM_TOGGLEBIT ) | anim;
+}
+
+
+#define	TIMER_GESTURE	(34*66+50)
+static void CelebrateStart( gentity_t *player ) {
+	player->s.torsoAnim = ( ( player->s.torsoAnim & ANIM_TOGGLEBIT ) ^ ANIM_TOGGLEBIT ) | BOTH_TALKGESTURE1;
+	player->nextthink = level.time + TIMER_GESTURE;
+	player->think = CelebrateStop;
+
+	
+//	player->client->ps.events[player->client->ps.eventSequence & (MAX_PS_EVENTS-1)] = EV_TAUNT;
+//	player->client->ps.eventParms[player->client->ps.eventSequence & (MAX_PS_EVENTS-1)] = 0;
+//	player->client->ps.eventSequence++;
+	
+	G_AddEvent(player, EV_TAUNT, 0);
+}
+
+
+static vec3_t	offsetFirst  = {0, 0, 74};
+static vec3_t	offsetSecond = {-10, 60, 54};
+static vec3_t	offsetThird  = {-19, -60, 45};
+
+static void PodiumPlacementThink( gentity_t *podium ) {
+	vec3_t		vec;
+	vec3_t		origin;
+	vec3_t		f, r, u;
+
+	podium->nextthink = level.time + 100;
+
+	AngleVectors( level.intermission_angle, vec, NULL, NULL );
+	VectorMA( level.intermission_origin, trap_Cvar_VariableIntegerValue( "g_podiumDist" ), vec, origin );
+	origin[2] -= trap_Cvar_VariableIntegerValue( "g_podiumDrop" );
+	G_SetOrigin( podium, origin );
+
+	if( podium1 ) {
+		VectorSubtract( level.intermission_origin, podium->r.currentOrigin, vec );
+		vectoangles( vec, podium1->s.apos.trBase );
+		podium1->s.apos.trBase[PITCH] = 0;
+		podium1->s.apos.trBase[ROLL] = 0;
+
+		AngleVectors( podium1->s.apos.trBase, f, r, u );
+		VectorMA( podium->r.currentOrigin, offsetFirst[0], f, vec );
+		VectorMA( vec, offsetFirst[1], r, vec );
+		VectorMA( vec, offsetFirst[2], u, vec );
+
+		G_SetOrigin( podium1, vec );
+	}
+
+	if( podium2 ) {
+		VectorSubtract( level.intermission_origin, podium->r.currentOrigin, vec );
+		vectoangles( vec, podium2->s.apos.trBase );
+		podium2->s.apos.trBase[PITCH] = 0;
+		podium2->s.apos.trBase[ROLL] = 0;
+
+		AngleVectors( podium2->s.apos.trBase, f, r, u );
+		VectorMA( podium->r.currentOrigin, offsetSecond[0], f, vec );
+		VectorMA( vec, offsetSecond[1], r, vec );
+		VectorMA( vec, offsetSecond[2], u, vec );
+
+		G_SetOrigin( podium2, vec );
+	}
+
+	if( podium3 ) {
+		VectorSubtract( level.intermission_origin, podium->r.currentOrigin, vec );
+		vectoangles( vec, podium3->s.apos.trBase );
+		podium3->s.apos.trBase[PITCH] = 0;
+		podium3->s.apos.trBase[ROLL] = 0;
+
+		AngleVectors( podium3->s.apos.trBase, f, r, u );
+		VectorMA( podium->r.currentOrigin, offsetThird[0], f, vec );
+		VectorMA( vec, offsetThird[1], r, vec );
+		VectorMA( vec, offsetThird[2], u, vec );
+
+		G_SetOrigin( podium3, vec );
+	}
+}
+
+
+static gentity_t *SpawnPodium( void ) {
+	gentity_t	*podium;
+	vec3_t		vec;
+	vec3_t		origin;
+
+	podium = G_Spawn();
+	if ( !podium ) {
+		return NULL;
+	}
+
+	podium->classname = "podium";
+	podium->s.eType = ET_GENERAL;
+	podium->s.number = podium - g_entities;
+	podium->clipmask = CONTENTS_SOLID;
+	podium->r.contents = CONTENTS_SOLID;
+	podium->s.modelindex = G_ModelIndex( SP_PODIUM_MODEL );
+
+	AngleVectors( level.intermission_angle, vec, NULL, NULL );
+	VectorMA( level.intermission_origin, trap_Cvar_VariableIntegerValue( "g_podiumDist" ), vec, origin );
+	origin[2] -= trap_Cvar_VariableIntegerValue( "g_podiumDrop" );
+	G_SetOrigin( podium, origin );
+
+	VectorSubtract( level.intermission_origin, podium->r.currentOrigin, vec );
+	podium->s.apos.trBase[YAW] = vectoyaw( vec );
+	trap_LinkEntity (podium);
+
+	podium->think = PodiumPlacementThink;
+	podium->nextthink = level.time + 100;
+	return podium;
+}
+
+
+
+//==================
+//SpawnModelsOnVictoryPads
+//==================
+
+void SpawnModelsOnVictoryPads( void ) {
+	gentity_t	*player;
+	gentity_t	*podium;
+
+	podium1 = NULL;
+	podium2 = NULL;
+	podium3 = NULL;
+
+	podium = SpawnPodium();
+
+	player = SpawnModelOnVictoryPad( podium, offsetFirst, &g_entities[level.sortedClients[0]],
+				level.clients[ level.sortedClients[0] ].ps.persistant[PERS_RANK] &~ RANK_TIED_FLAG );
+	if ( player ) {
+		player->nextthink = level.time + 2000;
+		player->think = CelebrateStart;
+		podium1 = player;
+	}
+
+	player = SpawnModelOnVictoryPad( podium, offsetSecond, &g_entities[level.sortedClients[1]],
+				level.clients[ level.sortedClients[1] ].ps.persistant[PERS_RANK] &~ RANK_TIED_FLAG );
+	if ( player ) {
+		podium2 = player;
+	}
+
+	if ( level.numNonSpectatorClients > 2 ) {
+		player = SpawnModelOnVictoryPad( podium, offsetThird, &g_entities[level.sortedClients[2]],
+				level.clients[ level.sortedClients[2] ].ps.persistant[PERS_RANK] &~ RANK_TIED_FLAG );
+		if ( player ) {
+			podium3 = player;
+		}
+	}
+}
+
+
+
+//===============
+//Svcmd_AbortPodium_f
+//===============
+
+void Svcmd_AbortPodium_f( void ) {
+	if( g_gametype.integer != GT_SINGLE_PLAYER ) {
+		return;
+	}
+
+	if( podium1 ) {
+		podium1->nextthink = level.time;
+		podium1->think = CelebrateStop;
+	}
+}
+*/
\ No newline at end of file
diff --git a/codemp/game/g_bot.c b/codemp/game/g_bot.c
new file mode 100644
index 0000000..c54e25d
--- /dev/null
+++ b/codemp/game/g_bot.c
@@ -0,0 +1,1308 @@
+// Copyright (C) 1999-2000 Id Software, Inc.
+//
+// g_bot.c
+
+#include "g_local.h"
+
+
+static int		g_numBots;
+static char		*g_botInfos[MAX_BOTS];
+
+
+int				g_numArenas;
+static char		*g_arenaInfos[MAX_ARENAS];
+
+
+#define BOT_BEGIN_DELAY_BASE		2000
+#define BOT_BEGIN_DELAY_INCREMENT	1500
+
+#define BOT_SPAWN_QUEUE_DEPTH	16
+
+typedef struct {
+	int		clientNum;
+	int		spawnTime;
+} botSpawnQueue_t;
+
+//static int			botBeginDelay = 0;  // bk001206 - unused, init
+static botSpawnQueue_t	botSpawnQueue[BOT_SPAWN_QUEUE_DEPTH];
+
+vmCvar_t bot_minplayers;
+
+extern gentity_t	*podium1;
+extern gentity_t	*podium2;
+extern gentity_t	*podium3;
+
+#include "../namespace_begin.h"
+float trap_Cvar_VariableValue( const char *var_name ) {
+	char buf[128];
+
+	trap_Cvar_VariableStringBuffer(var_name, buf, sizeof(buf));
+	return atof(buf);
+}
+#include "../namespace_end.h"
+
+
+/*
+===============
+G_ParseInfos
+===============
+*/
+int G_ParseInfos( char *buf, int max, char *infos[] ) {
+	char	*token;
+	int		count;
+	char	key[MAX_TOKEN_CHARS];
+	char	info[MAX_INFO_STRING];
+
+	count = 0;
+
+	while ( 1 ) {
+		token = COM_Parse( (const char **)(&buf) );
+		if ( !token[0] ) {
+			break;
+		}
+		if ( strcmp( token, "{" ) ) {
+			Com_Printf( "Missing { in info file\n" );
+			break;
+		}
+
+		if ( count == max ) {
+			Com_Printf( "Max infos exceeded\n" );
+			break;
+		}
+
+		info[0] = '\0';
+		while ( 1 ) {
+			token = COM_ParseExt( (const char **)(&buf), qtrue );
+			if ( !token[0] ) {
+				Com_Printf( "Unexpected end of info file\n" );
+				break;
+			}
+			if ( !strcmp( token, "}" ) ) {
+				break;
+			}
+			Q_strncpyz( key, token, sizeof( key ) );
+
+			token = COM_ParseExt( (const char **)(&buf), qfalse );
+			if ( !token[0] ) {
+				strcpy( token, "<NULL>" );
+			}
+			Info_SetValueForKey( info, key, token );
+		}
+		//NOTE: extra space for arena number
+		infos[count] = (char *) G_Alloc(strlen(info) + strlen("\\num\\") + strlen(va("%d", MAX_ARENAS)) + 1);
+		if (infos[count]) {
+			strcpy(infos[count], info);
+			count++;
+		}
+	}
+	return count;
+}
+
+/*
+===============
+G_LoadArenasFromFile
+===============
+*/
+static void G_LoadArenasFromFile( char *filename ) {
+	int				len;
+	fileHandle_t	f;
+	char			buf[MAX_ARENAS_TEXT];
+
+	len = trap_FS_FOpenFile( filename, &f, FS_READ );
+	if ( !f ) {
+		trap_Printf( va( S_COLOR_RED "file not found: %s\n", filename ) );
+		return;
+	}
+	if ( len >= MAX_ARENAS_TEXT ) {
+		trap_Printf( va( S_COLOR_RED "file too large: %s is %i, max allowed is %i", filename, len, MAX_ARENAS_TEXT ) );
+		trap_FS_FCloseFile( f );
+		return;
+	}
+
+	trap_FS_Read( buf, len, f );
+	buf[len] = 0;
+	trap_FS_FCloseFile( f );
+
+	g_numArenas += G_ParseInfos( buf, MAX_ARENAS - g_numArenas, &g_arenaInfos[g_numArenas] );
+}
+
+int G_GetMapTypeBits(char *type)
+{
+	int typeBits = 0;
+
+	if( *type ) {
+		if( strstr( type, "ffa" ) ) {
+			typeBits |= (1 << GT_FFA);
+			typeBits |= (1 << GT_TEAM);
+		}
+		if( strstr( type, "holocron" ) ) {
+			typeBits |= (1 << GT_HOLOCRON);
+		}
+		if( strstr( type, "jedimaster" ) ) {
+			typeBits |= (1 << GT_JEDIMASTER);
+		}
+		if( strstr( type, "duel" ) ) {
+			typeBits |= (1 << GT_DUEL);
+			typeBits |= (1 << GT_POWERDUEL);
+		}
+		if( strstr( type, "powerduel" ) ) {
+			typeBits |= (1 << GT_DUEL);
+			typeBits |= (1 << GT_POWERDUEL);
+		}
+		if( strstr( type, "siege" ) ) {
+			typeBits |= (1 << GT_SIEGE);
+		}
+		if( strstr( type, "ctf" ) ) {
+			typeBits |= (1 << GT_CTF);
+		}
+		if( strstr( type, "cty" ) ) {
+			typeBits |= (1 << GT_CTY);
+		}
+	} else {
+		typeBits |= (1 << GT_FFA);
+	}
+
+	return typeBits;
+}
+
+qboolean G_DoesMapSupportGametype(const char *mapname, int gametype)
+{
+	int			typeBits = 0;
+	int			thisLevel = -1;
+	int			n = 0;
+	char		*type = NULL;
+
+	if (!g_arenaInfos[0])
+	{
+		return qfalse;
+	}
+
+	if (!mapname || !mapname[0])
+	{
+		return qfalse;
+	}
+
+	for( n = 0; n < g_numArenas; n++ )
+	{
+		type = Info_ValueForKey( g_arenaInfos[n], "map" );
+
+		if (Q_stricmp(mapname, type) == 0)
+		{
+			thisLevel = n;
+			break;
+		}
+	}
+
+	if (thisLevel == -1)
+	{
+		return qfalse;
+	}
+
+	type = Info_ValueForKey(g_arenaInfos[thisLevel], "type");
+
+	typeBits = G_GetMapTypeBits(type);
+	if (typeBits & (1 << gametype))
+	{ //the map in question supports the gametype in question, so..
+		return qtrue;
+	}
+
+	return qfalse;
+}
+
+//rww - auto-obtain nextmap. I could've sworn Q3 had something like this, but I guess not.
+const char *G_RefreshNextMap(int gametype, qboolean forced)
+{
+	int			typeBits = 0;
+	int			thisLevel = 0;
+	int			desiredMap = 0;
+	int			n = 0;
+	char		*type = NULL;
+	qboolean	loopingUp = qfalse;
+	vmCvar_t	mapname;
+
+	if (!g_autoMapCycle.integer && !forced)
+	{
+		return NULL;
+	}
+
+	if (!g_arenaInfos[0])
+	{
+		return NULL;
+	}
+
+	trap_Cvar_Register( &mapname, "mapname", "", CVAR_SERVERINFO | CVAR_ROM );
+	for( n = 0; n < g_numArenas; n++ )
+	{
+		type = Info_ValueForKey( g_arenaInfos[n], "map" );
+
+		if (Q_stricmp(mapname.string, type) == 0)
+		{
+			thisLevel = n;
+			break;
+		}
+	}
+
+	desiredMap = thisLevel;
+
+	n = thisLevel+1;
+	while (n != thisLevel)
+	{ //now cycle through the arena list and find the next map that matches the gametype we're in
+		if (!g_arenaInfos[n] || n >= g_numArenas)
+		{
+			if (loopingUp)
+			{ //this shouldn't happen, but if it does we have a null entry break in the arena file
+			  //if this is the case just break out of the loop instead of sticking in an infinite loop
+				break;
+			}
+			n = 0;
+			loopingUp = qtrue;
+		}
+
+		type = Info_ValueForKey(g_arenaInfos[n], "type");
+		
+		typeBits = G_GetMapTypeBits(type);
+		if (typeBits & (1 << gametype))
+		{
+			desiredMap = n;
+			break;
+		}
+
+		n++;
+	}
+
+	if (desiredMap == thisLevel)
+	{ //If this is the only level for this game mode or we just can't find a map for this game mode, then nextmap
+	  //will always restart.
+		trap_Cvar_Set( "nextmap", "map_restart 0");
+	}
+	else
+	{ //otherwise we have a valid nextmap to cycle to, so use it.
+		type = Info_ValueForKey( g_arenaInfos[desiredMap], "map" );
+		trap_Cvar_Set( "nextmap", va("map %s", type));
+	}
+
+	return Info_ValueForKey( g_arenaInfos[desiredMap], "map" );
+}
+
+/*
+===============
+G_LoadArenas
+===============
+*/
+static void G_LoadArenas( void ) {
+	int			numdirs;
+	char		filename[128];
+	char		dirlist[1024];
+	char*		dirptr;
+	int			i, n;
+	int			dirlen;
+
+	g_numArenas = 0;
+
+	// get all arenas from .arena files
+	numdirs = trap_FS_GetFileList("scripts", ".arena", dirlist, 1024 );
+	dirptr  = dirlist;
+	for (i = 0; i < numdirs; i++, dirptr += dirlen+1) {
+		dirlen = strlen(dirptr);
+		strcpy(filename, "scripts/");
+		strcat(filename, dirptr);
+		G_LoadArenasFromFile(filename);
+	}
+//	trap_Printf( va( "%i arenas parsed\n", g_numArenas ) );
+	
+	for( n = 0; n < g_numArenas; n++ ) {
+		Info_SetValueForKey( g_arenaInfos[n], "num", va( "%i", n ) );
+	}
+
+	G_RefreshNextMap(g_gametype.integer, qfalse);
+}
+
+
+/*
+===============
+G_GetArenaInfoByNumber
+===============
+*/
+const char *G_GetArenaInfoByMap( const char *map ) {
+	int			n;
+
+	for( n = 0; n < g_numArenas; n++ ) {
+		if( Q_stricmp( Info_ValueForKey( g_arenaInfos[n], "map" ), map ) == 0 ) {
+			return g_arenaInfos[n];
+		}
+	}
+
+	return NULL;
+}
+
+#if 0
+/*
+=================
+PlayerIntroSound
+=================
+*/
+static void PlayerIntroSound( const char *modelAndSkin ) {
+	char	model[MAX_QPATH];
+	char	*skin;
+
+	Q_strncpyz( model, modelAndSkin, sizeof(model) );
+	skin = Q_strrchr( model, '/' );
+	if ( skin ) {
+		*skin++ = '\0';
+	}
+	else {
+		skin = model;
+	}
+
+	if( Q_stricmp( skin, "default" ) == 0 ) {
+		skin = model;
+	}
+
+	trap_SendConsoleCommand( EXEC_APPEND, va( "play sound/player/announce/%s.wav\n", skin ) );
+}
+#endif
+
+/*
+===============
+G_AddRandomBot
+===============
+*/
+void G_AddRandomBot( int team ) {
+	int		i, n, num;
+	float	skill;
+	char	*value, netname[36], *teamstr;
+	gclient_t	*cl;
+
+	num = 0;
+	for ( n = 0; n < g_numBots ; n++ ) {
+		value = Info_ValueForKey( g_botInfos[n], "name" );
+		//
+		for ( i=0 ; i< g_maxclients.integer ; i++ ) {
+			cl = level.clients + i;
+			if ( cl->pers.connected != CON_CONNECTED ) {
+				continue;
+			}
+			if ( !(g_entities[cl->ps.clientNum].r.svFlags & SVF_BOT) ) {
+				continue;
+			}
+			if (g_gametype.integer == GT_SIEGE)
+			{
+				if ( team >= 0 && cl->sess.siegeDesiredTeam != team ) {
+					continue;
+				}
+			}
+			else
+			{
+				if ( team >= 0 && cl->sess.sessionTeam != team ) {
+					continue;
+				}
+			}
+			if ( !Q_stricmp( value, cl->pers.netname ) ) {
+				break;
+			}
+		}
+		if (i >= g_maxclients.integer) {
+			num++;
+		}
+	}
+	num = random() * num;
+	for ( n = 0; n < g_numBots ; n++ ) {
+		value = Info_ValueForKey( g_botInfos[n], "name" );
+		//
+		for ( i=0 ; i< g_maxclients.integer ; i++ ) {
+			cl = level.clients + i;
+			if ( cl->pers.connected != CON_CONNECTED ) {
+				continue;
+			}
+			if ( !(g_entities[cl->ps.clientNum].r.svFlags & SVF_BOT) ) {
+				continue;
+			}
+			if (g_gametype.integer == GT_SIEGE)
+			{
+				if ( team >= 0 && cl->sess.siegeDesiredTeam != team ) {
+					continue;
+				}
+			}
+			else
+			{
+				if ( team >= 0 && cl->sess.sessionTeam != team ) {
+					continue;
+				}
+			}
+			if ( !Q_stricmp( value, cl->pers.netname ) ) {
+				break;
+			}
+		}
+		if (i >= g_maxclients.integer) {
+			num--;
+			if (num <= 0) {
+				skill = trap_Cvar_VariableValue( "g_spSkill" );
+				if (team == TEAM_RED) teamstr = "red";
+				else if (team == TEAM_BLUE) teamstr = "blue";
+				else teamstr = "";
+				strncpy(netname, value, sizeof(netname)-1);
+				netname[sizeof(netname)-1] = '\0';
+				Q_CleanStr(netname);
+				trap_SendConsoleCommand( EXEC_INSERT, va("addbot \"%s\" %f %s %i\n", netname, skill, teamstr, 0) );
+				return;
+			}
+		}
+	}
+}
+
+/*
+===============
+G_RemoveRandomBot
+===============
+*/
+int G_RemoveRandomBot( int team ) {
+	int i;
+	char netname[36];
+	gclient_t	*cl;
+
+	for ( i=0 ; i< g_maxclients.integer ; i++ ) {
+		cl = level.clients + i;
+		if ( cl->pers.connected != CON_CONNECTED ) {
+			continue;
+		}
+		if ( !(g_entities[cl->ps.clientNum].r.svFlags & SVF_BOT) ) {
+			continue;
+		}
+		if (g_gametype.integer == GT_SIEGE)
+		{
+			if ( team >= 0 && cl->sess.siegeDesiredTeam != team ) {
+				continue;
+			}
+		}
+		else
+		{
+			if ( team >= 0 && cl->sess.sessionTeam != team ) {
+				continue;
+			}
+		}
+		strcpy(netname, cl->pers.netname);
+		Q_CleanStr(netname);
+		trap_SendConsoleCommand( EXEC_INSERT, va("kick \"%s\"\n", netname) );
+		return qtrue;
+	}
+	return qfalse;
+}
+
+/*
+===============
+G_CountHumanPlayers
+===============
+*/
+int G_CountHumanPlayers( int team ) {
+	int i, num;
+	gclient_t	*cl;
+
+	num = 0;
+	for ( i=0 ; i< g_maxclients.integer ; i++ ) {
+		cl = level.clients + i;
+		if ( cl->pers.connected != CON_CONNECTED ) {
+			continue;
+		}
+		if ( g_entities[cl->ps.clientNum].r.svFlags & SVF_BOT ) {
+			continue;
+		}
+		if ( team >= 0 && cl->sess.sessionTeam != team ) {
+			continue;
+		}
+		num++;
+	}
+	return num;
+}
+
+/*
+===============
+G_CountBotPlayers
+===============
+*/
+int G_CountBotPlayers( int team ) {
+	int i, n, num;
+	gclient_t	*cl;
+
+	num = 0;
+	for ( i=0 ; i< g_maxclients.integer ; i++ ) {
+		cl = level.clients + i;
+		if ( cl->pers.connected != CON_CONNECTED ) {
+			continue;
+		}
+		if ( !(g_entities[cl->ps.clientNum].r.svFlags & SVF_BOT) ) {
+			continue;
+		}
+		if (g_gametype.integer == GT_SIEGE)
+		{
+			if ( team >= 0 && cl->sess.siegeDesiredTeam != team ) {
+				continue;
+			}
+		}
+		else
+		{
+			if ( team >= 0 && cl->sess.sessionTeam != team ) {
+				continue;
+			}
+		}
+		num++;
+	}
+	for( n = 0; n < BOT_SPAWN_QUEUE_DEPTH; n++ ) {
+		if( !botSpawnQueue[n].spawnTime ) {
+			continue;
+		}
+		if ( botSpawnQueue[n].spawnTime > level.time ) {
+			continue;
+		}
+		num++;
+	}
+	return num;
+}
+
+/*
+===============
+G_CheckMinimumPlayers
+===============
+*/
+void G_CheckMinimumPlayers( void ) {
+	int minplayers;
+	int humanplayers, botplayers;
+	static int checkminimumplayers_time;
+
+	if (g_gametype.integer == GT_SIEGE)
+	{
+		return;
+	}
+
+	if (level.intermissiontime) return;
+	//only check once each 10 seconds
+	if (checkminimumplayers_time > level.time - 10000) {
+		return;
+	}
+	checkminimumplayers_time = level.time;
+	trap_Cvar_Update(&bot_minplayers);
+	minplayers = bot_minplayers.integer;
+	if (minplayers <= 0) return;
+
+	if (minplayers > g_maxclients.integer)
+	{
+		minplayers = g_maxclients.integer;
+	}
+
+	humanplayers = G_CountHumanPlayers( -1 );
+	botplayers = G_CountBotPlayers(	-1 );
+
+	if ((humanplayers+botplayers) < minplayers)
+	{
+		G_AddRandomBot(-1);
+	}
+	else if ((humanplayers+botplayers) > minplayers && botplayers)
+	{
+		// try to remove spectators first
+		if (!G_RemoveRandomBot(TEAM_SPECTATOR))
+		{
+			// just remove the bot that is playing
+			G_RemoveRandomBot(-1);
+		}
+	}
+
+	/*
+	if (g_gametype.integer >= GT_TEAM) {
+		int humanplayers2, botplayers2;
+		if (minplayers >= g_maxclients.integer / 2) {
+			minplayers = (g_maxclients.integer / 2) -1;
+		}
+
+		humanplayers = G_CountHumanPlayers( TEAM_RED );
+		botplayers = G_CountBotPlayers(	TEAM_RED );
+		humanplayers2 = G_CountHumanPlayers( TEAM_BLUE );
+		botplayers2 = G_CountBotPlayers( TEAM_BLUE );
+		//
+		if ((humanplayers+botplayers+humanplayers2+botplayers) < minplayers)
+		{
+			if ((humanplayers+botplayers) < (humanplayers2+botplayers2))
+			{
+				G_AddRandomBot( TEAM_RED );
+			}
+			else
+			{
+				G_AddRandomBot( TEAM_BLUE );
+			}
+		}
+		else if ((humanplayers+botplayers+humanplayers2+botplayers) > minplayers && botplayers)
+		{
+			if ((humanplayers+botplayers) < (humanplayers2+botplayers2))
+			{
+				G_RemoveRandomBot( TEAM_BLUE );
+			}
+			else
+			{
+				G_RemoveRandomBot( TEAM_RED );
+			}
+		}
+	}
+	else if (g_gametype.integer == GT_DUEL || g_gametype.integer == GT_POWERDUEL) {
+		if (minplayers >= g_maxclients.integer) {
+			minplayers = g_maxclients.integer-1;
+		}
+		humanplayers = G_CountHumanPlayers( -1 );
+		botplayers = G_CountBotPlayers( -1 );
+		//
+		if (humanplayers + botplayers < minplayers) {
+			G_AddRandomBot( TEAM_FREE );
+		} else if (humanplayers + botplayers > minplayers && botplayers) {
+			// try to remove spectators first
+			if (!G_RemoveRandomBot( TEAM_SPECTATOR )) {
+				// just remove the bot that is playing
+				G_RemoveRandomBot( -1 );
+			}
+		}
+	}
+	else if (g_gametype.integer == GT_FFA) {
+		if (minplayers >= g_maxclients.integer) {
+			minplayers = g_maxclients.integer-1;
+		}
+		humanplayers = G_CountHumanPlayers( TEAM_FREE );
+		botplayers = G_CountBotPlayers( TEAM_FREE );
+		//
+		if (humanplayers + botplayers < minplayers) {
+			G_AddRandomBot( TEAM_FREE );
+		} else if (humanplayers + botplayers > minplayers && botplayers) {
+			G_RemoveRandomBot( TEAM_FREE );
+		}
+	}
+	else if (g_gametype.integer == GT_HOLOCRON || g_gametype.integer == GT_JEDIMASTER) {
+		if (minplayers >= g_maxclients.integer) {
+			minplayers = g_maxclients.integer-1;
+		}
+		humanplayers = G_CountHumanPlayers( TEAM_FREE );
+		botplayers = G_CountBotPlayers( TEAM_FREE );
+		//
+		if (humanplayers + botplayers < minplayers) {
+			G_AddRandomBot( TEAM_FREE );
+		} else if (humanplayers + botplayers > minplayers && botplayers) {
+			G_RemoveRandomBot( TEAM_FREE );
+		}
+	}
+	*/
+}
+
+/*
+===============
+G_CheckBotSpawn
+===============
+*/
+void G_CheckBotSpawn( void ) {
+	int		n;
+
+	G_CheckMinimumPlayers();
+
+	for( n = 0; n < BOT_SPAWN_QUEUE_DEPTH; n++ ) {
+		if( !botSpawnQueue[n].spawnTime ) {
+			continue;
+		}
+		if ( botSpawnQueue[n].spawnTime > level.time ) {
+			continue;
+		}
+		ClientBegin( botSpawnQueue[n].clientNum, qfalse );
+		botSpawnQueue[n].spawnTime = 0;
+
+		/*
+		if( g_gametype.integer == GT_SINGLE_PLAYER ) {
+			trap_GetUserinfo( botSpawnQueue[n].clientNum, userinfo, sizeof(userinfo) );
+			PlayerIntroSound( Info_ValueForKey (userinfo, "model") );
+		}
+		*/
+	}
+}
+
+
+/*
+===============
+AddBotToSpawnQueue
+===============
+*/
+static void AddBotToSpawnQueue( int clientNum, int delay ) {
+	int		n;
+
+	for( n = 0; n < BOT_SPAWN_QUEUE_DEPTH; n++ ) {
+		if( !botSpawnQueue[n].spawnTime ) {
+			botSpawnQueue[n].spawnTime = level.time + delay;
+			botSpawnQueue[n].clientNum = clientNum;
+			return;
+		}
+	}
+
+	G_Printf( S_COLOR_YELLOW "Unable to delay spawn\n" );
+	ClientBegin( clientNum, qfalse );
+}
+
+
+/*
+===============
+G_RemoveQueuedBotBegin
+
+Called on client disconnect to make sure the delayed spawn
+doesn't happen on a freed index
+===============
+*/
+void G_RemoveQueuedBotBegin( int clientNum ) {
+	int		n;
+
+	for( n = 0; n < BOT_SPAWN_QUEUE_DEPTH; n++ ) {
+		if( botSpawnQueue[n].clientNum == clientNum ) {
+			botSpawnQueue[n].spawnTime = 0;
+			return;
+		}
+	}
+}
+
+
+/*
+===============
+G_BotConnect
+===============
+*/
+qboolean G_BotConnect( int clientNum, qboolean restart ) {
+	bot_settings_t	settings;
+	char			userinfo[MAX_INFO_STRING];
+
+	trap_GetUserinfo( clientNum, userinfo, sizeof(userinfo) );
+
+	Q_strncpyz( settings.personalityfile, Info_ValueForKey( userinfo, "personality" ), sizeof(settings.personalityfile) );
+	settings.skill = atof( Info_ValueForKey( userinfo, "skill" ) );
+	Q_strncpyz( settings.team, Info_ValueForKey( userinfo, "team" ), sizeof(settings.team) );
+
+	if (!BotAISetupClient( clientNum, &settings, restart )) {
+		trap_DropClient( clientNum, "BotAISetupClient failed" );
+		return qfalse;
+	}
+
+	return qtrue;
+}
+
+
+/*
+===============
+G_AddBot
+===============
+*/
+static void G_AddBot( const char *name, float skill, const char *team, int delay, char *altname) {
+	int				clientNum;
+	char			*botinfo;
+	gentity_t		*bot;
+	char			*key;
+	char			*s;
+	char			*botname;
+	char			*model;
+//	char			*headmodel;
+	char			userinfo[MAX_INFO_STRING];
+	int				preTeam = 0;
+
+	// get the botinfo from bots.txt
+	botinfo = G_GetBotInfoByName( name );
+	if ( !botinfo ) {
+		G_Printf( S_COLOR_RED "Error: Bot '%s' not defined\n", name );
+		return;
+	}
+
+	// create the bot's userinfo
+	userinfo[0] = '\0';
+
+	botname = Info_ValueForKey( botinfo, "funname" );
+	if( !botname[0] ) {
+		botname = Info_ValueForKey( botinfo, "name" );
+	}
+	// check for an alternative name
+	if (altname && altname[0]) {
+		botname = altname;
+	}
+	Info_SetValueForKey( userinfo, "name", botname );
+	Info_SetValueForKey( userinfo, "rate", "25000" );
+	Info_SetValueForKey( userinfo, "snaps", "20" );
+	Info_SetValueForKey( userinfo, "skill", va("%1.2f", skill) );
+
+	if ( skill >= 1 && skill < 2 ) {
+		Info_SetValueForKey( userinfo, "handicap", "50" );
+	}
+	else if ( skill >= 2 && skill < 3 ) {
+		Info_SetValueForKey( userinfo, "handicap", "70" );
+	}
+	else if ( skill >= 3 && skill < 4 ) {
+		Info_SetValueForKey( userinfo, "handicap", "90" );
+	}
+
+	key = "model";
+	model = Info_ValueForKey( botinfo, key );
+	if ( !*model ) {
+		model = "kyle/default";
+	}
+	Info_SetValueForKey( userinfo, key, model );
+
+/*	key = "headmodel";
+	headmodel = Info_ValueForKey( botinfo, key );
+	if ( !*headmodel ) {
+		headmodel = model;
+	}
+	Info_SetValueForKey( userinfo, key, headmodel );
+	key = "team_headmodel";
+	Info_SetValueForKey( userinfo, key, headmodel );
+*/
+	key = "gender";
+	s = Info_ValueForKey( botinfo, key );
+	if ( !*s ) {
+		s = "male";
+	}
+	Info_SetValueForKey( userinfo, "sex", s );
+
+	key = "color1";
+	s = Info_ValueForKey( botinfo, key );
+	if ( !*s ) {
+		s = "4";
+	}
+	Info_SetValueForKey( userinfo, key, s );
+
+	key = "color2";
+	s = Info_ValueForKey( botinfo, key );
+	if ( !*s ) {
+		s = "4";
+	}
+	Info_SetValueForKey( userinfo, key, s );
+
+	key = "saber1";
+	s = Info_ValueForKey( botinfo, key );
+	if ( !*s ) {
+		s = "single_1";
+	}
+	Info_SetValueForKey( userinfo, key, s );
+
+	key = "saber2";
+	s = Info_ValueForKey( botinfo, key );
+	if ( !*s ) {
+		s = "none";
+	}
+	Info_SetValueForKey( userinfo, key, s );
+
+	s = Info_ValueForKey(botinfo, "personality");
+	if (!*s )
+	{
+		Info_SetValueForKey( userinfo, "personality", "botfiles/default.jkb" );
+	}
+	else
+	{
+		Info_SetValueForKey( userinfo, "personality", s );
+	}
+
+	// have the server allocate a client slot
+	clientNum = trap_BotAllocateClient();
+	if ( clientNum == -1 ) {
+//		G_Printf( S_COLOR_RED "Unable to add bot.  All player slots are in use.\n" );
+//		G_Printf( S_COLOR_RED "Start server with more 'open' slots.\n" );
+		trap_SendServerCommand( -1, va("print \"%s\n\"", G_GetStringEdString("MP_SVGAME", "UNABLE_TO_ADD_BOT")));
+		return;
+	}
+
+	// initialize the bot settings
+	if( !team || !*team ) {
+		if( g_gametype.integer >= GT_TEAM ) {
+			if( PickTeam(clientNum) == TEAM_RED) {
+				team = "red";
+			}
+			else {
+				team = "blue";
+			}
+		}
+		else {
+			team = "red";
+		}
+	}
+//	Info_SetValueForKey( userinfo, "characterfile", Info_ValueForKey( botinfo, "aifile" ) );
+	Info_SetValueForKey( userinfo, "skill", va( "%5.2f", skill ) );
+	Info_SetValueForKey( userinfo, "team", team );
+
+	bot = &g_entities[ clientNum ];
+	bot->r.svFlags |= SVF_BOT;
+	bot->inuse = qtrue;
+
+	// register the userinfo
+	trap_SetUserinfo( clientNum, userinfo );
+
+	if (g_gametype.integer >= GT_TEAM)
+	{
+		if (team && Q_stricmp(team, "red") == 0)
+		{
+			bot->client->sess.sessionTeam = TEAM_RED;
+		}
+		else if (team && Q_stricmp(team, "blue") == 0)
+		{
+			bot->client->sess.sessionTeam = TEAM_BLUE;
+		}
+		else
+		{
+			bot->client->sess.sessionTeam = PickTeam( -1 );
+		}
+	}
+
+	if (g_gametype.integer == GT_SIEGE)
+	{
+		bot->client->sess.siegeDesiredTeam = bot->client->sess.sessionTeam;
+		bot->client->sess.sessionTeam = TEAM_SPECTATOR;
+	}
+
+	preTeam = bot->client->sess.sessionTeam;
+
+	// have it connect to the game as a normal client
+	if ( ClientConnect( clientNum, qtrue, qtrue ) ) {
+		return;
+	}
+
+	if (bot->client->sess.sessionTeam != preTeam)
+	{
+		trap_GetUserinfo(clientNum, userinfo, MAX_INFO_STRING);
+
+		if (bot->client->sess.sessionTeam == TEAM_SPECTATOR)
+		{
+			bot->client->sess.sessionTeam = preTeam;
+		}
+
+		if (bot->client->sess.sessionTeam == TEAM_RED)
+		{
+			team = "Red";
+		}
+		else
+		{
+			if (g_gametype.integer == GT_SIEGE)
+			{
+				if (bot->client->sess.sessionTeam == TEAM_BLUE)
+				{
+					team = "Blue";
+				}
+				else
+				{
+					team = "s";
+				}
+			}
+			else
+			{
+				team = "Blue";
+			}
+		}
+
+		Info_SetValueForKey( userinfo, "team", team );
+
+		trap_SetUserinfo( clientNum, userinfo );
+
+		bot->client->ps.persistant[ PERS_TEAM ] = bot->client->sess.sessionTeam;
+
+		G_ReadSessionData( bot->client );
+		ClientUserinfoChanged( clientNum );
+	}
+
+	if (g_gametype.integer == GT_DUEL ||
+		g_gametype.integer == GT_POWERDUEL)
+	{
+		int loners = 0;
+		int doubles = 0;
+
+		bot->client->sess.duelTeam = 0;
+		G_PowerDuelCount(&loners, &doubles, qtrue);
+
+		if (!doubles || loners > (doubles/2))
+		{
+            bot->client->sess.duelTeam = DUELTEAM_DOUBLE;
+		}
+		else
+		{
+            bot->client->sess.duelTeam = DUELTEAM_LONE;
+		}
+
+		bot->client->sess.sessionTeam = TEAM_SPECTATOR;
+		SetTeam(bot, "s");
+	}
+	else
+	{
+		if( delay == 0 ) {
+			ClientBegin( clientNum, qfalse );
+			return;
+		}
+
+		AddBotToSpawnQueue( clientNum, delay );
+	}
+}
+
+
+/*
+===============
+Svcmd_AddBot_f
+===============
+*/
+void Svcmd_AddBot_f( void ) {
+	float			skill;
+	int				delay;
+	char			name[MAX_TOKEN_CHARS];
+	char			altname[MAX_TOKEN_CHARS];
+	char			string[MAX_TOKEN_CHARS];
+	char			team[MAX_TOKEN_CHARS];
+
+	// are bots enabled?
+	if ( !trap_Cvar_VariableIntegerValue( "bot_enable" ) ) {
+		return;
+	}
+
+	// name
+	trap_Argv( 1, name, sizeof( name ) );
+	if ( !name[0] ) {
+		trap_Printf( "Usage: Addbot <botname> [skill 1-5] [team] [msec delay] [altname]\n" );
+		return;
+	}
+
+	// skill
+	trap_Argv( 2, string, sizeof( string ) );
+	if ( !string[0] ) {
+		skill = 4;
+	}
+	else {
+		skill = atof( string );
+	}
+
+	// team
+	trap_Argv( 3, team, sizeof( team ) );
+
+	// delay
+	trap_Argv( 4, string, sizeof( string ) );
+	if ( !string[0] ) {
+		delay = 0;
+	}
+	else {
+		delay = atoi( string );
+	}
+
+	// alternative name
+	trap_Argv( 5, altname, sizeof( altname ) );
+
+	G_AddBot( name, skill, team, delay, altname );
+
+	// if this was issued during gameplay and we are playing locally,
+	// go ahead and load the bot's media immediately
+	if ( level.time - level.startTime > 1000 &&
+		trap_Cvar_VariableIntegerValue( "cl_running" ) ) {
+		trap_SendServerCommand( -1, "loaddefered\n" );	// FIXME: spelled wrong, but not changing for demo
+	}
+}
+
+/*
+===============
+Svcmd_BotList_f
+===============
+*/
+void Svcmd_BotList_f( void ) {
+	int i;
+	char name[MAX_TOKEN_CHARS];
+	char funname[MAX_TOKEN_CHARS];
+	char model[MAX_TOKEN_CHARS];
+	char personality[MAX_TOKEN_CHARS];
+
+	trap_Printf("^1name             model            personality              funname\n");
+	for (i = 0; i < g_numBots; i++) {
+		strcpy(name, Info_ValueForKey( g_botInfos[i], "name" ));
+		if ( !*name ) {
+			strcpy(name, "Padawan");
+		}
+		strcpy(funname, Info_ValueForKey( g_botInfos[i], "funname" ));
+		if ( !*funname ) {
+			strcpy(funname, "");
+		}
+		strcpy(model, Info_ValueForKey( g_botInfos[i], "model" ));
+		if ( !*model ) {
+			strcpy(model, "kyle/default");
+		}
+		strcpy(personality, Info_ValueForKey( g_botInfos[i], "personality"));
+		if (!*personality ) {
+			strcpy(personality, "botfiles/kyle.jkb");
+		}
+		trap_Printf(va("%-16s %-16s %-20s %-20s\n", name, model, personality, funname));
+	}
+}
+
+#if 0
+/*
+===============
+G_SpawnBots
+===============
+*/
+static void G_SpawnBots( char *botList, int baseDelay ) {
+	char		*bot;
+	char		*p;
+	float		skill;
+	int			delay;
+	char		bots[MAX_INFO_VALUE];
+
+	podium1 = NULL;
+	podium2 = NULL;
+	podium3 = NULL;
+
+	skill = trap_Cvar_VariableValue( "g_spSkill" );
+	if( skill < 1 ) {
+		trap_Cvar_Set( "g_spSkill", "1" );
+		skill = 1;
+	}
+	else if ( skill > 5 ) {
+		trap_Cvar_Set( "g_spSkill", "5" );
+		skill = 5;
+	}
+
+	Q_strncpyz( bots, botList, sizeof(bots) );
+	p = &bots[0];
+	delay = baseDelay;
+	while( *p ) {
+		//skip spaces
+		while( *p && *p == ' ' ) {
+			p++;
+		}
+		if( !p ) {
+			break;
+		}
+
+		// mark start of bot name
+		bot = p;
+
+		// skip until space of null
+		while( *p && *p != ' ' ) {
+			p++;
+		}
+		if( *p ) {
+			*p++ = 0;
+		}
+
+		// we must add the bot this way, calling G_AddBot directly at this stage
+		// does "Bad Things"
+		trap_SendConsoleCommand( EXEC_INSERT, va("addbot \"%s\" %f free %i\n", bot, skill, delay) );
+
+		delay += BOT_BEGIN_DELAY_INCREMENT;
+	}
+}
+#endif
+
+
+/*
+===============
+G_LoadBotsFromFile
+===============
+*/
+static void G_LoadBotsFromFile( char *filename ) {
+	int				len;
+	fileHandle_t	f;
+	char			buf[MAX_BOTS_TEXT];
+
+	len = trap_FS_FOpenFile( filename, &f, FS_READ );
+	if ( !f ) {
+		trap_Printf( va( S_COLOR_RED "file not found: %s\n", filename ) );
+		return;
+	}
+	if ( len >= MAX_BOTS_TEXT ) {
+		trap_Printf( va( S_COLOR_RED "file too large: %s is %i, max allowed is %i", filename, len, MAX_BOTS_TEXT ) );
+		trap_FS_FCloseFile( f );
+		return;
+	}
+
+	trap_FS_Read( buf, len, f );
+	buf[len] = 0;
+	trap_FS_FCloseFile( f );
+
+	g_numBots += G_ParseInfos( buf, MAX_BOTS - g_numBots, &g_botInfos[g_numBots] );
+}
+
+/*
+===============
+G_LoadBots
+===============
+*/
+static void G_LoadBots( void ) {
+	vmCvar_t	botsFile;
+	int			numdirs;
+	char		filename[128];
+	char		dirlist[1024];
+	char*		dirptr;
+	int			i;
+	int			dirlen;
+
+	if ( !trap_Cvar_VariableIntegerValue( "bot_enable" ) ) {
+		return;
+	}
+
+	g_numBots = 0;
+
+	trap_Cvar_Register( &botsFile, "g_botsFile", "", CVAR_INIT|CVAR_ROM );
+	if( *botsFile.string ) {
+		G_LoadBotsFromFile(botsFile.string);
+	}
+	else {
+		//G_LoadBotsFromFile("scripts/bots.txt");
+		G_LoadBotsFromFile("botfiles/bots.txt");
+	}
+
+	// get all bots from .bot files
+	numdirs = trap_FS_GetFileList("scripts", ".bot", dirlist, 1024 );
+	dirptr  = dirlist;
+	for (i = 0; i < numdirs; i++, dirptr += dirlen+1) {
+		dirlen = strlen(dirptr);
+		strcpy(filename, "scripts/");
+		strcat(filename, dirptr);
+		G_LoadBotsFromFile(filename);
+	}
+//	trap_Printf( va( "%i bots parsed\n", g_numBots ) );
+}
+
+
+
+/*
+===============
+G_GetBotInfoByNumber
+===============
+*/
+char *G_GetBotInfoByNumber( int num ) {
+	if( num < 0 || num >= g_numBots ) {
+		trap_Printf( va( S_COLOR_RED "Invalid bot number: %i\n", num ) );
+		return NULL;
+	}
+	return g_botInfos[num];
+}
+
+
+/*
+===============
+G_GetBotInfoByName
+===============
+*/
+char *G_GetBotInfoByName( const char *name ) {
+	int		n;
+	char	*value;
+
+	for ( n = 0; n < g_numBots ; n++ ) {
+		value = Info_ValueForKey( g_botInfos[n], "name" );
+		if ( !Q_stricmp( value, name ) ) {
+			return g_botInfos[n];
+		}
+	}
+
+	return NULL;
+}
+
+//rww - pd
+void LoadPath_ThisLevel(void);
+//end rww
+
+/*
+===============
+G_InitBots
+===============
+*/
+void G_InitBots( qboolean restart ) {
+	G_LoadBots();
+	G_LoadArenas();
+
+	trap_Cvar_Register( &bot_minplayers, "bot_minplayers", "0", CVAR_SERVERINFO );
+
+	//rww - new bot route stuff
+	LoadPath_ThisLevel();
+	//end rww
+}
diff --git a/codemp/game/g_client.c b/codemp/game/g_client.c
new file mode 100644
index 0000000..4b5cb31
--- /dev/null
+++ b/codemp/game/g_client.c
@@ -0,0 +1,3809 @@
+// Copyright (C) 1999-2000 Id Software, Inc.
+//
+#include "g_local.h"
+#include "../ghoul2/G2.h"
+#include "bg_saga.h"
+
+// g_client.c -- client functions that don't happen every frame
+
+static vec3_t	playerMins = {-15, -15, DEFAULT_MINS_2};
+static vec3_t	playerMaxs = {15, 15, DEFAULT_MAXS_2};
+
+extern int g_siegeRespawnCheck;
+
+void WP_SaberAddG2Model( gentity_t *saberent, const char *saberModel, qhandle_t saberSkin );
+void WP_SaberRemoveG2Model( gentity_t *saberent );
+
+forcedata_t Client_Force[MAX_CLIENTS];
+
+/*QUAKED info_player_duel (1 0 1) (-16 -16 -24) (16 16 32) initial
+potential spawning position for duelists in duel.
+Targets will be fired when someone spawns in on them.
+"nobots" will prevent bots from using this spot.
+"nohumans" will prevent non-bots from using this spot.
+*/
+void SP_info_player_duel( gentity_t *ent )
+{
+	int		i;
+
+	G_SpawnInt( "nobots", "0", &i);
+	if ( i ) {
+		ent->flags |= FL_NO_BOTS;
+	}
+	G_SpawnInt( "nohumans", "0", &i );
+	if ( i ) {
+		ent->flags |= FL_NO_HUMANS;
+	}
+}
+
+/*QUAKED info_player_duel1 (1 0 1) (-16 -16 -24) (16 16 32) initial
+potential spawning position for lone duelists in powerduel.
+Targets will be fired when someone spawns in on them.
+"nobots" will prevent bots from using this spot.
+"nohumans" will prevent non-bots from using this spot.
+*/
+void SP_info_player_duel1( gentity_t *ent )
+{
+	int		i;
+
+	G_SpawnInt( "nobots", "0", &i);
+	if ( i ) {
+		ent->flags |= FL_NO_BOTS;
+	}
+	G_SpawnInt( "nohumans", "0", &i );
+	if ( i ) {
+		ent->flags |= FL_NO_HUMANS;
+	}
+}
+
+/*QUAKED info_player_duel2 (1 0 1) (-16 -16 -24) (16 16 32) initial
+potential spawning position for paired duelists in powerduel.
+Targets will be fired when someone spawns in on them.
+"nobots" will prevent bots from using this spot.
+"nohumans" will prevent non-bots from using this spot.
+*/
+void SP_info_player_duel2( gentity_t *ent )
+{
+	int		i;
+
+	G_SpawnInt( "nobots", "0", &i);
+	if ( i ) {
+		ent->flags |= FL_NO_BOTS;
+	}
+	G_SpawnInt( "nohumans", "0", &i );
+	if ( i ) {
+		ent->flags |= FL_NO_HUMANS;
+	}
+}
+
+/*QUAKED info_player_deathmatch (1 0 1) (-16 -16 -24) (16 16 32) initial
+potential spawning position for deathmatch games.
+The first time a player enters the game, they will be at an 'initial' spot.
+Targets will be fired when someone spawns in on them.
+"nobots" will prevent bots from using this spot.
+"nohumans" will prevent non-bots from using this spot.
+*/
+void SP_info_player_deathmatch( gentity_t *ent ) {
+	int		i;
+
+	G_SpawnInt( "nobots", "0", &i);
+	if ( i ) {
+		ent->flags |= FL_NO_BOTS;
+	}
+	G_SpawnInt( "nohumans", "0", &i );
+	if ( i ) {
+		ent->flags |= FL_NO_HUMANS;
+	}
+}
+
+/*QUAKED info_player_start (1 0 0) (-16 -16 -24) (16 16 32)
+Targets will be fired when someone spawns in on them.
+equivelant to info_player_deathmatch
+*/
+void SP_info_player_start(gentity_t *ent) {
+	ent->classname = "info_player_deathmatch";
+	SP_info_player_deathmatch( ent );
+}
+
+void SiegePointUse( gentity_t *self, gentity_t *other, gentity_t *activator )
+{
+	//Toggle the point on/off
+	if (self->genericValue1)
+	{
+		self->genericValue1 = 0;
+	}
+	else
+	{
+		self->genericValue1 = 1;
+	}
+}
+
+/*QUAKED info_player_siegeteam1 (1 0 0) (-16 -16 -24) (16 16 32)
+siege start point - team1
+name and behavior of team1 depends on what is defined in the
+.siege file for this level
+
+startoff - if non-0 spawn point will be disabled until used
+idealclass - if specified, this spawn point will be considered
+"ideal" for players of this class name. Corresponds to the name
+entry in the .scl (siege class) file.
+Targets will be fired when someone spawns in on them.
+*/
+void SP_info_player_siegeteam1(gentity_t *ent) {
+	int soff = 0;
+
+	if (g_gametype.integer != GT_SIEGE)
+	{ //turn into a DM spawn if not in siege game mode
+		ent->classname = "info_player_deathmatch";
+		SP_info_player_deathmatch( ent );
+
+		return;
+	}
+
+	G_SpawnInt("startoff", "0", &soff);
+
+	if (soff)
+	{ //start disabled
+		ent->genericValue1 = 0;
+	}
+	else
+	{
+		ent->genericValue1 = 1;
+	}
+
+	ent->use = SiegePointUse;
+}
+
+/*QUAKED info_player_siegeteam2 (0 0 1) (-16 -16 -24) (16 16 32)
+siege start point - team2
+name and behavior of team2 depends on what is defined in the
+.siege file for this level
+
+startoff - if non-0 spawn point will be disabled until used
+idealclass - if specified, this spawn point will be considered
+"ideal" for players of this class name. Corresponds to the name
+entry in the .scl (siege class) file.
+Targets will be fired when someone spawns in on them.
+*/
+void SP_info_player_siegeteam2(gentity_t *ent) {
+	int soff = 0;
+
+	if (g_gametype.integer != GT_SIEGE)
+	{ //turn into a DM spawn if not in siege game mode
+		ent->classname = "info_player_deathmatch";
+		SP_info_player_deathmatch( ent );
+
+		return;
+	}
+
+	G_SpawnInt("startoff", "0", &soff);
+
+	if (soff)
+	{ //start disabled
+		ent->genericValue1 = 0;
+	}
+	else
+	{
+		ent->genericValue1 = 1;
+	}
+
+	ent->use = SiegePointUse;
+}
+
+/*QUAKED info_player_intermission (1 0 1) (-16 -16 -24) (16 16 32)
+The intermission will be viewed from this point.  Target an info_notnull for the view direction.
+*/
+void SP_info_player_intermission( gentity_t *ent ) {
+
+}
+
+#define JMSABER_RESPAWN_TIME 20000 //in case it gets stuck somewhere no one can reach
+
+void ThrowSaberToAttacker(gentity_t *self, gentity_t *attacker)
+{
+	gentity_t *ent = &g_entities[self->client->ps.saberIndex];
+	vec3_t a;
+	int altVelocity = 0;
+
+	if (!ent || ent->enemy != self)
+	{ //something has gone very wrong (this should never happen)
+		//but in case it does.. find the saber manually
+#ifdef _DEBUG
+		Com_Printf("Lost the saber! Attempting to use global pointer..\n");
+#endif
+		ent = gJMSaberEnt;
+
+		if (!ent)
+		{
+#ifdef _DEBUG
+			Com_Printf("The global pointer was NULL. This is a bad thing.\n");
+#endif
+			return;
+		}
+
+#ifdef _DEBUG
+		Com_Printf("Got it (%i). Setting enemy to client %i.\n", ent->s.number, self->s.number);
+#endif
+
+		ent->enemy = self;
+		self->client->ps.saberIndex = ent->s.number;
+	}
+
+	trap_SetConfigstring ( CS_CLIENT_JEDIMASTER, "-1" );
+
+	if (attacker && attacker->client && self->client->ps.saberInFlight)
+	{ //someone killed us and we had the saber thrown, so actually move this saber to the saber location
+	  //if we killed ourselves with saber thrown, however, same suicide rules of respawning at spawn spot still
+	  //apply.
+		gentity_t *flyingsaber = &g_entities[self->client->ps.saberEntityNum];
+
+		if (flyingsaber && flyingsaber->inuse)
+		{
+			VectorCopy(flyingsaber->s.pos.trBase, ent->s.pos.trBase);
+			VectorCopy(flyingsaber->s.pos.trDelta, ent->s.pos.trDelta);
+			VectorCopy(flyingsaber->s.apos.trBase, ent->s.apos.trBase);
+			VectorCopy(flyingsaber->s.apos.trDelta, ent->s.apos.trDelta);
+
+			VectorCopy(flyingsaber->r.currentOrigin, ent->r.currentOrigin);
+			VectorCopy(flyingsaber->r.currentAngles, ent->r.currentAngles);
+			altVelocity = 1;
+		}
+	}
+
+	self->client->ps.saberInFlight = qtrue; //say he threw it anyway in order to properly remove from dead body
+
+	WP_SaberAddG2Model( ent, self->client->saber[0].model, self->client->saber[0].skin );
+
+	ent->s.eFlags &= ~(EF_NODRAW);
+	ent->s.modelGhoul2 = 1;
+	ent->s.eType = ET_MISSILE;
+	ent->enemy = NULL;
+
+	if (!attacker || !attacker->client)
+	{
+		VectorCopy(ent->s.origin2, ent->s.pos.trBase);
+		VectorCopy(ent->s.origin2, ent->s.origin);
+		VectorCopy(ent->s.origin2, ent->r.currentOrigin);
+		ent->pos2[0] = 0;
+		trap_LinkEntity(ent);
+		return;
+	}
+
+	if (!altVelocity)
+	{
+		VectorCopy(self->s.pos.trBase, ent->s.pos.trBase);
+		VectorCopy(self->s.pos.trBase, ent->s.origin);
+		VectorCopy(self->s.pos.trBase, ent->r.currentOrigin);
+
+		VectorSubtract(attacker->client->ps.origin, ent->s.pos.trBase, a);
+
+		VectorNormalize(a);
+
+		ent->s.pos.trDelta[0] = a[0]*256;
+		ent->s.pos.trDelta[1] = a[1]*256;
+		ent->s.pos.trDelta[2] = 256;
+	}
+
+	trap_LinkEntity(ent);
+}
+
+void JMSaberThink(gentity_t *ent)
+{
+	gJMSaberEnt = ent;
+
+	if (ent->enemy)
+	{
+		if (!ent->enemy->client || !ent->enemy->inuse)
+		{ //disconnected?
+			VectorCopy(ent->enemy->s.pos.trBase, ent->s.pos.trBase);
+			VectorCopy(ent->enemy->s.pos.trBase, ent->s.origin);
+			VectorCopy(ent->enemy->s.pos.trBase, ent->r.currentOrigin);
+			ent->s.modelindex = G_ModelIndex("models/weapons2/saber/saber_w.glm");
+			ent->s.eFlags &= ~(EF_NODRAW);
+			ent->s.modelGhoul2 = 1;
+			ent->s.eType = ET_MISSILE;
+			ent->enemy = NULL;
+
+			ent->pos2[0] = 1;
+			ent->pos2[1] = 0; //respawn next think
+			trap_LinkEntity(ent);
+		}
+		else
+		{
+			ent->pos2[1] = level.time + JMSABER_RESPAWN_TIME;
+		}
+	}
+	else if (ent->pos2[0] && ent->pos2[1] < level.time)
+	{
+		VectorCopy(ent->s.origin2, ent->s.pos.trBase);
+		VectorCopy(ent->s.origin2, ent->s.origin);
+		VectorCopy(ent->s.origin2, ent->r.currentOrigin);
+		ent->pos2[0] = 0;
+		trap_LinkEntity(ent);
+	}
+
+	ent->nextthink = level.time + 50;
+	G_RunObject(ent);
+}
+
+void JMSaberTouch(gentity_t *self, gentity_t *other, trace_t *trace)
+{
+	int i = 0;
+//	gentity_t *te;
+
+	if (!other || !other->client || other->health < 1)
+	{
+		return;
+	}
+
+	if (self->enemy)
+	{
+		return;
+	}
+
+	if (!self->s.modelindex)
+	{
+		return;
+	}
+
+	if (other->client->ps.stats[STAT_WEAPONS] & (1 << WP_SABER))
+	{
+		return;
+	}
+
+	if (other->client->ps.isJediMaster)
+	{
+		return;
+	}
+
+	self->enemy = other;
+	other->client->ps.stats[STAT_WEAPONS] = (1 << WP_SABER);
+	other->client->ps.weapon = WP_SABER;
+	other->s.weapon = WP_SABER;
+	G_AddEvent(other, EV_BECOME_JEDIMASTER, 0);
+
+	// Track the jedi master 
+	trap_SetConfigstring ( CS_CLIENT_JEDIMASTER, va("%i", other->s.number ) );
+
+	if (g_spawnInvulnerability.integer)
+	{
+		other->client->ps.eFlags |= EF_INVULNERABLE;
+		other->client->invulnerableTimer = level.time + g_spawnInvulnerability.integer;
+	}
+
+	trap_SendServerCommand( -1, va("cp \"%s %s\n\"", other->client->pers.netname, G_GetStringEdString("MP_SVGAME", "BECOMEJM")) );
+
+	other->client->ps.isJediMaster = qtrue;
+	other->client->ps.saberIndex = self->s.number;
+
+	if (other->health < 200 && other->health > 0)
+	{ //full health when you become the Jedi Master
+		other->client->ps.stats[STAT_HEALTH] = other->health = 200;
+	}
+
+	if (other->client->ps.fd.forcePower < 100)
+	{
+		other->client->ps.fd.forcePower = 100;
+	}
+
+	while (i < NUM_FORCE_POWERS)
+	{
+		other->client->ps.fd.forcePowersKnown |= (1 << i);
+		other->client->ps.fd.forcePowerLevel[i] = FORCE_LEVEL_3;
+
+		i++;
+	}
+
+	self->pos2[0] = 1;
+	self->pos2[1] = level.time + JMSABER_RESPAWN_TIME;
+
+	self->s.modelindex = 0;
+	self->s.eFlags |= EF_NODRAW;
+	self->s.modelGhoul2 = 0;
+	self->s.eType = ET_GENERAL;
+
+	/*
+	te = G_TempEntity( vec3_origin, EV_DESTROY_GHOUL2_INSTANCE );
+	te->r.svFlags |= SVF_BROADCAST;
+	te->s.eventParm = self->s.number;
+	*/
+	G_KillG2Queue(self->s.number);
+
+	return;
+}
+
+gentity_t *gJMSaberEnt = NULL;
+
+/*QUAKED info_jedimaster_start (1 0 0) (-16 -16 -24) (16 16 32)
+"jedi master" saber spawn point
+*/
+void SP_info_jedimaster_start(gentity_t *ent)
+{
+	if (g_gametype.integer != GT_JEDIMASTER)
+	{
+		gJMSaberEnt = NULL;
+		G_FreeEntity(ent);
+		return;
+	}
+
+	ent->enemy = NULL;
+
+	ent->flags = FL_BOUNCE_HALF;
+
+	ent->s.modelindex = G_ModelIndex("models/weapons2/saber/saber_w.glm");
+	ent->s.modelGhoul2 = 1;
+	ent->s.g2radius = 20;
+	//ent->s.eType = ET_GENERAL;
+	ent->s.eType = ET_MISSILE;
+	ent->s.weapon = WP_SABER;
+	ent->s.pos.trType = TR_GRAVITY;
+	ent->s.pos.trTime = level.time;
+	VectorSet( ent->r.maxs, 3, 3, 3 );
+	VectorSet( ent->r.mins, -3, -3, -3 );
+	ent->r.contents = CONTENTS_TRIGGER;
+	ent->clipmask = MASK_SOLID;
+
+	ent->isSaberEntity = qtrue;
+
+	ent->bounceCount = -5;
+
+	ent->physicsObject = qtrue;
+
+	VectorCopy(ent->s.pos.trBase, ent->s.origin2); //remember the spawn spot
+
+	ent->touch = JMSaberTouch;
+
+	trap_LinkEntity(ent);
+
+	ent->think = JMSaberThink;
+	ent->nextthink = level.time + 50;
+}
+
+/*
+=======================================================================
+
+  SelectSpawnPoint
+
+=======================================================================
+*/
+
+/*
+================
+SpotWouldTelefrag
+
+================
+*/
+qboolean SpotWouldTelefrag( gentity_t *spot ) {
+	int			i, num;
+	int			touch[MAX_GENTITIES];
+	gentity_t	*hit;
+	vec3_t		mins, maxs;
+
+	VectorAdd( spot->s.origin, playerMins, mins );
+	VectorAdd( spot->s.origin, playerMaxs, maxs );
+	num = trap_EntitiesInBox( mins, maxs, touch, MAX_GENTITIES );
+
+	for (i=0 ; i<num ; i++) {
+		hit = &g_entities[touch[i]];
+		//if ( hit->client && hit->client->ps.stats[STAT_HEALTH] > 0 ) {
+		if ( hit->client) {
+			return qtrue;
+		}
+
+	}
+
+	return qfalse;
+}
+
+qboolean SpotWouldTelefrag2( gentity_t *mover, vec3_t dest ) 
+{
+	int			i, num;
+	int			touch[MAX_GENTITIES];
+	gentity_t	*hit;
+	vec3_t		mins, maxs;
+
+	VectorAdd( dest, mover->r.mins, mins );
+	VectorAdd( dest, mover->r.maxs, maxs );
+	num = trap_EntitiesInBox( mins, maxs, touch, MAX_GENTITIES );
+
+	for (i=0 ; i<num ; i++) 
+	{
+		hit = &g_entities[touch[i]];
+		if ( hit == mover )
+		{
+			continue;
+		}
+
+		if ( hit->r.contents & mover->r.contents )
+		{
+			return qtrue;
+		}
+	}
+
+	return qfalse;
+}
+
+/*
+================
+SelectNearestDeathmatchSpawnPoint
+
+Find the spot that we DON'T want to use
+================
+*/
+#define	MAX_SPAWN_POINTS	128
+gentity_t *SelectNearestDeathmatchSpawnPoint( vec3_t from ) {
+	gentity_t	*spot;
+	vec3_t		delta;
+	float		dist, nearestDist;
+	gentity_t	*nearestSpot;
+
+	nearestDist = 999999;
+	nearestSpot = NULL;
+	spot = NULL;
+
+	while ((spot = G_Find (spot, FOFS(classname), "info_player_deathmatch")) != NULL) {
+
+		VectorSubtract( spot->s.origin, from, delta );
+		dist = VectorLength( delta );
+		if ( dist < nearestDist ) {
+			nearestDist = dist;
+			nearestSpot = spot;
+		}
+	}
+
+	return nearestSpot;
+}
+
+
+/*
+================
+SelectRandomDeathmatchSpawnPoint
+
+go to a random point that doesn't telefrag
+================
+*/
+#define	MAX_SPAWN_POINTS	128
+gentity_t *SelectRandomDeathmatchSpawnPoint( void ) {
+	gentity_t	*spot;
+	int			count;
+	int			selection;
+	gentity_t	*spots[MAX_SPAWN_POINTS];
+
+	count = 0;
+	spot = NULL;
+
+	while ((spot = G_Find (spot, FOFS(classname), "info_player_deathmatch")) != NULL) {
+		if ( SpotWouldTelefrag( spot ) ) {
+			continue;
+		}
+		spots[ count ] = spot;
+		count++;
+	}
+
+	if ( !count ) {	// no spots that won't telefrag
+		return G_Find( NULL, FOFS(classname), "info_player_deathmatch");
+	}
+
+	selection = rand() % count;
+	return spots[ selection ];
+}
+
+/*
+===========
+SelectRandomFurthestSpawnPoint
+
+Chooses a player start, deathmatch start, etc
+============
+*/
+gentity_t *SelectRandomFurthestSpawnPoint ( vec3_t avoidPoint, vec3_t origin, vec3_t angles ) {
+	gentity_t	*spot;
+	vec3_t		delta;
+	float		dist;
+	float		list_dist[64];
+	gentity_t	*list_spot[64];
+	int			numSpots, rnd, i, j;
+
+	numSpots = 0;
+	spot = NULL;
+
+	while ((spot = G_Find (spot, FOFS(classname), "info_player_deathmatch")) != NULL) {
+		if ( SpotWouldTelefrag( spot ) ) {
+			continue;
+		}
+		VectorSubtract( spot->s.origin, avoidPoint, delta );
+		dist = VectorLength( delta );
+		for (i = 0; i < numSpots; i++) {
+			if ( dist > list_dist[i] ) {
+				if ( numSpots >= 64 )
+					numSpots = 64-1;
+				for (j = numSpots; j > i; j--) {
+					list_dist[j] = list_dist[j-1];
+					list_spot[j] = list_spot[j-1];
+				}
+				list_dist[i] = dist;
+				list_spot[i] = spot;
+				numSpots++;
+				if (numSpots > 64)
+					numSpots = 64;
+				break;
+			}
+		}
+		if (i >= numSpots && numSpots < 64) {
+			list_dist[numSpots] = dist;
+			list_spot[numSpots] = spot;
+			numSpots++;
+		}
+	}
+	if (!numSpots) {
+		spot = G_Find( NULL, FOFS(classname), "info_player_deathmatch");
+		if (!spot)
+			G_Error( "Couldn't find a spawn point" );
+		VectorCopy (spot->s.origin, origin);
+		origin[2] += 9;
+		VectorCopy (spot->s.angles, angles);
+		return spot;
+	}
+
+	// select a random spot from the spawn points furthest away
+	rnd = random() * (numSpots / 2);
+
+	VectorCopy (list_spot[rnd]->s.origin, origin);
+	origin[2] += 9;
+	VectorCopy (list_spot[rnd]->s.angles, angles);
+
+	return list_spot[rnd];
+}
+
+gentity_t *SelectDuelSpawnPoint( int team, vec3_t avoidPoint, vec3_t origin, vec3_t angles )
+{
+	gentity_t	*spot;
+	vec3_t		delta;
+	float		dist;
+	float		list_dist[64];
+	gentity_t	*list_spot[64];
+	int			numSpots, rnd, i, j;
+	char		*spotName;
+
+	if (team == DUELTEAM_LONE)
+	{
+		spotName = "info_player_duel1";
+	}
+	else if (team == DUELTEAM_DOUBLE)
+	{
+		spotName = "info_player_duel2";
+	}
+	else if (team == DUELTEAM_SINGLE)
+	{
+		spotName = "info_player_duel";
+	}
+	else
+	{
+		spotName = "info_player_deathmatch";
+	}
+tryAgain:
+
+	numSpots = 0;
+	spot = NULL;
+
+	while ((spot = G_Find (spot, FOFS(classname), spotName)) != NULL) {
+		if ( SpotWouldTelefrag( spot ) ) {
+			continue;
+		}
+		VectorSubtract( spot->s.origin, avoidPoint, delta );
+		dist = VectorLength( delta );
+		for (i = 0; i < numSpots; i++) {
+			if ( dist > list_dist[i] ) {
+				if ( numSpots >= 64 )
+					numSpots = 64-1;
+				for (j = numSpots; j > i; j--) {
+					list_dist[j] = list_dist[j-1];
+					list_spot[j] = list_spot[j-1];
+				}
+				list_dist[i] = dist;
+				list_spot[i] = spot;
+				numSpots++;
+				if (numSpots > 64)
+					numSpots = 64;
+				break;
+			}
+		}
+		if (i >= numSpots && numSpots < 64) {
+			list_dist[numSpots] = dist;
+			list_spot[numSpots] = spot;
+			numSpots++;
+		}
+	}
+	if (!numSpots)
+	{
+		if (Q_stricmp(spotName, "info_player_deathmatch"))
+		{ //try the loop again with info_player_deathmatch as the target if we couldn't find a duel spot
+			spotName = "info_player_deathmatch";
+			goto tryAgain;
+		}
+
+		//If we got here we found no free duel or DM spots, just try the first DM spot
+		spot = G_Find( NULL, FOFS(classname), "info_player_deathmatch");
+		if (!spot)
+			G_Error( "Couldn't find a spawn point" );
+		VectorCopy (spot->s.origin, origin);
+		origin[2] += 9;
+		VectorCopy (spot->s.angles, angles);
+		return spot;
+	}
+
+	// select a random spot from the spawn points furthest away
+	rnd = random() * (numSpots / 2);
+
+	VectorCopy (list_spot[rnd]->s.origin, origin);
+	origin[2] += 9;
+	VectorCopy (list_spot[rnd]->s.angles, angles);
+
+	return list_spot[rnd];
+}
+
+/*
+===========
+SelectSpawnPoint
+
+Chooses a player start, deathmatch start, etc
+============
+*/
+gentity_t *SelectSpawnPoint ( vec3_t avoidPoint, vec3_t origin, vec3_t angles ) {
+	return SelectRandomFurthestSpawnPoint( avoidPoint, origin, angles );
+
+	/*
+	gentity_t	*spot;
+	gentity_t	*nearestSpot;
+
+	nearestSpot = SelectNearestDeathmatchSpawnPoint( avoidPoint );
+
+	spot = SelectRandomDeathmatchSpawnPoint ( );
+	if ( spot == nearestSpot ) {
+		// roll again if it would be real close to point of death
+		spot = SelectRandomDeathmatchSpawnPoint ( );
+		if ( spot == nearestSpot ) {
+			// last try
+			spot = SelectRandomDeathmatchSpawnPoint ( );
+		}		
+	}
+
+	// find a single player start spot
+	if (!spot) {
+		G_Error( "Couldn't find a spawn point" );
+	}
+
+	VectorCopy (spot->s.origin, origin);
+	origin[2] += 9;
+	VectorCopy (spot->s.angles, angles);
+
+	return spot;
+	*/
+}
+
+/*
+===========
+SelectInitialSpawnPoint
+
+Try to find a spawn point marked 'initial', otherwise
+use normal spawn selection.
+============
+*/
+gentity_t *SelectInitialSpawnPoint( vec3_t origin, vec3_t angles ) {
+	gentity_t	*spot;
+
+	spot = NULL;
+	while ((spot = G_Find (spot, FOFS(classname), "info_player_deathmatch")) != NULL) {
+		if ( spot->spawnflags & 1 ) {
+			break;
+		}
+	}
+
+	if ( !spot || SpotWouldTelefrag( spot ) ) {
+		return SelectSpawnPoint( vec3_origin, origin, angles );
+	}
+
+	VectorCopy (spot->s.origin, origin);
+	origin[2] += 9;
+	VectorCopy (spot->s.angles, angles);
+
+	return spot;
+}
+
+/*
+===========
+SelectSpectatorSpawnPoint
+
+============
+*/
+gentity_t *SelectSpectatorSpawnPoint( vec3_t origin, vec3_t angles ) {
+	FindIntermissionPoint();
+
+	VectorCopy( level.intermission_origin, origin );
+	VectorCopy( level.intermission_angle, angles );
+
+	return NULL;
+}
+
+/*
+=======================================================================
+
+BODYQUE
+
+=======================================================================
+*/
+
+/*
+=======================================================================
+
+BODYQUE
+
+=======================================================================
+*/
+
+#define BODY_SINK_TIME		30000//45000
+
+/*
+===============
+InitBodyQue
+===============
+*/
+void InitBodyQue (void) {
+	int		i;
+	gentity_t	*ent;
+
+	level.bodyQueIndex = 0;
+	for (i=0; i<BODY_QUEUE_SIZE ; i++) {
+		ent = G_Spawn();
+		ent->classname = "bodyque";
+		ent->neverFree = qtrue;
+		level.bodyQue[i] = ent;
+	}
+}
+
+/*
+=============
+BodySink
+
+After sitting around for five seconds, fall into the ground and dissapear
+=============
+*/
+void BodySink( gentity_t *ent ) {
+	if ( level.time - ent->timestamp > BODY_SINK_TIME + 2500 ) {
+		// the body ques are never actually freed, they are just unlinked
+		trap_UnlinkEntity( ent );
+		ent->physicsObject = qfalse;
+		return;	
+	}
+//	ent->nextthink = level.time + 100;
+//	ent->s.pos.trBase[2] -= 1;
+
+	G_AddEvent(ent, EV_BODYFADE, 0);
+	ent->nextthink = level.time + 18000;
+	ent->takedamage = qfalse;
+}
+
+/*
+=============
+CopyToBodyQue
+
+A player is respawning, so make an entity that looks
+just like the existing corpse to leave behind.
+=============
+*/
+static qboolean CopyToBodyQue( gentity_t *ent ) {
+	gentity_t		*body;
+	int			contents;
+	int			islight = 0;
+
+	if (level.intermissiontime)
+	{
+		return qfalse;
+	}
+
+	trap_UnlinkEntity (ent);
+
+	// if client is in a nodrop area, don't leave the body
+	contents = trap_PointContents( ent->s.origin, -1 );
+	if ( contents & CONTENTS_NODROP ) {
+		return qfalse;
+	}
+
+	if (ent->client && (ent->client->ps.eFlags & EF_DISINTEGRATION))
+	{ //for now, just don't spawn a body if you got disint'd
+		return qfalse;
+	}
+
+	// grab a body que and cycle to the next one
+	body = level.bodyQue[ level.bodyQueIndex ];
+	level.bodyQueIndex = (level.bodyQueIndex + 1) % BODY_QUEUE_SIZE;
+
+	trap_UnlinkEntity (body);
+	body->s = ent->s;
+
+	//avoid oddly angled corpses floating around
+	body->s.angles[PITCH] = body->s.angles[ROLL] = body->s.apos.trBase[PITCH] = body->s.apos.trBase[ROLL] = 0;
+
+	body->s.g2radius = 100;
+
+	body->s.eType = ET_BODY;
+	body->s.eFlags = EF_DEAD;		// clear EF_TALK, etc
+
+	if (ent->client && (ent->client->ps.eFlags & EF_DISINTEGRATION))
+	{
+		body->s.eFlags |= EF_DISINTEGRATION;
+	}
+
+	VectorCopy(ent->client->ps.lastHitLoc, body->s.origin2);
+
+	body->s.powerups = 0;	// clear powerups
+	body->s.loopSound = 0;	// clear lava burning
+	body->s.loopIsSoundset = qfalse;
+	body->s.number = body - g_entities;
+	body->timestamp = level.time;
+	body->physicsObject = qtrue;
+	body->physicsBounce = 0;		// don't bounce
+	if ( body->s.groundEntityNum == ENTITYNUM_NONE ) {
+		body->s.pos.trType = TR_GRAVITY;
+		body->s.pos.trTime = level.time;
+		VectorCopy( ent->client->ps.velocity, body->s.pos.trDelta );
+	} else {
+		body->s.pos.trType = TR_STATIONARY;
+	}
+	body->s.event = 0;
+
+	body->s.weapon = ent->s.bolt2;
+
+	if (body->s.weapon == WP_SABER && ent->client->ps.saberInFlight)
+	{
+		body->s.weapon = WP_BLASTER; //lie to keep from putting a saber on the corpse, because it was thrown at death
+	}
+
+	//G_AddEvent(body, EV_BODY_QUEUE_COPY, ent->s.clientNum);
+	//Now doing this through a modified version of the rcg reliable command.
+	if (ent->client && ent->client->ps.fd.forceSide == FORCE_LIGHTSIDE)
+	{
+		islight = 1;
+	}
+	trap_SendServerCommand(-1, va("ircg %i %i %i %i", ent->s.number, body->s.number, body->s.weapon, islight));
+
+	body->r.svFlags = ent->r.svFlags | SVF_BROADCAST;
+	VectorCopy (ent->r.mins, body->r.mins);
+	VectorCopy (ent->r.maxs, body->r.maxs);
+	VectorCopy (ent->r.absmin, body->r.absmin);
+	VectorCopy (ent->r.absmax, body->r.absmax);
+
+	body->s.torsoAnim = body->s.legsAnim = ent->client->ps.legsAnim;
+
+	body->s.customRGBA[0] = ent->client->ps.customRGBA[0];
+	body->s.customRGBA[1] = ent->client->ps.customRGBA[1];
+	body->s.customRGBA[2] = ent->client->ps.customRGBA[2];
+	body->s.customRGBA[3] = ent->client->ps.customRGBA[3];
+
+	body->clipmask = CONTENTS_SOLID | CONTENTS_PLAYERCLIP;
+	body->r.contents = CONTENTS_CORPSE;
+	body->r.ownerNum = ent->s.number;
+
+	body->nextthink = level.time + BODY_SINK_TIME;
+	body->think = BodySink;
+
+	body->die = body_die;
+
+	// don't take more damage if already gibbed
+	if ( ent->health <= GIB_HEALTH ) {
+		body->takedamage = qfalse;
+	} else {
+		body->takedamage = qtrue;
+	}
+
+	VectorCopy ( body->s.pos.trBase, body->r.currentOrigin );
+	trap_LinkEntity (body);
+
+	return qtrue;
+}
+
+//======================================================================
+
+
+/*
+==================
+SetClientViewAngle
+
+==================
+*/
+void SetClientViewAngle( gentity_t *ent, vec3_t angle ) {
+	int			i;
+
+	// set the delta angle
+	for (i=0 ; i<3 ; i++) {
+		int		cmdAngle;
+
+		cmdAngle = ANGLE2SHORT(angle[i]);
+		ent->client->ps.delta_angles[i] = cmdAngle - ent->client->pers.cmd.angles[i];
+	}
+	VectorCopy( angle, ent->s.angles );
+	VectorCopy (ent->s.angles, ent->client->ps.viewangles);
+}
+
+void MaintainBodyQueue(gentity_t *ent)
+{ //do whatever should be done taking ragdoll and dismemberment states into account.
+	qboolean doRCG = qfalse;
+
+	assert(ent && ent->client);
+	if (ent->client->tempSpectate > level.time ||
+		(ent->client->ps.eFlags2 & EF2_SHIP_DEATH))
+	{
+		ent->client->noCorpse = qtrue;
+	}
+
+	if (!ent->client->noCorpse && !ent->client->ps.fallingToDeath)
+	{
+		if (!CopyToBodyQue (ent))
+		{
+			doRCG = qtrue;
+		}
+	}
+	else
+	{
+		ent->client->noCorpse = qfalse; //clear it for next time
+		ent->client->ps.fallingToDeath = qfalse;
+		doRCG = qtrue;
+	}
+
+	if (doRCG)
+	{ //bodyque func didn't manage to call ircg so call this to assure our limbs and ragdoll states are proper on the client.
+		trap_SendServerCommand(-1, va("rcg %i", ent->s.clientNum));
+	}
+}
+
+/*
+================
+respawn
+================
+*/
+void SiegeRespawn(gentity_t *ent);
+void respawn( gentity_t *ent ) {
+	MaintainBodyQueue(ent);
+
+	if (gEscaping || g_gametype.integer == GT_POWERDUEL)
+	{
+		ent->client->sess.sessionTeam = TEAM_SPECTATOR;
+		ent->client->sess.spectatorState = SPECTATOR_FREE;
+		ent->client->sess.spectatorClient = 0;
+
+		ent->client->pers.teamState.state = TEAM_BEGIN;
+		ent->client->sess.spectatorTime = level.time;
+		ClientSpawn(ent);
+		ent->client->iAmALoser = qtrue;
+		return;
+	}
+
+	trap_UnlinkEntity (ent);
+
+	if (g_gametype.integer == GT_SIEGE)
+	{
+		if (g_siegeRespawn.integer)
+		{
+			if (ent->client->tempSpectate <= level.time)
+			{
+				int minDel = g_siegeRespawn.integer* 2000;
+				if (minDel < 20000)
+				{
+					minDel = 20000;
+				}
+				ent->client->tempSpectate = level.time + minDel;
+				ent->health = ent->client->ps.stats[STAT_HEALTH] = 1;
+				ent->client->ps.weapon = WP_NONE;
+				ent->client->ps.stats[STAT_WEAPONS] = 0;
+				ent->client->ps.stats[STAT_HOLDABLE_ITEMS] = 0;
+				ent->client->ps.stats[STAT_HOLDABLE_ITEM] = 0;
+				ent->takedamage = qfalse;
+				trap_LinkEntity(ent);
+
+				// Respawn time.
+				if ( ent->s.number < MAX_CLIENTS )
+				{
+					gentity_t *te = G_TempEntity( ent->client->ps.origin, EV_SIEGESPEC );
+					te->s.time = g_siegeRespawnCheck;
+					te->s.owner = ent->s.number;
+				}
+
+				return;
+			}
+		}
+		SiegeRespawn(ent);
+	}
+	else
+	{
+		gentity_t	*tent;
+
+		ClientSpawn(ent);
+
+		// add a teleportation effect
+		tent = G_TempEntity( ent->client->ps.origin, EV_PLAYER_TELEPORT_IN );
+		tent->s.clientNum = ent->s.clientNum;
+	}
+}
+
+/*
+================
+TeamCount
+
+Returns number of players on a team
+================
+*/
+team_t TeamCount( int ignoreClientNum, int team ) {
+	int		i;
+	int		count = 0;
+
+	for ( i = 0 ; i < level.maxclients ; i++ ) {
+		if ( i == ignoreClientNum ) {
+			continue;
+		}
+		if ( level.clients[i].pers.connected == CON_DISCONNECTED ) {
+			continue;
+		}
+		if ( level.clients[i].sess.sessionTeam == team ) {
+			count++;
+		}
+		else if (g_gametype.integer == GT_SIEGE &&
+            level.clients[i].sess.siegeDesiredTeam == team)
+		{
+			count++;
+		}
+	}
+
+	return count;
+}
+
+/*
+================
+TeamLeader
+
+Returns the client number of the team leader
+================
+*/
+int TeamLeader( int team ) {
+	int		i;
+
+	for ( i = 0 ; i < level.maxclients ; i++ ) {
+		if ( level.clients[i].pers.connected == CON_DISCONNECTED ) {
+			continue;
+		}
+		if ( level.clients[i].sess.sessionTeam == team ) {
+			if ( level.clients[i].sess.teamLeader )
+				return i;
+		}
+	}
+
+	return -1;
+}
+
+
+/*
+================
+PickTeam
+
+================
+*/
+team_t PickTeam( int ignoreClientNum ) {
+	int		counts[TEAM_NUM_TEAMS];
+
+	counts[TEAM_BLUE] = TeamCount( ignoreClientNum, TEAM_BLUE );
+	counts[TEAM_RED] = TeamCount( ignoreClientNum, TEAM_RED );
+
+	if ( counts[TEAM_BLUE] > counts[TEAM_RED] ) {
+		return TEAM_RED;
+	}
+	if ( counts[TEAM_RED] > counts[TEAM_BLUE] ) {
+		return TEAM_BLUE;
+	}
+	// equal team count, so join the team with the lowest score
+	if ( level.teamScores[TEAM_BLUE] > level.teamScores[TEAM_RED] ) {
+		return TEAM_RED;
+	}
+	return TEAM_BLUE;
+}
+
+/*
+===========
+ForceClientSkin
+
+Forces a client's skin (for teamplay)
+===========
+*/
+/*
+static void ForceClientSkin( gclient_t *client, char *model, const char *skin ) {
+	char *p;
+
+	if ((p = Q_strrchr(model, '/')) != 0) {
+		*p = 0;
+	}
+
+	Q_strcat(model, MAX_QPATH, "/");
+	Q_strcat(model, MAX_QPATH, skin);
+}
+*/
+
+/*
+===========
+ClientCheckName
+============
+*/
+static void ClientCleanName( const char *in, char *out, int outSize ) {
+	int		len, colorlessLen;
+	char	ch;
+	char	*p;
+	int		spaces;
+
+	//save room for trailing null byte
+	outSize--;
+
+	len = 0;
+	colorlessLen = 0;
+	p = out;
+	*p = 0;
+	spaces = 0;
+
+	while( 1 ) {
+		ch = *in++;
+		if( !ch ) {
+			break;
+		}
+
+		// don't allow leading spaces
+		if( !*p && ch == ' ' ) {
+			continue;
+		}
+
+		// check colors
+		if( ch == Q_COLOR_ESCAPE ) {
+			// solo trailing carat is not a color prefix
+			if( !*in ) {
+				break;
+			}
+
+			// don't allow black in a name, period
+			if( ColorIndex(*in) == 0 ) {
+				in++;
+				continue;
+			}
+
+			// make sure room in dest for both chars
+			if( len > outSize - 2 ) {
+				break;
+			}
+
+			*out++ = ch;
+			*out++ = *in++;
+			len += 2;
+			continue;
+		}
+
+		// don't allow too many consecutive spaces
+		if( ch == ' ' ) {
+			spaces++;
+			if( spaces > 3 ) {
+				continue;
+			}
+		}
+		else {
+			spaces = 0;
+		}
+
+		if( len > outSize - 1 ) {
+			break;
+		}
+
+		*out++ = ch;
+		colorlessLen++;
+		len++;
+	}
+	*out = 0;
+
+	// don't allow empty names
+	if( *p == 0 || colorlessLen == 0 ) {
+		Q_strncpyz( p, "Padawan", outSize );
+	}
+}
+
+#ifdef _DEBUG
+void G_DebugWrite(const char *path, const char *text)
+{
+	fileHandle_t f;
+
+	trap_FS_FOpenFile( path, &f, FS_APPEND );
+	trap_FS_Write(text, strlen(text), f);
+	trap_FS_FCloseFile(f);
+}
+#endif
+
+qboolean G_SaberModelSetup(gentity_t *ent)
+{
+	int i = 0;
+	qboolean fallbackForSaber = qtrue;
+
+	while (i < MAX_SABERS)
+	{
+		if (ent->client->saber[i].model[0])
+		{
+			//first kill it off if we've already got it
+			if (ent->client->weaponGhoul2[i])
+			{
+				trap_G2API_CleanGhoul2Models(&(ent->client->weaponGhoul2[i]));
+			}
+			trap_G2API_InitGhoul2Model(&ent->client->weaponGhoul2[i], ent->client->saber[i].model, 0, 0, -20, 0, 0);
+
+			if (ent->client->weaponGhoul2[i])
+			{
+				int j = 0;
+				char *tagName;
+				int tagBolt;
+
+				if (ent->client->saber[i].skin)
+				{
+					trap_G2API_SetSkin(ent->client->weaponGhoul2[i], 0, ent->client->saber[i].skin, ent->client->saber[i].skin);
+				}
+
+				// bolt to right hand for 0, or left hand for 1
+				trap_G2API_SetBoltInfo(ent->client->weaponGhoul2[i], 0, i);
+
+				//Add all the bolt points
+				while (j < ent->client->saber[i].numBlades)
+				{
+					tagName = va("*blade%i", j+1);
+					tagBolt = trap_G2API_AddBolt(ent->client->weaponGhoul2[i], 0, tagName);
+
+					if (tagBolt == -1)
+					{
+						if (j == 0)
+						{ //guess this is an 0ldsk3wl saber
+							tagBolt = trap_G2API_AddBolt(ent->client->weaponGhoul2[i], 0, "*flash");
+							fallbackForSaber = qfalse;
+							break;
+						}
+
+						if (tagBolt == -1)
+						{
+							assert(0);
+							break;
+
+						}
+					}
+					j++;
+
+					fallbackForSaber = qfalse; //got at least one custom saber so don't need default
+				}
+
+				//Copy it into the main instance
+				trap_G2API_CopySpecificGhoul2Model(ent->client->weaponGhoul2[i], 0, ent->ghoul2, i+1); 
+			}
+		}
+		else
+		{
+			break;
+		}
+
+		i++;
+	}
+
+	return fallbackForSaber;
+}
+
+/*
+===========
+SetupGameGhoul2Model
+
+There are two ghoul2 model instances per player (actually three).  One is on the clientinfo (the base for the client side 
+player, and copied for player spawns and for corpses).  One is attached to the centity itself, which is the model acutally 
+animated and rendered by the system.  The final is the game ghoul2 model.  This is animated by pmove on the server, and
+is used for determining where the lightsaber should be, and for per-poly collision tests.
+===========
+*/
+void *g2SaberInstance = NULL;
+
+#include "../namespace_begin.h"
+qboolean BG_IsValidCharacterModel(const char *modelName, const char *skinName);
+qboolean BG_ValidateSkinForTeam( const char *modelName, char *skinName, int team, float *colors );
+void BG_GetVehicleModelName(char *modelname);
+#include "../namespace_end.h"
+
+void SetupGameGhoul2Model(gentity_t *ent, char *modelname, char *skinName)
+{
+	int handle;
+	char		afilename[MAX_QPATH];
+#if 0
+	char		/**GLAName,*/ *slash;
+#endif
+	char		GLAName[MAX_QPATH];
+	vec3_t	tempVec = {0,0,0};
+
+	// First things first.  If this is a ghoul2 model, then let's make sure we demolish this first.
+	if (ent->ghoul2 && trap_G2_HaveWeGhoul2Models(ent->ghoul2))
+	{
+		trap_G2API_CleanGhoul2Models(&(ent->ghoul2));
+	}
+
+	//rww - just load the "standard" model for the server"
+	if (!precachedKyle)
+	{
+		int defSkin;
+
+		Com_sprintf( afilename, sizeof( afilename ), "models/players/kyle/model.glm" );
+		handle = trap_G2API_InitGhoul2Model(&precachedKyle, afilename, 0, 0, -20, 0, 0);
+
+		if (handle<0)
+		{
+			return;
+		}
+
+		defSkin = trap_R_RegisterSkin("models/players/kyle/model_default.skin");
+		trap_G2API_SetSkin(precachedKyle, 0, defSkin, defSkin);
+	}
+
+	if (precachedKyle && trap_G2_HaveWeGhoul2Models(precachedKyle))
+	{
+		if (d_perPlayerGhoul2.integer || ent->s.number >= MAX_CLIENTS ||
+			G_PlayerHasCustomSkeleton(ent))
+		{ //rww - allow option for perplayer models on server for collision and bolt stuff.
+			char modelFullPath[MAX_QPATH];
+			char truncModelName[MAX_QPATH];
+			char skin[MAX_QPATH];
+			char vehicleName[MAX_QPATH];
+			int skinHandle = 0;
+			int i = 0;
+			char *p;
+
+			// If this is a vehicle, get it's model name.
+			if ( ent->client->NPC_class == CLASS_VEHICLE )
+			{
+				strcpy(vehicleName, modelname);
+				BG_GetVehicleModelName(modelname);
+				strcpy(truncModelName, modelname);
+				skin[0] = 0;
+				if ( ent->m_pVehicle
+					&& ent->m_pVehicle->m_pVehicleInfo
+					&& ent->m_pVehicle->m_pVehicleInfo->skin
+					&& ent->m_pVehicle->m_pVehicleInfo->skin[0] )
+				{
+					skinHandle = trap_R_RegisterSkin(va("models/players/%s/model_%s.skin", modelname, ent->m_pVehicle->m_pVehicleInfo->skin));
+				}
+				else
+				{
+					skinHandle = trap_R_RegisterSkin(va("models/players/%s/model_default.skin", modelname));
+				}
+			}
+			else
+			{
+				if (skinName && skinName[0])
+				{
+					strcpy(skin, skinName);
+					strcpy(truncModelName, modelname);
+				}
+				else
+				{
+					strcpy(skin, "default");
+
+					strcpy(truncModelName, modelname);
+					p = Q_strrchr(truncModelName, '/');
+
+					if (p)
+					{
+						*p = 0;
+						p++;
+
+						while (p && *p)
+						{
+							skin[i] = *p;
+							i++;
+							p++;
+						}
+						skin[i] = 0;
+						i = 0;
+					}
+
+					if (!BG_IsValidCharacterModel(truncModelName, skin))
+					{
+						strcpy(truncModelName, "kyle");
+						strcpy(skin, "default");
+					}
+
+					if ( g_gametype.integer >= GT_TEAM && g_gametype.integer != GT_SIEGE && !g_trueJedi.integer )
+					{
+						BG_ValidateSkinForTeam( truncModelName, skin, ent->client->sess.sessionTeam, NULL );
+					}
+					else if (g_gametype.integer == GT_SIEGE)
+					{ //force skin for class if appropriate
+						if (ent->client->siegeClass != -1)
+						{
+							siegeClass_t *scl = &bgSiegeClasses[ent->client->siegeClass];
+							if (scl->forcedSkin[0])
+							{
+								strcpy(skin, scl->forcedSkin);
+							}
+						}
+					}
+				}
+			}
+
+			if (skin[0])
+			{
+				char *useSkinName;
+
+				if (strchr(skin, '|'))
+				{//three part skin
+					useSkinName = va("models/players/%s/|%s", truncModelName, skin);
+				}
+				else
+				{
+					useSkinName = va("models/players/%s/model_%s.skin", truncModelName, skin);
+				}
+
+				skinHandle = trap_R_RegisterSkin(useSkinName);
+			}
+
+			strcpy(modelFullPath, va("models/players/%s/model.glm", truncModelName));
+			handle = trap_G2API_InitGhoul2Model(&ent->ghoul2, modelFullPath, 0, skinHandle, -20, 0, 0);
+
+			if (handle<0)
+			{ //Huh. Guess we don't have this model. Use the default.
+
+				if (ent->ghoul2 && trap_G2_HaveWeGhoul2Models(ent->ghoul2))
+				{
+					trap_G2API_CleanGhoul2Models(&(ent->ghoul2));
+				}
+				ent->ghoul2 = NULL;
+				trap_G2API_DuplicateGhoul2Instance(precachedKyle, &ent->ghoul2);
+			}
+			else
+			{
+				trap_G2API_SetSkin(ent->ghoul2, 0, skinHandle, skinHandle);
+
+				GLAName[0] = 0;
+				trap_G2API_GetGLAName( ent->ghoul2, 0, GLAName);
+
+				if (!GLAName[0] || (!strstr(GLAName, "players/_humanoid/") && ent->s.number < MAX_CLIENTS && !G_PlayerHasCustomSkeleton(ent)))
+				{ //a bad model
+					trap_G2API_CleanGhoul2Models(&(ent->ghoul2));
+					ent->ghoul2 = NULL;
+					trap_G2API_DuplicateGhoul2Instance(precachedKyle, &ent->ghoul2);
+				}
+
+				if (ent->s.number >= MAX_CLIENTS)
+				{
+					ent->s.modelGhoul2 = 1; //so we know to free it on the client when we're removed.
+
+					if (skin[0])
+					{ //append it after a *
+						strcat( modelFullPath, va("*%s", skin) );
+					}
+
+					if ( ent->client->NPC_class == CLASS_VEHICLE )
+					{ //vehicles are tricky and send over their vehicle names as the model (the model is then retrieved based on the vehicle name)
+						ent->s.modelindex = G_ModelIndex(vehicleName);
+					}
+					else
+					{
+						ent->s.modelindex = G_ModelIndex(modelFullPath);
+					}
+				}
+			}
+		}
+		else
+		{
+			trap_G2API_DuplicateGhoul2Instance(precachedKyle, &ent->ghoul2);
+		}
+	}
+	else
+	{
+		return;
+	}
+
+	//Attach the instance to this entity num so we can make use of client-server
+	//shared operations if possible.
+	trap_G2API_AttachInstanceToEntNum(ent->ghoul2, ent->s.number, qtrue);
+
+	// The model is now loaded.
+
+	GLAName[0] = 0;
+
+	if (!BGPAFtextLoaded)
+	{
+		if (BG_ParseAnimationFile("models/players/_humanoid/animation.cfg", bgHumanoidAnimations, qtrue) == -1)
+		{
+			Com_Printf( "Failed to load humanoid animation file\n");
+			return;
+		}
+	}
+
+	if (ent->s.number >= MAX_CLIENTS || G_PlayerHasCustomSkeleton(ent))
+	{
+		ent->localAnimIndex = -1;
+
+		GLAName[0] = 0;
+		trap_G2API_GetGLAName(ent->ghoul2, 0, GLAName);
+
+		if (GLAName[0] &&
+			!strstr(GLAName, "players/_humanoid/") /*&&
+			!strstr(GLAName, "players/rockettrooper/")*/)
+		{ //it doesn't use humanoid anims.
+			char *slash = Q_strrchr( GLAName, '/' );
+			if ( slash )
+			{
+				strcpy(slash, "/animation.cfg");
+
+				ent->localAnimIndex = BG_ParseAnimationFile(GLAName, NULL, qfalse);
+			}
+		}
+		else
+		{ //humanoid index.
+			if (strstr(GLAName, "players/rockettrooper/"))
+			{
+				ent->localAnimIndex = 1;
+			}
+			else
+			{
+				ent->localAnimIndex = 0;
+			}
+		}
+
+		if (ent->localAnimIndex == -1)
+		{
+			Com_Error(ERR_DROP, "NPC had an invalid GLA\n");
+		}
+	}
+	else
+	{
+		GLAName[0] = 0;
+		trap_G2API_GetGLAName(ent->ghoul2, 0, GLAName);
+
+		if (strstr(GLAName, "players/rockettrooper/"))
+		{
+			//assert(!"Should not have gotten in here with rockettrooper skel");
+			ent->localAnimIndex = 1;
+		}
+		else
+		{
+			ent->localAnimIndex = 0;
+		}
+	}
+
+	if (ent->s.NPC_class == CLASS_VEHICLE &&
+		ent->m_pVehicle)
+	{ //do special vehicle stuff
+		char strTemp[128];
+		int i;
+
+		// Setup the default first bolt
+		i = trap_G2API_AddBolt( ent->ghoul2, 0, "model_root" );
+
+		// Setup the droid unit.
+		ent->m_pVehicle->m_iDroidUnitTag = trap_G2API_AddBolt( ent->ghoul2, 0, "*droidunit" );
+
+		// Setup the Exhausts.
+		for ( i = 0; i < MAX_VEHICLE_EXHAUSTS; i++ )
+		{
+			Com_sprintf( strTemp, 128, "*exhaust%i", i + 1 );
+			ent->m_pVehicle->m_iExhaustTag[i] = trap_G2API_AddBolt( ent->ghoul2, 0, strTemp );
+		}
+
+		// Setup the Muzzles.
+		for ( i = 0; i < MAX_VEHICLE_MUZZLES; i++ )
+		{
+			Com_sprintf( strTemp, 128, "*muzzle%i", i + 1 );
+			ent->m_pVehicle->m_iMuzzleTag[i] = trap_G2API_AddBolt( ent->ghoul2, 0, strTemp );
+			if ( ent->m_pVehicle->m_iMuzzleTag[i] == -1 )
+			{//ergh, try *flash?
+				Com_sprintf( strTemp, 128, "*flash%i", i + 1 );
+				ent->m_pVehicle->m_iMuzzleTag[i] = trap_G2API_AddBolt( ent->ghoul2, 0, strTemp );
+			}
+		}
+
+		// Setup the Turrets.
+		for ( i = 0; i < MAX_VEHICLE_TURRET_MUZZLES; i++ )
+		{
+			if ( ent->m_pVehicle->m_pVehicleInfo->turret[i].gunnerViewTag )
+			{
+				ent->m_pVehicle->m_iGunnerViewTag[i] = trap_G2API_AddBolt( ent->ghoul2, 0, ent->m_pVehicle->m_pVehicleInfo->turret[i].gunnerViewTag );
+			}
+			else
+			{
+				ent->m_pVehicle->m_iGunnerViewTag[i] = -1;
+			}
+		}
+	}
+	
+	if (ent->client->ps.weapon == WP_SABER || ent->s.number < MAX_CLIENTS)
+	{ //a player or NPC saber user
+		trap_G2API_AddBolt(ent->ghoul2, 0, "*r_hand");
+		trap_G2API_AddBolt(ent->ghoul2, 0, "*l_hand");
+
+		//rhand must always be first bolt. lhand always second. Whichever you want the
+		//jetpack bolted to must always be third.
+		trap_G2API_AddBolt(ent->ghoul2, 0, "*chestg");
+
+		trap_G2API_SetBoneAnim(ent->ghoul2, 0, "model_root", 0, 12, BONE_ANIM_OVERRIDE_LOOP, 1.0f, level.time, -1, -1);
+		trap_G2API_SetBoneAngles(ent->ghoul2, 0, "upper_lumbar", tempVec, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, NULL, 0, level.time);
+		trap_G2API_SetBoneAngles(ent->ghoul2, 0, "cranium", tempVec, BONE_ANGLES_POSTMULT, POSITIVE_Z, NEGATIVE_Y, POSITIVE_X, NULL, 0, level.time);
+
+		if (!g2SaberInstance)
+		{
+			trap_G2API_InitGhoul2Model(&g2SaberInstance, "models/weapons2/saber/saber_w.glm", 0, 0, -20, 0, 0);
+
+			if (g2SaberInstance)
+			{
+				// indicate we will be bolted to model 0 (ie the player) on bolt 0 (always the right hand) when we get copied
+				trap_G2API_SetBoltInfo(g2SaberInstance, 0, 0);
+				// now set up the gun bolt on it
+				trap_G2API_AddBolt(g2SaberInstance, 0, "*blade1");
+			}
+		}
+
+		if (G_SaberModelSetup(ent))
+		{
+			if (g2SaberInstance)
+			{
+				trap_G2API_CopySpecificGhoul2Model(g2SaberInstance, 0, ent->ghoul2, 1); 
+			}
+		}
+	}
+
+	if (ent->s.number >= MAX_CLIENTS)
+	{ //some extra NPC stuff
+		if (trap_G2API_AddBolt(ent->ghoul2, 0, "lower_lumbar") == -1)
+		{ //check now to see if we have this bone for setting anims and such
+			ent->noLumbar = qtrue;
+		}
+	}
+}
+
+
+
+
+/*
+===========
+ClientUserInfoChanged
+
+Called from ClientConnect when the player first connects and
+directly by the server system when the player updates a userinfo variable.
+
+The game can override any of the settings and call trap_SetUserinfo
+if desired.
+============
+*/
+qboolean G_SetSaber(gentity_t *ent, int saberNum, char *saberName, qboolean siegeOverride);
+void G_ValidateSiegeClassForTeam(gentity_t *ent, int team);
+void ClientUserinfoChanged( int clientNum ) {
+	gentity_t *ent;
+	int		teamTask, teamLeader, team, health;
+	char	*s;
+	char	model[MAX_QPATH];
+	//char	headModel[MAX_QPATH];
+	char	forcePowers[MAX_QPATH];
+	char	oldname[MAX_STRING_CHARS];
+	gclient_t	*client;
+	char	c1[MAX_INFO_STRING];
+	char	c2[MAX_INFO_STRING];
+	char	redTeam[MAX_INFO_STRING];
+	char	blueTeam[MAX_INFO_STRING];
+	char	userinfo[MAX_INFO_STRING];
+	char	className[MAX_QPATH]; //name of class type to use in siege
+	char	saberName[MAX_QPATH];
+	char	saber2Name[MAX_QPATH];
+	char	*value;
+	int		maxHealth;
+	qboolean	modelChanged = qfalse;
+
+	ent = g_entities + clientNum;
+	client = ent->client;
+
+	trap_GetUserinfo( clientNum, userinfo, sizeof( userinfo ) );
+
+	// check for malformed or illegal info strings
+	if ( !Info_Validate(userinfo) ) {
+		strcpy (userinfo, "\\name\\badinfo");
+	}
+
+	// check for local client
+	s = Info_ValueForKey( userinfo, "ip" );
+	if ( !strcmp( s, "localhost" ) ) {
+		client->pers.localClient = qtrue;
+	}
+
+	// check the item prediction
+	s = Info_ValueForKey( userinfo, "cg_predictItems" );
+	if ( !atoi( s ) ) {
+		client->pers.predictItemPickup = qfalse;
+	} else {
+		client->pers.predictItemPickup = qtrue;
+	}
+
+	// set name
+	Q_strncpyz ( oldname, client->pers.netname, sizeof( oldname ) );
+	s = Info_ValueForKey (userinfo, "name");
+	ClientCleanName( s, client->pers.netname, sizeof(client->pers.netname) );
+
+	if ( client->sess.sessionTeam == TEAM_SPECTATOR ) {
+		if ( client->sess.spectatorState == SPECTATOR_SCOREBOARD ) {
+			Q_strncpyz( client->pers.netname, "scoreboard", sizeof(client->pers.netname) );
+		}
+	}
+
+	if ( client->pers.connected == CON_CONNECTED ) {
+		if ( strcmp( oldname, client->pers.netname ) ) 
+		{
+			if ( client->pers.netnameTime > level.time  )
+			{
+				trap_SendServerCommand( clientNum, va("print \"%s\n\"", G_GetStringEdString("MP_SVGAME", "NONAMECHANGE")) );
+
+				Info_SetValueForKey( userinfo, "name", oldname );
+				trap_SetUserinfo( clientNum, userinfo );			
+				strcpy ( client->pers.netname, oldname );
+			}
+			else
+			{				
+				trap_SendServerCommand( -1, va("print \"%s" S_COLOR_WHITE " %s %s\n\"", oldname, G_GetStringEdString("MP_SVGAME", "PLRENAME"), client->pers.netname) );
+				client->pers.netnameTime = level.time + 5000;
+			}
+		}
+	}
+
+	// set model
+	Q_strncpyz( model, Info_ValueForKey (userinfo, "model"), sizeof( model ) );
+
+	if (d_perPlayerGhoul2.integer)
+	{
+		if (Q_stricmp(model, client->modelname))
+		{
+			strcpy(client->modelname, model);
+			modelChanged = qtrue;
+		}
+	}
+
+	//Get the skin RGB based on his userinfo
+	value = Info_ValueForKey (userinfo, "char_color_red");
+	if (value)
+	{
+		client->ps.customRGBA[0] = atoi(value);
+	}
+	else
+	{
+		client->ps.customRGBA[0] = 255;
+	}
+
+	value = Info_ValueForKey (userinfo, "char_color_green");
+	if (value)
+	{
+		client->ps.customRGBA[1] = atoi(value);
+	}
+	else
+	{
+		client->ps.customRGBA[1] = 255;
+	}
+
+	value = Info_ValueForKey (userinfo, "char_color_blue");
+	if (value)
+	{
+		client->ps.customRGBA[2] = atoi(value);
+	}
+	else
+	{
+		client->ps.customRGBA[2] = 255;
+	}
+
+	if ((client->ps.customRGBA[0]+client->ps.customRGBA[1]+client->ps.customRGBA[2]) < 100)
+	{ //hmm, too dark!
+		client->ps.customRGBA[0] = client->ps.customRGBA[1] = client->ps.customRGBA[2] = 255;
+	}
+
+	client->ps.customRGBA[3]=255;
+
+	Q_strncpyz( forcePowers, Info_ValueForKey (userinfo, "forcepowers"), sizeof( forcePowers ) );
+
+	// bots set their team a few frames later
+	if (g_gametype.integer >= GT_TEAM && g_entities[clientNum].r.svFlags & SVF_BOT) {
+		s = Info_ValueForKey( userinfo, "team" );
+		if ( !Q_stricmp( s, "red" ) || !Q_stricmp( s, "r" ) ) {
+			team = TEAM_RED;
+		} else if ( !Q_stricmp( s, "blue" ) || !Q_stricmp( s, "b" ) ) {
+			team = TEAM_BLUE;
+		} else {
+			// pick the team with the least number of players
+			team = PickTeam( clientNum );
+		}
+	}
+	else {
+		team = client->sess.sessionTeam;
+	}
+
+	//Set the siege class
+	if (g_gametype.integer == GT_SIEGE)
+	{
+		strcpy(className, client->sess.siegeClass);
+
+		//This function will see if the given class is legal for the given team.
+		//If not className will be filled in with the first legal class for this team.
+/*		if (!BG_SiegeCheckClassLegality(team, className) &&
+			Q_stricmp(client->sess.siegeClass, "none"))
+		{ //if it isn't legal pop up the class menu
+			trap_SendServerCommand(ent-g_entities, "scl");
+		}
+*/
+		//Now that the team is legal for sure, we'll go ahead and get an index for it.
+		client->siegeClass = BG_SiegeFindClassIndexByName(className);
+		if (client->siegeClass == -1)
+		{ //ok, get the first valid class for the team you're on then, I guess.
+			BG_SiegeCheckClassLegality(team, className);
+			strcpy(client->sess.siegeClass, className);
+			client->siegeClass = BG_SiegeFindClassIndexByName(className);
+		}
+		else
+		{ //otherwise, make sure the class we are using is legal.
+			G_ValidateSiegeClassForTeam(ent, team);
+			strcpy(className, client->sess.siegeClass);
+		}
+
+		//Set the sabers if the class dictates
+		if (client->siegeClass != -1)
+		{
+			siegeClass_t *scl = &bgSiegeClasses[client->siegeClass];
+
+			if (scl->saber1[0])
+			{
+				G_SetSaber(ent, 0, scl->saber1, qtrue);
+			}
+			else
+			{ //default I guess
+				G_SetSaber(ent, 0, "Kyle", qtrue);
+			}
+			if (scl->saber2[0])
+			{
+				G_SetSaber(ent, 1, scl->saber2, qtrue);
+			}
+			else
+			{ //no second saber then
+				G_SetSaber(ent, 1, "none", qtrue);
+			}
+
+			//make sure the saber models are updated
+			G_SaberModelSetup(ent);
+
+			if (scl->forcedModel[0])
+			{ //be sure to override the model we actually use
+				strcpy(model, scl->forcedModel);
+				if (d_perPlayerGhoul2.integer)
+				{
+					if (Q_stricmp(model, client->modelname))
+					{
+						strcpy(client->modelname, model);
+						modelChanged = qtrue;
+					}
+				}
+			}
+
+			//force them to use their class model on the server, if the class dictates
+			if (G_PlayerHasCustomSkeleton(ent))
+			{
+				if (Q_stricmp(model, client->modelname) || ent->localAnimIndex == 0)
+				{
+					strcpy(client->modelname, model);
+					modelChanged = qtrue;
+				}
+			}
+		}
+	}
+	else
+	{
+		strcpy(className, "none");
+	}
+
+	//Set the saber name
+	strcpy(saberName, client->sess.saberType);
+	strcpy(saber2Name, client->sess.saber2Type);
+
+	// set max health
+	if (g_gametype.integer == GT_SIEGE && client->siegeClass != -1)
+	{
+		siegeClass_t *scl = &bgSiegeClasses[client->siegeClass];
+		maxHealth = 100;
+
+		if (scl->maxhealth)
+		{
+			maxHealth = scl->maxhealth;
+		}
+
+		health = maxHealth;
+	}
+	else
+	{
+		maxHealth = 100;
+		health = 100; //atoi( Info_ValueForKey( userinfo, "handicap" ) );
+	}
+	client->pers.maxHealth = health;
+	if ( client->pers.maxHealth < 1 || client->pers.maxHealth > maxHealth ) {
+		client->pers.maxHealth = 100;
+	}
+	client->ps.stats[STAT_MAX_HEALTH] = client->pers.maxHealth;
+
+/*	NOTE: all client side now
+
+	// team
+	switch( team ) {
+	case TEAM_RED:
+		ForceClientSkin(client, model, "red");
+//		ForceClientSkin(client, headModel, "red");
+		break;
+	case TEAM_BLUE:
+		ForceClientSkin(client, model, "blue");
+//		ForceClientSkin(client, headModel, "blue");
+		break;
+	}
+	// don't ever use a default skin in teamplay, it would just waste memory
+	// however bots will always join a team but they spawn in as spectator
+	if ( g_gametype.integer >= GT_TEAM && team == TEAM_SPECTATOR) {
+		ForceClientSkin(client, model, "red");
+//		ForceClientSkin(client, headModel, "red");
+	}
+*/
+
+	if (g_gametype.integer >= GT_TEAM) {
+		client->pers.teamInfo = qtrue;
+	} else {
+		s = Info_ValueForKey( userinfo, "teamoverlay" );
+		if ( ! *s || atoi( s ) != 0 ) {
+			client->pers.teamInfo = qtrue;
+		} else {
+			client->pers.teamInfo = qfalse;
+		}
+	}
+	/*
+	s = Info_ValueForKey( userinfo, "cg_pmove_fixed" );
+	if ( !*s || atoi( s ) == 0 ) {
+		client->pers.pmoveFixed = qfalse;
+	}
+	else {
+		client->pers.pmoveFixed = qtrue;
+	}
+	*/
+
+	// team task (0 = none, 1 = offence, 2 = defence)
+	teamTask = atoi(Info_ValueForKey(userinfo, "teamtask"));
+	// team Leader (1 = leader, 0 is normal player)
+	teamLeader = client->sess.teamLeader;
+
+	// colors
+	strcpy(c1, Info_ValueForKey( userinfo, "color1" ));
+	strcpy(c2, Info_ValueForKey( userinfo, "color2" ));
+
+	strcpy(redTeam, Info_ValueForKey( userinfo, "g_redteam" ));
+	strcpy(blueTeam, Info_ValueForKey( userinfo, "g_blueteam" ));
+
+	// send over a subset of the userinfo keys so other clients can
+	// print scoreboards, display models, and play custom sounds
+	if ( ent->r.svFlags & SVF_BOT ) {
+		s = va("n\\%s\\t\\%i\\model\\%s\\c1\\%s\\c2\\%s\\hc\\%i\\w\\%i\\l\\%i\\skill\\%s\\tt\\%d\\tl\\%d\\siegeclass\\%s\\st\\%s\\st2\\%s\\dt\\%i\\sdt\\%i",
+			client->pers.netname, team, model,  c1, c2, 
+			client->pers.maxHealth, client->sess.wins, client->sess.losses,
+			Info_ValueForKey( userinfo, "skill" ), teamTask, teamLeader, className, saberName, saber2Name, client->sess.duelTeam, client->sess.siegeDesiredTeam );
+	} else {
+		if (g_gametype.integer == GT_SIEGE)
+		{ //more crap to send
+			s = va("n\\%s\\t\\%i\\model\\%s\\g_redteam\\%s\\g_blueteam\\%s\\c1\\%s\\c2\\%s\\hc\\%i\\w\\%i\\l\\%i\\tt\\%d\\tl\\%d\\siegeclass\\%s\\st\\%s\\st2\\%s\\dt\\%i\\sdt\\%i",
+				client->pers.netname, client->sess.sessionTeam, model, redTeam, blueTeam, c1, c2, 
+				client->pers.maxHealth, client->sess.wins, client->sess.losses, teamTask, teamLeader, className, saberName, saber2Name, client->sess.duelTeam, client->sess.siegeDesiredTeam);
+		}
+		else
+		{
+			s = va("n\\%s\\t\\%i\\model\\%s\\g_redteam\\%s\\g_blueteam\\%s\\c1\\%s\\c2\\%s\\hc\\%i\\w\\%i\\l\\%i\\tt\\%d\\tl\\%d\\st\\%s\\st2\\%s\\dt\\%i",
+				client->pers.netname, client->sess.sessionTeam, model, redTeam, blueTeam, c1, c2, 
+				client->pers.maxHealth, client->sess.wins, client->sess.losses, teamTask, teamLeader, saberName, saber2Name, client->sess.duelTeam);
+		}
+	}
+
+	trap_SetConfigstring( CS_PLAYERS+clientNum, s );
+
+	if (modelChanged) //only going to be true for allowable server-side custom skeleton cases
+	{ //update the server g2 instance if appropriate
+		char *modelname = Info_ValueForKey (userinfo, "model");
+		SetupGameGhoul2Model(ent, modelname, NULL);
+
+		if (ent->ghoul2 && ent->client)
+		{
+			ent->client->renderInfo.lastG2 = NULL; //update the renderinfo bolts next update.
+		}
+
+		client->torsoAnimExecute = client->legsAnimExecute = -1;
+		client->torsoLastFlip = client->legsLastFlip = qfalse;
+	}
+
+	if (g_logClientInfo.integer)
+	{
+		G_LogPrintf( "ClientUserinfoChanged: %i %s\n", clientNum, s );
+	}
+}
+
+
+/*
+===========
+ClientConnect
+
+Called when a player begins connecting to the server.
+Called again for every map change or tournement restart.
+
+The session information will be valid after exit.
+
+Return NULL if the client should be allowed, otherwise return
+a string with the reason for denial.
+
+Otherwise, the client will be sent the current gamestate
+and will eventually get to ClientBegin.
+
+firstTime will be qtrue the very first time a client connects
+to the server machine, but qfalse on map changes and tournement
+restarts.
+============
+*/
+char *ClientConnect( int clientNum, qboolean firstTime, qboolean isBot ) {
+	char		*value;
+//	char		*areabits;
+	gclient_t	*client;
+	char		userinfo[MAX_INFO_STRING];
+	gentity_t	*ent;
+	gentity_t	*te;
+
+	ent = &g_entities[ clientNum ];
+
+	trap_GetUserinfo( clientNum, userinfo, sizeof( userinfo ) );
+
+	// check to see if they are on the banned IP list
+	value = Info_ValueForKey (userinfo, "ip");
+	if ( G_FilterPacket( value ) ) {
+		return "Banned.";
+	}
+
+	if ( !( ent->r.svFlags & SVF_BOT ) && !isBot && g_needpass.integer ) {
+		// check for a password
+		value = Info_ValueForKey (userinfo, "password");
+		if ( g_password.string[0] && Q_stricmp( g_password.string, "none" ) &&
+			strcmp( g_password.string, value) != 0) {
+			static char sTemp[1024];
+			Q_strncpyz(sTemp, G_GetStringEdString("MP_SVGAME","INVALID_ESCAPE_TO_MAIN"), sizeof (sTemp) );
+			return sTemp;// return "Invalid password";
+		}
+	}
+
+	// they can connect
+	ent->client = level.clients + clientNum;
+	client = ent->client;
+
+	//assign the pointer for bg entity access
+	ent->playerState = &ent->client->ps;
+
+//	areabits = client->areabits;
+
+	memset( client, 0, sizeof(*client) );
+
+	client->pers.connected = CON_CONNECTING;
+
+	// read or initialize the session data
+	if ( firstTime || level.newSession ) {
+		G_InitSessionData( client, userinfo, isBot );
+	}
+	G_ReadSessionData( client );
+
+	if (g_gametype.integer == GT_SIEGE &&
+		(firstTime || level.newSession))
+	{ //if this is the first time then auto-assign a desired siege team and show briefing for that team
+		client->sess.siegeDesiredTeam = 0;//PickTeam(ent->s.number);
+		/*
+		trap_SendServerCommand(ent->s.number, va("sb %i", client->sess.siegeDesiredTeam));
+		*/
+		//don't just show it - they'll see it if they switch to a team on purpose.
+	}
+
+
+	if (g_gametype.integer == GT_SIEGE && client->sess.sessionTeam != TEAM_SPECTATOR)
+	{
+		if (firstTime || level.newSession)
+		{ //start as spec
+			client->sess.siegeDesiredTeam = client->sess.sessionTeam;
+			client->sess.sessionTeam = TEAM_SPECTATOR;
+		}
+	}
+	else if (g_gametype.integer == GT_POWERDUEL && client->sess.sessionTeam != TEAM_SPECTATOR)
+	{
+		client->sess.sessionTeam = TEAM_SPECTATOR;
+	}
+
+	if( isBot ) {
+		ent->r.svFlags |= SVF_BOT;
+		ent->inuse = qtrue;
+		if( !G_BotConnect( clientNum, !firstTime ) ) {
+			return "BotConnectfailed";
+		}
+	}
+
+	// get and distribute relevent paramters
+	G_LogPrintf( "ClientConnect: %i\n", clientNum );
+	ClientUserinfoChanged( clientNum );
+
+	// don't do the "xxx connected" messages if they were caried over from previous level
+	if ( firstTime ) {
+		trap_SendServerCommand( -1, va("print \"%s" S_COLOR_WHITE " %s\n\"", client->pers.netname, G_GetStringEdString("MP_SVGAME", "PLCONNECT")) );
+	}
+
+	if ( g_gametype.integer >= GT_TEAM &&
+		client->sess.sessionTeam != TEAM_SPECTATOR ) {
+		BroadcastTeamChange( client, -1 );
+	}
+
+	// count current clients and rank for scoreboard
+	CalculateRanks();
+
+	te = G_TempEntity( vec3_origin, EV_CLIENTJOIN );
+	te->r.svFlags |= SVF_BROADCAST;
+	te->s.eventParm = clientNum;
+
+	// for statistics
+//	client->areabits = areabits;
+//	if ( !client->areabits )
+//		client->areabits = G_Alloc( (trap_AAS_PointReachabilityAreaIndex( NULL ) + 7) / 8 );
+
+	return NULL;
+}
+
+void G_WriteClientSessionData( gclient_t *client );
+
+#include "../namespace_begin.h"
+void WP_SetSaber( int entNum, saberInfo_t *sabers, int saberNum, const char *saberName );
+#include "../namespace_end.h"
+
+/*
+===========
+ClientBegin
+
+called when a client has finished connecting, and is ready
+to be placed into the level.  This will happen every level load,
+and on transition between teams, but doesn't happen on respawns
+============
+*/
+extern qboolean	gSiegeRoundBegun;
+extern qboolean	gSiegeRoundEnded;
+void SetTeamQuick(gentity_t *ent, int team, qboolean doBegin);
+void ClientBegin( int clientNum, qboolean allowTeamReset ) {
+	gentity_t	*ent;
+	gclient_t	*client;
+	gentity_t	*tent;
+	int			flags, i;
+	char		userinfo[MAX_INFO_VALUE], *modelname;
+
+	ent = g_entities + clientNum;
+
+	if ((ent->r.svFlags & SVF_BOT) && g_gametype.integer >= GT_TEAM)
+	{
+		if (allowTeamReset)
+		{
+			const char *team = "Red";
+			int preSess;
+
+			//SetTeam(ent, "");
+			ent->client->sess.sessionTeam = PickTeam(-1);
+			trap_GetUserinfo(clientNum, userinfo, MAX_INFO_STRING);
+
+			if (ent->client->sess.sessionTeam == TEAM_SPECTATOR)
+			{
+				ent->client->sess.sessionTeam = TEAM_RED;
+			}
+
+			if (ent->client->sess.sessionTeam == TEAM_RED)
+			{
+				team = "Red";
+			}
+			else
+			{
+				team = "Blue";
+			}
+
+			Info_SetValueForKey( userinfo, "team", team );
+
+			trap_SetUserinfo( clientNum, userinfo );
+
+			ent->client->ps.persistant[ PERS_TEAM ] = ent->client->sess.sessionTeam;
+
+			preSess = ent->client->sess.sessionTeam;
+			G_ReadSessionData( ent->client );
+			ent->client->sess.sessionTeam = preSess;
+			G_WriteClientSessionData(ent->client);
+			ClientUserinfoChanged( clientNum );
+			ClientBegin(clientNum, qfalse);
+			return;
+		}
+	}
+
+	client = level.clients + clientNum;
+
+	if ( ent->r.linked ) {
+		trap_UnlinkEntity( ent );
+	}
+	G_InitGentity( ent );
+	ent->touch = 0;
+	ent->pain = 0;
+	ent->client = client;
+
+	//assign the pointer for bg entity access
+	ent->playerState = &ent->client->ps;
+
+	client->pers.connected = CON_CONNECTED;
+	client->pers.enterTime = level.time;
+	client->pers.teamState.state = TEAM_BEGIN;
+
+	// save eflags around this, because changing teams will
+	// cause this to happen with a valid entity, and we
+	// want to make sure the teleport bit is set right
+	// so the viewpoint doesn't interpolate through the
+	// world to the new position
+	flags = client->ps.eFlags;
+
+	i = 0;
+
+	while (i < NUM_FORCE_POWERS)
+	{
+		if (ent->client->ps.fd.forcePowersActive & (1 << i))
+		{
+			WP_ForcePowerStop(ent, i);
+		}
+		i++;
+	}
+
+	i = TRACK_CHANNEL_1;
+
+	while (i < NUM_TRACK_CHANNELS)
+	{
+		if (ent->client->ps.fd.killSoundEntIndex[i-50] && ent->client->ps.fd.killSoundEntIndex[i-50] < MAX_GENTITIES && ent->client->ps.fd.killSoundEntIndex[i-50] > 0)
+		{
+			G_MuteSound(ent->client->ps.fd.killSoundEntIndex[i-50], CHAN_VOICE);
+		}
+		i++;
+	}
+	i = 0;
+
+	memset( &client->ps, 0, sizeof( client->ps ) );
+	client->ps.eFlags = flags;
+
+	client->ps.hasDetPackPlanted = qfalse;
+
+	//first-time force power initialization
+	WP_InitForcePowers( ent );
+
+	//init saber ent
+	WP_SaberInitBladeData( ent );
+
+	// First time model setup for that player.
+	trap_GetUserinfo( clientNum, userinfo, sizeof(userinfo) );
+	modelname = Info_ValueForKey (userinfo, "model");
+	SetupGameGhoul2Model(ent, modelname, NULL);
+
+	if (ent->ghoul2 && ent->client)
+	{
+		ent->client->renderInfo.lastG2 = NULL; //update the renderinfo bolts next update.
+	}
+
+	if (g_gametype.integer == GT_POWERDUEL && client->sess.sessionTeam != TEAM_SPECTATOR &&
+		client->sess.duelTeam == DUELTEAM_FREE)
+	{
+		SetTeam(ent, "s");
+	}
+	else
+	{
+		if (g_gametype.integer == GT_SIEGE && (!gSiegeRoundBegun || gSiegeRoundEnded))
+		{
+			SetTeamQuick(ent, TEAM_SPECTATOR, qfalse);
+		}
+        
+		if ((ent->r.svFlags & SVF_BOT) &&
+			g_gametype.integer != GT_SIEGE)
+		{
+			char *saberVal = Info_ValueForKey(userinfo, "saber1");
+			char *saber2Val = Info_ValueForKey(userinfo, "saber2");
+
+			if (!saberVal || !saberVal[0])
+			{ //blah, set em up with a random saber
+				int r = rand()%50;
+				char sab1[1024];
+				char sab2[1024];
+
+				if (r <= 17)
+				{
+					strcpy(sab1, "Katarn");
+					strcpy(sab2, "none");
+				}
+				else if (r <= 34)
+				{
+					strcpy(sab1, "Katarn");
+					strcpy(sab2, "Katarn");
+				}
+				else
+				{
+					strcpy(sab1, "dual_1");
+					strcpy(sab2, "none");
+				}
+				G_SetSaber(ent, 0, sab1, qfalse);
+				G_SetSaber(ent, 0, sab2, qfalse);
+				Info_SetValueForKey( userinfo, "saber1", sab1 );
+				Info_SetValueForKey( userinfo, "saber2", sab2 );
+				trap_SetUserinfo( clientNum, userinfo );
+			}
+			else
+			{
+				G_SetSaber(ent, 0, saberVal, qfalse);
+			}
+
+			if (saberVal && saberVal[0] &&
+				(!saber2Val || !saber2Val[0]))
+			{
+				G_SetSaber(ent, 0, "none", qfalse);
+				Info_SetValueForKey( userinfo, "saber2", "none" );
+				trap_SetUserinfo( clientNum, userinfo );
+			}
+			else
+			{
+				G_SetSaber(ent, 0, saber2Val, qfalse);
+			}
+		}
+
+		// locate ent at a spawn point
+		ClientSpawn( ent );
+	}
+
+	if ( client->sess.sessionTeam != TEAM_SPECTATOR ) {
+		// send event
+		tent = G_TempEntity( ent->client->ps.origin, EV_PLAYER_TELEPORT_IN );
+		tent->s.clientNum = ent->s.clientNum;
+
+		if ( g_gametype.integer != GT_DUEL || g_gametype.integer == GT_POWERDUEL ) {
+			trap_SendServerCommand( -1, va("print \"%s" S_COLOR_WHITE " %s\n\"", client->pers.netname, G_GetStringEdString("MP_SVGAME", "PLENTER")) );
+		}
+	}
+	G_LogPrintf( "ClientBegin: %i\n", clientNum );
+
+	// count current clients and rank for scoreboard
+	CalculateRanks();
+
+	G_ClearClientLog(clientNum);
+}
+
+static qboolean AllForceDisabled(int force)
+{
+	int i;
+
+	if (force)
+	{
+		for (i=0;i<NUM_FORCE_POWERS;i++)
+		{
+			if (!(force & (1<<i)))
+			{
+				return qfalse;
+			}
+		}
+
+		return qtrue;
+	}
+
+	return qfalse;
+}
+
+//Convenient interface to set all my limb breakage stuff up -rww
+void G_BreakArm(gentity_t *ent, int arm)
+{
+	int anim = -1;
+
+	assert(ent && ent->client);
+
+	if (ent->s.NPC_class == CLASS_VEHICLE || ent->localAnimIndex > 1)
+	{ //no broken limbs for vehicles and non-humanoids
+		return;
+	}
+
+	if (!arm)
+	{ //repair him
+		ent->client->ps.brokenLimbs = 0;
+		return;
+	}
+
+	if (ent->client->ps.fd.saberAnimLevel == SS_STAFF)
+	{ //I'm too lazy to deal with this as well for now.
+		return;
+	}
+
+	if (arm == BROKENLIMB_LARM)
+	{
+		if (ent->client->saber[1].model[0] &&
+			ent->client->ps.weapon == WP_SABER &&
+			!ent->client->ps.saberHolstered &&
+			ent->client->saber[1].soundOff)
+		{ //the left arm shuts off its saber upon being broken
+			G_Sound(ent, CHAN_AUTO, ent->client->saber[1].soundOff);
+		}
+	}
+
+	ent->client->ps.brokenLimbs = 0; //make sure it's cleared out
+	ent->client->ps.brokenLimbs |= (1 << arm); //this arm is now marked as broken
+
+	//Do a pain anim based on the side. Since getting your arm broken does tend to hurt.
+	if (arm == BROKENLIMB_LARM)
+	{
+		anim = BOTH_PAIN2;
+	}
+	else if (arm == BROKENLIMB_RARM)
+	{
+		anim = BOTH_PAIN3;
+	}
+
+	if (anim == -1)
+	{
+		return;
+	}
+
+	G_SetAnim(ent, &ent->client->pers.cmd, SETANIM_BOTH, anim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD, 0);
+
+	//This could be combined into a single event. But I guess limbs don't break often enough to
+	//worry about it.
+	G_EntitySound( ent, CHAN_VOICE, G_SoundIndex("*pain25.wav") );
+	//FIXME: A nice bone snapping sound instead if possible
+	G_Sound(ent, CHAN_AUTO, G_SoundIndex( va("sound/player/bodyfall_human%i.wav", Q_irand(1, 3)) ));
+}
+
+//Update the ghoul2 instance anims based on the playerstate values
+#include "../namespace_begin.h"
+qboolean BG_SaberStanceAnim( int anim );
+qboolean PM_RunningAnim( int anim );
+#include "../namespace_end.h"
+void G_UpdateClientAnims(gentity_t *self, float animSpeedScale)
+{
+	static int f;
+	static int torsoAnim;
+	static int legsAnim;
+	static int firstFrame, lastFrame;
+	static int aFlags;
+	static float animSpeed, lAnimSpeedScale;
+	qboolean setTorso = qfalse;
+
+	torsoAnim = (self->client->ps.torsoAnim);
+	legsAnim = (self->client->ps.legsAnim);
+
+	if (self->client->ps.saberLockFrame)
+	{
+		trap_G2API_SetBoneAnim(self->ghoul2, 0, "model_root", self->client->ps.saberLockFrame, self->client->ps.saberLockFrame+1, BONE_ANIM_OVERRIDE_FREEZE|BONE_ANIM_BLEND, animSpeedScale, level.time, -1, 150);
+		trap_G2API_SetBoneAnim(self->ghoul2, 0, "lower_lumbar", self->client->ps.saberLockFrame, self->client->ps.saberLockFrame+1, BONE_ANIM_OVERRIDE_FREEZE|BONE_ANIM_BLEND, animSpeedScale, level.time, -1, 150);
+		trap_G2API_SetBoneAnim(self->ghoul2, 0, "Motion", self->client->ps.saberLockFrame, self->client->ps.saberLockFrame+1, BONE_ANIM_OVERRIDE_FREEZE|BONE_ANIM_BLEND, animSpeedScale, level.time, -1, 150);
+		return;
+	}
+
+	if (self->localAnimIndex > 1 &&
+		bgAllAnims[self->localAnimIndex].anims[legsAnim].firstFrame == 0 &&
+		bgAllAnims[self->localAnimIndex].anims[legsAnim].numFrames == 0)
+	{ //We'll allow this for non-humanoids.
+		goto tryTorso;
+	}
+
+	if (self->client->legsAnimExecute != legsAnim || self->client->legsLastFlip != self->client->ps.legsFlip)
+	{
+		animSpeed = 50.0f / bgAllAnims[self->localAnimIndex].anims[legsAnim].frameLerp;
+		lAnimSpeedScale = (animSpeed *= animSpeedScale);
+
+		if (bgAllAnims[self->localAnimIndex].anims[legsAnim].loopFrames != -1)
+		{
+			aFlags = BONE_ANIM_OVERRIDE_LOOP;
+		}
+		else
+		{
+			aFlags = BONE_ANIM_OVERRIDE_FREEZE;
+		}
+
+		if (animSpeed < 0)
+		{
+			lastFrame = bgAllAnims[self->localAnimIndex].anims[legsAnim].firstFrame;
+			firstFrame = bgAllAnims[self->localAnimIndex].anims[legsAnim].firstFrame + bgAllAnims[self->localAnimIndex].anims[legsAnim].numFrames;
+		}
+		else
+		{
+			firstFrame = bgAllAnims[self->localAnimIndex].anims[legsAnim].firstFrame;
+			lastFrame = bgAllAnims[self->localAnimIndex].anims[legsAnim].firstFrame + bgAllAnims[self->localAnimIndex].anims[legsAnim].numFrames;
+		}
+
+		aFlags |= BONE_ANIM_BLEND; //since client defaults to blend. Not sure if this will make much difference if any on server position, but it's here just for the sake of matching them.
+
+		trap_G2API_SetBoneAnim(self->ghoul2, 0, "model_root", firstFrame, lastFrame, aFlags, lAnimSpeedScale, level.time, -1, 150);
+		self->client->legsAnimExecute = legsAnim;
+		self->client->legsLastFlip = self->client->ps.legsFlip;
+	}
+
+tryTorso:
+	if (self->localAnimIndex > 1 &&
+		bgAllAnims[self->localAnimIndex].anims[torsoAnim].firstFrame == 0 &&
+		bgAllAnims[self->localAnimIndex].anims[torsoAnim].numFrames == 0)
+
+	{ //If this fails as well just return.
+		return;
+	}
+	else if (self->s.number >= MAX_CLIENTS &&
+		self->s.NPC_class == CLASS_VEHICLE)
+	{ //we only want to set the root bone for vehicles
+		return;
+	}
+
+	if ((self->client->torsoAnimExecute != torsoAnim || self->client->torsoLastFlip != self->client->ps.torsoFlip) &&
+		!self->noLumbar)
+	{
+		aFlags = 0;
+		animSpeed = 0;
+
+		f = torsoAnim;
+
+		BG_SaberStartTransAnim(self->client->ps.fd.saberAnimLevel, f, &animSpeedScale, self->client->ps.brokenLimbs);
+
+		animSpeed = 50.0f / bgAllAnims[self->localAnimIndex].anims[f].frameLerp;
+		lAnimSpeedScale = (animSpeed *= animSpeedScale);
+
+		if (bgAllAnims[self->localAnimIndex].anims[f].loopFrames != -1)
+		{
+			aFlags = BONE_ANIM_OVERRIDE_LOOP;
+		}
+		else
+		{
+			aFlags = BONE_ANIM_OVERRIDE_FREEZE;
+		}
+
+		aFlags |= BONE_ANIM_BLEND; //since client defaults to blend. Not sure if this will make much difference if any on client position, but it's here just for the sake of matching them.
+
+		if (animSpeed < 0)
+		{
+			lastFrame = bgAllAnims[self->localAnimIndex].anims[f].firstFrame;
+			firstFrame = bgAllAnims[self->localAnimIndex].anims[f].firstFrame + bgAllAnims[self->localAnimIndex].anims[f].numFrames;
+		}
+		else
+		{
+			firstFrame = bgAllAnims[self->localAnimIndex].anims[f].firstFrame;
+			lastFrame = bgAllAnims[self->localAnimIndex].anims[f].firstFrame + bgAllAnims[self->localAnimIndex].anims[f].numFrames;
+		}
+
+		trap_G2API_SetBoneAnim(self->ghoul2, 0, "lower_lumbar", firstFrame, lastFrame, aFlags, lAnimSpeedScale, level.time, /*firstFrame why was it this before?*/-1, 150);
+
+		self->client->torsoAnimExecute = torsoAnim;
+		self->client->torsoLastFlip = self->client->ps.torsoFlip;
+		
+		setTorso = qtrue;
+	}
+
+	if (setTorso &&
+		self->localAnimIndex <= 1)
+	{ //only set the motion bone for humanoids.
+		trap_G2API_SetBoneAnim(self->ghoul2, 0, "Motion", firstFrame, lastFrame, aFlags, lAnimSpeedScale, level.time, -1, 150);
+	}
+
+#if 0 //disabled for now
+	if (self->client->ps.brokenLimbs != self->client->brokenLimbs ||
+		setTorso)
+	{
+		if (self->localAnimIndex <= 1 && self->client->ps.brokenLimbs &&
+			(self->client->ps.brokenLimbs & (1 << BROKENLIMB_LARM)))
+		{ //broken left arm
+			char *brokenBone = "lhumerus";
+			animation_t *armAnim;
+			int armFirstFrame;
+			int armLastFrame;
+			int armFlags = 0;
+			float armAnimSpeed;
+
+			armAnim = &bgAllAnims[self->localAnimIndex].anims[ BOTH_DEAD21 ];
+			self->client->brokenLimbs = self->client->ps.brokenLimbs;
+
+			armFirstFrame = armAnim->firstFrame;
+			armLastFrame = armAnim->firstFrame+armAnim->numFrames;
+			armAnimSpeed = 50.0f / armAnim->frameLerp;
+			armFlags = (BONE_ANIM_OVERRIDE_LOOP|BONE_ANIM_BLEND);
+
+			trap_G2API_SetBoneAnim(self->ghoul2, 0, brokenBone, armFirstFrame, armLastFrame, armFlags, armAnimSpeed, level.time, -1, 150);
+		}
+		else if (self->localAnimIndex <= 1 && self->client->ps.brokenLimbs &&
+			(self->client->ps.brokenLimbs & (1 << BROKENLIMB_RARM)))
+		{ //broken right arm
+			char *brokenBone = "rhumerus";
+			char *supportBone = "lhumerus";
+
+			self->client->brokenLimbs = self->client->ps.brokenLimbs;
+
+			//Only put the arm in a broken pose if the anim is such that we
+			//want to allow it.
+			if ((//self->client->ps.weapon == WP_MELEE ||
+				self->client->ps.weapon != WP_SABER ||
+				BG_SaberStanceAnim(self->client->ps.torsoAnim) ||
+				PM_RunningAnim(self->client->ps.torsoAnim)) &&
+				(!self->client->saber[1].model[0] || self->client->ps.weapon != WP_SABER))
+			{
+				int armFirstFrame;
+				int armLastFrame;
+				int armFlags = 0;
+				float armAnimSpeed;
+				animation_t *armAnim;
+
+				if (self->client->ps.weapon == WP_MELEE ||
+					self->client->ps.weapon == WP_SABER ||
+					self->client->ps.weapon == WP_BRYAR_PISTOL)
+				{ //don't affect this arm if holding a gun, just make the other arm support it
+					armAnim = &bgAllAnims[self->localAnimIndex].anims[ BOTH_ATTACK2 ];
+
+					//armFirstFrame = armAnim->firstFrame;
+					armFirstFrame = armAnim->firstFrame+armAnim->numFrames;
+					armLastFrame = armAnim->firstFrame+armAnim->numFrames;
+					armAnimSpeed = 50.0f / armAnim->frameLerp;
+					armFlags = (BONE_ANIM_OVERRIDE_LOOP|BONE_ANIM_BLEND);
+
+					trap_G2API_SetBoneAnim(self->ghoul2, 0, brokenBone, armFirstFrame, armLastFrame, armFlags, armAnimSpeed, level.time, -1, 150);
+				}
+				else
+				{ //we want to keep the broken bone updated for some cases
+					trap_G2API_SetBoneAnim(self->ghoul2, 0, brokenBone, firstFrame, lastFrame, aFlags, lAnimSpeedScale, level.time, -1, 150);
+				}
+
+				if (self->client->ps.torsoAnim != BOTH_MELEE1 &&
+					self->client->ps.torsoAnim != BOTH_MELEE2 &&
+					(self->client->ps.torsoAnim == TORSO_WEAPONREADY2 || self->client->ps.torsoAnim == BOTH_ATTACK2 || self->client->ps.weapon < WP_BRYAR_PISTOL))
+				{
+					//Now set the left arm to "support" the right one
+					armAnim = &bgAllAnims[self->localAnimIndex].anims[ BOTH_STAND2 ];
+					armFirstFrame = armAnim->firstFrame;
+					armLastFrame = armAnim->firstFrame+armAnim->numFrames;
+					armAnimSpeed = 50.0f / armAnim->frameLerp;
+					armFlags = (BONE_ANIM_OVERRIDE_LOOP|BONE_ANIM_BLEND);
+
+					trap_G2API_SetBoneAnim(self->ghoul2, 0, supportBone, armFirstFrame, armLastFrame, armFlags, armAnimSpeed, level.time, -1, 150);
+				}
+				else
+				{ //we want to keep the support bone updated for some cases
+					trap_G2API_SetBoneAnim(self->ghoul2, 0, supportBone, firstFrame, lastFrame, aFlags, lAnimSpeedScale, level.time, -1, 150);
+				}
+			}
+			else
+			{ //otherwise, keep it set to the same as the torso
+				trap_G2API_SetBoneAnim(self->ghoul2, 0, brokenBone, firstFrame, lastFrame, aFlags, lAnimSpeedScale, level.time, -1, 150);
+				trap_G2API_SetBoneAnim(self->ghoul2, 0, supportBone, firstFrame, lastFrame, aFlags, lAnimSpeedScale, level.time, -1, 150);
+			}
+		}
+		else if (self->client->brokenLimbs)
+		{ //remove the bone now so it can be set again
+			char *brokenBone = NULL;
+			int broken = 0;
+
+			//Warning: Don't remove bones that you've added as bolts unless you want to invalidate your bolt index
+			//(well, in theory, I haven't actually run into the problem)
+			if (self->client->brokenLimbs & (1<<BROKENLIMB_LARM))
+			{
+				brokenBone = "lhumerus";
+				broken |= (1<<BROKENLIMB_LARM);
+			}
+			else if (self->client->brokenLimbs & (1<<BROKENLIMB_RARM))
+			{ //can only have one arm broken at once.
+				brokenBone = "rhumerus";
+				broken |= (1<<BROKENLIMB_RARM);
+
+				//want to remove the support bone too then
+				trap_G2API_SetBoneAnim(self->ghoul2, 0, "lhumerus", 0, 1, 0, 0, level.time, -1, 0);
+				trap_G2API_RemoveBone(self->ghoul2, "lhumerus", 0);
+			}
+
+			assert(brokenBone);
+
+			//Set the flags and stuff to 0, so that the remove will succeed
+			trap_G2API_SetBoneAnim(self->ghoul2, 0, brokenBone, 0, 1, 0, 0, level.time, -1, 0);
+
+			//Now remove it
+			trap_G2API_RemoveBone(self->ghoul2, brokenBone, 0);
+			self->client->brokenLimbs &= ~broken;
+		}
+	}
+#endif
+}
+
+/*
+===========
+ClientSpawn
+
+Called every time a client is placed fresh in the world:
+after the first ClientBegin, and after each respawn
+Initializes all non-persistant parts of playerState
+============
+*/
+extern qboolean WP_HasForcePowers( const playerState_t *ps );
+void ClientSpawn(gentity_t *ent) {
+	int					index;
+	vec3_t				spawn_origin, spawn_angles;
+	gclient_t			*client;
+	int					i;
+	clientPersistant_t	saved;
+	clientSession_t		savedSess;
+	int					persistant[MAX_PERSISTANT];
+	gentity_t			*spawnPoint;
+	int					flags, gameFlags;
+	int					savedPing;
+	int					accuracy_hits, accuracy_shots;
+	int					eventSequence;
+	char				userinfo[MAX_INFO_STRING];
+	forcedata_t			savedForce;
+	int					saveSaberNum = ENTITYNUM_NONE;
+	int					wDisable = 0;
+	int					savedSiegeIndex = 0;
+	int					maxHealth;
+	saberInfo_t			saberSaved[MAX_SABERS];
+	int					l = 0;
+	void				*g2WeaponPtrs[MAX_SABERS];
+	char				*value;
+	char				*saber;
+	qboolean			changedSaber = qfalse;
+	qboolean			inSiegeWithClass = qfalse;
+
+	index = ent - g_entities;
+	client = ent->client;
+
+	//first we want the userinfo so we can see if we should update this client's saber -rww
+	trap_GetUserinfo( index, userinfo, sizeof(userinfo) );
+	while (l < MAX_SABERS)
+	{
+		switch (l)
+		{
+		case 0:
+			saber = &ent->client->sess.saberType[0];
+			break;
+		case 1:
+			saber = &ent->client->sess.saber2Type[0];
+			break;
+		default:
+			saber = NULL;
+			break;
+		}
+
+		value = Info_ValueForKey (userinfo, va("saber%i", l+1));
+		if (saber &&
+			value &&
+			(Q_stricmp(value, saber) || !saber[0] || !ent->client->saber[0].model[0]))
+		{ //doesn't match up (or our session saber is BS), we want to try setting it
+			if (G_SetSaber(ent, l, value, qfalse))
+			{
+				changedSaber = qtrue;
+			}
+			else if (!saber[0] || !ent->client->saber[0].model[0])
+			{ //Well, we still want to say they changed then (it means this is siege and we have some overrides)
+				changedSaber = qtrue;
+			}
+		}
+		l++;
+	}
+
+	if (changedSaber)
+	{ //make sure our new info is sent out to all the other clients, and give us a valid stance
+		ClientUserinfoChanged( ent->s.number );
+
+		//make sure the saber models are updated
+		G_SaberModelSetup(ent);
+
+		l = 0;
+		while (l < MAX_SABERS)
+		{ //go through and make sure both sabers match the userinfo
+			switch (l)
+			{
+			case 0:
+				saber = &ent->client->sess.saberType[0];
+				break;
+			case 1:
+				saber = &ent->client->sess.saber2Type[0];
+				break;
+			default:
+				saber = NULL;
+				break;
+			}
+
+			value = Info_ValueForKey (userinfo, va("saber%i", l+1));
+
+			if (Q_stricmp(value, saber))
+			{ //they don't match up, force the user info
+				Info_SetValueForKey(userinfo, va("saber%i", l+1), saber);
+				trap_SetUserinfo( ent->s.number, userinfo );
+			}
+			l++;
+		}
+
+		if (ent->client->saber[0].model[0] &&
+			ent->client->saber[1].model[0])
+		{ //dual
+			ent->client->ps.fd.saberAnimLevelBase = ent->client->ps.fd.saberAnimLevel = ent->client->ps.fd.saberDrawAnimLevel = SS_DUAL;
+		}
+		else if (ent->client->saber[0].twoHanded)
+		{ //staff
+			ent->client->ps.fd.saberAnimLevel = ent->client->ps.fd.saberDrawAnimLevel = SS_STAFF;
+		}
+		else
+		{
+			if (ent->client->sess.saberLevel < SS_FAST)
+			{
+				ent->client->sess.saberLevel = SS_FAST;
+			}
+			else if (ent->client->sess.saberLevel > SS_STRONG)
+			{
+				ent->client->sess.saberLevel = SS_STRONG;
+			}
+			ent->client->ps.fd.saberAnimLevelBase = ent->client->ps.fd.saberAnimLevel = ent->client->ps.fd.saberDrawAnimLevel = ent->client->sess.saberLevel;
+
+			if (g_gametype.integer != GT_SIEGE &&
+				ent->client->ps.fd.saberAnimLevel > ent->client->ps.fd.forcePowerLevel[FP_SABER_OFFENSE])
+			{
+				ent->client->ps.fd.saberAnimLevelBase = ent->client->ps.fd.saberAnimLevel = ent->client->ps.fd.saberDrawAnimLevel = ent->client->sess.saberLevel = ent->client->ps.fd.forcePowerLevel[FP_SABER_OFFENSE];
+			}
+		}
+	}
+	l = 0;
+
+	if (client->ps.fd.forceDoInit)
+	{ //force a reread of force powers
+		WP_InitForcePowers( ent );
+		client->ps.fd.forceDoInit = 0;
+	}
+
+	if (ent->client->ps.fd.saberAnimLevel != SS_STAFF &&
+		ent->client->ps.fd.saberAnimLevel != SS_DUAL &&
+		ent->client->ps.fd.saberAnimLevel == ent->client->ps.fd.saberDrawAnimLevel &&
+		ent->client->ps.fd.saberAnimLevel == ent->client->sess.saberLevel)
+	{
+		if (ent->client->sess.saberLevel < SS_FAST)
+		{
+			ent->client->sess.saberLevel = SS_FAST;
+		}
+		else if (ent->client->sess.saberLevel > SS_STRONG)
+		{
+			ent->client->sess.saberLevel = SS_STRONG;
+		}
+		ent->client->ps.fd.saberAnimLevel = ent->client->ps.fd.saberDrawAnimLevel = ent->client->sess.saberLevel;
+
+		if (g_gametype.integer != GT_SIEGE &&
+			ent->client->ps.fd.saberAnimLevel > ent->client->ps.fd.forcePowerLevel[FP_SABER_OFFENSE])
+		{
+			ent->client->ps.fd.saberAnimLevel = ent->client->ps.fd.saberDrawAnimLevel = ent->client->sess.saberLevel = ent->client->ps.fd.forcePowerLevel[FP_SABER_OFFENSE];
+		}
+	}
+
+	// find a spawn point
+	// do it before setting health back up, so farthest
+	// ranging doesn't count this client
+	if ( client->sess.sessionTeam == TEAM_SPECTATOR ) {
+		spawnPoint = SelectSpectatorSpawnPoint ( 
+						spawn_origin, spawn_angles);
+	} else if (g_gametype.integer == GT_CTF || g_gametype.integer == GT_CTY) {
+		// all base oriented team games use the CTF spawn points
+		spawnPoint = SelectCTFSpawnPoint ( 
+						client->sess.sessionTeam, 
+						client->pers.teamState.state, 
+						spawn_origin, spawn_angles);
+	}
+	else if (g_gametype.integer == GT_SIEGE)
+	{
+		spawnPoint = SelectSiegeSpawnPoint (
+						client->siegeClass,
+						client->sess.sessionTeam, 
+						client->pers.teamState.state, 
+						spawn_origin, spawn_angles);
+	}
+	else {
+		do {
+			if (g_gametype.integer == GT_POWERDUEL)
+			{
+				spawnPoint = SelectDuelSpawnPoint(client->sess.duelTeam, client->ps.origin, spawn_origin, spawn_angles);
+			}
+			else if (g_gametype.integer == GT_DUEL)
+			{	// duel 
+				spawnPoint = SelectDuelSpawnPoint(DUELTEAM_SINGLE, client->ps.origin, spawn_origin, spawn_angles);
+			}
+			else
+			{
+				// the first spawn should be at a good looking spot
+				if ( !client->pers.initialSpawn && client->pers.localClient ) {
+					client->pers.initialSpawn = qtrue;
+					spawnPoint = SelectInitialSpawnPoint( spawn_origin, spawn_angles );
+				} else {
+					// don't spawn near existing origin if possible
+					spawnPoint = SelectSpawnPoint ( 
+						client->ps.origin, 
+						spawn_origin, spawn_angles);
+				}
+			}
+
+			// Tim needs to prevent bots from spawning at the initial point
+			// on q3dm0...
+			if ( ( spawnPoint->flags & FL_NO_BOTS ) && ( ent->r.svFlags & SVF_BOT ) ) {
+				continue;	// try again
+			}
+			// just to be symetric, we have a nohumans option...
+			if ( ( spawnPoint->flags & FL_NO_HUMANS ) && !( ent->r.svFlags & SVF_BOT ) ) {
+				continue;	// try again
+			}
+
+			break;
+
+		} while ( 1 );
+	}
+	client->pers.teamState.state = TEAM_ACTIVE;
+
+	// toggle the teleport bit so the client knows to not lerp
+	// and never clear the voted flag
+	flags = ent->client->ps.eFlags & (EF_TELEPORT_BIT );
+	flags ^= EF_TELEPORT_BIT;
+	gameFlags = ent->client->mGameFlags & ( PSG_VOTED | PSG_TEAMVOTED);
+
+	// clear everything but the persistant data
+
+	saved = client->pers;
+	savedSess = client->sess;
+	savedPing = client->ps.ping;
+//	savedAreaBits = client->areabits;
+	accuracy_hits = client->accuracy_hits;
+	accuracy_shots = client->accuracy_shots;
+	for ( i = 0 ; i < MAX_PERSISTANT ; i++ ) {
+		persistant[i] = client->ps.persistant[i];
+	}
+	eventSequence = client->ps.eventSequence;
+
+	savedForce = client->ps.fd;
+
+	saveSaberNum = client->ps.saberEntityNum;
+
+	savedSiegeIndex = client->siegeClass;
+
+	l = 0;
+	while (l < MAX_SABERS)
+	{
+		saberSaved[l] = client->saber[l];
+		g2WeaponPtrs[l] = client->weaponGhoul2[l];
+		l++;
+	}
+
+	i = 0;
+	while (i < HL_MAX)
+	{
+		ent->locationDamage[i] = 0;
+		i++;
+	}
+
+	memset (client, 0, sizeof(*client)); // bk FIXME: Com_Memset?
+	client->bodyGrabIndex = ENTITYNUM_NONE;
+
+	//Get the skin RGB based on his userinfo
+	value = Info_ValueForKey (userinfo, "char_color_red");
+	if (value)
+	{
+		client->ps.customRGBA[0] = atoi(value);
+	}
+	else
+	{
+		client->ps.customRGBA[0] = 255;
+	}
+
+	value = Info_ValueForKey (userinfo, "char_color_green");
+	if (value)
+	{
+		client->ps.customRGBA[1] = atoi(value);
+	}
+	else
+	{
+		client->ps.customRGBA[1] = 255;
+	}
+
+	value = Info_ValueForKey (userinfo, "char_color_blue");
+	if (value)
+	{
+		client->ps.customRGBA[2] = atoi(value);
+	}
+	else
+	{
+		client->ps.customRGBA[2] = 255;
+	}
+
+	if ((client->ps.customRGBA[0]+client->ps.customRGBA[1]+client->ps.customRGBA[2]) < 100)
+	{ //hmm, too dark!
+		client->ps.customRGBA[0] = client->ps.customRGBA[1] = client->ps.customRGBA[2] = 255;
+	}
+
+	client->ps.customRGBA[3]=255;
+
+	client->siegeClass = savedSiegeIndex;
+
+	l = 0;
+	while (l < MAX_SABERS)
+	{
+		client->saber[l] = saberSaved[l];
+		client->weaponGhoul2[l] = g2WeaponPtrs[l];
+		l++;
+	}
+
+	//or the saber ent num
+	client->ps.saberEntityNum = saveSaberNum;
+	client->saberStoredIndex = saveSaberNum;
+
+	client->ps.fd = savedForce;
+
+	client->ps.duelIndex = ENTITYNUM_NONE;
+
+	//spawn with 100
+	client->ps.jetpackFuel = 100;
+	client->ps.cloakFuel = 100;
+
+	client->pers = saved;
+	client->sess = savedSess;
+	client->ps.ping = savedPing;
+//	client->areabits = savedAreaBits;
+	client->accuracy_hits = accuracy_hits;
+	client->accuracy_shots = accuracy_shots;
+	client->lastkilled_client = -1;
+
+	for ( i = 0 ; i < MAX_PERSISTANT ; i++ ) {
+		client->ps.persistant[i] = persistant[i];
+	}
+	client->ps.eventSequence = eventSequence;
+	// increment the spawncount so the client will detect the respawn
+	client->ps.persistant[PERS_SPAWN_COUNT]++;
+	client->ps.persistant[PERS_TEAM] = client->sess.sessionTeam;
+
+	client->airOutTime = level.time + 12000;
+
+	// set max health
+	if (g_gametype.integer == GT_SIEGE && client->siegeClass != -1)
+	{
+		siegeClass_t *scl = &bgSiegeClasses[client->siegeClass];
+		maxHealth = 100;
+
+		if (scl->maxhealth)
+		{
+			maxHealth = scl->maxhealth;
+		}
+	}
+	else
+	{
+		maxHealth = 100;
+	}
+	client->pers.maxHealth = maxHealth;//atoi( Info_ValueForKey( userinfo, "handicap" ) );
+	if ( client->pers.maxHealth < 1 || client->pers.maxHealth > maxHealth ) {
+		client->pers.maxHealth = 100;
+	}
+	// clear entity values
+	client->ps.stats[STAT_MAX_HEALTH] = client->pers.maxHealth;
+	client->ps.eFlags = flags;
+	client->mGameFlags = gameFlags;
+
+	ent->s.groundEntityNum = ENTITYNUM_NONE;
+	ent->client = &level.clients[index];
+	ent->playerState = &ent->client->ps;
+	ent->takedamage = qtrue;
+	ent->inuse = qtrue;
+	ent->classname = "player";
+	ent->r.contents = CONTENTS_BODY;
+	ent->clipmask = MASK_PLAYERSOLID;
+	ent->die = player_die;
+	ent->waterlevel = 0;
+	ent->watertype = 0;
+	ent->flags = 0;
+	
+	VectorCopy (playerMins, ent->r.mins);
+	VectorCopy (playerMaxs, ent->r.maxs);
+	client->ps.crouchheight = CROUCH_MAXS_2;
+	client->ps.standheight = DEFAULT_MAXS_2;
+
+	client->ps.clientNum = index;
+	//give default weapons
+	client->ps.stats[STAT_WEAPONS] = ( 1 << WP_NONE );
+
+	if (g_gametype.integer == GT_DUEL || g_gametype.integer == GT_POWERDUEL)
+	{
+		wDisable = g_duelWeaponDisable.integer;
+	}
+	else
+	{
+		wDisable = g_weaponDisable.integer;
+	}
+
+
+
+	if ( g_gametype.integer != GT_HOLOCRON 
+		&& g_gametype.integer != GT_JEDIMASTER 
+		&& !HasSetSaberOnly()
+		&& !AllForceDisabled( g_forcePowerDisable.integer )
+		&& g_trueJedi.integer )
+	{
+		if ( g_gametype.integer >= GT_TEAM && (client->sess.sessionTeam == TEAM_BLUE || client->sess.sessionTeam == TEAM_RED) )
+		{//In Team games, force one side to be merc and other to be jedi
+			if ( level.numPlayingClients > 0 )
+			{//already someone in the game
+				int		i, forceTeam = TEAM_SPECTATOR;
+				for ( i = 0 ; i < level.maxclients ; i++ ) 
+				{
+					if ( level.clients[i].pers.connected == CON_DISCONNECTED ) {
+						continue;
+					}
+					if ( level.clients[i].sess.sessionTeam == TEAM_BLUE || level.clients[i].sess.sessionTeam == TEAM_RED ) 
+					{//in-game
+						if ( WP_HasForcePowers( &level.clients[i].ps ) )
+						{//this side is using force
+							forceTeam = level.clients[i].sess.sessionTeam;
+						}
+						else
+						{//other team is using force
+							if ( level.clients[i].sess.sessionTeam == TEAM_BLUE )
+							{
+								forceTeam = TEAM_RED;
+							}
+							else
+							{
+								forceTeam = TEAM_BLUE;
+							}
+						}
+						break;
+					}
+				}
+				if ( WP_HasForcePowers( &client->ps ) && client->sess.sessionTeam != forceTeam )
+				{//using force but not on right team, switch him over
+					const char *teamName = TeamName( forceTeam );
+					//client->sess.sessionTeam = forceTeam;
+					SetTeam( ent, (char *)teamName );
+					return;
+				}
+			}
+		}
+
+		if ( WP_HasForcePowers( &client->ps ) )
+		{
+			client->ps.trueNonJedi = qfalse;
+			client->ps.trueJedi = qtrue;
+			//make sure they only use the saber
+			client->ps.weapon = WP_SABER;
+			client->ps.stats[STAT_WEAPONS] = (1 << WP_SABER);
+		}
+		else
+		{//no force powers set
+			client->ps.trueNonJedi = qtrue;
+			client->ps.trueJedi = qfalse;
+			if (!wDisable || !(wDisable & (1 << WP_BRYAR_PISTOL)))
+			{
+				client->ps.stats[STAT_WEAPONS] |= ( 1 << WP_BRYAR_PISTOL );
+			}
+			if (!wDisable || !(wDisable & (1 << WP_BLASTER)))
+			{
+				client->ps.stats[STAT_WEAPONS] |= ( 1 << WP_BLASTER );
+			}
+			if (!wDisable || !(wDisable & (1 << WP_BOWCASTER)))
+			{
+				client->ps.stats[STAT_WEAPONS] |= ( 1 << WP_BOWCASTER );
+			}
+			client->ps.stats[STAT_WEAPONS] &= ~(1 << WP_SABER);
+			client->ps.stats[STAT_WEAPONS] |= (1 << WP_MELEE);
+			client->ps.ammo[AMMO_POWERCELL] = ammoData[AMMO_POWERCELL].max;
+			client->ps.weapon = WP_BRYAR_PISTOL;
+		}
+	}
+	else
+	{//jediVmerc is incompatible with this gametype, turn it off!
+		trap_Cvar_Set( "g_jediVmerc", "0" );
+		if (g_gametype.integer == GT_HOLOCRON)
+		{
+			//always get free saber level 1 in holocron
+			client->ps.stats[STAT_WEAPONS] |= ( 1 << WP_SABER );	//these are precached in g_items, ClearRegisteredItems()
+		}
+		else
+		{
+			if (client->ps.fd.forcePowerLevel[FP_SABER_OFFENSE])
+			{
+				client->ps.stats[STAT_WEAPONS] |= ( 1 << WP_SABER );	//these are precached in g_items, ClearRegisteredItems()
+			}
+			else
+			{ //if you don't have saber attack rank then you don't get a saber
+				client->ps.stats[STAT_WEAPONS] |= (1 << WP_MELEE);
+			}
+		}
+
+		if (g_gametype.integer != GT_SIEGE)
+		{
+			if (!wDisable || !(wDisable & (1 << WP_BRYAR_PISTOL)))
+			{
+				client->ps.stats[STAT_WEAPONS] |= ( 1 << WP_BRYAR_PISTOL );
+			}
+			else if (g_gametype.integer == GT_JEDIMASTER)
+			{
+				client->ps.stats[STAT_WEAPONS] |= ( 1 << WP_BRYAR_PISTOL );
+			}
+		}
+
+		if (g_gametype.integer == GT_JEDIMASTER)
+		{
+			client->ps.stats[STAT_WEAPONS] &= ~(1 << WP_SABER);
+			client->ps.stats[STAT_WEAPONS] |= (1 << WP_MELEE);
+		}
+
+		if (client->ps.stats[STAT_WEAPONS] & (1 << WP_SABER))
+		{
+			client->ps.weapon = WP_SABER;
+		}
+		else if (client->ps.stats[STAT_WEAPONS] & (1 << WP_BRYAR_PISTOL))
+		{
+			client->ps.weapon = WP_BRYAR_PISTOL;
+		}
+		else
+		{
+			client->ps.weapon = WP_MELEE;
+		}
+	}
+
+	/*
+	client->ps.stats[STAT_HOLDABLE_ITEMS] |= ( 1 << HI_BINOCULARS );
+	client->ps.stats[STAT_HOLDABLE_ITEM] = BG_GetItemIndexByTag(HI_BINOCULARS, IT_HOLDABLE);
+	*/
+
+	if (g_gametype.integer == GT_SIEGE && client->siegeClass != -1 &&
+		client->sess.sessionTeam != TEAM_SPECTATOR)
+	{ //well then, we will use a custom weaponset for our class
+		int m = 0;
+
+		client->ps.stats[STAT_WEAPONS] = bgSiegeClasses[client->siegeClass].weapons;
+
+		if (client->ps.stats[STAT_WEAPONS] & (1 << WP_SABER))
+		{
+			client->ps.weapon = WP_SABER;
+		}
+		else if (client->ps.stats[STAT_WEAPONS] & (1 << WP_BRYAR_PISTOL))
+		{
+			client->ps.weapon = WP_BRYAR_PISTOL;
+		}
+		else
+		{
+			client->ps.weapon = WP_MELEE;
+		}
+		inSiegeWithClass = qtrue;
+
+		while (m < WP_NUM_WEAPONS)
+		{
+			if (client->ps.stats[STAT_WEAPONS] & (1 << m))
+			{
+				if (client->ps.weapon != WP_SABER)
+				{ //try to find the highest ranking weapon we have
+					if (m > client->ps.weapon)
+					{
+						client->ps.weapon = m;
+					}
+				}
+
+				if (m >= WP_BRYAR_PISTOL)
+				{ //Max his ammo out for all the weapons he has.
+					if ( g_gametype.integer == GT_SIEGE 
+						&& m == WP_ROCKET_LAUNCHER )
+					{//don't give full ammo!
+						//FIXME: extern this and check it when getting ammo from supplier, pickups or ammo stations!
+						if ( client->siegeClass != -1 &&
+							(bgSiegeClasses[client->siegeClass].classflags & (1<<CFL_SINGLE_ROCKET)) )
+						{
+							client->ps.ammo[weaponData[m].ammoIndex] = 1;
+						}
+						else
+						{
+							client->ps.ammo[weaponData[m].ammoIndex] = 10;
+						}
+					}
+					else
+					{
+						if ( g_gametype.integer == GT_SIEGE 
+							&& client->siegeClass != -1
+							&& (bgSiegeClasses[client->siegeClass].classflags & (1<<CFL_EXTRA_AMMO)) )
+						{//double ammo
+							client->ps.ammo[weaponData[m].ammoIndex] = ammoData[weaponData[m].ammoIndex].max*2;
+							client->ps.eFlags |= EF_DOUBLE_AMMO;
+						}
+						else
+						{
+							client->ps.ammo[weaponData[m].ammoIndex] = ammoData[weaponData[m].ammoIndex].max;
+						}
+					}
+				}
+			}
+			m++;
+		}
+	}
+
+	if (g_gametype.integer == GT_SIEGE &&
+		client->siegeClass != -1 &&
+		client->sess.sessionTeam != TEAM_SPECTATOR)
+	{ //use class-specified inventory
+		client->ps.stats[STAT_HOLDABLE_ITEMS] = bgSiegeClasses[client->siegeClass].invenItems;
+		client->ps.stats[STAT_HOLDABLE_ITEM] = 0;
+	}
+	else
+	{
+		client->ps.stats[STAT_HOLDABLE_ITEMS] = 0;
+		client->ps.stats[STAT_HOLDABLE_ITEM] = 0;
+	}
+
+	if (g_gametype.integer == GT_SIEGE &&
+		client->siegeClass != -1 &&
+		bgSiegeClasses[client->siegeClass].powerups &&
+		client->sess.sessionTeam != TEAM_SPECTATOR)
+	{ //this class has some start powerups
+		i = 0;
+		while (i < PW_NUM_POWERUPS)
+		{
+			if (bgSiegeClasses[client->siegeClass].powerups & (1 << i))
+			{
+				client->ps.powerups[i] = Q3_INFINITE;
+			}
+			i++;
+		}
+	}
+
+	if ( client->sess.sessionTeam == TEAM_SPECTATOR )
+	{
+		client->ps.stats[STAT_WEAPONS] = 0;
+		client->ps.stats[STAT_HOLDABLE_ITEMS] = 0;
+		client->ps.stats[STAT_HOLDABLE_ITEM] = 0;
+	}
+
+// nmckenzie: DESERT_SIEGE... or well, siege generally.  This was over-writing the max value, which was NOT good for siege.
+	if ( inSiegeWithClass == qfalse )
+	{
+		client->ps.ammo[AMMO_BLASTER] = 100; //ammoData[AMMO_BLASTER].max; //100 seems fair.
+	}
+//	client->ps.ammo[AMMO_POWERCELL] = ammoData[AMMO_POWERCELL].max;
+//	client->ps.ammo[AMMO_FORCE] = ammoData[AMMO_FORCE].max;
+//	client->ps.ammo[AMMO_METAL_BOLTS] = ammoData[AMMO_METAL_BOLTS].max;
+//	client->ps.ammo[AMMO_ROCKETS] = ammoData[AMMO_ROCKETS].max;
+/*
+	client->ps.stats[STAT_WEAPONS] = ( 1 << WP_BRYAR_PISTOL);
+	if ( g_gametype.integer == GT_TEAM ) {
+		client->ps.ammo[WP_BRYAR_PISTOL] = 50;
+	} else {
+		client->ps.ammo[WP_BRYAR_PISTOL] = 100;
+	}
+*/
+	client->ps.rocketLockIndex = ENTITYNUM_NONE;
+	client->ps.rocketLockTime = 0;
+
+	//rww - Set here to initialize the circling seeker drone to off.
+	//A quick note about this so I don't forget how it works again:
+	//ps.genericEnemyIndex is kept in sync between the server and client.
+	//When it gets set then an entitystate value of the same name gets
+	//set along with an entitystate flag in the shared bg code. Which
+	//is why a value needs to be both on the player state and entity state.
+	//(it doesn't seem to just carry over the entitystate value automatically
+	//because entity state value is derived from player state data or some
+	//such)
+	client->ps.genericEnemyIndex = -1;
+
+	client->ps.isJediMaster = qfalse;
+
+	if (client->ps.fallingToDeath)
+	{
+		client->ps.fallingToDeath = 0;
+		client->noCorpse = qtrue;
+	}
+
+	//Do per-spawn force power initialization
+	WP_SpawnInitForcePowers( ent );
+
+	// health will count down towards max_health
+	if (g_gametype.integer == GT_SIEGE &&
+		client->siegeClass != -1 &&
+		bgSiegeClasses[client->siegeClass].starthealth)
+	{ //class specifies a start health, so use it
+		ent->health = client->ps.stats[STAT_HEALTH] = bgSiegeClasses[client->siegeClass].starthealth;
+	}
+	else if ( g_gametype.integer == GT_DUEL || g_gametype.integer == GT_POWERDUEL )
+	{//only start with 100 health in Duel
+		if ( g_gametype.integer == GT_POWERDUEL && client->sess.duelTeam == DUELTEAM_LONE )
+		{
+			if ( g_duel_fraglimit.integer )
+			{
+				
+				ent->health = client->ps.stats[STAT_HEALTH] = client->ps.stats[STAT_MAX_HEALTH] =
+					g_powerDuelStartHealth.integer - ((g_powerDuelStartHealth.integer - g_powerDuelEndHealth.integer) * (float)client->sess.wins / (float)g_duel_fraglimit.integer);
+			}
+			else
+			{
+				ent->health = client->ps.stats[STAT_HEALTH] = client->ps.stats[STAT_MAX_HEALTH] = 150;
+			}
+		}
+		else
+		{
+			ent->health = client->ps.stats[STAT_HEALTH] = client->ps.stats[STAT_MAX_HEALTH] = 100;
+		}
+	}
+	else if (client->ps.stats[STAT_MAX_HEALTH] <= 100)
+	{
+		ent->health = client->ps.stats[STAT_HEALTH] = client->ps.stats[STAT_MAX_HEALTH] * 1.25;
+	}
+	else if (client->ps.stats[STAT_MAX_HEALTH] < 125)
+	{
+		ent->health = client->ps.stats[STAT_HEALTH] = 125;
+	}
+	else
+	{
+		ent->health = client->ps.stats[STAT_HEALTH] = client->ps.stats[STAT_MAX_HEALTH];
+	}
+
+	// Start with a small amount of armor as well.
+	if (g_gametype.integer == GT_SIEGE &&
+		client->siegeClass != -1 /*&&
+		bgSiegeClasses[client->siegeClass].startarmor*/)
+	{ //class specifies a start armor amount, so use it
+		client->ps.stats[STAT_ARMOR] = bgSiegeClasses[client->siegeClass].startarmor;
+	}
+	else if ( g_gametype.integer == GT_DUEL || g_gametype.integer == GT_POWERDUEL )
+	{//no armor in duel
+		client->ps.stats[STAT_ARMOR] = 0;
+	}
+	else
+	{
+		client->ps.stats[STAT_ARMOR] = client->ps.stats[STAT_MAX_HEALTH] * 0.25;
+	}
+
+	G_SetOrigin( ent, spawn_origin );
+	VectorCopy( spawn_origin, client->ps.origin );
+
+	// the respawned flag will be cleared after the attack and jump keys come up
+	client->ps.pm_flags |= PMF_RESPAWNED;
+
+	trap_GetUsercmd( client - level.clients, &ent->client->pers.cmd );
+	SetClientViewAngle( ent, spawn_angles );
+
+	if ( ent->client->sess.sessionTeam == TEAM_SPECTATOR ) {
+
+	} else {
+		G_KillBox( ent );
+		trap_LinkEntity (ent);
+
+		// force the base weapon up
+		//client->ps.weapon = WP_BRYAR_PISTOL;
+		//client->ps.weaponstate = FIRST_WEAPON;
+		if (client->ps.weapon <= WP_NONE)
+		{
+			client->ps.weapon = WP_BRYAR_PISTOL;
+		}
+
+		client->ps.torsoTimer = client->ps.legsTimer = 0;
+
+		if (client->ps.weapon == WP_SABER)
+		{
+			G_SetAnim(ent, NULL, SETANIM_BOTH, BOTH_STAND1TO2, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD|SETANIM_FLAG_HOLDLESS, 0);
+		}
+		else
+		{
+			G_SetAnim(ent, NULL, SETANIM_TORSO, TORSO_RAISEWEAP1, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD|SETANIM_FLAG_HOLDLESS, 0);
+			client->ps.legsAnim = WeaponReadyAnim[client->ps.weapon];
+		}
+		client->ps.weaponstate = WEAPON_RAISING;
+		client->ps.weaponTime = client->ps.torsoTimer;
+	}
+
+	// don't allow full run speed for a bit
+	client->ps.pm_flags |= PMF_TIME_KNOCKBACK;
+	client->ps.pm_time = 100;
+
+	client->respawnTime = level.time;
+	client->inactivityTime = level.time + g_inactivity.integer * 1000;
+	client->latched_buttons = 0;
+
+	if ( level.intermissiontime ) {
+		MoveClientToIntermission( ent );
+	} else {
+		// fire the targets of the spawn point
+		G_UseTargets( spawnPoint, ent );
+
+		// select the highest weapon number available, after any
+		// spawn given items have fired
+		/*
+		client->ps.weapon = 1;
+		for ( i = WP_NUM_WEAPONS - 1 ; i > 0 ; i-- ) {
+			if ( client->ps.stats[STAT_WEAPONS] & ( 1 << i ) ) {
+				client->ps.weapon = i;
+				break;
+			}
+		}
+		*/
+	}
+
+	//set teams for NPCs to recognize
+	if (g_gametype.integer == GT_SIEGE)
+	{ //Imperial (team1) team is allied with "enemy" NPCs in this mode
+		if (client->sess.sessionTeam == SIEGETEAM_TEAM1)
+		{
+			client->playerTeam = ent->s.teamowner = NPCTEAM_ENEMY;
+			client->enemyTeam = NPCTEAM_PLAYER;
+		}
+		else
+		{
+			client->playerTeam = ent->s.teamowner = NPCTEAM_PLAYER;
+			client->enemyTeam = NPCTEAM_ENEMY;
+		}
+	}
+	else
+	{
+		client->playerTeam = ent->s.teamowner = NPCTEAM_PLAYER;
+		client->enemyTeam = NPCTEAM_ENEMY;
+	}
+
+	/*
+	//scaling for the power duel opponent
+	if (g_gametype.integer == GT_POWERDUEL &&
+		client->sess.duelTeam == DUELTEAM_LONE)
+	{
+		client->ps.iModelScale = 125;
+		VectorSet(ent->modelScale, 1.25f, 1.25f, 1.25f);
+	}
+	*/
+	//Disabled. At least for now. Not sure if I'll want to do it or not eventually.
+
+	// run a client frame to drop exactly to the floor,
+	// initialize animations and other things
+	client->ps.commandTime = level.time - 100;
+	ent->client->pers.cmd.serverTime = level.time;
+	ClientThink( ent-g_entities, NULL );
+
+	// positively link the client, even if the command times are weird
+	if ( ent->client->sess.sessionTeam != TEAM_SPECTATOR ) {
+		BG_PlayerStateToEntityState( &client->ps, &ent->s, qtrue );
+		VectorCopy( ent->client->ps.origin, ent->r.currentOrigin );
+		trap_LinkEntity( ent );
+	}
+
+	if (g_spawnInvulnerability.integer)
+	{
+		ent->client->ps.eFlags |= EF_INVULNERABLE;
+		ent->client->invulnerableTimer = level.time + g_spawnInvulnerability.integer;
+	}
+
+	// run the presend to set anything else
+	ClientEndFrame( ent );
+
+	// clear entity state values
+	BG_PlayerStateToEntityState( &client->ps, &ent->s, qtrue );
+
+	//rww - make sure client has a valid icarus instance
+	trap_ICARUS_FreeEnt( ent );
+	trap_ICARUS_InitEnt( ent );
+}
+
+
+/*
+===========
+ClientDisconnect
+
+Called when a player drops from the server.
+Will not be called between levels.
+
+This should NOT be called directly by any game logic,
+call trap_DropClient(), which will call this and do
+server system housekeeping.
+============
+*/
+void ClientDisconnect( int clientNum ) {
+	gentity_t	*ent;
+	gentity_t	*tent;
+	int			i;
+
+	// cleanup if we are kicking a bot that
+	// hasn't spawned yet
+	G_RemoveQueuedBotBegin( clientNum );
+
+	ent = g_entities + clientNum;
+	if ( !ent->client ) {
+		return;
+	}
+
+	i = 0;
+
+	while (i < NUM_FORCE_POWERS)
+	{
+		if (ent->client->ps.fd.forcePowersActive & (1 << i))
+		{
+			WP_ForcePowerStop(ent, i);
+		}
+		i++;
+	}
+
+	i = TRACK_CHANNEL_1;
+
+	while (i < NUM_TRACK_CHANNELS)
+	{
+		if (ent->client->ps.fd.killSoundEntIndex[i-50] && ent->client->ps.fd.killSoundEntIndex[i-50] < MAX_GENTITIES && ent->client->ps.fd.killSoundEntIndex[i-50] > 0)
+		{
+			G_MuteSound(ent->client->ps.fd.killSoundEntIndex[i-50], CHAN_VOICE);
+		}
+		i++;
+	}
+	i = 0;
+
+	if (ent->client->ps.m_iVehicleNum)
+	{ //tell it I'm getting off
+		gentity_t *veh = &g_entities[ent->client->ps.m_iVehicleNum];
+
+		if (veh->inuse && veh->client && veh->m_pVehicle)
+		{
+			int pCon = ent->client->pers.connected;
+
+			ent->client->pers.connected = 0;
+			veh->m_pVehicle->m_pVehicleInfo->Eject(veh->m_pVehicle, (bgEntity_t *)ent, qtrue);
+			ent->client->pers.connected = pCon;
+		}
+	}
+
+	// stop any following clients
+	for ( i = 0 ; i < level.maxclients ; i++ ) {
+		if ( level.clients[i].sess.sessionTeam == TEAM_SPECTATOR
+			&& level.clients[i].sess.spectatorState == SPECTATOR_FOLLOW
+			&& level.clients[i].sess.spectatorClient == clientNum ) {
+			StopFollowing( &g_entities[i] );
+		}
+	}
+
+	// send effect if they were completely connected
+	if ( ent->client->pers.connected == CON_CONNECTED 
+		&& ent->client->sess.sessionTeam != TEAM_SPECTATOR ) {
+		tent = G_TempEntity( ent->client->ps.origin, EV_PLAYER_TELEPORT_OUT );
+		tent->s.clientNum = ent->s.clientNum;
+
+		// They don't get to take powerups with them!
+		// Especially important for stuff like CTF flags
+		TossClientItems( ent );
+	}
+
+	G_LogPrintf( "ClientDisconnect: %i\n", clientNum );
+
+	// if we are playing in tourney mode, give a win to the other player and clear his frags for this round
+	if ( (g_gametype.integer == GT_DUEL )
+		&& !level.intermissiontime
+		&& !level.warmupTime ) {
+		if ( level.sortedClients[1] == clientNum ) {
+			level.clients[ level.sortedClients[0] ].ps.persistant[PERS_SCORE] = 0;
+			level.clients[ level.sortedClients[0] ].sess.wins++;
+			ClientUserinfoChanged( level.sortedClients[0] );
+		}
+		else if ( level.sortedClients[0] == clientNum ) {
+			level.clients[ level.sortedClients[1] ].ps.persistant[PERS_SCORE] = 0;
+			level.clients[ level.sortedClients[1] ].sess.wins++;
+			ClientUserinfoChanged( level.sortedClients[1] );
+		}
+	}
+
+	if (ent->ghoul2 && trap_G2_HaveWeGhoul2Models(ent->ghoul2))
+	{
+		trap_G2API_CleanGhoul2Models(&ent->ghoul2);
+	}
+	i = 0;
+	while (i < MAX_SABERS)
+	{
+		if (ent->client->weaponGhoul2[i] && trap_G2_HaveWeGhoul2Models(ent->client->weaponGhoul2[i]))
+		{
+			trap_G2API_CleanGhoul2Models(&ent->client->weaponGhoul2[i]);
+		}
+		i++;
+	}
+
+	trap_UnlinkEntity (ent);
+	ent->s.modelindex = 0;
+	ent->inuse = qfalse;
+	ent->classname = "disconnected";
+	ent->client->pers.connected = CON_DISCONNECTED;
+	ent->client->ps.persistant[PERS_TEAM] = TEAM_FREE;
+	ent->client->sess.sessionTeam = TEAM_FREE;
+	ent->r.contents = 0;
+
+	trap_SetConfigstring( CS_PLAYERS + clientNum, "");
+
+	CalculateRanks();
+
+	if ( ent->r.svFlags & SVF_BOT ) {
+		BotAIShutdownClient( clientNum, qfalse );
+	}
+
+	G_ClearClientLog(clientNum);
+}
+
+
diff --git a/codemp/game/g_cmds.c b/codemp/game/g_cmds.c
new file mode 100644
index 0000000..2a7f2ee
--- /dev/null
+++ b/codemp/game/g_cmds.c
@@ -0,0 +1,3911 @@
+// Copyright (C) 1999-2000 Id Software, Inc.
+//
+#include "g_local.h"
+#include "bg_saga.h"
+
+#include "../../ui/menudef.h"			// for the voice chats
+
+//rww - for getting bot commands...
+int AcceptBotCommand(char *cmd, gentity_t *pl);
+//end rww
+
+#include "../namespace_begin.h"
+void WP_SetSaber( int entNum, saberInfo_t *sabers, int saberNum, const char *saberName );
+#include "../namespace_end.h"
+
+void Cmd_NPC_f( gentity_t *ent );
+void SetTeamQuick(gentity_t *ent, int team, qboolean doBegin);
+
+/*
+==================
+DeathmatchScoreboardMessage
+
+==================
+*/
+void DeathmatchScoreboardMessage( gentity_t *ent ) {
+	char		entry[1024];
+	char		string[1400];
+	int			stringlength;
+	int			i, j;
+	gclient_t	*cl;
+	int			numSorted, scoreFlags, accuracy, perfect;
+
+	// send the latest information on all clients
+	string[0] = 0;
+	stringlength = 0;
+	scoreFlags = 0;
+
+	numSorted = level.numConnectedClients;
+	
+	if (numSorted > MAX_CLIENT_SCORE_SEND)
+	{
+		numSorted = MAX_CLIENT_SCORE_SEND;
+	}
+
+	for (i=0 ; i < numSorted ; i++) {
+		int		ping;
+
+		cl = &level.clients[level.sortedClients[i]];
+
+		if ( cl->pers.connected == CON_CONNECTING ) {
+			ping = -1;
+		} else {
+			ping = cl->ps.ping < 999 ? cl->ps.ping : 999;
+		}
+
+		if( cl->accuracy_shots ) {
+			accuracy = cl->accuracy_hits * 100 / cl->accuracy_shots;
+		}
+		else {
+			accuracy = 0;
+		}
+		perfect = ( cl->ps.persistant[PERS_RANK] == 0 && cl->ps.persistant[PERS_KILLED] == 0 ) ? 1 : 0;
+
+		Com_sprintf (entry, sizeof(entry),
+			" %i %i %i %i %i %i %i %i %i %i %i %i %i %i", level.sortedClients[i],
+			cl->ps.persistant[PERS_SCORE], ping, (level.time - cl->pers.enterTime)/60000,
+			scoreFlags, g_entities[level.sortedClients[i]].s.powerups, accuracy, 
+			cl->ps.persistant[PERS_IMPRESSIVE_COUNT],
+			cl->ps.persistant[PERS_EXCELLENT_COUNT],
+			cl->ps.persistant[PERS_GAUNTLET_FRAG_COUNT], 
+			cl->ps.persistant[PERS_DEFEND_COUNT], 
+			cl->ps.persistant[PERS_ASSIST_COUNT], 
+			perfect,
+			cl->ps.persistant[PERS_CAPTURES]);
+		j = strlen(entry);
+		if (stringlength + j > 1022)
+			break;
+		strcpy (string + stringlength, entry);
+		stringlength += j;
+	}
+
+	//still want to know the total # of clients
+	i = level.numConnectedClients;
+
+	trap_SendServerCommand( ent-g_entities, va("scores %i %i %i%s", i, 
+		level.teamScores[TEAM_RED], level.teamScores[TEAM_BLUE],
+		string ) );
+}
+
+
+/*
+==================
+Cmd_Score_f
+
+Request current scoreboard information
+==================
+*/
+void Cmd_Score_f( gentity_t *ent ) {
+	DeathmatchScoreboardMessage( ent );
+}
+
+
+
+/*
+==================
+CheatsOk
+==================
+*/
+qboolean	CheatsOk( gentity_t *ent ) {
+	if ( !g_cheats.integer ) {
+		trap_SendServerCommand( ent-g_entities, va("print \"%s\n\"", G_GetStringEdString("MP_SVGAME", "NOCHEATS")));
+		return qfalse;
+	}
+	if ( ent->health <= 0 ) {
+		trap_SendServerCommand( ent-g_entities, va("print \"%s\n\"", G_GetStringEdString("MP_SVGAME", "MUSTBEALIVE")));
+		return qfalse;
+	}
+	return qtrue;
+}
+
+
+/*
+==================
+ConcatArgs
+==================
+*/
+char	*ConcatArgs( int start ) {
+	int		i, c, tlen;
+	static char	line[MAX_STRING_CHARS];
+	int		len;
+	char	arg[MAX_STRING_CHARS];
+
+	len = 0;
+	c = trap_Argc();
+	for ( i = start ; i < c ; i++ ) {
+		trap_Argv( i, arg, sizeof( arg ) );
+		tlen = strlen( arg );
+		if ( len + tlen >= MAX_STRING_CHARS - 1 ) {
+			break;
+		}
+		memcpy( line + len, arg, tlen );
+		len += tlen;
+		if ( i != c - 1 ) {
+			line[len] = ' ';
+			len++;
+		}
+	}
+
+	line[len] = 0;
+
+	return line;
+}
+
+/*
+==================
+SanitizeString
+
+Remove case and control characters
+==================
+*/
+void SanitizeString( char *in, char *out ) {
+	while ( *in ) {
+		if ( *in == 27 ) {
+			in += 2;		// skip color code
+			continue;
+		}
+		if ( *in < 32 ) {
+			in++;
+			continue;
+		}
+		*out++ = tolower( (unsigned char) *in++ );
+	}
+
+	*out = 0;
+}
+
+/*
+==================
+ClientNumberFromString
+
+Returns a player number for either a number or name string
+Returns -1 if invalid
+==================
+*/
+int ClientNumberFromString( gentity_t *to, char *s ) {
+	gclient_t	*cl;
+	int			idnum;
+	char		s2[MAX_STRING_CHARS];
+	char		n2[MAX_STRING_CHARS];
+
+	// numeric values are just slot numbers
+	if (s[0] >= '0' && s[0] <= '9') {
+		idnum = atoi( s );
+		if ( idnum < 0 || idnum >= level.maxclients ) {
+			trap_SendServerCommand( to-g_entities, va("print \"Bad client slot: %i\n\"", idnum));
+			return -1;
+		}
+
+		cl = &level.clients[idnum];
+		if ( cl->pers.connected != CON_CONNECTED ) {
+			trap_SendServerCommand( to-g_entities, va("print \"Client %i is not active\n\"", idnum));
+			return -1;
+		}
+		return idnum;
+	}
+
+	// check for a name match
+	SanitizeString( s, s2 );
+	for ( idnum=0,cl=level.clients ; idnum < level.maxclients ; idnum++,cl++ ) {
+		if ( cl->pers.connected != CON_CONNECTED ) {
+			continue;
+		}
+		SanitizeString( cl->pers.netname, n2 );
+		if ( !strcmp( n2, s2 ) ) {
+			return idnum;
+		}
+	}
+
+	trap_SendServerCommand( to-g_entities, va("print \"User %s is not on the server\n\"", s));
+	return -1;
+}
+
+/*
+==================
+Cmd_Give_f
+
+Give items to a client
+==================
+*/
+void Cmd_Give_f (gentity_t *cmdent, int baseArg)
+{
+	char		name[MAX_TOKEN_CHARS];
+	gentity_t	*ent;
+	gitem_t		*it;
+	int			i;
+	qboolean	give_all;
+	gentity_t		*it_ent;
+	trace_t		trace;
+	char		arg[MAX_TOKEN_CHARS];
+
+	if ( !CheatsOk( cmdent ) ) {
+		return;
+	}
+
+	if (baseArg)
+	{
+		char otherindex[MAX_TOKEN_CHARS];
+
+		trap_Argv( 1, otherindex, sizeof( otherindex ) );
+
+		if (!otherindex[0])
+		{
+			Com_Printf("giveother requires that the second argument be a client index number.\n");
+			return;
+		}
+
+		i = atoi(otherindex);
+
+		if (i < 0 || i >= MAX_CLIENTS)
+		{
+			Com_Printf("%i is not a client index\n", i);
+			return;
+		}
+
+		ent = &g_entities[i];
+
+		if (!ent->inuse || !ent->client)
+		{
+			Com_Printf("%i is not an active client\n", i);
+			return;
+		}
+	}
+	else
+	{
+		ent = cmdent;
+	}
+
+	trap_Argv( 1+baseArg, name, sizeof( name ) );
+
+	if (Q_stricmp(name, "all") == 0)
+		give_all = qtrue;
+	else
+		give_all = qfalse;
+
+	if (give_all)
+	{
+		i = 0;
+		while (i < HI_NUM_HOLDABLE)
+		{
+			ent->client->ps.stats[STAT_HOLDABLE_ITEMS] |= (1 << i);
+			i++;
+		}
+		i = 0;
+	}
+
+	if (give_all || Q_stricmp( name, "health") == 0)
+	{
+		if (trap_Argc() == 3+baseArg) {
+			trap_Argv( 2+baseArg, arg, sizeof( arg ) );
+			ent->health = atoi(arg);
+			if (ent->health > ent->client->ps.stats[STAT_MAX_HEALTH]) {
+				ent->health = ent->client->ps.stats[STAT_MAX_HEALTH];
+			}
+		}
+		else {
+			ent->health = ent->client->ps.stats[STAT_MAX_HEALTH];
+		}
+		if (!give_all)
+			return;
+	}
+
+	if (give_all || Q_stricmp(name, "weapons") == 0)
+	{
+		ent->client->ps.stats[STAT_WEAPONS] = (1 << (LAST_USEABLE_WEAPON+1))  - ( 1 << WP_NONE );
+		if (!give_all)
+			return;
+	}
+	
+	if ( !give_all && Q_stricmp(name, "weaponnum") == 0 )
+	{
+		trap_Argv( 2+baseArg, arg, sizeof( arg ) );
+		ent->client->ps.stats[STAT_WEAPONS] |= (1 << atoi(arg));
+		return;
+	}
+
+	if (give_all || Q_stricmp(name, "ammo") == 0)
+	{
+		int num = 999;
+		if (trap_Argc() == 3+baseArg) {
+			trap_Argv( 2+baseArg, arg, sizeof( arg ) );
+			num = atoi(arg);
+		}
+		for ( i = 0 ; i < MAX_WEAPONS ; i++ ) {
+			ent->client->ps.ammo[i] = num;
+		}
+		if (!give_all)
+			return;
+	}
+
+	if (give_all || Q_stricmp(name, "armor") == 0)
+	{
+		if (trap_Argc() == 3+baseArg) {
+			trap_Argv( 2+baseArg, arg, sizeof( arg ) );
+			ent->client->ps.stats[STAT_ARMOR] = atoi(arg);
+		} else {
+			ent->client->ps.stats[STAT_ARMOR] = ent->client->ps.stats[STAT_MAX_HEALTH];
+		}
+
+		if (!give_all)
+			return;
+	}
+
+	if (Q_stricmp(name, "excellent") == 0) {
+		ent->client->ps.persistant[PERS_EXCELLENT_COUNT]++;
+		return;
+	}
+	if (Q_stricmp(name, "impressive") == 0) {
+		ent->client->ps.persistant[PERS_IMPRESSIVE_COUNT]++;
+		return;
+	}
+	if (Q_stricmp(name, "gauntletaward") == 0) {
+		ent->client->ps.persistant[PERS_GAUNTLET_FRAG_COUNT]++;
+		return;
+	}
+	if (Q_stricmp(name, "defend") == 0) {
+		ent->client->ps.persistant[PERS_DEFEND_COUNT]++;
+		return;
+	}
+	if (Q_stricmp(name, "assist") == 0) {
+		ent->client->ps.persistant[PERS_ASSIST_COUNT]++;
+		return;
+	}
+
+	// spawn a specific item right on the player
+	if ( !give_all ) {
+		it = BG_FindItem (name);
+		if (!it) {
+			return;
+		}
+
+		it_ent = G_Spawn();
+		VectorCopy( ent->r.currentOrigin, it_ent->s.origin );
+		it_ent->classname = it->classname;
+		G_SpawnItem (it_ent, it);
+		FinishSpawningItem(it_ent );
+		memset( &trace, 0, sizeof( trace ) );
+		Touch_Item (it_ent, ent, &trace);
+		if (it_ent->inuse) {
+			G_FreeEntity( it_ent );
+		}
+	}
+}
+
+/*
+==================
+Cmd_God_f
+
+Sets client to godmode
+
+argv(0) god
+==================
+*/
+void Cmd_God_f (gentity_t *ent)
+{
+	char	*msg;
+
+	if ( !CheatsOk( ent ) ) {
+		return;
+	}
+
+	ent->flags ^= FL_GODMODE;
+	if (!(ent->flags & FL_GODMODE) )
+		msg = "godmode OFF\n";
+	else
+		msg = "godmode ON\n";
+
+	trap_SendServerCommand( ent-g_entities, va("print \"%s\"", msg));
+}
+
+
+/*
+==================
+Cmd_Notarget_f
+
+Sets client to notarget
+
+argv(0) notarget
+==================
+*/
+void Cmd_Notarget_f( gentity_t *ent ) {
+	char	*msg;
+
+	if ( !CheatsOk( ent ) ) {
+		return;
+	}
+
+	ent->flags ^= FL_NOTARGET;
+	if (!(ent->flags & FL_NOTARGET) )
+		msg = "notarget OFF\n";
+	else
+		msg = "notarget ON\n";
+
+	trap_SendServerCommand( ent-g_entities, va("print \"%s\"", msg));
+}
+
+
+/*
+==================
+Cmd_Noclip_f
+
+argv(0) noclip
+==================
+*/
+void Cmd_Noclip_f( gentity_t *ent ) {
+	char	*msg;
+
+	if ( !CheatsOk( ent ) ) {
+		return;
+	}
+
+	if ( ent->client->noclip ) {
+		msg = "noclip OFF\n";
+	} else {
+		msg = "noclip ON\n";
+	}
+	ent->client->noclip = !ent->client->noclip;
+
+	trap_SendServerCommand( ent-g_entities, va("print \"%s\"", msg));
+}
+
+
+/*
+==================
+Cmd_LevelShot_f
+
+This is just to help generate the level pictures
+for the menus.  It goes to the intermission immediately
+and sends over a command to the client to resize the view,
+hide the scoreboard, and take a special screenshot
+==================
+*/
+void Cmd_LevelShot_f( gentity_t *ent ) {
+	if ( !CheatsOk( ent ) ) {
+		return;
+	}
+
+	// doesn't work in single player
+	if ( g_gametype.integer != 0 ) {
+		trap_SendServerCommand( ent-g_entities, 
+			"print \"Must be in g_gametype 0 for levelshot\n\"" );
+		return;
+	}
+
+	BeginIntermission();
+	trap_SendServerCommand( ent-g_entities, "clientLevelShot" );
+}
+
+
+/*
+==================
+Cmd_TeamTask_f
+
+From TA.
+==================
+*/
+void Cmd_TeamTask_f( gentity_t *ent ) {
+	char userinfo[MAX_INFO_STRING];
+	char		arg[MAX_TOKEN_CHARS];
+	int task;
+	int client = ent->client - level.clients;
+
+	if ( trap_Argc() != 2 ) {
+		return;
+	}
+	trap_Argv( 1, arg, sizeof( arg ) );
+	task = atoi( arg );
+
+	trap_GetUserinfo(client, userinfo, sizeof(userinfo));
+	Info_SetValueForKey(userinfo, "teamtask", va("%d", task));
+	trap_SetUserinfo(client, userinfo);
+	ClientUserinfoChanged(client);
+}
+
+
+
+/*
+=================
+Cmd_Kill_f
+=================
+*/
+void Cmd_Kill_f( gentity_t *ent ) {
+	if ( ent->client->sess.sessionTeam == TEAM_SPECTATOR ) {
+		return;
+	}
+	if (ent->health <= 0) {
+		return;
+	}
+
+	if ((g_gametype.integer == GT_DUEL || g_gametype.integer == GT_POWERDUEL) &&
+		level.numPlayingClients > 1 && !level.warmupTime)
+	{
+		if (!g_allowDuelSuicide.integer)
+		{
+			trap_SendServerCommand( ent-g_entities, va("print \"%s\n\"", G_GetStringEdString("MP_SVGAME", "ATTEMPTDUELKILL")) );
+			return;
+		}
+	}
+
+	ent->flags &= ~FL_GODMODE;
+	ent->client->ps.stats[STAT_HEALTH] = ent->health = -999;
+	player_die (ent, ent, ent, 100000, MOD_SUICIDE);
+}
+
+gentity_t *G_GetDuelWinner(gclient_t *client)
+{
+	gclient_t *wCl;
+	int i;
+
+	for ( i = 0 ; i < level.maxclients ; i++ ) {
+		wCl = &level.clients[i];
+		
+		if (wCl && wCl != client && /*wCl->ps.clientNum != client->ps.clientNum &&*/
+			wCl->pers.connected == CON_CONNECTED && wCl->sess.sessionTeam != TEAM_SPECTATOR)
+		{
+			return &g_entities[wCl->ps.clientNum];
+		}
+	}
+
+	return NULL;
+}
+
+/*
+=================
+BroadCastTeamChange
+
+Let everyone know about a team change
+=================
+*/
+void BroadcastTeamChange( gclient_t *client, int oldTeam )
+{
+	client->ps.fd.forceDoInit = 1; //every time we change teams make sure our force powers are set right
+
+	if (g_gametype.integer == GT_SIEGE)
+	{ //don't announce these things in siege
+		return;
+	}
+
+	if ( client->sess.sessionTeam == TEAM_RED ) {
+		trap_SendServerCommand( -1, va("cp \"%s" S_COLOR_WHITE " %s\n\"",
+			client->pers.netname, G_GetStringEdString("MP_SVGAME", "JOINEDTHEREDTEAM")) );
+	} else if ( client->sess.sessionTeam == TEAM_BLUE ) {
+		trap_SendServerCommand( -1, va("cp \"%s" S_COLOR_WHITE " %s\n\"",
+		client->pers.netname, G_GetStringEdString("MP_SVGAME", "JOINEDTHEBLUETEAM")));
+	} else if ( client->sess.sessionTeam == TEAM_SPECTATOR && oldTeam != TEAM_SPECTATOR ) {
+		trap_SendServerCommand( -1, va("cp \"%s" S_COLOR_WHITE " %s\n\"",
+		client->pers.netname, G_GetStringEdString("MP_SVGAME", "JOINEDTHESPECTATORS")));
+	} else if ( client->sess.sessionTeam == TEAM_FREE ) {
+		if (g_gametype.integer == GT_DUEL || g_gametype.integer == GT_POWERDUEL)
+		{
+			/*
+			gentity_t *currentWinner = G_GetDuelWinner(client);
+
+			if (currentWinner && currentWinner->client)
+			{
+				trap_SendServerCommand( -1, va("cp \"%s" S_COLOR_WHITE " %s %s\n\"",
+				currentWinner->client->pers.netname, G_GetStringEdString("MP_SVGAME", "VERSUS"), client->pers.netname));
+			}
+			else
+			{
+				trap_SendServerCommand( -1, va("cp \"%s" S_COLOR_WHITE " %s\n\"",
+				client->pers.netname, G_GetStringEdString("MP_SVGAME", "JOINEDTHEBATTLE")));
+			}
+			*/
+			//NOTE: Just doing a vs. once it counts two players up
+		}
+		else
+		{
+			trap_SendServerCommand( -1, va("cp \"%s" S_COLOR_WHITE " %s\n\"",
+			client->pers.netname, G_GetStringEdString("MP_SVGAME", "JOINEDTHEBATTLE")));
+		}
+	}
+
+	G_LogPrintf ( "setteam:  %i %s %s\n",
+				  client - &level.clients[0],
+				  TeamName ( oldTeam ),
+				  TeamName ( client->sess.sessionTeam ) );
+}
+
+qboolean G_PowerDuelCheckFail(gentity_t *ent)
+{
+	int			loners = 0;
+	int			doubles = 0;
+
+	if (!ent->client || ent->client->sess.duelTeam == DUELTEAM_FREE)
+	{
+		return qtrue;
+	}
+
+	G_PowerDuelCount(&loners, &doubles, qfalse);
+
+	if (ent->client->sess.duelTeam == DUELTEAM_LONE && loners >= 1)
+	{
+		return qtrue;
+	}
+
+	if (ent->client->sess.duelTeam == DUELTEAM_DOUBLE && doubles >= 2)
+	{
+		return qtrue;
+	}
+
+	return qfalse;
+}
+
+/*
+=================
+SetTeam
+=================
+*/
+qboolean g_dontPenalizeTeam = qfalse;
+qboolean g_preventTeamBegin = qfalse;
+void SetTeam( gentity_t *ent, char *s ) {
+	int					team, oldTeam;
+	gclient_t			*client;
+	int					clientNum;
+	spectatorState_t	specState;
+	int					specClient;
+	int					teamLeader;
+
+	//
+	// see what change is requested
+	//
+	client = ent->client;
+
+	clientNum = client - level.clients;
+	specClient = 0;
+	specState = SPECTATOR_NOT;
+	if ( !Q_stricmp( s, "scoreboard" ) || !Q_stricmp( s, "score" )  ) {
+		team = TEAM_SPECTATOR;
+		specState = SPECTATOR_SCOREBOARD;
+	} else if ( !Q_stricmp( s, "follow1" ) ) {
+		team = TEAM_SPECTATOR;
+		specState = SPECTATOR_FOLLOW;
+		specClient = -1;
+	} else if ( !Q_stricmp( s, "follow2" ) ) {
+		team = TEAM_SPECTATOR;
+		specState = SPECTATOR_FOLLOW;
+		specClient = -2;
+	} else if ( !Q_stricmp( s, "spectator" ) || !Q_stricmp( s, "s" ) ) {
+		team = TEAM_SPECTATOR;
+		specState = SPECTATOR_FREE;
+	} else if ( g_gametype.integer >= GT_TEAM ) {
+		// if running a team game, assign player to one of the teams
+		specState = SPECTATOR_NOT;
+		if ( !Q_stricmp( s, "red" ) || !Q_stricmp( s, "r" ) ) {
+			team = TEAM_RED;
+		} else if ( !Q_stricmp( s, "blue" ) || !Q_stricmp( s, "b" ) ) {
+			team = TEAM_BLUE;
+		} else {
+			// pick the team with the least number of players
+			//For now, don't do this. The legalize function will set powers properly now.
+			/*
+			if (g_forceBasedTeams.integer)
+			{
+				if (ent->client->ps.fd.forceSide == FORCE_LIGHTSIDE)
+				{
+					team = TEAM_BLUE;
+				}
+				else
+				{
+					team = TEAM_RED;
+				}
+			}
+			else
+			{
+			*/
+				team = PickTeam( clientNum );
+			//}
+		}
+
+		if ( g_teamForceBalance.integer && !g_trueJedi.integer ) {
+			int		counts[TEAM_NUM_TEAMS];
+
+			counts[TEAM_BLUE] = TeamCount( ent->client->ps.clientNum, TEAM_BLUE );
+			counts[TEAM_RED] = TeamCount( ent->client->ps.clientNum, TEAM_RED );
+
+			// We allow a spread of two
+			if ( team == TEAM_RED && counts[TEAM_RED] - counts[TEAM_BLUE] > 1 ) {
+				//For now, don't do this. The legalize function will set powers properly now.
+				/*
+				if (g_forceBasedTeams.integer && ent->client->ps.fd.forceSide == FORCE_DARKSIDE)
+				{
+					trap_SendServerCommand( ent->client->ps.clientNum, 
+						va("print \"%s\n\"", G_GetStringEdString("MP_SVGAME", "TOOMANYRED_SWITCH")) );
+				}
+				else
+				*/
+				{
+					trap_SendServerCommand( ent->client->ps.clientNum, 
+						va("print \"%s\n\"", G_GetStringEdString("MP_SVGAME", "TOOMANYRED")) );
+				}
+				return; // ignore the request
+			}
+			if ( team == TEAM_BLUE && counts[TEAM_BLUE] - counts[TEAM_RED] > 1 ) {
+				//For now, don't do this. The legalize function will set powers properly now.
+				/*
+				if (g_forceBasedTeams.integer && ent->client->ps.fd.forceSide == FORCE_LIGHTSIDE)
+				{
+					trap_SendServerCommand( ent->client->ps.clientNum, 
+						va("print \"%s\n\"", G_GetStringEdString("MP_SVGAME", "TOOMANYBLUE_SWITCH")) );
+				}
+				else
+				*/
+				{
+					trap_SendServerCommand( ent->client->ps.clientNum, 
+						va("print \"%s\n\"", G_GetStringEdString("MP_SVGAME", "TOOMANYBLUE")) );
+				}
+				return; // ignore the request
+			}
+
+			// It's ok, the team we are switching to has less or same number of players
+		}
+
+		//For now, don't do this. The legalize function will set powers properly now.
+		/*
+		if (g_forceBasedTeams.integer)
+		{
+			if (team == TEAM_BLUE && ent->client->ps.fd.forceSide != FORCE_LIGHTSIDE)
+			{
+				trap_SendServerCommand( ent-g_entities, va("print \"%s\n\"", G_GetStringEdString("MP_SVGAME", "MUSTBELIGHT")) );
+				return;
+			}
+			if (team == TEAM_RED && ent->client->ps.fd.forceSide != FORCE_DARKSIDE)
+			{
+				trap_SendServerCommand( ent-g_entities, va("print \"%s\n\"", G_GetStringEdString("MP_SVGAME", "MUSTBEDARK")) );
+				return;
+			}
+		}
+		*/
+
+	} else {
+		// force them to spectators if there aren't any spots free
+		team = TEAM_FREE;
+	}
+
+	if (g_gametype.integer == GT_SIEGE)
+	{
+		if (client->tempSpectate >= level.time &&
+			team == TEAM_SPECTATOR)
+		{ //sorry, can't do that.
+			return;
+		}
+
+		client->sess.siegeDesiredTeam = team;
+		//oh well, just let them go.
+		/*
+		if (team != TEAM_SPECTATOR)
+		{ //can't switch to anything in siege unless you want to switch to being a fulltime spectator
+			//fill them in on their objectives for this team now
+			trap_SendServerCommand(ent-g_entities, va("sb %i", client->sess.siegeDesiredTeam));
+
+			trap_SendServerCommand( ent-g_entities, va("print \"You will be on the selected team the next time the round begins.\n\"") );
+			return;
+		}
+		*/
+		if (client->sess.sessionTeam != TEAM_SPECTATOR &&
+			team != TEAM_SPECTATOR)
+		{ //not a spectator now, and not switching to spec, so you have to wait til you die.
+			//trap_SendServerCommand( ent-g_entities, va("print \"You will be on the selected team the next time you respawn.\n\"") );
+			qboolean doBegin;
+			if (ent->client->tempSpectate >= level.time)
+			{
+				doBegin = qfalse;
+			}
+			else
+			{
+				doBegin = qtrue;
+			}
+
+			if (doBegin)
+			{
+				// Kill them so they automatically respawn in the team they wanted.
+				if (ent->health > 0)
+				{
+					ent->flags &= ~FL_GODMODE;
+					ent->client->ps.stats[STAT_HEALTH] = ent->health = 0;
+					player_die( ent, ent, ent, 100000, MOD_TEAM_CHANGE ); 
+				}
+			}
+
+			if (ent->client->sess.sessionTeam != ent->client->sess.siegeDesiredTeam)
+			{
+				SetTeamQuick(ent, ent->client->sess.siegeDesiredTeam, qfalse);
+			}
+
+			return;
+		}
+	}
+
+	// override decision if limiting the players
+	if ( (g_gametype.integer == GT_DUEL)
+		&& level.numNonSpectatorClients >= 2 )
+	{
+		team = TEAM_SPECTATOR;
+	}
+	else if ( (g_gametype.integer == GT_POWERDUEL)
+		&& (level.numPlayingClients >= 3 || G_PowerDuelCheckFail(ent)) )
+	{
+		team = TEAM_SPECTATOR;
+	}
+	else if ( g_maxGameClients.integer > 0 && 
+		level.numNonSpectatorClients >= g_maxGameClients.integer )
+	{
+		team = TEAM_SPECTATOR;
+	}
+
+	//
+	// decide if we will allow the change
+	//
+	oldTeam = client->sess.sessionTeam;
+	if ( team == oldTeam && team != TEAM_SPECTATOR ) {
+		return;
+	}
+
+	//
+	// execute the team change
+	//
+
+	//If it's siege then show the mission briefing for the team you just joined.
+//	if (g_gametype.integer == GT_SIEGE && team != TEAM_SPECTATOR)
+//	{
+//		trap_SendServerCommand(clientNum, va("sb %i", team));
+//	}
+
+	// if the player was dead leave the body
+	if ( client->ps.stats[STAT_HEALTH] <= 0 && client->sess.sessionTeam != TEAM_SPECTATOR ) {
+		MaintainBodyQueue(ent);
+	}
+
+	// he starts at 'base'
+	client->pers.teamState.state = TEAM_BEGIN;
+	if ( oldTeam != TEAM_SPECTATOR ) {
+		// Kill him (makes sure he loses flags, etc)
+		ent->flags &= ~FL_GODMODE;
+		ent->client->ps.stats[STAT_HEALTH] = ent->health = 0;
+		g_dontPenalizeTeam = qtrue;
+		player_die (ent, ent, ent, 100000, MOD_SUICIDE);
+		g_dontPenalizeTeam = qfalse;
+
+	}
+	// they go to the end of the line for tournements
+	if ( team == TEAM_SPECTATOR ) {
+		if ( (g_gametype.integer != GT_DUEL) || (oldTeam != TEAM_SPECTATOR) )	{//so you don't get dropped to the bottom of the queue for changing skins, etc.
+			client->sess.spectatorTime = level.time;
+		}
+	}
+
+	client->sess.sessionTeam = team;
+	client->sess.spectatorState = specState;
+	client->sess.spectatorClient = specClient;
+
+	client->sess.teamLeader = qfalse;
+	if ( team == TEAM_RED || team == TEAM_BLUE ) {
+		teamLeader = TeamLeader( team );
+		// if there is no team leader or the team leader is a bot and this client is not a bot
+		if ( teamLeader == -1 || ( !(g_entities[clientNum].r.svFlags & SVF_BOT) && (g_entities[teamLeader].r.svFlags & SVF_BOT) ) ) {
+			//SetLeader( team, clientNum );
+		}
+	}
+	// make sure there is a team leader on the team the player came from
+	if ( oldTeam == TEAM_RED || oldTeam == TEAM_BLUE ) {
+		CheckTeamLeader( oldTeam );
+	}
+
+	BroadcastTeamChange( client, oldTeam );
+
+	//make a disappearing effect where they were before teleporting them to the appropriate spawn point,
+	//if we were not on the spec team
+	if (oldTeam != TEAM_SPECTATOR)
+	{
+		gentity_t *tent = G_TempEntity( client->ps.origin, EV_PLAYER_TELEPORT_OUT );
+		tent->s.clientNum = clientNum;
+	}
+
+	// get and distribute relevent paramters
+	ClientUserinfoChanged( clientNum );
+
+	if (!g_preventTeamBegin)
+	{
+		ClientBegin( clientNum, qfalse );
+	}
+}
+
+/*
+=================
+StopFollowing
+
+If the client being followed leaves the game, or you just want to drop
+to free floating spectator mode
+=================
+*/
+void StopFollowing( gentity_t *ent ) {
+	ent->client->ps.persistant[ PERS_TEAM ] = TEAM_SPECTATOR;	
+	ent->client->sess.sessionTeam = TEAM_SPECTATOR;	
+	ent->client->sess.spectatorState = SPECTATOR_FREE;
+	ent->client->ps.pm_flags &= ~PMF_FOLLOW;
+	ent->r.svFlags &= ~SVF_BOT;
+	ent->client->ps.clientNum = ent - g_entities;
+	ent->client->ps.weapon = WP_NONE;
+	ent->client->ps.m_iVehicleNum = 0;
+	ent->client->ps.viewangles[ROLL] = 0.0f;
+	ent->client->ps.forceHandExtend = HANDEXTEND_NONE;
+	ent->client->ps.forceHandExtendTime = 0;
+	ent->client->ps.zoomMode = 0;
+	ent->client->ps.zoomLocked = 0;
+	ent->client->ps.zoomLockTime = 0;
+	ent->client->ps.legsAnim = 0;
+	ent->client->ps.legsTimer = 0;
+	ent->client->ps.torsoAnim = 0;
+	ent->client->ps.torsoTimer = 0;
+}
+
+/*
+=================
+Cmd_Team_f
+=================
+*/
+void Cmd_Team_f( gentity_t *ent ) {
+	int			oldTeam;
+	char		s[MAX_TOKEN_CHARS];
+
+	if ( trap_Argc() != 2 ) {
+		oldTeam = ent->client->sess.sessionTeam;
+		switch ( oldTeam ) {
+		case TEAM_BLUE:
+			trap_SendServerCommand( ent-g_entities, va("print \"%s\n\"", G_GetStringEdString("MP_SVGAME", "PRINTBLUETEAM")) );
+			break;
+		case TEAM_RED:
+			trap_SendServerCommand( ent-g_entities, va("print \"%s\n\"", G_GetStringEdString("MP_SVGAME", "PRINTREDTEAM")) );
+			break;
+		case TEAM_FREE:
+			trap_SendServerCommand( ent-g_entities, va("print \"%s\n\"", G_GetStringEdString("MP_SVGAME", "PRINTFREETEAM")) );
+			break;
+		case TEAM_SPECTATOR:
+			trap_SendServerCommand( ent-g_entities, va("print \"%s\n\"", G_GetStringEdString("MP_SVGAME", "PRINTSPECTEAM")) );
+			break;
+		}
+		return;
+	}
+
+	if ( ent->client->switchTeamTime > level.time ) {
+		trap_SendServerCommand( ent-g_entities, va("print \"%s\n\"", G_GetStringEdString("MP_SVGAME", "NOSWITCH")) );
+		return;
+	}
+
+	if (gEscaping)
+	{
+		return;
+	}
+
+	// if they are playing a tournement game, count as a loss
+	if ( g_gametype.integer == GT_DUEL
+		&& ent->client->sess.sessionTeam == TEAM_FREE ) {//in a tournament game
+		//disallow changing teams
+		trap_SendServerCommand( ent-g_entities, "print \"Cannot switch teams in Duel\n\"" );
+		return;
+		//FIXME: why should this be a loss???
+		//ent->client->sess.losses++;
+	}
+
+	if (g_gametype.integer == GT_POWERDUEL)
+	{ //don't let clients change teams manually at all in powerduel, it will be taken care of through automated stuff
+		trap_SendServerCommand( ent-g_entities, "print \"Cannot switch teams in Power Duel\n\"" );
+		return;
+	}
+
+	trap_Argv( 1, s, sizeof( s ) );
+
+	SetTeam( ent, s );
+
+	ent->client->switchTeamTime = level.time + 5000;
+}
+
+/*
+=================
+Cmd_DuelTeam_f
+=================
+*/
+void Cmd_DuelTeam_f(gentity_t *ent)
+{
+	int			oldTeam;
+	char		s[MAX_TOKEN_CHARS];
+
+	if (g_gametype.integer != GT_POWERDUEL)
+	{ //don't bother doing anything if this is not power duel
+		return;
+	}
+
+	/*
+	if (ent->client->sess.sessionTeam != TEAM_SPECTATOR)
+	{
+		trap_SendServerCommand( ent-g_entities, va("print \"You cannot change your duel team unless you are a spectator.\n\""));
+		return;
+	}
+	*/
+
+	if ( trap_Argc() != 2 )
+	{ //No arg so tell what team we're currently on.
+		oldTeam = ent->client->sess.duelTeam;
+		switch ( oldTeam )
+		{
+		case DUELTEAM_FREE:
+			trap_SendServerCommand( ent-g_entities, va("print \"None\n\"") );
+			break;
+		case DUELTEAM_LONE:
+			trap_SendServerCommand( ent-g_entities, va("print \"Single\n\"") );
+			break;
+		case DUELTEAM_DOUBLE:
+			trap_SendServerCommand( ent-g_entities, va("print \"Double\n\"") );
+			break;
+		default:
+			break;
+		}
+		return;
+	}
+
+	if ( ent->client->switchDuelTeamTime > level.time )
+	{ //debounce for changing
+		trap_SendServerCommand( ent-g_entities, va("print \"%s\n\"", G_GetStringEdString("MP_SVGAME", "NOSWITCH")) );
+		return;
+	}
+
+	trap_Argv( 1, s, sizeof( s ) );
+
+	oldTeam = ent->client->sess.duelTeam;
+
+	if (!Q_stricmp(s, "free"))
+	{
+		ent->client->sess.duelTeam = DUELTEAM_FREE;
+	}
+	else if (!Q_stricmp(s, "single"))
+	{
+		ent->client->sess.duelTeam = DUELTEAM_LONE;
+	}
+	else if (!Q_stricmp(s, "double"))
+	{
+		ent->client->sess.duelTeam = DUELTEAM_DOUBLE;
+	}
+	else
+	{
+		trap_SendServerCommand( ent-g_entities, va("print \"'%s' not a valid duel team.\n\"", s) );
+	}
+
+	if (oldTeam == ent->client->sess.duelTeam)
+	{ //didn't actually change, so don't care.
+		return;
+	}
+
+	if (ent->client->sess.sessionTeam != TEAM_SPECTATOR)
+	{ //ok..die
+		int curTeam = ent->client->sess.duelTeam;
+		ent->client->sess.duelTeam = oldTeam;
+		G_Damage(ent, ent, ent, NULL, ent->client->ps.origin, 99999, DAMAGE_NO_PROTECTION, MOD_SUICIDE);
+		ent->client->sess.duelTeam = curTeam;
+	}
+	//reset wins and losses
+	ent->client->sess.wins = 0;
+	ent->client->sess.losses = 0;
+
+	//get and distribute relevent paramters
+	ClientUserinfoChanged( ent->s.number );
+
+	ent->client->switchDuelTeamTime = level.time + 5000;
+}
+
+int G_TeamForSiegeClass(const char *clName)
+{
+	int i = 0;
+	int team = SIEGETEAM_TEAM1;
+	siegeTeam_t *stm = BG_SiegeFindThemeForTeam(team);
+	siegeClass_t *scl;
+
+	if (!stm)
+	{
+		return 0;
+	}
+
+	while (team <= SIEGETEAM_TEAM2)
+	{
+		scl = stm->classes[i];
+
+		if (scl && scl->name[0])
+		{
+			if (!Q_stricmp(clName, scl->name))
+			{
+				return team;
+			}
+		}
+
+		i++;
+		if (i >= MAX_SIEGE_CLASSES || i >= stm->numClasses)
+		{
+			if (team == SIEGETEAM_TEAM2)
+			{
+				break;
+			}
+			team = SIEGETEAM_TEAM2;
+			stm = BG_SiegeFindThemeForTeam(team);
+			i = 0;
+		}
+	}
+
+	return 0;
+}
+
+/*
+=================
+Cmd_SiegeClass_f
+=================
+*/
+void Cmd_SiegeClass_f( gentity_t *ent )
+{
+	char className[64];
+	int team = 0;
+	int preScore;
+	qboolean startedAsSpec = qfalse;
+
+	if (g_gametype.integer != GT_SIEGE)
+	{ //classes are only valid for this gametype
+		return;
+	}
+
+	if (!ent->client)
+	{
+		return;
+	}
+
+	if (trap_Argc() < 1)
+	{
+		return;
+	}
+
+	if ( ent->client->switchClassTime > level.time )
+	{
+		trap_SendServerCommand( ent-g_entities, va("print \"%s\n\"", G_GetStringEdString("MP_SVGAME", "NOCLASSSWITCH")) );
+		return;
+	}
+
+	if (ent->client->sess.sessionTeam == TEAM_SPECTATOR)
+	{
+		startedAsSpec = qtrue;
+	}
+
+	trap_Argv( 1, className, sizeof( className ) );
+
+	team = G_TeamForSiegeClass(className);
+
+	if (!team)
+	{ //not a valid class name
+		return;
+	}
+
+	if (ent->client->sess.sessionTeam != team)
+	{ //try changing it then
+		g_preventTeamBegin = qtrue;
+		if (team == TEAM_RED)
+		{
+			SetTeam(ent, "red");
+		}
+		else if (team == TEAM_BLUE)
+		{
+			SetTeam(ent, "blue");
+		}
+		g_preventTeamBegin = qfalse;
+
+		if (ent->client->sess.sessionTeam != team)
+		{ //failed, oh well
+			if (ent->client->sess.sessionTeam != TEAM_SPECTATOR ||
+				ent->client->sess.siegeDesiredTeam != team)
+			{
+				trap_SendServerCommand( ent-g_entities, va("print \"%s\n\"", G_GetStringEdString("MP_SVGAME", "NOCLASSTEAM")) );
+				return;
+			}
+		}
+	}
+
+	//preserve 'is score
+	preScore = ent->client->ps.persistant[PERS_SCORE];
+
+	//Make sure the class is valid for the team
+	BG_SiegeCheckClassLegality(team, className);
+
+	//Set the session data
+	strcpy(ent->client->sess.siegeClass, className);
+
+	// get and distribute relevent paramters
+	ClientUserinfoChanged( ent->s.number );
+
+	if (ent->client->tempSpectate < level.time)
+	{
+		// Kill him (makes sure he loses flags, etc)
+		if (ent->health > 0 && !startedAsSpec)
+		{
+			ent->flags &= ~FL_GODMODE;
+			ent->client->ps.stats[STAT_HEALTH] = ent->health = 0;
+			player_die (ent, ent, ent, 100000, MOD_SUICIDE);
+		}
+
+		if (ent->client->sess.sessionTeam == TEAM_SPECTATOR || startedAsSpec)
+		{ //respawn them instantly.
+			ClientBegin( ent->s.number, qfalse );
+		}
+	}
+	//set it back after we do all the stuff
+	ent->client->ps.persistant[PERS_SCORE] = preScore;
+
+	ent->client->switchClassTime = level.time + 5000;
+}
+
+/*
+=================
+Cmd_ForceChanged_f
+=================
+*/
+void Cmd_ForceChanged_f( gentity_t *ent )
+{
+	char fpChStr[1024];
+	const char *buf;
+//	Cmd_Kill_f(ent);
+	if (ent->client->sess.sessionTeam == TEAM_SPECTATOR)
+	{ //if it's a spec, just make the changes now
+		//trap_SendServerCommand( ent-g_entities, va("print \"%s\n\"", G_GetStringEdString("MP_SVGAME", "FORCEAPPLIED")) );
+		//No longer print it, as the UI calls this a lot.
+		WP_InitForcePowers( ent );
+		goto argCheck;
+	}
+
+	buf = G_GetStringEdString("MP_SVGAME", "FORCEPOWERCHANGED");
+
+	strcpy(fpChStr, buf);
+
+	trap_SendServerCommand( ent-g_entities, va("print \"%s%s\n\n\"", S_COLOR_GREEN, fpChStr) );
+
+	ent->client->ps.fd.forceDoInit = 1;
+argCheck:
+	if (g_gametype.integer == GT_DUEL || g_gametype.integer == GT_POWERDUEL)
+	{ //If this is duel, don't even bother changing team in relation to this.
+		return;
+	}
+
+	if (trap_Argc() > 1)
+	{
+		char	arg[MAX_TOKEN_CHARS];
+
+		trap_Argv( 1, arg, sizeof( arg ) );
+
+		if (arg && arg[0])
+		{ //if there's an arg, assume it's a combo team command from the UI.
+			Cmd_Team_f(ent);
+		}
+	}
+}
+
+qboolean G_SetSaber(gentity_t *ent, int saberNum, char *saberName, qboolean siegeOverride)
+{
+	char truncSaberName[64];
+	int i = 0;
+
+	if (!siegeOverride &&
+		g_gametype.integer == GT_SIEGE &&
+		ent->client->siegeClass != -1 &&
+		(
+		 bgSiegeClasses[ent->client->siegeClass].saberStance ||
+		 bgSiegeClasses[ent->client->siegeClass].saber1[0] ||
+		 bgSiegeClasses[ent->client->siegeClass].saber2[0]
+		))
+	{ //don't let it be changed if the siege class has forced any saber-related things
+        return qfalse;
+	}
+
+	while (saberName[i] && i < 64-1)
+	{
+        truncSaberName[i] = saberName[i];
+		i++;
+	}
+	truncSaberName[i] = 0;
+
+	if ( saberNum == 0 && (Q_stricmp( "none", truncSaberName ) == 0 || Q_stricmp( "remove", truncSaberName ) == 0) )
+	{ //can't remove saber 0 like this
+        strcpy(truncSaberName, "Kyle");
+	}
+
+	//Set the saber with the arg given. If the arg is
+	//not a valid sabername defaults will be used.
+	WP_SetSaber(ent->s.number, ent->client->saber, saberNum, truncSaberName);
+
+	if (!ent->client->saber[0].model[0])
+	{
+		assert(0); //should never happen!
+		strcpy(ent->client->sess.saberType, "none");
+	}
+	else
+	{
+		strcpy(ent->client->sess.saberType, ent->client->saber[0].name);
+	}
+
+	if (!ent->client->saber[1].model[0])
+	{
+		strcpy(ent->client->sess.saber2Type, "none");
+	}
+	else
+	{
+		strcpy(ent->client->sess.saber2Type, ent->client->saber[1].name);
+	}
+
+	return qtrue;
+}
+
+/*
+=================
+Cmd_Follow_f
+=================
+*/
+void Cmd_Follow_f( gentity_t *ent ) {
+	int		i;
+	char	arg[MAX_TOKEN_CHARS];
+
+	if ( trap_Argc() != 2 ) {
+		if ( ent->client->sess.spectatorState == SPECTATOR_FOLLOW ) {
+			StopFollowing( ent );
+		}
+		return;
+	}
+
+	trap_Argv( 1, arg, sizeof( arg ) );
+	i = ClientNumberFromString( ent, arg );
+	if ( i == -1 ) {
+		return;
+	}
+
+	// can't follow self
+	if ( &level.clients[ i ] == ent->client ) {
+		return;
+	}
+
+	// can't follow another spectator
+	if ( level.clients[ i ].sess.sessionTeam == TEAM_SPECTATOR ) {
+		return;
+	}
+
+	// if they are playing a tournement game, count as a loss
+	if ( (g_gametype.integer == GT_DUEL || g_gametype.integer == GT_POWERDUEL)
+		&& ent->client->sess.sessionTeam == TEAM_FREE ) {
+		//WTF???
+		ent->client->sess.losses++;
+	}
+
+	// first set them to spectator
+	if ( ent->client->sess.sessionTeam != TEAM_SPECTATOR ) {
+		SetTeam( ent, "spectator" );
+	}
+
+	ent->client->sess.spectatorState = SPECTATOR_FOLLOW;
+	ent->client->sess.spectatorClient = i;
+}
+
+/*
+=================
+Cmd_FollowCycle_f
+=================
+*/
+void Cmd_FollowCycle_f( gentity_t *ent, int dir ) {
+	int		clientnum;
+	int		original;
+
+	// if they are playing a tournement game, count as a loss
+	if ( (g_gametype.integer == GT_DUEL || g_gametype.integer == GT_POWERDUEL)
+		&& ent->client->sess.sessionTeam == TEAM_FREE ) {\
+		//WTF???
+		ent->client->sess.losses++;
+	}
+	// first set them to spectator
+	if ( ent->client->sess.spectatorState == SPECTATOR_NOT ) {
+		SetTeam( ent, "spectator" );
+	}
+
+	if ( dir != 1 && dir != -1 ) {
+		G_Error( "Cmd_FollowCycle_f: bad dir %i", dir );
+	}
+
+	clientnum = ent->client->sess.spectatorClient;
+	original = clientnum;
+	do {
+		clientnum += dir;
+		if ( clientnum >= level.maxclients ) {
+			clientnum = 0;
+		}
+		if ( clientnum < 0 ) {
+			clientnum = level.maxclients - 1;
+		}
+
+		// can only follow connected clients
+		if ( level.clients[ clientnum ].pers.connected != CON_CONNECTED ) {
+			continue;
+		}
+
+		// can't follow another spectator
+		if ( level.clients[ clientnum ].sess.sessionTeam == TEAM_SPECTATOR ) {
+			continue;
+		}
+
+		// this is good, we can use it
+		ent->client->sess.spectatorClient = clientnum;
+		ent->client->sess.spectatorState = SPECTATOR_FOLLOW;
+		return;
+	} while ( clientnum != original );
+
+	// leave it where it was
+}
+
+
+/*
+==================
+G_Say
+==================
+*/
+
+static void G_SayTo( gentity_t *ent, gentity_t *other, int mode, int color, const char *name, const char *message, char *locMsg )
+{
+	if (!other) {
+		return;
+	}
+	if (!other->inuse) {
+		return;
+	}
+	if (!other->client) {
+		return;
+	}
+	if ( other->client->pers.connected != CON_CONNECTED ) {
+		return;
+	}
+	if ( mode == SAY_TEAM  && !OnSameTeam(ent, other) ) {
+		return;
+	}
+	/*
+	// no chatting to players in tournements
+	if ( (g_gametype.integer == GT_DUEL || g_gametype.integer == GT_POWERDUEL)
+		&& other->client->sess.sessionTeam == TEAM_FREE
+		&& ent->client->sess.sessionTeam != TEAM_FREE ) {
+		//Hmm, maybe some option to do so if allowed?  Or at least in developer mode...
+		return;
+	}
+	*/
+	//They've requested I take this out.
+
+	if (g_gametype.integer == GT_SIEGE &&
+		ent->client && (ent->client->tempSpectate >= level.time || ent->client->sess.sessionTeam == TEAM_SPECTATOR) &&
+		other->client->sess.sessionTeam != TEAM_SPECTATOR &&
+		other->client->tempSpectate < level.time)
+	{ //siege temp spectators should not communicate to ingame players
+		return;
+	}
+
+	if (locMsg)
+	{
+		trap_SendServerCommand( other-g_entities, va("%s \"%s\" \"%s\" \"%c\" \"%s\"", 
+			mode == SAY_TEAM ? "ltchat" : "lchat",
+			name, locMsg, color, message));
+	}
+	else
+	{
+		trap_SendServerCommand( other-g_entities, va("%s \"%s%c%c%s\"", 
+			mode == SAY_TEAM ? "tchat" : "chat",
+			name, Q_COLOR_ESCAPE, color, message));
+	}
+}
+
+#define EC		"\x19"
+
+void G_Say( gentity_t *ent, gentity_t *target, int mode, const char *chatText ) {
+	int			j;
+	gentity_t	*other;
+	int			color;
+	char		name[64];
+	// don't let text be too long for malicious reasons
+	char		text[MAX_SAY_TEXT];
+	char		location[64];
+	char		*locMsg = NULL;
+
+	if ( g_gametype.integer < GT_TEAM && mode == SAY_TEAM ) {
+		mode = SAY_ALL;
+	}
+
+	switch ( mode ) {
+	default:
+	case SAY_ALL:
+		G_LogPrintf( "say: %s: %s\n", ent->client->pers.netname, chatText );
+		Com_sprintf (name, sizeof(name), "%s%c%c"EC": ", ent->client->pers.netname, Q_COLOR_ESCAPE, COLOR_WHITE );
+		color = COLOR_GREEN;
+		break;
+	case SAY_TEAM:
+		G_LogPrintf( "sayteam: %s: %s\n", ent->client->pers.netname, chatText );
+		if (Team_GetLocationMsg(ent, location, sizeof(location)))
+		{
+			Com_sprintf (name, sizeof(name), EC"(%s%c%c"EC")"EC": ", 
+				ent->client->pers.netname, Q_COLOR_ESCAPE, COLOR_WHITE );
+			locMsg = location;
+		}
+		else
+		{
+			Com_sprintf (name, sizeof(name), EC"(%s%c%c"EC")"EC": ", 
+				ent->client->pers.netname, Q_COLOR_ESCAPE, COLOR_WHITE );
+		}
+		color = COLOR_CYAN;
+		break;
+	case SAY_TELL:
+		if (target && g_gametype.integer >= GT_TEAM &&
+			target->client->sess.sessionTeam == ent->client->sess.sessionTeam &&
+			Team_GetLocationMsg(ent, location, sizeof(location)))
+		{
+			Com_sprintf (name, sizeof(name), EC"[%s%c%c"EC"]"EC": ", ent->client->pers.netname, Q_COLOR_ESCAPE, COLOR_WHITE );
+			locMsg = location;
+		}
+		else
+		{
+			Com_sprintf (name, sizeof(name), EC"[%s%c%c"EC"]"EC": ", ent->client->pers.netname, Q_COLOR_ESCAPE, COLOR_WHITE );
+		}
+		color = COLOR_MAGENTA;
+		break;
+	}
+
+	Q_strncpyz( text, chatText, sizeof(text) );
+
+	if ( target ) {
+		G_SayTo( ent, target, mode, color, name, text, locMsg );
+		return;
+	}
+
+	// echo the text to the console
+	if ( g_dedicated.integer ) {
+		G_Printf( "%s%s\n", name, text);
+	}
+
+	// send it to all the apropriate clients
+	for (j = 0; j < level.maxclients; j++) {
+		other = &g_entities[j];
+		G_SayTo( ent, other, mode, color, name, text, locMsg );
+	}
+}
+
+
+/*
+==================
+Cmd_Say_f
+==================
+*/
+static void Cmd_Say_f( gentity_t *ent, int mode, qboolean arg0 ) {
+	char		*p;
+
+	if ( trap_Argc () < 2 && !arg0 ) {
+		return;
+	}
+
+	if (arg0)
+	{
+		p = ConcatArgs( 0 );
+	}
+	else
+	{
+		p = ConcatArgs( 1 );
+	}
+
+	G_Say( ent, NULL, mode, p );
+}
+
+/*
+==================
+Cmd_Tell_f
+==================
+*/
+static void Cmd_Tell_f( gentity_t *ent ) {
+	int			targetNum;
+	gentity_t	*target;
+	char		*p;
+	char		arg[MAX_TOKEN_CHARS];
+
+	if ( trap_Argc () < 2 ) {
+		return;
+	}
+
+	trap_Argv( 1, arg, sizeof( arg ) );
+	targetNum = atoi( arg );
+	if ( targetNum < 0 || targetNum >= level.maxclients ) {
+		return;
+	}
+
+	target = &g_entities[targetNum];
+	if ( !target || !target->inuse || !target->client ) {
+		return;
+	}
+
+	p = ConcatArgs( 2 );
+
+	G_LogPrintf( "tell: %s to %s: %s\n", ent->client->pers.netname, target->client->pers.netname, p );
+	G_Say( ent, target, SAY_TELL, p );
+	// don't tell to the player self if it was already directed to this player
+	// also don't send the chat back to a bot
+	if ( ent != target && !(ent->r.svFlags & SVF_BOT)) {
+		G_Say( ent, ent, SAY_TELL, p );
+	}
+}
+
+//siege voice command
+static void Cmd_VoiceCommand_f(gentity_t *ent)
+{
+	gentity_t *te;
+	char arg[MAX_TOKEN_CHARS];
+	char *s;
+	int i = 0;
+
+	if (g_gametype.integer < GT_TEAM)
+	{
+		return;
+	}
+
+	if (trap_Argc() < 2)
+	{
+		return;
+	}
+
+	if (ent->client->sess.sessionTeam == TEAM_SPECTATOR ||
+		ent->client->tempSpectate >= level.time)
+	{
+		trap_SendServerCommand( ent-g_entities, va("print \"%s\n\"", G_GetStringEdString("MP_SVGAME", "NOVOICECHATASSPEC")) );
+		return;
+	}
+
+	trap_Argv(1, arg, sizeof(arg));
+
+	if (arg[0] == '*')
+	{ //hmm.. don't expect a * to be prepended already. maybe someone is trying to be sneaky.
+		return;
+	}
+
+	s = va("*%s", arg);
+
+	//now, make sure it's a valid sound to be playing like this.. so people can't go around
+	//screaming out death sounds or whatever.
+	while (i < MAX_CUSTOM_SIEGE_SOUNDS)
+	{
+		if (!bg_customSiegeSoundNames[i])
+		{
+			break;
+		}
+		if (!Q_stricmp(bg_customSiegeSoundNames[i], s))
+		{ //it matches this one, so it's ok
+			break;
+		}
+		i++;
+	}
+
+	if (i == MAX_CUSTOM_SIEGE_SOUNDS || !bg_customSiegeSoundNames[i])
+	{ //didn't find it in the list
+		return;
+	}
+
+	te = G_TempEntity(vec3_origin, EV_VOICECMD_SOUND);
+	te->s.groundEntityNum = ent->s.number;
+	te->s.eventParm = G_SoundIndex((char *)bg_customSiegeSoundNames[i]);
+	te->r.svFlags |= SVF_BROADCAST;
+}
+
+
+static char	*gc_orders[] = {
+	"hold your position",
+	"hold this position",
+	"come here",
+	"cover me",
+	"guard location",
+	"search and destroy",
+	"report"
+};
+
+void Cmd_GameCommand_f( gentity_t *ent ) {
+	int		player;
+	int		order;
+	char	str[MAX_TOKEN_CHARS];
+
+	trap_Argv( 1, str, sizeof( str ) );
+	player = atoi( str );
+	trap_Argv( 2, str, sizeof( str ) );
+	order = atoi( str );
+
+	if ( player < 0 || player >= MAX_CLIENTS ) {
+		return;
+	}
+	if ( order < 0 || order > sizeof(gc_orders)/sizeof(char *) ) {
+		return;
+	}
+	G_Say( ent, &g_entities[player], SAY_TELL, gc_orders[order] );
+	G_Say( ent, ent, SAY_TELL, gc_orders[order] );
+}
+
+/*
+==================
+Cmd_Where_f
+==================
+*/
+void Cmd_Where_f( gentity_t *ent ) {
+	trap_SendServerCommand( ent-g_entities, va("print \"%s\n\"", vtos( ent->s.origin ) ) );
+}
+
+static const char *gameNames[] = {
+	"Free For All",
+	"Holocron FFA",
+	"Jedi Master",
+	"Duel",
+	"Power Duel",
+	"Single Player",
+	"Team FFA",
+	"Siege",
+	"Capture the Flag",
+	"Capture the Ysalamiri"
+};
+
+/*
+==================
+G_ClientNumberFromName
+
+Finds the client number of the client with the given name
+==================
+*/
+int G_ClientNumberFromName ( const char* name )
+{
+	char		s2[MAX_STRING_CHARS];
+	char		n2[MAX_STRING_CHARS];
+	int			i;
+	gclient_t*	cl;
+
+	// check for a name match
+	SanitizeString( (char*)name, s2 );
+	for ( i=0, cl=level.clients ; i < level.numConnectedClients ; i++, cl++ ) 
+	{
+		SanitizeString( cl->pers.netname, n2 );
+		if ( !strcmp( n2, s2 ) ) 
+		{
+			return i;
+		}
+	}
+
+	return -1;
+}
+
+/*
+==================
+SanitizeString2
+
+Rich's revised version of SanitizeString
+==================
+*/
+void SanitizeString2( char *in, char *out )
+{
+	int i = 0;
+	int r = 0;
+
+	while (in[i])
+	{
+		if (i >= MAX_NAME_LENGTH-1)
+		{ //the ui truncates the name here..
+			break;
+		}
+
+		if (in[i] == '^')
+		{
+			if (in[i+1] >= 48 && //'0'
+				in[i+1] <= 57) //'9'
+			{ //only skip it if there's a number after it for the color
+				i += 2;
+				continue;
+			}
+			else
+			{ //just skip the ^
+				i++;
+				continue;
+			}
+		}
+
+		if (in[i] < 32)
+		{
+			i++;
+			continue;
+		}
+
+		out[r] = in[i];
+		r++;
+		i++;
+	}
+	out[r] = 0;
+}
+
+/*
+==================
+G_ClientNumberFromStrippedName
+
+Same as above, but strips special characters out of the names before comparing.
+==================
+*/
+int G_ClientNumberFromStrippedName ( const char* name )
+{
+	char		s2[MAX_STRING_CHARS];
+	char		n2[MAX_STRING_CHARS];
+	int			i;
+	gclient_t*	cl;
+
+	// check for a name match
+	SanitizeString2( (char*)name, s2 );
+	for ( i=0, cl=level.clients ; i < level.numConnectedClients ; i++, cl++ ) 
+	{
+		SanitizeString2( cl->pers.netname, n2 );
+		if ( !strcmp( n2, s2 ) ) 
+		{
+			return i;
+		}
+	}
+
+	return -1;
+}
+
+/*
+==================
+Cmd_CallVote_f
+==================
+*/
+extern void SiegeClearSwitchData(void); //g_saga.c
+const char *G_GetArenaInfoByMap( const char *map );
+void Cmd_CallVote_f( gentity_t *ent ) {
+	int		i;
+	char	arg1[MAX_STRING_TOKENS];
+	char	arg2[MAX_STRING_TOKENS];
+//	int		n = 0;
+//	char*	type = NULL;
+	char*		mapName = 0;
+	const char*	arenaInfo;
+
+	if ( !g_allowVote.integer ) {
+		trap_SendServerCommand( ent-g_entities, va("print \"%s\n\"", G_GetStringEdString("MP_SVGAME", "NOVOTE")) );
+		return;
+	}
+
+	if ( level.voteTime || level.voteExecuteTime >= level.time ) {
+		trap_SendServerCommand( ent-g_entities, va("print \"%s\n\"", G_GetStringEdString("MP_SVGAME", "VOTEINPROGRESS")) );
+		return;
+	}
+	if ( ent->client->pers.voteCount >= MAX_VOTE_COUNT ) {
+		trap_SendServerCommand( ent-g_entities, va("print \"%s\n\"", G_GetStringEdString("MP_SVGAME", "MAXVOTES")) );
+		return;
+	}
+
+	if (g_gametype.integer != GT_DUEL &&
+		g_gametype.integer != GT_POWERDUEL)
+	{
+		if ( ent->client->sess.sessionTeam == TEAM_SPECTATOR ) {
+			trap_SendServerCommand( ent-g_entities, va("print \"%s\n\"", G_GetStringEdString("MP_SVGAME", "NOSPECVOTE")) );
+			return;
+		}
+	}
+
+	// make sure it is a valid command to vote on
+	trap_Argv( 1, arg1, sizeof( arg1 ) );
+	trap_Argv( 2, arg2, sizeof( arg2 ) );
+
+	if( strchr( arg1, ';' ) || strchr( arg2, ';' ) ) {
+		trap_SendServerCommand( ent-g_entities, "print \"Invalid vote string.\n\"" );
+		return;
+	}
+
+	if ( !Q_stricmp( arg1, "map_restart" ) ) {
+	} else if ( !Q_stricmp( arg1, "nextmap" ) ) {
+	} else if ( !Q_stricmp( arg1, "map" ) ) {
+	} else if ( !Q_stricmp( arg1, "g_gametype" ) ) {
+	} else if ( !Q_stricmp( arg1, "kick" ) ) {
+	} else if ( !Q_stricmp( arg1, "clientkick" ) ) {
+	} else if ( !Q_stricmp( arg1, "g_doWarmup" ) ) {
+	} else if ( !Q_stricmp( arg1, "timelimit" ) ) {
+	} else if ( !Q_stricmp( arg1, "fraglimit" ) ) {
+	} else {
+		trap_SendServerCommand( ent-g_entities, "print \"Invalid vote string.\n\"" );
+		trap_SendServerCommand( ent-g_entities, "print \"Vote commands are: map_restart, nextmap, map <mapname>, g_gametype <n>, kick <player>, clientkick <clientnum>, g_doWarmup, timelimit <time>, fraglimit <frags>.\n\"" );
+		return;
+	}
+
+	// if there is still a vote to be executed
+	if ( level.voteExecuteTime ) {
+		level.voteExecuteTime = 0;
+		trap_SendConsoleCommand( EXEC_APPEND, va("%s\n", level.voteString ) );
+	}
+
+	// special case for g_gametype, check for bad values
+	if ( !Q_stricmp( arg1, "g_gametype" ) )
+	{
+		i = atoi( arg2 );
+		if( i == GT_SINGLE_PLAYER || i < GT_FFA || i >= GT_MAX_GAME_TYPE) {
+			trap_SendServerCommand( ent-g_entities, "print \"Invalid gametype.\n\"" );
+			return;
+		}
+
+		level.votingGametype = qtrue;
+		level.votingGametypeTo = i;
+
+		Com_sprintf( level.voteString, sizeof( level.voteString ), "%s %d", arg1, i );
+		Com_sprintf( level.voteDisplayString, sizeof( level.voteDisplayString ), "%s %s", arg1, gameNames[i] );
+	}
+	else if ( !Q_stricmp( arg1, "map" ) ) 
+	{
+		// special case for map changes, we want to reset the nextmap setting
+		// this allows a player to change maps, but not upset the map rotation
+		char	s[MAX_STRING_CHARS];
+
+		if (!G_DoesMapSupportGametype(arg2, trap_Cvar_VariableIntegerValue("g_gametype")))
+		{
+			//trap_SendServerCommand( ent-g_entities, "print \"You can't vote for this map, it isn't supported by the current gametype.\n\"" );
+			trap_SendServerCommand( ent-g_entities, va("print \"%s\n\"", G_GetStringEdString("MP_SVGAME", "NOVOTE_MAPNOTSUPPORTEDBYGAME")) );
+			return;
+		}
+
+		trap_Cvar_VariableStringBuffer( "nextmap", s, sizeof(s) );
+		if (*s) {
+			Com_sprintf( level.voteString, sizeof( level.voteString ), "%s %s; set nextmap \"%s\"", arg1, arg2, s );
+		} else {
+			Com_sprintf( level.voteString, sizeof( level.voteString ), "%s %s", arg1, arg2 );
+		}
+		
+		arenaInfo	= G_GetArenaInfoByMap(arg2);
+		if (arenaInfo)
+		{
+			mapName = Info_ValueForKey(arenaInfo, "longname");
+		}
+
+		if (!mapName || !mapName[0])
+		{
+			mapName = "ERROR";
+		}
+
+		Com_sprintf( level.voteDisplayString, sizeof( level.voteDisplayString ), "map %s", mapName);
+	}
+	else if ( !Q_stricmp ( arg1, "clientkick" ) )
+	{
+		int n = atoi ( arg2 );
+
+		if ( n < 0 || n >= MAX_CLIENTS )
+		{
+			trap_SendServerCommand( ent-g_entities, va("print \"invalid client number %d.\n\"", n ) );
+			return;
+		}
+
+		if ( g_entities[n].client->pers.connected == CON_DISCONNECTED )
+		{
+			trap_SendServerCommand( ent-g_entities, va("print \"there is no client with the client number %d.\n\"", n ) );
+			return;
+		}
+			
+		Com_sprintf ( level.voteString, sizeof(level.voteString ), "%s %s", arg1, arg2 );
+		Com_sprintf ( level.voteDisplayString, sizeof(level.voteDisplayString), "kick %s", g_entities[n].client->pers.netname );
+	}
+	else if ( !Q_stricmp ( arg1, "kick" ) )
+	{
+		int clientid = G_ClientNumberFromName ( arg2 );
+
+		if ( clientid == -1 )
+		{
+			clientid = G_ClientNumberFromStrippedName(arg2);
+
+			if (clientid == -1)
+			{
+				trap_SendServerCommand( ent-g_entities, va("print \"there is no client named '%s' currently on the server.\n\"", arg2 ) );
+				return;
+			}
+		}
+
+		Com_sprintf ( level.voteString, sizeof(level.voteString ), "clientkick %d", clientid );
+		Com_sprintf ( level.voteDisplayString, sizeof(level.voteDisplayString), "kick %s", g_entities[clientid].client->pers.netname );
+	}
+	else if ( !Q_stricmp( arg1, "nextmap" ) ) 
+	{
+		char	s[MAX_STRING_CHARS];
+
+		trap_Cvar_VariableStringBuffer( "nextmap", s, sizeof(s) );
+		if (!*s) {
+			trap_SendServerCommand( ent-g_entities, "print \"nextmap not set.\n\"" );
+			return;
+		}
+		SiegeClearSwitchData();
+		Com_sprintf( level.voteString, sizeof( level.voteString ), "vstr nextmap");
+		Com_sprintf( level.voteDisplayString, sizeof( level.voteDisplayString ), "%s", level.voteString );
+	} 
+	else
+	{
+		Com_sprintf( level.voteString, sizeof( level.voteString ), "%s \"%s\"", arg1, arg2 );
+		Com_sprintf( level.voteDisplayString, sizeof( level.voteDisplayString ), "%s", level.voteString );
+	}
+
+	trap_SendServerCommand( -1, va("print \"%s^7 %s\n\"", ent->client->pers.netname, G_GetStringEdString("MP_SVGAME", "PLCALLEDVOTE") ) );
+
+	// start the voting, the caller autoamtically votes yes
+	level.voteTime = level.time;
+	level.voteYes = 1;
+	level.voteNo = 0;
+
+	for ( i = 0 ; i < level.maxclients ; i++ ) {
+		level.clients[i].mGameFlags &= ~PSG_VOTED;
+	}
+	ent->client->mGameFlags |= PSG_VOTED;
+
+	trap_SetConfigstring( CS_VOTE_TIME, va("%i", level.voteTime ) );
+	trap_SetConfigstring( CS_VOTE_STRING, level.voteDisplayString );	
+	trap_SetConfigstring( CS_VOTE_YES, va("%i", level.voteYes ) );
+	trap_SetConfigstring( CS_VOTE_NO, va("%i", level.voteNo ) );	
+}
+
+/*
+==================
+Cmd_Vote_f
+==================
+*/
+void Cmd_Vote_f( gentity_t *ent ) {
+	char		msg[64];
+
+	if ( !level.voteTime ) {
+		trap_SendServerCommand( ent-g_entities, va("print \"%s\n\"", G_GetStringEdString("MP_SVGAME", "NOVOTEINPROG")) );
+		return;
+	}
+	if ( ent->client->mGameFlags & PSG_VOTED ) {
+		trap_SendServerCommand( ent-g_entities, va("print \"%s\n\"", G_GetStringEdString("MP_SVGAME", "VOTEALREADY")) );
+		return;
+	}
+	if (g_gametype.integer != GT_DUEL &&
+		g_gametype.integer != GT_POWERDUEL)
+	{
+		if ( ent->client->sess.sessionTeam == TEAM_SPECTATOR ) {
+			trap_SendServerCommand( ent-g_entities, va("print \"%s\n\"", G_GetStringEdString("MP_SVGAME", "NOVOTEASSPEC")) );
+			return;
+		}
+	}
+
+	trap_SendServerCommand( ent-g_entities, va("print \"%s\n\"", G_GetStringEdString("MP_SVGAME", "PLVOTECAST")) );
+
+	ent->client->mGameFlags |= PSG_VOTED;
+
+	trap_Argv( 1, msg, sizeof( msg ) );
+
+	if ( msg[0] == 'y' || msg[1] == 'Y' || msg[1] == '1' ) {
+		level.voteYes++;
+		trap_SetConfigstring( CS_VOTE_YES, va("%i", level.voteYes ) );
+	} else {
+		level.voteNo++;
+		trap_SetConfigstring( CS_VOTE_NO, va("%i", level.voteNo ) );	
+	}
+
+	// a majority will be determined in CheckVote, which will also account
+	// for players entering or leaving
+}
+
+/*
+==================
+Cmd_CallTeamVote_f
+==================
+*/
+void Cmd_CallTeamVote_f( gentity_t *ent ) {
+	int		i, team, cs_offset;
+	char	arg1[MAX_STRING_TOKENS];
+	char	arg2[MAX_STRING_TOKENS];
+
+	team = ent->client->sess.sessionTeam;
+	if ( team == TEAM_RED )
+		cs_offset = 0;
+	else if ( team == TEAM_BLUE )
+		cs_offset = 1;
+	else
+		return;
+
+	if ( !g_allowVote.integer ) {
+		trap_SendServerCommand( ent-g_entities, va("print \"%s\n\"", G_GetStringEdString("MP_SVGAME", "NOVOTE")) );
+		return;
+	}
+
+	if ( level.teamVoteTime[cs_offset] ) {
+		trap_SendServerCommand( ent-g_entities, va("print \"%s\n\"", G_GetStringEdString("MP_SVGAME", "TEAMVOTEALREADY")) );
+		return;
+	}
+	if ( ent->client->pers.teamVoteCount >= MAX_VOTE_COUNT ) {
+		trap_SendServerCommand( ent-g_entities, va("print \"%s\n\"", G_GetStringEdString("MP_SVGAME", "MAXTEAMVOTES")) );
+		return;
+	}
+	if ( ent->client->sess.sessionTeam == TEAM_SPECTATOR ) {
+		trap_SendServerCommand( ent-g_entities, va("print \"%s\n\"", G_GetStringEdString("MP_SVGAME", "NOSPECVOTE")) );
+		return;
+	}
+
+	// make sure it is a valid command to vote on
+	trap_Argv( 1, arg1, sizeof( arg1 ) );
+	arg2[0] = '\0';
+	for ( i = 2; i < trap_Argc(); i++ ) {
+		if (i > 2)
+			strcat(arg2, " ");
+		trap_Argv( i, &arg2[strlen(arg2)], sizeof( arg2 ) - strlen(arg2) );
+	}
+
+	if( strchr( arg1, ';' ) || strchr( arg2, ';' ) ) {
+		trap_SendServerCommand( ent-g_entities, "print \"Invalid vote string.\n\"" );
+		return;
+	}
+
+	if ( !Q_stricmp( arg1, "leader" ) ) {
+		char netname[MAX_NETNAME], leader[MAX_NETNAME];
+
+		if ( !arg2[0] ) {
+			i = ent->client->ps.clientNum;
+		}
+		else {
+			// numeric values are just slot numbers
+			for (i = 0; i < 3; i++) {
+				if ( !arg2[i] || arg2[i] < '0' || arg2[i] > '9' )
+					break;
+			}
+			if ( i >= 3 || !arg2[i]) {
+				i = atoi( arg2 );
+				if ( i < 0 || i >= level.maxclients ) {
+					trap_SendServerCommand( ent-g_entities, va("print \"Bad client slot: %i\n\"", i) );
+					return;
+				}
+
+				if ( !g_entities[i].inuse ) {
+					trap_SendServerCommand( ent-g_entities, va("print \"Client %i is not active\n\"", i) );
+					return;
+				}
+			}
+			else {
+				Q_strncpyz(leader, arg2, sizeof(leader));
+				Q_CleanStr(leader);
+				for ( i = 0 ; i < level.maxclients ; i++ ) {
+					if ( level.clients[i].pers.connected == CON_DISCONNECTED )
+						continue;
+					if (level.clients[i].sess.sessionTeam != team)
+						continue;
+					Q_strncpyz(netname, level.clients[i].pers.netname, sizeof(netname));
+					Q_CleanStr(netname);
+					if ( !Q_stricmp(netname, leader) ) {
+						break;
+					}
+				}
+				if ( i >= level.maxclients ) {
+					trap_SendServerCommand( ent-g_entities, va("print \"%s is not a valid player on your team.\n\"", arg2) );
+					return;
+				}
+			}
+		}
+		Com_sprintf(arg2, sizeof(arg2), "%d", i);
+	} else {
+		trap_SendServerCommand( ent-g_entities, "print \"Invalid vote string.\n\"" );
+		trap_SendServerCommand( ent-g_entities, "print \"Team vote commands are: leader <player>.\n\"" );
+		return;
+	}
+
+	Com_sprintf( level.teamVoteString[cs_offset], sizeof( level.teamVoteString[cs_offset] ), "%s %s", arg1, arg2 );
+
+	for ( i = 0 ; i < level.maxclients ; i++ ) {
+		if ( level.clients[i].pers.connected == CON_DISCONNECTED )
+			continue;
+		if (level.clients[i].sess.sessionTeam == team)
+			trap_SendServerCommand( i, va("print \"%s called a team vote.\n\"", ent->client->pers.netname ) );
+	}
+
+	// start the voting, the caller autoamtically votes yes
+	level.teamVoteTime[cs_offset] = level.time;
+	level.teamVoteYes[cs_offset] = 1;
+	level.teamVoteNo[cs_offset] = 0;
+
+	for ( i = 0 ; i < level.maxclients ; i++ ) {
+		if (level.clients[i].sess.sessionTeam == team)
+			level.clients[i].mGameFlags &= ~PSG_TEAMVOTED;
+	}
+	ent->client->mGameFlags |= PSG_TEAMVOTED;
+
+	trap_SetConfigstring( CS_TEAMVOTE_TIME + cs_offset, va("%i", level.teamVoteTime[cs_offset] ) );
+	trap_SetConfigstring( CS_TEAMVOTE_STRING + cs_offset, level.teamVoteString[cs_offset] );
+	trap_SetConfigstring( CS_TEAMVOTE_YES + cs_offset, va("%i", level.teamVoteYes[cs_offset] ) );
+	trap_SetConfigstring( CS_TEAMVOTE_NO + cs_offset, va("%i", level.teamVoteNo[cs_offset] ) );
+}
+
+/*
+==================
+Cmd_TeamVote_f
+==================
+*/
+void Cmd_TeamVote_f( gentity_t *ent ) {
+	int			team, cs_offset;
+	char		msg[64];
+
+	team = ent->client->sess.sessionTeam;
+	if ( team == TEAM_RED )
+		cs_offset = 0;
+	else if ( team == TEAM_BLUE )
+		cs_offset = 1;
+	else
+		return;
+
+	if ( !level.teamVoteTime[cs_offset] ) {
+		trap_SendServerCommand( ent-g_entities, va("print \"%s\n\"", G_GetStringEdString("MP_SVGAME", "NOTEAMVOTEINPROG")) );
+		return;
+	}
+	if ( ent->client->mGameFlags & PSG_TEAMVOTED ) {
+		trap_SendServerCommand( ent-g_entities, va("print \"%s\n\"", G_GetStringEdString("MP_SVGAME", "TEAMVOTEALREADYCAST")) );
+		return;
+	}
+	if ( ent->client->sess.sessionTeam == TEAM_SPECTATOR ) {
+		trap_SendServerCommand( ent-g_entities, va("print \"%s\n\"", G_GetStringEdString("MP_SVGAME", "NOVOTEASSPEC")) );
+		return;
+	}
+
+	trap_SendServerCommand( ent-g_entities, va("print \"%s\n\"", G_GetStringEdString("MP_SVGAME", "PLTEAMVOTECAST")) );
+
+	ent->client->mGameFlags |= PSG_TEAMVOTED;
+
+	trap_Argv( 1, msg, sizeof( msg ) );
+
+	if ( msg[0] == 'y' || msg[1] == 'Y' || msg[1] == '1' ) {
+		level.teamVoteYes[cs_offset]++;
+		trap_SetConfigstring( CS_TEAMVOTE_YES + cs_offset, va("%i", level.teamVoteYes[cs_offset] ) );
+	} else {
+		level.teamVoteNo[cs_offset]++;
+		trap_SetConfigstring( CS_TEAMVOTE_NO + cs_offset, va("%i", level.teamVoteNo[cs_offset] ) );	
+	}
+
+	// a majority will be determined in TeamCheckVote, which will also account
+	// for players entering or leaving
+}
+
+
+/*
+=================
+Cmd_SetViewpos_f
+=================
+*/
+void Cmd_SetViewpos_f( gentity_t *ent ) {
+	vec3_t		origin, angles;
+	char		buffer[MAX_TOKEN_CHARS];
+	int			i;
+
+	if ( !g_cheats.integer ) {
+		trap_SendServerCommand( ent-g_entities, va("print \"%s\n\"", G_GetStringEdString("MP_SVGAME", "NOCHEATS")));
+		return;
+	}
+	if ( trap_Argc() != 5 ) {
+		trap_SendServerCommand( ent-g_entities, va("print \"usage: setviewpos x y z yaw\n\""));
+		return;
+	}
+
+	VectorClear( angles );
+	for ( i = 0 ; i < 3 ; i++ ) {
+		trap_Argv( i + 1, buffer, sizeof( buffer ) );
+		origin[i] = atof( buffer );
+	}
+
+	trap_Argv( 4, buffer, sizeof( buffer ) );
+	angles[YAW] = atof( buffer );
+
+	TeleportPlayer( ent, origin, angles );
+}
+
+
+
+/*
+=================
+Cmd_Stats_f
+=================
+*/
+void Cmd_Stats_f( gentity_t *ent ) {
+/*
+	int max, n, i;
+
+	max = trap_AAS_PointReachabilityAreaIndex( NULL );
+
+	n = 0;
+	for ( i = 0; i < max; i++ ) {
+		if ( ent->client->areabits[i >> 3] & (1 << (i & 7)) )
+			n++;
+	}
+
+	//trap_SendServerCommand( ent-g_entities, va("print \"visited %d of %d areas\n\"", n, max));
+	trap_SendServerCommand( ent-g_entities, va("print \"%d%% level coverage\n\"", n * 100 / max));
+*/
+}
+
+int G_ItemUsable(playerState_t *ps, int forcedUse)
+{
+	vec3_t fwd, fwdorg, dest, pos;
+	vec3_t yawonly;
+	vec3_t mins, maxs;
+	vec3_t trtest;
+	trace_t tr;
+
+	if (ps->m_iVehicleNum)
+	{
+		return 0;
+	}
+	
+	if (ps->pm_flags & PMF_USE_ITEM_HELD)
+	{ //force to let go first
+		return 0;
+	}
+
+	if (!forcedUse)
+	{
+		forcedUse = bg_itemlist[ps->stats[STAT_HOLDABLE_ITEM]].giTag;
+	}
+
+	if (!BG_IsItemSelectable(ps, forcedUse))
+	{
+		return 0;
+	}
+
+	switch (forcedUse)
+	{
+	case HI_MEDPAC:
+	case HI_MEDPAC_BIG:
+		if (ps->stats[STAT_HEALTH] >= ps->stats[STAT_MAX_HEALTH])
+		{
+			return 0;
+		}
+
+		if (ps->stats[STAT_HEALTH] <= 0)
+		{
+			return 0;
+		}
+
+		return 1;
+	case HI_SEEKER:
+		if (ps->eFlags & EF_SEEKERDRONE)
+		{
+			G_AddEvent(&g_entities[ps->clientNum], EV_ITEMUSEFAIL, SEEKER_ALREADYDEPLOYED);
+			return 0;
+		}
+
+		return 1;
+	case HI_SENTRY_GUN:
+		if (ps->fd.sentryDeployed)
+		{
+			G_AddEvent(&g_entities[ps->clientNum], EV_ITEMUSEFAIL, SENTRY_ALREADYPLACED);
+			return 0;
+		}
+
+		yawonly[ROLL] = 0;
+		yawonly[PITCH] = 0;
+		yawonly[YAW] = ps->viewangles[YAW];
+
+		VectorSet( mins, -8, -8, 0 );
+		VectorSet( maxs, 8, 8, 24 );
+
+		AngleVectors(yawonly, fwd, NULL, NULL);
+
+		fwdorg[0] = ps->origin[0] + fwd[0]*64;
+		fwdorg[1] = ps->origin[1] + fwd[1]*64;
+		fwdorg[2] = ps->origin[2] + fwd[2]*64;
+
+		trtest[0] = fwdorg[0] + fwd[0]*16;
+		trtest[1] = fwdorg[1] + fwd[1]*16;
+		trtest[2] = fwdorg[2] + fwd[2]*16;
+
+		trap_Trace(&tr, ps->origin, mins, maxs, trtest, ps->clientNum, MASK_PLAYERSOLID);
+
+		if ((tr.fraction != 1 && tr.entityNum != ps->clientNum) || tr.startsolid || tr.allsolid)
+		{
+			G_AddEvent(&g_entities[ps->clientNum], EV_ITEMUSEFAIL, SENTRY_NOROOM);
+			return 0;
+		}
+
+		return 1;
+	case HI_SHIELD:
+		mins[0] = -8;
+		mins[1] = -8;
+		mins[2] = 0;
+
+		maxs[0] = 8;
+		maxs[1] = 8;
+		maxs[2] = 8;
+
+		AngleVectors (ps->viewangles, fwd, NULL, NULL);
+		fwd[2] = 0;
+		VectorMA(ps->origin, 64, fwd, dest);
+		trap_Trace(&tr, ps->origin, mins, maxs, dest, ps->clientNum, MASK_SHOT );
+		if (tr.fraction > 0.9 && !tr.startsolid && !tr.allsolid)
+		{
+			VectorCopy(tr.endpos, pos);
+			VectorSet( dest, pos[0], pos[1], pos[2] - 4096 );
+			trap_Trace( &tr, pos, mins, maxs, dest, ps->clientNum, MASK_SOLID );
+			if ( !tr.startsolid && !tr.allsolid )
+			{
+				return 1;
+			}
+		}
+		G_AddEvent(&g_entities[ps->clientNum], EV_ITEMUSEFAIL, SHIELD_NOROOM);
+		return 0;
+	case HI_JETPACK: //do something?
+		return 1;
+	case HI_HEALTHDISP:
+		return 1;
+	case HI_AMMODISP:
+		return 1;
+	case HI_EWEB:
+		return 1;
+	case HI_CLOAK:
+		return 1;
+	default:
+		return 1;
+	}
+}
+
+void saberKnockDown(gentity_t *saberent, gentity_t *saberOwner, gentity_t *other);
+
+void Cmd_ToggleSaber_f(gentity_t *ent)
+{
+	if (ent->client->ps.fd.forceGripCripple)
+	{ //if they are being gripped, don't let them unholster their saber
+		if (ent->client->ps.saberHolstered)
+		{
+			return;
+		}
+	}
+
+	if (ent->client->ps.saberInFlight)
+	{
+		if (ent->client->ps.saberEntityNum)
+		{ //turn it off in midair
+			saberKnockDown(&g_entities[ent->client->ps.saberEntityNum], ent, ent);
+		}
+		return;
+	}
+
+	if (ent->client->ps.forceHandExtend != HANDEXTEND_NONE)
+	{
+		return;
+	}
+
+	if (ent->client->ps.weapon != WP_SABER)
+	{
+		return;
+	}
+
+//	if (ent->client->ps.duelInProgress && !ent->client->ps.saberHolstered)
+//	{
+//		return;
+//	}
+
+	if (ent->client->ps.duelTime >= level.time)
+	{
+		return;
+	}
+
+	if (ent->client->ps.saberLockTime >= level.time)
+	{
+		return;
+	}
+
+	if (ent->client && ent->client->ps.weaponTime < 1)
+	{
+		if (ent->client->ps.saberHolstered == 2)
+		{
+			ent->client->ps.saberHolstered = 0;
+
+			if (ent->client->saber[0].soundOn)
+			{
+				G_Sound(ent, CHAN_AUTO, ent->client->saber[0].soundOn);
+			}
+			if (ent->client->saber[1].soundOn)
+			{
+				G_Sound(ent, CHAN_AUTO, ent->client->saber[1].soundOn);
+			}
+		}
+		else
+		{
+			ent->client->ps.saberHolstered = 2;
+			if (ent->client->saber[0].soundOff)
+			{
+				G_Sound(ent, CHAN_AUTO, ent->client->saber[0].soundOff);
+			}
+			if (ent->client->saber[1].soundOff &&
+				ent->client->saber[1].model[0])
+			{
+				G_Sound(ent, CHAN_AUTO, ent->client->saber[1].soundOff);
+			}
+			//prevent anything from being done for 400ms after holster
+			ent->client->ps.weaponTime = 400;
+		}
+	}
+}
+
+extern vmCvar_t		d_saberStanceDebug;
+
+void Cmd_SaberAttackCycle_f(gentity_t *ent)
+{
+	int selectLevel = 0;
+
+	if ( !ent || !ent->client )
+	{
+		return;
+	}
+	/*
+	if (ent->client->ps.weaponTime > 0)
+	{ //no switching attack level when busy
+		return;
+	}
+	*/
+
+	if (ent->client->saber[0].model[0] && ent->client->saber[1].model[0])
+	{ //no cycling for akimbo
+		if ( ent->client->ps.saberHolstered == 1 )
+		{//have one holstered
+			//unholster it
+			G_Sound(ent, CHAN_AUTO, ent->client->saber[1].soundOn);
+			ent->client->ps.saberHolstered = 0;
+			//g_active should take care of this, but...
+			ent->client->ps.fd.saberAnimLevel = SS_DUAL;
+		}
+		else if ( ent->client->ps.saberHolstered == 0 )
+		{//have none holstered
+			//holster it
+			G_Sound(ent, CHAN_AUTO, ent->client->saber[1].soundOff);
+			ent->client->ps.saberHolstered = 1;
+			//g_active should take care of this, but...
+			ent->client->ps.fd.saberAnimLevel = SS_FAST;
+		}
+
+		if (d_saberStanceDebug.integer)
+		{
+			trap_SendServerCommand( ent-g_entities, va("print \"SABERSTANCEDEBUG: Attempted to toggle dual saber blade.\n\"") );
+		}
+		return;
+	}
+
+	if (ent->client->saber[0].numBlades > 1 )
+	{ //use staff stance then.
+		if ( ent->client->ps.saberHolstered == 1 )
+		{//second blade off
+			if ( ent->client->ps.saberInFlight )
+			{//can't turn second blade back on if it's in the air, you naughty boy!
+				if (d_saberStanceDebug.integer)
+				{
+					trap_SendServerCommand( ent-g_entities, va("print \"SABERSTANCEDEBUG: Attempted to toggle staff blade in air.\n\"") );
+				}
+				return;
+			}
+			//turn it on
+			G_Sound(ent, CHAN_AUTO, ent->client->saber[0].soundOn);
+			ent->client->ps.saberHolstered = 0;
+			//g_active should take care of this, but...
+			if ( ent->client->saber[0].style != SS_NONE )
+			{
+				if ( ent->client->ps.weaponTime <= 0 )
+				{ //not busy, set it now
+					ent->client->ps.fd.saberAnimLevel = ent->client->saber[0].style;
+				}
+				else
+				{ //can't set it now or we might cause unexpected chaining, so queue it
+					ent->client->saberCycleQueue = ent->client->saber[0].style;
+				}
+			}
+		}
+		else if ( ent->client->ps.saberHolstered == 0 )
+		{//both blades on
+			//turn second one off
+			G_Sound(ent, CHAN_AUTO, ent->client->saber[0].soundOff);
+			ent->client->ps.saberHolstered = 1;
+			//g_active should take care of this, but...
+			if ( ent->client->saber[0].singleBladeStyle != SS_NONE )
+			{
+				if ( ent->client->ps.weaponTime <= 0 )
+				{ //not busy, set it now
+					ent->client->ps.fd.saberAnimLevel = ent->client->saber[0].singleBladeStyle;
+				}
+				else
+				{ //can't set it now or we might cause unexpected chaining, so queue it
+					ent->client->saberCycleQueue = ent->client->saber[0].singleBladeStyle;
+				}
+			}
+		}
+		if (d_saberStanceDebug.integer)
+		{
+			trap_SendServerCommand( ent-g_entities, va("print \"SABERSTANCEDEBUG: Attempted to toggle staff blade.\n\"") );
+		}
+		return;
+	}
+
+	if (ent->client->saberCycleQueue)
+	{ //resume off of the queue if we haven't gotten a chance to update it yet
+		selectLevel = ent->client->saberCycleQueue;
+	}
+	else
+	{
+		selectLevel = ent->client->ps.fd.saberAnimLevel;
+	}
+
+	if (g_gametype.integer == GT_SIEGE &&
+		ent->client->siegeClass != -1 &&
+		bgSiegeClasses[ent->client->siegeClass].saberStance)
+	{ //we have a flag of useable stances so cycle through it instead
+		int i = selectLevel+1;
+
+		while (i != selectLevel)
+		{ //cycle around upward til we hit the next style or end up back on this one
+			if (i >= SS_NUM_SABER_STYLES)
+			{ //loop back around to the first valid
+				i = SS_FAST;
+			}
+
+			if (bgSiegeClasses[ent->client->siegeClass].saberStance & (1 << i))
+			{ //we can use this one, select it and break out.
+				selectLevel = i;
+				break;
+			}
+			i++;
+		}
+
+		if (d_saberStanceDebug.integer)
+		{
+			trap_SendServerCommand( ent-g_entities, va("print \"SABERSTANCEDEBUG: Attempted to cycle given class stance.\n\"") );
+		}
+	}
+	else
+	{
+		selectLevel++;
+		if ( selectLevel > ent->client->ps.fd.forcePowerLevel[FP_SABER_OFFENSE] )
+		{
+			selectLevel = FORCE_LEVEL_1;
+		}
+		if (d_saberStanceDebug.integer)
+		{
+			trap_SendServerCommand( ent-g_entities, va("print \"SABERSTANCEDEBUG: Attempted to cycle stance normally.\n\"") );
+		}
+	}
+/*
+#ifndef FINAL_BUILD
+	switch ( selectLevel )
+	{
+	case FORCE_LEVEL_1:
+		trap_SendServerCommand( ent-g_entities, va("print \"Lightsaber Combat Style: %sfast\n\"", S_COLOR_BLUE) );
+		break;
+	case FORCE_LEVEL_2:
+		trap_SendServerCommand( ent-g_entities, va("print \"Lightsaber Combat Style: %smedium\n\"", S_COLOR_YELLOW) );
+		break;
+	case FORCE_LEVEL_3:
+		trap_SendServerCommand( ent-g_entities, va("print \"Lightsaber Combat Style: %sstrong\n\"", S_COLOR_RED) );
+		break;
+	}
+#endif
+*/
+	if (ent->client->ps.weaponTime <= 0)
+	{ //not busy, set it now
+		ent->client->ps.fd.saberAnimLevelBase = ent->client->ps.fd.saberAnimLevel = selectLevel;
+	}
+	else
+	{ //can't set it now or we might cause unexpected chaining, so queue it
+		ent->client->ps.fd.saberAnimLevelBase = ent->client->saberCycleQueue = selectLevel;
+	}
+}
+
+qboolean G_OtherPlayersDueling(void)
+{
+	int i = 0;
+	gentity_t *ent;
+
+	while (i < MAX_CLIENTS)
+	{
+		ent = &g_entities[i];
+
+		if (ent && ent->inuse && ent->client && ent->client->ps.duelInProgress)
+		{
+			return qtrue;
+		}
+		i++;
+	}
+
+	return qfalse;
+}
+
+void Cmd_EngageDuel_f(gentity_t *ent)
+{
+	trace_t tr;
+	vec3_t forward, fwdOrg;
+
+	if (!g_privateDuel.integer)
+	{
+		return;
+	}
+
+	if (g_gametype.integer == GT_DUEL || g_gametype.integer == GT_POWERDUEL)
+	{ //rather pointless in this mode..
+		trap_SendServerCommand( ent-g_entities, va("print \"%s\n\"", G_GetStringEdString("MP_SVGAME", "NODUEL_GAMETYPE")) );
+		return;
+	}
+
+	//if (g_gametype.integer >= GT_TEAM && g_gametype.integer != GT_SIEGE)
+	if (g_gametype.integer >= GT_TEAM)
+	{ //no private dueling in team modes
+		trap_SendServerCommand( ent-g_entities, va("print \"%s\n\"", G_GetStringEdString("MP_SVGAME", "NODUEL_GAMETYPE")) );
+		return;
+	}
+
+	if (ent->client->ps.duelTime >= level.time)
+	{
+		return;
+	}
+
+	if (ent->client->ps.weapon != WP_SABER)
+	{
+		return;
+	}
+
+	/*
+	if (!ent->client->ps.saberHolstered)
+	{ //must have saber holstered at the start of the duel
+		return;
+	}
+	*/
+	//NOTE: No longer doing this..
+
+	if (ent->client->ps.saberInFlight)
+	{
+		return;
+	}
+
+	if (ent->client->ps.duelInProgress)
+	{
+		return;
+	}
+
+	//New: Don't let a player duel if he just did and hasn't waited 10 seconds yet (note: If someone challenges him, his duel timer will reset so he can accept)
+	if (ent->client->ps.fd.privateDuelTime > level.time)
+	{
+		trap_SendServerCommand( ent-g_entities, va("print \"%s\n\"", G_GetStringEdString("MP_SVGAME", "CANTDUEL_JUSTDID")) );
+		return;
+	}
+
+	if (G_OtherPlayersDueling())
+	{
+		trap_SendServerCommand( ent-g_entities, va("print \"%s\n\"", G_GetStringEdString("MP_SVGAME", "CANTDUEL_BUSY")) );
+		return;
+	}
+
+	AngleVectors( ent->client->ps.viewangles, forward, NULL, NULL );
+
+	fwdOrg[0] = ent->client->ps.origin[0] + forward[0]*256;
+	fwdOrg[1] = ent->client->ps.origin[1] + forward[1]*256;
+	fwdOrg[2] = (ent->client->ps.origin[2]+ent->client->ps.viewheight) + forward[2]*256;
+
+	trap_Trace(&tr, ent->client->ps.origin, NULL, NULL, fwdOrg, ent->s.number, MASK_PLAYERSOLID);
+
+	if (tr.fraction != 1 && tr.entityNum < MAX_CLIENTS)
+	{
+		gentity_t *challenged = &g_entities[tr.entityNum];
+
+		if (!challenged || !challenged->client || !challenged->inuse ||
+			challenged->health < 1 || challenged->client->ps.stats[STAT_HEALTH] < 1 ||
+			challenged->client->ps.weapon != WP_SABER || challenged->client->ps.duelInProgress ||
+			challenged->client->ps.saberInFlight)
+		{
+			return;
+		}
+
+		if (g_gametype.integer >= GT_TEAM && OnSameTeam(ent, challenged))
+		{
+			return;
+		}
+
+		if (challenged->client->ps.duelIndex == ent->s.number && challenged->client->ps.duelTime >= level.time)
+		{
+			trap_SendServerCommand( /*challenged-g_entities*/-1, va("print \"%s %s %s!\n\"", challenged->client->pers.netname, G_GetStringEdString("MP_SVGAME", "PLDUELACCEPT"), ent->client->pers.netname) );
+
+			ent->client->ps.duelInProgress = qtrue;
+			challenged->client->ps.duelInProgress = qtrue;
+
+			ent->client->ps.duelTime = level.time + 2000;
+			challenged->client->ps.duelTime = level.time + 2000;
+
+			G_AddEvent(ent, EV_PRIVATE_DUEL, 1);
+			G_AddEvent(challenged, EV_PRIVATE_DUEL, 1);
+
+			//Holster their sabers now, until the duel starts (then they'll get auto-turned on to look cool)
+
+			if (!ent->client->ps.saberHolstered)
+			{
+				if (ent->client->saber[0].soundOff)
+				{
+					G_Sound(ent, CHAN_AUTO, ent->client->saber[0].soundOff);
+				}
+				if (ent->client->saber[1].soundOff &&
+					ent->client->saber[1].model[0])
+				{
+					G_Sound(ent, CHAN_AUTO, ent->client->saber[1].soundOff);
+				}
+				ent->client->ps.weaponTime = 400;
+				ent->client->ps.saberHolstered = 2;
+			}
+			if (!challenged->client->ps.saberHolstered)
+			{
+				if (challenged->client->saber[0].soundOff)
+				{
+					G_Sound(challenged, CHAN_AUTO, challenged->client->saber[0].soundOff);
+				}
+				if (challenged->client->saber[1].soundOff &&
+					challenged->client->saber[1].model[0])
+				{
+					G_Sound(challenged, CHAN_AUTO, challenged->client->saber[1].soundOff);
+				}
+				challenged->client->ps.weaponTime = 400;
+				challenged->client->ps.saberHolstered = 2;
+			}
+		}
+		else
+		{
+			//Print the message that a player has been challenged in private, only announce the actual duel initiation in private
+			trap_SendServerCommand( challenged-g_entities, va("cp \"%s %s\n\"", ent->client->pers.netname, G_GetStringEdString("MP_SVGAME", "PLDUELCHALLENGE")) );
+			trap_SendServerCommand( ent-g_entities, va("cp \"%s %s\n\"", G_GetStringEdString("MP_SVGAME", "PLDUELCHALLENGED"), challenged->client->pers.netname) );
+		}
+
+		challenged->client->ps.fd.privateDuelTime = 0; //reset the timer in case this player just got out of a duel. He should still be able to accept the challenge.
+
+		ent->client->ps.forceHandExtend = HANDEXTEND_DUELCHALLENGE;
+		ent->client->ps.forceHandExtendTime = level.time + 1000;
+
+		ent->client->ps.duelIndex = challenged->s.number;
+		ent->client->ps.duelTime = level.time + 5000;
+	}
+}
+
+#ifndef FINAL_BUILD
+extern stringID_table_t animTable[MAX_ANIMATIONS+1];
+
+void Cmd_DebugSetSaberMove_f(gentity_t *self)
+{
+	int argNum = trap_Argc();
+	char arg[MAX_STRING_CHARS];
+
+	if (argNum < 2)
+	{
+		return;
+	}
+
+	trap_Argv( 1, arg, sizeof( arg ) );
+
+	if (!arg[0])
+	{
+		return;
+	}
+
+	self->client->ps.saberMove = atoi(arg);
+	self->client->ps.saberBlocked = BLOCKED_BOUNCE_MOVE;
+
+	if (self->client->ps.saberMove >= LS_MOVE_MAX)
+	{
+		self->client->ps.saberMove = LS_MOVE_MAX-1;
+	}
+
+	Com_Printf("Anim for move: %s\n", animTable[saberMoveData[self->client->ps.saberMove].animToUse].name);
+}
+
+void Cmd_DebugSetBodyAnim_f(gentity_t *self, int flags)
+{
+	int argNum = trap_Argc();
+	char arg[MAX_STRING_CHARS];
+	int i = 0;
+
+	if (argNum < 2)
+	{
+		return;
+	}
+
+	trap_Argv( 1, arg, sizeof( arg ) );
+
+	if (!arg[0])
+	{
+		return;
+	}
+
+	while (i < MAX_ANIMATIONS)
+	{
+		if (!Q_stricmp(arg, animTable[i].name))
+		{
+			break;
+		}
+		i++;
+	}
+
+	if (i == MAX_ANIMATIONS)
+	{
+		Com_Printf("Animation '%s' does not exist\n", arg);
+		return;
+	}
+
+	G_SetAnim(self, NULL, SETANIM_BOTH, i, flags, 0);
+
+	Com_Printf("Set body anim to %s\n", arg);
+}
+#endif
+
+void StandardSetBodyAnim(gentity_t *self, int anim, int flags)
+{
+	G_SetAnim(self, NULL, SETANIM_BOTH, anim, flags, 0);
+}
+
+void DismembermentTest(gentity_t *self);
+
+void Bot_SetForcedMovement(int bot, int forward, int right, int up);
+
+#ifndef FINAL_BUILD
+extern void DismembermentByNum(gentity_t *self, int num);
+extern void G_SetVehDamageFlags( gentity_t *veh, int shipSurf, int damageLevel );
+#endif
+
+static int G_ClientNumFromNetname(char *name)
+{
+	int i = 0;
+	gentity_t *ent;
+
+	while (i < MAX_CLIENTS)
+	{
+		ent = &g_entities[i];
+
+		if (ent->inuse && ent->client &&
+			!Q_stricmp(ent->client->pers.netname, name))
+		{
+			return ent->s.number;
+		}
+		i++;
+	}
+
+	return -1;
+}
+
+qboolean TryGrapple(gentity_t *ent)
+{
+	if (ent->client->ps.weaponTime > 0)
+	{ //weapon busy
+		return qfalse;
+	}
+	if (ent->client->ps.forceHandExtend != HANDEXTEND_NONE)
+	{ //force power or knockdown or something
+		return qfalse;
+	}
+	if (ent->client->grappleState)
+	{ //already grappling? but weapontime should be > 0 then..
+		return qfalse;
+	}
+
+	if (ent->client->ps.weapon != WP_SABER && ent->client->ps.weapon != WP_MELEE)
+	{
+		return qfalse;
+	}
+
+	if (ent->client->ps.weapon == WP_SABER && !ent->client->ps.saberHolstered)
+	{
+		Cmd_ToggleSaber_f(ent);
+		if (!ent->client->ps.saberHolstered)
+		{ //must have saber holstered
+			return qfalse;
+		}
+	}
+
+	//G_SetAnim(ent, &ent->client->pers.cmd, SETANIM_BOTH, BOTH_KYLE_PA_1, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD, 0);
+	G_SetAnim(ent, &ent->client->pers.cmd, SETANIM_BOTH, BOTH_KYLE_GRAB, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD, 0);
+	if (ent->client->ps.torsoAnim == BOTH_KYLE_GRAB)
+	{ //providing the anim set succeeded..
+		ent->client->ps.torsoTimer += 500; //make the hand stick out a little longer than it normally would
+		if (ent->client->ps.legsAnim == ent->client->ps.torsoAnim)
+		{
+			ent->client->ps.legsTimer = ent->client->ps.torsoTimer;
+		}
+		ent->client->ps.weaponTime = ent->client->ps.torsoTimer;
+		return qtrue;
+	}
+
+	return qfalse;
+}
+
+#ifndef FINAL_BUILD
+qboolean saberKnockOutOfHand(gentity_t *saberent, gentity_t *saberOwner, vec3_t velocity);
+#endif
+
+/*
+=================
+ClientCommand
+=================
+*/
+void ClientCommand( int clientNum ) {
+	gentity_t *ent;
+	char	cmd[MAX_TOKEN_CHARS];
+
+	ent = g_entities + clientNum;
+	if ( !ent->client ) {
+		return;		// not fully in game yet
+	}
+
+
+	trap_Argv( 0, cmd, sizeof( cmd ) );
+
+	//rww - redirect bot commands
+	if (strstr(cmd, "bot_") && AcceptBotCommand(cmd, ent))
+	{
+		return;
+	}
+	//end rww
+
+	if (Q_stricmp (cmd, "say") == 0) {
+		Cmd_Say_f (ent, SAY_ALL, qfalse);
+		return;
+	}
+	if (Q_stricmp (cmd, "say_team") == 0) {
+		if (g_gametype.integer < GT_TEAM)
+		{ //not a team game, just refer to regular say.
+			Cmd_Say_f (ent, SAY_ALL, qfalse);
+		}
+		else
+		{
+			Cmd_Say_f (ent, SAY_TEAM, qfalse);
+		}
+		return;
+	}
+	if (Q_stricmp (cmd, "tell") == 0) {
+		Cmd_Tell_f ( ent );
+		return;
+	}
+
+	if (Q_stricmp(cmd, "voice_cmd") == 0)
+	{
+		Cmd_VoiceCommand_f(ent);
+		return;
+	}
+
+	if (Q_stricmp (cmd, "score") == 0) {
+		Cmd_Score_f (ent);
+		return;
+	}
+
+	// ignore all other commands when at intermission
+	if (level.intermissiontime)
+	{
+		qboolean giveError = qfalse;
+		//rwwFIXMEFIXME: This is terrible, write it differently
+
+		if (!Q_stricmp(cmd, "give"))
+		{
+			giveError = qtrue;
+		}
+		else if (!Q_stricmp(cmd, "giveother"))
+		{
+			giveError = qtrue;
+		}
+		else if (!Q_stricmp(cmd, "god"))
+		{
+			giveError = qtrue;
+		}
+		else if (!Q_stricmp(cmd, "notarget"))
+		{
+			giveError = qtrue;
+		}
+		else if (!Q_stricmp(cmd, "noclip"))
+		{
+			giveError = qtrue;
+		}
+		else if (!Q_stricmp(cmd, "kill"))
+		{
+			giveError = qtrue;
+		}
+		else if (!Q_stricmp(cmd, "teamtask"))
+		{
+			giveError = qtrue;
+		}
+		else if (!Q_stricmp(cmd, "levelshot"))
+		{
+			giveError = qtrue;
+		}
+		else if (!Q_stricmp(cmd, "follow"))
+		{
+			giveError = qtrue;
+		}
+		else if (!Q_stricmp(cmd, "follownext"))
+		{
+			giveError = qtrue;
+		}
+		else if (!Q_stricmp(cmd, "followprev"))
+		{
+			giveError = qtrue;
+		}
+		else if (!Q_stricmp(cmd, "team"))
+		{
+			giveError = qtrue;
+		}
+		else if (!Q_stricmp(cmd, "duelteam"))
+		{
+			giveError = qtrue;
+		}
+		else if (!Q_stricmp(cmd, "siegeclass"))
+		{
+			giveError = qtrue;
+		}
+		else if (!Q_stricmp(cmd, "forcechanged"))
+		{ //special case: still update force change
+			Cmd_ForceChanged_f (ent);
+			return;
+		}
+		else if (!Q_stricmp(cmd, "where"))
+		{
+			giveError = qtrue;
+		}
+		else if (!Q_stricmp(cmd, "callvote"))
+		{
+			giveError = qtrue;
+		}
+		else if (!Q_stricmp(cmd, "vote"))
+		{
+			giveError = qtrue;
+		}
+		else if (!Q_stricmp(cmd, "callteamvote"))
+		{
+			giveError = qtrue;
+		}
+		else if (!Q_stricmp(cmd, "teamvote"))
+		{
+			giveError = qtrue;
+		}
+		else if (!Q_stricmp(cmd, "gc"))
+		{
+			giveError = qtrue;
+		}
+		else if (!Q_stricmp(cmd, "setviewpos"))
+		{
+			giveError = qtrue;
+		}
+		else if (!Q_stricmp(cmd, "stats"))
+		{
+			giveError = qtrue;
+		}
+
+		if (giveError)
+		{
+			trap_SendServerCommand( clientNum, va("print \"%s (%s) \n\"", G_GetStringEdString("MP_SVGAME", "CANNOT_TASK_INTERMISSION"), cmd ) );
+		}
+		else
+		{
+			Cmd_Say_f (ent, qfalse, qtrue);
+		}
+		return;
+	}
+
+	if (Q_stricmp (cmd, "give") == 0)
+	{
+		Cmd_Give_f (ent, 0);
+	}
+	else if (Q_stricmp (cmd, "giveother") == 0)
+	{ //for debugging pretty much
+		Cmd_Give_f (ent, 1);
+	}
+	else if (Q_stricmp (cmd, "t_use") == 0 && CheatsOk(ent))
+	{ //debug use map object
+		if (trap_Argc() > 1)
+		{
+			char sArg[MAX_STRING_CHARS];
+			gentity_t *targ;
+
+			trap_Argv( 1, sArg, sizeof( sArg ) );
+			targ = G_Find( NULL, FOFS(targetname), sArg );
+
+			while (targ)
+			{
+				if (targ->use)
+				{
+					targ->use(targ, ent, ent);
+				}
+				targ = G_Find( targ, FOFS(targetname), sArg );
+			}
+		}
+	}
+	else if (Q_stricmp (cmd, "god") == 0)
+		Cmd_God_f (ent);
+	else if (Q_stricmp (cmd, "notarget") == 0)
+		Cmd_Notarget_f (ent);
+	else if (Q_stricmp (cmd, "noclip") == 0)
+		Cmd_Noclip_f (ent);
+	else if ( Q_stricmp( cmd, "NPC" ) == 0 && CheatsOk(ent) )
+	{
+		Cmd_NPC_f( ent );
+	}
+	else if (Q_stricmp (cmd, "kill") == 0)
+		Cmd_Kill_f (ent);
+	else if (Q_stricmp (cmd, "teamtask") == 0)
+		Cmd_TeamTask_f (ent);
+	else if (Q_stricmp (cmd, "levelshot") == 0)
+		Cmd_LevelShot_f (ent);
+	else if (Q_stricmp (cmd, "follow") == 0)
+		Cmd_Follow_f (ent);
+	else if (Q_stricmp (cmd, "follownext") == 0)
+		Cmd_FollowCycle_f (ent, 1);
+	else if (Q_stricmp (cmd, "followprev") == 0)
+		Cmd_FollowCycle_f (ent, -1);
+	else if (Q_stricmp (cmd, "team") == 0)
+		Cmd_Team_f (ent);
+	else if (Q_stricmp (cmd, "duelteam") == 0)
+		Cmd_DuelTeam_f (ent);
+	else if (Q_stricmp (cmd, "siegeclass") == 0)
+		Cmd_SiegeClass_f (ent);
+	else if (Q_stricmp (cmd, "forcechanged") == 0)
+		Cmd_ForceChanged_f (ent);
+	else if (Q_stricmp (cmd, "where") == 0)
+		Cmd_Where_f (ent);
+	else if (Q_stricmp (cmd, "callvote") == 0)
+		Cmd_CallVote_f (ent);
+	else if (Q_stricmp (cmd, "vote") == 0)
+		Cmd_Vote_f (ent);
+	else if (Q_stricmp (cmd, "callteamvote") == 0)
+		Cmd_CallTeamVote_f (ent);
+	else if (Q_stricmp (cmd, "teamvote") == 0)
+		Cmd_TeamVote_f (ent);
+	else if (Q_stricmp (cmd, "gc") == 0)
+		Cmd_GameCommand_f( ent );
+	else if (Q_stricmp (cmd, "setviewpos") == 0)
+		Cmd_SetViewpos_f( ent );
+	else if (Q_stricmp (cmd, "stats") == 0)
+		Cmd_Stats_f( ent );
+	/*
+	else if (Q_stricmp (cmd, "kylesmash") == 0)
+	{
+		TryGrapple(ent);
+	}
+	*/
+	//for convenient powerduel testing in release
+	else if (Q_stricmp(cmd, "killother") == 0 && CheatsOk( ent ))
+	{
+		if (trap_Argc() > 1)
+		{
+			char sArg[MAX_STRING_CHARS];
+			int entNum = 0;
+
+			trap_Argv( 1, sArg, sizeof( sArg ) );
+
+			entNum = G_ClientNumFromNetname(sArg);
+
+			if (entNum >= 0 && entNum < MAX_GENTITIES)
+			{
+				gentity_t *kEnt = &g_entities[entNum];
+
+				if (kEnt->inuse && kEnt->client)
+				{
+					kEnt->flags &= ~FL_GODMODE;
+					kEnt->client->ps.stats[STAT_HEALTH] = kEnt->health = -999;
+					player_die (kEnt, kEnt, kEnt, 100000, MOD_SUICIDE);
+				}
+			}
+		}
+	}
+#ifdef _DEBUG
+	else if (Q_stricmp(cmd, "relax") == 0 && CheatsOk( ent ))
+	{
+		if (ent->client->ps.eFlags & EF_RAG)
+		{
+			ent->client->ps.eFlags &= ~EF_RAG;
+		}
+		else
+		{
+			ent->client->ps.eFlags |= EF_RAG;
+		}
+	}
+	else if (Q_stricmp(cmd, "holdme") == 0 && CheatsOk( ent ))
+	{
+		if (trap_Argc() > 1)
+		{
+			char sArg[MAX_STRING_CHARS];
+			int entNum = 0;
+
+			trap_Argv( 1, sArg, sizeof( sArg ) );
+
+			entNum = atoi(sArg);
+
+			if (entNum >= 0 &&
+				entNum < MAX_GENTITIES)
+			{
+				gentity_t *grabber = &g_entities[entNum];
+
+				if (grabber->inuse && grabber->client && grabber->ghoul2)
+				{
+					if (!grabber->s.number)
+					{ //switch cl 0 and entitynum_none, so we can operate on the "if non-0" concept
+						ent->client->ps.ragAttach = ENTITYNUM_NONE;
+					}
+					else
+					{
+						ent->client->ps.ragAttach = grabber->s.number;
+					}
+				}
+			}
+		}
+		else
+		{
+			ent->client->ps.ragAttach = 0;
+		}
+	}
+	else if (Q_stricmp(cmd, "limb_break") == 0 && CheatsOk( ent ))
+	{
+		if (trap_Argc() > 1)
+		{
+			char sArg[MAX_STRING_CHARS];
+			int breakLimb = 0;
+
+			trap_Argv( 1, sArg, sizeof( sArg ) );
+			if (!Q_stricmp(sArg, "right"))
+			{
+				breakLimb = BROKENLIMB_RARM;
+			}
+			else if (!Q_stricmp(sArg, "left"))
+			{
+				breakLimb = BROKENLIMB_LARM;
+			}
+
+			G_BreakArm(ent, breakLimb);
+		}
+	}
+	else if (Q_stricmp(cmd, "headexplodey") == 0 && CheatsOk( ent ))
+	{
+		Cmd_Kill_f (ent);
+		if (ent->health < 1)
+		{
+			DismembermentTest(ent);
+		}
+	}
+	else if (Q_stricmp(cmd, "debugstupidthing") == 0 && CheatsOk( ent ))
+	{
+		int i = 0;
+		gentity_t *blah;
+		while (i < MAX_GENTITIES)
+		{
+			blah = &g_entities[i];
+			if (blah->inuse && blah->classname && blah->classname[0] && !Q_stricmp(blah->classname, "NPC_Vehicle"))
+			{
+				Com_Printf("Found it.\n");
+			}
+			i++;
+		}
+	}
+	else if (Q_stricmp(cmd, "arbitraryprint") == 0 && CheatsOk( ent ))
+	{
+		trap_SendServerCommand( -1, va("cp \"Blah blah blah\n\""));
+	}
+	else if (Q_stricmp(cmd, "handcut") == 0 && CheatsOk( ent ))
+	{
+		int bCl = 0;
+		char sarg[MAX_STRING_CHARS];
+
+		if (trap_Argc() > 1)
+		{
+			trap_Argv( 1, sarg, sizeof( sarg ) );
+
+			if (sarg[0])
+			{
+				bCl = atoi(sarg);
+
+				if (bCl >= 0 && bCl < MAX_GENTITIES)
+				{
+					gentity_t *hEnt = &g_entities[bCl];
+
+					if (hEnt->client)
+					{
+						if (hEnt->health > 0)
+						{
+							gGAvoidDismember = 1;
+							hEnt->flags &= ~FL_GODMODE;
+							hEnt->client->ps.stats[STAT_HEALTH] = hEnt->health = -999;
+							player_die (hEnt, hEnt, hEnt, 100000, MOD_SUICIDE);
+						}
+						gGAvoidDismember = 2;
+						G_CheckForDismemberment(hEnt, ent, hEnt->client->ps.origin, 999, hEnt->client->ps.legsAnim, qfalse);
+						gGAvoidDismember = 0;
+					}
+				}
+			}
+		}
+	}
+	else if (Q_stricmp(cmd, "loveandpeace") == 0 && CheatsOk( ent ))
+	{
+		trace_t tr;
+		vec3_t fPos;
+
+		AngleVectors(ent->client->ps.viewangles, fPos, 0, 0);
+
+		fPos[0] = ent->client->ps.origin[0] + fPos[0]*40;
+		fPos[1] = ent->client->ps.origin[1] + fPos[1]*40;
+		fPos[2] = ent->client->ps.origin[2] + fPos[2]*40;
+
+		trap_Trace(&tr, ent->client->ps.origin, 0, 0, fPos, ent->s.number, ent->clipmask);
+
+		if (tr.entityNum < MAX_CLIENTS && tr.entityNum != ent->s.number)
+		{
+			gentity_t *other = &g_entities[tr.entityNum];
+
+			if (other && other->inuse && other->client)
+			{
+				vec3_t entDir;
+				vec3_t otherDir;
+				vec3_t entAngles;
+				vec3_t otherAngles;
+
+				if (ent->client->ps.weapon == WP_SABER && !ent->client->ps.saberHolstered)
+				{
+					Cmd_ToggleSaber_f(ent);
+				}
+
+				if (other->client->ps.weapon == WP_SABER && !other->client->ps.saberHolstered)
+				{
+					Cmd_ToggleSaber_f(other);
+				}
+
+				if ((ent->client->ps.weapon != WP_SABER || ent->client->ps.saberHolstered) &&
+					(other->client->ps.weapon != WP_SABER || other->client->ps.saberHolstered))
+				{
+					VectorSubtract( other->client->ps.origin, ent->client->ps.origin, otherDir );
+					VectorCopy( ent->client->ps.viewangles, entAngles );
+					entAngles[YAW] = vectoyaw( otherDir );
+					SetClientViewAngle( ent, entAngles );
+
+					StandardSetBodyAnim(ent, /*BOTH_KISSER1LOOP*/BOTH_STAND1, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD|SETANIM_FLAG_HOLDLESS);
+					ent->client->ps.saberMove = LS_NONE;
+					ent->client->ps.saberBlocked = 0;
+					ent->client->ps.saberBlocking = 0;
+
+					VectorSubtract( ent->client->ps.origin, other->client->ps.origin, entDir );
+					VectorCopy( other->client->ps.viewangles, otherAngles );
+					otherAngles[YAW] = vectoyaw( entDir );
+					SetClientViewAngle( other, otherAngles );
+
+					StandardSetBodyAnim(other, /*BOTH_KISSEE1LOOP*/BOTH_STAND1, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD|SETANIM_FLAG_HOLDLESS);
+					other->client->ps.saberMove = LS_NONE;
+					other->client->ps.saberBlocked = 0;
+					other->client->ps.saberBlocking = 0;
+				}
+			}
+		}
+	}
+#endif
+	else if (Q_stricmp(cmd, "thedestroyer") == 0 && CheatsOk( ent ) && ent && ent->client && ent->client->ps.saberHolstered && ent->client->ps.weapon == WP_SABER)
+	{
+		Cmd_ToggleSaber_f(ent);
+
+		if (!ent->client->ps.saberHolstered)
+		{
+		}
+	}
+	//begin bot debug cmds
+	else if (Q_stricmp(cmd, "debugBMove_Forward") == 0 && CheatsOk(ent))
+	{
+		int arg = 4000;
+		int bCl = 0;
+		char sarg[MAX_STRING_CHARS];
+
+		assert(trap_Argc() > 1);
+		trap_Argv( 1, sarg, sizeof( sarg ) );
+
+		assert(sarg[0]);
+		bCl = atoi(sarg);
+		Bot_SetForcedMovement(bCl, arg, -1, -1);
+	}
+	else if (Q_stricmp(cmd, "debugBMove_Back") == 0 && CheatsOk(ent))
+	{
+		int arg = -4000;
+		int bCl = 0;
+		char sarg[MAX_STRING_CHARS];
+
+		assert(trap_Argc() > 1);
+		trap_Argv( 1, sarg, sizeof( sarg ) );
+
+		assert(sarg[0]);
+		bCl = atoi(sarg);
+		Bot_SetForcedMovement(bCl, arg, -1, -1);
+	}
+	else if (Q_stricmp(cmd, "debugBMove_Right") == 0 && CheatsOk(ent))
+	{
+		int arg = 4000;
+		int bCl = 0;
+		char sarg[MAX_STRING_CHARS];
+
+		assert(trap_Argc() > 1);
+		trap_Argv( 1, sarg, sizeof( sarg ) );
+
+		assert(sarg[0]);
+		bCl = atoi(sarg);
+		Bot_SetForcedMovement(bCl, -1, arg, -1);
+	}
+	else if (Q_stricmp(cmd, "debugBMove_Left") == 0 && CheatsOk(ent))
+	{
+		int arg = -4000;
+		int bCl = 0;
+		char sarg[MAX_STRING_CHARS];
+
+		assert(trap_Argc() > 1);
+		trap_Argv( 1, sarg, sizeof( sarg ) );
+
+		assert(sarg[0]);
+		bCl = atoi(sarg);
+		Bot_SetForcedMovement(bCl, -1, arg, -1);
+	}
+	else if (Q_stricmp(cmd, "debugBMove_Up") == 0 && CheatsOk(ent))
+	{
+		int arg = 4000;
+		int bCl = 0;
+		char sarg[MAX_STRING_CHARS];
+
+		assert(trap_Argc() > 1);
+		trap_Argv( 1, sarg, sizeof( sarg ) );
+
+		assert(sarg[0]);
+		bCl = atoi(sarg);
+		Bot_SetForcedMovement(bCl, -1, -1, arg);
+	}
+	//end bot debug cmds
+#ifndef FINAL_BUILD
+	else if (Q_stricmp(cmd, "debugSetSaberMove") == 0)
+	{
+		Cmd_DebugSetSaberMove_f(ent);
+	}
+	else if (Q_stricmp(cmd, "debugSetBodyAnim") == 0)
+	{
+		Cmd_DebugSetBodyAnim_f(ent, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD);
+	}
+	else if (Q_stricmp(cmd, "debugDismemberment") == 0)
+	{
+		Cmd_Kill_f (ent);
+		if (ent->health < 1)
+		{
+			char	arg[MAX_STRING_CHARS];
+			int		iArg = 0;
+
+			if (trap_Argc() > 1)
+			{
+				trap_Argv( 1, arg, sizeof( arg ) );
+
+				if (arg[0])
+				{
+					iArg = atoi(arg);
+				}
+			}
+
+			DismembermentByNum(ent, iArg);
+		}
+	}
+	else if (Q_stricmp(cmd, "debugDropSaber") == 0)
+	{
+		if (ent->client->ps.weapon == WP_SABER &&
+			ent->client->ps.saberEntityNum &&
+			!ent->client->ps.saberInFlight)
+		{
+			saberKnockOutOfHand(&g_entities[ent->client->ps.saberEntityNum], ent, vec3_origin);
+		}
+	}
+	else if (Q_stricmp(cmd, "debugKnockMeDown") == 0)
+	{
+		if (BG_KnockDownable(&ent->client->ps))
+		{
+			ent->client->ps.forceHandExtend = HANDEXTEND_KNOCKDOWN;
+			ent->client->ps.forceDodgeAnim = 0;
+			if (trap_Argc() > 1)
+			{
+				ent->client->ps.forceHandExtendTime = level.time + 1100;
+				ent->client->ps.quickerGetup = qfalse;
+			}
+			else
+			{
+				ent->client->ps.forceHandExtendTime = level.time + 700;
+				ent->client->ps.quickerGetup = qtrue;
+			}
+		}
+	}
+	else if (Q_stricmp(cmd, "debugSaberSwitch") == 0)
+	{
+		gentity_t *targ = NULL;
+
+		if (trap_Argc() > 1)
+		{
+			char	arg[MAX_STRING_CHARS];
+
+			trap_Argv( 1, arg, sizeof( arg ) );
+
+			if (arg[0])
+			{
+				int x = atoi(arg);
+				
+				if (x >= 0 && x < MAX_CLIENTS)
+				{
+					targ = &g_entities[x];
+				}
+			}
+		}
+
+		if (targ && targ->inuse && targ->client)
+		{
+			Cmd_ToggleSaber_f(targ);
+		}
+	}
+	else if (Q_stricmp(cmd, "debugIKGrab") == 0)
+	{
+		gentity_t *targ = NULL;
+
+		if (trap_Argc() > 1)
+		{
+			char	arg[MAX_STRING_CHARS];
+
+			trap_Argv( 1, arg, sizeof( arg ) );
+
+			if (arg[0])
+			{
+				int x = atoi(arg);
+				
+				if (x >= 0 && x < MAX_CLIENTS)
+				{
+					targ = &g_entities[x];
+				}
+			}
+		}
+
+		if (targ && targ->inuse && targ->client && ent->s.number != targ->s.number)
+		{
+			targ->client->ps.heldByClient = ent->s.number+1;
+		}
+	}
+	else if (Q_stricmp(cmd, "debugIKBeGrabbedBy") == 0)
+	{
+		gentity_t *targ = NULL;
+
+		if (trap_Argc() > 1)
+		{
+			char	arg[MAX_STRING_CHARS];
+
+			trap_Argv( 1, arg, sizeof( arg ) );
+
+			if (arg[0])
+			{
+				int x = atoi(arg);
+				
+				if (x >= 0 && x < MAX_CLIENTS)
+				{
+					targ = &g_entities[x];
+				}
+			}
+		}
+
+		if (targ && targ->inuse && targ->client && ent->s.number != targ->s.number)
+		{
+			ent->client->ps.heldByClient = targ->s.number+1;
+		}
+	}
+	else if (Q_stricmp(cmd, "debugIKRelease") == 0)
+	{
+		gentity_t *targ = NULL;
+
+		if (trap_Argc() > 1)
+		{
+			char	arg[MAX_STRING_CHARS];
+
+			trap_Argv( 1, arg, sizeof( arg ) );
+
+			if (arg[0])
+			{
+				int x = atoi(arg);
+				
+				if (x >= 0 && x < MAX_CLIENTS)
+				{
+					targ = &g_entities[x];
+				}
+			}
+		}
+
+		if (targ && targ->inuse && targ->client)
+		{
+			targ->client->ps.heldByClient = 0;
+		}
+	}
+	else if (Q_stricmp(cmd, "debugThrow") == 0)
+	{
+		trace_t tr;
+		vec3_t tTo, fwd;
+
+		if (ent->client->ps.weaponTime > 0 || ent->client->ps.forceHandExtend != HANDEXTEND_NONE ||
+			ent->client->ps.groundEntityNum == ENTITYNUM_NONE || ent->health < 1)
+		{
+			return;
+		}
+
+		AngleVectors(ent->client->ps.viewangles, fwd, 0, 0);
+		tTo[0] = ent->client->ps.origin[0] + fwd[0]*32;
+		tTo[1] = ent->client->ps.origin[1] + fwd[1]*32;
+		tTo[2] = ent->client->ps.origin[2] + fwd[2]*32;
+
+		trap_Trace(&tr, ent->client->ps.origin, 0, 0, tTo, ent->s.number, MASK_PLAYERSOLID);
+
+		if (tr.fraction != 1)
+		{
+			gentity_t *other = &g_entities[tr.entityNum];
+
+			if (other->inuse && other->client && other->client->ps.forceHandExtend == HANDEXTEND_NONE &&
+				other->client->ps.groundEntityNum != ENTITYNUM_NONE && other->health > 0 &&
+				(int)ent->client->ps.origin[2] == (int)other->client->ps.origin[2])
+			{
+				float pDif = 40.0f;
+				vec3_t entAngles, entDir;
+				vec3_t otherAngles, otherDir;
+				vec3_t intendedOrigin;
+				vec3_t boltOrg, pBoltOrg;
+				vec3_t tAngles, vDif;
+				vec3_t fwd, right;
+				trace_t tr;
+				trace_t tr2;
+
+				VectorSubtract( other->client->ps.origin, ent->client->ps.origin, otherDir );
+				VectorCopy( ent->client->ps.viewangles, entAngles );
+				entAngles[YAW] = vectoyaw( otherDir );
+				SetClientViewAngle( ent, entAngles );
+
+				ent->client->ps.forceHandExtend = HANDEXTEND_PRETHROW;
+				ent->client->ps.forceHandExtendTime = level.time + 5000;
+
+				ent->client->throwingIndex = other->s.number;
+				ent->client->doingThrow = level.time + 5000;
+				ent->client->beingThrown = 0;
+
+				VectorSubtract( ent->client->ps.origin, other->client->ps.origin, entDir );
+				VectorCopy( other->client->ps.viewangles, otherAngles );
+				otherAngles[YAW] = vectoyaw( entDir );
+				SetClientViewAngle( other, otherAngles );
+
+				other->client->ps.forceHandExtend = HANDEXTEND_PRETHROWN;
+				other->client->ps.forceHandExtendTime = level.time + 5000;
+
+				other->client->throwingIndex = ent->s.number;
+				other->client->beingThrown = level.time + 5000;
+				other->client->doingThrow = 0;
+
+				//Doing this now at a stage in the throw, isntead of initially.
+				//other->client->ps.heldByClient = ent->s.number+1;
+
+				G_EntitySound( other, CHAN_VOICE, G_SoundIndex("*pain100.wav") );
+				G_EntitySound( ent, CHAN_VOICE, G_SoundIndex("*jump1.wav") );
+				G_Sound(other, CHAN_AUTO, G_SoundIndex( "sound/movers/objects/objectHit.wav" ));
+
+				//see if we can move to be next to the hand.. if it's not clear, break the throw.
+				VectorClear(tAngles);
+				tAngles[YAW] = ent->client->ps.viewangles[YAW];
+				VectorCopy(ent->client->ps.origin, pBoltOrg);
+				AngleVectors(tAngles, fwd, right, 0);
+				boltOrg[0] = pBoltOrg[0] + fwd[0]*8 + right[0]*pDif;
+				boltOrg[1] = pBoltOrg[1] + fwd[1]*8 + right[1]*pDif;
+				boltOrg[2] = pBoltOrg[2];
+
+				VectorSubtract(boltOrg, pBoltOrg, vDif);
+				VectorNormalize(vDif);
+
+				VectorClear(other->client->ps.velocity);
+				intendedOrigin[0] = pBoltOrg[0] + vDif[0]*pDif;
+				intendedOrigin[1] = pBoltOrg[1] + vDif[1]*pDif;
+				intendedOrigin[2] = other->client->ps.origin[2];
+
+				trap_Trace(&tr, intendedOrigin, other->r.mins, other->r.maxs, intendedOrigin, other->s.number, other->clipmask);
+				trap_Trace(&tr2, ent->client->ps.origin, ent->r.mins, ent->r.maxs, intendedOrigin, ent->s.number, CONTENTS_SOLID);
+
+				if (tr.fraction == 1.0 && !tr.startsolid && tr2.fraction == 1.0 && !tr2.startsolid)
+				{
+					VectorCopy(intendedOrigin, other->client->ps.origin);
+				}
+				else
+				{ //if the guy can't be put here then it's time to break the throw off.
+					vec3_t oppDir;
+					int strength = 4;
+
+					other->client->ps.heldByClient = 0;
+					other->client->beingThrown = 0;
+					ent->client->doingThrow = 0;
+
+					ent->client->ps.forceHandExtend = HANDEXTEND_NONE;
+					G_EntitySound( ent, CHAN_VOICE, G_SoundIndex("*pain25.wav") );
+
+					other->client->ps.forceHandExtend = HANDEXTEND_NONE;
+					VectorSubtract(other->client->ps.origin, ent->client->ps.origin, oppDir);
+					VectorNormalize(oppDir);
+					other->client->ps.velocity[0] = oppDir[0]*(strength*40);
+					other->client->ps.velocity[1] = oppDir[1]*(strength*40);
+					other->client->ps.velocity[2] = 150;
+
+					VectorSubtract(ent->client->ps.origin, other->client->ps.origin, oppDir);
+					VectorNormalize(oppDir);
+					ent->client->ps.velocity[0] = oppDir[0]*(strength*40);
+					ent->client->ps.velocity[1] = oppDir[1]*(strength*40);
+					ent->client->ps.velocity[2] = 150;
+				}
+			}
+		}
+	}
+#endif
+#ifdef VM_MEMALLOC_DEBUG
+	else if (Q_stricmp(cmd, "debugTestAlloc") == 0)
+	{ //rww - small routine to stress the malloc trap stuff and make sure nothing bad is happening.
+		char *blah;
+		int i = 1;
+		int x;
+
+		//stress it. Yes, this will take a while. If it doesn't explode miserably in the process.
+		while (i < 32768)
+		{
+			x = 0;
+
+			trap_TrueMalloc((void **)&blah, i);
+			if (!blah)
+			{ //pointer is returned null if allocation failed
+				trap_SendServerCommand( -1, va("print \"Failed to alloc at %i!\n\"", i));
+				break;
+			}
+			while (x < i)
+			{ //fill the allocated memory up to the edge
+				if (x+1 == i)
+				{
+					blah[x] = 0;
+				}
+				else
+				{
+					blah[x] = 'A';
+				}
+				x++;
+			}
+			trap_TrueFree((void **)&blah);
+			if (blah)
+			{ //should be nullified in the engine after being freed
+				trap_SendServerCommand( -1, va("print \"Failed to free at %i!\n\"", i));
+				break;
+			}
+
+			i++;
+		}
+
+		trap_SendServerCommand( -1, "print \"Finished allocation test\n\"");
+	}
+#endif
+#ifndef FINAL_BUILD
+	else if (Q_stricmp(cmd, "debugShipDamage") == 0)
+	{
+		char	arg[MAX_STRING_CHARS];
+		char	arg2[MAX_STRING_CHARS];
+		int		shipSurf, damageLevel;
+
+		trap_Argv( 1, arg, sizeof( arg ) );
+		trap_Argv( 2, arg2, sizeof( arg2 ) );
+		shipSurf = SHIPSURF_FRONT+atoi(arg);
+		damageLevel = atoi(arg2);
+
+		G_SetVehDamageFlags( &g_entities[ent->s.m_iVehicleNum], shipSurf, damageLevel );
+	}
+#endif
+	else
+	{
+		if (Q_stricmp(cmd, "addbot") == 0)
+		{ //because addbot isn't a recognized command unless you're the server, but it is in the menus regardless
+//			trap_SendServerCommand( clientNum, va("print \"You can only add bots as the server.\n\"" ) );
+			trap_SendServerCommand( clientNum, va("print \"%s.\n\"", G_GetStringEdString("MP_SVGAME", "ONLY_ADD_BOTS_AS_SERVER")));
+		}
+		else
+		{
+			trap_SendServerCommand( clientNum, va("print \"unknown cmd %s\n\"", cmd ) );
+		}
+	}
+}
diff --git a/codemp/game/g_combat.c b/codemp/game/g_combat.c
new file mode 100644
index 0000000..306fcd4
--- /dev/null
+++ b/codemp/game/g_combat.c
@@ -0,0 +1,5617 @@
+// Copyright (C) 1999-2000 Id Software, Inc.
+//
+// g_combat.c
+
+//#include "g_local.h"
+#include "b_local.h"
+#include "bg_saga.h"
+
+extern int G_ShipSurfaceForSurfName( const char *surfaceName );
+extern qboolean G_FlyVehicleDestroySurface( gentity_t *veh, int surface );
+extern void G_VehicleSetDamageLocFlags( gentity_t *veh, int impactDir, int deathPoint );
+extern void G_VehUpdateShields( gentity_t *targ );
+extern void G_LetGoOfWall( gentity_t *ent );
+
+//rww - pd
+void BotDamageNotification(gclient_t *bot, gentity_t *attacker);
+//end rww
+
+void ThrowSaberToAttacker(gentity_t *self, gentity_t *attacker);
+
+void ObjectDie (gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int meansOfDeath )
+{
+	if(self->target)
+	{
+		G_UseTargets(self, attacker);
+	}
+
+	//remove my script_targetname
+	G_FreeEntity( self );
+}
+
+qboolean G_HeavyMelee( gentity_t *attacker )
+{
+	if (g_gametype.integer == GT_SIEGE 
+		&& attacker 
+		&& attacker->client
+		&& attacker->client->siegeClass != -1 
+		&& (bgSiegeClasses[attacker->client->siegeClass].classflags & (1<<CFL_HEAVYMELEE)) )
+	{
+		return qtrue;
+	}
+	return qfalse;
+}
+
+int G_GetHitLocation(gentity_t *target, vec3_t ppoint)
+{
+	vec3_t			point, point_dir;
+	vec3_t			forward, right, up;
+	vec3_t			tangles, tcenter;
+	float			tradius;
+	float			udot, fdot, rdot;
+	int				Vertical, Forward, Lateral;
+	int				HitLoc;
+
+	// Get target forward, right and up.
+	if(target->client)
+	{
+		// Ignore player's pitch and roll.
+		VectorSet(tangles, 0, target->r.currentAngles[YAW], 0);
+	}
+
+	AngleVectors(tangles, forward, right, up);
+
+	// Get center of target.
+	VectorAdd(target->r.absmin, target->r.absmax, tcenter);
+	VectorScale(tcenter, 0.5, tcenter);
+
+	// Get radius width of target.
+	tradius = (fabs(target->r.maxs[0]) + fabs(target->r.maxs[1]) + fabs(target->r.mins[0]) + fabs(target->r.mins[1]))/4;
+
+	// Get impact point.
+	if(ppoint && !VectorCompare(ppoint, vec3_origin))
+	{
+		VectorCopy(ppoint, point);
+	}
+	else
+	{
+		return HL_NONE;
+	}
+
+/*
+//get impact dir
+	if(pdir && !VectorCompare(pdir, vec3_origin))
+	{
+		VectorCopy(pdir, dir);
+	}
+	else
+	{
+		return;
+	}
+
+//put point at controlled distance from center
+	VectorSubtract(point, tcenter, tempvec);
+	tempvec[2] = 0;
+	hdist = VectorLength(tempvec);
+
+	VectorMA(point, hdist - tradius, dir, point);
+	//now a point on the surface of a cylinder with a radius of tradius
+*/	
+	VectorSubtract(point, tcenter, point_dir);
+	VectorNormalize(point_dir);
+
+	// Get bottom to top (vertical) position index
+	udot = DotProduct(up, point_dir);
+	if(udot>.800)
+	{
+		Vertical = 4;
+	}
+	else if(udot>.400)
+	{
+		Vertical = 3;
+	}
+	else if(udot>-.333)
+	{
+		Vertical = 2;
+	}
+	else if(udot>-.666)
+	{
+		Vertical = 1;
+	}
+	else
+	{
+		Vertical = 0;
+	}
+
+	// Get back to front (forward) position index.
+	fdot = DotProduct(forward, point_dir);
+	if(fdot>.666)
+	{
+		Forward = 4;
+	}
+	else if(fdot>.333)
+	{
+		Forward = 3;
+	}
+	else if(fdot>-.333)
+	{
+		Forward = 2;
+	}
+	else if(fdot>-.666)
+	{
+		Forward = 1;
+	}
+	else
+	{
+		Forward = 0;
+	}
+
+	// Get left to right (lateral) position index.
+	rdot = DotProduct(right, point_dir);
+	if(rdot>.666)
+	{
+		Lateral = 4;
+	}
+	else if(rdot>.333)
+	{
+		Lateral = 3;
+	}
+	else if(rdot>-.333)
+	{
+		Lateral = 2;
+	}
+	else if(rdot>-.666)
+	{
+		Lateral = 1;
+	}
+	else
+	{
+		Lateral = 0;
+	}
+
+	HitLoc = Vertical * 25 + Forward * 5 + Lateral;
+
+	if(HitLoc <= 10)
+	{
+		// Feet.
+		if ( rdot > 0 )
+		{
+			return HL_FOOT_RT;
+		}
+		else
+		{
+			return HL_FOOT_LT;
+		}
+	}
+	else if(HitLoc <= 50)
+	{
+		// Legs.
+		if ( rdot > 0 )
+		{
+			return HL_LEG_RT;
+		}
+		else
+		{
+			return HL_LEG_LT;
+		}
+	}
+	else if(HitLoc == 56||HitLoc == 60||HitLoc == 61||HitLoc == 65||HitLoc == 66||HitLoc == 70)
+	{
+		// Hands.
+		if ( rdot > 0 )
+		{
+			return HL_HAND_RT;
+		}
+		else
+		{
+			return HL_HAND_LT;
+		}
+	}
+	else if(HitLoc == 83||HitLoc == 87||HitLoc == 88||HitLoc == 92||HitLoc == 93||HitLoc == 97)
+	{
+		// Arms.
+		if ( rdot > 0 )
+		{
+			return HL_ARM_RT;
+		}
+		else
+		{
+			return HL_ARM_LT;
+		}
+	}
+	else if((HitLoc >= 107 && HitLoc <= 109)||(HitLoc >= 112 && HitLoc <= 114)||(HitLoc >= 117 && HitLoc <= 119))
+	{
+		// Head.
+		return HL_HEAD;
+	}
+	else
+	{
+		if(udot < 0.3)
+		{
+			return HL_WAIST;
+		}
+		else if(fdot < 0)
+		{
+			if(rdot > 0.4)
+			{
+				return HL_BACK_RT;
+			}
+			else if(rdot < -0.4)
+			{
+				return HL_BACK_LT;
+			}
+			else if(fdot < 0)
+			{
+				return HL_BACK;
+			}
+		}
+		else
+		{
+			if(rdot > 0.3)
+			{
+				return HL_CHEST_RT;
+			}
+			else if(rdot < -0.3)
+			{
+				return HL_CHEST_LT;
+			}
+			else if(fdot < 0)
+			{
+				return HL_CHEST;
+			}
+		}
+	}
+	return HL_NONE;
+}
+
+/*
+int G_PickPainAnim( gentity_t *self, vec3_t point, int damage )
+{
+	switch( G_GetHitLocation( self, point ) )
+	{
+	case HL_FOOT_RT:
+		return BOTH_PAIN12;
+		//PAIN12 = right foot
+		break;
+	case HL_FOOT_LT:
+		return -1;
+		break;
+	case HL_LEG_RT:
+		if ( !Q_irand( 0, 1 ) )
+		{
+			return BOTH_PAIN11;
+		}
+		else
+		{
+			return BOTH_PAIN13;
+		}
+		//PAIN11 = twitch right leg
+		//PAIN13 = right knee
+		break;
+	case HL_LEG_LT:
+		return BOTH_PAIN14;
+		//PAIN14 = twitch left leg
+		break;
+	case HL_BACK_RT:
+		return BOTH_PAIN7;
+		//PAIN7 = med left shoulder
+		break;
+	case HL_BACK_LT:
+		return Q_irand( BOTH_PAIN15, BOTH_PAIN16 );
+		//PAIN15 = med right shoulder
+		//PAIN16 = twitch right shoulder
+		break;
+	case HL_BACK:
+		if ( !Q_irand( 0, 1 ) )
+		{
+			return BOTH_PAIN1;
+		}
+		else
+		{
+			return BOTH_PAIN5;
+		}
+		//PAIN1 = back
+		//PAIN5 = same as 1
+		break;
+	case HL_CHEST_RT:
+		return BOTH_PAIN3;
+		//PAIN3 = long, right shoulder
+		break;
+	case HL_CHEST_LT:
+		return BOTH_PAIN2;
+		//PAIN2 = long, left shoulder
+		break;
+	case HL_WAIST:
+	case HL_CHEST:
+		if ( !Q_irand( 0, 3 ) )
+		{
+			return BOTH_PAIN6;
+		}
+		else if ( !Q_irand( 0, 2 ) )
+		{
+			return BOTH_PAIN8;
+		}
+		else if ( !Q_irand( 0, 1 ) )
+		{
+			return BOTH_PAIN17;
+		}
+		else
+		{
+			return BOTH_PAIN19;
+		}
+		//PAIN6 = gut
+		//PAIN8 = chest
+		//PAIN17 = twitch crotch
+		//PAIN19 = med crotch
+		break;
+	case HL_ARM_RT:
+	case HL_HAND_RT:
+		return BOTH_PAIN9;
+		//PAIN9 = twitch right arm
+		break;
+	case HL_ARM_LT:
+	case HL_HAND_LT:
+		return BOTH_PAIN10;
+		//PAIN10 = twitch left arm
+		break;
+	case HL_HEAD:
+		return BOTH_PAIN4;
+		//PAIN4 = head
+		break;
+	default:
+		return -1;
+		break;
+	}
+}
+*/
+
+void ExplodeDeath( gentity_t *self ) 
+{
+//	gentity_t	*tent;
+	vec3_t		forward;
+
+	self->takedamage = qfalse;//stop chain reaction runaway loops
+
+	self->s.loopSound = 0;
+	self->s.loopIsSoundset = qfalse;
+
+	VectorCopy( self->r.currentOrigin, self->s.pos.trBase );
+
+//	tent = G_TempEntity( self->s.origin, EV_FX_EXPLOSION );
+	AngleVectors(self->s.angles, forward, NULL, NULL);
+
+/*	
+	if ( self->fxID > 0 )
+	{
+		G_PlayEffect( self->fxID, self->r.currentOrigin, forward );
+	}
+	else
+	*/
+
+	{
+//		CG_SurfaceExplosion( self->r.currentOrigin, forward, 20.0f, 12.0f, ((self->spawnflags&4)==qfalse) );	//FIXME: This needs to be consistent to all exploders!
+//		G_Sound(self, self->sounds );
+	}
+	
+	if(self->splashDamage > 0 && self->splashRadius > 0)
+	{
+		gentity_t *attacker = self;
+		if ( self->parent )
+		{
+			attacker = self->parent;
+		}
+		G_RadiusDamage( self->r.currentOrigin, attacker, self->splashDamage, self->splashRadius, 
+				attacker, NULL, MOD_UNKNOWN );
+	}
+
+	ObjectDie( self, self, self, 20, 0 );
+}
+
+
+/*
+============
+ScorePlum
+============
+*/
+void ScorePlum( gentity_t *ent, vec3_t origin, int score ) {
+	gentity_t *plum;
+
+	plum = G_TempEntity( origin, EV_SCOREPLUM );
+	// only send this temp entity to a single client
+	plum->r.svFlags |= SVF_SINGLECLIENT;
+	plum->r.singleClient = ent->s.number;
+	//
+	plum->s.otherEntityNum = ent->s.number;
+	plum->s.time = score;
+}
+
+/*
+============
+AddScore
+
+Adds score to both the client and his team
+============
+*/
+extern qboolean g_dontPenalizeTeam; //g_cmds.c
+void AddScore( gentity_t *ent, vec3_t origin, int score )
+{
+	/*
+	if (g_gametype.integer == GT_SIEGE)
+	{ //no scoring in this gametype at all.
+		return;
+	}
+	*/
+
+	if ( !ent->client ) {
+		return;
+	}
+	// no scoring during pre-match warmup
+	if ( level.warmupTime ) {
+		return;
+	}
+	// show score plum
+	//ScorePlum(ent, origin, score);
+	//
+	ent->client->ps.persistant[PERS_SCORE] += score;
+	if ( g_gametype.integer == GT_TEAM && !g_dontPenalizeTeam )
+		level.teamScores[ ent->client->ps.persistant[PERS_TEAM] ] += score;
+	CalculateRanks();
+}
+
+/*
+=================
+TossClientItems
+
+rww - Toss the weapon away from the player in the specified direction
+=================
+*/
+void TossClientWeapon(gentity_t *self, vec3_t direction, float speed)
+{
+	vec3_t vel;
+	gitem_t *item;
+	gentity_t *launched;
+	int weapon = self->s.weapon;
+	int ammoSub;
+
+	if (g_gametype.integer == GT_SIEGE)
+	{ //no dropping weaps
+		return;
+	}
+
+	if (weapon <= WP_BRYAR_PISTOL)
+	{ //can't have this
+		return;
+	}
+
+	if (weapon == WP_EMPLACED_GUN ||
+		weapon == WP_TURRET)
+	{
+		return;
+	}
+
+	// find the item type for this weapon
+	item = BG_FindItemForWeapon( weapon );
+
+	ammoSub = (self->client->ps.ammo[weaponData[weapon].ammoIndex] - bg_itemlist[BG_GetItemIndexByTag(weapon, IT_WEAPON)].quantity);
+
+	if (ammoSub < 0)
+	{
+		int ammoQuan = item->quantity;
+		ammoQuan -= (-ammoSub);
+
+		if (ammoQuan <= 0)
+		{ //no ammo
+			return;
+		}
+	}
+
+	vel[0] = direction[0]*speed;
+	vel[1] = direction[1]*speed;
+	vel[2] = direction[2]*speed;
+
+	launched = LaunchItem(item, self->client->ps.origin, vel);
+
+	launched->s.generic1 = self->s.number;
+	launched->s.powerups = level.time + 1500;
+
+	launched->count = bg_itemlist[BG_GetItemIndexByTag(weapon, IT_WEAPON)].quantity;
+
+	self->client->ps.ammo[weaponData[weapon].ammoIndex] -= bg_itemlist[BG_GetItemIndexByTag(weapon, IT_WEAPON)].quantity;
+
+	if (self->client->ps.ammo[weaponData[weapon].ammoIndex] < 0)
+	{
+		launched->count -= (-self->client->ps.ammo[weaponData[weapon].ammoIndex]);
+		self->client->ps.ammo[weaponData[weapon].ammoIndex] = 0;
+	}
+
+	if ((self->client->ps.ammo[weaponData[weapon].ammoIndex] < 1 && weapon != WP_DET_PACK) ||
+		(weapon != WP_THERMAL && weapon != WP_DET_PACK && weapon != WP_TRIP_MINE))
+	{
+		int i = 0;
+		int weap = -1;
+
+		self->client->ps.stats[STAT_WEAPONS] &= ~(1 << weapon);
+
+		while (i < WP_NUM_WEAPONS)
+		{
+			if ((self->client->ps.stats[STAT_WEAPONS] & (1 << i)) && i != WP_NONE)
+			{ //this one's good
+				weap = i;
+				break;
+			}
+			i++;
+		}
+
+		if (weap != -1)
+		{
+			self->s.weapon = weap;
+			self->client->ps.weapon = weap;
+		}
+		else
+		{
+			self->s.weapon = 0;
+			self->client->ps.weapon = 0;
+		}
+
+		G_AddEvent(self, EV_NOAMMO, weapon);
+	}
+}
+
+/*
+=================
+TossClientItems
+
+Toss the weapon and powerups for the killed player
+=================
+*/
+void TossClientItems( gentity_t *self ) {
+	gitem_t		*item;
+	int			weapon;
+	float		angle;
+	int			i;
+	gentity_t	*drop;
+
+	if (g_gametype.integer == GT_SIEGE)
+	{ //just don't drop anything then
+		return;
+	}
+
+	// drop the weapon if not a gauntlet or machinegun
+	weapon = self->s.weapon;
+
+	// make a special check to see if they are changing to a new
+	// weapon that isn't the mg or gauntlet.  Without this, a client
+	// can pick up a weapon, be killed, and not drop the weapon because
+	// their weapon change hasn't completed yet and they are still holding the MG.
+	if ( weapon == WP_BRYAR_PISTOL) {
+		if ( self->client->ps.weaponstate == WEAPON_DROPPING ) {
+			weapon = self->client->pers.cmd.weapon;
+		}
+		if ( !( self->client->ps.stats[STAT_WEAPONS] & ( 1 << weapon ) ) ) {
+			weapon = WP_NONE;
+		}
+	}
+
+	self->s.bolt2 = weapon;
+
+	if ( weapon > WP_BRYAR_PISTOL && 
+		weapon != WP_EMPLACED_GUN &&
+		weapon != WP_TURRET &&
+		self->client->ps.ammo[ weaponData[weapon].ammoIndex ] ) {
+		gentity_t *te;
+
+		// find the item type for this weapon
+		item = BG_FindItemForWeapon( weapon );
+
+		// tell all clients to remove the weapon model on this guy until he respawns
+		te = G_TempEntity( vec3_origin, EV_DESTROY_WEAPON_MODEL );
+		te->r.svFlags |= SVF_BROADCAST;
+		te->s.eventParm = self->s.number;
+
+		// spawn the item
+		Drop_Item( self, item, 0 );
+	}
+
+	// drop all the powerups if not in teamplay
+	if ( g_gametype.integer != GT_TEAM && g_gametype.integer != GT_SIEGE ) {
+		angle = 45;
+		for ( i = 1 ; i < PW_NUM_POWERUPS ; i++ ) {
+			if ( self->client->ps.powerups[ i ] > level.time ) {
+				item = BG_FindItemForPowerup( i );
+				if ( !item ) {
+					continue;
+				}
+				drop = Drop_Item( self, item, angle );
+				// decide how many seconds it has left
+				drop->count = ( self->client->ps.powerups[ i ] - level.time ) / 1000;
+				if ( drop->count < 1 ) {
+					drop->count = 1;
+				}
+				angle += 45;
+			}
+		}
+	}
+}
+
+
+/*
+==================
+LookAtKiller
+==================
+*/
+void LookAtKiller( gentity_t *self, gentity_t *inflictor, gentity_t *attacker ) {
+	vec3_t		dir;
+	vec3_t		angles;
+
+	if ( attacker && attacker != self ) {
+		VectorSubtract (attacker->s.pos.trBase, self->s.pos.trBase, dir);
+	} else if ( inflictor && inflictor != self ) {
+		VectorSubtract (inflictor->s.pos.trBase, self->s.pos.trBase, dir);
+	} else {
+		self->client->ps.stats[STAT_DEAD_YAW] = self->s.angles[YAW];
+		return;
+	}
+
+	self->client->ps.stats[STAT_DEAD_YAW] = vectoyaw ( dir );
+
+	angles[YAW] = vectoyaw ( dir );
+	angles[PITCH] = 0; 
+	angles[ROLL] = 0;
+}
+
+/*
+==================
+GibEntity
+==================
+*/
+void GibEntity( gentity_t *self, int killer ) {
+	G_AddEvent( self, EV_GIB_PLAYER, killer );
+	self->takedamage = qfalse;
+	self->s.eType = ET_INVISIBLE;
+	self->r.contents = 0;
+}
+
+void BodyRid(gentity_t *ent)
+{
+	trap_UnlinkEntity( ent );
+	ent->physicsObject = qfalse;
+}
+
+/*
+==================
+body_die
+==================
+*/
+void body_die( gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int meansOfDeath ) {
+	// NOTENOTE No gibbing right now, this is star wars.
+	qboolean doDisint = qfalse;
+
+	if (self->s.eType == ET_NPC)
+	{ //well, just rem it then, so long as it's done with its death anim and it's not a standard weapon.
+		if ( self->client && self->client->ps.torsoTimer <= 0 &&
+			 (meansOfDeath == MOD_UNKNOWN ||
+			  meansOfDeath == MOD_WATER ||
+			  meansOfDeath == MOD_SLIME ||
+			  meansOfDeath == MOD_LAVA ||
+			  meansOfDeath == MOD_CRUSH ||
+			  meansOfDeath == MOD_TELEFRAG ||
+			  meansOfDeath == MOD_FALLING ||
+			  meansOfDeath == MOD_SUICIDE ||
+			  meansOfDeath == MOD_TARGET_LASER ||
+			  meansOfDeath == MOD_TRIGGER_HURT) )
+		{
+			self->think = G_FreeEntity;
+			self->nextthink = level.time;
+		}
+		return;
+	}
+
+	if (self->health < (GIB_HEALTH+1))
+	{
+		self->health = GIB_HEALTH+1;
+
+		if (self->client && (level.time - self->client->respawnTime) < 2000)
+		{
+			doDisint = qfalse;
+		}
+		else
+		{
+			doDisint = qtrue;
+		}
+	}
+
+	if (self->client && (self->client->ps.eFlags & EF_DISINTEGRATION))
+	{
+		return;
+	}
+	else if (self->s.eFlags & EF_DISINTEGRATION)
+	{
+		return;
+	}
+
+	if (doDisint)
+	{
+		if (self->client)
+		{
+			self->client->ps.eFlags |= EF_DISINTEGRATION;
+			VectorCopy(self->client->ps.origin, self->client->ps.lastHitLoc);
+		}
+		else
+		{
+			self->s.eFlags |= EF_DISINTEGRATION;
+			VectorCopy(self->r.currentOrigin, self->s.origin2);
+
+			//since it's the corpse entity, tell it to "remove" itself
+			self->think = BodyRid;
+			self->nextthink = level.time + 1000;
+		}
+		return;
+	}
+}
+
+
+// these are just for logging, the client prints its own messages
+char	*modNames[MOD_MAX] = {
+	"MOD_UNKNOWN",
+	"MOD_STUN_BATON",
+	"MOD_MELEE",
+	"MOD_SABER",
+	"MOD_BRYAR_PISTOL",
+	"MOD_BRYAR_PISTOL_ALT",
+	"MOD_BLASTER",
+	"MOD_TURBLAST",
+	"MOD_DISRUPTOR",
+	"MOD_DISRUPTOR_SPLASH",
+	"MOD_DISRUPTOR_SNIPER",
+	"MOD_BOWCASTER",
+	"MOD_REPEATER",
+	"MOD_REPEATER_ALT",
+	"MOD_REPEATER_ALT_SPLASH",
+	"MOD_DEMP2",
+	"MOD_DEMP2_ALT",
+	"MOD_FLECHETTE",
+	"MOD_FLECHETTE_ALT_SPLASH",
+	"MOD_ROCKET",
+	"MOD_ROCKET_SPLASH",
+	"MOD_ROCKET_HOMING",
+	"MOD_ROCKET_HOMING_SPLASH",
+	"MOD_THERMAL",
+	"MOD_THERMAL_SPLASH",
+	"MOD_TRIP_MINE_SPLASH",
+	"MOD_TIMED_MINE_SPLASH",
+	"MOD_DET_PACK_SPLASH",
+	"MOD_VEHICLE",
+	"MOD_CONC",
+	"MOD_CONC_ALT",
+	"MOD_FORCE_DARK",
+	"MOD_SENTRY",
+	"MOD_WATER",
+	"MOD_SLIME",
+	"MOD_LAVA",
+	"MOD_CRUSH",
+	"MOD_TELEFRAG",
+	"MOD_FALLING",
+	"MOD_SUICIDE",
+	"MOD_TARGET_LASER",
+	"MOD_TRIGGER_HURT"
+};
+
+
+/*
+==================
+CheckAlmostCapture
+==================
+*/
+void CheckAlmostCapture( gentity_t *self, gentity_t *attacker ) {
+#if 0
+	gentity_t	*ent;
+	vec3_t		dir;
+	char		*classname;
+
+	// if this player was carrying a flag
+	if ( self->client->ps.powerups[PW_REDFLAG] ||
+		self->client->ps.powerups[PW_BLUEFLAG] ||
+		self->client->ps.powerups[PW_NEUTRALFLAG] ) {
+		// get the goal flag this player should have been going for
+		if ( g_gametype.integer == GT_CTF || g_gametype.integer == GT_CTY ) {
+			if ( self->client->sess.sessionTeam == TEAM_BLUE ) {
+				classname = "team_CTF_blueflag";
+			}
+			else {
+				classname = "team_CTF_redflag";
+			}
+		}
+		else {
+			if ( self->client->sess.sessionTeam == TEAM_BLUE ) {
+				classname = "team_CTF_redflag";
+			}
+			else {
+				classname = "team_CTF_blueflag";
+			}
+		}
+		ent = NULL;
+		do
+		{
+			ent = G_Find(ent, FOFS(classname), classname);
+		} while (ent && (ent->flags & FL_DROPPED_ITEM));
+		// if we found the destination flag and it's not picked up
+		if (ent && !(ent->r.svFlags & SVF_NOCLIENT) ) {
+			// if the player was *very* close
+			VectorSubtract( self->client->ps.origin, ent->s.origin, dir );
+			if ( VectorLength(dir) < 200 ) {
+				self->client->ps.persistant[PERS_PLAYEREVENTS] ^= PLAYEREVENT_HOLYSHIT;
+				if ( attacker->client ) {
+					attacker->client->ps.persistant[PERS_PLAYEREVENTS] ^= PLAYEREVENT_HOLYSHIT;
+				}
+			}
+		}
+	}
+#endif
+}
+
+qboolean G_InKnockDown( playerState_t *ps )
+{
+	switch ( (ps->legsAnim) )
+	{
+	case BOTH_KNOCKDOWN1:
+	case BOTH_KNOCKDOWN2:
+	case BOTH_KNOCKDOWN3:
+	case BOTH_KNOCKDOWN4:
+	case BOTH_KNOCKDOWN5:
+		return qtrue;
+		break;
+	case BOTH_GETUP1:
+	case BOTH_GETUP2:
+	case BOTH_GETUP3:
+	case BOTH_GETUP4:
+	case BOTH_GETUP5:
+	case BOTH_FORCE_GETUP_F1:
+	case BOTH_FORCE_GETUP_F2:
+	case BOTH_FORCE_GETUP_B1:
+	case BOTH_FORCE_GETUP_B2:
+	case BOTH_FORCE_GETUP_B3:
+	case BOTH_FORCE_GETUP_B4:
+	case BOTH_FORCE_GETUP_B5:
+		return qtrue;
+		break;
+	}
+	return qfalse;
+}
+
+static int G_CheckSpecialDeathAnim( gentity_t *self, vec3_t point, int damage, int mod, int hitLoc )
+{
+	int deathAnim = -1;
+
+	if ( BG_InRoll( &self->client->ps, self->client->ps.legsAnim ) )
+	{
+		deathAnim = BOTH_DEATH_ROLL;		//# Death anim from a roll
+	}
+	else if ( BG_FlippingAnim( self->client->ps.legsAnim ) )
+	{
+		deathAnim = BOTH_DEATH_FLIP;		//# Death anim from a flip
+	}
+	else if ( G_InKnockDown( &self->client->ps ) )
+	{//since these happen a lot, let's handle them case by case
+		int animLength = bgAllAnims[self->localAnimIndex].anims[self->client->ps.legsAnim].numFrames * fabs((float)(bgHumanoidAnimations[self->client->ps.legsAnim].frameLerp));
+		switch ( self->client->ps.legsAnim )
+		{
+		case BOTH_KNOCKDOWN1:
+			if ( animLength - self->client->ps.legsTimer > 100 )
+			{//on our way down
+				if ( self->client->ps.legsTimer > 600 )
+				{//still partially up
+					deathAnim = BOTH_DEATH_FALLING_UP;
+				}
+				else
+				{//down
+					deathAnim = BOTH_DEATH_LYING_UP;
+				}
+			}
+			break;
+		case BOTH_KNOCKDOWN2:
+			if ( animLength - self->client->ps.legsTimer > 700 )
+			{//on our way down
+				if ( self->client->ps.legsTimer > 600 )
+				{//still partially up
+					deathAnim = BOTH_DEATH_FALLING_UP;
+				}
+				else
+				{//down
+					deathAnim = BOTH_DEATH_LYING_UP;
+				}
+			}
+			break;
+		case BOTH_KNOCKDOWN3:
+			if ( animLength - self->client->ps.legsTimer > 100 )
+			{//on our way down
+				if ( self->client->ps.legsTimer > 1300 )
+				{//still partially up
+					deathAnim = BOTH_DEATH_FALLING_DN;
+				}
+				else
+				{//down
+					deathAnim = BOTH_DEATH_LYING_DN;
+				}
+			}
+			break;
+		case BOTH_KNOCKDOWN4:
+			if ( animLength - self->client->ps.legsTimer > 300 )
+			{//on our way down
+				if ( self->client->ps.legsTimer > 350 )
+				{//still partially up
+					deathAnim = BOTH_DEATH_FALLING_UP;
+				}
+				else
+				{//down
+					deathAnim = BOTH_DEATH_LYING_UP;
+				}
+			}
+			else
+			{//crouch death
+				vec3_t fwd;
+				float thrown = 0;
+
+				AngleVectors( self->client->ps.viewangles, fwd, NULL, NULL );
+				thrown = DotProduct( fwd, self->client->ps.velocity );
+
+				if ( thrown < -150 )
+				{
+					deathAnim = BOTH_DEATHBACKWARD1;	//# Death anim when crouched and thrown back
+				}
+				else
+				{
+					deathAnim = BOTH_DEATH_CROUCHED;	//# Death anim when crouched
+				}
+			}
+			break;
+		case BOTH_KNOCKDOWN5:
+			if ( self->client->ps.legsTimer < 750 )
+			{//flat
+				deathAnim = BOTH_DEATH_LYING_DN;
+			}
+			break;
+		case BOTH_GETUP1:
+			if ( self->client->ps.legsTimer < 350 )
+			{//standing up
+			}
+			else if ( self->client->ps.legsTimer < 800 )
+			{//crouching
+				vec3_t fwd;
+				float thrown = 0;
+
+				AngleVectors( self->client->ps.viewangles, fwd, NULL, NULL );
+				thrown = DotProduct( fwd, self->client->ps.velocity );
+				if ( thrown < -150 )
+				{
+					deathAnim = BOTH_DEATHBACKWARD1;	//# Death anim when crouched and thrown back
+				}
+				else
+				{
+					deathAnim = BOTH_DEATH_CROUCHED;	//# Death anim when crouched
+				}
+			}
+			else
+			{//lying down
+				if ( animLength - self->client->ps.legsTimer > 450 )
+				{//partially up
+					deathAnim = BOTH_DEATH_FALLING_UP;
+				}
+				else
+				{//down
+					deathAnim = BOTH_DEATH_LYING_UP;
+				}
+			}
+			break;
+		case BOTH_GETUP2:
+			if ( self->client->ps.legsTimer < 150 )
+			{//standing up
+			}
+			else if ( self->client->ps.legsTimer < 850 )
+			{//crouching
+				vec3_t fwd;
+				float thrown = 0;
+
+				AngleVectors( self->client->ps.viewangles, fwd, NULL, NULL );
+				thrown = DotProduct( fwd, self->client->ps.velocity );
+
+				if ( thrown < -150 )
+				{
+					deathAnim = BOTH_DEATHBACKWARD1;	//# Death anim when crouched and thrown back
+				}
+				else
+				{
+					deathAnim = BOTH_DEATH_CROUCHED;	//# Death anim when crouched
+				}
+			}
+			else
+			{//lying down
+				if ( animLength - self->client->ps.legsTimer > 500 )
+				{//partially up
+					deathAnim = BOTH_DEATH_FALLING_UP;
+				}
+				else
+				{//down
+					deathAnim = BOTH_DEATH_LYING_UP;
+				}
+			}
+			break;
+		case BOTH_GETUP3:
+			if ( self->client->ps.legsTimer < 250 )
+			{//standing up
+			}
+			else if ( self->client->ps.legsTimer < 600 )
+			{//crouching
+				vec3_t fwd;
+				float thrown = 0;
+				AngleVectors( self->client->ps.viewangles, fwd, NULL, NULL );
+				thrown = DotProduct( fwd, self->client->ps.velocity );
+
+				if ( thrown < -150 )
+				{
+					deathAnim = BOTH_DEATHBACKWARD1;	//# Death anim when crouched and thrown back
+				}
+				else
+				{
+					deathAnim = BOTH_DEATH_CROUCHED;	//# Death anim when crouched
+				}
+			}
+			else
+			{//lying down
+				if ( animLength - self->client->ps.legsTimer > 150 )
+				{//partially up
+					deathAnim = BOTH_DEATH_FALLING_DN;
+				}
+				else
+				{//down
+					deathAnim = BOTH_DEATH_LYING_DN;
+				}
+			}
+			break;
+		case BOTH_GETUP4:
+			if ( self->client->ps.legsTimer < 250 )
+			{//standing up
+			}
+			else if ( self->client->ps.legsTimer < 600 )
+			{//crouching
+				vec3_t fwd;
+				float thrown = 0;
+
+				AngleVectors( self->client->ps.viewangles, fwd, NULL, NULL );
+				thrown = DotProduct( fwd, self->client->ps.velocity );
+
+				if ( thrown < -150 )
+				{
+					deathAnim = BOTH_DEATHBACKWARD1;	//# Death anim when crouched and thrown back
+				}
+				else
+				{
+					deathAnim = BOTH_DEATH_CROUCHED;	//# Death anim when crouched
+				}
+			}
+			else
+			{//lying down
+				if ( animLength - self->client->ps.legsTimer > 850 )
+				{//partially up
+					deathAnim = BOTH_DEATH_FALLING_DN;
+				}
+				else
+				{//down
+					deathAnim = BOTH_DEATH_LYING_UP;
+				}
+			}
+			break;
+		case BOTH_GETUP5:
+			if ( self->client->ps.legsTimer > 850 )
+			{//lying down
+				if ( animLength - self->client->ps.legsTimer > 1500 )
+				{//partially up
+					deathAnim = BOTH_DEATH_FALLING_DN;
+				}
+				else
+				{//down
+					deathAnim = BOTH_DEATH_LYING_DN;
+				}
+			}
+			break;
+		case BOTH_GETUP_CROUCH_B1:
+			if ( self->client->ps.legsTimer < 800 )
+			{//crouching
+				vec3_t fwd;
+				float thrown = 0;
+
+				AngleVectors( self->client->ps.viewangles, fwd, NULL, NULL );
+				thrown = DotProduct( fwd, self->client->ps.velocity );
+
+				if ( thrown < -150 )
+				{
+					deathAnim = BOTH_DEATHBACKWARD1;	//# Death anim when crouched and thrown back
+				}
+				else
+				{
+					deathAnim = BOTH_DEATH_CROUCHED;	//# Death anim when crouched
+				}
+			}
+			else
+			{//lying down
+				if ( animLength - self->client->ps.legsTimer > 400 )
+				{//partially up
+					deathAnim = BOTH_DEATH_FALLING_UP;
+				}
+				else
+				{//down
+					deathAnim = BOTH_DEATH_LYING_UP;
+				}
+			}
+			break;
+		case BOTH_GETUP_CROUCH_F1:
+			if ( self->client->ps.legsTimer < 800 )
+			{//crouching
+				vec3_t fwd;
+				float thrown = 0;
+
+				AngleVectors( self->client->ps.viewangles, fwd, NULL, NULL );
+				thrown = DotProduct( fwd, self->client->ps.velocity );
+
+				if ( thrown < -150 )
+				{
+					deathAnim = BOTH_DEATHBACKWARD1;	//# Death anim when crouched and thrown back
+				}
+				else
+				{
+					deathAnim = BOTH_DEATH_CROUCHED;	//# Death anim when crouched
+				}
+			}
+			else
+			{//lying down
+				if ( animLength - self->client->ps.legsTimer > 150 )
+				{//partially up
+					deathAnim = BOTH_DEATH_FALLING_DN;
+				}
+				else
+				{//down
+					deathAnim = BOTH_DEATH_LYING_DN;
+				}
+			}
+			break;
+		case BOTH_FORCE_GETUP_B1:
+			if ( self->client->ps.legsTimer < 325 )
+			{//standing up
+			}
+			else if ( self->client->ps.legsTimer < 725 )
+			{//spinning up
+				deathAnim = BOTH_DEATH_SPIN_180;	//# Death anim when facing backwards
+			}
+			else if ( self->client->ps.legsTimer < 900 )
+			{//crouching
+				vec3_t fwd;
+				float thrown = 0;
+
+				AngleVectors( self->client->ps.viewangles, fwd, NULL, NULL );
+				thrown = DotProduct( fwd, self->client->ps.velocity );
+
+				if ( thrown < -150 )
+				{
+					deathAnim = BOTH_DEATHBACKWARD1;	//# Death anim when crouched and thrown back
+				}
+				else
+				{
+					deathAnim = BOTH_DEATH_CROUCHED;	//# Death anim when crouched
+				}
+			}
+			else
+			{//lying down
+				if ( animLength - self->client->ps.legsTimer > 50 )
+				{//partially up
+					deathAnim = BOTH_DEATH_FALLING_UP;
+				}
+				else
+				{//down
+					deathAnim = BOTH_DEATH_LYING_UP;
+				}
+			}
+			break;
+		case BOTH_FORCE_GETUP_B2:
+			if ( self->client->ps.legsTimer < 575 )
+			{//standing up
+			}
+			else if ( self->client->ps.legsTimer < 875 )
+			{//spinning up
+				deathAnim = BOTH_DEATH_SPIN_180;	//# Death anim when facing backwards
+			}
+			else if ( self->client->ps.legsTimer < 900 )
+			{//crouching
+				vec3_t fwd;
+				float thrown = 0;
+
+				AngleVectors( self->client->ps.viewangles, fwd, NULL, NULL );
+				thrown = DotProduct( fwd, self->client->ps.velocity );
+
+				if ( thrown < -150 )
+				{
+					deathAnim = BOTH_DEATHBACKWARD1;	//# Death anim when crouched and thrown back
+				}
+				else
+				{
+					deathAnim = BOTH_DEATH_CROUCHED;	//# Death anim when crouched
+				}
+			}
+			else
+			{//lying down
+				//partially up
+				deathAnim = BOTH_DEATH_FALLING_UP;
+			}
+			break;
+		case BOTH_FORCE_GETUP_B3:
+			if ( self->client->ps.legsTimer < 150 )
+			{//standing up
+			}
+			else if ( self->client->ps.legsTimer < 775 )
+			{//flipping
+				deathAnim = BOTH_DEATHBACKWARD2; //backflip
+			}
+			else
+			{//lying down
+				//partially up
+				deathAnim = BOTH_DEATH_FALLING_UP;
+			}
+			break;
+		case BOTH_FORCE_GETUP_B4:
+			if ( self->client->ps.legsTimer < 325 )
+			{//standing up
+			}
+			else
+			{//lying down
+				if ( animLength - self->client->ps.legsTimer > 150 )
+				{//partially up
+					deathAnim = BOTH_DEATH_FALLING_UP;
+				}
+				else
+				{//down
+					deathAnim = BOTH_DEATH_LYING_UP;
+				}
+			}
+			break;
+		case BOTH_FORCE_GETUP_B5:
+			if ( self->client->ps.legsTimer < 550 )
+			{//standing up
+			}
+			else if ( self->client->ps.legsTimer < 1025 )
+			{//kicking up
+				deathAnim = BOTH_DEATHBACKWARD2; //backflip
+			}
+			else
+			{//lying down
+				if ( animLength - self->client->ps.legsTimer > 50 )
+				{//partially up
+					deathAnim = BOTH_DEATH_FALLING_UP;
+				}
+				else
+				{//down
+					deathAnim = BOTH_DEATH_LYING_UP;
+				}
+			}
+			break;
+		case BOTH_FORCE_GETUP_B6:
+			if ( self->client->ps.legsTimer < 225 )
+			{//standing up
+			}
+			else if ( self->client->ps.legsTimer < 425 )
+			{//crouching up
+				vec3_t fwd;
+				float thrown = 0;
+
+				AngleVectors( self->client->ps.viewangles, fwd, NULL, NULL );
+				thrown = DotProduct( fwd, self->client->ps.velocity );
+
+				if ( thrown < -150 )
+				{
+					deathAnim = BOTH_DEATHBACKWARD1;	//# Death anim when crouched and thrown back
+				}
+				else
+				{
+					deathAnim = BOTH_DEATH_CROUCHED;	//# Death anim when crouched
+				}
+			}
+			else if ( self->client->ps.legsTimer < 825 )
+			{//flipping up
+				deathAnim = BOTH_DEATHFORWARD3; //backflip
+			}
+			else
+			{//lying down
+				if ( animLength - self->client->ps.legsTimer > 225 )
+				{//partially up
+					deathAnim = BOTH_DEATH_FALLING_UP;
+				}
+				else
+				{//down
+					deathAnim = BOTH_DEATH_LYING_UP;
+				}
+			}
+			break;
+		case BOTH_FORCE_GETUP_F1:
+			if ( self->client->ps.legsTimer < 275 )
+			{//standing up
+			}
+			else if ( self->client->ps.legsTimer < 750 )
+			{//flipping
+				deathAnim = BOTH_DEATH14;
+			}
+			else
+			{//lying down
+				if ( animLength - self->client->ps.legsTimer > 100 )
+				{//partially up
+					deathAnim = BOTH_DEATH_FALLING_DN;
+				}
+				else
+				{//down
+					deathAnim = BOTH_DEATH_LYING_DN;
+				}
+			}
+			break;
+		case BOTH_FORCE_GETUP_F2:
+			if ( self->client->ps.legsTimer < 1200 )
+			{//standing
+			}
+			else
+			{//lying down
+				if ( animLength - self->client->ps.legsTimer > 225 )
+				{//partially up
+					deathAnim = BOTH_DEATH_FALLING_DN;
+				}
+				else
+				{//down
+					deathAnim = BOTH_DEATH_LYING_DN;
+				}
+			}
+			break;
+		}
+	}
+
+	return deathAnim;
+}
+
+int G_PickDeathAnim( gentity_t *self, vec3_t point, int damage, int mod, int hitLoc )
+{//FIXME: play dead flop anims on body if in an appropriate _DEAD anim when this func is called
+	int deathAnim = -1;
+	int max_health;
+	int legAnim = 0;
+	vec3_t objVelocity;
+
+	if (!self || !self->client)
+	{
+		if (!self || self->s.eType != ET_NPC)
+		{ //g2animent
+			return 0;
+		}
+	}
+
+	if (self->client)
+	{
+		max_health = self->client->ps.stats[STAT_MAX_HEALTH];
+
+		if (self->client->inSpaceIndex && self->client->inSpaceIndex != ENTITYNUM_NONE)
+		{
+			return BOTH_CHOKE3;
+		}
+	}
+	else
+	{
+		max_health = 60;
+	}
+
+	if (self->client)
+	{
+		VectorCopy(self->client->ps.velocity, objVelocity);
+	}
+	else
+	{
+		VectorCopy(self->s.pos.trDelta, objVelocity);
+	}
+
+	if ( hitLoc == HL_NONE )
+	{
+		hitLoc = G_GetHitLocation( self, point );//self->hitLoc
+	}
+
+	if (self->client)
+	{
+		legAnim = self->client->ps.legsAnim;
+	}
+	else
+	{
+		legAnim = self->s.legsAnim;
+	}
+
+	if (gGAvoidDismember)
+	{
+		return BOTH_RIGHTHANDCHOPPEDOFF;
+	}
+
+	//dead flops
+	switch( legAnim )
+	{
+	case BOTH_DEATH1:		//# First Death anim
+	case BOTH_DEAD1:
+	case BOTH_DEATH2:			//# Second Death anim
+	case BOTH_DEAD2:
+	case BOTH_DEATH8:			//# 
+	case BOTH_DEAD8:
+	case BOTH_DEATH13:			//# 
+	case BOTH_DEAD13:
+	case BOTH_DEATH14:			//# 
+	case BOTH_DEAD14:
+	case BOTH_DEATH16:			//# 
+	case BOTH_DEAD16:
+	case BOTH_DEADBACKWARD1:		//# First thrown backward death finished pose
+	case BOTH_DEADBACKWARD2:		//# Second thrown backward death finished pose
+		deathAnim = -2;
+		/*
+		if ( PM_FinishedCurrentLegsAnim( self ) )
+		{//done with the anim
+			deathAnim = BOTH_DEADFLOP2;
+		}
+		else
+		{
+			deathAnim = -2;
+		}
+		break;
+	case BOTH_DEADFLOP2:
+		deathAnim = BOTH_DEADFLOP2;
+		break;
+		*/
+	case BOTH_DEATH10:			//# 
+	case BOTH_DEAD10:
+	case BOTH_DEATH15:			//# 
+	case BOTH_DEAD15:
+	case BOTH_DEADFORWARD1:		//# First thrown forward death finished pose
+	case BOTH_DEADFORWARD2:		//# Second thrown forward death finished pose
+		deathAnim = -2;
+		/*
+		if ( PM_FinishedCurrentLegsAnim( self ) )
+		{//done with the anim
+			deathAnim = BOTH_DEADFLOP1;
+		}
+		else
+		{
+			deathAnim = -2;
+		}
+		break;
+		*/
+	case BOTH_DEADFLOP1:
+		deathAnim = -2;
+		//deathAnim = BOTH_DEADFLOP1;
+		break;
+	case BOTH_DEAD3:				//# Third Death finished pose
+	case BOTH_DEAD4:				//# Fourth Death finished pose
+	case BOTH_DEAD5:				//# Fifth Death finished pose
+	case BOTH_DEAD6:				//# Sixth Death finished pose
+	case BOTH_DEAD7:				//# Seventh Death finished pose
+	case BOTH_DEAD9:				//# 
+	case BOTH_DEAD11:			//#
+	case BOTH_DEAD12:			//# 
+	case BOTH_DEAD17:			//# 
+	case BOTH_DEAD18:			//# 
+	case BOTH_DEAD19:			//# 
+	case BOTH_LYINGDEAD1:		//# Killed lying down death finished pose
+	case BOTH_STUMBLEDEAD1:		//# Stumble forward death finished pose
+	case BOTH_FALLDEAD1LAND:		//# Fall forward and splat death finished pose
+	case BOTH_DEATH3:			//# Third Death anim
+	case BOTH_DEATH4:			//# Fourth Death anim
+	case BOTH_DEATH5:			//# Fifth Death anim
+	case BOTH_DEATH6:			//# Sixth Death anim
+	case BOTH_DEATH7:			//# Seventh Death anim
+	case BOTH_DEATH9:			//# 
+	case BOTH_DEATH11:			//#
+	case BOTH_DEATH12:			//# 
+	case BOTH_DEATH17:			//# 
+	case BOTH_DEATH18:			//# 
+	case BOTH_DEATH19:			//# 
+	case BOTH_DEATHFORWARD1:		//# First Death in which they get thrown forward
+	case BOTH_DEATHFORWARD2:		//# Second Death in which they get thrown forward
+	case BOTH_DEATHBACKWARD1:	//# First Death in which they get thrown backward
+	case BOTH_DEATHBACKWARD2:	//# Second Death in which they get thrown backward
+	case BOTH_DEATH1IDLE:		//# Idle while close to death
+	case BOTH_LYINGDEATH1:		//# Death to play when killed lying down
+	case BOTH_STUMBLEDEATH1:		//# Stumble forward and fall face first death
+	case BOTH_FALLDEATH1:		//# Fall forward off a high cliff and splat death - start
+	case BOTH_FALLDEATH1INAIR:	//# Fall forward off a high cliff and splat death - loop
+	case BOTH_FALLDEATH1LAND:	//# Fall forward off a high cliff and splat death - hit bottom
+		deathAnim = -2;
+		break;
+	}
+	if ( deathAnim == -1 )
+	{
+		if (self->client)
+		{
+			deathAnim = G_CheckSpecialDeathAnim( self, point, damage, mod, hitLoc );
+		}
+
+		if (deathAnim == -1)
+		{
+			//death anims
+			switch( hitLoc )
+			{
+			case HL_FOOT_RT:
+			case HL_FOOT_LT:
+				if ( mod == MOD_SABER && !Q_irand( 0, 2 ) )
+				{
+					return BOTH_DEATH10;//chest: back flip
+				}
+				else if ( !Q_irand( 0, 2 ) )
+				{
+					deathAnim = BOTH_DEATH4;//back: forward
+				}
+				else if ( !Q_irand( 0, 1 ) )
+				{
+					deathAnim = BOTH_DEATH5;//same as 4
+				}
+				else
+				{
+					deathAnim = BOTH_DEATH15;//back: forward
+				}
+				break;
+			case HL_LEG_RT:
+				if ( !Q_irand( 0, 2 ) )
+				{
+					deathAnim = BOTH_DEATH4;//back: forward
+				}
+				else if ( !Q_irand( 0, 1 ) )
+				{
+					deathAnim = BOTH_DEATH5;//same as 4
+				}
+				else
+				{
+					deathAnim = BOTH_DEATH15;//back: forward
+				}
+				break;
+			case HL_LEG_LT:
+				if ( !Q_irand( 0, 2 ) )
+				{
+					deathAnim = BOTH_DEATH4;//back: forward
+				}
+				else if ( !Q_irand( 0, 1 ) )
+				{
+					deathAnim = BOTH_DEATH5;//same as 4
+				}
+				else
+				{
+					deathAnim = BOTH_DEATH15;//back: forward
+				}
+				break;
+			case HL_BACK:
+				if ( !VectorLengthSquared( objVelocity ) )
+				{
+					deathAnim = BOTH_DEATH17;//head/back: croak
+				}
+				else
+				{
+					if ( !Q_irand( 0, 2 ) )
+					{
+						deathAnim = BOTH_DEATH4;//back: forward
+					}
+					else if ( !Q_irand( 0, 1 ) )
+					{
+						deathAnim = BOTH_DEATH5;//same as 4
+					}
+					else
+					{
+						deathAnim = BOTH_DEATH15;//back: forward
+					}
+				}
+				break;
+			case HL_CHEST_RT:
+			case HL_ARM_RT:
+			case HL_HAND_RT:
+			case HL_BACK_RT:
+				if ( damage <= max_health*0.25 )
+				{
+					deathAnim = BOTH_DEATH9;//chest right: snap, fall forward
+				}
+				else if ( damage <= max_health*0.5 )
+				{
+					deathAnim = BOTH_DEATH3;//chest right: back
+				}
+				else if ( damage <= max_health*0.75 )
+				{
+					deathAnim = BOTH_DEATH6;//chest right: spin
+				}
+				else 
+				{
+					//TEMP HACK: play spinny deaths less often
+					if ( Q_irand( 0, 1 ) )
+					{
+						deathAnim = BOTH_DEATH8;//chest right: spin high
+					}
+					else
+					{
+						switch ( Q_irand( 0, 2 ) )
+						{
+						default:
+						case 0:
+							deathAnim = BOTH_DEATH9;//chest right: snap, fall forward
+							break;
+						case 1:
+							deathAnim = BOTH_DEATH3;//chest right: back
+							break;
+						case 2:
+							deathAnim = BOTH_DEATH6;//chest right: spin
+							break;
+						}
+					}
+				}
+				break;
+			case HL_CHEST_LT:
+			case HL_ARM_LT:
+			case HL_HAND_LT:
+			case HL_BACK_LT:
+				if ( damage <= max_health*0.25 )
+				{
+					deathAnim = BOTH_DEATH11;//chest left: snap, fall forward
+				}
+				else if ( damage <= max_health*0.5 )
+				{
+					deathAnim = BOTH_DEATH7;//chest left: back
+				}
+				else if ( damage <= max_health*0.75 )
+				{
+					deathAnim = BOTH_DEATH12;//chest left: spin
+				}
+				else
+				{
+					//TEMP HACK: play spinny deaths less often
+					if ( Q_irand( 0, 1 ) )
+					{
+						deathAnim = BOTH_DEATH14;//chest left: spin high
+					}
+					else
+					{
+						switch ( Q_irand( 0, 2 ) )
+						{
+						default:
+						case 0:
+							deathAnim = BOTH_DEATH11;//chest left: snap, fall forward
+							break;
+						case 1:
+							deathAnim = BOTH_DEATH7;//chest left: back
+							break;
+						case 2:
+							deathAnim = BOTH_DEATH12;//chest left: spin
+							break;
+						}
+					}
+				}
+				break;
+			case HL_CHEST:
+			case HL_WAIST:
+				if ( damage <= max_health*0.25 || !VectorLengthSquared( objVelocity ) )
+				{
+					if ( !Q_irand( 0, 1 ) )
+					{
+						deathAnim = BOTH_DEATH18;//gut: fall right
+					}
+					else
+					{
+						deathAnim = BOTH_DEATH19;//gut: fall left
+					}
+				}
+				else if ( damage <= max_health*0.5 )
+				{
+					deathAnim = BOTH_DEATH2;//chest: backward short
+				}
+				else if ( damage <= max_health*0.75 )
+				{
+					if ( !Q_irand( 0, 1 ) )
+					{
+						deathAnim = BOTH_DEATH1;//chest: backward med
+					}
+					else
+					{
+						deathAnim = BOTH_DEATH16;//same as 1
+					}
+				}
+				else
+				{
+					deathAnim = BOTH_DEATH10;//chest: back flip
+				}
+				break;
+			case HL_HEAD:
+				if ( damage <= max_health*0.5 )
+				{
+					deathAnim = BOTH_DEATH17;//head/back: croak
+				}
+				else
+				{
+					deathAnim = BOTH_DEATH13;//head: stumble, fall back
+				}
+				break;
+			default:
+				break;
+			}
+		}
+	}
+
+	// Validate.....
+	if ( deathAnim == -1 || !BG_HasAnimation( self->localAnimIndex, deathAnim ))
+	{
+		// I guess we'll take what we can get.....
+		deathAnim = BG_PickAnim( self->localAnimIndex, BOTH_DEATH1, BOTH_DEATH25 );
+	}
+
+	return deathAnim;
+}
+
+gentity_t *G_GetJediMaster(void)
+{
+	int i = 0;
+	gentity_t *ent;
+
+	while (i < MAX_CLIENTS)
+	{
+		ent = &g_entities[i];
+
+		if (ent && ent->inuse && ent->client && ent->client->ps.isJediMaster)
+		{
+			return ent;
+		}
+
+		i++;
+	}
+
+	return NULL;
+}
+
+/*
+-------------------------
+G_AlertTeam
+-------------------------
+*/
+
+void G_AlertTeam( gentity_t *victim, gentity_t *attacker, float radius, float soundDist )
+{
+	int			radiusEnts[ 128 ];
+	gentity_t	*check;
+	vec3_t		mins, maxs;
+	int			numEnts;
+	int			i;
+	float		distSq, sndDistSq = (soundDist*soundDist);
+
+	if ( attacker == NULL || attacker->client == NULL )
+		return;
+
+	//Setup the bbox to search in
+	for ( i = 0; i < 3; i++ )
+	{
+		mins[i] = victim->r.currentOrigin[i] - radius;
+		maxs[i] = victim->r.currentOrigin[i] + radius;
+	}
+
+	//Get the number of entities in a given space
+	numEnts = trap_EntitiesInBox( mins, maxs, radiusEnts, 128 );
+
+	//Cull this list
+	for ( i = 0; i < numEnts; i++ )
+	{
+		check = &g_entities[radiusEnts[i]];
+
+		//Validate clients
+		if ( check->client == NULL )
+			continue;
+
+		//only want NPCs
+		if ( check->NPC == NULL )
+			continue;
+
+		//Don't bother if they're ignoring enemies
+//		if ( check->svFlags & SVF_IGNORE_ENEMIES )
+//			continue;
+
+		//This NPC specifically flagged to ignore alerts
+		if ( check->NPC->scriptFlags & SCF_IGNORE_ALERTS )
+			continue;
+
+		//This NPC specifically flagged to ignore alerts
+		if ( !(check->NPC->scriptFlags&SCF_LOOK_FOR_ENEMIES) )
+			continue;
+
+		//this ent does not participate in group AI
+		if ( (check->NPC->scriptFlags&SCF_NO_GROUPS) )
+			continue;
+
+		//Skip the requested avoid check if present
+		if ( check == victim )
+			continue;
+
+		//Skip the attacker
+		if ( check == attacker )
+			continue;
+
+		//Must be on the same team
+		if ( check->client->playerTeam != victim->client->playerTeam )
+			continue;
+
+		//Must be alive
+		if ( check->health <= 0 )
+			continue;
+
+		if ( check->enemy == NULL )
+		{//only do this if they're not already mad at someone
+			distSq = DistanceSquared( check->r.currentOrigin, victim->r.currentOrigin );
+			if ( distSq > 16384 /*128 squared*/ && !trap_InPVS( victim->r.currentOrigin, check->r.currentOrigin ) )
+			{//not even potentially visible/hearable
+				continue;
+			}
+			//NOTE: this allows sound alerts to still go through doors/PVS if the teammate is within 128 of the victim...
+			if ( soundDist <= 0 || distSq > sndDistSq )
+			{//out of sound range
+				if ( !InFOV( victim, check, check->NPC->stats.hfov, check->NPC->stats.vfov ) 
+					||  !NPC_ClearLOS2( check, victim->r.currentOrigin ) )
+				{//out of FOV or no LOS
+					continue;
+				}
+			}
+
+			//FIXME: This can have a nasty cascading effect if setup wrong...
+			G_SetEnemy( check, attacker );
+		}
+	}
+}
+
+/*
+-------------------------
+G_DeathAlert
+-------------------------
+*/
+
+#define	DEATH_ALERT_RADIUS			512
+#define	DEATH_ALERT_SOUND_RADIUS	512
+
+void G_DeathAlert( gentity_t *victim, gentity_t *attacker )
+{//FIXME: with all the other alert stuff, do we really need this?
+	G_AlertTeam( victim, attacker, DEATH_ALERT_RADIUS, DEATH_ALERT_SOUND_RADIUS );
+}
+
+/*
+----------------------------------------
+DeathFX
+
+Applies appropriate special effects that occur while the entity is dying
+Not to be confused with NPC_RemoveBodyEffects (NPC.cpp), which only applies effect when removing the body
+----------------------------------------
+*/
+
+void DeathFX( gentity_t *ent )
+{
+	vec3_t		effectPos, right;
+	vec3_t		defaultDir;
+
+	if ( !ent || !ent->client )
+		return;
+
+	VectorSet(defaultDir, 0, 0, 1);
+
+	// team no longer indicates species/race.  NPC_class should be used to identify certain npc types
+	switch(ent->client->NPC_class)
+	{
+	case CLASS_MOUSE:
+		VectorCopy( ent->r.currentOrigin, effectPos );
+		effectPos[2] -= 20;
+		G_PlayEffectID( G_EffectIndex("env/small_explode"), effectPos, defaultDir );
+		G_Sound( ent, CHAN_AUTO, G_SoundIndex("sound/chars/mouse/misc/death1") );
+		break;
+
+	case CLASS_PROBE:
+		VectorCopy( ent->r.currentOrigin, effectPos );
+		effectPos[2] += 50;
+		G_PlayEffectID( G_EffectIndex("explosions/probeexplosion1"), effectPos, defaultDir );
+		break;
+		
+	case CLASS_ATST: 
+		AngleVectors( ent->r.currentAngles, NULL, right, NULL );
+		VectorMA( ent->r.currentOrigin, 20, right, effectPos );
+		effectPos[2] += 180;
+		G_PlayEffectID( G_EffectIndex("explosions/droidexplosion1"), effectPos, defaultDir );
+		VectorMA( effectPos, -40, right, effectPos );
+		G_PlayEffectID( G_EffectIndex("explosions/droidexplosion1"), effectPos, defaultDir );
+		break;
+
+	case CLASS_SEEKER:
+	case CLASS_REMOTE:
+		G_PlayEffectID( G_EffectIndex("env/small_explode"), ent->r.currentOrigin, defaultDir );
+		break;
+
+	case CLASS_GONK:
+		VectorCopy( ent->r.currentOrigin, effectPos );
+		effectPos[2] -= 5;
+//		statusTextIndex = Q_irand( IGT_RESISTANCEISFUTILE, IGT_NAMEIS8OF12 );
+		G_Sound( ent, CHAN_AUTO, G_SoundIndex(va("sound/chars/gonk/misc/death%d.wav",Q_irand( 1, 3 ))) );
+		G_PlayEffectID( G_EffectIndex("env/med_explode"), effectPos, defaultDir );
+		break;
+
+	// should list all remaining droids here, hope I didn't miss any
+	case CLASS_R2D2:
+		VectorCopy( ent->r.currentOrigin, effectPos );
+		effectPos[2] -= 10;
+		G_PlayEffectID( G_EffectIndex("env/med_explode"), effectPos, defaultDir );
+		G_Sound( ent, CHAN_AUTO, G_SoundIndex("sound/chars/mark2/misc/mark2_explo") );
+		break;
+
+	case CLASS_PROTOCOL: //c3p0
+	case CLASS_R5D2:
+		VectorCopy( ent->r.currentOrigin, effectPos );
+		effectPos[2] -= 10;
+		G_PlayEffectID( G_EffectIndex("env/med_explode"), effectPos, defaultDir );
+		G_Sound( ent, CHAN_AUTO, G_SoundIndex("sound/chars/mark2/misc/mark2_explo") );
+		break;
+
+	case CLASS_MARK2:
+		VectorCopy( ent->r.currentOrigin, effectPos );
+		effectPos[2] -= 15;
+		G_PlayEffectID( G_EffectIndex("explosions/droidexplosion1"), effectPos, defaultDir );
+		G_Sound( ent, CHAN_AUTO, G_SoundIndex("sound/chars/mark2/misc/mark2_explo") );
+		break;
+
+	case CLASS_INTERROGATOR:
+		VectorCopy( ent->r.currentOrigin, effectPos );
+		effectPos[2] -= 15;
+		G_PlayEffectID( G_EffectIndex("explosions/droidexplosion1"), effectPos, defaultDir );
+		G_Sound( ent, CHAN_AUTO, G_SoundIndex("sound/chars/interrogator/misc/int_droid_explo") );
+		break;
+
+	case CLASS_MARK1:
+		AngleVectors( ent->r.currentAngles, NULL, right, NULL );
+		VectorMA( ent->r.currentOrigin, 10, right, effectPos );
+		effectPos[2] -= 15;
+		G_PlayEffectID( G_EffectIndex("explosions/droidexplosion1"), effectPos, defaultDir );
+		VectorMA( effectPos, -20, right, effectPos );
+		G_PlayEffectID( G_EffectIndex("explosions/droidexplosion1"), effectPos, defaultDir );
+		VectorMA( effectPos, -20, right, effectPos );
+		G_PlayEffectID( G_EffectIndex("explosions/droidexplosion1"), effectPos, defaultDir );
+		G_Sound( ent, CHAN_AUTO, G_SoundIndex("sound/chars/mark1/misc/mark1_explo") );
+		break;
+
+	case CLASS_SENTRY:
+		G_Sound( ent, CHAN_AUTO, G_SoundIndex("sound/chars/sentry/misc/sentry_explo") );
+		VectorCopy( ent->r.currentOrigin, effectPos );
+		G_PlayEffectID( G_EffectIndex("env/med_explode"), effectPos, defaultDir );
+		break;
+
+	default:
+		break;
+
+	}
+
+}
+
+void G_CheckVictoryScript(gentity_t *self)
+{
+	if ( !G_ActivateBehavior( self, BSET_VICTORY ) )
+	{
+		if ( self->NPC && self->s.weapon == WP_SABER )
+		{//Jedi taunt from within their AI
+			self->NPC->blockedSpeechDebounceTime = 0;//get them ready to taunt
+			return;
+		}
+		if ( self->client && self->client->NPC_class == CLASS_GALAKMECH )
+		{
+			self->wait = 1;
+			TIMER_Set( self, "gloatTime", Q_irand( 5000, 8000 ) );
+			self->NPC->blockedSpeechDebounceTime = 0;//get him ready to taunt
+			return;
+		}
+		//FIXME: any way to not say this *right away*?  Wait for victim's death anim/scream to finish?
+		if ( self->NPC && self->NPC->group && self->NPC->group->commander && self->NPC->group->commander->NPC && self->NPC->group->commander->NPC->rank > self->NPC->rank && !Q_irand( 0, 2 ) )
+		{//sometimes have the group commander speak instead
+			self->NPC->group->commander->NPC->greetingDebounceTime = level.time + Q_irand( 2000, 5000 );
+			//G_AddVoiceEvent( self->NPC->group->commander, Q_irand(EV_VICTORY1, EV_VICTORY3), 2000 );
+		}
+		else if ( self->NPC )
+		{
+			self->NPC->greetingDebounceTime = level.time + Q_irand( 2000, 5000 );
+			//G_AddVoiceEvent( self, Q_irand(EV_VICTORY1, EV_VICTORY3), 2000 );
+		}
+	}
+}
+
+void G_AddPowerDuelScore(int team, int score)
+{
+	int i = 0;
+	gentity_t *check;
+
+	while (i < MAX_CLIENTS)
+	{
+		check = &g_entities[i];
+		if (check->inuse && check->client &&
+			check->client->pers.connected == CON_CONNECTED && !check->client->iAmALoser &&
+			check->client->ps.stats[STAT_HEALTH] > 0 &&
+			check->client->sess.sessionTeam != TEAM_SPECTATOR &&
+			check->client->sess.duelTeam == team)
+		{ //found a living client on the specified team
+			check->client->sess.wins += score;
+			ClientUserinfoChanged(check->s.number);
+		}
+		i++;
+	}
+}
+
+void G_AddPowerDuelLoserScore(int team, int score)
+{
+	int i = 0;
+	gentity_t *check;
+
+	while (i < MAX_CLIENTS)
+	{
+		check = &g_entities[i];
+		if (check->inuse && check->client &&
+			check->client->pers.connected == CON_CONNECTED &&
+			(check->client->iAmALoser || (check->client->ps.stats[STAT_HEALTH] <= 0 && check->client->sess.sessionTeam != TEAM_SPECTATOR)) &&
+			check->client->sess.duelTeam == team)
+		{ //found a living client on the specified team
+			check->client->sess.losses += score;
+			ClientUserinfoChanged(check->s.number);
+		}
+		i++;
+	}
+}
+
+/*
+==================
+player_die
+==================
+*/
+extern stringID_table_t animTable[MAX_ANIMATIONS+1];
+
+extern void AI_DeleteSelfFromGroup( gentity_t *self );
+extern void AI_GroupMemberKilled( gentity_t *self );
+extern void Boba_FlyStop( gentity_t *self );
+extern qboolean Jedi_WaitingAmbush( gentity_t *self );
+void CheckExitRules( void );
+extern void Rancor_DropVictim( gentity_t *self );
+
+extern qboolean g_dontFrickinCheck;
+extern qboolean g_endPDuel;
+extern qboolean g_noPDuelCheck;
+void player_die( gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int meansOfDeath ) {
+	gentity_t	*ent;
+	int			anim;
+	int			contents;
+	int			killer;
+	int			i;
+	char		*killerName, *obit;
+	qboolean	wasJediMaster = qfalse;
+	int			sPMType = 0;
+
+	if ( self->client->ps.pm_type == PM_DEAD ) {
+		return;
+	}
+
+	if ( level.intermissiontime ) {
+		return;
+	}
+
+	//check player stuff
+	g_dontFrickinCheck = qfalse;
+
+	if (g_gametype.integer == GT_POWERDUEL)
+	{ //don't want to wait til later in the frame if this is the case
+		CheckExitRules();
+
+		if ( level.intermissiontime )
+		{
+			return;
+		}
+	}
+
+	if (self->s.eType == ET_NPC &&
+		self->s.NPC_class == CLASS_VEHICLE &&
+		self->m_pVehicle &&
+		!self->m_pVehicle->m_pVehicleInfo->explosionDelay &&
+		(self->m_pVehicle->m_pPilot || self->m_pVehicle->m_iNumPassengers > 0 || self->m_pVehicle->m_pDroidUnit))
+	{ //kill everyone on board in the name of the attacker... if the vehicle has no death delay
+		gentity_t *murderer = NULL;
+		gentity_t *killEnt;
+		int i = 0;
+
+		if (self->client->ps.otherKillerTime >= level.time)
+		{ //use the last attacker
+			murderer = &g_entities[self->client->ps.otherKiller];
+			if (!murderer->inuse || !murderer->client)
+			{
+				murderer = NULL;
+			}
+			else
+			{
+				if (murderer->s.number >= MAX_CLIENTS &&
+					murderer->s.eType == ET_NPC &&
+					murderer->s.NPC_class == CLASS_VEHICLE &&
+					murderer->m_pVehicle &&
+					murderer->m_pVehicle->m_pPilot)
+				{
+					gentity_t *murderPilot = &g_entities[murderer->m_pVehicle->m_pPilot->s.number];
+					if (murderPilot->inuse && murderPilot->client)
+					{ //give the pilot of the offending vehicle credit for the kill
+						murderer = murderPilot;
+					}
+				}
+			}
+		}
+		else if (attacker && attacker->inuse && attacker->client)
+		{
+			if (attacker->s.number >= MAX_CLIENTS &&
+				attacker->s.eType == ET_NPC &&
+				attacker->s.NPC_class == CLASS_VEHICLE &&
+				attacker->m_pVehicle &&
+				attacker->m_pVehicle->m_pPilot)
+			{ //set vehicles pilot's killer as murderer
+				murderer = &g_entities[attacker->m_pVehicle->m_pPilot->s.number];
+				if (murderer->inuse && murderer->client &&murderer->client->ps.otherKillerTime >= level.time)
+				{
+					murderer = &g_entities[murderer->client->ps.otherKiller];
+					if (!murderer->inuse || !murderer->client)
+					{
+						murderer = NULL;
+					}
+				}
+				else
+				{
+					murderer = NULL;
+				}
+			}
+			else
+			{
+				murderer = &g_entities[attacker->s.number];
+			}
+		}
+		else if (self->m_pVehicle->m_pPilot)
+		{
+			murderer = (gentity_t *)self->m_pVehicle->m_pPilot;
+			if (!murderer->inuse || !murderer->client)
+			{
+				murderer = NULL;
+			}
+		}
+
+		//no valid murderer.. just use self I guess
+		if (!murderer)
+		{
+			murderer = self;
+		}
+
+		if ( self->m_pVehicle->m_pVehicleInfo->hideRider )
+		{//pilot is *inside* me, so kill him, too
+			killEnt = (gentity_t *)self->m_pVehicle->m_pPilot;
+			if (killEnt && killEnt->inuse && killEnt->client)
+			{
+				G_Damage(killEnt, murderer, murderer, NULL, killEnt->client->ps.origin, 99999, DAMAGE_NO_PROTECTION, MOD_BLASTER);
+			}
+			if ( self->m_pVehicle->m_pVehicleInfo )
+			{//FIXME: this wile got stuck in an endless loop, that's BAD!!  This method SUCKS (not initting "i", not incrementing it or using it directly, all sorts of badness), so I'm rewriting it
+				//while (i < self->m_pVehicle->m_iNumPassengers)
+				int numPass = self->m_pVehicle->m_iNumPassengers;
+				for ( i = 0; i < numPass && self->m_pVehicle->m_iNumPassengers; i++ )
+				{//go through and eject the last passenger
+					killEnt = (gentity_t *)self->m_pVehicle->m_ppPassengers[self->m_pVehicle->m_iNumPassengers-1];
+					if ( killEnt )
+					{
+						self->m_pVehicle->m_pVehicleInfo->Eject(self->m_pVehicle, (bgEntity_t *)killEnt, qtrue);
+						if ( killEnt->inuse && killEnt->client )
+						{
+							G_Damage(killEnt, murderer, murderer, NULL, killEnt->client->ps.origin, 99999, DAMAGE_NO_PROTECTION, MOD_BLASTER);
+						}
+					}
+				}
+			}
+		}
+		killEnt = (gentity_t *)self->m_pVehicle->m_pDroidUnit;
+		if (killEnt && killEnt->inuse && killEnt->client)
+		{
+			killEnt->flags &= ~FL_UNDYING;
+			G_Damage(killEnt, murderer, murderer, NULL, killEnt->client->ps.origin, 99999, DAMAGE_NO_PROTECTION, MOD_BLASTER);
+		}
+	}
+
+	self->client->ps.emplacedIndex = 0;
+
+	G_BreakArm(self, 0); //unbreak anything we have broken
+	self->client->ps.saberEntityNum = self->client->saberStoredIndex; //in case we died while our saber was knocked away.
+
+	self->client->bodyGrabIndex = ENTITYNUM_NONE;
+	self->client->bodyGrabTime = 0;
+
+	if (self->client->holdingObjectiveItem > 0)
+	{ //carrying a siege objective item - make sure it updates and removes itself from us now in case this is an instant death-respawn situation
+		gentity_t *objectiveItem = &g_entities[self->client->holdingObjectiveItem];
+
+		if (objectiveItem->inuse && objectiveItem->think)
+		{
+            objectiveItem->think(objectiveItem);
+		}
+	}
+
+	if ( (self->client->inSpaceIndex && self->client->inSpaceIndex != ENTITYNUM_NONE) ||
+		 (self->client->ps.eFlags2 & EF2_SHIP_DEATH) )
+	{
+		self->client->noCorpse = qtrue;
+	}
+
+	if ( self->client->NPC_class != CLASS_VEHICLE
+		&& self->client->ps.m_iVehicleNum )
+	{ //I'm riding a vehicle
+		//tell it I'm getting off
+		gentity_t *veh = &g_entities[self->client->ps.m_iVehicleNum];
+
+		if (veh->inuse && veh->client && veh->m_pVehicle)
+		{
+			veh->m_pVehicle->m_pVehicleInfo->Eject(veh->m_pVehicle, (bgEntity_t *)self, qtrue);
+
+			if (veh->m_pVehicle->m_pVehicleInfo->type == VH_FIGHTER)
+			{ //go into "die in ship" mode with flag
+				self->client->ps.eFlags2 |= EF2_SHIP_DEATH;
+
+				//put me over where my vehicle exploded
+				G_SetOrigin(self, veh->client->ps.origin);
+				VectorCopy(veh->client->ps.origin, self->client->ps.origin);
+			}
+		}
+		//droids throw heads if they haven't yet
+		switch(self->client->NPC_class)
+		{
+		case CLASS_R2D2:
+			if ( !trap_G2API_GetSurfaceRenderStatus( self->ghoul2, 0, "head" ) )
+			{
+				vec3_t	up;
+				AngleVectors( self->r.currentAngles, NULL, NULL, up );
+				G_PlayEffectID( G_EffectIndex("chunks/r2d2head_veh"), self->r.currentOrigin, up );
+			}
+			break;
+
+		case CLASS_R5D2:
+			if ( !trap_G2API_GetSurfaceRenderStatus( self->ghoul2, 0, "head" ) )
+			{
+				vec3_t	up;
+				AngleVectors( self->r.currentAngles, NULL, NULL, up );
+				G_PlayEffectID( G_EffectIndex("chunks/r5d2head_veh"), self->r.currentOrigin, up );
+			}
+			break;
+		}
+	}
+
+	if ( self->NPC )
+	{
+		if ( self->client && Jedi_WaitingAmbush( self ) )
+		{//ambushing trooper
+			self->client->noclip = qfalse;
+		}
+		NPC_FreeCombatPoint( self->NPC->combatPoint, qfalse );
+		if ( self->NPC->group )
+		{
+			//lastInGroup = (self->NPC->group->numGroup < 2);
+			AI_GroupMemberKilled( self );
+			AI_DeleteSelfFromGroup( self );
+		}
+
+		if ( self->NPC->tempGoal )
+		{
+			G_FreeEntity( self->NPC->tempGoal );
+			self->NPC->tempGoal = NULL;
+		}
+		/*
+		if ( self->s.eFlags & EF_LOCKED_TO_WEAPON )
+		{
+			// dumb, just get the NPC out of the chair
+extern void RunEmplacedWeapon( gentity_t *ent, usercmd_t **ucmd );
+
+			usercmd_t cmd, *ad_cmd;
+
+			memset( &cmd, 0, sizeof( usercmd_t ));
+
+			//gentity_t *old = self->owner;
+
+			if ( self->owner )
+			{
+				self->owner->s.frame = self->owner->startFrame = self->owner->endFrame = 0;
+				self->owner->svFlags &= ~SVF_ANIMATING;
+			}
+
+			cmd.buttons |= BUTTON_USE;
+			ad_cmd = &cmd;
+			RunEmplacedWeapon( self, &ad_cmd );
+			//self->owner = old;
+		}
+		*/
+		//if ( self->client->NPC_class == CLASS_BOBAFETT && self->client->moveType == MT_FLYSWIM )
+		if (0)
+		{
+			Boba_FlyStop( self );
+		}
+		if ( self->s.NPC_class == CLASS_RANCOR )
+		{
+			Rancor_DropVictim( self );
+		}
+	}
+	if ( attacker && attacker->NPC && attacker->NPC->group && attacker->NPC->group->enemy == self )
+	{
+		attacker->NPC->group->enemy = NULL;
+	}
+
+	//Cheap method until/if I decide to put fancier stuff in (e.g. sabers falling out of hand and slowly
+	//holstering on death like sp)
+	if (self->client->ps.weapon == WP_SABER &&
+		!self->client->ps.saberHolstered &&
+		self->client->ps.saberEntityNum)
+	{
+		if (!self->client->ps.saberInFlight &&
+			self->client->saber[0].soundOff)
+		{
+			G_Sound(self, CHAN_AUTO, self->client->saber[0].soundOff);
+		}
+		if (self->client->saber[1].soundOff &&
+			self->client->saber[1].model[0])
+		{
+			G_Sound(self, CHAN_AUTO, self->client->saber[1].soundOff);
+		}
+	}
+
+	//Use any target we had
+	G_UseTargets( self, self );
+
+	if (g_slowmoDuelEnd.integer && (g_gametype.integer == GT_DUEL || g_gametype.integer == GT_POWERDUEL) && attacker && attacker->inuse && attacker->client)
+	{
+		if (!gDoSlowMoDuel)
+		{
+			gDoSlowMoDuel = qtrue;
+			gSlowMoDuelTime = level.time;
+		}
+	}
+	/*
+	else if (self->NPC && attacker && attacker->client && attacker->s.number < MAX_CLIENTS && !gDoSlowMoDuel)
+	{
+		gDoSlowMoDuel = qtrue;
+		gSlowMoDuelTime = level.time;
+	}
+	*/
+
+	//Make sure the jetpack is turned off.
+	Jetpack_Off(self);
+
+	self->client->ps.heldByClient = 0;
+	self->client->beingThrown = 0;
+	self->client->doingThrow = 0;
+
+	if (inflictor && inflictor->activator && !inflictor->client && !attacker->client &&
+		inflictor->activator->client && inflictor->activator->inuse &&
+		inflictor->s.weapon == WP_TURRET)
+	{
+		attacker = inflictor->activator;
+	}
+
+	if (self->client && self->client->ps.isJediMaster)
+	{
+		wasJediMaster = qtrue;
+	}
+
+	//if he was charging or anything else, kill the sound
+	G_MuteSound(self->s.number, CHAN_WEAPON);
+
+	BlowDetpacks(self); //blow detpacks if they're planted
+
+	self->client->ps.fd.forceDeactivateAll = 1;
+
+	if ((self == attacker || !attacker->client) &&
+		(meansOfDeath == MOD_CRUSH || meansOfDeath == MOD_FALLING || meansOfDeath == MOD_TRIGGER_HURT || meansOfDeath == MOD_UNKNOWN) &&
+		self->client->ps.otherKillerTime > level.time)
+	{
+		attacker = &g_entities[self->client->ps.otherKiller];
+	}
+
+	// check for an almost capture
+	CheckAlmostCapture( self, attacker );
+
+	self->client->ps.pm_type = PM_DEAD;
+	self->client->ps.pm_flags &= ~PMF_STUCK_TO_WALL;
+
+	if ( attacker ) {
+		killer = attacker->s.number;
+		if ( attacker->client ) {
+			killerName = attacker->client->pers.netname;
+		} else {
+			killerName = "<non-client>";
+		}
+	} else {
+		killer = ENTITYNUM_WORLD;
+		killerName = "<world>";
+	}
+
+	if ( killer < 0 || killer >= MAX_CLIENTS ) {
+		killer = ENTITYNUM_WORLD;
+		killerName = "<world>";
+	}
+
+	if ( meansOfDeath < 0 || meansOfDeath >= sizeof( modNames ) / sizeof( modNames[0] ) ) {
+		obit = "<bad obituary>";
+	} else {
+		obit = modNames[ meansOfDeath ];
+	}
+
+	G_LogPrintf("Kill: %i %i %i: %s killed %s by %s\n", 
+		killer, self->s.number, meansOfDeath, killerName, 
+		self->client->pers.netname, obit );
+
+	if ( g_austrian.integer 
+		&& (g_gametype.integer == GT_DUEL) 
+		&& level.numPlayingClients >= 2 )
+	{
+		int spawnTime = (level.clients[level.sortedClients[0]].respawnTime > level.clients[level.sortedClients[1]].respawnTime) ? level.clients[level.sortedClients[0]].respawnTime : level.clients[level.sortedClients[1]].respawnTime;
+		G_LogPrintf("Duel Kill Details:\n");
+		G_LogPrintf("Kill Time: %d\n", level.time-spawnTime );
+		G_LogPrintf("victim: %s, hits on enemy %d\n", self->client->pers.netname, self->client->ps.persistant[PERS_HITS] );
+		if ( attacker && attacker->client )
+		{
+			G_LogPrintf("killer: %s, hits on enemy %d, health: %d\n", attacker->client->pers.netname, attacker->client->ps.persistant[PERS_HITS], attacker->health );
+			//also - if MOD_SABER, list the animation and saber style
+			if ( meansOfDeath == MOD_SABER )
+			{
+				G_LogPrintf("killer saber style: %d, killer saber anim %s\n", attacker->client->ps.fd.saberAnimLevel, animTable[(attacker->client->ps.torsoAnim)].name );
+			}
+		}
+	}
+
+	G_LogWeaponKill(killer, meansOfDeath);
+	G_LogWeaponDeath(self->s.number, self->s.weapon);
+	if (attacker && attacker->client && attacker->inuse)
+	{
+		G_LogWeaponFrag(killer, self->s.number);
+	}
+
+	// broadcast the death event to everyone
+	if (self->s.eType != ET_NPC && !g_noPDuelCheck)
+	{
+		ent = G_TempEntity( self->r.currentOrigin, EV_OBITUARY );
+		ent->s.eventParm = meansOfDeath;
+		ent->s.otherEntityNum = self->s.number;
+		ent->s.otherEntityNum2 = killer;
+		ent->r.svFlags = SVF_BROADCAST;	// send to everyone
+		ent->s.isJediMaster = wasJediMaster;
+	}
+
+	self->enemy = attacker;
+
+	self->client->ps.persistant[PERS_KILLED]++;
+
+	if (self == attacker)
+	{
+		self->client->ps.fd.suicides++;
+	}
+
+	if (attacker && attacker->client) {
+		attacker->client->lastkilled_client = self->s.number;
+
+		G_CheckVictoryScript(attacker);
+
+		if ( attacker == self || OnSameTeam (self, attacker ) ) {
+			if (g_gametype.integer == GT_DUEL)
+			{ //in duel, if you kill yourself, the person you are dueling against gets a kill for it
+				int otherClNum = -1;
+				if (level.sortedClients[0] == self->s.number)
+				{
+					otherClNum = level.sortedClients[1];
+				}
+				else if (level.sortedClients[1] == self->s.number)
+				{
+					otherClNum = level.sortedClients[0];
+				}
+
+				if (otherClNum >= 0 && otherClNum < MAX_CLIENTS &&
+					g_entities[otherClNum].inuse && g_entities[otherClNum].client &&
+					otherClNum != attacker->s.number)
+				{
+					AddScore( &g_entities[otherClNum], self->r.currentOrigin, 1 );
+				}
+				else
+				{
+					AddScore( attacker, self->r.currentOrigin, -1 );
+				}
+			}
+			else
+			{
+				AddScore( attacker, self->r.currentOrigin, -1 );
+			}
+			if (g_gametype.integer == GT_JEDIMASTER)
+			{
+				if (self->client && self->client->ps.isJediMaster)
+				{ //killed ourself so return the saber to the original position
+				  //(to avoid people jumping off ledges and making the saber
+				  //unreachable for 60 seconds)
+					ThrowSaberToAttacker(self, NULL);
+					self->client->ps.isJediMaster = qfalse;
+				}
+			}
+		} else {
+			if (g_gametype.integer == GT_JEDIMASTER)
+			{
+				if ((attacker->client && attacker->client->ps.isJediMaster) ||
+					(self->client && self->client->ps.isJediMaster))
+				{
+					AddScore( attacker, self->r.currentOrigin, 1 );
+					
+					if (self->client && self->client->ps.isJediMaster)
+					{
+						ThrowSaberToAttacker(self, attacker);
+						self->client->ps.isJediMaster = qfalse;
+					}
+				}
+				else
+				{
+					gentity_t *jmEnt = G_GetJediMaster();
+
+					if (jmEnt && jmEnt->client)
+					{
+						AddScore( jmEnt, self->r.currentOrigin, 1 );
+					}
+				}
+			}
+			else
+			{
+				AddScore( attacker, self->r.currentOrigin, 1 );
+			}
+
+			if( meansOfDeath == MOD_STUN_BATON ) {
+				
+				// play humiliation on player
+				attacker->client->ps.persistant[PERS_GAUNTLET_FRAG_COUNT]++;
+
+				attacker->client->rewardTime = level.time + REWARD_SPRITE_TIME;
+
+				// also play humiliation on target
+				self->client->ps.persistant[PERS_PLAYEREVENTS] ^= PLAYEREVENT_GAUNTLETREWARD;
+			}
+
+			// check for two kills in a short amount of time
+			// if this is close enough to the last kill, give a reward sound
+			if ( level.time - attacker->client->lastKillTime < CARNAGE_REWARD_TIME ) {
+				// play excellent on player
+				attacker->client->ps.persistant[PERS_EXCELLENT_COUNT]++;
+
+				attacker->client->rewardTime = level.time + REWARD_SPRITE_TIME;
+			}
+			attacker->client->lastKillTime = level.time;
+
+		}
+	} else {
+		if (self->client && self->client->ps.isJediMaster)
+		{ //killed ourself so return the saber to the original position
+		  //(to avoid people jumping off ledges and making the saber
+		  //unreachable for 60 seconds)
+			ThrowSaberToAttacker(self, NULL);
+			self->client->ps.isJediMaster = qfalse;
+		}
+
+		if (g_gametype.integer == GT_DUEL)
+		{ //in duel, if you kill yourself, the person you are dueling against gets a kill for it
+			int otherClNum = -1;
+			if (level.sortedClients[0] == self->s.number)
+			{
+				otherClNum = level.sortedClients[1];
+			}
+			else if (level.sortedClients[1] == self->s.number)
+			{
+				otherClNum = level.sortedClients[0];
+			}
+
+			if (otherClNum >= 0 && otherClNum < MAX_CLIENTS &&
+				g_entities[otherClNum].inuse && g_entities[otherClNum].client &&
+				otherClNum != self->s.number)
+			{
+				AddScore( &g_entities[otherClNum], self->r.currentOrigin, 1 );
+			}
+			else
+			{
+				AddScore( self, self->r.currentOrigin, -1 );
+			}
+		}
+		else
+		{
+			AddScore( self, self->r.currentOrigin, -1 );
+		}
+	}
+
+	// Add team bonuses
+	Team_FragBonuses(self, inflictor, attacker);
+
+	// if I committed suicide, the flag does not fall, it returns.
+	if (meansOfDeath == MOD_SUICIDE) {
+		if ( self->client->ps.powerups[PW_NEUTRALFLAG] ) {		// only happens in One Flag CTF
+			Team_ReturnFlag( TEAM_FREE );
+			self->client->ps.powerups[PW_NEUTRALFLAG] = 0;
+		}
+		else if ( self->client->ps.powerups[PW_REDFLAG] ) {		// only happens in standard CTF
+			Team_ReturnFlag( TEAM_RED );
+			self->client->ps.powerups[PW_REDFLAG] = 0;
+		}
+		else if ( self->client->ps.powerups[PW_BLUEFLAG] ) {	// only happens in standard CTF
+			Team_ReturnFlag( TEAM_BLUE );
+			self->client->ps.powerups[PW_BLUEFLAG] = 0;
+		}
+	}
+
+	// if client is in a nodrop area, don't drop anything (but return CTF flags!)
+	contents = trap_PointContents( self->r.currentOrigin, -1 );
+	if ( !( contents & CONTENTS_NODROP ) && !self->client->ps.fallingToDeath) {
+		if (self->s.eType != ET_NPC)
+		{
+			TossClientItems( self );
+		}
+	}
+	else {
+		if ( self->client->ps.powerups[PW_NEUTRALFLAG] ) {		// only happens in One Flag CTF
+			Team_ReturnFlag( TEAM_FREE );
+		}
+		else if ( self->client->ps.powerups[PW_REDFLAG] ) {		// only happens in standard CTF
+			Team_ReturnFlag( TEAM_RED );
+		}
+		else if ( self->client->ps.powerups[PW_BLUEFLAG] ) {	// only happens in standard CTF
+			Team_ReturnFlag( TEAM_BLUE );
+		}
+	}
+
+	if ( MOD_TEAM_CHANGE == meansOfDeath )
+	{
+		// Give them back a point since they didn't really die.
+		AddScore( self, self->r.currentOrigin, 1 );
+	}
+	else
+	{
+		Cmd_Score_f( self );		// show scores
+	}
+
+	// send updated scores to any clients that are following this one,
+	// or they would get stale scoreboards
+	for ( i = 0 ; i < level.maxclients ; i++ ) {
+		gclient_t	*client;
+
+		client = &level.clients[i];
+		if ( client->pers.connected != CON_CONNECTED ) {
+			continue;
+		}
+		if ( client->sess.sessionTeam != TEAM_SPECTATOR ) {
+			continue;
+		}
+		if ( client->sess.spectatorClient == self->s.number ) {
+			Cmd_Score_f( g_entities + i );
+		}
+	}
+
+	self->takedamage = qtrue;	// can still be gibbed
+
+	self->s.weapon = WP_NONE;
+	self->s.powerups = 0;
+	if (self->s.eType != ET_NPC)
+	{ //handled differently for NPCs
+		self->r.contents = CONTENTS_CORPSE;
+	}
+	self->client->ps.zoomMode = 0;	// Turn off zooming when we die
+
+	//rww - 07/19/02 - I removed this because it isn't working and it's ugly (for people on the outside)
+	/*
+	self->s.angles[0] = 0;
+	self->s.angles[2] = 0;
+	LookAtKiller (self, inflictor, attacker);
+
+	VectorCopy( self->s.angles, self->client->ps.viewangles );
+	*/
+
+	self->s.loopSound = 0;
+	self->s.loopIsSoundset = qfalse;
+
+	if (self->s.eType != ET_NPC)
+	{ //handled differently for NPCs
+		self->r.maxs[2] = -8;
+	}
+
+	// don't allow respawn until the death anim is done
+	// g_forcerespawn may force spawning at some later time
+	self->client->respawnTime = level.time + 1700;
+
+	// remove powerups
+	memset( self->client->ps.powerups, 0, sizeof(self->client->ps.powerups) );
+
+	// NOTENOTE No gib deaths right now, this is star wars.
+	/*
+	// never gib in a nodrop
+	if ( (self->health <= GIB_HEALTH && !(contents & CONTENTS_NODROP) && g_blood.integer) || meansOfDeath == MOD_SUICIDE) 
+	{
+		// gib death
+		GibEntity( self, killer );
+	} 
+	else 
+	*/
+	{
+		// normal death
+		
+		static int i;
+
+		anim = G_PickDeathAnim(self, self->pos1, damage, meansOfDeath, HL_NONE);
+
+		if (anim >= 1)
+		{ //Some droids don't have death anims
+			// for the no-blood option, we need to prevent the health
+			// from going to gib level
+			if ( self->health <= GIB_HEALTH ) {
+				self->health = GIB_HEALTH+1;
+			}
+
+			self->client->respawnTime = level.time + 1000;//((self->client->animations[anim].numFrames*40)/(50.0f / self->client->animations[anim].frameLerp))+300;
+
+			sPMType = self->client->ps.pm_type;
+			self->client->ps.pm_type = PM_NORMAL; //don't want pm type interfering with our setanim calls.
+
+			if (self->inuse)
+			{ //not disconnecting
+				G_SetAnim(self, NULL, SETANIM_BOTH, anim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD|SETANIM_FLAG_RESTART, 0);
+			}
+
+			self->client->ps.pm_type = sPMType;
+
+			if (meansOfDeath == MOD_SABER || (meansOfDeath == MOD_MELEE && G_HeavyMelee( attacker )) )//saber or heavy melee (claws)
+			{ //update the anim on the actual skeleton (so bolt point will reflect the correct position) and then check for dismem
+				G_UpdateClientAnims(self, 1.0f);
+				G_CheckForDismemberment(self, attacker, self->pos1, damage, anim, qfalse);
+			}
+		}
+		else if (self->NPC && self->client && self->client->NPC_class != CLASS_MARK1 &&
+			self->client->NPC_class != CLASS_VEHICLE)
+		{ //in this case if we're an NPC it's my guess that we want to get removed straight away.
+			self->think = G_FreeEntity;
+			self->nextthink = level.time;
+		}
+
+		//self->client->ps.legsAnim = anim;
+		//self->client->ps.torsoAnim = anim;
+//		self->client->ps.pm_flags |= PMF_UPDATE_ANIM;		// Make sure the pmove sets up the GHOUL2 anims.
+
+		//rww - do this on respawn, not death
+		//CopyToBodyQue (self);
+
+		//G_AddEvent( self, EV_DEATH1 + i, killer );
+		if (wasJediMaster)
+		{
+			G_AddEvent( self, EV_DEATH1 + i, 1 );
+		}
+		else
+		{
+			G_AddEvent( self, EV_DEATH1 + i, 0 );
+		}
+
+		if (self != attacker)
+		{ //don't make NPCs want to murder you on respawn for killing yourself!
+			G_DeathAlert( self, attacker );
+		}
+
+		// the body can still be gibbed
+		if (!self->NPC)
+		{ //don't remove NPCs like this!
+			self->die = body_die;
+		}
+
+		//It won't gib, it will disintegrate (because this is Star Wars).
+		self->takedamage = qtrue;
+
+		// globally cycle through the different death animations
+		i = ( i + 1 ) % 3;
+	}
+
+	if ( self->NPC )
+	{//If an NPC, make sure we start running our scripts again- this gets set to infinite while we fall to our deaths
+		self->NPC->nextBStateThink = level.time;
+	}
+
+	if ( G_ActivateBehavior( self, BSET_DEATH ) )
+	{
+		//deathScript = qtrue;
+	}
+	
+	if ( self->NPC && (self->NPC->scriptFlags&SCF_FFDEATH) )
+	{
+		if ( G_ActivateBehavior( self, BSET_FFDEATH ) )  
+		{//FIXME: should running this preclude running the normal deathscript?
+			//deathScript = qtrue;
+		}
+		G_UseTargets2( self, self, self->target4 );
+	}
+	
+	/*
+	if ( !deathScript && !(self->svFlags&SVF_KILLED_SELF) )
+	{
+		//Should no longer run scripts
+		//WARNING!!! DO NOT DO THIS WHILE RUNNING A SCRIPT, ICARUS WILL CRASH!!!
+		//FIXME: shouldn't ICARUS handle this internally?
+		ICARUS_FreeEnt(self);
+	}
+	*/
+	//rwwFIXMEFIXME: Do this too?
+
+	// Free up any timers we may have on us.
+	TIMER_Clear2( self );
+
+	trap_LinkEntity (self);
+
+	if ( self->NPC )
+	{
+		self->NPC->timeOfDeath = level.time;//this will change - used for debouncing post-death events
+	}
+
+	// Start any necessary death fx for this entity
+	DeathFX( self );
+
+
+	if (g_gametype.integer == GT_POWERDUEL && !g_noPDuelCheck)
+	{ //powerduel checks
+		if (self->client->sess.duelTeam == DUELTEAM_LONE)
+		{ //automatically means a win as there is only one
+			G_AddPowerDuelScore(DUELTEAM_DOUBLE, 1);
+			G_AddPowerDuelLoserScore(DUELTEAM_LONE, 1);
+			g_endPDuel = qtrue;
+		}
+		else if (self->client->sess.duelTeam == DUELTEAM_DOUBLE)
+		{
+			int i = 0;
+			gentity_t *check;
+			qboolean heLives = qfalse;
+
+			while (i < MAX_CLIENTS)
+			{
+				check = &g_entities[i];
+				if (check->inuse && check->client && check->s.number != self->s.number &&
+					check->client->pers.connected == CON_CONNECTED && !check->client->iAmALoser &&
+					check->client->ps.stats[STAT_HEALTH] > 0 &&
+					check->client->sess.sessionTeam != TEAM_SPECTATOR &&
+					check->client->sess.duelTeam == DUELTEAM_DOUBLE)
+				{ //still an active living paired duelist so it's not over yet.
+					heLives = qtrue;
+					break;
+				}
+				i++;
+			}
+
+			if (!heLives)
+			{ //they're all dead, give the lone duelist the win.
+				G_AddPowerDuelScore(DUELTEAM_LONE, 1);
+				G_AddPowerDuelLoserScore(DUELTEAM_DOUBLE, 1);
+				g_endPDuel = qtrue;
+			}
+		}
+	}
+}
+
+
+/*
+================
+CheckArmor
+================
+*/
+int CheckArmor (gentity_t *ent, int damage, int dflags)
+{
+	gclient_t	*client;
+	int			save;
+	int			count;
+
+	if (!damage)
+		return 0;
+
+	client = ent->client;
+
+	if (!client)
+		return 0;
+
+	if (dflags & DAMAGE_NO_ARMOR)
+		return 0;
+
+	if ( client->NPC_class == CLASS_VEHICLE
+		&& ent->m_pVehicle
+		&& ent->client->ps.electrifyTime > level.time )
+	{//ion-cannon has disabled this ship's shields, take damage on hull!
+		return 0;
+	}
+	// armor
+	count = client->ps.stats[STAT_ARMOR];
+
+	if (dflags & DAMAGE_HALF_ABSORB)
+	{	// Half the damage gets absorbed by the shields, rather than 100%
+		save = ceil( damage * ARMOR_PROTECTION );
+	}
+	else
+	{	// All the damage gets absorbed by the shields.
+		save = damage;
+	}
+
+	// save is the most damage that the armor is elibigle to protect, of course, but it's limited by the total armor.
+	if (save >= count)
+		save = count;
+
+	if (!save)
+		return 0;
+
+	if (dflags & DAMAGE_HALF_ARMOR_REDUCTION)		// Armor isn't whittled so easily by sniper shots.
+	{
+		client->ps.stats[STAT_ARMOR] -= (int)(save*ARMOR_REDUCTION_FACTOR);
+	}
+	else
+	{
+		client->ps.stats[STAT_ARMOR] -= save;
+	}
+
+	return save;
+}
+
+
+void G_ApplyKnockback( gentity_t *targ, vec3_t newDir, float knockback )
+{
+	vec3_t	kvel;
+	float	mass;
+
+	if ( targ->physicsBounce > 0 )	//overide the mass
+		mass = targ->physicsBounce;
+	else
+		mass = 200;
+
+	if ( g_gravity.value > 0 )
+	{
+		VectorScale( newDir, g_knockback.value * (float)knockback / mass * 0.8, kvel );
+		kvel[2] = newDir[2] * g_knockback.value * (float)knockback / mass * 1.5;
+	}
+	else
+	{
+		VectorScale( newDir, g_knockback.value * (float)knockback / mass, kvel );
+	}
+
+	if ( targ->client )
+	{
+		VectorAdd( targ->client->ps.velocity, kvel, targ->client->ps.velocity );
+	}
+	else if ( targ->s.pos.trType != TR_STATIONARY && targ->s.pos.trType != TR_LINEAR_STOP && targ->s.pos.trType != TR_NONLINEAR_STOP )
+	{
+		VectorAdd( targ->s.pos.trDelta, kvel, targ->s.pos.trDelta );
+		VectorCopy( targ->r.currentOrigin, targ->s.pos.trBase );
+		targ->s.pos.trTime = level.time;
+	}
+
+	// set the timer so that the other client can't cancel
+	// out the movement immediately
+	if ( targ->client && !targ->client->ps.pm_time ) 
+	{
+		int		t;
+
+		t = knockback * 2;
+		if ( t < 50 ) {
+			t = 50;
+		}
+		if ( t > 200 ) {
+			t = 200;
+		}
+		targ->client->ps.pm_time = t;
+		targ->client->ps.pm_flags |= PMF_TIME_KNOCKBACK;
+	}
+}
+
+/*
+================
+RaySphereIntersections
+================
+*/
+int RaySphereIntersections( vec3_t origin, float radius, vec3_t point, vec3_t dir, vec3_t intersections[2] ) {
+	float b, c, d, t;
+
+	//	| origin - (point + t * dir) | = radius
+	//	a = dir[0]^2 + dir[1]^2 + dir[2]^2;
+	//	b = 2 * (dir[0] * (point[0] - origin[0]) + dir[1] * (point[1] - origin[1]) + dir[2] * (point[2] - origin[2]));
+	//	c = (point[0] - origin[0])^2 + (point[1] - origin[1])^2 + (point[2] - origin[2])^2 - radius^2;
+
+	// normalize dir so a = 1
+	VectorNormalize(dir);
+	b = 2 * (dir[0] * (point[0] - origin[0]) + dir[1] * (point[1] - origin[1]) + dir[2] * (point[2] - origin[2]));
+	c = (point[0] - origin[0]) * (point[0] - origin[0]) +
+		(point[1] - origin[1]) * (point[1] - origin[1]) +
+		(point[2] - origin[2]) * (point[2] - origin[2]) -
+		radius * radius;
+
+	d = b * b - 4 * c;
+	if (d > 0) {
+		t = (- b + sqrt(d)) / 2;
+		VectorMA(point, t, dir, intersections[0]);
+		t = (- b - sqrt(d)) / 2;
+		VectorMA(point, t, dir, intersections[1]);
+		return 2;
+	}
+	else if (d == 0) {
+		t = (- b ) / 2;
+		VectorMA(point, t, dir, intersections[0]);
+		return 1;
+	}
+	return 0;
+}
+
+/*
+===================================
+rww - beginning of the majority of the dismemberment and location based damage code.
+===================================
+*/
+char *hitLocName[HL_MAX] = 
+{
+	"none",	//HL_NONE = 0,
+	"right foot",	//HL_FOOT_RT,
+	"left foot",	//HL_FOOT_LT,
+	"right leg",	//HL_LEG_RT,
+	"left leg",	//HL_LEG_LT,
+	"waist",	//HL_WAIST,
+	"back right shoulder",	//HL_BACK_RT,
+	"back left shoulder",	//HL_BACK_LT,
+	"back",	//HL_BACK,
+	"front right shouler",	//HL_CHEST_RT,
+	"front left shoulder",	//HL_CHEST_LT,
+	"chest",	//HL_CHEST,
+	"right arm",	//HL_ARM_RT,
+	"left arm",	//HL_ARM_LT,
+	"right hand",	//HL_HAND_RT,
+	"left hand",	//HL_HAND_LT,
+	"head",	//HL_HEAD
+	"generic1",	//HL_GENERIC1,
+	"generic2",	//HL_GENERIC2,
+	"generic3",	//HL_GENERIC3,
+	"generic4",	//HL_GENERIC4,
+	"generic5",	//HL_GENERIC5,
+	"generic6"	//HL_GENERIC6
+};
+
+void G_GetDismemberLoc(gentity_t *self, vec3_t boltPoint, int limbType)
+{ //Just get the general area without using server-side ghoul2
+	vec3_t fwd, right, up;
+
+	AngleVectors(self->r.currentAngles, fwd, right, up);
+
+	VectorCopy(self->r.currentOrigin, boltPoint);
+
+	switch (limbType)
+	{
+	case G2_MODELPART_HEAD:
+		boltPoint[0] += up[0]*24;
+		boltPoint[1] += up[1]*24;
+		boltPoint[2] += up[2]*24;
+		break;
+	case G2_MODELPART_WAIST:
+		boltPoint[0] += up[0]*4;
+		boltPoint[1] += up[1]*4;
+		boltPoint[2] += up[2]*4;
+		break;
+	case G2_MODELPART_LARM:
+		boltPoint[0] += up[0]*18;
+		boltPoint[1] += up[1]*18;
+		boltPoint[2] += up[2]*18;
+
+		boltPoint[0] -= right[0]*10;
+		boltPoint[1] -= right[1]*10;
+		boltPoint[2] -= right[2]*10;
+		break;
+	case G2_MODELPART_RARM:
+		boltPoint[0] += up[0]*18;
+		boltPoint[1] += up[1]*18;
+		boltPoint[2] += up[2]*18;
+
+		boltPoint[0] += right[0]*10;
+		boltPoint[1] += right[1]*10;
+		boltPoint[2] += right[2]*10;
+		break;
+	case G2_MODELPART_RHAND:
+		boltPoint[0] += up[0]*8;
+		boltPoint[1] += up[1]*8;
+		boltPoint[2] += up[2]*8;
+
+		boltPoint[0] += right[0]*10;
+		boltPoint[1] += right[1]*10;
+		boltPoint[2] += right[2]*10;
+		break;
+	case G2_MODELPART_LLEG:
+		boltPoint[0] -= up[0]*4;
+		boltPoint[1] -= up[1]*4;
+		boltPoint[2] -= up[2]*4;
+
+		boltPoint[0] -= right[0]*10;
+		boltPoint[1] -= right[1]*10;
+		boltPoint[2] -= right[2]*10;
+		break;
+	case G2_MODELPART_RLEG:
+		boltPoint[0] -= up[0]*4;
+		boltPoint[1] -= up[1]*4;
+		boltPoint[2] -= up[2]*4;
+
+		boltPoint[0] += right[0]*10;
+		boltPoint[1] += right[1]*10;
+		boltPoint[2] += right[2]*10;
+		break;
+	default:
+		break;
+	}
+
+	return;
+}
+
+void G_GetDismemberBolt(gentity_t *self, vec3_t boltPoint, int limbType)
+{
+	int useBolt = self->genericValue5;
+	vec3_t properOrigin, properAngles, addVel;
+	//vec3_t legAxis[3];
+	mdxaBone_t	boltMatrix;
+	float fVSpeed = 0;
+	char *rotateBone = NULL;
+
+	switch (limbType)
+	{
+	case G2_MODELPART_HEAD:
+		rotateBone = "cranium";
+		break;
+	case G2_MODELPART_WAIST:
+		if (self->localAnimIndex <= 1)
+		{ //humanoid
+			rotateBone = "thoracic";
+		}
+		else
+		{
+			rotateBone = "pelvis";
+		}
+		break;
+	case G2_MODELPART_LARM:
+		rotateBone = "lradius";
+		break;
+	case G2_MODELPART_RARM:
+		rotateBone = "rradius";
+		break;
+	case G2_MODELPART_RHAND:
+		rotateBone = "rhand";
+		break;
+	case G2_MODELPART_LLEG:
+		rotateBone = "ltibia";
+		break;
+	case G2_MODELPART_RLEG:
+		rotateBone = "rtibia";
+		break;
+	default:
+		rotateBone = "rtibia";
+		break;
+	}
+
+	useBolt = trap_G2API_AddBolt(self->ghoul2, 0, rotateBone);
+
+	VectorCopy(self->client->ps.origin, properOrigin);
+	VectorCopy(self->client->ps.viewangles, properAngles);
+
+	//try to predict the origin based on velocity so it's more like what the client is seeing
+	VectorCopy(self->client->ps.velocity, addVel);
+	VectorNormalize(addVel);
+
+	if (self->client->ps.velocity[0] < 0)
+	{
+		fVSpeed += (-self->client->ps.velocity[0]);
+	}
+	else
+	{
+		fVSpeed += self->client->ps.velocity[0];
+	}
+	if (self->client->ps.velocity[1] < 0)
+	{
+		fVSpeed += (-self->client->ps.velocity[1]);
+	}
+	else
+	{
+		fVSpeed += self->client->ps.velocity[1];
+	}
+	if (self->client->ps.velocity[2] < 0)
+	{
+		fVSpeed += (-self->client->ps.velocity[2]);
+	}
+	else
+	{
+		fVSpeed += self->client->ps.velocity[2];
+	}
+
+	fVSpeed *= 0.08;
+
+	properOrigin[0] += addVel[0]*fVSpeed;
+	properOrigin[1] += addVel[1]*fVSpeed;
+	properOrigin[2] += addVel[2]*fVSpeed;
+
+	properAngles[0] = 0;
+	properAngles[1] = self->client->ps.viewangles[YAW];
+	properAngles[2] = 0;
+
+	trap_G2API_GetBoltMatrix(self->ghoul2, 0, useBolt, &boltMatrix, properAngles, properOrigin, level.time, NULL, self->modelScale);
+
+	boltPoint[0] = boltMatrix.matrix[0][3];
+	boltPoint[1] = boltMatrix.matrix[1][3];
+	boltPoint[2] = boltMatrix.matrix[2][3];
+
+	trap_G2API_GetBoltMatrix(self->ghoul2, 1, 0, &boltMatrix, properAngles, properOrigin, level.time, NULL, self->modelScale);
+
+	if (self->client && limbType == G2_MODELPART_RHAND)
+	{ //Make some saber hit sparks over the severed wrist area
+		vec3_t boltAngles;
+		gentity_t *te;
+
+		boltAngles[0] = -boltMatrix.matrix[0][1];
+		boltAngles[1] = -boltMatrix.matrix[1][1];
+		boltAngles[2] = -boltMatrix.matrix[2][1];
+
+		te = G_TempEntity( boltPoint, EV_SABER_HIT );
+		te->s.otherEntityNum = ENTITYNUM_NONE;
+		te->s.otherEntityNum2 = self->s.number;
+
+		VectorCopy(boltPoint, te->s.origin);
+		VectorCopy(boltAngles, te->s.angles);
+		
+		if (!te->s.angles[0] && !te->s.angles[1] && !te->s.angles[2])
+		{ //don't let it play with no direction
+			te->s.angles[1] = 1;
+		}
+
+		te->s.eventParm = 16; //lots of sparks
+	}
+}
+
+void LimbTouch( gentity_t *self, gentity_t *other, trace_t *trace )
+{
+}
+
+void LimbThink( gentity_t *ent )
+{
+	float gravity = 3.0f;
+	float mass = 0.09f;
+	float bounce = 1.3f;
+
+	switch (ent->s.modelGhoul2)
+	{
+	case G2_MODELPART_HEAD:
+		mass = 0.08f;
+		bounce = 1.4f;
+		break;
+	case G2_MODELPART_WAIST:
+		mass = 0.1f;
+		bounce = 1.2f;
+		break;
+	case G2_MODELPART_LARM:
+	case G2_MODELPART_RARM:
+	case G2_MODELPART_RHAND:
+	case G2_MODELPART_LLEG:
+	case G2_MODELPART_RLEG:
+	default:
+		break;
+	}
+
+	if (ent->speed < level.time)
+	{
+		ent->think = G_FreeEntity;
+		ent->nextthink = level.time;
+		return;
+	}
+
+	if (ent->genericValue5 <= level.time)
+	{ //this will be every frame by standard, but we want to compensate in case sv_fps is not 20.
+		G_RunExPhys(ent, gravity, mass, bounce, qtrue, NULL, 0);
+		ent->genericValue5 = level.time + 50;
+	}
+
+	ent->nextthink = level.time;
+}
+
+#include "../namespace_begin.h"
+extern qboolean BG_GetRootSurfNameWithVariant( void *ghoul2, const char *rootSurfName, char *returnSurfName, int returnSize );
+#include "../namespace_end.h"
+
+void G_Dismember( gentity_t *ent, gentity_t *enemy, vec3_t point, int limbType, float limbRollBase, float limbPitchBase, int deathAnim, qboolean postDeath )
+{
+	vec3_t	newPoint, dir, vel;
+	gentity_t *limb;
+	char	limbName[MAX_QPATH];
+	char	stubName[MAX_QPATH];
+	char	stubCapName[MAX_QPATH];
+
+	if (limbType == G2_MODELPART_HEAD)
+	{
+		Q_strncpyz( limbName , "head", sizeof( limbName  ) );
+		Q_strncpyz( stubCapName, "torso_cap_head", sizeof( stubCapName ) );
+	}
+	else if (limbType == G2_MODELPART_WAIST)
+	{
+		Q_strncpyz( limbName, "torso", sizeof( limbName ) );
+		Q_strncpyz( stubCapName, "hips_cap_torso", sizeof( stubCapName ) );
+	}
+	else if (limbType == G2_MODELPART_LARM)
+	{
+		BG_GetRootSurfNameWithVariant( ent->ghoul2, "l_arm", limbName, sizeof(limbName) );
+		BG_GetRootSurfNameWithVariant( ent->ghoul2, "torso", stubName, sizeof(stubName) );
+		Com_sprintf( stubCapName, sizeof( stubCapName), "%s_cap_l_arm", stubName );
+	}
+	else if (limbType == G2_MODELPART_RARM)
+	{
+		BG_GetRootSurfNameWithVariant( ent->ghoul2, "r_arm", limbName, sizeof(limbName) );
+		BG_GetRootSurfNameWithVariant( ent->ghoul2, "torso", stubName, sizeof(stubName) );
+		Com_sprintf( stubCapName, sizeof( stubCapName), "%s_cap_r_arm", stubName );
+	}
+	else if (limbType == G2_MODELPART_RHAND)
+	{
+		BG_GetRootSurfNameWithVariant( ent->ghoul2, "r_hand", limbName, sizeof(limbName) );
+		BG_GetRootSurfNameWithVariant( ent->ghoul2, "r_arm", stubName, sizeof(stubName) );
+		Com_sprintf( stubCapName, sizeof( stubCapName), "%s_cap_r_hand", stubName );
+	}
+	else if (limbType == G2_MODELPART_LLEG)
+	{
+		BG_GetRootSurfNameWithVariant( ent->ghoul2, "l_leg", limbName, sizeof(limbName) );
+		BG_GetRootSurfNameWithVariant( ent->ghoul2, "hips", stubName, sizeof(stubName) );
+		Com_sprintf( stubCapName, sizeof( stubCapName), "%s_cap_l_leg", stubName );
+	}
+	else if (limbType == G2_MODELPART_RLEG)
+	{
+		BG_GetRootSurfNameWithVariant( ent->ghoul2, "r_leg", limbName, sizeof(limbName) );
+		BG_GetRootSurfNameWithVariant( ent->ghoul2, "hips", stubName, sizeof(stubName) );
+		Com_sprintf( stubCapName, sizeof( stubCapName), "%s_cap_r_leg", stubName );
+	}
+	else
+	{//umm... just default to the right leg, I guess (same as on client)
+		BG_GetRootSurfNameWithVariant( ent->ghoul2, "r_leg", limbName, sizeof(limbName) );
+		BG_GetRootSurfNameWithVariant( ent->ghoul2, "hips", stubName, sizeof(stubName) );
+		Com_sprintf( stubCapName, sizeof( stubCapName), "%s_cap_r_leg", stubName );
+	}
+
+	if (ent->ghoul2 && limbName && trap_G2API_GetSurfaceRenderStatus(ent->ghoul2, 0, limbName))
+	{ //is it already off? If so there's no reason to be doing it again, so get out of here.
+		return;
+	}
+
+	VectorCopy( point, newPoint );
+	limb = G_Spawn();
+	limb->classname = "playerlimb";
+
+	/*
+	if (limbType == G2_MODELPART_WAIST)
+	{ //slight hack
+		newPoint[2] += 1;
+	}
+	*/
+
+	G_SetOrigin( limb, newPoint );
+	VectorCopy( newPoint, limb->s.pos.trBase );
+	limb->think = LimbThink;
+	limb->touch = LimbTouch;
+	limb->speed = level.time + Q_irand(8000, 16000);
+	limb->nextthink = level.time + FRAMETIME;
+
+	limb->r.svFlags = SVF_USE_CURRENT_ORIGIN;
+	limb->clipmask = MASK_SOLID;
+	limb->r.contents = CONTENTS_TRIGGER;
+	limb->physicsObject = qtrue;
+	VectorSet( limb->r.mins, -6.0f, -6.0f, -3.0f );
+	VectorSet( limb->r.maxs, 6.0f, 6.0f, 6.0f );
+
+	limb->s.g2radius = 200;
+
+	limb->s.eType = ET_GENERAL;
+	limb->s.weapon = G2_MODEL_PART;
+	limb->s.modelGhoul2 = limbType;
+	limb->s.modelindex = ent->s.number;
+	if (!ent->client)
+	{
+		limb->s.modelindex = -1;
+		limb->s.otherEntityNum2 = ent->s.number;
+	}
+
+	VectorClear(limb->s.apos.trDelta);
+
+	if (ent->client)
+	{
+		VectorCopy(ent->client->ps.viewangles, limb->r.currentAngles);
+		VectorCopy(ent->client->ps.viewangles, limb->s.apos.trBase);
+	}
+	else
+	{
+		VectorCopy(ent->r.currentAngles, limb->r.currentAngles);
+		VectorCopy(ent->r.currentAngles, limb->s.apos.trBase);
+	}
+
+	//Set up the ExPhys values for the entity.
+	limb->epGravFactor = 0;
+	VectorClear(limb->epVelocity);
+	VectorSubtract( point, ent->r.currentOrigin, dir );
+	VectorNormalize( dir );
+	if (ent->client)
+	{
+		VectorCopy(ent->client->ps.velocity, vel);
+	}
+	else
+	{
+		VectorCopy(ent->s.pos.trDelta, vel);
+	}
+	VectorMA( vel, 80, dir, limb->epVelocity );
+
+	//add some vertical velocity
+	if (limbType == G2_MODELPART_HEAD ||
+		limbType == G2_MODELPART_WAIST)
+	{
+		limb->epVelocity[2] += 10;
+	}
+
+	if (enemy && enemy->client && ent && ent != enemy && ent->s.number != enemy->s.number &&
+		enemy->client->ps.weapon == WP_SABER && enemy->client->olderIsValid &&
+		(level.time - enemy->client->lastSaberStorageTime) < 200)
+	{ //The enemy has valid saber positions between this and last frame. Use them to factor in direction of the limb.
+		vec3_t dif;
+		float totalDistance;
+		const float distScale = 1.2f;
+
+		//scale down the initial velocity first, which is based on the speed of the limb owner.
+		//ExPhys object velocity operates on a slightly different scale than Q3-based physics velocity.
+		VectorScale(limb->epVelocity, 0.4f, limb->epVelocity);
+
+		VectorSubtract(enemy->client->lastSaberBase_Always, enemy->client->olderSaberBase, dif);
+		totalDistance = VectorNormalize(dif);
+
+		VectorScale(dif, totalDistance*distScale, dif);
+		VectorAdd(limb->epVelocity, dif, limb->epVelocity);
+
+		if (ent->client && (ent->client->ps.torsoTimer > 0 || !BG_InDeathAnim(ent->client->ps.torsoAnim)))
+		{ //if he's done with his death anim we don't actually want the limbs going far
+			vec3_t preVel;
+
+			VectorCopy(limb->epVelocity, preVel);
+			preVel[2] = 0;
+			totalDistance = VectorNormalize(preVel);
+
+			if (totalDistance < 40.0f)
+			{
+				float mAmt = 40.0f;//60.0f/totalDistance;
+
+				limb->epVelocity[0] = preVel[0]*mAmt;
+				limb->epVelocity[1] = preVel[1]*mAmt;
+			}
+		}
+		else if (ent->client)
+		{
+			VectorScale(limb->epVelocity, 0.3f, limb->epVelocity);
+		}
+	}
+
+	if (ent->s.eType == ET_NPC && ent->ghoul2 && limbName && stubCapName)
+	{ //if it's an npc remove these surfs on the server too. For players we don't even care cause there's no further dismemberment after death.
+		trap_G2API_SetSurfaceOnOff(ent->ghoul2, limbName, 0x00000100);
+		trap_G2API_SetSurfaceOnOff(ent->ghoul2, stubCapName, 0);
+	}
+
+	limb->s.customRGBA[0] = ent->s.customRGBA[0];
+	limb->s.customRGBA[1] = ent->s.customRGBA[1];
+	limb->s.customRGBA[2] = ent->s.customRGBA[2];
+	limb->s.customRGBA[3] = ent->s.customRGBA[3];
+
+	trap_LinkEntity( limb );
+}
+
+void DismembermentTest(gentity_t *self)
+{
+	int sect = G2_MODELPART_HEAD;
+	vec3_t boltPoint;
+
+	while (sect <= G2_MODELPART_RLEG)
+	{
+		G_GetDismemberBolt(self, boltPoint, sect);
+		G_Dismember( self, self, boltPoint, sect, 90, 0, BOTH_DEATH1, qfalse );
+		sect++;
+	}
+}
+
+void DismembermentByNum(gentity_t *self, int num)
+{
+	int sect = G2_MODELPART_HEAD;
+	vec3_t boltPoint;
+
+	switch (num)
+	{
+	case 0:
+		sect = G2_MODELPART_HEAD;
+		break;
+	case 1:
+		sect = G2_MODELPART_WAIST;
+		break;
+	case 2:
+		sect = G2_MODELPART_LARM;
+		break;
+	case 3:
+		sect = G2_MODELPART_RARM;
+		break;
+	case 4:
+		sect = G2_MODELPART_RHAND;
+		break;
+	case 5:
+		sect = G2_MODELPART_LLEG;
+		break;
+	case 6:
+		sect = G2_MODELPART_RLEG;
+		break;
+	default:
+		break;
+	}
+
+	G_GetDismemberBolt(self, boltPoint, sect);
+	G_Dismember( self, self, boltPoint, sect, 90, 0, BOTH_DEATH1, qfalse );
+}
+
+int G_GetHitQuad( gentity_t *self, vec3_t hitloc )
+{
+	vec3_t diff, fwdangles={0,0,0}, right;
+	vec3_t clEye;
+	float rightdot;
+	float zdiff;
+	int hitLoc = gPainHitLoc;
+
+	if (self->client)
+	{
+		VectorCopy(self->client->ps.origin, clEye);
+		clEye[2] += self->client->ps.viewheight;
+	}
+	else
+	{
+		VectorCopy(self->s.pos.trBase, clEye);
+		clEye[2] += 16;
+	}
+
+	VectorSubtract( hitloc, clEye, diff );
+	diff[2] = 0;
+	VectorNormalize( diff );
+
+	if (self->client)
+	{
+		fwdangles[1] = self->client->ps.viewangles[1];
+	}
+	else
+	{
+		fwdangles[1] = self->s.apos.trBase[1];
+	}
+	// Ultimately we might care if the shot was ahead or behind, but for now, just quadrant is fine.
+	AngleVectors( fwdangles, NULL, right, NULL );
+
+	rightdot = DotProduct(right, diff);
+	zdiff = hitloc[2] - clEye[2];
+	
+	if ( zdiff > 0 )
+	{
+		if ( rightdot > 0.3 )
+		{
+			hitLoc = G2_MODELPART_RARM;
+		}
+		else if ( rightdot < -0.3 )
+		{
+			hitLoc = G2_MODELPART_LARM;
+		}
+		else
+		{
+			hitLoc = G2_MODELPART_HEAD;
+		}
+	}
+	else if ( zdiff > -20 )
+	{
+		if ( rightdot > 0.1 )
+		{
+			hitLoc = G2_MODELPART_RARM;
+		}
+		else if ( rightdot < -0.1 )
+		{
+			hitLoc = G2_MODELPART_LARM;
+		}
+		else
+		{
+			hitLoc = G2_MODELPART_HEAD;
+		}
+	}
+	else
+	{
+		if ( rightdot >= 0 )
+		{
+			hitLoc = G2_MODELPART_RLEG;
+		}
+		else
+		{
+			hitLoc = G2_MODELPART_LLEG;
+		}
+	}
+
+	return hitLoc;
+}
+
+int gGAvoidDismember = 0;
+
+void UpdateClientRenderBolts(gentity_t *self, vec3_t renderOrigin, vec3_t renderAngles);
+
+qboolean G_GetHitLocFromSurfName( gentity_t *ent, const char *surfName, int *hitLoc, vec3_t point, vec3_t dir, vec3_t bladeDir, int mod )
+{
+	qboolean dismember = qfalse;
+	int actualTime;
+	int kneeLBolt = -1;
+	int kneeRBolt = -1;
+	int handRBolt = -1;
+	int handLBolt = -1;
+	int footRBolt = -1;
+	int footLBolt = -1;
+
+	*hitLoc = HL_NONE;
+
+	if ( !surfName || !surfName[0] )
+	{
+		return qfalse;
+	}
+
+	if( !ent->client )
+	{
+		return qfalse;
+	}
+
+	if (!point)
+	{
+		return qfalse;
+	}
+
+	if ( ent->client 
+		&& ( ent->client->NPC_class == CLASS_R2D2 
+			|| ent->client->NPC_class == CLASS_R2D2 
+			|| ent->client->NPC_class == CLASS_GONK
+			|| ent->client->NPC_class == CLASS_MOUSE
+			|| ent->client->NPC_class == CLASS_SENTRY
+			|| ent->client->NPC_class == CLASS_INTERROGATOR
+			|| ent->client->NPC_class == CLASS_SENTRY
+			|| ent->client->NPC_class == CLASS_PROBE ) )
+	{//we don't care about per-surface hit-locations or dismemberment for these guys 
+		return qfalse;
+	}
+
+	if (ent->localAnimIndex <= 1)
+	{ //humanoid
+		handLBolt = trap_G2API_AddBolt(ent->ghoul2, 0, "*l_hand");
+		handRBolt = trap_G2API_AddBolt(ent->ghoul2, 0, "*r_hand");
+		kneeLBolt = trap_G2API_AddBolt(ent->ghoul2, 0, "*hips_l_knee");
+		kneeRBolt = trap_G2API_AddBolt(ent->ghoul2, 0, "*hips_r_knee");
+		footLBolt = trap_G2API_AddBolt(ent->ghoul2, 0, "*l_leg_foot");
+		footRBolt = trap_G2API_AddBolt(ent->ghoul2, 0, "*r_leg_foot");
+	}
+
+	if ( ent->client && (ent->client->NPC_class == CLASS_ATST) )
+	{
+		//FIXME: almost impossible to hit these... perhaps we should
+		//		check for splashDamage and do radius damage to these parts?
+		//		Or, if we ever get bbox G2 traces, that may fix it, too
+		if (!Q_stricmp("head_light_blaster_cann",surfName))
+		{
+			*hitLoc = HL_ARM_LT;
+		}
+		else if (!Q_stricmp("head_concussion_charger",surfName))
+		{
+			*hitLoc = HL_ARM_RT;
+		}
+		return(qfalse);
+	}
+	else if ( ent->client && (ent->client->NPC_class == CLASS_MARK1) )
+	{
+		if (!Q_stricmp("l_arm",surfName))
+		{
+			*hitLoc = HL_ARM_LT;
+		}
+		else if (!Q_stricmp("r_arm",surfName))
+		{
+			*hitLoc = HL_ARM_RT;
+		}
+		else if (!Q_stricmp("torso_front",surfName))
+		{
+			*hitLoc = HL_CHEST;
+		}
+		else if (!Q_stricmp("torso_tube1",surfName))
+		{
+			*hitLoc = HL_GENERIC1;
+		}
+		else if (!Q_stricmp("torso_tube2",surfName))
+		{
+			*hitLoc = HL_GENERIC2;
+		}
+		else if (!Q_stricmp("torso_tube3",surfName))
+		{
+			*hitLoc = HL_GENERIC3;
+		}
+		else if (!Q_stricmp("torso_tube4",surfName))
+		{
+			*hitLoc = HL_GENERIC4;
+		}
+		else if (!Q_stricmp("torso_tube5",surfName))
+		{
+			*hitLoc = HL_GENERIC5;
+		}
+		else if (!Q_stricmp("torso_tube6",surfName))
+		{
+			*hitLoc = HL_GENERIC6;
+		}
+		return(qfalse);
+	}
+	else if ( ent->client && (ent->client->NPC_class == CLASS_MARK2) )
+	{
+		if (!Q_stricmp("torso_canister1",surfName))
+		{
+			*hitLoc = HL_GENERIC1;
+		}
+		else if (!Q_stricmp("torso_canister2",surfName))
+		{
+			*hitLoc = HL_GENERIC2;
+		}
+		else if (!Q_stricmp("torso_canister3",surfName))
+		{
+			*hitLoc = HL_GENERIC3;
+		}
+		return(qfalse);
+	}
+	else if ( ent->client && (ent->client->NPC_class == CLASS_GALAKMECH) )
+	{
+		if (!Q_stricmp("torso_antenna",surfName)||!Q_stricmp("torso_antenna_base",surfName))
+		{
+			*hitLoc = HL_GENERIC1;
+		}
+		else if (!Q_stricmp("torso_shield",surfName))
+		{
+			*hitLoc = HL_GENERIC2;
+		}
+		else
+		{
+			*hitLoc = HL_CHEST;
+		}
+		return(qfalse);
+	}
+
+	//FIXME: check the hitLoc and hitDir against the cap tag for the place 
+	//where the split will be- if the hit dir is roughly perpendicular to 
+	//the direction of the cap, then the split is allowed, otherwise we
+	//hit it at the wrong angle and should not dismember...
+	actualTime = level.time;
+	if ( !Q_strncmp( "hips", surfName, 4 ) )
+	{//FIXME: test properly for legs
+		*hitLoc = HL_WAIST;
+		if ( ent->client != NULL && ent->ghoul2 )
+		{
+			mdxaBone_t	boltMatrix;
+			vec3_t	tagOrg, angles;
+
+			VectorSet( angles, 0, ent->r.currentAngles[YAW], 0 );
+			if (kneeLBolt>=0)
+			{
+				trap_G2API_GetBoltMatrix( ent->ghoul2, 0, kneeLBolt, 
+								&boltMatrix, angles, ent->r.currentOrigin,
+								actualTime, NULL, ent->modelScale );
+				BG_GiveMeVectorFromMatrix( &boltMatrix, ORIGIN, tagOrg );
+				if ( DistanceSquared( point, tagOrg ) < 100 )
+				{//actually hit the knee
+					*hitLoc = HL_LEG_LT;
+				}
+			}
+			if (*hitLoc == HL_WAIST)
+			{
+				if (kneeRBolt>=0)
+				{
+					trap_G2API_GetBoltMatrix( ent->ghoul2, 0, kneeRBolt, 
+									&boltMatrix, angles, ent->r.currentOrigin,
+									actualTime, NULL, ent->modelScale );
+					BG_GiveMeVectorFromMatrix( &boltMatrix, ORIGIN, tagOrg );
+					if ( DistanceSquared( point, tagOrg ) < 100 )
+					{//actually hit the knee
+						*hitLoc = HL_LEG_RT;
+					}
+				}
+			}
+		}
+	}
+	else if ( !Q_strncmp( "torso", surfName, 5 ) )
+	{
+		if ( !ent->client )
+		{
+			*hitLoc = HL_CHEST;
+		}
+		else
+		{
+			vec3_t	t_fwd, t_rt, t_up, dirToImpact;
+			float frontSide, rightSide, upSide;
+			AngleVectors( ent->client->renderInfo.torsoAngles, t_fwd, t_rt, t_up );
+
+			if (ent->client->renderInfo.boltValidityTime != level.time)
+			{
+				vec3_t renderAng;
+
+				renderAng[0] = 0;
+				renderAng[1] = ent->client->ps.viewangles[YAW];
+				renderAng[2] = 0;
+
+				UpdateClientRenderBolts(ent, ent->client->ps.origin, renderAng);
+			}
+
+			VectorSubtract( point, ent->client->renderInfo.torsoPoint, dirToImpact );
+			frontSide = DotProduct( t_fwd, dirToImpact );
+			rightSide = DotProduct( t_rt, dirToImpact );
+			upSide = DotProduct( t_up, dirToImpact );
+			if ( upSide < -10 )
+			{//hit at waist
+				*hitLoc = HL_WAIST;
+			}
+			else
+			{//hit on upper torso
+				if ( rightSide > 4 )
+				{
+					*hitLoc = HL_ARM_RT;
+				}
+				else if ( rightSide < -4 )
+				{
+					*hitLoc = HL_ARM_LT;
+				}
+				else if ( rightSide > 2 )
+				{
+					if ( frontSide > 0 )
+					{
+						*hitLoc = HL_CHEST_RT;
+					}
+					else
+					{
+						*hitLoc = HL_BACK_RT;
+					}
+				}
+				else if ( rightSide < -2 )
+				{
+					if ( frontSide > 0 )
+					{
+						*hitLoc = HL_CHEST_LT;
+					}
+					else
+					{
+						*hitLoc = HL_BACK_LT;
+					}
+				}
+				else if ( upSide > -3 && mod == MOD_SABER )
+				{
+					*hitLoc = HL_HEAD;
+				}
+				else if ( frontSide > 0 )
+				{
+					*hitLoc = HL_CHEST;
+				}
+				else
+				{
+					*hitLoc = HL_BACK;
+				}
+			}
+		}
+	}
+	else if ( !Q_strncmp( "head", surfName, 4 ) )
+	{
+		*hitLoc = HL_HEAD;
+	}
+	else if ( !Q_strncmp( "r_arm", surfName, 5 ) )
+	{
+		*hitLoc = HL_ARM_RT;
+		if ( ent->client != NULL && ent->ghoul2 )
+		{
+			mdxaBone_t	boltMatrix;
+			vec3_t	tagOrg, angles;
+
+			VectorSet( angles, 0, ent->r.currentAngles[YAW], 0 );
+			if (handRBolt>=0)
+			{
+				trap_G2API_GetBoltMatrix( ent->ghoul2, 0, handRBolt, 
+								&boltMatrix, angles, ent->r.currentOrigin,
+								actualTime, NULL, ent->modelScale );
+				BG_GiveMeVectorFromMatrix( &boltMatrix, ORIGIN, tagOrg );
+				if ( DistanceSquared( point, tagOrg ) < 256 )
+				{//actually hit the hand
+					*hitLoc = HL_HAND_RT;
+				}
+			}
+		}
+	}
+	else if ( !Q_strncmp( "l_arm", surfName, 5 ) )
+	{
+		*hitLoc = HL_ARM_LT;
+		if ( ent->client != NULL && ent->ghoul2 )
+		{
+			mdxaBone_t	boltMatrix;
+			vec3_t	tagOrg, angles;
+
+			VectorSet( angles, 0, ent->r.currentAngles[YAW], 0 );
+			if (handLBolt>=0)
+			{
+				trap_G2API_GetBoltMatrix( ent->ghoul2, 0, handLBolt, 
+								&boltMatrix, angles, ent->r.currentOrigin,
+								actualTime, NULL, ent->modelScale );
+				BG_GiveMeVectorFromMatrix( &boltMatrix, ORIGIN, tagOrg );
+				if ( DistanceSquared( point, tagOrg ) < 256 )
+				{//actually hit the hand
+					*hitLoc = HL_HAND_LT;
+				}
+			}
+		}
+	}
+	else if ( !Q_strncmp( "r_leg", surfName, 5 ) )
+	{
+		*hitLoc = HL_LEG_RT;
+		if ( ent->client != NULL && ent->ghoul2 )
+		{
+			mdxaBone_t	boltMatrix;
+			vec3_t	tagOrg, angles;
+
+			VectorSet( angles, 0, ent->r.currentAngles[YAW], 0 );
+			if (footRBolt>=0)
+			{
+				trap_G2API_GetBoltMatrix( ent->ghoul2, 0, footRBolt, 
+								&boltMatrix, angles, ent->r.currentOrigin,
+								actualTime, NULL, ent->modelScale );
+				BG_GiveMeVectorFromMatrix( &boltMatrix, ORIGIN, tagOrg );
+				if ( DistanceSquared( point, tagOrg ) < 100 )
+				{//actually hit the foot
+					*hitLoc = HL_FOOT_RT;
+				}
+			}
+		}
+	}
+	else if ( !Q_strncmp( "l_leg", surfName, 5 ) )
+	{
+		*hitLoc = HL_LEG_LT;
+		if ( ent->client != NULL && ent->ghoul2 )
+		{
+			mdxaBone_t	boltMatrix;
+			vec3_t	tagOrg, angles;
+
+			VectorSet( angles, 0, ent->r.currentAngles[YAW], 0 );
+			if (footLBolt>=0)
+			{
+				trap_G2API_GetBoltMatrix( ent->ghoul2, 0, footLBolt, 
+								&boltMatrix, angles, ent->r.currentOrigin,
+								actualTime, NULL, ent->modelScale );
+				BG_GiveMeVectorFromMatrix( &boltMatrix, ORIGIN, tagOrg );
+				if ( DistanceSquared( point, tagOrg ) < 100 )
+				{//actually hit the foot
+					*hitLoc = HL_FOOT_LT;
+				}
+			}
+		}
+	}
+	else if ( !Q_strncmp( "r_hand", surfName, 6 ) || !Q_strncmp( "w_", surfName, 2 ) )
+	{//right hand or weapon
+		*hitLoc = HL_HAND_RT;
+	}
+	else if ( !Q_strncmp( "l_hand", surfName, 6 ) )
+	{
+		*hitLoc = HL_HAND_LT;
+	}
+	/*
+#ifdef _DEBUG
+	else
+	{
+		Com_Printf( "ERROR: surface %s does not belong to any hitLocation!!!\n", surfName );
+	}
+#endif //_DEBUG
+	*/
+
+	//if ( g_dismemberment->integer >= 11381138 || !ent->client->dismembered )
+	if (g_dismember.integer == 100)
+	{ //full probability...
+		if ( ent->client && ent->client->NPC_class == CLASS_PROTOCOL )
+		{
+			dismember = qtrue;
+		}
+		else if ( dir && (dir[0] || dir[1] || dir[2]) &&
+			bladeDir && (bladeDir[0] || bladeDir[1] || bladeDir[2]) )
+		{//we care about direction (presumably for dismemberment)
+			//if ( g_dismemberProbabilities->value<=0.0f||G_Dismemberable( ent, *hitLoc ) )
+			if (1) //Fix me?
+			{//either we don't care about probabilties or the probability let us continue
+				char *tagName = NULL;
+				float	aoa = 0.5f;
+				//dir must be roughly perpendicular to the hitLoc's cap bolt
+				switch ( *hitLoc )
+				{
+					case HL_LEG_RT:
+						tagName = "*hips_cap_r_leg";
+						break;
+					case HL_LEG_LT:
+						tagName = "*hips_cap_l_leg";
+						break;
+					case HL_WAIST:
+						tagName = "*hips_cap_torso";
+						aoa = 0.25f;
+						break;
+					case HL_CHEST_RT:
+					case HL_ARM_RT:
+					case HL_BACK_LT:
+						tagName = "*torso_cap_r_arm";
+						break;
+					case HL_CHEST_LT:
+					case HL_ARM_LT:
+					case HL_BACK_RT:
+						tagName = "*torso_cap_l_arm";
+						break;
+					case HL_HAND_RT:
+						tagName = "*r_arm_cap_r_hand";
+						break;
+					case HL_HAND_LT:
+						tagName = "*l_arm_cap_l_hand";
+						break;
+					case HL_HEAD:
+						tagName = "*torso_cap_head";
+						aoa = 0.25f;
+						break;
+					case HL_CHEST:
+					case HL_BACK:
+					case HL_FOOT_RT:
+					case HL_FOOT_LT:
+					default:
+						//no dismemberment possible with these, so no checks needed
+						break;
+				}
+				if ( tagName )
+				{
+					int tagBolt = trap_G2API_AddBolt( ent->ghoul2, 0, tagName );
+					if ( tagBolt != -1 )
+					{
+						mdxaBone_t	boltMatrix;
+						vec3_t	tagOrg, tagDir, angles;
+
+						VectorSet( angles, 0, ent->r.currentAngles[YAW], 0 );
+						trap_G2API_GetBoltMatrix( ent->ghoul2, 0, tagBolt, 
+										&boltMatrix, angles, ent->r.currentOrigin,
+										actualTime, NULL, ent->modelScale );
+						BG_GiveMeVectorFromMatrix( &boltMatrix, ORIGIN, tagOrg );
+						BG_GiveMeVectorFromMatrix( &boltMatrix, NEGATIVE_Y, tagDir );
+						if ( DistanceSquared( point, tagOrg ) < 256 )
+						{//hit close
+							float dot = DotProduct( dir, tagDir );
+							if ( dot < aoa && dot > -aoa )
+							{//hit roughly perpendicular
+								dot = DotProduct( bladeDir, tagDir );
+								if ( dot < aoa && dot > -aoa )
+								{//blade was roughly perpendicular
+									dismember = qtrue;
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+		else
+		{ //hmm, no direction supplied.
+			dismember = qtrue;
+		}
+	}
+	return dismember;
+}
+
+void G_CheckForDismemberment(gentity_t *ent, gentity_t *enemy, vec3_t point, int damage, int deathAnim, qboolean postDeath)
+{
+	int hitLoc = -1, hitLocUse = -1;
+	vec3_t boltPoint;
+	int dismember = g_dismember.integer;
+
+	if (ent->localAnimIndex > 1)
+	{
+		if (!ent->NPC)
+		{
+			return;
+		}
+
+		if (ent->client->NPC_class != CLASS_PROTOCOL)
+		{ //this is the only non-humanoid allowed to do dismemberment.
+			return;
+		}
+	}
+
+	if (!dismember)
+	{
+		return;
+	}
+
+	if (gGAvoidDismember == 1)
+	{
+		return;
+	}
+
+	if (gGAvoidDismember != 2)
+	{ //this means do the dismemberment regardless of randomness and damage
+		if (Q_irand(0, 100) > dismember)
+		{
+			return;
+		}
+
+		if (damage < 5)
+		{
+			return;
+		}
+	}
+
+	if (gGAvoidDismember == 2)
+	{
+		hitLoc = HL_HAND_RT;
+	}
+	else
+	{
+		if (d_saberGhoul2Collision.integer && ent->client && ent->client->g2LastSurfaceTime == level.time)
+		{
+			char hitSurface[MAX_QPATH];
+
+			trap_G2API_GetSurfaceName(ent->ghoul2, ent->client->g2LastSurfaceHit, 0, hitSurface);
+
+			if (hitSurface[0])
+			{
+				G_GetHitLocFromSurfName(ent, hitSurface, &hitLoc, point, vec3_origin, vec3_origin, MOD_UNKNOWN);
+			}
+		}
+
+		if (hitLoc == -1)
+		{
+			hitLoc = G_GetHitLocation( ent, point );
+		}
+	}
+
+	switch(hitLoc)
+	{
+	case HL_FOOT_RT:
+	case HL_LEG_RT:
+		hitLocUse = G2_MODELPART_RLEG;
+		break;
+	case HL_FOOT_LT:
+	case HL_LEG_LT:
+		hitLocUse = G2_MODELPART_LLEG;
+		break;
+		
+	case HL_WAIST:
+		hitLocUse = G2_MODELPART_WAIST;
+		break;
+		/*
+	case HL_BACK_RT:
+	case HL_BACK_LT:
+	case HL_BACK:
+	case HL_CHEST_RT:
+	case HL_CHEST_LT:
+	case HL_CHEST:
+		break;
+		*/
+	case HL_ARM_RT:
+		hitLocUse = G2_MODELPART_RARM;
+		break;
+	case HL_HAND_RT:
+		hitLocUse = G2_MODELPART_RHAND;
+		break;
+	case HL_ARM_LT:
+	case HL_HAND_LT:
+		hitLocUse = G2_MODELPART_LARM;
+		break;
+	case HL_HEAD:
+		hitLocUse = G2_MODELPART_HEAD;
+		break;
+	default:
+		hitLocUse = G_GetHitQuad(ent, point);
+		break;
+	}
+
+	if (hitLocUse == -1)
+	{
+		return;
+	}
+
+	if (ent->client)
+	{
+		G_GetDismemberBolt(ent, boltPoint, hitLocUse);
+		if ( g_austrian.integer 
+			&& (g_gametype.integer == GT_DUEL || g_gametype.integer == GT_POWERDUEL) )
+		{
+			G_LogPrintf( "Duel Dismemberment: %s dismembered at %s\n", ent->client->pers.netname, hitLocName[hitLoc] );
+		}
+	}
+	else
+	{
+		G_GetDismemberLoc(ent, boltPoint, hitLocUse);
+	}
+	G_Dismember(ent, enemy, boltPoint, hitLocUse, 90, 0, deathAnim, postDeath);
+}
+
+void G_LocationBasedDamageModifier(gentity_t *ent, vec3_t point, int mod, int dflags, int *damage)
+{
+	int hitLoc = -1;
+
+	if (!g_locationBasedDamage.integer)
+	{ //then leave it alone
+		return;
+	}
+
+	if ( (dflags&DAMAGE_NO_HIT_LOC) )
+	{ //then leave it alone
+		return;
+	}
+
+	if (mod == MOD_SABER && *damage <= 1)
+	{ //don't bother for idle damage
+		return;
+	}
+
+	if (!point)
+	{
+		return;
+	}
+
+	if ((d_saberGhoul2Collision.integer && ent->client && ent->client->g2LastSurfaceTime == level.time && mod == MOD_SABER) || //using ghoul2 collision? Then if the mod is a saber we should have surface data from the last hit (unless thrown).
+		(d_projectileGhoul2Collision.integer && ent->client && ent->client->g2LastSurfaceTime == level.time)) //It's safe to assume we died from the projectile that just set our surface index. So, go ahead and use that as the surf I guess.
+	{
+		char hitSurface[MAX_QPATH];
+
+		trap_G2API_GetSurfaceName(ent->ghoul2, ent->client->g2LastSurfaceHit, 0, hitSurface);
+
+		if (hitSurface[0])
+		{
+			G_GetHitLocFromSurfName(ent, hitSurface, &hitLoc, point, vec3_origin, vec3_origin, MOD_UNKNOWN);
+		}
+	}
+
+	if (hitLoc == -1)
+	{
+		hitLoc = G_GetHitLocation( ent, point );
+	}
+
+	switch (hitLoc)
+	{
+	case HL_FOOT_RT:
+	case HL_FOOT_LT:
+		*damage *= 0.5;
+		break;
+	case HL_LEG_RT:
+	case HL_LEG_LT:
+		*damage *= 0.7;
+		break;
+	case HL_WAIST:
+	case HL_BACK_RT:
+	case HL_BACK_LT:
+	case HL_BACK:
+	case HL_CHEST_RT:
+	case HL_CHEST_LT:
+	case HL_CHEST:
+		break; //normal damage
+	case HL_ARM_RT:
+	case HL_ARM_LT:
+		*damage *= 0.85;
+		break;
+	case HL_HAND_RT:
+	case HL_HAND_LT:
+		*damage *= 0.6;
+		break;
+	case HL_HEAD:
+		*damage *= 1.3;
+		break;
+	default:
+		break; //do nothing then
+	}
+}
+/*
+===================================
+rww - end dismemberment/lbd
+===================================
+*/
+
+qboolean G_ThereIsAMaster(void)
+{
+	int i = 0;
+	gentity_t *ent;
+
+	while (i < MAX_CLIENTS)
+	{
+		ent = &g_entities[i];
+
+		if (ent && ent->client && ent->client->ps.isJediMaster)
+		{
+			return qtrue;
+		}
+
+		i++;
+	}
+
+	return qfalse;
+}
+
+void G_Knockdown( gentity_t *victim )
+{
+	if ( victim && victim->client && BG_KnockDownable(&victim->client->ps) )
+	{
+		victim->client->ps.forceHandExtend = HANDEXTEND_KNOCKDOWN;
+		victim->client->ps.forceDodgeAnim = 0;
+		victim->client->ps.forceHandExtendTime = level.time + 1100;
+		victim->client->ps.quickerGetup = qfalse;
+	}
+}
+
+/*
+============
+T_Damage
+
+targ		entity that is being damaged
+inflictor	entity that is causing the damage
+attacker	entity that caused the inflictor to damage targ
+	example: targ=monster, inflictor=rocket, attacker=player
+
+dir			direction of the attack for knockback
+point		point at which the damage is being inflicted, used for headshots
+damage		amount of damage being inflicted
+knockback	force to be applied against targ as a result of the damage
+
+inflictor, attacker, dir, and point can be NULL for environmental effects
+
+dflags		these flags are used to control how T_Damage works
+	DAMAGE_RADIUS			damage was indirect (from a nearby explosion)
+	DAMAGE_NO_ARMOR			armor does not protect from this damage
+	DAMAGE_NO_KNOCKBACK		do not affect velocity, just view angles
+	DAMAGE_NO_PROTECTION	kills godmode, armor, everything
+	DAMAGE_HALF_ABSORB		half shields, half health
+	DAMAGE_HALF_ARMOR_REDUCTION		Any damage that shields incur is halved
+============
+*/
+extern qboolean gSiegeRoundBegun;
+
+int gPainMOD = 0;
+int gPainHitLoc = -1;
+vec3_t gPainPoint;
+
+void G_Damage( gentity_t *targ, gentity_t *inflictor, gentity_t *attacker,
+			   vec3_t dir, vec3_t point, int damage, int dflags, int mod ) {
+	gclient_t	*client;
+	int			take;
+	int			save;
+	int			asave;
+	int			knockback;
+	int			max;
+	int			subamt = 0;
+	float		famt = 0;
+	float		hamt = 0;
+	float		shieldAbsorbed = 0;
+
+	if (targ && targ->damageRedirect)
+	{
+		G_Damage(&g_entities[targ->damageRedirectTo], inflictor, attacker, dir, point, damage, dflags, mod);
+		return;
+	}
+
+	if (mod == MOD_DEMP2 && targ && targ->inuse && targ->client)
+	{
+		if ( targ->client->ps.electrifyTime < level.time )
+		{//electrocution effect
+			if (targ->s.eType == ET_NPC && targ->s.NPC_class == CLASS_VEHICLE &&
+				targ->m_pVehicle && (targ->m_pVehicle->m_pVehicleInfo->type == VH_SPEEDER || targ->m_pVehicle->m_pVehicleInfo->type == VH_WALKER))
+			{ //do some extra stuff to speeders/walkers
+				targ->client->ps.electrifyTime = level.time + Q_irand( 3000, 4000 );
+			}
+			else if ( targ->s.NPC_class != CLASS_VEHICLE 
+				|| (targ->m_pVehicle && targ->m_pVehicle->m_pVehicleInfo->type != VH_FIGHTER) )
+			{//don't do this to fighters
+				targ->client->ps.electrifyTime = level.time + Q_irand( 300, 800 );
+			}
+		}
+	}
+
+	if (g_gametype.integer == GT_SIEGE &&
+		!gSiegeRoundBegun)
+	{ //nothing can be damaged til the round starts.
+		return;
+	}
+
+	if (!targ->takedamage) {
+		return;
+	}
+
+	if ( (targ->flags&FL_SHIELDED) && mod != MOD_SABER  && !targ->client)
+	{//magnetically protected, this thing can only be damaged by lightsabers
+		return;
+	}
+
+	if ((targ->flags & FL_DMG_BY_SABER_ONLY) && mod != MOD_SABER)
+	{ //saber-only damage
+		return;
+	}
+
+	if ( targ->client )
+	{//don't take damage when in a walker, or fighter
+		//unless the walker/fighter is dead!!! -rww
+		if ( targ->client->ps.clientNum < MAX_CLIENTS && targ->client->ps.m_iVehicleNum )
+		{
+			gentity_t *veh = &g_entities[targ->client->ps.m_iVehicleNum];
+			if ( veh->m_pVehicle && veh->health > 0 )
+			{
+				if ( veh->m_pVehicle->m_pVehicleInfo->type == VH_WALKER ||
+					 veh->m_pVehicle->m_pVehicleInfo->type == VH_FIGHTER)
+				{
+					if (!(dflags & DAMAGE_NO_PROTECTION))
+					{
+						return;
+					}
+				}
+			}
+		}
+	}
+
+	if ((targ->flags & FL_DMG_BY_HEAVY_WEAP_ONLY))
+	{ //only take damage from explosives and such
+		if (mod != MOD_REPEATER_ALT &&
+			mod != MOD_ROCKET &&
+			mod != MOD_FLECHETTE_ALT_SPLASH &&
+			mod != MOD_ROCKET_HOMING &&
+			mod != MOD_THERMAL &&
+			mod != MOD_THERMAL_SPLASH &&
+			mod != MOD_TRIP_MINE_SPLASH &&
+			mod != MOD_TIMED_MINE_SPLASH &&
+			mod != MOD_DET_PACK_SPLASH &&
+			mod != MOD_VEHICLE &&
+			mod != MOD_CONC &&
+			mod != MOD_CONC_ALT &&
+			mod != MOD_SABER &&
+			mod != MOD_TURBLAST &&
+			mod != MOD_SUICIDE &&
+			mod != MOD_FALLING &&
+			mod != MOD_CRUSH &&
+			mod != MOD_TELEFRAG &&
+			mod != MOD_TRIGGER_HURT)
+		{
+			if ( mod != MOD_MELEE || !G_HeavyMelee( attacker ) )
+			{ //let classes with heavy melee ability damage heavy wpn dmg doors with fists
+				return;
+			}
+		}
+	}
+
+	if (targ->flags & FL_BBRUSH)
+	{
+		if (mod == MOD_DEMP2 ||
+			mod == MOD_DEMP2_ALT ||
+			mod == MOD_BRYAR_PISTOL ||
+			mod == MOD_BRYAR_PISTOL_ALT ||
+			mod == MOD_MELEE)
+		{ //these don't damage bbrushes.. ever
+			if ( mod != MOD_MELEE || !G_HeavyMelee( attacker ) )
+			{ //let classes with heavy melee ability damage breakable brushes with fists
+				return;
+			}
+		}
+	}
+
+	if (targ && targ->client && targ->client->ps.duelInProgress)
+	{
+		if (attacker && attacker->client && attacker->s.number != targ->client->ps.duelIndex)
+		{
+			return;
+		}
+		else if (attacker && attacker->client && mod != MOD_SABER)
+		{
+			return;
+		}
+	}
+	if (attacker && attacker->client && attacker->client->ps.duelInProgress)
+	{
+		if (targ && targ->client && targ->s.number != attacker->client->ps.duelIndex)
+		{
+			return;
+		}
+		else if (targ && targ->client && mod != MOD_SABER)
+		{
+			return;
+		}
+	}
+
+	if (targ && targ->client && (targ->client->ps.fd.forcePowersActive & (1 << FP_RAGE)))
+	{
+		damage *= 0.5;
+	}
+
+	// the intermission has allready been qualified for, so don't
+	// allow any extra scoring
+	if ( level.intermissionQueued ) {
+		return;
+	}
+	if ( !inflictor ) {
+		inflictor = &g_entities[ENTITYNUM_WORLD];
+	}
+	if ( !attacker ) {
+		attacker = &g_entities[ENTITYNUM_WORLD];
+	}
+
+	// shootable doors / buttons don't actually have any health
+
+	//if genericValue4 == 1 then it's glass or a breakable and those do have health
+	if ( targ->s.eType == ET_MOVER && targ->genericValue4 != 1 ) {
+		if ( targ->use && targ->moverState == MOVER_POS1 ) {
+			GlobalUse( targ, inflictor, attacker );
+		}
+		return;
+	}
+	// reduce damage by the attacker's handicap value
+	// unless they are rocket jumping
+	if ( attacker->client && attacker != targ && attacker->s.eType == ET_PLAYER ) {
+		max = attacker->client->ps.stats[STAT_MAX_HEALTH];
+		damage = damage * max / 100;
+	}
+
+	if ( !(dflags&DAMAGE_NO_HIT_LOC) )
+	{//see if we should modify it by damage location
+		if (targ->inuse && (targ->client || targ->s.eType == ET_NPC) &&
+			attacker->inuse && (attacker->client || attacker->s.eType == ET_NPC))
+		{ //check for location based damage stuff.
+			G_LocationBasedDamageModifier(targ, point, mod, dflags, &damage);
+		}
+	}
+
+	if ( targ->client 
+		&& targ->client->NPC_class == CLASS_RANCOR 
+		&& (!attacker||!attacker->client||attacker->client->NPC_class!=CLASS_RANCOR) )
+	{
+		// I guess always do 10 points of damage...feel free to tweak as needed
+		if ( damage < 10 )
+		{//ignore piddly little damage
+			damage = 0;
+		}
+		else if ( damage >= 10 )
+		{
+			damage = 10;
+		}
+	}
+
+	client = targ->client;
+
+	if ( client ) {
+		if ( client->noclip ) {
+			return;
+		}
+	}
+
+	if ( !dir ) {
+		dflags |= DAMAGE_NO_KNOCKBACK;
+	} else {
+		VectorNormalize(dir);
+	}
+
+	knockback = damage;
+	if ( knockback > 200 ) {
+		knockback = 200;
+	}
+	if ( targ->flags & FL_NO_KNOCKBACK ) {
+		knockback = 0;
+	}
+	if ( dflags & DAMAGE_NO_KNOCKBACK ) {
+		knockback = 0;
+	}
+
+	// figure momentum add, even if the damage won't be taken
+	if ( knockback && targ->client ) {
+		vec3_t	kvel;
+		float	mass;
+
+		mass = 200;
+
+		if (mod == MOD_SABER)
+		{
+			VectorScale (dir, (g_knockback.value * (float)knockback / mass)*g_saberDmgVelocityScale.integer, kvel);
+		}
+		else
+		{
+			VectorScale (dir, g_knockback.value * (float)knockback / mass, kvel);
+		}
+		VectorAdd (targ->client->ps.velocity, kvel, targ->client->ps.velocity);
+
+		if (attacker && attacker->client && attacker != targ)
+		{
+			float dur = 5000;
+			float dur2 = 100;
+			if (targ->client && targ->s.eType == ET_NPC && targ->s.NPC_class == CLASS_VEHICLE)
+			{
+				dur = 25000;
+				dur2 = 25000;
+			}
+			targ->client->ps.otherKiller = attacker->s.number;
+			targ->client->ps.otherKillerTime = level.time + dur;
+			targ->client->ps.otherKillerDebounceTime = level.time + dur2;
+		}
+		// set the timer so that the other client can't cancel
+		// out the movement immediately
+		if ( !targ->client->ps.pm_time && (g_saberDmgVelocityScale.integer || mod != MOD_SABER) ) {
+			int		t;
+
+			t = knockback * 2;
+			if ( t < 50 ) {
+				t = 50;
+			}
+			if ( t > 200 ) {
+				t = 200;
+			}
+			targ->client->ps.pm_time = t;
+			targ->client->ps.pm_flags |= PMF_TIME_KNOCKBACK;
+		}
+	}
+	else if (targ->client && targ->s.eType == ET_NPC && targ->s.NPC_class == CLASS_VEHICLE && attacker != targ)
+	{
+		targ->client->ps.otherKiller = attacker->s.number;
+		targ->client->ps.otherKillerTime = level.time + 25000;
+		targ->client->ps.otherKillerDebounceTime = level.time + 25000;
+	}
+
+	
+	if ( (g_trueJedi.integer || g_gametype.integer == GT_SIEGE)
+		&& client )
+	{//less explosive damage for jedi, more saber damage for non-jedi
+		if ( client->ps.trueJedi 
+			|| (g_gametype.integer == GT_SIEGE&&client->ps.weapon == WP_SABER))
+		{//if the target is a trueJedi, reduce splash and explosive damage to 1/2
+			switch ( mod )
+			{
+			case MOD_REPEATER_ALT:
+			case MOD_REPEATER_ALT_SPLASH:
+			case MOD_DEMP2_ALT:
+			case MOD_FLECHETTE_ALT_SPLASH:
+			case MOD_ROCKET:
+			case MOD_ROCKET_SPLASH:
+			case MOD_ROCKET_HOMING:
+			case MOD_ROCKET_HOMING_SPLASH:
+			case MOD_THERMAL:
+			case MOD_THERMAL_SPLASH:
+			case MOD_TRIP_MINE_SPLASH:
+			case MOD_TIMED_MINE_SPLASH:
+			case MOD_DET_PACK_SPLASH:
+				damage *= 0.75;
+				break;
+			}
+		}
+		else if ( (client->ps.trueNonJedi || (g_gametype.integer == GT_SIEGE&&client->ps.weapon != WP_SABER))
+			&& mod == MOD_SABER )
+		{//if the target is a trueNonJedi, take more saber damage... combined with the 1.5 in the w_saber stuff, this is 6 times damage!
+			if ( damage < 100 )
+			{
+				damage *= 4;
+				if ( damage > 100 )
+				{
+					damage = 100;
+				}
+			}
+		}
+	}
+
+	if (attacker->client && targ->client && g_gametype.integer == GT_SIEGE &&
+		targ->client->siegeClass != -1 && (bgSiegeClasses[targ->client->siegeClass].classflags & (1<<CFL_STRONGAGAINSTPHYSICAL)))
+	{ //this class is flagged to take less damage from physical attacks.
+		//For now I'm just decreasing against any client-based attack, this can be changed later I guess.
+		damage *= 0.5;
+	}
+
+	// check for completely getting out of the damage
+	if ( !(dflags & DAMAGE_NO_PROTECTION) ) {
+
+		// if TF_NO_FRIENDLY_FIRE is set, don't do damage to the target
+		// if the attacker was on the same team
+		if ( targ != attacker)
+		{
+			if (OnSameTeam (targ, attacker))
+			{
+				if ( !g_friendlyFire.integer )
+				{
+					return;
+				}
+			}
+			else if (attacker && attacker->inuse &&
+				!attacker->client && attacker->activator &&
+				targ != attacker->activator &&
+				attacker->activator->inuse && attacker->activator->client)
+			{ //emplaced guns don't hurt teammates of user
+				if (OnSameTeam (targ, attacker->activator))
+				{
+					if ( !g_friendlyFire.integer )
+					{
+						return;
+					}
+				}
+			}
+			else if (targ->inuse && targ->client &&
+				g_gametype.integer >= GT_TEAM &&
+				attacker->s.number >= MAX_CLIENTS &&
+				attacker->alliedTeam &&
+				targ->client->sess.sessionTeam == attacker->alliedTeam &&
+				!g_friendlyFire.integer)
+			{ //things allied with my team should't hurt me.. I guess
+				return;
+			}
+		}
+
+		if (g_gametype.integer == GT_JEDIMASTER && !g_friendlyFire.integer &&
+			targ && targ->client && attacker && attacker->client &&
+			targ != attacker && !targ->client->ps.isJediMaster && !attacker->client->ps.isJediMaster &&
+			G_ThereIsAMaster())
+		{
+			return;
+		}
+
+		if (targ->s.number >= MAX_CLIENTS && targ->client 
+			&& targ->s.shouldtarget && targ->s.teamowner &&
+			attacker && attacker->inuse && attacker->client && targ->s.owner >= 0 && targ->s.owner < MAX_CLIENTS)
+		{
+			gentity_t *targown = &g_entities[targ->s.owner];
+
+			if (targown && targown->inuse && targown->client && OnSameTeam(targown, attacker))
+			{
+				if (!g_friendlyFire.integer)
+				{
+					return;
+				}
+			}
+		}
+
+		// check for godmode
+		if ( (targ->flags & FL_GODMODE) && targ->s.eType != ET_NPC ) {
+			return;
+		}
+
+		if (targ && targ->client && (targ->client->ps.eFlags & EF_INVULNERABLE) &&
+			attacker && attacker->client && targ != attacker)
+		{
+			if (targ->client->invulnerableTimer <= level.time)
+			{
+				targ->client->ps.eFlags &= ~EF_INVULNERABLE;
+			}
+			else
+			{
+				return;
+			}
+		}
+	}
+
+	//check for teamnodmg
+	//NOTE: non-client objects hitting clients (and clients hitting clients) purposely doesn't obey this teamnodmg (for emplaced guns)
+	if ( attacker && !targ->client )
+	{//attacker hit a non-client
+		if ( g_gametype.integer == GT_SIEGE &&
+			!g_ff_objectives.integer )
+		{//in siege mode (and...?)
+			if ( targ->teamnodmg )
+			{//targ shouldn't take damage from a certain team
+				if ( attacker->client )
+				{//a client hit a non-client object
+					if ( targ->teamnodmg == attacker->client->sess.sessionTeam )
+					{
+						return;
+					}
+				}
+				else if ( attacker->teamnodmg )
+				{//a non-client hit a non-client object
+					//FIXME: maybe check alliedTeam instead?
+					if ( targ->teamnodmg == attacker->teamnodmg )
+					{
+						if (attacker->activator &&
+							attacker->activator->inuse &&
+							attacker->activator->s.number < MAX_CLIENTS &&
+							attacker->activator->client &&
+							attacker->activator->client->sess.sessionTeam != targ->teamnodmg)
+						{ //uh, let them damage it I guess.
+						}
+						else
+						{
+							return;
+						}
+					}
+				}
+			}
+		}
+	}
+
+	// battlesuit protects from all radius damage (but takes knockback)
+	// and protects 50% against all damage
+	if ( client && client->ps.powerups[PW_BATTLESUIT] ) {
+		G_AddEvent( targ, EV_POWERUP_BATTLESUIT, 0 );
+		if ( ( dflags & DAMAGE_RADIUS ) || ( mod == MOD_FALLING ) ) {
+			return;
+		}
+		damage *= 0.5;
+	}
+
+	// add to the attacker's hit counter (if the target isn't a general entity like a prox mine)
+	if ( attacker->client && targ != attacker && targ->health > 0
+			&& targ->s.eType != ET_MISSILE
+			&& targ->s.eType != ET_GENERAL
+			&& client) {
+		if ( OnSameTeam( targ, attacker ) ) {
+			attacker->client->ps.persistant[PERS_HITS]--;
+		} else {
+			attacker->client->ps.persistant[PERS_HITS]++;
+		}
+		attacker->client->ps.persistant[PERS_ATTACKEE_ARMOR] = (targ->health<<8)|(client->ps.stats[STAT_ARMOR]);
+	}
+
+	// always give half damage if hurting self... but not in siege.  Heavy weapons need a counter.
+	// calculated after knockback, so rocket jumping works
+	if ( targ == attacker && !(dflags & DAMAGE_NO_SELF_PROTECTION)) {
+		if ( g_gametype.integer == GT_SIEGE )
+		{
+			damage *= 1.5;
+		}
+		else
+		{
+			damage *= 0.5;
+		}
+	}
+
+	if ( damage < 1 ) {
+		damage = 1;
+	}
+	take = damage;
+	save = 0;
+
+	// save some from armor
+	asave = CheckArmor (targ, take, dflags);
+
+	if (asave)
+	{
+		shieldAbsorbed = asave;
+	}
+
+	take -= asave;
+	if ( targ->client )
+	{//update vehicle shields and armor, check for explode 
+		if ( targ->client->NPC_class == CLASS_VEHICLE &&
+			targ->m_pVehicle )
+		{//FIXME: should be in its own function in g_vehicles.c now, too big to be here
+			int surface = -1;
+			if ( attacker )
+			{//so we know the last guy who shot at us
+				targ->enemy = attacker;
+			}
+
+			if ( ( targ->m_pVehicle->m_pVehicleInfo->type == VH_ANIMAL ) )
+			{
+				//((CVehicleNPC *)targ->NPC)->m_ulFlags |= CVehicleNPC::VEH_BUCKING;
+			}
+
+			targ->m_pVehicle->m_iShields = targ->client->ps.stats[STAT_ARMOR];
+			G_VehUpdateShields( targ );
+			targ->m_pVehicle->m_iArmor -= take;
+			if ( targ->m_pVehicle->m_iArmor <= 0 ) 
+			{
+				targ->s.eFlags |= EF_DEAD;
+				targ->client->ps.eFlags |= EF_DEAD;
+				targ->m_pVehicle->m_iArmor = 0;
+			}
+			if ( targ->m_pVehicle->m_pVehicleInfo->type == VH_FIGHTER )
+			{//get the last surf that was hit
+				if ( targ->client && targ->client->g2LastSurfaceTime == level.time)
+				{
+					char hitSurface[MAX_QPATH];
+
+					trap_G2API_GetSurfaceName(targ->ghoul2, targ->client->g2LastSurfaceHit, 0, hitSurface);
+
+					if (hitSurface[0])
+					{
+						surface = G_ShipSurfaceForSurfName( &hitSurface[0] );
+
+						if ( take && surface > 0 )
+						{//hit a certain part of the ship
+							int deathPoint = 0;
+
+							targ->locationDamage[surface] += take;
+
+							switch(surface)
+							{
+							case SHIPSURF_FRONT:
+								deathPoint = targ->m_pVehicle->m_pVehicleInfo->health_front;
+								break;
+							case SHIPSURF_BACK:
+								deathPoint = targ->m_pVehicle->m_pVehicleInfo->health_back;
+								break;
+							case SHIPSURF_RIGHT:
+								deathPoint = targ->m_pVehicle->m_pVehicleInfo->health_right;
+								break;
+							case SHIPSURF_LEFT:
+								deathPoint = targ->m_pVehicle->m_pVehicleInfo->health_left;
+								break;
+							default:
+								break;
+							}
+
+							//presume 0 means it wasn't set and so it should never die.
+							if ( deathPoint )
+							{
+								if ( targ->locationDamage[surface] >= deathPoint)
+								{ //this area of the ship is now dead
+									if ( G_FlyVehicleDestroySurface( targ, surface ) )
+									{//actually took off a surface
+										G_VehicleSetDamageLocFlags( targ, surface, deathPoint );
+									}
+								}
+								else
+								{
+									G_VehicleSetDamageLocFlags( targ, surface, deathPoint );
+								}
+							}
+						}
+					}
+				}
+			}
+			if ( targ->m_pVehicle->m_pVehicleInfo->type != VH_ANIMAL )
+			{
+				/*
+				if ( targ->m_pVehicle->m_iArmor <= 0 ) 
+				{//vehicle all out of armor
+					Vehicle_t *pVeh = targ->m_pVehicle;
+					if ( pVeh->m_iDieTime == 0 )
+					{//just start the flaming effect and explosion delay, if it's not going already...
+						pVeh->m_pVehicleInfo->StartDeathDelay( pVeh, 0 );
+					}
+				}
+				else*/
+				if ( attacker 
+						//&& attacker->client 
+						&& targ != attacker
+						&& point 
+						&& !VectorCompare( targ->client->ps.origin, point )
+						&& targ->m_pVehicle->m_LandTrace.fraction >= 1.0f)
+				{//just took a hit, knock us around
+					vec3_t	vUp, impactDir;
+					float	impactStrength = (damage/200.0f)*10.0f;
+					float	dot = 0.0f;
+					if ( impactStrength > 10.0f )
+					{
+						impactStrength = 10.0f;
+					}
+					//pitch or roll us based on where we were hit
+					AngleVectors( targ->m_pVehicle->m_vOrientation, NULL, NULL, vUp );
+					VectorSubtract( point, targ->r.currentOrigin, impactDir );
+					VectorNormalize( impactDir );
+					if ( surface <= 0 )
+					{//no surf guess where we were hit, then
+						vec3_t	vFwd, vRight;
+						AngleVectors( targ->m_pVehicle->m_vOrientation, vFwd, vRight, vUp );
+						dot = DotProduct( vRight, impactDir );
+						if ( dot > 0.4f )
+						{
+							surface = SHIPSURF_RIGHT;
+						}
+						else if ( dot < -0.4f )
+						{
+							surface = SHIPSURF_LEFT;
+						}
+						else
+						{
+							dot = DotProduct( vFwd, impactDir );
+							if ( dot > 0.0f )
+							{
+								surface = SHIPSURF_FRONT;
+							}
+							else
+							{
+								surface = SHIPSURF_BACK;
+							}
+						}
+					}
+					switch ( surface )
+					{
+					case SHIPSURF_FRONT:
+						dot = DotProduct( vUp, impactDir );
+						if ( dot > 0 )
+						{
+							targ->m_pVehicle->m_vOrientation[PITCH] += impactStrength;
+						}
+						else
+						{
+							targ->m_pVehicle->m_vOrientation[PITCH] -= impactStrength;
+						}
+						break;
+					case SHIPSURF_BACK:
+						dot = DotProduct( vUp, impactDir );
+						if ( dot > 0 )
+						{
+							targ->m_pVehicle->m_vOrientation[PITCH] -= impactStrength;
+						}
+						else
+						{
+							targ->m_pVehicle->m_vOrientation[PITCH] += impactStrength;
+						}
+						break;
+					case SHIPSURF_RIGHT:
+						dot = DotProduct( vUp, impactDir );
+						if ( dot > 0 )
+						{
+							targ->m_pVehicle->m_vOrientation[ROLL] -= impactStrength;
+						}
+						else
+						{
+							targ->m_pVehicle->m_vOrientation[ROLL] += impactStrength;
+						}
+						break;
+					case SHIPSURF_LEFT:
+						dot = DotProduct( vUp, impactDir );
+						if ( dot > 0 )
+						{
+							targ->m_pVehicle->m_vOrientation[ROLL] += impactStrength;
+						}
+						else
+						{
+							targ->m_pVehicle->m_vOrientation[ROLL] -= impactStrength;
+						}
+						break;
+					}
+
+				}
+			}
+		}
+	}
+
+	if ( mod == MOD_DEMP2 || mod == MOD_DEMP2_ALT )
+	{//FIXME: screw with non-animal vehicles, too?
+		if ( client )
+		{
+			if ( client->NPC_class == CLASS_VEHICLE 
+				&& targ->m_pVehicle
+				&& targ->m_pVehicle->m_pVehicleInfo
+				&& targ->m_pVehicle->m_pVehicleInfo->type == VH_FIGHTER )
+			{//all damage goes into the disruption of shields and systems
+				take = 0;
+			}
+			else
+			{
+
+				if (client->jetPackOn)
+				{ //disable jetpack temporarily
+					Jetpack_Off(targ);
+					client->jetPackToggleTime = level.time + Q_irand(3000, 10000);
+				}
+
+				if ( client->NPC_class == CLASS_PROTOCOL || client->NPC_class == CLASS_SEEKER ||
+					client->NPC_class == CLASS_R2D2 || client->NPC_class == CLASS_R5D2 ||
+					client->NPC_class == CLASS_MOUSE || client->NPC_class == CLASS_GONK )
+				{
+					// DEMP2 does more damage to these guys.
+					take *= 2;
+				}
+				else if ( client->NPC_class == CLASS_PROBE || client->NPC_class == CLASS_INTERROGATOR ||
+							client->NPC_class == CLASS_MARK1 || client->NPC_class == CLASS_MARK2 || client->NPC_class == CLASS_SENTRY ||
+							client->NPC_class == CLASS_ATST )
+				{
+					// DEMP2 does way more damage to these guys.
+					take *= 5;
+				}
+				else
+				{
+					if (take > 0)
+					{
+						take /= 3;
+						if (take < 1)
+						{
+							take = 1;
+						}
+					}
+				}
+			}
+		}
+	}
+
+#ifndef FINAL_BUILD
+	if ( g_debugDamage.integer ) {
+		G_Printf( "%i: client:%i health:%i damage:%i armor:%i\n", level.time, targ->s.number,
+			targ->health, take, asave );
+	}
+#endif
+
+	// add to the damage inflicted on a player this frame
+	// the total will be turned into screen blends and view angle kicks
+	// at the end of the frame
+	if ( client ) {
+		if ( attacker ) {
+			client->ps.persistant[PERS_ATTACKER] = attacker->s.number;
+		} else {
+			client->ps.persistant[PERS_ATTACKER] = ENTITYNUM_WORLD;
+		}
+		client->damage_armor += asave;
+		client->damage_blood += take;
+		client->damage_knockback += knockback;
+		if ( dir ) {
+			VectorCopy ( dir, client->damage_from );
+			client->damage_fromWorld = qfalse;
+		} else {
+			VectorCopy ( targ->r.currentOrigin, client->damage_from );
+			client->damage_fromWorld = qtrue;
+		}
+
+		if (attacker && attacker->client)
+		{
+			BotDamageNotification(client, attacker);
+		}
+		else if (inflictor && inflictor->client)
+		{
+			BotDamageNotification(client, inflictor);
+		}
+	}
+
+	// See if it's the player hurting the emeny flag carrier
+	if( g_gametype.integer == GT_CTF || g_gametype.integer == GT_CTY) {
+		Team_CheckHurtCarrier(targ, attacker);
+	}
+
+	if (targ->client) {
+		// set the last client who damaged the target
+		targ->client->lasthurt_client = attacker->s.number;
+		targ->client->lasthurt_mod = mod;
+	}
+
+	if (take && targ->client && (targ->client->ps.fd.forcePowersActive & (1 << FP_PROTECT)))
+	{
+		if (targ->client->ps.fd.forcePower)
+		{
+			int maxtake = take;
+
+			//G_Sound(targ, CHAN_AUTO, protectHitSound);
+			if (targ->client->forcePowerSoundDebounce < level.time)
+			{
+				G_PreDefSound(targ->client->ps.origin, PDSOUND_PROTECTHIT);
+				targ->client->forcePowerSoundDebounce = level.time + 400;
+			}
+
+			if (targ->client->ps.fd.forcePowerLevel[FP_PROTECT] == FORCE_LEVEL_1)
+			{
+				famt = 1;
+				hamt = 0.40;
+
+				if (maxtake > 100)
+				{
+					maxtake = 100;
+				}
+			}
+			else if (targ->client->ps.fd.forcePowerLevel[FP_PROTECT] == FORCE_LEVEL_2)
+			{
+				famt = 0.5;
+				hamt = 0.60;
+
+				if (maxtake > 200)
+				{
+					maxtake = 200;
+				}
+			}
+			else if (targ->client->ps.fd.forcePowerLevel[FP_PROTECT] == FORCE_LEVEL_3)
+			{
+				famt = 0.25;
+				hamt = 0.80;
+
+				if (maxtake > 400)
+				{
+					maxtake = 400;
+				}
+			}
+
+			if (!targ->client->ps.powerups[PW_FORCE_BOON])
+			{
+				targ->client->ps.fd.forcePower -= maxtake*famt;
+			}
+			else
+			{
+				targ->client->ps.fd.forcePower -= (maxtake*famt)/2;
+			}
+			subamt = (maxtake*hamt)+(take-maxtake);
+			if (targ->client->ps.fd.forcePower < 0)
+			{
+				subamt += targ->client->ps.fd.forcePower;
+				targ->client->ps.fd.forcePower = 0;
+			}
+			if (subamt)
+			{
+				take -= subamt;
+
+				if (take < 0)
+				{
+					take = 0;
+				}
+			}
+		}
+	}
+
+	if (shieldAbsorbed)
+	{
+		/*
+		if ( targ->client->NPC_class == CLASS_VEHICLE )
+		{
+			targ->client->ps.electrifyTime = level.time + Q_irand( 500, 1000 );
+		}
+		else
+		*/
+		{
+			gentity_t	*evEnt;
+
+			// Send off an event to show a shield shell on the player, pointing in the right direction.
+			//evEnt = G_TempEntity(vec3_origin, EV_SHIELD_HIT);
+			//rww - er.. what the? This isn't broadcast, why is it being set on vec3_origin?!
+			evEnt = G_TempEntity(targ->r.currentOrigin, EV_SHIELD_HIT);
+			evEnt->s.otherEntityNum = targ->s.number;
+			evEnt->s.eventParm = DirToByte(dir);
+			evEnt->s.time2=shieldAbsorbed;
+	/*
+			shieldAbsorbed *= 20;
+
+			if (shieldAbsorbed > 1500)
+			{
+				shieldAbsorbed = 1500;
+			}
+			if (shieldAbsorbed < 200)
+			{
+				shieldAbsorbed = 200;
+			}
+
+			if (targ->client->ps.powerups[PW_SHIELDHIT] < (level.time + shieldAbsorbed))
+			{
+				targ->client->ps.powerups[PW_SHIELDHIT] = level.time + shieldAbsorbed;
+			}
+			//flicker for as many ms as damage was absorbed (*20)
+			//therefore 10 damage causes 1/5 of a seond of flickering, whereas
+			//a full 100 causes 2 seconds (but is reduced to 1.5 seconds due to the max)
+
+	*/
+		}
+	}
+
+	// do the damage
+	if (take) 
+	{
+		if (targ->client && targ->s.number < MAX_CLIENTS &&
+			(mod == MOD_DEMP2 || mod == MOD_DEMP2_ALT))
+		{ //uh.. shock them or something. what the hell, I don't know.
+            if (targ->client->ps.weaponTime <= 0)
+			{ //yeah, we were supposed to be beta a week ago, I don't feel like
+				//breaking the game so I'm gonna be safe and only do this only
+				//if your weapon is not busy
+				targ->client->ps.weaponTime = 2000;
+				targ->client->ps.electrifyTime = level.time + 2000;
+				if (targ->client->ps.weaponstate == WEAPON_CHARGING ||
+					targ->client->ps.weaponstate == WEAPON_CHARGING_ALT)
+				{
+					targ->client->ps.weaponstate = WEAPON_READY;
+				}
+			}
+		}
+
+		if (targ->client && (targ->client->ps.fd.forcePowersActive & (1 << FP_RAGE)) && (inflictor->client || attacker->client))
+		{
+			take /= (targ->client->ps.fd.forcePowerLevel[FP_RAGE]+1);
+		}
+		targ->health = targ->health - take;
+
+		if ( (targ->flags&FL_UNDYING) )
+		{//take damage down to 1, but never die
+			if ( targ->health < 1 )
+			{
+				targ->health = 1;
+			}
+		}
+
+		if ( targ->client ) {
+			targ->client->ps.stats[STAT_HEALTH] = targ->health;
+		}
+
+		if (targ->client && (targ->client->ps.fd.forcePowersActive & (1 << FP_RAGE)) && (inflictor->client || attacker->client))
+		{
+			if (targ->health <= 0)
+			{
+				targ->health = 1;
+			}
+			if (targ->client->ps.stats[STAT_HEALTH] <= 0)
+			{
+				targ->client->ps.stats[STAT_HEALTH] = 1;
+			}
+		}
+
+		//We want to go ahead and set gPainHitLoc regardless of if we have a pain func,
+		//so we can adjust the location damage too.
+		if (targ->client && targ->ghoul2 && targ->client->g2LastSurfaceTime == level.time)
+		{ //We updated the hit surface this frame, so it's valid.
+			char hitSurface[MAX_QPATH];
+
+			trap_G2API_GetSurfaceName(targ->ghoul2, targ->client->g2LastSurfaceHit, 0, hitSurface);
+
+			if (hitSurface[0])
+			{
+				G_GetHitLocFromSurfName(targ, hitSurface, &gPainHitLoc, point, dir, vec3_origin, mod);
+			}
+			else
+			{
+				gPainHitLoc = -1;
+			}
+
+			if (gPainHitLoc < HL_MAX && gPainHitLoc >= 0 && targ->locationDamage[gPainHitLoc] < Q3_INFINITE &&
+				(targ->s.eType == ET_PLAYER || targ->s.NPC_class != CLASS_VEHICLE))
+			{
+				targ->locationDamage[gPainHitLoc] += take;
+
+				if (g_armBreakage.integer && !targ->client->ps.brokenLimbs &&
+					targ->client->ps.stats[STAT_HEALTH] > 0 && targ->health > 0 &&
+					!(targ->s.eFlags & EF_DEAD))
+				{ //check for breakage
+					if (targ->locationDamage[HL_ARM_RT]+targ->locationDamage[HL_HAND_RT] >= 80)
+					{
+						G_BreakArm(targ, BROKENLIMB_RARM);
+					}
+					else if (targ->locationDamage[HL_ARM_LT]+targ->locationDamage[HL_HAND_LT] >= 80)
+					{
+						G_BreakArm(targ, BROKENLIMB_LARM);
+					}
+				}
+			}
+		}
+		else
+		{
+			gPainHitLoc = -1;
+		}
+
+		if (targ->maxHealth)
+		{ //if this is non-zero this guy should be updated his s.health to send to the client
+			G_ScaleNetHealth(targ);
+		}
+
+		if ( targ->health <= 0 ) {
+			if ( client )
+			{
+				targ->flags |= FL_NO_KNOCKBACK;
+
+				if (point)
+				{
+					VectorCopy( point, targ->pos1 );
+				}
+				else
+				{
+					VectorCopy(targ->client->ps.origin, targ->pos1);
+				}
+			}
+			else if (targ->s.eType == ET_NPC)
+			{ //g2animent
+				VectorCopy(point, targ->pos1);
+			}
+
+			if (targ->health < -999)
+				targ->health = -999;
+
+			// If we are a breaking glass brush, store the damage point so we can do cool things with it.
+			if ( targ->r.svFlags & SVF_GLASS_BRUSH )
+			{
+				VectorCopy( point, targ->pos1 );
+				if (dir)
+				{
+					VectorCopy( dir, targ->pos2 );
+				}
+				else
+				{
+					VectorClear(targ->pos2);
+				}
+			}
+
+			if (targ->s.eType == ET_NPC &&
+				targ->client &&
+				(targ->s.eFlags & EF_DEAD))
+			{ //an NPC that's already dead. Maybe we can cut some more limbs off!
+				if ( (mod == MOD_SABER || (mod == MOD_MELEE && G_HeavyMelee( attacker )) )//saber or heavy melee (claws)
+					&& take > 2)
+				{
+					G_CheckForDismemberment(targ, attacker, targ->pos1, take, targ->client->ps.torsoAnim, qtrue);
+				}
+			}
+
+			targ->enemy = attacker;
+			targ->die (targ, inflictor, attacker, take, mod);
+			G_ActivateBehavior( targ, BSET_DEATH );
+			return;
+		} 
+		else 
+		{
+			if ( g_debugMelee.integer )
+			{//getting hurt makes you let go of the wall
+				if ( targ->client && (targ->client->ps.pm_flags&PMF_STUCK_TO_WALL) )
+				{
+					G_LetGoOfWall( targ );
+				}
+			}
+			if ( targ->pain ) 
+			{
+				if (targ->s.eType != ET_NPC || mod != MOD_SABER || take > 1)
+				{ //don't even notify NPCs of pain if it's just idle saber damage
+					gPainMOD = mod;
+					if (point)
+					{
+						VectorCopy(point, gPainPoint);
+					}
+					else
+					{
+						VectorCopy(targ->r.currentOrigin, gPainPoint);
+					}
+					targ->pain (targ, attacker, take);
+				}
+			}
+		}
+
+		G_LogWeaponDamage(attacker->s.number, mod, take);
+	}
+
+}
+
+
+/*
+============
+CanDamage
+
+Returns qtrue if the inflictor can directly damage the target.  Used for
+explosions and melee attacks.
+============
+*/
+qboolean CanDamage (gentity_t *targ, vec3_t origin) {
+	vec3_t	dest;
+	trace_t	tr;
+	vec3_t	midpoint;
+
+	// use the midpoint of the bounds instead of the origin, because
+	// bmodels may have their origin is 0,0,0
+	VectorAdd (targ->r.absmin, targ->r.absmax, midpoint);
+	VectorScale (midpoint, 0.5, midpoint);
+
+	VectorCopy (midpoint, dest);
+	trap_Trace ( &tr, origin, vec3_origin, vec3_origin, dest, ENTITYNUM_NONE, MASK_SOLID);
+	if (tr.fraction == 1.0 || tr.entityNum == targ->s.number)
+		return qtrue;
+
+	// this should probably check in the plane of projection, 
+	// rather than in world coordinate, and also include Z
+	VectorCopy (midpoint, dest);
+	dest[0] += 15.0;
+	dest[1] += 15.0;
+	trap_Trace ( &tr, origin, vec3_origin, vec3_origin, dest, ENTITYNUM_NONE, MASK_SOLID);
+	if (tr.fraction == 1.0)
+		return qtrue;
+
+	VectorCopy (midpoint, dest);
+	dest[0] += 15.0;
+	dest[1] -= 15.0;
+	trap_Trace ( &tr, origin, vec3_origin, vec3_origin, dest, ENTITYNUM_NONE, MASK_SOLID);
+	if (tr.fraction == 1.0)
+		return qtrue;
+
+	VectorCopy (midpoint, dest);
+	dest[0] -= 15.0;
+	dest[1] += 15.0;
+	trap_Trace ( &tr, origin, vec3_origin, vec3_origin, dest, ENTITYNUM_NONE, MASK_SOLID);
+	if (tr.fraction == 1.0)
+		return qtrue;
+
+	VectorCopy (midpoint, dest);
+	dest[0] -= 15.0;
+	dest[1] -= 15.0;
+	trap_Trace ( &tr, origin, vec3_origin, vec3_origin, dest, ENTITYNUM_NONE, MASK_SOLID);
+	if (tr.fraction == 1.0)
+		return qtrue;
+
+
+	return qfalse;
+}
+
+
+/*
+============
+G_RadiusDamage
+============
+*/
+qboolean G_RadiusDamage ( vec3_t origin, gentity_t *attacker, float damage, float radius,
+					 gentity_t *ignore, gentity_t *missile, int mod) {
+	float		points, dist;
+	gentity_t	*ent;
+	int			entityList[MAX_GENTITIES];
+	int			numListedEntities;
+	vec3_t		mins, maxs;
+	vec3_t		v;
+	vec3_t		dir;
+	int			i, e;
+	qboolean	hitClient = qfalse;
+	qboolean	roastPeople = qfalse;
+
+	/*
+	if (missile && !missile->client && missile->s.weapon > WP_NONE &&
+		missile->s.weapon < WP_NUM_WEAPONS && missile->r.ownerNum >= 0 &&
+		(missile->r.ownerNum < MAX_CLIENTS || g_entities[missile->r.ownerNum].s.eType == ET_NPC))
+	{ //sounds like it's a valid weapon projectile.. is it a valid explosive to create marks from?
+		switch(missile->s.weapon)
+		{
+		case WP_FLECHETTE: //flechette issuing this will be alt-fire
+		case WP_ROCKET_LAUNCHER:
+		case WP_THERMAL:
+		case WP_TRIP_MINE:
+		case WP_DET_PACK:
+			roastPeople = qtrue; //Then create explosive marks
+			break;
+		default:
+			break;
+		}
+	}
+	*/
+	//oh well.. maybe sometime? I am trying to cut down on tempent use.
+
+	if ( radius < 1 ) {
+		radius = 1;
+	}
+
+	for ( i = 0 ; i < 3 ; i++ ) {
+		mins[i] = origin[i] - radius;
+		maxs[i] = origin[i] + radius;
+	}
+
+	numListedEntities = trap_EntitiesInBox( mins, maxs, entityList, MAX_GENTITIES );
+
+	for ( e = 0 ; e < numListedEntities ; e++ ) {
+		ent = &g_entities[entityList[ e ]];
+
+		if (ent == ignore)
+			continue;
+		if (!ent->takedamage)
+			continue;
+
+		// find the distance from the edge of the bounding box
+		for ( i = 0 ; i < 3 ; i++ ) {
+			if ( origin[i] < ent->r.absmin[i] ) {
+				v[i] = ent->r.absmin[i] - origin[i];
+			} else if ( origin[i] > ent->r.absmax[i] ) {
+				v[i] = origin[i] - ent->r.absmax[i];
+			} else {
+				v[i] = 0;
+			}
+		}
+
+		dist = VectorLength( v );
+		if ( dist >= radius ) {
+			continue;
+		}
+
+		points = damage * ( 1.0 - dist / radius );
+
+		if( CanDamage (ent, origin) ) {
+			if( LogAccuracyHit( ent, attacker ) ) {
+				hitClient = qtrue;
+			}
+			VectorSubtract (ent->r.currentOrigin, origin, dir);
+			// push the center of mass higher than the origin so players
+			// get knocked into the air more
+			dir[2] += 24;
+			if (attacker && attacker->inuse && attacker->client &&
+				attacker->s.eType == ET_NPC && attacker->s.NPC_class == CLASS_VEHICLE &&
+				attacker->m_pVehicle && attacker->m_pVehicle->m_pPilot)
+			{ //say my pilot did it.
+				G_Damage (ent, NULL, (gentity_t *)attacker->m_pVehicle->m_pPilot, dir, origin, (int)points, DAMAGE_RADIUS, mod);
+			}
+			else
+			{
+				G_Damage (ent, NULL, attacker, dir, origin, (int)points, DAMAGE_RADIUS, mod);
+			}
+
+			if (ent && ent->client && roastPeople && missile &&
+				!VectorCompare(ent->r.currentOrigin, missile->r.currentOrigin))
+			{ //the thing calling this function can create burn marks on people, so create an event to do so
+				gentity_t *evEnt = G_TempEntity(ent->r.currentOrigin, EV_GHOUL2_MARK);
+
+				evEnt->s.otherEntityNum = ent->s.number; //the entity the mark should be placed on
+				evEnt->s.weapon = WP_ROCKET_LAUNCHER; //always say it's rocket so we make the right mark
+
+				//Try to place the decal by going from the missile location to the location of the person that was hit
+				VectorCopy(missile->r.currentOrigin, evEnt->s.origin);
+				VectorCopy(ent->r.currentOrigin, evEnt->s.origin2);
+
+				//it's hacky, but we want to move it up so it's more likely to hit
+				//the torso.
+				if (missile->r.currentOrigin[2] < ent->r.currentOrigin[2])
+				{ //move it up less so the decal is placed lower on the model then
+					evEnt->s.origin2[2] += 8;
+				}
+				else
+				{
+					evEnt->s.origin2[2] += 24;
+				}
+
+				//Special col check
+				evEnt->s.eventParm = 1;
+			}
+		}
+	}
+
+	return hitClient;
+}
diff --git a/codemp/game/g_exphysics.c b/codemp/game/g_exphysics.c
new file mode 100644
index 0000000..624f062
--- /dev/null
+++ b/codemp/game/g_exphysics.c
@@ -0,0 +1,232 @@
+// Copyright (C) 2000-2002 Raven Software, Inc.
+//
+/*****************************************************************************
+ * name:		g_exphysics.c
+ *
+ * desc:		Custom physics system (Expensive Physics)
+ *
+ * $Author: osman $ 
+ * $Revision: 1.4 $
+ *
+ *****************************************************************************/
+#pragma warning(disable : 4701) //local variable may be used without having been initialized
+
+#include "g_local.h"
+
+#define MAX_GRAVITY_PULL 512
+
+//Run physics on the object (purely origin-related) using custom epVelocity entity
+//state value. Origin smoothing on the client is expected to compensate for choppy
+//movement.
+void G_RunExPhys(gentity_t *ent, float gravity, float mass, float bounce, qboolean autoKill, int *g2Bolts, int numG2Bolts)
+{
+	trace_t tr;
+	vec3_t projectedOrigin;
+	vec3_t vNorm;
+	vec3_t ground;
+	float velScaling = 0.1f;
+	float vTotal = 0.0f;
+
+	assert(mass <= 1.0f && mass >= 0.01f);
+
+	if (gravity)
+	{ //factor it in before we do anything.
+		VectorCopy(ent->r.currentOrigin, ground);
+		ground[2] -= 0.1f;
+
+		trap_Trace(&tr, ent->r.currentOrigin, ent->r.mins, ent->r.maxs, ground, ent->s.number, ent->clipmask);
+
+		if (tr.fraction == 1.0f)
+		{
+			ent->s.groundEntityNum = ENTITYNUM_NONE;
+		}
+		else
+		{
+			ent->s.groundEntityNum = tr.entityNum;
+		}
+
+		if (ent->s.groundEntityNum == ENTITYNUM_NONE)
+		{
+			ent->epGravFactor += gravity;
+
+			if (ent->epGravFactor > MAX_GRAVITY_PULL)
+			{ //cap it off if needed
+				ent->epGravFactor = MAX_GRAVITY_PULL;
+			}
+
+			ent->epVelocity[2] -= ent->epGravFactor;
+		}
+		else
+		{ //if we're sitting on something then reset the gravity factor.
+			ent->epGravFactor = 0;
+		}
+	}
+
+	if (!ent->epVelocity[0] && !ent->epVelocity[1] && !ent->epVelocity[2])
+	{ //nothing to do if we have no velocity even after gravity.
+		if (ent->touch)
+		{ //call touch if we're in something
+			trap_Trace(&tr, ent->r.currentOrigin, ent->r.mins, ent->r.maxs, ent->r.currentOrigin, ent->s.number, ent->clipmask);
+			if (tr.startsolid || tr.allsolid)
+			{
+				ent->touch(ent, &g_entities[tr.entityNum], &tr);
+			}
+		}
+		return;
+	}
+
+	//get the projected origin based on velocity.
+	VectorMA(ent->r.currentOrigin, velScaling, ent->epVelocity, projectedOrigin);
+
+	VectorScale(ent->epVelocity, 1.0f-mass, ent->epVelocity); //scale it down based on mass
+
+	VectorCopy(ent->epVelocity, vNorm);
+	vTotal = VectorNormalize(vNorm);
+
+	if (vTotal < 1 && ent->s.groundEntityNum != ENTITYNUM_NONE)
+	{ //we've pretty much stopped moving anyway, just clear it out then.
+		VectorClear(ent->epVelocity);
+		ent->epGravFactor = 0;
+		trap_LinkEntity(ent);
+		return;
+	}
+
+	if (ent->ghoul2 && g2Bolts)
+	{ //Have we been passed a bolt index array to clip against points on the skeleton?
+		vec3_t tMins, tMaxs;
+		vec3_t trajDif;
+		vec3_t gbmAngles;
+		vec3_t boneOrg;
+		vec3_t projectedBoneOrg;
+		vec3_t collisionRootPos;
+		mdxaBone_t matrix;
+		trace_t bestCollision;
+		qboolean hasFirstCollision = qfalse;
+		int i = 0;
+
+		//Maybe we could use a trap call and get the default radius for the bone specified,
+		//but this will do at least for now.
+		VectorSet(tMins, -3, -3, -3);
+		VectorSet(tMaxs, 3, 3, 3);
+
+		gbmAngles[PITCH] = gbmAngles[ROLL] = 0;
+		gbmAngles[YAW] = ent->s.apos.trBase[YAW];
+
+		//Get the difference relative to the entity origin and projected origin, to add to each bolt position.
+		VectorSubtract(ent->r.currentOrigin, projectedOrigin, trajDif);
+        
+		while (i < numG2Bolts)
+		{
+			//Get the position of the actual bolt for this frame
+			trap_G2API_GetBoltMatrix(ent->ghoul2, 0, g2Bolts[i], &matrix, gbmAngles, ent->r.currentOrigin, level.time, NULL, ent->modelScale);
+			BG_GiveMeVectorFromMatrix(&matrix, ORIGIN, boneOrg);
+
+			//Now add the projected positional difference into the result
+			VectorAdd(boneOrg, trajDif, projectedBoneOrg);
+
+			trap_Trace(&tr, boneOrg, tMins, tMaxs, projectedBoneOrg, ent->s.number, ent->clipmask);
+
+			if (tr.fraction != 1.0 || tr.startsolid || tr.allsolid)
+			{ //we've hit something
+				//Store the "deepest" collision we have
+                if (!hasFirstCollision)
+				{ //don't have one yet so just use this one
+					bestCollision = tr;
+					VectorCopy(boneOrg, collisionRootPos);
+					hasFirstCollision = qtrue;
+				}
+				else
+				{
+					if (tr.allsolid && !bestCollision.allsolid)
+					{ //If the whole trace is solid then this one is deeper
+						bestCollision = tr;
+						VectorCopy(boneOrg, collisionRootPos);
+					}
+					else if (tr.startsolid && !bestCollision.startsolid && !bestCollision.allsolid)
+					{ //Next deepest is if it's startsolid
+						bestCollision = tr;
+						VectorCopy(boneOrg, collisionRootPos);
+					}
+					else if (!bestCollision.startsolid && !bestCollision.allsolid &&
+						tr.fraction < bestCollision.fraction)
+					{ //and finally, if neither is startsolid/allsolid, but the new one has a smaller fraction, then it's closer to an impact point so we will use it
+						bestCollision = tr;
+						VectorCopy(boneOrg, collisionRootPos);
+					}
+				}
+			}
+
+			i++;
+		}
+
+		if (hasFirstCollision)
+		{ //at least one bolt collided
+			//We'll get the offset between the collided bolt and endpos, then trace there
+			//from the origin so that our desired position becomes that point.
+			VectorSubtract(collisionRootPos, bestCollision.endpos, trajDif);
+
+			VectorAdd(ent->r.currentOrigin, trajDif, projectedOrigin);
+		}
+	}
+
+	//If we didn't collide with any bolts projectedOrigin will still be the original desired
+	//projected position so all is well. If we did then projectedOrigin will be modified
+	//to provide us with a relative position which does not place the bolt in a solid.
+	trap_Trace(&tr, ent->r.currentOrigin, ent->r.mins, ent->r.maxs, projectedOrigin, ent->s.number, ent->clipmask);
+
+	if (tr.startsolid || tr.allsolid)
+	{ //can't go anywhere from here
+#ifdef _DEBUG
+		Com_Printf("ExPhys object in solid (%i)\n", ent->s.number);
+#endif
+		if (autoKill)
+		{
+			ent->think = G_FreeEntity;
+			ent->nextthink = level.time;
+		}
+		return;
+	}
+
+	//Go ahead and set it to the trace endpoint regardless of what it hit
+	G_SetOrigin(ent, tr.endpos);
+	trap_LinkEntity(ent);
+
+	if (tr.fraction == 1.0f)
+	{ //Nothing was in the way.
+		return;
+	}
+
+	if (bounce)
+	{
+		vTotal *= bounce; //scale it by bounce
+
+		VectorScale(tr.plane.normal, vTotal, vNorm); //scale the trace plane normal by the bounce factor
+
+		if (vNorm[2] > 0)
+		{
+			ent->epGravFactor -= vNorm[2]*(1.0f-mass); //The lighter it is the more gravity will be reduced by bouncing vertically.
+			if (ent->epGravFactor < 0)
+			{
+				ent->epGravFactor = 0;
+			}
+		}
+
+		//call touch first so we can check velocity upon impact if we want
+		if (tr.entityNum != ENTITYNUM_NONE && ent->touch)
+		{ //then call the touch function
+			ent->touch(ent, &g_entities[tr.entityNum], &tr);
+		}
+
+		VectorAdd(ent->epVelocity, vNorm, ent->epVelocity); //add it into the existing velocity.
+	}
+	else
+	{ //if no bounce, kill when it hits something.
+		ent->epVelocity[0] = 0;
+		ent->epVelocity[1] = 0;
+
+		if (!gravity)
+		{
+			ent->epVelocity[2] = 0;
+		}
+	}
+}
diff --git a/codemp/game/g_headers.h b/codemp/game/g_headers.h
new file mode 100644
index 0000000..a781320
--- /dev/null
+++ b/codemp/game/g_headers.h
@@ -0,0 +1,4 @@
+//dummy file so as to not break SP's game PCH stuff.
+//in mp we don't even bother with pch since the point of
+//the code is to be totally cross-platform (or at least
+//as much so as possible)
diff --git a/codemp/game/g_items.c b/codemp/game/g_items.c
new file mode 100644
index 0000000..c2e7f26
--- /dev/null
+++ b/codemp/game/g_items.c
@@ -0,0 +1,3243 @@
+// Copyright (C) 1999-2000 Id Software, Inc.
+//
+#include "g_local.h"
+#include "../ghoul2/G2.h"
+#include "q_shared.h"
+
+/*
+
+  Items are any object that a player can touch to gain some effect.
+
+  Pickup will return the number of seconds until they should respawn.
+
+  all items should pop when dropped in lava or slime
+
+  Respawnable items don't actually go away when picked up, they are
+  just made invisible and untouchable.  This allows them to ride
+  movers and respawn apropriately.
+*/
+
+
+#define	RESPAWN_ARMOR		20
+#define	RESPAWN_TEAM_WEAPON	30
+#define	RESPAWN_HEALTH		30
+#define	RESPAWN_AMMO		40
+#define	RESPAWN_HOLDABLE	60
+#define	RESPAWN_MEGAHEALTH	120
+#define	RESPAWN_POWERUP		120
+
+// Item Spawn flags
+#define ITMSF_SUSPEND		1
+#define ITMSF_NOPLAYER		2
+#define ITMSF_ALLOWNPC		4
+#define ITMSF_NOTSOLID		8
+#define ITMSF_VERTICAL		16
+#define ITMSF_INVISIBLE		32
+
+extern gentity_t *droppedRedFlag;
+extern gentity_t *droppedBlueFlag;
+
+
+//======================================================================
+#define MAX_MEDPACK_HEAL_AMOUNT		25
+#define MAX_MEDPACK_BIG_HEAL_AMOUNT	50
+#define MAX_SENTRY_DISTANCE			256
+
+// For more than four players, adjust the respawn times, up to 1/4.
+int adjustRespawnTime(float preRespawnTime, int itemType, int itemTag)
+{
+	float respawnTime = preRespawnTime;
+
+	if (itemType == IT_WEAPON)
+	{
+		if (itemTag == WP_THERMAL ||
+			itemTag == WP_TRIP_MINE ||
+			itemTag == WP_DET_PACK)
+		{ //special case for these, use ammo respawn rate
+			respawnTime = RESPAWN_AMMO;
+		}
+	}
+
+	if (!g_adaptRespawn.integer)
+	{
+		return((int)respawnTime);
+	}
+
+	if (level.numPlayingClients > 4)
+	{	// Start scaling the respawn times.
+		if (level.numPlayingClients > 32)
+		{	// 1/4 time minimum.
+			respawnTime *= 0.25;
+		}
+		else if (level.numPlayingClients > 12)
+		{	// From 12-32, scale from 0.5 to 0.25;
+			respawnTime *= 20.0 / (float)(level.numPlayingClients + 8);
+		}
+		else 
+		{	// From 4-12, scale from 1.0 to 0.5;
+			respawnTime *= 8.0 / (float)(level.numPlayingClients + 4);
+		}
+	}
+
+	if (respawnTime < 1.0)
+	{	// No matter what, don't go lower than 1 second, or the pickups become very noisy!
+		respawnTime = 1.0;
+	}
+
+	return ((int)respawnTime);
+}
+
+
+#define SHIELD_HEALTH				250
+#define SHIELD_HEALTH_DEC			10		// 25 seconds	
+#define MAX_SHIELD_HEIGHT			254
+#define MAX_SHIELD_HALFWIDTH		255
+#define SHIELD_HALFTHICKNESS		4
+#define SHIELD_PLACEDIST			64
+
+#define SHIELD_SIEGE_HEALTH			2000
+#define SHIELD_SIEGE_HEALTH_DEC		(SHIELD_SIEGE_HEALTH/25)	// still 25 seconds.
+
+static qhandle_t	shieldLoopSound=0;
+static qhandle_t	shieldAttachSound=0;
+static qhandle_t	shieldActivateSound=0;
+static qhandle_t	shieldDeactivateSound=0;
+static qhandle_t	shieldDamageSound=0;
+
+
+void ShieldRemove(gentity_t *self)
+{
+	self->think = G_FreeEntity;
+	self->nextthink = level.time + 100;
+
+	// Play kill sound...
+	G_AddEvent(self, EV_GENERAL_SOUND, shieldDeactivateSound);
+	self->s.loopSound = 0;
+	self->s.loopIsSoundset = qfalse;
+
+	return;
+}
+
+
+// Count down the health of the shield.
+void ShieldThink(gentity_t *self)
+{
+	self->s.trickedentindex = 0;
+
+	if ( g_gametype.integer == GT_SIEGE )
+	{
+		self->health -= SHIELD_SIEGE_HEALTH_DEC;
+	}
+	else
+	{
+		self->health -= SHIELD_HEALTH_DEC;
+	}
+	self->nextthink = level.time + 1000;
+	if (self->health <= 0)
+	{
+		ShieldRemove(self);
+	}
+	return;
+}
+
+
+// The shield was damaged to below zero health.
+void ShieldDie(gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int mod)
+{
+	// Play damaging sound...
+	G_AddEvent(self, EV_GENERAL_SOUND, shieldDamageSound);
+
+	ShieldRemove(self);
+}
+
+
+// The shield had damage done to it.  Make it flicker.
+void ShieldPain(gentity_t *self, gentity_t *attacker, int damage)
+{
+	// Set the itemplaceholder flag to indicate the the shield drawing that the shield pain should be drawn.
+	self->think = ShieldThink;
+	self->nextthink = level.time + 400;
+
+	// Play damaging sound...
+	G_AddEvent(self, EV_GENERAL_SOUND, shieldDamageSound);
+
+	self->s.trickedentindex = 1;
+
+	return;
+}
+
+
+// Try to turn the shield back on after a delay.
+void ShieldGoSolid(gentity_t *self)
+{
+	trace_t		tr;
+
+	// see if we're valid
+	self->health--;
+	if (self->health <= 0)
+	{
+		ShieldRemove(self);
+		return;
+	}
+	
+	trap_Trace (&tr, self->r.currentOrigin, self->r.mins, self->r.maxs, self->r.currentOrigin, self->s.number, CONTENTS_BODY );
+	if(tr.startsolid)
+	{	// gah, we can't activate yet
+		self->nextthink = level.time + 200;
+		self->think = ShieldGoSolid;
+		trap_LinkEntity(self);
+	}
+	else
+	{ // get hard... huh-huh...
+		self->s.eFlags &= ~EF_NODRAW;
+
+		self->r.contents = CONTENTS_SOLID;
+		self->nextthink = level.time + 1000;
+		self->think = ShieldThink;
+		self->takedamage = qtrue;
+		trap_LinkEntity(self);
+
+		// Play raising sound...
+		G_AddEvent(self, EV_GENERAL_SOUND, shieldActivateSound);
+		self->s.loopSound = shieldLoopSound;
+		self->s.loopIsSoundset = qfalse;
+	}
+
+	return;
+}
+
+
+// Turn the shield off to allow a friend to pass through.
+void ShieldGoNotSolid(gentity_t *self)
+{
+	// make the shield non-solid very briefly
+	self->r.contents = 0;
+	self->s.eFlags |= EF_NODRAW;
+	// nextthink needs to have a large enough interval to avoid excess accumulation of Activate messages
+	self->nextthink = level.time + 200;
+	self->think = ShieldGoSolid;
+	self->takedamage = qfalse;
+	trap_LinkEntity(self);
+
+	// Play kill sound...
+	G_AddEvent(self, EV_GENERAL_SOUND, shieldDeactivateSound);
+	self->s.loopSound = 0;
+	self->s.loopIsSoundset = qfalse;
+}
+
+
+// Somebody (a player) has touched the shield.  See if it is a "friend".
+void ShieldTouch(gentity_t *self, gentity_t *other, trace_t *trace)
+{
+	if (g_gametype.integer >= GT_TEAM)
+	{ // let teammates through
+		// compare the parent's team to the "other's" team
+		if (self->parent && ( self->parent->client) && (other->client))
+		{
+			if (OnSameTeam(self->parent, other))
+			{
+				ShieldGoNotSolid(self);
+			}
+		}
+	}
+	else
+	{//let the person who dropped the shield through
+		if (self->parent && self->parent->s.number == other->s.number)
+		{
+			ShieldGoNotSolid(self);
+		}
+	}
+}
+
+
+// After a short delay, create the shield by expanding in all directions.
+void CreateShield(gentity_t *ent)
+{
+	trace_t		tr;
+	vec3_t		mins, maxs, end, posTraceEnd, negTraceEnd, start;
+	int			height, posWidth, negWidth, halfWidth = 0;
+	qboolean	xaxis;
+	int			paramData = 0;
+	static int	shieldID;
+
+	// trace upward to find height of shield
+	VectorCopy(ent->r.currentOrigin, end);
+	end[2] += MAX_SHIELD_HEIGHT;
+	trap_Trace (&tr, ent->r.currentOrigin, NULL, NULL, end, ent->s.number, MASK_SHOT );
+	height = (int)(MAX_SHIELD_HEIGHT * tr.fraction);
+
+	// use angles to find the proper axis along which to align the shield
+	VectorSet(mins, -SHIELD_HALFTHICKNESS, -SHIELD_HALFTHICKNESS, 0);
+	VectorSet(maxs, SHIELD_HALFTHICKNESS, SHIELD_HALFTHICKNESS, height);
+	VectorCopy(ent->r.currentOrigin, posTraceEnd);
+	VectorCopy(ent->r.currentOrigin, negTraceEnd);
+
+	if ((int)(ent->s.angles[YAW]) == 0) // shield runs along y-axis
+	{
+		posTraceEnd[1]+=MAX_SHIELD_HALFWIDTH;
+		negTraceEnd[1]-=MAX_SHIELD_HALFWIDTH;
+		xaxis = qfalse;
+	}
+	else  // shield runs along x-axis
+	{
+		posTraceEnd[0]+=MAX_SHIELD_HALFWIDTH;
+		negTraceEnd[0]-=MAX_SHIELD_HALFWIDTH;
+		xaxis = qtrue;
+	}
+
+	// trace horizontally to find extend of shield
+	// positive trace
+	VectorCopy(ent->r.currentOrigin, start);
+	start[2] += (height>>1);
+	trap_Trace (&tr, start, 0, 0, posTraceEnd, ent->s.number, MASK_SHOT );
+	posWidth = MAX_SHIELD_HALFWIDTH * tr.fraction;
+	// negative trace
+	trap_Trace (&tr, start, 0, 0, negTraceEnd, ent->s.number, MASK_SHOT );
+	negWidth = MAX_SHIELD_HALFWIDTH * tr.fraction;
+
+	// kef -- monkey with dimensions and place origin in center
+	halfWidth = (posWidth + negWidth)>>1;
+	if (xaxis)
+	{
+		ent->r.currentOrigin[0] = ent->r.currentOrigin[0] - negWidth + halfWidth;
+	}
+	else
+	{
+		ent->r.currentOrigin[1] = ent->r.currentOrigin[1] - negWidth + halfWidth;
+	}
+	ent->r.currentOrigin[2] += (height>>1);
+
+	// set entity's mins and maxs to new values, make it solid, and link it
+	if (xaxis)
+	{
+		VectorSet(ent->r.mins, -halfWidth, -SHIELD_HALFTHICKNESS, -(height>>1));
+		VectorSet(ent->r.maxs, halfWidth, SHIELD_HALFTHICKNESS, height>>1);
+	}
+	else
+	{
+		VectorSet(ent->r.mins, -SHIELD_HALFTHICKNESS, -halfWidth, -(height>>1));
+		VectorSet(ent->r.maxs, SHIELD_HALFTHICKNESS, halfWidth, height);
+	}
+	ent->clipmask = MASK_SHOT;
+
+	// Information for shield rendering.
+
+//	xaxis - 1 bit
+//	height - 0-254 8 bits
+//	posWidth - 0-255 8 bits
+//  negWidth - 0 - 255 8 bits
+
+	paramData = (xaxis << 24) | (height << 16) | (posWidth << 8) | (negWidth);
+	ent->s.time2 = paramData;
+
+	if ( g_gametype.integer == GT_SIEGE )
+	{
+		ent->health = ceil((float)(SHIELD_SIEGE_HEALTH*1));
+	}
+	else
+	{
+		ent->health = ceil((float)(SHIELD_HEALTH*1));
+	}
+
+	ent->s.time = ent->health;//???
+	ent->pain = ShieldPain;
+	ent->die = ShieldDie;
+	ent->touch = ShieldTouch;
+
+	// see if we're valid
+	trap_Trace (&tr, ent->r.currentOrigin, ent->r.mins, ent->r.maxs, ent->r.currentOrigin, ent->s.number, CONTENTS_BODY ); 
+
+	if (tr.startsolid)
+	{	// Something in the way!
+		// make the shield non-solid very briefly
+		ent->r.contents = 0;
+		ent->s.eFlags |= EF_NODRAW;
+		// nextthink needs to have a large enough interval to avoid excess accumulation of Activate messages
+		ent->nextthink = level.time + 200;
+		ent->think = ShieldGoSolid;
+		ent->takedamage = qfalse;
+		trap_LinkEntity(ent);
+	}
+	else
+	{	// Get solid.
+		ent->r.contents = CONTENTS_PLAYERCLIP|CONTENTS_SHOTCLIP;//CONTENTS_SOLID;
+
+		ent->nextthink = level.time;
+		ent->think = ShieldThink;
+
+		ent->takedamage = qtrue;
+		trap_LinkEntity(ent);
+
+		// Play raising sound...
+		G_AddEvent(ent, EV_GENERAL_SOUND, shieldActivateSound);
+		ent->s.loopSound = shieldLoopSound;
+		ent->s.loopIsSoundset = qfalse;
+	}
+
+	ShieldGoSolid(ent);
+
+	return;
+}
+
+qboolean PlaceShield(gentity_t *playerent)
+{
+	static const gitem_t *shieldItem = NULL;
+	gentity_t	*shield = NULL;
+	trace_t		tr;
+	vec3_t		fwd, pos, dest, mins = {-4,-4, 0}, maxs = {4,4,4};
+
+	if (shieldAttachSound==0)
+	{
+		shieldLoopSound = G_SoundIndex("sound/movers/doors/forcefield_lp.wav");
+		shieldAttachSound = G_SoundIndex("sound/weapons/detpack/stick.wav");
+		shieldActivateSound = G_SoundIndex("sound/movers/doors/forcefield_on.wav");
+		shieldDeactivateSound = G_SoundIndex("sound/movers/doors/forcefield_off.wav");
+		shieldDamageSound = G_SoundIndex("sound/effects/bumpfield.wav");
+		shieldItem = BG_FindItemForHoldable(HI_SHIELD);
+	}
+
+	// can we place this in front of us?
+	AngleVectors (playerent->client->ps.viewangles, fwd, NULL, NULL);
+	fwd[2] = 0;
+	VectorMA(playerent->client->ps.origin, SHIELD_PLACEDIST, fwd, dest);
+	trap_Trace (&tr, playerent->client->ps.origin, mins, maxs, dest, playerent->s.number, MASK_SHOT );
+	if (tr.fraction > 0.9)
+	{//room in front
+		VectorCopy(tr.endpos, pos);
+		// drop to floor
+		VectorSet( dest, pos[0], pos[1], pos[2] - 4096 );
+		trap_Trace( &tr, pos, mins, maxs, dest, playerent->s.number, MASK_SOLID );
+		if ( !tr.startsolid && !tr.allsolid )
+		{
+			// got enough room so place the portable shield
+			shield = G_Spawn();
+
+			// Figure out what direction the shield is facing.
+			if (fabs(fwd[0]) > fabs(fwd[1]))
+			{	// shield is north/south, facing east.
+				shield->s.angles[YAW] = 0;
+			}
+			else
+			{	// shield is along the east/west axis, facing north
+				shield->s.angles[YAW] = 90;
+			}
+			shield->think = CreateShield;
+			shield->nextthink = level.time + 500;	// power up after .5 seconds
+			shield->parent = playerent;
+
+			// Set team number.
+			shield->s.otherEntityNum2 = playerent->client->sess.sessionTeam;
+
+			shield->s.eType = ET_SPECIAL;
+			shield->s.modelindex =  HI_SHIELD;	// this'll be used in CG_Useable() for rendering.
+			shield->classname = shieldItem->classname;
+
+			shield->r.contents = CONTENTS_TRIGGER;
+
+			shield->touch = 0;
+			// using an item causes it to respawn
+			shield->use = 0; //Use_Item;
+
+			// allow to ride movers
+			shield->s.groundEntityNum = tr.entityNum;
+
+			G_SetOrigin( shield, tr.endpos );
+
+			shield->s.eFlags &= ~EF_NODRAW;
+			shield->r.svFlags &= ~SVF_NOCLIENT;
+
+			trap_LinkEntity (shield);
+
+			shield->s.owner = playerent->s.number;
+			shield->s.shouldtarget = qtrue;
+			if (g_gametype.integer >= GT_TEAM)
+			{
+				shield->s.teamowner = playerent->client->sess.sessionTeam;
+			}
+			else
+			{
+				shield->s.teamowner = 16;
+			}
+
+			// Play placing sound...
+			G_AddEvent(shield, EV_GENERAL_SOUND, shieldAttachSound);
+
+			return qtrue;
+		}
+	}
+	// no room
+	return qfalse;
+}
+
+void ItemUse_Binoculars(gentity_t *ent)
+{
+	if (!ent || !ent->client)
+	{
+		return;
+	}
+
+	if (ent->client->ps.weaponstate != WEAPON_READY)
+	{ //So we can't fool it and reactivate while switching to the saber or something.
+		return;
+	}
+
+	/*
+	if (ent->client->ps.weapon == WP_SABER)
+	{ //No.
+		return;
+	}
+	*/
+
+	if (ent->client->ps.zoomMode == 0) // not zoomed or currently zoomed with the disruptor
+	{
+		ent->client->ps.zoomMode = 2;
+		ent->client->ps.zoomLocked = qfalse;
+		ent->client->ps.zoomFov = 40.0f;
+	}
+	else if (ent->client->ps.zoomMode == 2)
+	{
+		ent->client->ps.zoomMode = 0;
+		ent->client->ps.zoomTime = level.time;
+	}
+}
+
+void ItemUse_Shield(gentity_t *ent)
+{
+	PlaceShield(ent);
+}
+
+//--------------------------
+// PERSONAL ASSAULT SENTRY
+//--------------------------
+
+#define PAS_DAMAGE	2
+
+void SentryTouch(gentity_t *ent, gentity_t *other, trace_t *trace)
+{
+	return;
+}
+
+//----------------------------------------------------------------
+void pas_fire( gentity_t *ent )
+//----------------------------------------------------------------
+{
+	vec3_t fwd, myOrg, enOrg;
+
+	VectorCopy(ent->r.currentOrigin, myOrg);
+	myOrg[2] += 24;
+
+	VectorCopy(ent->enemy->client->ps.origin, enOrg);
+	enOrg[2] += 24;
+
+	VectorSubtract(enOrg, myOrg, fwd);
+	VectorNormalize(fwd);
+	
+	myOrg[0] += fwd[0]*16;
+	myOrg[1] += fwd[1]*16;
+	myOrg[2] += fwd[2]*16;
+
+	WP_FireTurretMissile(&g_entities[ent->genericValue3], myOrg, fwd, qfalse, 10, 2300, MOD_SENTRY, ent );
+
+	G_RunObject(ent);
+}
+
+#define TURRET_RADIUS 800
+
+//-----------------------------------------------------
+static qboolean pas_find_enemies( gentity_t *self )
+//-----------------------------------------------------
+{
+	qboolean	found = qfalse;
+	int			count, i;
+	float		bestDist = TURRET_RADIUS*TURRET_RADIUS;
+	float		enemyDist;
+	vec3_t		enemyDir, org, org2;
+	gentity_t	*entity_list[MAX_GENTITIES], *target;
+	trace_t		tr;
+
+	if ( self->aimDebounceTime > level.time ) // time since we've been shut off
+	{
+		// We were active and alert, i.e. had an enemy in the last 3 secs
+		if ( self->painDebounceTime < level.time )
+		{
+			G_Sound(self, CHAN_BODY, G_SoundIndex( "sound/chars/turret/ping.wav" ));
+			self->painDebounceTime = level.time + 1000;
+		}
+	}
+
+	VectorCopy(self->s.pos.trBase, org2);
+
+	count = G_RadiusList( org2, TURRET_RADIUS, self, qtrue, entity_list );
+
+	for ( i = 0; i < count; i++ )
+	{
+		target = entity_list[i];
+
+		if ( !target->client )
+		{
+			continue;
+		}
+		if ( target == self || !target->takedamage || target->health <= 0 || ( target->flags & FL_NOTARGET ))
+		{
+			continue;
+		}
+		if ( self->alliedTeam && target->client->sess.sessionTeam == self->alliedTeam )
+		{ 
+			continue;
+		}
+		if (self->genericValue3 == target->s.number)
+		{
+			continue;
+		}
+		if ( !trap_InPVS( org2, target->r.currentOrigin ))
+		{
+			continue;
+		}
+
+		if (target->s.eType == ET_NPC &&
+			target->s.NPC_class == CLASS_VEHICLE)
+		{ //don't get mad at vehicles, silly.
+			continue;
+		}
+
+		if ( target->client )
+		{
+			VectorCopy( target->client->ps.origin, org );
+		}
+		else
+		{
+			VectorCopy( target->r.currentOrigin, org );
+		}
+
+		trap_Trace( &tr, org2, NULL, NULL, org, self->s.number, MASK_SHOT );
+
+		if ( !tr.allsolid && !tr.startsolid && ( tr.fraction == 1.0 || tr.entityNum == target->s.number ))
+		{
+			// Only acquire if have a clear shot, Is it in range and closer than our best?
+			VectorSubtract( target->r.currentOrigin, self->r.currentOrigin, enemyDir );
+			enemyDist = VectorLengthSquared( enemyDir );
+
+			if ( enemyDist < bestDist )// all things equal, keep current
+			{
+				if ( self->attackDebounceTime + 100 < level.time )
+				{
+					// We haven't fired or acquired an enemy in the last 2 seconds-start-up sound
+					G_Sound( self, CHAN_BODY, G_SoundIndex( "sound/chars/turret/startup.wav" ));
+
+					// Wind up turrets for a bit
+					self->attackDebounceTime = level.time + 900 + random() * 200;
+				}
+
+				G_SetEnemy( self, target );
+				bestDist = enemyDist;
+				found = qtrue;
+			}
+		}
+	}
+
+	return found;
+}
+
+//---------------------------------
+void pas_adjust_enemy( gentity_t *ent )
+//---------------------------------
+{
+	trace_t	tr;
+	qboolean keep = qtrue;
+
+	if ( ent->enemy->health <= 0 )
+	{
+		keep = qfalse;
+	}
+	else
+	{
+		vec3_t		org, org2;
+
+		VectorCopy(ent->s.pos.trBase, org2);
+
+		if ( ent->enemy->client )
+		{
+			VectorCopy( ent->enemy->client->ps.origin, org );
+			org[2] -= 15;
+		}
+		else
+		{
+			VectorCopy( ent->enemy->r.currentOrigin, org );
+		}
+
+		trap_Trace( &tr, org2, NULL, NULL, org, ent->s.number, MASK_SHOT );
+
+		if ( tr.allsolid || tr.startsolid || tr.fraction < 0.9f || tr.entityNum == ent->s.number )
+		{
+			if (tr.entityNum != ent->enemy->s.number)
+			{
+				// trace failed
+				keep = qfalse;
+			}
+		}
+	}
+
+	if ( keep )
+	{
+		//ent->bounceCount = level.time + 500 + random() * 150;
+	}
+	else if ( ent->bounceCount < level.time && ent->enemy ) // don't ping pong on and off
+	{
+		ent->enemy = NULL;
+		// shut-down sound
+		G_Sound( ent, CHAN_BODY, G_SoundIndex( "sound/chars/turret/shutdown.wav" ));
+	
+		ent->bounceCount = level.time + 500 + random() * 150;
+
+		// make turret play ping sound for 5 seconds
+		ent->aimDebounceTime = level.time + 5000;
+	}
+}
+
+#define TURRET_DEATH_DELAY 2000
+#define TURRET_LIFETIME 60000
+
+void turret_die(gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int mod);
+
+void sentryExpire(gentity_t *self)
+{
+	turret_die(self, self, self, 1000, MOD_UNKNOWN);	
+}
+
+//---------------------------------
+void pas_think( gentity_t *ent )
+//---------------------------------
+{
+	qboolean	moved;
+	float		diffYaw, diffPitch;
+	vec3_t		enemyDir, org;
+	vec3_t		frontAngles, backAngles;
+	vec3_t		desiredAngles;
+	int			iEntityList[MAX_GENTITIES];
+	int			numListedEntities;
+	int			i = 0;
+	qboolean	clTrapped = qfalse;
+	vec3_t		testMins, testMaxs;
+
+	testMins[0] = ent->r.currentOrigin[0] + ent->r.mins[0]+4;
+	testMins[1] = ent->r.currentOrigin[1] + ent->r.mins[1]+4;
+	testMins[2] = ent->r.currentOrigin[2] + ent->r.mins[2]+4;
+
+	testMaxs[0] = ent->r.currentOrigin[0] + ent->r.maxs[0]-4;
+	testMaxs[1] = ent->r.currentOrigin[1] + ent->r.maxs[1]-4;
+	testMaxs[2] = ent->r.currentOrigin[2] + ent->r.maxs[2]-4;
+
+	numListedEntities = trap_EntitiesInBox( testMins, testMaxs, iEntityList, MAX_GENTITIES );
+
+	while (i < numListedEntities)
+	{
+		if (iEntityList[i] < MAX_CLIENTS)
+		{ //client stuck inside me. go nonsolid.
+			int clNum = iEntityList[i];
+
+			numListedEntities = trap_EntitiesInBox( g_entities[clNum].r.absmin, g_entities[clNum].r.absmax, iEntityList, MAX_GENTITIES );
+
+			i = 0;
+			while (i < numListedEntities)
+			{
+				if (iEntityList[i] == ent->s.number)
+				{
+					clTrapped = qtrue;
+					break;
+				}
+				i++;
+			}
+			break;
+		}
+
+		i++;
+	}
+
+	if (clTrapped)
+	{
+		ent->r.contents = 0;
+		ent->s.fireflag = 0;
+		ent->nextthink = level.time + FRAMETIME;
+		return;
+	}
+	else
+	{
+		ent->r.contents = CONTENTS_SOLID;
+	}
+
+	if (!g_entities[ent->genericValue3].inuse || !g_entities[ent->genericValue3].client ||
+		g_entities[ent->genericValue3].client->sess.sessionTeam != ent->genericValue2)
+	{
+		ent->think = G_FreeEntity;
+		ent->nextthink = level.time;
+		return;
+	}
+
+//	G_RunObject(ent);
+
+	if ( !ent->damage )
+	{
+		ent->damage = 1;
+		ent->nextthink = level.time + FRAMETIME;
+		return;
+	}
+
+	if ((ent->genericValue8+TURRET_LIFETIME) < level.time)
+	{
+		G_Sound( ent, CHAN_BODY, G_SoundIndex( "sound/chars/turret/shutdown.wav" ));
+		ent->s.bolt2 = ENTITYNUM_NONE;
+		ent->s.fireflag = 2;
+
+		ent->think = sentryExpire;
+		ent->nextthink = level.time + TURRET_DEATH_DELAY;
+		return;
+	}
+
+	ent->nextthink = level.time + FRAMETIME;
+
+	if ( ent->enemy )
+	{
+		// make sure that the enemy is still valid
+		pas_adjust_enemy( ent );
+	}
+
+	if (ent->enemy)
+	{
+		if (!ent->enemy->client)
+		{
+			ent->enemy = NULL;
+		}
+		else if (ent->enemy->s.number == ent->s.number)
+		{
+			ent->enemy = NULL;
+		}
+		else if (ent->enemy->health < 1)
+		{
+			ent->enemy = NULL;
+		}
+	}
+
+	if ( !ent->enemy )
+	{
+		pas_find_enemies( ent );
+	}
+
+	if (ent->enemy)
+	{
+		ent->s.bolt2 = ent->enemy->s.number;
+	}
+	else
+	{
+		ent->s.bolt2 = ENTITYNUM_NONE;
+	}
+
+	moved = qfalse;
+	diffYaw = 0.0f; diffPitch = 0.0f;
+
+	ent->speed = AngleNormalize360( ent->speed );
+	ent->random = AngleNormalize360( ent->random );
+
+	if ( ent->enemy )
+	{
+		// ...then we'll calculate what new aim adjustments we should attempt to make this frame
+		// Aim at enemy
+		if ( ent->enemy->client )
+		{
+			VectorCopy( ent->enemy->client->ps.origin, org );
+		}
+		else
+		{
+			VectorCopy( ent->enemy->r.currentOrigin, org );
+		}
+
+		VectorSubtract( org, ent->r.currentOrigin, enemyDir );
+		vectoangles( enemyDir, desiredAngles );
+
+		diffYaw = AngleSubtract( ent->speed, desiredAngles[YAW] );
+		diffPitch = AngleSubtract( ent->random, desiredAngles[PITCH] );
+	}
+	else
+	{
+		// no enemy, so make us slowly sweep back and forth as if searching for a new one
+		diffYaw = sin( level.time * 0.0001f + ent->count ) * 2.0f;
+	}
+
+	if ( fabs(diffYaw) > 0.25f )
+	{
+		moved = qtrue;
+
+		if ( fabs(diffYaw) > 10.0f )
+		{
+			// cap max speed
+			ent->speed += (diffYaw > 0.0f) ? -10.0f : 10.0f;
+		}
+		else
+		{
+			// small enough
+			ent->speed -= diffYaw;
+		}
+	}
+
+
+	if ( fabs(diffPitch) > 0.25f )
+	{
+		moved = qtrue;
+
+		if ( fabs(diffPitch) > 4.0f )
+		{
+			// cap max speed
+			ent->random += (diffPitch > 0.0f) ? -4.0f : 4.0f;
+		}
+		else
+		{
+			// small enough
+			ent->random -= diffPitch;
+		}
+	}
+
+	// the bone axes are messed up, so hence some dumbness here
+	VectorSet( frontAngles, -ent->random, 0.0f, 0.0f );
+	VectorSet( backAngles, 0.0f, 0.0f, ent->speed );
+
+	if ( moved )
+	{
+	//ent->s.loopSound = G_SoundIndex( "sound/chars/turret/move.wav" );
+	}
+	else
+	{
+		ent->s.loopSound = 0;
+		ent->s.loopIsSoundset = qfalse;
+	}
+
+	if ( ent->enemy && ent->attackDebounceTime < level.time )
+	{
+		ent->count--;
+
+		if ( ent->count )
+		{
+			pas_fire( ent );
+			ent->s.fireflag = 1;
+			ent->attackDebounceTime = level.time + 200;
+		}
+		else
+		{
+			//ent->nextthink = 0;
+			G_Sound( ent, CHAN_BODY, G_SoundIndex( "sound/chars/turret/shutdown.wav" ));
+			ent->s.bolt2 = ENTITYNUM_NONE;
+			ent->s.fireflag = 2;
+
+			ent->think = sentryExpire;
+			ent->nextthink = level.time + TURRET_DEATH_DELAY;
+		}
+	}
+	else
+	{
+		ent->s.fireflag = 0;
+	}
+}
+
+//------------------------------------------------------------------------------------------------------------
+void turret_die(gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int mod)
+//------------------------------------------------------------------------------------------------------------
+{
+	// Turn off the thinking of the base & use it's targets
+	self->think = 0;//NULL;
+	self->use = 0;//NULL;
+
+	if ( self->target )
+	{
+		G_UseTargets( self, attacker );
+	}
+
+	if (!g_entities[self->genericValue3].inuse || !g_entities[self->genericValue3].client)
+	{
+		G_FreeEntity(self);
+		return;
+	}
+
+	// clear my data
+	self->die  = 0;//NULL;
+	self->takedamage = qfalse;
+	self->health = 0;
+
+	// hack the effect angle so that explode death can orient the effect properly
+	VectorSet( self->s.angles, 0, 0, 1 );
+
+	G_PlayEffect(EFFECT_EXPLOSION_PAS, self->s.pos.trBase, self->s.angles);
+	G_RadiusDamage(self->s.pos.trBase, &g_entities[self->genericValue3], 30, 256, self, self, MOD_UNKNOWN);
+
+	g_entities[self->genericValue3].client->ps.fd.sentryDeployed = qfalse;
+
+	//ExplodeDeath( self );
+	G_FreeEntity( self );
+}
+
+#define TURRET_AMMO_COUNT 40
+
+//---------------------------------
+void SP_PAS( gentity_t *base )
+//---------------------------------
+{
+	if ( base->count == 0 )
+	{
+		// give ammo
+		base->count = TURRET_AMMO_COUNT;
+	}
+
+	base->s.bolt1 = 1; //This is a sort of hack to indicate that this model needs special turret things done to it
+	base->s.bolt2 = ENTITYNUM_NONE; //store our current enemy index
+
+	base->damage = 0; // start animation flag
+
+	VectorSet( base->r.mins, -8, -8, 0 );
+	VectorSet( base->r.maxs, 8, 8, 24 );
+
+	G_RunObject(base);
+
+	base->think = pas_think;
+	base->nextthink = level.time + FRAMETIME;
+
+	if ( !base->health )
+	{
+		base->health = 50;
+	}
+
+	base->takedamage = qtrue;
+	base->die  = turret_die;
+
+	base->physicsObject = qtrue;
+
+	G_Sound( base, CHAN_BODY, G_SoundIndex( "sound/chars/turret/startup.wav" ));
+}
+
+//------------------------------------------------------------------------
+void ItemUse_Sentry( gentity_t *ent )
+//------------------------------------------------------------------------
+{
+	vec3_t fwd, fwdorg;
+	vec3_t yawonly;
+	vec3_t mins, maxs;
+	gentity_t *sentry;
+
+	if (!ent || !ent->client)
+	{
+		return;
+	}
+
+	VectorSet( mins, -8, -8, 0 );
+	VectorSet( maxs, 8, 8, 24 );
+
+
+	yawonly[ROLL] = 0;
+	yawonly[PITCH] = 0;
+	yawonly[YAW] = ent->client->ps.viewangles[YAW];
+
+	AngleVectors(yawonly, fwd, NULL, NULL);
+
+	fwdorg[0] = ent->client->ps.origin[0] + fwd[0]*64;
+	fwdorg[1] = ent->client->ps.origin[1] + fwd[1]*64;
+	fwdorg[2] = ent->client->ps.origin[2] + fwd[2]*64;
+
+	sentry = G_Spawn();
+
+	sentry->classname = "sentryGun";
+	sentry->s.modelindex = G_ModelIndex("models/items/psgun.glm"); //replace ASAP
+
+	sentry->s.g2radius = 30.0f;
+	sentry->s.modelGhoul2 = 1;
+
+	G_SetOrigin(sentry, fwdorg);
+	sentry->parent = ent;
+	sentry->r.contents = CONTENTS_SOLID;
+	sentry->s.solid = 2;
+	sentry->clipmask = MASK_SOLID;
+	VectorCopy(mins, sentry->r.mins);
+	VectorCopy(maxs, sentry->r.maxs);
+	sentry->genericValue3 = ent->s.number;
+	sentry->genericValue2 = ent->client->sess.sessionTeam; //so we can remove ourself if our owner changes teams
+	sentry->r.absmin[0] = sentry->s.pos.trBase[0] + sentry->r.mins[0];
+	sentry->r.absmin[1] = sentry->s.pos.trBase[1] + sentry->r.mins[1];
+	sentry->r.absmin[2] = sentry->s.pos.trBase[2] + sentry->r.mins[2];
+	sentry->r.absmax[0] = sentry->s.pos.trBase[0] + sentry->r.maxs[0];
+	sentry->r.absmax[1] = sentry->s.pos.trBase[1] + sentry->r.maxs[1];
+	sentry->r.absmax[2] = sentry->s.pos.trBase[2] + sentry->r.maxs[2];
+	sentry->s.eType = ET_GENERAL;
+	sentry->s.pos.trType = TR_GRAVITY;//STATIONARY;
+	sentry->s.pos.trTime = level.time;
+	sentry->touch = SentryTouch;
+	sentry->nextthink = level.time;
+	sentry->genericValue4 = ENTITYNUM_NONE; //genericValue4 used as enemy index
+
+	sentry->genericValue5 = 1000;
+
+	sentry->genericValue8 = level.time;
+
+	sentry->alliedTeam = ent->client->sess.sessionTeam;
+
+	ent->client->ps.fd.sentryDeployed = qtrue;
+
+	trap_LinkEntity(sentry);
+
+	sentry->s.owner = ent->s.number;
+	sentry->s.shouldtarget = qtrue;
+	if (g_gametype.integer >= GT_TEAM)
+	{
+		sentry->s.teamowner = ent->client->sess.sessionTeam;
+	}
+	else
+	{
+		sentry->s.teamowner = 16;
+	}
+
+	SP_PAS( sentry );
+}
+
+extern gentity_t *NPC_SpawnType( gentity_t *ent, char *npc_type, char *targetname, qboolean isVehicle );
+void ItemUse_Seeker(gentity_t *ent)
+{
+	if ( g_gametype.integer == GT_SIEGE && d_siegeSeekerNPC.integer )
+	{//actualy spawn a remote NPC
+		gentity_t *remote = NPC_SpawnType( ent, "remote", NULL, qfalse );
+		if ( remote && remote->client )
+		{//set it to my team
+			remote->s.owner = remote->r.ownerNum = ent->s.number;
+			remote->activator = ent;
+			if ( ent->client->sess.sessionTeam == TEAM_BLUE )
+			{
+				remote->client->playerTeam = NPCTEAM_PLAYER;
+			}
+			else if ( ent->client->sess.sessionTeam == TEAM_RED )
+			{
+				remote->client->playerTeam = NPCTEAM_ENEMY;
+			}
+			else
+			{
+				remote->client->playerTeam = NPCTEAM_NEUTRAL;
+			}
+		}	
+	}
+	else
+	{
+		ent->client->ps.eFlags |= EF_SEEKERDRONE;
+		ent->client->ps.droneExistTime = level.time + 30000;
+		ent->client->ps.droneFireTime = level.time + 1500;
+	}
+}
+
+static void MedPackGive(gentity_t *ent, int amount)
+{
+	if (!ent || !ent->client)
+	{
+		return;
+	}
+
+	if (ent->health <= 0 ||
+		ent->client->ps.stats[STAT_HEALTH] <= 0 ||
+		(ent->client->ps.eFlags & EF_DEAD))
+	{
+		return;
+	}
+
+	if (ent->health >= ent->client->ps.stats[STAT_MAX_HEALTH])
+	{
+		return;
+	}
+
+	ent->health += amount;
+
+	if (ent->health > ent->client->ps.stats[STAT_MAX_HEALTH])
+	{
+		ent->health = ent->client->ps.stats[STAT_MAX_HEALTH];
+	}
+}
+
+void ItemUse_MedPack_Big(gentity_t *ent)
+{
+	MedPackGive(ent, MAX_MEDPACK_BIG_HEAL_AMOUNT);
+}
+
+void ItemUse_MedPack(gentity_t *ent)
+{
+	MedPackGive(ent, MAX_MEDPACK_HEAL_AMOUNT);
+}
+
+#define JETPACK_TOGGLE_TIME			1000
+void Jetpack_Off(gentity_t *ent)
+{ //create effects?
+	assert(ent && ent->client);
+
+	if (!ent->client->jetPackOn)
+	{ //aready off
+		return;
+	}
+
+	ent->client->jetPackOn = qfalse;
+}
+
+void Jetpack_On(gentity_t *ent)
+{ //create effects?
+	assert(ent && ent->client);
+
+	if (ent->client->jetPackOn)
+	{ //aready on
+		return;
+	}
+
+	if (ent->client->ps.fd.forceGripBeingGripped >= level.time)
+	{ //can't turn on during grip interval
+		return;
+	}
+
+	if (ent->client->ps.fallingToDeath)
+	{ //too late!
+		return;
+	}
+
+	G_Sound(ent, CHAN_AUTO, G_SoundIndex("sound/boba/JETON"));
+
+	ent->client->jetPackOn = qtrue;
+}
+
+void ItemUse_Jetpack( gentity_t *ent )
+{
+	assert(ent && ent->client);
+
+	if (ent->client->jetPackToggleTime >= level.time)
+	{
+		return;
+	}
+
+	if (ent->health <= 0 ||
+		ent->client->ps.stats[STAT_HEALTH] <= 0 ||
+		(ent->client->ps.eFlags & EF_DEAD) ||
+		ent->client->ps.pm_type == PM_DEAD)
+	{ //can't use it when dead under any circumstances.
+		return;
+	}
+
+	if (!ent->client->jetPackOn &&
+		ent->client->ps.jetpackFuel < 5)
+	{ //too low on fuel to start it up
+		return;
+	}
+
+	if (ent->client->jetPackOn)
+	{
+		Jetpack_Off(ent);
+	}
+	else
+	{
+		Jetpack_On(ent);
+	}
+
+	ent->client->jetPackToggleTime = level.time + JETPACK_TOGGLE_TIME;
+}
+
+#define CLOAK_TOGGLE_TIME			1000
+extern void Jedi_Cloak( gentity_t *self );
+extern void Jedi_Decloak( gentity_t *self );
+void ItemUse_UseCloak( gentity_t *ent )
+{
+	assert(ent && ent->client);
+
+	if (ent->client->cloakToggleTime >= level.time)
+	{
+		return;
+	}
+
+	if (ent->health <= 0 ||
+		ent->client->ps.stats[STAT_HEALTH] <= 0 ||
+		(ent->client->ps.eFlags & EF_DEAD) ||
+		ent->client->ps.pm_type == PM_DEAD)
+	{ //can't use it when dead under any circumstances.
+		return;
+	}
+
+	if (!ent->client->ps.powerups[PW_CLOAKED] &&
+		ent->client->ps.cloakFuel < 5)
+	{ //too low on fuel to start it up
+		return;
+	}
+
+	if ( ent->client->ps.powerups[PW_CLOAKED] )
+	{//decloak
+		Jedi_Decloak( ent );
+	}
+	else
+	{//cloak
+		Jedi_Cloak( ent );
+	}
+
+	ent->client->cloakToggleTime = level.time + CLOAK_TOGGLE_TIME;
+}
+
+#define TOSSED_ITEM_STAY_PERIOD			20000
+#define TOSSED_ITEM_OWNER_NOTOUCH_DUR	1000
+
+void SpecialItemThink(gentity_t *ent)
+{
+	float gravity = 3.0f;
+	float mass = 0.09f;
+	float bounce = 1.1f;
+
+	if (ent->genericValue5 < level.time)
+	{
+		ent->think = G_FreeEntity;
+		ent->nextthink = level.time;
+		return;
+	}
+
+	G_RunExPhys(ent, gravity, mass, bounce, qfalse, NULL, 0);
+	VectorCopy(ent->r.currentOrigin, ent->s.origin);
+	ent->nextthink = level.time + 50;
+}
+
+void G_SpecialSpawnItem(gentity_t *ent, gitem_t *item)
+{
+	RegisterItem( item );
+	ent->item = item;
+
+	//go away if no one wants me
+	ent->genericValue5 = level.time + TOSSED_ITEM_STAY_PERIOD;
+	ent->think = SpecialItemThink;
+	ent->nextthink = level.time + 50;
+	ent->clipmask = MASK_SOLID;
+
+	ent->physicsBounce = 0.50;		// items are bouncy
+	VectorSet (ent->r.mins, -8, -8, -0);
+	VectorSet (ent->r.maxs, 8, 8, 16);
+
+	ent->s.eType = ET_ITEM;
+	ent->s.modelindex = ent->item - bg_itemlist;		// store item number in modelindex
+
+	ent->r.contents = CONTENTS_TRIGGER;
+	ent->touch = Touch_Item;
+
+	//can't touch owner for x seconds
+	ent->genericValue11 = ent->r.ownerNum;
+	ent->genericValue10 = level.time + TOSSED_ITEM_OWNER_NOTOUCH_DUR;
+
+	//so we know to remove when picked up, not respawn
+	ent->genericValue9 = 1;
+
+	//kind of a lame value to use, but oh well. This means don't
+	//pick up this item clientside with prediction, because we
+	//aren't sending over all the data necessary for the player
+	//to know if he can.
+	ent->s.brokenLimbs = 1;
+
+	//since it uses my server-only physics
+	ent->s.eFlags |= EF_CLIENTSMOOTH;
+}
+
+#define DISP_HEALTH_ITEM		"item_medpak_instant"
+#define DISP_AMMO_ITEM			"ammo_all"
+
+void G_PrecacheDispensers(void)
+{
+	gitem_t *item;
+		
+	item = BG_FindItem(DISP_HEALTH_ITEM);
+	if (item)
+	{
+		RegisterItem(item);
+	}
+
+	item = BG_FindItem(DISP_AMMO_ITEM);
+	if (item)
+	{
+		RegisterItem(item);
+	}
+}
+
+void ItemUse_UseDisp(gentity_t *ent, int type)
+{
+	gitem_t *item = NULL;
+	gentity_t *eItem;
+
+	if (!ent->client ||
+		ent->client->tossableItemDebounce > level.time)
+	{ //can't use it again yet
+		return;
+	}
+
+	if (ent->client->ps.weaponTime > 0 ||
+		ent->client->ps.forceHandExtend != HANDEXTEND_NONE)
+	{ //busy doing something else
+		return;
+	}
+	
+	ent->client->tossableItemDebounce = level.time + TOSS_DEBOUNCE_TIME;
+	
+	if (type == HI_HEALTHDISP)
+	{
+		item = BG_FindItem(DISP_HEALTH_ITEM);
+	}
+	else
+	{
+		item = BG_FindItem(DISP_AMMO_ITEM);
+	}
+
+	if (item)
+	{
+		vec3_t fwd, pos;
+		gentity_t	*te;
+
+		eItem = G_Spawn();
+		eItem->r.ownerNum = ent->s.number;
+		eItem->classname = item->classname;
+
+		VectorCopy(ent->client->ps.origin, pos);
+		pos[2] += ent->client->ps.viewheight;
+
+		G_SetOrigin(eItem, pos);
+		VectorCopy(eItem->r.currentOrigin, eItem->s.origin);
+		trap_LinkEntity(eItem);
+
+		G_SpecialSpawnItem(eItem, item);
+
+		AngleVectors(ent->client->ps.viewangles, fwd, NULL, NULL);
+		VectorScale(fwd, 128.0f, eItem->epVelocity);
+		eItem->epVelocity[2] = 16.0f;
+
+	//	G_SetAnim( ent, NULL, SETANIM_TORSO, BOTH_THERMAL_THROW, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD, 0 );
+
+		te = G_TempEntity( ent->client->ps.origin, EV_LOCALTIMER );
+		te->s.time = level.time;
+		te->s.time2 = TOSS_DEBOUNCE_TIME;
+		te->s.owner = ent->client->ps.clientNum;
+	}
+}
+
+
+//===============================================
+//Portable E-Web -rww
+//===============================================
+//put the e-web away/remove it from the owner
+void EWebDisattach(gentity_t *owner, gentity_t *eweb)
+{
+    owner->client->ewebIndex = 0;
+	owner->client->ps.emplacedIndex = 0;
+	if (owner->health > 0)
+	{
+		owner->client->ps.stats[STAT_WEAPONS] = eweb->genericValue11;
+	}
+	else
+	{
+		owner->client->ps.stats[STAT_WEAPONS] = 0;
+	}
+	eweb->think = G_FreeEntity;
+	eweb->nextthink = level.time;
+}
+
+//precache misc e-web assets
+void EWebPrecache(void)
+{
+	RegisterItem( BG_FindItemForWeapon(WP_TURRET) );
+	G_EffectIndex("detpack/explosion.efx");
+	G_EffectIndex("turret/muzzle_flash.efx");
+}
+
+//e-web death
+#define EWEB_DEATH_RADIUS		128
+#define EWEB_DEATH_DMG			90
+
+#include "../namespace_begin.h"
+extern void BG_CycleInven(playerState_t *ps, int direction); //bg_misc.c
+#include "../namespace_end.h"
+
+void EWebDie(gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int mod)
+{
+	vec3_t fxDir;
+
+	G_RadiusDamage(self->r.currentOrigin, self, EWEB_DEATH_DMG, EWEB_DEATH_RADIUS, self, self, MOD_SUICIDE);
+
+	VectorSet(fxDir, 1.0f, 0.0f, 0.0f);
+	G_PlayEffect(EFFECT_EXPLOSION_DETPACK, self->r.currentOrigin, fxDir);
+
+	if (self->r.ownerNum != ENTITYNUM_NONE)
+	{
+		gentity_t *owner = &g_entities[self->r.ownerNum];
+
+		if (owner->inuse && owner->client)
+		{
+			EWebDisattach(owner, self);
+
+			//make sure it resets next time we spawn one in case we someone obtain one before death
+			owner->client->ewebHealth = -1;
+
+			//take it away from him, it is gone forever.
+			owner->client->ps.stats[STAT_HOLDABLE_ITEMS] &= ~(1<<HI_EWEB);
+
+			if (owner->client->ps.stats[STAT_HOLDABLE_ITEM] > 0 &&
+				bg_itemlist[owner->client->ps.stats[STAT_HOLDABLE_ITEM]].giType == IT_HOLDABLE &&
+				bg_itemlist[owner->client->ps.stats[STAT_HOLDABLE_ITEM]].giTag == HI_EWEB)
+			{ //he has it selected so deselect it and select the first thing available
+				owner->client->ps.stats[STAT_HOLDABLE_ITEM] = 0;
+				BG_CycleInven(&owner->client->ps, 1);
+			}
+		}
+	}
+}
+
+//e-web pain
+void EWebPain(gentity_t *self, gentity_t *attacker, int damage)
+{
+	//update the owner's health status of me
+	if (self->r.ownerNum != ENTITYNUM_NONE)
+	{
+		gentity_t *owner = &g_entities[self->r.ownerNum];
+
+		if (owner->inuse && owner->client)
+		{
+			owner->client->ewebHealth = self->health;
+		}
+	}
+}
+
+//special routine for tracking angles between client and server
+void EWeb_SetBoneAngles(gentity_t *ent, char *bone, vec3_t angles)
+{
+#ifdef _XBOX
+	byte *thebone = &ent->s.boneIndex1;
+	byte *firstFree = NULL;
+#else
+	int *thebone = &ent->s.boneIndex1;
+	int *firstFree = NULL;
+#endif
+	int i = 0;
+	int boneIndex = G_BoneIndex(bone);
+	int flags, up, right, forward;
+	vec3_t *boneVector = &ent->s.boneAngles1;
+	vec3_t *freeBoneVec = NULL;
+
+	while (thebone)
+	{
+		if (!*thebone && !firstFree)
+		{ //if the value is 0 then this index is clear, we can use it if we don't find the bone we want already existing.
+			firstFree = thebone;
+			freeBoneVec = boneVector;
+		}
+		else if (*thebone)
+		{
+			if (*thebone == boneIndex)
+			{ //this is it
+				break;
+			}
+		}
+
+		switch (i)
+		{
+		case 0:
+			thebone = &ent->s.boneIndex2;
+			boneVector = &ent->s.boneAngles2;
+			break;
+		case 1:
+			thebone = &ent->s.boneIndex3;
+			boneVector = &ent->s.boneAngles3;
+			break;
+		case 2:
+			thebone = &ent->s.boneIndex4;
+			boneVector = &ent->s.boneAngles4;
+			break;
+		default:
+			thebone = NULL;
+			boneVector = NULL;
+			break;
+		}
+
+		i++;
+	}
+
+	if (!thebone)
+	{ //didn't find it, create it
+		if (!firstFree)
+		{ //no free bones.. can't do a thing then.
+			Com_Printf("WARNING: E-Web has no free bone indexes\n");
+			return;
+		}
+
+		thebone = firstFree;
+
+		*thebone = boneIndex;
+		boneVector = freeBoneVec;
+	}
+
+	//If we got here then we have a vector and an index.
+
+	//Copy the angles over the vector in the entitystate, so we can use the corresponding index
+	//to set the bone angles on the client.
+	VectorCopy(angles, *boneVector);
+
+	//Now set the angles on our server instance if we have one.
+
+	if (!ent->ghoul2)
+	{
+		return;
+	}
+
+	flags = BONE_ANGLES_POSTMULT;
+	up = POSITIVE_Y;
+	right = NEGATIVE_Z;
+	forward = NEGATIVE_X;
+
+	//first 3 bits is forward, second 3 bits is right, third 3 bits is up
+	ent->s.boneOrient = ((forward)|(right<<3)|(up<<6));
+
+	trap_G2API_SetBoneAngles( ent->ghoul2,
+					0,
+					bone,
+					angles, 
+					flags,
+					up,
+					right,
+					forward,
+					NULL,
+					100,
+					level.time ); 
+}
+
+//start an animation on model_root both server side and client side
+void EWeb_SetBoneAnim(gentity_t *eweb, int startFrame, int endFrame)
+{
+	//set info on the entity so it knows to start the anim on the client next snapshot.
+	eweb->s.eFlags |= EF_G2ANIMATING;
+
+	if (eweb->s.torsoAnim == startFrame && eweb->s.legsAnim == endFrame)
+	{ //already playing this anim, let's flag it to restart
+		eweb->s.torsoFlip = !eweb->s.torsoFlip;
+	}
+	else
+	{
+		eweb->s.torsoAnim = startFrame;
+		eweb->s.legsAnim = endFrame;
+	}
+
+	//now set the animation on the server ghoul2 instance.
+	assert(eweb->ghoul2);
+	trap_G2API_SetBoneAnim(eweb->ghoul2, 0, "model_root", startFrame, endFrame,
+		(BONE_ANIM_OVERRIDE_FREEZE|BONE_ANIM_BLEND), 1.0f, level.time, -1, 100);
+}
+
+//fire a shot off
+#define EWEB_MISSILE_DAMAGE			20
+void EWebFire(gentity_t *owner, gentity_t *eweb)
+{
+	mdxaBone_t boltMatrix;
+	gentity_t *missile;
+	vec3_t p, d, bPoint;
+
+	if (eweb->genericValue10 == -1)
+	{ //oh no
+		assert(!"Bad e-web bolt");
+		return;
+	}
+
+	//get the muzzle point
+	trap_G2API_GetBoltMatrix(eweb->ghoul2, 0, eweb->genericValue10, &boltMatrix, eweb->s.apos.trBase, eweb->r.currentOrigin, level.time, NULL, eweb->modelScale);
+	BG_GiveMeVectorFromMatrix(&boltMatrix, ORIGIN, p);
+	BG_GiveMeVectorFromMatrix(&boltMatrix, NEGATIVE_Y, d);
+
+	//Start the thing backwards into the bounding box so it can't start inside other solid things
+	VectorMA(p, -16.0f, d, bPoint);
+
+	//create the missile
+	missile = CreateMissile( bPoint, d, 1200.0f, 10000, owner, qfalse );
+
+	missile->classname = "generic_proj";
+	missile->s.weapon = WP_TURRET;
+
+	missile->damage = EWEB_MISSILE_DAMAGE;
+	missile->dflags = DAMAGE_DEATH_KNOCKBACK;
+	missile->methodOfDeath = MOD_TURBLAST;
+	missile->clipmask = (MASK_SHOT|CONTENTS_LIGHTSABER);
+
+	//ignore the e-web entity
+	missile->passThroughNum = eweb->s.number+1;
+
+	//times it can bounce before it dies
+	missile->bounceCount = 8;
+
+	//play the muzzle flash
+	vectoangles(d, d);
+	G_PlayEffectID(G_EffectIndex("turret/muzzle_flash.efx"), p, d);
+}
+
+//lock the owner into place relative to the cannon pos
+void EWebPositionUser(gentity_t *owner, gentity_t *eweb)
+{
+	mdxaBone_t boltMatrix;
+	vec3_t p, d;
+	trace_t tr;
+
+	trap_G2API_GetBoltMatrix(eweb->ghoul2, 0, eweb->genericValue9, &boltMatrix, eweb->s.apos.trBase, eweb->r.currentOrigin, level.time, NULL, eweb->modelScale);
+	BG_GiveMeVectorFromMatrix(&boltMatrix, ORIGIN, p);
+	BG_GiveMeVectorFromMatrix(&boltMatrix, NEGATIVE_X, d);
+
+	VectorMA(p, 32.0f, d, p);
+	p[2] = eweb->r.currentOrigin[2];
+
+	p[2] += 4.0f;
+
+	trap_Trace(&tr, owner->client->ps.origin, owner->r.mins, owner->r.maxs, p, owner->s.number, MASK_PLAYERSOLID);
+
+	if (!tr.startsolid && !tr.allsolid && tr.fraction == 1.0f)
+	{ //all clear, we can move there
+		vec3_t pDown;
+
+		VectorCopy(p, pDown);
+		pDown[2] -= 7.0f;
+		trap_Trace(&tr, p, owner->r.mins, owner->r.maxs, pDown, owner->s.number, MASK_PLAYERSOLID);
+
+		if (!tr.startsolid && !tr.allsolid)
+		{
+			VectorSubtract(owner->client->ps.origin, tr.endpos, d);
+			if (VectorLength(d) > 1.0f)
+			{ //we moved, do some animating
+				vec3_t dAng;
+				int aFlags = SETANIM_FLAG_HOLD;
+
+				vectoangles(d, dAng);
+				dAng[YAW] = AngleSubtract(owner->client->ps.viewangles[YAW], dAng[YAW]);
+				if (dAng[YAW] > 0.0f)
+				{
+					if (owner->client->ps.legsAnim == BOTH_STRAFE_RIGHT1)
+					{ //reset to change direction
+						aFlags |= SETANIM_FLAG_OVERRIDE;
+					}
+					G_SetAnim(owner, &owner->client->pers.cmd, SETANIM_LEGS, BOTH_STRAFE_LEFT1, aFlags, 0);
+				}
+				else
+				{
+					if (owner->client->ps.legsAnim == BOTH_STRAFE_LEFT1)
+					{ //reset to change direction
+						aFlags |= SETANIM_FLAG_OVERRIDE;
+					}
+					G_SetAnim(owner, &owner->client->pers.cmd, SETANIM_LEGS, BOTH_STRAFE_RIGHT1, aFlags, 0);
+				}
+			}
+			else if (owner->client->ps.legsAnim == BOTH_STRAFE_RIGHT1 || owner->client->ps.legsAnim == BOTH_STRAFE_LEFT1)
+			{ //don't keep animating in place
+				owner->client->ps.legsTimer = 0;
+			}
+
+			G_SetOrigin(owner, tr.endpos);
+			VectorCopy(tr.endpos, owner->client->ps.origin);
+		}
+	}
+	else
+	{ //can't move here.. stop using the thing I guess
+		EWebDisattach(owner, eweb);
+	}
+}
+
+//keep the bone angles updated based on the owner's look dir
+void EWebUpdateBoneAngles(gentity_t *owner, gentity_t *eweb)
+{
+	vec3_t yAng;
+	float ideal;
+	float incr;
+	const float turnCap = 4.0f; //max degrees we can turn per update
+	
+	VectorClear(yAng);
+	ideal = AngleSubtract(owner->client->ps.viewangles[YAW], eweb->s.angles[YAW]);
+	incr = AngleSubtract(ideal, eweb->angle);
+
+	if (incr > turnCap)
+	{
+		incr = turnCap;
+	}
+	else if (incr < -turnCap)
+	{
+		incr = -turnCap;
+	}
+
+	eweb->angle += incr;
+
+	yAng[0] = eweb->angle;
+	EWeb_SetBoneAngles(eweb, "cannon_Yrot", yAng);
+
+	EWebPositionUser(owner, eweb);
+	if (!owner->client->ewebIndex)
+	{ //was removed during position function
+		return;
+	}
+
+	VectorClear(yAng);
+	yAng[2] = AngleSubtract(owner->client->ps.viewangles[PITCH], eweb->s.angles[PITCH])*0.8f;
+	EWeb_SetBoneAngles(eweb, "cannon_Xrot", yAng);
+}
+
+//keep it updated
+#include "../namespace_begin.h"
+extern int BG_EmplacedView(vec3_t baseAngles, vec3_t angles, float *newYaw, float constraint); //bg_misc.c
+#include "../namespace_end.h"
+
+void EWebThink(gentity_t *self)
+{
+	qboolean killMe = qfalse;
+	const float gravity = 3.0f;
+	const float mass = 0.09f;
+	const float bounce = 1.1f;
+
+	if (self->r.ownerNum == ENTITYNUM_NONE)
+	{
+		killMe = qtrue;
+	}
+	else
+	{
+		gentity_t *owner = &g_entities[self->r.ownerNum];
+
+		if (!owner->inuse || !owner->client || owner->client->pers.connected != CON_CONNECTED ||
+			owner->client->ewebIndex != self->s.number || owner->health < 1)
+		{
+			killMe = qtrue;
+		}
+		else if (owner->client->ps.emplacedIndex != self->s.number)
+		{ //just go back to the inventory then
+			EWebDisattach(owner, self);
+			return;
+		}
+
+		if (!killMe)
+		{
+			float yaw;
+
+			if (BG_EmplacedView(owner->client->ps.viewangles, self->s.angles, &yaw, self->s.origin2[0]))
+			{
+				owner->client->ps.viewangles[YAW] = yaw;
+			}
+			owner->client->ps.weapon = WP_EMPLACED_GUN;
+			owner->client->ps.stats[STAT_WEAPONS] = WP_EMPLACED_GUN;
+
+			if (self->genericValue8 < level.time)
+			{ //make sure the anim timer is done
+				EWebUpdateBoneAngles(owner, self);
+				if (!owner->client->ewebIndex)
+				{ //was removed during position function
+					return;
+				}
+
+				if (owner->client->pers.cmd.buttons & BUTTON_ATTACK)
+				{
+					if (self->genericValue5 < level.time)
+					{ //we can fire another shot off
+						EWebFire(owner, self);
+
+						//cheap firing anim
+						EWeb_SetBoneAnim(self, 2, 4);
+						self->genericValue3 = 1;
+
+						//set fire debounce time
+						self->genericValue5 = level.time + 100;
+					}
+				}
+				else if (self->genericValue5 < level.time && self->genericValue3)
+				{ //reset the anim back to non-firing
+					EWeb_SetBoneAnim(self, 0, 1);
+					self->genericValue3 = 0;
+				}
+			}
+		}
+	}
+
+	if (killMe)
+	{ //something happened to the owner, let's explode
+		EWebDie(self, self, self, 999, MOD_SUICIDE);
+		return;
+	}
+
+	//run some physics on it real quick so it falls and stuff properly
+	G_RunExPhys(self, gravity, mass, bounce, qfalse, NULL, 0);
+
+	self->nextthink = level.time;
+}
+
+#define EWEB_HEALTH			200
+
+//spawn and set up an e-web ent
+gentity_t *EWeb_Create(gentity_t *spawner)
+{
+	const char *modelName = "models/map_objects/hoth/eweb_model.glm";
+	int failSound = G_SoundIndex("sound/interface/shieldcon_empty");
+	gentity_t *ent;
+	trace_t tr;
+	vec3_t fAng, fwd, pos, downPos, s;
+	vec3_t mins, maxs;
+
+	VectorSet(mins, -32, -32, -24);
+	VectorSet(maxs, 32, 32, 24);
+
+	VectorSet(fAng, 0, spawner->client->ps.viewangles[1], 0);
+	AngleVectors(fAng, fwd, 0, 0);
+
+	VectorCopy(spawner->client->ps.origin, s);
+	//allow some fudge
+	s[2] += 12.0f;
+
+	VectorMA(s, 48.0f, fwd, pos);
+
+	trap_Trace(&tr, s, mins, maxs, pos, spawner->s.number, MASK_PLAYERSOLID);
+
+	if (tr.allsolid || tr.startsolid || tr.fraction != 1.0f)
+	{ //can't spawn here, we are in solid
+		G_Sound(spawner, CHAN_AUTO, failSound);
+		return NULL;
+	}
+
+	ent = G_Spawn();
+
+	ent->clipmask = MASK_PLAYERSOLID;
+	ent->r.contents = MASK_PLAYERSOLID;
+
+	ent->physicsObject = qtrue;
+
+	//for the sake of being able to differentiate client-side between this and an emplaced gun
+	ent->s.weapon = WP_NONE;
+
+	VectorCopy(pos, downPos);
+	downPos[2] -= 18.0f;
+	trap_Trace(&tr, pos, mins, maxs, downPos, spawner->s.number, MASK_PLAYERSOLID);
+
+	if (tr.startsolid || tr.allsolid || tr.fraction == 1.0f || tr.entityNum < ENTITYNUM_WORLD)
+	{ //didn't hit ground.
+		G_FreeEntity(ent);
+		G_Sound(spawner, CHAN_AUTO, failSound);
+		return NULL;
+	}
+
+	VectorCopy(tr.endpos, pos);
+
+	G_SetOrigin(ent, pos);
+
+	VectorCopy(fAng, ent->s.apos.trBase);
+	VectorCopy(fAng, ent->r.currentAngles);
+
+	ent->s.owner = spawner->s.number;
+	ent->s.teamowner = spawner->client->sess.sessionTeam;
+
+	ent->takedamage = qtrue;
+
+	if (spawner->client->ewebHealth <= 0)
+	{ //refresh the owner's e-web health if its last e-web did not exist or was killed
+		spawner->client->ewebHealth = EWEB_HEALTH;
+	}
+
+	//resume health of last deployment
+	ent->maxHealth = EWEB_HEALTH;
+	ent->health = spawner->client->ewebHealth;
+	G_ScaleNetHealth(ent);
+
+	ent->die = EWebDie;
+	ent->pain = EWebPain;
+
+	ent->think = EWebThink;
+	ent->nextthink = level.time;
+
+	//set up the g2 model info
+	ent->s.modelGhoul2 = 1;
+	ent->s.g2radius = 128;
+	ent->s.modelindex = G_ModelIndex((char *)modelName);
+
+	trap_G2API_InitGhoul2Model(&ent->ghoul2, modelName, 0, 0, 0, 0, 0);
+
+	if (!ent->ghoul2)
+	{ //should not happen, but just to be safe.
+		G_FreeEntity(ent);
+		return NULL;
+	}
+
+	//initialize bone angles
+	EWeb_SetBoneAngles(ent, "cannon_Yrot", vec3_origin);
+	EWeb_SetBoneAngles(ent, "cannon_Xrot", vec3_origin);
+
+	ent->genericValue10 = trap_G2API_AddBolt(ent->ghoul2, 0, "*cannonflash"); //muzzle bolt
+	ent->genericValue9 = trap_G2API_AddBolt(ent->ghoul2, 0, "cannon_Yrot"); //for placing the owner relative to rotation
+
+	//set the constraints for this guy as an emplaced weapon, and his constraint angles
+	ent->s.origin2[0] = 360.0f; //360 degrees in either direction
+
+	VectorCopy(fAng, ent->s.angles); //consider "angle 0" for constraint
+
+	//angle of y rot bone
+	ent->angle = 0.0f;
+
+	ent->r.ownerNum = spawner->s.number;
+	trap_LinkEntity(ent);
+
+	//store off the owner's current weapons, we will be forcing him to use the "emplaced" weapon
+	ent->genericValue11 = spawner->client->ps.stats[STAT_WEAPONS];
+
+	//start the "unfolding" anim
+	EWeb_SetBoneAnim(ent, 4, 20);
+	//don't allow use until the anim is done playing (rough time estimate)
+	ent->genericValue8 = level.time + 500;
+
+	VectorCopy(mins, ent->r.mins);
+	VectorCopy(maxs, ent->r.maxs);
+
+	return ent;
+}
+
+#define EWEB_USE_DEBOUNCE		1000
+//use the e-web
+void ItemUse_UseEWeb(gentity_t *ent)
+{
+	if (ent->client->ewebTime > level.time)
+	{ //can't use again yet
+		return;
+	}
+
+	if (ent->client->ps.weaponTime > 0 ||
+		ent->client->ps.forceHandExtend != HANDEXTEND_NONE)
+	{ //busy doing something else
+		return;
+	}
+
+	if (ent->client->ps.emplacedIndex && !ent->client->ewebIndex)
+	{ //using an emplaced gun already that isn't our own e-web
+		return;
+	}
+
+	if (ent->client->ewebIndex)
+	{ //put it away
+		EWebDisattach(ent, &g_entities[ent->client->ewebIndex]);
+	}
+	else
+	{ //create it
+		gentity_t *eweb = EWeb_Create(ent);
+
+		if (eweb)
+		{ //if it's null the thing couldn't spawn (probably no room)
+			ent->client->ewebIndex = eweb->s.number;
+			ent->client->ps.emplacedIndex = eweb->s.number;
+		}
+	}
+
+	ent->client->ewebTime = level.time + EWEB_USE_DEBOUNCE;
+}
+//===============================================
+//End E-Web
+//===============================================
+
+
+int Pickup_Powerup( gentity_t *ent, gentity_t *other ) {
+	int			quantity;
+	int			i;
+	gclient_t	*client;
+
+	if ( !other->client->ps.powerups[ent->item->giTag] ) {
+		// round timing to seconds to make multiple powerup timers
+		// count in sync
+		other->client->ps.powerups[ent->item->giTag] = 
+			level.time - ( level.time % 1000 );
+
+		G_LogWeaponPowerup(other->s.number, ent->item->giTag);
+	}
+
+	if ( ent->count ) {
+		quantity = ent->count;
+	} else {
+		quantity = ent->item->quantity;
+	}
+
+	other->client->ps.powerups[ent->item->giTag] += quantity * 1000;
+
+	if (ent->item->giTag == PW_YSALAMIRI)
+	{
+		other->client->ps.powerups[PW_FORCE_ENLIGHTENED_LIGHT] = 0;
+		other->client->ps.powerups[PW_FORCE_ENLIGHTENED_DARK] = 0;
+		other->client->ps.powerups[PW_FORCE_BOON] = 0;
+	}
+
+	// give any nearby players a "denied" anti-reward
+	for ( i = 0 ; i < level.maxclients ; i++ ) {
+		vec3_t		delta;
+		float		len;
+		vec3_t		forward;
+		trace_t		tr;
+
+		client = &level.clients[i];
+		if ( client == other->client ) {
+			continue;
+		}
+		if ( client->pers.connected == CON_DISCONNECTED ) {
+			continue;
+		}
+		if ( client->ps.stats[STAT_HEALTH] <= 0 ) {
+			continue;
+		}
+
+    // if same team in team game, no sound
+    // cannot use OnSameTeam as it expects to g_entities, not clients
+  	if ( g_gametype.integer >= GT_TEAM && other->client->sess.sessionTeam == client->sess.sessionTeam  ) {
+      continue;
+    }
+
+		// if too far away, no sound
+		VectorSubtract( ent->s.pos.trBase, client->ps.origin, delta );
+		len = VectorNormalize( delta );
+		if ( len > 192 ) {
+			continue;
+		}
+
+		// if not facing, no sound
+		AngleVectors( client->ps.viewangles, forward, NULL, NULL );
+		if ( DotProduct( delta, forward ) < 0.4 ) {
+			continue;
+		}
+
+		// if not line of sight, no sound
+		trap_Trace( &tr, client->ps.origin, NULL, NULL, ent->s.pos.trBase, ENTITYNUM_NONE, CONTENTS_SOLID );
+		if ( tr.fraction != 1.0 ) {
+			continue;
+		}
+
+		// anti-reward
+		client->ps.persistant[PERS_PLAYEREVENTS] ^= PLAYEREVENT_DENIEDREWARD;
+	}
+	return RESPAWN_POWERUP;
+}
+
+//======================================================================
+
+int Pickup_Holdable( gentity_t *ent, gentity_t *other ) {
+
+	other->client->ps.stats[STAT_HOLDABLE_ITEM] = ent->item - bg_itemlist;
+
+	other->client->ps.stats[STAT_HOLDABLE_ITEMS] |= (1 << ent->item->giTag);
+
+	G_LogWeaponItem(other->s.number, ent->item->giTag);
+
+	return adjustRespawnTime(RESPAWN_HOLDABLE, ent->item->giType, ent->item->giTag);
+}
+
+
+//======================================================================
+
+void Add_Ammo (gentity_t *ent, int weapon, int count)
+{
+	if ( ent->client->ps.ammo[weapon] < ammoData[weapon].max )
+	{
+		ent->client->ps.ammo[weapon] += count;
+		if ( ent->client->ps.ammo[weapon] > ammoData[weapon].max )
+		{
+			ent->client->ps.ammo[weapon] = ammoData[weapon].max;
+		}
+	}
+}
+
+int Pickup_Ammo (gentity_t *ent, gentity_t *other)
+{
+	int		quantity;
+
+	if ( ent->count ) {
+		quantity = ent->count;
+	} else {
+		quantity = ent->item->quantity;
+	}
+
+	if (ent->item->giTag == -1)
+	{ //an ammo_all, give them a bit of everything
+		if ( g_gametype.integer == GT_SIEGE )	// complaints that siege tech's not giving enough ammo.  Does anything else use ammo all?
+		{
+			Add_Ammo(other, AMMO_BLASTER, 100);
+			Add_Ammo(other, AMMO_POWERCELL, 100);
+			Add_Ammo(other, AMMO_METAL_BOLTS, 100);
+			Add_Ammo(other, AMMO_ROCKETS, 5);
+			if (other->client->ps.stats[STAT_WEAPONS] & (1<<WP_DET_PACK))
+			{
+				Add_Ammo(other, AMMO_DETPACK, 2);
+			}
+			if (other->client->ps.stats[STAT_WEAPONS] & (1<<WP_THERMAL))
+			{
+				Add_Ammo(other, AMMO_THERMAL, 2);
+			}
+			if (other->client->ps.stats[STAT_WEAPONS] & (1<<WP_TRIP_MINE))
+			{
+				Add_Ammo(other, AMMO_TRIPMINE, 2);
+			}
+		}
+		else
+		{
+			Add_Ammo(other, AMMO_BLASTER, 50);
+			Add_Ammo(other, AMMO_POWERCELL, 50);
+			Add_Ammo(other, AMMO_METAL_BOLTS, 50);
+			Add_Ammo(other, AMMO_ROCKETS, 2);
+		}
+	}
+	else
+	{
+		Add_Ammo (other, ent->item->giTag, quantity);
+	}
+
+	return adjustRespawnTime(RESPAWN_AMMO, ent->item->giType, ent->item->giTag);
+}
+
+//======================================================================
+
+
+int Pickup_Weapon (gentity_t *ent, gentity_t *other) {
+	int		quantity;
+
+	if ( ent->count < 0 ) {
+		quantity = 0; // None for you, sir!
+	} else {
+		if ( ent->count ) {
+			quantity = ent->count;
+		} else {
+			quantity = ent->item->quantity;
+		}
+
+		// dropped items and teamplay weapons always have full ammo
+		if ( ! (ent->flags & FL_DROPPED_ITEM) && g_gametype.integer != GT_TEAM ) {
+			// respawning rules
+
+			// New method:  If the player has less than half the minimum, give them the minimum, else add 1/2 the min.
+
+			// drop the quantity if the already have over the minimum
+			if ( other->client->ps.ammo[ ent->item->giTag ] < quantity*0.5 ) {
+				quantity = quantity - other->client->ps.ammo[ ent->item->giTag ];
+			} else {
+				quantity = quantity*0.5;		// only add half the value.
+			}
+
+			// Old method:  If the player has less than the minimum, give them the minimum, else just add 1.
+/*
+			// drop the quantity if the already have over the minimum
+			if ( other->client->ps.ammo[ ent->item->giTag ] < quantity ) {
+				quantity = quantity - other->client->ps.ammo[ ent->item->giTag ];
+			} else {
+				quantity = 1;		// only add a single shot
+			}
+			*/
+		}
+	}
+
+	// add the weapon
+	other->client->ps.stats[STAT_WEAPONS] |= ( 1 << ent->item->giTag );
+
+	//Add_Ammo( other, ent->item->giTag, quantity );
+	Add_Ammo( other, weaponData[ent->item->giTag].ammoIndex, quantity );
+
+	G_LogWeaponPickup(other->s.number, ent->item->giTag);
+	
+	// team deathmatch has slow weapon respawns
+	if ( g_gametype.integer == GT_TEAM ) 
+	{
+		return adjustRespawnTime(RESPAWN_TEAM_WEAPON, ent->item->giType, ent->item->giTag);
+	}
+
+	return adjustRespawnTime(g_weaponRespawn.integer, ent->item->giType, ent->item->giTag);
+}
+
+
+//======================================================================
+
+int Pickup_Health (gentity_t *ent, gentity_t *other) {
+	int			max;
+	int			quantity;
+
+	// small and mega healths will go over the max
+	if ( ent->item->quantity != 5 && ent->item->quantity != 100 ) {
+		max = other->client->ps.stats[STAT_MAX_HEALTH];
+	} else {
+		max = other->client->ps.stats[STAT_MAX_HEALTH] * 2;
+	}
+
+	if ( ent->count ) {
+		quantity = ent->count;
+	} else {
+		quantity = ent->item->quantity;
+	}
+
+	other->health += quantity;
+
+	if (other->health > max ) {
+		other->health = max;
+	}
+	other->client->ps.stats[STAT_HEALTH] = other->health;
+
+	if ( ent->item->quantity == 100 ) {		// mega health respawns slow
+		return RESPAWN_MEGAHEALTH;
+	}
+
+	return adjustRespawnTime(RESPAWN_HEALTH, ent->item->giType, ent->item->giTag);
+}
+
+//======================================================================
+
+int Pickup_Armor( gentity_t *ent, gentity_t *other ) 
+{
+	other->client->ps.stats[STAT_ARMOR] += ent->item->quantity;
+	if ( other->client->ps.stats[STAT_ARMOR] > other->client->ps.stats[STAT_MAX_HEALTH] * ent->item->giTag ) 
+	{
+		other->client->ps.stats[STAT_ARMOR] = other->client->ps.stats[STAT_MAX_HEALTH] * ent->item->giTag;
+	}
+
+	return adjustRespawnTime(RESPAWN_ARMOR, ent->item->giType, ent->item->giTag);
+}
+
+//======================================================================
+
+/*
+===============
+RespawnItem
+===============
+*/
+void RespawnItem( gentity_t *ent ) {
+	// randomly select from teamed entities
+	if (ent->team) {
+		gentity_t	*master;
+		int	count;
+		int choice;
+
+		if ( !ent->teammaster ) {
+			G_Error( "RespawnItem: bad teammaster");
+		}
+		master = ent->teammaster;
+
+		for (count = 0, ent = master; ent; ent = ent->teamchain, count++)
+			;
+
+		choice = rand() % count;
+
+		for (count = 0, ent = master; count < choice; ent = ent->teamchain, count++)
+			;
+	}
+
+	ent->r.contents = CONTENTS_TRIGGER;
+	//ent->s.eFlags &= ~EF_NODRAW;
+	ent->s.eFlags &= ~(EF_NODRAW | EF_ITEMPLACEHOLDER);
+	ent->r.svFlags &= ~SVF_NOCLIENT;
+	trap_LinkEntity (ent);
+
+	if ( ent->item->giType == IT_POWERUP ) {
+		// play powerup spawn sound to all clients
+		gentity_t	*te;
+
+		// if the powerup respawn sound should Not be global
+		if (ent->speed) {
+			te = G_TempEntity( ent->s.pos.trBase, EV_GENERAL_SOUND );
+		}
+		else {
+			te = G_TempEntity( ent->s.pos.trBase, EV_GLOBAL_SOUND );
+		}
+		te->s.eventParm = G_SoundIndex( "sound/items/respawn1" );
+		te->r.svFlags |= SVF_BROADCAST;
+	}
+
+	// play the normal respawn sound only to nearby clients
+	G_AddEvent( ent, EV_ITEM_RESPAWN, 0 );
+
+	ent->nextthink = 0;
+}
+
+qboolean CheckItemCanBePickedUpByNPC( gentity_t *item, gentity_t *pickerupper )
+{
+	if ( (item->flags&FL_DROPPED_ITEM) 
+		&& item->activator != &g_entities[0] 
+		&& pickerupper->s.number 
+		&& pickerupper->s.weapon == WP_NONE 
+		&& pickerupper->enemy 
+		&& pickerupper->painDebounceTime < level.time
+		&& pickerupper->NPC && pickerupper->NPC->surrenderTime < level.time //not surrendering
+		&& !(pickerupper->NPC->scriptFlags&SCF_FORCED_MARCH) //not being forced to march
+		/*&& item->item->giTag != INV_SECURITY_KEY*/ )
+	{//non-player, in combat, picking up a dropped item that does NOT belong to the player and it *not* a security key
+		if ( level.time - item->s.time < 3000 )//was 5000
+		{
+			return qfalse;
+		}
+		return qtrue;
+	}
+	return qfalse;
+}
+
+/*
+===============
+Touch_Item
+===============
+*/
+void Touch_Item (gentity_t *ent, gentity_t *other, trace_t *trace) {
+	int			respawn;
+	qboolean	predict;
+
+	if (ent->genericValue10 > level.time &&
+		other &&
+		other->s.number == ent->genericValue11)
+	{ //this is the ent that we don't want to be able to touch us for x seconds
+		return;
+	}
+
+	if (ent->s.eFlags & EF_ITEMPLACEHOLDER)
+	{
+		return;
+	}
+
+	if (ent->s.eFlags & EF_NODRAW)
+	{
+		return;
+	}
+
+	if (ent->item->giType == IT_WEAPON &&
+		ent->s.powerups &&
+		ent->s.powerups < level.time)
+	{
+		ent->s.generic1 = 0;
+		ent->s.powerups = 0;
+	}
+
+	if (!other->client)
+		return;
+	if (other->health < 1)
+		return;		// dead people can't pickup
+
+	if (ent->item->giType == IT_POWERUP &&
+		(ent->item->giTag == PW_FORCE_ENLIGHTENED_LIGHT || ent->item->giTag == PW_FORCE_ENLIGHTENED_DARK))
+	{
+		if (ent->item->giTag == PW_FORCE_ENLIGHTENED_LIGHT)
+		{
+			if (other->client->ps.fd.forceSide != FORCE_LIGHTSIDE)
+			{
+				return;
+			}
+		}
+		else
+		{
+			if (other->client->ps.fd.forceSide != FORCE_DARKSIDE)
+			{
+				return;
+			}
+		}
+	}
+
+	// the same pickup rules are used for client side and server side
+	if ( !BG_CanItemBeGrabbed( g_gametype.integer, &ent->s, &other->client->ps ) ) {
+		return;
+	}
+
+	
+	if ( other->client->NPC_class == CLASS_ATST || 
+		other->client->NPC_class == CLASS_GONK || 
+		other->client->NPC_class == CLASS_MARK1 || 
+		other->client->NPC_class == CLASS_MARK2 || 
+		other->client->NPC_class == CLASS_MOUSE || 
+		other->client->NPC_class == CLASS_PROBE || 
+		other->client->NPC_class == CLASS_PROTOCOL || 
+		other->client->NPC_class == CLASS_R2D2 || 
+		other->client->NPC_class == CLASS_R5D2 || 
+		other->client->NPC_class == CLASS_SEEKER || 
+		other->client->NPC_class == CLASS_REMOTE || 
+		other->client->NPC_class == CLASS_RANCOR || 
+		other->client->NPC_class == CLASS_WAMPA || 
+		//other->client->NPC_class == CLASS_JAWA || //FIXME: in some cases it's okay?
+		other->client->NPC_class == CLASS_UGNAUGHT || //FIXME: in some cases it's okay?
+		other->client->NPC_class == CLASS_SENTRY )
+	{//FIXME: some flag would be better
+		//droids can't pick up items/weapons!
+		return;
+	}
+
+	if ( CheckItemCanBePickedUpByNPC( ent, other ) )
+	{
+		if ( other->NPC && other->NPC->goalEntity && other->NPC->goalEntity->enemy == ent )
+		{//they were running to pick me up, they did, so clear goal
+			other->NPC->goalEntity = NULL;
+			other->NPC->squadState = SQUAD_STAND_AND_SHOOT;
+		}
+	}
+	else if ( !(ent->spawnflags &  ITMSF_ALLOWNPC) )
+	{// NPCs cannot pick it up
+		if ( other->s.eType == ET_NPC )
+		{// Not the player?
+			qboolean dontGo = qfalse;
+			if (ent->item->giType == IT_AMMO &&
+				ent->item->giTag == -1 &&
+				other->s.NPC_class == CLASS_VEHICLE &&
+				other->m_pVehicle &&
+				other->m_pVehicle->m_pVehicleInfo->type == VH_WALKER)
+			{ //yeah, uh, atst gets healed by these things
+                if (other->maxHealth &&
+					other->health < other->maxHealth)
+				{
+					other->health += 80;
+					if (other->health > other->maxHealth)
+					{
+						other->health = other->maxHealth;
+					}
+					G_ScaleNetHealth(other);
+					dontGo = qtrue;
+				}
+			}
+
+			if (!dontGo)
+			{
+				return;
+			}
+		}
+	}
+
+	G_LogPrintf( "Item: %i %s\n", other->s.number, ent->item->classname );
+
+	predict = other->client->pers.predictItemPickup;
+
+	// call the item-specific pickup function
+	switch( ent->item->giType ) {
+	case IT_WEAPON:
+		respawn = Pickup_Weapon(ent, other);
+//		predict = qfalse;
+		predict = qtrue;
+		break;
+	case IT_AMMO:
+		respawn = Pickup_Ammo(ent, other);
+		if (ent->item->giTag == AMMO_THERMAL || ent->item->giTag == AMMO_TRIPMINE || ent->item->giTag == AMMO_DETPACK)
+		{
+			int weapForAmmo = 0;
+
+			if (ent->item->giTag == AMMO_THERMAL)
+			{
+				weapForAmmo = WP_THERMAL;
+			}
+			else if (ent->item->giTag == AMMO_TRIPMINE)
+			{
+				weapForAmmo = WP_TRIP_MINE;
+			}
+			else
+			{
+				weapForAmmo = WP_DET_PACK;
+			}
+
+			if (other && other->client && other->client->ps.ammo[weaponData[weapForAmmo].ammoIndex] > 0 )
+			{
+				other->client->ps.stats[STAT_WEAPONS] |= (1 << weapForAmmo);
+			}
+		}
+//		predict = qfalse;
+		predict = qtrue;
+		break;
+	case IT_ARMOR:
+		respawn = Pickup_Armor(ent, other);
+//		predict = qfalse;
+		predict = qtrue;
+		break;
+	case IT_HEALTH:
+		respawn = Pickup_Health(ent, other);
+//		predict = qfalse;
+		predict = qtrue;
+		break;
+	case IT_POWERUP:
+		respawn = Pickup_Powerup(ent, other);
+		predict = qfalse;
+//		predict = qtrue;
+		break;
+	case IT_TEAM:
+		respawn = Pickup_Team(ent, other);
+		break;
+	case IT_HOLDABLE:
+		respawn = Pickup_Holdable(ent, other);
+		break;
+	default:
+		return;
+	}
+
+	if ( !respawn ) {
+		return;
+	}
+
+	// play the normal pickup sound
+	if (predict) {
+		if (other->client)
+		{
+			BG_AddPredictableEventToPlayerstate( EV_ITEM_PICKUP, ent->s.number, &other->client->ps);
+		}
+		else
+		{
+			G_AddPredictableEvent( other, EV_ITEM_PICKUP, ent->s.number );
+		}
+	} else {
+		G_AddEvent( other, EV_ITEM_PICKUP, ent->s.number );
+	}
+
+	// powerup pickups are global broadcasts
+	if ( /*ent->item->giType == IT_POWERUP ||*/ ent->item->giType == IT_TEAM) {
+		// if we want the global sound to play
+		if (!ent->speed) {
+			gentity_t	*te;
+
+			te = G_TempEntity( ent->s.pos.trBase, EV_GLOBAL_ITEM_PICKUP );
+			te->s.eventParm = ent->s.modelindex;
+			te->r.svFlags |= SVF_BROADCAST;
+		} else {
+			gentity_t	*te;
+
+			te = G_TempEntity( ent->s.pos.trBase, EV_GLOBAL_ITEM_PICKUP );
+			te->s.eventParm = ent->s.modelindex;
+			// only send this temp entity to a single client
+			te->r.svFlags |= SVF_SINGLECLIENT;
+			te->r.singleClient = other->s.number;
+		}
+	}
+
+	// fire item targets
+	G_UseTargets (ent, other);
+
+	// wait of -1 will not respawn
+	if ( ent->wait == -1 ) {
+		ent->r.svFlags |= SVF_NOCLIENT;
+		ent->s.eFlags |= EF_NODRAW;
+		ent->r.contents = 0;
+		ent->unlinkAfterEvent = qtrue;
+		return;
+	}
+
+	// non zero wait overrides respawn time
+	if ( ent->wait ) {
+		respawn = ent->wait;
+	}
+
+	// random can be used to vary the respawn time
+	if ( ent->random ) {
+		respawn += crandom() * ent->random;
+		if ( respawn < 1 ) {
+			respawn = 1;
+		}
+	}
+
+	// dropped items will not respawn
+	if ( ent->flags & FL_DROPPED_ITEM ) {
+		ent->freeAfterEvent = qtrue;
+	}
+
+	// picked up items still stay around, they just don't
+	// draw anything.  This allows respawnable items
+	// to be placed on movers.
+	if (!(ent->flags & FL_DROPPED_ITEM) && (ent->item->giType==IT_WEAPON || ent->item->giType==IT_POWERUP))
+	{
+		ent->s.eFlags |= EF_ITEMPLACEHOLDER;
+		ent->s.eFlags &= ~EF_NODRAW;
+	}
+	else
+	{
+		ent->s.eFlags |= EF_NODRAW;
+		ent->r.svFlags |= SVF_NOCLIENT;
+	}
+	ent->r.contents = 0;
+
+	if (ent->genericValue9)
+	{ //dropped item, should be removed when picked up
+		ent->think = G_FreeEntity;
+		ent->nextthink = level.time;
+		return;
+	}
+
+	// ZOID
+	// A negative respawn times means to never respawn this item (but don't 
+	// delete it).  This is used by items that are respawned by third party 
+	// events such as ctf flags
+	if ( respawn <= 0 ) {
+		ent->nextthink = 0;
+		ent->think = 0;
+	} else {
+		ent->nextthink = level.time + respawn * 1000;
+		ent->think = RespawnItem;
+	}
+	trap_LinkEntity( ent );
+}
+
+
+//======================================================================
+
+/*
+================
+LaunchItem
+
+Spawns an item and tosses it forward
+================
+*/
+gentity_t *LaunchItem( gitem_t *item, vec3_t origin, vec3_t velocity ) {
+	gentity_t	*dropped;
+
+	dropped = G_Spawn();
+
+	dropped->s.eType = ET_ITEM;
+	dropped->s.modelindex = item - bg_itemlist;	// store item number in modelindex
+	if (dropped->s.modelindex < 0)
+	{
+		dropped->s.modelindex = 0;
+	}
+	dropped->s.modelindex2 = 1; // This is non-zero is it's a dropped item
+
+	dropped->classname = item->classname;
+	dropped->item = item;
+	VectorSet (dropped->r.mins, -ITEM_RADIUS, -ITEM_RADIUS, -ITEM_RADIUS);
+	VectorSet (dropped->r.maxs, ITEM_RADIUS, ITEM_RADIUS, ITEM_RADIUS);
+
+	dropped->r.contents = CONTENTS_TRIGGER;
+
+	dropped->touch = Touch_Item;
+
+	G_SetOrigin( dropped, origin );
+	dropped->s.pos.trType = TR_GRAVITY;
+	dropped->s.pos.trTime = level.time;
+	VectorCopy( velocity, dropped->s.pos.trDelta );
+
+	dropped->flags |= FL_BOUNCE_HALF;
+	if ((g_gametype.integer == GT_CTF || g_gametype.integer == GT_CTY) && item->giType == IT_TEAM) { // Special case for CTF flags
+		dropped->think = Team_DroppedFlagThink;
+		dropped->nextthink = level.time + 30000;
+		Team_CheckDroppedItem( dropped );
+
+		//rww - so bots know
+		if (strcmp(dropped->classname, "team_CTF_redflag") == 0)
+		{
+			droppedRedFlag = dropped;
+		}
+		else if (strcmp(dropped->classname, "team_CTF_blueflag") == 0)
+		{
+			droppedBlueFlag = dropped;
+		}
+	} else { // auto-remove after 30 seconds
+		dropped->think = G_FreeEntity;
+		dropped->nextthink = level.time + 30000;
+	}
+
+	dropped->flags = FL_DROPPED_ITEM;
+
+	if (item->giType == IT_WEAPON || item->giType == IT_POWERUP)
+	{
+		dropped->s.eFlags |= EF_DROPPEDWEAPON;
+	}
+
+	vectoangles(velocity, dropped->s.angles);
+	dropped->s.angles[PITCH] = 0;
+
+	if (item->giTag == WP_TRIP_MINE ||
+		item->giTag == WP_DET_PACK)
+	{
+		dropped->s.angles[PITCH] = -90;
+	}
+
+	if (item->giTag != WP_BOWCASTER &&
+		item->giTag != WP_DET_PACK &&
+		item->giTag != WP_THERMAL)
+	{
+		dropped->s.angles[ROLL] = -90;
+	}
+
+	dropped->physicsObject = qtrue;
+
+	trap_LinkEntity (dropped);
+
+	return dropped;
+}
+
+/*
+================
+Drop_Item
+
+Spawns an item and tosses it forward
+================
+*/
+gentity_t *Drop_Item( gentity_t *ent, gitem_t *item, float angle ) {
+	vec3_t	velocity;
+	vec3_t	angles;
+
+	VectorCopy( ent->s.apos.trBase, angles );
+	angles[YAW] += angle;
+	angles[PITCH] = 0;	// always forward
+
+	AngleVectors( angles, velocity, NULL, NULL );
+	VectorScale( velocity, 150, velocity );
+	velocity[2] += 200 + crandom() * 50;
+	
+	return LaunchItem( item, ent->s.pos.trBase, velocity );
+}
+
+
+/*
+================
+Use_Item
+
+Respawn the item
+================
+*/
+void Use_Item( gentity_t *ent, gentity_t *other, gentity_t *activator ) {
+	RespawnItem( ent );
+}
+
+//======================================================================
+
+/*
+================
+FinishSpawningItem
+
+Traces down to find where an item should rest, instead of letting them
+free fall from their spawn points
+================
+*/
+void FinishSpawningItem( gentity_t *ent ) {
+	trace_t		tr;
+	vec3_t		dest;
+//	gitem_t		*item;
+
+//	VectorSet( ent->r.mins, -ITEM_RADIUS, -ITEM_RADIUS, -ITEM_RADIUS );
+//	VectorSet( ent->r.maxs, ITEM_RADIUS, ITEM_RADIUS, ITEM_RADIUS );
+
+	if (g_gametype.integer == GT_SIEGE)
+	{ //in siege remove all powerups
+		if (ent->item->giType == IT_POWERUP)
+		{
+			G_FreeEntity(ent);
+			return;
+		}
+	}
+
+	if (g_gametype.integer != GT_JEDIMASTER)
+	{
+		if (HasSetSaberOnly())
+		{
+			if (ent->item->giType == IT_AMMO)
+			{
+				G_FreeEntity( ent );
+				return;
+			}
+
+			if (ent->item->giType == IT_HOLDABLE)
+			{
+				if (ent->item->giTag == HI_SEEKER ||
+					ent->item->giTag == HI_SHIELD ||
+					ent->item->giTag == HI_SENTRY_GUN)
+				{
+					G_FreeEntity( ent );
+					return;
+				}
+			}
+		}
+	}
+	else
+	{ //no powerups in jedi master
+		if (ent->item->giType == IT_POWERUP)
+		{
+			G_FreeEntity(ent);
+			return;
+		}
+	}
+
+	if (g_gametype.integer == GT_HOLOCRON)
+	{
+		if (ent->item->giType == IT_POWERUP)
+		{
+			if (ent->item->giTag == PW_FORCE_ENLIGHTENED_LIGHT ||
+				ent->item->giTag == PW_FORCE_ENLIGHTENED_DARK)
+			{
+				G_FreeEntity(ent);
+				return;
+			}
+		}
+	}
+
+	if (g_forcePowerDisable.integer)
+	{ //if force powers disabled, don't add force powerups
+		if (ent->item->giType == IT_POWERUP)
+		{
+			if (ent->item->giTag == PW_FORCE_ENLIGHTENED_LIGHT ||
+				ent->item->giTag == PW_FORCE_ENLIGHTENED_DARK ||
+				ent->item->giTag == PW_FORCE_BOON)
+			{
+				G_FreeEntity(ent);
+				return;
+			}
+		}
+	}
+
+	if (g_gametype.integer == GT_DUEL || g_gametype.integer == GT_POWERDUEL)
+	{
+		if ( ent->item->giType == IT_ARMOR ||
+			ent->item->giType == IT_HEALTH ||
+			(ent->item->giType == IT_HOLDABLE && (ent->item->giTag == HI_MEDPAC || ent->item->giTag == HI_MEDPAC_BIG)) )
+		{
+			G_FreeEntity(ent);
+			return;
+		}
+	}
+
+	if (g_gametype.integer != GT_CTF &&
+		g_gametype.integer != GT_CTY &&
+		ent->item->giType == IT_TEAM)
+	{
+		int killMe = 0;
+
+		switch (ent->item->giTag)
+		{
+		case PW_REDFLAG:
+			killMe = 1;
+			break;
+		case PW_BLUEFLAG:
+			killMe = 1;
+			break;
+		case PW_NEUTRALFLAG:
+			killMe = 1;
+			break;
+		default:
+			break;
+		}
+
+		if (killMe)
+		{
+			G_FreeEntity( ent );
+			return;
+		}
+	}
+
+	VectorSet (ent->r.mins, -8, -8, -0);
+	VectorSet (ent->r.maxs, 8, 8, 16);
+
+	ent->s.eType = ET_ITEM;
+	ent->s.modelindex = ent->item - bg_itemlist;		// store item number in modelindex
+	ent->s.modelindex2 = 0; // zero indicates this isn't a dropped item
+
+	ent->r.contents = CONTENTS_TRIGGER;
+	ent->touch = Touch_Item;
+	// useing an item causes it to respawn
+	ent->use = Use_Item;
+
+	// create a Ghoul2 model if the world model is a glm
+/*	item = &bg_itemlist[ ent->s.modelindex ];
+	if (!stricmp(&item->world_model[0][strlen(item->world_model[0]) - 4], ".glm"))
+	{
+		trap_G2API_InitGhoul2Model(&ent->s, item->world_model[0], G_ModelIndex(item->world_model[0] ), 0, 0, 0, 0);
+		ent->s.radius = 60;
+	}
+*/
+	if ( ent->spawnflags & ITMSF_SUSPEND ) {
+		// suspended
+		G_SetOrigin( ent, ent->s.origin );
+	} else {
+		// drop to floor
+
+		//if it is directly even with the floor it will return startsolid, so raise up by 0.1
+		//and temporarily subtract 0.1 from the z maxs so that going up doesn't push into the ceiling
+		ent->s.origin[2] += 0.1;
+		ent->r.maxs[2] -= 0.1;
+
+		VectorSet( dest, ent->s.origin[0], ent->s.origin[1], ent->s.origin[2] - 4096 );
+		trap_Trace( &tr, ent->s.origin, ent->r.mins, ent->r.maxs, dest, ent->s.number, MASK_SOLID );
+		if ( tr.startsolid ) {
+			G_Printf ("FinishSpawningItem: %s startsolid at %s\n", ent->classname, vtos(ent->s.origin));
+			G_FreeEntity( ent );
+			return;
+		}
+
+		//add the 0.1 back after the trace
+		ent->r.maxs[2] += 0.1;
+
+		// allow to ride movers
+		ent->s.groundEntityNum = tr.entityNum;
+
+		G_SetOrigin( ent, tr.endpos );
+	}
+
+	// team slaves and targeted items aren't present at start
+	if ( ( ent->flags & FL_TEAMSLAVE ) || ent->targetname ) {
+		ent->s.eFlags |= EF_NODRAW;
+		ent->r.contents = 0;
+		return;
+	}
+
+	// powerups don't spawn in for a while
+	/*
+	if ( ent->item->giType == IT_POWERUP ) {
+		float	respawn;
+
+		respawn = 45 + crandom() * 15;
+		ent->s.eFlags |= EF_NODRAW;
+		ent->r.contents = 0;
+		ent->nextthink = level.time + respawn * 1000;
+		ent->think = RespawnItem;
+		return;
+	}
+	*/
+
+	trap_LinkEntity (ent);
+}
+
+
+qboolean	itemRegistered[MAX_ITEMS];
+
+/*
+==================
+G_CheckTeamItems
+==================
+*/
+void G_CheckTeamItems( void ) {
+
+	// Set up team stuff
+	Team_InitGame();
+
+	if( g_gametype.integer == GT_CTF || g_gametype.integer == GT_CTY ) {
+		gitem_t	*item;
+
+		// check for the two flags
+		item = BG_FindItem( "team_CTF_redflag" );
+		if ( !item || !itemRegistered[ item - bg_itemlist ] ) {
+			G_Printf( S_COLOR_YELLOW "WARNING: No team_CTF_redflag in map" );
+		}
+		item = BG_FindItem( "team_CTF_blueflag" );
+		if ( !item || !itemRegistered[ item - bg_itemlist ] ) {
+			G_Printf( S_COLOR_YELLOW "WARNING: No team_CTF_blueflag in map" );
+		}
+	}
+}
+
+/*
+==============
+ClearRegisteredItems
+==============
+*/
+void ClearRegisteredItems( void ) {
+	memset( itemRegistered, 0, sizeof( itemRegistered ) );
+
+	// players always start with the base weapon
+	RegisterItem( BG_FindItemForWeapon( WP_BRYAR_PISTOL ) );
+	RegisterItem( BG_FindItemForWeapon( WP_STUN_BATON ) );
+	RegisterItem( BG_FindItemForWeapon( WP_MELEE ) );
+	RegisterItem( BG_FindItemForWeapon( WP_SABER ) );
+
+	if (g_gametype.integer == GT_SIEGE)
+	{ //kind of cheesy, maybe check if siege class with disp's is gonna be on this map too
+		G_PrecacheDispensers();
+	}
+}
+
+/*
+===============
+RegisterItem
+
+The item will be added to the precache list
+===============
+*/
+void RegisterItem( gitem_t *item ) {
+	if ( !item ) {
+		G_Error( "RegisterItem: NULL" );
+	}
+	itemRegistered[ item - bg_itemlist ] = qtrue;
+}
+
+
+/*
+===============
+SaveRegisteredItems
+
+Write the needed items to a config string
+so the client will know which ones to precache
+===============
+*/
+void SaveRegisteredItems( void ) {
+	char	string[MAX_ITEMS+1];
+	int		i;
+	int		count;
+
+	count = 0;
+	for ( i = 0 ; i < bg_numItems ; i++ ) {
+		if ( itemRegistered[i] ) {
+			count++;
+			string[i] = '1';
+		} else {
+			string[i] = '0';
+		}
+	}
+	string[ bg_numItems ] = 0;
+
+//	G_Printf( "%i items registered\n", count );
+	trap_SetConfigstring(CS_ITEMS, string);
+}
+
+/*
+============
+G_ItemDisabled
+============
+*/
+int G_ItemDisabled( gitem_t *item ) {
+
+	char name[128];
+
+	Com_sprintf(name, sizeof(name), "disable_%s", item->classname);
+	return trap_Cvar_VariableIntegerValue( name );
+}
+
+/*
+============
+G_SpawnItem
+
+Sets the clipping size and plants the object on the floor.
+
+Items can't be immediately dropped to floor, because they might
+be on an entity that hasn't spawned yet.
+============
+*/
+void G_SpawnItem (gentity_t *ent, gitem_t *item) {
+	int wDisable = 0;
+
+	G_SpawnFloat( "random", "0", &ent->random );
+	G_SpawnFloat( "wait", "0", &ent->wait );
+
+	if (g_gametype.integer == GT_DUEL || g_gametype.integer == GT_POWERDUEL)
+	{
+		wDisable = g_duelWeaponDisable.integer;
+	}
+	else
+	{
+		wDisable = g_weaponDisable.integer;
+	}
+
+	if (item->giType == IT_WEAPON &&
+		wDisable &&
+		(wDisable & (1 << item->giTag)))
+	{
+		if (g_gametype.integer != GT_JEDIMASTER)
+		{
+			G_FreeEntity( ent );
+			return;
+		}
+	}
+
+	RegisterItem( item );
+	if ( G_ItemDisabled(item) )
+		return;
+
+	ent->item = item;
+	// some movers spawn on the second frame, so delay item
+	// spawns until the third frame so they can ride trains
+	ent->nextthink = level.time + FRAMETIME * 2;
+	ent->think = FinishSpawningItem;
+
+	ent->physicsBounce = 0.50;		// items are bouncy
+
+	if ( item->giType == IT_POWERUP ) {
+		G_SoundIndex( "sound/items/respawn1" );
+		G_SpawnFloat( "noglobalsound", "0", &ent->speed);
+	}
+}
+
+
+/*
+================
+G_BounceItem
+
+================
+*/
+void G_BounceItem( gentity_t *ent, trace_t *trace ) {
+	vec3_t	velocity;
+	float	dot;
+	int		hitTime;
+
+	// reflect the velocity on the trace plane
+	hitTime = level.previousTime + ( level.time - level.previousTime ) * trace->fraction;
+	BG_EvaluateTrajectoryDelta( &ent->s.pos, hitTime, velocity );
+	dot = DotProduct( velocity, trace->plane.normal );
+	VectorMA( velocity, -2*dot, trace->plane.normal, ent->s.pos.trDelta );
+
+	// cut the velocity to keep from bouncing forever
+	VectorScale( ent->s.pos.trDelta, ent->physicsBounce, ent->s.pos.trDelta );
+
+	if ((ent->s.weapon == WP_DET_PACK && ent->s.eType == ET_GENERAL && ent->physicsObject))
+	{ //detpacks only
+		if (ent->touch)
+		{
+			ent->touch(ent, &g_entities[trace->entityNum], trace);
+			return;
+		}
+	}
+
+	// check for stop
+	if ( trace->plane.normal[2] > 0 && ent->s.pos.trDelta[2] < 40 ) {
+		trace->endpos[2] += 1.0;	// make sure it is off ground
+		SnapVector( trace->endpos );
+		G_SetOrigin( ent, trace->endpos );
+		ent->s.groundEntityNum = trace->entityNum;
+		return;
+	}
+
+	VectorAdd( ent->r.currentOrigin, trace->plane.normal, ent->r.currentOrigin);
+	VectorCopy( ent->r.currentOrigin, ent->s.pos.trBase );
+	ent->s.pos.trTime = level.time;
+
+	if (ent->s.eType == ET_HOLOCRON ||
+		(ent->s.shouldtarget && ent->s.eType == ET_GENERAL && ent->physicsObject))
+	{ //holocrons and sentry guns
+		if (ent->touch)
+		{
+			ent->touch(ent, &g_entities[trace->entityNum], trace);
+		}
+	}
+}
+
+
+/*
+================
+G_RunItem
+
+================
+*/
+void G_RunItem( gentity_t *ent ) {
+	vec3_t		origin;
+	trace_t		tr;
+	int			contents;
+	int			mask;
+
+	// if groundentity has been set to -1, it may have been pushed off an edge
+	if ( ent->s.groundEntityNum == -1 ) {
+		if ( ent->s.pos.trType != TR_GRAVITY ) {
+			ent->s.pos.trType = TR_GRAVITY;
+			ent->s.pos.trTime = level.time;
+		}
+	}
+
+	if ( ent->s.pos.trType == TR_STATIONARY ) {
+		// check think function
+		G_RunThink( ent );
+		return;
+	}
+
+	// get current position
+	BG_EvaluateTrajectory( &ent->s.pos, level.time, origin );
+
+	// trace a line from the previous position to the current position
+	if ( ent->clipmask ) {
+		mask = ent->clipmask;
+	} else {
+		mask = MASK_PLAYERSOLID & ~CONTENTS_BODY;//MASK_SOLID;
+	}
+	trap_Trace( &tr, ent->r.currentOrigin, ent->r.mins, ent->r.maxs, origin, 
+		ent->r.ownerNum, mask );
+
+	VectorCopy( tr.endpos, ent->r.currentOrigin );
+
+	if ( tr.startsolid ) {
+		tr.fraction = 0;
+	}
+
+	trap_LinkEntity( ent );	// FIXME: avoid this for stationary?
+
+	// check think function
+	G_RunThink( ent );
+
+	if ( tr.fraction == 1 ) {
+		return;
+	}
+
+	// if it is in a nodrop volume, remove it
+	contents = trap_PointContents( ent->r.currentOrigin, -1 );
+	if ( contents & CONTENTS_NODROP ) {
+		if (ent->item && ent->item->giType == IT_TEAM) {
+			Team_FreeEntity(ent);
+		} else {
+			G_FreeEntity( ent );
+		}
+		return;
+	}
+
+	G_BounceItem( ent, &tr );
+}
+
diff --git a/codemp/game/g_local.h b/codemp/game/g_local.h
new file mode 100644
index 0000000..fdf7c7e
--- /dev/null
+++ b/codemp/game/g_local.h
@@ -0,0 +1,1969 @@
+// Copyright (C) 1999-2000 Id Software, Inc.
+//
+// g_local.h -- local definitions for game module
+
+#include "q_shared.h"
+#include "bg_public.h"
+#include "bg_vehicles.h"
+#include "g_public.h"
+
+#ifndef __LCC__
+#define GAME_INLINE ID_INLINE
+#else
+#define GAME_INLINE //none
+#endif
+
+typedef struct gentity_s gentity_t;
+typedef struct gclient_s gclient_t;
+
+//npc stuff
+#include "b_public.h"
+
+extern int gPainMOD;
+extern int gPainHitLoc;
+extern vec3_t gPainPoint;
+
+//==================================================================
+
+// the "gameversion" client command will print this plus compile date
+#define	GAMEVERSION	"basejk"
+
+#define BODY_QUEUE_SIZE		8
+
+#ifndef INFINITE
+#define INFINITE			1000000
+#endif
+
+#define	FRAMETIME			100					// msec
+#define	CARNAGE_REWARD_TIME	3000
+#define REWARD_SPRITE_TIME	2000
+
+#define	INTERMISSION_DELAY_TIME	1000
+#define	SP_INTERMISSION_DELAY_TIME	5000
+
+//primarily used by NPCs
+#define	START_TIME_LINK_ENTS		FRAMETIME*1 // time-delay after map start at which all ents have been spawned, so can link them
+#define	START_TIME_FIND_LINKS		FRAMETIME*2 // time-delay after map start at which you can find linked entities
+#define	START_TIME_MOVERS_SPAWNED	FRAMETIME*2 // time-delay after map start at which all movers should be spawned
+#define	START_TIME_REMOVE_ENTS		FRAMETIME*3 // time-delay after map start to remove temporary ents
+#define	START_TIME_NAV_CALC			FRAMETIME*4 // time-delay after map start to connect waypoints and calc routes
+#define	START_TIME_FIND_WAYPOINT	FRAMETIME*5 // time-delay after map start after which it's okay to try to find your best waypoint
+
+// gentity->flags
+#define	FL_GODMODE				0x00000010
+#define	FL_NOTARGET				0x00000020
+#define	FL_TEAMSLAVE			0x00000400	// not the first on the team
+#define FL_NO_KNOCKBACK			0x00000800
+#define FL_DROPPED_ITEM			0x00001000
+#define FL_NO_BOTS				0x00002000	// spawn point not for bot use
+#define FL_NO_HUMANS			0x00004000	// spawn point just for bots
+#define FL_FORCE_GESTURE		0x00008000	// force gesture on client
+#define FL_INACTIVE				0x00010000	// inactive
+#define FL_NAVGOAL				0x00020000	// for npc nav stuff
+#define	FL_DONT_SHOOT			0x00040000
+#define FL_SHIELDED				0x00080000
+#define FL_UNDYING				0x00100000	// takes damage down to 1, but never dies
+
+//ex-eFlags -rww
+#define	FL_BOUNCE				0x00100000		// for missiles
+#define	FL_BOUNCE_HALF			0x00200000		// for missiles
+#define	FL_BOUNCE_SHRAPNEL		0x00400000		// special shrapnel flag
+
+//vehicle game-local stuff -rww
+#define	FL_VEH_BOARDING			0x00800000		// special shrapnel flag
+
+//breakable flags -rww
+#define FL_DMG_BY_SABER_ONLY		0x01000000 //only take dmg from saber
+#define FL_DMG_BY_HEAVY_WEAP_ONLY	0x02000000 //only take dmg from explosives
+
+#define FL_BBRUSH					0x04000000 //I am a breakable brush
+
+#ifndef FINAL_BUILD
+#define DEBUG_SABER_BOX
+#endif
+
+#define	MAX_G_SHARED_BUFFER_SIZE		8192
+extern char gSharedBuffer[MAX_G_SHARED_BUFFER_SIZE];
+
+// movers are things like doors, plats, buttons, etc
+typedef enum {
+	MOVER_POS1,
+	MOVER_POS2,
+	MOVER_1TO2,
+	MOVER_2TO1
+} moverState_t;
+
+#define SP_PODIUM_MODEL		"models/mapobjects/podium/podium4.md3"
+
+typedef enum 
+{
+	HL_NONE = 0,
+	HL_FOOT_RT,
+	HL_FOOT_LT,
+	HL_LEG_RT,
+	HL_LEG_LT,
+	HL_WAIST,
+	HL_BACK_RT,
+	HL_BACK_LT,
+	HL_BACK,
+	HL_CHEST_RT,
+	HL_CHEST_LT,
+	HL_CHEST,
+	HL_ARM_RT,
+	HL_ARM_LT,
+	HL_HAND_RT,
+	HL_HAND_LT,
+	HL_HEAD,
+	HL_GENERIC1,
+	HL_GENERIC2,
+	HL_GENERIC3,
+	HL_GENERIC4,
+	HL_GENERIC5,
+	HL_GENERIC6,
+	HL_MAX
+};
+
+//============================================================================
+extern void *precachedKyle;
+extern void *g2SaberInstance;
+
+extern qboolean gEscaping;
+extern int gEscapeTime;
+
+struct gentity_s {
+	//rww - entstate must be first, to correspond with the bg shared entity structure
+	entityState_t	s;				// communicated by server to clients
+	playerState_t	*playerState;	//ptr to playerstate if applicable (for bg ents)
+	Vehicle_t		*m_pVehicle; //vehicle data
+	void			*ghoul2; //g2 instance
+	int				localAnimIndex; //index locally (game/cgame) to anim data for this skel
+	vec3_t			modelScale; //needed for g2 collision
+
+	//From here up must be the same as centity_t/bgEntity_t
+
+	entityShared_t	r;				// shared by both the server system and game
+
+	//rww - these are shared icarus things. They must be in this order as well in relation to the entityshared structure.
+	int				taskID[NUM_TIDS];
+	parms_t			*parms;
+	char			*behaviorSet[NUM_BSETS];
+	char			*script_targetname;
+	int				delayScriptTime;
+	char			*fullName;
+
+	//rww - targetname and classname are now shared as well. ICARUS needs access to them.
+	char			*targetname;
+	char			*classname;			// set in QuakeEd
+
+	//rww - and yet more things to share. This is because the nav code is in the exe because it's all C++.
+	int				waypoint;			//Set once per frame, if you've moved, and if someone asks
+	int				lastWaypoint;		//To make sure you don't double-back
+	int				lastValidWaypoint;	//ALWAYS valid -used for tracking someone you lost
+	int				noWaypointTime;		//Debouncer - so don't keep checking every waypoint in existance every frame that you can't find one
+	int				combatPoint;
+	int				failedWaypoints[MAX_FAILED_NODES];
+	int				failedWaypointCheckTime;
+
+	int				next_roff_time; //rww - npc's need to know when they're getting roff'd
+
+	// DO NOT MODIFY ANYTHING ABOVE THIS, THE SERVER
+	// EXPECTS THE FIELDS IN THAT ORDER!
+	//================================
+
+	struct gclient_s	*client;			// NULL if not a client
+
+	gNPC_t		*NPC;//Only allocated if the entity becomes an NPC
+	int			cantHitEnemyCounter;//HACK - Makes them look for another enemy on the same team if the one they're after can't be hit
+
+	qboolean	noLumbar; //see note in cg_local.h
+
+	qboolean	inuse;
+
+	int			lockCount; //used by NPCs
+
+	int			spawnflags;			// set in QuakeEd
+
+	int			teamnodmg;			// damage will be ignored if it comes from this team
+
+	char		*roffname;			// set in QuakeEd
+	char		*rofftarget;		// set in QuakeEd
+
+	char		*healingclass; //set in quakeed
+	char		*healingsound; //set in quakeed
+	int			healingrate; //set in quakeed
+	int			healingDebounce; //debounce for generic object healing shiz
+
+	char		*ownername;
+
+	int			objective;
+	int			side;
+
+	int			passThroughNum;		// set to index to pass through (+1) for missiles
+
+	int			aimDebounceTime;
+	int			painDebounceTime;
+	int			attackDebounceTime;
+	int			alliedTeam;			// only useable by this team, never target this team
+
+	int			roffid;				// if roffname != NULL then set on spawn
+
+	qboolean	neverFree;			// if true, FreeEntity will only unlink
+									// bodyque uses this
+
+	int			flags;				// FL_* variables
+
+	char		*model;
+	char		*model2;
+	int			freetime;			// level.time when the object was freed
+	
+	int			eventTime;			// events will be cleared EVENT_VALID_MSEC after set
+	qboolean	freeAfterEvent;
+	qboolean	unlinkAfterEvent;
+
+	qboolean	physicsObject;		// if true, it can be pushed by movers and fall off edges
+									// all game items are physicsObjects, 
+	float		physicsBounce;		// 1.0 = continuous bounce, 0.0 = no bounce
+	int			clipmask;			// brushes with this content value will be collided against
+									// when moving.  items and corpses do not collide against
+									// players, for instance
+
+//Only used by NPC_spawners
+	char		*NPC_type;
+	char		*NPC_targetname;
+	char		*NPC_target;
+
+	// movers
+	moverState_t moverState;
+	int			soundPos1;
+	int			sound1to2;
+	int			sound2to1;
+	int			soundPos2;
+	int			soundLoop;
+	gentity_t	*parent;
+	gentity_t	*nextTrain;
+	gentity_t	*prevTrain;
+	vec3_t		pos1, pos2;
+
+	//for npc's
+	vec3_t		pos3;
+
+	char		*message;
+
+	int			timestamp;		// body queue sinking, etc
+
+	float		angle;			// set in editor, -1 = up, -2 = down
+	char		*target;
+	char		*target2;
+	char		*target3;		//For multiple targets, not used for firing/triggering/using, though, only for path branches
+	char		*target4;		//For multiple targets, not used for firing/triggering/using, though, only for path branches
+	char		*target5;		//mainly added for siege items
+	char		*target6;		//mainly added for siege items
+
+	char		*team;
+	char		*targetShaderName;
+	char		*targetShaderNewName;
+	gentity_t	*target_ent;
+
+	char		*closetarget;
+	char		*opentarget;
+	char		*paintarget;
+
+	char		*goaltarget;
+	char		*idealclass;
+
+	float		radius;
+
+	int			maxHealth; //used as a base for crosshair health display
+
+	float		speed;
+	vec3_t		movedir;
+	float		mass;
+	int			setTime;
+
+//Think Functions
+	int			nextthink;
+	void		(*think)(gentity_t *self);
+	void		(*reached)(gentity_t *self);	// movers call this when hitting endpoint
+	void		(*blocked)(gentity_t *self, gentity_t *other);
+	void		(*touch)(gentity_t *self, gentity_t *other, trace_t *trace);
+	void		(*use)(gentity_t *self, gentity_t *other, gentity_t *activator);
+	void		(*pain)(gentity_t *self, gentity_t *attacker, int damage);
+	void		(*die)(gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int mod);
+
+	int			pain_debounce_time;
+	int			fly_sound_debounce_time;	// wind tunnel
+	int			last_move_time;
+
+//Health and damage fields
+	int			health;
+	qboolean	takedamage;
+	material_t	material;
+
+	int			damage;
+	int			dflags;
+	int			splashDamage;	// quad will increase this without increasing radius
+	int			splashRadius;
+	int			methodOfDeath;
+	int			splashMethodOfDeath;
+
+	int			locationDamage[HL_MAX];		// Damage accumulated on different body locations
+
+	int			count;
+	int			bounceCount;
+	qboolean	alt_fire;
+
+	gentity_t	*chain;
+	gentity_t	*enemy;
+	gentity_t	*lastEnemy;
+	gentity_t	*activator;
+	gentity_t	*teamchain;		// next entity in team
+	gentity_t	*teammaster;	// master of the team
+
+	int			watertype;
+	int			waterlevel;
+
+	int			noise_index;
+
+	// timing variables
+	float		wait;
+	float		random;
+	int			delay;
+
+	//generic values used by various entities for different purposes.
+	int			genericValue1;
+	int			genericValue2;
+	int			genericValue3;
+	int			genericValue4;
+	int			genericValue5;
+	int			genericValue6;
+	int			genericValue7;
+	int			genericValue8;
+	int			genericValue9;
+	int			genericValue10;
+	int			genericValue11;
+	int			genericValue12;
+	int			genericValue13;
+	int			genericValue14;
+	int			genericValue15;
+
+	char		*soundSet;
+
+	qboolean	isSaberEntity;
+
+	int			damageRedirect; //if entity takes damage, redirect to..
+	int			damageRedirectTo; //this entity number
+
+	vec3_t		epVelocity;
+	float		epGravFactor;
+
+	gitem_t		*item;			// for bonus items
+};
+
+#define DAMAGEREDIRECT_HEAD		1
+#define DAMAGEREDIRECT_RLEG		2
+#define DAMAGEREDIRECT_LLEG		3
+
+typedef enum {
+	CON_DISCONNECTED,
+	CON_CONNECTING,
+	CON_CONNECTED
+};
+typedef int clientConnected_t;
+
+typedef enum {
+	SPECTATOR_NOT,
+	SPECTATOR_FREE,
+	SPECTATOR_FOLLOW,
+	SPECTATOR_SCOREBOARD
+} spectatorState_t;
+
+typedef enum {
+	TEAM_BEGIN,		// Beginning a team game, spawn at base
+	TEAM_ACTIVE		// Now actively playing
+} playerTeamStateState_t;
+
+typedef struct {
+	playerTeamStateState_t	state;
+
+	int			location;
+
+	int			captures;
+	int			basedefense;
+	int			carrierdefense;
+	int			flagrecovery;
+	int			fragcarrier;
+	int			assists;
+
+	float		lasthurtcarrier;
+	float		lastreturnedflag;
+	float		flagsince;
+	float		lastfraggedcarrier;
+} playerTeamState_t;
+
+// the auto following clients don't follow a specific client
+// number, but instead follow the first two active players
+#define	FOLLOW_ACTIVE1	-1
+#define	FOLLOW_ACTIVE2	-2
+
+// client data that stays across multiple levels or tournament restarts
+// this is achieved by writing all the data to cvar strings at game shutdown
+// time and reading them back at connection time.  Anything added here
+// MUST be dealt with in G_InitSessionData() / G_ReadSessionData() / G_WriteSessionData()
+typedef struct {
+	team_t		sessionTeam;
+	int			spectatorTime;		// for determining next-in-line to play
+	spectatorState_t	spectatorState;
+	int			spectatorClient;	// for chasecam and follow mode
+	int			wins, losses;		// tournament stats
+	int			selectedFP;			// check against this, if doesn't match value in playerstate then update userinfo
+	int			saberLevel;			// similar to above method, but for current saber attack level
+	qboolean	setForce;			// set to true once player is given the chance to set force powers
+	int			updateUITime;		// only update userinfo for FP/SL if < level.time
+	qboolean	teamLeader;			// true when this client is a team leader
+	char		siegeClass[64];
+	char		saberType[64];
+	char		saber2Type[64];
+	int			duelTeam;
+	int			siegeDesiredTeam;
+} clientSession_t;
+
+// playerstate mGameFlags
+#define	PSG_VOTED				(1<<0)		// already cast a vote
+#define PSG_TEAMVOTED			(1<<1)		// already cast a team vote
+
+//
+#define MAX_NETNAME			36
+#define	MAX_VOTE_COUNT		3
+
+// client data that stays across multiple respawns, but is cleared
+// on each level change or team change at ClientBegin()
+typedef struct {
+	clientConnected_t	connected;	
+	usercmd_t	cmd;				// we would lose angles if not persistant
+	qboolean	localClient;		// true if "ip" info key is "localhost"
+	qboolean	initialSpawn;		// the first spawn should be at a cool location
+	qboolean	predictItemPickup;	// based on cg_predictItems userinfo
+	qboolean	pmoveFixed;			//
+	char		netname[MAX_NETNAME];
+	int			netnameTime;				// Last time the name was changed
+	int			maxHealth;			// for handicapping
+	int			enterTime;			// level.time the client entered the game
+	playerTeamState_t teamState;	// status in teamplay games
+	int			voteCount;			// to prevent people from constantly calling votes
+	int			teamVoteCount;		// to prevent people from constantly calling votes
+	qboolean	teamInfo;			// send team overlay updates?
+} clientPersistant_t;
+
+typedef struct renderInfo_s
+{
+	//In whole degrees, How far to let the different model parts yaw and pitch
+	int		headYawRangeLeft;
+	int		headYawRangeRight;
+	int		headPitchRangeUp;
+	int		headPitchRangeDown;
+
+	int		torsoYawRangeLeft;
+	int		torsoYawRangeRight;
+	int		torsoPitchRangeUp;
+	int		torsoPitchRangeDown;
+
+	int		legsFrame;
+	int		torsoFrame;
+
+	float	legsFpsMod;
+	float	torsoFpsMod;
+
+	//Fields to apply to entire model set, individual model's equivalents will modify this value
+	vec3_t	customRGB;//Red Green Blue, 0 = don't apply
+	int		customAlpha;//Alpha to apply, 0 = none?
+
+	//RF?
+	int			renderFlags;
+
+	//
+	vec3_t		muzzlePoint;
+	vec3_t		muzzleDir;
+	vec3_t		muzzlePointOld;
+	vec3_t		muzzleDirOld;
+	//vec3_t		muzzlePointNext;	// Muzzle point one server frame in the future!
+	//vec3_t		muzzleDirNext;
+	int			mPCalcTime;//Last time muzzle point was calced
+
+	//
+	float		lockYaw;//
+
+	//
+	vec3_t		headPoint;//Where your tag_head is
+	vec3_t		headAngles;//where the tag_head in the torso is pointing
+	vec3_t		handRPoint;//where your right hand is
+	vec3_t		handLPoint;//where your left hand is
+	vec3_t		crotchPoint;//Where your crotch is
+	vec3_t		footRPoint;//where your right hand is
+	vec3_t		footLPoint;//where your left hand is
+	vec3_t		torsoPoint;//Where your chest is
+	vec3_t		torsoAngles;//Where the chest is pointing
+	vec3_t		eyePoint;//Where your eyes are
+	vec3_t		eyeAngles;//Where your eyes face
+	int			lookTarget;//Which ent to look at with lookAngles
+	lookMode_t	lookMode;
+	int			lookTargetClearTime;//Time to clear the lookTarget
+	int			lastVoiceVolume;//Last frame's voice volume
+	vec3_t		lastHeadAngles;//Last headAngles, NOT actual facing of head model
+	vec3_t		headBobAngles;//headAngle offsets
+	vec3_t		targetHeadBobAngles;//head bob angles will try to get to targetHeadBobAngles
+	int			lookingDebounceTime;//When we can stop using head looking angle behavior
+	float		legsYaw;//yaw angle your legs are actually rendering at
+
+	//for tracking legitimate bolt indecies
+	void		*lastG2; //if it doesn't match ent->ghoul2, the bolts are considered invalid.
+	int			headBolt;
+	int			handRBolt;
+	int			handLBolt;
+	int			torsoBolt;
+	int			crotchBolt;
+	int			footRBolt;
+	int			footLBolt;
+	int			motionBolt;
+
+	int			boltValidityTime;
+} renderInfo_t;
+
+// this structure is cleared on each ClientSpawn(),
+// except for 'client->pers' and 'client->sess'
+struct gclient_s {
+	// ps MUST be the first element, because the server expects it
+	playerState_t	ps;				// communicated by server to clients
+
+	// the rest of the structure is private to game
+	clientPersistant_t	pers;
+	clientSession_t		sess;
+
+	saberInfo_t	saber[MAX_SABERS];
+	void		*weaponGhoul2[MAX_SABERS];
+
+	int			tossableItemDebounce;
+
+	int			bodyGrabTime;
+	int			bodyGrabIndex;
+
+	int			pushEffectTime;
+
+	int			invulnerableTimer;
+
+	int			saberCycleQueue;
+
+	int			legsAnimExecute;
+	int			torsoAnimExecute;
+	qboolean	legsLastFlip;
+	qboolean	torsoLastFlip;
+
+	qboolean	readyToExit;		// wishes to leave the intermission
+
+	qboolean	noclip;
+
+	int			lastCmdTime;		// level.time of last usercmd_t, for EF_CONNECTION
+									// we can't just use pers.lastCommand.time, because
+									// of the g_sycronousclients case
+	int			buttons;
+	int			oldbuttons;
+	int			latched_buttons;
+
+	vec3_t		oldOrigin;
+
+	// sum up damage over an entire frame, so
+	// shotgun blasts give a single big kick
+	int			damage_armor;		// damage absorbed by armor
+	int			damage_blood;		// damage taken out of health
+	int			damage_knockback;	// impact damage
+	vec3_t		damage_from;		// origin for vector calculation
+	qboolean	damage_fromWorld;	// if true, don't use the damage_from vector
+
+	int			damageBoxHandle_Head; //entity number of head damage box
+	int			damageBoxHandle_RLeg; //entity number of right leg damage box
+	int			damageBoxHandle_LLeg; //entity number of left leg damage box
+
+	int			accurateCount;		// for "impressive" reward sound
+
+	int			accuracy_shots;		// total number of shots
+	int			accuracy_hits;		// total number of hits
+
+	//
+	int			lastkilled_client;	// last client that this client killed
+	int			lasthurt_client;	// last client that damaged this client
+	int			lasthurt_mod;		// type of damage the client did
+
+	// timers
+	int			respawnTime;		// can respawn when time > this, force after g_forcerespwan
+	int			inactivityTime;		// kick players when time > this
+	qboolean	inactivityWarning;	// qtrue if the five seoond warning has been given
+	int			rewardTime;			// clear the EF_AWARD_IMPRESSIVE, etc when time > this
+
+	int			airOutTime;
+
+	int			lastKillTime;		// for multiple kill rewards
+
+	qboolean	fireHeld;			// used for hook
+	gentity_t	*hook;				// grapple hook if out
+
+	int			switchTeamTime;		// time the player switched teams
+
+	int			switchDuelTeamTime;		// time the player switched duel teams
+
+	int			switchClassTime;	// class changed debounce timer
+
+	// timeResidual is used to handle events that happen every second
+	// like health / armor countdowns and regeneration
+	int			timeResidual;
+
+	char		*areabits;
+
+	int			g2LastSurfaceHit; //index of surface hit during the most recent ghoul2 collision performed on this client.
+	int			g2LastSurfaceTime; //time when the surface index was set (to make sure it's up to date)
+
+	int			corrTime;
+
+	vec3_t		lastHeadAngles;
+	int			lookTime;
+
+	int			brokenLimbs;
+
+	qboolean	noCorpse; //don't leave a corpse on respawn this time.
+
+	int			jetPackTime;
+
+	qboolean	jetPackOn;
+	int			jetPackToggleTime;
+	int			jetPackDebRecharge;
+	int			jetPackDebReduce;
+
+	int			cloakToggleTime;
+	int			cloakDebRecharge;
+	int			cloakDebReduce;
+
+	int			saberStoredIndex; //stores saberEntityNum from playerstate for when it's set to 0 (indicating saber was knocked out of the air)
+
+	int			saberKnockedTime; //if saber gets knocked away, can't pull it back until this value is < level.time
+
+	vec3_t		olderSaberBase; //Set before lastSaberBase_Always, to whatever lastSaberBase_Always was previously
+	qboolean	olderIsValid;	//is it valid?
+
+	vec3_t		lastSaberDir_Always; //every getboltmatrix, set to saber dir
+	vec3_t		lastSaberBase_Always; //every getboltmatrix, set to saber base
+	int			lastSaberStorageTime; //server time that the above two values were updated (for making sure they aren't out of date)
+
+	qboolean	hasCurrentPosition;	//are lastSaberTip and lastSaberBase valid?
+
+	int			dangerTime;		// level.time when last attack occured
+
+	int			idleTime;		//keep track of when to play an idle anim on the client.
+
+	int			idleHealth;		//stop idling if health decreases
+	vec3_t		idleViewAngles;	//stop idling if viewangles change
+
+	int			forcePowerSoundDebounce; //if > level.time, don't do certain sound events again (drain sound, absorb sound, etc)
+
+	char		modelname[MAX_QPATH];
+
+	qboolean	fjDidJump;
+
+	qboolean	ikStatus;
+
+	int			throwingIndex;
+	int			beingThrown;
+	int			doingThrow;
+
+	float		hiddenDist;//How close ents have to be to pick you up as an enemy
+	vec3_t		hiddenDir;//Normalized direction in which NPCs can't see you (you are hidden)
+
+	renderInfo_t	renderInfo;
+
+	//mostly NPC stuff:
+	npcteam_t	playerTeam;
+	npcteam_t	enemyTeam;
+	char		*squadname;
+	gentity_t	*team_leader;
+	gentity_t	*leader;
+	gentity_t	*follower;
+	int			numFollowers;
+	gentity_t	*formationGoal;
+	int			nextFormGoal;
+	class_t		NPC_class;
+
+	vec3_t		pushVec;
+	int			pushVecTime;
+
+	int			siegeClass;
+	int			holdingObjectiveItem;
+
+	//time values for when being healed/supplied by supplier class
+	int			isMedHealed;
+	int			isMedSupplied;
+
+	//seperate debounce time for refilling someone's ammo as a supplier
+	int			medSupplyDebounce;
+
+	//used in conjunction with ps.hackingTime
+	int			isHacking;
+	vec3_t		hackingAngles;
+
+	//debounce time for sending extended siege data to certain classes
+	int			siegeEDataSend;
+
+	int			ewebIndex; //index of e-web gun if spawned
+	int			ewebTime; //e-web use debounce
+	int			ewebHealth; //health of e-web (to keep track between deployments)
+
+	int			inSpaceIndex; //ent index of space trigger if inside one
+	int			inSpaceSuffocation; //suffocation timer
+
+	int			tempSpectate; //time to force spectator mode
+
+	//keep track of last person kicked and the time so we don't hit multiple times per kick
+	int			jediKickIndex;
+	int			jediKickTime;
+
+	//special moves (designed for kyle boss npc, but useable by players in mp)
+	int			grappleIndex;
+	int			grappleState;
+
+	int			solidHack;
+
+	int			noLightningTime;
+
+	unsigned	mGameFlags;
+
+	//fallen duelist
+	qboolean	iAmALoser;
+
+	int			lastGenCmd;
+	int			lastGenCmdTime;
+};
+
+//Interest points
+
+#define MAX_INTEREST_POINTS		64
+
+typedef struct 
+{
+	vec3_t		origin;
+	char		*target;
+} interestPoint_t;
+
+//Combat points
+
+#define MAX_COMBAT_POINTS		512
+
+typedef struct 
+{
+	vec3_t		origin;
+	int			flags;
+//	char		*NPC_targetname;
+//	team_t		team;
+	qboolean	occupied;
+	int			waypoint;
+	int			dangerTime;
+} combatPoint_t;
+
+// Alert events
+
+#define	MAX_ALERT_EVENTS	32
+
+typedef enum
+{
+	AET_SIGHT,
+	AET_SOUND,
+} alertEventType_e;
+
+typedef enum
+{
+	AEL_MINOR,			//Enemy responds to the sound, but only by looking
+	AEL_SUSPICIOUS,		//Enemy looks at the sound, and will also investigate it
+	AEL_DISCOVERED,		//Enemy knows the player is around, and will actively hunt
+	AEL_DANGER,			//Enemy should try to find cover
+	AEL_DANGER_GREAT,	//Enemy should run like hell!
+} alertEventLevel_e;
+
+typedef struct alertEvent_s
+{
+	vec3_t				position;	//Where the event is located
+	float				radius;		//Consideration radius
+	alertEventLevel_e	level;		//Priority level of the event
+	alertEventType_e	type;		//Event type (sound,sight)
+	gentity_t			*owner;		//Who made the sound
+	float				light;		//ambient light level at point
+	float				addLight;	//additional light- makes it more noticable, even in darkness
+	int					ID;			//unique... if get a ridiculous number, this will repeat, but should not be a problem as it's just comparing it to your lastAlertID
+	int					timestamp;	//when it was created
+} alertEvent_t;
+
+//
+// this structure is cleared as each map is entered
+//
+typedef struct
+{
+	char	targetname[MAX_QPATH];
+	char	target[MAX_QPATH];
+	char	target2[MAX_QPATH];
+	char	target3[MAX_QPATH];
+	char	target4[MAX_QPATH];
+	int		nodeID;
+} waypointData_t;
+
+typedef struct {
+	struct gclient_s	*clients;		// [maxclients]
+
+	struct gentity_s	*gentities;
+	int			gentitySize;
+	int			num_entities;		// current number, <= MAX_GENTITIES
+
+	int			warmupTime;			// restart match at this time
+
+	fileHandle_t	logFile;
+
+	// store latched cvars here that we want to get at often
+	int			maxclients;
+
+	int			framenum;
+	int			time;					// in msec
+	int			previousTime;			// so movers can back up when blocked
+
+	int			startTime;				// level.time the map was started
+
+	int			teamScores[TEAM_NUM_TEAMS];
+	int			lastTeamLocationTime;		// last time of client team location update
+
+	qboolean	newSession;				// don't use any old session data, because
+										// we changed gametype
+
+	qboolean	restarted;				// waiting for a map_restart to fire
+
+	int			numConnectedClients;
+	int			numNonSpectatorClients;	// includes connecting clients
+	int			numPlayingClients;		// connected, non-spectators
+	int			sortedClients[MAX_CLIENTS];		// sorted by score
+	int			follow1, follow2;		// clientNums for auto-follow spectators
+
+	int			snd_fry;				// sound index for standing in lava
+
+	int			snd_hack;				//hacking loop sound
+    int			snd_medHealed;			//being healed by supply class
+	int			snd_medSupplied;		//being supplied by supply class
+
+	int			warmupModificationCount;	// for detecting if g_warmup is changed
+
+	// voting state
+	char		voteString[MAX_STRING_CHARS];
+	char		voteDisplayString[MAX_STRING_CHARS];
+	int			voteTime;				// level.time vote was called
+	int			voteExecuteTime;		// time the vote is executed
+	int			voteYes;
+	int			voteNo;
+	int			numVotingClients;		// set by CalculateRanks
+
+	qboolean	votingGametype;
+	int			votingGametypeTo;
+
+	// team voting state
+	char		teamVoteString[2][MAX_STRING_CHARS];
+	int			teamVoteTime[2];		// level.time vote was called
+	int			teamVoteYes[2];
+	int			teamVoteNo[2];
+	int			numteamVotingClients[2];// set by CalculateRanks
+
+	// spawn variables
+	qboolean	spawning;				// the G_Spawn*() functions are valid
+	int			numSpawnVars;
+	char		*spawnVars[MAX_SPAWN_VARS][2];	// key / value pairs
+	int			numSpawnVarChars;
+	char		spawnVarChars[MAX_SPAWN_VARS_CHARS];
+
+	// intermission state
+	int			intermissionQueued;		// intermission was qualified, but
+										// wait INTERMISSION_DELAY_TIME before
+										// actually going there so the last
+										// frag can be watched.  Disable future
+										// kills during this delay
+	int			intermissiontime;		// time the intermission was started
+	char		*changemap;
+	qboolean	readyToExit;			// at least one client wants to exit
+	int			exitTime;
+	vec3_t		intermission_origin;	// also used for spectator spawns
+	vec3_t		intermission_angle;
+
+	qboolean	locationLinked;			// target_locations get linked
+	gentity_t	*locationHead;			// head of the location list
+	int			bodyQueIndex;			// dead bodies
+	gentity_t	*bodyQue[BODY_QUEUE_SIZE];
+	int			portalSequence;
+
+	alertEvent_t	alertEvents[ MAX_ALERT_EVENTS ];
+	int				numAlertEvents;
+	int				curAlertID;
+
+	AIGroupInfo_t	groups[MAX_FRAME_GROUPS];
+
+	//Interest points- squadmates automatically look at these if standing around and close to them
+	interestPoint_t	interestPoints[MAX_INTEREST_POINTS];
+	int			numInterestPoints;
+
+	//Combat points- NPCs in bState BS_COMBAT_POINT will find their closest empty combat_point
+	combatPoint_t	combatPoints[MAX_COMBAT_POINTS];
+	int			numCombatPoints;
+
+	//rwwRMG - added:
+	int			mNumBSPInstances;
+	int			mBSPInstanceDepth;
+	vec3_t		mOriginAdjust;
+	float		mRotationAdjust;
+	char		*mTargetAdjust;
+
+	char		mTeamFilter[MAX_QPATH];
+
+} level_locals_t;
+
+
+//
+// g_spawn.c
+//
+qboolean	G_SpawnString( const char *key, const char *defaultString, char **out );
+// spawn string returns a temporary reference, you must CopyString() if you want to keep it
+qboolean	G_SpawnFloat( const char *key, const char *defaultString, float *out );
+qboolean	G_SpawnInt( const char *key, const char *defaultString, int *out );
+qboolean	G_SpawnVector( const char *key, const char *defaultString, float *out );
+void		G_SpawnEntitiesFromString( qboolean inSubBSP );
+char *G_NewString( const char *string );
+
+//
+// g_cmds.c
+//
+void Cmd_Score_f (gentity_t *ent);
+void StopFollowing( gentity_t *ent );
+void BroadcastTeamChange( gclient_t *client, int oldTeam );
+void SetTeam( gentity_t *ent, char *s );
+void Cmd_FollowCycle_f( gentity_t *ent, int dir );
+void Cmd_SaberAttackCycle_f(gentity_t *ent);
+int G_ItemUsable(playerState_t *ps, int forcedUse);
+void Cmd_ToggleSaber_f(gentity_t *ent);
+void Cmd_EngageDuel_f(gentity_t *ent);
+
+gentity_t *G_GetDuelWinner(gclient_t *client);
+
+//
+// g_items.c
+//
+void ItemUse_Binoculars(gentity_t *ent);
+void ItemUse_Shield(gentity_t *ent);
+void ItemUse_Sentry(gentity_t *ent);
+
+void Jetpack_Off(gentity_t *ent);
+void Jetpack_On(gentity_t *ent);
+void ItemUse_Jetpack(gentity_t *ent);
+void ItemUse_UseCloak( gentity_t *ent );
+void ItemUse_UseDisp(gentity_t *ent, int type);
+void ItemUse_UseEWeb(gentity_t *ent);
+void G_PrecacheDispensers(void);
+
+void ItemUse_Seeker(gentity_t *ent);
+void ItemUse_MedPack(gentity_t *ent);
+void ItemUse_MedPack_Big(gentity_t *ent);
+
+void G_CheckTeamItems( void );
+void G_RunItem( gentity_t *ent );
+void RespawnItem( gentity_t *ent );
+
+void UseHoldableItem( gentity_t *ent );
+void PrecacheItem (gitem_t *it);
+gentity_t *Drop_Item( gentity_t *ent, gitem_t *item, float angle );
+gentity_t *LaunchItem( gitem_t *item, vec3_t origin, vec3_t velocity );
+void SetRespawn (gentity_t *ent, float delay);
+void G_SpawnItem (gentity_t *ent, gitem_t *item);
+void FinishSpawningItem( gentity_t *ent );
+void Think_Weapon (gentity_t *ent);
+int ArmorIndex (gentity_t *ent);
+void	Add_Ammo (gentity_t *ent, int weapon, int count);
+void Touch_Item (gentity_t *ent, gentity_t *other, trace_t *trace);
+
+void ClearRegisteredItems( void );
+void RegisterItem( gitem_t *item );
+void SaveRegisteredItems( void );
+
+//
+// g_utils.c
+//
+int		G_ModelIndex( const char *name );
+int		G_SoundIndex( const char *name );
+int		G_SoundSetIndex(const char *name);
+int		G_EffectIndex( const char *name );
+int		G_BSPIndex( const char *name );
+int		G_IconIndex( const char* name );
+
+qboolean	G_PlayerHasCustomSkeleton(gentity_t *ent);
+
+void	G_TeamCommand( team_t team, char *cmd );
+void	G_ScaleNetHealth(gentity_t *self);
+void	G_KillBox (gentity_t *ent);
+gentity_t *G_Find (gentity_t *from, int fieldofs, const char *match);
+int		G_RadiusList ( vec3_t origin, float radius,	gentity_t *ignore, qboolean takeDamage, gentity_t *ent_list[MAX_GENTITIES]);
+
+void	G_Throw( gentity_t *targ, vec3_t newDir, float push );
+
+void	G_FreeFakeClient(gclient_t **cl);
+void	G_CreateFakeClient(int entNum, gclient_t **cl);
+void	G_CleanAllFakeClients(void);
+
+void	G_SetAnim(gentity_t *ent, usercmd_t *ucmd, int setAnimParts, int anim, int setAnimFlags, int blendTime);
+gentity_t *G_PickTarget (char *targetname);
+void	GlobalUse(gentity_t *self, gentity_t *other, gentity_t *activator);
+void	G_UseTargets2( gentity_t *ent, gentity_t *activator, const char *string );
+void	G_UseTargets (gentity_t *ent, gentity_t *activator);
+void	G_SetMovedir ( vec3_t angles, vec3_t movedir);
+void	G_SetAngles( gentity_t *ent, vec3_t angles );
+
+void	G_InitGentity( gentity_t *e );
+gentity_t	*G_Spawn (void);
+gentity_t *G_TempEntity( vec3_t origin, int event );
+gentity_t	*G_PlayEffect(int fxID, vec3_t org, vec3_t ang);
+gentity_t	*G_PlayEffectID(const int fxID, vec3_t org, vec3_t ang);
+gentity_t *G_ScreenShake(vec3_t org, gentity_t *target, float intensity, int duration, qboolean global);
+void	G_MuteSound( int entnum, int channel );
+void	G_Sound( gentity_t *ent, int channel, int soundIndex );
+void	G_SoundAtLoc( vec3_t loc, int channel, int soundIndex );
+void	G_EntitySound( gentity_t *ent, int channel, int soundIndex );
+void	TryUse( gentity_t *ent );
+void	G_SendG2KillQueue(void);
+void	G_KillG2Queue(int entNum);
+void	G_FreeEntity( gentity_t *e );
+qboolean	G_EntitiesFree( void );
+
+qboolean G_ActivateBehavior (gentity_t *self, int bset );
+
+void	G_TouchTriggers (gentity_t *ent);
+void	G_TouchSolids (gentity_t *ent);
+void	GetAnglesForDirection( const vec3_t p1, const vec3_t p2, vec3_t out );
+
+//
+// g_object.c
+//
+
+extern void G_RunObject			( gentity_t *ent );
+
+
+float	*tv (float x, float y, float z);
+char	*vtos( const vec3_t v );
+
+void G_AddPredictableEvent( gentity_t *ent, int event, int eventParm );
+void G_AddEvent( gentity_t *ent, int event, int eventParm );
+void G_SetOrigin( gentity_t *ent, vec3_t origin );
+qboolean G_CheckInSolid (gentity_t *self, qboolean fix);
+void AddRemap(const char *oldShader, const char *newShader, float timeOffset);
+const char *BuildShaderStateConfig(void);
+/*
+Ghoul2 Insert Start
+*/
+int G_BoneIndex( const char *name );
+
+#include "../namespace_begin.h"
+
+qhandle_t	trap_R_RegisterSkin( const char *name );
+
+// CG specific API access
+void		trap_G2_ListModelSurfaces(void *ghlInfo);
+void		trap_G2_ListModelBones(void *ghlInfo, int frame);
+void		trap_G2_SetGhoul2ModelIndexes(void *ghoul2, qhandle_t *modelList, qhandle_t *skinList);
+qboolean	trap_G2_HaveWeGhoul2Models(void *ghoul2);
+qboolean	trap_G2API_GetBoltMatrix(void *ghoul2, const int modelIndex, const int boltIndex, mdxaBone_t *matrix,
+								const vec3_t angles, const vec3_t position, const int frameNum, qhandle_t *modelList, vec3_t scale);
+qboolean	trap_G2API_GetBoltMatrix_NoReconstruct(void *ghoul2, const int modelIndex, const int boltIndex, mdxaBone_t *matrix,
+								const vec3_t angles, const vec3_t position, const int frameNum, qhandle_t *modelList, vec3_t scale);
+qboolean	trap_G2API_GetBoltMatrix_NoRecNoRot(void *ghoul2, const int modelIndex, const int boltIndex, mdxaBone_t *matrix,
+								const vec3_t angles, const vec3_t position, const int frameNum, qhandle_t *modelList, vec3_t scale);
+int			trap_G2API_InitGhoul2Model(void **ghoul2Ptr, const char *fileName, int modelIndex, qhandle_t customSkin,
+						  qhandle_t customShader, int modelFlags, int lodBias);
+qboolean	trap_G2API_SetSkin(void *ghoul2, int modelIndex, qhandle_t customSkin, qhandle_t renderSkin);
+
+int			trap_G2API_Ghoul2Size ( void* ghlInfo );
+
+int			trap_G2API_AddBolt(void *ghoul2, int modelIndex, const char *boneName);
+void		trap_G2API_SetBoltInfo(void *ghoul2, int modelIndex, int boltInfo);
+
+int			trap_G2API_CopyGhoul2Instance(void *g2From, void *g2To, int modelIndex);
+void		trap_G2API_CopySpecificGhoul2Model(void *g2From, int modelFrom, void *g2To, int modelTo);
+void		trap_G2API_DuplicateGhoul2Instance(void *g2From, void **g2To);
+qboolean	trap_G2API_HasGhoul2ModelOnIndex(void *ghlInfo, int modelIndex);
+qboolean	trap_G2API_RemoveGhoul2Model(void *ghlInfo, int modelIndex);
+qboolean	trap_G2API_RemoveGhoul2Models(void *ghlInfo);
+void		trap_G2API_CleanGhoul2Models(void **ghoul2Ptr);
+void		trap_G2API_CollisionDetect ( CollisionRecord_t *collRecMap, void* ghoul2, const vec3_t angles, const vec3_t position,
+								int frameNumber, int entNum, vec3_t rayStart, vec3_t rayEnd, vec3_t scale, int traceFlags, int useLod, float fRadius );
+
+qboolean	trap_G2API_SetBoneAngles(void *ghoul2, int modelIndex, const char *boneName, const vec3_t angles, const int flags,
+								const int up, const int right, const int forward, qhandle_t *modelList,
+								int blendTime , int currentTime );
+void		trap_G2API_GetGLAName(void *ghoul2, int modelIndex, char *fillBuf);
+qboolean	trap_G2API_SetBoneAnim(void *ghoul2, const int modelIndex, const char *boneName, const int startFrame, const int endFrame,
+							  const int flags, const float animSpeed, const int currentTime, const float setFrame , const int blendTime );
+qboolean	trap_G2API_GetBoneAnim(void *ghoul2, const char *boneName, const int currentTime, float *currentFrame, int *startFrame,
+								int *endFrame, int *flags, float *animSpeed, int *modelList, const int modelIndex);
+void		trap_G2API_GetSurfaceName(void *ghoul2, int surfNumber, int modelIndex, char *fillBuf);
+qboolean	trap_G2API_SetRootSurface(void *ghoul2, const int modelIndex, const char *surfaceName);
+qboolean	trap_G2API_SetSurfaceOnOff(void *ghoul2, const char *surfaceName, const int flags);
+qboolean	trap_G2API_SetNewOrigin(void *ghoul2, const int boltIndex);
+qboolean	trap_G2API_DoesBoneExist(void *ghoul2, int modelIndex, const char *boneName);
+int			trap_G2API_GetSurfaceRenderStatus(void *ghoul2, const int modelIndex, const char *surfaceName);
+
+void		trap_G2API_AbsurdSmoothing(void *ghoul2, qboolean status);
+
+void		trap_G2API_SetRagDoll(void *ghoul2, sharedRagDollParams_t *params);
+void		trap_G2API_AnimateG2Models(void *ghoul2, int time, sharedRagDollUpdateParams_t *params);
+
+//additional ragdoll options -rww
+qboolean	trap_G2API_RagPCJConstraint(void *ghoul2, const char *boneName, vec3_t min, vec3_t max); //override default pcj bonee constraints
+qboolean	trap_G2API_RagPCJGradientSpeed(void *ghoul2, const char *boneName, const float speed); //override the default gradient movespeed for a pcj bone
+qboolean	trap_G2API_RagEffectorGoal(void *ghoul2, const char *boneName, vec3_t pos); //override an effector bone's goal position (world coordinates)
+qboolean	trap_G2API_GetRagBonePos(void *ghoul2, const char *boneName, vec3_t pos, vec3_t entAngles, vec3_t entPos, vec3_t entScale); //current position of said bone is put into pos (world coordinates)
+qboolean	trap_G2API_RagEffectorKick(void *ghoul2, const char *boneName, vec3_t velocity); //add velocity to a rag bone
+qboolean	trap_G2API_RagForceSolve(void *ghoul2, qboolean force); //make sure we are actively performing solve/settle routines, if desired
+
+qboolean	trap_G2API_SetBoneIKState(void *ghoul2, int time, const char *boneName, int ikState, sharedSetBoneIKStateParams_t *params);
+qboolean	trap_G2API_IKMove(void *ghoul2, int time, sharedIKMoveParams_t *params);
+
+//for removing bones so they no longer have their own seperate animation hierarchy. Or whatever reason you may have. -rww
+qboolean	trap_G2API_RemoveBone(void *ghoul2, const char *boneName, int modelIndex);
+
+void		trap_G2API_AttachInstanceToEntNum(void *ghoul2, int entityNum, qboolean server);
+void		trap_G2API_ClearAttachedInstance(int entityNum);
+void		trap_G2API_CleanEntAttachments(void);
+qboolean	trap_G2API_OverrideServer(void *serverInstance);
+
+#include "../namespace_end.h"
+
+/*
+Ghoul2 Insert End
+*/
+
+//
+// g_combat.c
+//
+qboolean CanDamage (gentity_t *targ, vec3_t origin);
+void G_Damage (gentity_t *targ, gentity_t *inflictor, gentity_t *attacker, vec3_t dir, vec3_t point, int damage, int dflags, int mod);
+qboolean G_RadiusDamage (vec3_t origin, gentity_t *attacker, float damage, float radius, gentity_t *ignore, gentity_t *missile, int mod);
+void body_die( gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int meansOfDeath );
+void TossClientWeapon(gentity_t *self, vec3_t direction, float speed);
+void TossClientItems( gentity_t *self );
+void TossClientCubes( gentity_t *self );
+void ExplodeDeath( gentity_t *self );
+void G_CheckForDismemberment(gentity_t *ent, gentity_t *enemy, vec3_t point, int damage, int deathAnim, qboolean postDeath);
+extern int gGAvoidDismember;
+
+
+// damage flags
+#define DAMAGE_NORMAL				0x00000000	// No flags set.
+#define DAMAGE_RADIUS				0x00000001	// damage was indirect
+#define DAMAGE_NO_ARMOR				0x00000002	// armour does not protect from this damage
+#define DAMAGE_NO_KNOCKBACK			0x00000004	// do not affect velocity, just view angles
+#define DAMAGE_NO_PROTECTION		0x00000008  // armor, shields, invulnerability, and godmode have no effect
+#define DAMAGE_NO_TEAM_PROTECTION	0x00000010  // armor, shields, invulnerability, and godmode have no effect
+//JK2 flags
+#define DAMAGE_EXTRA_KNOCKBACK		0x00000040	// add extra knockback to this damage
+#define DAMAGE_DEATH_KNOCKBACK		0x00000080	// only does knockback on death of target
+#define DAMAGE_IGNORE_TEAM			0x00000100	// damage is always done, regardless of teams
+#define DAMAGE_NO_DAMAGE			0x00000200	// do no actual damage but react as if damage was taken
+#define DAMAGE_HALF_ABSORB			0x00000400	// half shields, half health
+#define DAMAGE_HALF_ARMOR_REDUCTION	0x00000800	// This damage doesn't whittle down armor as efficiently.
+#define DAMAGE_HEAVY_WEAP_CLASS		0x00001000	// Heavy damage
+#define DAMAGE_NO_HIT_LOC			0x00002000	// No hit location
+#define DAMAGE_NO_SELF_PROTECTION	0x00004000	// Dont apply half damage to self attacks
+//
+// g_exphysics.c
+//
+void G_RunExPhys(gentity_t *ent, float gravity, float mass, float bounce, qboolean autoKill, int *g2Bolts, int numG2Bolts);
+
+//
+// g_missile.c
+//
+void G_ReflectMissile( gentity_t *ent, gentity_t *missile, vec3_t forward );
+
+void G_RunMissile( gentity_t *ent );
+
+gentity_t *CreateMissile( vec3_t org, vec3_t dir, float vel, int life, 
+							gentity_t *owner, qboolean altFire);
+void G_BounceProjectile( vec3_t start, vec3_t impact, vec3_t dir, vec3_t endout );
+void G_ExplodeMissile( gentity_t *ent );
+
+void WP_FireBlasterMissile( gentity_t *ent, vec3_t start, vec3_t dir, qboolean altFire );
+
+
+//
+// g_mover.c
+//
+extern int	BMS_START;
+extern int	BMS_MID;
+extern int	BMS_END;
+
+#define SPF_BUTTON_USABLE		1
+#define SPF_BUTTON_FPUSHABLE	2
+void G_PlayDoorLoopSound( gentity_t *ent );
+void G_PlayDoorSound( gentity_t *ent, int type );
+void G_RunMover( gentity_t *ent );
+void Touch_DoorTrigger( gentity_t *ent, gentity_t *other, trace_t *trace );
+
+//
+// g_trigger.c
+//
+void trigger_teleporter_touch (gentity_t *self, gentity_t *other, trace_t *trace );
+
+
+//
+// g_misc.c
+//
+#define MAX_REFNAME	32
+#define	START_TIME_LINK_ENTS		FRAMETIME*1
+
+#define	RTF_NONE	0
+#define	RTF_NAVGOAL	0x00000001
+
+typedef struct reference_tag_s
+{
+	char		name[MAX_REFNAME];
+	vec3_t		origin;
+	vec3_t		angles;
+	int			flags;	//Just in case
+	int			radius;	//For nav goals
+	qboolean	inuse;
+} reference_tag_t;
+
+void TAG_Init( void );
+reference_tag_t	*TAG_Find( const char *owner, const char *name );
+reference_tag_t	*TAG_Add( const char *name, const char *owner, vec3_t origin, vec3_t angles, int radius, int flags );
+int	TAG_GetOrigin( const char *owner, const char *name, vec3_t origin );
+int	TAG_GetOrigin2( const char *owner, const char *name, vec3_t origin );
+int	TAG_GetAngles( const char *owner, const char *name, vec3_t angles );
+int TAG_GetRadius( const char *owner, const char *name );
+int TAG_GetFlags( const char *owner, const char *name );
+
+void TeleportPlayer( gentity_t *player, vec3_t origin, vec3_t angles );
+
+//
+// g_weapon.c
+//
+void WP_FireTurretMissile( gentity_t *ent, vec3_t start, vec3_t dir, qboolean altFire, int damage, int velocity, int mod, gentity_t *ignore );
+void WP_FireGenericBlasterMissile( gentity_t *ent, vec3_t start, vec3_t dir, qboolean altFire, int damage, int velocity, int mod );
+qboolean LogAccuracyHit( gentity_t *target, gentity_t *attacker );
+void CalcMuzzlePoint ( gentity_t *ent, vec3_t forward, vec3_t right, vec3_t up, vec3_t muzzlePoint );
+void SnapVectorTowards( vec3_t v, vec3_t to );
+qboolean CheckGauntletAttack( gentity_t *ent );
+
+
+//
+// g_client.c
+//
+team_t TeamCount( int ignoreClientNum, int team );
+int TeamLeader( int team );
+team_t PickTeam( int ignoreClientNum );
+void SetClientViewAngle( gentity_t *ent, vec3_t angle );
+gentity_t *SelectSpawnPoint ( vec3_t avoidPoint, vec3_t origin, vec3_t angles );
+void MaintainBodyQueue(gentity_t *ent);
+void respawn (gentity_t *ent);
+void BeginIntermission (void);
+void InitBodyQue (void);
+void ClientSpawn( gentity_t *ent );
+void player_die (gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int mod);
+void AddScore( gentity_t *ent, vec3_t origin, int score );
+void CalculateRanks( void );
+qboolean SpotWouldTelefrag( gentity_t *spot );
+
+extern gentity_t *gJMSaberEnt;
+
+//
+// g_svcmds.c
+//
+qboolean	ConsoleCommand( void );
+void G_ProcessIPBans(void);
+qboolean G_FilterPacket (char *from);
+
+//
+// g_weapon.c
+//
+void FireWeapon( gentity_t *ent, qboolean altFire );
+void BlowDetpacks(gentity_t *ent);
+
+//
+// p_hud.c
+//
+void MoveClientToIntermission (gentity_t *client);
+void G_SetStats (gentity_t *ent);
+void DeathmatchScoreboardMessage (gentity_t *client);
+
+//
+// g_cmds.c
+//
+
+//
+// g_pweapon.c
+//
+
+
+//
+// g_main.c
+//
+extern vmCvar_t g_ff_objectives;
+extern qboolean gDoSlowMoDuel;
+extern int gSlowMoDuelTime;
+
+void G_PowerDuelCount(int *loners, int *doubles, qboolean countSpec);
+
+void FindIntermissionPoint( void );
+void SetLeader(int team, int client);
+void CheckTeamLeader( int team );
+void G_RunThink (gentity_t *ent);
+void QDECL G_LogPrintf( const char *fmt, ... );
+void SendScoreboardMessageToAllClients( void );
+void QDECL G_Printf( const char *fmt, ... );
+void QDECL G_Error( const char *fmt, ... );
+const char *G_GetStringEdString(char *refSection, char *refName);
+
+//
+// g_client.c
+//
+char *ClientConnect( int clientNum, qboolean firstTime, qboolean isBot );
+void ClientUserinfoChanged( int clientNum );
+void ClientDisconnect( int clientNum );
+void ClientBegin( int clientNum, qboolean allowTeamReset );
+void G_BreakArm(gentity_t *ent, int arm);
+void G_UpdateClientAnims(gentity_t *self, float animSpeedScale);
+void ClientCommand( int clientNum );
+
+//
+// g_active.c
+//
+void G_CheckClientTimeouts	( gentity_t *ent );
+void ClientThink			( int clientNum, usercmd_t *ucmd );
+void ClientEndFrame			( gentity_t *ent );
+void G_RunClient			( gentity_t *ent );
+
+//
+// g_team.c
+//
+qboolean OnSameTeam( gentity_t *ent1, gentity_t *ent2 );
+void Team_CheckDroppedItem( gentity_t *dropped );
+
+//
+// g_mem.c
+//
+void *G_Alloc( int size );
+void G_InitMemory( void );
+void Svcmd_GameMem_f( void );
+
+//
+// g_session.c
+//
+void G_ReadSessionData( gclient_t *client );
+void G_InitSessionData( gclient_t *client, char *userinfo, qboolean isBot );
+
+void G_InitWorldSession( void );
+void G_WriteSessionData( void );
+
+//
+// NPC_senses.cpp
+//
+extern void AddSightEvent( gentity_t *owner, vec3_t position, float radius, alertEventLevel_e alertLevel, float addLight ); //addLight = 0.0f
+extern void AddSoundEvent( gentity_t *owner, vec3_t position, float radius, alertEventLevel_e alertLevel, qboolean needLOS ); //needLOS = qfalse
+extern qboolean G_CheckForDanger( gentity_t *self, int alertEvent );
+extern int G_CheckAlertEvents( gentity_t *self, qboolean checkSight, qboolean checkSound, float maxSeeDist, float maxHearDist, int ignoreAlert, qboolean mustHaveOwner, int minAlertLevel ); //ignoreAlert = -1, mustHaveOwner = qfalse, minAlertLevel = AEL_MINOR
+extern qboolean G_CheckForDanger( gentity_t *self, int alertEvent );
+extern qboolean G_ClearLOS( gentity_t *self, const vec3_t start, const vec3_t end );
+extern qboolean G_ClearLOS2( gentity_t *self, gentity_t *ent, const vec3_t end );
+extern qboolean G_ClearLOS3( gentity_t *self, const vec3_t start, gentity_t *ent );
+extern qboolean G_ClearLOS4( gentity_t *self, gentity_t *ent );
+extern qboolean G_ClearLOS5( gentity_t *self, const vec3_t end );
+
+//
+// g_arenas.c
+//
+void UpdateTournamentInfo( void );
+//void SpawnModelsOnVictoryPads( void );
+//void Svcmd_AbortPodium_f( void );
+
+//
+// g_bot.c
+//
+void G_InitBots( qboolean restart );
+char *G_GetBotInfoByNumber( int num );
+char *G_GetBotInfoByName( const char *name );
+void G_CheckBotSpawn( void );
+void G_RemoveQueuedBotBegin( int clientNum );
+qboolean G_BotConnect( int clientNum, qboolean restart );
+void Svcmd_AddBot_f( void );
+void Svcmd_BotList_f( void );
+void BotInterbreedEndMatch( void );
+qboolean G_DoesMapSupportGametype(const char *mapname, int gametype);
+const char *G_RefreshNextMap(int gametype, qboolean forced);
+
+// w_force.c / w_saber.c
+gentity_t *G_PreDefSound(vec3_t org, int pdSound);
+qboolean HasSetSaberOnly(void);
+void WP_ForcePowerStop( gentity_t *self, forcePowers_t forcePower );
+void WP_SaberPositionUpdate( gentity_t *self, usercmd_t *ucmd );
+int WP_SaberCanBlock(gentity_t *self, vec3_t point, int dflags, int mod, qboolean projectile, int attackStr);
+void WP_SaberInitBladeData( gentity_t *ent );
+void WP_InitForcePowers( gentity_t *ent );
+void WP_SpawnInitForcePowers( gentity_t *ent );
+void WP_ForcePowersUpdate( gentity_t *self, usercmd_t *ucmd );
+int ForcePowerUsableOn(gentity_t *attacker, gentity_t *other, forcePowers_t forcePower);
+void ForceHeal( gentity_t *self );
+void ForceSpeed( gentity_t *self, int forceDuration );
+void ForceRage( gentity_t *self );
+void ForceGrip( gentity_t *self );
+void ForceProtect( gentity_t *self );
+void ForceAbsorb( gentity_t *self );
+void ForceTeamHeal( gentity_t *self );
+void ForceTeamForceReplenish( gentity_t *self );
+void ForceSeeing( gentity_t *self );
+void ForceThrow( gentity_t *self, qboolean pull );
+void ForceTelepathy(gentity_t *self);
+qboolean Jedi_DodgeEvasion( gentity_t *self, gentity_t *shooter, trace_t *tr, int hitLoc );
+
+// g_log.c
+void QDECL G_LogPrintf( const char *fmt, ... );
+void QDECL G_LogWeaponPickup(int client, int weaponid);
+void QDECL G_LogWeaponFire(int client, int weaponid);
+void QDECL G_LogWeaponDamage(int client, int mod, int amount);
+void QDECL G_LogWeaponKill(int client, int mod);
+void QDECL G_LogWeaponDeath(int client, int weaponid);
+void QDECL G_LogWeaponFrag(int attacker, int deadguy);
+void QDECL G_LogWeaponPowerup(int client, int powerupid);
+void QDECL G_LogWeaponItem(int client, int itemid);
+void QDECL G_LogWeaponInit(void);
+void QDECL G_LogWeaponOutput(void);
+void QDECL G_LogExit( const char *string );
+void QDECL G_ClearClientLog(int client);
+
+// g_siege.c
+void InitSiegeMode(void);
+void G_SiegeClientExData(gentity_t *msgTarg);
+
+// g_timer
+//Timing information
+void		TIMER_Clear( void );
+void		TIMER_Clear2( gentity_t *ent );
+void		TIMER_Set( gentity_t *ent, const char *identifier, int duration );
+int			TIMER_Get( gentity_t *ent, const char *identifier );
+qboolean	TIMER_Done( gentity_t *ent, const char *identifier );
+qboolean	TIMER_Start( gentity_t *self, const char *identifier, int duration );
+qboolean	TIMER_Done2( gentity_t *ent, const char *identifier, qboolean remove );
+qboolean	TIMER_Exists( gentity_t *ent, const char *identifier );
+void		TIMER_Remove( gentity_t *ent, const char *identifier );
+
+float NPC_GetHFOVPercentage( vec3_t spot, vec3_t from, vec3_t facing, float hFOV );
+float NPC_GetVFOVPercentage( vec3_t spot, vec3_t from, vec3_t facing, float vFOV );
+
+
+extern void G_SetEnemy (gentity_t *self, gentity_t *enemy);
+qboolean InFront( vec3_t spot, vec3_t from, vec3_t fromAngles, float threshHold );
+
+// ai_main.c
+#define MAX_FILEPATH			144
+
+int		OrgVisible		( vec3_t org1, vec3_t org2, int ignore);
+void	BotOrder		( gentity_t *ent, int clientnum, int ordernum);
+int		InFieldOfVision	( vec3_t viewangles, float fov, vec3_t angles);
+
+// ai_util.c
+void B_InitAlloc(void);
+void B_CleanupAlloc(void);
+
+//bot settings
+typedef struct bot_settings_s
+{
+	char personalityfile[MAX_FILEPATH];
+	float skill;
+	char team[MAX_FILEPATH];
+} bot_settings_t;
+
+int BotAISetup( int restart );
+int BotAIShutdown( int restart );
+int BotAILoadMap( int restart );
+int BotAISetupClient(int client, struct bot_settings_s *settings, qboolean restart);
+int BotAIShutdownClient( int client, qboolean restart );
+int BotAIStartFrame( int time );
+
+#include "g_team.h" // teamplay specific stuff
+
+
+extern	level_locals_t	level;
+extern	gentity_t		g_entities[MAX_GENTITIES];
+
+#define	FOFS(x) ((int)&(((gentity_t *)0)->x))
+
+extern	vmCvar_t	g_gametype;
+extern	vmCvar_t	g_dedicated;
+extern	vmCvar_t	g_developer;
+extern	vmCvar_t	g_cheats;
+extern	vmCvar_t	g_maxclients;			// allow this many total, including spectators
+extern	vmCvar_t	g_maxGameClients;		// allow this many active
+extern	vmCvar_t	g_restarted;
+
+extern	vmCvar_t	g_trueJedi;
+
+extern	vmCvar_t	g_autoMapCycle;
+extern	vmCvar_t	g_dmflags;
+extern	vmCvar_t	g_maxForceRank;
+extern	vmCvar_t	g_forceBasedTeams;
+extern	vmCvar_t	g_privateDuel;
+
+extern	vmCvar_t	g_allowNPC;
+
+extern	vmCvar_t	g_armBreakage;
+
+extern	vmCvar_t	g_saberLocking;
+extern	vmCvar_t	g_saberLockFactor;
+extern	vmCvar_t	g_saberTraceSaberFirst;
+
+extern	vmCvar_t	d_saberKickTweak;
+
+extern	vmCvar_t	d_powerDuelPrint;
+
+extern	vmCvar_t	d_saberGhoul2Collision;
+extern	vmCvar_t	g_saberBladeFaces;
+extern	vmCvar_t	d_saberAlwaysBoxTrace;
+extern	vmCvar_t	d_saberBoxTraceSize;
+
+extern	vmCvar_t	d_siegeSeekerNPC;
+
+extern	vmCvar_t	g_debugMelee;
+extern	vmCvar_t	g_stepSlideFix;
+
+extern	vmCvar_t	g_noSpecMove;
+
+#ifdef _DEBUG
+extern	vmCvar_t	g_disableServerG2;
+#endif
+
+extern	vmCvar_t	d_perPlayerGhoul2;
+
+extern	vmCvar_t	d_projectileGhoul2Collision;
+
+extern	vmCvar_t	g_g2TraceLod;
+
+extern	vmCvar_t	g_locationBasedDamage;
+
+extern	vmCvar_t	g_allowHighPingDuelist;
+
+extern	vmCvar_t	g_logClientInfo;
+
+extern	vmCvar_t	g_slowmoDuelEnd;
+
+extern	vmCvar_t	g_saberDamageScale;
+
+extern	vmCvar_t	g_useWhileThrowing;
+
+extern	vmCvar_t	g_RMG;
+
+extern	vmCvar_t	g_svfps;
+
+extern	vmCvar_t	g_forceRegenTime;
+extern	vmCvar_t	g_spawnInvulnerability;
+extern	vmCvar_t	g_forcePowerDisable;
+extern	vmCvar_t	g_weaponDisable;
+
+extern	vmCvar_t	g_allowDuelSuicide;
+extern	vmCvar_t	g_fraglimitVoteCorrection;
+
+extern	vmCvar_t	g_duelWeaponDisable;
+extern	vmCvar_t	g_fraglimit;
+extern	vmCvar_t	g_duel_fraglimit;
+extern	vmCvar_t	g_timelimit;
+extern	vmCvar_t	g_capturelimit;
+extern	vmCvar_t	d_saberInterpolate;
+extern	vmCvar_t	g_friendlyFire;
+extern	vmCvar_t	g_friendlySaber;
+extern	vmCvar_t	g_password;
+extern	vmCvar_t	g_needpass;
+extern	vmCvar_t	g_gravity;
+extern	vmCvar_t	g_speed;
+extern	vmCvar_t	g_knockback;
+extern	vmCvar_t	g_quadfactor;
+extern	vmCvar_t	g_forcerespawn;
+extern	vmCvar_t	g_siegeRespawn;
+extern	vmCvar_t	g_inactivity;
+extern	vmCvar_t	g_debugMove;
+extern	vmCvar_t	g_debugAlloc;
+#ifndef FINAL_BUILD
+extern	vmCvar_t	g_debugDamage;
+#endif
+extern	vmCvar_t	g_debugServerSkel;
+extern	vmCvar_t	g_weaponRespawn;
+extern	vmCvar_t	g_weaponTeamRespawn;
+extern	vmCvar_t	g_adaptRespawn;
+extern	vmCvar_t	g_synchronousClients;
+extern	vmCvar_t	g_motd;
+extern	vmCvar_t	g_warmup;
+extern	vmCvar_t	g_doWarmup;
+extern	vmCvar_t	g_blood;
+extern	vmCvar_t	g_allowVote;
+extern	vmCvar_t	g_teamAutoJoin;
+extern	vmCvar_t	g_teamForceBalance;
+extern	vmCvar_t	g_banIPs;
+extern	vmCvar_t	g_filterBan;
+extern	vmCvar_t	g_debugForward;
+extern	vmCvar_t	g_debugRight;
+extern	vmCvar_t	g_debugUp;
+extern	vmCvar_t	g_redteam;
+extern	vmCvar_t	g_blueteam;
+extern	vmCvar_t	g_smoothClients;
+
+#include "../namespace_begin.h"
+extern	vmCvar_t	pmove_fixed;
+extern	vmCvar_t	pmove_msec;
+#include "../namespace_end.h"
+
+extern	vmCvar_t	g_rankings;
+extern	vmCvar_t	g_enableDust;
+extern	vmCvar_t	g_enableBreath;
+extern	vmCvar_t	g_singlePlayer;
+extern	vmCvar_t	g_dismember;
+extern	vmCvar_t	g_forceDodge;
+extern	vmCvar_t	g_timeouttospec;
+
+extern	vmCvar_t	g_saberDmgVelocityScale;
+extern	vmCvar_t	g_saberDmgDelay_Idle;
+extern	vmCvar_t	g_saberDmgDelay_Wound;
+
+#ifndef FINAL_BUILD
+extern	vmCvar_t	g_saberDebugPrint;
+#endif
+
+extern	vmCvar_t	g_siegeTeamSwitch;
+
+extern	vmCvar_t	bg_fighterAltControl;
+
+#ifdef DEBUG_SABER_BOX
+extern	vmCvar_t	g_saberDebugBox;
+#endif
+
+//NPC nav debug
+extern vmCvar_t		d_altRoutes;
+extern vmCvar_t		d_patched;
+extern	vmCvar_t	d_noIntermissionWait;
+
+extern	vmCvar_t	g_siegeTeam1;
+extern	vmCvar_t	g_siegeTeam2;
+
+extern	vmCvar_t	g_austrian;
+
+extern	vmCvar_t	g_powerDuelStartHealth;
+extern	vmCvar_t	g_powerDuelEndHealth;
+
+extern vmCvar_t		g_showDuelHealths;
+
+#include "../namespace_begin.h"
+
+void	trap_Printf( const char *fmt );
+void	trap_Error( const char *fmt );
+int		trap_Milliseconds( void );
+void	trap_PrecisionTimer_Start(void **theNewTimer);
+int		trap_PrecisionTimer_End(void *theTimer);
+int		trap_Argc( void );
+void	trap_Argv( int n, char *buffer, int bufferLength );
+void	trap_Args( char *buffer, int bufferLength );
+int		trap_FS_FOpenFile( const char *qpath, fileHandle_t *f, fsMode_t mode );
+void	trap_FS_Read( void *buffer, int len, fileHandle_t f );
+void	trap_FS_Write( const void *buffer, int len, fileHandle_t f );
+void	trap_FS_FCloseFile( fileHandle_t f );
+int		trap_FS_GetFileList( const char *path, const char *extension, char *listbuf, int bufsize );
+void	trap_SendConsoleCommand( int exec_when, const char *text );
+void	trap_Cvar_Register( vmCvar_t *cvar, const char *var_name, const char *value, int flags );
+void	trap_Cvar_Update( vmCvar_t *cvar );
+void	trap_Cvar_Set( const char *var_name, const char *value );
+int		trap_Cvar_VariableIntegerValue( const char *var_name );
+float	trap_Cvar_VariableValue( const char *var_name );
+void	trap_Cvar_VariableStringBuffer( const char *var_name, char *buffer, int bufsize );
+void	trap_LocateGameData( gentity_t *gEnts, int numGEntities, int sizeofGEntity_t, playerState_t *gameClients, int sizeofGameClient );
+void	trap_DropClient( int clientNum, const char *reason );
+void	trap_SendServerCommand( int clientNum, const char *text );
+void	trap_SetConfigstring( int num, const char *string );
+void	trap_GetConfigstring( int num, char *buffer, int bufferSize );
+void	trap_GetUserinfo( int num, char *buffer, int bufferSize );
+void	trap_SetUserinfo( int num, const char *buffer );
+void	trap_GetServerinfo( char *buffer, int bufferSize );
+void	trap_SetServerCull(float cullDistance);
+void	trap_SetBrushModel( gentity_t *ent, const char *name );
+void	trap_Trace( trace_t *results, const vec3_t start, const vec3_t mins, const vec3_t maxs, const vec3_t end, int passEntityNum, int contentmask );
+void	trap_G2Trace( trace_t *results, const vec3_t start, const vec3_t mins, const vec3_t maxs, const vec3_t end, int passEntityNum, int contentmask, int g2TraceType, int traceLod );
+int		trap_PointContents( const vec3_t point, int passEntityNum );
+qboolean trap_InPVS( const vec3_t p1, const vec3_t p2 );
+qboolean trap_InPVSIgnorePortals( const vec3_t p1, const vec3_t p2 );
+void	trap_AdjustAreaPortalState( gentity_t *ent, qboolean open );
+qboolean trap_AreasConnected( int area1, int area2 );
+void	trap_LinkEntity( gentity_t *ent );
+void	trap_UnlinkEntity( gentity_t *ent );
+int		trap_EntitiesInBox( const vec3_t mins, const vec3_t maxs, int *entityList, int maxcount );
+qboolean trap_EntityContact( const vec3_t mins, const vec3_t maxs, const gentity_t *ent );
+int		trap_BotAllocateClient( void );
+void	trap_BotFreeClient( int clientNum );
+void	trap_GetUsercmd( int clientNum, usercmd_t *cmd );
+qboolean	trap_GetEntityToken( char *buffer, int bufferSize );
+
+//adding giant gamebreaking features post-alpha is fun!
+void	trap_SiegePersSet(siegePers_t *pers);
+void	trap_SiegePersGet(siegePers_t *pers);
+
+#ifdef BOT_ZMALLOC
+void	*trap_BotGetMemoryGame(int size);
+void	trap_BotFreeMemoryGame(void *ptr);
+#endif
+
+int		trap_DebugPolygonCreate(int color, int numPoints, vec3_t *points);
+void	trap_DebugPolygonDelete(int id);
+
+int		trap_BotLibSetup( void );
+int		trap_BotLibShutdown( void );
+int		trap_BotLibVarSet(char *var_name, char *value);
+int		trap_BotLibVarGet(char *var_name, char *value, int size);
+int		trap_BotLibDefine(char *string);
+int		trap_BotLibStartFrame(float time);
+int		trap_BotLibLoadMap(const char *mapname);
+int		trap_BotLibUpdateEntity(int ent, void /* struct bot_updateentity_s */ *bue);
+int		trap_BotLibTest(int parm0, char *parm1, vec3_t parm2, vec3_t parm3);
+
+int		trap_BotGetSnapshotEntity( int clientNum, int sequence );
+int		trap_BotGetServerCommand(int clientNum, char *message, int size);
+void	trap_BotUserCommand(int client, usercmd_t *ucmd);
+
+int		trap_AAS_BBoxAreas(vec3_t absmins, vec3_t absmaxs, int *areas, int maxareas);
+int		trap_AAS_AreaInfo( int areanum, void /* struct aas_areainfo_s */ *info );
+void	trap_AAS_EntityInfo(int entnum, void /* struct aas_entityinfo_s */ *info);
+
+int		trap_AAS_Initialized(void);
+void	trap_AAS_PresenceTypeBoundingBox(int presencetype, vec3_t mins, vec3_t maxs);
+float	trap_AAS_Time(void);
+
+int		trap_AAS_PointAreaNum(vec3_t point);
+int		trap_AAS_PointReachabilityAreaIndex(vec3_t point);
+int		trap_AAS_TraceAreas(vec3_t start, vec3_t end, int *areas, vec3_t *points, int maxareas);
+
+int		trap_AAS_PointContents(vec3_t point);
+int		trap_AAS_NextBSPEntity(int ent);
+int		trap_AAS_ValueForBSPEpairKey(int ent, char *key, char *value, int size);
+int		trap_AAS_VectorForBSPEpairKey(int ent, char *key, vec3_t v);
+int		trap_AAS_FloatForBSPEpairKey(int ent, char *key, float *value);
+int		trap_AAS_IntForBSPEpairKey(int ent, char *key, int *value);
+
+int		trap_AAS_AreaReachability(int areanum);
+
+int		trap_AAS_AreaTravelTimeToGoalArea(int areanum, vec3_t origin, int goalareanum, int travelflags);
+int		trap_AAS_EnableRoutingArea( int areanum, int enable );
+int		trap_AAS_PredictRoute(void /*struct aas_predictroute_s*/ *route, int areanum, vec3_t origin,
+							int goalareanum, int travelflags, int maxareas, int maxtime,
+							int stopevent, int stopcontents, int stoptfl, int stopareanum);
+
+int		trap_AAS_AlternativeRouteGoals(vec3_t start, int startareanum, vec3_t goal, int goalareanum, int travelflags,
+										void /*struct aas_altroutegoal_s*/ *altroutegoals, int maxaltroutegoals,
+										int type);
+int		trap_AAS_Swimming(vec3_t origin);
+int		trap_AAS_PredictClientMovement(void /* aas_clientmove_s */ *move, int entnum, vec3_t origin, int presencetype, int onground, vec3_t velocity, vec3_t cmdmove, int cmdframes, int maxframes, float frametime, int stopevent, int stopareanum, int visualize);
+
+
+void	trap_EA_Say(int client, char *str);
+void	trap_EA_SayTeam(int client, char *str);
+void	trap_EA_Command(int client, char *command);
+
+void	trap_EA_Action(int client, int action);
+void	trap_EA_Gesture(int client);
+void	trap_EA_Talk(int client);
+void	trap_EA_Attack(int client);
+void	trap_EA_Use(int client);
+void	trap_EA_Respawn(int client);
+void	trap_EA_Crouch(int client);
+void	trap_EA_MoveUp(int client);
+void	trap_EA_MoveDown(int client);
+void	trap_EA_MoveForward(int client);
+void	trap_EA_MoveBack(int client);
+void	trap_EA_MoveLeft(int client);
+void	trap_EA_MoveRight(int client);
+void	trap_EA_SelectWeapon(int client, int weapon);
+void	trap_EA_Jump(int client);
+void	trap_EA_DelayedJump(int client);
+void	trap_EA_Move(int client, vec3_t dir, float speed);
+void	trap_EA_View(int client, vec3_t viewangles);
+void	trap_EA_Alt_Attack(int client);
+void	trap_EA_ForcePower(int client);
+
+void	trap_EA_EndRegular(int client, float thinktime);
+void	trap_EA_GetInput(int client, float thinktime, void /* struct bot_input_s */ *input);
+void	trap_EA_ResetInput(int client);
+
+
+int		trap_BotLoadCharacter(char *charfile, float skill);
+void	trap_BotFreeCharacter(int character);
+float	trap_Characteristic_Float(int character, int index);
+float	trap_Characteristic_BFloat(int character, int index, float min, float max);
+int		trap_Characteristic_Integer(int character, int index);
+int		trap_Characteristic_BInteger(int character, int index, int min, int max);
+void	trap_Characteristic_String(int character, int index, char *buf, int size);
+
+int		trap_BotAllocChatState(void);
+void	trap_BotFreeChatState(int handle);
+void	trap_BotQueueConsoleMessage(int chatstate, int type, char *message);
+void	trap_BotRemoveConsoleMessage(int chatstate, int handle);
+int		trap_BotNextConsoleMessage(int chatstate, void /* struct bot_consolemessage_s */ *cm);
+int		trap_BotNumConsoleMessages(int chatstate);
+void	trap_BotInitialChat(int chatstate, char *type, int mcontext, char *var0, char *var1, char *var2, char *var3, char *var4, char *var5, char *var6, char *var7 );
+int		trap_BotNumInitialChats(int chatstate, char *type);
+int		trap_BotReplyChat(int chatstate, char *message, int mcontext, int vcontext, char *var0, char *var1, char *var2, char *var3, char *var4, char *var5, char *var6, char *var7 );
+int		trap_BotChatLength(int chatstate);
+void	trap_BotEnterChat(int chatstate, int client, int sendto);
+void	trap_BotGetChatMessage(int chatstate, char *buf, int size);
+int		trap_StringContains(char *str1, char *str2, int casesensitive);
+int		trap_BotFindMatch(char *str, void /* struct bot_match_s */ *match, unsigned long int context);
+void	trap_BotMatchVariable(void /* struct bot_match_s */ *match, int variable, char *buf, int size);
+void	trap_UnifyWhiteSpaces(char *string);
+void	trap_BotReplaceSynonyms(char *string, unsigned long int context);
+int		trap_BotLoadChatFile(int chatstate, char *chatfile, char *chatname);
+void	trap_BotSetChatGender(int chatstate, int gender);
+void	trap_BotSetChatName(int chatstate, char *name, int client);
+void	trap_BotResetGoalState(int goalstate);
+void	trap_BotRemoveFromAvoidGoals(int goalstate, int number);
+void	trap_BotResetAvoidGoals(int goalstate);
+void	trap_BotPushGoal(int goalstate, void /* struct bot_goal_s */ *goal);
+void	trap_BotPopGoal(int goalstate);
+void	trap_BotEmptyGoalStack(int goalstate);
+void	trap_BotDumpAvoidGoals(int goalstate);
+void	trap_BotDumpGoalStack(int goalstate);
+void	trap_BotGoalName(int number, char *name, int size);
+int		trap_BotGetTopGoal(int goalstate, void /* struct bot_goal_s */ *goal);
+int		trap_BotGetSecondGoal(int goalstate, void /* struct bot_goal_s */ *goal);
+int		trap_BotChooseLTGItem(int goalstate, vec3_t origin, int *inventory, int travelflags);
+int		trap_BotChooseNBGItem(int goalstate, vec3_t origin, int *inventory, int travelflags, void /* struct bot_goal_s */ *ltg, float maxtime);
+int		trap_BotTouchingGoal(vec3_t origin, void /* struct bot_goal_s */ *goal);
+int		trap_BotItemGoalInVisButNotVisible(int viewer, vec3_t eye, vec3_t viewangles, void /* struct bot_goal_s */ *goal);
+int		trap_BotGetNextCampSpotGoal(int num, void /* struct bot_goal_s */ *goal);
+int		trap_BotGetMapLocationGoal(char *name, void /* struct bot_goal_s */ *goal);
+int		trap_BotGetLevelItemGoal(int index, char *classname, void /* struct bot_goal_s */ *goal);
+float	trap_BotAvoidGoalTime(int goalstate, int number);
+void	trap_BotSetAvoidGoalTime(int goalstate, int number, float avoidtime);
+void	trap_BotInitLevelItems(void);
+void	trap_BotUpdateEntityItems(void);
+int		trap_BotLoadItemWeights(int goalstate, char *filename);
+void	trap_BotFreeItemWeights(int goalstate);
+void	trap_BotInterbreedGoalFuzzyLogic(int parent1, int parent2, int child);
+void	trap_BotSaveGoalFuzzyLogic(int goalstate, char *filename);
+void	trap_BotMutateGoalFuzzyLogic(int goalstate, float range);
+int		trap_BotAllocGoalState(int state);
+void	trap_BotFreeGoalState(int handle);
+
+void	trap_BotResetMoveState(int movestate);
+void	trap_BotMoveToGoal(void /* struct bot_moveresult_s */ *result, int movestate, void /* struct bot_goal_s */ *goal, int travelflags);
+int		trap_BotMoveInDirection(int movestate, vec3_t dir, float speed, int type);
+void	trap_BotResetAvoidReach(int movestate);
+void	trap_BotResetLastAvoidReach(int movestate);
+int		trap_BotReachabilityArea(vec3_t origin, int testground);
+int		trap_BotMovementViewTarget(int movestate, void /* struct bot_goal_s */ *goal, int travelflags, float lookahead, vec3_t target);
+int		trap_BotPredictVisiblePosition(vec3_t origin, int areanum, void /* struct bot_goal_s */ *goal, int travelflags, vec3_t target);
+int		trap_BotAllocMoveState(void);
+void	trap_BotFreeMoveState(int handle);
+void	trap_BotInitMoveState(int handle, void /* struct bot_initmove_s */ *initmove);
+void	trap_BotAddAvoidSpot(int movestate, vec3_t origin, float radius, int type);
+
+int		trap_BotChooseBestFightWeapon(int weaponstate, int *inventory);
+void	trap_BotGetWeaponInfo(int weaponstate, int weapon, void /* struct weaponinfo_s */ *weaponinfo);
+int		trap_BotLoadWeaponWeights(int weaponstate, char *filename);
+int		trap_BotAllocWeaponState(void);
+void	trap_BotFreeWeaponState(int weaponstate);
+void	trap_BotResetWeaponState(int weaponstate);
+
+int		trap_GeneticParentsAndChildSelection(int numranks, float *ranks, int *parent1, int *parent2, int *child);
+
+void	trap_SnapVector( float *v );
+
+int trap_SP_GetStringTextString(const char *text, char *buffer, int bufferLength);
+
+qboolean	trap_ROFF_Clean( void );
+void		trap_ROFF_UpdateEntities( void );
+int			trap_ROFF_Cache( char *file );
+qboolean	trap_ROFF_Play( int entID, int roffID, qboolean doTranslation );
+qboolean	trap_ROFF_Purge_Ent( int entID );
+
+//rww - dynamic vm memory allocation!
+void		trap_TrueMalloc(void **ptr, int size);
+void		trap_TrueFree(void **ptr);
+
+//rww - icarus traps
+int			trap_ICARUS_RunScript( gentity_t *ent, const char *name );
+qboolean	trap_ICARUS_RegisterScript( const char *name, qboolean bCalledDuringInterrogate);
+
+void		trap_ICARUS_Init( void );
+qboolean	trap_ICARUS_ValidEnt( gentity_t *ent );
+qboolean	trap_ICARUS_IsInitialized( int entID );
+qboolean	trap_ICARUS_MaintainTaskManager( int entID );
+qboolean	trap_ICARUS_IsRunning( int entID );
+qboolean	trap_ICARUS_TaskIDPending(gentity_t *ent, int taskID);
+void		trap_ICARUS_InitEnt( gentity_t *ent );
+void		trap_ICARUS_FreeEnt( gentity_t *ent );
+void		trap_ICARUS_AssociateEnt( gentity_t *ent );
+void		trap_ICARUS_Shutdown( void );
+void		trap_ICARUS_TaskIDSet(gentity_t *ent, int taskType, int taskID);
+void		trap_ICARUS_TaskIDComplete(gentity_t *ent, int taskType);
+void		trap_ICARUS_SetVar(int taskID, int entID, const char *type_name, const char *data);
+int			trap_ICARUS_VariableDeclared(const char *type_name);
+int			trap_ICARUS_GetFloatVariable( const char *name, float *value );
+int			trap_ICARUS_GetStringVariable( const char *name, const char *value );
+int			trap_ICARUS_GetVectorVariable( const char *name, const vec3_t value );
+
+
+//rww - BEGIN NPC NAV TRAPS
+void		trap_Nav_Init( void );
+void		trap_Nav_Free( void );
+qboolean	trap_Nav_Load( const char *filename, int checksum );
+qboolean	trap_Nav_Save( const char *filename, int checksum );
+int			trap_Nav_AddRawPoint( vec3_t point, int flags, int radius );
+void		trap_Nav_CalculatePaths( qboolean recalc ); //recalc = qfalse
+void		trap_Nav_HardConnect( int first, int second );
+
+void		trap_Nav_ShowNodes( void );
+void		trap_Nav_ShowEdges( void );
+void		trap_Nav_ShowPath( int start, int end );
+int			trap_Nav_GetNearestNode( gentity_t *ent, int lastID, int flags, int targetID );
+int			trap_Nav_GetBestNode( int startID, int endID, int rejectID ); //rejectID = NODE_NONE
+int			trap_Nav_GetNodePosition( int nodeID, vec3_t out );
+int			trap_Nav_GetNodeNumEdges( int nodeID );
+int			trap_Nav_GetNodeEdge( int nodeID, int edge );
+int			trap_Nav_GetNumNodes( void );
+qboolean	trap_Nav_Connected( int startID, int endID );
+int			trap_Nav_GetPathCost( int startID, int endID );
+int			trap_Nav_GetEdgeCost( int startID, int endID );
+int			trap_Nav_GetProjectedNode( vec3_t origin, int nodeID );
+void		trap_Nav_CheckFailedNodes( gentity_t *ent );
+void		trap_Nav_AddFailedNode( gentity_t *ent, int nodeID );
+qboolean	trap_Nav_NodeFailed( gentity_t *ent, int nodeID );
+qboolean	trap_Nav_NodesAreNeighbors( int startID, int endID );
+void		trap_Nav_ClearFailedEdge( failedEdge_t	*failedEdge );
+void		trap_Nav_ClearAllFailedEdges( void );
+int			trap_Nav_EdgeFailed( int startID, int endID );
+void		trap_Nav_AddFailedEdge( int entID, int startID, int endID );
+qboolean	trap_Nav_CheckFailedEdge( failedEdge_t *failedEdge );
+void		trap_Nav_CheckAllFailedEdges( void );
+qboolean	trap_Nav_RouteBlocked( int startID, int testEdgeID, int endID, int rejectRank );
+int			trap_Nav_GetBestNodeAltRoute( int startID, int endID, int *pathCost, int rejectID ); //rejectID = NODE_NONE
+int			trap_Nav_GetBestNodeAltRoute2( int startID, int endID, int rejectID ); //rejectID = NODE_NONE
+int			trap_Nav_GetBestPathBetweenEnts( gentity_t *ent, gentity_t *goal, int flags );
+int			trap_Nav_GetNodeRadius( int nodeID );
+void		trap_Nav_CheckBlockedEdges( void );
+void		trap_Nav_ClearCheckedNodes( void );
+int			trap_Nav_CheckedNode(int wayPoint, int ent); //return int was byte
+void		trap_Nav_SetCheckedNode(int wayPoint, int ent, int value); //int value was byte value
+void		trap_Nav_FlagAllNodes( int newFlag );
+qboolean	trap_Nav_GetPathsCalculated(void);
+void		trap_Nav_SetPathsCalculated(qboolean newVal);
+//rww - END NPC NAV TRAPS
+
+void		trap_SV_RegisterSharedMemory(char *memory);
+
+void trap_SetActiveSubBSP(int index);
+int	trap_CM_RegisterTerrain(const char *config);
+void trap_RMG_Init(int terrainID);
+
+void trap_Bot_UpdateWaypoints(int wpnum, wpobject_t **wps);
+void trap_Bot_CalculatePaths(int rmg);
+
+#include "../namespace_end.h"
diff --git a/codemp/game/g_log.c b/codemp/game/g_log.c
new file mode 100644
index 0000000..9c29e21
--- /dev/null
+++ b/codemp/game/g_log.c
@@ -0,0 +1,1751 @@
+#include "g_local.h"
+
+#define LOGGING_WEAPONS	
+
+// Weapon statistic logging.
+// Nothing super-fancy here, I just want to keep track of, per player:
+//		--hom many times a weapon/item is picked up
+//		--how many times a weapon/item is used/fired
+//		--the total damage done by that weapon
+//		--the number of kills by that weapon
+//		--the number of deaths while holding that weapon
+//		--the time spent with each weapon
+//
+// Additionally,
+//		--how many times each powerup or item is picked up
+
+
+#ifdef LOGGING_WEAPONS
+int G_WeaponLogPickups[MAX_CLIENTS][WP_NUM_WEAPONS];
+int G_WeaponLogFired[MAX_CLIENTS][WP_NUM_WEAPONS];
+int G_WeaponLogDamage[MAX_CLIENTS][MOD_MAX];
+int G_WeaponLogKills[MAX_CLIENTS][MOD_MAX];
+int G_WeaponLogDeaths[MAX_CLIENTS][WP_NUM_WEAPONS];
+int G_WeaponLogFrags[MAX_CLIENTS][MAX_CLIENTS];
+int G_WeaponLogTime[MAX_CLIENTS][WP_NUM_WEAPONS];
+int G_WeaponLogLastTime[MAX_CLIENTS];
+qboolean G_WeaponLogClientTouch[MAX_CLIENTS];
+int G_WeaponLogPowerups[MAX_CLIENTS][HI_NUM_HOLDABLE];
+int	G_WeaponLogItems[MAX_CLIENTS][PW_NUM_POWERUPS];
+
+extern vmCvar_t	g_statLog;
+extern vmCvar_t	g_statLogFile;
+
+// MOD-weapon mapping array.
+int weaponFromMOD[MOD_MAX] =
+{
+	WP_NONE,				//MOD_UNKNOWN,
+	WP_STUN_BATON,			//MOD_STUN_BATON,
+	WP_MELEE,				//MOD_MELEE,
+	WP_SABER,				//MOD_SABER,
+	WP_BRYAR_PISTOL,		//MOD_BRYAR_PISTOL,
+	WP_BRYAR_PISTOL,		//MOD_BRYAR_PISTOL_ALT,
+	WP_BLASTER,				//MOD_BLASTER,
+	WP_TURRET,				//MOD_TURBLAST
+	WP_DISRUPTOR,			//MOD_DISRUPTOR,
+	WP_DISRUPTOR,			//MOD_DISRUPTOR_SPLASH,
+	WP_DISRUPTOR,			//MOD_DISRUPTOR_SNIPER,
+	WP_BOWCASTER,			//MOD_BOWCASTER,
+	WP_REPEATER,			//MOD_REPEATER,
+	WP_REPEATER,			//MOD_REPEATER_ALT,
+	WP_REPEATER,			//MOD_REPEATER_ALT_SPLASH,
+	WP_DEMP2,				//MOD_DEMP2,
+	WP_DEMP2,				//MOD_DEMP2_ALT,
+	WP_FLECHETTE,			//MOD_FLECHETTE,
+	WP_FLECHETTE,			//MOD_FLECHETTE_ALT_SPLASH,
+	WP_ROCKET_LAUNCHER,		//MOD_ROCKET,
+	WP_ROCKET_LAUNCHER,		//MOD_ROCKET_SPLASH,
+	WP_ROCKET_LAUNCHER,		//MOD_ROCKET_HOMING,
+	WP_ROCKET_LAUNCHER,		//MOD_ROCKET_HOMING_SPLASH,
+	WP_THERMAL,				//MOD_THERMAL,
+	WP_THERMAL,				//MOD_THERMAL_SPLASH,
+	WP_TRIP_MINE,			//MOD_TRIP_MINE_SPLASH,
+	WP_TRIP_MINE,			//MOD_TIMED_MINE_SPLASH,
+	WP_DET_PACK,			//MOD_DET_PACK_SPLASH,
+	WP_NONE,				//MOD_FORCE_DARK,
+	WP_NONE,				//MOD_SENTRY,
+	WP_NONE,				//MOD_WATER,
+	WP_NONE,				//MOD_SLIME,
+	WP_NONE,				//MOD_LAVA,
+	WP_NONE,				//MOD_CRUSH,
+	WP_NONE,				//MOD_TELEFRAG,
+	WP_NONE,				//MOD_FALLING,
+	WP_NONE,				//MOD_SUICIDE,
+	WP_NONE,				//MOD_TARGET_LASER,
+	WP_NONE,				//MOD_TRIGGER_HURT,
+};
+
+char *weaponNameFromIndex[WP_NUM_WEAPONS] = 
+{
+	"No Weapon",
+	"Stun Baton",				
+	"Saber",	
+	"Bryar Pistol",				
+	"Blaster",		
+	"Disruptor",				
+	"Bowcaster",	
+	"Repeater",	
+	"Demp2",
+	"Flechette",
+	"Rocket Launcher",
+	"Thermal",
+	"Tripmine",
+	"Detpack",
+	"Emplaced gun",
+	"Turret"
+};
+
+extern char	*modNames[];
+
+#endif //LOGGING_WEAPONS
+
+/*
+=================
+G_LogWeaponInit
+=================
+*/
+void G_LogWeaponInit(void) {
+#ifdef LOGGING_WEAPONS
+	memset(G_WeaponLogPickups, 0, sizeof(G_WeaponLogPickups));
+	memset(G_WeaponLogFired, 0, sizeof(G_WeaponLogFired));
+	memset(G_WeaponLogDamage, 0, sizeof(G_WeaponLogDamage));
+	memset(G_WeaponLogKills, 0, sizeof(G_WeaponLogKills));
+	memset(G_WeaponLogDeaths, 0, sizeof(G_WeaponLogDeaths));
+	memset(G_WeaponLogFrags, 0, sizeof(G_WeaponLogFrags));
+	memset(G_WeaponLogTime, 0, sizeof(G_WeaponLogTime));
+	memset(G_WeaponLogLastTime, 0, sizeof(G_WeaponLogLastTime));
+	memset(G_WeaponLogPowerups, 0, sizeof(G_WeaponLogPowerups));
+	memset(G_WeaponLogItems, 0, sizeof(G_WeaponLogItems));
+#endif //LOGGING_WEAPONS
+}
+
+void QDECL G_LogWeaponPickup(int client, int weaponid)
+{
+#ifdef LOGGING_WEAPONS
+	G_WeaponLogPickups[client][weaponid]++;
+	G_WeaponLogClientTouch[client] = qtrue;
+#endif //_LOGGING_WEAPONS
+}
+
+void QDECL G_LogWeaponFire(int client, int weaponid)
+{
+#ifdef LOGGING_WEAPONS
+	int dur;
+
+	G_WeaponLogFired[client][weaponid]++;
+	dur = level.time - G_WeaponLogLastTime[client];
+	if (dur > 5000)		// 5 second max.
+		G_WeaponLogTime[client][weaponid] += 5000;
+	else
+		G_WeaponLogTime[client][weaponid] += dur;
+	G_WeaponLogLastTime[client] = level.time;
+	G_WeaponLogClientTouch[client] = qtrue;
+#endif //_LOGGING_WEAPONS
+}
+
+void QDECL G_LogWeaponDamage(int client, int mod, int amount)
+{
+#ifdef LOGGING_WEAPONS
+	if (client>=MAX_CLIENTS)
+		return;
+	G_WeaponLogDamage[client][mod] += amount;
+	G_WeaponLogClientTouch[client] = qtrue;
+#endif //_LOGGING_WEAPONS
+}
+
+void QDECL G_LogWeaponKill(int client, int mod)
+{
+#ifdef LOGGING_WEAPONS
+	if (client>=MAX_CLIENTS)
+		return;
+	G_WeaponLogKills[client][mod]++;
+	G_WeaponLogClientTouch[client] = qtrue;
+#endif //_LOGGING_WEAPONS
+}
+
+void QDECL G_LogWeaponFrag(int attacker, int deadguy)
+{
+#ifdef LOGGING_WEAPONS
+	if ( (attacker>=MAX_CLIENTS) || (deadguy>=MAX_CLIENTS) )
+		return;
+	G_WeaponLogFrags[attacker][deadguy]++;
+	G_WeaponLogClientTouch[attacker] = qtrue;
+#endif //_LOGGING_WEAPONS
+}
+
+void QDECL G_LogWeaponDeath(int client, int weaponid)
+{
+#ifdef LOGGING_WEAPONS
+	if (client>=MAX_CLIENTS)
+		return;
+	G_WeaponLogDeaths[client][weaponid]++;
+	G_WeaponLogClientTouch[client] = qtrue;
+#endif //_LOGGING_WEAPONS
+}
+
+void QDECL G_LogWeaponPowerup(int client, int powerupid)
+{
+#ifdef LOGGING_WEAPONS
+	if (client>=MAX_CLIENTS)
+		return;
+	G_WeaponLogPowerups[client][powerupid]++;
+	G_WeaponLogClientTouch[client] = qtrue;
+#endif //_LOGGING_WEAPONS
+}
+
+void QDECL G_LogWeaponItem(int client, int itemid)
+{
+#ifdef LOGGING_WEAPONS
+	if (client>=MAX_CLIENTS)
+		return;
+	G_WeaponLogItems[client][itemid]++;
+	G_WeaponLogClientTouch[client] = qtrue;
+#endif //_LOGGING_WEAPONS
+}
+
+
+// Run through each player.  Print out:
+//	-- Most commonly picked up weapon.
+//  -- Weapon with which the most time was spent.
+//  -- Weapon that was most often died with.
+//  -- Damage type with which the most damage was done.
+//  -- Damage type with the most kills.
+//  -- Weapon with which the most damage was done.
+//	-- Weapon with which the most damage was done per shot.
+//
+// For the whole game, print out:
+//  -- Total pickups of each weapon.
+//  -- Total time spent with each weapon.
+//  -- Total damage done with each weapon.
+//  -- Total damage done for each damage type.
+//  -- Number of kills with each weapon.
+//  -- Number of kills for each damage type.
+//  -- Damage per shot with each weapon.
+//  -- Number of deaths with each weapon.
+
+void G_LogWeaponOutput(void)
+{
+#ifdef LOGGING_WEAPONS
+	int i,j,curwp;
+	float pershot;
+	fileHandle_t weaponfile;
+	char string[1024];
+
+	int totalpickups[WP_NUM_WEAPONS];
+	int totaltime[WP_NUM_WEAPONS];
+	int totaldeaths[WP_NUM_WEAPONS];
+	int totaldamageMOD[MOD_MAX];
+	int totalkillsMOD[MOD_MAX];
+	int totaldamage[WP_NUM_WEAPONS];
+	int totalkills[WP_NUM_WEAPONS];
+	int totalshots[WP_NUM_WEAPONS];
+	int percharacter[WP_NUM_WEAPONS];
+	char info[1024];
+	char mapname[128];
+	char *nameptr, *unknownname="<Unknown>";
+
+	if (!g_statLog.integer)
+	{
+		return;
+	}
+
+	G_LogPrintf("*****************************Weapon Log:\n" );
+
+	memset(totalpickups, 0, sizeof(totalpickups));
+	memset(totaltime, 0, sizeof(totaltime));
+	memset(totaldeaths, 0, sizeof(totaldeaths));
+	memset(totaldamageMOD, 0, sizeof(totaldamageMOD));
+	memset(totalkillsMOD, 0, sizeof(totalkillsMOD));
+	memset(totaldamage, 0, sizeof(totaldamage));
+	memset(totalkills, 0, sizeof(totalkills));
+	memset(totalshots, 0, sizeof(totalshots));
+
+	for (i=0; i<MAX_CLIENTS; i++)
+	{
+		if (G_WeaponLogClientTouch[i])
+		{	// Ignore any entity/clients we don't care about!
+			for (j=0;j<WP_NUM_WEAPONS;j++)
+			{
+				totalpickups[j] += G_WeaponLogPickups[i][j];
+				totaltime[j] += G_WeaponLogTime[i][j];
+				totaldeaths[j] += G_WeaponLogDeaths[i][j];
+				totalshots[j] += G_WeaponLogFired[i][j];
+			}
+
+			for (j=0;j<MOD_MAX;j++)
+			{
+				totaldamageMOD[j] += G_WeaponLogDamage[i][j];
+				totalkillsMOD[j] += G_WeaponLogKills[i][j];
+			}
+		}
+	}
+
+	// Now total the weapon data from the MOD data.
+	for (j=0; j<MOD_MAX; j++)
+	{
+		if (j <= MOD_SENTRY)
+		{
+			curwp = weaponFromMOD[j];
+			totaldamage[curwp] += totaldamageMOD[j];
+			totalkills[curwp] += totalkillsMOD[j];
+		}
+	}
+
+	G_LogPrintf(  "\n****Data by Weapon:\n" );
+	for (j=0; j<WP_NUM_WEAPONS; j++)
+	{
+		G_LogPrintf("%15s:  Pickups: %4d,  Time:  %5d,  Deaths: %5d\n", 
+				weaponNameFromIndex[j], totalpickups[j], (int)(totaltime[j]/1000), totaldeaths[j]);
+	}
+
+	G_LogPrintf(  "\n****Combat Data by Weapon:\n" );
+	for (j=0; j<WP_NUM_WEAPONS; j++)
+	{
+		if (totalshots[j] > 0)
+		{
+			pershot = (float)(totaldamage[j])/(float)(totalshots[j]);
+		}
+		else
+		{
+			pershot = 0;
+		}
+		G_LogPrintf("%15s:  Damage: %6d,  Kills: %5d,  Dmg per Shot: %f\n", 
+				weaponNameFromIndex[j], totaldamage[j], totalkills[j], pershot);
+	}
+
+	G_LogPrintf(  "\n****Combat Data By Damage Type:\n" );
+	for (j=0; j<MOD_MAX; j++)
+	{
+		G_LogPrintf("%25s:  Damage: %6d,  Kills: %5d\n", 
+				modNames[j], totaldamageMOD[j], totalkillsMOD[j]);
+	}
+
+	G_LogPrintf("\n");
+
+
+
+	// Write the whole weapon statistic log out to a file.
+	trap_FS_FOpenFile( g_statLogFile.string, &weaponfile, FS_APPEND );
+	if (!weaponfile) {	//failed to open file, let's not crash, shall we?
+		return;
+	}
+
+	// Write out the level name
+	trap_GetServerinfo(info, sizeof(info));
+	strncpy(mapname, Info_ValueForKey( info, "mapname" ), sizeof(mapname)-1);
+	mapname[sizeof(mapname)-1] = '\0';
+
+	Com_sprintf(string, sizeof(string), "\n\n\nLevel:\t%s\n\n\n", mapname);
+	trap_FS_Write( string, strlen( string ), weaponfile);
+
+
+	// Combat data per character
+	
+	// Start with Pickups per character
+	Com_sprintf(string, sizeof(string), "Weapon Pickups per Player:\n\n");
+	trap_FS_Write( string, strlen( string ), weaponfile);
+
+	Com_sprintf(string, sizeof(string), "Player");
+	trap_FS_Write(string, strlen(string), weaponfile);
+
+	for (j=0; j<WP_NUM_WEAPONS; j++)
+	{
+		Com_sprintf(string, sizeof(string), "\t%s", weaponNameFromIndex[j]);
+		trap_FS_Write(string, strlen(string), weaponfile);
+	}
+	Com_sprintf(string, sizeof(string), "\n");
+	trap_FS_Write(string, strlen(string), weaponfile);
+
+	// Cycle through each player, give their name and the number of times they picked up each weapon.
+	for (i=0; i<MAX_CLIENTS; i++)
+	{
+		if (G_WeaponLogClientTouch[i])
+		{	// Ignore any entity/clients we don't care about!
+			if ( g_entities[i].client ) 
+			{
+				nameptr = g_entities[i].client->pers.netname;
+			} 
+			else 
+			{
+				nameptr = unknownname;
+			}
+			trap_FS_Write(nameptr, strlen(nameptr), weaponfile);
+
+			for (j=0;j<WP_NUM_WEAPONS;j++)
+			{
+				Com_sprintf(string, sizeof(string), "\t%d", G_WeaponLogPickups[i][j]);
+				trap_FS_Write(string, strlen(string), weaponfile);
+			}
+
+			Com_sprintf(string, sizeof(string), "\n");
+			trap_FS_Write(string, strlen(string), weaponfile);
+		}
+	}
+
+	// Sum up the totals.
+	Com_sprintf(string, sizeof(string), "\n***TOTAL:");
+	trap_FS_Write(string, strlen(string), weaponfile);
+
+	for (j=0;j<WP_NUM_WEAPONS;j++)
+	{
+		Com_sprintf(string, sizeof(string), "\t%d", totalpickups[j]);
+		trap_FS_Write(string, strlen(string), weaponfile);
+	}
+
+	Com_sprintf(string, sizeof(string), "\n\n\n");
+	trap_FS_Write(string, strlen(string), weaponfile);
+
+	
+	// Weapon fires per character
+	Com_sprintf(string, sizeof(string), "Weapon Shots per Player:\n\n");
+	trap_FS_Write( string, strlen( string ), weaponfile);
+
+	Com_sprintf(string, sizeof(string), "Player");
+	trap_FS_Write(string, strlen(string), weaponfile);
+
+	for (j=0; j<WP_NUM_WEAPONS; j++)
+	{
+		Com_sprintf(string, sizeof(string), "\t%s", weaponNameFromIndex[j]);
+		trap_FS_Write(string, strlen(string), weaponfile);
+	}
+	Com_sprintf(string, sizeof(string), "\n");
+	trap_FS_Write(string, strlen(string), weaponfile);
+
+	// Cycle through each player, give their name and the number of times they picked up each weapon.
+	for (i=0; i<MAX_CLIENTS; i++)
+	{
+		if (G_WeaponLogClientTouch[i])
+		{	// Ignore any entity/clients we don't care about!
+			if ( g_entities[i].client ) 
+			{
+				nameptr = g_entities[i].client->pers.netname;
+			} 
+			else 
+			{
+				nameptr = unknownname;
+			}
+			trap_FS_Write(nameptr, strlen(nameptr), weaponfile);
+
+			for (j=0;j<WP_NUM_WEAPONS;j++)
+			{
+				Com_sprintf(string, sizeof(string), "\t%d", G_WeaponLogFired[i][j]);
+				trap_FS_Write(string, strlen(string), weaponfile);
+			}
+
+			Com_sprintf(string, sizeof(string), "\n");
+			trap_FS_Write(string, strlen(string), weaponfile);
+		}
+	}
+
+	// Sum up the totals.
+	Com_sprintf(string, sizeof(string), "\n***TOTAL:");
+	trap_FS_Write(string, strlen(string), weaponfile);
+	
+	for (j=0;j<WP_NUM_WEAPONS;j++)
+	{
+		Com_sprintf(string, sizeof(string), "\t%d", totalshots[j]);
+		trap_FS_Write(string, strlen(string), weaponfile);
+	}
+
+	Com_sprintf(string, sizeof(string), "\n\n\n");
+	trap_FS_Write(string, strlen(string), weaponfile);
+
+
+	// Weapon time per character
+	Com_sprintf(string, sizeof(string), "Weapon Use Time per Player:\n\n");
+	trap_FS_Write( string, strlen( string ), weaponfile);
+
+	Com_sprintf(string, sizeof(string), "Player");
+	trap_FS_Write(string, strlen(string), weaponfile);
+
+	for (j=0; j<WP_NUM_WEAPONS; j++)
+	{
+		Com_sprintf(string, sizeof(string), "\t%s", weaponNameFromIndex[j]);
+		trap_FS_Write(string, strlen(string), weaponfile);
+	}
+	Com_sprintf(string, sizeof(string), "\n");
+	trap_FS_Write(string, strlen(string), weaponfile);
+
+	// Cycle through each player, give their name and the number of times they picked up each weapon.
+	for (i=0; i<MAX_CLIENTS; i++)
+	{
+		if (G_WeaponLogClientTouch[i])
+		{	// Ignore any entity/clients we don't care about!
+			if ( g_entities[i].client ) 
+			{
+				nameptr = g_entities[i].client->pers.netname;
+			} 
+			else 
+			{
+				nameptr = unknownname;
+			}
+			trap_FS_Write(nameptr, strlen(nameptr), weaponfile);
+
+			for (j=0;j<WP_NUM_WEAPONS;j++)
+			{
+				Com_sprintf(string, sizeof(string), "\t%d", G_WeaponLogTime[i][j]);
+				trap_FS_Write(string, strlen(string), weaponfile);
+			}
+
+			Com_sprintf(string, sizeof(string), "\n");
+			trap_FS_Write(string, strlen(string), weaponfile);
+		}
+	}
+
+	// Sum up the totals.
+	Com_sprintf(string, sizeof(string), "\n***TOTAL:");
+	trap_FS_Write(string, strlen(string), weaponfile);
+	
+	for (j=0;j<WP_NUM_WEAPONS;j++)
+	{
+		Com_sprintf(string, sizeof(string), "\t%d", totaltime[j]);
+		trap_FS_Write(string, strlen(string), weaponfile);
+	}
+
+	Com_sprintf(string, sizeof(string), "\n\n\n");
+	trap_FS_Write(string, strlen(string), weaponfile);
+
+
+	
+	// Weapon deaths per character
+	Com_sprintf(string, sizeof(string), "Weapon Deaths per Player:\n\n");
+	trap_FS_Write( string, strlen( string ), weaponfile);
+
+	Com_sprintf(string, sizeof(string), "Player");
+	trap_FS_Write(string, strlen(string), weaponfile);
+
+	for (j=0; j<WP_NUM_WEAPONS; j++)
+	{
+		Com_sprintf(string, sizeof(string), "\t%s", weaponNameFromIndex[j]);
+		trap_FS_Write(string, strlen(string), weaponfile);
+	}
+	Com_sprintf(string, sizeof(string), "\n");
+	trap_FS_Write(string, strlen(string), weaponfile);
+
+	// Cycle through each player, give their name and the number of times they picked up each weapon.
+	for (i=0; i<MAX_CLIENTS; i++)
+	{
+		if (G_WeaponLogClientTouch[i])
+		{	// Ignore any entity/clients we don't care about!
+			if ( g_entities[i].client ) 
+			{
+				nameptr = g_entities[i].client->pers.netname;
+			} 
+			else 
+			{
+				nameptr = unknownname;
+			}
+			trap_FS_Write(nameptr, strlen(nameptr), weaponfile);
+
+			for (j=0;j<WP_NUM_WEAPONS;j++)
+			{
+				Com_sprintf(string, sizeof(string), "\t%d", G_WeaponLogDeaths[i][j]);
+				trap_FS_Write(string, strlen(string), weaponfile);
+			}
+
+			Com_sprintf(string, sizeof(string), "\n");
+			trap_FS_Write(string, strlen(string), weaponfile);
+		}
+	}
+
+	// Sum up the totals.
+	Com_sprintf(string, sizeof(string), "\n***TOTAL:");
+	trap_FS_Write(string, strlen(string), weaponfile);
+	
+	for (j=0;j<WP_NUM_WEAPONS;j++)
+	{
+		Com_sprintf(string, sizeof(string), "\t%d", totaldeaths[j]);
+		trap_FS_Write(string, strlen(string), weaponfile);
+	}
+
+	Com_sprintf(string, sizeof(string), "\n\n\n");
+	trap_FS_Write(string, strlen(string), weaponfile);
+
+
+
+	
+	// Weapon damage per character
+
+	Com_sprintf(string, sizeof(string), "Weapon Damage per Player:\n\n");
+	trap_FS_Write( string, strlen( string ), weaponfile);
+
+	Com_sprintf(string, sizeof(string), "Player");
+	trap_FS_Write(string, strlen(string), weaponfile);
+
+	for (j=0; j<WP_NUM_WEAPONS; j++)
+	{
+		Com_sprintf(string, sizeof(string), "\t%s", weaponNameFromIndex[j]);
+		trap_FS_Write(string, strlen(string), weaponfile);
+	}
+	Com_sprintf(string, sizeof(string), "\n");
+	trap_FS_Write(string, strlen(string), weaponfile);
+
+	// Cycle through each player, give their name and the number of times they picked up each weapon.
+	for (i=0; i<MAX_CLIENTS; i++)
+	{
+		if (G_WeaponLogClientTouch[i])
+		{	// Ignore any entity/clients we don't care about!
+
+			// We must grab the totals from the damage types for the player and map them to the weapons.
+			memset(percharacter, 0, sizeof(percharacter));
+			for (j=0; j<MOD_MAX; j++)
+			{
+				if (j <= MOD_SENTRY)
+				{
+					curwp = weaponFromMOD[j];
+					percharacter[curwp] += G_WeaponLogDamage[i][j];
+				}
+			}
+
+			if ( g_entities[i].client ) 
+			{
+				nameptr = g_entities[i].client->pers.netname;
+			} 
+			else 
+			{
+				nameptr = unknownname;
+			}
+			trap_FS_Write(nameptr, strlen(nameptr), weaponfile);
+
+			for (j=0;j<WP_NUM_WEAPONS;j++)
+			{
+				Com_sprintf(string, sizeof(string), "\t%d", percharacter[j]);
+				trap_FS_Write(string, strlen(string), weaponfile);
+			}
+
+			Com_sprintf(string, sizeof(string), "\n");
+			trap_FS_Write(string, strlen(string), weaponfile);
+		}
+	}
+
+	// Sum up the totals.
+	Com_sprintf(string, sizeof(string), "\n***TOTAL:");
+	trap_FS_Write(string, strlen(string), weaponfile);
+	
+	for (j=0;j<WP_NUM_WEAPONS;j++)
+	{
+		Com_sprintf(string, sizeof(string), "\t%d", totaldamage[j]);
+		trap_FS_Write(string, strlen(string), weaponfile);
+	}
+
+	Com_sprintf(string, sizeof(string), "\n\n\n");
+	trap_FS_Write(string, strlen(string), weaponfile);
+
+
+	
+	// Weapon kills per character
+
+	Com_sprintf(string, sizeof(string), "Weapon Kills per Player:\n\n");
+	trap_FS_Write( string, strlen( string ), weaponfile);
+
+	Com_sprintf(string, sizeof(string), "Player");
+	trap_FS_Write(string, strlen(string), weaponfile);
+
+	for (j=0; j<WP_NUM_WEAPONS; j++)
+	{
+		Com_sprintf(string, sizeof(string), "\t%s", weaponNameFromIndex[j]);
+		trap_FS_Write(string, strlen(string), weaponfile);
+	}
+	Com_sprintf(string, sizeof(string), "\n");
+	trap_FS_Write(string, strlen(string), weaponfile);
+
+	// Cycle through each player, give their name and the number of times they picked up each weapon.
+	for (i=0; i<MAX_CLIENTS; i++)
+	{
+		if (G_WeaponLogClientTouch[i])
+		{	// Ignore any entity/clients we don't care about!
+
+			// We must grab the totals from the damage types for the player and map them to the weapons.
+			memset(percharacter, 0, sizeof(percharacter));
+			for (j=0; j<MOD_MAX; j++)
+			{
+				if (j <= MOD_SENTRY)
+				{
+					curwp = weaponFromMOD[j];
+					percharacter[curwp] += G_WeaponLogKills[i][j];
+				}
+			}
+
+			if ( g_entities[i].client ) 
+			{
+				nameptr = g_entities[i].client->pers.netname;
+			} 
+			else 
+			{
+				nameptr = unknownname;
+			}
+			trap_FS_Write(nameptr, strlen(nameptr), weaponfile);
+
+			for (j=0;j<WP_NUM_WEAPONS;j++)
+			{
+				Com_sprintf(string, sizeof(string), "\t%d", percharacter[j]);
+				trap_FS_Write(string, strlen(string), weaponfile);
+			}
+
+			Com_sprintf(string, sizeof(string), "\n");
+			trap_FS_Write(string, strlen(string), weaponfile);
+		}
+	}
+
+	// Sum up the totals.
+	Com_sprintf(string, sizeof(string), "\n***TOTAL:");
+	trap_FS_Write(string, strlen(string), weaponfile);
+	
+	for (j=0;j<WP_NUM_WEAPONS;j++)
+	{
+		Com_sprintf(string, sizeof(string), "\t%d", totalkills[j]);
+		trap_FS_Write(string, strlen(string), weaponfile);
+	}
+
+	Com_sprintf(string, sizeof(string), "\n\n\n");
+	trap_FS_Write(string, strlen(string), weaponfile);
+
+
+	
+	// Damage type damage per character
+	Com_sprintf(string, sizeof(string), "Typed Damage per Player:\n\n");
+	trap_FS_Write( string, strlen( string ), weaponfile);
+
+	Com_sprintf(string, sizeof(string), "Player");
+	trap_FS_Write(string, strlen(string), weaponfile);
+
+	for (j=0; j<MOD_MAX; j++)
+	{
+		Com_sprintf(string, sizeof(string), "\t%s", modNames[j]);
+		trap_FS_Write(string, strlen(string), weaponfile);
+	}
+	Com_sprintf(string, sizeof(string), "\n");
+	trap_FS_Write(string, strlen(string), weaponfile);
+
+	// Cycle through each player, give their name and the number of times they picked up each weapon.
+	for (i=0; i<MAX_CLIENTS; i++)
+	{
+		if (G_WeaponLogClientTouch[i])
+		{	// Ignore any entity/clients we don't care about!
+			if ( g_entities[i].client ) 
+			{
+				nameptr = g_entities[i].client->pers.netname;
+			} 
+			else 
+			{
+				nameptr = unknownname;
+			}
+			trap_FS_Write(nameptr, strlen(nameptr), weaponfile);
+
+			for (j=0;j<MOD_MAX;j++)
+			{
+				Com_sprintf(string, sizeof(string), "\t%d", G_WeaponLogDamage[i][j]);
+				trap_FS_Write(string, strlen(string), weaponfile);
+			}
+
+			Com_sprintf(string, sizeof(string), "\n");
+			trap_FS_Write(string, strlen(string), weaponfile);
+		}
+	}
+
+	// Sum up the totals.
+	Com_sprintf(string, sizeof(string), "\n***TOTAL:");
+	trap_FS_Write(string, strlen(string), weaponfile);
+	
+	for (j=0;j<MOD_MAX;j++)
+	{
+		Com_sprintf(string, sizeof(string), "\t%d", totaldamageMOD[j]);
+		trap_FS_Write(string, strlen(string), weaponfile);
+	}
+
+	Com_sprintf(string, sizeof(string), "\n\n\n");
+	trap_FS_Write(string, strlen(string), weaponfile);
+
+
+	
+	// Damage type kills per character
+	Com_sprintf(string, sizeof(string), "Damage-Typed Kills per Player:\n\n");
+	trap_FS_Write( string, strlen( string ), weaponfile);
+
+	Com_sprintf(string, sizeof(string), "Player");
+	trap_FS_Write(string, strlen(string), weaponfile);
+
+	for (j=0; j<MOD_MAX; j++)
+	{
+		Com_sprintf(string, sizeof(string), "\t%s", modNames[j]);
+		trap_FS_Write(string, strlen(string), weaponfile);
+	}
+	Com_sprintf(string, sizeof(string), "\n");
+	trap_FS_Write(string, strlen(string), weaponfile);
+
+	// Cycle through each player, give their name and the number of times they picked up each weapon.
+	for (i=0; i<MAX_CLIENTS; i++)
+	{
+		if (G_WeaponLogClientTouch[i])
+		{	// Ignore any entity/clients we don't care about!
+			if ( g_entities[i].client ) 
+			{
+				nameptr = g_entities[i].client->pers.netname;
+			} 
+			else 
+			{
+				nameptr = unknownname;
+			}
+			trap_FS_Write(nameptr, strlen(nameptr), weaponfile);
+
+			for (j=0;j<MOD_MAX;j++)
+			{
+				Com_sprintf(string, sizeof(string), "\t%d", G_WeaponLogKills[i][j]);
+				trap_FS_Write(string, strlen(string), weaponfile);
+			}
+
+			Com_sprintf(string, sizeof(string), "\n");
+			trap_FS_Write(string, strlen(string), weaponfile);
+		}
+	}
+
+	// Sum up the totals.
+	Com_sprintf(string, sizeof(string), "\n***TOTAL:");
+	trap_FS_Write(string, strlen(string), weaponfile);
+	
+	for (j=0;j<MOD_MAX;j++)
+	{
+		Com_sprintf(string, sizeof(string), "\t%d", totalkillsMOD[j]);
+		trap_FS_Write(string, strlen(string), weaponfile);
+	}
+
+	Com_sprintf(string, sizeof(string), "\n\n\n");
+	trap_FS_Write(string, strlen(string), weaponfile);
+
+
+	trap_FS_FCloseFile(weaponfile);
+
+
+#endif //LOGGING_WEAPONS
+}
+
+// did this player earn the efficiency award?
+qboolean CalculateEfficiency(gentity_t *ent, int *efficiency)
+{
+#ifdef LOGGING_WEAPONS
+	float		fAccuracyRatio = 0, fBestRatio = 0;
+	int			i = 0, nShotsFired = 0, nShotsHit = 0, nBestPlayer = -1, tempEff = 0;
+	gentity_t	*player = NULL;
+
+
+	for (i = 0; i < g_maxclients.integer; i++)
+	{
+		player = g_entities + i;
+		if (!player->inuse)
+			continue;
+		nShotsFired = player->client->accuracy_shots; //player->client->ps.persistant[PERS_ACCURACY_SHOTS];
+		nShotsHit = player->client->accuracy_hits; //player->client->ps.persistant[PERS_ACCURACY_HITS];
+		fAccuracyRatio = ( ((float)nShotsHit)/((float)nShotsFired) );
+		if (fAccuracyRatio > fBestRatio)
+		{
+			fBestRatio = fAccuracyRatio;
+			nBestPlayer = i;
+		}
+	}
+	if (-1 == nBestPlayer)
+	{
+		// huh?
+		return qfalse;
+	}
+	if (nBestPlayer == ent->s.number)
+	{
+		tempEff = (int)(100*fBestRatio);
+		if (tempEff > 50)
+		{
+			*efficiency = tempEff;
+			return qtrue;
+		}
+		return qfalse;
+	}
+#endif // LOGGING_WEAPONS
+	return qfalse;
+}
+
+// did this player earn the sharpshooter award?
+qboolean CalculateSharpshooter(gentity_t *ent, int *frags)
+{
+#ifdef LOGGING_WEAPONS
+	int			i = 0, nBestPlayer = -1, nKills = 0, nMostKills = 0,
+				playTime = (level.time - ent->client->pers.enterTime)/60000;
+	gentity_t	*player = NULL;
+
+	// if this guy didn't get one kill per minute, reject him right now
+	if ( ((float)(G_WeaponLogKills[ent-g_entities][MOD_DISRUPTOR_SNIPER]))/((float)(playTime)) < 1.0 )
+	{
+		return qfalse;
+	}
+
+	for (i = 0; i < g_maxclients.integer; i++)
+	{
+		nKills = 0;
+		player = g_entities + i;
+		if (!player->inuse)
+			continue;
+		nKills = G_WeaponLogKills[i][MOD_DISRUPTOR_SNIPER];
+		if (nKills > nMostKills)
+		{
+			nMostKills = nKills;
+			nBestPlayer = i;
+		}
+	}
+	if (-1 == nBestPlayer)
+	{
+		return qfalse;
+	}
+	if (nBestPlayer == ent->s.number)
+	{
+		*frags = nMostKills;
+		return qtrue;
+	}
+#endif // LOGGING_WEAPONS
+	return qfalse;
+}
+
+// did this player earn the untouchable award?
+qboolean CalculateUntouchable(gentity_t *ent)
+{
+#ifdef LOGGING_WEAPONS
+	int			playTime;
+	playTime = (level.time - ent->client->pers.enterTime)/60000;
+
+	if ( g_gametype.integer == GT_JEDIMASTER && ent->client->ps.isJediMaster )
+	{//Jedi Master (was Borg queen) can only be killed once anyway
+		return qfalse;
+	}
+	//------------------------------------------------------ MUST HAVE ACHIEVED 2 KILLS PER MINUTE
+	if ( ((float)ent->client->ps.persistant[PERS_SCORE])/((float)(playTime)) < 2.0  || playTime==0)
+		return qfalse;
+	//------------------------------------------------------ MUST HAVE ACHIEVED 2 KILLS PER MINUTE
+
+
+	// if this guy was never killed...  Award Away!!!
+	if (ent->client->ps.persistant[PERS_KILLED]==0)
+		return qtrue;
+
+#endif // LOGGING_WEAPONS
+	return qfalse;
+}
+
+// did this player earn the logistics award?
+qboolean CalculateLogistics(gentity_t *ent, int *stuffUsed)
+{
+#ifdef LOGGING_WEAPONS
+	int			i = 0, j = 0, nBestPlayer = -1, nStuffUsed = 0, nMostStuffUsed = 0,
+				nDifferent = 0, nMostDifferent = 0;
+	gentity_t	*player = NULL;
+
+	for (i = 0; i < g_maxclients.integer; i++)
+	{
+		nStuffUsed = 0;
+		nDifferent = 0;
+		player = g_entities + i;
+		if (!player->inuse)
+			continue;
+		for (j = HI_NONE+1; j < HI_NUM_HOLDABLE; j++)
+		{
+			if (G_WeaponLogPowerups[i][j])
+			{
+				nDifferent++;
+			}
+			nStuffUsed += G_WeaponLogPowerups[i][j];
+		}
+		for (j = PW_NONE+1; j < PW_NUM_POWERUPS; j++)
+		{
+			if (G_WeaponLogItems[i][j])
+			{
+				nDifferent++;
+			}
+			nStuffUsed += G_WeaponLogItems[i][j];
+		}
+		if ( (nDifferent >= 4) && (nDifferent >= nMostDifferent) )
+		{
+			if (nStuffUsed > nMostStuffUsed)
+			{
+				nMostDifferent = nDifferent;
+				nMostStuffUsed = nStuffUsed;
+				nBestPlayer = i;
+			}
+		}
+	}
+	if (-1 == nBestPlayer)
+	{
+		return qfalse;
+	}
+	if (nBestPlayer == ent->s.number)
+	{
+		*stuffUsed = nMostDifferent;
+		return qtrue;
+	}
+#endif // LOGGING_WEAPONS
+	return qfalse;
+}
+
+
+
+
+// did this player earn the tactician award?
+qboolean CalculateTactician(gentity_t *ent, int *kills)
+{
+#ifdef LOGGING_WEAPONS
+	int			i = 0, nBestPlayer = -1, nKills = 0, nMostKills = 0;
+	int			person = 0, weapon = 0;
+	gentity_t	*player = NULL;
+	int			wasPickedUpBySomeone[WP_NUM_WEAPONS];
+	int			killsWithWeapon[WP_NUM_WEAPONS];
+	int			playTime = (level.time - ent->client->pers.enterTime)/60000;
+
+	if ( HasSetSaberOnly() )
+	{//duh, only 1 weapon
+		return qfalse;
+	}
+	if ( g_gametype.integer == GT_JEDIMASTER && ent->client->ps.isJediMaster )
+	{//Jedi Master (was Borg queen) has only 1 weapon
+		return qfalse;
+	}
+	//------------------------------------------------------ MUST HAVE ACHIEVED 2 KILLS PER MINUTE
+	if (playTime<0.3)
+		return qfalse;
+
+	if ( ((float)ent->client->ps.persistant[PERS_SCORE])/((float)(playTime)) < 2.0 )
+		return qfalse;
+	//------------------------------------------------------ MUST HAVE ACHIEVED 2 KILLS PER MINUTE
+
+
+
+
+	//------------------------------------------------------ FOR EVERY WEAPON, ADD UP TOTAL PICKUPS
+	for (weapon = 0; weapon<WP_NUM_WEAPONS; weapon++)
+			wasPickedUpBySomeone[weapon] = 0;				// CLEAR
+
+	for (person=0; person<g_maxclients.integer; person++)
+	{
+		for (weapon = 0; weapon<WP_NUM_WEAPONS; weapon++)
+		{
+			if (G_WeaponLogPickups[person][weapon]>0)
+				wasPickedUpBySomeone[weapon]++;
+		}
+	}
+	//------------------------------------------------------ FOR EVERY WEAPON, ADD UP TOTAL PICKUPS
+
+
+
+
+	//------------------------------------------------------ FOR EVERY PERSON, CHECK FOR CANDIDATE
+	for (person=0; person<g_maxclients.integer; person++)
+	{
+		player = g_entities + person;
+		if (!player->inuse)			continue;
+
+		nKills = 0;											// This Persons's Kills
+		for (weapon=0; weapon<WP_NUM_WEAPONS; weapon++)
+			killsWithWeapon[weapon] = 0;					// CLEAR
+
+		for (i=0; i<MOD_MAX; i++)
+		{
+			weapon = weaponFromMOD[i];									// Select Weapon
+			killsWithWeapon[weapon] += G_WeaponLogKills[person][i];		// Store Num Kills With Weapon
+		}
+
+		weapon=WP_STUN_BATON;		// Start At Stun Baton
+		//   keep looking through weapons if weapon is not on map, or if it is and we used it
+		while( weapon<WP_NUM_WEAPONS && (!wasPickedUpBySomeone[weapon] || killsWithWeapon[weapon]>0) )
+		{
+			weapon++;
+			nKills+=killsWithWeapon[weapon];							//  Update the number of kills
+		}
+		//
+		// At this point we have either successfully gone through every weapon on the map and saw it had
+		// been used, or we found one that WAS on the map and was NOT used
+		//
+		// so we look to see if the weapon==Max (i.e. we used every one) and then we check to see
+		// if we got the most kills out of anyone else who did this.
+		//
+		if (weapon>=WP_NUM_WEAPONS && nKills>nMostKills)
+		{
+			// WE ARE A TACTICION CANDIDATE
+			nMostKills  = nKills;
+			nBestPlayer = person;
+		}
+	}
+	//------------------------------------------------------ FOR EVERY PERSON, CHECK FOR CANDIDATE
+
+	//Now, if we are the best player, return true and the number of kills we got
+	if (nBestPlayer == ent->s.number)
+	{
+		*kills = nMostKills;
+		return qtrue;
+	}
+#endif // LOGGING_WEAPONS
+	return qfalse;
+}
+
+
+
+
+// did this player earn the demolitionist award?
+qboolean CalculateDemolitionist(gentity_t *ent, int *kills)
+{
+#ifdef LOGGING_WEAPONS
+	int			i = 0, nBestPlayer = -1, nKills = 0, nMostKills = 0,
+				playTime = (level.time - ent->client->pers.enterTime)/60000;
+	gentity_t	*player = NULL;
+
+	for (i = 0; i < g_maxclients.integer; i++)
+	{
+		nKills = 0;
+		player = g_entities + i;
+		if (!player->inuse)
+			continue;
+
+		nKills = G_WeaponLogKills[i][MOD_THERMAL];
+		nKills += G_WeaponLogKills[i][MOD_THERMAL_SPLASH];
+		nKills += G_WeaponLogKills[i][MOD_ROCKET];
+		nKills += G_WeaponLogKills[i][MOD_ROCKET_SPLASH];
+		nKills += G_WeaponLogKills[i][MOD_ROCKET_HOMING];
+		nKills += G_WeaponLogKills[i][MOD_ROCKET_HOMING_SPLASH];
+		nKills += G_WeaponLogKills[i][MOD_TRIP_MINE_SPLASH];
+		nKills += G_WeaponLogKills[i][MOD_TIMED_MINE_SPLASH];
+		nKills += G_WeaponLogKills[i][MOD_DET_PACK_SPLASH];
+
+		// if this guy didn't get two explosive kills per minute, reject him right now
+		if ( ((float)nKills)/((float)(playTime)) < 2.0 )
+		{
+			continue;
+		}
+
+		if (nKills > nMostKills)
+		{
+			nMostKills = nKills;
+			nBestPlayer = i;
+		}
+	}
+	if (-1 == nBestPlayer)
+	{
+		return qfalse;
+	}
+	if (nBestPlayer == ent->s.number)
+	{
+		*kills = nMostKills;
+		return qtrue;
+	}
+#endif // LOGGING_WEAPONS
+	return qfalse;
+}
+
+int CalculateStreak(gentity_t *ent)
+{
+#if 0
+	if (ent->client->ps.persistant[PERS_STREAK_COUNT] >= STREAK_CHAMPION)
+	{
+		return STREAK_CHAMPION;
+	}
+	if (ent->client->ps.persistant[PERS_STREAK_COUNT] >= STREAK_MASTER)
+	{
+		return STREAK_MASTER;
+	}
+	if (ent->client->ps.persistant[PERS_STREAK_COUNT] >= STREAK_EXPERT)
+	{
+		return STREAK_EXPERT;
+	}
+	if (ent->client->ps.persistant[PERS_STREAK_COUNT] >= STREAK_ACE)
+	{
+		return STREAK_ACE;
+	}
+#endif
+	//No streak calculation, at least for now.
+	return 0;
+}
+
+qboolean CalculateTeamMVP(gentity_t *ent)
+{
+	int			i = 0, nBestPlayer = -1, nScore = 0, nHighestScore = 0,
+				team = ent->client->ps.persistant[PERS_TEAM];
+	gentity_t	*player = NULL;
+
+	for (i = 0; i < g_maxclients.integer; i++)
+	{
+		nScore = 0;
+		player = g_entities + i;
+		if (!player->inuse || (player->client->ps.persistant[PERS_TEAM] != team))
+			continue;
+		nScore = player->client->ps.persistant[PERS_SCORE];
+		if (nScore > nHighestScore)
+		{
+			nHighestScore = nScore;
+			nBestPlayer = i;
+		}
+	}
+	if (-1 == nBestPlayer)
+	{
+		return qfalse;
+	}
+	if (nBestPlayer == ent->s.number)
+	{
+		return qtrue;
+	}
+	return qfalse;
+}
+
+qboolean CalculateTeamMVPByRank(gentity_t *ent)
+{
+	int			i = 0, nBestPlayer = -1, nScore = 0, nHighestScore = 0,
+				team = ent->client->ps.persistant[PERS_RANK]+1;
+	qboolean	bTied = (team == 3);
+	gentity_t	*player = NULL;
+
+	/*
+	if ( team == ent->client->ps.persistant[PERS_TEAM] && ent->client->ps.persistant[PERS_CLASS] == PC_BORG )
+	{//only the queen can be the MVP
+		if ( borgQueenClientNum == ent->s.number )
+		{
+			return qtrue;
+		}
+		else
+		{
+			return qfalse;
+		}
+	}
+	*/
+
+	for (i = 0; i < g_maxclients.integer; i++)
+	{
+		nScore = 0;
+		player = g_entities + i;
+		if (!player->inuse)
+			continue;
+		if (!bTied)
+		{
+			 if (player->client->ps.persistant[PERS_TEAM] != team)
+			 {
+				 continue;
+			 }
+		}
+		nScore = player->client->ps.persistant[PERS_SCORE];
+		if (nScore > nHighestScore)
+		{
+			nHighestScore = nScore;
+			nBestPlayer = i;
+		}
+	}
+	if (-1 == nBestPlayer)
+	{
+		return qfalse;
+	}
+	if (nBestPlayer == ent->s.number)
+	{
+		return qtrue;
+	}
+	return qfalse;
+}
+
+qboolean CalculateTeamDefender(gentity_t *ent)
+{
+	int			i = 0, nBestPlayer = -1, nScore = 0, nHighestScore = 0,
+				team = ent->client->ps.persistant[PERS_TEAM];
+	gentity_t	*player = NULL;
+
+	/*
+	if (CalculateTeamMVP(ent))
+	{
+		return qfalse;
+	}
+	*/
+	for (i = 0; i < g_maxclients.integer; i++)
+	{
+		nScore = 0;
+		player = g_entities + i;
+		if (!player->inuse || (player->client->ps.persistant[PERS_TEAM] != team))
+			continue;
+		nScore = player->client->pers.teamState.basedefense;
+		if (nScore > nHighestScore)
+		{
+			nHighestScore = nScore;
+			nBestPlayer = i;
+		}
+	}
+	if (-1 == nBestPlayer)
+	{
+		return qfalse;
+	}
+	if (nBestPlayer == ent->s.number)
+	{
+		return qtrue;
+	}
+	return qfalse;
+}
+
+qboolean CalculateTeamWarrior(gentity_t *ent)
+{
+	int			i = 0, nBestPlayer = -1, nScore = 0, nHighestScore = 0,
+				team = ent->client->ps.persistant[PERS_TEAM];
+	gentity_t	*player = NULL;
+
+	/*
+	if (CalculateTeamMVP(ent) || CalculateTeamDefender(ent))
+	{
+		return qfalse;
+	}
+	*/
+	for (i = 0; i < g_maxclients.integer; i++)
+	{
+		nScore = 0;
+		player = g_entities + i;
+		if (!player->inuse || (player->client->ps.persistant[PERS_TEAM] != team))
+			continue;
+		nScore = player->client->ps.persistant[PERS_SCORE];
+		if (nScore > nHighestScore)
+		{
+			nHighestScore = nScore;
+			nBestPlayer = i;
+		}
+	}
+	if (-1 == nBestPlayer)
+	{
+		return qfalse;
+	}
+	if (nBestPlayer == ent->s.number)
+	{
+		return qtrue;
+	}
+	return qfalse;
+}
+
+qboolean CalculateTeamCarrier(gentity_t *ent)
+{
+	int			i = 0, nBestPlayer = -1, nScore = 0, nHighestScore = 0,
+				team = ent->client->ps.persistant[PERS_TEAM];
+	gentity_t	*player = NULL;
+
+	/*
+	if (CalculateTeamMVP(ent) || CalculateTeamDefender(ent) || CalculateTeamWarrior(ent))
+	{
+		return qfalse;
+	}
+	*/
+	for (i = 0; i < g_maxclients.integer; i++)
+	{
+		nScore = 0;
+		player = g_entities + i;
+		if (!player->inuse || (player->client->ps.persistant[PERS_TEAM] != team))
+			continue;
+		nScore = player->client->pers.teamState.captures;
+		if (nScore > nHighestScore)
+		{
+			nHighestScore = nScore;
+			nBestPlayer = i;
+		}
+	}
+	if (-1 == nBestPlayer)
+	{
+		return qfalse;
+	}
+	if (nBestPlayer == ent->s.number)
+	{
+		return qtrue;
+	}
+	return qfalse;
+}
+
+qboolean CalculateTeamInterceptor(gentity_t *ent)
+{
+	int			i = 0, nBestPlayer = -1, nScore = 0, nHighestScore = 0,
+				team = ent->client->ps.persistant[PERS_TEAM];
+	gentity_t	*player = NULL;
+
+	/*
+	if (CalculateTeamMVP(ent) || CalculateTeamDefender(ent) || CalculateTeamWarrior(ent) ||
+		CalculateTeamCarrier(ent))
+	{
+		return qfalse;
+	}
+	*/
+	for (i = 0; i < g_maxclients.integer; i++)
+	{
+		nScore = 0;
+		player = g_entities + i;
+		if (!player->inuse || (player->client->ps.persistant[PERS_TEAM] != team))
+			continue;
+		nScore = player->client->pers.teamState.flagrecovery;
+		nScore += player->client->pers.teamState.fragcarrier;
+		if (nScore > nHighestScore)
+		{
+			nHighestScore = nScore;
+			nBestPlayer = i;
+		}
+	}
+	if (-1 == nBestPlayer)
+	{
+		return qfalse;
+	}
+	if (nBestPlayer == ent->s.number)
+	{
+		return qtrue;
+	}
+	return qfalse;
+}
+
+qboolean CalculateTeamRedShirt(gentity_t *ent)
+{
+	int			i = 0, nBestPlayer = -1, nScore = 0, nHighestScore = 0,
+				team = ent->client->ps.persistant[PERS_TEAM];
+	gentity_t	*player = NULL;
+
+	/*
+	if (CalculateTeamMVP(ent) || CalculateTeamDefender(ent) || CalculateTeamWarrior(ent) ||
+		CalculateTeamCarrier(ent) || CalculateTeamInterceptor(ent))
+	{
+		return qfalse;
+	}
+	*/
+	for (i = 0; i < g_maxclients.integer; i++)
+	{
+		nScore = 0;
+		player = g_entities + i;
+		if (!player->inuse || (player->client->ps.persistant[PERS_TEAM] != team))
+			continue;
+		nScore = player->client->ps.persistant[PERS_KILLED];
+		nScore -= player->client->ps.fd.suicides; // suicides don't count, you big cheater.
+		if (nScore > nHighestScore)
+		{
+			nHighestScore = nScore;
+			nBestPlayer = i;
+		}
+	}
+	if (-1 == nBestPlayer)
+	{
+		return qfalse;
+	}
+	if (nBestPlayer == ent->s.number)
+	{
+		return qtrue;
+	}
+	return qfalse;
+}
+
+typedef enum {
+	AWARD_EFFICIENCY,		// Accuracy
+	AWARD_SHARPSHOOTER,		// Most compression rifle frags
+	AWARD_UNTOUCHABLE,		// Perfect (no deaths)
+	AWARD_LOGISTICS,		// Most pickups
+	AWARD_TACTICIAN,		// Kills with all weapons
+	AWARD_DEMOLITIONIST,	// Most explosive damage kills
+	AWARD_STREAK,			// Ace/Expert/Master/Champion
+	AWARD_TEAM,				// MVP/Defender/Warrior/Carrier/Interceptor/Bravery
+	AWARD_SECTION31,		// All-around god
+	AWARD_MAX
+} awardType_t;
+
+typedef enum
+{
+	TEAM_NONE = 0,			// ha ha! you suck!
+	TEAM_MVP,				// most overall points
+	TEAM_DEFENDER,			// killed the most baddies near your flag
+	TEAM_WARRIOR,			// most frags
+	TEAM_CARRIER,			// infected the most people with plague
+	TEAM_INTERCEPTOR,		// returned your own flag the most
+	TEAM_BRAVERY,			// Red Shirt Award (tm). you died more than anybody. 
+	TEAM_MAX
+} teamAward_e;
+
+int CalculateTeamAward(gentity_t *ent)
+{
+	int teamAwards = 0;
+
+	if (CalculateTeamMVP(ent))
+	{
+		teamAwards |= (1<<TEAM_MVP);
+	}
+	if (GT_CTF == g_gametype.integer ||
+		GT_CTY == g_gametype.integer)
+	{
+		if (CalculateTeamDefender(ent))
+		{
+			teamAwards |= (1<<TEAM_DEFENDER);
+		}
+		if (CalculateTeamWarrior(ent))
+		{
+			teamAwards |= (1<<TEAM_WARRIOR);
+		}
+		if (CalculateTeamCarrier(ent))
+		{
+			teamAwards |= (1<<TEAM_CARRIER);
+		}
+		if (CalculateTeamInterceptor(ent))
+		{
+			teamAwards |= (1<<TEAM_INTERCEPTOR);
+		}
+	}
+	if ( !teamAwards && CalculateTeamRedShirt(ent) )
+	{//if you got nothing else and died a lot, at least get bravery
+		teamAwards |= (1<<TEAM_BRAVERY);
+	}
+	return teamAwards;
+}
+
+qboolean CalculateSection31Award(gentity_t *ent)
+{
+	int			i = 0, frags = 0, efficiency = 0;
+	gentity_t	*player = NULL;
+
+	for (i = 0; i < g_maxclients.integer; i++)
+	{
+		player = g_entities + i;
+		if (!player->inuse)
+			continue;
+//
+//	kef -- heh.
+//
+//		if (strcmp("JaxxonPhred", ent->client->pers.netname))
+//		{
+//			continue;
+//		}
+		CalculateEfficiency(ent, &efficiency);
+		if (!CalculateSharpshooter(ent, &frags) ||
+			!CalculateUntouchable(ent) ||
+			/*(CalculateStreak(ent) < STREAK_CHAMPION) ||*/
+			(efficiency < 75))
+		{
+			continue;
+		}
+		return qtrue;
+	}
+	return qfalse;
+}
+
+#define AWARDS_MSG_LENGTH		256
+
+void CalculateAwards(gentity_t *ent, char *msg)
+{
+#ifdef LOGGING_WEAPONS
+	char		buf1[AWARDS_MSG_LENGTH], buf2[AWARDS_MSG_LENGTH];
+	int			awardFlags = 0, efficiency = 0, stuffUsed = 0, kills = 0, streak = 0, teamAwards = 0;
+
+	memset(buf1, 0, AWARDS_MSG_LENGTH);
+	memset(buf2, 0, AWARDS_MSG_LENGTH);
+	if (CalculateEfficiency(ent, &efficiency))
+	{
+		awardFlags |= (1<<AWARD_EFFICIENCY);
+		Com_sprintf(buf1, AWARDS_MSG_LENGTH, " %d", efficiency);
+	}
+	if (CalculateSharpshooter(ent, &kills))
+	{
+		awardFlags |= (1<<AWARD_SHARPSHOOTER);
+		strcpy(buf2, buf1);
+		Com_sprintf(buf1, AWARDS_MSG_LENGTH, "%s %d", buf2, kills);
+	}
+	if (CalculateUntouchable(ent))
+	{
+		awardFlags |= (1<<AWARD_UNTOUCHABLE);
+		strcpy(buf2, buf1);
+		Com_sprintf(buf1, AWARDS_MSG_LENGTH, "%s %d", buf2, 0);
+	}
+	if (CalculateLogistics(ent, &stuffUsed))
+	{
+		awardFlags |= (1<<AWARD_LOGISTICS);
+		strcpy(buf2, buf1);
+		Com_sprintf(buf1, AWARDS_MSG_LENGTH, "%s %d", buf2, stuffUsed);
+	}
+	if (CalculateTactician(ent, &kills))
+	{
+		awardFlags |= (1<<AWARD_TACTICIAN);
+		strcpy(buf2, buf1);
+		Com_sprintf(buf1, AWARDS_MSG_LENGTH, "%s %d", buf2, kills);
+	}
+	if (CalculateDemolitionist(ent, &kills))
+	{
+		awardFlags |= (1<<AWARD_DEMOLITIONIST);
+		strcpy(buf2, buf1);
+		Com_sprintf(buf1, AWARDS_MSG_LENGTH, "%s %d", buf2, kills);
+	}
+	streak = CalculateStreak(ent);
+	if (streak)
+	{
+		awardFlags |= (1<<AWARD_STREAK);
+		strcpy(buf2, buf1);
+		Com_sprintf(buf1, AWARDS_MSG_LENGTH, "%s %d", buf2, streak);
+	}
+	if (g_gametype.integer >= GT_TEAM)
+	{
+		teamAwards = CalculateTeamAward(ent);
+		if (teamAwards)
+		{
+			awardFlags |= (1<<AWARD_TEAM);
+			strcpy(buf2, buf1);
+			Com_sprintf(buf1, AWARDS_MSG_LENGTH, "%s %d", buf2, teamAwards);
+		}
+	}
+	if (CalculateSection31Award(ent))
+	{
+		awardFlags |= (1<<AWARD_SECTION31);
+		strcpy(buf2, buf1);
+		Com_sprintf(buf1, AWARDS_MSG_LENGTH, "%s %d", buf2, 0);
+	}
+	strcpy(buf2, msg);
+	Com_sprintf( msg, AWARDS_MSG_LENGTH, "%s %d%s", buf2, awardFlags, buf1);
+#endif // LOGGING_WEAPONS
+}
+
+int GetMaxDeathsForClient(int nClient)
+{
+	int i = 0, nMostDeaths = 0;
+
+	if ((nClient < 0) || (nClient >= MAX_CLIENTS))
+	{
+		return 0;
+	}
+	for (i = 0; i < MAX_CLIENTS; i++)
+	{
+		if (G_WeaponLogFrags[i][nClient] > nMostDeaths)
+		{
+			nMostDeaths = G_WeaponLogFrags[i][nClient];
+		}
+	}
+	return nMostDeaths;
+}
+
+int GetMaxKillsForClient(int nClient)
+{
+	int i = 0, nMostKills = 0;
+
+	if ((nClient < 0) || (nClient >= MAX_CLIENTS))
+	{
+		return 0;
+	}
+	for (i = 0; i < MAX_CLIENTS; i++)
+	{
+		if (G_WeaponLogFrags[nClient][i] > nMostKills)
+		{
+			nMostKills = G_WeaponLogFrags[nClient][i];
+		}
+	}
+	return nMostKills;
+}
+
+int GetFavoriteTargetForClient(int nClient)
+{
+	int i = 0, nMostKills = 0, nFavoriteTarget = -1;
+
+	if ((nClient < 0) || (nClient >= MAX_CLIENTS))
+	{
+		return 0;
+	}
+	for (i = 0; i < MAX_CLIENTS; i++)
+	{
+		if (G_WeaponLogFrags[nClient][i] > nMostKills)
+		{
+			nMostKills = G_WeaponLogFrags[nClient][i];
+			nFavoriteTarget = i;
+		}
+	}
+	return nFavoriteTarget;
+}
+
+int GetWorstEnemyForClient(int nClient)
+{
+	int i = 0, nMostDeaths = 0, nWorstEnemy = -1;
+
+	if ((nClient < 0) || (nClient >= MAX_CLIENTS))
+	{
+		return 0;
+	}
+	for (i = 0; i < MAX_CLIENTS; i++)
+	{
+		// If there is a tie for most deaths, we want to choose anybody else
+		// over the client...  I.E. Most deaths should not tie with yourself and
+		// have yourself show up...
+
+		if ( G_WeaponLogFrags[i][nClient] > nMostDeaths ||
+			(G_WeaponLogFrags[i][nClient]== nMostDeaths && i!=nClient && nMostDeaths!=0) )
+		{
+			nMostDeaths = G_WeaponLogFrags[i][nClient];
+			nWorstEnemy = i;
+		}
+	}
+	return nWorstEnemy;
+}
+
+int GetFavoriteWeaponForClient(int nClient)
+{
+	int i = 0, nMostKills = 0, fav=0, weapon=WP_STUN_BATON;
+	int	killsWithWeapon[WP_NUM_WEAPONS];
+
+
+	// First thing we need to do is cycle through all the MOD types and convert
+	// number of kills to a single weapon.
+	//----------------------------------------------------------------
+	for (weapon=0; weapon<WP_NUM_WEAPONS; weapon++)
+		killsWithWeapon[weapon] = 0;					// CLEAR
+
+	for (i=MOD_STUN_BATON; i<=MOD_FORCE_DARK; i++)
+	{
+		weapon = weaponFromMOD[i];									// Select Weapon
+
+		if (weapon != WP_NONE)
+		{
+			killsWithWeapon[weapon] += G_WeaponLogKills[nClient][i];	// Store Num Kills With Weapon
+		}
+	}
+
+	// now look through our list of kills per weapon and pick the biggest
+	//----------------------------------------------------------------
+	nMostKills=0;
+	for (weapon=WP_STUN_BATON; weapon<WP_NUM_WEAPONS; weapon++)
+	{
+		if (killsWithWeapon[weapon]>nMostKills)
+		{
+			nMostKills = killsWithWeapon[weapon];
+			fav = weapon;
+		}
+	}
+	return fav;
+}
+
+// kef -- if a client leaves the game, clear out all counters he may have set
+void QDECL G_ClearClientLog(int client)
+{
+	int i = 0;
+
+	for (i = 0; i < WP_NUM_WEAPONS; i++)
+	{
+		G_WeaponLogPickups[client][i] = 0;
+	}
+	for (i = 0; i < WP_NUM_WEAPONS; i++)
+	{
+		G_WeaponLogFired[client][i] = 0;
+	}
+	for (i = 0; i < MOD_MAX; i++)
+	{
+		G_WeaponLogDamage[client][i] = 0;
+	}
+	for (i = 0; i < MOD_MAX; i++)
+	{
+		G_WeaponLogKills[client][i] = 0;
+	}
+	for (i = 0; i < WP_NUM_WEAPONS; i++)
+	{
+		G_WeaponLogDeaths[client][i] = 0;
+	}
+	for (i = 0; i < MAX_CLIENTS; i++)
+	{
+		G_WeaponLogFrags[client][i] = 0;
+	}
+	for (i = 0; i < MAX_CLIENTS; i++)
+	{
+		G_WeaponLogFrags[i][client] = 0;
+	}
+	for (i = 0; i < WP_NUM_WEAPONS; i++)
+	{
+		G_WeaponLogTime[client][i] = 0;
+	}
+	G_WeaponLogLastTime[client] = 0;
+	G_WeaponLogClientTouch[client] = qfalse;
+	for (i = 0; i < HI_NUM_HOLDABLE; i++)
+	{
+		G_WeaponLogPowerups[client][i] = 0;
+	}
+	for (i = 0; i < PW_NUM_POWERUPS; i++)
+	{
+		G_WeaponLogItems[client][i] = 0;
+	}
+}
+
diff --git a/codemp/game/g_main.c b/codemp/game/g_main.c
new file mode 100644
index 0000000..cd5181d
--- /dev/null
+++ b/codemp/game/g_main.c
@@ -0,0 +1,4065 @@
+// Copyright (C) 1999-2000 Id Software, Inc.
+//
+
+#include "g_local.h"
+#include "g_ICARUScb.h"
+#include "g_nav.h"
+#include "bg_saga.h"
+
+level_locals_t	level;
+
+int		eventClearTime = 0;
+static int navCalcPathTime = 0;
+extern int fatalErrors;
+
+int killPlayerTimer = 0;
+
+typedef struct {
+	vmCvar_t	*vmCvar;
+	char		*cvarName;
+	char		*defaultString;
+	int			cvarFlags;
+	int			modificationCount;  // for tracking changes
+	qboolean	trackChange;	    // track this variable, and announce if changed
+  qboolean teamShader;        // track and if changed, update shader state
+} cvarTable_t;
+
+gentity_t		g_entities[MAX_GENTITIES];
+gclient_t		g_clients[MAX_CLIENTS];
+
+qboolean gDuelExit = qfalse;
+
+vmCvar_t	g_trueJedi;
+
+vmCvar_t	g_gametype;
+vmCvar_t	g_MaxHolocronCarry;
+vmCvar_t	g_ff_objectives;
+vmCvar_t	g_autoMapCycle;
+vmCvar_t	g_dmflags;
+vmCvar_t	g_maxForceRank;
+vmCvar_t	g_forceBasedTeams;
+vmCvar_t	g_privateDuel;
+
+vmCvar_t	g_allowNPC;
+
+vmCvar_t	g_armBreakage;
+
+vmCvar_t	g_saberLocking;
+vmCvar_t	g_saberLockFactor;
+vmCvar_t	g_saberTraceSaberFirst;
+
+vmCvar_t	d_saberKickTweak;
+
+vmCvar_t	d_powerDuelPrint;
+
+vmCvar_t	d_saberGhoul2Collision;
+vmCvar_t	g_saberBladeFaces;
+vmCvar_t	d_saberAlwaysBoxTrace;
+vmCvar_t	d_saberBoxTraceSize;
+
+vmCvar_t	d_siegeSeekerNPC;
+
+vmCvar_t	g_debugMelee;
+vmCvar_t	g_stepSlideFix;
+
+vmCvar_t	g_noSpecMove;
+
+#ifdef _DEBUG
+vmCvar_t	g_disableServerG2;
+#endif
+
+vmCvar_t	d_perPlayerGhoul2;
+
+vmCvar_t	d_projectileGhoul2Collision;
+
+vmCvar_t	g_g2TraceLod;
+
+vmCvar_t	g_locationBasedDamage;
+
+vmCvar_t	g_allowHighPingDuelist;
+
+vmCvar_t	g_logClientInfo;
+
+vmCvar_t	g_slowmoDuelEnd;
+
+vmCvar_t	g_saberDamageScale;
+
+vmCvar_t	g_useWhileThrowing;
+
+vmCvar_t	g_RMG;
+
+vmCvar_t	g_svfps;
+
+vmCvar_t	g_forceRegenTime;
+vmCvar_t	g_spawnInvulnerability;
+vmCvar_t	g_forcePowerDisable;
+vmCvar_t	g_weaponDisable;
+vmCvar_t	g_duelWeaponDisable;
+vmCvar_t	g_allowDuelSuicide;
+vmCvar_t	g_fraglimitVoteCorrection;
+vmCvar_t	g_fraglimit;
+vmCvar_t	g_duel_fraglimit;
+vmCvar_t	g_timelimit;
+vmCvar_t	g_capturelimit;
+vmCvar_t	d_saberInterpolate;
+vmCvar_t	g_friendlyFire;
+vmCvar_t	g_friendlySaber;
+vmCvar_t	g_password;
+vmCvar_t	g_needpass;
+vmCvar_t	g_maxclients;
+vmCvar_t	g_maxGameClients;
+vmCvar_t	g_dedicated;
+vmCvar_t	g_developer;
+vmCvar_t	g_speed;
+vmCvar_t	g_gravity;
+vmCvar_t	g_cheats;
+vmCvar_t	g_knockback;
+vmCvar_t	g_quadfactor;
+vmCvar_t	g_forcerespawn;
+vmCvar_t	g_siegeRespawn;
+vmCvar_t	g_inactivity;
+vmCvar_t	g_debugMove;
+#ifndef FINAL_BUILD
+vmCvar_t	g_debugDamage;
+#endif
+vmCvar_t	g_debugAlloc;
+vmCvar_t	g_debugServerSkel;
+vmCvar_t	g_weaponRespawn;
+vmCvar_t	g_weaponTeamRespawn;
+vmCvar_t	g_adaptRespawn;
+vmCvar_t	g_motd;
+vmCvar_t	g_synchronousClients;
+vmCvar_t	g_warmup;
+vmCvar_t	g_doWarmup;
+vmCvar_t	g_restarted;
+vmCvar_t	g_log;
+vmCvar_t	g_logSync;
+vmCvar_t	g_statLog;
+vmCvar_t	g_statLogFile;
+vmCvar_t	g_blood;
+vmCvar_t	g_podiumDist;
+vmCvar_t	g_podiumDrop;
+vmCvar_t	g_allowVote;
+vmCvar_t	g_teamAutoJoin;
+vmCvar_t	g_teamForceBalance;
+vmCvar_t	g_banIPs;
+vmCvar_t	g_filterBan;
+vmCvar_t	g_debugForward;
+vmCvar_t	g_debugRight;
+vmCvar_t	g_debugUp;
+vmCvar_t	g_smoothClients;
+
+#include "../namespace_begin.h"
+vmCvar_t	pmove_fixed;
+vmCvar_t	pmove_msec;
+#include "../namespace_end.h"
+
+vmCvar_t	g_rankings;
+vmCvar_t	g_listEntity;
+vmCvar_t	g_redteam;
+vmCvar_t	g_blueteam;
+vmCvar_t	g_singlePlayer;
+vmCvar_t	g_enableDust;
+vmCvar_t	g_enableBreath;
+vmCvar_t	g_dismember;
+vmCvar_t	g_forceDodge;
+vmCvar_t	g_timeouttospec;
+
+vmCvar_t	g_saberDmgVelocityScale;
+vmCvar_t	g_saberDmgDelay_Idle;
+vmCvar_t	g_saberDmgDelay_Wound;
+
+vmCvar_t	g_saberDebugPrint;
+
+vmCvar_t	g_siegeTeamSwitch;
+
+vmCvar_t	bg_fighterAltControl;
+
+#ifdef DEBUG_SABER_BOX
+vmCvar_t	g_saberDebugBox;
+#endif
+
+//NPC nav debug
+vmCvar_t	d_altRoutes;
+vmCvar_t	d_patched;
+
+vmCvar_t		g_saberRealisticCombat;
+vmCvar_t		g_saberRestrictForce;
+vmCvar_t		d_saberSPStyleDamage;
+vmCvar_t		g_debugSaberLocks;
+vmCvar_t		g_saberLockRandomNess;
+// nmckenzie: SABER_DAMAGE_WALLS
+vmCvar_t		g_saberWallDamageScale;
+
+vmCvar_t		d_saberStanceDebug;
+// ai debug cvars
+vmCvar_t		debugNPCAI;			// used to print out debug info about the bot AI
+vmCvar_t		debugNPCFreeze;		// set to disable bot ai and temporarily freeze them in place
+vmCvar_t		debugNPCAimingBeam;
+vmCvar_t		debugBreak;
+vmCvar_t		debugNoRoam;
+vmCvar_t		d_saberCombat;
+vmCvar_t		d_JediAI;
+vmCvar_t		d_noGroupAI;
+vmCvar_t		d_asynchronousGroupAI;
+vmCvar_t		d_slowmodeath;
+vmCvar_t		d_noIntermissionWait;
+
+vmCvar_t		g_spskill;
+
+
+vmCvar_t		g_siegeTeam1;
+vmCvar_t		g_siegeTeam2;
+
+vmCvar_t	g_austrian;
+
+vmCvar_t	g_powerDuelStartHealth;
+vmCvar_t	g_powerDuelEndHealth;
+
+// nmckenzie: temporary way to show player healths in duels - some iface gfx in game would be better, of course.
+// DUEL_HEALTH
+vmCvar_t		g_showDuelHealths;
+
+// bk001129 - made static to avoid aliasing
+static cvarTable_t		gameCvarTable[] = {
+	// don't override the cheat state set by the system
+	{ &g_cheats, "sv_cheats", "", 0, 0, qfalse },
+
+	{ &g_debugMelee, "g_debugMelee", "0", CVAR_SERVERINFO, 0, qtrue  },
+	{ &g_stepSlideFix, "g_stepSlideFix", "1", CVAR_SERVERINFO, 0, qtrue  },
+
+	{ &g_noSpecMove, "g_noSpecMove", "0", CVAR_SERVERINFO, 0, qtrue },
+
+	// noset vars
+	{ NULL, "gamename", GAMEVERSION , CVAR_SERVERINFO | CVAR_ROM, 0, qfalse  },
+	{ NULL, "gamedate", __DATE__ , CVAR_ROM, 0, qfalse  },
+	{ &g_restarted, "g_restarted", "0", CVAR_ROM, 0, qfalse  },
+	{ NULL, "sv_mapname", "", CVAR_SERVERINFO | CVAR_ROM, 0, qfalse  },
+
+	// latched vars
+	{ &g_gametype, "g_gametype", "0", CVAR_SERVERINFO | CVAR_USERINFO | CVAR_LATCH, 0, qfalse  },
+	{ &g_MaxHolocronCarry, "g_MaxHolocronCarry", "3", CVAR_SERVERINFO | CVAR_USERINFO | CVAR_LATCH, 0, qfalse  },
+
+	{ &g_maxclients, "sv_maxclients", "8", CVAR_SERVERINFO | CVAR_LATCH | CVAR_ARCHIVE, 0, qfalse  },
+	{ &g_maxGameClients, "g_maxGameClients", "0", CVAR_SERVERINFO | CVAR_LATCH | CVAR_ARCHIVE, 0, qfalse  },
+
+	// change anytime vars
+	{ &g_ff_objectives, "g_ff_objectives", "0", /*CVAR_SERVERINFO |*/ CVAR_CHEAT | CVAR_NORESTART, 0, qtrue },
+
+	{ &g_trueJedi, "g_jediVmerc", "0", CVAR_SERVERINFO | CVAR_LATCH | CVAR_ARCHIVE, 0, qtrue },
+
+	{ &g_autoMapCycle, "g_autoMapCycle", "0", CVAR_ARCHIVE | CVAR_NORESTART, 0, qtrue },
+	{ &g_dmflags, "dmflags", "0", CVAR_SERVERINFO | CVAR_ARCHIVE, 0, qtrue  },
+	
+	{ &g_maxForceRank, "g_maxForceRank", "6", CVAR_SERVERINFO | CVAR_ARCHIVE | CVAR_USERINFO | CVAR_LATCH, 0, qfalse  },
+	{ &g_forceBasedTeams, "g_forceBasedTeams", "0", CVAR_SERVERINFO | CVAR_ARCHIVE | CVAR_USERINFO | CVAR_LATCH, 0, qfalse  },
+	{ &g_privateDuel, "g_privateDuel", "1", CVAR_SERVERINFO | CVAR_ARCHIVE, 0, qtrue  },
+
+	{ &g_allowNPC, "g_allowNPC", "1", CVAR_SERVERINFO | CVAR_CHEAT, 0, qtrue  },
+
+	{ &g_armBreakage, "g_armBreakage", "0", 0, 0, qtrue  },
+
+	{ &g_saberLocking, "g_saberLocking", "1", CVAR_SERVERINFO | CVAR_ARCHIVE, 0, qtrue  },
+	{ &g_saberLockFactor, "g_saberLockFactor", "2", CVAR_ARCHIVE, 0, qtrue  },
+	{ &g_saberTraceSaberFirst, "g_saberTraceSaberFirst", "0", CVAR_ARCHIVE, 0, qtrue  },
+
+	{ &d_saberKickTweak, "d_saberKickTweak", "1", 0, 0, qtrue  },
+
+	{ &d_powerDuelPrint, "d_powerDuelPrint", "0", 0, qtrue },
+
+	{ &d_saberGhoul2Collision, "d_saberGhoul2Collision", "1", CVAR_CHEAT, 0, qtrue  },
+	{ &g_saberBladeFaces, "g_saberBladeFaces", "1", 0, 0, qtrue  },
+
+	{ &d_saberAlwaysBoxTrace, "d_saberAlwaysBoxTrace", "0", CVAR_CHEAT, 0, qtrue  },
+	{ &d_saberBoxTraceSize, "d_saberBoxTraceSize", "0", CVAR_CHEAT, 0, qtrue  },
+
+	{ &d_siegeSeekerNPC, "d_siegeSeekerNPC", "0", CVAR_CHEAT, 0, qtrue },
+
+#ifdef _DEBUG
+	{ &g_disableServerG2, "g_disableServerG2", "0", 0, 0, qtrue },
+#endif
+
+	{ &d_perPlayerGhoul2, "d_perPlayerGhoul2", "0", CVAR_CHEAT, 0, qtrue },
+
+	{ &d_projectileGhoul2Collision, "d_projectileGhoul2Collision", "1", CVAR_CHEAT, 0, qtrue  },
+
+	{ &g_g2TraceLod, "g_g2TraceLod", "3", 0, 0, qtrue  },
+
+	{ &g_locationBasedDamage, "g_locationBasedDamage", "1", 0, 0, qtrue },
+
+	{ &g_allowHighPingDuelist, "g_allowHighPingDuelist", "1", 0, 0, qtrue },
+
+	{ &g_logClientInfo, "g_logClientInfo", "0", CVAR_ARCHIVE, 0, qtrue  },
+
+	{ &g_slowmoDuelEnd, "g_slowmoDuelEnd", "0", CVAR_ARCHIVE, 0, qtrue  },
+
+	{ &g_saberDamageScale, "g_saberDamageScale", "1", CVAR_ARCHIVE, 0, qtrue  },
+
+	{ &g_useWhileThrowing, "g_useWhileThrowing", "1", 0, 0, qtrue  },
+
+	{ &g_RMG, "RMG", "0", 0, 0, qtrue  },
+
+	{ &g_svfps, "sv_fps", "20", 0, 0, qtrue },
+
+	{ &g_forceRegenTime, "g_forceRegenTime", "200", CVAR_SERVERINFO | CVAR_ARCHIVE, 0, qtrue  },
+
+	{ &g_spawnInvulnerability, "g_spawnInvulnerability", "3000", CVAR_ARCHIVE, 0, qtrue  },
+
+	{ &g_forcePowerDisable, "g_forcePowerDisable", "0", CVAR_SERVERINFO | CVAR_ARCHIVE | CVAR_LATCH, 0, qtrue  },
+	{ &g_weaponDisable, "g_weaponDisable", "0", CVAR_SERVERINFO | CVAR_ARCHIVE | CVAR_LATCH, 0, qtrue  },
+	{ &g_duelWeaponDisable, "g_duelWeaponDisable", "1", CVAR_SERVERINFO | CVAR_ARCHIVE | CVAR_LATCH, 0, qtrue  },
+
+	{ &g_allowDuelSuicide, "g_allowDuelSuicide", "1", CVAR_ARCHIVE, 0, qtrue },
+
+	{ &g_fraglimitVoteCorrection, "g_fraglimitVoteCorrection", "1", CVAR_ARCHIVE, 0, qtrue },
+
+	{ &g_fraglimit, "fraglimit", "20", CVAR_SERVERINFO | CVAR_ARCHIVE | CVAR_NORESTART, 0, qtrue },
+	{ &g_duel_fraglimit, "duel_fraglimit", "10", CVAR_SERVERINFO | CVAR_ARCHIVE | CVAR_NORESTART, 0, qtrue },
+	{ &g_timelimit, "timelimit", "0", CVAR_SERVERINFO | CVAR_ARCHIVE | CVAR_NORESTART, 0, qtrue },
+	{ &g_capturelimit, "capturelimit", "8", CVAR_SERVERINFO | CVAR_ARCHIVE | CVAR_NORESTART, 0, qtrue },
+
+	{ &g_synchronousClients, "g_synchronousClients", "0", CVAR_SYSTEMINFO, 0, qfalse  },
+
+	{ &d_saberInterpolate, "d_saberInterpolate", "0", CVAR_CHEAT, 0, qtrue },
+
+	{ &g_friendlyFire, "g_friendlyFire", "0", CVAR_ARCHIVE, 0, qtrue  },
+	{ &g_friendlySaber, "g_friendlySaber", "0", CVAR_ARCHIVE, 0, qtrue  },
+
+	{ &g_teamAutoJoin, "g_teamAutoJoin", "0", CVAR_ARCHIVE  },
+	{ &g_teamForceBalance, "g_teamForceBalance", "0", CVAR_ARCHIVE  },
+
+	{ &g_warmup, "g_warmup", "20", CVAR_ARCHIVE, 0, qtrue  },
+	{ &g_doWarmup, "g_doWarmup", "0", 0, 0, qtrue  },
+	{ &g_log, "g_log", "games.log", CVAR_ARCHIVE, 0, qfalse  },
+	{ &g_logSync, "g_logSync", "0", CVAR_ARCHIVE, 0, qfalse  },
+
+	{ &g_statLog, "g_statLog", "0", CVAR_ARCHIVE, 0, qfalse },
+	{ &g_statLogFile, "g_statLogFile", "statlog.log", CVAR_ARCHIVE, 0, qfalse },
+
+	{ &g_password, "g_password", "", CVAR_USERINFO, 0, qfalse  },
+
+	{ &g_banIPs, "g_banIPs", "", CVAR_ARCHIVE, 0, qfalse  },
+	{ &g_filterBan, "g_filterBan", "1", CVAR_ARCHIVE, 0, qfalse  },
+
+	{ &g_needpass, "g_needpass", "0", CVAR_SERVERINFO | CVAR_ROM, 0, qfalse },
+
+	{ &g_dedicated, "dedicated", "0", 0, 0, qfalse  },
+
+	{ &g_developer, "developer", "0", 0, 0, qfalse },
+
+	{ &g_speed, "g_speed", "250", 0, 0, qtrue  },
+	{ &g_gravity, "g_gravity", "800", 0, 0, qtrue  },
+	{ &g_knockback, "g_knockback", "1000", 0, 0, qtrue  },
+	{ &g_quadfactor, "g_quadfactor", "3", 0, 0, qtrue  },
+	{ &g_weaponRespawn, "g_weaponrespawn", "5", 0, 0, qtrue  },
+	{ &g_weaponTeamRespawn, "g_weaponTeamRespawn", "5", 0, 0, qtrue },
+	{ &g_adaptRespawn, "g_adaptrespawn", "1", 0, 0, qtrue  },		// Make weapons respawn faster with a lot of players.
+	{ &g_forcerespawn, "g_forcerespawn", "60", 0, 0, qtrue },		// One minute force respawn.  Give a player enough time to reallocate force.
+	{ &g_siegeRespawn, "g_siegeRespawn", "20", CVAR_SERVERINFO | CVAR_ARCHIVE, 0, qtrue }, //siege respawn wave time
+	{ &g_inactivity, "g_inactivity", "0", 0, 0, qtrue },
+	{ &g_debugMove, "g_debugMove", "0", 0, 0, qfalse },
+#ifndef FINAL_BUILD
+	{ &g_debugDamage, "g_debugDamage", "0", 0, 0, qfalse },
+#endif
+	{ &g_debugAlloc, "g_debugAlloc", "0", 0, 0, qfalse },
+	{ &g_debugServerSkel, "g_debugServerSkel", "0", CVAR_CHEAT, 0, qfalse },
+	{ &g_motd, "g_motd", "", 0, 0, qfalse },
+	{ &g_blood, "com_blood", "1", 0, 0, qfalse },
+
+	{ &g_podiumDist, "g_podiumDist", "80", 0, 0, qfalse },
+	{ &g_podiumDrop, "g_podiumDrop", "70", 0, 0, qfalse },
+
+	{ &g_allowVote, "g_allowVote", "1", CVAR_ARCHIVE, 0, qfalse },
+	{ &g_listEntity, "g_listEntity", "0", 0, 0, qfalse },
+
+#if 0
+	{ &g_debugForward, "g_debugForward", "0", 0, 0, qfalse },
+	{ &g_debugRight, "g_debugRight", "0", 0, 0, qfalse },
+	{ &g_debugUp, "g_debugUp", "0", 0, 0, qfalse },
+#endif
+
+	{ &g_redteam, "g_redteam", "Empire", CVAR_ARCHIVE | CVAR_SERVERINFO | CVAR_USERINFO , 0, qtrue, qtrue },
+	{ &g_blueteam, "g_blueteam", "Rebellion", CVAR_ARCHIVE | CVAR_SERVERINFO | CVAR_USERINFO , 0, qtrue, qtrue  },
+	{ &g_singlePlayer, "ui_singlePlayerActive", "", 0, 0, qfalse, qfalse  },
+
+	{ &g_enableDust, "g_enableDust", "0", 0, 0, qtrue, qfalse },
+	{ &g_enableBreath, "g_enableBreath", "0", 0, 0, qtrue, qfalse },
+	{ &g_smoothClients, "g_smoothClients", "1", 0, 0, qfalse},
+	{ &pmove_fixed, "pmove_fixed", "0", CVAR_SYSTEMINFO, 0, qfalse},
+	{ &pmove_msec, "pmove_msec", "8", CVAR_SYSTEMINFO, 0, qfalse},
+
+	{ &g_rankings, "g_rankings", "0", 0, 0, qfalse},
+
+	{ &g_dismember, "g_dismember", "0", CVAR_ARCHIVE, 0, qtrue  },
+	{ &g_forceDodge, "g_forceDodge", "1", 0, 0, qtrue  },
+
+	{ &g_timeouttospec, "g_timeouttospec", "70", CVAR_ARCHIVE, 0, qfalse },
+
+	{ &g_saberDmgVelocityScale, "g_saberDmgVelocityScale", "0", CVAR_ARCHIVE, 0, qtrue  },
+	{ &g_saberDmgDelay_Idle, "g_saberDmgDelay_Idle", "350", CVAR_ARCHIVE, 0, qtrue  },
+	{ &g_saberDmgDelay_Wound, "g_saberDmgDelay_Wound", "0", CVAR_ARCHIVE, 0, qtrue  },
+
+#ifndef FINAL_BUILD
+	{ &g_saberDebugPrint, "g_saberDebugPrint", "0", CVAR_CHEAT, 0, qfalse  },
+#endif
+	{ &g_debugSaberLocks, "g_debugSaberLocks", "0", CVAR_CHEAT, 0, qfalse },
+	{ &g_saberLockRandomNess, "g_saberLockRandomNess", "2", CVAR_CHEAT, 0, qfalse },
+// nmckenzie: SABER_DAMAGE_WALLS
+	{ &g_saberWallDamageScale, "g_saberWallDamageScale", "0.4", CVAR_SERVERINFO, 0, qfalse },
+
+	{ &d_saberStanceDebug, "d_saberStanceDebug", "0", 0, 0, qfalse },
+
+	{ &g_siegeTeamSwitch, "g_siegeTeamSwitch", "1", CVAR_SERVERINFO|CVAR_ARCHIVE, qfalse },
+
+	{ &bg_fighterAltControl, "bg_fighterAltControl", "0", CVAR_SERVERINFO, 0, qtrue },
+
+#ifdef DEBUG_SABER_BOX
+	{ &g_saberDebugBox, "g_saberDebugBox", "0", CVAR_CHEAT, 0, qfalse },
+#endif
+
+	{ &d_altRoutes, "d_altRoutes", "0", CVAR_CHEAT, 0, qfalse },
+	{ &d_patched, "d_patched", "0", CVAR_CHEAT, 0, qfalse },
+
+	{ &g_saberRealisticCombat, "g_saberRealisticCombat", "0", CVAR_CHEAT },
+	{ &g_saberRestrictForce, "g_saberRestrictForce", "0", CVAR_CHEAT },
+	{ &d_saberSPStyleDamage, "d_saberSPStyleDamage", "1", CVAR_CHEAT },
+
+	{ &debugNoRoam, "d_noroam", "0", CVAR_CHEAT },
+	{ &debugNPCAimingBeam, "d_npcaiming", "0", CVAR_CHEAT },
+	{ &debugBreak, "d_break", "0", CVAR_CHEAT },
+	{ &debugNPCAI, "d_npcai", "0", CVAR_CHEAT },
+	{ &debugNPCFreeze, "d_npcfreeze", "0", CVAR_CHEAT },
+	{ &d_JediAI, "d_JediAI", "0", CVAR_CHEAT },
+	{ &d_noGroupAI, "d_noGroupAI", "0", CVAR_CHEAT },
+	{ &d_asynchronousGroupAI, "d_asynchronousGroupAI", "0", CVAR_CHEAT },
+	
+	//0 = never (BORING)
+	//1 = kyle only
+	//2 = kyle and last enemy jedi
+	//3 = kyle and any enemy jedi
+	//4 = kyle and last enemy in a group
+	//5 = kyle and any enemy
+	//6 = also when kyle takes pain or enemy jedi dodges player saber swing or does an acrobatic evasion
+
+	{ &d_slowmodeath, "d_slowmodeath", "0", CVAR_CHEAT },
+
+	{ &d_saberCombat, "d_saberCombat", "0", CVAR_CHEAT },
+
+	{ &g_spskill, "g_npcspskill", "0", CVAR_ARCHIVE | CVAR_USERINFO },
+
+	//for overriding the level defaults
+	{ &g_siegeTeam1, "g_siegeTeam1", "none", CVAR_ARCHIVE|CVAR_SERVERINFO, 0, qfalse  },
+	{ &g_siegeTeam2, "g_siegeTeam2", "none", CVAR_ARCHIVE|CVAR_SERVERINFO, 0, qfalse  },
+
+	//mainly for debugging with bots while I'm not around (want the server to
+	//cycle through levels naturally)
+	{ &d_noIntermissionWait, "d_noIntermissionWait", "0", CVAR_CHEAT, 0, qfalse  },
+
+	{ &g_austrian, "g_austrian", "0", CVAR_ARCHIVE, 0, qfalse  },
+// nmckenzie:
+// DUEL_HEALTH
+	{ &g_showDuelHealths, "g_showDuelHealths", "0", CVAR_SERVERINFO },
+	{ &g_powerDuelStartHealth, "g_powerDuelStartHealth", "150", CVAR_ARCHIVE, 0, qtrue  },
+	{ &g_powerDuelEndHealth, "g_powerDuelEndHealth", "90", CVAR_ARCHIVE, 0, qtrue  },
+};
+
+// bk001129 - made static to avoid aliasing
+static int gameCvarTableSize = sizeof( gameCvarTable ) / sizeof( gameCvarTable[0] );
+
+
+void G_InitGame					( int levelTime, int randomSeed, int restart );
+void G_RunFrame					( int levelTime );
+void G_ShutdownGame				( int restart );
+void CheckExitRules				( void );
+void G_ROFF_NotetrackCallback	( gentity_t *cent, const char *notetrack);
+
+extern stringID_table_t setTable[];
+
+qboolean G_ParseSpawnVars( qboolean inSubBSP );
+void G_SpawnGEntityFromSpawnVars( qboolean inSubBSP );
+
+
+qboolean NAV_ClearPathToPoint( gentity_t *self, vec3_t pmins, vec3_t pmaxs, vec3_t point, int clipmask, int okToHitEntNum );
+qboolean NPC_ClearLOS2( gentity_t *ent, const vec3_t end );
+int NAVNEW_ClearPathBetweenPoints(vec3_t start, vec3_t end, vec3_t mins, vec3_t maxs, int ignore, int clipmask);
+qboolean NAV_CheckNodeFailedForEnt( gentity_t *ent, int nodeNum );
+qboolean G_EntIsUnlockedDoor( int entityNum );
+qboolean G_EntIsDoor( int entityNum );
+qboolean G_EntIsBreakable( int entityNum );
+qboolean G_EntIsRemovableUsable( int entNum );
+void CP_FindCombatPointWaypoints( void );
+
+/*
+================
+vmMain
+
+This is the only way control passes into the module.
+This must be the very first function compiled into the .q3vm file
+================
+*/
+#include "../namespace_begin.h"
+int vmMain( int command, int arg0, int arg1, int arg2, int arg3, int arg4, int arg5, int arg6, int arg7, int arg8, int arg9, int arg10, int arg11  ) {
+	switch ( command ) {
+	case GAME_INIT:
+		G_InitGame( arg0, arg1, arg2 );
+		return 0;
+	case GAME_SHUTDOWN:
+		G_ShutdownGame( arg0 );
+		return 0;
+	case GAME_CLIENT_CONNECT:
+		return (int)ClientConnect( arg0, arg1, arg2 );
+	case GAME_CLIENT_THINK:
+		ClientThink( arg0, NULL );
+		return 0;
+	case GAME_CLIENT_USERINFO_CHANGED:
+		ClientUserinfoChanged( arg0 );
+		return 0;
+	case GAME_CLIENT_DISCONNECT:
+		ClientDisconnect( arg0 );
+		return 0;
+	case GAME_CLIENT_BEGIN:
+		ClientBegin( arg0, qtrue );
+		return 0;
+	case GAME_CLIENT_COMMAND:
+		ClientCommand( arg0 );
+		return 0;
+	case GAME_RUN_FRAME:
+		G_RunFrame( arg0 );
+		return 0;
+	case GAME_CONSOLE_COMMAND:
+		return ConsoleCommand();
+	case BOTAI_START_FRAME:
+		return BotAIStartFrame( arg0 );
+	case GAME_ROFF_NOTETRACK_CALLBACK:
+		G_ROFF_NotetrackCallback( &g_entities[arg0], (const char *)arg1 );
+		return 0;
+	case GAME_SPAWN_RMG_ENTITY:
+		if (G_ParseSpawnVars(qfalse))
+		{
+			G_SpawnGEntityFromSpawnVars(qfalse);
+		}
+		return 0;
+
+	//rww - begin icarus callbacks
+	case GAME_ICARUS_PLAYSOUND:
+		{
+			T_G_ICARUS_PLAYSOUND *sharedMem = (T_G_ICARUS_PLAYSOUND *)gSharedBuffer;
+			return Q3_PlaySound(sharedMem->taskID, sharedMem->entID, sharedMem->name, sharedMem->channel);
+		}
+	case GAME_ICARUS_SET:
+		{
+			T_G_ICARUS_SET *sharedMem = (T_G_ICARUS_SET *)gSharedBuffer;
+			return Q3_Set(sharedMem->taskID, sharedMem->entID, sharedMem->type_name, sharedMem->data);
+		}
+	case GAME_ICARUS_LERP2POS:
+		{
+			T_G_ICARUS_LERP2POS *sharedMem = (T_G_ICARUS_LERP2POS *)gSharedBuffer;
+			if (sharedMem->nullAngles)
+			{
+				Q3_Lerp2Pos(sharedMem->taskID, sharedMem->entID, sharedMem->origin, NULL, sharedMem->duration);
+			}
+			else
+			{
+				Q3_Lerp2Pos(sharedMem->taskID, sharedMem->entID, sharedMem->origin, sharedMem->angles, sharedMem->duration);
+			}
+		}
+		return 0;
+	case GAME_ICARUS_LERP2ORIGIN:
+		{
+			T_G_ICARUS_LERP2ORIGIN *sharedMem = (T_G_ICARUS_LERP2ORIGIN *)gSharedBuffer;
+			Q3_Lerp2Origin(sharedMem->taskID, sharedMem->entID, sharedMem->origin, sharedMem->duration);
+		}
+		return 0;
+	case GAME_ICARUS_LERP2ANGLES:
+		{
+			T_G_ICARUS_LERP2ANGLES *sharedMem = (T_G_ICARUS_LERP2ANGLES *)gSharedBuffer;
+			Q3_Lerp2Angles(sharedMem->taskID, sharedMem->entID, sharedMem->angles, sharedMem->duration);
+		}
+		return 0;
+	case GAME_ICARUS_GETTAG:
+		{
+			T_G_ICARUS_GETTAG *sharedMem = (T_G_ICARUS_GETTAG *)gSharedBuffer;
+			return Q3_GetTag(sharedMem->entID, sharedMem->name, sharedMem->lookup, sharedMem->info);
+		}
+	case GAME_ICARUS_LERP2START:
+		{
+			T_G_ICARUS_LERP2START *sharedMem = (T_G_ICARUS_LERP2START *)gSharedBuffer;
+			Q3_Lerp2Start(sharedMem->entID, sharedMem->taskID, sharedMem->duration);
+		}
+		return 0;
+	case GAME_ICARUS_LERP2END:
+		{
+			T_G_ICARUS_LERP2END *sharedMem = (T_G_ICARUS_LERP2END *)gSharedBuffer;
+			Q3_Lerp2End(sharedMem->entID, sharedMem->taskID, sharedMem->duration);
+		}
+		return 0;
+	case GAME_ICARUS_USE:
+		{
+			T_G_ICARUS_USE *sharedMem = (T_G_ICARUS_USE *)gSharedBuffer;
+			Q3_Use(sharedMem->entID, sharedMem->target);
+		}
+		return 0;
+	case GAME_ICARUS_KILL:
+		{
+			T_G_ICARUS_KILL *sharedMem = (T_G_ICARUS_KILL *)gSharedBuffer;
+			Q3_Kill(sharedMem->entID, sharedMem->name);
+		}
+		return 0;
+	case GAME_ICARUS_REMOVE:
+		{
+			T_G_ICARUS_REMOVE *sharedMem = (T_G_ICARUS_REMOVE *)gSharedBuffer;
+			Q3_Remove(sharedMem->entID, sharedMem->name);
+		}
+		return 0;
+	case GAME_ICARUS_PLAY:
+		{
+			T_G_ICARUS_PLAY *sharedMem = (T_G_ICARUS_PLAY *)gSharedBuffer;
+			Q3_Play(sharedMem->taskID, sharedMem->entID, sharedMem->type, sharedMem->name);
+		}
+		return 0;
+	case GAME_ICARUS_GETFLOAT:
+		{
+			T_G_ICARUS_GETFLOAT *sharedMem = (T_G_ICARUS_GETFLOAT *)gSharedBuffer;
+			return Q3_GetFloat(sharedMem->entID, sharedMem->type, sharedMem->name, &sharedMem->value);
+		}
+	case GAME_ICARUS_GETVECTOR:
+		{
+			T_G_ICARUS_GETVECTOR *sharedMem = (T_G_ICARUS_GETVECTOR *)gSharedBuffer;
+			return Q3_GetVector(sharedMem->entID, sharedMem->type, sharedMem->name, sharedMem->value);
+		}
+	case GAME_ICARUS_GETSTRING:
+		{
+			T_G_ICARUS_GETSTRING *sharedMem = (T_G_ICARUS_GETSTRING *)gSharedBuffer;
+			int r;
+			char *crap = NULL; //I am sorry for this -rww
+			char **morecrap = &crap; //and this
+			r = Q3_GetString(sharedMem->entID, sharedMem->type, sharedMem->name, morecrap);
+
+			if (crap)
+			{ //success!
+				strcpy(sharedMem->value, crap);
+			}
+
+			return r;
+		}
+	case GAME_ICARUS_SOUNDINDEX:
+		{
+			T_G_ICARUS_SOUNDINDEX *sharedMem = (T_G_ICARUS_SOUNDINDEX *)gSharedBuffer;
+			G_SoundIndex(sharedMem->filename);
+		}
+		return 0;
+	case GAME_ICARUS_GETSETIDFORSTRING:
+		{
+			T_G_ICARUS_GETSETIDFORSTRING *sharedMem = (T_G_ICARUS_GETSETIDFORSTRING *)gSharedBuffer;
+			return GetIDForString(setTable, sharedMem->string);
+		}
+	//rww - end icarus callbacks
+
+	case GAME_NAV_CLEARPATHTOPOINT:
+		return NAV_ClearPathToPoint(&g_entities[arg0], (float *)arg1, (float *)arg2, (float *)arg3, arg4, arg5);
+	case GAME_NAV_CLEARLOS:
+		return NPC_ClearLOS2(&g_entities[arg0], (const float *)arg1);
+	case GAME_NAV_CLEARPATHBETWEENPOINTS:
+		return NAVNEW_ClearPathBetweenPoints((float *)arg0, (float *)arg1, (float *)arg2, (float *)arg3, arg4, arg5);
+	case GAME_NAV_CHECKNODEFAILEDFORENT:
+		return NAV_CheckNodeFailedForEnt(&g_entities[arg0], arg1);
+	case GAME_NAV_ENTISUNLOCKEDDOOR:
+		return G_EntIsUnlockedDoor(arg0);
+	case GAME_NAV_ENTISDOOR:
+		return G_EntIsDoor(arg0);
+	case GAME_NAV_ENTISBREAKABLE:
+		return G_EntIsBreakable(arg0);
+	case GAME_NAV_ENTISREMOVABLEUSABLE:
+		return G_EntIsRemovableUsable(arg0);
+	case GAME_NAV_FINDCOMBATPOINTWAYPOINTS:
+		CP_FindCombatPointWaypoints();
+		return 0;
+	case GAME_GETITEMINDEXBYTAG:
+		return BG_GetItemIndexByTag(arg0, arg1);
+	}
+
+	return -1;
+}
+#include "../namespace_end.h"
+
+
+void QDECL G_Printf( const char *fmt, ... ) {
+	va_list		argptr;
+	char		text[1024];
+
+	va_start (argptr, fmt);
+	vsprintf (text, fmt, argptr);
+	va_end (argptr);
+
+	trap_Printf( text );
+}
+
+void QDECL G_Error( const char *fmt, ... ) {
+	va_list		argptr;
+	char		text[1024];
+
+	va_start (argptr, fmt);
+	vsprintf (text, fmt, argptr);
+	va_end (argptr);
+
+	trap_Error( text );
+}
+
+/*
+================
+G_FindTeams
+
+Chain together all entities with a matching team field.
+Entity teams are used for item groups and multi-entity mover groups.
+
+All but the first will have the FL_TEAMSLAVE flag set and teammaster field set
+All but the last will have the teamchain field set to the next one
+================
+*/
+void G_FindTeams( void ) {
+	gentity_t	*e, *e2;
+	int		i, j;
+	int		c, c2;
+
+	c = 0;
+	c2 = 0;
+	for ( i=1, e=g_entities+i ; i < level.num_entities ; i++,e++ ){
+		if (!e->inuse)
+			continue;
+		if (!e->team)
+			continue;
+		if (e->flags & FL_TEAMSLAVE)
+			continue;
+		if (e->r.contents==CONTENTS_TRIGGER)
+			continue;//triggers NEVER link up in teams!
+		e->teammaster = e;
+		c++;
+		c2++;
+		for (j=i+1, e2=e+1 ; j < level.num_entities ; j++,e2++)
+		{
+			if (!e2->inuse)
+				continue;
+			if (!e2->team)
+				continue;
+			if (e2->flags & FL_TEAMSLAVE)
+				continue;
+			if (!strcmp(e->team, e2->team))
+			{
+				c2++;
+				e2->teamchain = e->teamchain;
+				e->teamchain = e2;
+				e2->teammaster = e;
+				e2->flags |= FL_TEAMSLAVE;
+
+				// make sure that targets only point at the master
+				if ( e2->targetname ) {
+					e->targetname = e2->targetname;
+					e2->targetname = NULL;
+				}
+			}
+		}
+	}
+
+//	G_Printf ("%i teams with %i entities\n", c, c2);
+}
+
+void G_RemapTeamShaders( void ) {
+#if 0
+	char string[1024];
+	float f = level.time * 0.001;
+	Com_sprintf( string, sizeof(string), "team_icon/%s_red", g_redteam.string );
+	AddRemap("textures/ctf2/redteam01", string, f); 
+	AddRemap("textures/ctf2/redteam02", string, f); 
+	Com_sprintf( string, sizeof(string), "team_icon/%s_blue", g_blueteam.string );
+	AddRemap("textures/ctf2/blueteam01", string, f); 
+	AddRemap("textures/ctf2/blueteam02", string, f); 
+	trap_SetConfigstring(CS_SHADERSTATE, BuildShaderStateConfig());
+#endif
+}
+
+
+/*
+=================
+G_RegisterCvars
+=================
+*/
+void G_RegisterCvars( void ) {
+	int			i;
+	cvarTable_t	*cv;
+	qboolean remapped = qfalse;
+
+	for ( i = 0, cv = gameCvarTable ; i < gameCvarTableSize ; i++, cv++ ) {
+		trap_Cvar_Register( cv->vmCvar, cv->cvarName,
+			cv->defaultString, cv->cvarFlags );
+		if ( cv->vmCvar )
+			cv->modificationCount = cv->vmCvar->modificationCount;
+
+		if (cv->teamShader) {
+			remapped = qtrue;
+		}
+	}
+
+	if (remapped) {
+		G_RemapTeamShaders();
+	}
+
+	// check some things
+	if ( g_gametype.integer < 0 || g_gametype.integer >= GT_MAX_GAME_TYPE ) {
+		G_Printf( "g_gametype %i is out of range, defaulting to 0\n", g_gametype.integer );
+		trap_Cvar_Set( "g_gametype", "0" );
+	}
+	else if (g_gametype.integer == GT_HOLOCRON)
+	{
+		G_Printf( "This gametype is not supported.\n" );
+		trap_Cvar_Set( "g_gametype", "0" );
+	}
+	else if (g_gametype.integer == GT_JEDIMASTER)
+	{
+		G_Printf( "This gametype is not supported.\n" );
+		trap_Cvar_Set( "g_gametype", "0" );
+	}
+	else if (g_gametype.integer == GT_CTY)
+	{
+		G_Printf( "This gametype is not supported.\n" );
+		trap_Cvar_Set( "g_gametype", "0" );
+	}
+
+	level.warmupModificationCount = g_warmup.modificationCount;
+}
+
+/*
+=================
+G_UpdateCvars
+=================
+*/
+void G_UpdateCvars( void ) {
+	int			i;
+	cvarTable_t	*cv;
+	qboolean remapped = qfalse;
+
+	for ( i = 0, cv = gameCvarTable ; i < gameCvarTableSize ; i++, cv++ ) {
+		if ( cv->vmCvar ) {
+			trap_Cvar_Update( cv->vmCvar );
+
+			if ( cv->modificationCount != cv->vmCvar->modificationCount ) {
+				cv->modificationCount = cv->vmCvar->modificationCount;
+
+				if ( cv->trackChange ) {
+					trap_SendServerCommand( -1, va("print \"Server: %s changed to %s\n\"", 
+						cv->cvarName, cv->vmCvar->string ) );
+				}
+
+				if (cv->teamShader) {
+					remapped = qtrue;
+				}				
+			}
+		}
+	}
+
+	if (remapped) {
+		G_RemapTeamShaders();
+	}
+}
+
+char gSharedBuffer[MAX_G_SHARED_BUFFER_SIZE];
+
+#include "../namespace_begin.h"
+void WP_SaberLoadParms( void );
+void BG_VehicleLoadParms( void );
+#include "../namespace_end.h"
+
+/*
+============
+G_InitGame
+
+============
+*/
+extern void RemoveAllWP(void);
+extern void BG_ClearVehicleParseParms(void);
+void G_InitGame( int levelTime, int randomSeed, int restart ) {
+	int					i;
+	vmCvar_t	mapname;
+	vmCvar_t	ckSum;
+
+#ifdef _XBOX
+	if(restart) {
+		BG_ClearVehicleParseParms();
+		RemoveAllWP();
+	}
+#endif
+
+	//Init RMG to 0, it will be autoset to 1 if there is terrain on the level.
+	trap_Cvar_Set("RMG", "0");
+	g_RMG.integer = 0;
+
+	//Clean up any client-server ghoul2 instance attachments that may still exist exe-side
+	trap_G2API_CleanEntAttachments();
+
+	BG_InitAnimsets(); //clear it out
+
+	B_InitAlloc(); //make sure everything is clean
+
+	trap_SV_RegisterSharedMemory(gSharedBuffer);
+
+	//Load external vehicle data
+	BG_VehicleLoadParms();
+
+	G_Printf ("------- Game Initialization -------\n");
+	G_Printf ("gamename: %s\n", GAMEVERSION);
+	G_Printf ("gamedate: %s\n", __DATE__);
+
+	srand( randomSeed );
+
+	G_RegisterCvars();
+
+	G_ProcessIPBans();
+
+	G_InitMemory();
+
+	// set some level globals
+	memset( &level, 0, sizeof( level ) );
+	level.time = levelTime;
+	level.startTime = levelTime;
+
+	level.snd_fry = G_SoundIndex("sound/player/fry.wav");	// FIXME standing in lava / slime
+
+	level.snd_hack = G_SoundIndex("sound/player/hacking.wav");
+	level.snd_medHealed = G_SoundIndex("sound/player/supp_healed.wav");
+	level.snd_medSupplied = G_SoundIndex("sound/player/supp_supplied.wav");
+
+	//trap_SP_RegisterServer("mp_svgame");
+
+#ifndef _XBOX
+	if ( g_log.string[0] ) {
+		if ( g_logSync.integer ) {
+			trap_FS_FOpenFile( g_log.string, &level.logFile, FS_APPEND_SYNC );
+		} else {
+			trap_FS_FOpenFile( g_log.string, &level.logFile, FS_APPEND );
+		}
+		if ( !level.logFile ) {
+			G_Printf( "WARNING: Couldn't open logfile: %s\n", g_log.string );
+		} else {
+			char	serverinfo[MAX_INFO_STRING];
+
+			trap_GetServerinfo( serverinfo, sizeof( serverinfo ) );
+
+			G_LogPrintf("------------------------------------------------------------\n" );
+			G_LogPrintf("InitGame: %s\n", serverinfo );
+		}
+	} else {
+		G_Printf( "Not logging to disk.\n" );
+	}
+#endif
+
+	G_LogWeaponInit();
+
+	G_InitWorldSession();
+
+	// initialize all entities for this game
+	memset( g_entities, 0, MAX_GENTITIES * sizeof(g_entities[0]) );
+	level.gentities = g_entities;
+
+	// initialize all clients for this game
+	level.maxclients = g_maxclients.integer;
+	memset( g_clients, 0, MAX_CLIENTS * sizeof(g_clients[0]) );
+	level.clients = g_clients;
+
+	// set client fields on player ents
+	for ( i=0 ; i<level.maxclients ; i++ ) {
+		g_entities[i].client = level.clients + i;
+	}
+
+	// always leave room for the max number of clients,
+	// even if they aren't all used, so numbers inside that
+	// range are NEVER anything but clients
+	level.num_entities = MAX_CLIENTS;
+
+	// let the server system know where the entites are
+	trap_LocateGameData( level.gentities, level.num_entities, sizeof( gentity_t ), 
+		&level.clients[0].ps, sizeof( level.clients[0] ) );
+
+	//Load sabers.cfg data
+	WP_SaberLoadParms();
+
+	NPC_InitGame();
+	
+	TIMER_Clear();
+	//
+	//ICARUS INIT START
+
+//	Com_Printf("------ ICARUS Initialization ------\n");
+
+	trap_ICARUS_Init();
+
+//	Com_Printf ("-----------------------------------\n");
+
+	//ICARUS INIT END
+	//
+
+	// reserve some spots for dead player bodies
+	InitBodyQue();
+
+	ClearRegisteredItems();
+
+	//make sure saber data is loaded before this! (so we can precache the appropriate hilts)
+	InitSiegeMode();
+
+	trap_Cvar_Register( &mapname, "mapname", "", CVAR_SERVERINFO | CVAR_ROM );
+	trap_Cvar_Register( &ckSum, "sv_mapChecksum", "", CVAR_ROM );
+
+	navCalculatePaths	= ( trap_Nav_Load( mapname.string, ckSum.integer ) == qfalse );
+
+	// parse the key/value pairs and spawn gentities
+	G_SpawnEntitiesFromString(qfalse);
+
+	// general initialization
+	G_FindTeams();
+
+	// make sure we have flags for CTF, etc
+	if( g_gametype.integer >= GT_TEAM ) {
+		G_CheckTeamItems();
+	}
+	else if ( g_gametype.integer == GT_JEDIMASTER )
+	{
+		trap_SetConfigstring ( CS_CLIENT_JEDIMASTER, "-1" );
+	}
+
+	if (g_gametype.integer == GT_POWERDUEL)
+	{
+		trap_SetConfigstring ( CS_CLIENT_DUELISTS, va("-1|-1|-1") );
+	}
+	else
+	{
+		trap_SetConfigstring ( CS_CLIENT_DUELISTS, va("-1|-1") );
+	}
+// nmckenzie: DUEL_HEALTH: Default.
+	trap_SetConfigstring ( CS_CLIENT_DUELHEALTHS, va("-1|-1|!") );
+	trap_SetConfigstring ( CS_CLIENT_DUELWINNER, va("-1") );
+
+	SaveRegisteredItems();
+
+	//G_Printf ("-----------------------------------\n");
+
+	if( g_gametype.integer == GT_SINGLE_PLAYER || trap_Cvar_VariableIntegerValue( "com_buildScript" ) ) {
+		G_ModelIndex( SP_PODIUM_MODEL );
+		G_SoundIndex( "sound/player/gurp1.wav" );
+		G_SoundIndex( "sound/player/gurp2.wav" );
+	}
+
+	if ( trap_Cvar_VariableIntegerValue( "bot_enable" ) ) {
+		BotAISetup( restart );
+		BotAILoadMap( restart );
+		G_InitBots( restart );
+	}
+
+	G_RemapTeamShaders();
+
+	if ( g_gametype.integer == GT_DUEL || g_gametype.integer == GT_POWERDUEL )
+	{
+		G_LogPrintf("Duel Tournament Begun: kill limit %d, win limit: %d\n", g_fraglimit.integer, g_duel_fraglimit.integer );
+	}
+
+	if ( navCalculatePaths )
+	{//not loaded - need to calc paths
+		navCalcPathTime = level.time + START_TIME_NAV_CALC;//make sure all ents are in and linked
+	}
+	else
+	{//loaded
+		//FIXME: if this is from a loadgame, it needs to be sure to write this 
+		//out whenever you do a savegame since the edges and routes are dynamic...
+		//OR: always do a navigator.CheckBlockedEdges() on map startup after nav-load/calc-paths
+		//navigator.pathsCalculated = qtrue;//just to be safe?  Does this get saved out?  No... assumed
+		trap_Nav_SetPathsCalculated(qtrue);
+		//need to do this, because combatpoint waypoints aren't saved out...?
+		CP_FindCombatPointWaypoints();
+		navCalcPathTime = 0;
+
+		/*
+		if ( g_eSavedGameJustLoaded == eNO )
+		{//clear all the failed edges unless we just loaded the game (which would include failed edges)
+			trap_Nav_ClearAllFailedEdges();
+		}
+		*/
+		//No loading games in MP.
+	}
+
+	if (g_gametype.integer == GT_SIEGE)
+	{ //just get these configstrings registered now...
+		int i = 0;
+		while (i < MAX_CUSTOM_SIEGE_SOUNDS)
+		{
+			if (!bg_customSiegeSoundNames[i])
+			{
+				break;
+			}
+			G_SoundIndex((char *)bg_customSiegeSoundNames[i]);
+			i++;
+		}
+	}
+}
+
+
+
+/*
+=================
+G_ShutdownGame
+=================
+*/
+void G_ShutdownGame( int restart ) {
+	int i = 0;
+	gentity_t *ent;
+
+//	G_Printf ("==== ShutdownGame ====\n");
+
+	G_CleanAllFakeClients(); //get rid of dynamically allocated fake client structs.
+
+	BG_ClearAnimsets(); //free all dynamic allocations made through the engine
+
+//	Com_Printf("... Gameside GHOUL2 Cleanup\n");
+	while (i < MAX_GENTITIES)
+	{ //clean up all the ghoul2 instances
+		ent = &g_entities[i];
+
+		if (ent->ghoul2 && trap_G2_HaveWeGhoul2Models(ent->ghoul2))
+		{
+			trap_G2API_CleanGhoul2Models(&ent->ghoul2);
+			ent->ghoul2 = NULL;
+		}
+		if (ent->client)
+		{
+			int j = 0;
+
+			while (j < MAX_SABERS)
+			{
+				if (ent->client->weaponGhoul2[j] && trap_G2_HaveWeGhoul2Models(ent->client->weaponGhoul2[j]))
+				{
+					trap_G2API_CleanGhoul2Models(&ent->client->weaponGhoul2[j]);
+				}
+				j++;
+			}
+		}
+		i++;
+	}
+	if (g2SaberInstance && trap_G2_HaveWeGhoul2Models(g2SaberInstance))
+	{
+		trap_G2API_CleanGhoul2Models(&g2SaberInstance);
+		g2SaberInstance = NULL;
+	}
+	if (precachedKyle && trap_G2_HaveWeGhoul2Models(precachedKyle))
+	{
+		trap_G2API_CleanGhoul2Models(&precachedKyle);
+		precachedKyle = NULL;
+	}
+
+//	Com_Printf ("... ICARUS_Shutdown\n");
+	trap_ICARUS_Shutdown ();	//Shut ICARUS down
+
+//	Com_Printf ("... Reference Tags Cleared\n");
+	TAG_Init();	//Clear the reference tags
+
+	G_LogWeaponOutput();
+
+	if ( level.logFile ) {
+		G_LogPrintf("ShutdownGame:\n" );
+		G_LogPrintf("------------------------------------------------------------\n" );
+		trap_FS_FCloseFile( level.logFile );
+	}
+
+	// write all the client session data so we can get it back
+	G_WriteSessionData();
+
+	trap_ROFF_Clean();
+
+	if ( trap_Cvar_VariableIntegerValue( "bot_enable" ) ) {
+		BotAIShutdown( restart );
+	}
+
+	B_CleanupAlloc(); //clean up all allocations made with B_Alloc
+}
+
+
+
+//===================================================================
+
+#ifndef GAME_HARD_LINKED
+// this is only here so the functions in q_shared.c and bg_*.c can link
+
+void QDECL Com_Error ( int level, const char *error, ... ) {
+	va_list		argptr;
+	char		text[1024];
+
+	va_start (argptr, error);
+	vsprintf (text, error, argptr);
+	va_end (argptr);
+
+	G_Error( "%s", text);
+}
+
+void QDECL Com_Printf( const char *msg, ... ) {
+	va_list		argptr;
+	char		text[1024];
+
+	va_start (argptr, msg);
+	vsprintf (text, msg, argptr);
+	va_end (argptr);
+
+	G_Printf ("%s", text);
+}
+
+#endif
+
+/*
+========================================================================
+
+PLAYER COUNTING / SCORE SORTING
+
+========================================================================
+*/
+
+/*
+=============
+AddTournamentPlayer
+
+If there are less than two tournament players, put a
+spectator in the game and restart
+=============
+*/
+void AddTournamentPlayer( void ) {
+	int			i;
+	gclient_t	*client;
+	gclient_t	*nextInLine;
+
+	if ( level.numPlayingClients >= 2 ) {
+		return;
+	}
+
+	// never change during intermission
+//	if ( level.intermissiontime ) {
+//		return;
+//	}
+
+	nextInLine = NULL;
+
+	for ( i = 0 ; i < level.maxclients ; i++ ) {
+		client = &level.clients[i];
+		if ( client->pers.connected != CON_CONNECTED ) {
+			continue;
+		}
+		if (!g_allowHighPingDuelist.integer && client->ps.ping >= 999)
+		{ //don't add people who are lagging out if cvar is not set to allow it.
+			continue;
+		}
+		if ( client->sess.sessionTeam != TEAM_SPECTATOR ) {
+			continue;
+		}
+		// never select the dedicated follow or scoreboard clients
+		if ( client->sess.spectatorState == SPECTATOR_SCOREBOARD || 
+			client->sess.spectatorClient < 0  ) {
+			continue;
+		}
+
+		if ( !nextInLine || client->sess.spectatorTime < nextInLine->sess.spectatorTime ) {
+			nextInLine = client;
+		}
+	}
+
+	if ( !nextInLine ) {
+		return;
+	}
+
+	level.warmupTime = -1;
+
+	// set them to free-for-all team
+	SetTeam( &g_entities[ nextInLine - level.clients ], "f" );
+}
+
+/*
+=======================
+RemoveTournamentLoser
+
+Make the loser a spectator at the back of the line
+=======================
+*/
+void RemoveTournamentLoser( void ) {
+	int			clientNum;
+
+	if ( level.numPlayingClients != 2 ) {
+		return;
+	}
+
+	clientNum = level.sortedClients[1];
+
+	if ( level.clients[ clientNum ].pers.connected != CON_CONNECTED ) {
+		return;
+	}
+
+	// make them a spectator
+	SetTeam( &g_entities[ clientNum ], "s" );
+}
+
+void G_PowerDuelCount(int *loners, int *doubles, qboolean countSpec)
+{
+	int i = 0;
+	gclient_t *cl;
+
+	while (i < MAX_CLIENTS)
+	{
+		cl = g_entities[i].client;
+
+		if (g_entities[i].inuse && cl && (countSpec || cl->sess.sessionTeam != TEAM_SPECTATOR))
+		{
+			if (cl->sess.duelTeam == DUELTEAM_LONE)
+			{
+				(*loners)++;
+			}
+			else if (cl->sess.duelTeam == DUELTEAM_DOUBLE)
+			{
+				(*doubles)++;
+			}
+		}
+		i++;
+	}
+}
+
+qboolean g_duelAssigning = qfalse;
+void AddPowerDuelPlayers( void )
+{
+	int			i;
+	int			loners = 0;
+	int			doubles = 0;
+	int			nonspecLoners = 0;
+	int			nonspecDoubles = 0;
+	gclient_t	*client;
+	gclient_t	*nextInLine;
+
+	if ( level.numPlayingClients >= 3 )
+	{
+		return;
+	}
+
+	nextInLine = NULL;
+
+	G_PowerDuelCount(&nonspecLoners, &nonspecDoubles, qfalse);
+	if (nonspecLoners >= 1 && nonspecDoubles >= 2)
+	{ //we have enough people, stop
+		return;
+	}
+
+	//Could be written faster, but it's not enough to care I suppose.
+	G_PowerDuelCount(&loners, &doubles, qtrue);
+
+	if (loners < 1 || doubles < 2)
+	{ //don't bother trying to spawn anyone yet if the balance is not even set up between spectators
+		return;
+	}
+
+	//Count again, with only in-game clients in mind.
+	loners = nonspecLoners;
+	doubles = nonspecDoubles;
+//	G_PowerDuelCount(&loners, &doubles, qfalse);
+
+	for ( i = 0 ; i < level.maxclients ; i++ ) {
+		client = &level.clients[i];
+		if ( client->pers.connected != CON_CONNECTED ) {
+			continue;
+		}
+		if ( client->sess.sessionTeam != TEAM_SPECTATOR ) {
+			continue;
+		}
+		if (client->sess.duelTeam == DUELTEAM_FREE)
+		{
+			continue;
+		}
+		if (client->sess.duelTeam == DUELTEAM_LONE && loners >= 1)
+		{
+			continue;
+		}
+		if (client->sess.duelTeam == DUELTEAM_DOUBLE && doubles >= 2)
+		{
+			continue;
+		}
+
+		// never select the dedicated follow or scoreboard clients
+		if ( client->sess.spectatorState == SPECTATOR_SCOREBOARD || 
+			client->sess.spectatorClient < 0  ) {
+			continue;
+		}
+
+		if ( !nextInLine || client->sess.spectatorTime < nextInLine->sess.spectatorTime ) {
+			nextInLine = client;
+		}
+	}
+
+	if ( !nextInLine ) {
+		return;
+	}
+
+	level.warmupTime = -1;
+
+	// set them to free-for-all team
+	SetTeam( &g_entities[ nextInLine - level.clients ], "f" );
+
+	//Call recursively until everyone is in
+	AddPowerDuelPlayers();
+}
+
+qboolean g_dontFrickinCheck = qfalse;
+
+void RemovePowerDuelLosers(void)
+{
+	int remClients[3];
+	int remNum = 0;
+	int i = 0;
+	gclient_t *cl;
+
+	while (i < MAX_CLIENTS && remNum < 3)
+	{
+		//cl = &level.clients[level.sortedClients[i]];
+		cl = &level.clients[i];
+
+		if (cl->pers.connected == CON_CONNECTED)
+		{
+			if ((cl->ps.stats[STAT_HEALTH] <= 0 || cl->iAmALoser) &&
+				(cl->sess.sessionTeam != TEAM_SPECTATOR || cl->iAmALoser))
+			{ //he was dead or he was spectating as a loser
+                remClients[remNum] = cl->ps.clientNum;
+				remNum++;
+			}
+		}
+
+		i++;
+	}
+
+	if (!remNum)
+	{ //Time ran out or something? Oh well, just remove the main guy.
+		remClients[remNum] = level.sortedClients[0];
+		remNum++;
+	}
+
+	i = 0;
+	while (i < remNum)
+	{ //set them all to spectator
+		SetTeam( &g_entities[ remClients[i] ], "s" );
+		i++;
+	}
+
+	g_dontFrickinCheck = qfalse;
+
+	//recalculate stuff now that we have reset teams.
+	CalculateRanks();
+}
+
+void RemoveDuelDrawLoser(void)
+{
+	int clFirst = 0;
+	int clSec = 0;
+	int clFailure = 0;
+
+	if ( level.clients[ level.sortedClients[0] ].pers.connected != CON_CONNECTED )
+	{
+		return;
+	}
+	if ( level.clients[ level.sortedClients[1] ].pers.connected != CON_CONNECTED )
+	{
+		return;
+	}
+
+	clFirst = level.clients[ level.sortedClients[0] ].ps.stats[STAT_HEALTH] + level.clients[ level.sortedClients[0] ].ps.stats[STAT_ARMOR];
+	clSec = level.clients[ level.sortedClients[1] ].ps.stats[STAT_HEALTH] + level.clients[ level.sortedClients[1] ].ps.stats[STAT_ARMOR];
+
+	if (clFirst > clSec)
+	{
+		clFailure = 1;
+	}
+	else if (clSec > clFirst)
+	{
+		clFailure = 0;
+	}
+	else
+	{
+		clFailure = 2;
+	}
+
+	if (clFailure != 2)
+	{
+		SetTeam( &g_entities[ level.sortedClients[clFailure] ], "s" );
+	}
+	else
+	{ //we could be more elegant about this, but oh well.
+		SetTeam( &g_entities[ level.sortedClients[1] ], "s" );
+	}
+}
+
+/*
+=======================
+RemoveTournamentWinner
+=======================
+*/
+void RemoveTournamentWinner( void ) {
+	int			clientNum;
+
+	if ( level.numPlayingClients != 2 ) {
+		return;
+	}
+
+	clientNum = level.sortedClients[0];
+
+	if ( level.clients[ clientNum ].pers.connected != CON_CONNECTED ) {
+		return;
+	}
+
+	// make them a spectator
+	SetTeam( &g_entities[ clientNum ], "s" );
+}
+
+/*
+=======================
+AdjustTournamentScores
+=======================
+*/
+void AdjustTournamentScores( void ) {
+	int			clientNum;
+
+	if (level.clients[level.sortedClients[0]].ps.persistant[PERS_SCORE] ==
+		level.clients[level.sortedClients[1]].ps.persistant[PERS_SCORE] &&
+		level.clients[level.sortedClients[0]].pers.connected == CON_CONNECTED &&
+		level.clients[level.sortedClients[1]].pers.connected == CON_CONNECTED)
+	{
+		int clFirst = level.clients[ level.sortedClients[0] ].ps.stats[STAT_HEALTH] + level.clients[ level.sortedClients[0] ].ps.stats[STAT_ARMOR];
+		int clSec = level.clients[ level.sortedClients[1] ].ps.stats[STAT_HEALTH] + level.clients[ level.sortedClients[1] ].ps.stats[STAT_ARMOR];
+		int clFailure = 0;
+		int clSuccess = 0;
+
+		if (clFirst > clSec)
+		{
+			clFailure = 1;
+			clSuccess = 0;
+		}
+		else if (clSec > clFirst)
+		{
+			clFailure = 0;
+			clSuccess = 1;
+		}
+		else
+		{
+			clFailure = 2;
+			clSuccess = 2;
+		}
+
+		if (clFailure != 2)
+		{
+			clientNum = level.sortedClients[clSuccess];
+
+			level.clients[ clientNum ].sess.wins++;
+			ClientUserinfoChanged( clientNum );
+			trap_SetConfigstring ( CS_CLIENT_DUELWINNER, va("%i", clientNum ) );
+
+			clientNum = level.sortedClients[clFailure];
+
+			level.clients[ clientNum ].sess.losses++;
+			ClientUserinfoChanged( clientNum );
+		}
+		else
+		{
+			clSuccess = 0;
+			clFailure = 1;
+
+			clientNum = level.sortedClients[clSuccess];
+
+			level.clients[ clientNum ].sess.wins++;
+			ClientUserinfoChanged( clientNum );
+			trap_SetConfigstring ( CS_CLIENT_DUELWINNER, va("%i", clientNum ) );
+
+			clientNum = level.sortedClients[clFailure];
+
+			level.clients[ clientNum ].sess.losses++;
+			ClientUserinfoChanged( clientNum );
+		}
+	}
+	else
+	{
+		clientNum = level.sortedClients[0];
+		if ( level.clients[ clientNum ].pers.connected == CON_CONNECTED ) {
+			level.clients[ clientNum ].sess.wins++;
+			ClientUserinfoChanged( clientNum );
+
+			trap_SetConfigstring ( CS_CLIENT_DUELWINNER, va("%i", clientNum ) );
+		}
+
+		clientNum = level.sortedClients[1];
+		if ( level.clients[ clientNum ].pers.connected == CON_CONNECTED ) {
+			level.clients[ clientNum ].sess.losses++;
+			ClientUserinfoChanged( clientNum );
+		}
+	}
+}
+
+/*
+=============
+SortRanks
+
+=============
+*/
+int QDECL SortRanks( const void *a, const void *b ) {
+	gclient_t	*ca, *cb;
+
+	ca = &level.clients[*(int *)a];
+	cb = &level.clients[*(int *)b];
+
+	if (g_gametype.integer == GT_POWERDUEL)
+	{
+		//sort single duelists first
+		if (ca->sess.duelTeam == DUELTEAM_LONE && ca->sess.sessionTeam != TEAM_SPECTATOR)
+		{
+			return -1;
+		}
+		if (cb->sess.duelTeam == DUELTEAM_LONE && cb->sess.sessionTeam != TEAM_SPECTATOR)
+		{
+			return 1;
+		}
+
+		//others will be auto-sorted below but above spectators.
+	}
+
+	// sort special clients last
+	if ( ca->sess.spectatorState == SPECTATOR_SCOREBOARD || ca->sess.spectatorClient < 0 ) {
+		return 1;
+	}
+	if ( cb->sess.spectatorState == SPECTATOR_SCOREBOARD || cb->sess.spectatorClient < 0  ) {
+		return -1;
+	}
+
+	// then connecting clients
+	if ( ca->pers.connected == CON_CONNECTING ) {
+		return 1;
+	}
+	if ( cb->pers.connected == CON_CONNECTING ) {
+		return -1;
+	}
+
+
+	// then spectators
+	if ( ca->sess.sessionTeam == TEAM_SPECTATOR && cb->sess.sessionTeam == TEAM_SPECTATOR ) {
+		if ( ca->sess.spectatorTime < cb->sess.spectatorTime ) {
+			return -1;
+		}
+		if ( ca->sess.spectatorTime > cb->sess.spectatorTime ) {
+			return 1;
+		}
+		return 0;
+	}
+	if ( ca->sess.sessionTeam == TEAM_SPECTATOR ) {
+		return 1;
+	}
+	if ( cb->sess.sessionTeam == TEAM_SPECTATOR ) {
+		return -1;
+	}
+
+	// then sort by score
+	if ( ca->ps.persistant[PERS_SCORE]
+		> cb->ps.persistant[PERS_SCORE] ) {
+		return -1;
+	}
+	if ( ca->ps.persistant[PERS_SCORE]
+		< cb->ps.persistant[PERS_SCORE] ) {
+		return 1;
+	}
+	return 0;
+}
+
+qboolean gQueueScoreMessage = qfalse;
+int gQueueScoreMessageTime = 0;
+
+//A new duel started so respawn everyone and make sure their stats are reset
+qboolean G_CanResetDuelists(void)
+{
+	int i;
+	gentity_t *ent;
+
+	i = 0;
+	while (i < 3)
+	{ //precheck to make sure they are all respawnable
+		ent = &g_entities[level.sortedClients[i]];
+
+		if (!ent->inuse || !ent->client || ent->health <= 0 ||
+			ent->client->sess.sessionTeam == TEAM_SPECTATOR ||
+			ent->client->sess.duelTeam <= DUELTEAM_FREE)
+		{
+			return qfalse;
+		}
+		i++;
+	}
+
+	return qtrue;
+}
+
+qboolean g_noPDuelCheck = qfalse;
+void G_ResetDuelists(void)
+{
+	int i;
+	gentity_t *ent;
+	gentity_t *tent;
+
+	i = 0;
+	while (i < 3)
+	{
+		ent = &g_entities[level.sortedClients[i]];
+
+		g_noPDuelCheck = qtrue;
+		player_die(ent, ent, ent, 999, MOD_SUICIDE);
+		g_noPDuelCheck = qfalse;
+		trap_UnlinkEntity (ent);
+		ClientSpawn(ent);
+
+		// add a teleportation effect
+		tent = G_TempEntity( ent->client->ps.origin, EV_PLAYER_TELEPORT_IN );
+		tent->s.clientNum = ent->s.clientNum;
+		i++;
+	}
+}
+
+/*
+============
+CalculateRanks
+
+Recalculates the score ranks of all players
+This will be called on every client connect, begin, disconnect, death,
+and team change.
+============
+*/
+void CalculateRanks( void ) {
+	int		i;
+	int		rank;
+	int		score;
+	int		newScore;
+	int		preNumSpec = 0;
+	//int		nonSpecIndex = -1;
+	gclient_t	*cl;
+
+	preNumSpec = level.numNonSpectatorClients;
+
+	level.follow1 = -1;
+	level.follow2 = -1;
+	level.numConnectedClients = 0;
+	level.numNonSpectatorClients = 0;
+	level.numPlayingClients = 0;
+	level.numVotingClients = 0;		// don't count bots
+	for ( i = 0; i < TEAM_NUM_TEAMS; i++ ) {
+		level.numteamVotingClients[i] = 0;
+	}
+	for ( i = 0 ; i < level.maxclients ; i++ ) {
+		if ( level.clients[i].pers.connected != CON_DISCONNECTED ) {
+			level.sortedClients[level.numConnectedClients] = i;
+			level.numConnectedClients++;
+
+			if ( level.clients[i].sess.sessionTeam != TEAM_SPECTATOR || g_gametype.integer == GT_DUEL || g_gametype.integer == GT_POWERDUEL )
+			{
+				if (level.clients[i].sess.sessionTeam != TEAM_SPECTATOR)
+				{
+					level.numNonSpectatorClients++;
+					//nonSpecIndex = i;
+				}
+			
+				// decide if this should be auto-followed
+				if ( level.clients[i].pers.connected == CON_CONNECTED )
+				{
+					if (level.clients[i].sess.sessionTeam != TEAM_SPECTATOR || level.clients[i].iAmALoser)
+					{
+						level.numPlayingClients++;
+					}
+					if ( !(g_entities[i].r.svFlags & SVF_BOT) )
+					{
+						level.numVotingClients++;
+						if ( level.clients[i].sess.sessionTeam == TEAM_RED )
+							level.numteamVotingClients[0]++;
+						else if ( level.clients[i].sess.sessionTeam == TEAM_BLUE )
+							level.numteamVotingClients[1]++;
+					}
+					if ( level.follow1 == -1 ) {
+						level.follow1 = i;
+					} else if ( level.follow2 == -1 ) {
+						level.follow2 = i;
+					}
+				}
+			}
+		}
+	}
+
+	//if (!g_warmup.integer)
+	if (1)
+	{
+		level.warmupTime = 0;
+	}
+
+	/*
+	if (level.numNonSpectatorClients == 2 && preNumSpec < 2 && nonSpecIndex != -1 && g_gametype.integer == GT_DUEL && !level.warmupTime)
+	{
+		gentity_t *currentWinner = G_GetDuelWinner(&level.clients[nonSpecIndex]);
+
+		if (currentWinner && currentWinner->client)
+		{
+			trap_SendServerCommand( -1, va("cp \"%s" S_COLOR_WHITE " %s %s\n\"",
+			currentWinner->client->pers.netname, G_GetStringEdString("MP_SVGAME", "VERSUS"), level.clients[nonSpecIndex].pers.netname));
+		}
+	}
+	*/
+	//NOTE: for now not doing this either. May use later if appropriate.
+
+	qsort( level.sortedClients, level.numConnectedClients, 
+		sizeof(level.sortedClients[0]), SortRanks );
+
+	// set the rank value for all clients that are connected and not spectators
+	if ( g_gametype.integer >= GT_TEAM ) {
+		// in team games, rank is just the order of the teams, 0=red, 1=blue, 2=tied
+		for ( i = 0;  i < level.numConnectedClients; i++ ) {
+			cl = &level.clients[ level.sortedClients[i] ];
+			if ( level.teamScores[TEAM_RED] == level.teamScores[TEAM_BLUE] ) {
+				cl->ps.persistant[PERS_RANK] = 2;
+			} else if ( level.teamScores[TEAM_RED] > level.teamScores[TEAM_BLUE] ) {
+				cl->ps.persistant[PERS_RANK] = 0;
+			} else {
+				cl->ps.persistant[PERS_RANK] = 1;
+			}
+		}
+	} else {	
+		rank = -1;
+		score = 0;
+		for ( i = 0;  i < level.numPlayingClients; i++ ) {
+			cl = &level.clients[ level.sortedClients[i] ];
+			newScore = cl->ps.persistant[PERS_SCORE];
+			if ( i == 0 || newScore != score ) {
+				rank = i;
+				// assume we aren't tied until the next client is checked
+				level.clients[ level.sortedClients[i] ].ps.persistant[PERS_RANK] = rank;
+			} else {
+				// we are tied with the previous client
+				level.clients[ level.sortedClients[i-1] ].ps.persistant[PERS_RANK] = rank | RANK_TIED_FLAG;
+				level.clients[ level.sortedClients[i] ].ps.persistant[PERS_RANK] = rank | RANK_TIED_FLAG;
+			}
+			score = newScore;
+			if ( g_gametype.integer == GT_SINGLE_PLAYER && level.numPlayingClients == 1 ) {
+				level.clients[ level.sortedClients[i] ].ps.persistant[PERS_RANK] = rank | RANK_TIED_FLAG;
+			}
+		}
+	}
+
+	// set the CS_SCORES1/2 configstrings, which will be visible to everyone
+	if ( g_gametype.integer >= GT_TEAM ) {
+		trap_SetConfigstring( CS_SCORES1, va("%i", level.teamScores[TEAM_RED] ) );
+		trap_SetConfigstring( CS_SCORES2, va("%i", level.teamScores[TEAM_BLUE] ) );
+	} else {
+		if ( level.numConnectedClients == 0 ) {
+			trap_SetConfigstring( CS_SCORES1, va("%i", SCORE_NOT_PRESENT) );
+			trap_SetConfigstring( CS_SCORES2, va("%i", SCORE_NOT_PRESENT) );
+		} else if ( level.numConnectedClients == 1 ) {
+			trap_SetConfigstring( CS_SCORES1, va("%i", level.clients[ level.sortedClients[0] ].ps.persistant[PERS_SCORE] ) );
+			trap_SetConfigstring( CS_SCORES2, va("%i", SCORE_NOT_PRESENT) );
+		} else {
+			trap_SetConfigstring( CS_SCORES1, va("%i", level.clients[ level.sortedClients[0] ].ps.persistant[PERS_SCORE] ) );
+			trap_SetConfigstring( CS_SCORES2, va("%i", level.clients[ level.sortedClients[1] ].ps.persistant[PERS_SCORE] ) );
+		}
+
+		if (g_gametype.integer != GT_DUEL || g_gametype.integer != GT_POWERDUEL)
+		{ //when not in duel, use this configstring to pass the index of the player currently in first place
+			if ( level.numConnectedClients >= 1 )
+			{
+				trap_SetConfigstring ( CS_CLIENT_DUELWINNER, va("%i", level.sortedClients[0] ) );
+			}
+			else
+			{
+				trap_SetConfigstring ( CS_CLIENT_DUELWINNER, "-1" );
+			}
+		}
+	}
+
+	// see if it is time to end the level
+	CheckExitRules();
+
+	// if we are at the intermission or in multi-frag Duel game mode, send the new info to everyone
+	if ( level.intermissiontime || g_gametype.integer == GT_DUEL || g_gametype.integer == GT_POWERDUEL ) {
+		gQueueScoreMessage = qtrue;
+		gQueueScoreMessageTime = level.time + 500;
+		//SendScoreboardMessageToAllClients();
+		//rww - Made this operate on a "queue" system because it was causing large overflows
+	}
+}
+
+
+/*
+========================================================================
+
+MAP CHANGING
+
+========================================================================
+*/
+
+/*
+========================
+SendScoreboardMessageToAllClients
+
+Do this at BeginIntermission time and whenever ranks are recalculated
+due to enters/exits/forced team changes
+========================
+*/
+void SendScoreboardMessageToAllClients( void ) {
+	int		i;
+
+	for ( i = 0 ; i < level.maxclients ; i++ ) {
+		if ( level.clients[ i ].pers.connected == CON_CONNECTED ) {
+			DeathmatchScoreboardMessage( g_entities + i );
+		}
+	}
+}
+
+/*
+========================
+MoveClientToIntermission
+
+When the intermission starts, this will be called for all players.
+If a new client connects, this will be called after the spawn function.
+========================
+*/
+void MoveClientToIntermission( gentity_t *ent ) {
+	// take out of follow mode if needed
+	if ( ent->client->sess.spectatorState == SPECTATOR_FOLLOW ) {
+		StopFollowing( ent );
+	}
+
+
+	// move to the spot
+	VectorCopy( level.intermission_origin, ent->s.origin );
+	VectorCopy( level.intermission_origin, ent->client->ps.origin );
+	VectorCopy (level.intermission_angle, ent->client->ps.viewangles);
+	ent->client->ps.pm_type = PM_INTERMISSION;
+
+	// clean up powerup info
+	memset( ent->client->ps.powerups, 0, sizeof(ent->client->ps.powerups) );
+
+	ent->client->ps.eFlags = 0;
+	ent->s.eFlags = 0;
+	ent->s.eType = ET_GENERAL;
+	ent->s.modelindex = 0;
+	ent->s.loopSound = 0;
+	ent->s.loopIsSoundset = qfalse;
+	ent->s.event = 0;
+	ent->r.contents = 0;
+}
+
+/*
+==================
+FindIntermissionPoint
+
+This is also used for spectator spawns
+==================
+*/
+void FindIntermissionPoint( void ) {
+	gentity_t	*ent, *target;
+	vec3_t		dir;
+
+	// find the intermission spot
+	ent = G_Find (NULL, FOFS(classname), "info_player_intermission");
+	if ( !ent ) {	// the map creator forgot to put in an intermission point...
+		SelectSpawnPoint ( vec3_origin, level.intermission_origin, level.intermission_angle );
+	} else {
+		VectorCopy (ent->s.origin, level.intermission_origin);
+		VectorCopy (ent->s.angles, level.intermission_angle);
+		// if it has a target, look towards it
+		if ( ent->target ) {
+			target = G_PickTarget( ent->target );
+			if ( target ) {
+				VectorSubtract( target->s.origin, level.intermission_origin, dir );
+				vectoangles( dir, level.intermission_angle );
+			}
+		}
+	}
+
+}
+
+qboolean DuelLimitHit(void);
+
+/*
+==================
+BeginIntermission
+==================
+*/
+void BeginIntermission( void ) {
+	int			i;
+	gentity_t	*client;
+
+	if ( level.intermissiontime ) {
+		return;		// already active
+	}
+
+	// if in tournement mode, change the wins / losses
+	if ( g_gametype.integer == GT_DUEL || g_gametype.integer == GT_POWERDUEL ) {
+		trap_SetConfigstring ( CS_CLIENT_DUELWINNER, "-1" );
+
+		if (g_gametype.integer != GT_POWERDUEL)
+		{
+			AdjustTournamentScores();
+		}
+		if (DuelLimitHit())
+		{
+			gDuelExit = qtrue;
+		}
+		else
+		{
+			gDuelExit = qfalse;
+		}
+	}
+
+	level.intermissiontime = level.time;
+	FindIntermissionPoint();
+
+	/*
+	if (g_singlePlayer.integer) {
+		trap_Cvar_Set("ui_singlePlayerActive", "0");
+		UpdateTournamentInfo();
+	}
+	*/
+	//what the? Well, I don't want this to happen.
+
+	// move all clients to the intermission point
+	for (i=0 ; i< level.maxclients ; i++) {
+		client = g_entities + i;
+		if (!client->inuse)
+			continue;
+		// respawn if dead
+		if (client->health <= 0) {
+			if (g_gametype.integer != GT_POWERDUEL ||
+				!client->client ||
+				client->client->sess.sessionTeam != TEAM_SPECTATOR)
+			{ //don't respawn spectators in powerduel or it will mess the line order all up
+				respawn(client);
+			}
+		}
+		MoveClientToIntermission( client );
+	}
+
+	// send the current scoring to all clients
+	SendScoreboardMessageToAllClients();
+
+}
+
+qboolean DuelLimitHit(void)
+{
+	int i;
+	gclient_t *cl;
+
+	for ( i=0 ; i< g_maxclients.integer ; i++ ) {
+		cl = level.clients + i;
+		if ( cl->pers.connected != CON_CONNECTED ) {
+			continue;
+		}
+
+		if ( g_duel_fraglimit.integer && cl->sess.wins >= g_duel_fraglimit.integer )
+		{
+			return qtrue;
+		}
+	}
+
+	return qfalse;
+}
+
+void DuelResetWinsLosses(void)
+{
+	int i;
+	gclient_t *cl;
+
+	for ( i=0 ; i< g_maxclients.integer ; i++ ) {
+		cl = level.clients + i;
+		if ( cl->pers.connected != CON_CONNECTED ) {
+			continue;
+		}
+
+		cl->sess.wins = 0;
+		cl->sess.losses = 0;
+	}
+}
+
+/*
+=============
+ExitLevel
+
+When the intermission has been exited, the server is either killed
+or moved to a new level based on the "nextmap" cvar 
+
+=============
+*/
+extern void SiegeDoTeamAssign(void); //g_saga.c
+extern siegePers_t g_siegePersistant; //g_saga.c
+void ExitLevel (void) {
+	int		i;
+	gclient_t *cl;
+
+	// if we are running a tournement map, kick the loser to spectator status,
+	// which will automatically grab the next spectator and restart
+	if ( g_gametype.integer == GT_DUEL || g_gametype.integer == GT_POWERDUEL ) {
+		if (!DuelLimitHit())
+		{
+			if ( !level.restarted ) {
+				trap_SendConsoleCommand( EXEC_APPEND, "map_restart 0\n" );
+				level.restarted = qtrue;
+				level.changemap = NULL;
+				level.intermissiontime = 0;
+			}
+			return;	
+		}
+
+		DuelResetWinsLosses();
+	}
+
+
+	if (g_gametype.integer == GT_SIEGE &&
+		g_siegeTeamSwitch.integer &&
+		g_siegePersistant.beatingTime)
+	{ //restart same map...
+		trap_SendConsoleCommand( EXEC_APPEND, "map_restart 0\n" );
+	}
+	else
+	{
+		trap_SendConsoleCommand( EXEC_APPEND, "vstr nextmap\n" );
+	}
+	level.changemap = NULL;
+	level.intermissiontime = 0;
+
+	if (g_gametype.integer == GT_SIEGE &&
+		g_siegeTeamSwitch.integer)
+	{ //switch out now
+		SiegeDoTeamAssign();
+	}
+
+	// reset all the scores so we don't enter the intermission again
+	level.teamScores[TEAM_RED] = 0;
+	level.teamScores[TEAM_BLUE] = 0;
+	for ( i=0 ; i< g_maxclients.integer ; i++ ) {
+		cl = level.clients + i;
+		if ( cl->pers.connected != CON_CONNECTED ) {
+			continue;
+		}
+		cl->ps.persistant[PERS_SCORE] = 0;
+	}
+
+	// we need to do this here before chaning to CON_CONNECTING
+	G_WriteSessionData();
+
+	// change all client states to connecting, so the early players into the
+	// next level will know the others aren't done reconnecting
+	for (i=0 ; i< g_maxclients.integer ; i++) {
+		if ( level.clients[i].pers.connected == CON_CONNECTED ) {
+			level.clients[i].pers.connected = CON_CONNECTING;
+		}
+	}
+
+}
+
+/*
+=================
+G_LogPrintf
+
+Print to the logfile with a time stamp if it is open
+=================
+*/
+void QDECL G_LogPrintf( const char *fmt, ... ) {
+	va_list		argptr;
+	char		string[1024];
+	int			min, tens, sec;
+
+	sec = level.time / 1000;
+
+	min = sec / 60;
+	sec -= min * 60;
+	tens = sec / 10;
+	sec -= tens * 10;
+
+	Com_sprintf( string, sizeof(string), "%3i:%i%i ", min, tens, sec );
+
+	va_start( argptr, fmt );
+	vsprintf( string +7 , fmt,argptr );
+	va_end( argptr );
+
+	if ( g_dedicated.integer ) {
+		G_Printf( "%s", string + 7 );
+	}
+
+	if ( !level.logFile ) {
+		return;
+	}
+
+	trap_FS_Write( string, strlen( string ), level.logFile );
+}
+
+/*
+================
+LogExit
+
+Append information about this game to the log file
+================
+*/
+void LogExit( const char *string ) {
+	int				i, numSorted;
+	gclient_t		*cl;
+//	qboolean		won = qtrue;
+	G_LogPrintf( "Exit: %s\n", string );
+
+	level.intermissionQueued = level.time;
+
+	// this will keep the clients from playing any voice sounds
+	// that will get cut off when the queued intermission starts
+	trap_SetConfigstring( CS_INTERMISSION, "1" );
+
+	// don't send more than 32 scores (FIXME?)
+	numSorted = level.numConnectedClients;
+	if ( numSorted > 32 ) {
+		numSorted = 32;
+	}
+
+	if ( g_gametype.integer >= GT_TEAM ) {
+		G_LogPrintf( "red:%i  blue:%i\n",
+			level.teamScores[TEAM_RED], level.teamScores[TEAM_BLUE] );
+	}
+
+	for (i=0 ; i < numSorted ; i++) {
+		int		ping;
+
+		cl = &level.clients[level.sortedClients[i]];
+
+		if ( cl->sess.sessionTeam == TEAM_SPECTATOR ) {
+			continue;
+		}
+		if ( cl->pers.connected == CON_CONNECTING ) {
+			continue;
+		}
+
+		ping = cl->ps.ping < 999 ? cl->ps.ping : 999;
+
+		G_LogPrintf( "score: %i  ping: %i  client: %i %s\n", cl->ps.persistant[PERS_SCORE], ping, level.sortedClients[i],	cl->pers.netname );
+//		if (g_singlePlayer.integer && (g_gametype.integer == GT_DUEL || g_gametype.integer == GT_POWERDUEL)) {
+//			if (g_entities[cl - level.clients].r.svFlags & SVF_BOT && cl->ps.persistant[PERS_RANK] == 0) {
+//				won = qfalse;
+//			}
+//		}
+	}
+
+	//yeah.. how about not.
+	/*
+	if (g_singlePlayer.integer) {
+		if (g_gametype.integer >= GT_CTF) {
+			won = level.teamScores[TEAM_RED] > level.teamScores[TEAM_BLUE];
+		}
+		trap_SendConsoleCommand( EXEC_APPEND, (won) ? "spWin\n" : "spLose\n" );
+	}
+	*/
+}
+
+qboolean gDidDuelStuff = qfalse; //gets reset on game reinit
+
+/*
+=================
+CheckIntermissionExit
+
+The level will stay at the intermission for a minimum of 5 seconds
+If all players wish to continue, the level will then exit.
+If one or more players have not acknowledged the continue, the game will
+wait 10 seconds before going on.
+=================
+*/
+void CheckIntermissionExit( void ) {
+	int			ready, notReady;
+	int			i;
+	gclient_t	*cl;
+	int			readyMask;
+
+	// see which players are ready
+	ready = 0;
+	notReady = 0;
+	readyMask = 0;
+	for (i=0 ; i< g_maxclients.integer ; i++) {
+		cl = level.clients + i;
+		if ( cl->pers.connected != CON_CONNECTED ) {
+			continue;
+		}
+		if ( g_entities[cl->ps.clientNum].r.svFlags & SVF_BOT ) {
+			continue;
+		}
+
+		if ( cl->readyToExit ) {
+			ready++;
+			if ( i < 16 ) {
+				readyMask |= 1 << i;
+			}
+		} else {
+			notReady++;
+		}
+	}
+
+	if ( (g_gametype.integer == GT_DUEL || g_gametype.integer == GT_POWERDUEL) && !gDidDuelStuff &&
+		(level.time > level.intermissiontime + 2000) )
+	{
+		gDidDuelStuff = qtrue;
+
+		if ( g_austrian.integer && g_gametype.integer != GT_POWERDUEL )
+		{
+			G_LogPrintf("Duel Results:\n");
+			//G_LogPrintf("Duel Time: %d\n", level.time );
+			G_LogPrintf("winner: %s, score: %d, wins/losses: %d/%d\n", 
+				level.clients[level.sortedClients[0]].pers.netname,
+				level.clients[level.sortedClients[0]].ps.persistant[PERS_SCORE],
+				level.clients[level.sortedClients[0]].sess.wins,
+				level.clients[level.sortedClients[0]].sess.losses );
+			G_LogPrintf("loser: %s, score: %d, wins/losses: %d/%d\n", 
+				level.clients[level.sortedClients[1]].pers.netname,
+				level.clients[level.sortedClients[1]].ps.persistant[PERS_SCORE],
+				level.clients[level.sortedClients[1]].sess.wins,
+				level.clients[level.sortedClients[1]].sess.losses );
+		}
+		// if we are running a tournement map, kick the loser to spectator status,
+		// which will automatically grab the next spectator and restart
+		if (!DuelLimitHit())
+		{
+			if (g_gametype.integer == GT_POWERDUEL)
+			{
+				RemovePowerDuelLosers();
+				AddPowerDuelPlayers();
+			}
+			else
+			{
+				if (level.clients[level.sortedClients[0]].ps.persistant[PERS_SCORE] ==
+					level.clients[level.sortedClients[1]].ps.persistant[PERS_SCORE] &&
+					level.clients[level.sortedClients[0]].pers.connected == CON_CONNECTED &&
+					level.clients[level.sortedClients[1]].pers.connected == CON_CONNECTED)
+				{
+					RemoveDuelDrawLoser();
+				}
+				else
+				{
+					RemoveTournamentLoser();
+				}
+				AddTournamentPlayer();
+			}
+
+			if ( g_austrian.integer )
+			{
+				if (g_gametype.integer == GT_POWERDUEL)
+				{
+					G_LogPrintf("Power Duel Initiated: %s %d/%d vs %s %d/%d and %s %d/%d, kill limit: %d\n", 
+						level.clients[level.sortedClients[0]].pers.netname,
+						level.clients[level.sortedClients[0]].sess.wins,
+						level.clients[level.sortedClients[0]].sess.losses,
+						level.clients[level.sortedClients[1]].pers.netname,
+						level.clients[level.sortedClients[1]].sess.wins,
+						level.clients[level.sortedClients[1]].sess.losses,
+						level.clients[level.sortedClients[2]].pers.netname,
+						level.clients[level.sortedClients[2]].sess.wins,
+						level.clients[level.sortedClients[2]].sess.losses,
+						g_fraglimit.integer );
+				}
+				else
+				{
+					G_LogPrintf("Duel Initiated: %s %d/%d vs %s %d/%d, kill limit: %d\n", 
+						level.clients[level.sortedClients[0]].pers.netname,
+						level.clients[level.sortedClients[0]].sess.wins,
+						level.clients[level.sortedClients[0]].sess.losses,
+						level.clients[level.sortedClients[1]].pers.netname,
+						level.clients[level.sortedClients[1]].sess.wins,
+						level.clients[level.sortedClients[1]].sess.losses,
+						g_fraglimit.integer );
+				}
+			}
+			
+			if (g_gametype.integer == GT_POWERDUEL)
+			{
+				if (level.numPlayingClients >= 3 && level.numNonSpectatorClients >= 3)
+				{
+					trap_SetConfigstring ( CS_CLIENT_DUELISTS, va("%i|%i|%i", level.sortedClients[0], level.sortedClients[1], level.sortedClients[2] ) );
+					trap_SetConfigstring ( CS_CLIENT_DUELWINNER, "-1" );
+				}			
+			}
+			else
+			{
+				if (level.numPlayingClients >= 2)
+				{
+					trap_SetConfigstring ( CS_CLIENT_DUELISTS, va("%i|%i", level.sortedClients[0], level.sortedClients[1] ) );
+					trap_SetConfigstring ( CS_CLIENT_DUELWINNER, "-1" );
+				}
+			}
+
+			return;	
+		}
+
+		if ( g_austrian.integer && g_gametype.integer != GT_POWERDUEL )
+		{
+			G_LogPrintf("Duel Tournament Winner: %s wins/losses: %d/%d\n", 
+				level.clients[level.sortedClients[0]].pers.netname,
+				level.clients[level.sortedClients[0]].sess.wins,
+				level.clients[level.sortedClients[0]].sess.losses );
+		}
+
+		if (g_gametype.integer == GT_POWERDUEL)
+		{
+			RemovePowerDuelLosers();
+			AddPowerDuelPlayers();
+
+			if (level.numPlayingClients >= 3 && level.numNonSpectatorClients >= 3)
+			{
+				trap_SetConfigstring ( CS_CLIENT_DUELISTS, va("%i|%i|%i", level.sortedClients[0], level.sortedClients[1], level.sortedClients[2] ) );
+				trap_SetConfigstring ( CS_CLIENT_DUELWINNER, "-1" );
+			}
+		}
+		else
+		{
+			//this means we hit the duel limit so reset the wins/losses
+			//but still push the loser to the back of the line, and retain the order for
+			//the map change
+			if (level.clients[level.sortedClients[0]].ps.persistant[PERS_SCORE] ==
+				level.clients[level.sortedClients[1]].ps.persistant[PERS_SCORE] &&
+				level.clients[level.sortedClients[0]].pers.connected == CON_CONNECTED &&
+				level.clients[level.sortedClients[1]].pers.connected == CON_CONNECTED)
+			{
+				RemoveDuelDrawLoser();
+			}
+			else
+			{
+				RemoveTournamentLoser();
+			}
+
+			AddTournamentPlayer();
+
+			if (level.numPlayingClients >= 2)
+			{
+				trap_SetConfigstring ( CS_CLIENT_DUELISTS, va("%i|%i", level.sortedClients[0], level.sortedClients[1] ) );
+				trap_SetConfigstring ( CS_CLIENT_DUELWINNER, "-1" );
+			}
+		}
+	}
+
+	if ((g_gametype.integer == GT_DUEL || g_gametype.integer == GT_POWERDUEL) && !gDuelExit)
+	{ //in duel, we have different behaviour for between-round intermissions
+		if ( level.time > level.intermissiontime + 4000 )
+		{ //automatically go to next after 4 seconds
+			ExitLevel();
+			return;
+		}
+
+		for (i=0 ; i< g_maxclients.integer ; i++)
+		{ //being in a "ready" state is not necessary here, so clear it for everyone
+		  //yes, I also thinking holding this in a ps value uniquely for each player
+		  //is bad and wrong, but it wasn't my idea.
+			cl = level.clients + i;
+			if ( cl->pers.connected != CON_CONNECTED )
+			{
+				continue;
+			}
+			cl->ps.stats[STAT_CLIENTS_READY] = 0;
+		}
+		return;
+	}
+
+	// copy the readyMask to each player's stats so
+	// it can be displayed on the scoreboard
+	for (i=0 ; i< g_maxclients.integer ; i++) {
+		cl = level.clients + i;
+		if ( cl->pers.connected != CON_CONNECTED ) {
+			continue;
+		}
+		cl->ps.stats[STAT_CLIENTS_READY] = readyMask;
+	}
+
+	// never exit in less than five seconds
+	if ( level.time < level.intermissiontime + 5000 ) {
+		return;
+	}
+
+	if (d_noIntermissionWait.integer)
+	{ //don't care who wants to go, just go.
+		ExitLevel();
+		return;
+	}
+
+	// if nobody wants to go, clear timer
+	if ( !ready ) {
+		level.readyToExit = qfalse;
+		return;
+	}
+
+	// if everyone wants to go, go now
+	if ( !notReady ) {
+		ExitLevel();
+		return;
+	}
+
+	// the first person to ready starts the ten second timeout
+	if ( !level.readyToExit ) {
+		level.readyToExit = qtrue;
+		level.exitTime = level.time;
+	}
+
+	// if we have waited ten seconds since at least one player
+	// wanted to exit, go ahead
+	if ( level.time < level.exitTime + 10000 ) {
+		return;
+	}
+
+	ExitLevel();
+}
+
+/*
+=============
+ScoreIsTied
+=============
+*/
+qboolean ScoreIsTied( void ) {
+	int		a, b;
+
+	if ( level.numPlayingClients < 2 ) {
+		return qfalse;
+	}
+	
+	if ( g_gametype.integer >= GT_TEAM ) {
+		return level.teamScores[TEAM_RED] == level.teamScores[TEAM_BLUE];
+	}
+
+	a = level.clients[level.sortedClients[0]].ps.persistant[PERS_SCORE];
+	b = level.clients[level.sortedClients[1]].ps.persistant[PERS_SCORE];
+
+	return a == b;
+}
+
+/*
+=================
+CheckExitRules
+
+There will be a delay between the time the exit is qualified for
+and the time everyone is moved to the intermission spot, so you
+can see the last frag.
+=================
+*/
+qboolean g_endPDuel = qfalse;
+void CheckExitRules( void ) {
+ 	int			i;
+	gclient_t	*cl;
+	char *sKillLimit;
+	qboolean printLimit = qtrue;
+	// if at the intermission, wait for all non-bots to
+	// signal ready, then go to next level
+	if ( level.intermissiontime ) {
+		CheckIntermissionExit ();
+		return;
+	}
+
+	if (gDoSlowMoDuel)
+	{ //don't go to intermission while in slow motion
+		return;
+	}
+
+	if (gEscaping)
+	{
+		int i = 0;
+		int numLiveClients = 0;
+
+		while (i < MAX_CLIENTS)
+		{
+			if (g_entities[i].inuse && g_entities[i].client && g_entities[i].health > 0)
+			{
+				if (g_entities[i].client->sess.sessionTeam != TEAM_SPECTATOR &&
+					!(g_entities[i].client->ps.pm_flags & PMF_FOLLOW))
+				{
+					numLiveClients++;
+				}
+			}
+
+			i++;
+		}
+		if (gEscapeTime < level.time)
+		{
+			gEscaping = qfalse;
+			LogExit( "Escape time ended." );
+			return;
+		}
+		if (!numLiveClients)
+		{
+			gEscaping = qfalse;
+			LogExit( "Everyone failed to escape." );
+			return;
+		}
+	}
+
+	if ( level.intermissionQueued ) {
+		//int time = (g_singlePlayer.integer) ? SP_INTERMISSION_DELAY_TIME : INTERMISSION_DELAY_TIME;
+		int time = INTERMISSION_DELAY_TIME;
+		if ( level.time - level.intermissionQueued >= time ) {
+			level.intermissionQueued = 0;
+			BeginIntermission();
+		}
+		return;
+	}
+
+	/*
+	if (g_gametype.integer == GT_POWERDUEL)
+	{
+		if (level.numPlayingClients < 3)
+		{
+			if (!level.intermissiontime)
+			{
+				if (d_powerDuelPrint.integer)
+				{
+					Com_Printf("POWERDUEL WIN CONDITION: Duel forfeit (1)\n");
+				}
+				LogExit("Duel forfeit.");
+				return;
+			}
+		}
+	}
+	*/
+
+	// check for sudden death
+	if (g_gametype.integer != GT_SIEGE)
+	{
+		if ( ScoreIsTied() ) {
+			// always wait for sudden death
+			if ((g_gametype.integer != GT_DUEL) || !g_timelimit.integer)
+			{
+				if (g_gametype.integer != GT_POWERDUEL)
+				{
+					return;
+				}
+			}
+		}
+	}
+
+	if (g_gametype.integer != GT_SIEGE)
+	{
+		if ( g_timelimit.integer && !level.warmupTime ) {
+			if ( level.time - level.startTime >= g_timelimit.integer*60000 ) {
+//				trap_SendServerCommand( -1, "print \"Timelimit hit.\n\"");
+				trap_SendServerCommand( -1, va("print \"%s.\n\"",G_GetStringEdString("MP_SVGAME", "TIMELIMIT_HIT")));
+				if (d_powerDuelPrint.integer)
+				{
+					Com_Printf("POWERDUEL WIN CONDITION: Timelimit hit (1)\n");
+				}
+				LogExit( "Timelimit hit." );
+				return;
+			}
+		}
+	}
+
+	if (g_gametype.integer == GT_POWERDUEL && level.numPlayingClients >= 3)
+	{
+		if (g_endPDuel)
+		{
+			g_endPDuel = qfalse;
+			LogExit("Powerduel ended.");
+		}
+
+		//yeah, this stuff was completely insane.
+		/*
+		int duelists[3];
+		duelists[0] = level.sortedClients[0];
+		duelists[1] = level.sortedClients[1];
+		duelists[2] = level.sortedClients[2];
+
+		if (duelists[0] != -1 &&
+			duelists[1] != -1 &&
+			duelists[2] != -1)
+		{
+			if (!g_entities[duelists[0]].inuse ||
+				!g_entities[duelists[0]].client ||
+				g_entities[duelists[0]].client->ps.stats[STAT_HEALTH] <= 0 ||
+				g_entities[duelists[0]].client->sess.sessionTeam != TEAM_FREE)
+			{ //The lone duelist lost, give the other two wins (if applicable) and him a loss
+				if (g_entities[duelists[0]].inuse &&
+					g_entities[duelists[0]].client)
+				{
+					g_entities[duelists[0]].client->sess.losses++;
+					ClientUserinfoChanged(duelists[0]);
+				}
+				if (g_entities[duelists[1]].inuse &&
+					g_entities[duelists[1]].client)
+				{
+					if (g_entities[duelists[1]].client->ps.stats[STAT_HEALTH] > 0 &&
+						g_entities[duelists[1]].client->sess.sessionTeam == TEAM_FREE)
+					{
+						g_entities[duelists[1]].client->sess.wins++;
+					}
+					else
+					{
+						g_entities[duelists[1]].client->sess.losses++;
+					}
+					ClientUserinfoChanged(duelists[1]);
+				}
+				if (g_entities[duelists[2]].inuse &&
+					g_entities[duelists[2]].client)
+				{
+					if (g_entities[duelists[2]].client->ps.stats[STAT_HEALTH] > 0 &&
+						g_entities[duelists[2]].client->sess.sessionTeam == TEAM_FREE)
+					{
+						g_entities[duelists[2]].client->sess.wins++;
+					}
+					else
+					{
+						g_entities[duelists[2]].client->sess.losses++;
+					}
+					ClientUserinfoChanged(duelists[2]);
+				}
+
+				//Will want to parse indecies for two out at some point probably
+				trap_SetConfigstring ( CS_CLIENT_DUELWINNER, va("%i", duelists[1] ) );
+
+				if (d_powerDuelPrint.integer)
+				{
+					Com_Printf("POWERDUEL WIN CONDITION: Coupled duelists won (1)\n");
+				}
+				LogExit( "Coupled duelists won." );
+				gDuelExit = qfalse;
+			}
+			else if ((!g_entities[duelists[1]].inuse ||
+				!g_entities[duelists[1]].client ||
+				g_entities[duelists[1]].client->sess.sessionTeam != TEAM_FREE ||
+				g_entities[duelists[1]].client->ps.stats[STAT_HEALTH] <= 0) &&
+				(!g_entities[duelists[2]].inuse ||
+				!g_entities[duelists[2]].client ||
+				g_entities[duelists[2]].client->sess.sessionTeam != TEAM_FREE ||
+				g_entities[duelists[2]].client->ps.stats[STAT_HEALTH] <= 0))
+			{ //the coupled duelists lost, give the lone duelist a win (if applicable) and the couple both losses
+				if (g_entities[duelists[1]].inuse &&
+					g_entities[duelists[1]].client)
+				{
+					g_entities[duelists[1]].client->sess.losses++;
+					ClientUserinfoChanged(duelists[1]);
+				}
+				if (g_entities[duelists[2]].inuse &&
+					g_entities[duelists[2]].client)
+				{
+					g_entities[duelists[2]].client->sess.losses++;
+					ClientUserinfoChanged(duelists[2]);
+				}
+
+				if (g_entities[duelists[0]].inuse &&
+					g_entities[duelists[0]].client &&
+					g_entities[duelists[0]].client->ps.stats[STAT_HEALTH] > 0 &&
+					g_entities[duelists[0]].client->sess.sessionTeam == TEAM_FREE)
+				{
+					g_entities[duelists[0]].client->sess.wins++;
+					ClientUserinfoChanged(duelists[0]);
+				}
+
+				trap_SetConfigstring ( CS_CLIENT_DUELWINNER, va("%i", duelists[0] ) );
+
+				if (d_powerDuelPrint.integer)
+				{
+					Com_Printf("POWERDUEL WIN CONDITION: Lone duelist won (1)\n");
+				}
+				LogExit( "Lone duelist won." );
+				gDuelExit = qfalse;
+			}
+		}
+		*/
+		return;
+	}
+
+	if ( level.numPlayingClients < 2 ) {
+		return;
+	}
+
+	if (g_gametype.integer == GT_DUEL ||
+		g_gametype.integer == GT_POWERDUEL)
+	{
+		if (g_fraglimit.integer > 1)
+		{
+			sKillLimit = "Kill limit hit.";
+		}
+		else
+		{
+			sKillLimit = "";
+			printLimit = qfalse;
+		}
+	}
+	else
+	{
+		sKillLimit = "Kill limit hit.";
+	}
+	if ( g_gametype.integer < GT_SIEGE && g_fraglimit.integer ) {
+		if ( level.teamScores[TEAM_RED] >= g_fraglimit.integer ) {
+			trap_SendServerCommand( -1, va("print \"Red %s\n\"", G_GetStringEdString("MP_SVGAME", "HIT_THE_KILL_LIMIT")) );
+			if (d_powerDuelPrint.integer)
+			{
+				Com_Printf("POWERDUEL WIN CONDITION: Kill limit (1)\n");
+			}
+			LogExit( sKillLimit );
+			return;
+		}
+
+		if ( level.teamScores[TEAM_BLUE] >= g_fraglimit.integer ) {
+			trap_SendServerCommand( -1, va("print \"Blue %s\n\"", G_GetStringEdString("MP_SVGAME", "HIT_THE_KILL_LIMIT")) );
+			if (d_powerDuelPrint.integer)
+			{
+				Com_Printf("POWERDUEL WIN CONDITION: Kill limit (2)\n");
+			}
+			LogExit( sKillLimit );
+			return;
+		}
+
+		for ( i=0 ; i< g_maxclients.integer ; i++ ) {
+			cl = level.clients + i;
+			if ( cl->pers.connected != CON_CONNECTED ) {
+				continue;
+			}
+			if ( cl->sess.sessionTeam != TEAM_FREE ) {
+				continue;
+			}
+
+			if ( (g_gametype.integer == GT_DUEL || g_gametype.integer == GT_POWERDUEL) && g_duel_fraglimit.integer && cl->sess.wins >= g_duel_fraglimit.integer )
+			{
+				if (d_powerDuelPrint.integer)
+				{
+					Com_Printf("POWERDUEL WIN CONDITION: Duel limit hit (1)\n");
+				}
+				LogExit( "Duel limit hit." );
+				gDuelExit = qtrue;
+				trap_SendServerCommand( -1, va("print \"%s" S_COLOR_WHITE " hit the win limit.\n\"",
+					cl->pers.netname ) );
+				return;
+			}
+
+			if ( cl->ps.persistant[PERS_SCORE] >= g_fraglimit.integer ) {
+				if (d_powerDuelPrint.integer)
+				{
+					Com_Printf("POWERDUEL WIN CONDITION: Kill limit (3)\n");
+				}
+				LogExit( sKillLimit );
+				gDuelExit = qfalse;
+				if (printLimit)
+				{
+					trap_SendServerCommand( -1, va("print \"%s" S_COLOR_WHITE " %s.\n\"",
+													cl->pers.netname,
+													G_GetStringEdString("MP_SVGAME", "HIT_THE_KILL_LIMIT")
+													) 
+											);
+				}
+				return;
+			}
+		}
+	}
+
+	if ( g_gametype.integer >= GT_CTF && g_capturelimit.integer ) {
+
+		if ( level.teamScores[TEAM_RED] >= g_capturelimit.integer ) 
+		{
+			trap_SendServerCommand( -1,  va("print \"%s \"", G_GetStringEdString("MP_SVGAME", "PRINTREDTEAM")));
+			trap_SendServerCommand( -1,  va("print \"%s.\n\"", G_GetStringEdString("MP_SVGAME", "HIT_CAPTURE_LIMIT")));
+			LogExit( "Capturelimit hit." );
+			return;
+		}
+
+		if ( level.teamScores[TEAM_BLUE] >= g_capturelimit.integer ) {
+			trap_SendServerCommand( -1,  va("print \"%s \"", G_GetStringEdString("MP_SVGAME", "PRINTBLUETEAM")));
+			trap_SendServerCommand( -1,  va("print \"%s.\n\"", G_GetStringEdString("MP_SVGAME", "HIT_CAPTURE_LIMIT")));
+			LogExit( "Capturelimit hit." );
+			return;
+		}
+	}
+}
+
+
+
+/*
+========================================================================
+
+FUNCTIONS CALLED EVERY FRAME
+
+========================================================================
+*/
+
+void G_RemoveDuelist(int team)
+{
+	int i = 0;
+	gentity_t *ent;
+	while (i < MAX_CLIENTS)
+	{
+		ent = &g_entities[i];
+
+		if (ent->inuse && ent->client && ent->client->sess.sessionTeam != TEAM_SPECTATOR &&
+			ent->client->sess.duelTeam == team)
+		{
+			SetTeam(ent, "s");
+		}
+        i++;
+	}
+}
+
+/*
+=============
+CheckTournament
+
+Once a frame, check for changes in tournement player state
+=============
+*/
+int g_duelPrintTimer = 0;
+void CheckTournament( void ) {
+	// check because we run 3 game frames before calling Connect and/or ClientBegin
+	// for clients on a map_restart
+//	if ( level.numPlayingClients == 0 && (g_gametype.integer != GT_POWERDUEL) ) {
+//		return;
+//	}
+
+	if (g_gametype.integer == GT_POWERDUEL)
+	{
+		if (level.numPlayingClients >= 3 && level.numNonSpectatorClients >= 3)
+		{
+			trap_SetConfigstring ( CS_CLIENT_DUELISTS, va("%i|%i|%i", level.sortedClients[0], level.sortedClients[1], level.sortedClients[2] ) );
+		}
+	}
+	else
+	{
+		if (level.numPlayingClients >= 2)
+		{
+			trap_SetConfigstring ( CS_CLIENT_DUELISTS, va("%i|%i", level.sortedClients[0], level.sortedClients[1] ) );
+		}
+	}
+
+	if ( g_gametype.integer == GT_DUEL )
+	{
+		// pull in a spectator if needed
+		if ( level.numPlayingClients < 2 && !level.intermissiontime && !level.intermissionQueued ) {
+			AddTournamentPlayer();
+
+			if (level.numPlayingClients >= 2)
+			{
+				trap_SetConfigstring ( CS_CLIENT_DUELISTS, va("%i|%i", level.sortedClients[0], level.sortedClients[1] ) );
+			}
+		}
+
+		if (level.numPlayingClients >= 2)
+		{
+// nmckenzie: DUEL_HEALTH
+			if ( g_showDuelHealths.integer >= 1 )
+			{
+				playerState_t *ps1, *ps2;
+				ps1 = &level.clients[level.sortedClients[0]].ps;
+				ps2 = &level.clients[level.sortedClients[1]].ps;
+				trap_SetConfigstring ( CS_CLIENT_DUELHEALTHS, va("%i|%i|!", 
+					ps1->stats[STAT_HEALTH], ps2->stats[STAT_HEALTH]));
+			}
+		}
+
+		//rww - It seems we have decided there will be no warmup in duel.
+		//if (!g_warmup.integer)
+		{ //don't care about any of this stuff then, just add people and leave me alone
+			level.warmupTime = 0;
+			return;
+		}
+#if 0
+		// if we don't have two players, go back to "waiting for players"
+		if ( level.numPlayingClients != 2 ) {
+			if ( level.warmupTime != -1 ) {
+				level.warmupTime = -1;
+				trap_SetConfigstring( CS_WARMUP, va("%i", level.warmupTime) );
+				G_LogPrintf( "Warmup:\n" );
+			}
+			return;
+		}
+
+		if ( level.warmupTime == 0 ) {
+			return;
+		}
+
+		// if the warmup is changed at the console, restart it
+		if ( g_warmup.modificationCount != level.warmupModificationCount ) {
+			level.warmupModificationCount = g_warmup.modificationCount;
+			level.warmupTime = -1;
+		}
+
+		// if all players have arrived, start the countdown
+		if ( level.warmupTime < 0 ) {
+			if ( level.numPlayingClients == 2 ) {
+				// fudge by -1 to account for extra delays
+				level.warmupTime = level.time + ( g_warmup.integer - 1 ) * 1000;
+
+				if (level.warmupTime < (level.time + 3000))
+				{ //rww - this is an unpleasent hack to keep the level from resetting completely on the client (this happens when two map_restarts are issued rapidly)
+					level.warmupTime = level.time + 3000;
+				}
+				trap_SetConfigstring( CS_WARMUP, va("%i", level.warmupTime) );
+			}
+			return;
+		}
+
+		// if the warmup time has counted down, restart
+		if ( level.time > level.warmupTime ) {
+			level.warmupTime += 10000;
+			trap_Cvar_Set( "g_restarted", "1" );
+			trap_SendConsoleCommand( EXEC_APPEND, "map_restart 0\n" );
+			level.restarted = qtrue;
+			return;
+		}
+#endif
+	}
+	else if (g_gametype.integer == GT_POWERDUEL)
+	{
+		if (level.numPlayingClients < 2)
+		{ //hmm, ok, pull more in.
+			g_dontFrickinCheck = qfalse;
+		}
+
+		if (level.numPlayingClients > 3)
+		{ //umm..yes..lets take care of that then.
+			int lone = 0, dbl = 0;
+
+			G_PowerDuelCount(&lone, &dbl, qfalse);
+			if (lone > 1)
+			{
+				G_RemoveDuelist(DUELTEAM_LONE);
+			}
+			else if (dbl > 2)
+			{
+				G_RemoveDuelist(DUELTEAM_DOUBLE);
+			}
+		}
+		else if (level.numPlayingClients < 3)
+		{ //hmm, someone disconnected or something and we need em
+			int lone = 0, dbl = 0;
+
+			G_PowerDuelCount(&lone, &dbl, qfalse);
+			if (lone < 1)
+			{
+				g_dontFrickinCheck = qfalse;
+			}
+			else if (dbl < 1)
+			{
+				g_dontFrickinCheck = qfalse;
+			}
+		}
+
+		// pull in a spectator if needed
+		if (level.numPlayingClients < 3 && !g_dontFrickinCheck)
+		{
+			AddPowerDuelPlayers();
+
+			if (level.numPlayingClients >= 3 &&
+				G_CanResetDuelists())
+			{
+				gentity_t *te = G_TempEntity(vec3_origin, EV_GLOBAL_DUEL);
+				te->r.svFlags |= SVF_BROADCAST;
+				//this is really pretty nasty, but..
+				te->s.otherEntityNum = level.sortedClients[0];
+				te->s.otherEntityNum2 = level.sortedClients[1];
+				te->s.groundEntityNum = level.sortedClients[2];
+
+				trap_SetConfigstring ( CS_CLIENT_DUELISTS, va("%i|%i|%i", level.sortedClients[0], level.sortedClients[1], level.sortedClients[2] ) );
+				G_ResetDuelists();
+
+				g_dontFrickinCheck = qtrue;
+			}
+			else if (level.numPlayingClients > 0 ||
+				level.numConnectedClients > 0)
+			{
+				if (g_duelPrintTimer < level.time)
+				{ //print once every 10 seconds
+					int lone = 0, dbl = 0;
+
+					G_PowerDuelCount(&lone, &dbl, qtrue);
+					if (lone < 1)
+					{
+						trap_SendServerCommand( -1, va("cp \"%s\n\"", G_GetStringEdString("MP_SVGAME", "DUELMORESINGLE")) );
+					}
+					else
+					{
+						trap_SendServerCommand( -1, va("cp \"%s\n\"", G_GetStringEdString("MP_SVGAME", "DUELMOREPAIRED")) );
+					}
+					g_duelPrintTimer = level.time + 10000;
+				}
+			}
+
+			if (level.numPlayingClients >= 3 && level.numNonSpectatorClients >= 3)
+			{ //pulled in a needed person
+				if (G_CanResetDuelists())
+				{
+					gentity_t *te = G_TempEntity(vec3_origin, EV_GLOBAL_DUEL);
+					te->r.svFlags |= SVF_BROADCAST;
+					//this is really pretty nasty, but..
+					te->s.otherEntityNum = level.sortedClients[0];
+					te->s.otherEntityNum2 = level.sortedClients[1];
+					te->s.groundEntityNum = level.sortedClients[2];
+
+					trap_SetConfigstring ( CS_CLIENT_DUELISTS, va("%i|%i|%i", level.sortedClients[0], level.sortedClients[1], level.sortedClients[2] ) );
+
+					if ( g_austrian.integer )
+					{
+						G_LogPrintf("Duel Initiated: %s %d/%d vs %s %d/%d and %s %d/%d, kill limit: %d\n", 
+							level.clients[level.sortedClients[0]].pers.netname,
+							level.clients[level.sortedClients[0]].sess.wins,
+							level.clients[level.sortedClients[0]].sess.losses,
+							level.clients[level.sortedClients[1]].pers.netname,
+							level.clients[level.sortedClients[1]].sess.wins,
+							level.clients[level.sortedClients[1]].sess.losses,
+							level.clients[level.sortedClients[2]].pers.netname,
+							level.clients[level.sortedClients[2]].sess.wins,
+							level.clients[level.sortedClients[2]].sess.losses,
+							g_fraglimit.integer );
+					}
+					//trap_SendConsoleCommand( EXEC_APPEND, "map_restart 0\n" );
+					//FIXME: This seems to cause problems. But we'd like to reset things whenever a new opponent is set.
+				}
+			}
+		}
+		else
+		{ //if you have proper num of players then don't try to add again
+			g_dontFrickinCheck = qtrue;
+		}
+
+		level.warmupTime = 0;
+		return;
+	}
+	else if ( level.warmupTime != 0 ) {
+		int		counts[TEAM_NUM_TEAMS];
+		qboolean	notEnough = qfalse;
+
+		if ( g_gametype.integer > GT_TEAM ) {
+			counts[TEAM_BLUE] = TeamCount( -1, TEAM_BLUE );
+			counts[TEAM_RED] = TeamCount( -1, TEAM_RED );
+
+			if (counts[TEAM_RED] < 1 || counts[TEAM_BLUE] < 1) {
+				notEnough = qtrue;
+			}
+		} else if ( level.numPlayingClients < 2 ) {
+			notEnough = qtrue;
+		}
+
+		if ( notEnough ) {
+			if ( level.warmupTime != -1 ) {
+				level.warmupTime = -1;
+				trap_SetConfigstring( CS_WARMUP, va("%i", level.warmupTime) );
+				G_LogPrintf( "Warmup:\n" );
+			}
+			return; // still waiting for team members
+		}
+
+		if ( level.warmupTime == 0 ) {
+			return;
+		}
+
+		// if the warmup is changed at the console, restart it
+		/*
+		if ( g_warmup.modificationCount != level.warmupModificationCount ) {
+			level.warmupModificationCount = g_warmup.modificationCount;
+			level.warmupTime = -1;
+		}
+		*/
+
+		// if all players have arrived, start the countdown
+		if ( level.warmupTime < 0 ) {
+			// fudge by -1 to account for extra delays
+			level.warmupTime = level.time + ( g_warmup.integer - 1 ) * 1000;
+			trap_SetConfigstring( CS_WARMUP, va("%i", level.warmupTime) );
+			return;
+		}
+
+		// if the warmup time has counted down, restart
+		if ( level.time > level.warmupTime ) {
+			level.warmupTime += 10000;
+			trap_Cvar_Set( "g_restarted", "1" );
+			trap_SendConsoleCommand( EXEC_APPEND, "map_restart 0\n" );
+			level.restarted = qtrue;
+			return;
+		}
+	}
+}
+
+void G_KickAllBots(void)
+{
+	int i;
+	char netname[36];
+	gclient_t	*cl;
+
+	for ( i=0 ; i< g_maxclients.integer ; i++ )
+	{
+		cl = level.clients + i;
+		if ( cl->pers.connected != CON_CONNECTED )
+		{
+			continue;
+		}
+		if ( !(g_entities[cl->ps.clientNum].r.svFlags & SVF_BOT) )
+		{
+			continue;
+		}
+		strcpy(netname, cl->pers.netname);
+		Q_CleanStr(netname);
+		trap_SendConsoleCommand( EXEC_INSERT, va("kick \"%s\"\n", netname) );
+	}
+}
+
+/*
+==================
+CheckVote
+==================
+*/
+void CheckVote( void ) {
+	if ( level.voteExecuteTime && level.voteExecuteTime < level.time ) {
+		level.voteExecuteTime = 0;
+		trap_SendConsoleCommand( EXEC_APPEND, va("%s\n", level.voteString ) );
+
+		if (level.votingGametype)
+		{
+			if (trap_Cvar_VariableIntegerValue("g_gametype") != level.votingGametypeTo)
+			{ //If we're voting to a different game type, be sure to refresh all the map stuff
+				const char *nextMap = G_RefreshNextMap(level.votingGametypeTo, qtrue);
+
+				if (level.votingGametypeTo == GT_SIEGE)
+				{ //ok, kick all the bots, cause the aren't supported!
+                    G_KickAllBots();
+					//just in case, set this to 0 too... I guess...maybe?
+					//trap_Cvar_Set("bot_minplayers", "0");
+				}
+
+				if (nextMap && nextMap[0])
+				{
+					trap_SendConsoleCommand( EXEC_APPEND, va("map %s\n", nextMap ) );
+				}
+			}
+			else
+			{ //otherwise, just leave the map until a restart
+				G_RefreshNextMap(level.votingGametypeTo, qfalse);
+			}
+
+			if (g_fraglimitVoteCorrection.integer)
+			{ //This means to auto-correct fraglimit when voting to and from duel.
+				int currentGT = trap_Cvar_VariableIntegerValue("g_gametype");
+				int currentFL = trap_Cvar_VariableIntegerValue("fraglimit");
+
+				if ((level.votingGametypeTo == GT_DUEL || level.votingGametypeTo == GT_POWERDUEL) && currentGT != GT_DUEL && currentGT != GT_POWERDUEL)
+				{
+					if (currentFL > 3 || !currentFL)
+					{ //if voting to duel, and fraglimit is more than 3 (or unlimited), then set it down to 3
+						trap_SendConsoleCommand(EXEC_APPEND, "fraglimit 3\n");
+					}
+				}
+				else if ((level.votingGametypeTo != GT_DUEL && level.votingGametypeTo != GT_POWERDUEL) &&
+					(currentGT == GT_DUEL || currentGT == GT_POWERDUEL))
+				{
+					if (currentFL && currentFL < 20)
+					{ //if voting from duel, an fraglimit is less than 20, then set it up to 20
+						trap_SendConsoleCommand(EXEC_APPEND, "fraglimit 20\n");
+					}
+				}
+			}
+
+			level.votingGametype = qfalse;
+			level.votingGametypeTo = 0;
+		}
+	}
+	if ( !level.voteTime ) {
+		return;
+	}
+	if ( level.time - level.voteTime >= VOTE_TIME ) {
+		trap_SendServerCommand( -1, va("print \"%s\n\"", G_GetStringEdString("MP_SVGAME", "VOTEFAILED")) );
+	} else {
+		if ( level.voteYes > level.numVotingClients/2 ) {
+			// execute the command, then remove the vote
+			trap_SendServerCommand( -1, va("print \"%s\n\"", G_GetStringEdString("MP_SVGAME", "VOTEPASSED")) );
+			level.voteExecuteTime = level.time + 3000;
+		} else if ( level.voteNo >= level.numVotingClients/2 ) {
+			// same behavior as a timeout
+			trap_SendServerCommand( -1, va("print \"%s\n\"", G_GetStringEdString("MP_SVGAME", "VOTEFAILED")) );
+		} else {
+			// still waiting for a majority
+			return;
+		}
+	}
+	level.voteTime = 0;
+	trap_SetConfigstring( CS_VOTE_TIME, "" );
+
+}
+
+/*
+==================
+PrintTeam
+==================
+*/
+void PrintTeam(int team, char *message) {
+	int i;
+
+	for ( i = 0 ; i < level.maxclients ; i++ ) {
+		if (level.clients[i].sess.sessionTeam != team)
+			continue;
+		trap_SendServerCommand( i, message );
+	}
+}
+
+/*
+==================
+SetLeader
+==================
+*/
+void SetLeader(int team, int client) {
+	int i;
+
+	if ( level.clients[client].pers.connected == CON_DISCONNECTED ) {
+		PrintTeam(team, va("print \"%s is not connected\n\"", level.clients[client].pers.netname) );
+		return;
+	}
+	if (level.clients[client].sess.sessionTeam != team) {
+		PrintTeam(team, va("print \"%s is not on the team anymore\n\"", level.clients[client].pers.netname) );
+		return;
+	}
+	for ( i = 0 ; i < level.maxclients ; i++ ) {
+		if (level.clients[i].sess.sessionTeam != team)
+			continue;
+		if (level.clients[i].sess.teamLeader) {
+			level.clients[i].sess.teamLeader = qfalse;
+			ClientUserinfoChanged(i);
+		}
+	}
+	level.clients[client].sess.teamLeader = qtrue;
+	ClientUserinfoChanged( client );
+	PrintTeam(team, va("print \"%s %s\n\"", level.clients[client].pers.netname, G_GetStringEdString("MP_SVGAME", "NEWTEAMLEADER")) );
+}
+
+/*
+==================
+CheckTeamLeader
+==================
+*/
+void CheckTeamLeader( int team ) {
+	int i;
+
+	for ( i = 0 ; i < level.maxclients ; i++ ) {
+		if (level.clients[i].sess.sessionTeam != team)
+			continue;
+		if (level.clients[i].sess.teamLeader)
+			break;
+	}
+	if (i >= level.maxclients) {
+		for ( i = 0 ; i < level.maxclients ; i++ ) {
+			if (level.clients[i].sess.sessionTeam != team)
+				continue;
+			if (!(g_entities[i].r.svFlags & SVF_BOT)) {
+				level.clients[i].sess.teamLeader = qtrue;
+				break;
+			}
+		}
+		for ( i = 0 ; i < level.maxclients ; i++ ) {
+			if (level.clients[i].sess.sessionTeam != team)
+				continue;
+			level.clients[i].sess.teamLeader = qtrue;
+			break;
+		}
+	}
+}
+
+/*
+==================
+CheckTeamVote
+==================
+*/
+void CheckTeamVote( int team ) {
+	int cs_offset;
+
+	if ( team == TEAM_RED )
+		cs_offset = 0;
+	else if ( team == TEAM_BLUE )
+		cs_offset = 1;
+	else
+		return;
+
+	if ( !level.teamVoteTime[cs_offset] ) {
+		return;
+	}
+	if ( level.time - level.teamVoteTime[cs_offset] >= VOTE_TIME ) {
+		trap_SendServerCommand( -1, va("print \"%s\n\"", G_GetStringEdString("MP_SVGAME", "TEAMVOTEFAILED")) );
+	} else {
+		if ( level.teamVoteYes[cs_offset] > level.numteamVotingClients[cs_offset]/2 ) {
+			// execute the command, then remove the vote
+			trap_SendServerCommand( -1, va("print \"%s\n\"", G_GetStringEdString("MP_SVGAME", "TEAMVOTEPASSED")) );
+			//
+			if ( !Q_strncmp( "leader", level.teamVoteString[cs_offset], 6) ) {
+				//set the team leader
+				//SetLeader(team, atoi(level.teamVoteString[cs_offset] + 7));
+			}
+			else {
+				trap_SendConsoleCommand( EXEC_APPEND, va("%s\n", level.teamVoteString[cs_offset] ) );
+			}
+		} else if ( level.teamVoteNo[cs_offset] >= level.numteamVotingClients[cs_offset]/2 ) {
+			// same behavior as a timeout
+			trap_SendServerCommand( -1, va("print \"%s\n\"", G_GetStringEdString("MP_SVGAME", "TEAMVOTEFAILED")) );
+		} else {
+			// still waiting for a majority
+			return;
+		}
+	}
+	level.teamVoteTime[cs_offset] = 0;
+	trap_SetConfigstring( CS_TEAMVOTE_TIME + cs_offset, "" );
+
+}
+
+
+/*
+==================
+CheckCvars
+==================
+*/
+void CheckCvars( void ) {
+	static int lastMod = -1;
+	
+	if ( g_password.modificationCount != lastMod ) {
+		char password[MAX_INFO_STRING];
+		char *c = password;
+		lastMod = g_password.modificationCount;
+		
+		strcpy( password, g_password.string );
+		while( *c )
+		{
+			if ( *c == '%' )
+			{
+				*c = '.';
+			}
+			c++;
+		}
+		trap_Cvar_Set("g_password", password );
+
+		if ( *g_password.string && Q_stricmp( g_password.string, "none" ) ) {
+			trap_Cvar_Set( "g_needpass", "1" );
+		} else {
+			trap_Cvar_Set( "g_needpass", "0" );
+		}
+	}
+}
+
+/*
+=============
+G_RunThink
+
+Runs thinking code for this frame if necessary
+=============
+*/
+void G_RunThink (gentity_t *ent) {
+	float	thinktime;
+
+	thinktime = ent->nextthink;
+	if (thinktime <= 0) {
+		goto runicarus;
+	}
+	if (thinktime > level.time) {
+		goto runicarus;
+	}
+	
+	ent->nextthink = 0;
+	if (!ent->think) {
+		//G_Error ( "NULL ent->think");
+		goto runicarus;
+	}
+	ent->think (ent);
+
+runicarus:
+	if ( ent->inuse )
+	{
+		trap_ICARUS_MaintainTaskManager(ent->s.number);
+	}
+}
+
+int g_LastFrameTime = 0;
+int g_TimeSinceLastFrame = 0;
+
+qboolean gDoSlowMoDuel = qfalse;
+int gSlowMoDuelTime = 0;
+
+//#define _G_FRAME_PERFANAL
+
+void NAV_CheckCalcPaths( void )
+{	
+	if ( navCalcPathTime && navCalcPathTime < level.time )
+	{//first time we've ever loaded this map...
+		vmCvar_t	mapname;
+		vmCvar_t	ckSum;
+
+		trap_Cvar_Register( &mapname, "mapname", "", CVAR_SERVERINFO | CVAR_ROM );
+		trap_Cvar_Register( &ckSum, "sv_mapChecksum", "", CVAR_ROM );
+
+		//clear all the failed edges
+		trap_Nav_ClearAllFailedEdges();
+
+		//Calculate all paths
+		NAV_CalculatePaths( mapname.string, ckSum.integer );
+		
+		trap_Nav_CalculatePaths(qfalse);
+
+#ifndef FINAL_BUILD
+		if ( fatalErrors )
+		{
+			Com_Printf( S_COLOR_RED"Not saving .nav file due to fatal nav errors\n" );
+		}
+		else 
+#endif
+#ifndef _XBOX
+		if ( trap_Nav_Save( mapname.string, ckSum.integer ) == qfalse )
+		{
+			Com_Printf("Unable to save navigations data for map \"%s\" (checksum:%d)\n", mapname.string, ckSum.integer );
+		}
+#endif
+		navCalcPathTime = 0;
+	}
+}
+
+//so shared code can get the local time depending on the side it's executed on
+#include "../namespace_begin.h"
+int BG_GetTime(void)
+{
+	return level.time;
+}
+#include "../namespace_end.h"
+
+/*
+================
+G_RunFrame
+
+Advances the non-player objects in the world
+================
+*/
+void ClearNPCGlobals( void );
+void AI_UpdateGroups( void );
+void ClearPlayerAlertEvents( void );
+void SiegeCheckTimers(void);
+void WP_SaberStartMissileBlockCheck( gentity_t *self, usercmd_t *ucmd );
+extern void Jedi_Decloak( gentity_t *self );
+qboolean G_PointInBounds( vec3_t point, vec3_t mins, vec3_t maxs );
+
+int g_siegeRespawnCheck = 0;
+
+void G_RunFrame( int levelTime ) {
+	int			i;
+	gentity_t	*ent;
+	int			msec;
+#ifdef _G_FRAME_PERFANAL
+	int			iTimer_ItemRun = 0;
+	int			iTimer_ROFF = 0;
+	int			iTimer_ClientEndframe = 0;
+	int			iTimer_GameChecks = 0;
+	int			iTimer_Queues = 0;
+	void		*timer_ItemRun;
+	void		*timer_ROFF;
+	void		*timer_ClientEndframe;
+	void		*timer_GameChecks;
+	void		*timer_Queues;
+#endif
+
+	if (g_gametype.integer == GT_SIEGE &&
+		g_siegeRespawn.integer &&
+		g_siegeRespawnCheck < level.time)
+	{ //check for a respawn wave
+		int i = 0;
+		gentity_t *clEnt;
+		while (i < MAX_CLIENTS)
+		{
+			clEnt = &g_entities[i];
+
+			if (clEnt->inuse && clEnt->client &&
+				clEnt->client->tempSpectate > level.time &&
+				clEnt->client->sess.sessionTeam != TEAM_SPECTATOR)
+			{
+				respawn(clEnt);
+				clEnt->client->tempSpectate = 0;
+			}
+			i++;
+		}
+
+		g_siegeRespawnCheck = level.time + g_siegeRespawn.integer * 1000;
+	}
+
+	if (gDoSlowMoDuel)
+	{
+		if (level.restarted)
+		{
+			char buf[128];
+			float tFVal = 0;
+
+			trap_Cvar_VariableStringBuffer("timescale", buf, sizeof(buf));
+
+			tFVal = atof(buf);
+
+			trap_Cvar_Set("timescale", "1");
+			if (tFVal == 1.0f)
+			{
+				gDoSlowMoDuel = qfalse;
+			}
+		}
+		else
+		{
+			float timeDif = (level.time - gSlowMoDuelTime); //difference in time between when the slow motion was initiated and now
+			float useDif = 0; //the difference to use when actually setting the timescale
+
+			if (timeDif < 150)
+			{
+				trap_Cvar_Set("timescale", "0.1f");
+			}
+			else if (timeDif < 1150)
+			{
+				useDif = (timeDif/1000); //scale from 0.1 up to 1
+				if (useDif < 0.1)
+				{
+					useDif = 0.1;
+				}
+				if (useDif > 1.0)
+				{
+					useDif = 1.0;
+				}
+				trap_Cvar_Set("timescale", va("%f", useDif));
+			}
+			else
+			{
+				char buf[128];
+				float tFVal = 0;
+
+				trap_Cvar_VariableStringBuffer("timescale", buf, sizeof(buf));
+
+				tFVal = atof(buf);
+
+				trap_Cvar_Set("timescale", "1");
+				if (timeDif > 1500 && tFVal == 1.0f)
+				{
+					gDoSlowMoDuel = qfalse;
+				}
+			}
+		}
+	}
+
+	// if we are waiting for the level to restart, do nothing
+	if ( level.restarted ) {
+		return;
+	}
+
+	level.framenum++;
+	level.previousTime = level.time;
+	level.time = levelTime;
+	msec = level.time - level.previousTime;
+
+	if (g_allowNPC.integer)
+	{
+		NAV_CheckCalcPaths();
+	}
+
+	AI_UpdateGroups();
+
+	if (g_allowNPC.integer)
+	{
+		if ( d_altRoutes.integer )
+		{
+			trap_Nav_CheckAllFailedEdges();
+		}
+		trap_Nav_ClearCheckedNodes();
+
+		//remember last waypoint, clear current one
+		for ( i = 0; i < level.num_entities ; i++) 
+		{
+			ent = &g_entities[i];
+
+			if ( !ent->inuse )
+				continue;
+
+			if ( ent->waypoint != WAYPOINT_NONE 
+				&& ent->noWaypointTime < level.time )
+			{
+				ent->lastWaypoint = ent->waypoint;
+				ent->waypoint = WAYPOINT_NONE;
+			}
+			if ( d_altRoutes.integer )
+			{
+				trap_Nav_CheckFailedNodes( ent );
+			}
+		}
+
+		//Look to clear out old events
+		ClearPlayerAlertEvents();
+	}
+
+	g_TimeSinceLastFrame = (level.time - g_LastFrameTime);
+
+	// get any cvar changes
+	G_UpdateCvars();
+
+
+
+#ifdef _G_FRAME_PERFANAL
+	trap_PrecisionTimer_Start(&timer_ItemRun);
+#endif
+	//
+	// go through all allocated objects
+	//
+	ent = &g_entities[0];
+	for (i=0 ; i<level.num_entities ; i++, ent++) {
+		if ( !ent->inuse ) {
+			continue;
+		}
+
+		// clear events that are too old
+		if ( level.time - ent->eventTime > EVENT_VALID_MSEC ) {
+			if ( ent->s.event ) {
+				ent->s.event = 0;	// &= EV_EVENT_BITS;
+				if ( ent->client ) {
+					ent->client->ps.externalEvent = 0;
+					// predicted events should never be set to zero
+					//ent->client->ps.events[0] = 0;
+					//ent->client->ps.events[1] = 0;
+				}
+			}
+			if ( ent->freeAfterEvent ) {
+				// tempEntities or dropped items completely go away after their event
+				if (ent->s.eFlags & EF_SOUNDTRACKER)
+				{ //don't trigger the event again..
+					ent->s.event = 0;
+					ent->s.eventParm = 0;
+					ent->s.eType = 0;
+					ent->eventTime = 0;
+				}
+				else
+				{
+					G_FreeEntity( ent );
+					continue;
+				}
+			} else if ( ent->unlinkAfterEvent ) {
+				// items that will respawn will hide themselves after their pickup event
+				ent->unlinkAfterEvent = qfalse;
+				trap_UnlinkEntity( ent );
+			}
+		}
+
+		// temporary entities don't think
+		if ( ent->freeAfterEvent ) {
+			continue;
+		}
+
+		if ( !ent->r.linked && ent->neverFree ) {
+			continue;
+		}
+
+		if ( ent->s.eType == ET_MISSILE ) {
+			G_RunMissile( ent );
+			continue;
+		}
+
+		if ( ent->s.eType == ET_ITEM || ent->physicsObject ) {
+#if 0 //use if body dragging enabled?
+			if (ent->s.eType == ET_BODY)
+			{ //special case for bodies
+				float grav = 3.0f;
+				float mass = 0.14f;
+				float bounce = 1.15f;
+
+				G_RunExPhys(ent, grav, mass, bounce, qfalse, NULL, 0);
+			}
+			else
+			{
+				G_RunItem( ent );
+			}
+#else
+			G_RunItem( ent );
+#endif
+			continue;
+		}
+
+		if ( ent->s.eType == ET_MOVER ) {
+			G_RunMover( ent );
+			continue;
+		}
+
+		if ( i < MAX_CLIENTS ) 
+		{
+			G_CheckClientTimeouts ( ent );
+			
+			if (ent->client->inSpaceIndex && ent->client->inSpaceIndex != ENTITYNUM_NONE)
+			{ //we're in space, check for suffocating and for exiting
+                gentity_t *spacetrigger = &g_entities[ent->client->inSpaceIndex];
+
+				if (!spacetrigger->inuse ||
+					!G_PointInBounds(ent->client->ps.origin, spacetrigger->r.absmin, spacetrigger->r.absmax))
+				{ //no longer in space then I suppose
+                    ent->client->inSpaceIndex = 0;					
+				}
+				else
+				{ //check for suffocation
+                    if (ent->client->inSpaceSuffocation < level.time)
+					{ //suffocate!
+						if (ent->health > 0 && ent->takedamage)
+						{ //if they're still alive..
+							G_Damage(ent, spacetrigger, spacetrigger, NULL, ent->client->ps.origin, Q_irand(50, 70), DAMAGE_NO_ARMOR, MOD_SUICIDE);
+
+							if (ent->health > 0)
+							{ //did that last one kill them?
+								//play the choking sound
+								G_EntitySound(ent, CHAN_VOICE, G_SoundIndex(va( "*choke%d.wav", Q_irand( 1, 3 ) )));
+
+								//make them grasp their throat
+								ent->client->ps.forceHandExtend = HANDEXTEND_CHOKE;
+								ent->client->ps.forceHandExtendTime = level.time + 2000;
+							}
+						}
+
+						ent->client->inSpaceSuffocation = level.time + Q_irand(100, 200);
+					}
+				}
+			}
+
+			if (ent->client->isHacking)
+			{ //hacking checks
+				gentity_t *hacked = &g_entities[ent->client->isHacking];
+				vec3_t angDif;
+
+				VectorSubtract(ent->client->ps.viewangles, ent->client->hackingAngles, angDif);
+
+				//keep him in the "use" anim
+				if (ent->client->ps.torsoAnim != BOTH_CONSOLE1)
+				{
+					G_SetAnim( ent, NULL, SETANIM_TORSO, BOTH_CONSOLE1, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD, 0 );
+				}
+				else
+				{
+					ent->client->ps.torsoTimer = 500;
+				}
+				ent->client->ps.weaponTime = ent->client->ps.torsoTimer;
+
+				if (!(ent->client->pers.cmd.buttons & BUTTON_USE))
+				{ //have to keep holding use
+					ent->client->isHacking = 0;
+					ent->client->ps.hackingTime = 0;
+				}
+				else if (!hacked || !hacked->inuse)
+				{ //shouldn't happen, but safety first
+					ent->client->isHacking = 0;
+					ent->client->ps.hackingTime = 0;
+				}
+				else if (!G_PointInBounds( ent->client->ps.origin, hacked->r.absmin, hacked->r.absmax ))
+				{ //they stepped outside the thing they're hacking, so reset hacking time
+					ent->client->isHacking = 0;
+					ent->client->ps.hackingTime = 0;
+				}
+				else if (VectorLength(angDif) > 10.0f)
+				{ //must remain facing generally the same angle as when we start
+					ent->client->isHacking = 0;
+					ent->client->ps.hackingTime = 0;
+				}
+			}
+
+#define JETPACK_DEFUEL_RATE		200 //approx. 20 seconds of idle use from a fully charged fuel amt
+#define JETPACK_REFUEL_RATE		150 //seems fair
+			if (ent->client->jetPackOn)
+			{ //using jetpack, drain fuel
+				if (ent->client->jetPackDebReduce < level.time)
+				{
+					if (ent->client->pers.cmd.upmove > 0)
+					{ //take more if they're thrusting
+						ent->client->ps.jetpackFuel -= 2;
+					}
+					else
+					{
+						ent->client->ps.jetpackFuel--;
+					}
+					
+					if (ent->client->ps.jetpackFuel <= 0)
+					{ //turn it off
+						ent->client->ps.jetpackFuel = 0;
+						Jetpack_Off(ent);
+					}
+					ent->client->jetPackDebReduce = level.time + JETPACK_DEFUEL_RATE;
+				}
+			}
+			else if (ent->client->ps.jetpackFuel < 100)
+			{ //recharge jetpack
+				if (ent->client->jetPackDebRecharge < level.time)
+				{
+					ent->client->ps.jetpackFuel++;
+					ent->client->jetPackDebRecharge = level.time + JETPACK_REFUEL_RATE;
+				}
+			}
+
+#define CLOAK_DEFUEL_RATE		200 //approx. 20 seconds of idle use from a fully charged fuel amt
+#define CLOAK_REFUEL_RATE		150 //seems fair
+			if (ent->client->ps.powerups[PW_CLOAKED])
+			{ //using cloak, drain battery
+				if (ent->client->cloakDebReduce < level.time)
+				{
+					ent->client->ps.cloakFuel--;
+					
+					if (ent->client->ps.cloakFuel <= 0)
+					{ //turn it off
+						ent->client->ps.cloakFuel = 0;
+						Jedi_Decloak(ent);
+					}
+					ent->client->cloakDebReduce = level.time + CLOAK_DEFUEL_RATE;
+				}
+			}
+			else if (ent->client->ps.cloakFuel < 100)
+			{ //recharge cloak
+				if (ent->client->cloakDebRecharge < level.time)
+				{
+					ent->client->ps.cloakFuel++;
+					ent->client->cloakDebRecharge = level.time + CLOAK_REFUEL_RATE;
+				}
+			}
+
+			if (g_gametype.integer == GT_SIEGE &&
+				ent->client->siegeClass != -1 &&
+				(bgSiegeClasses[ent->client->siegeClass].classflags & (1<<CFL_STATVIEWER)))
+			{ //see if it's time to send this guy an update of extended info
+				if (ent->client->siegeEDataSend < level.time)
+				{
+                    G_SiegeClientExData(ent);
+					ent->client->siegeEDataSend = level.time + 1000; //once every sec seems ok
+				}
+			}
+
+			if((!level.intermissiontime)&&!(ent->client->ps.pm_flags&PMF_FOLLOW) && ent->client->sess.sessionTeam != TEAM_SPECTATOR)
+			{
+				WP_ForcePowersUpdate(ent, &ent->client->pers.cmd );
+				WP_SaberPositionUpdate(ent, &ent->client->pers.cmd);
+				WP_SaberStartMissileBlockCheck(ent, &ent->client->pers.cmd);
+			}
+
+			if (g_allowNPC.integer)
+			{
+				//This was originally intended to only be done for client 0.
+				//Make sure it doesn't slow things down too much with lots of clients in game.
+				NAV_FindPlayerWaypoint(i);
+			}
+
+			trap_ICARUS_MaintainTaskManager(ent->s.number);
+
+			G_RunClient( ent );
+			continue;
+		}
+		else if (ent->s.eType == ET_NPC)
+		{
+			int j;
+			// turn off any expired powerups
+			for ( j = 0 ; j < MAX_POWERUPS ; j++ ) {
+				if ( ent->client->ps.powerups[ j ] < level.time ) {
+					ent->client->ps.powerups[ j ] = 0;
+				}
+			}
+
+			WP_ForcePowersUpdate(ent, &ent->client->pers.cmd );
+			WP_SaberPositionUpdate(ent, &ent->client->pers.cmd);
+			WP_SaberStartMissileBlockCheck(ent, &ent->client->pers.cmd);
+		}
+
+		G_RunThink( ent );
+
+		if (g_allowNPC.integer)
+		{
+			ClearNPCGlobals();
+		}
+	}
+#ifdef _G_FRAME_PERFANAL
+	iTimer_ItemRun = trap_PrecisionTimer_End(timer_ItemRun);
+#endif
+
+	SiegeCheckTimers();
+
+#ifdef _G_FRAME_PERFANAL
+	trap_PrecisionTimer_Start(&timer_ROFF);
+#endif
+	trap_ROFF_UpdateEntities();
+#ifdef _G_FRAME_PERFANAL
+	iTimer_ROFF = trap_PrecisionTimer_End(timer_ROFF);
+#endif
+
+
+
+#ifdef _G_FRAME_PERFANAL
+	trap_PrecisionTimer_Start(&timer_ClientEndframe);
+#endif
+	// perform final fixups on the players
+	ent = &g_entities[0];
+	for (i=0 ; i < level.maxclients ; i++, ent++ ) {
+		if ( ent->inuse ) {
+			ClientEndFrame( ent );
+		}
+	}
+#ifdef _G_FRAME_PERFANAL
+	iTimer_ClientEndframe = trap_PrecisionTimer_End(timer_ClientEndframe);
+#endif
+
+
+
+#ifdef _G_FRAME_PERFANAL
+	trap_PrecisionTimer_Start(&timer_GameChecks);
+#endif
+	// see if it is time to do a tournement restart
+	CheckTournament();
+
+	// see if it is time to end the level
+	CheckExitRules();
+
+	// update to team status?
+	CheckTeamStatus();
+
+	// cancel vote if timed out
+	CheckVote();
+
+	// check team votes
+	CheckTeamVote( TEAM_RED );
+	CheckTeamVote( TEAM_BLUE );
+
+	// for tracking changes
+	CheckCvars();
+
+	if (g_listEntity.integer) {
+		for (i = 0; i < MAX_GENTITIES; i++) {
+			G_Printf("%4i: %s\n", i, g_entities[i].classname);
+		}
+		trap_Cvar_Set("g_listEntity", "0");
+	}
+#ifdef _G_FRAME_PERFANAL
+	iTimer_GameChecks = trap_PrecisionTimer_End(timer_GameChecks);
+#endif
+
+
+
+#ifdef _G_FRAME_PERFANAL
+	trap_PrecisionTimer_Start(&timer_Queues);
+#endif
+	//At the end of the frame, send out the ghoul2 kill queue, if there is one
+	G_SendG2KillQueue();
+
+	if (gQueueScoreMessage)
+	{
+		if (gQueueScoreMessageTime < level.time)
+		{
+			SendScoreboardMessageToAllClients();
+
+			gQueueScoreMessageTime = 0;
+			gQueueScoreMessage = 0;
+		}
+	}
+#ifdef _G_FRAME_PERFANAL
+	iTimer_Queues = trap_PrecisionTimer_End(timer_Queues);
+#endif
+
+
+
+#ifdef _G_FRAME_PERFANAL
+	Com_Printf("---------------\nItemRun: %i\nROFF: %i\nClientEndframe: %i\nGameChecks: %i\nQueues: %i\n---------------\n",
+		iTimer_ItemRun,
+		iTimer_ROFF,
+		iTimer_ClientEndframe,
+		iTimer_GameChecks,
+		iTimer_Queues);
+#endif
+
+	g_LastFrameTime = level.time;
+}
+
+const char *G_GetStringEdString(char *refSection, char *refName)
+{
+	/*
+	static char text[1024]={0};
+	trap_SP_GetStringTextString(va("%s_%s", refSection, refName), text, sizeof(text));
+	return text;
+	*/
+
+	//Well, it would've been lovely doing it the above way, but it would mean mixing
+	//languages for the client depending on what the server is. So we'll mark this as
+	//a stringed reference with @@@ and send the refname to the client, and when it goes
+	//to print it will get scanned for the stringed reference indication and dealt with
+	//properly.
+	static char text[1024]={0};
+	Com_sprintf(text, sizeof(text), "@@@%s", refName);
+	return text;
+}
\ No newline at end of file
diff --git a/codemp/game/g_mem.c b/codemp/game/g_mem.c
new file mode 100644
index 0000000..949b169
--- /dev/null
+++ b/codemp/game/g_mem.c
@@ -0,0 +1,41 @@
+// Copyright (C) 1999-2000 Id Software, Inc.
+//
+//
+// g_mem.c
+//
+
+
+#include "g_local.h"
+
+
+#define POOLSIZE	(256 * 1024)
+
+static char		memoryPool[POOLSIZE];
+static int		allocPoint;
+
+void *G_Alloc( int size ) {
+	char	*p;
+
+	if ( g_debugAlloc.integer ) {
+		G_Printf( "G_Alloc of %i bytes (%i left)\n", size, POOLSIZE - allocPoint - ( ( size + 31 ) & ~31 ) );
+	}
+
+	if ( allocPoint + size > POOLSIZE ) {
+	  G_Error( "G_Alloc: failed on allocation of %i bytes\n", size ); // bk010103 - was %u, but is signed
+		return NULL;
+	}
+
+	p = &memoryPool[allocPoint];
+
+	allocPoint += ( size + 31 ) & ~31;
+
+	return p;
+}
+
+void G_InitMemory( void ) {
+	allocPoint = 0;
+}
+
+void Svcmd_GameMem_f( void ) {
+	G_Printf( "Game memory status: %i out of %i bytes allocated\n", allocPoint, POOLSIZE );
+}
diff --git a/codemp/game/g_misc.c b/codemp/game/g_misc.c
new file mode 100644
index 0000000..b9e3cde
--- /dev/null
+++ b/codemp/game/g_misc.c
@@ -0,0 +1,3494 @@
+// Copyright (C) 1999-2000 Id Software, Inc.
+//
+// g_misc.c
+
+#include "g_local.h"
+#include "../ghoul2/G2.h"
+
+#include "ai_main.h" //for the g2animents
+
+#define HOLOCRON_RESPAWN_TIME 30000
+#define MAX_AMMO_GIVE 2
+#define STATION_RECHARGE_TIME 100
+
+void HolocronThink(gentity_t *ent);
+extern vmCvar_t g_MaxHolocronCarry;
+
+/*QUAKED func_group (0 0 0) ?
+Used to group brushes together just for editor convenience.  They are turned into normal brushes by the utilities.
+*/
+
+
+/*QUAKED info_camp (0 0.5 0) (-4 -4 -4) (4 4 4)
+Used as a positional target for calculations in the utilities (spotlights, etc), but removed during gameplay.
+*/
+void SP_info_camp( gentity_t *self ) {
+	G_SetOrigin( self, self->s.origin );
+}
+
+
+/*QUAKED info_null (0 0.5 0) (-4 -4 -4) (4 4 4)
+Used as a positional target for calculations in the utilities (spotlights, etc), but removed during gameplay.
+*/
+void SP_info_null( gentity_t *self ) {
+	G_FreeEntity( self );
+}
+
+
+/*QUAKED info_notnull (0 0.5 0) (-4 -4 -4) (4 4 4)
+Used as a positional target for in-game calculation, like jumppad targets.
+target_position does the same thing
+*/
+void SP_info_notnull( gentity_t *self ){
+	G_SetOrigin( self, self->s.origin );
+}
+
+
+/*QUAKED lightJunior (0 0.7 0.3) (-8 -8 -8) (8 8 8) nonlinear angle negative_spot negative_point
+Non-displayed light that only affects dynamic game models, but does not contribute to lightmaps
+"light" overrides the default 300 intensity.
+Nonlinear checkbox gives inverse square falloff instead of linear 
+Angle adds light:surface angle calculations (only valid for "Linear" lights) (wolf)
+Lights pointed at a target will be spotlights.
+"radius" overrides the default 64 unit radius of a spotlight at the target point.
+"fade" falloff/radius adjustment value. multiply the run of the slope by "fade" (1.0f default) (only valid for "Linear" lights) (wolf)
+*/
+
+/*QUAKED light (0 1 0) (-8 -8 -8) (8 8 8) linear noIncidence START_OFF
+Non-displayed light.
+"light" overrides the default 300 intensity. - affects size
+a negative "light" will subtract the light's color
+'Linear' checkbox gives linear falloff instead of inverse square
+'noIncidence' checkbox makes lighting smoother
+Lights pointed at a target will be spotlights.
+"radius" overrides the default 64 unit radius of a spotlight at the target point.
+"scale" multiplier for the light intensity - does not affect size (default 1)
+		greater than 1 is brighter, between 0 and 1 is dimmer.
+"color" sets the light's color
+"targetname" to indicate a switchable light - NOTE that all lights with the same targetname will be grouped together and act as one light (ie: don't mix colors, styles or start_off flag)
+"style" to specify a specify light style, even for switchable lights!
+"style_off" light style to use when switched off (Only for switchable lights)
+
+   1 FLICKER (first variety)
+   2 SLOW STRONG PULSE
+   3 CANDLE (first variety)
+   4 FAST STROBE
+   5 GENTLE PULSE 1
+   6 FLICKER (second variety)
+   7 CANDLE (second variety)
+   8 CANDLE (third variety)
+   9 SLOW STROBE (fourth variety)
+   10 FLUORESCENT FLICKER
+   11 SLOW PULSE NOT FADE TO BLACK
+   12 FAST PULSE FOR JEREMY
+   13 Test Blending
+*/
+static void misc_lightstyle_set ( gentity_t *ent)
+{
+	const int mLightStyle = ent->count;
+	const int mLightSwitchStyle = ent->bounceCount;
+	const int mLightOffStyle = ent->fly_sound_debounce_time;
+	if (!ent->alt_fire)
+	{	//turn off
+		if (mLightOffStyle)	//i have a light style i'd like to use when off
+		{
+			char lightstyle[32];
+			trap_GetConfigstring(CS_LIGHT_STYLES + (mLightOffStyle*3)+0, lightstyle, 32);
+			trap_SetConfigstring(CS_LIGHT_STYLES + (mLightStyle*3)+0, lightstyle);
+
+			trap_GetConfigstring(CS_LIGHT_STYLES + (mLightOffStyle*3)+1, lightstyle, 32);
+			trap_SetConfigstring(CS_LIGHT_STYLES + (mLightStyle*3)+1, lightstyle);
+
+			trap_GetConfigstring(CS_LIGHT_STYLES + (mLightOffStyle*3)+2, lightstyle, 32);
+			trap_SetConfigstring(CS_LIGHT_STYLES + (mLightStyle*3)+2, lightstyle);
+		}else
+		{
+			trap_SetConfigstring(CS_LIGHT_STYLES + (mLightStyle*3)+0, "a");
+			trap_SetConfigstring(CS_LIGHT_STYLES + (mLightStyle*3)+1, "a");
+			trap_SetConfigstring(CS_LIGHT_STYLES + (mLightStyle*3)+2, "a");
+		}
+	} 
+	else
+	{	//Turn myself on now
+		if (mLightSwitchStyle)	//i have a light style i'd like to use when on
+		{
+			char lightstyle[32];
+			trap_GetConfigstring(CS_LIGHT_STYLES + (mLightSwitchStyle*3)+0, lightstyle, 32);
+			trap_SetConfigstring(CS_LIGHT_STYLES + (mLightStyle*3)+0, lightstyle);
+
+			trap_GetConfigstring(CS_LIGHT_STYLES + (mLightSwitchStyle*3)+1, lightstyle, 32);
+			trap_SetConfigstring(CS_LIGHT_STYLES + (mLightStyle*3)+1, lightstyle);
+
+			trap_GetConfigstring(CS_LIGHT_STYLES + (mLightSwitchStyle*3)+2, lightstyle, 32);
+			trap_SetConfigstring(CS_LIGHT_STYLES + (mLightStyle*3)+2, lightstyle);
+		}
+		else
+		{
+			trap_SetConfigstring(CS_LIGHT_STYLES + (mLightStyle*3)+0, "z");
+			trap_SetConfigstring(CS_LIGHT_STYLES + (mLightStyle*3)+1, "z");
+			trap_SetConfigstring(CS_LIGHT_STYLES + (mLightStyle*3)+2, "z");
+		}
+	}
+}
+
+void misc_dlight_use ( gentity_t *ent, gentity_t *other, gentity_t *activator )
+{
+	G_ActivateBehavior(ent,BSET_USE);
+
+	ent->alt_fire = !ent->alt_fire;	//toggle
+	misc_lightstyle_set (ent);
+}
+
+void SP_light( gentity_t *self ) {
+	if (!self->targetname )
+	{//if i don't have a light style switch, the i go away
+		G_FreeEntity( self );
+		return;
+	}
+
+	G_SpawnInt( "style", "0", &self->count );
+	G_SpawnInt( "switch_style", "0", &self->bounceCount );
+	G_SpawnInt( "style_off", "0", &self->fly_sound_debounce_time );
+	G_SetOrigin( self, self->s.origin );
+	trap_LinkEntity( self );
+
+	self->use = misc_dlight_use;
+
+	self->s.eType = ET_GENERAL;
+	self->alt_fire = qfalse;
+	self->r.svFlags |= SVF_NOCLIENT;
+
+	if ( !(self->spawnflags & 4) )
+	{	//turn myself on now
+		self->alt_fire = qtrue;
+	}
+	misc_lightstyle_set (self);
+}
+
+
+/*
+=================================================================================
+
+TELEPORTERS
+
+=================================================================================
+*/
+
+void TeleportPlayer( gentity_t *player, vec3_t origin, vec3_t angles ) {
+	gentity_t	*tent;
+	qboolean	isNPC = qfalse;
+	if (player->s.eType == ET_NPC)
+	{
+		isNPC = qtrue;
+	}
+
+	// use temp events at source and destination to prevent the effect
+	// from getting dropped by a second player event
+	if ( player->client->sess.sessionTeam != TEAM_SPECTATOR ) {
+		tent = G_TempEntity( player->client->ps.origin, EV_PLAYER_TELEPORT_OUT );
+		tent->s.clientNum = player->s.clientNum;
+
+		tent = G_TempEntity( origin, EV_PLAYER_TELEPORT_IN );
+		tent->s.clientNum = player->s.clientNum;
+	}
+
+	// unlink to make sure it can't possibly interfere with G_KillBox
+	trap_UnlinkEntity (player);
+
+	VectorCopy ( origin, player->client->ps.origin );
+	player->client->ps.origin[2] += 1;
+
+	// spit the player out
+	AngleVectors( angles, player->client->ps.velocity, NULL, NULL );
+	VectorScale( player->client->ps.velocity, 400, player->client->ps.velocity );
+	player->client->ps.pm_time = 160;		// hold time
+	player->client->ps.pm_flags |= PMF_TIME_KNOCKBACK;
+
+	// toggle the teleport bit so the client knows to not lerp
+	player->client->ps.eFlags ^= EF_TELEPORT_BIT;
+
+	// set angles
+	SetClientViewAngle( player, angles );
+
+	// kill anything at the destination
+	if ( player->client->sess.sessionTeam != TEAM_SPECTATOR ) {
+		G_KillBox (player);
+	}
+
+	// save results of pmove
+	BG_PlayerStateToEntityState( &player->client->ps, &player->s, qtrue );
+	if (isNPC)
+	{
+		player->s.eType = ET_NPC;
+	}
+
+	// use the precise origin for linking
+	VectorCopy( player->client->ps.origin, player->r.currentOrigin );
+
+	if ( player->client->sess.sessionTeam != TEAM_SPECTATOR ) {
+		trap_LinkEntity (player);
+	}
+}
+
+
+/*QUAKED misc_teleporter_dest (1 0 0) (-32 -32 -24) (32 32 -16)
+Point teleporters at these.
+Now that we don't have teleport destination pads, this is just
+an info_notnull
+*/
+void SP_misc_teleporter_dest( gentity_t *ent ) {
+}
+
+
+//===========================================================
+
+/*QUAKED misc_model (1 0 0) (-16 -16 -16) (16 16 16)
+"model"		arbitrary .md3 or .ase file to display
+turns into map triangles - not solid
+*/
+void SP_misc_model( gentity_t *ent ) {
+
+#if 0
+	ent->s.modelindex = G_ModelIndex( ent->model );
+	VectorSet (ent->r.mins, -16, -16, -16);
+	VectorSet (ent->r.maxs, 16, 16, 16);
+	trap_LinkEntity (ent);
+
+	G_SetOrigin( ent, ent->s.origin );
+	VectorCopy( ent->s.angles, ent->s.apos.trBase );
+#else
+	G_FreeEntity( ent );
+#endif
+}
+
+/*QUAKED misc_model_static (1 0 0) (-16 -16 0) (16 16 16)
+"model"		arbitrary .md3 file to display
+"zoffset"	units to offset vertical culling position by, can be
+			negative or positive. This does not affect the actual
+			position of the model, only the culling position. Use
+			it for models with stupid origins that go below the
+			ground and whatnot.
+"modelscale" scale on all axis
+"modelscale_vec" scale difference axis
+
+loaded as a model in the renderer - does not take up precious
+bsp space!
+*/
+void SP_misc_model_static(gentity_t *ent)
+{
+	G_FreeEntity( ent );
+}
+
+/*QUAKED misc_G2model (1 0 0) (-16 -16 -16) (16 16 16)
+"model"		arbitrary .glm file to display
+*/
+void SP_misc_G2model( gentity_t *ent ) {
+
+#if 0
+	char name1[200] = "models/players/kyle/modelmp.glm";
+	trap_G2API_InitGhoul2Model(&ent->s, name1, G_ModelIndex( name1 ), 0, 0, 0, 0);
+	trap_G2API_SetBoneAnim(ent->s.ghoul2, 0, "model_root", 0, 12, BONE_ANIM_OVERRIDE_LOOP, 1.0f, level.time, -1, -1);
+	ent->s.radius = 150;
+//	VectorSet (ent->r.mins, -16, -16, -16);
+//	VectorSet (ent->r.maxs, 16, 16, 16);
+	trap_LinkEntity (ent);
+
+	G_SetOrigin( ent, ent->s.origin );
+	VectorCopy( ent->s.angles, ent->s.apos.trBase );
+#else
+	G_FreeEntity( ent );
+#endif
+}
+
+//===========================================================
+
+void locateCamera( gentity_t *ent ) {
+	vec3_t		dir;
+	gentity_t	*target;
+	gentity_t	*owner;
+
+	owner = G_PickTarget( ent->target );
+	if ( !owner ) {
+		G_Printf( "Couldn't find target for misc_partal_surface\n" );
+		G_FreeEntity( ent );
+		return;
+	}
+	ent->r.ownerNum = owner->s.number;
+
+	// frame holds the rotate speed
+	if ( owner->spawnflags & 1 ) {
+		ent->s.frame = 25;
+	} else if ( owner->spawnflags & 2 ) {
+		ent->s.frame = 75;
+	}
+
+	// swing camera ?
+	if ( owner->spawnflags & 4 ) {
+		// set to 0 for no rotation at all
+		ent->s.powerups = 0;
+	}
+	else {
+		ent->s.powerups = 1;
+	}
+
+	// clientNum holds the rotate offset
+	ent->s.clientNum = owner->s.clientNum;
+
+	VectorCopy( owner->s.origin, ent->s.origin2 );
+
+	// see if the portal_camera has a target
+	target = G_PickTarget( owner->target );
+	if ( target ) {
+		VectorSubtract( target->s.origin, owner->s.origin, dir );
+		VectorNormalize( dir );
+	} else {
+		G_SetMovedir( owner->s.angles, dir );
+	}
+
+	ent->s.eventParm = DirToByte( dir );
+}
+
+/*QUAKED misc_portal_surface (0 0 1) (-8 -8 -8) (8 8 8)
+The portal surface nearest this entity will show a view from the targeted misc_portal_camera, or a mirror view if untargeted.
+This must be within 64 world units of the surface!
+*/
+void SP_misc_portal_surface(gentity_t *ent) {
+	VectorClear( ent->r.mins );
+	VectorClear( ent->r.maxs );
+	trap_LinkEntity (ent);
+
+	ent->r.svFlags = SVF_PORTAL;
+	ent->s.eType = ET_PORTAL;
+
+	if ( !ent->target ) {
+		VectorCopy( ent->s.origin, ent->s.origin2 );
+	} else {
+		ent->think = locateCamera;
+		ent->nextthink = level.time + 100;
+	}
+}
+
+/*QUAKED misc_portal_camera (0 0 1) (-8 -8 -8) (8 8 8) slowrotate fastrotate noswing
+The target for a misc_portal_director.  You can set either angles or target another entity to determine the direction of view.
+"roll" an angle modifier to orient the camera around the target vector;
+*/
+void SP_misc_portal_camera(gentity_t *ent) {
+	float	roll;
+
+	VectorClear( ent->r.mins );
+	VectorClear( ent->r.maxs );
+	trap_LinkEntity (ent);
+
+	G_SpawnFloat( "roll", "0", &roll );
+
+	ent->s.clientNum = roll/360.0 * 256;
+}
+
+/*QUAKED misc_bsp (1 0 0) (-16 -16 -16) (16 16 16)
+"bspmodel"		arbitrary .bsp file to display
+*/
+void SP_misc_bsp(gentity_t *ent) 
+{
+	char	temp[MAX_QPATH];
+	char	*out;
+	float	newAngle;
+	int		tempint;
+
+	G_SpawnFloat( "angle", "0", &newAngle );
+	if (newAngle != 0.0)
+	{
+		ent->s.angles[1] = newAngle;
+	}
+	// don't support rotation any other way
+	ent->s.angles[0] = 0.0;
+	ent->s.angles[2] = 0.0;
+	
+	G_SpawnString("bspmodel", "", &out);
+
+	ent->s.eFlags = EF_PERMANENT;
+
+	// Mainly for debugging
+	G_SpawnInt( "spacing", "0", &tempint);
+	ent->s.time2 = tempint;
+	G_SpawnInt( "flatten", "0", &tempint);
+	ent->s.time = tempint;
+
+	Com_sprintf(temp, MAX_QPATH, "#%s", out);
+	trap_SetBrushModel( ent, temp );  // SV_SetBrushModel -- sets mins and maxs
+	G_BSPIndex(temp);
+
+	level.mNumBSPInstances++;
+	Com_sprintf(temp, MAX_QPATH, "%d-", level.mNumBSPInstances);
+	VectorCopy(ent->s.origin, level.mOriginAdjust);
+	level.mRotationAdjust = ent->s.angles[1];
+	level.mTargetAdjust = temp;
+	//level.hasBspInstances = qtrue; //rww - also not referenced anywhere.
+	level.mBSPInstanceDepth++;
+	/*
+	G_SpawnString("filter", "", &out);
+	strcpy(level.mFilter, out);
+	*/
+	G_SpawnString("teamfilter", "", &out);
+	strcpy(level.mTeamFilter, out);
+
+	VectorCopy( ent->s.origin, ent->s.pos.trBase );
+	VectorCopy( ent->s.origin, ent->r.currentOrigin );
+	VectorCopy( ent->s.angles, ent->s.apos.trBase );
+	VectorCopy( ent->s.angles, ent->r.currentAngles );
+
+	ent->s.eType = ET_MOVER;
+
+	trap_LinkEntity (ent);
+
+	trap_SetActiveSubBSP(ent->s.modelindex);
+	G_SpawnEntitiesFromString(qtrue);
+	trap_SetActiveSubBSP(-1);
+
+	level.mBSPInstanceDepth--;
+	//level.mFilter[0] = level.mTeamFilter[0] = 0;
+	level.mTeamFilter[0] = 0;
+
+	/*
+	if ( g_debugRMG.integer )
+	{
+		G_SpawnDebugCylinder ( ent->s.origin, ent->s.time2, &g_entities[0], 2000, COLOR_WHITE );
+
+		if ( ent->s.time )
+		{
+			G_SpawnDebugCylinder ( ent->s.origin, ent->s.time, &g_entities[0], 2000, COLOR_RED );
+		}
+	}
+	*/
+}
+
+/*QUAKED terrain (1.0 1.0 1.0) ? NOVEHDMG
+
+NOVEHDMG - don't damage vehicles upon impact with this terrain
+
+Terrain entity
+It will stretch to the full height of the brush
+
+numPatches - integer number of patches to split the terrain brush into (default 200)
+terxels - integer number of terxels on a patch side (default 4) (2 <= count <= 8)
+seed - integer seed for random terrain generation (default 0)
+textureScale - float scale of texture (default 0.005)
+heightmap - name of heightmap data image to use, located in heightmaps/*.png. (must be PNG format)
+terrainDef - defines how the game textures the terrain (file is base/ext_data/rmg/*.terrain - default is grassyhills)
+instanceDef - defines which bsp instances appear
+miscentDef - defines which client models spawn on the terrain (file is base/ext_data/rmg/*.miscents)
+densityMap - how dense the client models are packed
+
+*/
+void AddSpawnField(char *field, char *value);
+#define MAX_INSTANCE_TYPES		16
+void SP_terrain(gentity_t *ent) 
+{
+	char				temp[MAX_INFO_STRING];
+	char				final[MAX_QPATH];
+	char				seed[MAX_QPATH];
+	char				missionType[MAX_QPATH];
+	//char				soundSet[MAX_QPATH];
+	int					shaderNum, i;
+	char				*value;
+	int					terrainID;
+
+	//Force it to 1 when there is terrain on the level.
+	trap_Cvar_Set("RMG", "1");
+	g_RMG.integer = 1;
+
+	VectorClear (ent->s.angles);
+	trap_SetBrushModel( ent, ent->model );
+
+	// Get the shader from the top of the brush
+//	shaderNum = gi.CM_GetShaderNum(s.modelindex);
+	shaderNum = 0;
+
+	if (g_RMG.integer)
+	{
+		/*
+		// Grab the default terrain file from the RMG cvar
+		trap_Cvar_VariableStringBuffer("RMG_terrain", temp, MAX_QPATH);
+		Com_sprintf(final, MAX_QPATH, "%s", temp);
+		AddSpawnField("terrainDef", temp);
+ 
+		trap_Cvar_VariableStringBuffer("RMG_instances", temp, MAX_QPATH);
+		Com_sprintf(final, MAX_QPATH, "%s", temp);
+		AddSpawnField("instanceDef", temp);
+
+		trap_Cvar_VariableStringBuffer("RMG_miscents", temp, MAX_QPATH);
+		Com_sprintf(final, MAX_QPATH, "%s", temp);
+		AddSpawnField("miscentDef", temp);
+		*/
+		//rww - disabled for now, don't want cvar overrides.
+
+		trap_Cvar_VariableStringBuffer("RMG_seed", seed, MAX_QPATH);
+		trap_Cvar_VariableStringBuffer("RMG_mission", missionType, MAX_QPATH);
+
+		//rww - May want to implement these at some point.
+		//trap_Cvar_VariableStringBuffer("RMG_soundset", soundSet, MAX_QPATH);
+		//trap_SetConfigstring(CS_AMBIENT_SOUNDSETS, soundSet );
+	}
+
+	// Get info required for the common init
+	temp[0] = 0;
+	G_SpawnString("heightmap", "", &value);
+	Info_SetValueForKey(temp, "heightMap", value);
+
+	G_SpawnString("numpatches", "400", &value);
+	Info_SetValueForKey(temp, "numPatches", va("%d", atoi(value)));
+
+	G_SpawnString("terxels", "4", &value);
+	Info_SetValueForKey(temp, "terxels", va("%d", atoi(value)));
+
+	Info_SetValueForKey(temp, "seed", seed);
+	Info_SetValueForKey(temp, "minx", va("%f", ent->r.mins[0]));
+	Info_SetValueForKey(temp, "miny", va("%f", ent->r.mins[1]));
+	Info_SetValueForKey(temp, "minz", va("%f", ent->r.mins[2]));
+	Info_SetValueForKey(temp, "maxx", va("%f", ent->r.maxs[0]));
+	Info_SetValueForKey(temp, "maxy", va("%f", ent->r.maxs[1]));
+	Info_SetValueForKey(temp, "maxz", va("%f", ent->r.maxs[2]));
+
+	Info_SetValueForKey(temp, "modelIndex", va("%d", ent->s.modelindex));
+
+	G_SpawnString("terraindef", "grassyhills", &value);
+	Info_SetValueForKey(temp, "terrainDef", value);
+
+	G_SpawnString("instancedef", "", &value);
+	Info_SetValueForKey(temp, "instanceDef", value);
+
+	G_SpawnString("miscentdef", "", &value);
+	Info_SetValueForKey(temp, "miscentDef", value);
+
+	Info_SetValueForKey(temp, "missionType", missionType);
+	
+	for(i = 0; i < MAX_INSTANCE_TYPES; i++)
+	{
+		trap_Cvar_VariableStringBuffer(va("RMG_instance%d", i), final, MAX_QPATH);
+		if(strlen(final))
+		{
+			Info_SetValueForKey(temp, va("inst%d", i), final);
+		}
+	}
+
+	// Set additional data required on the client only
+	G_SpawnString("densitymap", "", &value);
+	Info_SetValueForKey(temp, "densityMap", value);
+
+	Info_SetValueForKey(temp, "shader", va("%d", shaderNum));
+	G_SpawnString("texturescale", "0.005", &value);
+	Info_SetValueForKey(temp, "texturescale", va("%f", atof(value)));
+
+	// Initialise the common aspects of the terrain
+	terrainID = trap_CM_RegisterTerrain(temp);
+//	SetCommon(common);
+
+	Info_SetValueForKey(temp, "terrainId", va("%d", terrainID));
+
+	// Let the entity know if it is random generated or not
+//	SetIsRandom(common->GetIsRandom());
+
+	// Let the game remember everything
+	//level.landScapes[terrainID] = ent; //rww - also not referenced
+
+	// Send all the data down to the client
+	trap_SetConfigstring(CS_TERRAINS + terrainID, temp);
+
+	// Make sure the contents are properly set
+	ent->r.contents = CONTENTS_TERRAIN;
+	ent->r.svFlags = SVF_NOCLIENT;
+	ent->s.eFlags = EF_PERMANENT;
+	ent->s.eType = ET_TERRAIN;
+
+	// Hook into the world so physics will work
+	trap_LinkEntity(ent);
+
+	// If running RMG then initialize the terrain and handle team skins
+	if ( g_RMG.integer ) 
+	{
+		trap_RMG_Init(terrainID);
+
+		/*
+		if ( level.gametypeData->teams )
+		{
+			char temp[MAX_QPATH];
+
+			// Red team change from RMG ?
+			trap_GetConfigstring ( CS_GAMETYPE_REDTEAM, temp, MAX_QPATH );
+			if ( Q_stricmp ( temp, level.gametypeTeam[TEAM_RED] ) )
+			{
+				level.gametypeTeam[TEAM_RED] = trap_VM_LocalStringAlloc ( temp );
+			}
+
+			// Blue team change from RMG ?
+			trap_GetConfigstring ( CS_GAMETYPE_BLUETEAM, temp, MAX_QPATH );
+			if ( Q_stricmp ( temp, level.gametypeTeam[TEAM_BLUE] ) )
+			{
+				level.gametypeTeam[TEAM_BLUE] = trap_VM_LocalStringAlloc ( temp );
+			}
+		}
+		*/
+	}
+}
+
+//rww - Called by skyportal entities. This will check through entities and flag them
+//as portal ents if they are in the same pvs as a skyportal entity and pass
+//a direct point trace check between origins. I really wanted to use an eFlag for
+//flagging portal entities, but too many entities like to reset their eFlags.
+//Note that this was not part of the original wolf sky portal stuff.
+void G_PortalifyEntities(gentity_t *ent)
+{
+	int i = 0;
+	gentity_t *scan = NULL;
+
+	while (i < MAX_GENTITIES)
+	{
+		scan = &g_entities[i];
+
+		if (scan && scan->inuse && scan->s.number != ent->s.number && trap_InPVS(ent->s.origin, scan->r.currentOrigin))
+		{
+			trace_t tr;
+
+			trap_Trace(&tr, ent->s.origin, vec3_origin, vec3_origin, scan->r.currentOrigin, ent->s.number, CONTENTS_SOLID);
+
+			if (tr.fraction == 1.0 || (tr.entityNum == scan->s.number && tr.entityNum != ENTITYNUM_NONE && tr.entityNum != ENTITYNUM_WORLD))
+			{
+				if (!scan->client || scan->s.eType == ET_NPC)
+				{ //making a client a portal entity would be bad.
+					scan->s.isPortalEnt = qtrue; //he's flagged now
+				}
+			}
+		}
+
+		i++;
+	}
+
+	ent->think = G_FreeEntity; //the portal entity is no longer needed because its information is stored in a config string.
+	ent->nextthink = level.time;
+}
+
+/*QUAKED misc_skyportal_orient (.6 .7 .7) (-8 -8 0) (8 8 16)
+point from which to orient the sky portal cam in relation
+to the regular view position.
+
+"modelscale"			the scale at which to scale positions
+*/
+void SP_misc_skyportal_orient (gentity_t *ent)
+{
+	G_FreeEntity(ent);
+}
+
+
+/*QUAKED misc_skyportal (.6 .7 .7) (-8 -8 0) (8 8 16)
+"fov" for the skybox default is 80
+To have the portal sky fogged, enter any of the following values:
+"onlyfoghere" if non-0 allows you to set a global fog, but will only use that fog within this sky portal.
+
+Also note that entities in the same PVS and visible (via point trace) from this
+object will be flagged as portal entities. This means they will be sent and
+updated from the server for every client every update regardless of where
+they are, and they will essentially be added to the scene twice if the client
+is in the same PVS as them (only once otherwise, but still once no matter
+where the client is). In other words, don't go overboard with it or everything
+will explode.
+*/
+void SP_misc_skyportal (gentity_t *ent)
+{
+	char	*fov;
+	vec3_t	fogv;	//----(SA)	
+	int		fogn;	//----(SA)	
+	int		fogf;	//----(SA)	
+	int		isfog = 0;	// (SA)
+
+	float	fov_x;
+
+	G_SpawnString ("fov", "80", &fov);
+	fov_x = atof (fov);
+
+	isfog += G_SpawnVector ("fogcolor", "0 0 0", fogv);
+	isfog += G_SpawnInt ("fognear", "0", &fogn);
+	isfog += G_SpawnInt ("fogfar", "300", &fogf);
+
+	trap_SetConfigstring( CS_SKYBOXORG, va("%.2f %.2f %.2f %.1f %i %.2f %.2f %.2f %i %i", ent->s.origin[0], ent->s.origin[1], ent->s.origin[2], fov_x, (int)isfog, fogv[0], fogv[1], fogv[2], fogn, fogf ) );
+
+	ent->think = G_PortalifyEntities;
+	ent->nextthink = level.time + 1050; //give it some time first so that all other entities are spawned.
+}
+
+/*QUAKED misc_holocron (0 0 1) (-8 -8 -8) (8 8 8)
+count	Set to type of holocron (based on force power value)
+	HEAL = 0
+	JUMP = 1
+	SPEED = 2
+	PUSH = 3
+	PULL = 4
+	TELEPATHY = 5
+	GRIP = 6
+	LIGHTNING = 7
+	RAGE = 8
+	PROTECT = 9
+	ABSORB = 10
+	TEAM HEAL = 11
+	TEAM FORCE = 12
+	DRAIN = 13
+	SEE = 14
+	SABERATTACK = 15
+	SABERDEFEND = 16
+	SABERTHROW = 17
+*/
+
+/*char *holocronTypeModels[] = {
+	"models/chunks/rock/rock_big.md3",//FP_HEAL,
+	"models/chunks/rock/rock_big.md3",//FP_LEVITATION,
+	"models/chunks/rock/rock_big.md3",//FP_SPEED,
+	"models/chunks/rock/rock_big.md3",//FP_PUSH,
+	"models/chunks/rock/rock_big.md3",//FP_PULL,
+	"models/chunks/rock/rock_big.md3",//FP_TELEPATHY,
+	"models/chunks/rock/rock_big.md3",//FP_GRIP,
+	"models/chunks/rock/rock_big.md3",//FP_LIGHTNING,
+	"models/chunks/rock/rock_big.md3",//FP_RAGE,
+	"models/chunks/rock/rock_big.md3",//FP_PROTECT,
+	"models/chunks/rock/rock_big.md3",//FP_ABSORB,
+	"models/chunks/rock/rock_big.md3",//FP_TEAM_HEAL,
+	"models/chunks/rock/rock_big.md3",//FP_TEAM_FORCE,
+	"models/chunks/rock/rock_big.md3",//FP_DRAIN,
+	"models/chunks/rock/rock_big.md3",//FP_SEE
+	"models/chunks/rock/rock_big.md3",//FP_SABER_OFFENSE
+	"models/chunks/rock/rock_big.md3",//FP_SABER_DEFENSE
+	"models/chunks/rock/rock_big.md3"//FP_SABERTHROW
+};*/
+
+void HolocronRespawn(gentity_t *self)
+{
+	self->s.modelindex = (self->count - 128);
+}
+
+void HolocronPopOut(gentity_t *self)
+{
+	if (Q_irand(1, 10) < 5)
+	{
+		self->s.pos.trDelta[0] = 150 + Q_irand(1, 100);
+	}
+	else
+	{
+		self->s.pos.trDelta[0] = -150 - Q_irand(1, 100);
+	}
+	if (Q_irand(1, 10) < 5)
+	{
+		self->s.pos.trDelta[1] = 150 + Q_irand(1, 100);
+	}
+	else
+	{
+		self->s.pos.trDelta[1] = -150 - Q_irand(1, 100);
+	}
+	self->s.pos.trDelta[2] = 150 + Q_irand(1, 100);
+}
+
+void HolocronTouch(gentity_t *self, gentity_t *other, trace_t *trace)
+{
+	int i = 0;
+	int othercarrying = 0;
+	float time_lowest = 0;
+	int index_lowest = -1;
+	int hasall = 1;
+	int forceReselect = WP_NONE;
+
+	if (trace)
+	{
+		self->s.groundEntityNum = trace->entityNum;
+	}
+
+	if (!other || !other->client || other->health < 1)
+	{
+		return;
+	}
+
+	if (!self->s.modelindex)
+	{
+		return;
+	}
+
+	if (self->enemy)
+	{
+		return;
+	}
+
+	if (other->client->ps.holocronsCarried[self->count])
+	{
+		return;
+	}
+
+	if (other->client->ps.holocronCantTouch == self->s.number && other->client->ps.holocronCantTouchTime > level.time)
+	{
+		return;
+	}
+
+	while (i < NUM_FORCE_POWERS)
+	{
+		if (other->client->ps.holocronsCarried[i])
+		{
+			othercarrying++;
+
+			if (index_lowest == -1 || other->client->ps.holocronsCarried[i] < time_lowest)
+			{
+				index_lowest = i;
+				time_lowest = other->client->ps.holocronsCarried[i];
+			}
+		}
+		else if (i != self->count)
+		{
+			hasall = 0;
+		}
+		i++;
+	}
+
+	if (hasall)
+	{ //once we pick up this holocron we'll have all of them, so give us super special best prize!
+		//G_Printf("You deserve a pat on the back.\n");
+	}
+
+	if (!(other->client->ps.fd.forcePowersActive & (1 << other->client->ps.fd.forcePowerSelected)))
+	{ //If the player isn't using his currently selected force power, select this one
+		if (self->count != FP_SABER_OFFENSE && self->count != FP_SABER_DEFENSE && self->count != FP_SABERTHROW && self->count != FP_LEVITATION)
+		{
+			other->client->ps.fd.forcePowerSelected = self->count;
+		}
+	}
+
+	if (g_MaxHolocronCarry.integer && othercarrying >= g_MaxHolocronCarry.integer)
+	{ //make the oldest holocron carried by the player pop out to make room for this one
+		other->client->ps.holocronsCarried[index_lowest] = 0;
+
+		/*
+		if (index_lowest == FP_SABER_OFFENSE && !HasSetSaberOnly())
+		{ //you lost your saberattack holocron, so no more saber for you
+			other->client->ps.stats[STAT_WEAPONS] |= (1 << WP_STUN_BATON);
+			other->client->ps.stats[STAT_WEAPONS] &= ~(1 << WP_SABER);
+
+			if (other->client->ps.weapon == WP_SABER)
+			{
+				forceReselect = WP_SABER;
+			}
+		}
+		*/
+		//NOTE: No longer valid as we are now always giving a force level 1 saber attack level in holocron
+	}
+
+	//G_Sound(other, CHAN_AUTO, G_SoundIndex("sound/weapons/w_pkup.wav"));
+	G_AddEvent( other, EV_ITEM_PICKUP, self->s.number );
+
+	other->client->ps.holocronsCarried[self->count] = level.time;
+	self->s.modelindex = 0;
+	self->enemy = other;
+
+	self->pos2[0] = 1;
+	self->pos2[1] = level.time + HOLOCRON_RESPAWN_TIME;
+
+	/*
+	if (self->count == FP_SABER_OFFENSE && !HasSetSaberOnly())
+	{ //player gets a saber
+		other->client->ps.stats[STAT_WEAPONS] |= (1 << WP_SABER);
+		other->client->ps.stats[STAT_WEAPONS] &= ~(1 << WP_STUN_BATON);
+
+		if (other->client->ps.weapon == WP_STUN_BATON)
+		{
+			forceReselect = WP_STUN_BATON;
+		}
+	}
+	*/
+
+	if (forceReselect != WP_NONE)
+	{
+		G_AddEvent(other, EV_NOAMMO, forceReselect);
+	}
+
+	//G_Printf("DON'T TOUCH ME\n");
+}
+
+void HolocronThink(gentity_t *ent)
+{
+	if (ent->pos2[0] && (!ent->enemy || !ent->enemy->client || ent->enemy->health < 1))
+	{
+		if (ent->enemy && ent->enemy->client)
+		{
+			HolocronRespawn(ent);
+			VectorCopy(ent->enemy->client->ps.origin, ent->s.pos.trBase);
+			VectorCopy(ent->enemy->client->ps.origin, ent->s.origin);
+			VectorCopy(ent->enemy->client->ps.origin, ent->r.currentOrigin);
+			//copy to person carrying's origin before popping out of them
+			HolocronPopOut(ent);
+			ent->enemy->client->ps.holocronsCarried[ent->count] = 0;
+			ent->enemy = NULL;
+			
+			goto justthink;
+		}
+	}
+	else if (ent->pos2[0] && ent->enemy && ent->enemy->client)
+	{
+		ent->pos2[1] = level.time + HOLOCRON_RESPAWN_TIME;
+	}
+
+	if (ent->enemy && ent->enemy->client)
+	{
+		if (!ent->enemy->client->ps.holocronsCarried[ent->count])
+		{
+			ent->enemy->client->ps.holocronCantTouch = ent->s.number;
+			ent->enemy->client->ps.holocronCantTouchTime = level.time + 5000;
+
+			HolocronRespawn(ent);
+			VectorCopy(ent->enemy->client->ps.origin, ent->s.pos.trBase);
+			VectorCopy(ent->enemy->client->ps.origin, ent->s.origin);
+			VectorCopy(ent->enemy->client->ps.origin, ent->r.currentOrigin);
+			//copy to person carrying's origin before popping out of them
+			HolocronPopOut(ent);
+			ent->enemy = NULL;
+
+			goto justthink;
+		}
+
+		if (!ent->enemy->inuse || (ent->enemy->client && ent->enemy->client->ps.fallingToDeath))
+		{
+			if (ent->enemy->inuse && ent->enemy->client)
+			{
+				ent->enemy->client->ps.holocronBits &= ~(1 << ent->count);
+				ent->enemy->client->ps.holocronsCarried[ent->count] = 0;
+			}
+			ent->enemy = NULL;
+			HolocronRespawn(ent);
+			VectorCopy(ent->s.origin2, ent->s.pos.trBase);
+			VectorCopy(ent->s.origin2, ent->s.origin);
+			VectorCopy(ent->s.origin2, ent->r.currentOrigin);
+
+			ent->s.pos.trTime = level.time;
+
+			ent->pos2[0] = 0;
+
+			trap_LinkEntity(ent);
+
+			goto justthink;
+		}
+	}
+
+	if (ent->pos2[0] && ent->pos2[1] < level.time)
+	{ //isn't in original place and has been there for (HOLOCRON_RESPAWN_TIME) seconds without being picked up, so respawn
+		VectorCopy(ent->s.origin2, ent->s.pos.trBase);
+		VectorCopy(ent->s.origin2, ent->s.origin);
+		VectorCopy(ent->s.origin2, ent->r.currentOrigin);
+
+		ent->s.pos.trTime = level.time;
+
+		ent->pos2[0] = 0;
+
+		trap_LinkEntity(ent);
+	}
+
+justthink:
+	ent->nextthink = level.time + 50;
+
+	if (ent->s.pos.trDelta[0] || ent->s.pos.trDelta[1] || ent->s.pos.trDelta[2])
+	{
+		G_RunObject(ent);
+	}
+}
+
+void SP_misc_holocron(gentity_t *ent)
+{
+	vec3_t dest;
+	trace_t tr;
+
+	if (g_gametype.integer != GT_HOLOCRON)
+	{
+		G_FreeEntity(ent);
+		return;
+	}
+
+	if (HasSetSaberOnly())
+	{
+		if (ent->count == FP_SABER_OFFENSE ||
+			ent->count == FP_SABER_DEFENSE ||
+			ent->count == FP_SABERTHROW)
+		{ //having saber holocrons in saber only mode is pointless
+			G_FreeEntity(ent);
+			return;
+		}
+	}
+
+	ent->s.isJediMaster = qtrue;
+
+	VectorSet( ent->r.maxs, 8, 8, 8 );
+	VectorSet( ent->r.mins, -8, -8, -8 );
+
+	ent->s.origin[2] += 0.1;
+	ent->r.maxs[2] -= 0.1;
+
+	VectorSet( dest, ent->s.origin[0], ent->s.origin[1], ent->s.origin[2] - 4096 );
+	trap_Trace( &tr, ent->s.origin, ent->r.mins, ent->r.maxs, dest, ent->s.number, MASK_SOLID );
+	if ( tr.startsolid )
+	{
+		G_Printf ("SP_misc_holocron: misc_holocron startsolid at %s\n", vtos(ent->s.origin));
+		G_FreeEntity( ent );
+		return;
+	}
+
+	//add the 0.1 back after the trace
+	ent->r.maxs[2] += 0.1;
+
+	// allow to ride movers
+//	ent->s.groundEntityNum = tr.entityNum;
+
+	G_SetOrigin( ent, tr.endpos );
+
+	if (ent->count < 0)
+	{
+		ent->count = 0;
+	}
+
+	if (ent->count >= NUM_FORCE_POWERS)
+	{
+		ent->count = NUM_FORCE_POWERS-1;
+	}
+/*
+	if (g_forcePowerDisable.integer &&
+		(g_forcePowerDisable.integer & (1 << ent->count)))
+	{
+		G_FreeEntity(ent);
+		return;
+	}
+*/
+	//No longer doing this, causing too many complaints about accidentally setting no force powers at all
+	//and starting a holocron game (making it basically just FFA)
+
+	ent->enemy = NULL;
+
+	ent->flags = FL_BOUNCE_HALF;
+
+	ent->s.modelindex = (ent->count - 128);//G_ModelIndex(holocronTypeModels[ent->count]);
+	ent->s.eType = ET_HOLOCRON;
+	ent->s.pos.trType = TR_GRAVITY;
+	ent->s.pos.trTime = level.time;
+
+	ent->r.contents = CONTENTS_TRIGGER;
+	ent->clipmask = MASK_SOLID;
+
+	ent->s.trickedentindex4 = ent->count;
+
+	if (forcePowerDarkLight[ent->count] == FORCE_DARKSIDE)
+	{
+		ent->s.trickedentindex3 = 1;
+	}
+	else if (forcePowerDarkLight[ent->count] == FORCE_LIGHTSIDE)
+	{
+		ent->s.trickedentindex3 = 2;
+	}
+	else
+	{
+		ent->s.trickedentindex3 = 3;
+	}
+
+	ent->physicsObject = qtrue;
+
+	VectorCopy(ent->s.pos.trBase, ent->s.origin2); //remember the spawn spot
+
+	ent->touch = HolocronTouch;
+
+	trap_LinkEntity(ent);
+
+	ent->think = HolocronThink;
+	ent->nextthink = level.time + 50;
+}
+
+/*
+======================================================================
+
+  SHOOTERS
+
+======================================================================
+*/
+
+void Use_Shooter( gentity_t *ent, gentity_t *other, gentity_t *activator ) {
+	vec3_t		dir;
+	float		deg;
+	vec3_t		up, right;
+
+	// see if we have a target
+	if ( ent->enemy ) {
+		VectorSubtract( ent->enemy->r.currentOrigin, ent->s.origin, dir );
+		VectorNormalize( dir );
+	} else {
+		VectorCopy( ent->movedir, dir );
+	}
+
+	// randomize a bit
+	PerpendicularVector( up, dir );
+	CrossProduct( up, dir, right );
+
+	deg = crandom() * ent->random;
+	VectorMA( dir, deg, up, dir );
+
+	deg = crandom() * ent->random;
+	VectorMA( dir, deg, right, dir );
+
+	VectorNormalize( dir );
+
+	switch ( ent->s.weapon ) {
+	case WP_BLASTER:
+		WP_FireBlasterMissile( ent, ent->s.origin, dir, qfalse );
+		break;
+	}
+
+	G_AddEvent( ent, EV_FIRE_WEAPON, 0 );
+}
+
+
+static void InitShooter_Finish( gentity_t *ent ) {
+	ent->enemy = G_PickTarget( ent->target );
+	ent->think = 0;
+	ent->nextthink = 0;
+}
+
+void InitShooter( gentity_t *ent, int weapon ) {
+	ent->use = Use_Shooter;
+	ent->s.weapon = weapon;
+
+	RegisterItem( BG_FindItemForWeapon( weapon ) );
+
+	G_SetMovedir( ent->s.angles, ent->movedir );
+
+	if ( !ent->random ) {
+		ent->random = 1.0;
+	}
+	ent->random = sin( M_PI * ent->random / 180 );
+	// target might be a moving object, so we can't set movedir for it
+	if ( ent->target ) {
+		ent->think = InitShooter_Finish;
+		ent->nextthink = level.time + 500;
+	}
+	trap_LinkEntity( ent );
+}
+
+/*QUAKED shooter_blaster (1 0 0) (-16 -16 -16) (16 16 16)
+Fires at either the target or the current direction.
+"random" is the number of degrees of deviance from the taget. (1.0 default)
+*/
+void SP_shooter_blaster( gentity_t *ent ) {
+	InitShooter( ent, WP_BLASTER);
+}
+
+void check_recharge(gentity_t *ent)
+{
+	if (ent->fly_sound_debounce_time < level.time ||
+		!ent->activator ||
+		!ent->activator->client ||
+		!(ent->activator->client->pers.cmd.buttons & BUTTON_USE))
+	{
+		if (ent->activator)
+		{
+			G_Sound(ent, CHAN_AUTO, ent->genericValue7);
+		}
+		ent->s.loopSound = 0;
+		ent->s.loopIsSoundset = qfalse;
+		ent->activator = NULL;
+		ent->fly_sound_debounce_time = 0;
+	}
+	
+	if (!ent->activator)
+	{ //don't recharge during use
+		if (ent->genericValue8 < level.time)
+		{
+			if (ent->count < ent->genericValue4)
+			{
+				ent->count++;
+			}
+			ent->genericValue8 = level.time + ent->genericValue5;
+		}
+	}
+	ent->s.health = ent->count; //the "health bar" is gonna be how full we are
+	ent->nextthink = level.time;
+}
+
+/*
+================
+EnergyShieldStationSettings
+================
+*/
+void EnergyShieldStationSettings(gentity_t *ent)
+{
+	G_SpawnInt( "count", "200", &ent->count );
+
+	G_SpawnInt("chargerate", "0", &ent->genericValue5);
+
+	if (!ent->genericValue5)
+	{
+		ent->genericValue5 = STATION_RECHARGE_TIME;
+	}
+}
+
+/*
+================
+shield_power_converter_use
+================
+*/
+void shield_power_converter_use( gentity_t *self, gentity_t *other, gentity_t *activator)
+{
+	int dif,add;
+	int stop = 1;
+
+	if (!activator || !activator->client)
+	{
+		return;
+	}
+
+	if ( g_gametype.integer == GT_SIEGE 
+		&& other 
+		&& other->client 
+		&& other->client->siegeClass )
+	{
+		if ( !bgSiegeClasses[other->client->siegeClass].maxarmor )
+		{//can't use it!
+			G_Sound(self, CHAN_AUTO, G_SoundIndex("sound/interface/shieldcon_empty"));
+			return;
+		}
+	}
+
+	if (self->setTime < level.time)
+	{
+		int	maxArmor;
+		if (!self->s.loopSound)
+		{
+			self->s.loopSound = G_SoundIndex("sound/interface/shieldcon_run");
+			self->s.loopIsSoundset = qfalse;
+		}
+		self->setTime = level.time + 100;
+
+		if ( g_gametype.integer == GT_SIEGE 
+			&& other 
+			&& other->client 
+			&& other->client->siegeClass != -1 )
+		{
+			maxArmor = bgSiegeClasses[other->client->siegeClass].maxarmor;
+		}
+		else
+		{
+			maxArmor = activator->client->ps.stats[STAT_MAX_HEALTH];
+		}
+		dif = maxArmor - activator->client->ps.stats[STAT_ARMOR];
+
+		if (dif > 0)					// Already at full armor?
+		{
+			if (dif >MAX_AMMO_GIVE)
+			{
+				add = MAX_AMMO_GIVE;
+			}
+			else
+			{
+				add = dif;
+			}
+
+			if (self->count<add)
+			{
+				add = self->count;
+			}
+
+		    if (!self->genericValue12)
+			{
+				self->count -= add;
+			}
+			if (self->count <= 0)
+			{
+				self->setTime = 0;
+			}
+			stop = 0;
+
+			self->fly_sound_debounce_time = level.time + 500;
+			self->activator = activator;
+
+			activator->client->ps.stats[STAT_ARMOR] += add;
+		}
+	}
+
+	if (stop || self->count <= 0)
+	{
+		if (self->s.loopSound && self->setTime < level.time)
+		{
+			if (self->count <= 0)
+			{
+				G_Sound(self, CHAN_AUTO, G_SoundIndex("sound/interface/shieldcon_empty"));
+			}
+			else
+			{
+				G_Sound(self, CHAN_AUTO, self->genericValue7);
+			}
+		}
+		self->s.loopSound = 0;
+		self->s.loopIsSoundset = qfalse;
+		if (self->setTime < level.time)
+		{
+			self->setTime = level.time + self->genericValue5+100;
+		}
+	}
+}
+
+//dispense generic ammo
+void ammo_generic_power_converter_use( gentity_t *self, gentity_t *other, gentity_t *activator)
+{
+	int /*dif,*/ add;
+	//int ammoType;
+	int stop = 1;
+
+	if (!activator || !activator->client)
+	{
+		return;
+	}
+
+	if (self->setTime < level.time)
+	{
+		qboolean gaveSome = qfalse;
+		/*
+		while (i < 3)
+		{
+			if (!self->s.loopSound)
+			{
+				self->s.loopSound = G_SoundIndex("sound/interface/ammocon_run");
+				self->s.loopIsSoundset = qfalse;
+			}
+			self->setTime = level.time + 100;
+
+			//dif = activator->client->ps.stats[STAT_MAX_HEALTH] - activator->client->ps.stats[STAT_ARMOR];
+			switch (i)
+			{ //don't give rockets I guess
+			case 0:
+				ammoType = AMMO_BLASTER;
+				break;
+			case 1:
+				ammoType = AMMO_POWERCELL;
+				break;
+			case 2:
+				ammoType = AMMO_METAL_BOLTS;
+				break;
+			default:
+				ammoType = -1;
+				break;
+			}
+
+			if (ammoType != -1)
+			{
+				dif = ammoData[ammoType].max - activator->client->ps.ammo[ammoType];
+			}
+			else
+			{
+				dif = 0;
+			}
+
+			if (dif > 0)
+			{ //only give if not full
+				if (dif > MAX_AMMO_GIVE)
+				{
+					add = MAX_AMMO_GIVE;
+				}
+				else
+				{
+					add = dif;
+				}
+
+				if (self->count<add)
+				{
+					add = self->count;
+				}
+
+				self->count -= add;
+				if (self->count <= 0)
+				{
+					self->setTime = 0;
+					break;
+				}
+				stop = 0;
+
+				self->fly_sound_debounce_time = level.time + 500;
+				self->activator = activator;
+
+				activator->client->ps.ammo[ammoType] += add;
+			}
+
+			i++;
+		}
+		*/
+		int i = AMMO_BLASTER;
+		if (!self->s.loopSound)
+		{
+			self->s.loopSound = G_SoundIndex("sound/interface/ammocon_run");
+			self->s.loopIsSoundset = qfalse;
+		}
+		//self->setTime = level.time + 100;
+		self->fly_sound_debounce_time = level.time + 500;
+		self->activator = activator;
+		while (i < AMMO_MAX)
+		{
+			add = ammoData[i].max*0.05;
+			if (add < 1)
+			{
+				add = 1;
+			}
+			if ( ( (activator->client->ps.eFlags & EF_DOUBLE_AMMO) && (activator->client->ps.ammo[i] < ammoData[i].max*2)) ||
+				( activator->client->ps.ammo[i] < ammoData[i].max ) )
+			{
+				gaveSome = qtrue;
+				if ( g_gametype.integer == GT_SIEGE  && i == AMMO_ROCKETS && activator->client->ps.ammo[i] >= 10 )
+				{ //this stuff is already a freaking mess, so..
+					gaveSome = qfalse;
+				}
+				activator->client->ps.ammo[i] += add;
+				if ( g_gametype.integer == GT_SIEGE  && i == AMMO_ROCKETS && activator->client->ps.ammo[i] >= 10 )
+				{	// fixme - this should SERIOUSLY be externed.
+					activator->client->ps.ammo[i] = 10;
+				}
+				else if ( activator->client->ps.eFlags & EF_DOUBLE_AMMO )
+				{
+					if (activator->client->ps.ammo[i] >= ammoData[i].max * 2)
+					{	// yuck.
+						activator->client->ps.ammo[i] = ammoData[i].max * 2;
+					}
+					else
+					{
+						stop = 0;
+					}
+				}
+				else
+				{
+					if (activator->client->ps.ammo[i] >= ammoData[i].max)
+					{
+						activator->client->ps.ammo[i] = ammoData[i].max;
+					}
+					else
+					{
+						stop = 0;
+					}
+				}
+			}
+			i++;
+			if (!self->genericValue12 && gaveSome)
+			{
+				int sub = (add*0.2);
+				if (sub < 1)
+				{
+					sub = 1;
+				}
+				self->count -= sub;
+				if (self->count <= 0)
+				{
+					self->count = 0;
+					stop = 1;
+					break;
+				}
+			}
+		}
+	}
+
+	if (stop || self->count <= 0)
+	{
+		if (self->s.loopSound && self->setTime < level.time)
+		{
+			if (self->count <= 0)
+			{
+				G_Sound(self, CHAN_AUTO, G_SoundIndex("sound/interface/ammocon_empty"));
+			}
+			else
+			{
+				G_Sound(self, CHAN_AUTO, self->genericValue7);
+			}
+		}
+		self->s.loopSound = 0;
+		self->s.loopIsSoundset = qfalse;
+		if (self->setTime < level.time)
+		{
+			self->setTime = level.time + self->genericValue5+100;
+		}
+	}
+}
+
+/*QUAKED misc_ammo_floor_unit (1 0 0) (-16 -16 0) (16 16 40)
+model="/models/items/a_pwr_converter.md3"
+Gives generic ammo when used
+
+"count" - max charge value (default 200)
+"chargerate" - rechage 1 point every this many milliseconds (default 2000)
+"nodrain" - don't drain power from station if 1
+*/
+void SP_misc_ammo_floor_unit(gentity_t *ent)
+{
+	vec3_t dest;
+	trace_t tr;
+
+	VectorSet( ent->r.mins, -16, -16, 0 );
+	VectorSet( ent->r.maxs, 16, 16, 40 );
+
+	ent->s.origin[2] += 0.1f;
+	ent->r.maxs[2] -= 0.1f;
+
+	VectorSet( dest, ent->s.origin[0], ent->s.origin[1], ent->s.origin[2] - 4096 );
+	trap_Trace( &tr, ent->s.origin, ent->r.mins, ent->r.maxs, dest, ent->s.number, MASK_SOLID );
+	if ( tr.startsolid )
+	{
+		G_Printf ("SP_misc_ammo_floor_unit: misc_ammo_floor_unit startsolid at %s\n", vtos(ent->s.origin));
+		G_FreeEntity( ent );
+		return;
+	}
+
+	//add the 0.1 back after the trace
+	ent->r.maxs[2] += 0.1f;
+
+	// allow to ride movers
+	ent->s.groundEntityNum = tr.entityNum;
+
+	G_SetOrigin( ent, tr.endpos );
+
+	if (!ent->health)
+	{
+		ent->health = 60;
+	}
+
+	if (!ent->model || !ent->model[0])
+	{
+		ent->model = "/models/items/a_pwr_converter.md3";
+	}
+
+	ent->s.modelindex = G_ModelIndex( ent->model );
+
+	ent->s.eFlags = 0;
+	ent->r.svFlags |= SVF_PLAYER_USABLE;
+	ent->r.contents = CONTENTS_SOLID;
+	ent->clipmask = MASK_SOLID;
+
+	EnergyShieldStationSettings(ent);
+
+	ent->genericValue4 = ent->count; //initial value
+	ent->think = check_recharge;
+
+	G_SpawnInt("nodrain", "0", &ent->genericValue12);
+
+	if (!ent->genericValue12)
+	{
+		ent->s.maxhealth = ent->s.health = ent->count;
+	}
+	ent->s.shouldtarget = qtrue;
+	ent->s.teamowner = 0;
+	ent->s.owner = ENTITYNUM_NONE;
+
+	ent->nextthink = level.time + 200;// + STATION_RECHARGE_TIME;
+
+	ent->use = ammo_generic_power_converter_use;
+
+	VectorCopy( ent->s.angles, ent->s.apos.trBase );
+	trap_LinkEntity (ent);
+
+	G_SoundIndex("sound/interface/ammocon_run");
+	ent->genericValue7 = G_SoundIndex("sound/interface/ammocon_done");
+	G_SoundIndex("sound/interface/ammocon_empty");
+
+	if (g_gametype.integer == GT_SIEGE)
+	{ //show on radar from everywhere
+		ent->r.svFlags |= SVF_BROADCAST;
+		ent->s.eFlags |= EF_RADAROBJECT;
+		ent->s.genericenemyindex = G_IconIndex("gfx/mp/siegeicons/desert/weapon_recharge");
+	}
+}
+
+/*QUAKED misc_shield_floor_unit (1 0 0) (-16 -16 0) (16 16 40)
+model="/models/items/a_shield_converter.md3"
+Gives shield energy when used.
+
+"count" - max charge value (default 50)
+"chargerate" - rechage 1 point every this many milliseconds (default 3000)
+"nodrain" - don't drain power from me
+*/
+void SP_misc_shield_floor_unit( gentity_t *ent )
+{
+	vec3_t dest;
+	trace_t tr;
+
+	if (g_gametype.integer != GT_CTF &&
+		g_gametype.integer != GT_CTY &&
+		g_gametype.integer != GT_SIEGE)
+	{
+		G_FreeEntity( ent );
+		return;
+	}
+
+	VectorSet( ent->r.mins, -16, -16, 0 );
+	VectorSet( ent->r.maxs, 16, 16, 40 );
+
+	ent->s.origin[2] += 0.1;
+	ent->r.maxs[2] -= 0.1;
+
+	VectorSet( dest, ent->s.origin[0], ent->s.origin[1], ent->s.origin[2] - 4096 );
+	trap_Trace( &tr, ent->s.origin, ent->r.mins, ent->r.maxs, dest, ent->s.number, MASK_SOLID );
+	if ( tr.startsolid )
+	{
+		G_Printf ("SP_misc_shield_floor_unit: misc_shield_floor_unit startsolid at %s\n", vtos(ent->s.origin));
+		G_FreeEntity( ent );
+		return;
+	}
+
+	//add the 0.1 back after the trace
+	ent->r.maxs[2] += 0.1;
+
+	// allow to ride movers
+	ent->s.groundEntityNum = tr.entityNum;
+
+	G_SetOrigin( ent, tr.endpos );
+
+	if (!ent->health)
+	{
+		ent->health = 60;
+	}
+
+	if (!ent->model || !ent->model[0])
+	{
+		ent->model = "/models/items/a_shield_converter.md3";
+	}
+
+	ent->s.modelindex = G_ModelIndex( ent->model );
+
+	ent->s.eFlags = 0;
+	ent->r.svFlags |= SVF_PLAYER_USABLE;
+	ent->r.contents = CONTENTS_SOLID;
+	ent->clipmask = MASK_SOLID;
+
+	EnergyShieldStationSettings(ent);
+
+	ent->genericValue4 = ent->count; //initial value
+	ent->think = check_recharge;
+
+	G_SpawnInt("nodrain", "0", &ent->genericValue12);
+
+    if (!ent->genericValue12)
+	{
+		ent->s.maxhealth = ent->s.health = ent->count;
+	}
+	ent->s.shouldtarget = qtrue;
+	ent->s.teamowner = 0;
+	ent->s.owner = ENTITYNUM_NONE;
+
+	ent->nextthink = level.time + 200;// + STATION_RECHARGE_TIME;
+
+	ent->use = shield_power_converter_use;
+
+	VectorCopy( ent->s.angles, ent->s.apos.trBase );
+	trap_LinkEntity (ent);
+
+	G_SoundIndex("sound/interface/shieldcon_run");
+	ent->genericValue7 = G_SoundIndex("sound/interface/shieldcon_done");
+	G_SoundIndex("sound/interface/shieldcon_empty");
+
+	if (g_gametype.integer == GT_SIEGE)
+	{ //show on radar from everywhere
+		ent->r.svFlags |= SVF_BROADCAST;
+		ent->s.eFlags |= EF_RADAROBJECT;
+		ent->s.genericenemyindex = G_IconIndex("gfx/mp/siegeicons/desert/shield_recharge");
+	}
+}
+
+
+/*QUAKED misc_model_shield_power_converter (1 0 0) (-16 -16 -16) (16 16 16)
+model="models/items/psd_big.md3"
+Gives shield energy when used.
+
+"count" - the amount of ammo given when used (default 200)
+*/
+//------------------------------------------------------------
+void SP_misc_model_shield_power_converter( gentity_t *ent )
+{
+	if (!ent->health)
+	{
+		ent->health = 60;
+	}
+
+	VectorSet (ent->r.mins, -16, -16, -16);
+	VectorSet (ent->r.maxs, 16, 16, 16);
+
+	ent->s.modelindex = G_ModelIndex( ent->model );
+
+	ent->s.eFlags = 0;
+	ent->r.svFlags |= SVF_PLAYER_USABLE;
+	ent->r.contents = CONTENTS_SOLID;
+	ent->clipmask = MASK_SOLID;
+
+	EnergyShieldStationSettings(ent);
+
+	ent->genericValue4 = ent->count; //initial value
+	ent->think = check_recharge;
+
+	ent->s.maxhealth = ent->s.health = ent->count;
+	ent->s.shouldtarget = qtrue;
+	ent->s.teamowner = 0;
+	ent->s.owner = ENTITYNUM_NONE;
+
+	ent->nextthink = level.time + 200;// + STATION_RECHARGE_TIME;
+
+	ent->use = shield_power_converter_use;
+
+	G_SetOrigin( ent, ent->s.origin );
+	VectorCopy( ent->s.angles, ent->s.apos.trBase );
+	trap_LinkEntity (ent);
+
+	//G_SoundIndex("sound/movers/objects/useshieldstation.wav");
+
+	ent->s.modelindex2 = G_ModelIndex("/models/items/psd_big.md3");	// Precache model
+}
+
+
+/*
+================
+EnergyAmmoShieldStationSettings
+================
+*/
+void EnergyAmmoStationSettings(gentity_t *ent)
+{
+	G_SpawnInt( "count", "200", &ent->count );
+}
+
+/*
+================
+ammo_power_converter_use
+================
+*/
+void ammo_power_converter_use( gentity_t *self, gentity_t *other, gentity_t *activator)
+{
+	int			add = 0.0f;//,highest;
+	qboolean	overcharge;
+//	int			difBlaster,difPowerCell,difMetalBolts;
+	int			stop = 1;
+
+	if (!activator || !activator->client)
+	{
+		return;
+	}
+
+	if (self->setTime < level.time)
+	{
+		overcharge = qfalse;
+
+		if (!self->s.loopSound)
+		{
+			self->s.loopSound = G_SoundIndex("sound/player/pickupshield.wav");
+		}
+
+		self->setTime = level.time + 100;
+
+		if (self->count)	// Has it got any power left?
+		{
+			int i = AMMO_BLASTER;
+			while (i < AMMO_MAX)
+			{
+				add = ammoData[i].max*0.1;
+				if (add < 1)
+				{
+					add = 1;
+				}
+				if (activator->client->ps.ammo[i] < ammoData[i].max)
+				{
+					activator->client->ps.ammo[i] += add;
+					if (activator->client->ps.ammo[i] > ammoData[i].max)
+					{
+						activator->client->ps.ammo[i] = ammoData[i].max;
+					}
+				}
+				i++;
+			}
+			if (!self->genericValue12)
+			{
+				self->count -= add;
+			}
+			stop = 0;
+
+			self->fly_sound_debounce_time = level.time + 500;
+			self->activator = activator;
+
+			/*
+			if (self->count > MAX_AMMO_GIVE)
+			{
+				add = MAX_AMMO_GIVE;
+			}
+			else if (self->count<0)
+			{
+				add = 0;
+			}
+			else
+			{
+				add = self->count;
+			}
+
+			activator->client->ps.ammo[AMMO_BLASTER] += add;
+			activator->client->ps.ammo[AMMO_POWERCELL] += add;
+			activator->client->ps.ammo[AMMO_METAL_BOLTS] += add;
+
+			self->count -= add;
+			stop = 0;
+
+			self->fly_sound_debounce_time = level.time + 500;
+			self->activator = activator;
+
+			difBlaster = activator->client->ps.ammo[AMMO_BLASTER] - ammoData[AMMO_BLASTER].max;
+			difPowerCell = activator->client->ps.ammo[AMMO_POWERCELL] - ammoData[AMMO_POWERCELL].max;
+			difMetalBolts = activator->client->ps.ammo[AMMO_METAL_BOLTS] - ammoData[AMMO_METAL_BOLTS].max;
+
+			// Find the highest one
+			highest = difBlaster;
+			if (difPowerCell>difBlaster)
+			{
+				highest = difPowerCell;
+			}
+
+			if (difMetalBolts > highest)
+			{
+				highest = difMetalBolts;
+			}
+			*/
+		}
+	}
+
+	if (stop)
+	{
+		self->s.loopSound = 0;
+		self->s.loopIsSoundset = qfalse;
+	}
+}
+
+
+/*QUAKED misc_model_ammo_power_converter (1 0 0) (-16 -16 -16) (16 16 16)
+model="models/items/power_converter.md3"
+Gives ammo energy when used.
+
+"count" - the amount of ammo given when used (default 200)
+"nodrain" - don't drain power from me
+*/
+//------------------------------------------------------------
+void SP_misc_model_ammo_power_converter( gentity_t *ent )
+{
+	if (!ent->health)
+	{
+		ent->health = 60;
+	}
+
+	VectorSet (ent->r.mins, -16, -16, -16);
+	VectorSet (ent->r.maxs, 16, 16, 16);
+
+	ent->s.modelindex = G_ModelIndex( ent->model );
+
+	ent->s.eFlags = 0;
+	ent->r.svFlags |= SVF_PLAYER_USABLE;
+	ent->r.contents = CONTENTS_SOLID;
+	ent->clipmask = MASK_SOLID;
+
+	G_SpawnInt("nodrain", "0", &ent->genericValue12);
+	ent->use = ammo_power_converter_use;
+
+	EnergyAmmoStationSettings(ent);
+
+	ent->genericValue4 = ent->count; //initial value
+	ent->think = check_recharge;
+
+	if (!ent->genericValue12)
+	{
+		ent->s.maxhealth = ent->s.health = ent->count;
+	}
+	ent->s.shouldtarget = qtrue;
+	ent->s.teamowner = 0;
+	ent->s.owner = ENTITYNUM_NONE;
+
+	ent->nextthink = level.time + 200;// + STATION_RECHARGE_TIME;
+
+	G_SetOrigin( ent, ent->s.origin );
+	VectorCopy( ent->s.angles, ent->s.apos.trBase );
+	trap_LinkEntity (ent);
+
+	//G_SoundIndex("sound/movers/objects/useshieldstation.wav");
+}
+
+/*
+================
+EnergyHealthStationSettings
+================
+*/
+void EnergyHealthStationSettings(gentity_t *ent)
+{
+	G_SpawnInt( "count", "200", &ent->count );
+}
+
+/*
+================
+health_power_converter_use
+================
+*/
+void health_power_converter_use( gentity_t *self, gentity_t *other, gentity_t *activator)
+{
+	int dif,add;
+	int stop = 1;
+
+	if (!activator || !activator->client)
+	{
+		return;
+	}
+
+	if (self->setTime < level.time)
+	{
+		if (!self->s.loopSound)
+		{
+			self->s.loopSound = G_SoundIndex("sound/player/pickuphealth.wav");
+		}
+		self->setTime = level.time + 100;
+
+		dif = activator->client->ps.stats[STAT_MAX_HEALTH] - activator->health;
+
+		if (dif > 0)					// Already at full armor?
+		{
+			if (dif >/*MAX_AMMO_GIVE*/5)
+			{
+				add = 5;//MAX_AMMO_GIVE;
+			}
+			else
+			{
+				add = dif;
+			}
+
+			if (self->count<add)
+			{
+				add = self->count;
+			}
+
+			//self->count -= add;
+			stop = 0;
+
+			self->fly_sound_debounce_time = level.time + 500;
+			self->activator = activator;
+
+			activator->health += add;
+		}
+	}
+
+	if (stop)
+	{
+		self->s.loopSound = 0;
+		self->s.loopIsSoundset = qfalse;
+	}
+}
+
+
+/*QUAKED misc_model_health_power_converter (1 0 0) (-16 -16 -16) (16 16 16)
+model="models/items/power_converter.md3"
+Gives ammo energy when used.
+
+"count" - the amount of ammo given when used (default 200)
+*/
+//------------------------------------------------------------
+void SP_misc_model_health_power_converter( gentity_t *ent )
+{
+	if (!ent->health)
+	{
+		ent->health = 60;
+	}
+
+	VectorSet (ent->r.mins, -16, -16, -16);
+	VectorSet (ent->r.maxs, 16, 16, 16);
+
+	ent->s.modelindex = G_ModelIndex( ent->model );
+
+	ent->s.eFlags = 0;
+	ent->r.svFlags |= SVF_PLAYER_USABLE;
+	ent->r.contents = CONTENTS_SOLID;
+	ent->clipmask = MASK_SOLID;
+
+	ent->use = health_power_converter_use;
+
+	EnergyHealthStationSettings(ent);
+
+	ent->genericValue4 = ent->count; //initial value
+	ent->think = check_recharge;
+
+	//ent->s.maxhealth = ent->s.health = ent->count;
+	ent->s.shouldtarget = qtrue;
+	ent->s.teamowner = 0;
+	ent->s.owner = ENTITYNUM_NONE;
+
+	ent->nextthink = level.time + 200;// + STATION_RECHARGE_TIME;
+
+	G_SetOrigin( ent, ent->s.origin );
+	VectorCopy( ent->s.angles, ent->s.apos.trBase );
+	trap_LinkEntity (ent);
+
+	//G_SoundIndex("sound/movers/objects/useshieldstation.wav");
+	G_SoundIndex("sound/player/pickuphealth.wav");
+	ent->genericValue7 = G_SoundIndex("sound/interface/shieldcon_done");
+
+	if (g_gametype.integer == GT_SIEGE)
+	{ //show on radar from everywhere
+		ent->r.svFlags |= SVF_BROADCAST;
+		ent->s.eFlags |= EF_RADAROBJECT;
+		ent->s.genericenemyindex = G_IconIndex("gfx/mp/siegeicons/desert/bacta");
+	}
+}
+
+#if 0 //damage box stuff
+void DmgBoxHit( gentity_t *self, gentity_t *other, trace_t *trace )
+{
+	return;
+}
+
+void DmgBoxUpdateSelf(gentity_t *self)
+{
+	gentity_t *owner = &g_entities[self->r.ownerNum];
+
+	if (!owner || !owner->client || !owner->inuse)
+	{
+		goto killMe;
+	}
+
+	if (self->damageRedirect == DAMAGEREDIRECT_HEAD &&
+		owner->client->damageBoxHandle_Head != self->s.number)
+	{
+		goto killMe;
+	}
+
+	if (self->damageRedirect == DAMAGEREDIRECT_RLEG &&
+		owner->client->damageBoxHandle_RLeg != self->s.number)
+	{
+		goto killMe;
+	}
+
+	if (self->damageRedirect == DAMAGEREDIRECT_LLEG &&
+		owner->client->damageBoxHandle_LLeg != self->s.number)
+	{
+		goto killMe;
+	}
+
+	if (owner->health < 1)
+	{
+		goto killMe;
+	}
+
+	//G_TestLine(self->r.currentOrigin, owner->client->ps.origin, 0x0000ff, 100);
+
+	trap_LinkEntity(self);
+
+	self->nextthink = level.time;
+	return;
+
+killMe:
+	self->think = G_FreeEntity;
+	self->nextthink = level.time;
+}
+
+void DmgBoxAbsorb_Die( gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int mod )
+{
+	self->health = 1;
+}
+
+void DmgBoxAbsorb_Pain(gentity_t *self, gentity_t *attacker, int damage)
+{
+	self->health = 1;
+}
+
+gentity_t *CreateNewDamageBox( gentity_t *ent )
+{
+	gentity_t *dmgBox;
+
+	//We do not want the client to have any real knowledge of the entity whatsoever. It will only
+	//ever be used on the server.
+	dmgBox = G_Spawn();
+	dmgBox->classname = "dmg_box";
+			
+	dmgBox->r.svFlags = SVF_USE_CURRENT_ORIGIN;
+	dmgBox->r.ownerNum = ent->s.number;
+
+	dmgBox->clipmask = 0;
+	dmgBox->r.contents = MASK_PLAYERSOLID;
+
+	dmgBox->mass = 5000;
+
+	dmgBox->s.eFlags |= EF_NODRAW;
+	dmgBox->r.svFlags |= SVF_NOCLIENT;
+
+	dmgBox->touch = DmgBoxHit;
+
+	dmgBox->takedamage = qtrue;
+
+	dmgBox->health = 1;
+
+	dmgBox->pain = DmgBoxAbsorb_Pain;
+	dmgBox->die = DmgBoxAbsorb_Die;
+
+	dmgBox->think = DmgBoxUpdateSelf;
+	dmgBox->nextthink = level.time + 50;
+
+	return dmgBox;
+}
+
+void ATST_ManageDamageBoxes(gentity_t *ent)
+{
+	vec3_t headOrg, lLegOrg, rLegOrg;
+	vec3_t fwd, right, up, flatAngle;
+
+	if (!ent->client->damageBoxHandle_Head)
+	{
+		gentity_t *dmgBox = CreateNewDamageBox(ent);
+
+		if (dmgBox)
+		{
+			VectorSet( dmgBox->r.mins, ATST_MINS0, ATST_MINS1, ATST_MINS2 );
+			VectorSet( dmgBox->r.maxs, ATST_MAXS0, ATST_MAXS1, ATST_HEADSIZE );
+
+			ent->client->damageBoxHandle_Head = dmgBox->s.number;
+			dmgBox->damageRedirect = DAMAGEREDIRECT_HEAD;
+			dmgBox->damageRedirectTo = ent->s.number;
+		}
+	}
+	if (!ent->client->damageBoxHandle_RLeg)
+	{
+		gentity_t *dmgBox = CreateNewDamageBox(ent);
+
+		if (dmgBox)
+		{
+			VectorSet( dmgBox->r.mins, ATST_MINS0/4, ATST_MINS1/4, ATST_MINS2 );
+			VectorSet( dmgBox->r.maxs, ATST_MAXS0/4, ATST_MAXS1/4, ATST_MAXS2-ATST_HEADSIZE );
+
+			ent->client->damageBoxHandle_RLeg = dmgBox->s.number;
+			dmgBox->damageRedirect = DAMAGEREDIRECT_RLEG;
+			dmgBox->damageRedirectTo = ent->s.number;
+		}
+	}
+	if (!ent->client->damageBoxHandle_LLeg)
+	{
+		gentity_t *dmgBox = CreateNewDamageBox(ent);
+
+		if (dmgBox)
+		{
+			VectorSet( dmgBox->r.mins, ATST_MINS0/4, ATST_MINS1/4, ATST_MINS2 );
+			VectorSet( dmgBox->r.maxs, ATST_MAXS0/4, ATST_MAXS1/4, ATST_MAXS2-ATST_HEADSIZE );
+
+			ent->client->damageBoxHandle_LLeg = dmgBox->s.number;
+			dmgBox->damageRedirect = DAMAGEREDIRECT_LLEG;
+			dmgBox->damageRedirectTo = ent->s.number;
+		}
+	}
+
+	if (!ent->client->damageBoxHandle_Head ||
+		!ent->client->damageBoxHandle_LLeg ||
+		!ent->client->damageBoxHandle_RLeg)
+	{
+		return;
+	}
+
+	VectorCopy(ent->client->ps.origin, headOrg);
+	headOrg[2] += (ATST_MAXS2-ATST_HEADSIZE);
+
+	VectorCopy(ent->client->ps.viewangles, flatAngle);
+	flatAngle[PITCH] = 0;
+	flatAngle[ROLL] = 0;
+
+	AngleVectors(flatAngle, fwd, right, up);
+
+	VectorCopy(ent->client->ps.origin, lLegOrg);
+	VectorCopy(ent->client->ps.origin, rLegOrg);
+
+	lLegOrg[0] -= right[0]*32;
+	lLegOrg[1] -= right[1]*32;
+	lLegOrg[2] -= right[2]*32;
+
+	rLegOrg[0] += right[0]*32;
+	rLegOrg[1] += right[1]*32;
+	rLegOrg[2] += right[2]*32;
+
+	G_SetOrigin(&g_entities[ent->client->damageBoxHandle_Head], headOrg);
+	G_SetOrigin(&g_entities[ent->client->damageBoxHandle_LLeg], lLegOrg);
+	G_SetOrigin(&g_entities[ent->client->damageBoxHandle_RLeg], rLegOrg);
+}
+
+int G_PlayerBecomeATST(gentity_t *ent)
+{
+	if (!ent || !ent->client)
+	{
+		return 0;
+	}
+
+	if (ent->client->ps.weaponTime > 0)
+	{
+		return 0;
+	}
+
+	if (ent->client->ps.forceHandExtend != HANDEXTEND_NONE)
+	{
+		return 0;
+	}
+
+	if (ent->client->ps.zoomMode)
+	{
+		return 0;
+	}
+
+	if (ent->client->ps.usingATST)
+	{
+		ent->client->ps.usingATST = qfalse;
+		ent->client->ps.forceHandExtend = HANDEXTEND_WEAPONREADY;
+	}
+	else
+	{
+		ent->client->ps.usingATST = qtrue;
+	}
+
+	ent->client->ps.weaponTime = 1000;
+
+	return 1;
+}
+#endif
+
+//----------------------------------------------------------
+
+/*QUAKED fx_runner (0 0 1) (-8 -8 -8) (8 8 8) STARTOFF ONESHOT DAMAGE
+Runs the specified effect, can also be targeted at an info_notnull to orient the effect
+
+	STARTOFF - effect starts off, toggles on/off when used
+	ONESHOT - effect fires only when used
+	DAMAGE - does radius damage around effect every "delay" milliseonds
+
+	"fxFile" - name of the effect file to play
+	"target" - direction to aim the effect in, otherwise defaults to up
+	"target2" - uses its target2 when the fx gets triggered
+	"delay"  - how often to call the effect, don't over-do this ( default 200 )
+	"random" - random amount of time to add to delay, ( default 0, 200 = 0ms to 200ms )
+	"splashRadius" - only works when damage is checked ( default 16 )
+	"splashDamage" - only works when damage is checked ( default 5 )
+	"soundset"	- bmodel set to use, plays start sound when toggled on, loop sound while on ( doesn't play on a oneshot), and a stop sound when turned off
+*/
+#define FX_RUNNER_RESERVED 0x800000
+#define FX_ENT_RADIUS 32
+extern int	BMS_START;
+extern int	BMS_MID;
+extern int	BMS_END;
+//----------------------------------------------------------
+void fx_runner_think( gentity_t *ent )
+{
+	BG_EvaluateTrajectory( &ent->s.pos, level.time, ent->r.currentOrigin );
+	BG_EvaluateTrajectory( &ent->s.apos, level.time, ent->r.currentAngles );
+
+	// call the effect with the desired position and orientation
+	if (ent->s.isPortalEnt)
+	{
+//		G_AddEvent( ent, EV_PLAY_PORTAL_EFFECT_ID, ent->genericValue5 );
+	}
+	else
+	{
+//		G_AddEvent( ent, EV_PLAY_EFFECT_ID, ent->genericValue5 );
+	}
+
+	// start the fx on the client (continuous)
+	ent->s.modelindex2 = FX_STATE_CONTINUOUS;
+
+	VectorCopy(ent->r.currentAngles, ent->s.angles);
+	VectorCopy(ent->r.currentOrigin, ent->s.origin);
+
+	ent->nextthink = level.time + ent->delay + random() * ent->random;
+
+	if ( ent->spawnflags & 4 ) // damage
+	{
+		G_RadiusDamage( ent->r.currentOrigin, ent, ent->splashDamage, ent->splashRadius, ent, ent, MOD_UNKNOWN );
+	}
+
+	if ( ent->target2 && ent->target2[0] )
+	{
+		// let our target know that we have spawned an effect
+		G_UseTargets2( ent, ent, ent->target2 );
+	}
+
+	if ( !(ent->spawnflags & 2 ) && !ent->s.loopSound ) // NOT ONESHOT...this is an assy thing to do
+	{
+		if ( ent->soundSet && ent->soundSet[0] )
+		{
+			ent->s.soundSetIndex = G_SoundSetIndex(ent->soundSet);
+			ent->s.loopIsSoundset = qtrue;
+			ent->s.loopSound = BMS_MID;
+		}
+	}
+
+}
+
+//----------------------------------------------------------
+void fx_runner_use( gentity_t *self, gentity_t *other, gentity_t *activator )
+{
+	if (self->s.isPortalEnt)
+	{ //rww - mark it as broadcast upon first use if it's within the area of a skyportal
+		self->r.svFlags |= SVF_BROADCAST;
+	}
+
+	if ( self->spawnflags & 2 ) // ONESHOT
+	{
+		// call the effect with the desired position and orientation, as a safety thing,
+		//	make sure we aren't thinking at all.
+		int		saveState = self->s.modelindex2 + 1;
+
+		fx_runner_think( self );
+		self->nextthink = -1;
+		// one shot indicator
+		self->s.modelindex2 = saveState;
+		if (self->s.modelindex2 > FX_STATE_ONE_SHOT_LIMIT)
+		{
+			self->s.modelindex2 = FX_STATE_ONE_SHOT;
+		}
+
+		if ( self->target2 )
+		{
+			// let our target know that we have spawned an effect
+			G_UseTargets2( self, self, self->target2 );
+		}
+
+		if ( self->soundSet && self->soundSet[0] )
+		{
+			self->s.soundSetIndex = G_SoundSetIndex(self->soundSet);
+			G_AddEvent( self, EV_BMODEL_SOUND, BMS_START);
+		}
+	}
+	else
+	{
+		// ensure we are working with the right think function
+		self->think = fx_runner_think;
+
+		// toggle our state
+		if ( self->nextthink == -1 )
+		{
+			// NOTE: we fire the effect immediately on use, the fx_runner_think func will set
+			//	up the nextthink time.
+			fx_runner_think( self );
+
+			if ( self->soundSet && self->soundSet[0] )
+			{
+				self->s.soundSetIndex = G_SoundSetIndex(self->soundSet);
+				G_AddEvent( self, EV_BMODEL_SOUND, BMS_START);
+				self->s.loopSound = BMS_MID;
+				self->s.loopIsSoundset = qtrue;
+			}
+		}
+		else
+		{
+			// turn off for now
+			self->nextthink = -1;
+
+			// turn off fx on client
+			self->s.modelindex2 = FX_STATE_OFF;
+
+			if ( self->soundSet && self->soundSet[0] )
+			{
+				self->s.soundSetIndex = G_SoundSetIndex(self->soundSet);
+				G_AddEvent( self, EV_BMODEL_SOUND, BMS_END );
+				self->s.loopSound = 0;
+				self->s.loopIsSoundset = qfalse;
+			}
+		}
+	}
+}
+
+//----------------------------------------------------------
+void fx_runner_link( gentity_t *ent )
+{
+	vec3_t	dir;
+
+	if ( ent->target && ent->target[0] )
+	{
+		// try to use the target to override the orientation
+		gentity_t	*target = NULL;
+
+		target = G_Find( target, FOFS(targetname), ent->target );
+
+		if ( !target )
+		{
+			// Bah, no good, dump a warning, but continue on and use the UP vector
+			Com_Printf( "fx_runner_link: target specified but not found: %s\n", ent->target );
+			Com_Printf( "  -assuming UP orientation.\n" );
+		}
+		else
+		{
+			// Our target is valid so let's override the default UP vector
+			VectorSubtract( target->s.origin, ent->s.origin, dir );
+			VectorNormalize( dir );
+			vectoangles( dir, ent->s.angles );
+		}
+	}
+
+	// don't really do anything with this right now other than do a check to warn the designers if the target2 is bogus
+	if ( ent->target2 && ent->target2[0] )
+	{
+		gentity_t	*target = NULL;
+
+		target = G_Find( target, FOFS(targetname), ent->target2 );
+
+		if ( !target )
+		{
+			// Target2 is bogus, but we can still continue
+			Com_Printf( "fx_runner_link: target2 was specified but is not valid: %s\n", ent->target2 );
+		}
+	}
+
+	G_SetAngles( ent, ent->s.angles );
+
+	if ( ent->spawnflags & 1 || ent->spawnflags & 2 ) // STARTOFF || ONESHOT
+	{
+		// We won't even consider thinking until we are used
+		ent->nextthink = -1;
+	}
+	else
+	{
+		if ( ent->soundSet && ent->soundSet[0] )
+		{
+			ent->s.soundSetIndex = G_SoundSetIndex(ent->soundSet);
+			ent->s.loopSound = BMS_MID;
+			ent->s.loopIsSoundset = qtrue;
+		}
+
+		// Let's get to work right now!
+		ent->think = fx_runner_think;
+		ent->nextthink = level.time + 200; // wait a small bit, then start working
+	}
+
+	// make us useable if we can be targeted
+	if ( ent->targetname && ent->targetname[0] )
+	{
+		ent->use = fx_runner_use;
+	}
+}
+
+//----------------------------------------------------------
+void SP_fx_runner( gentity_t *ent )
+{
+	char *fxFile;
+
+	G_SpawnString( "fxFile", "", &fxFile );
+	// Get our defaults
+	G_SpawnInt( "delay", "200", &ent->delay );
+	G_SpawnFloat( "random", "0", &ent->random );
+	G_SpawnInt( "splashRadius", "16", &ent->splashRadius );
+	G_SpawnInt( "splashDamage", "5", &ent->splashDamage );
+
+	if (!ent->s.angles[0] && !ent->s.angles[1] && !ent->s.angles[2])
+	{
+		// didn't have angles, so give us the default of up
+		VectorSet( ent->s.angles, -90, 0, 0 );
+	}
+
+	if ( !fxFile || !fxFile[0] )
+	{
+		Com_Printf( S_COLOR_RED"ERROR: fx_runner %s at %s has no fxFile specified\n", ent->targetname, vtos(ent->s.origin) );
+		G_FreeEntity( ent );
+		return;
+	}
+
+	// Try and associate an effect file, unfortunately we won't know if this worked or not 
+	//	until the CGAME trys to register it...
+	ent->s.modelindex = G_EffectIndex( fxFile );
+
+	// important info transmitted
+	ent->s.eType = ET_FX;
+	ent->s.speed = ent->delay;
+	ent->s.time = ent->random;
+	ent->s.modelindex2 = FX_STATE_OFF;
+
+	// Give us a bit of time to spawn in the other entities, since we may have to target one of 'em
+	ent->think = fx_runner_link; 
+	ent->nextthink = level.time + 400;
+
+	// Save our position and link us up!
+	G_SetOrigin( ent, ent->s.origin );
+
+	VectorSet( ent->r.maxs, FX_ENT_RADIUS, FX_ENT_RADIUS, FX_ENT_RADIUS );
+	VectorScale( ent->r.maxs, -1, ent->r.mins );
+
+	trap_LinkEntity( ent );
+}
+
+/*QUAKED fx_spacedust (1 0 0) (-16 -16 -16) (16 16 16)
+This world effect will spawn space dust globally into the level.
+
+"count" the number of snow particles (default of 1000)
+*/
+//----------------------------------------------------------
+void SP_CreateSpaceDust( gentity_t *ent )
+{ 
+	G_EffectIndex(va("*spacedust %i", ent->count));
+	//G_EffectIndex("*constantwind ( 10 -10 0 )");
+}
+
+
+/*QUAKED fx_snow (1 0 0) (-16 -16 -16) (16 16 16)
+This world effect will spawn snow globally into the level.
+
+"count" the number of snow particles (default of 1000)
+*/
+//----------------------------------------------------------
+void SP_CreateSnow( gentity_t *ent )
+{ 
+	G_EffectIndex("*snow");
+	G_EffectIndex("*fog");
+	G_EffectIndex("*constantwind (100 100 -100)");
+}
+
+/*QUAKED fx_rain (1 0 0) (-16 -16 -16) (16 16 16)
+This world effect will spawn rain globally into the level.
+
+"count" the number of rain particles (default of 500)
+*/
+//----------------------------------------------------------
+void SP_CreateRain( gentity_t *ent )
+{ 
+	G_EffectIndex(va("*rain init %i", ent->count));
+}
+
+qboolean gEscaping = qfalse;
+int gEscapeTime = 0;
+
+void Use_Target_Screenshake( gentity_t *ent, gentity_t *other, gentity_t *activator )
+{
+	qboolean bGlobal = qfalse;
+
+	if (ent->genericValue6)
+	{
+		bGlobal = qtrue;
+	}
+
+	G_ScreenShake(ent->s.origin, NULL, ent->speed, ent->genericValue5, bGlobal);
+}
+
+void SP_target_screenshake(gentity_t *ent)
+{
+	G_SpawnFloat( "intensity", "10", &ent->speed );
+	//intensity of the shake
+	G_SpawnInt( "duration", "800", &ent->genericValue5 );
+	//duration of the shake
+	G_SpawnInt( "globalshake", "1", &ent->genericValue6 );
+	//non-0 if shake should be global (all clients). Otherwise, only in the PVS.
+
+	ent->use = Use_Target_Screenshake;
+}
+
+void LogExit( const char *string );
+
+void Use_Target_Escapetrig( gentity_t *ent, gentity_t *other, gentity_t *activator )
+{
+	if (!ent->genericValue6)
+	{
+		gEscaping = qtrue;
+		gEscapeTime = level.time + ent->genericValue5;
+	}
+	else if (gEscaping)
+	{
+		int i = 0;
+		gEscaping = qfalse;
+		while (i < MAX_CLIENTS)
+		{ //all of the survivors get 100 points!
+			if (g_entities[i].inuse && g_entities[i].client && g_entities[i].health > 0 &&
+				g_entities[i].client->sess.sessionTeam != TEAM_SPECTATOR &&
+				!(g_entities[i].client->ps.pm_flags & PMF_FOLLOW))
+			{
+				AddScore(&g_entities[i], g_entities[i].client->ps.origin, 100);
+			}
+			i++;
+		}
+		if (activator && activator->inuse && activator->client)
+		{ //the one who escaped gets 500
+			AddScore(activator, activator->client->ps.origin, 500);
+		}
+
+		LogExit("Escaped!");
+	}
+}
+
+void SP_target_escapetrig(gentity_t *ent)
+{
+	if (g_gametype.integer != GT_SINGLE_PLAYER)
+	{
+		G_FreeEntity(ent);
+		return;
+	}
+
+	G_SpawnInt( "escapetime", "60000", &ent->genericValue5);
+	//time given (in ms) for the escape
+	G_SpawnInt( "escapegoal", "0", &ent->genericValue6);
+	//if non-0, when used, will end an ongoing escape instead of start it
+
+	ent->use = Use_Target_Escapetrig;
+}
+
+/*QUAKED misc_maglock (0 .5 .8) (-8 -8 -8) (8 8 8) x x x x x x x x
+Place facing a door (using the angle, not a targetname) and it will lock that door.  Can only be destroyed by lightsaber and will automatically unlock the door it's attached to
+
+NOTE: place these half-way in the door to make it flush with the door's surface.
+
+"target"	thing to use when destoryed (not doors - it automatically unlocks the door it was angled at)
+"health"	default is 10
+*/
+void maglock_die(gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int mod)
+{
+	//unlock our door if we're the last lock pointed at the door
+	if ( self->activator )
+	{
+		self->activator->lockCount--;
+		if ( !self->activator->lockCount )
+		{
+			self->activator->flags &= ~FL_INACTIVE;
+		}
+	}
+	
+	//use targets
+	G_UseTargets( self, attacker );
+	//die
+	//rwwFIXMEFIXME - weap expl func
+//	WP_Explode( self );
+}
+
+void maglock_link( gentity_t *self );
+gentity_t *G_FindDoorTrigger( gentity_t *ent );
+
+void SP_misc_maglock ( gentity_t *self )
+{
+	//NOTE: May have to make these only work on doors that are either untargeted 
+	//		or are targeted by a trigger, not doors fired off by scripts, counters 
+	//		or other such things?
+	self->s.modelindex = G_ModelIndex( "models/map_objects/imp_detention/door_lock.md3" );
+	self->genericValue1 = G_EffectIndex( "maglock/explosion" );
+
+	G_SetOrigin( self, self->s.origin );
+
+	self->think = maglock_link;
+	//FIXME: for some reason, when you re-load a level, these fail to find their doors...?  Random?  Testing an additional 200ms after the START_TIME_FIND_LINKS
+	self->nextthink = level.time + START_TIME_FIND_LINKS+200;//START_TIME_FIND_LINKS;//because we need to let the doors link up and spawn their triggers first!
+}
+void maglock_link( gentity_t *self )
+{
+	//find what we're supposed to be attached to
+	vec3_t	forward, start, end;
+	trace_t	trace;
+	gentity_t *traceEnt;
+
+	AngleVectors( self->s.angles, forward, NULL, NULL );
+	VectorMA( self->s.origin, 128, forward, end );
+	VectorMA( self->s.origin, -4, forward, start );
+
+	trap_Trace( &trace, start, vec3_origin, vec3_origin, end, self->s.number, MASK_SHOT );
+
+	if ( trace.allsolid || trace.startsolid )
+	{
+		Com_Error( ERR_DROP,"misc_maglock at %s in solid\n", vtos(self->s.origin) );
+		G_FreeEntity( self );
+		return;
+	}
+	if ( trace.fraction == 1.0 )
+	{
+		self->think = maglock_link;
+		self->nextthink = level.time + 100;
+		/*
+		Com_Error( ERR_DROP,"misc_maglock at %s pointed at no surface\n", vtos(self->s.origin) );
+		G_FreeEntity( self );
+		*/
+		return;
+	}
+	traceEnt = &g_entities[trace.entityNum];
+	if ( trace.entityNum >= ENTITYNUM_WORLD || !traceEnt || Q_stricmp( "func_door", traceEnt->classname ) )
+	{
+		self->think = maglock_link;
+		self->nextthink = level.time + 100;
+		//Com_Error( ERR_DROP,"misc_maglock at %s not pointed at a door\n", vtos(self->s.origin) );
+		//G_FreeEntity( self );
+		return;
+	}
+
+	//check the traceEnt, make sure it's a door and give it a lockCount and deactivate it
+	//find the trigger for the door
+	self->activator = G_FindDoorTrigger( traceEnt );
+	if ( !self->activator )
+	{
+		self->activator = traceEnt;
+	}
+	self->activator->lockCount++;
+	self->activator->flags |= FL_INACTIVE;
+
+	//now position and orient it
+	vectoangles( trace.plane.normal, end );
+	G_SetOrigin( self, trace.endpos );
+	G_SetAngles( self, end );
+
+	//make it hittable
+	//FIXME: if rotated/inclined this bbox may be off... but okay if we're a ghoul model?
+	//self->s.modelindex = G_ModelIndex( "models/map_objects/imp_detention/door_lock.md3" );
+	VectorSet( self->r.mins, -8, -8, -8 );
+	VectorSet( self->r.maxs, 8, 8, 8 );
+	self->r.contents = CONTENTS_CORPSE;
+
+	//make it destroyable
+	self->flags |= FL_SHIELDED;//only damagable by lightsabers
+	self->takedamage = qtrue;
+	self->health = 10;
+	self->die = maglock_die;
+	//self->fxID = G_EffectIndex( "maglock/explosion" );
+
+	trap_LinkEntity( self );
+}
+
+void faller_touch(gentity_t *self, gentity_t *other, trace_t *trace)
+{
+	if (self->epVelocity[2] < -100 && self->genericValue7 < level.time)
+	{
+		int r = Q_irand(1, 3);
+
+		if (r == 1)
+		{
+			self->genericValue11 = G_SoundIndex("sound/chars/stofficer1/misc/pain25");
+		}
+		else if (r == 2)
+		{
+			self->genericValue11 = G_SoundIndex("sound/chars/stofficer1/misc/pain50");
+		}
+		else
+		{
+			self->genericValue11 = G_SoundIndex("sound/chars/stofficer1/misc/pain75");
+		}
+
+		G_EntitySound(self, CHAN_VOICE, self->genericValue11);
+		G_EntitySound(self, CHAN_AUTO, self->genericValue10);
+
+		self->genericValue6 = level.time + 3000;
+
+		self->genericValue7 = level.time + 200;
+	}
+}
+
+void faller_think(gentity_t *ent)
+{
+	float gravity = 3.0f;
+	float mass = 0.09f;
+	float bounce = 1.1f;
+
+	if (ent->genericValue6 < level.time)
+	{
+		ent->think = G_FreeEntity;
+		ent->nextthink = level.time;
+		return;
+	}
+
+	if (ent->epVelocity[2] < -100)
+	{
+		if (!ent->genericValue8)
+		{
+			G_EntitySound(ent, CHAN_VOICE, ent->genericValue9);
+			ent->genericValue8 = 1;
+		}
+	}
+	else
+	{
+		ent->genericValue8 = 0;
+	}
+
+	G_RunExPhys(ent, gravity, mass, bounce, qtrue, NULL, 0);
+	VectorScale(ent->epVelocity, 10.0f, ent->s.pos.trDelta);
+	ent->nextthink = level.time + 25;
+}
+
+void misc_faller_create( gentity_t *ent, gentity_t *other, gentity_t *activator )
+{
+	gentity_t *faller = G_Spawn();
+
+	faller->genericValue10 = G_SoundIndex("sound/player/fallsplat");
+	faller->genericValue9 = G_SoundIndex("sound/chars/stofficer1/misc/falling1");
+	faller->genericValue8 = 0;
+	faller->genericValue7 = 0;
+
+	faller->genericValue6 = level.time + 15000;
+
+	G_SetOrigin(faller, ent->s.origin);
+
+	faller->s.modelGhoul2 = 1;
+	faller->s.modelindex = G_ModelIndex("models/players/stormtrooper/model.glm");
+	faller->s.g2radius = 100;
+	
+	faller->s.customRGBA[0]=Q_irand(1,255);
+	faller->s.customRGBA[1]=Q_irand(1,255);
+	faller->s.customRGBA[2]=Q_irand(1,255);
+	faller->s.customRGBA[3]=255;
+
+	VectorSet(faller->r.mins, -15, -15, DEFAULT_MINS_2);
+	VectorSet(faller->r.maxs, 15, 15, DEFAULT_MAXS_2);
+	
+	faller->clipmask = MASK_PLAYERSOLID;
+	faller->r.contents = MASK_PLAYERSOLID;
+
+	faller->s.eFlags = (EF_RAG|EF_CLIENTSMOOTH);
+
+	faller->think = faller_think;
+	faller->nextthink = level.time;
+
+	faller->touch = faller_touch;
+
+	faller->epVelocity[0] = flrand(-256.0f, 256.0f);
+	faller->epVelocity[1] = flrand(-256.0f, 256.0f);
+
+	trap_LinkEntity(faller);
+}
+
+void misc_faller_think(gentity_t *ent)
+{
+	misc_faller_create(ent, ent, ent);
+	ent->nextthink = level.time + ent->genericValue1 + Q_irand(0, ent->genericValue2);
+}
+
+/*QUAKED misc_faller (1 0 0) (-8 -8 -8) (8 8 8)
+Falling stormtrooper - spawned every interval+random fudgefactor,
+or if specified, when used.
+
+targetname	- if specified, will only spawn when used
+interval	- spawn every so often (milliseconds)
+fudgefactor	- milliseconds between 0 and this number randomly added to interval
+*/
+void SP_misc_faller(gentity_t *ent)
+{
+	G_ModelIndex("models/players/stormtrooper/model.glm");
+	G_SoundIndex("sound/chars/stofficer1/misc/pain25");
+	G_SoundIndex("sound/chars/stofficer1/misc/pain50");
+	G_SoundIndex("sound/chars/stofficer1/misc/pain75");
+	G_SoundIndex("sound/chars/stofficer1/misc/falling1");
+	G_SoundIndex("sound/player/fallsplat");
+
+	G_SpawnInt("interval", "500", &ent->genericValue1);
+	G_SpawnInt("fudgefactor", "0", &ent->genericValue2);
+
+	if (!ent->targetname || !ent->targetname[0])
+	{
+		ent->think = misc_faller_think;
+		ent->nextthink = level.time + ent->genericValue1 + Q_irand(0, ent->genericValue2);
+	}
+	else
+	{
+		ent->use = misc_faller_create;
+	}
+}
+
+//rww - ref tag stuff ported from SP (and C-ified)
+#define	TAG_GENERIC_NAME	"__WORLD__"	//If a designer chooses this name, cut a finger off as an example to the others
+
+//MAX_TAG_OWNERS is 16 for now in order to not use too much VM memory.
+//Each tag owner has preallocated space for tags up to MAX_TAGS.
+//As is this means 16*256 sizeof(reference_tag_t)'s in addition to name+inuse*16.
+#define MAX_TAGS 256
+#define MAX_TAG_OWNERS 16
+
+//Maybe I should use my trap_TrueMalloc/trap_TrueFree stuff with this.
+//But I am not yet confident that it can be used without exploding at some point.
+
+typedef struct tagOwner_s
+{
+	char			name[MAX_REFNAME];
+	reference_tag_t	tags[MAX_TAGS];
+	qboolean		inuse;
+} tagOwner_t;
+
+tagOwner_t refTagOwnerMap[MAX_TAG_OWNERS];
+
+tagOwner_t *FirstFreeTagOwner(void)
+{
+	int i = 0;
+
+	while (i < MAX_TAG_OWNERS)
+	{
+		if (!refTagOwnerMap[i].inuse)
+		{
+			return &refTagOwnerMap[i];
+		}
+		i++;
+	}
+
+	Com_Printf("WARNING: MAX_TAG_OWNERS (%i) REF TAG LIMIT HIT\n", MAX_TAG_OWNERS);
+	return NULL;
+}
+
+reference_tag_t *FirstFreeRefTag(tagOwner_t *tagOwner)
+{
+	int i = 0;
+
+	assert(tagOwner);
+
+	while (i < MAX_TAGS)
+	{
+		if (!tagOwner->tags[i].inuse)
+		{
+			return &tagOwner->tags[i];
+		}
+		i++;
+	}
+
+	Com_Printf("WARNING: MAX_TAGS (%i) REF TAG LIMIT HIT\n", MAX_TAGS);
+	return NULL;
+}
+
+/*
+-------------------------
+TAG_Init
+-------------------------
+*/
+
+void TAG_Init( void )
+{
+	int i = 0;
+	int x = 0;
+
+	while (i < MAX_TAG_OWNERS)
+	{
+		while (x < MAX_TAGS)
+		{
+			memset(&refTagOwnerMap[i].tags[x], 0, sizeof(refTagOwnerMap[i].tags[x]));
+			x++;
+		}
+		memset(&refTagOwnerMap[i], 0, sizeof(refTagOwnerMap[i]));
+		i++;
+	}
+}
+
+/*
+-------------------------
+TAG_FindOwner
+-------------------------
+*/
+
+tagOwner_t	*TAG_FindOwner( const char *owner )
+{
+	int i = 0;
+
+	while (i < MAX_TAG_OWNERS)
+	{
+		if (refTagOwnerMap[i].inuse && !Q_stricmp(refTagOwnerMap[i].name, owner))
+		{
+			return &refTagOwnerMap[i];
+		}
+		i++;
+	}
+
+	return NULL;
+}
+
+/*
+-------------------------
+TAG_Find
+-------------------------
+*/
+
+reference_tag_t	*TAG_Find( const char *owner, const char *name )
+{
+	tagOwner_t	*tagOwner = NULL;
+	int i = 0;
+
+	if (owner && owner[0])
+	{
+		tagOwner = TAG_FindOwner(owner);
+	}
+	if (!tagOwner)
+	{
+		tagOwner = TAG_FindOwner(TAG_GENERIC_NAME);
+	}
+
+	//Not found...
+	if (!tagOwner)
+	{
+		tagOwner = TAG_FindOwner( TAG_GENERIC_NAME );
+
+		if (!tagOwner)
+		{
+			return NULL;
+		}
+	}
+
+	while (i < MAX_TAGS)
+	{
+		if (tagOwner->tags[i].inuse && !Q_stricmp(tagOwner->tags[i].name, name))
+		{
+			return &tagOwner->tags[i];
+		}
+		i++;
+	}
+
+	//Try the generic owner instead
+	tagOwner = TAG_FindOwner( TAG_GENERIC_NAME );
+
+	if (!tagOwner)
+	{
+		return NULL;
+	}
+
+	i = 0;
+	while (i < MAX_TAGS)
+	{
+		if (tagOwner->tags[i].inuse && !Q_stricmp(tagOwner->tags[i].name, name))
+		{
+			return &tagOwner->tags[i];
+		}
+		i++;
+	}
+
+	return NULL;
+}
+
+/*
+-------------------------
+TAG_Add
+-------------------------
+*/
+
+reference_tag_t	*TAG_Add( const char *name, const char *owner, vec3_t origin, vec3_t angles, int radius, int flags )
+{
+	reference_tag_t	*tag = NULL;
+	tagOwner_t	*tagOwner = NULL;
+
+	//Make sure this tag's name isn't alread in use
+	if ( TAG_Find( owner, name ) )
+	{
+		Com_Printf(S_COLOR_RED"Duplicate tag name \"%s\"\n", name );
+		return NULL;
+	}
+
+	//Attempt to add this to the owner's list
+	if ( !owner || !owner[0] )
+	{
+		//If the owner isn't found, use the generic world name
+		owner = TAG_GENERIC_NAME;
+	}
+
+	tagOwner = TAG_FindOwner( owner );
+	
+	if (!tagOwner)
+	{
+		//Create a new owner list
+		tagOwner = FirstFreeTagOwner();//new	tagOwner_t;
+
+		if (!tagOwner)
+		{
+			assert(0);
+			return 0;
+		}
+	}
+	
+	//This is actually reverse order of how SP does it because of the way we're storing/allocating.
+	//Now that we have the owner, we want to get the first free reftag on the owner itself.
+	tag = FirstFreeRefTag(tagOwner);
+
+	if (!tag)
+	{
+		assert(0);
+		return NULL;
+	}
+
+	//Copy the information
+	VectorCopy( origin, tag->origin );
+	VectorCopy( angles, tag->angles );
+	tag->radius = radius;
+	tag->flags	= flags;
+
+	if ( !name || !name[0] )
+	{
+		Com_Printf(S_COLOR_RED"ERROR: Nameless ref_tag found at (%i %i %i)\n", (int)origin[0], (int)origin[1], (int)origin[2]);
+		return NULL;
+	}
+
+
+	//Copy the name
+	Q_strncpyz( (char *) tagOwner->name, owner, MAX_REFNAME );
+	Q_strlwr( (char *) tagOwner->name );	//NOTENOTE: For case insensitive searches on a map
+
+	//Copy the name
+	Q_strncpyz( (char *) tag->name, name, MAX_REFNAME );
+	Q_strlwr( (char *) tag->name );	//NOTENOTE: For case insensitive searches on a map
+
+	tagOwner->inuse = qtrue;
+	tag->inuse = qtrue;
+
+	return tag;
+}
+
+/*
+-------------------------
+TAG_GetOrigin
+-------------------------
+*/
+
+int	TAG_GetOrigin( const char *owner, const char *name, vec3_t origin )
+{
+	reference_tag_t	*tag = TAG_Find( owner, name );
+
+	if (!tag)
+	{
+		VectorClear(origin);
+		return 0;
+	}
+
+	VectorCopy( tag->origin, origin );
+
+	return 1;
+}
+
+/*
+-------------------------
+TAG_GetOrigin2
+Had to get rid of that damn assert for dev
+-------------------------
+*/
+
+int	TAG_GetOrigin2( const char *owner, const char *name, vec3_t origin )
+{
+	reference_tag_t	*tag = TAG_Find( owner, name );
+
+	if( tag == NULL )
+	{
+		return 0;
+	}
+
+	VectorCopy( tag->origin, origin );
+
+	return 1;
+}
+/*
+-------------------------
+TAG_GetAngles
+-------------------------
+*/
+
+int	TAG_GetAngles( const char *owner, const char *name, vec3_t angles )
+{
+	reference_tag_t	*tag = TAG_Find( owner, name );
+
+	if (!tag)
+	{
+		assert(0);
+		return 0;
+	}
+
+	VectorCopy( tag->angles, angles );
+	
+	return 1;
+}
+
+/*
+-------------------------
+TAG_GetRadius
+-------------------------
+*/
+
+int TAG_GetRadius( const char *owner, const char *name )
+{
+	reference_tag_t	*tag = TAG_Find( owner, name );
+
+	if (!tag)
+	{
+		assert(0);
+		return 0;
+	}
+
+	return tag->radius;
+}
+
+/*
+-------------------------
+TAG_GetFlags
+-------------------------
+*/
+
+int TAG_GetFlags( const char *owner, const char *name )
+{
+	reference_tag_t	*tag = TAG_Find( owner, name );
+
+	if (!tag)
+	{
+		assert(0);
+		return 0;
+	}
+
+	return tag->flags;
+}
+
+/*
+==============================================================================
+
+Spawn functions
+
+==============================================================================
+*/
+
+/*QUAKED ref_tag_huge (0.5 0.5 1) (-128 -128 -128) (128 128 128)
+SAME AS ref_tag, JUST BIGGER SO YOU CAN SEE THEM IN EDITOR ON HUGE MAPS!
+
+Reference tags which can be positioned throughout the level.
+These tags can later be refered to by the scripting system
+so that their origins and angles can be referred to.
+
+If you set angles on the tag, these will be retained.
+
+If you target a ref_tag at an entity, that will set the ref_tag's
+angles toward that entity.
+
+If you set the ref_tag's ownername to the ownername of an entity,
+it makes that entity is the owner of the ref_tag.  This means 
+that the owner, and only the owner, may refer to that tag.
+
+Tags may not have the same name as another tag with the same
+owner.  However, tags with different owners may have the same
+name as one another.  In this way, scripts can generically 
+refer to tags by name, and their owners will automatically
+specifiy which tag is being referred to.
+
+targetname	- the name of this tag
+ownername	- the owner of this tag
+target		- use to point the tag at something for angles
+*/
+
+/*QUAKED ref_tag (0.5 0.5 1) (-8 -8 -8) (8 8 8)
+
+Reference tags which can be positioned throughout the level.
+These tags can later be refered to by the scripting system
+so that their origins and angles can be referred to.
+
+If you set angles on the tag, these will be retained.
+
+If you target a ref_tag at an entity, that will set the ref_tag's
+angles toward that entity.
+
+If you set the ref_tag's ownername to the ownername of an entity,
+it makes that entity is the owner of the ref_tag.  This means 
+that the owner, and only the owner, may refer to that tag.
+
+Tags may not have the same name as another tag with the same
+owner.  However, tags with different owners may have the same
+name as one another.  In this way, scripts can generically 
+refer to tags by name, and their owners will automatically
+specifiy which tag is being referred to.
+
+targetname	- the name of this tag
+ownername	- the owner of this tag
+target		- use to point the tag at something for angles
+*/
+
+void ref_link ( gentity_t *ent )
+{
+	reference_tag_t	*tag;
+
+	if ( ent->target )
+	{
+		//TODO: Find the target and set our angles to that direction
+		gentity_t	*target = G_Find( NULL, FOFS(targetname), ent->target );
+		vec3_t	dir;
+
+		if ( target )
+		{
+			//Find the direction to the target
+			VectorSubtract( target->s.origin, ent->s.origin, dir );
+			VectorNormalize( dir );
+			vectoangles( dir, ent->s.angles );
+			
+			//FIXME: Does pitch get flipped?
+		}
+		else
+		{
+			Com_Printf( S_COLOR_RED"ERROR: ref_tag (%s) has invalid target (%s)", ent->targetname, ent->target );
+		}
+	}
+	
+	//Add the tag
+	tag = TAG_Add( ent->targetname, ent->ownername, ent->s.origin, ent->s.angles, 16, 0 );
+
+	//Delete immediately, cannot be refered to as an entity again
+	//NOTE: this means if you wanted to link them in a chain for, say, a path, you can't
+	G_FreeEntity( ent );
+}
+
+void SP_reference_tag ( gentity_t *ent )
+{
+	if ( ent->target )
+	{
+		//Init cannot occur until all entities have been spawned
+		ent->think = ref_link;
+		ent->nextthink = level.time + START_TIME_LINK_ENTS;
+	}
+	else
+	{
+		ref_link( ent );
+	}
+}
+
+/*QUAKED misc_weapon_shooter (1 0 0) (-8 -8 -8) (8 8 8) ALTFIRE TOGGLE
+ALTFIRE - fire the alt-fire of the chosen weapon
+TOGGLE - keep firing until used again (fires at intervals of "wait")
+
+"wait" - debounce time between refires (defaults to 500)
+
+"target" - what to aim at (will update aim every frame if it's a moving target)  
+
+"weapon" - specify the weapon to use (default is WP_BLASTER)
+	WP_BRYAR_PISTOL
+	WP_BLASTER
+	WP_DISRUPTOR
+	WP_BOWCASTER
+	WP_REPEATER
+	WP_DEMP2
+	WP_FLECHETTE
+	WP_ROCKET_LAUNCHER
+	WP_THERMAL
+	WP_TRIP_MINE
+	WP_DET_PACK
+	WP_STUN_BATON
+	WP_EMPLACED_GUN
+	WP_BOT_LASER
+	WP_TURRET
+	WP_ATST_MAIN
+	WP_ATST_SIDE
+	WP_TIE_FIGHTER
+	WP_RAPID_FIRE_CONC
+	WP_BLASTER_PISTOL
+*/
+//kind of hacky, but we have to do this with no dynamic allocation
+#define MAX_SHOOTERS		16
+typedef struct shooterClient_s
+{
+	gclient_t		cl;
+	qboolean		inuse;
+} shooterClient_t;
+static shooterClient_t g_shooterClients[MAX_SHOOTERS];
+static qboolean g_shooterClientInit = qfalse;
+
+gclient_t *G_ClientForShooter(void)
+{
+	int i = 0;
+
+	if (!g_shooterClientInit)
+	{ //in theory it should be initialized to 0 on the stack, but just in case.
+		memset(g_shooterClients, 0, sizeof(shooterClient_t)*MAX_SHOOTERS);
+		g_shooterClientInit = qtrue;
+	}
+
+	while (i < MAX_SHOOTERS)
+	{
+		if (!g_shooterClients[i].inuse)
+		{
+			return &g_shooterClients[i].cl;
+		}
+		i++;
+	}
+
+	Com_Error(ERR_DROP, "No free shooter clients - hit MAX_SHOOTERS");
+	return NULL;
+}
+
+void G_FreeClientForShooter(gclient_t *cl)
+{
+	int i = 0;
+	while (i < MAX_SHOOTERS)
+	{
+		if (&g_shooterClients[i].cl == cl)
+		{
+			g_shooterClients[i].inuse = qfalse;
+			return;
+		}
+		i++;
+	}
+}
+
+void misc_weapon_shooter_fire( gentity_t *self )
+{
+	FireWeapon( self, (self->spawnflags&1) );
+	if ( (self->spawnflags&2) )
+	{//repeat
+		self->think = misc_weapon_shooter_fire;
+		self->nextthink = level.time + self->wait;
+	}
+}
+
+void misc_weapon_shooter_use ( gentity_t *self, gentity_t *other, gentity_t *activator )
+{
+	if ( self->think == misc_weapon_shooter_fire )
+	{//repeating fire, stop
+		/*
+		G_FreeClientForShooter(self->client);
+		self->think = G_FreeEntity;
+		self->nextthink = level.time;
+		*/
+		self->nextthink = 0;
+		return;
+	}
+	//otherwise, fire
+	misc_weapon_shooter_fire( self );
+}
+
+void misc_weapon_shooter_aim( gentity_t *self )
+{
+	//update my aim
+	if ( self->target )
+	{
+		gentity_t *targ = G_Find( NULL, FOFS(targetname), self->target );
+		if ( targ )
+		{
+			self->enemy = targ;
+			VectorSubtract( targ->r.currentOrigin, self->r.currentOrigin, self->pos1 );
+			VectorCopy( targ->r.currentOrigin, self->pos1 );
+			vectoangles( self->pos1, self->client->ps.viewangles );
+			SetClientViewAngle( self, self->client->ps.viewangles );
+			//FIXME: don't keep doing this unless target is a moving target?
+			self->nextthink = level.time + FRAMETIME;
+		}
+		else
+		{
+			self->enemy = NULL;
+		}
+	}
+}
+
+#include "../namespace_begin.h"
+extern stringID_table_t WPTable[];
+#include "../namespace_end.h"
+
+void SP_misc_weapon_shooter( gentity_t *self )
+{
+	char *s;
+
+	//alloc a client just for the weapon code to use
+	self->client = G_ClientForShooter();//(gclient_s *)gi.Malloc(sizeof(gclient_s), TAG_G_ALLOC, qtrue);
+
+	G_SpawnString("weapon", "", &s);
+
+	//set weapon
+	self->s.weapon = self->client->ps.weapon = WP_BLASTER;
+	if ( s && s[0] )
+	{//use a different weapon
+		self->s.weapon = self->client->ps.weapon = GetIDForString( WPTable, s );
+	}
+
+	RegisterItem(BG_FindItemForWeapon(self->s.weapon));
+
+	//set where our muzzle is
+	VectorCopy( self->s.origin, self->client->renderInfo.muzzlePoint );
+	//permanently updated (don't need for MP)
+	//self->client->renderInfo.mPCalcTime = Q3_INFINITE;
+
+	//set up to link
+	if ( self->target )
+	{
+        self->think = misc_weapon_shooter_aim;
+		self->nextthink = level.time + START_TIME_LINK_ENTS;
+	}
+	else
+	{//just set aim angles
+		VectorCopy( self->s.angles, self->client->ps.viewangles );
+		AngleVectors( self->s.angles, self->pos1, NULL, NULL );
+	}
+
+	//set up to fire when used
+    self->use = misc_weapon_shooter_use;
+
+	if ( !self->wait )
+	{
+		self->wait = 500;
+	}
+}
+
+/*QUAKED misc_weather_zone (0 .5 .8) ? 
+Determines a region to check for weather contents - will significantly reduce load time
+*/
+void SP_misc_weather_zone( gentity_t *ent )
+{
+	G_FreeEntity(ent);
+}
diff --git a/codemp/game/g_missile.c b/codemp/game/g_missile.c
new file mode 100644
index 0000000..b22f6aa
--- /dev/null
+++ b/codemp/game/g_missile.c
@@ -0,0 +1,1010 @@
+// Copyright (C) 1999-2000 Id Software, Inc.
+//
+#include "g_local.h"
+#include "w_saber.h"
+#include "q_shared.h"
+
+#define	MISSILE_PRESTEP_TIME	50
+
+extern void laserTrapStick( gentity_t *ent, vec3_t endpos, vec3_t normal );
+extern void Jedi_Decloak( gentity_t *self );
+
+#include "../namespace_begin.h"
+extern qboolean FighterIsLanded( Vehicle_t *pVeh, playerState_t *parentPS );
+#include "../namespace_end.h"
+
+/*
+================
+G_ReflectMissile
+
+  Reflect the missile roughly back at it's owner
+================
+*/
+float RandFloat(float min, float max);
+void G_ReflectMissile( gentity_t *ent, gentity_t *missile, vec3_t forward ) 
+{
+	vec3_t	bounce_dir;
+	int		i;
+	float	speed;
+	gentity_t	*owner = ent;
+	int		isowner = 0;
+
+	if ( ent->r.ownerNum )
+	{
+		owner = &g_entities[ent->r.ownerNum];
+	}
+
+	if (missile->r.ownerNum == ent->s.number)
+	{ //the original owner is bouncing the missile, so don't try to bounce it back at him
+		isowner = 1;
+	}
+
+	//save the original speed
+	speed = VectorNormalize( missile->s.pos.trDelta );
+
+	//if ( ent && owner && owner->NPC && owner->enemy && Q_stricmp( "Tavion", owner->NPC_type ) == 0 && Q_irand( 0, 3 ) )
+	if ( &g_entities[missile->r.ownerNum] && missile->s.weapon != WP_SABER && missile->s.weapon != G2_MODEL_PART && !isowner )
+	{//bounce back at them if you can
+		VectorSubtract( g_entities[missile->r.ownerNum].r.currentOrigin, missile->r.currentOrigin, bounce_dir );
+		VectorNormalize( bounce_dir );
+	}
+	else if (isowner)
+	{ //in this case, actually push the missile away from me, and since we're giving boost to our own missile by pushing it, up the velocity
+		vec3_t missile_dir;
+
+		speed *= 1.5;
+
+		VectorSubtract( missile->r.currentOrigin, ent->r.currentOrigin, missile_dir );
+		VectorCopy( missile->s.pos.trDelta, bounce_dir );
+		VectorScale( bounce_dir, DotProduct( forward, missile_dir ), bounce_dir );
+		VectorNormalize( bounce_dir );
+	}
+	else
+	{
+		vec3_t missile_dir;
+
+		VectorSubtract( ent->r.currentOrigin, missile->r.currentOrigin, missile_dir );
+		VectorCopy( missile->s.pos.trDelta, bounce_dir );
+		VectorScale( bounce_dir, DotProduct( forward, missile_dir ), bounce_dir );
+		VectorNormalize( bounce_dir );
+	}
+	for ( i = 0; i < 3; i++ )
+	{
+		bounce_dir[i] += RandFloat( -0.2f, 0.2f );
+	}
+
+	VectorNormalize( bounce_dir );
+	VectorScale( bounce_dir, speed, missile->s.pos.trDelta );
+	missile->s.pos.trTime = level.time;		// move a bit on the very first frame
+	VectorCopy( missile->r.currentOrigin, missile->s.pos.trBase );
+	if ( missile->s.weapon != WP_SABER && missile->s.weapon != G2_MODEL_PART )
+	{//you are mine, now!
+		missile->r.ownerNum = ent->s.number;
+	}
+	if ( missile->s.weapon == WP_ROCKET_LAUNCHER )
+	{//stop homing
+		missile->think = 0;
+		missile->nextthink = 0;
+	}
+}
+
+void G_DeflectMissile( gentity_t *ent, gentity_t *missile, vec3_t forward ) 
+{
+	vec3_t	bounce_dir;
+	int		i;
+	float	speed;
+	int		isowner = 0;
+	vec3_t missile_dir;
+
+	if (missile->r.ownerNum == ent->s.number)
+	{ //the original owner is bouncing the missile, so don't try to bounce it back at him
+		isowner = 1;
+	}
+
+	//save the original speed
+	speed = VectorNormalize( missile->s.pos.trDelta );
+
+	if (ent->client)
+	{
+		//VectorSubtract( ent->r.currentOrigin, missile->r.currentOrigin, missile_dir );
+		AngleVectors(ent->client->ps.viewangles, missile_dir, 0, 0);
+		VectorCopy(missile_dir, bounce_dir);
+		//VectorCopy( missile->s.pos.trDelta, bounce_dir );
+		VectorScale( bounce_dir, DotProduct( forward, missile_dir ), bounce_dir );
+		VectorNormalize( bounce_dir );
+	}
+	else
+	{
+		VectorCopy(forward, bounce_dir);
+		VectorNormalize(bounce_dir);
+	}
+
+	for ( i = 0; i < 3; i++ )
+	{
+		bounce_dir[i] += RandFloat( -1.0f, 1.0f );
+	}
+
+	VectorNormalize( bounce_dir );
+	VectorScale( bounce_dir, speed, missile->s.pos.trDelta );
+	missile->s.pos.trTime = level.time;		// move a bit on the very first frame
+	VectorCopy( missile->r.currentOrigin, missile->s.pos.trBase );
+	if ( missile->s.weapon != WP_SABER && missile->s.weapon != G2_MODEL_PART )
+	{//you are mine, now!
+		missile->r.ownerNum = ent->s.number;
+	}
+	if ( missile->s.weapon == WP_ROCKET_LAUNCHER )
+	{//stop homing
+		missile->think = 0;
+		missile->nextthink = 0;
+	}
+}
+
+/*
+================
+G_BounceMissile
+
+================
+*/
+void G_BounceMissile( gentity_t *ent, trace_t *trace ) {
+	vec3_t	velocity;
+	float	dot;
+	int		hitTime;
+
+	// reflect the velocity on the trace plane
+	hitTime = level.previousTime + ( level.time - level.previousTime ) * trace->fraction;
+	BG_EvaluateTrajectoryDelta( &ent->s.pos, hitTime, velocity );
+	dot = DotProduct( velocity, trace->plane.normal );
+	VectorMA( velocity, -2*dot, trace->plane.normal, ent->s.pos.trDelta );
+
+
+	if ( ent->flags & FL_BOUNCE_SHRAPNEL ) 
+	{
+		VectorScale( ent->s.pos.trDelta, 0.25f, ent->s.pos.trDelta );
+		ent->s.pos.trType = TR_GRAVITY;
+
+		// check for stop
+		if ( trace->plane.normal[2] > 0.7 && ent->s.pos.trDelta[2] < 40 ) //this can happen even on very slightly sloped walls, so changed it from > 0 to > 0.7
+		{
+			G_SetOrigin( ent, trace->endpos );
+			ent->nextthink = level.time + 100;
+			return;
+		}
+	}
+	else if ( ent->flags & FL_BOUNCE_HALF ) 
+	{
+		VectorScale( ent->s.pos.trDelta, 0.65, ent->s.pos.trDelta );
+		// check for stop
+		if ( trace->plane.normal[2] > 0.2 && VectorLength( ent->s.pos.trDelta ) < 40 ) 
+		{
+			G_SetOrigin( ent, trace->endpos );
+			return;
+		}
+	}
+
+	if (ent->s.weapon == WP_THERMAL)
+	{ //slight hack for hit sound
+		G_Sound(ent, CHAN_BODY, G_SoundIndex(va("sound/weapons/thermal/bounce%i.wav", Q_irand(1, 2))));
+	}
+	else if (ent->s.weapon == WP_SABER)
+	{
+		G_Sound(ent, CHAN_BODY, G_SoundIndex(va("sound/weapons/saber/bounce%i.wav", Q_irand(1, 3))));
+	}
+	else if (ent->s.weapon == G2_MODEL_PART)
+	{
+		//Limb bounce sound?
+	}
+
+	VectorAdd( ent->r.currentOrigin, trace->plane.normal, ent->r.currentOrigin);
+	VectorCopy( ent->r.currentOrigin, ent->s.pos.trBase );
+	ent->s.pos.trTime = level.time;
+
+	if (ent->bounceCount != -5)
+	{
+		ent->bounceCount--;
+	}
+}
+
+
+/*
+================
+G_ExplodeMissile
+
+Explode a missile without an impact
+================
+*/
+void G_ExplodeMissile( gentity_t *ent ) {
+	vec3_t		dir;
+	vec3_t		origin;
+
+	BG_EvaluateTrajectory( &ent->s.pos, level.time, origin );
+	SnapVector( origin );
+	G_SetOrigin( ent, origin );
+
+	// we don't have a valid direction, so just point straight up
+	dir[0] = dir[1] = 0;
+	dir[2] = 1;
+
+	ent->s.eType = ET_GENERAL;
+	G_AddEvent( ent, EV_MISSILE_MISS, DirToByte( dir ) );
+
+	ent->freeAfterEvent = qtrue;
+
+	ent->takedamage = qfalse;
+	// splash damage
+	if ( ent->splashDamage ) {
+		if( G_RadiusDamage( ent->r.currentOrigin, ent->parent, ent->splashDamage, ent->splashRadius, ent, 
+				ent, ent->splashMethodOfDeath ) ) 
+		{
+			if (ent->parent)
+			{
+				g_entities[ent->parent->s.number].client->accuracy_hits++;
+			}
+			else if (ent->activator)
+			{
+				g_entities[ent->activator->s.number].client->accuracy_hits++;
+			}
+		}
+	}
+
+	trap_LinkEntity( ent );
+}
+
+void G_RunStuckMissile( gentity_t *ent )
+{
+	if ( ent->takedamage )
+	{
+		if ( ent->s.groundEntityNum >= 0 && ent->s.groundEntityNum < ENTITYNUM_WORLD )
+		{
+			gentity_t *other = &g_entities[ent->s.groundEntityNum];
+
+			if ( (!VectorCompare( vec3_origin, other->s.pos.trDelta ) && other->s.pos.trType != TR_STATIONARY) || 
+				(!VectorCompare( vec3_origin, other->s.apos.trDelta ) && other->s.apos.trType != TR_STATIONARY) )
+			{//thing I stuck to is moving or rotating now, kill me
+				G_Damage( ent, other, other, NULL, NULL, 99999, 0, MOD_CRUSH );
+				return;
+			}
+		}
+	}
+	// check think function
+	G_RunThink( ent );
+}
+
+/*
+================
+G_BounceProjectile
+================
+*/
+void G_BounceProjectile( vec3_t start, vec3_t impact, vec3_t dir, vec3_t endout ) {
+	vec3_t v, newv;
+	float dot;
+
+	VectorSubtract( impact, start, v );
+	dot = DotProduct( v, dir );
+	VectorMA( v, -2*dot, dir, newv );
+
+	VectorNormalize(newv);
+	VectorMA(impact, 8192, newv, endout);
+}
+
+
+//-----------------------------------------------------------------------------
+gentity_t *CreateMissile( vec3_t org, vec3_t dir, float vel, int life, 
+							gentity_t *owner, qboolean altFire)
+//-----------------------------------------------------------------------------
+{
+	gentity_t	*missile;
+
+	missile = G_Spawn();
+	
+	missile->nextthink = level.time + life;
+	missile->think = G_FreeEntity;
+	missile->s.eType = ET_MISSILE;
+	missile->r.svFlags = SVF_USE_CURRENT_ORIGIN;
+	missile->parent = owner;
+	missile->r.ownerNum = owner->s.number;
+
+	if (altFire)
+	{
+		missile->s.eFlags |= EF_ALT_FIRING;
+	}
+
+	missile->s.pos.trType = TR_LINEAR;
+	missile->s.pos.trTime = level.time;// - MISSILE_PRESTEP_TIME;	// NOTENOTE This is a Quake 3 addition over JK2
+	missile->target_ent = NULL;
+
+	SnapVector(org);
+	VectorCopy( org, missile->s.pos.trBase );
+	VectorScale( dir, vel, missile->s.pos.trDelta );
+	VectorCopy( org, missile->r.currentOrigin);
+	SnapVector(missile->s.pos.trDelta);
+
+	return missile;
+}
+
+void G_MissileBounceEffect( gentity_t *ent, vec3_t org, vec3_t dir )
+{
+	//FIXME: have an EV_BOUNCE_MISSILE event that checks the s.weapon and does the appropriate effect
+	switch( ent->s.weapon )
+	{
+	case WP_BOWCASTER:
+		G_PlayEffectID( G_EffectIndex("bowcaster/deflect"), ent->r.currentOrigin, dir );
+		break;
+	case WP_BLASTER:
+	case WP_BRYAR_PISTOL:
+		G_PlayEffectID( G_EffectIndex("blaster/deflect"), ent->r.currentOrigin, dir );
+		break;
+	default:
+		{
+			gentity_t *te = G_TempEntity( org, EV_SABER_BLOCK );
+			VectorCopy(org, te->s.origin);
+			VectorCopy(dir, te->s.angles);
+			te->s.eventParm = 0;
+		}
+		break;
+	}
+}
+
+/*
+================
+G_MissileImpact
+================
+*/
+void WP_SaberBlockNonRandom( gentity_t *self, vec3_t hitloc, qboolean missileBlock );
+void G_MissileImpact( gentity_t *ent, trace_t *trace ) {
+	gentity_t		*other;
+	qboolean		hitClient = qfalse;
+	qboolean		isKnockedSaber = qfalse;
+
+	other = &g_entities[trace->entityNum];
+
+	// check for bounce
+	if ( !other->takedamage &&
+		(ent->bounceCount > 0 || ent->bounceCount == -5) &&
+		( ent->flags & ( FL_BOUNCE | FL_BOUNCE_HALF ) ) ) {
+		G_BounceMissile( ent, trace );
+		G_AddEvent( ent, EV_GRENADE_BOUNCE, 0 );
+		return;
+	}
+	else if (ent->neverFree && ent->s.weapon == WP_SABER && (ent->flags & FL_BOUNCE_HALF))
+	{ //this is a knocked-away saber
+		if (ent->bounceCount > 0 || ent->bounceCount == -5)
+		{
+			G_BounceMissile( ent, trace );
+			G_AddEvent( ent, EV_GRENADE_BOUNCE, 0 );
+			return;
+		}
+
+		isKnockedSaber = qtrue;
+	}
+	
+	// I would glom onto the FL_BOUNCE code section above, but don't feel like risking breaking something else
+	if ( (!other->takedamage && (ent->bounceCount > 0 || ent->bounceCount == -5) && ( ent->flags&(FL_BOUNCE_SHRAPNEL) ) ) || ((trace->surfaceFlags&SURF_FORCEFIELD)&&!ent->splashDamage&&!ent->splashRadius&&(ent->bounceCount > 0 || ent->bounceCount == -5)) ) 
+	{
+		G_BounceMissile( ent, trace );
+
+		if ( ent->bounceCount < 1 )
+		{
+			ent->flags &= ~FL_BOUNCE_SHRAPNEL;
+		}
+		return;
+	}
+
+	/*
+	if ( !other->takedamage && ent->s.weapon == WP_THERMAL && !ent->alt_fire )
+	{//rolling thermal det - FIXME: make this an eFlag like bounce & stick!!!
+		//G_BounceRollMissile( ent, trace );
+		if ( ent->owner && ent->owner->s.number == 0 ) 
+		{
+			G_MissileAddAlerts( ent );
+		}
+		//gi.linkentity( ent );
+		return;
+	}
+	*/
+
+	if ((other->r.contents & CONTENTS_LIGHTSABER) && !isKnockedSaber)
+	{ //hit this person's saber, so..
+		gentity_t *otherOwner = &g_entities[other->r.ownerNum];
+
+		if (otherOwner->takedamage && otherOwner->client && otherOwner->client->ps.duelInProgress &&
+			otherOwner->client->ps.duelIndex != ent->r.ownerNum)
+		{
+			goto killProj;
+		}
+	}
+	else if (!isKnockedSaber)
+	{
+		if (other->takedamage && other->client && other->client->ps.duelInProgress &&
+			other->client->ps.duelIndex != ent->r.ownerNum)
+		{
+			goto killProj;
+		}
+	}
+
+	if (other->flags & FL_DMG_BY_HEAVY_WEAP_ONLY)
+	{
+		if (ent->methodOfDeath != MOD_REPEATER_ALT &&
+			ent->methodOfDeath != MOD_ROCKET &&
+			ent->methodOfDeath != MOD_FLECHETTE_ALT_SPLASH &&
+			ent->methodOfDeath != MOD_ROCKET_HOMING &&
+			ent->methodOfDeath != MOD_THERMAL &&
+			ent->methodOfDeath != MOD_THERMAL_SPLASH &&
+			ent->methodOfDeath != MOD_TRIP_MINE_SPLASH &&
+			ent->methodOfDeath != MOD_TIMED_MINE_SPLASH &&
+			ent->methodOfDeath != MOD_DET_PACK_SPLASH &&
+			ent->methodOfDeath != MOD_VEHICLE &&
+			ent->methodOfDeath != MOD_CONC &&
+			ent->methodOfDeath != MOD_CONC_ALT &&
+			ent->methodOfDeath != MOD_SABER &&
+			ent->methodOfDeath != MOD_TURBLAST)
+		{
+			vec3_t fwd;
+
+			if (trace)
+			{
+				VectorCopy(trace->plane.normal, fwd);
+			}
+			else
+			{ //oh well
+				AngleVectors(other->r.currentAngles, fwd, NULL, NULL);
+			}
+
+			G_DeflectMissile(other, ent, fwd);
+			G_MissileBounceEffect(ent, ent->r.currentOrigin, fwd);
+			return;
+		}
+	}
+
+	if ((other->flags & FL_SHIELDED) &&
+		ent->s.weapon != WP_ROCKET_LAUNCHER &&
+		ent->s.weapon != WP_THERMAL &&
+		ent->s.weapon != WP_TRIP_MINE &&
+		ent->s.weapon != WP_DET_PACK &&
+		ent->s.weapon != WP_DEMP2 &&
+		ent->s.weapon != WP_EMPLACED_GUN &&
+		ent->methodOfDeath != MOD_REPEATER_ALT &&
+		ent->methodOfDeath != MOD_FLECHETTE_ALT_SPLASH && 
+		ent->methodOfDeath != MOD_TURBLAST &&
+		ent->methodOfDeath != MOD_VEHICLE &&
+		ent->methodOfDeath != MOD_CONC &&
+		ent->methodOfDeath != MOD_CONC_ALT &&
+		!(ent->dflags&DAMAGE_HEAVY_WEAP_CLASS) )
+	{
+		vec3_t fwd;
+
+		if (other->client)
+		{
+			AngleVectors(other->client->ps.viewangles, fwd, NULL, NULL);
+		}
+		else
+		{
+			AngleVectors(other->r.currentAngles, fwd, NULL, NULL);
+		}
+
+		G_DeflectMissile(other, ent, fwd);
+		G_MissileBounceEffect(ent, ent->r.currentOrigin, fwd);
+		return;
+	}
+		
+	if (other->takedamage && other->client &&
+		ent->s.weapon != WP_ROCKET_LAUNCHER &&
+		ent->s.weapon != WP_THERMAL &&
+		ent->s.weapon != WP_TRIP_MINE &&
+		ent->s.weapon != WP_DET_PACK &&
+		ent->s.weapon != WP_DEMP2 &&
+		ent->methodOfDeath != MOD_REPEATER_ALT &&
+		ent->methodOfDeath != MOD_FLECHETTE_ALT_SPLASH &&
+		ent->methodOfDeath != MOD_CONC &&
+		ent->methodOfDeath != MOD_CONC_ALT &&
+		other->client->ps.saberBlockTime < level.time &&
+		!isKnockedSaber &&
+		WP_SaberCanBlock(other, ent->r.currentOrigin, 0, 0, qtrue, 0))
+	{ //only block one projectile per 200ms (to prevent giant swarms of projectiles being blocked)
+		vec3_t fwd;
+		gentity_t *te;
+		int otherDefLevel = other->client->ps.fd.forcePowerLevel[FP_SABER_DEFENSE];
+
+		te = G_TempEntity( ent->r.currentOrigin, EV_SABER_BLOCK );
+		VectorCopy(ent->r.currentOrigin, te->s.origin);
+		VectorCopy(trace->plane.normal, te->s.angles);
+		te->s.eventParm = 0;
+
+		/*if (other->client->ps.velocity[2] > 0 ||
+			other->client->pers.cmd.forwardmove ||
+			other->client->pers.cmd.rightmove)
+			*/
+		if (other->client->ps.velocity[2] > 0 ||
+			other->client->pers.cmd.forwardmove < 0) //now we only do it if jumping or running backward. Should be able to full-on charge.
+		{
+			otherDefLevel -= 1;
+			if (otherDefLevel < 0)
+			{
+				otherDefLevel = 0;
+			}
+		}
+
+		AngleVectors(other->client->ps.viewangles, fwd, NULL, NULL);
+		if (otherDefLevel == FORCE_LEVEL_1)
+		{
+			//if def is only level 1, instead of deflecting the shot it should just die here
+		}
+		else if (otherDefLevel == FORCE_LEVEL_2)
+		{
+			G_DeflectMissile(other, ent, fwd);
+		}
+		else
+		{
+			G_ReflectMissile(other, ent, fwd);
+		}
+		other->client->ps.saberBlockTime = level.time + (350 - (otherDefLevel*100)); //200;
+
+		//For jedi AI
+		other->client->ps.saberEventFlags |= SEF_DEFLECTED;
+
+		if (otherDefLevel == FORCE_LEVEL_3)
+		{
+			other->client->ps.saberBlockTime = 0; //^_^
+		}
+
+		if (otherDefLevel == FORCE_LEVEL_1)
+		{
+			goto killProj;
+		}
+		return;
+	}
+	else if ((other->r.contents & CONTENTS_LIGHTSABER) && !isKnockedSaber)
+	{ //hit this person's saber, so..
+		gentity_t *otherOwner = &g_entities[other->r.ownerNum];
+
+		if (otherOwner->takedamage && otherOwner->client &&
+			ent->s.weapon != WP_ROCKET_LAUNCHER &&
+			ent->s.weapon != WP_THERMAL &&
+			ent->s.weapon != WP_TRIP_MINE &&
+			ent->s.weapon != WP_DET_PACK &&
+			ent->s.weapon != WP_DEMP2 &&
+			ent->methodOfDeath != MOD_REPEATER_ALT &&
+			ent->methodOfDeath != MOD_FLECHETTE_ALT_SPLASH &&
+			ent->methodOfDeath != MOD_CONC &&
+			ent->methodOfDeath != MOD_CONC_ALT /*&&
+			otherOwner->client->ps.saberBlockTime < level.time*/)
+		{ //for now still deflect even if saberBlockTime >= level.time because it hit the actual saber
+			vec3_t fwd;
+			gentity_t *te;
+			int otherDefLevel = otherOwner->client->ps.fd.forcePowerLevel[FP_SABER_DEFENSE];
+
+			//in this case, deflect it even if we can't actually block it because it hit our saber
+			//WP_SaberCanBlock(otherOwner, ent->r.currentOrigin, 0, 0, qtrue, 0);
+			if (otherOwner->client && otherOwner->client->ps.weaponTime <= 0)
+			{
+				WP_SaberBlockNonRandom(otherOwner, ent->r.currentOrigin, qtrue);
+			}
+
+			te = G_TempEntity( ent->r.currentOrigin, EV_SABER_BLOCK );
+			VectorCopy(ent->r.currentOrigin, te->s.origin);
+			VectorCopy(trace->plane.normal, te->s.angles);
+			te->s.eventParm = 0;
+
+			/*if (otherOwner->client->ps.velocity[2] > 0 ||
+				otherOwner->client->pers.cmd.forwardmove ||
+				otherOwner->client->pers.cmd.rightmove)*/
+			if (otherOwner->client->ps.velocity[2] > 0 ||
+				otherOwner->client->pers.cmd.forwardmove < 0) //now we only do it if jumping or running backward. Should be able to full-on charge.
+			{
+				otherDefLevel -= 1;
+				if (otherDefLevel < 0)
+				{
+					otherDefLevel = 0;
+				}
+			}
+
+			AngleVectors(otherOwner->client->ps.viewangles, fwd, NULL, NULL);
+
+			if (otherDefLevel == FORCE_LEVEL_1)
+			{
+				//if def is only level 1, instead of deflecting the shot it should just die here
+			}
+			else if (otherDefLevel == FORCE_LEVEL_2)
+			{
+				G_DeflectMissile(otherOwner, ent, fwd);
+			}
+			else
+			{
+				G_ReflectMissile(otherOwner, ent, fwd);
+			}
+			otherOwner->client->ps.saberBlockTime = level.time + (350 - (otherDefLevel*100));//200;
+
+			//For jedi AI
+			otherOwner->client->ps.saberEventFlags |= SEF_DEFLECTED;
+
+			if (otherDefLevel == FORCE_LEVEL_3)
+			{
+				otherOwner->client->ps.saberBlockTime = 0; //^_^
+			}
+
+			if (otherDefLevel == FORCE_LEVEL_1)
+			{
+				goto killProj;
+			}
+			return;
+		}
+	}
+
+	// check for sticking
+	if ( !other->takedamage && ( ent->s.eFlags & EF_MISSILE_STICK ) ) 
+	{
+		laserTrapStick( ent, trace->endpos, trace->plane.normal );
+		G_AddEvent( ent, EV_MISSILE_STICK, 0 );
+		return;
+	}
+
+	// impact damage
+	if (other->takedamage && !isKnockedSaber) {
+		// FIXME: wrong damage direction?
+		if ( ent->damage ) {
+			vec3_t	velocity;
+			qboolean didDmg = qfalse;
+
+			if( LogAccuracyHit( other, &g_entities[ent->r.ownerNum] ) ) {
+				g_entities[ent->r.ownerNum].client->accuracy_hits++;
+				hitClient = qtrue;
+			}
+			BG_EvaluateTrajectoryDelta( &ent->s.pos, level.time, velocity );
+			if ( VectorLength( velocity ) == 0 ) {
+				velocity[2] = 1;	// stepped on a grenade
+			}
+
+			if (ent->s.weapon == WP_BOWCASTER || ent->s.weapon == WP_FLECHETTE ||
+				ent->s.weapon == WP_ROCKET_LAUNCHER)
+			{
+				if (ent->s.weapon == WP_FLECHETTE && (ent->s.eFlags & EF_ALT_FIRING))
+				{
+					ent->think(ent);
+				}
+				else
+				{
+					G_Damage (other, ent, &g_entities[ent->r.ownerNum], velocity,
+						/*ent->s.origin*/ent->r.currentOrigin, ent->damage, 
+						DAMAGE_HALF_ABSORB, ent->methodOfDeath);
+					didDmg = qtrue;
+				}
+			}
+			else
+			{
+				G_Damage (other, ent, &g_entities[ent->r.ownerNum], velocity,
+					/*ent->s.origin*/ent->r.currentOrigin, ent->damage, 
+					0, ent->methodOfDeath);
+				didDmg = qtrue;
+			}
+
+			if (didDmg && other && other->client)
+			{ //What I'm wondering is why this isn't in the NPC pain funcs. But this is what SP does, so whatever.
+				class_t	npc_class = other->client->NPC_class;
+
+				// If we are a robot and we aren't currently doing the full body electricity...
+				if ( npc_class == CLASS_SEEKER || npc_class == CLASS_PROBE || npc_class == CLASS_MOUSE ||
+					   npc_class == CLASS_GONK || npc_class == CLASS_R2D2 || npc_class == CLASS_R5D2 || npc_class == CLASS_REMOTE ||
+					   npc_class == CLASS_MARK1 || npc_class == CLASS_MARK2 || //npc_class == CLASS_PROTOCOL ||//no protocol, looks odd
+					   npc_class == CLASS_INTERROGATOR || npc_class == CLASS_ATST || npc_class == CLASS_SENTRY )
+				{
+					// special droid only behaviors
+					if ( other->client->ps.electrifyTime < level.time + 100 )
+					{
+						// ... do the effect for a split second for some more feedback
+						other->client->ps.electrifyTime = level.time + 450;
+					}
+					//FIXME: throw some sparks off droids,too
+				}
+			}
+		}
+
+		if ( ent->s.weapon == WP_DEMP2 )
+		{//a hit with demp2 decloaks people, disables ships
+			if ( other && other->client && other->client->NPC_class == CLASS_VEHICLE )
+			{//hit a vehicle
+				if ( other->m_pVehicle //valid vehicle ent
+					&& other->m_pVehicle->m_pVehicleInfo//valid stats
+					&& (other->m_pVehicle->m_pVehicleInfo->type == VH_SPEEDER//always affect speeders
+						||(other->m_pVehicle->m_pVehicleInfo->type == VH_FIGHTER && ent->classname && Q_stricmp("vehicle_proj", ent->classname ) == 0) )//only vehicle ion weapons affect a fighter in this manner
+					&& !FighterIsLanded( other->m_pVehicle , &other->client->ps )//not landed
+					&& !(other->spawnflags&2) )//and not suspended
+				{//vehicles hit by "ion cannons" lose control
+					if ( other->client->ps.electrifyTime > level.time )
+					{//add onto it
+						//FIXME: extern the length of the "out of control" time?
+						other->client->ps.electrifyTime += Q_irand(200,500);
+						if ( other->client->ps.electrifyTime > level.time + 4000 )
+						{//cap it
+							other->client->ps.electrifyTime = level.time + 4000;
+						}
+					}
+					else
+					{//start it
+						//FIXME: extern the length of the "out of control" time?
+						other->client->ps.electrifyTime = level.time + Q_irand(200,500);
+					}
+				}
+			}
+			else if ( other && other->client && other->client->ps.powerups[PW_CLOAKED] )
+			{
+				Jedi_Decloak( other );
+				if ( ent->methodOfDeath == MOD_DEMP2_ALT )
+				{//direct hit with alt disables cloak forever
+					//permanently disable the saboteur's cloak
+					other->client->cloakToggleTime = Q3_INFINITE;
+				}
+				else
+				{//temp disable
+					other->client->cloakToggleTime = level.time + Q_irand( 3000, 10000 );
+				}
+			}
+		}
+	}
+killProj:
+	// is it cheaper in bandwidth to just remove this ent and create a new
+	// one, rather than changing the missile into the explosion?
+
+	if ( other->takedamage && other->client && !isKnockedSaber ) {
+		G_AddEvent( ent, EV_MISSILE_HIT, DirToByte( trace->plane.normal ) );
+		ent->s.otherEntityNum = other->s.number;
+	} else if( trace->surfaceFlags & SURF_METALSTEPS ) {
+		G_AddEvent( ent, EV_MISSILE_MISS_METAL, DirToByte( trace->plane.normal ) );
+	} else if (ent->s.weapon != G2_MODEL_PART && !isKnockedSaber) {
+		G_AddEvent( ent, EV_MISSILE_MISS, DirToByte( trace->plane.normal ) );
+	}
+
+	if (!isKnockedSaber)
+	{
+		ent->freeAfterEvent = qtrue;
+
+		// change over to a normal entity right at the point of impact
+		ent->s.eType = ET_GENERAL;
+	}
+
+	SnapVectorTowards( trace->endpos, ent->s.pos.trBase );	// save net bandwidth
+
+	G_SetOrigin( ent, trace->endpos );
+
+	ent->takedamage = qfalse;
+	// splash damage (doesn't apply to person directly hit)
+	if ( ent->splashDamage ) {
+		if( G_RadiusDamage( trace->endpos, ent->parent, ent->splashDamage, ent->splashRadius, 
+			other, ent, ent->splashMethodOfDeath ) ) {
+			if( !hitClient 
+				&& g_entities[ent->r.ownerNum].client ) {
+				g_entities[ent->r.ownerNum].client->accuracy_hits++;
+			}
+		}
+	}
+
+	if (ent->s.weapon == G2_MODEL_PART)
+	{
+		ent->freeAfterEvent = qfalse; //it will free itself
+	}
+
+	trap_LinkEntity( ent );
+}
+
+/*
+================
+G_RunMissile
+================
+*/
+void G_RunMissile( gentity_t *ent ) {
+	vec3_t		origin, groundSpot;
+	trace_t		tr;
+	int			passent;
+	qboolean	isKnockedSaber = qfalse;
+
+	if (ent->neverFree && ent->s.weapon == WP_SABER && (ent->flags & FL_BOUNCE_HALF))
+	{
+		isKnockedSaber = qtrue;
+		ent->s.pos.trType = TR_GRAVITY;
+	}
+
+	// get current position
+	BG_EvaluateTrajectory( &ent->s.pos, level.time, origin );
+
+	// if this missile bounced off an invulnerability sphere
+	if ( ent->target_ent ) {
+		passent = ent->target_ent->s.number;
+	}
+	else {
+		// ignore interactions with the missile owner
+		if ( (ent->r.svFlags&SVF_OWNERNOTSHARED) 
+			&& (ent->s.eFlags&EF_JETPACK_ACTIVE) )
+		{//A vehicle missile that should be solid to its owner
+			//I don't care about hitting my owner
+			passent = ent->s.number;
+		}
+		else
+		{
+			passent = ent->r.ownerNum;
+		}
+	}
+	// trace a line from the previous position to the current position
+	if (d_projectileGhoul2Collision.integer)
+	{
+		trap_G2Trace( &tr, ent->r.currentOrigin, ent->r.mins, ent->r.maxs, origin, passent, ent->clipmask, G2TRFLAG_DOGHOULTRACE|G2TRFLAG_GETSURFINDEX|G2TRFLAG_THICK|G2TRFLAG_HITCORPSES, g_g2TraceLod.integer );
+
+		if (tr.fraction != 1.0 && tr.entityNum < ENTITYNUM_WORLD)
+		{
+			gentity_t *g2Hit = &g_entities[tr.entityNum];
+
+			if (g2Hit->inuse && g2Hit->client && g2Hit->ghoul2)
+			{ //since we used G2TRFLAG_GETSURFINDEX, tr.surfaceFlags will actually contain the index of the surface on the ghoul2 model we collided with.
+				g2Hit->client->g2LastSurfaceHit = tr.surfaceFlags;
+				g2Hit->client->g2LastSurfaceTime = level.time;
+			}
+
+			if (g2Hit->ghoul2)
+			{
+				tr.surfaceFlags = 0; //clear the surface flags after, since we actually care about them in here.
+			}
+		}
+	}
+	else
+	{
+		trap_Trace( &tr, ent->r.currentOrigin, ent->r.mins, ent->r.maxs, origin, passent, ent->clipmask );
+	}
+
+	if ( tr.startsolid || tr.allsolid ) {
+		// make sure the tr.entityNum is set to the entity we're stuck in
+		trap_Trace( &tr, ent->r.currentOrigin, ent->r.mins, ent->r.maxs, ent->r.currentOrigin, passent, ent->clipmask );
+		tr.fraction = 0;
+	}
+	else {
+		VectorCopy( tr.endpos, ent->r.currentOrigin );
+	}
+
+	if (ent->passThroughNum && tr.entityNum == (ent->passThroughNum-1))
+	{
+		VectorCopy( origin, ent->r.currentOrigin );
+		trap_LinkEntity( ent );
+		goto passthrough;
+	}
+
+	trap_LinkEntity( ent );
+
+	if (ent->s.weapon == G2_MODEL_PART && !ent->bounceCount)
+	{
+		vec3_t lowerOrg;
+		trace_t trG;
+
+		VectorCopy(ent->r.currentOrigin, lowerOrg);
+		lowerOrg[2] -= 1;
+		trap_Trace( &trG, ent->r.currentOrigin, ent->r.mins, ent->r.maxs, lowerOrg, passent, ent->clipmask );
+
+		VectorCopy(trG.endpos, groundSpot);
+
+		if (!trG.startsolid && !trG.allsolid && trG.entityNum == ENTITYNUM_WORLD)
+		{
+			ent->s.groundEntityNum = trG.entityNum;
+		}
+		else
+		{
+			ent->s.groundEntityNum = ENTITYNUM_NONE;
+		}
+	}
+
+	if ( tr.fraction != 1) {
+		// never explode or bounce on sky
+		if ( tr.surfaceFlags & SURF_NOIMPACT ) {
+			// If grapple, reset owner
+			if (ent->parent && ent->parent->client && ent->parent->client->hook == ent) {
+				ent->parent->client->hook = NULL;
+			}
+
+			if ((ent->s.weapon == WP_SABER && ent->isSaberEntity) || isKnockedSaber)
+			{
+				G_RunThink( ent );
+				return;
+			}
+			else if (ent->s.weapon != G2_MODEL_PART)
+			{
+				G_FreeEntity( ent );
+				return;
+			}
+		}
+
+#if 0 //will get stomped with missile impact event...
+		if (ent->s.weapon > WP_NONE && ent->s.weapon < WP_NUM_WEAPONS &&
+			(tr.entityNum < MAX_CLIENTS || g_entities[tr.entityNum].s.eType == ET_NPC))
+		{ //player or NPC, try making a mark on him
+			/*
+			gentity_t *evEnt = G_TempEntity(ent->r.currentOrigin, EV_GHOUL2_MARK);
+
+			evEnt->s.owner = tr.entityNum; //the entity the mark should be placed on
+			evEnt->s.weapon = ent->s.weapon; //the weapon used (to determine mark type)
+			VectorCopy(ent->r.currentOrigin, evEnt->s.origin); //the point of impact
+
+			//origin2 gets the predicted trajectory-based position.
+			BG_EvaluateTrajectory( &ent->s.pos, level.time, evEnt->s.origin2 );
+
+			//If they are the same, there will be problems.
+			if (VectorCompare(evEnt->s.origin, evEnt->s.origin2))
+			{
+				evEnt->s.origin2[2] += 2; //whatever, at least it won't mess up.
+			}
+			*/
+			//ok, let's try adding it to the missile ent instead (tempents bad!)
+			G_AddEvent(ent, EV_GHOUL2_MARK, 0);
+
+			//copy current pos to s.origin, and current projected traj to origin2
+			VectorCopy(ent->r.currentOrigin, ent->s.origin);
+			BG_EvaluateTrajectory( &ent->s.pos, level.time, ent->s.origin2 );
+
+			//the index for whoever we are hitting
+			ent->s.otherEntityNum = tr.entityNum;
+
+			if (VectorCompare(ent->s.origin, ent->s.origin2))
+			{
+				ent->s.origin2[2] += 2.0f; //whatever, at least it won't mess up.
+			}
+		}
+#else
+		if (ent->s.weapon > WP_NONE && ent->s.weapon < WP_NUM_WEAPONS &&
+			(tr.entityNum < MAX_CLIENTS || g_entities[tr.entityNum].s.eType == ET_NPC))
+		{ //player or NPC, try making a mark on him
+			//copy current pos to s.origin, and current projected traj to origin2
+			VectorCopy(ent->r.currentOrigin, ent->s.origin);
+			BG_EvaluateTrajectory( &ent->s.pos, level.time, ent->s.origin2 );
+
+			if (VectorCompare(ent->s.origin, ent->s.origin2))
+			{
+				ent->s.origin2[2] += 2.0f; //whatever, at least it won't mess up.
+			}
+		}
+#endif
+
+		G_MissileImpact( ent, &tr );
+
+		if (tr.entityNum == ent->s.otherEntityNum)
+		{ //if the impact event other and the trace ent match then it's ok to do the g2 mark
+			ent->s.trickedentindex = 1;
+		}
+
+		if ( ent->s.eType != ET_MISSILE && ent->s.weapon != G2_MODEL_PART )
+		{
+			return;		// exploded
+		}
+	}
+
+passthrough:
+	if ( ent->s.pos.trType == TR_STATIONARY && (ent->s.eFlags&EF_MISSILE_STICK) )
+	{//stuck missiles should check some special stuff
+		G_RunStuckMissile( ent );
+		return;
+	}
+
+	if (ent->s.weapon == G2_MODEL_PART)
+	{
+		if (ent->s.groundEntityNum == ENTITYNUM_WORLD)
+		{
+			ent->s.pos.trType = TR_LINEAR;
+			VectorClear(ent->s.pos.trDelta);
+			ent->s.pos.trTime = level.time;
+
+			VectorCopy(groundSpot, ent->s.pos.trBase);
+			VectorCopy(groundSpot, ent->r.currentOrigin);
+
+			if (ent->s.apos.trType != TR_STATIONARY)
+			{
+				ent->s.apos.trType = TR_STATIONARY;
+				ent->s.apos.trTime = level.time;
+
+				ent->s.apos.trBase[ROLL] = 0;
+				ent->s.apos.trBase[PITCH] = 0;
+			}
+		}
+	}
+
+	// check think function after bouncing
+	G_RunThink( ent );
+}
+
+
+//=============================================================================
+
+
+
+
diff --git a/codemp/game/g_mover.c b/codemp/game/g_mover.c
new file mode 100644
index 0000000..d1ea0fe
--- /dev/null
+++ b/codemp/game/g_mover.c
@@ -0,0 +1,3265 @@
+// Copyright (C) 1999-2000 Id Software, Inc.
+//
+
+#include "g_local.h"
+
+
+
+/*
+===============================================================================
+
+PUSHMOVE
+
+===============================================================================
+*/
+
+void MatchTeam( gentity_t *teamLeader, int moverState, int time );
+
+typedef struct {
+	gentity_t	*ent;
+	vec3_t	origin;
+	vec3_t	angles;
+	float	deltayaw;
+} pushed_t;
+pushed_t	pushed[MAX_GENTITIES], *pushed_p;
+
+#define MOVER_START_ON		1
+#define MOVER_FORCE_ACTIVATE	2
+#define MOVER_CRUSHER		4
+#define MOVER_TOGGLE		8
+#define MOVER_LOCKED		16
+#define MOVER_GOODIE		32
+#define MOVER_PLAYER_USE	64
+#define MOVER_INACTIVE		128
+
+int	BMS_START = 0;
+int	BMS_MID = 1;
+int	BMS_END = 2;
+
+/*
+-------------------------
+G_PlayDoorLoopSound
+-------------------------
+*/
+
+void G_PlayDoorLoopSound( gentity_t *ent )
+{
+	if (!ent->soundSet || !ent->soundSet[0])
+	{
+		return;
+	}
+
+	ent->s.soundSetIndex = G_SoundSetIndex(ent->soundSet);
+	ent->s.loopIsSoundset = qtrue;
+	ent->s.loopSound = BMS_MID;
+	/*
+	ent->s.soundSetIndex = G_SoundSetIndex(ent->soundSet);
+	ent->loopingOnClient = qtrue;
+	G_AddEvent(ent, EV_PLAYDOORLOOPSOUND, 0);
+	*/
+}
+
+/*
+-------------------------
+G_PlayDoorSound
+-------------------------
+*/
+
+void G_PlayDoorSound( gentity_t *ent, int type )
+{
+	if (!ent->soundSet || !ent->soundSet[0])
+	{
+		return;
+	}
+
+	ent->s.soundSetIndex = G_SoundSetIndex(ent->soundSet);
+
+	G_AddEvent(ent, EV_PLAYDOORSOUND, type);
+}
+
+/*
+============
+G_TestEntityPosition
+
+============
+*/
+gentity_t	*G_TestEntityPosition( gentity_t *ent ) {
+	trace_t	tr;
+	int		mask;
+
+	if ( ent->clipmask ) {
+		mask = ent->clipmask;
+	} else {
+		mask = MASK_SOLID;
+	}
+	if ( ent->client ) {
+		vec3_t vMax;
+		VectorCopy(ent->r.maxs, vMax);
+		if (vMax[2] < 1)
+		{
+			vMax[2] = 1;
+		}
+		trap_Trace( &tr, ent->client->ps.origin, ent->r.mins, vMax, ent->client->ps.origin, ent->s.number, mask );
+	} else {
+		trap_Trace( &tr, ent->s.pos.trBase, ent->r.mins, ent->r.maxs, ent->s.pos.trBase, ent->s.number, mask );
+	}
+	
+	if (tr.startsolid)
+		return &g_entities[ tr.entityNum ];
+		
+	return NULL;
+}
+
+/*
+================
+G_CreateRotationMatrix
+================
+*/
+void G_CreateRotationMatrix(vec3_t angles, vec3_t matrix[3]) {
+	AngleVectors(angles, matrix[0], matrix[1], matrix[2]);
+	VectorInverse(matrix[1]);
+}
+
+/*
+================
+G_TransposeMatrix
+================
+*/
+void G_TransposeMatrix(vec3_t matrix[3], vec3_t transpose[3]) {
+	int i, j;
+	for (i = 0; i < 3; i++) {
+		for (j = 0; j < 3; j++) {
+			transpose[i][j] = matrix[j][i];
+		}
+	}
+}
+
+/*
+================
+G_RotatePoint
+================
+*/
+void G_RotatePoint(vec3_t point, vec3_t matrix[3]) {
+	vec3_t tvec;
+
+	VectorCopy(point, tvec);
+	point[0] = DotProduct(matrix[0], tvec);
+	point[1] = DotProduct(matrix[1], tvec);
+	point[2] = DotProduct(matrix[2], tvec);
+}
+
+/*
+==================
+G_TryPushingEntity
+
+Returns qfalse if the move is blocked
+==================
+*/
+qboolean	G_TryPushingEntity( gentity_t *check, gentity_t *pusher, vec3_t move, vec3_t amove ) {
+	vec3_t		matrix[3], transpose[3];
+	vec3_t		org, org2, move2;
+	gentity_t	*block;
+
+	//This was only serverside not to mention it was never set.
+	/*
+	// EF_MOVER_STOP will just stop when contacting another entity
+	// instead of pushing it, but entities can still ride on top of it
+	if ( ( pusher->s.eFlags & EF_MOVER_STOP ) && 
+		check->s.groundEntityNum != pusher->s.number ) {
+		return qfalse;
+	}
+	*/
+	if ( pusher->s.apos.trType != TR_STATIONARY//rotating
+		&& (pusher->spawnflags&16) //IMPACT
+		&& Q_stricmp( "func_rotating", pusher->classname ) == 0 )
+	{//just blow the fuck out of them
+		G_Damage( check, pusher, pusher, NULL, NULL, pusher->damage, DAMAGE_NO_KNOCKBACK, MOD_CRUSH );
+		return qtrue;
+	}
+
+	// save off the old position
+	if (pushed_p > &pushed[MAX_GENTITIES]) {
+		G_Error( "pushed_p > &pushed[MAX_GENTITIES]" );
+	}
+	pushed_p->ent = check;
+	VectorCopy (check->s.pos.trBase, pushed_p->origin);
+	VectorCopy (check->s.apos.trBase, pushed_p->angles);
+	if ( check->client ) {
+		pushed_p->deltayaw = check->client->ps.delta_angles[YAW];
+		VectorCopy (check->client->ps.origin, pushed_p->origin);
+	}
+	pushed_p++;
+
+	// try moving the contacted entity 
+	// figure movement due to the pusher's amove
+	G_CreateRotationMatrix( amove, transpose );
+	G_TransposeMatrix( transpose, matrix );
+	if ( check->client ) {
+		VectorSubtract (check->client->ps.origin, pusher->r.currentOrigin, org);
+	}
+	else {
+		VectorSubtract (check->s.pos.trBase, pusher->r.currentOrigin, org);
+	}
+	VectorCopy( org, org2 );
+	G_RotatePoint( org2, matrix );
+	VectorSubtract (org2, org, move2);
+	// add movement
+	VectorAdd (check->s.pos.trBase, move, check->s.pos.trBase);
+	VectorAdd (check->s.pos.trBase, move2, check->s.pos.trBase);
+	if ( check->client ) {
+		VectorAdd (check->client->ps.origin, move, check->client->ps.origin);
+		VectorAdd (check->client->ps.origin, move2, check->client->ps.origin);
+		// make sure the client's view rotates when on a rotating mover
+		check->client->ps.delta_angles[YAW] += ANGLE2SHORT(amove[YAW]);
+	}
+
+	// may have pushed them off an edge
+	if ( check->s.groundEntityNum != pusher->s.number ) {
+		check->s.groundEntityNum = ENTITYNUM_NONE;//-1;
+	}
+
+	block = G_TestEntityPosition( check );
+	if (!block) {
+		// pushed ok
+		if ( check->client ) {
+			VectorCopy( check->client->ps.origin, check->r.currentOrigin );
+		} else {
+			VectorCopy( check->s.pos.trBase, check->r.currentOrigin );
+		}
+		trap_LinkEntity (check);
+		return qtrue;
+	}
+
+	if (check->takedamage && !check->client && check->s.weapon && check->r.ownerNum < MAX_CLIENTS &&
+		check->health < 500)
+	{
+		if (check->health > 0)
+		{
+			G_Damage(check, pusher, pusher, vec3_origin, check->r.currentOrigin, 999, 0, MOD_UNKNOWN);
+		}
+		return qfalse;
+	}
+	// if it is ok to leave in the old position, do it
+	// this is only relevent for riding entities, not pushed
+	// Sliding trapdoors can cause this.
+	VectorCopy( (pushed_p-1)->origin, check->s.pos.trBase);
+	if ( check->client ) {
+		VectorCopy( (pushed_p-1)->origin, check->client->ps.origin);
+	}
+	VectorCopy( (pushed_p-1)->angles, check->s.apos.trBase );
+	block = G_TestEntityPosition (check);
+	if ( !block ) {
+		check->s.groundEntityNum = -1;
+		pushed_p--;
+		return qtrue;
+	}
+
+	// blocked
+	return qfalse;
+}
+
+
+void G_ExplodeMissile( gentity_t *ent );
+
+/*
+============
+G_MoverPush
+
+Objects need to be moved back on a failed push,
+otherwise riders would continue to slide.
+If qfalse is returned, *obstacle will be the blocking entity
+============
+*/
+qboolean G_MoverPush( gentity_t *pusher, vec3_t move, vec3_t amove, gentity_t **obstacle ) {
+	int			i, e;
+	gentity_t	*check;
+	vec3_t		mins, maxs;
+	pushed_t	*p;
+	int			entityList[MAX_GENTITIES];
+	int			listedEntities;
+	vec3_t		totalMins, totalMaxs;
+
+	*obstacle = NULL;
+
+
+	// mins/maxs are the bounds at the destination
+	// totalMins / totalMaxs are the bounds for the entire move
+	if ( pusher->r.currentAngles[0] || pusher->r.currentAngles[1] || pusher->r.currentAngles[2]
+		|| amove[0] || amove[1] || amove[2] ) {
+		float		radius;
+
+		radius = RadiusFromBounds( pusher->r.mins, pusher->r.maxs );
+		for ( i = 0 ; i < 3 ; i++ ) {
+			mins[i] = pusher->r.currentOrigin[i] + move[i] - radius;
+			maxs[i] = pusher->r.currentOrigin[i] + move[i] + radius;
+			totalMins[i] = mins[i] - move[i];
+			totalMaxs[i] = maxs[i] - move[i];
+		}
+	} else {
+		for (i=0 ; i<3 ; i++) {
+			mins[i] = pusher->r.absmin[i] + move[i];
+			maxs[i] = pusher->r.absmax[i] + move[i];
+		}
+
+		VectorCopy( pusher->r.absmin, totalMins );
+		VectorCopy( pusher->r.absmax, totalMaxs );
+		for (i=0 ; i<3 ; i++) {
+			if ( move[i] > 0 ) {
+				totalMaxs[i] += move[i];
+			} else {
+				totalMins[i] += move[i];
+			}
+		}
+	}
+
+	// unlink the pusher so we don't get it in the entityList
+	trap_UnlinkEntity( pusher );
+
+	listedEntities = trap_EntitiesInBox( totalMins, totalMaxs, entityList, MAX_GENTITIES );
+
+	// move the pusher to it's final position
+	VectorAdd( pusher->r.currentOrigin, move, pusher->r.currentOrigin );
+	VectorAdd( pusher->r.currentAngles, amove, pusher->r.currentAngles );
+	trap_LinkEntity( pusher );
+
+	// see if any solid entities are inside the final position
+	for ( e = 0 ; e < listedEntities ; e++ ) {
+		check = &g_entities[ entityList[ e ] ];
+
+		// only push items and players
+		if ( /*check->s.eType != ET_ITEM &&*/ check->s.eType != ET_PLAYER && check->s.eType != ET_NPC && !check->physicsObject ) {
+			continue;
+		}
+
+		// if the entity is standing on the pusher, it will definitely be moved
+		if ( check->s.groundEntityNum != pusher->s.number ) {
+			// see if the ent needs to be tested
+			if ( check->r.absmin[0] >= maxs[0]
+			|| check->r.absmin[1] >= maxs[1]
+			|| check->r.absmin[2] >= maxs[2]
+			|| check->r.absmax[0] <= mins[0]
+			|| check->r.absmax[1] <= mins[1]
+			|| check->r.absmax[2] <= mins[2] ) {
+				continue;
+			}
+			// see if the ent's bbox is inside the pusher's final position
+			// this does allow a fast moving object to pass through a thin entity...
+			if (!G_TestEntityPosition (check)) {
+				continue;
+			}
+		}
+
+		// the entity needs to be pushed
+		if ( G_TryPushingEntity( check, pusher, move, amove ) ) {
+			continue;
+		}
+
+		if (pusher->damage && check->client && (pusher->spawnflags & 32))
+		{
+			G_Damage( check, pusher, pusher, NULL, NULL, pusher->damage, 0, MOD_CRUSH );
+			continue;
+		}
+
+		if (check->s.eType == ET_BODY ||
+			(check->s.eType == ET_PLAYER && check->health < 1))
+		{ //whatever, just crush it
+			G_Damage( check, pusher, pusher, NULL, NULL, 999, 0, MOD_CRUSH );
+			continue;
+		}
+
+		// the move was blocked an entity
+
+		// bobbing entities are instant-kill and never get blocked
+		if ( pusher->s.pos.trType == TR_SINE || pusher->s.apos.trType == TR_SINE ) {
+			G_Damage( check, pusher, pusher, NULL, NULL, 99999, 0, MOD_CRUSH );
+			continue;
+		}
+
+		
+		// save off the obstacle so we can call the block function (crush, etc)
+		*obstacle = check;
+
+		// move back any entities we already moved
+		// go backwards, so if the same entity was pushed
+		// twice, it goes back to the original position
+		for ( p=pushed_p-1 ; p>=pushed ; p-- ) {
+			VectorCopy (p->origin, p->ent->s.pos.trBase);
+			VectorCopy (p->angles, p->ent->s.apos.trBase);
+			if ( p->ent->client ) {
+				p->ent->client->ps.delta_angles[YAW] = p->deltayaw;
+				VectorCopy (p->origin, p->ent->client->ps.origin);
+			}
+			trap_LinkEntity (p->ent);
+		}
+		return qfalse;
+	}
+
+	return qtrue;
+}
+
+
+/*
+=================
+G_MoverTeam
+=================
+*/
+void G_MoverTeam( gentity_t *ent ) {
+	vec3_t		move, amove;
+	gentity_t	*part, *obstacle;
+	vec3_t		origin, angles;
+
+	obstacle = NULL;
+
+	// make sure all team slaves can move before commiting
+	// any moves or calling any think functions
+	// if the move is blocked, all moved objects will be backed out
+	pushed_p = pushed;
+	for (part = ent ; part ; part=part->teamchain) {
+		// get current position
+		BG_EvaluateTrajectory( &part->s.pos, level.time, origin );
+		BG_EvaluateTrajectory( &part->s.apos, level.time, angles );
+		VectorSubtract( origin, part->r.currentOrigin, move );
+		VectorSubtract( angles, part->r.currentAngles, amove );
+		if ( !VectorCompare( move, vec3_origin )
+			|| !VectorCompare( amove, vec3_origin ) )
+		{//actually moved
+			if ( !G_MoverPush( part, move, amove, &obstacle ) ) {
+				break;	// move was blocked
+			}
+		}
+	}
+
+	if (part) {
+		// go back to the previous position
+		for ( part = ent ; part ; part = part->teamchain ) {
+			part->s.pos.trTime += level.time - level.previousTime;
+			part->s.apos.trTime += level.time - level.previousTime;
+			BG_EvaluateTrajectory( &part->s.pos, level.time, part->r.currentOrigin );
+			BG_EvaluateTrajectory( &part->s.apos, level.time, part->r.currentAngles );
+			trap_LinkEntity( part );
+		}
+
+		// if the pusher has a "blocked" function, call it
+		if (ent->blocked) {
+			ent->blocked( ent, obstacle );
+		}
+		return;
+	}
+
+	// the move succeeded
+	for ( part = ent ; part ; part = part->teamchain ) {
+		// call the reached function if time is at or past end point
+		if ( part->s.pos.trType == TR_LINEAR_STOP ||
+			part->s.pos.trType == TR_NONLINEAR_STOP) {
+			if ( level.time >= part->s.pos.trTime + part->s.pos.trDuration ) {
+				if ( part->reached ) {
+					part->reached( part );
+				}
+			}
+		}
+	}
+}
+
+/*
+================
+G_RunMover
+
+================
+*/
+void G_RunMover( gentity_t *ent ) {
+	// if not a team captain, don't do anything, because
+	// the captain will handle everything
+	if ( ent->flags & FL_TEAMSLAVE ) {
+		return;
+	}
+
+	// if stationary at one of the positions, don't move anything
+	if ( ent->s.pos.trType != TR_STATIONARY || ent->s.apos.trType != TR_STATIONARY ) {
+		G_MoverTeam( ent );
+	}
+
+	// check think function
+	G_RunThink( ent );
+}
+
+/*
+============================================================================
+
+GENERAL MOVERS
+
+Doors, plats, and buttons are all binary (two position) movers
+Pos1 is "at rest", pos2 is "activated"
+============================================================================
+*/
+
+/*
+CalcTeamDoorCenter
+
+Finds all the doors of a team and returns their center position
+*/
+
+void CalcTeamDoorCenter ( gentity_t *ent, vec3_t center ) 
+{
+	vec3_t		slavecenter;
+	gentity_t	*slave;
+
+	//Start with our center
+	VectorAdd(ent->r.mins, ent->r.maxs, center);
+	VectorScale(center, 0.5, center);
+	for ( slave = ent->teamchain ; slave ; slave = slave->teamchain ) 
+	{
+		//Find slave's center
+		VectorAdd(slave->r.mins, slave->r.maxs, slavecenter);
+		VectorScale(slavecenter, 0.5, slavecenter);
+		//Add that to our own, find middle
+		VectorAdd(center, slavecenter, center);
+		VectorScale(center, 0.5, center);
+	}
+}
+
+/*
+===============
+SetMoverState
+===============
+*/
+void SetMoverState( gentity_t *ent, moverState_t moverState, int time ) {
+	vec3_t			delta;
+	float			f;
+
+	ent->moverState = moverState;
+
+	ent->s.pos.trTime = time;
+
+	if ( ent->s.pos.trDuration <= 0 )
+	{//Don't allow divide by zero!
+		ent->s.pos.trDuration = 1;
+	}
+
+	switch( moverState ) {
+	case MOVER_POS1:
+		VectorCopy( ent->pos1, ent->s.pos.trBase );
+		ent->s.pos.trType = TR_STATIONARY;
+		break;
+	case MOVER_POS2:
+		VectorCopy( ent->pos2, ent->s.pos.trBase );
+		ent->s.pos.trType = TR_STATIONARY;
+		break;
+	case MOVER_1TO2:
+		VectorCopy( ent->pos1, ent->s.pos.trBase );
+		VectorSubtract( ent->pos2, ent->pos1, delta );
+		f = 1000.0 / ent->s.pos.trDuration;
+		VectorScale( delta, f, ent->s.pos.trDelta );
+		if ( ent->alt_fire )
+		{
+			ent->s.pos.trType = TR_LINEAR_STOP;
+		}
+		else
+		{
+			ent->s.pos.trType = TR_NONLINEAR_STOP;
+		}
+		//ent->s.eFlags &= ~EF_BLOCKED_MOVER;
+		break;
+	case MOVER_2TO1:
+		VectorCopy( ent->pos2, ent->s.pos.trBase );
+		VectorSubtract( ent->pos1, ent->pos2, delta );
+		f = 1000.0 / ent->s.pos.trDuration;
+		VectorScale( delta, f, ent->s.pos.trDelta );
+		if ( ent->alt_fire )
+		{
+			ent->s.pos.trType = TR_LINEAR_STOP;
+		}
+		else
+		{
+			ent->s.pos.trType = TR_NONLINEAR_STOP;
+		}
+		//ent->s.eFlags &= ~EF_BLOCKED_MOVER;
+		break;
+	}
+	BG_EvaluateTrajectory( &ent->s.pos, level.time, ent->r.currentOrigin );	
+	trap_LinkEntity( ent );
+}
+
+/*
+================
+MatchTeam
+
+All entities in a mover team will move from pos1 to pos2
+in the same amount of time
+================
+*/
+void MatchTeam( gentity_t *teamLeader, int moverState, int time ) {
+	gentity_t		*slave;
+
+	for ( slave = teamLeader ; slave ; slave = slave->teamchain ) {
+		SetMoverState( slave, (moverState_t) moverState, time );
+	}
+}
+
+
+
+/*
+================
+ReturnToPos1
+================
+*/
+void ReturnToPos1( gentity_t *ent ) {
+	ent->think = 0;
+	ent->nextthink = 0;
+	ent->s.time = level.time;
+
+	MatchTeam( ent, MOVER_2TO1, level.time );
+
+	// starting sound
+	G_PlayDoorLoopSound( ent );
+	G_PlayDoorSound( ent, BMS_START );	//??
+}
+
+
+/*
+================
+Reached_BinaryMover
+================
+*/
+
+void Reached_BinaryMover( gentity_t *ent ) 
+{
+	// stop the looping sound
+	ent->s.loopSound = 0;
+	ent->s.loopIsSoundset = qfalse;
+
+	if ( ent->moverState == MOVER_1TO2 ) 
+	{//reached open
+		vec3_t	doorcenter;
+
+		// reached pos2
+		SetMoverState( ent, MOVER_POS2, level.time );
+
+		CalcTeamDoorCenter( ent, doorcenter );
+
+		// play sound
+		G_PlayDoorSound( ent, BMS_END );
+
+		if ( ent->wait < 0 )
+		{//Done for good
+			ent->think = 0;
+			ent->nextthink = 0;
+			ent->use = 0;
+		}
+		else
+		{
+			// return to pos1 after a delay
+			ent->think = ReturnToPos1;
+			if(ent->spawnflags & 8)
+			{//Toggle, keep think, wait for next use?
+				ent->nextthink = -1;
+			}
+			else
+			{
+				ent->nextthink = level.time + ent->wait;
+			}
+		}
+
+		// fire targets
+		if ( !ent->activator ) 
+		{
+			ent->activator = ent;
+		}
+		G_UseTargets2( ent, ent->activator, ent->opentarget );
+	} 
+	else if ( ent->moverState == MOVER_2TO1 ) 
+	{//closed
+		vec3_t	doorcenter;
+
+		// reached pos1
+		SetMoverState( ent, MOVER_POS1, level.time );
+
+		CalcTeamDoorCenter( ent, doorcenter );
+
+		// play sound
+		G_PlayDoorSound( ent, BMS_END );
+
+		// close areaportals
+		if ( ent->teammaster == ent || !ent->teammaster ) 
+		{
+			trap_AdjustAreaPortalState( ent, qfalse );
+		}
+		G_UseTargets2( ent, ent->activator, ent->closetarget );
+	} 
+	else 
+	{
+		G_Error( "Reached_BinaryMover: bad moverState" );
+	}
+}
+
+
+/*
+================
+Use_BinaryMover_Go
+================
+*/
+void Use_BinaryMover_Go( gentity_t *ent ) 
+{
+	int		total;
+	int		partial;
+//	gentity_t	*other = ent->enemy;
+	gentity_t	*activator = ent->activator; 
+
+	ent->activator = activator;
+
+	if ( ent->moverState == MOVER_POS1 ) 
+	{
+		vec3_t	doorcenter;
+
+		// start moving 50 msec later, becase if this was player
+		// triggered, level.time hasn't been advanced yet
+		MatchTeam( ent, MOVER_1TO2, level.time + 50 );
+
+		CalcTeamDoorCenter( ent, doorcenter );
+
+		// starting sound
+		G_PlayDoorLoopSound( ent );
+		G_PlayDoorSound( ent, BMS_START );
+		ent->s.time = level.time;
+
+		// open areaportal
+		if ( ent->teammaster == ent || !ent->teammaster ) {
+			trap_AdjustAreaPortalState( ent, qtrue );
+		}
+		G_UseTargets( ent, ent->activator );
+		return;
+	}
+
+	// if all the way up, just delay before coming down
+	if ( ent->moverState == MOVER_POS2 ) {
+		//have to do this because the delay sets our think to Use_BinaryMover_Go
+		ent->think = ReturnToPos1;
+		if ( ent->spawnflags & 8 )
+		{//TOGGLE doors don't use wait!
+			ent->nextthink = level.time + FRAMETIME;
+		}
+		else
+		{
+			ent->nextthink = level.time + ent->wait;
+		}
+		G_UseTargets2( ent, ent->activator, ent->target2 );
+		return;
+	}
+
+	// only partway down before reversing
+	if ( ent->moverState == MOVER_2TO1 ) 
+	{
+		if ( ent->s.pos.trType == TR_NONLINEAR_STOP )
+		{
+			vec3_t curDelta;
+			float fPartial;
+			total = ent->s.pos.trDuration-50;
+			VectorSubtract( ent->r.currentOrigin, ent->pos1, curDelta );
+			fPartial = VectorLength( curDelta )/VectorLength( ent->s.pos.trDelta );
+			VectorScale( ent->s.pos.trDelta, fPartial, curDelta );
+			fPartial /= ent->s.pos.trDuration;
+			fPartial /= 0.001f;
+			fPartial = acos( fPartial );
+			fPartial = RAD2DEG( fPartial );
+			fPartial = (90.0f - fPartial)/90.0f*ent->s.pos.trDuration;
+			partial = total - floor( fPartial );
+		}
+		else
+		{
+			total = ent->s.pos.trDuration;
+			partial = level.time - ent->s.pos.trTime;
+		}
+
+		if ( partial > total ) {
+			partial = total;
+		}
+		ent->s.pos.trTime = level.time - ( total - partial );//ent->s.time;
+
+		MatchTeam( ent, MOVER_1TO2, ent->s.pos.trTime );
+
+		G_PlayDoorSound( ent, BMS_START );
+
+		return;
+	}
+
+	// only partway up before reversing
+	if ( ent->moverState == MOVER_1TO2 ) 
+	{
+		if ( ent->s.pos.trType == TR_NONLINEAR_STOP )
+		{
+			vec3_t curDelta;
+			float fPartial;
+			total = ent->s.pos.trDuration-50;
+			VectorSubtract( ent->r.currentOrigin, ent->pos2, curDelta );
+			fPartial = VectorLength( curDelta )/VectorLength( ent->s.pos.trDelta );
+			VectorScale( ent->s.pos.trDelta, fPartial, curDelta );
+			fPartial /= ent->s.pos.trDuration;
+			fPartial /= 0.001f;
+			fPartial = acos( fPartial );
+			fPartial = RAD2DEG( fPartial );
+			fPartial = (90.0f - fPartial)/90.0f*ent->s.pos.trDuration;
+			partial = total - floor( fPartial );
+		}
+		else
+		{
+			total = ent->s.pos.trDuration;
+			partial = level.time - ent->s.pos.trTime;
+		}
+		if ( partial > total ) {
+			partial = total;
+		}
+
+		ent->s.pos.trTime = level.time - ( total - partial );//ent->s.time;
+		MatchTeam( ent, MOVER_2TO1, ent->s.pos.trTime );
+
+		G_PlayDoorSound( ent, BMS_START );
+
+		return;
+	}
+}
+
+void UnLockDoors(gentity_t *const ent)
+{
+	//noise?
+	//go through and unlock the door and all the slaves
+	gentity_t	*slave = ent;
+	do 
+	{	// want to allow locked toggle doors, so keep the targetname
+		if( !(slave->spawnflags & MOVER_TOGGLE) )
+		{
+			slave->targetname = NULL;//not usable ever again
+		}
+		slave->spawnflags &= ~MOVER_LOCKED;
+		slave->s.frame = 1;//second stage of anim
+		slave = slave->teamchain;
+	} while  ( slave );
+}
+void LockDoors(gentity_t *const ent)
+{
+	//noise?
+	//go through and lock the door and all the slaves
+	gentity_t	*slave = ent;
+	do 
+	{
+		slave->spawnflags |= MOVER_LOCKED;
+		slave->s.frame = 0;//first stage of anim
+		slave = slave->teamchain;
+	} while  ( slave );
+}
+/*
+================
+Use_BinaryMover
+================
+*/
+void Use_BinaryMover( gentity_t *ent, gentity_t *other, gentity_t *activator ) 
+{
+	if ( !ent->use )
+	{//I cannot be used anymore, must be a door with a wait of -1 that's opened.
+		return;
+	}
+
+	// only the master should be used
+	if ( ent->flags & FL_TEAMSLAVE ) 
+	{
+		Use_BinaryMover( ent->teammaster, other, activator );
+		return;
+	}
+
+	if ( ent->flags & FL_INACTIVE )
+	{
+		return;
+	}
+
+	if ( ent->spawnflags & MOVER_LOCKED )
+	{//a locked door, unlock it
+		UnLockDoors(ent);
+		return;
+	}
+
+	G_ActivateBehavior(ent,BSET_USE);
+
+	ent->enemy = other;
+	ent->activator = activator;
+	if(ent->delay)
+	{
+		ent->think = Use_BinaryMover_Go;
+		ent->nextthink = level.time + ent->delay;
+	}
+	else
+	{
+		Use_BinaryMover_Go(ent);
+	}
+}
+
+
+
+/*
+================
+InitMover
+
+"pos1", "pos2", and "speed" should be set before calling,
+so the movement delta can be calculated
+================
+*/
+void InitMoverTrData( gentity_t *ent )
+{
+	vec3_t		move;
+	float		distance;
+
+	ent->s.pos.trType = TR_STATIONARY;
+	VectorCopy( ent->pos1, ent->s.pos.trBase );
+
+	// calculate time to reach second position from speed
+	VectorSubtract( ent->pos2, ent->pos1, move );
+	distance = VectorLength( move );
+	if ( ! ent->speed ) 
+	{
+		ent->speed = 100;
+	}
+	VectorScale( move, ent->speed, ent->s.pos.trDelta );
+	ent->s.pos.trDuration = distance * 1000 / ent->speed;
+	if ( ent->s.pos.trDuration <= 0 ) 
+	{
+		ent->s.pos.trDuration = 1;
+	}
+}
+
+void InitMover( gentity_t *ent ) 
+{
+	float		light;
+	vec3_t		color;
+	qboolean	lightSet, colorSet;
+
+	// if the "model2" key is set, use a seperate model
+	// for drawing, but clip against the brushes
+	if ( ent->model2 ) 
+	{
+		if ( strstr( ent->model2, ".glm" ))
+		{ //for now, not supported in MP.
+			ent->s.modelindex2 = 0;
+		}
+		else
+		{
+			ent->s.modelindex2 = G_ModelIndex( ent->model2 );
+		}
+	}
+
+	// if the "color" or "light" keys are set, setup constantLight
+	lightSet = G_SpawnFloat( "light", "100", &light );
+	colorSet = G_SpawnVector( "color", "1 1 1", color );
+	if ( lightSet || colorSet ) {
+		int		r, g, b, i;
+
+		r = color[0] * 255;
+		if ( r > 255 ) {
+			r = 255;
+		}
+		g = color[1] * 255;
+		if ( g > 255 ) {
+			g = 255;
+		}
+		b = color[2] * 255;
+		if ( b > 255 ) {
+			b = 255;
+		}
+		i = light / 4;
+		if ( i > 255 ) {
+			i = 255;
+		}
+		ent->s.constantLight = r | ( g << 8 ) | ( b << 16 ) | ( i << 24 );
+	}
+
+	ent->use = Use_BinaryMover;
+	ent->reached = Reached_BinaryMover;
+
+	ent->moverState = MOVER_POS1;
+	ent->r.svFlags = SVF_USE_CURRENT_ORIGIN;
+	if ( ent->spawnflags & MOVER_INACTIVE )
+	{// Make it inactive
+		ent->flags |= FL_INACTIVE;	
+	}
+	if(ent->spawnflags & MOVER_PLAYER_USE)
+	{//Can be used by the player's BUTTON_USE
+		ent->r.svFlags |= SVF_PLAYER_USABLE;
+	}
+	ent->s.eType = ET_MOVER;
+	VectorCopy( ent->pos1, ent->r.currentOrigin );
+	trap_LinkEntity( ent );
+
+	InitMoverTrData( ent );
+}
+
+
+/*
+===============================================================================
+
+DOOR
+
+A use can be triggered either by a touch function, by being shot, or by being
+targeted by another entity.
+
+===============================================================================
+*/
+
+/*
+================
+Blocked_Door
+================
+*/
+void Blocked_Door( gentity_t *ent, gentity_t *other )
+{
+	if ( ent->damage ) {
+		G_Damage( other, ent, ent, NULL, NULL, ent->damage, 0, MOD_CRUSH );
+	}
+	if ( ent->spawnflags & MOVER_CRUSHER ) {
+		return;		// crushers don't reverse
+	}
+
+	// reverse direction
+	Use_BinaryMover( ent, ent, other );
+}
+
+
+/*
+================
+Touch_DoorTriggerSpectator
+================
+*/
+static void Touch_DoorTriggerSpectator( gentity_t *ent, gentity_t *other, trace_t *trace ) {
+	int i, axis;
+	trace_t tr;
+	vec3_t pMins, pMaxs;
+	vec3_t origin, dir, angles;
+
+	axis = ent->count;
+	VectorClear(dir);
+	if (fabs(other->s.origin[axis] - ent->r.absmax[axis]) <
+		fabs(other->s.origin[axis] - ent->r.absmin[axis])) {
+		origin[axis] = ent->r.absmin[axis] - 10;
+		dir[axis] = -1;
+	}
+	else {
+		origin[axis] = ent->r.absmax[axis] + 10;
+		dir[axis] = 1;
+	}
+	for (i = 0; i < 3; i++) {
+		if (i == axis) continue;
+		origin[i] = (ent->r.absmin[i] + ent->r.absmax[i]) * 0.5;
+	}
+
+	vectoangles(dir, angles);
+
+	VectorSet(pMins, -15.0f, -15.0f, DEFAULT_MINS_2);
+	VectorSet(pMaxs, 15.0f, 15.0f, DEFAULT_MAXS_2);
+	trap_Trace(&tr, origin, pMins, pMaxs, origin, other->s.number, other->clipmask);
+	if (!tr.startsolid &&
+		!tr.allsolid &&
+		tr.fraction == 1.0f &&
+		tr.entityNum == ENTITYNUM_NONE)
+	{
+		TeleportPlayer(other, origin, angles );
+	}
+}
+
+/*
+================
+Touch_DoorTrigger
+================
+*/
+void Touch_DoorTrigger( gentity_t *ent, gentity_t *other, trace_t *trace ) 
+{
+	gentity_t *relockEnt = NULL;
+
+	if ( other->client && other->client->sess.sessionTeam == TEAM_SPECTATOR ) 
+	{
+		// if the door is not open and not opening
+		if ( ent->parent->moverState != MOVER_1TO2 &&
+			ent->parent->moverState != MOVER_POS2 ) 
+		{
+			Touch_DoorTriggerSpectator( ent, other, trace );
+		}
+		return;
+	}
+
+	if (!ent->genericValue14 &&
+		(!ent->parent || !ent->parent->genericValue14))
+	{
+		if (other->client && other->s.number >= MAX_CLIENTS &&
+			other->s.eType == ET_NPC && other->s.NPC_class == CLASS_VEHICLE)
+		{ //doors don't open for vehicles
+			return;
+		}
+
+		if (other->client && other->s.number < MAX_CLIENTS &&
+			other->client->ps.m_iVehicleNum)
+		{ //can't open a door while on a vehicle
+			return;
+		}
+	}
+
+	if ( ent->flags & FL_INACTIVE )
+	{
+		return;
+	}
+
+	if ( ent->parent->spawnflags & MOVER_LOCKED )
+	{//don't even try to use the door if it's locked 
+		if ( !ent->parent->alliedTeam //we don't have a "teamallow" team
+			|| !other->client //we do have a "teamallow" team, but this isn't a client
+			|| other->client->sess.sessionTeam != ent->parent->alliedTeam )//it is a client, but it's not on the right team
+		{
+			return;
+		}
+		else
+		{//temporarily unlock us while we call Use_BinaryMover (so it doesn't unlock all the doors in this team)
+			if ( ent->parent->flags & FL_TEAMSLAVE ) 
+			{
+				relockEnt = ent->parent->teammaster;
+			}
+			else
+			{
+				relockEnt = ent->parent;
+			}
+			if ( relockEnt != NULL )
+			{
+				relockEnt->spawnflags &= ~MOVER_LOCKED;
+			}
+		}
+	}
+
+	if ( ent->parent->moverState != MOVER_1TO2 ) 
+	{//Door is not already opening
+		//if ( ent->parent->moverState == MOVER_POS1 || ent->parent->moverState == MOVER_2TO1 )
+		//{//only check these if closed or closing
+
+		//If door is closed, opening or open, check this
+		Use_BinaryMover( ent->parent, ent, other );
+	}
+	if ( relockEnt != NULL )
+	{//re-lock us
+		relockEnt->spawnflags |= MOVER_LOCKED;
+	}
+
+	/*
+	//Old style
+	if ( ent->parent->moverState != MOVER_1TO2 ) {
+		Use_BinaryMover( ent->parent, ent, other );
+	}
+	*/
+}
+
+/*
+======================
+Think_SpawnNewDoorTrigger
+
+All of the parts of a door have been spawned, so create
+a trigger that encloses all of them
+======================
+*/
+void Think_SpawnNewDoorTrigger( gentity_t *ent ) 
+{
+	gentity_t		*other;
+	vec3_t		mins, maxs;
+	int			i, best;
+
+	// set all of the slaves as shootable
+	if ( ent->takedamage ) 
+	{
+		for ( other = ent ; other ; other = other->teamchain ) 
+		{
+			other->takedamage = qtrue;
+		}
+	}
+
+	// find the bounds of everything on the team
+	VectorCopy (ent->r.absmin, mins);
+	VectorCopy (ent->r.absmax, maxs);
+
+	for (other = ent->teamchain ; other ; other=other->teamchain) {
+		AddPointToBounds (other->r.absmin, mins, maxs);
+		AddPointToBounds (other->r.absmax, mins, maxs);
+	}
+
+	// find the thinnest axis, which will be the one we expand
+	best = 0;
+	for ( i = 1 ; i < 3 ; i++ ) {
+		if ( maxs[i] - mins[i] < maxs[best] - mins[best] ) {
+			best = i;
+		}
+	}
+	maxs[best] += 120;
+	mins[best] -= 120;
+
+	// create a trigger with this size
+	other = G_Spawn ();
+	VectorCopy (mins, other->r.mins);
+	VectorCopy (maxs, other->r.maxs);
+	other->parent = ent;
+	other->r.contents = CONTENTS_TRIGGER;
+	other->touch = Touch_DoorTrigger;
+	trap_LinkEntity (other);
+	other->classname = "trigger_door";
+	// remember the thinnest axis
+	other->count = best;
+
+	MatchTeam( ent, ent->moverState, level.time );
+}
+
+void Think_MatchTeam( gentity_t *ent ) 
+{
+	MatchTeam( ent, ent->moverState, level.time );
+}
+
+qboolean G_EntIsDoor( int entityNum )
+{
+	gentity_t *ent;
+
+	if ( entityNum < 0 || entityNum >= ENTITYNUM_WORLD )
+	{
+		return qfalse;
+	}
+
+	ent = &g_entities[entityNum];
+	if ( ent && !Q_stricmp( "func_door", ent->classname ) )
+	{//blocked by a door
+		return qtrue;
+	}
+	return qfalse;
+}
+
+gentity_t *G_FindDoorTrigger( gentity_t *ent )
+{
+	gentity_t *owner = NULL;
+	gentity_t *door = ent;
+	if ( door->flags & FL_TEAMSLAVE )
+	{//not the master door, get the master door
+		while ( door->teammaster && (door->flags&FL_TEAMSLAVE))
+		{
+			door = door->teammaster;
+		}
+	}
+	if ( door->targetname )
+	{//find out what is targeting it
+		//FIXME: if ent->targetname, check what kind of trigger/ent is targetting it?  If a normal trigger (active, etc), then it's okay?
+		while ( (owner = G_Find( owner, FOFS( target ), door->targetname )) != NULL )
+		{
+			if ( owner && (owner->r.contents&CONTENTS_TRIGGER) )
+			{
+				return owner;
+			}
+		}
+		owner = NULL;
+		while ( (owner = G_Find( owner, FOFS( target2 ), door->targetname )) != NULL )
+		{
+			if ( owner && (owner->r.contents&CONTENTS_TRIGGER) )
+			{
+				return owner;
+			}
+		}
+	}
+
+	owner = NULL;
+	while ( (owner = G_Find( owner, FOFS( classname ), "trigger_door" )) != NULL )
+	{
+		if ( owner->parent == door )
+		{
+			return owner;
+		}
+	}
+
+	return NULL;
+}
+
+qboolean G_EntIsUnlockedDoor( int entityNum )
+{
+	if ( entityNum < 0 || entityNum >= ENTITYNUM_WORLD )
+	{
+		return qfalse;
+	}
+
+	if ( G_EntIsDoor( entityNum ) )
+	{
+		gentity_t *ent = &g_entities[entityNum];
+		gentity_t *owner = NULL;
+		if ( ent->flags & FL_TEAMSLAVE )
+		{//not the master door, get the master door
+			while ( ent->teammaster && (ent->flags&FL_TEAMSLAVE))
+			{
+				ent = ent->teammaster;
+			}
+		}
+		if ( ent->targetname )
+		{//find out what is targetting it
+			owner = NULL;
+			//FIXME: if ent->targetname, check what kind of trigger/ent is targetting it?  If a normal trigger (active, etc), then it's okay?
+			while ( (owner = G_Find( owner, FOFS( target ), ent->targetname )) != NULL )
+			{
+				if ( !Q_stricmp( "trigger_multiple", owner->classname ) )//FIXME: other triggers okay too?
+				{
+					if ( !(owner->flags & FL_INACTIVE) )
+					{
+						return qtrue;
+					}
+				}
+			}
+			owner = NULL;
+			while ( (owner = G_Find( owner, FOFS( target2 ), ent->targetname )) != NULL )
+			{
+				if ( !Q_stricmp( "trigger_multiple", owner->classname ) )//FIXME: other triggers okay too?
+				{
+					if ( !(owner->flags & FL_INACTIVE) )
+					{
+						return qtrue;
+					}
+				}
+			}
+			return qfalse;
+		}
+		else
+		{//check the door's auto-created trigger instead
+			owner = G_FindDoorTrigger( ent );
+			if ( owner && (owner->flags&FL_INACTIVE) )
+			{//owning auto-created trigger is inactive
+				return qfalse;
+			}
+		}
+		if ( !(ent->flags & FL_INACTIVE) && //assumes that the reactivate trigger isn't right next to the door!
+			!ent->health &&
+			!(ent->spawnflags & MOVER_PLAYER_USE) &&
+			!(ent->spawnflags & MOVER_FORCE_ACTIVATE) &&
+			!(ent->spawnflags & MOVER_LOCKED))
+			//FIXME: what about MOVER_GOODIE?
+		{
+			return qtrue;
+		}
+	}
+	return qfalse;
+}
+
+
+/*QUAKED func_door (0 .5 .8) ? START_OPEN FORCE_ACTIVATE CRUSHER TOGGLE LOCKED x PLAYER_USE INACTIVE
+START_OPEN	the door to moves to its destination when spawned, and operate in reverse.  It is used to temporarily or permanently close off an area when triggered (not useful for touch or takedamage doors).
+FORCE_ACTIVATE	Can only be activated by a force push or pull
+CRUSHER		?
+TOGGLE		wait in both the start and end states for a trigger event - does NOT work on Trek doors.
+LOCKED		Starts locked, with the shader animmap at the first frame and inactive.  Once used, the animmap changes to the second frame and the door operates normally.  Note that you cannot use the door again after this.
+PLAYER_USE	Player can use it with the use button
+INACTIVE	must be used by a target_activate before it can be used
+
+"target"     Door fires this when it starts moving from it's closed position to its open position.
+"opentarget" Door fires this after reaching its "open" position
+"target2"    Door fires this when it starts moving from it's open position to its closed position.
+"closetarget" Door fires this after reaching its "closed" position
+"model2"	.md3 model to also draw
+"angle"		determines the opening direction
+"targetname" if set, no touch field will be spawned and a remote button or trigger field activates the door.
+"speed"		movement speed (100 default)
+"wait"		wait before returning (3 default, -1 = never return)
+"delay"		when used, how many seconds to wait before moving - default is none
+"lip"		lip remaining at end of move (8 default)
+"dmg"		damage to inflict when blocked (2 default, set to negative for no damage)
+"color"		constantLight color
+"light"		constantLight radius
+"health"	if set, the door must be shot open
+"linear"	set to 1 and it will move linearly rather than with acceleration (default is 0)
+"teamallow" even if locked, this team can always open and close it just by walking up to it
+	0 - none (locked to everyone)
+	1 - red
+	2 - blue
+"vehopen"	if non-0, vehicles/players riding vehicles can open
+*/
+void SP_func_door (gentity_t *ent) 
+{
+	vec3_t	abs_movedir;
+	float	distance;
+	vec3_t	size;
+	float	lip;
+
+	G_SpawnInt("vehopen", "0", &ent->genericValue14);
+
+	ent->blocked = Blocked_Door;
+
+	// default speed of 400
+	if (!ent->speed)
+		ent->speed = 400;
+
+	// default wait of 2 seconds
+	if (!ent->wait)
+		ent->wait = 2;
+	ent->wait *= 1000;
+
+	ent->delay *= 1000;
+
+	// default lip of 8 units
+	G_SpawnFloat( "lip", "8", &lip );
+
+	// default damage of 2 points
+	G_SpawnInt( "dmg", "2", &ent->damage );
+	if ( ent->damage < 0 )
+	{
+		ent->damage = 0;
+	}
+
+	G_SpawnInt( "teamallow", "0", &ent->alliedTeam );
+
+	// first position at start
+	VectorCopy( ent->s.origin, ent->pos1 );
+
+	// calculate second position
+	trap_SetBrushModel( ent, ent->model );
+	G_SetMovedir( ent->s.angles, ent->movedir );
+	abs_movedir[0] = fabs( ent->movedir[0] );
+	abs_movedir[1] = fabs( ent->movedir[1] );
+	abs_movedir[2] = fabs( ent->movedir[2] );
+	VectorSubtract( ent->r.maxs, ent->r.mins, size );
+	distance = DotProduct( abs_movedir, size ) - lip;
+	VectorMA( ent->pos1, distance, ent->movedir, ent->pos2 );
+
+	// if "start_open", reverse position 1 and 2
+	if ( ent->spawnflags & 1 ) 
+	{
+		vec3_t	temp;
+
+		VectorCopy( ent->pos2, temp );
+		VectorCopy( ent->s.origin, ent->pos2 );
+		VectorCopy( temp, ent->pos1 );
+	}
+
+	if ( ent->spawnflags & MOVER_LOCKED )
+	{//a locked door, set up as locked until used directly
+		ent->s.eFlags |= EF_SHADER_ANIM;//use frame-controlled shader anim
+		ent->s.frame = 0;//first stage of anim
+	}
+	InitMover( ent );
+
+	ent->nextthink = level.time + FRAMETIME;
+
+	if ( !(ent->flags&FL_TEAMSLAVE) ) 
+	{
+		int health;
+
+		G_SpawnInt( "health", "0", &health );
+		
+		if ( health ) 
+		{
+			ent->takedamage = qtrue;
+		}
+		
+		if ( !(ent->spawnflags&MOVER_LOCKED) && (ent->targetname || health || ent->spawnflags & MOVER_PLAYER_USE || ent->spawnflags & MOVER_FORCE_ACTIVATE) )
+		{
+			// non touch/shoot doors
+			ent->think = Think_MatchTeam;
+
+			if (ent->spawnflags & MOVER_FORCE_ACTIVATE)
+			{ //so we know it's push/pullable on the client
+				ent->s.bolt1 = 1;
+			}
+		} 
+		else 
+		{//locked doors still spawn a trigger
+			ent->think = Think_SpawnNewDoorTrigger;
+		}
+	}
+}
+
+/*
+===============================================================================
+
+PLAT
+
+===============================================================================
+*/
+
+/*
+==============
+Touch_Plat
+
+Don't allow decent if a living player is on it
+===============
+*/
+void Touch_Plat( gentity_t *ent, gentity_t *other, trace_t *trace ) {
+	if ( !other->client || other->client->ps.stats[STAT_HEALTH] <= 0 ) {
+		return;
+	}
+
+	// delay return-to-pos1 by one second
+	if ( ent->moverState == MOVER_POS2 ) {
+		ent->nextthink = level.time + 1000;
+	}
+}
+
+/*
+==============
+Touch_PlatCenterTrigger
+
+If the plat is at the bottom position, start it going up
+===============
+*/
+void Touch_PlatCenterTrigger(gentity_t *ent, gentity_t *other, trace_t *trace ) {
+	if ( !other->client ) {
+		return;
+	}
+
+	if ( ent->parent->moverState == MOVER_POS1 ) {
+		Use_BinaryMover( ent->parent, ent, other );
+	}
+}
+
+
+/*
+================
+SpawnPlatTrigger
+
+Spawn a trigger in the middle of the plat's low position
+Elevator cars require that the trigger extend through the entire low position,
+not just sit on top of it.
+================
+*/
+void SpawnPlatTrigger( gentity_t *ent ) {
+	gentity_t	*trigger;
+	vec3_t	tmin, tmax;
+
+	// the middle trigger will be a thin trigger just
+	// above the starting position
+	trigger = G_Spawn();
+	trigger->touch = Touch_PlatCenterTrigger;
+	trigger->r.contents = CONTENTS_TRIGGER;
+	trigger->parent = ent;
+	
+	tmin[0] = ent->pos1[0] + ent->r.mins[0] + 33;
+	tmin[1] = ent->pos1[1] + ent->r.mins[1] + 33;
+	tmin[2] = ent->pos1[2] + ent->r.mins[2];
+
+	tmax[0] = ent->pos1[0] + ent->r.maxs[0] - 33;
+	tmax[1] = ent->pos1[1] + ent->r.maxs[1] - 33;
+	tmax[2] = ent->pos1[2] + ent->r.maxs[2] + 8;
+
+	if ( tmax[0] <= tmin[0] ) {
+		tmin[0] = ent->pos1[0] + (ent->r.mins[0] + ent->r.maxs[0]) *0.5;
+		tmax[0] = tmin[0] + 1;
+	}
+	if ( tmax[1] <= tmin[1] ) {
+		tmin[1] = ent->pos1[1] + (ent->r.mins[1] + ent->r.maxs[1]) *0.5;
+		tmax[1] = tmin[1] + 1;
+	}
+	
+	VectorCopy (tmin, trigger->r.mins);
+	VectorCopy (tmax, trigger->r.maxs);
+
+	trap_LinkEntity (trigger);
+}
+
+
+/*QUAKED func_plat (0 .5 .8) ? x x x x x x PLAYER_USE INACTIVE
+PLAYER_USE	Player can use it with the use button
+INACTIVE	must be used by a target_activate before it can be used
+
+Plats are always drawn in the extended position so they will light correctly.
+
+"lip"		default 8, protrusion above rest position
+"height"	total height of movement, defaults to model height
+"speed"		overrides default 200.
+"dmg"		overrides default 2
+"model2"	.md3 model to also draw
+"color"		constantLight color
+"light"		constantLight radius
+*/
+void SP_func_plat (gentity_t *ent) {
+	float		lip, height;
+
+//	ent->sound1to2 = ent->sound2to1 = G_SoundIndex("sound/movers/plats/pt1_strt.wav");
+//	ent->soundPos1 = ent->soundPos2 = G_SoundIndex("sound/movers/plats/pt1_end.wav");
+
+	VectorClear (ent->s.angles);
+
+	G_SpawnFloat( "speed", "200", &ent->speed );
+	G_SpawnInt( "dmg", "2", &ent->damage );
+	G_SpawnFloat( "wait", "1", &ent->wait );
+	G_SpawnFloat( "lip", "8", &lip );
+
+	ent->wait = 1000;
+
+	// create second position
+	trap_SetBrushModel( ent, ent->model );
+
+	if ( !G_SpawnFloat( "height", "0", &height ) ) {
+		height = (ent->r.maxs[2] - ent->r.mins[2]) - lip;
+	}
+
+	// pos1 is the rest (bottom) position, pos2 is the top
+	VectorCopy( ent->s.origin, ent->pos2 );
+	VectorCopy( ent->pos2, ent->pos1 );
+	ent->pos1[2] -= height;
+
+	InitMover( ent );
+
+	// touch function keeps the plat from returning while
+	// a live player is standing on it
+	ent->touch = Touch_Plat;
+
+	ent->blocked = Blocked_Door;
+
+	ent->parent = ent;	// so it can be treated as a door
+
+	// spawn the trigger if one hasn't been custom made
+	if ( !ent->targetname ) {
+		SpawnPlatTrigger(ent);
+	}
+}
+
+/*
+===============================================================================
+
+BUTTON
+
+===============================================================================
+*/
+
+/*
+==============
+Touch_Button
+
+===============
+*/
+void Touch_Button(gentity_t *ent, gentity_t *other, trace_t *trace ) {
+	if ( !other->client ) {
+		return;
+	}
+
+	if ( ent->moverState == MOVER_POS1 ) {
+		Use_BinaryMover( ent, other, other );
+	}
+}
+
+
+/*QUAKED func_button (0 .5 .8) ? x x x x x x PLAYER_USE INACTIVE
+PLAYER_USE	Player can use it with the use button
+INACTIVE	must be used by a target_activate before it can be used
+
+When a button is touched, it moves some distance in the direction of it's angle, triggers all of it's targets, waits some time, then returns to it's original position where it can be triggered again.
+
+"model2"	.md3 model to also draw
+"angle"		determines the opening direction
+"target"	all entities with a matching targetname will be used
+"speed"		override the default 40 speed
+"wait"		override the default 1 second wait (-1 = never return)
+"lip"		override the default 4 pixel lip remaining at end of move
+"health"	if set, the button must be killed instead of touched
+"color"		constantLight color
+"light"		constantLight radius
+*/
+void SP_func_button( gentity_t *ent ) {
+	vec3_t		abs_movedir;
+	float		distance;
+	vec3_t		size;
+	float		lip;
+
+//	ent->sound1to2 = G_SoundIndex("sound/movers/switches/butn2.wav");
+	
+	if ( !ent->speed ) {
+		ent->speed = 40;
+	}
+
+	if ( !ent->wait ) {
+		ent->wait = 1;
+	}
+	ent->wait *= 1000;
+
+	// first position
+	VectorCopy( ent->s.origin, ent->pos1 );
+
+	// calculate second position
+	trap_SetBrushModel( ent, ent->model );
+
+	G_SpawnFloat( "lip", "4", &lip );
+
+	G_SetMovedir( ent->s.angles, ent->movedir );
+	abs_movedir[0] = fabs(ent->movedir[0]);
+	abs_movedir[1] = fabs(ent->movedir[1]);
+	abs_movedir[2] = fabs(ent->movedir[2]);
+	VectorSubtract( ent->r.maxs, ent->r.mins, size );
+	distance = abs_movedir[0] * size[0] + abs_movedir[1] * size[1] + abs_movedir[2] * size[2] - lip;
+	VectorMA (ent->pos1, distance, ent->movedir, ent->pos2);
+
+	if (ent->health) {
+		// shootable button
+		ent->takedamage = qtrue;
+	} else {
+		// touchable button
+		ent->touch = Touch_Button;
+	}
+
+	InitMover( ent );
+}
+
+
+
+
+/*
+===============================================================================
+
+TRAIN
+
+===============================================================================
+*/
+
+
+#define TRAIN_START_ON		1
+#define TRAIN_TOGGLE		2
+#define TRAIN_BLOCK_STOPS	4
+
+/*
+===============
+Think_BeginMoving
+
+The wait time at a corner has completed, so start moving again
+===============
+*/
+void Think_BeginMoving( gentity_t *ent ) {
+	G_PlayDoorSound( ent, BMS_START );
+	G_PlayDoorLoopSound( ent );
+	ent->s.pos.trTime = level.time;
+	ent->s.pos.trType = TR_LINEAR_STOP;
+}
+
+/*
+===============
+Reached_Train
+===============
+*/
+void Reached_Train( gentity_t *ent ) {
+	gentity_t		*next;
+	float			speed;
+	vec3_t			move;
+	float			length;
+
+	// copy the apropriate values
+	next = ent->nextTrain;
+	if ( !next || !next->nextTrain ) {
+		return;		// just stop
+	}
+
+	// fire all other targets
+	G_UseTargets( next, NULL );
+
+	// set the new trajectory
+	ent->nextTrain = next->nextTrain;
+	VectorCopy( next->s.origin, ent->pos1 );
+	VectorCopy( next->nextTrain->s.origin, ent->pos2 );
+
+	// if the path_corner has a speed, use that
+	if ( next->speed ) {
+		speed = next->speed;
+	} else {
+		// otherwise use the train's speed
+		speed = ent->speed;
+	}
+	if ( speed < 1 ) {
+		speed = 1;
+	}
+
+	// calculate duration
+	VectorSubtract( ent->pos2, ent->pos1, move );
+	length = VectorLength( move );
+
+	ent->s.pos.trDuration = length * 1000 / speed;
+
+	// start it going
+	SetMoverState( ent, MOVER_1TO2, level.time );
+
+	G_PlayDoorSound( ent, BMS_END );
+
+	// if there is a "wait" value on the target, don't start moving yet
+	if ( next->wait ) {
+		ent->s.loopSound = 0;
+		ent->s.loopIsSoundset = qfalse;
+		ent->nextthink = level.time + next->wait * 1000;
+		ent->think = Think_BeginMoving;
+		ent->s.pos.trType = TR_STATIONARY;
+	}
+	else
+	{
+		G_PlayDoorLoopSound( ent );
+	}
+}
+
+/*
+===============
+Think_SetupTrainTargets
+
+Link all the corners together
+===============
+*/
+void Think_SetupTrainTargets( gentity_t *ent ) {
+	gentity_t		*path, *next, *start;
+
+	ent->nextTrain = G_Find( NULL, FOFS(targetname), ent->target );
+	if ( !ent->nextTrain ) {
+		Com_Printf( "func_train at %s with an unfound target\n",
+			vtos(ent->r.absmin) );
+		//Free me?`
+		return;
+	}
+
+	//FIXME: this can go into an infinite loop if last path_corner doesn't link to first
+	//path_corner, like so:
+	// t1---->t2---->t3
+	//         ^      |
+	//          \_____|
+	start = NULL;
+	for ( path = ent->nextTrain ; path != start ; path = next ) {
+		if ( !start ) {
+			start = path;
+		}
+
+		if ( !path->target ) {
+//			gi.Printf( "Train corner at %s without a target\n",
+//				vtos(path->s.origin) );
+			//end of path
+			break;
+		}
+
+		// find a path_corner among the targets
+		// there may also be other targets that get fired when the corner
+		// is reached
+		next = NULL;
+		do {
+			next = G_Find( next, FOFS(targetname), path->target );
+			if ( !next ) {
+//				gi.Printf( "Train corner at %s without a target path_corner\n",
+//					vtos(path->s.origin) );
+				//end of path
+				break;
+			}
+		} while ( strcmp( next->classname, "path_corner" ) );
+
+		if ( next )
+		{
+			path->nextTrain = next;
+		}
+		else
+		{
+			break;
+		}
+	}
+
+	if ( !ent->targetname || (ent->spawnflags&1) /*start on*/)
+	{
+		// start the train moving from the first corner
+		Reached_Train( ent );
+	}
+	else
+	{
+		G_SetOrigin( ent, ent->s.origin );
+	}
+}
+
+
+/*QUAKED path_corner (.5 .3 0) (-8 -8 -8) (8 8 8)
+Train path corners.
+Target: next path corner and other targets to fire
+"speed" speed to move to the next corner
+"wait" seconds to wait before behining move to next corner
+*/
+void SP_path_corner( gentity_t *self ) {
+	if ( !self->targetname ) {
+		G_Printf ("path_corner with no targetname at %s\n", vtos(self->s.origin));
+		G_FreeEntity( self );
+		return;
+	}
+	// path corners don't need to be linked in
+}
+
+
+
+/*QUAKED func_train (0 .5 .8) ? START_ON TOGGLE BLOCK_STOPS ? ? CRUSH_THROUGH PLAYER_USE INACTIVE
+A train is a mover that moves between path_corner target points.
+Trains MUST HAVE AN ORIGIN BRUSH.
+The train spawns at the first target it is pointing at.
+CRUSH_THROUGH spawnflag combined with a dmg value will make the train pass through
+entities and damage them on contact as well.
+"model2"	.md3 model to also draw
+"speed"		default 100
+"dmg"		default	2
+"target"	next path corner
+"color"		constantLight color
+"light"		constantLight radius
+*/
+void SP_func_train (gentity_t *self) {
+	VectorClear (self->s.angles);
+
+	if (self->spawnflags & TRAIN_BLOCK_STOPS) {
+		self->damage = 0;
+	} else {
+		if (!self->damage) {
+			self->damage = 2;
+		}
+	}
+
+	if ( !self->speed ) {
+		self->speed = 100;
+	}
+
+	if ( !self->target ) {
+		G_Printf ("func_train without a target at %s\n", vtos(self->r.absmin));
+		G_FreeEntity( self );
+		return;
+	}
+
+	trap_SetBrushModel( self, self->model );
+	InitMover( self );
+
+	self->reached = Reached_Train;
+
+	// start trains on the second frame, to make sure their targets have had
+	// a chance to spawn
+	self->nextthink = level.time + FRAMETIME;
+	self->think = Think_SetupTrainTargets;
+}
+
+/*
+===============================================================================
+
+STATIC
+
+===============================================================================
+*/
+
+void func_static_use ( gentity_t *self, gentity_t *other, gentity_t *activator );
+/*QUAKED func_static (0 .5 .8) ? F_PUSH F_PULL SWITCH_SHADER CRUSHER IMPACT x PLAYER_USE INACTIVE BROADCAST
+F_PUSH		Will be used when you Force-Push it
+F_PULL		Will be used when you Force-Pull it
+SWITCH_SHADER	Toggle the shader anim frame between 1 and 2 when used
+CRUSHER		Make it do damage when it's blocked
+IMPACT		Make it do damage when it hits any entity
+PLAYER_USE	Player can use it with the use button
+INACTIVE	must be used by a target_activate before it can be used
+BROADCAST   don't ever use this, it's evil
+
+A bmodel that just sits there, doing nothing.  Can be used for conditional walls and models.
+"model2"	.md3 model to also draw
+"model2scale"	percent of normal scale (on all x y and z axii) to scale the model2 if there is one. 100 is normal scale, min is 1 (100 times smaller than normal), max is 1000 (ten times normal).
+"color"		constantLight color
+"light"		constantLight radius
+"dmg"		how much damage to do when it crushes (use with CRUSHER spawnflag)
+"linear" set to 1 and it will move linearly rather than with acceleration (default is 0)
+*/
+void SP_func_static( gentity_t *ent ) 
+{
+	int		test;
+	trap_SetBrushModel( ent, ent->model );
+
+	VectorCopy( ent->s.origin, ent->pos1 );
+	VectorCopy( ent->s.origin, ent->pos2 );
+
+	InitMover( ent );
+
+	ent->use = func_static_use;
+	ent->reached = 0;
+
+	G_SetOrigin( ent, ent->s.origin );
+	G_SetAngles( ent, ent->s.angles );
+
+	if( ent->spawnflags & 2048 )
+	{								   // yes this is very very evil, but for now (pre-alpha) it's a solution
+		ent->r.svFlags |= SVF_BROADCAST; // I need to rotate something that is huge and it's touching too many area portals...
+	}
+
+	if ( ent->spawnflags & 4/*SWITCH_SHADER*/ )
+	{
+		ent->s.eFlags |= EF_SHADER_ANIM;//use frame-controlled shader anim
+		ent->s.frame = 0;//first stage of anim
+	}
+
+	if ((ent->spawnflags & 1) || (ent->spawnflags & 2))
+	{ //so we know it's push/pullable on the client
+		ent->s.bolt1 = 1;
+	}
+
+#ifdef _XBOX
+	int	tempModelScale;
+	G_SpawnInt("model2scale", "0", &tempModelScale);
+	ent->s.iModelScale = tempModelScale;
+#else
+	G_SpawnInt("model2scale", "0", &ent->s.iModelScale);
+#endif
+	if (ent->s.iModelScale < 0)
+	{
+		ent->s.iModelScale = 0;
+	}
+	else if (ent->s.iModelScale > 1023)
+	{
+		ent->s.iModelScale = 1023;
+	}
+
+	G_SpawnInt( "hyperspace", "0", &test );
+	if ( test )
+	{
+		ent->r.svFlags |= SVF_BROADCAST; // I need to rotate something that is huge and it's touching too many area portals...
+		ent->s.eFlags2 |= EF2_HYPERSPACE;
+	}
+
+	trap_LinkEntity( ent );
+
+	if (level.mBSPInstanceDepth)
+	{	// this means that this guy will never be updated, moved, changed, etc.
+		ent->s.eFlags = EF_PERMANENT;
+	}
+}
+
+void func_static_use ( gentity_t *self, gentity_t *other, gentity_t *activator )
+{
+	G_ActivateBehavior( self, BSET_USE );
+
+	if ( self->spawnflags & 4/*SWITCH_SHADER*/ )
+	{
+		self->s.frame = self->s.frame ? 0 : 1;//toggle frame
+	}
+	G_UseTargets( self, activator );
+}
+
+/*
+===============================================================================
+
+ROTATING
+
+===============================================================================
+*/
+
+void func_rotating_use( gentity_t *self, gentity_t *other, gentity_t *activator )
+{
+	if(	self->s.apos.trType == TR_LINEAR )
+	{
+		self->s.apos.trType = TR_STATIONARY;
+		// stop the sound if it stops moving
+		self->s.loopSound = 0;
+		self->s.loopIsSoundset = qfalse;
+		// play stop sound too?
+		if ( self->soundSet && self->soundSet[0] )
+		{
+			self->s.soundSetIndex = G_SoundSetIndex(self->soundSet);
+			G_AddEvent( self, EV_BMODEL_SOUND, BMS_END );
+		}
+	}
+	else
+	{
+		if ( self->soundSet && self->soundSet[0] )
+		{
+			self->s.soundSetIndex = G_SoundSetIndex(self->soundSet);
+			G_AddEvent( self, EV_BMODEL_SOUND, BMS_START );
+			self->s.loopSound = BMS_MID;
+			self->s.loopIsSoundset = qtrue;
+		}
+		self->s.apos.trType = TR_LINEAR;
+	}
+}
+
+/*QUAKED func_rotating (0 .5 .8) ? START_ON RADAR X_AXIS Y_AXIS IMPACT x PLAYER_USE INACTIVE
+RADAR - shows up on Radar in Siege mode (good for asteroids when you're in a ship)
+IMPACT - Kills anything on impact when rotating (10000 points of damage, unless specified otherwise)
+
+You need to have an origin brush as part of this entity.  The center of that brush will be
+the point around which it is rotated. It will rotate around the Z axis by default.  You can
+check either the X_AXIS or Y_AXIS box to change that.
+
+"model2"		.md3 model to also draw
+"model2scale"	percent of normal scale (on all x y and z axii) to scale the model2 if there is one. 100 is normal scale, min is 1 (100 times smaller than normal), max is 1000 (ten times normal).
+"speed"			determines how fast it moves; default value is 100.
+"dmg"			damage to inflict when blocked (2 default)
+"color"			constantLight color
+"light"			constantLight radius
+"spinangles"	instead of using "speed", you can set use this to set rotation on all 3 axes (pitch yaw and roll)
+
+==================================================
+"health"	default is 0
+
+If health is set, the following key/values are available:
+
+"numchunks" Multiplies the number of chunks spawned.  Chunk code tries to pick a good volume of chunks, but you can alter this to scale the number of spawned chunks. (default 1)  (.5) is half as many chunks, (2) is twice as many chunks
+"chunksize"	scales up/down the chunk size by this number (default is 1)
+
+"showhealth" if non-0, will display the health bar on the hud when the crosshair is over this ent (in siege)
+"teamowner" in siege this will specify which team this thing is "owned" by. To that team the crosshair will
+highlight green, to the other team it will highlight red.
+
+Damage: default is none
+"splashDamage" - damage to do
+"splashRadius" - radius for above damage
+
+"team" - If set, only this team can trip this trigger
+	0 - any
+	1 - red
+	2 - blue
+
+Don't know if these work:  
+"color"		constantLight color
+"light"		constantLight radius
+
+"material" - default is "0 - MAT_METAL" - choose from this list:
+0 = MAT_METAL		(basic blue-grey scorched-DEFAULT)
+1 = MAT_GLASS		
+2 = MAT_ELECTRICAL	(sparks only)
+3 = MAT_ELEC_METAL	(METAL2 chunks and sparks)
+4 =	MAT_DRK_STONE	(brown stone chunks)
+5 =	MAT_LT_STONE	(tan stone chunks)
+6 =	MAT_GLASS_METAL (glass and METAL2 chunks)
+7 = MAT_METAL2		(electronic type of metal)
+8 = MAT_NONE		(no chunks)
+9 = MAT_GREY_STONE	(grey colored stone)
+10 = MAT_METAL3		(METAL and METAL2 chunk combo)
+11 = MAT_CRATE1		(yellow multi-colored crate chunks)
+12 = MAT_GRATE1		(grate chunks--looks horrible right now)
+13 = MAT_ROPE		(for yavin_trial, no chunks, just wispy bits )
+14 = MAT_CRATE2		(red multi-colored crate chunks)
+15 = MAT_WHITE_METAL (white angular chunks for Stu, NS_hideout )
+16 = MAT_SNOWY_ROCK	 (mix of gray and brown rocks)
+
+Applicable only during Siege gametype:
+teamnodmg - if 1, team 1 can't damage this. If 2, team 2 can't damage this.
+
+*/
+void SP_func_breakable( gentity_t *self );
+void SP_func_rotating (gentity_t *ent) {
+	vec3_t spinangles;
+	if ( ent->health )
+	{
+		int sav_spawnflags = ent->spawnflags;
+		ent->spawnflags = 0;
+		SP_func_breakable( ent );
+		ent->spawnflags = sav_spawnflags;
+	}
+	else
+	{
+		trap_SetBrushModel( ent, ent->model );
+		InitMover( ent );
+
+		VectorCopy( ent->s.origin, ent->s.pos.trBase );
+		VectorCopy( ent->s.pos.trBase, ent->r.currentOrigin );
+		VectorCopy( ent->s.apos.trBase, ent->r.currentAngles );
+
+		trap_LinkEntity( ent );
+	}
+
+#ifdef _XBOX
+	int	tempModelScale;
+	G_SpawnInt("model2scale", "0", &tempModelScale);
+	ent->s.iModelScale = tempModelScale;
+#else
+	G_SpawnInt("model2scale", "0", &ent->s.iModelScale);
+#endif
+	if (ent->s.iModelScale < 0)
+	{
+		ent->s.iModelScale = 0;
+	}
+	else if (ent->s.iModelScale > 1023)
+	{
+		ent->s.iModelScale = 1023;
+	}
+
+	if ( G_SpawnVector( "spinangles", "0 0 0", spinangles ) )
+	{
+		ent->speed = VectorLength( spinangles );
+		// set the axis of rotation
+		VectorCopy( spinangles, ent->s.apos.trDelta );
+	}
+	else
+	{
+		if ( !ent->speed ) {
+			ent->speed = 100;
+		}
+		// set the axis of rotation
+		if ( ent->spawnflags & 4 ) {
+			ent->s.apos.trDelta[2] = ent->speed;
+		} else if ( ent->spawnflags & 8 ) {
+			ent->s.apos.trDelta[0] = ent->speed;
+		} else {
+			ent->s.apos.trDelta[1] = ent->speed;
+		}
+	}
+	ent->s.apos.trType = TR_LINEAR;
+
+	if (!ent->damage) {
+		if ( (ent->spawnflags&16) )//IMPACT
+		{
+			ent->damage = 10000;
+		}
+		else
+		{
+			ent->damage = 2;
+		}
+	}
+	if ( (ent->spawnflags&2) )//RADAR
+	{//show up on Radar at close range and play impact sound when close...?  Range based on my size
+		ent->s.speed = Distance( ent->r.absmin, ent->r.absmax )*0.5f;
+		ent->s.eFlags |= EF_RADAROBJECT;
+	}
+}
+
+
+/*
+===============================================================================
+
+BOBBING
+
+===============================================================================
+*/
+
+
+/*QUAKED func_bobbing (0 .5 .8) ? X_AXIS Y_AXIS x x x x PLAYER_USE INACTIVE
+Normally bobs on the Z axis
+"model2"	.md3 model to also draw
+"height"	amplitude of bob (32 default)
+"speed"		seconds to complete a bob cycle (4 default)
+"phase"		the 0.0 to 1.0 offset in the cycle to start at
+"dmg"		damage to inflict when blocked (2 default)
+"color"		constantLight color
+"light"		constantLight radius
+*/
+void SP_func_bobbing (gentity_t *ent) {
+	float		height;
+	float		phase;
+
+	G_SpawnFloat( "speed", "4", &ent->speed );
+	G_SpawnFloat( "height", "32", &height );
+	G_SpawnInt( "dmg", "2", &ent->damage );
+	G_SpawnFloat( "phase", "0", &phase );
+
+	trap_SetBrushModel( ent, ent->model );
+	InitMover( ent );
+
+	VectorCopy( ent->s.origin, ent->s.pos.trBase );
+	VectorCopy( ent->s.origin, ent->r.currentOrigin );
+
+	ent->s.pos.trDuration = ent->speed * 1000;
+	ent->s.pos.trTime = ent->s.pos.trDuration * phase;
+	ent->s.pos.trType = TR_SINE;
+
+	// set the axis of bobbing
+	if ( ent->spawnflags & 1 ) {
+		ent->s.pos.trDelta[0] = height;
+	} else if ( ent->spawnflags & 2 ) {
+		ent->s.pos.trDelta[1] = height;
+	} else {
+		ent->s.pos.trDelta[2] = height;
+	}
+}
+
+/*
+===============================================================================
+
+PENDULUM
+
+===============================================================================
+*/
+
+
+/*QUAKED func_pendulum (0 .5 .8) ? x x x x x x PLAYER_USE INACTIVE
+You need to have an origin brush as part of this entity.
+Pendulums always swing north / south on unrotated models.  Add an angles field to the model to allow rotation in other directions.
+Pendulum frequency is a physical constant based on the length of the beam and gravity.
+"model2"	.md3 model to also draw
+"speed"		the number of degrees each way the pendulum swings, (30 default)
+"phase"		the 0.0 to 1.0 offset in the cycle to start at
+"dmg"		damage to inflict when blocked (2 default)
+"color"		constantLight color
+"light"		constantLight radius
+*/
+void SP_func_pendulum(gentity_t *ent) {
+	float		freq;
+	float		length;
+	float		phase;
+	float		speed;
+
+	G_SpawnFloat( "speed", "30", &speed );
+	G_SpawnInt( "dmg", "2", &ent->damage );
+	G_SpawnFloat( "phase", "0", &phase );
+
+	trap_SetBrushModel( ent, ent->model );
+
+	// find pendulum length
+	length = fabs( ent->r.mins[2] );
+	if ( length < 8 ) {
+		length = 8;
+	}
+
+	freq = 1 / ( M_PI * 2 ) * sqrt( g_gravity.value / ( 3 * length ) );
+
+	ent->s.pos.trDuration = ( 1000 / freq );
+
+	InitMover( ent );
+
+	VectorCopy( ent->s.origin, ent->s.pos.trBase );
+	VectorCopy( ent->s.origin, ent->r.currentOrigin );
+
+	VectorCopy( ent->s.angles, ent->s.apos.trBase );
+
+	ent->s.apos.trDuration = 1000 / freq;
+	ent->s.apos.trTime = ent->s.apos.trDuration * phase;
+	ent->s.apos.trType = TR_SINE;
+	ent->s.apos.trDelta[2] = speed;
+}
+
+/*
+===============================================================================
+
+BREAKABLE BRUSH
+
+===============================================================================
+*/
+//---------------------------------------------------
+static void CacheChunkEffects( material_t material )
+{
+	switch( material )
+	{
+	case MAT_GLASS:
+		G_EffectIndex( "chunks/glassbreak" );
+		break;
+	case MAT_GLASS_METAL:
+		G_EffectIndex( "chunks/glassbreak" );
+		G_EffectIndex( "chunks/metalexplode" );
+		break;
+	case MAT_ELECTRICAL:
+	case MAT_ELEC_METAL:
+		G_EffectIndex( "chunks/sparkexplode" );
+		break;
+	case MAT_METAL:
+	case MAT_METAL2:
+	case MAT_METAL3:
+	case MAT_CRATE1:
+	case MAT_CRATE2:
+		G_EffectIndex( "chunks/metalexplode" );
+		break;
+	case MAT_GRATE1:
+		G_EffectIndex( "chunks/grateexplode" );
+		break;
+	case MAT_DRK_STONE:
+	case MAT_LT_STONE:
+	case MAT_GREY_STONE:
+	case MAT_WHITE_METAL: // what is this crap really supposed to be??
+	case MAT_SNOWY_ROCK:
+		G_EffectIndex( "chunks/rockbreaklg" );
+		G_EffectIndex( "chunks/rockbreakmed" );
+		break;
+	case MAT_ROPE:
+		G_EffectIndex( "chunks/ropebreak" );
+//		G_SoundIndex(); // FIXME: give it a sound
+		break;
+	}
+}
+
+void G_MiscModelExplosion( vec3_t mins, vec3_t maxs, int size, material_t chunkType )
+{
+	gentity_t *te;
+	vec3_t mid;
+	
+	VectorAdd( mins, maxs, mid );
+	VectorScale( mid, 0.5f, mid );
+
+	te = G_TempEntity( mid, EV_MISC_MODEL_EXP );
+
+	VectorCopy(maxs, te->s.origin2);
+	VectorCopy(mins, te->s.angles2);
+	te->s.time = size;
+	te->s.eventParm = chunkType;
+}
+
+void G_Chunks( int owner, vec3_t origin, const vec3_t normal, const vec3_t mins, const vec3_t maxs, 
+						float speed, int numChunks, material_t chunkType, int customChunk, float baseScale )
+{
+	gentity_t *te = G_TempEntity( origin, EV_DEBRIS );
+
+	//Now it's time to cram everything horribly into the entitystate of an event entity.
+	te->s.owner = owner;
+	VectorCopy(origin, te->s.origin);
+	VectorCopy(normal, te->s.angles);
+	VectorCopy(maxs, te->s.origin2);
+	VectorCopy(mins, te->s.angles2);
+	te->s.speed = speed;
+	te->s.eventParm = numChunks;
+	te->s.trickedentindex = chunkType;
+	te->s.modelindex = customChunk;
+	te->s.apos.trBase[0] = baseScale;
+}
+
+//--------------------------------------
+void funcBBrushDieGo (gentity_t *self)
+{
+	vec3_t		org, dir, up;
+	gentity_t	*attacker = self->enemy;
+	float		scale;
+	int			i, numChunks, size = 0;
+	material_t	chunkType = self->material;
+	
+	// if a missile is stuck to us, blow it up so we don't look dumb
+	for ( i = 0; i < MAX_GENTITIES; i++ )
+	{
+		if ( g_entities[i].s.groundEntityNum == self->s.number && ( g_entities[i].s.eFlags & EF_MISSILE_STICK ))
+		{
+			G_Damage( &g_entities[i], self, self, NULL, NULL, 99999, 0, MOD_CRUSH ); //?? MOD?
+		}
+	}
+
+	//So chunks don't get stuck inside me
+	self->s.solid = 0;
+	self->r.contents = 0;
+	self->clipmask = 0;
+	trap_LinkEntity(self); 
+
+	VectorSet(up, 0, 0, 1);
+
+	if ( self->target && attacker != NULL )
+	{
+		G_UseTargets(self, attacker);
+	}
+
+	VectorSubtract( self->r.absmax, self->r.absmin, org );// size
+
+	numChunks = random() * 6 + 18;
+
+	// This formula really has no logical basis other than the fact that it seemed to be the closest to yielding the results that I wanted.
+	// Volume is length * width * height...then break that volume down based on how many chunks we have
+	scale = sqrt( sqrt( org[0] * org[1] * org[2] )) * 1.75f;
+
+	if ( scale > 48 )
+	{
+		size = 2;
+	}
+	else if ( scale > 24 )
+	{
+		size = 1;
+	}
+
+	scale = scale / numChunks;
+
+	if ( self->radius > 0.0f )
+	{
+		// designer wants to scale number of chunks, helpful because the above scale code is far from perfect
+		//	I do this after the scale calculation because it seems that the chunk size generally seems to be very close, it's just the number of chunks is a bit weak
+		numChunks *= self->radius;
+	}
+
+	VectorMA( self->r.absmin, 0.5, org, org );
+	VectorAdd( self->r.absmin,self->r.absmax, org );
+	VectorScale( org, 0.5f, org );
+
+	if ( attacker != NULL && attacker->client )
+	{
+		VectorSubtract( org, attacker->r.currentOrigin, dir );
+		VectorNormalize( dir );
+	}
+	else
+	{
+		VectorCopy(up, dir);
+	} 
+
+	if ( !(self->spawnflags & 2048) ) // NO_EXPLOSION
+	{
+		// we are allowed to explode
+		G_MiscModelExplosion( self->r.absmin, self->r.absmax, size, chunkType );
+	}
+
+	if (self->genericValue15)
+	{ //a custom effect to play
+		vec3_t ang;
+		VectorSet(ang, 0.0f, 1.0f, 0.0f);
+		G_PlayEffectID(self->genericValue15, org, ang);
+	}
+
+	if ( self->splashDamage > 0 && self->splashRadius > 0 )
+	{
+		gentity_t *te;
+		//explode
+		G_RadiusDamage( org, self, self->splashDamage, self->splashRadius, self, NULL, MOD_UNKNOWN );
+
+		te = G_TempEntity( org, EV_GENERAL_SOUND );
+		te->s.eventParm = G_SoundIndex("sound/weapons/explosions/cargoexplode.wav");
+	}
+
+	//FIXME: base numChunks off size?
+	G_Chunks( self->s.number, org, dir, self->r.absmin, self->r.absmax, 300, numChunks, chunkType, 0, (scale*self->mass) );
+
+	trap_AdjustAreaPortalState( self, qtrue );
+	self->think = G_FreeEntity;
+	self->nextthink = level.time + 50;
+	//G_FreeEntity( self );
+}
+
+void funcBBrushDie (gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int mod)
+{
+	self->takedamage = qfalse;//stop chain reaction runaway loops
+
+	self->enemy = attacker;
+
+	if(self->delay)
+	{
+		self->think = funcBBrushDieGo;
+		self->nextthink = level.time + floor(self->delay * 1000.0f);
+		return;
+	}
+
+	funcBBrushDieGo(self);
+}
+
+void funcBBrushUse (gentity_t *self, gentity_t *other, gentity_t *activator)
+{
+	G_ActivateBehavior( self, BSET_USE );
+	if(self->spawnflags & 64)
+	{//Using it doesn't break it, makes it use it's targets
+		if(self->target && self->target[0])
+		{
+			G_UseTargets(self, activator);
+		}
+	}
+	else
+	{
+		funcBBrushDie(self, other, activator, self->health, MOD_UNKNOWN);
+	}
+}
+
+void funcBBrushPain(gentity_t *self, gentity_t *attacker, int damage)
+{
+	if ( self->painDebounceTime > level.time )
+	{
+		return;
+	}
+
+	if ( self->paintarget && self->paintarget[0] )
+	{
+		if (!self->activator)
+		{
+			if (attacker && attacker->inuse && attacker->client)
+			{
+				G_UseTargets2 (self, attacker, self->paintarget);
+			}
+		}
+		else
+		{
+			G_UseTargets2 (self, self->activator, self->paintarget);
+		}
+	}
+
+	G_ActivateBehavior( self, BSET_PAIN );
+
+	if ( self->material == MAT_DRK_STONE
+		|| self->material == MAT_LT_STONE
+		|| self->material == MAT_GREY_STONE 
+		|| self->material == MAT_SNOWY_ROCK )
+	{
+		vec3_t	org, dir;
+		float	scale;
+		int		numChunks;
+		VectorSubtract( self->r.absmax, self->r.absmin, org );// size
+		// This formula really has no logical basis other than the fact that it seemed to be the closest to yielding the results that I wanted.
+		// Volume is length * width * height...then break that volume down based on how many chunks we have
+		scale = VectorLength( org ) / 100.0f;
+		VectorMA( self->r.absmin, 0.5, org, org );
+		VectorAdd( self->r.absmin,self->r.absmax, org );
+		VectorScale( org, 0.5f, org );
+		if ( attacker != NULL && attacker->client )
+		{
+			VectorSubtract( attacker->r.currentOrigin, org, dir );
+			VectorNormalize( dir );
+		}
+		else
+		{
+			VectorSet( dir, 0, 0, 1 );
+		} 
+		numChunks = Q_irand( 1, 3 );
+		if ( self->radius > 0.0f )
+		{
+			// designer wants to scale number of chunks, helpful because the above scale code is far from perfect
+			//	I do this after the scale calculation because it seems that the chunk size generally seems to be very close, it's just the number of chunks is a bit weak
+			numChunks = ceil(numChunks*self->radius);
+		}
+		G_Chunks( self->s.number, org, dir, self->r.absmin, self->r.absmax, 300, numChunks, self->material, 0, (scale*self->mass) );
+	}
+
+	if ( self->wait == -1 )
+	{
+		self->pain = 0;
+		return;
+	}
+
+	self->painDebounceTime = level.time + self->wait;
+}
+
+static void InitBBrush ( gentity_t *ent ) 
+{
+	float		light;
+	vec3_t		color;
+	qboolean	lightSet, colorSet;
+
+	VectorCopy( ent->s.origin, ent->pos1 );
+	
+	trap_SetBrushModel( ent, ent->model );
+
+	ent->die = funcBBrushDie;
+	
+	ent->flags |= FL_BBRUSH;
+
+	//This doesn't have to be an svFlag, can just be a flag.
+	//And it might not be needed anyway.
+	//ent->r.svFlags |= SVF_BBRUSH;
+
+
+	// if the "model2" key is set, use a seperate model
+	// for drawing, but clip against the brushes
+	if ( ent->model2 && ent->model2[0] ) 
+	{
+		ent->s.modelindex2 = G_ModelIndex( ent->model2 );
+	}
+
+	// if the "color" or "light" keys are set, setup constantLight
+	lightSet = G_SpawnFloat( "light", "100", &light );
+	colorSet = G_SpawnVector( "color", "1 1 1", color );
+	if ( lightSet || colorSet ) 
+	{
+		int		r, g, b, i;
+
+		r = color[0] * 255;
+		if ( r > 255 ) {
+			r = 255;
+		}
+		g = color[1] * 255;
+		if ( g > 255 ) {
+			g = 255;
+		}
+		b = color[2] * 255;
+		if ( b > 255 ) {
+			b = 255;
+		}
+		i = light / 4;
+		if ( i > 255 ) {
+			i = 255;
+		}
+		ent->s.constantLight = r | ( g << 8 ) | ( b << 16 ) | ( i << 24 );
+	}
+
+	if(ent->spawnflags & 128)
+	{//Can be used by the player's BUTTON_USE
+		ent->r.svFlags |= SVF_PLAYER_USABLE;
+	}
+
+	ent->s.eType = ET_MOVER;
+	trap_LinkEntity(ent);
+
+	ent->s.pos.trType = TR_STATIONARY;
+	VectorCopy( ent->pos1, ent->s.pos.trBase );
+}
+
+void funcBBrushTouch( gentity_t *ent, gentity_t *other, trace_t *trace )
+{
+}
+
+/*QUAKED func_breakable (0 .8 .5) ? INVINCIBLE IMPACT CRUSHER THIN SABERONLY HEAVY_WEAP USE_NOT_BREAK PLAYER_USE NO_EXPLOSION
+INVINCIBLE - can only be broken by being used
+IMPACT - does damage on impact
+CRUSHER - won't reverse movement when hit an obstacle
+THIN - can be broken by impact damage, like glass
+SABERONLY - only takes damage from sabers
+HEAVY_WEAP - only takes damage by a heavy weapon, like an emplaced gun or AT-ST gun.
+USE_NOT_BREAK - Using it doesn't make it break, still can be destroyed by damage
+PLAYER_USE - Player can use it with the use button
+NO_EXPLOSION - Does not play an explosion effect, though will still create chunks if specified
+
+When destroyed, fires it's trigger and chunks and plays sound "noise" or sound for type if no noise specified
+
+"targetname" entities with matching target will fire it
+"paintarget" target to fire when hit (but not destroyed)
+"wait"		how long minimum to wait between firing paintarget each time hit
+"delay"		When killed or used, how long (in seconds) to wait before blowing up (none by default)
+"model2"	.md3 model to also draw
+"target"	all entities with a matching targetname will be used when this is destoryed
+"health"	default is 10
+"numchunks" Multiplies the number of chunks spawned.  Chunk code tries to pick a good volume of chunks, but you can alter this to scale the number of spawned chunks. (default 1)  (.5) is half as many chunks, (2) is twice as many chunks
+"chunksize"	scales up/down the chunk size by this number (default is 1)
+"playfx"	path of effect to play on death
+
+"showhealth" if non-0, will display the health bar on the hud when the crosshair is over this ent (in siege)
+"teamowner" in siege this will specify which team this thing is "owned" by. To that team the crosshair will
+highlight green, to the other team it will highlight red.
+
+Damage: default is none
+"splashDamage" - damage to do
+"splashRadius" - radius for above damage
+
+"team" - If set, only this team can trip this trigger
+	0 - any
+	1 - red
+	2 - blue
+
+Don't know if these work:  
+"color"		constantLight color
+"light"		constantLight radius
+
+"material" - default is "0 - MAT_METAL" - choose from this list:
+0 = MAT_METAL		(basic blue-grey scorched-DEFAULT)
+1 = MAT_GLASS		
+2 = MAT_ELECTRICAL	(sparks only)
+3 = MAT_ELEC_METAL	(METAL2 chunks and sparks)
+4 =	MAT_DRK_STONE	(brown stone chunks)
+5 =	MAT_LT_STONE	(tan stone chunks)
+6 =	MAT_GLASS_METAL (glass and METAL2 chunks)
+7 = MAT_METAL2		(electronic type of metal)
+8 = MAT_NONE		(no chunks)
+9 = MAT_GREY_STONE	(grey colored stone)
+10 = MAT_METAL3		(METAL and METAL2 chunk combo)
+11 = MAT_CRATE1		(yellow multi-colored crate chunks)
+12 = MAT_GRATE1		(grate chunks--looks horrible right now)
+13 = MAT_ROPE		(for yavin_trial, no chunks, just wispy bits )
+14 = MAT_CRATE2		(red multi-colored crate chunks)
+15 = MAT_WHITE_METAL (white angular chunks for Stu, NS_hideout )
+16 = MAT_SNOWY_ROCK	 (mix of gray and brown rocks)
+
+Applicable only during Siege gametype:
+teamnodmg - if 1, team 1 can't damage this. If 2, team 2 can't damage this.
+
+*/
+void SP_func_breakable( gentity_t *self ) 
+{
+	int t;
+	char *s = NULL;
+
+	G_SpawnString("playfx", "", &s);
+
+	if (s && s[0])
+	{ //should we play a special death effect?
+		self->genericValue15 = G_EffectIndex(s);
+	}
+	else
+	{
+		self->genericValue15 = 0;
+	}
+
+	if(!(self->spawnflags & 1))
+	{
+		if(!self->health)
+		{
+			self->health = 10;
+		}
+	}
+
+	G_SpawnInt( "showhealth", "0", &t );
+
+	if (t)
+	{ //a non-0 maxhealth value will mean we want to show the health on the hud
+		self->maxHealth = self->health;
+		G_ScaleNetHealth(self);
+	}
+
+	//NOTE: g_spawn.c does this automatically now
+	//G_SpawnInt( "teamowner", "0", &t );
+	//self->s.teamowner = t;
+
+	if ( self->spawnflags & 16 ) // saber only
+	{
+		self->flags |= FL_DMG_BY_SABER_ONLY;
+	}
+	else if ( self->spawnflags & 32 ) // heavy weap
+	{
+		self->flags |= FL_DMG_BY_HEAVY_WEAP_ONLY;
+	}
+
+	if (self->health) 
+	{
+		self->takedamage = qtrue;
+	}
+
+	G_SoundIndex("sound/weapons/explosions/cargoexplode.wav");//precaching
+	G_SpawnFloat( "radius", "1", &self->radius ); // used to scale chunk code if desired by a designer
+	G_SpawnInt( "material", "0", (int*)&self->material );
+
+	G_SpawnInt( "splashDamage", "0", &self->splashDamage );
+	G_SpawnInt( "splashRadius", "0", &self->splashRadius );
+
+	CacheChunkEffects( self->material );
+
+	self->use = funcBBrushUse;
+
+	//if ( self->paintarget )
+	{
+		self->pain = funcBBrushPain;
+	}
+
+	self->touch = funcBBrushTouch;
+
+	/*
+	if ( self->team && self->team[0] )
+	{
+		self->alliedTeam = TranslateTeamName( self->team );
+		if(self->alliedTeam == TEAM_FREE)
+		{
+			G_Error("team name %s not recognized\n", self->team);
+		}
+	}
+	*/
+	if ( self->team && self->team[0] && g_gametype.integer == GT_SIEGE &&
+		!self->teamnodmg)
+	{
+		self->teamnodmg = atoi(self->team);
+	}
+	self->team = NULL;
+	if (!self->model) {
+		G_Error("func_breakable with NULL model\n");
+	}
+	InitBBrush( self );
+
+	if ( !self->radius )
+	{//numchunks multiplier
+		self->radius = 1.0f;
+	}
+	if ( !self->mass )
+	{//chunksize multiplier
+		self->mass = 1.0f;
+	}
+	self->genericValue4 = 1; //so damage sys knows it's a bbrush
+}
+
+qboolean G_EntIsBreakable( int entityNum )
+{
+	gentity_t *ent;
+
+	if ( entityNum < 0 || entityNum >= ENTITYNUM_WORLD )
+	{
+		return qfalse;
+	}
+
+	ent = &g_entities[entityNum];
+	if ( (ent->r.svFlags & SVF_GLASS_BRUSH) )
+	{
+		return qtrue;
+	}
+	/*
+	if ( (ent->svFlags&SVF_BBRUSH) )
+	{
+		return qtrue;
+	}
+	*/
+	if ( !Q_stricmp( "func_breakable", ent->classname ) )
+	{
+		return qtrue;
+	}
+
+	if ( !Q_stricmp( "misc_model_breakable", ent->classname ) )
+	{
+		return qtrue;
+	}
+	if ( !Q_stricmp( "misc_maglock", ent->classname ) )
+	{
+		return qtrue;
+	}
+
+	return qfalse;
+}
+
+/*
+===============================================================================
+
+GLASS
+
+===============================================================================
+*/
+void GlassDie(gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int mod)
+{
+	gentity_t *te;
+	vec3_t dif;
+
+	if (self->genericValue5)
+	{ //was already destroyed, do not retrigger it
+		return;
+	}
+
+	self->genericValue5 = 1;
+
+	dif[0] = (self->r.absmax[0]+self->r.absmin[0])/2;
+	dif[1] = (self->r.absmax[1]+self->r.absmin[1])/2;
+	dif[2] = (self->r.absmax[2]+self->r.absmin[2])/2;
+
+	G_UseTargets(self, attacker);
+
+	self->splashRadius = 40; // ?? some random number, maybe it's ok?
+
+	te = G_TempEntity( dif, EV_GLASS_SHATTER );
+	te->s.genericenemyindex = self->s.number;
+	VectorCopy(self->pos1, te->s.origin);
+	VectorCopy(self->pos2, te->s.angles);
+	te->s.trickedentindex = (int)self->splashRadius;
+	te->s.pos.trTime = (int)self->genericValue3;
+
+	G_FreeEntity(self);
+}
+
+void GlassDie_Old(gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int mod)
+{
+	gentity_t *te;
+	vec3_t dif;
+
+	dif[0] = (self->r.absmax[0]+self->r.absmin[0])/2;
+	dif[1] = (self->r.absmax[1]+self->r.absmin[1])/2;
+	dif[2] = (self->r.absmax[2]+self->r.absmin[2])/2;
+
+	G_UseTargets(self, attacker);
+
+	te = G_TempEntity( dif, EV_GLASS_SHATTER );
+	te->s.genericenemyindex = self->s.number;
+	VectorCopy(self->r.maxs, te->s.origin);
+	VectorCopy(self->r.mins, te->s.angles);
+
+	G_FreeEntity(self);
+}
+
+void GlassPain(gentity_t *self, gentity_t *attacker, int damage)
+{
+	//G_Printf("Mr. Glass says: PLZ NO IT HURTS\n");
+	//Make "cracking" sound?
+}
+
+void GlassUse(gentity_t *self, gentity_t *other, gentity_t *activator)
+{
+	vec3_t temp1, temp2;
+
+	//no direct object to blame for the break, so fill the values with whatever
+	VectorAdd( self->r.mins, self->r.maxs, temp1 );
+	VectorScale( temp1, 0.5f, temp1 );
+
+	VectorAdd( other->r.mins, other->r.maxs, temp2 );
+	VectorScale( temp2, 0.5f, temp2 );
+
+	VectorSubtract( temp1, temp2, self->pos2 );
+	VectorCopy( temp1, self->pos1 );
+
+	VectorNormalize( self->pos2 );
+	VectorScale( self->pos2, 390, self->pos2 );
+
+	GlassDie(self, other, activator, 100, MOD_UNKNOWN);
+}
+
+/*QUAKED func_glass (0 .5 .8) ? x x x x x x PLAYER_USE INACTIVE
+Breakable glass
+"model2"	.md3 model to also draw
+"color"		constantLight color
+"light"		constantLight radius
+"maxshards"	Max number of shards to spawn on glass break
+*/
+void SP_func_glass( gentity_t *ent ) {
+	trap_SetBrushModel( ent, ent->model );
+	InitMover( ent );
+
+	ent->r.svFlags = SVF_GLASS_BRUSH;
+
+	VectorCopy( ent->s.origin, ent->s.pos.trBase );
+	VectorCopy( ent->s.origin, ent->r.currentOrigin );
+	if (!ent->health)
+	{
+		ent->health = 1;
+	}
+
+	G_SpawnInt("maxshards", "0", &ent->genericValue3);
+
+	ent->genericValue1 = 0;
+
+	ent->genericValue4 = 1;
+
+	ent->moverState = MOVER_POS1;
+
+	if (ent->spawnflags & 1)
+	{
+		ent->takedamage = qfalse;
+	}
+	else
+	{
+		ent->takedamage = qtrue;
+	}
+
+	ent->die = GlassDie;
+	ent->use = GlassUse;
+	ent->pain = GlassPain;
+}
+
+void func_usable_use (gentity_t *self, gentity_t *other, gentity_t *activator);
+
+extern gentity_t	*G_TestEntityPosition( gentity_t *ent );
+void func_wait_return_solid( gentity_t *self )
+{
+	//once a frame, see if it's clear.
+	self->clipmask = CONTENTS_BODY;
+	if ( !(self->spawnflags&16) || G_TestEntityPosition( self ) == NULL )
+	{
+		trap_SetBrushModel( self, self->model );
+		InitMover( self );
+		VectorCopy( self->s.origin, self->s.pos.trBase );
+		VectorCopy( self->s.origin, self->r.currentOrigin );
+		self->r.svFlags &= ~SVF_NOCLIENT;
+		self->s.eFlags &= ~EF_NODRAW;
+		self->use = func_usable_use;
+		self->clipmask = 0;
+		if ( self->target2 && self->target2[0] )
+		{
+			G_UseTargets2( self, self->activator, self->target2 );
+		}
+		//FIXME: Animations?
+		/*if ( self->s.eFlags & EF_ANIM_ONCE )
+		{//Start our anim
+			self->s.frame = 0;
+		}*/
+	}
+	else
+	{
+		self->clipmask = 0;
+		self->think = func_wait_return_solid;
+		self->nextthink = level.time + FRAMETIME;
+	}
+}
+
+void func_usable_think( gentity_t *self )
+{
+	if ( self->spawnflags & 8 )
+	{
+		self->r.svFlags |= SVF_PLAYER_USABLE;	//Replace the usable flag
+		self->use = func_usable_use;
+		self->think = 0;
+	}
+}
+
+qboolean G_EntIsRemovableUsable( int entNum )
+{
+	gentity_t *ent = &g_entities[entNum];
+	if ( ent->classname && !Q_stricmp( "func_usable", ent->classname ) )
+	{
+		if ( !(ent->s.eFlags&EF_SHADER_ANIM) && !(ent->spawnflags&8) && ent->targetname )
+		{//not just a shader-animator and not ALWAYS_ON, so it must be removable somehow
+			return qtrue;
+		}
+	}
+	return qfalse;
+}
+
+void func_usable_use (gentity_t *self, gentity_t *other, gentity_t *activator)
+{//Toggle on and off
+	G_ActivateBehavior( self, BSET_USE );
+	if ( self->s.eFlags & EF_SHADER_ANIM )
+	{//animate shader when used
+		self->s.frame++;//inc frame
+		if ( self->s.frame > self->genericValue5 )
+		{//wrap around
+			self->s.frame = 0;
+		}
+		if ( self->target && self->target[0] )
+		{
+			G_UseTargets( self, activator );
+		}
+	}
+	else if ( self->spawnflags & 8 )
+	{//ALWAYS_ON
+		//Remove the ability to use the entity directly
+		self->r.svFlags &= ~SVF_PLAYER_USABLE;
+		//also remove ability to call any use func at all!
+		self->use = 0;
+		
+		if(self->target && self->target[0])
+		{
+			G_UseTargets(self, activator);
+		}
+		
+		if ( self->wait )
+		{
+			self->think = func_usable_think;
+			self->nextthink = level.time + ( self->wait * 1000 );
+		}
+
+		return;
+	}
+	else if ( !self->count )
+	{//become solid again
+		self->count = 1;
+		func_wait_return_solid( self );
+	}
+	else
+	{
+		self->s.solid = 0;
+		self->r.contents = 0;
+		self->clipmask = 0;
+		self->r.svFlags |= SVF_NOCLIENT;
+		self->s.eFlags |= EF_NODRAW;
+		self->count = 0;
+
+		if(self->target && self->target[0])
+		{
+			G_UseTargets(self, activator);
+		}
+		self->think = 0;
+		self->nextthink = -1;
+	}
+}
+
+void func_usable_pain(gentity_t *self, gentity_t *attacker, int damage)
+{
+	GlobalUse(self, attacker, attacker);
+}
+
+void func_usable_die(gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int mod)
+{
+	self->takedamage = qfalse;
+	GlobalUse(self, inflictor, attacker);
+}
+
+/*QUAKED func_usable (0 .5 .8) ? STARTOFF x x ALWAYS_ON x x PLAYER_USE INACTIVE
+START_OFF - the wall will not be there
+ALWAYS_ON - Doesn't toggle on and off when used, just runs usescript and fires target
+
+A bmodel that just sits there, doing nothing.  Can be used for conditional walls and models.
+"targetname" - When used, will toggle on and off
+"target"	Will fire this target every time it is toggled OFF
+"model2"	.md3 model to also draw
+"color"		constantLight color
+"light"		constantLight radius
+"usescript" script to run when turned on
+"deathscript"  script to run when turned off
+"wait"		amount of time before the object is usable again (only valid with ALWAYS_ON flag)
+"health"	if it has health, it will be used whenever shot at/killed - if you want it to only be used once this way, set health to 1
+"endframe"	Will make it animate to next shader frame when used, not turn on/off... set this to number of frames in the shader, minus 1
+
+Applicable only during Siege gametype:
+teamuser - if 1, team 2 can't use this. If 2, team 1 can't use this.
+
+*/
+
+void SP_func_usable( gentity_t *self ) 
+{
+	trap_SetBrushModel( self, self->model );
+	InitMover( self );
+	VectorCopy( self->s.origin, self->s.pos.trBase );
+	VectorCopy( self->s.origin, self->r.currentOrigin );
+	VectorCopy( self->s.origin, self->pos1 );
+
+	G_SpawnInt("endframe", "0", &self->genericValue5);
+
+	if ( self->model2 && self->model2[0] ) 
+	{
+		if ( strstr( self->model2, ".glm" ))
+		{ //for now, not supported in MP.
+			self->s.modelindex2 = 0;
+		}
+		else
+		{
+			self->s.modelindex2 = G_ModelIndex( self->model2 );
+		}
+	}
+
+	self->count = 1;
+	if (self->spawnflags & 1)
+	{
+		self->s.solid = 0;
+		self->r.contents = 0;
+		self->clipmask = 0;
+		self->r.svFlags |= SVF_NOCLIENT;
+		self->s.eFlags |= EF_NODRAW;
+		self->count = 0;
+	}
+
+	//FIXME: Animation?
+	/*
+	if (self->spawnflags & 2)
+	{
+		self->s.eFlags |= EF_ANIM_ALLFAST;
+	}
+
+	if (self->spawnflags & 4)
+	{//FIXME: need to be able to do change to something when it's done?  Or not be usable until it's done?
+		self->s.eFlags |= EF_ANIM_ONCE;
+	}
+	*/
+
+	self->use = func_usable_use;
+
+	if ( self->health )
+	{
+		self->takedamage = qtrue;
+		self->die = func_usable_die;
+		self->pain = func_usable_pain;
+	}
+
+	if ( self->genericValue5 > 0 )
+	{
+		self->s.frame = 0;
+		self->s.eFlags |= EF_SHADER_ANIM;
+		self->s.time = self->genericValue5 + 1;
+	}
+
+	trap_LinkEntity (self);
+}
+
+
+/*
+===============================================================================
+
+WALL
+
+===============================================================================
+*/
+
+//static -slc
+void use_wall( gentity_t *ent, gentity_t *other, gentity_t *activator )
+{
+	G_ActivateBehavior(ent,BSET_USE);
+
+	// Not there so make it there
+	if (!(ent->r.contents & CONTENTS_SOLID))
+	{
+		ent->r.svFlags &= ~SVF_NOCLIENT;
+		ent->s.eFlags &= ~EF_NODRAW;
+		ent->r.contents = CONTENTS_SOLID;
+		if ( !(ent->spawnflags&1) )
+		{//START_OFF doesn't effect area portals
+			trap_AdjustAreaPortalState( ent, qfalse );
+		}
+	}
+	// Make it go away
+	else
+	{
+		ent->r.contents = 0;
+		ent->r.svFlags |= SVF_NOCLIENT;
+		ent->s.eFlags |= EF_NODRAW;
+		if ( !(ent->spawnflags&1) )
+		{//START_OFF doesn't effect area portals
+			trap_AdjustAreaPortalState( ent, qtrue );
+		}
+	}
+}
+
+#define FUNC_WALL_OFF	1
+
+/*QUAKED func_wall (0 .5 .8) ? START_OFF x x x x x PLAYER_USE INACTIVE
+PLAYER_USE	Player can use it with the use button
+INACTIVE	must be used by a target_activate before it can be used
+
+A bmodel that just sits there, doing nothing.  Can be used for conditional walls and models.
+"model2"	.md3 model to also draw
+"color"		constantLight color
+"light"		constantLight radius
+
+START_OFF - the wall will not be there
+*/
+void SP_func_wall( gentity_t *ent ) 
+{
+	trap_SetBrushModel( ent, ent->model );
+
+	VectorCopy( ent->s.origin, ent->pos1 );
+	VectorCopy( ent->s.origin, ent->pos2 );
+
+	InitMover( ent );
+	VectorCopy( ent->s.origin, ent->s.pos.trBase );
+	VectorCopy( ent->s.origin, ent->r.currentOrigin );
+
+	// it must be START_OFF
+	if (ent->spawnflags & FUNC_WALL_OFF)
+	{
+		ent->r.contents = 0;
+		ent->r.svFlags |= SVF_NOCLIENT;
+		ent->s.eFlags |= EF_NODRAW;
+	}
+
+	ent->use = use_wall;
+
+	trap_LinkEntity (ent);
+
+}
diff --git a/codemp/game/g_nav.c b/codemp/game/g_nav.c
new file mode 100644
index 0000000..a78ae83
--- /dev/null
+++ b/codemp/game/g_nav.c
@@ -0,0 +1,1913 @@
+#include "b_local.h"
+#include "g_nav.h"
+
+extern qboolean G_EntIsUnlockedDoor( int entityNum );
+extern qboolean G_EntIsDoor( int entityNum );
+extern qboolean G_EntIsBreakable( int entityNum );
+extern qboolean G_EntIsRemovableUsable( int entNum );
+extern qboolean G_FindClosestPointOnLineSegment( const vec3_t start, const vec3_t end, const vec3_t from, vec3_t result );
+//For debug graphics
+//rwwFIXMEFIXME: Write these at some point for the sake of being able to debug visually
+void G_Line( vec3_t start, vec3_t end, vec3_t color, float alpha )
+{
+
+}
+
+void G_Cube( vec3_t mins, vec3_t maxs, vec3_t color, float alpha )
+{
+
+}
+
+void G_CubeOutline( vec3_t mins, vec3_t maxs, int time, unsigned int color, float alpha )
+{
+
+}
+
+void G_DrawEdge( vec3_t start, vec3_t end, int type )
+{
+
+}
+
+void G_DrawNode( vec3_t origin, int type )
+{
+
+}
+
+void G_DrawCombatPoint( vec3_t origin, int type )
+{
+
+}
+
+void TAG_ShowTags( int flags )
+{
+
+}
+
+qboolean FlyingCreature( gentity_t *ent )
+{
+	if (ent->client && ent->client->ps.gravity <= 0)
+	{
+		return qtrue;
+	}
+	return qfalse;
+}
+
+qboolean NAV_CheckAhead( gentity_t *self, vec3_t end, trace_t *trace, int clipmask );
+void NAV_StoreWaypoint( gentity_t *ent );
+
+extern vec3_t NPCDEBUG_RED;
+
+
+/*
+-------------------------
+NPC_Blocked
+-------------------------
+*/
+
+
+void NPC_Blocked( gentity_t *self, gentity_t *blocker )
+{
+	if ( self->NPC == NULL )
+		return;
+
+	//Don't do this too often
+	if ( self->NPC->blockedSpeechDebounceTime > level.time )
+		return;
+
+	//Attempt to run any blocked scripts
+	if ( G_ActivateBehavior( self, BSET_BLOCKED ) )
+	{
+		return;
+	}
+
+	//If this is one of our enemies, then just attack him
+	if ( blocker->client && ( blocker->client->playerTeam == self->client->enemyTeam ) )
+	{
+		G_SetEnemy( self, blocker );
+		return;
+	}
+
+	//Debug_Printf( debugNPCAI, DEBUG_LEVEL_WARNING, "%s: Excuse me, %s %s!\n", self->targetname, blocker->classname, blocker->targetname );
+	
+	//If we're being blocked by the player, say something to them
+	if ( ( blocker->s.number == 0 ) && ( ( blocker->client->playerTeam == self->client->playerTeam ) ) )
+	{
+		//guys in formation are not trying to get to a critical point, 
+		//don't make them yell at the player (unless they have an enemy and
+		//are in combat because BP thinks it sounds cool during battle)
+		//NOTE: only imperials, misc crewmen and hazard team have these wav files now
+		//G_AddVoiceEvent( self, Q_irand(EV_BLOCKED1, EV_BLOCKED3), 0 );
+	}
+
+	self->NPC->blockedSpeechDebounceTime = level.time + MIN_BLOCKED_SPEECH_TIME + ( random() * 4000 );
+	self->NPC->blockingEntNum = blocker->s.number;
+}
+
+/*
+-------------------------
+NPC_SetMoveGoal
+-------------------------
+*/
+
+void NPC_SetMoveGoal( gentity_t *ent, vec3_t point, int radius, qboolean isNavGoal, int combatPoint, gentity_t *targetEnt )
+{
+	//Must be an NPC
+	if ( ent->NPC == NULL )
+	{
+		return;
+	}
+
+	if ( ent->NPC->tempGoal == NULL )
+	{//must still have a goal
+		return;
+	}
+
+	//Copy the origin
+	//VectorCopy( point, ent->NPC->goalPoint );	//FIXME: Make it use this, and this alone!
+	VectorCopy( point, ent->NPC->tempGoal->r.currentOrigin );
+	
+	//Copy the mins and maxs to the tempGoal
+	VectorCopy( ent->r.mins, ent->NPC->tempGoal->r.mins );
+	VectorCopy( ent->r.mins, ent->NPC->tempGoal->r.maxs );
+
+	ent->NPC->tempGoal->target = NULL;
+	ent->NPC->tempGoal->clipmask = ent->clipmask;
+	ent->NPC->tempGoal->flags &= ~FL_NAVGOAL;
+	if ( targetEnt && targetEnt->waypoint >= 0 )
+	{
+		ent->NPC->tempGoal->waypoint = targetEnt->waypoint;
+	}
+	else
+	{
+		ent->NPC->tempGoal->waypoint = WAYPOINT_NONE;
+	}
+	ent->NPC->tempGoal->noWaypointTime = 0;
+
+	if ( isNavGoal )
+	{
+		assert(ent->NPC->tempGoal->parent);
+		ent->NPC->tempGoal->flags |= FL_NAVGOAL;
+	}
+
+	ent->NPC->tempGoal->combatPoint = combatPoint;
+	ent->NPC->tempGoal->enemy = targetEnt;
+
+	ent->NPC->goalEntity = ent->NPC->tempGoal;
+	ent->NPC->goalRadius = radius;
+
+	trap_LinkEntity( ent->NPC->goalEntity );
+}
+
+/*
+-------------------------
+NAV_HitNavGoal
+-------------------------
+*/
+
+qboolean NAV_HitNavGoal( vec3_t point, vec3_t mins, vec3_t maxs, vec3_t dest, int radius, qboolean flying )
+{
+	vec3_t	dmins, dmaxs, pmins, pmaxs;
+
+	if ( radius & NAVGOAL_USE_RADIUS )
+	{
+		radius &= ~NAVGOAL_USE_RADIUS;
+		//NOTE:  This needs to do a DistanceSquared on navgoals that had
+		//			a radius manually set! We can't do the smaller navgoals against
+		//			walls to get around this because player-sized traces to them
+		//			from angles will not work... - MCG
+		if ( !flying )
+		{//Allow for a little z difference
+			vec3_t	diff;
+			VectorSubtract( point, dest, diff );
+			if ( fabs(diff[2]) <= 24 )
+			{
+				diff[2] = 0;
+			}
+			return ( VectorLengthSquared( diff ) <= (radius*radius) );
+		}
+		else
+		{//must hit exactly
+			return ( DistanceSquared(dest, point) <= (radius*radius) );
+		}
+		//There is probably a better way to do this, either by preserving the original
+		//		mins and maxs of the navgoal and doing this check ONLY if the radius 
+		//		is non-zero (like the original implementation) or some boolean to
+		//		tell us to do this check rather than the fake bbox overlap check...
+	}
+	else
+	{
+		//Construct a dummy bounding box from our radius value
+		VectorSet( dmins, -radius, -radius, -radius );
+		VectorSet( dmaxs,  radius,  radius,  radius );
+
+		//Translate it
+		VectorAdd( dmins, dest, dmins );
+		VectorAdd( dmaxs, dest, dmaxs );
+
+		//Translate the starting box
+		VectorAdd( point, mins, pmins );
+		VectorAdd( point, maxs, pmaxs );
+
+		//See if they overlap
+		return G_BoundsOverlap( pmins, pmaxs, dmins, dmaxs );
+	}
+}
+
+/*
+-------------------------
+NAV_ClearPathToPoint
+-------------------------
+*/
+
+qboolean NAV_ClearPathToPoint( gentity_t *self, vec3_t pmins, vec3_t pmaxs, vec3_t point, int clipmask, int okToHitEntNum )
+{
+//	trace_t	trace;
+//	return NAV_CheckAhead( self, point, trace, clipmask|CONTENTS_BOTCLIP );
+
+	vec3_t	mins, maxs;
+	trace_t	trace;
+
+	//Test if they're even conceivably close to one another
+	if ( !trap_InPVS( self->r.currentOrigin, point ) )
+		return qfalse;
+
+	if ( self->flags & FL_NAVGOAL )
+	{
+		if ( !self->parent )
+		{
+			//SHOULD NEVER HAPPEN!!!
+			assert(self->parent);
+			return qfalse;
+		}
+		VectorCopy( self->parent->r.mins, mins );
+		VectorCopy( self->parent->r.maxs, maxs );
+	}
+	else
+	{
+		VectorCopy( pmins, mins );
+		VectorCopy( pmaxs, maxs );
+	}
+	
+	if ( self->client || ( self->flags & FL_NAVGOAL ) )
+	{
+		//Clients can step up things, or if this is a navgoal check, a client will be using this info
+		mins[2] += STEPSIZE;
+
+		//don't let box get inverted
+		if ( mins[2] > maxs[2] )
+		{	
+			mins[2] = maxs[2];
+		}
+	}
+
+	if ( self->flags & FL_NAVGOAL )
+	{
+		//Trace from point to navgoal
+		trap_Trace( &trace, point, mins, maxs, self->r.currentOrigin, self->parent->s.number, (clipmask|CONTENTS_MONSTERCLIP|CONTENTS_BOTCLIP)&~CONTENTS_BODY );
+		if ( trace.startsolid&&(trace.contents&CONTENTS_BOTCLIP) )
+		{//started inside do not enter, so ignore them
+			clipmask &= ~CONTENTS_BOTCLIP;
+			trap_Trace( &trace, point, mins, maxs, self->r.currentOrigin, self->parent->s.number, (clipmask|CONTENTS_MONSTERCLIP)&~CONTENTS_BODY );
+		}
+		
+		if ( trace.startsolid || trace.allsolid )
+		{
+			return qfalse;
+		}
+		
+		//Made it
+		if ( trace.fraction == 1.0 )
+		{
+			return qtrue;
+		}
+		
+		if ( okToHitEntNum != ENTITYNUM_NONE && trace.entityNum == okToHitEntNum )
+		{
+			return qtrue;
+		}
+
+		//Okay, didn't get all the way there, let's see if we got close enough:
+		if ( NAV_HitNavGoal( self->r.currentOrigin, self->parent->r.mins, self->parent->r.maxs, trace.endpos, NPCInfo->goalRadius, FlyingCreature( self->parent ) ) )
+		{
+			return qtrue;
+		}
+		else
+		{
+			if ( NAVDEBUG_showCollision )
+			{
+				if ( trace.entityNum < ENTITYNUM_WORLD && (&g_entities[trace.entityNum] != NULL) && g_entities[trace.entityNum].s.eType != ET_MOVER )
+				{
+					vec3_t	p1, p2;
+					G_DrawEdge( point, trace.endpos, EDGE_PATH );
+					VectorAdd(g_entities[trace.entityNum].r.mins, g_entities[trace.entityNum].r.currentOrigin, p1);
+					VectorAdd(g_entities[trace.entityNum].r.maxs, g_entities[trace.entityNum].r.currentOrigin, p2);
+					G_CubeOutline( p1, p2, FRAMETIME, 0x0000ff, 0.5 );
+				}
+				//FIXME: if it is a bmodel, light up the surf?
+			}
+		}
+	}
+	else
+	{
+		trap_Trace( &trace, self->r.currentOrigin, mins, maxs, point, self->s.number, clipmask|CONTENTS_MONSTERCLIP|CONTENTS_BOTCLIP);
+		if ( trace.startsolid&&(trace.contents&CONTENTS_BOTCLIP) )
+		{//started inside do not enter, so ignore them
+			clipmask &= ~CONTENTS_BOTCLIP;
+			trap_Trace( &trace, self->r.currentOrigin, mins, maxs, point, self->s.number, clipmask|CONTENTS_MONSTERCLIP);
+		}
+
+		if( ( ( trace.startsolid == qfalse ) && ( trace.allsolid == qfalse ) ) && ( trace.fraction == 1.0f ) )
+		{//FIXME: check for drops
+			return qtrue;
+		}
+
+		if ( okToHitEntNum != ENTITYNUM_NONE && trace.entityNum == okToHitEntNum )
+		{
+			return qtrue;
+		}
+
+		if ( NAVDEBUG_showCollision )
+		{
+			if ( trace.entityNum < ENTITYNUM_WORLD && (&g_entities[trace.entityNum] != NULL) && g_entities[trace.entityNum].s.eType != ET_MOVER )
+			{
+				vec3_t	p1, p2;
+				G_DrawEdge( self->r.currentOrigin, trace.endpos, EDGE_PATH );
+				VectorAdd(g_entities[trace.entityNum].r.mins, g_entities[trace.entityNum].r.currentOrigin, p1);
+				VectorAdd(g_entities[trace.entityNum].r.maxs, g_entities[trace.entityNum].r.currentOrigin, p2);
+				G_CubeOutline( p1, p2, FRAMETIME, 0x0000ff, 0.5 );
+			}
+			//FIXME: if it is a bmodel, light up the surf?
+		}
+	}
+
+	return qfalse;
+}
+
+/*
+-------------------------
+NAV_FindClosestWaypointForEnt
+-------------------------
+*/
+
+int NAV_FindClosestWaypointForEnt( gentity_t *ent, int targWp )
+{
+	//FIXME: Take the target into account
+	return trap_Nav_GetNearestNode( ent, ent->waypoint, NF_CLEAR_PATH, targWp );
+}
+
+int NAV_FindClosestWaypointForPoint( gentity_t *ent, vec3_t point )
+{
+	int	bestWP;
+	//FIXME: can we make this a static ent?
+	gentity_t *marker = G_Spawn();
+	
+	if ( !marker )
+	{
+		return WAYPOINT_NONE;
+	}
+
+	G_SetOrigin( marker, point );
+
+	VectorCopy( ent->r.mins, marker->r.mins );//stepsize?
+	VectorCopy( ent->r.mins, marker->r.maxs );//crouching?
+
+	marker->clipmask = ent->clipmask;
+	marker->waypoint = WAYPOINT_NONE;
+
+	bestWP = trap_Nav_GetNearestNode( marker, marker->waypoint, NF_CLEAR_PATH, WAYPOINT_NONE );
+
+	G_FreeEntity( marker );
+
+	return bestWP;
+}
+
+int NAV_FindClosestWaypointForPoint2( vec3_t point )
+{
+	int	bestWP;
+	//FIXME: can we make this a static ent?
+	gentity_t *marker = G_Spawn();
+	
+	if ( !marker )
+	{
+		return WAYPOINT_NONE;
+	}
+
+	G_SetOrigin( marker, point );
+
+	VectorSet( marker->r.mins, -16, -16, -6 );//includes stepsize
+	VectorSet( marker->r.maxs, 16, 16, 32 );
+
+	marker->clipmask = MASK_NPCSOLID;
+	marker->waypoint = WAYPOINT_NONE;
+
+	bestWP = trap_Nav_GetNearestNode( marker, marker->waypoint, NF_CLEAR_PATH, WAYPOINT_NONE );
+
+	G_FreeEntity( marker );
+
+	return bestWP;
+}
+
+/*
+-------------------------
+NAV_ClearBlockedInfo
+-------------------------
+*/
+
+void NAV_ClearBlockedInfo( gentity_t *self )
+{
+	self->NPC->aiFlags &= ~NPCAI_BLOCKED;
+	self->NPC->blockingEntNum = ENTITYNUM_WORLD;
+}
+
+/*
+-------------------------
+NAV_SetBlockedInfo
+-------------------------
+*/
+
+void NAV_SetBlockedInfo( gentity_t *self, int entId )
+{
+	self->NPC->aiFlags |= NPCAI_BLOCKED;
+	self->NPC->blockingEntNum = entId;
+}
+
+/*
+-------------------------
+NAV_Steer
+-------------------------
+*/
+
+int NAV_Steer( gentity_t *self, vec3_t dir, float distance )
+{
+	vec3_t	right_test, left_test;
+	vec3_t	deviation;
+	trace_t	tr;
+	float	right_push;
+	float	left_push;
+	float	right_ang	= dir[YAW] + 45;
+	float	left_ang	= dir[YAW] - 45;
+
+	//Get the steering angles
+	VectorCopy( dir, deviation );
+	deviation[YAW] = right_ang;
+
+	AngleVectors( deviation, right_test, NULL, NULL );
+
+	deviation[YAW] = left_ang;
+
+	AngleVectors( deviation, left_test, NULL, NULL );
+
+	//Find the end positions
+	VectorMA( self->r.currentOrigin, distance, right_test, right_test );
+	VectorMA( self->r.currentOrigin, distance, left_test,  left_test );
+
+	//Draw for debug purposes
+	if ( NAVDEBUG_showCollision )
+	{
+		G_DrawEdge( self->r.currentOrigin, right_test, EDGE_PATH );
+		G_DrawEdge( self->r.currentOrigin, left_test,  EDGE_PATH );
+	}
+
+	//Find the right influence
+	NAV_CheckAhead( self, right_test, &tr, self->clipmask|CONTENTS_BOTCLIP );
+
+	right_push = -45 * ( 1.0f - tr.fraction );
+
+	//Find the left influence
+	NAV_CheckAhead( self, left_test, &tr, self->clipmask|CONTENTS_BOTCLIP );
+
+	left_push = 45 * ( 1.0f - tr.fraction );
+
+	//Influence the mover to respond to the steering
+	VectorCopy( dir, deviation );
+	deviation[YAW] += ( left_push + right_push );
+
+	return deviation[YAW];
+}
+
+/*
+-------------------------
+NAV_CheckAhead
+-------------------------
+*/
+
+qboolean NAV_CheckAhead( gentity_t *self, vec3_t end, trace_t *trace, int clipmask )
+{
+	vec3_t	mins;
+	float	radius;
+	float	dist;
+	float	tFrac;
+
+	//Offset the step height
+	VectorSet( mins, self->r.mins[0], self->r.mins[1], self->r.mins[2] + STEPSIZE );
+	
+	trap_Trace( trace, self->r.currentOrigin, mins, self->r.maxs, end, self->s.number, clipmask );
+
+	if ( trace->startsolid&&(trace->contents&CONTENTS_BOTCLIP) )
+	{//started inside do not enter, so ignore them
+		clipmask &= ~CONTENTS_BOTCLIP;
+		trap_Trace( trace, self->r.currentOrigin, mins, self->r.maxs, end, self->s.number, clipmask );
+	}
+	//Do a simple check
+	if ( ( trace->allsolid == qfalse ) && ( trace->startsolid == qfalse ) && ( trace->fraction == 1.0f ) )
+		return qtrue;
+
+	//See if we're too far above
+	if ( fabs( self->r.currentOrigin[2] - end[2] ) > 48 )
+		return qfalse;
+
+	//This is a work around
+	radius = ( self->r.maxs[0] > self->r.maxs[1] ) ? self->r.maxs[0] : self->r.maxs[1];
+	dist = Distance( self->r.currentOrigin, end );
+	tFrac = 1.0f - ( radius / dist );
+
+	if ( trace->fraction >= tFrac )
+		return qtrue;
+
+	//Do a special check for doors
+	if ( trace->entityNum < ENTITYNUM_WORLD )
+	{
+		gentity_t	*blocker = &g_entities[trace->entityNum];
+		
+		if VALIDSTRING( blocker->classname )
+		{
+			if ( G_EntIsUnlockedDoor( blocker->s.number ) )
+			//if ( Q_stricmp( blocker->classname, "func_door" ) == 0 )
+			{
+				//We're too close, try and avoid the door (most likely stuck on a lip)
+				if ( DistanceSquared( self->r.currentOrigin, trace->endpos ) < MIN_DOOR_BLOCK_DIST_SQR )
+					return qfalse;
+
+				return qtrue;
+			}
+		}
+	}
+
+	return qfalse;
+}
+
+/*
+-------------------------
+NAV_TestBypass
+-------------------------
+*/
+
+static qboolean NAV_TestBypass( gentity_t *self, float yaw, float blocked_dist, vec3_t movedir )
+{
+	trace_t	tr;
+	vec3_t	avoidAngles;
+	vec3_t	block_test, block_pos;
+
+	VectorClear( avoidAngles );
+	avoidAngles[YAW] = yaw;
+
+	AngleVectors( avoidAngles, block_test, NULL, NULL );
+	VectorMA( self->r.currentOrigin, blocked_dist, block_test, block_pos );
+		
+	if ( NAVDEBUG_showCollision )
+	{
+		G_DrawEdge( self->r.currentOrigin, block_pos, EDGE_BLOCKED );
+	}
+
+	//See if we're clear to move in that direction
+	if ( NAV_CheckAhead( self, block_pos, &tr, ( self->clipmask & ~CONTENTS_BODY )|CONTENTS_BOTCLIP ) )
+	{
+		VectorCopy( block_test, movedir );
+		
+		return qtrue;
+	}
+
+	return qfalse;
+}
+
+/*
+-------------------------
+NAV_Bypass
+-------------------------
+*/
+
+qboolean NAV_Bypass( gentity_t *self, gentity_t *blocker, vec3_t blocked_dir, float blocked_dist, vec3_t movedir ) 
+{
+	float dot, yaw, avoidRadius, arcAngle;
+	vec3_t	right;
+
+	//Draw debug info if requested
+	if ( NAVDEBUG_showCollision )
+	{
+		G_DrawEdge( self->r.currentOrigin, blocker->r.currentOrigin, EDGE_NORMAL );
+	}
+
+	AngleVectors( self->r.currentAngles, NULL, right, NULL );
+
+	//Get the blocked direction
+	yaw = vectoyaw( blocked_dir );
+
+	//Get the avoid radius
+	avoidRadius = sqrt( ( blocker->r.maxs[0] * blocker->r.maxs[0] ) + ( blocker->r.maxs[1] * blocker->r.maxs[1] ) ) + 
+						sqrt( ( self->r.maxs[0] * self->r.maxs[0] ) + ( self->r.maxs[1] * self->r.maxs[1] ) );
+
+	//See if we're inside our avoidance radius
+	arcAngle = ( blocked_dist <= avoidRadius ) ? 135 : ( ( avoidRadius / blocked_dist ) * 90 );
+
+	//FIXME: Although the below code will cause the NPC to take the "better" route, it can cause NPCs to become stuck on
+	//		 one another in certain situations where both decide to take the same direction.
+
+	//Check to see what dir the other guy is moving in (if any) and pick the opposite dir
+	if ( blocker->client && !VectorCompare( blocker->client->ps.velocity, vec3_origin ) )
+	{
+		vec3_t blocker_movedir;
+		VectorNormalize2( blocker->client->ps.velocity, blocker_movedir );
+		dot = DotProduct( blocker_movedir, blocked_dir );
+		if ( dot < 0.35f && dot > -0.35f )
+		{//he's moving to the side of me
+			vec3_t	block_pos;
+			trace_t	tr;
+			VectorScale( blocker_movedir, -1, blocker_movedir );
+			VectorMA( self->r.currentOrigin, blocked_dist, blocker_movedir, block_pos );
+			if ( NAV_CheckAhead( self, block_pos, &tr, ( self->clipmask & ~CONTENTS_BODY )|CONTENTS_BOTCLIP ) )
+			{
+				VectorCopy( blocker_movedir, movedir );
+				return qtrue;
+			}
+		}
+	}
+
+	//FIXME: this makes NPCs stack up and ping-pong like crazy.
+	//			Need to keep track of this and stop trying after a while
+	dot = DotProduct( blocked_dir, right );
+
+	//Go right on the first try if that works better
+	if ( dot < 0.0f )
+		arcAngle *= -1;
+
+	//Test full, best position first
+	if ( NAV_TestBypass( self, AngleNormalize360( yaw + arcAngle ), blocked_dist, movedir ) )
+		return qtrue;
+
+	//Try a smaller arc
+	if ( NAV_TestBypass( self, AngleNormalize360( yaw + ( arcAngle * 0.5f ) ), blocked_dist, movedir ) )
+		return qtrue;
+
+	//Try the other direction
+	if ( NAV_TestBypass( self, AngleNormalize360( yaw + ( arcAngle * -1 ) ), blocked_dist, movedir ) )
+		return qtrue;
+
+	//Try the other direction more precisely
+	if ( NAV_TestBypass( self, AngleNormalize360( yaw + ( ( arcAngle * -1 ) * 0.5f ) ), blocked_dist, movedir ) )
+		return qtrue;
+
+	//Unable to go around
+	return qfalse;
+}
+
+/*
+-------------------------
+NAV_MoveBlocker
+-------------------------
+*/
+
+qboolean NAV_MoveBlocker( gentity_t *self, vec3_t shove_dir )
+{
+	//FIXME: This is a temporary method for making blockers move
+	
+	//FIXME: This will, of course, push blockers off of cliffs, into walls and all over the place
+
+	vec3_t	temp_dir, forward;
+
+	vectoangles( shove_dir, temp_dir );
+
+	temp_dir[YAW] += 45;
+	AngleVectors( temp_dir, forward, NULL, NULL );
+
+	VectorScale( forward, SHOVE_SPEED, self->client->ps.velocity );
+	self->client->ps.velocity[2] += SHOVE_LIFT;
+
+	//self->NPC->shoveDebounce = level.time + 100;
+
+	return qtrue;
+}
+
+/*
+-------------------------
+NAV_ResolveBlock
+-------------------------
+*/
+
+qboolean NAV_ResolveBlock( gentity_t *self, gentity_t *blocker, vec3_t blocked_dir )
+{
+	//Stop double waiting
+	if ( ( blocker->NPC ) && ( blocker->NPC->blockingEntNum == self->s.number ) )
+		return qtrue;
+
+	//For now, just complain about it
+	NPC_Blocked( self, blocker );
+	NPC_FaceEntity( blocker, qtrue );
+
+	return qfalse;
+}
+
+/*
+-------------------------
+NAV_TrueCollision
+-------------------------
+*/
+
+qboolean NAV_TrueCollision( gentity_t *self, gentity_t *blocker, vec3_t movedir, vec3_t blocked_dir )
+{
+	vec3_t	velocityDir;
+	float speed, dot;
+	vec3_t	testPos;
+	vec3_t	ptmins, ptmaxs, tmins, tmaxs;
+
+	//TODO: Handle all ents
+	if ( blocker->client == NULL )
+		return qfalse;
+
+	//Get the player's move direction and speed
+	speed = VectorNormalize2( self->client->ps.velocity, velocityDir );
+
+	//See if it's even feasible
+	dot = DotProduct( movedir, velocityDir );
+
+	if ( dot < 0.85 )
+		return qfalse;
+
+	VectorMA( self->r.currentOrigin, speed*FRAMETIME, velocityDir, testPos );
+
+	VectorAdd( blocker->r.currentOrigin, blocker->r.mins, tmins );
+	VectorAdd( blocker->r.currentOrigin, blocker->r.maxs, tmaxs );
+
+	VectorAdd( testPos, self->r.mins, ptmins );
+	VectorAdd( testPos, self->r.maxs, ptmaxs );
+
+	if ( G_BoundsOverlap( ptmins, ptmaxs, tmins, tmaxs ) )
+	{
+		VectorCopy( velocityDir, blocked_dir );
+		return qtrue;
+	}
+
+	return qfalse;
+}
+
+/*
+-------------------------
+NAV_StackedCanyon
+-------------------------
+*/
+
+qboolean NAV_StackedCanyon( gentity_t *self, gentity_t *blocker, vec3_t pathDir )
+{
+	vec3_t	perp, cross, test;
+	float	avoidRadius;
+	int		extraClip = CONTENTS_BOTCLIP;
+	trace_t	tr;
+
+	PerpendicularVector( perp, pathDir );
+	CrossProduct( pathDir, perp, cross );
+
+	avoidRadius =	sqrt( ( blocker->r.maxs[0] * blocker->r.maxs[0] ) + ( blocker->r.maxs[1] * blocker->r.maxs[1] ) ) + 
+					sqrt( ( self->r.maxs[0] * self->r.maxs[0] ) + ( self->r.maxs[1] * self->r.maxs[1] ) );
+
+	VectorMA( blocker->r.currentOrigin, avoidRadius, cross, test );
+
+	trap_Trace( &tr, test, self->r.mins, self->r.maxs, test, self->s.number, self->clipmask|extraClip );
+	if ( tr.startsolid&&(tr.contents&CONTENTS_BOTCLIP) )
+	{//started inside do not enter, so ignore them
+		extraClip &= ~CONTENTS_BOTCLIP;
+		trap_Trace( &tr, test, self->r.mins, self->r.maxs, test, self->s.number, self->clipmask|extraClip );
+	}
+
+	if ( NAVDEBUG_showCollision )
+	{
+		vec3_t	mins, maxs;
+		vec3_t	RED = { 1.0f, 0.0f, 0.0f };
+
+		VectorAdd( test, self->r.mins, mins );
+		VectorAdd( test, self->r.maxs, maxs );
+		G_Cube( mins, maxs, RED, 0.25 );
+	}
+
+	if ( tr.startsolid == qfalse && tr.allsolid == qfalse )
+		return qfalse;
+
+	VectorMA( blocker->r.currentOrigin, -avoidRadius, cross, test );
+
+	trap_Trace( &tr, test, self->r.mins, self->r.maxs, test, self->s.number, self->clipmask|extraClip );
+	if ( tr.startsolid&&(tr.contents&CONTENTS_BOTCLIP) )
+	{//started inside do not enter, so ignore them
+		extraClip &= ~CONTENTS_BOTCLIP;
+		trap_Trace( &tr, test, self->r.mins, self->r.maxs, test, self->s.number, self->clipmask|extraClip );
+	}
+
+	if ( tr.startsolid == qfalse && tr.allsolid == qfalse )
+		return qfalse;
+
+	if ( NAVDEBUG_showCollision )
+	{
+		vec3_t	mins, maxs;
+		vec3_t	RED = { 1.0f, 0.0f, 0.0f };
+
+		VectorAdd( test, self->r.mins, mins );
+		VectorAdd( test, self->r.maxs, maxs );
+		G_Cube( mins, maxs, RED, 0.25 );
+	}
+
+	return qtrue;
+}
+
+/*
+-------------------------
+NAV_ResolveEntityCollision
+-------------------------
+*/
+
+qboolean NAV_ResolveEntityCollision( gentity_t *self, gentity_t *blocker, vec3_t movedir, vec3_t pathDir )
+{
+	vec3_t	blocked_dir;
+	float blocked_dist;
+
+	//Doors are ignored
+	if ( G_EntIsUnlockedDoor( blocker->s.number ) )
+	//if ( Q_stricmp( blocker->classname, "func_door" ) == 0 )
+	{
+		if ( DistanceSquared( self->r.currentOrigin, blocker->r.currentOrigin ) > MIN_DOOR_BLOCK_DIST_SQR )
+			return qtrue;
+	}
+
+	VectorSubtract( blocker->r.currentOrigin, self->r.currentOrigin, blocked_dir );
+	blocked_dist = VectorNormalize( blocked_dir );
+
+	//Make sure an actual collision is going to happen
+//	if ( NAV_PredictCollision( self, blocker, movedir, blocked_dir ) == qfalse )
+//		return qtrue;
+	
+	//See if we can get around the blocker at all (only for player!)
+	if ( blocker->s.number == 0 )
+	{
+		if ( NAV_StackedCanyon( self, blocker, pathDir ) )
+		{
+			NPC_Blocked( self, blocker );
+			NPC_FaceEntity( blocker, qtrue );
+
+			return qfalse;
+		}
+	}
+
+	//First, attempt to walk around the blocker
+	if ( NAV_Bypass( self, blocker, blocked_dir, blocked_dist, movedir ) )
+		return qtrue;
+
+	//Second, attempt to calculate a good move position for the blocker
+	if ( NAV_ResolveBlock( self, blocker, blocked_dir ) )
+		return qtrue;
+
+	return qfalse;
+}
+
+/*
+-------------------------
+NAV_TestForBlocked
+-------------------------
+*/
+
+qboolean NAV_TestForBlocked( gentity_t *self, gentity_t *goal, gentity_t *blocker, float distance, int *flags )
+{
+	if ( goal == NULL )
+		return qfalse;
+
+	if ( blocker->s.eType == ET_ITEM )
+		return qfalse;
+
+	if ( NAV_HitNavGoal( blocker->r.currentOrigin, blocker->r.mins, blocker->r.maxs, goal->r.currentOrigin, 12, qfalse ) )
+	{
+		*flags |= NIF_BLOCKED;
+
+		if ( distance <= MIN_STOP_DIST )
+		{
+			NPC_Blocked( self, blocker );
+			NPC_FaceEntity( blocker, qtrue );
+			return qtrue;
+		}
+	}
+
+	return qfalse;
+}
+
+/*
+-------------------------
+NAV_AvoidCollsion
+-------------------------
+*/
+
+qboolean NAV_AvoidCollision( gentity_t *self, gentity_t *goal, navInfo_t *info )
+{
+	vec3_t	movedir;
+	vec3_t	movepos;
+
+	//Clear our block info for this frame
+	NAV_ClearBlockedInfo( NPC );
+
+	//Cap our distance
+	if ( info->distance > MAX_COLL_AVOID_DIST )
+	{
+		info->distance = MAX_COLL_AVOID_DIST;
+	}
+
+	//Get an end position
+	VectorMA( self->r.currentOrigin, info->distance, info->direction, movepos );
+	VectorCopy( info->direction, movedir );
+
+	//Now test against entities
+	if ( NAV_CheckAhead( self, movepos, &info->trace, CONTENTS_BODY ) == qfalse )
+	{
+		//Get the blocker
+		info->blocker = &g_entities[ info->trace.entityNum ];
+		info->flags |= NIF_COLLISION;
+
+		//Ok to hit our goal entity
+		if ( goal == info->blocker )
+			return qtrue;
+
+		//See if we're moving along with them
+		//if ( NAV_TrueCollision( self, info.blocker, movedir, info.direction ) == qfalse )
+		//	return qtrue;
+
+		//Test for blocking by standing on goal
+		if ( NAV_TestForBlocked( self, goal, info->blocker, info->distance, &info->flags ) == qtrue )
+			return qfalse;
+
+		//If the above function said we're blocked, don't do the extra checks
+		if ( info->flags & NIF_BLOCKED )
+			return qtrue;
+
+		//See if we can get that entity to move out of our way
+		if ( NAV_ResolveEntityCollision( self, info->blocker, movedir, info->pathDirection ) == qfalse )
+			return qfalse;
+
+		VectorCopy( movedir, info->direction );
+		
+		return qtrue;
+	}
+
+	//Our path is clear, just move there
+	if ( NAVDEBUG_showCollision )
+	{
+		G_DrawEdge( self->r.currentOrigin, movepos, EDGE_PATH );
+	}
+
+	return qtrue;
+}
+
+/*
+-------------------------
+NAV_TestBestNode
+-------------------------
+*/
+
+int NAV_TestBestNode( gentity_t *self, int startID, int endID, qboolean failEdge )
+{//check only against architectrure
+	vec3_t	end;
+	trace_t	trace;
+	vec3_t	mins;
+	int		clipmask = (NPC->clipmask&~CONTENTS_BODY)|CONTENTS_BOTCLIP;
+
+	//get the position for the test choice
+	trap_Nav_GetNodePosition( endID, end );
+
+	//Offset the step height
+	VectorSet( mins, self->r.mins[0], self->r.mins[1], self->r.mins[2] + STEPSIZE );
+	
+	trap_Trace( &trace, self->r.currentOrigin, mins, self->r.maxs, end, self->s.number, clipmask );
+
+	if ( trace.startsolid&&(trace.contents&CONTENTS_BOTCLIP) )
+	{//started inside do not enter, so ignore them
+		clipmask &= ~CONTENTS_BOTCLIP;
+		trap_Trace( &trace, self->r.currentOrigin, mins, self->r.maxs, end, self->s.number, clipmask );
+	}
+	//Do a simple check
+	if ( ( trace.allsolid == qfalse ) && ( trace.startsolid == qfalse ) && ( trace.fraction == 1.0f ) )
+	{//it's clear
+		return endID;
+	}
+
+	//See if we're too far above
+	if ( self->s.weapon != WP_SABER && fabs( self->r.currentOrigin[2] - end[2] ) > 48 )
+	{
+	}
+	else
+	{
+		//This is a work around
+		float	radius = ( self->r.maxs[0] > self->r.maxs[1] ) ? self->r.maxs[0] : self->r.maxs[1];
+		float	dist = Distance( self->r.currentOrigin, end );
+		float	tFrac = 1.0f - ( radius / dist );
+
+		if ( trace.fraction >= tFrac )
+		{//it's clear
+			return endID;
+		}
+	}
+
+	//Do a special check for doors
+	if ( trace.entityNum < ENTITYNUM_WORLD )
+	{
+		gentity_t	*blocker = &g_entities[trace.entityNum];
+		
+		if VALIDSTRING( blocker->classname )
+		{//special case: doors are architecture, but are dynamic, like entitites
+			if ( G_EntIsUnlockedDoor( blocker->s.number ) )
+			//if ( Q_stricmp( blocker->classname, "func_door" ) == 0 )
+			{//it's unlocked, go for it
+				//We're too close, try and avoid the door (most likely stuck on a lip)
+				if ( DistanceSquared( self->r.currentOrigin, trace.endpos ) < MIN_DOOR_BLOCK_DIST_SQR )
+				{
+					return startID;
+				}
+				//we can keep heading to the door, it should open
+				if ( self->s.weapon != WP_SABER && fabs( self->r.currentOrigin[2] - end[2] ) > 48 )
+				{//too far above
+				}
+				else
+				{
+					return endID;
+				}
+			}
+			else if ( G_EntIsDoor( blocker->s.number ) )
+			{//a locked door!
+				//path is blocked by a locked door, mark it as such if instructed to do so
+				if ( failEdge )
+				{
+					trap_Nav_AddFailedEdge( self->s.number, startID, endID );
+				}
+			}
+			else if ( G_EntIsBreakable( blocker->s.number ) )
+			{//do same for breakable brushes/models/glass?
+				//path is blocked by a breakable, mark it as such if instructed to do so
+				if ( failEdge )
+				{
+					trap_Nav_AddFailedEdge( self->s.number, startID, endID );
+				}
+			}
+			else if ( G_EntIsRemovableUsable( blocker->s.number ) )
+			{//and removable usables
+				//path is blocked by a removable usable, mark it as such if instructed to do so
+				if ( failEdge )
+				{
+					trap_Nav_AddFailedEdge( self->s.number, startID, endID );
+				}
+			}
+			else if ( blocker->targetname && blocker->s.solid == SOLID_BMODEL && ((blocker->r.contents&CONTENTS_MONSTERCLIP)|| (blocker->r.contents&CONTENTS_BOTCLIP)) )
+			{//some other kind of do not enter entity brush that will probably be removed
+				//path is blocked by a removable brushent, mark it as such if instructed to do so
+				if ( failEdge )
+				{
+					trap_Nav_AddFailedEdge( self->s.number, startID, endID );
+				}
+			}
+		}
+	}
+	//path is blocked 
+	//use the fallback choice
+	return startID;
+}
+
+/*
+-------------------------
+NAV_GetNearestNode
+-------------------------
+*/
+
+int NAV_GetNearestNode( gentity_t *self, int lastNode )
+{
+	return trap_Nav_GetNearestNode( self, lastNode, NF_CLEAR_PATH, WAYPOINT_NONE );
+}
+
+/*
+-------------------------
+NAV_MicroError
+-------------------------
+*/
+
+qboolean NAV_MicroError( vec3_t start, vec3_t end )
+{
+	if ( VectorCompare( start, end ) )
+	{
+		if ( DistanceSquared( NPC->r.currentOrigin, start ) < (8*8) )
+		{
+			return qtrue;
+		}
+	}
+
+	return qfalse;
+}
+
+/*
+-------------------------
+NAV_MoveToGoal
+-------------------------
+*/
+
+int	NAV_MoveToGoal( gentity_t *self, navInfo_t *info )
+{
+	int bestNode;
+	vec3_t	origin, end;
+
+	//Must have a goal entity to move there
+	if( self->NPC->goalEntity == NULL )
+		return WAYPOINT_NONE;
+
+	//Check special player optimizations
+	if ( self->NPC->goalEntity->s.number == 0 )
+	{
+		//If we couldn't find the point, then we won't be able to this turn
+		if ( self->NPC->goalEntity->waypoint == WAYPOINT_NONE )
+			return WAYPOINT_NONE;
+
+		//NOTENOTE: Otherwise trust this waypoint for the whole frame (reduce all unnecessary calculations)
+	}
+	else
+	{
+		//Find the target's waypoint
+		if ( ( self->NPC->goalEntity->waypoint = NAV_GetNearestNode( self->NPC->goalEntity, self->NPC->goalEntity->waypoint ) ) == WAYPOINT_NONE )
+			return WAYPOINT_NONE;
+	}
+
+	//Find our waypoint
+	if ( ( self->waypoint = NAV_GetNearestNode( self, self->lastWaypoint ) ) == WAYPOINT_NONE )
+		return WAYPOINT_NONE;
+
+	bestNode = trap_Nav_GetBestNode( self->waypoint, self->NPC->goalEntity->waypoint, NODE_NONE );
+
+	if ( bestNode == WAYPOINT_NONE )
+	{
+		if ( NAVDEBUG_showEnemyPath )
+		{
+			vec3_t	origin, torigin;
+
+			trap_Nav_GetNodePosition( self->NPC->goalEntity->waypoint, torigin );
+			trap_Nav_GetNodePosition( self->waypoint, origin );
+
+			G_DrawNode( torigin, NODE_GOAL );
+			G_DrawNode( origin, NODE_GOAL );
+			G_DrawNode( self->NPC->goalEntity->r.currentOrigin, NODE_START );
+		}
+		
+		return WAYPOINT_NONE;
+	}
+
+	//Check this node
+	bestNode = NAV_TestBestNode( self, bestNode, self->NPC->goalEntity->waypoint, qfalse );
+
+	//trace_t	trace;
+
+	//Get this position
+	trap_Nav_GetNodePosition( bestNode, origin );
+	trap_Nav_GetNodePosition( self->waypoint, end );
+
+	//Basically, see if the path we have isn't helping
+	//if ( NAV_MicroError( origin, end ) )
+	//	return WAYPOINT_NONE;
+
+	//Test the path connection from our current position to the best node
+	if ( NAV_CheckAhead( self, origin, &info->trace, (self->clipmask&~CONTENTS_BODY)|CONTENTS_BOTCLIP ) == qfalse )
+	{
+		//First attempt to move to the closest point on the line between the waypoints
+		G_FindClosestPointOnLineSegment( origin, end, self->r.currentOrigin, origin );
+
+		//See if we can go there
+		if ( NAV_CheckAhead( self, origin, &info->trace, (self->clipmask&~CONTENTS_BODY)|CONTENTS_BOTCLIP ) == qfalse )
+		{
+			//Just move towards our current waypoint
+			bestNode = self->waypoint;
+			trap_Nav_GetNodePosition( bestNode, origin );
+		}
+	}
+
+	//Setup our new move information
+	VectorSubtract( origin, self->r.currentOrigin, info->direction );
+	info->distance = VectorNormalize( info->direction );
+
+	VectorSubtract( end, origin, info->pathDirection );
+	VectorNormalize( info->pathDirection );
+
+	//Draw any debug info, if requested
+	if ( NAVDEBUG_showEnemyPath )
+	{
+		vec3_t	dest, start;
+
+		//Get the positions
+		trap_Nav_GetNodePosition( self->NPC->goalEntity->waypoint, dest );
+		trap_Nav_GetNodePosition( bestNode, start );
+
+		//Draw the route
+		G_DrawNode( start, NODE_START );
+		G_DrawNode( dest, NODE_GOAL );
+		trap_Nav_ShowPath( self->waypoint, self->NPC->goalEntity->waypoint );
+	}
+
+	return bestNode;
+}
+
+/*
+-------------------------
+waypoint_testDirection
+-------------------------
+*/
+
+unsigned int waypoint_testDirection( vec3_t origin, float yaw, unsigned int minDist )
+{
+	vec3_t	trace_dir, test_pos;
+	vec3_t	maxs, mins;
+	vec3_t	angles;
+	trace_t	tr;
+
+	//Setup the mins and max
+	VectorSet( maxs, 15, 15, DEFAULT_MAXS_2 );
+	VectorSet( mins, -15, -15, DEFAULT_MINS_2 + STEPSIZE );
+
+	//Get our test direction
+	VectorSet(angles, 0, yaw, 0 );
+	AngleVectors( angles, trace_dir, NULL, NULL );
+
+	//Move ahead
+//	VectorMA( origin, MAX_RADIUS_CHECK, trace_dir, test_pos );
+	VectorMA( origin, minDist, trace_dir, test_pos );
+
+	trap_Trace( &tr, origin, mins, maxs, test_pos, ENTITYNUM_NONE, ( CONTENTS_SOLID | CONTENTS_MONSTERCLIP | CONTENTS_BOTCLIP ) );
+
+	//return (unsigned int) ( (float) MAX_RADIUS_CHECK * tr.fraction );
+	return (unsigned int) ( (float) minDist * tr.fraction );
+}
+
+/*
+-------------------------
+waypoint_getRadius
+-------------------------
+*/
+
+unsigned int waypoint_getRadius( gentity_t *ent )
+{
+	unsigned int	minDist = MAX_RADIUS_CHECK + 1; // (unsigned int) -1;
+	unsigned int	dist;
+	int				i;
+
+	for ( i = 0; i < YAW_ITERATIONS; i++ )
+	{
+		dist = waypoint_testDirection( ent->r.currentOrigin, ((360.0f/YAW_ITERATIONS) * i), minDist );
+
+		if ( dist < minDist )
+			minDist = dist;
+	}
+
+	return minDist;
+}
+
+/*QUAKED waypoint  (0.7 0.7 0) (-16 -16 -24) (16 16 32) SOLID_OK
+a place to go.
+
+SOLID_OK - only use if placing inside solid is unavoidable in map, but may be clear in-game (ie: at the bottom of a tall, solid lift that starts at the top position)
+
+radius is automatically calculated in-world.
+*/
+void SP_waypoint ( gentity_t *ent )
+{
+	if ( navCalculatePaths )
+	{
+		unsigned int radius;
+
+		VectorSet(ent->r.mins, -15, -15, DEFAULT_MINS_2);
+		VectorSet(ent->r.maxs, 15, 15, DEFAULT_MAXS_2);
+		
+		ent->r.contents = CONTENTS_TRIGGER;
+		ent->clipmask = MASK_DEADSOLID;
+
+		trap_LinkEntity( ent );
+
+		ent->count = -1;
+		ent->classname = "waypoint";
+
+		if( !(ent->spawnflags&1) && G_CheckInSolid (ent, qtrue))
+		{//if not SOLID_OK, and in solid
+			ent->r.maxs[2] = CROUCH_MAXS_2;
+			if(G_CheckInSolid (ent, qtrue))
+			{
+				Com_Printf(S_COLOR_RED"ERROR: Waypoint %s at %s in solid!\n", ent->targetname, vtos(ent->r.currentOrigin));
+				assert(0 && "Waypoint in solid!");
+				G_FreeEntity(ent);
+				return;
+			}
+		}
+
+		radius = waypoint_getRadius( ent );
+
+		ent->health = trap_Nav_AddRawPoint( ent->r.currentOrigin, ent->spawnflags, radius );
+		NAV_StoreWaypoint( ent );
+		G_FreeEntity(ent);
+		return;
+	}
+
+	G_FreeEntity(ent);
+}
+
+/*QUAKED waypoint_small  (0.7 0.7 0) (-2 -2 -24) (2 2 32) SOLID_OK
+SOLID_OK - only use if placing inside solid is unavoidable in map, but may be clear in-game (ie: at the bottom of a tall, solid lift that starts at the top position)
+*/
+void SP_waypoint_small (gentity_t *ent)
+{
+	if ( navCalculatePaths )
+	{
+		VectorSet(ent->r.mins, -2, -2, DEFAULT_MINS_2);
+		VectorSet(ent->r.maxs, 2, 2, DEFAULT_MAXS_2);
+
+		ent->r.contents = CONTENTS_TRIGGER;
+		ent->clipmask = MASK_DEADSOLID;
+
+		trap_LinkEntity( ent );
+
+		ent->count = -1;
+		ent->classname = "waypoint";
+
+		if ( !(ent->spawnflags&1) && G_CheckInSolid( ent, qtrue ) )
+		{
+			ent->r.maxs[2] = CROUCH_MAXS_2;
+			if ( G_CheckInSolid( ent, qtrue ) )
+			{
+				Com_Printf(S_COLOR_RED"ERROR: Waypoint_small %s at %s in solid!\n", ent->targetname, vtos(ent->r.currentOrigin));
+				assert(0);
+				G_FreeEntity(ent);
+				return;
+			}
+		}
+
+		ent->health = trap_Nav_AddRawPoint( ent->r.currentOrigin, ent->spawnflags, 2 );
+		NAV_StoreWaypoint( ent );
+		G_FreeEntity(ent);
+		return;
+	}
+
+	G_FreeEntity(ent);
+}
+
+
+/*QUAKED waypoint_navgoal (0.3 1 0.3) (-16 -16 -24) (16 16 32) SOLID_OK
+A waypoint for script navgoals
+Not included in navigation data
+
+SOLID_OK - only use if placing inside solid is unavoidable in map, but may be clear in-game (ie: at the bottom of a tall, solid lift that starts at the top position)
+
+targetname - name you would use in script when setting a navgoal (like so:)
+
+  For example: if you give this waypoint a targetname of "console", make an NPC go to it in a script like so:
+
+  set ("navgoal", "console");
+
+radius - how far from the navgoal an ent can be before it thinks it reached it - default is "0" which means no radius check, just have to touch it
+*/
+
+void SP_waypoint_navgoal( gentity_t *ent )
+{
+	int radius = ( ent->radius ) ? (((int)ent->radius)|NAVGOAL_USE_RADIUS) : 12;
+
+	VectorSet( ent->r.mins, -16, -16, -24 );
+	VectorSet( ent->r.maxs, 16, 16, 32 );
+	ent->s.origin[2] += 0.125;
+	if ( !(ent->spawnflags&1) && G_CheckInSolid( ent, qfalse ) )
+	{
+		Com_Printf(S_COLOR_RED"ERROR: Waypoint_navgoal %s at %s in solid!\n", ent->targetname, vtos(ent->r.currentOrigin));
+		assert(0);
+	}
+	TAG_Add( ent->targetname, NULL, ent->s.origin, ent->s.angles, radius, RTF_NAVGOAL );
+
+	ent->classname = "navgoal";
+	G_FreeEntity( ent );//can't do this, they need to be found later by some functions, though those could be fixed, maybe?
+}
+
+/*QUAKED waypoint_navgoal_8 (0.3 1 0.3) (-8 -8 -24) (8 8 32) SOLID_OK
+A waypoint for script navgoals, 8 x 8 size
+Not included in navigation data
+
+SOLID_OK - only use if placing inside solid is unavoidable in map, but may be clear in-game (ie: at the bottom of a tall, solid lift that starts at the top position)
+
+targetname - name you would use in script when setting a navgoal (like so:)
+
+  For example: if you give this waypoint a targetname of "console", make an NPC go to it in a script like so:
+
+  set ("navgoal", "console");
+
+You CANNOT set a radius on these navgoals, they are touch-reach ONLY
+*/
+void SP_waypoint_navgoal_8( gentity_t *ent )
+{
+	VectorSet( ent->r.mins, -8, -8, -24 );
+	VectorSet( ent->r.maxs, 8, 8, 32 );
+	ent->s.origin[2] += 0.125;
+	if ( !(ent->spawnflags&1) && G_CheckInSolid( ent, qfalse ) )
+	{
+		Com_Printf(S_COLOR_RED"ERROR: Waypoint_navgoal_8 %s at %s in solid!\n", ent->targetname, vtos(ent->r.currentOrigin));
+		assert(0);
+	}
+
+	TAG_Add( ent->targetname, NULL, ent->s.origin, ent->s.angles, 8, RTF_NAVGOAL );
+
+	ent->classname = "navgoal";
+	G_FreeEntity( ent );//can't do this, they need to be found later by some functions, though those could be fixed, maybe?
+}
+
+/*QUAKED waypoint_navgoal_4 (0.3 1 0.3) (-4 -4 -24) (4 4 32) SOLID_OK
+A waypoint for script navgoals, 4 x 4 size
+Not included in navigation data
+
+SOLID_OK - only use if placing inside solid is unavoidable in map, but may be clear in-game (ie: at the bottom of a tall, solid lift that starts at the top position)
+
+targetname - name you would use in script when setting a navgoal (like so:)
+
+  For example: if you give this waypoint a targetname of "console", make an NPC go to it in a script like so:
+
+  set ("navgoal", "console");
+
+You CANNOT set a radius on these navgoals, they are touch-reach ONLY
+*/
+void SP_waypoint_navgoal_4( gentity_t *ent )
+{
+	VectorSet( ent->r.mins, -4, -4, -24 );
+	VectorSet( ent->r.maxs, 4, 4, 32 );
+	ent->s.origin[2] += 0.125;
+	if ( !(ent->spawnflags&1) && G_CheckInSolid( ent, qfalse ) )
+	{
+		Com_Printf(S_COLOR_RED"ERROR: Waypoint_navgoal_4 %s at %s in solid!\n", ent->targetname, vtos(ent->r.currentOrigin));
+		assert(0);
+	}
+
+	TAG_Add( ent->targetname, NULL, ent->s.origin, ent->s.angles, 4, RTF_NAVGOAL );
+
+	ent->classname = "navgoal";
+	G_FreeEntity( ent );//can't do this, they need to be found later by some functions, though those could be fixed, maybe?
+}
+
+/*QUAKED waypoint_navgoal_2 (0.3 1 0.3) (-2 -2 -24) (2 2 32) SOLID_OK
+A waypoint for script navgoals, 2 x 2 size
+Not included in navigation data
+
+SOLID_OK - only use if placing inside solid is unavoidable in map, but may be clear in-game (ie: at the bottom of a tall, solid lift that starts at the top position)
+
+targetname - name you would use in script when setting a navgoal (like so:)
+
+  For example: if you give this waypoint a targetname of "console", make an NPC go to it in a script like so:
+
+  set ("navgoal", "console");
+
+You CANNOT set a radius on these navgoals, they are touch-reach ONLY
+*/
+void SP_waypoint_navgoal_2( gentity_t *ent )
+{	
+	VectorSet( ent->r.mins, -2, -2, -24 );
+	VectorSet( ent->r.maxs, 2, 2, 32 );
+	ent->s.origin[2] += 0.125;
+	if ( !(ent->spawnflags&1) && G_CheckInSolid( ent, qfalse ) )
+	{
+		Com_Printf(S_COLOR_RED"ERROR: Waypoint_navgoal_2 %s at %s in solid!\n", ent->targetname, vtos(ent->r.currentOrigin));
+		assert(0);
+	}
+
+	TAG_Add( ent->targetname, NULL, ent->s.origin, ent->s.angles, 2, RTF_NAVGOAL );
+
+	ent->classname = "navgoal";
+	G_FreeEntity( ent );//can't do this, they need to be found later by some functions, though those could be fixed, maybe?
+}
+
+/*QUAKED waypoint_navgoal_1 (0.3 1 0.3) (-1 -1 -24) (1 1 32) SOLID_OK
+A waypoint for script navgoals, 1 x 1 size
+Not included in navigation data
+
+SOLID_OK - only use if placing inside solid is unavoidable in map, but may be clear in-game (ie: at the bottom of a tall, solid lift that starts at the top position)
+
+targetname - name you would use in script when setting a navgoal (like so:)
+
+  For example: if you give this waypoint a targetname of "console", make an NPC go to it in a script like so:
+
+  set ("navgoal", "console");
+
+You CANNOT set a radius on these navgoals, they are touch-reach ONLY
+*/
+void SP_waypoint_navgoal_1( gentity_t *ent )
+{
+	VectorSet( ent->r.mins, -1, -1, -24 );
+	VectorSet( ent->r.maxs, 1, 1, 32 );
+	ent->s.origin[2] += 0.125;
+	if ( !(ent->spawnflags&1) && G_CheckInSolid( ent, qfalse ) )
+	{
+		Com_Printf(S_COLOR_RED"ERROR: Waypoint_navgoal_1 %s at %s in solid!\n", ent->targetname, vtos(ent->r.currentOrigin));
+		assert(0);
+	}
+
+	TAG_Add( ent->targetname, NULL, ent->s.origin, ent->s.angles, 1, RTF_NAVGOAL );
+
+	ent->classname = "navgoal";
+	G_FreeEntity( ent );//can't do this, they need to be found later by some functions, though those could be fixed, maybe?
+}
+
+/*
+-------------------------
+Svcmd_Nav_f
+-------------------------
+*/
+
+void Svcmd_Nav_f( void )
+{
+	char cmd[1024];
+	trap_Argv( 1, cmd, 1024 );
+
+	if ( Q_stricmp( cmd, "show" ) == 0 )
+	{
+		trap_Argv(2, cmd, 1024);
+
+		if ( Q_stricmp( cmd, "all" ) == 0 )
+		{
+			NAVDEBUG_showNodes = !NAVDEBUG_showNodes;
+			
+			//NOTENOTE: This causes the two states to sync up if they aren't already
+			NAVDEBUG_showCollision = NAVDEBUG_showNavGoals = 
+			NAVDEBUG_showCombatPoints = NAVDEBUG_showEnemyPath = 
+			NAVDEBUG_showEdges = NAVDEBUG_showRadius = NAVDEBUG_showNodes;		
+		}
+		else if ( Q_stricmp( cmd, "nodes" ) == 0 )
+		{
+			NAVDEBUG_showNodes = !NAVDEBUG_showNodes;
+		}
+		else if ( Q_stricmp( cmd, "radius" ) == 0 )
+		{
+			NAVDEBUG_showRadius = !NAVDEBUG_showRadius;
+		}
+		else if ( Q_stricmp( cmd, "edges" ) == 0 )
+		{
+			NAVDEBUG_showEdges = !NAVDEBUG_showEdges;
+		}
+		else if ( Q_stricmp( cmd, "testpath" ) == 0 )
+		{
+			NAVDEBUG_showTestPath = !NAVDEBUG_showTestPath;
+		}
+		else if ( Q_stricmp( cmd, "enemypath" ) == 0 )
+		{
+			NAVDEBUG_showEnemyPath = !NAVDEBUG_showEnemyPath;
+		}
+		else if ( Q_stricmp( cmd, "combatpoints" ) == 0 )
+		{
+			NAVDEBUG_showCombatPoints = !NAVDEBUG_showCombatPoints;
+		}
+		else if ( Q_stricmp( cmd, "navgoals" ) == 0 )
+		{
+			NAVDEBUG_showNavGoals = !NAVDEBUG_showNavGoals;
+		}
+		else if ( Q_stricmp( cmd, "collision" ) == 0 )
+		{
+			NAVDEBUG_showCollision = !NAVDEBUG_showCollision;
+		}
+	}
+	else if ( Q_stricmp( cmd, "set" ) == 0 )
+	{
+		trap_Argv( 2, cmd, 1024 );
+
+		if ( Q_stricmp( cmd, "testgoal" ) == 0 )
+		{
+			NAVDEBUG_curGoal = trap_Nav_GetNearestNode( &g_entities[0], g_entities[0].waypoint, NF_CLEAR_PATH, WAYPOINT_NONE );
+		}
+	}
+	else if ( Q_stricmp( cmd, "totals" ) == 0 )
+	{
+		Com_Printf("Navigation Totals:\n");
+		Com_Printf("------------------\n");
+		Com_Printf("Total Nodes:         %d\n", trap_Nav_GetNumNodes() );
+		Com_Printf("Total Combat Points: %d\n", level.numCombatPoints );
+	}
+	else
+	{
+		//Print the available commands
+		Com_Printf("nav - valid commands\n---\n" );
+		Com_Printf("show\n - nodes\n - edges\n - testpath\n - enemypath\n - combatpoints\n - navgoals\n---\n");
+		Com_Printf("set\n - testgoal\n---\n" );
+	}
+}
+
+//
+//JWEIER ADDITIONS START
+
+qboolean	navCalculatePaths	= qfalse;
+
+qboolean	NAVDEBUG_showNodes			= qfalse;
+qboolean	NAVDEBUG_showRadius			= qfalse;
+qboolean	NAVDEBUG_showEdges			= qfalse;
+qboolean	NAVDEBUG_showTestPath		= qfalse;
+qboolean	NAVDEBUG_showEnemyPath		= qfalse;
+qboolean	NAVDEBUG_showCombatPoints	= qfalse;
+qboolean	NAVDEBUG_showNavGoals		= qfalse;
+qboolean	NAVDEBUG_showCollision		= qfalse;
+int		NAVDEBUG_curGoal			= 0;
+
+/*
+-------------------------
+NAV_CalculatePaths
+-------------------------
+*/
+#ifndef FINAL_BUILD
+int fatalErrors = 0;
+char *fatalErrorPointer = NULL;
+char	fatalErrorString[4096];
+qboolean NAV_WaypointsTooFar( gentity_t *wp1, gentity_t *wp2 )
+{
+	if ( Distance( wp1->r.currentOrigin, wp2->r.currentOrigin ) > 1024 )
+	{
+		char	temp[1024];
+		int		len;
+		fatalErrors++;
+		if ( !wp1->targetname && !wp2->targetname )
+		{
+			Com_sprintf( temp, sizeof(temp), S_COLOR_RED"Waypoint conn %s->%s > 1024\n", vtos( wp1->r.currentOrigin ), vtos( wp2->r.currentOrigin ) );
+		}
+		else if ( !wp1->targetname )
+		{
+			Com_sprintf( temp, sizeof(temp), S_COLOR_RED"Waypoint conn %s->%s > 1024\n", vtos( wp1->r.currentOrigin ), wp2->targetname );
+		}
+		else if ( !wp2->targetname )
+		{
+			Com_sprintf( temp, sizeof(temp), S_COLOR_RED"Waypoint conn %s->%s > 1024\n", wp1->targetname, vtos( wp2->r.currentOrigin ) );
+		}
+		else
+		{//they both have valid targetnames
+			Com_sprintf( temp, sizeof(temp), S_COLOR_RED"Waypoint conn %s->%s > 1024\n", wp1->targetname, wp2->targetname );
+		}
+		len = strlen( temp );
+		if ( (fatalErrorPointer-fatalErrorString)+len >= sizeof( fatalErrorString ) )
+		{
+			Com_Error( ERR_DROP, "%s%s%dTOO MANY FATAL NAV ERRORS!!!\n", fatalErrorString, temp, fatalErrors );
+			return qtrue;
+		}
+		strcat( fatalErrorPointer, temp );
+		fatalErrorPointer += len;
+		return qtrue;
+	}
+	else
+	{
+		return qfalse;
+	}
+}
+#endif
+
+static int numStoredWaypoints = 0;
+//static waypointData_t *tempWaypointList=0;
+static waypointData_t tempWaypointList[MAX_STORED_WAYPOINTS]; //rwwFIXMEFIXME: Need.. dynamic.. memory
+
+
+void NAV_ClearStoredWaypoints(void)
+{
+	numStoredWaypoints = 0;
+}
+
+
+void NAV_StoreWaypoint( gentity_t *ent )
+{
+	/*
+	if ( !tempWaypointList )
+	{
+		//tempWaypointList = (waypointData_t *) gi.Malloc(sizeof(waypointData_t)*MAX_STORED_WAYPOINTS, TAG_TEMP_WORKSPACE, qtrue);
+
+		int size = sizeof(waypointData_t)*MAX_STORED_WAYPOINTS;
+		trap_TrueMalloc((void **)&tempWaypointList, size);
+		memset(tempWaypointList, 0, size);
+	}
+	*/
+
+	if ( numStoredWaypoints >= MAX_STORED_WAYPOINTS )
+	{
+		//G_Error( "Too many waypoints!  (%d > %d)\n", numStoredWaypoints, MAX_STORED_WAYPOINTS );
+		//rwwFIXMEFIXME: commented this out so I can load some of the SP levels.
+		return;
+	}
+	if ( ent->targetname )
+	{
+		Q_strncpyz( tempWaypointList[numStoredWaypoints].targetname, ent->targetname, MAX_QPATH );
+	}
+	if ( ent->target )
+	{
+		Q_strncpyz( tempWaypointList[numStoredWaypoints].target, ent->target, MAX_QPATH );
+	}
+	if ( ent->target2 )
+	{
+		Q_strncpyz( tempWaypointList[numStoredWaypoints].target2, ent->target2, MAX_QPATH );
+	}
+	if ( ent->target3 )
+	{
+		Q_strncpyz( tempWaypointList[numStoredWaypoints].target3, ent->target3, MAX_QPATH );
+	}
+	if ( ent->target4 )
+	{
+		Q_strncpyz( tempWaypointList[numStoredWaypoints].target4, ent->target4, MAX_QPATH );
+	}
+	tempWaypointList[numStoredWaypoints].nodeID = ent->health;
+
+	numStoredWaypoints++;
+}
+
+int NAV_GetStoredWaypoint( char *targetname )
+{
+	int i;
+
+	if ( !tempWaypointList || !targetname || !targetname[0] )
+	{
+		return -1;
+	}
+	for ( i = 0; i < numStoredWaypoints; i++ )
+	{
+		if ( tempWaypointList[i].targetname[0] )
+		{
+			if ( !Q_stricmp( targetname, tempWaypointList[i].targetname ) )
+			{
+				return i;
+			}
+		}
+	}
+	return -1;
+}
+
+void NAV_CalculatePaths( const char *filename, int checksum )
+{
+	int target = -1;
+	int i;
+
+	if ( !tempWaypointList )
+	{
+		return;
+	}
+#ifndef FINAL_BUILD
+	fatalErrors = 0;
+	memset( fatalErrorString, 0, sizeof( fatalErrorString ) );
+	fatalErrorPointer = &fatalErrorString[0];
+#endif
+#if _HARD_CONNECT
+
+	//Find all connections and hard connect them
+	for ( i = 0; i < numStoredWaypoints; i++ )
+	{
+		//Find the first connection
+		target = NAV_GetStoredWaypoint( tempWaypointList[i].target );
+
+		if ( target != -1 )
+		{
+#ifndef FINAL_BUILD
+//			if ( !NAV_WaypointsTooFar( ent, target ) )
+#endif
+			{
+				trap_Nav_HardConnect( tempWaypointList[i].nodeID, tempWaypointList[target].nodeID );
+			}
+		}
+
+		//Find a possible second connection
+		target = NAV_GetStoredWaypoint( tempWaypointList[i].target2 );
+
+		if ( target != -1 )
+		{
+#ifndef FINAL_BUILD
+//			if ( !NAV_WaypointsTooFar( ent, target ) )
+#endif
+			{
+				trap_Nav_HardConnect( tempWaypointList[i].nodeID, tempWaypointList[target].nodeID );
+			}
+		}
+
+		//Find a possible third connection
+		target = NAV_GetStoredWaypoint( tempWaypointList[i].target3 );
+
+		if ( target != -1 )
+		{
+#ifndef FINAL_BUILD
+//			if ( !NAV_WaypointsTooFar( ent, target ) )
+#endif
+			{
+				trap_Nav_HardConnect( tempWaypointList[i].nodeID, tempWaypointList[target].nodeID );
+			}
+		}
+
+		//Find a possible fourth connection
+		target = NAV_GetStoredWaypoint( tempWaypointList[i].target4 );
+
+		if ( target != -1 )
+		{
+#ifndef FINAL_BUILD
+//			if ( !NAV_WaypointsTooFar( ent, target ) )
+#endif
+			{
+				trap_Nav_HardConnect( tempWaypointList[i].nodeID, tempWaypointList[target].nodeID );
+			}
+		}
+	}
+
+#endif
+
+	//Remove all waypoints now that they're done
+	//gi.Free(tempWaypointList);
+	/*
+	trap_TrueFree((void **)&tempWaypointList);
+	tempWaypointList=0;
+	*/
+
+	//Now check all blocked edges, mark failed ones
+	trap_Nav_CheckBlockedEdges();
+
+	trap_Nav_SetPathsCalculated(qfalse);
+	//navigator.pathsCalculated = qfalse;
+
+	//Calculate the paths based on the supplied waypoints
+	//trap_Nav_CalculatePaths();
+
+	//Save the resulting information
+	/*
+	if ( trap_Nav_Save( filename, checksum ) == qfalse )
+	{
+		Com_Printf("Unable to save navigations data for map \"%s\" (checksum:%d)\n", filename, checksum );
+	}
+	*/
+#ifndef FINAL_BUILD
+	if ( fatalErrors )
+	{
+		//Com_Error( ERR_DROP, "%s%d FATAL NAV ERRORS\n", fatalErrorString, fatalErrors );
+		Com_Printf( "%s%d FATAL NAV ERRORS\n", fatalErrorString, fatalErrors );
+	}
+#endif
+}
+
+/*
+-------------------------
+NAV_Shutdown
+-------------------------
+*/
+
+void NAV_Shutdown( void )
+{
+	trap_Nav_Free();
+}
+
+/*
+-------------------------
+NAV_ShowDebugInfo
+-------------------------
+*/
+
+void NAV_ShowDebugInfo( void )
+{
+	int i;
+
+	if ( NAVDEBUG_showNodes )
+	{
+		trap_Nav_ShowNodes();
+	}
+
+	if ( NAVDEBUG_showEdges )
+	{
+		trap_Nav_ShowEdges();
+	}
+
+	if ( NAVDEBUG_showTestPath )
+	{
+		//Get the nearest node to the player
+		int	nearestNode = trap_Nav_GetNearestNode( &g_entities[0], g_entities[0].waypoint, NF_ANY, WAYPOINT_NONE );
+		int	testNode = trap_Nav_GetBestNode( nearestNode, NAVDEBUG_curGoal, NODE_NONE );
+		vec3_t	dest, start;
+		
+		nearestNode = NAV_TestBestNode( &g_entities[0], nearestNode, testNode, qfalse );
+
+		//Show the connection
+
+		//Get the positions
+		trap_Nav_GetNodePosition( NAVDEBUG_curGoal, dest );
+		trap_Nav_GetNodePosition( nearestNode, start );
+
+		G_DrawNode( start, NODE_START );
+		G_DrawNode( dest, NODE_GOAL );
+		trap_Nav_ShowPath( nearestNode, NAVDEBUG_curGoal );
+	}
+
+	if ( NAVDEBUG_showCombatPoints )
+	{
+		for ( i = 0; i < level.numCombatPoints; i++ )
+		{
+			G_DrawCombatPoint( level.combatPoints[i].origin, 0 );
+		}
+	}
+
+	if ( NAVDEBUG_showNavGoals )
+	{
+		TAG_ShowTags( RTF_NAVGOAL );
+	}
+}
+
+/*
+-------------------------
+NAV_FindPlayerWaypoint
+-------------------------
+*/
+
+void NAV_FindPlayerWaypoint( int clNum )
+{
+	g_entities[clNum].waypoint = trap_Nav_GetNearestNode( &g_entities[clNum], g_entities[clNum].lastWaypoint, NF_CLEAR_PATH, WAYPOINT_NONE );
+}
+
+//
+//JWEIER ADDITIONS END
diff --git a/codemp/game/g_nav.h b/codemp/game/g_nav.h
new file mode 100644
index 0000000..29b696d
--- /dev/null
+++ b/codemp/game/g_nav.h
@@ -0,0 +1,78 @@
+#ifndef __G_NAV_H__
+#define __G_NAV_H__
+
+//This file is shared by the exe nav code.
+//If you modify it without recompiling the exe with new code, there could be issues.
+
+#define	WAYPOINT_NONE	-1
+
+#define MAX_STORED_WAYPOINTS	512//???
+#define MAX_WAYPOINT_REACHED_DIST_SQUARED	1024	//32 squared
+#define	MAX_COLL_AVOID_DIST					128
+#define	NAVGOAL_USE_RADIUS					16384	//Used to force the waypoint_navgoals with a manually set radius to actually do a DistanceSquared check, not just bounds overlap
+
+#define	MIN_STOP_DIST 64
+#define	MIN_BLOCKED_SPEECH_TIME	4000
+#define	MIN_DOOR_BLOCK_DIST			16
+#define	MIN_DOOR_BLOCK_DIST_SQR		( MIN_DOOR_BLOCK_DIST * MIN_DOOR_BLOCK_DIST )
+#define	SHOVE_SPEED	200
+#define SHOVE_LIFT	10
+#define	MAX_RADIUS_CHECK	1024
+#define	YAW_ITERATIONS	16
+
+// This is probably wrong - VVFIXME
+// Some kind of wacky code sharing going on here, but we need these things
+// in g_navnew.c -- which is now C++ code in the GAME on Xbox, so the
+// original test fails.
+#if !defined(__cplusplus) || (defined(_XBOX) && defined(QAGAME)) || (defined(__linux__) && defined(QAGAME))
+//rww - Rest of defines here are also shared in exe, do not modify.
+#define	__NEWCOLLECT	1
+
+#define _HARD_CONNECT	1
+
+//Node flags
+#define	NF_ANY			0
+//#define	NF_CLEAR_LOS	0x00000001
+#define NF_CLEAR_PATH	0x00000002
+#define NF_RECALC		0x00000004
+
+//Edge flags
+#define	EFLAG_NONE		0
+#define EFLAG_BLOCKED	0x00000001
+#define EFLAG_FAILED	0x00000002
+
+//Miscellaneous defines
+#define	NODE_NONE		-1
+#define	NAV_HEADER_ID	'JNV5'
+#define	NODE_HEADER_ID	'NODE'
+
+//this stuff is local and can be modified, don't even show it to the engine.
+extern	qboolean navCalculatePaths;
+
+extern	qboolean NAVDEBUG_showNodes;
+extern	qboolean NAVDEBUG_showRadius;
+extern	qboolean NAVDEBUG_showEdges;
+extern	qboolean NAVDEBUG_showTestPath;
+extern	qboolean NAVDEBUG_showEnemyPath;
+extern	qboolean NAVDEBUG_showCombatPoints;
+extern	qboolean NAVDEBUG_showNavGoals;
+extern	qboolean NAVDEBUG_showCollision;
+
+extern	int	 NAVDEBUG_curGoal;
+
+void NAV_Shutdown( void );
+void NAV_CalculatePaths( const char *filename, int checksum );
+void NAV_CalculateSquadPaths( const char *filename, int checksum );
+
+void NAV_ShowDebugInfo( void );
+
+int NAV_GetNearestNode( gentity_t *self, int lastNode );
+extern int NAV_TestBestNode( gentity_t *self, int startID, int endID, qboolean failEdge );
+
+qboolean NPC_GetMoveDirection( vec3_t out, float *distance );
+void NPC_MoveToGoalExt( vec3_t point );
+void NAV_FindPlayerWaypoint( int clNum );
+qboolean NAV_CheckAhead( gentity_t *self, vec3_t end, trace_t *trace, int clipmask );
+#endif
+
+#endif //#ifndef __G_NAV_H__
diff --git a/codemp/game/g_navnew.c b/codemp/game/g_navnew.c
new file mode 100644
index 0000000..78a9a11
--- /dev/null
+++ b/codemp/game/g_navnew.c
@@ -0,0 +1,865 @@
+#include "b_local.h"
+#include "g_nav.h"
+
+qboolean NAV_CheckAhead( gentity_t *self, vec3_t end, trace_t *trace, int clipmask );
+qboolean NAV_TestForBlocked( gentity_t *self, gentity_t *goal, gentity_t *blocker, float distance, int *flags );
+
+void G_Line( vec3_t start, vec3_t end, vec3_t color, float alpha );
+void G_Cube( vec3_t mins, vec3_t maxs, vec3_t color, float alpha );
+void G_CubeOutline( vec3_t mins, vec3_t maxs, int time, unsigned int color, float alpha );
+void G_DrawEdge( vec3_t start, vec3_t end, int type );
+void G_DrawNode( vec3_t origin, int type );
+void G_DrawCombatPoint( vec3_t origin, int type );
+void TAG_ShowTags( int flags );
+
+qboolean NAV_CheckNodeFailedForEnt( gentity_t *ent, int nodeNum )
+{
+	int j;
+
+	//FIXME: must be a better way to do this
+	for ( j = 0; j < MAX_FAILED_NODES; j++ )
+	{
+		if ( ent->failedWaypoints[j] == nodeNum+1 )//+1 because 0 is a valid nodeNum, but also the default
+		{//we failed against this node
+			return qtrue;
+		}
+	}
+	return qfalse;
+}
+/*
+-------------------------
+NPC_UnBlocked
+-------------------------
+*/
+void NPC_ClearBlocked( gentity_t *self )
+{
+	if ( self->NPC == NULL )
+		return;
+
+	//self->NPC->aiFlags &= ~NPCAI_BLOCKED;
+	self->NPC->blockingEntNum = ENTITYNUM_NONE;
+}
+
+void NPC_SetBlocked( gentity_t *self, gentity_t *blocker )
+{
+	if ( self->NPC == NULL )
+		return;
+
+	//self->NPC->aiFlags |= NPCAI_BLOCKED;
+	self->NPC->blockedSpeechDebounceTime = level.time + MIN_BLOCKED_SPEECH_TIME + ( random() * 4000 );
+	self->NPC->blockingEntNum = blocker->s.number;
+}
+
+/*
+-------------------------
+NAVNEW_ClearPathBetweenPoints
+-------------------------
+*/
+int NAVNEW_ClearPathBetweenPoints(vec3_t start, vec3_t end, vec3_t mins, vec3_t maxs, int ignore, int clipmask)
+{
+	trace_t	trace;
+
+	//Test if they're even conceivably close to one another
+	if ( !trap_InPVS( start, end ) )
+	{
+		return ENTITYNUM_WORLD;
+	}
+
+	trap_Trace( &trace, start, mins, maxs, end, ignore, clipmask );
+
+	//if( ( ( trace.startsolid == false ) && ( trace.allsolid == false ) ) && ( trace.fraction < 1.0f ) )
+	//{//FIXME: check for drops?
+	//FIXME: if startsolid or allsolid, then the path isn't clear... but returning ENTITYNUM_NONE indicates to CheckFailedEdge that is is clear...?
+		return trace.entityNum;
+	//}
+
+	//return ENTITYNUM_NONE;
+}
+
+/*
+-------------------------
+NAVNEW_PushBlocker
+-------------------------
+*/
+void NAVNEW_PushBlocker( gentity_t *self, gentity_t *blocker, vec3_t right, qboolean setBlockedInfo )
+{//try pushing blocker to one side
+	trace_t	tr;
+	vec3_t	mins, end;
+	float	rightSucc, leftSucc, moveamt;
+
+	if ( self->NPC->shoveCount > 30 )
+	{//don't push for more than 3 seconds;
+		return;
+	}
+
+	if ( !blocker->s.number )
+	{//never push the player
+		return;
+	}
+
+	if ( !blocker->client || !VectorCompare( blocker->client->pushVec, vec3_origin ) )
+	{//someone else is pushing him, wait until they give up?
+		return;
+	}
+
+	VectorCopy( blocker->r.mins, mins );
+	mins[2] += STEPSIZE;
+
+	moveamt = (self->r.maxs[1] + blocker->r.maxs[1]) * 1.2;//yes, magic number
+
+	VectorMA( blocker->r.currentOrigin, -moveamt, right, end );
+	trap_Trace( &tr, blocker->r.currentOrigin, mins, blocker->r.maxs, end, blocker->s.number, blocker->clipmask|CONTENTS_BOTCLIP);
+	if ( !tr.startsolid && !tr.allsolid )
+	{
+		leftSucc = tr.fraction;
+	}
+	else
+	{
+		leftSucc = 0.0f;
+	}
+	
+	if ( leftSucc >= 1.0f )
+	{//it's clear, shove him that way
+		VectorScale( right, -moveamt, blocker->client->pushVec );
+		blocker->client->pushVecTime = level.time + 2000;
+	}
+	else
+	{
+		VectorMA( blocker->r.currentOrigin, moveamt, right, end );
+		trap_Trace( &tr, blocker->r.currentOrigin, mins, blocker->r.maxs, end, blocker->s.number, blocker->clipmask|CONTENTS_BOTCLIP );
+		if ( !tr.startsolid && !tr.allsolid )
+		{
+			rightSucc = tr.fraction;
+		}
+		else
+		{
+			rightSucc = 0.0f;
+		}
+		
+		if ( leftSucc == 0.0f && rightSucc == 0.0f )
+		{//both sides failed
+			if ( d_patched.integer )
+			{//use patch-style navigation
+				blocker->client->pushVecTime = 0;
+			}
+			return;
+		}
+
+		if ( rightSucc >= 1.0f )
+		{//it's clear, shove him that way
+			VectorScale( right, moveamt, blocker->client->pushVec );
+			blocker->client->pushVecTime = level.time + 2000;
+		}
+		//if neither are enough, we probably can't get around him, but keep trying
+		else if ( leftSucc >= rightSucc )
+		{//favor the left, all things being equal
+			VectorScale( right, -moveamt, blocker->client->pushVec );
+			blocker->client->pushVecTime = level.time + 2000;
+		}
+		else
+		{
+			VectorScale( right, moveamt, blocker->client->pushVec );
+			blocker->client->pushVecTime = level.time + 2000;
+		}
+	}
+
+	if ( setBlockedInfo )
+	{
+		//we tried pushing
+		self->NPC->shoveCount++;
+	}
+}
+
+/*
+-------------------------
+NAVNEW_DanceWithBlocker
+-------------------------
+*/
+qboolean NAVNEW_DanceWithBlocker( gentity_t *self, gentity_t *blocker, vec3_t movedir, vec3_t right )
+{//sees if blocker has any lateral movement
+	if ( blocker->client && !VectorCompare( blocker->client->ps.velocity, vec3_origin ) )
+	{
+		vec3_t blocker_movedir;
+		float dot;
+
+		VectorCopy( blocker->client->ps.velocity, blocker_movedir );
+		blocker_movedir[2] = 0;//cancel any vertical motion
+		dot = DotProduct( blocker_movedir, right );
+		if ( dot > 50.0f )
+		{//he's moving to the right of me at a relatively good speed
+			//go to my left
+			VectorMA( movedir, -1, right, movedir );
+			VectorNormalize( movedir );
+			return qtrue;
+		}
+		else if ( dot > -50.0f )
+		{//he's moving to the left of me at a relatively good speed
+			//go to my right
+			VectorAdd( right, movedir, movedir );
+			VectorNormalize( movedir );
+			return qtrue;
+		}
+		/*
+		vec3_t	block_pos;
+		trace_t	tr;
+		VectorScale( blocker_movedir, -1, blocker_movedir );
+		VectorMA( self->r.currentOrigin, blocked_dist, blocker_movedir, block_pos );
+		if ( NAVNEW_CheckAhead( self, block_pos, tr, ( self->clipmask & ~CONTENTS_BODY )|CONTENTS_BOTCLIP ) )
+		{
+			VectorCopy( blocker_movedir, movedir );
+			return qtrue;
+		}
+		*/
+	}
+	return qfalse;
+}
+
+/*
+-------------------------
+NAVNEW_SidestepBlocker
+-------------------------
+*/
+qboolean NAVNEW_SidestepBlocker( gentity_t *self, gentity_t *blocker, vec3_t blocked_dir, float blocked_dist, vec3_t movedir, vec3_t right )
+{//trace to sides of blocker and see if either is clear
+	trace_t	tr;
+	vec3_t	avoidAngles;
+	vec3_t	avoidRight_dir, avoidLeft_dir, block_pos, mins;
+	float	rightSucc, leftSucc, yaw, avoidRadius, arcAngle;
+
+	VectorCopy( self->r.mins, mins );
+	mins[2] += STEPSIZE;
+
+	//Get the blocked direction
+	yaw = vectoyaw( blocked_dir );
+
+	//Get the avoid radius
+	avoidRadius = sqrt( ( blocker->r.maxs[0] * blocker->r.maxs[0] ) + ( blocker->r.maxs[1] * blocker->r.maxs[1] ) ) + 
+						sqrt( ( self->r.maxs[0] * self->r.maxs[0] ) + ( self->r.maxs[1] * self->r.maxs[1] ) );
+
+	//See if we're inside our avoidance radius
+	arcAngle = ( blocked_dist <= avoidRadius ) ? 135 : ( ( avoidRadius / blocked_dist ) * 90 );
+
+	/*
+	float dot = DotProduct( blocked_dir, right );
+
+	//Go right on the first try if that works better
+	if ( dot < 0.0f )
+		arcAngle *= -1;
+	*/
+
+	VectorClear( avoidAngles );
+
+	//need to stop it from ping-ponging, so we have a bit of a debounce time on which side you try
+	if ( self->NPC->sideStepHoldTime > level.time )
+	{
+		if ( self->NPC->lastSideStepSide == -1 )//left
+		{
+			arcAngle *= -1;
+		}//else right
+		avoidAngles[YAW] = AngleNormalize360( yaw + arcAngle );
+		AngleVectors( avoidAngles, movedir, NULL, NULL );
+		VectorMA( self->r.currentOrigin, blocked_dist, movedir, block_pos );
+		trap_Trace( &tr, self->r.currentOrigin, mins, self->r.maxs, block_pos, self->s.number, self->clipmask|CONTENTS_BOTCLIP );
+		return (tr.fraction==1.0&&!tr.allsolid&&!tr.startsolid);
+	}
+
+	//test right
+	avoidAngles[YAW] = AngleNormalize360( yaw + arcAngle );
+	AngleVectors( avoidAngles, avoidRight_dir, NULL, NULL );
+
+	VectorMA( self->r.currentOrigin, blocked_dist, avoidRight_dir, block_pos );
+		
+	trap_Trace( &tr, self->r.currentOrigin, mins, self->r.maxs, block_pos, self->s.number, self->clipmask|CONTENTS_BOTCLIP );
+
+	if ( !tr.allsolid && !tr.startsolid )
+	{
+		if ( tr.fraction >= 1.0f )
+		{//all clear, go for it (favor the right if both are equal)
+			VectorCopy( avoidRight_dir, movedir );
+			self->NPC->lastSideStepSide = 1;
+			self->NPC->sideStepHoldTime = level.time + 2000;
+			return qtrue;
+		}
+		rightSucc = tr.fraction;
+	}
+	else
+	{
+		rightSucc = 0.0f;
+	}
+
+	//now test left
+	arcAngle *= -1;
+
+	avoidAngles[YAW] = AngleNormalize360( yaw + arcAngle );
+	AngleVectors( avoidAngles, avoidLeft_dir, NULL, NULL );
+
+	VectorMA( self->r.currentOrigin, blocked_dist, avoidLeft_dir, block_pos );
+		
+	trap_Trace( &tr, self->r.currentOrigin, mins, self->r.maxs, block_pos, self->s.number, self->clipmask|CONTENTS_BOTCLIP );
+
+	if ( !tr.allsolid && !tr.startsolid )
+	{
+		if ( tr.fraction >= 1.0f )
+		{//all clear, go for it (right side would have already succeeded if as good as this)
+			VectorCopy( avoidLeft_dir, movedir );
+			self->NPC->lastSideStepSide = -1;
+			self->NPC->sideStepHoldTime = level.time + 2000;
+			return qtrue;
+		}
+		leftSucc = tr.fraction;
+	}
+	else
+	{
+		leftSucc = 0.0f;
+	}
+
+	if ( leftSucc == 0.0f && rightSucc == 0.0f )
+	{//both sides failed
+		return qfalse;
+	}
+
+	if ( rightSucc*blocked_dist >= avoidRadius || leftSucc*blocked_dist >= avoidRadius ) 
+	{//the traces hit something, but got a relatively good distance
+		if ( rightSucc >= leftSucc )
+		{//favor the right, all things being equal
+			VectorCopy( avoidRight_dir, movedir );
+			self->NPC->lastSideStepSide = 1;
+			self->NPC->sideStepHoldTime = level.time + 2000;
+		}
+		else
+		{
+			VectorCopy( avoidLeft_dir, movedir );
+			self->NPC->lastSideStepSide = -1;
+			self->NPC->sideStepHoldTime = level.time + 2000;
+		}
+		return qtrue;
+	}
+
+	//if neither are enough, we probably can't get around him
+	return qfalse;
+}
+
+/*
+-------------------------
+NAVNEW_Bypass
+-------------------------
+*/
+qboolean NAVNEW_Bypass( gentity_t *self, gentity_t *blocker, vec3_t blocked_dir, float blocked_dist, vec3_t movedir, qboolean setBlockedInfo ) 
+{
+	vec3_t	moveangles, right;
+
+	//Draw debug info if requested
+	if ( NAVDEBUG_showCollision )
+	{
+		G_DrawEdge( self->r.currentOrigin, blocker->r.currentOrigin, EDGE_NORMAL );
+	}
+
+	vectoangles( movedir, moveangles );
+	moveangles[2] = 0;
+	AngleVectors( moveangles, NULL, right, NULL );
+
+	//Check to see what dir the other guy is moving in (if any) and pick the opposite dir
+	if ( NAVNEW_DanceWithBlocker( self, blocker, movedir, right ) )
+	{
+		return qtrue;
+	}
+
+	//Okay, so he's not moving to my side, see which side of him is most clear
+	if ( NAVNEW_SidestepBlocker( self, blocker, blocked_dir, blocked_dist, movedir, right ) )
+	{
+		return qtrue;
+	}
+
+	//Neither side is clear, tell him to step aside
+	NAVNEW_PushBlocker( self, blocker, right, setBlockedInfo );
+
+	return qfalse;
+}
+
+/*
+-------------------------
+NAVNEW_CheckDoubleBlock
+-------------------------
+*/
+qboolean NAVNEW_CheckDoubleBlock( gentity_t *self, gentity_t *blocker, vec3_t blocked_dir )
+{
+	//Stop double waiting
+	if ( ( blocker->NPC ) && ( blocker->NPC->blockingEntNum == self->s.number ) )
+		return qtrue;
+
+	return qfalse;
+}
+
+/*
+-------------------------
+NAVNEW_ResolveEntityCollision
+-------------------------
+*/
+extern void CalcTeamDoorCenter ( gentity_t *ent, vec3_t center );
+qboolean NAVNEW_ResolveEntityCollision( gentity_t *self, gentity_t *blocker, vec3_t movedir, vec3_t pathDir, qboolean setBlockedInfo )
+{
+	vec3_t	blocked_dir;
+	float blocked_dist;
+
+	//Doors are ignored
+	if ( Q_stricmp( blocker->classname, "func_door" ) == 0 )
+	{
+		vec3_t center;
+		CalcTeamDoorCenter ( blocker, center );
+		if ( DistanceSquared( self->r.currentOrigin, center ) > MIN_DOOR_BLOCK_DIST_SQR )
+			return qtrue;
+	}
+
+	VectorSubtract( blocker->r.currentOrigin, self->r.currentOrigin, blocked_dir );
+	blocked_dist = VectorNormalize( blocked_dir );
+
+	//Make sure an actual collision is going to happen
+//	if ( NAVNEW_PredictCollision( self, blocker, movedir, blocked_dir ) == qfalse )
+//		return qtrue;
+	
+	//First, attempt to walk around the blocker or shove him out of the way
+	if ( NAVNEW_Bypass( self, blocker, blocked_dir, blocked_dist, movedir, setBlockedInfo ) )
+		return qtrue;
+
+	//Can't get around him... see if I'm blocking him too... if so, I need to just keep moving?
+	if ( NAVNEW_CheckDoubleBlock( self, blocker, blocked_dir ) )
+		return qtrue;
+
+	if ( setBlockedInfo )
+	{
+		//Complain about it if we can
+		NPC_SetBlocked( self, blocker );
+	}
+
+	return qfalse;
+}
+
+/*
+-------------------------
+NAVNEW_AvoidCollision
+-------------------------
+*/
+qboolean NAVNEW_AvoidCollision( gentity_t *self, gentity_t *goal, navInfo_t *info, qboolean setBlockedInfo, int blockedMovesLimit )
+{
+	vec3_t	movedir;
+	vec3_t	movepos;
+
+	//Cap our distance
+	if ( info->distance > MAX_COLL_AVOID_DIST )
+	{
+		info->distance = MAX_COLL_AVOID_DIST;
+	}
+
+	//Get an end position
+	VectorMA( self->r.currentOrigin, info->distance, info->direction, movepos );
+	VectorCopy( info->direction, movedir );
+
+	//Now test against entities
+	if ( NAV_CheckAhead( self, movepos, &info->trace, CONTENTS_BODY ) == qfalse )
+	{
+		//Get the blocker
+		info->blocker = &g_entities[ info->trace.entityNum ];
+		info->flags |= NIF_COLLISION;
+
+		//Ok to hit our goal entity
+		if ( goal == info->blocker )
+			return qtrue;
+
+		if ( setBlockedInfo )
+		{
+			if ( self->NPC->consecutiveBlockedMoves > blockedMovesLimit  )
+			{
+				if ( d_patched.integer )
+				{//use patch-style navigation
+					self->NPC->consecutiveBlockedMoves++;
+				}
+				NPC_SetBlocked( self, info->blocker );
+				return qfalse;
+			}
+			self->NPC->consecutiveBlockedMoves++;
+		}
+		//See if we're moving along with them
+		//if ( NAVNEW_TrueCollision( self, info->blocker, movedir, info->direction ) == qfalse )
+		//	return qtrue;
+
+		//Test for blocking by standing on goal
+		if ( NAV_TestForBlocked( self, goal, info->blocker, info->distance, &info->flags ) == qtrue )
+			return qfalse;
+
+		//If the above function said we're blocked, don't do the extra checks
+		/*
+		if ( info->flags & NIF_BLOCKED )
+			return qtrue;
+		*/
+
+		//See if we can get that entity to move out of our way
+		if ( NAVNEW_ResolveEntityCollision( self, info->blocker, movedir, info->pathDirection, setBlockedInfo ) == qfalse )
+			return qfalse;
+
+		VectorCopy( movedir, info->direction );
+		
+		return qtrue;
+	}
+	else
+	{
+		if ( setBlockedInfo )
+		{
+			self->NPC->consecutiveBlockedMoves = 0;
+		}
+	}
+
+	//Our path is clear, just move there
+	if ( NAVDEBUG_showCollision )
+	{
+		G_DrawEdge( self->r.currentOrigin, movepos, EDGE_MOVEDIR );
+	}
+
+	return qtrue;
+}
+
+qboolean NAVNEW_TestNodeConnectionBlocked( int wp1, int wp2, gentity_t *ignoreEnt, int goalEntNum, qboolean checkWorld, qboolean checkEnts )
+{//see if the direct path between 2 nodes is blocked by architecture or an ent
+	vec3_t	pos1, pos2, mins, maxs;
+	trace_t	trace;
+	int		clipmask = MASK_NPCSOLID|CONTENTS_BOTCLIP;
+	int ignoreEntNum;
+	vec3_t playerMins, playerMaxs;
+
+	if ( !checkWorld && !checkEnts )
+	{//duh, nothing to trace against
+		return qfalse;
+	}
+	VectorSet(playerMins, -15, -15, DEFAULT_MINS_2);
+	VectorSet(playerMaxs, 15, 15, DEFAULT_MAXS_2);
+
+	trap_Nav_GetNodePosition( wp1, pos1 );
+	trap_Nav_GetNodePosition( wp2, pos2 );
+
+	if ( !checkWorld )
+	{
+		clipmask &= ~(CONTENTS_SOLID|CONTENTS_MONSTERCLIP|CONTENTS_BOTCLIP);
+	}
+	if ( !checkEnts )
+	{
+		clipmask &= ~CONTENTS_BODY;
+	}
+	if ( ignoreEnt )
+	{
+		VectorCopy( ignoreEnt->r.mins, mins );
+		VectorCopy( ignoreEnt->r.maxs, maxs );
+		ignoreEntNum = ignoreEnt->s.number;
+	}
+	else
+	{
+		VectorCopy( playerMins, mins );
+		VectorCopy( playerMaxs, mins );
+		ignoreEntNum = ENTITYNUM_NONE;
+	}
+	mins[2] += STEPSIZE;
+	//don't let box get inverted
+	if ( mins[2] > maxs[2] )
+	{	
+		mins[2] = maxs[2];
+	}
+
+	trap_Trace( &trace, pos1, mins, maxs, pos2, ignoreEntNum, clipmask );
+	if ( trace.fraction >= 1.0f || trace.entityNum == goalEntNum )
+	{//clear or hit goal
+		return qfalse;
+	}
+	//hit something we weren't supposed to
+	return qtrue;
+}
+/*
+-------------------------
+NAVNEW_MoveToGoal
+-------------------------
+*/
+int	NAVNEW_MoveToGoal( gentity_t *self, navInfo_t *info )
+{
+	int			bestNode = WAYPOINT_NONE;
+	qboolean	foundClearPath = qfalse;
+	vec3_t		origin;
+	navInfo_t	tempInfo;
+	qboolean	setBlockedInfo = qtrue;
+	qboolean	inBestWP, inGoalWP, goalWPFailed = qfalse;
+	int			numTries = 0;
+
+	memcpy( &tempInfo, info, sizeof( tempInfo ) );
+
+	//Must have a goal entity to move there
+	if( self->NPC->goalEntity == NULL )
+		return WAYPOINT_NONE;
+
+	if ( self->waypoint == WAYPOINT_NONE && self->noWaypointTime > level.time )
+	{//didn't have a valid one in about the past second, don't look again just yet
+		return WAYPOINT_NONE;
+	}
+	if ( self->NPC->goalEntity->waypoint == WAYPOINT_NONE && self->NPC->goalEntity->noWaypointTime > level.time )
+	{//didn't have a valid one in about the past second, don't look again just yet
+		return WAYPOINT_NONE;
+	}
+	if ( self->noWaypointTime > level.time &&
+		self->NPC->goalEntity->noWaypointTime > level.time )
+	{//just use current waypoints
+		bestNode = trap_Nav_GetBestNodeAltRoute2( self->waypoint, self->NPC->goalEntity->waypoint, bestNode );
+	}
+	//FIXME!!!!: this is making them wiggle back and forth between waypoints
+	else if ( (bestNode = trap_Nav_GetBestPathBetweenEnts( self, self->NPC->goalEntity, NF_CLEAR_PATH )) == NODE_NONE )//!NAVNEW_GetWaypoints( self, qtrue ) )
+	{//one of us didn't have a valid waypoint!
+		if ( self->waypoint == NODE_NONE )
+		{//don't even try to find one again for a bit
+			self->noWaypointTime = level.time + Q_irand( 500, 1500 );
+		}
+		if ( self->NPC->goalEntity->waypoint == NODE_NONE )
+		{//don't even try to find one again for a bit
+			self->NPC->goalEntity->noWaypointTime = level.time + Q_irand( 500, 1500 );
+		}
+		return WAYPOINT_NONE;
+	}
+	else
+	{
+		if ( self->NPC->goalEntity->noWaypointTime < level.time )
+		{
+			self->NPC->goalEntity->noWaypointTime = level.time + Q_irand( 500, 1500 );
+		}
+	}
+
+	while( !foundClearPath )
+	{
+		inBestWP = inGoalWP = qfalse;
+		/*
+		bestNode = trap_Nav_GetBestNodeAltRoute( self->waypoint, self->NPC->goalEntity->waypoint, bestNode );
+		*/
+
+		if ( bestNode == WAYPOINT_NONE )
+		{
+			goto failed;
+		}
+
+		//see if we can get directly to the next node off bestNode en route to goal's node...
+		//NOTE: shouldn't be necc. now
+		/*
+		int oldBestNode = bestNode;
+		bestNode = NAV_TestBestNode( self, self->waypoint, bestNode, qtrue );//, self->NPC->goalEntity->waypoint );// 
+		//NOTE: Guaranteed to return something
+		if ( bestNode != oldBestNode )
+		{//we were blocked somehow
+			if ( setBlockedInfo )
+			{
+				self->NPC->aiFlags |= NPCAI_BLOCKED;
+				trap_Nav_GetNodePosition( oldBestNode, NPCInfo->blockedDest );
+			}
+		}
+		*/
+		trap_Nav_GetNodePosition( bestNode, origin );
+		/*
+		if ( !goalWPFailed )
+		{//we haven't already tried to go straight to goal or goal's wp
+			if ( bestNode == self->NPC->goalEntity->waypoint )
+			{//our bestNode is the goal's wp
+				if ( NAV_HitNavGoal( self->r.currentOrigin, self->r.mins, self->r.maxs, origin, trap_Nav_GetNodeRadius( bestNode ), FlyingCreature( self ) ) )
+				{//we're in the goal's wp
+					inGoalWP = qtrue;
+					//we're in the goalEntity's waypoint already
+					//so head for the goalEntity since we know it's clear of architecture
+					//FIXME: this is pretty stupid because the NPCs try to go straight
+					//		towards their goal before then even try macro_nav...
+					VectorCopy( self->NPC->goalEntity->r.currentOrigin, origin );
+				}
+			}
+		}
+		*/
+		if ( !inGoalWP )
+		{//not heading straight for goal
+			if ( bestNode == self->waypoint )
+			{//we know it's clear or architecture
+				//trap_Nav_GetNodePosition( self->waypoint, origin );
+				/*
+				if ( NAV_HitNavGoal( self->r.currentOrigin, self->r.mins, self->r.maxs, origin, trap_Nav_GetNodeRadius( bestNode ), FlyingCreature( self ) ) )
+				{//we're in the wp we're heading for already
+					inBestWP = qtrue;
+				}
+				*/
+			}
+			else
+			{//heading to an edge off our confirmed clear waypoint... make sure it's clear
+				//it it's not, bestNode will fall back to our waypoint
+				int oldBestNode = bestNode;
+				bestNode = NAV_TestBestNode( self, self->waypoint, bestNode, qtrue );
+				if ( bestNode == self->waypoint )
+				{//we fell back to our waypoint, reset the origin
+					self->NPC->aiFlags |= NPCAI_BLOCKED;
+					trap_Nav_GetNodePosition( oldBestNode, NPCInfo->blockedDest );
+					trap_Nav_GetNodePosition( bestNode, origin );
+				}
+			}
+		}
+		//Com_Printf( "goalwp = %d, mywp = %d, node = %d, origin = %s\n", self->NPC->goalEntity->waypoint, self->waypoint, bestNode, vtos(origin) );
+
+		memcpy( &tempInfo, info, sizeof( tempInfo ) );
+		VectorSubtract( origin, self->r.currentOrigin, tempInfo.direction );
+		VectorNormalize( tempInfo.direction );
+
+		//NOTE: One very important thing NAVNEW_AvoidCollision does is
+		//		it actually CHANGES the value of "direction" - it changes it to
+		//		whatever dir you need to go in to avoid the obstacle...
+		foundClearPath = NAVNEW_AvoidCollision( self, self->NPC->goalEntity, &tempInfo, setBlockedInfo, 5 );
+
+		if ( !foundClearPath )
+		{//blocked by an ent
+			if ( inGoalWP )
+			{//we were heading straight for the goal, head for the goal's wp instead
+				trap_Nav_GetNodePosition( bestNode, origin );
+				foundClearPath = NAVNEW_AvoidCollision( self, self->NPC->goalEntity, &tempInfo, setBlockedInfo, 5 );
+			}
+		}
+
+		if ( foundClearPath )
+		{//clear!
+			//If we got set to blocked, clear it
+			NPC_ClearBlocked( self );
+			//Take the dir
+			memcpy( info, &tempInfo, sizeof( *info ) );
+			if ( self->s.weapon == WP_SABER )
+			{//jedi
+				if ( info->direction[2] * info->distance > 64 )
+				{
+					self->NPC->aiFlags |= NPCAI_BLOCKED;
+					VectorCopy( origin, NPCInfo->blockedDest );
+					goto failed;
+				}
+			}
+		}
+		else
+		{//blocked by ent!
+			if ( setBlockedInfo )
+			{
+				self->NPC->aiFlags |= NPCAI_BLOCKED;
+				trap_Nav_GetNodePosition( bestNode, NPCInfo->blockedDest );
+			}
+			//Only set blocked info first time
+			setBlockedInfo = qfalse;
+
+			if ( inGoalWP )
+			{//we headed for our goal and failed and our goal's WP and failed
+				if ( self->waypoint == self->NPC->goalEntity->waypoint )
+				{//our waypoint is our goal's waypoint, nothing we can do
+					//remember that this node is blocked
+					trap_Nav_AddFailedNode( self, self->waypoint );
+					goto failed;
+				}
+				else
+				{//try going for our waypoint this time
+					goalWPFailed = qtrue;
+					inGoalWP = qfalse;
+				}
+			}
+			else if ( bestNode != self->waypoint )
+			{//we headed toward our next waypoint (instead of our waypoint) and failed
+				if ( d_altRoutes.integer )
+				{//mark this edge failed and try our waypoint
+					//NOTE: don't assume there is something blocking the direct path
+					//			between my waypoint and the bestNode... I could be off
+					//			that path because of collision avoidance...
+					if ( d_patched.integer &&//use patch-style navigation
+ 						( !trap_Nav_NodesAreNeighbors( self->waypoint, bestNode )
+						|| NAVNEW_TestNodeConnectionBlocked( self->waypoint, bestNode, self, self->NPC->goalEntity->s.number, qfalse, qtrue ) ) )
+					{//the direct path between these 2 nodes is blocked by an ent
+						trap_Nav_AddFailedEdge( self->s.number, self->waypoint, bestNode );
+					}
+					bestNode = self->waypoint;
+				}
+				else
+				{
+					//we should stop
+					goto failed;
+				}
+			}
+			else 
+			{//we headed for *our* waypoint and couldn't get to it
+				if ( d_altRoutes.integer )
+				{
+					//remember that this node is blocked
+					trap_Nav_AddFailedNode( self, self->waypoint );
+					//Now we should get our waypoints again
+					//FIXME: cache the trace-data for subsequent calls as only the route info would have changed
+					//if ( (bestNode = trap_Nav_GetBestPathBetweenEnts( self, self->NPC->goalEntity, NF_CLEAR_PATH )) == NODE_NONE )//!NAVNEW_GetWaypoints( self, qfalse ) )
+					{//one of our waypoints is WAYPOINT_NONE now
+						goto failed;
+					}
+				}
+				else
+				{
+					//we should stop
+					goto failed;
+				}
+			}
+
+			if ( ++numTries >= 10 )
+			{
+				goto failed;
+			}
+		}
+	}
+
+//finish:
+	//Draw any debug info, if requested
+	if ( NAVDEBUG_showEnemyPath )
+	{
+		vec3_t	dest, start;
+
+		//Get the positions
+		trap_Nav_GetNodePosition( self->NPC->goalEntity->waypoint, dest );
+		trap_Nav_GetNodePosition( bestNode, start );
+
+		//Draw the route
+		G_DrawNode( start, NODE_START );
+		if ( bestNode != self->waypoint )
+		{
+			vec3_t	wpPos;
+			trap_Nav_GetNodePosition( self->waypoint, wpPos );
+			G_DrawNode( wpPos, NODE_NAVGOAL );
+		}
+		G_DrawNode( dest, NODE_GOAL );
+		G_DrawEdge( dest, self->NPC->goalEntity->r.currentOrigin, EDGE_PATH );
+		G_DrawNode( self->NPC->goalEntity->r.currentOrigin, NODE_GOAL );
+		trap_Nav_ShowPath( bestNode, self->NPC->goalEntity->waypoint );
+	}
+
+	self->NPC->shoveCount = 0;
+
+	//let me keep this waypoint for a while
+	if ( self->noWaypointTime < level.time )
+	{
+		self->noWaypointTime = level.time + Q_irand( 500, 1500 );
+	}
+	return bestNode;
+
+failed:
+	//FIXME: What we should really do here is have a list of the goal's and our
+	//		closest clearpath waypoints, ranked.  If the first set fails, try the rest
+	//		until there are no alternatives.
+
+	trap_Nav_GetNodePosition( self->waypoint, origin );
+
+	//do this to avoid ping-ponging?
+	return WAYPOINT_NONE;
+	/*
+	//this was causing ping-ponging
+	if ( DistanceSquared( origin, self->r.currentOrigin ) < 16 )//woo, magic number
+	{//We're right up on our waypoint, so that won't help, return none
+		//Or maybe find the nextbest here?
+		return WAYPOINT_NONE;
+	}
+	else
+	{//Try going to our waypoint
+		bestNode = self->waypoint;
+
+		VectorSubtract( origin, self->r.currentOrigin, info.direction );
+		VectorNormalize( info.direction );
+	}
+	
+	goto finish;
+	*/
+}
diff --git a/codemp/game/g_object.c b/codemp/game/g_object.c
new file mode 100644
index 0000000..3899917
--- /dev/null
+++ b/codemp/game/g_object.c
@@ -0,0 +1,287 @@
+#include "g_local.h"
+
+extern void G_MoverTouchPushTriggers( gentity_t *ent, vec3_t oldOrg );
+void G_StopObjectMoving( gentity_t *object );
+
+void pitch_roll_for_slope( gentity_t *forwhom, vec3_t pass_slope );
+
+/*
+================
+G_BounceObject
+
+================
+*/
+void G_BounceObject( gentity_t *ent, trace_t *trace ) 
+{
+	vec3_t	velocity;
+	float	dot, bounceFactor;
+	int		hitTime;
+
+	// reflect the velocity on the trace plane
+	hitTime = level.previousTime + ( level.time - level.previousTime ) * trace->fraction;
+	BG_EvaluateTrajectoryDelta( &ent->s.pos, hitTime, velocity );
+	dot = DotProduct( velocity, trace->plane.normal );
+//	bounceFactor = 60/ent->mass;		// NOTENOTE Mass is not yet implemented
+	bounceFactor = 1.0f;
+	if ( bounceFactor > 1.0f )
+	{
+		bounceFactor = 1.0f;
+	}
+	VectorMA( velocity, -2*dot*bounceFactor, trace->plane.normal, ent->s.pos.trDelta );
+
+	//FIXME: customized or material-based impact/bounce sounds
+	if ( ent->flags & FL_BOUNCE_HALF ) 
+	{
+		VectorScale( ent->s.pos.trDelta, 0.5, ent->s.pos.trDelta );
+
+		// check for stop
+		if ( ((trace->plane.normal[2] > 0.7&&g_gravity.value>0) || (trace->plane.normal[2]<-0.7&&g_gravity.value<0)) && ((ent->s.pos.trDelta[2]<40&&g_gravity.value>0)||(ent->s.pos.trDelta[2]>-40&&g_gravity.value<0)) ) //this can happen even on very slightly sloped walls, so changed it from > 0 to > 0.7
+		{
+			//G_SetOrigin( ent, trace->endpos );
+			//ent->nextthink = level.time + 500;
+			ent->s.apos.trType = TR_STATIONARY;
+			VectorCopy( ent->r.currentAngles, ent->s.apos.trBase );
+			VectorCopy( trace->endpos, ent->r.currentOrigin );
+			VectorCopy( trace->endpos, ent->s.pos.trBase );
+			ent->s.pos.trTime = level.time;
+			return;
+		}
+	}
+
+	// NEW--It would seem that we want to set our trBase to the trace endpos
+	//	and set the trTime to the actual time of impact....
+	//	FIXME: Should we still consider adding the normal though??
+	VectorCopy( trace->endpos, ent->r.currentOrigin );
+	ent->s.pos.trTime = hitTime;
+
+	VectorCopy( ent->r.currentOrigin, ent->s.pos.trBase );
+	VectorCopy( trace->plane.normal, ent->pos1 );//???
+}
+
+
+/*
+================
+G_RunObject
+
+  TODO:  When transition to 0 grav, push away from surface you were resting on
+  TODO:  When free-floating in air, apply some friction to your trDelta (based on mass?)
+================
+*/
+extern void DoImpact( gentity_t *self, gentity_t *other, qboolean damageSelf );
+extern void pitch_roll_for_slope( gentity_t *forwhom, vec3_t pass_slope );
+void G_RunObject( gentity_t *ent ) 
+{
+	vec3_t		origin, oldOrg;
+	trace_t		tr;
+	gentity_t	*traceEnt = NULL;
+
+	//FIXME: floaters need to stop floating up after a while, even if gravity stays negative?
+	if ( ent->s.pos.trType == TR_STATIONARY )//g_gravity.value <= 0 && 
+	{
+		ent->s.pos.trType = TR_GRAVITY;
+		VectorCopy( ent->r.currentOrigin, ent->s.pos.trBase );
+		ent->s.pos.trTime = level.previousTime;//?necc?
+		if ( !g_gravity.value )
+		{
+			ent->s.pos.trDelta[2] += 100;
+		}
+	}
+
+	ent->nextthink = level.time + FRAMETIME;
+
+	VectorCopy( ent->r.currentOrigin, oldOrg );
+	// get current position
+	BG_EvaluateTrajectory( &ent->s.pos, level.time, origin );
+	//Get current angles?
+	BG_EvaluateTrajectory( &ent->s.apos, level.time, ent->r.currentAngles );
+
+	if ( VectorCompare( ent->r.currentOrigin, origin ) )
+	{//error - didn't move at all!
+		return;
+	}
+	// trace a line from the previous position to the current position,
+	// ignoring interactions with the missile owner
+	trap_Trace( &tr, ent->r.currentOrigin, ent->r.mins, ent->r.maxs, origin, 
+		ent->parent ? ent->parent->s.number : ent->s.number, ent->clipmask );
+
+	if ( !tr.startsolid && !tr.allsolid && tr.fraction ) 
+	{
+		VectorCopy( tr.endpos, ent->r.currentOrigin );
+		trap_LinkEntity( ent );
+	}
+	else
+	//if ( tr.startsolid ) 
+	{
+		tr.fraction = 0;
+	}
+
+	G_MoverTouchPushTriggers( ent, oldOrg );
+	/*
+	if ( !(ent->s.eFlags & EF_TELEPORT_BIT) && !(ent->svFlags & SVF_NO_TELEPORT) )
+	{
+		G_MoverTouchTeleportTriggers( ent, oldOrg );
+		if ( ent->s.eFlags & EF_TELEPORT_BIT )
+		{//was teleported
+			return;
+		}
+	}
+	else
+	{
+		ent->s.eFlags &= ~EF_TELEPORT_BIT;
+	}
+	*/
+
+	if ( tr.fraction == 1 ) 
+	{
+		if ( g_gravity.value <= 0 )
+		{
+			if ( ent->s.apos.trType == TR_STATIONARY )
+			{
+				VectorCopy( ent->r.currentAngles, ent->s.apos.trBase );
+				ent->s.apos.trType = TR_LINEAR;
+				ent->s.apos.trDelta[1] = flrand( -300, 300 );
+				ent->s.apos.trDelta[0] = flrand( -10, 10 );
+				ent->s.apos.trDelta[2] = flrand( -10, 10 );
+				ent->s.apos.trTime = level.time;
+			}
+		}
+		//friction in zero-G
+		if ( !g_gravity.value )
+		{
+			float friction = 0.975f;
+			//friction -= ent->mass/1000.0f;
+			if ( friction < 0.1 )
+			{
+				friction = 0.1f;
+			}
+
+			VectorScale( ent->s.pos.trDelta, friction, ent->s.pos.trDelta );
+			VectorCopy( ent->r.currentOrigin, ent->s.pos.trBase );
+			ent->s.pos.trTime = level.time;
+		}
+		return;
+	}
+
+	//hit something
+
+	//Do impact damage
+	traceEnt = &g_entities[tr.entityNum];
+	if ( tr.fraction || (traceEnt && traceEnt->takedamage) )
+	{
+		if ( !VectorCompare( ent->r.currentOrigin, oldOrg ) )
+		{//moved and impacted
+			if ( (traceEnt && traceEnt->takedamage) )
+			{//hurt someone
+//				G_Sound( ent, G_SoundIndex( "sound/movers/objects/objectHurt.wav" ) );
+			}
+//			G_Sound( ent, G_SoundIndex( "sound/movers/objects/objectHit.wav" ) );
+		}
+
+		if (ent->s.weapon != WP_SABER)
+		{
+			DoImpact( ent, traceEnt, qtrue );
+		}
+	}
+
+	if ( !ent || (ent->takedamage&&ent->health <= 0) )
+	{//been destroyed by impact
+		//chunks?
+//		G_Sound( ent, G_SoundIndex( "sound/movers/objects/objectBreak.wav" ) );
+		return;
+	}
+
+	//do impact physics
+	if ( ent->s.pos.trType == TR_GRAVITY )//tr.fraction < 1.0 && 
+	{//FIXME: only do this if no trDelta
+		if ( g_gravity.value <= 0 || tr.plane.normal[2] < 0.7 )
+		{
+			if ( ent->flags&(FL_BOUNCE|FL_BOUNCE_HALF) )
+			{
+				if ( tr.fraction <= 0.0f )
+				{
+					VectorCopy( tr.endpos, ent->r.currentOrigin );
+					VectorCopy( tr.endpos, ent->s.pos.trBase );
+					VectorClear( ent->s.pos.trDelta );
+					ent->s.pos.trTime = level.time;
+				}
+				else
+				{
+					G_BounceObject( ent, &tr );
+				}
+			}
+			else
+			{//slide down?
+				//FIXME: slide off the slope
+			}
+		}
+		else
+		{
+			ent->s.apos.trType = TR_STATIONARY;
+			pitch_roll_for_slope( ent, tr.plane.normal );
+			//ent->r.currentAngles[0] = 0;//FIXME: match to slope
+			//ent->r.currentAngles[2] = 0;//FIXME: match to slope
+			VectorCopy( ent->r.currentAngles, ent->s.apos.trBase );
+			//okay, we hit the floor, might as well stop or prediction will
+			//make us go through the floor!
+			//FIXME: this means we can't fall if something is pulled out from under us...
+			G_StopObjectMoving( ent );
+		}
+	}
+	else if (ent->s.weapon != WP_SABER)
+	{
+		ent->s.apos.trType = TR_STATIONARY;
+		pitch_roll_for_slope( ent, tr.plane.normal );
+		//ent->r.currentAngles[0] = 0;//FIXME: match to slope
+		//ent->r.currentAngles[2] = 0;//FIXME: match to slope
+		VectorCopy( ent->r.currentAngles, ent->s.apos.trBase );
+	}
+
+	//call touch func
+	ent->touch( ent, &g_entities[tr.entityNum], &tr );
+}
+
+
+void G_StopObjectMoving( gentity_t *object )
+{
+	object->s.pos.trType = TR_STATIONARY;
+	VectorCopy( object->r.currentOrigin, object->s.origin );
+	VectorCopy( object->r.currentOrigin, object->s.pos.trBase );
+	VectorClear( object->s.pos.trDelta );
+
+	/*
+	//Stop spinning
+	VectorClear( self->s.apos.trDelta );
+	vectoangles(trace->plane.normal, self->s.angles);
+	VectorCopy(self->s.angles, self->r.currentAngles );
+	VectorCopy(self->s.angles, self->s.apos.trBase);
+	*/
+}
+
+void G_StartObjectMoving( gentity_t *object, vec3_t dir, float speed, trType_t trType )
+{
+	VectorNormalize (dir);
+
+	//object->s.eType = ET_GENERAL;
+	object->s.pos.trType = trType;
+	VectorCopy( object->r.currentOrigin, object->s.pos.trBase );
+	VectorScale(dir, speed, object->s.pos.trDelta );
+	object->s.pos.trTime = level.time;
+
+	/*
+	//FIXME: incorporate spin?
+	vectoangles(dir, object->s.angles);
+	VectorCopy(object->s.angles, object->s.apos.trBase);
+	VectorSet(object->s.apos.trDelta, 300, 0, 0 );
+	object->s.apos.trTime = level.time;
+	*/
+
+	//FIXME: make these objects go through G_RunObject automatically, like missiles do
+	if ( object->think == NULL )
+	{
+		object->nextthink = level.time + FRAMETIME;
+		object->think = G_RunObject;
+	}
+	else
+	{//You're responsible for calling RunObject
+	}
+}
diff --git a/codemp/game/g_public.h b/codemp/game/g_public.h
new file mode 100644
index 0000000..07abab6
--- /dev/null
+++ b/codemp/game/g_public.h
@@ -0,0 +1,920 @@
+// Copyright (C) 1999-2000 Id Software, Inc.
+//
+#ifndef G_PUBLIC_H
+
+// g_public.h -- game module information visible to server
+
+#define G_PUBLIC_H
+
+#define Q3_INFINITE			16777216 
+
+#define	GAME_API_VERSION	8
+
+// entity->svFlags
+// the server does not know how to interpret most of the values
+// in entityStates (level eType), so the game must explicitly flag
+// special server behaviors
+#define	SVF_NOCLIENT			0x00000001	// don't send entity to clients, even if it has effects
+#define SVF_BOT					0x00000008	// set if the entity is a bot
+#define SVF_PLAYER_USABLE		0x00000010	// player can use this with the use button
+#define	SVF_BROADCAST			0x00000020	// send to all connected clients
+#define	SVF_PORTAL				0x00000040	// merge a second pvs at origin2 into snapshots
+#define	SVF_USE_CURRENT_ORIGIN	0x00000080	// entity->r.currentOrigin instead of entity->s.origin
+											// for link position (missiles and movers)
+#define SVF_SINGLECLIENT		0x00000100	// only send to a single client (entityShared_t->singleClient)
+#define SVF_NOSERVERINFO		0x00000200	// don't send CS_SERVERINFO updates to this client
+											// so that it can be updated for ping tools without
+											// lagging clients
+#define SVF_CAPSULE				0x00000400	// use capsule for collision detection instead of bbox
+#define SVF_NOTSINGLECLIENT		0x00000800	// send entity to everyone but one client
+											// (entityShared_t->singleClient)
+
+#define SVF_OWNERNOTSHARED		0x00001000	// If it's owned by something and another thing owned by that something
+											// hits it, it will still touch
+
+#define	SVF_ICARUS_FREEZE		0x00008000	// NPCs are frozen, ents don't execute ICARUS commands
+
+#define SVF_GLASS_BRUSH			0x08000000	// Ent is a glass brush
+
+//rww - ghoul2 trace flags
+#define G2TRFLAG_DOGHOULTRACE	0x00000001 //do the ghoul2 trace
+#define G2TRFLAG_HITCORPSES		0x00000002 //will try g2 collision on the ent even if it's EF_DEAD
+#define G2TRFLAG_GETSURFINDEX	0x00000004 //will replace surfaceFlags with the ghoul2 surface index that was hit, if any.
+#define G2TRFLAG_THICK			0x00000008 //assures that the trace radius will be significantly large regardless of the trace box size.
+
+//===============================================================
+
+//this structure is shared by gameside and in-engine NPC nav routines.
+typedef struct failedEdge_e
+{
+	int	startID;
+	int	endID;
+	int checkTime;
+	int	entID;
+} failedEdge_t;
+
+typedef struct {
+	qboolean	linked;				// qfalse if not in any good cluster
+	int			linkcount;
+
+	int			svFlags;			// SVF_NOCLIENT, SVF_BROADCAST, etc
+	int			singleClient;		// only send to this client when SVF_SINGLECLIENT is set
+
+	qboolean	bmodel;				// if false, assume an explicit mins / maxs bounding box
+									// only set by trap_SetBrushModel
+	vec3_t		mins, maxs;
+	int			contents;			// CONTENTS_TRIGGER, CONTENTS_SOLID, CONTENTS_BODY, etc
+									// a non-solid entity should set to 0
+
+	vec3_t		absmin, absmax;		// derived from mins/maxs and origin + rotation
+
+	// currentOrigin will be used for all collision detection and world linking.
+	// it will not necessarily be the same as the trajectory evaluation for the current
+	// time, because each entity must be moved one at a time after time is advanced
+	// to avoid simultanious collision issues
+	vec3_t		currentOrigin;
+	vec3_t		currentAngles;
+	qboolean	mIsRoffing;			// set to qtrue when the entity is being roffed
+
+	// when a trace call is made and passEntityNum != ENTITYNUM_NONE,
+	// an ent will be excluded from testing if:
+	// ent->s.number == passEntityNum	(don't interact with self)
+	// ent->s.ownerNum = passEntityNum	(don't interact with your own missiles)
+	// entity[ent->s.ownerNum].ownerNum = passEntityNum	(don't interact with other missiles from owner)
+	int			ownerNum;
+
+	// mask of clients that this entity should be broadcast too.  The first 32 clients
+	// are represented by the first array index and the latter 32 clients are represented
+	// by the second array index.
+	int			broadcastClients[2];
+
+} entityShared_t;
+
+//===============================================================
+
+//
+// system traps provided by the main engine
+//
+typedef enum {
+	//============== general Quake services ==================
+
+	G_PRINT,		// ( const char *string );
+	// print message on the local console
+
+	G_ERROR,		// ( const char *string );
+	// abort the game
+
+	G_MILLISECONDS,	// ( void );
+	// get current time for profiling reasons
+	// this should NOT be used for any game related tasks,
+	// because it is not journaled
+
+	//Also for profiling.. do not use for game related tasks.
+	G_PRECISIONTIMER_START,
+	G_PRECISIONTIMER_END,
+
+	// console variable interaction
+	G_CVAR_REGISTER,	// ( vmCvar_t *vmCvar, const char *varName, const char *defaultValue, int flags );
+	G_CVAR_UPDATE,	// ( vmCvar_t *vmCvar );
+	G_CVAR_SET,		// ( const char *var_name, const char *value );
+	G_CVAR_VARIABLE_INTEGER_VALUE,	// ( const char *var_name );
+
+	G_CVAR_VARIABLE_STRING_BUFFER,	// ( const char *var_name, char *buffer, int bufsize );
+
+	G_ARGC,			// ( void );
+	// ClientCommand and ServerCommand parameter access
+
+	G_ARGV,			// ( int n, char *buffer, int bufferLength );
+
+	G_FS_FOPEN_FILE,	// ( const char *qpath, fileHandle_t *file, fsMode_t mode );
+	G_FS_READ,		// ( void *buffer, int len, fileHandle_t f );
+	G_FS_WRITE,		// ( const void *buffer, int len, fileHandle_t f );
+	G_FS_FCLOSE_FILE,		// ( fileHandle_t f );
+
+	G_SEND_CONSOLE_COMMAND,	// ( const char *text );
+	// add commands to the console as if they were typed in
+	// for map changing, etc
+
+
+	//=========== server specific functionality =============
+
+	G_LOCATE_GAME_DATA,		// ( gentity_t *gEnts, int numGEntities, int sizeofGEntity_t,
+	//							playerState_t *clients, int sizeofGameClient );
+	// the game needs to let the server system know where and how big the gentities
+	// are, so it can look at them directly without going through an interface
+
+	G_DROP_CLIENT,		// ( int clientNum, const char *reason );
+	// kick a client off the server with a message
+
+	G_SEND_SERVER_COMMAND,	// ( int clientNum, const char *fmt, ... );
+	// reliably sends a command string to be interpreted by the given
+	// client.  If clientNum is -1, it will be sent to all clients
+
+	G_SET_CONFIGSTRING,	// ( int num, const char *string );
+	// config strings hold all the index strings, and various other information
+	// that is reliably communicated to all clients
+	// All of the current configstrings are sent to clients when
+	// they connect, and changes are sent to all connected clients.
+	// All confgstrings are cleared at each level start.
+
+	G_GET_CONFIGSTRING,	// ( int num, char *buffer, int bufferSize );
+
+	G_GET_USERINFO,		// ( int num, char *buffer, int bufferSize );
+	// userinfo strings are maintained by the server system, so they
+	// are persistant across level loads, while all other game visible
+	// data is completely reset
+
+	G_SET_USERINFO,		// ( int num, const char *buffer );
+
+	G_GET_SERVERINFO,	// ( char *buffer, int bufferSize );
+	// the serverinfo info string has all the cvars visible to server browsers
+
+	G_SET_SERVER_CULL,
+	//server culling to reduce traffic on open maps -rww
+
+	G_SET_BRUSH_MODEL,	// ( gentity_t *ent, const char *name );
+	// sets mins and maxs based on the brushmodel name
+
+	G_TRACE,	// ( trace_t *results, const vec3_t start, const vec3_t mins, const vec3_t maxs, const vec3_t end, int passEntityNum, int contentmask );
+	// collision detection against all linked entities
+
+	G_G2TRACE,	// ( trace_t *results, const vec3_t start, const vec3_t mins, const vec3_t maxs, const vec3_t end, int passEntityNum, int contentmask );
+	// collision detection against all linked entities with ghoul2 check
+
+	G_POINT_CONTENTS,	// ( const vec3_t point, int passEntityNum );
+	// point contents against all linked entities
+
+	G_IN_PVS,			// ( const vec3_t p1, const vec3_t p2 );
+
+	G_IN_PVS_IGNORE_PORTALS,	// ( const vec3_t p1, const vec3_t p2 );
+
+	G_ADJUST_AREA_PORTAL_STATE,	// ( gentity_t *ent, qboolean open );
+
+	G_AREAS_CONNECTED,	// ( int area1, int area2 );
+
+	G_LINKENTITY,		// ( gentity_t *ent );
+	// an entity will never be sent to a client or used for collision
+	// if it is not passed to linkentity.  If the size, position, or
+	// solidity changes, it must be relinked.
+
+	G_UNLINKENTITY,		// ( gentity_t *ent );		
+	// call before removing an interactive entity
+
+	G_ENTITIES_IN_BOX,	// ( const vec3_t mins, const vec3_t maxs, gentity_t **list, int maxcount );
+	// EntitiesInBox will return brush models based on their bounding box,
+	// so exact determination must still be done with EntityContact
+
+	G_ENTITY_CONTACT,	// ( const vec3_t mins, const vec3_t maxs, const gentity_t *ent );
+	// perform an exact check against inline brush models of non-square shape
+
+	// access for bots to get and free a server client (FIXME?)
+	G_BOT_ALLOCATE_CLIENT,	// ( void );
+
+	G_BOT_FREE_CLIENT,	// ( int clientNum );
+
+	G_GET_USERCMD,	// ( int clientNum, usercmd_t *cmd )
+
+	G_GET_ENTITY_TOKEN,	// qboolean ( char *buffer, int bufferSize )
+	// Retrieves the next string token from the entity spawn text, returning
+	// false when all tokens have been parsed.
+	// This should only be done at GAME_INIT time.
+
+	G_SIEGEPERSSET,
+	G_SIEGEPERSGET,
+
+	G_FS_GETFILELIST,
+	G_DEBUG_POLYGON_CREATE,
+	G_DEBUG_POLYGON_DELETE,
+	G_REAL_TIME,
+	G_SNAPVECTOR,
+
+	G_TRACECAPSULE,	// ( trace_t *results, const vec3_t start, const vec3_t mins, const vec3_t maxs, const vec3_t end, int passEntityNum, int contentmask );
+	G_ENTITY_CONTACTCAPSULE,	// ( const vec3_t mins, const vec3_t maxs, const gentity_t *ent );
+
+//	SP_REGISTER_SERVER_CMD,
+	SP_GETSTRINGTEXTSTRING,
+
+	G_ROFF_CLEAN,				// qboolean	ROFF_Clean(void);
+	G_ROFF_UPDATE_ENTITIES,		// void		ROFF_UpdateEntities(void);
+	G_ROFF_CACHE,				// int		ROFF_Cache(char *file);
+	G_ROFF_PLAY,				// qboolean	ROFF_Play(int entID, int roffID, qboolean doTranslation);
+	G_ROFF_PURGE_ENT,			// qboolean ROFF_PurgeEnt( int entID )
+
+	//rww - dynamic vm memory allocation!
+	G_TRUEMALLOC,
+	G_TRUEFREE,
+
+	//rww - icarus traps
+	G_ICARUS_RUNSCRIPT,
+	G_ICARUS_REGISTERSCRIPT,
+
+	G_ICARUS_INIT,
+	G_ICARUS_VALIDENT,
+	G_ICARUS_ISINITIALIZED,
+	G_ICARUS_MAINTAINTASKMANAGER,
+	G_ICARUS_ISRUNNING,
+	G_ICARUS_TASKIDPENDING,
+	G_ICARUS_INITENT,
+	G_ICARUS_FREEENT,
+	G_ICARUS_ASSOCIATEENT,
+	G_ICARUS_SHUTDOWN,
+	G_ICARUS_TASKIDSET,
+	G_ICARUS_TASKIDCOMPLETE,
+	G_ICARUS_SETVAR,
+	G_ICARUS_VARIABLEDECLARED,
+	G_ICARUS_GETFLOATVARIABLE,
+	G_ICARUS_GETSTRINGVARIABLE,
+	G_ICARUS_GETVECTORVARIABLE,
+
+	G_SET_SHARED_BUFFER,
+
+	//BEGIN VM STUFF
+	G_MEMSET = 100,
+	G_MEMCPY,
+	G_STRNCPY,
+	G_SIN,
+	G_COS,
+	G_ATAN2,
+	G_SQRT,
+	G_MATRIXMULTIPLY,
+	G_ANGLEVECTORS,
+	G_PERPENDICULARVECTOR,
+	G_FLOOR,
+	G_CEIL,
+
+	G_TESTPRINTINT,
+	G_TESTPRINTFLOAT,
+
+	G_ACOS,
+	G_ASIN,
+
+	//END VM STUFF
+
+	//rww - BEGIN NPC NAV TRAPS
+	G_NAV_INIT = 200,
+	G_NAV_FREE,
+	G_NAV_LOAD,
+	G_NAV_SAVE,
+	G_NAV_ADDRAWPOINT,
+	G_NAV_CALCULATEPATHS,
+	G_NAV_HARDCONNECT,
+	G_NAV_SHOWNODES,
+	G_NAV_SHOWEDGES,
+	G_NAV_SHOWPATH,
+	G_NAV_GETNEARESTNODE,
+	G_NAV_GETBESTNODE,
+	G_NAV_GETNODEPOSITION,
+	G_NAV_GETNODENUMEDGES,
+	G_NAV_GETNODEEDGE,
+	G_NAV_GETNUMNODES,
+	G_NAV_CONNECTED,
+	G_NAV_GETPATHCOST,
+	G_NAV_GETEDGECOST,
+	G_NAV_GETPROJECTEDNODE,
+	G_NAV_CHECKFAILEDNODES,
+	G_NAV_ADDFAILEDNODE,
+	G_NAV_NODEFAILED,
+	G_NAV_NODESARENEIGHBORS,
+	G_NAV_CLEARFAILEDEDGE,
+	G_NAV_CLEARALLFAILEDEDGES,
+	G_NAV_EDGEFAILED,
+	G_NAV_ADDFAILEDEDGE,
+	G_NAV_CHECKFAILEDEDGE,
+	G_NAV_CHECKALLFAILEDEDGES,
+	G_NAV_ROUTEBLOCKED,
+	G_NAV_GETBESTNODEALTROUTE,
+	G_NAV_GETBESTNODEALT2,
+	G_NAV_GETBESTPATHBETWEENENTS,
+	G_NAV_GETNODERADIUS,
+	G_NAV_CHECKBLOCKEDEDGES,
+	G_NAV_CLEARCHECKEDNODES,
+	G_NAV_CHECKEDNODE,
+	G_NAV_SETCHECKEDNODE,
+	G_NAV_FLAGALLNODES,
+	G_NAV_GETPATHSCALCULATED,
+	G_NAV_SETPATHSCALCULATED,
+	//rww - END NPC NAV TRAPS
+
+	BOTLIB_SETUP = 250,				// ( void );
+	BOTLIB_SHUTDOWN,				// ( void );
+	BOTLIB_LIBVAR_SET,
+	BOTLIB_LIBVAR_GET,
+	BOTLIB_PC_ADD_GLOBAL_DEFINE,
+	BOTLIB_START_FRAME,
+	BOTLIB_LOAD_MAP,
+	BOTLIB_UPDATENTITY,
+	BOTLIB_TEST,
+
+	BOTLIB_GET_SNAPSHOT_ENTITY,		// ( int client, int ent );
+	BOTLIB_GET_CONSOLE_MESSAGE,		// ( int client, char *message, int size );
+	BOTLIB_USER_COMMAND,			// ( int client, usercmd_t *ucmd );
+
+	BOTLIB_AAS_ENABLE_ROUTING_AREA = 300,
+	BOTLIB_AAS_BBOX_AREAS,
+	BOTLIB_AAS_AREA_INFO,
+	BOTLIB_AAS_ENTITY_INFO,
+
+	BOTLIB_AAS_INITIALIZED,
+	BOTLIB_AAS_PRESENCE_TYPE_BOUNDING_BOX,
+	BOTLIB_AAS_TIME,
+
+	BOTLIB_AAS_POINT_AREA_NUM,
+	BOTLIB_AAS_TRACE_AREAS,
+
+	BOTLIB_AAS_POINT_CONTENTS,
+	BOTLIB_AAS_NEXT_BSP_ENTITY,
+	BOTLIB_AAS_VALUE_FOR_BSP_EPAIR_KEY,
+	BOTLIB_AAS_VECTOR_FOR_BSP_EPAIR_KEY,
+	BOTLIB_AAS_FLOAT_FOR_BSP_EPAIR_KEY,
+	BOTLIB_AAS_INT_FOR_BSP_EPAIR_KEY,
+
+	BOTLIB_AAS_AREA_REACHABILITY,
+
+	BOTLIB_AAS_AREA_TRAVEL_TIME_TO_GOAL_AREA,
+
+	BOTLIB_AAS_SWIMMING,
+	BOTLIB_AAS_PREDICT_CLIENT_MOVEMENT,
+
+	BOTLIB_EA_SAY = 400,
+	BOTLIB_EA_SAY_TEAM,
+	BOTLIB_EA_COMMAND,
+
+	BOTLIB_EA_ACTION,
+	BOTLIB_EA_GESTURE,
+	BOTLIB_EA_TALK,
+	BOTLIB_EA_ATTACK,
+	BOTLIB_EA_ALT_ATTACK,
+	BOTLIB_EA_FORCEPOWER,
+	BOTLIB_EA_USE,
+	BOTLIB_EA_RESPAWN,
+	BOTLIB_EA_CROUCH,
+	BOTLIB_EA_MOVE_UP,
+	BOTLIB_EA_MOVE_DOWN,
+	BOTLIB_EA_MOVE_FORWARD,
+	BOTLIB_EA_MOVE_BACK,
+	BOTLIB_EA_MOVE_LEFT,
+	BOTLIB_EA_MOVE_RIGHT,
+
+	BOTLIB_EA_SELECT_WEAPON,
+	BOTLIB_EA_JUMP,
+	BOTLIB_EA_DELAYED_JUMP,
+	BOTLIB_EA_MOVE,
+	BOTLIB_EA_VIEW,
+
+	BOTLIB_EA_END_REGULAR,
+	BOTLIB_EA_GET_INPUT,
+	BOTLIB_EA_RESET_INPUT,
+
+
+	BOTLIB_AI_LOAD_CHARACTER = 500,
+	BOTLIB_AI_FREE_CHARACTER,
+	BOTLIB_AI_CHARACTERISTIC_FLOAT,
+	BOTLIB_AI_CHARACTERISTIC_BFLOAT,
+	BOTLIB_AI_CHARACTERISTIC_INTEGER,
+	BOTLIB_AI_CHARACTERISTIC_BINTEGER,
+	BOTLIB_AI_CHARACTERISTIC_STRING,
+
+	BOTLIB_AI_ALLOC_CHAT_STATE,
+	BOTLIB_AI_FREE_CHAT_STATE,
+	BOTLIB_AI_QUEUE_CONSOLE_MESSAGE,
+	BOTLIB_AI_REMOVE_CONSOLE_MESSAGE,
+	BOTLIB_AI_NEXT_CONSOLE_MESSAGE,
+	BOTLIB_AI_NUM_CONSOLE_MESSAGE,
+	BOTLIB_AI_INITIAL_CHAT,
+	BOTLIB_AI_REPLY_CHAT,
+	BOTLIB_AI_CHAT_LENGTH,
+	BOTLIB_AI_ENTER_CHAT,
+	BOTLIB_AI_STRING_CONTAINS,
+	BOTLIB_AI_FIND_MATCH,
+	BOTLIB_AI_MATCH_VARIABLE,
+	BOTLIB_AI_UNIFY_WHITE_SPACES,
+	BOTLIB_AI_REPLACE_SYNONYMS,
+	BOTLIB_AI_LOAD_CHAT_FILE,
+	BOTLIB_AI_SET_CHAT_GENDER,
+	BOTLIB_AI_SET_CHAT_NAME,
+
+	BOTLIB_AI_RESET_GOAL_STATE,
+	BOTLIB_AI_RESET_AVOID_GOALS,
+	BOTLIB_AI_PUSH_GOAL,
+	BOTLIB_AI_POP_GOAL,
+	BOTLIB_AI_EMPTY_GOAL_STACK,
+	BOTLIB_AI_DUMP_AVOID_GOALS,
+	BOTLIB_AI_DUMP_GOAL_STACK,
+	BOTLIB_AI_GOAL_NAME,
+	BOTLIB_AI_GET_TOP_GOAL,
+	BOTLIB_AI_GET_SECOND_GOAL,
+	BOTLIB_AI_CHOOSE_LTG_ITEM,
+	BOTLIB_AI_CHOOSE_NBG_ITEM,
+	BOTLIB_AI_TOUCHING_GOAL,
+	BOTLIB_AI_ITEM_GOAL_IN_VIS_BUT_NOT_VISIBLE,
+	BOTLIB_AI_GET_LEVEL_ITEM_GOAL,
+	BOTLIB_AI_AVOID_GOAL_TIME,
+	BOTLIB_AI_INIT_LEVEL_ITEMS,
+	BOTLIB_AI_UPDATE_ENTITY_ITEMS,
+	BOTLIB_AI_LOAD_ITEM_WEIGHTS,
+	BOTLIB_AI_FREE_ITEM_WEIGHTS,
+	BOTLIB_AI_SAVE_GOAL_FUZZY_LOGIC,
+	BOTLIB_AI_ALLOC_GOAL_STATE,
+	BOTLIB_AI_FREE_GOAL_STATE,
+
+	BOTLIB_AI_RESET_MOVE_STATE,
+	BOTLIB_AI_MOVE_TO_GOAL,
+	BOTLIB_AI_MOVE_IN_DIRECTION,
+	BOTLIB_AI_RESET_AVOID_REACH,
+	BOTLIB_AI_RESET_LAST_AVOID_REACH,
+	BOTLIB_AI_REACHABILITY_AREA,
+	BOTLIB_AI_MOVEMENT_VIEW_TARGET,
+	BOTLIB_AI_ALLOC_MOVE_STATE,
+	BOTLIB_AI_FREE_MOVE_STATE,
+	BOTLIB_AI_INIT_MOVE_STATE,
+
+	BOTLIB_AI_CHOOSE_BEST_FIGHT_WEAPON,
+	BOTLIB_AI_GET_WEAPON_INFO,
+	BOTLIB_AI_LOAD_WEAPON_WEIGHTS,
+	BOTLIB_AI_ALLOC_WEAPON_STATE,
+	BOTLIB_AI_FREE_WEAPON_STATE,
+	BOTLIB_AI_RESET_WEAPON_STATE,
+
+	BOTLIB_AI_GENETIC_PARENTS_AND_CHILD_SELECTION,
+	BOTLIB_AI_INTERBREED_GOAL_FUZZY_LOGIC,
+	BOTLIB_AI_MUTATE_GOAL_FUZZY_LOGIC,
+	BOTLIB_AI_GET_NEXT_CAMP_SPOT_GOAL,
+	BOTLIB_AI_GET_MAP_LOCATION_GOAL,
+	BOTLIB_AI_NUM_INITIAL_CHATS,
+	BOTLIB_AI_GET_CHAT_MESSAGE,
+	BOTLIB_AI_REMOVE_FROM_AVOID_GOALS,
+	BOTLIB_AI_PREDICT_VISIBLE_POSITION,
+
+	BOTLIB_AI_SET_AVOID_GOAL_TIME,
+	BOTLIB_AI_ADD_AVOID_SPOT,
+	BOTLIB_AAS_ALTERNATIVE_ROUTE_GOAL,
+	BOTLIB_AAS_PREDICT_ROUTE,
+	BOTLIB_AAS_POINT_REACHABILITY_AREA_INDEX,
+
+	BOTLIB_PC_LOAD_SOURCE,
+	BOTLIB_PC_FREE_SOURCE,
+	BOTLIB_PC_READ_TOKEN,
+	BOTLIB_PC_SOURCE_FILE_AND_LINE,
+
+	/*
+Ghoul2 Insert Start
+*/
+	G_R_REGISTERSKIN,
+	G_G2_LISTBONES,
+	G_G2_LISTSURFACES,
+	G_G2_HAVEWEGHOULMODELS,
+	G_G2_SETMODELS,
+	G_G2_GETBOLT,
+	G_G2_GETBOLT_NOREC,
+	G_G2_GETBOLT_NOREC_NOROT,
+	G_G2_INITGHOUL2MODEL,
+	G_G2_SETSKIN,
+	G_G2_SIZE,
+	G_G2_ADDBOLT,
+	G_G2_SETBOLTINFO,
+	G_G2_ANGLEOVERRIDE,
+	G_G2_PLAYANIM,
+	G_G2_GETBONEANIM,
+	G_G2_GETGLANAME,
+	G_G2_COPYGHOUL2INSTANCE,
+	G_G2_COPYSPECIFICGHOUL2MODEL,
+	G_G2_DUPLICATEGHOUL2INSTANCE,
+	G_G2_HASGHOUL2MODELONINDEX,
+	G_G2_REMOVEGHOUL2MODEL,
+	G_G2_REMOVEGHOUL2MODELS,
+	G_G2_CLEANMODELS,
+	G_G2_COLLISIONDETECT,
+
+	G_G2_SETROOTSURFACE,
+	G_G2_SETSURFACEONOFF,
+	G_G2_SETNEWORIGIN,
+	G_G2_DOESBONEEXIST,
+	G_G2_GETSURFACERENDERSTATUS,
+
+	G_G2_ABSURDSMOOTHING,
+
+/*
+	//rww - RAGDOLL_BEGIN
+*/
+	G_G2_SETRAGDOLL,
+	G_G2_ANIMATEG2MODELS,
+/*
+	//rww - RAGDOLL_END
+*/
+	//additional ragdoll options -rww
+	G_G2_RAGPCJCONSTRAINT,
+	G_G2_RAGPCJGRADIENTSPEED,
+	G_G2_RAGEFFECTORGOAL,
+	G_G2_GETRAGBONEPOS,
+	G_G2_RAGEFFECTORKICK,
+	G_G2_RAGFORCESOLVE,
+
+	//rww - ik move method, allows you to specify a bone and move it to a world point (within joint constraints)
+	//by using the majority of gil's existing bone angling stuff from the ragdoll code.
+	G_G2_SETBONEIKSTATE,
+	G_G2_IKMOVE,
+
+	G_G2_REMOVEBONE,
+
+	G_G2_ATTACHINSTANCETOENTNUM,
+	G_G2_CLEARATTACHEDINSTANCE,
+	G_G2_CLEANENTATTACHMENTS,
+	G_G2_OVERRIDESERVER,
+
+	G_G2_GETSURFACENAME,
+
+	G_SET_ACTIVE_SUBBSP,
+	G_CM_REGISTER_TERRAIN,
+	G_RMG_INIT,
+
+	G_BOT_UPDATEWAYPOINTS,
+	G_BOT_CALCULATEPATHS
+/*
+Ghoul2 Insert End
+*/
+
+} gameImport_t;
+
+//bstate.h
+typedef enum //# bState_e
+{//These take over only if script allows them to be autonomous
+	BS_DEFAULT = 0,//# default behavior for that NPC
+	BS_ADVANCE_FIGHT,//# Advance to captureGoal and shoot enemies if you can
+	BS_SLEEP,//# Play awake script when startled by sound
+	BS_FOLLOW_LEADER,//# Follow your leader and shoot any enemies you come across
+	BS_JUMP,//# Face navgoal and jump to it.
+	BS_SEARCH,//# Using current waypoint as a base, search the immediate branches of waypoints for enemies
+	BS_WANDER,//# Wander down random waypoint paths
+	BS_NOCLIP,//# Moves through walls, etc.
+	BS_REMOVE,//# Waits for player to leave PVS then removes itself
+	BS_CINEMATIC,//# Does nothing but face it's angles and move to a goal if it has one
+	//# #eol
+	//internal bStates only
+	BS_WAIT,//# Does nothing but face it's angles
+	BS_STAND_GUARD,
+	BS_PATROL,
+	BS_INVESTIGATE,//# head towards temp goal and look for enemies and listen for sounds
+	BS_STAND_AND_SHOOT,
+	BS_HUNT_AND_KILL,
+	BS_FLEE,//# Run away!
+	NUM_BSTATES
+} bState_t;
+
+enum
+{
+	EDGE_NORMAL,
+	EDGE_PATH,
+	EDGE_BLOCKED,
+	EDGE_FAILED,
+	EDGE_MOVEDIR
+};
+
+enum
+{
+	NODE_NORMAL,
+	NODE_START,
+	NODE_GOAL,
+	NODE_NAVGOAL,
+};
+
+typedef enum //# taskID_e
+{
+	TID_CHAN_VOICE = 0,	// Waiting for a voice sound to complete
+	TID_ANIM_UPPER,		// Waiting to finish a lower anim holdtime
+	TID_ANIM_LOWER,		// Waiting to finish a lower anim holdtime
+	TID_ANIM_BOTH,		// Waiting to finish lower and upper anim holdtimes or normal md3 animating
+	TID_MOVE_NAV,		// Trying to get to a navgoal or For ET_MOVERS
+	TID_ANGLE_FACE,		// Turning to an angle or facing
+	TID_BSTATE,			// Waiting for a certain bState to finish
+	TID_LOCATION,		// Waiting for ent to enter a specific trigger_location
+//	TID_MISSIONSTATUS,	// Waiting for player to finish reading MISSION STATUS SCREEN
+	TID_RESIZE,			// Waiting for clear bbox to inflate size
+	TID_SHOOT,			// Waiting for fire event
+	NUM_TIDS,			// for def of taskID array
+} taskID_t;
+
+typedef enum //# bSet_e
+{//This should check to matching a behavior state name first, then look for a script
+	BSET_INVALID = -1,
+	BSET_FIRST = 0,
+	BSET_SPAWN = 0,//# script to use when first spawned
+	BSET_USE,//# script to use when used
+	BSET_AWAKE,//# script to use when awoken/startled
+	BSET_ANGER,//# script to use when aquire an enemy
+	BSET_ATTACK,//# script to run when you attack
+	BSET_VICTORY,//# script to run when you kill someone
+	BSET_LOSTENEMY,//# script to run when you can't find your enemy
+	BSET_PAIN,//# script to use when take pain
+	BSET_FLEE,//# script to use when take pain below 50% of health
+	BSET_DEATH,//# script to use when killed
+	BSET_DELAYED,//# script to run when self->delayScriptTime is reached
+	BSET_BLOCKED,//# script to run when blocked by a friendly NPC or player
+	BSET_BUMPED,//# script to run when bumped into a friendly NPC or player (can set bumpRadius)
+	BSET_STUCK,//# script to run when blocked by a wall
+	BSET_FFIRE,//# script to run when player shoots their own teammates
+	BSET_FFDEATH,//# script to run when player kills a teammate
+	BSET_MINDTRICK,//# script to run when player does a mind trick on this NPC
+
+	NUM_BSETS
+} bSet_t;
+
+#define	MAX_PARMS	16
+#define	MAX_PARM_STRING_LENGTH	MAX_QPATH//was 16, had to lengthen it so they could take a valid file path
+typedef struct
+{	
+	char	parm[MAX_PARMS][MAX_PARM_STRING_LENGTH];
+} parms_t;
+
+#define MAX_FAILED_NODES 8
+
+typedef struct Vehicle_s Vehicle_t;
+
+// the server looks at a sharedEntity, which is the start of the game's gentity_t structure
+//mod authors should not touch this struct
+typedef struct {
+	entityState_t	s;				// communicated by server to clients
+	playerState_t	*playerState;	//needs to be in the gentity for bg entity access
+									//if you want to actually see the contents I guess
+									//you will have to be sure to VMA it first.
+	Vehicle_t		*m_pVehicle; //vehicle data
+	void			*ghoul2; //g2 instance
+	int				localAnimIndex; //index locally (game/cgame) to anim data for this skel
+	vec3_t			modelScale; //needed for g2 collision
+
+	//from here up must also be unified with bgEntity/centity
+
+	entityShared_t	r;				// shared by both the server system and game
+
+	//Script/ICARUS-related fields
+	int				taskID[NUM_TIDS];
+	parms_t			*parms;
+	char			*behaviorSet[NUM_BSETS];
+	char			*script_targetname;
+	int				delayScriptTime;
+	char			*fullName;
+
+	//rww - targetname and classname are now shared as well. ICARUS needs access to them.
+	char			*targetname;
+	char			*classname;			// set in QuakeEd
+
+	//rww - and yet more things to share. This is because the nav code is in the exe because it's all C++.
+	int				waypoint;			//Set once per frame, if you've moved, and if someone asks
+	int				lastWaypoint;		//To make sure you don't double-back
+	int				lastValidWaypoint;	//ALWAYS valid -used for tracking someone you lost
+	int				noWaypointTime;		//Debouncer - so don't keep checking every waypoint in existance every frame that you can't find one
+	int				combatPoint;
+	int				failedWaypoints[MAX_FAILED_NODES];
+	int				failedWaypointCheckTime;
+
+	int				next_roff_time; //rww - npc's need to know when they're getting roff'd
+} sharedEntity_t;
+
+#ifdef __cplusplus
+class CSequencer;
+class CTaskManager;
+
+//I suppose this could be in another in-engine header or something. But we never want to
+//include an icarus file before sharedentity_t is declared.
+extern CSequencer	*gSequencers[MAX_GENTITIES];
+extern CTaskManager	*gTaskManagers[MAX_GENTITIES];
+
+#include "../icarus/icarus.h"
+#include "../icarus/sequencer.h"
+#include "../icarus/taskmanager.h"
+#endif
+
+//
+// functions exported by the game subsystem
+//
+typedef enum {
+	GAME_INIT,	// ( int levelTime, int randomSeed, int restart );
+	// init and shutdown will be called every single level
+	// The game should call G_GET_ENTITY_TOKEN to parse through all the
+	// entity configuration text and spawn gentities.
+
+	GAME_SHUTDOWN,	// (void);
+
+	GAME_CLIENT_CONNECT,	// ( int clientNum, qboolean firstTime, qboolean isBot );
+	// return NULL if the client is allowed to connect, otherwise return
+	// a text string with the reason for denial
+
+	GAME_CLIENT_BEGIN,				// ( int clientNum );
+
+	GAME_CLIENT_USERINFO_CHANGED,	// ( int clientNum );
+
+	GAME_CLIENT_DISCONNECT,			// ( int clientNum );
+
+	GAME_CLIENT_COMMAND,			// ( int clientNum );
+
+	GAME_CLIENT_THINK,				// ( int clientNum );
+
+	GAME_RUN_FRAME,					// ( int levelTime );
+
+	GAME_CONSOLE_COMMAND,			// ( void );
+	// ConsoleCommand will be called when a command has been issued
+	// that is not recognized as a builtin function.
+	// The game can issue trap_argc() / trap_argv() commands to get the command
+	// and parameters.  Return qfalse if the game doesn't recognize it as a command.
+
+	BOTAI_START_FRAME,				// ( int time );
+
+	GAME_ROFF_NOTETRACK_CALLBACK,	// int entnum, char *notetrack
+
+	GAME_SPAWN_RMG_ENTITY, //rwwRMG - added
+
+	//rww - icarus callbacks
+	GAME_ICARUS_PLAYSOUND,
+	GAME_ICARUS_SET,
+	GAME_ICARUS_LERP2POS,
+	GAME_ICARUS_LERP2ORIGIN,
+	GAME_ICARUS_LERP2ANGLES,
+	GAME_ICARUS_GETTAG,
+	GAME_ICARUS_LERP2START,
+	GAME_ICARUS_LERP2END,
+	GAME_ICARUS_USE,
+	GAME_ICARUS_KILL,
+	GAME_ICARUS_REMOVE,
+	GAME_ICARUS_PLAY,
+	GAME_ICARUS_GETFLOAT,
+	GAME_ICARUS_GETVECTOR,
+	GAME_ICARUS_GETSTRING,
+	GAME_ICARUS_SOUNDINDEX,
+	GAME_ICARUS_GETSETIDFORSTRING,
+	GAME_NAV_CLEARPATHTOPOINT,
+	GAME_NAV_CLEARLOS,
+	GAME_NAV_CLEARPATHBETWEENPOINTS,
+	GAME_NAV_CHECKNODEFAILEDFORENT,
+	GAME_NAV_ENTISUNLOCKEDDOOR,
+	GAME_NAV_ENTISDOOR,
+	GAME_NAV_ENTISBREAKABLE,
+	GAME_NAV_ENTISREMOVABLEUSABLE,
+	GAME_NAV_FINDCOMBATPOINTWAYPOINTS,
+	
+	GAME_GETITEMINDEXBYTAG
+} gameExport_t;
+
+typedef struct
+{
+	int taskID;
+	int entID;
+	char name[2048];
+	char channel[2048];
+} T_G_ICARUS_PLAYSOUND;
+
+
+typedef struct
+{
+	int taskID;
+	int entID;
+	char type_name[2048];
+	char data[2048];
+} T_G_ICARUS_SET;
+
+typedef struct
+{
+	int taskID;
+	int entID; 
+	vec3_t origin;
+	vec3_t angles;
+	float duration;
+	qboolean nullAngles; //special case
+} T_G_ICARUS_LERP2POS;
+
+typedef struct
+{
+	int taskID;
+	int entID;
+	vec3_t origin;
+	float duration;
+} T_G_ICARUS_LERP2ORIGIN;
+
+typedef struct
+{
+	int taskID;
+	int entID;
+	vec3_t angles;
+	float duration;
+} T_G_ICARUS_LERP2ANGLES;
+
+typedef struct
+{
+	int entID;
+	char name[2048];
+	int lookup;
+	vec3_t info;
+} T_G_ICARUS_GETTAG;
+
+typedef struct
+{
+	int entID;
+	int taskID;
+	float duration;
+} T_G_ICARUS_LERP2START;
+
+typedef struct
+{
+	int entID;
+	int taskID;
+	float duration;
+} T_G_ICARUS_LERP2END;
+
+typedef struct
+{
+	int entID;
+	char target[2048];
+} T_G_ICARUS_USE;
+
+typedef struct
+{
+	int entID;
+	char name[2048];
+} T_G_ICARUS_KILL;
+
+typedef struct
+{
+	int entID;
+	char name[2048];
+} T_G_ICARUS_REMOVE;
+
+typedef struct
+{
+	int taskID;
+	int entID;
+	char type[2048];
+	char name[2048];
+} T_G_ICARUS_PLAY;
+
+typedef struct
+{
+	int entID;
+	int type;
+	char name[2048];
+	float value;
+} T_G_ICARUS_GETFLOAT;
+
+typedef struct
+{
+	int entID;
+	int type;
+	char name[2048];
+	vec3_t value;
+} T_G_ICARUS_GETVECTOR;
+
+typedef struct
+{
+	int entID;
+	int type;
+	char name[2048];
+	char value[2048];
+} T_G_ICARUS_GETSTRING;
+
+typedef struct
+{
+	char filename[2048];
+} T_G_ICARUS_SOUNDINDEX;
+typedef struct
+{
+	char string[2048];
+} T_G_ICARUS_GETSETIDFORSTRING;
+
+#endif //G_PUBLIC_H
diff --git a/codemp/game/g_saga.c b/codemp/game/g_saga.c
new file mode 100644
index 0000000..3de8101
--- /dev/null
+++ b/codemp/game/g_saga.c
@@ -0,0 +1,1884 @@
+// Copyright (C) 2000-2002 Raven Software, Inc.
+//
+/*****************************************************************************
+ * name:		g_saga.c
+ *
+ * desc:		Game-side module for Siege gametype.
+ *
+ * $Author: Rich Whitehouse $ 
+ * $Revision: 1.6 $
+ *
+ *****************************************************************************/
+#include "g_local.h"
+#include "bg_saga.h"
+
+#define SIEGEITEM_STARTOFFRADAR 8
+
+static char		team1[512];
+static char		team2[512];
+
+siegePers_t	g_siegePersistant = {qfalse, 0, 0};
+
+int			imperial_goals_required = 0;
+int			imperial_goals_completed = 0;
+int			rebel_goals_required = 0;
+int			rebel_goals_completed = 0;
+
+int			imperial_time_limit = 0;
+int			rebel_time_limit = 0;
+
+int			gImperialCountdown = 0;
+int			gRebelCountdown = 0;
+
+int			rebel_attackers = 0;
+int			imperial_attackers = 0;
+
+qboolean	gSiegeRoundBegun = qfalse;
+qboolean	gSiegeRoundEnded = qfalse;
+int			gSiegeBeginTime = Q3_INFINITE;
+
+int			g_preroundState = 0; //default to starting as spec (1 is starting ingame)
+
+void LogExit( const char *string );
+void SetTeamQuick(gentity_t *ent, int team, qboolean doBegin);
+
+static char gParseObjectives[MAX_SIEGE_INFO_SIZE];
+static char gObjectiveCfgStr[1024];
+
+//go through all classes on a team and register their
+//weapons and items for precaching.
+void G_SiegeRegisterWeaponsAndHoldables(int team)
+{
+	siegeTeam_t *stm = BG_SiegeFindThemeForTeam(team);
+
+	if (stm)
+	{
+		int i = 0;
+		siegeClass_t *scl;
+		while (i < stm->numClasses)
+		{
+			scl = stm->classes[i];
+
+			if (scl)
+			{
+				int j = 0;
+				while (j < WP_NUM_WEAPONS)
+				{
+					if (scl->weapons & (1 << j))
+					{ //we use this weapon so register it.
+						RegisterItem(BG_FindItemForWeapon(j));
+					}
+					j++;
+				}
+				j = 0;
+				while (j < HI_NUM_HOLDABLE)
+				{
+					if (scl->invenItems & (1 << j))
+					{ //we use this item so register it.
+						RegisterItem(BG_FindItemForHoldable(j));
+					}
+					j++;
+				}
+			}
+			i++;
+		}
+	}
+}
+
+//tell clients that this team won and print it on their scoreboard for intermission
+//or whatever.
+void SiegeSetCompleteData(int team)
+{
+	trap_SetConfigstring(CS_SIEGE_WINTEAM, va("%i", team));
+}
+
+void InitSiegeMode(void)
+{
+	vmCvar_t		mapname;
+	char			levelname[512];
+	char			teamIcon[128];
+	char			goalreq[64];
+	char			teams[2048];
+	char			objective[MAX_SIEGE_INFO_SIZE];
+	char			objecStr[8192];
+	int				len = 0;
+	int				i = 0;
+//	int				j = 0;
+	int				objectiveNumTeam1 = 0;
+	int				objectiveNumTeam2 = 0;
+	fileHandle_t	f;
+
+	if (g_gametype.integer != GT_SIEGE)
+	{
+		goto failure;
+	}
+
+	//reset
+	SiegeSetCompleteData(0);
+
+	//get pers data in case it existed from last level
+	if (g_siegeTeamSwitch.integer)
+	{
+		trap_SiegePersGet(&g_siegePersistant);
+		if (g_siegePersistant.beatingTime)
+		{
+			trap_SetConfigstring(CS_SIEGE_TIMEOVERRIDE, va("%i", g_siegePersistant.lastTime));
+		}
+		else
+		{
+			trap_SetConfigstring(CS_SIEGE_TIMEOVERRIDE, "0");
+		}
+	}
+	else
+	{ //hmm, ok, nothing.
+		trap_SetConfigstring(CS_SIEGE_TIMEOVERRIDE, "0");
+	}
+
+	imperial_goals_completed = 0;
+	rebel_goals_completed = 0;
+
+	trap_Cvar_Register( &mapname, "mapname", "", CVAR_SERVERINFO | CVAR_ROM );
+
+	Com_sprintf(levelname, sizeof(levelname), "maps/%s.siege\0", mapname.string);
+
+	if (!levelname || !levelname[0])
+	{
+		goto failure;
+	}
+
+	len = trap_FS_FOpenFile(levelname, &f, FS_READ);
+
+	if (!f || len >= MAX_SIEGE_INFO_SIZE)
+	{
+		goto failure;
+	}
+
+	trap_FS_Read(siege_info, len, f);
+
+	trap_FS_FCloseFile(f);
+
+	siege_valid = 1;
+
+	//See if players should be specs or ingame preround
+	if (BG_SiegeGetPairedValue(siege_info, "preround_state", teams))
+	{
+		if (teams[0])
+		{
+			g_preroundState = atoi(teams);
+		}
+	}
+
+	if (BG_SiegeGetValueGroup(siege_info, "Teams", teams))
+	{
+		if (g_siegeTeam1.string[0] && Q_stricmp(g_siegeTeam1.string, "none"))
+		{ //check for override
+			strcpy(team1, g_siegeTeam1.string);
+		}
+		else
+		{ //otherwise use level default
+			BG_SiegeGetPairedValue(teams, "team1", team1);
+		}
+
+		if (g_siegeTeam2.string[0] && Q_stricmp(g_siegeTeam2.string, "none"))
+		{ //check for override
+			strcpy(team2, g_siegeTeam2.string);
+		}
+		else
+		{ //otherwise use level default
+			BG_SiegeGetPairedValue(teams, "team2", team2);
+		}
+	}
+	else
+	{
+		G_Error("Siege teams not defined");
+	}
+
+	if (BG_SiegeGetValueGroup(siege_info, team2, gParseObjectives))
+	{
+		if (BG_SiegeGetPairedValue(gParseObjectives, "TeamIcon", teamIcon))
+		{
+			trap_Cvar_Set( "team2_icon", teamIcon);
+		}
+
+		if (BG_SiegeGetPairedValue(gParseObjectives, "RequiredObjectives", goalreq))
+		{
+			rebel_goals_required = atoi(goalreq);
+		}
+		if (BG_SiegeGetPairedValue(gParseObjectives, "Timed", goalreq))
+		{
+			rebel_time_limit = atoi(goalreq)*1000;
+			if (g_siegeTeamSwitch.integer &&
+				g_siegePersistant.beatingTime)
+			{
+				gRebelCountdown = level.time + g_siegePersistant.lastTime;
+			}
+			else
+			{
+				gRebelCountdown = level.time + rebel_time_limit;
+			}
+		}
+		if (BG_SiegeGetPairedValue(gParseObjectives, "attackers", goalreq))
+		{
+			rebel_attackers = atoi(goalreq);
+		}
+	}
+
+	if (BG_SiegeGetValueGroup(siege_info, team1, gParseObjectives))
+	{
+
+		if (BG_SiegeGetPairedValue(gParseObjectives, "TeamIcon", teamIcon))
+		{
+			trap_Cvar_Set( "team1_icon", teamIcon);
+		}
+
+		if (BG_SiegeGetPairedValue(gParseObjectives, "RequiredObjectives", goalreq))
+		{
+			imperial_goals_required = atoi(goalreq);
+		}
+		if (BG_SiegeGetPairedValue(gParseObjectives, "Timed", goalreq))
+		{
+			if (rebel_time_limit)
+			{
+				Com_Printf("Tried to set imperial time limit, but there's already a rebel time limit!\nOnly one team can have a time limit.\n");
+			}
+			else
+			{
+				imperial_time_limit = atoi(goalreq)*1000;
+				if (g_siegeTeamSwitch.integer &&
+					g_siegePersistant.beatingTime)
+				{
+					gImperialCountdown = level.time + g_siegePersistant.lastTime;
+				}
+				else
+				{
+					gImperialCountdown = level.time + imperial_time_limit;
+				}
+			}
+		}
+		if (BG_SiegeGetPairedValue(gParseObjectives, "attackers", goalreq))
+		{
+			imperial_attackers = atoi(goalreq);
+		}
+	}
+
+	//Load the player class types
+	BG_SiegeLoadClasses(NULL);
+
+	if (!bgNumSiegeClasses)
+	{ //We didn't find any?!
+		G_Error("Couldn't find any player classes for Siege");
+	}
+
+	/*
+	//We could probably just see what teams are used on this level,
+	//then see what classes are used by those teams, and then precache
+	//all weapons for said classes. However, I'm just going to do them
+	//all for now.
+	while (i < bgNumSiegeClasses)
+	{
+		cl = &bgSiegeClasses[i];
+		j = 0;
+
+		while (j < WP_NUM_WEAPONS)
+		{
+			if (cl->weapons & (1 << j))
+			{ //we use this weapon so register it.
+				RegisterItem(BG_FindItemForWeapon(j));
+			}
+
+			j++;
+		}
+
+		i++;
+	}
+	*/
+	//Ok, I'm adding inventory item precaching now, so I'm finally going to optimize this
+	//to only do weapons/items for the current teams used on the level.
+
+	//Now load the teams since we have class data.
+	BG_SiegeLoadTeams();
+
+	if (!bgNumSiegeTeams)
+	{ //React same as with classes.
+		G_Error("Couldn't find any player teams for Siege");
+	}
+
+	//Get and set the team themes for each team. This will control which classes can be
+	//used on each team.
+	if (BG_SiegeGetValueGroup(siege_info, team1, gParseObjectives))
+	{
+		if (BG_SiegeGetPairedValue(gParseObjectives, "UseTeam", goalreq))
+		{
+			BG_SiegeSetTeamTheme(SIEGETEAM_TEAM1, goalreq);
+		}
+
+		//Now count up the objectives for this team.
+		i = 1;
+		strcpy(objecStr, va("Objective%i", i));
+		while (BG_SiegeGetValueGroup(gParseObjectives, objecStr, objective))
+		{
+			objectiveNumTeam1++;
+			i++;
+			strcpy(objecStr, va("Objective%i", i));
+		}
+	}
+	if (BG_SiegeGetValueGroup(siege_info, team2, gParseObjectives))
+	{
+		if (BG_SiegeGetPairedValue(gParseObjectives, "UseTeam", goalreq))
+		{
+			BG_SiegeSetTeamTheme(SIEGETEAM_TEAM2, goalreq);
+		}
+
+		//Now count up the objectives for this team.
+		i = 1;
+		strcpy(objecStr, va("Objective%i", i));
+		while (BG_SiegeGetValueGroup(gParseObjectives, objecStr, objective))
+		{
+			objectiveNumTeam2++;
+			i++;
+			strcpy(objecStr, va("Objective%i", i));
+		}
+	}
+
+	//Set the configstring to show status of all current objectives
+	strcpy(gObjectiveCfgStr, "t1");
+	while (objectiveNumTeam1 > 0)
+	{ //mark them all as not completed since we just initialized
+		Q_strcat(gObjectiveCfgStr, 1024, "-0");
+		objectiveNumTeam1--;
+	}
+	//Finished doing team 1's objectives, now do team 2's
+	Q_strcat(gObjectiveCfgStr, 1024, "|t2");
+	while (objectiveNumTeam2 > 0)
+	{
+		Q_strcat(gObjectiveCfgStr, 1024, "-0");
+		objectiveNumTeam2--;
+	}
+
+	//And finally set the actual config string
+	trap_SetConfigstring(CS_SIEGE_OBJECTIVES, gObjectiveCfgStr);
+
+	//precache saber data for classes that use sabers on both teams
+	BG_PrecacheSabersForSiegeTeam(SIEGETEAM_TEAM1);
+	BG_PrecacheSabersForSiegeTeam(SIEGETEAM_TEAM2);
+
+	G_SiegeRegisterWeaponsAndHoldables(SIEGETEAM_TEAM1);
+	G_SiegeRegisterWeaponsAndHoldables(SIEGETEAM_TEAM2);
+
+	return;
+
+failure:
+	siege_valid = 0;
+}
+
+void G_SiegeSetObjectiveComplete(int team, int objective, qboolean failIt)
+{
+	char *p = NULL;
+	int onObjective = 0;
+
+	if (team == SIEGETEAM_TEAM1)
+	{
+		p = strstr(gObjectiveCfgStr, "t1");
+	}
+	else if (team == SIEGETEAM_TEAM2)
+	{
+		p = strstr(gObjectiveCfgStr, "t2");
+	}
+
+	if (!p)
+	{
+		assert(0);
+		return;
+	}
+
+	//Parse from the beginning of this team's objectives until we get to the desired objective
+	//number.
+	while (p && *p && *p != '|')
+	{
+		if (*p == '-')
+		{
+			onObjective++;
+		}
+
+		if (onObjective == objective)
+		{ //this is the one we want
+			//Move to the next char, the status of this objective
+			p++;
+
+			//Now change it from '0' to '1' if we are completeing the objective
+			//or vice versa if the objective has been taken away
+			if (failIt)
+			{
+				*p = '0';
+			}
+			else
+			{
+				*p = '1';
+			}
+			break;
+		}
+
+		p++;
+	}
+
+	//Now re-update the configstring.
+	trap_SetConfigstring(CS_SIEGE_OBJECTIVES, gObjectiveCfgStr);
+}
+
+//Returns qtrue if objective complete currently, otherwise qfalse
+qboolean G_SiegeGetCompletionStatus(int team, int objective)
+{
+	char *p = NULL;
+	int onObjective = 0;
+
+	if (team == SIEGETEAM_TEAM1)
+	{
+		p = strstr(gObjectiveCfgStr, "t1");
+	}
+	else if (team == SIEGETEAM_TEAM2)
+	{
+		p = strstr(gObjectiveCfgStr, "t2");
+	}
+
+	if (!p)
+	{
+		assert(0);
+		return qfalse;
+	}
+
+	//Parse from the beginning of this team's objectives until we get to the desired objective
+	//number.
+	while (p && *p && *p != '|')
+	{
+		if (*p == '-')
+		{
+			onObjective++;
+		}
+
+		if (onObjective == objective)
+		{ //this is the one we want
+			//Move to the next char, the status of this objective
+			p++;
+
+			//return qtrue if it's '1', qfalse if it's anything else
+			if (*p == '1')
+			{
+				return qtrue;
+			}
+			else
+			{
+				return qfalse;
+			}
+			break;
+		}
+
+		p++;
+	}
+
+	return qfalse;
+}
+
+void UseSiegeTarget(gentity_t *other, gentity_t *en, char *target)
+{ //actually use the player which triggered the object which triggered the siege objective to trigger the target
+	gentity_t		*t;
+	gentity_t		*ent;
+
+	if ( !en || !en->client )
+	{ //looks like we don't have access to a player, so just use the activating entity
+		ent = other;
+	}
+	else
+	{
+		ent = en;
+	}
+
+	if (!en)
+	{
+		return;
+	}
+
+	if ( !target )
+	{
+		return;
+	}
+
+	t = NULL;
+	while ( (t = G_Find (t, FOFS(targetname), target)) != NULL )
+	{
+		if ( t == ent )
+		{
+			G_Printf ("WARNING: Entity used itself.\n");
+		}
+		else
+		{
+			if ( t->use )
+			{
+				GlobalUse(t, ent, ent);
+			}
+		}
+		if ( !ent->inuse )
+		{
+			G_Printf("entity was removed while using targets\n");
+			return;
+		}
+	}
+}
+
+void SiegeBroadcast_OBJECTIVECOMPLETE(int team, int client, int objective)
+{
+	gentity_t *te;
+	vec3_t nomatter;
+
+	VectorClear(nomatter);
+
+	te = G_TempEntity( nomatter, EV_SIEGE_OBJECTIVECOMPLETE );
+	te->r.svFlags |= SVF_BROADCAST;
+	te->s.eventParm = team;
+	te->s.weapon = client;
+	te->s.trickedentindex = objective;
+}
+
+void SiegeBroadcast_ROUNDOVER(int winningteam, int winningclient)
+{
+	gentity_t *te;
+	vec3_t nomatter;
+
+	VectorClear(nomatter);
+
+	te = G_TempEntity( nomatter, EV_SIEGE_ROUNDOVER );
+	te->r.svFlags |= SVF_BROADCAST;
+	te->s.eventParm = winningteam;
+	te->s.weapon = winningclient;
+}
+
+void BroadcastObjectiveCompletion(int team, int objective, int final, int client)
+{
+	if (client != ENTITYNUM_NONE && g_entities[client].client && g_entities[client].client->sess.sessionTeam == team)
+	{ //guy who completed this objective gets points, providing he's on the opposing team
+		AddScore(&g_entities[client], g_entities[client].client->ps.origin, SIEGE_POINTS_OBJECTIVECOMPLETED);
+	}
+
+	SiegeBroadcast_OBJECTIVECOMPLETE(team, client, objective);
+	//G_Printf("Broadcast goal completion team %i objective %i final %i\n", team, objective, final);
+}
+
+void AddSiegeWinningTeamPoints(int team, int winner)
+{
+	int i = 0;
+	gentity_t *ent;
+
+	while (i < MAX_CLIENTS)
+	{
+		ent = &g_entities[i];
+
+		if (ent && ent->client && ent->client->sess.sessionTeam == team)
+		{
+			if (i == winner)
+			{
+				AddScore(ent, ent->client->ps.origin, SIEGE_POINTS_TEAMWONROUND+SIEGE_POINTS_FINALOBJECTIVECOMPLETED);
+			}
+			else
+			{
+				AddScore(ent, ent->client->ps.origin, SIEGE_POINTS_TEAMWONROUND);
+			}
+		}
+
+		i++;
+	}
+}
+
+void SiegeClearSwitchData(void)
+{
+	memset(&g_siegePersistant, 0, sizeof(g_siegePersistant));
+	trap_SiegePersSet(&g_siegePersistant);
+}
+
+void SiegeDoTeamAssign(void)
+{
+	int i = 0;
+	gentity_t *ent;
+
+	//yeah, this is great...
+	while (i < MAX_CLIENTS)
+	{
+		ent = &g_entities[i];
+
+		if (ent->inuse && ent->client &&
+			ent->client->pers.connected == CON_CONNECTED)
+		{ //a connected client, switch his frickin teams around
+			if (ent->client->sess.siegeDesiredTeam == SIEGETEAM_TEAM1)
+			{
+				ent->client->sess.siegeDesiredTeam = SIEGETEAM_TEAM2;
+			}
+			else if (ent->client->sess.siegeDesiredTeam == SIEGETEAM_TEAM2)
+			{
+				ent->client->sess.siegeDesiredTeam = SIEGETEAM_TEAM1;
+			}
+
+			if (ent->client->sess.sessionTeam == SIEGETEAM_TEAM1)
+			{
+				SetTeamQuick(ent, SIEGETEAM_TEAM2, qfalse);
+			}
+			else if (ent->client->sess.sessionTeam == SIEGETEAM_TEAM2)
+			{
+				SetTeamQuick(ent, SIEGETEAM_TEAM1, qfalse);
+			}
+		}
+		i++;
+	}
+}
+
+void SiegeTeamSwitch(int winTeam, int winTime)
+{
+	trap_SiegePersGet(&g_siegePersistant);
+	if (g_siegePersistant.beatingTime)
+	{ //was already in "switched" mode, change back
+		//announce the winning team.
+		//either the first team won again, or the second
+		//team beat the time set by the initial team. In any
+		//case the winTeam here is the overall winning team.
+		SiegeSetCompleteData(winTeam);
+		SiegeClearSwitchData();
+	}
+	else
+	{ //go into "beat their time" mode
+		g_siegePersistant.beatingTime = qtrue;
+        g_siegePersistant.lastTeam = winTeam;
+		g_siegePersistant.lastTime = winTime;
+
+		trap_SiegePersSet(&g_siegePersistant);
+	}
+}
+
+void SiegeRoundComplete(int winningteam, int winningclient)
+{
+	vec3_t nomatter;
+	char teamstr[1024];
+	int originalWinningClient = winningclient;
+
+	//G_Printf("Team %i won\n", winningteam);
+
+	if (winningclient != ENTITYNUM_NONE && g_entities[winningclient].client &&
+		g_entities[winningclient].client->sess.sessionTeam != winningteam)
+	{ //this person just won the round for the other team..
+		winningclient = ENTITYNUM_NONE;
+	}
+
+	VectorClear(nomatter);
+
+	SiegeBroadcast_ROUNDOVER(winningteam, winningclient);
+
+	AddSiegeWinningTeamPoints(winningteam, winningclient);
+
+	//Instead of exiting like this, fire off a target, and let it handle things.
+	//Can be a script or whatever the designer wants.
+   	if (winningteam == SIEGETEAM_TEAM1)
+	{
+		Com_sprintf(teamstr, sizeof(teamstr), team1);
+	}
+	else
+	{
+		Com_sprintf(teamstr, sizeof(teamstr), team2);
+	}
+
+	trap_SetConfigstring(CS_SIEGE_STATE, va("3|%i", level.time)); //ended
+	gSiegeRoundBegun = qfalse;
+	gSiegeRoundEnded = qtrue;
+
+	if (BG_SiegeGetValueGroup(siege_info, teamstr, gParseObjectives))
+	{
+		if (!BG_SiegeGetPairedValue(gParseObjectives, "roundover_target", teamstr))
+		{ //didn't find the name of the thing to target upon win, just logexit now then.
+			LogExit( "Objectives completed" );
+			return;
+		}
+		
+		if (originalWinningClient == ENTITYNUM_NONE)
+		{ //oh well, just find something active and use it then.
+            int i = 0;
+			gentity_t *ent;
+
+			while (i < MAX_CLIENTS)
+			{
+				ent = &g_entities[i];
+
+				if (ent->inuse)
+				{ //sure, you'll do.
+                    originalWinningClient = ent->s.number;
+					break;
+				}
+
+				i++;
+			}
+		}
+		G_UseTargets2(&g_entities[originalWinningClient], &g_entities[originalWinningClient], teamstr);
+	}
+
+	if (g_siegeTeamSwitch.integer &&
+		(imperial_time_limit || rebel_time_limit))
+	{ //handle stupid team switching crap
+		int time = 0;
+		if (imperial_time_limit)
+		{
+			time = imperial_time_limit-(gImperialCountdown-level.time);
+		}
+		else if (rebel_time_limit)
+		{
+			time = rebel_time_limit-(gRebelCountdown-level.time);
+		}
+
+		if (time < 1)
+		{
+			time = 1;
+		}
+		SiegeTeamSwitch(winningteam, time);
+	}
+	else
+	{ //assure it's clear for next round
+		SiegeClearSwitchData();
+	}
+}
+
+void G_ValidateSiegeClassForTeam(gentity_t *ent, int team)
+{
+	siegeClass_t *scl;
+	siegeTeam_t *stm;
+	int newClassIndex = -1;
+	if (ent->client->siegeClass == -1)
+	{ //uh.. sure.
+		return;
+	}
+
+	scl = &bgSiegeClasses[ent->client->siegeClass];
+
+	stm = BG_SiegeFindThemeForTeam(team);
+	if (stm)
+	{
+		int i = 0;
+
+		while (i < stm->numClasses)
+		{ //go through the team and see its valid classes, can we find one that matches our current player class?
+			if (stm->classes[i])
+			{
+				if (!Q_stricmp(scl->name, stm->classes[i]->name))
+				{ //the class we're using is already ok for this team.
+					return;
+				}
+				if (stm->classes[i]->playerClass == scl->playerClass ||
+					newClassIndex == -1)
+				{
+					newClassIndex = i;
+				}
+			}
+			i++;
+		}
+
+		if (newClassIndex != -1)
+		{ //ok, let's find it in the global class array
+			ent->client->siegeClass = BG_SiegeFindClassIndexByName(stm->classes[newClassIndex]->name);
+			strcpy(ent->client->sess.siegeClass, stm->classes[newClassIndex]->name);
+		}
+	}
+}
+
+//bypass most of the normal checks in SetTeam
+void SetTeamQuick(gentity_t *ent, int team, qboolean doBegin)
+{
+	char userinfo[MAX_INFO_STRING];
+
+	trap_GetUserinfo( ent->s.number, userinfo, sizeof( userinfo ) );
+
+	if (g_gametype.integer == GT_SIEGE)
+	{
+		G_ValidateSiegeClassForTeam(ent, team);
+	}
+
+	ent->client->sess.sessionTeam = team;
+
+	if (team == TEAM_SPECTATOR)
+	{
+		ent->client->sess.spectatorState = SPECTATOR_FREE;
+		Info_SetValueForKey(userinfo, "team", "s");
+	}
+	else
+	{
+		ent->client->sess.spectatorState = SPECTATOR_NOT;
+		if (team == TEAM_RED)
+		{
+			Info_SetValueForKey(userinfo, "team", "r");
+		}
+		else if (team == TEAM_BLUE)
+		{
+			Info_SetValueForKey(userinfo, "team", "b");
+		}
+		else
+		{
+			Info_SetValueForKey(userinfo, "team", "?");
+		}
+	}
+
+	trap_SetUserinfo( ent->s.number, userinfo );
+
+	ent->client->sess.spectatorClient = 0;
+
+	ent->client->pers.teamState.state = TEAM_BEGIN;
+
+	ClientUserinfoChanged( ent->s.number );
+
+	if (doBegin)
+	{
+		ClientBegin( ent->s.number, qfalse );
+	}
+}
+
+void SiegeRespawn(gentity_t *ent)
+{
+	gentity_t *tent;
+
+	if (ent->client->sess.sessionTeam != ent->client->sess.siegeDesiredTeam)
+	{
+		SetTeamQuick(ent, ent->client->sess.siegeDesiredTeam, qtrue);
+	}
+	else
+	{
+		ClientSpawn(ent);
+		// add a teleportation effect
+		tent = G_TempEntity( ent->client->ps.origin, EV_PLAYER_TELEPORT_IN );
+		tent->s.clientNum = ent->s.clientNum;
+	}
+}
+
+void SiegeBeginRound(int entNum)
+{ //entNum is just used as something to fire targets from.
+	char targname[1024];
+
+	if (!g_preroundState)
+	{ //if players are not ingame on round start then respawn them now
+		int i = 0;
+		gentity_t *ent;
+		qboolean spawnEnt = qfalse;
+
+		//respawn everyone now
+		while (i < MAX_CLIENTS)
+		{
+			ent = &g_entities[i];
+
+			if (ent->inuse && ent->client)
+			{
+				if (ent->client->sess.sessionTeam != TEAM_SPECTATOR &&
+					!(ent->client->ps.pm_flags & PMF_FOLLOW))
+				{ //not a spec, just respawn them
+					spawnEnt = qtrue;
+				}
+				else if (ent->client->sess.sessionTeam == TEAM_SPECTATOR &&
+					(ent->client->sess.siegeDesiredTeam == TEAM_RED ||
+					 ent->client->sess.siegeDesiredTeam == TEAM_BLUE))
+				{ //spectator but has a desired team
+					spawnEnt = qtrue;
+				}
+			}
+
+			if (spawnEnt)
+			{
+				SiegeRespawn(ent);
+
+				spawnEnt = qfalse;
+			}
+			i++;
+		}
+	}
+
+	//Now check if there's something to fire off at the round start, if so do it.
+	if (BG_SiegeGetPairedValue(siege_info, "roundbegin_target", targname))
+	{
+		if (targname[0])
+		{
+			G_UseTargets2(&g_entities[entNum], &g_entities[entNum], targname);
+		}
+	}
+
+	trap_SetConfigstring(CS_SIEGE_STATE, va("0|%i", level.time)); //we're ready to g0g0g0
+}
+
+void SiegeCheckTimers(void)
+{
+	int i=0;
+	gentity_t *ent;
+	int numTeam1 = 0;
+	int numTeam2 = 0;
+
+	if (g_gametype.integer != GT_SIEGE)
+	{
+		return;
+	}
+
+	if (level.intermissiontime)
+	{
+		return;
+	}
+
+	if (gSiegeRoundEnded)
+	{
+		return;
+	}
+
+	if (!gSiegeRoundBegun)
+	{ //check if anyone is active on this team - if not, keep the timer set up.
+		i = 0;
+
+		while (i < MAX_CLIENTS)
+		{
+			ent = &g_entities[i];
+
+			if (ent && ent->inuse && ent->client &&
+				ent->client->pers.connected == CON_CONNECTED &&
+				ent->client->sess.siegeDesiredTeam == SIEGETEAM_TEAM1)
+			{
+				numTeam1++;
+			}
+			i++;
+		}
+
+		i = 0;
+
+		while (i < MAX_CLIENTS)
+		{
+			ent = &g_entities[i];
+
+			if (ent && ent->inuse && ent->client &&
+				ent->client->pers.connected == CON_CONNECTED &&
+				ent->client->sess.siegeDesiredTeam == SIEGETEAM_TEAM2)
+			{
+				numTeam2++;
+			}
+			i++;
+		}
+
+		if (g_siegeTeamSwitch.integer &&
+			g_siegePersistant.beatingTime)
+		{
+			gImperialCountdown = level.time + g_siegePersistant.lastTime;
+			gRebelCountdown = level.time + g_siegePersistant.lastTime;
+		}
+		else
+		{
+			gImperialCountdown = level.time + imperial_time_limit;
+			gRebelCountdown = level.time + rebel_time_limit;
+		}
+	}
+
+	if (imperial_time_limit)
+	{ //team1
+		if (gImperialCountdown < level.time)
+		{
+			SiegeRoundComplete(SIEGETEAM_TEAM2, ENTITYNUM_NONE);
+			imperial_time_limit = 0;
+			return;
+		}
+	}
+
+	if (rebel_time_limit)
+	{ //team2
+		if (gRebelCountdown < level.time)
+		{
+			SiegeRoundComplete(SIEGETEAM_TEAM1, ENTITYNUM_NONE);
+			rebel_time_limit = 0;
+			return;
+		}
+	}
+
+	if (!gSiegeRoundBegun)
+	{
+		if (!numTeam1 || !numTeam2)
+		{ //don't have people on both teams yet.
+			gSiegeBeginTime = level.time + SIEGE_ROUND_BEGIN_TIME;
+			trap_SetConfigstring(CS_SIEGE_STATE, "1"); //"waiting for players on both teams"
+		}
+		else if (gSiegeBeginTime < level.time)
+		{ //mark the round as having begun
+			gSiegeRoundBegun = qtrue;
+			SiegeBeginRound(i); //perform any round start tasks
+		}
+		else if (gSiegeBeginTime > (level.time + SIEGE_ROUND_BEGIN_TIME))
+		{
+			gSiegeBeginTime = level.time + SIEGE_ROUND_BEGIN_TIME;
+		}
+		else
+		{
+			trap_SetConfigstring(CS_SIEGE_STATE, va("2|%i", gSiegeBeginTime - SIEGE_ROUND_BEGIN_TIME)); //getting ready to begin
+		}
+	}
+}
+
+void SiegeObjectiveCompleted(int team, int objective, int final, int client)
+{
+	int goals_completed, goals_required;
+
+	if (gSiegeRoundEnded)
+	{
+		return;
+	}
+
+	//Update the configstring status
+	G_SiegeSetObjectiveComplete(team, objective, qfalse);
+
+	if (final != -1)
+	{
+		if (team == SIEGETEAM_TEAM1)
+		{
+			imperial_goals_completed++;
+		}
+		else
+		{
+			rebel_goals_completed++;
+		}
+	}
+
+	if (team == SIEGETEAM_TEAM1)
+	{
+		goals_completed = imperial_goals_completed;
+		goals_required = imperial_goals_required;
+	}
+	else
+	{
+		goals_completed = rebel_goals_completed;
+		goals_required = rebel_goals_required;
+	}
+
+	if (final == 1 || goals_completed >= goals_required)
+	{
+		SiegeRoundComplete(team, client);
+	}
+	else
+	{
+		BroadcastObjectiveCompletion(team, objective, final, client);
+	}
+}
+
+void siegeTriggerUse(gentity_t *ent, gentity_t *other, gentity_t *activator)
+{
+	char			teamstr[64];
+	char			objectivestr[64];
+	char			desiredobjective[MAX_SIEGE_INFO_SIZE];
+	int				clUser = ENTITYNUM_NONE;
+	int				final = 0;
+	int				i = 0;
+
+	if (!siege_valid)
+	{
+		return;
+	}
+
+	if (!(ent->s.eFlags & EF_RADAROBJECT))
+	{ //toggle radar on and exit if it is not showing up already
+		ent->s.eFlags |= EF_RADAROBJECT;
+		return;
+	}
+
+	if (activator && activator->client)
+	{ //activator will hopefully be the person who triggered this event
+		clUser = activator->s.number;
+	}
+
+	if (ent->side == SIEGETEAM_TEAM1)
+	{
+		Com_sprintf(teamstr, sizeof(teamstr), team1);
+	}
+	else
+	{
+		Com_sprintf(teamstr, sizeof(teamstr), team2);
+	}
+
+	if (BG_SiegeGetValueGroup(siege_info, teamstr, gParseObjectives))
+	{
+		Com_sprintf(objectivestr, sizeof(objectivestr), "Objective%i", ent->objective);
+
+		if (BG_SiegeGetValueGroup(gParseObjectives, objectivestr, desiredobjective))
+		{
+			if (BG_SiegeGetPairedValue(desiredobjective, "final", teamstr))
+			{
+				final = atoi(teamstr);
+			}
+
+			if (BG_SiegeGetPairedValue(desiredobjective, "target", teamstr))
+			{
+				while (teamstr[i])
+				{
+					if (teamstr[i] == '\r' ||
+						teamstr[i] == '\n')
+					{
+						teamstr[i] = '\0';
+					}
+
+					i++;
+				}
+				UseSiegeTarget(other, activator, teamstr);
+			}
+
+			if (ent->target && ent->target[0])
+			{ //use this too
+				UseSiegeTarget(other, activator, ent->target);
+			}
+
+			SiegeObjectiveCompleted(ent->side, ent->objective, final, clUser);
+		}
+	}
+}
+
+/*QUAKED info_siege_objective (1 0 1) (-16 -16 -24) (16 16 32) ? x x STARTOFFRADAR
+STARTOFFRADAR - start not displaying on radar, don't display until used.
+
+"objective" - specifies the objective to complete upon activation
+"side" - set to 1 to specify an imperial goal, 2 to specify rebels
+"icon" - icon that represents the objective on the radar
+*/
+void SP_info_siege_objective (gentity_t *ent)
+{
+	char* s;
+
+	if (!siege_valid || g_gametype.integer != GT_SIEGE)
+	{
+		G_FreeEntity(ent);
+		return;
+	}
+
+	ent->use = siegeTriggerUse;
+	G_SpawnInt( "objective", "0", &ent->objective);
+	G_SpawnInt( "side", "0", &ent->side);
+
+	if (!ent->objective || !ent->side)
+	{ //j00 fux0red something up
+		G_FreeEntity(ent);
+		G_Printf("ERROR: info_siege_objective without an objective or side value\n");
+		return;
+	}
+
+	//Set it up to be drawn on radar
+	if (!(ent->spawnflags & SIEGEITEM_STARTOFFRADAR))
+	{
+		ent->s.eFlags |= EF_RADAROBJECT;
+	}
+
+	//All clients want to know where it is at all times for radar
+	ent->r.svFlags |= SVF_BROADCAST;
+
+	G_SpawnString( "icon", "", &s );
+	
+	if (s && s[0])
+	{ 
+		// We have an icon, so index it now.  We are reusing the genericenemyindex
+		// variable rather than adding a new one to the entity state.
+		ent->s.genericenemyindex = G_IconIndex(s);
+	}
+
+	ent->s.brokenLimbs = ent->side;
+	ent->s.frame = ent->objective;
+	trap_LinkEntity(ent);
+}
+
+
+void SiegeIconUse(gentity_t *ent, gentity_t *other, gentity_t *activator)
+{ //toggle it on and off
+	if (ent->s.eFlags & EF_RADAROBJECT)
+	{
+		ent->s.eFlags &= ~EF_RADAROBJECT;
+		ent->r.svFlags &= ~SVF_BROADCAST;
+	}
+	else
+	{
+		ent->s.eFlags |= EF_RADAROBJECT;
+		ent->r.svFlags |= SVF_BROADCAST;
+	}
+}
+
+/*QUAKED info_siege_radaricon (1 0 1) (-16 -16 -24) (16 16 32) ? 
+Used to arbitrarily display radar icons at placed location. Can be used
+to toggle on and off.
+
+"icon" - icon that represents the objective on the radar
+"startoff" - if 1 start off
+*/
+void SP_info_siege_radaricon (gentity_t *ent)
+{
+	char* s;
+	int i;
+
+	if (!siege_valid || g_gametype.integer != GT_SIEGE)
+	{
+		G_FreeEntity(ent);
+		return;
+	}
+
+	G_SpawnInt("startoff", "0", &i);
+
+	if (!i)
+	{ //start on then
+		ent->s.eFlags |= EF_RADAROBJECT;
+		ent->r.svFlags |= SVF_BROADCAST;
+	}
+
+	G_SpawnString( "icon", "", &s );
+	if (!s || !s[0])
+	{ //that's the whole point of the entity
+        Com_Error(ERR_DROP, "misc_siege_radaricon without an icon");
+		return;
+	}
+
+	ent->use = SiegeIconUse;
+
+	ent->s.genericenemyindex = G_IconIndex(s);
+
+	trap_LinkEntity(ent);
+}
+
+void decompTriggerUse(gentity_t *ent, gentity_t *other, gentity_t *activator)
+{
+	int final = 0;
+	char teamstr[1024];
+	char objectivestr[64];
+	char desiredobjective[MAX_SIEGE_INFO_SIZE];
+
+	if (gSiegeRoundEnded)
+	{
+		return;
+	}
+
+	if (!G_SiegeGetCompletionStatus(ent->side, ent->objective))
+	{ //if it's not complete then there's nothing to do here
+		return;
+	}
+
+	//Update the configstring status
+	G_SiegeSetObjectiveComplete(ent->side, ent->objective, qtrue);
+
+	//Find out if this objective counts toward the final objective count
+   	if (ent->side == SIEGETEAM_TEAM1)
+	{
+		Com_sprintf(teamstr, sizeof(teamstr), team1);
+	}
+	else
+	{
+		Com_sprintf(teamstr, sizeof(teamstr), team2);
+	}
+
+	if (BG_SiegeGetValueGroup(siege_info, teamstr, gParseObjectives))
+	{
+		Com_sprintf(objectivestr, sizeof(objectivestr), "Objective%i", ent->objective);
+
+		if (BG_SiegeGetValueGroup(gParseObjectives, objectivestr, desiredobjective))
+		{
+			if (BG_SiegeGetPairedValue(desiredobjective, "final", teamstr))
+			{
+				final = atoi(teamstr);
+			}
+		}
+	}
+
+	//Subtract the goal num if applicable
+	if (final != -1)
+	{
+		if (ent->side == SIEGETEAM_TEAM1)
+		{
+			imperial_goals_completed--;
+		}
+		else
+		{
+			rebel_goals_completed--;
+		}
+	}
+}
+
+/*QUAKED info_siege_decomplete (1 0 1) (-16 -16 -24) (16 16 32)
+"objective" - specifies the objective to decomplete upon activation
+"side" - set to 1 to specify an imperial (team1) goal, 2 to specify rebels (team2)
+*/
+void SP_info_siege_decomplete (gentity_t *ent)
+{
+	if (!siege_valid || g_gametype.integer != GT_SIEGE)
+	{
+		G_FreeEntity(ent);
+		return;
+	}
+
+	ent->use = decompTriggerUse;
+	G_SpawnInt( "objective", "0", &ent->objective);
+	G_SpawnInt( "side", "0", &ent->side);
+
+	if (!ent->objective || !ent->side)
+	{ //j00 fux0red something up
+		G_FreeEntity(ent);
+		G_Printf("ERROR: info_siege_objective_decomplete without an objective or side value\n");
+		return;
+	}
+}
+
+void siegeEndUse(gentity_t *ent, gentity_t *other, gentity_t *activator)
+{
+	LogExit("Round ended");
+}
+
+/*QUAKED target_siege_end (1 0 1) (-16 -16 -24) (16 16 32)
+Do a logexit for siege when used.
+*/
+void SP_target_siege_end (gentity_t *ent)
+{
+	if (!siege_valid || g_gametype.integer != GT_SIEGE)
+	{
+		G_FreeEntity(ent);
+		return;
+	}
+
+	ent->use = siegeEndUse;
+}
+
+#define SIEGE_ITEM_RESPAWN_TIME 20000
+
+void SiegeItemRemoveOwner(gentity_t *ent, gentity_t *carrier)
+{
+	ent->genericValue2 = 0; //Remove picked-up flag
+
+	ent->genericValue8 = ENTITYNUM_NONE; //Mark entity carrying us as none
+
+	if (carrier)
+	{
+		carrier->client->holdingObjectiveItem = 0; //The carrier is no longer carrying us
+		carrier->r.svFlags &= ~SVF_BROADCAST;
+	}
+}
+
+static void SiegeItemRespawnEffect(gentity_t *ent, vec3_t newOrg)
+{
+	vec3_t upAng;
+
+	if (ent->target5 && ent->target5[0])
+	{
+		G_UseTargets2(ent, ent, ent->target5);
+	}
+
+	if (!ent->genericValue10)
+	{ //no respawn effect
+		return;
+	}
+
+	VectorSet(upAng, 0, 0, 1);
+
+	//Play it once on the current origin, and once on the origin we're respawning to.
+	G_PlayEffectID(ent->genericValue10, ent->r.currentOrigin, upAng);
+	G_PlayEffectID(ent->genericValue10, newOrg, upAng);
+}
+
+static void SiegeItemRespawnOnOriginalSpot(gentity_t *ent, gentity_t *carrier)
+{
+	SiegeItemRespawnEffect(ent, ent->pos1);
+	G_SetOrigin(ent, ent->pos1);
+	SiegeItemRemoveOwner(ent, carrier);
+	
+	// Stop the item from flashing on the radar
+	ent->s.time2 = 0;
+}
+
+void SiegeItemThink(gentity_t *ent)
+{
+	gentity_t *carrier = NULL;
+
+	if (ent->genericValue12)
+	{ //recharge health
+		if (ent->health > 0 && ent->health < ent->maxHealth && ent->genericValue14 < level.time)
+		{
+            ent->genericValue14 = level.time + ent->genericValue13;
+			ent->health += ent->genericValue12;
+			if (ent->health > ent->maxHealth)
+			{
+				ent->health = ent->maxHealth;
+			}
+		}
+	}
+
+	if (ent->genericValue8 != ENTITYNUM_NONE)
+	{ //Just keep sticking it on top of the owner. We need it in the same PVS as him so it will render bolted onto him properly.
+		carrier = &g_entities[ent->genericValue8];
+
+		if (carrier->inuse && carrier->client)
+		{
+			VectorCopy(carrier->client->ps.origin, ent->r.currentOrigin);
+			trap_LinkEntity(ent);
+		}
+	}
+	else if (ent->genericValue1)
+	{ //this means we want to run physics on the object
+		G_RunExPhys(ent, ent->radius, ent->mass, ent->random, qfalse, NULL, 0);
+	}
+
+	//Bolt us to whoever is carrying us if a client
+	if (ent->genericValue8 < MAX_CLIENTS)
+	{
+		ent->s.boltToPlayer = ent->genericValue8+1;
+	}
+	else
+	{
+		ent->s.boltToPlayer = 0;
+	}
+
+
+	if (carrier)
+	{
+		gentity_t *carrier = &g_entities[ent->genericValue8];
+
+		//This checking can be a bit iffy on the death stuff, but in theory we should always
+		//get a think in before the default minimum respawn time is exceeded.
+		if (!carrier->inuse || !carrier->client ||
+			(carrier->client->sess.sessionTeam != SIEGETEAM_TEAM1 && carrier->client->sess.sessionTeam != SIEGETEAM_TEAM2) ||
+			(carrier->client->ps.pm_flags & PMF_FOLLOW))
+		{ //respawn on the original spot
+			SiegeItemRespawnOnOriginalSpot(ent, NULL);
+		}
+		else if (carrier->health < 1)
+		{ //The carrier died so pop out where he is (unless in nodrop).
+			if (ent->target6 && ent->target6[0])
+			{
+				G_UseTargets2(ent, ent, ent->target6);
+			}
+
+			if ( trap_PointContents(carrier->client->ps.origin, carrier->s.number) & CONTENTS_NODROP )
+			{ //In nodrop land, go back to the original spot.
+				SiegeItemRespawnOnOriginalSpot(ent, carrier);
+			}
+			else
+			{
+				G_SetOrigin(ent, carrier->client->ps.origin);
+				ent->epVelocity[0] = Q_irand(-80, 80);
+				ent->epVelocity[1] = Q_irand(-80, 80);
+				ent->epVelocity[2] = Q_irand(40, 80);
+
+				//We're in a nonstandard place, so if we go this long without being touched,
+				//assume we may not be reachable and respawn on the original spot.
+				ent->genericValue9 = level.time + SIEGE_ITEM_RESPAWN_TIME;
+
+				SiegeItemRemoveOwner(ent, carrier);
+			}
+		}
+	}
+
+	if (ent->genericValue9 && ent->genericValue9 < level.time)
+	{ //time to respawn on the original spot then
+		SiegeItemRespawnEffect(ent, ent->pos1);
+		G_SetOrigin(ent, ent->pos1);
+		ent->genericValue9 = 0;
+		
+		// stop flashing on radar
+		ent->s.time2 = 0;
+	}
+
+	ent->nextthink = level.time + FRAMETIME/2;
+}
+
+void SiegeItemTouch( gentity_t *self, gentity_t *other, trace_t *trace )
+{
+	if (!other || !other->inuse ||
+		!other->client || other->s.eType == ET_NPC)
+	{
+		if (trace && trace->startsolid)
+		{ //let me out! (ideally this should not happen, but such is life)
+			vec3_t escapePos;
+			VectorCopy(self->r.currentOrigin, escapePos);
+			escapePos[2] += 1.0f;
+
+			//I hope you weren't stuck in the ceiling.
+			G_SetOrigin(self, escapePos);
+		}
+		return;
+	}
+
+	if (other->health < 1)
+	{ //dead people can't pick us up.
+		return;
+	}
+
+	if (other->client->holdingObjectiveItem)
+	{ //this guy's already carrying a siege item
+		return;
+	}
+
+	if ( other->client->ps.pm_type == PM_SPECTATOR )
+	{//spectators don't pick stuff up
+		return;
+	}
+
+	if (self->genericValue2)
+	{ //Am I already picked up?
+		return;
+	}
+
+	if (self->genericValue6 == other->client->sess.sessionTeam)
+	{ //Set to not be touchable by players on this team.
+		return;
+	}
+
+	if (!gSiegeRoundBegun)
+	{ //can't pick it up if round hasn't started yet
+		return;
+	}
+
+	if (self->noise_index)
+	{ //play the pickup noise.
+		G_Sound(other, CHAN_AUTO, self->noise_index);
+	}
+
+	self->genericValue2 = 1; //Mark it as picked up.
+
+	other->client->holdingObjectiveItem = self->s.number;
+	other->r.svFlags |= SVF_BROADCAST; //broadcast player while he carries this
+	self->genericValue8 = other->s.number; //Keep the index so we know who is "carrying" us
+
+	self->genericValue9 = 0; //So it doesn't think it has to respawn.
+
+	if (self->target2 && self->target2[0] && (!self->genericValue4 || !self->genericValue5))
+	{ //fire the target for pickup, if it's set to fire every time, or set to only fire the first time and the first time has not yet occured.
+		G_UseTargets2(self, self, self->target2);
+		self->genericValue5 = 1; //mark it as having been picked up
+	}	
+	
+	// time2 set to -1 will blink the item on the radar indefinately
+	self->s.time2 = 0xFFFFFFFF;
+}
+
+void SiegeItemPain(gentity_t *self, gentity_t *attacker, int damage)
+{
+	// Time 2 is used to pulse the radar icon to show its under attack
+	self->s.time2 = level.time;
+}
+
+void SiegeItemDie( gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int meansOfDeath )
+{
+	self->takedamage = qfalse; //don't die more than once
+
+	if (self->genericValue3)
+	{ //An indexed effect to play on death
+		vec3_t upAng;
+
+		VectorSet(upAng, 0, 0, 1);
+		G_PlayEffectID(self->genericValue3, self->r.currentOrigin, upAng);
+	}
+
+	self->neverFree = qfalse;
+	self->think = G_FreeEntity;
+	self->nextthink = level.time;
+
+	//Fire off the death target if we've got one.
+	if (self->target4 && self->target4[0])
+	{
+		G_UseTargets2(self, self, self->target4);
+	}
+}
+
+void SiegeItemUse(gentity_t *ent, gentity_t *other, gentity_t *activator)
+{ //once used, become active
+	if (ent->spawnflags & SIEGEITEM_STARTOFFRADAR)
+	{ //start showing on radar
+		ent->s.eFlags |= EF_RADAROBJECT;
+
+		if (!(ent->s.eFlags & EF_NODRAW))
+		{ //we've nothing else to do here
+			return;
+		}
+	}
+	else
+	{ //make sure it's showing up
+		ent->s.eFlags |= EF_RADAROBJECT;
+	}
+
+	if (ent->genericValue11 || !ent->takedamage)
+	{ //We want to be able to walk into it to pick it up then.
+		ent->r.contents = CONTENTS_TRIGGER;
+		ent->clipmask = CONTENTS_SOLID|CONTENTS_TERRAIN;
+		if (ent->genericValue11)
+		{
+			ent->touch = SiegeItemTouch;
+		}
+	}
+	else
+	{ //Make it solid.
+		ent->r.contents = MASK_PLAYERSOLID;
+		ent->clipmask = MASK_PLAYERSOLID;
+	}
+
+	ent->think = SiegeItemThink;
+	ent->nextthink = level.time + FRAMETIME/2;
+
+	//take off nodraw
+	ent->s.eFlags &= ~EF_NODRAW;
+
+	if (ent->paintarget && ent->paintarget[0])
+	{ //want to be on this guy's origin now then
+		gentity_t *targ = G_Find (NULL, FOFS(targetname), ent->paintarget);
+		
+		if (targ && targ->inuse)
+		{
+			G_SetOrigin(ent, targ->r.currentOrigin);
+			trap_LinkEntity(ent);
+		}
+	}
+}
+
+/*QUAKED misc_siege_item (1 0 1) (-16 -16 -24) (16 16 32) ? x x STARTOFFRADAR
+STARTOFFRADAR - start not displaying on radar, don't display until used.
+
+"model"				Name of model to use for the object
+"mins"				Actual mins of the object. Careful not to place it into a solid,
+					as these new mins will not be reflected visually in the editor.
+					Default value is "-16 -16 -24".
+"maxs"				Same as above for maxs. Default value is "16 16 32".
+"targetname"		If it has a targetname, it will only spawn upon being used.
+"target2"			Target to fire upon pickup. If none, nothing will happen.
+"pickuponlyonce"	If non-0, target2 will only be fired on the first pickup. If the item is
+					dropped and picked up again later, the target will not be fired off on
+					the sequential pickup. Default value is 1.
+"target3"			Target to fire upon delivery of the item to the goal point.
+					If none, nothing will happen. (but you should always want something to happen)
+"health"			If > 0, object can be damaged and will die once health reaches 0. Default is 0.
+"showhealth"		if health > 0, will show a health meter for this item
+"teamowner"			Which team owns this item, used only for deciding what color to make health meter
+"target4"			Target to fire upon death, if damageable. Default is none.
+"deathfx"			Effect to play on death, if damageable. Default is none.
+"canpickup"			If non-0, item can be picked up. Otherwise it will just be solid and sit on the
+					ground. Default is 1.
+"pickupsound"		Sound to play on pickup, if any.
+"goaltarget"		Must be the targetname of a trigger_multi/trigger_once. Once a player carrying
+					this object is brought inside the specified trigger, then that trigger will be
+					allowed to fire. Ideally it will target a siege objective or something like that.
+"usephysics"		If non-0, run standard physics on the object. Default is 1.
+"mass"				If usephysics, this will be the factored object mass. Default is 0.09.
+"gravity"			If usephysics, this will be the factored gravitational pull. Default is 3.0.
+"bounce"			If usephysics, this will be the factored bounce amount. Default is 1.3.
+"teamnotouch"		If 1 don't let team 1 pickup, if 2 don't let team 2. By default both teams
+					can pick this object up and carry it around until death.
+"teamnocomplete"	Same values as above, but controls if this object can be taken into the objective
+					area by said team.
+"respawnfx"			Plays this effect when respawning (e.g. it is left in an unknown area too long
+					and goes back to the original spot). If this is not specified there will be
+					no effect. (expected format is .efx file)
+"paintarget"		plop self on top of this guy's origin when we are used (only applies if the siege
+					item has a targetname)
+"noradar"			if non-0 this thing will not show up on radar
+
+"forcelimit"		if non-0, while carrying this item, the carrier's force powers will be crippled.
+"target5"			target to fire when respawning.
+"target6"			target to fire when dropped by someone carrying this item.
+
+"icon"				icon that represents the gametype item on the radar
+
+health charge things only work with showhealth 1 on siege items that take damage.
+"health_chargeamt"	if non-0 will recharge this much health every...
+"health_chargerate"	...this many milliseconds
+*/
+void SP_misc_siege_item (gentity_t *ent)
+{
+	int		canpickup;
+	int		noradar;
+	char	*s;
+
+	if (!siege_valid || g_gametype.integer != GT_SIEGE)
+	{
+		G_FreeEntity(ent);
+		return;
+	}
+
+	if (!ent->model || !ent->model[0])
+	{
+		G_Error("You must specify a model for misc_siege_item types.");
+	}
+
+	G_SpawnInt("canpickup", "1", &canpickup);
+	G_SpawnInt("usephysics", "1", &ent->genericValue1);
+
+	if (ent->genericValue1)
+	{ //if we're using physics we want lerporigin smoothing
+		ent->s.eFlags |= EF_CLIENTSMOOTH;
+	}
+
+	G_SpawnInt("noradar", "0", &noradar);
+	//Want it to always show up as a goal object on radar
+	if (!noradar && !(ent->spawnflags & SIEGEITEM_STARTOFFRADAR))
+	{
+		ent->s.eFlags |= EF_RADAROBJECT;
+	}
+
+	//All clients want to know where it is at all times for radar
+	ent->r.svFlags |= SVF_BROADCAST;
+
+	G_SpawnInt("pickuponlyonce", "1", &ent->genericValue4);
+
+	G_SpawnInt("teamnotouch", "0", &ent->genericValue6);
+	G_SpawnInt("teamnocomplete", "0", &ent->genericValue7);
+	
+	//Get default physics values.
+	G_SpawnFloat("mass", "0.09", &ent->mass);
+	G_SpawnFloat("gravity", "3.0", &ent->radius);
+	G_SpawnFloat("bounce", "1.3", &ent->random);
+
+	G_SpawnString( "pickupsound", "", &s );
+
+	if (s && s[0])
+	{ //We have a pickup sound, so index it now.
+		ent->noise_index = G_SoundIndex(s);
+	}
+
+	G_SpawnString( "deathfx", "", &s );
+
+	if (s && s[0])
+	{ //We have a death effect, so index it now.
+		ent->genericValue3 = G_EffectIndex(s);
+	}
+
+	G_SpawnString( "respawnfx", "", &s );
+
+	if (s && s[0])
+	{ //We have a respawn effect, so index it now.
+		ent->genericValue10 = G_EffectIndex(s);
+	}
+
+	G_SpawnString( "icon", "", &s );
+	
+	if (s && s[0])
+	{ 
+		// We have an icon, so index it now.  We are reusing the genericenemyindex
+		// variable rather than adding a new one to the entity state.
+		ent->s.genericenemyindex = G_IconIndex(s);
+	}
+	
+	ent->s.modelindex = G_ModelIndex(ent->model);
+
+	//Is the model a ghoul2 model?
+	if (!Q_stricmp(&ent->model[strlen(ent->model) - 4], ".glm"))
+	{ //apparently so.
+        ent->s.modelGhoul2 = 1;
+	}
+
+	ent->s.eType = ET_GENERAL;
+
+	//Set the mins/maxs with default values.
+	G_SpawnVector("mins", "-16 -16 -24", ent->r.mins);
+	G_SpawnVector("maxs", "16 16 32", ent->r.maxs);
+
+	VectorCopy(ent->s.origin, ent->pos1); //store off the initial origin for respawning
+	G_SetOrigin(ent, ent->s.origin);
+
+	VectorCopy(ent->s.angles, ent->r.currentAngles);
+	VectorCopy(ent->s.angles, ent->s.apos.trBase);
+
+	G_SpawnInt("forcelimit", "0", &ent->genericValue15);
+
+	if (ent->health > 0)
+	{ //If it has health, it can be killed.
+		int t;
+
+		ent->pain = SiegeItemPain;
+		ent->die = SiegeItemDie;
+		ent->takedamage = qtrue;
+
+		G_SpawnInt( "showhealth", "0", &t );
+		if (t)
+		{ //a non-0 maxhealth value will mean we want to show the health on the hud
+			ent->maxHealth = ent->health;
+			G_ScaleNetHealth(ent);
+
+			G_SpawnInt( "health_chargeamt", "0", &ent->genericValue12);
+			G_SpawnInt( "health_chargerate", "0", &ent->genericValue13);
+		}
+	}
+	else
+	{ //Otherwise no.
+		ent->takedamage = qfalse;
+	}
+
+	if (ent->spawnflags & SIEGEITEM_STARTOFFRADAR)
+	{
+		ent->use = SiegeItemUse;
+	}
+	else if (ent->targetname && ent->targetname[0])
+	{
+		ent->s.eFlags |= EF_NODRAW; //kind of hacky, but whatever
+		ent->genericValue11 = canpickup;
+        ent->use = SiegeItemUse;
+		ent->s.eFlags &= ~EF_RADAROBJECT;
+	}
+
+	if ( (!ent->targetname || !ent->targetname[0]) ||
+		 (ent->spawnflags & SIEGEITEM_STARTOFFRADAR) )
+	{
+		if (canpickup || !ent->takedamage)
+		{ //We want to be able to walk into it to pick it up then.
+			ent->r.contents = CONTENTS_TRIGGER;
+			ent->clipmask = CONTENTS_SOLID|CONTENTS_TERRAIN;
+			if (canpickup)
+			{
+				ent->touch = SiegeItemTouch;
+			}
+		}
+		else
+		{ //Make it solid.
+			ent->r.contents = MASK_PLAYERSOLID;
+			ent->clipmask = MASK_PLAYERSOLID;
+		}
+
+		ent->think = SiegeItemThink;
+		ent->nextthink = level.time + FRAMETIME/2;
+	}
+
+	ent->genericValue8 = ENTITYNUM_NONE; //initialize the carrier to none
+
+	ent->neverFree = qtrue; //never free us unless we specifically request it.
+
+	trap_LinkEntity(ent);
+}
+
+//sends extra data about other client's in this client's PVS
+//used for support guy etc.
+//with this formatting:
+//sxd 16,999,999,999|17,999,999,999
+//assumed max 2 chars for cl num, 3 chars per ammo/health/maxhealth, even a single string full of
+//info for all 32 clients should not get much past 450 bytes, which is well within a
+//reasonable range. We don't need to send anything about the max ammo or current weapon, because
+//currentState.weapon can be checked for the ent in question on the client. -rww
+void G_SiegeClientExData(gentity_t *msgTarg)
+{
+	gentity_t *ent;
+	int count = 0;
+	int i = 0;
+	char str[MAX_STRING_CHARS];
+	char scratch[MAX_STRING_CHARS];
+
+	while (i < level.num_entities && count < MAX_EXDATA_ENTS_TO_SEND)
+	{
+		ent = &g_entities[i];
+
+		if (ent->inuse && ent->client && msgTarg->s.number != ent->s.number &&
+			ent->s.eType == ET_PLAYER && msgTarg->client->sess.sessionTeam == ent->client->sess.sessionTeam &&
+			trap_InPVS(msgTarg->client->ps.origin, ent->client->ps.origin))
+		{ //another client in the same pvs, send his jive
+            if (count)
+			{ //append a seperating space if we are not the first in the list
+				Q_strcat(str, sizeof(str), " ");
+			}
+			else
+			{ //otherwise create the prepended chunk
+				strcpy(str, "sxd ");
+			}
+
+			//append the stats
+			Com_sprintf(scratch, sizeof(scratch), "%i|%i|%i|%i", ent->s.number, ent->client->ps.stats[STAT_HEALTH],
+				ent->client->ps.stats[STAT_MAX_HEALTH], ent->client->ps.ammo[weaponData[ent->client->ps.weapon].ammoIndex]);
+			Q_strcat(str, sizeof(str), scratch);
+			count++;
+		}
+		i++;
+	}
+
+	if (!count)
+	{ //nothing to send
+		return;
+	}
+
+	//send the string to him
+	trap_SendServerCommand(msgTarg-g_entities, str);
+}
diff --git a/codemp/game/g_session.c b/codemp/game/g_session.c
new file mode 100644
index 0000000..6c0452e
--- /dev/null
+++ b/codemp/game/g_session.c
@@ -0,0 +1,322 @@
+// Copyright (C) 1999-2000 Id Software, Inc.
+//
+#include "g_local.h"
+
+
+/*
+=======================================================================
+
+  SESSION DATA
+
+Session data is the only data that stays persistant across level loads
+and tournament restarts.
+=======================================================================
+*/
+
+/*
+================
+G_WriteClientSessionData
+
+Called on game shutdown
+================
+*/
+void G_WriteClientSessionData( gclient_t *client ) {
+	const char	*s;
+	const char	*var;
+	int			i = 0;
+	char		siegeClass[64];
+	char		saberType[64];
+	char		saber2Type[64];
+
+	strcpy(siegeClass, client->sess.siegeClass);
+
+	while (siegeClass[i])
+	{ //sort of a hack.. we don't want spaces by siege class names have spaces so convert them all to unused chars
+		if (siegeClass[i] == ' ')
+		{
+			siegeClass[i] = 1;
+		}
+
+		i++;
+	}
+
+	if (!siegeClass[0])
+	{ //make sure there's at least something
+		strcpy(siegeClass, "none");
+	}
+
+	//Do the same for the saber
+	strcpy(saberType, client->sess.saberType);
+
+	i = 0;
+	while (saberType[i])
+	{
+		if (saberType[i] == ' ')
+		{
+			saberType[i] = 1;
+		}
+
+		i++;
+	}
+
+	strcpy(saber2Type, client->sess.saber2Type);
+
+	i = 0;
+	while (saber2Type[i])
+	{
+		if (saber2Type[i] == ' ')
+		{
+			saber2Type[i] = 1;
+		}
+
+		i++;
+	}
+
+	s = va("%i %i %i %i %i %i %i %i %i %i %i %i %s %s %s", 
+		client->sess.sessionTeam,
+		client->sess.spectatorTime,
+		client->sess.spectatorState,
+		client->sess.spectatorClient,
+		client->sess.wins,
+		client->sess.losses,
+		client->sess.teamLeader,
+		client->sess.setForce,
+		client->sess.saberLevel,
+		client->sess.selectedFP,
+		client->sess.duelTeam,
+		client->sess.siegeDesiredTeam,
+		siegeClass,
+		saberType,
+		saber2Type
+		);
+
+	var = va( "session%i", client - level.clients );
+
+	trap_Cvar_Set( var, s );
+}
+
+/*
+================
+G_ReadSessionData
+
+Called on a reconnect
+================
+*/
+void G_ReadSessionData( gclient_t *client ) {
+	char	s[MAX_STRING_CHARS];
+	const char	*var;
+	int			i = 0;
+
+	// bk001205 - format
+	int teamLeader;
+	int spectatorState;
+	int sessionTeam;
+
+	var = va( "session%i", client - level.clients );
+	trap_Cvar_VariableStringBuffer( var, s, sizeof(s) );
+
+	sscanf( s, "%i %i %i %i %i %i %i %i %i %i %i %i %s %s %s",
+		&sessionTeam,                 // bk010221 - format
+		&client->sess.spectatorTime,
+		&spectatorState,              // bk010221 - format
+		&client->sess.spectatorClient,
+		&client->sess.wins,
+		&client->sess.losses,
+		&teamLeader,                   // bk010221 - format
+		&client->sess.setForce,
+		&client->sess.saberLevel,
+		&client->sess.selectedFP,
+		&client->sess.duelTeam,
+		&client->sess.siegeDesiredTeam,
+		&client->sess.siegeClass,
+		&client->sess.saberType,
+		&client->sess.saber2Type
+		);
+
+	while (client->sess.siegeClass[i])
+	{ //convert back to spaces from unused chars, as session data is written that way.
+		if (client->sess.siegeClass[i] == 1)
+		{
+			client->sess.siegeClass[i] = ' ';
+		}
+
+		i++;
+	}
+
+	i = 0;
+	//And do the same for the saber type
+	while (client->sess.saberType[i])
+	{
+		if (client->sess.saberType[i] == 1)
+		{
+			client->sess.saberType[i] = ' ';
+		}
+
+		i++;
+	}
+
+	i = 0;
+	while (client->sess.saber2Type[i])
+	{
+		if (client->sess.saber2Type[i] == 1)
+		{
+			client->sess.saber2Type[i] = ' ';
+		}
+
+		i++;
+	}
+
+	// bk001205 - format issues
+	client->sess.sessionTeam = (team_t)sessionTeam;
+	client->sess.spectatorState = (spectatorState_t)spectatorState;
+	client->sess.teamLeader = (qboolean)teamLeader;
+
+	client->ps.fd.saberAnimLevel = client->sess.saberLevel;
+	client->ps.fd.saberDrawAnimLevel = client->sess.saberLevel;
+	client->ps.fd.forcePowerSelected = client->sess.selectedFP;
+}
+
+
+/*
+================
+G_InitSessionData
+
+Called on a first-time connect
+================
+*/
+void G_InitSessionData( gclient_t *client, char *userinfo, qboolean isBot ) {
+	clientSession_t	*sess;
+	const char		*value;
+
+	sess = &client->sess;
+
+	client->sess.siegeDesiredTeam = TEAM_FREE;
+
+	// initial team determination
+	if ( g_gametype.integer >= GT_TEAM ) {
+		if ( g_teamAutoJoin.integer ) {
+			sess->sessionTeam = PickTeam( -1 );
+			BroadcastTeamChange( client, -1 );
+		} else {
+			// always spawn as spectator in team games
+			if (!isBot)
+			{
+				sess->sessionTeam = TEAM_SPECTATOR;	
+			}
+			else
+			{ //Bots choose their team on creation
+				value = Info_ValueForKey( userinfo, "team" );
+				if (value[0] == 'r' || value[0] == 'R')
+				{
+					sess->sessionTeam = TEAM_RED;
+				}
+				else if (value[0] == 'b' || value[0] == 'B')
+				{
+					sess->sessionTeam = TEAM_BLUE;
+				}
+				else
+				{
+					sess->sessionTeam = PickTeam( -1 );
+				}
+				BroadcastTeamChange( client, -1 );
+			}
+		}
+	} else {
+		value = Info_ValueForKey( userinfo, "team" );
+		if ( value[0] == 's' ) {
+			// a willing spectator, not a waiting-in-line
+			sess->sessionTeam = TEAM_SPECTATOR;
+		} else {
+			switch ( g_gametype.integer ) {
+			default:
+			case GT_FFA:
+			case GT_HOLOCRON:
+			case GT_JEDIMASTER:
+			case GT_SINGLE_PLAYER:
+				if ( g_maxGameClients.integer > 0 && 
+					level.numNonSpectatorClients >= g_maxGameClients.integer ) {
+					sess->sessionTeam = TEAM_SPECTATOR;
+				} else {
+					sess->sessionTeam = TEAM_FREE;
+				}
+				break;
+			case GT_DUEL:
+				// if the game is full, go into a waiting mode
+				if ( level.numNonSpectatorClients >= 2 ) {
+					sess->sessionTeam = TEAM_SPECTATOR;
+				} else {
+					sess->sessionTeam = TEAM_FREE;
+				}
+				break;
+			case GT_POWERDUEL:
+				//sess->duelTeam = DUELTEAM_LONE; //default
+				{
+					int loners = 0;
+					int doubles = 0;
+
+					G_PowerDuelCount(&loners, &doubles, qtrue);
+
+					if (!doubles || loners > (doubles/2))
+					{
+						sess->duelTeam = DUELTEAM_DOUBLE;
+					}
+					else
+					{
+						sess->duelTeam = DUELTEAM_LONE;
+					}
+				}
+				sess->sessionTeam = TEAM_SPECTATOR;
+				break;
+			}
+		}
+	}
+
+	sess->spectatorState = SPECTATOR_FREE;
+	sess->spectatorTime = level.time;
+
+	sess->siegeClass[0] = 0;
+	sess->saberType[0] = 0;
+	sess->saber2Type[0] = 0;
+
+	G_WriteClientSessionData( client );
+}
+
+
+/*
+==================
+G_InitWorldSession
+
+==================
+*/
+void G_InitWorldSession( void ) {
+	char	s[MAX_STRING_CHARS];
+	int			gt;
+
+	trap_Cvar_VariableStringBuffer( "session", s, sizeof(s) );
+	gt = atoi( s );
+	
+	// if the gametype changed since the last session, don't use any
+	// client sessions
+	if ( g_gametype.integer != gt ) {
+		level.newSession = qtrue;
+		G_Printf( "Gametype changed, clearing session data.\n" );
+	}
+}
+
+/*
+==================
+G_WriteSessionData
+
+==================
+*/
+void G_WriteSessionData( void ) {
+	int		i;
+
+	trap_Cvar_Set( "session", va("%i", g_gametype.integer) );
+
+	for ( i = 0 ; i < level.maxclients ; i++ ) {
+		if ( level.clients[i].pers.connected == CON_CONNECTED ) {
+			G_WriteClientSessionData( &level.clients[i] );
+		}
+	}
+}
diff --git a/codemp/game/g_spawn.c b/codemp/game/g_spawn.c
new file mode 100644
index 0000000..bf89820
--- /dev/null
+++ b/codemp/game/g_spawn.c
@@ -0,0 +1,1472 @@
+// Copyright (C) 1999-2000 Id Software, Inc.
+//
+
+#include "g_local.h"
+
+qboolean	G_SpawnString( const char *key, const char *defaultString, char **out ) {
+	int		i;
+
+	if ( !level.spawning ) {
+		*out = (char *)defaultString;
+//		G_Error( "G_SpawnString() called while not spawning" );
+	}
+
+	for ( i = 0 ; i < level.numSpawnVars ; i++ ) {
+		if ( !Q_stricmp( key, level.spawnVars[i][0] ) ) {
+			*out = level.spawnVars[i][1];
+			return qtrue;
+		}
+	}
+
+	*out = (char *)defaultString;
+	return qfalse;
+}
+
+qboolean	G_SpawnFloat( const char *key, const char *defaultString, float *out ) {
+	char		*s;
+	qboolean	present;
+
+	present = G_SpawnString( key, defaultString, &s );
+	*out = atof( s );
+	return present;
+}
+
+qboolean	G_SpawnInt( const char *key, const char *defaultString, int *out ) {
+	char		*s;
+	qboolean	present;
+
+	present = G_SpawnString( key, defaultString, &s );
+	*out = atoi( s );
+	return present;
+}
+
+qboolean	G_SpawnVector( const char *key, const char *defaultString, float *out ) {
+	char		*s;
+	qboolean	present;
+
+	present = G_SpawnString( key, defaultString, &s );
+	sscanf( s, "%f %f %f", &out[0], &out[1], &out[2] );
+	return present;
+}
+
+
+
+BG_field_t fields[] = {
+	{"classname", FOFS(classname), F_LSTRING},
+	{"teamnodmg", FOFS(teamnodmg), F_INT},
+	{"teamowner", FOFS(s.teamowner), F_INT},
+	{"teamuser", FOFS(alliedTeam), F_INT},
+	{"alliedTeam", FOFS(alliedTeam), F_INT},//for misc_turrets
+	{"roffname", FOFS(roffname), F_LSTRING},
+	{"rofftarget", FOFS(rofftarget), F_LSTRING},
+	{"healingclass", FOFS(healingclass), F_LSTRING},
+	{"healingsound", FOFS(healingsound), F_LSTRING},
+	{"healingrate", FOFS(healingrate), F_INT},
+	{"ownername", FOFS(ownername), F_LSTRING},
+	{"origin", FOFS(s.origin), F_VECTOR},
+	{"model", FOFS(model), F_LSTRING},
+	{"model2", FOFS(model2), F_LSTRING},
+	{"spawnflags", FOFS(spawnflags), F_INT},
+	{"speed", FOFS(speed), F_FLOAT},
+	{"target", FOFS(target), F_LSTRING},
+	{"target2", FOFS(target2), F_LSTRING},
+	{"target3", FOFS(target3), F_LSTRING},
+	{"target4", FOFS(target4), F_LSTRING},
+	{"target5", FOFS(target5), F_LSTRING},
+	{"target6", FOFS(target6), F_LSTRING},
+	{"NPC_targetname", FOFS(NPC_targetname), F_LSTRING},
+	{"NPC_target", FOFS(NPC_target), F_LSTRING},
+	{"NPC_target2", FOFS(target2), F_LSTRING},//NPC_spawner only
+	{"NPC_target4", FOFS(target4), F_LSTRING},//NPC_spawner only
+	{"NPC_type", FOFS(NPC_type), F_LSTRING},
+	{"targetname", FOFS(targetname), F_LSTRING},
+	{"message", FOFS(message), F_LSTRING},
+	{"team", FOFS(team), F_LSTRING},
+	{"wait", FOFS(wait), F_FLOAT},
+	{"delay", FOFS(delay), F_INT},
+	{"random", FOFS(random), F_FLOAT},
+	{"count", FOFS(count), F_INT},
+	{"health", FOFS(health), F_INT},
+	{"light", 0, F_IGNORE},
+	{"dmg", FOFS(damage), F_INT},
+	{"angles", FOFS(s.angles), F_VECTOR},
+	{"angle", FOFS(s.angles), F_ANGLEHACK},
+	{"targetShaderName", FOFS(targetShaderName), F_LSTRING},
+	{"targetShaderNewName", FOFS(targetShaderNewName), F_LSTRING},
+	{"linear", FOFS(alt_fire), F_INT},//for movers to use linear movement
+
+	{"closetarget", FOFS(closetarget), F_LSTRING},//for doors
+	{"opentarget", FOFS(opentarget), F_LSTRING},//for doors
+	{"paintarget", FOFS(paintarget), F_LSTRING},//for doors
+
+	{"goaltarget", FOFS(goaltarget), F_LSTRING},//for siege
+	{"idealclass", FOFS(idealclass), F_LSTRING},//for siege spawnpoints
+
+	//rww - icarus stuff:
+	{"spawnscript", FOFS(behaviorSet[BSET_SPAWN]), F_LSTRING},//name of script to run
+	{"usescript", FOFS(behaviorSet[BSET_USE]), F_LSTRING},//name of script to run
+	{"awakescript", FOFS(behaviorSet[BSET_AWAKE]), F_LSTRING},//name of script to run
+	{"angerscript", FOFS(behaviorSet[BSET_ANGER]), F_LSTRING},//name of script to run
+	{"attackscript", FOFS(behaviorSet[BSET_ATTACK]), F_LSTRING},//name of script to run
+	{"victoryscript", FOFS(behaviorSet[BSET_VICTORY]), F_LSTRING},//name of script to run
+	{"lostenemyscript", FOFS(behaviorSet[BSET_LOSTENEMY]), F_LSTRING},//name of script to run
+	{"painscript", FOFS(behaviorSet[BSET_PAIN]), F_LSTRING},//name of script to run
+	{"fleescript", FOFS(behaviorSet[BSET_FLEE]), F_LSTRING},//name of script to run
+	{"deathscript", FOFS(behaviorSet[BSET_DEATH]), F_LSTRING},//name of script to run
+	{"delayscript", FOFS(behaviorSet[BSET_DELAYED]), F_LSTRING},//name of script to run
+	{"delayscripttime", FOFS(delayScriptTime), F_INT},//name of script to run
+	{"blockedscript", FOFS(behaviorSet[BSET_BLOCKED]), F_LSTRING},//name of script to run
+	{"ffirescript", FOFS(behaviorSet[BSET_FFIRE]), F_LSTRING},//name of script to run
+	{"ffdeathscript", FOFS(behaviorSet[BSET_FFDEATH]), F_LSTRING},//name of script to run
+	{"mindtrickscript", FOFS(behaviorSet[BSET_MINDTRICK]), F_LSTRING},//name of script to run
+	{"script_targetname", FOFS(script_targetname), F_LSTRING},//scripts look for this when "affecting"
+
+	{"fullName", FOFS(fullName), F_LSTRING},
+
+	{"soundSet", FOFS(soundSet), F_LSTRING},
+	{"radius", FOFS(radius), F_FLOAT},
+	{"numchunks", FOFS(radius), F_FLOAT},//for func_breakables
+	{"chunksize", FOFS(mass), F_FLOAT},//for func_breakables
+
+//Script parms - will this handle clamping to 16 or whatever length of parm[0] is?
+	{"parm1", 0, F_PARM1},
+	{"parm2", 0, F_PARM2},
+	{"parm3", 0, F_PARM3},
+	{"parm4", 0, F_PARM4},
+	{"parm5", 0, F_PARM5},
+	{"parm6", 0, F_PARM6},
+	{"parm7", 0, F_PARM7},
+	{"parm8", 0, F_PARM8},
+	{"parm9", 0, F_PARM9},
+	{"parm10", 0, F_PARM10},
+	{"parm11", 0, F_PARM11},
+	{"parm12", 0, F_PARM12},
+	{"parm13", 0, F_PARM13},
+	{"parm14", 0, F_PARM14},
+	{"parm15", 0, F_PARM15},
+	{"parm16", 0, F_PARM16},
+
+	{NULL}
+};
+
+
+typedef struct {
+	char	*name;
+	void	(*spawn)(gentity_t *ent);
+} spawn_t;
+
+void SP_info_player_start (gentity_t *ent);
+void SP_info_player_duel( gentity_t *ent );
+void SP_info_player_duel1( gentity_t *ent );
+void SP_info_player_duel2( gentity_t *ent );
+void SP_info_player_deathmatch (gentity_t *ent);
+void SP_info_player_siegeteam1 (gentity_t *ent);
+void SP_info_player_siegeteam2 (gentity_t *ent);
+void SP_info_player_intermission (gentity_t *ent);
+void SP_info_jedimaster_start (gentity_t *ent);
+void SP_info_firstplace(gentity_t *ent);
+void SP_info_secondplace(gentity_t *ent);
+void SP_info_thirdplace(gentity_t *ent);
+void SP_info_podium(gentity_t *ent);
+
+void SP_info_siege_objective (gentity_t *ent);
+void SP_info_siege_radaricon (gentity_t *ent);
+void SP_info_siege_decomplete (gentity_t *ent);
+void SP_target_siege_end (gentity_t *ent);
+void SP_misc_siege_item (gentity_t *ent);
+
+void SP_func_plat (gentity_t *ent);
+void SP_func_static (gentity_t *ent);
+void SP_func_rotating (gentity_t *ent);
+void SP_func_bobbing (gentity_t *ent);
+void SP_func_pendulum( gentity_t *ent );
+void SP_func_button (gentity_t *ent);
+void SP_func_door (gentity_t *ent);
+void SP_func_train (gentity_t *ent);
+void SP_func_timer (gentity_t *self);
+void SP_func_breakable (gentity_t *ent);
+void SP_func_glass (gentity_t *ent);
+void SP_func_usable( gentity_t *ent);
+void SP_func_wall( gentity_t *ent );
+
+void SP_trigger_lightningstrike( gentity_t *ent );
+
+void SP_trigger_always (gentity_t *ent);
+void SP_trigger_multiple (gentity_t *ent);
+void SP_trigger_once( gentity_t *ent );
+void SP_trigger_push (gentity_t *ent);
+void SP_trigger_teleport (gentity_t *ent);
+void SP_trigger_hurt (gentity_t *ent);
+void SP_trigger_space(gentity_t *self);
+void SP_trigger_shipboundary(gentity_t *self);
+void SP_trigger_hyperspace(gentity_t *self);
+
+void SP_target_remove_powerups( gentity_t *ent );
+void SP_target_give (gentity_t *ent);
+void SP_target_delay (gentity_t *ent);
+void SP_target_speaker (gentity_t *ent);
+void SP_target_print (gentity_t *ent);
+void SP_target_laser (gentity_t *self);
+void SP_target_character (gentity_t *ent);
+void SP_target_score( gentity_t *ent );
+void SP_target_teleporter( gentity_t *ent );
+void SP_target_relay (gentity_t *ent);
+void SP_target_kill (gentity_t *ent);
+void SP_target_position (gentity_t *ent);
+void SP_target_location (gentity_t *ent);
+void SP_target_counter (gentity_t *self);
+void SP_target_random (gentity_t *self);
+void SP_target_scriptrunner( gentity_t *self );
+void SP_target_interest (gentity_t *self);
+void SP_target_activate (gentity_t *self);
+void SP_target_deactivate (gentity_t *self);
+void SP_target_level_change( gentity_t *self );
+void SP_target_play_music( gentity_t *self );
+void SP_target_push (gentity_t *ent);
+
+void SP_light (gentity_t *self);
+void SP_info_null (gentity_t *self);
+void SP_info_notnull (gentity_t *self);
+void SP_info_camp (gentity_t *self);
+void SP_path_corner (gentity_t *self);
+
+void SP_misc_teleporter_dest (gentity_t *self);
+void SP_misc_model(gentity_t *ent);
+void SP_misc_model_static(gentity_t *ent);
+void SP_misc_G2model(gentity_t *ent);
+void SP_misc_portal_camera(gentity_t *ent);
+void SP_misc_portal_surface(gentity_t *ent);
+void SP_misc_weather_zone( gentity_t *ent );
+
+void SP_misc_bsp (gentity_t *ent);
+void SP_terrain (gentity_t *ent);
+void SP_misc_skyportal_orient (gentity_t *ent);
+void SP_misc_skyportal (gentity_t *ent);
+
+void SP_misc_ammo_floor_unit(gentity_t *ent);
+void SP_misc_shield_floor_unit( gentity_t *ent );
+void SP_misc_model_shield_power_converter( gentity_t *ent );
+void SP_misc_model_ammo_power_converter( gentity_t *ent );
+void SP_misc_model_health_power_converter( gentity_t *ent );
+
+void SP_fx_runner( gentity_t *ent );
+
+void SP_target_screenshake(gentity_t *ent);
+void SP_target_escapetrig(gentity_t *ent);
+
+void SP_misc_maglock ( gentity_t *self );
+
+void SP_misc_faller(gentity_t *ent);
+
+void SP_misc_holocron(gentity_t *ent);
+
+void SP_reference_tag ( gentity_t *ent );
+
+void SP_misc_weapon_shooter( gentity_t *self );
+
+void SP_NPC_spawner( gentity_t *self );
+
+void SP_NPC_Vehicle( gentity_t *self);
+
+void SP_NPC_Kyle( gentity_t *self );
+void SP_NPC_Lando( gentity_t *self );
+void SP_NPC_Jan( gentity_t *self );
+void SP_NPC_Luke( gentity_t *self );
+void SP_NPC_MonMothma( gentity_t *self );
+void SP_NPC_Tavion( gentity_t *self );
+void SP_NPC_Tavion_New( gentity_t *self );
+void SP_NPC_Alora( gentity_t *self );
+void SP_NPC_Reelo( gentity_t *self );
+void SP_NPC_Galak( gentity_t *self );
+void SP_NPC_Desann( gentity_t *self );
+void SP_NPC_Bartender( gentity_t *self );
+void SP_NPC_MorganKatarn( gentity_t *self );
+void SP_NPC_Jedi( gentity_t *self );
+void SP_NPC_Prisoner( gentity_t *self );
+void SP_NPC_Rebel( gentity_t *self );
+void SP_NPC_Stormtrooper( gentity_t *self );
+void SP_NPC_StormtrooperOfficer( gentity_t *self );
+void SP_NPC_Snowtrooper( gentity_t *self);
+void SP_NPC_Tie_Pilot( gentity_t *self );
+void SP_NPC_Ugnaught( gentity_t *self );
+void SP_NPC_Jawa( gentity_t *self );
+void SP_NPC_Gran( gentity_t *self );
+void SP_NPC_Rodian( gentity_t *self );
+void SP_NPC_Weequay( gentity_t *self );
+void SP_NPC_Trandoshan( gentity_t *self );
+void SP_NPC_Tusken( gentity_t *self );
+void SP_NPC_Noghri( gentity_t *self );
+void SP_NPC_SwampTrooper( gentity_t *self );
+void SP_NPC_Imperial( gentity_t *self );
+void SP_NPC_ImpWorker( gentity_t *self );
+void SP_NPC_BespinCop( gentity_t *self );
+void SP_NPC_Reborn( gentity_t *self );
+void SP_NPC_ShadowTrooper( gentity_t *self );
+void SP_NPC_Monster_Murjj( gentity_t *self );
+void SP_NPC_Monster_Swamp( gentity_t *self );
+void SP_NPC_Monster_Howler( gentity_t *self );
+void SP_NPC_Monster_Claw( gentity_t *self );
+void SP_NPC_Monster_Glider( gentity_t *self );
+void SP_NPC_Monster_Flier2( gentity_t *self );
+void SP_NPC_Monster_Lizard( gentity_t *self );
+void SP_NPC_Monster_Fish( gentity_t *self );
+void SP_NPC_Monster_Wampa( gentity_t *self );
+void SP_NPC_Monster_Rancor( gentity_t *self );
+void SP_NPC_MineMonster( gentity_t *self );
+void SP_NPC_Droid_Interrogator( gentity_t *self );
+void SP_NPC_Droid_Probe( gentity_t *self );
+void SP_NPC_Droid_Mark1( gentity_t *self );
+void SP_NPC_Droid_Mark2( gentity_t *self );
+void SP_NPC_Droid_ATST( gentity_t *self );
+void SP_NPC_Droid_Seeker( gentity_t *self );
+void SP_NPC_Droid_Remote( gentity_t *self );
+void SP_NPC_Droid_Sentry( gentity_t *self );
+void SP_NPC_Droid_Gonk( gentity_t *self );
+void SP_NPC_Droid_Mouse( gentity_t *self );
+void SP_NPC_Droid_R2D2( gentity_t *self );
+void SP_NPC_Droid_R5D2( gentity_t *self );
+void SP_NPC_Droid_Protocol( gentity_t *self );
+
+void SP_NPC_Reborn_New( gentity_t *self);
+void SP_NPC_Cultist( gentity_t *self );
+void SP_NPC_Cultist_Saber( gentity_t *self );
+void SP_NPC_Cultist_Saber_Powers( gentity_t *self );
+void SP_NPC_Cultist_Destroyer( gentity_t *self );
+void SP_NPC_Cultist_Commando( gentity_t *self );
+
+void SP_waypoint (gentity_t *ent);
+void SP_waypoint_small (gentity_t *ent);
+void SP_waypoint_navgoal (gentity_t *ent);
+void SP_waypoint_navgoal_8 (gentity_t *ent);
+void SP_waypoint_navgoal_4 (gentity_t *ent);
+void SP_waypoint_navgoal_2 (gentity_t *ent);
+void SP_waypoint_navgoal_1 (gentity_t *ent);
+
+void SP_CreateSpaceDust( gentity_t *ent );
+void SP_CreateSnow( gentity_t *ent );
+void SP_CreateRain( gentity_t *ent );
+
+void SP_point_combat( gentity_t *self );
+
+void SP_shooter_blaster( gentity_t *ent );
+
+void SP_team_CTF_redplayer( gentity_t *ent );
+void SP_team_CTF_blueplayer( gentity_t *ent );
+
+void SP_team_CTF_redspawn( gentity_t *ent );
+void SP_team_CTF_bluespawn( gentity_t *ent );
+
+void SP_misc_turret( gentity_t *ent );
+void SP_misc_turretG2( gentity_t *base );
+
+
+void SP_item_botroam( gentity_t *ent )
+{
+}
+
+void SP_gametype_item ( gentity_t* ent )
+{
+	gitem_t *item = NULL;
+	char *value;
+	int team = -1;
+
+	G_SpawnString("teamfilter", "", &value);
+
+	G_SetOrigin( ent, ent->s.origin );
+
+	// If a team filter is set then override any team settings for the spawns
+	if ( level.mTeamFilter[0] )
+	{
+		if ( Q_stricmp ( level.mTeamFilter, "red") == 0 )
+		{
+			team = TEAM_RED;
+		}
+		else if ( Q_stricmp ( level.mTeamFilter, "blue") == 0 )
+		{
+			team = TEAM_BLUE;
+		}
+	}
+
+	if (ent->targetname && ent->targetname[0])
+	{
+		if (team != -1)
+		{
+			if (strstr(ent->targetname, "flag"))
+			{
+				if (team == TEAM_RED)
+				{
+					item = BG_FindItem("team_CTF_redflag");
+				}
+				else
+				{ //blue
+					item = BG_FindItem("team_CTF_blueflag");
+				}
+			}
+		}
+		else if (strstr(ent->targetname, "red_flag"))
+		{
+			item = BG_FindItem("team_CTF_redflag");
+		}
+		else if (strstr(ent->targetname, "blue_flag"))
+		{
+			item = BG_FindItem("team_CTF_blueflag");
+		}
+		else
+		{
+			item = NULL;
+		}
+
+		if (item)
+		{
+			ent->targetname = NULL;
+			ent->classname = item->classname;
+			G_SpawnItem( ent, item );
+		}
+	}
+}
+
+void SP_emplaced_gun( gentity_t *ent );
+
+spawn_t	spawns[] = {
+	// info entities don't do anything at all, but provide positional
+	// information for things controlled by other processes
+	{"info_player_start", SP_info_player_start},
+	{"info_player_duel", SP_info_player_duel},
+	{"info_player_duel1", SP_info_player_duel1},
+	{"info_player_duel2", SP_info_player_duel2},
+	{"info_player_deathmatch", SP_info_player_deathmatch},
+	{"info_player_siegeteam1", SP_info_player_siegeteam1},
+	{"info_player_siegeteam2", SP_info_player_siegeteam2},
+	{"info_player_intermission", SP_info_player_intermission},
+	{"info_jedimaster_start", SP_info_jedimaster_start},
+	{"info_null", SP_info_null},
+	{"info_notnull", SP_info_notnull},		// use target_position instead
+	{"info_camp", SP_info_camp},
+
+	{"info_siege_objective", SP_info_siege_objective},
+	{"info_siege_radaricon", SP_info_siege_radaricon},
+	{"info_siege_decomplete", SP_info_siege_decomplete},
+	{"target_siege_end", SP_target_siege_end},
+	{"misc_siege_item", SP_misc_siege_item},
+
+	{"func_plat", SP_func_plat},
+	{"func_button", SP_func_button},
+	{"func_door", SP_func_door},
+	{"func_static", SP_func_static},
+	{"func_rotating", SP_func_rotating},
+	{"func_bobbing", SP_func_bobbing},
+	{"func_pendulum", SP_func_pendulum},
+	{"func_train", SP_func_train},
+	{"func_group", SP_info_null},
+	{"func_timer", SP_func_timer},			// rename trigger_timer?
+	{"func_breakable", SP_func_breakable},
+	{"func_glass", SP_func_glass},
+	{"func_usable", SP_func_usable},
+	{"func_wall", SP_func_wall},
+
+	// Triggers are brush objects that cause an effect when contacted
+	// by a living player, usually involving firing targets.
+	// While almost everything could be done with
+	// a single trigger class and different targets, triggered effects
+	// could not be client side predicted (push and teleport).
+	{"trigger_lightningstrike", SP_trigger_lightningstrike},
+
+	{"trigger_always", SP_trigger_always},
+	{"trigger_multiple", SP_trigger_multiple},
+	{"trigger_once", SP_trigger_once},
+	{"trigger_push", SP_trigger_push},
+	{"trigger_teleport", SP_trigger_teleport},
+	{"trigger_hurt", SP_trigger_hurt},
+	{"trigger_space", SP_trigger_space},
+	{"trigger_shipboundary", SP_trigger_shipboundary},
+	{"trigger_hyperspace", SP_trigger_hyperspace},
+
+	// targets perform no action by themselves, but must be triggered
+	// by another entity
+	{"target_give", SP_target_give},
+	{"target_remove_powerups", SP_target_remove_powerups},
+	{"target_delay", SP_target_delay},
+	{"target_speaker", SP_target_speaker},
+	{"target_print", SP_target_print},
+	{"target_laser", SP_target_laser},
+	{"target_score", SP_target_score},
+	{"target_teleporter", SP_target_teleporter},
+	{"target_relay", SP_target_relay},
+	{"target_kill", SP_target_kill},
+	{"target_position", SP_target_position},
+	{"target_location", SP_target_location},
+	{"target_counter", SP_target_counter},
+	{"target_random", SP_target_random},
+	{"target_scriptrunner", SP_target_scriptrunner},
+	{"target_interest", SP_target_interest},
+	{"target_activate", SP_target_activate},
+	{"target_deactivate", SP_target_deactivate},
+	{"target_level_change", SP_target_level_change},
+	{"target_play_music", SP_target_play_music},
+	{"target_push", SP_target_push},
+
+	{"light", SP_light},
+	{"path_corner", SP_path_corner},
+
+	{"misc_teleporter_dest", SP_misc_teleporter_dest},
+	{"misc_model", SP_misc_model},
+	{"misc_model_static", SP_misc_model_static},
+	{"misc_G2model", SP_misc_G2model},
+	{"misc_portal_surface", SP_misc_portal_surface},
+	{"misc_portal_camera", SP_misc_portal_camera},
+	{"misc_weather_zone", SP_misc_weather_zone},
+
+	{"misc_bsp", SP_misc_bsp},
+	{"terrain", SP_terrain},
+	{"misc_skyportal_orient", SP_misc_skyportal_orient},
+	{"misc_skyportal", SP_misc_skyportal},
+
+	//rwwFIXMEFIXME: only for testing rmg team stuff
+	{"gametype_item", SP_gametype_item },
+
+	{"misc_ammo_floor_unit", SP_misc_ammo_floor_unit},
+	{"misc_shield_floor_unit", SP_misc_shield_floor_unit},
+	{"misc_model_shield_power_converter", SP_misc_model_shield_power_converter},
+	{"misc_model_ammo_power_converter", SP_misc_model_ammo_power_converter},
+	{"misc_model_health_power_converter", SP_misc_model_health_power_converter},
+
+	{"fx_runner", SP_fx_runner},
+
+	{"target_screenshake", SP_target_screenshake},
+	{"target_escapetrig", SP_target_escapetrig},
+
+	{"misc_maglock", SP_misc_maglock},
+
+	{"misc_faller", SP_misc_faller},
+
+	{"ref_tag",	SP_reference_tag},
+	{"ref_tag_huge",	SP_reference_tag},
+
+	{"misc_weapon_shooter", SP_misc_weapon_shooter},
+
+	//new NPC ents
+	{"NPC_spawner", SP_NPC_spawner},
+
+	{"NPC_Vehicle", SP_NPC_Vehicle },
+	{"NPC_Kyle", SP_NPC_Kyle },
+	{"NPC_Lando", SP_NPC_Lando },
+	{"NPC_Jan", SP_NPC_Jan },
+	{"NPC_Luke", SP_NPC_Luke },
+	{"NPC_MonMothma", SP_NPC_MonMothma },
+	{"NPC_Tavion", SP_NPC_Tavion },
+	
+	//new tavion
+	{"NPC_Tavion_New", SP_NPC_Tavion_New },
+
+	//new alora
+	{"NPC_Alora", SP_NPC_Alora },
+
+	{"NPC_Reelo", SP_NPC_Reelo },
+	{"NPC_Galak", SP_NPC_Galak },
+	{"NPC_Desann", SP_NPC_Desann },
+	{"NPC_Bartender", SP_NPC_Bartender },
+	{"NPC_MorganKatarn", SP_NPC_MorganKatarn },
+	{"NPC_Jedi", SP_NPC_Jedi },
+	{"NPC_Prisoner", SP_NPC_Prisoner },
+	{"NPC_Rebel", SP_NPC_Rebel },
+	{"NPC_Stormtrooper", SP_NPC_Stormtrooper },
+	{"NPC_StormtrooperOfficer", SP_NPC_StormtrooperOfficer },
+	{"NPC_Snowtrooper", SP_NPC_Snowtrooper },
+	{"NPC_Tie_Pilot", SP_NPC_Tie_Pilot },
+	{"NPC_Ugnaught", SP_NPC_Ugnaught },
+	{"NPC_Jawa", SP_NPC_Jawa },
+	{"NPC_Gran", SP_NPC_Gran },
+	{"NPC_Rodian", SP_NPC_Rodian },
+	{"NPC_Weequay", SP_NPC_Weequay },
+	{"NPC_Trandoshan", SP_NPC_Trandoshan },
+	{"NPC_Tusken", SP_NPC_Tusken },
+	{"NPC_Noghri", SP_NPC_Noghri },
+	{"NPC_SwampTrooper", SP_NPC_SwampTrooper },
+	{"NPC_Imperial", SP_NPC_Imperial },
+	{"NPC_ImpWorker", SP_NPC_ImpWorker },
+	{"NPC_BespinCop", SP_NPC_BespinCop },
+	{"NPC_Reborn", SP_NPC_Reborn },
+	{"NPC_ShadowTrooper", SP_NPC_ShadowTrooper },
+	{"NPC_Monster_Murjj", SP_NPC_Monster_Murjj },
+	{"NPC_Monster_Swamp", SP_NPC_Monster_Swamp },
+	{"NPC_Monster_Howler", SP_NPC_Monster_Howler },
+	{"NPC_MineMonster",	SP_NPC_MineMonster },
+	{"NPC_Monster_Claw", SP_NPC_Monster_Claw },
+	{"NPC_Monster_Glider", SP_NPC_Monster_Glider },
+	{"NPC_Monster_Flier2", SP_NPC_Monster_Flier2 },
+	{"NPC_Monster_Lizard", SP_NPC_Monster_Lizard },
+	{"NPC_Monster_Fish", SP_NPC_Monster_Fish },
+	{"NPC_Monster_Wampa", SP_NPC_Monster_Wampa },
+	{"NPC_Monster_Rancor", SP_NPC_Monster_Rancor },
+	{"NPC_Droid_Interrogator", SP_NPC_Droid_Interrogator },
+	{"NPC_Droid_Probe", SP_NPC_Droid_Probe },
+	{"NPC_Droid_Mark1", SP_NPC_Droid_Mark1 },
+	{"NPC_Droid_Mark2", SP_NPC_Droid_Mark2 },
+	{"NPC_Droid_ATST", SP_NPC_Droid_ATST },
+	{"NPC_Droid_Seeker", SP_NPC_Droid_Seeker },
+	{"NPC_Droid_Remote", SP_NPC_Droid_Remote },
+	{"NPC_Droid_Sentry", SP_NPC_Droid_Sentry },
+	{"NPC_Droid_Gonk", SP_NPC_Droid_Gonk },
+	{"NPC_Droid_Mouse", SP_NPC_Droid_Mouse },
+	{"NPC_Droid_R2D2", SP_NPC_Droid_R2D2 },
+	{"NPC_Droid_R5D2", SP_NPC_Droid_R5D2 },
+	{"NPC_Droid_Protocol", SP_NPC_Droid_Protocol },
+
+	//maybe put these guys in some day, for now just spawn reborns in their place.
+	{"NPC_Reborn_New", SP_NPC_Reborn_New },
+	{"NPC_Cultist", SP_NPC_Cultist },
+	{"NPC_Cultist_Saber", SP_NPC_Cultist_Saber },
+	{"NPC_Cultist_Saber_Powers", SP_NPC_Cultist_Saber_Powers },
+	{"NPC_Cultist_Destroyer", SP_NPC_Cultist_Destroyer },
+	{"NPC_Cultist_Commando", SP_NPC_Cultist_Commando },
+
+	//rwwFIXMEFIXME: Faked for testing NPCs (another other things) in RMG with sof2 assets
+	{"NPC_Colombian_Soldier", SP_NPC_Reborn },
+	{"NPC_Colombian_Rebel", SP_NPC_Reborn },
+	{"NPC_Colombian_EmplacedGunner", SP_NPC_ShadowTrooper },
+	{"NPC_Manuel_Vergara_RMG", SP_NPC_Desann },
+//	{"info_NPCnav", SP_waypoint},
+
+	{"waypoint", SP_waypoint},
+	{"waypoint_small", SP_waypoint_small},
+	{"waypoint_navgoal", SP_waypoint_navgoal},
+	{"waypoint_navgoal_8", SP_waypoint_navgoal_8},
+	{"waypoint_navgoal_4", SP_waypoint_navgoal_4},
+	{"waypoint_navgoal_2", SP_waypoint_navgoal_2},
+	{"waypoint_navgoal_1", SP_waypoint_navgoal_1},
+
+	{"fx_spacedust", SP_CreateSpaceDust},
+	{"fx_rain", SP_CreateRain},
+	{"fx_snow", SP_CreateSnow},
+
+	{"point_combat", SP_point_combat},
+
+	{"misc_holocron", SP_misc_holocron},
+
+	{"shooter_blaster", SP_shooter_blaster},
+
+	{"team_CTF_redplayer", SP_team_CTF_redplayer},
+	{"team_CTF_blueplayer", SP_team_CTF_blueplayer},
+
+	{"team_CTF_redspawn", SP_team_CTF_redspawn},
+	{"team_CTF_bluespawn", SP_team_CTF_bluespawn},
+
+	{"item_botroam", SP_item_botroam},
+
+	{"emplaced_gun", SP_emplaced_gun},
+
+	{"misc_turret", SP_misc_turret},
+	{"misc_turretG2", SP_misc_turretG2},
+
+
+	{0, 0}
+};
+
+/*
+===============
+G_CallSpawn
+
+Finds the spawn function for the entity and calls it,
+returning qfalse if not found
+===============
+*/
+qboolean G_CallSpawn( gentity_t *ent ) {
+	spawn_t	*s;
+	gitem_t	*item;
+
+	if ( !ent->classname ) {
+		G_Printf ("G_CallSpawn: NULL classname\n");
+		return qfalse;
+	}
+
+	// check item spawn functions
+	for ( item=bg_itemlist+1 ; item->classname ; item++ ) {
+		if ( !strcmp(item->classname, ent->classname) ) {
+			G_SpawnItem( ent, item );
+			return qtrue;
+		}
+	}
+
+	// check normal spawn functions
+	for ( s=spawns ; s->name ; s++ ) {
+		if ( !strcmp(s->name, ent->classname) ) {
+			// found it
+			if (ent->healingsound && ent->healingsound[0])
+			{ //yeah...this can be used for anything, so.. precache it if it's there
+				G_SoundIndex(ent->healingsound);
+			}
+			s->spawn(ent);
+			return qtrue;
+		}
+	}
+	G_Printf ("%s doesn't have a spawn function\n", ent->classname);
+	return qfalse;
+}
+
+/*
+=============
+G_NewString
+
+Builds a copy of the string, translating \n to real linefeeds
+so message texts can be multi-line
+=============
+*/
+char *G_NewString( const char *string ) {
+	char	*newb, *new_p;
+	int		i,l;
+	
+	l = strlen(string) + 1;
+
+	newb = (char *) G_Alloc( l );
+
+	new_p = newb;
+
+	// turn \n into a real linefeed
+	for ( i=0 ; i< l ; i++ ) {
+		if (string[i] == '\\' && i < l-1) {
+			i++;
+			if (string[i] == 'n') {
+				*new_p++ = '\n';
+			} else {
+				*new_p++ = '\\';
+			}
+		} else {
+			*new_p++ = string[i];
+		}
+	}
+	
+	return newb;
+}
+
+
+
+
+
+/*
+===================
+G_SpawnGEntityFromSpawnVars
+
+Spawn an entity and fill in all of the level fields from
+level.spawnVars[], then call the class specfic spawn function
+===================
+*/
+#include "../namespace_begin.h"
+void BG_ParseField( BG_field_t *l_fields, const char *key, const char *value, byte *ent );
+#include "../namespace_end.h"
+void G_SpawnGEntityFromSpawnVars( qboolean inSubBSP ) {
+	int			i;
+	gentity_t	*ent;
+	char		*s, *value, *gametypeName;
+	static char *gametypeNames[] = {"ffa", "holocron", "jedimaster", "duel", "powerduel", "single", "team", "siege", "ctf", "cty"};
+
+	// get the next free entity
+	ent = G_Spawn();
+
+	for ( i = 0 ; i < level.numSpawnVars ; i++ ) {
+		BG_ParseField( fields, level.spawnVars[i][0], level.spawnVars[i][1], (byte *)ent );
+	}
+
+	// check for "notsingle" flag
+	if ( g_gametype.integer == GT_SINGLE_PLAYER ) {
+		G_SpawnInt( "notsingle", "0", &i );
+		if ( i ) {
+			G_FreeEntity( ent );
+			return;
+		}
+	}
+	// check for "notteam" flag (GT_FFA, GT_DUEL, GT_SINGLE_PLAYER)
+	if ( g_gametype.integer >= GT_TEAM ) {
+		G_SpawnInt( "notteam", "0", &i );
+		if ( i ) {
+			G_FreeEntity( ent );
+			return;
+		}
+	} else {
+		G_SpawnInt( "notfree", "0", &i );
+		if ( i ) {
+			G_FreeEntity( ent );
+			return;
+		}
+	}
+
+	G_SpawnInt( "notta", "0", &i );
+	if ( i ) {
+		G_FreeEntity( ent );
+		return;
+	}
+
+	if( G_SpawnString( "gametype", NULL, &value ) ) {
+		if( g_gametype.integer >= GT_FFA && g_gametype.integer < GT_MAX_GAME_TYPE ) {
+			gametypeName = gametypeNames[g_gametype.integer];
+
+			s = strstr( value, gametypeName );
+			if( !s ) {
+				G_FreeEntity( ent );
+				return;
+			}
+		}
+	}
+
+	// move editor origin to pos
+	VectorCopy( ent->s.origin, ent->s.pos.trBase );
+	VectorCopy( ent->s.origin, ent->r.currentOrigin );
+
+	// if we didn't get a classname, don't bother spawning anything
+	if ( !G_CallSpawn( ent ) ) {
+		G_FreeEntity( ent );
+	}
+
+	//Tag on the ICARUS scripting information only to valid recipients
+	if ( trap_ICARUS_ValidEnt( ent ) )
+	{
+		trap_ICARUS_InitEnt( ent );
+
+		if ( ent->classname && ent->classname[0] )
+		{
+			if ( Q_strncmp( "NPC_", ent->classname, 4 ) != 0 )
+			{//Not an NPC_spawner (rww - probably don't even care for MP, but whatever)
+				G_ActivateBehavior( ent, BSET_SPAWN );
+			}
+		}
+	}
+}
+
+
+
+/*
+====================
+G_AddSpawnVarToken
+====================
+*/
+char *G_AddSpawnVarToken( const char *string ) {
+	int		l;
+	char	*dest;
+
+	l = strlen( string );
+	if ( level.numSpawnVarChars + l + 1 > MAX_SPAWN_VARS_CHARS ) {
+		G_Error( "G_AddSpawnVarToken: MAX_SPAWN_CHARS" );
+	}
+
+	dest = level.spawnVarChars + level.numSpawnVarChars;
+	memcpy( dest, string, l+1 );
+
+	level.numSpawnVarChars += l + 1;
+
+	return dest;
+}
+
+void AddSpawnField(char *field, char *value)
+{
+	int	i;
+
+	for(i=0;i<level.numSpawnVars;i++)
+	{
+		if (Q_stricmp(level.spawnVars[i][0], field) == 0)
+		{
+			level.spawnVars[ i ][1] = G_AddSpawnVarToken( value );
+			return;
+		}
+	}
+
+	level.spawnVars[ level.numSpawnVars ][0] = G_AddSpawnVarToken( field );
+	level.spawnVars[ level.numSpawnVars ][1] = G_AddSpawnVarToken( value );
+	level.numSpawnVars++;
+}
+
+#define NOVALUE "novalue"
+
+static void HandleEntityAdjustment(void)
+{
+	char		*value;
+	vec3_t		origin, newOrigin, angles;
+	char		temp[MAX_QPATH];
+	float		rotation;
+
+	G_SpawnString("origin", NOVALUE, &value);
+	if (Q_stricmp(value, NOVALUE) != 0)
+	{
+		sscanf( value, "%f %f %f", &origin[0], &origin[1], &origin[2] );
+	}
+	else
+	{
+		origin[0] = origin[1] = origin[2] = 0.0;
+	}
+
+	rotation = DEG2RAD(level.mRotationAdjust);
+	newOrigin[0] = origin[0]*cos(rotation) - origin[1]*sin(rotation);
+	newOrigin[1] = origin[0]*sin(rotation) + origin[1]*cos(rotation);
+	newOrigin[2] = origin[2];
+	VectorAdd(newOrigin, level.mOriginAdjust, newOrigin);
+	// damn VMs don't handle outputing a float that is compatible with sscanf in all cases
+	Com_sprintf(temp, MAX_QPATH, "%0.0f %0.0f %0.0f", newOrigin[0], newOrigin[1], newOrigin[2]);
+	AddSpawnField("origin", temp);
+
+	G_SpawnString("angles", NOVALUE, &value);
+	if (Q_stricmp(value, NOVALUE) != 0)
+	{
+		sscanf( value, "%f %f %f", &angles[0], &angles[1], &angles[2] );
+
+		angles[1] = fmod(angles[1] + level.mRotationAdjust, 360.0f);
+		// damn VMs don't handle outputing a float that is compatible with sscanf in all cases
+		Com_sprintf(temp, MAX_QPATH, "%0.0f %0.0f %0.0f", angles[0], angles[1], angles[2]);
+		AddSpawnField("angles", temp);
+	}
+	else
+	{
+		G_SpawnString("angle", NOVALUE, &value);
+		if (Q_stricmp(value, NOVALUE) != 0)
+		{
+			sscanf( value, "%f", &angles[1] );
+		}
+		else
+		{
+			angles[1] = 0.0;
+		}
+		angles[1] = fmod(angles[1] + level.mRotationAdjust, 360.0f);
+		Com_sprintf(temp, MAX_QPATH, "%0.0f", angles[1]);
+		AddSpawnField("angle", temp);
+	}
+
+	// RJR experimental code for handling "direction" field of breakable brushes
+	// though direction is rarely ever used.
+	G_SpawnString("direction", NOVALUE, &value);
+	if (Q_stricmp(value, NOVALUE) != 0)
+	{
+		sscanf( value, "%f %f %f", &angles[0], &angles[1], &angles[2] );
+	}
+	else
+	{
+		angles[0] = angles[1] = angles[2] = 0.0;
+	}
+	angles[1] = fmod(angles[1] + level.mRotationAdjust, 360.0f);
+	Com_sprintf(temp, MAX_QPATH, "%0.0f %0.0f %0.0f", angles[0], angles[1], angles[2]);
+	AddSpawnField("direction", temp);
+
+
+	AddSpawnField("BSPInstanceID", level.mTargetAdjust);
+
+	G_SpawnString("targetname", NOVALUE, &value);
+	if (Q_stricmp(value, NOVALUE) != 0)
+	{
+		Com_sprintf(temp, MAX_QPATH, "%s%s", level.mTargetAdjust, value);
+		AddSpawnField("targetname", temp);
+	}
+
+	G_SpawnString("target", NOVALUE, &value);
+	if (Q_stricmp(value, NOVALUE) != 0)
+	{
+		Com_sprintf(temp, MAX_QPATH, "%s%s", level.mTargetAdjust, value);
+		AddSpawnField("target", temp);
+	}
+
+	G_SpawnString("killtarget", NOVALUE, &value);
+	if (Q_stricmp(value, NOVALUE) != 0)
+	{
+		Com_sprintf(temp, MAX_QPATH, "%s%s", level.mTargetAdjust, value);
+		AddSpawnField("killtarget", temp);
+	}
+
+	G_SpawnString("brushparent", NOVALUE, &value);
+	if (Q_stricmp(value, NOVALUE) != 0)
+	{
+		Com_sprintf(temp, MAX_QPATH, "%s%s", level.mTargetAdjust, value);
+		AddSpawnField("brushparent", temp);
+	}
+
+	G_SpawnString("brushchild", NOVALUE, &value);
+	if (Q_stricmp(value, NOVALUE) != 0)
+	{
+		Com_sprintf(temp, MAX_QPATH, "%s%s", level.mTargetAdjust, value);
+		AddSpawnField("brushchild", temp);
+	}
+
+	G_SpawnString("enemy", NOVALUE, &value);
+	if (Q_stricmp(value, NOVALUE) != 0)
+	{
+		Com_sprintf(temp, MAX_QPATH, "%s%s", level.mTargetAdjust, value);
+		AddSpawnField("enemy", temp);
+	}
+
+	G_SpawnString("ICARUSname", NOVALUE, &value);
+	if (Q_stricmp(value, NOVALUE) != 0)
+	{
+		Com_sprintf(temp, MAX_QPATH, "%s%s", level.mTargetAdjust, value);
+		AddSpawnField("ICARUSname", temp);
+	}
+}
+
+/*
+====================
+G_ParseSpawnVars
+
+Parses a brace bounded set of key / value pairs out of the
+level's entity strings into level.spawnVars[]
+
+This does not actually spawn an entity.
+====================
+*/
+qboolean G_ParseSpawnVars( qboolean inSubBSP ) {
+	char		keyname[MAX_TOKEN_CHARS];
+	char		com_token[MAX_TOKEN_CHARS];
+
+	level.numSpawnVars = 0;
+	level.numSpawnVarChars = 0;
+
+	// parse the opening brace
+	if ( !trap_GetEntityToken( com_token, sizeof( com_token ) ) ) {
+		// end of spawn string
+		return qfalse;
+	}
+	if ( com_token[0] != '{' ) {
+		G_Error( "G_ParseSpawnVars: found %s when expecting {",com_token );
+	}
+
+	// go through all the key / value pairs
+	while ( 1 ) {	
+		// parse key
+		if ( !trap_GetEntityToken( keyname, sizeof( keyname ) ) ) {
+			G_Error( "G_ParseSpawnVars: EOF without closing brace" );
+		}
+
+		if ( keyname[0] == '}' ) {
+			break;
+		}
+		
+		// parse value	
+		if ( !trap_GetEntityToken( com_token, sizeof( com_token ) ) ) {
+			G_Error( "G_ParseSpawnVars: EOF without closing brace" );
+		}
+
+		if ( com_token[0] == '}' ) {
+			G_Error( "G_ParseSpawnVars: closing brace without data" );
+		}
+		if ( level.numSpawnVars == MAX_SPAWN_VARS ) {
+			G_Error( "G_ParseSpawnVars: MAX_SPAWN_VARS" );
+		}
+		level.spawnVars[ level.numSpawnVars ][0] = G_AddSpawnVarToken( keyname );
+		level.spawnVars[ level.numSpawnVars ][1] = G_AddSpawnVarToken( com_token );
+		level.numSpawnVars++;
+	}
+
+	if (inSubBSP)
+	{
+		HandleEntityAdjustment();
+	}
+
+	return qtrue;
+}
+
+
+static	char *defaultStyles[32][3] = 
+{
+	{	// 0 normal
+		"z",
+		"z",
+		"z"
+	},
+	{	// 1 FLICKER (first variety)
+		"mmnmmommommnonmmonqnmmo",
+		"mmnmmommommnonmmonqnmmo",
+		"mmnmmommommnonmmonqnmmo"
+	},
+	{	// 2 SLOW STRONG PULSE
+		"abcdefghijklmnopqrstuvwxyzyxwvutsrqponmlkjihgfedcb",
+		"abcdefghijklmnopqrstuvwxyzyxwvutsrqponmlkjihgfedcb",
+		"abcdefghijklmnopqrstuvwxyzyxwvutsrqponmlkjihgfedcb"
+	},
+	{	// 3 CANDLE (first variety)
+		"mmmmmaaaaammmmmaaaaaabcdefgabcdefg",
+		"mmmmmaaaaammmmmaaaaaabcdefgabcdefg",
+		"mmmmmaaaaammmmmaaaaaabcdefgabcdefg"
+	},
+	{	// 4 FAST STROBE
+		"mamamamamama",
+		"mamamamamama",
+		"mamamamamama"
+	},
+	{	// 5 GENTLE PULSE 1
+		"jklmnopqrstuvwxyzyxwvutsrqponmlkj",
+		"jklmnopqrstuvwxyzyxwvutsrqponmlkj",
+		"jklmnopqrstuvwxyzyxwvutsrqponmlkj"
+	},
+	{	// 6 FLICKER (second variety)
+		"nmonqnmomnmomomno",
+		"nmonqnmomnmomomno",
+		"nmonqnmomnmomomno"
+	},
+	{	// 7 CANDLE (second variety)
+		"mmmaaaabcdefgmmmmaaaammmaamm",
+		"mmmaaaabcdefgmmmmaaaammmaamm",
+		"mmmaaaabcdefgmmmmaaaammmaamm"
+	},
+	{	// 8 CANDLE (third variety)
+		"mmmaaammmaaammmabcdefaaaammmmabcdefmmmaaaa",
+		"mmmaaammmaaammmabcdefaaaammmmabcdefmmmaaaa",
+		"mmmaaammmaaammmabcdefaaaammmmabcdefmmmaaaa"
+	},
+	{	// 9 SLOW STROBE (fourth variety)
+		"aaaaaaaazzzzzzzz",
+		"aaaaaaaazzzzzzzz",
+		"aaaaaaaazzzzzzzz"
+	},
+	{	// 10 FLUORESCENT FLICKER
+		"mmamammmmammamamaaamammma",
+		"mmamammmmammamamaaamammma",
+		"mmamammmmammamamaaamammma"
+	},
+	{	// 11 SLOW PULSE NOT FADE TO BLACK
+		"abcdefghijklmnopqrrqponmlkjihgfedcba",
+		"abcdefghijklmnopqrrqponmlkjihgfedcba",
+		"abcdefghijklmnopqrrqponmlkjihgfedcba"
+	},
+	{	// 12 FAST PULSE FOR JEREMY
+		"mkigegik",
+		"mkigegik",
+		"mkigegik"
+	},
+	{	// 13 Test Blending
+		"abcdefghijklmqrstuvwxyz",
+		"zyxwvutsrqmlkjihgfedcba",
+		"aammbbzzccllcckkffyyggp"
+	},
+	{	// 14
+		"",
+		"",
+		""
+	},
+	{	// 15
+		"",
+		"",
+		""
+	},
+	{	// 16
+		"",
+		"",
+		""
+	},
+	{	// 17
+		"",
+		"",
+		""
+	},
+	{	// 18
+		"",
+		"",
+		""
+	},
+	{	// 19
+		"",
+		"",
+		""
+	},
+	{	// 20
+		"",
+		"",
+		""
+	},
+	{	// 21
+		"",
+		"",
+		""
+	},
+	{	// 22
+		"",
+		"",
+		""
+	},
+	{	// 23
+		"",
+		"",
+		""
+	},
+	{	// 24
+		"",
+		"",
+		""
+	},
+	{	// 25
+		"",
+		"",
+		""
+	},
+	{	// 26
+		"",
+		"",
+		""
+	},
+	{	// 27
+		"",
+		"",
+		""
+	},
+	{	// 28
+		"",
+		"",
+		""
+	},
+	{	// 29
+		"",
+		"",
+		""
+	},
+	{	// 30
+		"",
+		"",
+		""
+	},
+	{	// 31
+		"",
+		"",
+		""
+	}
+};
+
+void *precachedKyle = 0;
+void scriptrunner_run (gentity_t *self);
+
+/*QUAKED worldspawn (0 0 0) ?
+
+Every map should have exactly one worldspawn.
+"music"		music wav file
+"gravity"	800 is default gravity
+"message"	Text to print during connection process
+
+BSP Options
+"gridsize"     size of lighting grid to "X Y Z". default="64 64 128"
+"ambient"      scale of global light (from _color)
+"fog"          shader name of the global fog texture - must include the full path, such as "textures/rj/fog1"
+"distancecull" value for vis for the maximum viewing distance
+"chopsize"     value for bsp on the maximum polygon / portal size
+"ls_Xr"	override lightstyle X with this pattern for Red.
+"ls_Xg"	green (valid patterns are "a-z")
+"ls_Xb"	blue (a is OFF, z is ON)
+
+"fogstart"		override fog start distance and force linear
+"radarrange" for Siege/Vehicle radar - default range is 2500
+*/
+extern void EWebPrecache(void); //g_items.c
+float g_cullDistance;
+void SP_worldspawn( void ) 
+{
+	char		*text, temp[32];
+	int			i;
+	int			lengthRed, lengthBlue, lengthGreen;
+
+	//I want to "cull" entities out of net sends to clients to reduce
+	//net traffic on our larger open maps -rww
+	G_SpawnFloat("distanceCull", "6000.0", &g_cullDistance);
+	trap_SetServerCull(g_cullDistance);
+
+	G_SpawnString( "classname", "", &text );
+	if ( Q_stricmp( text, "worldspawn" ) ) {
+		G_Error( "SP_worldspawn: The first entity isn't 'worldspawn'" );
+	}
+
+	for ( i = 0 ; i < level.numSpawnVars ; i++ ) 
+	{
+		if ( Q_stricmp( "spawnscript", level.spawnVars[i][0] ) == 0 )
+		{//ONly let them set spawnscript, we don't want them setting an angle or something on the world.
+			BG_ParseField( fields, level.spawnVars[i][0], level.spawnVars[i][1], (byte *)&g_entities[ENTITYNUM_WORLD] );
+		}
+	}
+	//The server will precache the standard model and animations, so that there is no hit
+	//when the first client connnects.
+	if (!BGPAFtextLoaded)
+	{
+		BG_ParseAnimationFile("models/players/_humanoid/animation.cfg", bgHumanoidAnimations, qtrue);
+	}
+
+	if (!precachedKyle)
+	{
+		int defSkin;
+
+		trap_G2API_InitGhoul2Model(&precachedKyle, "models/players/kyle/model.glm", 0, 0, -20, 0, 0);
+
+		if (precachedKyle)
+		{
+			defSkin = trap_R_RegisterSkin("models/players/kyle/model_default.skin");
+			trap_G2API_SetSkin(precachedKyle, 0, defSkin, defSkin);
+		}
+	}
+
+	if (!g2SaberInstance)
+	{
+		trap_G2API_InitGhoul2Model(&g2SaberInstance, "models/weapons2/saber/saber_w.glm", 0, 0, -20, 0, 0);
+
+		if (g2SaberInstance)
+		{
+			// indicate we will be bolted to model 0 (ie the player) on bolt 0 (always the right hand) when we get copied
+			trap_G2API_SetBoltInfo(g2SaberInstance, 0, 0);
+			// now set up the gun bolt on it
+			trap_G2API_AddBolt(g2SaberInstance, 0, "*blade1");
+		}
+	}
+
+	if (g_gametype.integer == GT_SIEGE)
+	{ //a tad bit of a hack, but..
+		EWebPrecache();
+	}
+
+	// make some data visible to connecting client
+	trap_SetConfigstring( CS_GAME_VERSION, GAME_VERSION );
+
+	trap_SetConfigstring( CS_LEVEL_START_TIME, va("%i", level.startTime ) );
+
+	G_SpawnString( "music", "", &text );
+	trap_SetConfigstring( CS_MUSIC, text );
+
+	G_SpawnString( "message", "", &text );
+	trap_SetConfigstring( CS_MESSAGE, text );				// map specific message
+
+	trap_SetConfigstring( CS_MOTD, g_motd.string );		// message of the day
+
+	G_SpawnString( "gravity", "800", &text );
+	trap_Cvar_Set( "g_gravity", text );
+
+	G_SpawnString( "enableDust", "0", &text );
+	trap_Cvar_Set( "g_enableDust", text );
+
+	G_SpawnString( "enableBreath", "0", &text );
+	trap_Cvar_Set( "g_enableBreath", text );
+
+	G_SpawnString( "soundSet", "default", &text );
+	trap_SetConfigstring( CS_GLOBAL_AMBIENT_SET, text );
+
+	g_entities[ENTITYNUM_WORLD].s.number = ENTITYNUM_WORLD;
+	g_entities[ENTITYNUM_WORLD].classname = "worldspawn";
+
+	// see if we want a warmup time
+	trap_SetConfigstring( CS_WARMUP, "" );
+	if ( g_restarted.integer ) {
+		trap_Cvar_Set( "g_restarted", "0" );
+		level.warmupTime = 0;
+	} 
+	/*
+	else if ( g_doWarmup.integer && g_gametype.integer != GT_DUEL && g_gametype.integer != GT_POWERDUEL ) { // Turn it on
+		level.warmupTime = -1;
+		trap_SetConfigstring( CS_WARMUP, va("%i", level.warmupTime) );
+		G_LogPrintf( "Warmup:\n" );
+	}
+	*/
+
+	trap_SetConfigstring(CS_LIGHT_STYLES+(LS_STYLES_START*3)+0, defaultStyles[0][0]);
+	trap_SetConfigstring(CS_LIGHT_STYLES+(LS_STYLES_START*3)+1, defaultStyles[0][1]);
+	trap_SetConfigstring(CS_LIGHT_STYLES+(LS_STYLES_START*3)+2, defaultStyles[0][2]);
+	
+	for(i=1;i<LS_NUM_STYLES;i++)
+	{
+		Com_sprintf(temp, sizeof(temp), "ls_%dr", i);
+		G_SpawnString(temp, defaultStyles[i][0], &text);
+		lengthRed = strlen(text);
+		trap_SetConfigstring(CS_LIGHT_STYLES+((i+LS_STYLES_START)*3)+0, text);
+
+		Com_sprintf(temp, sizeof(temp), "ls_%dg", i);
+		G_SpawnString(temp, defaultStyles[i][1], &text);
+		lengthGreen = strlen(text);
+		trap_SetConfigstring(CS_LIGHT_STYLES+((i+LS_STYLES_START)*3)+1, text);
+
+		Com_sprintf(temp, sizeof(temp), "ls_%db", i);
+		G_SpawnString(temp, defaultStyles[i][2], &text);
+		lengthBlue = strlen(text);
+		trap_SetConfigstring(CS_LIGHT_STYLES+((i+LS_STYLES_START)*3)+2, text);
+
+		if (lengthRed != lengthGreen || lengthGreen != lengthBlue)
+		{
+			Com_Error(ERR_DROP, "Style %d has inconsistent lengths: R %d, G %d, B %d", 
+				i, lengthRed, lengthGreen, lengthBlue);
+		}
+	}		
+}
+
+//rww - Planning on having something here?
+qboolean SP_bsp_worldspawn ( void )
+{
+	return qtrue;
+}
+
+void G_PrecacheSoundsets( void )
+{
+	gentity_t	*ent = NULL;
+	int i;
+	int countedSets = 0;
+
+	for ( i = 0; i < MAX_GENTITIES; i++ )
+	{
+		ent = &g_entities[i];
+
+		if (ent->inuse && ent->soundSet && ent->soundSet[0])
+		{
+			if (countedSets >= MAX_AMBIENT_SETS)
+			{
+				Com_Error(ERR_DROP, "MAX_AMBIENT_SETS was exceeded! (too many soundsets)\n");
+			}
+
+			ent->s.soundSetIndex = G_SoundSetIndex(ent->soundSet);
+			countedSets++;
+		}
+	}
+}
+
+/*
+==============
+G_SpawnEntitiesFromString
+
+Parses textual entity definitions out of an entstring and spawns gentities.
+==============
+*/
+void G_SpawnEntitiesFromString( qboolean inSubBSP ) {
+	// allow calls to G_Spawn*()
+	level.spawning = qtrue;
+	level.numSpawnVars = 0;
+
+	// the worldspawn is not an actual entity, but it still
+	// has a "spawn" function to perform any global setup
+	// needed by a level (setting configstrings or cvars, etc)
+	if ( !G_ParseSpawnVars(qfalse) ) {
+		G_Error( "SpawnEntities: no entities" );
+	}
+
+	if (!inSubBSP)
+	{
+		SP_worldspawn();
+	}
+	else
+	{
+		// Skip this guy if its worldspawn fails
+		if ( !SP_bsp_worldspawn() )
+		{
+			return;
+		}
+	}
+
+	// parse ents
+	while( G_ParseSpawnVars(inSubBSP) ) {
+		G_SpawnGEntityFromSpawnVars(inSubBSP);
+	}	
+
+	if( g_entities[ENTITYNUM_WORLD].behaviorSet[BSET_SPAWN] && g_entities[ENTITYNUM_WORLD].behaviorSet[BSET_SPAWN][0] )
+	{//World has a spawn script, but we don't want the world in ICARUS and running scripts,
+		//so make a scriptrunner and start it going.
+		gentity_t *script_runner = G_Spawn();
+		if ( script_runner )
+		{
+			script_runner->behaviorSet[BSET_USE] = g_entities[ENTITYNUM_WORLD].behaviorSet[BSET_SPAWN];
+			script_runner->count = 1;
+			script_runner->think = scriptrunner_run;
+			script_runner->nextthink = level.time + 100;
+
+			if ( script_runner->inuse )
+			{
+				trap_ICARUS_InitEnt( script_runner );
+			}
+		}
+	}
+
+	if (!inSubBSP)
+	{
+		level.spawning = qfalse;			// any future calls to G_Spawn*() will be errors
+	}
+
+	G_PrecacheSoundsets();
+}
+
diff --git a/codemp/game/g_strap.c b/codemp/game/g_strap.c
new file mode 100644
index 0000000..9ade218
--- /dev/null
+++ b/codemp/game/g_strap.c
@@ -0,0 +1,73 @@
+//rww - shared trap call system
+#include "g_local.h"
+
+#include "../namespace_begin.h"
+
+qboolean strap_G2API_GetBoltMatrix(void *ghoul2, const int modelIndex, const int boltIndex, mdxaBone_t *matrix,
+								const vec3_t angles, const vec3_t position, const int frameNum, qhandle_t *modelList, vec3_t scale)
+{
+	return trap_G2API_GetBoltMatrix(ghoul2, modelIndex, boltIndex, matrix, angles, position, frameNum, modelList, scale);
+}
+
+qboolean strap_G2API_GetBoltMatrix_NoReconstruct(void *ghoul2, const int modelIndex, const int boltIndex, mdxaBone_t *matrix,
+								const vec3_t angles, const vec3_t position, const int frameNum, qhandle_t *modelList, vec3_t scale)
+{
+	return trap_G2API_GetBoltMatrix_NoReconstruct(ghoul2, modelIndex, boltIndex, matrix, angles, position, frameNum, modelList, scale);
+}
+
+qboolean strap_G2API_GetBoltMatrix_NoRecNoRot(void *ghoul2, const int modelIndex, const int boltIndex, mdxaBone_t *matrix,
+								const vec3_t angles, const vec3_t position, const int frameNum, qhandle_t *modelList, vec3_t scale)
+{
+	return trap_G2API_GetBoltMatrix_NoRecNoRot(ghoul2, modelIndex, boltIndex, matrix, angles, position, frameNum, modelList, scale);
+}
+
+qboolean strap_G2API_SetBoneAngles(void *ghoul2, int modelIndex, const char *boneName, const vec3_t angles, const int flags,
+								const int up, const int right, const int forward, qhandle_t *modelList,
+								int blendTime , int currentTime )
+{
+	return trap_G2API_SetBoneAngles(ghoul2, modelIndex, boneName, angles, flags, up, right, forward, modelList, blendTime, currentTime);
+}
+
+qboolean strap_G2API_SetBoneAnim(void *ghoul2, const int modelIndex, const char *boneName, const int startFrame, const int endFrame,
+							  const int flags, const float animSpeed, const int currentTime, const float setFrame , const int blendTime )
+{
+	return trap_G2API_SetBoneAnim(ghoul2, modelIndex, boneName, startFrame, endFrame, flags, animSpeed, currentTime, setFrame, blendTime);
+}
+
+qboolean strap_G2API_GetBoneAnim(void *ghoul2, const char *boneName, const int currentTime, float *currentFrame,
+						   int *startFrame, int *endFrame, int *flags, float *animSpeed, int *modelList, const int modelIndex)
+{
+	return trap_G2API_GetBoneAnim(ghoul2, boneName, currentTime, currentFrame, startFrame, endFrame, flags, animSpeed, modelList, modelIndex);
+}
+
+void strap_G2API_SetRagDoll(void *ghoul2, sharedRagDollParams_t *params)
+{
+	trap_G2API_SetRagDoll(ghoul2, params);
+}
+
+void strap_G2API_AnimateG2Models(void *ghoul2, int time, sharedRagDollUpdateParams_t *params)
+{
+	trap_G2API_AnimateG2Models(ghoul2, time, params);
+}
+
+qboolean strap_G2API_SetBoneIKState(void *ghoul2, int time, const char *boneName, int ikState, sharedSetBoneIKStateParams_t *params)
+{
+	return trap_G2API_SetBoneIKState(ghoul2, time, boneName, ikState, params);
+}
+
+qboolean strap_G2API_IKMove(void *ghoul2, int time, sharedIKMoveParams_t *params)
+{
+	return trap_G2API_IKMove(ghoul2, time, params);
+}
+
+void strap_TrueMalloc(void **ptr, int size)
+{
+	trap_TrueMalloc(ptr, size);
+}
+
+void strap_TrueFree(void **ptr)
+{
+	trap_TrueFree(ptr);
+}
+
+#include "../namespace_end.h"
diff --git a/codemp/game/g_svcmds.c b/codemp/game/g_svcmds.c
new file mode 100644
index 0000000..bcea59f
--- /dev/null
+++ b/codemp/game/g_svcmds.c
@@ -0,0 +1,470 @@
+// Copyright (C) 1999-2000 Id Software, Inc.
+//
+
+// this file holds commands that can be executed by the server console, but not remote clients
+
+#include "g_local.h"
+
+
+/*
+==============================================================================
+
+PACKET FILTERING
+ 
+
+You can add or remove addresses from the filter list with:
+
+addip <ip>
+removeip <ip>
+
+The ip address is specified in dot format, and any unspecified digits will match any value, so you can specify an entire class C network with "addip 192.246.40".
+
+Removeip will only remove an address specified exactly the same way.  You cannot addip a subnet, then removeip a single host.
+
+listip
+Prints the current list of filters.
+
+g_filterban <0 or 1>
+
+If 1 (the default), then ip addresses matching the current list will be prohibited from entering the game.  This is the default setting.
+
+If 0, then only addresses matching the list will be allowed.  This lets you easily set up a private game, or a game that only allows players from your local network.
+
+
+==============================================================================
+*/
+
+// extern	vmCvar_t	g_banIPs;
+// extern	vmCvar_t	g_filterBan;
+
+
+typedef struct ipFilter_s
+{
+	unsigned	mask;
+	unsigned	compare;
+} ipFilter_t;
+
+// VVFIXME - We don't need this at all, but this is the quick way.
+#ifdef _XBOX
+#define	MAX_IPFILTERS	1
+#else
+#define	MAX_IPFILTERS	1024
+#endif
+
+static ipFilter_t	ipFilters[MAX_IPFILTERS];
+static int			numIPFilters;
+
+/*
+=================
+StringToFilter
+=================
+*/
+static qboolean StringToFilter (char *s, ipFilter_t *f)
+{
+	char	num[128];
+	int		i, j;
+	byte	b[4];
+	byte	m[4];
+	
+	for (i=0 ; i<4 ; i++)
+	{
+		b[i] = 0;
+		m[i] = 0;
+	}
+	
+	for (i=0 ; i<4 ; i++)
+	{
+		if (*s < '0' || *s > '9')
+		{
+			G_Printf( "Bad filter address: %s\n", s );
+			return qfalse;
+		}
+		
+		j = 0;
+		while (*s >= '0' && *s <= '9')
+		{
+			num[j++] = *s++;
+		}
+		num[j] = 0;
+		b[i] = atoi(num);
+		if (b[i] != 0)
+			m[i] = 255;
+
+		if (!*s)
+			break;
+		s++;
+	}
+	
+	f->mask = *(unsigned *)m;
+	f->compare = *(unsigned *)b;
+	
+	return qtrue;
+}
+
+/*
+=================
+UpdateIPBans
+=================
+*/
+static void UpdateIPBans (void)
+{
+	byte	b[4];
+	int		i;
+	char	iplist[MAX_INFO_STRING];
+
+	*iplist = 0;
+	for (i = 0 ; i < numIPFilters ; i++)
+	{
+		if (ipFilters[i].compare == 0xffffffff)
+			continue;
+
+		*(unsigned *)b = ipFilters[i].compare;
+		Com_sprintf( iplist + strlen(iplist), sizeof(iplist) - strlen(iplist), 
+			"%i.%i.%i.%i ", b[0], b[1], b[2], b[3]);
+	}
+
+	trap_Cvar_Set( "g_banIPs", iplist );
+}
+
+/*
+=================
+G_FilterPacket
+=================
+*/
+qboolean G_FilterPacket (char *from)
+{
+	byte			m[4];// = {'\0','\0','\0','\0'};
+	int				i = 0;
+	unsigned int	in;
+	char			*p;
+
+	while (i < 4)
+	{
+		m[i] = 0;
+		i++;
+	}
+
+	i = 0;
+	p = from;
+	while (*p && i < 4) {
+		while (*p >= '0' && *p <= '9') {
+			m[i] = m[i]*10 + (*p - '0');
+			p++;
+		}
+		if (!*p || *p == ':')
+			break;
+		i++, p++;
+	}
+	
+	in = *(unsigned int *)m;
+
+	for (i=0 ; i<numIPFilters ; i++)
+		if ( (in & ipFilters[i].mask) == ipFilters[i].compare)
+			return g_filterBan.integer != 0;
+
+	return g_filterBan.integer == 0;
+}
+
+/*
+=================
+AddIP
+=================
+*/
+static void AddIP( char *str )
+{
+	int		i;
+
+	for (i = 0 ; i < numIPFilters ; i++)
+		if (ipFilters[i].compare == 0xffffffff)
+			break;		// free spot
+	if (i == numIPFilters)
+	{
+		if (numIPFilters == MAX_IPFILTERS)
+		{
+			G_Printf ("IP filter list is full\n");
+			return;
+		}
+		numIPFilters++;
+	}
+	
+	if (!StringToFilter (str, &ipFilters[i]))
+		ipFilters[i].compare = 0xffffffffu;
+
+	UpdateIPBans();
+}
+
+/*
+=================
+G_ProcessIPBans
+=================
+*/
+void G_ProcessIPBans(void) 
+{
+	char *s, *t;
+	char		str[MAX_TOKEN_CHARS];
+
+	Q_strncpyz( str, g_banIPs.string, sizeof(str) );
+
+	for (t = s = g_banIPs.string; *t; /* */ ) {
+		s = strchr(s, ' ');
+		if (!s)
+			break;
+		while (*s == ' ')
+			*s++ = 0;
+		if (*t)
+			AddIP( t );
+		t = s;
+	}
+}
+
+
+/*
+=================
+Svcmd_AddIP_f
+=================
+*/
+void Svcmd_AddIP_f (void)
+{
+	char		str[MAX_TOKEN_CHARS];
+
+	if ( trap_Argc() < 2 ) {
+		G_Printf("Usage:  addip <ip-mask>\n");
+		return;
+	}
+
+	trap_Argv( 1, str, sizeof( str ) );
+
+	AddIP( str );
+
+}
+
+/*
+=================
+Svcmd_RemoveIP_f
+=================
+*/
+void Svcmd_RemoveIP_f (void)
+{
+	ipFilter_t	f;
+	int			i;
+	char		str[MAX_TOKEN_CHARS];
+
+	if ( trap_Argc() < 2 ) {
+		G_Printf("Usage:  sv removeip <ip-mask>\n");
+		return;
+	}
+
+	trap_Argv( 1, str, sizeof( str ) );
+
+	if (!StringToFilter (str, &f))
+		return;
+
+	for (i=0 ; i<numIPFilters ; i++) {
+		if (ipFilters[i].mask == f.mask	&&
+			ipFilters[i].compare == f.compare) {
+			ipFilters[i].compare = 0xffffffffu;
+			G_Printf ("Removed.\n");
+
+			UpdateIPBans();
+			return;
+		}
+	}
+
+	G_Printf ( "Didn't find %s.\n", str );
+}
+
+/*
+===================
+Svcmd_EntityList_f
+===================
+*/
+void	Svcmd_EntityList_f (void) {
+	int			e;
+	gentity_t		*check;
+
+	check = g_entities+1;
+	for (e = 1; e < level.num_entities ; e++, check++) {
+		if ( !check->inuse ) {
+			continue;
+		}
+		G_Printf("%3i:", e);
+		switch ( check->s.eType ) {
+		case ET_GENERAL:
+			G_Printf("ET_GENERAL          ");
+			break;
+		case ET_PLAYER:
+			G_Printf("ET_PLAYER           ");
+			break;
+		case ET_ITEM:
+			G_Printf("ET_ITEM             ");
+			break;
+		case ET_MISSILE:
+			G_Printf("ET_MISSILE          ");
+			break;
+		case ET_MOVER:
+			G_Printf("ET_MOVER            ");
+			break;
+		case ET_BEAM:
+			G_Printf("ET_BEAM             ");
+			break;
+		case ET_PORTAL:
+			G_Printf("ET_PORTAL           ");
+			break;
+		case ET_SPEAKER:
+			G_Printf("ET_SPEAKER          ");
+			break;
+		case ET_PUSH_TRIGGER:
+			G_Printf("ET_PUSH_TRIGGER     ");
+			break;
+		case ET_TELEPORT_TRIGGER:
+			G_Printf("ET_TELEPORT_TRIGGER ");
+			break;
+		case ET_INVISIBLE:
+			G_Printf("ET_INVISIBLE        ");
+			break;
+		case ET_NPC:
+			G_Printf("ET_NPC              ");
+			break;
+		default:
+			G_Printf("%3i                 ", check->s.eType);
+			break;
+		}
+
+		if ( check->classname ) {
+			G_Printf("%s", check->classname);
+		}
+		G_Printf("\n");
+	}
+}
+
+gclient_t	*ClientForString( const char *s ) {
+	gclient_t	*cl;
+	int			i;
+	int			idnum;
+
+	// numeric values are just slot numbers
+	if ( s[0] >= '0' && s[0] <= '9' ) {
+		idnum = atoi( s );
+		if ( idnum < 0 || idnum >= level.maxclients ) {
+			Com_Printf( "Bad client slot: %i\n", idnum );
+			return NULL;
+		}
+
+		cl = &level.clients[idnum];
+		if ( cl->pers.connected == CON_DISCONNECTED ) {
+			G_Printf( "Client %i is not connected\n", idnum );
+			return NULL;
+		}
+		return cl;
+	}
+
+	// check for a name match
+	for ( i=0 ; i < level.maxclients ; i++ ) {
+		cl = &level.clients[i];
+		if ( cl->pers.connected == CON_DISCONNECTED ) {
+			continue;
+		}
+		if ( !Q_stricmp( cl->pers.netname, s ) ) {
+			return cl;
+		}
+	}
+
+	G_Printf( "User %s is not on the server\n", s );
+
+	return NULL;
+}
+
+/*
+===================
+Svcmd_ForceTeam_f
+
+forceteam <player> <team>
+===================
+*/
+void	Svcmd_ForceTeam_f( void ) {
+	gclient_t	*cl;
+	char		str[MAX_TOKEN_CHARS];
+
+	// find the player
+	trap_Argv( 1, str, sizeof( str ) );
+	cl = ClientForString( str );
+	if ( !cl ) {
+		return;
+	}
+
+	// set the team
+	trap_Argv( 2, str, sizeof( str ) );
+	SetTeam( &g_entities[cl - level.clients], str );
+}
+
+char	*ConcatArgs( int start );
+
+/*
+=================
+ConsoleCommand
+
+=================
+*/
+qboolean	ConsoleCommand( void ) {
+	char	cmd[MAX_TOKEN_CHARS];
+
+	trap_Argv( 0, cmd, sizeof( cmd ) );
+
+	if ( Q_stricmp (cmd, "entitylist") == 0 ) {
+		Svcmd_EntityList_f();
+		return qtrue;
+	}
+
+	if ( Q_stricmp (cmd, "forceteam") == 0 ) {
+		Svcmd_ForceTeam_f();
+		return qtrue;
+	}
+
+	if (Q_stricmp (cmd, "game_memory") == 0) {
+		Svcmd_GameMem_f();
+		return qtrue;
+	}
+
+	if (Q_stricmp (cmd, "addbot") == 0) {
+		Svcmd_AddBot_f();
+		return qtrue;
+	}
+
+	if (Q_stricmp (cmd, "botlist") == 0) {
+		Svcmd_BotList_f();
+		return qtrue;
+	}
+
+/*	if (Q_stricmp (cmd, "abort_podium") == 0) {
+		Svcmd_AbortPodium_f();
+		return qtrue;
+	}
+*/
+	if (Q_stricmp (cmd, "addip") == 0) {
+		Svcmd_AddIP_f();
+		return qtrue;
+	}
+
+	if (Q_stricmp (cmd, "removeip") == 0) {
+		Svcmd_RemoveIP_f();
+		return qtrue;
+	}
+
+	if (Q_stricmp (cmd, "listip") == 0) {
+		trap_SendConsoleCommand( EXEC_NOW, "g_banIPs\n" );
+		return qtrue;
+	}
+
+	if (g_dedicated.integer) {
+		if (Q_stricmp (cmd, "say") == 0) {
+			trap_SendServerCommand( -1, va("print \"server: %s\n\"", ConcatArgs(1) ) );
+			return qtrue;
+		}
+		// everything else will also be printed as a say command
+		trap_SendServerCommand( -1, va("print \"server: %s\n\"", ConcatArgs(0) ) );
+		return qtrue;
+	}
+
+	return qfalse;
+}
+
diff --git a/codemp/game/g_syscalls.c b/codemp/game/g_syscalls.c
new file mode 100644
index 0000000..61b87f1
--- /dev/null
+++ b/codemp/game/g_syscalls.c
@@ -0,0 +1,1469 @@
+// Copyright (C) 1999-2000 Id Software, Inc.
+//
+#include "g_local.h"
+
+// this file is only included when building a dll
+// g_syscalls.asm is included instead when building a qvm
+
+static int (QDECL *syscall)( int arg, ... ) = (int (QDECL *)( int, ...))-1;
+
+#include "../namespace_begin.h"
+void dllEntry( int (QDECL *syscallptr)( int arg,... ) ) {
+	syscall = syscallptr;
+}
+
+int PASSFLOAT( float x ) {
+	float	floatTemp;
+	floatTemp = x;
+	return *(int *)&floatTemp;
+}
+
+void	trap_Printf( const char *fmt ) {
+	syscall( G_PRINT, fmt );
+}
+
+void	trap_Error( const char *fmt ) {
+	syscall( G_ERROR, fmt );
+}
+
+int		trap_Milliseconds( void ) {
+	return syscall( G_MILLISECONDS ); 
+}
+
+
+//rww - precision timer funcs... -ALWAYS- call end after start with supplied ptr, or you'll get a nasty memory leak.
+//not that you should be using these outside of debug anyway.. because you shouldn't be. So don't.
+
+//Start should be suppled with a pointer to an empty pointer (e.g. void *blah; trap_PrecisionTimer_Start(&blah);),
+//the empty pointer will be filled with an exe address to our timer (this address means nothing in vm land however).
+//You must pass this pointer back unmodified to the timer end func.
+void trap_PrecisionTimer_Start(void **theNewTimer)
+{
+	syscall(G_PRECISIONTIMER_START, theNewTimer);
+}
+
+//If you're using the above example, the appropriate call for this is int result = trap_PrecisionTimer_End(blah);
+int trap_PrecisionTimer_End(void *theTimer)
+{
+	return syscall(G_PRECISIONTIMER_END, theTimer);
+}
+
+void	trap_Cvar_Register( vmCvar_t *cvar, const char *var_name, const char *value, int flags ) {
+	syscall( G_CVAR_REGISTER, cvar, var_name, value, flags );
+}
+
+void	trap_Cvar_Update( vmCvar_t *cvar ) {
+	syscall( G_CVAR_UPDATE, cvar );
+}
+
+void trap_Cvar_Set( const char *var_name, const char *value ) {
+	syscall( G_CVAR_SET, var_name, value );
+}
+
+int trap_Cvar_VariableIntegerValue( const char *var_name ) {
+	return syscall( G_CVAR_VARIABLE_INTEGER_VALUE, var_name );
+}
+
+void trap_Cvar_VariableStringBuffer( const char *var_name, char *buffer, int bufsize ) {
+	syscall( G_CVAR_VARIABLE_STRING_BUFFER, var_name, buffer, bufsize );
+}
+
+int		trap_Argc( void ) {
+	return syscall( G_ARGC );
+}
+
+void	trap_Argv( int n, char *buffer, int bufferLength ) {
+	syscall( G_ARGV, n, buffer, bufferLength );
+}
+
+int		trap_FS_FOpenFile( const char *qpath, fileHandle_t *f, fsMode_t mode ) {
+	return syscall( G_FS_FOPEN_FILE, qpath, f, mode );
+}
+
+void	trap_FS_Read( void *buffer, int len, fileHandle_t f ) {
+	syscall( G_FS_READ, buffer, len, f );
+}
+
+void	trap_FS_Write( const void *buffer, int len, fileHandle_t f ) {
+	syscall( G_FS_WRITE, buffer, len, f );
+}
+
+void	trap_FS_FCloseFile( fileHandle_t f ) {
+	syscall( G_FS_FCLOSE_FILE, f );
+}
+
+void	trap_SendConsoleCommand( int exec_when, const char *text ) {
+	syscall( G_SEND_CONSOLE_COMMAND, exec_when, text );
+}
+
+void trap_LocateGameData( gentity_t *gEnts, int numGEntities, int sizeofGEntity_t,
+						 playerState_t *clients, int sizeofGClient ) {
+	syscall( G_LOCATE_GAME_DATA, gEnts, numGEntities, sizeofGEntity_t, clients, sizeofGClient );
+}
+
+void trap_DropClient( int clientNum, const char *reason ) {
+	syscall( G_DROP_CLIENT, clientNum, reason );
+}
+
+void trap_SendServerCommand( int clientNum, const char *text ) {
+	syscall( G_SEND_SERVER_COMMAND, clientNum, text );
+}
+
+void trap_SetConfigstring( int num, const char *string ) {
+	syscall( G_SET_CONFIGSTRING, num, string );
+}
+
+void trap_GetConfigstring( int num, char *buffer, int bufferSize ) {
+	syscall( G_GET_CONFIGSTRING, num, buffer, bufferSize );
+}
+
+void trap_GetUserinfo( int num, char *buffer, int bufferSize ) {
+	syscall( G_GET_USERINFO, num, buffer, bufferSize );
+}
+
+void trap_SetUserinfo( int num, const char *buffer ) {
+	syscall( G_SET_USERINFO, num, buffer );
+}
+
+void trap_GetServerinfo( char *buffer, int bufferSize ) {
+	syscall( G_GET_SERVERINFO, buffer, bufferSize );
+}
+
+//server culling to reduce traffic on open maps -rww
+void trap_SetServerCull(float cullDistance)
+{
+	syscall(G_SET_SERVER_CULL, PASSFLOAT(cullDistance));
+}
+
+void trap_SetBrushModel( gentity_t *ent, const char *name ) {
+	syscall( G_SET_BRUSH_MODEL, ent, name );
+}
+
+void trap_Trace( trace_t *results, const vec3_t start, const vec3_t mins, const vec3_t maxs, const vec3_t end, int passEntityNum, int contentmask ) {
+	syscall( G_TRACE, results, start, mins, maxs, end, passEntityNum, contentmask, 0, 10 );
+}
+
+//g2TraceType 0 is no g2 col, 1 is collision against anything not EF_DEAD, 2 is collision against all.
+void trap_G2Trace( trace_t *results, const vec3_t start, const vec3_t mins, const vec3_t maxs, const vec3_t end, int passEntityNum, int contentmask, int g2TraceType, int traceLod ) {
+	syscall( G_G2TRACE, results, start, mins, maxs, end, passEntityNum, contentmask, g2TraceType, traceLod );
+}
+
+int trap_PointContents( const vec3_t point, int passEntityNum ) {
+	return syscall( G_POINT_CONTENTS, point, passEntityNum );
+}
+
+
+qboolean trap_InPVS( const vec3_t p1, const vec3_t p2 ) {
+	return syscall( G_IN_PVS, p1, p2 );
+}
+
+qboolean trap_InPVSIgnorePortals( const vec3_t p1, const vec3_t p2 ) {
+	return syscall( G_IN_PVS_IGNORE_PORTALS, p1, p2 );
+}
+
+void trap_AdjustAreaPortalState( gentity_t *ent, qboolean open ) {
+	syscall( G_ADJUST_AREA_PORTAL_STATE, ent, open );
+}
+
+qboolean trap_AreasConnected( int area1, int area2 ) {
+	return syscall( G_AREAS_CONNECTED, area1, area2 );
+}
+
+void trap_LinkEntity( gentity_t *ent ) {
+	syscall( G_LINKENTITY, ent );
+}
+
+void trap_UnlinkEntity( gentity_t *ent ) {
+	syscall( G_UNLINKENTITY, ent );
+}
+
+int trap_EntitiesInBox( const vec3_t mins, const vec3_t maxs, int *list, int maxcount ) {
+	return syscall( G_ENTITIES_IN_BOX, mins, maxs, list, maxcount );
+}
+
+qboolean trap_EntityContact( const vec3_t mins, const vec3_t maxs, const gentity_t *ent ) {
+	return syscall( G_ENTITY_CONTACT, mins, maxs, ent );
+}
+
+int trap_BotAllocateClient( void ) {
+	return syscall( G_BOT_ALLOCATE_CLIENT );
+}
+
+void trap_BotFreeClient( int clientNum ) {
+	syscall( G_BOT_FREE_CLIENT, clientNum );
+}
+
+void trap_GetUsercmd( int clientNum, usercmd_t *cmd ) {
+	syscall( G_GET_USERCMD, clientNum, cmd );
+}
+
+qboolean trap_GetEntityToken( char *buffer, int bufferSize ) {
+	return syscall( G_GET_ENTITY_TOKEN, buffer, bufferSize );
+}
+
+void trap_SiegePersSet(siegePers_t *pers)
+{
+	syscall(G_SIEGEPERSSET, pers);
+}
+void trap_SiegePersGet(siegePers_t *pers)
+{
+	syscall(G_SIEGEPERSGET, pers);
+}
+
+int trap_FS_GetFileList(  const char *path, const char *extension, char *listbuf, int bufsize ) {
+	return syscall( G_FS_GETFILELIST, path, extension, listbuf, bufsize );
+}
+
+int trap_DebugPolygonCreate(int color, int numPoints, vec3_t *points) {
+	return syscall( G_DEBUG_POLYGON_CREATE, color, numPoints, points );
+}
+
+void trap_DebugPolygonDelete(int id) {
+	syscall( G_DEBUG_POLYGON_DELETE, id );
+}
+
+int trap_RealTime( qtime_t *qtime ) {
+	return syscall( G_REAL_TIME, qtime );
+}
+
+void trap_SnapVector( float *v ) {
+	syscall( G_SNAPVECTOR, v );
+}
+
+void trap_TraceCapsule( trace_t *results, const vec3_t start, const vec3_t mins, const vec3_t maxs, const vec3_t end, int passEntityNum, int contentmask ) {
+	syscall( G_TRACECAPSULE, results, start, mins, maxs, end, passEntityNum, contentmask, 0, 10 );
+}
+
+qboolean trap_EntityContactCapsule( const vec3_t mins, const vec3_t maxs, const gentity_t *ent ) {
+	return syscall( G_ENTITY_CONTACTCAPSULE, mins, maxs, ent );
+}
+
+//qboolean trap_SP_RegisterServer( const char *package ) 
+//{
+//	return syscall( SP_REGISTER_SERVER_CMD, package );
+//}
+
+int trap_SP_GetStringTextString(const char *text, char *buffer, int bufferLength)
+{
+	return syscall( SP_GETSTRINGTEXTSTRING, text, buffer, bufferLength );
+}
+
+qboolean trap_ROFF_Clean( void ) 
+{
+	return syscall( G_ROFF_CLEAN );
+}
+
+void trap_ROFF_UpdateEntities( void ) 
+{
+	syscall( G_ROFF_UPDATE_ENTITIES );
+}
+
+int trap_ROFF_Cache( char *file ) 
+{
+	return syscall( G_ROFF_CACHE, file );
+}
+
+qboolean trap_ROFF_Play( int entID, int roffID, qboolean doTranslation ) 
+{
+	return syscall( G_ROFF_PLAY, entID, roffID, doTranslation );
+}
+
+qboolean trap_ROFF_Purge_Ent( int entID ) 
+{
+	return syscall( G_ROFF_PURGE_ENT, entID );
+}
+
+//rww - dynamic vm memory allocation!
+void trap_TrueMalloc(void **ptr, int size)
+{
+	syscall(G_TRUEMALLOC, ptr, size);
+}
+
+void trap_TrueFree(void **ptr)
+{
+	syscall(G_TRUEFREE, ptr);
+}
+
+//rww - icarus traps
+int trap_ICARUS_RunScript( gentity_t *ent, const char *name )
+{
+	return syscall(G_ICARUS_RUNSCRIPT, ent, name);
+}
+
+qboolean trap_ICARUS_RegisterScript( const char *name, qboolean bCalledDuringInterrogate)
+{
+	return syscall(G_ICARUS_REGISTERSCRIPT, name, bCalledDuringInterrogate);
+}
+
+void trap_ICARUS_Init( void )
+{
+	syscall(G_ICARUS_INIT);
+}
+
+qboolean trap_ICARUS_ValidEnt( gentity_t *ent )
+{
+	return syscall(G_ICARUS_VALIDENT, ent);
+}
+
+qboolean trap_ICARUS_IsInitialized( int entID )
+{
+	return syscall(G_ICARUS_ISINITIALIZED, entID);
+}
+
+qboolean trap_ICARUS_MaintainTaskManager( int entID )
+{
+	return syscall(G_ICARUS_MAINTAINTASKMANAGER, entID);
+}
+
+qboolean trap_ICARUS_IsRunning( int entID )
+{
+	return syscall(G_ICARUS_ISRUNNING, entID);
+}
+
+qboolean trap_ICARUS_TaskIDPending(gentity_t *ent, int taskID)
+{
+	return syscall(G_ICARUS_TASKIDPENDING, ent, taskID);
+}
+
+void trap_ICARUS_InitEnt( gentity_t *ent )
+{
+	syscall(G_ICARUS_INITENT, ent);
+}
+
+void trap_ICARUS_FreeEnt( gentity_t *ent )
+{
+	syscall(G_ICARUS_FREEENT, ent);
+}
+
+void trap_ICARUS_AssociateEnt( gentity_t *ent )
+{
+	syscall(G_ICARUS_ASSOCIATEENT, ent);
+}
+
+void trap_ICARUS_Shutdown( void )
+{
+	syscall(G_ICARUS_SHUTDOWN);
+}
+
+void trap_ICARUS_TaskIDSet(gentity_t *ent, int taskType, int taskID)
+{
+	syscall(G_ICARUS_TASKIDSET, ent, taskType, taskID);
+}
+
+void trap_ICARUS_TaskIDComplete(gentity_t *ent, int taskType)
+{
+	syscall(G_ICARUS_TASKIDCOMPLETE, ent, taskType);
+}
+
+void trap_ICARUS_SetVar(int taskID, int entID, const char *type_name, const char *data)
+{
+	syscall(G_ICARUS_SETVAR, taskID, entID, type_name, data);
+}
+
+int trap_ICARUS_VariableDeclared(const char *type_name)
+{
+	return syscall(G_ICARUS_VARIABLEDECLARED, type_name);
+}
+
+int trap_ICARUS_GetFloatVariable( const char *name, float *value )
+{
+	return syscall(G_ICARUS_GETFLOATVARIABLE, name, value);
+}
+
+int trap_ICARUS_GetStringVariable( const char *name, const char *value )
+{
+	return syscall(G_ICARUS_GETSTRINGVARIABLE, name, value);
+}
+
+int trap_ICARUS_GetVectorVariable( const char *name, const vec3_t value )
+{
+	return syscall(G_ICARUS_GETVECTORVARIABLE, name, value);
+}
+
+//rww - BEGIN NPC NAV TRAPS
+void trap_Nav_Init( void )
+{
+	syscall(G_NAV_INIT);
+}
+
+void trap_Nav_Free( void )
+{
+	syscall(G_NAV_FREE);
+}
+
+qboolean trap_Nav_Load( const char *filename, int checksum )
+{
+	return syscall(G_NAV_LOAD, filename, checksum);
+}
+
+qboolean trap_Nav_Save( const char *filename, int checksum )
+{
+	return syscall(G_NAV_SAVE, filename, checksum);
+}
+
+int trap_Nav_AddRawPoint( vec3_t point, int flags, int radius )
+{
+	return syscall(G_NAV_ADDRAWPOINT, point, flags, radius);
+}
+
+void trap_Nav_CalculatePaths( qboolean recalc ) //recalc = qfalse
+{
+	syscall(G_NAV_CALCULATEPATHS, recalc);
+}
+
+void trap_Nav_HardConnect( int first, int second )
+{
+	syscall(G_NAV_HARDCONNECT, first, second);
+}
+
+void trap_Nav_ShowNodes( void )
+{
+	syscall(G_NAV_SHOWNODES);
+}
+
+void trap_Nav_ShowEdges( void )
+{
+	syscall(G_NAV_SHOWEDGES);
+}
+
+void trap_Nav_ShowPath( int start, int end )
+{
+	syscall(G_NAV_SHOWPATH, start, end);
+}
+
+int trap_Nav_GetNearestNode( gentity_t *ent, int lastID, int flags, int targetID )
+{
+	return syscall(G_NAV_GETNEARESTNODE, ent, lastID, flags, targetID);
+}
+
+int trap_Nav_GetBestNode( int startID, int endID, int rejectID ) //rejectID = NODE_NONE
+{
+	return syscall(G_NAV_GETBESTNODE, startID, endID, rejectID);
+}
+
+int trap_Nav_GetNodePosition( int nodeID, vec3_t out )
+{
+	return syscall(G_NAV_GETNODEPOSITION, nodeID, out);
+}
+
+int trap_Nav_GetNodeNumEdges( int nodeID )
+{
+	return syscall(G_NAV_GETNODENUMEDGES, nodeID);
+}
+
+int trap_Nav_GetNodeEdge( int nodeID, int edge )
+{
+	return syscall(G_NAV_GETNODEEDGE, nodeID, edge);
+}
+
+int trap_Nav_GetNumNodes( void )
+{
+	return syscall(G_NAV_GETNUMNODES);
+}
+	
+qboolean trap_Nav_Connected( int startID, int endID )
+{
+	return syscall(G_NAV_CONNECTED, startID, endID);
+}
+
+int trap_Nav_GetPathCost( int startID, int endID )
+{
+	return syscall(G_NAV_GETPATHCOST, startID, endID);
+}
+
+int trap_Nav_GetEdgeCost( int startID, int endID )
+{
+	return syscall(G_NAV_GETEDGECOST, startID, endID);
+}
+
+int trap_Nav_GetProjectedNode( vec3_t origin, int nodeID )
+{
+	return syscall(G_NAV_GETPROJECTEDNODE, origin, nodeID);
+}
+
+void trap_Nav_CheckFailedNodes( gentity_t *ent )
+{
+	syscall(G_NAV_CHECKFAILEDNODES, ent);
+}
+
+void trap_Nav_AddFailedNode( gentity_t *ent, int nodeID )
+{
+	syscall(G_NAV_ADDFAILEDNODE, ent, nodeID);
+}
+
+qboolean trap_Nav_NodeFailed( gentity_t *ent, int nodeID )
+{
+	return syscall(G_NAV_NODEFAILED, ent, nodeID);
+}
+
+qboolean trap_Nav_NodesAreNeighbors( int startID, int endID )
+{
+	return syscall(G_NAV_NODESARENEIGHBORS, startID, endID);
+}
+
+void trap_Nav_ClearFailedEdge( failedEdge_t	*failedEdge )
+{
+	syscall(G_NAV_CLEARFAILEDEDGE, failedEdge);
+}
+
+void trap_Nav_ClearAllFailedEdges( void )
+{
+	syscall(G_NAV_CLEARALLFAILEDEDGES);
+}
+
+int trap_Nav_EdgeFailed( int startID, int endID )
+{
+	return syscall(G_NAV_EDGEFAILED, startID, endID);
+}
+
+void trap_Nav_AddFailedEdge( int entID, int startID, int endID )
+{
+	syscall(G_NAV_ADDFAILEDEDGE, entID, startID, endID);
+}
+
+qboolean trap_Nav_CheckFailedEdge( failedEdge_t *failedEdge )
+{
+	return syscall(G_NAV_CHECKFAILEDEDGE, failedEdge);
+}
+
+void trap_Nav_CheckAllFailedEdges( void )
+{
+	syscall(G_NAV_CHECKALLFAILEDEDGES);
+}
+
+qboolean trap_Nav_RouteBlocked( int startID, int testEdgeID, int endID, int rejectRank )
+{
+	return syscall(G_NAV_ROUTEBLOCKED, startID, testEdgeID, endID, rejectRank);
+}
+
+int trap_Nav_GetBestNodeAltRoute( int startID, int endID, int *pathCost, int rejectID ) //rejectID = NODE_NONE
+{
+	return syscall(G_NAV_GETBESTNODEALTROUTE, startID, endID, pathCost, rejectID);
+}
+
+int trap_Nav_GetBestNodeAltRoute2( int startID, int endID, int rejectID ) //rejectID = NODE_NONE
+{
+	return syscall(G_NAV_GETBESTNODEALT2, startID, endID, rejectID);
+}
+	
+int trap_Nav_GetBestPathBetweenEnts( gentity_t *ent, gentity_t *goal, int flags )
+{
+	return syscall(G_NAV_GETBESTPATHBETWEENENTS, ent, goal, flags);
+}
+
+int	trap_Nav_GetNodeRadius( int nodeID )
+{
+	return syscall(G_NAV_GETNODERADIUS, nodeID);
+}
+
+void trap_Nav_CheckBlockedEdges( void )
+{
+	syscall(G_NAV_CHECKBLOCKEDEDGES);
+}
+
+void trap_Nav_ClearCheckedNodes( void )
+{
+	syscall(G_NAV_CLEARCHECKEDNODES);
+}
+
+int trap_Nav_CheckedNode(int wayPoint, int ent) //return int was byte
+{
+	return syscall(G_NAV_CHECKEDNODE, wayPoint, ent);
+}
+
+void trap_Nav_SetCheckedNode(int wayPoint, int ent, int value) //int value was byte value
+{
+	syscall(G_NAV_SETCHECKEDNODE, wayPoint, ent, value);
+}
+
+void trap_Nav_FlagAllNodes( int newFlag )
+{
+	syscall(G_NAV_FLAGALLNODES, newFlag);
+}
+
+qboolean trap_Nav_GetPathsCalculated(void)
+{
+	return syscall(G_NAV_GETPATHSCALCULATED);
+}
+
+void trap_Nav_SetPathsCalculated(qboolean newVal)
+{
+	syscall(G_NAV_SETPATHSCALCULATED, newVal);
+}
+//rww - END NPC NAV TRAPS
+
+void trap_SV_RegisterSharedMemory(char *memory)
+{
+	syscall(G_SET_SHARED_BUFFER, memory);
+}
+
+// BotLib traps start here
+int trap_BotLibSetup( void ) {
+	return syscall( BOTLIB_SETUP );
+}
+
+int trap_BotLibShutdown( void ) {
+	return syscall( BOTLIB_SHUTDOWN );
+}
+
+int trap_BotLibVarSet(char *var_name, char *value) {
+	return syscall( BOTLIB_LIBVAR_SET, var_name, value );
+}
+
+int trap_BotLibVarGet(char *var_name, char *value, int size) {
+	return syscall( BOTLIB_LIBVAR_GET, var_name, value, size );
+}
+
+int trap_BotLibDefine(char *string) {
+	return syscall( BOTLIB_PC_ADD_GLOBAL_DEFINE, string );
+}
+
+int trap_BotLibStartFrame(float time) {
+	return syscall( BOTLIB_START_FRAME, PASSFLOAT( time ) );
+}
+
+int trap_BotLibLoadMap(const char *mapname) {
+	return syscall( BOTLIB_LOAD_MAP, mapname );
+}
+
+int trap_BotLibUpdateEntity(int ent, void /* struct bot_updateentity_s */ *bue) {
+	return syscall( BOTLIB_UPDATENTITY, ent, bue );
+}
+
+int trap_BotLibTest(int parm0, char *parm1, vec3_t parm2, vec3_t parm3) {
+	return syscall( BOTLIB_TEST, parm0, parm1, parm2, parm3 );
+}
+
+int trap_BotGetSnapshotEntity( int clientNum, int sequence ) {
+	return syscall( BOTLIB_GET_SNAPSHOT_ENTITY, clientNum, sequence );
+}
+
+int trap_BotGetServerCommand(int clientNum, char *message, int size) {
+	return syscall( BOTLIB_GET_CONSOLE_MESSAGE, clientNum, message, size );
+}
+
+void trap_BotUserCommand(int clientNum, usercmd_t *ucmd) {
+	syscall( BOTLIB_USER_COMMAND, clientNum, ucmd );
+}
+
+void trap_AAS_EntityInfo(int entnum, void /* struct aas_entityinfo_s */ *info) {
+	syscall( BOTLIB_AAS_ENTITY_INFO, entnum, info );
+}
+
+int trap_AAS_Initialized(void) {
+	return syscall( BOTLIB_AAS_INITIALIZED );
+}
+
+void trap_AAS_PresenceTypeBoundingBox(int presencetype, vec3_t mins, vec3_t maxs) {
+	syscall( BOTLIB_AAS_PRESENCE_TYPE_BOUNDING_BOX, presencetype, mins, maxs );
+}
+
+float trap_AAS_Time(void) {
+	int temp;
+	temp = syscall( BOTLIB_AAS_TIME );
+	return (*(float*)&temp);
+}
+
+int trap_AAS_PointAreaNum(vec3_t point) {
+	return syscall( BOTLIB_AAS_POINT_AREA_NUM, point );
+}
+
+int trap_AAS_PointReachabilityAreaIndex(vec3_t point) {
+	return syscall( BOTLIB_AAS_POINT_REACHABILITY_AREA_INDEX, point );
+}
+
+int trap_AAS_TraceAreas(vec3_t start, vec3_t end, int *areas, vec3_t *points, int maxareas) {
+	return syscall( BOTLIB_AAS_TRACE_AREAS, start, end, areas, points, maxareas );
+}
+
+int trap_AAS_BBoxAreas(vec3_t absmins, vec3_t absmaxs, int *areas, int maxareas) {
+	return syscall( BOTLIB_AAS_BBOX_AREAS, absmins, absmaxs, areas, maxareas );
+}
+
+int trap_AAS_AreaInfo( int areanum, void /* struct aas_areainfo_s */ *info ) {
+	return syscall( BOTLIB_AAS_AREA_INFO, areanum, info );
+}
+
+int trap_AAS_PointContents(vec3_t point) {
+	return syscall( BOTLIB_AAS_POINT_CONTENTS, point );
+}
+
+int trap_AAS_NextBSPEntity(int ent) {
+	return syscall( BOTLIB_AAS_NEXT_BSP_ENTITY, ent );
+}
+
+int trap_AAS_ValueForBSPEpairKey(int ent, char *key, char *value, int size) {
+	return syscall( BOTLIB_AAS_VALUE_FOR_BSP_EPAIR_KEY, ent, key, value, size );
+}
+
+int trap_AAS_VectorForBSPEpairKey(int ent, char *key, vec3_t v) {
+	return syscall( BOTLIB_AAS_VECTOR_FOR_BSP_EPAIR_KEY, ent, key, v );
+}
+
+int trap_AAS_FloatForBSPEpairKey(int ent, char *key, float *value) {
+	return syscall( BOTLIB_AAS_FLOAT_FOR_BSP_EPAIR_KEY, ent, key, value );
+}
+
+int trap_AAS_IntForBSPEpairKey(int ent, char *key, int *value) {
+	return syscall( BOTLIB_AAS_INT_FOR_BSP_EPAIR_KEY, ent, key, value );
+}
+
+int trap_AAS_AreaReachability(int areanum) {
+	return syscall( BOTLIB_AAS_AREA_REACHABILITY, areanum );
+}
+
+int trap_AAS_AreaTravelTimeToGoalArea(int areanum, vec3_t origin, int goalareanum, int travelflags) {
+	return syscall( BOTLIB_AAS_AREA_TRAVEL_TIME_TO_GOAL_AREA, areanum, origin, goalareanum, travelflags );
+}
+
+int trap_AAS_EnableRoutingArea( int areanum, int enable ) {
+	return syscall( BOTLIB_AAS_ENABLE_ROUTING_AREA, areanum, enable );
+}
+
+int trap_AAS_PredictRoute(void /*struct aas_predictroute_s*/ *route, int areanum, vec3_t origin,
+							int goalareanum, int travelflags, int maxareas, int maxtime,
+							int stopevent, int stopcontents, int stoptfl, int stopareanum) {
+	return syscall( BOTLIB_AAS_PREDICT_ROUTE, route, areanum, origin, goalareanum, travelflags, maxareas, maxtime, stopevent, stopcontents, stoptfl, stopareanum );
+}
+
+int trap_AAS_AlternativeRouteGoals(vec3_t start, int startareanum, vec3_t goal, int goalareanum, int travelflags,
+										void /*struct aas_altroutegoal_s*/ *altroutegoals, int maxaltroutegoals,
+										int type) {
+	return syscall( BOTLIB_AAS_ALTERNATIVE_ROUTE_GOAL, start, startareanum, goal, goalareanum, travelflags, altroutegoals, maxaltroutegoals, type );
+}
+
+int trap_AAS_Swimming(vec3_t origin) {
+	return syscall( BOTLIB_AAS_SWIMMING, origin );
+}
+
+int trap_AAS_PredictClientMovement(void /* struct aas_clientmove_s */ *move, int entnum, vec3_t origin, int presencetype, int onground, vec3_t velocity, vec3_t cmdmove, int cmdframes, int maxframes, float frametime, int stopevent, int stopareanum, int visualize) {
+	return syscall( BOTLIB_AAS_PREDICT_CLIENT_MOVEMENT, move, entnum, origin, presencetype, onground, velocity, cmdmove, cmdframes, maxframes, PASSFLOAT(frametime), stopevent, stopareanum, visualize );
+}
+
+void trap_EA_Say(int client, char *str) {
+	syscall( BOTLIB_EA_SAY, client, str );
+}
+
+void trap_EA_SayTeam(int client, char *str) {
+	syscall( BOTLIB_EA_SAY_TEAM, client, str );
+}
+
+void trap_EA_Command(int client, char *command) {
+	syscall( BOTLIB_EA_COMMAND, client, command );
+}
+
+void trap_EA_Action(int client, int action) {
+	syscall( BOTLIB_EA_ACTION, client, action );
+}
+
+void trap_EA_Gesture(int client) {
+	syscall( BOTLIB_EA_GESTURE, client );
+}
+
+void trap_EA_Talk(int client) {
+	syscall( BOTLIB_EA_TALK, client );
+}
+
+void trap_EA_Attack(int client) {
+	syscall( BOTLIB_EA_ATTACK, client );
+}
+
+void trap_EA_Alt_Attack(int client) {
+	syscall( BOTLIB_EA_ALT_ATTACK, client );
+}
+
+void trap_EA_ForcePower(int client) {
+	syscall( BOTLIB_EA_FORCEPOWER, client );
+}
+
+void trap_EA_Use(int client) {
+	syscall( BOTLIB_EA_USE, client );
+}
+
+void trap_EA_Respawn(int client) {
+	syscall( BOTLIB_EA_RESPAWN, client );
+}
+
+void trap_EA_Crouch(int client) {
+	syscall( BOTLIB_EA_CROUCH, client );
+}
+
+void trap_EA_MoveUp(int client) {
+	syscall( BOTLIB_EA_MOVE_UP, client );
+}
+
+void trap_EA_MoveDown(int client) {
+	syscall( BOTLIB_EA_MOVE_DOWN, client );
+}
+
+void trap_EA_MoveForward(int client) {
+	syscall( BOTLIB_EA_MOVE_FORWARD, client );
+}
+
+void trap_EA_MoveBack(int client) {
+	syscall( BOTLIB_EA_MOVE_BACK, client );
+}
+
+void trap_EA_MoveLeft(int client) {
+	syscall( BOTLIB_EA_MOVE_LEFT, client );
+}
+
+void trap_EA_MoveRight(int client) {
+	syscall( BOTLIB_EA_MOVE_RIGHT, client );
+}
+
+void trap_EA_SelectWeapon(int client, int weapon) {
+	syscall( BOTLIB_EA_SELECT_WEAPON, client, weapon );
+}
+
+void trap_EA_Jump(int client) {
+	syscall( BOTLIB_EA_JUMP, client );
+}
+
+void trap_EA_DelayedJump(int client) {
+	syscall( BOTLIB_EA_DELAYED_JUMP, client );
+}
+
+void trap_EA_Move(int client, vec3_t dir, float speed) {
+	syscall( BOTLIB_EA_MOVE, client, dir, PASSFLOAT(speed) );
+}
+
+void trap_EA_View(int client, vec3_t viewangles) {
+	syscall( BOTLIB_EA_VIEW, client, viewangles );
+}
+
+void trap_EA_EndRegular(int client, float thinktime) {
+	syscall( BOTLIB_EA_END_REGULAR, client, PASSFLOAT(thinktime) );
+}
+
+void trap_EA_GetInput(int client, float thinktime, void /* struct bot_input_s */ *input) {
+	syscall( BOTLIB_EA_GET_INPUT, client, PASSFLOAT(thinktime), input );
+}
+
+void trap_EA_ResetInput(int client) {
+	syscall( BOTLIB_EA_RESET_INPUT, client );
+}
+
+int trap_BotLoadCharacter(char *charfile, float skill) {
+	return syscall( BOTLIB_AI_LOAD_CHARACTER, charfile, PASSFLOAT(skill));
+}
+
+void trap_BotFreeCharacter(int character) {
+	syscall( BOTLIB_AI_FREE_CHARACTER, character );
+}
+
+float trap_Characteristic_Float(int character, int index) {
+	int temp;
+	temp = syscall( BOTLIB_AI_CHARACTERISTIC_FLOAT, character, index );
+	return (*(float*)&temp);
+}
+
+float trap_Characteristic_BFloat(int character, int index, float min, float max) {
+	int temp;
+	temp = syscall( BOTLIB_AI_CHARACTERISTIC_BFLOAT, character, index, PASSFLOAT(min), PASSFLOAT(max) );
+	return (*(float*)&temp);
+}
+
+int trap_Characteristic_Integer(int character, int index) {
+	return syscall( BOTLIB_AI_CHARACTERISTIC_INTEGER, character, index );
+}
+
+int trap_Characteristic_BInteger(int character, int index, int min, int max) {
+	return syscall( BOTLIB_AI_CHARACTERISTIC_BINTEGER, character, index, min, max );
+}
+
+void trap_Characteristic_String(int character, int index, char *buf, int size) {
+	syscall( BOTLIB_AI_CHARACTERISTIC_STRING, character, index, buf, size );
+}
+
+int trap_BotAllocChatState(void) {
+	return syscall( BOTLIB_AI_ALLOC_CHAT_STATE );
+}
+
+void trap_BotFreeChatState(int handle) {
+	syscall( BOTLIB_AI_FREE_CHAT_STATE, handle );
+}
+
+void trap_BotQueueConsoleMessage(int chatstate, int type, char *message) {
+	syscall( BOTLIB_AI_QUEUE_CONSOLE_MESSAGE, chatstate, type, message );
+}
+
+void trap_BotRemoveConsoleMessage(int chatstate, int handle) {
+	syscall( BOTLIB_AI_REMOVE_CONSOLE_MESSAGE, chatstate, handle );
+}
+
+int trap_BotNextConsoleMessage(int chatstate, void /* struct bot_consolemessage_s */ *cm) {
+	return syscall( BOTLIB_AI_NEXT_CONSOLE_MESSAGE, chatstate, cm );
+}
+
+int trap_BotNumConsoleMessages(int chatstate) {
+	return syscall( BOTLIB_AI_NUM_CONSOLE_MESSAGE, chatstate );
+}
+
+void trap_BotInitialChat(int chatstate, char *type, int mcontext, char *var0, char *var1, char *var2, char *var3, char *var4, char *var5, char *var6, char *var7 ) {
+	syscall( BOTLIB_AI_INITIAL_CHAT, chatstate, type, mcontext, var0, var1, var2, var3, var4, var5, var6, var7 );
+}
+
+int	trap_BotNumInitialChats(int chatstate, char *type) {
+	return syscall( BOTLIB_AI_NUM_INITIAL_CHATS, chatstate, type );
+}
+
+int trap_BotReplyChat(int chatstate, char *message, int mcontext, int vcontext, char *var0, char *var1, char *var2, char *var3, char *var4, char *var5, char *var6, char *var7 ) {
+	return syscall( BOTLIB_AI_REPLY_CHAT, chatstate, message, mcontext, vcontext, var0, var1, var2, var3, var4, var5, var6, var7 );
+}
+
+int trap_BotChatLength(int chatstate) {
+	return syscall( BOTLIB_AI_CHAT_LENGTH, chatstate );
+}
+
+void trap_BotEnterChat(int chatstate, int client, int sendto) {
+	syscall( BOTLIB_AI_ENTER_CHAT, chatstate, client, sendto );
+}
+
+void trap_BotGetChatMessage(int chatstate, char *buf, int size) {
+	syscall( BOTLIB_AI_GET_CHAT_MESSAGE, chatstate, buf, size);
+}
+
+int trap_StringContains(char *str1, char *str2, int casesensitive) {
+	return syscall( BOTLIB_AI_STRING_CONTAINS, str1, str2, casesensitive );
+}
+
+int trap_BotFindMatch(char *str, void /* struct bot_match_s */ *match, unsigned long int context) {
+	return syscall( BOTLIB_AI_FIND_MATCH, str, match, context );
+}
+
+void trap_BotMatchVariable(void /* struct bot_match_s */ *match, int variable, char *buf, int size) {
+	syscall( BOTLIB_AI_MATCH_VARIABLE, match, variable, buf, size );
+}
+
+void trap_UnifyWhiteSpaces(char *string) {
+	syscall( BOTLIB_AI_UNIFY_WHITE_SPACES, string );
+}
+
+void trap_BotReplaceSynonyms(char *string, unsigned long int context) {
+	syscall( BOTLIB_AI_REPLACE_SYNONYMS, string, context );
+}
+
+int trap_BotLoadChatFile(int chatstate, char *chatfile, char *chatname) {
+	return syscall( BOTLIB_AI_LOAD_CHAT_FILE, chatstate, chatfile, chatname );
+}
+
+void trap_BotSetChatGender(int chatstate, int gender) {
+	syscall( BOTLIB_AI_SET_CHAT_GENDER, chatstate, gender );
+}
+
+void trap_BotSetChatName(int chatstate, char *name, int client) {
+	syscall( BOTLIB_AI_SET_CHAT_NAME, chatstate, name, client );
+}
+
+void trap_BotResetGoalState(int goalstate) {
+	syscall( BOTLIB_AI_RESET_GOAL_STATE, goalstate );
+}
+
+void trap_BotResetAvoidGoals(int goalstate) {
+	syscall( BOTLIB_AI_RESET_AVOID_GOALS, goalstate );
+}
+
+void trap_BotRemoveFromAvoidGoals(int goalstate, int number) {
+	syscall( BOTLIB_AI_REMOVE_FROM_AVOID_GOALS, goalstate, number);
+}
+
+void trap_BotPushGoal(int goalstate, void /* struct bot_goal_s */ *goal) {
+	syscall( BOTLIB_AI_PUSH_GOAL, goalstate, goal );
+}
+
+void trap_BotPopGoal(int goalstate) {
+	syscall( BOTLIB_AI_POP_GOAL, goalstate );
+}
+
+void trap_BotEmptyGoalStack(int goalstate) {
+	syscall( BOTLIB_AI_EMPTY_GOAL_STACK, goalstate );
+}
+
+void trap_BotDumpAvoidGoals(int goalstate) {
+	syscall( BOTLIB_AI_DUMP_AVOID_GOALS, goalstate );
+}
+
+void trap_BotDumpGoalStack(int goalstate) {
+	syscall( BOTLIB_AI_DUMP_GOAL_STACK, goalstate );
+}
+
+void trap_BotGoalName(int number, char *name, int size) {
+	syscall( BOTLIB_AI_GOAL_NAME, number, name, size );
+}
+
+int trap_BotGetTopGoal(int goalstate, void /* struct bot_goal_s */ *goal) {
+	return syscall( BOTLIB_AI_GET_TOP_GOAL, goalstate, goal );
+}
+
+int trap_BotGetSecondGoal(int goalstate, void /* struct bot_goal_s */ *goal) {
+	return syscall( BOTLIB_AI_GET_SECOND_GOAL, goalstate, goal );
+}
+
+int trap_BotChooseLTGItem(int goalstate, vec3_t origin, int *inventory, int travelflags) {
+	return syscall( BOTLIB_AI_CHOOSE_LTG_ITEM, goalstate, origin, inventory, travelflags );
+}
+
+int trap_BotChooseNBGItem(int goalstate, vec3_t origin, int *inventory, int travelflags, void /* struct bot_goal_s */ *ltg, float maxtime) {
+	return syscall( BOTLIB_AI_CHOOSE_NBG_ITEM, goalstate, origin, inventory, travelflags, ltg, PASSFLOAT(maxtime) );
+}
+
+int trap_BotTouchingGoal(vec3_t origin, void /* struct bot_goal_s */ *goal) {
+	return syscall( BOTLIB_AI_TOUCHING_GOAL, origin, goal );
+}
+
+int trap_BotItemGoalInVisButNotVisible(int viewer, vec3_t eye, vec3_t viewangles, void /* struct bot_goal_s */ *goal) {
+	return syscall( BOTLIB_AI_ITEM_GOAL_IN_VIS_BUT_NOT_VISIBLE, viewer, eye, viewangles, goal );
+}
+
+int trap_BotGetLevelItemGoal(int index, char *classname, void /* struct bot_goal_s */ *goal) {
+	return syscall( BOTLIB_AI_GET_LEVEL_ITEM_GOAL, index, classname, goal );
+}
+
+int trap_BotGetNextCampSpotGoal(int num, void /* struct bot_goal_s */ *goal) {
+	return syscall( BOTLIB_AI_GET_NEXT_CAMP_SPOT_GOAL, num, goal );
+}
+
+int trap_BotGetMapLocationGoal(char *name, void /* struct bot_goal_s */ *goal) {
+	return syscall( BOTLIB_AI_GET_MAP_LOCATION_GOAL, name, goal );
+}
+
+float trap_BotAvoidGoalTime(int goalstate, int number) {
+	int temp;
+	temp = syscall( BOTLIB_AI_AVOID_GOAL_TIME, goalstate, number );
+	return (*(float*)&temp);
+}
+
+void trap_BotSetAvoidGoalTime(int goalstate, int number, float avoidtime) {
+	syscall( BOTLIB_AI_SET_AVOID_GOAL_TIME, goalstate, number, PASSFLOAT(avoidtime));
+}
+
+void trap_BotInitLevelItems(void) {
+	syscall( BOTLIB_AI_INIT_LEVEL_ITEMS );
+}
+
+void trap_BotUpdateEntityItems(void) {
+	syscall( BOTLIB_AI_UPDATE_ENTITY_ITEMS );
+}
+
+int trap_BotLoadItemWeights(int goalstate, char *filename) {
+	return syscall( BOTLIB_AI_LOAD_ITEM_WEIGHTS, goalstate, filename );
+}
+
+void trap_BotFreeItemWeights(int goalstate) {
+	syscall( BOTLIB_AI_FREE_ITEM_WEIGHTS, goalstate );
+}
+
+void trap_BotInterbreedGoalFuzzyLogic(int parent1, int parent2, int child) {
+	syscall( BOTLIB_AI_INTERBREED_GOAL_FUZZY_LOGIC, parent1, parent2, child );
+}
+
+void trap_BotSaveGoalFuzzyLogic(int goalstate, char *filename) {
+	syscall( BOTLIB_AI_SAVE_GOAL_FUZZY_LOGIC, goalstate, filename );
+}
+
+void trap_BotMutateGoalFuzzyLogic(int goalstate, float range) {
+	syscall( BOTLIB_AI_MUTATE_GOAL_FUZZY_LOGIC, goalstate, range );
+}
+
+int trap_BotAllocGoalState(int state) {
+	return syscall( BOTLIB_AI_ALLOC_GOAL_STATE, state );
+}
+
+void trap_BotFreeGoalState(int handle) {
+	syscall( BOTLIB_AI_FREE_GOAL_STATE, handle );
+}
+
+void trap_BotResetMoveState(int movestate) {
+	syscall( BOTLIB_AI_RESET_MOVE_STATE, movestate );
+}
+
+void trap_BotAddAvoidSpot(int movestate, vec3_t origin, float radius, int type) {
+	syscall( BOTLIB_AI_ADD_AVOID_SPOT, movestate, origin, PASSFLOAT(radius), type);
+}
+
+void trap_BotMoveToGoal(void /* struct bot_moveresult_s */ *result, int movestate, void /* struct bot_goal_s */ *goal, int travelflags) {
+	syscall( BOTLIB_AI_MOVE_TO_GOAL, result, movestate, goal, travelflags );
+}
+
+int trap_BotMoveInDirection(int movestate, vec3_t dir, float speed, int type) {
+	return syscall( BOTLIB_AI_MOVE_IN_DIRECTION, movestate, dir, PASSFLOAT(speed), type );
+}
+
+void trap_BotResetAvoidReach(int movestate) {
+	syscall( BOTLIB_AI_RESET_AVOID_REACH, movestate );
+}
+
+void trap_BotResetLastAvoidReach(int movestate) {
+	syscall( BOTLIB_AI_RESET_LAST_AVOID_REACH,movestate  );
+}
+
+int trap_BotReachabilityArea(vec3_t origin, int testground) {
+	return syscall( BOTLIB_AI_REACHABILITY_AREA, origin, testground );
+}
+
+int trap_BotMovementViewTarget(int movestate, void /* struct bot_goal_s */ *goal, int travelflags, float lookahead, vec3_t target) {
+	return syscall( BOTLIB_AI_MOVEMENT_VIEW_TARGET, movestate, goal, travelflags, PASSFLOAT(lookahead), target );
+}
+
+int trap_BotPredictVisiblePosition(vec3_t origin, int areanum, void /* struct bot_goal_s */ *goal, int travelflags, vec3_t target) {
+	return syscall( BOTLIB_AI_PREDICT_VISIBLE_POSITION, origin, areanum, goal, travelflags, target );
+}
+
+int trap_BotAllocMoveState(void) {
+	return syscall( BOTLIB_AI_ALLOC_MOVE_STATE );
+}
+
+void trap_BotFreeMoveState(int handle) {
+	syscall( BOTLIB_AI_FREE_MOVE_STATE, handle );
+}
+
+void trap_BotInitMoveState(int handle, void /* struct bot_initmove_s */ *initmove) {
+	syscall( BOTLIB_AI_INIT_MOVE_STATE, handle, initmove );
+}
+
+int trap_BotChooseBestFightWeapon(int weaponstate, int *inventory) {
+	return syscall( BOTLIB_AI_CHOOSE_BEST_FIGHT_WEAPON, weaponstate, inventory );
+}
+
+void trap_BotGetWeaponInfo(int weaponstate, int weapon, void /* struct weaponinfo_s */ *weaponinfo) {
+	syscall( BOTLIB_AI_GET_WEAPON_INFO, weaponstate, weapon, weaponinfo );
+}
+
+int trap_BotLoadWeaponWeights(int weaponstate, char *filename) {
+	return syscall( BOTLIB_AI_LOAD_WEAPON_WEIGHTS, weaponstate, filename );
+}
+
+int trap_BotAllocWeaponState(void) {
+	return syscall( BOTLIB_AI_ALLOC_WEAPON_STATE );
+}
+
+void trap_BotFreeWeaponState(int weaponstate) {
+	syscall( BOTLIB_AI_FREE_WEAPON_STATE, weaponstate );
+}
+
+void trap_BotResetWeaponState(int weaponstate) {
+	syscall( BOTLIB_AI_RESET_WEAPON_STATE, weaponstate );
+}
+
+int trap_GeneticParentsAndChildSelection(int numranks, float *ranks, int *parent1, int *parent2, int *child) {
+	return syscall( BOTLIB_AI_GENETIC_PARENTS_AND_CHILD_SELECTION, numranks, ranks, parent1, parent2, child );
+}
+
+int trap_PC_LoadSource( const char *filename ) {
+	return syscall( BOTLIB_PC_LOAD_SOURCE, filename );
+}
+
+int trap_PC_FreeSource( int handle ) {
+	return syscall( BOTLIB_PC_FREE_SOURCE, handle );
+}
+
+int trap_PC_ReadToken( int handle, pc_token_t *pc_token ) {
+	return syscall( BOTLIB_PC_READ_TOKEN, handle, pc_token );
+}
+
+int trap_PC_SourceFileAndLine( int handle, char *filename, int *line ) {
+	return syscall( BOTLIB_PC_SOURCE_FILE_AND_LINE, handle, filename, line );
+}
+
+
+/*
+Ghoul2 Insert Start
+*/
+qhandle_t trap_R_RegisterSkin( const char *name )
+{
+	return syscall( G_R_REGISTERSKIN, name );
+}
+
+// CG Specific API calls
+void trap_G2_ListModelBones(void *ghlInfo, int frame)
+{
+	syscall( G_G2_LISTBONES, ghlInfo, frame);
+}
+
+void trap_G2_ListModelSurfaces(void *ghlInfo)
+{
+	syscall( G_G2_LISTSURFACES, ghlInfo);
+}
+
+qboolean trap_G2_HaveWeGhoul2Models(	void *ghoul2)
+{
+	return (qboolean)(syscall(G_G2_HAVEWEGHOULMODELS, ghoul2));
+}
+
+void trap_G2_SetGhoul2ModelIndexes(void *ghoul2, qhandle_t *modelList, qhandle_t *skinList)
+{
+	syscall( G_G2_SETMODELS, ghoul2, modelList, skinList);
+}
+
+qboolean trap_G2API_GetBoltMatrix(void *ghoul2, const int modelIndex, const int boltIndex, mdxaBone_t *matrix,
+								const vec3_t angles, const vec3_t position, const int frameNum, qhandle_t *modelList, vec3_t scale)
+{
+	return (qboolean)(syscall(G_G2_GETBOLT, ghoul2, modelIndex, boltIndex, matrix, angles, position, frameNum, modelList, scale));
+}
+
+qboolean trap_G2API_GetBoltMatrix_NoReconstruct(void *ghoul2, const int modelIndex, const int boltIndex, mdxaBone_t *matrix,
+								const vec3_t angles, const vec3_t position, const int frameNum, qhandle_t *modelList, vec3_t scale)
+{ //Same as above but force it to not reconstruct the skeleton before getting the bolt position
+	return (qboolean)(syscall(G_G2_GETBOLT_NOREC, ghoul2, modelIndex, boltIndex, matrix, angles, position, frameNum, modelList, scale));
+}
+
+qboolean trap_G2API_GetBoltMatrix_NoRecNoRot(void *ghoul2, const int modelIndex, const int boltIndex, mdxaBone_t *matrix,
+								const vec3_t angles, const vec3_t position, const int frameNum, qhandle_t *modelList, vec3_t scale)
+{ //Same as above but force it to not reconstruct the skeleton before getting the bolt position
+	return (qboolean)(syscall(G_G2_GETBOLT_NOREC_NOROT, ghoul2, modelIndex, boltIndex, matrix, angles, position, frameNum, modelList, scale));
+}
+
+int trap_G2API_InitGhoul2Model(void **ghoul2Ptr, const char *fileName, int modelIndex, qhandle_t customSkin,
+						  qhandle_t customShader, int modelFlags, int lodBias)
+{
+	return syscall(G_G2_INITGHOUL2MODEL, ghoul2Ptr, fileName, modelIndex, customSkin, customShader, modelFlags, lodBias);
+}
+
+qboolean trap_G2API_SetSkin(void *ghoul2, int modelIndex, qhandle_t customSkin, qhandle_t renderSkin)
+{
+	return syscall(G_G2_SETSKIN, ghoul2, modelIndex, customSkin, renderSkin);
+}
+
+int trap_G2API_Ghoul2Size ( void* ghlInfo )
+{
+	return syscall(G_G2_SIZE, ghlInfo );
+}
+
+int trap_G2API_AddBolt(void *ghoul2, int modelIndex, const char *boneName)
+{
+	return syscall(G_G2_ADDBOLT, ghoul2, modelIndex, boneName);
+}
+
+void trap_G2API_SetBoltInfo(void *ghoul2, int modelIndex, int boltInfo)
+{
+	syscall(G_G2_SETBOLTINFO, ghoul2, modelIndex, boltInfo);
+}
+
+qboolean trap_G2API_SetBoneAngles(void *ghoul2, int modelIndex, const char *boneName, const vec3_t angles, const int flags,
+								const int up, const int right, const int forward, qhandle_t *modelList,
+								int blendTime , int currentTime )
+{
+	return (syscall(G_G2_ANGLEOVERRIDE, ghoul2, modelIndex, boneName, angles, flags, up, right, forward, modelList, blendTime, currentTime));
+}
+
+qboolean trap_G2API_SetBoneAnim(void *ghoul2, const int modelIndex, const char *boneName, const int startFrame, const int endFrame,
+							  const int flags, const float animSpeed, const int currentTime, const float setFrame , const int blendTime )
+{
+	return syscall(G_G2_PLAYANIM, ghoul2, modelIndex, boneName, startFrame, endFrame, flags, PASSFLOAT(animSpeed), currentTime, PASSFLOAT(setFrame), blendTime);
+}
+
+qboolean trap_G2API_GetBoneAnim(void *ghoul2, const char *boneName, const int currentTime, float *currentFrame,
+						   int *startFrame, int *endFrame, int *flags, float *animSpeed, int *modelList, const int modelIndex)
+{
+	return syscall(G_G2_GETBONEANIM, ghoul2, boneName, currentTime, currentFrame, startFrame, endFrame, flags, animSpeed, modelList, modelIndex);
+}
+
+void trap_G2API_GetGLAName(void *ghoul2, int modelIndex, char *fillBuf)
+{
+	syscall(G_G2_GETGLANAME, ghoul2, modelIndex, fillBuf);
+}
+
+int trap_G2API_CopyGhoul2Instance(void *g2From, void *g2To, int modelIndex)
+{
+	return syscall(G_G2_COPYGHOUL2INSTANCE, g2From, g2To, modelIndex);
+}
+
+void trap_G2API_CopySpecificGhoul2Model(void *g2From, int modelFrom, void *g2To, int modelTo)
+{
+	syscall(G_G2_COPYSPECIFICGHOUL2MODEL, g2From, modelFrom, g2To, modelTo);
+}
+
+void trap_G2API_DuplicateGhoul2Instance(void *g2From, void **g2To)
+{
+	syscall(G_G2_DUPLICATEGHOUL2INSTANCE, g2From, g2To);
+}
+
+qboolean trap_G2API_HasGhoul2ModelOnIndex(void *ghlInfo, int modelIndex)
+{
+	return syscall(G_G2_HASGHOUL2MODELONINDEX, ghlInfo, modelIndex);
+}
+
+qboolean trap_G2API_RemoveGhoul2Model(void *ghlInfo, int modelIndex)
+{
+	return syscall(G_G2_REMOVEGHOUL2MODEL, ghlInfo, modelIndex);
+}
+
+qboolean trap_G2API_RemoveGhoul2Models(void *ghlInfo)
+{
+	return syscall(G_G2_REMOVEGHOUL2MODELS, ghlInfo);
+}
+
+void trap_G2API_CleanGhoul2Models(void **ghoul2Ptr)
+{
+	syscall(G_G2_CLEANMODELS, ghoul2Ptr);
+}
+
+void trap_G2API_CollisionDetect ( 
+	CollisionRecord_t *collRecMap, 
+	void* ghoul2, 
+	const vec3_t angles, 
+	const vec3_t position,
+	int frameNumber, 
+	int entNum, 
+	vec3_t rayStart, 
+	vec3_t rayEnd, 
+	vec3_t scale, 
+	int traceFlags, 
+	int useLod,
+	float fRadius
+	)
+{
+	syscall ( G_G2_COLLISIONDETECT, collRecMap, ghoul2, angles, position, frameNumber, entNum, rayStart, rayEnd, scale, traceFlags, useLod, PASSFLOAT(fRadius) );
+}
+
+void trap_G2API_GetSurfaceName(void *ghoul2, int surfNumber, int modelIndex, char *fillBuf)
+{
+	syscall(G_G2_GETSURFACENAME, ghoul2, surfNumber, modelIndex, fillBuf);
+}
+
+qboolean trap_G2API_SetRootSurface(void *ghoul2, const int modelIndex, const char *surfaceName)
+{
+	return syscall(G_G2_SETROOTSURFACE, ghoul2, modelIndex, surfaceName);
+}
+
+qboolean trap_G2API_SetSurfaceOnOff(void *ghoul2, const char *surfaceName, const int flags)
+{
+	return syscall(G_G2_SETSURFACEONOFF, ghoul2, surfaceName, flags);
+}
+
+qboolean trap_G2API_SetNewOrigin(void *ghoul2, const int boltIndex)
+{
+	return syscall(G_G2_SETNEWORIGIN, ghoul2, boltIndex);
+}
+
+//check if a bone exists on skeleton without actually adding to the bone list -rww
+qboolean trap_G2API_DoesBoneExist(void *ghoul2, int modelIndex, const char *boneName)
+{
+	return syscall(G_G2_DOESBONEEXIST, ghoul2, modelIndex, boneName);
+}
+
+int trap_G2API_GetSurfaceRenderStatus(void *ghoul2, const int modelIndex, const char *surfaceName)
+{
+	return syscall(G_G2_GETSURFACERENDERSTATUS, ghoul2, modelIndex, surfaceName);
+}
+
+//hack for smoothing during ugly situations. forgive me.
+void trap_G2API_AbsurdSmoothing(void *ghoul2, qboolean status)
+{
+	syscall(G_G2_ABSURDSMOOTHING, ghoul2, status);
+}
+
+//rww - RAGDOLL_BEGIN
+void trap_G2API_SetRagDoll(void *ghoul2, sharedRagDollParams_t *params)
+{
+	syscall(G_G2_SETRAGDOLL, ghoul2, params);
+}
+
+void trap_G2API_AnimateG2Models(void *ghoul2, int time, sharedRagDollUpdateParams_t *params)
+{
+	syscall(G_G2_ANIMATEG2MODELS, ghoul2, time, params);
+}
+//rww - RAGDOLL_END
+
+//additional ragdoll options -rww
+qboolean trap_G2API_RagPCJConstraint(void *ghoul2, const char *boneName, vec3_t min, vec3_t max) //override default pcj bonee constraints
+{
+	return syscall(G_G2_RAGPCJCONSTRAINT, ghoul2, boneName, min, max);
+}
+
+qboolean trap_G2API_RagPCJGradientSpeed(void *ghoul2, const char *boneName, const float speed) //override the default gradient movespeed for a pcj bone
+{
+	return syscall(G_G2_RAGPCJGRADIENTSPEED, ghoul2, boneName, PASSFLOAT(speed));
+}
+
+qboolean trap_G2API_RagEffectorGoal(void *ghoul2, const char *boneName, vec3_t pos) //override an effector bone's goal position (world coordinates)
+{
+	return syscall(G_G2_RAGEFFECTORGOAL, ghoul2, boneName, pos);
+}
+
+qboolean trap_G2API_GetRagBonePos(void *ghoul2, const char *boneName, vec3_t pos, vec3_t entAngles, vec3_t entPos, vec3_t entScale) //current position of said bone is put into pos (world coordinates)
+{
+	return syscall(G_G2_GETRAGBONEPOS, ghoul2, boneName, pos, entAngles, entPos, entScale);
+}
+
+qboolean trap_G2API_RagEffectorKick(void *ghoul2, const char *boneName, vec3_t velocity) //add velocity to a rag bone
+{
+	return syscall(G_G2_RAGEFFECTORKICK, ghoul2, boneName, velocity);
+}
+
+qboolean trap_G2API_RagForceSolve(void *ghoul2, qboolean force) //make sure we are actively performing solve/settle routines, if desired
+{
+	return syscall(G_G2_RAGFORCESOLVE, ghoul2, force);
+}
+
+qboolean trap_G2API_SetBoneIKState(void *ghoul2, int time, const char *boneName, int ikState, sharedSetBoneIKStateParams_t *params)
+{
+	return syscall(G_G2_SETBONEIKSTATE, ghoul2, time, boneName, ikState, params);
+}
+
+qboolean trap_G2API_IKMove(void *ghoul2, int time, sharedIKMoveParams_t *params)
+{
+	return syscall(G_G2_IKMOVE, ghoul2, time, params);
+}
+
+qboolean trap_G2API_RemoveBone(void *ghoul2, const char *boneName, int modelIndex)
+{
+	return syscall(G_G2_REMOVEBONE, ghoul2, boneName, modelIndex);
+}
+
+//rww - Stuff to allow association of ghoul2 instances to entity numbers.
+//This way, on listen servers when both the client and server are doing
+//ghoul2 operations, we can copy relevant data off the client instance
+//directly onto the server instance and slash the transforms and whatnot
+//right in half.
+void trap_G2API_AttachInstanceToEntNum(void *ghoul2, int entityNum, qboolean server)
+{
+	syscall(G_G2_ATTACHINSTANCETOENTNUM, ghoul2, entityNum, server);
+}
+
+void trap_G2API_ClearAttachedInstance(int entityNum)
+{
+	syscall(G_G2_CLEARATTACHEDINSTANCE, entityNum);
+}
+
+void trap_G2API_CleanEntAttachments(void)
+{
+	syscall(G_G2_CLEANENTATTACHMENTS);
+}
+
+qboolean trap_G2API_OverrideServer(void *serverInstance)
+{
+	return syscall(G_G2_OVERRIDESERVER, serverInstance);
+}
+
+/*
+Ghoul2 Insert End
+*/
+
+void trap_SetActiveSubBSP(int index)
+{ //rwwRMG - added [NEWTRAP]
+	syscall( G_SET_ACTIVE_SUBBSP, index );
+}
+
+int	trap_CM_RegisterTerrain(const char *config)
+{ //rwwRMG - added [NEWTRAP]
+	return syscall(G_CM_REGISTER_TERRAIN, config);
+}
+
+void trap_RMG_Init(int terrainID)
+{ //rwwRMG - added [NEWTRAP]
+	syscall(G_RMG_INIT, terrainID);
+}
+
+void trap_Bot_UpdateWaypoints(int wpnum, wpobject_t **wps)
+{
+	syscall(G_BOT_UPDATEWAYPOINTS, wpnum, wps);
+}
+
+void trap_Bot_CalculatePaths(int rmg)
+{
+	syscall(G_BOT_CALCULATEPATHS, rmg);
+}
+
+#include "../namespace_end.h"
diff --git a/codemp/game/g_target.c b/codemp/game/g_target.c
new file mode 100644
index 0000000..94ba33a
--- /dev/null
+++ b/codemp/game/g_target.c
@@ -0,0 +1,987 @@
+// Copyright (C) 1999-2000 Id Software, Inc.
+//
+#include "g_local.h"
+
+//==========================================================
+
+/*QUAKED target_give (1 0 0) (-8 -8 -8) (8 8 8)
+Gives the activator all the items pointed to.
+*/
+void Use_Target_Give( gentity_t *ent, gentity_t *other, gentity_t *activator ) {
+	gentity_t	*t;
+	trace_t		trace;
+
+	if ( !activator->client ) {
+		return;
+	}
+
+	if ( !ent->target ) {
+		return;
+	}
+
+	memset( &trace, 0, sizeof( trace ) );
+	t = NULL;
+	while ( (t = G_Find (t, FOFS(targetname), ent->target)) != NULL ) {
+		if ( !t->item ) {
+			continue;
+		}
+		Touch_Item( t, activator, &trace );
+
+		// make sure it isn't going to respawn or show any events
+		t->nextthink = 0;
+		trap_UnlinkEntity( t );
+	}
+}
+
+void SP_target_give( gentity_t *ent ) {
+	ent->use = Use_Target_Give;
+}
+
+
+//==========================================================
+
+/*QUAKED target_remove_powerups (1 0 0) (-8 -8 -8) (8 8 8)
+takes away all the activators powerups.
+Used to drop flight powerups into death puts.
+*/
+void Use_target_remove_powerups( gentity_t *ent, gentity_t *other, gentity_t *activator ) {
+	if( !activator->client ) {
+		return;
+	}
+
+	if( activator->client->ps.powerups[PW_REDFLAG] ) {
+		Team_ReturnFlag( TEAM_RED );
+	} else if( activator->client->ps.powerups[PW_BLUEFLAG] ) {
+		Team_ReturnFlag( TEAM_BLUE );
+	} else if( activator->client->ps.powerups[PW_NEUTRALFLAG] ) {
+		Team_ReturnFlag( TEAM_FREE );
+	}
+
+	memset( activator->client->ps.powerups, 0, sizeof( activator->client->ps.powerups ) );
+}
+
+void SP_target_remove_powerups( gentity_t *ent ) {
+	ent->use = Use_target_remove_powerups;
+}
+
+
+//==========================================================
+
+/*QUAKED target_delay (1 0 0) (-8 -8 -8) (8 8 8) NO_RETRIGGER
+
+NO_RETRIGGER - Keeps the delay from resetting the time if it is
+activated again while it is counting down to an event.
+
+"wait" seconds to pause before firing targets.
+"random" delay variance, total delay = delay +/- random seconds
+*/
+void Think_Target_Delay( gentity_t *ent ) {
+	G_UseTargets( ent, ent->activator );
+}
+
+void Use_Target_Delay( gentity_t *ent, gentity_t *other, gentity_t *activator ) {
+	if (ent->nextthink > level.time && (ent->spawnflags & 1))
+	{ //Leave me alone, I am thinking.
+		return;
+	}
+	G_ActivateBehavior(ent,BSET_USE);
+	ent->nextthink = level.time + ( ent->wait + ent->random * crandom() ) * 1000;
+	ent->think = Think_Target_Delay;
+	ent->activator = activator;
+}
+
+void SP_target_delay( gentity_t *ent ) {
+	// check delay for backwards compatability
+	if ( !G_SpawnFloat( "delay", "0", &ent->wait ) ) {
+		G_SpawnFloat( "wait", "1", &ent->wait );
+	}
+
+	if ( !ent->wait ) {
+		ent->wait = 1;
+	}
+	ent->use = Use_Target_Delay;
+}
+
+
+//==========================================================
+
+/*QUAKED target_score (1 0 0) (-8 -8 -8) (8 8 8)
+"count" number of points to add, default 1
+
+The activator is given this many points.
+*/
+void Use_Target_Score (gentity_t *ent, gentity_t *other, gentity_t *activator) {
+	AddScore( activator, ent->r.currentOrigin, ent->count );
+}
+
+void SP_target_score( gentity_t *ent ) {
+	if ( !ent->count ) {
+		ent->count = 1;
+	}
+	ent->use = Use_Target_Score;
+}
+
+
+//==========================================================
+
+/*QUAKED target_print (1 0 0) (-8 -8 -8) (8 8 8) redteam blueteam private
+"message"	text to print
+"wait"		don't fire off again if triggered within this many milliseconds ago
+If "private", only the activator gets the message.  If no checks, all clients get the message.
+*/
+void Use_Target_Print (gentity_t *ent, gentity_t *other, gentity_t *activator)
+{
+	if (!ent || !ent->inuse)
+	{
+		Com_Error(ERR_DROP, "Bad ent in Use_Target_Print");
+	}
+	else if (!activator || !activator->inuse)
+	{
+		Com_Error(ERR_DROP, "Bad activator in Use_Target_Print");
+	}
+
+	if (ent->wait)
+	{
+		if (ent->genericValue14 >= level.time)
+		{
+			return;
+		}
+		ent->genericValue14 = level.time + ent->wait;
+	}
+
+#ifndef FINAL_BUILD
+	if (ent->genericValue15 > level.time)
+	{
+		Com_Printf("TARGET PRINT ERRORS:\n");
+		if (activator && activator->classname && activator->classname[0])
+		{
+			Com_Printf("activator classname: %s\n", activator->classname);
+		}
+		if (activator && activator->target && activator->target[0])
+		{
+			Com_Printf("activator target: %s\n", activator->target);
+		}
+		if (activator && activator->targetname && activator->targetname[0])
+		{
+			Com_Printf("activator targetname: %s\n", activator->targetname);
+		}
+		if (ent->targetname && ent->targetname[0])
+		{
+			Com_Printf("print targetname: %s\n", ent->targetname);
+		}
+		Com_Error(ERR_DROP, "target_print used in quick succession, fix it! See the console for details.");
+	}
+	ent->genericValue15 = level.time + 5000;
+#endif
+
+	G_ActivateBehavior(ent,BSET_USE);
+	if ( activator->client && ( ent->spawnflags & 4 ) ) {
+		if (ent->message[0] == '@' && ent->message[1] != '@')
+		{
+			trap_SendServerCommand( activator-g_entities, va("cps \"%s\"", ent->message ));
+		}
+		else
+		{
+			trap_SendServerCommand( activator-g_entities, va("cp \"%s\"", ent->message ));
+		}
+		return;
+	}
+
+	if ( ent->spawnflags & 3 ) {
+		if ( ent->spawnflags & 1 ) {
+			if (ent->message[0] == '@' && ent->message[1] != '@')
+			{
+				G_TeamCommand( TEAM_RED, va("cps \"%s\"", ent->message) );
+			}
+			else
+			{
+				G_TeamCommand( TEAM_RED, va("cp \"%s\"", ent->message) );
+			}
+		}
+		if ( ent->spawnflags & 2 ) {
+			if (ent->message[0] == '@' && ent->message[1] != '@')
+			{
+				G_TeamCommand( TEAM_BLUE, va("cps \"%s\"", ent->message) );
+			}
+			else
+			{
+				G_TeamCommand( TEAM_BLUE, va("cp \"%s\"", ent->message) );
+			}
+		}
+		return;
+	}
+
+	if (ent->message[0] == '@' && ent->message[1] != '@')
+	{
+		trap_SendServerCommand( -1, va("cps \"%s\"", ent->message ));
+	}
+	else
+	{
+		trap_SendServerCommand( -1, va("cp \"%s\"", ent->message ));
+	}
+}
+
+void SP_target_print( gentity_t *ent ) {
+	ent->use = Use_Target_Print;
+}
+
+
+//==========================================================
+
+
+/*QUAKED target_speaker (1 0 0) (-8 -8 -8) (8 8 8) looped-on looped-off global activator
+"noise"		wav file to play
+
+A global sound will play full volume throughout the level.
+Activator sounds will play on the player that activated the target.
+Global and activator sounds can't be combined with looping.
+Normal sounds play each time the target is used.
+Looped sounds will be toggled by use functions.
+Multiple identical looping sounds will just increase volume without any speed cost.
+"wait" : Seconds between auto triggerings, 0 = don't auto trigger
+"random"	wait variance, default is 0
+*/
+void Use_Target_Speaker (gentity_t *ent, gentity_t *other, gentity_t *activator) {
+	G_ActivateBehavior(ent,BSET_USE);
+
+	if (ent->spawnflags & 3) {	// looping sound toggles
+		if (ent->s.loopSound)
+		{
+			ent->s.loopSound = 0;	// turn it off
+			ent->s.loopIsSoundset = qfalse;
+			ent->s.trickedentindex = 1;
+		}
+		else
+		{
+			ent->s.loopSound = ent->noise_index;	// start it
+			ent->s.loopIsSoundset = qfalse;
+			ent->s.trickedentindex = 0;
+		}
+	}else {	// normal sound
+		if ( ent->spawnflags & 8 ) {
+			G_AddEvent( activator, EV_GENERAL_SOUND, ent->noise_index );
+		} else if (ent->spawnflags & 4) {
+			G_AddEvent( ent, EV_GLOBAL_SOUND, ent->noise_index );
+		} else {
+			G_AddEvent( ent, EV_GENERAL_SOUND, ent->noise_index );
+		}
+	}
+}
+
+void SP_target_speaker( gentity_t *ent ) {
+	char	buffer[MAX_QPATH];
+	char	*s;
+
+	G_SpawnFloat( "wait", "0", &ent->wait );
+	G_SpawnFloat( "random", "0", &ent->random );
+
+	if ( G_SpawnString ( "soundSet", "", &s ) )
+	{	// this is a sound set
+		ent->s.soundSetIndex = G_SoundSetIndex(s);
+		ent->s.eFlags = EF_PERMANENT;
+		VectorCopy( ent->s.origin, ent->s.pos.trBase );
+		trap_LinkEntity (ent);
+		return;
+	}
+
+	if ( !G_SpawnString( "noise", "NOSOUND", &s ) ) {
+		G_Error( "target_speaker without a noise key at %s", vtos( ent->s.origin ) );
+	}
+
+	// force all client reletive sounds to be "activator" speakers that
+	// play on the entity that activates it
+	if ( s[0] == '*' ) {
+		ent->spawnflags |= 8;
+	}
+
+	Q_strncpyz( buffer, s, sizeof(buffer) );
+
+	ent->noise_index = G_SoundIndex(buffer);
+
+	// a repeating speaker can be done completely client side
+	ent->s.eType = ET_SPEAKER;
+	ent->s.eventParm = ent->noise_index;
+	ent->s.frame = ent->wait * 10;
+	ent->s.clientNum = ent->random * 10;
+
+
+	// check for prestarted looping sound
+	if ( ent->spawnflags & 1 ) {
+		ent->s.loopSound = ent->noise_index;
+		ent->s.loopIsSoundset = qfalse;
+	}
+
+	ent->use = Use_Target_Speaker;
+
+	if (ent->spawnflags & 4) {
+		ent->r.svFlags |= SVF_BROADCAST;
+	}
+
+	VectorCopy( ent->s.origin, ent->s.pos.trBase );
+
+	// must link the entity so we get areas and clusters so
+	// the server can determine who to send updates to
+	trap_LinkEntity( ent );
+}
+
+
+
+//==========================================================
+
+/*QUAKED target_laser (0 .5 .8) (-8 -8 -8) (8 8 8) START_ON
+When triggered, fires a laser.  You can either set a target or a direction.
+*/
+void target_laser_think (gentity_t *self) {
+	vec3_t	end;
+	trace_t	tr;
+	vec3_t	point;
+
+	// if pointed at another entity, set movedir to point at it
+	if ( self->enemy ) {
+		VectorMA (self->enemy->s.origin, 0.5, self->enemy->r.mins, point);
+		VectorMA (point, 0.5, self->enemy->r.maxs, point);
+		VectorSubtract (point, self->s.origin, self->movedir);
+		VectorNormalize (self->movedir);
+	}
+
+	// fire forward and see what we hit
+	VectorMA (self->s.origin, 2048, self->movedir, end);
+
+	trap_Trace( &tr, self->s.origin, NULL, NULL, end, self->s.number, CONTENTS_SOLID|CONTENTS_BODY|CONTENTS_CORPSE);
+
+	if ( tr.entityNum ) {
+		// hurt it if we can
+		G_Damage ( &g_entities[tr.entityNum], self, self->activator, self->movedir, 
+			tr.endpos, self->damage, DAMAGE_NO_KNOCKBACK, MOD_TARGET_LASER);
+	}
+
+	VectorCopy (tr.endpos, self->s.origin2);
+
+	trap_LinkEntity( self );
+	self->nextthink = level.time + FRAMETIME;
+}
+
+void target_laser_on (gentity_t *self)
+{
+	if (!self->activator)
+		self->activator = self;
+	target_laser_think (self);
+}
+
+void target_laser_off (gentity_t *self)
+{
+	trap_UnlinkEntity( self );
+	self->nextthink = 0;
+}
+
+void target_laser_use (gentity_t *self, gentity_t *other, gentity_t *activator)
+{
+	self->activator = activator;
+	if ( self->nextthink > 0 )
+		target_laser_off (self);
+	else
+		target_laser_on (self);
+}
+
+void target_laser_start (gentity_t *self)
+{
+	gentity_t *ent;
+
+	self->s.eType = ET_BEAM;
+
+	if (self->target) {
+		ent = G_Find (NULL, FOFS(targetname), self->target);
+		if (!ent) {
+			G_Printf ("%s at %s: %s is a bad target\n", self->classname, vtos(self->s.origin), self->target);
+		}
+		self->enemy = ent;
+	} else {
+		G_SetMovedir (self->s.angles, self->movedir);
+	}
+
+	self->use = target_laser_use;
+	self->think = target_laser_think;
+
+	if ( !self->damage ) {
+		self->damage = 1;
+	}
+
+	if (self->spawnflags & 1)
+		target_laser_on (self);
+	else
+		target_laser_off (self);
+}
+
+void SP_target_laser (gentity_t *self)
+{
+	// let everything else get spawned before we start firing
+	self->think = target_laser_start;
+	self->nextthink = level.time + FRAMETIME;
+}
+
+
+//==========================================================
+
+void target_teleporter_use( gentity_t *self, gentity_t *other, gentity_t *activator ) {
+	gentity_t	*dest;
+
+	if (!activator->client)
+		return;
+
+	G_ActivateBehavior(self,BSET_USE);
+
+	dest = 	G_PickTarget( self->target );
+	if (!dest) {
+		G_Printf ("Couldn't find teleporter destination\n");
+		return;
+	}
+
+	TeleportPlayer( activator, dest->s.origin, dest->s.angles );
+}
+
+/*QUAKED target_teleporter (1 0 0) (-8 -8 -8) (8 8 8)
+The activator will be teleported away.
+*/
+void SP_target_teleporter( gentity_t *self ) {
+	if (!self->targetname)
+		G_Printf("untargeted %s at %s\n", self->classname, vtos(self->s.origin));
+
+	self->use = target_teleporter_use;
+}
+
+//==========================================================
+
+
+/*QUAKED target_relay (.5 .5 .5) (-8 -8 -8) (8 8 8) RED_ONLY BLUE_ONLY RANDOM x x x x INACTIVE
+This doesn't perform any actions except fire its targets.
+The activator can be forced to be from a certain team.
+if RANDOM is checked, only one of the targets will be fired, not all of them
+
+  INACTIVE  Can't be used until activated
+
+wait - set to -1 to use it only once
+*/
+void target_relay_use (gentity_t *self, gentity_t *other, gentity_t *activator) {
+	qboolean ranscript = qfalse;
+	if ( ( self->spawnflags & 1 ) && activator->client 
+		&& activator->client->sess.sessionTeam != TEAM_RED ) {
+		return;
+	}
+	if ( ( self->spawnflags & 2 ) && activator->client 
+		&& activator->client->sess.sessionTeam != TEAM_BLUE ) {
+		return;
+	}
+
+	if ( self->flags & FL_INACTIVE )
+	{//set by target_deactivate
+		return;
+	}
+
+	ranscript = G_ActivateBehavior( self, BSET_USE );
+	if ( self->wait == -1 )
+	{//never use again
+		if ( ranscript )
+		{//crap, can't remove!
+			self->use = NULL;
+		}
+		else
+		{//remove
+			self->think = G_FreeEntity;
+			self->nextthink = level.time + FRAMETIME;
+		}
+	}
+	if ( self->spawnflags & 4 ) {
+		gentity_t	*ent;
+
+		ent = G_PickTarget( self->target );
+		if ( ent && ent->use ) {
+			GlobalUse( ent, self, activator );
+		}
+		return;
+	}
+	G_UseTargets (self, activator);
+}
+
+void SP_target_relay (gentity_t *self) {
+	self->use = target_relay_use;
+	if ( self->spawnflags&128 )
+	{
+		self->flags |= FL_INACTIVE;
+	}
+}
+
+
+//==========================================================
+
+/*QUAKED target_kill (.5 .5 .5) (-8 -8 -8) (8 8 8)
+Kills the activator.
+*/
+void target_kill_use( gentity_t *self, gentity_t *other, gentity_t *activator ) {
+	G_ActivateBehavior(self,BSET_USE);
+	G_Damage ( activator, NULL, NULL, NULL, NULL, 100000, DAMAGE_NO_PROTECTION, MOD_TELEFRAG);
+}
+
+void SP_target_kill( gentity_t *self ) {
+	self->use = target_kill_use;
+}
+
+/*QUAKED target_position (0 0.5 0) (-4 -4 -4) (4 4 4)
+Used as a positional target for in-game calculation, like jumppad targets.
+*/
+void SP_target_position( gentity_t *self ){
+	G_SetOrigin( self, self->s.origin );
+	/*
+	G_SetAngles( self, self->s.angles );
+	self->s.eType = ET_INVISIBLE;
+	*/
+}
+
+static void target_location_linkup(gentity_t *ent)
+{
+	int i;
+	int n;
+
+	if (level.locationLinked) 
+		return;
+
+	level.locationLinked = qtrue;
+
+	level.locationHead = NULL;
+
+	trap_SetConfigstring( CS_LOCATIONS, "unknown" );
+
+	for (i = 0, ent = g_entities, n = 1;
+			i < level.num_entities;
+			i++, ent++) {
+		if (ent->classname && !Q_stricmp(ent->classname, "target_location")) {
+			// lets overload some variables!
+			ent->health = n; // use for location marking
+			trap_SetConfigstring( CS_LOCATIONS + n, ent->message );
+			n++;
+			ent->nextTrain = level.locationHead;
+			level.locationHead = ent;
+		}
+	}
+
+	// All linked together now
+}
+
+/*QUAKED target_location (0 0.5 0) (-8 -8 -8) (8 8 8)
+Set "message" to the name of this location.
+Set "count" to 0-7 for color.
+0:white 1:red 2:green 3:yellow 4:blue 5:cyan 6:magenta 7:white
+
+Closest target_location in sight used for the location, if none
+in site, closest in distance
+*/
+void SP_target_location( gentity_t *self ){
+	self->think = target_location_linkup;
+	self->nextthink = level.time + 200;  // Let them all spawn first
+
+	G_SetOrigin( self, self->s.origin );
+}
+
+/*QUAKED target_counter (1.0 0 0) (-4 -4 -4) (4 4 4) x x x x x x x INACTIVE
+Acts as an intermediary for an action that takes multiple inputs.
+
+INACTIVE cannot be used until used by a target_activate
+
+target2 - what the counter should fire each time it's incremented and does NOT reach it's count
+
+After the counter has been triggered "count" times (default 2), it will fire all of it's targets and remove itself.
+
+bounceCount - number of times the counter should reset to it's full count when it's done
+*/
+extern void G_DebugPrint( int level, const char *format, ... );
+void target_counter_use( gentity_t *self, gentity_t *other, gentity_t *activator )
+{
+	if ( self->count == 0 )
+	{
+		return;
+	}
+	
+	//gi.Printf("target_counter %s used by %s, entnum %d\n", self->targetname, activator->targetname, activator->s.number );
+	self->count--;
+
+	if ( activator )
+	{
+		G_DebugPrint( WL_VERBOSE, "target_counter %s used by %s (%d/%d)\n", self->targetname, activator->targetname, (self->genericValue1-self->count), self->genericValue1 );
+	}
+
+	if ( self->count )
+	{
+		if ( self->target2 )
+		{
+			//gi.Printf("target_counter %s firing target2 from %s, entnum %d\n", self->targetname, activator->targetname, activator->s.number );
+			G_UseTargets2( self, activator, self->target2 );
+		}
+		return;
+	}
+	
+	G_ActivateBehavior( self,BSET_USE );
+
+	if ( self->spawnflags & 128 )
+	{
+		self->flags |= FL_INACTIVE;
+	}
+
+	self->activator = activator;
+	G_UseTargets( self, activator );
+
+	if ( self->count == 0 )
+	{
+		if ( self->bounceCount == 0 )
+		{
+			return;
+		}
+		self->count = self->genericValue1;
+		if ( self->bounceCount > 0 )
+		{//-1 means bounce back forever
+			self->bounceCount--; 
+		}
+	}
+}
+
+void SP_target_counter (gentity_t *self)
+{
+	self->wait = -1;
+	if (!self->count)
+	{
+		self->count = 2;
+	}
+	//if ( self->bounceCount > 0 )//let's always set this anyway
+	{//we will reset when we use up our count, remember our initial count
+		self->genericValue1 = self->count;
+	}
+
+	self->use = target_counter_use;
+}
+
+/*QUAKED target_random (.5 .5 .5) (-4 -4 -4) (4 4 4) USEONCE
+Randomly fires off only one of it's targets each time used
+
+USEONCE	set to never fire again
+*/
+
+void target_random_use(gentity_t *self, gentity_t *other, gentity_t *activator)
+{
+	int			t_count = 0, pick;
+	gentity_t	*t = NULL;
+
+	//gi.Printf("target_random %s used by %s (entnum %d)\n", self->targetname, activator->targetname, activator->s.number );
+	G_ActivateBehavior(self,BSET_USE);
+
+	if(self->spawnflags & 1)
+	{
+		self->use = 0;
+	}
+
+	while ( (t = G_Find (t, FOFS(targetname), self->target)) != NULL )
+	{
+		if (t != self)
+		{
+			t_count++;
+		}
+	}
+
+	if(!t_count)
+	{
+		return;
+	}
+
+	if(t_count == 1)
+	{
+		G_UseTargets (self, activator);
+		return;
+	}
+
+	//FIXME: need a seed
+	pick = Q_irand(1, t_count);
+	t_count = 0;
+	while ( (t = G_Find (t, FOFS(targetname), self->target)) != NULL )
+	{
+		if (t != self)
+		{
+			t_count++;
+		}
+		else
+		{
+			continue;
+		}
+		
+		if (t == self)
+		{
+//				gi.Printf ("WARNING: Entity used itself.\n");
+		}
+		else if(t_count == pick)
+		{
+			if (t->use != NULL)	// check can be omitted
+			{
+				GlobalUse(t, self, activator);
+				return;
+			}
+		}
+
+		if (!self->inuse)
+		{
+			Com_Printf("entity was removed while using targets\n");
+			return;
+		}
+	}
+}
+
+void SP_target_random (gentity_t *self)
+{
+	self->use = target_random_use;
+}
+
+int	numNewICARUSEnts = 0;
+void scriptrunner_run (gentity_t *self)
+{
+	/*
+	if (self->behaviorSet[BSET_USE])
+	{	
+		char	newname[MAX_FILENAME_LENGTH];
+
+		sprintf((char *) &newname, "%s/%s", Q3_SCRIPT_DIR, self->behaviorSet[BSET_USE] );
+
+		ICARUS_RunScript( self, newname );
+	}
+	*/
+
+	if ( self->count != -1 )
+	{
+		if ( self->count <= 0 )
+		{
+			self->use = 0;
+			self->behaviorSet[BSET_USE] = NULL;
+			return;
+		}
+		else
+		{
+			--self->count;
+		}
+	}
+
+	if (self->behaviorSet[BSET_USE])
+	{
+		if ( self->spawnflags & 1 )
+		{
+			if ( !self->activator )
+			{
+				if (g_developer.integer)
+				{
+					Com_Printf("target_scriptrunner tried to run on invalid entity!\n");
+				}
+				return;
+			}
+
+			//if ( !self->activator->sequencer || !self->activator->taskManager )
+			if (!trap_ICARUS_IsInitialized(self->s.number))
+			{//Need to be initialized through ICARUS
+				if ( !self->activator->script_targetname || !self->activator->script_targetname[0] )
+				{
+					//We don't have a script_targetname, so create a new one
+					self->activator->script_targetname = va( "newICARUSEnt%d", numNewICARUSEnts++ );
+				}
+
+				if ( trap_ICARUS_ValidEnt( self->activator ) )
+				{
+					trap_ICARUS_InitEnt( self->activator );
+				}
+				else
+				{
+					if (g_developer.integer)
+					{
+						Com_Printf("target_scriptrunner tried to run on invalid ICARUS activator!\n");
+					}
+					return;
+				}
+			}
+
+			if (g_developer.integer)
+			{
+				Com_Printf( "target_scriptrunner running %s on activator %s\n", self->behaviorSet[BSET_USE], self->activator->targetname );
+			}
+			trap_ICARUS_RunScript( self->activator, va( "%s/%s", Q3_SCRIPT_DIR, self->behaviorSet[BSET_USE] ) );
+		}
+		else
+		{
+			if ( g_developer.integer && self->activator )
+			{
+				Com_Printf( "target_scriptrunner %s used by %s\n", self->targetname, self->activator->targetname );
+			}
+			G_ActivateBehavior( self, BSET_USE );
+		}
+	}
+
+	if ( self->wait )
+	{
+		self->nextthink = level.time + self->wait;
+	}
+}
+
+void target_scriptrunner_use(gentity_t *self, gentity_t *other, gentity_t *activator)
+{
+	if ( self->nextthink > level.time )
+	{
+		return;
+	}
+
+	self->activator = activator;
+	self->enemy = other;
+	if ( self->delay )
+	{//delay before firing scriptrunner
+		self->think = scriptrunner_run;
+		self->nextthink = level.time + self->delay;
+	}
+	else
+	{
+		scriptrunner_run (self);
+	}
+}
+
+/*QUAKED target_scriptrunner (1 0 0) (-4 -4 -4) (4 4 4) runonactivator x x x x x x INACTIVE
+--- SPAWNFLAGS ---
+runonactivator - Will run the script on the entity that used this or tripped the trigger that used this
+INACTIVE - start off
+
+----- KEYS ------
+Usescript - Script to run when used
+count - how many times to run, -1 = infinite.  Default is once
+wait - can't be used again in this amount of seconds (Default is 1 second if it's multiple-use)
+delay - how long to wait after use to run script
+
+*/
+void SP_target_scriptrunner( gentity_t *self )
+{
+	float v;
+	if ( self->spawnflags & 128 )
+	{
+		self->flags |= FL_INACTIVE;
+	}
+
+	if ( !self->count )
+	{
+		self->count = 1;//default 1 use only
+	}
+	/*
+	else if ( !self->wait )
+	{
+		self->wait = 1;//default wait of 1 sec
+	}
+	*/
+	// FIXME: this is a hack... because delay is read in as an int, so I'm bypassing that because it's too late in the project to change it and I want to be able to set less than a second delays
+	// no one should be setting a radius on a scriptrunner, if they are this would be bad, take this out for the next project
+	v = 0.0f;
+	G_SpawnFloat( "delay", "0", &v );
+	self->delay = v * 1000;//sec to ms
+	self->wait *= 1000;//sec to ms
+
+	G_SetOrigin( self, self->s.origin );
+	self->use = target_scriptrunner_use;
+}
+
+void G_SetActiveState(char *targetstring, qboolean actState)
+{
+	gentity_t	*target = NULL;
+	while( NULL != (target = G_Find(target, FOFS(targetname), targetstring)) )
+	{
+		target->flags = actState ? (target->flags&~FL_INACTIVE) : (target->flags|FL_INACTIVE);
+	}
+}
+
+#define ACT_ACTIVE		qtrue
+#define ACT_INACTIVE	qfalse
+
+void target_activate_use(gentity_t *self, gentity_t *other, gentity_t *activator)
+{
+	G_ActivateBehavior(self,BSET_USE);
+
+	G_SetActiveState(self->target, ACT_ACTIVE);
+}
+
+void target_deactivate_use(gentity_t *self, gentity_t *other, gentity_t *activator)
+{
+	G_ActivateBehavior(self,BSET_USE);
+
+	G_SetActiveState(self->target, ACT_INACTIVE);
+}
+
+//FIXME: make these apply to doors, etc too?
+/*QUAKED target_activate (1 0 0) (-4 -4 -4) (4 4 4)
+Will set the target(s) to be usable/triggerable
+*/
+void SP_target_activate( gentity_t *self )
+{
+	G_SetOrigin( self, self->s.origin );
+	self->use = target_activate_use;
+}
+
+/*QUAKED target_deactivate (1 0 0) (-4 -4 -4) (4 4 4)
+Will set the target(s) to be non-usable/triggerable
+*/
+void SP_target_deactivate( gentity_t *self )
+{
+	G_SetOrigin( self, self->s.origin );
+	self->use = target_deactivate_use;
+}
+
+void target_level_change_use(gentity_t *self, gentity_t *other, gentity_t *activator)
+{
+	G_ActivateBehavior(self,BSET_USE);
+
+	trap_SendConsoleCommand(EXEC_NOW, va("map %s", self->message));
+}
+
+/*QUAKED target_level_change (1 0 0) (-4 -4 -4) (4 4 4)
+"mapname" - Name of map to change to
+*/
+void SP_target_level_change( gentity_t *self )
+{
+	char *s;
+
+	G_SpawnString( "mapname", "", &s );
+	self->message = G_NewString(s);
+
+	if ( !self->message || !self->message[0] )
+	{
+		G_Error( "target_level_change with no mapname!\n");
+		return;
+	}
+
+	G_SetOrigin( self, self->s.origin );
+	self->use = target_level_change_use;
+}
+
+void target_play_music_use(gentity_t *self, gentity_t *other, gentity_t *activator)
+{
+	G_ActivateBehavior(self,BSET_USE);
+	trap_SetConfigstring( CS_MUSIC, self->message );
+}
+
+/*QUAKED target_play_music (1 0 0) (-4 -4 -4) (4 4 4)
+target_play_music
+Plays the requested music files when this target is used.
+
+"targetname"
+"music"		music WAV or MP3 file ( music/introfile.mp3 [optional]  music/loopfile.mp3 )
+
+If an intro file and loop file are specified, the intro plays first, then the looping
+portion will start and loop indefinetly.  If no introfile is entered, only the loopfile
+will play.
+*/
+void SP_target_play_music( gentity_t *self )
+{
+	char *s;
+
+	G_SetOrigin( self, self->s.origin );
+	if (!G_SpawnString( "music", "", &s ))
+	{
+		G_Error( "target_play_music without a music key at %s", vtos( self->s.origin ) );
+	}
+
+	self->message = G_NewString(s);
+
+	self->use = target_play_music_use;
+}
diff --git a/codemp/game/g_team.c b/codemp/game/g_team.c
new file mode 100644
index 0000000..d9eaec6
--- /dev/null
+++ b/codemp/game/g_team.c
@@ -0,0 +1,1225 @@
+// Copyright (C) 1999-2000 Id Software, Inc.
+//
+
+#include "g_local.h"
+#include "bg_saga.h"
+
+
+typedef struct teamgame_s {
+	float			last_flag_capture;
+	int				last_capture_team;
+	flagStatus_t	redStatus;	// CTF
+	flagStatus_t	blueStatus;	// CTF
+	flagStatus_t	flagStatus;	// One Flag CTF
+	int				redTakenTime;
+	int				blueTakenTime;
+} teamgame_t;
+
+teamgame_t teamgame;
+
+void Team_SetFlagStatus( int team, flagStatus_t status );
+
+void Team_InitGame( void ) {
+	memset(&teamgame, 0, sizeof teamgame);
+
+	switch( g_gametype.integer ) {
+	case GT_CTF:
+	case GT_CTY:
+		teamgame.redStatus = teamgame.blueStatus = -1; // Invalid to force update
+		Team_SetFlagStatus( TEAM_RED, FLAG_ATBASE );
+		Team_SetFlagStatus( TEAM_BLUE, FLAG_ATBASE );
+		break;
+	default:
+		break;
+	}
+}
+
+int OtherTeam(int team) {
+	if (team==TEAM_RED)
+		return TEAM_BLUE;
+	else if (team==TEAM_BLUE)
+		return TEAM_RED;
+	return team;
+}
+
+const char *TeamName(int team)  {
+	if (team==TEAM_RED)
+		return "RED";
+	else if (team==TEAM_BLUE)
+		return "BLUE";
+	else if (team==TEAM_SPECTATOR)
+		return "SPECTATOR";
+	return "FREE";
+}
+
+const char *OtherTeamName(int team) {
+	if (team==TEAM_RED)
+		return "BLUE";
+	else if (team==TEAM_BLUE)
+		return "RED";
+	else if (team==TEAM_SPECTATOR)
+		return "SPECTATOR";
+	return "FREE";
+}
+
+const char *TeamColorString(int team) {
+	if (team==TEAM_RED)
+		return S_COLOR_RED;
+	else if (team==TEAM_BLUE)
+		return S_COLOR_BLUE;
+	else if (team==TEAM_SPECTATOR)
+		return S_COLOR_YELLOW;
+	return S_COLOR_WHITE;
+}
+
+// NULL for everyone
+/*
+void QDECL PrintMsg( gentity_t *ent, const char *fmt, ... ) {
+	char		msg[1024];
+	va_list		argptr;
+	char		*p;
+	
+	va_start (argptr,fmt);
+	if (vsprintf (msg, fmt, argptr) > sizeof(msg)) {
+		G_Error ( "PrintMsg overrun" );
+	}
+	va_end (argptr);
+
+	// double quotes are bad
+	while ((p = strchr(msg, '"')) != NULL)
+		*p = '\'';
+
+	trap_SendServerCommand ( ( (ent == NULL) ? -1 : ent-g_entities ), va("print \"%s\"", msg ));
+}
+*/
+//Printing messages to players via this method is no longer done, StringEd stuff is client only.
+
+
+//plIndex used to print pl->client->pers.netname
+//teamIndex used to print team name
+void PrintCTFMessage(int plIndex, int teamIndex, int ctfMessage)
+{
+	gentity_t *te;
+
+	if (plIndex == -1)
+	{
+		plIndex = MAX_CLIENTS+1;
+	}
+	if (teamIndex == -1)
+	{
+		teamIndex = 50;
+	}
+
+	te = G_TempEntity(vec3_origin, EV_CTFMESSAGE);
+	te->r.svFlags |= SVF_BROADCAST;
+	te->s.eventParm = ctfMessage;
+	te->s.trickedentindex = plIndex;
+	if (ctfMessage == CTFMESSAGE_PLAYER_CAPTURED_FLAG)
+	{
+		if (teamIndex == TEAM_RED)
+		{
+			te->s.trickedentindex2 = TEAM_BLUE;
+		}
+		else
+		{
+			te->s.trickedentindex2 = TEAM_RED;
+		}
+	}
+	else
+	{
+		te->s.trickedentindex2 = teamIndex;
+	}
+}
+
+/*
+==============
+AddTeamScore
+
+ used for gametype > GT_TEAM
+ for gametype GT_TEAM the level.teamScores is updated in AddScore in g_combat.c
+==============
+*/
+void AddTeamScore(vec3_t origin, int team, int score) {
+	gentity_t	*te;
+
+	te = G_TempEntity(origin, EV_GLOBAL_TEAM_SOUND );
+	te->r.svFlags |= SVF_BROADCAST;
+
+	if ( team == TEAM_RED ) {
+		if ( level.teamScores[ TEAM_RED ] + score == level.teamScores[ TEAM_BLUE ] ) {
+			//teams are tied sound
+			te->s.eventParm = GTS_TEAMS_ARE_TIED;
+		}
+		else if ( level.teamScores[ TEAM_RED ] <= level.teamScores[ TEAM_BLUE ] &&
+					level.teamScores[ TEAM_RED ] + score > level.teamScores[ TEAM_BLUE ]) {
+			// red took the lead sound
+			te->s.eventParm = GTS_REDTEAM_TOOK_LEAD;
+		}
+		else {
+			// red scored sound
+			te->s.eventParm = GTS_REDTEAM_SCORED;
+		}
+	}
+	else {
+		if ( level.teamScores[ TEAM_BLUE ] + score == level.teamScores[ TEAM_RED ] ) {
+			//teams are tied sound
+			te->s.eventParm = GTS_TEAMS_ARE_TIED;
+		}
+		else if ( level.teamScores[ TEAM_BLUE ] <= level.teamScores[ TEAM_RED ] &&
+					level.teamScores[ TEAM_BLUE ] + score > level.teamScores[ TEAM_RED ]) {
+			// blue took the lead sound
+			te->s.eventParm = GTS_BLUETEAM_TOOK_LEAD;
+		}
+		else {
+			// blue scored sound
+			te->s.eventParm = GTS_BLUETEAM_SCORED;
+		}
+	}
+	level.teamScores[ team ] += score;
+}
+
+/*
+==============
+OnSameTeam
+==============
+*/
+qboolean OnSameTeam( gentity_t *ent1, gentity_t *ent2 ) {
+	if ( !ent1->client || !ent2->client ) {
+		return qfalse;
+	}
+
+	if (g_gametype.integer == GT_POWERDUEL)
+	{
+		if (ent1->client->sess.duelTeam == ent2->client->sess.duelTeam)
+		{
+			return qtrue;
+		}
+
+		return qfalse;
+	}
+
+	if (g_gametype.integer == GT_SINGLE_PLAYER)
+	{
+		qboolean ent1IsBot = qfalse;
+		qboolean ent2IsBot = qfalse;
+
+		if (ent1->r.svFlags & SVF_BOT)
+		{
+			ent1IsBot = qtrue;
+		}
+		if (ent2->r.svFlags & SVF_BOT)
+		{
+			ent2IsBot = qtrue;
+		}
+
+		if ((ent1IsBot && ent2IsBot) || (!ent1IsBot && !ent2IsBot))
+		{
+			return qtrue;
+		}
+		return qfalse;
+	}
+
+	if ( g_gametype.integer < GT_TEAM ) {
+		return qfalse;
+	}
+
+	if (ent1->s.eType == ET_NPC &&
+		ent1->s.NPC_class == CLASS_VEHICLE &&
+		ent1->client &&
+		ent1->client->sess.sessionTeam != TEAM_FREE &&
+		ent2->client &&
+		ent1->client->sess.sessionTeam == ent2->client->sess.sessionTeam)
+	{
+		return qtrue;
+	}
+	if (ent2->s.eType == ET_NPC &&
+		ent2->s.NPC_class == CLASS_VEHICLE &&
+		ent2->client &&
+		ent2->client->sess.sessionTeam != TEAM_FREE &&
+		ent1->client &&
+		ent2->client->sess.sessionTeam == ent1->client->sess.sessionTeam)
+	{
+		return qtrue;
+	}
+
+	if (ent1->client->sess.sessionTeam == TEAM_FREE &&
+		ent2->client->sess.sessionTeam == TEAM_FREE &&
+		ent1->s.eType == ET_NPC &&
+		ent2->s.eType == ET_NPC)
+	{ //NPCs don't do normal team rules
+		return qfalse;
+	}
+
+	if (ent1->s.eType == ET_NPC && ent2->s.eType == ET_PLAYER)
+	{
+		return qfalse;
+	}
+	else if (ent1->s.eType == ET_PLAYER && ent2->s.eType == ET_NPC)
+	{
+		return qfalse;
+	}
+
+	if ( ent1->client->sess.sessionTeam == ent2->client->sess.sessionTeam ) {
+		return qtrue;
+	}
+
+	return qfalse;
+}
+
+
+static char ctfFlagStatusRemap[] = { '0', '1', '*', '*', '2' };
+
+void Team_SetFlagStatus( int team, flagStatus_t status ) {
+	qboolean modified = qfalse;
+
+	switch( team ) {
+	case TEAM_RED:	// CTF
+		if( teamgame.redStatus != status ) {
+			teamgame.redStatus = status;
+			modified = qtrue;
+		}
+		break;
+
+	case TEAM_BLUE:	// CTF
+		if( teamgame.blueStatus != status ) {
+			teamgame.blueStatus = status;
+			modified = qtrue;
+		}
+		break;
+
+	case TEAM_FREE:	// One Flag CTF
+		if( teamgame.flagStatus != status ) {
+			teamgame.flagStatus = status;
+			modified = qtrue;
+		}
+		break;
+	}
+
+	if( modified ) {
+		char st[4];
+
+		if( g_gametype.integer == GT_CTF || g_gametype.integer == GT_CTY ) {
+			st[0] = ctfFlagStatusRemap[teamgame.redStatus];
+			st[1] = ctfFlagStatusRemap[teamgame.blueStatus];
+			st[2] = 0;
+		}
+
+		trap_SetConfigstring( CS_FLAGSTATUS, st );
+	}
+}
+
+void Team_CheckDroppedItem( gentity_t *dropped ) {
+	if( dropped->item->giTag == PW_REDFLAG ) {
+		Team_SetFlagStatus( TEAM_RED, FLAG_DROPPED );
+	}
+	else if( dropped->item->giTag == PW_BLUEFLAG ) {
+		Team_SetFlagStatus( TEAM_BLUE, FLAG_DROPPED );
+	}
+	else if( dropped->item->giTag == PW_NEUTRALFLAG ) {
+		Team_SetFlagStatus( TEAM_FREE, FLAG_DROPPED );
+	}
+}
+
+/*
+================
+Team_ForceGesture
+================
+*/
+void Team_ForceGesture(int team) {
+	int i;
+	gentity_t *ent;
+
+	for (i = 0; i < MAX_CLIENTS; i++) {
+		ent = &g_entities[i];
+		if (!ent->inuse)
+			continue;
+		if (!ent->client)
+			continue;
+		if (ent->client->sess.sessionTeam != team)
+			continue;
+		//
+		ent->flags |= FL_FORCE_GESTURE;
+	}
+}
+
+/*
+================
+Team_FragBonuses
+
+Calculate the bonuses for flag defense, flag carrier defense, etc.
+Note that bonuses are not cumulative.  You get one, they are in importance
+order.
+================
+*/
+void Team_FragBonuses(gentity_t *targ, gentity_t *inflictor, gentity_t *attacker)
+{
+	int i;
+	gentity_t *ent;
+	int flag_pw, enemy_flag_pw;
+	int otherteam;
+	int tokens;
+	gentity_t *flag, *carrier = NULL;
+	char *c;
+	vec3_t v1, v2;
+	int team;
+
+	// no bonus for fragging yourself or team mates
+	if (!targ->client || !attacker->client || targ == attacker || OnSameTeam(targ, attacker))
+		return;
+
+	team = targ->client->sess.sessionTeam;
+	otherteam = OtherTeam(targ->client->sess.sessionTeam);
+	if (otherteam < 0)
+		return; // whoever died isn't on a team
+
+	// same team, if the flag at base, check to he has the enemy flag
+	if (team == TEAM_RED) {
+		flag_pw = PW_REDFLAG;
+		enemy_flag_pw = PW_BLUEFLAG;
+	} else {
+		flag_pw = PW_BLUEFLAG;
+		enemy_flag_pw = PW_REDFLAG;
+	}
+
+	// did the attacker frag the flag carrier?
+	tokens = 0;
+	if (targ->client->ps.powerups[enemy_flag_pw]) {
+		attacker->client->pers.teamState.lastfraggedcarrier = level.time;
+		AddScore(attacker, targ->r.currentOrigin, CTF_FRAG_CARRIER_BONUS);
+		attacker->client->pers.teamState.fragcarrier++;
+		//PrintMsg(NULL, "%s" S_COLOR_WHITE " fragged %s's flag carrier!\n",
+		//	attacker->client->pers.netname, TeamName(team));
+		PrintCTFMessage(attacker->s.number, team, CTFMESSAGE_FRAGGED_FLAG_CARRIER);
+
+		// the target had the flag, clear the hurt carrier
+		// field on the other team
+		for (i = 0; i < g_maxclients.integer; i++) {
+			ent = g_entities + i;
+			if (ent->inuse && ent->client->sess.sessionTeam == otherteam)
+				ent->client->pers.teamState.lasthurtcarrier = 0;
+		}
+		return;
+	}
+
+	// did the attacker frag a head carrier? other->client->ps.generic1
+	if (tokens) {
+		attacker->client->pers.teamState.lastfraggedcarrier = level.time;
+		AddScore(attacker, targ->r.currentOrigin, CTF_FRAG_CARRIER_BONUS * tokens * tokens);
+		attacker->client->pers.teamState.fragcarrier++;
+		//PrintMsg(NULL, "%s" S_COLOR_WHITE " fragged %s's skull carrier!\n",
+		//	attacker->client->pers.netname, TeamName(team));
+
+		// the target had the flag, clear the hurt carrier
+		// field on the other team
+		for (i = 0; i < g_maxclients.integer; i++) {
+			ent = g_entities + i;
+			if (ent->inuse && ent->client->sess.sessionTeam == otherteam)
+				ent->client->pers.teamState.lasthurtcarrier = 0;
+		}
+		return;
+	}
+
+	if (targ->client->pers.teamState.lasthurtcarrier &&
+		level.time - targ->client->pers.teamState.lasthurtcarrier < CTF_CARRIER_DANGER_PROTECT_TIMEOUT &&
+		!attacker->client->ps.powerups[flag_pw]) {
+		// attacker is on the same team as the flag carrier and
+		// fragged a guy who hurt our flag carrier
+		AddScore(attacker, targ->r.currentOrigin, CTF_CARRIER_DANGER_PROTECT_BONUS);
+
+		attacker->client->pers.teamState.carrierdefense++;
+		targ->client->pers.teamState.lasthurtcarrier = 0;
+
+		attacker->client->ps.persistant[PERS_DEFEND_COUNT]++;
+		team = attacker->client->sess.sessionTeam;
+		attacker->client->rewardTime = level.time + REWARD_SPRITE_TIME;
+
+		return;
+	}
+
+	if (targ->client->pers.teamState.lasthurtcarrier &&
+		level.time - targ->client->pers.teamState.lasthurtcarrier < CTF_CARRIER_DANGER_PROTECT_TIMEOUT) {
+		// attacker is on the same team as the skull carrier and
+		AddScore(attacker, targ->r.currentOrigin, CTF_CARRIER_DANGER_PROTECT_BONUS);
+
+		attacker->client->pers.teamState.carrierdefense++;
+		targ->client->pers.teamState.lasthurtcarrier = 0;
+
+		attacker->client->ps.persistant[PERS_DEFEND_COUNT]++;
+		team = attacker->client->sess.sessionTeam;
+		attacker->client->rewardTime = level.time + REWARD_SPRITE_TIME;
+
+		return;
+	}
+
+	// flag and flag carrier area defense bonuses
+
+	// we have to find the flag and carrier entities
+
+	// find the flag
+	switch (attacker->client->sess.sessionTeam) {
+	case TEAM_RED:
+		c = "team_CTF_redflag";
+		break;
+	case TEAM_BLUE:
+		c = "team_CTF_blueflag";
+		break;		
+	default:
+		return;
+	}
+	// find attacker's team's flag carrier
+	for (i = 0; i < g_maxclients.integer; i++) {
+		carrier = g_entities + i;
+		if (carrier->inuse && carrier->client->ps.powerups[flag_pw])
+			break;
+		carrier = NULL;
+	}
+	flag = NULL;
+	while ((flag = G_Find (flag, FOFS(classname), c)) != NULL) {
+		if (!(flag->flags & FL_DROPPED_ITEM))
+			break;
+	}
+
+	if (!flag)
+		return; // can't find attacker's flag
+
+	// ok we have the attackers flag and a pointer to the carrier
+
+	// check to see if we are defending the base's flag
+	VectorSubtract(targ->r.currentOrigin, flag->r.currentOrigin, v1);
+	VectorSubtract(attacker->r.currentOrigin, flag->r.currentOrigin, v2);
+
+	if ( ( ( VectorLength(v1) < CTF_TARGET_PROTECT_RADIUS &&
+		trap_InPVS(flag->r.currentOrigin, targ->r.currentOrigin ) ) ||
+		( VectorLength(v2) < CTF_TARGET_PROTECT_RADIUS &&
+		trap_InPVS(flag->r.currentOrigin, attacker->r.currentOrigin ) ) ) &&
+		attacker->client->sess.sessionTeam != targ->client->sess.sessionTeam) {
+
+		// we defended the base flag
+		AddScore(attacker, targ->r.currentOrigin, CTF_FLAG_DEFENSE_BONUS);
+		attacker->client->pers.teamState.basedefense++;
+
+		attacker->client->ps.persistant[PERS_DEFEND_COUNT]++;
+		attacker->client->rewardTime = level.time + REWARD_SPRITE_TIME;
+
+		return;
+	}
+
+	if (carrier && carrier != attacker) {
+		VectorSubtract(targ->r.currentOrigin, carrier->r.currentOrigin, v1);
+		VectorSubtract(attacker->r.currentOrigin, carrier->r.currentOrigin, v1);
+
+		if ( ( ( VectorLength(v1) < CTF_ATTACKER_PROTECT_RADIUS &&
+			trap_InPVS(carrier->r.currentOrigin, targ->r.currentOrigin ) ) ||
+			( VectorLength(v2) < CTF_ATTACKER_PROTECT_RADIUS &&
+				trap_InPVS(carrier->r.currentOrigin, attacker->r.currentOrigin ) ) ) &&
+			attacker->client->sess.sessionTeam != targ->client->sess.sessionTeam) {
+			AddScore(attacker, targ->r.currentOrigin, CTF_CARRIER_PROTECT_BONUS);
+			attacker->client->pers.teamState.carrierdefense++;
+
+			attacker->client->ps.persistant[PERS_DEFEND_COUNT]++;
+			attacker->client->rewardTime = level.time + REWARD_SPRITE_TIME;
+
+			return;
+		}
+	}
+}
+
+/*
+================
+Team_CheckHurtCarrier
+
+Check to see if attacker hurt the flag carrier.  Needed when handing out bonuses for assistance to flag
+carrier defense.
+================
+*/
+void Team_CheckHurtCarrier(gentity_t *targ, gentity_t *attacker)
+{
+	int flag_pw;
+
+	if (!targ->client || !attacker->client)
+		return;
+
+	if (targ->client->sess.sessionTeam == TEAM_RED)
+		flag_pw = PW_BLUEFLAG;
+	else
+		flag_pw = PW_REDFLAG;
+
+	// flags
+	if (targ->client->ps.powerups[flag_pw] &&
+		targ->client->sess.sessionTeam != attacker->client->sess.sessionTeam)
+		attacker->client->pers.teamState.lasthurtcarrier = level.time;
+
+	// skulls
+	if (targ->client->ps.generic1 &&
+		targ->client->sess.sessionTeam != attacker->client->sess.sessionTeam)
+		attacker->client->pers.teamState.lasthurtcarrier = level.time;
+}
+
+
+gentity_t *Team_ResetFlag( int team ) {
+	char *c;
+	gentity_t *ent, *rent = NULL;
+
+	switch (team) {
+	case TEAM_RED:
+		c = "team_CTF_redflag";
+		break;
+	case TEAM_BLUE:
+		c = "team_CTF_blueflag";
+		break;
+	case TEAM_FREE:
+		c = "team_CTF_neutralflag";
+		break;
+	default:
+		return NULL;
+	}
+
+	ent = NULL;
+	while ((ent = G_Find (ent, FOFS(classname), c)) != NULL) {
+		if (ent->flags & FL_DROPPED_ITEM)
+			G_FreeEntity(ent);
+		else {
+			rent = ent;
+			RespawnItem(ent);
+		}
+	}
+
+	Team_SetFlagStatus( team, FLAG_ATBASE );
+
+	return rent;
+}
+
+void Team_ResetFlags( void ) {
+	if( g_gametype.integer == GT_CTF || g_gametype.integer == GT_CTY ) {
+		Team_ResetFlag( TEAM_RED );
+		Team_ResetFlag( TEAM_BLUE );
+	}
+}
+
+void Team_ReturnFlagSound( gentity_t *ent, int team ) {
+	gentity_t	*te;
+
+	if (ent == NULL) {
+		G_Printf ("Warning:  NULL passed to Team_ReturnFlagSound\n");
+		return;
+	}
+
+	te = G_TempEntity( ent->s.pos.trBase, EV_GLOBAL_TEAM_SOUND );
+	if( team == TEAM_BLUE ) {
+		te->s.eventParm = GTS_RED_RETURN;
+	}
+	else {
+		te->s.eventParm = GTS_BLUE_RETURN;
+	}
+	te->r.svFlags |= SVF_BROADCAST;
+}
+
+void Team_TakeFlagSound( gentity_t *ent, int team ) {
+	gentity_t	*te;
+
+	if (ent == NULL) {
+		G_Printf ("Warning:  NULL passed to Team_TakeFlagSound\n");
+		return;
+	}
+
+	// only play sound when the flag was at the base
+	// or not picked up the last 10 seconds
+	switch(team) {
+		case TEAM_RED:
+			if( teamgame.blueStatus != FLAG_ATBASE ) {
+				if (teamgame.blueTakenTime > level.time - 10000)
+					return;
+			}
+			teamgame.blueTakenTime = level.time;
+			break;
+
+		case TEAM_BLUE:	// CTF
+			if( teamgame.redStatus != FLAG_ATBASE ) {
+				if (teamgame.redTakenTime > level.time - 10000)
+					return;
+			}
+			teamgame.redTakenTime = level.time;
+			break;
+	}
+
+	te = G_TempEntity( ent->s.pos.trBase, EV_GLOBAL_TEAM_SOUND );
+	if( team == TEAM_BLUE ) {
+		te->s.eventParm = GTS_RED_TAKEN;
+	}
+	else {
+		te->s.eventParm = GTS_BLUE_TAKEN;
+	}
+	te->r.svFlags |= SVF_BROADCAST;
+}
+
+void Team_CaptureFlagSound( gentity_t *ent, int team ) {
+	gentity_t	*te;
+
+	if (ent == NULL) {
+		G_Printf ("Warning:  NULL passed to Team_CaptureFlagSound\n");
+		return;
+	}
+
+	te = G_TempEntity( ent->s.pos.trBase, EV_GLOBAL_TEAM_SOUND );
+	if( team == TEAM_BLUE ) {
+		te->s.eventParm = GTS_BLUE_CAPTURE;
+	}
+	else {
+		te->s.eventParm = GTS_RED_CAPTURE;
+	}
+	te->r.svFlags |= SVF_BROADCAST;
+}
+
+void Team_ReturnFlag( int team ) {
+	Team_ReturnFlagSound(Team_ResetFlag(team), team);
+	if( team == TEAM_FREE ) {
+		//PrintMsg(NULL, "The flag has returned!\n" );
+	}
+	else { //flag should always have team in normal CTF
+		//PrintMsg(NULL, "The %s flag has returned!\n", TeamName(team));
+		PrintCTFMessage(-1, team, CTFMESSAGE_FLAG_RETURNED);
+	}
+}
+
+void Team_FreeEntity( gentity_t *ent ) {
+	if( ent->item->giTag == PW_REDFLAG ) {
+		Team_ReturnFlag( TEAM_RED );
+	}
+	else if( ent->item->giTag == PW_BLUEFLAG ) {
+		Team_ReturnFlag( TEAM_BLUE );
+	}
+	else if( ent->item->giTag == PW_NEUTRALFLAG ) {
+		Team_ReturnFlag( TEAM_FREE );
+	}
+}
+
+/*
+==============
+Team_DroppedFlagThink
+
+Automatically set in Launch_Item if the item is one of the flags
+
+Flags are unique in that if they are dropped, the base flag must be respawned when they time out
+==============
+*/
+void Team_DroppedFlagThink(gentity_t *ent) {
+	int		team = TEAM_FREE;
+
+	if( ent->item->giTag == PW_REDFLAG ) {
+		team = TEAM_RED;
+	}
+	else if( ent->item->giTag == PW_BLUEFLAG ) {
+		team = TEAM_BLUE;
+	}
+	else if( ent->item->giTag == PW_NEUTRALFLAG ) {
+		team = TEAM_FREE;
+	}
+
+	Team_ReturnFlagSound( Team_ResetFlag( team ), team );
+	// Reset Flag will delete this entity
+}
+
+
+/*
+==============
+Team_DroppedFlagThink
+==============
+*/
+int Team_TouchOurFlag( gentity_t *ent, gentity_t *other, int team ) {
+	int			i;
+	gentity_t	*player;
+	gclient_t	*cl = other->client;
+	int			enemy_flag;
+
+	if (cl->sess.sessionTeam == TEAM_RED) {
+		enemy_flag = PW_BLUEFLAG;
+	} else {
+		enemy_flag = PW_REDFLAG;
+	}
+
+	if ( ent->flags & FL_DROPPED_ITEM ) {
+		// hey, its not home.  return it by teleporting it back
+		//PrintMsg( NULL, "%s" S_COLOR_WHITE " returned the %s flag!\n", 
+		//	cl->pers.netname, TeamName(team));
+		PrintCTFMessage(other->s.number, team, CTFMESSAGE_PLAYER_RETURNED_FLAG);
+
+		AddScore(other, ent->r.currentOrigin, CTF_RECOVERY_BONUS);
+		other->client->pers.teamState.flagrecovery++;
+		other->client->pers.teamState.lastreturnedflag = level.time;
+		//ResetFlag will remove this entity!  We must return zero
+		Team_ReturnFlagSound(Team_ResetFlag(team), team);
+		return 0;
+	}
+
+	// the flag is at home base.  if the player has the enemy
+	// flag, he's just won!
+	if (!cl->ps.powerups[enemy_flag])
+		return 0; // We don't have the flag
+	//PrintMsg( NULL, "%s" S_COLOR_WHITE " captured the %s flag!\n", cl->pers.netname, TeamName(OtherTeam(team)));
+	PrintCTFMessage(other->s.number, team, CTFMESSAGE_PLAYER_CAPTURED_FLAG);
+
+	cl->ps.powerups[enemy_flag] = 0;
+
+	teamgame.last_flag_capture = level.time;
+	teamgame.last_capture_team = team;
+
+	// Increase the team's score
+	AddTeamScore(ent->s.pos.trBase, other->client->sess.sessionTeam, 1);
+//	Team_ForceGesture(other->client->sess.sessionTeam);
+	//rww - don't really want to do this now. Mainly because performing a gesture disables your upper torso animations until it's done and you can't fire
+
+	other->client->pers.teamState.captures++;
+	other->client->rewardTime = level.time + REWARD_SPRITE_TIME;
+	other->client->ps.persistant[PERS_CAPTURES]++;
+
+	// other gets another 10 frag bonus
+	AddScore(other, ent->r.currentOrigin, CTF_CAPTURE_BONUS);
+
+	Team_CaptureFlagSound( ent, team );
+
+	// Ok, let's do the player loop, hand out the bonuses
+	for (i = 0; i < g_maxclients.integer; i++) {
+		player = &g_entities[i];
+		if (!player->inuse)
+			continue;
+
+		if (player->client->sess.sessionTeam !=
+			cl->sess.sessionTeam) {
+			player->client->pers.teamState.lasthurtcarrier = -5;
+		} else if (player->client->sess.sessionTeam ==
+			cl->sess.sessionTeam) {
+			if (player != other)
+				AddScore(player, ent->r.currentOrigin, CTF_TEAM_BONUS);
+			// award extra points for capture assists
+			if (player->client->pers.teamState.lastreturnedflag + 
+				CTF_RETURN_FLAG_ASSIST_TIMEOUT > level.time) {
+				AddScore (player, ent->r.currentOrigin, CTF_RETURN_FLAG_ASSIST_BONUS);
+				other->client->pers.teamState.assists++;
+
+				player->client->ps.persistant[PERS_ASSIST_COUNT]++;
+				player->client->rewardTime = level.time + REWARD_SPRITE_TIME;
+
+			} else if (player->client->pers.teamState.lastfraggedcarrier + 
+				CTF_FRAG_CARRIER_ASSIST_TIMEOUT > level.time) {
+				AddScore(player, ent->r.currentOrigin, CTF_FRAG_CARRIER_ASSIST_BONUS);
+				other->client->pers.teamState.assists++;
+				player->client->ps.persistant[PERS_ASSIST_COUNT]++;
+				player->client->rewardTime = level.time + REWARD_SPRITE_TIME;
+			}
+		}
+	}
+	Team_ResetFlags();
+
+	CalculateRanks();
+
+	return 0; // Do not respawn this automatically
+}
+
+int Team_TouchEnemyFlag( gentity_t *ent, gentity_t *other, int team ) {
+	gclient_t *cl = other->client;
+
+	//PrintMsg (NULL, "%s" S_COLOR_WHITE " got the %s flag!\n",
+	//	other->client->pers.netname, TeamName(team));
+	PrintCTFMessage(other->s.number, team, CTFMESSAGE_PLAYER_GOT_FLAG);
+
+	if (team == TEAM_RED)
+		cl->ps.powerups[PW_REDFLAG] = INT_MAX; // flags never expire
+	else
+		cl->ps.powerups[PW_BLUEFLAG] = INT_MAX; // flags never expire
+
+	Team_SetFlagStatus( team, FLAG_TAKEN );
+
+	AddScore(other, ent->r.currentOrigin, CTF_FLAG_BONUS);
+	cl->pers.teamState.flagsince = level.time;
+	Team_TakeFlagSound( ent, team );
+
+	return -1; // Do not respawn this automatically, but do delete it if it was FL_DROPPED
+}
+
+int Pickup_Team( gentity_t *ent, gentity_t *other ) {
+	int team;
+	gclient_t *cl = other->client;
+
+	// figure out what team this flag is
+	if( strcmp(ent->classname, "team_CTF_redflag") == 0 ) {
+		team = TEAM_RED;
+	}
+	else if( strcmp(ent->classname, "team_CTF_blueflag") == 0 ) {
+		team = TEAM_BLUE;
+	}
+	else if( strcmp(ent->classname, "team_CTF_neutralflag") == 0  ) {
+		team = TEAM_FREE;
+	}
+	else {
+//		PrintMsg ( other, "Don't know what team the flag is on.\n");
+		return 0;
+	}
+	// GT_CTF
+	if( team == cl->sess.sessionTeam) {
+		return Team_TouchOurFlag( ent, other, team );
+	}
+	return Team_TouchEnemyFlag( ent, other, team );
+}
+
+/*
+===========
+Team_GetLocation
+
+Report a location for the player. Uses placed nearby target_location entities
+============
+*/
+gentity_t *Team_GetLocation(gentity_t *ent)
+{
+	gentity_t		*eloc, *best;
+	float			bestlen, len;
+	vec3_t			origin;
+
+	best = NULL;
+	bestlen = 3*8192.0*8192.0;
+
+	VectorCopy( ent->r.currentOrigin, origin );
+
+	for (eloc = level.locationHead; eloc; eloc = eloc->nextTrain) {
+		len = ( origin[0] - eloc->r.currentOrigin[0] ) * ( origin[0] - eloc->r.currentOrigin[0] )
+			+ ( origin[1] - eloc->r.currentOrigin[1] ) * ( origin[1] - eloc->r.currentOrigin[1] )
+			+ ( origin[2] - eloc->r.currentOrigin[2] ) * ( origin[2] - eloc->r.currentOrigin[2] );
+
+		if ( len > bestlen ) {
+			continue;
+		}
+
+		if ( !trap_InPVS( origin, eloc->r.currentOrigin ) ) {
+			continue;
+		}
+
+		bestlen = len;
+		best = eloc;
+	}
+
+	return best;
+}
+
+
+/*
+===========
+Team_GetLocation
+
+Report a location for the player. Uses placed nearby target_location entities
+============
+*/
+qboolean Team_GetLocationMsg(gentity_t *ent, char *loc, int loclen)
+{
+	gentity_t *best;
+
+	best = Team_GetLocation( ent );
+	
+	if (!best)
+		return qfalse;
+
+	if (best->count) {
+		if (best->count < 0)
+			best->count = 0;
+		if (best->count > 7)
+			best->count = 7;
+		Com_sprintf(loc, loclen, "%c%c%s" S_COLOR_WHITE, Q_COLOR_ESCAPE, best->count + '0', best->message );
+	} else
+		Com_sprintf(loc, loclen, "%s", best->message);
+
+	return qtrue;
+}
+
+
+/*---------------------------------------------------------------------------*/
+
+/*
+================
+SelectRandomDeathmatchSpawnPoint
+
+go to a random point that doesn't telefrag
+================
+*/
+#define	MAX_TEAM_SPAWN_POINTS	32
+gentity_t *SelectRandomTeamSpawnPoint( int teamstate, team_t team, int siegeClass ) {
+	gentity_t	*spot;
+	int			count;
+	int			selection;
+	gentity_t	*spots[MAX_TEAM_SPAWN_POINTS];
+	char		*classname;
+	qboolean	mustBeEnabled = qfalse;
+
+	if (g_gametype.integer == GT_SIEGE)
+	{
+		if (team == SIEGETEAM_TEAM1)
+		{
+			classname = "info_player_siegeteam1";
+		}
+		else
+		{
+			classname = "info_player_siegeteam2";
+		}
+
+		mustBeEnabled = qtrue; //siege spawn points need to be "enabled" to be used (because multiple spawnpoint sets can be placed at once)
+	}
+	else
+	{
+		if (teamstate == TEAM_BEGIN) {
+			if (team == TEAM_RED)
+				classname = "team_CTF_redplayer";
+			else if (team == TEAM_BLUE)
+				classname = "team_CTF_blueplayer";
+			else
+				return NULL;
+		} else {
+			if (team == TEAM_RED)
+				classname = "team_CTF_redspawn";
+			else if (team == TEAM_BLUE)
+				classname = "team_CTF_bluespawn";
+			else
+				return NULL;
+		}
+	}
+	count = 0;
+
+	spot = NULL;
+
+	while ((spot = G_Find (spot, FOFS(classname), classname)) != NULL) {
+		if ( SpotWouldTelefrag( spot ) ) {
+			continue;
+		}
+
+		if (mustBeEnabled && !spot->genericValue1)
+		{ //siege point that's not enabled, can't use it
+			continue;
+		}
+
+		spots[ count ] = spot;
+		if (++count == MAX_TEAM_SPAWN_POINTS)
+			break;
+	}
+
+	if ( !count ) {	// no spots that won't telefrag
+		return G_Find( NULL, FOFS(classname), classname);
+	}
+
+	if (g_gametype.integer == GT_SIEGE && siegeClass >= 0 &&
+		bgSiegeClasses[siegeClass].name[0])
+	{ //out of the spots found, see if any have an idealclass to match our class name
+		gentity_t *classSpots[MAX_TEAM_SPAWN_POINTS];
+		int classCount = 0;
+		int i = 0;
+
+        while (i < count)
+		{
+			if (spots[i] && spots[i]->idealclass && spots[i]->idealclass[0] &&
+				!Q_stricmp(spots[i]->idealclass, bgSiegeClasses[siegeClass].name))
+			{ //this spot's idealclass matches the class name
+                classSpots[classCount] = spots[i];
+				classCount++;
+			}
+			i++;
+		}
+
+		if (classCount > 0)
+		{ //found at least one
+			selection = rand() % classCount;
+			return spots[ selection ];
+		}
+	}
+
+	selection = rand() % count;
+	return spots[ selection ];
+}
+
+
+/*
+===========
+SelectCTFSpawnPoint
+
+============
+*/
+gentity_t *SelectCTFSpawnPoint ( team_t team, int teamstate, vec3_t origin, vec3_t angles ) {
+	gentity_t	*spot;
+
+	spot = SelectRandomTeamSpawnPoint ( teamstate, team, -1 );
+
+	if (!spot) {
+		return SelectSpawnPoint( vec3_origin, origin, angles );
+	}
+
+	VectorCopy (spot->s.origin, origin);
+	origin[2] += 9;
+	VectorCopy (spot->s.angles, angles);
+
+	return spot;
+}
+
+/*
+===========
+SelectSiegeSpawnPoint
+
+============
+*/
+gentity_t *SelectSiegeSpawnPoint ( int siegeClass, team_t team, int teamstate, vec3_t origin, vec3_t angles ) {
+	gentity_t	*spot;
+
+	spot = SelectRandomTeamSpawnPoint ( teamstate, team, siegeClass );
+
+	if (!spot) {
+		return SelectSpawnPoint( vec3_origin, origin, angles );
+	}
+
+	VectorCopy (spot->s.origin, origin);
+	origin[2] += 9;
+	VectorCopy (spot->s.angles, angles);
+
+	return spot;
+}
+
+/*---------------------------------------------------------------------------*/
+
+static int QDECL SortClients( const void *a, const void *b ) {
+	return *(int *)a - *(int *)b;
+}
+
+
+/*
+==================
+TeamplayLocationsMessage
+
+Format:
+	clientNum location health armor weapon powerups
+
+==================
+*/
+void TeamplayInfoMessage( gentity_t *ent ) {
+	char		entry[1024];
+	char		string[8192];
+	int			stringlength;
+	int			i, j;
+	gentity_t	*player;
+	int			cnt;
+	int			h, a;
+	int			clients[TEAM_MAXOVERLAY];
+
+	if ( ! ent->client->pers.teamInfo )
+		return;
+
+	// figure out what client should be on the display
+	// we are limited to 8, but we want to use the top eight players
+	// but in client order (so they don't keep changing position on the overlay)
+	for (i = 0, cnt = 0; i < g_maxclients.integer && cnt < TEAM_MAXOVERLAY; i++) {
+		player = g_entities + level.sortedClients[i];
+		if (player->inuse && player->client->sess.sessionTeam == 
+			ent->client->sess.sessionTeam ) {
+			clients[cnt++] = level.sortedClients[i];
+		}
+	}
+
+	// We have the top eight players, sort them by clientNum
+	qsort( clients, cnt, sizeof( clients[0] ), SortClients );
+
+	// send the latest information on all clients
+	string[0] = 0;
+	stringlength = 0;
+
+	for (i = 0, cnt = 0; i < g_maxclients.integer && cnt < TEAM_MAXOVERLAY; i++) {
+		player = g_entities + i;
+		if (player->inuse && player->client->sess.sessionTeam == 
+			ent->client->sess.sessionTeam ) {
+
+			h = player->client->ps.stats[STAT_HEALTH];
+			a = player->client->ps.stats[STAT_ARMOR];
+			if (h < 0) h = 0;
+			if (a < 0) a = 0;
+
+			Com_sprintf (entry, sizeof(entry),
+				" %i %i %i %i %i %i", 
+//				level.sortedClients[i], player->client->pers.teamState.location, h, a, 
+				i, player->client->pers.teamState.location, h, a, 
+				player->client->ps.weapon, player->s.powerups);
+			j = strlen(entry);
+			if (stringlength + j > sizeof(string))
+				break;
+			strcpy (string + stringlength, entry);
+			stringlength += j;
+			cnt++;
+		}
+	}
+
+	trap_SendServerCommand( ent-g_entities, va("tinfo %i %s", cnt, string) );
+}
+
+void CheckTeamStatus(void) {
+	int i;
+	gentity_t *loc, *ent;
+
+	if (level.time - level.lastTeamLocationTime > TEAM_LOCATION_UPDATE_TIME) {
+
+		level.lastTeamLocationTime = level.time;
+
+		for (i = 0; i < g_maxclients.integer; i++) {
+			ent = g_entities + i;
+
+			if ( !ent->client )
+			{
+				continue;
+			}
+
+			if ( ent->client->pers.connected != CON_CONNECTED ) {
+				continue;
+			}
+
+			if (ent->inuse && (ent->client->sess.sessionTeam == TEAM_RED ||	ent->client->sess.sessionTeam == TEAM_BLUE)) {
+				loc = Team_GetLocation( ent );
+				if (loc)
+					ent->client->pers.teamState.location = loc->health;
+				else
+					ent->client->pers.teamState.location = 0;
+			}
+		}
+
+		for (i = 0; i < g_maxclients.integer; i++) {
+			ent = g_entities + i;
+
+			if ( ent->client->pers.connected != CON_CONNECTED ) {
+				continue;
+			}
+
+			if (ent->inuse && (ent->client->sess.sessionTeam == TEAM_RED ||	ent->client->sess.sessionTeam == TEAM_BLUE)) {
+				TeamplayInfoMessage( ent );
+			}
+		}
+	}
+}
+
+/*-----------------------------------------------------------------*/
+
+/*QUAKED team_CTF_redplayer (1 0 0) (-16 -16 -16) (16 16 32)
+Only in CTF games.  Red players spawn here at game start.
+*/
+void SP_team_CTF_redplayer( gentity_t *ent ) {
+}
+
+
+/*QUAKED team_CTF_blueplayer (0 0 1) (-16 -16 -16) (16 16 32)
+Only in CTF games.  Blue players spawn here at game start.
+*/
+void SP_team_CTF_blueplayer( gentity_t *ent ) {
+}
+
+
+/*QUAKED team_CTF_redspawn (1 0 0) (-16 -16 -24) (16 16 32)
+potential spawning position for red team in CTF games.
+Targets will be fired when someone spawns in on them.
+*/
+void SP_team_CTF_redspawn(gentity_t *ent) {
+}
+
+/*QUAKED team_CTF_bluespawn (0 0 1) (-16 -16 -24) (16 16 32)
+potential spawning position for blue team in CTF games.
+Targets will be fired when someone spawns in on them.
+*/
+void SP_team_CTF_bluespawn(gentity_t *ent) {
+}
+
+
diff --git a/codemp/game/g_team.h b/codemp/game/g_team.h
new file mode 100644
index 0000000..32cd840
--- /dev/null
+++ b/codemp/game/g_team.h
@@ -0,0 +1,50 @@
+// Copyright (C) 1999-2000 Id Software, Inc.
+//
+
+#define CTF_CAPTURE_BONUS		100		// what you get for capture
+#define CTF_TEAM_BONUS			25		// what your team gets for capture
+#define CTF_RECOVERY_BONUS		10		// what you get for recovery
+#define CTF_FLAG_BONUS			10		// what you get for picking up enemy flag
+#define CTF_FRAG_CARRIER_BONUS	20		// what you get for fragging enemy flag carrier
+#define CTF_FLAG_RETURN_TIME	40000	// seconds until auto return
+
+#define CTF_CARRIER_DANGER_PROTECT_BONUS	5	// bonus for fraggin someone who has recently hurt your flag carrier
+#define CTF_CARRIER_PROTECT_BONUS			2	// bonus for fraggin someone while either you or your target are near your flag carrier
+#define CTF_FLAG_DEFENSE_BONUS				10	// bonus for fraggin someone while either you or your target are near your flag
+#define CTF_RETURN_FLAG_ASSIST_BONUS		10	// awarded for returning a flag that causes a capture to happen almost immediately
+#define CTF_FRAG_CARRIER_ASSIST_BONUS		10	// award for fragging a flag carrier if a capture happens almost immediately
+
+#define CTF_TARGET_PROTECT_RADIUS			1000	// the radius around an object being defended where a target will be worth extra frags
+#define CTF_ATTACKER_PROTECT_RADIUS			1000	// the radius around an object being defended where an attacker will get extra frags when making kills
+
+#define CTF_CARRIER_DANGER_PROTECT_TIMEOUT	8000
+#define CTF_FRAG_CARRIER_ASSIST_TIMEOUT		10000
+#define CTF_RETURN_FLAG_ASSIST_TIMEOUT		10000
+
+#define CTF_GRAPPLE_SPEED					750 // speed of grapple in flight
+#define CTF_GRAPPLE_PULL_SPEED				750	// speed player is pulled at
+
+#define OVERLOAD_ATTACK_BASE_SOUND_TIME		20000
+
+// Prototypes
+
+int OtherTeam(int team);
+const char *TeamName(int team);
+const char *OtherTeamName(int team);
+const char *TeamColorString(int team);
+void AddTeamScore(vec3_t origin, int team, int score);
+
+void Team_DroppedFlagThink(gentity_t *ent);
+void Team_FragBonuses(gentity_t *targ, gentity_t *inflictor, gentity_t *attacker);
+void Team_CheckHurtCarrier(gentity_t *targ, gentity_t *attacker);
+void Team_InitGame(void);
+void Team_ReturnFlag(int team);
+void Team_FreeEntity(gentity_t *ent);
+gentity_t *SelectCTFSpawnPoint ( team_t team, int teamstate, vec3_t origin, vec3_t angles );
+gentity_t *SelectSiegeSpawnPoint ( int siegeClass, team_t team, int teamstate, vec3_t origin, vec3_t angles );
+gentity_t *Team_GetLocation(gentity_t *ent);
+qboolean Team_GetLocationMsg(gentity_t *ent, char *loc, int loclen);
+void TeamplayInfoMessage( gentity_t *ent );
+void CheckTeamStatus(void);
+
+int Pickup_Team( gentity_t *ent, gentity_t *other );
diff --git a/codemp/game/g_timer.c b/codemp/game/g_timer.c
new file mode 100644
index 0000000..36ae9ce
--- /dev/null
+++ b/codemp/game/g_timer.c
@@ -0,0 +1,294 @@
+//rww - rewrite from C++ SP version.
+//This is here only to make porting from SP easier, it's really sort of nasty (being static
+//now). Basically it's slower and takes more memory.
+
+#include "g_local.h"
+//typedef map		< string, int >	timer_m;
+
+#define MAX_GTIMERS	16384
+
+typedef struct gtimer_s
+{
+	const char *name;
+	int time;
+	struct gtimer_s *next;	// In either free list or current list
+} gtimer_t;
+
+gtimer_t g_timerPool[ MAX_GTIMERS ];
+gtimer_t *g_timers[ MAX_GENTITIES ];
+gtimer_t *g_timerFreeList;
+
+/*
+-------------------------
+TIMER_Clear
+-------------------------
+*/
+
+void TIMER_Clear( void )
+{
+	int i;
+	for (i = 0; i < MAX_GENTITIES; i++)
+	{
+		g_timers[i] = NULL;
+	}
+
+	for (i = 0; i < MAX_GTIMERS - 1; i++)
+	{
+		g_timerPool[i].next = &g_timerPool[i+1];
+	}
+	g_timerPool[MAX_GTIMERS-1].next = NULL;
+	g_timerFreeList = &g_timerPool[0];
+}
+
+/*
+-------------------------
+TIMER_Clear
+-------------------------
+*/
+
+void TIMER_Clear2( gentity_t *ent )
+{
+	// rudimentary safety checks, might be other things to check?
+	if ( ent && ent->s.number > 0 && ent->s.number < MAX_GENTITIES )
+	{
+		gtimer_t *p = g_timers[ent->s.number];
+
+		// No timers at all -> do nothing
+		if (!p)
+		{
+			return;
+		}
+
+		// Find the end of this ents timer list
+		while (p->next)
+		{
+			p = p->next;
+		}
+
+		// Splice the lists
+		p->next = g_timerFreeList;
+		g_timerFreeList = g_timers[ent->s.number];
+		g_timers[ent->s.number] = NULL;
+		return;
+	}
+}
+
+
+//New C "lookup" func.
+//Returns existing timer in array if 
+gtimer_t *TIMER_GetNew(int num, const char *identifier)
+{
+	gtimer_t *p = g_timers[num];
+
+	// Search for an existing timer with this name
+	while (p)
+	{
+		if (!Q_stricmp(p->name, identifier))
+		{ // Found it
+			return p;
+		}
+
+		p = p->next;
+	}
+
+	// No existing timer with this name was found, so grab one from the free list
+	if (!g_timerFreeList)
+		return NULL;
+
+	p = g_timerFreeList;
+	g_timerFreeList = g_timerFreeList->next;
+	p->next = g_timers[num];
+	g_timers[num] = p;
+	return p;
+}
+
+//don't return the first free if it doesn't already exist, return null.
+gtimer_t *TIMER_GetExisting(int num, const char *identifier)
+{
+	gtimer_t *p = g_timers[num];
+
+	while (p)
+	{
+		if (!Q_stricmp(p->name, identifier))
+		{ // Found it
+			return p;
+		}
+
+		p = p->next;
+	}
+	
+	return NULL;
+}	
+
+/*
+-------------------------
+TIMER_Set
+-------------------------
+*/
+
+void TIMER_Set( gentity_t *ent, const char *identifier, int duration )
+{
+	gtimer_t *timer = TIMER_GetNew(ent->s.number, identifier);
+
+	if (!timer)
+	{
+		return;
+	}
+	timer->name = identifier;
+	timer->time = level.time + duration;
+}
+
+/*
+-------------------------
+TIMER_Get
+-------------------------
+*/
+
+int	TIMER_Get( gentity_t *ent, const char *identifier )
+{
+	gtimer_t *timer = TIMER_GetExisting(ent->s.number, identifier);
+
+	if (!timer)
+	{
+		return -1;
+	}
+
+	return timer->time;
+}
+
+/*
+-------------------------
+TIMER_Done
+-------------------------
+*/
+
+qboolean TIMER_Done( gentity_t *ent, const char *identifier )
+{
+	gtimer_t *timer = TIMER_GetExisting(ent->s.number, identifier);
+
+	if (!timer)
+	{
+		return qtrue;
+	}
+
+	return (timer->time < level.time);
+}
+
+/*
+-------------------------
+TIMER_RemoveHelper
+
+Scans an entities timer list to remove a given
+timer from the list and put it on the free list
+
+Doesn't do much error checking, only called below
+-------------------------
+*/
+void TIMER_RemoveHelper( int num, gtimer_t *timer )
+{
+	gtimer_t *p = g_timers[num];
+
+	// Special case: first timer in list
+	if (p == timer)
+	{
+		g_timers[num] = g_timers[num]->next;
+		p->next = g_timerFreeList;
+		g_timerFreeList = p;
+		return;
+	}
+
+	// Find the predecessor
+	while (p->next != timer)
+	{
+		p = p->next;
+	}
+
+	// Rewire
+	p->next = p->next->next;
+	timer->next = g_timerFreeList;
+	g_timerFreeList = timer;
+	return;
+}
+
+/*
+-------------------------
+TIMER_Done2
+
+Returns false if timer has been 
+started but is not done...or if 
+timer was never started
+-------------------------
+*/
+
+qboolean TIMER_Done2( gentity_t *ent, const char *identifier, qboolean remove )
+{
+	gtimer_t *timer = TIMER_GetExisting(ent->s.number, identifier);
+	qboolean res;
+
+	if (!timer)
+	{
+		return qfalse;
+	}
+
+	res = (timer->time < level.time);
+
+	if (res && remove)
+	{
+		// Put it back on the free list
+		TIMER_RemoveHelper(ent->s.number, timer);
+	}
+
+	return res;
+}
+
+/*
+-------------------------
+TIMER_Exists
+-------------------------
+*/
+qboolean TIMER_Exists( gentity_t *ent, const char *identifier )
+{
+	gtimer_t *timer = TIMER_GetExisting(ent->s.number, identifier);
+
+	if (!timer)
+	{
+		return qfalse;
+	}
+
+	return qtrue;
+}
+
+/*
+-------------------------
+TIMER_Remove
+Utility to get rid of any timer
+-------------------------
+*/
+void TIMER_Remove( gentity_t *ent, const char *identifier )
+{
+	gtimer_t *timer = TIMER_GetExisting(ent->s.number, identifier);
+
+	if (!timer)
+	{
+		return;
+	}
+
+	// Put it back on the free list
+	TIMER_RemoveHelper(ent->s.number, timer);
+}
+
+/*
+-------------------------
+TIMER_Start
+-------------------------
+*/
+
+qboolean TIMER_Start( gentity_t *self, const char *identifier, int duration )
+{
+	if ( TIMER_Done( self, identifier ) )
+	{
+		TIMER_Set( self, identifier, duration );
+		return qtrue;
+	}
+	return qfalse;
+}
diff --git a/codemp/game/g_trigger.c b/codemp/game/g_trigger.c
new file mode 100644
index 0000000..34adc5f
--- /dev/null
+++ b/codemp/game/g_trigger.c
@@ -0,0 +1,1791 @@
+// Copyright (C) 1999-2000 Id Software, Inc.
+//
+#include "g_local.h"
+#include "bg_saga.h"
+
+int gTrigFallSound;
+
+void InitTrigger( gentity_t *self ) {
+	if (!VectorCompare (self->s.angles, vec3_origin))
+		G_SetMovedir (self->s.angles, self->movedir);
+
+	trap_SetBrushModel( self, self->model );
+	self->r.contents = CONTENTS_TRIGGER;		// replaces the -1 from trap_SetBrushModel
+	self->r.svFlags = SVF_NOCLIENT;
+
+	if(self->spawnflags & 128)
+	{
+		self->flags |= FL_INACTIVE;
+	}
+}
+
+// the wait time has passed, so set back up for another activation
+void multi_wait( gentity_t *ent ) {
+	ent->nextthink = 0;
+}
+
+void trigger_cleared_fire (gentity_t *self);
+
+// the trigger was just activated
+// ent->activator should be set to the activator so it can be held through a delay
+// so wait for the delay time before firing
+void multi_trigger_run( gentity_t *ent ) 
+{
+	ent->think = 0;
+
+	G_ActivateBehavior( ent, BSET_USE );
+
+	if ( ent->soundSet && ent->soundSet[0] )
+	{
+		trap_SetConfigstring( CS_GLOBAL_AMBIENT_SET, ent->soundSet );
+	}
+
+	if (ent->genericValue4)
+	{ //we want to activate target3 for team1 or target4 for team2
+		if (ent->genericValue4 == SIEGETEAM_TEAM1 &&
+			ent->target3 && ent->target3[0])
+		{
+			G_UseTargets2(ent, ent->activator, ent->target3);
+		}
+		else if (ent->genericValue4 == SIEGETEAM_TEAM2 &&
+			ent->target4 && ent->target4[0])
+		{
+			G_UseTargets2(ent, ent->activator, ent->target4);
+		}
+
+		ent->genericValue4 = 0;
+	}
+
+	G_UseTargets (ent, ent->activator);
+	if ( ent->noise_index ) 
+	{
+		G_Sound( ent->activator, CHAN_AUTO, ent->noise_index );
+	}
+
+	if ( ent->target2 && ent->target2[0] && ent->wait >= 0 )
+	{
+		ent->think = trigger_cleared_fire;
+		ent->nextthink = level.time + ent->speed;
+	}
+	else if ( ent->wait > 0 ) 
+	{
+		if ( ent->painDebounceTime != level.time )
+		{//first ent to touch it this frame
+			//ent->e_ThinkFunc = thinkF_multi_wait;
+			ent->nextthink = level.time + ( ent->wait + ent->random * crandom() ) * 1000;
+			ent->painDebounceTime = level.time;
+		}
+	} 
+	else if ( ent->wait < 0 )
+	{
+		// we can't just remove (self) here, because this is a touch function
+		// called while looping through area links...
+		ent->r.contents &= ~CONTENTS_TRIGGER;//so the EntityContact trace doesn't have to be done against me
+		ent->think = 0;
+		ent->use = 0;
+		//Don't remove, Icarus may barf?
+		//ent->nextthink = level.time + FRAMETIME;
+		//ent->think = G_FreeEntity;
+	}
+	if( ent->activator && ent->activator->client )
+	{	// mark the trigger as being touched by the player
+		ent->aimDebounceTime = level.time;
+	}
+}
+
+//determine if the class given is listed in the string using the | formatting
+qboolean G_NameInTriggerClassList(char *list, char *str)
+{
+	char cmp[MAX_STRING_CHARS];
+	int i = 0;
+	int j;
+
+	while (list[i])
+	{
+        j = 0;
+        while (list[i] && list[i] != '|')
+		{
+			cmp[j] = list[i];
+			i++;
+			j++;
+		}
+		cmp[j] = 0;
+
+		if (!Q_stricmp(str, cmp))
+		{ //found it
+			return qtrue;
+		}
+		if (list[i] != '|')
+		{ //reached the end and never found it
+			return qfalse;
+		}
+		i++;
+	}
+
+	return qfalse;
+}
+
+extern qboolean gSiegeRoundBegun;
+void SiegeItemRemoveOwner(gentity_t *ent, gentity_t *carrier);
+void multi_trigger( gentity_t *ent, gentity_t *activator ) 
+{
+	qboolean haltTrigger = qfalse;
+
+	if ( ent->think == multi_trigger_run )
+	{//already triggered, just waiting to run
+		return;
+	}
+
+	if (g_gametype.integer == GT_SIEGE &&
+		!gSiegeRoundBegun)
+	{ //nothing can be used til the round starts.
+		return;
+	}
+
+	if (g_gametype.integer == GT_SIEGE &&
+		activator && activator->client &&
+		ent->alliedTeam &&
+		activator->client->sess.sessionTeam != ent->alliedTeam)
+	{ //this team can't activate this trigger.
+		return;
+	}
+
+	if (g_gametype.integer == GT_SIEGE &&
+		ent->idealclass && ent->idealclass[0])
+	{ //only certain classes can activate it
+		if (!activator ||
+			!activator->client ||
+			activator->client->siegeClass < 0)
+		{ //no class
+			return;
+		}
+
+		if (!G_NameInTriggerClassList(bgSiegeClasses[activator->client->siegeClass].name, ent->idealclass))
+		{ //wasn't in the list
+			return;
+		}
+	}
+
+	if (g_gametype.integer == GT_SIEGE && ent->genericValue1)
+	{
+		haltTrigger = qtrue;
+
+		if (activator && activator->client &&
+			activator->client->holdingObjectiveItem &&
+			ent->targetname && ent->targetname[0])
+		{
+			gentity_t *objItem = &g_entities[activator->client->holdingObjectiveItem];
+
+			if (objItem && objItem->inuse)
+			{
+				if (objItem->goaltarget && objItem->goaltarget[0] &&
+					!Q_stricmp(ent->targetname, objItem->goaltarget))
+				{
+					if (objItem->genericValue7 != activator->client->sess.sessionTeam)
+					{ //The carrier of the item is not on the team which disallows objective scoring for it
+						if (objItem->target3 && objItem->target3[0])
+						{ //if it has a target3, fire it off instead of using the trigger
+							G_UseTargets2(objItem, objItem, objItem->target3);
+
+                            //3-24-03 - want to fire off the target too I guess, if we have one.
+							if (ent->targetname && ent->targetname[0])
+							{
+								haltTrigger = qfalse;
+							}
+						}
+						else
+						{
+							haltTrigger = qfalse;
+						}
+
+						//now that the item has been delivered, it can go away.
+						SiegeItemRemoveOwner(objItem, activator);
+						objItem->nextthink = 0;
+						objItem->neverFree = qfalse;
+						G_FreeEntity(objItem);
+					}
+				}
+			}
+		}
+	}
+	else if (ent->genericValue1)
+	{ //Never activate in non-siege gametype I guess.
+		return;
+	}
+
+	if (ent->genericValue2)
+	{ //has "teambalance" property
+		int i = 0;
+		int team1ClNum = 0;
+		int team2ClNum = 0;
+		int owningTeam = ent->genericValue3;
+		int newOwningTeam = 0;
+		int numEnts = 0;
+		int entityList[MAX_GENTITIES];
+		gentity_t *cl;
+
+		if (g_gametype.integer != GT_SIEGE)
+		{
+			return;
+		}
+
+		if (!activator->client ||
+			(activator->client->sess.sessionTeam != SIEGETEAM_TEAM1 && activator->client->sess.sessionTeam != SIEGETEAM_TEAM2))
+		{ //activator must be a valid client to begin with
+			return;
+		}
+
+		//Count up the number of clients standing within the bounds of the trigger and the number of them on each team
+		numEnts = trap_EntitiesInBox( ent->r.absmin, ent->r.absmax, entityList, MAX_GENTITIES );
+		while (i < numEnts)
+		{
+			if (entityList[i] < MAX_CLIENTS)
+			{ //only care about clients
+				cl = &g_entities[entityList[i]];
+
+				//the client is valid
+				if (cl->inuse && cl->client &&
+					(cl->client->sess.sessionTeam == SIEGETEAM_TEAM1 || cl->client->sess.sessionTeam == SIEGETEAM_TEAM2) &&
+					cl->health > 0 &&
+					!(cl->client->ps.eFlags & EF_DEAD))
+				{
+					//See which team he's on
+					if (cl->client->sess.sessionTeam == SIEGETEAM_TEAM1)
+					{
+						team1ClNum++;
+					}
+					else
+					{
+						team2ClNum++;
+					}
+				}
+			}
+			i++;
+		}
+
+		if (!team1ClNum && !team2ClNum)
+		{ //no one in the box? How did we get activated? Oh well.
+			return;
+		}
+
+		if (team1ClNum == team2ClNum)
+		{ //if equal numbers the ownership will remain the same as it is now
+			return;
+		}
+
+		//decide who owns it now
+		if (team1ClNum > team2ClNum)
+		{
+			newOwningTeam = SIEGETEAM_TEAM1;
+		}
+		else
+		{
+			newOwningTeam = SIEGETEAM_TEAM2;
+		}
+
+		if (owningTeam == newOwningTeam)
+		{ //it's the same one it already was, don't care then.
+			return;
+		}
+
+		//Set the new owner and set the variable which will tell us to activate a team-specific target
+		ent->genericValue3 = newOwningTeam;
+		ent->genericValue4 = newOwningTeam;
+	}
+
+	if (haltTrigger)
+	{ //This is an objective trigger and the activator is not carrying an objective item that matches the targetname.
+		return;
+	}
+
+	if ( ent->nextthink > level.time ) 
+	{
+		if( ent->spawnflags & 2048 ) // MULTIPLE - allow multiple entities to touch this trigger in a single frame
+		{
+			if ( ent->painDebounceTime && ent->painDebounceTime != level.time )
+			{//this should still allow subsequent ents to fire this trigger in the current frame
+				return;		// can't retrigger until the wait is over
+			}
+		}
+		else
+		{
+			return;
+		}
+
+	}
+
+	// if the player has already activated this trigger this frame
+	if( activator && !activator->s.number && ent->aimDebounceTime == level.time )
+	{
+		return;	
+	}
+
+	if ( ent->flags & FL_INACTIVE )
+	{//Not active at this time
+		return;
+	}
+
+	ent->activator = activator;
+
+	if(ent->delay && ent->painDebounceTime < (level.time + ent->delay) )
+	{//delay before firing trigger
+		ent->think = multi_trigger_run;
+		ent->nextthink = level.time + ent->delay;
+		ent->painDebounceTime = level.time;
+		
+	}
+	else
+	{
+		multi_trigger_run (ent);
+	}
+}
+
+void Use_Multi( gentity_t *ent, gentity_t *other, gentity_t *activator ) 
+{
+	multi_trigger( ent, activator );
+}
+
+qboolean G_PointInBounds( vec3_t point, vec3_t mins, vec3_t maxs );
+
+void Touch_Multi( gentity_t *self, gentity_t *other, trace_t *trace ) 
+{
+	if( !other->client ) 
+	{
+		return;
+	}
+
+	if ( self->flags & FL_INACTIVE )
+	{//set by target_deactivate
+		return;
+	}
+
+	if( self->alliedTeam )
+	{
+		if ( other->client->sess.sessionTeam != self->alliedTeam )
+		{
+			return;
+		}
+	}
+
+// moved to just above multi_trigger because up here it just checks if the trigger is not being touched
+// we want it to check any conditions set on the trigger, if one of those isn't met, the trigger is considered to be "cleared"
+//	if ( self->e_ThinkFunc == thinkF_trigger_cleared_fire )
+//	{//We're waiting to fire our target2 first
+//		self->nextthink = level.time + self->speed;
+//		return;
+//	}
+
+	if ( self->spawnflags & 1 )
+	{
+		if ( other->s.eType == ET_NPC )
+		{
+			return;
+		}
+	}
+	else
+	{
+		if ( self->spawnflags & 16 )
+		{//NPCONLY
+			if ( other->NPC == NULL )
+			{
+				return;
+			}
+		}
+
+		if ( self->NPC_targetname && self->NPC_targetname[0] )
+		{
+			if ( other->script_targetname && other->script_targetname[0] )
+			{
+				if ( Q_stricmp( self->NPC_targetname, other->script_targetname ) != 0 )
+				{//not the right guy to fire me off
+					return;
+				}
+			}
+			else
+			{
+				return;
+			}
+		}
+	}
+
+	if ( self->spawnflags & 2 )
+	{//FACING
+		vec3_t	forward;
+
+		AngleVectors( other->client->ps.viewangles, forward, NULL, NULL );
+
+		if ( DotProduct( self->movedir, forward ) < 0.5 )
+		{//Not Within 45 degrees
+			return;
+		}
+	}
+
+	if ( self->spawnflags & 4 )
+	{//USE_BUTTON
+		if( !( other->client->pers.cmd.buttons & BUTTON_USE ) )
+		{//not pressing use button
+			return;
+		}
+
+		if ((other->client->ps.weaponTime > 0 && other->client->ps.torsoAnim != BOTH_BUTTON_HOLD && other->client->ps.torsoAnim != BOTH_CONSOLE1) || other->health < 1 ||
+			(other->client->ps.pm_flags & PMF_FOLLOW) || other->client->sess.sessionTeam == TEAM_SPECTATOR ||
+			other->client->ps.forceHandExtend != HANDEXTEND_NONE)
+		{ //player has to be free of other things to use.
+			return;
+		}
+
+		if (self->genericValue7)
+		{ //we have to be holding the use key in this trigger for x milliseconds before firing
+			if (g_gametype.integer == GT_SIEGE &&
+				self->idealclass && self->idealclass[0])
+			{ //only certain classes can activate it
+				if (!other ||
+					!other->client ||
+					other->client->siegeClass < 0)
+				{ //no class
+					return;
+				}
+
+				if (!G_NameInTriggerClassList(bgSiegeClasses[other->client->siegeClass].name, self->idealclass))
+				{ //wasn't in the list
+					return;
+				}
+			}
+
+			if (!G_PointInBounds( other->client->ps.origin, self->r.absmin, self->r.absmax ))
+			{
+				return;
+			}
+			else if (other->client->isHacking != self->s.number && other->s.number < MAX_CLIENTS )
+			{ //start the hack
+				other->client->isHacking = self->s.number;
+				VectorCopy(other->client->ps.viewangles, other->client->hackingAngles);
+				other->client->ps.hackingTime = level.time + self->genericValue7;
+				other->client->ps.hackingBaseTime = self->genericValue7;
+				if (other->client->ps.hackingBaseTime > 60000)
+				{ //don't allow a bit overflow
+					other->client->ps.hackingTime = level.time + 60000;
+					other->client->ps.hackingBaseTime = 60000;
+				}
+				return;
+			}
+			else if (other->client->ps.hackingTime < level.time)
+			{ //finished with the hack, reset the hacking values and let it fall through
+				other->client->isHacking = 0; //can't hack a client
+				other->client->ps.hackingTime = 0;
+			}
+			else
+			{ //hack in progress
+				return;
+			}
+		}
+	}
+
+	if ( self->spawnflags & 8 )
+	{//FIRE_BUTTON
+		if( !( other->client->pers.cmd.buttons & BUTTON_ATTACK ) &&
+			!( other->client->pers.cmd.buttons & BUTTON_ALT_ATTACK ) )
+		{//not pressing fire button or altfire button
+			return;
+		}
+	}
+
+	if ( self->radius )
+	{
+		vec3_t	eyeSpot;
+
+		//Only works if your head is in it, but we allow leaning out
+		//NOTE: We don't use CalcEntitySpot SPOT_HEAD because we don't want this
+		//to be reliant on the physical model the player uses.
+		VectorCopy(other->client->ps.origin, eyeSpot);
+		eyeSpot[2] += other->client->ps.viewheight;
+
+		if ( G_PointInBounds( eyeSpot, self->r.absmin, self->r.absmax ) )
+		{
+			if( !( other->client->pers.cmd.buttons & BUTTON_ATTACK ) &&
+				!( other->client->pers.cmd.buttons & BUTTON_ALT_ATTACK ) )
+			{//not attacking, so hiding bonus
+				/*
+				//FIXME:  should really have sound events clear the hiddenDist
+				other->client->hiddenDist = self->radius;
+				//NOTE: movedir HAS to be normalized!
+				if ( VectorLength( self->movedir ) )
+				{//They can only be hidden from enemies looking in this direction
+					VectorCopy( self->movedir, other->client->hiddenDir );
+				}
+				else
+				{
+					VectorClear( other->client->hiddenDir );
+				}
+				*/
+				//Not using this, at least not yet.
+			}
+		}
+	}
+
+	if ( self->spawnflags & 4 )
+	{//USE_BUTTON
+		if (other->client->ps.torsoAnim != BOTH_BUTTON_HOLD &&
+			other->client->ps.torsoAnim != BOTH_CONSOLE1)
+		{
+			G_SetAnim( other, NULL, SETANIM_TORSO, BOTH_BUTTON_HOLD, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD, 0 );
+		}
+		else
+		{
+			other->client->ps.torsoTimer = 500;
+		}
+		other->client->ps.weaponTime = other->client->ps.torsoTimer;
+	}
+	
+	if ( self->think == trigger_cleared_fire )
+	{//We're waiting to fire our target2 first
+		self->nextthink = level.time + self->speed;
+		return;
+	}
+
+	multi_trigger( self, other );
+}
+
+void trigger_cleared_fire (gentity_t *self)
+{
+	G_UseTargets2( self, self->activator, self->target2 );
+	self->think = 0;
+	// should start the wait timer now, because the trigger's just been cleared, so we must "wait" from this point
+	if ( self->wait > 0 ) 
+	{
+		self->nextthink = level.time + ( self->wait + self->random * crandom() ) * 1000;
+	}
+}
+
+/*QUAKED trigger_multiple (.1 .5 .1) ? CLIENTONLY FACING USE_BUTTON FIRE_BUTTON NPCONLY x x INACTIVE MULTIPLE
+CLIENTONLY - only a player can trigger this by touch
+FACING - Won't fire unless triggering ent's view angles are within 45 degrees of trigger's angles (in addition to any other conditions)
+USE_BUTTON - Won't fire unless player is in it and pressing use button (in addition to any other conditions)
+FIRE_BUTTON - Won't fire unless player/NPC is in it and pressing fire button (in addition to any other conditions)
+NPCONLY - only non-player NPCs can trigger this by touch
+INACTIVE - Start off, has to be activated to be touchable/usable
+MULTIPLE - multiple entities can touch this trigger in a single frame *and* if needed, the trigger can have a wait of > 0
+
+"wait"		Seconds between triggerings, 0 default, number < 0 means one time only.
+"random"	wait variance, default is 0
+"delay"		how many seconds to wait to fire targets after tripped
+"hiderange" As long as NPC's head is in this trigger, NPCs out of this hiderange cannot see him.  If you set an angle on the trigger, they're only hidden from enemies looking in that direction.  the player's crouch viewheight is 36, his standing viewheight is 54.  So a trigger thast should hide you when crouched but not standing should be 48 tall.
+"target2"	The trigger will fire this only when the trigger has been activated and subsequently 'cleared'( once any of the conditions on the trigger have not been satisfied).  This will not fire the "target" more than once until the "target2" is fired (trigger field is 'cleared')
+"speed"		How many seconds to wait to fire the target2, default is 1
+"noise"		Sound to play when the trigger fires (plays at activator's origin)
+"NPC_targetname"  Only the NPC with this NPC_targetname fires this trigger
+
+Variable sized repeatable trigger.  Must be targeted at one or more entities.
+so, the basic time between firing is a random time between
+(wait - random) and (wait + random)
+
+"team" - If set, only this team can trip this trigger
+	0 - any
+	1 - red
+	2 - blue
+
+"soundSet"	Ambient sound set to play when this trigger is activated
+
+usetime		-	If specified (in milliseconds) along with the USE_BUTTON flag, will
+				require a client to hold the use key for x amount of ms before firing.
+
+Applicable only during Siege gametype:
+teamuser	-	if 1, team 2 can't use this. If 2, team 1 can't use this.
+siegetrig	-	if non-0, can only be activated by players carrying a misc_siege_item
+				which is associated with this trigger by the item's goaltarget value.
+teambalance	-	if non-0, is "owned" by the last team that activated. Can only be activated
+				by the other team if the number of players on the other team inside	the
+				trigger outnumber the number of players on the owning team inside the
+				trigger.
+target3		-	fire when activated by team1
+target4		-	fire when activated by team2
+
+idealclass	-	Can only be used by this class/these classes. You can specify use by
+				multiple classes with the use of |, e.g.:
+				"Imperial Medic|Imperial Assassin|Imperial Demolitionist"
+*/
+void SP_trigger_multiple( gentity_t *ent ) 
+{
+	char	*s;
+	if ( G_SpawnString( "noise", "", &s ) ) 
+	{
+		if (s && s[0])
+		{
+			ent->noise_index = G_SoundIndex(s);
+		}
+		else
+		{
+			ent->noise_index = 0;
+		}
+	}
+
+	G_SpawnInt("usetime", "0", &ent->genericValue7);
+
+	//For siege gametype
+	G_SpawnInt("siegetrig", "0", &ent->genericValue1);
+    G_SpawnInt("teambalance", "0", &ent->genericValue2);
+
+	G_SpawnInt("delay", "0", &ent->delay);
+
+	if ( (ent->wait > 0) && (ent->random >= ent->wait) ) {
+		ent->random = ent->wait - FRAMETIME;
+		Com_Printf(S_COLOR_YELLOW"trigger_multiple has random >= wait\n");
+	}
+
+	ent->delay *= 1000;//1 = 1 msec, 1000 = 1 sec
+	if ( !ent->speed && ent->target2 && ent->target2[0] )
+	{
+		ent->speed = 1000;
+	}
+	else
+	{
+		ent->speed *= 1000;
+	}
+
+	ent->touch = Touch_Multi;
+	ent->use   = Use_Multi;
+
+	if ( ent->team && ent->team[0] )
+	{
+		ent->alliedTeam = atoi(ent->team);
+		ent->team = NULL;
+	}
+
+	InitTrigger( ent );
+	trap_LinkEntity (ent);
+}
+
+
+/*QUAKED trigger_once (.5 1 .5) ? CLIENTONLY FACING USE_BUTTON FIRE_BUTTON x x x INACTIVE MULTIPLE
+CLIENTONLY - only a player can trigger this by touch
+FACING - Won't fire unless triggering ent's view angles are within 45 degrees of trigger's angles (in addition to any other conditions)
+USE_BUTTON - Won't fire unless player is in it and pressing use button (in addition to any other conditions)
+FIRE_BUTTON - Won't fire unless player/NPC is in it and pressing fire button (in addition to any other conditions)
+INACTIVE - Start off, has to be activated to be touchable/usable
+MULTIPLE - multiple entities can touch this trigger in a single frame *and* if needed, the trigger can have a wait of > 0
+
+"random"	wait variance, default is 0
+"delay"		how many seconds to wait to fire targets after tripped
+Variable sized repeatable trigger.  Must be targeted at one or more entities.
+so, the basic time between firing is a random time between
+(wait - random) and (wait + random)
+"noise"		Sound to play when the trigger fires (plays at activator's origin)
+"NPC_targetname"  Only the NPC with this NPC_targetname fires this trigger
+
+"team" - If set, only this team can trip this trigger
+	0 - any
+	1 - red
+	2 - blue
+
+"soundSet"	Ambient sound set to play when this trigger is activated
+
+usetime		-	If specified (in milliseconds) along with the USE_BUTTON flag, will
+				require a client to hold the use key for x amount of ms before firing.
+
+Applicable only during Siege gametype:
+teamuser - if 1, team 2 can't use this. If 2, team 1 can't use this.
+siegetrig - if non-0, can only be activated by players carrying a misc_siege_item
+			which is associated with this trigger by the item's goaltarget value.
+
+idealclass	-	Can only be used by this class/these classes. You can specify use by
+				multiple classes with the use of |, e.g.:
+				"Imperial Medic|Imperial Assassin|Imperial Demolitionist"
+*/
+void SP_trigger_once( gentity_t *ent ) 
+{
+	char	*s;
+	if ( G_SpawnString( "noise", "", &s ) ) 
+	{
+		if (s && s[0])
+		{
+			ent->noise_index = G_SoundIndex(s);
+		}
+		else
+		{
+			ent->noise_index = 0;
+		}
+	}
+
+	G_SpawnInt("usetime", "0", &ent->genericValue7);
+
+	//For siege gametype
+	G_SpawnInt("siegetrig", "0", &ent->genericValue1);
+
+	G_SpawnInt("delay", "0", &ent->delay);
+
+	ent->wait = -1;
+
+	ent->touch = Touch_Multi;
+	ent->use   = Use_Multi;
+
+	if ( ent->team && ent->team[0] )
+	{
+		ent->alliedTeam = atoi(ent->team);
+		ent->team = NULL;
+	}
+
+	ent->delay *= 1000;//1 = 1 msec, 1000 = 1 sec
+
+	InitTrigger( ent );
+	trap_LinkEntity (ent);
+}
+
+/*
+======================================================================
+trigger_lightningstrike -rww
+======================================================================
+*/
+//lightning strike trigger lightning strike event
+void Do_Strike(gentity_t *ent)
+{
+	trace_t localTrace;
+	vec3_t strikeFrom;
+	vec3_t strikePoint;
+	vec3_t fxAng;
+	
+	//maybe allow custom fx direction at some point?
+	VectorSet(fxAng, 90.0f, 0.0f, 0.0f);
+
+	//choose a random point to strike within the bounds of the trigger
+	strikePoint[0] = flrand(ent->r.absmin[0], ent->r.absmax[0]);
+	strikePoint[1] = flrand(ent->r.absmin[1], ent->r.absmax[1]);
+
+	//consider the bottom mins the ground level
+	strikePoint[2] = ent->r.absmin[2];
+
+	//set the from point
+	strikeFrom[0] = strikePoint[0];
+	strikeFrom[1] = strikePoint[1];
+	strikeFrom[2] = ent->r.absmax[2]-4.0f;
+
+	//now trace for damaging stuff, and do the effect
+	trap_Trace(&localTrace, strikeFrom, NULL, NULL, strikePoint, ent->s.number, MASK_PLAYERSOLID);
+	VectorCopy(localTrace.endpos, strikePoint);
+
+	if (localTrace.startsolid || localTrace.allsolid)
+	{ //got a bad spot, think again next frame to try another strike
+		ent->nextthink = level.time;
+		return;
+	}
+
+	if (ent->radius)
+	{ //do a radius damage at the end pos
+		G_RadiusDamage(strikePoint, ent, ent->damage, ent->radius, ent, NULL, MOD_SUICIDE);
+	}
+	else
+	{ //only damage individuals
+		gentity_t *trHit = &g_entities[localTrace.entityNum];
+
+		if (trHit->inuse && trHit->takedamage)
+		{ //damage it then
+			G_Damage(trHit, ent, ent, NULL, trHit->r.currentOrigin, ent->damage, 0, MOD_SUICIDE);
+		}
+	}
+
+	G_PlayEffectID(ent->genericValue2, strikeFrom, fxAng);
+}
+
+//lightning strike trigger think loop
+void Think_Strike(gentity_t *ent)
+{
+	if (ent->genericValue1)
+	{ //turned off currently
+		return;
+	}
+
+	ent->nextthink = level.time + ent->wait + Q_irand(0, ent->random);
+	Do_Strike(ent);
+}
+
+//lightning strike trigger use event function
+void Use_Strike( gentity_t *ent, gentity_t *other, gentity_t *activator ) 
+{
+	ent->genericValue1 = !ent->genericValue1;
+
+	if (!ent->genericValue1)
+	{ //turn it back on
+		ent->nextthink = level.time;
+	}
+}
+
+/*QUAKED trigger_lightningstrike (.1 .5 .1) ? START_OFF
+START_OFF - start trigger disabled
+
+"lightningfx"	effect to use for lightning, MUST be specified
+"wait"			Seconds between strikes, 1000 default
+"random"		wait variance, default is 2000
+"dmg"			damage on strike (default 50)
+"radius"		if non-0, does a radius damage at the lightning strike
+				impact point (using this value as the radius). otherwise
+				will only do line trace damage. default 0.
+
+use to toggle on and off
+*/
+void SP_trigger_lightningstrike( gentity_t *ent ) 
+{
+	char *s;
+
+	ent->use = Use_Strike;
+	ent->think = Think_Strike;
+	ent->nextthink = level.time + 500;
+
+	G_SpawnString("lightningfx", "", &s);
+	if (!s || !s[0])
+	{
+		Com_Error(ERR_DROP, "trigger_lightningstrike with no lightningfx");
+	}
+
+	//get a configstring index for it
+	ent->genericValue2 = G_EffectIndex(s);
+
+	if (ent->spawnflags & 1)
+	{ //START_OFF
+		ent->genericValue1 = 1;
+	}
+
+	if (!ent->wait)
+	{ //default 1000
+		ent->wait = 1000;
+	}
+	if (!ent->random)
+	{ //default 2000
+		ent->random = 2000;
+	}
+	if (!ent->damage)
+	{ //default 50
+		ent->damage = 50;
+	}
+
+	InitTrigger( ent );
+	trap_LinkEntity (ent);
+}
+
+
+/*
+==============================================================================
+
+trigger_always
+
+==============================================================================
+*/
+
+void trigger_always_think( gentity_t *ent ) {
+	G_UseTargets(ent, ent);
+	G_FreeEntity( ent );
+}
+
+/*QUAKED trigger_always (.5 .5 .5) (-8 -8 -8) (8 8 8)
+This trigger will always fire.  It is activated by the world.
+*/
+void SP_trigger_always (gentity_t *ent) {
+	// we must have some delay to make sure our use targets are present
+	ent->nextthink = level.time + 300;
+	ent->think = trigger_always_think;
+}
+
+
+/*
+==============================================================================
+
+trigger_push
+
+==============================================================================
+*/
+//trigger_push
+#define PUSH_LINEAR		4
+#define PUSH_RELATIVE	16
+#define PUSH_MULTIPLE	2048
+//target_push
+#define PUSH_CONSTANT	2
+
+void trigger_push_touch (gentity_t *self, gentity_t *other, trace_t *trace ) {
+	if ( self->flags & FL_INACTIVE )
+	{//set by target_deactivate
+		return;
+	}
+
+	if ( !(self->spawnflags&PUSH_LINEAR) )
+	{//normal throw
+		if ( !other->client ) {
+			return;
+		}
+		BG_TouchJumpPad( &other->client->ps, &self->s );
+		return;
+	}
+
+	//linear
+	if( level.time < self->painDebounceTime + self->wait  ) // normal 'wait' check
+	{
+		if( self->spawnflags & PUSH_MULTIPLE ) // MULTIPLE - allow multiple entities to touch this trigger in one frame
+		{
+			if ( self->painDebounceTime && level.time > self->painDebounceTime ) // if we haven't reached the next frame continue to let ents touch the trigger
+			{
+				return;
+			}
+		}
+		else // only allowing one ent per frame to touch trigger
+		{
+			return;
+		}
+	}
+
+	/*
+	//???
+	// if the player has already activated this trigger this frame
+	if( other && !other->s.number && self->aimDebounceTime == level.time )
+	{
+		return;		
+	}
+	*/
+	
+	/*
+	if( self->spawnflags & PUSH_CONVEYOR )
+	{   // only push player if he's on the ground
+		if( other->s.groundEntityNum == ENTITYNUM_NONE )
+		{
+			return;
+		}
+	}
+	*/
+
+	/*
+	if ( self->spawnflags & 1 )
+	{//PLAYERONLY
+		if ( other->s.number >= MAX_CLIENTS )
+		{
+			return;
+		}
+	}
+	else
+	{
+		if ( self->spawnflags & 8 )
+		{//NPCONLY
+			if ( other->NPC == NULL )
+			{
+				return;
+			}
+		}
+	}
+	*/
+
+	if ( !other->client ) {
+		if ( other->s.pos.trType != TR_STATIONARY && other->s.pos.trType != TR_LINEAR_STOP && other->s.pos.trType != TR_NONLINEAR_STOP && VectorLengthSquared( other->s.pos.trDelta ) )
+		{//already moving
+			VectorCopy( other->r.currentOrigin, other->s.pos.trBase );
+			VectorCopy( self->s.origin2, other->s.pos.trDelta );
+			other->s.pos.trTime = level.time;
+		}
+		return;
+	}
+
+	if ( other->client->ps.pm_type != PM_NORMAL 
+		&& other->client->ps.pm_type != PM_DEAD 
+		&& other->client->ps.pm_type != PM_FREEZE ) 
+	{
+		return;
+	}
+	
+	if ( (self->spawnflags&PUSH_RELATIVE) )
+	{//relative, dir to it * speed
+		vec3_t dir;
+		VectorSubtract( self->s.origin2, other->r.currentOrigin, dir );
+		if ( self->speed )
+		{
+			VectorNormalize( dir );
+			VectorScale( dir, self->speed, dir );
+		}
+		VectorCopy( dir, other->client->ps.velocity );
+	}
+	else if ( (self->spawnflags&PUSH_LINEAR) )
+	{//linear dir * speed
+		VectorScale( self->s.origin2, self->speed, other->client->ps.velocity );
+	}
+	else
+	{
+		VectorCopy( self->s.origin2, other->client->ps.velocity );
+	}
+	//so we don't take damage unless we land lower than we start here...
+	/*
+	other->client->ps.forceJumpZStart = 0;
+	other->client->ps.pm_flags |= PMF_TRIGGER_PUSHED;//pushed by a trigger
+	other->client->ps.jumpZStart = other->client->ps.origin[2];
+	*/
+
+	if ( self->wait == -1 )
+	{
+		self->touch = NULL;
+	}
+	else if ( self->wait > 0 )
+	{
+		self->painDebounceTime = level.time;
+		
+	}
+	/*
+	if( other && !other->s.number )
+	{	// mark that the player has activated this trigger this frame
+		self->aimDebounceTime =level.time;
+	}
+	*/
+}
+
+
+/*
+=================
+AimAtTarget
+
+Calculate origin2 so the target apogee will be hit
+=================
+*/
+void AimAtTarget( gentity_t *self ) {
+	gentity_t	*ent;
+	vec3_t		origin;
+	float		height, gravity, time, forward;
+	float		dist;
+
+	VectorAdd( self->r.absmin, self->r.absmax, origin );
+	VectorScale ( origin, 0.5f, origin );
+
+	ent = G_PickTarget( self->target );
+	if ( !ent ) {
+		G_FreeEntity( self );
+		return;
+	}
+
+	if ( self->classname && !Q_stricmp( "trigger_push", self->classname ) )
+	{
+		if ( (self->spawnflags&PUSH_RELATIVE) )
+		{//relative, not an arc or linear
+			VectorCopy( ent->r.currentOrigin, self->s.origin2 );
+			return;
+		}
+		else if ( (self->spawnflags&PUSH_LINEAR) )
+		{//linear, not an arc
+			VectorSubtract( ent->r.currentOrigin, origin, self->s.origin2 );
+			VectorNormalize( self->s.origin2 );
+			return;
+		}
+	}
+
+	if ( self->classname && !Q_stricmp( "target_push", self->classname ) )
+	{
+		if( self->spawnflags & PUSH_CONSTANT )
+		{
+			VectorSubtract ( ent->s.origin, self->s.origin, self->s.origin2 );
+			VectorNormalize( self->s.origin2);
+			VectorScale (self->s.origin2, self->speed, self->s.origin2);
+			return;
+		}
+	}
+
+	height = ent->s.origin[2] - origin[2];
+	gravity = g_gravity.value;
+	time = sqrt( height / ( .5 * gravity ) );
+	if ( !time ) {
+		G_FreeEntity( self );
+		return;
+	}
+
+	// set s.origin2 to the push velocity
+	VectorSubtract ( ent->s.origin, origin, self->s.origin2 );
+	self->s.origin2[2] = 0;
+	dist = VectorNormalize( self->s.origin2);
+
+	forward = dist / time;
+	VectorScale( self->s.origin2, forward, self->s.origin2 );
+
+	self->s.origin2[2] = time * gravity;
+}
+
+
+/*QUAKED trigger_push (.5 .5 .5) ? x x LINEAR x RELATIVE x x INACTIVE MULTIPLE
+Must point at a target_position, which will be the apex of the leap.
+This will be client side predicted, unlike target_push
+
+LINEAR - Instead of tossing the client at the target_position, it will push them towards it.  Must set a "speed" (see below)
+RELATIVE - instead of pushing you in a direction that is always from the center of the trigger to the target_position, it pushes *you* toward the target position, relative to your current location (can use with "speed"... if don't set a speed, it will use the distance from you to the target_position)
+INACTIVE - not active until targeted by a target_activate
+MULTIPLE - multiple entities can touch this trigger in a single frame *and* if needed, the trigger can have a wait of > 0
+
+wait - how long to wait between pushes: -1 = push only once
+speed - when used with the LINEAR spawnflag, pushes the client toward the position at a constant speed (default is 1000)
+*/
+void SP_trigger_push( gentity_t *self ) {
+	InitTrigger (self);
+
+	// unlike other triggers, we need to send this one to the client
+	self->r.svFlags &= ~SVF_NOCLIENT;
+
+	// make sure the client precaches this sound
+	G_SoundIndex("sound/weapons/force/jump.wav");
+
+	self->s.eType = ET_PUSH_TRIGGER;
+	
+	if ( !(self->spawnflags&2) )
+	{//start on
+		self->touch = trigger_push_touch;
+	}
+
+	if ( self->spawnflags & 4 )
+	{//linear
+		self->speed = 1000;
+	}
+
+	self->think = AimAtTarget;
+	self->nextthink = level.time + FRAMETIME;
+	trap_LinkEntity (self);
+}
+
+void Use_target_push( gentity_t *self, gentity_t *other, gentity_t *activator ) {
+	if ( !activator->client ) {
+		return;
+	}
+
+	if ( activator->client->ps.pm_type != PM_NORMAL && activator->client->ps.pm_type != PM_FLOAT ) {
+		return;
+	}
+
+	G_ActivateBehavior(self,BSET_USE);
+
+	VectorCopy (self->s.origin2, activator->client->ps.velocity);
+
+	// play fly sound every 1.5 seconds
+	if ( activator->fly_sound_debounce_time < level.time ) {
+		activator->fly_sound_debounce_time = level.time + 1500;
+		if (self->noise_index)
+		{
+			G_Sound( activator, CHAN_AUTO, self->noise_index );
+		}
+	}
+}
+
+/*QUAKED target_push (.5 .5 .5) (-8 -8 -8) (8 8 8) bouncepad CONSTANT
+CONSTANT will push activator in direction of 'target' at constant 'speed'
+
+Pushes the activator in the direction.of angle, or towards a target apex.
+"speed"		defaults to 1000
+if "bouncepad", play bounce noise instead of none
+*/
+void SP_target_push( gentity_t *self ) {
+	if (!self->speed) {
+		self->speed = 1000;
+	}
+	G_SetMovedir (self->s.angles, self->s.origin2);
+	VectorScale (self->s.origin2, self->speed, self->s.origin2);
+
+	if ( self->spawnflags & 1 ) {
+		self->noise_index = G_SoundIndex("sound/weapons/force/jump.wav");
+	} else {
+		self->noise_index = 0;	//G_SoundIndex("sound/misc/windfly.wav");
+	}
+	if ( self->target ) {
+		VectorCopy( self->s.origin, self->r.absmin );
+		VectorCopy( self->s.origin, self->r.absmax );
+		self->think = AimAtTarget;
+		self->nextthink = level.time + FRAMETIME;
+	}
+	self->use = Use_target_push;
+}
+
+/*
+==============================================================================
+
+trigger_teleport
+
+==============================================================================
+*/
+
+void trigger_teleporter_touch (gentity_t *self, gentity_t *other, trace_t *trace ) {
+	gentity_t	*dest;
+
+	if ( self->flags & FL_INACTIVE )
+	{//set by target_deactivate
+		return;
+	}
+
+	if ( !other->client ) {
+		return;
+	}
+	if ( other->client->ps.pm_type == PM_DEAD ) {
+		return;
+	}
+	// Spectators only?
+	if ( ( self->spawnflags & 1 ) && 
+		other->client->sess.sessionTeam != TEAM_SPECTATOR ) {
+		return;
+	}
+
+
+	dest = 	G_PickTarget( self->target );
+	if (!dest) {
+		G_Printf ("Couldn't find teleporter destination\n");
+		return;
+	}
+
+	TeleportPlayer( other, dest->s.origin, dest->s.angles );
+}
+
+
+/*QUAKED trigger_teleport (.5 .5 .5) ? SPECTATOR
+Allows client side prediction of teleportation events.
+Must point at a target_position, which will be the teleport destination.
+
+If spectator is set, only spectators can use this teleport
+Spectator teleporters are not normally placed in the editor, but are created
+automatically near doors to allow spectators to move through them
+*/
+void SP_trigger_teleport( gentity_t *self ) {
+	InitTrigger (self);
+
+	// unlike other triggers, we need to send this one to the client
+	// unless is a spectator trigger
+	if ( self->spawnflags & 1 ) {
+		self->r.svFlags |= SVF_NOCLIENT;
+	} else {
+		self->r.svFlags &= ~SVF_NOCLIENT;
+	}
+
+	// make sure the client precaches this sound
+	G_SoundIndex("sound/weapons/force/speed.wav");
+
+	self->s.eType = ET_TELEPORT_TRIGGER;
+	self->touch = trigger_teleporter_touch;
+
+	trap_LinkEntity (self);
+}
+
+
+/*
+==============================================================================
+
+trigger_hurt
+
+==============================================================================
+*/
+
+/*QUAKED trigger_hurt (.5 .5 .5) ? START_OFF CAN_TARGET SILENT NO_PROTECTION SLOW
+Any entity that touches this will be hurt.
+It does dmg points of damage each server frame
+Targeting the trigger will toggle its on / off state.
+
+CAN_TARGET		if you target it, it will toggle on and off
+SILENT			supresses playing the sound
+SLOW			changes the damage rate to once per second
+NO_PROTECTION	*nothing* stops the damage
+
+"team"			team (1 or 2) to allow hurting (if none then hurt anyone) only applicable for siege
+"dmg"			default 5 (whole numbers only)
+If dmg is set to -1 this brush will use the fade-kill method
+
+*/
+void hurt_use( gentity_t *self, gentity_t *other, gentity_t *activator ) {
+	if (activator && activator->inuse && activator->client)
+	{
+		self->activator = activator;
+	}
+	else
+	{
+		self->activator = NULL;
+	}
+
+	G_ActivateBehavior(self,BSET_USE);
+
+	if ( self->r.linked ) {
+		trap_UnlinkEntity( self );
+	} else {
+		trap_LinkEntity( self );
+	}
+}
+
+void hurt_touch( gentity_t *self, gentity_t *other, trace_t *trace ) {
+	int		dflags;
+
+	if (g_gametype.integer == GT_SIEGE && self->team && self->team[0])
+	{
+		int team = atoi(self->team);
+
+		if (other->inuse && other->s.number < MAX_CLIENTS && other->client &&
+			other->client->sess.sessionTeam != team)
+		{ //real client don't hurt
+			return;
+		}
+		else if (other->inuse && other->client && other->s.eType == ET_NPC &&
+			other->s.NPC_class == CLASS_VEHICLE && other->s.teamowner != team)
+		{ //vehicle owned by team don't hurt
+			return;
+		}
+	}
+
+	if ( self->flags & FL_INACTIVE )
+	{//set by target_deactivate
+		return;
+	}
+
+	if ( !other->takedamage ) {
+		return;
+	}
+
+	if ( self->timestamp > level.time ) {
+		return;
+	}
+
+	if (self->damage == -1 && other && other->client && other->health < 1)
+	{
+		other->client->ps.fallingToDeath = 0;
+		respawn(other);
+		return;
+	}
+
+	if (self->damage == -1 && other && other->client && other->client->ps.fallingToDeath)
+	{
+		return;
+	}
+
+	if ( self->spawnflags & 16 ) {
+		self->timestamp = level.time + 1000;
+	} else {
+		self->timestamp = level.time + FRAMETIME;
+	}
+
+	// play sound
+	/*
+	if ( !(self->spawnflags & 4) && self->damage != -1 ) {
+		G_Sound( other, CHAN_AUTO, self->noise_index );
+	}
+	*/
+
+	if (self->spawnflags & 8)
+		dflags = DAMAGE_NO_PROTECTION;
+	else
+		dflags = 0;
+
+	if (self->damage == -1 && other && other->client)
+	{
+		if (other->client->ps.otherKillerTime > level.time)
+		{ //we're as good as dead, so if someone pushed us into this then remember them
+			other->client->ps.otherKillerTime = level.time + 20000;
+			other->client->ps.otherKillerDebounceTime = level.time + 10000;
+		}
+		other->client->ps.fallingToDeath = level.time;
+
+		//rag on the way down, this flag will automatically be cleared for us on respawn
+		other->client->ps.eFlags |= EF_RAG;
+
+		//make sure his jetpack is off
+		Jetpack_Off(other);
+
+		if (other->NPC)
+		{ //kill it now
+			vec3_t vDir;
+
+			VectorSet(vDir, 0, 1, 0);
+			G_Damage(other, other, other, vDir, other->client->ps.origin, Q3_INFINITE, 0, MOD_FALLING);
+		}
+		else
+		{
+			G_EntitySound(other, CHAN_VOICE, G_SoundIndex("*falling1.wav"));
+		}
+
+		self->timestamp = 0; //do not ignore others
+	}
+	else	
+	{
+		int dmg = self->damage;
+
+		if (dmg == -1)
+		{ //so fall-to-blackness triggers destroy evertyhing
+			dmg = 99999;
+			self->timestamp = 0;
+		}
+		if (self->activator && self->activator->inuse && self->activator->client)
+		{
+			G_Damage (other, self->activator, self->activator, NULL, NULL, dmg, dflags|DAMAGE_NO_PROTECTION, MOD_TRIGGER_HURT);
+		}
+		else
+		{
+			G_Damage (other, self, self, NULL, NULL, dmg, dflags|DAMAGE_NO_PROTECTION, MOD_TRIGGER_HURT);
+		}
+	}
+}
+
+void SP_trigger_hurt( gentity_t *self ) {
+	InitTrigger (self);
+
+	gTrigFallSound = G_SoundIndex("*falling1.wav");
+
+	self->noise_index = G_SoundIndex( "sound/weapons/force/speed.wav" );
+	self->touch = hurt_touch;
+
+	if ( !self->damage ) {
+		self->damage = 5;
+	}
+
+	self->r.contents = CONTENTS_TRIGGER;
+
+	if ( self->spawnflags & 2 ) {
+		self->use = hurt_use;
+	}
+
+	// link in to the world if starting active
+	if ( ! (self->spawnflags & 1) ) {
+		trap_LinkEntity (self);
+	}
+	else if (self->r.linked)
+	{
+		trap_UnlinkEntity(self);
+	}
+}
+
+#define	INITIAL_SUFFOCATION_DELAY	500 //.5 seconds
+void space_touch( gentity_t *self, gentity_t *other, trace_t *trace )
+{
+	if (!other || !other->inuse || !other->client )
+		//NOTE: we need vehicles to know this, too...
+		//|| other->s.number >= MAX_CLIENTS)
+	{
+		return;
+	}
+
+	if ( other->s.number < MAX_CLIENTS//player
+		&& other->client->ps.m_iVehicleNum//in a vehicle
+		&& other->client->ps.m_iVehicleNum >= MAX_CLIENTS )
+	{//a player client inside a vehicle
+		gentity_t *veh = &g_entities[other->client->ps.m_iVehicleNum];
+
+		if (veh->inuse && veh->client && veh->m_pVehicle &&
+			veh->m_pVehicle->m_pVehicleInfo->hideRider)
+		{ //if they are "inside" a vehicle, then let that protect them from THE HORRORS OF SPACE.
+			other->client->inSpaceSuffocation = 0;
+			other->client->inSpaceIndex = ENTITYNUM_NONE;
+			return;
+		}
+	}
+
+	if (!G_PointInBounds(other->client->ps.origin, self->r.absmin, self->r.absmax))
+	{ //his origin must be inside the trigger
+		return;
+	}
+
+	if (!other->client->inSpaceIndex ||
+		other->client->inSpaceIndex == ENTITYNUM_NONE)
+	{ //freshly entering space
+		other->client->inSpaceSuffocation = level.time + INITIAL_SUFFOCATION_DELAY;
+	}
+
+	other->client->inSpaceIndex = self->s.number;
+}
+
+/*QUAKED trigger_space (.5 .5 .5) ? 
+causes human clients to suffocate and have no gravity.
+
+*/
+void SP_trigger_space(gentity_t *self)
+{
+	InitTrigger(self);
+	self->r.contents = CONTENTS_TRIGGER;
+	
+	self->touch = space_touch;
+
+    trap_LinkEntity(self);
+}
+
+void shipboundary_touch( gentity_t *self, gentity_t *other, trace_t *trace )
+{
+	gentity_t *ent;
+
+	if (!other || !other->inuse || !other->client ||
+		other->s.number < MAX_CLIENTS ||
+		!other->m_pVehicle)
+	{ //only let vehicles touch
+		return;
+	}
+
+	if ( other->client->ps.hyperSpaceTime && level.time - other->client->ps.hyperSpaceTime < HYPERSPACE_TIME )
+	{//don't interfere with hyperspacing ships
+		return;
+	}
+
+	ent = G_Find (NULL, FOFS(targetname), self->target);
+	if (!ent || !ent->inuse)
+	{ //this is bad
+		G_Error("trigger_shipboundary has invalid target '%s'\n", self->target);
+		return;
+	}
+
+	if (!other->client->ps.m_iVehicleNum || other->m_pVehicle->m_iRemovedSurfaces)
+	{ //if a vehicle touches a boundary without a pilot in it or with parts missing, just blow the thing up
+		G_Damage(other, other, other, NULL, other->client->ps.origin, 99999, DAMAGE_NO_PROTECTION, MOD_SUICIDE);
+		return;
+	}
+
+	//make sure this sucker is linked so the prediction knows where to go
+	trap_LinkEntity(ent);
+
+	other->client->ps.vehTurnaroundIndex = ent->s.number;
+	other->client->ps.vehTurnaroundTime = level.time + (self->genericValue1*2);
+
+	//keep up the detailed checks for another 2 seconds
+	self->genericValue7 = level.time + 2000;
+}
+
+void shipboundary_think(gentity_t *ent)
+{
+	int			iEntityList[MAX_GENTITIES];
+	int			numListedEntities;
+	int			i = 0;
+	gentity_t	*listedEnt;
+
+	ent->nextthink = level.time + 100;
+
+	if (ent->genericValue7 < level.time)
+	{ //don't need to be doing this check, no one has touched recently
+		return;
+	}
+
+	numListedEntities = trap_EntitiesInBox( ent->r.absmin, ent->r.absmax, iEntityList, MAX_GENTITIES );
+	while (i < numListedEntities)
+	{
+		listedEnt = &g_entities[iEntityList[i]];
+		if (listedEnt->inuse && listedEnt->client && listedEnt->client->ps.m_iVehicleNum)
+		{
+            if (listedEnt->s.eType == ET_NPC &&
+				listedEnt->s.NPC_class == CLASS_VEHICLE)
+			{
+				Vehicle_t *pVeh = listedEnt->m_pVehicle;
+				if (pVeh && pVeh->m_pVehicleInfo->type == VH_FIGHTER)
+				{
+                    shipboundary_touch(ent, listedEnt, NULL);
+				}
+			}
+		}
+		i++;
+	}
+}
+
+/*QUAKED trigger_shipboundary (.5 .5 .5) ? 
+causes vehicle to turn toward target and travel in that direction for a set time when hit.
+
+"target"		name of entity to turn toward (can be info_notnull, or whatever).
+"traveltime"	time to travel in this direction
+
+*/
+void SP_trigger_shipboundary(gentity_t *self)
+{
+	InitTrigger(self);
+	self->r.contents = CONTENTS_TRIGGER;
+	
+	if (!self->target || !self->target[0])
+	{
+		G_Error("trigger_shipboundary without a target.");
+	}
+	G_SpawnInt("traveltime", "0", &self->genericValue1);
+
+	if (!self->genericValue1)
+	{
+		G_Error("trigger_shipboundary without traveltime.");
+	}
+
+	self->think = shipboundary_think;
+	self->nextthink = level.time + 500;
+	self->touch = shipboundary_touch;
+
+    trap_LinkEntity(self);
+}
+
+void hyperspace_touch( gentity_t *self, gentity_t *other, trace_t *trace )
+{
+	gentity_t *ent;
+
+	if (!other || !other->inuse || !other->client ||
+		other->s.number < MAX_CLIENTS ||
+		!other->m_pVehicle)
+	{ //only let vehicles touch
+		return;
+	}
+
+	if ( other->client->ps.hyperSpaceTime && level.time - other->client->ps.hyperSpaceTime < HYPERSPACE_TIME )
+	{//already hyperspacing, just keep us moving
+		if ( (other->client->ps.eFlags2&EF2_HYPERSPACE) )
+		{//they've started the hyperspace but haven't been teleported yet
+			float timeFrac = ((float)(level.time-other->client->ps.hyperSpaceTime))/HYPERSPACE_TIME;
+			if ( timeFrac >= HYPERSPACE_TELEPORT_FRAC )
+			{//half-way, now teleport them!
+				vec3_t	diff, fwd, right, up, newOrg;
+				float	fDiff, rDiff, uDiff;
+				//take off the flag so we only do this once
+				other->client->ps.eFlags2 &= ~EF2_HYPERSPACE;
+				//Get the offset from the local position
+				ent = G_Find (NULL, FOFS(targetname), self->target);
+				if (!ent || !ent->inuse)
+				{ //this is bad
+					G_Error("trigger_hyperspace has invalid target '%s'\n", self->target);
+					return;
+				}
+				VectorSubtract( other->client->ps.origin, ent->s.origin, diff );
+				AngleVectors( ent->s.angles, fwd, right, up );
+				fDiff = DotProduct( fwd, diff );
+				rDiff = DotProduct( right, diff );
+				uDiff = DotProduct( up, diff );
+				//Now get the base position of the destination
+				ent = G_Find (NULL, FOFS(targetname), self->target2);
+				if (!ent || !ent->inuse)
+				{ //this is bad
+					G_Error("trigger_hyperspace has invalid target2 '%s'\n", self->target2);
+					return;
+				}
+				VectorCopy( ent->s.origin, newOrg );
+				//finally, add the offset into the new origin
+				AngleVectors( ent->s.angles, fwd, right, up );
+				VectorMA( newOrg, fDiff, fwd, newOrg );
+				VectorMA( newOrg, rDiff, right, newOrg );
+				VectorMA( newOrg, uDiff, up, newOrg );
+				//G_Printf("hyperspace from %s to %s\n", vtos(other->client->ps.origin), vtos(newOrg) );
+				//now put them in the offset position, facing the angles that position wants them to be facing
+				TeleportPlayer( other, newOrg, ent->s.angles );
+				if ( other->m_pVehicle && other->m_pVehicle->m_pPilot )
+				{//teleport the pilot, too
+					TeleportPlayer( (gentity_t*)other->m_pVehicle->m_pPilot, newOrg, ent->s.angles );
+					//FIXME: and the passengers?
+				}
+				//make them face the new angle
+				//other->client->ps.hyperSpaceIndex = ent->s.number;
+				VectorCopy( ent->s.angles, other->client->ps.hyperSpaceAngles );
+				//sound
+				G_Sound( other, CHAN_LOCAL, G_SoundIndex( "sound/vehicles/common/hyperend.wav" ) );
+			}
+		}
+		return;
+	}
+	else
+	{
+		ent = G_Find (NULL, FOFS(targetname), self->target);
+		if (!ent || !ent->inuse)
+		{ //this is bad
+			G_Error("trigger_hyperspace has invalid target '%s'\n", self->target);
+			return;
+		}
+
+		if (!other->client->ps.m_iVehicleNum || other->m_pVehicle->m_iRemovedSurfaces)
+		{ //if a vehicle touches a boundary without a pilot in it or with parts missing, just blow the thing up
+			G_Damage(other, other, other, NULL, other->client->ps.origin, 99999, DAMAGE_NO_PROTECTION, MOD_SUICIDE);
+			return;
+		}
+		//other->client->ps.hyperSpaceIndex = ent->s.number;
+		VectorCopy( ent->s.angles, other->client->ps.hyperSpaceAngles );
+		other->client->ps.hyperSpaceTime = level.time;
+	}
+}
+
+/*
+void trigger_hyperspace_find_targets( gentity_t *self )
+{
+	gentity_t *targEnt = NULL;
+	targEnt = G_Find (NULL, FOFS(targetname), self->target);
+	if (!targEnt || !targEnt->inuse)
+	{ //this is bad
+		G_Error("trigger_hyperspace has invalid target '%s'\n", self->target);
+		return;
+	}
+	targEnt->r.svFlags |= SVF_BROADCAST;//crap, need to tell the cgame about the target_position
+	targEnt = G_Find (NULL, FOFS(targetname), self->target2);
+	if (!targEnt || !targEnt->inuse)
+	{ //this is bad
+		G_Error("trigger_hyperspace has invalid target2 '%s'\n", self->target2);
+		return;
+	}
+	targEnt->r.svFlags |= SVF_BROADCAST;//crap, need to tell the cgame about the target_position
+}
+*/
+/*QUAKED trigger_hyperspace (.5 .5 .5) ? 
+Ship will turn to face the angles of the first target_position then fly forward, playing the hyperspace effect, then pop out at a relative point around the target
+
+"target"		whatever position the ship teleports from in relation to the target_position specified here, that's the relative position the ship will spawn at around the target2 target_position
+"target2"		name of target_position to teleport the ship to (will be relative to it's origin)
+*/
+void SP_trigger_hyperspace(gentity_t *self)
+{
+	//register the hyperspace end sound (start sounds are customized)
+	G_SoundIndex( "sound/vehicles/common/hyperend.wav" );
+
+	InitTrigger(self);
+	self->r.contents = CONTENTS_TRIGGER;
+	
+	if (!self->target || !self->target[0])
+	{
+		G_Error("trigger_hyperspace without a target.");
+	}
+	if (!self->target2 || !self->target2[0])
+	{
+		G_Error("trigger_hyperspace without a target2.");
+	}
+	
+	self->delay = Distance( self->r.absmax, self->r.absmin );//my size
+
+	self->touch = hyperspace_touch;
+
+    trap_LinkEntity(self);
+
+	//self->think = trigger_hyperspace_find_targets;
+	//self->nextthink = level.time + FRAMETIME;
+}
+/*
+==============================================================================
+
+timer
+
+==============================================================================
+*/
+
+
+/*QUAKED func_timer (0.3 0.1 0.6) (-8 -8 -8) (8 8 8) START_ON
+This should be renamed trigger_timer...
+Repeatedly fires its targets.
+Can be turned on or off by using.
+
+"wait"			base time between triggering all targets, default is 1
+"random"		wait variance, default is 0
+so, the basic time between firing is a random time between
+(wait - random) and (wait + random)
+
+*/
+void func_timer_think( gentity_t *self ) {
+	G_UseTargets (self, self->activator);
+	// set time before next firing
+	self->nextthink = level.time + 1000 * ( self->wait + crandom() * self->random );
+}
+
+void func_timer_use( gentity_t *self, gentity_t *other, gentity_t *activator ) {
+	self->activator = activator;
+
+	G_ActivateBehavior(self,BSET_USE);
+
+	// if on, turn it off
+	if ( self->nextthink ) {
+		self->nextthink = 0;
+		return;
+	}
+
+	// turn it on
+	func_timer_think (self);
+}
+
+void SP_func_timer( gentity_t *self ) {
+	G_SpawnFloat( "random", "1", &self->random);
+	G_SpawnFloat( "wait", "1", &self->wait );
+
+	self->use = func_timer_use;
+	self->think = func_timer_think;
+
+	if ( self->random >= self->wait ) {
+		self->random = self->wait - 1;//NOTE: was - FRAMETIME, but FRAMETIME is in msec (100) and these numbers are in *seconds*!
+		G_Printf( "func_timer at %s has random >= wait\n", vtos( self->s.origin ) );
+	}
+
+	if ( self->spawnflags & 1 ) {
+		self->nextthink = level.time + FRAMETIME;
+		self->activator = self;
+	}
+
+	self->r.svFlags = SVF_NOCLIENT;
+}
+
+
diff --git a/codemp/game/g_turret.c b/codemp/game/g_turret.c
new file mode 100644
index 0000000..8a30494
--- /dev/null
+++ b/codemp/game/g_turret.c
@@ -0,0 +1,849 @@
+// Copyright (C) 1999-2000 Id Software, Inc.
+//
+#include "g_local.h"
+#include "q_shared.h"
+
+void G_SetEnemy( gentity_t *self, gentity_t *enemy );
+qboolean turret_base_spawn_top( gentity_t *base );
+void ObjectDie (gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int meansOfDeath );
+
+//------------------------------------------------------------------------------------------------------------
+void TurretPain( gentity_t *self, gentity_t *attacker, int damage )
+//------------------------------------------------------------------------------------------------------------
+{
+	if (self->target_ent)
+	{
+		self->target_ent->health = self->health;
+		if (self->target_ent->maxHealth)
+		{
+			G_ScaleNetHealth(self->target_ent);
+		}
+	}
+
+	if ( attacker->client && attacker->client->ps.weapon == WP_DEMP2 )
+	{
+		self->attackDebounceTime = level.time + 800 + random() * 500;
+		self->painDebounceTime = self->attackDebounceTime;
+	}
+	if ( !self->enemy )
+	{//react to being hit
+		G_SetEnemy( self, attacker );
+	}
+}
+
+//------------------------------------------------------------------------------------------------------------
+void TurretBasePain( gentity_t *self, gentity_t *attacker, int damage )
+//------------------------------------------------------------------------------------------------------------
+{
+	if (self->target_ent)
+	{
+		self->target_ent->health = self->health;
+		if (self->target_ent->maxHealth)
+		{
+			G_ScaleNetHealth(self->target_ent);
+		}
+
+		TurretPain(self->target_ent, attacker, damage);
+	}
+}
+
+//------------------------------------------------------------------------------------------------------------
+void auto_turret_die ( gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int meansOfDeath )
+//------------------------------------------------------------------------------------------------------------
+{
+	vec3_t	forward = { 0,0, 1 }, pos;
+
+	// Turn off the thinking of the base & use it's targets
+	g_entities[self->r.ownerNum].think = NULL;
+	g_entities[self->r.ownerNum].use = NULL;
+
+	// clear my data
+	self->die = NULL;
+	self->takedamage = qfalse;
+	self->s.health = self->health = 0;
+	self->s.loopSound = 0;
+	self->s.shouldtarget = qfalse;
+	//self->s.owner = MAX_CLIENTS; //not owned by any client
+
+	VectorCopy( self->r.currentOrigin, pos );
+	pos[2] += self->r.maxs[2]*0.5f;
+	G_PlayEffect( EFFECT_EXPLOSION_TURRET, pos, forward );
+	G_PlayEffectID( G_EffectIndex( "turret/explode" ), pos, forward );
+	
+	if ( self->splashDamage > 0 && self->splashRadius > 0 )
+	{
+		G_RadiusDamage( self->r.currentOrigin, 
+						attacker, 
+						self->splashDamage, 
+						self->splashRadius, 
+						attacker,
+						NULL,
+						MOD_UNKNOWN );
+	}
+
+	self->s.weapon = 0; // crosshair code uses this to mark crosshair red
+
+
+	if ( self->s.modelindex2 )
+	{
+		// switch to damage model if we should
+		self->s.modelindex = self->s.modelindex2;
+
+		if (self->target_ent && self->target_ent->s.modelindex2)
+		{
+			self->target_ent->s.modelindex = self->target_ent->s.modelindex2;
+		}
+
+		VectorCopy( self->r.currentAngles, self->s.apos.trBase );
+		VectorClear( self->s.apos.trDelta );
+		
+		if ( self->target )
+		{
+			G_UseTargets( self, attacker );
+		}
+	}
+	else
+	{
+		ObjectDie( self, inflictor, attacker, damage, meansOfDeath );
+	}
+}
+
+//------------------------------------------------------------------------------------------------------------
+void bottom_die ( gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int meansOfDeath )
+//------------------------------------------------------------------------------------------------------------
+{
+	if (self->target_ent && self->target_ent->health > 0)
+	{
+		self->target_ent->health = self->health;
+		if (self->target_ent->maxHealth)
+		{
+			G_ScaleNetHealth(self->target_ent);
+		}
+		auto_turret_die(self->target_ent, inflictor, attacker, damage, meansOfDeath);
+	}
+}
+
+#define START_DIS 15
+
+//----------------------------------------------------------------
+static void turret_fire ( gentity_t *ent, vec3_t start, vec3_t dir )
+//----------------------------------------------------------------
+{
+	vec3_t		org;
+	gentity_t	*bolt;
+
+	if ( (trap_PointContents( start, ent->s.number )&MASK_SHOT) )
+	{
+		return;
+	}
+
+	VectorMA( start, -START_DIS, dir, org ); // dumb....
+	G_PlayEffectID( ent->genericValue13, org, dir );
+
+	bolt = G_Spawn();
+	
+	//use a custom shot effect
+	bolt->s.otherEntityNum2 = ent->genericValue14;
+	//use a custom impact effect
+	bolt->s.emplacedOwner = ent->genericValue15;
+
+	bolt->classname = "turret_proj";
+	bolt->nextthink = level.time + 10000;
+	bolt->think = G_FreeEntity;
+	bolt->s.eType = ET_MISSILE;
+	bolt->s.weapon = WP_EMPLACED_GUN;
+	bolt->r.ownerNum = ent->s.number;
+	bolt->damage = ent->damage;
+	bolt->alliedTeam = ent->alliedTeam;
+	bolt->teamnodmg = ent->teamnodmg;
+	//bolt->dflags = DAMAGE_NO_KNOCKBACK;// | DAMAGE_HEAVY_WEAP_CLASS;		// Don't push them around, or else we are constantly re-aiming
+	bolt->splashDamage = ent->damage;
+	bolt->splashRadius = 100;
+	bolt->methodOfDeath = MOD_TARGET_LASER;
+	bolt->clipmask = MASK_SHOT | CONTENTS_LIGHTSABER;
+	//bolt->trigger_formation = qfalse;		// don't draw tail on first frame	
+
+	VectorSet( bolt->r.maxs, 1.5, 1.5, 1.5 );
+	VectorScale( bolt->r.maxs, -1, bolt->r.mins );
+	bolt->s.pos.trType = TR_LINEAR;
+	bolt->s.pos.trTime = level.time;
+	VectorCopy( start, bolt->s.pos.trBase );
+	VectorScale( dir, ent->mass, bolt->s.pos.trDelta );
+	SnapVector( bolt->s.pos.trDelta );		// save net bandwidth
+	VectorCopy( start, bolt->r.currentOrigin);
+
+	bolt->parent = ent;
+}
+
+//-----------------------------------------------------
+void turret_head_think( gentity_t *self )
+//-----------------------------------------------------
+{
+	gentity_t *top = &g_entities[self->r.ownerNum];
+	if ( !top )
+	{
+		return;
+	}
+	if ( self->painDebounceTime > level.time )
+	{
+		vec3_t	v_up;
+		VectorSet( v_up, 0, 0, 1 );
+		G_PlayEffect( EFFECT_SPARKS, self->r.currentOrigin, v_up );
+		if ( Q_irand( 0, 3) )
+		{//25% chance of still firing
+			return;
+		}
+	}
+	// if it's time to fire and we have an enemy, then gun 'em down!  pushDebounce time controls next fire time
+	if ( self->enemy && self->setTime < level.time && self->attackDebounceTime < level.time )
+	{
+		vec3_t		fwd, org;
+		// set up our next fire time
+		self->setTime = level.time + self->wait;
+
+		/*
+		mdxaBone_t	boltMatrix;
+
+		// Getting the flash bolt here
+		gi.G2API_GetBoltMatrix( self->ghoul2, self->playerModel, 
+					self->torsoBolt,
+					&boltMatrix, self->r.currentAngles, self->r.currentOrigin, (cg.time?cg.time:level.time),
+					NULL, self->s.modelScale );
+
+		gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, org );
+		gi.G2API_GiveMeVectorFromMatrix( boltMatrix, POSITIVE_Y, fwd );
+		*/
+		VectorCopy( top->r.currentOrigin, org );
+		org[2] += top->r.maxs[2]-8;
+		AngleVectors( top->r.currentAngles, fwd, NULL, NULL );
+
+		VectorMA( org, START_DIS, fwd, org );
+
+		turret_fire( top, org, fwd );
+		self->fly_sound_debounce_time = level.time;//used as lastShotTime
+	}
+}
+
+//-----------------------------------------------------
+static void turret_aim( gentity_t *self )
+//-----------------------------------------------------
+{
+	vec3_t	enemyDir, org, org2;
+	vec3_t	desiredAngles, setAngle;
+	float	diffYaw = 0.0f, diffPitch = 0.0f, turnSpeed;
+	const float pitchCap = 40.0f;
+	gentity_t *top = &g_entities[self->r.ownerNum];
+	if ( !top )
+	{
+		return;
+	}
+
+	// move our gun base yaw to where we should be at this time....
+	BG_EvaluateTrajectory( &top->s.apos, level.time, top->r.currentAngles );
+	top->r.currentAngles[YAW] = AngleNormalize180( top->r.currentAngles[YAW] );
+	top->r.currentAngles[PITCH] = AngleNormalize180( top->r.currentAngles[PITCH] );
+	turnSpeed = top->speed;
+
+	if ( self->painDebounceTime > level.time )
+	{
+		desiredAngles[YAW] = top->r.currentAngles[YAW]+flrand(-45,45);
+		desiredAngles[PITCH] = top->r.currentAngles[PITCH]+flrand(-10,10);
+
+		if (desiredAngles[PITCH] < -pitchCap)
+		{
+			desiredAngles[PITCH] = -pitchCap;
+		}
+		else if (desiredAngles[PITCH] > pitchCap)
+		{
+			desiredAngles[PITCH] = pitchCap;
+		}
+
+		diffYaw = AngleSubtract( desiredAngles[YAW], top->r.currentAngles[YAW] );
+		diffPitch = AngleSubtract( desiredAngles[PITCH], top->r.currentAngles[PITCH] );
+		turnSpeed = flrand( -5, 5 );
+	}
+	else if ( self->enemy )
+	{
+		// ...then we'll calculate what new aim adjustments we should attempt to make this frame
+		// Aim at enemy
+		VectorCopy( self->enemy->r.currentOrigin, org );
+		org[2]+=self->enemy->r.maxs[2]*0.5f;
+		if (self->enemy->s.eType == ET_NPC &&
+			self->enemy->s.NPC_class == CLASS_VEHICLE &&
+			self->enemy->m_pVehicle &&
+			self->enemy->m_pVehicle->m_pVehicleInfo->type == VH_WALKER)
+		{ //hack!
+			org[2] += 32.0f;
+		}
+		/*
+		mdxaBone_t	boltMatrix;
+
+		// Getting the "eye" here
+		gi.G2API_GetBoltMatrix( self->ghoul2, self->playerModel, 
+					self->torsoBolt,
+					&boltMatrix, self->r.currentAngles, self->s.origin, (cg.time?cg.time:level.time),
+					NULL, self->s.modelScale );
+
+		gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, org2 );
+		*/
+		VectorCopy( top->r.currentOrigin, org2 );
+
+		VectorSubtract( org, org2, enemyDir );
+		vectoangles( enemyDir, desiredAngles );
+		desiredAngles[PITCH] = AngleNormalize180(desiredAngles[PITCH]);
+
+		if (desiredAngles[PITCH] < -pitchCap)
+		{
+			desiredAngles[PITCH] = -pitchCap;
+		}
+		else if (desiredAngles[PITCH] > pitchCap)
+		{
+			desiredAngles[PITCH] = pitchCap;
+		}
+
+		diffYaw = AngleSubtract( desiredAngles[YAW], top->r.currentAngles[YAW] );
+		diffPitch = AngleSubtract( desiredAngles[PITCH], top->r.currentAngles[PITCH] );
+	}
+	else
+	{//FIXME: Pan back and forth in original facing
+		// no enemy, so make us slowly sweep back and forth as if searching for a new one
+		desiredAngles[YAW] = sin( level.time * 0.0001f + top->count );
+		desiredAngles[YAW] *=  60.0f;
+		desiredAngles[YAW] += self->s.angles[YAW];
+		desiredAngles[YAW] = AngleNormalize180( desiredAngles[YAW] );
+		diffYaw = AngleSubtract( desiredAngles[YAW], top->r.currentAngles[YAW] );
+		diffPitch = AngleSubtract( 0, top->r.currentAngles[PITCH] );
+		turnSpeed = 1.0f;
+	}
+
+	if ( diffYaw )
+	{
+		// cap max speed....
+		if ( fabs(diffYaw) > turnSpeed )
+		{
+			diffYaw = ( diffYaw >= 0 ? turnSpeed : -turnSpeed );
+		}
+	}
+	if ( diffPitch )
+	{
+		if ( fabs(diffPitch) > turnSpeed )
+		{
+			// cap max speed
+			diffPitch = (diffPitch > 0.0f ? turnSpeed : -turnSpeed );
+		}
+	}
+	// ...then set up our desired yaw
+	VectorSet( setAngle, diffPitch, diffYaw, 0 );
+
+	VectorCopy( top->r.currentAngles, top->s.apos.trBase );
+	VectorScale( setAngle, (1000/FRAMETIME), top->s.apos.trDelta );
+	top->s.apos.trTime = level.time;
+	top->s.apos.trType = TR_LINEAR_STOP;
+	top->s.apos.trDuration = FRAMETIME;
+
+	if ( diffYaw || diffPitch )
+	{
+		top->s.loopSound = G_SoundIndex( "sound/vehicles/weapons/hoth_turret/turn.wav" );
+	}
+	else
+	{
+		top->s.loopSound = 0;
+	}
+}
+
+//-----------------------------------------------------
+static void turret_turnoff( gentity_t *self )
+//-----------------------------------------------------
+{
+	gentity_t *top = &g_entities[self->r.ownerNum];
+	if ( top != NULL )
+	{//still have a top
+		//stop it from rotating
+		VectorCopy( top->r.currentAngles, top->s.apos.trBase );
+		VectorClear( top->s.apos.trDelta );
+		top->s.apos.trTime = level.time;
+		top->s.apos.trType = TR_STATIONARY;
+	}
+
+	self->s.loopSound = 0;
+	// shut-down sound
+	//G_Sound( self, CHAN_BODY, G_SoundIndex( "sound/chars/turret/shutdown.wav" ));
+
+	// Clear enemy
+	self->enemy = NULL;
+}
+
+//-----------------------------------------------------
+static void turret_sleep( gentity_t *self )
+//-----------------------------------------------------
+{
+	if ( self->enemy == NULL )
+	{
+		// we don't need to play sound
+		return;
+	}
+
+	// make turret play ping sound for 5 seconds
+	self->aimDebounceTime = level.time + 5000;
+
+	// Clear enemy
+	self->enemy = NULL;
+}
+
+//-----------------------------------------------------
+static qboolean turret_find_enemies( gentity_t *self )
+//-----------------------------------------------------
+{
+	qboolean	found = qfalse;
+	int			i, count;
+	float		bestDist = self->radius * self->radius;
+	float		enemyDist;
+	vec3_t		enemyDir, org, org2;
+	gentity_t	*entity_list[MAX_GENTITIES], *target, *bestTarget = NULL;
+	trace_t		tr;
+	gentity_t *top = &g_entities[self->r.ownerNum];
+	if ( !top )
+	{
+		return qfalse;
+	}
+
+	if ( self->aimDebounceTime > level.time ) // time since we've been shut off
+	{
+		// We were active and alert, i.e. had an enemy in the last 3 secs
+		if ( self->timestamp < level.time )
+		{
+			//G_Sound(self, CHAN_BODY, G_SoundIndex( "sound/chars/turret/ping.wav" ));
+			self->timestamp = level.time + 1000;
+		}
+	}
+
+	VectorCopy( top->r.currentOrigin, org2 );
+
+	count = G_RadiusList( org2, self->radius, self, qtrue, entity_list );
+
+	for ( i = 0; i < count; i++ )
+	{
+		target = entity_list[i];
+
+		if ( !target->client )
+		{
+			// only attack clients
+			continue;
+		}
+		if ( target == self || !target->takedamage || target->health <= 0 || ( target->flags & FL_NOTARGET ))
+		{
+			continue;
+		}
+		if ( target->client->sess.sessionTeam == TEAM_SPECTATOR )
+		{
+			continue;
+		}
+		if ( self->alliedTeam )
+		{
+			if ( target->client )
+			{
+				if ( target->client->sess.sessionTeam == self->alliedTeam )
+				{ 
+					// A bot/client/NPC we don't want to shoot
+					continue;
+				}
+			}
+			else if ( target->teamnodmg == self->alliedTeam )
+			{ 
+				// An ent we don't want to shoot
+				continue;
+			}
+		}
+		if ( !trap_InPVS( org2, target->r.currentOrigin ))
+		{
+			continue;
+		}
+
+		VectorCopy( target->r.currentOrigin, org );
+		org[2] += target->r.maxs[2]*0.5f;
+
+		trap_Trace( &tr, org2, NULL, NULL, org, self->s.number, MASK_SHOT );
+
+		if ( !tr.allsolid && !tr.startsolid && ( tr.fraction == 1.0 || tr.entityNum == target->s.number ))
+		{
+			// Only acquire if have a clear shot, Is it in range and closer than our best?
+			VectorSubtract( target->r.currentOrigin, top->r.currentOrigin, enemyDir );
+			enemyDist = VectorLengthSquared( enemyDir );
+
+			if ( enemyDist < bestDist // all things equal, keep current
+				|| (!Q_stricmp( "atst_vehicle", target->NPC_type ) && bestTarget && Q_stricmp( "atst_vehicle", bestTarget->NPC_type ) ) )//target AT-STs over non-AT-STs... FIXME: must be a better, easier way to tell this, no?
+			{
+				if ( self->attackDebounceTime < level.time )
+				{
+					// We haven't fired or acquired an enemy in the last 2 seconds-start-up sound
+					//G_Sound( self, CHAN_BODY, G_SoundIndex( "sound/chars/turret/startup.wav" ));
+
+					// Wind up turrets for a bit
+					self->attackDebounceTime = level.time + 1400;
+				}
+
+				bestTarget = target;
+				bestDist = enemyDist;
+				found = qtrue;
+			}
+		}
+	}
+
+	if ( found )
+	{
+		G_SetEnemy( self, bestTarget );
+		if ( VALIDSTRING( self->target2 ))
+		{
+			G_UseTargets2( self, self, self->target2 );
+		}
+	}
+
+	return found;
+}
+
+//-----------------------------------------------------
+void turret_base_think( gentity_t *self )
+//-----------------------------------------------------
+{
+	qboolean	turnOff = qtrue;
+	float		enemyDist;
+	vec3_t		enemyDir, org, org2;
+
+	if ( self->spawnflags & 1 )
+	{
+		// not turned on
+		turret_turnoff( self );
+
+		// No target
+		self->flags |= FL_NOTARGET;
+		self->nextthink = -1;//never think again
+		return;
+	}
+	else
+	{
+		// I'm all hot and bothered
+		self->flags &= ~FL_NOTARGET;
+		//remember to keep thinking!
+		self->nextthink = level.time + FRAMETIME;
+	}
+
+	if ( !self->enemy )
+	{
+		if ( turret_find_enemies( self ))
+		{
+			turnOff = qfalse;
+		}
+	}
+	else if ( self->enemy->client && self->enemy->client->sess.sessionTeam == TEAM_SPECTATOR )
+	{//don't keep going after spectators
+		self->enemy = NULL;
+	}
+	else
+	{//FIXME: remain single-minded or look for a new enemy every now and then?
+		if ( self->enemy->health > 0 )
+		{
+			// enemy is alive
+			VectorSubtract( self->enemy->r.currentOrigin, self->r.currentOrigin, enemyDir );
+			enemyDist = VectorLengthSquared( enemyDir );
+
+			if ( enemyDist < (self->radius * self->radius) )
+			{
+				// was in valid radius
+				if ( trap_InPVS( self->r.currentOrigin, self->enemy->r.currentOrigin ) )
+				{
+					// Every now and again, check to see if we can even trace to the enemy
+					trace_t tr;
+
+					if ( self->enemy->client )
+					{
+						VectorCopy( self->enemy->client->renderInfo.eyePoint, org );
+					}
+					else
+					{
+						VectorCopy( self->enemy->r.currentOrigin, org );
+					}
+					VectorCopy( self->r.currentOrigin, org2 );
+					if ( self->spawnflags & 2 )
+					{
+						org2[2] += 10;
+					}
+					else
+					{
+						org2[2] -= 10;
+					}
+					trap_Trace( &tr, org2, NULL, NULL, org, self->s.number, MASK_SHOT );
+
+					if ( !tr.allsolid && !tr.startsolid && tr.entityNum == self->enemy->s.number )
+					{
+						turnOff = qfalse;	// Can see our enemy
+					}
+				}
+			}
+		}
+
+		turret_head_think( self );
+	}
+
+	if ( turnOff )
+	{
+		if ( self->bounceCount < level.time ) // bounceCount is used to keep the thing from ping-ponging from on to off
+		{
+			turret_sleep( self );
+		}
+	}
+	else
+	{
+		// keep our enemy for a minimum of 2 seconds from now
+		self->bounceCount = level.time + 2000 + random() * 150;
+	}
+
+	turret_aim( self );
+}
+
+//-----------------------------------------------------------------------------
+void turret_base_use( gentity_t *self, gentity_t *other, gentity_t *activator )
+//-----------------------------------------------------------------------------
+{
+	// Toggle on and off
+	self->spawnflags = (self->spawnflags ^ 1);
+
+	/*
+	if (( self->s.eFlags & EF_SHADER_ANIM ) && ( self->spawnflags & 1 )) // Start_Off
+	{
+		self->s.frame = 1; // black
+	}
+	else
+	{
+		self->s.frame = 0; // glow
+	}
+	*/
+}
+
+
+/*QUAKED misc_turret (1 0 0) (-48 -48 0) (48 48 144) START_OFF
+Large 2-piece turbolaser turret
+
+  START_OFF - Starts off
+
+  radius - How far away an enemy can be for it to pick it up (default 1024)
+  wait	- Time between shots (default 300 ms)
+  dmg	- How much damage each shot does (default 100)
+  health - How much damage it can take before exploding (default 3000)
+  speed - how fast it turns (default 10)
+  
+  splashDamage - How much damage the explosion does (300)
+  splashRadius - The radius of the explosion (128)
+
+  shotspeed - speed at which projectiles will move
+  
+  targetname - Toggles it on/off
+  target - What to use when destroyed
+  target2 - What to use when it decides to start shooting at an enemy
+
+  showhealth - set to 1 to show health bar on this entity when crosshair is over it
+  
+  teamowner - crosshair shows green for this team, red for opposite team
+	0 - none
+	1 - red
+	2 - blue
+
+  alliedTeam - team that this turret won't target
+	0 - none
+	1 - red
+	2 - blue
+
+  teamnodmg - team that turret does not take damage from
+	0 - none
+	1 - red
+	2 - blue
+*/
+//-----------------------------------------------------
+void SP_misc_turret( gentity_t *base )
+//-----------------------------------------------------
+{
+	base->s.modelindex2 = G_ModelIndex( "models/map_objects/hoth/turret_bottom.md3" );
+	base->s.modelindex = G_ModelIndex( "models/map_objects/hoth/turret_base.md3" );
+	//base->playerModel = gi.G2API_InitGhoul2Model( base->ghoul2, "models/map_objects/imp_mine/turret_canon.glm", base->s.modelindex );
+	//base->s.radius = 80.0f;
+
+	//gi.G2API_SetBoneAngles( &base->ghoul2[base->playerModel], "Bone_body", vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_Y, POSITIVE_Z, POSITIVE_X, NULL ); 
+	//base->torsoBolt = gi.G2API_AddBolt( &base->ghoul2[base->playerModel], "*flash03" );
+
+	G_SetAngles( base, base->s.angles );
+	G_SetOrigin( base, base->s.origin );
+
+	base->r.contents = CONTENTS_BODY;
+
+	VectorSet( base->r.maxs, 32.0f, 32.0f, 128.0f );
+	VectorSet( base->r.mins, -32.0f, -32.0f, 0.0f );
+
+	base->use = turret_base_use;
+	base->think = turret_base_think;
+	// don't start working right away
+	base->nextthink = level.time + FRAMETIME * 5;
+
+	trap_LinkEntity( base );
+
+	if ( !turret_base_spawn_top( base ) )
+	{
+		G_FreeEntity( base );
+	}
+}
+
+//-----------------------------------------------------
+qboolean turret_base_spawn_top( gentity_t *base )
+{
+	vec3_t		org;
+	int			t;
+
+	gentity_t *top = G_Spawn();
+	if ( !top )
+	{
+		return qfalse;
+	}
+
+	top->s.modelindex = G_ModelIndex( "models/map_objects/hoth/turret_top_new.md3" );
+	top->s.modelindex2 = G_ModelIndex( "models/map_objects/hoth/turret_top.md3" );
+	G_SetAngles( top, base->s.angles );
+	VectorCopy( base->s.origin, org );
+	org[2] += 128;
+	G_SetOrigin( top, org );
+
+	base->r.ownerNum = top->s.number;
+	top->r.ownerNum = base->s.number;
+
+	if ( base->team && base->team[0] && //g_gametype.integer == GT_SIEGE &&
+		!base->teamnodmg)
+	{
+		base->teamnodmg = atoi(base->team);
+	}
+	base->team = NULL;
+	top->teamnodmg = base->teamnodmg;
+	top->alliedTeam = base->alliedTeam;
+
+	base->s.eType = ET_GENERAL;
+
+	// Set up our explosion effect for the ExplodeDeath code....
+	G_EffectIndex( "turret/explode" );
+	G_EffectIndex( "sparks/spark_exp_nosnd" );
+	G_EffectIndex( "turret/hoth_muzzle_flash" );
+
+	// this is really the pitch angle.....
+	top->speed = 0;
+
+	// this is a random time offset for the no-enemy-search-around-mode
+	top->count = random() * 9000;
+
+	if ( !base->health )
+	{
+		base->health = 3000;
+	}
+	top->health = base->health;
+
+	G_SpawnInt( "showhealth", "0", &t );
+
+	if (t)
+	{ //a non-0 maxhealth value will mean we want to show the health on the hud
+		top->maxHealth = base->health; //acts as "maxhealth"
+		G_ScaleNetHealth(top);
+
+		base->maxHealth = base->health;
+		G_ScaleNetHealth(base);
+	}
+
+	base->takedamage = qtrue;
+	base->pain = TurretBasePain;
+	base->die = bottom_die;
+
+	//design specified shot speed
+	G_SpawnFloat( "shotspeed", "1100", &base->mass );
+	top->mass = base->mass;
+
+	//even if we don't want to show health, let's at least light the crosshair up properly over ourself
+	if ( !top->s.teamowner )
+	{
+		top->s.teamowner = top->alliedTeam;
+	}
+
+	base->alliedTeam = top->alliedTeam;
+	base->s.teamowner = top->s.teamowner;
+
+	base->s.shouldtarget = qtrue;
+	top->s.shouldtarget = qtrue;
+
+	//link them to each other
+	base->target_ent = top;
+	top->target_ent = base;
+
+	//top->s.owner = MAX_CLIENTS; //not owned by any client
+
+	// search radius
+	if ( !base->radius )
+	{
+		base->radius = 1024;
+	}
+	top->radius = base->radius;
+
+	// How quickly to fire
+	if ( !base->wait )
+	{
+		base->wait = 300 + random() * 55;
+	}
+	top->wait = base->wait;
+
+	if ( !base->splashDamage )
+	{
+		base->splashDamage = 300;
+	}
+	top->splashDamage = base->splashDamage;
+
+	if ( !base->splashRadius )
+	{
+		base->splashRadius = 128;
+	}
+	top->splashRadius = base->splashRadius;
+
+	// how much damage each shot does
+	if ( !base->damage )
+	{
+		base->damage = 100;
+	}
+	top->damage = base->damage;
+
+	// how fast it turns
+	if ( !base->speed )
+	{
+		base->speed = 20;
+	}
+	top->speed = base->speed;
+
+	VectorSet( top->r.maxs, 48.0f, 48.0f, 16.0f );
+	VectorSet( top->r.mins, -48.0f, -48.0f, 0.0f );
+	// Precache moving sounds
+	//G_SoundIndex( "sound/chars/turret/startup.wav" );
+	//G_SoundIndex( "sound/chars/turret/shutdown.wav" );
+	//G_SoundIndex( "sound/chars/turret/ping.wav" );
+	G_SoundIndex( "sound/vehicles/weapons/hoth_turret/turn.wav" );
+	top->genericValue13 = G_EffectIndex( "turret/hoth_muzzle_flash" );
+	top->genericValue14 = G_EffectIndex( "turret/hoth_shot" );
+	top->genericValue15 = G_EffectIndex( "turret/hoth_impact" );
+
+	top->r.contents = CONTENTS_BODY;
+
+	//base->max_health = base->health;
+	top->takedamage = qtrue;
+	top->pain = TurretPain;
+	top->die  = auto_turret_die;
+
+	top->material = MAT_METAL;
+	//base->r.svFlags |= SVF_NO_TELEPORT|SVF_NONNPC_ENEMY|SVF_SELF_ANIMATING;
+
+	// Register this so that we can use it for the missile effect
+	RegisterItem( BG_FindItemForWeapon( WP_EMPLACED_GUN ));
+
+	// But set us as a turret so that we can be identified as a turret
+	top->s.weapon = WP_EMPLACED_GUN;
+
+	trap_LinkEntity( top );
+	return qtrue;
+}
diff --git a/codemp/game/g_turret_G2.c b/codemp/game/g_turret_G2.c
new file mode 100644
index 0000000..afe6573
--- /dev/null
+++ b/codemp/game/g_turret_G2.c
@@ -0,0 +1,1277 @@
+#include "g_local.h"
+#include "../ghoul2/G2.h"
+#include "q_shared.h"
+
+void G_SetEnemy( gentity_t *self, gentity_t *enemy );
+void finish_spawning_turretG2( gentity_t *base );
+void ObjectDie (gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int meansOfDeath );
+void turretG2_base_use( gentity_t *self, gentity_t *other, gentity_t *activator );
+
+
+#define SPF_TURRETG2_CANRESPAWN	4
+#define SPF_TURRETG2_TURBO		8
+#define SPF_TURRETG2_LEAD_ENEMY	16
+#define SPF_SHOWONRADAR			32
+
+#define	ARM_ANGLE_RANGE		60
+#define	HEAD_ANGLE_RANGE	90
+
+#define name "models/map_objects/imp_mine/turret_canon.glm"
+#define name2 "models/map_objects/imp_mine/turret_damage.md3"
+#define name3 "models/map_objects/wedge/laser_cannon_model.glm"
+
+//special routine for tracking angles between client and server -rww
+void G2Tur_SetBoneAngles(gentity_t *ent, char *bone, vec3_t angles)
+{
+#ifdef _XBOX
+	byte *thebone = &ent->s.boneIndex1;
+	byte *firstFree = NULL;
+#else
+	int *thebone = &ent->s.boneIndex1;
+	int *firstFree = NULL;
+#endif
+	int i = 0;
+	int boneIndex = G_BoneIndex(bone);
+	int flags, up, right, forward;
+	vec3_t *boneVector = &ent->s.boneAngles1;
+	vec3_t *freeBoneVec = NULL;
+
+	while (thebone)
+	{
+		if (!*thebone && !firstFree)
+		{ //if the value is 0 then this index is clear, we can use it if we don't find the bone we want already existing.
+			firstFree = thebone;
+			freeBoneVec = boneVector;
+		}
+		else if (*thebone)
+		{
+			if (*thebone == boneIndex)
+			{ //this is it
+				break;
+			}
+		}
+
+		switch (i)
+		{
+		case 0:
+			thebone = &ent->s.boneIndex2;
+			boneVector = &ent->s.boneAngles2;
+			break;
+		case 1:
+			thebone = &ent->s.boneIndex3;
+			boneVector = &ent->s.boneAngles3;
+			break;
+		case 2:
+			thebone = &ent->s.boneIndex4;
+			boneVector = &ent->s.boneAngles4;
+			break;
+		default:
+			thebone = NULL;
+			boneVector = NULL;
+			break;
+		}
+
+		i++;
+	}
+
+	if (!thebone)
+	{ //didn't find it, create it
+		if (!firstFree)
+		{ //no free bones.. can't do a thing then.
+			Com_Printf("WARNING: NPC has no free bone indexes\n");
+			return;
+		}
+
+		thebone = firstFree;
+
+		*thebone = boneIndex;
+		boneVector = freeBoneVec;
+	}
+
+	//If we got here then we have a vector and an index.
+
+	//Copy the angles over the vector in the entitystate, so we can use the corresponding index
+	//to set the bone angles on the client.
+	VectorCopy(angles, *boneVector);
+
+	//Now set the angles on our server instance if we have one.
+
+	if (!ent->ghoul2)
+	{
+		return;
+	}
+
+	flags = BONE_ANGLES_POSTMULT;
+	up = POSITIVE_Y;
+	right = NEGATIVE_Z;
+	forward = NEGATIVE_X;
+
+	//first 3 bits is forward, second 3 bits is right, third 3 bits is up
+	ent->s.boneOrient = ((forward)|(right<<3)|(up<<6));
+
+	trap_G2API_SetBoneAngles( ent->ghoul2,
+					0,
+					bone,
+					angles, 
+					flags,
+					up,
+					right,
+					forward,
+					NULL,
+					100,
+					level.time ); 
+}
+
+void turretG2_set_models( gentity_t *self, qboolean dying )
+{
+	if ( dying )
+	{
+		if ( !(self->spawnflags&SPF_TURRETG2_TURBO) )
+		{
+			self->s.modelindex = G_ModelIndex( name2 );
+			self->s.modelindex2 = G_ModelIndex( name );
+		}
+		
+		trap_G2API_RemoveGhoul2Model( &self->ghoul2, 0 );
+		G_KillG2Queue( self->s.number );
+		self->s.modelGhoul2 = 0;
+		/*
+		trap_G2API_InitGhoul2Model( &self->ghoul2,
+									name2,
+									0, //base->s.modelindex,
+									//note, this is not the same kind of index - this one's referring to the actual
+									//index of the model in the g2 instance, whereas modelindex is the index of a
+									//configstring -rww
+									0,
+									0,
+									0,
+									0);
+		*/
+	}
+	else
+	{
+		if ( !(self->spawnflags&SPF_TURRETG2_TURBO) )
+		{
+			self->s.modelindex = G_ModelIndex( name );
+			self->s.modelindex2 = G_ModelIndex( name2 );
+			//set the new onw
+			trap_G2API_InitGhoul2Model( &self->ghoul2,
+										name,
+										0, //base->s.modelindex,
+										//note, this is not the same kind of index - this one's referring to the actual
+										//index of the model in the g2 instance, whereas modelindex is the index of a
+										//configstring -rww
+										0,
+										0,
+										0,
+										0);
+		}
+		else
+		{
+			self->s.modelindex = G_ModelIndex( name3 );
+			//set the new onw
+			trap_G2API_InitGhoul2Model( &self->ghoul2,
+										name3,
+										0, //base->s.modelindex,
+										//note, this is not the same kind of index - this one's referring to the actual
+										//index of the model in the g2 instance, whereas modelindex is the index of a
+										//configstring -rww
+										0,
+										0,
+										0,
+										0);
+		}
+		
+		self->s.modelGhoul2 = 1;
+		if ( (self->spawnflags&SPF_TURRETG2_TURBO) )
+		{//larger
+			self->s.g2radius = 128;
+		}
+		else
+		{
+			self->s.g2radius = 80;
+		}
+
+		if ( (self->spawnflags&SPF_TURRETG2_TURBO) )
+		{//different pitch bone and muzzle flash points
+			G2Tur_SetBoneAngles(self, "pitch", vec3_origin);
+			self->genericValue11 = trap_G2API_AddBolt( self->ghoul2, 0, "*muzzle1" );
+			self->genericValue12 = trap_G2API_AddBolt( self->ghoul2, 0, "*muzzle2" );
+		}
+		else
+		{
+			G2Tur_SetBoneAngles(self, "Bone_body", vec3_origin);
+			self->genericValue11 = trap_G2API_AddBolt( self->ghoul2, 0, "*flash03" );
+		}
+	}
+}
+
+//------------------------------------------------------------------------------------------------------------
+void TurretG2Pain( gentity_t *self, gentity_t *attacker, int damage )
+//------------------------------------------------------------------------------------------------------------
+{
+	if (self->paintarget && self->paintarget[0])
+	{
+		if (self->genericValue8 < level.time)
+		{
+			G_UseTargets2(self, self, self->paintarget);
+			self->genericValue8 = level.time + self->genericValue4;
+		}
+	}
+
+	if ( attacker->client && attacker->client->ps.weapon == WP_DEMP2 )
+	{
+		self->attackDebounceTime = level.time + 2000 + random() * 500;
+		self->painDebounceTime = self->attackDebounceTime;
+	}
+	if ( !self->enemy )
+	{//react to being hit
+		G_SetEnemy( self, attacker );
+	}
+	//self->s.health = self->health;
+	//mmm..yes..bad.
+}
+
+//------------------------------------------------------------------------------------------------------------
+void turretG2_die ( gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int meansOfDeath )
+//------------------------------------------------------------------------------------------------------------
+{
+	vec3_t	forward = { 0,0,-1 }, pos;
+
+	// Turn off the thinking of the base & use it's targets
+	//self->think = NULL;
+	self->use = NULL;
+
+	// clear my data
+	self->die  = NULL;
+	self->pain = NULL;
+	self->takedamage = qfalse;
+	self->s.health = self->health = 0;
+	self->s.loopSound = 0;
+	self->s.shouldtarget = qfalse;
+	//self->s.owner = MAX_CLIENTS; //not owned by any client
+
+	// hack the effect angle so that explode death can orient the effect properly
+	if ( self->spawnflags & 2 )
+	{
+		VectorSet( forward, 0, 0, 1 );
+	}
+
+//	VectorCopy( self->r.currentOrigin, self->s.pos.trBase );
+
+	VectorMA( self->r.currentOrigin, 12, forward, pos );
+	G_PlayEffect( EFFECT_EXPLOSION_TURRET, pos, forward );
+	
+	if ( self->splashDamage > 0 && self->splashRadius > 0 )
+	{
+		G_RadiusDamage( self->r.currentOrigin,
+						attacker,
+						self->splashDamage,
+						self->splashRadius,
+						attacker,
+						NULL,
+						MOD_UNKNOWN );
+	}
+
+	if ( self->s.eFlags & EF_SHADER_ANIM )
+	{
+		self->s.frame = 1; // black
+	}
+
+	self->s.weapon = 0; // crosshair code uses this to mark crosshair red
+
+	if ( self->s.modelindex2 )
+	{
+		// switch to damage model if we should
+		turretG2_set_models( self, qtrue );
+
+		VectorCopy( self->r.currentAngles, self->s.apos.trBase );
+		VectorClear( self->s.apos.trDelta );
+		
+		if ( self->target )
+		{
+			G_UseTargets( self, attacker );
+		}
+		
+		if (self->spawnflags & SPF_TURRETG2_CANRESPAWN)
+		{//respawn
+			if (self->health < 1 && !self->genericValue5)
+			{ //we are dead, set our respawn delay if we have one
+				self->genericValue5 = level.time + self->count;
+			}
+		}
+	}
+	else
+	{
+		ObjectDie( self, inflictor, attacker, damage, meansOfDeath );
+	}
+}
+
+#define START_DIS 15
+
+//start an animation on model_root both server side and client side
+void TurboLaser_SetBoneAnim(gentity_t *eweb, int startFrame, int endFrame)
+{
+	//set info on the entity so it knows to start the anim on the client next snapshot.
+	eweb->s.eFlags |= EF_G2ANIMATING;
+
+	if (eweb->s.torsoAnim == startFrame && eweb->s.legsAnim == endFrame)
+	{ //already playing this anim, let's flag it to restart
+		eweb->s.torsoFlip = !eweb->s.torsoFlip;
+	}
+	else
+	{
+		eweb->s.torsoAnim = startFrame;
+		eweb->s.legsAnim = endFrame;
+	}
+
+	//now set the animation on the server ghoul2 instance.
+	assert(eweb->ghoul2);
+	trap_G2API_SetBoneAnim(eweb->ghoul2, 0, "model_root", startFrame, endFrame,
+		(BONE_ANIM_OVERRIDE_FREEZE|BONE_ANIM_BLEND), 1.0f, level.time, -1, 100);
+}
+
+extern void WP_FireTurboLaserMissile( gentity_t *ent, vec3_t start, vec3_t dir );
+//----------------------------------------------------------------
+static void turretG2_fire ( gentity_t *ent, vec3_t start, vec3_t dir )
+//----------------------------------------------------------------
+{
+	vec3_t		org, ang;
+	gentity_t	*bolt;
+
+	if ( (trap_PointContents( start, ent->s.number )&MASK_SHOT) )
+	{
+		return;
+	}
+
+	VectorMA( start, -START_DIS, dir, org ); // dumb....
+
+	if ( ent->random )
+	{
+		vectoangles( dir, ang );
+		ang[PITCH] += flrand( -ent->random, ent->random );
+		ang[YAW] += flrand( -ent->random, ent->random );
+		AngleVectors( ang, dir, NULL, NULL );
+	}
+
+	vectoangles(dir, ang);
+
+	if ( (ent->spawnflags&SPF_TURRETG2_TURBO) )
+	{
+		//muzzle flash
+		G_PlayEffectID( ent->genericValue13, org, ang );
+		WP_FireTurboLaserMissile( ent, start, dir );
+		if ( ent->alt_fire )
+		{
+			TurboLaser_SetBoneAnim( ent, 2, 3 );
+		}
+		else
+		{
+			TurboLaser_SetBoneAnim( ent, 0, 1 );
+		}
+	}
+	else
+	{
+		G_PlayEffectID( G_EffectIndex("blaster/muzzle_flash"), org, ang );
+		bolt = G_Spawn();
+		
+		bolt->classname = "turret_proj";
+		bolt->nextthink = level.time + 10000;
+		bolt->think = G_FreeEntity;
+		bolt->s.eType = ET_MISSILE;
+		bolt->s.weapon = WP_BLASTER;
+		bolt->r.ownerNum = ent->s.number;
+		bolt->damage = ent->damage;
+		bolt->alliedTeam = ent->alliedTeam;
+		bolt->teamnodmg = ent->teamnodmg;
+		bolt->dflags = (DAMAGE_NO_KNOCKBACK|DAMAGE_HEAVY_WEAP_CLASS);		// Don't push them around, or else we are constantly re-aiming
+		bolt->splashDamage = ent->splashDamage;
+		bolt->splashRadius = ent->splashDamage;
+		bolt->methodOfDeath = MOD_TARGET_LASER;//MOD_ENERGY;
+		bolt->splashMethodOfDeath = MOD_TARGET_LASER;//MOD_ENERGY;
+		bolt->clipmask = MASK_SHOT | CONTENTS_LIGHTSABER;
+		//bolt->trigger_formation = qfalse;		// don't draw tail on first frame	
+
+		VectorSet( bolt->r.maxs, 1.5, 1.5, 1.5 );
+		VectorScale( bolt->r.maxs, -1, bolt->r.mins );
+		bolt->s.pos.trType = TR_LINEAR;
+		bolt->s.pos.trTime = level.time;
+		VectorCopy( start, bolt->s.pos.trBase );
+		VectorScale( dir, ent->mass, bolt->s.pos.trDelta );
+		SnapVector( bolt->s.pos.trDelta );		// save net bandwidth
+		VectorCopy( start, bolt->r.currentOrigin);
+	}
+}
+
+void turretG2_respawn( gentity_t *self )
+{
+	self->use = turretG2_base_use;
+	self->pain = TurretG2Pain;
+	self->die  = turretG2_die;
+	self->takedamage = qtrue;
+	self->s.shouldtarget = qtrue;
+	//self->s.owner = MAX_CLIENTS; //not owned by any client
+	if ( self->s.eFlags & EF_SHADER_ANIM )
+	{
+		self->s.frame = 0; // normal
+	}
+	self->s.weapon = WP_TURRET; // crosshair code uses this to mark crosshair red
+
+	turretG2_set_models( self, qfalse );
+	self->s.health = self->health = self->genericValue6;
+	if (self->maxHealth) {
+		G_ScaleNetHealth(self);
+	}
+	self->genericValue5 = 0;//clear this now
+}
+
+//-----------------------------------------------------
+void turretG2_head_think( gentity_t *self )
+//-----------------------------------------------------
+{
+	// if it's time to fire and we have an enemy, then gun 'em down!  pushDebounce time controls next fire time
+	if ( self->enemy 
+		&& self->setTime < level.time 
+		&& self->attackDebounceTime < level.time )
+	{
+		vec3_t		fwd, org;
+		mdxaBone_t	boltMatrix;
+
+		// set up our next fire time
+		self->setTime = level.time + self->wait;
+
+		// Getting the flash bolt here
+		trap_G2API_GetBoltMatrix( self->ghoul2,
+					0, 
+					(self->alt_fire?self->genericValue12:self->genericValue11),
+					&boltMatrix, 
+					self->r.currentAngles, 
+					self->r.currentOrigin, 
+					level.time,
+					NULL, 
+					self->modelScale );
+		if ( (self->spawnflags&SPF_TURRETG2_TURBO) )
+		{
+			self->alt_fire = !self->alt_fire;
+		}
+
+		BG_GiveMeVectorFromMatrix( &boltMatrix, ORIGIN, org );
+		//BG_GiveMeVectorFromMatrix( &boltMatrix, POSITIVE_Y, fwd );
+		if ( (self->spawnflags&SPF_TURRETG2_TURBO) )
+		{
+			BG_GiveMeVectorFromMatrix( &boltMatrix, POSITIVE_X, fwd );
+		}
+		else
+		{
+			BG_GiveMeVectorFromMatrix( &boltMatrix, NEGATIVE_X, fwd );
+		}
+
+		VectorMA( org, START_DIS, fwd, org );
+
+		turretG2_fire( self, org, fwd );
+		self->fly_sound_debounce_time = level.time;//used as lastShotTime
+	}
+}
+
+//-----------------------------------------------------
+static void turretG2_aim( gentity_t *self )
+//-----------------------------------------------------
+{
+	vec3_t	enemyDir, org, org2;
+	vec3_t	desiredAngles, setAngle;
+	float	diffYaw = 0.0f, diffPitch = 0.0f;
+	float	maxYawSpeed = (self->spawnflags&SPF_TURRETG2_TURBO)?30.0f:14.0f;
+	float	maxPitchSpeed = (self->spawnflags&SPF_TURRETG2_TURBO)?15.0f:3.0f;
+
+	// move our gun base yaw to where we should be at this time....
+	BG_EvaluateTrajectory( &self->s.apos, level.time, self->r.currentAngles );
+	self->r.currentAngles[YAW] = AngleNormalize360( self->r.currentAngles[YAW] );
+	self->speed = AngleNormalize360( self->speed );
+
+	if ( self->enemy )
+	{
+		mdxaBone_t	boltMatrix;
+		// ...then we'll calculate what new aim adjustments we should attempt to make this frame
+		// Aim at enemy
+		if ( self->enemy->client )
+		{
+			VectorCopy( self->enemy->client->renderInfo.eyePoint, org );
+		}
+		else
+		{
+			VectorCopy( self->enemy->r.currentOrigin, org );
+		}
+		if ( self->spawnflags & 2 )
+		{
+			org[2] -= 15;
+		}
+		else
+		{
+			org[2] -= 5;
+		}
+
+		if ( (self->spawnflags&SPF_TURRETG2_LEAD_ENEMY) )
+		{//we want to lead them a bit
+			vec3_t diff, velocity;
+			float dist;
+			VectorSubtract( org, self->s.origin, diff );
+			dist = VectorNormalize( diff );
+			if ( self->enemy->client )
+			{
+				VectorCopy( self->enemy->client->ps.velocity, velocity );
+			}
+			else
+			{
+				VectorCopy( self->enemy->s.pos.trDelta, velocity );
+			}
+			VectorMA( org, (dist/self->mass), velocity, org );
+		}
+
+		// Getting the "eye" here
+		trap_G2API_GetBoltMatrix( self->ghoul2,
+					0, 
+					(self->alt_fire?self->genericValue12:self->genericValue11),
+					&boltMatrix,
+					self->r.currentAngles,
+					self->s.origin,
+					level.time,
+					NULL,
+					self->modelScale );
+
+		BG_GiveMeVectorFromMatrix( &boltMatrix, ORIGIN, org2 );
+
+		VectorSubtract( org, org2, enemyDir );
+		vectoangles( enemyDir, desiredAngles );
+
+		diffYaw = AngleSubtract( self->r.currentAngles[YAW], desiredAngles[YAW] );
+		diffPitch = AngleSubtract( self->speed, desiredAngles[PITCH] );
+	}
+	else
+	{
+		// no enemy, so make us slowly sweep back and forth as if searching for a new one
+//		diffYaw = sin( level.time * 0.0001f + self->count ) * 5.0f;	// don't do this for now since it can make it go into walls.
+	}
+
+	if ( diffYaw )
+	{
+		// cap max speed....
+		if ( fabs(diffYaw) > maxYawSpeed )
+		{
+			diffYaw = ( diffYaw >= 0 ? maxYawSpeed : -maxYawSpeed );
+		}
+
+		// ...then set up our desired yaw
+		VectorSet( setAngle, 0.0f, diffYaw, 0.0f );
+
+		VectorCopy( self->r.currentAngles, self->s.apos.trBase );
+		VectorScale( setAngle,- 5, self->s.apos.trDelta );
+		self->s.apos.trTime = level.time;
+		self->s.apos.trType = TR_LINEAR;
+	}
+
+	if ( diffPitch )
+	{
+		if ( fabs(diffPitch) > maxPitchSpeed )
+		{
+			// cap max speed
+			self->speed += (diffPitch > 0.0f) ? -maxPitchSpeed : maxPitchSpeed;
+		}
+		else
+		{
+			// small enough, so just add half the diff so we smooth out the stopping
+			self->speed -= ( diffPitch );//desiredAngles[PITCH];
+		}
+
+		// Note that this is NOT interpolated, so it will be less smooth...On the other hand, it does use Ghoul2 to blend, so it may smooth it out a bit?
+		if ( (self->spawnflags&SPF_TURRETG2_TURBO) )
+		{
+			if ( self->spawnflags & 2 )
+			{
+				VectorSet( desiredAngles, 0.0f, 0.0f, -self->speed );
+			}
+			else
+			{
+				VectorSet( desiredAngles, 0.0f, 0.0f, self->speed );
+			}
+			G2Tur_SetBoneAngles(self, "pitch", desiredAngles);
+		}
+		else
+		{
+			if ( self->spawnflags & 2 )
+			{
+				VectorSet( desiredAngles, self->speed, 0.0f, 0.0f );
+			}
+			else
+			{
+				VectorSet( desiredAngles, -self->speed, 0.0f, 0.0f );
+			}
+			G2Tur_SetBoneAngles(self, "Bone_body", desiredAngles);
+		}
+		/*
+		trap_G2API_SetBoneAngles( self->ghoul2,
+						0,
+						"Bone_body",
+						desiredAngles, 
+						BONE_ANGLES_POSTMULT,
+						POSITIVE_Y,
+						POSITIVE_Z,
+						POSITIVE_X,
+						NULL,
+						100,
+						level.time ); 
+						*/
+	}
+
+	if ( diffYaw || diffPitch )
+	{//FIXME: turbolaser sounds
+		if ( (self->spawnflags&SPF_TURRETG2_TURBO) )
+		{
+			self->s.loopSound = G_SoundIndex( "sound/vehicles/weapons/turbolaser/turn.wav" );
+		}
+		else
+		{
+			self->s.loopSound = G_SoundIndex( "sound/chars/turret/move.wav" );
+		}
+	}
+	else
+	{
+		self->s.loopSound = 0;
+	}
+}
+
+//-----------------------------------------------------
+static void turretG2_turnoff( gentity_t *self )
+//-----------------------------------------------------
+{
+	if ( self->enemy == NULL )
+	{
+		// we don't need to turnoff
+		return;
+	}
+	if ( (self->spawnflags&SPF_TURRETG2_TURBO) )
+	{
+		TurboLaser_SetBoneAnim( self, 4, 5 );
+	}
+	// shut-down sound
+	if ( !(self->spawnflags&SPF_TURRETG2_TURBO) )
+	{
+		G_Sound( self, CHAN_BODY, G_SoundIndex( "sound/chars/turret/shutdown.wav" ));
+	}
+	
+	// make turret play ping sound for 5 seconds
+	self->aimDebounceTime = level.time + 5000;
+
+	// Clear enemy
+	self->enemy = NULL;
+}
+
+//-----------------------------------------------------
+static qboolean turretG2_find_enemies( gentity_t *self )
+//-----------------------------------------------------
+{
+	qboolean	found = qfalse;
+	int			i, count;
+	float		bestDist = self->radius * self->radius;
+	float		enemyDist;
+	vec3_t		enemyDir, org, org2;
+	qboolean	foundClient = qfalse;
+	gentity_t	*entity_list[MAX_GENTITIES], *target, *bestTarget = NULL;
+
+	if ( self->aimDebounceTime > level.time ) // time since we've been shut off
+	{
+		// We were active and alert, i.e. had an enemy in the last 3 secs
+		if ( self->painDebounceTime < level.time )
+		{
+			if ( !(self->spawnflags&SPF_TURRETG2_TURBO) )
+			{
+				G_Sound(self, CHAN_BODY, G_SoundIndex( "sound/chars/turret/ping.wav" ));
+			}
+			self->painDebounceTime = level.time + 1000;
+		}
+	}
+
+	VectorCopy( self->r.currentOrigin, org2 );
+	if ( self->spawnflags & 2 )
+	{
+		org2[2] += 20;
+	}
+	else
+	{
+		org2[2] -= 20;
+	}
+
+	count = G_RadiusList( org2, self->radius, self, qtrue, entity_list );
+
+	for ( i = 0; i < count; i++ )
+	{
+		trace_t	tr;
+		target = entity_list[i];
+
+		if ( !target->client )
+		{
+			// only attack clients
+			if ( !(target->flags&FL_BBRUSH)//not a breakable brush
+				|| !target->takedamage//is a bbrush, but invincible
+				|| (target->NPC_targetname&&self->targetname&&Q_stricmp(target->NPC_targetname,self->targetname)!=0) )//not in invicible bbrush, but can only be broken by an NPC that is not me
+			{
+				continue;
+			}
+			//else: we will shoot at bbrushes!
+		}
+		if ( target == self || !target->takedamage || target->health <= 0 || ( target->flags & FL_NOTARGET ))
+		{
+			continue;
+		}
+		if ( target->client && target->client->sess.sessionTeam == TEAM_SPECTATOR )
+		{
+			continue;
+		}
+		if ( self->alliedTeam )
+		{
+			if ( target->client )
+			{
+				if ( target->client->sess.sessionTeam == self->alliedTeam )
+				{ 
+					// A bot/client/NPC we don't want to shoot
+					continue;
+				}
+			}
+			else if ( target->teamnodmg == self->alliedTeam )
+			{ 
+				// An ent we don't want to shoot
+				continue;
+			}
+		}
+		if ( !trap_InPVS( org2, target->r.currentOrigin ))
+		{
+			continue;
+		}
+
+		if ( target->client )
+		{
+			VectorCopy( target->client->renderInfo.eyePoint, org );
+		}
+		else
+		{
+			VectorCopy( target->r.currentOrigin, org );
+		}
+
+		if ( self->spawnflags & 2 )
+		{
+			org[2] -= 15;
+		}
+		else
+		{
+			org[2] += 5;
+		}
+
+		trap_Trace( &tr, org2, NULL, NULL, org, self->s.number, MASK_SHOT );
+
+		if ( !tr.allsolid && !tr.startsolid && ( tr.fraction == 1.0 || tr.entityNum == target->s.number ))
+		{
+			// Only acquire if have a clear shot, Is it in range and closer than our best?
+			VectorSubtract( target->r.currentOrigin, self->r.currentOrigin, enemyDir );
+			enemyDist = VectorLengthSquared( enemyDir );
+
+			if ( enemyDist < bestDist || (target->client && !foundClient))// all things equal, keep current
+			{
+				if ( self->attackDebounceTime < level.time )
+				{
+					// We haven't fired or acquired an enemy in the last 2 seconds-start-up sound
+					if ( !(self->spawnflags&SPF_TURRETG2_TURBO) )
+					{
+						G_Sound( self, CHAN_BODY, G_SoundIndex( "sound/chars/turret/startup.wav" ));
+					}
+
+					// Wind up turrets for a bit
+					self->attackDebounceTime = level.time + 1400;
+				}
+
+				bestTarget = target;
+				bestDist = enemyDist;
+				found = qtrue;
+				if ( target->client )
+				{//prefer clients over non-clients
+					foundClient = qtrue;
+				}
+			}
+		}
+	}
+
+	if ( found )
+	{
+		/*
+		if ( !self->enemy )
+		{//just aquired one
+			AddSoundEvent( bestTarget, self->r.currentOrigin, 256, AEL_DISCOVERED );
+			AddSightEvent( bestTarget, self->r.currentOrigin, 512, AEL_DISCOVERED, 20 );
+		}
+		*/
+		G_SetEnemy( self, bestTarget );
+		if ( VALIDSTRING( self->target2 ))
+		{
+			G_UseTargets2( self, self, self->target2 );
+		}
+	}
+
+	return found;
+}
+
+//-----------------------------------------------------
+void turretG2_base_think( gentity_t *self )
+//-----------------------------------------------------
+{
+	qboolean	turnOff = qtrue;
+	float		enemyDist;
+	vec3_t		enemyDir, org, org2;
+
+	self->nextthink = level.time + FRAMETIME;
+
+	if ( self->health <= 0 )
+	{//dead
+		if (self->spawnflags & SPF_TURRETG2_CANRESPAWN)
+		{//can respawn
+			if ( self->genericValue5 && self->genericValue5 < level.time )
+			{ //we are dead, see if it's time to respawn
+				turretG2_respawn( self );
+			}
+		}
+		return;
+	}
+	else if ( self->spawnflags & 1 )
+	{// not turned on
+		turretG2_turnoff( self );
+		turretG2_aim( self );
+
+		// No target
+		self->flags |= FL_NOTARGET;
+		return;
+	}
+	else
+	{
+		// I'm all hot and bothered
+		self->flags &= ~FL_NOTARGET;
+	}
+
+	if ( self->enemy )
+	{
+		if ( self->enemy->health < 0 
+			|| !self->enemy->inuse )
+		{
+			self->enemy = NULL;
+		}
+	}
+
+	if ( self->last_move_time < level.time )
+	{//MISNOMER: used a enemy recalcing debouncer
+		if ( turretG2_find_enemies( self ) )
+		{//found one
+			turnOff = qfalse;
+			if ( self->enemy->client )
+			{//hold on to clients for a min of 3 seconds
+				self->last_move_time = level.time + 3000;
+			}
+			else
+			{//hold less
+				self->last_move_time = level.time + 500;
+			}
+		}
+	}
+
+	if ( self->enemy != NULL )
+	{
+		if ( self->enemy->client && self->enemy->client->sess.sessionTeam == TEAM_SPECTATOR )
+		{//don't keep going after spectators
+			self->enemy = NULL;
+		}
+		else
+		{//FIXME: remain single-minded or look for a new enemy every now and then?
+			// enemy is alive
+			VectorSubtract( self->enemy->r.currentOrigin, self->r.currentOrigin, enemyDir );
+			enemyDist = VectorLengthSquared( enemyDir );
+
+			if ( enemyDist < self->radius * self->radius )
+			{
+				// was in valid radius
+				if ( trap_InPVS( self->r.currentOrigin, self->enemy->r.currentOrigin ) )
+				{
+					// Every now and again, check to see if we can even trace to the enemy
+					trace_t tr;
+
+					if ( self->enemy->client )
+					{
+						VectorCopy( self->enemy->client->renderInfo.eyePoint, org );
+					}
+					else
+					{
+						VectorCopy( self->enemy->r.currentOrigin, org );
+					}
+					VectorCopy( self->r.currentOrigin, org2 );
+					if ( self->spawnflags & 2 )
+					{
+						org2[2] += 10;
+					}
+					else
+					{
+						org2[2] -= 10;
+					}
+					trap_Trace( &tr, org2, NULL, NULL, org, self->s.number, MASK_SHOT );
+
+					if ( !tr.allsolid && !tr.startsolid && tr.entityNum == self->enemy->s.number )
+					{
+						turnOff = qfalse;	// Can see our enemy
+					}
+				}
+			}
+
+		}
+	}
+
+	if ( turnOff )
+	{
+		if ( self->bounceCount < level.time ) // bounceCount is used to keep the thing from ping-ponging from on to off
+		{
+			turretG2_turnoff( self );
+		}
+	}
+	else
+	{
+		// keep our enemy for a minimum of 2 seconds from now
+		self->bounceCount = level.time + 2000 + random() * 150;
+	}
+
+	turretG2_aim( self );
+	if ( !turnOff )
+	{
+		turretG2_head_think( self );
+	}
+}
+
+//-----------------------------------------------------------------------------
+void turretG2_base_use( gentity_t *self, gentity_t *other, gentity_t *activator )
+//-----------------------------------------------------------------------------
+{
+	// Toggle on and off
+	self->spawnflags = (self->spawnflags ^ 1);
+
+	if (( self->s.eFlags & EF_SHADER_ANIM ) && ( self->spawnflags & 1 )) // Start_Off
+	{
+		self->s.frame = 1; // black
+	}
+	else
+	{
+		self->s.frame = 0; // glow
+	}
+}
+
+
+/*QUAKED misc_turretG2 (1 0 0) (-8 -8 -22) (8 8 0) START_OFF UPSIDE_DOWN CANRESPAWN TURBO LEAD SHOWRADAR
+
+Turret that hangs from the ceiling, will aim and shoot at enemies
+
+  START_OFF - Starts off
+  UPSIDE_DOWN - make it rest on a surface/floor instead of hanging from the ceiling
+  CANRESPAWN - will respawn after being killed (use count)
+  TURBO - Big-ass, Boxy Death Star Turbo Laser version
+  LEAD - Turret will aim ahead of moving targets ("lead" them)
+  SHOWRADAR - show on radar
+
+  radius - How far away an enemy can be for it to pick it up (default 512)
+  wait	- Time between shots (default 150 ms)
+  dmg	- How much damage each shot does (default 5)
+  health - How much damage it can take before exploding (default 100)
+  count - if CANRESPAWN spawnflag, decides how long it is before gun respawns (in ms) - defaults to 20000 (20 seconds)
+
+  paintarget - target to fire off upon being hurt
+  painwait - ms to wait between firing off pain targets
+
+  random - random error (in degrees) of projectile direction when it comes out of the muzzle (default is 2)
+
+  shotspeed - the speed of the missile it fires travels at (default is 1100 for regular turrets, 20000 for TURBOLASERS)
+
+  splashDamage - How much damage the explosion does
+  splashRadius - The radius of the explosion
+  
+  targetname - Toggles it on/off
+  target - What to use when destroyed
+  target2 - What to use when it decides to start shooting at an enemy
+
+  showhealth - set to 1 to show health bar on this entity when crosshair is over it
+  
+  teamowner - crosshair shows green for this team, red for opposite team
+	0 - none
+	1 - red
+	2 - blue
+
+  alliedTeam - team that this turret won't target
+	0 - none
+	1 - red
+	2 - blue
+
+  teamnodmg - team that turret does not take damage from
+	0 - none
+	1 - red
+	2 - blue
+
+  customscale - custom scaling size. 100 is normal size, 1024 is the max scaling. this will change the bounding box size, so be careful of starting in solid!
+*/
+//-----------------------------------------------------
+void SP_misc_turretG2( gentity_t *base )
+//-----------------------------------------------------
+{
+	int customscaleVal;
+	turretG2_set_models( base, qfalse );
+
+	G_SpawnInt("painwait", "0", &base->genericValue4);
+	base->genericValue8 = 0;
+
+	G_SpawnInt("customscale", "0", &customscaleVal);
+	base->s.iModelScale = customscaleVal;
+	if (base->s.iModelScale)
+	{
+		if (base->s.iModelScale > 1023)
+		{
+			base->s.iModelScale = 1023;
+		}
+		base->modelScale[0] = base->modelScale[1] = base->modelScale[2] = base->s.iModelScale/100.0f;
+	}
+
+	finish_spawning_turretG2( base );
+
+	if (( base->spawnflags & 1 )) // Start_Off
+	{
+		base->s.frame = 1; // black
+	}
+	else
+	{
+		base->s.frame = 0; // glow
+	}
+	if ( !(base->spawnflags&SPF_TURRETG2_TURBO) )
+	{
+		base->s.eFlags |= EF_SHADER_ANIM;
+	}
+
+	if (base->spawnflags & SPF_SHOWONRADAR)
+	{
+		base->s.eFlags |= EF_RADAROBJECT;
+	}
+#undef name
+#undef name2
+#undef name3
+}
+
+//-----------------------------------------------------
+void finish_spawning_turretG2( gentity_t *base )
+{
+	vec3_t		fwd;
+	int			t;
+
+	if ( (base->spawnflags&2) )
+	{
+		base->s.angles[ROLL] += 180;
+		base->s.origin[2] -= 22.0f;
+	}
+
+	G_SetAngles( base, base->s.angles );
+	AngleVectors( base->r.currentAngles, fwd, NULL, NULL );
+
+	G_SetOrigin(base, base->s.origin);
+
+	base->s.eType = ET_GENERAL;
+
+	if ( base->team && base->team[0] && //g_gametype.integer == GT_SIEGE &&
+		!base->teamnodmg)
+	{
+		base->teamnodmg = atoi(base->team);
+	}
+	base->team = NULL;
+
+	// Set up our explosion effect for the ExplodeDeath code....
+	G_EffectIndex( "turret/explode" );
+	G_EffectIndex( "sparks/spark_exp_nosnd" );
+
+	base->use = turretG2_base_use;
+	base->pain = TurretG2Pain;
+
+	// don't start working right away
+	base->think = turretG2_base_think;
+	base->nextthink = level.time + FRAMETIME * 5;
+
+	// this is really the pitch angle.....
+	base->speed = 0;
+
+	// respawn time defaults to 20 seconds
+	if ( (base->spawnflags&SPF_TURRETG2_CANRESPAWN) && !base->count )
+	{
+		base->count = 20000;
+	}
+
+	G_SpawnFloat( "shotspeed", "0", &base->mass );
+	if ( (base->spawnflags&SPF_TURRETG2_TURBO) )
+	{
+		if ( !base->random )
+		{//error worked into projectile direction
+			base->random = 2.0f;
+		}
+
+		if ( !base->mass )
+		{//misnomer: speed of projectile
+			base->mass = 20000;
+		}
+
+		if ( !base->health )
+		{
+			base->health = 2000;
+		}
+
+		// search radius
+		if ( !base->radius )
+		{
+			base->radius = 32768;
+		}
+
+		// How quickly to fire
+		if ( !base->wait )
+		{
+			base->wait = 1000;// + random() * 500;
+		}
+
+		if ( !base->splashDamage )
+		{
+			base->splashDamage = 200;
+		}
+
+		if ( !base->splashRadius )
+		{
+			base->splashRadius = 500;
+		}
+
+		// how much damage each shot does
+		if ( !base->damage )
+		{
+			base->damage = 500;
+		}
+
+		if ( (base->spawnflags&SPF_TURRETG2_TURBO) )
+		{
+			VectorSet( base->r.maxs, 64.0f, 64.0f, 30.0f );
+			VectorSet( base->r.mins, -64.0f, -64.0f, -30.0f );
+		}
+		//start in "off" anim
+		TurboLaser_SetBoneAnim( base, 4, 5 );
+		if ( g_gametype.integer == GT_SIEGE )
+		{//FIXME: designer-specified?
+			//FIXME: put on other entities, too, particularly siege objectives and bbrushes...
+			base->s.eFlags2 |= EF2_BRACKET_ENTITY;
+		}
+	}
+	else
+	{
+		if ( !base->random )
+		{//error worked into projectile direction
+			base->random = 2.0f;
+		}
+
+		if ( !base->mass )
+		{//misnomer: speed of projectile
+			base->mass = 1100;
+		}
+
+		if ( !base->health )
+		{
+			base->health = 100;
+		}
+
+		// search radius
+		if ( !base->radius )
+		{
+			base->radius = 512;
+		}
+
+		// How quickly to fire
+		if ( !base->wait )
+		{
+			base->wait = 150 + random() * 55;
+		}
+
+		if ( !base->splashDamage )
+		{
+			base->splashDamage = 10;
+		}
+
+		if ( !base->splashRadius )
+		{
+			base->splashRadius = 25;
+		}
+
+		// how much damage each shot does
+		if ( !base->damage )
+		{
+			base->damage = 5;
+		}
+
+		if ( base->spawnflags & 2 )
+		{//upside-down, invert r.mins and maxe
+			VectorSet( base->r.maxs, 10.0f, 10.0f, 30.0f );
+			VectorSet( base->r.mins, -10.0f, -10.0f, 0.0f );
+		}
+		else
+		{
+			VectorSet( base->r.maxs, 10.0f, 10.0f, 0.0f );
+			VectorSet( base->r.mins, -10.0f, -10.0f, -30.0f );
+		}
+	}
+
+	//stash health off for respawn.  NOTE: cannot use maxhealth because that might not be set if not showing the health bar
+	base->genericValue6 = base->health;
+
+	G_SpawnInt( "showhealth", "0", &t );
+	if (t)
+	{ //a non-0 maxhealth value will mean we want to show the health on the hud
+		base->maxHealth = base->health;
+		G_ScaleNetHealth(base);
+		base->s.shouldtarget = qtrue;
+		//base->s.owner = MAX_CLIENTS; //not owned by any client
+	}
+
+	if (base->s.iModelScale)
+	{ //let's scale the bbox too...
+		float fScale = base->s.iModelScale/100.0f;
+		VectorScale(base->r.mins, fScale, base->r.mins);
+		VectorScale(base->r.maxs, fScale, base->r.maxs);
+	}
+
+	// Precache special FX and moving sounds
+	if ( (base->spawnflags&SPF_TURRETG2_TURBO) )
+	{
+		base->genericValue13 = G_EffectIndex( "turret/turb_muzzle_flash" );
+		base->genericValue14 = G_EffectIndex( "turret/turb_shot" );
+		base->genericValue15 = G_EffectIndex( "turret/turb_impact" );
+		//FIXME: Turbo Laser Cannon sounds!
+		G_SoundIndex( "sound/vehicles/weapons/turbolaser/turn.wav" );
+	}
+	else
+	{
+		G_SoundIndex( "sound/chars/turret/startup.wav" );
+		G_SoundIndex( "sound/chars/turret/shutdown.wav" );
+		G_SoundIndex( "sound/chars/turret/ping.wav" );
+		G_SoundIndex( "sound/chars/turret/move.wav" );
+	}
+
+	base->r.contents = CONTENTS_BODY|CONTENTS_PLAYERCLIP|CONTENTS_MONSTERCLIP|CONTENTS_SHOTCLIP;
+
+	//base->max_health = base->health;
+	base->takedamage = qtrue;
+	base->die  = turretG2_die;
+
+	base->material = MAT_METAL;
+	//base->r.svFlags |= SVF_NO_TELEPORT|SVF_NONNPC_ENEMY|SVF_SELF_ANIMATING;
+
+	// Register this so that we can use it for the missile effect
+	RegisterItem( BG_FindItemForWeapon( WP_BLASTER ));
+
+	// But set us as a turret so that we can be identified as a turret
+	base->s.weapon = WP_TURRET;
+
+	trap_LinkEntity( base );
+}
diff --git a/codemp/game/g_utils.c b/codemp/game/g_utils.c
new file mode 100644
index 0000000..ca84b3a
--- /dev/null
+++ b/codemp/game/g_utils.c
@@ -0,0 +1,2311 @@
+// Copyright (C) 1999-2000 Id Software, Inc.
+//
+// g_utils.c -- misc utility functions for game module
+
+#include "g_local.h"
+#include "bg_saga.h"
+#include "q_shared.h"
+
+typedef struct {
+  char oldShader[MAX_QPATH];
+  char newShader[MAX_QPATH];
+  float timeOffset;
+} shaderRemap_t;
+
+#define MAX_SHADER_REMAPS 128
+
+int remapCount = 0;
+shaderRemap_t remappedShaders[MAX_SHADER_REMAPS];
+
+void AddRemap(const char *oldShader, const char *newShader, float timeOffset) {
+	int i;
+
+	for (i = 0; i < remapCount; i++) {
+		if (Q_stricmp(oldShader, remappedShaders[i].oldShader) == 0) {
+			// found it, just update this one
+			strcpy(remappedShaders[i].newShader,newShader);
+			remappedShaders[i].timeOffset = timeOffset;
+			return;
+		}
+	}
+	if (remapCount < MAX_SHADER_REMAPS) {
+		strcpy(remappedShaders[remapCount].newShader,newShader);
+		strcpy(remappedShaders[remapCount].oldShader,oldShader);
+		remappedShaders[remapCount].timeOffset = timeOffset;
+		remapCount++;
+	}
+}
+
+const char *BuildShaderStateConfig(void) {
+	static char	buff[MAX_STRING_CHARS*4];
+	char out[(MAX_QPATH * 2) + 5];
+	int i;
+  
+	memset(buff, 0, MAX_STRING_CHARS);
+	for (i = 0; i < remapCount; i++) {
+		Com_sprintf(out, (MAX_QPATH * 2) + 5, "%s=%s:%5.2f@", remappedShaders[i].oldShader, remappedShaders[i].newShader, remappedShaders[i].timeOffset);
+		Q_strcat( buff, sizeof( buff ), out);
+	}
+	return buff;
+}
+
+/*
+=========================================================================
+
+model / sound configstring indexes
+
+=========================================================================
+*/
+
+/*
+================
+G_FindConfigstringIndex
+
+================
+*/
+static int G_FindConfigstringIndex( const char *name, int start, int max, qboolean create ) {
+	int		i;
+	char	s[MAX_STRING_CHARS];
+
+	if ( !name || !name[0] ) {
+		return 0;
+	}
+
+	for ( i=1 ; i<max ; i++ ) {
+		trap_GetConfigstring( start + i, s, sizeof( s ) );
+		if ( !s[0] ) {
+			break;
+		}
+		if ( !strcmp( s, name ) ) {
+			return i;
+		}
+	}
+
+	if ( !create ) {
+		return 0;
+	}
+
+	if ( i == max ) {
+		G_Error( "G_FindConfigstringIndex: overflow" );
+	}
+
+	trap_SetConfigstring( start + i, name );
+
+	return i;
+}
+
+/*
+Ghoul2 Insert Start
+*/
+
+int G_BoneIndex( const char *name ) {
+	return G_FindConfigstringIndex (name, CS_G2BONES, MAX_G2BONES, qtrue);
+}
+/*
+Ghoul2 Insert End
+*/
+
+int G_ModelIndex( const char *name ) {
+#ifdef _DEBUG_MODEL_PATH_ON_SERVER
+	//debug to see if we are shoving data into configstrings for models that don't exist, and if
+	//so, where we are doing it from -rww
+	fileHandle_t fh;
+
+	trap_FS_FOpenFile(name, &fh, FS_READ);
+	if (!fh)
+	{ //try models/ then, this is assumed for registering models
+		trap_FS_FOpenFile(va("models/%s", name), &fh, FS_READ);
+		if (!fh)
+		{
+			Com_Printf("ERROR: Server tried to modelindex %s but it doesn't exist.\n", name);
+		}
+	}
+
+	if (fh)
+	{
+		trap_FS_FCloseFile(fh);
+	}
+#endif
+	return G_FindConfigstringIndex (name, CS_MODELS, MAX_MODELS, qtrue);
+}
+
+int	G_IconIndex( const char* name ) 
+{
+	assert(name && name[0]);
+	return G_FindConfigstringIndex (name, CS_ICONS, MAX_ICONS, qtrue);
+}
+
+int G_SoundIndex( const char *name ) {
+	assert(name && name[0]);
+	return G_FindConfigstringIndex (name, CS_SOUNDS, MAX_SOUNDS, qtrue);
+}
+
+int G_SoundSetIndex(const char *name)
+{
+	return G_FindConfigstringIndex (name, CS_AMBIENT_SET, MAX_AMBIENT_SETS, qtrue);
+}
+
+int G_EffectIndex( const char *name )
+{
+	return G_FindConfigstringIndex (name, CS_EFFECTS, MAX_FX, qtrue);
+}
+
+int G_BSPIndex( const char *name )
+{
+	return G_FindConfigstringIndex (name, CS_BSP_MODELS, MAX_SUB_BSP, qtrue);
+}
+
+//=====================================================================
+
+
+//see if we can or should allow this guy to use a custom skeleton -rww
+qboolean G_PlayerHasCustomSkeleton(gentity_t *ent)
+{
+	/*
+	siegeClass_t *scl;
+
+	if (g_gametype.integer != GT_SIEGE)
+	{ //only in siege
+		return qfalse;
+	}
+
+	if (ent->s.number >= MAX_CLIENTS ||
+		!ent->client ||
+		ent->client->siegeClass == -1)
+	{ //invalid class
+		return qfalse;
+	}
+
+	scl = &bgSiegeClasses[ent->client->siegeClass];
+	if (!(scl->classflags & (1<<CFL_CUSTOMSKEL)))
+	{ //class is not flagged for this
+		return qfalse;
+	}
+
+	return qtrue;
+	*/
+	return qfalse;
+}
+
+/*
+================
+G_TeamCommand
+
+Broadcasts a command to only a specific team
+================
+*/
+void G_TeamCommand( team_t team, char *cmd ) {
+	int		i;
+
+	for ( i = 0 ; i < level.maxclients ; i++ ) {
+		if ( level.clients[i].pers.connected == CON_CONNECTED ) {
+			if ( level.clients[i].sess.sessionTeam == team ) {
+				trap_SendServerCommand( i, va("%s", cmd ));
+			}
+		}
+	}
+}
+
+
+/*
+=============
+G_Find
+
+Searches all active entities for the next one that holds
+the matching string at fieldofs (use the FOFS() macro) in the structure.
+
+Searches beginning at the entity after from, or the beginning if NULL
+NULL will be returned if the end of the list is reached.
+
+=============
+*/
+gentity_t *G_Find (gentity_t *from, int fieldofs, const char *match)
+{
+	char	*s;
+
+	if (!from)
+		from = g_entities;
+	else
+		from++;
+
+	for ( ; from < &g_entities[level.num_entities] ; from++)
+	{
+		if (!from->inuse)
+			continue;
+		s = *(char **) ((byte *)from + fieldofs);
+		if (!s)
+			continue;
+		if (!Q_stricmp (s, match))
+			return from;
+	}
+
+	return NULL;
+}
+
+
+
+/*
+============
+G_RadiusList - given an origin and a radius, return all entities that are in use that are within the list
+============
+*/
+int G_RadiusList ( vec3_t origin, float radius,	gentity_t *ignore, qboolean takeDamage, gentity_t *ent_list[MAX_GENTITIES])					  
+{
+	float		dist;
+	gentity_t	*ent;
+	int			entityList[MAX_GENTITIES];
+	int			numListedEntities;
+	vec3_t		mins, maxs;
+	vec3_t		v;
+	int			i, e;
+	int			ent_count = 0;
+
+	if ( radius < 1 ) 
+	{
+		radius = 1;
+	}
+
+	for ( i = 0 ; i < 3 ; i++ ) 
+	{
+		mins[i] = origin[i] - radius;
+		maxs[i] = origin[i] + radius;
+	}
+
+	numListedEntities = trap_EntitiesInBox( mins, maxs, entityList, MAX_GENTITIES );
+
+	for ( e = 0 ; e < numListedEntities ; e++ ) 
+	{
+		ent = &g_entities[entityList[ e ]];
+
+		if ((ent == ignore) || !(ent->inuse) || ent->takedamage != takeDamage)
+			continue;
+
+		// find the distance from the edge of the bounding box
+		for ( i = 0 ; i < 3 ; i++ ) 
+		{
+			if ( origin[i] < ent->r.absmin[i] ) 
+			{
+				v[i] = ent->r.absmin[i] - origin[i];
+			} else if ( origin[i] > ent->r.absmax[i] ) 
+			{
+				v[i] = origin[i] - ent->r.absmax[i];
+			} else 
+			{
+				v[i] = 0;
+			}
+		}
+
+		dist = VectorLength( v );
+		if ( dist >= radius ) 
+		{
+			continue;
+		}
+		
+		// ok, we are within the radius, add us to the incoming list
+		ent_list[ent_count] = ent;
+		ent_count++;
+
+	}
+	// we are done, return how many we found
+	return(ent_count);
+}
+
+
+//----------------------------------------------------------
+void G_Throw( gentity_t *targ, vec3_t newDir, float push )
+//----------------------------------------------------------
+{
+	vec3_t	kvel;
+	float	mass;
+
+	if ( targ->physicsBounce > 0 )	//overide the mass
+	{
+		mass = targ->physicsBounce;
+	}
+	else
+	{
+		mass = 200;
+	}
+
+	if ( g_gravity.value > 0 )
+	{
+		VectorScale( newDir, g_knockback.value * (float)push / mass * 0.8, kvel );
+		kvel[2] = newDir[2] * g_knockback.value * (float)push / mass * 1.5;
+	}
+	else
+	{
+		VectorScale( newDir, g_knockback.value * (float)push / mass, kvel );
+	}
+
+	if ( targ->client )
+	{
+		VectorAdd( targ->client->ps.velocity, kvel, targ->client->ps.velocity );
+	}
+	else if ( targ->s.pos.trType != TR_STATIONARY && targ->s.pos.trType != TR_LINEAR_STOP && targ->s.pos.trType != TR_NONLINEAR_STOP )
+	{
+		VectorAdd( targ->s.pos.trDelta, kvel, targ->s.pos.trDelta );
+		VectorCopy( targ->r.currentOrigin, targ->s.pos.trBase );
+		targ->s.pos.trTime = level.time;
+	}
+
+	// set the timer so that the other client can't cancel
+	// out the movement immediately
+	if ( targ->client && !targ->client->ps.pm_time ) 
+	{
+		int		t;
+
+		t = push * 2;
+
+		if ( t < 50 ) 
+		{
+			t = 50;
+		}
+		if ( t > 200 ) 
+		{
+			t = 200;
+		}
+		targ->client->ps.pm_time = t;
+		targ->client->ps.pm_flags |= PMF_TIME_KNOCKBACK;
+	}
+}
+
+//methods of creating/freeing "fake" dynamically allocated client entity structures.
+//You ABSOLUTELY MUST free this client after creating it before game shutdown. If
+//it is left around you will have a memory leak, because true dynamic memory is
+//allocated by the exe.
+void G_FreeFakeClient(gclient_t **cl)
+{ //or not, the dynamic stuff is busted somehow at the moment. Yet it still works in the test.
+  //I think something is messed up in being able to cast the memory to stuff to modify it,
+  //while modifying it directly seems to work fine.
+	//trap_TrueFree((void **)cl);
+}
+
+//allocate a veh object
+#define MAX_VEHICLES_AT_A_TIME		128
+static Vehicle_t g_vehiclePool[MAX_VEHICLES_AT_A_TIME];
+static qboolean g_vehiclePoolOccupied[MAX_VEHICLES_AT_A_TIME];
+static qboolean g_vehiclePoolInit = qfalse;
+void G_AllocateVehicleObject(Vehicle_t **pVeh)
+{
+	int i = 0;
+
+	if (!g_vehiclePoolInit)
+	{
+		g_vehiclePoolInit = qtrue;
+		memset(g_vehiclePoolOccupied, 0, sizeof(g_vehiclePoolOccupied));
+	}
+
+	while (i < MAX_VEHICLES_AT_A_TIME)
+	{ //iterate through and try to find a free one
+		if (!g_vehiclePoolOccupied[i])
+		{
+			g_vehiclePoolOccupied[i] = qtrue;
+			memset(&g_vehiclePool[i], 0, sizeof(Vehicle_t));
+			*pVeh = &g_vehiclePool[i];
+			return;
+		}
+		i++;
+	}
+	Com_Error(ERR_DROP, "Ran out of vehicle pool slots.");
+}
+
+//free the pointer, sort of a lame method
+void G_FreeVehicleObject(Vehicle_t *pVeh)
+{
+	int i = 0;
+	while (i < MAX_VEHICLES_AT_A_TIME)
+	{
+		if (g_vehiclePoolOccupied[i] &&
+			&g_vehiclePool[i] == pVeh)
+		{ //guess this is it
+			g_vehiclePoolOccupied[i] = qfalse;
+			break;
+		}
+		i++;
+	}
+}
+
+gclient_t *gClPtrs[MAX_GENTITIES];
+
+void G_CreateFakeClient(int entNum, gclient_t **cl)
+{
+	//trap_TrueMalloc((void **)cl, sizeof(gclient_t));
+	if (!gClPtrs[entNum])
+	{
+		gClPtrs[entNum] = (gclient_t *) BG_Alloc(sizeof(gclient_t));
+	}
+	*cl = gClPtrs[entNum];
+}
+
+#ifdef _XBOX
+void G_ClPtrClear(void)
+{
+	for(int i=0; i<MAX_GENTITIES; i++) {
+		gClPtrs[i] = NULL;
+	}
+}
+#endif
+
+//call this on game shutdown to run through and get rid of all the lingering client pointers.
+void G_CleanAllFakeClients(void)
+{
+	int i = MAX_CLIENTS; //start off here since all ents below have real client structs.
+	gentity_t *ent;
+
+	while (i < MAX_GENTITIES)
+	{
+		ent = &g_entities[i];
+
+		if (ent->inuse && ent->s.eType == ET_NPC && ent->client)
+		{
+			G_FreeFakeClient(&ent->client);
+		}
+		i++;
+	}
+}
+
+/*
+=============
+G_SetAnim
+
+Finally reworked PM_SetAnim to allow non-pmove calls, so we take our
+local anim index into account and make the call -rww
+=============
+*/
+#include "../namespace_begin.h"
+void BG_SetAnim(playerState_t *ps, animation_t *animations, int setAnimParts,int anim,int setAnimFlags, int blendTime);
+#include "../namespace_end.h"
+
+void G_SetAnim(gentity_t *ent, usercmd_t *ucmd, int setAnimParts, int anim, int setAnimFlags, int blendTime)
+{
+#if 0 //old hackish way
+	pmove_t pmv;
+
+	assert(ent && ent->inuse && ent->client);
+
+	memset (&pmv, 0, sizeof(pmv));
+	pmv.ps = &ent->client->ps;
+	pmv.animations = bgAllAnims[ent->localAnimIndex].anims;
+	if (!ucmd)
+	{
+		pmv.cmd = ent->client->pers.cmd;
+	}
+	else
+	{
+		pmv.cmd = *ucmd;
+	}
+	pmv.trace = trap_Trace;
+	pmv.pointcontents = trap_PointContents;
+	pmv.gametype = g_gametype.integer;
+
+	//don't need to bother with ghoul2 stuff, it's not even used in PM_SetAnim.
+	pm = &pmv;
+	PM_SetAnim(setAnimParts, anim, setAnimFlags, blendTime);
+#else //new clean and shining way!
+	assert(ent->client);
+    BG_SetAnim(&ent->client->ps, bgAllAnims[ent->localAnimIndex].anims, setAnimParts,
+		anim, setAnimFlags, blendTime);
+#endif
+}
+
+
+/*
+=============
+G_PickTarget
+
+Selects a random entity from among the targets
+=============
+*/
+#define MAXCHOICES	32
+
+gentity_t *G_PickTarget (char *targetname)
+{
+	gentity_t	*ent = NULL;
+	int		num_choices = 0;
+	gentity_t	*choice[MAXCHOICES];
+
+	if (!targetname)
+	{
+		G_Printf("G_PickTarget called with NULL targetname\n");
+		return NULL;
+	}
+
+	while(1)
+	{
+		ent = G_Find (ent, FOFS(targetname), targetname);
+		if (!ent)
+			break;
+		choice[num_choices++] = ent;
+		if (num_choices == MAXCHOICES)
+			break;
+	}
+
+	if (!num_choices)
+	{
+		G_Printf("G_PickTarget: target %s not found\n", targetname);
+		return NULL;
+	}
+
+	return choice[rand() % num_choices];
+}
+
+void GlobalUse(gentity_t *self, gentity_t *other, gentity_t *activator)
+{
+	if (!self || (self->flags & FL_INACTIVE))
+	{
+		return;
+	}
+
+	if (!self->use)
+	{
+		return;
+	}
+	self->use(self, other, activator);
+}
+
+void G_UseTargets2( gentity_t *ent, gentity_t *activator, const char *string ) {
+	gentity_t		*t;
+	
+	if ( !ent ) {
+		return;
+	}
+
+	if (ent->targetShaderName && ent->targetShaderNewName) {
+		float f = level.time * 0.001;
+		AddRemap(ent->targetShaderName, ent->targetShaderNewName, f);
+		trap_SetConfigstring(CS_SHADERSTATE, BuildShaderStateConfig());
+	}
+
+	if ( !string || !string[0] ) {
+		return;
+	}
+
+	t = NULL;
+	while ( (t = G_Find (t, FOFS(targetname), string)) != NULL ) {
+		if ( t == ent ) {
+			G_Printf ("WARNING: Entity used itself.\n");
+		} else {
+			if ( t->use ) {
+				GlobalUse(t, ent, activator);
+			}
+		}
+		if ( !ent->inuse ) {
+			G_Printf("entity was removed while using targets\n");
+			return;
+		}
+	}
+}
+/*
+==============================
+G_UseTargets
+
+"activator" should be set to the entity that initiated the firing.
+
+Search for (string)targetname in all entities that
+match (string)self.target and call their .use function
+
+==============================
+*/
+void G_UseTargets( gentity_t *ent, gentity_t *activator )
+{
+	if (!ent)
+	{
+		return;
+	}
+	G_UseTargets2(ent, activator, ent->target);
+}
+
+
+/*
+=============
+TempVector
+
+This is just a convenience function
+for making temporary vectors for function calls
+=============
+*/
+float	*tv( float x, float y, float z ) {
+	static	int		index;
+	static	vec3_t	vecs[8];
+	float	*v;
+
+	// use an array so that multiple tempvectors won't collide
+	// for a while
+	v = vecs[index];
+	index = (index + 1)&7;
+
+	v[0] = x;
+	v[1] = y;
+	v[2] = z;
+
+	return v;
+}
+
+
+/*
+=============
+VectorToString
+
+This is just a convenience function
+for printing vectors
+=============
+*/
+char	*vtos( const vec3_t v ) {
+	static	int		index;
+	static	char	str[8][32];
+	char	*s;
+
+	// use an array so that multiple vtos won't collide
+	s = str[index];
+	index = (index + 1)&7;
+
+	Com_sprintf (s, 32, "(%i %i %i)", (int)v[0], (int)v[1], (int)v[2]);
+
+	return s;
+}
+
+
+/*
+===============
+G_SetMovedir
+
+The editor only specifies a single value for angles (yaw),
+but we have special constants to generate an up or down direction.
+Angles will be cleared, because it is being used to represent a direction
+instead of an orientation.
+===============
+*/
+void G_SetMovedir( vec3_t angles, vec3_t movedir ) {
+	static vec3_t VEC_UP		= {0, -1, 0};
+	static vec3_t MOVEDIR_UP	= {0, 0, 1};
+	static vec3_t VEC_DOWN		= {0, -2, 0};
+	static vec3_t MOVEDIR_DOWN	= {0, 0, -1};
+
+	if ( VectorCompare (angles, VEC_UP) ) {
+		VectorCopy (MOVEDIR_UP, movedir);
+	} else if ( VectorCompare (angles, VEC_DOWN) ) {
+		VectorCopy (MOVEDIR_DOWN, movedir);
+	} else {
+		AngleVectors (angles, movedir, NULL, NULL);
+	}
+	VectorClear( angles );
+}
+
+void G_InitGentity( gentity_t *e ) {
+	e->inuse = qtrue;
+	e->classname = "noclass";
+	e->s.number = e - g_entities;
+	e->r.ownerNum = ENTITYNUM_NONE;
+	e->s.modelGhoul2 = 0; //assume not
+
+	trap_ICARUS_FreeEnt( e );	//ICARUS information must be added after this point
+}
+
+//give us some decent info on all the active ents -rww
+static void G_SpewEntList(void)
+{
+	int i = 0;
+	int numNPC = 0;
+	int numProjectile = 0;
+	int numTempEnt = 0;
+	int numTempEntST = 0;
+	char className[MAX_STRING_CHARS];
+	gentity_t *ent;
+	char *str;
+#ifdef FINAL_BUILD
+	#define VM_OR_FINAL_BUILD
+#elif defined Q3_VM
+	#define VM_OR_FINAL_BUILD
+#endif
+
+#ifndef VM_OR_FINAL_BUILD
+	fileHandle_t fh;
+	trap_FS_FOpenFile("entspew.txt", &fh, FS_WRITE);
+#endif
+
+	while (i < ENTITYNUM_MAX_NORMAL)
+	{
+		ent = &g_entities[i];
+		if (ent->inuse)
+		{
+			if (ent->s.eType == ET_NPC)
+			{
+				numNPC++;
+			}
+			else if (ent->s.eType == ET_MISSILE)
+			{
+				numProjectile++;
+			}
+			else if (ent->freeAfterEvent)
+			{
+				numTempEnt++;
+				if (ent->s.eFlags & EF_SOUNDTRACKER)
+				{
+					numTempEntST++;
+				}
+
+				str = va("TEMPENT %4i: EV %i\n", ent->s.number, (ent->s.event&~EV_EVENT_BITS));
+				Com_Printf(str);
+#ifndef VM_OR_FINAL_BUILD
+				if (fh)
+				{
+					trap_FS_Write(str, strlen(str), fh);
+				}
+#endif
+			}
+
+			if (ent->classname && ent->classname[0])
+			{
+				strcpy(className, ent->classname);
+			}
+			else
+			{
+				strcpy(className, "Unknown");
+			}
+			str = va("ENT %4i: Classname %s\n", ent->s.number, className);
+			Com_Printf(str);
+#ifndef VM_OR_FINAL_BUILD
+			if (fh)
+			{
+				trap_FS_Write(str, strlen(str), fh);
+			}
+#endif
+		}
+
+		i++;
+	}
+
+	str = va("TempEnt count: %i\nTempEnt ST: %i\nNPC count: %i\nProjectile count: %i\n", numTempEnt, numTempEntST, numNPC, numProjectile);
+	Com_Printf(str);
+#ifndef VM_OR_FINAL_BUILD
+	if (fh)
+	{
+		trap_FS_Write(str, strlen(str), fh);
+		trap_FS_FCloseFile(fh);
+	}
+#endif
+}
+
+/*
+=================
+G_Spawn
+
+Either finds a free entity, or allocates a new one.
+
+  The slots from 0 to MAX_CLIENTS-1 are always reserved for clients, and will
+never be used by anything else.
+
+Try to avoid reusing an entity that was recently freed, because it
+can cause the client to think the entity morphed into something else
+instead of being removed and recreated, which can cause interpolated
+angles and bad trails.
+=================
+*/
+gentity_t *G_Spawn( void ) {
+	int			i, force;
+	gentity_t	*e;
+
+	e = NULL;	// shut up warning
+	i = 0;		// shut up warning
+	for ( force = 0 ; force < 2 ; force++ ) {
+		// if we go through all entities and can't find one to free,
+		// override the normal minimum times before use
+		e = &g_entities[MAX_CLIENTS];
+		for ( i = MAX_CLIENTS ; i<level.num_entities ; i++, e++) {
+			if ( e->inuse ) {
+				continue;
+			}
+
+			// the first couple seconds of server time can involve a lot of
+			// freeing and allocating, so relax the replacement policy
+			if ( !force && e->freetime > level.startTime + 2000 && level.time - e->freetime < 1000 )
+			{
+				continue;
+			}
+
+			// reuse this slot
+			G_InitGentity( e );
+			return e;
+		}
+		if ( i != MAX_GENTITIES ) {
+			break;
+		}
+	}
+	if ( i == ENTITYNUM_MAX_NORMAL ) {
+		/*
+		for (i = 0; i < MAX_GENTITIES; i++) {
+			G_Printf("%4i: %s\n", i, g_entities[i].classname);
+		}
+		*/
+		G_SpewEntList();
+		G_Error( "G_Spawn: no free entities" );
+	}
+	
+	// open up a new slot
+	level.num_entities++;
+
+	// let the server system know that there are more entities
+	trap_LocateGameData( level.gentities, level.num_entities, sizeof( gentity_t ), 
+		&level.clients[0].ps, sizeof( level.clients[0] ) );
+
+	G_InitGentity( e );
+	return e;
+}
+
+/*
+=================
+G_EntitiesFree
+=================
+*/
+qboolean G_EntitiesFree( void ) {
+	int			i;
+	gentity_t	*e;
+
+	e = &g_entities[MAX_CLIENTS];
+	for ( i = MAX_CLIENTS; i < level.num_entities; i++, e++) {
+		if ( e->inuse ) {
+			continue;
+		}
+		// slot available
+		return qtrue;
+	}
+	return qfalse;
+}
+
+#define MAX_G2_KILL_QUEUE 256
+
+int gG2KillIndex[MAX_G2_KILL_QUEUE];
+int gG2KillNum = 0;
+
+void G_SendG2KillQueue(void)
+{
+	char g2KillString[1024];
+	int i = 0;
+	
+	if (!gG2KillNum)
+	{
+		return;
+	}
+
+	Com_sprintf(g2KillString, 1024, "kg2");
+
+	while (i < gG2KillNum && i < 64)
+	{ //send 64 at once, max...
+		Q_strcat(g2KillString, 1024, va(" %i", gG2KillIndex[i]));
+		i++;
+	}
+
+	trap_SendServerCommand(-1, g2KillString);
+
+	//Clear the count because we just sent off the whole queue
+	gG2KillNum -= i;
+	if (gG2KillNum < 0)
+	{ //hmm, should be impossible, but I'm paranoid as we're far past beta.
+		assert(0);
+		gG2KillNum = 0;
+	}
+}
+
+void G_KillG2Queue(int entNum)
+{
+	if (gG2KillNum >= MAX_G2_KILL_QUEUE)
+	{ //This would be considered a Bad Thing.
+#ifdef _DEBUG
+		Com_Printf("WARNING: Exceeded the MAX_G2_KILL_QUEUE count for this frame!\n");
+#endif
+		//Since we're out of queue slots, just send it now as a seperate command (eats more bandwidth, but we have no choice)
+		trap_SendServerCommand(-1, va("kg2 %i", entNum));
+		return;
+	}
+
+	gG2KillIndex[gG2KillNum] = entNum;
+	gG2KillNum++;
+}
+
+/*
+=================
+G_FreeEntity
+
+Marks the entity as free
+=================
+*/
+void G_FreeEntity( gentity_t *ed ) {
+	//gentity_t *te;
+
+	if (ed->isSaberEntity)
+	{
+#ifdef _DEBUG
+		Com_Printf("Tried to remove JM saber!\n");
+#endif
+		return;
+	}
+
+	trap_UnlinkEntity (ed);		// unlink from world
+
+	trap_ICARUS_FreeEnt( ed );	//ICARUS information must be added after this point
+
+	if ( ed->neverFree ) {
+		return;
+	}
+
+	//rww - this may seem a bit hackish, but unfortunately we have no access
+	//to anything ghoul2-related on the server and thus must send a message
+	//to let the client know he needs to clean up all the g2 stuff for this
+	//now-removed entity
+	if (ed->s.modelGhoul2)
+	{ //force all clients to accept an event to destroy this instance, right now
+		/*
+		te = G_TempEntity( vec3_origin, EV_DESTROY_GHOUL2_INSTANCE );
+		te->r.svFlags |= SVF_BROADCAST;
+		te->s.eventParm = ed->s.number;
+		*/
+		//Or not. Events can be dropped, so that would be a bad thing.
+		G_KillG2Queue(ed->s.number);
+	}
+
+	//And, free the server instance too, if there is one.
+	if (ed->ghoul2)
+	{
+		trap_G2API_CleanGhoul2Models(&(ed->ghoul2));
+	}
+
+	if (ed->s.eType == ET_NPC && ed->m_pVehicle)
+	{ //tell the "vehicle pool" that this one is now free
+		G_FreeVehicleObject(ed->m_pVehicle);
+	}
+
+	if (ed->s.eType == ET_NPC && ed->client)
+	{ //this "client" structure is one of our dynamically allocated ones, so free the memory
+		int saberEntNum = -1;
+		int i = 0;
+		if (ed->client->ps.saberEntityNum)
+		{
+			saberEntNum = ed->client->ps.saberEntityNum;
+		}
+		else if (ed->client->saberStoredIndex)
+		{
+			saberEntNum = ed->client->saberStoredIndex;
+		}
+
+		if (saberEntNum > 0 && g_entities[saberEntNum].inuse)
+		{
+			g_entities[saberEntNum].neverFree = qfalse;
+			G_FreeEntity(&g_entities[saberEntNum]);
+		}
+
+		while (i < MAX_SABERS)
+		{
+			if (ed->client->weaponGhoul2[i] && trap_G2_HaveWeGhoul2Models(ed->client->weaponGhoul2[i]))
+			{
+				trap_G2API_CleanGhoul2Models(&ed->client->weaponGhoul2[i]);
+			}
+			i++;
+		}
+
+		G_FreeFakeClient(&ed->client);
+	}
+
+	if (ed->s.eFlags & EF_SOUNDTRACKER)
+	{
+		int i = 0;
+		gentity_t *ent;
+
+		while (i < MAX_CLIENTS)
+		{
+			ent = &g_entities[i];
+
+			if (ent && ent->inuse && ent->client)
+			{
+				int ch = TRACK_CHANNEL_NONE-50;
+
+				while (ch < NUM_TRACK_CHANNELS-50)
+				{
+					if (ent->client->ps.fd.killSoundEntIndex[ch] == ed->s.number)
+					{
+						ent->client->ps.fd.killSoundEntIndex[ch] = 0;
+					}
+
+					ch++;
+				}
+			}
+
+			i++;
+		}
+
+		//make sure clientside loop sounds are killed on the tracker and client
+		trap_SendServerCommand(-1, va("kls %i %i", ed->s.trickedentindex, ed->s.number));
+	}
+
+	memset (ed, 0, sizeof(*ed));
+	ed->classname = "freed";
+	ed->freetime = level.time;
+	ed->inuse = qfalse;
+}
+
+/*
+=================
+G_TempEntity
+
+Spawns an event entity that will be auto-removed
+The origin will be snapped to save net bandwidth, so care
+must be taken if the origin is right on a surface (snap towards start vector first)
+=================
+*/
+gentity_t *G_TempEntity( vec3_t origin, int event ) {
+	gentity_t		*e;
+	vec3_t		snapped;
+
+	e = G_Spawn();
+	e->s.eType = ET_EVENTS + event;
+
+	e->classname = "tempEntity";
+	e->eventTime = level.time;
+	e->freeAfterEvent = qtrue;
+
+	VectorCopy( origin, snapped );
+	SnapVector( snapped );		// save network bandwidth
+	G_SetOrigin( e, snapped );
+
+	// find cluster for PVS
+	trap_LinkEntity( e );
+
+	return e;
+}
+
+
+/*
+=================
+G_SoundTempEntity
+
+Special event entity that keeps sound trackers in mind
+=================
+*/
+gentity_t *G_SoundTempEntity( vec3_t origin, int event, int channel ) {
+	gentity_t		*e;
+	vec3_t		snapped;
+
+	e = G_Spawn();
+
+	e->s.eType = ET_EVENTS + event;
+	e->inuse = qtrue;
+
+	e->classname = "tempEntity";
+	e->eventTime = level.time;
+	e->freeAfterEvent = qtrue;
+
+	VectorCopy( origin, snapped );
+	SnapVector( snapped );		// save network bandwidth
+	G_SetOrigin( e, snapped );
+
+	// find cluster for PVS
+	trap_LinkEntity( e );
+
+	return e;
+}
+
+
+//scale health down below 1024 to fit in health bits
+void G_ScaleNetHealth(gentity_t *self)
+{
+	int maxHealth = self->maxHealth;
+
+    if (maxHealth < 1000)
+	{ //it's good then
+		self->s.maxhealth = maxHealth;
+		self->s.health = self->health;
+
+		if (self->s.health < 0)
+		{ //don't let it wrap around
+			self->s.health = 0;
+		}
+		return;
+	}
+
+	//otherwise, scale it down
+	self->s.maxhealth = (maxHealth/100);
+	self->s.health = (self->health/100);
+
+	if (self->s.health < 0)
+	{ //don't let it wrap around
+		self->s.health = 0;
+	}
+
+	if (self->health > 0 &&
+		self->s.health <= 0)
+	{ //don't let it scale to 0 if the thing is still not "dead"
+		self->s.health = 1;
+	}
+}
+
+
+
+/*
+==============================================================================
+
+Kill box
+
+==============================================================================
+*/
+
+/*
+=================
+G_KillBox
+
+Kills all entities that would touch the proposed new positioning
+of ent.  Ent should be unlinked before calling this!
+=================
+*/
+void G_KillBox (gentity_t *ent) {
+	int			i, num;
+	int			touch[MAX_GENTITIES];
+	gentity_t	*hit;
+	vec3_t		mins, maxs;
+
+	VectorAdd( ent->client->ps.origin, ent->r.mins, mins );
+	VectorAdd( ent->client->ps.origin, ent->r.maxs, maxs );
+	num = trap_EntitiesInBox( mins, maxs, touch, MAX_GENTITIES );
+
+	for (i=0 ; i<num ; i++) {
+		hit = &g_entities[touch[i]];
+		if ( !hit->client ) {
+			continue;
+		}
+
+		if (hit->s.number == ent->s.number)
+		{ //don't telefrag yourself!
+			continue;
+		}
+
+		if (ent->r.ownerNum == hit->s.number)
+		{ //don't telefrag your vehicle!
+			continue;
+		}
+
+		// nail it
+		G_Damage ( hit, ent, ent, NULL, NULL,
+			100000, DAMAGE_NO_PROTECTION, MOD_TELEFRAG);
+	}
+
+}
+
+//==============================================================================
+
+/*
+===============
+G_AddPredictableEvent
+
+Use for non-pmove events that would also be predicted on the
+client side: jumppads and item pickups
+Adds an event+parm and twiddles the event counter
+===============
+*/
+void G_AddPredictableEvent( gentity_t *ent, int event, int eventParm ) {
+	if ( !ent->client ) {
+		return;
+	}
+	BG_AddPredictableEventToPlayerstate( event, eventParm, &ent->client->ps );
+}
+
+
+/*
+===============
+G_AddEvent
+
+Adds an event+parm and twiddles the event counter
+===============
+*/
+void G_AddEvent( gentity_t *ent, int event, int eventParm ) {
+	int		bits;
+
+	if ( !event ) {
+		G_Printf( "G_AddEvent: zero event added for entity %i\n", ent->s.number );
+		return;
+	}
+
+	// clients need to add the event in playerState_t instead of entityState_t
+	if ( ent->client ) {
+		bits = ent->client->ps.externalEvent & EV_EVENT_BITS;
+		bits = ( bits + EV_EVENT_BIT1 ) & EV_EVENT_BITS;
+		ent->client->ps.externalEvent = event | bits;
+		ent->client->ps.externalEventParm = eventParm;
+		ent->client->ps.externalEventTime = level.time;
+	} else {
+		bits = ent->s.event & EV_EVENT_BITS;
+		bits = ( bits + EV_EVENT_BIT1 ) & EV_EVENT_BITS;
+		ent->s.event = event | bits;
+		ent->s.eventParm = eventParm;
+	}
+	ent->eventTime = level.time;
+}
+
+/*
+=============
+G_PlayEffect
+=============
+*/
+gentity_t *G_PlayEffect(int fxID, vec3_t org, vec3_t ang)
+{
+	gentity_t	*te;
+
+	te = G_TempEntity( org, EV_PLAY_EFFECT );
+	VectorCopy(ang, te->s.angles);
+	VectorCopy(org, te->s.origin);
+	te->s.eventParm = fxID;
+
+	return te;
+}
+
+/*
+=============
+G_PlayEffectID
+=============
+*/
+gentity_t *G_PlayEffectID(const int fxID, vec3_t org, vec3_t ang)
+{ //play an effect by the G_EffectIndex'd ID instead of a predefined effect ID
+	gentity_t	*te;
+
+	te = G_TempEntity( org, EV_PLAY_EFFECT_ID );
+	VectorCopy(ang, te->s.angles);
+	VectorCopy(org, te->s.origin);
+	te->s.eventParm = fxID;
+
+	if (!te->s.angles[0] &&
+		!te->s.angles[1] &&
+		!te->s.angles[2])
+	{ //play off this dir by default then.
+		te->s.angles[1] = 1;
+	}
+
+	return te;
+}
+
+/*
+=============
+G_ScreenShake
+=============
+*/
+gentity_t *G_ScreenShake(vec3_t org, gentity_t *target, float intensity, int duration, qboolean global)
+{
+	gentity_t	*te;
+
+	te = G_TempEntity( org, EV_SCREENSHAKE );
+	VectorCopy(org, te->s.origin);
+	te->s.angles[0] = intensity;
+	te->s.time = duration;
+
+	if (target)
+	{
+		te->s.modelindex = target->s.number+1;
+	}
+	else
+	{
+		te->s.modelindex = 0;
+	}
+
+	if (global)
+	{
+		te->r.svFlags |= SVF_BROADCAST;
+	}
+
+	return te;
+}
+
+/*
+=============
+G_MuteSound
+=============
+*/
+void G_MuteSound( int entnum, int channel )
+{
+	gentity_t	*te, *e;
+
+	te = G_TempEntity( vec3_origin, EV_MUTE_SOUND );
+	te->r.svFlags = SVF_BROADCAST;
+	te->s.trickedentindex2 = entnum;
+	te->s.trickedentindex = channel;
+
+	e = &g_entities[entnum];
+
+	if (e && (e->s.eFlags & EF_SOUNDTRACKER))
+	{
+		G_FreeEntity(e);
+		e->s.eFlags = 0;
+	}
+}
+
+/*
+=============
+G_Sound
+=============
+*/
+void G_Sound( gentity_t *ent, int channel, int soundIndex ) {
+	gentity_t	*te;
+
+	assert(soundIndex);
+
+	te = G_SoundTempEntity( ent->r.currentOrigin, EV_GENERAL_SOUND, channel );
+	te->s.eventParm = soundIndex;
+	te->s.saberEntityNum = channel;
+
+	if (ent && ent->client && channel > TRACK_CHANNEL_NONE)
+	{ //let the client remember the index of the player entity so he can kill the most recent sound on request
+		if (g_entities[ent->client->ps.fd.killSoundEntIndex[channel-50]].inuse &&
+			ent->client->ps.fd.killSoundEntIndex[channel-50] > MAX_CLIENTS)
+		{
+			G_MuteSound(ent->client->ps.fd.killSoundEntIndex[channel-50], CHAN_VOICE);
+			if (ent->client->ps.fd.killSoundEntIndex[channel-50] > MAX_CLIENTS && g_entities[ent->client->ps.fd.killSoundEntIndex[channel-50]].inuse)
+			{
+				G_FreeEntity(&g_entities[ent->client->ps.fd.killSoundEntIndex[channel-50]]);
+			}
+			ent->client->ps.fd.killSoundEntIndex[channel-50] = 0;
+		}
+
+		ent->client->ps.fd.killSoundEntIndex[channel-50] = te->s.number;
+		te->s.trickedentindex = ent->s.number;
+		te->s.eFlags = EF_SOUNDTRACKER;
+		//te->freeAfterEvent = qfalse;
+	}
+}
+
+/*
+=============
+G_SoundAtLoc
+=============
+*/
+void G_SoundAtLoc( vec3_t loc, int channel, int soundIndex ) {
+	gentity_t	*te;
+
+	te = G_TempEntity( loc, EV_GENERAL_SOUND );
+	te->s.eventParm = soundIndex;
+	te->s.saberEntityNum = channel;
+}
+
+/*
+=============
+G_EntitySound
+=============
+*/
+void G_EntitySound( gentity_t *ent, int channel, int soundIndex ) {
+	gentity_t	*te;
+
+	te = G_TempEntity( ent->r.currentOrigin, EV_ENTITY_SOUND );
+	te->s.eventParm = soundIndex;
+	te->s.clientNum = ent->s.number;
+	te->s.trickedentindex = channel;
+}
+
+//To make porting from SP easier.
+void G_SoundOnEnt( gentity_t *ent, int channel, const char *soundPath )
+{
+	gentity_t	*te;
+
+	te = G_TempEntity( ent->r.currentOrigin, EV_ENTITY_SOUND );
+	te->s.eventParm = G_SoundIndex((char *)soundPath);
+	te->s.clientNum = ent->s.number;
+	te->s.trickedentindex = channel;
+
+}
+
+#ifdef _XBOX
+//-----------------------------
+void G_EntityPosition( int i, vec3_t ret )
+{
+	if ( /*g_entities &&*/ i >= 0 && i < MAX_GENTITIES && g_entities[i].inuse)
+	{
+#if 0	// VVFIXME - Do we really care about doing this? It's slow and unnecessary
+		gentity_t *ent = g_entities + i;
+
+		if (ent->bmodel)
+		{
+			vec3_t mins, maxs;
+			clipHandle_t h = CM_InlineModel( ent->s.modelindex );
+			CM_ModelBounds( cmg, h, mins, maxs );
+			ret[0] = (mins[0] + maxs[0]) / 2 + ent->currentOrigin[0];
+			ret[1] = (mins[1] + maxs[1]) / 2 + ent->currentOrigin[1];
+			ret[2] = (mins[2] + maxs[2]) / 2 + ent->currentOrigin[2];
+		}
+		else
+#endif
+		{
+			VectorCopy(g_entities[i].r.currentOrigin, ret);
+		}
+	}
+	else
+	{
+		ret[0] = ret[1] = ret[2] = 0;
+	}
+}
+#endif
+
+//==============================================================================
+
+/*
+==============
+ValidUseTarget
+
+Returns whether or not the targeted entity is useable
+==============
+*/
+qboolean ValidUseTarget( gentity_t *ent )
+{
+	if ( !ent->use )
+	{
+		return qfalse;
+	}
+
+	if ( ent->flags & FL_INACTIVE )
+	{//set by target_deactivate
+		return qfalse;
+	}
+
+	if ( !(ent->r.svFlags & SVF_PLAYER_USABLE) )
+	{//Check for flag that denotes BUTTON_USE useability
+		return qfalse;
+	}
+
+	return qtrue;
+}
+
+//use an ammo/health dispenser on another client
+void G_UseDispenserOn(gentity_t *ent, int dispType, gentity_t *target)
+{
+	if (dispType == HI_HEALTHDISP)
+	{
+		target->client->ps.stats[STAT_HEALTH] += 4;
+
+		if (target->client->ps.stats[STAT_HEALTH] > target->client->ps.stats[STAT_MAX_HEALTH])
+		{
+			target->client->ps.stats[STAT_HEALTH] = target->client->ps.stats[STAT_MAX_HEALTH];
+		}
+
+		target->client->isMedHealed = level.time + 500;
+		target->health = target->client->ps.stats[STAT_HEALTH];
+	}
+	else if (dispType == HI_AMMODISP)
+	{
+		if (ent->client->medSupplyDebounce < level.time)
+		{ //do the next increment
+			//increment based on the amount of ammo used per normal shot.
+			target->client->ps.ammo[weaponData[target->client->ps.weapon].ammoIndex] += weaponData[target->client->ps.weapon].energyPerShot;
+
+			if (target->client->ps.ammo[weaponData[target->client->ps.weapon].ammoIndex] > ammoData[weaponData[target->client->ps.weapon].ammoIndex].max)
+			{ //cap it off
+				target->client->ps.ammo[weaponData[target->client->ps.weapon].ammoIndex] = ammoData[weaponData[target->client->ps.weapon].ammoIndex].max;
+			}
+
+			//base the next supply time on how long the weapon takes to fire. Seems fair enough.
+			ent->client->medSupplyDebounce = level.time + weaponData[target->client->ps.weapon].fireTime;
+		}
+		target->client->isMedSupplied = level.time + 500;
+	}
+}
+
+//see if this guy needs servicing from a specific type of dispenser
+int G_CanUseDispOn(gentity_t *ent, int dispType)
+{
+	if (!ent->client || !ent->inuse || ent->health < 1 ||
+		ent->client->ps.stats[STAT_HEALTH] < 1)
+	{ //dead or invalid
+		return 0;
+	}
+
+	if (dispType == HI_HEALTHDISP)
+	{
+        if (ent->client->ps.stats[STAT_HEALTH] < ent->client->ps.stats[STAT_MAX_HEALTH])
+		{ //he's hurt
+			return 1;
+		}
+
+		//otherwise no
+		return 0;
+	}
+	else if (dispType == HI_AMMODISP)
+	{
+		if (ent->client->ps.weapon <= WP_NONE || ent->client->ps.weapon > LAST_USEABLE_WEAPON)
+		{ //not a player-useable weapon
+			return 0;
+		}
+
+		if (ent->client->ps.ammo[weaponData[ent->client->ps.weapon].ammoIndex] < ammoData[weaponData[ent->client->ps.weapon].ammoIndex].max)
+		{ //needs more ammo for current weapon
+			return 1;
+		}
+
+		//needs none
+		return 0;
+	}
+
+	//invalid type?
+	return 0;
+}
+
+qboolean TryHeal(gentity_t *ent, gentity_t *target)
+{
+	if (g_gametype.integer == GT_SIEGE && ent->client->siegeClass != -1 &&
+		target && target->inuse && target->maxHealth && target->healingclass &&
+		target->healingclass[0] && target->health > 0 && target->health < target->maxHealth)
+	{ //it's not dead yet...
+		siegeClass_t *scl = &bgSiegeClasses[ent->client->siegeClass];
+
+		if (!Q_stricmp(scl->name, target->healingclass))
+		{ //this thing can be healed by the class this player is using
+			if (target->healingDebounce < level.time)
+			{ //do the actual heal
+				target->health += 10;
+				if (target->health > target->maxHealth)
+				{ //don't go too high
+					target->health = target->maxHealth;
+				}
+				target->healingDebounce = level.time + target->healingrate;
+				if (target->healingsound && target->healingsound[0])
+				{ //play it
+					if (target->s.solid == SOLID_BMODEL)
+					{ //ok, well, just play it on the client then.
+						G_Sound(ent, CHAN_AUTO, G_SoundIndex(target->healingsound));
+					}
+					else
+					{
+						G_Sound(target, CHAN_AUTO, G_SoundIndex(target->healingsound));
+					}
+				}
+
+				//update net health for bar
+				G_ScaleNetHealth(target);
+				if (target->target_ent &&
+					target->target_ent->maxHealth)
+				{
+					target->target_ent->health = target->health;
+					G_ScaleNetHealth(target->target_ent);
+				}
+			}
+
+			//keep them in the healing anim even when the healing debounce is not yet expired
+			if (ent->client->ps.torsoAnim == BOTH_BUTTON_HOLD ||
+				ent->client->ps.torsoAnim == BOTH_CONSOLE1)
+			{ //extend the time
+				ent->client->ps.torsoTimer = 500;
+			}
+			else
+			{
+				G_SetAnim( ent, NULL, SETANIM_TORSO, BOTH_BUTTON_HOLD, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD, 0 );
+			}
+
+			return qtrue;
+		}
+	}
+
+	return qfalse;
+}
+
+/*
+==============
+TryUse
+
+Try and use an entity in the world, directly ahead of us
+==============
+*/
+
+#define USE_DISTANCE	64.0f
+
+extern void Touch_Button(gentity_t *ent, gentity_t *other, trace_t *trace );
+extern qboolean gSiegeRoundBegun;
+static vec3_t	playerMins = {-15, -15, DEFAULT_MINS_2};
+static vec3_t	playerMaxs = {15, 15, DEFAULT_MAXS_2};
+void TryUse( gentity_t *ent )
+{
+	gentity_t	*target;
+	trace_t		trace;
+	vec3_t		src, dest, vf;
+	vec3_t		viewspot;
+
+	if (g_gametype.integer == GT_SIEGE &&
+		!gSiegeRoundBegun)
+	{ //nothing can be used til the round starts.
+		return;
+	}
+
+	if (!ent || !ent->client || (ent->client->ps.weaponTime > 0 && ent->client->ps.torsoAnim != BOTH_BUTTON_HOLD && ent->client->ps.torsoAnim != BOTH_CONSOLE1) || ent->health < 1 ||
+		(ent->client->ps.pm_flags & PMF_FOLLOW) || ent->client->sess.sessionTeam == TEAM_SPECTATOR ||
+		(ent->client->ps.forceHandExtend != HANDEXTEND_NONE && ent->client->ps.forceHandExtend != HANDEXTEND_DRAGGING))
+	{
+		return;
+	}
+
+	if (ent->client->ps.emplacedIndex)
+	{ //on an emplaced gun or using a vehicle, don't do anything when hitting use key
+		return;
+	}
+
+	if (ent->s.number < MAX_CLIENTS && ent->client && ent->client->ps.m_iVehicleNum)
+	{
+		gentity_t *currentVeh = &g_entities[ent->client->ps.m_iVehicleNum];
+		if (currentVeh->inuse && currentVeh->m_pVehicle)
+		{
+			Vehicle_t *pVeh = currentVeh->m_pVehicle;
+			if (!pVeh->m_iBoarding)
+			{
+				pVeh->m_pVehicleInfo->Eject( pVeh, (bgEntity_t *)ent, qfalse );
+			}
+			return;
+		}
+	}
+
+	if (ent->client->jetPackOn)
+	{ //can't use anything else to jp is off
+		goto tryJetPack;
+	}
+
+	if (ent->client->bodyGrabIndex != ENTITYNUM_NONE)
+	{ //then hitting the use key just means let go
+		if (ent->client->bodyGrabTime < level.time)
+		{
+			gentity_t *grabbed = &g_entities[ent->client->bodyGrabIndex];
+
+			if (grabbed->inuse)
+			{
+				if (grabbed->client)
+				{
+					grabbed->client->ps.ragAttach = 0;
+				}
+				else
+				{
+					grabbed->s.ragAttach = 0;
+				}
+			}
+			ent->client->bodyGrabIndex = ENTITYNUM_NONE;
+			ent->client->bodyGrabTime = level.time + 1000;
+		}
+		return;
+	}
+
+	VectorCopy(ent->client->ps.origin, viewspot);
+	viewspot[2] += ent->client->ps.viewheight;
+
+	VectorCopy( viewspot, src );
+	AngleVectors( ent->client->ps.viewangles, vf, NULL, NULL );
+
+	VectorMA( src, USE_DISTANCE, vf, dest );
+
+	//Trace ahead to find a valid target
+	trap_Trace( &trace, src, vec3_origin, vec3_origin, dest, ent->s.number, MASK_OPAQUE|CONTENTS_SOLID|CONTENTS_BODY|CONTENTS_ITEM|CONTENTS_CORPSE );
+	
+	if ( trace.fraction == 1.0f || trace.entityNum < 1 )
+	{
+		goto tryJetPack;
+	}
+
+	target = &g_entities[trace.entityNum];
+
+//Enable for corpse dragging
+#if 0
+	if (target->inuse && target->s.eType == ET_BODY &&
+		ent->client->bodyGrabTime < level.time)
+	{ //then grab the body
+		target->s.eFlags |= EF_RAG; //make sure it's in rag state
+		if (!ent->s.number)
+		{ //switch cl 0 and entitynum_none, so we can operate on the "if non-0" concept
+			target->s.ragAttach = ENTITYNUM_NONE;
+		}
+		else
+		{
+			target->s.ragAttach = ent->s.number;
+		}
+		ent->client->bodyGrabTime = level.time + 1000;
+		ent->client->bodyGrabIndex = target->s.number;
+		return;
+	}
+#endif
+
+	if (target && target->m_pVehicle && target->client &&
+		target->s.NPC_class == CLASS_VEHICLE &&
+		!ent->client->ps.zoomMode)
+	{ //if target is a vehicle then perform appropriate checks
+		Vehicle_t *pVeh = target->m_pVehicle;
+
+		if (pVeh->m_pVehicleInfo)
+		{
+			if ( ent->r.ownerNum == target->s.number )
+			{ //user is already on this vehicle so eject him
+				pVeh->m_pVehicleInfo->Eject( pVeh, (bgEntity_t *)ent, qfalse );
+			}
+			else
+			{ // Otherwise board this vehicle.
+				if (g_gametype.integer < GT_TEAM ||
+					!target->alliedTeam ||
+					(target->alliedTeam == ent->client->sess.sessionTeam))
+				{ //not belonging to a team, or client is on same team
+					pVeh->m_pVehicleInfo->Board( pVeh, (bgEntity_t *)ent );
+				}
+			}
+			//clear the damn button!
+			ent->client->pers.cmd.buttons &= ~BUTTON_USE;
+			return;
+		}
+	}
+
+#if 0 //ye olde method
+	if (ent->client->ps.stats[STAT_HOLDABLE_ITEM] > 0 &&
+		bg_itemlist[ent->client->ps.stats[STAT_HOLDABLE_ITEM]].giType == IT_HOLDABLE)
+	{
+		if (bg_itemlist[ent->client->ps.stats[STAT_HOLDABLE_ITEM]].giTag == HI_HEALTHDISP ||
+			bg_itemlist[ent->client->ps.stats[STAT_HOLDABLE_ITEM]].giTag == HI_AMMODISP)
+		{ //has a dispenser item selected
+            if (target && target->client && target->health > 0 && OnSameTeam(ent, target) &&
+				G_CanUseDispOn(target, bg_itemlist[ent->client->ps.stats[STAT_HOLDABLE_ITEM]].giTag))
+			{ //a live target that's on my team, we can use him
+				G_UseDispenserOn(ent, bg_itemlist[ent->client->ps.stats[STAT_HOLDABLE_ITEM]].giTag, target);
+
+				//for now, we will use the standard use anim
+				if (ent->client->ps.torsoAnim == BOTH_BUTTON_HOLD)
+				{ //extend the time
+					ent->client->ps.torsoTimer = 500;
+				}
+				else
+				{
+					G_SetAnim( ent, NULL, SETANIM_TORSO, BOTH_BUTTON_HOLD, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD, 0 );
+				}
+				ent->client->ps.weaponTime = ent->client->ps.torsoTimer;
+				return;
+			}
+		}
+	}
+#else
+    if ( ((ent->client->ps.stats[STAT_HOLDABLE_ITEMS] & (1 << HI_HEALTHDISP)) || (ent->client->ps.stats[STAT_HOLDABLE_ITEMS] & (1 << HI_AMMODISP))) &&
+		target && target->inuse && target->client && target->health > 0 && OnSameTeam(ent, target) &&
+		(G_CanUseDispOn(target, HI_HEALTHDISP) || G_CanUseDispOn(target, HI_AMMODISP)) )
+	{ //a live target that's on my team, we can use him
+		if (G_CanUseDispOn(target, HI_HEALTHDISP))
+		{
+			G_UseDispenserOn(ent, HI_HEALTHDISP, target);
+		}
+		if (G_CanUseDispOn(target, HI_AMMODISP))
+		{
+			G_UseDispenserOn(ent, HI_AMMODISP, target);
+		}
+
+		//for now, we will use the standard use anim
+		if (ent->client->ps.torsoAnim == BOTH_BUTTON_HOLD)
+		{ //extend the time
+			ent->client->ps.torsoTimer = 500;
+		}
+		else
+		{
+			G_SetAnim( ent, NULL, SETANIM_TORSO, BOTH_BUTTON_HOLD, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD, 0 );
+		}
+		ent->client->ps.weaponTime = ent->client->ps.torsoTimer;
+		return;
+	}
+
+#endif
+
+	//Check for a use command
+	if ( ValidUseTarget( target ) 
+		&& (g_gametype.integer != GT_SIEGE 
+			|| !target->alliedTeam 
+			|| target->alliedTeam != ent->client->sess.sessionTeam 
+			|| g_ff_objectives.integer) )
+	{
+		if (ent->client->ps.torsoAnim == BOTH_BUTTON_HOLD ||
+			ent->client->ps.torsoAnim == BOTH_CONSOLE1)
+		{ //extend the time
+			ent->client->ps.torsoTimer = 500;
+		}
+		else
+		{
+			G_SetAnim( ent, NULL, SETANIM_TORSO, BOTH_BUTTON_HOLD, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD, 0 );
+		}
+		ent->client->ps.weaponTime = ent->client->ps.torsoTimer;
+		/*
+		NPC_SetAnim( ent, SETANIM_TORSO, BOTH_FORCEPUSH, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
+		if ( !VectorLengthSquared( ent->client->ps.velocity ) )
+		{
+			NPC_SetAnim( ent, SETANIM_LEGS, BOTH_FORCEPUSH, SETANIM_FLAG_NORMAL|SETANIM_FLAG_HOLD );
+		}
+		*/
+		if ( target->touch == Touch_Button )
+		{//pretend we touched it
+			target->touch(target, ent, NULL);
+		}
+		else
+		{
+			GlobalUse(target, ent, ent);
+		}
+		return;
+	}
+
+	if (TryHeal(ent, target))
+	{
+		return;
+	}
+
+tryJetPack:
+	//if we got here, we didn't actually use anything else, so try to toggle jetpack if we are in the air, or if it is already on
+	if (ent->client->ps.stats[STAT_HOLDABLE_ITEMS] & (1 << HI_JETPACK))
+	{
+		if (ent->client->jetPackOn || ent->client->ps.groundEntityNum == ENTITYNUM_NONE)
+		{
+			ItemUse_Jetpack(ent);
+			return;
+		}
+	}
+
+	if ( (ent->client->ps.stats[STAT_HOLDABLE_ITEMS] & (1 << HI_AMMODISP)) /*&&
+		G_ItemUsable(&ent->client->ps, HI_AMMODISP)*/ )
+	{ //if you used nothing, then try spewing out some ammo
+		trace_t trToss;
+		vec3_t fAng;
+		vec3_t fwd;
+
+		VectorSet(fAng, 0.0f, ent->client->ps.viewangles[YAW], 0.0f);
+		AngleVectors(fAng, fwd, 0, 0);
+
+        VectorMA(ent->client->ps.origin, 64.0f, fwd, fwd);		
+		trap_Trace(&trToss, ent->client->ps.origin, playerMins, playerMaxs, fwd, ent->s.number, ent->clipmask);
+		if (trToss.fraction == 1.0f && !trToss.allsolid && !trToss.startsolid)
+		{
+			ItemUse_UseDisp(ent, HI_AMMODISP);
+			G_AddEvent(ent, EV_USE_ITEM0+HI_AMMODISP, 0);
+			return;
+		}
+	}
+}
+
+qboolean G_PointInBounds( vec3_t point, vec3_t mins, vec3_t maxs )
+{
+	int i;
+
+	for(i = 0; i < 3; i++ )
+	{
+		if ( point[i] < mins[i] )
+		{
+			return qfalse;
+		}
+		if ( point[i] > maxs[i] )
+		{
+			return qfalse;
+		}
+	}
+
+	return qtrue;
+}
+
+qboolean G_BoxInBounds( vec3_t point, vec3_t mins, vec3_t maxs, vec3_t boundsMins, vec3_t boundsMaxs )
+{
+	vec3_t boxMins;
+	vec3_t boxMaxs;
+
+	VectorAdd( point, mins, boxMins );
+	VectorAdd( point, maxs, boxMaxs );
+
+	if(boxMaxs[0]>boundsMaxs[0])
+		return qfalse;
+
+	if(boxMaxs[1]>boundsMaxs[1])
+		return qfalse;
+
+	if(boxMaxs[2]>boundsMaxs[2])
+		return qfalse;
+
+	if(boxMins[0]<boundsMins[0])
+		return qfalse;
+
+	if(boxMins[1]<boundsMins[1])
+		return qfalse;
+
+	if(boxMins[2]<boundsMins[2])
+		return qfalse;
+
+	//box is completely contained within bounds
+	return qtrue;
+}
+
+
+void G_SetAngles( gentity_t *ent, vec3_t angles )
+{
+	VectorCopy( angles, ent->r.currentAngles );
+	VectorCopy( angles, ent->s.angles );
+	VectorCopy( angles, ent->s.apos.trBase );
+}
+
+qboolean G_ClearTrace( vec3_t start, vec3_t mins, vec3_t maxs, vec3_t end, int ignore, int clipmask )
+{
+	static	trace_t	tr;
+
+	trap_Trace( &tr, start, mins, maxs, end, ignore, clipmask );
+
+	if ( tr.allsolid || tr.startsolid || tr.fraction < 1.0 )
+	{
+		return qfalse;
+	}
+
+	return qtrue;
+}
+
+/*
+================
+G_SetOrigin
+
+Sets the pos trajectory for a fixed position
+================
+*/
+void G_SetOrigin( gentity_t *ent, vec3_t origin ) {
+	VectorCopy( origin, ent->s.pos.trBase );
+	ent->s.pos.trType = TR_STATIONARY;
+	ent->s.pos.trTime = 0;
+	ent->s.pos.trDuration = 0;
+	VectorClear( ent->s.pos.trDelta );
+
+	VectorCopy( origin, ent->r.currentOrigin );
+}
+
+qboolean G_CheckInSolid (gentity_t *self, qboolean fix)
+{
+	trace_t	trace;
+	vec3_t	end, mins;
+
+	VectorCopy(self->r.currentOrigin, end);
+	end[2] += self->r.mins[2];
+	VectorCopy(self->r.mins, mins);
+	mins[2] = 0;
+
+	trap_Trace(&trace, self->r.currentOrigin, mins, self->r.maxs, end, self->s.number, self->clipmask);
+	if(trace.allsolid || trace.startsolid)
+	{
+		return qtrue;
+	}
+	
+	if(trace.fraction < 1.0)
+	{
+		if(fix)
+		{//Put them at end of trace and check again
+			vec3_t	neworg;
+
+			VectorCopy(trace.endpos, neworg);
+			neworg[2] -= self->r.mins[2];
+			G_SetOrigin(self, neworg);
+			trap_LinkEntity(self);
+
+			return G_CheckInSolid(self, qfalse);
+		}
+		else
+		{
+			return qtrue;
+		}
+	}
+		
+	return qfalse;
+}
+
+/*
+================
+DebugLine
+
+  debug polygons only work when running a local game
+  with r_debugSurface set to 2
+================
+*/
+int DebugLine(vec3_t start, vec3_t end, int color) {
+	vec3_t points[4], dir, cross, up = {0, 0, 1};
+	float dot;
+
+	VectorCopy(start, points[0]);
+	VectorCopy(start, points[1]);
+	//points[1][2] -= 2;
+	VectorCopy(end, points[2]);
+	//points[2][2] -= 2;
+	VectorCopy(end, points[3]);
+
+
+	VectorSubtract(end, start, dir);
+	VectorNormalize(dir);
+	dot = DotProduct(dir, up);
+	if (dot > 0.99 || dot < -0.99) VectorSet(cross, 1, 0, 0);
+	else CrossProduct(dir, up, cross);
+
+	VectorNormalize(cross);
+
+	VectorMA(points[0], 2, cross, points[0]);
+	VectorMA(points[1], -2, cross, points[1]);
+	VectorMA(points[2], -2, cross, points[2]);
+	VectorMA(points[3], 2, cross, points[3]);
+
+	return trap_DebugPolygonCreate(color, 4, points);
+}
+
+void G_ROFF_NotetrackCallback( gentity_t *cent, const char *notetrack)
+{
+	char type[256];
+	int i = 0;
+	int addlArg = 0;
+
+	if (!cent || !notetrack)
+	{
+		return;
+	}
+
+	while (notetrack[i] && notetrack[i] != ' ')
+	{
+		type[i] = notetrack[i];
+		i++;
+	}
+
+	type[i] = '\0';
+
+	if (!i || !type[0])
+	{
+		return;
+	}
+
+	if (notetrack[i] == ' ')
+	{
+		addlArg = 1;
+	}
+
+	if (strcmp(type, "loop") == 0)
+	{
+		if (addlArg) //including an additional argument means reset to original position before loop
+		{
+			VectorCopy(cent->s.origin2, cent->s.pos.trBase);
+			VectorCopy(cent->s.origin2, cent->r.currentOrigin);
+			VectorCopy(cent->s.angles2, cent->s.apos.trBase);
+			VectorCopy(cent->s.angles2, cent->r.currentAngles);
+		}
+
+		trap_ROFF_Play(cent->s.number, cent->roffid, qfalse);
+	}
+}
+
+void G_SpeechEvent( gentity_t *self, int event )
+{
+	G_AddEvent(self, event, 0);
+}
+
+qboolean G_ExpandPointToBBox( vec3_t point, const vec3_t mins, const vec3_t maxs, int ignore, int clipmask )
+{
+	trace_t	tr;
+	vec3_t	start, end;
+	int i;
+
+	VectorCopy( point, start );
+	
+	for ( i = 0; i < 3; i++ )
+	{
+		VectorCopy( start, end );
+		end[i] += mins[i];
+		trap_Trace( &tr, start, vec3_origin, vec3_origin, end, ignore, clipmask );
+		if ( tr.allsolid || tr.startsolid )
+		{
+			return qfalse;
+		}
+		if ( tr.fraction < 1.0 )
+		{
+			VectorCopy( start, end );
+			end[i] += maxs[i]-(mins[i]*tr.fraction);
+			trap_Trace( &tr, start, vec3_origin, vec3_origin, end, ignore, clipmask );
+			if ( tr.allsolid || tr.startsolid )
+			{
+				return qfalse;
+			}
+			if ( tr.fraction < 1.0 )
+			{
+				return qfalse;
+			}
+			VectorCopy( end, start );
+		}
+	}
+	//expanded it, now see if it's all clear
+	trap_Trace( &tr, start, mins, maxs, start, ignore, clipmask );
+	if ( tr.allsolid || tr.startsolid )
+	{
+		return qfalse;
+	}
+	VectorCopy( start, point );
+	return qtrue;
+}
+
+extern qboolean G_FindClosestPointOnLineSegment( const vec3_t start, const vec3_t end, const vec3_t from, vec3_t result );
+float ShortestLineSegBewteen2LineSegs( vec3_t start1, vec3_t end1, vec3_t start2, vec3_t end2, vec3_t close_pnt1, vec3_t close_pnt2 )
+{
+	float	current_dist, new_dist;
+	vec3_t	new_pnt;
+	//start1, end1 : the first segment
+	//start2, end2 : the second segment
+
+	//output, one point on each segment, the closest two points on the segments.
+
+	//compute some temporaries:
+	//vec start_dif = start2 - start1
+	vec3_t	start_dif;
+	vec3_t	v1;
+	vec3_t	v2;
+	float v1v1, v2v2, v1v2;
+	float denom;
+
+	VectorSubtract( start2, start1, start_dif );
+	//vec v1 = end1 - start1
+	VectorSubtract( end1, start1, v1 );
+	//vec v2 = end2 - start2
+	VectorSubtract( end2, start2, v2 );
+	//
+	v1v1 = DotProduct( v1, v1 );
+	v2v2 = DotProduct( v2, v2 );
+	v1v2 = DotProduct( v1, v2 );
+
+	//the main computation
+
+	denom = (v1v2 * v1v2) - (v1v1 * v2v2);
+
+	//if denom is small, then skip all this and jump to the section marked below
+	if ( fabs(denom) > 0.001f )
+	{
+		float s = -( (v2v2*DotProduct( v1, start_dif )) - (v1v2*DotProduct( v2, start_dif )) ) / denom;
+		float t = ( (v1v1*DotProduct( v2, start_dif )) - (v1v2*DotProduct( v1, start_dif )) ) / denom;
+		qboolean done = qtrue;
+
+		if ( s < 0 )
+		{
+			done = qfalse;
+			s = 0;// and see note below
+		}
+
+		if ( s > 1 ) 
+		{
+			done = qfalse;
+			s = 1;// and see note below
+		}
+
+		if ( t < 0 ) 
+		{
+			done = qfalse;
+			t = 0;// and see note below
+		}
+
+		if ( t > 1 ) 
+		{
+			done = qfalse;
+			t = 1;// and see note below
+		}
+
+		//vec close_pnt1 = start1 + s * v1
+		VectorMA( start1, s, v1, close_pnt1 );
+		//vec close_pnt2 = start2 + t * v2
+		VectorMA( start2, t, v2, close_pnt2 );
+
+		current_dist = Distance( close_pnt1, close_pnt2 );
+		//now, if none of those if's fired, you are done. 
+		if ( done )
+		{
+			return current_dist;
+		}
+		//If they did fire, then we need to do some additional tests.
+
+		//What we are gonna do is see if we can find a shorter distance than the above
+		//involving the endpoints.
+	}
+	else
+	{
+		//******start here for paralell lines with current_dist = infinity****
+		current_dist = Q3_INFINITE;
+	}
+
+	//test 2 close_pnts first
+	/*
+	G_FindClosestPointOnLineSegment( start1, end1, close_pnt2, new_pnt );
+	new_dist = Distance( close_pnt2, new_pnt );
+	if ( new_dist < current_dist )
+	{//then update close_pnt1 close_pnt2 and current_dist
+		VectorCopy( new_pnt, close_pnt1 );
+		VectorCopy( close_pnt2, close_pnt2 );
+		current_dist = new_dist;
+	}
+
+	G_FindClosestPointOnLineSegment( start2, end2, close_pnt1, new_pnt );
+	new_dist = Distance( close_pnt1, new_pnt );
+	if ( new_dist < current_dist )
+	{//then update close_pnt1 close_pnt2 and current_dist
+		VectorCopy( close_pnt1, close_pnt1 );
+		VectorCopy( new_pnt, close_pnt2 );
+		current_dist = new_dist;
+	}
+	*/
+	//test all the endpoints
+	new_dist = Distance( start1, start2 );
+	if ( new_dist < current_dist )
+	{//then update close_pnt1 close_pnt2 and current_dist
+		VectorCopy( start1, close_pnt1 );
+		VectorCopy( start2, close_pnt2 );
+		current_dist = new_dist;
+	}
+
+	new_dist = Distance( start1, end2 );
+	if ( new_dist < current_dist )
+	{//then update close_pnt1 close_pnt2 and current_dist
+		VectorCopy( start1, close_pnt1 );
+		VectorCopy( end2, close_pnt2 );
+		current_dist = new_dist;
+	}
+
+	new_dist = Distance( end1, start2 );
+	if ( new_dist < current_dist )
+	{//then update close_pnt1 close_pnt2 and current_dist
+		VectorCopy( end1, close_pnt1 );
+		VectorCopy( start2, close_pnt2 );
+		current_dist = new_dist;
+	}
+
+	new_dist = Distance( end1, end2 );
+	if ( new_dist < current_dist )
+	{//then update close_pnt1 close_pnt2 and current_dist
+		VectorCopy( end1, close_pnt1 );
+		VectorCopy( end2, close_pnt2 );
+		current_dist = new_dist;
+	}
+
+	//Then we have 4 more point / segment tests
+
+	G_FindClosestPointOnLineSegment( start2, end2, start1, new_pnt );
+	new_dist = Distance( start1, new_pnt );
+	if ( new_dist < current_dist )
+	{//then update close_pnt1 close_pnt2 and current_dist
+		VectorCopy( start1, close_pnt1 );
+		VectorCopy( new_pnt, close_pnt2 );
+		current_dist = new_dist;
+	}
+
+	G_FindClosestPointOnLineSegment( start2, end2, end1, new_pnt );
+	new_dist = Distance( end1, new_pnt );
+	if ( new_dist < current_dist )
+	{//then update close_pnt1 close_pnt2 and current_dist
+		VectorCopy( end1, close_pnt1 );
+		VectorCopy( new_pnt, close_pnt2 );
+		current_dist = new_dist;
+	}
+
+	G_FindClosestPointOnLineSegment( start1, end1, start2, new_pnt );
+	new_dist = Distance( start2, new_pnt );
+	if ( new_dist < current_dist )
+	{//then update close_pnt1 close_pnt2 and current_dist
+		VectorCopy( new_pnt, close_pnt1 );
+		VectorCopy( start2, close_pnt2 );
+		current_dist = new_dist;
+	}
+
+	G_FindClosestPointOnLineSegment( start1, end1, end2, new_pnt );
+	new_dist = Distance( end2, new_pnt );
+	if ( new_dist < current_dist )
+	{//then update close_pnt1 close_pnt2 and current_dist
+		VectorCopy( new_pnt, close_pnt1 );
+		VectorCopy( end2, close_pnt2 );
+		current_dist = new_dist;
+	}
+
+	return current_dist;
+}
+
+void GetAnglesForDirection( const vec3_t p1, const vec3_t p2, vec3_t out )
+{
+	vec3_t v;
+
+	VectorSubtract( p2, p1, v );
+	vectoangles( v, out );
+}
diff --git a/codemp/game/g_vehicleTurret.c b/codemp/game/g_vehicleTurret.c
new file mode 100644
index 0000000..41a8a04
--- /dev/null
+++ b/codemp/game/g_vehicleTurret.c
@@ -0,0 +1,435 @@
+#include "g_headers.h"
+#include "bg_vehicles.h"
+#include "b_local.h"
+#include "../ghoul2/G2.h"
+
+extern void G_SetEnemy( gentity_t *self, gentity_t *enemy );
+extern void WP_CalcVehMuzzle(gentity_t *ent, int muzzleNum);
+extern gentity_t *WP_FireVehicleWeapon( gentity_t *ent, vec3_t start, vec3_t dir, vehWeaponInfo_t *vehWeapon, qboolean alt_fire, qboolean isTurretWeap );
+
+extern void G_VehMuzzleFireFX( gentity_t *ent, gentity_t *broadcaster, int muzzlesFired );
+//-----------------------------------------------------
+void VEH_TurretCheckFire( Vehicle_t *pVeh, 
+						 gentity_t *parent,
+						 //gentity_t *turretEnemy,
+						 turretStats_t *turretStats, 
+						 vehWeaponInfo_t *vehWeapon, 
+						 int turretNum, int curMuzzle )
+{
+	// if it's time to fire and we have an enemy, then gun 'em down!  pushDebounce time controls next fire time
+	if ( pVeh->m_iMuzzleTag[curMuzzle] == -1 )
+	{//invalid muzzle?
+		return;
+	}
+	
+	if ( pVeh->m_iMuzzleWait[curMuzzle] >= level.time )
+	{//can't fire yet
+		return;
+	}
+
+	if ( pVeh->turretStatus[turretNum].ammo < vehWeapon->iAmmoPerShot )
+	{//no ammo, can't fire
+		return;
+	}
+	
+	//if ( turretEnemy )
+	{
+		//FIXME: check to see if I'm aiming generally where I want to
+		int nextMuzzle = 0, muzzlesFired = (1<<curMuzzle);
+		gentity_t *missile;
+		WP_CalcVehMuzzle( parent, curMuzzle );
+
+		//FIXME: some variation in fire dir
+		missile = WP_FireVehicleWeapon( parent, pVeh->m_vMuzzlePos[curMuzzle], pVeh->m_vMuzzleDir[curMuzzle], vehWeapon, (turretNum!=0), qtrue );
+
+		//play the weapon's muzzle effect if we have one
+		G_VehMuzzleFireFX(parent, missile, muzzlesFired );
+
+		//take the ammo away
+		pVeh->turretStatus[turretNum].ammo -= vehWeapon->iAmmoPerShot;
+		//toggle to the next muzzle on this turret, if there is one
+		nextMuzzle = ((curMuzzle+1)==pVeh->m_pVehicleInfo->turret[turretNum].iMuzzle[0])?pVeh->m_pVehicleInfo->turret[turretNum].iMuzzle[1]:pVeh->m_pVehicleInfo->turret[turretNum].iMuzzle[0];
+		if ( nextMuzzle )
+		{//a valid muzzle to toggle to
+			pVeh->turretStatus[turretNum].nextMuzzle = nextMuzzle-1;//-1 because you type muzzles 1-10 in the .veh file
+		}
+		//add delay to the next muzzle so it doesn't fire right away on the next frame
+		pVeh->m_iMuzzleWait[pVeh->turretStatus[turretNum].nextMuzzle] = level.time + turretStats->iDelay;
+	}
+}
+
+void VEH_TurretAnglesToEnemy( Vehicle_t *pVeh, int curMuzzle, float fSpeed, gentity_t *turretEnemy, qboolean bAILead, vec3_t desiredAngles )
+{
+	vec3_t	enemyDir, org;
+	VectorCopy( turretEnemy->r.currentOrigin, org );
+	if ( bAILead )
+	{//we want to lead them a bit
+		vec3_t diff, velocity;
+		float dist;
+		VectorSubtract( org, pVeh->m_vMuzzlePos[curMuzzle], diff );
+		dist = VectorNormalize( diff );
+		if ( turretEnemy->client )
+		{
+			VectorCopy( turretEnemy->client->ps.velocity, velocity );
+		}
+		else
+		{
+			VectorCopy( turretEnemy->s.pos.trDelta, velocity );
+		}
+		VectorMA( org, (dist/fSpeed), velocity, org );
+	}
+
+	//FIXME: this isn't quite right, it's aiming from the muzzle, not the center of the turret...
+	VectorSubtract( org, pVeh->m_vMuzzlePos[curMuzzle], enemyDir );
+	//Get the desired absolute, world angles to our target
+	vectoangles( enemyDir, desiredAngles );
+}
+
+//-----------------------------------------------------
+qboolean VEH_TurretAim( Vehicle_t *pVeh, 
+						 gentity_t *parent, 
+						 gentity_t *turretEnemy,
+						 turretStats_t *turretStats, 
+						 vehWeaponInfo_t *vehWeapon, 
+						 int turretNum, int curMuzzle, vec3_t desiredAngles )
+//-----------------------------------------------------
+{
+	vec3_t	curAngles, addAngles, newAngles, yawAngles, pitchAngles;
+	float	aimCorrect = qfalse;
+
+	WP_CalcVehMuzzle( parent, curMuzzle );
+	//get the current absolute angles of the turret right now
+	vectoangles( pVeh->m_vMuzzleDir[curMuzzle], curAngles );
+	//subtract out the vehicle's angles to get the relative alignment
+	AnglesSubtract( curAngles, pVeh->m_vOrientation, curAngles );
+
+	if ( turretEnemy )
+	{
+		aimCorrect = qtrue;
+		// ...then we'll calculate what new aim adjustments we should attempt to make this frame
+		// Aim at enemy
+		VEH_TurretAnglesToEnemy( pVeh, curMuzzle, vehWeapon->fSpeed, turretEnemy, turretStats->bAILead, desiredAngles ); 
+	}
+	//subtract out the vehicle's angles to get the relative desired alignment
+	AnglesSubtract( desiredAngles, pVeh->m_vOrientation, desiredAngles );
+	//Now clamp the desired relative angles
+	//clamp yaw
+	desiredAngles[YAW] = AngleNormalize180( desiredAngles[YAW] );
+	if ( pVeh->m_pVehicleInfo->turret[turretNum].yawClampLeft
+		&& desiredAngles[YAW] > pVeh->m_pVehicleInfo->turret[turretNum].yawClampLeft )
+	{
+		aimCorrect = qfalse;
+		desiredAngles[YAW] = pVeh->m_pVehicleInfo->turret[turretNum].yawClampLeft;
+	}
+	if ( pVeh->m_pVehicleInfo->turret[turretNum].yawClampRight
+		&& desiredAngles[YAW] < pVeh->m_pVehicleInfo->turret[turretNum].yawClampRight )
+	{
+		aimCorrect = qfalse;
+		desiredAngles[YAW] = pVeh->m_pVehicleInfo->turret[turretNum].yawClampRight;
+	}
+	//clamp pitch
+	desiredAngles[PITCH] = AngleNormalize180( desiredAngles[PITCH] );
+	if ( pVeh->m_pVehicleInfo->turret[turretNum].pitchClampDown
+		&& desiredAngles[PITCH] > pVeh->m_pVehicleInfo->turret[turretNum].pitchClampDown )
+	{
+		aimCorrect = qfalse;
+		desiredAngles[PITCH] = pVeh->m_pVehicleInfo->turret[turretNum].pitchClampDown;
+	}
+	if ( pVeh->m_pVehicleInfo->turret[turretNum].pitchClampUp
+		&& desiredAngles[PITCH] < pVeh->m_pVehicleInfo->turret[turretNum].pitchClampUp )
+	{
+		aimCorrect = qfalse;
+		desiredAngles[PITCH] = pVeh->m_pVehicleInfo->turret[turretNum].pitchClampUp;
+	}
+	//Now get the offset we want from our current relative angles
+	AnglesSubtract( desiredAngles, curAngles, addAngles );
+	//Now cap the addAngles for our fTurnSpeed
+	if ( addAngles[PITCH] > turretStats->fTurnSpeed )
+	{
+		//aimCorrect = qfalse;//???
+		addAngles[PITCH] = turretStats->fTurnSpeed;
+	}
+	else if ( addAngles[PITCH] < -turretStats->fTurnSpeed )
+	{
+		//aimCorrect = qfalse;//???
+		addAngles[PITCH] = -turretStats->fTurnSpeed;
+	}
+	if ( addAngles[YAW] > turretStats->fTurnSpeed )
+	{
+		//aimCorrect = qfalse;//???
+		addAngles[YAW] = turretStats->fTurnSpeed;
+	}
+	else if ( addAngles[YAW] < -turretStats->fTurnSpeed )
+	{
+		//aimCorrect = qfalse;//???
+		addAngles[YAW] = -turretStats->fTurnSpeed;
+	}
+	//Now add the additional angles back in to our current relative angles
+	//FIXME: add some AI aim error randomness...?
+	newAngles[PITCH] = AngleNormalize180( curAngles[PITCH]+addAngles[PITCH] );
+	newAngles[YAW] = AngleNormalize180( curAngles[YAW]+addAngles[YAW] );
+	//Now set the bone angles to the new angles
+	//set yaw
+	if ( turretStats->yawBone )
+	{
+		VectorClear( yawAngles );
+		yawAngles[turretStats->yawAxis] = newAngles[YAW];
+		NPC_SetBoneAngles( parent, turretStats->yawBone, yawAngles );
+	}
+	//set pitch
+	if ( turretStats->pitchBone )
+	{
+		VectorClear( pitchAngles );
+		pitchAngles[turretStats->pitchAxis] = newAngles[PITCH];
+		NPC_SetBoneAngles( parent, turretStats->pitchBone, pitchAngles );
+	}
+	//force muzzle to recalc next check
+	pVeh->m_iMuzzleTime[curMuzzle] = 0;
+
+	return aimCorrect;
+}
+
+//-----------------------------------------------------
+static qboolean VEH_TurretFindEnemies( Vehicle_t *pVeh, 
+						 gentity_t *parent, 
+						 turretStats_t *turretStats, 
+						 int turretNum, int curMuzzle )
+//-----------------------------------------------------
+{
+	qboolean	found = qfalse;
+	int			i, count;
+	float		bestDist = turretStats->fAIRange * turretStats->fAIRange;
+	float		enemyDist;
+	vec3_t		enemyDir, org, org2;
+	qboolean	foundClient = qfalse;
+	gentity_t	*entity_list[MAX_GENTITIES], *target, *bestTarget = NULL;
+
+	WP_CalcVehMuzzle( parent, curMuzzle );
+	VectorCopy( pVeh->m_vMuzzlePos[curMuzzle], org2 );
+
+	count = G_RadiusList( org2, turretStats->fAIRange, parent, qtrue, entity_list );
+
+	for ( i = 0; i < count; i++ )
+	{
+		trace_t	tr;
+		target = entity_list[i];
+
+		if ( target == parent 
+			|| !target->takedamage 
+			|| target->health <= 0 
+			|| ( target->flags & FL_NOTARGET ))
+		{
+			continue;
+		}
+		if ( !target->client )
+		{// only attack clients
+			if ( !(target->flags&FL_BBRUSH)//not a breakable brush
+				|| !target->takedamage//is a bbrush, but invincible
+				|| (target->NPC_targetname&&parent->targetname&&Q_stricmp(target->NPC_targetname,parent->targetname)!=0) )//not in invicible bbrush, but can only be broken by an NPC that is not me
+			{
+				if ( target->s.weapon == WP_TURRET
+					&& target->classname
+					&& Q_strncmp( "misc_turret", target->classname, 11 ) == 0 )
+				{//these guys we want to shoot at
+				}
+				else
+				{
+					continue;
+				}
+			}
+			//else: we will shoot at bbrushes!
+		}
+		else if ( target->client->sess.sessionTeam == TEAM_SPECTATOR )
+		{
+			continue;
+		}
+		if ( target == ((gentity_t*)pVeh->m_pPilot)
+			|| target->r.ownerNum == parent->s.number )
+		{//don't get angry at my pilot or passengers?
+			continue;
+		}
+		if ( parent->client
+			&& parent->client->sess.sessionTeam )
+		{
+			if ( target->client )
+			{
+				if ( target->client->sess.sessionTeam == parent->client->sess.sessionTeam )
+				{ 
+					// A bot/client/NPC we don't want to shoot
+					continue;
+				}
+			}
+			else if ( target->teamnodmg == parent->client->sess.sessionTeam )
+			{//some other entity that's allied with us
+				continue;
+			}
+		}
+		if ( !trap_InPVS( org2, target->r.currentOrigin ))
+		{
+			continue;
+		}
+
+		VectorCopy( target->r.currentOrigin, org );
+
+		trap_Trace( &tr, org2, NULL, NULL, org, parent->s.number, MASK_SHOT );
+
+		if ( tr.entityNum == target->s.number
+			|| (!tr.allsolid && !tr.startsolid && tr.fraction == 1.0 ) )
+		{
+			// Only acquire if have a clear shot, Is it in range and closer than our best?
+			VectorSubtract( target->r.currentOrigin, org2, enemyDir );
+			enemyDist = VectorLengthSquared( enemyDir );
+
+			if ( enemyDist < bestDist || (target->client && !foundClient))// all things equal, keep current
+			{
+				bestTarget = target;
+				bestDist = enemyDist;
+				found = qtrue;
+				if ( target->client )
+				{//prefer clients over non-clients
+					foundClient = qtrue;
+				}
+			}
+		}
+	}
+
+	if ( found )
+	{
+		pVeh->turretStatus[turretNum].enemyEntNum = bestTarget->s.number;
+	}
+
+	return found;
+}
+
+void VEH_TurretObeyPassengerControl( Vehicle_t *pVeh, gentity_t *parent, int turretNum )
+{
+	turretStats_t *turretStats = &pVeh->m_pVehicleInfo->turret[turretNum];
+	gentity_t *passenger = (gentity_t *)pVeh->m_ppPassengers[turretStats->passengerNum-1];
+
+	if ( passenger && passenger->client && passenger->health > 0 )
+	{//a valid, living passenger client
+		vehWeaponInfo_t	*vehWeapon = &g_vehWeaponInfo[turretStats->iWeapon];
+		int	curMuzzle = pVeh->turretStatus[turretNum].nextMuzzle;
+		vec3_t aimAngles;
+		VectorCopy( passenger->client->ps.viewangles, aimAngles );
+
+		VEH_TurretAim( pVeh, parent, NULL, turretStats, vehWeapon, turretNum, curMuzzle, aimAngles );
+		if ( (passenger->client->pers.cmd.buttons&(BUTTON_ATTACK|BUTTON_ALT_ATTACK)) )
+		{//he's pressing an attack button, so fire!
+			VEH_TurretCheckFire( pVeh, parent, turretStats, vehWeapon, turretNum, curMuzzle );
+		}
+	}
+}
+
+void VEH_TurretThink( Vehicle_t *pVeh, gentity_t *parent, int turretNum )
+//-----------------------------------------------------
+{
+	qboolean	doAim = qfalse;
+	float		enemyDist, rangeSq;
+	vec3_t		enemyDir;
+	turretStats_t *turretStats = &pVeh->m_pVehicleInfo->turret[turretNum];
+	vehWeaponInfo_t	*vehWeapon = NULL;
+	gentity_t	*turretEnemy = NULL;
+	int			curMuzzle = 0;//?
+	
+
+	if ( !turretStats || !turretStats->iAmmoMax )
+	{//not a valid turret
+		return;
+	}
+	
+	if ( turretStats->passengerNum 
+		&& pVeh->m_iNumPassengers >= turretStats->passengerNum )
+	{//the passenger that has control of this turret is on the ship
+		VEH_TurretObeyPassengerControl( pVeh, parent, turretNum );
+		return;
+	}
+	else if ( !turretStats->bAI )//try AI
+	{//this turret does not think on its own.
+		return;
+	}
+
+	vehWeapon = &g_vehWeaponInfo[turretStats->iWeapon];
+	rangeSq = (turretStats->fAIRange*turretStats->fAIRange);
+	curMuzzle = pVeh->turretStatus[turretNum].nextMuzzle;
+
+	if ( pVeh->turretStatus[turretNum].enemyEntNum < ENTITYNUM_WORLD )
+	{
+		turretEnemy = &g_entities[pVeh->turretStatus[turretNum].enemyEntNum];
+		if ( turretEnemy->health < 0 
+			|| !turretEnemy->inuse
+			|| turretEnemy == ((gentity_t*)pVeh->m_pPilot)//enemy became my pilot///?
+			|| turretEnemy == parent
+			|| turretEnemy->r.ownerNum == parent->s.number // a passenger?
+			|| ( turretEnemy->client && turretEnemy->client->sess.sessionTeam == TEAM_SPECTATOR ) )
+		{//don't keep going after spectators, pilot, self, dead people, etc.
+			turretEnemy = NULL;
+			pVeh->turretStatus[turretNum].enemyEntNum = ENTITYNUM_NONE;
+		}
+	}
+
+	if ( pVeh->turretStatus[turretNum].enemyHoldTime < level.time )
+	{
+		if ( VEH_TurretFindEnemies( pVeh, parent, turretStats, turretNum, curMuzzle ) )
+		{
+			turretEnemy = &g_entities[pVeh->turretStatus[turretNum].enemyEntNum];
+			doAim = qtrue;
+		}
+		else if ( parent->enemy && parent->enemy->s.number < ENTITYNUM_WORLD )
+		{
+			turretEnemy = parent->enemy;
+			doAim = qtrue;
+		}
+		if ( turretEnemy )
+		{//found one
+			if ( turretEnemy->client )
+			{//hold on to clients for a min of 3 seconds
+				pVeh->turretStatus[turretNum].enemyHoldTime = level.time + 3000;
+			}
+			else
+			{//hold less
+				pVeh->turretStatus[turretNum].enemyHoldTime = level.time + 500;
+			}
+		}
+	}
+	if ( turretEnemy != NULL )
+	{
+		if ( turretEnemy->health > 0 )
+		{
+			// enemy is alive
+			WP_CalcVehMuzzle( parent, curMuzzle );
+			VectorSubtract( turretEnemy->r.currentOrigin, pVeh->m_vMuzzlePos[curMuzzle], enemyDir );
+			enemyDist = VectorLengthSquared( enemyDir );
+
+			if ( enemyDist < rangeSq )
+			{
+				// was in valid radius
+				if ( trap_InPVS( pVeh->m_vMuzzlePos[curMuzzle], turretEnemy->r.currentOrigin ) )
+				{
+					// Every now and again, check to see if we can even trace to the enemy
+					trace_t tr;
+					vec3_t start, end;
+					VectorCopy( pVeh->m_vMuzzlePos[curMuzzle], start );
+
+					VectorCopy( turretEnemy->r.currentOrigin, end );
+					trap_Trace( &tr, start, NULL, NULL, end, parent->s.number, MASK_SHOT );
+
+					if ( tr.entityNum == turretEnemy->s.number
+						|| (!tr.allsolid && !tr.startsolid ) )
+					{
+						doAim = qtrue;	// Can see our enemy
+					}
+				}
+			}
+		}
+	}
+
+	if ( doAim )
+	{
+		vec3_t aimAngles;
+		if ( VEH_TurretAim( pVeh, parent, turretEnemy, turretStats, vehWeapon, turretNum, curMuzzle, aimAngles ) )
+		{
+			VEH_TurretCheckFire( pVeh, parent, /*turretEnemy,*/ turretStats, vehWeapon, turretNum, curMuzzle );
+		}
+	}
+}
diff --git a/codemp/game/g_vehicles.c b/codemp/game/g_vehicles.c
new file mode 100644
index 0000000..88ac841
--- /dev/null
+++ b/codemp/game/g_vehicles.c
@@ -0,0 +1,3334 @@
+// leave this line at the top for all g_xxxx.cpp files...
+#include "g_headers.h"
+
+#include "q_shared.h"
+#include "g_local.h"
+
+#ifdef _JK2 //SP does not have this preprocessor for game like MP does
+#ifndef _JK2MP
+#define _JK2MP
+#endif
+#endif
+
+#ifndef _JK2MP
+#include "g_functions.h"
+#include "g_vehicles.h"
+#include "../CGame/cg_Local.h"
+#else
+#include "bg_vehicles.h"
+#endif
+
+#ifdef _JK2MP
+//this is really horrible, but it works! just be sure not to use any locals or anything
+//with these names (exluding bool, false, true). -rww
+#define currentAngles r.currentAngles
+#define currentOrigin r.currentOrigin
+#define mins r.mins
+#define maxs r.maxs
+#define legsAnimTimer legsTimer
+#define torsoAnimTimer torsoTimer
+#define bool qboolean
+#define false qfalse
+#define true qtrue
+
+#define sqrtf sqrt
+
+#define MOD_EXPLOSIVE MOD_SUICIDE
+#endif
+
+#ifndef _JK2MP
+#define GAME_INLINE inline
+#define bgEntity_t gentity_t
+#endif
+
+#ifdef _JK2MP
+extern gentity_t *NPC_Spawn_Do( gentity_t *ent );
+extern void NPC_SetAnim(gentity_t	*ent,int setAnimParts,int anim,int setAnimFlags);
+#else
+extern gentity_t *NPC_Spawn_Do( gentity_t *pEnt, qboolean fullSpawnNow );
+extern qboolean G_ClearLineOfSight(const vec3_t point1, const vec3_t point2, int ignore, int clipmask);
+
+extern qboolean G_SetG2PlayerModelInfo( gentity_t *pEnt, const char *modelName, const char *customSkin, const char *surfOff, const char *surfOn );
+extern void G_RemovePlayerModel( gentity_t *pEnt );
+extern void G_ChangePlayerModel( gentity_t *pEnt, const char *newModel );
+extern void G_RemoveWeaponModels( gentity_t *pEnt );
+extern void CG_ChangeWeapon( int num );
+extern float DotToSpot( vec3_t spot, vec3_t from, vec3_t fromAngles );
+extern qboolean Q3_TaskIDPending( gentity_t *ent, taskID_t taskType );
+extern void SetClientViewAngle( gentity_t *ent, vec3_t angle );
+
+extern vmCvar_t	cg_thirdPersonAlpha;
+extern vec3_t playerMins;
+extern vec3_t playerMaxs;
+extern cvar_t	*g_speederControlScheme;
+extern cvar_t *in_joystick;
+extern void PM_SetAnim(pmove_t	*pm,int setAnimParts,int anim,int setAnimFlags, int blendTime);
+extern int PM_AnimLength( int index, animNumber_t anim );
+extern void NPC_SetAnim(gentity_t	*ent,int setAnimParts,int anim,int setAnimFlags, int iBlend);
+extern void G_Knockdown( gentity_t *self, gentity_t *attacker, const vec3_t pushDir, float strength, qboolean breakSaberLock );
+#endif
+
+#ifdef _JK2MP
+#include "../namespace_begin.h"
+extern void BG_SetAnim(playerState_t *ps, animation_t *animations, int setAnimParts,int anim,int setAnimFlags, int blendTime);
+extern void BG_SetLegsAnimTimer(playerState_t *ps, int time );
+extern void BG_SetTorsoAnimTimer(playerState_t *ps, int time );
+#include "../namespace_end.h"
+void G_VehUpdateShields( gentity_t *targ );
+#ifdef QAGAME
+extern void VEH_TurretThink( Vehicle_t *pVeh, gentity_t *parent, int turretNum );
+#endif
+#else
+extern void PM_SetTorsoAnimTimer( gentity_t *ent, int *torsoAnimTimer, int time );
+extern void PM_SetLegsAnimTimer( gentity_t *ent, int *legsAnimTimer, int time );
+#endif
+
+extern qboolean BG_UnrestrainedPitchRoll( playerState_t *ps, Vehicle_t *pVeh );
+
+void Vehicle_SetAnim(gentity_t *ent,int setAnimParts,int anim,int setAnimFlags, int iBlend)
+{
+#ifdef _JK2MP
+	assert(ent->client);
+	BG_SetAnim(&ent->client->ps, bgAllAnims[ent->localAnimIndex].anims, setAnimParts, anim, setAnimFlags, iBlend);
+	ent->s.legsAnim = ent->client->ps.legsAnim;
+#else
+	NPC_SetAnim(ent, setAnimParts, anim, setAnimFlags, iBlend);
+#endif
+}
+
+void G_VehicleTrace( trace_t *results, const vec3_t start, const vec3_t tMins, const vec3_t tMaxs, const vec3_t end, int passEntityNum, int contentmask )
+{
+#ifdef _JK2MP
+	trap_Trace(results, start, tMins, tMaxs, end, passEntityNum, contentmask);
+#else
+	gi.trace( results, start, tMins, tMaxs, end, passEntityNum, contentmask );
+#endif
+}
+
+Vehicle_t *G_IsRidingVehicle( gentity_t *pEnt )
+{
+	gentity_t *ent = (gentity_t *)pEnt;
+
+	if ( ent && ent->client && ent->client->NPC_class != CLASS_VEHICLE && ent->s.m_iVehicleNum != 0 ) //ent->client && ( ent->client->ps.eFlags & EF_IN_VEHICLE ) && ent->owner )
+	{
+		return g_entities[ent->s.m_iVehicleNum].m_pVehicle;
+	}
+	return NULL;
+}
+
+
+
+float	G_CanJumpToEnemyVeh(Vehicle_t *pVeh, const usercmd_t *pUcmd )
+{
+#ifndef _JK2MP
+	gentity_t*	rider = pVeh->m_pPilot;
+
+	// If There Is An Enemy And We Are At The Same Z Height
+	//------------------------------------------------------
+	if (rider && 
+		rider->enemy && 
+		pUcmd->rightmove && 
+		fabsf(rider->enemy->currentOrigin[2] - rider->currentOrigin[2])<50.0f)
+	{
+		if (level.time<pVeh->m_safeJumpMountTime)
+		{
+			return pVeh->m_safeJumpMountRightDot;
+		}
+
+
+		// If The Enemy Is Riding Another Vehicle
+		//----------------------------------------
+		Vehicle_t*	enemyVeh = G_IsRidingVehicle(rider->enemy);
+		if (enemyVeh)
+		{
+			vec3_t	enemyFwd;
+			vec3_t	toEnemy;
+			float	toEnemyDistance;
+			vec3_t	riderFwd;
+			vec3_t	riderRight;
+			float	riderRightDot;
+
+			// If He Is Close Enough And Going The Same Speed
+			//------------------------------------------------
+			VectorSubtract(rider->enemy->currentOrigin, rider->currentOrigin, toEnemy);
+		 	toEnemyDistance = VectorNormalize(toEnemy);
+			if (toEnemyDistance<70.0f && 
+				pVeh->m_pParentEntity->resultspeed>100.0f &&
+				fabsf(pVeh->m_pParentEntity->resultspeed - enemyVeh->m_pParentEntity->resultspeed)<100.0f)
+			{
+				// If He Is Either To The Left Or Right Of Me
+				//--------------------------------------------
+				AngleVectors(rider->currentAngles, riderFwd, riderRight, 0);
+				riderRightDot = DotProduct(riderRight, toEnemy);
+				if ((pUcmd->rightmove>0 && riderRightDot>0.2) || (pUcmd->rightmove<0 &&riderRightDot<-0.2))
+				{
+					// If We Are Both Going About The Same Direction
+					//-----------------------------------------------
+					AngleVectors(rider->enemy->currentAngles, enemyFwd, 0, 0);
+					if (DotProduct(enemyFwd, riderFwd)>0.2f)
+					{
+						pVeh->m_safeJumpMountTime = level.time + Q_irand(3000, 4000);	// Ok, now you get a 3 sec window
+						pVeh->m_safeJumpMountRightDot = riderRightDot;
+						return riderRightDot;
+					}// Same Direction?
+				}// To Left Or Right?
+			}// Close Enough & Same Speed?
+		}// Enemy Riding A Vehicle?
+	}// Has Enemy And On Same Z-Height
+#endif
+	return 0.0f;
+}
+
+// Spawn this vehicle into the world.
+void G_VehicleSpawn( gentity_t *self )
+{
+	float yaw;
+	gentity_t *vehEnt;
+
+	VectorCopy( self->currentOrigin, self->s.origin );
+
+#ifdef _JK2MP
+	trap_LinkEntity( self );
+#else
+	gi.linkentity( self );
+#endif
+
+	if ( !self->count )
+	{
+		self->count = 1;
+	}
+
+	//save this because self gets removed in next func
+	yaw = self->s.angles[YAW];
+	
+#ifdef _JK2MP
+	vehEnt = NPC_Spawn_Do( self );
+#else
+	vehEnt = NPC_Spawn_Do( self, qtrue );
+#endif
+	
+	if ( !vehEnt )
+	{
+		return;//return NULL;
+	}
+	
+	vehEnt->s.angles[YAW] = yaw;
+	if ( vehEnt->m_pVehicle->m_pVehicleInfo->type != VH_ANIMAL )
+	{
+		vehEnt->NPC->behaviorState = BS_CINEMATIC;
+	}
+
+#ifdef _JK2MP //special check in case someone disconnects/dies while boarding
+	if (vehEnt->spawnflags & 1)
+	{ //die without pilot
+		if (!vehEnt->damage)
+		{ //default 10 sec
+			vehEnt->damage = 10000;
+		}
+		if (!vehEnt->speed)
+		{ //default 512 units
+			vehEnt->speed = 512.0f;
+		}
+		vehEnt->m_pVehicle->m_iPilotTime = level.time + vehEnt->damage;
+	}
+#else
+	if (vehEnt->spawnflags & 1)
+	{ //die without pilot
+		vehEnt->m_pVehicle->m_iPilotTime = level.time + vehEnt->endFrame;
+	}
+#endif
+	//return vehEnt;
+}
+
+// Attachs an entity to the vehicle it's riding (it's owner).
+void G_AttachToVehicle( gentity_t *pEnt, usercmd_t **ucmd )
+{
+	gentity_t		*vehEnt;
+	mdxaBone_t		boltMatrix;
+	gentity_t		*ent;
+#ifdef _JK2MP
+	int				crotchBolt;
+#endif
+
+	if ( !pEnt || !ucmd )
+		return;
+
+	ent = (gentity_t *)pEnt;
+
+#ifdef _JK2MP
+	vehEnt = &g_entities[ent->r.ownerNum];
+#else
+	vehEnt = ent->owner;
+#endif
+	ent->waypoint = vehEnt->waypoint; // take the veh's waypoint as your own
+
+	if ( !vehEnt->m_pVehicle )
+		return;
+
+#ifdef _JK2MP
+	crotchBolt = trap_G2API_AddBolt(vehEnt->ghoul2, 0, "*driver");
+
+	// Get the driver tag.
+	trap_G2API_GetBoltMatrix( vehEnt->ghoul2, 0, crotchBolt, &boltMatrix,
+							vehEnt->m_pVehicle->m_vOrientation, vehEnt->currentOrigin,
+							level.time, NULL, vehEnt->modelScale );
+	BG_GiveMeVectorFromMatrix( &boltMatrix, ORIGIN, ent->client->ps.origin );
+	G_SetOrigin(ent, ent->client->ps.origin);
+	trap_LinkEntity( ent );
+#else
+	// Get the driver tag.
+	gi.G2API_GetBoltMatrix( vehEnt->ghoul2, vehEnt->playerModel, vehEnt->crotchBolt, &boltMatrix,
+							vehEnt->m_pVehicle->m_vOrientation, vehEnt->currentOrigin,
+							(cg.time?cg.time:level.time), NULL, vehEnt->s.modelScale );
+	gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, ent->client->ps.origin );
+	gi.linkentity( ent );
+#endif
+}
+
+#ifndef _JK2MP
+void G_KnockOffVehicle( gentity_t *pRider, gentity_t *self, qboolean bPull )
+{
+	Vehicle_t *pVeh = NULL;
+	vec3_t riderAngles, fDir, rDir, dir2Me;
+	float	fDot, rDot;
+
+	if ( !pRider || !pRider->client )
+	{
+		return;
+	}
+	
+	pVeh = G_IsRidingVehicle( pRider );
+
+	if ( !pVeh || !pVeh->m_pVehicleInfo )
+	{
+		return;
+	}
+
+	VectorCopy( pRider->currentAngles, riderAngles );
+	riderAngles[0] = 0;
+	AngleVectors( riderAngles, fDir, rDir, NULL );
+	VectorSubtract( self->currentOrigin, pRider->currentOrigin, dir2Me );
+	dir2Me[2] = 0;
+	VectorNormalize( dir2Me );
+	fDot = DotProduct( fDir, dir2Me );
+	if ( fDot >= 0.5f )
+	{//I'm in front of them
+		if ( bPull )
+		{//pull them foward
+			pVeh->m_EjectDir = VEH_EJECT_FRONT;
+		}
+		else
+		{//push them back
+			pVeh->m_EjectDir = VEH_EJECT_REAR;
+		}
+	}
+	else if ( fDot <= -0.5f )
+	{//I'm behind them
+		if ( bPull )
+		{//pull them back
+			pVeh->m_EjectDir = VEH_EJECT_REAR;
+		}
+		else
+		{//push them forward
+			pVeh->m_EjectDir = VEH_EJECT_FRONT;
+		}
+	}
+	else
+	{//to the side of them
+		rDot = DotProduct( fDir, dir2Me );
+		if ( rDot >= 0.0f )
+		{//to the right
+			if ( bPull )
+			{//pull them right
+				pVeh->m_EjectDir = VEH_EJECT_RIGHT;
+			}
+			else
+			{//push them left
+				pVeh->m_EjectDir = VEH_EJECT_LEFT;
+			}
+		}
+		else
+		{//to the left
+			if ( bPull )
+			{//pull them left
+				pVeh->m_EjectDir = VEH_EJECT_LEFT;
+			}
+			else
+			{//push them right
+				pVeh->m_EjectDir = VEH_EJECT_RIGHT;
+			}
+		}
+	}
+	//now forcibly eject them
+	pVeh->m_pVehicleInfo->Eject( pVeh, pRider, qtrue );
+}
+#endif
+
+#ifndef _JK2MP //don't want this in mp at least for now
+void G_DrivableATSTDie( gentity_t *self )
+{
+}
+
+void G_DriveATST( gentity_t *pEnt, gentity_t *atst )
+{
+	if ( pEnt->NPC_type && pEnt->client && (pEnt->client->NPC_class == CLASS_ATST) )
+	{//already an atst, switch back
+		//open hatch
+		G_RemovePlayerModel( pEnt );
+		pEnt->NPC_type = "player";
+		pEnt->client->NPC_class = CLASS_PLAYER;
+		pEnt->flags &= ~FL_SHIELDED;
+		pEnt->client->ps.eFlags &= ~EF_IN_ATST;
+		//size
+		VectorCopy( playerMins, pEnt->mins );
+		VectorCopy( playerMaxs, pEnt->maxs );
+		pEnt->client->crouchheight = CROUCH_MAXS_2;
+		pEnt->client->standheight = DEFAULT_MAXS_2;
+		G_ChangePlayerModel( pEnt, pEnt->NPC_type );
+		//G_SetG2PlayerModel( pEnt, pEnt->NPC_type, NULL, NULL, NULL );
+
+		//FIXME: reset/4 their weapon
+		pEnt->client->ps.stats[STAT_WEAPONS] &= ~(( 1 << WP_ATST_MAIN )|( 1 << WP_ATST_SIDE ));
+		pEnt->client->ps.ammo[weaponData[WP_ATST_MAIN].ammoIndex] = 0;
+		pEnt->client->ps.ammo[weaponData[WP_ATST_SIDE].ammoIndex] = 0;
+		CG_ChangeWeapon( WP_BLASTER );
+		//camera
+		//if ( pEnt->client->ps.weapon != WP_SABER )
+		{
+			gi.cvar_set( "cg_thirdperson", "0" );
+		}
+		cg.overrides.active &= ~(CG_OVERRIDE_3RD_PERSON_RNG|CG_OVERRIDE_3RD_PERSON_VOF|CG_OVERRIDE_3RD_PERSON_POF|CG_OVERRIDE_3RD_PERSON_APH);
+		cg.overrides.thirdPersonRange = cg.overrides.thirdPersonVertOffset = cg.overrides.thirdPersonPitchOffset = 0;
+		cg.overrides.thirdPersonAlpha = cg_thirdPersonAlpha.value;
+		pEnt->client->ps.viewheight = pEnt->maxs[2] + STANDARD_VIEWHEIGHT_OFFSET;
+		//pEnt->mass = 10;
+	}
+	else
+	{//become an atst
+		pEnt->NPC_type = "atst";
+		pEnt->client->NPC_class = CLASS_ATST;
+		pEnt->client->ps.eFlags |= EF_IN_ATST;
+		pEnt->flags |= FL_SHIELDED;
+		//size
+		VectorSet( pEnt->mins, ATST_MINS0, ATST_MINS1, ATST_MINS2 );
+		VectorSet( pEnt->maxs, ATST_MAXS0, ATST_MAXS1, ATST_MAXS2 );
+		pEnt->client->crouchheight = ATST_MAXS2;
+		pEnt->client->standheight = ATST_MAXS2;
+		if ( !atst )
+		{//no pEnt to copy from
+			G_ChangePlayerModel( pEnt, "atst" );
+			//G_SetG2PlayerModel( pEnt, "atst", NULL, NULL, NULL );
+			NPC_SetAnim( pEnt, SETANIM_BOTH, BOTH_STAND1, SETANIM_FLAG_OVERRIDE, 200 );
+		}
+		else
+		{
+			G_RemovePlayerModel( pEnt );
+			G_RemoveWeaponModels( pEnt );
+			gi.G2API_CopyGhoul2Instance( atst->ghoul2, pEnt->ghoul2 );
+			pEnt->playerModel = 0;
+			G_SetG2PlayerModelInfo( pEnt, "atst", NULL, NULL, NULL );
+			//turn off hatch underside
+			gi.G2API_SetSurfaceOnOff( &pEnt->ghoul2[pEnt->playerModel], "head_hatchcover", 0x00000002/*G2SURFACEFLAG_OFF*/ );
+			G_Sound( pEnt, G_SoundIndex( "sound/chars/atst/atst_hatch_close" ));
+		}
+		pEnt->s.radius = 320;
+		//weapon
+		gitem_t	*item = FindItemForWeapon( WP_ATST_MAIN );	//precache the weapon
+		CG_RegisterItemSounds( (item-bg_itemlist) );
+		CG_RegisterItemVisuals( (item-bg_itemlist) );
+		item = FindItemForWeapon( WP_ATST_SIDE );	//precache the weapon
+		CG_RegisterItemSounds( (item-bg_itemlist) );
+		CG_RegisterItemVisuals( (item-bg_itemlist) );
+		pEnt->client->ps.stats[STAT_WEAPONS] |= ( 1 << WP_ATST_MAIN )|( 1 << WP_ATST_SIDE );
+		pEnt->client->ps.ammo[weaponData[WP_ATST_MAIN].ammoIndex] = ammoData[weaponData[WP_ATST_MAIN].ammoIndex].max;
+		pEnt->client->ps.ammo[weaponData[WP_ATST_SIDE].ammoIndex] = ammoData[weaponData[WP_ATST_SIDE].ammoIndex].max;
+		CG_ChangeWeapon( WP_ATST_MAIN );
+		//HACKHACKHACKTEMP
+		item = FindItemForWeapon( WP_EMPLACED_GUN );
+		CG_RegisterItemSounds( (item-bg_itemlist) );
+		CG_RegisterItemVisuals( (item-bg_itemlist) );
+		item = FindItemForWeapon( WP_ROCKET_LAUNCHER );
+		CG_RegisterItemSounds( (item-bg_itemlist) );
+		CG_RegisterItemVisuals( (item-bg_itemlist) );
+		item = FindItemForWeapon( WP_BOWCASTER );
+		CG_RegisterItemSounds( (item-bg_itemlist) );
+		CG_RegisterItemVisuals( (item-bg_itemlist) );
+		//HACKHACKHACKTEMP
+		//FIXME: these get lost in load/save!  Must use variables that are set every frame or saved/loaded
+		//camera
+		gi.cvar_set( "cg_thirdperson", "1" );
+		cg.overrides.active |= CG_OVERRIDE_3RD_PERSON_RNG;
+		cg.overrides.thirdPersonRange = 240;
+		//cg.overrides.thirdPersonVertOffset = 100;
+		//cg.overrides.thirdPersonPitchOffset = -30;
+		//FIXME: this gets stomped in pmove?
+		pEnt->client->ps.viewheight = 120;
+		//FIXME: setting these broke things very badly...?
+		//pEnt->client->standheight = 200;
+		//pEnt->client->crouchheight = 200;
+		//pEnt->mass = 300;
+		//movement
+		//pEnt->client->ps.speed = 0;//FIXME: override speed?
+		//FIXME: slow turn turning/can't turn if not moving?
+	}
+}
+#endif //_JK2MP
+
+// Animate the vehicle and it's riders.
+void Animate( Vehicle_t *pVeh )
+{
+	// Validate a pilot rider.
+	if ( pVeh->m_pPilot )
+	{
+		if (pVeh->m_pVehicleInfo->AnimateRiders)
+		{
+			pVeh->m_pVehicleInfo->AnimateRiders( pVeh );
+		}
+	}
+
+	pVeh->m_pVehicleInfo->AnimateVehicle( pVeh );
+}
+
+// Determine whether this entity is able to board this vehicle or not.
+bool ValidateBoard( Vehicle_t *pVeh, bgEntity_t *pEnt )
+{
+	// Determine where the entity is entering the vehicle from (left, right, or back).
+	vec3_t vVehToEnt;
+	vec3_t vVehDir;
+	const gentity_t *parent = (gentity_t *)pVeh->m_pParentEntity;
+	const gentity_t *ent = (gentity_t *)pEnt;
+	vec3_t vVehAngles;
+	float fDot;
+
+	if ( pVeh->m_iDieTime>0)
+	{
+		return false;
+	}
+
+	if ( pVeh->m_pPilot != NULL )
+	{//already have a driver!
+		if ( pVeh->m_pVehicleInfo->type == VH_FIGHTER )
+		{//I know, I know, this should by in the fighters's validateboard()
+			//can never steal a fighter from it's pilot
+			if ( pVeh->m_iNumPassengers < pVeh->m_pVehicleInfo->maxPassengers )
+			{
+				return true;
+			}
+			else
+			{
+				return false;
+			}
+		}
+		else if ( pVeh->m_pVehicleInfo->type == VH_WALKER )
+		{//I know, I know, this should by in the walker's validateboard()
+			if ( !ent->client || ent->client->ps.groundEntityNum != parent->s.number )
+			{//can only steal an occupied AT-ST if you're on top (by the hatch)
+				return false;
+			}
+		}
+		else if (pVeh->m_pVehicleInfo->type == VH_SPEEDER)
+		{//you can only steal the bike from the driver if you landed on the driver or bike
+			return (pVeh->m_iBoarding==VEH_MOUNT_THROW_LEFT || pVeh->m_iBoarding==VEH_MOUNT_THROW_RIGHT);
+		}
+	}
+	// Yes, you shouldn't have put this here (you 'should' have made an 'overriden' ValidateBoard func), but in this
+	// instance it's more than adequate (which is why I do it too :-). Making a whole other function for this is silly.
+	else if ( pVeh->m_pVehicleInfo->type == VH_FIGHTER )
+	{
+		// If you're a fighter, you allow everyone to enter you from all directions.
+		return true;
+	}
+
+	// Clear out all orientation axis except for the yaw.
+	VectorSet(vVehAngles, 0, parent->currentAngles[YAW], 0);
+
+	// Vector from Entity to Vehicle.
+	VectorSubtract( ent->currentOrigin, parent->currentOrigin, vVehToEnt );
+	vVehToEnt[2] = 0;
+	VectorNormalize( vVehToEnt );
+
+	// Get the right vector.
+	AngleVectors( vVehAngles, NULL, vVehDir, NULL ); 
+	VectorNormalize( vVehDir );
+
+	// Find the angle between the vehicle right vector and the vehicle to entity vector.
+	fDot = DotProduct( vVehToEnt, vVehDir );
+
+	// If the entity is within a certain angle to the left of the vehicle...
+	if ( fDot >= 0.5f )
+	{
+		// Right board.
+		pVeh->m_iBoarding = -2;
+	}
+	else if ( fDot <= -0.5f )
+	{
+		// Left board.
+		pVeh->m_iBoarding = -1;
+	}
+	// Maybe they're trying to board from the back...
+	else
+	{
+		// The forward vector of the vehicle.
+	//	AngleVectors( vVehAngles, vVehDir, NULL, NULL ); 
+	//	VectorNormalize( vVehDir );
+
+		// Find the angle between the vehicle forward and the vehicle to entity vector.
+	//	fDot = DotProduct( vVehToEnt, vVehDir );
+
+		// If the entity is within a certain angle behind the vehicle...
+		//if ( fDot <= -0.85f )
+		{
+			// Jump board.
+			pVeh->m_iBoarding = -3;
+		}
+	}
+
+	// If for some reason we couldn't board, leave...
+	if ( pVeh->m_iBoarding > -1 )
+		return false;
+
+	return true;
+}
+
+void FighterStorePilotViewAngles( Vehicle_t *pVeh, bgEntity_t *parent )
+{
+	playerState_t *riderPS;
+#ifdef _JK2MP
+	bgEntity_t *rider = NULL;
+	if (parent->s.owner != ENTITYNUM_NONE)
+	{
+		rider = PM_BGEntForNum(parent->s.owner); //&g_entities[parent->r.ownerNum];
+	}
+#else
+	gentity_t *rider = parent->owner;
+#endif
+
+#ifdef _JK2MP
+	if ( !rider )
+#else
+	if ( !rider || !rider->client )
+#endif
+	{
+		rider = parent;
+	}
+
+#ifdef _JK2MP
+	riderPS = rider->playerState;
+#else
+	riderPS = &rider->client->ps;
+#endif
+	VectorClear( pVeh->m_vPrevRiderViewAngles );
+	pVeh->m_vPrevRiderViewAngles[YAW] = AngleNormalize180(riderPS->viewangles[YAW]);
+}
+
+// Board this Vehicle (get on). The first entity to board an empty vehicle becomes the Pilot.
+bool Board( Vehicle_t *pVeh, bgEntity_t *pEnt )
+{
+	vec3_t vPlayerDir;
+	gentity_t *ent = (gentity_t *)pEnt;
+	gentity_t *parent = (gentity_t *)pVeh->m_pParentEntity;
+
+	// If it's not a valid entity, OR if the vehicle is blowing up (it's dead), OR it's not
+	// empty, OR we're already being boarded, OR the person trying to get on us is already
+	// in a vehicle (that was a fun bug :-), leave!
+	if ( !ent || parent->health <= 0 /*|| !( parent->client->ps.eFlags & EF_EMPTY_VEHICLE )*/ || (pVeh->m_iBoarding > 0) ||
+#ifdef _JK2MP
+		 ( ent->client->ps.m_iVehicleNum ) )
+#else
+		 ( ent->s.m_iVehicleNum != 0 ) )
+#endif
+		return false;
+
+	// Bucking so we can't do anything (NOTE: Should probably be a better name since fighters don't buck...).
+	if ( pVeh->m_ulFlags & VEH_BUCKING )
+		return false;
+
+	// Validate the entity's ability to board this vehicle.
+	if ( !pVeh->m_pVehicleInfo->ValidateBoard( pVeh, pEnt ) )
+		return false;
+
+	// FIXME FIXME!!! Ask Mike monday where ent->client->ps.eFlags might be getting changed!!! It is always 0 (when it should
+	// be 1024) so a person riding a vehicle is able to ride another vehicle!!!!!!!!
+
+	// Tell everybody their status.
+	// ALWAYS let the player be the pilot.
+	if ( ent->s.number < MAX_CLIENTS )
+	{
+		pVeh->m_pOldPilot = pVeh->m_pPilot;
+
+
+#ifdef _JK2MP
+		if ( !pVeh->m_pPilot )
+		{ //become the pilot, if there isn't one now
+			pVeh->m_pVehicleInfo->SetPilot( pVeh, (bgEntity_t *)ent );
+		}
+		// If we're not yet full...
+		else if ( pVeh->m_iNumPassengers < pVeh->m_pVehicleInfo->maxPassengers )
+		{
+			int i;
+			// Find an empty slot and put that passenger here.
+			for ( i = 0; i < pVeh->m_pVehicleInfo->maxPassengers; i++ )
+			{
+				if ( pVeh->m_ppPassengers[i] == NULL )
+				{
+					pVeh->m_ppPassengers[i] = (bgEntity_t *)ent;
+#ifdef QAGAME
+					//Server just needs to tell client which passengernum he is
+					if ( ent->client )
+					{
+						ent->client->ps.generic1 = i+1;
+					}
+#endif
+					break;
+				}
+			}
+			pVeh->m_iNumPassengers++;
+		}
+		// We're full, sorry...
+		else
+		{
+			return false;
+		}
+		ent->s.m_iVehicleNum = parent->s.number;
+		if (ent->client)
+		{
+			ent->client->ps.m_iVehicleNum = ent->s.m_iVehicleNum;
+		}
+		if ( pVeh->m_pPilot == (bgEntity_t *)ent )
+		{
+			parent->r.ownerNum = ent->s.number;
+			parent->s.owner = parent->r.ownerNum; //for prediction
+		}
+#else
+		pVeh->m_pVehicleInfo->SetPilot( pVeh, ent );
+		ent->s.m_iVehicleNum = parent->s.number;
+		parent->owner = ent;
+#endif
+
+#ifdef QAGAME		
+		{
+			gentity_t *gParent = (gentity_t *)parent;
+			if ( (gParent->spawnflags&2) )
+			{//was being suspended
+				gParent->spawnflags &= ~2;//SUSPENDED - clear this spawnflag, no longer docked, okay to free-fall if not in space
+				//gParent->client->ps.eFlags &= ~EF_RADAROBJECT;
+				G_Sound( gParent, CHAN_AUTO, G_SoundIndex( "sound/vehicles/common/release.wav" ) );
+				if ( gParent->fly_sound_debounce_time )
+				{//we should drop like a rock for a few seconds
+					pVeh->m_iDropTime = level.time + gParent->fly_sound_debounce_time;
+				}
+			}
+		}
+#endif
+
+#ifndef _JK2MP
+		gi.cvar_set( "cg_thirdperson", "1" );								//go to third person
+		CG_CenterPrint( "@SP_INGAME_EXIT_VIEW", SCREEN_HEIGHT * 0.95 );		//tell them how to get out!
+#endif
+
+		//FIXME: rider needs to look in vehicle's direction when he gets in
+		// Clear these since they're used to turn the vehicle now.
+		/*SetClientViewAngle( ent, pVeh->m_vOrientation );
+		memset( &parent->client->usercmd, 0, sizeof( usercmd_t ) );
+		memset( &pVeh->m_ucmd, 0, sizeof( usercmd_t ) );
+		VectorClear( parent->client->ps.viewangles );
+		VectorClear( parent->client->ps.delta_angles );*/
+
+		// Set the looping sound only when there is a pilot (when the vehicle is "on").
+		if ( pVeh->m_pVehicleInfo->soundLoop )
+		{
+#ifdef _JK2MP
+			parent->client->ps.loopSound = parent->s.loopSound = pVeh->m_pVehicleInfo->soundLoop;
+#else
+			parent->s.loopSound = pVeh->m_pVehicleInfo->soundLoop;
+#endif
+		}
+	}
+	else
+	{
+		// If there's no pilot, try to drive this vehicle.
+		if ( pVeh->m_pPilot == NULL )
+		{
+#ifdef _JK2MP
+			pVeh->m_pVehicleInfo->SetPilot( pVeh, (bgEntity_t *)ent );
+			// TODO: Set pilot should do all this stuff....
+			parent->r.ownerNum = ent->s.number;
+			parent->s.owner = parent->r.ownerNum; //for prediction
+#else
+			pVeh->m_pVehicleInfo->SetPilot( pVeh, ent );
+			// TODO: Set pilot should do all this stuff....
+			parent->owner = ent;
+#endif
+			// Set the looping sound only when there is a pilot (when the vehicle is "on").
+			if ( pVeh->m_pVehicleInfo->soundLoop )
+			{
+#ifdef _JK2MP
+				parent->client->ps.loopSound = parent->s.loopSound = pVeh->m_pVehicleInfo->soundLoop;
+#else
+				parent->s.loopSound = pVeh->m_pVehicleInfo->soundLoop;
+#endif
+			}
+
+			parent->client->ps.speed = 0;
+			memset( &pVeh->m_ucmd, 0, sizeof( usercmd_t ) );
+		}
+		// If we're not yet full...
+		else if ( pVeh->m_iNumPassengers < pVeh->m_pVehicleInfo->maxPassengers )
+		{
+			int i;
+			// Find an empty slot and put that passenger here.
+			for ( i = 0; i < pVeh->m_pVehicleInfo->maxPassengers; i++ )
+			{
+				if ( pVeh->m_ppPassengers[i] == NULL )
+				{
+#ifdef _JK2MP
+					pVeh->m_ppPassengers[i] = (bgEntity_t *)ent;
+#ifdef QAGAME
+					//Server just needs to tell client which passengernum he is
+					if ( ent->client )
+					{
+						ent->client->ps.generic1 = i+1;
+					}
+#endif
+#else
+					pVeh->m_ppPassengers[i] = ent;
+#endif
+					break;
+				}
+			}
+			pVeh->m_iNumPassengers++;
+		}
+		// We're full, sorry...
+		else
+		{
+			return false;
+		}
+	}
+	
+	// Make sure the entity knows it's in a vehicle.
+#ifdef _JK2MP
+	ent->client->ps.m_iVehicleNum = parent->s.number;
+	ent->r.ownerNum = parent->s.number;
+	ent->s.owner = ent->r.ownerNum; //for prediction
+	if (pVeh->m_pPilot == (bgEntity_t *)ent)
+	{
+		parent->client->ps.m_iVehicleNum = ent->s.number+1; //always gonna be under MAX_CLIENTS so no worries about 1 byte overflow
+	}
+#else
+	ent->s.m_iVehicleNum = parent->s.number;
+	ent->owner = parent;
+	parent->s.m_iVehicleNum = ent->s.number+1;
+#endif
+
+	//memset( &ent->client->usercmd, 0, sizeof( usercmd_t ) );
+
+	//FIXME: no saber or weapons if numHands = 2, should switch to speeder weapon, no attack anim on player
+	if ( pVeh->m_pVehicleInfo->numHands == 2 )
+	{//switch to vehicle weapon
+#ifndef _JK2MP //rwwFIXMEFIXMEFIXME
+		if (ent->s.number<MAX_CLIENTS)
+		{
+			CG_ChangeWeapon(WP_NONE);
+		}
+
+		ent->client->ps.weapon = WP_NONE;
+		G_RemoveWeaponModels( ent );
+#endif
+	}
+
+	if ( pVeh->m_pVehicleInfo->hideRider )
+	{//hide the rider
+		pVeh->m_pVehicleInfo->Ghost( pVeh, (bgEntity_t *)ent );
+	}
+
+	// Play the start sounds
+	if ( pVeh->m_pVehicleInfo->soundOn )
+	{
+#ifdef _JK2MP
+		G_Sound( parent, CHAN_AUTO, pVeh->m_pVehicleInfo->soundOn );
+#else
+		// NOTE: Use this type so it's spatialized and updates play origin as bike moves - MCG
+		G_SoundIndexOnEnt( parent, CHAN_AUTO, pVeh->m_pVehicleInfo->soundOn );
+#endif
+	}
+
+	if ( pVeh->m_pVehicleInfo->type == VH_FIGHTER )
+	{//clear their angles
+		FighterStorePilotViewAngles( pVeh, (bgEntity_t *)parent );
+	}
+	VectorCopy( pVeh->m_vOrientation, vPlayerDir );
+	vPlayerDir[ROLL] = 0;
+	SetClientViewAngle( ent, vPlayerDir );
+
+	return true;
+}
+
+bool VEH_TryEject( Vehicle_t *pVeh, 
+				  gentity_t *parent, 
+				  gentity_t *ent, 
+				  int ejectDir, 
+				  vec3_t vExitPos )
+{
+	float		fBias;
+	float		fVehDiag;
+	float		fEntDiag;
+	int			oldOwner;
+	vec3_t		vEntMins, vEntMaxs, vVehLeaveDir, vVehAngles;
+	trace_t		m_ExitTrace;
+
+	// Make sure that the entity is not 'stuck' inside the vehicle (since their bboxes will now intersect).
+	// This makes the entity leave the vehicle from the right side.
+	VectorSet(vVehAngles, 0, parent->currentAngles[YAW], 0);
+	switch ( ejectDir )
+	{
+		// Left.
+		case VEH_EJECT_LEFT:
+			AngleVectors( vVehAngles, NULL, vVehLeaveDir, NULL ); 
+			vVehLeaveDir[0] = -vVehLeaveDir[0];
+			vVehLeaveDir[1] = -vVehLeaveDir[1];
+			vVehLeaveDir[2] = -vVehLeaveDir[2];
+			break;
+		// Right.
+		case VEH_EJECT_RIGHT:
+			AngleVectors( vVehAngles, NULL, vVehLeaveDir, NULL ); 
+			break;
+		// Front.
+		case VEH_EJECT_FRONT:
+			AngleVectors( vVehAngles, vVehLeaveDir, NULL, NULL ); 
+			break;
+		// Rear.
+		case VEH_EJECT_REAR:
+			AngleVectors( vVehAngles, vVehLeaveDir, NULL, NULL ); 
+			vVehLeaveDir[0] = -vVehLeaveDir[0];
+			vVehLeaveDir[1] = -vVehLeaveDir[1];
+			vVehLeaveDir[2] = -vVehLeaveDir[2];
+			break;
+		// Top.
+		case VEH_EJECT_TOP:
+			AngleVectors( vVehAngles, NULL, NULL, vVehLeaveDir ); 
+			break;
+		// Bottom?.
+		case VEH_EJECT_BOTTOM:
+			break;
+	}
+	VectorNormalize( vVehLeaveDir );
+	//NOTE: not sure why following line was needed - MCG
+	//pVeh->m_EjectDir = VEH_EJECT_LEFT;
+
+	// Since (as of this time) the collidable geometry of the entity is just an axis 
+	// aligned box, we need to get the diagonal length of it in case we come out on that side.
+	// Diagonal Length == squareroot( squared( Sidex / 2 ) + squared( Sidey / 2 ) );
+
+	// TODO: DO diagonal for entity.
+
+	fBias = 1.0f;
+	if (pVeh->m_pVehicleInfo->type == VH_WALKER)
+	{ //hacktastic!
+		fBias += 0.2f;
+	}
+	VectorCopy( ent->currentOrigin, vExitPos );
+	fVehDiag = sqrtf( ( parent->maxs[0] * parent->maxs[0] ) + ( parent->maxs[1] * parent->maxs[1] ) );
+	VectorCopy( ent->maxs, vEntMaxs );
+#ifdef _JK2MP
+	if ( ent->s.number < MAX_CLIENTS )
+	{//for some reason, in MP, player client mins and maxs are never stored permanently, just set to these hardcoded numbers in PMove
+		vEntMaxs[0] = 15;
+		vEntMaxs[1] = 15;
+	}
+#endif
+	fEntDiag = sqrtf( ( vEntMaxs[0] * vEntMaxs[0] ) + ( vEntMaxs[1] * vEntMaxs[1] ) );
+	vVehLeaveDir[0] *= ( fVehDiag + fEntDiag ) * fBias;	// x
+	vVehLeaveDir[1] *= ( fVehDiag + fEntDiag ) * fBias;	// y
+	vVehLeaveDir[2] *= ( fVehDiag + fEntDiag ) * fBias;
+	VectorAdd( vExitPos, vVehLeaveDir, vExitPos );
+
+	//we actually could end up *not* getting off if the trace fails...
+	// Check to see if this new position is a valid place for our entity to go.
+#ifdef _JK2MP
+	VectorSet(vEntMins, -15.0f, -15.0f, DEFAULT_MINS_2);
+	VectorSet(vEntMaxs, 15.0f, 15.0f, DEFAULT_MAXS_2);
+#else
+	VectorCopy(ent->mins, vEntMins);
+	VectorCopy(ent->maxs, vEntMaxs);
+#endif
+	oldOwner = ent->r.ownerNum;
+	ent->r.ownerNum = ENTITYNUM_NONE;
+	G_VehicleTrace( &m_ExitTrace, ent->currentOrigin, vEntMins, vEntMaxs, vExitPos, ent->s.number, ent->clipmask );
+	ent->r.ownerNum = oldOwner;
+
+	if ( m_ExitTrace.allsolid//in solid
+		|| m_ExitTrace.startsolid)
+	{
+		return false;
+	}
+	// If the trace hit something, we can't go there!
+	if ( m_ExitTrace.fraction < 1.0f )
+	{//not totally clear
+#ifdef _JK2MP
+//		if ( (parent->clipmask&ent->r.contents) )//vehicle could actually get stuck on body
+#else
+		if ( (parent->clipmask&ent->contents) )//vehicle could actually get stuck on body
+#endif
+		{//the trace hit the vehicle, don't let them get out, just in case
+			return false;
+		}
+		//otherwise, use the trace.endpos
+		VectorCopy( m_ExitTrace.endpos, vExitPos );
+	}
+	return true;
+}
+
+void G_EjectDroidUnit( Vehicle_t *pVeh, qboolean kill )
+{
+	pVeh->m_pDroidUnit->s.m_iVehicleNum = ENTITYNUM_NONE;
+#ifdef _JK2MP
+	pVeh->m_pDroidUnit->s.owner = ENTITYNUM_NONE;
+#else
+	pVeh->m_pDroidUnit->owner = NULL;
+#endif
+//	pVeh->m_pDroidUnit->s.otherEntityNum2 = ENTITYNUM_NONE;
+#ifdef QAGAME
+	{
+		gentity_t *droidEnt = (gentity_t *)pVeh->m_pDroidUnit;
+		droidEnt->flags &= ~FL_UNDYING;
+		droidEnt->r.ownerNum = ENTITYNUM_NONE;
+		if ( droidEnt->client )
+		{
+			droidEnt->client->ps.m_iVehicleNum = ENTITYNUM_NONE;
+		}
+		if ( kill )
+		{//Kill them, too
+			//FIXME: proper origin, MOD and attacker (for credit/death message)?  Get from vehicle?
+			G_MuteSound(droidEnt->s.number, CHAN_VOICE);
+			G_Damage( droidEnt, NULL, NULL, NULL, droidEnt->s.origin, 10000, 0, MOD_SUICIDE );//FIXME: proper MOD?  Get from vehicle?
+		}
+	}
+#endif
+	pVeh->m_pDroidUnit = NULL;
+}
+
+// Eject the pilot from the vehicle.
+bool Eject( Vehicle_t *pVeh, bgEntity_t *pEnt, qboolean forceEject )
+{
+	gentity_t	*parent;
+	vec3_t		vExitPos;
+#ifndef _JK2MP
+	vec3_t		vPlayerDir;
+#endif
+	gentity_t	*ent = (gentity_t *)pEnt;
+	int			firstEjectDir;
+
+#ifdef _JK2MP
+	qboolean	taintedRider = qfalse;
+	qboolean	deadRider = qfalse;
+
+	if ( pEnt == pVeh->m_pDroidUnit )
+	{
+		G_EjectDroidUnit( pVeh, qfalse );
+		return true;
+	}
+
+	if (ent)
+	{
+		if (!ent->inuse || !ent->client || ent->client->pers.connected != CON_CONNECTED)
+		{
+			taintedRider = qtrue;
+			parent = (gentity_t *)pVeh->m_pParentEntity;
+			goto getItOutOfMe;
+		}
+		else if (ent->health < 1)
+		{
+			deadRider = qtrue;
+		}
+	}
+#endif
+
+	// Validate.
+	if ( !ent )
+	{
+		return false;
+	}
+	if ( !forceEject )
+	{
+		if ( !( pVeh->m_iBoarding == 0 || pVeh->m_iBoarding == -999 || ( pVeh->m_iBoarding < -3 && pVeh->m_iBoarding >= -9 ) ) )
+		{
+#ifdef _JK2MP //I don't care, if he's dead get him off even if he died while boarding
+			deadRider = qtrue;
+			pVeh->m_iBoarding = 0;
+			pVeh->m_bWasBoarding = false;
+#else
+			return false;
+#endif
+		}
+	}
+
+#ifndef _JK2MP //rwwFIXMEFIXMEFIXME
+	if (ent->s.number<MAX_CLIENTS)
+	{
+		CG_ChangeWeapon(WP_NONE);
+	}
+	ent->client->ps.weapon = WP_NONE;
+	G_RemoveWeaponModels( ent );
+#endif
+
+	parent = (gentity_t *)pVeh->m_pParentEntity;
+
+	//Try ejecting in every direction
+	if ( pVeh->m_EjectDir < VEH_EJECT_LEFT )
+	{
+		pVeh->m_EjectDir = VEH_EJECT_LEFT;
+	}
+	else if ( pVeh->m_EjectDir > VEH_EJECT_BOTTOM )
+	{
+		pVeh->m_EjectDir = VEH_EJECT_BOTTOM;
+	}
+	firstEjectDir = pVeh->m_EjectDir;
+	while ( !VEH_TryEject( pVeh, parent, ent, pVeh->m_EjectDir, vExitPos ) )
+	{
+		pVeh->m_EjectDir++;
+		if ( pVeh->m_EjectDir > VEH_EJECT_BOTTOM )
+		{
+			pVeh->m_EjectDir = VEH_EJECT_LEFT;
+		}
+		if ( pVeh->m_EjectDir == firstEjectDir )
+		{//they all failed
+#ifdef _JK2MP
+			if (!deadRider)
+			{ //if he's dead.. just shove him in solid, who cares.
+				return false;
+			}
+#endif
+			if ( forceEject )
+			{//we want to always get out, just eject him here
+				VectorCopy( ent->currentOrigin, vExitPos );
+				break;
+			}
+			else
+			{//can't eject
+				return false;
+			}
+		}
+	}
+
+	// Move them to the exit position.
+	G_SetOrigin( ent, vExitPos );
+#ifdef _JK2MP
+	VectorCopy(ent->currentOrigin, ent->client->ps.origin);
+	trap_LinkEntity( ent );
+#else
+	gi.linkentity( ent );
+#endif
+
+	// If it's the player, stop overrides.
+	if ( ent->s.number < MAX_CLIENTS )
+	{
+#ifndef _JK2MP
+		cg.overrides.active = 0;
+#else
+
+#endif
+	}
+
+#ifdef _JK2MP //in MP if someone disconnects on us, we still have to clear our owner
+getItOutOfMe:
+#endif
+
+	// If he's the pilot...
+	if ( (gentity_t *)pVeh->m_pPilot == ent )
+	{
+#ifdef _JK2MP
+		int j = 0;
+#endif
+
+		pVeh->m_pPilot = NULL;
+#ifdef _JK2MP
+		parent->r.ownerNum = ENTITYNUM_NONE;
+		parent->s.owner = parent->r.ownerNum; //for prediction
+
+		//keep these current angles
+		//SetClientViewAngle( parent, pVeh->m_vOrientation );
+		memset( &parent->client->pers.cmd, 0, sizeof( usercmd_t ) );
+#else
+		parent->owner = NULL;
+
+		//keep these current angles
+		//SetClientViewAngle( parent, pVeh->m_vOrientation );
+		memset( &parent->client->usercmd, 0, sizeof( usercmd_t ) );
+#endif
+		memset( &pVeh->m_ucmd, 0, sizeof( usercmd_t ) );
+
+#ifdef _JK2MP //if there are some passengers, promote the first passenger to pilot
+		while (j < pVeh->m_iNumPassengers)
+		{
+			if (pVeh->m_ppPassengers[j])
+			{
+				int k = 1;
+				pVeh->m_pVehicleInfo->SetPilot( pVeh, pVeh->m_ppPassengers[j] );
+				parent->r.ownerNum = pVeh->m_ppPassengers[j]->s.number;
+				parent->s.owner = parent->r.ownerNum; //for prediction
+				parent->client->ps.m_iVehicleNum = pVeh->m_ppPassengers[j]->s.number+1;
+
+				//rearrange the passenger slots now..
+#ifdef QAGAME
+				//Server just needs to tell client he's not a passenger anymore
+				if ( ((gentity_t *)pVeh->m_ppPassengers[j])->client )
+				{
+					((gentity_t *)pVeh->m_ppPassengers[j])->client->ps.generic1 = 0;
+				}
+#endif
+				pVeh->m_ppPassengers[j] = NULL;
+				while (k < pVeh->m_iNumPassengers)
+				{
+					if (!pVeh->m_ppPassengers[k-1])
+					{ //move down
+						pVeh->m_ppPassengers[k-1] = pVeh->m_ppPassengers[k];
+						pVeh->m_ppPassengers[k] = NULL;
+#ifdef QAGAME
+						//Server just needs to tell client which passenger he is
+						if ( ((gentity_t *)pVeh->m_ppPassengers[k-1])->client )
+						{
+							((gentity_t *)pVeh->m_ppPassengers[k-1])->client->ps.generic1 = k;
+						}
+#endif
+					}
+					k++;
+				}
+				pVeh->m_iNumPassengers--;
+
+				break;
+			}
+			j++;
+		}
+#endif
+	}
+	else if (ent==(gentity_t *)pVeh->m_pOldPilot)
+	{
+		pVeh->m_pOldPilot = 0;
+	}
+	else
+	{
+		int i;
+		// Look for this guy in the passenger list.
+		for ( i = 0; i < pVeh->m_pVehicleInfo->maxPassengers; i++ )
+		{
+			// If we found him...
+			if ( (gentity_t *)pVeh->m_ppPassengers[i] == ent )
+			{
+#ifdef QAGAME
+				//Server just needs to tell client he's not a passenger anymore
+				if ( ((gentity_t *)pVeh->m_ppPassengers[i])->client )
+				{
+					((gentity_t *)pVeh->m_ppPassengers[i])->client->ps.generic1 = 0;
+				}
+#endif
+				pVeh->m_ppPassengers[i] = NULL;
+				pVeh->m_iNumPassengers--;
+				break;
+			}
+		}
+
+		// Didn't find him, can't eject because they aren't in the vehicle (hopefully)!
+		if ( i == pVeh->m_pVehicleInfo->maxPassengers )
+		{
+			return false;
+		}
+	}
+
+#ifdef _JK2MP //I hate adding these!
+	if (!taintedRider)
+	{
+#endif
+		if ( pVeh->m_pVehicleInfo->hideRider )
+		{
+			pVeh->m_pVehicleInfo->UnGhost( pVeh, (bgEntity_t *)ent );
+		}
+#ifdef _JK2MP
+	}
+#endif
+
+	// If the vehicle now has no pilot...
+	if ( pVeh->m_pPilot == NULL  )
+	{
+#ifdef _JK2MP
+		parent->client->ps.loopSound = parent->s.loopSound = 0;
+#else
+		parent->s.loopSound = 0;
+#endif
+		// Completely empty vehicle...?
+		if ( pVeh->m_iNumPassengers == 0 )
+		{
+#ifdef _JK2MP
+			parent->client->ps.m_iVehicleNum = 0;
+#else
+			parent->s.m_iVehicleNum = 0;
+#endif
+		}
+	}
+
+#ifdef _JK2MP
+	if (taintedRider)
+	{ //you can go now
+		pVeh->m_iBoarding = level.time + 1000;
+		return true;
+	}
+#endif
+
+	// Client not in a vehicle.
+#ifdef _JK2MP
+	ent->client->ps.m_iVehicleNum = 0;
+	ent->r.ownerNum = ENTITYNUM_NONE;
+	ent->s.owner = ent->r.ownerNum; //for prediction
+
+	ent->client->ps.viewangles[PITCH] = 0.0f;
+	ent->client->ps.viewangles[ROLL] = 0.0f;
+	ent->client->ps.viewangles[YAW] = pVeh->m_vOrientation[YAW];
+	SetClientViewAngle(ent, ent->client->ps.viewangles);
+
+	if (ent->client->solidHack)
+	{
+		ent->client->solidHack = 0;
+		ent->r.contents = CONTENTS_BODY;
+	}
+#else
+	ent->owner = NULL;	
+#endif
+	ent->s.m_iVehicleNum = 0;
+
+	// Jump out.
+/*	if ( ent->client->ps.velocity[2] < JUMP_VELOCITY )
+	{
+		ent->client->ps.velocity[2] = JUMP_VELOCITY;
+	}
+	else
+	{
+		ent->client->ps.velocity[2] += JUMP_VELOCITY;
+	}*/
+
+	// Make sure entity is facing the direction it got off at.
+#ifndef _JK2MP
+	VectorCopy( pVeh->m_vOrientation, vPlayerDir );
+	vPlayerDir[ROLL] = 0;
+	SetClientViewAngle( ent, vPlayerDir );
+#endif
+
+	//if was using vehicle weapon, remove it and switch to normal weapon when hop out...
+	if ( ent->client->ps.weapon == WP_NONE )
+	{//FIXME: check against this vehicle's gun from the g_vehicleInfo table
+		//remove the vehicle's weapon from me
+		//ent->client->ps.stats[STAT_WEAPONS] &= ~( 1 << WP_EMPLACED_GUN );
+		//ent->client->ps.ammo[weaponData[WP_EMPLACED_GUN].ammoIndex] = 0;//maybe store this ammo on the vehicle before clearing it?
+		//switch back to a normal weapon we're carrying
+		
+		//FIXME: store the weapon we were using when we got on and restore that when hop off
+/*		if ( (ent->client->ps.stats[STAT_WEAPONS]&(1<<WP_SABER)) )
+		{
+			CG_ChangeWeapon( WP_SABER );
+		}
+		else
+		{//go through all weapons and switch to highest held
+			for ( int checkWp = WP_NUM_WEAPONS-1; checkWp > WP_NONE; checkWp-- )
+			{
+				if ( (ent->client->ps.stats[STAT_WEAPONS]&(1<<checkWp)) )
+				{
+					CG_ChangeWeapon( checkWp );
+				}
+			}
+			if ( checkWp == WP_NONE )
+			{
+				CG_ChangeWeapon( WP_NONE );
+			}
+		}*/
+	}
+	else
+	{//FIXME: if they have their saber out:
+		//if dualSabers, add the second saber into the left hand
+		//saber[0] has more than one blade, turn them all on
+		//NOTE: this is because you're only allowed to use your first saber's first blade on a vehicle
+	}
+
+/*	if ( !ent->s.number && ent->client->ps.weapon != WP_SABER 
+		&& cg_gunAutoFirst.value )
+	{
+		gi.cvar_set( "cg_thirdperson", "0" );
+	}*/
+#ifdef _JK2MP
+	BG_SetLegsAnimTimer( &ent->client->ps, 0 );
+	BG_SetTorsoAnimTimer( &ent->client->ps, 0 );
+#else
+	PM_SetLegsAnimTimer( ent, &ent->client->ps.legsAnimTimer, 0 );
+	PM_SetTorsoAnimTimer( ent, &ent->client->ps.torsoAnimTimer, 0 );
+#endif
+
+	// Set how long until this vehicle can be boarded again.
+	pVeh->m_iBoarding = level.time + 1000;
+
+	return true;
+}
+
+// Eject all the inhabitants of this vehicle.
+bool EjectAll( Vehicle_t *pVeh )
+{
+	// TODO: Setup a default escape for ever vehicle type.
+
+	pVeh->m_EjectDir = VEH_EJECT_TOP;
+	// Make sure no other boarding calls exist. We MUST exit.
+	pVeh->m_iBoarding = 0;
+	pVeh->m_bWasBoarding = false;
+
+	// Throw them off.
+	if ( pVeh->m_pPilot )
+	{
+#ifdef QAGAME
+		gentity_t *pilot = (gentity_t*)pVeh->m_pPilot;
+#endif
+		pVeh->m_pVehicleInfo->Eject( pVeh, pVeh->m_pPilot, qtrue );
+#ifdef QAGAME
+		if ( pVeh->m_pVehicleInfo->killRiderOnDeath && pilot )
+		{//Kill them, too
+			//FIXME: proper origin, MOD and attacker (for credit/death message)?  Get from vehicle?
+			G_MuteSound(pilot->s.number, CHAN_VOICE);
+			G_Damage( pilot, NULL, NULL, NULL, pilot->s.origin, 10000, 0, MOD_SUICIDE );
+		}
+#endif
+	}
+	if ( pVeh->m_pOldPilot )
+	{
+#ifdef QAGAME
+		gentity_t *pilot = (gentity_t*)pVeh->m_pOldPilot;
+#endif
+		pVeh->m_pVehicleInfo->Eject( pVeh, pVeh->m_pOldPilot, qtrue );
+#ifdef QAGAME
+		if ( pVeh->m_pVehicleInfo->killRiderOnDeath && pilot )
+		{//Kill them, too
+			//FIXME: proper origin, MOD and attacker (for credit/death message)?  Get from vehicle?
+			G_MuteSound(pilot->s.number, CHAN_VOICE);
+			G_Damage( pilot, NULL, NULL, NULL, pilot->s.origin, 10000, 0, MOD_SUICIDE );
+		}
+#endif
+	}
+	if ( pVeh->m_iNumPassengers )
+	{
+		int i;
+
+		for ( i = 0; i < pVeh->m_pVehicleInfo->maxPassengers; i++ )
+		{
+			if ( pVeh->m_ppPassengers[i] )
+			{
+#ifdef QAGAME
+				gentity_t *rider = (gentity_t*)pVeh->m_ppPassengers[i];
+#endif
+				pVeh->m_pVehicleInfo->Eject( pVeh, pVeh->m_ppPassengers[i], qtrue );
+#ifdef QAGAME
+				if ( pVeh->m_pVehicleInfo->killRiderOnDeath && rider )
+				{//Kill them, too
+					//FIXME: proper origin, MOD and attacker (for credit/death message)?  Get from vehicle?
+					G_MuteSound(rider->s.number, CHAN_VOICE);
+					G_Damage( rider, NULL, NULL, NULL, rider->s.origin, 10000, 0, MOD_SUICIDE );//FIXME: proper MOD?  Get from vehicle?
+				}
+#endif
+			}
+		}
+		pVeh->m_iNumPassengers = 0;
+	}
+	
+	if ( pVeh->m_pDroidUnit )
+	{
+		G_EjectDroidUnit( pVeh, pVeh->m_pVehicleInfo->killRiderOnDeath );
+	}
+
+	return true;
+}
+
+// Start a delay until the vehicle explodes.
+static void StartDeathDelay( Vehicle_t *pVeh, int iDelayTimeOverride )
+{
+	gentity_t *parent = (gentity_t *)pVeh->m_pParentEntity;
+
+	if ( iDelayTimeOverride )
+	{
+		pVeh->m_iDieTime = level.time + iDelayTimeOverride;
+	}
+	else
+	{
+		pVeh->m_iDieTime = level.time + pVeh->m_pVehicleInfo->explosionDelay;
+	}
+
+#ifdef _JK2MP
+	if ( pVeh->m_pVehicleInfo->flammable )
+	{
+		parent->client->ps.loopSound = parent->s.loopSound = G_SoundIndex( "sound/vehicles/common/fire_lp.wav" );
+	}
+#else
+	// Armor Gone Effects (Fire)
+	//---------------------------
+	if (pVeh->m_pVehicleInfo->iArmorGoneFX)
+	{
+		if (!(pVeh->m_ulFlags&VEH_ARMORGONE) && (pVeh->m_iArmor <= 0))
+		{
+			pVeh->m_ulFlags |= VEH_ARMORGONE;
+			G_PlayEffect(pVeh->m_pVehicleInfo->iArmorGoneFX, parent->playerModel, parent->crotchBolt, parent->s.number, parent->currentOrigin, 1, qtrue);
+			parent->s.loopSound = G_SoundIndex( "sound/vehicles/common/fire_lp.wav" );
+		}
+	}
+#endif
+}
+
+// Decide whether to explode the vehicle or not.
+static void DeathUpdate( Vehicle_t *pVeh )
+{
+	gentity_t *parent = (gentity_t *)pVeh->m_pParentEntity;
+
+	if ( level.time >= pVeh->m_iDieTime )
+	{
+		// If the vehicle is not empty.
+		if ( pVeh->m_pVehicleInfo->Inhabited( pVeh ) )
+		{
+#ifndef _JK2MP
+			if (pVeh->m_pPilot)
+			{
+				pVeh->m_pPilot->client->noRagTime = -1;		// no ragdoll for you
+			}
+#endif
+
+			pVeh->m_pVehicleInfo->EjectAll( pVeh );
+#ifdef _JK2MP
+			if ( pVeh->m_pVehicleInfo->Inhabited( pVeh ) )
+			{ //if we've still got people in us, just kill the bastards
+				if ( pVeh->m_pPilot )
+				{
+					//FIXME: does this give proper credit to the enemy who shot you down?
+					G_Damage((gentity_t *)pVeh->m_pPilot, (gentity_t *)pVeh->m_pParentEntity, (gentity_t *)pVeh->m_pParentEntity,
+						NULL, pVeh->m_pParentEntity->playerState->origin, 999, DAMAGE_NO_PROTECTION, MOD_EXPLOSIVE);
+				}
+				if ( pVeh->m_iNumPassengers )
+				{
+					int i;
+
+					for ( i = 0; i < pVeh->m_pVehicleInfo->maxPassengers; i++ )
+					{
+						if ( pVeh->m_ppPassengers[i] )
+						{
+							//FIXME: does this give proper credit to the enemy who shot you down?
+							G_Damage((gentity_t *)pVeh->m_ppPassengers[i], (gentity_t *)pVeh->m_pParentEntity, (gentity_t *)pVeh->m_pParentEntity,
+								NULL, pVeh->m_pParentEntity->playerState->origin, 999, DAMAGE_NO_PROTECTION, MOD_EXPLOSIVE);
+						}
+					}
+				}				
+			}
+#endif
+		}
+
+		if ( !pVeh->m_pVehicleInfo->Inhabited( pVeh ) )
+		{ //explode now as long as we managed to kick everyone out
+			vec3_t	lMins, lMaxs, bottom;
+			trace_t	trace;
+
+
+#ifndef _JK2MP
+			// Kill All Client Side Looping Effects
+			//--------------------------------------
+			if (pVeh->m_pVehicleInfo->iExhaustFX)
+			{
+				for (int i=0; (i<MAX_VEHICLE_EXHAUSTS && pVeh->m_iExhaustTag[i]!=-1); i++)
+				{
+					G_StopEffect(pVeh->m_pVehicleInfo->iExhaustFX, parent->playerModel, pVeh->m_iExhaustTag[i], parent->s.number);
+				}
+			}
+			if (pVeh->m_pVehicleInfo->iArmorLowFX)
+			{
+				G_StopEffect(pVeh->m_pVehicleInfo->iArmorLowFX,  parent->playerModel, parent->crotchBolt, parent->s.number);
+			}
+			if (pVeh->m_pVehicleInfo->iArmorGoneFX)
+			{
+				G_StopEffect(pVeh->m_pVehicleInfo->iArmorGoneFX, parent->playerModel, parent->crotchBolt, parent->s.number);
+			}
+			//--------------------------------------
+#endif
+			if ( pVeh->m_pVehicleInfo->iExplodeFX )
+			{
+#ifdef _JK2MP
+				vec3_t fxAng;
+
+				VectorSet(fxAng, -90.0f, 0.0f, 0.0f);
+				G_PlayEffectID( pVeh->m_pVehicleInfo->iExplodeFX, parent->currentOrigin, fxAng );
+#else
+				G_PlayEffect( pVeh->m_pVehicleInfo->iExplodeFX, parent->currentOrigin, vec3_origin );
+#endif
+				//trace down and place mark
+				VectorCopy( parent->currentOrigin, bottom );
+				bottom[2] -= 80;
+				G_VehicleTrace( &trace, parent->currentOrigin, vec3_origin, vec3_origin, bottom, parent->s.number, CONTENTS_SOLID );
+				if ( trace.fraction < 1.0f )
+				{
+					VectorCopy( trace.endpos, bottom );
+					bottom[2] += 2;
+#ifdef _JK2MP
+					VectorSet(fxAng, -90.0f, 0.0f, 0.0f);
+					G_PlayEffectID( G_EffectIndex("ships/ship_explosion_mark"), trace.endpos, fxAng );
+#else
+					G_PlayEffect( "ships/ship_explosion_mark", trace.endpos );
+#endif
+				}
+			}
+
+			parent->takedamage = qfalse;//so we don't recursively damage ourselves
+			if ( pVeh->m_pVehicleInfo->explosionRadius > 0 && pVeh->m_pVehicleInfo->explosionDamage > 0 )
+			{
+				VectorCopy( parent->mins, lMins );
+				lMins[2] = -4;//to keep it off the ground a *little*
+				VectorCopy( parent->maxs, lMaxs );
+				VectorCopy( parent->currentOrigin, bottom );
+				bottom[2] += parent->mins[2] - 32;
+				G_VehicleTrace( &trace, parent->currentOrigin, lMins, lMaxs, bottom, parent->s.number, CONTENTS_SOLID );
+#ifdef _JK2MP
+				G_RadiusDamage( trace.endpos, NULL, pVeh->m_pVehicleInfo->explosionDamage, pVeh->m_pVehicleInfo->explosionRadius, NULL, NULL, MOD_EXPLOSIVE );//FIXME: extern damage and radius or base on fuel
+#else
+				G_RadiusDamage( trace.endpos, NULL, pVeh->m_pVehicleInfo->explosionDamage, pVeh->m_pVehicleInfo->explosionRadius, NULL, MOD_EXPLOSIVE );//FIXME: extern damage and radius or base on fuel
+#endif
+			}
+
+#ifdef _JK2MP
+			parent->think = G_FreeEntity;
+#else
+			parent->e_ThinkFunc = thinkF_G_FreeEntity;
+#endif
+			parent->nextthink = level.time + FRAMETIME;
+		}
+	}
+#ifndef _JK2MP
+	else
+	{//let everyone around me know I'm gonna blow!
+		if ( !Q_irand( 0, 10 ) )
+		{//not so often...
+			AddSoundEvent( parent, parent->currentOrigin, 512, AEL_DANGER );
+			AddSightEvent( parent, parent->currentOrigin, 512, AEL_DANGER, 100 );
+		}
+	}
+#endif
+}
+
+// Register all the assets used by this vehicle.
+void RegisterAssets( Vehicle_t *pVeh )
+{
+}
+
+extern void ChangeWeapon( gentity_t *ent, int newWeapon );
+
+// Initialize the vehicle.
+bool Initialize( Vehicle_t *pVeh )
+{
+	gentity_t *parent = (gentity_t *)pVeh->m_pParentEntity;
+	int i = 0;
+
+	if ( !parent || !parent->client )
+		return false;
+
+#ifdef _JK2MP
+	parent->client->ps.m_iVehicleNum = 0;
+#endif
+	parent->s.m_iVehicleNum = 0;
+	{
+	pVeh->m_iArmor = pVeh->m_pVehicleInfo->armor;
+	parent->client->pers.maxHealth = parent->client->ps.stats[STAT_MAX_HEALTH] = parent->NPC->stats.health = parent->health = parent->client->ps.stats[STAT_HEALTH] = pVeh->m_iArmor;
+	pVeh->m_iShields = pVeh->m_pVehicleInfo->shields;
+#ifdef _JK2MP
+	G_VehUpdateShields( parent );
+#endif
+	parent->client->ps.stats[STAT_ARMOR] = pVeh->m_iShields;
+	}
+	parent->mass = pVeh->m_pVehicleInfo->mass;
+	//initialize the ammo to max
+	for ( i = 0; i < MAX_VEHICLE_WEAPONS; i++ )
+	{
+		parent->client->ps.ammo[i] = pVeh->weaponStatus[i].ammo = pVeh->m_pVehicleInfo->weapon[i].ammoMax;
+	}
+	for ( i = 0; i < MAX_VEHICLE_TURRETS; i++ )
+	{
+		pVeh->turretStatus[i].nextMuzzle = (pVeh->m_pVehicleInfo->turret[i].iMuzzle[i]-1);
+		parent->client->ps.ammo[MAX_VEHICLE_WEAPONS+i] = pVeh->turretStatus[i].ammo = pVeh->m_pVehicleInfo->turret[i].iAmmoMax;
+		if ( pVeh->m_pVehicleInfo->turret[i].bAI )
+		{//they're going to be finding enemies, init this to NONE
+			pVeh->turretStatus[i].enemyEntNum = ENTITYNUM_NONE;
+		}
+	}
+	//begin stopped...?
+	parent->client->ps.speed = 0; 
+	
+	VectorClear( pVeh->m_vOrientation );
+	pVeh->m_vOrientation[YAW] = parent->s.angles[YAW];
+
+#ifdef _JK2MP
+	if ( pVeh->m_pVehicleInfo->gravity &&
+		pVeh->m_pVehicleInfo->gravity != g_gravity.value )
+	{//not normal gravity
+		if ( parent->NPC )
+		{
+			parent->NPC->aiFlags |= NPCAI_CUSTOM_GRAVITY;
+		}
+		parent->client->ps.gravity = pVeh->m_pVehicleInfo->gravity;
+	}
+#else
+	if ( pVeh->m_pVehicleInfo->gravity &&
+		pVeh->m_pVehicleInfo->gravity != g_gravity->value )
+	{//not normal gravity
+		parent->svFlags |= SVF_CUSTOM_GRAVITY;
+		parent->client->ps.gravity = pVeh->m_pVehicleInfo->gravity;
+	}
+#endif
+
+	if ( pVeh->m_pVehicleInfo->maxPassengers > 0 )
+	{
+		int i;
+
+		// Allocate an array of entity pointers.
+#ifndef _JK2MP //this is kind of silly if you ask me, I'm just using a static pointer array
+		pVeh->m_ppPassengers = (gentity_t**)G_Alloc ( sizeof(gentity_t*) * pVeh->m_pVehicleInfo->maxPassengers );
+#endif
+		for ( i = 0; i < pVeh->m_pVehicleInfo->maxPassengers; i++ )
+		{
+			pVeh->m_ppPassengers[i] = NULL;
+		}
+	}
+
+	pVeh->m_iNumPassengers = 0; 
+	/*
+	if ( pVeh->m_iVehicleTypeID == VH_FIGHTER )
+	{
+		pVeh->m_ulFlags = VEH_GEARSOPEN;
+	}
+	else
+	*/
+	//why?! -rww
+	{
+		pVeh->m_ulFlags = 0;
+	}
+	pVeh->m_fTimeModifier = 1.0f;
+	pVeh->m_iBoarding = 0;
+	pVeh->m_bWasBoarding = false;
+	pVeh->m_pOldPilot = NULL;
+	VectorClear(pVeh->m_vBoardingVelocity);
+	pVeh->m_pPilot = NULL;
+	memset( &pVeh->m_ucmd, 0, sizeof( usercmd_t ) );
+	pVeh->m_iDieTime = 0;
+	pVeh->m_EjectDir = VEH_EJECT_LEFT;
+
+	//pVeh->m_iDriverTag = -1;
+	//pVeh->m_iLeftExhaustTag = -1;
+	//pVeh->m_iRightExhaustTag = -1;
+	//pVeh->m_iGun1Tag = -1;
+	//pVeh->m_iGun1Bone = -1;
+	//pVeh->m_iLeftWingBone = -1;
+	//pVeh->m_iRightWingBone = -1;
+	memset( pVeh->m_iExhaustTag, -1, sizeof( int ) * MAX_VEHICLE_EXHAUSTS );
+	memset( pVeh->m_iMuzzleTag, -1, sizeof( int ) * MAX_VEHICLE_MUZZLES );
+	// FIXME! Use external values read from the vehicle data file!
+#ifndef _JK2MP //blargh, fixme
+	memset( pVeh->m_Muzzles, 0, sizeof( Muzzle ) * MAX_VEHICLE_MUZZLES );
+#endif
+	pVeh->m_iDroidUnitTag = -1;
+
+	//initialize to blaster, just since it's a basic weapon and there's no lightsaber crap...?
+	parent->client->ps.weapon = WP_BLASTER;
+	parent->client->ps.weaponstate = WEAPON_READY;
+	parent->client->ps.stats[STAT_WEAPONS] |= (1<<WP_BLASTER);
+
+	//Initialize to landed (wings closed, gears down) animation
+	{
+		int iFlags = SETANIM_FLAG_NORMAL, iBlend = 300;
+#ifdef _JK2MP
+		pVeh->m_ulFlags |= VEH_GEARSOPEN;
+		BG_SetAnim(pVeh->m_pParentEntity->playerState, 
+			bgAllAnims[pVeh->m_pParentEntity->localAnimIndex].anims,
+			SETANIM_BOTH, BOTH_VS_IDLE, iFlags, iBlend);
+#else
+		NPC_SetAnim( pVeh->m_pParentEntity, SETANIM_BOTH, BOTH_VS_IDLE, iFlags, iBlend );
+#endif
+	}
+
+	return true;
+}
+
+// Like a think or move command, this updates various vehicle properties.
+#ifdef _JK2MP
+void G_VehicleDamageBoxSizing(Vehicle_t *pVeh); //declared below
+#endif
+static bool Update( Vehicle_t *pVeh, const usercmd_t *pUmcd )
+{
+	gentity_t *parent = (gentity_t *)pVeh->m_pParentEntity;
+	gentity_t *pilotEnt;
+	//static float fMod = 1000.0f / 60.0f;
+	vec3_t vVehAngles;
+	int i;
+	int	prevSpeed;
+	int	nextSpeed;
+	int	curTime;
+	int halfMaxSpeed;
+	playerState_t *parentPS;
+	qboolean linkHeld = qfalse;
+
+
+#ifdef _JK2MP
+	parentPS =  pVeh->m_pParentEntity->playerState;
+#else
+	parentPS = &pVeh->m_pParentEntity->client->ps;
+#endif
+
+#ifndef _JK2MP//SP
+	curTime = level.time;
+#elif QAGAME//MP GAME
+	curTime = level.time;
+#elif CGAME//MP CGAME
+	//FIXME: pass in ucmd?  Not sure if this is reliable...
+	curTime = pm->cmd.serverTime;
+#endif
+
+	//increment the ammo for all rechargeable weapons
+	for ( i = 0; i < MAX_VEHICLE_WEAPONS; i++ )
+	{
+		if ( pVeh->m_pVehicleInfo->weapon[i].ID > VEH_WEAPON_BASE//have a weapon in this slot
+			&& pVeh->m_pVehicleInfo->weapon[i].ammoRechargeMS//its ammo is rechargable
+			&& pVeh->weaponStatus[i].ammo < pVeh->m_pVehicleInfo->weapon[i].ammoMax//its ammo is below max
+			&& pUmcd->serverTime-pVeh->weaponStatus[i].lastAmmoInc >= pVeh->m_pVehicleInfo->weapon[i].ammoRechargeMS )//enough time has passed
+		{//add 1 to the ammo
+			pVeh->weaponStatus[i].lastAmmoInc = pUmcd->serverTime;
+			pVeh->weaponStatus[i].ammo++;
+			//NOTE: in order to send the vehicle's ammo info to the client, we copy the ammo into the first 2 ammo slots on the vehicle NPC's client->ps.ammo array
+			if ( parent && parent->client )
+			{
+				parent->client->ps.ammo[i] = pVeh->weaponStatus[i].ammo;
+			}
+		}
+	}
+	for ( i = 0; i < MAX_VEHICLE_TURRETS; i++ )
+	{
+		if ( pVeh->m_pVehicleInfo->turret[i].iWeapon > VEH_WEAPON_BASE//have a weapon in this slot
+			&& pVeh->m_pVehicleInfo->turret[i].iAmmoRechargeMS//its ammo is rechargable
+			&& pVeh->turretStatus[i].ammo < pVeh->m_pVehicleInfo->turret[i].iAmmoMax//its ammo is below max
+			&& pUmcd->serverTime-pVeh->turretStatus[i].lastAmmoInc >= pVeh->m_pVehicleInfo->turret[i].iAmmoRechargeMS )//enough time has passed
+		{//add 1 to the ammo
+			pVeh->turretStatus[i].lastAmmoInc = pUmcd->serverTime;
+			pVeh->turretStatus[i].ammo++;
+			//NOTE: in order to send the vehicle's ammo info to the client, we copy the ammo into the first 2 ammo slots on the vehicle NPC's client->ps.ammo array
+			if ( parent && parent->client )
+			{
+				parent->client->ps.ammo[MAX_VEHICLE_WEAPONS+i] = pVeh->turretStatus[i].ammo;
+			}
+		}
+	}
+
+	//increment shields for rechargable shields
+	if ( pVeh->m_pVehicleInfo->shieldRechargeMS
+		&& parentPS->stats[STAT_ARMOR] > 0 //still have some shields left
+		&& parentPS->stats[STAT_ARMOR] < pVeh->m_pVehicleInfo->shields//its below max
+		&& pUmcd->serverTime-pVeh->lastShieldInc >= pVeh->m_pVehicleInfo->shieldRechargeMS )//enough time has passed
+	{
+		parentPS->stats[STAT_ARMOR]++;
+		if ( parentPS->stats[STAT_ARMOR] > pVeh->m_pVehicleInfo->shields )
+		{
+			parentPS->stats[STAT_ARMOR] = pVeh->m_pVehicleInfo->shields;
+		}
+		pVeh->m_iShields = parentPS->stats[STAT_ARMOR];
+#ifdef _JK2MP
+		G_VehUpdateShields( parent );
+#endif
+	}
+
+#ifdef _JK2MP //sometimes this gets out of whack, probably init'ing
+	if (parent && parent->r.ownerNum != parent->s.owner)
+	{
+		parent->s.owner = parent->r.ownerNum;
+	}
+
+	//keep the PS value in sync. set it up here in case we return below at some point.
+	if (pVeh->m_iBoarding)
+	{
+		parent->client->ps.vehBoarding = qtrue;
+	}
+	else
+	{
+		parent->client->ps.vehBoarding = qfalse;
+	}
+#endif
+
+	// See whether this vehicle should be dieing or dead.
+	if ( pVeh->m_iDieTime != 0 
+#ifndef _JK2MP //sometimes this gets out of whack, probably init'ing
+		|| (parent->health <= 0)
+#endif
+		)
+	{//NOTE!!!: This HAS to be consistent with cgame!!!
+		// Keep track of the old orientation.
+		VectorCopy( pVeh->m_vOrientation, pVeh->m_vPrevOrientation );
+
+		// Process the orient commands.
+		pVeh->m_pVehicleInfo->ProcessOrientCommands( pVeh );
+		// Need to copy orientation to our entity's viewangles so that it renders at the proper angle and currentAngles is correct.
+		SetClientViewAngle( parent, pVeh->m_vOrientation ); 
+		if ( pVeh->m_pPilot )
+		{
+			SetClientViewAngle( (gentity_t *)pVeh->m_pPilot, pVeh->m_vOrientation );
+		}
+		/*
+		for ( i = 0; i < pVeh->m_pVehicleInfo->maxPassengers; i++ )
+		{
+			if ( pVeh->m_ppPassengers[i] )
+			{
+				SetClientViewAngle( (gentity_t *)pVeh->m_ppPassengers[i], pVeh->m_vOrientation );
+			}
+		}
+		*/
+
+		// Process the move commands.
+		pVeh->m_pVehicleInfo->ProcessMoveCommands( pVeh );
+
+		// Setup the move direction.
+		if ( pVeh->m_pVehicleInfo->type == VH_FIGHTER )
+		{
+			AngleVectors( pVeh->m_vOrientation, parent->client->ps.moveDir, NULL, NULL ); 
+		}
+		else
+		{
+			VectorSet(vVehAngles, 0, pVeh->m_vOrientation[YAW], 0);
+			AngleVectors( vVehAngles, parent->client->ps.moveDir, NULL, NULL ); 
+		}
+		pVeh->m_pVehicleInfo->DeathUpdate( pVeh );
+		return false;
+	}
+	// Vehicle dead!
+
+#ifdef _JK2MP
+	else if ( parent->health <= 0 )
+	{
+		// Instant kill.
+		if (pVeh->m_pVehicleInfo->type == VH_FIGHTER &&
+			pVeh->m_iLastImpactDmg > 500)
+		{ //explode instantly in inferno-y death
+			pVeh->m_pVehicleInfo->StartDeathDelay( pVeh, -1/* -1 causes instant death */);
+		}
+		else
+		{
+			pVeh->m_pVehicleInfo->StartDeathDelay( pVeh, 0 );
+		}
+		pVeh->m_pVehicleInfo->DeathUpdate( pVeh );
+		return false;
+	}
+#endif
+	
+#ifdef _JK2MP //special check in case someone disconnects/dies while boarding
+#ifdef QAGAME
+	if (parent->spawnflags & 1)
+	{
+		if (pVeh->m_pPilot || !pVeh->m_bHasHadPilot)
+		{
+			if (pVeh->m_pPilot && !pVeh->m_bHasHadPilot)
+			{
+				pVeh->m_bHasHadPilot = qtrue;
+				pVeh->m_iPilotLastIndex = pVeh->m_pPilot->s.number;
+			}
+			pVeh->m_iPilotTime = level.time + parent->damage;
+		}
+		else if (pVeh->m_iPilotTime)
+		{ //die
+			gentity_t *oldPilot = &g_entities[pVeh->m_iPilotLastIndex];
+
+			if (!oldPilot->inuse || !oldPilot->client ||
+				oldPilot->client->pers.connected != CON_CONNECTED)
+			{ //no longer in the game?
+				G_Damage(parent, parent, parent, NULL, parent->client->ps.origin, 99999, DAMAGE_NO_PROTECTION, MOD_SUICIDE);
+			}
+			else
+			{
+				vec3_t v;
+				VectorSubtract(parent->client->ps.origin, oldPilot->client->ps.origin, v);
+
+				if (VectorLength(v) < parent->speed)
+				{ //they are still within the minimum distance to their vehicle
+					pVeh->m_iPilotTime = level.time + parent->damage;
+				}
+				else if (pVeh->m_iPilotTime < level.time)
+				{ //dying time
+					G_Damage(parent, parent, parent, NULL, parent->client->ps.origin, 99999, DAMAGE_NO_PROTECTION, MOD_SUICIDE);
+				}
+			}
+		}
+	}
+#endif
+#else
+	if (parent->spawnflags & 1)
+	{//NOTE: in SP, this actually just checks LOS to the Player
+		if (pVeh->m_iPilotTime < level.time)
+		{//do another check?
+			if ( !player || G_ClearLineOfSight(pVeh->m_pParentEntity->currentOrigin, player->currentOrigin, pVeh->m_pParentEntity->s.number, MASK_OPAQUE ) )
+			{
+				pVeh->m_iPilotTime = level.time + pVeh->m_pParentEntity->endFrame;
+			}
+		}
+		if (pVeh->m_iPilotTime && pVeh->m_iPilotTime < level.time)
+		{ //die
+			//FIXME: does this give proper credit to the enemy who shot you down?
+            G_Damage(parent, parent, parent, NULL, parent->client->ps.origin, 99999, DAMAGE_NO_PROTECTION, MOD_SUICIDE);
+		}
+	}
+#endif
+
+#ifndef _JK2MP
+//	if (level.time<pVeh->m_iTurboTime || pVeh->m_pVehicleInfo->type==VH_ANIMAL)
+	// always knock guys around now...
+	{
+		vec3_t	dir;						
+		vec3_t	projectedPosition;
+		VectorCopy(parent->client->ps.velocity, dir);
+		VectorMA(parent->currentOrigin, 0.1f, dir, projectedPosition);
+
+		float	force = VectorNormalize(dir);
+		force /= 10.0f;
+		if (force>30.0f)
+		{
+			trace_t	tr;
+			G_VehicleTrace(&tr, parent->currentOrigin, parent->mins, parent->maxs, projectedPosition, parent->s.number, CONTENTS_BODY);
+			if (tr.fraction<1.0f && 
+				!tr.allsolid && 
+				!tr.startsolid && 
+				tr.entityNum!=ENTITYNUM_NONE && 
+				tr.entityNum!=ENTITYNUM_WORLD &&
+				(level.time<pVeh->m_iTurboTime || Q_irand(0,3)==0))
+			{
+				gentity_t*	other = &g_entities[tr.entityNum];
+				if (other && other->client && !other->s.m_iVehicleNum)
+				{
+					G_Throw( other, dir, force/10.0f );
+					G_Knockdown( other, parent, dir, force, qtrue );
+					G_Damage( other, parent, parent, parent->client->ps.velocity, parent->currentOrigin, force, DAMAGE_NO_ARMOR|DAMAGE_EXTRA_KNOCKBACK, MOD_IMPACT);
+				}
+			}
+		}
+	}
+#endif
+
+#ifdef _JK2MP //special check in case someone disconnects/dies while boarding
+	if (pVeh->m_iBoarding != 0)
+	{
+		pilotEnt = (gentity_t *)pVeh->m_pPilot;
+		if (pilotEnt)
+		{
+			if (!pilotEnt->inuse || !pilotEnt->client || pilotEnt->health <= 0 ||
+				pilotEnt->client->pers.connected != CON_CONNECTED)
+			{
+				pVeh->m_pVehicleInfo->Eject( pVeh, pVeh->m_pPilot, qtrue );
+				return false;
+			}
+		}
+	}
+#endif
+
+	// If we're not done mounting, can't do anything.
+	if ( pVeh->m_iBoarding != 0 )
+	{
+		if (!pVeh->m_bWasBoarding)
+		{
+			VectorCopy(parentPS->velocity, pVeh->m_vBoardingVelocity);
+			pVeh->m_bWasBoarding = true;
+		}
+
+		// See if we're done boarding.
+		if ( pVeh->m_iBoarding > -1 && pVeh->m_iBoarding <= level.time )
+		{
+			pVeh->m_bWasBoarding = false;
+			pVeh->m_iBoarding = 0;
+		}
+		else
+		{
+#ifdef _JK2MP
+			goto maintainSelfDuringBoarding;
+#else
+			return false;
+#endif
+		}
+	}
+
+	parent = (gentity_t *)pVeh->m_pParentEntity;
+
+	// Validate vehicle.
+	if ( !parent || !parent->client || parent->health <= 0 )
+		return false;
+
+	// See if any of the riders are dead and if so kick em off.
+	if ( pVeh->m_pPilot )
+	{
+		pilotEnt = (gentity_t *)pVeh->m_pPilot;
+		
+#ifdef _JK2MP
+		if (!pilotEnt->inuse || !pilotEnt->client || pilotEnt->health <= 0 ||
+			pilotEnt->client->pers.connected != CON_CONNECTED)
+#else
+		if (pilotEnt->health <= 0)
+#endif
+		{
+			pVeh->m_pVehicleInfo->Eject( pVeh, pVeh->m_pPilot, qtrue );
+		}
+	}
+	// If we're not empty...
+	if ( pVeh->m_iNumPassengers > 0 )
+	{
+		gentity_t *psngr;
+		// See if any of these suckers are dead.
+		for ( i = 0; i < pVeh->m_pVehicleInfo->maxPassengers; i++ )
+		{
+			psngr = (gentity_t *)pVeh->m_ppPassengers[i];
+
+#ifdef _JK2MP
+			if ( psngr &&
+				(!psngr->inuse || !psngr->client || psngr->health <= 0 || psngr->client->pers.connected != CON_CONNECTED) )
+#else
+			if ( psngr && psngr->health <= 0 )
+#endif
+			{
+				pVeh->m_pVehicleInfo->Eject( pVeh, pVeh->m_ppPassengers[i], qtrue );
+				pVeh->m_iNumPassengers--;
+			}
+		}
+	}
+
+#ifdef _JK2MP
+	// Copy over the commands for local storage.
+	memcpy( &parent->client->pers.cmd, &pVeh->m_ucmd, sizeof( usercmd_t ) );
+	pVeh->m_ucmd.buttons &= ~(BUTTON_TALK);//|BUTTON_GESTURE); //don't want some of these buttons
+#else
+	// Copy over the commands for local storage.
+	memcpy( &pVeh->m_ucmd, pUmcd, sizeof( usercmd_t ) );
+	memcpy( &parent->client->pers.lastCommand, pUmcd, sizeof( usercmd_t ) );
+#endif
+
+	/*
+	// Update time modifier.
+	pVeh->m_fTimeModifier = pVeh->m_ucmd.serverTime - parent->client->ps.commandTime;
+	//sanity check
+	if ( pVeh->m_fTimeModifier < 1 ) 
+	{
+		pVeh->m_fTimeModifier = 1;
+	} 
+	else if ( pVeh->m_fTimeModifier > 200 ) 
+	{
+		pVeh->m_fTimeModifier = 200;
+	}
+	//normalize to 1.0f at 20fps
+	pVeh->m_fTimeModifier = pVeh->m_fTimeModifier / fMod;
+	*/
+	
+	//check for weapon linking/unlinking command
+	for ( i = 0; i < MAX_VEHICLE_WEAPONS; i++ )
+	{//HMM... can't get a seperate command for each weapon, so do them all...?
+		if ( pVeh->m_pVehicleInfo->weapon[i].linkable == 2 )
+		{//always linked
+			//FIXME: just set this once, on Initialize...?
+			if ( !pVeh->weaponStatus[i].linked )
+			{
+				pVeh->weaponStatus[i].linked = qtrue;
+			}
+		}
+#ifdef _JK2MP
+		else if ( (pVeh->m_ucmd.buttons&BUTTON_USE_HOLDABLE) ) 
+#else
+		//FIXME: implement... just a console command bound to a key?
+		else if ( 0 )
+#endif	
+		{//pilot pressed the "weapon link" toggle button
+			playerState_t *pilotPS;
+#ifdef _JK2MP
+			bgEntity_t *rider = NULL;
+			if (parent->s.owner != ENTITYNUM_NONE)
+			{
+				rider = PM_BGEntForNum(parent->s.owner); //&g_entities[parent->r.ownerNum];
+			}
+			pilotPS = rider->playerState;
+#else
+			gentity_t *rider = parent->owner;
+			pilotPS = &rider->client->ps;
+#endif
+			if ( !pVeh->linkWeaponToggleHeld )//so we don't hold it down and toggle it back and forth
+			{//okay to toggle
+				if ( pVeh->m_pVehicleInfo->weapon[i].linkable == 1 )
+				{//link-toggleable
+					pVeh->weaponStatus[i].linked = !pVeh->weaponStatus[i].linked;
+				}
+			}
+			linkHeld = qtrue;
+		}
+	}
+	if ( linkHeld )
+	{
+		//so we don't hold it down and toggle it back and forth
+		pVeh->linkWeaponToggleHeld = qtrue;
+	}
+	else
+	{
+		//so we don't hold it down and toggle it back and forth
+		pVeh->linkWeaponToggleHeld = qfalse;
+	}
+#ifdef _JK2MP
+	//now pass it over the network so cgame knows about it
+	//NOTE: SP can just cheat and check directly
+	parentPS->vehWeaponsLinked = qfalse;
+	for ( i = 0; i < MAX_VEHICLE_WEAPONS; i++ )
+	{//HMM... can't get a seperate command for each weapon, so do them all...?
+		if ( pVeh->weaponStatus[i].linked )
+		{
+			parentPS->vehWeaponsLinked = qtrue;
+		}
+	}
+#endif
+
+#ifdef QAGAME
+	for ( i = 0; i < MAX_VEHICLE_TURRETS; i++ )
+	{//HMM... can't get a seperate command for each weapon, so do them all...?
+		VEH_TurretThink( pVeh, parent, i );
+	}
+#endif
+
+#ifdef _JK2MP
+maintainSelfDuringBoarding:
+
+	if (pVeh->m_pPilot && pVeh->m_pPilot->playerState && pVeh->m_iBoarding != 0)
+	{
+        VectorCopy(pVeh->m_vOrientation, pVeh->m_pPilot->playerState->viewangles);
+		pVeh->m_ucmd.buttons = 0;
+		pVeh->m_ucmd.forwardmove = 0;
+		pVeh->m_ucmd.rightmove = 0;
+		pVeh->m_ucmd.upmove = 0;
+	}
+#endif
+
+	// Keep track of the old orientation.
+	VectorCopy( pVeh->m_vOrientation, pVeh->m_vPrevOrientation );
+
+	// Process the orient commands.
+	pVeh->m_pVehicleInfo->ProcessOrientCommands( pVeh );
+	// Need to copy orientation to our entity's viewangles so that it renders at the proper angle and currentAngles is correct.
+	SetClientViewAngle( parent, pVeh->m_vOrientation ); 
+	if ( pVeh->m_pPilot )
+	{
+#ifdef _JK2MP
+		if ( !BG_UnrestrainedPitchRoll( pVeh->m_pPilot->playerState, pVeh ) )
+		{
+			vec3_t newVAngle;
+			newVAngle[PITCH] = pVeh->m_pPilot->playerState->viewangles[PITCH];
+			newVAngle[YAW] = pVeh->m_pPilot->playerState->viewangles[YAW];
+			newVAngle[ROLL] = pVeh->m_vOrientation[ROLL];
+			SetClientViewAngle( (gentity_t *)pVeh->m_pPilot, newVAngle );
+		}
+#else
+		if ( !BG_UnrestrainedPitchRoll( &pVeh->m_pPilot->client->ps, pVeh ) )
+		{
+			SetClientViewAngle( (gentity_t *)pVeh->m_pPilot, pVeh->m_vOrientation );
+		}
+#endif
+	}
+	/*
+	for ( i = 0; i < pVeh->m_pVehicleInfo->maxPassengers; i++ )
+	{
+		if ( pVeh->m_ppPassengers[i] )
+		{
+			SetClientViewAngle( (gentity_t *)pVeh->m_ppPassengers[i], pVeh->m_vOrientation );
+		}
+	}
+	*/
+
+	// Process the move commands.
+	prevSpeed = parentPS->speed;
+	pVeh->m_pVehicleInfo->ProcessMoveCommands( pVeh );
+	nextSpeed = parentPS->speed;
+	halfMaxSpeed = pVeh->m_pVehicleInfo->speedMax*0.5f;
+	
+
+// Shifting Sounds
+//=====================================================================
+	if (pVeh->m_iTurboTime<curTime && 
+		pVeh->m_iSoundDebounceTimer<curTime && 
+		((nextSpeed>prevSpeed && nextSpeed>halfMaxSpeed &&	prevSpeed<halfMaxSpeed) || (nextSpeed>halfMaxSpeed && !Q_irand(0,1000)))
+ 		)
+	{
+		int	shiftSound = Q_irand(1,4);
+		switch (shiftSound)
+		{
+		case 1: shiftSound=pVeh->m_pVehicleInfo->soundShift1; break;
+		case 2: shiftSound=pVeh->m_pVehicleInfo->soundShift2; break;
+		case 3: shiftSound=pVeh->m_pVehicleInfo->soundShift3; break;
+		case 4: shiftSound=pVeh->m_pVehicleInfo->soundShift4; break;
+		}
+		if (shiftSound)
+		{
+			pVeh->m_iSoundDebounceTimer = curTime + Q_irand(1000, 4000);
+#ifdef _JK2MP
+			// TODO: MP Shift Sound Playback
+#else
+			// NOTE: Use this type so it's spatialized and updates play origin as bike moves - MCG
+			G_SoundIndexOnEnt( pVeh->m_pParentEntity, CHAN_AUTO, shiftSound);
+#endif
+		}
+	}
+//=====================================================================
+
+
+	// Setup the move direction.
+	if ( pVeh->m_pVehicleInfo->type == VH_FIGHTER )
+	{
+		AngleVectors( pVeh->m_vOrientation, parent->client->ps.moveDir, NULL, NULL ); 
+	}
+	else
+	{
+		VectorSet(vVehAngles, 0, pVeh->m_vOrientation[YAW], 0);
+		AngleVectors( vVehAngles, parent->client->ps.moveDir, NULL, NULL ); 
+	}
+
+#ifdef _JK2MP
+	if (pVeh->m_pVehicleInfo->surfDestruction)
+	{
+		if (pVeh->m_iRemovedSurfaces)
+		{
+			gentity_t *killer = parent;
+			float	   dmg;
+			G_VehicleDamageBoxSizing(pVeh);
+
+			//damage him constantly if any chunks are currently taken off
+			if (parent->client->ps.otherKiller < ENTITYNUM_WORLD &&
+				parent->client->ps.otherKillerTime > level.time)
+			{
+				gentity_t *potentialKiller = &g_entities[parent->client->ps.otherKiller];
+
+				if (potentialKiller->inuse && potentialKiller->client)
+				{ //he's valid I guess
+					killer = potentialKiller;
+				}
+			}
+			//FIXME: aside from bypassing shields, maybe set m_iShields to 0, too... ?
+			
+			// 3 seconds max on death.
+			dmg = (float)parent->client->ps.stats[STAT_MAX_HEALTH] * pVeh->m_fTimeModifier / 180.0f;			
+			G_Damage(parent, killer, killer, NULL, parent->client->ps.origin, dmg, DAMAGE_NO_SELF_PROTECTION|DAMAGE_NO_HIT_LOC|DAMAGE_NO_PROTECTION|DAMAGE_NO_ARMOR, MOD_SUICIDE);
+		}
+		
+		//make sure playerstate value stays in sync
+		parent->client->ps.vehSurfaces = pVeh->m_iRemovedSurfaces;
+	}
+#endif
+
+#ifdef _JK2MP
+	//keep the PS value in sync
+	if (pVeh->m_iBoarding)
+	{
+		parent->client->ps.vehBoarding = qtrue;
+	}
+	else
+	{
+		parent->client->ps.vehBoarding = qfalse;
+	}
+#endif
+
+#ifndef _JK2MP
+	// Make sure the vehicle takes on the enemy of it's rider (for homing missles for instance).
+	if ( pVeh->m_pPilot )
+	{
+		parent->enemy = pVeh->m_pPilot->enemy;
+	}
+#endif
+	
+
+	return true;
+}
+
+
+// Update the properties of a Rider (that may reflect what happens to the vehicle).
+static bool UpdateRider( Vehicle_t *pVeh, bgEntity_t *pRider, usercmd_t *pUmcd )
+{
+	gentity_t *parent;
+	gentity_t *rider;
+
+	if ( pVeh->m_iBoarding != 0 && pVeh->m_iDieTime==0)
+		return true;
+
+	parent = (gentity_t *)pVeh->m_pParentEntity;
+	rider = (gentity_t *)pRider;
+#ifdef _JK2MP
+	//MG FIXME !! Single player needs update!
+	if ( rider && rider->client 
+		&& parent && parent->client )
+	{//so they know who we're locking onto with our rockets, if anyone
+		rider->client->ps.rocketLockIndex = parent->client->ps.rocketLockIndex;
+		rider->client->ps.rocketLockTime = parent->client->ps.rocketLockTime;
+		rider->client->ps.rocketTargetTime = parent->client->ps.rocketTargetTime;
+	}
+#endif
+	// Regular exit.
+	if ( pUmcd->buttons & BUTTON_USE && pVeh->m_pVehicleInfo->type!=VH_SPEEDER)
+	{
+		if ( pVeh->m_pVehicleInfo->type == VH_WALKER )
+		{//just get the fuck out
+			pVeh->m_EjectDir = VEH_EJECT_REAR;
+			if ( pVeh->m_pVehicleInfo->Eject( pVeh, pRider, qfalse ) )
+				return false;
+		}
+		else if ( !(pVeh->m_ulFlags & VEH_FLYING))
+		{
+			// If going too fast, roll off.
+			if ((parent->client->ps.speed<=600) && pUmcd->rightmove!=0)
+			{
+				if ( pVeh->m_pVehicleInfo->Eject( pVeh, pRider, qfalse ) )
+				{
+					animNumber_t Anim;
+					int iFlags = SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLD | SETANIM_FLAG_HOLDLESS, iBlend = 300;
+					if ( pUmcd->rightmove > 0 )
+					{
+						Anim = BOTH_ROLL_R;
+						pVeh->m_EjectDir = VEH_EJECT_RIGHT;
+					}
+					else
+					{
+						Anim = BOTH_ROLL_L;
+						pVeh->m_EjectDir = VEH_EJECT_LEFT;
+					}
+					VectorScale( parent->client->ps.velocity, 0.25f, rider->client->ps.velocity );
+#if 1
+					Vehicle_SetAnim( rider, SETANIM_BOTH, Anim, iFlags, iBlend );
+#else
+
+#endif
+					//PM_SetAnim(pm,SETANIM_BOTH,anim,SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD|SETANIM_FLAG_HOLDLESS);
+					rider->client->ps.weaponTime = rider->client->ps.torsoAnimTimer - 200;//just to make sure it's cleared when roll is done
+					G_AddEvent( rider, EV_ROLL, 0 );
+					return false;
+				}
+			}
+			else
+			{
+				// FIXME: Check trace to see if we should start playing the animation.
+				animNumber_t Anim;
+				int iFlags = SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLD, iBlend = 500;
+				if ( pUmcd->rightmove > 0 )
+				{
+					Anim = BOTH_VS_DISMOUNT_R;
+					pVeh->m_EjectDir = VEH_EJECT_RIGHT;
+				}
+				else
+				{
+					Anim = BOTH_VS_DISMOUNT_L;
+					pVeh->m_EjectDir = VEH_EJECT_LEFT;
+				}
+				
+				if ( pVeh->m_iBoarding <= 1 )
+				{
+					int iAnimLen;
+					// NOTE: I know I shouldn't reuse pVeh->m_iBoarding so many times for so many different
+					// purposes, but it's not used anywhere else right here so why waste memory???
+#ifdef _JK2MP
+					iAnimLen = BG_AnimLength( rider->localAnimIndex, Anim );
+#else
+					iAnimLen = PM_AnimLength( pRider->client->clientInfo.animFileIndex, Anim );
+#endif
+					pVeh->m_iBoarding = level.time + iAnimLen;
+					// Weird huh? Well I wanted to reuse flags and this should never be set in an
+					// entity, so what the heck.
+#ifdef _JK2MP
+					rider->flags |= FL_VEH_BOARDING;
+#else
+					rider->client->ps.eFlags |= EF_VEH_BOARDING;
+#endif
+
+					// Make sure they can't fire when leaving.
+					rider->client->ps.weaponTime = iAnimLen;
+				}
+
+				VectorScale( parent->client->ps.velocity, 0.25f, rider->client->ps.velocity );
+
+				Vehicle_SetAnim( rider, SETANIM_BOTH, Anim, iFlags, iBlend );
+			}
+		}
+		// Flying, so just fall off.
+		else
+		{
+			pVeh->m_EjectDir = VEH_EJECT_LEFT;
+			if ( pVeh->m_pVehicleInfo->Eject( pVeh, pRider, qfalse ) )
+				return false;
+		}
+	}
+
+	// Getting off animation complete (if we had one going)?
+#ifdef _JK2MP
+	if ( pVeh->m_iBoarding < level.time && (rider->flags & FL_VEH_BOARDING) )
+	{
+		rider->flags &= ~FL_VEH_BOARDING;
+#else
+	if ( pVeh->m_iBoarding < level.time && (rider->client->ps.eFlags & EF_VEH_BOARDING) )
+	{
+		rider->client->ps.eFlags &= ~EF_VEH_BOARDING;
+#endif
+		// Eject this guy now.
+		if ( pVeh->m_pVehicleInfo->Eject( pVeh, pRider, qfalse ) )
+		{
+			return false;
+		}
+	}
+
+	if ( pVeh->m_pVehicleInfo->type != VH_FIGHTER 
+		&& pVeh->m_pVehicleInfo->type != VH_WALKER  )
+	{
+		// Jump off.
+		if ( pUmcd->upmove > 0 )
+		{
+
+// NOT IN MULTI PLAYER!
+//===================================================================
+#ifndef _JK2MP
+			float riderRightDot = G_CanJumpToEnemyVeh(pVeh, pUmcd);
+			if (riderRightDot!=0.0f)
+			{
+				// Eject Player From Current Vehicle
+				//-----------------------------------
+				pVeh->m_EjectDir = VEH_EJECT_TOP;
+				pVeh->m_pVehicleInfo->Eject( pVeh, pRider, qtrue );
+
+				// Send Current Vehicle Spinning Out Of Control
+				//----------------------------------------------
+				pVeh->m_pVehicleInfo->StartDeathDelay(pVeh, 10000);
+				pVeh->m_ulFlags |= (VEH_OUTOFCONTROL);
+ 				VectorScale(pVeh->m_pParentEntity->client->ps.velocity, 1.0f, pVeh->m_pParentEntity->pos3);
+
+				// Todo: Throw Old Vehicle Away From The New Vehicle Some
+				//-------------------------------------------------------
+				vec3_t	toEnemy;
+				VectorSubtract(pVeh->m_pParentEntity->currentOrigin, rider->enemy->currentOrigin, toEnemy);
+				VectorNormalize(toEnemy);
+				G_Throw(pVeh->m_pParentEntity, toEnemy, 50);
+
+				// Start Boarding On Enemy's Vehicle
+				//-----------------------------------
+				Vehicle_t*	enemyVeh = G_IsRidingVehicle(rider->enemy);
+				enemyVeh->m_iBoarding = (riderRightDot>0)?(VEH_MOUNT_THROW_RIGHT):(VEH_MOUNT_THROW_LEFT);
+				enemyVeh->m_pVehicleInfo->Board(enemyVeh, rider);
+			}
+
+			// Don't Jump Off If Holding Strafe Key and Moving Fast
+			else if (pUmcd->rightmove && (parent->client->ps.speed>=10))
+			{
+				return true;
+			}
+#endif
+//===================================================================
+
+			if ( pVeh->m_pVehicleInfo->Eject( pVeh, pRider, qfalse ) )
+			{
+				// Allow them to force jump off.
+				VectorScale( parent->client->ps.velocity, 0.5f, rider->client->ps.velocity );
+				rider->client->ps.velocity[2] += JUMP_VELOCITY;
+#ifdef _JK2MP
+				rider->client->ps.fd.forceJumpZStart = rider->client->ps.origin[2];
+
+				if (!trap_ICARUS_TaskIDPending(rider, TID_CHAN_VOICE))
+#else
+				rider->client->ps.pm_flags |= ( PMF_JUMPING | PMF_JUMP_HELD );
+				rider->client->ps.forceJumpZStart = rider->client->ps.origin[2];
+
+				if ( !Q3_TaskIDPending( rider, TID_CHAN_VOICE ) )
+#endif
+				{
+					G_AddEvent( rider, EV_JUMP, 0 );
+				}
+#if 1
+				Vehicle_SetAnim( rider, SETANIM_BOTH, BOTH_JUMP1, SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLD, 300 );
+#else
+
+#endif
+				return false;
+			}
+		}
+
+		// Roll off.
+		if ( pUmcd->upmove < 0 )
+		{
+			animNumber_t Anim = BOTH_ROLL_B;
+			pVeh->m_EjectDir = VEH_EJECT_REAR;
+			if ( pUmcd->rightmove > 0 )
+			{
+				Anim = BOTH_ROLL_R;
+				pVeh->m_EjectDir = VEH_EJECT_RIGHT;
+			}
+			else if ( pUmcd->rightmove < 0 )
+			{
+				Anim = BOTH_ROLL_L;
+				pVeh->m_EjectDir = VEH_EJECT_LEFT;
+			}
+			else if ( pUmcd->forwardmove < 0 )
+			{
+				Anim = BOTH_ROLL_B;
+				pVeh->m_EjectDir = VEH_EJECT_REAR;
+			}
+			else if ( pUmcd->forwardmove > 0 )
+			{
+				Anim = BOTH_ROLL_F;
+				pVeh->m_EjectDir = VEH_EJECT_FRONT;
+			}
+
+			if ( pVeh->m_pVehicleInfo->Eject( pVeh, pRider, qfalse ) )
+			{
+				if ( !(pVeh->m_ulFlags & VEH_FLYING) )
+				{
+					VectorScale( parent->client->ps.velocity, 0.25f, rider->client->ps.velocity );
+#if 1
+					Vehicle_SetAnim( rider, SETANIM_BOTH, Anim, SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLD | SETANIM_FLAG_HOLDLESS, 300 );
+#else
+
+#endif
+					//PM_SetAnim(pm,SETANIM_BOTH,anim,SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD|SETANIM_FLAG_HOLDLESS);
+					rider->client->ps.weaponTime = rider->client->ps.torsoAnimTimer - 200;//just to make sure it's cleared when roll is done
+					G_AddEvent( rider, EV_ROLL, 0 );
+				}
+				return false;
+			}
+
+		}
+	}
+
+	return true;
+}
+
+#ifdef _JK2MP //we want access to this one clientside, but it's the only
+//generic vehicle function we care about over there
+#include "../namespace_begin.h"
+extern void AttachRidersGeneric( Vehicle_t *pVeh );
+#include "../namespace_end.h"
+#endif
+
+// Attachs all the riders of this vehicle to their appropriate tag (*driver, *pass1, *pass2, whatever...).
+static void AttachRiders( Vehicle_t *pVeh )
+{
+#ifdef _JK2MP
+	int i = 0;
+
+	AttachRidersGeneric(pVeh);
+
+	if (pVeh->m_pPilot)
+	{
+		gentity_t *parent = (gentity_t *)pVeh->m_pParentEntity;
+		gentity_t *pilot = (gentity_t *)pVeh->m_pPilot;
+		pilot->waypoint = parent->waypoint; // take the veh's waypoint as your own
+
+		//assuming we updated him relative to the bolt in AttachRidersGeneric
+		G_SetOrigin( pilot, pilot->client->ps.origin );
+		trap_LinkEntity( pilot );
+	}
+
+	if (pVeh->m_pOldPilot)
+	{
+		gentity_t *parent = (gentity_t *)pVeh->m_pParentEntity;
+		gentity_t *oldpilot = (gentity_t *)pVeh->m_pOldPilot;
+		oldpilot->waypoint = parent->waypoint; // take the veh's waypoint as your own
+
+		//assuming we updated him relative to the bolt in AttachRidersGeneric
+		G_SetOrigin( oldpilot, oldpilot->client->ps.origin );
+		trap_LinkEntity( oldpilot );
+	}
+
+	//attach passengers
+	while (i < pVeh->m_iNumPassengers)
+	{
+		if (pVeh->m_ppPassengers[i])
+		{
+			mdxaBone_t boltMatrix;
+			vec3_t	yawOnlyAngles;
+			gentity_t *parent = (gentity_t *)pVeh->m_pParentEntity;
+			gentity_t *pilot = (gentity_t *)pVeh->m_ppPassengers[i];
+			int crotchBolt;
+
+			assert(parent->ghoul2);
+			crotchBolt = trap_G2API_AddBolt(parent->ghoul2, 0, "*driver");
+			assert(parent->client);
+			assert(pilot->client);
+
+			VectorSet(yawOnlyAngles, 0, parent->client->ps.viewangles[YAW], 0);
+
+			// Get the driver tag.
+			trap_G2API_GetBoltMatrix( parent->ghoul2, 0, crotchBolt, &boltMatrix,
+									yawOnlyAngles, parent->client->ps.origin,
+									level.time, NULL, parent->modelScale );
+			BG_GiveMeVectorFromMatrix( &boltMatrix, ORIGIN, pilot->client->ps.origin );
+
+			G_SetOrigin( pilot, pilot->client->ps.origin );
+			trap_LinkEntity( pilot );
+		}
+		i++;
+	}
+
+	//attach droid
+	if (pVeh->m_pDroidUnit
+		&& pVeh->m_iDroidUnitTag != -1)
+	{
+		mdxaBone_t boltMatrix;
+		vec3_t	yawOnlyAngles, fwd;
+		gentity_t *parent = (gentity_t *)pVeh->m_pParentEntity;
+		gentity_t *droid = (gentity_t *)pVeh->m_pDroidUnit;
+
+		assert(parent->ghoul2);
+		assert(parent->client);
+		//assert(droid->client);
+
+		if ( droid->client )
+		{
+			VectorSet(yawOnlyAngles, 0, parent->client->ps.viewangles[YAW], 0);
+
+			// Get the droid tag.
+			trap_G2API_GetBoltMatrix( parent->ghoul2, 0, pVeh->m_iDroidUnitTag, &boltMatrix,
+									yawOnlyAngles, parent->currentOrigin,
+									level.time, NULL, parent->modelScale );
+			BG_GiveMeVectorFromMatrix( &boltMatrix, ORIGIN, droid->client->ps.origin );
+			BG_GiveMeVectorFromMatrix( &boltMatrix, NEGATIVE_Y, fwd );
+			vectoangles( fwd, droid->client->ps.viewangles );
+
+			G_SetOrigin( droid, droid->client->ps.origin );
+			G_SetAngles( droid, droid->client->ps.viewangles);
+			SetClientViewAngle( droid, droid->client->ps.viewangles );
+			trap_LinkEntity( droid );
+
+			if ( droid->NPC )
+			{
+				NPC_SetAnim( droid, SETANIM_BOTH, BOTH_STAND2, (SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD) );
+				droid->client->ps.legsTimer = 500;
+				droid->client->ps.torsoTimer = 500;
+			}
+		}
+	}
+#else
+	// If we have a pilot, attach him to the driver tag.
+	if ( pVeh->m_pPilot )
+	{
+		gentity_t * const parent = pVeh->m_pParentEntity;
+		gentity_t * const pilot = pVeh->m_pPilot;
+		mdxaBone_t	boltMatrix;
+
+		pilot->waypoint = parent->waypoint; // take the veh's waypoint as your own
+
+		// Get the driver tag.
+		gi.G2API_GetBoltMatrix( parent->ghoul2, parent->playerModel, parent->crotchBolt, &boltMatrix,
+								pVeh->m_vOrientation, parent->currentOrigin,
+								(cg.time?cg.time:level.time), NULL, parent->s.modelScale );
+		gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, pilot->client->ps.origin );
+		G_SetOrigin( pilot, pilot->client->ps.origin );
+		gi.linkentity( pilot );
+	}
+	// If we have a pilot, attach him to the driver tag.
+	if ( pVeh->m_pOldPilot )
+	{
+		gentity_t * const parent = pVeh->m_pParentEntity;
+		gentity_t * const pilot = pVeh->m_pOldPilot;
+		mdxaBone_t	boltMatrix;
+
+		pilot->waypoint = parent->waypoint; // take the veh's waypoint as your own
+
+		// Get the driver tag.
+		gi.G2API_GetBoltMatrix( parent->ghoul2, parent->playerModel, parent->crotchBolt, &boltMatrix,
+								pVeh->m_vOrientation, parent->currentOrigin,
+								(cg.time?cg.time:level.time), NULL, parent->s.modelScale );
+		gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, pilot->client->ps.origin );
+		G_SetOrigin( pilot, pilot->client->ps.origin );
+		gi.linkentity( pilot );
+	}
+#endif
+}
+
+// Make someone invisible and un-collidable.
+static void Ghost( Vehicle_t *pVeh, bgEntity_t *pEnt )
+{
+	gentity_t *ent;
+
+	if ( !pEnt )
+		return;
+
+	ent = (gentity_t *)pEnt;
+	
+	// This was introduced to prevent one extra entity from being sent to the clients
+	ent->r.svFlags |= SVF_NOCLIENT;
+
+	ent->s.eFlags |= EF_NODRAW;
+	if ( ent->client )
+	{
+		ent->client->ps.eFlags |= EF_NODRAW;
+	}
+#ifdef _JK2MP
+	ent->r.contents = 0;
+#else
+	ent->contents = 0;
+#endif
+}
+
+// Make someone visible and collidable.
+static void UnGhost( Vehicle_t *pVeh, bgEntity_t *pEnt )
+{
+	gentity_t *ent;
+
+	if ( !pEnt )
+		return;
+
+	ent = (gentity_t *)pEnt;
+
+	// make sure the client is sent again
+	ent->r.svFlags &= ~SVF_NOCLIENT;
+
+	ent->s.eFlags &= ~EF_NODRAW;
+	if ( ent->client )
+	{
+		ent->client->ps.eFlags &= ~EF_NODRAW;
+	}
+#ifdef _JK2MP
+	ent->r.contents = CONTENTS_BODY;
+#else
+	ent->contents = CONTENTS_BODY;
+#endif
+}
+
+#ifdef _JK2MP
+//try to resize the bounding box around a torn apart ship
+void G_VehicleDamageBoxSizing(Vehicle_t *pVeh)
+{
+	vec3_t fwd, right, up;
+	vec3_t nose; //maxs
+	vec3_t back; //mins
+	trace_t trace;
+	const float fDist = 256.0f; //estimated distance to nose from origin
+	const float bDist = 256.0f; //estimated distance to back from origin
+	const float wDist = 32.0f; //width on each side from origin
+	const float hDist = 32.0f; //height on each side from origin
+	gentity_t *parent = (gentity_t *)pVeh->m_pParentEntity;
+
+	if (!parent->ghoul2 || !parent->m_pVehicle || !parent->client)
+	{ //shouldn't have gotten in here then
+		return;
+	}
+
+	//for now, let's only do anything if all wings are stripped off.
+	//this is because I want to be able to tear my wings off and fling
+	//myself down narrow hallways to my death. Because it's fun! -rww
+	if (!(pVeh->m_iRemovedSurfaces & SHIPSURF_BROKEN_C) ||
+		!(pVeh->m_iRemovedSurfaces & SHIPSURF_BROKEN_D) ||
+		!(pVeh->m_iRemovedSurfaces & SHIPSURF_BROKEN_E) ||
+		!(pVeh->m_iRemovedSurfaces & SHIPSURF_BROKEN_F) )
+	{
+		return;
+	}
+
+	//get directions based on orientation
+	AngleVectors(pVeh->m_vOrientation, fwd, right, up);
+
+	//get the nose and back positions (relative to 0, they're gonna be mins/maxs)
+	VectorMA(vec3_origin, fDist, fwd, nose);
+	VectorMA(vec3_origin, -bDist, fwd, back);
+
+	//move the nose and back to opposite right/left, they will end up as our relative mins and maxs
+	VectorMA(nose, wDist, right, nose);
+	VectorMA(nose, -wDist, right, back);
+
+	//use the same concept for up/down now
+	VectorMA(nose, hDist, up, nose);
+	VectorMA(nose, -hDist, up, back);
+
+	//and now, let's trace and see if our new mins/maxs are safe..
+	trap_Trace(&trace, parent->client->ps.origin, back, nose, parent->client->ps.origin, parent->s.number, parent->clipmask);
+	if (!trace.allsolid && !trace.startsolid && trace.fraction == 1.0f)
+	{ //all clear!
+		VectorCopy(nose, parent->maxs);
+		VectorCopy(back, parent->mins);
+	}
+	else
+	{ //oh well, DIE!
+		//FIXME: does this give proper credit to the enemy who shot you down?
+		G_Damage(parent, parent, parent, NULL, parent->client->ps.origin, 9999, DAMAGE_NO_PROTECTION, MOD_SUICIDE);
+	}
+}
+
+//get one of 4 possible impact locations based on the trace direction
+int G_FlyVehicleImpactDir(gentity_t *veh, trace_t *trace)
+{
+	float impactAngle;
+	float relativeAngle;
+	trace_t localTrace;
+	vec3_t testMins, testMaxs;
+	vec3_t rWing, lWing;
+	vec3_t fwd, right;
+	vec3_t fPos;
+	Vehicle_t *pVeh = veh->m_pVehicle;
+	qboolean noseClear = qfalse;
+
+	if (!trace || !pVeh || !veh->client)
+	{
+		return -1;
+	}
+
+	AngleVectors(veh->client->ps.viewangles, fwd, right, 0);
+	VectorSet(testMins, -24.0f, -24.0f, -24.0f);
+	VectorSet(testMaxs, 24.0f, 24.0f, 24.0f);
+
+	//do a trace to determine if the nose is clear
+	VectorMA(veh->client->ps.origin, 256.0f, fwd, fPos);
+	trap_Trace(&localTrace, veh->client->ps.origin, testMins, testMaxs, fPos, veh->s.number, veh->clipmask);
+	if (!localTrace.startsolid && !localTrace.allsolid && localTrace.fraction == 1.0f)
+	{ //otherwise I guess it's not clear..
+		noseClear = qtrue;
+	}
+
+	if (noseClear)
+	{ //if nose is clear check for tearing the wings off
+		//sadly, the trace endpos given always matches the vehicle origin, so we
+		//can't get a real impact direction. First we'll trace forward and see if the wings are colliding
+		//with anything, and if not, we'll fall back to checking the trace plane normal.
+		VectorMA(veh->client->ps.origin, 128.0f, right, rWing);
+		VectorMA(veh->client->ps.origin, -128.0f, right, lWing);
+
+		//test the right wing - unless it's already removed
+		if (!(pVeh->m_iRemovedSurfaces & SHIPSURF_BROKEN_E) ||
+			!(pVeh->m_iRemovedSurfaces & SHIPSURF_BROKEN_F))
+		{
+			VectorMA(rWing, 256.0f, fwd, fPos);
+			trap_Trace(&localTrace, rWing, testMins, testMaxs, fPos, veh->s.number, veh->clipmask);
+			if (localTrace.startsolid || localTrace.allsolid || localTrace.fraction != 1.0f)
+			{ //impact
+				return SHIPSURF_RIGHT;
+			}
+		}
+
+		//test the left wing - unless it's already removed
+		if (!(pVeh->m_iRemovedSurfaces & SHIPSURF_BROKEN_C) ||
+			!(pVeh->m_iRemovedSurfaces & SHIPSURF_BROKEN_D))
+		{
+			VectorMA(lWing, 256.0f, fwd, fPos);
+			trap_Trace(&localTrace, lWing, testMins, testMaxs, fPos, veh->s.number, veh->clipmask);
+			if (localTrace.startsolid || localTrace.allsolid || localTrace.fraction != 1.0f)
+			{ //impact
+				return SHIPSURF_LEFT;
+			}
+		}
+	}
+
+	//try to use the trace plane normal
+	impactAngle = vectoyaw(trace->plane.normal);
+	relativeAngle = AngleSubtract(impactAngle, veh->client->ps.viewangles[YAW]);
+
+	if (relativeAngle > 130 ||
+		relativeAngle < -130)
+	{ //consider this front
+		return SHIPSURF_FRONT;
+	}
+	else if (relativeAngle > 0)
+	{
+		return SHIPSURF_RIGHT;
+	}
+	else if (relativeAngle < 0)
+	{
+		return SHIPSURF_LEFT;
+	}
+
+	return SHIPSURF_BACK;
+}
+
+//try to break surfaces off the ship on impact
+#define TURN_ON				0x00000000
+#define TURN_OFF			0x00000100
+extern void NPC_SetSurfaceOnOff(gentity_t *ent, const char *surfaceName, int surfaceFlags); //NPC_utils.c
+int G_ShipSurfaceForSurfName( const char *surfaceName )
+{
+	if ( !surfaceName )
+	{
+		return -1;
+	}
+	if ( !Q_strncmp( "nose", surfaceName, 4 )
+		|| !Q_strncmp( "f_gear", surfaceName, 6 )
+		|| !Q_strncmp( "glass", surfaceName, 5 ) )
+	{
+		return SHIPSURF_FRONT;
+	}
+	if ( !Q_strncmp( "body", surfaceName, 4 ) )
+	{
+		return SHIPSURF_BACK;
+	}
+	if ( !Q_strncmp( "r_wing1", surfaceName, 7 )
+		|| !Q_strncmp( "r_wing2", surfaceName, 7 )
+		|| !Q_strncmp( "r_gear", surfaceName, 6 ) )
+	{
+		return SHIPSURF_RIGHT;
+	}
+	if ( !Q_strncmp( "l_wing1", surfaceName, 7 )
+		|| !Q_strncmp( "l_wing2", surfaceName, 7 )
+		|| !Q_strncmp( "l_gear", surfaceName, 6 ) )
+	{
+		return SHIPSURF_LEFT;
+	}
+	return -1;
+}
+
+void G_SetVehDamageFlags( gentity_t *veh, int shipSurf, int damageLevel )
+{
+	int dmgFlag;
+	switch ( damageLevel )
+	{
+	case 3://destroyed
+		//add both flags so cgame side knows this surf is GONE
+		//add heavy
+		dmgFlag = SHIPSURF_DAMAGE_FRONT_HEAVY+(shipSurf-SHIPSURF_FRONT);
+		veh->client->ps.brokenLimbs |= (1<<dmgFlag);
+		//add light
+		dmgFlag = SHIPSURF_DAMAGE_FRONT_LIGHT+(shipSurf-SHIPSURF_FRONT);
+		veh->client->ps.brokenLimbs |= (1<<dmgFlag);
+		//copy down
+		veh->s.brokenLimbs = veh->client->ps.brokenLimbs;
+		//check droid
+		if ( shipSurf == SHIPSURF_BACK )
+		{//destroy the droid if we have one
+			if ( veh->m_pVehicle
+				&& veh->m_pVehicle->m_pDroidUnit )
+			{//we have one
+				gentity_t *droidEnt = (gentity_t *)veh->m_pVehicle->m_pDroidUnit;
+				if ( droidEnt 
+					&& ((droidEnt->flags&FL_UNDYING) || droidEnt->health > 0) )
+				{//boom
+					//make it vulnerable
+					droidEnt->flags &= ~FL_UNDYING;
+					//blow it up
+					G_Damage( droidEnt, veh->enemy, veh->enemy, NULL, NULL, 99999, 0, MOD_UNKNOWN );
+				}
+			}
+		}
+		break;
+	case 2://heavy only
+		dmgFlag = SHIPSURF_DAMAGE_FRONT_HEAVY+(shipSurf-SHIPSURF_FRONT);
+		veh->client->ps.brokenLimbs |= (1<<dmgFlag);
+		//remove light
+		dmgFlag = SHIPSURF_DAMAGE_FRONT_LIGHT+(shipSurf-SHIPSURF_FRONT);
+		veh->client->ps.brokenLimbs &= ~(1<<dmgFlag);
+		//copy down
+		veh->s.brokenLimbs = veh->client->ps.brokenLimbs;
+		//check droid
+		if ( shipSurf == SHIPSURF_BACK )
+		{//make the droid vulnerable if we have one
+			if ( veh->m_pVehicle
+				&& veh->m_pVehicle->m_pDroidUnit )
+			{//we have one
+				gentity_t *droidEnt = (gentity_t *)veh->m_pVehicle->m_pDroidUnit;
+				if ( droidEnt 
+					&& (droidEnt->flags&FL_UNDYING) )
+				{//make it vulnerab;e
+					droidEnt->flags &= ~FL_UNDYING;
+				}
+			}
+		}
+		break;
+	case 1://light only
+		//add light
+		dmgFlag = SHIPSURF_DAMAGE_FRONT_LIGHT+(shipSurf-SHIPSURF_FRONT);
+		veh->client->ps.brokenLimbs |= (1<<dmgFlag);
+		//remove heavy (shouldn't have to do this, but...
+		dmgFlag = SHIPSURF_DAMAGE_FRONT_HEAVY+(shipSurf-SHIPSURF_FRONT);
+		veh->client->ps.brokenLimbs &= ~(1<<dmgFlag);
+		//copy down
+		veh->s.brokenLimbs = veh->client->ps.brokenLimbs;
+		break;
+	case 0://no damage
+	default:
+		//remove heavy
+		dmgFlag = SHIPSURF_DAMAGE_FRONT_HEAVY+(shipSurf-SHIPSURF_FRONT);
+		veh->client->ps.brokenLimbs &= ~(1<<dmgFlag);
+		//remove light
+		dmgFlag = SHIPSURF_DAMAGE_FRONT_LIGHT+(shipSurf-SHIPSURF_FRONT);
+		veh->client->ps.brokenLimbs &= ~(1<<dmgFlag);
+		//copy down
+		veh->s.brokenLimbs = veh->client->ps.brokenLimbs;
+		break;
+	}
+}
+
+void G_VehicleSetDamageLocFlags( gentity_t *veh, int impactDir, int deathPoint )
+{
+	if ( !veh->client )
+	{
+		return;
+	}
+	else
+	{
+		int	deathPoint, heavyDamagePoint, lightDamagePoint;
+		switch(impactDir)
+		{
+		case SHIPSURF_FRONT:
+			deathPoint = veh->m_pVehicle->m_pVehicleInfo->health_front;
+			break;
+		case SHIPSURF_BACK:
+			deathPoint = veh->m_pVehicle->m_pVehicleInfo->health_back;
+			break;
+		case SHIPSURF_RIGHT:
+			deathPoint = veh->m_pVehicle->m_pVehicleInfo->health_right;
+			break;
+		case SHIPSURF_LEFT:
+			deathPoint = veh->m_pVehicle->m_pVehicleInfo->health_left;
+			break;
+		default:
+			return;
+			break;
+		}
+		if ( veh->m_pVehicle
+			&& veh->m_pVehicle->m_pVehicleInfo
+			&& veh->m_pVehicle->m_pVehicleInfo->malfunctionArmorLevel 
+			&& veh->m_pVehicle->m_pVehicleInfo->armor )
+		{
+			float perc = ((float)veh->m_pVehicle->m_pVehicleInfo->malfunctionArmorLevel/(float)veh->m_pVehicle->m_pVehicleInfo->armor);
+			if ( perc > 0.99f )
+			{
+				perc = 0.99f;
+			}
+			heavyDamagePoint = ceil( deathPoint*perc*0.25f );
+			lightDamagePoint = ceil( deathPoint*perc );
+		}
+		else
+		{
+			heavyDamagePoint = ceil( deathPoint*0.66f );
+			lightDamagePoint = ceil( deathPoint*0.14f );
+		}
+
+		if ( veh->locationDamage[impactDir] >= deathPoint)
+		{//destroyed
+			G_SetVehDamageFlags( veh, impactDir, 3 );
+		}
+		else if ( veh->locationDamage[impactDir] <= heavyDamagePoint )
+		{//heavy only
+			G_SetVehDamageFlags( veh, impactDir, 2 );
+		}
+		else if ( veh->locationDamage[impactDir] <= lightDamagePoint )
+		{//light only
+			G_SetVehDamageFlags( veh, impactDir, 1 );
+		}
+	}
+}
+
+qboolean G_FlyVehicleDestroySurface( gentity_t *veh, int surface )
+{
+	char *surfName[4]; //up to 4 surfs at once
+	int numSurfs = 0;
+	int smashedBits = 0;
+
+	if (surface == -1)
+	{ //not valid?
+		return qfalse;
+	}
+
+	switch(surface)
+	{
+	case SHIPSURF_FRONT: //break the nose off
+		surfName[0] = "nose";
+
+		smashedBits = (SHIPSURF_BROKEN_G);
+
+		numSurfs = 1;
+		break;
+	case SHIPSURF_BACK: //break both the bottom wings off for a backward impact I guess
+		surfName[0] = "r_wing2";
+		surfName[1] = "l_wing2";
+
+		//get rid of the landing gear
+		surfName[2] = "r_gear";
+		surfName[3] = "l_gear";
+
+		smashedBits = (SHIPSURF_BROKEN_A|SHIPSURF_BROKEN_B|SHIPSURF_BROKEN_D|SHIPSURF_BROKEN_F);
+
+		numSurfs = 4;
+		break;
+	case SHIPSURF_RIGHT: //break both right wings off
+		surfName[0] = "r_wing1";
+		surfName[1] = "r_wing2";
+
+		//get rid of the landing gear
+		surfName[2] = "r_gear";
+
+		smashedBits = (SHIPSURF_BROKEN_B|SHIPSURF_BROKEN_E|SHIPSURF_BROKEN_F);
+
+		numSurfs = 3;
+		break;
+	case SHIPSURF_LEFT: //break both left wings off
+		surfName[0] = "l_wing1";
+		surfName[1] = "l_wing2";
+
+		//get rid of the landing gear
+		surfName[2] = "l_gear";
+
+		smashedBits = (SHIPSURF_BROKEN_A|SHIPSURF_BROKEN_C|SHIPSURF_BROKEN_D);
+
+		numSurfs = 3;
+		break;
+	default:
+		break;
+	}
+
+	if (numSurfs < 1)
+	{ //didn't get any valid surfs..
+		return qfalse;
+	}
+
+	while (numSurfs > 0)
+	{ //use my silly system of automatically managing surf status on both client and server
+		numSurfs--;
+		NPC_SetSurfaceOnOff(veh, surfName[numSurfs], TURN_OFF);
+	}
+
+	if ( !veh->m_pVehicle->m_iRemovedSurfaces )
+	{//first time something got blown off
+		if ( veh->m_pVehicle->m_pPilot )
+		{//make the pilot scream to his death
+			G_EntitySound((gentity_t*)veh->m_pVehicle->m_pPilot, CHAN_VOICE, G_SoundIndex("*falling1.wav"));
+		}
+	}
+	//so we can check what's broken
+	veh->m_pVehicle->m_iRemovedSurfaces |= smashedBits;
+
+	//do some explosive damage, but don't damage this ship with it
+	G_RadiusDamage(veh->client->ps.origin, veh, 100, 500, veh, NULL, MOD_SUICIDE);
+
+	//when spiraling to your death, do the electical shader
+	veh->client->ps.electrifyTime = level.time + 10000;
+
+	return qtrue;
+}
+
+void G_FlyVehicleSurfaceDestruction(gentity_t *veh, trace_t *trace, int magnitude, qboolean force)
+{
+	int impactDir;
+	int secondImpact;
+	int deathPoint = -1;
+	qboolean alreadyRebroken = qfalse;
+
+	if (!veh->ghoul2 || !veh->m_pVehicle)
+	{ //no g2 instance.. or no vehicle instance
+		return;
+	}
+
+    impactDir = G_FlyVehicleImpactDir(veh, trace);
+
+anotherImpact:
+	if (impactDir == -1)
+	{ //not valid?
+		return;
+	}
+
+	veh->locationDamage[impactDir] += magnitude*7;
+
+	switch(impactDir)
+	{
+	case SHIPSURF_FRONT:
+		deathPoint = veh->m_pVehicle->m_pVehicleInfo->health_front;
+		break;
+	case SHIPSURF_BACK:
+		deathPoint = veh->m_pVehicle->m_pVehicleInfo->health_back;
+		break;
+	case SHIPSURF_RIGHT:
+		deathPoint = veh->m_pVehicle->m_pVehicleInfo->health_right;
+		break;
+	case SHIPSURF_LEFT:
+		deathPoint = veh->m_pVehicle->m_pVehicleInfo->health_left;
+		break;
+	default:
+		break;
+	}
+
+	if ( deathPoint != -1 )
+	{//got a valid health value
+		if ( force && veh->locationDamage[impactDir] < deathPoint )
+		{//force that surf to be destroyed
+			veh->locationDamage[impactDir] = deathPoint;
+		}
+		if ( veh->locationDamage[impactDir] >= deathPoint)
+		{ //do it
+			if ( G_FlyVehicleDestroySurface( veh, impactDir ) )
+			{//actually took off a surface
+				G_VehicleSetDamageLocFlags( veh, impactDir, deathPoint );
+			}
+		}
+		else
+		{
+			G_VehicleSetDamageLocFlags( veh, impactDir, deathPoint );
+		}
+	}
+
+	if (!alreadyRebroken)
+	{
+		secondImpact = G_FlyVehicleImpactDir(veh, trace);
+		if (impactDir != secondImpact)
+		{ //can break off another piece in this same impact.. but only break off up to 2 at once
+			alreadyRebroken = qtrue;
+			impactDir = secondImpact;
+			goto anotherImpact;
+		}
+	}
+}
+
+void G_VehUpdateShields( gentity_t *targ )
+{
+	if ( !targ || !targ->client 
+		|| !targ->m_pVehicle || !targ->m_pVehicle->m_pVehicleInfo )
+	{
+		return;
+	}
+	if ( targ->m_pVehicle->m_pVehicleInfo->shields <= 0 )
+	{//doesn't have shields, so don't have to send it
+		return;
+	}
+	targ->client->ps.activeForcePass = floor(((float)targ->m_pVehicle->m_iShields/(float)targ->m_pVehicle->m_pVehicleInfo->shields)*10.0f);
+}
+#endif
+
+// Set the parent entity of this Vehicle NPC.
+GAME_INLINE void SetParent( Vehicle_t *pVeh, bgEntity_t *pParentEntity ) { pVeh->m_pParentEntity = pParentEntity; }
+
+// Add a pilot to the vehicle.
+GAME_INLINE void SetPilot( Vehicle_t *pVeh, bgEntity_t *pPilot ) { pVeh->m_pPilot = pPilot; }
+
+// Add a passenger to the vehicle (false if we're full).
+GAME_INLINE bool AddPassenger( Vehicle_t *pVeh ) { return false; }
+
+// Whether this vehicle is currently inhabited (by anyone) or not.
+GAME_INLINE bool Inhabited( Vehicle_t *pVeh ) { return ( pVeh->m_pPilot || pVeh->m_iNumPassengers ) ? true : false; }
+
+
+// Setup the shared functions (one's that all vehicles would generally use).
+void G_SetSharedVehicleFunctions( vehicleInfo_t *pVehInfo )
+{
+//	pVehInfo->AnimateVehicle				=		AnimateVehicle;
+//	pVehInfo->AnimateRiders					=		AnimateRiders;
+	pVehInfo->ValidateBoard					=		ValidateBoard;
+	pVehInfo->SetParent						=		SetParent;
+	pVehInfo->SetPilot						=		SetPilot;
+	pVehInfo->AddPassenger					=		AddPassenger;
+	pVehInfo->Animate						=		Animate;
+	pVehInfo->Board							=		Board;
+	pVehInfo->Eject							=		Eject;
+	pVehInfo->EjectAll						=		EjectAll;
+	pVehInfo->StartDeathDelay				=		StartDeathDelay;
+	pVehInfo->DeathUpdate					=		DeathUpdate;
+	pVehInfo->RegisterAssets				=		RegisterAssets;
+	pVehInfo->Initialize					=		Initialize;
+	pVehInfo->Update						=		Update;
+	pVehInfo->UpdateRider					=		UpdateRider;
+//	pVehInfo->ProcessMoveCommands			=		ProcessMoveCommands;
+//	pVehInfo->ProcessOrientCommands			=		ProcessOrientCommands;
+	pVehInfo->AttachRiders					=		AttachRiders;
+	pVehInfo->Ghost							=		Ghost;
+	pVehInfo->UnGhost						=		UnGhost;
+	pVehInfo->Inhabited						=		Inhabited;
+}
+
+#ifdef _JK2MP
+//get rid of all the crazy defs we added for this file
+#undef currentAngles
+#undef currentOrigin
+#undef mins
+#undef maxs
+#undef legsAnimTimer
+#undef torsoAnimTimer
+#undef bool
+#undef false
+#undef true
+
+#undef sqrtf
+
+#undef MOD_EXPLOSIVE
+#endif
diff --git a/codemp/game/g_weapon.c b/codemp/game/g_weapon.c
new file mode 100644
index 0000000..ac5fbad
--- /dev/null
+++ b/codemp/game/g_weapon.c
@@ -0,0 +1,4953 @@
+// Copyright (C) 1999-2000 Id Software, Inc.
+//
+// g_weapon.c 
+// perform the server side effects of a weapon firing
+
+#include "g_local.h"
+#include "be_aas.h"
+#include "bg_saga.h"
+#include "../ghoul2/G2.h"
+#include "q_shared.h"
+
+static	float	s_quadFactor;
+static	vec3_t	forward, vright, up;
+static	vec3_t	muzzle;
+
+// Bryar Pistol
+//--------
+#define BRYAR_PISTOL_VEL			1600
+#define BRYAR_PISTOL_DAMAGE			10
+#define BRYAR_CHARGE_UNIT			200.0f	// bryar charging gives us one more unit every 200ms--if you change this, you'll have to do the same in bg_pmove
+#define BRYAR_ALT_SIZE				1.0f
+
+// E11 Blaster
+//---------
+#define BLASTER_SPREAD				1.6f//1.2f
+#define BLASTER_VELOCITY			2300
+#define BLASTER_DAMAGE				20
+
+// Tenloss Disruptor
+//----------
+#define DISRUPTOR_MAIN_DAMAGE			30 //40
+#define DISRUPTOR_MAIN_DAMAGE_SIEGE		50
+#define DISRUPTOR_NPC_MAIN_DAMAGE_CUT	0.25f
+
+#define DISRUPTOR_ALT_DAMAGE			100 //125
+#define DISRUPTOR_NPC_ALT_DAMAGE_CUT	0.2f
+#define DISRUPTOR_ALT_TRACES			3		// can go through a max of 3 damageable(sp?) entities
+#define DISRUPTOR_CHARGE_UNIT			50.0f	// distruptor charging gives us one more unit every 50ms--if you change this, you'll have to do the same in bg_pmove
+
+// Wookiee Bowcaster
+//----------
+#define	BOWCASTER_DAMAGE			50
+#define	BOWCASTER_VELOCITY			1300
+#define BOWCASTER_SPLASH_DAMAGE		0
+#define BOWCASTER_SPLASH_RADIUS		0
+#define BOWCASTER_SIZE				2
+
+#define BOWCASTER_ALT_SPREAD		5.0f
+#define BOWCASTER_VEL_RANGE			0.3f
+#define BOWCASTER_CHARGE_UNIT		200.0f	// bowcaster charging gives us one more unit every 200ms--if you change this, you'll have to do the same in bg_pmove
+
+// Heavy Repeater
+//----------
+#define REPEATER_SPREAD				1.4f
+#define	REPEATER_DAMAGE				14
+#define	REPEATER_VELOCITY			1600
+
+#define REPEATER_ALT_SIZE				3	// half of bbox size
+#define	REPEATER_ALT_DAMAGE				60
+#define REPEATER_ALT_SPLASH_DAMAGE		60
+#define REPEATER_ALT_SPLASH_RADIUS		128
+#define REPEATER_ALT_SPLASH_RAD_SIEGE	80
+#define	REPEATER_ALT_VELOCITY			1100
+
+// DEMP2
+//----------
+#define	DEMP2_DAMAGE				35
+#define	DEMP2_VELOCITY				1800
+#define	DEMP2_SIZE					2		// half of bbox size
+
+#define DEMP2_ALT_DAMAGE			8 //12		// does 12, 36, 84 at each of the 3 charge levels.
+#define DEMP2_CHARGE_UNIT			700.0f	// demp2 charging gives us one more unit every 700ms--if you change this, you'll have to do the same in bg_weapons
+#define DEMP2_ALT_RANGE				4096
+#define DEMP2_ALT_SPLASHRADIUS		256
+
+// Golan Arms Flechette
+//---------
+#define FLECHETTE_SHOTS				5
+#define FLECHETTE_SPREAD			4.0f
+#define FLECHETTE_DAMAGE			12//15
+#define FLECHETTE_VEL				3500
+#define FLECHETTE_SIZE				1
+#define FLECHETTE_MINE_RADIUS_CHECK	256
+#define FLECHETTE_ALT_DAMAGE		60
+#define FLECHETTE_ALT_SPLASH_DAM	60
+#define FLECHETTE_ALT_SPLASH_RAD	128
+
+// Personal Rocket Launcher
+//---------
+#define	ROCKET_VELOCITY				900
+#define	ROCKET_DAMAGE				100
+#define	ROCKET_SPLASH_DAMAGE		100
+#define	ROCKET_SPLASH_RADIUS		160
+#define ROCKET_SIZE					3
+#define ROCKET_ALT_THINK_TIME		100
+
+// Concussion Rifle
+//---------
+//primary
+//man, this thing is too absurdly powerful. having to
+//slash the values way down from sp.
+#define	CONC_VELOCITY				3000
+#define	CONC_DAMAGE					75 //150
+#define	CONC_NPC_DAMAGE_EASY		40
+#define	CONC_NPC_DAMAGE_NORMAL		80
+#define	CONC_NPC_DAMAGE_HARD		100
+#define	CONC_SPLASH_DAMAGE			40 //50
+#define	CONC_SPLASH_RADIUS			200 //300
+//alt
+#define CONC_ALT_DAMAGE				25 //100
+#define CONC_ALT_NPC_DAMAGE_EASY	20
+#define CONC_ALT_NPC_DAMAGE_MEDIUM	35
+#define CONC_ALT_NPC_DAMAGE_HARD	50
+
+// Stun Baton
+//--------------
+#define STUN_BATON_DAMAGE			20
+#define STUN_BATON_ALT_DAMAGE		20
+#define STUN_BATON_RANGE			8
+
+// Melee
+//--------------
+#define MELEE_SWING1_DAMAGE			10
+#define MELEE_SWING2_DAMAGE			12
+#define MELEE_RANGE					8
+
+// ATST Main Gun
+//--------------
+#define ATST_MAIN_VEL				4000	// 
+#define ATST_MAIN_DAMAGE			25		// 
+#define ATST_MAIN_SIZE				3		// make it easier to hit things
+
+// ATST Side Gun
+//---------------
+#define ATST_SIDE_MAIN_DAMAGE				75
+#define ATST_SIDE_MAIN_VELOCITY				1300
+#define ATST_SIDE_MAIN_NPC_DAMAGE_EASY		30
+#define ATST_SIDE_MAIN_NPC_DAMAGE_NORMAL	40
+#define ATST_SIDE_MAIN_NPC_DAMAGE_HARD		50
+#define ATST_SIDE_MAIN_SIZE					4
+#define ATST_SIDE_MAIN_SPLASH_DAMAGE		10	// yeah, pretty small, either zero out or make it worth having?
+#define ATST_SIDE_MAIN_SPLASH_RADIUS		16	// yeah, pretty small, either zero out or make it worth having?
+
+#define ATST_SIDE_ALT_VELOCITY				1100
+#define ATST_SIDE_ALT_NPC_VELOCITY			600
+#define ATST_SIDE_ALT_DAMAGE				130
+
+#define ATST_SIDE_ROCKET_NPC_DAMAGE_EASY	30
+#define ATST_SIDE_ROCKET_NPC_DAMAGE_NORMAL	50
+#define ATST_SIDE_ROCKET_NPC_DAMAGE_HARD	90
+
+#define	ATST_SIDE_ALT_SPLASH_DAMAGE			130
+#define	ATST_SIDE_ALT_SPLASH_RADIUS			200
+#define ATST_SIDE_ALT_ROCKET_SIZE			5
+#define ATST_SIDE_ALT_ROCKET_SPLASH_SCALE	0.5f	// scales splash for NPC's
+
+extern qboolean G_BoxInBounds( vec3_t point, vec3_t mins, vec3_t maxs, vec3_t boundsMins, vec3_t boundsMaxs );
+extern qboolean G_HeavyMelee( gentity_t *attacker );
+extern void Jedi_Decloak( gentity_t *self );
+
+static void WP_FireEmplaced( gentity_t *ent, qboolean altFire );
+
+void laserTrapStick( gentity_t *ent, vec3_t endpos, vec3_t normal );
+
+void touch_NULL( gentity_t *ent, gentity_t *other, trace_t *trace )
+{
+
+}
+
+void laserTrapExplode( gentity_t *self );
+void RocketDie(gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int mod);
+
+//We should really organize weapon data into tables or parse from the ext data so we have accurate info for this,
+float WP_SpeedOfMissileForWeapon( int wp, qboolean alt_fire )
+{
+	return 500;
+}
+
+//-----------------------------------------------------------------------------
+void W_TraceSetStart( gentity_t *ent, vec3_t start, vec3_t mins, vec3_t maxs )
+//-----------------------------------------------------------------------------
+{
+	//make sure our start point isn't on the other side of a wall
+	trace_t	tr;
+	vec3_t	entMins;
+	vec3_t	entMaxs;
+	vec3_t	eyePoint;
+
+	VectorAdd( ent->r.currentOrigin, ent->r.mins, entMins );
+	VectorAdd( ent->r.currentOrigin, ent->r.maxs, entMaxs );
+
+	if ( G_BoxInBounds( start, mins, maxs, entMins, entMaxs ) )
+	{
+		return;
+	}
+
+	if ( !ent->client )
+	{
+		return;
+	}
+
+	VectorCopy( ent->s.pos.trBase, eyePoint);
+	eyePoint[2] += ent->client->ps.viewheight;
+		
+	trap_Trace( &tr, eyePoint, mins, maxs, start, ent->s.number, MASK_SOLID|CONTENTS_SHOTCLIP );
+
+	if ( tr.startsolid || tr.allsolid )
+	{
+		return;
+	}
+
+	if ( tr.fraction < 1.0f )
+	{
+		VectorCopy( tr.endpos, start );
+	}
+}
+
+
+/*
+----------------------------------------------
+	PLAYER WEAPONS
+----------------------------------------------
+*/
+
+/*
+======================================================================
+
+BRYAR PISTOL
+
+======================================================================
+*/
+
+//----------------------------------------------
+static void WP_FireBryarPistol( gentity_t *ent, qboolean altFire )
+//---------------------------------------------------------
+{
+	int damage = BRYAR_PISTOL_DAMAGE;
+	int count;
+
+	gentity_t	*missile = CreateMissile( muzzle, forward, BRYAR_PISTOL_VEL, 10000, ent, altFire );
+
+	missile->classname = "bryar_proj";
+	missile->s.weapon = WP_BRYAR_PISTOL;
+
+	if ( altFire )
+	{
+		float boxSize = 0;
+
+		count = ( level.time - ent->client->ps.weaponChargeTime ) / BRYAR_CHARGE_UNIT;
+
+		if ( count < 1 )
+		{
+			count = 1;
+		}
+		else if ( count > 5 )
+		{
+			count = 5;
+		}
+
+		if (count > 1)
+		{
+			damage *= (count*1.7);
+		}
+		else
+		{
+			damage *= (count*1.5);
+		}
+
+		missile->s.generic1 = count; // The missile will then render according to the charge level.
+
+		boxSize = BRYAR_ALT_SIZE*(count*0.5);
+
+		VectorSet( missile->r.maxs, boxSize, boxSize, boxSize );
+		VectorSet( missile->r.mins, -boxSize, -boxSize, -boxSize );
+	}
+
+	missile->damage = damage;
+	missile->dflags = DAMAGE_DEATH_KNOCKBACK;
+	if (altFire)
+	{
+		missile->methodOfDeath = MOD_BRYAR_PISTOL_ALT;
+	}
+	else
+	{
+		missile->methodOfDeath = MOD_BRYAR_PISTOL;
+	}
+	missile->clipmask = MASK_SHOT | CONTENTS_LIGHTSABER;
+
+	// we don't want it to bounce forever
+	missile->bounceCount = 8;
+}
+
+/*
+======================================================================
+
+GENERIC
+
+======================================================================
+*/
+
+//---------------------------------------------------------
+void WP_FireTurretMissile( gentity_t *ent, vec3_t start, vec3_t dir, qboolean altFire, int damage, int velocity, int mod, gentity_t *ignore )
+//---------------------------------------------------------
+{
+	gentity_t *missile;
+
+	missile = CreateMissile( start, dir, velocity, 10000, ent, altFire );
+
+	missile->classname = "generic_proj";
+	missile->s.weapon = WP_TURRET;
+
+	missile->damage = damage;
+	missile->dflags = DAMAGE_DEATH_KNOCKBACK;
+	missile->methodOfDeath = mod;
+	missile->clipmask = MASK_SHOT | CONTENTS_LIGHTSABER;
+
+	if (ignore)
+	{
+		missile->passThroughNum = ignore->s.number+1;
+	}
+
+	// we don't want it to bounce forever
+	missile->bounceCount = 8;
+}
+
+//Currently only the seeker drone uses this, but it might be useful for other things as well.
+
+//---------------------------------------------------------
+void WP_FireGenericBlasterMissile( gentity_t *ent, vec3_t start, vec3_t dir, qboolean altFire, int damage, int velocity, int mod )
+//---------------------------------------------------------
+{
+	gentity_t *missile;
+
+	missile = CreateMissile( start, dir, velocity, 10000, ent, altFire );
+
+	missile->classname = "generic_proj";
+	missile->s.weapon = WP_BRYAR_PISTOL;
+
+	missile->damage = damage;
+	missile->dflags = DAMAGE_DEATH_KNOCKBACK;
+	missile->methodOfDeath = mod;
+	missile->clipmask = MASK_SHOT | CONTENTS_LIGHTSABER;
+
+	// we don't want it to bounce forever
+	missile->bounceCount = 8;
+}
+
+/*
+======================================================================
+
+BLASTER
+
+======================================================================
+*/
+
+//---------------------------------------------------------
+void WP_FireBlasterMissile( gentity_t *ent, vec3_t start, vec3_t dir, qboolean altFire )
+//---------------------------------------------------------
+{
+	int velocity	= BLASTER_VELOCITY;
+	int	damage		= BLASTER_DAMAGE;
+	gentity_t *missile;
+
+	if (ent->s.eType == ET_NPC)
+	{ //animent
+		damage = 10;
+	}
+
+	missile = CreateMissile( start, dir, velocity, 10000, ent, altFire );
+
+	missile->classname = "blaster_proj";
+	missile->s.weapon = WP_BLASTER;
+
+	missile->damage = damage;
+	missile->dflags = DAMAGE_DEATH_KNOCKBACK;
+	missile->methodOfDeath = MOD_BLASTER;
+	missile->clipmask = MASK_SHOT | CONTENTS_LIGHTSABER;
+
+	// we don't want it to bounce forever
+	missile->bounceCount = 8;
+}
+
+//---------------------------------------------------------
+void WP_FireTurboLaserMissile( gentity_t *ent, vec3_t start, vec3_t dir )
+//---------------------------------------------------------
+{
+	int velocity	= ent->mass; //FIXME: externalize
+	gentity_t *missile;
+
+	missile = CreateMissile( start, dir, velocity, 10000, ent, qfalse );
+	
+	//use a custom shot effect
+	missile->s.otherEntityNum2 = ent->genericValue14;
+	//use a custom impact effect
+	missile->s.emplacedOwner = ent->genericValue15;
+
+	missile->classname = "turbo_proj";
+	missile->s.weapon = WP_TURRET;
+
+	missile->damage = ent->damage;		//FIXME: externalize
+	missile->splashDamage = ent->splashDamage;	//FIXME: externalize
+	missile->splashRadius = ent->splashRadius;	//FIXME: externalize
+	missile->dflags = DAMAGE_DEATH_KNOCKBACK;
+	missile->methodOfDeath = MOD_TURBLAST; //count as a heavy weap
+	missile->splashMethodOfDeath = MOD_TURBLAST;// ?SPLASH;
+	missile->clipmask = MASK_SHOT;
+
+	// we don't want it to bounce forever
+	missile->bounceCount = 8;
+
+	//set veh as cgame side owner for purpose of fx overrides
+	missile->s.owner = ent->s.number;
+
+	//don't let them last forever
+	missile->think = G_FreeEntity;
+	missile->nextthink = level.time + 5000;//at 20000 speed, that should be more than enough
+}
+
+//---------------------------------------------------------
+void WP_FireEmplacedMissile( gentity_t *ent, vec3_t start, vec3_t dir, qboolean altFire, gentity_t *ignore )
+//---------------------------------------------------------
+{
+	int velocity	= BLASTER_VELOCITY;
+	int	damage		= BLASTER_DAMAGE;
+	gentity_t *missile;
+
+	missile = CreateMissile( start, dir, velocity, 10000, ent, altFire );
+
+	missile->classname = "emplaced_gun_proj";
+	missile->s.weapon = WP_TURRET;//WP_EMPLACED_GUN;
+
+	missile->activator = ignore;
+
+	missile->damage = damage;
+	missile->dflags = (DAMAGE_DEATH_KNOCKBACK|DAMAGE_HEAVY_WEAP_CLASS);
+	missile->methodOfDeath = MOD_VEHICLE;
+	missile->clipmask = MASK_SHOT | CONTENTS_LIGHTSABER;
+
+	if (ignore)
+	{
+		missile->passThroughNum = ignore->s.number+1;
+	}
+
+	// we don't want it to bounce forever
+	missile->bounceCount = 8;
+}
+
+//---------------------------------------------------------
+static void WP_FireBlaster( gentity_t *ent, qboolean altFire )
+//---------------------------------------------------------
+{
+	vec3_t	dir, angs;
+
+	vectoangles( forward, angs );
+
+	if ( altFire )
+	{
+		// add some slop to the alt-fire direction
+		angs[PITCH] += crandom() * BLASTER_SPREAD;
+		angs[YAW]	+= crandom() * BLASTER_SPREAD;
+	}
+
+	AngleVectors( angs, dir, NULL, NULL );
+
+	// FIXME: if temp_org does not have clear trace to inside the bbox, don't shoot!
+	WP_FireBlasterMissile( ent, muzzle, dir, altFire );
+}
+
+
+
+int G_GetHitLocation(gentity_t *target, vec3_t ppoint);
+
+/*
+======================================================================
+
+DISRUPTOR
+
+======================================================================
+*/
+//---------------------------------------------------------
+static void WP_DisruptorMainFire( gentity_t *ent )
+//---------------------------------------------------------
+{
+	int			damage = DISRUPTOR_MAIN_DAMAGE;
+	qboolean	render_impact = qtrue;
+	vec3_t		start, end;
+	trace_t		tr;
+	gentity_t	*traceEnt, *tent;
+	float		shotRange = 8192;
+	int			ignore, traces;
+
+	if ( g_gametype.integer == GT_SIEGE )
+	{
+		damage = DISRUPTOR_MAIN_DAMAGE_SIEGE;
+	}
+
+	memset(&tr, 0, sizeof(tr)); //to shut the compiler up
+
+	VectorCopy( ent->client->ps.origin, start );
+	start[2] += ent->client->ps.viewheight;//By eyes
+
+	VectorMA( start, shotRange, forward, end );
+
+	ignore = ent->s.number;
+	traces = 0;
+	while ( traces < 10 )
+	{//need to loop this in case we hit a Jedi who dodges the shot
+		if (d_projectileGhoul2Collision.integer)
+		{
+			trap_G2Trace( &tr, start, NULL, NULL, end, ignore, MASK_SHOT, G2TRFLAG_DOGHOULTRACE|G2TRFLAG_GETSURFINDEX|G2TRFLAG_THICK|G2TRFLAG_HITCORPSES, g_g2TraceLod.integer );
+		}
+		else
+		{
+			trap_Trace( &tr, start, NULL, NULL, end, ignore, MASK_SHOT );
+		}
+
+		traceEnt = &g_entities[tr.entityNum];
+
+		if (d_projectileGhoul2Collision.integer && traceEnt->inuse && traceEnt->client)
+		{ //g2 collision checks -rww
+			if (traceEnt->inuse && traceEnt->client && traceEnt->ghoul2)
+			{ //since we used G2TRFLAG_GETSURFINDEX, tr.surfaceFlags will actually contain the index of the surface on the ghoul2 model we collided with.
+				traceEnt->client->g2LastSurfaceHit = tr.surfaceFlags;
+				traceEnt->client->g2LastSurfaceTime = level.time;
+			}
+
+			if (traceEnt->ghoul2)
+			{
+				tr.surfaceFlags = 0; //clear the surface flags after, since we actually care about them in here.
+			}
+		}
+
+		if (traceEnt && traceEnt->client && traceEnt->client->ps.duelInProgress &&
+			traceEnt->client->ps.duelIndex != ent->s.number)
+		{
+			VectorCopy( tr.endpos, start );
+			ignore = tr.entityNum;
+			traces++;
+			continue;
+		}
+
+		if ( Jedi_DodgeEvasion( traceEnt, ent, &tr, G_GetHitLocation(traceEnt, tr.endpos) ) )
+		{//act like we didn't even hit him
+			VectorCopy( tr.endpos, start );
+			ignore = tr.entityNum;
+			traces++;
+			continue;
+		}
+		else if (traceEnt && traceEnt->client && traceEnt->client->ps.fd.forcePowerLevel[FP_SABER_DEFENSE] >= FORCE_LEVEL_3)
+		{
+			if (WP_SaberCanBlock(traceEnt, tr.endpos, 0, MOD_DISRUPTOR, qtrue, 0))
+			{ //broadcast and stop the shot because it was blocked
+				gentity_t *te = NULL;
+
+				tent = G_TempEntity( tr.endpos, EV_DISRUPTOR_MAIN_SHOT );
+				VectorCopy( muzzle, tent->s.origin2 );
+				tent->s.eventParm = ent->s.number;
+
+				te = G_TempEntity( tr.endpos, EV_SABER_BLOCK );
+				VectorCopy(tr.endpos, te->s.origin);
+				VectorCopy(tr.plane.normal, te->s.angles);
+				if (!te->s.angles[0] && !te->s.angles[1] && !te->s.angles[2])
+				{
+					te->s.angles[1] = 1;
+				}
+				te->s.eventParm = 0;
+
+				return;
+			}
+		}
+		else if ( (traceEnt->flags&FL_SHIELDED) )
+		{//stopped cold
+			return;
+		}
+		//a Jedi is not dodging this shot
+		break;
+	}
+
+	if ( tr.surfaceFlags & SURF_NOIMPACT ) 
+	{
+		render_impact = qfalse;
+	}
+
+	// always render a shot beam, doing this the old way because I don't much feel like overriding the effect.
+	tent = G_TempEntity( tr.endpos, EV_DISRUPTOR_MAIN_SHOT );
+	VectorCopy( muzzle, tent->s.origin2 );
+	tent->s.eventParm = ent->s.number;
+
+	traceEnt = &g_entities[tr.entityNum];
+
+	if ( render_impact )
+	{
+		if ( tr.entityNum < ENTITYNUM_WORLD && traceEnt->takedamage )
+		{
+			if ( traceEnt->client && LogAccuracyHit( traceEnt, ent )) 
+			{
+				ent->client->accuracy_hits++;
+			} 
+
+			G_Damage( traceEnt, ent, ent, forward, tr.endpos, damage, DAMAGE_NORMAL, MOD_DISRUPTOR );
+			
+			tent = G_TempEntity( tr.endpos, EV_DISRUPTOR_HIT );
+			tent->s.eventParm = DirToByte( tr.plane.normal );
+			if (traceEnt->client)
+			{
+				tent->s.weapon = 1;
+			}
+		}
+		else 
+		{
+			 // Hmmm, maybe don't make any marks on things that could break
+			tent = G_TempEntity( tr.endpos, EV_DISRUPTOR_SNIPER_MISS );
+			tent->s.eventParm = DirToByte( tr.plane.normal );
+			tent->s.weapon = 1;
+		}
+	}
+}
+
+
+qboolean G_CanDisruptify(gentity_t *ent)
+{
+	if (!ent || !ent->inuse || !ent->client || ent->s.eType != ET_NPC ||
+		ent->s.NPC_class != CLASS_VEHICLE || !ent->m_pVehicle)
+	{ //not vehicle
+		return qtrue;
+	}
+
+	if (ent->m_pVehicle->m_pVehicleInfo->type == VH_ANIMAL)
+	{ //animal is only type that can be disintigeiteigerated
+		return qtrue;
+	}
+
+	//don't do it to any other veh
+	return qfalse;
+}
+
+//---------------------------------------------------------
+void WP_DisruptorAltFire( gentity_t *ent )
+//---------------------------------------------------------
+{
+	int			damage = 0, skip;
+	qboolean	render_impact = qtrue;
+	vec3_t		start, end;
+	vec3_t		muzzle2;
+	trace_t		tr;
+	gentity_t	*traceEnt, *tent;
+	float		shotRange = 8192.0f;
+	int			i;
+	int			count, maxCount = 60;
+	int			traces = DISRUPTOR_ALT_TRACES;
+	qboolean	fullCharge = qfalse;
+
+	damage = DISRUPTOR_ALT_DAMAGE-30;
+
+	VectorCopy( muzzle, muzzle2 ); // making a backup copy
+
+	if (ent->client)
+	{
+		VectorCopy( ent->client->ps.origin, start );
+		start[2] += ent->client->ps.viewheight;//By eyes
+
+		count = ( level.time - ent->client->ps.weaponChargeTime ) / DISRUPTOR_CHARGE_UNIT;
+		if ( g_gametype.integer == GT_SIEGE )
+		{//maybe a full alt-charge should be a *bit* more dangerous in Siege mode?
+			//maxCount = ceil((200.0f-(float)damage)/2.0f);//cap at 200 damage total
+			maxCount = 200;//the previous line ALWAYS evaluated to 135 - was that on purpose?
+		}
+	}
+	else
+	{
+		VectorCopy( ent->r.currentOrigin, start );
+		start[2] += 24;
+
+		count = ( 100 ) / DISRUPTOR_CHARGE_UNIT;
+	}
+
+	count *= 2;
+
+	if ( count < 1 )
+	{
+		count = 1;
+	}
+	else if ( count >= maxCount )
+	{
+		count = maxCount;
+		fullCharge = qtrue;
+	}
+
+	// more powerful charges go through more things
+	if ( count < 10 )
+	{
+		traces = 1;
+	}
+	else if ( count < 20 )
+	{
+		traces = 2;
+	}
+
+	damage += count;
+	
+	skip = ent->s.number;
+
+	for (i = 0; i < traces; i++ )
+	{
+		VectorMA( start, shotRange, forward, end );
+
+		if (d_projectileGhoul2Collision.integer)
+		{
+			trap_G2Trace( &tr, start, NULL, NULL, end, skip, MASK_SHOT, G2TRFLAG_DOGHOULTRACE|G2TRFLAG_GETSURFINDEX|G2TRFLAG_THICK|G2TRFLAG_HITCORPSES, g_g2TraceLod.integer );
+		}
+		else
+		{
+			trap_Trace( &tr, start, NULL, NULL, end, skip, MASK_SHOT );
+		}
+
+		traceEnt = &g_entities[tr.entityNum];
+
+		if (d_projectileGhoul2Collision.integer && traceEnt->inuse && traceEnt->client)
+		{ //g2 collision checks -rww
+			if (traceEnt->inuse && traceEnt->client && traceEnt->ghoul2)
+			{ //since we used G2TRFLAG_GETSURFINDEX, tr.surfaceFlags will actually contain the index of the surface on the ghoul2 model we collided with.
+				traceEnt->client->g2LastSurfaceHit = tr.surfaceFlags;
+				traceEnt->client->g2LastSurfaceTime = level.time;
+			}
+
+			if (traceEnt->ghoul2)
+			{
+				tr.surfaceFlags = 0; //clear the surface flags after, since we actually care about them in here.
+			}
+		}
+
+		if ( tr.surfaceFlags & SURF_NOIMPACT ) 
+		{
+			render_impact = qfalse;
+		}
+
+		if (traceEnt && traceEnt->client && traceEnt->client->ps.duelInProgress &&
+			traceEnt->client->ps.duelIndex != ent->s.number)
+		{
+			skip = tr.entityNum;
+			VectorCopy(tr.endpos, start);
+			continue;
+		}
+
+		if (Jedi_DodgeEvasion(traceEnt, ent, &tr, G_GetHitLocation(traceEnt, tr.endpos)))
+		{
+			skip = tr.entityNum;
+			VectorCopy(tr.endpos, start);
+			continue;
+		}
+		else if (traceEnt && traceEnt->client && traceEnt->client->ps.fd.forcePowerLevel[FP_SABER_DEFENSE] >= FORCE_LEVEL_3)
+		{
+			if (WP_SaberCanBlock(traceEnt, tr.endpos, 0, MOD_DISRUPTOR_SNIPER, qtrue, 0))
+			{ //broadcast and stop the shot because it was blocked
+				gentity_t *te = NULL;
+
+				tent = G_TempEntity( tr.endpos, EV_DISRUPTOR_SNIPER_SHOT );
+				VectorCopy( muzzle, tent->s.origin2 );
+				tent->s.shouldtarget = fullCharge;
+				tent->s.eventParm = ent->s.number;
+
+				te = G_TempEntity( tr.endpos, EV_SABER_BLOCK );
+				VectorCopy(tr.endpos, te->s.origin);
+				VectorCopy(tr.plane.normal, te->s.angles);
+				if (!te->s.angles[0] && !te->s.angles[1] && !te->s.angles[2])
+				{
+					te->s.angles[1] = 1;
+				}
+				te->s.eventParm = 0;
+
+				return;
+			}
+		}
+
+		// always render a shot beam, doing this the old way because I don't much feel like overriding the effect.
+		tent = G_TempEntity( tr.endpos, EV_DISRUPTOR_SNIPER_SHOT );
+		VectorCopy( muzzle, tent->s.origin2 );
+		tent->s.shouldtarget = fullCharge;
+		tent->s.eventParm = ent->s.number;
+
+		// If the beam hits a skybox, etc. it would look foolish to add impact effects
+		if ( render_impact ) 
+		{
+			if ( traceEnt->takedamage && traceEnt->client )
+			{
+				tent->s.otherEntityNum = traceEnt->s.number;
+
+				// Create a simple impact type mark
+				tent = G_TempEntity(tr.endpos, EV_MISSILE_MISS);
+				tent->s.eventParm = DirToByte(tr.plane.normal);
+				tent->s.eFlags |= EF_ALT_FIRING;
+	
+				if ( LogAccuracyHit( traceEnt, ent )) 
+				{
+					if (ent->client)
+					{
+						ent->client->accuracy_hits++;
+					}
+				}
+			} 
+			else 
+			{
+				 if ( traceEnt->r.svFlags & SVF_GLASS_BRUSH 
+						|| traceEnt->takedamage 
+						|| traceEnt->s.eType == ET_MOVER )
+				 {
+					if ( traceEnt->takedamage )
+					{
+						G_Damage( traceEnt, ent, ent, forward, tr.endpos, damage, 
+								DAMAGE_NO_KNOCKBACK, MOD_DISRUPTOR_SNIPER );
+
+						tent = G_TempEntity( tr.endpos, EV_DISRUPTOR_HIT );
+						tent->s.eventParm = DirToByte( tr.plane.normal );
+					}
+				 }
+				 else
+				 {
+					 // Hmmm, maybe don't make any marks on things that could break
+					tent = G_TempEntity( tr.endpos, EV_DISRUPTOR_SNIPER_MISS );
+					tent->s.eventParm = DirToByte( tr.plane.normal );
+				 }
+				break; // and don't try any more traces
+			}
+
+			if ( (traceEnt->flags&FL_SHIELDED) )
+			{//stops us cold
+				break;
+			}
+
+			if ( traceEnt->takedamage )
+			{
+				vec3_t preAng;
+				int preHealth = traceEnt->health;
+				int preLegs = 0;
+				int preTorso = 0;
+
+				if (traceEnt->client)
+				{
+					preLegs = traceEnt->client->ps.legsAnim;
+					preTorso = traceEnt->client->ps.torsoAnim;
+					VectorCopy(traceEnt->client->ps.viewangles, preAng);
+				}
+
+				G_Damage( traceEnt, ent, ent, forward, tr.endpos, damage, DAMAGE_NO_KNOCKBACK, MOD_DISRUPTOR_SNIPER );
+
+				if (traceEnt->client && preHealth > 0 && traceEnt->health <= 0 && fullCharge &&
+					G_CanDisruptify(traceEnt))
+				{ //was killed by a fully charged sniper shot, so disintegrate
+					VectorCopy(preAng, traceEnt->client->ps.viewangles);
+
+					traceEnt->client->ps.eFlags |= EF_DISINTEGRATION;
+					VectorCopy(tr.endpos, traceEnt->client->ps.lastHitLoc);
+
+					traceEnt->client->ps.legsAnim = preLegs;
+					traceEnt->client->ps.torsoAnim = preTorso;
+
+					traceEnt->r.contents = 0;
+
+					VectorClear(traceEnt->client->ps.velocity);
+				}
+
+				tent = G_TempEntity( tr.endpos, EV_DISRUPTOR_HIT );
+				tent->s.eventParm = DirToByte( tr.plane.normal );
+				if (traceEnt->client)
+				{
+					tent->s.weapon = 1;
+				}
+			}
+		}
+		else // not rendering impact, must be a skybox or other similar thing?
+		{
+			break; // don't try anymore traces
+		}
+
+		// Get ready for an attempt to trace through another person
+		VectorCopy( tr.endpos, muzzle );
+		VectorCopy( tr.endpos, start );
+		skip = tr.entityNum;
+	}
+}
+
+
+//---------------------------------------------------------
+static void WP_FireDisruptor( gentity_t *ent, qboolean altFire )
+//---------------------------------------------------------
+{
+	if (!ent || !ent->client || ent->client->ps.zoomMode != 1)
+	{ //do not ever let it do the alt fire when not zoomed
+		altFire = qfalse;
+	}
+
+	if (ent && ent->s.eType == ET_NPC && !ent->client)
+	{ //special case for animents
+		WP_DisruptorAltFire( ent );
+		return;
+	}
+
+	if ( altFire )
+	{
+		WP_DisruptorAltFire( ent );
+	}
+	else
+	{
+		WP_DisruptorMainFire( ent );
+	}
+}
+
+
+/*
+======================================================================
+
+BOWCASTER
+
+======================================================================
+*/
+
+static void WP_BowcasterAltFire( gentity_t *ent )
+{
+	int	damage	= BOWCASTER_DAMAGE;
+
+	gentity_t *missile = CreateMissile( muzzle, forward, BOWCASTER_VELOCITY, 10000, ent, qfalse);
+
+	missile->classname = "bowcaster_proj";
+	missile->s.weapon = WP_BOWCASTER;
+
+	VectorSet( missile->r.maxs, BOWCASTER_SIZE, BOWCASTER_SIZE, BOWCASTER_SIZE );
+	VectorScale( missile->r.maxs, -1, missile->r.mins );
+
+	missile->damage = damage;
+	missile->dflags = DAMAGE_DEATH_KNOCKBACK;
+	missile->methodOfDeath = MOD_BOWCASTER;
+	missile->clipmask = MASK_SHOT | CONTENTS_LIGHTSABER;
+
+	missile->flags |= FL_BOUNCE;
+	missile->bounceCount = 3;
+}
+
+//---------------------------------------------------------
+static void WP_BowcasterMainFire( gentity_t *ent )
+//---------------------------------------------------------
+{
+	int			damage	= BOWCASTER_DAMAGE, count;
+	float		vel;
+	vec3_t		angs, dir;
+	gentity_t	*missile;
+	int i;
+
+	if (!ent->client)
+	{
+		count = 1;
+	}
+	else
+	{
+		count = ( level.time - ent->client->ps.weaponChargeTime ) / BOWCASTER_CHARGE_UNIT;
+	}
+
+	if ( count < 1 )
+	{
+		count = 1;
+	}
+	else if ( count > 5 )
+	{
+		count = 5;
+	}
+
+	if ( !(count & 1 ))
+	{
+		// if we aren't odd, knock us down a level
+		count--;
+	}
+
+	//scale the damage down based on how many are about to be fired
+	if (count <= 1)
+	{
+		damage = 50;
+	}
+	else if (count == 2)
+	{
+		damage = 45;
+	}
+	else if (count == 3)
+	{
+		damage = 40;
+	}
+	else if (count == 4)
+	{
+		damage = 35;
+	}
+	else
+	{
+		damage = 30;
+	}
+
+	for (i = 0; i < count; i++ )
+	{
+		// create a range of different velocities
+		vel = BOWCASTER_VELOCITY * ( crandom() * BOWCASTER_VEL_RANGE + 1.0f );
+
+		vectoangles( forward, angs );
+
+		// add some slop to the alt-fire direction
+		angs[PITCH] += crandom() * BOWCASTER_ALT_SPREAD * 0.2f;
+		angs[YAW]	+= ((i+0.5f) * BOWCASTER_ALT_SPREAD - count * 0.5f * BOWCASTER_ALT_SPREAD );
+		
+		AngleVectors( angs, dir, NULL, NULL );
+
+		missile = CreateMissile( muzzle, dir, vel, 10000, ent, qtrue );
+
+		missile->classname = "bowcaster_alt_proj";
+		missile->s.weapon = WP_BOWCASTER;
+
+		VectorSet( missile->r.maxs, BOWCASTER_SIZE, BOWCASTER_SIZE, BOWCASTER_SIZE );
+		VectorScale( missile->r.maxs, -1, missile->r.mins );
+
+		missile->damage = damage;
+		missile->dflags = DAMAGE_DEATH_KNOCKBACK;
+		missile->methodOfDeath = MOD_BOWCASTER;
+		missile->clipmask = MASK_SHOT | CONTENTS_LIGHTSABER;
+
+		// we don't want it to bounce
+		missile->bounceCount = 0;
+	}
+}
+
+//---------------------------------------------------------
+static void WP_FireBowcaster( gentity_t *ent, qboolean altFire )
+//---------------------------------------------------------
+{
+	if ( altFire )
+	{
+		WP_BowcasterAltFire( ent );
+	}
+	else
+	{
+		WP_BowcasterMainFire( ent );
+	}
+}
+
+
+
+/*
+======================================================================
+
+REPEATER
+
+======================================================================
+*/
+
+//---------------------------------------------------------
+static void WP_RepeaterMainFire( gentity_t *ent, vec3_t dir )
+//---------------------------------------------------------
+{
+	int	damage	= REPEATER_DAMAGE;
+
+	gentity_t *missile = CreateMissile( muzzle, dir, REPEATER_VELOCITY, 10000, ent, qfalse );
+
+	missile->classname = "repeater_proj";
+	missile->s.weapon = WP_REPEATER;
+
+	missile->damage = damage;
+	missile->dflags = DAMAGE_DEATH_KNOCKBACK;
+	missile->methodOfDeath = MOD_REPEATER;
+	missile->clipmask = MASK_SHOT | CONTENTS_LIGHTSABER;
+
+	// we don't want it to bounce forever
+	missile->bounceCount = 8;
+}
+
+//---------------------------------------------------------
+static void WP_RepeaterAltFire( gentity_t *ent )
+//---------------------------------------------------------
+{
+	int	damage	= REPEATER_ALT_DAMAGE;
+
+	gentity_t *missile = CreateMissile( muzzle, forward, REPEATER_ALT_VELOCITY, 10000, ent, qtrue );
+
+	missile->classname = "repeater_alt_proj";
+	missile->s.weapon = WP_REPEATER;
+
+	VectorSet( missile->r.maxs, REPEATER_ALT_SIZE, REPEATER_ALT_SIZE, REPEATER_ALT_SIZE );
+	VectorScale( missile->r.maxs, -1, missile->r.mins );
+	missile->s.pos.trType = TR_GRAVITY;
+	missile->s.pos.trDelta[2] += 40.0f; //give a slight boost in the upward direction
+	missile->damage = damage;
+	missile->dflags = DAMAGE_DEATH_KNOCKBACK;
+	missile->methodOfDeath = MOD_REPEATER_ALT;
+	missile->splashMethodOfDeath = MOD_REPEATER_ALT_SPLASH;
+	missile->clipmask = MASK_SHOT | CONTENTS_LIGHTSABER;
+	missile->splashDamage = REPEATER_ALT_SPLASH_DAMAGE;
+	if ( g_gametype.integer == GT_SIEGE )	// we've been having problems with this being too hyper-potent because of it's radius
+	{
+		missile->splashRadius = REPEATER_ALT_SPLASH_RAD_SIEGE;
+	}
+	else
+	{
+		missile->splashRadius = REPEATER_ALT_SPLASH_RADIUS;
+	}
+
+	// we don't want it to bounce forever
+	missile->bounceCount = 8;
+}
+
+//---------------------------------------------------------
+static void WP_FireRepeater( gentity_t *ent, qboolean altFire )
+//---------------------------------------------------------
+{
+	vec3_t	dir, angs;
+
+	vectoangles( forward, angs );
+
+	if ( altFire )
+	{
+		WP_RepeaterAltFire( ent );
+	}
+	else
+	{
+		// add some slop to the alt-fire direction
+		angs[PITCH] += crandom() * REPEATER_SPREAD;
+		angs[YAW]	+= crandom() * REPEATER_SPREAD;
+
+		AngleVectors( angs, dir, NULL, NULL );
+
+		WP_RepeaterMainFire( ent, dir );
+	}
+}
+
+
+/*
+======================================================================
+
+DEMP2
+
+======================================================================
+*/
+
+static void WP_DEMP2_MainFire( gentity_t *ent )
+{
+	int	damage	= DEMP2_DAMAGE;
+
+	gentity_t *missile = CreateMissile( muzzle, forward, DEMP2_VELOCITY, 10000, ent, qfalse);
+
+	missile->classname = "demp2_proj";
+	missile->s.weapon = WP_DEMP2;
+
+	VectorSet( missile->r.maxs, DEMP2_SIZE, DEMP2_SIZE, DEMP2_SIZE );
+	VectorScale( missile->r.maxs, -1, missile->r.mins );
+	missile->damage = damage;
+	missile->dflags = DAMAGE_DEATH_KNOCKBACK;
+	missile->methodOfDeath = MOD_DEMP2;
+	missile->clipmask = MASK_SHOT;
+
+	// we don't want it to ever bounce
+	missile->bounceCount = 0;
+}
+
+static gentity_t *ent_list[MAX_GENTITIES];
+
+void DEMP2_AltRadiusDamage( gentity_t *ent )
+{
+	float		frac = ( level.time - ent->genericValue5 ) / 800.0f; // / 1600.0f; // synchronize with demp2 effect
+	float		dist, radius, fact;
+	gentity_t	*gent;
+	int			iEntityList[MAX_GENTITIES];
+	gentity_t	*entityList[MAX_GENTITIES];
+	gentity_t	*myOwner = NULL;
+	int			numListedEntities, i, e;
+	vec3_t		mins, maxs;
+	vec3_t		v, dir;
+
+	if (ent->r.ownerNum >= 0 &&
+		ent->r.ownerNum < /*MAX_CLIENTS ... let npc's/shooters use it*/MAX_GENTITIES)
+	{
+		myOwner = &g_entities[ent->r.ownerNum];
+	}
+
+	if (!myOwner || !myOwner->inuse || !myOwner->client)
+	{
+		ent->think = G_FreeEntity;
+		ent->nextthink = level.time;
+		return;
+	}
+
+	frac *= frac * frac; // yes, this is completely ridiculous...but it causes the shell to grow slowly then "explode" at the end
+	
+	radius = frac * 200.0f; // 200 is max radius...the model is aprox. 100 units tall...the fx draw code mults. this by 2.
+
+	fact = ent->count*0.6;
+
+	if (fact < 1)
+	{
+		fact = 1;
+	}
+
+	radius *= fact;
+
+	for ( i = 0 ; i < 3 ; i++ ) 
+	{
+		mins[i] = ent->r.currentOrigin[i] - radius;
+		maxs[i] = ent->r.currentOrigin[i] + radius;
+	}
+
+	numListedEntities = trap_EntitiesInBox( mins, maxs, iEntityList, MAX_GENTITIES );
+
+	i = 0;
+	while (i < numListedEntities)
+	{
+		entityList[i] = &g_entities[iEntityList[i]];
+		i++;
+	}
+
+	for ( e = 0 ; e < numListedEntities ; e++ ) 
+	{
+		gent = entityList[ e ];
+
+		if ( !gent || !gent->takedamage || !gent->r.contents )
+		{
+			continue;
+		}
+
+		// find the distance from the edge of the bounding box
+		for ( i = 0 ; i < 3 ; i++ ) 
+		{
+			if ( ent->r.currentOrigin[i] < gent->r.absmin[i] ) 
+			{
+				v[i] = gent->r.absmin[i] - ent->r.currentOrigin[i];
+			} 
+			else if ( ent->r.currentOrigin[i] > gent->r.absmax[i] ) 
+			{
+				v[i] = ent->r.currentOrigin[i] - gent->r.absmax[i];
+			} 
+			else 
+			{
+				v[i] = 0;
+			}
+		}
+
+		// shape is an ellipsoid, so cut vertical distance in half`
+		v[2] *= 0.5f;
+
+		dist = VectorLength( v );
+
+		if ( dist >= radius ) 
+		{
+			// shockwave hasn't hit them yet
+			continue;
+		}
+
+		if (dist+(16*ent->count) < ent->genericValue6)
+		{
+			// shockwave has already hit this thing...
+			continue;
+		}
+
+		VectorCopy( gent->r.currentOrigin, v );
+		VectorSubtract( v, ent->r.currentOrigin, dir);
+
+		// push the center of mass higher than the origin so players get knocked into the air more
+		dir[2] += 12;
+
+		if (gent != myOwner)
+		{
+			G_Damage( gent, myOwner, myOwner, dir, ent->r.currentOrigin, ent->damage, DAMAGE_DEATH_KNOCKBACK, ent->splashMethodOfDeath );
+			if ( gent->takedamage 
+				&& gent->client ) 
+			{
+				if ( gent->client->ps.electrifyTime < level.time )
+				{//electrocution effect
+					if (gent->s.eType == ET_NPC && gent->s.NPC_class == CLASS_VEHICLE &&
+						gent->m_pVehicle && (gent->m_pVehicle->m_pVehicleInfo->type == VH_SPEEDER || gent->m_pVehicle->m_pVehicleInfo->type == VH_WALKER))
+					{ //do some extra stuff to speeders/walkers
+						gent->client->ps.electrifyTime = level.time + Q_irand( 3000, 4000 );
+					}
+					else if ( gent->s.NPC_class != CLASS_VEHICLE 
+						|| (gent->m_pVehicle && gent->m_pVehicle->m_pVehicleInfo->type != VH_FIGHTER) )
+					{//don't do this to fighters
+						gent->client->ps.electrifyTime = level.time + Q_irand( 300, 800 );
+					}
+				}
+				if ( gent->client->ps.powerups[PW_CLOAKED] )
+				{//disable cloak temporarily
+					Jedi_Decloak( gent );
+					gent->client->cloakToggleTime = level.time + Q_irand( 3000, 10000 );
+				}
+			}
+		}
+	}
+
+	// store the last fraction so that next time around we can test against those things that fall between that last point and where the current shockwave edge is
+	ent->genericValue6 = radius;
+
+	if ( frac < 1.0f )
+	{
+		// shock is still happening so continue letting it expand
+		ent->nextthink = level.time + 50;
+	}
+	else
+	{ //don't just leave the entity around
+		ent->think = G_FreeEntity;
+		ent->nextthink = level.time;
+	}
+}
+
+//---------------------------------------------------------
+void DEMP2_AltDetonate( gentity_t *ent )
+//---------------------------------------------------------
+{
+	gentity_t *efEnt;
+
+	G_SetOrigin( ent, ent->r.currentOrigin );
+	if (!ent->pos1[0] && !ent->pos1[1] && !ent->pos1[2])
+	{ //don't play effect with a 0'd out directional vector
+		ent->pos1[1] = 1;
+	}
+	//Let's just save ourself some bandwidth and play both the effect and sphere spawn in 1 event
+	efEnt = G_PlayEffect( EFFECT_EXPLOSION_DEMP2ALT, ent->r.currentOrigin, ent->pos1 );
+
+	if (efEnt)
+	{
+		efEnt->s.weapon = ent->count*2;
+	}
+
+	ent->genericValue5 = level.time;
+	ent->genericValue6 = 0;
+	ent->nextthink = level.time + 50;
+	ent->think = DEMP2_AltRadiusDamage;
+	ent->s.eType = ET_GENERAL; // make us a missile no longer
+}
+
+//---------------------------------------------------------
+static void WP_DEMP2_AltFire( gentity_t *ent )
+//---------------------------------------------------------
+{
+	int		damage	= DEMP2_ALT_DAMAGE;
+	int		count, origcount;
+	float	fact;
+	vec3_t	start, end;
+	trace_t	tr;
+	gentity_t *missile;
+
+	VectorCopy( muzzle, start );
+
+	VectorMA( start, DEMP2_ALT_RANGE, forward, end );
+
+	count = ( level.time - ent->client->ps.weaponChargeTime ) / DEMP2_CHARGE_UNIT;
+
+	origcount = count;
+
+	if ( count < 1 )
+	{
+		count = 1;
+	}
+	else if ( count > 3 )
+	{
+		count = 3;
+	}
+
+	fact = count*0.8;
+	if (fact < 1)
+	{
+		fact = 1;
+	}
+	damage *= fact;
+
+	if (!origcount)
+	{ //this was just a tap-fire
+		damage = 1;
+	}
+
+	trap_Trace( &tr, start, NULL, NULL, end, ent->s.number, MASK_SHOT);
+
+	missile = G_Spawn();
+	G_SetOrigin(missile, tr.endpos);
+	//In SP the impact actually travels as a missile based on the trace fraction, but we're
+	//just going to be instant. -rww
+
+	VectorCopy( tr.plane.normal, missile->pos1 );
+
+	missile->count = count;
+
+	missile->classname = "demp2_alt_proj";
+	missile->s.weapon = WP_DEMP2;
+
+	missile->think = DEMP2_AltDetonate;
+	missile->nextthink = level.time;
+
+	missile->splashDamage = missile->damage = damage;
+	missile->splashMethodOfDeath = missile->methodOfDeath = MOD_DEMP2;
+	missile->splashRadius = DEMP2_ALT_SPLASHRADIUS;
+
+	missile->r.ownerNum = ent->s.number;
+
+	missile->dflags = DAMAGE_DEATH_KNOCKBACK;
+	missile->clipmask = MASK_SHOT | CONTENTS_LIGHTSABER;
+
+	// we don't want it to ever bounce
+	missile->bounceCount = 0;
+}
+
+//---------------------------------------------------------
+static void WP_FireDEMP2( gentity_t *ent, qboolean altFire )
+//---------------------------------------------------------
+{
+	if ( altFire )
+	{
+		WP_DEMP2_AltFire( ent );
+	}
+	else
+	{
+		WP_DEMP2_MainFire( ent );
+	}
+}
+
+
+
+/*
+======================================================================
+
+FLECHETTE
+
+======================================================================
+*/
+
+//---------------------------------------------------------
+static void WP_FlechetteMainFire( gentity_t *ent )
+//---------------------------------------------------------
+{
+	vec3_t		fwd, angs;
+	gentity_t	*missile;
+	int i;
+
+	for (i = 0; i < FLECHETTE_SHOTS; i++ )
+	{
+		vectoangles( forward, angs );
+
+		if (i != 0)
+		{ //do nothing on the first shot, it will hit the crosshairs
+			angs[PITCH] += crandom() * FLECHETTE_SPREAD;
+			angs[YAW]	+= crandom() * FLECHETTE_SPREAD;
+		}
+
+		AngleVectors( angs, fwd, NULL, NULL );
+
+		missile = CreateMissile( muzzle, fwd, FLECHETTE_VEL, 10000, ent, qfalse);
+
+		missile->classname = "flech_proj";
+		missile->s.weapon = WP_FLECHETTE;
+
+		VectorSet( missile->r.maxs, FLECHETTE_SIZE, FLECHETTE_SIZE, FLECHETTE_SIZE );
+		VectorScale( missile->r.maxs, -1, missile->r.mins );
+
+		missile->damage = FLECHETTE_DAMAGE;
+		missile->dflags = DAMAGE_DEATH_KNOCKBACK;
+		missile->methodOfDeath = MOD_FLECHETTE;
+		missile->clipmask = MASK_SHOT | CONTENTS_LIGHTSABER;
+
+		// we don't want it to bounce forever
+		missile->bounceCount = Q_irand(5,8);
+
+		missile->flags |= FL_BOUNCE_SHRAPNEL;
+	}
+}
+
+//---------------------------------------------------------
+void prox_mine_think( gentity_t *ent )
+//---------------------------------------------------------
+{
+	int			count, i;
+	qboolean	blow = qfalse;
+
+	// if it isn't time to auto-explode, do a small proximity check
+	if ( ent->delay > level.time )
+	{
+		count = G_RadiusList( ent->r.currentOrigin, FLECHETTE_MINE_RADIUS_CHECK, ent, qtrue, ent_list );
+
+		for ( i = 0; i < count; i++ )
+		{
+			if ( ent_list[i]->client && ent_list[i]->health > 0 && ent->activator && ent_list[i]->s.number != ent->activator->s.number )
+			{
+				blow = qtrue;
+				break;
+			}
+		}
+	}
+	else
+	{
+		// well, we must die now
+		blow = qtrue;
+	}
+
+	if ( blow )
+	{
+		ent->think = laserTrapExplode;
+		ent->nextthink = level.time + 200;
+	}
+	else
+	{
+		// we probably don't need to do this thinking logic very often...maybe this is fast enough?
+		ent->nextthink = level.time + 500;
+	}
+}
+
+//-----------------------------------------------------------------------------
+static void WP_TraceSetStart( gentity_t *ent, vec3_t start, vec3_t mins, vec3_t maxs )
+//-----------------------------------------------------------------------------
+{
+	//make sure our start point isn't on the other side of a wall
+	trace_t	tr;
+	vec3_t	entMins;
+	vec3_t	entMaxs;
+
+	VectorAdd( ent->r.currentOrigin, ent->r.mins, entMins );
+	VectorAdd( ent->r.currentOrigin, ent->r.maxs, entMaxs );
+
+	if ( G_BoxInBounds( start, mins, maxs, entMins, entMaxs ) )
+	{
+		return;
+	}
+
+	if ( !ent->client )
+	{
+		return;
+	}
+
+	trap_Trace( &tr, ent->client->ps.origin, mins, maxs, start, ent->s.number, MASK_SOLID|CONTENTS_SHOTCLIP );
+
+	if ( tr.startsolid || tr.allsolid )
+	{
+		return;
+	}
+
+	if ( tr.fraction < 1.0f )
+	{
+		VectorCopy( tr.endpos, start );
+	}
+}
+
+void WP_ExplosiveDie(gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int mod)
+{
+	laserTrapExplode(self);
+}
+
+//----------------------------------------------
+void WP_flechette_alt_blow( gentity_t *ent )
+//----------------------------------------------
+{
+	ent->s.pos.trDelta[0] = 1;
+	ent->s.pos.trDelta[1] = 0;
+	ent->s.pos.trDelta[2] = 0;
+
+	laserTrapExplode(ent);
+}
+
+//------------------------------------------------------------------------------
+static void WP_CreateFlechetteBouncyThing( vec3_t start, vec3_t fwd, gentity_t *self )
+//------------------------------------------------------------------------------
+{
+	gentity_t	*missile = CreateMissile( start, fwd, 700 + random() * 700, 1500 + random() * 2000, self, qtrue );
+	
+	missile->think = WP_flechette_alt_blow;
+
+	missile->activator = self;
+
+	missile->s.weapon = WP_FLECHETTE;
+	missile->classname = "flech_alt";
+	missile->mass = 4;
+
+	// How 'bout we give this thing a size...
+	VectorSet( missile->r.mins, -3.0f, -3.0f, -3.0f );
+	VectorSet( missile->r.maxs, 3.0f, 3.0f, 3.0f );
+	missile->clipmask = MASK_SHOT;
+
+	missile->touch = touch_NULL;
+
+	// normal ones bounce, alt ones explode on impact
+	missile->s.pos.trType = TR_GRAVITY;
+
+	missile->flags |= FL_BOUNCE_HALF;
+	missile->s.eFlags |= EF_ALT_FIRING;
+
+	missile->bounceCount = 50;
+
+	missile->damage = FLECHETTE_ALT_DAMAGE;
+	missile->dflags = 0;
+	missile->splashDamage = FLECHETTE_ALT_SPLASH_DAM;
+	missile->splashRadius = FLECHETTE_ALT_SPLASH_RAD;
+
+	missile->r.svFlags = SVF_USE_CURRENT_ORIGIN;
+
+	missile->methodOfDeath = MOD_FLECHETTE_ALT_SPLASH;
+	missile->splashMethodOfDeath = MOD_FLECHETTE_ALT_SPLASH;
+
+	VectorCopy( start, missile->pos2 );
+}
+
+//---------------------------------------------------------
+static void WP_FlechetteAltFire( gentity_t *self )
+//---------------------------------------------------------
+{
+	vec3_t 	dir, fwd, start, angs;
+	int i;
+
+	vectoangles( forward, angs );
+	VectorCopy( muzzle, start );
+
+	WP_TraceSetStart( self, start, vec3_origin, vec3_origin );//make sure our start point isn't on the other side of a wall
+
+	for ( i = 0; i < 2; i++ )
+	{
+		VectorCopy( angs, dir );
+
+		dir[PITCH] -= random() * 4 + 8; // make it fly upwards
+		dir[YAW] += crandom() * 2;
+		AngleVectors( dir, fwd, NULL, NULL );
+
+		WP_CreateFlechetteBouncyThing( start, fwd, self );
+	}
+}
+
+//---------------------------------------------------------
+static void WP_FireFlechette( gentity_t *ent, qboolean altFire )
+//---------------------------------------------------------
+{
+	if ( altFire )
+	{
+		//WP_FlechetteProxMine( ent );
+		WP_FlechetteAltFire(ent);
+	}
+	else
+	{
+		WP_FlechetteMainFire( ent );
+	}
+}
+
+
+
+/*
+======================================================================
+
+ROCKET LAUNCHER
+
+======================================================================
+*/
+
+//---------------------------------------------------------
+void rocketThink( gentity_t *ent )
+//---------------------------------------------------------
+{
+	vec3_t newdir, targetdir, 
+			up={0,0,1}, right; 
+	vec3_t	org;
+	float dot, dot2, dis;
+	int i;
+	float vel = (ent->spawnflags&1)?ent->speed:ROCKET_VELOCITY;
+
+	if ( ent->genericValue1 && ent->genericValue1 < level.time )
+	{//time's up, we're done, remove us
+		if ( ent->genericValue2 )
+		{//explode when die
+			RocketDie( ent, &g_entities[ent->r.ownerNum], &g_entities[ent->r.ownerNum], 0, MOD_UNKNOWN );
+		}
+		else
+		{//just remove when die
+			G_FreeEntity( ent );
+		}
+		return;
+	}
+	if ( !ent->enemy 
+		|| !ent->enemy->client 
+		|| ent->enemy->health <= 0 
+		|| ent->enemy->client->ps.powerups[PW_CLOAKED] )
+	{//no enemy or enemy not a client or enemy dead or enemy cloaked
+		if ( !ent->genericValue1  )
+		{//doesn't have its own self-kill time
+			ent->nextthink = level.time + 10000;
+			ent->think = G_FreeEntity;
+		}
+		return;
+	}
+
+	if ( (ent->spawnflags&1) )
+	{//vehicle rocket
+		if ( ent->enemy->client && ent->enemy->client->NPC_class == CLASS_VEHICLE )
+		{//tracking another vehicle
+			if ( ent->enemy->client->ps.speed+4000 > vel )
+			{
+				vel = ent->enemy->client->ps.speed+4000;
+			}
+		}
+	}
+
+	if ( ent->enemy && ent->enemy->inuse )
+	{	
+		float newDirMult = ent->angle?ent->angle*2.0f:1.0f;
+		float oldDirMult = ent->angle?(1.0f-ent->angle)*2.0f:1.0f;
+
+		VectorCopy( ent->enemy->r.currentOrigin, org );
+		org[2] += (ent->enemy->r.mins[2] + ent->enemy->r.maxs[2]) * 0.5f;
+
+		VectorSubtract( org, ent->r.currentOrigin, targetdir );
+		VectorNormalize( targetdir );
+
+		// Now the rocket can't do a 180 in space, so we'll limit the turn to about 45 degrees.
+		dot = DotProduct( targetdir, ent->movedir );
+
+		// a dot of 1.0 means right-on-target.
+		if ( dot < 0.0f )
+		{	
+			// Go in the direction opposite, start a 180.
+			CrossProduct( ent->movedir, up, right );
+			dot2 = DotProduct( targetdir, right );
+
+			if ( dot2 > 0 )
+			{	
+				// Turn 45 degrees right.
+				VectorMA( ent->movedir, 0.4f*newDirMult, right, newdir );
+			}
+			else
+			{	
+				// Turn 45 degrees left.
+				VectorMA( ent->movedir, -0.4f*newDirMult, right, newdir );
+			}
+
+			// Yeah we've adjusted horizontally, but let's split the difference vertically, so we kinda try to move towards it.
+			newdir[2] = ( (targetdir[2]*newDirMult) + (ent->movedir[2]*oldDirMult) ) * 0.5;
+
+			// let's also slow down a lot
+			vel *= 0.5f;
+		}
+		else if ( dot < 0.70f )
+		{	
+			// Still a bit off, so we turn a bit softer
+			VectorMA( ent->movedir, 0.5f*newDirMult, targetdir, newdir );
+		}
+		else
+		{	
+			// getting close, so turn a bit harder
+			VectorMA( ent->movedir, 0.9f*newDirMult, targetdir, newdir );
+		}
+
+		// add crazy drunkenness
+		for (i = 0; i < 3; i++ )
+		{
+			newdir[i] += crandom() * ent->random * 0.25f;
+		}
+
+		// decay the randomness
+		ent->random *= 0.9f;
+
+		if ( ent->enemy->client
+			&& ent->enemy->client->ps.groundEntityNum != ENTITYNUM_NONE )
+		{//tracking a client who's on the ground, aim at the floor...?
+			// Try to crash into the ground if we get close enough to do splash damage
+			dis = Distance( ent->r.currentOrigin, org );
+
+			if ( dis < 128 )
+			{
+				// the closer we get, the more we push the rocket down, heh heh.
+				newdir[2] -= (1.0f - (dis / 128.0f)) * 0.6f;
+			}
+		}
+
+		VectorNormalize( newdir );
+
+		VectorScale( newdir, vel * 0.5f, ent->s.pos.trDelta );
+		VectorCopy( newdir, ent->movedir );
+		SnapVector( ent->s.pos.trDelta );			// save net bandwidth
+		VectorCopy( ent->r.currentOrigin, ent->s.pos.trBase );
+		ent->s.pos.trTime = level.time;
+	}
+
+	ent->nextthink = level.time + ROCKET_ALT_THINK_TIME;	// Nothing at all spectacular happened, continue.
+	return;
+}
+
+extern void G_ExplodeMissile( gentity_t *ent );
+void RocketDie(gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int mod)
+{
+	self->die = 0;
+	self->r.contents = 0;
+
+	G_ExplodeMissile( self );
+
+	self->think = G_FreeEntity;
+	self->nextthink = level.time;
+}
+
+//---------------------------------------------------------
+static void WP_FireRocket( gentity_t *ent, qboolean altFire )
+//---------------------------------------------------------
+{
+	int	damage	= ROCKET_DAMAGE;
+	int	vel = ROCKET_VELOCITY;
+	int dif = 0;
+	float rTime;
+	gentity_t *missile;
+
+	if ( altFire )
+	{
+		vel *= 0.5f;
+	}
+
+	missile = CreateMissile( muzzle, forward, vel, 10000, ent, altFire );
+
+	if (ent->client && ent->client->ps.rocketLockIndex != ENTITYNUM_NONE)
+	{
+		float lockTimeInterval = ((g_gametype.integer==GT_SIEGE)?2400.0f:1200.0f)/16.0f;
+		rTime = ent->client->ps.rocketLockTime;
+
+		if (rTime == -1)
+		{
+			rTime = ent->client->ps.rocketLastValidTime;
+		}
+		dif = ( level.time - rTime ) / lockTimeInterval;
+
+		if (dif < 0)
+		{
+			dif = 0;
+		}
+
+		//It's 10 even though it locks client-side at 8, because we want them to have a sturdy lock first, and because there's a slight difference in time between server and client
+		if ( dif >= 10 && rTime != -1 )
+		{
+			missile->enemy = &g_entities[ent->client->ps.rocketLockIndex];
+
+			if (missile->enemy && missile->enemy->client && missile->enemy->health > 0 && !OnSameTeam(ent, missile->enemy))
+			{ //if enemy became invalid, died, or is on the same team, then don't seek it
+				missile->angle = 0.5f;
+				missile->think = rocketThink;
+				missile->nextthink = level.time + ROCKET_ALT_THINK_TIME;
+			}
+		}
+
+		ent->client->ps.rocketLockIndex = ENTITYNUM_NONE;
+		ent->client->ps.rocketLockTime = 0;
+		ent->client->ps.rocketTargetTime = 0;
+	}
+
+	missile->classname = "rocket_proj";
+	missile->s.weapon = WP_ROCKET_LAUNCHER;
+
+	// Make it easier to hit things
+	VectorSet( missile->r.maxs, ROCKET_SIZE, ROCKET_SIZE, ROCKET_SIZE );
+	VectorScale( missile->r.maxs, -1, missile->r.mins );
+
+	missile->damage = damage;
+	missile->dflags = DAMAGE_DEATH_KNOCKBACK;
+	if (altFire)
+	{
+		missile->methodOfDeath = MOD_ROCKET_HOMING;
+		missile->splashMethodOfDeath = MOD_ROCKET_HOMING_SPLASH;
+	}
+	else
+	{
+		missile->methodOfDeath = MOD_ROCKET;
+		missile->splashMethodOfDeath = MOD_ROCKET_SPLASH;
+	}
+//===testing being able to shoot rockets out of the air==================================
+	missile->health = 10;
+	missile->takedamage = qtrue;
+	missile->r.contents = MASK_SHOT;
+	missile->die = RocketDie;
+//===testing being able to shoot rockets out of the air==================================
+	
+	missile->clipmask = MASK_SHOT;
+	missile->splashDamage = ROCKET_SPLASH_DAMAGE;
+	missile->splashRadius = ROCKET_SPLASH_RADIUS;
+
+	// we don't want it to ever bounce
+	missile->bounceCount = 0;
+}
+
+/*
+======================================================================
+
+THERMAL DETONATOR
+
+======================================================================
+*/
+
+#define TD_DAMAGE			70 //only do 70 on a direct impact
+#define TD_SPLASH_RAD		128
+#define TD_SPLASH_DAM		90
+#define TD_VELOCITY			900
+#define TD_MIN_CHARGE		0.15f
+#define TD_TIME				3000//6000
+#define TD_ALT_TIME			3000
+
+#define TD_ALT_DAMAGE		60//100
+#define TD_ALT_SPLASH_RAD	128
+#define TD_ALT_SPLASH_DAM	50//90
+#define TD_ALT_VELOCITY		600
+#define TD_ALT_MIN_CHARGE	0.15f
+#define TD_ALT_TIME			3000
+
+void thermalThinkStandard(gentity_t *ent);
+
+//---------------------------------------------------------
+void thermalDetonatorExplode( gentity_t *ent )
+//---------------------------------------------------------
+{
+	if ( !ent->count )
+	{
+		G_Sound( ent, CHAN_WEAPON, G_SoundIndex( "sound/weapons/thermal/warning.wav" ) );
+		ent->count = 1;
+		ent->genericValue5 = level.time + 500;
+		ent->think = thermalThinkStandard;
+		ent->nextthink = level.time;
+		ent->r.svFlags |= SVF_BROADCAST;//so everyone hears/sees the explosion?
+	}
+	else
+	{
+		vec3_t	origin;
+		vec3_t	dir={0,0,1};
+
+		BG_EvaluateTrajectory( &ent->s.pos, level.time, origin );
+		origin[2] += 8;
+		SnapVector( origin );
+		G_SetOrigin( ent, origin );
+
+		ent->s.eType = ET_GENERAL;
+		G_AddEvent( ent, EV_MISSILE_MISS, DirToByte( dir ) );
+		ent->freeAfterEvent = qtrue;
+
+		if (G_RadiusDamage( ent->r.currentOrigin, ent->parent,  ent->splashDamage, ent->splashRadius, 
+				ent, ent, ent->splashMethodOfDeath))
+		{
+			g_entities[ent->r.ownerNum].client->accuracy_hits++;
+		}
+
+		trap_LinkEntity( ent );
+	}
+}
+
+void thermalThinkStandard(gentity_t *ent)
+{
+	if (ent->genericValue5 < level.time)
+	{
+		ent->think = thermalDetonatorExplode;
+		ent->nextthink = level.time;
+		return;
+	}
+
+	G_RunObject(ent);
+	ent->nextthink = level.time;
+}
+
+//---------------------------------------------------------
+gentity_t *WP_FireThermalDetonator( gentity_t *ent, qboolean altFire )
+//---------------------------------------------------------
+{
+	gentity_t	*bolt;
+	vec3_t		dir, start;
+	float chargeAmount = 1.0f; // default of full charge
+	
+	VectorCopy( forward, dir );
+	VectorCopy( muzzle, start );
+
+	bolt = G_Spawn();
+	
+	bolt->physicsObject = qtrue;
+
+	bolt->classname = "thermal_detonator";
+	bolt->think = thermalThinkStandard;
+	bolt->nextthink = level.time;
+	bolt->touch = touch_NULL;
+
+	// How 'bout we give this thing a size...
+	VectorSet( bolt->r.mins, -3.0f, -3.0f, -3.0f );
+	VectorSet( bolt->r.maxs, 3.0f, 3.0f, 3.0f );
+	bolt->clipmask = MASK_SHOT;
+
+	W_TraceSetStart( ent, start, bolt->r.mins, bolt->r.maxs );//make sure our start point isn't on the other side of a wall
+
+	if ( ent->client )
+	{
+		chargeAmount = level.time - ent->client->ps.weaponChargeTime;
+	}
+
+	// get charge amount
+	chargeAmount = chargeAmount / (float)TD_VELOCITY;
+
+	if ( chargeAmount > 1.0f )
+	{
+		chargeAmount = 1.0f;
+	}
+	else if ( chargeAmount < TD_MIN_CHARGE )
+	{
+		chargeAmount = TD_MIN_CHARGE;
+	}
+
+	// normal ones bounce, alt ones explode on impact
+	bolt->genericValue5 = level.time + TD_TIME; // How long 'til she blows
+	bolt->s.pos.trType = TR_GRAVITY;
+	bolt->parent = ent;
+	bolt->r.ownerNum = ent->s.number;
+	VectorScale( dir, TD_VELOCITY * chargeAmount, bolt->s.pos.trDelta );
+
+	if ( ent->health >= 0 )
+	{
+		bolt->s.pos.trDelta[2] += 120;
+	}
+
+	if ( !altFire )
+	{
+		bolt->flags |= FL_BOUNCE_HALF;
+	}
+
+	bolt->s.loopSound = G_SoundIndex( "sound/weapons/thermal/thermloop.wav" );
+	bolt->s.loopIsSoundset = qfalse;
+
+	bolt->damage = TD_DAMAGE;
+	bolt->dflags = 0;
+	bolt->splashDamage = TD_SPLASH_DAM;
+	bolt->splashRadius = TD_SPLASH_RAD;
+
+	bolt->s.eType = ET_MISSILE;
+	bolt->r.svFlags = SVF_USE_CURRENT_ORIGIN;
+	bolt->s.weapon = WP_THERMAL;
+
+	bolt->methodOfDeath = MOD_THERMAL;
+	bolt->splashMethodOfDeath = MOD_THERMAL_SPLASH;
+
+	bolt->s.pos.trTime = level.time;		// move a bit on the very first frame
+	VectorCopy( start, bolt->s.pos.trBase );
+	
+	SnapVector( bolt->s.pos.trDelta );			// save net bandwidth
+	VectorCopy (start, bolt->r.currentOrigin);
+
+	VectorCopy( start, bolt->pos2 );
+
+	bolt->bounceCount = -5;
+
+	return bolt;
+}
+
+gentity_t *WP_DropThermal( gentity_t *ent )
+{
+	AngleVectors( ent->client->ps.viewangles, forward, vright, up );
+	return (WP_FireThermalDetonator( ent, qfalse ));
+}
+
+
+//---------------------------------------------------------
+qboolean WP_LobFire( gentity_t *self, vec3_t start, vec3_t target, vec3_t mins, vec3_t maxs, int clipmask, 
+				vec3_t velocity, qboolean tracePath, int ignoreEntNum, int enemyNum,
+				float minSpeed, float maxSpeed, float idealSpeed, qboolean mustHit )
+//---------------------------------------------------------
+{ //for the galak mech NPC
+	float	targetDist, shotSpeed, speedInc = 100, travelTime, impactDist, bestImpactDist = Q3_INFINITE;//fireSpeed, 
+	vec3_t	targetDir, shotVel, failCase; 
+	trace_t	trace;
+	trajectory_t	tr;
+	qboolean	blocked;
+	int		elapsedTime, skipNum, timeStep = 500, hitCount = 0, maxHits = 7;
+	vec3_t	lastPos, testPos;
+	gentity_t	*traceEnt;
+	
+	if ( !idealSpeed )
+	{
+		idealSpeed = 300;
+	}
+	else if ( idealSpeed < speedInc )
+	{
+		idealSpeed = speedInc;
+	}
+	shotSpeed = idealSpeed;
+	skipNum = (idealSpeed-speedInc)/speedInc;
+	if ( !minSpeed )
+	{
+		minSpeed = 100;
+	}
+	if ( !maxSpeed )
+	{
+		maxSpeed = 900;
+	}
+	while ( hitCount < maxHits )
+	{
+		VectorSubtract( target, start, targetDir );
+		targetDist = VectorNormalize( targetDir );
+
+		VectorScale( targetDir, shotSpeed, shotVel );
+		travelTime = targetDist/shotSpeed;
+		shotVel[2] += travelTime * 0.5 * g_gravity.value;
+
+		if ( !hitCount )		
+		{//save the first (ideal) one as the failCase (fallback value)
+			if ( !mustHit )
+			{//default is fine as a return value
+				VectorCopy( shotVel, failCase );
+			}
+		}
+
+		if ( tracePath )
+		{//do a rough trace of the path
+			blocked = qfalse;
+
+			VectorCopy( start, tr.trBase );
+			VectorCopy( shotVel, tr.trDelta );
+			tr.trType = TR_GRAVITY;
+			tr.trTime = level.time;
+			travelTime *= 1000.0f;
+			VectorCopy( start, lastPos );
+			
+			//This may be kind of wasteful, especially on long throws... use larger steps?  Divide the travelTime into a certain hard number of slices?  Trace just to apex and down?
+			for ( elapsedTime = timeStep; elapsedTime < floor(travelTime)+timeStep; elapsedTime += timeStep )
+			{
+				if ( (float)elapsedTime > travelTime )
+				{//cap it
+					elapsedTime = floor( travelTime );
+				}
+				BG_EvaluateTrajectory( &tr, level.time + elapsedTime, testPos );
+				trap_Trace( &trace, lastPos, mins, maxs, testPos, ignoreEntNum, clipmask );
+
+				if ( trace.allsolid || trace.startsolid )
+				{
+					blocked = qtrue;
+					break;
+				}
+				if ( trace.fraction < 1.0f )
+				{//hit something
+					if ( trace.entityNum == enemyNum )
+					{//hit the enemy, that's perfect!
+						break;
+					}
+					else if ( trace.plane.normal[2] > 0.7 && DistanceSquared( trace.endpos, target ) < 4096 )//hit within 64 of desired location, should be okay
+					{//close enough!
+						break;
+					}
+					else
+					{//FIXME: maybe find the extents of this brush and go above or below it on next try somehow?
+						impactDist = DistanceSquared( trace.endpos, target );
+						if ( impactDist < bestImpactDist )
+						{
+							bestImpactDist = impactDist;
+							VectorCopy( shotVel, failCase );
+						}
+						blocked = qtrue;
+						//see if we should store this as the failCase
+						if ( trace.entityNum < ENTITYNUM_WORLD )
+						{//hit an ent
+							traceEnt = &g_entities[trace.entityNum];
+							if ( traceEnt && traceEnt->takedamage && !OnSameTeam( self, traceEnt ) )
+							{//hit something breakable, so that's okay
+								//we haven't found a clear shot yet so use this as the failcase
+								VectorCopy( shotVel, failCase );
+							}
+						}
+						break;
+					}
+				}
+				if ( elapsedTime == floor( travelTime ) )
+				{//reached end, all clear
+					break;
+				}
+				else
+				{
+					//all clear, try next slice
+					VectorCopy( testPos, lastPos );
+				}
+			}
+			if ( blocked )
+			{//hit something, adjust speed (which will change arc)
+				hitCount++;
+				shotSpeed = idealSpeed + ((hitCount-skipNum) * speedInc);//from min to max (skipping ideal)
+				if ( hitCount >= skipNum )
+				{//skip ideal since that was the first value we tested
+					shotSpeed += speedInc;
+				}
+			}
+			else
+			{//made it!
+				break;
+			}
+		}
+		else
+		{//no need to check the path, go with first calc
+			break;
+		}
+	}
+
+	if ( hitCount >= maxHits )
+	{//NOTE: worst case scenario, use the one that impacted closest to the target (or just use the first try...?)
+		VectorCopy( failCase, velocity );
+		return qfalse;
+	}
+	VectorCopy( shotVel, velocity );
+	return qtrue;
+}
+
+/*
+======================================================================
+
+LASER TRAP / TRIP MINE
+
+======================================================================
+*/
+#define LT_DAMAGE			100
+#define LT_SPLASH_RAD		256.0f
+#define LT_SPLASH_DAM		105
+#define LT_VELOCITY			900.0f
+#define LT_SIZE				1.5f
+#define LT_ALT_TIME			2000
+#define	LT_ACTIVATION_DELAY	1000
+#define	LT_DELAY_TIME		50
+
+void laserTrapExplode( gentity_t *self )
+{
+	vec3_t v;
+	self->takedamage = qfalse;
+
+	if (self->activator)
+	{
+		G_RadiusDamage( self->r.currentOrigin, self->activator, self->splashDamage, self->splashRadius, self, self, MOD_TRIP_MINE_SPLASH/*MOD_LT_SPLASH*/ );
+	}
+
+	if (self->s.weapon != WP_FLECHETTE)
+	{
+		G_AddEvent( self, EV_MISSILE_MISS, 0);
+	}
+
+	VectorCopy(self->s.pos.trDelta, v);
+	//Explode outward from the surface
+
+	if (self->s.time == -2)
+	{
+		v[0] = 0;
+		v[1] = 0;
+		v[2] = 0;
+	}
+
+	if (self->s.weapon == WP_FLECHETTE)
+	{
+		G_PlayEffect(EFFECT_EXPLOSION_FLECHETTE, self->r.currentOrigin, v);
+	}
+	else
+	{
+		G_PlayEffect(EFFECT_EXPLOSION_TRIPMINE, self->r.currentOrigin, v);
+	}
+
+	self->think = G_FreeEntity;
+	self->nextthink = level.time;
+}
+
+void laserTrapDelayedExplode( gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int meansOfDeath )
+{
+	self->enemy = attacker;
+	self->think = laserTrapExplode;
+	self->nextthink = level.time + FRAMETIME;
+	self->takedamage = qfalse;
+	if ( attacker && !attacker->s.number )
+	{
+		//less damage when shot by player
+		self->splashDamage /= 3;
+		self->splashRadius /= 3;
+	}
+}
+
+void touchLaserTrap( gentity_t *ent, gentity_t *other, trace_t *trace )
+{
+	if (other && other->s.number < ENTITYNUM_WORLD)
+	{ //just explode if we hit any entity. This way we don't have things happening like tripmines floating
+	  //in the air after getting stuck to a moving door
+		if ( ent->activator != other )
+		{
+			ent->touch = 0;
+			ent->nextthink = level.time + FRAMETIME;
+			ent->think = laserTrapExplode;
+			VectorCopy(trace->plane.normal, ent->s.pos.trDelta);
+		}
+	}
+	else
+	{
+		ent->touch = 0;
+		if (trace->entityNum != ENTITYNUM_NONE)
+		{
+			ent->enemy = &g_entities[trace->entityNum];
+		}
+		laserTrapStick(ent, trace->endpos, trace->plane.normal);
+	}
+}
+
+void proxMineThink(gentity_t *ent)
+{
+	int i = 0;
+	gentity_t *cl;
+	gentity_t *owner = NULL;
+
+	if (ent->r.ownerNum < ENTITYNUM_WORLD)
+	{
+		owner = &g_entities[ent->r.ownerNum];
+	}
+
+	ent->nextthink = level.time;
+
+	if (ent->genericValue15 < level.time ||
+		!owner ||
+		!owner->inuse ||
+		!owner->client ||
+		owner->client->pers.connected != CON_CONNECTED)
+	{ //time to die!
+		ent->think = laserTrapExplode;
+		return;
+	}
+
+	while (i < MAX_CLIENTS)
+	{ //eh, just check for clients, don't care about anyone else...
+		cl = &g_entities[i];
+
+		if (cl->inuse && cl->client && cl->client->pers.connected == CON_CONNECTED &&
+			owner != cl && cl->client->sess.sessionTeam != TEAM_SPECTATOR &&
+			cl->client->tempSpectate < level.time && cl->health > 0)
+		{
+			if (!OnSameTeam(owner, cl) || g_friendlyFire.integer)
+			{ //not on the same team, or friendly fire is enabled
+				vec3_t v;
+
+				VectorSubtract(ent->r.currentOrigin, cl->client->ps.origin, v);
+				if (VectorLength(v) < (ent->splashRadius/2.0f))
+				{
+					ent->think = laserTrapExplode;
+					return;
+				}
+			}
+		}
+		i++;
+	}
+}
+
+void laserTrapThink ( gentity_t *ent )
+{
+	gentity_t	*traceEnt;
+	vec3_t		end;
+	trace_t		tr;
+
+	//just relink it every think
+	trap_LinkEntity(ent);
+
+	//turn on the beam effect
+	if ( !(ent->s.eFlags&EF_FIRING) )
+	{//arm me
+		G_Sound( ent, CHAN_WEAPON, G_SoundIndex( "sound/weapons/laser_trap/warning.wav" ) );
+		ent->s.eFlags |= EF_FIRING;
+	}
+	ent->think = laserTrapThink;
+	ent->nextthink = level.time + FRAMETIME;
+
+	// Find the main impact point
+	VectorMA ( ent->s.pos.trBase, 1024, ent->movedir, end );
+	trap_Trace ( &tr, ent->r.currentOrigin, NULL, NULL, end, ent->s.number, MASK_SHOT);
+	
+	traceEnt = &g_entities[ tr.entityNum ];
+
+	ent->s.time = -1; //let all clients know to draw a beam from this guy
+
+	if ( traceEnt->client || tr.startsolid )
+	{
+		//go boom
+		ent->touch = 0;
+		ent->nextthink = level.time + LT_DELAY_TIME;
+		ent->think = laserTrapExplode;
+	}
+}
+
+void laserTrapStick( gentity_t *ent, vec3_t endpos, vec3_t normal )
+{
+	G_SetOrigin( ent, endpos );
+	VectorCopy( normal, ent->pos1 );
+
+	VectorClear( ent->s.apos.trDelta );
+	// This will orient the object to face in the direction of the normal
+	VectorCopy( normal, ent->s.pos.trDelta );
+	//VectorScale( normal, -1, ent->s.pos.trDelta );
+	ent->s.pos.trTime = level.time;
+	
+	
+	//This does nothing, cg_missile makes assumptions about direction of travel controlling angles
+	vectoangles( normal, ent->s.apos.trBase );
+	VectorClear( ent->s.apos.trDelta );
+	ent->s.apos.trType = TR_STATIONARY;
+	VectorCopy( ent->s.apos.trBase, ent->s.angles );
+	VectorCopy( ent->s.angles, ent->r.currentAngles );
+	
+
+	G_Sound( ent, CHAN_WEAPON, G_SoundIndex( "sound/weapons/laser_trap/stick.wav" ) );
+	if ( ent->count )
+	{//a tripwire
+		//add draw line flag
+		VectorCopy( normal, ent->movedir );
+		ent->think = laserTrapThink;
+		ent->nextthink = level.time + LT_ACTIVATION_DELAY;//delay the activation
+		ent->touch = touch_NULL;
+		//make it shootable
+		ent->takedamage = qtrue;
+		ent->health = 5;
+		ent->die = laserTrapDelayedExplode;
+
+		//shove the box through the wall
+		VectorSet( ent->r.mins, -LT_SIZE*2, -LT_SIZE*2, -LT_SIZE*2 );
+		VectorSet( ent->r.maxs, LT_SIZE*2, LT_SIZE*2, LT_SIZE*2 );
+
+		//so that the owner can blow it up with projectiles
+		ent->r.svFlags |= SVF_OWNERNOTSHARED;
+	}
+	else
+	{
+		ent->touch = touchLaserTrap;
+		ent->think = proxMineThink;//laserTrapExplode;
+		ent->genericValue15 = level.time + 30000; //auto-explode after 30 seconds.
+		ent->nextthink = level.time + LT_ALT_TIME; // How long 'til she blows
+
+		//make it shootable
+		ent->takedamage = qtrue;
+		ent->health = 5;
+		ent->die = laserTrapDelayedExplode;
+
+		//shove the box through the wall
+		VectorSet( ent->r.mins, -LT_SIZE*2, -LT_SIZE*2, -LT_SIZE*2 );
+		VectorSet( ent->r.maxs, LT_SIZE*2, LT_SIZE*2, LT_SIZE*2 );
+
+		//so that the owner can blow it up with projectiles
+		ent->r.svFlags |= SVF_OWNERNOTSHARED;
+
+		if ( !(ent->s.eFlags&EF_FIRING) )
+		{//arm me
+			G_Sound( ent, CHAN_WEAPON, G_SoundIndex( "sound/weapons/laser_trap/warning.wav" ) );
+			ent->s.eFlags |= EF_FIRING;
+			ent->s.time = -1;
+			ent->s.bolt2 = 1;
+		}
+	}
+}
+
+void TrapThink(gentity_t *ent)
+{ //laser trap think
+	ent->nextthink = level.time + 50;
+	G_RunObject(ent);
+}
+
+void CreateLaserTrap( gentity_t *laserTrap, vec3_t start, gentity_t *owner )
+{ //create a laser trap entity
+	laserTrap->classname = "laserTrap";
+	laserTrap->flags |= FL_BOUNCE_HALF;
+	laserTrap->s.eFlags |= EF_MISSILE_STICK;
+	laserTrap->splashDamage = LT_SPLASH_DAM;
+	laserTrap->splashRadius = LT_SPLASH_RAD;
+	laserTrap->damage = LT_DAMAGE;
+	laserTrap->methodOfDeath = MOD_TRIP_MINE_SPLASH;
+	laserTrap->splashMethodOfDeath = MOD_TRIP_MINE_SPLASH;
+	laserTrap->s.eType = ET_GENERAL;
+	laserTrap->r.svFlags = SVF_USE_CURRENT_ORIGIN;
+	laserTrap->s.weapon = WP_TRIP_MINE;
+	laserTrap->s.pos.trType = TR_GRAVITY;
+	laserTrap->r.contents = MASK_SHOT;
+	laserTrap->parent = owner;
+	laserTrap->activator = owner;
+	laserTrap->r.ownerNum = owner->s.number;
+	VectorSet( laserTrap->r.mins, -LT_SIZE, -LT_SIZE, -LT_SIZE );
+	VectorSet( laserTrap->r.maxs, LT_SIZE, LT_SIZE, LT_SIZE );
+	laserTrap->clipmask = MASK_SHOT;
+	laserTrap->s.solid = 2;
+	laserTrap->s.modelindex = G_ModelIndex( "models/weapons2/laser_trap/laser_trap_w.glm" );
+	laserTrap->s.modelGhoul2 = 1;
+	laserTrap->s.g2radius = 40;
+
+	laserTrap->s.genericenemyindex = owner->s.number+MAX_GENTITIES;
+
+	laserTrap->health = 1;
+
+	laserTrap->s.time = 0;
+
+	laserTrap->s.pos.trTime = level.time;		// move a bit on the very first frame
+	VectorCopy( start, laserTrap->s.pos.trBase );
+	SnapVector( laserTrap->s.pos.trBase );			// save net bandwidth
+	
+	SnapVector( laserTrap->s.pos.trDelta );			// save net bandwidth
+	VectorCopy (start, laserTrap->r.currentOrigin);
+
+	laserTrap->s.apos.trType = TR_GRAVITY;
+	laserTrap->s.apos.trTime = level.time;
+	laserTrap->s.apos.trBase[YAW] = rand()%360;
+	laserTrap->s.apos.trBase[PITCH] = rand()%360;
+	laserTrap->s.apos.trBase[ROLL] = rand()%360;
+
+	if (rand()%10 < 5)
+	{
+		laserTrap->s.apos.trBase[YAW] = -laserTrap->s.apos.trBase[YAW];
+	}
+
+	VectorCopy( start, laserTrap->pos2 );
+	laserTrap->touch = touchLaserTrap;
+	laserTrap->think = TrapThink;
+	laserTrap->nextthink = level.time + 50;
+}
+
+void WP_PlaceLaserTrap( gentity_t *ent, qboolean alt_fire )
+{
+	gentity_t	*laserTrap;
+	gentity_t	*found = NULL;
+	vec3_t		dir, start;
+	int			trapcount = 0;
+	int			foundLaserTraps[MAX_GENTITIES];
+	int			trapcount_org;
+	int			lowestTimeStamp;
+	int			removeMe;
+	int			i;
+
+	foundLaserTraps[0] = ENTITYNUM_NONE;
+
+	VectorCopy( forward, dir );
+	VectorCopy( muzzle, start );
+
+	laserTrap = G_Spawn();
+	
+	//limit to 10 placed at any one time
+	//see how many there are now
+	while ( (found = G_Find( found, FOFS(classname), "laserTrap" )) != NULL )
+	{
+		if ( found->parent != ent )
+		{
+			continue;
+		}
+		foundLaserTraps[trapcount++] = found->s.number;
+	}
+	//now remove first ones we find until there are only 9 left
+	found = NULL;
+	trapcount_org = trapcount;
+	lowestTimeStamp = level.time;
+	while ( trapcount > 9 )
+	{
+		removeMe = -1;
+		for ( i = 0; i < trapcount_org; i++ )
+		{
+			if ( foundLaserTraps[i] == ENTITYNUM_NONE )
+			{
+				continue;
+			}
+			found = &g_entities[foundLaserTraps[i]];
+			if ( laserTrap && found->setTime < lowestTimeStamp )
+			{
+				removeMe = i;
+				lowestTimeStamp = found->setTime;
+			}
+		}
+		if ( removeMe != -1 )
+		{
+			//remove it... or blow it?
+			if ( &g_entities[foundLaserTraps[removeMe]] == NULL )
+			{
+				break;
+			}
+			else
+			{
+				G_FreeEntity( &g_entities[foundLaserTraps[removeMe]] );
+			}
+			foundLaserTraps[removeMe] = ENTITYNUM_NONE;
+			trapcount--;
+		}
+		else
+		{
+			break;
+		}
+	}
+
+	//now make the new one
+	CreateLaserTrap( laserTrap, start, ent );
+
+	//set player-created-specific fields
+	laserTrap->setTime = level.time;//remember when we placed it
+
+	if (!alt_fire)
+	{//tripwire
+		laserTrap->count = 1;
+	}
+
+	//move it
+	laserTrap->s.pos.trType = TR_GRAVITY;
+
+	if (alt_fire)
+	{
+		VectorScale( dir, 512, laserTrap->s.pos.trDelta );
+	}
+	else
+	{
+		VectorScale( dir, 256, laserTrap->s.pos.trDelta );
+	}
+
+	trap_LinkEntity(laserTrap);
+}
+
+
+/*
+======================================================================
+
+DET PACK
+
+======================================================================
+*/
+void VectorNPos(vec3_t in, vec3_t out)
+{
+	if (in[0] < 0) { out[0] = -in[0]; } else { out[0] = in[0]; }
+	if (in[1] < 0) { out[1] = -in[1]; } else { out[1] = in[1]; }
+	if (in[2] < 0) { out[2] = -in[2]; } else { out[2] = in[2]; }
+}
+
+void DetPackBlow(gentity_t *self);
+
+void charge_stick (gentity_t *self, gentity_t *other, trace_t *trace)
+{
+	gentity_t	*tent;
+
+	if ( other 
+		&& (other->flags&FL_BBRUSH)
+		&& other->s.pos.trType == TR_STATIONARY
+		&& other->s.apos.trType == TR_STATIONARY )
+	{//a perfectly still breakable brush, let us attach directly to it!
+		self->target_ent = other;//remember them when we blow up
+	}
+	else if ( other 
+		&& other->s.number < ENTITYNUM_WORLD
+		&& other->s.eType == ET_MOVER
+		&& trace->plane.normal[2] > 0 )
+	{//stick to it?
+		self->s.groundEntityNum = other->s.number;
+	}
+	else if (other && other->s.number < ENTITYNUM_WORLD &&
+		(other->client || !other->s.weapon))
+	{ //hit another entity that is not stickable, "bounce" off
+		vec3_t vNor, tN;
+
+		VectorCopy(trace->plane.normal, vNor);
+		VectorNormalize(vNor);
+		VectorNPos(self->s.pos.trDelta, tN);
+		self->s.pos.trDelta[0] += vNor[0]*(tN[0]*(((float)Q_irand(1, 10))*0.1));
+		self->s.pos.trDelta[1] += vNor[1]*(tN[1]*(((float)Q_irand(1, 10))*0.1));
+		self->s.pos.trDelta[2] += vNor[1]*(tN[2]*(((float)Q_irand(1, 10))*0.1));
+
+		vectoangles(vNor, self->s.angles);
+		vectoangles(vNor, self->s.apos.trBase);
+		self->touch = charge_stick;
+		return;
+	}
+	else if (other && other->s.number < ENTITYNUM_WORLD)
+	{ //hit an entity that we just want to explode on (probably another projectile or something)
+		vec3_t v;
+
+		self->touch = 0;
+		self->think = 0;
+		self->nextthink = 0;
+
+		self->takedamage = qfalse;
+
+		VectorClear(self->s.apos.trDelta);
+		self->s.apos.trType = TR_STATIONARY;
+
+		G_RadiusDamage( self->r.currentOrigin, self->parent, self->splashDamage, self->splashRadius, self, self, MOD_DET_PACK_SPLASH );
+		VectorCopy(trace->plane.normal, v);
+		VectorCopy(v, self->pos2);
+		self->count = -1;
+		G_PlayEffect(EFFECT_EXPLOSION_DETPACK, self->r.currentOrigin, v);
+
+		self->think = G_FreeEntity;
+		self->nextthink = level.time;
+		return;
+	}
+
+	//if we get here I guess we hit hte world so we can stick to it
+
+	self->touch = 0;
+	self->think = DetPackBlow;
+	self->nextthink = level.time + 30000;
+
+	VectorClear(self->s.apos.trDelta);
+	self->s.apos.trType = TR_STATIONARY;
+
+	self->s.pos.trType = TR_STATIONARY;
+	VectorCopy( self->r.currentOrigin, self->s.origin );
+	VectorCopy( self->r.currentOrigin, self->s.pos.trBase );
+	VectorClear( self->s.pos.trDelta );
+
+	VectorClear( self->s.apos.trDelta );
+
+	VectorNormalize(trace->plane.normal);
+
+	vectoangles(trace->plane.normal, self->s.angles);
+	VectorCopy(self->s.angles, self->r.currentAngles );
+	VectorCopy(self->s.angles, self->s.apos.trBase);
+
+	VectorCopy(trace->plane.normal, self->pos2);
+	self->count = -1;
+
+	G_Sound(self, CHAN_WEAPON, G_SoundIndex("sound/weapons/detpack/stick.wav"));
+		
+	tent = G_TempEntity( self->r.currentOrigin, EV_MISSILE_MISS );
+	tent->s.weapon = 0;
+	tent->parent = self;
+	tent->r.ownerNum = self->s.number;
+
+	//so that the owner can blow it up with projectiles
+	self->r.svFlags |= SVF_OWNERNOTSHARED;
+}
+
+void DetPackBlow(gentity_t *self)
+{
+	vec3_t v;
+
+	self->pain = 0;
+	self->die = 0;
+	self->takedamage = qfalse;
+
+	if ( self->target_ent )
+	{//we were attached to something, do *direct* damage to it!
+		G_Damage( self->target_ent, self, &g_entities[self->r.ownerNum], v, self->r.currentOrigin, self->damage, 0, MOD_DET_PACK_SPLASH );
+	}
+	G_RadiusDamage( self->r.currentOrigin, self->parent, self->splashDamage, self->splashRadius, self, self, MOD_DET_PACK_SPLASH );
+	v[0] = 0;
+	v[1] = 0;
+	v[2] = 1;
+
+	if (self->count == -1)
+	{
+		VectorCopy(self->pos2, v);
+	}
+
+	G_PlayEffect(EFFECT_EXPLOSION_DETPACK, self->r.currentOrigin, v);
+
+	self->think = G_FreeEntity;
+	self->nextthink = level.time;
+}
+
+void DetPackPain(gentity_t *self, gentity_t *attacker, int damage)
+{
+	self->think = DetPackBlow;
+	self->nextthink = level.time + Q_irand(50, 100);
+	self->takedamage = qfalse;
+}
+
+void DetPackDie(gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int mod)
+{
+	self->think = DetPackBlow;
+	self->nextthink = level.time + Q_irand(50, 100);
+	self->takedamage = qfalse;
+}
+
+void drop_charge (gentity_t *self, vec3_t start, vec3_t dir) 
+{
+	gentity_t	*bolt;
+
+	VectorNormalize (dir);
+
+	bolt = G_Spawn();
+	bolt->classname = "detpack";
+	bolt->nextthink = level.time + FRAMETIME;
+	bolt->think = G_RunObject;
+	bolt->s.eType = ET_GENERAL;
+	bolt->s.g2radius = 100;
+	bolt->s.modelGhoul2 = 1;
+	bolt->s.modelindex = G_ModelIndex("models/weapons2/detpack/det_pack_proj.glm");
+
+	bolt->parent = self;
+	bolt->r.ownerNum = self->s.number;
+	bolt->damage = 100;
+	bolt->splashDamage = 200;
+	bolt->splashRadius = 200;
+	bolt->methodOfDeath = MOD_DET_PACK_SPLASH;
+	bolt->splashMethodOfDeath = MOD_DET_PACK_SPLASH;
+	bolt->clipmask = MASK_SHOT;
+	bolt->s.solid = 2;
+	bolt->r.contents = MASK_SHOT;
+	bolt->touch = charge_stick;
+
+	bolt->physicsObject = qtrue;
+
+	bolt->s.genericenemyindex = self->s.number+MAX_GENTITIES;
+	//rww - so client prediction knows we own this and won't hit it
+
+	VectorSet( bolt->r.mins, -2, -2, -2 );
+	VectorSet( bolt->r.maxs, 2, 2, 2 );
+
+	bolt->health = 1;
+	bolt->takedamage = qtrue;
+	bolt->pain = DetPackPain;
+	bolt->die = DetPackDie;
+
+	bolt->s.weapon = WP_DET_PACK;
+
+	bolt->setTime = level.time;
+
+	G_SetOrigin(bolt, start);
+	bolt->s.pos.trType = TR_GRAVITY;
+	VectorCopy( start, bolt->s.pos.trBase );
+	VectorScale(dir, 300, bolt->s.pos.trDelta );
+	bolt->s.pos.trTime = level.time;
+
+	bolt->s.apos.trType = TR_GRAVITY;
+	bolt->s.apos.trTime = level.time;
+	bolt->s.apos.trBase[YAW] = rand()%360;
+	bolt->s.apos.trBase[PITCH] = rand()%360;
+	bolt->s.apos.trBase[ROLL] = rand()%360;
+
+	if (rand()%10 < 5)
+	{
+		bolt->s.apos.trBase[YAW] = -bolt->s.apos.trBase[YAW];
+	}
+
+	vectoangles(dir, bolt->s.angles);
+	VectorCopy(bolt->s.angles, bolt->s.apos.trBase);
+	VectorSet(bolt->s.apos.trDelta, 300, 0, 0 );
+	bolt->s.apos.trTime = level.time;
+
+	trap_LinkEntity(bolt);
+}
+
+void BlowDetpacks(gentity_t *ent)
+{
+	gentity_t *found = NULL;
+
+	if ( ent->client->ps.hasDetPackPlanted )
+	{
+		while ( (found = G_Find( found, FOFS(classname), "detpack") ) != NULL )
+		{//loop through all ents and blow the crap out of them!
+			if ( found->parent == ent )
+			{
+				VectorCopy( found->r.currentOrigin, found->s.origin );
+				found->think = DetPackBlow;
+				found->nextthink = level.time + 100 + random() * 200;
+				G_Sound( found, CHAN_BODY, G_SoundIndex("sound/weapons/detpack/warning.wav") );
+			}
+		}
+		ent->client->ps.hasDetPackPlanted = qfalse;
+	}
+}
+
+qboolean CheatsOn(void) 
+{
+	if ( !g_cheats.integer )
+	{
+		return qfalse;
+	}
+	return qtrue;
+}
+
+void WP_DropDetPack( gentity_t *ent, qboolean alt_fire )
+{
+	gentity_t	*found = NULL;
+	int			trapcount = 0;
+	int			foundDetPacks[MAX_GENTITIES] = {ENTITYNUM_NONE};
+	int			trapcount_org;
+	int			lowestTimeStamp;
+	int			removeMe;
+	int			i;
+
+	if ( !ent || !ent->client )
+	{
+		return;
+	}
+
+	//limit to 10 placed at any one time
+	//see how many there are now
+	while ( (found = G_Find( found, FOFS(classname), "detpack" )) != NULL )
+	{
+		if ( found->parent != ent )
+		{
+			continue;
+		}
+		foundDetPacks[trapcount++] = found->s.number;
+	}
+	//now remove first ones we find until there are only 9 left
+	found = NULL;
+	trapcount_org = trapcount;
+	lowestTimeStamp = level.time;
+	while ( trapcount > 9 )
+	{
+		removeMe = -1;
+		for ( i = 0; i < trapcount_org; i++ )
+		{
+			if ( foundDetPacks[i] == ENTITYNUM_NONE )
+			{
+				continue;
+			}
+			found = &g_entities[foundDetPacks[i]];
+			if ( found->setTime < lowestTimeStamp )
+			{
+				removeMe = i;
+				lowestTimeStamp = found->setTime;
+			}
+		}
+		if ( removeMe != -1 )
+		{
+			//remove it... or blow it?
+			if ( &g_entities[foundDetPacks[removeMe]] == NULL )
+			{
+				break;
+			}
+			else
+			{
+				if (!CheatsOn())
+				{ //Let them have unlimited if cheats are enabled
+					G_FreeEntity( &g_entities[foundDetPacks[removeMe]] );
+				}
+			}
+			foundDetPacks[removeMe] = ENTITYNUM_NONE;
+			trapcount--;
+		}
+		else
+		{
+			break;
+		}
+	}
+
+	if ( alt_fire  )
+	{
+		BlowDetpacks(ent);
+	}
+	else
+	{
+		AngleVectors( ent->client->ps.viewangles, forward, vright, up );
+
+		CalcMuzzlePoint( ent, forward, vright, up, muzzle );
+
+		VectorNormalize( forward );
+		VectorMA( muzzle, -4, forward, muzzle );
+		drop_charge( ent, muzzle, forward );
+
+		ent->client->ps.hasDetPackPlanted = qtrue;
+	}
+}
+
+#pragma warning(disable : 4701) //local variable may be used without having been initialized
+static void WP_FireConcussionAlt( gentity_t *ent )
+{//a rail-gun-like beam
+	int			damage = CONC_ALT_DAMAGE, skip, traces = DISRUPTOR_ALT_TRACES;
+	qboolean	render_impact = qtrue;
+	vec3_t		start, end;
+	vec3_t		muzzle2, dir;
+	trace_t		tr;
+	gentity_t	*traceEnt, *tent;
+	float		shotRange = 8192.0f;
+	qboolean	hitDodged = qfalse;
+	vec3_t shot_mins, shot_maxs;
+	int			i;
+
+	//Shove us backwards for half a second
+	VectorMA( ent->client->ps.velocity, -200, forward, ent->client->ps.velocity );
+	ent->client->ps.groundEntityNum = ENTITYNUM_NONE;
+	if ( (ent->client->ps.pm_flags&PMF_DUCKED) )
+	{//hunkered down
+		ent->client->ps.pm_time = 100;
+	}
+	else
+	{
+		ent->client->ps.pm_time = 250;
+	}
+//	ent->client->ps.pm_flags |= PMF_TIME_KNOCKBACK|PMF_TIME_NOFRICTION;
+	//FIXME: only if on ground?  So no "rocket jump"?  Or: (see next FIXME)
+	//FIXME: instead, set a forced ucmd backmove instead of this sliding
+
+	VectorCopy( muzzle, muzzle2 ); // making a backup copy
+
+	VectorCopy( muzzle, start );
+	WP_TraceSetStart( ent, start, vec3_origin, vec3_origin );
+
+	skip = ent->s.number;
+
+//	if ( ent->client && ent->client->ps.powerups[PW_WEAPON_OVERCHARGE] > 0 && ent->client->ps.powerups[PW_WEAPON_OVERCHARGE] > cg.time )
+//	{
+//		// in overcharge mode, so doing double damage
+//		damage *= 2;
+//	}
+	
+	//Make it a little easier to hit guys at long range
+	VectorSet( shot_mins, -1, -1, -1 );
+	VectorSet( shot_maxs, 1, 1, 1 );
+
+	for ( i = 0; i < traces; i++ )
+	{
+		VectorMA( start, shotRange, forward, end );
+
+		//NOTE: if you want to be able to hit guys in emplaced guns, use "G2_COLLIDE, 10" instead of "G2_RETURNONHIT, 0"
+		//alternately, if you end up hitting an emplaced_gun that has a sitter, just redo this one trace with the "G2_COLLIDE, 10" to see if we it the sitter
+		//gi.trace( &tr, start, NULL, NULL, end, skip, MASK_SHOT, G2_COLLIDE, 10 );//G2_RETURNONHIT, 0 );
+		if (d_projectileGhoul2Collision.integer)
+		{
+			trap_G2Trace( &tr, start, shot_mins, shot_maxs, end, skip, MASK_SHOT, G2TRFLAG_DOGHOULTRACE|G2TRFLAG_GETSURFINDEX|G2TRFLAG_HITCORPSES, g_g2TraceLod.integer );
+		}
+		else
+		{
+			trap_Trace( &tr, start, shot_mins, shot_maxs, end, skip, MASK_SHOT );
+		}
+
+		traceEnt = &g_entities[tr.entityNum];
+
+		if (d_projectileGhoul2Collision.integer && traceEnt->inuse && traceEnt->client)
+		{ //g2 collision checks -rww
+			if (traceEnt->inuse && traceEnt->client && traceEnt->ghoul2)
+			{ //since we used G2TRFLAG_GETSURFINDEX, tr.surfaceFlags will actually contain the index of the surface on the ghoul2 model we collided with.
+				traceEnt->client->g2LastSurfaceHit = tr.surfaceFlags;
+				traceEnt->client->g2LastSurfaceTime = level.time;
+			}
+
+			if (traceEnt->ghoul2)
+			{
+				tr.surfaceFlags = 0; //clear the surface flags after, since we actually care about them in here.
+			}
+		}
+		if ( tr.surfaceFlags & SURF_NOIMPACT ) 
+		{
+			render_impact = qfalse;
+		}
+
+		if ( tr.entityNum == ent->s.number )
+		{
+			// should never happen, but basically we don't want to consider a hit to ourselves?
+			// Get ready for an attempt to trace through another person
+			VectorCopy( tr.endpos, muzzle2 );
+			VectorCopy( tr.endpos, start );
+			skip = tr.entityNum;
+#ifdef _DEBUG
+			Com_Printf( "BAD! Concussion gun shot somehow traced back and hit the owner!\n" );			
+#endif
+			continue;
+		}
+
+		// always render a shot beam, doing this the old way because I don't much feel like overriding the effect.
+		//NOTE: let's just draw one beam at the end
+		//tent = G_TempEntity( tr.endpos, EV_CONC_ALT_SHOT );
+		//tent->svFlags |= SVF_BROADCAST;
+
+		//VectorCopy( muzzle2, tent->s.origin2 );
+
+		if ( tr.fraction >= 1.0f )
+		{
+			// draw the beam but don't do anything else
+			break;
+		}
+
+		if ( traceEnt->s.weapon == WP_SABER )//&& traceEnt->NPC 
+		{//FIXME: need a more reliable way to know we hit a jedi?
+			hitDodged = Jedi_DodgeEvasion( traceEnt, ent, &tr, HL_NONE );
+			//acts like we didn't even hit him
+		}
+		if ( !hitDodged )
+		{
+			if ( render_impact )
+			{
+				if (( tr.entityNum < ENTITYNUM_WORLD && traceEnt->takedamage ) 
+					|| !Q_stricmp( traceEnt->classname, "misc_model_breakable" ) 
+					|| traceEnt->s.eType == ET_MOVER )
+				{
+					qboolean noKnockBack;
+
+					// Create a simple impact type mark that doesn't last long in the world
+					//G_PlayEffectID( G_EffectIndex( "concussion/alt_hit" ), tr.endpos, tr.plane.normal );
+					//no no no
+
+					if ( traceEnt->client && LogAccuracyHit( traceEnt, ent )) 
+					{//NOTE: hitting multiple ents can still get you over 100% accuracy
+						ent->client->accuracy_hits++;
+					} 
+
+					noKnockBack = (traceEnt->flags&FL_NO_KNOCKBACK);//will be set if they die, I want to know if it was on *before* they died
+					if ( traceEnt && traceEnt->client && traceEnt->client->NPC_class == CLASS_GALAKMECH )
+					{//hehe
+						G_Damage( traceEnt, ent, ent, forward, tr.endpos, 10, DAMAGE_NO_KNOCKBACK|DAMAGE_NO_HIT_LOC, MOD_CONC_ALT );
+						break;
+					}
+					G_Damage( traceEnt, ent, ent, forward, tr.endpos, damage, DAMAGE_NO_KNOCKBACK|DAMAGE_NO_HIT_LOC, MOD_CONC_ALT );
+
+					//do knockback and knockdown manually
+					if ( traceEnt->client )
+					{//only if we hit a client
+						vec3_t pushDir;
+						VectorCopy( forward, pushDir );
+						if ( pushDir[2] < 0.2f )
+						{
+							pushDir[2] = 0.2f;
+						}//hmm, re-normalize?  nah...
+						/*
+						if ( !noKnockBack )
+						{//knock-backable
+							G_Throw( traceEnt, pushDir, 200 );
+						}
+						*/
+						if ( traceEnt->health > 0 )
+						{//alive
+							//if ( G_HasKnockdownAnims( traceEnt ) )
+							if (!noKnockBack && !traceEnt->localAnimIndex && traceEnt->client->ps.forceHandExtend != HANDEXTEND_KNOCKDOWN &&
+								BG_KnockDownable(&traceEnt->client->ps)) //just check for humanoids..
+							{//knock-downable
+								//G_Knockdown( traceEnt, ent, pushDir, 400, qtrue );
+								vec3_t plPDif;
+								float pStr;
+
+								//cap it and stuff, base the strength and whether or not we can knockdown on the distance
+								//from the shooter to the target
+								VectorSubtract(traceEnt->client->ps.origin, ent->client->ps.origin, plPDif);
+								pStr = 500.0f-VectorLength(plPDif);
+								if (pStr < 150.0f)
+								{
+									pStr = 150.0f;
+								}
+								if (pStr > 200.0f)
+								{
+									traceEnt->client->ps.forceHandExtend = HANDEXTEND_KNOCKDOWN;
+									traceEnt->client->ps.forceHandExtendTime = level.time + 1100;
+									traceEnt->client->ps.forceDodgeAnim = 0; //this toggles between 1 and 0, when it's 1 we should play the get up anim
+								}
+								traceEnt->client->ps.otherKiller = ent->s.number;
+								traceEnt->client->ps.otherKillerTime = level.time + 5000;
+								traceEnt->client->ps.otherKillerDebounceTime = level.time + 100;
+
+								traceEnt->client->ps.velocity[0] += pushDir[0]*pStr;
+								traceEnt->client->ps.velocity[1] += pushDir[1]*pStr;
+								traceEnt->client->ps.velocity[2] = pStr;
+							}
+						}
+					}
+
+					if ( traceEnt->s.eType == ET_MOVER )
+					{//stop the traces on any mover
+						break;
+					}
+				}
+				else 
+				{
+					 // we only make this mark on things that can't break or move
+				//	tent = G_TempEntity(tr.endpos, EV_MISSILE_MISS);
+				//	tent->s.eventParm = DirToByte(tr.plane.normal);
+				//	tent->s.eFlags |= EF_ALT_FIRING;
+
+					//tent->svFlags |= SVF_BROADCAST;
+					//eh? why broadcast?
+				//	VectorCopy( tr.plane.normal, tent->pos1 );
+
+					//mmm..no..don't do this more than once for no reason whatsoever.
+					break; // hit solid, but doesn't take damage, so stop the shot...we _could_ allow it to shoot through walls, might be cool?
+				}
+			}
+			else // not rendering impact, must be a skybox or other similar thing?
+			{
+				break; // don't try anymore traces
+			}
+		}
+		// Get ready for an attempt to trace through another person
+		VectorCopy( tr.endpos, muzzle2 );
+		VectorCopy( tr.endpos, start );
+		skip = tr.entityNum;
+		hitDodged = qfalse;
+	}
+	//just draw one beam all the way to the end
+//	tent = G_TempEntity( tr.endpos, EV_CONC_ALT_SHOT );
+//	tent->svFlags |= SVF_BROADCAST;
+	//again, why broadcast?
+
+//	tent = G_TempEntity(tr.endpos, EV_MISSILE_MISS);
+//	tent->s.eventParm = DirToByte(tr.plane.normal);
+//	tent->s.eFlags |= EF_ALT_FIRING;
+//	VectorCopy( muzzle, tent->s.origin2 );
+
+	// now go along the trail and make sight events
+	VectorSubtract( tr.endpos, muzzle, dir );
+
+//	shotDist = VectorNormalize( dir );
+
+	//let's pack all this junk into a single tempent, and send it off.
+	tent = G_TempEntity(tr.endpos, EV_CONC_ALT_IMPACT);
+	tent->s.eventParm = DirToByte(tr.plane.normal);
+	tent->s.owner = ent->s.number;
+	VectorCopy(dir, tent->s.angles);
+	VectorCopy(muzzle, tent->s.origin2);
+	VectorCopy(forward, tent->s.angles2);
+
+#if 0 //yuck
+	//FIXME: if shoot *really* close to someone, the alert could be way out of their FOV
+	for ( dist = 0; dist < shotDist; dist += 64 )
+	{
+		//FIXME: on a really long shot, this could make a LOT of alerts in one frame...
+		VectorMA( muzzle, dist, dir, spot );
+		AddSightEvent( ent, spot, 256, AEL_DISCOVERED, 50 );
+		//FIXME: creates *way* too many effects, make it one effect somehow?
+		G_PlayEffectID( G_EffectIndex( "concussion/alt_ring" ), spot, actualAngles );
+	}
+	//FIXME: spawn a temp ent that continuously spawns sight alerts here?  And 1 sound alert to draw their attention?
+	VectorMA( start, shotDist-4, forward, spot );
+	AddSightEvent( ent, spot, 256, AEL_DISCOVERED, 50 );
+
+	G_PlayEffectID( G_EffectIndex( "concussion/altmuzzle_flash" ), muzzle, forward );
+#endif
+}
+#pragma warning(default : 4701) //local variable may be used without having been initialized
+
+static void WP_FireConcussion( gentity_t *ent )
+{//a fast rocket-like projectile
+	vec3_t	start;
+	int		damage	= CONC_DAMAGE;
+	float	vel = CONC_VELOCITY;
+	gentity_t *missile;
+
+	//hold us still for a bit
+	//ent->client->ps.pm_time = 300;
+	//ent->client->ps.pm_flags |= PMF_TIME_KNOCKBACK;
+	//add viewkick
+//	if ( ent->s.number < MAX_CLIENTS//player only
+//		&& !cg.renderingThirdPerson )//gives an advantage to being in 3rd person, but would look silly otherwise
+//	{//kick the view back
+//		cg.kick_angles[PITCH] = Q_flrand( -10, -15 );
+//		cg.kick_time = level.time;
+//	}
+	//mm..yeah..this needs some reworking for mp
+
+	VectorCopy( muzzle, start );
+	WP_TraceSetStart( ent, start, vec3_origin, vec3_origin );//make sure our start point isn't on the other side of a wall
+
+	missile = CreateMissile( start, forward, vel, 10000, ent, qfalse );
+
+	missile->classname = "conc_proj";
+	missile->s.weapon = WP_CONCUSSION;
+	missile->mass = 10;
+
+	// Make it easier to hit things
+	VectorSet( missile->r.maxs, ROCKET_SIZE, ROCKET_SIZE, ROCKET_SIZE );
+	VectorScale( missile->r.maxs, -1, missile->r.mins );
+
+	missile->damage = damage;
+	missile->dflags = DAMAGE_EXTRA_KNOCKBACK;
+
+	missile->methodOfDeath = MOD_CONC;
+	missile->splashMethodOfDeath = MOD_CONC;
+
+	missile->clipmask = MASK_SHOT | CONTENTS_LIGHTSABER;
+	missile->splashDamage = CONC_SPLASH_DAMAGE;
+	missile->splashRadius = CONC_SPLASH_RADIUS;
+
+	// we don't want it to ever bounce
+	missile->bounceCount = 0;
+}
+
+
+//---------------------------------------------------------
+// FireStunBaton
+//---------------------------------------------------------
+void WP_FireStunBaton( gentity_t *ent, qboolean alt_fire )
+{
+	gentity_t	*tr_ent;
+	trace_t		tr;
+	vec3_t		mins, maxs, end;
+	vec3_t		muzzleStun;
+
+	if (!ent->client)
+	{
+		VectorCopy(ent->r.currentOrigin, muzzleStun);
+		muzzleStun[2] += 8;
+	}
+	else
+	{
+		VectorCopy(ent->client->ps.origin, muzzleStun);
+		muzzleStun[2] += ent->client->ps.viewheight-6;
+	}
+
+	VectorMA(muzzleStun, 20.0f, forward, muzzleStun);
+	VectorMA(muzzleStun, 4.0f, vright, muzzleStun);
+
+	VectorMA( muzzleStun, STUN_BATON_RANGE, forward, end );
+
+	VectorSet( maxs, 6, 6, 6 );
+	VectorScale( maxs, -1, mins );
+
+	trap_Trace ( &tr, muzzleStun, mins, maxs, end, ent->s.number, MASK_SHOT );
+
+	if ( tr.entityNum >= ENTITYNUM_WORLD )
+	{
+		return;
+	}
+
+	tr_ent = &g_entities[tr.entityNum];
+
+	if (tr_ent && tr_ent->takedamage && tr_ent->client)
+	{ //see if either party is involved in a duel
+		if (tr_ent->client->ps.duelInProgress &&
+			tr_ent->client->ps.duelIndex != ent->s.number)
+		{
+			return;
+		}
+
+		if (ent->client &&
+			ent->client->ps.duelInProgress &&
+			ent->client->ps.duelIndex != tr_ent->s.number)
+		{
+			return;
+		}
+	}
+
+	if ( tr_ent && tr_ent->takedamage )
+	{
+		G_PlayEffect( EFFECT_STUNHIT, tr.endpos, tr.plane.normal );
+
+		G_Sound( tr_ent, CHAN_WEAPON, G_SoundIndex( va("sound/weapons/melee/punch%d", Q_irand(1, 4)) ) );
+		G_Damage( tr_ent, ent, ent, forward, tr.endpos, STUN_BATON_DAMAGE, (DAMAGE_NO_KNOCKBACK|DAMAGE_HALF_ABSORB), MOD_STUN_BATON );
+
+		if (tr_ent->client)
+		{ //if it's a player then use the shock effect
+			if ( tr_ent->client->NPC_class == CLASS_VEHICLE )
+			{//not on vehicles
+				if ( !tr_ent->m_pVehicle
+					|| tr_ent->m_pVehicle->m_pVehicleInfo->type == VH_ANIMAL 
+					|| tr_ent->m_pVehicle->m_pVehicleInfo->type == VH_FLIER )
+				{//can zap animals
+					tr_ent->client->ps.electrifyTime = level.time + Q_irand( 3000, 4000 );
+				}
+			}
+			else
+			{
+				tr_ent->client->ps.electrifyTime = level.time + 700;
+			}
+		}
+	}
+}
+
+
+//---------------------------------------------------------
+// FireMelee
+//---------------------------------------------------------
+void WP_FireMelee( gentity_t *ent, qboolean alt_fire )
+{
+	gentity_t	*tr_ent;
+	trace_t		tr;
+	vec3_t		mins, maxs, end;
+	vec3_t		muzzlePunch;
+
+	if (ent->client && ent->client->ps.torsoAnim == BOTH_MELEE2)
+	{ //right
+		if (ent->client->ps.brokenLimbs & (1 << BROKENLIMB_RARM))
+		{
+			return;
+		}
+	}
+	else
+	{ //left
+		if (ent->client->ps.brokenLimbs & (1 << BROKENLIMB_LARM))
+		{
+			return;
+		}
+	}
+
+	if (!ent->client)
+	{
+		VectorCopy(ent->r.currentOrigin, muzzlePunch);
+		muzzlePunch[2] += 8;
+	}
+	else
+	{
+		VectorCopy(ent->client->ps.origin, muzzlePunch);
+		muzzlePunch[2] += ent->client->ps.viewheight-6;
+	}
+
+	VectorMA(muzzlePunch, 20.0f, forward, muzzlePunch);
+	VectorMA(muzzlePunch, 4.0f, vright, muzzlePunch);
+
+	VectorMA( muzzlePunch, MELEE_RANGE, forward, end );
+
+	VectorSet( maxs, 6, 6, 6 );
+	VectorScale( maxs, -1, mins );
+
+	trap_Trace ( &tr, muzzlePunch, mins, maxs, end, ent->s.number, MASK_SHOT );
+
+	if (tr.entityNum != ENTITYNUM_NONE)
+	{ //hit something
+		tr_ent = &g_entities[tr.entityNum];
+
+		G_Sound( ent, CHAN_AUTO, G_SoundIndex( va("sound/weapons/melee/punch%d", Q_irand(1, 4)) ) );
+
+		if (tr_ent->takedamage && tr_ent->client)
+		{ //special duel checks
+			if (tr_ent->client->ps.duelInProgress &&
+				tr_ent->client->ps.duelIndex != ent->s.number)
+			{
+				return;
+			}
+
+			if (ent->client &&
+				ent->client->ps.duelInProgress &&
+				ent->client->ps.duelIndex != tr_ent->s.number)
+			{
+				return;
+			}
+		}
+
+		if ( tr_ent->takedamage )
+		{ //damage them, do more damage if we're in the second right hook
+			int dmg = MELEE_SWING1_DAMAGE;
+
+			if (ent->client && ent->client->ps.torsoAnim == BOTH_MELEE2)
+			{ //do a tad bit more damage on the second swing
+				dmg = MELEE_SWING2_DAMAGE;
+			}
+
+			if ( G_HeavyMelee( ent ) )
+			{ //2x damage for heavy melee class
+				dmg *= 2;
+			}
+
+			G_Damage( tr_ent, ent, ent, forward, tr.endpos, dmg, DAMAGE_NO_ARMOR, MOD_MELEE );
+		}
+	}
+}
+
+////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////
+
+
+/*
+======================
+SnapVectorTowards
+
+Round a vector to integers for more efficient network
+transmission, but make sure that it rounds towards a given point
+rather than blindly truncating.  This prevents it from truncating 
+into a wall.
+======================
+*/
+void SnapVectorTowards( vec3_t v, vec3_t to ) {
+	int		i;
+
+	for ( i = 0 ; i < 3 ; i++ ) {
+		if ( to[i] <= v[i] ) {
+			v[i] = (int)v[i];
+		} else {
+			v[i] = (int)v[i] + 1;
+		}
+	}
+}
+
+
+//======================================================================
+
+
+/*
+===============
+LogAccuracyHit
+===============
+*/
+qboolean LogAccuracyHit( gentity_t *target, gentity_t *attacker ) {
+	if( !target->takedamage ) {
+		return qfalse;
+	}
+
+	if ( target == attacker ) {
+		return qfalse;
+	}
+
+	if( !target->client ) {
+		return qfalse;
+	}
+
+	if (!attacker)
+	{
+		return qfalse;
+	}
+
+	if( !attacker->client ) {
+		return qfalse;
+	}
+
+	if( target->client->ps.stats[STAT_HEALTH] <= 0 ) {
+		return qfalse;
+	}
+
+	if ( OnSameTeam( target, attacker ) ) {
+		return qfalse;
+	}
+
+	return qtrue;
+}
+
+
+/*
+===============
+CalcMuzzlePoint
+
+set muzzle location relative to pivoting eye
+rwwFIXMEFIXME: Since ghoul2 models are on server and properly updated now,
+it may be reasonable to base muzzle point off actual weapon bolt point.
+The down side would be that it does not necessarily look alright from a
+first person perspective.
+===============
+*/
+void CalcMuzzlePoint ( gentity_t *ent, vec3_t forward, vec3_t right, vec3_t up, vec3_t muzzlePoint ) 
+{
+	int weapontype;
+	vec3_t muzzleOffPoint;
+
+	weapontype = ent->s.weapon;
+	VectorCopy( ent->s.pos.trBase, muzzlePoint );
+
+	VectorCopy(WP_MuzzlePoint[weapontype], muzzleOffPoint);
+
+	if (weapontype > WP_NONE && weapontype < WP_NUM_WEAPONS)
+	{	// Use the table to generate the muzzlepoint;
+		{	// Crouching.  Use the add-to-Z method to adjust vertically.
+			VectorMA(muzzlePoint, muzzleOffPoint[0], forward, muzzlePoint);
+			VectorMA(muzzlePoint, muzzleOffPoint[1], right, muzzlePoint);
+			muzzlePoint[2] += ent->client->ps.viewheight + muzzleOffPoint[2];
+		}
+	}
+
+	// snap to integer coordinates for more efficient network bandwidth usage
+	SnapVector( muzzlePoint );
+}
+
+/*
+===============
+CalcMuzzlePointOrigin
+
+set muzzle location relative to pivoting eye
+===============
+*/
+void CalcMuzzlePointOrigin ( gentity_t *ent, vec3_t origin, vec3_t forward, vec3_t right, vec3_t up, vec3_t muzzlePoint ) {
+	VectorCopy( ent->s.pos.trBase, muzzlePoint );
+	muzzlePoint[2] += ent->client->ps.viewheight;
+	VectorMA( muzzlePoint, 14, forward, muzzlePoint );
+	// snap to integer coordinates for more efficient network bandwidth usage
+	SnapVector( muzzlePoint );
+}
+
+extern void G_MissileImpact( gentity_t *ent, trace_t *trace );
+void WP_TouchVehMissile( gentity_t *ent, gentity_t *other, trace_t *trace )
+{
+	trace_t	myTrace;
+	memcpy( (void *)&myTrace, (void *)trace, sizeof(myTrace) );
+	if ( other )
+	{
+		myTrace.entityNum = other->s.number;
+	}
+	G_MissileImpact( ent, &myTrace );
+}
+
+void WP_CalcVehMuzzle(gentity_t *ent, int muzzleNum)
+{
+	Vehicle_t *pVeh = ent->m_pVehicle;
+	mdxaBone_t boltMatrix;
+	vec3_t	vehAngles;
+
+	assert(pVeh);
+
+	if (pVeh->m_iMuzzleTime[muzzleNum] == level.time)
+	{ //already done for this frame, don't need to do it again
+		return;
+	}
+	//Uh... how about we set this, hunh...?  :)
+	pVeh->m_iMuzzleTime[muzzleNum] = level.time;
+	
+	VectorCopy( ent->client->ps.viewangles, vehAngles );
+	if ( pVeh->m_pVehicleInfo
+		&& (pVeh->m_pVehicleInfo->type == VH_ANIMAL
+			 ||pVeh->m_pVehicleInfo->type == VH_WALKER
+			 ||pVeh->m_pVehicleInfo->type == VH_SPEEDER) )
+	{
+		vehAngles[PITCH] = vehAngles[ROLL] = 0;
+	}
+
+	trap_G2API_GetBoltMatrix_NoRecNoRot(ent->ghoul2, 0, pVeh->m_iMuzzleTag[muzzleNum], &boltMatrix, vehAngles,
+		ent->client->ps.origin, level.time, NULL, ent->modelScale);
+	BG_GiveMeVectorFromMatrix(&boltMatrix, ORIGIN, pVeh->m_vMuzzlePos[muzzleNum]);
+	BG_GiveMeVectorFromMatrix(&boltMatrix, NEGATIVE_Y, pVeh->m_vMuzzleDir[muzzleNum]);
+}
+
+void WP_VehWeapSetSolidToOwner( gentity_t *self )
+{
+	self->r.svFlags |= SVF_OWNERNOTSHARED;
+	if ( self->genericValue1 )
+	{//expire after a time
+		if ( self->genericValue2 )
+		{//blow up when your lifetime is up
+			self->think = G_ExplodeMissile;//FIXME: custom func?
+		}
+		else
+		{//just remove yourself
+			self->think = G_FreeEntity;//FIXME: custom func?
+		}
+		self->nextthink = level.time + self->genericValue1;
+	}
+}
+
+#define VEH_HOMING_MISSILE_THINK_TIME		100
+gentity_t *WP_FireVehicleWeapon( gentity_t *ent, vec3_t start, vec3_t dir, vehWeaponInfo_t *vehWeapon, qboolean alt_fire, qboolean isTurretWeap )
+{
+	gentity_t	*missile = NULL;
+
+	//FIXME: add some randomness...?  Inherent inaccuracy stat of weapon?  Pilot skill?
+	if ( !vehWeapon )
+	{//invalid vehicle weapon
+		return NULL;
+	}
+	else if ( vehWeapon->bIsProjectile )
+	{//projectile entity
+		vec3_t		mins, maxs;
+
+		VectorSet( maxs, vehWeapon->fWidth/2.0f,vehWeapon->fWidth/2.0f,vehWeapon->fHeight/2.0f );
+		VectorScale( maxs, -1, mins );
+
+		//make sure our start point isn't on the other side of a wall
+		WP_TraceSetStart( ent, start, mins, maxs );
+		
+		//FIXME: CUSTOM MODEL?
+		//QUERY: alt_fire true or not?  Does it matter?
+		missile = CreateMissile( start, dir, vehWeapon->fSpeed, 10000, ent, qfalse );
+
+		missile->classname = "vehicle_proj";
+		
+		missile->s.genericenemyindex = ent->s.number+MAX_GENTITIES;
+		missile->damage = vehWeapon->iDamage;
+		missile->splashDamage = vehWeapon->iSplashDamage;
+		missile->splashRadius = vehWeapon->fSplashRadius;
+
+		//FIXME: externalize some of these properties?
+		missile->dflags = DAMAGE_DEATH_KNOCKBACK;
+		missile->clipmask = MASK_SHOT;
+		//Maybe by checking flags...?
+		if ( vehWeapon->bSaberBlockable )
+		{
+			missile->clipmask |= CONTENTS_LIGHTSABER;
+		}
+		/*
+		if ( (vehWeapon->iFlags&VWF_KNOCKBACK) )
+		{
+			missile->dflags &= ~DAMAGE_DEATH_KNOCKBACK;
+		}
+		if ( (vehWeapon->iFlags&VWF_RADAR) )
+		{
+			missile->s.eFlags |= EF_RADAROBJECT;
+		}
+		*/
+		// Make it easier to hit things
+		VectorCopy( mins, missile->r.mins );
+		VectorCopy( maxs, missile->r.maxs );
+		//some slightly different stuff for things with bboxes
+		if ( vehWeapon->fWidth || vehWeapon->fHeight )
+		{//we assume it's a rocket-like thing
+			missile->s.weapon = WP_ROCKET_LAUNCHER;//does this really matter?
+			missile->methodOfDeath = MOD_VEHICLE;//MOD_ROCKET;
+			missile->splashMethodOfDeath = MOD_VEHICLE;//MOD_ROCKET;// ?SPLASH;
+
+			// we don't want it to ever bounce
+			missile->bounceCount = 0;
+
+			missile->mass = 10;
+		}
+		else
+		{//a blaster-laser-like thing
+			missile->s.weapon = WP_BLASTER;//does this really matter?
+			missile->methodOfDeath = MOD_VEHICLE; //count as a heavy weap
+			missile->splashMethodOfDeath = MOD_VEHICLE;// ?SPLASH;
+			// we don't want it to bounce forever
+			missile->bounceCount = 8;
+		}
+		
+		if ( vehWeapon->bHasGravity )
+		{//TESTME: is this all we need to do?
+			missile->s.weapon = WP_THERMAL;//does this really matter?
+			missile->s.pos.trType = TR_GRAVITY;
+		}
+		
+		if ( vehWeapon->bIonWeapon )
+		{//so it disables ship shields and sends them out of control
+			missile->s.weapon = WP_DEMP2;
+		}
+
+		if ( vehWeapon->iHealth )
+		{//the missile can take damage
+			missile->health = vehWeapon->iHealth;
+			missile->takedamage = qtrue;
+			missile->r.contents = MASK_SHOT;
+			missile->die = RocketDie;
+		}
+
+		//pilot should own this projectile on server if we have a pilot
+		if (ent->m_pVehicle && ent->m_pVehicle->m_pPilot)
+		{//owned by vehicle pilot
+			missile->r.ownerNum = ent->m_pVehicle->m_pPilot->s.number;
+		}
+		else
+		{//owned by vehicle?
+			missile->r.ownerNum = ent->s.number;
+		}
+
+		//set veh as cgame side owner for purpose of fx overrides
+		missile->s.owner = ent->s.number;
+		if ( alt_fire )
+		{//use the second weapon's iShotFX
+			missile->s.eFlags |= EF_ALT_FIRING;
+		}
+		if ( isTurretWeap )
+		{//look for the turret weapon info on cgame side, not vehicle weapon info
+			missile->s.weapon = WP_TURRET;
+		}
+		if ( vehWeapon->iLifeTime )
+		{//expire after a time
+			if ( vehWeapon->bExplodeOnExpire )
+			{//blow up when your lifetime is up
+				missile->think = G_ExplodeMissile;//FIXME: custom func?
+			}
+			else
+			{//just remove yourself
+				missile->think = G_FreeEntity;//FIXME: custom func?
+			}
+			missile->nextthink = level.time + vehWeapon->iLifeTime;
+		}
+		missile->s.otherEntityNum2 = (vehWeapon-&g_vehWeaponInfo[0]);
+		missile->s.eFlags |= EF_JETPACK_ACTIVE;
+		//homing
+		if ( vehWeapon->fHoming )
+		{//homing missile
+			if ( ent->client && ent->client->ps.rocketLockIndex != ENTITYNUM_NONE )
+			{
+				int dif = 0;
+				float rTime;
+				rTime = ent->client->ps.rocketLockTime;
+
+				if (rTime == -1)
+				{
+					rTime = ent->client->ps.rocketLastValidTime;
+				}
+
+				if ( !vehWeapon->iLockOnTime )
+				{//no minimum lock-on time
+					dif = 10;//guaranteed lock-on
+				}
+				else
+				{
+					float lockTimeInterval = vehWeapon->iLockOnTime/16.0f;
+					dif = ( level.time - rTime ) / lockTimeInterval;
+				}
+
+				if (dif < 0)
+				{
+					dif = 0;
+				}
+
+				//It's 10 even though it locks client-side at 8, because we want them to have a sturdy lock first, and because there's a slight difference in time between server and client
+				if ( dif >= 10 && rTime != -1 )
+				{
+					missile->enemy = &g_entities[ent->client->ps.rocketLockIndex];
+
+					if (missile->enemy && missile->enemy->client && missile->enemy->health > 0 && !OnSameTeam(ent, missile->enemy))
+					{ //if enemy became invalid, died, or is on the same team, then don't seek it
+						missile->spawnflags |= 1;//just to let it know it should be faster...
+						missile->speed = vehWeapon->fSpeed;
+						missile->angle = vehWeapon->fHoming;
+						//crap, if we have a lifetime, need to store that somewhere else on ent and have rocketThink func check it every frame...
+						if ( vehWeapon->iLifeTime )
+						{//expire after a time
+							missile->genericValue1 = level.time + vehWeapon->iLifeTime;
+							missile->genericValue2 = (int)(vehWeapon->bExplodeOnExpire);
+						}
+						//now go ahead and use the rocketThink func
+						missile->think = rocketThink;//FIXME: custom func?
+						missile->nextthink = level.time + VEH_HOMING_MISSILE_THINK_TIME;
+						missile->s.eFlags |= EF_RADAROBJECT;//FIXME: externalize
+						if ( missile->enemy->s.NPC_class == CLASS_VEHICLE )
+						{//let vehicle know we've locked on to them
+							missile->s.otherEntityNum = missile->enemy->s.number;
+						}
+					}
+				}
+
+				VectorCopy( dir, missile->movedir );
+				missile->random = 1.0f;//FIXME: externalize?
+			}
+		}
+		if ( !vehWeapon->fSpeed )
+		{//a mine or something?
+			//only do damage when someone touches us
+			missile->s.weapon = WP_THERMAL;//does this really matter?
+			G_SetOrigin( missile, start );
+			missile->touch = WP_TouchVehMissile;
+			missile->s.eFlags |= EF_RADAROBJECT;//FIXME: externalize
+			//crap, if we have a lifetime, need to store that somewhere else on ent and have rocketThink func check it every frame...
+			if ( vehWeapon->iLifeTime )
+			{//expire after a time
+				missile->genericValue1 = vehWeapon->iLifeTime;
+				missile->genericValue2 = (int)(vehWeapon->bExplodeOnExpire);
+			}
+			//now go ahead and use the setsolidtoowner func
+			missile->think = WP_VehWeapSetSolidToOwner;
+			missile->nextthink = level.time + 3000;
+		}
+	}
+	else
+	{//traceline
+		//FIXME: implement
+	}
+
+	return missile;
+}
+
+//custom routine to not waste tempents horribly -rww
+void G_VehMuzzleFireFX( gentity_t *ent, gentity_t *broadcaster, int muzzlesFired )
+{
+	Vehicle_t *pVeh = ent->m_pVehicle;
+	gentity_t *b;
+
+	if (!pVeh)
+	{
+		return;
+	}
+
+	if (!broadcaster)
+	{ //oh well. We will WASTE A TEMPENT.
+		b = G_TempEntity( ent->client->ps.origin, EV_VEH_FIRE );
+	}
+	else
+	{ //joy
+		b = broadcaster;
+	}
+
+	//this guy owns it
+	b->s.owner = ent->s.number;
+
+	//this is the bitfield of all muzzles fired this time
+	//NOTE: just need MAX_VEHICLE_MUZZLES bits for this... should be cool since it's currently 12 and we're sending it in 16 bits
+	b->s.trickedentindex = muzzlesFired;
+
+	if ( broadcaster )
+	{ //add the event
+		G_AddEvent( b, EV_VEH_FIRE, 0 );
+	}
+}
+
+void G_EstimateCamPos( vec3_t viewAngles, vec3_t cameraFocusLoc, float viewheight, float thirdPersonRange, 
+					  float thirdPersonHorzOffset, float vertOffset, float pitchOffset, 
+					  int ignoreEntNum, vec3_t camPos )
+{
+	int		MASK_CAMERACLIP = (MASK_SOLID|CONTENTS_PLAYERCLIP);
+	float	CAMERA_SIZE = 4;
+	vec3_t	cameramins;
+	vec3_t	cameramaxs;
+	vec3_t	cameraFocusAngles, camerafwd, cameraup;
+	vec3_t	cameraIdealTarget, cameraCurTarget;
+	vec3_t	cameraIdealLoc, cameraCurLoc;
+	vec3_t	diff;
+	vec3_t	camAngles;
+	vec3_t	viewaxis[3];
+	trace_t	trace;
+
+	VectorSet( cameramins, -CAMERA_SIZE, -CAMERA_SIZE, -CAMERA_SIZE );
+	VectorSet( cameramaxs, CAMERA_SIZE, CAMERA_SIZE, CAMERA_SIZE );
+
+	VectorCopy( viewAngles, cameraFocusAngles );
+	cameraFocusAngles[PITCH] += pitchOffset;
+	if ( !bg_fighterAltControl.integer )
+	{//clamp view pitch
+		if (cameraFocusAngles[PITCH] > 80.0)
+		{
+			cameraFocusAngles[PITCH] = 80.0;
+		}
+		else if (cameraFocusAngles[PITCH] < -80.0)
+		{
+			cameraFocusAngles[PITCH] = -80.0;
+		}
+	}
+	AngleVectors(cameraFocusAngles, camerafwd, NULL, cameraup);
+
+	cameraFocusLoc[2] += viewheight;
+
+	VectorCopy( cameraFocusLoc, cameraIdealTarget );
+	cameraIdealTarget[2] += vertOffset;
+
+	//NOTE: on cgame, this uses the thirdpersontargetdamp value, we ignore that here
+	VectorCopy( cameraIdealTarget, cameraCurTarget );
+	trap_Trace( &trace, cameraFocusLoc, cameramins, cameramaxs, cameraCurTarget, ignoreEntNum, MASK_CAMERACLIP );
+	if (trace.fraction < 1.0)
+	{
+		VectorCopy(trace.endpos, cameraCurTarget);
+	}
+
+	VectorMA(cameraIdealTarget, -(thirdPersonRange), camerafwd, cameraIdealLoc);
+	//NOTE: on cgame, this uses the thirdpersoncameradamp value, we ignore that here
+	VectorCopy( cameraIdealLoc, cameraCurLoc );
+	trap_Trace(&trace, cameraCurTarget, cameramins, cameramaxs, cameraCurLoc, ignoreEntNum, MASK_CAMERACLIP);
+	if (trace.fraction < 1.0)
+	{
+		VectorCopy( trace.endpos, cameraCurLoc );
+	}
+
+	VectorSubtract(cameraCurTarget, cameraCurLoc, diff);
+	{
+		float dist = VectorNormalize(diff);
+		//under normal circumstances, should never be 0.00000 and so on.
+		if ( !dist || (diff[0] == 0 || diff[1] == 0) )
+		{//must be hitting something, need some value to calc angles, so use cam forward
+			VectorCopy( camerafwd, diff );
+		}
+	}
+
+	vectoangles(diff, camAngles);
+
+	if ( thirdPersonHorzOffset != 0.0f )
+	{
+		AnglesToAxis( camAngles, viewaxis );
+		VectorMA( cameraCurLoc, thirdPersonHorzOffset, viewaxis[1], cameraCurLoc );
+	}
+
+	VectorCopy(cameraCurLoc, camPos);
+}
+
+void WP_GetVehicleCamPos( gentity_t *ent, gentity_t *pilot, vec3_t camPos )
+{
+	float thirdPersonHorzOffset = ent->m_pVehicle->m_pVehicleInfo->cameraHorzOffset;
+	float thirdPersonRange = ent->m_pVehicle->m_pVehicleInfo->cameraRange;
+	float pitchOffset = ent->m_pVehicle->m_pVehicleInfo->cameraPitchOffset;
+	float vertOffset = ent->m_pVehicle->m_pVehicleInfo->cameraVertOffset;
+
+	if ( ent->client->ps.hackingTime )
+	{
+		thirdPersonHorzOffset += (((float)ent->client->ps.hackingTime)/MAX_STRAFE_TIME) * -80.0f;
+		thirdPersonRange += fabs(((float)ent->client->ps.hackingTime)/MAX_STRAFE_TIME) * 100.0f;
+	}
+
+	if ( ent->m_pVehicle->m_pVehicleInfo->cameraPitchDependantVertOffset )
+	{
+		if ( pilot->client->ps.viewangles[PITCH] > 0 )
+		{
+			vertOffset = 130+pilot->client->ps.viewangles[PITCH]*-10;
+			if ( vertOffset < -170 )
+			{
+				vertOffset = -170;
+			}
+		}
+		else if ( pilot->client->ps.viewangles[PITCH] < 0 )
+		{
+			vertOffset = 130+pilot->client->ps.viewangles[PITCH]*-5;
+			if ( vertOffset > 130 )
+			{
+				vertOffset = 130;
+			}
+		}
+		else
+		{
+			vertOffset = 30;
+		}
+		if ( pilot->client->ps.viewangles[PITCH] > 0 )
+		{
+			pitchOffset = pilot->client->ps.viewangles[PITCH]*-0.75;
+		}
+		else if ( pilot->client->ps.viewangles[PITCH] < 0 )
+		{
+			pitchOffset = pilot->client->ps.viewangles[PITCH]*-0.75;
+		}
+		else
+		{
+			pitchOffset = 0;
+		}
+	}
+
+	G_EstimateCamPos( ent->m_pVehicle->m_vOrientation, ent->r.currentOrigin, pilot->client->ps.viewheight, thirdPersonRange, 
+		thirdPersonHorzOffset, vertOffset, pitchOffset, 
+		pilot->s.number, camPos );
+}
+
+#define MAX_XHAIR_DIST_ACCURACY	20000.0f
+extern float g_cullDistance;
+qboolean WP_VehCheckTraceFromCamPos( gentity_t *ent, const vec3_t shotStart, vec3_t shotDir )
+{
+	//FIXME: only if dynamicCrosshair and dynamicCrosshairPrecision is on!
+	if ( !ent 
+		|| !ent->m_pVehicle 
+		|| !ent->m_pVehicle->m_pVehicleInfo 
+		|| !ent->m_pVehicle->m_pPilot//not being driven
+		|| !((gentity_t*)ent->m_pVehicle->m_pPilot)->client//not being driven by a client...?!!!
+		|| (ent->m_pVehicle->m_pPilot->s.number >= MAX_CLIENTS) )//being driven, but not by a real client, no need to worry about crosshair
+	{
+		return qfalse;
+	}
+	if ( (ent->m_pVehicle->m_pVehicleInfo->type == VH_FIGHTER && g_cullDistance > MAX_XHAIR_DIST_ACCURACY )
+		|| ent->m_pVehicle->m_pVehicleInfo->type == VH_WALKER)
+	{
+		//FIRST: simulate the normal crosshair trace from the center of the veh straight forward
+		trace_t trace;
+		vec3_t	dir, start, end;
+		if ( ent->m_pVehicle->m_pVehicleInfo->type == VH_WALKER )
+		{//for some reason, the walker always draws the crosshair out from from the first muzzle point
+			AngleVectors( ent->client->ps.viewangles, dir, NULL, NULL );
+			VectorCopy( ent->r.currentOrigin, start );
+			start[2] += ent->m_pVehicle->m_pVehicleInfo->height-DEFAULT_MINS_2-48;
+		}
+		else
+		{
+			vec3_t ang;
+			if (ent->m_pVehicle->m_pVehicleInfo->type == VH_SPEEDER)
+			{
+				VectorSet(ang, 0.0f, ent->m_pVehicle->m_vOrientation[1], 0.0f);
+			}
+			else
+			{
+				VectorCopy(ent->m_pVehicle->m_vOrientation, ang);
+			}
+			AngleVectors( ang, dir, NULL, NULL );
+			VectorCopy( ent->r.currentOrigin, start );
+		}
+		VectorMA( start, g_cullDistance, dir, end );
+		trap_Trace( &trace, start, vec3_origin, vec3_origin, end, 
+			ent->s.number, CONTENTS_SOLID|CONTENTS_BODY );
+
+		if ( ent->m_pVehicle->m_pVehicleInfo->type == VH_WALKER )
+		{//just use the result of that one trace since walkers don't do the extra trace
+			VectorSubtract( trace.endpos, shotStart, shotDir );
+			VectorNormalize( shotDir );
+			return qtrue;
+		}
+		else
+		{//NOW do the trace from the camPos and compare with above trace
+			//NOTE: this MUST stay up to date with the method used in CG_ScanForCrosshairEntity (where it checks the doExtraVehTraceFromViewPos bool)
+			trace_t	extraTrace;
+			vec3_t	viewDir2End, extraEnd, camPos;
+			float	minAutoAimDist;
+
+			WP_GetVehicleCamPos( ent, (gentity_t *)ent->m_pVehicle->m_pPilot, camPos );
+			
+			minAutoAimDist = Distance( ent->r.currentOrigin, camPos ) + (ent->m_pVehicle->m_pVehicleInfo->length/2.0f) + 200.0f;
+
+			VectorSubtract( end, camPos, viewDir2End );
+			VectorNormalize( viewDir2End );
+			VectorMA( camPos, MAX_XHAIR_DIST_ACCURACY, viewDir2End, extraEnd );
+			trap_Trace( &extraTrace, camPos, vec3_origin, vec3_origin, extraEnd, 
+				ent->s.number, CONTENTS_SOLID|CONTENTS_BODY );
+			if ( !extraTrace.allsolid
+				&& !extraTrace.startsolid
+				&& extraTrace.fraction < 1.0f
+				&& (extraTrace.fraction*MAX_XHAIR_DIST_ACCURACY) > minAutoAimDist 
+				&& ((extraTrace.fraction*MAX_XHAIR_DIST_ACCURACY)-Distance( ent->r.currentOrigin, camPos )) < (trace.fraction*g_cullDistance) )
+			{//this trace hit *something* that's closer than the thing the main trace hit, so use this result instead
+				VectorSubtract( extraTrace.endpos, shotStart, shotDir );
+				VectorNormalize( shotDir );
+				return qtrue;
+			}
+		}
+	}
+	return qfalse;
+}
+
+//---------------------------------------------------------
+void FireVehicleWeapon( gentity_t *ent, qboolean alt_fire ) 
+//---------------------------------------------------------
+{
+	Vehicle_t *pVeh = ent->m_pVehicle;
+	int muzzlesFired = 0;
+	gentity_t *missile = NULL;
+	vehWeaponInfo_t *vehWeapon = NULL;
+	qboolean	clearRocketLockEntity = qfalse;
+	
+	if ( !pVeh )
+	{
+		return;
+	}
+
+	if (pVeh->m_iRemovedSurfaces)
+	{ //can't fire when the thing is breaking apart
+		return;
+	}
+
+	if (pVeh->m_pVehicleInfo->type == VH_WALKER &&
+		ent->client->ps.electrifyTime > level.time)
+	{ //don't fire while being electrocuted
+		return;
+	}
+
+	// TODO?: If possible (probably not enough time), it would be nice if secondary fire was actually a mode switch/toggle
+	// so that, for instance, an x-wing can have 4-gun fire, or individual muzzle fire. If you wanted a different weapon, you
+	// would actually have to press the 2 key or something like that (I doubt I'd get a graphic for it anyways though). -AReis
+
+	// If this is not the alternate fire, fire a normal blaster shot...
+	if ( pVeh->m_pVehicleInfo &&
+		(pVeh->m_pVehicleInfo->type != VH_FIGHTER || (pVeh->m_ulFlags&VEH_WINGSOPEN)) ) // NOTE: Wings open also denotes that it has already launched.
+	{//fighters can only fire when wings are open
+		int	weaponNum = 0, vehWeaponIndex = VEH_WEAPON_NONE;
+		int	delay = 1000;
+		qboolean aimCorrect = qfalse;
+		qboolean linkedFiring = qfalse;
+
+		if ( !alt_fire )
+		{
+			weaponNum = 0;
+		}
+		else
+		{
+			weaponNum = 1;
+		}
+
+		vehWeaponIndex = pVeh->m_pVehicleInfo->weapon[weaponNum].ID;
+
+		if ( pVeh->weaponStatus[weaponNum].ammo <= 0 )
+		{//no ammo for this weapon
+			if ( pVeh->m_pPilot && pVeh->m_pPilot->s.number < MAX_CLIENTS )
+			{// let the client know he's out of ammo
+				int i;
+				//but only if one of the vehicle muzzles is actually ready to fire this weapon
+				for ( i = 0; i < MAX_VEHICLE_MUZZLES; i++ )
+				{
+					if ( pVeh->m_pVehicleInfo->weapMuzzle[i] != vehWeaponIndex )
+					{//this muzzle doesn't match the weapon we're trying to use
+						continue;
+					}
+					if ( pVeh->m_iMuzzleTag[i] != -1 
+						&& pVeh->m_iMuzzleWait[i] < level.time )
+					{//this one would have fired, send the no ammo message
+						G_AddEvent( (gentity_t*)pVeh->m_pPilot, EV_NOAMMO, weaponNum );
+						break;
+					}
+				}
+			}
+			return;
+		}
+
+		delay = pVeh->m_pVehicleInfo->weapon[weaponNum].delay;
+		aimCorrect = pVeh->m_pVehicleInfo->weapon[weaponNum].aimCorrect;
+		if ( pVeh->m_pVehicleInfo->weapon[weaponNum].linkable == 2//always linked
+			|| ( pVeh->m_pVehicleInfo->weapon[weaponNum].linkable == 1//optionally linkable
+				 && pVeh->weaponStatus[weaponNum].linked ) )//linked
+		{//we're linking the primary or alternate weapons, so we'll do *all* the muzzles
+			linkedFiring = qtrue;
+		}
+
+		if ( vehWeaponIndex <= VEH_WEAPON_BASE || vehWeaponIndex >= MAX_VEH_WEAPONS )
+		{//invalid vehicle weapon
+			return;
+		}
+		else
+		{
+			int i, numMuzzles = 0, numMuzzlesReady = 0, cumulativeDelay = 0, cumulativeAmmo = 0;
+			qboolean sentAmmoWarning = qfalse;
+
+			vehWeapon = &g_vehWeaponInfo[vehWeaponIndex];
+
+			if ( pVeh->m_pVehicleInfo->weapon[weaponNum].linkable == 2 )
+			{//always linked weapons don't accumulate delay, just use specified delay
+				cumulativeDelay = delay;
+			}
+			//find out how many we've got for this weapon
+			for ( i = 0; i < MAX_VEHICLE_MUZZLES; i++ )
+			{
+				if ( pVeh->m_pVehicleInfo->weapMuzzle[i] != vehWeaponIndex )
+				{//this muzzle doesn't match the weapon we're trying to use
+					continue;
+				}
+				if ( pVeh->m_iMuzzleTag[i] != -1 && pVeh->m_iMuzzleWait[i] < level.time )
+				{
+					numMuzzlesReady++;
+				}
+				if ( pVeh->m_pVehicleInfo->weapMuzzle[pVeh->weaponStatus[weaponNum].nextMuzzle] != vehWeaponIndex )
+				{//Our designated next muzzle for this weapon isn't valid for this weapon (happens when ships fire for the first time)
+					//set the next to this one
+					pVeh->weaponStatus[weaponNum].nextMuzzle = i;
+				}
+				if ( linkedFiring )
+				{
+					cumulativeAmmo += vehWeapon->iAmmoPerShot;
+					if ( pVeh->m_pVehicleInfo->weapon[weaponNum].linkable != 2 )
+					{//always linked weapons don't accumulate delay, just use specified delay
+						cumulativeDelay += delay;
+					}
+				}
+				numMuzzles++;
+			}
+
+			if ( linkedFiring )
+			{//firing all muzzles at once
+				if ( numMuzzlesReady != numMuzzles )
+				{//can't fire all linked muzzles yet
+					return;
+				}
+				else 
+				{//can fire all linked muzzles, check ammo
+					if ( pVeh->weaponStatus[weaponNum].ammo < cumulativeAmmo )
+					{//can't fire, not enough ammo
+						if ( pVeh->m_pPilot && pVeh->m_pPilot->s.number < MAX_CLIENTS )
+						{// let the client know he's out of ammo
+							G_AddEvent( (gentity_t*)pVeh->m_pPilot, EV_NOAMMO, weaponNum );
+						}
+						return;
+					}
+				}
+			}
+
+			for ( i = 0; i < MAX_VEHICLE_MUZZLES; i++ )
+			{
+				if ( pVeh->m_pVehicleInfo->weapMuzzle[i] != vehWeaponIndex )
+				{//this muzzle doesn't match the weapon we're trying to use
+					continue;
+				}
+				if ( !linkedFiring
+					&& i != pVeh->weaponStatus[weaponNum].nextMuzzle )
+				{//we're only firing one muzzle and this isn't it
+					continue;
+				}
+
+				// Fire this muzzle.
+				if ( pVeh->m_iMuzzleTag[i] != -1 && pVeh->m_iMuzzleWait[i] < level.time )
+				{
+					vec3_t	start, dir;
+					
+					if ( pVeh->weaponStatus[weaponNum].ammo < vehWeapon->iAmmoPerShot )
+					{//out of ammo!
+						if ( !sentAmmoWarning )
+						{
+							sentAmmoWarning = qtrue;
+							if ( pVeh->m_pPilot && pVeh->m_pPilot->s.number < MAX_CLIENTS )
+							{// let the client know he's out of ammo
+								G_AddEvent( (gentity_t*)pVeh->m_pPilot, EV_NOAMMO, weaponNum );
+							}
+						}
+					}
+					else
+					{//have enough ammo to shoot
+						//do the firing
+						WP_CalcVehMuzzle(ent, i);
+						VectorCopy( pVeh->m_vMuzzlePos[i], start );
+						VectorCopy( pVeh->m_vMuzzleDir[i], dir );
+						if ( WP_VehCheckTraceFromCamPos( ent, start, dir ) )
+						{//auto-aim at whatever crosshair would be over from camera's point of view (if closer)
+						}
+						else if ( aimCorrect )
+						{//auto-aim the missile at the crosshair if there's anything there
+							trace_t trace;
+							vec3_t	end;
+							vec3_t	ang;
+
+							if (pVeh->m_pVehicleInfo->type == VH_SPEEDER)
+							{
+								VectorSet(ang, 0.0f, pVeh->m_vOrientation[1], 0.0f);
+							}
+							else
+							{
+								VectorCopy(pVeh->m_vOrientation, ang);
+							}
+							AngleVectors( ang, dir, NULL, NULL );
+							VectorMA( ent->r.currentOrigin, 32768, dir, end );
+							//VectorMA( ent->r.currentOrigin, 8192, dir, end );
+							trap_Trace( &trace, ent->r.currentOrigin, vec3_origin, vec3_origin, end, ent->s.number, MASK_SHOT );
+							if ( trace.fraction < 1.0f && !trace.allsolid && !trace.startsolid )
+							{
+								VectorSubtract( trace.endpos, start, dir );
+								VectorNormalize( dir );
+							}
+						}
+
+						//play the weapon's muzzle effect if we have one
+						//NOTE: just need MAX_VEHICLE_MUZZLES bits for this... should be cool since it's currently 12 and we're sending it in 16 bits
+						muzzlesFired |= (1<<i);
+												
+						missile = WP_FireVehicleWeapon( ent, start, dir, vehWeapon, alt_fire, qfalse );
+						if ( vehWeapon->fHoming )
+						{//clear the rocket lock entity *after* all muzzles have fired
+							clearRocketLockEntity = qtrue;
+						}
+					}
+
+					if ( linkedFiring )
+					{//we're linking the weapon, so continue on and fire all appropriate muzzles
+						continue;
+					}
+					//else just firing one
+					//take the ammo, set the next muzzle and set the delay on it
+					if ( numMuzzles > 1 )
+					{//more than one, look for it
+						int nextMuzzle = pVeh->weaponStatus[weaponNum].nextMuzzle;
+						while ( 1 )
+						{
+							nextMuzzle++;
+							if ( nextMuzzle >= MAX_VEHICLE_MUZZLES )
+							{
+								nextMuzzle = 0;
+							}
+							if ( nextMuzzle == pVeh->weaponStatus[weaponNum].nextMuzzle )
+							{//WTF?  Wrapped without finding another valid one!
+								break;
+							}
+							if ( pVeh->m_pVehicleInfo->weapMuzzle[nextMuzzle] == vehWeaponIndex )
+							{//this is the next muzzle for this weapon
+								pVeh->weaponStatus[weaponNum].nextMuzzle = nextMuzzle;
+								break;
+							}
+						}
+					}//else, just stay on the one we just fired
+					//set the delay on the next muzzle
+					pVeh->m_iMuzzleWait[pVeh->weaponStatus[weaponNum].nextMuzzle] = level.time + delay;
+					//take away the ammo
+					pVeh->weaponStatus[weaponNum].ammo -= vehWeapon->iAmmoPerShot;
+					//NOTE: in order to send the vehicle's ammo info to the client, we copy the ammo into the first 2 ammo slots on the vehicle NPC's client->ps.ammo array
+					if ( pVeh->m_pParentEntity && ((gentity_t*)(pVeh->m_pParentEntity))->client )
+					{
+						((gentity_t*)(pVeh->m_pParentEntity))->client->ps.ammo[weaponNum] = pVeh->weaponStatus[weaponNum].ammo;
+					}
+					//done!
+					//we'll get in here again next frame and try the next muzzle...
+					//return;
+					goto tryFire;
+				}
+			}
+			//we went through all the muzzles, so apply the cumulative delay and ammo cost
+			if ( cumulativeAmmo )
+			{//taking ammo one shot at a time
+				//take the ammo
+				pVeh->weaponStatus[weaponNum].ammo -= cumulativeAmmo;
+				//NOTE: in order to send the vehicle's ammo info to the client, we copy the ammo into the first 2 ammo slots on the vehicle NPC's client->ps.ammo array
+				if ( pVeh->m_pParentEntity && ((gentity_t*)(pVeh->m_pParentEntity))->client )
+				{
+					((gentity_t*)(pVeh->m_pParentEntity))->client->ps.ammo[weaponNum] = pVeh->weaponStatus[weaponNum].ammo;
+				}
+			}
+			if ( cumulativeDelay )
+			{//we linked muzzles so we need to apply the cumulative delay now, to each of the linked muzzles
+				for ( i = 0; i < MAX_VEHICLE_MUZZLES; i++ )
+				{
+					if ( pVeh->m_pVehicleInfo->weapMuzzle[i] != vehWeaponIndex )
+					{//this muzzle doesn't match the weapon we're trying to use
+						continue;
+					}
+					//apply the cumulative delay
+					pVeh->m_iMuzzleWait[i] = level.time + cumulativeDelay;
+				}
+			}
+		}
+	}
+
+tryFire:
+	if ( clearRocketLockEntity )
+	{//hmm, should probably clear that anytime any weapon fires?
+		ent->client->ps.rocketLockIndex = ENTITYNUM_NONE;
+		ent->client->ps.rocketLockTime = 0;
+		ent->client->ps.rocketTargetTime = 0;
+	}
+
+	if ( vehWeapon && muzzlesFired > 0 )
+	{
+		G_VehMuzzleFireFX(ent, missile, muzzlesFired );
+	}
+}
+
+/*
+===============
+FireWeapon
+===============
+*/
+#include "../namespace_begin.h"
+int BG_EmplacedView(vec3_t baseAngles, vec3_t angles, float *newYaw, float constraint);
+#include "../namespace_end.h"
+
+void FireWeapon( gentity_t *ent, qboolean altFire ) {
+	if (ent->client->ps.powerups[PW_QUAD] ) {
+		s_quadFactor = g_quadfactor.value;
+	} else {
+		s_quadFactor = 1;
+	}
+
+	// track shots taken for accuracy tracking.  Grapple is not a weapon and gauntet is just not tracked
+	if( ent->s.weapon != WP_SABER && ent->s.weapon != WP_STUN_BATON && ent->s.weapon != WP_MELEE ) 
+	{
+		if( ent->s.weapon == WP_FLECHETTE ) {
+			ent->client->accuracy_shots += FLECHETTE_SHOTS;
+		} else {
+			ent->client->accuracy_shots++;
+		}
+	}
+
+	if ( ent && ent->client && ent->client->NPC_class == CLASS_VEHICLE )
+	{
+		FireVehicleWeapon( ent, altFire );
+		return;
+	}
+	else
+	{
+		// set aiming directions
+		if (ent->s.weapon == WP_EMPLACED_GUN &&
+			ent->client->ps.emplacedIndex)
+		{ //if using emplaced then base muzzle point off of gun position/angles
+			gentity_t *emp = &g_entities[ent->client->ps.emplacedIndex];
+
+			if (emp->inuse)
+			{
+				float yaw;
+				vec3_t viewAngCap;
+				int override;
+
+				VectorCopy(ent->client->ps.viewangles, viewAngCap);
+				if (viewAngCap[PITCH] > 40)
+				{
+					viewAngCap[PITCH] = 40;
+				}
+
+				override = BG_EmplacedView(ent->client->ps.viewangles, emp->s.angles, &yaw,
+					emp->s.origin2[0]);
+				
+				if (override)
+				{
+					viewAngCap[YAW] = yaw;
+				}
+
+				AngleVectors( viewAngCap, forward, vright, up );
+			}
+			else
+			{
+				AngleVectors( ent->client->ps.viewangles, forward, vright, up );
+			}
+		}
+		else if (ent->s.number < MAX_CLIENTS &&
+			ent->client->ps.m_iVehicleNum && ent->s.weapon == WP_BLASTER)
+		{ //riding a vehicle...with blaster selected
+			vec3_t vehTurnAngles;
+			gentity_t *vehEnt = &g_entities[ent->client->ps.m_iVehicleNum];
+
+			if (vehEnt->inuse && vehEnt->client && vehEnt->m_pVehicle)
+			{
+				VectorCopy(vehEnt->m_pVehicle->m_vOrientation, vehTurnAngles);
+				vehTurnAngles[PITCH] = ent->client->ps.viewangles[PITCH];
+			}
+			else
+			{
+				VectorCopy(ent->client->ps.viewangles, vehTurnAngles);
+			}
+			if (ent->client->pers.cmd.rightmove > 0)
+			{ //shooting to right
+				vehTurnAngles[YAW] -= 90.0f;
+			}
+			else if (ent->client->pers.cmd.rightmove < 0)
+			{ //shooting to left
+				vehTurnAngles[YAW] += 90.0f;
+			}
+
+			AngleVectors( vehTurnAngles, forward, vright, up );
+		}
+		else
+		{
+			AngleVectors( ent->client->ps.viewangles, forward, vright, up );
+		}
+
+		CalcMuzzlePoint ( ent, forward, vright, up, muzzle );
+
+		// fire the specific weapon
+		switch( ent->s.weapon ) {
+		case WP_STUN_BATON:
+			WP_FireStunBaton( ent, altFire );
+			break;
+
+		case WP_MELEE:
+			WP_FireMelee(ent, altFire);
+			break;
+
+		case WP_SABER:
+			break;
+
+		case WP_BRYAR_PISTOL:
+			//if ( g_gametype.integer == GT_SIEGE )
+			if (1)
+			{//allow alt-fire
+				WP_FireBryarPistol( ent, altFire );
+			}
+			else
+			{
+				WP_FireBryarPistol( ent, qfalse );
+			}
+			break;
+
+		case WP_CONCUSSION:
+			if ( altFire )
+			{
+				WP_FireConcussionAlt( ent );
+			}
+			else
+			{
+				WP_FireConcussion( ent );
+			}
+			break;
+
+		case WP_BRYAR_OLD:
+			WP_FireBryarPistol( ent, altFire );
+			break;
+
+		case WP_BLASTER:
+			WP_FireBlaster( ent, altFire );
+			break;
+
+		case WP_DISRUPTOR:
+			WP_FireDisruptor( ent, altFire );
+			break;
+
+		case WP_BOWCASTER:
+			WP_FireBowcaster( ent, altFire );
+			break;
+
+		case WP_REPEATER:
+			WP_FireRepeater( ent, altFire );
+			break;
+
+		case WP_DEMP2:
+			WP_FireDEMP2( ent, altFire );
+			break;
+
+		case WP_FLECHETTE:
+			WP_FireFlechette( ent, altFire );
+			break;
+
+		case WP_ROCKET_LAUNCHER:
+			WP_FireRocket( ent, altFire );
+			break;
+
+		case WP_THERMAL:
+			WP_FireThermalDetonator( ent, altFire );
+			break;
+
+		case WP_TRIP_MINE:
+			WP_PlaceLaserTrap( ent, altFire );
+			break;
+
+		case WP_DET_PACK:
+			WP_DropDetPack( ent, altFire );
+			break;
+
+		case WP_EMPLACED_GUN:
+			if (ent->client && ent->client->ewebIndex)
+			{ //specially handled by the e-web itself
+				break;
+			}
+			WP_FireEmplaced( ent, altFire );
+			break;
+		default:
+//			assert(!"unknown weapon fire");
+			break;
+		}
+	}
+
+	G_LogWeaponFire(ent->s.number, ent->s.weapon);
+}
+
+//---------------------------------------------------------
+static void WP_FireEmplaced( gentity_t *ent, qboolean altFire )
+//---------------------------------------------------------
+{
+	vec3_t	dir, angs, gunpoint;
+	vec3_t	right;
+	gentity_t *gun;
+	int side;
+
+	if (!ent->client)
+	{
+		return;
+	}
+
+	if (!ent->client->ps.emplacedIndex)
+	{ //shouldn't be using WP_EMPLACED_GUN if we aren't on an emplaced weapon
+		return;
+	}
+
+	gun = &g_entities[ent->client->ps.emplacedIndex];
+
+	if (!gun->inuse || gun->health <= 0)
+	{ //gun was removed or killed, although we should never hit this check because we should have been forced off it already
+		return;
+	}
+
+	VectorCopy(gun->s.origin, gunpoint);
+	gunpoint[2] += 46;
+
+	AngleVectors(ent->client->ps.viewangles, NULL, right, NULL);
+
+	if (gun->genericValue10)
+	{ //fire out of the right cannon side
+		VectorMA(gunpoint, 10.0f, right, gunpoint);
+		side = 0;
+	}
+	else
+	{ //the left
+		VectorMA(gunpoint, -10.0f, right, gunpoint);
+		side = 1;
+	}
+
+	gun->genericValue10 = side;
+	G_AddEvent(gun, EV_FIRE_WEAPON, side);
+
+	vectoangles( forward, angs );
+
+	AngleVectors( angs, dir, NULL, NULL );
+
+	WP_FireEmplacedMissile( gun, gunpoint, dir, altFire, ent );
+}
+
+#define EMPLACED_CANRESPAWN 1
+
+//----------------------------------------------------------
+
+/*QUAKED emplaced_gun (0 0 1) (-30 -20 8) (30 20 60) CANRESPAWN
+
+ count - if CANRESPAWN spawnflag, decides how long it is before gun respawns (in ms)
+ constraint - number of degrees gun is constrained from base angles on each side (default 60.0)
+
+ showhealth - set to 1 to show health bar on this entity when crosshair is over it
+  
+  teamowner - crosshair shows green for this team, red for opposite team
+	0 - none
+	1 - red
+	2 - blue
+
+  alliedTeam - team that can use this
+	0 - any
+	1 - red
+	2 - blue
+
+  teamnodmg - team that turret does not take damage from or do damage to
+	0 - none
+	1 - red
+	2 - blue
+*/
+ 
+//----------------------------------------------------------
+extern qboolean TryHeal(gentity_t *ent, gentity_t *target); //g_utils.c
+void emplaced_gun_use( gentity_t *self, gentity_t *other, trace_t *trace )
+{
+	vec3_t fwd1, fwd2;
+	float dot;
+	int oldWeapon;
+	gentity_t *activator = other;
+	float zoffset = 50;
+	vec3_t anglesToOwner;
+	vec3_t vLen;
+	float ownLen;
+
+	if ( self->health <= 0 )
+	{ //gun is destroyed
+		return;
+	}
+
+	if (self->activator)
+	{ //someone is already using me
+		return;
+	}
+
+	if (!activator->client)
+	{
+		return;
+	}
+
+	if (activator->client->ps.emplacedTime > level.time)
+	{ //last use attempt still too recent
+		return;
+	}
+
+	if (activator->client->ps.forceHandExtend != HANDEXTEND_NONE)
+	{ //don't use if busy doing something else
+		return;
+	}
+
+	if (activator->client->ps.origin[2] > self->s.origin[2]+zoffset-8)
+	{ //can't use it from the top
+		return;
+	}
+
+	if (activator->client->ps.pm_flags & PMF_DUCKED)
+	{ //must be standing
+		return;
+	}
+
+	if (activator->client->ps.isJediMaster)
+	{ //jm can't use weapons
+		return;
+	}
+
+	VectorSubtract(self->s.origin, activator->client->ps.origin, vLen);
+	ownLen = VectorLength(vLen);
+
+	if (ownLen > 64.0f)
+	{ //must be within 64 units of the gun to use at all
+		return;
+	}
+
+	// Let's get some direction vectors for the user
+	AngleVectors( activator->client->ps.viewangles, fwd1, NULL, NULL );
+
+	// Get the guns direction vector
+	AngleVectors( self->pos1, fwd2, NULL, NULL );
+
+	dot = DotProduct( fwd1, fwd2 );
+
+	// Must be reasonably facing the way the gun points ( 110 degrees or so ), otherwise we don't allow to use it.
+	if ( dot < -0.2f )
+	{
+		goto tryHeal;
+	}
+
+	VectorSubtract(self->s.origin, activator->client->ps.origin, fwd1);
+	VectorNormalize(fwd1);
+
+	dot = DotProduct( fwd1, fwd2 );
+
+	//check the positioning in relation to the gun as well
+	if ( dot < 0.6f )
+	{
+		goto tryHeal;
+	}
+
+	self->genericValue1 = 1;
+
+	oldWeapon = activator->s.weapon;
+
+	// swap the users weapon with the emplaced gun
+	activator->client->ps.weapon = self->s.weapon;
+	activator->client->ps.weaponstate = WEAPON_READY;
+	activator->client->ps.stats[STAT_WEAPONS] |= ( 1 << WP_EMPLACED_GUN );
+
+	activator->client->ps.emplacedIndex = self->s.number;
+
+	self->s.emplacedOwner = activator->s.number;
+	self->s.activeForcePass = NUM_FORCE_POWERS+1;
+
+	// the gun will track which weapon we used to have
+	self->s.weapon = oldWeapon;
+
+	//user's new owner becomes the gun ent
+	activator->r.ownerNum = self->s.number;
+	self->activator = activator;
+
+	VectorSubtract(self->r.currentOrigin, activator->client->ps.origin, anglesToOwner);
+	vectoangles(anglesToOwner, anglesToOwner);
+	return;
+
+tryHeal: //well, not in the right dir, try healing it instead...
+	TryHeal(activator, self);
+}
+
+void emplaced_gun_realuse( gentity_t *self, gentity_t *other, gentity_t *activator )
+{
+	emplaced_gun_use(self, other, NULL);
+}
+
+//----------------------------------------------------------
+void emplaced_gun_pain( gentity_t *self, gentity_t *attacker, int damage )
+{
+	self->s.health = self->health;
+
+	if ( self->health <= 0 )
+	{
+		//death effect.. for now taken care of on cgame
+	}
+	else
+	{
+		//if we have a pain behavior set then use it I guess
+		G_ActivateBehavior( self, BSET_PAIN );
+	}
+}
+
+#define EMPLACED_GUN_HEALTH 800
+
+//----------------------------------------------------------
+void emplaced_gun_update(gentity_t *self)
+{
+	vec3_t	smokeOrg, puffAngle;
+	int oldWeap;
+	float ownLen = 0;
+
+	if (self->health < 1 && !self->genericValue5)
+	{ //we are dead, set our respawn delay if we have one
+		if (self->spawnflags & EMPLACED_CANRESPAWN)
+		{
+			self->genericValue5 = level.time + 4000 + self->count;
+		}
+	}
+	else if (self->health < 1 && self->genericValue5 < level.time)
+	{ //we are dead, see if it's time to respawn
+		self->s.time = 0;
+		self->genericValue4 = 0;
+		self->genericValue3 = 0;
+		self->health = EMPLACED_GUN_HEALTH*0.4;
+		self->s.health = self->health;
+	}
+
+	if (self->genericValue4 && self->genericValue4 < 2 && self->s.time < level.time)
+	{ //we have finished our warning (red flashing) effect, it's time to finish dying
+		vec3_t explOrg;
+
+		VectorSet( puffAngle, 0, 0, 1 );
+
+		VectorCopy(self->r.currentOrigin, explOrg);
+		explOrg[2] += 16;
+
+		//just use the detpack explosion effect
+		G_PlayEffect(EFFECT_EXPLOSION_DETPACK, explOrg, puffAngle);
+
+		self->genericValue3 = level.time + Q_irand(2500, 3500);
+
+		G_RadiusDamage(self->r.currentOrigin, self, self->splashDamage, self->splashRadius, self, NULL, MOD_UNKNOWN);
+
+		self->s.time = -1;
+
+		self->genericValue4 = 2;
+	}
+
+	if (self->genericValue3 > level.time)
+	{ //see if we are freshly dead and should be smoking
+		if (self->genericValue2 < level.time)
+		{ //is it time yet to spawn another smoke puff?
+			VectorSet( puffAngle, 0, 0, 1 );
+			VectorCopy(self->r.currentOrigin, smokeOrg);
+
+			smokeOrg[2] += 60;
+
+			G_PlayEffect(EFFECT_SMOKE, smokeOrg, puffAngle);
+			self->genericValue2 = level.time + Q_irand(250, 400);
+		}
+	}
+
+	if (self->activator && self->activator->client && self->activator->inuse)
+	{ //handle updating current user
+		vec3_t vLen;
+		VectorSubtract(self->s.origin, self->activator->client->ps.origin, vLen);
+		ownLen = VectorLength(vLen);
+
+		if (!(self->activator->client->pers.cmd.buttons & BUTTON_USE) && self->genericValue1)
+		{
+			self->genericValue1 = 0;
+		}
+
+		if ((self->activator->client->pers.cmd.buttons & BUTTON_USE) && !self->genericValue1)
+		{
+			self->activator->client->ps.emplacedIndex = 0;
+			self->activator->client->ps.saberHolstered = 0;
+			self->nextthink = level.time + 50;
+			return;
+		}
+	}
+
+	if ((self->activator && self->activator->client) &&
+		(!self->activator->inuse || self->activator->client->ps.emplacedIndex != self->s.number || self->genericValue4 || ownLen > 64))
+	{ //get the user off of me then
+		self->activator->client->ps.stats[STAT_WEAPONS] &= ~(1<<WP_EMPLACED_GUN);
+
+		oldWeap = self->activator->client->ps.weapon;
+		self->activator->client->ps.weapon = self->s.weapon;
+		self->s.weapon = oldWeap;
+		self->activator->r.ownerNum = ENTITYNUM_NONE;
+		self->activator->client->ps.emplacedTime = level.time + 1000;
+		self->activator->client->ps.emplacedIndex = 0;
+		self->activator->client->ps.saberHolstered = 0;
+		self->activator = NULL;
+
+		self->s.activeForcePass = 0;
+	}
+	else if (self->activator && self->activator->client)
+	{ //make sure the user is using the emplaced gun weapon
+		self->activator->client->ps.weapon = WP_EMPLACED_GUN;
+		self->activator->client->ps.weaponstate = WEAPON_READY;
+	}
+	self->nextthink = level.time + 50;
+}
+
+//----------------------------------------------------------
+void emplaced_gun_die( gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int mod )
+{ //set us up to flash and then explode
+	if (self->genericValue4)
+	{
+		return;
+	}
+
+	self->genericValue4 = 1;
+
+	self->s.time = level.time + 3000;
+
+	self->genericValue5 = 0;
+}
+
+void SP_emplaced_gun( gentity_t *ent )
+{
+	const char *name = "models/map_objects/mp/turret_chair.glm";
+	vec3_t down;
+	trace_t tr;
+
+	//make sure our assets are precached
+	RegisterItem( BG_FindItemForWeapon(WP_EMPLACED_GUN) );
+
+	ent->r.contents = CONTENTS_SOLID;
+	ent->s.solid = SOLID_BBOX;
+
+	ent->genericValue5 = 0;
+
+	VectorSet( ent->r.mins, -30, -20, 8 );
+	VectorSet( ent->r.maxs, 30, 20, 60 );
+
+	VectorCopy(ent->s.origin, down);
+
+	down[2] -= 1024;
+
+	trap_Trace(&tr, ent->s.origin, ent->r.mins, ent->r.maxs, down, ent->s.number, MASK_SOLID);
+
+	if (tr.fraction != 1 && !tr.allsolid && !tr.startsolid)
+	{
+		VectorCopy(tr.endpos, ent->s.origin);
+	}
+
+	ent->spawnflags |= 4; // deadsolid
+
+	ent->health = EMPLACED_GUN_HEALTH;
+
+	if (ent->spawnflags & EMPLACED_CANRESPAWN)
+	{ //make it somewhat easier to kill if it can respawn
+		ent->health *= 0.4;
+	}
+
+	ent->maxHealth = ent->health;
+	G_ScaleNetHealth(ent);
+
+	ent->genericValue4 = 0;
+
+	ent->takedamage = qtrue;
+	ent->pain = emplaced_gun_pain;
+	ent->die = emplaced_gun_die;
+
+	// being caught in this thing when it blows would be really bad.
+	ent->splashDamage = 80;
+	ent->splashRadius = 128;
+
+	// amount of ammo that this little poochie has
+	G_SpawnInt( "count", "600", &ent->count );
+
+	G_SpawnFloat( "constraint", "60", &ent->s.origin2[0] );
+
+	ent->s.modelindex = G_ModelIndex( (char *)name );
+	ent->s.modelGhoul2 = 1;
+	ent->s.g2radius = 110;
+
+	//so the cgame knows for sure that we're an emplaced weapon
+	ent->s.weapon = WP_EMPLACED_GUN;
+
+	G_SetOrigin( ent, ent->s.origin );
+	
+	// store base angles for later
+	VectorCopy( ent->s.angles, ent->pos1 );
+	VectorCopy( ent->s.angles, ent->r.currentAngles );
+	VectorCopy( ent->s.angles, ent->s.apos.trBase );
+
+	ent->think = emplaced_gun_update;
+	ent->nextthink = level.time + 50;
+
+	ent->use = emplaced_gun_realuse;
+
+	ent->r.svFlags |= SVF_PLAYER_USABLE;
+
+	ent->s.pos.trType = TR_STATIONARY;
+
+	ent->s.owner = MAX_CLIENTS+1;
+	ent->s.shouldtarget = qtrue;
+	//ent->s.teamowner = 0;
+
+	trap_LinkEntity(ent);
+}
diff --git a/codemp/game/game.bat b/codemp/game/game.bat
new file mode 100644
index 0000000..27ae082
--- /dev/null
+++ b/codemp/game/game.bat
@@ -0,0 +1,19 @@
+echo off
+
+REM del /q vm
+REM rww - removed this.. point of makefile is not have to rebuild all of it
+
+mkdir vm
+
+del vm\bg_lib.asm
+asm2mak game makefile
+make game
+
+cd vm
+
+mkdir "..\..\base\vm"
+copy *.map "..\..\base\vm"
+copy *.qvm "..\..\base\vm"
+
+:quit
+cd ..
diff --git a/codemp/game/game.q3asm b/codemp/game/game.q3asm
new file mode 100644
index 0000000..c54dc7b
--- /dev/null
+++ b/codemp/game/game.q3asm
@@ -0,0 +1,80 @@
+-o "vm/jk2mpgame"
+
+vm/g_main
+vm/ai_main
+vm/ai_util
+vm/ai_wpnav
+vm/bg_lib
+vm/bg_misc
+vm/bg_pmove
+vm/bg_panimate
+vm/bg_slidemove
+vm/bg_weapons
+vm/bg_saber
+vm/bg_saberLoad
+vm/bg_saga
+vm/bg_vehicleLoad
+vm/g_active
+vm/g_arenas
+vm/g_bot
+vm/g_client
+vm/g_cmds
+vm/g_combat
+vm/g_exphysics
+vm/g_ICARUScb
+vm/g_items
+vm/g_log
+vm/g_mem
+vm/g_misc
+vm/g_missile
+vm/g_mover
+vm/g_nav
+vm/g_navnew
+vm/g_object
+vm/g_saga
+vm/g_session
+vm/g_spawn
+vm/g_strap
+vm/g_svcmds
+vm/g_syscalls
+vm/g_target
+vm/g_team
+vm/g_timer
+vm/g_trigger
+vm/g_utils
+vm/g_weapon
+vm/NPC
+vm/NPC_AI_Atst
+vm/NPC_AI_Default
+vm/NPC_AI_Droid
+vm/NPC_AI_GalakMech
+vm/NPC_AI_Grenadier
+vm/NPC_AI_Howler
+vm/NPC_AI_ImperialProbe
+vm/NPC_AI_Interrogator
+vm/NPC_AI_Jedi
+vm/NPC_AI_Mark1
+vm/NPC_AI_Mark2
+vm/NPC_AI_MineMonster
+vm/NPC_AI_Remote
+vm/NPC_AI_Seeker
+vm/NPC_AI_Sentry
+vm/NPC_AI_Sniper
+vm/NPC_AI_Stormtrooper
+vm/NPC_AI_Utils
+vm/NPC_behavior
+vm/NPC_combat
+vm/NPC_goal
+vm/NPC_misc
+vm/NPC_move
+vm/NPC_reactions
+vm/NPC_senses
+vm/NPC_sounds
+vm/NPC_spawn
+vm/NPC_stats
+vm/NPC_utils
+
+vm/w_force
+vm/w_saber
+vm/q_math
+vm/q_shared
diff --git a/codemp/game/inv.h b/codemp/game/inv.h
new file mode 100644
index 0000000..c9133b0
--- /dev/null
+++ b/codemp/game/inv.h
@@ -0,0 +1,104 @@
+
+#define INVENTORY_NONE				0
+//pickups
+#define INVENTORY_ARMOR				1
+#define INVENTORY_HEALTH			2
+//items
+#define INVENTORY_SEEKER			3
+#define INVENTORY_MEDPAC			4
+#define INVENTORY_DATAPAD			5
+#define INVENTORY_BINOCULARS		6
+#define INVENTORY_SENTRY_GUN		7
+#define INVENTORY_GOGGLES			8
+//weapons
+#define INVENTORY_STUN_BATON		9
+#define INVENTORY_SABER				10
+#define INVENTORY_BRYAR_PISTOL		11
+#define INVENTORY_BLASTER			12
+#define INVENTORY_DISRUPTOR			13
+#define INVENTORY_BOWCASTER			14
+#define INVENTORY_REPEATER			15
+#define INVENTORY_DEMP2				16
+#define INVENTORY_FLECHETTE			17
+#define INVENTORY_ROCKET_LAUNCHER	18
+#define INVENTORY_THERMAL			19
+#define INVENTORY_TRIP_MINE			20
+#define INVENTORY_DET_PACK			21
+//ammo
+#define INVENTORY_AMMO_FORCE		22
+#define INVENTORY_AMMO_BLASTER		23
+#define INVENTORY_AMMO_BOLTS		24
+#define INVENTORY_AMMO_ROCKETS		25
+//powerups
+#define INVENTORY_REDFLAG			26
+#define INVENTORY_BLUEFLAG			27
+#define INVENTORY_SCOUT				28
+#define INVENTORY_GUARD				29
+#define INVENTORY_DOUBLER			30
+#define INVENTORY_AMMOREGEN			31
+#define INVENTORY_NEUTRALFLAG		32
+#define INVENTORY_REDCUBE			33
+#define INVENTORY_BLUECUBE			34
+
+//enemy stuff
+#define ENEMY_HORIZONTAL_DIST		200
+#define ENEMY_HEIGHT				201
+#define NUM_VISIBLE_ENEMIES			202
+#define NUM_VISIBLE_TEAMMATES		203
+
+// NOTENOTE Update this so that it is in sync.
+//item numbers (make sure they are in sync with bg_itemlist in bg_misc.c)
+//pickups
+#define MODELINDEX_ARMOR			1
+#define MODELINDEX_HEALTH			2
+//items
+#define MODELINDEX_SEEKER			3
+#define MODELINDEX_MEDPAC			4
+#define MODELINDEX_DATAPAD			5
+#define MODELINDEX_BINOCULARS		6
+#define MODELINDEX_SENTRY_GUN		7
+#define MODELINDEX_GOGGLES			8
+//weapons
+#define MODELINDEX_STUN_BATON		9
+#define MODELINDEX_SABER			10
+#define MODELINDEX_BRYAR_PISTOL		11
+#define MODELINDEX_BLASTER			12
+#define MODELINDEX_DISRUPTOR		13
+#define MODELINDEX_BOWCASTER		14
+#define MODELINDEX_REPEATER			15
+#define MODELINDEX_DEMP2			16
+#define MODELINDEX_FLECHETTE		17
+#define MODELINDEX_ROCKET_LAUNCHER	18
+#define MODELINDEX_THERMAL			19
+#define MODELINDEX_TRIP_MINE		20
+#define MODELINDEX_DET_PACK			21
+//ammo
+#define MODELINDEX_AMMO_FORCE		22
+#define MODELINDEX_AMMO_BLASTER		23
+#define MODELINDEX_AMMO_BOLTS		24
+#define MODELINDEX_AMMO_ROCKETS		25
+//powerups
+#define MODELINDEX_REDFLAG			26
+#define MODELINDEX_BLUEFLAG			27
+#define MODELINDEX_SCOUT			28
+#define MODELINDEX_GUARD			29
+#define MODELINDEX_DOUBLER			30
+#define MODELINDEX_AMMOREGEN		31
+#define MODELINDEX_NEUTRALFLAG		32
+#define MODELINDEX_REDCUBE			33
+#define MODELINDEX_BLUECUBE			34
+
+//
+#define WEAPONINDEX_STUN_BATON		1
+#define WEAPONINDEX_SABER			2
+#define WEAPONINDEX_BRYAR_PISTOL	3
+#define WEAPONINDEX_BLASTER			4
+#define WEAPONINDEX_DISRUPTOR		5
+#define WEAPONINDEX_BOWCASTER		6
+#define WEAPONINDEX_REPEATER		7
+#define WEAPONINDEX_DEMP2			8
+#define WEAPONINDEX_FLECHETTE		9
+#define WEAPONINDEX_ROCKET_LAUNCHER	10
+#define WEAPONINDEX_THERMAL			11
+#define WEAPONINDEX_TRIP_MINE		12
+#define WEAPONINDEX_DET_PACK		13
diff --git a/codemp/game/match.h b/codemp/game/match.h
new file mode 100644
index 0000000..7fb6a38
--- /dev/null
+++ b/codemp/game/match.h
@@ -0,0 +1,122 @@
+//===========================================================================
+//
+// Name:			match.h
+// Function:		match template defines
+// Programmer:		Mr Elusive
+// Last update:
+// Tab Size:		4 (real tabs)
+//
+//===========================================================================
+
+// make sure this is the same character as we use in chats in g_cmd.c
+#define EC	"\x19"
+
+//match template contexts
+#define MTCONTEXT_MISC					2
+#define MTCONTEXT_INITIALTEAMCHAT		4
+#define MTCONTEXT_TIME					8
+#define MTCONTEXT_TEAMMATE				16
+#define MTCONTEXT_ADDRESSEE				32
+#define MTCONTEXT_PATROLKEYAREA			64
+#define MTCONTEXT_REPLYCHAT				128
+#define MTCONTEXT_CTF					256
+
+//message types
+#define MSG_NEWLEADER					1		//new leader
+#define MSG_ENTERGAME					2		//enter game message
+#define MSG_HELP						3		//help someone
+#define MSG_ACCOMPANY					4		//accompany someone
+#define MSG_DEFENDKEYAREA				5		//defend a key area
+#define MSG_RUSHBASE					6		//everyone rush to base
+#define MSG_GETFLAG						7		//get the enemy flag
+#define MSG_STARTTEAMLEADERSHIP			8		//someone wants to become the team leader
+#define MSG_STOPTEAMLEADERSHIP			9		//someone wants to stop being the team leader
+#define MSG_WHOISTEAMLAEDER				10		//who is the team leader
+#define MSG_WAIT						11		//wait for someone
+#define MSG_WHATAREYOUDOING				12		//what are you doing?
+#define MSG_JOINSUBTEAM					13		//join a sub-team
+#define MSG_LEAVESUBTEAM				14		//leave a sub-team
+#define MSG_CREATENEWFORMATION			15		//create a new formation
+#define MSG_FORMATIONPOSITION			16		//tell someone his/her position in a formation
+#define MSG_FORMATIONSPACE				17		//set the formation intervening space
+#define MSG_DOFORMATION					18		//form a known formation
+#define MSG_DISMISS						19		//dismiss commanded team mates
+#define MSG_CAMP						20		//camp somewhere
+#define MSG_CHECKPOINT					21		//remember a check point
+#define MSG_PATROL						22		//patrol between certain keypoints
+#define MSG_LEADTHEWAY					23		//lead the way
+#define MSG_GETITEM						24		//get an item
+#define MSG_KILL						25		//kill someone
+#define MSG_WHEREAREYOU					26		//where is someone
+#define MSG_RETURNFLAG					27		//return the flag
+#define MSG_WHATISMYCOMMAND				28		//ask the team leader what to do
+#define MSG_WHICHTEAM					29		//ask which team a bot is in
+#define MSG_TASKPREFERENCE				30		//tell your teamplay task preference
+#define MSG_ATTACKENEMYBASE				31		//attack the enemy base
+#define MSG_HARVEST						32		//go harvest
+#define MSG_SUICIDE						33		//order to suicide
+//
+#define MSG_ME							100
+#define MSG_EVERYONE					101
+#define MSG_MULTIPLENAMES				102
+#define MSG_NAME						103
+#define MSG_PATROLKEYAREA				104
+#define MSG_MINUTES						105
+#define MSG_SECONDS						106
+#define MSG_FOREVER						107
+#define MSG_FORALONGTIME				108
+#define MSG_FORAWHILE					109
+//
+#define MSG_CHATALL						200
+#define MSG_CHATTEAM					201
+#define MSG_CHATTELL					202
+//
+#define MSG_CTF							300		//ctf message
+
+//command sub types
+#define ST_SOMEWHERE					0
+#define ST_NEARITEM						1
+#define ST_ADDRESSED					2
+#define ST_METER						4
+#define ST_FEET							8
+#define ST_TIME							16
+#define ST_HERE							32
+#define ST_THERE						64
+#define ST_I							128
+#define ST_MORE							256
+#define ST_BACK							512
+#define ST_REVERSE						1024
+#define ST_SOMEONE						2048
+#define ST_GOTFLAG						4096
+#define ST_CAPTUREDFLAG					8192
+#define ST_RETURNEDFLAG					16384
+#define ST_TEAM							32768
+#define ST_1FCTFGOTFLAG					65535
+//ctf task preferences
+#define ST_DEFENDER						1
+#define ST_ATTACKER						2
+#define ST_ROAMER						4
+
+
+//word replacement variables
+#define THE_ENEMY						7
+#define THE_TEAM						7
+//team message variables
+#define NETNAME							0
+#define PLACE							1
+#define FLAG							1
+#define MESSAGE							2
+#define ADDRESSEE						2
+#define ITEM							3
+#define TEAMMATE						4
+#define TEAMNAME						4
+#define ENEMY							4
+#define KEYAREA							5
+#define FORMATION						5
+#define POSITION						5
+#define NUMBER							5
+#define TIME							6
+#define NAME							6
+#define MORE							6
+
+
diff --git a/codemp/game/mssccprj.scc b/codemp/game/mssccprj.scc
new file mode 100644
index 0000000..da4c818
--- /dev/null
+++ b/codemp/game/mssccprj.scc
@@ -0,0 +1,5 @@
+SCC = This is a Source Code Control file
+
+[JK2_game.vcproj]
+SCC_Aux_Path = "\\ravendata1\vss\central_code"
+SCC_Project_Name = "$/jedi/codemp/game", EGAAAAAA
diff --git a/codemp/game/npc_headers.h b/codemp/game/npc_headers.h
new file mode 100644
index 0000000..0ad76eb
--- /dev/null
+++ b/codemp/game/npc_headers.h
@@ -0,0 +1,7 @@
+// PCH header file organiser for  NPC_xxxx cpp files' most commonly used headers
+
+#include "b_local.h"
+#include "anims.h"
+#include "g_functions.h"
+#include "g_nav.h"
+#include "g_navigator.h"
diff --git a/codemp/game/q_math.c b/codemp/game/q_math.c
new file mode 100644
index 0000000..aab7f34
--- /dev/null
+++ b/codemp/game/q_math.c
@@ -0,0 +1,1663 @@
+// Copyright (C) 1999-2000 Id Software, Inc.
+//
+// q_math.c -- stateless support routines that are included in each code module
+#include "q_shared.h"
+
+
+vec3_t	vec3_origin = {0,0,0};
+vec3_t	axisDefault[3] = { { 1, 0, 0 }, { 0, 1, 0 }, { 0, 0, 1 } };
+
+
+vec4_t		colorBlack	= {0, 0, 0, 1};
+vec4_t		colorRed	= {1, 0, 0, 1};
+vec4_t		colorGreen	= {0, 1, 0, 1};
+vec4_t		colorBlue	= {0, 0, 1, 1};
+vec4_t		colorYellow	= {1, 1, 0, 1};
+vec4_t		colorMagenta= {1, 0, 1, 1};
+vec4_t		colorCyan	= {0, 1, 1, 1};
+vec4_t		colorWhite	= {1, 1, 1, 1};
+vec4_t		colorLtGrey	= {0.75, 0.75, 0.75, 1};
+vec4_t		colorMdGrey	= {0.5, 0.5, 0.5, 1};
+vec4_t		colorDkGrey	= {0.25, 0.25, 0.25, 1};
+
+vec4_t		colorLtBlue	= {0.367f, 0.261f, 0.722f, 1};
+vec4_t		colorDkBlue	= {0.199f, 0.0f,   0.398f, 1};
+
+vec4_t	g_color_table[8] =
+	{
+	{0.0, 0.0, 0.0, 1.0},
+	{1.0, 0.0, 0.0, 1.0},
+	{0.0, 1.0, 0.0, 1.0},
+	{1.0, 1.0, 0.0, 1.0},
+	{0.0, 0.0, 1.0, 1.0},
+	{0.0, 1.0, 1.0, 1.0},
+	{1.0, 0.0, 1.0, 1.0},
+	{1.0, 1.0, 1.0, 1.0},
+	};
+
+
+vec3_t	bytedirs[NUMVERTEXNORMALS] =
+{
+{-0.525731f, 0.000000f, 0.850651f}, {-0.442863f, 0.238856f, 0.864188f}, 
+{-0.295242f, 0.000000f, 0.955423f}, {-0.309017f, 0.500000f, 0.809017f}, 
+{-0.162460f, 0.262866f, 0.951056f}, {0.000000f, 0.000000f, 1.000000f}, 
+{0.000000f, 0.850651f, 0.525731f}, {-0.147621f, 0.716567f, 0.681718f}, 
+{0.147621f, 0.716567f, 0.681718f}, {0.000000f, 0.525731f, 0.850651f}, 
+{0.309017f, 0.500000f, 0.809017f}, {0.525731f, 0.000000f, 0.850651f}, 
+{0.295242f, 0.000000f, 0.955423f}, {0.442863f, 0.238856f, 0.864188f}, 
+{0.162460f, 0.262866f, 0.951056f}, {-0.681718f, 0.147621f, 0.716567f}, 
+{-0.809017f, 0.309017f, 0.500000f},{-0.587785f, 0.425325f, 0.688191f}, 
+{-0.850651f, 0.525731f, 0.000000f},{-0.864188f, 0.442863f, 0.238856f}, 
+{-0.716567f, 0.681718f, 0.147621f},{-0.688191f, 0.587785f, 0.425325f}, 
+{-0.500000f, 0.809017f, 0.309017f}, {-0.238856f, 0.864188f, 0.442863f}, 
+{-0.425325f, 0.688191f, 0.587785f}, {-0.716567f, 0.681718f, -0.147621f}, 
+{-0.500000f, 0.809017f, -0.309017f}, {-0.525731f, 0.850651f, 0.000000f}, 
+{0.000000f, 0.850651f, -0.525731f}, {-0.238856f, 0.864188f, -0.442863f}, 
+{0.000000f, 0.955423f, -0.295242f}, {-0.262866f, 0.951056f, -0.162460f}, 
+{0.000000f, 1.000000f, 0.000000f}, {0.000000f, 0.955423f, 0.295242f}, 
+{-0.262866f, 0.951056f, 0.162460f}, {0.238856f, 0.864188f, 0.442863f}, 
+{0.262866f, 0.951056f, 0.162460f}, {0.500000f, 0.809017f, 0.309017f}, 
+{0.238856f, 0.864188f, -0.442863f},{0.262866f, 0.951056f, -0.162460f}, 
+{0.500000f, 0.809017f, -0.309017f},{0.850651f, 0.525731f, 0.000000f}, 
+{0.716567f, 0.681718f, 0.147621f}, {0.716567f, 0.681718f, -0.147621f}, 
+{0.525731f, 0.850651f, 0.000000f}, {0.425325f, 0.688191f, 0.587785f}, 
+{0.864188f, 0.442863f, 0.238856f}, {0.688191f, 0.587785f, 0.425325f}, 
+{0.809017f, 0.309017f, 0.500000f}, {0.681718f, 0.147621f, 0.716567f}, 
+{0.587785f, 0.425325f, 0.688191f}, {0.955423f, 0.295242f, 0.000000f}, 
+{1.000000f, 0.000000f, 0.000000f}, {0.951056f, 0.162460f, 0.262866f}, 
+{0.850651f, -0.525731f, 0.000000f},{0.955423f, -0.295242f, 0.000000f}, 
+{0.864188f, -0.442863f, 0.238856f}, {0.951056f, -0.162460f, 0.262866f}, 
+{0.809017f, -0.309017f, 0.500000f}, {0.681718f, -0.147621f, 0.716567f}, 
+{0.850651f, 0.000000f, 0.525731f}, {0.864188f, 0.442863f, -0.238856f}, 
+{0.809017f, 0.309017f, -0.500000f}, {0.951056f, 0.162460f, -0.262866f}, 
+{0.525731f, 0.000000f, -0.850651f}, {0.681718f, 0.147621f, -0.716567f}, 
+{0.681718f, -0.147621f, -0.716567f},{0.850651f, 0.000000f, -0.525731f}, 
+{0.809017f, -0.309017f, -0.500000f}, {0.864188f, -0.442863f, -0.238856f}, 
+{0.951056f, -0.162460f, -0.262866f}, {0.147621f, 0.716567f, -0.681718f}, 
+{0.309017f, 0.500000f, -0.809017f}, {0.425325f, 0.688191f, -0.587785f}, 
+{0.442863f, 0.238856f, -0.864188f}, {0.587785f, 0.425325f, -0.688191f}, 
+{0.688191f, 0.587785f, -0.425325f}, {-0.147621f, 0.716567f, -0.681718f}, 
+{-0.309017f, 0.500000f, -0.809017f}, {0.000000f, 0.525731f, -0.850651f}, 
+{-0.525731f, 0.000000f, -0.850651f}, {-0.442863f, 0.238856f, -0.864188f}, 
+{-0.295242f, 0.000000f, -0.955423f}, {-0.162460f, 0.262866f, -0.951056f}, 
+{0.000000f, 0.000000f, -1.000000f}, {0.295242f, 0.000000f, -0.955423f}, 
+{0.162460f, 0.262866f, -0.951056f}, {-0.442863f, -0.238856f, -0.864188f}, 
+{-0.309017f, -0.500000f, -0.809017f}, {-0.162460f, -0.262866f, -0.951056f}, 
+{0.000000f, -0.850651f, -0.525731f}, {-0.147621f, -0.716567f, -0.681718f}, 
+{0.147621f, -0.716567f, -0.681718f}, {0.000000f, -0.525731f, -0.850651f}, 
+{0.309017f, -0.500000f, -0.809017f}, {0.442863f, -0.238856f, -0.864188f}, 
+{0.162460f, -0.262866f, -0.951056f}, {0.238856f, -0.864188f, -0.442863f}, 
+{0.500000f, -0.809017f, -0.309017f}, {0.425325f, -0.688191f, -0.587785f}, 
+{0.716567f, -0.681718f, -0.147621f}, {0.688191f, -0.587785f, -0.425325f}, 
+{0.587785f, -0.425325f, -0.688191f}, {0.000000f, -0.955423f, -0.295242f}, 
+{0.000000f, -1.000000f, 0.000000f}, {0.262866f, -0.951056f, -0.162460f}, 
+{0.000000f, -0.850651f, 0.525731f}, {0.000000f, -0.955423f, 0.295242f}, 
+{0.238856f, -0.864188f, 0.442863f}, {0.262866f, -0.951056f, 0.162460f}, 
+{0.500000f, -0.809017f, 0.309017f}, {0.716567f, -0.681718f, 0.147621f}, 
+{0.525731f, -0.850651f, 0.000000f}, {-0.238856f, -0.864188f, -0.442863f}, 
+{-0.500000f, -0.809017f, -0.309017f}, {-0.262866f, -0.951056f, -0.162460f}, 
+{-0.850651f, -0.525731f, 0.000000f}, {-0.716567f, -0.681718f, -0.147621f}, 
+{-0.716567f, -0.681718f, 0.147621f}, {-0.525731f, -0.850651f, 0.000000f}, 
+{-0.500000f, -0.809017f, 0.309017f}, {-0.238856f, -0.864188f, 0.442863f}, 
+{-0.262866f, -0.951056f, 0.162460f}, {-0.864188f, -0.442863f, 0.238856f}, 
+{-0.809017f, -0.309017f, 0.500000f}, {-0.688191f, -0.587785f, 0.425325f}, 
+{-0.681718f, -0.147621f, 0.716567f}, {-0.442863f, -0.238856f, 0.864188f}, 
+{-0.587785f, -0.425325f, 0.688191f}, {-0.309017f, -0.500000f, 0.809017f}, 
+{-0.147621f, -0.716567f, 0.681718f}, {-0.425325f, -0.688191f, 0.587785f}, 
+{-0.162460f, -0.262866f, 0.951056f}, {0.442863f, -0.238856f, 0.864188f}, 
+{0.162460f, -0.262866f, 0.951056f}, {0.309017f, -0.500000f, 0.809017f}, 
+{0.147621f, -0.716567f, 0.681718f}, {0.000000f, -0.525731f, 0.850651f}, 
+{0.425325f, -0.688191f, 0.587785f}, {0.587785f, -0.425325f, 0.688191f}, 
+{0.688191f, -0.587785f, 0.425325f}, {-0.955423f, 0.295242f, 0.000000f}, 
+{-0.951056f, 0.162460f, 0.262866f}, {-1.000000f, 0.000000f, 0.000000f}, 
+{-0.850651f, 0.000000f, 0.525731f}, {-0.955423f, -0.295242f, 0.000000f}, 
+{-0.951056f, -0.162460f, 0.262866f}, {-0.864188f, 0.442863f, -0.238856f}, 
+{-0.951056f, 0.162460f, -0.262866f}, {-0.809017f, 0.309017f, -0.500000f}, 
+{-0.864188f, -0.442863f, -0.238856f}, {-0.951056f, -0.162460f, -0.262866f}, 
+{-0.809017f, -0.309017f, -0.500000f}, {-0.681718f, 0.147621f, -0.716567f}, 
+{-0.681718f, -0.147621f, -0.716567f}, {-0.850651f, 0.000000f, -0.525731f}, 
+{-0.688191f, 0.587785f, -0.425325f}, {-0.587785f, 0.425325f, -0.688191f}, 
+{-0.425325f, 0.688191f, -0.587785f}, {-0.425325f, -0.688191f, -0.587785f}, 
+{-0.587785f, -0.425325f, -0.688191f}, {-0.688191f, -0.587785f, -0.425325f}
+};
+
+//==============================================================
+
+int		Q_rand( int *seed ) {
+	*seed = (69069 * *seed + 1);
+	return *seed;
+}
+
+float	Q_random( int *seed ) {
+	return ( Q_rand( seed ) & 0xffff ) / (float)0x10000;
+}
+
+float	Q_crandom( int *seed ) {
+	return 2.0 * ( Q_random( seed ) - 0.5 );
+}
+
+#ifdef __LCC__
+
+int VectorCompare( const vec3_t v1, const vec3_t v2 ) {
+	if (v1[0] != v2[0] || v1[1] != v2[1] || v1[2] != v2[2]) {
+		return 0;
+	}			
+	return 1;
+}
+
+vec_t VectorLength( const vec3_t v ) {
+	return (vec_t)sqrt (v[0]*v[0] + v[1]*v[1] + v[2]*v[2]);
+}
+
+vec_t VectorLengthSquared( const vec3_t v ) {
+	return (v[0]*v[0] + v[1]*v[1] + v[2]*v[2]);
+}
+
+vec_t Distance( const vec3_t p1, const vec3_t p2 ) {
+	vec3_t	v;
+
+	VectorSubtract (p2, p1, v);
+	return VectorLength( v );
+}
+
+vec_t DistanceSquared( const vec3_t p1, const vec3_t p2 ) {
+	vec3_t	v;
+
+	VectorSubtract (p2, p1, v);
+	return v[0]*v[0] + v[1]*v[1] + v[2]*v[2];
+}
+
+// fast vector normalize routine that does not check to make sure
+// that length != 0, nor does it return length, uses rsqrt approximation
+void VectorNormalizeFast( vec3_t v )
+{
+	float ilength;
+
+	ilength = Q_rsqrt( DotProduct( v, v ) );
+
+	v[0] *= ilength;
+	v[1] *= ilength;
+	v[2] *= ilength;
+}
+
+void VectorInverse( vec3_t v ){
+	v[0] = -v[0];
+	v[1] = -v[1];
+	v[2] = -v[2];
+}
+
+//i wrote this function in a console test app and it appeared faster
+//in debug and release than the standard crossproduct asm generated
+//by the compiler. however, when inlining the crossproduct function
+//the compiler performs further optimizations and generally ends up
+//being faster than this asm version. but feel free to try this one
+//and see if you're heavily crossproducting in an area and looking
+//for a way to optimize. -rww
+#if 0
+void CrossProductA (float *v1, float *v2, float *cross)
+{
+#if 1
+	static float scratch1, scratch2, scratch3, scratch4, scratch5, scratch6;
+
+	__asm mov   eax,v1
+	__asm mov   ecx,v2
+	__asm mov   edx,cross
+
+	__asm fld   dword ptr[eax+4]
+	__asm fmul  dword ptr[ecx+8]
+	__asm fstp  scratch1
+
+	__asm fld   dword ptr[eax+8]
+	__asm fmul  dword ptr[ecx+4]
+	__asm fstp  scratch2
+
+	__asm fld   dword ptr[eax+8]
+	__asm fmul  dword ptr[ecx]
+	__asm fstp  scratch3
+
+	__asm fld   dword ptr[eax]
+	__asm fmul  dword ptr[ecx+8]
+	__asm fstp  scratch4
+
+	__asm fld   dword ptr[eax]
+	__asm fmul  dword ptr[ecx+4]
+	__asm fstp  scratch5
+
+	__asm fld   dword ptr[eax+4]
+	__asm fmul  dword ptr[ecx]
+	__asm fstp  scratch6
+
+	__asm fld   scratch1
+	__asm fsub  scratch2
+	__asm fstp  dword ptr[edx]
+
+	__asm fld   scratch3
+	__asm fsub  scratch4
+	__asm fstp  dword ptr[edx+4]
+
+	__asm fld   scratch5
+	__asm fsub  scratch6
+	__asm fstp  dword ptr[edx+8]
+#else //doesn't require use of statics, but not nearly as fast.
+	__asm mov   eax,v1
+	__asm mov   ecx,v2
+	__asm mov   edx,cross
+
+	__asm fld   dword ptr[eax+4]
+	__asm fmul  dword ptr[ecx+8]
+	__asm fld   dword ptr[eax+8]
+	__asm fmul  dword ptr[ecx+4]
+	__asm fsubp st(1),st
+	__asm fstp  dword ptr[edx]
+
+	__asm fld   dword ptr[eax+8]
+	__asm fmul  dword ptr[ecx]
+	__asm fld   dword ptr[eax]
+	__asm fmul  dword ptr[ecx+8]
+	__asm fsubp st(1),st
+	__asm fstp  dword ptr[edx+4]
+
+	__asm fld   dword ptr[eax]
+	__asm fmul  dword ptr[ecx+4]
+	__asm fld   dword ptr[eax+4]
+	__asm fmul  dword ptr[ecx]
+	__asm fsubp st(1),st
+	__asm fstp  dword ptr[edx+8]
+#endif
+}
+#endif
+
+void CrossProduct( const vec3_t v1, const vec3_t v2, vec3_t cross ) {
+	cross[0] = v1[1]*v2[2] - v1[2]*v2[1];
+	cross[1] = v1[2]*v2[0] - v1[0]*v2[2];
+	cross[2] = v1[0]*v2[1] - v1[1]*v2[0];
+}
+#endif
+
+//=======================================================
+
+signed char ClampChar( int i ) {
+	if ( i < -128 ) {
+		return -128;
+	}
+	if ( i > 127 ) {
+		return 127;
+	}
+	return i;
+}
+
+signed short ClampShort( int i ) {
+	if ( i < -32768 ) {
+		return -32768;
+	}
+	if ( i > 0x7fff ) {
+		return 0x7fff;
+	}
+	return i;
+}
+
+
+// this isn't a real cheap function to call!
+int DirToByte( vec3_t dir ) {
+	int		i, best;
+	float	d, bestd;
+
+	if ( !dir ) {
+		return 0;
+	}
+
+	bestd = 0;
+	best = 0;
+	for (i=0 ; i<NUMVERTEXNORMALS ; i++)
+	{
+		d = DotProduct (dir, bytedirs[i]);
+		if (d > bestd)
+		{
+			bestd = d;
+			best = i;
+		}
+	}
+
+	return best;
+}
+
+void ByteToDir( int b, vec3_t dir ) {
+	if ( b < 0 || b >= NUMVERTEXNORMALS ) {
+		VectorCopy( vec3_origin, dir );
+		return;
+	}
+	VectorCopy (bytedirs[b], dir);
+}
+
+
+unsigned ColorBytes3 (float r, float g, float b) {
+	unsigned	i;
+
+	( (byte *)&i )[0] = r * 255;
+	( (byte *)&i )[1] = g * 255;
+	( (byte *)&i )[2] = b * 255;
+
+	return i;
+}
+
+unsigned ColorBytes4 (float r, float g, float b, float a) {
+	unsigned	i;
+
+	( (byte *)&i )[0] = r * 255;
+	( (byte *)&i )[1] = g * 255;
+	( (byte *)&i )[2] = b * 255;
+	( (byte *)&i )[3] = a * 255;
+
+	return i;
+}
+
+float NormalizeColor( const vec3_t in, vec3_t out ) {
+	float	max;
+	
+	max = in[0];
+	if ( in[1] > max ) {
+		max = in[1];
+	}
+	if ( in[2] > max ) {
+		max = in[2];
+	}
+
+	if ( !max ) {
+		VectorClear( out );
+	} else {
+		out[0] = in[0] / max;
+		out[1] = in[1] / max;
+		out[2] = in[2] / max;
+	}
+	return max;
+}
+
+
+/*
+=====================
+PlaneFromPoints
+
+Returns false if the triangle is degenrate.
+The normal will point out of the clock for clockwise ordered points
+=====================
+*/
+qboolean PlaneFromPoints( vec4_t plane, const vec3_t a, const vec3_t b, const vec3_t c ) {
+	vec3_t	d1, d2;
+
+	VectorSubtract( b, a, d1 );
+	VectorSubtract( c, a, d2 );
+	CrossProduct( d2, d1, plane );
+	if ( VectorNormalize( plane ) == 0 ) {
+		return qfalse;
+	}
+
+	plane[3] = DotProduct( a, plane );
+	return qtrue;
+}
+
+/*
+===============
+RotatePointAroundVector
+
+This is not implemented very well...
+===============
+*/
+void RotatePointAroundVector( vec3_t dst, const vec3_t dir, const vec3_t point,
+							 float degrees ) {
+	float	m[3][3];
+	float	im[3][3];
+	float	zrot[3][3];
+	float	tmpmat[3][3];
+	float	rot[3][3];
+	int	i;
+	vec3_t vr, vup, vf;
+	float	rad;
+
+	vf[0] = dir[0];
+	vf[1] = dir[1];
+	vf[2] = dir[2];
+
+	PerpendicularVector( vr, dir );
+	CrossProduct( vr, vf, vup );
+
+	m[0][0] = vr[0];
+	m[1][0] = vr[1];
+	m[2][0] = vr[2];
+
+	m[0][1] = vup[0];
+	m[1][1] = vup[1];
+	m[2][1] = vup[2];
+
+	m[0][2] = vf[0];
+	m[1][2] = vf[1];
+	m[2][2] = vf[2];
+
+	memcpy( im, m, sizeof( im ) );
+
+	im[0][1] = m[1][0];
+	im[0][2] = m[2][0];
+	im[1][0] = m[0][1];
+	im[1][2] = m[2][1];
+	im[2][0] = m[0][2];
+	im[2][1] = m[1][2];
+
+	memset( zrot, 0, sizeof( zrot ) );
+	zrot[0][0] = zrot[1][1] = zrot[2][2] = 1.0F;
+
+	rad = DEG2RAD( degrees );
+	zrot[0][0] = cos( rad );
+	zrot[0][1] = sin( rad );
+	zrot[1][0] = -sin( rad );
+	zrot[1][1] = cos( rad );
+
+	MatrixMultiply( m, zrot, tmpmat );
+	MatrixMultiply( tmpmat, im, rot );
+
+	for ( i = 0; i < 3; i++ ) {
+		dst[i] = rot[i][0] * point[0] + rot[i][1] * point[1] + rot[i][2] * point[2];
+	}
+}
+
+/*
+===============
+RotateAroundDirection
+===============
+*/
+void RotateAroundDirection( vec3_t axis[3], float yaw ) {
+
+	// create an arbitrary axis[1] 
+	PerpendicularVector( axis[1], axis[0] );
+
+	// rotate it around axis[0] by yaw
+	if ( yaw ) {
+		vec3_t	temp;
+
+		VectorCopy( axis[1], temp );
+		RotatePointAroundVector( axis[1], axis[0], temp, yaw );
+	}
+
+	// cross to get axis[2]
+	CrossProduct( axis[0], axis[1], axis[2] );
+}
+
+
+
+void vectoangles( const vec3_t value1, vec3_t angles ) {
+	float	forward;
+	float	yaw, pitch;
+	
+	if ( value1[1] == 0 && value1[0] == 0 ) {
+		yaw = 0;
+		if ( value1[2] > 0 ) {
+			pitch = 90;
+		}
+		else {
+			pitch = 270;
+		}
+	}
+	else {
+		if ( value1[0] ) {
+			yaw = ( atan2 ( value1[1], value1[0] ) * 180 / M_PI );
+		}
+		else if ( value1[1] > 0 ) {
+			yaw = 90;
+		}
+		else {
+			yaw = 270;
+		}
+		if ( yaw < 0 ) {
+			yaw += 360;
+		}
+
+		forward = sqrt ( value1[0]*value1[0] + value1[1]*value1[1] );
+		pitch = ( atan2(value1[2], forward) * 180 / M_PI );
+		if ( pitch < 0 ) {
+			pitch += 360;
+		}
+	}
+
+	angles[PITCH] = -pitch;
+	angles[YAW] = yaw;
+	angles[ROLL] = 0;
+}
+
+
+/*
+=================
+AnglesToAxis
+=================
+*/
+void AnglesToAxis( const vec3_t angles, vec3_t axis[3] ) {
+	vec3_t	right;
+
+	// angle vectors returns "right" instead of "y axis"
+	AngleVectors( angles, axis[0], right, axis[2] );
+	VectorSubtract( vec3_origin, right, axis[1] );
+}
+
+void AxisClear( vec3_t axis[3] ) {
+	axis[0][0] = 1;
+	axis[0][1] = 0;
+	axis[0][2] = 0;
+	axis[1][0] = 0;
+	axis[1][1] = 1;
+	axis[1][2] = 0;
+	axis[2][0] = 0;
+	axis[2][1] = 0;
+	axis[2][2] = 1;
+}
+
+void AxisCopy( vec3_t in[3], vec3_t out[3] ) {
+	VectorCopy( in[0], out[0] );
+	VectorCopy( in[1], out[1] );
+	VectorCopy( in[2], out[2] );
+}
+
+void ProjectPointOnPlane( vec3_t dst, const vec3_t p, const vec3_t normal )
+{
+	float d;
+	vec3_t n;
+	float inv_denom;
+
+	inv_denom =  DotProduct( normal, normal );
+#ifndef Q3_VM
+	assert( Q_fabs(inv_denom) != 0.0f ); // bk010122 - zero vectors get here
+#endif
+	inv_denom = 1.0f / inv_denom;
+
+	d = DotProduct( normal, p ) * inv_denom;
+
+	n[0] = normal[0] * inv_denom;
+	n[1] = normal[1] * inv_denom;
+	n[2] = normal[2] * inv_denom;
+
+	dst[0] = p[0] - d * n[0];
+	dst[1] = p[1] - d * n[1];
+	dst[2] = p[2] - d * n[2];
+}
+
+/*
+================
+MakeNormalVectors
+
+Given a normalized forward vector, create two
+other perpendicular vectors
+================
+*/
+void MakeNormalVectors( const vec3_t forward, vec3_t right, vec3_t up) {
+	float		d;
+
+	// this rotate and negate guarantees a vector
+	// not colinear with the original
+	right[1] = -forward[0];
+	right[2] = forward[1];
+	right[0] = forward[2];
+
+	d = DotProduct (right, forward);
+	VectorMA (right, -d, forward, right);
+	VectorNormalize (right);
+	CrossProduct (right, forward, up);
+}
+
+
+void VectorRotate( vec3_t in, vec3_t matrix[3], vec3_t out )
+{
+	out[0] = DotProduct( in, matrix[0] );
+	out[1] = DotProduct( in, matrix[1] );
+	out[2] = DotProduct( in, matrix[2] );
+}
+
+//============================================================================
+
+#if !idppc
+/*
+** float q_rsqrt( float number )
+*/
+float Q_rsqrt( float number )
+{
+	long i;
+	float x2, y;
+	const float threehalfs = 1.5F;
+
+	x2 = number * 0.5F;
+	y  = number;
+	i  = * ( long * ) &y;						// evil floating point bit level hacking
+	i  = 0x5f3759df - ( i >> 1 );               // what the fuck?
+	y  = * ( float * ) &i;
+	y  = y * ( threehalfs - ( x2 * y * y ) );   // 1st iteration
+//	y  = y * ( threehalfs - ( x2 * y * y ) );   // 2nd iteration, this can be removed
+
+#ifndef Q3_VM
+#ifdef __linux__
+	assert( !isnan(y) ); // bk010122 - FPE?
+#endif
+#endif
+	return y;
+}
+
+float Q_fabs( float f ) {
+	int tmp = * ( int * ) &f;
+	tmp &= 0x7FFFFFFF;
+	return * ( float * ) &tmp;
+}
+#endif
+
+//============================================================
+
+/*
+===============
+LerpAngle
+
+===============
+*/
+float LerpAngle (float from, float to, float frac) {
+	float	a;
+
+	if ( to - from > 180 ) {
+		to -= 360;
+	}
+	if ( to - from < -180 ) {
+		to += 360;
+	}
+	a = from + frac * (to - from);
+
+	return a;
+}
+
+
+/*
+=================
+AngleSubtract
+
+Always returns a value from -180 to 180
+=================
+*/
+float	AngleSubtract( float a1, float a2 ) {
+	float	a;
+
+	a = a1 - a2;
+	a=fmod(a,360);//chop it down quickly, then level it out
+	while ( a > 180 ) {
+		a -= 360;
+	}
+	while ( a < -180 ) {
+		a += 360;
+	}
+	return a;
+}
+
+
+void AnglesSubtract( vec3_t v1, vec3_t v2, vec3_t v3 ) {
+	v3[0] = AngleSubtract( v1[0], v2[0] );
+	v3[1] = AngleSubtract( v1[1], v2[1] );
+	v3[2] = AngleSubtract( v1[2], v2[2] );
+}
+
+
+float	AngleMod(float a) {
+	a = (360.0/65536) * ((int)(a*(65536/360.0)) & 65535);
+	return a;
+}
+
+
+/*
+=================
+AngleNormalize360
+
+returns angle normalized to the range [0 <= angle < 360]
+=================
+*/
+float AngleNormalize360 ( float angle ) {
+	return (360.0 / 65536) * ((int)(angle * (65536 / 360.0)) & 65535);
+}
+
+
+/*
+=================
+AngleNormalize180
+
+returns angle normalized to the range [-180 < angle <= 180]
+=================
+*/
+float AngleNormalize180 ( float angle ) {
+	angle = AngleNormalize360( angle );
+	if ( angle > 180.0 ) {
+		angle -= 360.0;
+	}
+	return angle;
+}
+
+
+/*
+=================
+AngleDelta
+
+returns the normalized delta from angle1 to angle2
+=================
+*/
+float AngleDelta ( float angle1, float angle2 ) {
+	return AngleNormalize180( angle1 - angle2 );
+}
+
+
+//============================================================
+
+
+/*
+=================
+SetPlaneSignbits
+=================
+*/
+void SetPlaneSignbits (cplane_t *out) {
+	int	bits, j;
+
+	// for fast box on planeside test
+	bits = 0;
+	for (j=0 ; j<3 ; j++) {
+		if (out->normal[j] < 0) {
+			bits |= 1<<j;
+		}
+	}
+	out->signbits = bits;
+}
+
+
+/*
+==================
+BoxOnPlaneSide
+
+Returns 1, 2, or 1 + 2
+
+// this is the slow, general version
+int BoxOnPlaneSide2 (vec3_t emins, vec3_t emaxs, struct cplane_s *p)
+{
+	int		i;
+	float	dist1, dist2;
+	int		sides;
+	vec3_t	corners[2];
+
+	for (i=0 ; i<3 ; i++)
+	{
+		if (p->normal[i] < 0)
+		{
+			corners[0][i] = emins[i];
+			corners[1][i] = emaxs[i];
+		}
+		else
+		{
+			corners[1][i] = emins[i];
+			corners[0][i] = emaxs[i];
+		}
+	}
+	dist1 = DotProduct (p->normal, corners[0]) - p->dist;
+	dist2 = DotProduct (p->normal, corners[1]) - p->dist;
+	sides = 0;
+	if (dist1 >= 0)
+		sides = 1;
+	if (dist2 < 0)
+		sides |= 2;
+
+	return sides;
+}
+
+==================
+*/
+#if !( (defined __linux__ || __FreeBSD__) && (defined __i386__) && (!defined C_ONLY)) // rb010123
+
+#if defined __LCC__ || defined C_ONLY || !id386
+
+int BoxOnPlaneSide (vec3_t emins, vec3_t emaxs, struct cplane_s *p)
+{
+	float	dist1, dist2;
+	int		sides;
+
+// fast axial cases
+	if (p->type < 3)
+	{
+		if (p->dist <= emins[p->type])
+			return 1;
+		if (p->dist >= emaxs[p->type])
+			return 2;
+		return 3;
+	}
+
+// general case
+	switch (p->signbits)
+	{
+	case 0:
+		dist1 = p->normal[0]*emaxs[0] + p->normal[1]*emaxs[1] + p->normal[2]*emaxs[2];
+		dist2 = p->normal[0]*emins[0] + p->normal[1]*emins[1] + p->normal[2]*emins[2];
+		break;
+	case 1:
+		dist1 = p->normal[0]*emins[0] + p->normal[1]*emaxs[1] + p->normal[2]*emaxs[2];
+		dist2 = p->normal[0]*emaxs[0] + p->normal[1]*emins[1] + p->normal[2]*emins[2];
+		break;
+	case 2:
+		dist1 = p->normal[0]*emaxs[0] + p->normal[1]*emins[1] + p->normal[2]*emaxs[2];
+		dist2 = p->normal[0]*emins[0] + p->normal[1]*emaxs[1] + p->normal[2]*emins[2];
+		break;
+	case 3:
+		dist1 = p->normal[0]*emins[0] + p->normal[1]*emins[1] + p->normal[2]*emaxs[2];
+		dist2 = p->normal[0]*emaxs[0] + p->normal[1]*emaxs[1] + p->normal[2]*emins[2];
+		break;
+	case 4:
+		dist1 = p->normal[0]*emaxs[0] + p->normal[1]*emaxs[1] + p->normal[2]*emins[2];
+		dist2 = p->normal[0]*emins[0] + p->normal[1]*emins[1] + p->normal[2]*emaxs[2];
+		break;
+	case 5:
+		dist1 = p->normal[0]*emins[0] + p->normal[1]*emaxs[1] + p->normal[2]*emins[2];
+		dist2 = p->normal[0]*emaxs[0] + p->normal[1]*emins[1] + p->normal[2]*emaxs[2];
+		break;
+	case 6:
+		dist1 = p->normal[0]*emaxs[0] + p->normal[1]*emins[1] + p->normal[2]*emins[2];
+		dist2 = p->normal[0]*emins[0] + p->normal[1]*emaxs[1] + p->normal[2]*emaxs[2];
+		break;
+	case 7:
+		dist1 = p->normal[0]*emins[0] + p->normal[1]*emins[1] + p->normal[2]*emins[2];
+		dist2 = p->normal[0]*emaxs[0] + p->normal[1]*emaxs[1] + p->normal[2]*emaxs[2];
+		break;
+	default:
+		dist1 = dist2 = 0;		// shut up compiler
+		break;
+	}
+
+	sides = 0;
+	if (dist1 >= p->dist)
+		sides = 1;
+	if (dist2 < p->dist)
+		sides |= 2;
+
+	return sides;
+}
+#else
+#pragma warning( disable: 4035 )
+
+__declspec( naked ) int BoxOnPlaneSide (vec3_t emins, vec3_t emaxs, struct cplane_s *p)
+{
+	static int bops_initialized;
+	static int Ljmptab[8];
+
+	__asm {
+
+		push ebx
+			
+		cmp bops_initialized, 1
+		je  initialized
+		mov bops_initialized, 1
+		
+		mov Ljmptab[0*4], offset Lcase0
+		mov Ljmptab[1*4], offset Lcase1
+		mov Ljmptab[2*4], offset Lcase2
+		mov Ljmptab[3*4], offset Lcase3
+		mov Ljmptab[4*4], offset Lcase4
+		mov Ljmptab[5*4], offset Lcase5
+		mov Ljmptab[6*4], offset Lcase6
+		mov Ljmptab[7*4], offset Lcase7
+			
+initialized:
+
+		mov edx,dword ptr[4+12+esp]
+		mov ecx,dword ptr[4+4+esp]
+		xor eax,eax
+		mov ebx,dword ptr[4+8+esp]
+		mov al,byte ptr[17+edx]
+		cmp al,8
+		jge Lerror
+		fld dword ptr[0+edx]
+		fld st(0)
+		jmp dword ptr[Ljmptab+eax*4]
+Lcase0:
+		fmul dword ptr[ebx]
+		fld dword ptr[0+4+edx]
+		fxch st(2)
+		fmul dword ptr[ecx]
+		fxch st(2)
+		fld st(0)
+		fmul dword ptr[4+ebx]
+		fld dword ptr[0+8+edx]
+		fxch st(2)
+		fmul dword ptr[4+ecx]
+		fxch st(2)
+		fld st(0)
+		fmul dword ptr[8+ebx]
+		fxch st(5)
+		faddp st(3),st(0)
+		fmul dword ptr[8+ecx]
+		fxch st(1)
+		faddp st(3),st(0)
+		fxch st(3)
+		faddp st(2),st(0)
+		jmp LSetSides
+Lcase1:
+		fmul dword ptr[ecx]
+		fld dword ptr[0+4+edx]
+		fxch st(2)
+		fmul dword ptr[ebx]
+		fxch st(2)
+		fld st(0)
+		fmul dword ptr[4+ebx]
+		fld dword ptr[0+8+edx]
+		fxch st(2)
+		fmul dword ptr[4+ecx]
+		fxch st(2)
+		fld st(0)
+		fmul dword ptr[8+ebx]
+		fxch st(5)
+		faddp st(3),st(0)
+		fmul dword ptr[8+ecx]
+		fxch st(1)
+		faddp st(3),st(0)
+		fxch st(3)
+		faddp st(2),st(0)
+		jmp LSetSides
+Lcase2:
+		fmul dword ptr[ebx]
+		fld dword ptr[0+4+edx]
+		fxch st(2)
+		fmul dword ptr[ecx]
+		fxch st(2)
+		fld st(0)
+		fmul dword ptr[4+ecx]
+		fld dword ptr[0+8+edx]
+		fxch st(2)
+		fmul dword ptr[4+ebx]
+		fxch st(2)
+		fld st(0)
+		fmul dword ptr[8+ebx]
+		fxch st(5)
+		faddp st(3),st(0)
+		fmul dword ptr[8+ecx]
+		fxch st(1)
+		faddp st(3),st(0)
+		fxch st(3)
+		faddp st(2),st(0)
+		jmp LSetSides
+Lcase3:
+		fmul dword ptr[ecx]
+		fld dword ptr[0+4+edx]
+		fxch st(2)
+		fmul dword ptr[ebx]
+		fxch st(2)
+		fld st(0)
+		fmul dword ptr[4+ecx]
+		fld dword ptr[0+8+edx]
+		fxch st(2)
+		fmul dword ptr[4+ebx]
+		fxch st(2)
+		fld st(0)
+		fmul dword ptr[8+ebx]
+		fxch st(5)
+		faddp st(3),st(0)
+		fmul dword ptr[8+ecx]
+		fxch st(1)
+		faddp st(3),st(0)
+		fxch st(3)
+		faddp st(2),st(0)
+		jmp LSetSides
+Lcase4:
+		fmul dword ptr[ebx]
+		fld dword ptr[0+4+edx]
+		fxch st(2)
+		fmul dword ptr[ecx]
+		fxch st(2)
+		fld st(0)
+		fmul dword ptr[4+ebx]
+		fld dword ptr[0+8+edx]
+		fxch st(2)
+		fmul dword ptr[4+ecx]
+		fxch st(2)
+		fld st(0)
+		fmul dword ptr[8+ecx]
+		fxch st(5)
+		faddp st(3),st(0)
+		fmul dword ptr[8+ebx]
+		fxch st(1)
+		faddp st(3),st(0)
+		fxch st(3)
+		faddp st(2),st(0)
+		jmp LSetSides
+Lcase5:
+		fmul dword ptr[ecx]
+		fld dword ptr[0+4+edx]
+		fxch st(2)
+		fmul dword ptr[ebx]
+		fxch st(2)
+		fld st(0)
+		fmul dword ptr[4+ebx]
+		fld dword ptr[0+8+edx]
+		fxch st(2)
+		fmul dword ptr[4+ecx]
+		fxch st(2)
+		fld st(0)
+		fmul dword ptr[8+ecx]
+		fxch st(5)
+		faddp st(3),st(0)
+		fmul dword ptr[8+ebx]
+		fxch st(1)
+		faddp st(3),st(0)
+		fxch st(3)
+		faddp st(2),st(0)
+		jmp LSetSides
+Lcase6:
+		fmul dword ptr[ebx]
+		fld dword ptr[0+4+edx]
+		fxch st(2)
+		fmul dword ptr[ecx]
+		fxch st(2)
+		fld st(0)
+		fmul dword ptr[4+ecx]
+		fld dword ptr[0+8+edx]
+		fxch st(2)
+		fmul dword ptr[4+ebx]
+		fxch st(2)
+		fld st(0)
+		fmul dword ptr[8+ecx]
+		fxch st(5)
+		faddp st(3),st(0)
+		fmul dword ptr[8+ebx]
+		fxch st(1)
+		faddp st(3),st(0)
+		fxch st(3)
+		faddp st(2),st(0)
+		jmp LSetSides
+Lcase7:
+		fmul dword ptr[ecx]
+		fld dword ptr[0+4+edx]
+		fxch st(2)
+		fmul dword ptr[ebx]
+		fxch st(2)
+		fld st(0)
+		fmul dword ptr[4+ecx]
+		fld dword ptr[0+8+edx]
+		fxch st(2)
+		fmul dword ptr[4+ebx]
+		fxch st(2)
+		fld st(0)
+		fmul dword ptr[8+ecx]
+		fxch st(5)
+		faddp st(3),st(0)
+		fmul dword ptr[8+ebx]
+		fxch st(1)
+		faddp st(3),st(0)
+		fxch st(3)
+		faddp st(2),st(0)
+LSetSides:
+		faddp st(2),st(0)
+		fcomp dword ptr[12+edx]
+		xor ecx,ecx
+		fnstsw ax
+		fcomp dword ptr[12+edx]
+		and ah,1
+		xor ah,1
+		add cl,ah
+		fnstsw ax
+		and ah,1
+		add ah,ah
+		add cl,ah
+		pop ebx
+		mov eax,ecx
+		ret
+Lerror:
+		int 3
+	}
+}
+#pragma warning( default: 4035 )
+
+#endif
+#endif
+
+/*
+=================
+RadiusFromBounds
+=================
+*/
+float RadiusFromBounds( const vec3_t mins, const vec3_t maxs ) {
+	int		i;
+	vec3_t	corner;
+	float	a, b;
+
+	for (i=0 ; i<3 ; i++) {
+		a = fabs( mins[i] );
+		b = fabs( maxs[i] );
+		corner[i] = a > b ? a : b;
+	}
+
+	return VectorLength (corner);
+}
+
+
+void ClearBounds( vec3_t mins, vec3_t maxs ) {
+	mins[0] = mins[1] = mins[2] = 99999;
+	maxs[0] = maxs[1] = maxs[2] = -99999;
+}
+
+vec_t DistanceHorizontal( const vec3_t p1, const vec3_t p2 ) {
+	vec3_t	v;
+
+	VectorSubtract( p2, p1, v );
+	return sqrt( v[0]*v[0] + v[1]*v[1] );	//Leave off the z component
+}
+
+vec_t DistanceHorizontalSquared( const vec3_t p1, const vec3_t p2 ) {
+	vec3_t	v;
+
+	VectorSubtract( p2, p1, v );
+	return v[0]*v[0] + v[1]*v[1];	//Leave off the z component
+}
+
+void AddPointToBounds( const vec3_t v, vec3_t mins, vec3_t maxs ) {
+	if ( v[0] < mins[0] ) {
+		mins[0] = v[0];
+	}
+	if ( v[0] > maxs[0]) {
+		maxs[0] = v[0];
+	}
+
+	if ( v[1] < mins[1] ) {
+		mins[1] = v[1];
+	}
+	if ( v[1] > maxs[1]) {
+		maxs[1] = v[1];
+	}
+
+	if ( v[2] < mins[2] ) {
+		mins[2] = v[2];
+	}
+	if ( v[2] > maxs[2]) {
+		maxs[2] = v[2];
+	}
+}
+
+
+vec_t VectorNormalize( vec3_t v ) {
+	float	length, ilength;
+
+	length = v[0]*v[0] + v[1]*v[1] + v[2]*v[2];
+	length = sqrt (length);
+
+	if ( length ) {
+		ilength = 1/length;
+		v[0] *= ilength;
+		v[1] *= ilength;
+		v[2] *= ilength;
+	}
+		
+	return length;
+}
+
+vec_t VectorNormalize2( const vec3_t v, vec3_t out) {
+	float	length, ilength;
+
+	length = v[0]*v[0] + v[1]*v[1] + v[2]*v[2];
+	length = sqrt (length);
+
+	if (length)
+	{
+#ifndef Q3_VM // bk0101022 - FPE related
+//	  assert( ((Q_fabs(v[0])!=0.0f) || (Q_fabs(v[1])!=0.0f) || (Q_fabs(v[2])!=0.0f)) );
+#endif
+		ilength = 1/length;
+		out[0] = v[0]*ilength;
+		out[1] = v[1]*ilength;
+		out[2] = v[2]*ilength;
+	} else {
+#ifndef Q3_VM // bk0101022 - FPE related
+//	  assert( ((Q_fabs(v[0])==0.0f) && (Q_fabs(v[1])==0.0f) && (Q_fabs(v[2])==0.0f)) );
+#endif
+		VectorClear( out );
+	}
+		
+	return length;
+
+}
+
+void _VectorMA( const vec3_t veca, float scale, const vec3_t vecb, vec3_t vecc) {
+	vecc[0] = veca[0] + scale*vecb[0];
+	vecc[1] = veca[1] + scale*vecb[1];
+	vecc[2] = veca[2] + scale*vecb[2];
+}
+
+
+vec_t _DotProduct( const vec3_t v1, const vec3_t v2 ) {
+	return v1[0]*v2[0] + v1[1]*v2[1] + v1[2]*v2[2];
+}
+
+void _VectorSubtract( const vec3_t veca, const vec3_t vecb, vec3_t out ) {
+	out[0] = veca[0]-vecb[0];
+	out[1] = veca[1]-vecb[1];
+	out[2] = veca[2]-vecb[2];
+}
+
+void _VectorAdd( const vec3_t veca, const vec3_t vecb, vec3_t out ) {
+	out[0] = veca[0]+vecb[0];
+	out[1] = veca[1]+vecb[1];
+	out[2] = veca[2]+vecb[2];
+}
+
+void _VectorCopy( const vec3_t in, vec3_t out ) {
+	out[0] = in[0];
+	out[1] = in[1];
+	out[2] = in[2];
+}
+
+void _VectorScale( const vec3_t in, vec_t scale, vec3_t out ) {
+	out[0] = in[0]*scale;
+	out[1] = in[1]*scale;
+	out[2] = in[2]*scale;
+}
+
+void Vector4Scale( const vec4_t in, vec_t scale, vec4_t out ) {
+	out[0] = in[0]*scale;
+	out[1] = in[1]*scale;
+	out[2] = in[2]*scale;
+	out[3] = in[3]*scale;
+}
+
+
+int Q_log2( int val ) {
+	int answer;
+
+	answer = 0;
+	while ( ( val>>=1 ) != 0 ) {
+		answer++;
+	}
+	return answer;
+}
+
+
+
+/*
+=================
+PlaneTypeForNormal
+=================
+*/
+/*
+int	PlaneTypeForNormal (vec3_t normal) {
+	if ( normal[0] == 1.0 )
+		return PLANE_X;
+	if ( normal[1] == 1.0 )
+		return PLANE_Y;
+	if ( normal[2] == 1.0 )
+		return PLANE_Z;
+	
+	return PLANE_NON_AXIAL;
+}
+*/
+
+
+/*
+================
+MatrixMultiply
+================
+*/
+void MatrixMultiply(float in1[3][3], float in2[3][3], float out[3][3]) {
+	out[0][0] = in1[0][0] * in2[0][0] + in1[0][1] * in2[1][0] +
+				in1[0][2] * in2[2][0];
+	out[0][1] = in1[0][0] * in2[0][1] + in1[0][1] * in2[1][1] +
+				in1[0][2] * in2[2][1];
+	out[0][2] = in1[0][0] * in2[0][2] + in1[0][1] * in2[1][2] +
+				in1[0][2] * in2[2][2];
+	out[1][0] = in1[1][0] * in2[0][0] + in1[1][1] * in2[1][0] +
+				in1[1][2] * in2[2][0];
+	out[1][1] = in1[1][0] * in2[0][1] + in1[1][1] * in2[1][1] +
+				in1[1][2] * in2[2][1];
+	out[1][2] = in1[1][0] * in2[0][2] + in1[1][1] * in2[1][2] +
+				in1[1][2] * in2[2][2];
+	out[2][0] = in1[2][0] * in2[0][0] + in1[2][1] * in2[1][0] +
+				in1[2][2] * in2[2][0];
+	out[2][1] = in1[2][0] * in2[0][1] + in1[2][1] * in2[1][1] +
+				in1[2][2] * in2[2][1];
+	out[2][2] = in1[2][0] * in2[0][2] + in1[2][1] * in2[1][2] +
+				in1[2][2] * in2[2][2];
+}
+
+
+void AngleVectors( const vec3_t angles, vec3_t forward, vec3_t right, vec3_t up) {
+	float		angle;
+	static float		sr, sp, sy, cr, cp, cy;
+	// static to help MS compiler fp bugs
+
+	angle = angles[YAW] * (M_PI*2 / 360);
+	sy = sin(angle);
+	cy = cos(angle);
+	angle = angles[PITCH] * (M_PI*2 / 360);
+	sp = sin(angle);
+	cp = cos(angle);
+	angle = angles[ROLL] * (M_PI*2 / 360);
+	sr = sin(angle);
+	cr = cos(angle);
+
+	if (forward)
+	{
+		forward[0] = cp*cy;
+		forward[1] = cp*sy;
+		forward[2] = -sp;
+	}
+	if (right)
+	{
+		right[0] = (-1*sr*sp*cy+-1*cr*-sy);
+		right[1] = (-1*sr*sp*sy+-1*cr*cy);
+		right[2] = -1*sr*cp;
+	}
+	if (up)
+	{
+		up[0] = (cr*sp*cy+-sr*-sy);
+		up[1] = (cr*sp*sy+-sr*cy);
+		up[2] = cr*cp;
+	}
+}
+
+/*
+** assumes "src" is normalized
+*/
+void PerpendicularVector( vec3_t dst, const vec3_t src )
+{
+	int	pos;
+	int i;
+	float minelem = 1.0F;
+	vec3_t tempvec;
+
+	/*
+	** find the smallest magnitude axially aligned vector
+	*/
+	for ( pos = 0, i = 0; i < 3; i++ )
+	{
+		if ( fabs( src[i] ) < minelem )
+		{
+			pos = i;
+			minelem = fabs( src[i] );
+		}
+	}
+	tempvec[0] = tempvec[1] = tempvec[2] = 0.0F;
+	tempvec[pos] = 1.0F;
+
+	/*
+	** project the point onto the plane defined by src
+	*/
+	ProjectPointOnPlane( dst, tempvec, src );
+
+	/*
+	** normalize the result
+	*/
+	VectorNormalize( dst );
+}
+
+/*
+** NormalToLatLong
+**
+** We use two byte encoded normals in some space critical applications.
+** Lat = 0 at (1,0,0) to 360 (-1,0,0), encoded in 8-bit sine table format
+** Lng = 0 at (0,0,1) to 180 (0,0,-1), encoded in 8-bit sine table format
+**
+*/
+//rwwRMG - added
+void NormalToLatLong( const vec3_t normal, byte bytes[2] )
+{
+	// check for singularities
+	if (!normal[0] && !normal[1])
+	{
+		if ( normal[2] > 0.0f )
+		{
+			bytes[0] = 0;
+			bytes[1] = 0;		// lat = 0, long = 0
+		}
+		else
+		{
+			bytes[0] = 128;
+			bytes[1] = 0;		// lat = 0, long = 128
+		}
+	}
+	else
+	{
+		int	a, b;
+
+		a = (int)(RAD2DEG( (vec_t)atan2( normal[1], normal[0] ) ) * (255.0f / 360.0f ));
+		a &= 0xff;
+
+		b = (int)(RAD2DEG( (vec_t)acos( normal[2] ) ) * ( 255.0f / 360.0f ));
+		b &= 0xff;
+
+		bytes[0] = b;	// longitude
+		bytes[1] = a;	// lattitude
+	}
+}
+
+// This is the VC libc version of rand() without multiple seeds per thread or 12 levels
+// of subroutine calls.
+// Both calls have been designed to minimise the inherent number of float <--> int 
+// conversions and the additional math required to get the desired value.
+// eg the typical tint = (rand() * 255) / 32768
+// becomes tint = irand(0, 255)
+
+static unsigned long	holdrand = 0x89abcdef;
+
+void Rand_Init(int seed)
+{
+	holdrand = seed;
+}
+
+// Returns a float min <= x < max (exclusive; will get max - 0.00001; but never max)
+
+float flrand(float min, float max)
+{
+	float	result;
+
+	assert((max - min) < 32768);
+
+	holdrand = (holdrand * 214013L) + 2531011L;
+	result = (float)(holdrand >> 17);						// 0 - 32767 range
+	result = ((result * (max - min)) / 32768.0F) + min;
+
+	return(result);
+}
+
+// Returns an integer min <= x <= max (ie inclusive)
+
+int irand(int min, int max)
+{
+	int		result;
+
+	assert((max - min) < 32768);
+
+	max++;
+	holdrand = (holdrand * 214013L) + 2531011L;
+	result = holdrand >> 17;
+	result = ((result * (max - min)) >> 15) + min;
+	return(result);
+}
+
+float powf ( float x, int y )
+{
+	float r = x;
+	for ( y--; y>0; y-- )
+		r = r * r;
+	return r;
+}
+
+#ifdef Q3_VM 
+//rwwRMG - needed for HandleEntityAdjustment
+double fmod( double x, double y )
+{
+	int		result;
+
+	if (y == 0.0)
+	{
+		return 0.0;
+	}
+
+	result = x / y;
+
+	return x - (result * y);
+}
+
+#endif // Q3_VM
+
+/*
+-------------------------
+DotProductNormalize
+-------------------------
+*/
+
+float DotProductNormalize( const vec3_t inVec1, const vec3_t inVec2 )
+{
+	vec3_t	v1, v2;
+
+	VectorNormalize2( inVec1, v1 );
+	VectorNormalize2( inVec2, v2 );
+
+	return DotProduct(v1, v2);
+}
+
+/*
+-------------------------
+G_FindClosestPointOnLineSegment
+-------------------------
+*/
+
+qboolean G_FindClosestPointOnLineSegment( const vec3_t start, const vec3_t end, const vec3_t from, vec3_t result )
+{
+	vec3_t	vecStart2From, vecStart2End, vecEnd2Start, vecEnd2From;
+	float	distEnd2From, distEnd2Result, theta, cos_theta, dot;
+
+	//Find the perpendicular vector to vec from start to end
+	VectorSubtract( from, start, vecStart2From);
+	VectorSubtract( end, start, vecStart2End);
+
+	dot = DotProductNormalize( vecStart2From, vecStart2End );
+
+	if ( dot <= 0 )
+	{
+		//The perpendicular would be beyond or through the start point
+		VectorCopy( start, result );
+		return qfalse;
+	}
+
+	if ( dot == 1 )
+	{
+		//parallel, closer of 2 points will be the target
+		if( (VectorLengthSquared( vecStart2From )) < (VectorLengthSquared( vecStart2End )) )
+		{
+			VectorCopy( from, result );
+		}
+		else
+		{
+			VectorCopy( end, result );
+		}
+		return qfalse;
+	}
+
+	//Try other end
+	VectorSubtract( from, end, vecEnd2From);
+	VectorSubtract( start, end, vecEnd2Start);
+
+	dot = DotProductNormalize( vecEnd2From, vecEnd2Start );
+
+	if ( dot <= 0 )
+	{//The perpendicular would be beyond or through the start point
+		VectorCopy( end, result );
+		return qfalse;
+	}
+
+	if ( dot == 1 )
+	{//parallel, closer of 2 points will be the target
+		if( (VectorLengthSquared( vecEnd2From )) < (VectorLengthSquared( vecEnd2Start )))
+		{
+			VectorCopy( from, result );
+		}
+		else
+		{
+			VectorCopy( end, result );
+		}
+		return qfalse;
+	}
+
+	//		      /|
+	//		  c  / |
+	//		    /  |a
+	//	theta  /)__|    
+	//		      b
+	//cos(theta) = b / c
+	//solve for b
+	//b = cos(theta) * c
+
+	//angle between vecs end2from and end2start, should be between 0 and 90
+	theta = 90 * (1 - dot);//theta
+	
+	//Get length of side from End2Result using sine of theta
+	distEnd2From = VectorLength( vecEnd2From );//c
+	cos_theta = cos(DEG2RAD(theta));//cos(theta)
+	distEnd2Result = cos_theta * distEnd2From;//b
+
+	//Extrapolate to find result
+	VectorNormalize( vecEnd2Start );
+	VectorMA( end, distEnd2Result, vecEnd2Start, result );
+	
+	//perpendicular intersection is between the 2 endpoints
+	return qtrue;
+}
+
+float G_PointDistFromLineSegment( const vec3_t start, const vec3_t end, const vec3_t from )
+{
+	vec3_t	vecStart2From, vecStart2End, vecEnd2Start, vecEnd2From, intersection;
+	float	distEnd2From, distStart2From, distEnd2Result, theta, cos_theta, dot;
+
+	//Find the perpendicular vector to vec from start to end
+	VectorSubtract( from, start, vecStart2From);
+	VectorSubtract( end, start, vecStart2End);
+	VectorSubtract( from, end, vecEnd2From);
+	VectorSubtract( start, end, vecEnd2Start);
+
+	dot = DotProductNormalize( vecStart2From, vecStart2End );
+
+	distStart2From = Distance( start, from );
+	distEnd2From = Distance( end, from );
+
+	if ( dot <= 0 )
+	{
+		//The perpendicular would be beyond or through the start point
+		return distStart2From;
+	}
+
+	if ( dot == 1 )
+	{
+		//parallel, closer of 2 points will be the target
+		return ((distStart2From<distEnd2From)?distStart2From:distEnd2From);
+	}
+
+	//Try other end
+
+	dot = DotProductNormalize( vecEnd2From, vecEnd2Start );
+
+	if ( dot <= 0 )
+	{//The perpendicular would be beyond or through the end point
+		return distEnd2From;
+	}
+
+	if ( dot == 1 )
+	{//parallel, closer of 2 points will be the target
+		return ((distStart2From<distEnd2From)?distStart2From:distEnd2From);
+	}
+
+	//		      /|
+	//		  c  / |
+	//		    /  |a
+	//	theta  /)__|    
+	//		      b
+	//cos(theta) = b / c
+	//solve for b
+	//b = cos(theta) * c
+
+	//angle between vecs end2from and end2start, should be between 0 and 90
+	theta = 90 * (1 - dot);//theta
+	
+	//Get length of side from End2Result using sine of theta
+	cos_theta = cos(DEG2RAD(theta));//cos(theta)
+	distEnd2Result = cos_theta * distEnd2From;//b
+
+	//Extrapolate to find result
+	VectorNormalize( vecEnd2Start );
+	VectorMA( end, distEnd2Result, vecEnd2Start, intersection );
+	
+	//perpendicular intersection is between the 2 endpoints, return dist to it from from
+	return Distance( intersection, from );
+}
diff --git a/codemp/game/q_shared.c b/codemp/game/q_shared.c
new file mode 100644
index 0000000..e026398
--- /dev/null
+++ b/codemp/game/q_shared.c
@@ -0,0 +1,1378 @@
+// Copyright (C) 1999-2000 Id Software, Inc.
+//
+// q_shared.c -- stateless support routines that are included in each code dll
+#include "q_shared.h"
+
+/*
+-------------------------
+GetIDForString 
+-------------------------
+*/
+
+
+int GetIDForString ( stringID_table_t *table, const char *string )
+{
+	int	index = 0;
+
+	while ( ( table[index].name != NULL ) &&
+			( table[index].name[0] != 0 ) )
+	{
+		if ( !Q_stricmp( table[index].name, string ) )
+			return table[index].id;
+
+		index++;
+	}
+
+	return -1;
+}
+
+/*
+-------------------------
+GetStringForID
+-------------------------
+*/
+
+const char *GetStringForID( stringID_table_t *table, int id )
+{
+	int	index = 0;
+
+	while ( ( table[index].name != NULL ) &&
+			( table[index].name[0] != 0 ) )
+	{
+		if ( table[index].id == id )
+			return table[index].name;
+
+		index++;
+	}
+
+	return NULL;
+}
+
+int Com_Clampi( int min, int max, int value ) 
+{
+	if ( value < min ) 
+	{
+		return min;
+	}
+	if ( value > max ) 
+	{
+		return max;
+	}
+	return value;
+}
+
+float Com_Clamp( float min, float max, float value ) {
+	if ( value < min ) {
+		return min;
+	}
+	if ( value > max ) {
+		return max;
+	}
+	return value;
+}
+
+
+/*
+============
+COM_SkipPath
+============
+*/
+char *COM_SkipPath (char *pathname)
+{
+	char	*last;
+	
+	last = pathname;
+	while (*pathname)
+	{
+		if (*pathname=='/')
+			last = pathname+1;
+		pathname++;
+	}
+	return last;
+}
+
+/*
+============
+COM_StripExtension
+============
+*/
+void COM_StripExtension( const char *in, char *out ) {
+	while ( *in && *in != '.' ) {
+		*out++ = *in++;
+	}
+	*out = 0;
+}
+
+
+/*
+==================
+COM_DefaultExtension
+==================
+*/
+void COM_DefaultExtension (char *path, int maxSize, const char *extension ) {
+	char	oldPath[MAX_QPATH];
+	char    *src;
+
+//
+// if path doesn't have a .EXT, append extension
+// (extension should include the .)
+//
+	src = path + strlen(path) - 1;
+
+	while (*src != '/' && src != path) {
+		if ( *src == '.' ) {
+			return;                 // it has an extension
+		}
+		src--;
+	}
+
+	Q_strncpyz( oldPath, path, sizeof( oldPath ) );
+	Com_sprintf( path, maxSize, "%s%s", oldPath, extension );
+}
+
+/*
+============================================================================
+
+					BYTE ORDER FUNCTIONS
+
+============================================================================
+*/
+/*
+// can't just use function pointers, or dll linkage can
+// mess up when qcommon is included in multiple places
+static short	(*_BigShort) (short l);
+static short	(*_LittleShort) (short l);
+static int		(*_BigLong) (int l);
+static int		(*_LittleLong) (int l);
+static qint64	(*_BigLong64) (qint64 l);
+static qint64	(*_LittleLong64) (qint64 l);
+static float	(*_BigFloat) (const float *l);
+static float	(*_LittleFloat) (const float *l);
+
+short	BigShort(short l){return _BigShort(l);}
+short	LittleShort(short l) {return _LittleShort(l);}
+int		BigLong (int l) {return _BigLong(l);}
+int		LittleLong (int l) {return _LittleLong(l);}
+qint64 	BigLong64 (qint64 l) {return _BigLong64(l);}
+qint64 	LittleLong64 (qint64 l) {return _LittleLong64(l);}
+float	BigFloat (const float *l) {return _BigFloat(l);}
+float	LittleFloat (const float *l) {return _LittleFloat(l);}
+*/
+
+short   ShortSwap (short l)
+{
+	byte    b1,b2;
+
+	b1 = l&255;
+	b2 = (l>>8)&255;
+
+	return (b1<<8) + b2;
+}
+
+short	ShortNoSwap (short l)
+{
+	return l;
+}
+
+int    LongSwap (int l)
+{
+	byte    b1,b2,b3,b4;
+
+	b1 = l&255;
+	b2 = (l>>8)&255;
+	b3 = (l>>16)&255;
+	b4 = (l>>24)&255;
+
+	return ((int)b1<<24) + ((int)b2<<16) + ((int)b3<<8) + b4;
+}
+
+int	LongNoSwap (int l)
+{
+	return l;
+}
+
+qint64 Long64Swap (qint64 ll)
+{
+	qint64	result;
+
+	result.b0 = ll.b7;
+	result.b1 = ll.b6;
+	result.b2 = ll.b5;
+	result.b3 = ll.b4;
+	result.b4 = ll.b3;
+	result.b5 = ll.b2;
+	result.b6 = ll.b1;
+	result.b7 = ll.b0;
+
+	return result;
+}
+
+qint64 Long64NoSwap (qint64 ll)
+{
+	return ll;
+}
+
+typedef union {
+    float	f;
+    unsigned int i;
+} _FloatByteUnion;
+
+float FloatSwap (const float *f) {
+	const _FloatByteUnion *in;
+	_FloatByteUnion out;
+
+	in = (_FloatByteUnion *)f;
+	out.i = LongSwap(in->i);
+
+	return out.f;
+}
+
+float FloatNoSwap (const float *f)
+{
+	return *f;
+}
+
+/*
+================
+Swap_Init
+================
+*/
+/*
+void Swap_Init (void)
+{
+	byte	swaptest[2] = {1,0};
+
+// set the byte swapping variables in a portable manner	
+	if ( *(short *)swaptest == 1)
+	{
+		_BigShort = ShortSwap;
+		_LittleShort = ShortNoSwap;
+		_BigLong = LongSwap;
+		_LittleLong = LongNoSwap;
+		_BigLong64 = Long64Swap;
+		_LittleLong64 = Long64NoSwap;
+		_BigFloat = FloatSwap;
+		_LittleFloat = FloatNoSwap;
+	}
+	else
+	{
+		_BigShort = ShortNoSwap;
+		_LittleShort = ShortSwap;
+		_BigLong = LongNoSwap;
+		_LittleLong = LongSwap;
+		_BigLong64 = Long64NoSwap;
+		_LittleLong64 = Long64Swap;
+		_BigFloat = FloatNoSwap;
+		_LittleFloat = FloatSwap;
+	}
+
+}
+*/
+
+/*
+============================================================================
+
+PARSING
+
+============================================================================
+*/
+
+static	char	com_token[MAX_TOKEN_CHARS];
+static	char	com_parsename[MAX_TOKEN_CHARS];
+static	int		com_lines;
+
+void COM_BeginParseSession( const char *name )
+{
+	com_lines = 0;
+	Com_sprintf(com_parsename, sizeof(com_parsename), "%s", name);
+}
+
+int COM_GetCurrentParseLine( void )
+{
+	return com_lines;
+}
+
+char *COM_Parse( const char **data_p )
+{
+	return COM_ParseExt( data_p, qtrue );
+}
+
+void COM_ParseError( char *format, ... )
+{
+	va_list argptr;
+	static char string[4096];
+
+	va_start (argptr, format);
+	vsprintf (string, format, argptr);
+	va_end (argptr);
+
+	Com_Printf("ERROR: %s, line %d: %s\n", com_parsename, com_lines, string);
+}
+
+void COM_ParseWarning( char *format, ... )
+{
+	va_list argptr;
+	static char string[4096];
+
+	va_start (argptr, format);
+	vsprintf (string, format, argptr);
+	va_end (argptr);
+
+	Com_Printf("WARNING: %s, line %d: %s\n", com_parsename, com_lines, string);
+}
+
+/*
+==============
+COM_Parse
+
+Parse a token out of a string
+Will never return NULL, just empty strings
+
+If "allowLineBreaks" is qtrue then an empty
+string will be returned if the next token is
+a newline.
+==============
+*/
+const char *SkipWhitespace( const char *data, qboolean *hasNewLines ) {
+	int c;
+
+	while( (c = *data) <= ' ') {
+		if( !c ) {
+			return NULL;
+		}
+		if( c == '\n' ) {
+			com_lines++;
+			*hasNewLines = qtrue;
+		}
+		data++;
+	}
+
+	return data;
+}
+
+int COM_Compress( char *data_p ) {
+	char *in, *out;
+	int c;
+	qboolean newline = qfalse, whitespace = qfalse;
+	
+	in = out = data_p;
+	if (in) {
+		while ((c = *in) != 0) {
+			// skip double slash comments
+			if ( c == '/' && in[1] == '/' ) {
+				while (*in && *in != '\n') {
+					in++;
+				}
+				// skip /* */ comments
+			} else if ( c == '/' && in[1] == '*' ) {
+				while ( *in && ( *in != '*' || in[1] != '/' ) ) 
+					in++;
+				if ( *in ) 
+					in += 2;
+				// record when we hit a newline
+			} else if ( c == '\n' || c == '\r' ) {
+				newline = qtrue;
+				in++;
+				// record when we hit whitespace
+			} else if ( c == ' ' || c == '\t') {
+				whitespace = qtrue;
+				in++;
+				// an actual token
+			} else {
+				// if we have a pending newline, emit it (and it counts as whitespace)
+				if (newline) {
+					*out++ = '\n';
+					newline = qfalse;
+					whitespace = qfalse;
+				} if (whitespace) {
+					*out++ = ' ';
+					whitespace = qfalse;
+				}
+				
+				// copy quoted strings unmolested
+				if (c == '"') {
+					*out++ = c;
+					in++;
+					while (1) {
+						c = *in;
+						if (c && c != '"') {
+							*out++ = c;
+							in++;
+						} else {
+							break;
+						}
+					}
+					if (c == '"') {
+						*out++ = c;
+						in++;
+					}
+				} else {
+					*out = c;
+					out++;
+					in++;
+				}
+			}
+		}
+	}
+	*out = 0;
+	return out - data_p;
+}
+
+char *COM_ParseExt( const char **data_p, qboolean allowLineBreaks )
+{
+	int c = 0, len;
+	qboolean hasNewLines = qfalse;
+	const char *data;
+
+	data = *data_p;
+	len = 0;
+	com_token[0] = 0;
+
+	// make sure incoming data is valid
+	if ( !data )
+	{
+		*data_p = NULL;
+		return com_token;
+	}
+
+	while ( 1 )
+	{
+		// skip whitespace
+		data = SkipWhitespace( data, &hasNewLines );
+		if ( !data )
+		{
+			*data_p = NULL;
+			return com_token;
+		}
+		if ( hasNewLines && !allowLineBreaks )
+		{
+			*data_p = data;
+			return com_token;
+		}
+
+		c = *data;
+
+		// skip double slash comments
+		if ( c == '/' && data[1] == '/' )
+		{
+			data += 2;
+			while (*data && *data != '\n') {
+				data++;
+			}
+		}
+		// skip /* */ comments
+		else if ( c=='/' && data[1] == '*' ) 
+		{
+			data += 2;
+			while ( *data && ( *data != '*' || data[1] != '/' ) ) 
+			{
+				data++;
+			}
+			if ( *data ) 
+			{
+				data += 2;
+			}
+		}
+		else
+		{
+			break;
+		}
+	}
+
+	// handle quoted strings
+	if (c == '\"')
+	{
+		data++;
+		while (1)
+		{
+			c = *data++;
+			if (c=='\"' || !c)
+			{
+				com_token[len] = 0;
+				*data_p = ( char * ) data;
+				return com_token;
+			}
+			if (len < MAX_TOKEN_CHARS)
+			{
+				com_token[len] = c;
+				len++;
+			}
+		}
+	}
+
+	// parse a regular word
+	do
+	{
+		if (len < MAX_TOKEN_CHARS)
+		{
+			com_token[len] = c;
+			len++;
+		}
+		data++;
+		c = *data;
+		if ( c == '\n' )
+			com_lines++;
+	} while (c>32);
+
+	if (len == MAX_TOKEN_CHARS)
+	{
+//		Com_Printf ("Token exceeded %i chars, discarded.\n", MAX_TOKEN_CHARS);
+		len = 0;
+	}
+	com_token[len] = 0;
+
+	*data_p = ( char * ) data;
+	return com_token;
+}
+
+
+#if 0
+// no longer used
+/*
+===============
+COM_ParseInfos
+===============
+*/
+int COM_ParseInfos( char *buf, int max, char infos[][MAX_INFO_STRING] ) {
+	char	*token;
+	int		count;
+	char	key[MAX_TOKEN_CHARS];
+
+	count = 0;
+
+	while ( 1 ) {
+		token = COM_Parse( &buf );
+		if ( !token[0] ) {
+			break;
+		}
+		if ( strcmp( token, "{" ) ) {
+			Com_Printf( "Missing { in info file\n" );
+			break;
+		}
+
+		if ( count == max ) {
+			Com_Printf( "Max infos exceeded\n" );
+			break;
+		}
+
+		infos[count][0] = 0;
+		while ( 1 ) {
+			token = COM_ParseExt( &buf, qtrue );
+			if ( !token[0] ) {
+				Com_Printf( "Unexpected end of info file\n" );
+				break;
+			}
+			if ( !strcmp( token, "}" ) ) {
+				break;
+			}
+			Q_strncpyz( key, token, sizeof( key ) );
+
+			token = COM_ParseExt( &buf, qfalse );
+			if ( !token[0] ) {
+				strcpy( token, "<NULL>" );
+			}
+			Info_SetValueForKey( infos[count], key, token );
+		}
+		count++;
+	}
+
+	return count;
+}
+#endif
+
+/*
+===============
+COM_ParseString
+===============
+*/
+qboolean COM_ParseString( const char **data, const char **s ) 
+{
+//	*s = COM_ParseExt( data, qtrue );
+	*s = COM_ParseExt( data, qfalse );
+	if ( s[0] == 0 ) 
+	{
+		Com_Printf("unexpected EOF\n");
+		return qtrue;
+	}
+	return qfalse;
+}
+
+/*
+===============
+COM_ParseInt
+===============
+*/
+qboolean COM_ParseInt( const char **data, int *i ) 
+{
+	const char	*token;
+
+	token = COM_ParseExt( data, qfalse );
+	if ( token[0] == 0 ) 
+	{
+		Com_Printf( "unexpected EOF\n" );
+		return qtrue;
+	}
+
+	*i = atoi( token );
+	return qfalse;
+}
+
+/*
+===============
+COM_ParseFloat
+===============
+*/
+qboolean COM_ParseFloat( const char **data, float *f ) 
+{
+	const char	*token;
+
+	token = COM_ParseExt( data, qfalse );
+	if ( token[0] == 0 ) 
+	{
+		Com_Printf( "unexpected EOF\n" );
+		return qtrue;
+	}
+
+	*f = atof( token );
+	return qfalse;
+}
+
+/*
+===============
+COM_ParseVec4
+===============
+*/
+qboolean COM_ParseVec4( const char **buffer, vec4_t *c) 
+{
+	int i;
+	float f;
+
+	for (i = 0; i < 4; i++) 
+	{
+		if (COM_ParseFloat(buffer, &f)) 
+		{
+			return qtrue;
+		}
+		(*c)[i] = f;
+	}
+	return qfalse;
+}
+
+/*
+==================
+COM_MatchToken
+==================
+*/
+void COM_MatchToken( const char **buf_p, char *match ) {
+	char	*token;
+
+	token = COM_Parse( buf_p );
+	if ( strcmp( token, match ) ) {
+		Com_Error( ERR_DROP, "MatchToken: %s != %s", token, match );
+	}
+}
+
+
+/*
+=================
+SkipBracedSection
+
+The next token should be an open brace.
+Skips until a matching close brace is found.
+Internal brace depths are properly skipped.
+=================
+*/
+void SkipBracedSection (const char **program) {
+	char			*token;
+	int				depth;
+
+	depth = 0;
+	do {
+		token = COM_ParseExt( program, qtrue );
+		if( token[1] == 0 ) {
+			if( token[0] == '{' ) {
+				depth++;
+			}
+			else if( token[0] == '}' ) {
+				depth--;
+			}
+		}
+	} while( depth && *program );
+}
+
+/*
+=================
+SkipRestOfLine
+=================
+*/
+void SkipRestOfLine ( const char **data ) {
+	const char	*p;
+	int		c;
+
+	p = *data;
+	while ( (c = *p++) != 0 ) {
+		if ( c == '\n' ) {
+			com_lines++;
+			break;
+		}
+	}
+
+	*data = p;
+}
+
+
+void Parse1DMatrix (const char **buf_p, int x, float *m) {
+	char	*token;
+	int		i;
+
+	COM_MatchToken( buf_p, "(" );
+
+	for (i = 0 ; i < x ; i++) {
+		token = COM_Parse(buf_p);
+		m[i] = atof(token);
+	}
+
+	COM_MatchToken( buf_p, ")" );
+}
+
+void Parse2DMatrix (const char **buf_p, int y, int x, float *m) {
+	int		i;
+
+	COM_MatchToken( buf_p, "(" );
+
+	for (i = 0 ; i < y ; i++) {
+		Parse1DMatrix (buf_p, x, m + i * x);
+	}
+
+	COM_MatchToken( buf_p, ")" );
+}
+
+void Parse3DMatrix (const char **buf_p, int z, int y, int x, float *m) {
+	int		i;
+
+	COM_MatchToken( buf_p, "(" );
+
+	for (i = 0 ; i < z ; i++) {
+		Parse2DMatrix (buf_p, y, x, m + i * x*y);
+	}
+
+	COM_MatchToken( buf_p, ")" );
+}
+
+
+/*
+============================================================================
+
+					LIBRARY REPLACEMENT FUNCTIONS
+
+============================================================================
+*/
+
+int Q_isprint( int c )
+{
+	if ( c >= 0x20 && c <= 0x7E )
+		return ( 1 );
+	return ( 0 );
+}
+
+int Q_islower( int c )
+{
+	if (c >= 'a' && c <= 'z')
+		return ( 1 );
+	return ( 0 );
+}
+
+int Q_isupper( int c )
+{
+	if (c >= 'A' && c <= 'Z')
+		return ( 1 );
+	return ( 0 );
+}
+
+int Q_isalpha( int c )
+{
+	if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'))
+		return ( 1 );
+	return ( 0 );
+}
+
+char* Q_strrchr( const char* string, int c )
+{
+	char cc = c;
+	char *s;
+	char *sp=(char *)0;
+
+	s = (char*)string;
+
+	while (*s)
+	{
+		if (*s == cc)
+			sp = s;
+		s++;
+	}
+	if (cc == 0)
+		sp = s;
+
+	return sp;
+}
+
+/*
+=============
+Q_strncpyz
+ 
+Safe strncpy that ensures a trailing zero
+=============
+*/
+void Q_strncpyz( char *dest, const char *src, int destsize ) {
+  // bk001129 - also NULL dest
+  if ( !dest ) {
+    Com_Error( ERR_FATAL, "Q_strncpyz: NULL dest" );
+  }
+	if ( !src ) {
+		Com_Error( ERR_FATAL, "Q_strncpyz: NULL src" );
+	}
+	if ( destsize < 1 ) {
+		Com_Error(ERR_FATAL,"Q_strncpyz: destsize < 1" ); 
+	}
+
+	strncpy( dest, src, destsize-1 );
+  dest[destsize-1] = 0;
+}
+                 
+int Q_stricmpn (const char *s1, const char *s2, int n) {
+	int		c1, c2;
+
+	// bk001129 - moved in 1.17 fix not in id codebase
+        if ( s1 == NULL ) {
+           if ( s2 == NULL )
+             return 0;
+           else
+             return -1;
+        }
+        else if ( s2==NULL )
+          return 1;
+
+
+	
+	do {
+		c1 = *s1++;
+		c2 = *s2++;
+
+		if (!n--) {
+			return 0;		// strings are equal until end point
+		}
+		
+		if (c1 != c2) {
+			if (c1 >= 'a' && c1 <= 'z') {
+				c1 -= ('a' - 'A');
+			}
+			if (c2 >= 'a' && c2 <= 'z') {
+				c2 -= ('a' - 'A');
+			}
+			if (c1 != c2) {
+				return c1 < c2 ? -1 : 1;
+			}
+		}
+	} while (c1);
+	
+	return 0;		// strings are equal
+}
+
+int Q_strncmp (const char *s1, const char *s2, int n) {
+	int		c1, c2;
+	
+	do {
+		c1 = *s1++;
+		c2 = *s2++;
+
+		if (!n--) {
+			return 0;		// strings are equal until end point
+		}
+		
+		if (c1 != c2) {
+			return c1 < c2 ? -1 : 1;
+		}
+	} while (c1);
+	
+	return 0;		// strings are equal
+}
+
+int Q_stricmp (const char *s1, const char *s2) {
+	return (s1 && s2) ? Q_stricmpn (s1, s2, 99999) : -1;
+}
+
+
+char *Q_strlwr( char *s1 ) {
+    char	*s;
+
+    s = s1;
+	while ( *s ) {
+		*s = tolower(*s);
+		s++;
+	}
+    return s1;
+}
+
+char *Q_strupr( char *s1 ) {
+    char	*s;
+
+    s = s1;
+	while ( *s ) {
+		*s = toupper(*s);
+		s++;
+	}
+    return s1;
+}
+
+
+// never goes past bounds or leaves without a terminating 0
+void Q_strcat( char *dest, int size, const char *src ) {
+	int		l1;
+
+	l1 = strlen( dest );
+	if ( l1 >= size ) {
+		Com_Error( ERR_FATAL, "Q_strcat: already overflowed" );
+	}
+	Q_strncpyz( dest + l1, src, size - l1 );
+}
+
+
+int Q_PrintStrlen( const char *string ) {
+	int			len;
+	const char	*p;
+
+	if( !string ) {
+		return 0;
+	}
+
+	len = 0;
+	p = string;
+	while( *p ) {
+		if( Q_IsColorString( p ) ) {
+			p += 2;
+			continue;
+		}
+		p++;
+		len++;
+	}
+
+	return len;
+}
+
+
+char *Q_CleanStr( char *string ) {
+	char*	d;
+	char*	s;
+	int		c;
+
+	s = string;
+	d = string;
+	while ((c = *s) != 0 ) {
+		if ( Q_IsColorString( s ) ) {
+			s++;
+		}		
+		else if ( c >= 0x20 && c <= 0x7E ) {
+			*d++ = c;
+		}
+		s++;
+	}
+	*d = '\0';
+
+	return string;
+}
+
+
+void QDECL Com_sprintf( char *dest, int size, const char *fmt, ...) {
+	int		len;
+	va_list		argptr;
+	char	bigbuffer[32000];	// big, but small enough to fit in PPC stack
+
+	va_start (argptr,fmt);
+	len = vsprintf (bigbuffer,fmt,argptr);
+	va_end (argptr);
+	if ( len >= sizeof( bigbuffer ) ) {
+		Com_Error( ERR_FATAL, "Com_sprintf: overflowed bigbuffer" );
+	}
+	if (len >= size) {
+		Com_Printf ("Com_sprintf: overflow of %i in %i\n", len, size);
+#ifdef	_DEBUG
+		__asm {
+			int 3;
+		}
+#endif
+	}
+	Q_strncpyz (dest, bigbuffer, size );
+}
+
+
+/*
+============
+va
+
+does a varargs printf into a temp buffer, so I don't need to have
+varargs versions of all text functions.
+FIXME: make this buffer size safe someday
+============
+*/
+char	* QDECL va( const char *format, ... ) {
+	va_list		argptr;
+	static char		string[2][32000];	// in case va is called by nested functions
+	static int		index = 0;
+	char	*buf;
+
+	buf = string[index & 1];
+	index++;
+
+	va_start (argptr, format);
+	vsprintf (buf, format,argptr);
+	va_end (argptr);
+
+	return buf;
+}
+
+
+/*
+=====================================================================
+
+  INFO STRINGS
+
+=====================================================================
+*/
+
+/*
+===============
+Info_ValueForKey
+
+Searches the string for the given
+key and returns the associated value, or an empty string.
+FIXME: overflow check?
+===============
+*/
+char *Info_ValueForKey( const char *s, const char *key ) {
+	char	pkey[BIG_INFO_KEY];
+	static	char value[2][BIG_INFO_VALUE];	// use two buffers so compares
+											// work without stomping on each other
+	static	int	valueindex = 0;
+	char	*o;
+	
+	if ( !s || !key ) {
+		return "";
+	}
+
+	if ( strlen( s ) >= BIG_INFO_STRING ) {
+		Com_Error( ERR_DROP, "Info_ValueForKey: oversize infostring" );
+	}
+
+	valueindex ^= 1;
+	if (*s == '\\')
+		s++;
+	while (1)
+	{
+		o = pkey;
+		while (*s != '\\')
+		{
+			if (!*s)
+				return "";
+			*o++ = *s++;
+		}
+		*o = 0;
+		s++;
+
+		o = value[valueindex];
+
+		while (*s != '\\' && *s)
+		{
+			*o++ = *s++;
+		}
+		*o = 0;
+
+		if (!Q_stricmp (key, pkey) )
+			return value[valueindex];
+
+		if (!*s)
+			break;
+		s++;
+	}
+
+	return "";
+}
+
+
+/*
+===================
+Info_NextPair
+
+Used to itterate through all the key/value pairs in an info string
+===================
+*/
+void Info_NextPair( const char **head, char *key, char *value ) {
+	char	*o;
+	const char	*s;
+
+	s = *head;
+
+	if ( *s == '\\' ) {
+		s++;
+	}
+	key[0] = 0;
+	value[0] = 0;
+
+	o = key;
+	while ( *s != '\\' ) {
+		if ( !*s ) {
+			*o = 0;
+			*head = s;
+			return;
+		}
+		*o++ = *s++;
+	}
+	*o = 0;
+	s++;
+
+	o = value;
+	while ( *s != '\\' && *s ) {
+		*o++ = *s++;
+	}
+	*o = 0;
+
+	*head = s;
+}
+
+
+/*
+===================
+Info_RemoveKey
+===================
+*/
+void Info_RemoveKey( char *s, const char *key ) {
+	char	*start;
+	char	pkey[MAX_INFO_KEY];
+	char	value[MAX_INFO_VALUE];
+	char	*o;
+
+	if ( strlen( s ) >= MAX_INFO_STRING ) {
+		Com_Error( ERR_DROP, "Info_RemoveKey: oversize infostring" );
+	}
+
+	if (strchr (key, '\\')) {
+		return;
+	}
+
+	while (1)
+	{
+		start = s;
+		if (*s == '\\')
+			s++;
+		o = pkey;
+		while (*s != '\\')
+		{
+			if (!*s)
+				return;
+			*o++ = *s++;
+		}
+		*o = 0;
+		s++;
+
+		o = value;
+		while (*s != '\\' && *s)
+		{
+			if (!*s)
+				return;
+			*o++ = *s++;
+		}
+		*o = 0;
+
+		if (!strcmp (key, pkey) )
+		{
+			strcpy (start, s);	// remove this part
+			return;
+		}
+
+		if (!*s)
+			return;
+	}
+
+}
+
+/*
+===================
+Info_RemoveKey_Big
+===================
+*/
+void Info_RemoveKey_Big( char *s, const char *key ) {
+	char	*start;
+	char	pkey[BIG_INFO_KEY];
+	char	value[BIG_INFO_VALUE];
+	char	*o;
+
+	if ( strlen( s ) >= BIG_INFO_STRING ) {
+		Com_Error( ERR_DROP, "Info_RemoveKey_Big: oversize infostring" );
+	}
+
+	if (strchr (key, '\\')) {
+		return;
+	}
+
+	while (1)
+	{
+		start = s;
+		if (*s == '\\')
+			s++;
+		o = pkey;
+		while (*s != '\\')
+		{
+			if (!*s)
+				return;
+			*o++ = *s++;
+		}
+		*o = 0;
+		s++;
+
+		o = value;
+		while (*s != '\\' && *s)
+		{
+			if (!*s)
+				return;
+			*o++ = *s++;
+		}
+		*o = 0;
+
+		if (!strcmp (key, pkey) )
+		{
+			strcpy (start, s);	// remove this part
+			return;
+		}
+
+		if (!*s)
+			return;
+	}
+
+}
+
+
+
+
+/*
+==================
+Info_Validate
+
+Some characters are illegal in info strings because they
+can mess up the server's parsing
+==================
+*/
+qboolean Info_Validate( const char *s ) {
+	if ( strchr( s, '\"' ) ) {
+		return qfalse;
+	}
+	if ( strchr( s, ';' ) ) {
+		return qfalse;
+	}
+	return qtrue;
+}
+
+/*
+==================
+Info_SetValueForKey
+
+Changes or adds a key/value pair
+==================
+*/
+void Info_SetValueForKey( char *s, const char *key, const char *value ) {
+	char	newi[MAX_INFO_STRING];
+
+	if ( strlen( s ) >= MAX_INFO_STRING ) {
+		Com_Error( ERR_DROP, "Info_SetValueForKey: oversize infostring" );
+	}
+
+	if (strchr (key, '\\') || strchr (value, '\\'))
+	{
+		Com_Printf ("Can't use keys or values with a \\\n");
+		return;
+	}
+
+	if (strchr (key, ';') || strchr (value, ';'))
+	{
+		Com_Printf ("Can't use keys or values with a semicolon\n");
+		return;
+	}
+
+	if (strchr (key, '\"') || strchr (value, '\"'))
+	{
+		Com_Printf ("Can't use keys or values with a \"\n");
+		return;
+	}
+
+	Info_RemoveKey (s, key);
+	if (!value || !strlen(value))
+		return;
+
+	Com_sprintf (newi, sizeof(newi), "\\%s\\%s", key, value);
+
+	if (strlen(newi) + strlen(s) > MAX_INFO_STRING)
+	{
+		Com_Printf ("Info string length exceeded\n");
+		return;
+	}
+
+	strcat (newi, s);
+	strcpy (s, newi);
+}
+
+/*
+==================
+Info_SetValueForKey_Big
+
+Changes or adds a key/value pair
+==================
+*/
+void Info_SetValueForKey_Big( char *s, const char *key, const char *value ) {
+	char	newi[BIG_INFO_STRING];
+
+	if ( strlen( s ) >= BIG_INFO_STRING ) {
+		Com_Error( ERR_DROP, "Info_SetValueForKey: oversize infostring" );
+	}
+
+	if (strchr (key, '\\') || strchr (value, '\\'))
+	{
+		Com_Printf ("Can't use keys or values with a \\\n");
+		return;
+	}
+
+	if (strchr (key, ';') || strchr (value, ';'))
+	{
+		Com_Printf ("Can't use keys or values with a semicolon\n");
+		return;
+	}
+
+	if (strchr (key, '\"') || strchr (value, '\"'))
+	{
+		Com_Printf ("Can't use keys or values with a \"\n");
+		return;
+	}
+
+	Info_RemoveKey_Big (s, key);
+	if (!value || !strlen(value))
+		return;
+
+	Com_sprintf (newi, sizeof(newi), "\\%s\\%s", key, value);
+
+	if (strlen(newi) + strlen(s) > BIG_INFO_STRING)
+	{
+		Com_Printf ("BIG Info string length exceeded\n");
+		return;
+	}
+
+	strcat (s, newi);
+}
+
+
+//rww - convience function..
+int Q_irand(int value1, int value2)
+{
+	value2++; //so it can round down
+	return ((rand() * (value2 - value1)) >> 15) + value1;
+}
+
+//====================================================================
+
+
diff --git a/codemp/game/q_shared.h b/codemp/game/q_shared.h
new file mode 100644
index 0000000..8926d97
--- /dev/null
+++ b/codemp/game/q_shared.h
@@ -0,0 +1,3055 @@
+// Copyright (C) 1999-2000 Id Software, Inc.
+//
+#ifndef __Q_SHARED_H
+#define __Q_SHARED_H
+
+// q_shared.h -- included first by ALL program modules.
+// A user mod should never modify this file
+
+//NOTENOTE: Only change this to re-point ICARUS to a new script directory
+#define Q3_SCRIPT_DIR	"scripts"
+
+#define MAX_TEAMNAME 32
+
+#include "../qcommon/disablewarnings.h"
+
+#include "teams.h" //npc team stuff
+
+#define MAX_WORLD_COORD		( 64 * 1024 )
+#define MIN_WORLD_COORD		( -64 * 1024 )
+#define WORLD_SIZE			( MAX_WORLD_COORD - MIN_WORLD_COORD )
+
+//Pointer safety utilities
+#define VALID( a )		( a != NULL )
+#define	VALIDATE( a )	( assert( a ) )
+
+#define	VALIDATEV( a )	if ( a == NULL ) {	assert(0);	return;			}
+#define	VALIDATEB( a )	if ( a == NULL ) {	assert(0);	return qfalse;	}
+#define VALIDATEP( a )	if ( a == NULL ) {	assert(0);	return NULL;	}
+
+#define VALIDSTRING( a )	( ( a != 0 ) && ( a[0] != 0 ) )
+
+/*
+#define G2_EHNANCEMENTS
+
+#ifdef G2_EHNANCEMENTS
+//these two will probably explode if they're defined independant of one another.
+//rww - RAGDOLL_BEGIN
+#define JK2_RAGDOLL
+//rww - RAGDOLL_END
+//rww - Bone cache for multiplayer base.
+#define MP_BONECACHE
+#endif
+*/
+
+#ifndef FINAL_BUILD
+#define G2_PERFORMANCE_ANALYSIS
+#define _FULL_G2_LEAK_CHECKING
+extern int g_Ghoul2Allocations;
+extern int g_G2ServerAlloc;
+extern int g_G2ClientAlloc;
+extern int g_G2AllocServer;
+#endif
+
+/**********************************************************************
+  VM Considerations
+
+  The VM can not use the standard system headers because we aren't really
+  using the compiler they were meant for.  We use bg_lib.h which contains
+  prototypes for the functions we define for our own use in bg_lib.c.
+
+  When writing mods, please add needed headers HERE, do not start including
+  stuff like <stdio.h> in the various .c files that make up each of the VMs
+  since you will be including system headers files can will have issues.
+
+  Remember, if you use a C library function that is not defined in bg_lib.c,
+  you will have to add your own version for support in the VM.
+
+ **********************************************************************/
+
+#ifdef Q3_VM
+
+#include "bg_lib.h"
+
+#define assert(exp)     ((void)0)
+
+#define min(x,y) ((x)<(y)?(x):(y))
+#define max(x,y) ((x)>(y)?(x):(y))
+
+#else
+
+#include <assert.h>
+#include <math.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <string.h>
+#include <stdlib.h>
+#include <time.h>
+#include <ctype.h>
+#include <limits.h>
+
+// Special min treatment for Xbox C++ version
+
+#ifdef _XBOX
+#define min(x,y) ((x)<(y)?(x):(y))
+#define max(x,y) ((x)>(y)?(x):(y))
+
+#define tvector(T) std::vector< T >
+#define tdeque(T) std::deque< T >
+
+#define tlist(T) std::list< T >
+#define tslist(T) std::slist< T >
+
+#define tset(T) std::set< T, std::less< T > >
+#define tmultiset(T) std::multiset< T, std::less< T > >
+
+#define tcset(T,C) std::set< T, C >
+#define tcmultiset(T,C) std::multiset< T, C >
+
+#define tmap(K,T) std::map< K, T, std::less< K > >
+#define tmultimap(K,T) std::multimap< K, T, std::less< K > >
+
+#define tcmap(K,T,C) std::map< K, T, C >
+#define tcmultimap(K,T,C) std::multimap< K, T, C >
+#endif
+
+#endif
+
+#ifdef _WIN32
+
+//#pragma intrinsic( memset, memcpy )
+
+#endif
+
+// this is the define for determining if we have an asm version of a C function
+#if (defined _M_IX86 || defined __i386__) && !defined __sun__  && !defined __LCC__
+#define id386	1
+#else
+#define id386	0
+#endif
+
+#if (defined(powerc) || defined(powerpc) || defined(ppc) || defined(__ppc) || defined(__ppc__)) && !defined(C_ONLY)
+#define idppc	1
+#else
+#define idppc	0
+#endif
+
+// for windows fastcall option
+
+#define	QDECL
+
+short   ShortSwap (short l);
+int		LongSwap (int l);
+float	FloatSwap (const float *f);
+
+//======================= WIN32 DEFINES =================================
+
+#ifdef WIN32
+
+#define	MAC_STATIC
+
+#undef QDECL
+#define	QDECL	__cdecl
+
+// buildstring will be incorporated into the version string
+#ifdef NDEBUG
+#ifdef _M_IX86
+#define	CPUSTRING	"win-x86"
+#elif defined _M_ALPHA
+#define	CPUSTRING	"win-AXP"
+#endif
+#else
+#ifdef _M_IX86
+#define	CPUSTRING	"win-x86-debug"
+#elif defined _M_ALPHA
+#define	CPUSTRING	"win-AXP-debug"
+#endif
+#endif
+
+#define ID_INLINE __inline 
+
+static ID_INLINE short BigShort( short l) { return ShortSwap(l); }
+#define LittleShort
+static ID_INLINE int BigLong(int l) { return LongSwap(l); }
+#define LittleLong
+static ID_INLINE float BigFloat(const float *l) { FloatSwap(l); }
+#define LittleFloat
+
+#define	PATH_SEP '\\'
+
+#endif
+
+//======================= MAC OS X DEFINES =====================
+
+#if defined(MACOS_X)
+
+#define MAC_STATIC
+#define __cdecl
+#define __declspec(x)
+#define stricmp strcasecmp
+#define ID_INLINE inline 
+
+#ifdef __ppc__
+#define CPUSTRING	"MacOSX-ppc"
+#elif defined __i386__
+#define CPUSTRING	"MacOSX-i386"
+#else
+#define CPUSTRING	"MacOSX-other"
+#endif
+
+#define	PATH_SEP	'/'
+
+#define __rlwimi(out, in, shift, maskBegin, maskEnd) asm("rlwimi %0,%1,%2,%3,%4" : "=r" (out) : "r" (in), "i" (shift), "i" (maskBegin), "i" (maskEnd))
+#define __dcbt(addr, offset) asm("dcbt %0,%1" : : "b" (addr), "r" (offset))
+
+static inline unsigned int __lwbrx(register void *addr, register int offset) {
+    register unsigned int word;
+    
+    asm("lwbrx %0,%2,%1" : "=r" (word) : "r" (addr), "b" (offset));
+    return word;
+}
+
+static inline unsigned short __lhbrx(register void *addr, register int offset) {
+    register unsigned short halfword;
+    
+    asm("lhbrx %0,%2,%1" : "=r" (halfword) : "r" (addr), "b" (offset));
+    return halfword;
+}
+
+static inline float __fctiw(register float f) {
+    register float fi;
+    
+    asm("fctiw %0,%1" : "=f" (fi) : "f" (f));
+
+    return fi;
+}
+
+#define BigShort
+static inline short LittleShort(short l) { return ShortSwap(l); }
+#define BigLong
+static inline int LittleLong (int l) { return LongSwap(l); }
+#define BigFloat
+static inline float LittleFloat (const float l) { return FloatSwap(&l); }
+
+#endif
+
+//======================= MAC DEFINES =================================
+
+#ifdef __MACOS__
+
+#include <MacTypes.h>
+#define	MAC_STATIC
+#define ID_INLINE inline 
+
+#define	CPUSTRING	"MacOS-PPC"
+
+#define	PATH_SEP ':'
+
+void Sys_PumpEvents( void );
+
+#define BigShort
+static inline short LittleShort(short l) { return ShortSwap(l); }
+#define BigLong
+static inline int LittleLong (int l) { return LongSwap(l); }
+#define BigFloat
+static inline float LittleFloat (const float l) { return FloatSwap(&l); }
+
+#endif
+
+//======================= LINUX DEFINES =================================
+
+// the mac compiler can't handle >32k of locals, so we
+// just waste space and make big arrays static...
+#ifdef __linux__
+
+// bk001205 - from Makefile
+#define stricmp strcasecmp
+
+#define	MAC_STATIC // bk: FIXME
+#define ID_INLINE inline 
+
+#ifdef __i386__
+#define	CPUSTRING	"linux-i386"
+#elif defined __axp__
+#define	CPUSTRING	"linux-alpha"
+#else
+#define	CPUSTRING	"linux-other"
+#endif
+
+#define	PATH_SEP '/'
+
+// bk001205 - try
+#ifdef Q3_STATIC
+#define	GAME_HARD_LINKED
+#define	CGAME_HARD_LINKED
+#define	UI_HARD_LINKED
+#define	BOTLIB_HARD_LINKED
+#endif
+
+#if !idppc
+inline static short BigShort( short l) { return ShortSwap(l); }
+#define LittleShort
+inline static int BigLong(int l) { return LongSwap(l); }
+#define LittleLong
+inline static float BigFloat(const float *l) { return FloatSwap(l); }
+#define LittleFloat
+#else
+#define BigShort
+inline static short LittleShort(short l) { return ShortSwap(l); }
+#define BigLong
+inline static int LittleLong (int l) { return LongSwap(l); }
+#define BigFloat
+inline static float LittleFloat (const float *l) { return FloatSwap(l); }
+#endif
+
+#endif
+
+//======================= FreeBSD DEFINES =====================
+#ifdef __FreeBSD__ // rb010123
+
+#define stricmp strcasecmp
+
+#define MAC_STATIC
+#define ID_INLINE inline 
+
+#ifdef __i386__
+#define CPUSTRING       "freebsd-i386"
+#elif defined __axp__
+#define CPUSTRING       "freebsd-alpha"
+#else
+#define CPUSTRING       "freebsd-other"
+#endif
+
+#define	PATH_SEP '/'
+
+// bk010116 - omitted Q3STATIC (see Linux above), broken target
+
+#if !idppc
+static short BigShort( short l) { return ShortSwap(l); }
+#define LittleShort
+static int BigLong(int l) { LongSwap(l); }
+#define LittleLong
+static float BigFloat(const float *l) { FloatSwap(l); }
+#define LittleFloat
+#else
+#define BigShort
+static short LittleShort(short l) { return ShortSwap(l); }
+#define BigLong
+static int LittleLong (int l) { return LongSwap(l); }
+#define BigFloat
+static float LittleFloat (const float *l) { return FloatSwap(l); }
+#endif
+
+#endif
+
+//=============================================================
+
+//=============================================================
+
+typedef unsigned char 		byte;
+typedef unsigned short		word;
+typedef unsigned long		ulong;
+
+typedef enum {qfalse, qtrue}	qboolean;
+#ifdef _XBOX
+#define	qboolean	int		//don't want strict type checking on the qboolean
+#endif
+
+typedef int		qhandle_t;
+typedef int		thandle_t; //rwwRMG - inserted
+typedef int		fxHandle_t;
+typedef int		sfxHandle_t;
+typedef int		fileHandle_t;
+typedef int		clipHandle_t;
+
+#ifndef NULL
+#define NULL ((void *)0)
+#endif
+
+#define	MAX_QINT			0x7fffffff
+#define	MIN_QINT			(-MAX_QINT-1)
+
+
+// angle indexes
+#define	PITCH				0		// up / down
+#define	YAW					1		// left / right
+#define	ROLL				2		// fall over
+
+// the game guarantees that no string from the network will ever
+// exceed MAX_STRING_CHARS
+#define	MAX_STRING_CHARS	1024	// max length of a string passed to Cmd_TokenizeString
+#define	MAX_STRING_TOKENS	1024	// max tokens resulting from Cmd_TokenizeString
+#define	MAX_TOKEN_CHARS		1024	// max length of an individual token
+
+#define	MAX_INFO_STRING		1024
+#define	MAX_INFO_KEY		1024
+#define	MAX_INFO_VALUE		1024
+
+#define	BIG_INFO_STRING		8192  // used for system info key only
+#define	BIG_INFO_KEY		  8192
+#define	BIG_INFO_VALUE		8192
+
+
+#define	MAX_QPATH			64		// max length of a quake game pathname
+#ifdef PATH_MAX
+#define MAX_OSPATH			PATH_MAX
+#else
+#define	MAX_OSPATH			256		// max length of a filesystem pathname
+#endif
+
+#define	MAX_NAME_LENGTH		32		// max length of a client name
+
+#define	MAX_SAY_TEXT	150
+
+// paramters for command buffer stuffing
+typedef enum {
+	EXEC_NOW,			// don't return until completed, a VM should NEVER use this,
+						// because some commands might cause the VM to be unloaded...
+	EXEC_INSERT,		// insert at current position, but don't run yet
+	EXEC_APPEND			// add to end of the command buffer (normal case)
+} cbufExec_t;
+
+
+//
+// these aren't needed by any of the VMs.  put in another header?
+//
+#define	MAX_MAP_AREA_BYTES		32		// bit vector of area visibility
+
+
+#define LS_STYLES_START			0
+#define LS_NUM_STYLES			32
+#define	LS_SWITCH_START			(LS_STYLES_START+LS_NUM_STYLES)
+#define LS_NUM_SWITCH			32
+#if !defined MAX_LIGHT_STYLES
+#define MAX_LIGHT_STYLES		64
+#endif
+
+//For system-wide prints
+enum WL_e {
+	WL_ERROR=1,
+	WL_WARNING,
+	WL_VERBOSE,
+	WL_DEBUG
+};
+
+extern float forceSpeedLevels[4];
+
+// print levels from renderer (FIXME: set up for game / cgame?)
+typedef enum {
+	PRINT_ALL,
+	PRINT_DEVELOPER,		// only print when "developer 1"
+	PRINT_WARNING,
+	PRINT_ERROR
+} printParm_t;
+
+
+#ifdef ERR_FATAL
+#undef ERR_FATAL			// this is be defined in malloc.h
+#endif
+
+// parameters to the main Error routine
+typedef enum {
+	ERR_FATAL,					// exit the entire game with a popup window
+	ERR_DROP,					// print to console and disconnect from game
+	ERR_SERVERDISCONNECT,		// don't kill server
+	ERR_DISCONNECT,				// client disconnected from the server
+	ERR_NEED_CD					// pop up the need-cd dialog
+} errorParm_t;
+
+
+// font rendering values used by ui and cgame
+
+/*#define PROP_GAP_WIDTH			3
+#define PROP_SPACE_WIDTH		8
+#define PROP_HEIGHT				27
+#define PROP_SMALL_SIZE_SCALE	0.75*/
+
+#define PROP_GAP_WIDTH			2
+//#define PROP_GAP_WIDTH			3
+#define PROP_SPACE_WIDTH		4
+#define PROP_HEIGHT				16
+
+#define PROP_TINY_SIZE_SCALE	1
+#define PROP_SMALL_SIZE_SCALE	1
+#define PROP_BIG_SIZE_SCALE		1
+#define PROP_GIANT_SIZE_SCALE	2
+
+#define PROP_TINY_HEIGHT		10
+#define PROP_GAP_TINY_WIDTH		1
+#define PROP_SPACE_TINY_WIDTH	3
+
+#define PROP_BIG_HEIGHT			24
+#define PROP_GAP_BIG_WIDTH		3
+#define PROP_SPACE_BIG_WIDTH	6
+
+#define BLINK_DIVISOR			200
+#define PULSE_DIVISOR			75
+
+#define UI_LEFT			0x00000000	// default
+#define UI_CENTER		0x00000001
+#define UI_RIGHT		0x00000002
+#define UI_FORMATMASK	0x00000007
+#define UI_SMALLFONT	0x00000010
+#define UI_BIGFONT		0x00000020	// default
+//#define UI_GIANTFONT	0x00000040
+#define UI_DROPSHADOW	0x00000800
+#define UI_BLINK		0x00001000
+#define UI_INVERSE		0x00002000
+#define UI_PULSE		0x00004000
+
+#if defined(_DEBUG) && !defined(BSPC) && !defined(_XBOX)
+	#define HUNK_DEBUG
+#endif
+
+typedef enum {
+	h_high,
+	h_low,
+	h_dontcare
+} ha_pref;
+
+void *Hunk_Alloc( int size, ha_pref preference );
+
+void Com_Memset (void* dest, const int val, const size_t count);
+void Com_Memcpy (void* dest, const void* src, const size_t count);
+
+#define CIN_system	1
+#define CIN_loop	2
+#define	CIN_hold	4
+#define CIN_silent	8
+#define CIN_shader	16
+
+/*
+==============================================================
+
+MATHLIB
+
+==============================================================
+*/
+
+
+typedef float vec_t;
+typedef vec_t vec2_t[2];
+typedef vec_t vec3_t[3];
+typedef vec_t vec4_t[4];
+typedef vec_t vec5_t[5];
+
+//rwwRMG - new vec types
+typedef vec3_t	vec3pair_t[2];
+
+typedef int ivec3_t[3];
+typedef int ivec4_t[4];
+typedef int ivec5_t[5];
+
+typedef	int	fixed4_t;
+typedef	int	fixed8_t;
+typedef	int	fixed16_t;
+
+#ifndef M_PI
+#define M_PI		3.14159265358979323846f	// matches value in gcc v2 math.h
+#endif
+
+
+typedef enum {
+	BLK_NO,
+	BLK_TIGHT,		// Block only attacks and shots around the saber itself, a bbox of around 12x12x12
+	BLK_WIDE		// Block all attacks in an area around the player in a rough arc of 180 degrees
+} saberBlockType_t;
+
+typedef enum {
+	BLOCKED_NONE,
+	BLOCKED_BOUNCE_MOVE,
+	BLOCKED_PARRY_BROKEN,
+	BLOCKED_ATK_BOUNCE,
+	BLOCKED_UPPER_RIGHT,
+	BLOCKED_UPPER_LEFT,
+	BLOCKED_LOWER_RIGHT,
+	BLOCKED_LOWER_LEFT,
+	BLOCKED_TOP,
+	BLOCKED_UPPER_RIGHT_PROJ,
+	BLOCKED_UPPER_LEFT_PROJ,
+	BLOCKED_LOWER_RIGHT_PROJ,
+	BLOCKED_LOWER_LEFT_PROJ,
+	BLOCKED_TOP_PROJ
+} saberBlockedType_t;
+
+
+
+typedef enum
+{
+	SABER_RED,
+	SABER_ORANGE,
+	SABER_YELLOW,
+	SABER_GREEN,
+	SABER_BLUE,
+	SABER_PURPLE,
+	NUM_SABER_COLORS
+
+};
+typedef int saber_colors_t;
+
+typedef enum
+{
+	FP_FIRST = 0,//marker
+	FP_HEAL = 0,//instant
+	FP_LEVITATION,//hold/duration
+	FP_SPEED,//duration
+	FP_PUSH,//hold/duration
+	FP_PULL,//hold/duration
+	FP_TELEPATHY,//instant
+	FP_GRIP,//hold/duration
+	FP_LIGHTNING,//hold/duration
+	FP_RAGE,//duration
+	FP_PROTECT,
+	FP_ABSORB,
+	FP_TEAM_HEAL,
+	FP_TEAM_FORCE,
+	FP_DRAIN,
+	FP_SEE,
+	FP_SABER_OFFENSE,
+	FP_SABER_DEFENSE,
+	FP_SABERTHROW,
+	NUM_FORCE_POWERS
+};
+typedef int forcePowers_t;
+
+typedef enum
+{
+	SABER_NONE = 0,
+	SABER_SINGLE,
+	SABER_STAFF,
+	SABER_DAGGER,
+	SABER_BROAD,
+	SABER_PRONG,
+	SABER_ARC,
+	SABER_SAI,
+	SABER_CLAW,
+	SABER_LANCE,
+	SABER_STAR,
+	SABER_TRIDENT,
+	SABER_SITH_SWORD,
+	NUM_SABERS
+} saberType_t;
+
+typedef struct 
+{
+	// Actual trail stuff
+	int		inAction;	// controls whether should we even consider starting one
+	int		duration;	// how long each trail seg stays in existence
+	int		lastTime;	// time a saber segement was last stored
+	vec3_t	base;
+	vec3_t	tip;
+
+	vec3_t	dualbase;
+	vec3_t	dualtip;
+
+	// Marks stuff
+	qboolean	haveOldPos[2];
+	vec3_t		oldPos[2];		
+	vec3_t		oldNormal[2];	// store this in case we don't have a connect-the-dots situation
+							//	..then we'll need the normal to project a mark blob onto the impact point
+} saberTrail_t;
+
+typedef struct
+{
+	qboolean	active;
+	saber_colors_t	color;
+	float		radius;
+	float		length;
+	float		lengthMax;
+	float		lengthOld;
+	float		desiredLength;
+	vec3_t		muzzlePoint;
+	vec3_t		muzzlePointOld;
+	vec3_t		muzzleDir;
+	vec3_t		muzzleDirOld;
+	saberTrail_t	trail;
+	int			hitWallDebounceTime;
+	int			storageTime;
+	int			extendDebounce;
+} bladeInfo_t;
+#define MAX_BLADES 8
+
+typedef enum
+{
+	SS_NONE = 0,
+	SS_FAST,
+	SS_MEDIUM,
+	SS_STRONG,
+	SS_DESANN,
+	SS_TAVION,
+	SS_DUAL,
+	SS_STAFF,
+	SS_NUM_SABER_STYLES
+} saber_styles_t;
+
+typedef struct
+{
+	char		name[64];						//entry in sabers.cfg, if any
+	char		fullName[64];				//the "Proper Name" of the saber, shown in UI
+	saberType_t	type;						//none, single or staff
+	char		model[MAX_QPATH];						//hilt model
+	qhandle_t	skin;						//registered skin id
+	int			soundOn;					//game soundindex for turning on sound
+	int			soundLoop;					//game soundindex for hum/loop sound
+	int			soundOff;					//game soundindex for turning off sound
+	int			numBlades;
+	bladeInfo_t	blade[MAX_BLADES];			//blade info - like length, trail, origin, dir, etc.
+	saber_styles_t	style;					//locked style to use, if any
+	int			maxChain;					//how many moves can be chained in a row with this weapon (-1 is infinite, 0 is use default behavior)
+	qboolean	lockable;					//can get into a saberlock
+	qboolean	throwable;					//whether or not this saber can be thrown - FIXME: maybe make this a max level of force saber throw that can be used with this saber?
+	qboolean	disarmable;					//whether or not this saber can be dropped
+	qboolean	activeBlocking;				//whether or not to try to block incoming shots with this saber
+	qboolean	twoHanded;					//uses both hands
+	int			forceRestrictions;			//force powers that cannot be used while this saber is on (bitfield) - FIXME: maybe make this a limit on the max level, per force power, that can be used with this type?
+	int			lockBonus;					//in saberlocks, this type of saber pushes harder or weaker
+	int			parryBonus;					//added to strength of parry with this saber
+	int			breakParryBonus;			//added to strength when hit a parry
+	int			disarmBonus;				//added to disarm chance when win saberlock or have a good parry (knockaway)
+	saber_styles_t	singleBladeStyle;		//makes it so that you use a different style if you only have the first blade active
+	qboolean	singleBladeThrowable;		//makes it so that you can throw this saber if only the first blade is on
+	qboolean	returnDamage;
+} saberInfo_t;
+#define MAX_SABERS 2
+
+typedef enum
+{
+	FORCE_LEVEL_0,
+	FORCE_LEVEL_1,
+	FORCE_LEVEL_2,
+	FORCE_LEVEL_3,
+	NUM_FORCE_POWER_LEVELS
+};
+
+#define	FORCE_LEVEL_4 (FORCE_LEVEL_3+1)
+#define	FORCE_LEVEL_5 (FORCE_LEVEL_4+1)
+
+//rww - a C-ified structure version of the class which fires off callbacks and gives arguments to update ragdoll status.
+enum sharedERagPhase
+{
+	RP_START_DEATH_ANIM,
+	RP_END_DEATH_ANIM,
+	RP_DEATH_COLLISION,
+	RP_CORPSE_SHOT,
+	RP_GET_PELVIS_OFFSET,  // this actually does nothing but set the pelvisAnglesOffset, and pelvisPositionOffset
+	RP_SET_PELVIS_OFFSET,  // this actually does nothing but set the pelvisAnglesOffset, and pelvisPositionOffset
+	RP_DISABLE_EFFECTORS  // this removes effectors given by the effectorsToTurnOff member
+};
+
+enum sharedERagEffector
+{
+	RE_MODEL_ROOT=			0x00000001, //"model_root"
+	RE_PELVIS=				0x00000002, //"pelvis"
+	RE_LOWER_LUMBAR=		0x00000004, //"lower_lumbar"
+	RE_UPPER_LUMBAR=		0x00000008, //"upper_lumbar"
+	RE_THORACIC=			0x00000010, //"thoracic"
+	RE_CRANIUM=				0x00000020, //"cranium"
+	RE_RHUMEROUS=			0x00000040, //"rhumerus"
+	RE_LHUMEROUS=			0x00000080, //"lhumerus"
+	RE_RRADIUS=				0x00000100, //"rradius"
+	RE_LRADIUS=				0x00000200, //"lradius"
+	RE_RFEMURYZ=			0x00000400, //"rfemurYZ"
+	RE_LFEMURYZ=			0x00000800, //"lfemurYZ"
+	RE_RTIBIA=				0x00001000, //"rtibia"
+	RE_LTIBIA=				0x00002000, //"ltibia"
+	RE_RHAND=				0x00004000, //"rhand"
+	RE_LHAND=				0x00008000, //"lhand"
+	RE_RTARSAL=				0x00010000, //"rtarsal"
+	RE_LTARSAL=				0x00020000, //"ltarsal"
+	RE_RTALUS=				0x00040000, //"rtalus"
+	RE_LTALUS=				0x00080000, //"ltalus"
+	RE_RRADIUSX=			0x00100000, //"rradiusX"
+	RE_LRADIUSX=			0x00200000, //"lradiusX"
+	RE_RFEMURX=				0x00400000, //"rfemurX"
+	RE_LFEMURX=				0x00800000, //"lfemurX"
+	RE_CEYEBROW=			0x01000000 //"ceyebrow"
+};
+
+typedef struct
+{
+	vec3_t angles;
+	vec3_t position;
+	vec3_t scale;
+	vec3_t pelvisAnglesOffset;    // always set on return, an argument for RP_SET_PELVIS_OFFSET
+	vec3_t pelvisPositionOffset; // always set on return, an argument for RP_SET_PELVIS_OFFSET
+
+	float fImpactStrength; //should be applicable when RagPhase is RP_DEATH_COLLISION
+	float fShotStrength; //should be applicable for setting velocity of corpse on shot (probably only on RP_CORPSE_SHOT)
+	int me; //index of entity giving this update
+
+	//rww - we have convenient animation/frame access in the game, so just send this info over from there.
+	int startFrame;
+	int endFrame;
+
+	int collisionType; // 1 = from a fall, 0 from effectors, this will be going away soon, hence no enum 
+
+	qboolean CallRagDollBegin; // a return value, means that we are now begininng ragdoll and the NPC stuff needs to happen
+
+	int RagPhase;
+
+// effector control, used for RP_DISABLE_EFFECTORS call
+
+	int effectorsToTurnOff;  // set this to an | of the above flags for a RP_DISABLE_EFFECTORS
+
+} sharedRagDollParams_t;
+
+//And one for updating during model animation.
+typedef struct
+{
+	vec3_t angles;
+	vec3_t position;
+	vec3_t scale;
+	vec3_t velocity;
+	int	me;
+	int settleFrame;
+} sharedRagDollUpdateParams_t;
+
+//rww - update parms for ik bone stuff
+typedef struct
+{
+	char boneName[512]; //name of bone
+	vec3_t desiredOrigin; //world coordinate that this bone should be attempting to reach
+	vec3_t origin; //world coordinate of the entity who owns the g2 instance that owns the bone
+	float movementSpeed; //how fast the bone should move toward the destination
+} sharedIKMoveParams_t;
+
+
+typedef struct
+{
+	vec3_t pcjMins; //ik joint limit
+	vec3_t pcjMaxs; //ik joint limit
+	vec3_t origin; //origin of caller
+	vec3_t angles; //angles of caller
+	vec3_t scale; //scale of caller
+	float radius; //bone rad
+	int blendTime; //bone blend time
+	int pcjOverrides; //override ik bone flags
+	int startFrame; //base pose start
+	int endFrame; //base pose end
+	qboolean forceAnimOnBone; //normally if the bone has specified start/end frames already it will leave it alone.. if this is true, then the animation will be restarted on the bone with the specified frames anyway.
+} sharedSetBoneIKStateParams_t;
+
+enum sharedEIKMoveState
+{
+	IKS_NONE = 0,
+	IKS_DYNAMIC
+};
+
+//material stuff needs to be shared
+typedef enum //# material_e
+{
+	MAT_METAL = 0,	// scorched blue-grey metal
+	MAT_GLASS,		// not a real chunk type, just plays an effect with glass sprites
+	MAT_ELECTRICAL,	// sparks only
+	MAT_ELEC_METAL,	// sparks/electrical type metal
+	MAT_DRK_STONE,	// brown
+	MAT_LT_STONE,	// tan
+	MAT_GLASS_METAL,// glass sprites and METAl chunk
+	MAT_METAL2,		// electrical metal type
+	MAT_NONE,		// no chunks
+	MAT_GREY_STONE,	// grey
+	MAT_METAL3,		// METAL and METAL2 chunks
+	MAT_CRATE1,		// yellow multi-colored crate chunks
+	MAT_GRATE1,		// grate chunks
+	MAT_ROPE,		// for yavin trial...no chunks, just wispy bits
+	MAT_CRATE2,		// read multi-colored crate chunks
+	MAT_WHITE_METAL,// white angular chunks
+	MAT_SNOWY_ROCK,	// gray & brown chunks
+
+	NUM_MATERIALS
+
+};
+typedef int material_t;
+
+//rww - bot stuff that needs to be shared
+#define MAX_WPARRAY_SIZE 4096
+#define MAX_NEIGHBOR_SIZE 32
+
+#define MAX_NEIGHBOR_LINK_DISTANCE 128
+#define MAX_NEIGHBOR_FORCEJUMP_LINK_DISTANCE 400
+
+#define DEFAULT_GRID_SPACING 400
+
+typedef struct wpneighbor_s
+{
+	int num;
+	int forceJumpTo;
+} wpneighbor_t;
+
+typedef struct wpobject_s
+{
+	vec3_t origin;
+	int inuse;
+	int index;
+	float weight;
+	float disttonext;
+	int flags;
+	int associated_entity;
+
+	int forceJumpTo;
+
+	int neighbornum;
+	wpneighbor_t neighbors[MAX_NEIGHBOR_SIZE];
+} wpobject_t;
+
+
+#define NUMVERTEXNORMALS	162
+extern	vec3_t	bytedirs[NUMVERTEXNORMALS];
+
+// all drawing is done to a 640*480 virtual screen size
+// and will be automatically scaled to the real resolution
+#define	SCREEN_WIDTH		640
+#define	SCREEN_HEIGHT		480
+
+#define TINYCHAR_WIDTH		(SMALLCHAR_WIDTH)
+#define TINYCHAR_HEIGHT		(SMALLCHAR_HEIGHT/2)
+
+#define SMALLCHAR_WIDTH		8
+#define SMALLCHAR_HEIGHT	16
+
+#define BIGCHAR_WIDTH		16
+#define BIGCHAR_HEIGHT		16
+
+#define	GIANTCHAR_WIDTH		32
+#define	GIANTCHAR_HEIGHT	48
+
+typedef enum
+{
+CT_NONE,
+CT_BLACK,
+CT_RED,
+CT_GREEN,
+CT_BLUE,
+CT_YELLOW,
+CT_MAGENTA,
+CT_CYAN,
+CT_WHITE,
+CT_LTGREY,
+CT_MDGREY,
+CT_DKGREY,
+CT_DKGREY2,
+
+CT_VLTORANGE,
+CT_LTORANGE,
+CT_DKORANGE,
+CT_VDKORANGE,
+
+CT_VLTBLUE1,
+CT_LTBLUE1,
+CT_DKBLUE1,
+CT_VDKBLUE1,
+
+CT_VLTBLUE2,
+CT_LTBLUE2,
+CT_DKBLUE2,
+CT_VDKBLUE2,
+
+CT_VLTBROWN1,
+CT_LTBROWN1,
+CT_DKBROWN1,
+CT_VDKBROWN1,
+
+CT_VLTGOLD1,
+CT_LTGOLD1,
+CT_DKGOLD1,
+CT_VDKGOLD1,
+
+CT_VLTPURPLE1,
+CT_LTPURPLE1,
+CT_DKPURPLE1,
+CT_VDKPURPLE1,
+
+CT_VLTPURPLE2,
+CT_LTPURPLE2,
+CT_DKPURPLE2,
+CT_VDKPURPLE2,
+
+CT_VLTPURPLE3,
+CT_LTPURPLE3,
+CT_DKPURPLE3,
+CT_VDKPURPLE3,
+
+CT_VLTRED1,
+CT_LTRED1,
+CT_DKRED1,
+CT_VDKRED1,
+CT_VDKRED,
+CT_DKRED,
+
+CT_VLTAQUA,
+CT_LTAQUA,
+CT_DKAQUA,
+CT_VDKAQUA,
+
+CT_LTPINK,
+CT_DKPINK,
+CT_LTCYAN,
+CT_DKCYAN,
+CT_LTBLUE3,
+CT_BLUE3,
+CT_DKBLUE3,
+
+CT_HUD_GREEN,
+CT_HUD_RED,
+CT_ICON_BLUE,
+CT_NO_AMMO_RED,
+CT_HUD_ORANGE,
+
+CT_MAX
+} ct_table_t;
+
+extern vec4_t colorTable[CT_MAX];
+
+extern	vec4_t		colorBlack;
+extern	vec4_t		colorRed;
+extern	vec4_t		colorGreen;
+extern	vec4_t		colorBlue;
+extern	vec4_t		colorYellow;
+extern	vec4_t		colorMagenta;
+extern	vec4_t		colorCyan;
+extern	vec4_t		colorWhite;
+extern	vec4_t		colorLtGrey;
+extern	vec4_t		colorMdGrey;
+extern	vec4_t		colorDkGrey;
+extern	vec4_t		colorLtBlue;
+extern	vec4_t		colorDkBlue;
+
+#define Q_COLOR_ESCAPE	'^'
+// you MUST have the last bit on here about colour strings being less than 7 or taiwanese strings register as colour!!!!
+#define Q_IsColorString(p)	( p && *(p) == Q_COLOR_ESCAPE && *((p)+1) && *((p)+1) != Q_COLOR_ESCAPE && *((p)+1) <= '7' && *((p)+1) >= '0' )
+
+
+#define COLOR_BLACK		'0'
+#define COLOR_RED		'1'
+#define COLOR_GREEN		'2'
+#define COLOR_YELLOW	'3'
+#define COLOR_BLUE		'4'
+#define COLOR_CYAN		'5'
+#define COLOR_MAGENTA	'6'
+#define COLOR_WHITE		'7'
+#define ColorIndex(c)	( ( (c) - '0' ) & 7 )
+
+#define S_COLOR_BLACK	"^0"
+#define S_COLOR_RED		"^1"
+#define S_COLOR_GREEN	"^2"
+#define S_COLOR_YELLOW	"^3"
+#define S_COLOR_BLUE	"^4"
+#define S_COLOR_CYAN	"^5"
+#define S_COLOR_MAGENTA	"^6"
+#define S_COLOR_WHITE	"^7"
+
+extern vec4_t	g_color_table[8];
+
+#define	MAKERGB( v, r, g, b ) v[0]=r;v[1]=g;v[2]=b
+#define	MAKERGBA( v, r, g, b, a ) v[0]=r;v[1]=g;v[2]=b;v[3]=a
+
+#define DEG2RAD( a ) ( ( (a) * M_PI ) / 180.0F )
+#define RAD2DEG( a ) ( ( (a) * 180.0f ) / M_PI )
+
+struct cplane_s;
+
+extern	vec3_t	vec3_origin;
+extern	vec3_t	axisDefault[3];
+
+#define	nanmask (255<<23)
+
+#define	IS_NAN(x) (((*(int *)&x)&nanmask)==nanmask)
+
+#ifdef _XBOX
+inline void Q_CastShort2Float(float *f, const short *s)
+{
+	*f = ((float)*s);
+}
+
+inline void Q_CastUShort2Float(float *f, const unsigned short *s)
+{
+	*f = ((float)*s);
+}
+
+inline void Q_CastShort2FloatScale(float *f, const short *s, float scale)
+{
+	*f = ((float)*s) * scale;
+}
+
+inline void Q_CastUShort2FloatScale(float *f, const unsigned short *s, float scale)
+{
+	*f = ((float)*s) * scale;
+}
+#endif // _XBOX
+
+#if idppc
+
+static inline float Q_rsqrt( float number ) {
+		float x = 0.5f * number;
+                float y;
+#ifdef __GNUC__            
+                asm("frsqrte %0,%1" : "=f" (y) : "f" (number));
+#else
+		y = __frsqrte( number );
+#endif
+		return y * (1.5f - (x * y * y));
+	}
+
+#ifdef __GNUC__            
+static inline float Q_fabs(float x) {
+    float abs_x;
+    
+    asm("fabs %0,%1" : "=f" (abs_x) : "f" (x));
+    return abs_x;
+}
+#else
+#define Q_fabs __fabsf
+#endif
+
+#else
+float Q_fabs( float f );
+float Q_rsqrt( float f );		// reciprocal square root
+#endif
+
+#define SQRTFAST( x ) ( (x) * Q_rsqrt( x ) )
+
+signed char ClampChar( int i );
+signed short ClampShort( int i );
+
+float powf ( float x, int y );
+
+// this isn't a real cheap function to call!
+int DirToByte( vec3_t dir );
+void ByteToDir( int b, vec3_t dir );
+
+#ifdef _XBOX
+// SSE Vectorized math functions
+inline vec_t DotProduct( const vec3_t v1, const vec3_t v2 ) {
+#if defined (_XBOX)		/// use xbox stuff
+	float res;
+    __asm {
+        mov     edx, v1
+        movss   xmm1, [edx]
+        movhps  xmm1, [edx+4]
+
+        mov     edx, v2
+        movss   xmm2, [edx]
+        movhps  xmm2, [edx+4]
+
+        mulps   xmm1, xmm2
+
+        movaps  xmm0, xmm1
+
+        shufps  xmm0, xmm0, 32h
+        addps   xmm1, xmm0
+
+        shufps  xmm0, xmm0, 32h
+        addps   xmm1, xmm0
+
+        movss   [res], xmm1
+    }
+    return res;
+#else
+	return v1[0]*v2[0] + v1[1]*v2[1] + v1[2]*v2[2];
+#endif
+}
+
+inline void VectorSubtract( const vec3_t veca, const vec3_t vecb, vec3_t o ) {
+#ifdef _XBOX
+	__asm {
+        mov      ecx, veca
+        movss    xmm0, [ecx]
+        movhps   xmm0, [ecx+4]
+
+        mov      edx, vecb
+        movss    xmm1, [edx]
+        movhps   xmm1, [edx+4]
+
+        subps    xmm0, xmm1
+
+        mov      eax, o
+        movss    [eax], xmm0
+        movhps   [eax+4], xmm0
+    }
+#else
+	o[0] = veca[0]-vecb[0];
+	o[1] = veca[1]-vecb[1];
+	o[2] = veca[2]-vecb[2];
+#endif
+}
+
+inline void VectorAdd( const vec3_t veca, const vec3_t vecb, vec3_t o ) {
+#ifdef _XBOX
+  __asm {
+        mov      ecx, veca
+        movss    xmm0, [ecx]
+        movhps   xmm0, [ecx+4]
+
+        mov      edx, vecb
+        movss    xmm1, [edx]
+        movhps   xmm1, [edx+4]
+
+        addps    xmm0, xmm1
+
+        mov      eax, o
+        movss    [eax], xmm0
+        movhps   [eax+4], xmm0
+    }
+#else
+	o[0] = veca[0]+vecb[0];
+	o[1] = veca[1]+vecb[1];
+	o[2] = veca[2]+vecb[2];
+#endif
+}
+
+inline void VectorScale( const vec3_t i, vec_t scale, vec3_t o ) {
+#ifdef _XBOX
+__asm {
+        movss    xmm0, scale
+        shufps   xmm0, xmm0, 0h
+
+        mov      edx, i
+        movss    xmm1, [edx]
+        movhps   xmm1, [edx+4]
+
+        mulps    xmm0, xmm1
+
+        mov      eax, o
+        movss    [eax], xmm0
+        movhps   [eax+4], xmm0
+    }
+#else
+	o[0] = i[0]*scale;
+	o[1] = i[1]*scale;
+	o[2] = i[2]*scale;
+#endif
+}
+#endif	// _XBOX
+
+#if	1
+//rwwRMG - added math defines
+#define minimum(x,y) ((x)<(y)?(x):(y))
+#define maximum(x,y) ((x)>(y)?(x):(y))
+
+#ifndef _XBOX	// Done above to use SSE
+#define DotProduct(x,y)					((x)[0]*(y)[0]+(x)[1]*(y)[1]+(x)[2]*(y)[2])
+#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	VectorScale(v, s, o)			((o)[0]=(v)[0]*(s),(o)[1]=(v)[1]*(s),(o)[2]=(v)[2]*(s))
+#endif
+#define VectorCopy(a,b)					((b)[0]=(a)[0],(b)[1]=(a)[1],(b)[2]=(a)[2])
+#define VectorCopy4(a,b)				((b)[0]=(a)[0],(b)[1]=(a)[1],(b)[2]=(a)[2],(b)[3]=(a)[3])
+#define	VectorMA(v, s, b, o)			((o)[0]=(v)[0]+(b)[0]*(s),(o)[1]=(v)[1]+(b)[1]*(s),(o)[2]=(v)[2]+(b)[2]*(s))
+#define VectorInc(v)					((v)[0] += 1.0f,(v)[1] += 1.0f,(v)[2] +=1.0f)
+#define VectorDec(v)					((v)[0] -= 1.0f,(v)[1] -= 1.0f,(v)[2] -=1.0f)
+#define VectorInverseScaleVector(a,b,c)	((c)[0]=(a)[0]/(b)[0],(c)[1]=(a)[1]/(b)[1],(c)[2]=(a)[2]/(b)[2])
+#define VectorScaleVectorAdd(c,a,b,o)	((o)[0]=(c)[0]+((a)[0]*(b)[0]),(o)[1]=(c)[1]+((a)[1]*(b)[1]),(o)[2]=(c)[2]+((a)[2]*(b)[2]))
+#define VectorAdvance(a,s,b,c)			(((c)[0]=(a)[0] + s * ((b)[0] - (a)[0])),((c)[1]=(a)[1] + s * ((b)[1] - (a)[1])),((c)[2]=(a)[2] + s * ((b)[2] - (a)[2])))
+#define VectorAverage(a,b,c)			(((c)[0]=((a)[0]+(b)[0])*0.5f),((c)[1]=((a)[1]+(b)[1])*0.5f),((c)[2]=((a)[2]+(b)[2])*0.5f))
+#define VectorScaleVector(a,b,c)		(((c)[0]=(a)[0]*(b)[0]),((c)[1]=(a)[1]*(b)[1]),((c)[2]=(a)[2]*(b)[2]))
+
+#else
+
+#define DotProduct(x,y)			_DotProduct(x,y)
+#define VectorSubtract(a,b,c)	_VectorSubtract(a,b,c)
+#define VectorAdd(a,b,c)		_VectorAdd(a,b,c)
+#define VectorCopy(a,b)			_VectorCopy(a,b)
+#define	VectorScale(v, s, o)	_VectorScale(v,s,o)
+#define	VectorMA(v, s, b, o)	_VectorMA(v,s,b,o)
+
+#endif
+
+#ifdef __LCC__
+#ifdef VectorCopy
+#undef VectorCopy
+// this is a little hack to get more efficient copies in our interpreter
+typedef struct {
+	float	v[3];
+} vec3struct_t;
+#define VectorCopy(a,b)	*(vec3struct_t *)b=*(vec3struct_t *)a;
+#define ID_INLINE static
+#endif
+#endif
+
+#define VectorClear(a)			((a)[0]=(a)[1]=(a)[2]=0)
+#define VectorNegate(a,b)		((b)[0]=-(a)[0],(b)[1]=-(a)[1],(b)[2]=-(a)[2])
+#define VectorSet(v, x, y, z)	((v)[0]=(x), (v)[1]=(y), (v)[2]=(z))
+#define VectorSet5(v,x,y,z,a,b)	((v)[0]=(x), (v)[1]=(y), (v)[2]=(z), (v)[3]=(a), (v)[4]=(b)) //rwwRMG - added
+#define Vector4Copy(a,b)		((b)[0]=(a)[0],(b)[1]=(a)[1],(b)[2]=(a)[2],(b)[3]=(a)[3])
+
+#ifndef __linux2__
+#ifndef __LCC__
+//pitiful attempt to reduce _ftol2 calls -rww
+static ID_INLINE void SnapVector( float *v )
+{
+	static int i;
+	static float f;
+
+	f = *v;
+	__asm	fld		f;
+	__asm	fistp	i;
+	*v = i;
+	v++;
+	f = *v;
+	__asm	fld		f;
+	__asm	fistp	i;
+	*v = i;
+	v++;
+	f = *v;
+	__asm	fld		f;
+	__asm	fistp	i;
+	*v = i;
+}
+#else
+#define	SnapVector(v) {v[0]=((int)(v[0]));v[1]=((int)(v[1]));v[2]=((int)(v[2]));}
+#endif
+#endif // __linux__
+// just in case you do't want to use the macros
+vec_t _DotProduct( const vec3_t v1, const vec3_t v2 );
+void _VectorSubtract( const vec3_t veca, const vec3_t vecb, vec3_t out );
+void _VectorAdd( const vec3_t veca, const vec3_t vecb, vec3_t out );
+void _VectorCopy( const vec3_t in, vec3_t out );
+void _VectorScale( const vec3_t in, float scale, vec3_t out );
+void _VectorMA( const vec3_t veca, float scale, const vec3_t vecb, vec3_t vecc );
+
+unsigned ColorBytes3 (float r, float g, float b);
+unsigned ColorBytes4 (float r, float g, float b, float a);
+
+float NormalizeColor( const vec3_t in, vec3_t out );
+
+float RadiusFromBounds( const vec3_t mins, const vec3_t maxs );
+void ClearBounds( vec3_t mins, vec3_t maxs );
+vec_t DistanceHorizontal( const vec3_t p1, const vec3_t p2 );
+vec_t DistanceHorizontalSquared( const vec3_t p1, const vec3_t p2 );
+void AddPointToBounds( const vec3_t v, vec3_t mins, vec3_t maxs );
+
+#ifndef __LCC__
+static ID_INLINE int VectorCompare( const vec3_t v1, const vec3_t v2 ) {
+	if (v1[0] != v2[0] || v1[1] != v2[1] || v1[2] != v2[2]) {
+		return 0;
+	}			
+	return 1;
+}
+
+static ID_INLINE vec_t VectorLength( const vec3_t v ) {
+#ifdef _XBOX
+	float res;
+
+	__asm {
+        mov     edx, v
+        movss   xmm1, [edx]
+        movhps  xmm1, [edx+4]
+
+        movaps  xmm2, xmm1
+
+        mulps   xmm1, xmm2
+
+        movaps  xmm0, xmm1
+
+        shufps  xmm0, xmm0, 32h
+        addps   xmm1, xmm0
+
+        shufps  xmm0, xmm0, 32h
+        addps   xmm1, xmm0
+
+        sqrtss  xmm1, xmm1
+        movss   [res], xmm1
+    }
+
+    return res;
+#else
+	return (vec_t)sqrt (v[0]*v[0] + v[1]*v[1] + v[2]*v[2]);
+#endif
+}
+
+static ID_INLINE vec_t VectorLengthSquared( const vec3_t v ) {
+#ifdef _XBOX
+	float res;
+	__asm {
+        mov     edx, v
+        movss   xmm1, [edx]
+        movhps  xmm1, [edx+4]
+
+        movaps  xmm2, xmm1
+
+        mulps   xmm1, xmm2
+
+        movaps  xmm0, xmm1
+
+        shufps  xmm0, xmm0, 32h
+        addps   xmm1, xmm0
+
+        shufps  xmm0, xmm0, 32h
+        addps   xmm1, xmm0
+
+        movss   [res], xmm1
+    }
+
+    return res;
+#else
+	return (v[0]*v[0] + v[1]*v[1] + v[2]*v[2]);
+#endif
+}
+
+static ID_INLINE vec_t Distance( const vec3_t p1, const vec3_t p2 ) {
+	vec3_t	v;
+
+	VectorSubtract (p2, p1, v);
+	return VectorLength( v );
+}
+
+static ID_INLINE vec_t DistanceSquared( const vec3_t p1, const vec3_t p2 ) {
+	vec3_t	v;
+
+	VectorSubtract (p2, p1, v);
+	return v[0]*v[0] + v[1]*v[1] + v[2]*v[2];
+}
+
+// fast vector normalize routine that does not check to make sure
+// that length != 0, nor does it return length, uses rsqrt approximation
+static ID_INLINE void VectorNormalizeFast( vec3_t v )
+{
+	float ilength;
+
+	ilength = Q_rsqrt( DotProduct( v, v ) );
+
+	v[0] *= ilength;
+	v[1] *= ilength;
+	v[2] *= ilength;
+}
+
+static ID_INLINE void VectorInverse( vec3_t v ){
+	v[0] = -v[0];
+	v[1] = -v[1];
+	v[2] = -v[2];
+}
+
+static ID_INLINE void CrossProduct( const vec3_t v1, const vec3_t v2, vec3_t cross ) {
+	cross[0] = v1[1]*v2[2] - v1[2]*v2[1];
+	cross[1] = v1[2]*v2[0] - v1[0]*v2[2];
+	cross[2] = v1[0]*v2[1] - v1[1]*v2[0];
+}
+
+#else
+int VectorCompare( const vec3_t v1, const vec3_t v2 );
+
+vec_t VectorLength( const vec3_t v );
+
+vec_t VectorLengthSquared( const vec3_t v );
+
+vec_t Distance( const vec3_t p1, const vec3_t p2 );
+
+vec_t DistanceSquared( const vec3_t p1, const vec3_t p2 );
+ 
+void VectorNormalizeFast( vec3_t v );
+
+void VectorInverse( vec3_t v );
+
+void CrossProduct( const vec3_t v1, const vec3_t v2, vec3_t cross );
+
+#endif
+
+vec_t VectorNormalize (vec3_t v);		// returns vector length
+vec_t VectorNormalize2( const vec3_t v, vec3_t out );
+void Vector4Scale( const vec4_t in, vec_t scale, vec4_t out );
+void VectorRotate( vec3_t in, vec3_t matrix[3], vec3_t out );
+int Q_log2(int val);
+
+float Q_acos(float c);
+float Q_asin(float c);
+
+int		Q_rand( int *seed );
+float	Q_random( int *seed );
+float	Q_crandom( int *seed );
+
+#define random()	((rand () & 0x7fff) / ((float)0x7fff))
+#define crandom()	(2.0 * (random() - 0.5))
+
+void vectoangles( const vec3_t value1, vec3_t angles);
+void AnglesToAxis( const vec3_t angles, vec3_t axis[3] );
+
+void AxisClear( vec3_t axis[3] );
+void AxisCopy( vec3_t in[3], vec3_t out[3] );
+
+void SetPlaneSignbits( struct cplane_s *out );
+int BoxOnPlaneSide (vec3_t emins, vec3_t emaxs, struct cplane_s *plane);
+
+double	fmod( double x, double y );
+float	AngleMod(float a);
+float	LerpAngle (float from, float to, float frac);
+float	AngleSubtract( float a1, float a2 );
+void	AnglesSubtract( vec3_t v1, vec3_t v2, vec3_t v3 );
+
+float AngleNormalize360 ( float angle );
+float AngleNormalize180 ( float angle );
+float AngleDelta ( float angle1, float angle2 );
+
+qboolean PlaneFromPoints( vec4_t plane, const vec3_t a, const vec3_t b, const vec3_t c );
+void ProjectPointOnPlane( vec3_t dst, const vec3_t p, const vec3_t normal );
+void RotatePointAroundVector( vec3_t dst, const vec3_t dir, const vec3_t point, float degrees );
+void RotateAroundDirection( vec3_t axis[3], float yaw );
+void MakeNormalVectors( const vec3_t forward, vec3_t right, vec3_t up );
+// perpendicular vector could be replaced by this
+
+//int	PlaneTypeForNormal (vec3_t normal);
+
+void MatrixMultiply(float in1[3][3], float in2[3][3], float out[3][3]);
+void AngleVectors( const vec3_t angles, vec3_t forward, vec3_t right, vec3_t up);
+void PerpendicularVector( vec3_t dst, const vec3_t src );
+void NormalToLatLong( const vec3_t normal, byte bytes[2] ); //rwwRMG - added
+
+//=============================================
+
+int Com_Clampi( int min, int max, int value ); //rwwRMG - added
+float Com_Clamp( float min, float max, float value );
+
+char	*COM_SkipPath( char *pathname );
+void	COM_StripExtension( const char *in, char *out );
+void	COM_DefaultExtension( char *path, int maxSize, const char *extension );
+
+void	COM_BeginParseSession( const char *name );
+int		COM_GetCurrentParseLine( void );
+const char	*SkipWhitespace( const char *data, qboolean *hasNewLines );
+char	*COM_Parse( const char **data_p );
+char	*COM_ParseExt( const char **data_p, qboolean allowLineBreak );
+int		COM_Compress( char *data_p );
+void	COM_ParseError( char *format, ... );
+void	COM_ParseWarning( char *format, ... );
+qboolean COM_ParseString( const char **data, const char **s );
+qboolean COM_ParseInt( const char **data, int *i );
+qboolean COM_ParseFloat( const char **data, float *f );
+qboolean COM_ParseVec4( const char **buffer, vec4_t *c);
+//int		COM_ParseInfos( char *buf, int max, char infos[][MAX_INFO_STRING] );
+
+#define MAX_TOKENLENGTH		1024
+
+#ifndef TT_STRING
+//token types
+#define TT_STRING					1			// string
+#define TT_LITERAL					2			// literal
+#define TT_NUMBER					3			// number
+#define TT_NAME						4			// name
+#define TT_PUNCTUATION				5			// punctuation
+#endif
+
+typedef struct pc_token_s
+{
+	int type;
+	int subtype;
+	int intvalue;
+	float floatvalue;
+	char string[MAX_TOKENLENGTH];
+} pc_token_t;
+
+// data is an in/out parm, returns a parsed out token
+
+void	COM_MatchToken( const char**buf_p, char *match );
+
+void SkipBracedSection (const char **program);
+void SkipRestOfLine ( const char **data );
+
+void Parse1DMatrix (const char **buf_p, int x, float *m);
+void Parse2DMatrix (const char **buf_p, int y, int x, float *m);
+void Parse3DMatrix (const char **buf_p, int z, int y, int x, float *m);
+
+void	QDECL Com_sprintf (char *dest, int size, const char *fmt, ...);
+
+
+// mode parm for FS_FOpenFile
+typedef enum {
+	FS_READ,
+	FS_WRITE,
+	FS_APPEND,
+	FS_APPEND_SYNC
+} fsMode_t;
+
+typedef enum {
+	FS_SEEK_CUR,
+	FS_SEEK_END,
+	FS_SEEK_SET
+} fsOrigin_t;
+
+//=============================================
+
+int Q_isprint( int c );
+int Q_islower( int c );
+int Q_isupper( int c );
+int Q_isalpha( int c );
+
+// portable case insensitive compare
+int		Q_stricmp (const char *s1, const char *s2);
+int		Q_strncmp (const char *s1, const char *s2, int n);
+int		Q_stricmpn (const char *s1, const char *s2, int n);
+char	*Q_strlwr( char *s1 );
+char	*Q_strupr( char *s1 );
+char	*Q_strrchr( const char* string, int c );
+
+// buffer size safe library replacements
+void	Q_strncpyz( char *dest, const char *src, int destsize );
+void	Q_strcat( char *dest, int size, const char *src );
+
+// strlen that discounts Quake color sequences
+int Q_PrintStrlen( const char *string );
+// removes color sequences from string
+char *Q_CleanStr( char *string );
+
+//=============================================
+
+// 64-bit integers for global rankings interface
+// implemented as a struct for qvm compatibility
+typedef struct
+{
+	byte	b0;
+	byte	b1;
+	byte	b2;
+	byte	b3;
+	byte	b4;
+	byte	b5;
+	byte	b6;
+	byte	b7;
+} qint64;
+
+//=============================================
+/*
+short	BigShort(short l);
+short	LittleShort(short l);
+int		BigLong (int l);
+int		LittleLong (int l);
+qint64  BigLong64 (qint64 l);
+qint64  LittleLong64 (qint64 l);
+float	BigFloat (const float *l);
+float	LittleFloat (const float *l);
+
+void	Swap_Init (void);
+*/
+char	* QDECL va(const char *format, ...);
+
+//=============================================
+
+//
+// key / value info strings
+//
+char *Info_ValueForKey( const char *s, const char *key );
+void Info_RemoveKey( char *s, const char *key );
+void Info_RemoveKey_big( char *s, const char *key );
+void Info_SetValueForKey( char *s, const char *key, const char *value );
+void Info_SetValueForKey_Big( char *s, const char *key, const char *value );
+qboolean Info_Validate( const char *s );
+void Info_NextPair( const char **s, char *key, char *value );
+
+// this is only here so the functions in q_shared.c and bg_*.c can link
+void	QDECL Com_Error( int level, const char *error, ... );
+void	QDECL Com_Printf( const char *msg, ... );
+
+
+/*
+==========================================================
+
+CVARS (console variables)
+
+Many variables can be used for cheating purposes, so when
+cheats is zero, force all unspecified variables to their
+default values.
+==========================================================
+*/
+
+#define	CVAR_ARCHIVE		0x00000001		// set to cause it to be saved to vars.rc
+											// used for system variables, not for player
+											// specific configurations
+#define	CVAR_USERINFO		0x00000002		// sent to server on connect or change
+#define	CVAR_SERVERINFO		0x00000004		// sent in response to front end requests
+#define	CVAR_SYSTEMINFO		0x00000008		// these cvars will be duplicated on all clients
+#define	CVAR_INIT			0x00000010		// don't allow change from console at all,
+											// but can be set from the command line
+#define	CVAR_LATCH			0x00000020		// will only change when C code next does
+											// a Cvar_Get(), so it can't be changed
+											// without proper initialization.  modified
+											// will be set, even though the value hasn't
+											// changed yet
+#define	CVAR_ROM			0x00000040		// display only, cannot be set by user at all (can be set by code)
+#define	CVAR_USER_CREATED	0x00000080		// created by a set command
+#define	CVAR_TEMP			0x00000100		// can be set even when cheats are disabled, but is not archived
+#define CVAR_CHEAT			0x00000200		// can not be changed if cheats are disabled
+#define CVAR_NORESTART		0x00000400		// do not clear when a cvar_restart is issued
+#define CVAR_INTERNAL		0x00000800		// cvar won't be displayed, ever (for passwords and such)
+#define	CVAR_PARENTAL		0x00001000		// lets cvar system know that parental stuff needs to be updated
+
+// nothing outside the Cvar_*() functions should modify these fields!
+typedef struct cvar_s {
+	char		*name;
+	char		*string;
+	char		*resetString;		// cvar_restart will reset to this value
+	char		*latchedString;		// for CVAR_LATCH vars
+	int			flags;
+	qboolean	modified;			// set each time the cvar is changed
+	int			modificationCount;	// incremented each time the cvar is changed
+	float		value;				// atof( string )
+	int			integer;			// atoi( string )
+	struct cvar_s *next;
+	struct cvar_s *hashNext;
+} cvar_t;
+
+#define	MAX_CVAR_VALUE_STRING	256
+
+typedef int	cvarHandle_t;
+
+// the modules that run in the virtual machine can't access the cvar_t directly,
+// so they must ask for structured updates
+typedef struct {
+	cvarHandle_t	handle;
+	int			modificationCount;
+	float		value;
+	int			integer;
+	char		string[MAX_CVAR_VALUE_STRING];
+} vmCvar_t;
+
+/*
+==============================================================
+
+COLLISION DETECTION
+
+==============================================================
+*/
+
+#include "surfaceflags.h"			// shared with the q3map utility
+
+// plane types are used to speed some tests
+// 0-2 are axial planes
+#define	PLANE_X			0
+#define	PLANE_Y			1
+#define	PLANE_Z			2
+#define	PLANE_NON_AXIAL	3
+
+
+/*
+=================
+PlaneTypeForNormal
+=================
+*/
+
+#define PlaneTypeForNormal(x) (x[0] == 1.0 ? PLANE_X : (x[1] == 1.0 ? PLANE_Y : (x[2] == 1.0 ? PLANE_Z : PLANE_NON_AXIAL) ) )
+
+// plane_t structure
+// !!! if this is changed, it must be changed in asm code too !!!
+typedef struct cplane_s {
+	vec3_t	normal;
+	float	dist;
+	byte	type;			// for fast side tests: 0,1,2 = axial, 3 = nonaxial
+	byte	signbits;		// signx + (signy<<1) + (signz<<2), used as lookup during collision
+	byte	pad[2];
+} cplane_t;
+/*
+Ghoul2 Insert Start
+*/
+typedef struct
+{
+	float		mDistance;
+	int			mEntityNum;
+	int			mModelIndex;
+	int			mPolyIndex;
+	int			mSurfaceIndex;
+	vec3_t		mCollisionPosition;
+	vec3_t		mCollisionNormal;
+	int			mFlags;
+	int			mMaterial;
+	int			mLocation;
+	float		mBarycentricI; // two barycentic coodinates for the hit point
+	float		mBarycentricJ; // K = 1-I-J
+}CollisionRecord_t;
+
+#define MAX_G2_COLLISIONS 16
+
+typedef CollisionRecord_t G2Trace_t[MAX_G2_COLLISIONS];	// map that describes all of the parts of ghoul2 models that got hit
+
+/*
+Ghoul2 Insert End
+*/
+// a trace is returned when a box is swept through the world
+typedef struct {
+	byte		allsolid;	// if true, plane is not valid
+	byte		startsolid;	// if true, the initial point was in a solid area
+	short		entityNum;	// entity the contacted sirface is a part of
+
+	float		fraction;	// time completed, 1.0 = didn't hit anything
+	vec3_t		endpos;		// final position
+	cplane_t	plane;		// surface normal at impact, transformed to world space
+	int			surfaceFlags;	// surface hit
+	int			contents;	// contents on other side of surface hit
+/*
+Ghoul2 Insert Start
+*/
+	//rww - removed this for now, it's just wasting space in the trace structure.
+//	CollisionRecord_t G2CollisionMap[MAX_G2_COLLISIONS];	// map that describes all of the parts of ghoul2 models that got hit
+/*
+Ghoul2 Insert End
+*/
+} trace_t;
+
+// trace->entityNum can also be 0 to (MAX_GENTITIES-1)
+// or ENTITYNUM_NONE, ENTITYNUM_WORLD
+
+
+// markfragments are returned by CM_MarkFragments()
+typedef struct {
+	int		firstPoint;
+	int		numPoints;
+} markFragment_t;
+
+
+
+typedef struct {
+	vec3_t		origin;
+	vec3_t		axis[3];
+} orientation_t;
+
+//=====================================================================
+
+
+// in order from highest priority to lowest
+// if none of the catchers are active, bound key strings will be executed
+#define KEYCATCH_CONSOLE		0x0001
+#define	KEYCATCH_UI					0x0002
+#define	KEYCATCH_MESSAGE		0x0004
+#define	KEYCATCH_CGAME			0x0008
+
+
+// sound channels
+// channel 0 never willingly overrides
+// other channels will allways override a playing sound on that channel
+typedef enum {
+	CHAN_AUTO,	//## %s !!"W:\game\base\!!sound\*.wav;*.mp3" # Auto-picks an empty channel to play sound on
+	CHAN_LOCAL,	//## %s !!"W:\game\base\!!sound\*.wav;*.mp3" # menu sounds, etc
+	CHAN_WEAPON,//## %s !!"W:\game\base\!!sound\*.wav;*.mp3" 
+	CHAN_VOICE, //## %s !!"W:\game\base\!!sound\voice\*.wav;*.mp3" # Voice sounds cause mouth animation
+	CHAN_VOICE_ATTEN, //## %s !!"W:\game\base\!!sound\voice\*.wav;*.mp3" # Causes mouth animation but still use normal sound falloff 
+	CHAN_ITEM,  //## %s !!"W:\game\base\!!sound\*.wav;*.mp3"
+	CHAN_BODY,	//## %s !!"W:\game\base\!!sound\*.wav;*.mp3"
+	CHAN_AMBIENT,//## %s !!"W:\game\base\!!sound\*.wav;*.mp3" # added for ambient sounds
+	CHAN_LOCAL_SOUND,	//## %s !!"W:\game\base\!!sound\*.wav;*.mp3" #chat messages, etc
+	CHAN_ANNOUNCER,		//## %s !!"W:\game\base\!!sound\*.wav;*.mp3" #announcer voices, etc
+	CHAN_LESS_ATTEN,	//## %s !!"W:\game\base\!!sound\*.wav;*.mp3" #attenuates similar to chan_voice, but uses empty channel auto-pick behaviour
+	CHAN_MENU1,		//## %s !!"W:\game\base\!!sound\*.wav;*.mp3" #menu stuff, etc
+	CHAN_VOICE_GLOBAL,  //## %s !!"W:\game\base\!!sound\voice\*.wav;*.mp3" # Causes mouth animation and is broadcast, like announcer
+	CHAN_MUSIC,	//## %s !!"W:\game\base\!!sound\*.wav;*.mp3" #music played as a looping sound - added by BTO (VV)
+};
+typedef int soundChannel_t;
+
+
+/*
+========================================================================
+
+  ELEMENTS COMMUNICATED ACROSS THE NET
+
+========================================================================
+*/
+
+#define	ANGLE2SHORT(x)	((int)((x)*65536/360) & 65535)
+#define	SHORT2ANGLE(x)	((x)*(360.0/65536))
+
+#define	SNAPFLAG_RATE_DELAYED	1
+#define	SNAPFLAG_NOT_ACTIVE		2	// snapshot used during connection and for zombies
+#define SNAPFLAG_SERVERCOUNT	4	// toggled every map_restart so transitions can be detected
+
+//
+// per-level limits
+//
+#ifdef _XBOX
+#define MAX_CLIENTS			16
+#else
+#define	MAX_CLIENTS			32		// absolute limit
+#endif
+#define MAX_RADAR_ENTITIES	MAX_GENTITIES
+#define MAX_TERRAINS		1//32 //rwwRMG: inserted
+#define MAX_LOCATIONS		64
+
+#ifdef _XBOX
+#define	GENTITYNUM_BITS	9		// don't need to send any more
+#else
+#define	GENTITYNUM_BITS	10		// don't need to send any more
+#endif
+#define	MAX_GENTITIES	(1<<GENTITYNUM_BITS)
+
+//I am reverting. I guess. For now.
+/*
+#define	GENTITYNUM_BITS		11
+							//rww - I am raising this 1 bit. SP actually has room for 1024 ents - none - world - 1 client.
+							//Which means 1021 useable entities. However we have 32 clients.. so if we keep our limit
+							//at 1024 we are not going to be able to load any SP levels at the edge of the ent limit.
+#define		MAX_GENTITIES	(1024+(MAX_CLIENTS-1))
+							//rww - we do have enough room to send over 2048 ents now. However, I cannot live with the guilt of
+							//actually increasing the entity limit to 2048 (as it would slow down countless things, and
+							//there are tons of ent list traversals all over the place). So I am merely going to give enough
+							//to compensate for our larger maxclients.
+*/
+
+// entitynums are communicated with GENTITY_BITS, so any reserved
+// values thatare going to be communcated over the net need to
+// also be in this range
+#define	ENTITYNUM_NONE		(MAX_GENTITIES-1)
+#define	ENTITYNUM_WORLD		(MAX_GENTITIES-2)
+#define	ENTITYNUM_MAX_NORMAL	(MAX_GENTITIES-2)
+
+
+// these are also in be_aas_def.h - argh (rjr)
+#define	MAX_MODELS			512		// these are sent over the net as -12 bits
+#define	MAX_SOUNDS			256		// so they cannot be blindly increased
+#define MAX_ICONS			64		// max registered icons you can have per map 
+#define MAX_FX				64		// max effects strings, I'm hoping that 64 will be plenty
+
+#define MAX_SUB_BSP			32 //rwwRMG - added
+
+/*
+Ghoul2 Insert Start
+*/
+#define	MAX_G2BONES		64		//rww - changed from MAX_CHARSKINS to MAX_G2BONES. value still equal.
+/*
+Ghoul2 Insert End
+*/
+
+#define MAX_AMBIENT_SETS		256 //rww - ambient soundsets must be sent over in config strings.
+
+#define	MAX_CONFIGSTRINGS	1700 //this is getting pretty high. Try not to raise it anymore than it already is.
+
+// these are the only configstrings that the system reserves, all the
+// other ones are strictly for servergame to clientgame communication
+#define	CS_SERVERINFO		0		// an info string with all the serverinfo cvars
+#define	CS_SYSTEMINFO		1		// an info string for server system to client system configuration (timescale, etc)
+
+#define	RESERVED_CONFIGSTRINGS	2	// game can't modify below this, only the system can
+
+#define	MAX_GAMESTATE_CHARS	16000
+typedef struct {
+	int			stringOffsets[MAX_CONFIGSTRINGS];
+	char		stringData[MAX_GAMESTATE_CHARS];
+	int			dataCount;
+} gameState_t;
+
+//=========================================================
+
+// all the different tracking "channels"
+typedef enum {
+	TRACK_CHANNEL_NONE = 50,
+	TRACK_CHANNEL_1,
+	TRACK_CHANNEL_2,
+	TRACK_CHANNEL_3,
+	TRACK_CHANNEL_4,
+	TRACK_CHANNEL_5,
+	NUM_TRACK_CHANNELS
+} trackchan_t;
+
+#define TRACK_CHANNEL_MAX (NUM_TRACK_CHANNELS-50)
+
+typedef struct forcedata_s {
+	int			forcePowerDebounce[NUM_FORCE_POWERS];	//for effects that must have an interval
+	int			forcePowersKnown;
+	int			forcePowersActive;
+	int			forcePowerSelected;
+	int			forceButtonNeedRelease;
+	int			forcePowerDuration[NUM_FORCE_POWERS];
+	int			forcePower;
+	int			forcePowerMax;
+	int			forcePowerRegenDebounceTime;
+	int			forcePowerLevel[NUM_FORCE_POWERS];		//so we know the max forceJump power you have
+	int			forcePowerBaseLevel[NUM_FORCE_POWERS];
+	int			forceUsingAdded;
+	float		forceJumpZStart;					//So when you land, you don't get hurt as much
+	float		forceJumpCharge;					//you're current forceJump charge-up level, increases the longer you hold the force jump button down
+	int			forceJumpSound;
+	int			forceJumpAddTime;
+	int			forceGripEntityNum;					//what entity I'm gripping
+	int			forceGripDamageDebounceTime;		//debounce for grip damage
+	float		forceGripBeingGripped;				//if > level.time then client is in someone's grip
+	int			forceGripCripple;					//if != 0 then make it so this client can't move quickly (he's being gripped)
+	int			forceGripUseTime;					//can't use if > level.time
+	float		forceGripSoundTime;
+	float		forceGripStarted;					//level.time when the grip was activated
+	int			forceHealTime;
+	int			forceHealAmount;
+
+	//This hurts me somewhat to do, but there's no other real way to allow completely "dynamic" mindtricking.
+	int			forceMindtrickTargetIndex; //0-15
+	int			forceMindtrickTargetIndex2; //16-32
+	int			forceMindtrickTargetIndex3; //33-48
+	int			forceMindtrickTargetIndex4; //49-64
+
+	int			forceRageRecoveryTime;
+	int			forceDrainEntNum;
+	float		forceDrainTime;
+
+	int			forceDoInit;
+
+	int			forceSide;
+	int			forceRank;
+
+	int			forceDeactivateAll;
+
+	int			killSoundEntIndex[TRACK_CHANNEL_MAX]; //this goes here so it doesn't get wiped over respawn
+
+	qboolean	sentryDeployed;
+
+	int			saberAnimLevelBase;//sigh...
+	int			saberAnimLevel;
+	int			saberDrawAnimLevel;
+
+	int			suicides;
+
+	int			privateDuelTime;
+} forcedata_t;
+
+
+typedef enum {
+	SENTRY_NOROOM = 1,
+	SENTRY_ALREADYPLACED,
+	SHIELD_NOROOM,
+	SEEKER_ALREADYDEPLOYED
+} itemUseFail_t;
+
+// bit field limits
+#define	MAX_STATS				16
+#define	MAX_PERSISTANT			16
+#define	MAX_POWERUPS			16
+#define	MAX_WEAPONS				19		
+
+#define	MAX_PS_EVENTS			2
+
+#define PS_PMOVEFRAMECOUNTBITS	6
+
+#define FORCE_LIGHTSIDE			1
+#define FORCE_DARKSIDE			2
+
+#define MAX_FORCE_RANK			7
+
+#define FALL_FADE_TIME			3000
+
+//#define _ONEBIT_COMBO
+//Crazy optimization attempt to take all those 1 bit values and shove them into a single
+//send. May help us not have to send so many 1/0 bits to acknowledge modified values. -rww
+
+#define _OPTIMIZED_VEHICLE_NETWORKING
+//Instead of sending 2 full playerStates for the pilot and the vehicle, send a smaller,
+//specialized pilot playerState and vehicle playerState.  Also removes some vehicle
+//fields from the normal playerState -mcg
+
+// playerState_t is the information needed by both the client and server
+// to predict player motion and actions
+// nothing outside of pmove should modify these, or some degree of prediction error
+// will occur
+
+// you can't add anything to this without modifying the code in msg.c
+
+// playerState_t is a full superset of entityState_t as it is used by players,
+// so if a playerState_t is transmitted, the entityState_t can be fully derived
+// from it.
+typedef struct playerState_s {
+	int			commandTime;	// cmd->serverTime of last executed command
+	int			pm_type;
+	int			bobCycle;		// for view bobbing and footstep generation
+	int			pm_flags;		// ducked, jump_held, etc
+	int			pm_time;
+
+	vec3_t		origin;
+	vec3_t		velocity;
+
+	vec3_t		moveDir; //NOT sent over the net - nor should it be.
+
+	int			weaponTime;
+	int			weaponChargeTime;
+	int			weaponChargeSubtractTime;
+	int			gravity;
+	float		speed;
+	int			basespeed; //used in prediction to know base server g_speed value when modifying speed between updates
+	int			delta_angles[3];	// add to command angles to get view direction
+									// changed by spawns, rotating objects, and teleporters
+
+	int			slopeRecalcTime; //this is NOT sent across the net and is maintained seperately on game and cgame in pmove code.
+
+	int			useTime;
+
+	int			groundEntityNum;// ENTITYNUM_NONE = in air
+
+	int			legsTimer;		// don't change low priority animations until this runs out
+	int			legsAnim;
+
+	int			torsoTimer;		// don't change low priority animations until this runs out
+	int			torsoAnim;
+
+	qboolean	legsFlip; //set to opposite when the same anim needs restarting, sent over in only 1 bit. Cleaner and makes porting easier than having that god forsaken ANIM_TOGGLEBIT.
+	qboolean	torsoFlip;
+
+	int			movementDir;	// a number 0 to 7 that represents the reletive angle
+								// of movement to the view angle (axial and diagonals)
+								// when at rest, the value will remain unchanged
+								// used to twist the legs during strafing
+
+	int			eFlags;			// copied to entityState_t->eFlags
+	int			eFlags2;		// copied to entityState_t->eFlags2, EF2_??? used much less frequently
+
+	int			eventSequence;	// pmove generated events
+	int			events[MAX_PS_EVENTS];
+	int			eventParms[MAX_PS_EVENTS];
+
+	int			externalEvent;	// events set on player from another source
+	int			externalEventParm;
+	int			externalEventTime;
+
+	int			clientNum;		// ranges from 0 to MAX_CLIENTS-1
+	int			weapon;			// copied to entityState_t->weapon
+	int			weaponstate;
+
+	vec3_t		viewangles;		// for fixed views
+	int			viewheight;
+
+	// damage feedback
+	int			damageEvent;	// when it changes, latch the other parms
+	int			damageYaw;
+	int			damagePitch;
+	int			damageCount;
+	int			damageType;
+
+	int			painTime;		// used for both game and client side to process the pain twitch - NOT sent across the network
+	int			painDirection;	// NOT sent across the network
+	float		yawAngle;		// NOT sent across the network
+	qboolean	yawing;			// NOT sent across the network
+	float		pitchAngle;		// NOT sent across the network
+	qboolean	pitching;		// NOT sent across the network
+
+	int			stats[MAX_STATS];
+	int			persistant[MAX_PERSISTANT];	// stats that aren't cleared on death
+	int			powerups[MAX_POWERUPS];	// level.time that the powerup runs out
+	int			ammo[MAX_WEAPONS];
+
+	int			generic1;
+	int			loopSound;
+	int			jumppad_ent;	// jumppad entity hit this frame
+
+	// not communicated over the net at all
+	int			ping;			// server to game info for scoreboard
+	int			pmove_framecount;	// FIXME: don't transmit over the network
+	int			jumppad_frame;
+	int			entityEventSequence;
+
+	int			lastOnGround;	//last time you were on the ground
+
+	qboolean	saberInFlight;
+
+	int			saberMove;
+	int			saberBlocking;
+	int			saberBlocked;
+
+	int			saberLockTime;
+	int			saberLockEnemy;
+	int			saberLockFrame; //since we don't actually have the ability to get the current anim frame
+	int			saberLockHits; //every x number of buttons hits, allow one push forward in a saber lock (server only)
+	int			saberLockHitCheckTime; //so we don't allow more than 1 push per server frame
+	int			saberLockHitIncrementTime; //so we don't add a hit per attack button press more than once per server frame
+	qboolean	saberLockAdvance; //do an advance (sent across net as 1 bit)
+
+	int			saberEntityNum;
+	float		saberEntityDist;
+	int			saberEntityState;
+	int			saberThrowDelay;
+	qboolean	saberCanThrow;
+	int			saberDidThrowTime;
+	int			saberDamageDebounceTime;
+	int			saberHitWallSoundDebounceTime;
+	int			saberEventFlags;
+
+	int			rocketLockIndex;
+	float		rocketLastValidTime;
+	float		rocketLockTime;
+	float		rocketTargetTime;
+
+	int			emplacedIndex;
+	float		emplacedTime;
+
+	qboolean	isJediMaster;
+	qboolean	forceRestricted;
+	qboolean	trueJedi;
+	qboolean	trueNonJedi;
+	int			saberIndex;
+
+	int			genericEnemyIndex;
+	float		droneFireTime;
+	float		droneExistTime;
+
+	int			activeForcePass;
+
+	qboolean	hasDetPackPlanted; //better than taking up an eFlag isn't it?
+
+	float		holocronsCarried[NUM_FORCE_POWERS];
+	int			holocronCantTouch;
+	float		holocronCantTouchTime; //for keeping track of the last holocron that just popped out of me (if any)
+	int			holocronBits;
+
+	int			electrifyTime;
+
+	int			saberAttackSequence;
+	int			saberIdleWound;
+	int			saberAttackWound;
+	int			saberBlockTime;
+
+	int			otherKiller;
+	int			otherKillerTime;
+	int			otherKillerDebounceTime;
+
+	forcedata_t	fd;
+	qboolean	forceJumpFlip;
+	int			forceHandExtend;
+	int			forceHandExtendTime;
+
+	int			forceRageDrainTime;
+
+	int			forceDodgeAnim;
+	qboolean	quickerGetup;
+
+	int			groundTime;		// time when first left ground
+
+	int			footstepTime;
+
+	int			otherSoundTime;
+	float		otherSoundLen;
+
+	int			forceGripMoveInterval;
+	int			forceGripChangeMovetype;
+
+	int			forceKickFlip;
+
+	int			duelIndex;
+	int			duelTime;
+	qboolean	duelInProgress;
+
+	int			saberAttackChainCount;
+
+	int			saberHolstered;
+
+	int			forceAllowDeactivateTime;
+
+	// zoom key
+	int			zoomMode;		// 0 - not zoomed, 1 - disruptor weapon
+	int			zoomTime;
+	qboolean	zoomLocked;
+	float		zoomFov;
+	int			zoomLockTime;
+
+	int			fallingToDeath;
+
+	int			useDelay;
+
+	qboolean	inAirAnim;
+
+	vec3_t		lastHitLoc;
+
+	int			heldByClient; //can only be a client index - this client should be holding onto my arm using IK stuff.
+
+	int			ragAttach; //attach to ent while ragging
+
+	int			iModelScale;
+
+	int			brokenLimbs;
+
+	//for looking at an entity's origin (NPCs and players)
+	qboolean	hasLookTarget;
+	int			lookTarget;
+
+	int			customRGBA[4];
+
+	int			standheight;
+	int			crouchheight;
+
+	//If non-0, this is the index of the vehicle a player/NPC is riding.
+	int			m_iVehicleNum;
+
+	//lovely hack for keeping vehicle orientation in sync with prediction
+	vec3_t		vehOrientation;
+	qboolean	vehBoarding;
+	int			vehSurfaces;
+
+	//vehicle turnaround stuff (need this in ps so it doesn't jerk too much in prediction)
+	int			vehTurnaroundIndex;
+	int			vehTurnaroundTime;
+
+	//vehicle has weapons linked
+	qboolean	vehWeaponsLinked;
+
+	//when hyperspacing, you just go forward really fast for HYPERSPACE_TIME
+	int			hyperSpaceTime;
+	vec3_t		hyperSpaceAngles;
+
+	//hacking when > time
+	int			hackingTime;
+	//actual hack amount - only for the proper percentage display when
+	//drawing progress bar (is there a less bandwidth-eating way to do
+	//this without a lot of hassle?)
+	int			hackingBaseTime;
+
+	//keeps track of jetpack fuel
+	int			jetpackFuel;
+
+	//keeps track of cloak fuel
+	int			cloakFuel;
+
+	//rww - spare values specifically for use by mod authors.
+	//See psf_overrides.txt if you want to increase the send
+	//amount of any of these above 1 bit.
+#ifndef _XBOX
+	int			userInt1;
+	int			userInt2;
+	int			userInt3;
+	float		userFloat1;
+	float		userFloat2;
+	float		userFloat3;
+	vec3_t		userVec1;
+	vec3_t		userVec2;
+#endif
+
+#ifdef _ONEBIT_COMBO
+	int			deltaOneBits;
+	int			deltaNumBits;
+#endif
+} playerState_t;
+
+typedef struct siegePers_s
+{
+	qboolean	beatingTime;
+	int			lastTeam;
+	int			lastTime;
+} siegePers_t;
+
+//====================================================================
+
+
+//
+// usercmd_t->button bits, many of which are generated by the client system,
+// so they aren't game/cgame only definitions
+//
+#define	BUTTON_ATTACK			1
+#define	BUTTON_TALK				2			// displays talk balloon and disables actions
+#define	BUTTON_USE_HOLDABLE		4
+#define	BUTTON_GESTURE			8
+#define	BUTTON_WALKING			16			// walking can't just be infered from MOVE_RUN
+										// because a key pressed late in the frame will
+										// only generate a small move value for that frame
+										// walking will use different animations and
+										// won't generate footsteps
+#define	BUTTON_USE				32			// the ol' use key returns!
+#define BUTTON_FORCEGRIP		64			// 
+#define BUTTON_ALT_ATTACK		128
+
+#define	BUTTON_ANY				256			// any key whatsoever
+
+#define BUTTON_FORCEPOWER		512			// use the "active" force power
+
+#define BUTTON_FORCE_LIGHTNING	1024
+
+#define BUTTON_FORCE_DRAIN		2048
+
+// Here's an interesting bit.  The bots in TA used buttons to do additional gestures.
+// I ripped them out because I didn't want too many buttons given the fact that I was already adding some for JK2.
+// We can always add some back in if we want though.
+/*
+#define BUTTON_AFFIRMATIVE	32
+#define	BUTTON_NEGATIVE		64
+
+#define BUTTON_GETFLAG		128
+#define BUTTON_GUARDBASE	256
+#define BUTTON_PATROL		512
+#define BUTTON_FOLLOWME		1024
+*/
+
+#define	MOVE_RUN			120			// if forwardmove or rightmove are >= MOVE_RUN,
+										// then BUTTON_WALKING should be set
+
+typedef enum
+{
+	GENCMD_SABERSWITCH = 1,
+	GENCMD_ENGAGE_DUEL,
+	GENCMD_FORCE_HEAL,
+	GENCMD_FORCE_SPEED,
+	GENCMD_FORCE_THROW,
+	GENCMD_FORCE_PULL,
+	GENCMD_FORCE_DISTRACT,
+	GENCMD_FORCE_RAGE,
+	GENCMD_FORCE_PROTECT,
+	GENCMD_FORCE_ABSORB,
+	GENCMD_FORCE_HEALOTHER,
+	GENCMD_FORCE_FORCEPOWEROTHER,
+	GENCMD_FORCE_SEEING,
+	GENCMD_USE_SEEKER,
+	GENCMD_USE_FIELD,
+	GENCMD_USE_BACTA,
+	GENCMD_USE_ELECTROBINOCULARS,
+	GENCMD_ZOOM,
+	GENCMD_USE_SENTRY,
+	GENCMD_USE_JETPACK,
+	GENCMD_USE_BACTABIG,
+	GENCMD_USE_HEALTHDISP,
+	GENCMD_USE_AMMODISP,
+	GENCMD_USE_EWEB,
+	GENCMD_USE_CLOAK,
+	GENCMD_SABERATTACKCYCLE,
+	GENCMD_TAUNT,
+	GENCMD_BOW,
+	GENCMD_MEDITATE,
+	GENCMD_FLOURISH,
+	GENCMD_GLOAT
+} genCmds_t;
+
+// usercmd_t is sent to the server each client frame
+typedef struct usercmd_s {
+	int				serverTime;
+	int				angles[3];
+	int 			buttons;
+	byte			weapon;           // weapon 
+	byte			forcesel;
+	byte			invensel;
+	byte			generic_cmd;
+	signed char	forwardmove, rightmove, upmove;
+} usercmd_t;
+
+//===================================================================
+
+//rww - unsightly hack to allow us to make an FX call that takes a horrible amount of args
+typedef struct addpolyArgStruct_s {
+	vec3_t				p[4];
+	vec2_t				ev[4];
+	int					numVerts;
+	vec3_t				vel;
+	vec3_t				accel;
+	float				alpha1;
+	float				alpha2;
+	float				alphaParm;
+	vec3_t				rgb1;
+	vec3_t				rgb2;
+	float				rgbParm;
+	vec3_t				rotationDelta;
+	float				bounce;
+	int					motionDelay;
+	int					killTime;
+	qhandle_t			shader;
+	int					flags;
+} addpolyArgStruct_t;
+
+typedef struct addbezierArgStruct_s {
+	vec3_t start;
+	vec3_t end;
+	vec3_t control1;
+	vec3_t control1Vel;
+	vec3_t control2;
+	vec3_t control2Vel;
+	float size1;
+	float size2;
+	float sizeParm;
+	float alpha1;
+	float alpha2;
+	float alphaParm;
+	vec3_t sRGB;
+	vec3_t eRGB;
+	float rgbParm;
+	int killTime;
+	qhandle_t shader;
+	int flags;
+} addbezierArgStruct_t;
+
+typedef struct addspriteArgStruct_s
+{
+	vec3_t origin;
+	vec3_t vel;
+	vec3_t accel;
+	float scale;
+	float dscale;
+	float sAlpha;
+	float eAlpha;
+	float rotation;
+	float bounce;
+	int life;
+	qhandle_t shader;
+	int flags;
+} addspriteArgStruct_t;
+
+typedef struct
+{
+	vec3_t	origin;
+
+	// very specifc case, we can modulate the color and the alpha
+	vec3_t	rgb;
+	vec3_t	destrgb;
+	vec3_t	curRGB;
+
+	float	alpha;
+	float	destAlpha;
+	float	curAlpha;
+
+	// this is a very specific case thing...allow interpolating the st coords so we can map the texture
+	//	properly as this segement progresses through it's life
+	float	ST[2];
+	float	destST[2];
+	float	curST[2];
+} effectTrailVertStruct_t;
+
+typedef struct effectTrailArgStruct_s {
+	effectTrailVertStruct_t		mVerts[4];
+	qhandle_t					mShader;
+	int							mSetFlags;
+	int							mKillTime;
+} effectTrailArgStruct_t;
+
+typedef struct
+{
+	vec3_t start;
+	vec3_t end;
+	float size1;
+	float size2;
+	float sizeParm;
+	float alpha1;
+	float alpha2;
+	float alphaParm;
+	vec3_t sRGB;
+	vec3_t eRGB;
+	float rgbParm;
+	float chaos;
+	int killTime;
+	qhandle_t shader;
+	int flags;
+} addElectricityArgStruct_t;
+
+// if entityState->solid == SOLID_BMODEL, modelindex is an inline model number
+#define	SOLID_BMODEL	0xffffff
+
+typedef enum {
+	TR_STATIONARY,
+	TR_INTERPOLATE,				// non-parametric, but interpolate between snapshots
+	TR_LINEAR,
+	TR_LINEAR_STOP,
+	TR_NONLINEAR_STOP,
+	TR_SINE,					// value = base + sin( time / duration ) * delta
+	TR_GRAVITY
+} trType_t;
+
+typedef struct {
+	trType_t	trType;
+	int		trTime;
+	int		trDuration;			// if non 0, trTime + trDuration = stop time
+	vec3_t	trBase;
+	vec3_t	trDelta;			// velocity, etc
+} trajectory_t;
+
+// entityState_t is the information conveyed from the server
+// in an update message about entities that the client will
+// need to render in some way
+// Different eTypes may use the information in different ways
+// The messages are delta compressed, so it doesn't really matter if
+// the structure size is fairly large
+#ifndef _XBOX	// First, real version for the PC, with all members 32-bits
+
+typedef struct entityState_s {
+	int		number;			// entity index
+	int		eType;			// entityType_t
+	int		eFlags;
+	int		eFlags2;		// EF2_??? used much less frequently
+
+	trajectory_t	pos;	// for calculating position
+	trajectory_t	apos;	// for calculating angles
+
+	int		time;
+	int		time2;
+
+	vec3_t	origin;
+	vec3_t	origin2;
+
+	vec3_t	angles;
+	vec3_t	angles2;
+
+	//rww - these were originally because we shared g2 info client and server side. Now they
+	//just get used as generic values everywhere.
+	int		bolt1;
+	int		bolt2;
+
+	//rww - this is necessary for determining player visibility during a jedi mindtrick
+	int		trickedentindex; //0-15
+	int		trickedentindex2; //16-32
+	int		trickedentindex3; //33-48
+	int		trickedentindex4; //49-64
+
+	float	speed;
+
+	int		fireflag;
+
+	int		genericenemyindex;
+
+	int		activeForcePass;
+
+	int		emplacedOwner;
+
+	int		otherEntityNum;	// shotgun sources, etc
+	int		otherEntityNum2;
+
+	int		groundEntityNum;	// -1 = in air
+
+	int		constantLight;	// r + (g<<8) + (b<<16) + (intensity<<24)
+	int		loopSound;		// constantly loop this sound
+	qboolean	loopIsSoundset; //qtrue if the loopSound index is actually a soundset index
+
+	int		soundSetIndex;
+
+	int		modelGhoul2;
+	int		g2radius;
+	int		modelindex;
+	int		modelindex2;
+	int		clientNum;		// 0 to (MAX_CLIENTS - 1), for players and corpses
+	int		frame;
+
+	qboolean	saberInFlight;
+	int			saberEntityNum;
+	int			saberMove;
+	int			forcePowersActive;
+	int			saberHolstered;//sent in only only 2 bits - should be 0, 1 or 2
+
+	qboolean	isJediMaster;
+
+	qboolean	isPortalEnt; //this needs to be seperate for all entities I guess, which is why I couldn't reuse another value.
+
+	int		solid;			// for client side prediction, trap_linkentity sets this properly
+
+	int		event;			// impulse events -- muzzle flashes, footsteps, etc
+	int		eventParm;
+
+	// so crosshair knows what it's looking at
+	int			owner;
+	int			teamowner;
+	qboolean	shouldtarget;
+
+	// for players
+	int		powerups;		// bit flags
+	int		weapon;			// determines weapon and flash model, etc
+	int		legsAnim;
+	int		torsoAnim;
+
+	qboolean	legsFlip; //set to opposite when the same anim needs restarting, sent over in only 1 bit. Cleaner and makes porting easier than having that god forsaken ANIM_TOGGLEBIT.
+	qboolean	torsoFlip;
+
+	int		forceFrame;		//if non-zero, force the anim frame
+
+	int		generic1;
+
+	int		heldByClient; //can only be a client index - this client should be holding onto my arm using IK stuff.
+
+	int		ragAttach; //attach to ent while ragging
+
+	int		iModelScale; //rww - transfer a percentage of the normal scale in a single int instead of 3 x-y-z scale values
+
+	int		brokenLimbs;
+
+	int		boltToPlayer; //set to index of a real client+1 to bolt the ent to that client. Must be a real client, NOT an NPC.
+
+	//for looking at an entity's origin (NPCs and players)
+	qboolean	hasLookTarget;
+	int			lookTarget;
+
+	int			customRGBA[4];
+
+	//I didn't want to do this, but I.. have no choice. However, we aren't setting this for all ents or anything,
+	//only ones we want health knowledge about on cgame (like siege objective breakables) -rww
+	int			health;
+	int			maxhealth; //so I know how to draw the stupid health bar
+
+	//NPC-SPECIFIC FIELDS
+	//------------------------------------------------------------
+	int		npcSaber1;
+	int		npcSaber2;
+
+	//index values for each type of sound, gets the folder the sounds
+	//are in. I wish there were a better way to do this,
+	int		csSounds_Std;
+	int		csSounds_Combat;
+	int		csSounds_Extra;
+	int		csSounds_Jedi;
+
+	int		surfacesOn; //a bitflag of corresponding surfaces from a lookup table. These surfaces will be forced on.
+	int		surfacesOff; //same as above, but forced off instead.
+
+	//Allow up to 4 PCJ lookup values to be stored here.
+	//The resolve to configstrings which contain the name of the
+	//desired bone.
+	int		boneIndex1;
+	int		boneIndex2;
+	int		boneIndex3;
+	int		boneIndex4;
+
+	//packed with x, y, z orientations for bone angles
+	int		boneOrient;
+
+	//I.. feel bad for doing this, but NPCs really just need to
+	//be able to control this sort of thing from the server sometimes.
+	//At least it's at the end so this stuff is never going to get sent
+	//over for anything that isn't an NPC.
+	vec3_t	boneAngles1; //angles of boneIndex1
+	vec3_t	boneAngles2; //angles of boneIndex2
+	vec3_t	boneAngles3; //angles of boneIndex3
+	vec3_t	boneAngles4; //angles of boneIndex4
+
+	int		NPC_class; //we need to see what it is on the client for a few effects.
+
+	//If non-0, this is the index of the vehicle a player/NPC is riding.
+	int		m_iVehicleNum;
+
+	//rww - spare values specifically for use by mod authors.
+	//See netf_overrides.txt if you want to increase the send
+	//amount of any of these above 1 bit.
+	int			userInt1;
+	int			userInt2;
+	int			userInt3;
+	float		userFloat1;
+	float		userFloat2;
+	float		userFloat3;
+	vec3_t		userVec1;
+	vec3_t		userVec2;
+} entityState_t;
+
+#else
+// Now, XBOX version with members packed in tightly to save gobs of memory
+// This is rather confusing. All members are in 1, 2, or 4 bytes, and then
+// re-ordered within the structure to keep everything aligned.
+
+#pragma pack(push, 1)
+
+typedef struct entityState_s {
+	// Large (32-bit) fields first
+
+	int		number;			// entity index
+	int		eFlags;
+
+	trajectory_t	pos;	// for calculating position
+	trajectory_t	apos;	// for calculating angles
+
+	int		time;
+	int		time2;
+
+	vec3_t	origin;
+	vec3_t	origin2;
+
+	vec3_t	angles;
+	vec3_t	angles2;
+
+	float	speed;
+
+	int		genericenemyindex;
+
+	int		emplacedOwner;
+
+	int		constantLight;	// r + (g<<8) + (b<<16) + (intensity<<24)
+	int		forcePowersActive;
+
+	int		solid;			// for client side prediction, trap_linkentity sets this properly
+
+	byte	customRGBA[4];
+
+	int		surfacesOn; //a bitflag of corresponding surfaces from a lookup table. These surfaces will be forced on.
+	int		surfacesOff; //same as above, but forced off instead.
+
+	//I.. feel bad for doing this, but NPCs really just need to
+	//be able to control this sort of thing from the server sometimes.
+	//At least it's at the end so this stuff is never going to get sent
+	//over for anything that isn't an NPC.
+	vec3_t	boneAngles1; //angles of boneIndex1
+	vec3_t	boneAngles2; //angles of boneIndex2
+	vec3_t	boneAngles3; //angles of boneIndex3
+	vec3_t	boneAngles4; //angles of boneIndex4
+
+
+	// Now, the 16-bit members
+
+
+	word	bolt2;
+	word	trickedentindex; //0-15
+
+	word	trickedentindex2; //16-32
+	word	trickedentindex3; //33-48
+
+	word	trickedentindex4; //49-64
+	word	otherEntityNum;	// shotgun sources, etc
+
+	word	otherEntityNum2;
+	word	groundEntityNum;	// -1 = in air
+
+	short	modelindex;
+	word	clientNum;		// 0 to (MAX_CLIENTS - 1), for players and corpses
+
+	word	frame;
+	word	saberEntityNum;
+
+	word	event;			// impulse events -- muzzle flashes, footsteps, etc
+	word	owner; // so crosshair knows what it's looking at
+
+	word	powerups;		// bit flags
+	word	legsAnim;
+
+	word	torsoAnim;
+	word	forceFrame;		//if non-zero, force the anim frame
+
+	word	ragAttach; //attach to ent while ragging
+	short	iModelScale; //rww - transfer a percentage of the normal scale in a single int instead of 3 x-y-z scale values
+
+	word	lookTarget;
+	word	health;
+
+	word	maxhealth; //so I know how to draw the stupid health bar
+	word	npcSaber1;
+
+	word	npcSaber2;
+	word	boneOrient; //packed with x, y, z orientations for bone angles
+
+	//If non-0, this is the index of the vehicle a player/NPC is riding.
+	word	m_iVehicleNum;
+
+
+	// Now, the 8-bit members. These start out two bytes off, thanks to the above word
+
+
+	byte	eType;			// entityType_t
+	byte	eFlags2;		// EF2_??? used much less frequently
+
+	byte	bolt1;
+	byte	fireflag;
+	byte	activeForcePass;
+	byte	loopSound;		// constantly loop this sound
+
+	byte	loopIsSoundset; //qtrue if the loopSound index is actually a soundset index
+	byte	soundSetIndex;
+	byte	modelGhoul2;
+	byte	g2radius;
+
+	byte	modelindex2;
+	byte	saberInFlight;
+	byte	saberMove;
+	byte	isJediMaster;
+	byte	saberHolstered;//sent in only 2 bytes, should be 0, 1 or 2
+
+	byte	isPortalEnt; //this needs to be seperate for all entities I guess, which is why I couldn't reuse another value.
+	byte	eventParm;
+	byte	teamowner;
+	byte	shouldtarget;
+
+	byte	weapon;			// determines weapon and flash model, etc
+	byte	legsFlip; //set to opposite when the same anim needs restarting, sent over in only 1 bit. Cleaner and makes porting easier than having that god forsaken ANIM_TOGGLEBIT.
+	byte	torsoFlip;
+	byte	generic1;
+
+	byte	heldByClient; //can only be a client index - this client should be holding onto my arm using IK stuff.
+	byte	brokenLimbs;
+	byte	boltToPlayer; //set to index of a real client+1 to bolt the ent to that client. Must be a real client, NOT an NPC.
+	byte	hasLookTarget; //for looking at an entity's origin (NPCs and players)
+
+	//index values for each type of sound, gets the folder the sounds
+	//are in. I wish there were a better way to do this,
+	byte	csSounds_Std;
+	byte	csSounds_Combat;
+	byte	csSounds_Extra;
+	byte	csSounds_Jedi;
+
+	//Allow up to 4 PCJ lookup values to be stored here.
+	//The resolve to configstrings which contain the name of the
+	//desired bone.
+	byte	boneIndex1;
+	byte	boneIndex2;
+	byte	boneIndex3;
+	byte	boneIndex4;
+
+	byte	NPC_class; //we need to see what it is on the client for a few effects.
+	byte	alignPad[3];
+} entityState_t;
+
+#pragma pack(pop)
+
+#endif
+
+typedef enum {
+	CA_UNINITIALIZED,
+	CA_DISCONNECTED, 	// not talking to a server
+	CA_AUTHORIZING,		// not used any more, was checking cd key 
+	CA_CONNECTING,		// sending request packets to the server
+	CA_CHALLENGING,		// sending challenge packets to the server
+	CA_CONNECTED,		// netchan_t established, getting gamestate
+	CA_LOADING,			// only during cgame initialization, never during main loop
+	CA_PRIMED,			// got gamestate, waiting for first frame
+	CA_ACTIVE,			// game views should be displayed
+	CA_CINEMATIC		// playing a cinematic or a static pic, not connected to a server
+} connstate_t;
+
+
+#define Square(x) ((x)*(x))
+
+// real time
+//=============================================
+
+
+typedef struct qtime_s {
+	int tm_sec;     /* seconds after the minute - [0,59] */
+	int tm_min;     /* minutes after the hour - [0,59] */
+	int tm_hour;    /* hours since midnight - [0,23] */
+	int tm_mday;    /* day of the month - [1,31] */
+	int tm_mon;     /* months since January - [0,11] */
+	int tm_year;    /* years since 1900 */
+	int tm_wday;    /* days since Sunday - [0,6] */
+	int tm_yday;    /* days since January 1 - [0,365] */
+	int tm_isdst;   /* daylight savings time flag */
+} qtime_t;
+
+
+// server browser sources
+#define AS_LOCAL			0
+#define AS_GLOBAL			1
+#define AS_FAVORITES		2
+
+#define AS_MPLAYER			3 // (Obsolete)
+
+// cinematic states
+typedef enum {
+	FMV_IDLE,
+	FMV_PLAY,		// play
+	FMV_EOF,		// all other conditions, i.e. stop/EOF/abort
+	FMV_ID_BLT,
+	FMV_ID_IDLE,
+	FMV_LOOPED,
+	FMV_ID_WAIT
+};
+typedef int e_status;
+
+typedef enum _flag_status {
+	FLAG_ATBASE = 0,
+	FLAG_TAKEN,			// CTF
+	FLAG_TAKEN_RED,		// One Flag CTF
+	FLAG_TAKEN_BLUE,	// One Flag CTF
+	FLAG_DROPPED
+};
+typedef int flagStatus_t;
+
+
+
+#ifdef _XBOX
+#define	MAX_GLOBAL_SERVERS			50
+#define	MAX_OTHER_SERVERS			16
+#else
+#define	MAX_GLOBAL_SERVERS			2048
+#define	MAX_OTHER_SERVERS			128
+#endif
+#define MAX_PINGREQUESTS			32
+#define MAX_SERVERSTATUSREQUESTS	16
+
+#define SAY_ALL		0
+#define SAY_TEAM	1
+#define SAY_TELL	2
+
+#define CDKEY_LEN 16
+#define CDCHKSUM_LEN 2
+
+void Rand_Init(int seed);
+float flrand(float min, float max);
+int irand(int min, int max);
+int Q_irand(int value1, int value2);
+
+/*
+Ghoul2 Insert Start
+*/
+
+typedef struct {
+	float		matrix[3][4];
+} mdxaBone_t;
+
+// For ghoul2 axis use
+
+typedef enum Eorientations
+{
+	ORIGIN = 0, 
+	POSITIVE_X,
+	POSITIVE_Z,
+	POSITIVE_Y,
+	NEGATIVE_X,
+	NEGATIVE_Z,
+	NEGATIVE_Y
+};
+/*
+Ghoul2 Insert End
+*/
+
+
+// define the new memory tags for the zone, used by all modules now
+//
+#define TAGDEF(blah) TAG_ ## blah
+typedef enum {
+	#include "../qcommon/tags.h"
+};
+typedef char memtag_t;
+
+//rww - conveniently toggle "gore" code, for model decals and stuff.
+#define _G2_GORE
+
+typedef struct SSkinGoreData_s
+{
+	vec3_t			angles;
+	vec3_t			position;
+	int				currentTime;
+	int				entNum;
+	vec3_t			rayDirection;	// in world space
+	vec3_t			hitLocation;	// in world space
+	vec3_t			scale;
+	float			SSize;			// size of splotch in the S texture direction in world units
+	float			TSize;			// size of splotch in the T texture direction in world units
+	float			theta;			// angle to rotate the splotch
+
+	// growing stuff
+	int				growDuration;			// time over which we want this to scale up, set to -1 for no scaling
+	float			goreScaleStartFraction; // fraction of the final size at which we want the gore to initially appear
+
+	qboolean		frontFaces;
+	qboolean		backFaces;
+	qboolean		baseModelOnly;
+	int				lifeTime;				// effect expires after this amount of time
+	int				fadeOutTime;			//specify the duration of fading, from the lifeTime (e.g. 3000 will start fading 3 seconds before removal and be faded entirely by removal)
+	int				shrinkOutTime;			// unimplemented
+	float			alphaModulate;			// unimplemented
+	vec3_t			tint;					// unimplemented
+	float			impactStrength;			// unimplemented
+
+	int				shader; // shader handle 
+
+	int				myIndex; // used internally
+
+	qboolean		fadeRGB; //specify fade method to modify RGB (by default, the alpha is set instead)
+} SSkinGoreData;
+
+/*
+========================================================================
+
+String ID Tables
+
+========================================================================
+*/
+#define ENUM2STRING(arg)   #arg,arg
+typedef struct stringID_table_s
+{
+	char	*name;
+	int		id;
+} stringID_table_t;
+
+int GetIDForString ( stringID_table_t *table, const char *string );
+const char *GetStringForID( stringID_table_t *table, int id );
+
+
+// stuff to help out during development process, force reloading/uncacheing of certain filetypes...
+//
+typedef enum
+{
+	eForceReload_NOTHING,
+//	eForceReload_BSP,	// not used in MP codebase
+	eForceReload_MODELS,
+	eForceReload_ALL
+
+} ForceReload_e;
+
+
+enum {
+	FONT_NONE,
+	FONT_SMALL=1,
+	FONT_MEDIUM,
+	FONT_LARGE,
+	FONT_SMALL2
+};
+
+
+
+#endif	// __Q_SHARED_H
diff --git a/codemp/game/say.h b/codemp/game/say.h
new file mode 100644
index 0000000..0d47401
--- /dev/null
+++ b/codemp/game/say.h
@@ -0,0 +1,30 @@
+#ifndef __SAY_H__
+#define __SAY_H__
+
+typedef enum //# saying_e
+{
+	//Acknowledge command
+	SAY_ACKCOMM1,
+	SAY_ACKCOMM2,
+	SAY_ACKCOMM3,
+	SAY_ACKCOMM4,
+	//Refuse command
+	SAY_REFCOMM1,
+	SAY_REFCOMM2,
+	SAY_REFCOMM3,
+	SAY_REFCOMM4,
+	//Bad command
+	SAY_BADCOMM1,
+	SAY_BADCOMM2,
+	SAY_BADCOMM3,
+	SAY_BADCOMM4,
+	//Unfinished hail
+	SAY_BADHAIL1,
+	SAY_BADHAIL2,
+	SAY_BADHAIL3,
+	SAY_BADHAIL4,
+	//# #eol
+	NUM_SAYINGS
+} saying_t;
+
+#endif //#ifndef __SAY_H__
diff --git a/codemp/game/surfaceflags.h b/codemp/game/surfaceflags.h
new file mode 100644
index 0000000..b6f4c48
--- /dev/null
+++ b/codemp/game/surfaceflags.h
@@ -0,0 +1,122 @@
+// Copyright (C) 1999-2000 Id Software, Inc.
+//
+// This file must be identical in the quake and utils directories
+
+// contents flags are seperate bits
+// a given brush can contribute multiple content bits
+
+// these definitions also need to be in q_shared.h!
+
+#define	CONTENTS_SOLID			0x00000001	// Default setting. An eye is never valid in a solid
+#define	CONTENTS_LAVA			0x00000002
+#define	CONTENTS_WATER			0x00000004
+#define	CONTENTS_FOG			0x00000008
+#define	CONTENTS_PLAYERCLIP		0x00000010
+#define	CONTENTS_MONSTERCLIP	0x00000020	// Physically block bots
+#define CONTENTS_BOTCLIP		0x00000040	// A hint for bots - do not enter this brush by navigation (if possible)
+#define CONTENTS_SHOTCLIP		0x00000080
+#define	CONTENTS_BODY			0x00000100	// should never be on a brush, only in game
+#define	CONTENTS_CORPSE			0x00000200	// should never be on a brush, only in game
+#define	CONTENTS_TRIGGER		0x00000400
+#define	CONTENTS_NODROP			0x00000800	// don't leave bodies or items (death fog, lava)
+#define CONTENTS_TERRAIN		0x00001000	// volume contains terrain data
+#define CONTENTS_LADDER			0x00002000
+#define CONTENTS_ABSEIL			0x00004000  // (SOF2) used like ladder to define where an NPC can abseil
+#define CONTENTS_OPAQUE			0x00008000	// defaults to on, when off, solid can be seen through
+#define CONTENTS_OUTSIDE		0x00010000	// volume is considered to be in the outside (i.e. not indoors)
+
+#define	CONTENTS_INSIDE			0x10000000	// volume is considered to be inside (i.e. indoors)
+
+#define CONTENTS_SLIME			0x00020000	// CHC needs this since we use same tools
+#define CONTENTS_LIGHTSABER		0x00040000	// ""
+#define CONTENTS_TELEPORTER		0x00080000	// ""
+#define CONTENTS_ITEM			0x00100000	// ""
+#define CONTENTS_NOSHOT			0x00200000	// shots pass through me
+#define	CONTENTS_DETAIL			0x08000000	// brushes not used for the bsp
+#define	CONTENTS_TRANSLUCENT	0x80000000	// don't consume surface fragments inside
+
+#define	SURF_SKY				0x00002000	// lighting from environment map
+#define	SURF_SLICK				0x00004000	// affects game physics
+#define	SURF_METALSTEPS			0x00008000	// CHC needs this since we use same tools (though this flag is temp?)
+#define SURF_FORCEFIELD			0x00010000	// CHC ""			(but not temp)
+#define	SURF_NODAMAGE			0x00040000	// never give falling damage
+#define	SURF_NOIMPACT			0x00080000	// don't make missile explosions
+#define	SURF_NOMARKS			0x00100000	// don't leave missile marks
+#define	SURF_NODRAW				0x00200000	// don't generate a drawsurface at all
+#define	SURF_NOSTEPS			0x00400000	// no footstep sounds
+#define	SURF_NODLIGHT			0x00800000	// don't dlight even if solid (solid lava, skies)
+#define	SURF_NOMISCENTS			0x01000000	// no client models allowed on this surface
+
+
+#define MATERIAL_BITS			5
+#define MATERIAL_MASK			0x1f	// mask to get the material type
+
+#define MATERIAL_NONE			0			// for when the artist hasn't set anything up =)
+#define MATERIAL_SOLIDWOOD		1			// freshly cut timber
+#define MATERIAL_HOLLOWWOOD		2			// termite infested creaky wood
+#define MATERIAL_SOLIDMETAL		3			// solid girders
+#define MATERIAL_HOLLOWMETAL	4			// hollow metal machines
+#define MATERIAL_SHORTGRASS		5			// manicured lawn
+#define MATERIAL_LONGGRASS		6			// long jungle grass
+#define MATERIAL_DIRT			7			// hard mud
+#define MATERIAL_SAND			8			// sandy beach
+#define MATERIAL_GRAVEL			9			// lots of small stones
+#define MATERIAL_GLASS			10			// 
+#define MATERIAL_CONCRETE		11			// hardened concrete pavement
+#define MATERIAL_MARBLE			12			// marble floors
+#define MATERIAL_WATER			13			// light covering of water on a surface
+#define MATERIAL_SNOW			14			// freshly laid snow
+#define MATERIAL_ICE			15			// packed snow/solid ice
+#define MATERIAL_FLESH			16			// hung meat, corpses in the world
+#define MATERIAL_MUD			17			// wet soil
+#define MATERIAL_BPGLASS		18			// bulletproof glass
+#define MATERIAL_DRYLEAVES		19			// dried up leaves on the floor
+#define MATERIAL_GREENLEAVES	20			// fresh leaves still on a tree
+#define MATERIAL_FABRIC			21			// Cotton sheets
+#define MATERIAL_CANVAS			22			// tent material
+#define MATERIAL_ROCK			23			//
+#define MATERIAL_RUBBER			24			// hard tire like rubber
+#define MATERIAL_PLASTIC		25			// 
+#define MATERIAL_TILES			26			// tiled floor
+#define MATERIAL_CARPET			27			// lush carpet
+#define MATERIAL_PLASTER		28			// drywall style plaster
+#define MATERIAL_SHATTERGLASS	29			// glass with the Crisis Zone style shattering
+#define MATERIAL_ARMOR			30			// body armor
+#define MATERIAL_COMPUTER		31			// computers/electronic equipment
+#define MATERIAL_LAST			32			// number of materials
+
+// Defined as a macro here so one change will affect all the relevant files
+
+#define MATERIALS	\
+	"none",			\
+	"solidwood",	\
+	"hollowwood",	\
+	"solidmetal",	\
+	"hollowmetal",	\
+	"shortgrass",	\
+	"longgrass",	\
+	"dirt",	   		\
+	"sand",	   		\
+	"gravel",		\
+	"glass",		\
+	"concrete",		\
+	"marble",		\
+	"water",		\
+	"snow",	   		\
+	"ice",			\
+	"flesh",		\
+	"mud",			\
+	"bpglass",		\
+	"dryleaves",	\
+	"greenleaves",	\
+	"fabric",		\
+	"canvas",		\
+	"rock",			\
+	"rubber",		\
+	"plastic",		\
+	"tiles",		\
+	"carpet",		\
+	"plaster",		\
+	"shatterglass",	\
+	"armor",		\
+	"computer"/* this was missing, see enums above, plus ShaderEd2 pulldown options */
diff --git a/codemp/game/syn.h b/codemp/game/syn.h
new file mode 100644
index 0000000..b9f3ae3
--- /dev/null
+++ b/codemp/game/syn.h
@@ -0,0 +1,20 @@
+//===========================================================================
+//
+// Name:			syn.h
+// Function:		synonyms
+// Programmer:		Mr Elusive
+// Last update:		-
+// Tab Size:		4 (real tabs)
+// Notes:			-
+//===========================================================================
+
+#define CONTEXT_ALL						0xFFFFFFFF
+#define CONTEXT_NORMAL					1
+#define CONTEXT_NEARBYITEM				2
+#define CONTEXT_CTFREDTEAM				4
+#define CONTEXT_CTFBLUETEAM				8
+#define CONTEXT_REPLY					16
+#define CONTEXT_HARVESTERREDTEAM		128
+#define CONTEXT_HARVESTERBLUETEAM		256
+
+#define CONTEXT_NAMES 1024
diff --git a/codemp/game/teams.h b/codemp/game/teams.h
new file mode 100644
index 0000000..4aa132d
--- /dev/null
+++ b/codemp/game/teams.h
@@ -0,0 +1,79 @@
+#ifndef TEAMS_H
+#define TEAMS_H
+
+typedef enum //# team_e
+{
+	NPCTEAM_FREE,			// also TEAM_FREE - caution, some code checks a team_t via "if (!team_t_varname)" so I guess this should stay as entry 0, great or what? -slc
+	NPCTEAM_ENEMY,			// also TEAM_RED
+	NPCTEAM_PLAYER,			// also TEAM_BLUE
+	NPCTEAM_NEUTRAL,		// also TEAM_SPECTATOR - most droids are team_neutral, there are some exceptions like Probe,Seeker,Interrogator
+
+	//# #eol
+	NPCTEAM_NUM_TEAMS
+};
+typedef int npcteam_t;
+
+// This list is made up from the model directories, this MUST be in the same order as the ClassNames array in NPC_stats.cpp
+typedef enum 
+{
+	CLASS_NONE,				// hopefully this will never be used by an npc, just covering all bases
+	CLASS_ATST,				// technically droid...
+	CLASS_BARTENDER,
+	CLASS_BESPIN_COP,		
+	CLASS_CLAW,
+	CLASS_COMMANDO,
+	CLASS_DESANN,			
+	CLASS_FISH,
+	CLASS_FLIER2,
+	CLASS_GALAK,
+	CLASS_GLIDER,
+	CLASS_GONK,				// droid
+	CLASS_GRAN,
+	CLASS_HOWLER,
+	CLASS_IMPERIAL,
+	CLASS_IMPWORKER,
+	CLASS_INTERROGATOR,		// droid 
+	CLASS_JAN,				
+	CLASS_JEDI,				
+	CLASS_KYLE,				
+	CLASS_LANDO,			
+	CLASS_LIZARD,
+	CLASS_LUKE,				
+	CLASS_MARK1,			// droid
+	CLASS_MARK2,			// droid
+	CLASS_GALAKMECH,		// droid
+	CLASS_MINEMONSTER,
+	CLASS_MONMOTHA,			
+	CLASS_MORGANKATARN,
+	CLASS_MOUSE,			// droid
+	CLASS_MURJJ,
+	CLASS_PRISONER,
+	CLASS_PROBE,			// droid
+	CLASS_PROTOCOL,			// droid
+	CLASS_R2D2,				// droid
+	CLASS_R5D2,				// droid
+	CLASS_REBEL,
+	CLASS_REBORN,
+	CLASS_REELO,
+	CLASS_REMOTE,
+	CLASS_RODIAN,
+	CLASS_SEEKER,			// droid
+	CLASS_SENTRY,
+	CLASS_SHADOWTROOPER,
+	CLASS_STORMTROOPER,
+	CLASS_SWAMP,
+	CLASS_SWAMPTROOPER,
+	CLASS_TAVION,
+	CLASS_TRANDOSHAN,
+	CLASS_UGNAUGHT,
+	CLASS_JAWA,
+	CLASS_WEEQUAY,
+	CLASS_BOBAFETT,
+	CLASS_VEHICLE,
+	CLASS_RANCOR,
+	CLASS_WAMPA,
+	
+	CLASS_NUM_CLASSES
+} class_t;
+
+#endif	// #ifndef TEAMS_H
diff --git a/codemp/game/tri_coll_test.c b/codemp/game/tri_coll_test.c
new file mode 100644
index 0000000..988b6fb
--- /dev/null
+++ b/codemp/game/tri_coll_test.c
@@ -0,0 +1,292 @@
+/* Triangle/triangle intersection test routine,
+ * by Tomas Moller, 1997.
+ * See article "A Fast Triangle-Triangle Intersection Test",
+ * Journal of Graphics Tools, 2(2), 1997
+ *
+ * int tri_tri_intersect(float V0[3],float V1[3],float V2[3],
+ *                         float U0[3],float U1[3],float U2[3])
+ *
+ * parameters: vertices of triangle 1: V0,V1,V2
+ *             vertices of triangle 2: U0,U1,U2
+ * result    : returns 1 if the triangles intersect, otherwise 0
+ *
+ */
+
+#include <math.h>
+#include "../game/q_shared.h"
+#include "../game/g_local.h"
+
+/* if USE_EPSILON_TEST is true then we do a check: 
+         if |dv|<EPSILON then dv=0.0;
+   else no check is done (which is less robust)
+*/
+#define USE_EPSILON_TEST 1
+#define EPSILON 0.000001
+
+
+/* some macros */
+#define CROSS(dest,v1,v2)                      \
+              dest[0]=v1[1]*v2[2]-v1[2]*v2[1]; \
+              dest[1]=v1[2]*v2[0]-v1[0]*v2[2]; \
+              dest[2]=v1[0]*v2[1]-v1[1]*v2[0];
+
+#define DOT(v1,v2) (v1[0]*v2[0]+v1[1]*v2[1]+v1[2]*v2[2])
+
+#define SUB(dest,v1,v2)          \
+            dest[0]=v1[0]-v2[0]; \
+            dest[1]=v1[1]-v2[1]; \
+            dest[2]=v1[2]-v2[2]; 
+
+/* sort so that a<=b */
+#define SORT(a,b)       \
+             if(a>b)    \
+             {          \
+               float c; \
+               c=a;     \
+               a=b;     \
+               b=c;     \
+             }
+
+#define ISECT(VV0,VV1,VV2,D0,D1,D2,isect0,isect1) \
+              isect0=VV0+(VV1-VV0)*D0/(D0-D1);    \
+              isect1=VV0+(VV2-VV0)*D0/(D0-D2);
+
+
+#define COMPUTE_INTERVALS(VV0,VV1,VV2,D0,D1,D2,D0D1,D0D2,isect0,isect1) \
+  if(D0D1>0.0f)                                         \
+  {                                                     \
+    /* here we know that D0D2<=0.0 */                   \
+    /* that is D0, D1 are on the same side, D2 on the other or on the plane */ \
+    ISECT(VV2,VV0,VV1,D2,D0,D1,isect0,isect1);          \
+  }                                                     \
+  else if(D0D2>0.0f)                                    \
+  {                                                     \
+    /* here we know that d0d1<=0.0 */                   \
+    ISECT(VV1,VV0,VV2,D1,D0,D2,isect0,isect1);          \
+  }                                                     \
+  else if(D1*D2>0.0f || D0!=0.0f)                       \
+  {                                                     \
+    /* here we know that d0d1<=0.0 or that D0!=0.0 */   \
+    ISECT(VV0,VV1,VV2,D0,D1,D2,isect0,isect1);          \
+  }                                                     \
+  else if(D1!=0.0f)                                     \
+  {                                                     \
+    ISECT(VV1,VV0,VV2,D1,D0,D2,isect0,isect1);          \
+  }                                                     \
+  else if(D2!=0.0f)                                     \
+  {                                                     \
+    ISECT(VV2,VV0,VV1,D2,D0,D1,isect0,isect1);          \
+  }                                                     \
+  else                                                  \
+  {                                                     \
+    /* triangles are coplanar */                        \
+    return coplanar_tri_tri(N1,V0,V1,V2,U0,U1,U2);      \
+  }
+
+
+
+/* this edge to edge test is based on Franlin Antonio's gem:
+   "Faster Line Segment Intersection", in Graphics Gems III,
+   pp. 199-202 */ 
+#define EDGE_EDGE_TEST(V0,U0,U1)                      \
+  Bx=U0[i0]-U1[i0];                                   \
+  By=U0[i1]-U1[i1];                                   \
+  Cx=V0[i0]-U0[i0];                                   \
+  Cy=V0[i1]-U0[i1];                                   \
+  f=Ay*Bx-Ax*By;                                      \
+  d=By*Cx-Bx*Cy;                                      \
+  if((f>0 && d>=0 && d<=f) || (f<0 && d<=0 && d>=f))  \
+  {                                                   \
+    e=Ax*Cy-Ay*Cx;                                    \
+    if(f>0)                                           \
+    {                                                 \
+      if(e>=0 && e<=f) return 1;                      \
+    }                                                 \
+    else                                              \
+    {                                                 \
+      if(e<=0 && e>=f) return 1;                      \
+    }                                                 \
+  }                                
+
+#define EDGE_AGAINST_TRI_EDGES(V0,V1,U0,U1,U2) \
+{                                              \
+  float Ax,Ay,Bx,By,Cx,Cy,e,d,f;               \
+  Ax=V1[i0]-V0[i0];                            \
+  Ay=V1[i1]-V0[i1];                            \
+  /* test edge U0,U1 against V0,V1 */          \
+  EDGE_EDGE_TEST(V0,U0,U1);                    \
+  /* test edge U1,U2 against V0,V1 */          \
+  EDGE_EDGE_TEST(V0,U1,U2);                    \
+  /* test edge U2,U1 against V0,V1 */          \
+  EDGE_EDGE_TEST(V0,U2,U0);                    \
+}
+
+#define POINT_IN_TRI(V0,U0,U1,U2)           \
+{                                           \
+  float a,b,c,d0,d1,d2;                     \
+  /* is T1 completly inside T2? */          \
+  /* check if V0 is inside tri(U0,U1,U2) */ \
+  a=U1[i1]-U0[i1];                          \
+  b=-(U1[i0]-U0[i0]);                       \
+  c=-a*U0[i0]-b*U0[i1];                     \
+  d0=a*V0[i0]+b*V0[i1]+c;                   \
+                                            \
+  a=U2[i1]-U1[i1];                          \
+  b=-(U2[i0]-U1[i0]);                       \
+  c=-a*U1[i0]-b*U1[i1];                     \
+  d1=a*V0[i0]+b*V0[i1]+c;                   \
+                                            \
+  a=U0[i1]-U2[i1];                          \
+  b=-(U0[i0]-U2[i0]);                       \
+  c=-a*U2[i0]-b*U2[i1];                     \
+  d2=a*V0[i0]+b*V0[i1]+c;                   \
+  if(d0*d1>0.0)                             \
+  {                                         \
+    if(d0*d2>0.0) return 1;                 \
+  }                                         \
+}
+
+qboolean coplanar_tri_tri(vec3_t N,vec3_t V0,vec3_t V1,vec3_t V2,
+                     vec3_t U0,vec3_t U1,vec3_t U2)
+{
+   vec3_t A;
+   short i0,i1;
+   /* first project onto an axis-aligned plane, that maximizes the area */
+   /* of the triangles, compute indices: i0,i1. */
+   A[0]=fabs(N[0]);
+   A[1]=fabs(N[1]);
+   A[2]=fabs(N[2]);
+   if(A[0]>A[1])
+   {
+      if(A[0]>A[2])  
+      {
+          i0=1;      /* A[0] is greatest */
+          i1=2;
+      }
+      else
+      {
+          i0=0;      /* A[2] is greatest */
+          i1=1;
+      }
+   }
+   else   /* A[0]<=A[1] */
+   {
+      if(A[2]>A[1])
+      {
+          i0=0;      /* A[2] is greatest */
+          i1=1;                                           
+      }
+      else
+      {
+          i0=0;      /* A[1] is greatest */
+          i1=2;
+      }
+    }               
+                
+    /* test all edges of triangle 1 against the edges of triangle 2 */
+    EDGE_AGAINST_TRI_EDGES(V0,V1,U0,U1,U2);
+    EDGE_AGAINST_TRI_EDGES(V1,V2,U0,U1,U2);
+    EDGE_AGAINST_TRI_EDGES(V2,V0,U0,U1,U2);
+                
+    /* finally, test if tri1 is totally contained in tri2 or vice versa */
+    POINT_IN_TRI(V0,U0,U1,U2);
+    POINT_IN_TRI(U0,V0,V1,V2);
+
+    return qfalse;
+}
+
+qboolean tri_tri_intersect(vec3_t V0,vec3_t V1,vec3_t V2,
+                      vec3_t U0,vec3_t U1,vec3_t U2)
+{
+  vec3_t E1,E2;
+  vec3_t N1,N2;
+  float	d1,d2;
+  float du0,du1,du2,dv0,dv1,dv2;
+  vec3_t D;
+  float isect1[2], isect2[2];
+  float du0du1,du0du2,dv0dv1,dv0dv2;
+  short index;
+  float vp0,vp1,vp2;
+  float up0,up1,up2;
+  float b,c,max;
+
+  /* compute plane equation of triangle(V0,V1,V2) */
+  SUB(E1,V1,V0);
+  SUB(E2,V2,V0);
+  CROSS(N1,E1,E2);
+  d1=-DOT(N1,V0);
+  /* plane equation 1: N1.X+d1=0 */
+
+  /* put U0,U1,U2 into plane equation 1 to compute signed distances to the plane*/
+  du0=DOT(N1,U0)+d1;
+  du1=DOT(N1,U1)+d1;
+  du2=DOT(N1,U2)+d1;
+
+  /* coplanarity robustness check */
+#if USE_EPSILON_TEST
+  if(fabs(du0)<EPSILON) du0=0.0;
+  if(fabs(du1)<EPSILON) du1=0.0;
+  if(fabs(du2)<EPSILON) du2=0.0;
+#endif
+  du0du1=du0*du1;
+  du0du2=du0*du2;
+
+  if(du0du1>0.0f && du0du2>0.0f) /* same sign on all of them + not equal 0 ? */
+    return 0;                    /* no intersection occurs */
+
+  /* compute plane of triangle (U0,U1,U2) */
+  SUB(E1,U1,U0);
+  SUB(E2,U2,U0);
+  CROSS(N2,E1,E2);
+  d2=-DOT(N2,U0);
+  /* plane equation 2: N2.X+d2=0 */
+
+  /* put V0,V1,V2 into plane equation 2 */
+  dv0=DOT(N2,V0)+d2;
+  dv1=DOT(N2,V1)+d2;
+  dv2=DOT(N2,V2)+d2;
+
+#if USE_EPSILON_TEST
+  if(fabs(dv0)<EPSILON) dv0=0.0;
+  if(fabs(dv1)<EPSILON) dv1=0.0;
+  if(fabs(dv2)<EPSILON) dv2=0.0;
+#endif
+
+  dv0dv1=dv0*dv1;
+  dv0dv2=dv0*dv2;
+        
+  if(dv0dv1>0.0f && dv0dv2>0.0f) /* same sign on all of them + not equal 0 ? */
+    return 0;                    /* no intersection occurs */
+
+  /* compute direction of intersection line */
+  CROSS(D,N1,N2);
+
+  /* compute and index to the largest component of D */
+  max=fabs(D[0]);
+  index=0;
+  b=fabs(D[1]);
+  c=fabs(D[2]);
+  if(b>max) max=b,index=1;
+  if(c>max) max=c,index=2;
+
+        /* this is the simplified projection onto L*/
+        vp0=V0[index];
+        vp1=V1[index];
+        vp2=V2[index];
+
+        up0=U0[index];
+        up1=U1[index];
+        up2=U2[index];
+
+  /* compute interval for triangle 1 */
+  COMPUTE_INTERVALS(vp0,vp1,vp2,dv0,dv1,dv2,dv0dv1,dv0dv2,isect1[0],isect1[1]);
+
+  /* compute interval for triangle 2 */
+  COMPUTE_INTERVALS(up0,up1,up2,du0,du1,du2,du0du1,du0du2,isect2[0],isect2[1]);
+
+  SORT(isect1[0],isect1[1]);
+  SORT(isect2[0],isect2[1]);
+
+  if(isect1[1]<isect2[0] || isect2[1]<isect1[0]) return qtrue;
+  return qfalse;
+}
\ No newline at end of file
diff --git a/codemp/game/vssver.scc b/codemp/game/vssver.scc
new file mode 100644
index 0000000..b713319
Binary files /dev/null and b/codemp/game/vssver.scc differ
diff --git a/codemp/game/w_force.c b/codemp/game/w_force.c
new file mode 100644
index 0000000..87d793c
--- /dev/null
+++ b/codemp/game/w_force.c
@@ -0,0 +1,5787 @@
+//#include "g_local.h"
+#include "b_local.h"
+#include "w_saber.h"
+#include "ai_main.h"
+#include "../ghoul2/G2.h"
+
+#define METROID_JUMP 1
+
+//NEEDED FOR MIND-TRICK on NPCS=========================================================
+extern void NPC_PlayConfusionSound( gentity_t *self );
+extern void NPC_Jedi_PlayConfusionSound( gentity_t *self );
+extern void NPC_UseResponse( gentity_t *self, gentity_t *user, qboolean useWhenDone );
+//NEEDED FOR MIND-TRICK on NPCS=========================================================
+extern void Jedi_Decloak( gentity_t *self );
+
+extern vmCvar_t		g_saberRestrictForce;
+
+#include "../namespace_begin.h"
+extern qboolean BG_FullBodyTauntAnim( int anim );
+#include "../namespace_end.h"
+
+extern bot_state_t *botstates[MAX_CLIENTS];
+
+int speedLoopSound = 0;
+ 
+int rageLoopSound = 0;
+
+int protectLoopSound = 0;
+
+int absorbLoopSound = 0;
+
+int seeLoopSound = 0;
+
+int	ysalamiriLoopSound = 0;
+
+#define FORCE_VELOCITY_DAMAGE 0
+
+int ForceShootDrain( gentity_t *self );
+
+gentity_t *G_PreDefSound(vec3_t org, int pdSound)
+{
+	gentity_t	*te;
+
+	te = G_TempEntity( org, EV_PREDEFSOUND );
+	te->s.eventParm = pdSound;
+	VectorCopy(org, te->s.origin);
+
+	return te;
+}
+
+const int forcePowerMinRank[NUM_FORCE_POWER_LEVELS][NUM_FORCE_POWERS] = //0 == neutral
+{
+	{
+		999,//FP_HEAL,//instant
+		999,//FP_LEVITATION,//hold/duration
+		999,//FP_SPEED,//duration
+		999,//FP_PUSH,//hold/duration
+		999,//FP_PULL,//hold/duration
+		999,//FP_TELEPATHY,//instant
+		999,//FP_GRIP,//hold/duration
+		999,//FP_LIGHTNING,//hold/duration
+		999,//FP_RAGE,//duration
+		999,//FP_PROTECT,//duration
+		999,//FP_ABSORB,//duration
+		999,//FP_TEAM_HEAL,//instant
+		999,//FP_TEAM_FORCE,//instant
+		999,//FP_DRAIN,//hold/duration
+		999,//FP_SEE,//duration
+		999,//FP_SABER_OFFENSE,
+		999,//FP_SABER_DEFENSE,
+		999//FP_SABERTHROW,
+		//NUM_FORCE_POWERS
+	},
+	{
+		10,//FP_HEAL,//instant
+		0,//FP_LEVITATION,//hold/duration
+		0,//FP_SPEED,//duration
+		0,//FP_PUSH,//hold/duration
+		0,//FP_PULL,//hold/duration
+		10,//FP_TELEPATHY,//instant
+		15,//FP_GRIP,//hold/duration
+		10,//FP_LIGHTNING,//hold/duration
+		15,//FP_RAGE,//duration
+		15,//FP_PROTECT,//duration
+		15,//FP_ABSORB,//duration
+		10,//FP_TEAM_HEAL,//instant
+		10,//FP_TEAM_FORCE,//instant
+		10,//FP_DRAIN,//hold/duration
+		5,//FP_SEE,//duration
+		0,//FP_SABER_OFFENSE,
+		0,//FP_SABER_DEFENSE,
+		0//FP_SABERTHROW,
+		//NUM_FORCE_POWERS
+	},
+	{
+		10,//FP_HEAL,//instant
+		0,//FP_LEVITATION,//hold/duration
+		0,//FP_SPEED,//duration
+		0,//FP_PUSH,//hold/duration
+		0,//FP_PULL,//hold/duration
+		10,//FP_TELEPATHY,//instant
+		15,//FP_GRIP,//hold/duration
+		10,//FP_LIGHTNING,//hold/duration
+		15,//FP_RAGE,//duration
+		15,//FP_PROTECT,//duration
+		15,//FP_ABSORB,//duration
+		10,//FP_TEAM_HEAL,//instant
+		10,//FP_TEAM_FORCE,//instant
+		10,//FP_DRAIN,//hold/duration
+		5,//FP_SEE,//duration
+		5,//FP_SABER_OFFENSE,
+		5,//FP_SABER_DEFENSE,
+		5//FP_SABERTHROW,
+		//NUM_FORCE_POWERS
+	},
+	{
+		10,//FP_HEAL,//instant
+		0,//FP_LEVITATION,//hold/duration
+		0,//FP_SPEED,//duration
+		0,//FP_PUSH,//hold/duration
+		0,//FP_PULL,//hold/duration
+		10,//FP_TELEPATHY,//instant
+		15,//FP_GRIP,//hold/duration
+		10,//FP_LIGHTNING,//hold/duration
+		15,//FP_RAGE,//duration
+		15,//FP_PROTECT,//duration
+		15,//FP_ABSORB,//duration
+		10,//FP_TEAM_HEAL,//instant
+		10,//FP_TEAM_FORCE,//instant
+		10,//FP_DRAIN,//hold/duration
+		5,//FP_SEE,//duration
+		10,//FP_SABER_OFFENSE,
+		10,//FP_SABER_DEFENSE,
+		10//FP_SABERTHROW,
+		//NUM_FORCE_POWERS
+	}
+};
+
+const int mindTrickTime[NUM_FORCE_POWER_LEVELS] =
+{
+	0,//none
+	5000,
+	10000,
+	15000
+};
+
+void WP_InitForcePowers( gentity_t *ent )
+{
+	int i;
+	int i_r;
+	int maxRank = g_maxForceRank.integer;
+	qboolean warnClient = qfalse;
+	qboolean warnClientLimit = qfalse;
+	char userinfo[MAX_INFO_STRING];
+	char forcePowers[256];
+	char readBuf[256];
+	int lastFPKnown = -1;
+	qboolean didEvent = qfalse;
+
+	if (!maxRank)
+	{ //if server has no max rank, default to max (50)
+		maxRank = FORCE_MASTERY_JEDI_MASTER;
+	}
+
+	/*
+	if (g_forcePowerDisable.integer)
+	{
+		maxRank = FORCE_MASTERY_UNINITIATED;
+	}
+	*/
+	//rww - don't do this
+
+	if ( !ent || !ent->client )
+	{
+		return;
+	}
+
+	ent->client->ps.fd.saberAnimLevel = ent->client->sess.saberLevel;
+
+	if (ent->client->ps.fd.saberAnimLevel < FORCE_LEVEL_1 ||
+		ent->client->ps.fd.saberAnimLevel > FORCE_LEVEL_3)
+	{
+		ent->client->ps.fd.saberAnimLevel = FORCE_LEVEL_1;
+	}
+
+	if (!speedLoopSound)
+	{ //so that the client configstring is already modified with this when we need it
+		speedLoopSound = G_SoundIndex("sound/weapons/force/speedloop.wav");
+	}
+
+	if (!rageLoopSound)
+	{
+		rageLoopSound = G_SoundIndex("sound/weapons/force/rageloop.wav");
+	}
+
+	if (!absorbLoopSound)
+	{
+		absorbLoopSound = G_SoundIndex("sound/weapons/force/absorbloop.wav");
+	}
+
+	if (!protectLoopSound)
+	{
+		protectLoopSound = G_SoundIndex("sound/weapons/force/protectloop.wav");
+	}
+
+	if (!seeLoopSound)
+	{
+		seeLoopSound = G_SoundIndex("sound/weapons/force/seeloop.wav");
+	}
+
+	if (!ysalamiriLoopSound)
+	{
+		ysalamiriLoopSound = G_SoundIndex("sound/player/nullifyloop.wav");
+	}
+
+	if (ent->s.eType == ET_NPC)
+	{ //just stop here then.
+		return;
+	}
+
+	i = 0;
+	while (i < NUM_FORCE_POWERS)
+	{
+		ent->client->ps.fd.forcePowerLevel[i] = 0;
+		ent->client->ps.fd.forcePowersKnown &= ~(1 << i);
+		i++;
+	}
+
+	ent->client->ps.fd.forcePowerSelected = -1;
+
+	ent->client->ps.fd.forceSide = 0;
+
+	if (g_gametype.integer == GT_SIEGE &&
+		ent->client->siegeClass != -1)
+	{ //Then use the powers for this class, and skip all this nonsense.
+		i = 0;
+
+		while (i < NUM_FORCE_POWERS)
+		{
+			ent->client->ps.fd.forcePowerLevel[i] = bgSiegeClasses[ent->client->siegeClass].forcePowerLevels[i];
+
+			if (!ent->client->ps.fd.forcePowerLevel[i])
+			{
+				ent->client->ps.fd.forcePowersKnown &= ~(1 << i);
+			}
+			else
+			{
+				ent->client->ps.fd.forcePowersKnown |= (1 << i);
+			}
+			i++;
+		}
+
+		if (!ent->client->sess.setForce)
+		{
+			//bring up the class selection menu
+			trap_SendServerCommand(ent-g_entities, "scl");
+		}
+		ent->client->sess.setForce = qtrue;
+
+		return;
+	}
+
+	if (ent->s.eType == ET_NPC && ent->s.number >= MAX_CLIENTS)
+	{ //rwwFIXMEFIXME: Temp
+		strcpy(userinfo, "forcepowers\\7-1-333003000313003120");
+	}
+	else
+	{
+		trap_GetUserinfo( ent->s.number, userinfo, sizeof( userinfo ) );
+	}
+
+	Q_strncpyz( forcePowers, Info_ValueForKey (userinfo, "forcepowers"), sizeof( forcePowers ) );
+
+	if ( (ent->r.svFlags & SVF_BOT) && botstates[ent->s.number] )
+	{ //if it's a bot just copy the info directly from its personality
+		Com_sprintf(forcePowers, sizeof(forcePowers), "%s\0", botstates[ent->s.number]->forceinfo);
+	}
+
+	//rww - parse through the string manually and eat out all the appropriate data
+	i = 0;
+
+	if (g_forceBasedTeams.integer)
+	{
+		if (ent->client->sess.sessionTeam == TEAM_RED)
+		{
+			warnClient = !(BG_LegalizedForcePowers(forcePowers, maxRank, HasSetSaberOnly(), FORCE_DARKSIDE, g_gametype.integer, g_forcePowerDisable.integer));
+		}
+		else if (ent->client->sess.sessionTeam == TEAM_BLUE)
+		{
+			warnClient = !(BG_LegalizedForcePowers(forcePowers, maxRank, HasSetSaberOnly(), FORCE_LIGHTSIDE, g_gametype.integer, g_forcePowerDisable.integer));
+		}
+		else
+		{
+			warnClient = !(BG_LegalizedForcePowers(forcePowers, maxRank, HasSetSaberOnly(), 0, g_gametype.integer, g_forcePowerDisable.integer));
+		}
+	}
+	else
+	{
+		warnClient = !(BG_LegalizedForcePowers(forcePowers, maxRank, HasSetSaberOnly(), 0, g_gametype.integer, g_forcePowerDisable.integer));
+	}
+
+	i_r = 0;
+	while (forcePowers[i] && forcePowers[i] != '-')
+	{
+		readBuf[i_r] = forcePowers[i];
+		i_r++;
+		i++;
+	}
+	readBuf[i_r] = 0;
+	//THE RANK
+	ent->client->ps.fd.forceRank = atoi(readBuf);
+	i++;
+
+	i_r = 0;
+	while (forcePowers[i] && forcePowers[i] != '-')
+	{
+		readBuf[i_r] = forcePowers[i];
+		i_r++;
+		i++;
+	}
+	readBuf[i_r] = 0;
+	//THE SIDE
+	ent->client->ps.fd.forceSide = atoi(readBuf);
+	i++;
+
+
+	if ( g_gametype.integer != GT_SIEGE && (ent->r.svFlags & SVF_BOT) && botstates[ent->s.number] )
+	{ //hmm..I'm going to cheat here.
+		int oldI = i;
+		i_r = 0;
+		while (forcePowers[i] && forcePowers[i] != '\n' &&
+			i_r < NUM_FORCE_POWERS)
+		{
+			if (ent->client->ps.fd.forceSide == FORCE_LIGHTSIDE)
+			{
+				if (i_r == FP_ABSORB)
+				{
+					forcePowers[i] = '3';
+				}
+				if (botstates[ent->s.number]->settings.skill >= 4)
+				{ //cheat and give them more stuff
+					if (i_r == FP_HEAL)
+					{
+						forcePowers[i] = '3';
+					}
+					else if (i_r == FP_PROTECT)
+					{
+						forcePowers[i] = '3';
+					}
+				}
+			}
+			else if (ent->client->ps.fd.forceSide == FORCE_DARKSIDE)
+			{
+				if (botstates[ent->s.number]->settings.skill >= 4)
+				{
+					if (i_r == FP_GRIP)
+					{
+						forcePowers[i] = '3';
+					}
+					else if (i_r == FP_LIGHTNING)
+					{
+						forcePowers[i] = '3';
+					}
+					else if (i_r == FP_RAGE)
+					{
+						forcePowers[i] = '3';
+					}
+					else if (i_r == FP_DRAIN)
+					{
+						forcePowers[i] = '3';
+					}
+				}
+			}
+
+			if (i_r == FP_PUSH)
+			{
+				forcePowers[i] = '3';
+			}
+			else if (i_r == FP_PULL)
+			{
+				forcePowers[i] = '3';
+			}
+
+			i++;
+			i_r++;
+		}
+		i = oldI;
+	}
+
+	i_r = 0;
+	while (forcePowers[i] && forcePowers[i] != '\n' &&
+		i_r < NUM_FORCE_POWERS)
+	{
+		readBuf[0] = forcePowers[i];
+		readBuf[1] = 0;
+
+		ent->client->ps.fd.forcePowerLevel[i_r] = atoi(readBuf);
+		if (ent->client->ps.fd.forcePowerLevel[i_r])
+		{
+			ent->client->ps.fd.forcePowersKnown |= (1 << i_r);
+		}
+		else
+		{
+			ent->client->ps.fd.forcePowersKnown &= ~(1 << i_r);
+		}
+		i++;
+		i_r++;
+	}
+	//THE POWERS
+
+	if (ent->s.eType != ET_NPC)
+	{
+		if (HasSetSaberOnly())
+		{
+			gentity_t *te = G_TempEntity( vec3_origin, EV_SET_FREE_SABER );
+			te->r.svFlags |= SVF_BROADCAST;
+			te->s.eventParm = 1;
+		}
+		else
+		{
+			gentity_t *te = G_TempEntity( vec3_origin, EV_SET_FREE_SABER );
+			te->r.svFlags |= SVF_BROADCAST;
+			te->s.eventParm = 0;
+		}
+
+		if (g_forcePowerDisable.integer)
+		{
+			gentity_t *te = G_TempEntity( vec3_origin, EV_SET_FORCE_DISABLE );
+			te->r.svFlags |= SVF_BROADCAST;
+			te->s.eventParm = 1;
+		}
+		else
+		{
+			gentity_t *te = G_TempEntity( vec3_origin, EV_SET_FORCE_DISABLE );
+			te->r.svFlags |= SVF_BROADCAST;
+			te->s.eventParm = 0;
+		}
+	}
+
+	//rww - It seems we currently want to always do this, even if the player isn't exceeding the max
+	//rank, so..
+//	if (g_gametype.integer == GT_DUEL || g_gametype.integer == GT_POWERDUEL)
+//	{ //totally messes duel up to force someone into spec mode, and besides, each "round" is
+	  //counted as a full restart
+//		ent->client->sess.setForce = qtrue;
+//	}
+
+	if (ent->s.eType == ET_NPC)
+	{
+		ent->client->sess.setForce = qtrue;
+	}
+	else if (g_gametype.integer == GT_SIEGE)
+	{
+		if (!ent->client->sess.setForce)
+		{
+			ent->client->sess.setForce = qtrue;
+			//bring up the class selection menu
+			trap_SendServerCommand(ent-g_entities, "scl");
+		}
+	}
+	else
+	{
+		if (warnClient || !ent->client->sess.setForce)
+		{ //the client's rank is too high for the server and has been autocapped, so tell them
+			if (g_gametype.integer != GT_HOLOCRON && g_gametype.integer != GT_JEDIMASTER)
+			{
+#ifdef EVENT_FORCE_RANK
+				gentity_t *te = G_TempEntity( vec3_origin, EV_GIVE_NEW_RANK );
+
+				te->r.svFlags |= SVF_BROADCAST;
+				te->s.trickedentindex = ent->s.number;
+				te->s.eventParm = maxRank;
+				te->s.bolt1 = 0;
+#endif
+				didEvent = qtrue;
+
+//				if (!(ent->r.svFlags & SVF_BOT) && g_gametype.integer != GT_DUEL && g_gametype.integer != GT_POWERDUEL && ent->s.eType != ET_NPC)
+				if (!(ent->r.svFlags & SVF_BOT) && ent->s.eType != ET_NPC)
+				{
+					if (!g_teamAutoJoin.integer)
+					{
+						//Make them a spectator so they can set their powerups up without being bothered.
+						ent->client->sess.sessionTeam = TEAM_SPECTATOR;
+						ent->client->sess.spectatorState = SPECTATOR_FREE;
+						ent->client->sess.spectatorClient = 0;
+
+						ent->client->pers.teamState.state = TEAM_BEGIN;
+						trap_SendServerCommand(ent-g_entities, "spc");	// Fire up the profile menu
+					}
+				}
+
+#ifdef EVENT_FORCE_RANK
+				te->s.bolt2 = ent->client->sess.sessionTeam;
+#else
+				//Event isn't very reliable, I made it a string. This way I can send it to just one
+				//client also, as opposed to making a broadcast event.
+				trap_SendServerCommand(ent->s.number, va("nfr %i %i %i", maxRank, 1, ent->client->sess.sessionTeam));
+				//Arg1 is new max rank, arg2 is non-0 if force menu should be shown, arg3 is the current team
+#endif
+			}
+			ent->client->sess.setForce = qtrue;
+		}
+
+		if (!didEvent)
+		{
+#ifdef EVENT_FORCE_RANK
+			gentity_t *te = G_TempEntity( vec3_origin, EV_GIVE_NEW_RANK );
+
+			te->r.svFlags |= SVF_BROADCAST;
+			te->s.trickedentindex = ent->s.number;
+			te->s.eventParm = maxRank;
+			te->s.bolt1 = 1;
+			te->s.bolt2 = ent->client->sess.sessionTeam;
+#else
+			trap_SendServerCommand(ent->s.number, va("nfr %i %i %i", maxRank, 0, ent->client->sess.sessionTeam));
+#endif
+		}
+
+		if (warnClientLimit)
+		{ //the server has one or more force powers disabled and the client is using them in his config
+			//trap_SendServerCommand(ent-g_entities, va("print \"The server has one or more force powers that you have chosen disabled.\nYou will not be able to use the disable force power(s) while playing on this server.\n\""));
+		}
+	}
+
+	i = 0;
+	while (i < NUM_FORCE_POWERS)
+	{
+		if ((ent->client->ps.fd.forcePowersKnown & (1 << i)) &&
+			!ent->client->ps.fd.forcePowerLevel[i])
+		{ //err..
+			ent->client->ps.fd.forcePowersKnown &= ~(1 << i);
+		}
+		else
+		{
+			if (i != FP_LEVITATION && i != FP_SABER_OFFENSE && i != FP_SABER_DEFENSE && i != FP_SABERTHROW)
+			{
+				lastFPKnown = i;
+			}
+		}
+
+		i++;
+	}
+
+	if (ent->client->ps.fd.forcePowersKnown & ent->client->sess.selectedFP)
+	{
+		ent->client->ps.fd.forcePowerSelected = ent->client->sess.selectedFP;
+	}
+
+	if (!(ent->client->ps.fd.forcePowersKnown & (1 << ent->client->ps.fd.forcePowerSelected)))
+	{
+		if (lastFPKnown != -1)
+		{
+			ent->client->ps.fd.forcePowerSelected = lastFPKnown;
+		}
+		else
+		{
+			ent->client->ps.fd.forcePowerSelected = 0;
+		}
+	}
+
+	while (i < NUM_FORCE_POWERS)
+	{
+		ent->client->ps.fd.forcePowerBaseLevel[i] = ent->client->ps.fd.forcePowerLevel[i];
+		i++;
+	}
+	ent->client->ps.fd.forceUsingAdded = 0;
+}
+
+void WP_SpawnInitForcePowers( gentity_t *ent )
+{
+	int i = 0;
+
+	ent->client->ps.saberAttackChainCount = 0;
+
+	i = 0;
+
+	while (i < NUM_FORCE_POWERS)
+	{
+		if (ent->client->ps.fd.forcePowersActive & (1 << i))
+		{
+			WP_ForcePowerStop(ent, i);
+		}
+
+		i++;
+	}
+
+	ent->client->ps.fd.forceDeactivateAll = 0;
+
+	ent->client->ps.fd.forcePower = ent->client->ps.fd.forcePowerMax = FORCE_POWER_MAX;
+	ent->client->ps.fd.forcePowerRegenDebounceTime = 0;
+	ent->client->ps.fd.forceGripEntityNum = ENTITYNUM_NONE;
+	ent->client->ps.fd.forceMindtrickTargetIndex = 0;
+	ent->client->ps.fd.forceMindtrickTargetIndex2 = 0;
+	ent->client->ps.fd.forceMindtrickTargetIndex3 = 0;
+	ent->client->ps.fd.forceMindtrickTargetIndex4 = 0;
+
+	ent->client->ps.holocronBits = 0;
+
+	i = 0;
+	while (i < NUM_FORCE_POWERS)
+	{
+		ent->client->ps.holocronsCarried[i] = 0;
+		i++;
+	}
+
+	if (g_gametype.integer == GT_HOLOCRON)
+	{
+		i = 0;
+		while (i < NUM_FORCE_POWERS)
+		{
+			ent->client->ps.fd.forcePowerLevel[i] = FORCE_LEVEL_0;
+			i++;
+		}
+
+		if (HasSetSaberOnly())
+		{
+			if (ent->client->ps.fd.forcePowerLevel[FP_SABER_OFFENSE] < FORCE_LEVEL_1)
+			{
+				ent->client->ps.fd.forcePowerLevel[FP_SABER_OFFENSE] = FORCE_LEVEL_1;
+			}
+			if (ent->client->ps.fd.forcePowerLevel[FP_SABER_DEFENSE] < FORCE_LEVEL_1)
+			{
+				ent->client->ps.fd.forcePowerLevel[FP_SABER_DEFENSE] = FORCE_LEVEL_1;
+			}
+		}
+	}
+
+	i = 0;
+
+	while (i < NUM_FORCE_POWERS)
+	{
+		ent->client->ps.fd.forcePowerDebounce[i] = 0;
+		ent->client->ps.fd.forcePowerDuration[i] = 0;
+
+		i++;
+	}
+
+	ent->client->ps.fd.forcePowerRegenDebounceTime = 0;
+	ent->client->ps.fd.forceJumpZStart = 0;
+	ent->client->ps.fd.forceJumpCharge = 0;
+	ent->client->ps.fd.forceJumpSound = 0;
+	ent->client->ps.fd.forceGripDamageDebounceTime = 0;
+	ent->client->ps.fd.forceGripBeingGripped = 0;
+	ent->client->ps.fd.forceGripCripple = 0;
+	ent->client->ps.fd.forceGripUseTime = 0;
+	ent->client->ps.fd.forceGripSoundTime = 0;
+	ent->client->ps.fd.forceGripStarted = 0;
+	ent->client->ps.fd.forceHealTime = 0;
+	ent->client->ps.fd.forceHealAmount = 0;
+	ent->client->ps.fd.forceRageRecoveryTime = 0;
+	ent->client->ps.fd.forceDrainEntNum = ENTITYNUM_NONE;
+	ent->client->ps.fd.forceDrainTime = 0;
+
+	i = 0;
+	while (i < NUM_FORCE_POWERS)
+	{
+		if ((ent->client->ps.fd.forcePowersKnown & (1 << i)) &&
+			!ent->client->ps.fd.forcePowerLevel[i])
+		{ //make sure all known powers are cleared if we have level 0 in them
+			ent->client->ps.fd.forcePowersKnown &= ~(1 << i);
+		}
+
+		i++;
+	}
+
+	if (g_gametype.integer == GT_SIEGE &&
+		ent->client->siegeClass != -1)
+	{ //Then use the powers for this class.
+		i = 0;
+
+		while (i < NUM_FORCE_POWERS)
+		{
+			ent->client->ps.fd.forcePowerLevel[i] = bgSiegeClasses[ent->client->siegeClass].forcePowerLevels[i];
+
+			if (!ent->client->ps.fd.forcePowerLevel[i])
+			{
+				ent->client->ps.fd.forcePowersKnown &= ~(1 << i);
+			}
+			else
+			{
+				ent->client->ps.fd.forcePowersKnown |= (1 << i);
+			}
+			i++;
+		}
+	}
+}
+
+#include "../namespace_begin.h"
+extern qboolean BG_InKnockDown( int anim ); //bg_pmove.c
+#include "../namespace_end.h"
+
+int ForcePowerUsableOn(gentity_t *attacker, gentity_t *other, forcePowers_t forcePower)
+{
+	if (other && other->client && BG_HasYsalamiri(g_gametype.integer, &other->client->ps))
+	{
+		return 0;
+	}
+
+	if (attacker && attacker->client && !BG_CanUseFPNow(g_gametype.integer, &attacker->client->ps, level.time, forcePower))
+	{
+		return 0;
+	}
+
+	//Dueling fighters cannot use force powers on others, with the exception of force push when locked with each other
+	if (attacker && attacker->client && attacker->client->ps.duelInProgress)
+	{
+		return 0;
+	}
+
+	if (other && other->client && other->client->ps.duelInProgress)
+	{
+		return 0;
+	}
+
+	if (forcePower == FP_GRIP)
+	{
+		if (other && other->client &&
+			(other->client->ps.fd.forcePowersActive & (1<<FP_ABSORB)))
+		{ //don't allow gripping to begin with if they are absorbing
+			//play sound indicating that attack was absorbed
+			if (other->client->forcePowerSoundDebounce < level.time)
+			{
+				gentity_t *abSound = G_PreDefSound(other->client->ps.origin, PDSOUND_ABSORBHIT);
+				abSound->s.trickedentindex = other->s.number;
+				other->client->forcePowerSoundDebounce = level.time + 400;
+			}
+			return 0;
+		}
+		else if (other && other->client &&
+			other->client->ps.weapon == WP_SABER &&
+			BG_SaberInSpecial(other->client->ps.saberMove))
+		{ //don't grip person while they are in a special or some really bad things can happen.
+			return 0;
+		}
+	}
+
+	if (other && other->client &&
+		(forcePower == FP_PUSH ||
+		forcePower == FP_PULL))
+	{
+		if (BG_InKnockDown(other->client->ps.legsAnim))
+		{
+			return 0;
+		}
+	}
+
+	if (other && other->client && other->s.eType == ET_NPC &&
+		other->s.NPC_class == CLASS_VEHICLE)
+	{ //can't use the force on vehicles.. except lightning
+		if (forcePower == FP_LIGHTNING)
+		{
+			return 1;
+		}
+		else
+		{
+			return 0;
+		}
+	}
+
+	if (other && other->client && other->s.eType == ET_NPC &&
+		g_gametype.integer == GT_SIEGE)
+	{ //can't use powers at all on npc's normally in siege...
+		return 0;
+	}
+
+	return 1;
+}
+
+qboolean WP_ForcePowerAvailable( gentity_t *self, forcePowers_t forcePower, int overrideAmt )
+{
+	int	drain = overrideAmt ? overrideAmt :
+				forcePowerNeeded[self->client->ps.fd.forcePowerLevel[forcePower]][forcePower];
+
+	if (self->client->ps.fd.forcePowersActive & (1 << forcePower))
+	{ //we're probably going to deactivate it..
+		return qtrue;
+	}
+	if ( forcePower == FP_LEVITATION )
+	{
+		return qtrue;
+	}
+	if ( !drain )
+	{
+		return qtrue;
+	}
+	if ((forcePower == FP_DRAIN || forcePower == FP_LIGHTNING) &&
+		self->client->ps.fd.forcePower >= 25)
+	{ //it's ok then, drain/lightning are actually duration
+		return qtrue;
+	}
+	if ( self->client->ps.fd.forcePower < drain )
+	{
+		return qfalse;
+	}
+	return qtrue;
+}
+
+qboolean WP_ForcePowerInUse( gentity_t *self, forcePowers_t forcePower )
+{
+	if ( (self->client->ps.fd.forcePowersActive & ( 1 << forcePower )) )
+	{//already using this power
+		return qtrue;
+	}
+
+	return qfalse;
+}
+
+qboolean WP_ForcePowerUsable( gentity_t *self, forcePowers_t forcePower )
+{
+	if (BG_HasYsalamiri(g_gametype.integer, &self->client->ps))
+	{
+		return qfalse;
+	}
+
+	if (self->health <= 0 || self->client->ps.stats[STAT_HEALTH] <= 0 ||
+		(self->client->ps.eFlags & EF_DEAD))
+	{
+		return qfalse;
+	}
+
+	if (self->client->ps.pm_flags & PMF_FOLLOW)
+	{ //specs can't use powers through people
+		return qfalse;
+	}
+	if (self->client->sess.sessionTeam == TEAM_SPECTATOR)
+	{
+		return qfalse;
+	}
+	if (self->client->tempSpectate >= level.time)
+	{
+		return qfalse;
+	}
+
+	if (!BG_CanUseFPNow(g_gametype.integer, &self->client->ps, level.time, forcePower))
+	{
+		return qfalse;
+	}
+
+	if ( !(self->client->ps.fd.forcePowersKnown & ( 1 << forcePower )) )
+	{//don't know this power
+		return qfalse;
+	}
+	
+	if ( (self->client->ps.fd.forcePowersActive & ( 1 << forcePower )) )
+	{//already using this power
+		if (forcePower != FP_LEVITATION)
+		{
+			return qfalse;
+		}
+	}
+
+	if (forcePower == FP_LEVITATION && self->client->fjDidJump)
+	{
+		return qfalse;
+	}
+
+	if (!self->client->ps.fd.forcePowerLevel[forcePower])
+	{
+		return qfalse;
+	}
+
+	if ( g_debugMelee.integer )
+	{
+		if ( (self->client->ps.pm_flags&PMF_STUCK_TO_WALL) )
+		{//no offensive force powers when stuck to wall
+			switch ( forcePower )
+			{
+			case FP_GRIP:
+			case FP_LIGHTNING:
+			case FP_DRAIN:
+			case FP_SABER_OFFENSE:
+			case FP_SABER_DEFENSE:
+			case FP_SABERTHROW:
+				return qfalse;
+				break;
+			}
+		}
+	}
+
+	if ( !self->client->ps.saberHolstered )
+	{
+		if ( self->client->saber[0].twoHanded )
+		{
+			if ( g_saberRestrictForce.integer )
+			{
+				switch ( forcePower )
+				{
+				case FP_PUSH:
+				case FP_PULL:
+				case FP_TELEPATHY:
+				case FP_GRIP:
+				case FP_LIGHTNING:
+				case FP_DRAIN:
+					return qfalse;
+					break;
+				}
+			}
+		}
+
+		if ( self->client->saber[0].twoHanded 
+			|| (self->client->saber[0].model && self->client->saber[0].model[0]) )
+		{//this saber requires the use of two hands OR our other hand is using an active saber too
+			if ( (self->client->saber[0].forceRestrictions&(1<<forcePower)) )
+			{//this power is verboten when using this saber
+				return qfalse;
+			}
+		}
+
+		if ( self->client->saber[0].model 
+			&& self->client->saber[0].model[0] )
+		{//both sabers on
+			if ( g_saberRestrictForce.integer )
+			{
+				switch ( forcePower )
+				{
+				case FP_PUSH:
+				case FP_PULL:
+				case FP_TELEPATHY:
+				case FP_GRIP:
+				case FP_LIGHTNING:
+				case FP_DRAIN:
+					return qfalse;
+					break;
+				}
+			}
+			if ( (self->client->saber[1].forceRestrictions&(1<<forcePower)) )
+			{//this power is verboten when using this saber
+				return qfalse;
+			}
+		}
+	}
+	return WP_ForcePowerAvailable( self, forcePower, 0 );	// OVERRIDEFIXME
+}
+
+int WP_AbsorbConversion(gentity_t *attacked, int atdAbsLevel, gentity_t *attacker, int atPower, int atPowerLevel, int atForceSpent)
+{
+	int getLevel = 0;
+	int addTot = 0;
+	gentity_t *abSound;
+
+	if (atPower != FP_LIGHTNING &&
+		atPower != FP_DRAIN &&
+		atPower != FP_GRIP &&
+		atPower != FP_PUSH &&
+		atPower != FP_PULL)
+	{ //Only these powers can be absorbed
+		return -1;
+	}
+
+	if (!atdAbsLevel)
+	{ //looks like attacker doesn't have any absorb power
+		return -1;
+	}
+
+	if (!(attacked->client->ps.fd.forcePowersActive & (1 << FP_ABSORB)))
+	{ //absorb is not active
+		return -1;
+	}
+
+	//Subtract absorb power level from the offensive force power
+	getLevel = atPowerLevel;
+	getLevel -= atdAbsLevel;
+
+	if (getLevel < 0)
+	{
+		getLevel = 0;
+	}
+
+	//let the attacker absorb an amount of force used in this attack based on his level of absorb
+	addTot = (atForceSpent/3)*attacked->client->ps.fd.forcePowerLevel[FP_ABSORB];
+
+	if (addTot < 1 && atForceSpent >= 1)
+	{
+		addTot = 1;
+	}
+	attacked->client->ps.fd.forcePower += addTot;
+	if (attacked->client->ps.fd.forcePower > 100)
+	{
+		attacked->client->ps.fd.forcePower = 100;
+	}
+
+	//play sound indicating that attack was absorbed
+	if (attacked->client->forcePowerSoundDebounce < level.time)
+	{
+		abSound = G_PreDefSound(attacked->client->ps.origin, PDSOUND_ABSORBHIT);
+		abSound->s.trickedentindex = attacked->s.number;
+
+		attacked->client->forcePowerSoundDebounce = level.time + 400;
+	}
+
+	return getLevel;
+}
+
+void WP_ForcePowerRegenerate( gentity_t *self, int overrideAmt )
+{ //called on a regular interval to regenerate force power.
+	if ( !self->client )
+	{
+		return;
+	}
+
+	if ( overrideAmt )
+	{ //custom regen amount
+		self->client->ps.fd.forcePower += overrideAmt;
+	}
+	else
+	{ //otherwise, just 1
+		self->client->ps.fd.forcePower++;
+	}
+
+	if ( self->client->ps.fd.forcePower > self->client->ps.fd.forcePowerMax )
+	{ //cap it off at the max (default 100)
+		self->client->ps.fd.forcePower = self->client->ps.fd.forcePowerMax;
+	}
+}
+
+void WP_ForcePowerStart( gentity_t *self, forcePowers_t forcePower, int overrideAmt )
+{ //activate the given force power
+	int	duration = 0;
+	qboolean hearable = qfalse;
+	float hearDist = 0;
+
+	if (!WP_ForcePowerAvailable( self, forcePower, overrideAmt ))
+	{
+		return;
+	}
+
+	if ( BG_FullBodyTauntAnim( self->client->ps.legsAnim ) )
+	{//stop taunt
+		self->client->ps.legsTimer = 0;
+	}
+	if ( BG_FullBodyTauntAnim( self->client->ps.torsoAnim ) )
+	{//stop taunt
+		self->client->ps.torsoTimer = 0;
+	}
+	//hearable and hearDist are merely for the benefit of bots, and not related to if a sound is actually played.
+	//If duration is set, the force power will assume to be timer-based.
+	switch( (int)forcePower )
+	{
+	case FP_HEAL:
+		hearable = qtrue;
+		hearDist = 256;
+		self->client->ps.fd.forcePowersActive |= ( 1 << forcePower );
+		break;
+	case FP_LEVITATION:
+		hearable = qtrue;
+		hearDist = 256;
+		self->client->ps.fd.forcePowersActive |= ( 1 << forcePower );
+		break;
+	case FP_SPEED:
+		hearable = qtrue;
+		hearDist = 256;
+		if (self->client->ps.fd.forcePowerLevel[FP_SPEED] == FORCE_LEVEL_1)
+		{
+			duration = 10000;
+		}
+		else if (self->client->ps.fd.forcePowerLevel[FP_SPEED] == FORCE_LEVEL_2)
+		{
+			duration = 15000;
+		}
+		else if (self->client->ps.fd.forcePowerLevel[FP_SPEED] == FORCE_LEVEL_3)
+		{
+			duration = 20000;
+		}
+		else //shouldn't get here
+		{
+			break;
+		}
+
+		if (overrideAmt)
+		{
+			duration = overrideAmt;
+		}
+
+		self->client->ps.fd.forcePowersActive |= ( 1 << forcePower );
+		break;
+	case FP_PUSH:
+		hearable = qtrue;
+		hearDist = 256;
+		break;
+	case FP_PULL:
+		hearable = qtrue;
+		hearDist = 256;
+		break;
+	case FP_TELEPATHY:
+		hearable = qtrue;
+		hearDist = 256;
+		if (self->client->ps.fd.forcePowerLevel[FP_TELEPATHY] == FORCE_LEVEL_1)
+		{
+			duration = 20000;
+		}
+		else if (self->client->ps.fd.forcePowerLevel[FP_TELEPATHY] == FORCE_LEVEL_2)
+		{
+			duration = 25000;
+		}
+		else if (self->client->ps.fd.forcePowerLevel[FP_TELEPATHY] == FORCE_LEVEL_3)
+		{
+			duration = 30000;
+		}
+		else //shouldn't get here
+		{
+			break;
+		}
+
+		self->client->ps.fd.forcePowersActive |= ( 1 << forcePower );
+		break;
+	case FP_GRIP:
+		hearable = qtrue;
+		hearDist = 256;
+		self->client->ps.fd.forcePowersActive |= ( 1 << forcePower );
+		self->client->ps.powerups[PW_DISINT_4] = level.time + 60000;
+		break;
+	case FP_LIGHTNING:
+		hearable = qtrue;
+		hearDist = 512;
+		duration = overrideAmt;
+		overrideAmt = 0;
+		self->client->ps.fd.forcePowersActive |= ( 1 << forcePower );
+		self->client->ps.activeForcePass = self->client->ps.fd.forcePowerLevel[FP_LIGHTNING];
+		break;
+	case FP_RAGE:
+		hearable = qtrue;
+		hearDist = 256;
+		if (self->client->ps.fd.forcePowerLevel[FP_RAGE] == FORCE_LEVEL_1)
+		{
+			duration = 8000;
+		}
+		else if (self->client->ps.fd.forcePowerLevel[FP_RAGE] == FORCE_LEVEL_2)
+		{
+			duration = 14000;
+		}
+		else if (self->client->ps.fd.forcePowerLevel[FP_RAGE] == FORCE_LEVEL_3)
+		{
+			duration = 20000;
+		}
+		else //shouldn't get here
+		{
+			break;
+		}
+
+		self->client->ps.fd.forcePowersActive |= ( 1 << forcePower );
+		break;
+	case FP_PROTECT:
+		hearable = qtrue;
+		hearDist = 256;
+		duration = 20000;
+		self->client->ps.fd.forcePowersActive |= ( 1 << forcePower );
+		break;
+	case FP_ABSORB:
+		hearable = qtrue;
+		hearDist = 256;
+		duration = 20000;
+		self->client->ps.fd.forcePowersActive |= ( 1 << forcePower );
+		break;
+	case FP_TEAM_HEAL:
+		hearable = qtrue;
+		hearDist = 256;
+		self->client->ps.fd.forcePowersActive |= ( 1 << forcePower );
+		break;
+	case FP_TEAM_FORCE:
+		hearable = qtrue;
+		hearDist = 256;
+		self->client->ps.fd.forcePowersActive |= ( 1 << forcePower );
+		break;
+	case FP_DRAIN:
+		hearable = qtrue;
+		hearDist = 256;
+		duration = overrideAmt;
+		overrideAmt = 0;
+		self->client->ps.fd.forcePowersActive |= ( 1 << forcePower );
+		//self->client->ps.activeForcePass = self->client->ps.fd.forcePowerLevel[FP_DRAIN];
+		break;
+	case FP_SEE:
+		hearable = qtrue;
+		hearDist = 256;
+		if (self->client->ps.fd.forcePowerLevel[FP_SEE] == FORCE_LEVEL_1)
+		{
+			duration = 10000;
+		}
+		else if (self->client->ps.fd.forcePowerLevel[FP_SEE] == FORCE_LEVEL_2)
+		{
+			duration = 20000;
+		}
+		else if (self->client->ps.fd.forcePowerLevel[FP_SEE] == FORCE_LEVEL_3)
+		{
+			duration = 30000;
+		}
+		else //shouldn't get here
+		{
+			break;
+		}
+
+		self->client->ps.fd.forcePowersActive |= ( 1 << forcePower );
+		break;
+	case FP_SABER_OFFENSE:
+		break;
+	case FP_SABER_DEFENSE:
+		break;
+	case FP_SABERTHROW:
+		break;
+	default:
+		break;
+	}
+
+	if ( duration )
+	{
+		self->client->ps.fd.forcePowerDuration[forcePower] = level.time + duration;
+	}
+	else
+	{
+		self->client->ps.fd.forcePowerDuration[forcePower] = 0;
+	}
+
+	if (hearable)
+	{
+		self->client->ps.otherSoundLen = hearDist;
+		self->client->ps.otherSoundTime = level.time + 100;
+	}
+	
+	self->client->ps.fd.forcePowerDebounce[forcePower] = 0;
+
+	if ((int)forcePower == FP_SPEED && overrideAmt)
+	{
+		BG_ForcePowerDrain( &self->client->ps, forcePower, overrideAmt*0.025 );
+	}
+	else if ((int)forcePower != FP_GRIP && (int)forcePower != FP_DRAIN)
+	{ //grip and drain drain as damage is done
+		BG_ForcePowerDrain( &self->client->ps, forcePower, overrideAmt );
+	}
+}
+
+void ForceHeal( gentity_t *self )
+{
+	if ( self->health <= 0 )
+	{
+		return;
+	}
+
+	if ( !WP_ForcePowerUsable( self, FP_HEAL ) )
+	{
+		return;
+	}
+
+	if ( self->health >= self->client->ps.stats[STAT_MAX_HEALTH])
+	{
+		return;
+	}
+
+	if (self->client->ps.fd.forcePowerLevel[FP_HEAL] == FORCE_LEVEL_3)
+	{
+		self->health += 25; //This was 50, but that angered the Balance God.
+		
+		if (self->health > self->client->ps.stats[STAT_MAX_HEALTH])
+		{
+			self->health = self->client->ps.stats[STAT_MAX_HEALTH];
+		}
+		BG_ForcePowerDrain( &self->client->ps, FP_HEAL, 0 );
+	}
+	else if (self->client->ps.fd.forcePowerLevel[FP_HEAL] == FORCE_LEVEL_2)
+	{
+		self->health += 10;
+		
+		if (self->health > self->client->ps.stats[STAT_MAX_HEALTH])
+		{
+			self->health = self->client->ps.stats[STAT_MAX_HEALTH];
+		}
+		BG_ForcePowerDrain( &self->client->ps, FP_HEAL, 0 );
+	}
+	else
+	{
+		self->health += 5;
+		
+		if (self->health > self->client->ps.stats[STAT_MAX_HEALTH])
+		{
+			self->health = self->client->ps.stats[STAT_MAX_HEALTH];
+		}
+		BG_ForcePowerDrain( &self->client->ps, FP_HEAL, 0 );
+	}
+	/*
+	else
+	{
+		WP_ForcePowerStart( self, FP_HEAL, 0 );
+	}
+	*/
+	//NOTE: Decided to make all levels instant.
+
+	G_Sound( self, CHAN_ITEM, G_SoundIndex("sound/weapons/force/heal.wav") );
+}
+
+void WP_AddToClientBitflags(gentity_t *ent, int entNum)
+{
+	if (!ent)
+	{
+		return;
+	}
+
+	if (entNum > 47)
+	{
+		ent->s.trickedentindex4 |= (1 << (entNum-48));
+	}
+	else if (entNum > 31)
+	{
+		ent->s.trickedentindex3 |= (1 << (entNum-32));
+	}
+	else if (entNum > 15)
+	{
+		ent->s.trickedentindex2 |= (1 << (entNum-16));
+	}
+	else
+	{
+		ent->s.trickedentindex |= (1 << entNum);
+	}
+}
+
+void ForceTeamHeal( gentity_t *self )
+{
+	float radius = 256;
+	int i = 0;
+	gentity_t *ent;
+	vec3_t a;
+	int numpl = 0;
+	int pl[MAX_CLIENTS];
+	int healthadd = 0;
+	gentity_t *te = NULL;
+
+	if ( self->health <= 0 )
+	{
+		return;
+	}
+
+	if ( !WP_ForcePowerUsable( self, FP_TEAM_HEAL ) )
+	{
+		return;
+	}
+
+	if (self->client->ps.fd.forcePowerDebounce[FP_TEAM_HEAL] >= level.time)
+	{
+		return;
+	}
+
+	if (self->client->ps.fd.forcePowerLevel[FP_TEAM_HEAL] == FORCE_LEVEL_2)
+	{
+		radius *= 1.5;
+	}
+	if (self->client->ps.fd.forcePowerLevel[FP_TEAM_HEAL] == FORCE_LEVEL_3)
+	{
+		radius *= 2;
+	}
+
+	while (i < MAX_CLIENTS)
+	{
+		ent = &g_entities[i];
+
+		if (ent && ent->client && self != ent && OnSameTeam(self, ent) && ent->client->ps.stats[STAT_HEALTH] < ent->client->ps.stats[STAT_MAX_HEALTH] && ent->client->ps.stats[STAT_HEALTH] > 0 && ForcePowerUsableOn(self, ent, FP_TEAM_HEAL) &&
+			trap_InPVS(self->client->ps.origin, ent->client->ps.origin))
+		{
+			VectorSubtract(self->client->ps.origin, ent->client->ps.origin, a);
+
+			if (VectorLength(a) <= radius)
+			{
+				pl[numpl] = i;
+				numpl++;
+			}
+		}
+
+		i++;
+	}
+
+	if (numpl < 1)
+	{
+		return;
+	}
+
+	if (numpl == 1)
+	{
+		healthadd = 50;
+	}
+	else if (numpl == 2)
+	{
+		healthadd = 33;
+	}
+	else
+	{
+		healthadd = 25;
+	}
+
+	self->client->ps.fd.forcePowerDebounce[FP_TEAM_HEAL] = level.time + 2000;
+	i = 0;
+
+	while (i < numpl)
+	{
+		if (g_entities[pl[i]].client->ps.stats[STAT_HEALTH] > 0 &&
+			g_entities[pl[i]].health > 0)
+		{
+			g_entities[pl[i]].client->ps.stats[STAT_HEALTH] += healthadd;
+			if (g_entities[pl[i]].client->ps.stats[STAT_HEALTH] > g_entities[pl[i]].client->ps.stats[STAT_MAX_HEALTH])
+			{
+				g_entities[pl[i]].client->ps.stats[STAT_HEALTH] = g_entities[pl[i]].client->ps.stats[STAT_MAX_HEALTH];
+			}
+
+			g_entities[pl[i]].health = g_entities[pl[i]].client->ps.stats[STAT_HEALTH];
+
+			//At this point we know we got one, so add him into the collective event client bitflag
+			if (!te)
+			{
+				te = G_TempEntity( self->client->ps.origin, EV_TEAM_POWER);
+				te->s.eventParm = 1; //eventParm 1 is heal, eventParm 2 is force regen
+
+				//since we had an extra check above, do the drain now because we got at least one guy
+				BG_ForcePowerDrain( &self->client->ps, FP_TEAM_HEAL, forcePowerNeeded[self->client->ps.fd.forcePowerLevel[FP_TEAM_HEAL]][FP_TEAM_HEAL] );
+			}
+
+			WP_AddToClientBitflags(te, pl[i]);
+			//Now cramming it all into one event.. doing this many g_sound events at once was a Bad Thing.
+		}
+		i++;
+	}
+}
+
+void ForceTeamForceReplenish( gentity_t *self )
+{
+	float radius = 256;
+	int i = 0;
+	gentity_t *ent;
+	vec3_t a;
+	int numpl = 0;
+	int pl[MAX_CLIENTS];
+	int poweradd = 0;
+	gentity_t *te = NULL;
+
+	if ( self->health <= 0 )
+	{
+		return;
+	}
+
+	if ( !WP_ForcePowerUsable( self, FP_TEAM_FORCE ) )
+	{
+		return;
+	}
+
+	if (self->client->ps.fd.forcePowerDebounce[FP_TEAM_FORCE] >= level.time)
+	{
+		return;
+	}
+
+	if (self->client->ps.fd.forcePowerLevel[FP_TEAM_FORCE] == FORCE_LEVEL_2)
+	{
+		radius *= 1.5;
+	}
+	if (self->client->ps.fd.forcePowerLevel[FP_TEAM_FORCE] == FORCE_LEVEL_3)
+	{
+		radius *= 2;
+	}
+
+	while (i < MAX_CLIENTS)
+	{
+		ent = &g_entities[i];
+
+		if (ent && ent->client && self != ent && OnSameTeam(self, ent) && ent->client->ps.fd.forcePower < 100 && ForcePowerUsableOn(self, ent, FP_TEAM_FORCE) &&
+			trap_InPVS(self->client->ps.origin, ent->client->ps.origin))
+		{
+			VectorSubtract(self->client->ps.origin, ent->client->ps.origin, a);
+
+			if (VectorLength(a) <= radius)
+			{
+				pl[numpl] = i;
+				numpl++;
+			}
+		}
+
+		i++;
+	}
+
+	if (numpl < 1)
+	{
+		return;
+	}
+
+	if (numpl == 1)
+	{
+		poweradd = 50;
+	}
+	else if (numpl == 2)
+	{
+		poweradd = 33;
+	}
+	else
+	{
+		poweradd = 25;
+	}
+	self->client->ps.fd.forcePowerDebounce[FP_TEAM_FORCE] = level.time + 2000;
+
+	BG_ForcePowerDrain( &self->client->ps, FP_TEAM_FORCE, forcePowerNeeded[self->client->ps.fd.forcePowerLevel[FP_TEAM_FORCE]][FP_TEAM_FORCE] );
+
+	i = 0;
+
+	while (i < numpl)
+	{
+		g_entities[pl[i]].client->ps.fd.forcePower += poweradd;
+		if (g_entities[pl[i]].client->ps.fd.forcePower > 100)
+		{
+			g_entities[pl[i]].client->ps.fd.forcePower = 100;
+		}
+
+		//At this point we know we got one, so add him into the collective event client bitflag
+		if (!te)
+		{
+			te = G_TempEntity( self->client->ps.origin, EV_TEAM_POWER);
+			te->s.eventParm = 2; //eventParm 1 is heal, eventParm 2 is force regen
+		}
+
+		WP_AddToClientBitflags(te, pl[i]);
+		//Now cramming it all into one event.. doing this many g_sound events at once was a Bad Thing.
+		
+		i++;
+	}
+}
+
+void ForceGrip( gentity_t *self )
+{
+	trace_t tr;
+	vec3_t tfrom, tto, fwd;
+
+	if ( self->health <= 0 )
+	{
+		return;
+	}
+
+	if (self->client->ps.forceHandExtend != HANDEXTEND_NONE)
+	{
+		return;
+	}
+
+	if (self->client->ps.weaponTime > 0)
+	{
+		return;
+	}
+
+	if (self->client->ps.fd.forceGripUseTime > level.time)
+	{
+		return;
+	}
+
+	if ( !WP_ForcePowerUsable( self, FP_GRIP ) )
+	{
+		return;
+	}
+
+	VectorCopy(self->client->ps.origin, tfrom);
+	tfrom[2] += self->client->ps.viewheight;
+	AngleVectors(self->client->ps.viewangles, fwd, NULL, NULL);
+	tto[0] = tfrom[0] + fwd[0]*MAX_GRIP_DISTANCE;
+	tto[1] = tfrom[1] + fwd[1]*MAX_GRIP_DISTANCE;
+	tto[2] = tfrom[2] + fwd[2]*MAX_GRIP_DISTANCE;
+
+	trap_Trace(&tr, tfrom, NULL, NULL, tto, self->s.number, MASK_PLAYERSOLID);
+
+	if ( tr.fraction != 1.0 &&
+		tr.entityNum != ENTITYNUM_NONE &&
+		g_entities[tr.entityNum].client &&
+		!g_entities[tr.entityNum].client->ps.fd.forceGripCripple &&
+		g_entities[tr.entityNum].client->ps.fd.forceGripBeingGripped < level.time &&
+		ForcePowerUsableOn(self, &g_entities[tr.entityNum], FP_GRIP) &&
+		(g_friendlyFire.integer || !OnSameTeam(self, &g_entities[tr.entityNum])) ) //don't grip someone who's still crippled
+	{
+		if (g_entities[tr.entityNum].s.number < MAX_CLIENTS && g_entities[tr.entityNum].client->ps.m_iVehicleNum)
+		{ //a player on a vehicle
+			gentity_t *vehEnt = &g_entities[g_entities[tr.entityNum].client->ps.m_iVehicleNum];
+			if (vehEnt->inuse && vehEnt->client && vehEnt->m_pVehicle)
+			{
+				if (vehEnt->m_pVehicle->m_pVehicleInfo->type == VH_SPEEDER ||
+					vehEnt->m_pVehicle->m_pVehicleInfo->type == VH_ANIMAL)
+				{ //push the guy off
+					vehEnt->m_pVehicle->m_pVehicleInfo->Eject(vehEnt->m_pVehicle, (bgEntity_t *)&g_entities[tr.entityNum], qfalse);
+				}
+			}
+		}
+		self->client->ps.fd.forceGripEntityNum = tr.entityNum;
+		g_entities[tr.entityNum].client->ps.fd.forceGripStarted = level.time;
+		self->client->ps.fd.forceGripDamageDebounceTime = 0;
+
+		self->client->ps.forceHandExtend = HANDEXTEND_FORCE_HOLD;
+		self->client->ps.forceHandExtendTime = level.time + 5000;
+	}
+	else
+	{
+		self->client->ps.fd.forceGripEntityNum = ENTITYNUM_NONE;
+		return;
+	}
+}
+
+void ForceSpeed( gentity_t *self, int forceDuration )
+{
+	if ( self->health <= 0 )
+	{
+		return;
+	}
+
+	if (self->client->ps.forceAllowDeactivateTime < level.time &&
+		(self->client->ps.fd.forcePowersActive & (1 << FP_SPEED)) )
+	{
+		WP_ForcePowerStop( self, FP_SPEED );
+		return;
+	}
+
+	if ( !WP_ForcePowerUsable( self, FP_SPEED ) )
+	{
+		return;
+	}
+
+	if ( self->client->holdingObjectiveItem >= MAX_CLIENTS  
+		&& self->client->holdingObjectiveItem < ENTITYNUM_WORLD )
+	{//holding Siege item
+		if ( g_entities[self->client->holdingObjectiveItem].genericValue15 )
+		{//disables force powers
+			return;
+		}
+	}
+
+	self->client->ps.forceAllowDeactivateTime = level.time + 1500;
+
+	WP_ForcePowerStart( self, FP_SPEED, forceDuration );
+	G_Sound( self, CHAN_BODY, G_SoundIndex("sound/weapons/force/speed.wav") );
+	G_Sound( self, TRACK_CHANNEL_2, speedLoopSound );
+}
+
+void ForceSeeing( gentity_t *self )
+{
+	if ( self->health <= 0 )
+	{
+		return;
+	}
+
+	if (self->client->ps.forceAllowDeactivateTime < level.time &&
+		(self->client->ps.fd.forcePowersActive & (1 << FP_SEE)) )
+	{
+		WP_ForcePowerStop( self, FP_SEE );
+		return;
+	}
+
+	if ( !WP_ForcePowerUsable( self, FP_SEE ) )
+	{
+		return;
+	}
+
+	self->client->ps.forceAllowDeactivateTime = level.time + 1500;
+
+	WP_ForcePowerStart( self, FP_SEE, 0 );
+
+	G_Sound( self, CHAN_AUTO, G_SoundIndex("sound/weapons/force/see.wav") );
+	G_Sound( self, TRACK_CHANNEL_5, seeLoopSound );
+}
+
+void ForceProtect( gentity_t *self )
+{
+	if ( self->health <= 0 )
+	{
+		return;
+	}
+
+	if (self->client->ps.forceAllowDeactivateTime < level.time &&
+		(self->client->ps.fd.forcePowersActive & (1 << FP_PROTECT)) )
+	{
+		WP_ForcePowerStop( self, FP_PROTECT );
+		return;
+	}
+
+	if ( !WP_ForcePowerUsable( self, FP_PROTECT ) )
+	{
+		return;
+	}
+
+	// Make sure to turn off Force Rage and Force Absorb.
+	if (self->client->ps.fd.forcePowersActive & (1 << FP_RAGE) )
+	{
+		WP_ForcePowerStop( self, FP_RAGE );
+	}
+	if (self->client->ps.fd.forcePowersActive & (1 << FP_ABSORB) )
+	{
+		WP_ForcePowerStop( self, FP_ABSORB );
+	}
+
+	self->client->ps.forceAllowDeactivateTime = level.time + 1500;
+
+	WP_ForcePowerStart( self, FP_PROTECT, 0 );
+	G_PreDefSound(self->client->ps.origin, PDSOUND_PROTECT);
+	G_Sound( self, TRACK_CHANNEL_3, protectLoopSound );
+}
+
+void ForceAbsorb( gentity_t *self )
+{
+	if ( self->health <= 0 )
+	{
+		return;
+	}
+
+	if (self->client->ps.forceAllowDeactivateTime < level.time &&
+		(self->client->ps.fd.forcePowersActive & (1 << FP_ABSORB)) )
+	{
+		WP_ForcePowerStop( self, FP_ABSORB );
+		return;
+	}
+
+	if ( !WP_ForcePowerUsable( self, FP_ABSORB ) )
+	{
+		return;
+	}
+
+	// Make sure to turn off Force Rage and Force Protection.
+	if (self->client->ps.fd.forcePowersActive & (1 << FP_RAGE) )
+	{
+		WP_ForcePowerStop( self, FP_RAGE );
+	}
+	if (self->client->ps.fd.forcePowersActive & (1 << FP_PROTECT) )
+	{
+		WP_ForcePowerStop( self, FP_PROTECT );
+	}
+
+	self->client->ps.forceAllowDeactivateTime = level.time + 1500;
+
+	WP_ForcePowerStart( self, FP_ABSORB, 0 );
+	G_PreDefSound(self->client->ps.origin, PDSOUND_ABSORB);
+	G_Sound( self, TRACK_CHANNEL_3, absorbLoopSound );
+}
+
+void ForceRage( gentity_t *self )
+{
+	if ( self->health <= 0 )
+	{
+		return;
+	}
+
+	if (self->client->ps.forceAllowDeactivateTime < level.time &&
+		(self->client->ps.fd.forcePowersActive & (1 << FP_RAGE)) )
+	{
+		WP_ForcePowerStop( self, FP_RAGE );
+		return;
+	}
+
+	if ( !WP_ForcePowerUsable( self, FP_RAGE ) )
+	{
+		return;
+	}
+
+	if (self->client->ps.fd.forceRageRecoveryTime >= level.time)
+	{
+		return;
+	}
+
+	if (self->health < 10)
+	{
+		return;
+	}
+
+	// Make sure to turn off Force Protection and Force Absorb.
+	if (self->client->ps.fd.forcePowersActive & (1 << FP_PROTECT) )
+	{
+		WP_ForcePowerStop( self, FP_PROTECT );
+	}
+	if (self->client->ps.fd.forcePowersActive & (1 << FP_ABSORB) )
+	{
+		WP_ForcePowerStop( self, FP_ABSORB );
+	}
+
+	self->client->ps.forceAllowDeactivateTime = level.time + 1500;
+
+	WP_ForcePowerStart( self, FP_RAGE, 0 );
+
+	G_Sound( self, TRACK_CHANNEL_4, G_SoundIndex("sound/weapons/force/rage.wav") );
+	G_Sound( self, TRACK_CHANNEL_3, rageLoopSound );
+}
+
+void ForceLightning( gentity_t *self )
+{
+	if ( self->health <= 0 )
+	{
+		return;
+	}
+	if ( self->client->ps.fd.forcePower < 25 || !WP_ForcePowerUsable( self, FP_LIGHTNING ) )
+	{
+		return;
+	}
+	if ( self->client->ps.fd.forcePowerDebounce[FP_LIGHTNING] > level.time )
+	{//stops it while using it and also after using it, up to 3 second delay
+		return;
+	}
+
+	if (self->client->ps.forceHandExtend != HANDEXTEND_NONE)
+	{
+		return;
+	}
+
+	if (self->client->ps.weaponTime > 0)
+	{
+		return;
+	}
+
+	//Shoot lightning from hand
+	//using grip anim now, to extend the burst time
+	self->client->ps.forceHandExtend = HANDEXTEND_FORCE_HOLD;
+	self->client->ps.forceHandExtendTime = level.time + 20000;
+
+	G_Sound( self, CHAN_BODY, G_SoundIndex("sound/weapons/force/lightning") );
+	
+	WP_ForcePowerStart( self, FP_LIGHTNING, 500 );
+}
+
+void ForceLightningDamage( gentity_t *self, gentity_t *traceEnt, vec3_t dir, vec3_t impactPoint )
+{
+	self->client->dangerTime = level.time;
+	self->client->ps.eFlags &= ~EF_INVULNERABLE;
+	self->client->invulnerableTimer = 0;
+
+	if ( traceEnt && traceEnt->takedamage )
+	{
+		if (!traceEnt->client && traceEnt->s.eType == ET_NPC)
+		{ //g2animent
+			if (traceEnt->s.genericenemyindex < level.time)
+			{
+				traceEnt->s.genericenemyindex = level.time + 2000;
+			}
+		}
+		if ( traceEnt->client )
+		{//an enemy or object
+			if (traceEnt->client->noLightningTime >= level.time)
+			{ //give them power and don't hurt them.
+				traceEnt->client->ps.fd.forcePower++;
+				if (traceEnt->client->ps.fd.forcePower > 100)
+				{
+					traceEnt->client->ps.fd.forcePower = 100;
+				}
+				return;
+			}
+			if (ForcePowerUsableOn(self, traceEnt, FP_LIGHTNING))
+			{
+				int	dmg = Q_irand(1,2); //Q_irand( 1, 3 );
+				
+				int modPowerLevel = -1;
+				
+				if (traceEnt->client)
+				{
+					modPowerLevel = WP_AbsorbConversion(traceEnt, traceEnt->client->ps.fd.forcePowerLevel[FP_ABSORB], self, FP_LIGHTNING, self->client->ps.fd.forcePowerLevel[FP_LIGHTNING], 1);
+				}
+
+				if (modPowerLevel != -1)
+				{
+					if (!modPowerLevel)
+					{
+						dmg = 0;
+						traceEnt->client->noLightningTime = level.time + 400;
+					}
+					else if (modPowerLevel == 1)
+					{
+						dmg = 1;
+						traceEnt->client->noLightningTime = level.time + 300;
+					}
+					else if (modPowerLevel == 2)
+					{
+						dmg = 1;
+						traceEnt->client->noLightningTime = level.time + 100;
+					}
+				}
+
+				if ( self->client->ps.weapon == WP_MELEE
+					&& self->client->ps.fd.forcePowerLevel[FP_LIGHTNING] > FORCE_LEVEL_2 )
+				{//2-handed lightning
+					//jackin' 'em up, Palpatine-style
+					dmg *= 2;
+				}
+
+				if (dmg)
+				{
+					//rww - Shields can now absorb lightning too.
+					G_Damage( traceEnt, self, self, dir, impactPoint, dmg, 0, MOD_FORCE_DARK );
+				}
+				if ( traceEnt->client )
+				{
+					if ( !Q_irand( 0, 2 ) )
+					{
+						G_Sound( traceEnt, CHAN_BODY, G_SoundIndex( va("sound/weapons/force/lightninghit%i", Q_irand(1, 3) )) );
+					}
+
+					if (traceEnt->client->ps.electrifyTime < (level.time + 400))
+					{ //only update every 400ms to reduce bandwidth usage (as it is passing a 32-bit time value)
+						traceEnt->client->ps.electrifyTime = level.time + 800;
+					}
+					if ( traceEnt->client->ps.powerups[PW_CLOAKED] )
+					{//disable cloak temporarily
+						Jedi_Decloak( traceEnt );
+						traceEnt->client->cloakToggleTime = level.time + Q_irand( 3000, 10000 );
+					}
+				}
+			}
+		}
+	}
+}
+
+void ForceShootLightning( gentity_t *self )
+{
+	trace_t	tr;
+	vec3_t	end, forward;
+	gentity_t	*traceEnt;
+
+	if ( self->health <= 0 )
+	{
+		return;
+	}
+	AngleVectors( self->client->ps.viewangles, forward, NULL, NULL );
+	VectorNormalize( forward );
+
+	if ( self->client->ps.fd.forcePowerLevel[FP_LIGHTNING] > FORCE_LEVEL_2 )
+	{//arc
+		vec3_t	center, mins, maxs, dir, ent_org, size, v;
+		float	radius = FORCE_LIGHTNING_RADIUS, dot, dist;
+		gentity_t	*entityList[MAX_GENTITIES];
+		int			iEntityList[MAX_GENTITIES];
+		int		e, numListedEntities, i;
+
+		VectorCopy( self->client->ps.origin, center );
+		for ( i = 0 ; i < 3 ; i++ ) 
+		{
+			mins[i] = center[i] - radius;
+			maxs[i] = center[i] + radius;
+		}
+		numListedEntities = trap_EntitiesInBox( mins, maxs, iEntityList, MAX_GENTITIES );
+
+		i = 0;
+		while (i < numListedEntities)
+		{
+			entityList[i] = &g_entities[iEntityList[i]];
+
+			i++;
+		}
+
+		for ( e = 0 ; e < numListedEntities ; e++ ) 
+		{
+			traceEnt = entityList[e];
+
+			if ( !traceEnt )
+				continue;
+			if ( traceEnt == self )
+				continue;
+			if ( traceEnt->r.ownerNum == self->s.number && traceEnt->s.weapon != WP_THERMAL )//can push your own thermals
+				continue;
+			if ( !traceEnt->inuse )
+				continue;
+			if ( !traceEnt->takedamage )
+				continue;
+			if ( traceEnt->health <= 0 )//no torturing corpses
+				continue;
+			if ( !g_friendlyFire.integer && OnSameTeam(self, traceEnt))
+				continue;
+			//this is all to see if we need to start a saber attack, if it's in flight, this doesn't matter
+			// find the distance from the edge of the bounding box
+			for ( i = 0 ; i < 3 ; i++ ) 
+			{
+				if ( center[i] < traceEnt->r.absmin[i] ) 
+				{
+					v[i] = traceEnt->r.absmin[i] - center[i];
+				} else if ( center[i] > traceEnt->r.absmax[i] ) 
+				{
+					v[i] = center[i] - traceEnt->r.absmax[i];
+				} else 
+				{
+					v[i] = 0;
+				}
+			}
+
+			VectorSubtract( traceEnt->r.absmax, traceEnt->r.absmin, size );
+			VectorMA( traceEnt->r.absmin, 0.5, size, ent_org );
+
+			//see if they're in front of me
+			//must be within the forward cone
+			VectorSubtract( ent_org, center, dir );
+			VectorNormalize( dir );
+			if ( (dot = DotProduct( dir, forward )) < 0.5 )
+				continue;
+
+			//must be close enough
+			dist = VectorLength( v );
+			if ( dist >= radius ) 
+			{
+				continue;
+			}
+		
+			//in PVS?
+			if ( !traceEnt->r.bmodel && !trap_InPVS( ent_org, self->client->ps.origin ) )
+			{//must be in PVS
+				continue;
+			}
+
+			//Now check and see if we can actually hit it
+			trap_Trace( &tr, self->client->ps.origin, vec3_origin, vec3_origin, ent_org, self->s.number, MASK_SHOT );
+			if ( tr.fraction < 1.0f && tr.entityNum != traceEnt->s.number )
+			{//must have clear LOS
+				continue;
+			}
+
+			// ok, we are within the radius, add us to the incoming list
+			ForceLightningDamage( self, traceEnt, dir, ent_org );
+		}
+	}
+	else
+	{//trace-line
+		VectorMA( self->client->ps.origin, 2048, forward, end );
+		
+		trap_Trace( &tr, self->client->ps.origin, vec3_origin, vec3_origin, end, self->s.number, MASK_SHOT );
+		if ( tr.entityNum == ENTITYNUM_NONE || tr.fraction == 1.0 || tr.allsolid || tr.startsolid )
+		{
+			return;
+		}
+		
+		traceEnt = &g_entities[tr.entityNum];
+		ForceLightningDamage( self, traceEnt, forward, tr.endpos );
+	}
+}
+
+void ForceDrain( gentity_t *self )
+{
+	if ( self->health <= 0 )
+	{
+		return;
+	}
+
+	if (self->client->ps.forceHandExtend != HANDEXTEND_NONE)
+	{
+		return;
+	}
+
+	if (self->client->ps.weaponTime > 0)
+	{
+		return;
+	}
+
+	if ( self->client->ps.fd.forcePower < 25 || !WP_ForcePowerUsable( self, FP_DRAIN ) )
+	{
+		return;
+	}
+	if ( self->client->ps.fd.forcePowerDebounce[FP_DRAIN] > level.time )
+	{//stops it while using it and also after using it, up to 3 second delay
+		return;
+	}
+
+//	self->client->ps.forceHandExtend = HANDEXTEND_FORCEPUSH;
+//	self->client->ps.forceHandExtendTime = level.time + 1000;
+	self->client->ps.forceHandExtend = HANDEXTEND_FORCE_HOLD;
+	self->client->ps.forceHandExtendTime = level.time + 20000;
+
+	G_Sound( self, CHAN_BODY, G_SoundIndex("sound/weapons/force/drain.wav") );
+	
+	WP_ForcePowerStart( self, FP_DRAIN, 500 );
+}
+
+void ForceDrainDamage( gentity_t *self, gentity_t *traceEnt, vec3_t dir, vec3_t impactPoint )
+{
+	gentity_t *tent;
+
+	self->client->dangerTime = level.time;
+	self->client->ps.eFlags &= ~EF_INVULNERABLE;
+	self->client->invulnerableTimer = 0;
+
+	if ( traceEnt && traceEnt->takedamage )
+	{
+		if ( traceEnt->client && (!OnSameTeam(self, traceEnt) || g_friendlyFire.integer) && self->client->ps.fd.forceDrainTime < level.time && traceEnt->client->ps.fd.forcePower )
+		{//an enemy or object
+			if (!traceEnt->client && traceEnt->s.eType == ET_NPC)
+			{ //g2animent
+				if (traceEnt->s.genericenemyindex < level.time)
+				{
+					traceEnt->s.genericenemyindex = level.time + 2000;
+				}
+			}
+			if (ForcePowerUsableOn(self, traceEnt, FP_DRAIN))
+			{
+				int modPowerLevel = -1;
+				int	dmg = 0; //Q_irand( 1, 3 );
+				if (self->client->ps.fd.forcePowerLevel[FP_DRAIN] == FORCE_LEVEL_1)
+				{
+					dmg = 2; //because it's one-shot
+				}
+				else if (self->client->ps.fd.forcePowerLevel[FP_DRAIN] == FORCE_LEVEL_2)
+				{
+					dmg = 3;
+				}
+				else if (self->client->ps.fd.forcePowerLevel[FP_DRAIN] == FORCE_LEVEL_3)
+				{
+					dmg = 4;
+				}
+			
+				if (traceEnt->client)
+				{
+					modPowerLevel = WP_AbsorbConversion(traceEnt, traceEnt->client->ps.fd.forcePowerLevel[FP_ABSORB], self, FP_DRAIN, self->client->ps.fd.forcePowerLevel[FP_DRAIN], 1);
+				}
+
+				if (modPowerLevel != -1)
+				{
+					if (!modPowerLevel)
+					{
+						dmg = 0;
+					}
+					else if (modPowerLevel == 1)
+					{
+						dmg = 1;
+					}
+					else if (modPowerLevel == 2)
+					{
+						dmg = 2;
+					}
+				}
+				//G_Damage( traceEnt, self, self, dir, impactPoint, dmg, 0, MOD_FORCE_DARK );
+
+				if (dmg)
+				{
+					traceEnt->client->ps.fd.forcePower -= (dmg);
+				}
+				if (traceEnt->client->ps.fd.forcePower < 0)
+				{
+					traceEnt->client->ps.fd.forcePower = 0;
+				}
+
+				if (self->client->ps.stats[STAT_HEALTH] < self->client->ps.stats[STAT_MAX_HEALTH] &&
+					self->health > 0 && self->client->ps.stats[STAT_HEALTH] > 0)
+				{
+					self->health += dmg;
+					if (self->health > self->client->ps.stats[STAT_MAX_HEALTH])
+					{
+						self->health = self->client->ps.stats[STAT_MAX_HEALTH];
+					}
+					self->client->ps.stats[STAT_HEALTH] = self->health;
+				}
+
+				traceEnt->client->ps.fd.forcePowerRegenDebounceTime = level.time + 800; //don't let the client being drained get force power back right away
+
+				//Drain the standard amount since we just drained someone else
+
+				/*
+				if (self->client->ps.fd.forcePowerLevel[FP_DRAIN] == FORCE_LEVEL_1)
+				{
+					BG_ForcePowerDrain( &self->client->ps, FP_DRAIN, 0 );
+				}
+				else
+				{
+					BG_ForcePowerDrain( &self->client->ps, FP_DRAIN, forcePowerNeeded[self->client->ps.fd.forcePowerLevel[FP_DRAIN]][FP_DRAIN]/5 );
+				}
+
+				if (self->client->ps.fd.forcePowerLevel[FP_DRAIN] == FORCE_LEVEL_1)
+				{
+					self->client->ps.fd.forceDrainTime = level.time + 100;
+				}
+				else
+				{
+					self->client->ps.fd.forceDrainTime = level.time + 20;
+				}
+
+				if ( traceEnt->client )
+				{
+					if ( !Q_irand( 0, 2 ) )
+					{
+						//G_Sound( traceEnt, CHAN_BODY, G_SoundIndex( "sound/weapons/force/lightninghit.wav" ) );
+					}
+				//	traceEnt->s.powerups |= ( 1 << PW_DISINT_1 );
+
+				//	traceEnt->client->ps.powerups[PW_DISINT_1] = level.time + 500;
+				}
+				*/
+
+				if (traceEnt->client->forcePowerSoundDebounce < level.time)
+				{
+					tent = G_TempEntity( impactPoint, EV_FORCE_DRAINED);
+					tent->s.eventParm = DirToByte(dir);
+					tent->s.owner = traceEnt->s.number;
+
+					traceEnt->client->forcePowerSoundDebounce = level.time + 400;
+				}
+			}
+		}
+	}
+}
+
+int ForceShootDrain( gentity_t *self )
+{
+	trace_t	tr;
+	vec3_t	end, forward;
+	gentity_t	*traceEnt;
+	int			gotOneOrMore = 0;
+
+	if ( self->health <= 0 )
+	{
+		return 0;
+	}
+	AngleVectors( self->client->ps.viewangles, forward, NULL, NULL );
+	VectorNormalize( forward );
+
+	if ( self->client->ps.fd.forcePowerLevel[FP_DRAIN] > FORCE_LEVEL_2 )
+	{//arc
+		vec3_t	center, mins, maxs, dir, ent_org, size, v;
+		float	radius = MAX_DRAIN_DISTANCE, dot, dist;
+		gentity_t	*entityList[MAX_GENTITIES];
+		int			iEntityList[MAX_GENTITIES];
+		int		e, numListedEntities, i;
+
+		VectorCopy( self->client->ps.origin, center );
+		for ( i = 0 ; i < 3 ; i++ ) 
+		{
+			mins[i] = center[i] - radius;
+			maxs[i] = center[i] + radius;
+		}
+		numListedEntities = trap_EntitiesInBox( mins, maxs, iEntityList, MAX_GENTITIES );
+
+		i = 0;
+		while (i < numListedEntities)
+		{
+			entityList[i] = &g_entities[iEntityList[i]];
+
+			i++;
+		}
+
+		for ( e = 0 ; e < numListedEntities ; e++ ) 
+		{
+			traceEnt = entityList[e];
+
+			if ( !traceEnt )
+				continue;
+			if ( traceEnt == self )
+				continue;
+			if ( !traceEnt->inuse )
+				continue;
+			if ( !traceEnt->takedamage )
+				continue;
+			if ( traceEnt->health <= 0 )//no torturing corpses
+				continue;
+			if ( !traceEnt->client )
+				continue;
+			if ( !traceEnt->client->ps.fd.forcePower )
+				continue;
+			if (OnSameTeam(self, traceEnt) && !g_friendlyFire.integer)
+				continue;
+			//this is all to see if we need to start a saber attack, if it's in flight, this doesn't matter
+			// find the distance from the edge of the bounding box
+			for ( i = 0 ; i < 3 ; i++ ) 
+			{
+				if ( center[i] < traceEnt->r.absmin[i] ) 
+				{
+					v[i] = traceEnt->r.absmin[i] - center[i];
+				} else if ( center[i] > traceEnt->r.absmax[i] ) 
+				{
+					v[i] = center[i] - traceEnt->r.absmax[i];
+				} else 
+				{
+					v[i] = 0;
+				}
+			}
+
+			VectorSubtract( traceEnt->r.absmax, traceEnt->r.absmin, size );
+			VectorMA( traceEnt->r.absmin, 0.5, size, ent_org );
+
+			//see if they're in front of me
+			//must be within the forward cone
+			VectorSubtract( ent_org, center, dir );
+			VectorNormalize( dir );
+			if ( (dot = DotProduct( dir, forward )) < 0.5 )
+				continue;
+
+			//must be close enough
+			dist = VectorLength( v );
+			if ( dist >= radius ) 
+			{
+				continue;
+			}
+		
+			//in PVS?
+			if ( !traceEnt->r.bmodel && !trap_InPVS( ent_org, self->client->ps.origin ) )
+			{//must be in PVS
+				continue;
+			}
+
+			//Now check and see if we can actually hit it
+			trap_Trace( &tr, self->client->ps.origin, vec3_origin, vec3_origin, ent_org, self->s.number, MASK_SHOT );
+			if ( tr.fraction < 1.0f && tr.entityNum != traceEnt->s.number )
+			{//must have clear LOS
+				continue;
+			}
+
+			// ok, we are within the radius, add us to the incoming list
+			ForceDrainDamage( self, traceEnt, dir, ent_org );
+			gotOneOrMore = 1;
+		}
+	}
+	else
+	{//trace-line
+		VectorMA( self->client->ps.origin, 2048, forward, end );
+		
+		trap_Trace( &tr, self->client->ps.origin, vec3_origin, vec3_origin, end, self->s.number, MASK_SHOT );
+		if ( tr.entityNum == ENTITYNUM_NONE || tr.fraction == 1.0 || tr.allsolid || tr.startsolid || !g_entities[tr.entityNum].client || !g_entities[tr.entityNum].inuse )
+		{
+			return 0;
+		}
+		
+		traceEnt = &g_entities[tr.entityNum];
+		ForceDrainDamage( self, traceEnt, forward, tr.endpos );
+		gotOneOrMore = 1;
+	}
+
+	self->client->ps.activeForcePass = self->client->ps.fd.forcePowerLevel[FP_DRAIN] + FORCE_LEVEL_3;
+
+	BG_ForcePowerDrain( &self->client->ps, FP_DRAIN, 5 ); //used to be 1, but this did, too, anger the God of Balance.
+
+	self->client->ps.fd.forcePowerRegenDebounceTime = level.time + 500;
+
+	return gotOneOrMore;
+}
+
+void ForceJumpCharge( gentity_t *self, usercmd_t *ucmd )
+{ //I guess this is unused now. Was used for the "charge" jump type.
+	float forceJumpChargeInterval = forceJumpStrength[0] / (FORCE_JUMP_CHARGE_TIME/FRAMETIME);
+
+	if ( self->health <= 0 )
+	{
+		return;
+	}
+
+	if (!self->client->ps.fd.forceJumpCharge && self->client->ps.groundEntityNum == ENTITYNUM_NONE)
+	{
+		return;
+	}
+
+	if (self->client->ps.fd.forcePower < forcePowerNeeded[self->client->ps.fd.forcePowerLevel[FP_LEVITATION]][FP_LEVITATION])
+	{
+		G_MuteSound(self->client->ps.fd.killSoundEntIndex[TRACK_CHANNEL_1-50], CHAN_VOICE);
+		return;
+	}
+
+	if (!self->client->ps.fd.forceJumpCharge)
+	{
+		self->client->ps.fd.forceJumpAddTime = 0;
+	}
+
+	if (self->client->ps.fd.forceJumpAddTime >= level.time)
+	{
+		return;
+	}
+
+	//need to play sound
+	if ( !self->client->ps.fd.forceJumpCharge )
+	{
+		G_Sound( self, TRACK_CHANNEL_1, G_SoundIndex("sound/weapons/force/jumpbuild.wav") );
+	}
+
+	//Increment
+	if (self->client->ps.fd.forceJumpAddTime < level.time)
+	{
+		self->client->ps.fd.forceJumpCharge += forceJumpChargeInterval*50;
+		self->client->ps.fd.forceJumpAddTime = level.time + 500;
+	}
+
+	//clamp to max strength for current level
+	if ( self->client->ps.fd.forceJumpCharge > forceJumpStrength[self->client->ps.fd.forcePowerLevel[FP_LEVITATION]] )
+	{
+		self->client->ps.fd.forceJumpCharge = forceJumpStrength[self->client->ps.fd.forcePowerLevel[FP_LEVITATION]];
+		G_MuteSound(self->client->ps.fd.killSoundEntIndex[TRACK_CHANNEL_1-50], CHAN_VOICE);
+	}
+
+	//clamp to max available force power
+	if ( self->client->ps.fd.forceJumpCharge/forceJumpChargeInterval/(FORCE_JUMP_CHARGE_TIME/FRAMETIME)*forcePowerNeeded[self->client->ps.fd.forcePowerLevel[FP_LEVITATION]][FP_LEVITATION] > self->client->ps.fd.forcePower )
+	{//can't use more than you have
+		G_MuteSound(self->client->ps.fd.killSoundEntIndex[TRACK_CHANNEL_1-50], CHAN_VOICE);
+		self->client->ps.fd.forceJumpCharge = self->client->ps.fd.forcePower*forceJumpChargeInterval/(FORCE_JUMP_CHARGE_TIME/FRAMETIME);
+	}
+	
+	//G_Printf("%f\n", self->client->ps.fd.forceJumpCharge);
+}
+
+int WP_GetVelocityForForceJump( gentity_t *self, vec3_t jumpVel, usercmd_t *ucmd )
+{
+	float pushFwd = 0, pushRt = 0;
+	vec3_t	view, forward, right;
+	VectorCopy( self->client->ps.viewangles, view );
+	view[0] = 0;
+	AngleVectors( view, forward, right, NULL );
+	if ( ucmd->forwardmove && ucmd->rightmove )
+	{
+		if ( ucmd->forwardmove > 0 )
+		{
+			pushFwd = 50;
+		}
+		else
+		{
+			pushFwd = -50;
+		}
+		if ( ucmd->rightmove > 0 )
+		{
+			pushRt = 50;
+		}
+		else
+		{
+			pushRt = -50;
+		}
+	}
+	else if ( ucmd->forwardmove || ucmd->rightmove )
+	{
+		if ( ucmd->forwardmove > 0 )
+		{
+			pushFwd = 100;
+		}
+		else if ( ucmd->forwardmove < 0 )
+		{
+			pushFwd = -100;
+		}
+		else if ( ucmd->rightmove > 0 )
+		{
+			pushRt = 100;
+		}
+		else if ( ucmd->rightmove < 0 )
+		{
+			pushRt = -100;
+		}
+	}
+
+	G_MuteSound(self->client->ps.fd.killSoundEntIndex[TRACK_CHANNEL_1-50], CHAN_VOICE);
+
+	G_PreDefSound(self->client->ps.origin, PDSOUND_FORCEJUMP);
+
+	if (self->client->ps.fd.forceJumpCharge < JUMP_VELOCITY+40)
+	{ //give him at least a tiny boost from just a tap
+		self->client->ps.fd.forceJumpCharge = JUMP_VELOCITY+400;
+	}
+
+	if (self->client->ps.velocity[2] < -30)
+	{ //so that we can get a good boost when force jumping in a fall
+		self->client->ps.velocity[2] = -30;
+	}
+
+	VectorMA( self->client->ps.velocity, pushFwd, forward, jumpVel );
+	VectorMA( self->client->ps.velocity, pushRt, right, jumpVel );
+	jumpVel[2] += self->client->ps.fd.forceJumpCharge;
+	if ( pushFwd > 0 && self->client->ps.fd.forceJumpCharge > 200 )
+	{
+		return FJ_FORWARD;
+	}
+	else if ( pushFwd < 0 && self->client->ps.fd.forceJumpCharge > 200 )
+	{
+		return FJ_BACKWARD;
+	}
+	else if ( pushRt > 0 && self->client->ps.fd.forceJumpCharge > 200 )
+	{
+		return FJ_RIGHT;
+	}
+	else if ( pushRt < 0 && self->client->ps.fd.forceJumpCharge > 200 )
+	{
+		return FJ_LEFT;
+	}
+	else
+	{
+		return FJ_UP;
+	}
+}
+
+void ForceJump( gentity_t *self, usercmd_t *ucmd )
+{
+	float forceJumpChargeInterval;
+	vec3_t	jumpVel;
+
+	if ( self->client->ps.fd.forcePowerDuration[FP_LEVITATION] > level.time )
+	{
+		return;
+	}
+	if ( !WP_ForcePowerUsable( self, FP_LEVITATION ) )
+	{
+		return;
+	}
+	if ( self->s.groundEntityNum == ENTITYNUM_NONE )
+	{
+		return;
+	}
+	if ( self->health <= 0 )
+	{
+		return;
+	}
+
+	self->client->fjDidJump = qtrue;
+
+	forceJumpChargeInterval = forceJumpStrength[self->client->ps.fd.forcePowerLevel[FP_LEVITATION]]/(FORCE_JUMP_CHARGE_TIME/FRAMETIME);
+
+	WP_GetVelocityForForceJump( self, jumpVel, ucmd );
+
+	//FIXME: sound effect
+	self->client->ps.fd.forceJumpZStart = self->client->ps.origin[2];//remember this for when we land
+	VectorCopy( jumpVel, self->client->ps.velocity );
+	//wasn't allowing them to attack when jumping, but that was annoying
+	//self->client->ps.weaponTime = self->client->ps.torsoAnimTimer;
+
+	WP_ForcePowerStart( self, FP_LEVITATION, self->client->ps.fd.forceJumpCharge/forceJumpChargeInterval/(FORCE_JUMP_CHARGE_TIME/FRAMETIME)*forcePowerNeeded[self->client->ps.fd.forcePowerLevel[FP_LEVITATION]][FP_LEVITATION] );
+	//self->client->ps.fd.forcePowerDuration[FP_LEVITATION] = level.time + self->client->ps.weaponTime;
+	self->client->ps.fd.forceJumpCharge = 0;
+	self->client->ps.forceJumpFlip = qtrue;
+}
+
+void WP_AddAsMindtricked(forcedata_t *fd, int entNum)
+{
+	if (!fd)
+	{
+		return;
+	}
+
+	if (entNum > 47)
+	{
+		fd->forceMindtrickTargetIndex4 |= (1 << (entNum-48));
+	}
+	else if (entNum > 31)
+	{
+		fd->forceMindtrickTargetIndex3 |= (1 << (entNum-32));
+	}
+	else if (entNum > 15)
+	{
+		fd->forceMindtrickTargetIndex2 |= (1 << (entNum-16));
+	}
+	else
+	{
+		fd->forceMindtrickTargetIndex |= (1 << entNum);
+	}
+}
+
+qboolean ForceTelepathyCheckDirectNPCTarget( gentity_t *self, trace_t *tr, qboolean *tookPower )
+{
+	gentity_t	*traceEnt;
+	qboolean	targetLive = qfalse, mindTrickDone = qfalse;
+	vec3_t		tfrom, tto, fwd;
+	float		radius = MAX_TRICK_DISTANCE;
+
+	//Check for a direct usage on NPCs first
+	VectorCopy(self->client->ps.origin, tfrom);
+	tfrom[2] += self->client->ps.viewheight;
+	AngleVectors(self->client->ps.viewangles, fwd, NULL, NULL);
+	tto[0] = tfrom[0] + fwd[0]*radius/2;
+	tto[1] = tfrom[1] + fwd[1]*radius/2;
+	tto[2] = tfrom[2] + fwd[2]*radius/2;
+
+	trap_Trace( tr, tfrom, NULL, NULL, tto, self->s.number, MASK_PLAYERSOLID );
+	
+	if ( tr->entityNum == ENTITYNUM_NONE 
+		|| tr->fraction == 1.0f
+		|| tr->allsolid 
+		|| tr->startsolid )
+	{
+		return qfalse;
+	}
+	
+	traceEnt = &g_entities[tr->entityNum];
+	
+	if( traceEnt->NPC 
+		&& traceEnt->NPC->scriptFlags & SCF_NO_FORCE )
+	{
+		return qfalse;
+	}
+
+	if ( traceEnt && traceEnt->client  )
+	{
+		switch ( traceEnt->client->NPC_class )
+		{
+		case CLASS_GALAKMECH://cant grip him, he's in armor
+		case CLASS_ATST://much too big to grip!
+		//no droids either
+		case CLASS_PROBE:
+		case CLASS_GONK:
+		case CLASS_R2D2:
+		case CLASS_R5D2:
+		case CLASS_MARK1:
+		case CLASS_MARK2:
+		case CLASS_MOUSE:
+		case CLASS_SEEKER:
+		case CLASS_REMOTE:
+		case CLASS_PROTOCOL:
+		case CLASS_BOBAFETT:
+		case CLASS_RANCOR:
+			break;
+		default:
+			targetLive = qtrue;
+			break;
+		}
+	}
+
+	if ( traceEnt->s.number < MAX_CLIENTS )
+	{//a regular client
+		return qfalse;
+	}
+
+	if ( targetLive && traceEnt->NPC )
+	{//hit an organic non-player
+		vec3_t	eyeDir;
+		if ( G_ActivateBehavior( traceEnt, BSET_MINDTRICK ) )
+		{//activated a script on him
+			//FIXME: do the visual sparkles effect on their heads, still?
+			WP_ForcePowerStart( self, FP_TELEPATHY, 0 );
+		}
+		else if ( (self->NPC && traceEnt->client->playerTeam != self->client->playerTeam)
+			|| (!self->NPC && traceEnt->client->playerTeam != self->client->sess.sessionTeam) )
+		{//an enemy
+			int override = 0;
+			if ( (traceEnt->NPC->scriptFlags&SCF_NO_MIND_TRICK) )
+			{
+			}
+			else if ( traceEnt->s.weapon != WP_SABER 
+				&& traceEnt->client->NPC_class != CLASS_REBORN )
+			{//haha!  Jedi aren't easily confused!
+				if ( self->client->ps.fd.forcePowerLevel[FP_TELEPATHY] > FORCE_LEVEL_2 )
+				{//turn them to our side
+					//if mind trick 3 and aiming at an enemy need more force power
+					if ( traceEnt->s.weapon != WP_NONE )
+					{//don't charm people who aren't capable of fighting... like ugnaughts and droids
+						int newPlayerTeam, newEnemyTeam;
+
+						if ( traceEnt->enemy )
+						{
+							G_ClearEnemy( traceEnt );
+						}
+						if ( traceEnt->NPC )
+						{
+							//traceEnt->NPC->tempBehavior = BS_FOLLOW_LEADER;
+							traceEnt->client->leader = self;
+						}
+						//FIXME: maybe pick an enemy right here?
+						if ( self->NPC )
+						{//NPC
+							newPlayerTeam = self->client->playerTeam;
+							newEnemyTeam = self->client->enemyTeam;
+						}
+						else
+						{//client/bot
+							if ( self->client->sess.sessionTeam == TEAM_BLUE )
+							{//rebel
+								newPlayerTeam = NPCTEAM_PLAYER;
+								newEnemyTeam = NPCTEAM_ENEMY;
+							}
+							else if ( self->client->sess.sessionTeam == TEAM_RED )
+							{//imperial
+								newPlayerTeam = NPCTEAM_ENEMY;
+								newEnemyTeam = NPCTEAM_PLAYER;
+							}
+							else
+							{//neutral - wan't attack anyone
+								newPlayerTeam = NPCTEAM_NEUTRAL;
+								newEnemyTeam = NPCTEAM_NEUTRAL;
+							}
+						}
+						//store these for retrieval later
+						traceEnt->genericValue1 = traceEnt->client->playerTeam;
+						traceEnt->genericValue2 = traceEnt->client->enemyTeam;
+						traceEnt->genericValue3 = traceEnt->s.teamowner;
+						//set the new values
+						traceEnt->client->playerTeam = newPlayerTeam;
+						traceEnt->client->enemyTeam = newEnemyTeam;
+						traceEnt->s.teamowner = newPlayerTeam;
+						//FIXME: need a *charmed* timer on this...?  Or do TEAM_PLAYERS assume that "confusion" means they should switch to team_enemy when done?
+						traceEnt->NPC->charmedTime = level.time + mindTrickTime[self->client->ps.fd.forcePowerLevel[FP_TELEPATHY]];
+					}
+				}
+				else
+				{//just confuse them
+					//somehow confuse them?  Set don't fire to true for a while?  Drop their aggression?  Maybe just take their enemy away and don't let them pick one up for a while unless shot?
+					traceEnt->NPC->confusionTime = level.time + mindTrickTime[self->client->ps.fd.forcePowerLevel[FP_TELEPATHY]];//confused for about 10 seconds
+					NPC_PlayConfusionSound( traceEnt );
+					if ( traceEnt->enemy )
+					{
+						G_ClearEnemy( traceEnt );
+					}
+				}
+			}
+			else
+			{
+				NPC_Jedi_PlayConfusionSound( traceEnt );
+			}
+			WP_ForcePowerStart( self, FP_TELEPATHY, override );
+		}
+		else if ( traceEnt->client->playerTeam == self->client->playerTeam )
+		{//an ally
+			//maybe just have him look at you?  Respond?  Take your enemy?
+			if ( traceEnt->client->ps.pm_type < PM_DEAD && traceEnt->NPC!=NULL && !(traceEnt->NPC->scriptFlags&SCF_NO_RESPONSE) )
+			{
+				NPC_UseResponse( traceEnt, self, qfalse );
+				WP_ForcePowerStart( self, FP_TELEPATHY, 1 );
+			}
+		}//NOTE: no effect on TEAM_NEUTRAL?
+		AngleVectors( traceEnt->client->renderInfo.eyeAngles, eyeDir, NULL, NULL );
+		VectorNormalize( eyeDir );
+		G_PlayEffectID( G_EffectIndex( "force/force_touch" ), traceEnt->client->renderInfo.eyePoint, eyeDir );
+
+		//make sure this plays and that you cannot press fire for about 1 second after this
+		//FIXME: BOTH_FORCEMINDTRICK or BOTH_FORCEDISTRACT
+		//NPC_SetAnim( self, SETANIM_TORSO, BOTH_MINDTRICK1, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_RESTART|SETANIM_FLAG_HOLD );
+		//FIXME: build-up or delay this until in proper part of anim
+		mindTrickDone = qtrue;
+	}
+	else 
+	{
+		if ( self->client->ps.fd.forcePowerLevel[FP_TELEPATHY] > FORCE_LEVEL_1 && tr->fraction * 2048 > 64 )
+		{//don't create a diversion less than 64 from you of if at power level 1
+			//use distraction anim instead
+			G_PlayEffectID( G_EffectIndex( "force/force_touch" ), tr->endpos, tr->plane.normal );
+			//FIXME: these events don't seem to always be picked up...?
+			AddSoundEvent( self, tr->endpos, 512, AEL_SUSPICIOUS, qtrue );//, qtrue );
+			AddSightEvent( self, tr->endpos, 512, AEL_SUSPICIOUS, 50 );
+			WP_ForcePowerStart( self, FP_TELEPATHY, 0 );
+			*tookPower = qtrue;
+		}
+		//NPC_SetAnim( self, SETANIM_TORSO, BOTH_MINDTRICK2, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_RESTART|SETANIM_FLAG_HOLD );
+	}
+	//self->client->ps.saberMove = self->client->ps.saberBounceMove = LS_READY;//don't finish whatever saber anim you may have been in
+	self->client->ps.saberBlocked = BLOCKED_NONE;
+	self->client->ps.weaponTime = 1000;
+	/*
+	if ( self->client->ps.fd.forcePowersActive&(1<<FP_SPEED) )
+	{
+		self->client->ps.weaponTime = floor( self->client->ps.weaponTime * g_timescale->value );
+	}
+	*/
+	return qtrue;
+}
+
+void ForceTelepathy(gentity_t *self)
+{
+	trace_t tr;
+	vec3_t tto, thispush_org, a;
+	vec3_t mins, maxs, fwdangles, forward, right, center;
+	int i;
+	float visionArc = 0;
+	float radius = MAX_TRICK_DISTANCE;
+	qboolean	tookPower = qfalse;
+
+	if ( self->health <= 0 )
+	{
+		return;
+	}
+
+	if (self->client->ps.forceHandExtend != HANDEXTEND_NONE)
+	{
+		return;
+	}
+
+	if (self->client->ps.weaponTime > 0)
+	{
+		return;
+	}
+
+	if (self->client->ps.powerups[PW_REDFLAG] ||
+		self->client->ps.powerups[PW_BLUEFLAG])
+	{ //can't mindtrick while carrying the flag
+		return;
+	}
+
+	if (self->client->ps.forceAllowDeactivateTime < level.time &&
+		(self->client->ps.fd.forcePowersActive & (1 << FP_TELEPATHY)) )
+	{
+		WP_ForcePowerStop( self, FP_TELEPATHY );
+		return;
+	}
+
+	if ( !WP_ForcePowerUsable( self, FP_TELEPATHY ) )
+	{
+		return;
+	}
+
+	if ( ForceTelepathyCheckDirectNPCTarget( self, &tr, &tookPower ) )
+	{//hit an NPC directly
+		self->client->ps.forceAllowDeactivateTime = level.time + 1500;
+		G_Sound( self, CHAN_AUTO, G_SoundIndex("sound/weapons/force/distract.wav") );
+		self->client->ps.forceHandExtend = HANDEXTEND_FORCEPUSH;
+		self->client->ps.forceHandExtendTime = level.time + 1000;
+		return;
+	}
+
+	if (self->client->ps.fd.forcePowerLevel[FP_TELEPATHY] == FORCE_LEVEL_2)
+	{
+		visionArc = 180;
+	}
+	else if (self->client->ps.fd.forcePowerLevel[FP_TELEPATHY] == FORCE_LEVEL_3)
+	{
+		visionArc = 360;
+		radius = MAX_TRICK_DISTANCE*2.0f;
+	}
+
+	VectorCopy( self->client->ps.viewangles, fwdangles );
+	AngleVectors( fwdangles, forward, right, NULL );
+	VectorCopy( self->client->ps.origin, center );
+
+	for ( i = 0 ; i < 3 ; i++ ) 
+	{
+		mins[i] = center[i] - radius;
+		maxs[i] = center[i] + radius;
+	}
+
+	if (self->client->ps.fd.forcePowerLevel[FP_TELEPATHY] == FORCE_LEVEL_1)
+	{
+		if (tr.fraction != 1.0 &&
+			tr.entityNum != ENTITYNUM_NONE &&
+			g_entities[tr.entityNum].inuse &&
+			g_entities[tr.entityNum].client &&
+			g_entities[tr.entityNum].client->pers.connected &&
+			g_entities[tr.entityNum].client->sess.sessionTeam != TEAM_SPECTATOR)
+		{
+			WP_AddAsMindtricked(&self->client->ps.fd, tr.entityNum);
+			if ( !tookPower )
+			{
+				WP_ForcePowerStart( self, FP_TELEPATHY, 0 );
+			}
+
+			G_Sound( self, CHAN_AUTO, G_SoundIndex("sound/weapons/force/distract.wav") );
+
+			self->client->ps.forceHandExtend = HANDEXTEND_FORCEPUSH;
+			self->client->ps.forceHandExtendTime = level.time + 1000;
+
+			return;
+		}
+		else
+		{
+			return;
+		}
+	}
+	else	//level 2 & 3
+	{
+		gentity_t *ent;
+		int entityList[MAX_GENTITIES];
+		int numListedEntities;
+		int e = 0;
+		qboolean gotatleastone = qfalse;
+
+		numListedEntities = trap_EntitiesInBox( mins, maxs, entityList, MAX_GENTITIES );
+
+		while (e < numListedEntities)
+		{
+			ent = &g_entities[entityList[e]];
+
+			if (ent)
+			{ //not in the arc, don't consider it
+				if (ent->client)
+				{
+					VectorCopy(ent->client->ps.origin, thispush_org);
+				}
+				else
+				{
+					VectorCopy(ent->s.pos.trBase, thispush_org);
+				}
+				VectorCopy(self->client->ps.origin, tto);
+				tto[2] += self->client->ps.viewheight;
+				VectorSubtract(thispush_org, tto, a);
+				vectoangles(a, a);
+
+				if (!ent->client)
+				{
+					entityList[e] = ENTITYNUM_NONE;
+				}
+				else if (!InFieldOfVision(self->client->ps.viewangles, visionArc, a))
+				{ //only bother with arc rules if the victim is a client
+					entityList[e] = ENTITYNUM_NONE;
+				}
+				else if (!ForcePowerUsableOn(self, ent, FP_TELEPATHY))
+				{
+					entityList[e] = ENTITYNUM_NONE;
+				}
+				else if (OnSameTeam(self, ent))
+				{
+					entityList[e] = ENTITYNUM_NONE;
+				}
+			}
+			ent = &g_entities[entityList[e]];
+			if (ent && ent != self && ent->client)
+			{
+				gotatleastone = qtrue;
+				WP_AddAsMindtricked(&self->client->ps.fd, ent->s.number);
+			}
+			e++;
+		}
+
+		if (gotatleastone)
+		{
+			self->client->ps.forceAllowDeactivateTime = level.time + 1500;
+
+			if ( !tookPower )
+			{
+				WP_ForcePowerStart( self, FP_TELEPATHY, 0 );
+			}
+
+			G_Sound( self, CHAN_AUTO, G_SoundIndex("sound/weapons/force/distract.wav") );
+
+			self->client->ps.forceHandExtend = HANDEXTEND_FORCEPUSH;
+			self->client->ps.forceHandExtendTime = level.time + 1000;
+		}
+	}
+
+}
+
+void GEntity_UseFunc( gentity_t *self, gentity_t *other, gentity_t *activator )
+{
+	GlobalUse(self, other, activator);
+}
+
+qboolean CanCounterThrow(gentity_t *self, gentity_t *thrower, qboolean pull)
+{
+	int powerUse = 0;
+
+	if (self->client->ps.forceHandExtend != HANDEXTEND_NONE)
+	{
+		return 0;
+	}
+
+	if (self->client->ps.weaponTime > 0)
+	{
+		return 0;
+	}
+
+	if ( self->health <= 0 )
+	{
+		return 0;
+	}
+
+	if ( self->client->ps.powerups[PW_DISINT_4] > level.time )
+	{
+		return 0;
+	}
+
+	if (self->client->ps.weaponstate == WEAPON_CHARGING ||
+		self->client->ps.weaponstate == WEAPON_CHARGING_ALT)
+	{ //don't autodefend when charging a weapon
+		return 0;
+	}
+
+	if (g_gametype.integer == GT_SIEGE &&
+		pull &&
+		thrower && thrower->client)
+	{ //in siege, pull will affect people if they are not facing you, so they can't run away so much
+		vec3_t d;
+		float a;
+
+        VectorSubtract(thrower->client->ps.origin, self->client->ps.origin, d);
+		vectoangles(d, d);
+
+        a = AngleSubtract(d[YAW], self->client->ps.viewangles[YAW]);
+
+		if (a > 60.0f || a < -60.0f)
+		{ //if facing more than 60 degrees away they cannot defend
+			return 0;
+		}
+	}
+
+	if (pull)
+	{
+		powerUse = FP_PULL;
+	}
+	else
+	{
+		powerUse = FP_PUSH;
+	}
+
+	if ( !WP_ForcePowerUsable( self, powerUse ) )
+	{
+		return 0;
+	}
+
+	if (self->client->ps.groundEntityNum == ENTITYNUM_NONE)
+	{ //you cannot counter a push/pull if you're in the air
+		return 0;
+	}
+
+	return 1;
+}
+
+qboolean G_InGetUpAnim(playerState_t *ps)
+{
+	switch( (ps->legsAnim) )
+	{
+	case BOTH_GETUP1:
+	case BOTH_GETUP2:
+	case BOTH_GETUP3:
+	case BOTH_GETUP4:
+	case BOTH_GETUP5:
+	case BOTH_FORCE_GETUP_F1:
+	case BOTH_FORCE_GETUP_F2:
+	case BOTH_FORCE_GETUP_B1:
+	case BOTH_FORCE_GETUP_B2:
+	case BOTH_FORCE_GETUP_B3:
+	case BOTH_FORCE_GETUP_B4:
+	case BOTH_FORCE_GETUP_B5:
+	case BOTH_GETUP_BROLL_B:
+	case BOTH_GETUP_BROLL_F:
+	case BOTH_GETUP_BROLL_L:
+	case BOTH_GETUP_BROLL_R:
+	case BOTH_GETUP_FROLL_B:
+	case BOTH_GETUP_FROLL_F:
+	case BOTH_GETUP_FROLL_L:
+	case BOTH_GETUP_FROLL_R:
+		return qtrue;
+	}
+
+	switch( (ps->torsoAnim) )
+	{
+	case BOTH_GETUP1:
+	case BOTH_GETUP2:
+	case BOTH_GETUP3:
+	case BOTH_GETUP4:
+	case BOTH_GETUP5:
+	case BOTH_FORCE_GETUP_F1:
+	case BOTH_FORCE_GETUP_F2:
+	case BOTH_FORCE_GETUP_B1:
+	case BOTH_FORCE_GETUP_B2:
+	case BOTH_FORCE_GETUP_B3:
+	case BOTH_FORCE_GETUP_B4:
+	case BOTH_FORCE_GETUP_B5:
+	case BOTH_GETUP_BROLL_B:
+	case BOTH_GETUP_BROLL_F:
+	case BOTH_GETUP_BROLL_L:
+	case BOTH_GETUP_BROLL_R:
+	case BOTH_GETUP_FROLL_B:
+	case BOTH_GETUP_FROLL_F:
+	case BOTH_GETUP_FROLL_L:
+	case BOTH_GETUP_FROLL_R:
+		return qtrue;
+	}
+
+	return qfalse;
+}
+
+void G_LetGoOfWall( gentity_t *ent )
+{
+	if ( !ent || !ent->client )
+	{
+		return;
+	}
+	ent->client->ps.pm_flags &= ~PMF_STUCK_TO_WALL;
+	if ( BG_InReboundJump( ent->client->ps.legsAnim ) 
+		|| BG_InReboundHold( ent->client->ps.legsAnim ) )
+	{
+		ent->client->ps.legsTimer = 0;
+	}
+	if ( BG_InReboundJump( ent->client->ps.torsoAnim ) 
+		|| BG_InReboundHold( ent->client->ps.torsoAnim ) )
+	{
+		ent->client->ps.torsoTimer = 0;
+	}
+}
+
+float forcePushPullRadius[NUM_FORCE_POWER_LEVELS] =
+{
+	0,//none
+	384,//256,
+	448,//384,
+	512
+};
+//rwwFIXMEFIXME: incorporate this into the below function? Currently it's only being used by jedi AI
+
+extern void Touch_Button(gentity_t *ent, gentity_t *other, trace_t *trace );
+void ForceThrow( gentity_t *self, qboolean pull )
+{
+	//shove things in front of you away
+	float		dist;
+	gentity_t	*ent;
+	int			entityList[MAX_GENTITIES];
+	gentity_t	*push_list[MAX_GENTITIES];
+	int			numListedEntities;
+	vec3_t		mins, maxs;
+	vec3_t		v;
+	int			i, e;
+	int			ent_count = 0;
+	int			radius = 1024; //since it's view-based now. //350;
+	int			powerLevel;
+	int			visionArc;
+	int			pushPower;
+	int			pushPowerMod;
+	vec3_t		center, ent_org, size, forward, right, end, dir, fwdangles = {0};
+	float		dot1;
+	trace_t		tr;
+	int			x;
+	vec3_t		pushDir;
+	vec3_t		thispush_org;
+	vec3_t		tfrom, tto, fwd, a;
+	float		knockback = pull?0:200;
+	int			powerUse = 0;
+
+	visionArc = 0;
+
+	if (self->client->ps.forceHandExtend != HANDEXTEND_NONE && (self->client->ps.forceHandExtend != HANDEXTEND_KNOCKDOWN || !G_InGetUpAnim(&self->client->ps)))
+	{
+		return;
+	}
+
+	if (!g_useWhileThrowing.integer && self->client->ps.saberInFlight)
+	{
+		return;
+	}
+
+	if (self->client->ps.weaponTime > 0)
+	{
+		return;
+	}
+
+	if ( self->health <= 0 )
+	{
+		return;
+	}
+	if ( self->client->ps.powerups[PW_DISINT_4] > level.time )
+	{
+		return;
+	}
+	if (pull)
+	{
+		powerUse = FP_PULL;
+	}
+	else
+	{
+		powerUse = FP_PUSH;
+	}
+
+	if ( !WP_ForcePowerUsable( self, powerUse ) )
+	{
+		return;
+	}
+
+	if (!pull && self->client->ps.saberLockTime > level.time && self->client->ps.saberLockFrame)
+	{
+		G_Sound( self, CHAN_BODY, G_SoundIndex( "sound/weapons/force/push.wav" ) );
+		self->client->ps.powerups[PW_DISINT_4] = level.time + 1500;
+
+		self->client->ps.saberLockHits += self->client->ps.fd.forcePowerLevel[FP_PUSH]*2;
+
+		WP_ForcePowerStart( self, FP_PUSH, 0 );
+		return;
+	}
+
+	WP_ForcePowerStart( self, powerUse, 0 );
+
+	//make sure this plays and that you cannot press fire for about 1 second after this
+	if ( pull )
+	{
+		G_Sound( self, CHAN_BODY, G_SoundIndex( "sound/weapons/force/pull.wav" ) );
+		if (self->client->ps.forceHandExtend == HANDEXTEND_NONE)
+		{
+			self->client->ps.forceHandExtend = HANDEXTEND_FORCEPULL;
+			if ( g_gametype.integer == GT_SIEGE && self->client->ps.weapon == WP_SABER )
+			{//hold less so can attack right after a pull
+				self->client->ps.forceHandExtendTime = level.time + 200;
+			}
+			else
+			{
+				self->client->ps.forceHandExtendTime = level.time + 400;
+			}
+		}
+		self->client->ps.powerups[PW_DISINT_4] = self->client->ps.forceHandExtendTime + 200;
+		self->client->ps.powerups[PW_PULL] = self->client->ps.powerups[PW_DISINT_4];
+	}
+	else
+	{
+		G_Sound( self, CHAN_BODY, G_SoundIndex( "sound/weapons/force/push.wav" ) );
+		if (self->client->ps.forceHandExtend == HANDEXTEND_NONE)
+		{
+			self->client->ps.forceHandExtend = HANDEXTEND_FORCEPUSH;
+			self->client->ps.forceHandExtendTime = level.time + 1000;
+		}
+		else if (self->client->ps.forceHandExtend == HANDEXTEND_KNOCKDOWN && G_InGetUpAnim(&self->client->ps))
+		{
+			if (self->client->ps.forceDodgeAnim > 4)
+			{
+				self->client->ps.forceDodgeAnim -= 8;
+			}
+			self->client->ps.forceDodgeAnim += 8; //special case, play push on upper torso, but keep playing current knockdown anim on legs
+		}
+		self->client->ps.powerups[PW_DISINT_4] = level.time + 1100;
+		self->client->ps.powerups[PW_PULL] = 0;
+	}
+
+	VectorCopy( self->client->ps.viewangles, fwdangles );
+	AngleVectors( fwdangles, forward, right, NULL );
+	VectorCopy( self->client->ps.origin, center );
+
+	for ( i = 0 ; i < 3 ; i++ ) 
+	{
+		mins[i] = center[i] - radius;
+		maxs[i] = center[i] + radius;
+	}
+
+
+	if (pull)
+	{
+		powerLevel = self->client->ps.fd.forcePowerLevel[FP_PULL];
+		pushPower = 256*self->client->ps.fd.forcePowerLevel[FP_PULL];
+	}
+	else
+	{
+		powerLevel = self->client->ps.fd.forcePowerLevel[FP_PUSH];
+		pushPower = 256*self->client->ps.fd.forcePowerLevel[FP_PUSH];
+	}
+
+	if (!powerLevel)
+	{ //Shouldn't have made it here..
+		return;
+	}
+
+	if (powerLevel == FORCE_LEVEL_2)
+	{
+		visionArc = 60;
+	}
+	else if (powerLevel == FORCE_LEVEL_3)
+	{
+		visionArc = 180;
+	}
+
+	if (powerLevel == FORCE_LEVEL_1)
+	{ //can only push/pull targeted things at level 1
+		VectorCopy(self->client->ps.origin, tfrom);
+		tfrom[2] += self->client->ps.viewheight;
+		AngleVectors(self->client->ps.viewangles, fwd, NULL, NULL);
+		tto[0] = tfrom[0] + fwd[0]*radius/2;
+		tto[1] = tfrom[1] + fwd[1]*radius/2;
+		tto[2] = tfrom[2] + fwd[2]*radius/2;
+
+		trap_Trace(&tr, tfrom, NULL, NULL, tto, self->s.number, MASK_PLAYERSOLID);
+
+		if (tr.fraction != 1.0 &&
+			tr.entityNum != ENTITYNUM_NONE)
+		{
+			if (!g_entities[tr.entityNum].client && g_entities[tr.entityNum].s.eType == ET_NPC)
+			{ //g2animent
+				if (g_entities[tr.entityNum].s.genericenemyindex < level.time)
+				{
+					g_entities[tr.entityNum].s.genericenemyindex = level.time + 2000;
+				}
+			}
+
+			numListedEntities = 0;
+			entityList[numListedEntities] = tr.entityNum;
+
+			if (pull)
+			{
+				if (!ForcePowerUsableOn(self, &g_entities[tr.entityNum], FP_PULL))
+				{
+					return;
+				}
+			}
+			else
+			{
+				if (!ForcePowerUsableOn(self, &g_entities[tr.entityNum], FP_PUSH))
+				{
+					return;
+				}
+			}
+			numListedEntities++;
+		}
+		else
+		{
+			//didn't get anything, so just
+			return;
+		}
+	}
+	else
+	{
+		numListedEntities = trap_EntitiesInBox( mins, maxs, entityList, MAX_GENTITIES );
+
+		e = 0;
+
+		while (e < numListedEntities)
+		{
+			ent = &g_entities[entityList[e]];
+
+			if (!ent->client && ent->s.eType == ET_NPC)
+			{ //g2animent
+				if (ent->s.genericenemyindex < level.time)
+				{
+					ent->s.genericenemyindex = level.time + 2000;
+				}
+			}
+
+			if (ent)
+			{
+				if (ent->client)
+				{
+					VectorCopy(ent->client->ps.origin, thispush_org);
+				}
+				else
+				{
+					VectorCopy(ent->s.pos.trBase, thispush_org);
+				}
+			}
+
+			if (ent)
+			{ //not in the arc, don't consider it
+				VectorCopy(self->client->ps.origin, tto);
+				tto[2] += self->client->ps.viewheight;
+				VectorSubtract(thispush_org, tto, a);
+				vectoangles(a, a);
+
+				if (ent->client && !InFieldOfVision(self->client->ps.viewangles, visionArc, a) &&
+					ForcePowerUsableOn(self, ent, powerUse))
+				{ //only bother with arc rules if the victim is a client
+					entityList[e] = ENTITYNUM_NONE;
+				}
+				else if (ent->client)
+				{
+					if (pull)
+					{
+						if (!ForcePowerUsableOn(self, ent, FP_PULL))
+						{
+							entityList[e] = ENTITYNUM_NONE;
+						}
+					}
+					else
+					{
+						if (!ForcePowerUsableOn(self, ent, FP_PUSH))
+						{
+							entityList[e] = ENTITYNUM_NONE;
+						}
+					}
+				}
+			}
+			e++;
+		}
+	}
+
+	for ( e = 0 ; e < numListedEntities ; e++ ) 
+	{
+		if (entityList[e] != ENTITYNUM_NONE &&
+			entityList[e] >= 0 &&
+			entityList[e] < MAX_GENTITIES)
+		{
+			ent = &g_entities[entityList[e]];
+		}
+		else
+		{
+			ent = NULL;
+		}
+
+		if (!ent)
+			continue;
+		if (ent == self)
+			continue;
+		if (ent->client && OnSameTeam(ent, self))
+		{
+			continue;
+		}
+		if ( !(ent->inuse) )
+			continue;
+		if ( ent->s.eType != ET_MISSILE )
+		{
+			if ( ent->s.eType != ET_ITEM )
+			{
+				//FIXME: need pushable objects
+				if ( Q_stricmp( "func_button", ent->classname ) == 0 )
+				{//we might push it
+					if ( pull || !(ent->spawnflags&SPF_BUTTON_FPUSHABLE) )
+					{//not force-pushable, never pullable
+						continue;
+					}
+				}
+				else
+				{
+					if ( ent->s.eFlags & EF_NODRAW )
+					{
+						continue;
+					}
+					if ( !ent->client )
+					{
+						if ( Q_stricmp( "lightsaber", ent->classname ) != 0 )
+						{//not a lightsaber 
+							if ( Q_stricmp( "func_door", ent->classname ) != 0 || !(ent->spawnflags & 2/*MOVER_FORCE_ACTIVATE*/) )
+							{//not a force-usable door
+								if ( Q_stricmp( "func_static", ent->classname ) != 0 || (!(ent->spawnflags&1/*F_PUSH*/)&&!(ent->spawnflags&2/*F_PULL*/)) )
+								{//not a force-usable func_static
+									if ( Q_stricmp( "limb", ent->classname ) )
+									{//not a limb
+										continue;
+									}
+								}
+							}
+							else if ( ent->moverState != MOVER_POS1 && ent->moverState != MOVER_POS2 )
+							{//not at rest
+								continue;
+							}
+						}
+					}
+					else if ( ent->client->NPC_class == CLASS_GALAKMECH 
+						|| ent->client->NPC_class == CLASS_ATST
+						|| ent->client->NPC_class == CLASS_RANCOR )
+					{//can't push ATST or Galak or Rancor
+						continue;
+					}
+				}
+			}
+		}
+		else
+		{
+			if ( ent->s.pos.trType == TR_STATIONARY && (ent->s.eFlags&EF_MISSILE_STICK) )
+			{//can't force-push/pull stuck missiles (detpacks, tripmines)
+				continue;
+			}
+			if ( ent->s.pos.trType == TR_STATIONARY && ent->s.weapon != WP_THERMAL )
+			{//only thermal detonators can be pushed once stopped
+				continue;
+			}
+		}
+
+		//this is all to see if we need to start a saber attack, if it's in flight, this doesn't matter
+		// find the distance from the edge of the bounding box
+		for ( i = 0 ; i < 3 ; i++ ) 
+		{
+			if ( center[i] < ent->r.absmin[i] ) 
+			{
+				v[i] = ent->r.absmin[i] - center[i];
+			} else if ( center[i] > ent->r.absmax[i] ) 
+			{
+				v[i] = center[i] - ent->r.absmax[i];
+			} else 
+			{
+				v[i] = 0;
+			}
+		}
+
+		VectorSubtract( ent->r.absmax, ent->r.absmin, size );
+		VectorMA( ent->r.absmin, 0.5, size, ent_org );
+
+		VectorSubtract( ent_org, center, dir );
+		VectorNormalize( dir );
+		if ( (dot1 = DotProduct( dir, forward )) < 0.6 )
+			continue;
+
+		dist = VectorLength( v );
+
+		//Now check and see if we can actually deflect it
+		//method1
+		//if within a certain range, deflect it
+		if ( dist >= radius ) 
+		{
+			continue;
+		}
+	
+		//in PVS?
+		if ( !ent->r.bmodel && !trap_InPVS( ent_org, self->client->ps.origin ) )
+		{//must be in PVS
+			continue;
+		}
+
+		//really should have a clear LOS to this thing...
+		trap_Trace( &tr, self->client->ps.origin, vec3_origin, vec3_origin, ent_org, self->s.number, MASK_SHOT );
+		if ( tr.fraction < 1.0f && tr.entityNum != ent->s.number )
+		{//must have clear LOS
+			//try from eyes too before you give up
+			vec3_t eyePoint;
+			VectorCopy(self->client->ps.origin, eyePoint);
+			eyePoint[2] += self->client->ps.viewheight;
+			trap_Trace( &tr, eyePoint, vec3_origin, vec3_origin, ent_org, self->s.number, MASK_SHOT );
+
+			if ( tr.fraction < 1.0f && tr.entityNum != ent->s.number )
+			{
+				continue;
+			}
+		}
+
+		// ok, we are within the radius, add us to the incoming list
+		push_list[ent_count] = ent;
+		ent_count++;
+	}
+
+	if ( ent_count )
+	{
+		//method1:
+		for ( x = 0; x < ent_count; x++ )
+		{
+			int modPowerLevel = powerLevel;
+
+	
+			if (push_list[x]->client)
+			{
+				modPowerLevel = WP_AbsorbConversion(push_list[x], push_list[x]->client->ps.fd.forcePowerLevel[FP_ABSORB], self, powerUse, powerLevel, forcePowerNeeded[self->client->ps.fd.forcePowerLevel[powerUse]][powerUse]);
+				if (modPowerLevel == -1)
+				{
+					modPowerLevel = powerLevel;
+				}
+			}
+
+			pushPower = 256*modPowerLevel;
+
+			if (push_list[x]->client)
+			{
+				VectorCopy(push_list[x]->client->ps.origin, thispush_org);
+			}
+			else
+			{
+				VectorCopy(push_list[x]->s.origin, thispush_org);
+			}
+
+			if ( push_list[x]->client )
+			{//FIXME: make enemy jedi able to hunker down and resist this?
+				int otherPushPower = push_list[x]->client->ps.fd.forcePowerLevel[powerUse];
+				qboolean canPullWeapon = qtrue;
+				float dirLen = 0;
+
+				if ( g_debugMelee.integer )
+				{
+					if ( (push_list[x]->client->ps.pm_flags&PMF_STUCK_TO_WALL) )
+					{//no resistance if stuck to wall
+						//push/pull them off the wall
+						otherPushPower = 0;
+						G_LetGoOfWall( push_list[x] );
+					}
+				}
+
+				knockback = pull?0:200;
+
+				pushPowerMod = pushPower;
+
+				if (push_list[x]->client->pers.cmd.forwardmove ||
+					push_list[x]->client->pers.cmd.rightmove)
+				{ //if you are moving, you get one less level of defense
+					otherPushPower--;
+
+					if (otherPushPower < 0)
+					{
+						otherPushPower = 0;
+					}
+				}
+
+				if (otherPushPower && CanCounterThrow(push_list[x], self, pull))
+				{
+					if ( pull )
+					{
+						G_Sound( push_list[x], CHAN_BODY, G_SoundIndex( "sound/weapons/force/pull.wav" ) );
+						push_list[x]->client->ps.forceHandExtend = HANDEXTEND_FORCEPULL;
+						push_list[x]->client->ps.forceHandExtendTime = level.time + 400;
+					}
+					else
+					{
+						G_Sound( push_list[x], CHAN_BODY, G_SoundIndex( "sound/weapons/force/push.wav" ) );
+						push_list[x]->client->ps.forceHandExtend = HANDEXTEND_FORCEPUSH;
+						push_list[x]->client->ps.forceHandExtendTime = level.time + 1000;
+					}
+					push_list[x]->client->ps.powerups[PW_DISINT_4] = push_list[x]->client->ps.forceHandExtendTime + 200;
+
+					if (pull)
+					{
+						push_list[x]->client->ps.powerups[PW_PULL] = push_list[x]->client->ps.powerups[PW_DISINT_4];
+					}
+					else
+					{
+						push_list[x]->client->ps.powerups[PW_PULL] = 0;
+					}
+
+					//Make a counter-throw effect
+
+					if (otherPushPower >= modPowerLevel)
+					{
+						pushPowerMod = 0;
+						canPullWeapon = qfalse;
+					}
+					else
+					{
+						int powerDif = (modPowerLevel - otherPushPower);
+
+						if (powerDif >= 3)
+						{
+							pushPowerMod -= pushPowerMod*0.2;
+						}
+						else if (powerDif == 2)
+						{
+							pushPowerMod -= pushPowerMod*0.4;
+						}
+						else if (powerDif == 1)
+						{
+							pushPowerMod -= pushPowerMod*0.8;
+						}
+
+						if (pushPowerMod < 0)
+						{
+							pushPowerMod = 0;
+						}
+					}
+				}
+
+				//shove them
+				if ( pull )
+				{
+					VectorSubtract( self->client->ps.origin, thispush_org, pushDir );
+
+					if (push_list[x]->client && VectorLength(pushDir) <= 256)
+					{
+						int randfact = 0;
+
+						if (modPowerLevel == FORCE_LEVEL_1)
+						{
+							randfact = 3;
+						}
+						else if (modPowerLevel == FORCE_LEVEL_2)
+						{
+							randfact = 7;
+						}
+						else if (modPowerLevel == FORCE_LEVEL_3)
+						{
+							randfact = 10;
+						}
+
+						if (!OnSameTeam(self, push_list[x]) && Q_irand(1, 10) <= randfact && canPullWeapon)
+						{
+							vec3_t uorg, vecnorm;
+
+							VectorCopy(self->client->ps.origin, uorg);
+							uorg[2] += 64;
+
+							VectorSubtract(uorg, thispush_org, vecnorm);
+							VectorNormalize(vecnorm);
+
+							TossClientWeapon(push_list[x], vecnorm, 500);
+						}
+					}
+				}
+				else
+				{
+					VectorSubtract( thispush_org, self->client->ps.origin, pushDir );
+				}
+
+				if ((modPowerLevel > otherPushPower || push_list[x]->client->ps.m_iVehicleNum) && push_list[x]->client)
+				{
+					if (modPowerLevel == FORCE_LEVEL_3 &&
+						push_list[x]->client->ps.forceHandExtend != HANDEXTEND_KNOCKDOWN)
+					{
+						dirLen = VectorLength(pushDir);
+
+						if (BG_KnockDownable(&push_list[x]->client->ps) &&
+							dirLen <= (64*((modPowerLevel - otherPushPower)-1)))
+						{ //can only do a knockdown if fairly close
+							push_list[x]->client->ps.forceHandExtend = HANDEXTEND_KNOCKDOWN;
+							push_list[x]->client->ps.forceHandExtendTime = level.time + 700;
+							push_list[x]->client->ps.forceDodgeAnim = 0; //this toggles between 1 and 0, when it's 1 we should play the get up anim
+							push_list[x]->client->ps.quickerGetup = qtrue;
+						}
+						else if (push_list[x]->s.number < MAX_CLIENTS && push_list[x]->client->ps.m_iVehicleNum &&
+							dirLen <= 128.0f )
+						{ //a player on a vehicle
+							gentity_t *vehEnt = &g_entities[push_list[x]->client->ps.m_iVehicleNum];
+							if (vehEnt->inuse && vehEnt->client && vehEnt->m_pVehicle)
+							{
+								if (vehEnt->m_pVehicle->m_pVehicleInfo->type == VH_SPEEDER ||
+									vehEnt->m_pVehicle->m_pVehicleInfo->type == VH_ANIMAL)
+								{ //push the guy off
+									vehEnt->m_pVehicle->m_pVehicleInfo->Eject(vehEnt->m_pVehicle, (bgEntity_t *)push_list[x], qfalse);
+								}
+							}
+						}
+					}
+				}
+
+				if (!dirLen)
+				{
+					dirLen = VectorLength(pushDir);
+				}
+
+				VectorNormalize(pushDir);
+
+				if (push_list[x]->client)
+				{
+					//escape a force grip if we're in one
+					if (self->client->ps.fd.forceGripBeingGripped > level.time)
+					{ //force the enemy to stop gripping me if I managed to push him
+						if (push_list[x]->client->ps.fd.forceGripEntityNum == self->s.number)
+						{
+							if (modPowerLevel >= push_list[x]->client->ps.fd.forcePowerLevel[FP_GRIP])
+							{ //only break the grip if our push/pull level is >= their grip level
+								WP_ForcePowerStop(push_list[x], FP_GRIP);
+								self->client->ps.fd.forceGripBeingGripped = 0;
+								push_list[x]->client->ps.fd.forceGripUseTime = level.time + 1000; //since we just broke out of it..
+							}
+						}
+					}
+
+					push_list[x]->client->ps.otherKiller = self->s.number;
+					push_list[x]->client->ps.otherKillerTime = level.time + 5000;
+					push_list[x]->client->ps.otherKillerDebounceTime = level.time + 100;
+
+					pushPowerMod -= (dirLen*0.7);
+					if (pushPowerMod < 16)
+					{
+						pushPowerMod = 16;
+					}
+
+					//fullbody push effect
+					push_list[x]->client->pushEffectTime = level.time + 600;
+
+					push_list[x]->client->ps.velocity[0] = pushDir[0]*pushPowerMod;
+					push_list[x]->client->ps.velocity[1] = pushDir[1]*pushPowerMod;
+
+					if ((int)push_list[x]->client->ps.velocity[2] == 0)
+					{ //if not going anywhere vertically, boost them up a bit
+						push_list[x]->client->ps.velocity[2] = pushDir[2]*pushPowerMod;
+
+						if (push_list[x]->client->ps.velocity[2] < 128)
+						{
+							push_list[x]->client->ps.velocity[2] = 128;
+						}
+					}
+					else
+					{
+						push_list[x]->client->ps.velocity[2] = pushDir[2]*pushPowerMod;
+					}
+				}
+			}
+			else if ( push_list[x]->s.eType == ET_MISSILE && push_list[x]->s.pos.trType != TR_STATIONARY && (push_list[x]->s.pos.trType != TR_INTERPOLATE||push_list[x]->s.weapon != WP_THERMAL) )//rolling and stationary thermal detonators are dealt with below
+			{
+				if ( pull )
+				{//deflect rather than reflect?
+				}
+				else 
+				{
+					G_ReflectMissile( self, push_list[x], forward );
+				}
+			}
+			else if ( !Q_stricmp( "func_static", push_list[x]->classname ) )
+			{//force-usable func_static
+				if ( !pull && (push_list[x]->spawnflags&1/*F_PUSH*/) )
+				{
+					GEntity_UseFunc( push_list[x], self, self );
+				}
+				else if ( pull && (push_list[x]->spawnflags&2/*F_PULL*/) )
+				{
+					GEntity_UseFunc( push_list[x], self, self );
+				}
+			}
+			else if ( !Q_stricmp( "func_door", push_list[x]->classname ) && (push_list[x]->spawnflags&2) )
+			{//push/pull the door
+				vec3_t	pos1, pos2;
+				vec3_t	trFrom;
+
+				VectorCopy(self->client->ps.origin, trFrom);
+				trFrom[2] += self->client->ps.viewheight;
+
+				AngleVectors( self->client->ps.viewangles, forward, NULL, NULL );
+				VectorNormalize( forward );
+				VectorMA( trFrom, radius, forward, end );
+				trap_Trace( &tr, trFrom, vec3_origin, vec3_origin, end, self->s.number, MASK_SHOT );
+				if ( tr.entityNum != push_list[x]->s.number || tr.fraction == 1.0 || tr.allsolid || tr.startsolid )
+				{//must be pointing right at it
+					continue;
+				}
+
+				if ( VectorCompare( vec3_origin, push_list[x]->s.origin ) )
+				{//does not have an origin brush, so pos1 & pos2 are relative to world origin, need to calc center
+					VectorSubtract( push_list[x]->r.absmax, push_list[x]->r.absmin, size );
+					VectorMA( push_list[x]->r.absmin, 0.5, size, center );
+					if ( (push_list[x]->spawnflags&1) && push_list[x]->moverState == MOVER_POS1 )
+					{//if at pos1 and started open, make sure we get the center where it *started* because we're going to add back in the relative values pos1 and pos2
+						VectorSubtract( center, push_list[x]->pos1, center );
+					}
+					else if ( !(push_list[x]->spawnflags&1) && push_list[x]->moverState == MOVER_POS2 )
+					{//if at pos2, make sure we get the center where it *started* because we're going to add back in the relative values pos1 and pos2
+						VectorSubtract( center, push_list[x]->pos2, center );
+					}
+					VectorAdd( center, push_list[x]->pos1, pos1 );
+					VectorAdd( center, push_list[x]->pos2, pos2 );
+				}
+				else
+				{//actually has an origin, pos1 and pos2 are absolute
+					VectorCopy( push_list[x]->r.currentOrigin, center );
+					VectorCopy( push_list[x]->pos1, pos1 );
+					VectorCopy( push_list[x]->pos2, pos2 );
+				}
+
+				if ( Distance( pos1, trFrom ) < Distance( pos2, trFrom ) )
+				{//pos1 is closer
+					if ( push_list[x]->moverState == MOVER_POS1 )
+					{//at the closest pos
+						if ( pull )
+						{//trying to pull, but already at closest point, so screw it
+							continue;
+						}
+					}
+					else if ( push_list[x]->moverState == MOVER_POS2 )
+					{//at farthest pos
+						if ( !pull )
+						{//trying to push, but already at farthest point, so screw it
+							continue;
+						}
+					}
+				}
+				else
+				{//pos2 is closer
+					if ( push_list[x]->moverState == MOVER_POS1 )
+					{//at the farthest pos
+						if ( !pull )
+						{//trying to push, but already at farthest point, so screw it
+							continue;
+						}
+					}
+					else if ( push_list[x]->moverState == MOVER_POS2 )
+					{//at closest pos
+						if ( pull )
+						{//trying to pull, but already at closest point, so screw it
+							continue;
+						}
+					}
+				}
+				GEntity_UseFunc( push_list[x], self, self );
+			}
+			else if ( Q_stricmp( "func_button", push_list[x]->classname ) == 0 )
+			{//pretend you pushed it
+				Touch_Button( push_list[x], self, NULL );
+				continue;
+			}
+		}
+	}
+
+	//attempt to break any leftover grips
+	//if we're still in a current grip that wasn't broken by the push, it will still remain
+	self->client->dangerTime = level.time;
+	self->client->ps.eFlags &= ~EF_INVULNERABLE;
+	self->client->invulnerableTimer = 0;
+
+	if (self->client->ps.fd.forceGripBeingGripped > level.time)
+	{
+		self->client->ps.fd.forceGripBeingGripped = 0;
+	}
+}
+
+void WP_ForcePowerStop( gentity_t *self, forcePowers_t forcePower )
+{
+	int wasActive = self->client->ps.fd.forcePowersActive;
+
+	self->client->ps.fd.forcePowersActive &= ~( 1 << forcePower );
+
+	switch( (int)forcePower )
+	{
+	case FP_HEAL:
+		self->client->ps.fd.forceHealAmount = 0;
+		self->client->ps.fd.forceHealTime = 0;
+		break;
+	case FP_LEVITATION:
+		break;
+	case FP_SPEED:
+		if (wasActive & (1 << FP_SPEED))
+		{
+			G_MuteSound(self->client->ps.fd.killSoundEntIndex[TRACK_CHANNEL_2-50], CHAN_VOICE);
+		}
+		break;
+	case FP_PUSH:
+		break;
+	case FP_PULL:
+		break;
+	case FP_TELEPATHY:
+		if (wasActive & (1 << FP_TELEPATHY))
+		{
+			G_Sound( self, CHAN_AUTO, G_SoundIndex("sound/weapons/force/distractstop.wav") );
+		}
+		self->client->ps.fd.forceMindtrickTargetIndex = 0;
+		self->client->ps.fd.forceMindtrickTargetIndex2 = 0;
+		self->client->ps.fd.forceMindtrickTargetIndex3 = 0;
+		self->client->ps.fd.forceMindtrickTargetIndex4 = 0;
+		break;
+	case FP_SEE:
+		if (wasActive & (1 << FP_SEE))
+		{
+			G_MuteSound(self->client->ps.fd.killSoundEntIndex[TRACK_CHANNEL_5-50], CHAN_VOICE);
+		}
+		break;
+	case FP_GRIP:
+		self->client->ps.fd.forceGripUseTime = level.time + 3000;
+		if (self->client->ps.fd.forcePowerLevel[FP_GRIP] > FORCE_LEVEL_1 &&
+			g_entities[self->client->ps.fd.forceGripEntityNum].client &&
+			g_entities[self->client->ps.fd.forceGripEntityNum].health > 0 &&
+			g_entities[self->client->ps.fd.forceGripEntityNum].inuse &&
+			(level.time - g_entities[self->client->ps.fd.forceGripEntityNum].client->ps.fd.forceGripStarted) > 500)
+		{ //if we had our throat crushed in for more than half a second, gasp for air when we're let go
+			if (wasActive & (1 << FP_GRIP))
+			{
+				G_EntitySound( &g_entities[self->client->ps.fd.forceGripEntityNum], CHAN_VOICE, G_SoundIndex("*gasp.wav") );
+			}
+		}
+
+		if (g_entities[self->client->ps.fd.forceGripEntityNum].client &&
+			g_entities[self->client->ps.fd.forceGripEntityNum].inuse)
+		{
+			
+			g_entities[self->client->ps.fd.forceGripEntityNum].client->ps.forceGripChangeMovetype = PM_NORMAL;
+		}
+
+		if (self->client->ps.forceHandExtend == HANDEXTEND_FORCE_HOLD)
+		{
+			self->client->ps.forceHandExtendTime = 0;
+		}
+
+		self->client->ps.fd.forceGripEntityNum = ENTITYNUM_NONE;
+
+		self->client->ps.powerups[PW_DISINT_4] = 0;
+		break;
+	case FP_LIGHTNING:
+		if ( self->client->ps.fd.forcePowerLevel[FP_LIGHTNING] < FORCE_LEVEL_2 )
+		{//don't do it again for 3 seconds, minimum... FIXME: this should be automatic once regeneration is slower (normal)
+			self->client->ps.fd.forcePowerDebounce[FP_LIGHTNING] = level.time + 3000;
+		}
+		else
+		{
+			self->client->ps.fd.forcePowerDebounce[FP_LIGHTNING] = level.time + 1500;
+		}
+		if (self->client->ps.forceHandExtend == HANDEXTEND_FORCE_HOLD)
+		{
+			self->client->ps.forceHandExtendTime = 0; //reset hand position
+		}
+
+		self->client->ps.activeForcePass = 0;
+		break;
+	case FP_RAGE:
+		self->client->ps.fd.forceRageRecoveryTime = level.time + 10000;
+		if (wasActive & (1 << FP_RAGE))
+		{
+			G_MuteSound(self->client->ps.fd.killSoundEntIndex[TRACK_CHANNEL_3-50], CHAN_VOICE);
+		}
+		break;
+	case FP_ABSORB:
+		if (wasActive & (1 << FP_ABSORB))
+		{
+			G_MuteSound(self->client->ps.fd.killSoundEntIndex[TRACK_CHANNEL_3-50], CHAN_VOICE);
+		}
+		break;
+	case FP_PROTECT:
+		if (wasActive & (1 << FP_PROTECT))
+		{
+			G_MuteSound(self->client->ps.fd.killSoundEntIndex[TRACK_CHANNEL_3-50], CHAN_VOICE);
+		}
+		break;
+	case FP_DRAIN:
+		if ( self->client->ps.fd.forcePowerLevel[FP_DRAIN] < FORCE_LEVEL_2 )
+		{//don't do it again for 3 seconds, minimum...
+			self->client->ps.fd.forcePowerDebounce[FP_DRAIN] = level.time + 3000;
+		}
+		else
+		{
+			self->client->ps.fd.forcePowerDebounce[FP_DRAIN] = level.time + 1500;
+		}
+
+		if (self->client->ps.forceHandExtend == HANDEXTEND_FORCE_HOLD)
+		{
+			self->client->ps.forceHandExtendTime = 0; //reset hand position
+		}
+
+		self->client->ps.activeForcePass = 0;
+	default:
+		break;
+	}
+}
+
+void DoGripAction(gentity_t *self, forcePowers_t forcePower)
+{
+	gentity_t *gripEnt;
+	int gripLevel = 0;
+	trace_t tr;
+	vec3_t a;
+	vec3_t fwd, fwd_o, start_o, nvel;
+
+	self->client->dangerTime = level.time;
+	self->client->ps.eFlags &= ~EF_INVULNERABLE;
+	self->client->invulnerableTimer = 0;
+
+	gripEnt = &g_entities[self->client->ps.fd.forceGripEntityNum];
+
+	if (!gripEnt || !gripEnt->client || !gripEnt->inuse || gripEnt->health < 1 || !ForcePowerUsableOn(self, gripEnt, FP_GRIP))
+	{
+		WP_ForcePowerStop(self, forcePower);
+		self->client->ps.fd.forceGripEntityNum = ENTITYNUM_NONE;
+
+		if (gripEnt && gripEnt->client && gripEnt->inuse)
+		{
+			gripEnt->client->ps.forceGripChangeMovetype = PM_NORMAL;
+		}
+		return;
+	}
+
+	VectorSubtract(gripEnt->client->ps.origin, self->client->ps.origin, a);
+	
+	trap_Trace(&tr, self->client->ps.origin, NULL, NULL, gripEnt->client->ps.origin, self->s.number, MASK_PLAYERSOLID);
+
+	gripLevel = WP_AbsorbConversion(gripEnt, gripEnt->client->ps.fd.forcePowerLevel[FP_ABSORB], self, FP_GRIP, self->client->ps.fd.forcePowerLevel[FP_GRIP], forcePowerNeeded[self->client->ps.fd.forcePowerLevel[FP_GRIP]][FP_GRIP]);
+
+	if (gripLevel == -1)
+	{
+		gripLevel = self->client->ps.fd.forcePowerLevel[FP_GRIP];
+	}
+
+	if (!gripLevel)
+	{
+		WP_ForcePowerStop(self, forcePower);
+		return;
+	}
+
+	if (VectorLength(a) > MAX_GRIP_DISTANCE)
+	{
+		WP_ForcePowerStop(self, forcePower);
+		return;
+	}
+
+	if ( !InFront( gripEnt->client->ps.origin, self->client->ps.origin, self->client->ps.viewangles, 0.9f ) &&
+		gripLevel < FORCE_LEVEL_3)
+	{
+		WP_ForcePowerStop(self, forcePower);
+		return;
+	}
+
+	if (tr.fraction != 1.0f &&
+		tr.entityNum != gripEnt->s.number /*&&
+		gripLevel < FORCE_LEVEL_3*/)
+	{
+		WP_ForcePowerStop(self, forcePower);
+		return;
+	}
+
+	if (self->client->ps.fd.forcePowerDebounce[FP_GRIP] < level.time)
+	{ //2 damage per second while choking, resulting in 10 damage total (not including The Squeeze<tm>)
+		self->client->ps.fd.forcePowerDebounce[FP_GRIP] = level.time + 1000;
+		G_Damage(gripEnt, self, self, NULL, NULL, 2, DAMAGE_NO_ARMOR, MOD_FORCE_DARK);
+	}
+
+	Jetpack_Off(gripEnt); //make sure the guy being gripped has his jetpack off.
+
+	if (gripLevel == FORCE_LEVEL_1)
+	{
+		gripEnt->client->ps.fd.forceGripBeingGripped = level.time + 1000;
+		
+		if ((level.time - gripEnt->client->ps.fd.forceGripStarted) > 5000)
+		{
+			WP_ForcePowerStop(self, forcePower);
+		}
+		return;
+	}
+
+	if (gripLevel == FORCE_LEVEL_2)
+	{
+		gripEnt->client->ps.fd.forceGripBeingGripped = level.time + 1000;
+
+		if (gripEnt->client->ps.forceGripMoveInterval < level.time)
+		{
+			gripEnt->client->ps.velocity[2] = 30;
+
+			gripEnt->client->ps.forceGripMoveInterval = level.time + 300; //only update velocity every 300ms, so as to avoid heavy bandwidth usage
+		}
+
+		gripEnt->client->ps.otherKiller = self->s.number;
+		gripEnt->client->ps.otherKillerTime = level.time + 5000;
+		gripEnt->client->ps.otherKillerDebounceTime = level.time + 100;
+
+		gripEnt->client->ps.forceGripChangeMovetype = PM_FLOAT;
+
+		if ((level.time - gripEnt->client->ps.fd.forceGripStarted) > 3000 && !self->client->ps.fd.forceGripDamageDebounceTime)
+		{ //if we managed to lift him into the air for 2 seconds, give him a crack
+			self->client->ps.fd.forceGripDamageDebounceTime = 1;
+			G_Damage(gripEnt, self, self, NULL, NULL, 20, DAMAGE_NO_ARMOR, MOD_FORCE_DARK);
+
+			//Must play custom sounds on the actual entity. Don't use G_Sound (it creates a temp entity for the sound)
+			G_EntitySound( gripEnt, CHAN_VOICE, G_SoundIndex(va( "*choke%d.wav", Q_irand( 1, 3 ) )) );
+
+			gripEnt->client->ps.forceHandExtend = HANDEXTEND_CHOKE;
+			gripEnt->client->ps.forceHandExtendTime = level.time + 2000;
+
+			if (gripEnt->client->ps.fd.forcePowersActive & (1 << FP_GRIP))
+			{ //choking, so don't let him keep gripping himself
+				WP_ForcePowerStop(gripEnt, FP_GRIP);
+			}
+		}
+		else if ((level.time - gripEnt->client->ps.fd.forceGripStarted) > 4000)
+		{
+			WP_ForcePowerStop(self, forcePower);
+		}
+		return;
+	}
+
+	if (gripLevel == FORCE_LEVEL_3)
+	{
+		gripEnt->client->ps.fd.forceGripBeingGripped = level.time + 1000;
+
+		gripEnt->client->ps.otherKiller = self->s.number;
+		gripEnt->client->ps.otherKillerTime = level.time + 5000;
+		gripEnt->client->ps.otherKillerDebounceTime = level.time + 100;
+
+		gripEnt->client->ps.forceGripChangeMovetype = PM_FLOAT;
+
+		if (gripEnt->client->ps.forceGripMoveInterval < level.time)
+		{
+			float nvLen = 0;
+
+			VectorCopy(gripEnt->client->ps.origin, start_o);
+			AngleVectors(self->client->ps.viewangles, fwd, NULL, NULL);
+			fwd_o[0] = self->client->ps.origin[0] + fwd[0]*128;
+			fwd_o[1] = self->client->ps.origin[1] + fwd[1]*128;
+			fwd_o[2] = self->client->ps.origin[2] + fwd[2]*128;
+			fwd_o[2] += 16;
+			VectorSubtract(fwd_o, start_o, nvel);
+
+			nvLen = VectorLength(nvel);
+
+			if (nvLen < 16)
+			{ //within x units of desired spot
+				VectorNormalize(nvel);
+				gripEnt->client->ps.velocity[0] = nvel[0]*8;
+				gripEnt->client->ps.velocity[1] = nvel[1]*8;
+				gripEnt->client->ps.velocity[2] = nvel[2]*8;
+			}
+			else if (nvLen < 64)
+			{
+				VectorNormalize(nvel);
+				gripEnt->client->ps.velocity[0] = nvel[0]*128;
+				gripEnt->client->ps.velocity[1] = nvel[1]*128;
+				gripEnt->client->ps.velocity[2] = nvel[2]*128;
+			}
+			else if (nvLen < 128)
+			{
+				VectorNormalize(nvel);
+				gripEnt->client->ps.velocity[0] = nvel[0]*256;
+				gripEnt->client->ps.velocity[1] = nvel[1]*256;
+				gripEnt->client->ps.velocity[2] = nvel[2]*256;
+			}
+			else if (nvLen < 200)
+			{
+				VectorNormalize(nvel);
+				gripEnt->client->ps.velocity[0] = nvel[0]*512;
+				gripEnt->client->ps.velocity[1] = nvel[1]*512;
+				gripEnt->client->ps.velocity[2] = nvel[2]*512;
+			}
+			else
+			{
+				VectorNormalize(nvel);
+				gripEnt->client->ps.velocity[0] = nvel[0]*700;
+				gripEnt->client->ps.velocity[1] = nvel[1]*700;
+				gripEnt->client->ps.velocity[2] = nvel[2]*700;
+			}
+
+			gripEnt->client->ps.forceGripMoveInterval = level.time + 300; //only update velocity every 300ms, so as to avoid heavy bandwidth usage
+		}
+
+		if ((level.time - gripEnt->client->ps.fd.forceGripStarted) > 3000 && !self->client->ps.fd.forceGripDamageDebounceTime)
+		{ //if we managed to lift him into the air for 2 seconds, give him a crack
+			self->client->ps.fd.forceGripDamageDebounceTime = 1;
+			G_Damage(gripEnt, self, self, NULL, NULL, 40, DAMAGE_NO_ARMOR, MOD_FORCE_DARK);
+
+			//Must play custom sounds on the actual entity. Don't use G_Sound (it creates a temp entity for the sound)
+			G_EntitySound( gripEnt, CHAN_VOICE, G_SoundIndex(va( "*choke%d.wav", Q_irand( 1, 3 ) )) );
+
+			gripEnt->client->ps.forceHandExtend = HANDEXTEND_CHOKE;
+			gripEnt->client->ps.forceHandExtendTime = level.time + 2000;
+
+			if (gripEnt->client->ps.fd.forcePowersActive & (1 << FP_GRIP))
+			{ //choking, so don't let him keep gripping himself
+				WP_ForcePowerStop(gripEnt, FP_GRIP);
+			}
+		}
+		else if ((level.time - gripEnt->client->ps.fd.forceGripStarted) > 4000)
+		{
+			WP_ForcePowerStop(self, forcePower);
+		}
+		return;
+	}
+}
+
+qboolean G_IsMindTricked(forcedata_t *fd, int client)
+{
+	int checkIn;
+	int trickIndex1, trickIndex2, trickIndex3, trickIndex4;
+	int sub = 0;
+
+	if (!fd)
+	{
+		return qfalse;
+	}
+
+	trickIndex1 = fd->forceMindtrickTargetIndex;
+	trickIndex2 = fd->forceMindtrickTargetIndex2;
+	trickIndex3 = fd->forceMindtrickTargetIndex3;
+	trickIndex4 = fd->forceMindtrickTargetIndex4;
+
+	if (client > 47)
+	{
+		checkIn = trickIndex4;
+		sub = 48;
+	}
+	else if (client > 31)
+	{
+		checkIn = trickIndex3;
+		sub = 32;
+	}
+	else if (client > 15)
+	{
+		checkIn = trickIndex2;
+		sub = 16;
+	}
+	else
+	{
+		checkIn = trickIndex1;
+	}
+
+	if (checkIn & (1 << (client-sub)))
+	{
+		return qtrue;
+	}
+	
+	return qfalse;
+}
+
+static void RemoveTrickedEnt(forcedata_t *fd, int client)
+{
+	if (!fd)
+	{
+		return;
+	}
+
+	if (client > 47)
+	{
+		fd->forceMindtrickTargetIndex4 &= ~(1 << (client-48));
+	}
+	else if (client > 31)
+	{
+		fd->forceMindtrickTargetIndex3 &= ~(1 << (client-32));
+	}
+	else if (client > 15)
+	{
+		fd->forceMindtrickTargetIndex2 &= ~(1 << (client-16));
+	}
+	else
+	{
+		fd->forceMindtrickTargetIndex &= ~(1 << client);
+	}
+}
+
+extern int g_LastFrameTime;
+extern int g_TimeSinceLastFrame;
+
+static void WP_UpdateMindtrickEnts(gentity_t *self)
+{
+	int i = 0;
+
+	while (i < MAX_CLIENTS)
+	{
+		if (G_IsMindTricked(&self->client->ps.fd, i))
+		{
+			gentity_t *ent = &g_entities[i];
+
+			if ( !ent || !ent->client || !ent->inuse || ent->health < 1 ||
+				(ent->client->ps.fd.forcePowersActive & (1 << FP_SEE)) )
+			{
+				RemoveTrickedEnt(&self->client->ps.fd, i);
+			}
+			else if ((level.time - self->client->dangerTime) < g_TimeSinceLastFrame*4)
+			{ //Untrick this entity if the tricker (self) fires while in his fov
+				if (trap_InPVS(ent->client->ps.origin, self->client->ps.origin) &&
+					OrgVisible(ent->client->ps.origin, self->client->ps.origin, ent->s.number))
+				{
+					RemoveTrickedEnt(&self->client->ps.fd, i);
+				}
+			}
+			else if (BG_HasYsalamiri(g_gametype.integer, &ent->client->ps))
+			{
+				RemoveTrickedEnt(&self->client->ps.fd, i);
+			}
+		}
+
+		i++;
+	}
+
+	if (!self->client->ps.fd.forceMindtrickTargetIndex &&
+		!self->client->ps.fd.forceMindtrickTargetIndex2 &&
+		!self->client->ps.fd.forceMindtrickTargetIndex3 &&
+		!self->client->ps.fd.forceMindtrickTargetIndex4)
+	{ //everyone who we had tricked is no longer tricked, so stop the power
+		WP_ForcePowerStop(self, FP_TELEPATHY);
+	}
+	else if (self->client->ps.powerups[PW_REDFLAG] ||
+		self->client->ps.powerups[PW_BLUEFLAG])
+	{
+		WP_ForcePowerStop(self, FP_TELEPATHY);
+	}
+}
+
+static void WP_ForcePowerRun( gentity_t *self, forcePowers_t forcePower, usercmd_t *cmd )
+{
+	extern usercmd_t	ucmd;
+
+	switch( (int)forcePower )
+	{
+	case FP_HEAL:
+		if (self->client->ps.fd.forcePowerLevel[FP_HEAL] == FORCE_LEVEL_1)
+		{
+			if (self->client->ps.velocity[0] || self->client->ps.velocity[1] || self->client->ps.velocity[2])
+			{
+				WP_ForcePowerStop( self, forcePower );
+				break;
+			}
+		}
+
+		if (self->health < 1 || self->client->ps.stats[STAT_HEALTH] < 1)
+		{
+			WP_ForcePowerStop( self, forcePower );
+			break;
+		}
+
+		if (self->client->ps.fd.forceHealTime > level.time)
+		{
+			break;
+		}
+		if ( self->health > self->client->ps.stats[STAT_MAX_HEALTH])
+		{ //rww - we might start out over max_health and we don't want force heal taking us down to 100 or whatever max_health is
+			WP_ForcePowerStop( self, forcePower );
+			break;
+		}
+		self->client->ps.fd.forceHealTime = level.time + 1000;
+		self->health++;
+		self->client->ps.fd.forceHealAmount++;
+
+		if ( self->health > self->client->ps.stats[STAT_MAX_HEALTH])	// Past max health
+		{
+			self->health = self->client->ps.stats[STAT_MAX_HEALTH];
+			WP_ForcePowerStop( self, forcePower );
+		}
+
+		if ( (self->client->ps.fd.forcePowerLevel[FP_HEAL] == FORCE_LEVEL_1 && self->client->ps.fd.forceHealAmount >= 25) ||
+			(self->client->ps.fd.forcePowerLevel[FP_HEAL] == FORCE_LEVEL_2 && self->client->ps.fd.forceHealAmount >= 33))
+		{
+			WP_ForcePowerStop( self, forcePower );
+		}
+		break;
+	case FP_SPEED:
+		//This is handled in PM_WalkMove and PM_StepSlideMove
+		if ( self->client->holdingObjectiveItem >= MAX_CLIENTS  
+			&& self->client->holdingObjectiveItem < ENTITYNUM_WORLD )
+		{
+			if ( g_entities[self->client->holdingObjectiveItem].genericValue15 )
+			{//disables force powers
+				WP_ForcePowerStop( self, forcePower );
+			}
+		}
+		/*
+		if ( self->client->ps.powerups[PW_REDFLAG]
+			|| self->client->ps.powerups[PW_BLUEFLAG]
+			|| self->client->ps.powerups[PW_NEUTRALFLAG] )
+		{//no force speed when carrying flag
+			WP_ForcePowerStop( self, forcePower );
+		}
+		*/
+		break;
+	case FP_GRIP:
+		if (self->client->ps.forceHandExtend != HANDEXTEND_FORCE_HOLD)
+		{
+			WP_ForcePowerStop(self, FP_GRIP);
+			break;
+		}
+
+		if (self->client->ps.fd.forcePowerDebounce[FP_PULL] < level.time)
+		{ //This is sort of not ideal. Using the debounce value reserved for pull for this because pull doesn't need it.
+			BG_ForcePowerDrain( &self->client->ps, forcePower, 1 );
+			self->client->ps.fd.forcePowerDebounce[FP_PULL] = level.time + 100;
+		}
+
+		if (self->client->ps.fd.forcePower < 1)
+		{
+			WP_ForcePowerStop(self, FP_GRIP);
+			break;
+		}
+
+		DoGripAction(self, forcePower);
+		break;
+	case FP_LEVITATION:
+		if ( self->client->ps.groundEntityNum != ENTITYNUM_NONE && !self->client->ps.fd.forceJumpZStart )
+		{//done with jump
+			WP_ForcePowerStop( self, forcePower );
+		}
+		break;
+	case FP_RAGE:
+		if (self->health < 1)
+		{
+			WP_ForcePowerStop(self, forcePower);
+			break;
+		}
+		if (self->client->ps.forceRageDrainTime < level.time)
+		{
+			int addTime = 400;
+
+			self->health -= 2;
+
+			if (self->client->ps.fd.forcePowerLevel[FP_RAGE] == FORCE_LEVEL_1)
+			{
+				addTime = 150;
+			}
+			else if (self->client->ps.fd.forcePowerLevel[FP_RAGE] == FORCE_LEVEL_2)
+			{
+				addTime = 300;
+			}
+			else if (self->client->ps.fd.forcePowerLevel[FP_RAGE] == FORCE_LEVEL_3)
+			{
+				addTime = 450;
+			}
+			self->client->ps.forceRageDrainTime = level.time + addTime;
+		}
+
+		if (self->health < 1)
+		{
+			self->health = 1;
+			WP_ForcePowerStop(self, forcePower);
+		}
+
+		self->client->ps.stats[STAT_HEALTH] = self->health;
+		break;
+	case FP_DRAIN:
+		if (self->client->ps.forceHandExtend != HANDEXTEND_FORCE_HOLD)
+		{
+			WP_ForcePowerStop(self, forcePower);
+			break;
+		}
+
+		if ( self->client->ps.fd.forcePowerLevel[FP_DRAIN] > FORCE_LEVEL_1 )
+		{//higher than level 1
+			if ( (cmd->buttons & BUTTON_FORCE_DRAIN) || ((cmd->buttons & BUTTON_FORCEPOWER) && self->client->ps.fd.forcePowerSelected == FP_DRAIN) )
+			{//holding it keeps it going
+				self->client->ps.fd.forcePowerDuration[FP_DRAIN] = level.time + 500;
+			}
+		}
+		// OVERRIDEFIXME
+		if ( !WP_ForcePowerAvailable( self, forcePower, 0 ) || self->client->ps.fd.forcePowerDuration[FP_DRAIN] < level.time ||
+			self->client->ps.fd.forcePower < 25)
+		{
+			WP_ForcePowerStop( self, forcePower );
+		}
+		else
+		{
+			ForceShootDrain( self );
+		}
+		break;
+	case FP_LIGHTNING:
+		if (self->client->ps.forceHandExtend != HANDEXTEND_FORCE_HOLD)
+		{ //Animation for hand extend doesn't end with hand out, so we have to limit lightning intervals by animation intervals (once hand starts to go in in animation, lightning should stop)
+			WP_ForcePowerStop(self, forcePower);
+			break;
+		}
+
+		if ( self->client->ps.fd.forcePowerLevel[FP_LIGHTNING] > FORCE_LEVEL_1 )
+		{//higher than level 1
+			if ( (cmd->buttons & BUTTON_FORCE_LIGHTNING) || ((cmd->buttons & BUTTON_FORCEPOWER) && self->client->ps.fd.forcePowerSelected == FP_LIGHTNING) )
+			{//holding it keeps it going
+				self->client->ps.fd.forcePowerDuration[FP_LIGHTNING] = level.time + 500;
+			}
+		}
+		// OVERRIDEFIXME
+		if ( !WP_ForcePowerAvailable( self, forcePower, 0 ) || self->client->ps.fd.forcePowerDuration[FP_LIGHTNING] < level.time ||
+			self->client->ps.fd.forcePower < 25)
+		{
+			WP_ForcePowerStop( self, forcePower );
+		}
+		else
+		{
+			ForceShootLightning( self );
+			BG_ForcePowerDrain( &self->client->ps, forcePower, 0 );
+		}
+		break;
+	case FP_TELEPATHY:
+		if ( self->client->holdingObjectiveItem >= MAX_CLIENTS  
+			&& self->client->holdingObjectiveItem < ENTITYNUM_WORLD
+			&& g_entities[self->client->holdingObjectiveItem].genericValue15 )
+		{ //if force hindered can't mindtrick whilst carrying a siege item
+			WP_ForcePowerStop( self, FP_TELEPATHY );
+		}
+		else
+		{
+			WP_UpdateMindtrickEnts(self);
+		}
+		break;
+	case FP_SABER_OFFENSE:
+		break;
+	case FP_SABER_DEFENSE:
+		break;
+	case FP_SABERTHROW:
+		break;
+	case FP_PROTECT:
+		if (self->client->ps.fd.forcePowerDebounce[forcePower] < level.time)
+		{
+			BG_ForcePowerDrain( &self->client->ps, forcePower, 1 );
+			if (self->client->ps.fd.forcePower < 1)
+			{
+				WP_ForcePowerStop(self, forcePower);
+			}
+
+			self->client->ps.fd.forcePowerDebounce[forcePower] = level.time + 300;
+		}
+		break;
+	case FP_ABSORB:
+		if (self->client->ps.fd.forcePowerDebounce[forcePower] < level.time)
+		{
+			BG_ForcePowerDrain( &self->client->ps, forcePower, 1 );
+			if (self->client->ps.fd.forcePower < 1)
+			{
+				WP_ForcePowerStop(self, forcePower);
+			}
+
+			self->client->ps.fd.forcePowerDebounce[forcePower] = level.time + 600;
+		}
+		break;
+	default:
+		break;
+	}
+}
+
+int WP_DoSpecificPower( gentity_t *self, usercmd_t *ucmd, forcePowers_t forcepower)
+{
+	int powerSucceeded;
+
+	powerSucceeded = 1;
+
+	// OVERRIDEFIXME
+	if ( !WP_ForcePowerAvailable( self, forcepower, 0 ) )
+	{
+		return 0;
+	}
+
+	switch(forcepower)
+	{
+	case FP_HEAL:
+		powerSucceeded = 0; //always 0 for nonhold powers
+		if (self->client->ps.fd.forceButtonNeedRelease)
+		{ //need to release before we can use nonhold powers again
+			break;
+		}
+		ForceHeal(self);
+		self->client->ps.fd.forceButtonNeedRelease = 1;
+		break;
+	case FP_LEVITATION:
+		//if leave the ground by some other means, cancel the force jump so we don't suddenly jump when we land.
+		
+		if ( self->client->ps.groundEntityNum == ENTITYNUM_NONE )
+		{
+			self->client->ps.fd.forceJumpCharge = 0;
+			G_MuteSound( self->client->ps.fd.killSoundEntIndex[TRACK_CHANNEL_1-50], CHAN_VOICE );
+			//This only happens if the groundEntityNum == ENTITYNUM_NONE when the button is actually released
+		}
+		else
+		{//still on ground, so jump
+			ForceJump( self, ucmd );
+		}
+		break;
+	case FP_SPEED:
+		powerSucceeded = 0; //always 0 for nonhold powers
+		if (self->client->ps.fd.forceButtonNeedRelease)
+		{ //need to release before we can use nonhold powers again
+			break;
+		}
+		ForceSpeed(self, 0);
+		self->client->ps.fd.forceButtonNeedRelease = 1;
+		break;
+	case FP_GRIP:
+		if (self->client->ps.fd.forceGripEntityNum == ENTITYNUM_NONE)
+		{
+			ForceGrip( self );
+		}
+
+		if (self->client->ps.fd.forceGripEntityNum != ENTITYNUM_NONE)
+		{
+			if (!(self->client->ps.fd.forcePowersActive & (1 << FP_GRIP)))
+			{
+				WP_ForcePowerStart( self, FP_GRIP, 0 );
+				BG_ForcePowerDrain( &self->client->ps, FP_GRIP, GRIP_DRAIN_AMOUNT );
+			}
+		}
+		else
+		{
+			powerSucceeded = 0;
+		}
+		break;
+	case FP_LIGHTNING:
+		ForceLightning(self);
+		break;
+	case FP_PUSH:
+		powerSucceeded = 0; //always 0 for nonhold powers
+		if (self->client->ps.fd.forceButtonNeedRelease && !(self->r.svFlags & SVF_BOT))
+		{ //need to release before we can use nonhold powers again
+			break;
+		}
+		ForceThrow(self, qfalse);
+		self->client->ps.fd.forceButtonNeedRelease = 1;
+		break;
+	case FP_PULL:
+		powerSucceeded = 0; //always 0 for nonhold powers
+		if (self->client->ps.fd.forceButtonNeedRelease)
+		{ //need to release before we can use nonhold powers again
+			break;
+		}
+		ForceThrow(self, qtrue);
+		self->client->ps.fd.forceButtonNeedRelease = 1;
+		break;
+	case FP_TELEPATHY:
+		powerSucceeded = 0; //always 0 for nonhold powers
+		if (self->client->ps.fd.forceButtonNeedRelease)
+		{ //need to release before we can use nonhold powers again
+			break;
+		}
+		ForceTelepathy(self);
+		self->client->ps.fd.forceButtonNeedRelease = 1;
+		break;
+	case FP_RAGE:
+		powerSucceeded = 0; //always 0 for nonhold powers
+		if (self->client->ps.fd.forceButtonNeedRelease)
+		{ //need to release before we can use nonhold powers again
+			break;
+		}
+		ForceRage(self);
+		self->client->ps.fd.forceButtonNeedRelease = 1;
+		break;
+	case FP_PROTECT:
+		powerSucceeded = 0; //always 0 for nonhold powers
+		if (self->client->ps.fd.forceButtonNeedRelease)
+		{ //need to release before we can use nonhold powers again
+			break;
+		}
+		ForceProtect(self);
+		self->client->ps.fd.forceButtonNeedRelease = 1;
+		break;
+	case FP_ABSORB:
+		powerSucceeded = 0; //always 0 for nonhold powers
+		if (self->client->ps.fd.forceButtonNeedRelease)
+		{ //need to release before we can use nonhold powers again
+			break;
+		}
+		ForceAbsorb(self);
+		self->client->ps.fd.forceButtonNeedRelease = 1;
+		break;
+	case FP_TEAM_HEAL:
+		powerSucceeded = 0; //always 0 for nonhold powers
+		if (self->client->ps.fd.forceButtonNeedRelease)
+		{ //need to release before we can use nonhold powers again
+			break;
+		}
+		ForceTeamHeal(self);
+		self->client->ps.fd.forceButtonNeedRelease = 1;
+		break;
+	case FP_TEAM_FORCE:
+		powerSucceeded = 0; //always 0 for nonhold powers
+		if (self->client->ps.fd.forceButtonNeedRelease)
+		{ //need to release before we can use nonhold powers again
+			break;
+		}
+		ForceTeamForceReplenish(self);
+		self->client->ps.fd.forceButtonNeedRelease = 1;
+		break;
+	case FP_DRAIN:
+		ForceDrain(self);
+		break;
+	case FP_SEE:
+		powerSucceeded = 0; //always 0 for nonhold powers
+		if (self->client->ps.fd.forceButtonNeedRelease)
+		{ //need to release before we can use nonhold powers again
+			break;
+		}
+		ForceSeeing(self);
+		self->client->ps.fd.forceButtonNeedRelease = 1;
+		break;
+	case FP_SABER_OFFENSE:
+		break;
+	case FP_SABER_DEFENSE:
+		break;
+	case FP_SABERTHROW:
+		break;
+	default:
+		break;
+	}
+
+	return powerSucceeded;
+}
+
+void FindGenericEnemyIndex(gentity_t *self)
+{ //Find another client that would be considered a threat.
+	int i = 0;
+	float tlen;
+	gentity_t *ent;
+	gentity_t *besten = NULL;
+	float blen = 99999999;
+	vec3_t a;
+
+	while (i < MAX_CLIENTS)
+	{
+		ent = &g_entities[i];
+
+		if (ent && ent->client && ent->s.number != self->s.number && ent->health > 0 && !OnSameTeam(self, ent) && ent->client->ps.pm_type != PM_INTERMISSION && ent->client->ps.pm_type != PM_SPECTATOR)
+		{
+			VectorSubtract(ent->client->ps.origin, self->client->ps.origin, a);
+			tlen = VectorLength(a);
+
+			if (tlen < blen &&
+				InFront(ent->client->ps.origin, self->client->ps.origin, self->client->ps.viewangles, 0.8f ) &&
+				OrgVisible(self->client->ps.origin, ent->client->ps.origin, self->s.number))
+			{
+				blen = tlen;
+				besten = ent;
+			}
+		}
+
+		i++;
+	}
+
+	if (!besten)
+	{
+		return;
+	}
+
+	self->client->ps.genericEnemyIndex = besten->s.number;
+}
+
+void SeekerDroneUpdate(gentity_t *self)
+{
+	vec3_t org, elevated, dir, a, endir;
+	gentity_t *en;
+	float angle;
+	float prefig = 0;
+	trace_t tr;
+
+	if (!(self->client->ps.eFlags & EF_SEEKERDRONE))
+	{
+		self->client->ps.genericEnemyIndex = -1;
+		return;
+	}
+
+	if (self->health < 1)
+	{
+		VectorCopy(self->client->ps.origin, elevated);
+		elevated[2] += 40;
+
+		angle = ((level.time / 12) & 255) * (M_PI * 2) / 255; //magical numbers make magic happen
+		dir[0] = cos(angle) * 20;
+		dir[1] = sin(angle) * 20;
+		dir[2] = cos(angle) * 5;
+		VectorAdd(elevated, dir, org);
+
+		a[ROLL] = 0;
+		a[YAW] = 0;
+		a[PITCH] = 1;
+
+		G_PlayEffect(EFFECT_SPARK_EXPLOSION, org, a);
+
+		self->client->ps.eFlags -= EF_SEEKERDRONE;
+		self->client->ps.genericEnemyIndex = -1;
+
+		return;
+	}
+
+	if (self->client->ps.droneExistTime >= level.time && 
+		self->client->ps.droneExistTime < (level.time+5000))
+	{
+		self->client->ps.genericEnemyIndex = 1024+self->client->ps.droneExistTime;
+		if (self->client->ps.droneFireTime < level.time)
+		{
+			G_Sound( self, CHAN_BODY, G_SoundIndex("sound/weapons/laser_trap/warning.wav") );
+			self->client->ps.droneFireTime = level.time + 100;
+		}
+		return;
+	}
+	else if (self->client->ps.droneExistTime < level.time)
+	{
+		VectorCopy(self->client->ps.origin, elevated);
+		elevated[2] += 40;
+
+		prefig = (self->client->ps.droneExistTime-level.time)/80;
+
+		if (prefig > 55)
+		{
+			prefig = 55;
+		}
+		else if (prefig < 1)
+		{
+			prefig = 1;
+		}
+
+		elevated[2] -= 55-prefig;
+
+		angle = ((level.time / 12) & 255) * (M_PI * 2) / 255; //magical numbers make magic happen
+		dir[0] = cos(angle) * 20;
+		dir[1] = sin(angle) * 20;
+		dir[2] = cos(angle) * 5;
+		VectorAdd(elevated, dir, org);
+
+		a[ROLL] = 0;
+		a[YAW] = 0;
+		a[PITCH] = 1;
+
+		G_PlayEffect(EFFECT_SPARK_EXPLOSION, org, a);
+
+		self->client->ps.eFlags -= EF_SEEKERDRONE;
+		self->client->ps.genericEnemyIndex = -1;
+
+		return;
+	}
+
+	if (self->client->ps.genericEnemyIndex == -1)
+	{
+		self->client->ps.genericEnemyIndex = ENTITYNUM_NONE;
+	}
+
+	if (self->client->ps.genericEnemyIndex != ENTITYNUM_NONE && self->client->ps.genericEnemyIndex != -1)
+	{
+		en = &g_entities[self->client->ps.genericEnemyIndex];
+
+		if (!en || !en->client)
+		{
+			self->client->ps.genericEnemyIndex = ENTITYNUM_NONE;
+		}
+		else if (en->s.number == self->s.number)
+		{
+			self->client->ps.genericEnemyIndex = ENTITYNUM_NONE;
+		}
+		else if (en->health < 1)
+		{
+			self->client->ps.genericEnemyIndex = ENTITYNUM_NONE;
+		}
+		else if (OnSameTeam(self, en))
+		{
+			self->client->ps.genericEnemyIndex = ENTITYNUM_NONE;
+		}
+		else
+		{
+			if (!InFront(en->client->ps.origin, self->client->ps.origin, self->client->ps.viewangles, 0.8f ))
+			{
+				self->client->ps.genericEnemyIndex = ENTITYNUM_NONE;
+			}
+			else if (!OrgVisible(self->client->ps.origin, en->client->ps.origin, self->s.number))
+			{
+				self->client->ps.genericEnemyIndex = ENTITYNUM_NONE;
+			}
+		}
+	}
+
+	if (self->client->ps.genericEnemyIndex == ENTITYNUM_NONE || self->client->ps.genericEnemyIndex == -1)
+	{
+		FindGenericEnemyIndex(self);
+	}
+
+	if (self->client->ps.genericEnemyIndex != ENTITYNUM_NONE && self->client->ps.genericEnemyIndex != -1)
+	{
+		en = &g_entities[self->client->ps.genericEnemyIndex];
+
+		VectorCopy(self->client->ps.origin, elevated);
+		elevated[2] += 40;
+
+		angle = ((level.time / 12) & 255) * (M_PI * 2) / 255; //magical numbers make magic happen
+		dir[0] = cos(angle) * 20;
+		dir[1] = sin(angle) * 20;
+		dir[2] = cos(angle) * 5;
+		VectorAdd(elevated, dir, org);
+
+		//org is now where the thing should be client-side because it uses the same time-based offset
+		if (self->client->ps.droneFireTime < level.time)
+		{
+			trap_Trace(&tr, org, NULL, NULL, en->client->ps.origin, -1, MASK_SOLID);
+
+			if (tr.fraction == 1 && !tr.startsolid && !tr.allsolid)
+			{
+				VectorSubtract(en->client->ps.origin, org, endir);
+				VectorNormalize(endir);
+
+				WP_FireGenericBlasterMissile(self, org, endir, 0, 15, 2000, MOD_BLASTER);
+				G_SoundAtLoc( org, CHAN_WEAPON, G_SoundIndex("sound/weapons/bryar/fire.wav") );
+
+				self->client->ps.droneFireTime = level.time + Q_irand(400, 700);
+			}
+		}
+	}
+}
+
+void HolocronUpdate(gentity_t *self)
+{ //keep holocron status updated in holocron mode
+	int i = 0;
+	int noHRank = 0;
+
+	if (noHRank < FORCE_LEVEL_0)
+	{
+		noHRank = FORCE_LEVEL_0;
+	}
+	if (noHRank > FORCE_LEVEL_3)
+	{
+		noHRank = FORCE_LEVEL_3;
+	}
+
+	trap_Cvar_Update(&g_MaxHolocronCarry);
+
+	while (i < NUM_FORCE_POWERS)
+	{
+		if (self->client->ps.holocronsCarried[i])
+		{ //carrying it, make sure we have the power
+			self->client->ps.holocronBits |= (1 << i);
+			self->client->ps.fd.forcePowersKnown |= (1 << i);
+			self->client->ps.fd.forcePowerLevel[i] = FORCE_LEVEL_3;
+		}
+		else
+		{ //otherwise, make sure the power is cleared from us
+			self->client->ps.fd.forcePowerLevel[i] = 0;
+			if (self->client->ps.holocronBits & (1 << i))
+			{
+				self->client->ps.holocronBits -= (1 << i);
+			}
+
+			if ((self->client->ps.fd.forcePowersKnown & (1 << i)) && i != FP_LEVITATION && i != FP_SABER_OFFENSE)
+			{
+				self->client->ps.fd.forcePowersKnown -= (1 << i);
+			}
+
+			if ((self->client->ps.fd.forcePowersActive & (1 << i)) && i != FP_LEVITATION && i != FP_SABER_OFFENSE)
+			{
+				WP_ForcePowerStop(self, i);
+			}
+
+			if (i == FP_LEVITATION)
+			{
+				if (noHRank >= FORCE_LEVEL_1)
+				{
+					self->client->ps.fd.forcePowerLevel[i] = noHRank;
+				}
+				else
+				{
+					self->client->ps.fd.forcePowerLevel[i] = FORCE_LEVEL_1;
+				}
+			}
+			else if (i == FP_SABER_OFFENSE)
+			{
+				self->client->ps.fd.forcePowersKnown |= (1 << i);
+
+				if (noHRank >= FORCE_LEVEL_1)
+				{
+					self->client->ps.fd.forcePowerLevel[i] = noHRank;
+				}
+				else
+				{
+					self->client->ps.fd.forcePowerLevel[i] = FORCE_LEVEL_1;
+				}
+			}
+			else
+			{
+				self->client->ps.fd.forcePowerLevel[i] = FORCE_LEVEL_0;
+			}
+		}
+
+		i++;
+	}
+
+	if (HasSetSaberOnly())
+	{ //if saberonly, we get these powers no matter what (still need the holocrons for level 3)
+		if (self->client->ps.fd.forcePowerLevel[FP_SABER_OFFENSE] < FORCE_LEVEL_1)
+		{
+			self->client->ps.fd.forcePowerLevel[FP_SABER_OFFENSE] = FORCE_LEVEL_1;
+		}
+		if (self->client->ps.fd.forcePowerLevel[FP_SABER_DEFENSE] < FORCE_LEVEL_1)
+		{
+			self->client->ps.fd.forcePowerLevel[FP_SABER_DEFENSE] = FORCE_LEVEL_1;
+		}
+	}
+}
+
+void JediMasterUpdate(gentity_t *self)
+{ //keep jedi master status updated for JM gametype
+	int i = 0;
+
+	trap_Cvar_Update(&g_MaxHolocronCarry);
+
+	while (i < NUM_FORCE_POWERS)
+	{
+		if (self->client->ps.isJediMaster)
+		{
+			self->client->ps.fd.forcePowersKnown |= (1 << i);
+			self->client->ps.fd.forcePowerLevel[i] = FORCE_LEVEL_3;
+
+			if (i == FP_TEAM_HEAL || i == FP_TEAM_FORCE ||
+				i == FP_DRAIN || i == FP_ABSORB)
+			{ //team powers are useless in JM, absorb is too because no one else has powers to absorb. Drain is just
+			  //relatively useless in comparison, because its main intent is not to heal, but rather to cripple others
+			  //by draining their force at the same time. And no one needs force in JM except the JM himself.
+				self->client->ps.fd.forcePowersKnown &= ~(1 << i);
+				self->client->ps.fd.forcePowerLevel[i] = 0;
+			}
+
+			if (i == FP_TELEPATHY)
+			{ //this decision was made because level 3 mindtrick allows the JM to just hide too much, and no one else has force
+			  //sight to counteract it. Since the JM himself is the focus of gameplay in this mode, having him hidden for large
+			  //durations is indeed a bad thing.
+				self->client->ps.fd.forcePowerLevel[i] = FORCE_LEVEL_2;
+			}
+		}
+		else
+		{
+			if ((self->client->ps.fd.forcePowersKnown & (1 << i)) && i != FP_LEVITATION)
+			{
+				self->client->ps.fd.forcePowersKnown -= (1 << i);
+			}
+
+			if ((self->client->ps.fd.forcePowersActive & (1 << i)) && i != FP_LEVITATION)
+			{
+				WP_ForcePowerStop(self, i);
+			}
+
+			if (i == FP_LEVITATION)
+			{
+				self->client->ps.fd.forcePowerLevel[i] = FORCE_LEVEL_1;
+			}
+			else
+			{
+				self->client->ps.fd.forcePowerLevel[i] = FORCE_LEVEL_0;
+			}
+		}
+
+		i++;
+	}
+}
+
+qboolean WP_HasForcePowers( const playerState_t *ps )
+{
+	int i;
+	if ( ps )
+	{
+		for ( i = 0; i < NUM_FORCE_POWERS; i++ )
+		{
+			if ( i == FP_LEVITATION )
+			{
+				if ( ps->fd.forcePowerLevel[i] > FORCE_LEVEL_1 )
+				{
+					return qtrue;
+				}
+			}
+			else if ( ps->fd.forcePowerLevel[i] > FORCE_LEVEL_0 )
+			{
+				return qtrue;
+			}
+		}
+	}
+	return qfalse;
+}
+
+//try a special roll getup move
+qboolean G_SpecialRollGetup(gentity_t *self)
+{ //fixme: currently no knockdown will actually land you on your front... so froll's are pretty useless at the moment.
+	qboolean rolled = qfalse;
+
+	/*
+	if (self->client->ps.weapon != WP_SABER &&
+		self->client->ps.weapon != WP_MELEE)
+	{ //can't do acrobatics without saber selected
+		return qfalse;
+	}
+	*/
+
+	if (/*!self->client->pers.cmd.upmove &&*/
+		self->client->pers.cmd.rightmove > 0 &&
+		!self->client->pers.cmd.forwardmove)
+	{
+		G_SetAnim(self, &self->client->pers.cmd, SETANIM_BOTH, BOTH_GETUP_BROLL_R, SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLD, 0);
+		rolled = qtrue;
+	}
+	else if (/*!self->client->pers.cmd.upmove &&*/
+		self->client->pers.cmd.rightmove < 0 &&
+		!self->client->pers.cmd.forwardmove)
+	{
+		G_SetAnim(self, &self->client->pers.cmd, SETANIM_BOTH, BOTH_GETUP_BROLL_L, SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLD, 0);
+		rolled = qtrue;
+	}
+	else if (/*self->client->pers.cmd.upmove > 0 &&*/
+		!self->client->pers.cmd.rightmove &&
+		self->client->pers.cmd.forwardmove > 0)
+	{
+		G_SetAnim(self, &self->client->pers.cmd, SETANIM_BOTH, BOTH_GETUP_BROLL_F, SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLD, 0);
+		rolled = qtrue;
+	}
+	else if (/*self->client->pers.cmd.upmove > 0 &&*/
+		!self->client->pers.cmd.rightmove &&
+		self->client->pers.cmd.forwardmove < 0)
+	{
+		G_SetAnim(self, &self->client->pers.cmd, SETANIM_BOTH, BOTH_GETUP_BROLL_B, SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLD, 0);
+		rolled = qtrue;
+	}
+	else if (self->client->pers.cmd.upmove)
+	{
+		G_PreDefSound(self->client->ps.origin, PDSOUND_FORCEJUMP);
+		self->client->ps.forceDodgeAnim = 2;
+		self->client->ps.forceHandExtendTime = level.time + 500;
+
+		//self->client->ps.velocity[2] = 300;
+	}
+
+	if (rolled)
+	{
+		G_EntitySound( self, CHAN_VOICE, G_SoundIndex("*jump1.wav") );
+	}
+
+	return rolled;
+}
+
+void WP_ForcePowersUpdate( gentity_t *self, usercmd_t *ucmd )
+{
+	qboolean	usingForce = qfalse;
+	int			i, holo, holoregen;
+	int			prepower = 0;
+	//see if any force powers are running
+	if ( !self )
+	{
+		return;
+	}
+
+	if ( !self->client )
+	{
+		return;
+	}
+
+	if (self->client->ps.pm_flags & PMF_FOLLOW)
+	{ //not a "real" game client, it's a spectator following someone
+		return;
+	}
+	if (self->client->sess.sessionTeam == TEAM_SPECTATOR)
+	{
+		return;
+	}
+
+	/*
+	if (self->client->ps.fd.saberAnimLevel > self->client->ps.fd.forcePowerLevel[FP_SABER_OFFENSE])
+	{
+		self->client->ps.fd.saberAnimLevel = self->client->ps.fd.forcePowerLevel[FP_SABER_OFFENSE];
+	}
+	else if (!self->client->ps.fd.saberAnimLevel)
+	{
+		self->client->ps.fd.saberAnimLevel = FORCE_LEVEL_1;
+	}
+	*/
+	//The stance in relation to power level is no longer applicable with the crazy new akimbo/staff stances.
+	if (!self->client->ps.fd.saberAnimLevel)
+	{
+		self->client->ps.fd.saberAnimLevel = FORCE_LEVEL_1;
+	}
+
+	if (g_gametype.integer != GT_SIEGE)
+	{
+		if (!(self->client->ps.fd.forcePowersKnown & (1 << FP_LEVITATION)))
+		{
+			self->client->ps.fd.forcePowersKnown |= (1 << FP_LEVITATION);
+		}
+
+		if (self->client->ps.fd.forcePowerLevel[FP_LEVITATION] < FORCE_LEVEL_1)
+		{
+			self->client->ps.fd.forcePowerLevel[FP_LEVITATION] = FORCE_LEVEL_1;
+		}
+	}
+
+	if (self->client->ps.fd.forcePowerSelected < 0)
+	{ //bad
+		self->client->ps.fd.forcePowerSelected = 0;
+	}
+
+	if ( ((self->client->sess.selectedFP != self->client->ps.fd.forcePowerSelected) ||
+		(self->client->sess.saberLevel != self->client->ps.fd.saberAnimLevel)) &&
+		!(self->r.svFlags & SVF_BOT) )
+	{
+		if (self->client->sess.updateUITime < level.time)
+		{ //a bit hackish, but we don't want the client to flood with userinfo updates if they rapidly cycle
+		  //through their force powers or saber attack levels
+
+			self->client->sess.selectedFP = self->client->ps.fd.forcePowerSelected;
+			self->client->sess.saberLevel = self->client->ps.fd.saberAnimLevel;
+		}
+	}
+
+	if (!g_LastFrameTime)
+	{
+		g_LastFrameTime = level.time;
+	}
+
+	if (self->client->ps.forceHandExtend == HANDEXTEND_KNOCKDOWN)
+	{
+		self->client->ps.zoomFov = 0;
+		self->client->ps.zoomMode = 0;
+		self->client->ps.zoomLocked = qfalse;
+		self->client->ps.zoomTime = 0;
+	}
+
+	if (self->client->ps.forceHandExtend == HANDEXTEND_KNOCKDOWN &&
+		self->client->ps.forceHandExtendTime >= level.time)
+	{
+		self->client->ps.saberMove = 0;
+		self->client->ps.saberBlocking = 0;
+		self->client->ps.saberBlocked = 0;
+		self->client->ps.weaponTime = 0;
+		self->client->ps.weaponstate = WEAPON_READY;
+	}
+	else if (self->client->ps.forceHandExtend != HANDEXTEND_NONE &&
+		self->client->ps.forceHandExtendTime < level.time)
+	{
+		if (self->client->ps.forceHandExtend == HANDEXTEND_KNOCKDOWN &&
+			!self->client->ps.forceDodgeAnim)
+		{
+			if (self->health < 1 || (self->client->ps.eFlags & EF_DEAD))
+			{
+				self->client->ps.forceHandExtend = HANDEXTEND_NONE;
+			}
+			else if (G_SpecialRollGetup(self))
+			{
+				self->client->ps.forceHandExtend = HANDEXTEND_NONE;
+			}
+			else
+			{ //hmm.. ok.. no more getting up on your own, you've gotta push something, unless..
+				if ((level.time-self->client->ps.forceHandExtendTime) > 4000)
+				{ //4 seconds elapsed, I guess they're too dumb to push something to get up!
+					if (self->client->pers.cmd.upmove &&
+						self->client->ps.fd.forcePowerLevel[FP_LEVITATION] > FORCE_LEVEL_1)
+					{ //force getup
+						G_PreDefSound(self->client->ps.origin, PDSOUND_FORCEJUMP);
+						self->client->ps.forceDodgeAnim = 2;
+						self->client->ps.forceHandExtendTime = level.time + 500;
+
+						//self->client->ps.velocity[2] = 400;
+					}
+					else if (self->client->ps.quickerGetup)
+					{
+						G_EntitySound( self, CHAN_VOICE, G_SoundIndex("*jump1.wav") );
+						self->client->ps.forceDodgeAnim = 3;
+						self->client->ps.forceHandExtendTime = level.time + 500;
+						self->client->ps.velocity[2] = 300;
+					}
+					else
+					{
+						self->client->ps.forceDodgeAnim = 1;
+						self->client->ps.forceHandExtendTime = level.time + 1000;
+					}
+				}
+			}
+			self->client->ps.quickerGetup = qfalse;
+		}
+		else if (self->client->ps.forceHandExtend == HANDEXTEND_POSTTHROWN)
+		{
+			if (self->health < 1 || (self->client->ps.eFlags & EF_DEAD))
+			{
+				self->client->ps.forceHandExtend = HANDEXTEND_NONE;
+			}
+			else if (self->client->ps.groundEntityNum != ENTITYNUM_NONE && !self->client->ps.forceDodgeAnim)
+			{
+				self->client->ps.forceDodgeAnim = 1;
+				self->client->ps.forceHandExtendTime = level.time + 1000;
+				G_EntitySound( self, CHAN_VOICE, G_SoundIndex("*jump1.wav") );
+				self->client->ps.velocity[2] = 100;
+			}
+			else if (!self->client->ps.forceDodgeAnim)
+			{
+				self->client->ps.forceHandExtendTime = level.time + 100;
+			}
+			else
+			{
+				self->client->ps.forceHandExtend = HANDEXTEND_WEAPONREADY;
+			}
+		}
+		else
+		{
+			self->client->ps.forceHandExtend = HANDEXTEND_WEAPONREADY;
+		}
+	}
+
+	if (g_gametype.integer == GT_HOLOCRON)
+	{
+		HolocronUpdate(self);
+	}
+	if (g_gametype.integer == GT_JEDIMASTER)
+	{
+		JediMasterUpdate(self);
+	}
+
+	SeekerDroneUpdate(self);
+
+	if (self->client->ps.powerups[PW_FORCE_BOON])
+	{
+		prepower = self->client->ps.fd.forcePower;
+	}
+
+	if (self && self->client && (BG_HasYsalamiri(g_gametype.integer, &self->client->ps) ||
+		self->client->ps.fd.forceDeactivateAll || self->client->tempSpectate >= level.time))
+	{ //has ysalamiri.. or we want to forcefully stop all his active powers
+		i = 0;
+
+		while (i < NUM_FORCE_POWERS)
+		{
+			if ((self->client->ps.fd.forcePowersActive & (1 << i)) && i != FP_LEVITATION)
+			{
+				WP_ForcePowerStop(self, i);
+			}
+
+			i++;
+		}
+
+		if (self->client->tempSpectate >= level.time)
+		{
+			self->client->ps.fd.forcePower = 100;
+			self->client->ps.fd.forceRageRecoveryTime = 0;
+		}
+
+		self->client->ps.fd.forceDeactivateAll = 0;
+
+		if (self->client->ps.fd.forceJumpCharge)
+		{
+			G_MuteSound(self->client->ps.fd.killSoundEntIndex[TRACK_CHANNEL_1-50], CHAN_VOICE);
+			self->client->ps.fd.forceJumpCharge = 0;
+		}
+	}
+	else
+	{ //otherwise just do a check through them all to see if they need to be stopped for any reason.
+		i = 0;
+
+		while (i < NUM_FORCE_POWERS)
+		{
+			if ((self->client->ps.fd.forcePowersActive & (1 << i)) && i != FP_LEVITATION &&
+				!BG_CanUseFPNow(g_gametype.integer, &self->client->ps, level.time, i))
+			{
+				WP_ForcePowerStop(self, i);
+			}
+
+			i++;
+		}
+	}
+
+	i = 0;
+
+	if (self->client->ps.powerups[PW_FORCE_ENLIGHTENED_LIGHT] || self->client->ps.powerups[PW_FORCE_ENLIGHTENED_DARK])
+	{ //enlightenment
+		if (!self->client->ps.fd.forceUsingAdded)
+		{
+			i = 0;
+
+			while (i < NUM_FORCE_POWERS)
+			{
+				self->client->ps.fd.forcePowerBaseLevel[i] = self->client->ps.fd.forcePowerLevel[i];
+
+				if (!forcePowerDarkLight[i] ||
+					self->client->ps.fd.forceSide == forcePowerDarkLight[i])
+				{
+					self->client->ps.fd.forcePowerLevel[i] = FORCE_LEVEL_3;
+					self->client->ps.fd.forcePowersKnown |= (1 << i);
+				}
+
+				i++;
+			}
+
+			self->client->ps.fd.forceUsingAdded = 1;
+		}
+	}
+	else if (self->client->ps.fd.forceUsingAdded)
+	{ //we don't have enlightenment but we're still using enlightened powers, so clear them back to how they should be.
+		i = 0;
+
+		while (i < NUM_FORCE_POWERS)
+		{
+			self->client->ps.fd.forcePowerLevel[i] = self->client->ps.fd.forcePowerBaseLevel[i];
+			if (!self->client->ps.fd.forcePowerLevel[i])
+			{
+				if (self->client->ps.fd.forcePowersActive & (1 << i))
+				{
+					WP_ForcePowerStop(self, i);
+				}
+				self->client->ps.fd.forcePowersKnown &= ~(1 << i);
+			}
+
+			i++;
+		}
+
+		self->client->ps.fd.forceUsingAdded = 0;
+	}
+
+	i = 0;
+
+	if (!(self->client->ps.fd.forcePowersActive & (1 << FP_TELEPATHY)))
+	{ //clear the mindtrick index values
+		self->client->ps.fd.forceMindtrickTargetIndex = 0;
+		self->client->ps.fd.forceMindtrickTargetIndex2 = 0;
+		self->client->ps.fd.forceMindtrickTargetIndex3 = 0;
+		self->client->ps.fd.forceMindtrickTargetIndex4 = 0;
+	}
+	
+	if (self->health < 1)
+	{
+		self->client->ps.fd.forceGripBeingGripped = 0;
+	}
+
+	if (self->client->ps.fd.forceGripBeingGripped > level.time)
+	{
+		self->client->ps.fd.forceGripCripple = 1;
+
+		//keep the saber off during this period
+		if (self->client->ps.weapon == WP_SABER && !self->client->ps.saberHolstered)
+		{
+			Cmd_ToggleSaber_f(self);
+		}
+	}
+	else
+	{
+		self->client->ps.fd.forceGripCripple = 0;
+	}
+
+	if (self->client->ps.fd.forceJumpSound)
+	{
+		G_PreDefSound(self->client->ps.origin, PDSOUND_FORCEJUMP);
+		self->client->ps.fd.forceJumpSound = 0;
+	}
+
+	if (self->client->ps.fd.forceGripCripple)
+	{
+		if (self->client->ps.fd.forceGripSoundTime < level.time)
+		{
+			G_PreDefSound(self->client->ps.origin, PDSOUND_FORCEGRIP);
+			self->client->ps.fd.forceGripSoundTime = level.time + 1000;
+		}
+	}
+
+	if (self->client->ps.fd.forcePowersActive & (1 << FP_SPEED))
+	{
+		self->client->ps.powerups[PW_SPEED] = level.time + 100;
+	}
+
+	if ( self->health <= 0 )
+	{//if dead, deactivate any active force powers
+		for ( i = 0; i < NUM_FORCE_POWERS; i++ )
+		{
+			if ( self->client->ps.fd.forcePowerDuration[i] || (self->client->ps.fd.forcePowersActive&( 1 << i )) )
+			{
+				WP_ForcePowerStop( self, (forcePowers_t)i );
+				self->client->ps.fd.forcePowerDuration[i] = 0;
+			}
+		}
+		goto powersetcheck;
+	}
+
+	if (self->client->ps.groundEntityNum != ENTITYNUM_NONE)
+	{
+		self->client->fjDidJump = qfalse;
+	}
+
+	if (self->client->ps.fd.forceJumpCharge && self->client->ps.groundEntityNum == ENTITYNUM_NONE && self->client->fjDidJump)
+	{ //this was for the "charge" jump method... I guess
+		if (ucmd->upmove < 10 && (!(ucmd->buttons & BUTTON_FORCEPOWER) || self->client->ps.fd.forcePowerSelected != FP_LEVITATION))
+		{
+			G_MuteSound(self->client->ps.fd.killSoundEntIndex[TRACK_CHANNEL_1-50], CHAN_VOICE);
+			self->client->ps.fd.forceJumpCharge = 0;
+		}
+	}
+
+#ifndef METROID_JUMP
+	else if ( (ucmd->upmove > 10) && (self->client->ps.pm_flags & PMF_JUMP_HELD) && self->client->ps.groundTime && (level.time - self->client->ps.groundTime) > 150 && !BG_HasYsalamiri(g_gametype.integer, &self->client->ps) && BG_CanUseFPNow(g_gametype.integer, &self->client->ps, level.time, FP_LEVITATION) )
+	{//just charging up
+		ForceJumpCharge( self, ucmd );
+		usingForce = qtrue;
+	}
+	else if (ucmd->upmove < 10 && self->client->ps.groundEntityNum == ENTITYNUM_NONE && self->client->ps.fd.forceJumpCharge)
+	{
+		self->client->ps.pm_flags &= ~(PMF_JUMP_HELD);
+	}
+#endif
+
+	if (!(self->client->ps.pm_flags & PMF_JUMP_HELD) && self->client->ps.fd.forceJumpCharge)
+	{
+		if (!(ucmd->buttons & BUTTON_FORCEPOWER) ||
+			self->client->ps.fd.forcePowerSelected != FP_LEVITATION)
+		{
+			if (WP_DoSpecificPower( self, ucmd, FP_LEVITATION ))
+			{
+				usingForce = qtrue;
+			}
+		}
+	}
+
+	if ( ucmd->buttons & BUTTON_FORCEGRIP )
+	{ //grip is one of the powers with its own button.. if it's held, call the specific grip power function.
+		if (WP_DoSpecificPower( self, ucmd, FP_GRIP ))
+		{
+			usingForce = qtrue;
+		}
+		else
+		{ //don't let recharge even if the grip misses if the player still has the button down
+			usingForce = qtrue;
+		}
+	}
+	else
+	{ //see if we're using it generically.. if not, stop.
+		if (self->client->ps.fd.forcePowersActive & (1 << FP_GRIP))
+		{
+			if (!(ucmd->buttons & BUTTON_FORCEPOWER) || self->client->ps.fd.forcePowerSelected != FP_GRIP)
+			{
+				WP_ForcePowerStop(self, FP_GRIP);
+			}
+		}
+	}
+
+	if ( ucmd->buttons & BUTTON_FORCE_LIGHTNING )
+	{ //lightning
+		WP_DoSpecificPower(self, ucmd, FP_LIGHTNING);
+		usingForce = qtrue;
+	}
+	else
+	{ //see if we're using it generically.. if not, stop.
+		if (self->client->ps.fd.forcePowersActive & (1 << FP_LIGHTNING))
+		{
+			if (!(ucmd->buttons & BUTTON_FORCEPOWER) || self->client->ps.fd.forcePowerSelected != FP_LIGHTNING)
+			{
+				WP_ForcePowerStop(self, FP_LIGHTNING);
+			}
+		}
+	}
+
+	if ( ucmd->buttons & BUTTON_FORCE_DRAIN )
+	{ //drain
+		WP_DoSpecificPower(self, ucmd, FP_DRAIN);
+		usingForce = qtrue;
+	}
+	else
+	{ //see if we're using it generically.. if not, stop.
+		if (self->client->ps.fd.forcePowersActive & (1 << FP_DRAIN))
+		{
+			if (!(ucmd->buttons & BUTTON_FORCEPOWER) || self->client->ps.fd.forcePowerSelected != FP_DRAIN)
+			{
+				WP_ForcePowerStop(self, FP_DRAIN);
+			}
+		}
+	}
+
+	if ( (ucmd->buttons & BUTTON_FORCEPOWER) &&
+		BG_CanUseFPNow(g_gametype.integer, &self->client->ps, level.time, self->client->ps.fd.forcePowerSelected))
+	{
+		if (self->client->ps.fd.forcePowerSelected == FP_LEVITATION)
+		{
+			ForceJumpCharge( self, ucmd );
+			usingForce = qtrue;
+		}
+		else if (WP_DoSpecificPower( self, ucmd, self->client->ps.fd.forcePowerSelected ))
+		{
+			usingForce = qtrue;
+		}
+		else if (self->client->ps.fd.forcePowerSelected == FP_GRIP)
+		{
+			usingForce = qtrue;
+		}
+	}
+	else
+	{
+		self->client->ps.fd.forceButtonNeedRelease = 0;
+	}
+
+	for ( i = 0; i < NUM_FORCE_POWERS; i++ )
+	{
+		if ( self->client->ps.fd.forcePowerDuration[i] )
+		{
+			if ( self->client->ps.fd.forcePowerDuration[i] < level.time )
+			{
+				if ( (self->client->ps.fd.forcePowersActive&( 1 << i )) )
+				{//turn it off
+					WP_ForcePowerStop( self, (forcePowers_t)i );
+				}
+				self->client->ps.fd.forcePowerDuration[i] = 0;
+			}
+		}
+		if ( (self->client->ps.fd.forcePowersActive&( 1 << i )) )
+		{
+			usingForce = qtrue;
+			WP_ForcePowerRun( self, (forcePowers_t)i, ucmd );
+		}
+	}
+	if ( self->client->ps.saberInFlight && self->client->ps.saberEntityNum )
+	{//don't regen force power while throwing saber
+		if ( self->client->ps.saberEntityNum < ENTITYNUM_NONE && self->client->ps.saberEntityNum > 0 )//player is 0
+		{//
+			if ( &g_entities[self->client->ps.saberEntityNum] != NULL && g_entities[self->client->ps.saberEntityNum].s.pos.trType == TR_LINEAR )
+			{//fell to the ground and we're trying to pull it back
+				usingForce = qtrue;
+			}
+		}
+	}
+	if ( !self->client->ps.fd.forcePowersActive || self->client->ps.fd.forcePowersActive == (1 << FP_DRAIN) )
+	{//when not using the force, regenerate at 1 point per half second
+		if ( !self->client->ps.saberInFlight && self->client->ps.fd.forcePowerRegenDebounceTime < level.time &&
+			(self->client->ps.weapon != WP_SABER || !BG_SaberInSpecial(self->client->ps.saberMove)) )
+		{
+			if (g_gametype.integer != GT_HOLOCRON || g_MaxHolocronCarry.value)
+			{
+				//if (!g_trueJedi.integer || self->client->ps.weapon == WP_SABER)
+				//let non-jedi force regen since we're doing a more strict jedi/non-jedi thing... this gives dark jedi something to drain
+				{
+					if (self->client->ps.powerups[PW_FORCE_BOON])
+					{
+						WP_ForcePowerRegenerate( self, 6 );
+					}
+					else if (self->client->ps.isJediMaster && g_gametype.integer == GT_JEDIMASTER)
+					{
+						WP_ForcePowerRegenerate( self, 4 ); //jedi master regenerates 4 times as fast
+					}
+					else
+					{
+						WP_ForcePowerRegenerate( self, 0 );
+					}
+				}
+				/*
+				else if (g_trueJedi.integer && self->client->ps.weapon != WP_SABER)
+				{
+					self->client->ps.fd.forcePower = 0;
+				}
+				*/
+			}
+			else
+			{ //regenerate based on the number of holocrons carried
+				holoregen = 0;
+				holo = 0;
+				while (holo < NUM_FORCE_POWERS)
+				{
+					if (self->client->ps.holocronsCarried[holo])
+					{
+						holoregen++;
+					}
+					holo++;
+				}
+
+				WP_ForcePowerRegenerate(self, holoregen);
+			}
+
+			if (g_gametype.integer == GT_SIEGE)
+			{
+				if (self->client->holdingObjectiveItem &&
+					g_entities[self->client->holdingObjectiveItem].inuse &&
+					g_entities[self->client->holdingObjectiveItem].genericValue15)
+				{ //1 point per 7 seconds.. super slow
+					self->client->ps.fd.forcePowerRegenDebounceTime = level.time + 7000;
+				}
+				else if (self->client->siegeClass != -1 &&
+					(bgSiegeClasses[self->client->siegeClass].classflags & (1<<CFL_FASTFORCEREGEN)))
+				{ //if this is siege and our player class has the fast force regen ability, then recharge with 1/5th the usual delay
+					self->client->ps.fd.forcePowerRegenDebounceTime = level.time + (g_forceRegenTime.integer*0.2);
+				}
+				else
+				{
+					self->client->ps.fd.forcePowerRegenDebounceTime = level.time + g_forceRegenTime.integer;
+				}
+			}
+			else
+			{
+				if ( g_gametype.integer == GT_POWERDUEL && self->client->sess.duelTeam == DUELTEAM_LONE )
+				{
+					if ( g_duel_fraglimit.integer )
+					{
+						self->client->ps.fd.forcePowerRegenDebounceTime = level.time + (g_forceRegenTime.integer*
+							(0.6 + (.3 * (float)self->client->sess.wins / (float)g_duel_fraglimit.integer)));
+					}
+					else
+					{
+						self->client->ps.fd.forcePowerRegenDebounceTime = level.time + (g_forceRegenTime.integer*0.7);
+					}
+				}
+				else
+				{
+					self->client->ps.fd.forcePowerRegenDebounceTime = level.time + g_forceRegenTime.integer;
+				}
+			}
+		}
+	}
+
+powersetcheck:
+
+	if (prepower && self->client->ps.fd.forcePower < prepower)
+	{
+		int dif = ((prepower - self->client->ps.fd.forcePower)/2);
+		if (dif < 1)
+		{
+			dif = 1;
+		}
+
+		self->client->ps.fd.forcePower = (prepower-dif);
+	}
+}
+
+qboolean Jedi_DodgeEvasion( gentity_t *self, gentity_t *shooter, trace_t *tr, int hitLoc )
+{
+	int	dodgeAnim = -1;
+
+	if ( !self || !self->client || self->health <= 0 )
+	{
+		return qfalse;
+	}
+
+	if (!g_forceDodge.integer)
+	{
+		return qfalse;
+	}
+
+	if (g_forceDodge.integer != 2)
+	{
+		if (!(self->client->ps.fd.forcePowersActive & (1 << FP_SEE)))
+		{
+			return qfalse;
+		}
+	}
+
+	if ( self->client->ps.groundEntityNum == ENTITYNUM_NONE )
+	{//can't dodge in mid-air
+		return qfalse;
+	}
+
+	if ( self->client->ps.weaponTime > 0 || self->client->ps.forceHandExtend != HANDEXTEND_NONE )
+	{//in some effect that stops me from moving on my own
+		return qfalse;
+	}
+
+	if (g_forceDodge.integer == 2)
+	{
+		if (self->client->ps.fd.forcePowersActive)
+		{ //for now just don't let us dodge if we're using a force power at all
+			return qfalse;
+		}
+	}
+
+	if (g_forceDodge.integer == 2)
+	{
+		if ( !WP_ForcePowerUsable( self, FP_SPEED ) )
+		{//make sure we have it and have enough force power
+			return qfalse;
+		}
+	}
+
+	if (g_forceDodge.integer == 2)
+	{
+		if ( Q_irand( 1, 7 ) > self->client->ps.fd.forcePowerLevel[FP_SPEED] )
+		{//more likely to fail on lower force speed level
+			return qfalse;
+		}
+	}
+	else
+	{
+		//We now dodge all the time, but only on level 3
+		if (self->client->ps.fd.forcePowerLevel[FP_SEE] < FORCE_LEVEL_3)
+		{//more likely to fail on lower force sight level
+			return qfalse;
+		}
+	}
+
+	switch( hitLoc )
+	{
+	case HL_NONE:
+		return qfalse;
+		break;
+
+	case HL_FOOT_RT:
+	case HL_FOOT_LT:
+	case HL_LEG_RT:
+	case HL_LEG_LT:
+		return qfalse;
+
+	case HL_BACK_RT:
+		dodgeAnim = BOTH_DODGE_FL;
+		break;
+	case HL_CHEST_RT:
+		dodgeAnim = BOTH_DODGE_FR;
+		break;
+	case HL_BACK_LT:
+		dodgeAnim = BOTH_DODGE_FR;
+		break;
+	case HL_CHEST_LT:
+		dodgeAnim = BOTH_DODGE_FR;
+		break;
+	case HL_BACK:
+	case HL_CHEST:
+	case HL_WAIST:
+		dodgeAnim = BOTH_DODGE_FL;
+		break;
+	case HL_ARM_RT:
+	case HL_HAND_RT:
+		dodgeAnim = BOTH_DODGE_L;
+		break;
+	case HL_ARM_LT:
+	case HL_HAND_LT:
+		dodgeAnim = BOTH_DODGE_R;
+		break;
+	case HL_HEAD:
+		dodgeAnim = BOTH_DODGE_FL;
+		break;
+	default:
+		return qfalse;
+	}
+
+	if ( dodgeAnim != -1 )
+	{
+		//Our own happy way of forcing an anim:
+		self->client->ps.forceHandExtend = HANDEXTEND_DODGE;
+		self->client->ps.forceDodgeAnim = dodgeAnim;
+		self->client->ps.forceHandExtendTime = level.time + 300;
+
+		self->client->ps.powerups[PW_SPEEDBURST] = level.time + 100;
+
+		if (g_forceDodge.integer == 2)
+		{
+			ForceSpeed( self, 500 );
+		}
+		else
+		{
+			G_Sound( self, CHAN_BODY, G_SoundIndex("sound/weapons/force/speed.wav") );
+		}
+		return qtrue;
+	}
+	return qfalse;
+}
diff --git a/codemp/game/w_saber.c b/codemp/game/w_saber.c
new file mode 100644
index 0000000..ab3e1c7
--- /dev/null
+++ b/codemp/game/w_saber.c
@@ -0,0 +1,8957 @@
+#include "g_local.h"
+#include "bg_local.h"
+#include "w_saber.h"
+#include "ai_main.h"
+#include "../ghoul2/G2.h"
+
+#define SABER_BOX_SIZE 16.0f
+extern bot_state_t *botstates[MAX_CLIENTS];
+extern qboolean InFront( vec3_t spot, vec3_t from, vec3_t fromAngles, float threshHold );
+extern void G_TestLine(vec3_t start, vec3_t end, int color, int time);
+
+extern vmCvar_t		g_saberRealisticCombat;
+extern vmCvar_t		d_saberSPStyleDamage;
+extern vmCvar_t		g_debugSaberLocks;
+// nmckenzie: SABER_DAMAGE_WALLS
+extern vmCvar_t		g_saberWallDamageScale;
+
+int saberSpinSound = 0;
+
+//would be cleaner if these were renamed to BG_ and proto'd in a header.
+#include "../namespace_begin.h"
+qboolean PM_SaberInTransition( int move );
+qboolean PM_SaberInDeflect( int move );
+qboolean PM_SaberInBrokenParry( int move );
+qboolean PM_SaberInBounce( int move );
+qboolean BG_SaberInReturn( int move );
+qboolean BG_InKnockDownOnGround( playerState_t *ps );
+qboolean BG_StabDownAnim( int anim );
+qboolean BG_SabersOff( playerState_t *ps );
+#include "../namespace_end.h"
+
+void WP_SaberAddG2Model( gentity_t *saberent, const char *saberModel, qhandle_t saberSkin );
+void WP_SaberRemoveG2Model( gentity_t *saberent );
+
+float RandFloat(float min, float max) {
+	return ((rand() * (max - min)) / 32768.0F) + min;
+}
+
+#ifdef DEBUG_SABER_BOX
+void	G_DebugBoxLines(vec3_t mins, vec3_t maxs, int duration)
+{
+	vec3_t start;
+	vec3_t end;
+
+	float x = maxs[0] - mins[0];
+	float y = maxs[1] - mins[1];
+
+	// top of box
+	VectorCopy(maxs, start);
+	VectorCopy(maxs, end);
+	start[0] -= x;
+	G_TestLine(start, end, 0x00000ff, duration);
+	end[0] = start[0];
+	end[1] -= y;
+	G_TestLine(start, end, 0x00000ff, duration);
+	start[1] = end[1];
+	start[0] += x;
+	G_TestLine(start, end, 0x00000ff, duration);
+	G_TestLine(start, maxs, 0x00000ff, duration);
+	// bottom of box
+	VectorCopy(mins, start);
+	VectorCopy(mins, end);
+	start[0] += x;
+	G_TestLine(start, end, 0x00000ff, duration);
+	end[0] = start[0];
+	end[1] += y;
+	G_TestLine(start, end, 0x00000ff, duration);
+	start[1] = end[1];
+	start[0] -= x;
+	G_TestLine(start, end, 0x00000ff, duration);
+	G_TestLine(start, mins, 0x00000ff, duration);
+}
+#endif
+
+//general check for performing certain attacks against others
+qboolean G_CanBeEnemy(gentity_t *self, gentity_t *enemy)
+{
+	if (!self->inuse || !enemy->inuse || !self->client || !enemy->client)
+	{
+		return qfalse;
+	}
+
+	if (self->client->ps.duelInProgress && self->client->ps.duelIndex != enemy->s.number)
+	{ //dueling but not with this person
+		return qfalse;
+	}
+
+	if (enemy->client->ps.duelInProgress && enemy->client->ps.duelIndex != self->s.number)
+	{ //other guy dueling but not with me
+		return qfalse;
+	}
+
+	if (g_gametype.integer < GT_TEAM)
+	{ //ok, sure
+		return qtrue;
+	}
+
+	if (g_friendlyFire.integer)
+	{ //if ff on then can inflict damage normally on teammates
+		return qtrue;
+	}
+
+	if (OnSameTeam(self, enemy))
+	{ //ff not on, don't hurt teammates
+		return qfalse;
+	}
+
+	return qtrue;
+}
+
+//This function gets the attack power which is used to decide broken parries,
+//knockaways, and numerous other things. It is not directly related to the
+//actual amount of damage done, however. -rww
+static GAME_INLINE int G_SaberAttackPower(gentity_t *ent, qboolean attacking)
+{
+	int baseLevel;
+	assert(ent && ent->client);
+
+	baseLevel = ent->client->ps.fd.saberAnimLevel;
+
+	//Give "medium" strength for the two special stances.
+	if (baseLevel == SS_DUAL)
+	{
+		baseLevel = 2;
+	}
+	else if (baseLevel == SS_STAFF)
+	{
+		baseLevel = 2;
+	}
+
+	if (attacking)
+	{ //the attacker gets a boost to help penetrate defense.
+		//General boost up so the individual levels make a bigger difference.
+		baseLevel *= 2;
+
+		baseLevel++;
+
+		//Get the "speed" of the swing, roughly, and add more power
+		//to the attack based on it.
+		if (ent->client->lastSaberStorageTime >= (level.time-50) &&
+			ent->client->olderIsValid)
+		{
+			vec3_t vSub;
+			int swingDist;
+			int toleranceAmt;
+
+			//We want different "tolerance" levels for adding in the distance of the last swing
+			//to the base power level depending on which stance we are using. Otherwise fast
+			//would have more advantage than it should since the animations are all much faster.
+			switch (ent->client->ps.fd.saberAnimLevel)
+			{
+			case SS_STRONG:
+				toleranceAmt = 8;
+				break;
+			case SS_MEDIUM:
+				toleranceAmt = 16;
+				break;
+			case SS_FAST:
+				toleranceAmt = 24;
+				break;
+			default: //dual, staff, etc.
+				toleranceAmt = 16;
+				break;
+			}
+
+            VectorSubtract(ent->client->lastSaberBase_Always, ent->client->olderSaberBase, vSub);
+			swingDist = (int)VectorLength(vSub);
+
+			while (swingDist > 0)
+			{ //I would like to do something more clever. But I suppose this works, at least for now.
+				baseLevel++;
+				swingDist -= toleranceAmt;
+			}
+		}
+
+#ifndef FINAL_BUILD
+		if (g_saberDebugPrint.integer > 1)
+		{
+			Com_Printf("Client %i: ATT STR: %i\n", ent->s.number, baseLevel);
+		}
+#endif
+	}
+
+	if ((ent->client->ps.brokenLimbs & (1 << BROKENLIMB_RARM)) ||
+		(ent->client->ps.brokenLimbs & (1 << BROKENLIMB_LARM)))
+	{ //We're very weak when one of our arms is broken
+		baseLevel *= 0.3;
+	}
+
+	//Cap at reasonable values now.
+	if (baseLevel < 1)
+	{
+		baseLevel = 1;
+	}
+	else if (baseLevel > 16)
+	{
+		baseLevel = 16;
+	}
+
+	if (g_gametype.integer == GT_POWERDUEL &&
+		ent->client->sess.duelTeam == DUELTEAM_LONE)
+	{ //get more power then
+		return baseLevel*2;
+	}
+	else if (attacking && g_gametype.integer == GT_SIEGE)
+	{ //in siege, saber battles should be quicker and more biased toward the attacker
+		return baseLevel*3;
+	}
+	
+	return baseLevel;
+}
+
+void WP_DeactivateSaber( gentity_t *self, qboolean clearLength )
+{
+	if ( !self || !self->client )
+	{
+		return;
+	}
+	//keep my saber off!
+	if ( !self->client->ps.saberHolstered )
+	{
+		self->client->ps.saberHolstered = 2;
+		/*
+		if ( clearLength )
+		{
+			self->client->ps.SetSaberLength( 0 );
+		}
+		*/
+		//Doens't matter ATM
+		if (self->client->saber[0].soundOff)
+		{
+			G_Sound(self, CHAN_WEAPON, self->client->saber[0].soundOff);
+		}
+
+		if (self->client->saber[1].soundOff &&
+			self->client->saber[1].model[0])
+		{
+			G_Sound(self, CHAN_WEAPON, self->client->saber[1].soundOff);
+		}
+
+	}
+}
+
+void WP_ActivateSaber( gentity_t *self )
+{
+	if ( !self || !self->client )
+	{
+		return;
+	}
+
+	if (self->NPC &&
+		self->client->ps.forceHandExtend == HANDEXTEND_JEDITAUNT &&
+		(self->client->ps.forceHandExtendTime - level.time) > 200)
+	{ //if we're an NPC and in the middle of a taunt then stop it
+		self->client->ps.forceHandExtend = HANDEXTEND_NONE;
+		self->client->ps.forceHandExtendTime = 0;
+	}
+	else if (self->client->ps.fd.forceGripCripple)
+	{ //can't activate saber while being gripped
+		return;
+	}
+
+	if ( self->client->ps.saberHolstered )
+	{
+		self->client->ps.saberHolstered = 0;
+		if (self->client->saber[0].soundOn)
+		{
+			G_Sound(self, CHAN_WEAPON, self->client->saber[0].soundOn);
+		}
+
+		if (self->client->saber[1].soundOn)
+		{
+			G_Sound(self, CHAN_WEAPON, self->client->saber[1].soundOn);
+		}
+	}
+}
+
+#define PROPER_THROWN_VALUE 999 //Ah, well.. 
+
+void SaberUpdateSelf(gentity_t *ent)
+{
+	if (ent->r.ownerNum == ENTITYNUM_NONE)
+	{
+		ent->think = G_FreeEntity;
+		ent->nextthink = level.time;
+		return;
+	}
+
+	if (!g_entities[ent->r.ownerNum].inuse ||
+		!g_entities[ent->r.ownerNum].client/* ||
+		g_entities[ent->r.ownerNum].client->sess.sessionTeam == TEAM_SPECTATOR*/)
+	{
+		ent->think = G_FreeEntity;
+		ent->nextthink = level.time;
+		return;
+	}
+
+	if (g_entities[ent->r.ownerNum].client->ps.saberInFlight && g_entities[ent->r.ownerNum].health > 0)
+	{ //let The Master take care of us now (we'll get treated like a missile until we return)
+		ent->nextthink = level.time;
+		ent->genericValue5 = PROPER_THROWN_VALUE;
+		return;
+	}
+
+	ent->genericValue5 = 0;
+
+	if (g_entities[ent->r.ownerNum].client->ps.weapon != WP_SABER ||
+		(g_entities[ent->r.ownerNum].client->ps.pm_flags & PMF_FOLLOW) ||
+		//RWW ADDED 7-19-03 BEGIN
+		g_entities[ent->r.ownerNum].client->sess.sessionTeam == TEAM_SPECTATOR ||
+		g_entities[ent->r.ownerNum].client->tempSpectate >= level.time ||
+		//RWW ADDED 7-19-03 END
+		g_entities[ent->r.ownerNum].health < 1 ||
+		BG_SabersOff( &g_entities[ent->r.ownerNum].client->ps ) ||
+		(!g_entities[ent->r.ownerNum].client->ps.fd.forcePowerLevel[FP_SABER_OFFENSE] && g_entities[ent->r.ownerNum].s.eType != ET_NPC))
+	{ //owner is not using saber, spectating, dead, saber holstered, or has no attack level
+		ent->r.contents = 0;
+		ent->clipmask = 0;
+	}
+	else
+	{ //Standard contents (saber is active)
+#ifdef DEBUG_SABER_BOX
+		if (g_saberDebugBox.integer == 1|| g_saberDebugBox.integer == 4)
+		{
+			vec3_t dbgMins;
+			vec3_t dbgMaxs;
+
+			VectorAdd( ent->r.currentOrigin, ent->r.mins, dbgMins );
+			VectorAdd( ent->r.currentOrigin, ent->r.maxs, dbgMaxs );
+
+			G_DebugBoxLines(dbgMins, dbgMaxs, (10.0f/(float)g_svfps.integer)*100);
+		}
+#endif
+		if (ent->r.contents != CONTENTS_LIGHTSABER)
+		{
+			if ((level.time - g_entities[ent->r.ownerNum].client->lastSaberStorageTime) <= 200)
+			{ //Only go back to solid once we're sure our owner has updated recently
+				ent->r.contents = CONTENTS_LIGHTSABER;
+				ent->clipmask = MASK_PLAYERSOLID | CONTENTS_LIGHTSABER;
+			}
+		}
+		else
+		{
+			ent->r.contents = CONTENTS_LIGHTSABER;
+			ent->clipmask = MASK_PLAYERSOLID | CONTENTS_LIGHTSABER;
+		}
+	}
+
+	trap_LinkEntity(ent);
+
+	ent->nextthink = level.time;
+}
+
+void SaberGotHit( gentity_t *self, gentity_t *other, trace_t *trace )
+{
+	gentity_t *own = &g_entities[self->r.ownerNum];
+
+	if (!own || !own->client)
+	{
+		return;
+	}
+
+	//Do something here..? Was handling projectiles here, but instead they're now handled in their own functions.
+}
+
+#include "../namespace_begin.h"
+qboolean BG_SuperBreakLoseAnim( int anim );
+#include "../namespace_end.h"
+
+static GAME_INLINE void SetSaberBoxSize(gentity_t *saberent)
+{
+	gentity_t *owner = NULL;
+	vec3_t saberOrg, saberTip;
+	int i;
+	int j = 0;
+	int k = 0;
+
+	assert(saberent && saberent->inuse);
+
+	if (saberent->r.ownerNum < MAX_CLIENTS && saberent->r.ownerNum >= 0)
+	{
+		owner = &g_entities[saberent->r.ownerNum];
+	}
+	else if (saberent->r.ownerNum >= 0 && saberent->r.ownerNum < ENTITYNUM_WORLD &&
+		g_entities[saberent->r.ownerNum].s.eType == ET_NPC)
+	{
+		owner = &g_entities[saberent->r.ownerNum];
+	}
+
+	if (!owner || !owner->inuse || !owner->client)
+	{
+		assert(!"Saber with no owner?");
+		return;
+	}
+
+	if ( PM_SaberInBrokenParry(owner->client->ps.saberMove)
+		|| BG_SuperBreakLoseAnim( owner->client->ps.torsoAnim ) )
+	{ //let swings go right through when we're in this state
+		VectorSet( saberent->r.mins, 0, 0, 0 );
+		VectorSet( saberent->r.maxs, 0, 0, 0 );
+#ifndef FINAL_BUILD
+		if (g_saberDebugPrint.integer > 1)
+		{
+			Com_Printf("Client %i in broken parry, saber box 0\n", owner->s.number);
+		}
+#endif
+		return;
+	}
+
+	if ((level.time - owner->client->lastSaberStorageTime) > 200 ||
+		(level.time - owner->client->saber[j].blade[k].storageTime) > 100)
+	{ //it's been too long since we got a reliable point storage, so use the defaults and leave.
+		VectorSet( saberent->r.mins, -SABER_BOX_SIZE, -SABER_BOX_SIZE, -SABER_BOX_SIZE );
+		VectorSet( saberent->r.maxs, SABER_BOX_SIZE, SABER_BOX_SIZE, SABER_BOX_SIZE );
+		return;
+	}
+
+	//Start out at the saber origin, then go through all the blades and push out the extents
+	//for each blade, then set the box relative to the origin.
+	VectorCopy(saberent->r.currentOrigin, saberent->r.mins);
+	VectorCopy(saberent->r.currentOrigin, saberent->r.maxs);
+
+	for (i = 0; i < 3; i++)
+	{
+		for (j = 0; j < MAX_SABERS; j++)
+		{
+			if (!owner->client->saber[j].model[0])
+			{
+				break;
+			}
+
+			for (k = 0; k < owner->client->saber[j].numBlades; k++)
+			{
+				//VectorMA(owner->client->saber[j].blade[k].muzzlePoint, owner->client->saber[j].blade[k].lengthMax*0.5f, owner->client->saber[j].blade[k].muzzleDir, saberOrg);
+				VectorCopy(owner->client->saber[j].blade[k].muzzlePoint, saberOrg);
+				VectorMA(owner->client->saber[j].blade[k].muzzlePoint, owner->client->saber[j].blade[k].lengthMax, owner->client->saber[j].blade[k].muzzleDir, saberTip);
+
+				if (saberOrg[i] < saberent->r.mins[i])
+				{
+					saberent->r.mins[i] = saberOrg[i];
+				}
+				if (saberTip[i] < saberent->r.mins[i])
+				{
+					saberent->r.mins[i] = saberTip[i];
+				}
+
+				if (saberOrg[i] > saberent->r.maxs[i])
+				{
+					saberent->r.maxs[i] = saberOrg[i];
+				}
+				if (saberTip[i] > saberent->r.maxs[i])
+				{
+					saberent->r.maxs[i] = saberTip[i];
+				}
+
+				//G_TestLine(saberOrg, saberTip, 0x0000ff, 50);
+			}
+		}
+	}
+
+	VectorSubtract(saberent->r.mins, saberent->r.currentOrigin, saberent->r.mins);
+	VectorSubtract(saberent->r.maxs, saberent->r.currentOrigin, saberent->r.maxs);
+}
+
+void WP_SaberInitBladeData( gentity_t *ent )
+{
+	gentity_t *saberent = NULL;
+	gentity_t *checkEnt;
+	int i = 0;
+
+	while (i < level.num_entities)
+	{ //make sure there are no other saber entities floating around that think they belong to this client.
+		checkEnt = &g_entities[i];
+
+		if (checkEnt->inuse && checkEnt->neverFree &&
+			checkEnt->r.ownerNum == ent->s.number &&
+			checkEnt->classname && checkEnt->classname[0] &&
+			!Q_stricmp(checkEnt->classname, "lightsaber"))
+		{
+			if (saberent)
+			{ //already have one
+				checkEnt->neverFree = qfalse;
+				checkEnt->think = G_FreeEntity;
+				checkEnt->nextthink = level.time;
+			}
+			else
+			{ //hmm.. well then, take it as my own.
+				//free the bitch but don't issue a kg2 to avoid overflowing clients.
+				checkEnt->s.modelGhoul2 = 0;
+				G_FreeEntity(checkEnt);
+
+				//now init it manually and reuse this ent slot.
+				G_InitGentity(checkEnt);
+				saberent = checkEnt;
+			}
+		}
+
+		i++;
+	}
+
+	//We do not want the client to have any real knowledge of the entity whatsoever. It will only
+	//ever be used on the server.
+	if (!saberent)
+	{ //ok, make one then
+		saberent = G_Spawn();
+	}
+	ent->client->ps.saberEntityNum = ent->client->saberStoredIndex = saberent->s.number;
+	saberent->classname = "lightsaber";
+	
+	saberent->neverFree = qtrue; //the saber being removed would be a terrible thing.
+
+	saberent->r.svFlags = SVF_USE_CURRENT_ORIGIN;
+	saberent->r.ownerNum = ent->s.number;
+
+	saberent->clipmask = MASK_PLAYERSOLID | CONTENTS_LIGHTSABER;
+	saberent->r.contents = CONTENTS_LIGHTSABER;
+
+	SetSaberBoxSize(saberent);
+
+	saberent->mass = 10;
+
+	saberent->s.eFlags |= EF_NODRAW;
+	saberent->r.svFlags |= SVF_NOCLIENT;
+
+	saberent->s.modelGhoul2 = 1;
+	//should we happen to be removed (we belong to an NPC and he is removed) then
+	//we want to attempt to remove our g2 instance on the client in case we had one.
+
+	saberent->touch = SaberGotHit;
+
+	saberent->think = SaberUpdateSelf;
+	saberent->genericValue5 = 0;
+	saberent->nextthink = level.time + 50;
+
+	saberSpinSound = G_SoundIndex("sound/weapons/saber/saberspin.wav");
+}
+
+#define LOOK_DEFAULT_SPEED	0.15f
+#define LOOK_TALKING_SPEED	0.15f	
+
+static GAME_INLINE qboolean G_CheckLookTarget( gentity_t *ent, vec3_t	lookAngles, float *lookingSpeed )
+{
+	//FIXME: also clamp the lookAngles based on the clamp + the existing difference between
+	//		headAngles and torsoAngles?  But often the tag_torso is straight but the torso itself
+	//		is deformed to not face straight... sigh...
+
+	if (ent->s.eType == ET_NPC &&
+		ent->s.m_iVehicleNum &&
+		ent->s.NPC_class != CLASS_VEHICLE )
+	{ //an NPC bolted to a vehicle should just look around randomly
+		if ( TIMER_Done( ent, "lookAround" ) )
+		{
+			ent->NPC->shootAngles[YAW] = flrand(0,360);
+			TIMER_Set( ent, "lookAround", Q_irand( 500, 3000 ) );
+		}
+		VectorSet( lookAngles, 0, ent->NPC->shootAngles[YAW], 0 );
+		return qtrue;
+	}
+	//Now calc head angle to lookTarget, if any
+	if ( ent->client->renderInfo.lookTarget >= 0 && ent->client->renderInfo.lookTarget < ENTITYNUM_WORLD )
+	{
+		vec3_t	lookDir, lookOrg, eyeOrg;
+		int i;
+
+		if ( ent->client->renderInfo.lookMode == LM_ENT )
+		{
+			gentity_t	*lookCent = &g_entities[ent->client->renderInfo.lookTarget];
+			if ( lookCent )
+			{
+				if ( lookCent != ent->enemy )
+				{//We turn heads faster than headbob speed, but not as fast as if watching an enemy
+					*lookingSpeed = LOOK_DEFAULT_SPEED;
+				}
+
+				//FIXME: Ignore small deltas from current angles so we don't bob our head in synch with theirs?
+
+				/*
+				if ( ent->client->renderInfo.lookTarget == 0 && !cg.renderingThirdPerson )//!cg_thirdPerson.integer )
+				{//Special case- use cg.refdef.vieworg if looking at player and not in third person view
+					VectorCopy( cg.refdef.vieworg, lookOrg );
+				}
+				*/ //No no no!
+				if ( lookCent->client )
+				{
+					VectorCopy( lookCent->client->renderInfo.eyePoint, lookOrg );
+				}
+				else if ( lookCent->inuse && !VectorCompare( lookCent->r.currentOrigin, vec3_origin ) )
+				{
+					VectorCopy( lookCent->r.currentOrigin, lookOrg );
+				}
+				else
+				{//at origin of world
+					return qfalse;
+				}
+				//Look in dir of lookTarget
+			}
+		}
+		else if ( ent->client->renderInfo.lookMode == LM_INTEREST && ent->client->renderInfo.lookTarget > -1 && ent->client->renderInfo.lookTarget < MAX_INTEREST_POINTS )
+		{
+			VectorCopy( level.interestPoints[ent->client->renderInfo.lookTarget].origin, lookOrg );
+		}
+		else
+		{
+			return qfalse;
+		}
+
+		VectorCopy( ent->client->renderInfo.eyePoint, eyeOrg );
+
+		VectorSubtract( lookOrg, eyeOrg, lookDir );
+
+		vectoangles( lookDir, lookAngles );
+
+		for ( i = 0; i < 3; i++ )
+		{
+			lookAngles[i] = AngleNormalize180( lookAngles[i] );
+			ent->client->renderInfo.eyeAngles[i] = AngleNormalize180( ent->client->renderInfo.eyeAngles[i] );
+		}
+		AnglesSubtract( lookAngles, ent->client->renderInfo.eyeAngles, lookAngles );
+		return qtrue;
+	}
+
+	return qfalse;
+}
+
+//rww - attempted "port" of the SP version which is completely client-side and
+//uses illegal gentity access. I am trying to keep this from being too
+//bandwidth-intensive.
+//This is primarily droid stuff I guess, I'm going to try to handle all humanoid
+//NPC stuff in with the actual player stuff if possible.
+void NPC_SetBoneAngles(gentity_t *ent, char *bone, vec3_t angles);
+static GAME_INLINE void G_G2NPCAngles(gentity_t *ent, vec3_t legs[3], vec3_t angles)
+{
+	char *craniumBone = "cranium";
+	char *thoracicBone = "thoracic"; //only used by atst so doesn't need a case
+	qboolean looking = qfalse;
+	vec3_t viewAngles;
+	vec3_t lookAngles;
+
+	if ( ent->client )
+	{
+		if ( (ent->client->NPC_class == CLASS_PROBE ) 
+			|| (ent->client->NPC_class == CLASS_R2D2 ) 
+			|| (ent->client->NPC_class == CLASS_R5D2) 
+			|| (ent->client->NPC_class == CLASS_ATST) )
+		{
+			vec3_t	trailingLegsAngles;
+
+			if (ent->s.eType == ET_NPC &&
+				ent->s.m_iVehicleNum &&
+				ent->s.NPC_class != CLASS_VEHICLE )
+			{ //an NPC bolted to a vehicle should use the full angles
+				VectorCopy(ent->r.currentAngles, angles);
+			}
+			else
+			{
+				VectorCopy( ent->client->ps.viewangles, angles );
+				angles[PITCH] = 0;
+			}
+
+			//FIXME: use actual swing/clamp tolerances?
+			/*
+			if ( ent->client->ps.groundEntityNum != ENTITYNUM_NONE )
+			{//on the ground
+				CG_PlayerLegsYawFromMovement( cent, ent->client->ps.velocity, &angles[YAW], cent->lerpAngles[YAW], -60, 60, qtrue );
+			}
+			else
+			{//face legs to front
+				CG_PlayerLegsYawFromMovement( cent, vec3_origin, &angles[YAW], cent->lerpAngles[YAW], -60, 60, qtrue );
+			}
+			*/
+
+			VectorCopy( ent->client->ps.viewangles, viewAngles );
+	//			viewAngles[YAW] = viewAngles[ROLL] = 0;
+			viewAngles[PITCH] *= 0.5;
+			VectorCopy( viewAngles, lookAngles );
+
+			lookAngles[1] = 0;
+
+			if ( ent->client->NPC_class == CLASS_ATST )
+			{//body pitch
+				NPC_SetBoneAngles(ent, thoracicBone, lookAngles);
+				//BG_G2SetBoneAngles( cent, ent, ent->thoracicBone, lookAngles, BONE_ANGLES_POSTMULT,POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, cgs.model_draw);
+			}
+
+			VectorCopy( viewAngles, lookAngles );
+
+			if ( ent && ent->client && ent->client->NPC_class == CLASS_ATST )
+			{
+				//CG_ATSTLegsYaw( cent, trailingLegsAngles );
+				AnglesToAxis( trailingLegsAngles, legs );
+			}
+			else
+			{
+				//FIXME: this needs to properly set the legs.yawing field so we don't erroneously play the turning anim, but we do play it when turning in place
+				/*
+				if ( angles[YAW] == cent->pe.legs.yawAngle )
+				{
+					cent->pe.legs.yawing = qfalse;
+				}
+				else
+				{
+					cent->pe.legs.yawing = qtrue;
+				}
+
+				cent->pe.legs.yawAngle = angles[YAW];
+				if ( ent->client )
+				{
+					ent->client->renderInfo.legsYaw = angles[YAW];
+				}
+				AnglesToAxis( angles, legs );
+				*/
+			}
+
+	//			if ( ent && ent->client && ent->client->NPC_class == CLASS_ATST )
+	//			{
+	//				looking = qfalse;
+	//			}
+	//			else
+			{	//look at lookTarget!
+				//FIXME: snaps to side when lets go of lookTarget... ?
+				float	lookingSpeed = 0.3f;
+				looking = G_CheckLookTarget( ent, lookAngles, &lookingSpeed );
+				lookAngles[PITCH] = lookAngles[ROLL] = 0;//droids can't pitch or roll their heads
+				if ( looking )
+				{//want to keep doing this lerp behavior for a full second after stopped looking (so don't snap)
+					ent->client->renderInfo.lookingDebounceTime = level.time + 1000;
+				}
+			}
+			if ( ent->client->renderInfo.lookingDebounceTime > level.time )
+			{	//adjust for current body orientation
+				vec3_t	oldLookAngles;
+
+				lookAngles[YAW] -= 0;//ent->client->ps.viewangles[YAW];//cent->pe.torso.yawAngle;
+				//lookAngles[YAW] -= cent->pe.legs.yawAngle;
+
+				//normalize
+				lookAngles[YAW] = AngleNormalize180( lookAngles[YAW] );
+
+				//slowly lerp to this new value
+				//Remember last headAngles
+				VectorCopy( ent->client->renderInfo.lastHeadAngles, oldLookAngles );
+				if( VectorCompare( oldLookAngles, lookAngles ) == qfalse )
+				{
+					//FIXME: This clamp goes off viewAngles,
+					//but really should go off the tag_torso's axis[0] angles, no?
+					lookAngles[YAW] = oldLookAngles[YAW]+(lookAngles[YAW]-oldLookAngles[YAW])*0.4f;
+				}
+				//Remember current lookAngles next time
+				VectorCopy( lookAngles, ent->client->renderInfo.lastHeadAngles );
+			}
+			else
+			{//Remember current lookAngles next time
+				VectorCopy( lookAngles, ent->client->renderInfo.lastHeadAngles );
+			}
+			if ( ent->client->NPC_class == CLASS_ATST )
+			{
+				VectorCopy( ent->client->ps.viewangles, lookAngles );
+				lookAngles[0] = lookAngles[2] = 0;
+				lookAngles[YAW] -= trailingLegsAngles[YAW];
+			}
+			else
+			{
+				lookAngles[PITCH] = lookAngles[ROLL] = 0;
+				lookAngles[YAW] -= ent->client->ps.viewangles[YAW];
+			}
+
+			NPC_SetBoneAngles(ent, craniumBone, lookAngles);
+			//BG_G2SetBoneAngles( cent, ent, ent->craniumBone, lookAngles, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, cgs.model_draw); 
+			//return;
+		}
+		else//if ( (ent->client->NPC_class == CLASS_GONK ) || (ent->client->NPC_class == CLASS_INTERROGATOR) || (ent->client->NPC_class == CLASS_SENTRY) )
+		{
+		//	VectorCopy( ent->client->ps.viewangles, angles );
+		//	AnglesToAxis( angles, legs );
+			//return;
+		}
+	}
+}
+
+static GAME_INLINE void G_G2PlayerAngles( gentity_t *ent, vec3_t legs[3], vec3_t legsAngles)
+{
+	qboolean tPitching = qfalse,
+			 tYawing = qfalse,
+			 lYawing = qfalse;
+	float tYawAngle = ent->client->ps.viewangles[YAW],
+		  tPitchAngle = 0,
+		  lYawAngle = ent->client->ps.viewangles[YAW];
+
+	int ciLegs = ent->client->ps.legsAnim;
+	int ciTorso = ent->client->ps.torsoAnim;
+
+	vec3_t turAngles;
+	vec3_t lerpOrg, lerpAng;
+
+	if (ent->s.eType == ET_NPC && ent->client)
+	{ //sort of hacky, but it saves a pretty big load off the server
+		int i = 0;
+		gentity_t *clEnt;
+
+		//If no real clients are in the same PVS then don't do any of this stuff, no one can see him anyway!
+		while (i < MAX_CLIENTS)
+		{
+			clEnt = &g_entities[i];
+
+			if (clEnt && clEnt->inuse && clEnt->client &&
+				trap_InPVS(clEnt->client->ps.origin, ent->client->ps.origin))
+			{ //this client can see him
+				break;
+			}
+
+			i++;
+		}
+
+		if (i == MAX_CLIENTS)
+		{ //no one can see him, just return
+			return;
+		}
+	}
+
+	VectorCopy(ent->client->ps.origin, lerpOrg);
+	VectorCopy(ent->client->ps.viewangles, lerpAng);
+
+	if (ent->localAnimIndex <= 1)
+	{ //don't do these things on non-humanoids
+		vec3_t lookAngles;
+		entityState_t *emplaced = NULL;
+
+		if (ent->client->ps.hasLookTarget)
+		{
+			VectorSubtract(g_entities[ent->client->ps.lookTarget].r.currentOrigin, ent->client->ps.origin, lookAngles);
+			vectoangles(lookAngles, lookAngles);
+			ent->client->lookTime = level.time + 1000;
+		}
+		else
+		{
+			VectorCopy(ent->client->ps.origin, lookAngles);
+		}
+		lookAngles[PITCH] = 0;
+
+		if (ent->client->ps.emplacedIndex)
+		{
+			emplaced = &g_entities[ent->client->ps.emplacedIndex].s;
+		}
+
+		BG_G2PlayerAngles(ent->ghoul2, ent->client->renderInfo.motionBolt, &ent->s, level.time, lerpOrg, lerpAng, legs,
+			legsAngles, &tYawing, &tPitching, &lYawing, &tYawAngle, &tPitchAngle, &lYawAngle, FRAMETIME, turAngles,
+			ent->modelScale, ciLegs, ciTorso, &ent->client->corrTime, lookAngles, ent->client->lastHeadAngles,
+			ent->client->lookTime, emplaced, NULL);
+
+		if (ent->client->ps.heldByClient && ent->client->ps.heldByClient <= MAX_CLIENTS)
+		{ //then put our arm in this client's hand
+			//is index+1 because index 0 is valid.
+			int heldByIndex = ent->client->ps.heldByClient-1;
+			gentity_t *other = &g_entities[heldByIndex];
+			int lHandBolt = 0;
+
+			if (other && other->inuse && other->client && other->ghoul2)
+			{
+				lHandBolt = trap_G2API_AddBolt(other->ghoul2, 0, "*l_hand");
+			}
+			else
+			{ //they left the game, perhaps?
+				ent->client->ps.heldByClient = 0;
+				return;
+			}
+
+			if (lHandBolt)
+			{
+				mdxaBone_t boltMatrix;
+				vec3_t boltOrg;
+				vec3_t tAngles;
+
+				VectorCopy(other->client->ps.viewangles, tAngles);
+				tAngles[PITCH] = tAngles[ROLL] = 0;
+
+				trap_G2API_GetBoltMatrix(other->ghoul2, 0, lHandBolt, &boltMatrix, tAngles, other->client->ps.origin, level.time, 0, other->modelScale);
+				boltOrg[0] = boltMatrix.matrix[0][3];
+				boltOrg[1] = boltMatrix.matrix[1][3];
+				boltOrg[2] = boltMatrix.matrix[2][3];
+
+				BG_IK_MoveArm(ent->ghoul2, lHandBolt, level.time, &ent->s, ent->client->ps.torsoAnim/*BOTH_DEAD1*/, boltOrg, &ent->client->ikStatus,
+					ent->client->ps.origin, ent->client->ps.viewangles, ent->modelScale, 500, qfalse);
+			}
+		}
+		else if (ent->client->ikStatus)
+		{ //make sure we aren't IKing if we don't have anyone to hold onto us.
+			int lHandBolt = 0;
+
+			if (ent && ent->inuse && ent->client && ent->ghoul2)
+			{
+				lHandBolt = trap_G2API_AddBolt(ent->ghoul2, 0, "*l_hand");
+			}
+			else
+			{ //This shouldn't happen, but just in case it does, we'll have a failsafe.
+				ent->client->ikStatus = qfalse;
+			}
+
+			if (lHandBolt)
+			{
+				BG_IK_MoveArm(ent->ghoul2, lHandBolt, level.time, &ent->s,
+					ent->client->ps.torsoAnim/*BOTH_DEAD1*/, vec3_origin, &ent->client->ikStatus, ent->client->ps.origin, ent->client->ps.viewangles, ent->modelScale, 500, qtrue);
+			}
+		}
+	}
+	else if ( ent->m_pVehicle && ent->m_pVehicle->m_pVehicleInfo->type == VH_WALKER )
+	{
+		vec3_t lookAngles;
+
+		VectorCopy(ent->client->ps.viewangles, legsAngles);
+		legsAngles[PITCH] = 0;
+		AnglesToAxis( legsAngles, legs );
+
+		VectorCopy(ent->client->ps.viewangles, lookAngles);
+		lookAngles[YAW] = lookAngles[ROLL] = 0;
+
+		BG_G2ATSTAngles( ent->ghoul2, level.time, lookAngles );
+	}
+	else if (ent->NPC)
+	{ //an NPC not using a humanoid skeleton, do special angle stuff.
+		if (ent->s.eType == ET_NPC &&
+			ent->s.NPC_class == CLASS_VEHICLE &&
+			ent->m_pVehicle &&
+			ent->m_pVehicle->m_pVehicleInfo->type == VH_FIGHTER)
+		{ //fighters actually want to take pitch and roll into account for the axial angles
+			VectorCopy(ent->client->ps.viewangles, legsAngles);
+			AnglesToAxis( legsAngles, legs );
+		}
+		else
+		{
+			G_G2NPCAngles(ent, legs, legsAngles);
+		}
+	}
+}
+
+static GAME_INLINE qboolean SaberAttacking(gentity_t *self)
+{
+	if (PM_SaberInParry(self->client->ps.saberMove))
+	{
+		return qfalse;
+	}
+	if (PM_SaberInBrokenParry(self->client->ps.saberMove))
+	{
+		return qfalse;
+	}
+	if (PM_SaberInDeflect(self->client->ps.saberMove))
+	{
+		return qfalse;
+	}
+	if (PM_SaberInBounce(self->client->ps.saberMove))
+	{
+		return qfalse;
+	}
+	if (PM_SaberInKnockaway(self->client->ps.saberMove))
+	{
+		return qfalse;
+	}
+
+	if (BG_SaberInAttack(self->client->ps.saberMove))
+	{
+		if (self->client->ps.weaponstate == WEAPON_FIRING && self->client->ps.saberBlocked == BLOCKED_NONE)
+		{ //if we're firing and not blocking, then we're attacking.
+			return qtrue;
+		}
+	}
+
+	if (BG_SaberInSpecial(self->client->ps.saberMove))
+	{
+		return qtrue;
+	}
+
+	return qfalse;
+}
+
+typedef enum
+{
+	LOCK_FIRST = 0,
+	LOCK_TOP = LOCK_FIRST,
+	LOCK_DIAG_TR,
+	LOCK_DIAG_TL,
+	LOCK_DIAG_BR,
+	LOCK_DIAG_BL,
+	LOCK_R,
+	LOCK_L,
+	LOCK_RANDOM
+} sabersLockMode_t;
+
+#define LOCK_IDEAL_DIST_TOP 32.0f
+#define LOCK_IDEAL_DIST_CIRCLE 48.0f
+
+#define SABER_HITDAMAGE 35
+void WP_SaberBlockNonRandom( gentity_t *self, vec3_t hitloc, qboolean missileBlock );
+
+int G_SaberLockAnim( int attackerSaberStyle, int defenderSaberStyle, int topOrSide, int lockOrBreakOrSuperBreak, int winOrLose )
+{
+	int baseAnim = -1;
+	if ( lockOrBreakOrSuperBreak == SABERLOCK_LOCK )
+	{//special case: if we're using the same style and locking
+		if ( attackerSaberStyle == defenderSaberStyle 
+			|| (attackerSaberStyle>=SS_FAST&&attackerSaberStyle<=SS_TAVION&&defenderSaberStyle>=SS_FAST&&defenderSaberStyle<=SS_TAVION) )
+		{//using same style
+			if ( winOrLose == SABERLOCK_LOSE )
+			{//you want the defender's stance...
+				switch ( defenderSaberStyle )
+				{
+				case SS_DUAL:
+					if ( topOrSide == SABERLOCK_TOP )
+					{
+						baseAnim = BOTH_LK_DL_DL_T_L_2;
+					}
+					else
+					{
+						baseAnim = BOTH_LK_DL_DL_S_L_2;
+					}
+					break;
+				case SS_STAFF:
+					if ( topOrSide == SABERLOCK_TOP )
+					{
+						baseAnim = BOTH_LK_ST_ST_T_L_2;
+					}
+					else
+					{
+						baseAnim = BOTH_LK_ST_ST_S_L_2;
+					}
+					break;
+				default:
+					if ( topOrSide == SABERLOCK_TOP )
+					{
+						baseAnim = BOTH_LK_S_S_T_L_2;
+					}
+					else
+					{
+						baseAnim = BOTH_LK_S_S_S_L_2;
+					}
+					break;
+				}
+			}
+		}
+	}
+	if ( baseAnim == -1 )
+	{
+		switch ( attackerSaberStyle )
+		{
+		case SS_DUAL:
+			switch ( defenderSaberStyle )
+			{
+				case SS_DUAL:
+					baseAnim = BOTH_LK_DL_DL_S_B_1_L;
+					break;
+				case SS_STAFF:
+					baseAnim = BOTH_LK_DL_ST_S_B_1_L;
+					break;
+				default://single
+					baseAnim = BOTH_LK_DL_S_S_B_1_L;
+					break;
+			}
+			break;
+		case SS_STAFF:
+			switch ( defenderSaberStyle )
+			{
+				case SS_DUAL:
+					baseAnim = BOTH_LK_ST_DL_S_B_1_L;
+					break;
+				case SS_STAFF:
+					baseAnim = BOTH_LK_ST_ST_S_B_1_L;
+					break;
+				default://single
+					baseAnim = BOTH_LK_ST_S_S_B_1_L;
+					break;
+			}
+			break;
+		default://single
+			switch ( defenderSaberStyle )
+			{
+				case SS_DUAL:
+					baseAnim = BOTH_LK_S_DL_S_B_1_L;
+					break;
+				case SS_STAFF:
+					baseAnim = BOTH_LK_S_ST_S_B_1_L;
+					break;
+				default://single
+					baseAnim = BOTH_LK_S_S_S_B_1_L;
+					break;
+			}
+			break;
+		}
+		//side lock or top lock?
+		if ( topOrSide == SABERLOCK_TOP )
+		{
+			baseAnim += 5;
+		}
+		//lock, break or superbreak?
+		if ( lockOrBreakOrSuperBreak == SABERLOCK_LOCK )
+		{
+			baseAnim += 2;
+		}
+		else 
+		{//a break or superbreak
+			if ( lockOrBreakOrSuperBreak == SABERLOCK_SUPERBREAK )
+			{
+				baseAnim += 3;
+			}
+			//winner or loser?
+			if ( winOrLose == SABERLOCK_WIN )
+			{
+				baseAnim += 1;
+			}
+		}
+	}
+	return baseAnim;
+}
+
+#include "../namespace_begin.h"
+extern qboolean BG_CheckIncrementLockAnim( int anim, int winOrLose ); //bg_saber.c
+#include "../namespace_end.h"
+#define LOCK_IDEAL_DIST_JKA 46.0f//all of the new saberlocks are 46.08 from each other because Richard Lico is da MAN
+
+static GAME_INLINE qboolean WP_SabersCheckLock2( gentity_t *attacker, gentity_t *defender, sabersLockMode_t lockMode )
+{
+	int		attAnim, defAnim = 0;
+	float	attStart = 0.5f, defStart = 0.5f;
+	float	idealDist = 48.0f;
+	vec3_t	attAngles, defAngles, defDir;
+	vec3_t	newOrg;
+	vec3_t	attDir;
+	float	diff = 0;
+	trace_t trace;
+
+	//MATCH ANIMS
+	if ( lockMode == LOCK_RANDOM )
+	{
+		lockMode = (sabersLockMode_t)Q_irand( (int)LOCK_FIRST, (int)(LOCK_RANDOM)-1 );
+	}
+	if ( attacker->client->ps.fd.saberAnimLevel >= SS_FAST
+		&& attacker->client->ps.fd.saberAnimLevel <= SS_TAVION
+		&& defender->client->ps.fd.saberAnimLevel >= SS_FAST
+		&& defender->client->ps.fd.saberAnimLevel <= SS_TAVION )
+	{//2 single sabers?  Just do it the old way...
+		switch ( lockMode )
+		{
+		case LOCK_TOP:
+			attAnim = BOTH_BF2LOCK;
+			defAnim = BOTH_BF1LOCK;
+			attStart = defStart = 0.5f;
+			idealDist = LOCK_IDEAL_DIST_TOP;
+			break;
+		case LOCK_DIAG_TR:
+			attAnim = BOTH_CCWCIRCLELOCK;
+			defAnim = BOTH_CWCIRCLELOCK;
+			attStart = defStart = 0.5f;
+			idealDist = LOCK_IDEAL_DIST_CIRCLE;
+			break;
+		case LOCK_DIAG_TL:
+			attAnim = BOTH_CWCIRCLELOCK;
+			defAnim = BOTH_CCWCIRCLELOCK;
+			attStart = defStart = 0.5f;
+			idealDist = LOCK_IDEAL_DIST_CIRCLE;
+			break;
+		case LOCK_DIAG_BR:
+			attAnim = BOTH_CWCIRCLELOCK;
+			defAnim = BOTH_CCWCIRCLELOCK;
+			attStart = defStart = 0.85f;
+			idealDist = LOCK_IDEAL_DIST_CIRCLE;
+			break;
+		case LOCK_DIAG_BL:
+			attAnim = BOTH_CCWCIRCLELOCK;
+			defAnim = BOTH_CWCIRCLELOCK;
+			attStart = defStart = 0.85f;
+			idealDist = LOCK_IDEAL_DIST_CIRCLE;
+			break;
+		case LOCK_R:
+			attAnim = BOTH_CCWCIRCLELOCK;
+			defAnim = BOTH_CWCIRCLELOCK;
+			attStart = defStart = 0.75f;
+			idealDist = LOCK_IDEAL_DIST_CIRCLE;
+			break;
+		case LOCK_L:
+			attAnim = BOTH_CWCIRCLELOCK;
+			defAnim = BOTH_CCWCIRCLELOCK;
+			attStart = defStart = 0.75f;
+			idealDist = LOCK_IDEAL_DIST_CIRCLE;
+			break;
+		default:
+			return qfalse;
+			break;
+		}
+	}
+	else
+	{//use the new system
+		idealDist = LOCK_IDEAL_DIST_JKA;//all of the new saberlocks are 46.08 from each other because Richard Lico is da MAN
+		if ( lockMode == LOCK_TOP )
+		{//top lock
+			attAnim = G_SaberLockAnim( attacker->client->ps.fd.saberAnimLevel, defender->client->ps.fd.saberAnimLevel, SABERLOCK_TOP, SABERLOCK_LOCK, SABERLOCK_WIN );
+			defAnim = G_SaberLockAnim( defender->client->ps.fd.saberAnimLevel, attacker->client->ps.fd.saberAnimLevel, SABERLOCK_TOP, SABERLOCK_LOCK, SABERLOCK_LOSE );
+			attStart = defStart = 0.5f;
+		}
+		else
+		{//side lock
+			switch ( lockMode )
+			{
+			case LOCK_DIAG_TR:
+				attAnim = G_SaberLockAnim( attacker->client->ps.fd.saberAnimLevel, defender->client->ps.fd.saberAnimLevel, SABERLOCK_SIDE, SABERLOCK_LOCK, SABERLOCK_WIN );
+				defAnim = G_SaberLockAnim( defender->client->ps.fd.saberAnimLevel, attacker->client->ps.fd.saberAnimLevel, SABERLOCK_SIDE, SABERLOCK_LOCK, SABERLOCK_LOSE );
+				attStart = defStart = 0.5f;
+				break;
+			case LOCK_DIAG_TL:
+				attAnim = G_SaberLockAnim( attacker->client->ps.fd.saberAnimLevel, defender->client->ps.fd.saberAnimLevel, SABERLOCK_SIDE, SABERLOCK_LOCK, SABERLOCK_LOSE );
+				defAnim = G_SaberLockAnim( defender->client->ps.fd.saberAnimLevel, attacker->client->ps.fd.saberAnimLevel, SABERLOCK_SIDE, SABERLOCK_LOCK, SABERLOCK_WIN );
+				attStart = defStart = 0.5f;
+				break;
+			case LOCK_DIAG_BR:
+				attAnim = G_SaberLockAnim( attacker->client->ps.fd.saberAnimLevel, defender->client->ps.fd.saberAnimLevel, SABERLOCK_SIDE, SABERLOCK_LOCK, SABERLOCK_WIN );
+				defAnim = G_SaberLockAnim( defender->client->ps.fd.saberAnimLevel, attacker->client->ps.fd.saberAnimLevel, SABERLOCK_SIDE, SABERLOCK_LOCK, SABERLOCK_LOSE );
+				if ( BG_CheckIncrementLockAnim( attAnim, SABERLOCK_WIN ) )
+				{
+					attStart = 0.85f;//move to end of anim
+				}
+				else
+				{
+					attStart = 0.15f;//start at beginning of anim
+				}
+				if ( BG_CheckIncrementLockAnim( defAnim, SABERLOCK_LOSE ) )
+				{
+					defStart = 0.85f;//start at end of anim
+				}
+				else
+				{
+					defStart = 0.15f;//start at beginning of anim
+				}
+				break;
+			case LOCK_DIAG_BL:
+				attAnim = G_SaberLockAnim( attacker->client->ps.fd.saberAnimLevel, defender->client->ps.fd.saberAnimLevel, SABERLOCK_SIDE, SABERLOCK_LOCK, SABERLOCK_LOSE );
+				defAnim = G_SaberLockAnim( defender->client->ps.fd.saberAnimLevel, attacker->client->ps.fd.saberAnimLevel, SABERLOCK_SIDE, SABERLOCK_LOCK, SABERLOCK_WIN );
+				if ( BG_CheckIncrementLockAnim( attAnim, SABERLOCK_WIN ) )
+				{
+					attStart = 0.85f;//move to end of anim
+				}
+				else
+				{
+					attStart = 0.15f;//start at beginning of anim
+				}
+				if ( BG_CheckIncrementLockAnim( defAnim, SABERLOCK_LOSE ) )
+				{
+					defStart = 0.85f;//start at end of anim
+				}
+				else
+				{
+					defStart = 0.15f;//start at beginning of anim
+				}
+				break;
+			case LOCK_R:
+				attAnim = G_SaberLockAnim( attacker->client->ps.fd.saberAnimLevel, defender->client->ps.fd.saberAnimLevel, SABERLOCK_SIDE, SABERLOCK_LOCK, SABERLOCK_LOSE );
+				defAnim = G_SaberLockAnim( defender->client->ps.fd.saberAnimLevel, attacker->client->ps.fd.saberAnimLevel, SABERLOCK_SIDE, SABERLOCK_LOCK, SABERLOCK_WIN );
+				if ( BG_CheckIncrementLockAnim( attAnim, SABERLOCK_WIN ) )
+				{
+					attStart = 0.75f;//move to end of anim
+				}
+				else
+				{
+					attStart = 0.25f;//start at beginning of anim
+				}
+				if ( BG_CheckIncrementLockAnim( defAnim, SABERLOCK_LOSE ) )
+				{
+					defStart = 0.75f;//start at end of anim
+				}
+				else
+				{
+					defStart = 0.25f;//start at beginning of anim
+				}
+				break;
+			case LOCK_L:
+				attAnim = G_SaberLockAnim( attacker->client->ps.fd.saberAnimLevel, defender->client->ps.fd.saberAnimLevel, SABERLOCK_SIDE, SABERLOCK_LOCK, SABERLOCK_WIN );
+				defAnim = G_SaberLockAnim( defender->client->ps.fd.saberAnimLevel, attacker->client->ps.fd.saberAnimLevel, SABERLOCK_SIDE, SABERLOCK_LOCK, SABERLOCK_LOSE );
+				//attacker starts with advantage
+				if ( BG_CheckIncrementLockAnim( attAnim, SABERLOCK_WIN ) )
+				{
+					attStart = 0.75f;//move to end of anim
+				}
+				else
+				{
+					attStart = 0.25f;//start at beginning of anim
+				}
+				if ( BG_CheckIncrementLockAnim( defAnim, SABERLOCK_LOSE ) )
+				{
+					defStart = 0.75f;//start at end of anim
+				}
+				else
+				{
+					defStart = 0.25f;//start at beginning of anim
+				}
+				break;
+			default:
+				return qfalse;
+				break;
+			}
+		}
+	}
+
+	G_SetAnim(attacker, NULL, SETANIM_BOTH, attAnim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD, 0);
+	attacker->client->ps.saberLockFrame = bgAllAnims[attacker->localAnimIndex].anims[attAnim].firstFrame+(bgAllAnims[attacker->localAnimIndex].anims[attAnim].numFrames*attStart);
+
+	G_SetAnim(defender, NULL, SETANIM_BOTH, defAnim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD, 0);
+	defender->client->ps.saberLockFrame = bgAllAnims[defender->localAnimIndex].anims[defAnim].firstFrame+(bgAllAnims[defender->localAnimIndex].anims[defAnim].numFrames*defStart);
+
+	attacker->client->ps.saberLockHits = 0;
+	defender->client->ps.saberLockHits = 0;
+
+	attacker->client->ps.saberLockAdvance = qfalse;
+	defender->client->ps.saberLockAdvance = qfalse;
+
+	VectorClear( attacker->client->ps.velocity );
+	VectorClear( defender->client->ps.velocity );
+	attacker->client->ps.saberLockTime = defender->client->ps.saberLockTime = level.time + 10000;
+	attacker->client->ps.saberLockEnemy = defender->s.number;
+	defender->client->ps.saberLockEnemy = attacker->s.number;
+	attacker->client->ps.weaponTime = defender->client->ps.weaponTime = Q_irand( 1000, 3000 );//delay 1 to 3 seconds before pushing
+
+	VectorSubtract( defender->r.currentOrigin, attacker->r.currentOrigin, defDir );
+	VectorCopy( attacker->client->ps.viewangles, attAngles );
+	attAngles[YAW] = vectoyaw( defDir );
+	SetClientViewAngle( attacker, attAngles );
+	defAngles[PITCH] = attAngles[PITCH]*-1;
+	defAngles[YAW] = AngleNormalize180( attAngles[YAW] + 180);
+	defAngles[ROLL] = 0;
+	SetClientViewAngle( defender, defAngles );
+	
+	//MATCH POSITIONS
+	diff = VectorNormalize( defDir ) - idealDist;//diff will be the total error in dist
+	//try to move attacker half the diff towards the defender
+	VectorMA( attacker->r.currentOrigin, diff*0.5f, defDir, newOrg );
+
+	trap_Trace( &trace, attacker->r.currentOrigin, attacker->r.mins, attacker->r.maxs, newOrg, attacker->s.number, attacker->clipmask );
+	if ( !trace.startsolid && !trace.allsolid )
+	{
+		G_SetOrigin( attacker, trace.endpos );
+		if (attacker->client)
+		{
+			VectorCopy(trace.endpos, attacker->client->ps.origin);
+		}
+		trap_LinkEntity( attacker );
+	}
+	//now get the defender's dist and do it for him too
+	VectorSubtract( attacker->r.currentOrigin, defender->r.currentOrigin, attDir );
+	diff = VectorNormalize( attDir ) - idealDist;//diff will be the total error in dist
+	//try to move defender all of the remaining diff towards the attacker
+	VectorMA( defender->r.currentOrigin, diff, attDir, newOrg );
+	trap_Trace( &trace, defender->r.currentOrigin, defender->r.mins, defender->r.maxs, newOrg, defender->s.number, defender->clipmask );
+	if ( !trace.startsolid && !trace.allsolid )
+	{
+		if (defender->client)
+		{
+			VectorCopy(trace.endpos, defender->client->ps.origin);
+		}
+		G_SetOrigin( defender, trace.endpos );
+		trap_LinkEntity( defender );
+	}
+
+	//DONE!
+	return qtrue;
+}
+
+qboolean WP_SabersCheckLock( gentity_t *ent1, gentity_t *ent2 )
+{
+	float dist;
+	qboolean	ent1BlockingPlayer = qfalse;
+	qboolean	ent2BlockingPlayer = qfalse;
+
+	if ( g_debugSaberLocks.integer )
+	{
+		WP_SabersCheckLock2( ent1, ent2, LOCK_RANDOM );
+		return qtrue;
+	}
+	//for now.. it's not fair to the lone duelist.
+	//we need dual saber lock animations.
+	if (g_gametype.integer == GT_POWERDUEL)
+	{
+		return qfalse;
+	}
+
+	if (!g_saberLocking.integer)
+	{
+		return qfalse;
+	}
+
+	if (!ent1->client || !ent2->client)
+	{
+		return qfalse;
+	}
+
+	if (ent1->s.eType == ET_NPC ||
+		ent2->s.eType == ET_NPC)
+	{ //if either ents is NPC, then never let an NPC lock with someone on the same playerTeam
+		if (ent1->client->playerTeam == ent2->client->playerTeam)
+		{
+			return qfalse;
+		}
+	}
+
+	if (!ent1->client->ps.saberEntityNum ||
+		!ent2->client->ps.saberEntityNum ||
+		ent1->client->ps.saberInFlight ||
+		ent2->client->ps.saberInFlight)
+	{ //can't get in lock if one of them has had the saber knocked out of his hand
+		return qfalse;
+	}
+
+	if (ent1->s.eType != ET_NPC && ent2->s.eType != ET_NPC)
+	{ //can always get into locks with NPCs
+		if (!ent1->client->ps.duelInProgress ||
+			!ent2->client->ps.duelInProgress ||
+			ent1->client->ps.duelIndex != ent2->s.number ||
+			ent2->client->ps.duelIndex != ent1->s.number)
+		{ //only allow saber locking if two players are dueling with each other directly
+			if (g_gametype.integer != GT_DUEL && g_gametype.integer != GT_POWERDUEL)
+			{
+				return qfalse;
+			}
+		}
+	}
+
+	if ( fabs( ent1->r.currentOrigin[2]-ent2->r.currentOrigin[2] ) > 16 )
+	{
+		return qfalse;
+	}
+	if ( ent1->client->ps.groundEntityNum == ENTITYNUM_NONE ||
+		ent2->client->ps.groundEntityNum == ENTITYNUM_NONE )
+	{
+		return qfalse;
+	}
+	dist = DistanceSquared(ent1->r.currentOrigin,ent2->r.currentOrigin);
+	if ( dist < 64 || dist > 6400 )
+	{//between 8 and 80 from each other
+		return qfalse;
+	}
+
+	if (BG_InSpecialJump(ent1->client->ps.legsAnim))
+	{
+		return qfalse;
+	}
+	if (BG_InSpecialJump(ent2->client->ps.legsAnim))
+	{
+		return qfalse;
+	}
+
+	if (BG_InRoll(&ent1->client->ps, ent1->client->ps.legsAnim))
+	{
+		return qfalse;
+	}
+	if (BG_InRoll(&ent2->client->ps, ent2->client->ps.legsAnim))
+	{
+		return qfalse;
+	}
+
+	if (ent1->client->ps.forceHandExtend != HANDEXTEND_NONE ||
+		ent2->client->ps.forceHandExtend != HANDEXTEND_NONE)
+	{
+		return qfalse;
+	}
+
+	if ((ent1->client->ps.pm_flags & PMF_DUCKED) ||
+		(ent2->client->ps.pm_flags & PMF_DUCKED))
+	{
+		return qfalse;
+	}
+
+	if ( !ent1->client->saber[0].lockable
+		|| !ent2->client->saber[0].lockable )
+	{
+		return qfalse;
+	}
+	if ( ent1->client->saber[1].model
+		&& ent1->client->saber[1].model[0]
+		&& !ent1->client->ps.saberHolstered
+		&& !ent1->client->saber[1].lockable )
+	{
+		return qfalse;
+	}
+	if ( ent2->client->saber[1].model
+		&& ent2->client->saber[1].model[0]
+		&& !ent2->client->ps.saberHolstered
+		&& !ent2->client->saber[1].lockable )
+	{
+		return qfalse;
+	}
+
+	if (!InFront( ent1->client->ps.origin, ent2->client->ps.origin, ent2->client->ps.viewangles, 0.4f ))
+	{
+		return qfalse;
+	}
+	if (!InFront( ent2->client->ps.origin, ent1->client->ps.origin, ent1->client->ps.viewangles, 0.4f ))
+	{
+		return qfalse;
+	}
+
+	//T to B lock
+	if ( ent1->client->ps.torsoAnim == BOTH_A1_T__B_ ||
+		ent1->client->ps.torsoAnim == BOTH_A2_T__B_ ||
+		ent1->client->ps.torsoAnim == BOTH_A3_T__B_ ||
+		ent1->client->ps.torsoAnim == BOTH_A4_T__B_ ||
+		ent1->client->ps.torsoAnim == BOTH_A5_T__B_ ||
+		ent1->client->ps.torsoAnim == BOTH_A6_T__B_ ||
+		ent1->client->ps.torsoAnim == BOTH_A7_T__B_)
+	{//ent1 is attacking top-down
+		return WP_SabersCheckLock2( ent1, ent2, LOCK_TOP );
+	}
+
+	if ( ent2->client->ps.torsoAnim == BOTH_A1_T__B_ ||
+		ent2->client->ps.torsoAnim == BOTH_A2_T__B_ ||
+		ent2->client->ps.torsoAnim == BOTH_A3_T__B_ ||
+		ent2->client->ps.torsoAnim == BOTH_A4_T__B_ ||
+		ent2->client->ps.torsoAnim == BOTH_A5_T__B_ ||
+		ent2->client->ps.torsoAnim == BOTH_A6_T__B_ ||
+		ent2->client->ps.torsoAnim == BOTH_A7_T__B_)
+	{//ent2 is attacking top-down
+		return WP_SabersCheckLock2( ent2, ent1, LOCK_TOP );
+	}
+
+	if ( ent1->s.number == 0 &&
+		ent1->client->ps.saberBlocking == BLK_WIDE && ent1->client->ps.weaponTime <= 0 )
+	{
+		ent1BlockingPlayer = qtrue;
+	}
+	if ( ent2->s.number == 0 &&
+		ent2->client->ps.saberBlocking == BLK_WIDE && ent2->client->ps.weaponTime <= 0 )
+	{
+		ent2BlockingPlayer = qtrue;
+	}
+
+	//TR to BL lock
+	if ( ent1->client->ps.torsoAnim == BOTH_A1_TR_BL ||
+		ent1->client->ps.torsoAnim == BOTH_A2_TR_BL ||
+		ent1->client->ps.torsoAnim == BOTH_A3_TR_BL ||
+		ent1->client->ps.torsoAnim == BOTH_A4_TR_BL ||
+		ent1->client->ps.torsoAnim == BOTH_A5_TR_BL ||
+		ent1->client->ps.torsoAnim == BOTH_A6_TR_BL ||
+		ent1->client->ps.torsoAnim == BOTH_A7_TR_BL)
+	{//ent1 is attacking diagonally
+		if ( ent2BlockingPlayer )
+		{//player will block this anyway
+			return WP_SabersCheckLock2( ent1, ent2, LOCK_DIAG_TR );
+		}
+		if ( ent2->client->ps.torsoAnim == BOTH_A1_TR_BL ||
+			ent2->client->ps.torsoAnim == BOTH_A2_TR_BL ||
+			ent2->client->ps.torsoAnim == BOTH_A3_TR_BL ||
+			ent2->client->ps.torsoAnim == BOTH_A4_TR_BL ||
+			ent2->client->ps.torsoAnim == BOTH_A5_TR_BL ||
+			ent2->client->ps.torsoAnim == BOTH_A6_TR_BL ||
+			ent2->client->ps.torsoAnim == BOTH_A7_TR_BL ||
+			ent2->client->ps.torsoAnim == BOTH_P1_S1_TL )
+		{//ent2 is attacking in the opposite diagonal
+			return WP_SabersCheckLock2( ent1, ent2, LOCK_DIAG_TR );
+		}
+		if ( ent2->client->ps.torsoAnim == BOTH_A1_BR_TL ||
+			ent2->client->ps.torsoAnim == BOTH_A2_BR_TL ||
+			ent2->client->ps.torsoAnim == BOTH_A3_BR_TL ||
+			ent2->client->ps.torsoAnim == BOTH_A4_BR_TL ||
+			ent2->client->ps.torsoAnim == BOTH_A5_BR_TL ||
+			ent2->client->ps.torsoAnim == BOTH_A6_BR_TL ||
+			ent2->client->ps.torsoAnim == BOTH_A7_BR_TL ||
+			ent2->client->ps.torsoAnim == BOTH_P1_S1_BL )
+		{//ent2 is attacking in the opposite diagonal
+			return WP_SabersCheckLock2( ent1, ent2, LOCK_DIAG_BL );
+		}
+		return qfalse;
+	}
+
+	if ( ent2->client->ps.torsoAnim == BOTH_A1_TR_BL ||
+		ent2->client->ps.torsoAnim == BOTH_A2_TR_BL ||
+		ent2->client->ps.torsoAnim == BOTH_A3_TR_BL ||
+		ent2->client->ps.torsoAnim == BOTH_A4_TR_BL ||
+		ent2->client->ps.torsoAnim == BOTH_A5_TR_BL ||
+		ent2->client->ps.torsoAnim == BOTH_A6_TR_BL ||
+		ent2->client->ps.torsoAnim == BOTH_A7_TR_BL)
+	{//ent2 is attacking diagonally
+		if ( ent1BlockingPlayer )
+		{//player will block this anyway
+			return WP_SabersCheckLock2( ent2, ent1, LOCK_DIAG_TR );
+		}
+		if ( ent1->client->ps.torsoAnim == BOTH_A1_TR_BL ||
+			ent1->client->ps.torsoAnim == BOTH_A2_TR_BL ||
+			ent1->client->ps.torsoAnim == BOTH_A3_TR_BL ||
+			ent1->client->ps.torsoAnim == BOTH_A4_TR_BL ||
+			ent1->client->ps.torsoAnim == BOTH_A5_TR_BL ||
+			ent1->client->ps.torsoAnim == BOTH_A6_TR_BL ||
+			ent1->client->ps.torsoAnim == BOTH_A7_TR_BL ||
+			ent1->client->ps.torsoAnim == BOTH_P1_S1_TL )
+		{//ent1 is attacking in the opposite diagonal
+			return WP_SabersCheckLock2( ent2, ent1, LOCK_DIAG_TR );
+		}
+		if ( ent1->client->ps.torsoAnim == BOTH_A1_BR_TL ||
+			ent1->client->ps.torsoAnim == BOTH_A2_BR_TL ||
+			ent1->client->ps.torsoAnim == BOTH_A3_BR_TL ||
+			ent1->client->ps.torsoAnim == BOTH_A4_BR_TL ||
+			ent1->client->ps.torsoAnim == BOTH_A5_BR_TL ||
+			ent1->client->ps.torsoAnim == BOTH_A6_BR_TL ||
+			ent1->client->ps.torsoAnim == BOTH_A7_BR_TL ||
+			ent1->client->ps.torsoAnim == BOTH_P1_S1_BL )
+		{//ent1 is attacking in the opposite diagonal
+			return WP_SabersCheckLock2( ent2, ent1, LOCK_DIAG_BL );
+		}
+		return qfalse;
+	}
+
+	//TL to BR lock
+	if ( ent1->client->ps.torsoAnim == BOTH_A1_TL_BR ||
+		ent1->client->ps.torsoAnim == BOTH_A2_TL_BR ||
+		ent1->client->ps.torsoAnim == BOTH_A3_TL_BR ||
+		ent1->client->ps.torsoAnim == BOTH_A4_TL_BR ||
+		ent1->client->ps.torsoAnim == BOTH_A5_TL_BR ||
+		ent1->client->ps.torsoAnim == BOTH_A6_TL_BR ||
+		ent1->client->ps.torsoAnim == BOTH_A7_TL_BR)
+	{//ent1 is attacking diagonally
+		if ( ent2BlockingPlayer )
+		{//player will block this anyway
+			return WP_SabersCheckLock2( ent1, ent2, LOCK_DIAG_TL );
+		}
+		if ( ent2->client->ps.torsoAnim == BOTH_A1_TL_BR ||
+			ent2->client->ps.torsoAnim == BOTH_A2_TL_BR ||
+			ent2->client->ps.torsoAnim == BOTH_A3_TL_BR ||
+			ent2->client->ps.torsoAnim == BOTH_A4_TL_BR ||
+			ent2->client->ps.torsoAnim == BOTH_A5_TL_BR ||
+			ent2->client->ps.torsoAnim == BOTH_A6_TL_BR ||
+			ent2->client->ps.torsoAnim == BOTH_A7_TL_BR ||
+			ent2->client->ps.torsoAnim == BOTH_P1_S1_TR )
+		{//ent2 is attacking in the opposite diagonal
+			return WP_SabersCheckLock2( ent1, ent2, LOCK_DIAG_TL );
+		}
+		if ( ent2->client->ps.torsoAnim == BOTH_A1_BL_TR ||
+			ent2->client->ps.torsoAnim == BOTH_A2_BL_TR ||
+			ent2->client->ps.torsoAnim == BOTH_A3_BL_TR ||
+			ent2->client->ps.torsoAnim == BOTH_A4_BL_TR ||
+			ent2->client->ps.torsoAnim == BOTH_A5_BL_TR ||
+			ent2->client->ps.torsoAnim == BOTH_A6_BL_TR ||
+			ent2->client->ps.torsoAnim == BOTH_A7_BL_TR ||
+			ent2->client->ps.torsoAnim == BOTH_P1_S1_BR )
+		{//ent2 is attacking in the opposite diagonal
+			return WP_SabersCheckLock2( ent1, ent2, LOCK_DIAG_BR );
+		}
+		return qfalse;
+	}
+
+	if ( ent2->client->ps.torsoAnim == BOTH_A1_TL_BR ||
+		ent2->client->ps.torsoAnim == BOTH_A2_TL_BR ||
+		ent2->client->ps.torsoAnim == BOTH_A3_TL_BR ||
+		ent2->client->ps.torsoAnim == BOTH_A4_TL_BR ||
+		ent2->client->ps.torsoAnim == BOTH_A5_TL_BR ||
+		ent2->client->ps.torsoAnim == BOTH_A6_TL_BR ||
+		ent2->client->ps.torsoAnim == BOTH_A7_TL_BR)
+	{//ent2 is attacking diagonally
+		if ( ent1BlockingPlayer )
+		{//player will block this anyway
+			return WP_SabersCheckLock2( ent2, ent1, LOCK_DIAG_TL );
+		}
+		if ( ent1->client->ps.torsoAnim == BOTH_A1_TL_BR ||
+			ent1->client->ps.torsoAnim == BOTH_A2_TL_BR ||
+			ent1->client->ps.torsoAnim == BOTH_A3_TL_BR ||
+			ent1->client->ps.torsoAnim == BOTH_A4_TL_BR ||
+			ent1->client->ps.torsoAnim == BOTH_A5_TL_BR ||
+			ent1->client->ps.torsoAnim == BOTH_A6_TL_BR ||
+			ent1->client->ps.torsoAnim == BOTH_A7_TL_BR ||
+			ent1->client->ps.torsoAnim == BOTH_P1_S1_TR )
+		{//ent1 is attacking in the opposite diagonal
+			return WP_SabersCheckLock2( ent2, ent1, LOCK_DIAG_TL );
+		}
+		if ( ent1->client->ps.torsoAnim == BOTH_A1_BL_TR ||
+			ent1->client->ps.torsoAnim == BOTH_A2_BL_TR ||
+			ent1->client->ps.torsoAnim == BOTH_A3_BL_TR ||
+			ent1->client->ps.torsoAnim == BOTH_A4_BL_TR ||
+			ent1->client->ps.torsoAnim == BOTH_A5_BL_TR ||
+			ent1->client->ps.torsoAnim == BOTH_A6_BL_TR ||
+			ent1->client->ps.torsoAnim == BOTH_A7_BL_TR ||
+			ent1->client->ps.torsoAnim == BOTH_P1_S1_BR )
+		{//ent1 is attacking in the opposite diagonal
+			return WP_SabersCheckLock2( ent2, ent1, LOCK_DIAG_BR );
+		}
+		return qfalse;
+	}
+	//L to R lock
+	if ( ent1->client->ps.torsoAnim == BOTH_A1__L__R ||
+		ent1->client->ps.torsoAnim == BOTH_A2__L__R ||
+		ent1->client->ps.torsoAnim == BOTH_A3__L__R ||
+		ent1->client->ps.torsoAnim == BOTH_A4__L__R ||
+		ent1->client->ps.torsoAnim == BOTH_A5__L__R ||
+		ent1->client->ps.torsoAnim == BOTH_A6__L__R ||
+		ent1->client->ps.torsoAnim == BOTH_A7__L__R)
+	{//ent1 is attacking l to r
+		if ( ent2BlockingPlayer )
+		{//player will block this anyway
+			return WP_SabersCheckLock2( ent1, ent2, LOCK_L );
+		}
+		if ( ent2->client->ps.torsoAnim == BOTH_A1_TL_BR ||
+			ent2->client->ps.torsoAnim == BOTH_A2_TL_BR ||
+			ent2->client->ps.torsoAnim == BOTH_A3_TL_BR ||
+			ent2->client->ps.torsoAnim == BOTH_A4_TL_BR ||
+			ent2->client->ps.torsoAnim == BOTH_A5_TL_BR ||
+			ent2->client->ps.torsoAnim == BOTH_A6_TL_BR ||
+			ent2->client->ps.torsoAnim == BOTH_A7_TL_BR ||
+			ent2->client->ps.torsoAnim == BOTH_P1_S1_TR ||
+			ent2->client->ps.torsoAnim == BOTH_P1_S1_BL )
+		{//ent2 is attacking or blocking on the r
+			return WP_SabersCheckLock2( ent1, ent2, LOCK_L );
+		}
+		return qfalse;
+	}
+	if ( ent2->client->ps.torsoAnim == BOTH_A1__L__R ||
+		ent2->client->ps.torsoAnim == BOTH_A2__L__R ||
+		ent2->client->ps.torsoAnim == BOTH_A3__L__R ||
+		ent2->client->ps.torsoAnim == BOTH_A4__L__R ||
+		ent2->client->ps.torsoAnim == BOTH_A5__L__R ||
+		ent2->client->ps.torsoAnim == BOTH_A6__L__R ||
+		ent2->client->ps.torsoAnim == BOTH_A7__L__R)
+	{//ent2 is attacking l to r
+		if ( ent1BlockingPlayer )
+		{//player will block this anyway
+			return WP_SabersCheckLock2( ent2, ent1, LOCK_L );
+		}
+		if ( ent1->client->ps.torsoAnim == BOTH_A1_TL_BR ||
+			ent1->client->ps.torsoAnim == BOTH_A2_TL_BR ||
+			ent1->client->ps.torsoAnim == BOTH_A3_TL_BR ||
+			ent1->client->ps.torsoAnim == BOTH_A4_TL_BR ||
+			ent1->client->ps.torsoAnim == BOTH_A5_TL_BR ||
+			ent1->client->ps.torsoAnim == BOTH_A6_TL_BR ||
+			ent1->client->ps.torsoAnim == BOTH_A7_TL_BR ||
+			ent1->client->ps.torsoAnim == BOTH_P1_S1_TR ||
+			ent1->client->ps.torsoAnim == BOTH_P1_S1_BL )
+		{//ent1 is attacking or blocking on the r
+			return WP_SabersCheckLock2( ent2, ent1, LOCK_L );
+		}
+		return qfalse;
+	}
+	//R to L lock
+	if ( ent1->client->ps.torsoAnim == BOTH_A1__R__L ||
+		ent1->client->ps.torsoAnim == BOTH_A2__R__L ||
+		ent1->client->ps.torsoAnim == BOTH_A3__R__L ||
+		ent1->client->ps.torsoAnim == BOTH_A4__R__L ||
+		ent1->client->ps.torsoAnim == BOTH_A5__R__L ||
+		ent1->client->ps.torsoAnim == BOTH_A6__R__L ||
+		ent1->client->ps.torsoAnim == BOTH_A7__R__L)
+	{//ent1 is attacking r to l
+		if ( ent2BlockingPlayer )
+		{//player will block this anyway
+			return WP_SabersCheckLock2( ent1, ent2, LOCK_R );
+		}
+		if ( ent2->client->ps.torsoAnim == BOTH_A1_TR_BL ||
+			ent2->client->ps.torsoAnim == BOTH_A2_TR_BL ||
+			ent2->client->ps.torsoAnim == BOTH_A3_TR_BL ||
+			ent2->client->ps.torsoAnim == BOTH_A4_TR_BL ||
+			ent2->client->ps.torsoAnim == BOTH_A5_TR_BL ||
+			ent2->client->ps.torsoAnim == BOTH_A6_TR_BL ||
+			ent2->client->ps.torsoAnim == BOTH_A7_TR_BL ||
+			ent2->client->ps.torsoAnim == BOTH_P1_S1_TL ||
+			ent2->client->ps.torsoAnim == BOTH_P1_S1_BR )
+		{//ent2 is attacking or blocking on the l
+			return WP_SabersCheckLock2( ent1, ent2, LOCK_R );
+		}
+		return qfalse;
+	}
+	if ( ent2->client->ps.torsoAnim == BOTH_A1__R__L ||
+		ent2->client->ps.torsoAnim == BOTH_A2__R__L ||
+		ent2->client->ps.torsoAnim == BOTH_A3__R__L ||
+		ent2->client->ps.torsoAnim == BOTH_A4__R__L ||
+		ent2->client->ps.torsoAnim == BOTH_A5__R__L ||
+		ent2->client->ps.torsoAnim == BOTH_A6__R__L ||
+		ent2->client->ps.torsoAnim == BOTH_A7__R__L)
+	{//ent2 is attacking r to l
+		if ( ent1BlockingPlayer )
+		{//player will block this anyway
+			return WP_SabersCheckLock2( ent2, ent1, LOCK_R );
+		}
+		if ( ent1->client->ps.torsoAnim == BOTH_A1_TR_BL ||
+			ent1->client->ps.torsoAnim == BOTH_A2_TR_BL ||
+			ent1->client->ps.torsoAnim == BOTH_A3_TR_BL ||
+			ent1->client->ps.torsoAnim == BOTH_A4_TR_BL ||
+			ent1->client->ps.torsoAnim == BOTH_A5_TR_BL ||
+			ent1->client->ps.torsoAnim == BOTH_A6_TR_BL ||
+			ent1->client->ps.torsoAnim == BOTH_A7_TR_BL ||
+			ent1->client->ps.torsoAnim == BOTH_P1_S1_TL ||
+			ent1->client->ps.torsoAnim == BOTH_P1_S1_BR )
+		{//ent1 is attacking or blocking on the l
+			return WP_SabersCheckLock2( ent2, ent1, LOCK_R );
+		}
+		return qfalse;
+	}
+	if ( !Q_irand( 0, 10 ) )
+	{
+		return WP_SabersCheckLock2( ent1, ent2, LOCK_RANDOM );
+	}
+	return qfalse;
+}
+
+static GAME_INLINE int G_GetParryForBlock(int block)
+{
+	switch (block)
+	{
+		case BLOCKED_UPPER_RIGHT:
+			return LS_PARRY_UR;
+			break;
+		case BLOCKED_UPPER_RIGHT_PROJ:
+			return LS_REFLECT_UR;
+			break;
+		case BLOCKED_UPPER_LEFT:
+			return LS_PARRY_UL;
+			break;
+		case BLOCKED_UPPER_LEFT_PROJ:
+			return LS_REFLECT_UL;
+			break;
+		case BLOCKED_LOWER_RIGHT:
+			return LS_PARRY_LR;
+			break;
+		case BLOCKED_LOWER_RIGHT_PROJ:
+			return LS_REFLECT_LR;
+			break;
+		case BLOCKED_LOWER_LEFT:
+			return LS_PARRY_LL;
+			break;
+		case BLOCKED_LOWER_LEFT_PROJ:
+			return LS_REFLECT_LL;
+			break;
+		case BLOCKED_TOP:
+			return LS_PARRY_UP;
+			break;
+		case BLOCKED_TOP_PROJ:
+			return LS_REFLECT_UP;
+			break;
+		default:
+			break;
+	}
+
+	return LS_NONE;
+}
+
+#include "../namespace_begin.h"
+int PM_SaberBounceForAttack( int move );
+int PM_SaberDeflectionForQuad( int quad );
+#include "../namespace_end.h"
+
+extern stringID_table_t animTable[MAX_ANIMATIONS+1];
+static GAME_INLINE qboolean WP_GetSaberDeflectionAngle( gentity_t *attacker, gentity_t *defender, float saberHitFraction )
+{
+	qboolean animBasedDeflection = qtrue;
+	int attSaberLevel, defSaberLevel;
+
+	if ( !attacker || !attacker->client || !attacker->ghoul2 )
+	{
+		return qfalse;
+	}
+	if ( !defender || !defender->client || !defender->ghoul2 )
+	{
+		return qfalse;
+	}
+
+	if ((level.time - attacker->client->lastSaberStorageTime) > 500)
+	{ //last update was too long ago, something is happening to this client to prevent his saber from updating
+		return qfalse;
+	}
+	if ((level.time - defender->client->lastSaberStorageTime) > 500)
+	{ //ditto
+		return qfalse;
+	}
+
+	attSaberLevel = G_SaberAttackPower(attacker, SaberAttacking(attacker));
+	defSaberLevel = G_SaberAttackPower(defender, SaberAttacking(defender));
+
+	if ( animBasedDeflection )
+	{
+		//Hmm, let's try just basing it off the anim
+		int attQuadStart = saberMoveData[attacker->client->ps.saberMove].startQuad;
+		int attQuadEnd = saberMoveData[attacker->client->ps.saberMove].endQuad;
+		int defQuad = saberMoveData[defender->client->ps.saberMove].endQuad;
+		int quadDiff = fabs((float)(defQuad-attQuadStart));
+
+		if ( defender->client->ps.saberMove == LS_READY )
+		{
+			//FIXME: we should probably do SOMETHING here...
+			//I have this return qfalse here in the hopes that
+			//the defender will pick a parry and the attacker
+			//will hit the defender's saber again.
+			//But maybe this func call should come *after*
+			//it's decided whether or not the defender is
+			//going to parry.
+			return qfalse;
+		}
+
+		//reverse the left/right of the defQuad because of the mirrored nature of facing each other in combat
+		switch ( defQuad )
+		{
+		case Q_BR:
+			defQuad = Q_BL;
+			break;
+		case Q_R:
+			defQuad = Q_L;
+			break;
+		case Q_TR:
+			defQuad = Q_TL;
+			break;
+		case Q_TL:
+			defQuad = Q_TR;
+			break;
+		case Q_L:
+			defQuad = Q_R;
+			break;
+		case Q_BL:
+			defQuad = Q_BR;
+			break;
+		}
+
+		if ( quadDiff > 4 )
+		{//wrap around so diff is never greater than 180 (4 * 45)
+			quadDiff = 4 - (quadDiff - 4);
+		}
+		//have the quads, find a good anim to use
+		if ( (!quadDiff || (quadDiff == 1 && Q_irand(0,1))) //defender pretty much stopped the attack at a 90 degree angle
+			&& (defSaberLevel == attSaberLevel || Q_irand( 0, defSaberLevel-attSaberLevel ) >= 0) )//and the defender's style is stronger
+		{
+			//bounce straight back
+#ifndef FINAL_BUILD
+			int attMove = attacker->client->ps.saberMove;
+#endif
+			attacker->client->ps.saberMove = PM_SaberBounceForAttack( attacker->client->ps.saberMove );
+#ifndef FINAL_BUILD
+			if (g_saberDebugPrint.integer)
+			{
+				Com_Printf( "attack %s vs. parry %s bounced to %s\n", 
+					animTable[saberMoveData[attMove].animToUse].name, 
+					animTable[saberMoveData[defender->client->ps.saberMove].animToUse].name,
+					animTable[saberMoveData[attacker->client->ps.saberMove].animToUse].name );
+			}
+#endif
+			attacker->client->ps.saberBlocked = BLOCKED_ATK_BOUNCE;
+			return qfalse;
+		}
+		else
+		{//attack hit at an angle, figure out what angle it should bounce off att
+			int newQuad;
+			quadDiff = defQuad - attQuadEnd;
+			//add half the diff of between the defense and attack end to the attack end
+			if ( quadDiff > 4 )
+			{
+				quadDiff = 4 - (quadDiff - 4);
+			}
+			else if ( quadDiff < -4 )
+			{
+				quadDiff = -4 + (quadDiff + 4);
+			}
+			newQuad = attQuadEnd + ceil( ((float)quadDiff)/2.0f );
+			if ( newQuad < Q_BR )
+			{//less than zero wraps around
+				newQuad = Q_B + newQuad;
+			}
+			if ( newQuad == attQuadStart )
+			{//never come off at the same angle that we would have if the attack was not interrupted
+				if ( Q_irand(0, 1) )
+				{
+					newQuad--;
+				}
+				else
+				{
+					newQuad++;
+				}
+				if ( newQuad < Q_BR )
+				{
+					newQuad = Q_B;
+				}
+				else if ( newQuad > Q_B )
+				{
+					newQuad = Q_BR;
+				}
+			}
+			if ( newQuad == defQuad )
+			{//bounce straight back
+#ifndef FINAL_BUILD
+				int attMove = attacker->client->ps.saberMove;
+#endif
+				attacker->client->ps.saberMove = PM_SaberBounceForAttack( attacker->client->ps.saberMove );
+#ifndef FINAL_BUILD
+				if (g_saberDebugPrint.integer)
+				{
+					Com_Printf( "attack %s vs. parry %s bounced to %s\n", 
+						animTable[saberMoveData[attMove].animToUse].name, 
+						animTable[saberMoveData[defender->client->ps.saberMove].animToUse].name,
+						animTable[saberMoveData[attacker->client->ps.saberMove].animToUse].name );
+				}
+#endif
+				attacker->client->ps.saberBlocked = BLOCKED_ATK_BOUNCE;
+				return qfalse;
+			}
+			//else, pick a deflection
+			else
+			{
+#ifndef FINAL_BUILD
+				int attMove = attacker->client->ps.saberMove;
+#endif
+				attacker->client->ps.saberMove = PM_SaberDeflectionForQuad( newQuad );
+#ifndef FINAL_BUILD
+				if (g_saberDebugPrint.integer)
+				{
+					Com_Printf( "attack %s vs. parry %s deflected to %s\n", 
+						animTable[saberMoveData[attMove].animToUse].name, 
+						animTable[saberMoveData[defender->client->ps.saberMove].animToUse].name,
+						animTable[saberMoveData[attacker->client->ps.saberMove].animToUse].name );
+				}
+#endif
+				attacker->client->ps.saberBlocked = BLOCKED_BOUNCE_MOVE;
+				return qtrue;
+			}
+		}
+	}
+	else
+	{ //old math-based method (probably broken)
+		vec3_t	att_HitDir, def_BladeDir, temp;
+		float	hitDot;
+
+		VectorCopy(attacker->client->lastSaberBase_Always, temp);
+
+		AngleVectors(attacker->client->lastSaberDir_Always, att_HitDir, 0, 0);
+
+		AngleVectors(defender->client->lastSaberDir_Always, def_BladeDir, 0, 0);
+
+		//now compare
+		hitDot = DotProduct( att_HitDir, def_BladeDir );
+		if ( hitDot < 0.25f && hitDot > -0.25f )
+		{//hit pretty much perpendicular, pop straight back
+			attacker->client->ps.saberMove = PM_SaberBounceForAttack( attacker->client->ps.saberMove );
+			attacker->client->ps.saberBlocked = BLOCKED_ATK_BOUNCE;
+			return qfalse;
+		}
+		else 
+		{//a deflection
+			vec3_t	att_Right, att_Up, att_DeflectionDir;
+			float	swingRDot, swingUDot;
+
+			//get the direction of the deflection
+			VectorScale( def_BladeDir, hitDot, att_DeflectionDir );
+			//get our bounce straight back direction
+			VectorScale( att_HitDir, -1.0f, temp );
+			//add the bounce back and deflection
+			VectorAdd( att_DeflectionDir, temp, att_DeflectionDir );
+			//normalize the result to determine what direction our saber should bounce back toward
+			VectorNormalize( att_DeflectionDir );
+
+			//need to know the direction of the deflectoin relative to the attacker's facing
+			VectorSet( temp, 0, attacker->client->ps.viewangles[YAW], 0 );//presumes no pitch!
+			AngleVectors( temp, NULL, att_Right, att_Up );
+			swingRDot = DotProduct( att_Right, att_DeflectionDir );
+			swingUDot = DotProduct( att_Up, att_DeflectionDir );
+
+			if ( swingRDot > 0.25f )
+			{//deflect to right
+				if ( swingUDot > 0.25f )
+				{//deflect to top
+					attacker->client->ps.saberMove = LS_D1_TR;
+				}
+				else if ( swingUDot < -0.25f )
+				{//deflect to bottom
+					attacker->client->ps.saberMove = LS_D1_BR;
+				}
+				else
+				{//deflect horizontally
+					attacker->client->ps.saberMove = LS_D1__R;
+				}
+			}
+			else if ( swingRDot < -0.25f )
+			{//deflect to left
+				if ( swingUDot > 0.25f )
+				{//deflect to top
+					attacker->client->ps.saberMove = LS_D1_TL;
+				}
+				else if ( swingUDot < -0.25f )
+				{//deflect to bottom
+					attacker->client->ps.saberMove = LS_D1_BL;
+				}
+				else
+				{//deflect horizontally
+					attacker->client->ps.saberMove = LS_D1__L;
+				}
+			}
+			else
+			{//deflect in middle
+				if ( swingUDot > 0.25f )
+				{//deflect to top
+					attacker->client->ps.saberMove = LS_D1_T_;
+				}
+				else if ( swingUDot < -0.25f )
+				{//deflect to bottom
+					attacker->client->ps.saberMove = LS_D1_B_;
+				}
+				else
+				{//deflect horizontally?  Well, no such thing as straight back in my face, so use top
+					if ( swingRDot > 0 )
+					{
+						attacker->client->ps.saberMove = LS_D1_TR;
+					}
+					else if ( swingRDot < 0 )
+					{
+						attacker->client->ps.saberMove = LS_D1_TL;
+					}
+					else
+					{
+						attacker->client->ps.saberMove = LS_D1_T_;
+					}
+				}
+			}
+
+			attacker->client->ps.saberBlocked = BLOCKED_BOUNCE_MOVE;
+			return qtrue;
+		}
+	}
+}
+
+int G_KnockawayForParry( int move )
+{
+	//FIXME: need actual anims for this
+	//FIXME: need to know which side of the saber was hit!  For now, we presume the saber gets knocked away from the center
+	switch ( move )
+	{
+	case LS_PARRY_UP:
+		return LS_K1_T_;//push up
+		break;
+	case LS_PARRY_UR:
+	default://case LS_READY:
+		return LS_K1_TR;//push up, slightly to right
+		break;
+	case LS_PARRY_UL:
+		return LS_K1_TL;//push up and to left
+		break;
+	case LS_PARRY_LR:
+		return LS_K1_BR;//push down and to left
+		break;
+	case LS_PARRY_LL:
+		return LS_K1_BL;//push down and to right
+		break;
+	}
+}
+
+#define SABER_NONATTACK_DAMAGE 1
+
+//For strong attacks, we ramp damage based on the point in the attack animation
+static GAME_INLINE int G_GetAttackDamage(gentity_t *self, int minDmg, int maxDmg, float multPoint)
+{
+	int peakDif = 0;
+	int speedDif = 0;
+	int totalDamage = maxDmg;
+	float peakPoint = 0;
+	float attackAnimLength = bgAllAnims[self->localAnimIndex].anims[self->client->ps.torsoAnim].numFrames * fabs((float)(bgAllAnims[self->localAnimIndex].anims[self->client->ps.torsoAnim].frameLerp));
+	float currentPoint = 0;
+	float damageFactor = 0;
+	float animSpeedFactor = 1.0f;
+
+	//Be sure to scale by the proper anim speed just as if we were going to play the animation
+	BG_SaberStartTransAnim(self->client->ps.fd.saberAnimLevel, self->client->ps.torsoAnim, &animSpeedFactor, self->client->ps.brokenLimbs);
+	speedDif = attackAnimLength - (attackAnimLength * animSpeedFactor);
+	attackAnimLength += speedDif;
+	peakPoint = attackAnimLength;
+	peakPoint -= attackAnimLength*multPoint;
+
+	//we treat torsoTimer as the point in the animation (closer it is to attackAnimLength, closer it is to beginning)
+	currentPoint = self->client->ps.torsoTimer;
+
+	if (peakPoint > currentPoint)
+	{
+		peakDif = (peakPoint - currentPoint);
+	}
+	else
+	{
+		peakDif = (currentPoint - peakPoint);
+	}
+
+	damageFactor = (float)((currentPoint/peakPoint));
+	if (damageFactor > 1)
+	{
+		damageFactor = (2.0f - damageFactor);
+	}
+
+	totalDamage *= damageFactor;
+	if (totalDamage < minDmg)
+	{
+		totalDamage = minDmg;
+	}
+	if (totalDamage > maxDmg)
+	{
+		totalDamage = maxDmg;
+	}
+
+	//Com_Printf("%i\n", totalDamage);
+
+	return totalDamage;
+}
+
+//Get the point in the animation and return a percentage of the current point in the anim between 0 and the total anim length (0.0f - 1.0f)
+static GAME_INLINE float G_GetAnimPoint(gentity_t *self)
+{
+	int speedDif = 0;
+	float attackAnimLength = bgAllAnims[self->localAnimIndex].anims[self->client->ps.torsoAnim].numFrames * fabs((float)(bgAllAnims[self->localAnimIndex].anims[self->client->ps.torsoAnim].frameLerp));
+	float currentPoint = 0;
+	float animSpeedFactor = 1.0f;
+	float animPercentage = 0;
+
+	//Be sure to scale by the proper anim speed just as if we were going to play the animation
+	BG_SaberStartTransAnim(self->client->ps.fd.saberAnimLevel, self->client->ps.torsoAnim, &animSpeedFactor, self->client->ps.brokenLimbs);
+	speedDif = attackAnimLength - (attackAnimLength * animSpeedFactor);
+	attackAnimLength += speedDif;
+
+	currentPoint = self->client->ps.torsoTimer;
+
+	animPercentage = currentPoint/attackAnimLength;
+
+	//Com_Printf("%f\n", animPercentage);
+
+	return animPercentage;
+}
+
+static GAME_INLINE qboolean G_ClientIdleInWorld(gentity_t *ent)
+{
+	if (ent->s.eType == ET_NPC)
+	{
+		return qfalse;
+	}
+
+	if (!ent->client->pers.cmd.upmove &&
+		!ent->client->pers.cmd.forwardmove &&
+		!ent->client->pers.cmd.rightmove &&
+		!(ent->client->pers.cmd.buttons & BUTTON_GESTURE) &&
+		!(ent->client->pers.cmd.buttons & BUTTON_FORCEGRIP) &&
+		!(ent->client->pers.cmd.buttons & BUTTON_ALT_ATTACK) &&
+		!(ent->client->pers.cmd.buttons & BUTTON_FORCEPOWER) &&
+		!(ent->client->pers.cmd.buttons & BUTTON_FORCE_LIGHTNING) &&
+		!(ent->client->pers.cmd.buttons & BUTTON_FORCE_DRAIN) &&
+		!(ent->client->pers.cmd.buttons & BUTTON_ATTACK))
+	{
+		return qtrue;
+	}
+
+	return qfalse;
+}
+
+static GAME_INLINE qboolean G_G2TraceCollide(trace_t *tr, vec3_t lastValidStart, vec3_t lastValidEnd, vec3_t traceMins, vec3_t traceMaxs)
+{ //Hit the ent with the normal trace, try the collision trace.
+	G2Trace_t		G2Trace;
+	gentity_t		*g2Hit;
+	vec3_t			angles;
+	int				tN = 0;
+	float			fRadius = 0;
+
+	if (!d_saberGhoul2Collision.integer)
+	{
+		return qfalse;
+	}
+
+	if (!g_entities[tr->entityNum].inuse /*||
+		(g_entities[tr->entityNum].s.eFlags & EF_DEAD)*/)
+	{ //don't do perpoly on corpses.
+		return qfalse;
+	}
+
+	if (traceMins[0] ||
+		traceMins[1] ||
+		traceMins[2] ||
+		traceMaxs[0] ||
+		traceMaxs[1] ||
+		traceMaxs[2])
+	{
+		fRadius=(traceMaxs[0]-traceMins[0])/2.0f;
+	}
+
+	memset (&G2Trace, 0, sizeof(G2Trace));
+
+	while (tN < MAX_G2_COLLISIONS)
+	{
+		G2Trace[tN].mEntityNum = -1;
+		tN++;
+	}
+	g2Hit = &g_entities[tr->entityNum];
+
+	if (g2Hit && g2Hit->inuse && g2Hit->ghoul2)
+	{
+		vec3_t g2HitOrigin;
+
+		angles[ROLL] = angles[PITCH] = 0;
+
+		if (g2Hit->client)
+		{
+			VectorCopy(g2Hit->client->ps.origin, g2HitOrigin);
+			angles[YAW] = g2Hit->client->ps.viewangles[YAW];
+		}
+		else
+		{
+			VectorCopy(g2Hit->r.currentOrigin, g2HitOrigin);
+			angles[YAW] = g2Hit->r.currentAngles[YAW];
+		}
+
+		trap_G2API_CollisionDetect ( G2Trace, g2Hit->ghoul2, angles, g2HitOrigin, level.time, g2Hit->s.number, lastValidStart, lastValidEnd, g2Hit->modelScale, 0, g_g2TraceLod.integer, fRadius );
+
+		if (G2Trace[0].mEntityNum != g2Hit->s.number)
+		{
+			tr->fraction = 1.0f;
+			tr->entityNum = ENTITYNUM_NONE;
+			tr->startsolid = 0;
+			tr->allsolid = 0;
+			return qfalse;
+		}
+		else
+		{ //The ghoul2 trace result matches, so copy the collision position into the trace endpos and send it back.
+			VectorCopy(G2Trace[0].mCollisionPosition, tr->endpos);
+			VectorCopy(G2Trace[0].mCollisionNormal, tr->plane.normal);
+
+			if (g2Hit->client)
+			{
+				g2Hit->client->g2LastSurfaceHit = G2Trace[0].mSurfaceIndex;
+				g2Hit->client->g2LastSurfaceTime = level.time;
+			}
+			return qtrue;
+		}
+	}
+
+	return qfalse;
+}
+
+static GAME_INLINE qboolean G_SaberInBackAttack(int move)
+{
+	switch (move)
+	{
+	case LS_A_BACK:
+	case LS_A_BACK_CR:
+	case LS_A_BACKSTAB:
+		return qtrue;
+	}
+
+	return qfalse;
+}
+
+qboolean saberCheckKnockdown_Thrown(gentity_t *saberent, gentity_t *saberOwner, gentity_t *other);
+qboolean saberCheckKnockdown_Smashed(gentity_t *saberent, gentity_t *saberOwner, gentity_t *other, int damage);
+qboolean saberCheckKnockdown_BrokenParry(gentity_t *saberent, gentity_t *saberOwner, gentity_t *other);
+
+
+typedef struct saberFace_s
+{
+	vec3_t v1;
+	vec3_t v2;
+	vec3_t v3;
+} saberFace_t;
+
+//build faces around blade for collision checking -rww
+static GAME_INLINE void G_BuildSaberFaces(vec3_t base, vec3_t tip, float radius, vec3_t fwd,
+										  vec3_t right, int *fNum, saberFace_t **fList)
+{
+	static saberFace_t faces[12];
+	int i = 0;
+	float *d1 = NULL, *d2 = NULL;
+	vec3_t invFwd;
+	vec3_t invRight;
+
+	VectorCopy(fwd, invFwd);
+	VectorInverse(invFwd);
+	VectorCopy(right, invRight);
+	VectorInverse(invRight);
+
+	while (i < 8)
+	{
+		//yeah, this part is kind of a hack, but eh
+		if (i < 2)
+		{ //"left" surface
+			d1 = &fwd[0];
+			d2 = &invRight[0];
+		}
+		else if (i < 4)
+		{ //"right" surface
+			d1 = &fwd[0];
+			d2 = &right[0];
+		}
+		else if (i < 6)
+		{ //"front" surface
+			d1 = &right[0];
+			d2 = &fwd[0];
+		}
+		else if (i < 8)
+		{ //"back" surface
+			d1 = &right[0];
+			d2 = &invFwd[0];
+		}
+
+		//first triangle for this surface
+		VectorMA(base, radius/2.0f, d1, faces[i].v1);
+		VectorMA(faces[i].v1, radius/2.0f, d2, faces[i].v1);
+
+		VectorMA(tip, radius/2.0f, d1, faces[i].v2);
+		VectorMA(faces[i].v2, radius/2.0f, d2, faces[i].v2);
+
+		VectorMA(tip, -radius/2.0f, d1, faces[i].v3);
+		VectorMA(faces[i].v3, radius/2.0f, d2, faces[i].v3);
+
+		i++;
+
+		//second triangle for this surface
+		VectorMA(tip, -radius/2.0f, d1, faces[i].v1);
+		VectorMA(faces[i].v1, radius/2.0f, d2, faces[i].v1);
+
+		VectorMA(base, radius/2.0f, d1, faces[i].v2);
+		VectorMA(faces[i].v2, radius/2.0f, d2, faces[i].v2);
+
+		VectorMA(base, -radius/2.0f, d1, faces[i].v3);
+		VectorMA(faces[i].v3, radius/2.0f, d2, faces[i].v3);
+
+		i++;
+	}
+
+	//top surface
+	//face 1
+	VectorMA(tip, radius/2.0f, fwd, faces[i].v1);
+	VectorMA(faces[i].v1, -radius/2.0f, right, faces[i].v1);
+
+	VectorMA(tip, radius/2.0f, fwd, faces[i].v2);
+	VectorMA(faces[i].v2, radius/2.0f, right, faces[i].v2);
+
+	VectorMA(tip, -radius/2.0f, fwd, faces[i].v3);
+	VectorMA(faces[i].v3, -radius/2.0f, right, faces[i].v3);
+
+	i++;
+
+	//face 2
+	VectorMA(tip, radius/2.0f, fwd, faces[i].v1);
+	VectorMA(faces[i].v1, radius/2.0f, right, faces[i].v1);
+
+	VectorMA(tip, -radius/2.0f, fwd, faces[i].v2);
+	VectorMA(faces[i].v2, -radius/2.0f, right, faces[i].v2);
+
+	VectorMA(tip, -radius/2.0f, fwd, faces[i].v3);
+	VectorMA(faces[i].v3, radius/2.0f, right, faces[i].v3);
+
+	i++;
+
+	//bottom surface
+	//face 1
+	VectorMA(base, radius/2.0f, fwd, faces[i].v1);
+	VectorMA(faces[i].v1, -radius/2.0f, right, faces[i].v1);
+
+	VectorMA(base, radius/2.0f, fwd, faces[i].v2);
+	VectorMA(faces[i].v2, radius/2.0f, right, faces[i].v2);
+
+	VectorMA(base, -radius/2.0f, fwd, faces[i].v3);
+	VectorMA(faces[i].v3, -radius/2.0f, right, faces[i].v3);
+
+	i++;
+
+	//face 2
+	VectorMA(base, radius/2.0f, fwd, faces[i].v1);
+	VectorMA(faces[i].v1, radius/2.0f, right, faces[i].v1);
+
+	VectorMA(base, -radius/2.0f, fwd, faces[i].v2);
+	VectorMA(faces[i].v2, -radius/2.0f, right, faces[i].v2);
+
+	VectorMA(base, -radius/2.0f, fwd, faces[i].v3);
+	VectorMA(faces[i].v3, radius/2.0f, right, faces[i].v3);
+
+	i++;
+
+	//yeah.. always going to be 12 I suppose.
+	*fNum = i;
+	*fList = &faces[0];
+}
+
+//collision utility function -rww
+static GAME_INLINE void G_SabCol_CalcPlaneEq(vec3_t x, vec3_t y, vec3_t z, float *planeEq)
+{
+	planeEq[0] = x[1]*(y[2]-z[2]) + y[1]*(z[2]-x[2]) + z[1]*(x[2]-y[2]);
+	planeEq[1] = x[2]*(y[0]-z[0]) + y[2]*(z[0]-x[0]) + z[2]*(x[0]-y[0]);
+	planeEq[2] = x[0]*(y[1]-z[1]) + y[0]*(z[1]-x[1]) + z[0]*(x[1]-y[1]);
+	planeEq[3] = -(x[0]*(y[1]*z[2] - z[1]*y[2]) + y[0]*(z[1]*x[2] - x[1]*z[2]) + z[0]*(x[1]*y[2] - y[1]*x[2]) );
+}
+
+//collision utility function -rww
+static GAME_INLINE int G_SabCol_PointRelativeToPlane(vec3_t pos, float *side, float *planeEq)
+{
+	*side = planeEq[0]*pos[0] + planeEq[1]*pos[1] + planeEq[2]*pos[2] + planeEq[3];
+
+	if (*side > 0.0f)
+	{
+		return 1;
+	}
+	else if (*side < 0.0f)
+	{
+		return -1;
+	}
+
+	return 0;
+}
+
+//do actual collision check using generated saber "faces"
+static GAME_INLINE qboolean G_SaberFaceCollisionCheck(int fNum, saberFace_t *fList, vec3_t atkStart,
+											 vec3_t atkEnd, vec3_t atkMins, vec3_t atkMaxs, vec3_t impactPoint)
+{
+	static float planeEq[4];
+	static float side, side2, dist;
+	static vec3_t dir;
+	static vec3_t point;
+	int i = 0;
+
+	if (VectorCompare(atkMins, vec3_origin) && VectorCompare(atkMaxs, vec3_origin))
+	{
+		VectorSet(atkMins, -1.0f, -1.0f, -1.0f);
+		VectorSet(atkMaxs, 1.0f, 1.0f, 1.0f);
+	}
+
+	VectorSubtract(atkEnd, atkStart, dir);
+
+	while (i < fNum)
+	{
+		G_SabCol_CalcPlaneEq(fList->v1, fList->v2, fList->v3, planeEq);
+
+		if (G_SabCol_PointRelativeToPlane(atkStart, &side, planeEq) !=
+			G_SabCol_PointRelativeToPlane(atkEnd, &side2, planeEq))
+		{ //start/end points intersect with the plane
+			static vec3_t extruded;
+			static vec3_t minPoint, maxPoint;
+			static vec3_t planeNormal;
+			static int facing;
+
+			VectorCopy(&planeEq[0], planeNormal);
+			side2 = planeNormal[0]*dir[0] + planeNormal[1]*dir[1] + planeNormal[2]*dir[2];
+
+			dist = side/side2;
+			VectorMA(atkStart, -dist, dir, point);
+
+			VectorAdd(point, atkMins, minPoint);
+			VectorAdd(point, atkMaxs, maxPoint);
+
+			//point is now the point at which we intersect on the plane.
+			//see if that point is within the edges of the face.
+            VectorMA(fList->v1, -2.0f, planeNormal, extruded);
+			G_SabCol_CalcPlaneEq(fList->v1, fList->v2, extruded, planeEq);
+			facing = G_SabCol_PointRelativeToPlane(point, &side, planeEq);
+
+			if (facing < 0)
+			{ //not intersecting.. let's try with the mins/maxs and see if they interesect on the edge plane
+				facing = G_SabCol_PointRelativeToPlane(minPoint, &side, planeEq);
+				if (facing < 0)
+				{
+					facing = G_SabCol_PointRelativeToPlane(maxPoint, &side, planeEq);
+				}
+			}
+
+			if (facing >= 0)
+			{ //first edge is facing...
+				VectorMA(fList->v2, -2.0f, planeNormal, extruded);
+				G_SabCol_CalcPlaneEq(fList->v2, fList->v3, extruded, planeEq);
+				facing = G_SabCol_PointRelativeToPlane(point, &side, planeEq);
+
+				if (facing < 0)
+				{ //not intersecting.. let's try with the mins/maxs and see if they interesect on the edge plane
+					facing = G_SabCol_PointRelativeToPlane(minPoint, &side, planeEq);
+					if (facing < 0)
+					{
+						facing = G_SabCol_PointRelativeToPlane(maxPoint, &side, planeEq);
+					}
+				}
+
+				if (facing >= 0)
+				{ //second edge is facing...
+					VectorMA(fList->v3, -2.0f, planeNormal, extruded);
+					G_SabCol_CalcPlaneEq(fList->v3, fList->v1, extruded, planeEq);
+					facing = G_SabCol_PointRelativeToPlane(point, &side, planeEq);
+
+					if (facing < 0)
+					{ //not intersecting.. let's try with the mins/maxs and see if they interesect on the edge plane
+						facing = G_SabCol_PointRelativeToPlane(minPoint, &side, planeEq);
+						if (facing < 0)
+						{
+							facing = G_SabCol_PointRelativeToPlane(maxPoint, &side, planeEq);
+						}
+					}
+
+					if (facing >= 0)
+					{ //third edge is facing.. success
+						VectorCopy(point, impactPoint);
+						return qtrue;
+					}
+				}
+			}
+		}
+
+		i++;
+		fList++;
+	}
+	
+	//did not hit anything
+	return qfalse;
+}
+
+//check for collision of 2 blades -rww
+static GAME_INLINE qboolean G_SaberCollide(gentity_t *atk, gentity_t *def, vec3_t atkStart,
+						vec3_t atkEnd, vec3_t atkMins, vec3_t atkMaxs, vec3_t impactPoint)
+{
+	static int i, j;
+
+	if (!g_saberBladeFaces.integer)
+	{ //detailed check not enabled
+		return qtrue;
+	}
+
+	if (!atk->inuse || !atk->client || !def->inuse || !def->client)
+	{ //must have 2 clients and a valid saber entity
+		return qfalse;
+	}
+
+	i = 0;
+	while (i < MAX_SABERS)
+	{
+		j = 0;
+		if (def->client->saber[i].model && def->client->saber[i].model[0])
+		{ //valid saber on the defender
+			bladeInfo_t *blade;
+			vec3_t v, fwd, right, base, tip;
+			int fNum;
+			saberFace_t *fList;
+
+			//go through each blade on the defender's sabers
+			while (j < def->client->saber[i].numBlades)
+			{
+				blade = &def->client->saber[i].blade[j];
+
+				if ((level.time-blade->storageTime) < 200)
+				{ //recently updated
+					//first get base and tip of blade
+					VectorCopy(blade->muzzlePoint, base);
+					VectorMA(base, blade->lengthMax, blade->muzzleDir, tip);
+
+					//Now get relative angles between the points
+					VectorSubtract(tip, base, v);
+					vectoangles(v, v);
+					AngleVectors(v, NULL, right, fwd);
+
+					//now build collision faces for this blade
+					G_BuildSaberFaces(base, tip, blade->radius*3.0f, fwd, right, &fNum, &fList);
+					if (fNum > 0)
+					{
+#if 0
+						if (atk->s.number == 0)
+						{
+							int x = 0;
+							saberFace_t *l = fList;
+							while (x < fNum)
+							{
+								G_TestLine(fList->v1, fList->v2, 0x0000ff, 100);
+								G_TestLine(fList->v2, fList->v3, 0x0000ff, 100);
+								G_TestLine(fList->v3, fList->v1, 0x0000ff, 100);
+
+								fList++;
+								x++;
+							}
+							fList = l;
+						}
+#endif
+
+						if (G_SaberFaceCollisionCheck(fNum, fList, atkStart, atkEnd, atkMins, atkMaxs, impactPoint))
+						{ //collided
+							return qtrue;
+						}
+					}
+				}
+				j++;
+			}
+		}
+		i++;
+	}
+
+	return qfalse;
+}
+
+float WP_SaberBladeLength( saberInfo_t *saber )
+{//return largest length
+	int	i;
+	float len = 0.0f;
+	for ( i = 0; i < saber->numBlades; i++ )
+	{
+		if ( saber->blade[i].lengthMax > len )
+		{
+			len = saber->blade[i].lengthMax; 
+		}
+	}
+	return len;
+}
+
+float WP_SaberLength( gentity_t *ent )
+{//return largest length
+	if ( !ent || !ent->client )
+	{
+		return 0.0f;
+	}
+	else
+	{
+		int i;
+		float len, bestLen = 0.0f;
+		for ( i = 0; i < MAX_SABERS; i++ )
+		{
+			len = WP_SaberBladeLength( &ent->client->saber[i] );
+			if ( len > bestLen )
+			{
+				bestLen = len;
+			}
+		}
+		return bestLen;
+	}
+}
+int WPDEBUG_SaberColor( saber_colors_t saberColor )
+{
+	switch( (int)(saberColor) )
+	{
+		case SABER_RED:
+			return 0x000000ff;
+			break;
+		case SABER_ORANGE:
+			return 0x000088ff;
+			break;
+		case SABER_YELLOW:
+			return 0x0000ffff;
+			break;
+		case SABER_GREEN:
+			return 0x0000ff00;
+			break;
+		case SABER_BLUE:
+			return 0x00ff0000;
+			break;
+		case SABER_PURPLE:
+			return 0x00ff00ff;
+			break;
+		default:
+			return 0x00ffffff;//white
+			break;
+	}
+}
+/*
+WP_SabersIntersect
+
+Breaks the two saber paths into 2 tris each and tests each tri for the first saber path against each of the other saber path's tris
+
+FIXME: subdivide the arc into a consistant increment
+FIXME: test the intersection to see if the sabers really did intersect (weren't going in the same direction and/or passed through same point at different times)?
+*/
+extern qboolean tri_tri_intersect(vec3_t V0,vec3_t V1,vec3_t V2,vec3_t U0,vec3_t U1,vec3_t U2);
+#define SABER_EXTRAPOLATE_DIST 16.0f
+qboolean WP_SabersIntersect( gentity_t *ent1, int ent1SaberNum, int ent1BladeNum, gentity_t *ent2, qboolean checkDir )
+{
+	vec3_t	saberBase1, saberTip1, saberBaseNext1, saberTipNext1;
+	vec3_t	saberBase2, saberTip2, saberBaseNext2, saberTipNext2;
+	int		ent2SaberNum = 0, ent2BladeNum = 0;
+	vec3_t	dir;
+
+	if ( !ent1 || !ent2 )
+	{
+		return qfalse;
+	}
+	if ( !ent1->client || !ent2->client )
+	{
+		return qfalse;
+	}
+	if ( BG_SabersOff( &ent1->client->ps )
+		|| BG_SabersOff( &ent2->client->ps ) )
+	{
+		return qfalse;
+	}
+
+	for ( ent2SaberNum = 0; ent2SaberNum < MAX_SABERS; ent2SaberNum++ )
+	{
+		if ( ent2->client->saber[ent2SaberNum].type != SABER_NONE )
+		{
+			for ( ent2BladeNum = 0; ent2BladeNum < ent2->client->saber[ent2SaberNum].numBlades; ent2BladeNum++ )
+			{
+				if ( ent2->client->saber[ent2SaberNum].blade[ent2BladeNum].lengthMax > 0 )
+				{//valid saber and this blade is on
+					//if ( ent1->client->saberInFlight )
+					{
+						VectorCopy( ent1->client->saber[ent1SaberNum].blade[ent1BladeNum].muzzlePointOld, saberBase1 );
+						VectorCopy( ent1->client->saber[ent1SaberNum].blade[ent1BladeNum].muzzlePoint, saberBaseNext1 );
+
+						VectorSubtract( ent1->client->saber[ent1SaberNum].blade[ent1BladeNum].muzzlePoint, ent1->client->saber[ent1SaberNum].blade[ent1BladeNum].muzzlePointOld, dir );
+						VectorNormalize( dir );
+						VectorMA( saberBaseNext1, SABER_EXTRAPOLATE_DIST, dir, saberBaseNext1 );
+
+						VectorMA( saberBase1, ent1->client->saber[ent1SaberNum].blade[ent1BladeNum].lengthMax+SABER_EXTRAPOLATE_DIST, ent1->client->saber[ent1SaberNum].blade[ent1BladeNum].muzzleDirOld, saberTip1 );
+						VectorMA( saberBaseNext1, ent1->client->saber[ent1SaberNum].blade[ent1BladeNum].lengthMax+SABER_EXTRAPOLATE_DIST, ent1->client->saber[ent1SaberNum].blade[ent1BladeNum].muzzleDir, saberTipNext1 );
+
+						VectorSubtract( saberTipNext1, saberTip1, dir );
+						VectorNormalize( dir );
+						VectorMA( saberTipNext1, SABER_EXTRAPOLATE_DIST, dir, saberTipNext1 );
+					}
+					/*
+					else
+					{
+						VectorCopy( ent1->client->saber[ent1SaberNum].blade[ent1BladeNum].muzzlePoint, saberBase1 );
+						VectorCopy( ent1->client->saber[ent1SaberNum].blade[ent1BladeNum].muzzlePointNext, saberBaseNext1 );
+						VectorMA( saberBase1, ent1->client->saber[ent1SaberNum].blade[ent1BladeNum].lengthMax, ent1->client->saber[ent1SaberNum].blade[ent1BladeNum].muzzleDir, saberTip1 );
+						VectorMA( saberBaseNext1, ent1->client->saber[ent1SaberNum].blade[ent1BladeNum].lengthMax, ent1->client->saber[ent1SaberNum].blade[ent1BladeNum].muzzleDirNext, saberTipNext1 );
+					}
+					*/
+
+					//if ( ent2->client->saberInFlight )
+					{
+						VectorCopy( ent2->client->saber[ent2SaberNum].blade[ent2BladeNum].muzzlePointOld, saberBase2 );
+						VectorCopy( ent2->client->saber[ent2SaberNum].blade[ent2BladeNum].muzzlePoint, saberBaseNext2 );
+
+						VectorSubtract( ent2->client->saber[ent2SaberNum].blade[ent2BladeNum].muzzlePoint, ent2->client->saber[ent2SaberNum].blade[ent2BladeNum].muzzlePointOld, dir );
+						VectorNormalize( dir );
+						VectorMA( saberBaseNext2, SABER_EXTRAPOLATE_DIST, dir, saberBaseNext2 );
+
+						VectorMA( saberBase2, ent2->client->saber[ent2SaberNum].blade[ent2BladeNum].lengthMax+SABER_EXTRAPOLATE_DIST, ent2->client->saber[ent2SaberNum].blade[ent2BladeNum].muzzleDirOld, saberTip2 );
+						VectorMA( saberBaseNext2, ent2->client->saber[ent2SaberNum].blade[ent2BladeNum].lengthMax+SABER_EXTRAPOLATE_DIST, ent2->client->saber[ent2SaberNum].blade[ent2BladeNum].muzzleDir, saberTipNext2 );
+
+						VectorSubtract( saberTipNext2, saberTip2, dir );
+						VectorNormalize( dir );
+						VectorMA( saberTipNext2, SABER_EXTRAPOLATE_DIST, dir, saberTipNext2 );
+					}
+					/*
+					else
+					{
+						VectorCopy( ent2->client->saber[ent2SaberNum].blade[ent2BladeNum].muzzlePoint, saberBase2 );
+						VectorCopy( ent2->client->saber[ent2SaberNum].blade[ent2BladeNum].muzzlePointNext, saberBaseNext2 );
+						VectorMA( saberBase2, ent2->client->saber[ent2SaberNum].blade[ent2BladeNum].lengthMax, ent2->client->saber[ent2SaberNum].blade[ent2BladeNum].muzzleDir, saberTip2 );
+						VectorMA( saberBaseNext2, ent2->client->saber[ent2SaberNum].blade[ent2BladeNum].lengthMax, ent2->client->saber[ent2SaberNum].blade[ent2BladeNum].muzzleDirNext, saberTipNext2 );
+					}
+					*/
+					if ( checkDir )
+					{//check the direction of the two swings to make sure the sabers are swinging towards each other
+						vec3_t saberDir1, saberDir2;
+						float dot = 0.0f;
+
+						VectorSubtract( saberTipNext1, saberTip1, saberDir1 );
+						VectorSubtract( saberTipNext2, saberTip2, saberDir2 );
+						VectorNormalize( saberDir1 );
+						VectorNormalize( saberDir2 );
+						if ( DotProduct( saberDir1, saberDir2 ) > 0.6f )
+						{//sabers moving in same dir, probably didn't actually hit
+							continue;
+						}
+						//now check orientation of sabers, make sure they're not parallel or close to it
+						dot = DotProduct( ent1->client->saber[ent1SaberNum].blade[ent1BladeNum].muzzleDir, ent2->client->saber[ent2SaberNum].blade[ent2BladeNum].muzzleDir );
+						if ( dot > 0.9f || dot < -0.9f )
+						{//too parallel to really block effectively?
+							continue;
+						}
+					}
+
+#ifdef DEBUG_SABER_BOX
+					if ( g_saberDebugBox.integer == 2 || g_saberDebugBox.integer == 4 )
+					{
+						G_TestLine(saberBase1, saberTip1, ent1->client->saber[ent1SaberNum].blade[ent1BladeNum].color, 500);
+						G_TestLine(saberTip1, saberTipNext1, ent1->client->saber[ent1SaberNum].blade[ent1BladeNum].color, 500);
+						G_TestLine(saberTipNext1, saberBase1, ent1->client->saber[ent1SaberNum].blade[ent1BladeNum].color, 500);
+
+						G_TestLine(saberBase2, saberTip2, ent2->client->saber[ent2SaberNum].blade[ent2BladeNum].color, 500);
+						G_TestLine(saberTip2, saberTipNext2, ent2->client->saber[ent2SaberNum].blade[ent2BladeNum].color, 500);
+						G_TestLine(saberTipNext2, saberBase2, ent2->client->saber[ent2SaberNum].blade[ent2BladeNum].color, 500);
+					}
+#endif
+					if ( tri_tri_intersect( saberBase1, saberTip1, saberBaseNext1, saberBase2, saberTip2, saberBaseNext2 ) )
+					{
+						return qtrue;
+					}
+					if ( tri_tri_intersect( saberBase1, saberTip1, saberBaseNext1, saberBase2, saberTip2, saberTipNext2 ) )
+					{
+						return qtrue;
+					}
+					if ( tri_tri_intersect( saberBase1, saberTip1, saberTipNext1, saberBase2, saberTip2, saberBaseNext2 ) )
+					{
+						return qtrue;
+					}
+					if ( tri_tri_intersect( saberBase1, saberTip1, saberTipNext1, saberBase2, saberTip2, saberTipNext2 ) )
+					{
+						return qtrue;
+					}
+				}
+			}
+		}
+	}
+	return qfalse;
+}
+
+static GAME_INLINE int G_PowerLevelForSaberAnim( gentity_t *ent, int saberNum, qboolean mySaberHit )
+{
+	if ( !ent || !ent->client || saberNum >= MAX_SABERS )
+	{
+		return FORCE_LEVEL_0;
+	}
+	else
+	{
+		int anim = ent->client->ps.torsoAnim;
+		int	animTimer = ent->client->ps.torsoTimer;
+		int	animTimeElapsed = BG_AnimLength( ent->localAnimIndex, (animNumber_t)anim ) - animTimer;
+		saberInfo_t *saber = &ent->client->saber[saberNum];
+		if ( anim >= BOTH_A1_T__B_ && anim <= BOTH_D1_B____ )
+		{
+			//FIXME: these two need their own style
+			if ( saber->type == SABER_LANCE )
+			{
+				return FORCE_LEVEL_4;
+			}
+			else if ( saber->type == SABER_TRIDENT )
+			{
+				return FORCE_LEVEL_3;
+			}
+			return FORCE_LEVEL_1;
+		}
+		if ( anim >= BOTH_A2_T__B_ && anim <= BOTH_D2_B____ )
+		{
+			return FORCE_LEVEL_2;
+		}
+		if ( anim >= BOTH_A3_T__B_ && anim <= BOTH_D3_B____ )
+		{
+			return FORCE_LEVEL_3;
+		}
+		if ( anim >= BOTH_A4_T__B_ && anim <= BOTH_D4_B____ )
+		{//desann
+			return FORCE_LEVEL_4;
+		}
+		if ( anim >= BOTH_A5_T__B_ && anim <= BOTH_D5_B____ )
+		{//tavion
+			return FORCE_LEVEL_2;
+		}
+		if ( anim >= BOTH_A6_T__B_ && anim <= BOTH_D6_B____ )
+		{//dual
+			return FORCE_LEVEL_2;
+		}
+		if ( anim >= BOTH_A7_T__B_ && anim <= BOTH_D7_B____ )
+		{//staff
+			return FORCE_LEVEL_2;
+		}
+		if ( anim >= BOTH_P1_S1_T_ && anim <= BOTH_H1_S1_BR )
+		{//parries, knockaways and broken parries
+			return FORCE_LEVEL_1;//FIXME: saberAnimLevel?
+		}
+		switch ( anim )
+		{
+		case BOTH_A2_STABBACK1:
+			if ( mySaberHit )
+			{//someone else hit my saber, not asking for damage level, but defense strength
+				return FORCE_LEVEL_1;
+			}
+			if ( animTimer < 450 )
+			{//end of anim
+				return FORCE_LEVEL_0;
+			}
+			else if ( animTimeElapsed < 400 )
+			{//beginning of anim
+				return FORCE_LEVEL_0;
+			}
+			return FORCE_LEVEL_3;
+			break;
+		case BOTH_ATTACK_BACK:
+			if ( animTimer < 500 )
+			{//end of anim
+				return FORCE_LEVEL_0;
+			}
+			return FORCE_LEVEL_3;
+			break;
+		case BOTH_CROUCHATTACKBACK1:
+			if ( animTimer < 800 )
+			{//end of anim
+				return FORCE_LEVEL_0;
+			}
+			return FORCE_LEVEL_3;
+			break;
+		case BOTH_BUTTERFLY_LEFT:
+		case BOTH_BUTTERFLY_RIGHT:
+		case BOTH_BUTTERFLY_FL1:
+		case BOTH_BUTTERFLY_FR1:
+			//FIXME: break up?
+			return FORCE_LEVEL_3;
+			break;
+		case BOTH_FJSS_TR_BL:
+		case BOTH_FJSS_TL_BR:
+			//FIXME: break up?
+			return FORCE_LEVEL_3;
+			break;
+		case BOTH_K1_S1_T_:	//# knockaway saber top
+		case BOTH_K1_S1_TR:	//# knockaway saber top right
+		case BOTH_K1_S1_TL:	//# knockaway saber top left
+		case BOTH_K1_S1_BL:	//# knockaway saber bottom left
+		case BOTH_K1_S1_B_:	//# knockaway saber bottom
+		case BOTH_K1_S1_BR:	//# knockaway saber bottom right
+			//FIXME: break up?
+			return FORCE_LEVEL_3;
+			break;
+		case BOTH_LUNGE2_B__T_:
+			if ( mySaberHit )
+			{//someone else hit my saber, not asking for damage level, but defense strength
+				return FORCE_LEVEL_1;
+			}
+			if ( animTimer < 400 )
+			{//end of anim
+				return FORCE_LEVEL_0;
+			}
+			else if ( animTimeElapsed < 150 )
+			{//beginning of anim
+				return FORCE_LEVEL_0;
+			}
+			return FORCE_LEVEL_3;
+			break;
+		case BOTH_FORCELEAP2_T__B_:
+			if ( animTimer < 400 )
+			{//end of anim
+				return FORCE_LEVEL_0;
+			}
+			else if ( animTimeElapsed < 550 )
+			{//beginning of anim
+				return FORCE_LEVEL_0;
+			}
+			return FORCE_LEVEL_3;
+			break;
+		case BOTH_VS_ATR_S:
+		case BOTH_VS_ATL_S:
+		case BOTH_VT_ATR_S:
+		case BOTH_VT_ATL_S:
+			return FORCE_LEVEL_3;//???
+			break;
+		case BOTH_JUMPFLIPSLASHDOWN1:
+			if ( animTimer <= 1000 )
+			{//end of anim
+				return FORCE_LEVEL_0;
+			}
+			else if ( animTimeElapsed < 600 )
+			{//beginning of anim
+				return FORCE_LEVEL_0;
+			}
+			return FORCE_LEVEL_3;
+			break;
+		case BOTH_JUMPFLIPSTABDOWN:
+			if ( animTimer <= 1300 )
+			{//end of anim
+				return FORCE_LEVEL_0;
+			}
+			else if ( animTimeElapsed <= 300 )
+			{//beginning of anim
+				return FORCE_LEVEL_0;
+			}
+			return FORCE_LEVEL_3;
+			break;
+		case BOTH_JUMPATTACK6:
+			/*
+			if (pm->ps)
+			{
+				if ( ( pm->ps->legsAnimTimer >= 1450
+						&& BG_AnimLength( g_entities[ps->clientNum].client->clientInfo.animFileIndex, BOTH_JUMPATTACK6 ) - pm->ps->legsAnimTimer >= 400 ) 
+					||(pm->ps->legsAnimTimer >= 400
+						&& BG_AnimLength( g_entities[ps->clientNum].client->clientInfo.animFileIndex, BOTH_JUMPATTACK6 ) - pm->ps->legsAnimTimer >= 1100 ) )
+				{//pretty much sideways
+					return FORCE_LEVEL_3;
+				}
+			}
+			*/
+			if ( ( animTimer >= 1450
+					&& animTimeElapsed >= 400 )
+				||(animTimer >= 400
+					&& animTimeElapsed >= 1100 ) )
+			{//pretty much sideways
+				return FORCE_LEVEL_3;
+			}
+			return FORCE_LEVEL_0;
+			break;
+		case BOTH_JUMPATTACK7:
+			if ( animTimer <= 1200 )
+			{//end of anim
+				return FORCE_LEVEL_0;
+			}
+			else if ( animTimeElapsed < 200 )
+			{//beginning of anim
+				return FORCE_LEVEL_0;
+			}
+			return FORCE_LEVEL_3;
+			break;
+		case BOTH_SPINATTACK6:
+			if ( animTimeElapsed <= 200 )
+			{//beginning of anim
+				return FORCE_LEVEL_0;
+			}
+			return FORCE_LEVEL_2;//FORCE_LEVEL_3;
+			break;
+		case BOTH_SPINATTACK7:
+			if ( animTimer <= 500 )
+			{//end of anim
+				return FORCE_LEVEL_0;
+			}
+			else if ( animTimeElapsed < 500 )
+			{//beginning of anim
+				return FORCE_LEVEL_0;
+			}
+			return FORCE_LEVEL_2;//FORCE_LEVEL_3;
+			break;
+		case BOTH_FORCELONGLEAP_ATTACK:
+			if ( animTimeElapsed <= 200 )
+			{//1st four frames of anim
+				return FORCE_LEVEL_3;
+			}
+			break;
+		/*
+		case BOTH_A7_KICK_F://these kicks attack, too
+		case BOTH_A7_KICK_B:
+		case BOTH_A7_KICK_R:
+		case BOTH_A7_KICK_L:
+			//FIXME: break up
+			return FORCE_LEVEL_3;
+			break;
+		*/
+		case BOTH_STABDOWN:
+			if ( animTimer <= 900 )
+			{//end of anim
+				return FORCE_LEVEL_3;
+			}
+			break;
+		case BOTH_STABDOWN_STAFF:
+			if ( animTimer <= 850 )
+			{//end of anim
+				return FORCE_LEVEL_3;
+			}
+			break;
+		case BOTH_STABDOWN_DUAL:
+			if ( animTimer <= 900 )
+			{//end of anim
+				return FORCE_LEVEL_3;
+			}
+			break;
+		case BOTH_A6_SABERPROTECT:
+			if ( animTimer < 650 )
+			{//end of anim
+				return FORCE_LEVEL_0;
+			}
+			else if ( animTimeElapsed < 250 )
+			{//start of anim
+				return FORCE_LEVEL_0;
+			}
+			return FORCE_LEVEL_3;
+			break;
+		case BOTH_A7_SOULCAL:
+			if ( animTimer < 650 )
+			{//end of anim
+				return FORCE_LEVEL_0;
+			}
+			else if ( animTimeElapsed < 600 )
+			{//beginning of anim
+				return FORCE_LEVEL_0;
+			}
+			return FORCE_LEVEL_3;
+			break;
+		case BOTH_A1_SPECIAL:
+			if ( animTimer < 600 )
+			{//end of anim
+				return FORCE_LEVEL_0;
+			}
+			else if ( animTimeElapsed < 200 )
+			{//beginning of anim
+				return FORCE_LEVEL_0;
+			}
+			return FORCE_LEVEL_3;
+			break;
+		case BOTH_A2_SPECIAL:
+			if ( animTimer < 300 )
+			{//end of anim
+				return FORCE_LEVEL_0;
+			}
+			else if ( animTimeElapsed < 200 )
+			{//beginning of anim
+				return FORCE_LEVEL_0;
+			}
+			return FORCE_LEVEL_3;
+			break;
+		case BOTH_A3_SPECIAL:
+			if ( animTimer < 700 )
+			{//end of anim
+				return FORCE_LEVEL_0;
+			}
+			else if ( animTimeElapsed < 200 )
+			{//beginning of anim
+				return FORCE_LEVEL_0;
+			}
+			return FORCE_LEVEL_3;
+			break;
+		case BOTH_FLIP_ATTACK7:
+			return FORCE_LEVEL_3;
+			break;
+		case BOTH_PULL_IMPALE_STAB:
+			if ( mySaberHit )
+			{//someone else hit my saber, not asking for damage level, but defense strength
+				return FORCE_LEVEL_1;
+			}
+			if ( animTimer < 1000 )
+			{//end of anim
+				return FORCE_LEVEL_0;
+			}
+			return FORCE_LEVEL_3;
+			break;
+		case BOTH_PULL_IMPALE_SWING:
+			if ( animTimer < 500 )
+			{//end of anim
+				return FORCE_LEVEL_0;
+			}
+			else if ( animTimeElapsed < 650 )
+			{//beginning of anim
+				return FORCE_LEVEL_0;
+			}
+			return FORCE_LEVEL_3;
+			break;
+		case BOTH_ALORA_SPIN_SLASH:
+			if ( animTimer < 900 )
+			{//end of anim
+				return FORCE_LEVEL_0;
+			}
+			else if ( animTimeElapsed < 250 )
+			{//beginning of anim
+				return FORCE_LEVEL_0;
+			}
+			return FORCE_LEVEL_3;
+			break;
+		case BOTH_A6_FB:
+			if ( mySaberHit )
+			{//someone else hit my saber, not asking for damage level, but defense strength
+				return FORCE_LEVEL_1;
+			}
+			if ( animTimer < 250 )
+			{//end of anim
+				return FORCE_LEVEL_0;
+			}
+			else if ( animTimeElapsed < 250 )
+			{//beginning of anim
+				return FORCE_LEVEL_0;
+			}
+			return FORCE_LEVEL_3;
+			break;
+		case BOTH_A6_LR:	
+			if ( mySaberHit )
+			{//someone else hit my saber, not asking for damage level, but defense strength
+				return FORCE_LEVEL_1;
+			}
+			if ( animTimer < 250 )
+			{//end of anim
+				return FORCE_LEVEL_0;
+			}
+			else if ( animTimeElapsed < 250 )
+			{//beginning of anim
+				return FORCE_LEVEL_0;
+			}
+			return FORCE_LEVEL_3;
+			break;
+		case BOTH_A7_HILT:
+			return FORCE_LEVEL_0;
+			break;
+	//===SABERLOCK SUPERBREAKS START===========================================================================
+		case BOTH_LK_S_DL_T_SB_1_W:
+			if ( animTimer < 700 )
+			{//end of anim
+				return FORCE_LEVEL_0;
+			}
+			return FORCE_LEVEL_5;
+			break;
+		case BOTH_LK_S_ST_S_SB_1_W:
+			if ( animTimer < 300 )
+			{//end of anim
+				return FORCE_LEVEL_0;
+			}
+			return FORCE_LEVEL_5;
+			break;
+		case BOTH_LK_S_DL_S_SB_1_W:
+		case BOTH_LK_S_S_S_SB_1_W:
+			if ( animTimer < 700 )
+			{//end of anim
+				return FORCE_LEVEL_0;
+			}
+			else if ( animTimeElapsed < 400 )
+			{//beginning of anim
+				return FORCE_LEVEL_0;
+			}
+			return FORCE_LEVEL_5;
+			break;
+		case BOTH_LK_S_ST_T_SB_1_W:
+		case BOTH_LK_S_S_T_SB_1_W:
+			if ( animTimer < 150 )
+			{//end of anim
+				return FORCE_LEVEL_0;
+			}
+			else if ( animTimeElapsed < 400 )
+			{//beginning of anim
+				return FORCE_LEVEL_0;
+			}
+			return FORCE_LEVEL_5;
+			break;
+		case BOTH_LK_DL_DL_T_SB_1_W:
+			return FORCE_LEVEL_5;
+			break;
+		case BOTH_LK_DL_DL_S_SB_1_W:
+		case BOTH_LK_DL_ST_S_SB_1_W:
+			if ( animTimeElapsed < 1000 )
+			{//beginning of anim
+				return FORCE_LEVEL_0;
+			}
+			return FORCE_LEVEL_5;
+			break;
+		case BOTH_LK_DL_ST_T_SB_1_W:
+			if ( animTimer < 950 )
+			{//end of anim
+				return FORCE_LEVEL_0;
+			}
+			else if ( animTimeElapsed < 650 )
+			{//beginning of anim
+				return FORCE_LEVEL_0;
+			}
+			return FORCE_LEVEL_5;
+			break;
+		case BOTH_LK_DL_S_S_SB_1_W:
+			if ( saberNum != 0 )
+			{//only right hand saber does damage in this suberbreak
+				return FORCE_LEVEL_0;
+			}
+			if ( animTimer < 900 )
+			{//end of anim
+				return FORCE_LEVEL_0;
+			}
+			else if ( animTimeElapsed < 450 )
+			{//beginning of anim
+				return FORCE_LEVEL_0;
+			}
+			return FORCE_LEVEL_5;
+			break;
+		case BOTH_LK_DL_S_T_SB_1_W:
+			if ( saberNum != 0 )
+			{//only right hand saber does damage in this suberbreak
+				return FORCE_LEVEL_0;
+			}
+			if ( animTimer < 250 )
+			{//end of anim
+				return FORCE_LEVEL_0;
+			}
+			else if ( animTimeElapsed < 150 )
+			{//beginning of anim
+				return FORCE_LEVEL_0;
+			}
+			return FORCE_LEVEL_5;
+			break;
+		case BOTH_LK_ST_DL_S_SB_1_W:
+			return FORCE_LEVEL_5;
+			break;
+		case BOTH_LK_ST_DL_T_SB_1_W:
+			//special suberbreak - doesn't kill, just kicks them backwards
+			return FORCE_LEVEL_0;
+			break;
+		case BOTH_LK_ST_ST_S_SB_1_W:
+		case BOTH_LK_ST_S_S_SB_1_W:
+			if ( animTimer < 800 )
+			{//end of anim
+				return FORCE_LEVEL_0;
+			}
+			else if ( animTimeElapsed < 350 )
+			{//beginning of anim
+				return FORCE_LEVEL_0;
+			}
+			return FORCE_LEVEL_5;
+			break;
+		case BOTH_LK_ST_ST_T_SB_1_W:
+		case BOTH_LK_ST_S_T_SB_1_W:
+			return FORCE_LEVEL_5;
+			break;
+	//===SABERLOCK SUPERBREAKS START===========================================================================
+		case BOTH_HANG_ATTACK:
+			//FIME: break up
+			if ( animTimer < 1000 )
+			{//end of anim
+				return FORCE_LEVEL_0;
+			}
+			else if ( animTimeElapsed < 250 )
+			{//beginning of anim
+				return FORCE_LEVEL_0;
+			}
+			else
+			{//sweet spot
+				return FORCE_LEVEL_5;
+			}
+			break;
+		case BOTH_ROLL_STAB:
+			if ( mySaberHit )
+			{//someone else hit my saber, not asking for damage level, but defense strength
+				return FORCE_LEVEL_1;
+			}
+			if ( animTimeElapsed > 400 )
+			{//end of anim
+				return FORCE_LEVEL_0;
+			}
+			else
+			{
+				return FORCE_LEVEL_3;
+			}
+			break;
+		}
+		return FORCE_LEVEL_0;
+	}
+}
+
+#define MAX_SABER_VICTIMS 16
+static int		victimEntityNum[MAX_SABER_VICTIMS];
+static float	totalDmg[MAX_SABER_VICTIMS];
+static vec3_t	dmgDir[MAX_SABER_VICTIMS];
+static vec3_t	dmgSpot[MAX_SABER_VICTIMS];
+static int numVictims = 0;
+void WP_SaberClearDamage( void )
+{
+	int ven;
+	for ( ven = 0; ven < MAX_SABER_VICTIMS; ven++ )
+	{
+		victimEntityNum[ven] = ENTITYNUM_NONE;
+	}
+	memset( totalDmg, 0, sizeof( totalDmg) );
+	memset( dmgDir, 0, sizeof( dmgDir ) );
+	memset( dmgSpot, 0, sizeof( dmgSpot ) );
+	numVictims = 0;
+}
+
+void WP_SaberDamageAdd( int trVictimEntityNum, vec3_t trDmgDir, vec3_t trDmgSpot, int trDmg )
+{
+	if ( trVictimEntityNum < 0 || trVictimEntityNum >= ENTITYNUM_WORLD )
+	{
+		return;
+	}
+	
+	if ( trDmg )
+	{//did some damage to something
+		int curVictim = 0;
+		int i;
+
+		for ( i = 0; i < numVictims; i++ )
+		{
+			if ( victimEntityNum[i] == trVictimEntityNum )
+			{//already hit this guy before
+				curVictim = i;
+				break;
+			}
+		}
+		if ( i == numVictims )
+		{//haven't hit his guy before
+			if ( numVictims + 1 >= MAX_SABER_VICTIMS )
+			{//can't add another victim at this time
+				return;
+			}
+			//add a new victim to the list
+			curVictim = numVictims;
+			victimEntityNum[numVictims++] = trVictimEntityNum;
+		}
+
+		totalDmg[curVictim] += trDmg;
+		if ( VectorCompare( dmgDir[curVictim], vec3_origin ) )
+		{
+			VectorCopy( trDmgDir, dmgDir[curVictim] );
+		}
+		if ( VectorCompare( dmgSpot[curVictim], vec3_origin ) )
+		{
+			VectorCopy( trDmgSpot, dmgSpot[curVictim] );
+		}
+	}
+}
+
+void WP_SaberApplyDamage( gentity_t *self )
+{
+	int i;
+	if ( !numVictims )
+	{
+		return;
+	}
+	for ( i = 0; i < numVictims; i++ )
+	{
+		gentity_t *te = NULL, *victim = NULL;
+		qboolean isDroid = qfalse;
+
+		victim = &g_entities[victimEntityNum[i]];
+
+// nmckenzie: SABER_DAMAGE_WALLS
+		if ( !victim->client )
+		{
+			totalDmg[i] *= g_saberWallDamageScale.value;
+		}
+
+		G_Damage( victim, self, self, dmgDir[i], dmgSpot[i], totalDmg[i], 0, MOD_SABER );
+
+		if ( victim->client )
+		{
+			class_t npc_class = victim->client->NPC_class;
+
+			if ( npc_class == CLASS_SEEKER || npc_class == CLASS_PROBE || npc_class == CLASS_MOUSE || npc_class == CLASS_REMOTE ||
+					npc_class == CLASS_GONK || npc_class == CLASS_R2D2 || npc_class == CLASS_R5D2 ||
+					npc_class == CLASS_PROTOCOL || npc_class == CLASS_MARK1 || npc_class == CLASS_MARK2 ||
+					npc_class == CLASS_INTERROGATOR || npc_class == CLASS_ATST || npc_class == CLASS_SENTRY )  
+			{ //don't make "blood" sparks for droids.
+				isDroid = qtrue;
+			}
+		}
+
+		te = G_TempEntity( dmgSpot[i], EV_SABER_HIT );
+		if ( te )
+		{
+			te->s.otherEntityNum = victimEntityNum[i];
+			te->s.otherEntityNum2 = self->s.number;
+
+			VectorCopy(dmgSpot[i], te->s.origin);
+			//VectorCopy(tr.plane.normal, te->s.angles);
+			VectorScale( dmgDir[i], -1, te->s.angles);
+			
+			if (!te->s.angles[0] && !te->s.angles[1] && !te->s.angles[2])
+			{ //don't let it play with no direction
+				te->s.angles[1] = 1;
+			}
+
+			if (!isDroid && (victim->client || victim->s.eType == ET_NPC ||
+				victim->s.eType == ET_BODY))
+			{
+				if ( totalDmg[i] < 5 )
+				{
+					te->s.eventParm = 3;
+				}
+				else if (totalDmg[i] < 20 )
+				{
+					te->s.eventParm = 2;
+				}
+				else
+				{
+					te->s.eventParm = 1;
+				}
+			}
+			else
+			{
+				if (totalDmg[i] > SABER_NONATTACK_DAMAGE)
+				{ //I suppose I could tie this into the saberblock event, but I'm tired of adding flags to that thing.
+					gentity_t *teS = G_TempEntity( te->s.origin, EV_SABER_CLASHFLARE );
+					VectorCopy(te->s.origin, teS->s.origin);
+				}
+				te->s.eventParm = 0;
+			}
+		}
+	}
+}
+
+static qboolean saberDoClashEffect = qfalse;
+static vec3_t saberClashPos = {0};
+static vec3_t saberClashNorm = {0};
+static int saberClashEventParm = 1;
+void WP_SaberDoClash( void )
+{
+	if ( saberDoClashEffect )
+	{
+		gentity_t *te = G_TempEntity( saberClashPos, EV_SABER_BLOCK );
+		VectorCopy(saberClashPos, te->s.origin);
+		VectorCopy(saberClashNorm, te->s.angles);
+		te->s.eventParm = saberClashEventParm;
+	}
+}
+
+static qboolean saberHitWall = qfalse;
+static qboolean saberHitSaber = qfalse;
+static float saberHitFraction = 1.0f;
+//rww - MP version of the saber damage function. This is where all the things like blocking, triggering a parry,
+//triggering a broken parry, doing actual damage, etc. are done for the saber. It doesn't resemble the SP
+//version very much, but functionality is (hopefully) about the same.
+//This is a large function. I feel sort of bad inlining it. But it does get called tons of times per frame.
+#include "../namespace_begin.h"
+qboolean BG_SuperBreakWinAnim( int anim );
+#include "../namespace_end.h"
+
+static GAME_INLINE qboolean CheckSaberDamage(gentity_t *self, int rSaberNum, int rBladeNum, vec3_t saberStart, vec3_t saberEnd, qboolean doInterpolate, int trMask, qboolean extrapolate )
+{
+	static trace_t tr;
+	static vec3_t dir;
+	static vec3_t saberTrMins, saberTrMaxs;
+	static vec3_t lastValidStart;
+	static vec3_t lastValidEnd;
+	static int selfSaberLevel;
+	static int otherSaberLevel;
+	int dmg = 0;
+	int attackStr = 0;
+	float saberBoxSize = d_saberBoxTraceSize.value;
+	qboolean idleDamage = qfalse;
+	qboolean didHit = qfalse;
+	qboolean sabersClashed = qfalse;
+	qboolean unblockable = qfalse;
+	qboolean didDefense = qfalse;
+	qboolean didOffense = qfalse;
+	qboolean saberTraceDone = qfalse;
+	qboolean otherUnblockable = qfalse;
+	qboolean tryDeflectAgain = qfalse;
+
+	gentity_t *otherOwner;
+
+	if (BG_SabersOff( &self->client->ps ))
+	{
+		return qfalse;
+	}
+
+	selfSaberLevel = G_SaberAttackPower(self, SaberAttacking(self));
+
+	//Add the standard radius into the box size
+	saberBoxSize += (self->client->saber[rSaberNum].blade[rBladeNum].radius*0.5f);
+
+	if (self->client->ps.weaponTime <= 0)
+	{ //if not doing any attacks or anything, just use point traces.
+		VectorClear(saberTrMins);
+		VectorClear(saberTrMaxs);
+	}
+	else if (d_saberGhoul2Collision.integer)
+	{
+		if ( d_saberSPStyleDamage.integer )
+		{//SP-size saber damage traces
+			VectorSet(saberTrMins, -2, -2, -2 );
+			VectorSet(saberTrMaxs, 2, 2, 2 );
+		}
+		else
+		{
+			VectorSet(saberTrMins, -saberBoxSize*3, -saberBoxSize*3, -saberBoxSize*3);
+			VectorSet(saberTrMaxs, saberBoxSize*3, saberBoxSize*3, saberBoxSize*3);
+		}
+	}
+	else if (self->client->ps.fd.saberAnimLevel < FORCE_LEVEL_2)
+	{ //box trace for fast, because it doesn't get updated so often
+		VectorSet(saberTrMins, -saberBoxSize, -saberBoxSize, -saberBoxSize);
+		VectorSet(saberTrMaxs, saberBoxSize, saberBoxSize, saberBoxSize);
+	}
+	else if (d_saberAlwaysBoxTrace.integer)
+	{
+		VectorSet(saberTrMins, -saberBoxSize, -saberBoxSize, -saberBoxSize);
+		VectorSet(saberTrMaxs, saberBoxSize, saberBoxSize, saberBoxSize);
+	}
+	else
+	{ //just trace the minimum blade radius
+		saberBoxSize = (self->client->saber[rSaberNum].blade[rBladeNum].radius*0.4f);
+
+		VectorSet(saberTrMins, -saberBoxSize, -saberBoxSize, -saberBoxSize);
+		VectorSet(saberTrMaxs, saberBoxSize, saberBoxSize, saberBoxSize);
+	}
+
+	while (!saberTraceDone)
+	{
+		if ( doInterpolate
+			&& !d_saberSPStyleDamage.integer )
+		{ //This didn't quite work out like I hoped. But it's better than nothing. Sort of.
+			vec3_t oldSaberStart, oldSaberEnd, saberDif, oldSaberDif;
+			int traceTests = 0;
+			float trDif = 8;
+
+			VectorCopy(self->client->saber[rSaberNum].blade[rBladeNum].trail.base, oldSaberStart);
+			VectorCopy(self->client->saber[rSaberNum].blade[rBladeNum].trail.tip, oldSaberEnd);
+
+			VectorSubtract(saberStart, saberEnd, saberDif);
+			VectorSubtract(oldSaberStart, oldSaberEnd, oldSaberDif);
+
+			VectorNormalize(saberDif);
+			VectorNormalize(oldSaberDif);
+
+			saberEnd[0] = saberStart[0] - (saberDif[0]*trDif);
+			saberEnd[1] = saberStart[1] - (saberDif[1]*trDif);
+			saberEnd[2] = saberStart[2] - (saberDif[2]*trDif);
+
+			oldSaberEnd[0] = oldSaberStart[0] - (oldSaberDif[0]*trDif);
+			oldSaberEnd[1] = oldSaberStart[1] - (oldSaberDif[1]*trDif);
+			oldSaberEnd[2] = oldSaberStart[2] - (oldSaberDif[2]*trDif);
+
+			trap_Trace(&tr, saberEnd, saberTrMins, saberTrMaxs, saberStart, self->s.number, trMask);
+
+			VectorCopy(saberEnd, lastValidStart);
+			VectorCopy(saberStart, lastValidEnd);
+			if (tr.entityNum < MAX_CLIENTS)
+			{
+				G_G2TraceCollide(&tr, lastValidStart, lastValidEnd, saberTrMins, saberTrMaxs);
+			}
+			else if (tr.entityNum < ENTITYNUM_WORLD)
+			{
+				gentity_t *trHit = &g_entities[tr.entityNum];
+
+				if (trHit->inuse && trHit->ghoul2)
+				{ //hit a non-client entity with a g2 instance
+					G_G2TraceCollide(&tr, lastValidStart, lastValidEnd, saberTrMins, saberTrMaxs);
+				}
+			}
+
+			trDif++;
+
+			while (tr.fraction == 1.0 && traceTests < 4 && tr.entityNum >= ENTITYNUM_NONE)
+			{
+				VectorCopy(self->client->saber[rSaberNum].blade[rBladeNum].trail.base, oldSaberStart);
+				VectorCopy(self->client->saber[rSaberNum].blade[rBladeNum].trail.tip, oldSaberEnd);
+
+				VectorSubtract(saberStart, saberEnd, saberDif);
+				VectorSubtract(oldSaberStart, oldSaberEnd, oldSaberDif);
+
+				VectorNormalize(saberDif);
+				VectorNormalize(oldSaberDif);
+
+				saberEnd[0] = saberStart[0] - (saberDif[0]*trDif);
+				saberEnd[1] = saberStart[1] - (saberDif[1]*trDif);
+				saberEnd[2] = saberStart[2] - (saberDif[2]*trDif);
+
+				oldSaberEnd[0] = oldSaberStart[0] - (oldSaberDif[0]*trDif);
+				oldSaberEnd[1] = oldSaberStart[1] - (oldSaberDif[1]*trDif);
+				oldSaberEnd[2] = oldSaberStart[2] - (oldSaberDif[2]*trDif);
+
+				trap_Trace(&tr, saberEnd, saberTrMins, saberTrMaxs, saberStart, self->s.number, trMask);
+				
+				VectorCopy(saberEnd, lastValidStart);
+				VectorCopy(saberStart, lastValidEnd);
+				if (tr.entityNum < MAX_CLIENTS)
+				{
+					G_G2TraceCollide(&tr, lastValidStart, lastValidEnd, saberTrMins, saberTrMaxs);
+				}
+				else if (tr.entityNum < ENTITYNUM_WORLD)
+				{
+					gentity_t *trHit = &g_entities[tr.entityNum];
+
+					if (trHit->inuse && trHit->ghoul2)
+					{ //hit a non-client entity with a g2 instance
+						G_G2TraceCollide(&tr, lastValidStart, lastValidEnd, saberTrMins, saberTrMaxs);
+					}
+				}
+
+				traceTests++;
+				trDif += 8;
+			}
+		}
+		else
+		{
+			vec3_t saberEndExtrapolated;
+			if ( extrapolate )
+			{//extrapolate 16
+				vec3_t diff;
+				VectorSubtract( saberEnd, saberStart, diff );
+				VectorNormalize( diff );
+				VectorMA( saberStart, SABER_EXTRAPOLATE_DIST, diff, saberEndExtrapolated );
+			}
+			else
+			{
+				VectorCopy( saberEnd, saberEndExtrapolated );
+			}
+			trap_Trace(&tr, saberStart, saberTrMins, saberTrMaxs, saberEndExtrapolated, self->s.number, trMask);
+
+			VectorCopy(saberStart, lastValidStart);
+			VectorCopy(saberEndExtrapolated, lastValidEnd);
+			/*
+			if ( tr.allsolid || tr.startsolid )
+			{
+				if ( tr.entityNum == ENTITYNUM_NONE )
+				{
+					qboolean whah = qtrue;
+				}
+				Com_Printf( "saber trace start/all solid - ent is %d\n", tr.entityNum );
+			}
+			*/
+			if (tr.entityNum < MAX_CLIENTS)
+			{
+				G_G2TraceCollide(&tr, lastValidStart, lastValidEnd, saberTrMins, saberTrMaxs);
+			}
+			else if (tr.entityNum < ENTITYNUM_WORLD)
+			{
+				gentity_t *trHit = &g_entities[tr.entityNum];
+
+				if (trHit->inuse && trHit->ghoul2)
+				{ //hit a non-client entity with a g2 instance
+					G_G2TraceCollide(&tr, lastValidStart, lastValidEnd, saberTrMins, saberTrMaxs);
+				}
+			}
+		}
+
+		saberTraceDone = qtrue;
+	}
+
+	if ( (SaberAttacking(self) 
+			|| BG_SuperBreakWinAnim(self->client->ps.torsoAnim)
+			|| (d_saberSPStyleDamage.integer&&self->client->ps.saberInFlight&&rSaberNum==0)
+			|| (self->client->ps.m_iVehicleNum && self->client->ps.saberMove > LS_READY) ) &&
+		self->client->ps.saberAttackWound < level.time )
+	{ //this animation is that of the last attack movement, and so it should do full damage
+		qboolean saberInSpecial = BG_SaberInSpecial(self->client->ps.saberMove);
+		qboolean inBackAttack = G_SaberInBackAttack(self->client->ps.saberMove);
+
+		if ( d_saberSPStyleDamage.integer )
+		{
+			float fDmg = 0.0f;
+			if ( self->client->ps.saberInFlight )
+			{
+				gentity_t *saberEnt = &g_entities[self->client->ps.saberEntityNum];
+				if ( !saberEnt 
+					|| !saberEnt->s.saberInFlight )
+				{//does less damage on the way back
+					fDmg = 1.0f;
+					attackStr = FORCE_LEVEL_0;
+				}
+				else
+				{
+					fDmg = 2.5f*self->client->ps.fd.forcePowerLevel[FP_SABERTHROW];
+					attackStr = FORCE_LEVEL_1;
+				}
+			}
+			else
+			{
+				attackStr = G_PowerLevelForSaberAnim( self, rSaberNum, qfalse );
+				if ( g_saberRealisticCombat.integer )
+				{
+					switch ( attackStr )
+					{
+					default:
+					case FORCE_LEVEL_3:
+						fDmg = 10.0f;
+						break;
+					case FORCE_LEVEL_2:
+						fDmg = 5.0f;
+						break;
+					case FORCE_LEVEL_1:
+					case FORCE_LEVEL_0:
+						fDmg = 2.5f;
+						break;
+					}
+				}
+				else
+				{
+					if ( self->client->ps.torsoAnim == BOTH_SPINATTACK6
+						|| self->client->ps.torsoAnim == BOTH_SPINATTACK7 )
+					{//too easy to do, lower damage
+						fDmg = 2.5f;
+					}
+					else
+					{
+						fDmg = 2.5f * (float)attackStr;
+					}
+				}
+			}
+			if ( g_saberRealisticCombat.integer > 1 )
+			{//always do damage, and lots of it
+				if ( g_saberRealisticCombat.integer > 2 )
+				{//always do damage, and lots of it
+					fDmg = 25.0f;
+				}
+				else if ( fDmg > 0.1f )
+				{//only do super damage if we would have done damage according to normal rules
+					fDmg = 25.0f;
+				}
+			}
+			/*
+			if ( dmg > 0.1f )
+			{
+				if ( (self->client->ps.forcePowersActive&(1<<FP_RAGE)) )
+				{//add some damage if raged
+					dmg += self->client->ps.forcePowerLevel[FP_RAGE] * 5.0f;
+				}
+				else if ( self->client->ps.forceRageRecoveryTime )
+				{//halve it if recovering
+					dmg *= 0.5f;
+				}
+			}
+			*/
+			if ( g_gametype.integer != GT_DUEL
+				&& g_gametype.integer != GT_POWERDUEL
+				&& g_gametype.integer != GT_SIEGE )
+			{//in faster-paced games, sabers do more damage
+				fDmg *= 2.0f;
+			}
+			if ( fDmg )
+			{//the longer the trace, the more damage it does
+				//FIXME: in SP, we only use the part of the trace that's actually *inside* the hit ent...
+				float traceLength = Distance( saberEnd, saberStart );
+				if ( tr.fraction >= 1.0f )
+				{//allsolid?
+					dmg = ceil( fDmg*traceLength*0.1f*0.33f );
+				}
+				else
+				{//fractional hit, the sooner you hit in the trace, the more damage you did
+					dmg = ceil( fDmg*traceLength*(1.0f-tr.fraction)*0.1f*0.33f );//(1.0f-tr.fraction) isn't really accurate, but kind of simulates what we have in SP
+				}
+#ifdef DEBUG_SABER_BOX
+				if ( g_saberDebugBox.integer == 3 || g_saberDebugBox.integer == 4 )
+				{
+					G_TestLine( saberStart, saberEnd, 0x0000ff, 50 );
+				}
+#endif
+			}
+			/*
+			if ( dmg )
+			{
+				Com_Printf("CL %i SABER DMG: %i, anim %s, torsoTimer %i\n", self->s.number, dmg, animTable[self->client->ps.torsoAnim].name, self->client->ps.torsoTimer );
+			}
+			*/
+			if ( self->client->ps.torsoAnim == BOTH_A1_SPECIAL
+				|| self->client->ps.torsoAnim == BOTH_A2_SPECIAL
+				|| self->client->ps.torsoAnim == BOTH_A3_SPECIAL )
+			{//parry/block/break-parry bonus for single-style kata moves
+				attackStr++;
+			}
+			if ( BG_SuperBreakWinAnim( self->client->ps.torsoAnim ) )
+			{
+				trMask &= ~CONTENTS_LIGHTSABER;
+			}
+		}
+		else
+		{
+			dmg = SABER_HITDAMAGE;
+
+			if (self->client->ps.fd.saberAnimLevel == SS_STAFF ||
+				self->client->ps.fd.saberAnimLevel == SS_DUAL)
+			{
+				if (saberInSpecial)
+				{
+					//it will get auto-ramped based on the point in the attack, later on
+					if (self->client->ps.saberMove == LS_SPINATTACK ||
+						self->client->ps.saberMove == LS_SPINATTACK_DUAL)
+					{ //these attacks are long and have the potential to hit a lot so they will do less damage.
+						dmg = 10;
+					}
+					else
+					{
+						if ( BG_KickingAnim( self->client->ps.legsAnim ) ||
+							BG_KickingAnim( self->client->ps.torsoAnim ) )
+						{ //saber shouldn't do more than min dmg during kicks
+							dmg = 2;
+						}
+						else if (BG_SaberInKata(self->client->ps.saberMove))
+						{ //special kata move
+							if (self->client->ps.fd.saberAnimLevel == SS_DUAL)
+							{ //this is the nasty saber twirl, do big damage cause it makes you vulnerable
+								dmg = 90;
+							}
+							else
+							{ //staff kata
+								dmg = G_GetAttackDamage(self, 60, 70, 0.5f);
+							}
+						}
+						else
+						{
+							//dmg = 90;
+							//ramp from 2 to 90 by default for other specials
+							dmg = G_GetAttackDamage(self, 2, 90, 0.5f);
+						}
+					}
+				}
+				else
+				{ //otherwise we'll ramp up to 70 I guess, for both dual and staff
+					dmg = G_GetAttackDamage(self, 2, 70, 0.5f);
+				}
+			}
+			else if (self->client->ps.fd.saberAnimLevel == 3)
+			{
+				//new damage-ramping system
+				if (!saberInSpecial && !inBackAttack)
+				{
+					dmg = G_GetAttackDamage(self, 2, 120, 0.5f);
+				}
+				else if (saberInSpecial &&
+						(self->client->ps.saberMove == LS_A_JUMP_T__B_))
+				{
+					dmg = G_GetAttackDamage(self, 2, 180, 0.65f);
+				}
+				else if (inBackAttack)
+				{
+					dmg = G_GetAttackDamage(self, 2, 30, 0.5f); //can hit multiple times (and almost always does), so..
+				}
+				else
+				{
+					dmg = 100;
+				}
+			}
+			else if (self->client->ps.fd.saberAnimLevel == 2)
+			{
+				if (saberInSpecial &&
+					(self->client->ps.saberMove == LS_A_FLIP_STAB || self->client->ps.saberMove == LS_A_FLIP_SLASH))
+				{ //a well-timed hit with this can do a full 85
+					dmg = G_GetAttackDamage(self, 2, 80, 0.5f);
+				}
+				else if (inBackAttack)
+				{
+					dmg = G_GetAttackDamage(self, 2, 25, 0.5f);
+				}
+				else
+				{
+					dmg = 60;
+				}
+			}
+			else if (self->client->ps.fd.saberAnimLevel == 1)
+			{
+				if (saberInSpecial &&
+					(self->client->ps.saberMove == LS_A_LUNGE))
+				{
+					dmg = G_GetAttackDamage(self, 2, SABER_HITDAMAGE-5, 0.3f);
+				}
+				else if (inBackAttack)
+				{
+					dmg = G_GetAttackDamage(self, 2, 30, 0.5f);
+				}
+				else
+				{
+					dmg = SABER_HITDAMAGE;
+				}
+			}
+
+			attackStr = self->client->ps.fd.saberAnimLevel;
+		}
+	}
+	else if (self->client->ps.saberAttackWound < level.time &&
+		self->client->ps.saberIdleWound < level.time)
+	{ //just touching, do minimal damage and only check for it every 200ms (mainly to cut down on network traffic for hit events)
+		trMask &= ~CONTENTS_LIGHTSABER;
+		if ( d_saberSPStyleDamage.integer )
+		{
+			if ( BG_SaberInReturn( self->client->ps.saberMove ) )
+			{
+				dmg = SABER_NONATTACK_DAMAGE;
+			}
+			else
+			{
+				if (d_saberSPStyleDamage.integer == 2)
+				{
+					dmg = SABER_NONATTACK_DAMAGE;
+				}
+				else
+				{
+					dmg = 0;
+				}
+			}
+		}
+		else
+		{
+			dmg = SABER_NONATTACK_DAMAGE;
+		}
+		idleDamage = qtrue;
+	}
+	else
+	{
+		return qtrue; //true cause even though we didn't get a hit, we don't want to do those extra traces because the debounce time says not to.
+	}
+
+	if (BG_SaberInSpecial(self->client->ps.saberMove))
+	{
+		qboolean inBackAttack = G_SaberInBackAttack(self->client->ps.saberMove);
+
+		unblockable = qtrue;
+		self->client->ps.saberBlocked = 0;
+
+		if ( d_saberSPStyleDamage.integer )
+		{
+		}
+		else if (!inBackAttack)
+		{
+			if (self->client->ps.saberMove == LS_A_JUMP_T__B_)
+			{ //do extra damage for special unblockables
+				dmg += 5; //This is very tiny, because this move has a huge damage ramp
+			}
+			else if (self->client->ps.saberMove == LS_A_FLIP_STAB || self->client->ps.saberMove == LS_A_FLIP_SLASH)
+			{
+				dmg += 5; //ditto
+				if (dmg <= 40 || G_GetAnimPoint(self) <= 0.4f)
+				{ //sort of a hack, don't want it doing big damage in the off points of the anim
+					dmg = 2;
+				}
+			}
+			else if (self->client->ps.saberMove == LS_A_LUNGE)
+			{
+				dmg += 2; //and ditto again
+				if (G_GetAnimPoint(self) <= 0.4f)
+				{ //same as above
+					dmg = 2;
+				}
+			}
+			else if (self->client->ps.saberMove == LS_SPINATTACK ||
+				self->client->ps.saberMove == LS_SPINATTACK_DUAL)
+			{ //do a constant significant amount of damage but ramp up a little to the mid-point
+				dmg = G_GetAttackDamage(self, 2, dmg+3, 0.5f);
+				dmg += 10;
+			}
+			else
+			{
+				//dmg += 20;
+				if ( BG_KickingAnim( self->client->ps.legsAnim ) ||
+					BG_KickingAnim( self->client->ps.torsoAnim ) )
+				{ //saber shouldn't do more than min dmg during kicks
+					dmg = 2;
+				}
+				else
+				{ //auto-ramp it I guess since it's a special we don't have a special case for.
+					dmg = G_GetAttackDamage(self, 5, dmg+5, 0.5f);
+				}
+			}
+		}
+	}
+
+	if (!dmg)
+	{
+		if (tr.entityNum < MAX_CLIENTS ||
+			(g_entities[tr.entityNum].inuse && (g_entities[tr.entityNum].r.contents & CONTENTS_LIGHTSABER)))
+		{
+			return qtrue;
+		}
+		return qfalse;
+	}
+
+	if (dmg > SABER_NONATTACK_DAMAGE)
+	{
+		dmg *= g_saberDamageScale.value;
+
+		if ((self->client->ps.brokenLimbs & (1 << BROKENLIMB_RARM)) ||
+			(self->client->ps.brokenLimbs & (1 << BROKENLIMB_LARM)))
+		{ //weaken it if an arm is broken
+			dmg *= 0.3;
+			if (dmg <= SABER_NONATTACK_DAMAGE)
+			{
+				dmg = SABER_NONATTACK_DAMAGE+1;
+			}
+		}
+	}
+
+	if (dmg > SABER_NONATTACK_DAMAGE && self->client->ps.isJediMaster)
+	{ //give the Jedi Master more saber attack power
+		dmg *= 2;
+	}
+
+	if (dmg > SABER_NONATTACK_DAMAGE && g_gametype.integer == GT_SIEGE &&
+		self->client->siegeClass != -1 && (bgSiegeClasses[self->client->siegeClass].classflags & (1<<CFL_MORESABERDMG)))
+	{ //this class is flagged to do extra saber damage. I guess 2x will do for now.
+		dmg *= 2;
+	}
+
+	if (g_gametype.integer == GT_POWERDUEL &&
+		self->client->sess.duelTeam == DUELTEAM_LONE)
+	{ //always x2 when we're powerdueling alone... er, so, we apparently no longer want this?  So they say.
+		if ( g_duel_fraglimit.integer )
+		{
+			//dmg *= 1.5 - (.4 * (float)self->client->sess.wins / (float)g_duel_fraglimit.integer);
+				
+		}
+		//dmg *= 2;
+	}
+
+#ifndef FINAL_BUILD
+	if (g_saberDebugPrint.integer > 2 && dmg > 1)
+	{
+		Com_Printf("CL %i SABER DMG: %i\n", self->s.number, dmg);
+	}
+#endif
+
+	VectorSubtract(saberEnd, saberStart, dir);
+	VectorNormalize(dir);
+
+	if (tr.entityNum == ENTITYNUM_WORLD ||
+		g_entities[tr.entityNum].s.eType == ET_TERRAIN)
+	{ //register this as a wall hit for jedi AI
+        self->client->ps.saberEventFlags |= SEF_HITWALL;
+		saberHitWall = qtrue;
+	}
+
+	//rww - I'm saying || tr.startsolid here, because otherwise your saber tends to skip positions and go through
+	//people, and the compensation traces start in their bbox too. Which results in the saber passing through people
+	//when you visually cut right through them. Which sucks.
+
+	if ((tr.fraction != 1 || tr.startsolid) &&
+		g_entities[tr.entityNum].takedamage &&
+		(g_entities[tr.entityNum].health > 0 || !(g_entities[tr.entityNum].s.eFlags & EF_DISINTEGRATION)) &&
+		tr.entityNum != self->s.number &&
+		g_entities[tr.entityNum].inuse)
+	{//hit something that had health and takes damage
+		if (idleDamage &&
+			g_entities[tr.entityNum].client &&
+			OnSameTeam(self, &g_entities[tr.entityNum]) &&
+			!g_friendlySaber.integer)
+		{
+			return qfalse;
+		}
+
+		if (g_entities[tr.entityNum].client &&
+			g_entities[tr.entityNum].client->ps.duelInProgress &&
+			g_entities[tr.entityNum].client->ps.duelIndex != self->s.number)
+		{
+			return qfalse;
+		}
+
+		if (g_entities[tr.entityNum].client &&
+			self->client->ps.duelInProgress &&
+			self->client->ps.duelIndex != g_entities[tr.entityNum].s.number)
+		{
+			return qfalse;
+		}
+
+		if ( BG_StabDownAnim( self->client->ps.torsoAnim )
+			&& g_entities[tr.entityNum].client 
+			&& !BG_InKnockDownOnGround( &g_entities[tr.entityNum].client->ps ) )
+		{//stabdowns only damage people who are actually on the ground...
+			return qfalse;
+		}
+		self->client->ps.saberIdleWound = level.time + g_saberDmgDelay_Idle.integer;
+
+		didHit = qtrue;
+
+		if ( !d_saberSPStyleDamage.integer//let's trying making blocks have to be blocked by a saber
+			&& g_entities[tr.entityNum].client 
+			&& !unblockable 
+			&& WP_SaberCanBlock(&g_entities[tr.entityNum], tr.endpos, 0, MOD_SABER, qfalse, attackStr))
+		{//hit a client who blocked the attack (fake: didn't actually hit their saber)
+			if (dmg <= SABER_NONATTACK_DAMAGE)
+			{
+				self->client->ps.saberIdleWound = level.time + g_saberDmgDelay_Idle.integer;
+			}
+			saberDoClashEffect = qtrue;
+			VectorCopy( tr.endpos, saberClashPos );
+			VectorCopy( tr.endpos, saberClashNorm );
+			saberClashEventParm = 1;
+
+			if (dmg > SABER_NONATTACK_DAMAGE)
+			{
+				int lockFactor = g_saberLockFactor.integer;
+
+				if ((g_entities[tr.entityNum].client->ps.fd.forcePowerLevel[FP_SABER_OFFENSE] - self->client->ps.fd.forcePowerLevel[FP_SABER_OFFENSE]) > 1 &&
+					Q_irand(1, 10) < lockFactor*2)
+				{ //Just got blocked by someone with a decently higher attack level, so enter into a lock (where they have the advantage due to a higher attack lev)
+					if (!G_ClientIdleInWorld(&g_entities[tr.entityNum]))
+					{
+						if ( (trMask&CONTENTS_LIGHTSABER)
+							&& WP_SabersCheckLock(self, &g_entities[tr.entityNum]))
+						{	
+							self->client->ps.saberBlocked = BLOCKED_NONE;
+							g_entities[tr.entityNum].client->ps.saberBlocked = BLOCKED_NONE;
+							return didHit;
+						}
+					}
+				}
+				else if (Q_irand(1, 20) < lockFactor)
+				{
+					if (!G_ClientIdleInWorld(&g_entities[tr.entityNum]))
+					{
+						if ((trMask&CONTENTS_LIGHTSABER)
+							&& WP_SabersCheckLock(self, &g_entities[tr.entityNum]))
+						{	
+							self->client->ps.saberBlocked = BLOCKED_NONE;
+							g_entities[tr.entityNum].client->ps.saberBlocked = BLOCKED_NONE;
+							return didHit;
+						}
+					}
+				}
+			}
+			otherOwner = &g_entities[tr.entityNum];
+			goto blockStuff;
+		}
+		else
+		{//damage the thing we hit
+			if (g_entities[tr.entityNum].client 
+				&& !g_entities[tr.entityNum].client->ps.weapon != WP_SABER )//fd.forcePowerLevel[FP_SABER_OFFENSE])
+			{ //not a "jedi", so make them suffer more
+				if ( dmg > SABER_NONATTACK_DAMAGE )
+				{ //don't bother increasing just for idle touch damage
+					dmg *= 1.5;
+				}
+			}
+
+			if ( !d_saberSPStyleDamage.integer )
+			{
+				if (g_entities[tr.entityNum].client && g_entities[tr.entityNum].client->ps.weapon == WP_SABER)
+				{ //for jedi using the saber, half the damage (this comes with the increased default dmg debounce time)
+					if (g_gametype.integer != GT_SIEGE)
+					{ //unless siege..
+						if (dmg > SABER_NONATTACK_DAMAGE && !unblockable)
+						{ //don't reduce damage if it's only 1, or if this is an unblockable attack
+							if (dmg == SABER_HITDAMAGE)
+							{ //level 1 attack
+								dmg *= 0.7;
+							}
+							else
+							{
+								dmg *= 0.5;
+							}
+						}
+					}
+				}
+			}
+
+			if (self->s.eType == ET_NPC &&
+				g_entities[tr.entityNum].client &&
+				self->client->playerTeam == g_entities[tr.entityNum].client->playerTeam)
+			{ //Oops. Since he's an NPC, we'll be forgiving and cut the damage down.
+				dmg *= 0.2f;
+			}
+
+			//store the damage, we'll apply it later
+			WP_SaberDamageAdd( tr.entityNum, dir, tr.endpos, dmg );
+
+			if (g_entities[tr.entityNum].client)
+			{
+				//Let jedi AI know if it hit an enemy
+				if ( self->enemy && self->enemy == &g_entities[tr.entityNum] )
+				{
+					self->client->ps.saberEventFlags |= SEF_HITENEMY;
+				}
+				else
+				{
+                    self->client->ps.saberEventFlags |= SEF_HITOBJECT;
+				}
+			}
+
+			if ( d_saberSPStyleDamage.integer )
+			{
+			}
+			else
+			{
+				self->client->ps.saberAttackWound = level.time + 100;
+			}
+		}
+	}
+	else if ((tr.fraction != 1 || tr.startsolid) &&
+		(g_entities[tr.entityNum].r.contents & CONTENTS_LIGHTSABER) &&
+		g_entities[tr.entityNum].r.contents != -1 &&
+		g_entities[tr.entityNum].inuse)
+	{ //saber clash
+		otherOwner = &g_entities[g_entities[tr.entityNum].r.ownerNum];
+
+		if (!otherOwner->inuse || !otherOwner->client)
+		{
+			return qfalse;
+		}
+
+		if ( otherOwner 
+			&& otherOwner->client 
+			&& otherOwner->client->ps.saberInFlight )
+		{//don't do extra collision checking vs sabers in air
+		}
+		else
+		{//hit an in-hand saber, do extra collision check against it
+			if ( d_saberSPStyleDamage.integer )
+			{//use SP-style blade-collision test
+				if ( !WP_SabersIntersect( self, rSaberNum, rBladeNum, otherOwner, qfalse ) )
+				{//sabers did not actually intersect
+					return qfalse;
+				}
+			}
+			else
+			{//MP-style
+				if (!G_SaberCollide(self, otherOwner, lastValidStart,
+					lastValidEnd, saberTrMins, saberTrMaxs, tr.endpos))
+				{ //detailed collision did not produce results...
+					return qfalse;
+				}
+			}
+		}
+
+		if (OnSameTeam(self, otherOwner) &&
+			!g_friendlySaber.integer)
+		{
+			return qfalse;
+		}
+
+		if ((self->s.eType == ET_NPC || otherOwner->s.eType == ET_NPC) && //just make sure one of us is an npc
+			self->client->playerTeam == otherOwner->client->playerTeam &&
+			g_gametype.integer != GT_SIEGE)
+		{ //don't hit your teammate's sabers if you are an NPC. It can be rather annoying.
+			return qfalse;
+		}
+
+		if (otherOwner->client->ps.duelInProgress &&
+			otherOwner->client->ps.duelIndex != self->s.number)
+		{
+			return qfalse;
+		}
+
+		if (self->client->ps.duelInProgress &&
+			self->client->ps.duelIndex != otherOwner->s.number)
+		{
+			return qfalse;
+		}
+
+		if ( g_debugSaberLocks.integer )
+		{
+			WP_SabersCheckLock2( self, otherOwner, LOCK_RANDOM );
+			return qtrue;
+		}
+		didHit = qtrue;
+		self->client->ps.saberIdleWound = level.time + g_saberDmgDelay_Idle.integer;
+
+		if (dmg <= SABER_NONATTACK_DAMAGE)
+		{
+			self->client->ps.saberIdleWound = level.time + g_saberDmgDelay_Idle.integer;
+		}
+
+		saberDoClashEffect = qtrue;
+		VectorCopy( tr.endpos, saberClashPos );
+		VectorCopy( tr.endpos, saberClashNorm );
+		saberClashEventParm = 1;
+
+		sabersClashed = qtrue;
+		saberHitSaber = qtrue;
+		saberHitFraction = tr.fraction;
+
+		if (saberCheckKnockdown_Smashed(&g_entities[tr.entityNum], otherOwner, self, dmg))
+		{ //smashed it out of the air
+			return qfalse;
+		}
+
+		//is this my thrown saber?
+		if ( self->client->ps.saberEntityNum
+			&& self->client->ps.saberInFlight
+			&& rSaberNum == 0
+			&& saberCheckKnockdown_Smashed( &g_entities[self->client->ps.saberEntityNum], self, otherOwner, dmg))
+		{ //they smashed it out of the air
+			return qfalse;
+		}
+
+blockStuff:
+		otherUnblockable = qfalse;
+
+		if (otherOwner && otherOwner->client && otherOwner->client->ps.saberInFlight)
+		{
+			return qfalse;
+		}
+
+		//this is a thrown saber, don't do any fancy saber-saber collision stuff
+		if ( self->client->ps.saberEntityNum
+			&& self->client->ps.saberInFlight
+			&& rSaberNum == 0 )
+		{
+			return qfalse;
+		}
+
+		otherSaberLevel = G_SaberAttackPower(otherOwner, SaberAttacking(otherOwner));
+
+		if (dmg > SABER_NONATTACK_DAMAGE && !unblockable && !otherUnblockable)
+		{
+			int lockFactor = g_saberLockFactor.integer;
+
+			if (sabersClashed && Q_irand(1, 20) <= lockFactor)
+			{
+				if (!G_ClientIdleInWorld(otherOwner))
+				{
+					if (WP_SabersCheckLock(self, otherOwner))
+					{
+						self->client->ps.saberBlocked = BLOCKED_NONE;
+						otherOwner->client->ps.saberBlocked = BLOCKED_NONE;
+						return didHit;
+					}
+				}
+			}
+		}
+
+		if (!otherOwner || !otherOwner->client)
+		{
+			return didHit;
+		}
+
+		if (BG_SaberInSpecial(otherOwner->client->ps.saberMove))
+		{
+			otherUnblockable = qtrue;
+			otherOwner->client->ps.saberBlocked = 0;
+		}
+
+		if ( sabersClashed &&
+			dmg > SABER_NONATTACK_DAMAGE &&
+			 selfSaberLevel < FORCE_LEVEL_3 &&
+			 !PM_SaberInBounce(otherOwner->client->ps.saberMove) &&
+			 !PM_SaberInParry(self->client->ps.saberMove) &&
+			 !PM_SaberInBrokenParry(self->client->ps.saberMove) &&
+			 !BG_SaberInSpecial(self->client->ps.saberMove) &&
+			 !PM_SaberInBounce(self->client->ps.saberMove) &&
+			 !PM_SaberInDeflect(self->client->ps.saberMove) &&
+			 !PM_SaberInReflect(self->client->ps.saberMove) &&
+			 !unblockable )
+		{
+			//if (Q_irand(1, 10) <= 6)
+			if (1) //for now, just always try a deflect. (deflect func can cause bounces too)
+			{
+				if (!WP_GetSaberDeflectionAngle(self, otherOwner, tr.fraction))
+				{
+					tryDeflectAgain = qtrue; //Failed the deflect, try it again if we can if the guy we're smashing goes into a parry and we don't break it
+				}
+				else
+				{
+					self->client->ps.saberBlocked = BLOCKED_BOUNCE_MOVE;
+					didOffense = qtrue;
+				}
+			}
+			else
+			{
+				self->client->ps.saberBlocked = BLOCKED_ATK_BOUNCE;
+				didOffense = qtrue;
+
+#ifndef FINAL_BUILD
+				if (g_saberDebugPrint.integer)
+				{
+					Com_Printf("Client %i clashed into client %i's saber, did BLOCKED_ATK_BOUNCE\n", self->s.number, otherOwner->s.number);
+				}
+#endif
+			}
+		}
+
+		if ( ((selfSaberLevel < FORCE_LEVEL_3 && ((tryDeflectAgain && Q_irand(1, 10) <= 3) || (!tryDeflectAgain && Q_irand(1, 10) <= 7))) || (Q_irand(1, 10) <= 1 && otherSaberLevel >= FORCE_LEVEL_3))
+			&& !PM_SaberInBounce(self->client->ps.saberMove)
+
+			&& !PM_SaberInBrokenParry(otherOwner->client->ps.saberMove)
+			&& !BG_SaberInSpecial(otherOwner->client->ps.saberMove)
+			&& !PM_SaberInBounce(otherOwner->client->ps.saberMove)
+			&& !PM_SaberInDeflect(otherOwner->client->ps.saberMove)
+			&& !PM_SaberInReflect(otherOwner->client->ps.saberMove)
+
+			&& (otherSaberLevel > FORCE_LEVEL_2 || ( otherOwner->client->ps.fd.forcePowerLevel[FP_SABER_DEFENSE] >= 3 && Q_irand(0, otherSaberLevel) )) 
+			&& !unblockable
+			&& !otherUnblockable
+			&& dmg > SABER_NONATTACK_DAMAGE
+			&& !didOffense) //don't allow the person we're attacking to do this if we're making an unblockable attack
+		{//knockaways can make fast-attacker go into a broken parry anim if the ent is using fast or med. In MP, we also randomly decide this for level 3 attacks.
+			//Going to go ahead and let idle damage do simple knockaways. Looks sort of good that way.
+			//turn the parry into a knockaway
+			if (self->client->ps.saberEntityNum) //make sure he has his saber still
+			{
+				saberCheckKnockdown_BrokenParry(&g_entities[self->client->ps.saberEntityNum], self, otherOwner);
+			}
+
+			if (!PM_SaberInParry(otherOwner->client->ps.saberMove))
+			{
+				WP_SaberBlockNonRandom(otherOwner, tr.endpos, qfalse);
+				otherOwner->client->ps.saberMove = BG_KnockawayForParry( otherOwner->client->ps.saberBlocked );
+				otherOwner->client->ps.saberBlocked = BLOCKED_BOUNCE_MOVE;
+			}
+			else
+			{
+				otherOwner->client->ps.saberMove = G_KnockawayForParry(otherOwner->client->ps.saberMove); //BG_KnockawayForParry( otherOwner->client->ps.saberBlocked );
+				otherOwner->client->ps.saberBlocked = BLOCKED_BOUNCE_MOVE;
+			}
+	
+			//make them (me) go into a broken parry
+			self->client->ps.saberMove = BG_BrokenParryForAttack( self->client->ps.saberMove );
+			self->client->ps.saberBlocked = BLOCKED_BOUNCE_MOVE;
+
+#ifndef FINAL_BUILD
+			if (g_saberDebugPrint.integer)
+			{
+				Com_Printf("Client %i sent client %i into a reflected attack with a knockaway\n", otherOwner->s.number, self->s.number);
+			}
+#endif
+
+			didDefense = qtrue;
+		}
+		else if ((selfSaberLevel > FORCE_LEVEL_2 || unblockable) && //if we're doing a special attack, we can send them into a broken parry too (MP only)
+				 ( otherOwner->client->ps.fd.forcePowerLevel[FP_SABER_DEFENSE] < selfSaberLevel || (otherOwner->client->ps.fd.forcePowerLevel[FP_SABER_DEFENSE] == selfSaberLevel && (Q_irand(1, 10) >= otherSaberLevel*1.5 || unblockable)) ) &&
+				 PM_SaberInParry(otherOwner->client->ps.saberMove) &&
+				 !PM_SaberInBrokenParry(otherOwner->client->ps.saberMove) &&
+				 !PM_SaberInParry(self->client->ps.saberMove) &&
+				 !PM_SaberInBrokenParry(self->client->ps.saberMove) &&
+				 !PM_SaberInBounce(self->client->ps.saberMove) &&
+				 dmg > SABER_NONATTACK_DAMAGE &&
+				 !didOffense &&
+				 !otherUnblockable)
+		{ //they are in a parry, and we are slamming down on them with a move of equal or greater force than their defense, so send them into a broken parry.. unless they are already in one.
+			if (otherOwner->client->ps.saberEntityNum) //make sure he has his saber still
+			{
+				saberCheckKnockdown_BrokenParry(&g_entities[otherOwner->client->ps.saberEntityNum], otherOwner, self);
+			}
+
+#ifndef FINAL_BUILD
+			if (g_saberDebugPrint.integer)
+			{
+				Com_Printf("Client %i sent client %i into a broken parry\n", self->s.number, otherOwner->s.number);
+			}
+#endif
+
+			otherOwner->client->ps.saberMove = BG_BrokenParryForParry( otherOwner->client->ps.saberMove );
+			otherOwner->client->ps.saberBlocked = BLOCKED_PARRY_BROKEN;
+
+			didDefense = qtrue;
+		}
+		else if ((selfSaberLevel > FORCE_LEVEL_2) && //if we're doing a special attack, we can send them into a broken parry too (MP only)
+				 //( otherOwner->client->ps.fd.forcePowerLevel[FP_SABER_DEFENSE] < selfSaberLevel || (otherOwner->client->ps.fd.forcePowerLevel[FP_SABER_DEFENSE] == selfSaberLevel && (Q_irand(1, 10) >= otherSaberLevel*3 || unblockable)) ) &&
+				 otherSaberLevel >= FORCE_LEVEL_3 &&
+				 PM_SaberInParry(otherOwner->client->ps.saberMove) &&
+				 !PM_SaberInBrokenParry(otherOwner->client->ps.saberMove) &&
+				 !PM_SaberInParry(self->client->ps.saberMove) &&
+				 !PM_SaberInBrokenParry(self->client->ps.saberMove) &&
+				 !PM_SaberInBounce(self->client->ps.saberMove) &&
+				 !PM_SaberInDeflect(self->client->ps.saberMove) &&
+				 !PM_SaberInReflect(self->client->ps.saberMove) &&
+				 dmg > SABER_NONATTACK_DAMAGE &&
+				 !didOffense &&
+				 !unblockable)
+		{ //they are in a parry, and we are slamming down on them with a move of equal or greater force than their defense, so send them into a broken parry.. unless they are already in one.
+#ifndef FINAL_BUILD
+			if (g_saberDebugPrint.integer)
+			{
+				Com_Printf("Client %i bounced off of client %i's saber\n", self->s.number, otherOwner->s.number);
+			}
+#endif
+
+			if (!tryDeflectAgain)
+			{
+				if (!WP_GetSaberDeflectionAngle(self, otherOwner, tr.fraction))
+				{
+					tryDeflectAgain = qtrue;
+				}
+			}
+
+			didOffense = qtrue;
+		}
+		else if (SaberAttacking(otherOwner) && dmg > SABER_NONATTACK_DAMAGE && !BG_SaberInSpecial(otherOwner->client->ps.saberMove) && !didOffense && !otherUnblockable)
+		{ //they were attacking and our saber hit their saber, make them bounce. But if they're in a special attack, leave them.
+			if (!PM_SaberInBounce(self->client->ps.saberMove) &&
+				!PM_SaberInBounce(otherOwner->client->ps.saberMove) &&
+				!PM_SaberInDeflect(self->client->ps.saberMove) &&
+				!PM_SaberInDeflect(otherOwner->client->ps.saberMove) &&
+
+				!PM_SaberInReflect(self->client->ps.saberMove) &&
+				!PM_SaberInReflect(otherOwner->client->ps.saberMove))
+			{
+				int attackAdv, defendStr = G_PowerLevelForSaberAnim( otherOwner, 0, qtrue ), attackBonus = 0;
+				if ( otherOwner->client->ps.torsoAnim == BOTH_A1_SPECIAL
+					|| otherOwner->client->ps.torsoAnim == BOTH_A2_SPECIAL
+					|| otherOwner->client->ps.torsoAnim == BOTH_A3_SPECIAL )
+				{//parry/block/break-parry bonus for single-style kata moves
+					defendStr++;
+				}
+				defendStr += Q_irand(0, otherOwner->client->saber[0].parryBonus );
+				if ( otherOwner->client->saber[1].model
+					&& otherOwner->client->saber[1].model[0]
+					&& !otherOwner->client->ps.saberHolstered )
+				{
+					defendStr += Q_irand(0, otherOwner->client->saber[1].parryBonus );
+				}
+
+#ifndef FINAL_BUILD
+				if (g_saberDebugPrint.integer)
+				{
+					Com_Printf("Client %i and client %i bounced off of each other's sabers\n", self->s.number, otherOwner->s.number);
+				}
+#endif
+
+				attackBonus = Q_irand(0, self->client->saber[0].breakParryBonus );
+				if ( self->client->saber[1].model
+					&& self->client->saber[1].model[0]
+					&& !self->client->ps.saberHolstered )
+				{
+					attackBonus += Q_irand(0, self->client->saber[1].breakParryBonus );
+				}
+				attackAdv = (attackStr+attackBonus+self->client->ps.fd.forcePowerLevel[FP_SABER_OFFENSE])-(defendStr+otherOwner->client->ps.fd.forcePowerLevel[FP_SABER_OFFENSE]);
+				
+				if ( attackAdv > 1 ) 
+				{//I won, he should knockaway
+					otherOwner->client->ps.saberMove = BG_BrokenParryForAttack( otherOwner->client->ps.saberMove );
+					otherOwner->client->ps.saberBlocked = BLOCKED_BOUNCE_MOVE;
+				}
+				else if ( attackAdv > 0 )
+				{//I won, he should bounce, I should continue
+					otherOwner->client->ps.saberBlocked = BLOCKED_ATK_BOUNCE;
+				}
+				else if ( attackAdv < 1 )
+				{//I lost, I get knocked away
+					self->client->ps.saberMove = BG_BrokenParryForAttack( self->client->ps.saberMove );
+					self->client->ps.saberBlocked = BLOCKED_BOUNCE_MOVE;
+				}
+				else if ( attackAdv < 0 )
+				{//I lost, I bounce off
+					self->client->ps.saberBlocked = BLOCKED_ATK_BOUNCE;
+				}
+				else
+				{//even, both bounce off
+					self->client->ps.saberBlocked = BLOCKED_ATK_BOUNCE;
+					otherOwner->client->ps.saberBlocked = BLOCKED_ATK_BOUNCE;
+				}
+
+				didOffense = qtrue;
+			}
+		}
+		
+		if (d_saberGhoul2Collision.integer && !didDefense && dmg <= SABER_NONATTACK_DAMAGE && !otherUnblockable) //with perpoly, it looks pretty weird to have clash flares coming off the guy's face and whatnot
+		{
+			if (!PM_SaberInParry(otherOwner->client->ps.saberMove) &&
+				!PM_SaberInBrokenParry(otherOwner->client->ps.saberMove) &&
+				!BG_SaberInSpecial(otherOwner->client->ps.saberMove) &&
+				!PM_SaberInBounce(otherOwner->client->ps.saberMove) &&
+				!PM_SaberInDeflect(otherOwner->client->ps.saberMove) &&
+				!PM_SaberInReflect(otherOwner->client->ps.saberMove))
+			{
+				WP_SaberBlockNonRandom(otherOwner, tr.endpos, qfalse);
+				otherOwner->client->ps.saberEventFlags |= SEF_PARRIED;
+			}
+		}
+		else if (!didDefense && dmg > SABER_NONATTACK_DAMAGE && !otherUnblockable) //if not more than idle damage, don't even bother blocking.
+		{ //block
+			if (!PM_SaberInParry(otherOwner->client->ps.saberMove) &&
+				!PM_SaberInBrokenParry(otherOwner->client->ps.saberMove) &&
+				!BG_SaberInSpecial(otherOwner->client->ps.saberMove) &&
+				!PM_SaberInBounce(otherOwner->client->ps.saberMove) &&
+				!PM_SaberInDeflect(otherOwner->client->ps.saberMove) &&
+				!PM_SaberInReflect(otherOwner->client->ps.saberMove))
+			{
+				qboolean crushTheParry = qfalse;
+
+				if (unblockable)
+				{ //It's unblockable. So send us into a broken parry immediately.
+					crushTheParry = qtrue;
+				}
+
+				if (!SaberAttacking(otherOwner))
+				{
+					int otherIdleStr = otherOwner->client->ps.fd.saberAnimLevel;
+					if ( otherIdleStr == SS_DUAL
+						|| otherIdleStr == SS_STAFF )
+					{
+						otherIdleStr = SS_MEDIUM;
+					}
+
+					WP_SaberBlockNonRandom(otherOwner, tr.endpos, qfalse);
+					otherOwner->client->ps.saberEventFlags |= SEF_PARRIED;
+					self->client->ps.saberEventFlags |= SEF_BLOCKED;
+
+					if ( attackStr+self->client->ps.fd.forcePowerLevel[FP_SABER_OFFENSE] > otherIdleStr+otherOwner->client->ps.fd.forcePowerLevel[FP_SABER_DEFENSE] )
+					{
+						crushTheParry = qtrue;
+					}
+					else
+					{
+						tryDeflectAgain = qtrue;
+					}
+				}
+				else if (selfSaberLevel > otherSaberLevel ||
+					(selfSaberLevel == otherSaberLevel && Q_irand(1, 10) <= 2))
+				{ //they are attacking, and we managed to make them break
+					//Give them a parry, so we can later break it.
+					WP_SaberBlockNonRandom(otherOwner, tr.endpos, qfalse);
+					crushTheParry = qtrue;
+
+					if (otherOwner->client->ps.saberEntityNum) //make sure he has his saber still
+					{
+						saberCheckKnockdown_BrokenParry(&g_entities[otherOwner->client->ps.saberEntityNum], otherOwner, self);
+					}
+
+#ifndef FINAL_BUILD
+					if (g_saberDebugPrint.integer)
+					{
+						Com_Printf("Client %i forced client %i into a broken parry with a stronger attack\n", self->s.number, otherOwner->s.number);
+					}
+#endif
+				}
+				else
+				{ //They are attacking, so are we, and obviously they have an attack level higher than or equal to ours
+					if (selfSaberLevel == otherSaberLevel)
+					{ //equal level, try to bounce off each other's sabers
+						if (!didOffense &&
+							!PM_SaberInParry(self->client->ps.saberMove) &&
+							!PM_SaberInBrokenParry(self->client->ps.saberMove) &&
+							!BG_SaberInSpecial(self->client->ps.saberMove) &&
+							!PM_SaberInBounce(self->client->ps.saberMove) &&
+							!PM_SaberInDeflect(self->client->ps.saberMove) &&
+							!PM_SaberInReflect(self->client->ps.saberMove) &&
+							!unblockable)
+						{
+							self->client->ps.saberBlocked = BLOCKED_ATK_BOUNCE;
+							didOffense = qtrue;
+						}
+						if (!didDefense &&
+							!PM_SaberInParry(otherOwner->client->ps.saberMove) &&
+							!PM_SaberInBrokenParry(otherOwner->client->ps.saberMove) &&
+							!BG_SaberInSpecial(otherOwner->client->ps.saberMove) &&
+							!PM_SaberInBounce(otherOwner->client->ps.saberMove) &&
+							!PM_SaberInDeflect(otherOwner->client->ps.saberMove) &&
+							!PM_SaberInReflect(otherOwner->client->ps.saberMove) &&
+							!unblockable)
+						{
+							otherOwner->client->ps.saberBlocked = BLOCKED_ATK_BOUNCE;
+						}
+#ifndef FINAL_BUILD
+						if (g_saberDebugPrint.integer)
+						{
+							Com_Printf("Equal attack level bounce/deflection for clients %i and %i\n", self->s.number, otherOwner->s.number);
+						}
+#endif
+
+						self->client->ps.saberEventFlags |= SEF_DEFLECTED;
+						otherOwner->client->ps.saberEventFlags |= SEF_DEFLECTED;
+					}
+					else if ((level.time - otherOwner->client->lastSaberStorageTime) < 500 && !unblockable) //make sure the stored saber data is updated
+					{ //They are higher, this means they can actually smash us into a broken parry
+						//Using reflected anims instead now
+						self->client->ps.saberMove = BG_BrokenParryForAttack(self->client->ps.saberMove);
+						self->client->ps.saberBlocked = BLOCKED_PARRY_BROKEN;
+
+						if (self->client->ps.saberEntityNum) //make sure he has his saber still
+						{
+							saberCheckKnockdown_BrokenParry(&g_entities[self->client->ps.saberEntityNum], self, otherOwner);
+						}
+
+#ifndef FINAL_BUILD
+						if (g_saberDebugPrint.integer)
+						{
+							Com_Printf("Client %i hit client %i's stronger attack, was forced into a broken parry\n", self->s.number, otherOwner->s.number);
+						}
+#endif
+
+						otherOwner->client->ps.saberEventFlags &= ~SEF_BLOCKED;
+
+						didOffense = qtrue;
+					}
+				}
+
+				if (crushTheParry && PM_SaberInParry(G_GetParryForBlock(otherOwner->client->ps.saberBlocked)))
+				{ //This means that the attack actually hit our saber, and we went to block it.
+				  //But, one of the above cases says we actually can't. So we will be smashed into a broken parry instead.
+					otherOwner->client->ps.saberMove = BG_BrokenParryForParry( G_GetParryForBlock(otherOwner->client->ps.saberBlocked) );
+					otherOwner->client->ps.saberBlocked = BLOCKED_PARRY_BROKEN;
+
+					otherOwner->client->ps.saberEventFlags &= ~SEF_PARRIED;
+					self->client->ps.saberEventFlags &= ~SEF_BLOCKED;
+
+#ifndef FINAL_BUILD
+					if (g_saberDebugPrint.integer)
+					{
+						Com_Printf("Client %i broke through %i's parry with a special or stronger attack\n", self->s.number, otherOwner->s.number);
+					}
+#endif
+				}
+				else if (PM_SaberInParry(G_GetParryForBlock(otherOwner->client->ps.saberBlocked)) && !didOffense && tryDeflectAgain)
+				{ //We want to try deflecting again because the other is in the parry and we haven't made any new moves
+					int preMove = otherOwner->client->ps.saberMove;
+
+					otherOwner->client->ps.saberMove = G_GetParryForBlock(otherOwner->client->ps.saberBlocked);
+					WP_GetSaberDeflectionAngle(self, otherOwner, tr.fraction);
+					otherOwner->client->ps.saberMove = preMove;
+				}
+			}
+		}
+
+		self->client->ps.saberAttackWound = level.time + g_saberDmgDelay_Wound.integer;
+	}
+
+	return didHit;
+}
+
+GAME_INLINE int VectorCompare2( const vec3_t v1, const vec3_t v2 ) {
+	if ( v1[0] > v2[0]+0.0001f || v1[0] < v2[0]-0.0001f
+		|| v1[1] > v2[1]+0.0001f || v1[1] < v2[1]-0.0001f
+		|| v1[2] > v2[2]+0.0001f || v1[2] < v2[2]-0.0001f ) {
+		return 0;
+	}			
+	return 1;
+}
+
+#define MAX_SABER_SWING_INC 0.33f
+void G_SPSaberDamageTraceLerped( gentity_t *self, int saberNum, int bladeNum, vec3_t baseNew, vec3_t endNew, int clipmask )
+{
+	vec3_t baseOld, endOld;
+	vec3_t mp1, mp2;
+	vec3_t md1, md2;
+
+	VectorCopy( self->client->saber[saberNum].blade[bladeNum].trail.base, baseOld );
+	VectorCopy( self->client->saber[saberNum].blade[bladeNum].trail.tip, endOld );
+
+	VectorCopy( baseOld, mp1 );
+	VectorCopy( baseNew, mp2 );
+	VectorSubtract( endOld, baseOld, md1 );
+	VectorNormalize( md1 );
+	VectorSubtract( endNew, baseNew, md2 );
+	VectorNormalize( md2 );
+
+	saberHitWall = qfalse;
+	saberHitSaber = qfalse;
+	saberHitFraction = 1.0f;
+	if ( VectorCompare2( baseOld, baseNew ) && VectorCompare2( endOld, endNew ) )
+	{//no diff
+		CheckSaberDamage( self, saberNum, bladeNum, baseNew, endNew, qfalse, clipmask, qfalse );
+	}
+	else
+	{//saber moved, lerp
+		float step = 8, stepsize = 8;//aveLength, 
+		vec3_t	ma1, ma2, md2ang, curBase1, curBase2;
+		int	xx;
+		vec3_t curMD1, curMD2;//, mdDiff, dirDiff;
+		float dirInc, curDirFrac;
+		vec3_t baseDiff, bladePointOld, bladePointNew;
+		qboolean extrapolate = qtrue;
+
+		//do the trace at the base first
+		VectorCopy( baseOld, bladePointOld );
+		VectorCopy( baseNew, bladePointNew );
+		CheckSaberDamage( self, saberNum, bladeNum, bladePointOld, bladePointNew, qfalse, clipmask, qtrue );
+
+		//if hit a saber, shorten rest of traces to match
+		if ( saberHitFraction < 1.0f )
+		{
+			//adjust muzzleDir...
+			vec3_t ma1, ma2;
+			vectoangles( md1, ma1 );
+			vectoangles( md2, ma2 );
+			for ( xx = 0; xx < 3; xx++ )
+			{
+				md2ang[xx] = LerpAngle( ma1[xx], ma2[xx], saberHitFraction );
+			}
+			AngleVectors( md2ang, md2, NULL, NULL );
+			//shorten the base pos
+			VectorSubtract( mp2, mp1, baseDiff );
+			VectorMA( mp1, saberHitFraction, baseDiff, baseNew );
+			VectorMA( baseNew, self->client->saber[saberNum].blade[bladeNum].lengthMax, md2, endNew );
+		}
+
+		//If the angle diff in the blade is high, need to do it in chunks of 33 to avoid flattening of the arc
+		if ( BG_SaberInAttack( self->client->ps.saberMove ) 
+			|| BG_SaberInSpecialAttack( self->client->ps.torsoAnim ) 
+			|| BG_SpinningSaberAnim( self->client->ps.torsoAnim ) 
+			|| BG_InSpecialJump( self->client->ps.torsoAnim ) )
+			//|| (g_timescale->value<1.0f&&BG_SaberInTransitionAny( ent->client->ps.saberMove )) )
+		{
+			curDirFrac = DotProduct( md1, md2 );
+		}
+		else
+		{
+			curDirFrac = 1.0f;
+		}
+		//NOTE: if saber spun at least 180 degrees since last damage trace, this is not reliable...!
+		if ( fabs(curDirFrac) < 1.0f - MAX_SABER_SWING_INC )
+		{//the saber blade spun more than 33 degrees since the last damage trace
+			curDirFrac = dirInc = 1.0f/((1.0f - curDirFrac)/MAX_SABER_SWING_INC);
+		}
+		else
+		{
+			curDirFrac = 1.0f;
+			dirInc = 0.0f;
+		}
+		//qboolean hit_saber = qfalse;
+
+		vectoangles( md1, ma1 );
+		vectoangles( md2, ma2 );
+
+		//VectorSubtract( md2, md1, mdDiff );
+		VectorCopy( md1, curMD2 );
+		VectorCopy( baseOld, curBase2 );
+
+		while ( 1 )
+		{
+			VectorCopy( curMD2, curMD1 );
+			VectorCopy( curBase2, curBase1 );
+			if ( curDirFrac >= 1.0f )
+			{
+				VectorCopy( md2, curMD2 );
+				VectorCopy( baseNew, curBase2 );
+			}
+			else
+			{
+				for ( xx = 0; xx < 3; xx++ )
+				{
+					md2ang[xx] = LerpAngle( ma1[xx], ma2[xx], curDirFrac );
+				}
+				AngleVectors( md2ang, curMD2, NULL, NULL );
+				//VectorMA( md1, curDirFrac, mdDiff, curMD2 );
+				VectorSubtract( baseNew, baseOld, baseDiff );
+				VectorMA( baseOld, curDirFrac, baseDiff, curBase2 );
+			}
+			// Move up the blade in intervals of stepsize
+			for ( step = stepsize; step <= self->client->saber[saberNum].blade[bladeNum].lengthMax /*&& step < self->client->saber[saberNum].blade[bladeNum].lengthOld*/; step += stepsize )
+			{
+				VectorMA( curBase1, step, curMD1, bladePointOld );
+				VectorMA( curBase2, step, curMD2, bladePointNew );
+				
+				if ( step+stepsize >= self->client->saber[saberNum].blade[bladeNum].lengthMax )
+				{
+					extrapolate = qfalse;
+				}
+				//do the damage trace
+				CheckSaberDamage( self, saberNum, bladeNum, bladePointOld, bladePointNew, qfalse, clipmask, extrapolate );
+				/*
+				if ( WP_SaberDamageForTrace( ent->s.number, bladePointOld, bladePointNew, baseDamage, curMD2, 
+					qfalse, entPowerLevel, ent->client->ps.saber[saberNum].type, qtrue,
+					saberNum, bladeNum ) )
+				{
+					hit_wall = qtrue;
+				}
+				*/
+
+				//if hit a saber, shorten rest of traces to match
+				if ( saberHitFraction < 1.0f )
+				{
+					vec3_t curMA1, curMA2;
+					//adjust muzzle endpoint
+					VectorSubtract( mp2, mp1, baseDiff );
+					VectorMA( mp1, saberHitFraction, baseDiff, baseNew );
+					VectorMA( baseNew, self->client->saber[saberNum].blade[bladeNum].lengthMax, curMD2, endNew );
+					//adjust muzzleDir...
+					vectoangles( curMD1, curMA1 );
+					vectoangles( curMD2, curMA2 );
+					for ( xx = 0; xx < 3; xx++ )
+					{
+						md2ang[xx] = LerpAngle( curMA1[xx], curMA2[xx], saberHitFraction );
+					}
+					AngleVectors( md2ang, curMD2, NULL, NULL );
+					saberHitSaber = qtrue;
+				}
+				if (saberHitWall)
+				{
+					break;
+				}
+			}
+			if ( saberHitWall || saberHitSaber )
+			{
+				break;
+			}
+			if ( curDirFrac >= 1.0f )
+			{
+				break;
+			}
+			else
+			{
+				curDirFrac += dirInc;
+				if ( curDirFrac >= 1.0f )
+				{
+					curDirFrac = 1.0f;
+				}
+			}
+		}
+
+		//do the trace at the end last
+		//Special check- adjust for length of blade not being a multiple of 12
+		/*
+		aveLength = (ent->client->ps.saber[saberNum].blade[bladeNum].lengthOld + ent->client->ps.saber[saberNum].blade[bladeNum].length)/2;
+		if ( step > aveLength )
+		{//less dmg if the last interval was not stepsize
+			tipDmgMod = (stepsize-(step-aveLength))/stepsize;
+		}
+		//NOTE: since this is the tip, we do not extrapolate the extra 16
+		if ( WP_SaberDamageForTrace( ent->s.number, endOld, endNew, tipDmgMod*baseDamage, md2, 
+			qfalse, entPowerLevel, ent->client->ps.saber[saberNum].type, qfalse,
+			saberNum, bladeNum ) )
+		{
+			hit_wall = qtrue;
+		}
+		*/
+	}
+}
+
+#include "../namespace_begin.h"
+qboolean BG_SaberInTransitionAny( int move );
+#include "../namespace_end.h"
+
+qboolean WP_ForcePowerUsable( gentity_t *self, forcePowers_t forcePower );
+qboolean InFOV3( vec3_t spot, vec3_t from, vec3_t fromAngles, int hFOV, int vFOV );
+qboolean Jedi_WaitingAmbush( gentity_t *self );
+void Jedi_Ambush( gentity_t *self );
+evasionType_t Jedi_SaberBlockGo( gentity_t *self, usercmd_t *cmd, vec3_t pHitloc, vec3_t phitDir, gentity_t *incoming, float dist );
+void NPC_SetLookTarget( gentity_t *self, int entNum, int clearTime );
+void WP_SaberStartMissileBlockCheck( gentity_t *self, usercmd_t *ucmd  )
+{
+	float		dist;
+	gentity_t	*ent, *incoming = NULL;
+	int			entityList[MAX_GENTITIES];
+	int			numListedEntities;
+	vec3_t		mins, maxs;
+	int			i, e;
+	float		closestDist, radius = 256;
+	vec3_t		forward, dir, missile_dir, fwdangles = {0};
+	trace_t		trace;
+	vec3_t		traceTo, entDir;
+	float		dot1, dot2;
+	float		lookTDist = -1;
+	gentity_t	*lookT = NULL;
+	qboolean	doFullRoutine = qtrue;
+
+	//keep this updated even if we don't get below
+	if ( !(self->client->ps.eFlags2&EF2_HELD_BY_MONSTER) )
+	{//lookTarget is set by and to the monster that's holding you, no other operations can change that
+		self->client->ps.hasLookTarget = qfalse;
+	}
+
+	if ( self->client->ps.weapon != WP_SABER && self->client->NPC_class != CLASS_BOBAFETT )
+	{
+		doFullRoutine = qfalse;
+	}
+	else if ( self->client->ps.saberInFlight )
+	{
+		doFullRoutine = qfalse;
+	}
+	else if ( self->client->ps.fd.forcePowersActive&(1<<FP_LIGHTNING) )
+	{//can't block while zapping
+		doFullRoutine = qfalse;
+	}
+	else if ( self->client->ps.fd.forcePowersActive&(1<<FP_DRAIN) )
+	{//can't block while draining
+		doFullRoutine = qfalse;
+	}
+	else if ( self->client->ps.fd.forcePowersActive&(1<<FP_PUSH) )
+	{//can't block while shoving
+		doFullRoutine = qfalse;
+	}
+	else if ( self->client->ps.fd.forcePowersActive&(1<<FP_GRIP) )
+	{//can't block while gripping (FIXME: or should it break the grip?  Pain should break the grip, I think...)
+		doFullRoutine = qfalse;
+	}
+	
+	if (self->client->ps.weaponTime > 0)
+	{ //don't autoblock while busy with stuff
+		return;
+	}
+
+	if ( !self->client->saber[0].activeBlocking )
+	{//can't actively block with this saber type
+		return;
+	}
+
+	if ( self->health <= 0 )
+	{//dead don't try to block (NOTE: actual deflection happens in missile code)
+		return;
+	}
+	if ( PM_InKnockDown( &self->client->ps ) )
+	{//can't block when knocked down
+		return;
+	}
+
+	if ( BG_SabersOff( &self->client->ps ) && self->client->NPC_class != CLASS_BOBAFETT )
+	{
+		if ( self->s.eType != ET_NPC )
+		{//player doesn't auto-activate
+			doFullRoutine = qfalse;
+		}
+	}
+
+	if ( self->s.eType == ET_PLAYER )
+	{//don't do this if already attacking!
+		if ( ucmd->buttons & BUTTON_ATTACK 
+			|| BG_SaberInAttack( self->client->ps.saberMove )
+			|| BG_SaberInSpecialAttack( self->client->ps.torsoAnim )
+			|| BG_SaberInTransitionAny( self->client->ps.saberMove ))
+		{
+			doFullRoutine = qfalse;
+		}
+	}
+
+	if ( self->client->ps.fd.forcePowerDebounce[FP_SABER_DEFENSE] > level.time )
+	{//can't block while gripping (FIXME: or should it break the grip?  Pain should break the grip, I think...)
+		doFullRoutine = qfalse;
+	}
+
+	fwdangles[1] = self->client->ps.viewangles[1];
+	AngleVectors( fwdangles, forward, NULL, NULL );
+
+	for ( i = 0 ; i < 3 ; i++ ) 
+	{
+		mins[i] = self->r.currentOrigin[i] - radius;
+		maxs[i] = self->r.currentOrigin[i] + radius;
+	}
+
+	numListedEntities = trap_EntitiesInBox( mins, maxs, entityList, MAX_GENTITIES );
+
+	closestDist = radius;
+
+	for ( e = 0 ; e < numListedEntities ; e++ ) 
+	{
+		ent = &g_entities[entityList[ e ]];
+
+		if (ent == self)
+			continue;
+
+		//as long as we're here I'm going to get a looktarget too, I guess. -rww
+		if (self->s.eType == ET_PLAYER &&
+			ent->client &&
+			(ent->s.eType == ET_NPC || ent->s.eType == ET_PLAYER) &&
+			!OnSameTeam(ent, self) &&
+			ent->client->sess.sessionTeam != TEAM_SPECTATOR &&
+			!(ent->client->ps.pm_flags & PMF_FOLLOW) &&
+			(ent->s.eType != ET_NPC || ent->s.NPC_class != CLASS_VEHICLE) && //don't look at vehicle NPCs
+			ent->health > 0)
+		{ //seems like a valid enemy to look at.
+			vec3_t vecSub;
+			float vecLen;
+
+			VectorSubtract(self->client->ps.origin, ent->client->ps.origin, vecSub);
+			vecLen = VectorLength(vecSub);
+
+			if (lookTDist == -1 || vecLen < lookTDist)
+			{
+				trace_t tr;
+				vec3_t myEyes;
+
+				VectorCopy(self->client->ps.origin, myEyes);
+				myEyes[2] += self->client->ps.viewheight;
+
+				trap_Trace(&tr, myEyes, NULL, NULL, ent->client->ps.origin, self->s.number, MASK_PLAYERSOLID);
+
+				if (tr.fraction == 1.0f || tr.entityNum == ent->s.number)
+				{ //we have a clear line of sight to him, so it's all good.
+					lookT = ent;
+					lookTDist = vecLen;
+				}
+			}
+		}
+
+		if (!doFullRoutine)
+		{ //don't care about the rest then
+			continue;
+		}
+
+		if (ent->r.ownerNum == self->s.number)
+			continue;
+		if ( !(ent->inuse) )
+			continue;
+		if ( ent->s.eType != ET_MISSILE && !(ent->s.eFlags&EF_MISSILE_STICK) )
+		{//not a normal projectile
+			gentity_t *pOwner;
+
+			if (ent->r.ownerNum < 0 || ent->r.ownerNum >= ENTITYNUM_WORLD)
+			{ //not going to be a client then.
+				continue;
+			}
+				
+			pOwner = &g_entities[ent->r.ownerNum];
+
+			if (!pOwner->inuse || !pOwner->client)
+			{
+				continue; //not valid cl owner
+			}
+
+			if (!pOwner->client->ps.saberEntityNum ||
+				!pOwner->client->ps.saberInFlight ||
+				pOwner->client->ps.saberEntityNum != ent->s.number)
+			{ //the saber is knocked away and/or not flying actively, or this ent is not the cl's saber ent at all
+				continue;
+			}
+
+			//If we get here then it's ok to be treated as a thrown saber, I guess.
+		}
+		else
+		{
+			if ( ent->s.pos.trType == TR_STATIONARY && self->s.eType == ET_PLAYER )
+			{//nothing you can do with a stationary missile if you're the player
+				continue;
+			}
+		}
+
+		//see if they're in front of me
+		VectorSubtract( ent->r.currentOrigin, self->r.currentOrigin, dir );
+		dist = VectorNormalize( dir );
+		//FIXME: handle detpacks, proximity mines and tripmines
+		if ( ent->s.weapon == WP_THERMAL )
+		{//thermal detonator!
+			if ( self->NPC && dist < ent->splashRadius )
+			{
+				if ( dist < ent->splashRadius && 
+					ent->nextthink < level.time + 600 && 
+					ent->count && 
+					self->client->ps.groundEntityNum != ENTITYNUM_NONE && 
+						(ent->s.pos.trType == TR_STATIONARY||
+						ent->s.pos.trType == TR_INTERPOLATE||
+						(dot1 = DotProduct( dir, forward )) < SABER_REFLECT_MISSILE_CONE||
+						!WP_ForcePowerUsable( self, FP_PUSH )) )
+				{//TD is close enough to hurt me, I'm on the ground and the thing is at rest or behind me and about to blow up, or I don't have force-push so force-jump!
+					//FIXME: sometimes this might make me just jump into it...?
+					self->client->ps.fd.forceJumpCharge = 480;
+				}
+				else if ( self->client->NPC_class != CLASS_BOBAFETT )
+				{//FIXME: check forcePushRadius[NPC->client->ps.forcePowerLevel[FP_PUSH]]
+					ForceThrow( self, qfalse );
+				}
+			}
+			continue;
+		}
+		else if ( ent->splashDamage && ent->splashRadius )
+		{//exploding missile
+			//FIXME: handle tripmines and detpacks somehow... 
+			//			maybe do a force-gesture that makes them explode?  
+			//			But what if we're within it's splashradius?
+			if ( self->s.eType == ET_PLAYER )
+			{//players don't auto-handle these at all
+				continue;
+			}
+			else 
+			{
+				//if ( ent->s.pos.trType == TR_STATIONARY && (ent->s.eFlags&EF_MISSILE_STICK) 
+				//	&& 	self->client->NPC_class != CLASS_BOBAFETT )
+				if (0) //Maybe handle this later?
+				{//a placed explosive like a tripmine or detpack
+					if ( InFOV3( ent->r.currentOrigin, self->client->renderInfo.eyePoint, self->client->ps.viewangles, 90, 90 ) )
+					{//in front of me
+						if ( G_ClearLOS4( self, ent ) )
+						{//can see it
+							vec3_t throwDir;
+							//make the gesture
+							ForceThrow( self, qfalse );
+							//take it off the wall and toss it
+							ent->s.pos.trType = TR_GRAVITY;
+							ent->s.eType = ET_MISSILE;
+							ent->s.eFlags &= ~EF_MISSILE_STICK;
+							ent->flags |= FL_BOUNCE_HALF;
+							AngleVectors( ent->r.currentAngles, throwDir, NULL, NULL );
+							VectorMA( ent->r.currentOrigin, ent->r.maxs[0]+4, throwDir, ent->r.currentOrigin );
+							VectorCopy( ent->r.currentOrigin, ent->s.pos.trBase );
+							VectorScale( throwDir, 300, ent->s.pos.trDelta );
+							ent->s.pos.trDelta[2] += 150;
+							VectorMA( ent->s.pos.trDelta, 800, dir, ent->s.pos.trDelta );
+							ent->s.pos.trTime = level.time;		// move a bit on the very first frame
+							VectorCopy( ent->r.currentOrigin, ent->s.pos.trBase );
+							ent->r.ownerNum = self->s.number;
+							// make it explode, but with less damage
+							ent->splashDamage /= 3;
+							ent->splashRadius /= 3;
+							//ent->think = WP_Explode;
+							ent->nextthink = level.time + Q_irand( 500, 3000 );
+						}
+					}
+				}
+				else if ( dist < ent->splashRadius && 
+				self->client->ps.groundEntityNum != ENTITYNUM_NONE && 
+					(DotProduct( dir, forward ) < SABER_REFLECT_MISSILE_CONE||
+					!WP_ForcePowerUsable( self, FP_PUSH )) )
+				{//NPCs try to evade it
+					self->client->ps.fd.forceJumpCharge = 480;
+				}
+				else if ( self->client->NPC_class != CLASS_BOBAFETT )
+				{//else, try to force-throw it away
+					//FIXME: check forcePushRadius[NPC->client->ps.forcePowerLevel[FP_PUSH]]
+					ForceThrow( self, qfalse );
+				}
+			}
+			//otherwise, can't block it, so we're screwed
+			continue;
+		}
+
+		if ( ent->s.weapon != WP_SABER )
+		{//only block shots coming from behind
+			if ( (dot1 = DotProduct( dir, forward )) < SABER_REFLECT_MISSILE_CONE )
+				continue;
+		}
+		else if ( self->s.eType == ET_PLAYER )
+		{//player never auto-blocks thrown sabers
+			continue;
+		}//NPCs always try to block sabers coming from behind!
+
+		//see if they're heading towards me
+		VectorCopy( ent->s.pos.trDelta, missile_dir );
+		VectorNormalize( missile_dir );
+		if ( (dot2 = DotProduct( dir, missile_dir )) > 0 )
+			continue;
+
+		//FIXME: must have a clear trace to me, too...
+		if ( dist < closestDist )
+		{
+			VectorCopy( self->r.currentOrigin, traceTo );
+			traceTo[2] = self->r.absmax[2] - 4;
+			trap_Trace( &trace, ent->r.currentOrigin, ent->r.mins, ent->r.maxs, traceTo, ent->s.number, ent->clipmask );
+			if ( trace.allsolid || trace.startsolid || (trace.fraction < 1.0f && trace.entityNum != self->s.number && trace.entityNum != self->client->ps.saberEntityNum) )
+			{//okay, try one more check
+				VectorNormalize2( ent->s.pos.trDelta, entDir );
+				VectorMA( ent->r.currentOrigin, radius, entDir, traceTo );
+				trap_Trace( &trace, ent->r.currentOrigin, ent->r.mins, ent->r.maxs, traceTo, ent->s.number, ent->clipmask );
+				if ( trace.allsolid || trace.startsolid || (trace.fraction < 1.0f && trace.entityNum != self->s.number && trace.entityNum != self->client->ps.saberEntityNum) )
+				{//can't hit me, ignore it
+					continue;
+				}
+			}
+			if ( self->s.eType == ET_NPC )
+			{//An NPC
+				if ( self->NPC && !self->enemy && ent->r.ownerNum != ENTITYNUM_NONE )
+				{
+					gentity_t *owner = &g_entities[ent->r.ownerNum];
+					if ( owner->health >= 0 && (!owner->client || owner->client->playerTeam != self->client->playerTeam) )
+					{
+						G_SetEnemy( self, owner );
+					}
+				}
+			}
+			//FIXME: if NPC, predict the intersection between my current velocity/path and the missile's, see if it intersects my bounding box (+/-saberLength?), don't try to deflect unless it does?
+			closestDist = dist;
+			incoming = ent;
+		}
+	}
+
+	if (self->s.eType == ET_NPC && self->localAnimIndex <= 1)
+	{ //humanoid NPCs don't set angles based on server angles for looking, unlike other NPCs
+		if (self->client && self->client->renderInfo.lookTarget < ENTITYNUM_WORLD)
+		{
+			lookT = &g_entities[self->client->renderInfo.lookTarget];
+		}
+	}
+
+	if (lookT)
+	{ //we got a looktarget at some point so we'll assign it then.
+		if ( !(self->client->ps.eFlags2&EF2_HELD_BY_MONSTER) )
+		{//lookTarget is set by and to the monster that's holding you, no other operations can change that
+			self->client->ps.hasLookTarget = qtrue;
+			self->client->ps.lookTarget = lookT->s.number;
+		}
+	}
+
+	if (!doFullRoutine)
+	{ //then we're done now
+		return;
+	}
+
+	if ( incoming )
+	{
+		if ( self->NPC /*&& !G_ControlledByPlayer( self )*/ )
+		{
+			if ( Jedi_WaitingAmbush( self ) )
+			{
+				Jedi_Ambush( self );
+			}
+			if ( self->client->NPC_class == CLASS_BOBAFETT 
+				&& (self->client->ps.eFlags2&EF2_FLYING)//moveType == MT_FLYSWIM 
+				&& incoming->methodOfDeath != MOD_ROCKET_HOMING )
+			{//a hovering Boba Fett, not a tracking rocket
+				if ( !Q_irand( 0, 1 ) )
+				{//strafe
+					self->NPC->standTime = 0;
+					self->client->ps.fd.forcePowerDebounce[FP_SABER_DEFENSE] = level.time + Q_irand( 1000, 2000 );
+				}
+				if ( !Q_irand( 0, 1 ) )
+				{//go up/down
+					TIMER_Set( self, "heightChange", Q_irand( 1000, 3000 ) );
+					self->client->ps.fd.forcePowerDebounce[FP_SABER_DEFENSE] = level.time + Q_irand( 1000, 2000 );
+				}
+			}
+			else if ( Jedi_SaberBlockGo( self, &self->NPC->last_ucmd, NULL, NULL, incoming, 0.0f ) != EVASION_NONE )
+			{//make sure to turn on your saber if it's not on
+				if ( self->client->NPC_class != CLASS_BOBAFETT )
+				{
+					//self->client->ps.SaberActivate();
+					WP_ActivateSaber(self);
+				}
+			}
+		}
+		else//player
+		{
+			gentity_t *owner = &g_entities[incoming->r.ownerNum];
+
+			WP_SaberBlockNonRandom( self, incoming->r.currentOrigin, qtrue );
+			if ( owner && owner->client && (!self->enemy || self->enemy->s.weapon != WP_SABER) )//keep enemy jedi over shooters
+			{
+				self->enemy = owner;
+				//NPC_SetLookTarget( self, owner->s.number, level.time+1000 );
+				//player looktargetting done differently
+			}
+		}
+	}
+}
+
+#define MIN_SABER_SLICE_DISTANCE 50
+
+#define MIN_SABER_SLICE_RETURN_DISTANCE 30
+
+#define SABER_THROWN_HIT_DAMAGE 30
+#define SABER_THROWN_RETURN_HIT_DAMAGE 5
+
+void thrownSaberTouch (gentity_t *saberent, gentity_t *other, trace_t *trace);
+
+static GAME_INLINE qboolean CheckThrownSaberDamaged(gentity_t *saberent, gentity_t *saberOwner, gentity_t *ent, int dist, int returning, qboolean noDCheck)
+{
+	vec3_t vecsub;
+	float veclen;
+	gentity_t *te;
+
+	if (saberOwner && saberOwner->client && saberOwner->client->ps.saberAttackWound > level.time)
+	{
+		return qfalse;
+	}
+
+	if (ent && ent->client && ent->inuse && ent->s.number != saberOwner->s.number &&
+		ent->health > 0 && ent->takedamage &&
+		trap_InPVS(ent->client->ps.origin, saberent->r.currentOrigin) &&
+		ent->client->sess.sessionTeam != TEAM_SPECTATOR &&
+		(ent->client->pers.connected || ent->s.eType == ET_NPC))
+	{ //hit a client
+		if (ent->inuse && ent->client &&
+			ent->client->ps.duelInProgress &&
+			ent->client->ps.duelIndex != saberOwner->s.number)
+		{
+			return qfalse;
+		}
+
+		if (ent->inuse && ent->client &&
+			saberOwner->client->ps.duelInProgress &&
+			saberOwner->client->ps.duelIndex != ent->s.number)
+		{
+			return qfalse;
+		}
+
+		VectorSubtract(saberent->r.currentOrigin, ent->client->ps.origin, vecsub);
+		veclen = VectorLength(vecsub);
+
+		if (veclen < dist)
+		{ //within range
+			trace_t tr;
+
+			trap_Trace(&tr, saberent->r.currentOrigin, NULL, NULL, ent->client->ps.origin, saberent->s.number, MASK_SHOT);
+
+			if (tr.fraction == 1 || tr.entityNum == ent->s.number)
+			{ //Slice them
+				if (!saberOwner->client->ps.isJediMaster && WP_SaberCanBlock(ent, tr.endpos, 0, MOD_SABER, qfalse, 999))
+				{ //they blocked it
+					WP_SaberBlockNonRandom(ent, tr.endpos, qfalse);
+
+					te = G_TempEntity( tr.endpos, EV_SABER_BLOCK );
+					VectorCopy(tr.endpos, te->s.origin);
+					VectorCopy(tr.plane.normal, te->s.angles);
+					if (!te->s.angles[0] && !te->s.angles[1] && !te->s.angles[2])
+					{
+						te->s.angles[1] = 1;
+					}
+					te->s.eventParm = 1;
+
+					if (saberCheckKnockdown_Thrown(saberent, saberOwner, &g_entities[tr.entityNum]))
+					{ //it was knocked out of the air
+						return qfalse;
+					}
+
+					if (!returning)
+					{ //return to owner if blocked
+						thrownSaberTouch(saberent, saberent, NULL);
+					}
+
+					saberOwner->client->ps.saberAttackWound = level.time + 500;
+					return qfalse;
+				}
+				else
+				{ //a good hit
+					vec3_t dir;
+
+					VectorSubtract(tr.endpos, saberent->r.currentOrigin, dir);
+					VectorNormalize(dir);
+
+					if (!dir[0] && !dir[1] && !dir[2])
+					{
+						dir[1] = 1;
+					}
+
+					if (saberOwner->client->ps.isJediMaster)
+					{ //2x damage for the Jedi Master
+						G_Damage(ent, saberOwner, saberOwner, dir, tr.endpos, saberent->damage*2, 0, MOD_SABER);
+					}
+					else
+					{
+						G_Damage(ent, saberOwner, saberOwner, dir, tr.endpos, saberent->damage, 0, MOD_SABER);
+					}
+
+					te = G_TempEntity( tr.endpos, EV_SABER_HIT );
+					te->s.otherEntityNum = ent->s.number;
+					te->s.otherEntityNum2 = saberOwner->s.number;
+					VectorCopy(tr.endpos, te->s.origin);
+					VectorCopy(tr.plane.normal, te->s.angles);
+					if (!te->s.angles[0] && !te->s.angles[1] && !te->s.angles[2])
+					{
+						te->s.angles[1] = 1;
+					}
+
+					te->s.eventParm = 1;
+
+					if (!returning)
+					{ //return to owner if blocked
+						thrownSaberTouch(saberent, saberent, NULL);
+					}
+				}
+
+				saberOwner->client->ps.saberAttackWound = level.time + 500;
+			}
+		}
+	}
+	else if (ent && !ent->client && ent->inuse && ent->takedamage && ent->health > 0 && ent->s.number != saberOwner->s.number &&
+		ent->s.number != saberent->s.number && (noDCheck ||trap_InPVS(ent->r.currentOrigin, saberent->r.currentOrigin)))
+	{ //hit a non-client
+
+		if (noDCheck)
+		{
+			veclen = 0;
+		}
+		else
+		{
+			VectorSubtract(saberent->r.currentOrigin, ent->r.currentOrigin, vecsub);
+			veclen = VectorLength(vecsub);
+		}
+
+		if (veclen < dist)
+		{
+			trace_t tr;
+			vec3_t entOrigin;
+
+			if (ent->s.eType == ET_MOVER)
+			{
+				VectorSubtract( ent->r.absmax, ent->r.absmin, entOrigin );
+				VectorMA( ent->r.absmin, 0.5, entOrigin, entOrigin );
+				VectorAdd( ent->r.absmin, ent->r.absmax, entOrigin );
+				VectorScale( entOrigin, 0.5f, entOrigin );
+			}
+			else
+			{
+				VectorCopy(ent->r.currentOrigin, entOrigin);
+			}
+
+			trap_Trace(&tr, saberent->r.currentOrigin, NULL, NULL, entOrigin, saberent->s.number, MASK_SHOT);
+
+			if (tr.fraction == 1 || tr.entityNum == ent->s.number)
+			{
+				vec3_t dir;
+
+				VectorSubtract(tr.endpos, entOrigin, dir);
+				VectorNormalize(dir);
+
+				if (ent->s.eType == ET_NPC)
+				{ //an animent
+					G_Damage(ent, saberOwner, saberOwner, dir, tr.endpos, 40, 0, MOD_SABER);
+				}
+				else
+				{
+					G_Damage(ent, saberOwner, saberOwner, dir, tr.endpos, 5, 0, MOD_SABER);
+				}
+
+				te = G_TempEntity( tr.endpos, EV_SABER_HIT );
+				te->s.otherEntityNum = ENTITYNUM_NONE; //don't do this for throw damage
+				//te->s.otherEntityNum = ent->s.number;
+				//te->s.otherEntityNum2 = saberOwner->s.number;
+				VectorCopy(tr.endpos, te->s.origin);
+				VectorCopy(tr.plane.normal, te->s.angles);
+				if (!te->s.angles[0] && !te->s.angles[1] && !te->s.angles[2])
+				{
+					te->s.angles[1] = 1;
+				}
+
+				if (ent->s.eType == ET_MOVER)
+				{
+					//I suppose I could tie this into the saberblock event, but I'm tired of adding flags to that thing.
+					gentity_t *teS = G_TempEntity( te->s.origin, EV_SABER_CLASHFLARE );
+					VectorCopy(te->s.origin, teS->s.origin);
+
+					te->s.eventParm = 0;
+				}
+				else
+				{
+					te->s.eventParm = 1;
+				}
+
+				if (!returning)
+				{ //return to owner if blocked
+					thrownSaberTouch(saberent, saberent, NULL);
+				}
+
+				saberOwner->client->ps.saberAttackWound = level.time + 500;
+			}
+		}
+	}
+
+	return qtrue;
+}
+
+static GAME_INLINE void saberCheckRadiusDamage(gentity_t *saberent, int returning)
+{ //we're going to cheat and damage players within the saber's radius, just for the sake of doing things more "efficiently" (and because the saber entity has no server g2 instance)
+	int i = 0;
+	int dist = 0;
+	gentity_t *ent;
+	gentity_t *saberOwner = &g_entities[saberent->r.ownerNum];
+
+	if (returning && returning != 2)
+	{
+		dist = MIN_SABER_SLICE_RETURN_DISTANCE;
+	}
+	else
+	{
+		dist = MIN_SABER_SLICE_DISTANCE;
+	}
+
+	if (!saberOwner || !saberOwner->client)
+	{
+		return;
+	}
+
+	if (saberOwner->client->ps.saberAttackWound > level.time)
+	{
+		return;
+	}
+
+	while (i < level.num_entities)
+	{
+		ent = &g_entities[i];
+
+		CheckThrownSaberDamaged(saberent, saberOwner, ent, dist, returning, qfalse);
+
+		i++;
+	}
+}
+
+#define THROWN_SABER_COMP
+
+static GAME_INLINE void saberMoveBack( gentity_t *ent, qboolean goingBack ) 
+{
+	vec3_t		origin, oldOrg;
+
+	ent->s.pos.trType = TR_LINEAR;
+
+	VectorCopy( ent->r.currentOrigin, oldOrg );
+	// get current position
+	BG_EvaluateTrajectory( &ent->s.pos, level.time, origin );
+	//Get current angles?
+	BG_EvaluateTrajectory( &ent->s.apos, level.time, ent->r.currentAngles );
+
+	//compensation test code..
+#ifdef THROWN_SABER_COMP
+	if (!goingBack && ent->s.pos.trType != TR_GRAVITY)
+	{ //acts as a fallback in case touch code fails, keeps saber from going through things between predictions
+		float originalLength = 0;
+		int iCompensationLength = 32;
+		trace_t tr;
+		vec3_t mins, maxs;
+		vec3_t calcComp, compensatedOrigin;
+		VectorSet( mins, -24.0f, -24.0f, -8.0f );
+		VectorSet( maxs, 24.0f, 24.0f, 8.0f );
+
+		VectorSubtract(origin, oldOrg, calcComp);
+		originalLength = VectorLength(calcComp);
+
+		VectorNormalize(calcComp);
+
+		compensatedOrigin[0] = oldOrg[0] + calcComp[0]*(originalLength+iCompensationLength);		
+		compensatedOrigin[1] = oldOrg[1] + calcComp[1]*(originalLength+iCompensationLength);
+		compensatedOrigin[2] = oldOrg[2] + calcComp[2]*(originalLength+iCompensationLength);
+
+		trap_Trace(&tr, oldOrg, mins, maxs, compensatedOrigin, ent->r.ownerNum, MASK_PLAYERSOLID);
+
+		if ((tr.fraction != 1 || tr.startsolid || tr.allsolid) && tr.entityNum != ent->r.ownerNum && !(g_entities[tr.entityNum].r.contents & CONTENTS_LIGHTSABER))
+		{
+			VectorClear(ent->s.pos.trDelta);
+
+			//Unfortunately doing this would defeat the purpose of the compensation. We will have to settle for a jerk on the client.
+			//VectorCopy( origin, ent->r.currentOrigin );
+
+			//we'll skip the dist check, since we don't really care about that (we just hit it physically)
+			CheckThrownSaberDamaged(ent, &g_entities[ent->r.ownerNum], &g_entities[tr.entityNum], 256, 0, qtrue);
+
+			if (ent->s.pos.trType == TR_GRAVITY)
+			{ //got blocked and knocked away in the damage func
+				return;
+			}
+
+			tr.startsolid = 0;
+			if (tr.entityNum == ENTITYNUM_NONE)
+			{ //eh, this is a filthy lie. (obviously it had to hit something or it wouldn't be in here, so we'll say it hit the world)
+				tr.entityNum = ENTITYNUM_WORLD;
+			}
+			thrownSaberTouch(ent, &g_entities[tr.entityNum], &tr);
+			return;
+		}
+	}
+#endif
+
+	VectorCopy( origin, ent->r.currentOrigin );
+}
+
+void SaberBounceSound( gentity_t *self, gentity_t *other, trace_t *trace )
+{
+	VectorCopy(self->r.currentAngles, self->s.apos.trBase);
+	self->s.apos.trBase[PITCH] = 90;
+}
+
+void DeadSaberThink(gentity_t *saberent)
+{
+	if (saberent->speed < level.time)
+	{
+		saberent->think = G_FreeEntity;
+		saberent->nextthink = level.time;
+		return;
+	}
+
+	G_RunObject(saberent);
+}
+
+void MakeDeadSaber(gentity_t *ent)
+{	//spawn a "dead" saber entity here so it looks like the saber fell out of the air.
+	//This entity will remove itself after a very short time period.
+	vec3_t startorg;
+	vec3_t startang;
+	gentity_t *saberent;
+	gentity_t *owner = NULL;
+	
+	if (g_gametype.integer == GT_JEDIMASTER)
+	{ //never spawn a dead saber in JM, because the only saber on the level is really a world object
+		//G_Sound(ent, CHAN_AUTO, saberOffSound);
+		return;
+	}
+
+	saberent = G_Spawn();
+
+	VectorCopy(ent->r.currentOrigin, startorg);
+	VectorCopy(ent->r.currentAngles, startang);
+
+	saberent->classname = "deadsaber";
+			
+	saberent->r.svFlags = SVF_USE_CURRENT_ORIGIN;
+	saberent->r.ownerNum = ent->s.number;
+
+	saberent->clipmask = MASK_PLAYERSOLID;
+	saberent->r.contents = CONTENTS_TRIGGER;//0;
+
+	VectorSet( saberent->r.mins, -3.0f, -3.0f, -1.5f );
+	VectorSet( saberent->r.maxs, 3.0f, 3.0f, 1.5f );
+
+	saberent->touch = SaberBounceSound;
+
+	saberent->think = DeadSaberThink;
+	saberent->nextthink = level.time;
+
+	VectorCopy(startorg, saberent->s.pos.trBase);
+	VectorCopy(startang, saberent->s.apos.trBase);
+
+	VectorCopy(startorg, saberent->s.origin);
+	VectorCopy(startang, saberent->s.angles);
+
+	VectorCopy(startorg, saberent->r.currentOrigin);
+	VectorCopy(startang, saberent->r.currentAngles);
+
+	saberent->s.apos.trType = TR_GRAVITY;
+	saberent->s.apos.trDelta[0] = Q_irand(200, 800);
+	saberent->s.apos.trDelta[1] = Q_irand(200, 800);
+	saberent->s.apos.trDelta[2] = Q_irand(200, 800);
+	saberent->s.apos.trTime = level.time-50;
+
+	saberent->s.pos.trType = TR_GRAVITY;
+	saberent->s.pos.trTime = level.time-50;
+	saberent->flags = FL_BOUNCE_HALF;
+	if (ent->r.ownerNum >= 0 && ent->r.ownerNum < ENTITYNUM_WORLD)
+	{
+		owner = &g_entities[ent->r.ownerNum];
+
+		if (owner->inuse && owner->client &&
+			owner->client->saber[0].model[0])
+		{
+			WP_SaberAddG2Model( saberent, owner->client->saber[0].model, owner->client->saber[0].skin );
+		}
+		else
+		{
+			//WP_SaberAddG2Model( saberent, NULL, 0 );
+			//argh!!!!
+			G_FreeEntity(saberent);
+			return;
+		}
+	}
+
+	saberent->s.modelGhoul2 = 1;
+	saberent->s.g2radius = 20;
+
+	saberent->s.eType = ET_MISSILE;
+	saberent->s.weapon = WP_SABER;
+
+	saberent->speed = level.time + 4000;
+
+	saberent->bounceCount = 12;
+
+	//fall off in the direction the real saber was headed
+	VectorCopy(ent->s.pos.trDelta, saberent->s.pos.trDelta);
+
+	saberMoveBack(saberent, qtrue);
+	saberent->s.pos.trType = TR_GRAVITY;
+
+	trap_LinkEntity(saberent);	
+}
+
+#define MAX_LEAVE_TIME 20000
+
+void saberReactivate(gentity_t *saberent, gentity_t *saberOwner);
+void saberBackToOwner(gentity_t *saberent);
+
+void DownedSaberThink(gentity_t *saberent)
+{
+	gentity_t *saberOwn = NULL;
+	qboolean notDisowned = qfalse;
+	qboolean pullBack = qfalse;
+
+	saberent->nextthink = level.time;
+
+	if (saberent->r.ownerNum == ENTITYNUM_NONE)
+	{
+		MakeDeadSaber(saberent);
+
+		saberent->think = G_FreeEntity;
+		saberent->nextthink = level.time;
+		return;
+	}
+
+	saberOwn = &g_entities[saberent->r.ownerNum];
+
+	if (!saberOwn ||
+		!saberOwn->inuse ||
+		!saberOwn->client ||
+		saberOwn->client->sess.sessionTeam == TEAM_SPECTATOR ||
+		(saberOwn->client->ps.pm_flags & PMF_FOLLOW))
+	{
+		MakeDeadSaber(saberent);
+
+		saberent->think = G_FreeEntity;
+		saberent->nextthink = level.time;
+		return;
+	}
+
+	if (saberOwn->client->ps.saberEntityNum)
+	{
+		if (saberOwn->client->ps.saberEntityNum == saberent->s.number)
+		{ //owner shouldn't have this set if we're thinking in here. Must've fallen off a cliff and instantly respawned or something.
+			notDisowned = qtrue;
+		}
+		else
+		{ //This should never happen, but just in case..
+			assert(!"ULTRA BAD THING");
+			MakeDeadSaber(saberent);
+
+			saberent->think = G_FreeEntity;
+			saberent->nextthink = level.time;
+			return;
+		}
+	}
+
+	if (notDisowned || saberOwn->health < 1 || !saberOwn->client->ps.fd.forcePowerLevel[FP_SABER_OFFENSE])
+	{ //He's dead, just go back to our normal saber status
+		saberOwn->client->ps.saberEntityNum = saberOwn->client->saberStoredIndex;
+
+		//MakeDeadSaber(saberent); //spawn a dead saber on top of where we are now. The "bodyqueue" method.
+		//Actually this will get taken care of when the thrown saber func sees we're dead.
+
+#ifdef _DEBUG
+		if (saberOwn->client->saberStoredIndex != saberent->s.number)
+		{ //I'm paranoid.
+			assert(!"Bad saber index!!!");
+		}
+#endif
+
+		saberReactivate(saberent, saberOwn);
+
+		if (saberOwn->health < 1)
+		{
+			saberOwn->client->ps.saberInFlight = qfalse;
+			MakeDeadSaber(saberent);
+		}
+
+		saberent->touch = SaberGotHit;
+		saberent->think = SaberUpdateSelf;
+		saberent->genericValue5 = 0;
+		saberent->nextthink = level.time;
+
+		saberent->r.svFlags |= (SVF_NOCLIENT);
+		//saberent->r.contents = CONTENTS_LIGHTSABER;
+		saberent->s.loopSound = 0;
+		saberent->s.loopIsSoundset = qfalse;
+
+		if (saberOwn->health > 0)
+		{ //only set this if he's alive. If dead we want to reflect the lack of saber on the corpse, as he died with his saber out.
+			saberOwn->client->ps.saberInFlight = qfalse;
+			WP_SaberRemoveG2Model( saberent );
+		}
+		saberOwn->client->ps.saberEntityState = 0;
+		saberOwn->client->ps.saberThrowDelay = level.time + 500;
+		saberOwn->client->ps.saberCanThrow = qfalse;
+
+		return;
+	}
+
+	if (saberOwn->client->saberKnockedTime < level.time && (saberOwn->client->pers.cmd.buttons & BUTTON_ATTACK))
+	{ //He wants us back
+		pullBack = qtrue;
+	}
+	else if ((level.time - saberOwn->client->saberKnockedTime) > MAX_LEAVE_TIME)
+	{ //Been sitting around for too long, go back no matter what he wants.
+		pullBack = qtrue;
+	}
+
+	if (pullBack)
+	{ //Get going back to the owner.
+		saberOwn->client->ps.saberEntityNum = saberOwn->client->saberStoredIndex;
+
+#ifdef _DEBUG
+		if (saberOwn->client->saberStoredIndex != saberent->s.number)
+		{ //I'm paranoid.
+			assert(!"Bad saber index!!!");
+		}
+#endif
+		saberReactivate(saberent, saberOwn);
+
+		saberent->touch = SaberGotHit;
+
+		saberent->think = saberBackToOwner;
+		saberent->speed = 0;
+		saberent->genericValue5 = 0;
+		saberent->nextthink = level.time;
+
+		saberent->r.contents = CONTENTS_LIGHTSABER;
+
+		G_Sound( saberOwn, CHAN_BODY, G_SoundIndex( "sound/weapons/force/pull.wav" ) );
+		if (saberOwn->client->saber[0].soundOn)
+		{
+			G_Sound( saberent, CHAN_BODY, saberOwn->client->saber[0].soundOn );
+		}
+		if (saberOwn->client->saber[1].soundOn)
+		{
+			G_Sound( saberOwn, CHAN_BODY, saberOwn->client->saber[1].soundOn );
+		}
+
+		return;
+	}
+
+	G_RunObject(saberent);
+	saberent->nextthink = level.time;
+}
+
+void saberReactivate(gentity_t *saberent, gentity_t *saberOwner)
+{
+	saberent->s.saberInFlight = qtrue;
+
+	saberent->s.apos.trType = TR_LINEAR;
+	saberent->s.apos.trDelta[0] = 0;
+	saberent->s.apos.trDelta[1] = 800;
+	saberent->s.apos.trDelta[2] = 0;
+
+	saberent->s.pos.trType = TR_LINEAR;
+	saberent->s.eType = ET_GENERAL;
+	saberent->s.eFlags = 0;
+
+	saberent->parent = saberOwner;
+
+	saberent->genericValue5 = 0;
+
+	SetSaberBoxSize(saberent);
+
+	saberent->touch = thrownSaberTouch;
+
+	saberent->s.weapon = WP_SABER;
+
+	saberOwner->client->ps.saberEntityState = 1;
+
+	trap_LinkEntity(saberent);
+}
+
+#define SABER_RETRIEVE_DELAY 3000 //3 seconds for now. This will leave you nice and open if you lose your saber.
+
+void saberKnockDown(gentity_t *saberent, gentity_t *saberOwner, gentity_t *other)
+{
+	saberOwner->client->ps.saberEntityNum = 0; //still stored in client->saberStoredIndex
+	saberOwner->client->saberKnockedTime = level.time + SABER_RETRIEVE_DELAY;
+
+	saberent->clipmask = MASK_SOLID;
+	saberent->r.contents = CONTENTS_TRIGGER;//0;
+
+	VectorSet( saberent->r.mins, -3.0f, -3.0f, -1.5f );
+	VectorSet( saberent->r.maxs, 3.0f, 3.0f, 1.5f );
+
+	saberent->s.apos.trType = TR_GRAVITY;
+	saberent->s.apos.trDelta[0] = Q_irand(200, 800);
+	saberent->s.apos.trDelta[1] = Q_irand(200, 800);
+	saberent->s.apos.trDelta[2] = Q_irand(200, 800);
+	saberent->s.apos.trTime = level.time-50;
+
+	saberent->s.pos.trType = TR_GRAVITY;
+	saberent->s.pos.trTime = level.time-50;
+	saberent->flags |= FL_BOUNCE_HALF;
+
+	WP_SaberAddG2Model( saberent, saberOwner->client->saber[0].model, saberOwner->client->saber[0].skin );
+
+	saberent->s.modelGhoul2 = 1;
+	saberent->s.g2radius = 20;
+
+	saberent->s.eType = ET_MISSILE;
+	saberent->s.weapon = WP_SABER;
+
+	saberent->speed = level.time + 4000;
+
+	saberent->bounceCount = -5;//8;
+
+	saberMoveBack(saberent, qtrue);
+	saberent->s.pos.trType = TR_GRAVITY;
+
+	saberent->s.loopSound = 0; //kill this in case it was spinning.
+	saberent->s.loopIsSoundset = qfalse;
+
+	saberent->r.svFlags &= ~(SVF_NOCLIENT); //make sure the client is getting updates on where it is and such.
+
+	saberent->touch = SaberBounceSound;
+	saberent->think = DownedSaberThink;
+	saberent->nextthink = level.time;
+
+	if (saberOwner != other)
+	{ //if someone knocked it out of the air and it wasn't turned off, go in the direction they were facing.
+		if (other->inuse && other->client)
+		{
+			vec3_t otherFwd;
+			float deflectSpeed = 200;
+
+			AngleVectors(other->client->ps.viewangles, otherFwd, 0, 0);
+
+			saberent->s.pos.trDelta[0] = otherFwd[0]*deflectSpeed;
+			saberent->s.pos.trDelta[1] = otherFwd[1]*deflectSpeed;
+			saberent->s.pos.trDelta[2] = otherFwd[2]*deflectSpeed;
+		}
+	}
+
+	trap_LinkEntity(saberent);
+
+	if (saberOwner->client->saber[0].soundOff)
+	{
+		G_Sound( saberent, CHAN_BODY, saberOwner->client->saber[0].soundOff );
+	}
+
+	if (saberOwner->client->saber[1].soundOff &&
+		saberOwner->client->saber[1].model[0])
+	{
+		G_Sound( saberOwner, CHAN_BODY, saberOwner->client->saber[1].soundOff );
+	}
+}
+
+//sort of a silly macro I guess. But if I change anything in here I'll probably want it to be everywhere.
+#define SABERINVALID (!saberent || !saberOwner || !other || !saberent->inuse || !saberOwner->inuse || !other->inuse || !saberOwner->client || !other->client || !saberOwner->client->ps.saberEntityNum || saberOwner->client->ps.saberLockTime > (level.time-100))
+
+void WP_SaberRemoveG2Model( gentity_t *saberent )
+{
+	if ( saberent->ghoul2 )
+	{
+		trap_G2API_RemoveGhoul2Models( &saberent->ghoul2 );
+	}
+}
+
+void WP_SaberAddG2Model( gentity_t *saberent, const char *saberModel, qhandle_t saberSkin )
+{
+	WP_SaberRemoveG2Model( saberent );
+	if ( saberModel && saberModel[0] )
+	{
+		saberent->s.modelindex = G_ModelIndex(saberModel);
+	}
+	else
+	{
+		saberent->s.modelindex = G_ModelIndex( "models/weapons2/saber/saber_w.glm" );
+	}
+	//FIXME: use customSkin?
+	trap_G2API_InitGhoul2Model( &saberent->ghoul2, saberModel, saberent->s.modelindex, saberSkin, 0, 0, 0 );
+}
+
+//Make the saber go flying directly out of the owner's hand in the specified direction
+qboolean saberKnockOutOfHand(gentity_t *saberent, gentity_t *saberOwner, vec3_t velocity)
+{
+	if (!saberent || !saberOwner ||
+		!saberent->inuse || !saberOwner->inuse ||
+		!saberOwner->client)
+	{
+		return qfalse;
+	}
+
+	if (!saberOwner->client->ps.saberEntityNum)
+	{ //already gone
+		return qfalse;
+	}
+
+	if ((level.time - saberOwner->client->lastSaberStorageTime) > 50)
+	{ //must have a reasonably updated saber base pos
+		return qfalse;
+	}
+
+	if (saberOwner->client->ps.saberLockTime > (level.time-100))
+	{
+		return qfalse;
+	}
+	if ( !saberOwner->client->saber[0].disarmable )
+	{
+		return qfalse;
+	}
+
+	saberOwner->client->ps.saberInFlight = qtrue;
+	saberOwner->client->ps.saberEntityState = 1;
+
+	saberent->s.saberInFlight = qfalse;//qtrue;
+
+	saberent->s.pos.trType = TR_LINEAR;
+	saberent->s.eType = ET_GENERAL;
+	saberent->s.eFlags = 0;
+
+	WP_SaberAddG2Model( saberent, saberOwner->client->saber[0].model, saberOwner->client->saber[0].skin );
+
+	saberent->s.modelGhoul2 = 127;
+
+	saberent->parent = saberOwner;
+
+	saberent->damage = SABER_THROWN_HIT_DAMAGE;
+	saberent->methodOfDeath = MOD_SABER;
+	saberent->splashMethodOfDeath = MOD_SABER;
+	saberent->s.solid = 2;
+	saberent->r.contents = CONTENTS_LIGHTSABER;
+
+	saberent->genericValue5 = 0;
+
+	VectorSet( saberent->r.mins, -24.0f, -24.0f, -8.0f );
+	VectorSet( saberent->r.maxs, 24.0f, 24.0f, 8.0f );
+
+	saberent->s.genericenemyindex = saberOwner->s.number+1024;
+	saberent->s.weapon = WP_SABER;
+
+	saberent->genericValue5 = 0;
+
+	G_SetOrigin(saberent, saberOwner->client->lastSaberBase_Always); //use this as opposed to the right hand bolt,
+	//because I don't want to risk reconstructing the skel again to get it here. And it isn't worth storing.
+	saberKnockDown(saberent, saberOwner, saberOwner);
+	VectorCopy(velocity, saberent->s.pos.trDelta); //override the velocity on the knocked away saber.
+	
+	return qtrue;
+}
+
+//Called at the result of a circle lock duel - the loser gets his saber tossed away and is put into a reflected attack anim
+qboolean saberCheckKnockdown_DuelLoss(gentity_t *saberent, gentity_t *saberOwner, gentity_t *other)
+{
+	vec3_t dif;
+	float totalDistance = 1;
+	float distScale = 6.5f;
+	qboolean validMomentum = qtrue;
+	int	disarmChance = 1;
+
+	if (SABERINVALID)
+	{
+		return qfalse;
+	}
+
+	VectorClear(dif);
+
+	if (!other->client->olderIsValid || (level.time - other->client->lastSaberStorageTime) >= 200)
+	{ //see if the spots are valid
+		validMomentum = qfalse;
+	}
+
+	if (validMomentum)
+	{
+		//Get the difference 
+		VectorSubtract(other->client->lastSaberBase_Always, other->client->olderSaberBase, dif);
+		totalDistance = VectorNormalize(dif);
+
+		if (!totalDistance)
+		{ //fine, try our own
+			if (!saberOwner->client->olderIsValid || (level.time - saberOwner->client->lastSaberStorageTime) >= 200)
+			{
+				validMomentum = qfalse;
+			}
+
+			if (validMomentum)
+			{
+				VectorSubtract(saberOwner->client->lastSaberBase_Always, saberOwner->client->olderSaberBase, dif);
+				totalDistance = VectorNormalize(dif);
+			}
+		}
+
+		if (validMomentum)
+		{
+			if (!totalDistance)
+			{ //try the difference between the two blades
+				VectorSubtract(saberOwner->client->lastSaberBase_Always, other->client->lastSaberBase_Always, dif);
+				totalDistance = VectorNormalize(dif);
+			}
+
+			if (totalDistance)
+			{ //if we still have no difference somehow, just let it fall to the ground when the time comes.
+				if (totalDistance < 20)
+				{
+					totalDistance = 20;
+				}
+				VectorScale(dif, totalDistance*distScale, dif);
+			}
+		}
+	}
+
+	saberOwner->client->ps.saberMove = LS_V1_BL; //rwwFIXMEFIXME: Ideally check which lock it was exactly and use the proper anim (same goes for the attacker)
+	saberOwner->client->ps.saberBlocked = BLOCKED_BOUNCE_MOVE;
+
+	if ( other && other->client )
+	{
+		disarmChance += other->client->saber[0].disarmBonus;
+		if ( other->client->saber[1].model
+			&& other->client->saber[1].model[0]
+			&& !other->client->ps.saberHolstered )
+		{
+			other->client->saber[1].disarmBonus;
+		}
+	}
+	if ( Q_irand( 0, disarmChance ) )
+	{
+		return saberKnockOutOfHand(saberent, saberOwner, dif);
+	}
+	else
+	{
+		return qfalse;
+	}
+}
+
+//Called when we want to try knocking the saber out of the owner's hand upon them going into a broken parry.
+//Also called on reflected attacks.
+qboolean saberCheckKnockdown_BrokenParry(gentity_t *saberent, gentity_t *saberOwner, gentity_t *other)
+{
+	int myAttack;
+	int otherAttack;
+	qboolean doKnock = qfalse;
+	int	disarmChance = 1;
+
+	if (SABERINVALID)
+	{
+		return qfalse;
+	}
+
+	//Neither gets an advantage based on attack state, when it comes to knocking
+	//saber out of hand.
+	myAttack = G_SaberAttackPower(saberOwner, qfalse);
+	otherAttack = G_SaberAttackPower(other, qfalse);
+
+	if (!other->client->olderIsValid || (level.time - other->client->lastSaberStorageTime) >= 200)
+	{ //if we don't know which way to throw the saber based on momentum between saber positions, just don't throw it
+		return qfalse;
+	}
+
+	//only knock the saber out of the hand if they're in a stronger stance I suppose. Makes strong more advantageous.
+	if (otherAttack > myAttack+1 && Q_irand(1, 10) <= 7)
+	{ //This would be, say, strong stance against light stance.
+		doKnock = qtrue;
+	}
+	else if (otherAttack > myAttack && Q_irand(1, 10) <= 3)
+	{ //Strong vs. medium, medium vs. light
+		doKnock = qtrue;
+	}
+
+	if (doKnock)
+	{
+		vec3_t dif;
+		float totalDistance;
+		float distScale = 6.5f;
+
+		VectorSubtract(other->client->lastSaberBase_Always, other->client->olderSaberBase, dif);
+		totalDistance = VectorNormalize(dif);
+
+		if (!totalDistance)
+		{ //fine, try our own
+			if (!saberOwner->client->olderIsValid || (level.time - saberOwner->client->lastSaberStorageTime) >= 200)
+			{ //if we don't know which way to throw the saber based on momentum between saber positions, just don't throw it
+				return qfalse;
+			}
+
+			VectorSubtract(saberOwner->client->lastSaberBase_Always, saberOwner->client->olderSaberBase, dif);
+			totalDistance = VectorNormalize(dif);
+		}
+
+		if (!totalDistance)
+		{ //...forget it then.
+			return qfalse;
+		}
+
+		if (totalDistance < 20)
+		{
+			totalDistance = 20;
+		}
+		VectorScale(dif, totalDistance*distScale, dif);
+
+		if ( other && other->client )
+		{
+			disarmChance += other->client->saber[0].disarmBonus;
+			if ( other->client->saber[1].model
+				&& other->client->saber[1].model[0]
+				&& !other->client->ps.saberHolstered )
+			{
+				other->client->saber[1].disarmBonus;
+			}
+		}
+		if ( Q_irand( 0, disarmChance ) )
+		{
+			return saberKnockOutOfHand(saberent, saberOwner, dif);
+		}
+	}
+
+	return qfalse;
+}
+
+#include "../namespace_begin.h"
+qboolean BG_InExtraDefenseSaberMove( int move );
+#include "../namespace_end.h"
+
+//Called upon an enemy actually slashing into a thrown saber
+qboolean saberCheckKnockdown_Smashed(gentity_t *saberent, gentity_t *saberOwner, gentity_t *other, int damage)
+{
+	if (SABERINVALID)
+	{
+		return qfalse;
+	}
+
+	if (!saberOwner->client->ps.saberInFlight)
+	{ //can only do this if the saber is already actually in flight
+		return qfalse;
+	}
+
+	if ( other
+		&& other->inuse
+		&& other->client 
+		&& BG_InExtraDefenseSaberMove( other->client->ps.saberMove ) )
+	{ //make sure the blow was strong enough
+		saberKnockDown(saberent, saberOwner, other);
+		return qtrue;
+	}
+
+	if (damage > 10)
+	{ //make sure the blow was strong enough
+		saberKnockDown(saberent, saberOwner, other);
+		return qtrue;
+	}
+
+	return qfalse;
+}
+
+//Called upon blocking a thrown saber. If the throw level compared to the blocker's defense level
+//is inferior, or equal and a random factor is met, then the saber will be tossed to the ground.
+qboolean saberCheckKnockdown_Thrown(gentity_t *saberent, gentity_t *saberOwner, gentity_t *other)
+{
+	int throwLevel = 0;
+	int defenLevel = 0;
+	qboolean tossIt = qfalse;
+
+	if (SABERINVALID)
+	{
+		return qfalse;
+	}
+
+	defenLevel = other->client->ps.fd.forcePowerLevel[FP_SABER_DEFENSE];
+	throwLevel = saberOwner->client->ps.fd.forcePowerLevel[FP_SABERTHROW];
+
+	if (defenLevel > throwLevel)
+	{
+		tossIt = qtrue;
+	}
+	else if (defenLevel == throwLevel && Q_irand(1, 10) <= 4)
+	{
+		tossIt = qtrue;
+	}
+	//otherwise don't
+
+	if (tossIt)
+	{
+		saberKnockDown(saberent, saberOwner, other);
+		return qtrue;
+	}
+
+	return qfalse;
+}
+
+void saberBackToOwner(gentity_t *saberent)
+{
+	gentity_t *saberOwner = &g_entities[saberent->r.ownerNum];
+	vec3_t dir;
+	float ownerLen;
+
+	if (saberent->r.ownerNum == ENTITYNUM_NONE)
+	{
+		MakeDeadSaber(saberent);
+
+		saberent->think = G_FreeEntity;
+		saberent->nextthink = level.time;
+		return;
+	}
+
+	if (!saberOwner->inuse ||
+		!saberOwner->client ||
+		saberOwner->client->sess.sessionTeam == TEAM_SPECTATOR)
+	{
+		MakeDeadSaber(saberent);
+
+		saberent->think = G_FreeEntity;
+		saberent->nextthink = level.time;
+		return;
+	}
+
+	if (saberOwner->health < 1 || !saberOwner->client->ps.fd.forcePowerLevel[FP_SABER_OFFENSE])
+	{ //He's dead, just go back to our normal saber status
+		saberent->touch = SaberGotHit;
+		saberent->think = SaberUpdateSelf;
+		saberent->genericValue5 = 0;
+		saberent->nextthink = level.time;
+
+		if (saberOwner->client &&
+			saberOwner->client->saber[0].soundOff)
+		{
+			G_Sound(saberent, CHAN_AUTO, saberOwner->client->saber[0].soundOff);
+		}
+		MakeDeadSaber(saberent);
+
+		saberent->r.svFlags |= (SVF_NOCLIENT);
+		saberent->r.contents = CONTENTS_LIGHTSABER;
+		SetSaberBoxSize(saberent);
+		saberent->s.loopSound = 0;
+		saberent->s.loopIsSoundset = qfalse;
+		WP_SaberRemoveG2Model( saberent );
+
+		saberOwner->client->ps.saberInFlight = qfalse;
+		saberOwner->client->ps.saberEntityState = 0;
+		saberOwner->client->ps.saberThrowDelay = level.time + 500;
+		saberOwner->client->ps.saberCanThrow = qfalse;
+
+		return;
+	}
+
+	//make sure this is set alright
+	assert(saberOwner->client->ps.saberEntityNum == saberent->s.number ||
+		saberOwner->client->saberStoredIndex == saberent->s.number);
+	saberOwner->client->ps.saberEntityNum = saberent->s.number;
+
+	saberent->r.contents = CONTENTS_LIGHTSABER;
+
+	VectorSubtract(saberent->pos1, saberent->r.currentOrigin, dir);
+
+	ownerLen = VectorLength(dir);
+
+	if (saberent->speed < level.time)
+	{
+		float baseSpeed = 900;
+
+		VectorNormalize(dir);
+
+		saberMoveBack(saberent, qtrue);
+		VectorCopy(saberent->r.currentOrigin, saberent->s.pos.trBase);
+
+		if (saberOwner->client->ps.fd.forcePowerLevel[FP_SABERTHROW] >= FORCE_LEVEL_3)
+		{ //allow players with high saber throw rank to control the return speed of the saber
+			baseSpeed = 900;
+
+			saberent->speed = level.time;// + 200;
+		}
+		else
+		{
+			baseSpeed = 700;
+			saberent->speed = level.time + 50;
+		}
+
+		//Gradually slow down as it approaches, so it looks smoother coming into the hand.
+		if (ownerLen < 64)
+		{
+			VectorScale(dir, baseSpeed-200, saberent->s.pos.trDelta );
+		}
+		else if (ownerLen < 128)
+		{
+			VectorScale(dir, baseSpeed-150, saberent->s.pos.trDelta );
+		}
+		else if (ownerLen < 256)
+		{
+			VectorScale(dir, baseSpeed-100, saberent->s.pos.trDelta );
+		}
+		else
+		{
+			VectorScale(dir, baseSpeed, saberent->s.pos.trDelta );
+		}
+
+		saberent->s.pos.trTime = level.time;
+	}
+
+	/*
+	if (ownerLen <= 512)
+	{
+		saberent->s.saberInFlight = qfalse;
+		saberent->s.loopSound = saberHumSound;
+		saberent->s.loopIsSoundset = qfalse;
+	}
+	*/
+	//I'm just doing this now. I don't really like the spin on the way back. And it does weird stuff with the new saber-knocked-away code.
+	if (saberOwner->client->ps.saberEntityNum == saberent->s.number)
+	{
+		if ( !saberOwner->client->saber[0].returnDamage
+			|| saberOwner->client->ps.saberHolstered )
+		{
+			saberent->s.saberInFlight = qfalse;
+		}
+		saberent->s.loopSound = saberOwner->client->saber[0].soundLoop;
+		saberent->s.loopIsSoundset = qfalse;
+
+		if (ownerLen <= 32)
+		{
+			G_Sound( saberent, CHAN_AUTO, G_SoundIndex( "sound/weapons/saber/saber_catch.wav" ) );
+
+			saberOwner->client->ps.saberInFlight = qfalse;
+			saberOwner->client->ps.saberEntityState = 0;
+			saberOwner->client->ps.saberCanThrow = qfalse;
+			saberOwner->client->ps.saberThrowDelay = level.time + 300;
+
+			saberent->touch = SaberGotHit;
+
+			saberent->think = SaberUpdateSelf;
+			saberent->genericValue5 = 0;
+			saberent->nextthink = level.time + 50;
+			WP_SaberRemoveG2Model( saberent );
+
+			return;
+		}
+
+		if (!saberent->s.saberInFlight)
+		{
+			saberCheckRadiusDamage(saberent, 1);
+		}
+		else
+		{
+			saberCheckRadiusDamage(saberent, 2);
+		}
+
+		saberMoveBack(saberent, qtrue);
+	}
+
+	saberent->nextthink = level.time;
+}
+
+void saberFirstThrown(gentity_t *saberent);
+
+void thrownSaberTouch (gentity_t *saberent, gentity_t *other, trace_t *trace)
+{
+	gentity_t *hitEnt = other;
+
+	if (other && other->s.number == saberent->r.ownerNum)
+	{
+		return;
+	}
+	VectorClear(saberent->s.pos.trDelta);
+	saberent->s.pos.trTime = level.time;
+
+	saberent->s.apos.trType = TR_LINEAR;
+	saberent->s.apos.trDelta[0] = 0;
+	saberent->s.apos.trDelta[1] = 800;
+	saberent->s.apos.trDelta[2] = 0;
+
+	VectorCopy(saberent->r.currentOrigin, saberent->s.pos.trBase);
+
+	saberent->think = saberBackToOwner;
+	saberent->nextthink = level.time;
+
+	if (other && other->r.ownerNum < MAX_CLIENTS &&
+		(other->r.contents & CONTENTS_LIGHTSABER) &&
+		g_entities[other->r.ownerNum].client &&
+		g_entities[other->r.ownerNum].inuse)
+	{
+		hitEnt = &g_entities[other->r.ownerNum];
+	}
+
+	//we'll skip the dist check, since we don't really care about that (we just hit it physically)
+	CheckThrownSaberDamaged(saberent, &g_entities[saberent->r.ownerNum], hitEnt, 256, 0, qtrue);
+
+	saberent->speed = 0;
+}
+
+#define SABER_MAX_THROW_DISTANCE 700
+
+void saberFirstThrown(gentity_t *saberent)
+{
+	vec3_t		vSub;
+	float		vLen;
+	gentity_t	*saberOwn = &g_entities[saberent->r.ownerNum];
+
+	if (saberent->r.ownerNum == ENTITYNUM_NONE)
+	{
+		MakeDeadSaber(saberent);
+
+		saberent->think = G_FreeEntity;
+		saberent->nextthink = level.time;
+		return;
+	}
+
+	if (!saberOwn ||
+		!saberOwn->inuse ||
+		!saberOwn->client ||
+		saberOwn->client->sess.sessionTeam == TEAM_SPECTATOR)
+	{
+		MakeDeadSaber(saberent);
+
+		saberent->think = G_FreeEntity;
+		saberent->nextthink = level.time;
+		return;
+	}
+
+	if (saberOwn->health < 1 || !saberOwn->client->ps.fd.forcePowerLevel[FP_SABER_OFFENSE])
+	{ //He's dead, just go back to our normal saber status
+		saberent->touch = SaberGotHit;
+		saberent->think = SaberUpdateSelf;
+		saberent->genericValue5 = 0;
+		saberent->nextthink = level.time;
+
+		if (saberOwn->client &&
+			saberOwn->client->saber[0].soundOff)
+		{
+			G_Sound(saberent, CHAN_AUTO, saberOwn->client->saber[0].soundOff);
+		}
+		MakeDeadSaber(saberent);
+
+		saberent->r.svFlags |= (SVF_NOCLIENT);
+		saberent->r.contents = CONTENTS_LIGHTSABER;
+		SetSaberBoxSize(saberent);
+		saberent->s.loopSound = 0;
+		saberent->s.loopIsSoundset = qfalse;
+		WP_SaberRemoveG2Model( saberent );
+
+		saberOwn->client->ps.saberInFlight = qfalse;
+		saberOwn->client->ps.saberEntityState = 0;
+		saberOwn->client->ps.saberThrowDelay = level.time + 500;
+		saberOwn->client->ps.saberCanThrow = qfalse;
+
+		return;
+	}
+
+	if ((level.time - saberOwn->client->ps.saberDidThrowTime) > 500)
+	{
+		if (!(saberOwn->client->buttons & BUTTON_ALT_ATTACK))
+		{ //If owner releases altattack 500ms or later after throwing saber, it autoreturns
+			thrownSaberTouch(saberent, saberent, NULL);
+			goto runMin;
+		}
+		else if ((level.time - saberOwn->client->ps.saberDidThrowTime) > 6000)
+		{ //if it's out longer than 6 seconds, return it
+			thrownSaberTouch(saberent, saberent, NULL);
+			goto runMin;
+		}
+	}
+
+	if (BG_HasYsalamiri(g_gametype.integer, &saberOwn->client->ps))
+	{
+		thrownSaberTouch(saberent, saberent, NULL);
+		goto runMin;
+	}
+	
+	if (!BG_CanUseFPNow(g_gametype.integer, &saberOwn->client->ps, level.time, FP_SABERTHROW))
+	{
+		thrownSaberTouch(saberent, saberent, NULL);
+		goto runMin;
+	}
+
+	VectorSubtract(saberOwn->client->ps.origin, saberent->r.currentOrigin, vSub);
+	vLen = VectorLength(vSub);
+
+	if (vLen >= (SABER_MAX_THROW_DISTANCE*saberOwn->client->ps.fd.forcePowerLevel[FP_SABERTHROW]))
+	{
+		thrownSaberTouch(saberent, saberent, NULL);
+		goto runMin;
+	}
+
+	if (saberOwn->client->ps.fd.forcePowerLevel[FP_SABERTHROW] >= FORCE_LEVEL_2 &&
+		saberent->speed < level.time)
+	{ //if owner is rank 3 in saber throwing, the saber goes where he points
+		vec3_t fwd, traceFrom, traceTo, dir;
+		trace_t tr;
+
+		AngleVectors(saberOwn->client->ps.viewangles, fwd, 0, 0);
+
+		VectorCopy(saberOwn->client->ps.origin, traceFrom);
+		traceFrom[2] += saberOwn->client->ps.viewheight;
+
+		VectorCopy(traceFrom, traceTo);
+		traceTo[0] += fwd[0]*4096;
+		traceTo[1] += fwd[1]*4096;
+		traceTo[2] += fwd[2]*4096;
+
+		saberMoveBack(saberent, qfalse);
+		VectorCopy(saberent->r.currentOrigin, saberent->s.pos.trBase);
+
+		if (saberOwn->client->ps.fd.forcePowerLevel[FP_SABERTHROW] >= FORCE_LEVEL_3)
+		{ //if highest saber throw rank, we can direct the saber toward players directly by looking at them
+			trap_Trace(&tr, traceFrom, NULL, NULL, traceTo, saberOwn->s.number, MASK_PLAYERSOLID);
+		}
+		else
+		{
+			trap_Trace(&tr, traceFrom, NULL, NULL, traceTo, saberOwn->s.number, MASK_SOLID);
+		}
+
+		VectorSubtract(tr.endpos, saberent->r.currentOrigin, dir);
+
+		VectorNormalize(dir);
+
+		VectorScale(dir, 500, saberent->s.pos.trDelta );
+		saberent->s.pos.trTime = level.time;
+
+		if (saberOwn->client->ps.fd.forcePowerLevel[FP_SABERTHROW] >= FORCE_LEVEL_3)
+		{ //we'll treat them to a quicker update rate if their throw rank is high enough
+			saberent->speed = level.time + 100;
+		}
+		else
+		{
+			saberent->speed = level.time + 400;
+		}
+	}
+
+runMin:
+
+	saberCheckRadiusDamage(saberent, 0);
+	G_RunObject(saberent);
+}
+
+void UpdateClientRenderBolts(gentity_t *self, vec3_t renderOrigin, vec3_t renderAngles)
+{
+	mdxaBone_t boltMatrix;
+	renderInfo_t *ri = &self->client->renderInfo;
+
+	if (!self->ghoul2)
+	{
+		VectorCopy(self->client->ps.origin, ri->headPoint);
+		VectorCopy(self->client->ps.origin, ri->handRPoint);
+		VectorCopy(self->client->ps.origin, ri->handLPoint);
+		VectorCopy(self->client->ps.origin, ri->torsoPoint);
+		VectorCopy(self->client->ps.origin, ri->crotchPoint);
+		VectorCopy(self->client->ps.origin, ri->footRPoint);
+		VectorCopy(self->client->ps.origin, ri->footLPoint);
+	}
+	else
+	{
+		//head
+		trap_G2API_GetBoltMatrix(self->ghoul2, 0, ri->headBolt, &boltMatrix, renderAngles, renderOrigin, level.time, NULL, self->modelScale);
+		ri->headPoint[0] = boltMatrix.matrix[0][3];
+		ri->headPoint[1] = boltMatrix.matrix[1][3];
+		ri->headPoint[2] = boltMatrix.matrix[2][3];
+
+		//right hand
+		trap_G2API_GetBoltMatrix(self->ghoul2, 0, ri->handRBolt, &boltMatrix, renderAngles, renderOrigin, level.time, NULL, self->modelScale);
+		ri->handRPoint[0] = boltMatrix.matrix[0][3];
+		ri->handRPoint[1] = boltMatrix.matrix[1][3];
+		ri->handRPoint[2] = boltMatrix.matrix[2][3];
+
+		//left hand
+		trap_G2API_GetBoltMatrix(self->ghoul2, 0, ri->handLBolt, &boltMatrix, renderAngles, renderOrigin, level.time, NULL, self->modelScale);
+		ri->handLPoint[0] = boltMatrix.matrix[0][3];
+		ri->handLPoint[1] = boltMatrix.matrix[1][3];
+		ri->handLPoint[2] = boltMatrix.matrix[2][3];
+
+		//chest
+		trap_G2API_GetBoltMatrix(self->ghoul2, 0, ri->torsoBolt, &boltMatrix, renderAngles, renderOrigin, level.time, NULL, self->modelScale);
+		ri->torsoPoint[0] = boltMatrix.matrix[0][3];
+		ri->torsoPoint[1] = boltMatrix.matrix[1][3];
+		ri->torsoPoint[2] = boltMatrix.matrix[2][3];
+
+		//crotch
+		trap_G2API_GetBoltMatrix(self->ghoul2, 0, ri->crotchBolt, &boltMatrix, renderAngles, renderOrigin, level.time, NULL, self->modelScale);
+		ri->crotchPoint[0] = boltMatrix.matrix[0][3];
+		ri->crotchPoint[1] = boltMatrix.matrix[1][3];
+		ri->crotchPoint[2] = boltMatrix.matrix[2][3];
+
+		//right foot
+		trap_G2API_GetBoltMatrix(self->ghoul2, 0, ri->footRBolt, &boltMatrix, renderAngles, renderOrigin, level.time, NULL, self->modelScale);
+		ri->footRPoint[0] = boltMatrix.matrix[0][3];
+		ri->footRPoint[1] = boltMatrix.matrix[1][3];
+		ri->footRPoint[2] = boltMatrix.matrix[2][3];
+
+		//left foot
+		trap_G2API_GetBoltMatrix(self->ghoul2, 0, ri->footLBolt, &boltMatrix, renderAngles, renderOrigin, level.time, NULL, self->modelScale);
+		ri->footLPoint[0] = boltMatrix.matrix[0][3];
+		ri->footLPoint[1] = boltMatrix.matrix[1][3];
+		ri->footLPoint[2] = boltMatrix.matrix[2][3];
+	}
+
+	self->client->renderInfo.boltValidityTime = level.time;
+}
+
+void UpdateClientRenderinfo(gentity_t *self, vec3_t renderOrigin, vec3_t renderAngles)
+{
+	renderInfo_t *ri = &self->client->renderInfo;
+	if ( ri->mPCalcTime < level.time )
+	{
+		//We're just going to give rough estimates on most of this stuff,
+		//it's not like most of it matters.
+
+	#if 0 //#if 0'd since it's a waste setting all this to 0 each frame.
+		//Should you wish to make any of this valid then feel free to do so.
+		ri->headYawRangeLeft = ri->headYawRangeRight = ri->headPitchRangeUp = ri->headPitchRangeDown = 0;
+		ri->torsoYawRangeLeft = ri->torsoYawRangeRight = ri->torsoPitchRangeUp = ri->torsoPitchRangeDown = 0;
+
+		ri->torsoFpsMod = ri->legsFpsMod = 0;
+
+		VectorClear(ri->customRGB);
+		ri->customAlpha = 0;
+		ri->renderFlags = 0;
+		ri->lockYaw = 0;
+
+		VectorClear(ri->headAngles);
+		VectorClear(ri->torsoAngles);
+
+		//VectorClear(ri->eyeAngles);
+
+		ri->legsYaw = 0;
+	#endif
+
+		if (self->ghoul2 &&
+			self->ghoul2 != ri->lastG2)
+		{ //the g2 instance changed, so update all the bolts.
+			//rwwFIXMEFIXME: Base on skeleton used? Assuming humanoid currently.
+			ri->lastG2 = self->ghoul2;
+
+			if (self->localAnimIndex <= 1)
+			{
+				ri->headBolt = trap_G2API_AddBolt(self->ghoul2, 0, "*head_eyes");
+				ri->handRBolt = trap_G2API_AddBolt(self->ghoul2, 0, "*r_hand");
+				ri->handLBolt = trap_G2API_AddBolt(self->ghoul2, 0, "*l_hand");
+				ri->torsoBolt = trap_G2API_AddBolt(self->ghoul2, 0, "thoracic");
+				ri->crotchBolt = trap_G2API_AddBolt(self->ghoul2, 0, "pelvis");
+				ri->footRBolt = trap_G2API_AddBolt(self->ghoul2, 0, "*r_leg_foot");
+				ri->footLBolt = trap_G2API_AddBolt(self->ghoul2, 0, "*l_leg_foot");
+				ri->motionBolt = trap_G2API_AddBolt(self->ghoul2, 0, "Motion");
+			}
+			else
+			{
+				ri->headBolt = -1;
+				ri->handRBolt = -1;
+				ri->handLBolt = -1;
+				ri->torsoBolt = -1;
+				ri->crotchBolt = -1;
+				ri->footRBolt = -1;
+				ri->footLBolt = -1;
+				ri->motionBolt = -1;
+			}
+
+			ri->lastG2 = self->ghoul2;
+		}
+
+		VectorCopy( self->client->ps.viewangles, self->client->renderInfo.eyeAngles );
+
+		//we'll just say the legs/torso are whatever the first frame of our current anim is.
+		ri->torsoFrame = bgAllAnims[self->localAnimIndex].anims[self->client->ps.torsoAnim].firstFrame;
+		ri->legsFrame = bgAllAnims[self->localAnimIndex].anims[self->client->ps.legsAnim].firstFrame;
+		if (g_debugServerSkel.integer)
+		{	//Alright, I was doing this, but it's just too slow to do every frame.
+			//From now on if we want this data to be valid we're going to have to make a verify call for it before
+			//accessing it. I'm only doing this now if we want to debug the server skel by drawing lines from bolt
+			//positions every frame.
+			mdxaBone_t boltMatrix;
+
+			if (!self->ghoul2)
+			{
+				VectorCopy(self->client->ps.origin, ri->headPoint);
+				VectorCopy(self->client->ps.origin, ri->handRPoint);
+				VectorCopy(self->client->ps.origin, ri->handLPoint);
+				VectorCopy(self->client->ps.origin, ri->torsoPoint);
+				VectorCopy(self->client->ps.origin, ri->crotchPoint);
+				VectorCopy(self->client->ps.origin, ri->footRPoint);
+				VectorCopy(self->client->ps.origin, ri->footLPoint);
+			}
+			else
+			{
+				//head
+				trap_G2API_GetBoltMatrix(self->ghoul2, 0, ri->headBolt, &boltMatrix, renderAngles, renderOrigin, level.time, NULL, self->modelScale);
+				ri->headPoint[0] = boltMatrix.matrix[0][3];
+				ri->headPoint[1] = boltMatrix.matrix[1][3];
+				ri->headPoint[2] = boltMatrix.matrix[2][3];
+
+				//right hand
+				trap_G2API_GetBoltMatrix(self->ghoul2, 0, ri->handRBolt, &boltMatrix, renderAngles, renderOrigin, level.time, NULL, self->modelScale);
+				ri->handRPoint[0] = boltMatrix.matrix[0][3];
+				ri->handRPoint[1] = boltMatrix.matrix[1][3];
+				ri->handRPoint[2] = boltMatrix.matrix[2][3];
+
+				//left hand
+				trap_G2API_GetBoltMatrix(self->ghoul2, 0, ri->handLBolt, &boltMatrix, renderAngles, renderOrigin, level.time, NULL, self->modelScale);
+				ri->handLPoint[0] = boltMatrix.matrix[0][3];
+				ri->handLPoint[1] = boltMatrix.matrix[1][3];
+				ri->handLPoint[2] = boltMatrix.matrix[2][3];
+
+				//chest
+				trap_G2API_GetBoltMatrix(self->ghoul2, 0, ri->torsoBolt, &boltMatrix, renderAngles, renderOrigin, level.time, NULL, self->modelScale);
+				ri->torsoPoint[0] = boltMatrix.matrix[0][3];
+				ri->torsoPoint[1] = boltMatrix.matrix[1][3];
+				ri->torsoPoint[2] = boltMatrix.matrix[2][3];
+
+				//crotch
+				trap_G2API_GetBoltMatrix(self->ghoul2, 0, ri->crotchBolt, &boltMatrix, renderAngles, renderOrigin, level.time, NULL, self->modelScale);
+				ri->crotchPoint[0] = boltMatrix.matrix[0][3];
+				ri->crotchPoint[1] = boltMatrix.matrix[1][3];
+				ri->crotchPoint[2] = boltMatrix.matrix[2][3];
+
+				//right foot
+				trap_G2API_GetBoltMatrix(self->ghoul2, 0, ri->footRBolt, &boltMatrix, renderAngles, renderOrigin, level.time, NULL, self->modelScale);
+				ri->footRPoint[0] = boltMatrix.matrix[0][3];
+				ri->footRPoint[1] = boltMatrix.matrix[1][3];
+				ri->footRPoint[2] = boltMatrix.matrix[2][3];
+
+				//left foot
+				trap_G2API_GetBoltMatrix(self->ghoul2, 0, ri->footLBolt, &boltMatrix, renderAngles, renderOrigin, level.time, NULL, self->modelScale);
+				ri->footLPoint[0] = boltMatrix.matrix[0][3];
+				ri->footLPoint[1] = boltMatrix.matrix[1][3];
+				ri->footLPoint[2] = boltMatrix.matrix[2][3];
+			}
+
+			//Now draw the skel for debug
+			G_TestLine(ri->headPoint, ri->torsoPoint, 0x000000ff, 50);
+			G_TestLine(ri->torsoPoint, ri->handRPoint, 0x000000ff, 50);
+			G_TestLine(ri->torsoPoint, ri->handLPoint, 0x000000ff, 50);
+			G_TestLine(ri->torsoPoint, ri->crotchPoint, 0x000000ff, 50);
+			G_TestLine(ri->crotchPoint, ri->footRPoint, 0x000000ff, 50);
+			G_TestLine(ri->crotchPoint, ri->footLPoint, 0x000000ff, 50);
+		}
+
+		//muzzle point calc (we are going to be cheap here)
+		VectorCopy(ri->muzzlePoint, ri->muzzlePointOld);
+		VectorCopy(self->client->ps.origin, ri->muzzlePoint);
+		VectorCopy(ri->muzzleDir, ri->muzzleDirOld);
+		AngleVectors(self->client->ps.viewangles, ri->muzzleDir, 0, 0);
+		ri->mPCalcTime = level.time;
+
+		VectorCopy(self->client->ps.origin, ri->eyePoint);
+		ri->eyePoint[2] += self->client->ps.viewheight;
+	}
+}
+
+#define STAFF_KICK_RANGE 16
+extern void G_GetBoltPosition( gentity_t *self, int boltIndex, vec3_t pos, int modelIndex ); //NPC_utils.c
+
+extern qboolean BG_InKnockDown( int anim );
+static qboolean G_KickDownable(gentity_t *ent)
+{
+	if (!d_saberKickTweak.integer)
+	{
+		return qtrue;
+	}
+
+	if (!ent || !ent->inuse || !ent->client)
+	{
+		return qfalse;
+	}
+
+	if (BG_InKnockDown(ent->client->ps.legsAnim) ||
+		BG_InKnockDown(ent->client->ps.torsoAnim))
+	{
+		return qfalse;
+	}
+
+	if (ent->client->ps.weaponTime <= 0 &&
+		ent->client->ps.weapon == WP_SABER &&
+		ent->client->ps.groundEntityNum != ENTITYNUM_NONE)
+	{
+		return qfalse;
+	}
+
+	return qtrue;
+}
+
+static void G_TossTheMofo(gentity_t *ent, vec3_t tossDir, float tossStr)
+{
+	if (!ent->inuse || !ent->client)
+	{ //no good
+		return;
+	}
+
+	if (ent->s.eType == ET_NPC && ent->s.NPC_class == CLASS_VEHICLE)
+	{ //no, silly
+		return;
+	}
+
+	VectorMA(ent->client->ps.velocity, tossStr, tossDir, ent->client->ps.velocity);
+	ent->client->ps.velocity[2] = 200;
+	if (ent->health > 0 && ent->client->ps.forceHandExtend != HANDEXTEND_KNOCKDOWN &&
+		BG_KnockDownable(&ent->client->ps) &&
+		G_KickDownable(ent))
+	{ //if they are alive, knock them down I suppose
+		ent->client->ps.forceHandExtend = HANDEXTEND_KNOCKDOWN;
+		ent->client->ps.forceHandExtendTime = level.time + 700;
+		ent->client->ps.forceDodgeAnim = 0; //this toggles between 1 and 0, when it's 1 we should play the get up anim
+		//ent->client->ps.quickerGetup = qtrue;
+	}
+}
+
+static gentity_t *G_KickTrace( gentity_t *ent, vec3_t kickDir, float kickDist, vec3_t kickEnd, int kickDamage, float kickPush )
+{
+	vec3_t	traceOrg, traceEnd, kickMins, kickMaxs;
+	trace_t	trace;
+	gentity_t	*hitEnt = NULL;
+	VectorSet(kickMins, -2.0f, -2.0f, -2.0f);
+	VectorSet(kickMaxs, 2.0f, 2.0f, 2.0f);
+	//FIXME: variable kick height?
+	if ( kickEnd && !VectorCompare( kickEnd, vec3_origin ) )
+	{//they passed us the end point of the trace, just use that
+		//this makes the trace flat
+		VectorSet( traceOrg, ent->r.currentOrigin[0], ent->r.currentOrigin[1], kickEnd[2] );
+		VectorCopy( kickEnd, traceEnd );
+	}
+	else
+	{//extrude
+		VectorSet( traceOrg, ent->r.currentOrigin[0], ent->r.currentOrigin[1], ent->r.currentOrigin[2]+ent->r.maxs[2]*0.5f );
+		VectorMA( traceOrg, kickDist, kickDir, traceEnd );
+	}
+
+	if (d_saberKickTweak.integer)
+	{
+		trap_G2Trace( &trace, traceOrg, kickMins, kickMaxs, traceEnd, ent->s.number, MASK_SHOT, G2TRFLAG_DOGHOULTRACE|G2TRFLAG_GETSURFINDEX|G2TRFLAG_THICK|G2TRFLAG_HITCORPSES, g_g2TraceLod.integer );
+	}
+	else
+	{
+		trap_Trace( &trace, traceOrg, kickMins, kickMaxs, traceEnd, ent->s.number, MASK_SHOT );
+	}
+
+	//G_TestLine(traceOrg, traceEnd, 0x0000ff, 5000);
+	if ( trace.fraction < 1.0f && !trace.startsolid && !trace.allsolid )
+	{
+		if (ent->client->jediKickTime > level.time)
+		{
+			if (trace.entityNum == ent->client->jediKickIndex)
+			{ //we are hitting the same ent we last hit in this same anim, don't hit it again
+				return NULL;
+			}
+		}
+		ent->client->jediKickIndex = trace.entityNum;
+		ent->client->jediKickTime = level.time + ent->client->ps.legsTimer;
+
+		hitEnt = &g_entities[trace.entityNum];
+		//FIXME: regardless of what we hit, do kick hit sound and impact effect
+		//G_PlayEffect( "misc/kickHit", trace.endpos, trace.plane.normal );
+		if ( ent->client->ps.torsoAnim == BOTH_A7_HILT )
+		{
+			G_Sound( ent, CHAN_AUTO, G_SoundIndex( "sound/movers/objects/saber_slam" ) );
+		}
+		else
+		{
+			G_Sound( ent, CHAN_AUTO, G_SoundIndex( va( "sound/weapons/melee/punch%d", Q_irand( 1, 4 ) ) ) );
+		}
+		if ( hitEnt->inuse )
+		{//we hit an entity
+			//FIXME: don't hit same ent more than once per kick
+			if ( hitEnt->takedamage )
+			{//hurt it
+				if (hitEnt->client)
+				{
+					hitEnt->client->ps.otherKiller = ent->s.number;
+					hitEnt->client->ps.otherKillerDebounceTime = level.time + 10000;
+					hitEnt->client->ps.otherKillerTime = level.time + 10000;
+				}
+
+				if (d_saberKickTweak.integer)
+				{
+					G_Damage( hitEnt, ent, ent, kickDir, trace.endpos, kickDamage*0.2f, DAMAGE_NO_KNOCKBACK, MOD_MELEE );
+				}
+				else
+				{
+					G_Damage( hitEnt, ent, ent, kickDir, trace.endpos, kickDamage, DAMAGE_NO_KNOCKBACK, MOD_MELEE );
+				}
+			}
+			if ( hitEnt->client 
+				&& !(hitEnt->client->ps.pm_flags&PMF_TIME_KNOCKBACK) //not already flying through air?  Intended to stop multiple hits, but...
+				&& G_CanBeEnemy(ent, hitEnt) )
+			{//FIXME: this should not always work
+				if ( hitEnt->health <= 0 )
+				{//we kicked a dead guy
+					//throw harder - FIXME: no matter how hard I push them, they don't go anywhere... corpses use less physics???
+				//	G_Throw( hitEnt, kickDir, kickPush*4 );
+					//see if we should play a better looking death on them
+				//	G_ThrownDeathAnimForDeathAnim( hitEnt, trace.endpos );
+					G_TossTheMofo(hitEnt, kickDir, kickPush*4.0f);
+				}
+				else
+				{
+					/*
+					G_Throw( hitEnt, kickDir, kickPush );
+					if ( kickPush >= 75.0f && !Q_irand( 0, 2 ) )
+					{
+						G_Knockdown( hitEnt, ent, kickDir, 300, qtrue );
+					}
+					else
+					{
+						G_Knockdown( hitEnt, ent, kickDir, kickPush, qtrue );
+					}
+					*/
+					if ( kickPush >= 75.0f && !Q_irand( 0, 2 ) )
+					{
+						G_TossTheMofo(hitEnt, kickDir, 300.0f);
+					}
+					else
+					{
+						G_TossTheMofo(hitEnt, kickDir, kickPush);
+					}
+				}
+			}
+		}
+	}
+	return (hitEnt);
+}
+
+static void G_KickSomeMofos(gentity_t *ent)
+{
+	vec3_t	kickDir, kickEnd, fwdAngs;
+	float animLength = BG_AnimLength( ent->localAnimIndex, (animNumber_t)ent->client->ps.legsAnim );
+	float elapsedTime = (float)(animLength-ent->client->ps.legsTimer);
+	float remainingTime = (animLength-elapsedTime);
+	float kickDist = (ent->r.maxs[0]*1.5f)+STAFF_KICK_RANGE+8.0f;//fudge factor of 8
+	int	  kickDamage = Q_irand(10, 15);//Q_irand( 3, 8 ); //since it can only hit a guy once now
+	int	  kickPush = flrand( 50.0f, 100.0f );
+	qboolean doKick = qfalse;
+	renderInfo_t *ri = &ent->client->renderInfo;
+
+	VectorSet(kickDir, 0.0f, 0.0f, 0.0f);
+	VectorSet(kickEnd, 0.0f, 0.0f, 0.0f);
+	VectorSet(fwdAngs, 0.0f, ent->client->ps.viewangles[YAW], 0.0f);
+
+	//HMM... or maybe trace from origin to footRBolt/footLBolt?  Which one?  G2 trace?  Will do hitLoc, if so...
+	if ( ent->client->ps.torsoAnim == BOTH_A7_HILT )
+	{
+		if ( elapsedTime >= 250 && remainingTime >= 250 )
+		{//front
+			doKick = qtrue;
+			if ( ri->handRBolt != -1 )
+			{//actually trace to a bolt
+				G_GetBoltPosition( ent, ri->handRBolt, kickEnd, 0 );
+				VectorSubtract( kickEnd, ent->client->ps.origin, kickDir );
+				kickDir[2] = 0;//ah, flatten it, I guess...
+				VectorNormalize( kickDir );
+			}
+			else
+			{//guess
+				AngleVectors( fwdAngs, kickDir, NULL, NULL );
+			}
+		}
+	}
+	else
+	{
+		switch ( ent->client->ps.legsAnim )
+		{
+		case BOTH_GETUP_BROLL_B:
+		case BOTH_GETUP_BROLL_F:
+		case BOTH_GETUP_FROLL_B:
+		case BOTH_GETUP_FROLL_F:
+			if ( elapsedTime >= 250 && remainingTime >= 250 )
+			{//front
+				doKick = qtrue;
+				if ( ri->footRBolt != -1 )
+				{//actually trace to a bolt
+					G_GetBoltPosition( ent, ri->footRBolt, kickEnd, 0 );
+					VectorSubtract( kickEnd, ent->client->ps.origin, kickDir );
+					kickDir[2] = 0;//ah, flatten it, I guess...
+					VectorNormalize( kickDir );
+				}
+				else
+				{//guess
+					AngleVectors( fwdAngs, kickDir, NULL, NULL );
+				}
+			}
+			break;
+		case BOTH_A7_KICK_F_AIR:
+		case BOTH_A7_KICK_B_AIR:
+		case BOTH_A7_KICK_R_AIR:
+		case BOTH_A7_KICK_L_AIR:
+			if ( elapsedTime >= 100 && remainingTime >= 250 )
+			{//air
+				doKick = qtrue;
+				if ( ri->footRBolt != -1 )
+				{//actually trace to a bolt
+					G_GetBoltPosition( ent, ri->footRBolt, kickEnd, 0 );
+					VectorSubtract( kickEnd, ent->r.currentOrigin, kickDir );
+					kickDir[2] = 0;//ah, flatten it, I guess...
+					VectorNormalize( kickDir );
+				}
+				else
+				{//guess
+					AngleVectors( fwdAngs, kickDir, NULL, NULL );
+				}
+			}
+			break;
+		case BOTH_A7_KICK_F:
+			//FIXME: push forward?
+			if ( elapsedTime >= 250 && remainingTime >= 250 )
+			{//front
+				doKick = qtrue;
+				if ( ri->footRBolt != -1 )
+				{//actually trace to a bolt
+					G_GetBoltPosition( ent, ri->footRBolt, kickEnd, 0 );
+					VectorSubtract( kickEnd, ent->r.currentOrigin, kickDir );
+					kickDir[2] = 0;//ah, flatten it, I guess...
+					VectorNormalize( kickDir );
+				}
+				else
+				{//guess
+					AngleVectors( fwdAngs, kickDir, NULL, NULL );
+				}
+			}
+			break;
+		case BOTH_A7_KICK_B:
+			//FIXME: push back?
+			if ( elapsedTime >= 250 && remainingTime >= 250 )
+			{//back
+				doKick = qtrue;
+				if ( ri->footRBolt != -1 )
+				{//actually trace to a bolt
+					G_GetBoltPosition( ent, ri->footRBolt, kickEnd, 0 );
+					VectorSubtract( kickEnd, ent->r.currentOrigin, kickDir );
+					kickDir[2] = 0;//ah, flatten it, I guess...
+					VectorNormalize( kickDir );
+				}
+				else
+				{//guess
+					AngleVectors( fwdAngs, kickDir, NULL, NULL );
+					VectorScale( kickDir, -1, kickDir );
+				}
+			}
+			break;
+		case BOTH_A7_KICK_R:
+			//FIXME: push right?
+			if ( elapsedTime >= 250 && remainingTime >= 250 )
+			{//right
+				doKick = qtrue;
+				if ( ri->footRBolt != -1 )
+				{//actually trace to a bolt
+					G_GetBoltPosition( ent, ri->footRBolt, kickEnd, 0 );
+					VectorSubtract( kickEnd, ent->r.currentOrigin, kickDir );
+					kickDir[2] = 0;//ah, flatten it, I guess...
+					VectorNormalize( kickDir );
+				}
+				else
+				{//guess
+					AngleVectors( fwdAngs, NULL, kickDir, NULL );
+				}
+			}
+			break;
+		case BOTH_A7_KICK_L:
+			//FIXME: push left?
+			if ( elapsedTime >= 250 && remainingTime >= 250 )
+			{//left
+				doKick = qtrue;
+				if ( ri->footLBolt != -1 )
+				{//actually trace to a bolt
+					G_GetBoltPosition( ent, ri->footLBolt, kickEnd, 0 );
+					VectorSubtract( kickEnd, ent->r.currentOrigin, kickDir );
+					kickDir[2] = 0;//ah, flatten it, I guess...
+					VectorNormalize( kickDir );
+				}
+				else
+				{//guess
+					AngleVectors( fwdAngs, NULL, kickDir, NULL );
+					VectorScale( kickDir, -1, kickDir );
+				}
+			}
+			break;
+		case BOTH_A7_KICK_S:
+			kickPush = flrand( 75.0f, 125.0f );
+			if ( ri->footRBolt != -1 )
+			{//actually trace to a bolt
+				if ( elapsedTime >= 550 
+					&& elapsedTime <= 1050 )
+				{
+					doKick = qtrue;
+					G_GetBoltPosition( ent, ri->footRBolt, kickEnd, 0 );
+					VectorSubtract( kickEnd, ent->r.currentOrigin, kickDir );
+					kickDir[2] = 0;//ah, flatten it, I guess...
+					VectorNormalize( kickDir );
+					//NOTE: have to fudge this a little because it's not getting enough range with the anim as-is
+					VectorMA( kickEnd, 8.0f, kickDir, kickEnd );
+				}
+			}
+			else
+			{//guess
+				if ( elapsedTime >= 400 && elapsedTime < 500 )
+				{//front
+					doKick = qtrue;
+					AngleVectors( fwdAngs, kickDir, NULL, NULL );
+				}
+				else if ( elapsedTime >= 500 && elapsedTime < 600 )
+				{//front-right?
+					doKick = qtrue;
+					fwdAngs[YAW] += 45;
+					AngleVectors( fwdAngs, kickDir, NULL, NULL );
+				}
+				else if ( elapsedTime >= 600 && elapsedTime < 700 )
+				{//right
+					doKick = qtrue;
+					AngleVectors( fwdAngs, NULL, kickDir, NULL );
+				}
+				else if ( elapsedTime >= 700 && elapsedTime < 800 )
+				{//back-right?
+					doKick = qtrue;
+					fwdAngs[YAW] += 45;
+					AngleVectors( fwdAngs, NULL, kickDir, NULL );
+				}
+				else if ( elapsedTime >= 800 && elapsedTime < 900 )
+				{//back
+					doKick = qtrue;
+					AngleVectors( fwdAngs, kickDir, NULL, NULL );
+					VectorScale( kickDir, -1, kickDir );
+				}
+				else if ( elapsedTime >= 900 && elapsedTime < 1000 )
+				{//back-left?
+					doKick = qtrue;
+					fwdAngs[YAW] += 45;
+					AngleVectors( fwdAngs, kickDir, NULL, NULL );
+				}
+				else if ( elapsedTime >= 1000 && elapsedTime < 1100 )
+				{//left
+					doKick = qtrue;
+					AngleVectors( fwdAngs, NULL, kickDir, NULL );
+					VectorScale( kickDir, -1, kickDir );
+				}
+				else if ( elapsedTime >= 1100 && elapsedTime < 1200 )
+				{//front-left?
+					doKick = qtrue;
+					fwdAngs[YAW] += 45;
+					AngleVectors( fwdAngs, NULL, kickDir, NULL );
+					VectorScale( kickDir, -1, kickDir );
+				}
+			}
+			break;
+		case BOTH_A7_KICK_BF:
+			kickPush = flrand( 75.0f, 125.0f );
+			kickDist += 20.0f;
+			if ( elapsedTime < 1500 )
+			{//auto-aim!
+	//			overridAngles = PM_AdjustAnglesForBFKick( ent, ucmd, fwdAngs, qboolean(elapsedTime<850) )?qtrue:overridAngles;
+				//FIXME: if we haven't done the back kick yet and there's no-one there to
+				//			kick anymore, go into some anim that returns us to our base stance
+			}
+			if ( ri->footRBolt != -1 )
+			{//actually trace to a bolt
+				if ( ( elapsedTime >= 750 && elapsedTime < 850 )
+					|| ( elapsedTime >= 1400 && elapsedTime < 1500 ) )
+				{//right, though either would do
+					doKick = qtrue;
+					G_GetBoltPosition( ent, ri->footRBolt, kickEnd, 0 );
+					VectorSubtract( kickEnd, ent->r.currentOrigin, kickDir );
+					kickDir[2] = 0;//ah, flatten it, I guess...
+					VectorNormalize( kickDir );
+					//NOTE: have to fudge this a little because it's not getting enough range with the anim as-is
+					VectorMA( kickEnd, 8, kickDir, kickEnd );
+				}
+			}
+			else
+			{//guess
+				if ( elapsedTime >= 250 && elapsedTime < 350 )
+				{//front
+					doKick = qtrue;
+					AngleVectors( fwdAngs, kickDir, NULL, NULL );
+				}
+				else if ( elapsedTime >= 350 && elapsedTime < 450 )
+				{//back
+					doKick = qtrue;
+					AngleVectors( fwdAngs, kickDir, NULL, NULL );
+					VectorScale( kickDir, -1, kickDir );
+				}
+			}
+			break;
+		case BOTH_A7_KICK_RL:
+			kickPush = flrand( 75.0f, 125.0f );
+			kickDist += 10.0f;
+
+			//ok, I'm tracing constantly on these things, they NEVER hit otherwise (in MP at least)
+
+			//FIXME: auto aim at enemies on the side of us?
+			//overridAngles = PM_AdjustAnglesForRLKick( ent, ucmd, fwdAngs, qboolean(elapsedTime<850) )?qtrue:overridAngles;
+			//if ( elapsedTime >= 250 && elapsedTime < 350 )
+			if (level.framenum&1)
+			{//right
+				doKick = qtrue;
+				if ( ri->footRBolt != -1 )
+				{//actually trace to a bolt
+					G_GetBoltPosition( ent, ri->footRBolt, kickEnd, 0 );
+					VectorSubtract( kickEnd, ent->r.currentOrigin, kickDir );
+					kickDir[2] = 0;//ah, flatten it, I guess...
+					VectorNormalize( kickDir );
+					//NOTE: have to fudge this a little because it's not getting enough range with the anim as-is
+					VectorMA( kickEnd, 8, kickDir, kickEnd );
+				}
+				else
+				{//guess
+					AngleVectors( fwdAngs, NULL, kickDir, NULL );
+				}
+			}
+			//else if ( elapsedTime >= 350 && elapsedTime < 450 )
+			else
+			{//left
+				doKick = qtrue;
+				if ( ri->footLBolt != -1 )
+				{//actually trace to a bolt
+					G_GetBoltPosition( ent, ri->footLBolt, kickEnd, 0 );
+					VectorSubtract( kickEnd, ent->r.currentOrigin, kickDir );
+					kickDir[2] = 0;//ah, flatten it, I guess...
+					VectorNormalize( kickDir );
+					//NOTE: have to fudge this a little because it's not getting enough range with the anim as-is
+					VectorMA( kickEnd, 8, kickDir, kickEnd );
+				}
+				else
+				{//guess
+					AngleVectors( fwdAngs, NULL, kickDir, NULL );
+					VectorScale( kickDir, -1, kickDir );
+				}
+			}
+			break;
+		}
+	}
+
+	if ( doKick )
+	{
+//		G_KickTrace( ent, kickDir, kickDist, kickEnd, kickDamage, kickPush );
+		G_KickTrace( ent, kickDir, kickDist, NULL, kickDamage, kickPush );
+	}
+}
+
+static GAME_INLINE qboolean G_PrettyCloseIGuess(float a, float b, float tolerance)
+{
+    if ((a-b) < tolerance &&
+		(a-b) > -tolerance)
+	{
+		return qtrue;
+	}
+
+	return qfalse;
+}
+
+static void G_GrabSomeMofos(gentity_t *self)
+{
+	renderInfo_t *ri = &self->client->renderInfo;
+	mdxaBone_t boltMatrix;
+	vec3_t flatAng;
+	vec3_t pos;
+	vec3_t grabMins, grabMaxs;
+	trace_t trace;
+
+	if (!self->ghoul2 || ri->handRBolt == -1)
+	{ //no good
+		return;
+	}
+
+    VectorSet(flatAng, 0.0f, self->client->ps.viewangles[1], 0.0f);
+	trap_G2API_GetBoltMatrix(self->ghoul2, 0, ri->handRBolt, &boltMatrix, flatAng, self->client->ps.origin,
+		level.time, NULL, self->modelScale);
+	BG_GiveMeVectorFromMatrix(&boltMatrix, ORIGIN, pos);
+
+	VectorSet(grabMins, -4.0f, -4.0f, -4.0f);
+	VectorSet(grabMaxs, 4.0f, 4.0f, 4.0f);
+
+	//trace from my origin to my hand, if we hit anyone then get 'em
+	trap_G2Trace( &trace, self->client->ps.origin, grabMins, grabMaxs, pos, self->s.number, MASK_SHOT, G2TRFLAG_DOGHOULTRACE|G2TRFLAG_GETSURFINDEX|G2TRFLAG_THICK|G2TRFLAG_HITCORPSES, g_g2TraceLod.integer );
+    
+	if (trace.fraction != 1.0f &&
+		trace.entityNum < ENTITYNUM_WORLD)
+	{
+		gentity_t *grabbed = &g_entities[trace.entityNum];
+
+		if (grabbed->inuse && (grabbed->s.eType == ET_PLAYER || grabbed->s.eType == ET_NPC) &&
+			grabbed->client && grabbed->health > 0 &&
+			G_CanBeEnemy(self, grabbed) &&
+			G_PrettyCloseIGuess(grabbed->client->ps.origin[2], self->client->ps.origin[2], 4.0f) &&
+			(!BG_InGrappleMove(grabbed->client->ps.torsoAnim) || grabbed->client->ps.torsoAnim == BOTH_KYLE_GRAB) &&
+			(!BG_InGrappleMove(grabbed->client->ps.legsAnim) || grabbed->client->ps.legsAnim == BOTH_KYLE_GRAB))
+		{ //grabbed an active player/npc
+			int tortureAnim = -1;
+			int correspondingAnim = -1;
+
+			if (self->client->pers.cmd.forwardmove > 0)
+			{ //punch grab
+				tortureAnim = BOTH_KYLE_PA_1;
+				correspondingAnim = BOTH_PLAYER_PA_1;
+			}
+			else if (self->client->pers.cmd.forwardmove < 0)
+			{ //knee-throw
+				tortureAnim = BOTH_KYLE_PA_2;
+				correspondingAnim = BOTH_PLAYER_PA_2;
+			}
+
+			if (tortureAnim == -1 || correspondingAnim == -1)
+			{
+				if (self->client->ps.torsoTimer < 300 && !self->client->grappleState)
+				{ //you failed to grab anyone, play the "failed to grab" anim
+					G_SetAnim(self, &self->client->pers.cmd, SETANIM_BOTH, BOTH_KYLE_MISS, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD, 0);
+					if (self->client->ps.torsoAnim == BOTH_KYLE_MISS)
+					{ //providing the anim set succeeded..
+						self->client->ps.weaponTime = self->client->ps.torsoTimer;
+					}
+				}
+				return;
+			}
+
+			self->client->grappleIndex = grabbed->s.number;
+			self->client->grappleState = 1;
+
+			grabbed->client->grappleIndex = self->s.number;
+			grabbed->client->grappleState = 20;
+
+			//time to crack some heads
+			G_SetAnim(self, &self->client->pers.cmd, SETANIM_BOTH, tortureAnim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD, 0);
+			if (self->client->ps.torsoAnim == tortureAnim)
+			{ //providing the anim set succeeded..
+				self->client->ps.weaponTime = self->client->ps.torsoTimer;
+			}
+
+			G_SetAnim(grabbed, &grabbed->client->pers.cmd, SETANIM_BOTH, correspondingAnim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD, 0);
+			if (grabbed->client->ps.torsoAnim == correspondingAnim)
+			{ //providing the anim set succeeded..
+				if (grabbed->client->ps.weapon == WP_SABER)
+				{ //turn it off
+					if (!grabbed->client->ps.saberHolstered)
+					{
+						grabbed->client->ps.saberHolstered = 2;
+						if (grabbed->client->saber[0].soundOff)
+						{
+							G_Sound(grabbed, CHAN_AUTO, grabbed->client->saber[0].soundOff);
+						}
+						if (grabbed->client->saber[1].soundOff &&
+							grabbed->client->saber[1].model[0])
+						{
+							G_Sound(grabbed, CHAN_AUTO, grabbed->client->saber[1].soundOff);
+						}
+					}
+				}
+				if (grabbed->client->ps.torsoTimer < self->client->ps.torsoTimer)
+				{ //make sure they stay in the anim at least as long as the grabber
+					grabbed->client->ps.torsoTimer = self->client->ps.torsoTimer;
+				}
+				grabbed->client->ps.weaponTime = grabbed->client->ps.torsoTimer;
+			}
+		}
+	}
+
+	if (self->client->ps.torsoTimer < 300 && !self->client->grappleState)
+	{ //you failed to grab anyone, play the "failed to grab" anim
+		G_SetAnim(self, &self->client->pers.cmd, SETANIM_BOTH, BOTH_KYLE_MISS, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD, 0);
+		if (self->client->ps.torsoAnim == BOTH_KYLE_MISS)
+		{ //providing the anim set succeeded..
+			self->client->ps.weaponTime = self->client->ps.torsoTimer;
+		}
+	}
+}
+
+void WP_SaberPositionUpdate( gentity_t *self, usercmd_t *ucmd )
+{ //rww - keep the saber position as updated as possible on the server so that we can try to do realistic-looking contact stuff
+  //Note that this function also does the majority of working in maintaining the server g2 client instance (updating angles/anims/etc)
+	gentity_t *mySaber = NULL;
+	mdxaBone_t	boltMatrix;
+	vec3_t properAngles, properOrigin;
+	vec3_t boltAngles, boltOrigin;
+	vec3_t end;
+	vec3_t legAxis[3];
+	vec3_t addVel;
+	vec3_t rawAngles;
+	float fVSpeed = 0;
+	int returnAfterUpdate = 0;
+	float animSpeedScale = 1.0f;
+	int saberNum;
+	qboolean clientOverride;
+	gentity_t *vehEnt = NULL;
+	int rSaberNum = 0;
+	int rBladeNum = 0;
+
+#ifdef _DEBUG
+	if (g_disableServerG2.integer)
+	{
+		return;
+	}
+#endif
+
+	if (self && self->inuse && self->client)
+	{
+		if (self->client->saberCycleQueue)
+		{
+			self->client->ps.fd.saberDrawAnimLevel = self->client->saberCycleQueue;
+		}
+		else
+		{
+			self->client->ps.fd.saberDrawAnimLevel = self->client->ps.fd.saberAnimLevel;
+		}
+	}
+
+	if (self &&
+		self->inuse &&
+		self->client &&
+		self->client->saberCycleQueue &&
+		(self->client->ps.weaponTime <= 0 || self->health < 1))
+	{ //we cycled attack levels while we were busy, so update now that we aren't (even if that means we're dead)
+		self->client->ps.fd.saberAnimLevel = self->client->saberCycleQueue;
+		self->client->saberCycleQueue = 0;
+	}
+
+	if (!self ||
+		!self->inuse ||
+		!self->client ||
+		!self->ghoul2 ||
+		!g2SaberInstance)
+	{
+		return;
+	}
+
+	if (BG_KickingAnim(self->client->ps.legsAnim))
+	{ //do some kick traces and stuff if we're in the appropriate anim
+		G_KickSomeMofos(self);
+	}
+	else if (self->client->ps.torsoAnim == BOTH_KYLE_GRAB)
+	{ //try to grab someone
+		G_GrabSomeMofos(self);
+	}
+	else if (self->client->grappleState)
+	{
+		gentity_t *grappler = &g_entities[self->client->grappleIndex];
+
+		if (!grappler->inuse || !grappler->client || grappler->client->grappleIndex != self->s.number ||
+			!BG_InGrappleMove(grappler->client->ps.torsoAnim) || !BG_InGrappleMove(grappler->client->ps.legsAnim) ||
+			!BG_InGrappleMove(self->client->ps.torsoAnim) || !BG_InGrappleMove(self->client->ps.legsAnim) ||
+			!self->client->grappleState || !grappler->client->grappleState ||
+			grappler->health < 1 || self->health < 1 ||
+			!G_PrettyCloseIGuess(self->client->ps.origin[2], grappler->client->ps.origin[2], 4.0f))
+		{
+			self->client->grappleState = 0;
+			if ((BG_InGrappleMove(self->client->ps.torsoAnim) && self->client->ps.torsoTimer > 100) ||
+				(BG_InGrappleMove(self->client->ps.legsAnim) && self->client->ps.legsTimer > 100))
+			{ //if they're pretty far from finishing the anim then shove them into another anim
+				G_SetAnim(self, &self->client->pers.cmd, SETANIM_BOTH, BOTH_KYLE_MISS, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD, 0);
+				if (self->client->ps.torsoAnim == BOTH_KYLE_MISS)
+				{ //providing the anim set succeeded..
+					self->client->ps.weaponTime = self->client->ps.torsoTimer;
+				}
+			}
+		}
+		else
+		{
+			vec3_t grapAng;
+
+			VectorSubtract(grappler->client->ps.origin, self->client->ps.origin, grapAng);
+
+			if (VectorLength(grapAng) > 64.0f)
+			{ //too far away, break it off
+				if ((BG_InGrappleMove(self->client->ps.torsoAnim) && self->client->ps.torsoTimer > 100) ||
+					(BG_InGrappleMove(self->client->ps.legsAnim) && self->client->ps.legsTimer > 100))
+				{
+					self->client->grappleState = 0;
+
+					G_SetAnim(self, &self->client->pers.cmd, SETANIM_BOTH, BOTH_KYLE_MISS, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD, 0);
+					if (self->client->ps.torsoAnim == BOTH_KYLE_MISS)
+					{ //providing the anim set succeeded..
+						self->client->ps.weaponTime = self->client->ps.torsoTimer;
+					}
+				}
+			}
+			else
+			{
+				vectoangles(grapAng, grapAng);
+				SetClientViewAngle(self, grapAng);
+
+				if (self->client->grappleState >= 20)
+				{ //grapplee
+					//try to position myself at the correct distance from my grappler
+					float idealDist;
+					vec3_t gFwd, idealSpot;
+					trace_t trace;
+
+					if (grappler->client->ps.torsoAnim == BOTH_KYLE_PA_1)
+					{ //grab punch
+						idealDist = 46.0f;
+					}
+					else
+					{ //knee-throw
+						idealDist = 34.0f;
+					}
+
+					AngleVectors(grappler->client->ps.viewangles, gFwd, 0, 0);
+					VectorMA(grappler->client->ps.origin, idealDist, gFwd, idealSpot);
+
+					trap_Trace(&trace, self->client->ps.origin, self->r.mins, self->r.maxs, idealSpot, self->s.number, self->clipmask);
+					if (!trace.startsolid && !trace.allsolid && trace.fraction == 1.0f)
+					{ //go there
+						G_SetOrigin(self, idealSpot);
+						VectorCopy(idealSpot, self->client->ps.origin);
+					}
+				}
+				else if (self->client->grappleState >= 1)
+				{ //grappler
+					if (grappler->client->ps.weapon == WP_SABER)
+					{ //make sure their saber is shut off
+						if (!grappler->client->ps.saberHolstered)
+						{
+							grappler->client->ps.saberHolstered = 2;
+							if (grappler->client->saber[0].soundOff)
+							{
+								G_Sound(grappler, CHAN_AUTO, grappler->client->saber[0].soundOff);
+							}
+							if (grappler->client->saber[1].soundOff &&
+								grappler->client->saber[1].model[0])
+							{
+								G_Sound(grappler, CHAN_AUTO, grappler->client->saber[1].soundOff);
+							}
+						}
+					}
+
+					//check for smashy events
+					if (self->client->ps.torsoAnim == BOTH_KYLE_PA_1)
+					{ //grab punch
+                        if (self->client->grappleState == 1)
+						{ //smack
+							if (self->client->ps.torsoTimer < 3400)
+							{
+								int grapplerAnim = grappler->client->ps.torsoAnim;
+								int grapplerTime = grappler->client->ps.torsoTimer;
+
+								G_Damage(grappler, self, self, NULL, self->client->ps.origin, 10, 0, MOD_MELEE);
+								//G_Sound( grappler, CHAN_AUTO, G_SoundIndex( va( "sound/weapons/melee/punch%d", Q_irand( 1, 4 ) ) ) );
+
+								//it might try to put them into a pain anim or something, so override it back again
+								if (grappler->health > 0)
+								{
+									grappler->client->ps.torsoAnim = grapplerAnim;
+									grappler->client->ps.torsoTimer = grapplerTime;
+									grappler->client->ps.legsAnim = grapplerAnim;
+									grappler->client->ps.legsTimer = grapplerTime;
+									grappler->client->ps.weaponTime = grapplerTime;
+								}
+								self->client->grappleState++;
+							}
+						}
+						else if (self->client->grappleState == 2)
+						{ //smack!
+							if (self->client->ps.torsoTimer < 2550)
+							{
+								int grapplerAnim = grappler->client->ps.torsoAnim;
+								int grapplerTime = grappler->client->ps.torsoTimer;
+
+								G_Damage(grappler, self, self, NULL, self->client->ps.origin, 10, 0, MOD_MELEE);
+								//G_Sound( grappler, CHAN_AUTO, G_SoundIndex( va( "sound/weapons/melee/punch%d", Q_irand( 1, 4 ) ) ) );
+
+								//it might try to put them into a pain anim or something, so override it back again
+								if (grappler->health > 0)
+								{
+									grappler->client->ps.torsoAnim = grapplerAnim;
+									grappler->client->ps.torsoTimer = grapplerTime;
+									grappler->client->ps.legsAnim = grapplerAnim;
+									grappler->client->ps.legsTimer = grapplerTime;
+									grappler->client->ps.weaponTime = grapplerTime;
+								}
+								self->client->grappleState++;
+							}
+						}
+						else
+						{ //SMACK!
+							if (self->client->ps.torsoTimer < 1300)
+							{
+								vec3_t tossDir;
+
+								G_Damage(grappler, self, self, NULL, self->client->ps.origin, 30, 0, MOD_MELEE);
+								//G_Sound( grappler, CHAN_AUTO, G_SoundIndex( va( "sound/weapons/melee/punch%d", Q_irand( 1, 4 ) ) ) );
+
+								self->client->grappleState = 0;
+
+								VectorSubtract(grappler->client->ps.origin, self->client->ps.origin, tossDir);
+								VectorNormalize(tossDir);
+								VectorScale(tossDir, 500.0f, tossDir);
+								tossDir[2] = 200.0f;
+
+								VectorAdd(grappler->client->ps.velocity, tossDir, grappler->client->ps.velocity);
+
+								if (grappler->health > 0)
+								{ //if still alive knock them down
+									grappler->client->ps.forceHandExtend = HANDEXTEND_KNOCKDOWN;
+									grappler->client->ps.forceHandExtendTime = level.time + 1300;
+								}
+							}
+						}
+					}
+					else if (self->client->ps.torsoAnim == BOTH_KYLE_PA_2)
+					{ //knee throw
+                        if (self->client->grappleState == 1)
+						{ //knee to the face
+							if (self->client->ps.torsoTimer < 3200)
+							{
+								int grapplerAnim = grappler->client->ps.torsoAnim;
+								int grapplerTime = grappler->client->ps.torsoTimer;
+
+								G_Damage(grappler, self, self, NULL, self->client->ps.origin, 20, 0, MOD_MELEE);
+								//G_Sound( grappler, CHAN_AUTO, G_SoundIndex( va( "sound/weapons/melee/punch%d", Q_irand( 1, 4 ) ) ) );
+
+								//it might try to put them into a pain anim or something, so override it back again
+								if (grappler->health > 0)
+								{
+									grappler->client->ps.torsoAnim = grapplerAnim;
+									grappler->client->ps.torsoTimer = grapplerTime;
+									grappler->client->ps.legsAnim = grapplerAnim;
+									grappler->client->ps.legsTimer = grapplerTime;
+									grappler->client->ps.weaponTime = grapplerTime;
+								}
+								self->client->grappleState++;
+							}
+						}
+						else if (self->client->grappleState == 2)
+						{ //smashed on the ground
+							if (self->client->ps.torsoTimer < 2000)
+							{
+								//G_Damage(grappler, self, self, NULL, self->client->ps.origin, 10, 0, MOD_MELEE);
+								//don't do damage on this one, it would look very freaky if they died
+								G_EntitySound( grappler, CHAN_VOICE, G_SoundIndex("*pain100.wav") );
+								//G_Sound( grappler, CHAN_AUTO, G_SoundIndex( va( "sound/weapons/melee/punch%d", Q_irand( 1, 4 ) ) ) );
+								self->client->grappleState++;
+							}
+						}
+						else
+						{ //and another smash
+							if (self->client->ps.torsoTimer < 1000)
+							{
+								G_Damage(grappler, self, self, NULL, self->client->ps.origin, 30, 0, MOD_MELEE);
+								//G_Sound( grappler, CHAN_AUTO, G_SoundIndex( va( "sound/weapons/melee/punch%d", Q_irand( 1, 4 ) ) ) );
+
+								//it might try to put them into a pain anim or something, so override it back again
+								if (grappler->health > 0)
+								{
+									grappler->client->ps.torsoTimer = 1000;
+									//G_SetAnim(grappler, &grappler->client->pers.cmd, SETANIM_BOTH, BOTH_GETUP3, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD, 0);
+									grappler->client->grappleState = 0;
+								}
+								else
+								{ //override death anim
+									grappler->client->ps.torsoAnim = BOTH_DEADFLOP1;
+									grappler->client->ps.legsAnim = BOTH_DEADFLOP1;
+								}
+
+								self->client->grappleState = 0;
+							}
+						}
+					}
+					else
+					{ //?
+					}
+				}
+			}
+		}
+	}
+
+	//If this is a listen server (client+server running on same machine),
+	//then lets try to steal the skeleton/etc data off the client instance
+	//for this entity to save us processing time.
+	clientOverride = trap_G2API_OverrideServer(self->ghoul2);
+
+	saberNum = self->client->ps.saberEntityNum;
+
+	if (!saberNum)
+	{
+		saberNum = self->client->saberStoredIndex;
+	}
+
+	if (!saberNum)
+	{
+		returnAfterUpdate = 1;
+		goto nextStep;
+	}
+
+	mySaber = &g_entities[saberNum];
+
+	if (self->health < 1)
+	{ //we don't want to waste precious CPU time calculating saber positions for corpses. But we want to avoid the saber ent position lagging on spawn, so..
+		//I guess it's good to keep the position updated even when contents are 0
+		if (mySaber && ((mySaber->r.contents & CONTENTS_LIGHTSABER) || mySaber->r.contents == 0) && !self->client->ps.saberInFlight)
+		{ //Since we haven't got a bolt position, place it on top of the player origin.
+			VectorCopy(self->client->ps.origin, mySaber->r.currentOrigin);
+		}
+	
+		//I don't want to return now actually, I want to keep g2 instances for corpses up to
+		//date because I'm doing better corpse hit detection/dismem (particularly for the
+		//npc's)
+		//return;
+	}
+
+	if ( BG_SuperBreakWinAnim( self->client->ps.torsoAnim ) )
+	{
+		self->client->ps.weaponstate = WEAPON_FIRING;
+	}
+	if (self->client->ps.weapon != WP_SABER ||
+		self->client->ps.weaponstate == WEAPON_RAISING ||
+		self->client->ps.weaponstate == WEAPON_DROPPING ||
+		self->health < 1)
+	{
+		if (!self->client->ps.saberInFlight)
+		{
+			returnAfterUpdate = 1;
+		}
+	}
+
+	if (self->client->ps.saberThrowDelay < level.time)
+	{
+		if ( !self->client->saber[0].throwable )
+		{//cant throw it normally!
+			if ( self->client->saber[0].singleBladeThrowable )
+			{//but can throw it if only have 1 blade on
+				if ( self->client->saber[0].numBlades > 1
+					&& self->client->ps.saberHolstered == 1 )
+				{//have multiple blades and only one blade on
+					self->client->ps.saberCanThrow = qtrue;//qfalse;
+					//huh? want to be able to throw then right?
+				}
+				else
+				{//multiple blades on, can't throw
+					self->client->ps.saberCanThrow = qfalse;
+				}
+			}
+			else
+			{//never can throw it
+				self->client->ps.saberCanThrow = qfalse;
+			}
+		}
+		else
+		{//can throw it!
+			self->client->ps.saberCanThrow = qtrue;
+		}
+	}
+nextStep:
+	if (self->client->ps.fd.forcePowersActive & (1 << FP_RAGE))
+	{
+		animSpeedScale = 2;
+	}
+	
+	VectorCopy(self->client->ps.origin, properOrigin);
+
+	//try to predict the origin based on velocity so it's more like what the client is seeing
+	VectorCopy(self->client->ps.velocity, addVel);
+	VectorNormalize(addVel);
+
+	if (self->client->ps.velocity[0] < 0)
+	{
+		fVSpeed += (-self->client->ps.velocity[0]);
+	}
+	else
+	{
+		fVSpeed += self->client->ps.velocity[0];
+	}
+	if (self->client->ps.velocity[1] < 0)
+	{
+		fVSpeed += (-self->client->ps.velocity[1]);
+	}
+	else
+	{
+		fVSpeed += self->client->ps.velocity[1];
+	}
+	if (self->client->ps.velocity[2] < 0)
+	{
+		fVSpeed += (-self->client->ps.velocity[2]);
+	}
+	else
+	{
+		fVSpeed += self->client->ps.velocity[2];
+	}
+
+	//fVSpeed *= 0.08;
+	fVSpeed *= 1.6f/g_svfps.value;
+
+	//Cap it off at reasonable values so the saber box doesn't go flying ahead of us or
+	//something if we get a big speed boost from something.
+	if (fVSpeed > 70)
+	{
+		fVSpeed = 70;
+	}
+	if (fVSpeed < -70)
+	{
+		fVSpeed = -70;
+	}
+
+	properOrigin[0] += addVel[0]*fVSpeed;
+	properOrigin[1] += addVel[1]*fVSpeed;
+	properOrigin[2] += addVel[2]*fVSpeed;
+
+	properAngles[0] = 0;
+	if (self->s.number < MAX_CLIENTS && self->client->ps.m_iVehicleNum)
+	{
+		vehEnt = &g_entities[self->client->ps.m_iVehicleNum];
+		if (vehEnt->inuse && vehEnt->client && vehEnt->m_pVehicle)
+		{
+			properAngles[1] = vehEnt->m_pVehicle->m_vOrientation[YAW];
+		}
+		else
+		{
+			properAngles[1] = self->client->ps.viewangles[YAW];
+			vehEnt = NULL;
+		}
+	}
+	else
+	{
+		properAngles[1] = self->client->ps.viewangles[YAW];
+	}
+	properAngles[2] = 0;
+
+	AnglesToAxis( properAngles, legAxis );
+
+	UpdateClientRenderinfo(self, properOrigin, properAngles);
+
+	if (!clientOverride)
+	{ //if we get the client instance we don't need to do this
+		G_G2PlayerAngles( self, legAxis, properAngles );
+	}
+
+	if (vehEnt)
+	{
+		properAngles[1] = vehEnt->m_pVehicle->m_vOrientation[YAW];
+	}
+
+	if (returnAfterUpdate && saberNum)
+	{ //We don't even need to do GetBoltMatrix if we're only in here to keep the g2 server instance in sync
+		//but keep our saber entity in sync too, just copy it over our origin.
+
+		//I guess it's good to keep the position updated even when contents are 0
+		if (mySaber && ((mySaber->r.contents & CONTENTS_LIGHTSABER) || mySaber->r.contents == 0) && !self->client->ps.saberInFlight)
+		{ //Since we haven't got a bolt position, place it on top of the player origin.
+			VectorCopy(self->client->ps.origin, mySaber->r.currentOrigin);
+		}
+
+		goto finalUpdate;
+	}
+
+	if (returnAfterUpdate)
+	{
+		goto finalUpdate;
+	}
+
+	//We'll get data for blade 0 first no matter what it is and stick them into
+	//the constant ("_Always") values. Later we will handle going through each blade.
+	trap_G2API_GetBoltMatrix(self->ghoul2, 1, 0, &boltMatrix, properAngles, properOrigin, level.time, NULL, self->modelScale);
+	BG_GiveMeVectorFromMatrix(&boltMatrix, ORIGIN, boltOrigin);
+	BG_GiveMeVectorFromMatrix(&boltMatrix, NEGATIVE_Y, boltAngles);
+
+	//immediately store these values so we don't have to recalculate this again
+	if (self->client->lastSaberStorageTime && (level.time - self->client->lastSaberStorageTime) < 200)
+	{ //alright
+		VectorCopy(self->client->lastSaberBase_Always, self->client->olderSaberBase);
+		self->client->olderIsValid = qtrue;
+	}
+	else
+	{
+		self->client->olderIsValid = qfalse;
+	}
+
+	VectorCopy(boltOrigin, self->client->lastSaberBase_Always);
+	VectorCopy(boltAngles, self->client->lastSaberDir_Always);
+	self->client->lastSaberStorageTime = level.time;
+
+	VectorCopy(boltAngles, rawAngles);
+
+	VectorMA( boltOrigin, self->client->saber[0].blade[0].lengthMax, boltAngles, end );
+
+	if (self->client->ps.saberEntityNum)
+	{
+		//I guess it's good to keep the position updated even when contents are 0
+		if (mySaber && ((mySaber->r.contents & CONTENTS_LIGHTSABER) || mySaber->r.contents == 0) && !self->client->ps.saberInFlight)
+		{ //place it roughly in the middle of the saber..
+			VectorMA( boltOrigin, self->client->saber[0].blade[0].lengthMax, boltAngles, mySaber->r.currentOrigin );
+		}
+	}
+
+	boltAngles[YAW] = self->client->ps.viewangles[YAW];
+
+/*	{
+		static int lastDTime = 0;
+		if (lastDTime < level.time)
+		{
+			G_TestLine(boltOrigin, end, 0x0000ff, 200);
+			lastDTime = level.time + 200;
+		}
+	}
+*/
+	if (self->client->ps.saberInFlight)
+	{ //do the thrown-saber stuff
+		gentity_t *saberent = &g_entities[saberNum];
+
+		if (saberent)
+		{
+			if (!self->client->ps.saberEntityState && self->client->ps.saberEntityNum)
+			{
+				vec3_t startorg, startang, dir;
+
+				VectorCopy(boltOrigin, saberent->r.currentOrigin);
+
+				VectorCopy(boltOrigin, startorg);
+				VectorCopy(boltAngles, startang);
+
+				//startang[0] = 90;
+				//Instead of this we'll sort of fake it and slowly tilt it down on the client via
+				//a perframe method (which doesn't actually affect where or how the saber hits)
+
+				saberent->r.svFlags &= ~(SVF_NOCLIENT);
+				VectorCopy(startorg, saberent->s.pos.trBase);
+				VectorCopy(startang, saberent->s.apos.trBase);
+
+				VectorCopy(startorg, saberent->s.origin);
+				VectorCopy(startang, saberent->s.angles);
+
+				saberent->s.saberInFlight = qtrue;
+
+				saberent->s.apos.trType = TR_LINEAR;
+				saberent->s.apos.trDelta[0] = 0;
+				saberent->s.apos.trDelta[1] = 800;
+				saberent->s.apos.trDelta[2] = 0;
+
+				saberent->s.pos.trType = TR_LINEAR;
+				saberent->s.eType = ET_GENERAL;
+				saberent->s.eFlags = 0;
+
+				WP_SaberAddG2Model( saberent, self->client->saber[0].model, self->client->saber[0].skin );
+
+				saberent->s.modelGhoul2 = 127;
+
+				saberent->parent = self;
+
+				self->client->ps.saberEntityState = 1;
+
+				//Projectile stuff:
+				AngleVectors(self->client->ps.viewangles, dir, NULL, NULL);
+
+				saberent->nextthink = level.time + FRAMETIME;
+				saberent->think = saberFirstThrown;
+
+				saberent->damage = SABER_THROWN_HIT_DAMAGE;
+				saberent->methodOfDeath = MOD_SABER;
+				saberent->splashMethodOfDeath = MOD_SABER;
+				saberent->s.solid = 2;
+				saberent->r.contents = CONTENTS_LIGHTSABER;
+
+				saberent->genericValue5 = 0;
+
+				VectorSet( saberent->r.mins, SABERMINS_X, SABERMINS_Y, SABERMINS_Z );
+				VectorSet( saberent->r.maxs, SABERMAXS_X, SABERMAXS_Y, SABERMAXS_Z );
+
+				saberent->s.genericenemyindex = self->s.number+1024;
+
+				saberent->touch = thrownSaberTouch;
+
+				saberent->s.weapon = WP_SABER;
+
+				VectorScale(dir, 400, saberent->s.pos.trDelta );
+				saberent->s.pos.trTime = level.time;
+
+				saberent->s.loopSound = saberSpinSound;
+				saberent->s.loopIsSoundset = qfalse;
+
+				self->client->ps.saberDidThrowTime = level.time;
+
+				self->client->dangerTime = level.time;
+				self->client->ps.eFlags &= ~EF_INVULNERABLE;
+				self->client->invulnerableTimer = 0;
+
+				trap_LinkEntity(saberent);
+			}
+			else if (self->client->ps.saberEntityNum) //only do this stuff if your saber is active and has not been knocked out of the air.
+			{
+				VectorCopy(boltOrigin, saberent->pos1);
+				trap_LinkEntity(saberent);
+
+				if (saberent->genericValue5 == PROPER_THROWN_VALUE)
+				{ //return to the owner now, this is a bad state to be in for here..
+					saberent->genericValue5 = 0;
+					saberent->think = SaberUpdateSelf;
+					saberent->nextthink = level.time;
+					WP_SaberRemoveG2Model( saberent );
+					
+					self->client->ps.saberInFlight = qfalse;
+					self->client->ps.saberEntityState = 0;
+					self->client->ps.saberThrowDelay = level.time + 500;
+					self->client->ps.saberCanThrow = qfalse;
+				}
+			}
+		}
+	}
+
+	/*
+	if (self->client->ps.saberInFlight)
+	{ //if saber is thrown then only do the standard stuff for the left hand saber
+		rSaberNum = 1;
+	}
+	*/
+
+	if (!BG_SabersOff(&self->client->ps))
+	{
+		gentity_t *saberent = &g_entities[saberNum];
+
+		if (!self->client->ps.saberInFlight && saberent)
+		{
+			saberent->r.svFlags |= (SVF_NOCLIENT);
+			saberent->r.contents = CONTENTS_LIGHTSABER;
+			SetSaberBoxSize(saberent);
+			saberent->s.loopSound = 0;
+			saberent->s.loopIsSoundset = qfalse;
+		}
+
+		if (self->client->ps.saberLockTime > level.time && self->client->ps.saberEntityNum)
+		{
+			if (self->client->ps.saberIdleWound < level.time)
+			{
+				gentity_t *te;
+				vec3_t dir;
+				te = G_TempEntity( g_entities[saberNum].r.currentOrigin, EV_SABER_BLOCK );
+				VectorSet( dir, 0, 1, 0 );
+				VectorCopy(g_entities[saberNum].r.currentOrigin, te->s.origin);
+				VectorCopy(dir, te->s.angles);
+				te->s.eventParm = 1;
+
+				self->client->ps.saberIdleWound = level.time + Q_irand(400, 600);
+			}
+
+			while (rSaberNum < MAX_SABERS)
+			{
+				rBladeNum = 0;
+				while (rBladeNum < self->client->saber[rSaberNum].numBlades)
+				{ //Don't bother updating the bolt for each blade for this, it's just a very rough fallback method for during saberlocks
+					VectorCopy(boltOrigin, self->client->saber[saberNum].blade[rBladeNum].trail.base);
+					VectorCopy(end, self->client->saber[saberNum].blade[rBladeNum].trail.tip);
+
+					rBladeNum++;
+				}
+
+				rSaberNum++;
+			}
+			self->client->hasCurrentPosition = qtrue;
+
+			self->client->ps.saberBlocked = BLOCKED_NONE;
+
+			goto finalUpdate;
+		}
+
+		//reset it in case we used it for cycling before
+		rSaberNum = rBladeNum = 0;
+
+		if (self->client->ps.saberInFlight)
+		{ //if saber is thrown then only do the standard stuff for the left hand saber
+			if (!self->client->ps.saberEntityNum)
+			{ //however, if saber is not in flight but rather knocked away, our left saber is off, and thus we may do nothing.
+				rSaberNum = 1;//was 2?
+			}
+			else
+			{//thrown saber still in flight, so do damage
+				rSaberNum = 0;//was 1?
+			}
+		}
+
+		WP_SaberClearDamage();
+		saberDoClashEffect = qfalse;
+
+		//Now cycle through each saber and each blade on the saber and do damage traces.
+		while (rSaberNum < MAX_SABERS)
+		{
+			if (!self->client->saber[rSaberNum].model[0])
+			{
+				rSaberNum++;
+				continue;
+			}
+
+			/*
+			if (rSaberNum == 0 && (self->client->ps.brokenLimbs & (1 << BROKENLIMB_RARM)))
+			{ //don't do saber 0 is the right arm is broken
+				rSaberNum++;
+				continue;
+			}
+			*/
+			//for now I'm keeping a broken right arm swingable, it will just look and act damaged
+			//but still be useable
+			
+			if (rSaberNum == 1 && (self->client->ps.brokenLimbs & (1 << BROKENLIMB_LARM)))
+			{ //don't to saber 1 if the left arm is broken
+				break;
+			}
+			if (rSaberNum > 0 
+				&& self->client->saber[1].model
+				&& self->client->saber[1].model[0]
+				&& self->client->ps.saberHolstered == 1 )
+			{ //don't to saber 2 if it's off
+				break;
+			}
+			rBladeNum = 0;
+			while (rBladeNum < self->client->saber[rSaberNum].numBlades)
+			{
+				//update muzzle data for the blade
+				VectorCopy(self->client->saber[rSaberNum].blade[rBladeNum].muzzlePoint, self->client->saber[rSaberNum].blade[rBladeNum].muzzlePointOld);
+				VectorCopy(self->client->saber[rSaberNum].blade[rBladeNum].muzzleDir, self->client->saber[rSaberNum].blade[rBladeNum].muzzleDirOld);
+
+				if ( rBladeNum > 0 //more than one blade
+					&& (!self->client->saber[1].model||!self->client->saber[1].model[0])//not using dual blades
+					&& self->client->saber[rSaberNum].numBlades > 1//using a multi-bladed saber
+					&& self->client->ps.saberHolstered == 1 )//
+				{ //don't to extra blades if they're off
+					break;
+				}
+				//get the new data
+				//then update the bolt pos/dir. rBladeNum corresponds to the bolt index because blade bolts are added in order.
+				if ( rSaberNum == 0 && self->client->ps.saberInFlight )
+				{
+					if ( !self->client->ps.saberEntityNum )
+					{//dropped it... shouldn't get here, but...
+						//assert(0);
+						//FIXME: It's getting here a lot actually....
+						rSaberNum++;
+						rBladeNum = 0;
+						continue;
+					}
+					else
+					{
+						gentity_t *saberEnt = &g_entities[self->client->ps.saberEntityNum];
+						vec3_t saberOrg, saberAngles;
+						if ( !saberEnt 
+							|| !saberEnt->inuse
+							|| !saberEnt->ghoul2 )
+						{//wtf?
+							rSaberNum++;
+							rBladeNum = 0;
+							continue;
+						}
+						if ( saberent->s.saberInFlight )
+						{//spinning
+							BG_EvaluateTrajectory( &saberEnt->s.pos, level.time+50, saberOrg );
+							BG_EvaluateTrajectory( &saberEnt->s.apos, level.time+50, saberAngles );
+						}
+						else
+						{//coming right back
+							vec3_t saberDir;
+							BG_EvaluateTrajectory( &saberEnt->s.pos, level.time, saberOrg );
+							VectorSubtract( self->r.currentOrigin, saberOrg, saberDir );
+							vectoangles( saberDir, saberAngles );
+						}
+						trap_G2API_GetBoltMatrix(saberEnt->ghoul2, 0, rBladeNum, &boltMatrix, saberAngles, saberOrg, level.time, NULL, self->modelScale);
+						BG_GiveMeVectorFromMatrix(&boltMatrix, ORIGIN, self->client->saber[rSaberNum].blade[rBladeNum].muzzlePoint);
+						BG_GiveMeVectorFromMatrix(&boltMatrix, NEGATIVE_Y, self->client->saber[rSaberNum].blade[rBladeNum].muzzleDir);
+						VectorCopy( self->client->saber[rSaberNum].blade[rBladeNum].muzzlePoint, boltOrigin );
+						VectorMA( boltOrigin, self->client->saber[rSaberNum].blade[rBladeNum].lengthMax, self->client->saber[rSaberNum].blade[rBladeNum].muzzleDir, end );
+					}
+
+				}
+				else
+				{
+					trap_G2API_GetBoltMatrix(self->ghoul2, rSaberNum+1, rBladeNum, &boltMatrix, properAngles, properOrigin, level.time, NULL, self->modelScale);
+					BG_GiveMeVectorFromMatrix(&boltMatrix, ORIGIN, self->client->saber[rSaberNum].blade[rBladeNum].muzzlePoint);
+					BG_GiveMeVectorFromMatrix(&boltMatrix, NEGATIVE_Y, self->client->saber[rSaberNum].blade[rBladeNum].muzzleDir);
+					VectorCopy( self->client->saber[rSaberNum].blade[rBladeNum].muzzlePoint, boltOrigin );
+					VectorMA( boltOrigin, self->client->saber[rSaberNum].blade[rBladeNum].lengthMax, self->client->saber[rSaberNum].blade[rBladeNum].muzzleDir, end );
+				}
+
+				self->client->saber[rSaberNum].blade[rBladeNum].storageTime = level.time;
+
+				if (self->client->hasCurrentPosition && d_saberInterpolate.integer)
+				{
+					if (self->client->ps.weaponTime <= 0)
+					{ //rww - 07/17/02 - don't bother doing the extra stuff unless actually attacking. This is in attempt to save CPU.
+						CheckSaberDamage(self, rSaberNum, rBladeNum, boltOrigin, end, qfalse, (MASK_PLAYERSOLID|CONTENTS_LIGHTSABER|MASK_SHOT), qfalse);
+					}
+					else if (d_saberInterpolate.integer == 1)
+					{
+						int trMask = CONTENTS_LIGHTSABER|CONTENTS_BODY;
+						int sN = 0;
+						qboolean gotHit = qfalse;
+						qboolean clientUnlinked[MAX_CLIENTS];
+						qboolean skipSaberTrace = qfalse;
+						
+						if (!g_saberTraceSaberFirst.integer)
+						{
+							skipSaberTrace = qtrue;
+						}
+						else if (g_saberTraceSaberFirst.integer >= 2 &&
+							g_gametype.integer != GT_DUEL &&
+							g_gametype.integer != GT_POWERDUEL &&
+							!self->client->ps.duelInProgress)
+						{ //if value is >= 2, and not in a duel, skip
+							skipSaberTrace = qtrue;
+						}
+
+						if (skipSaberTrace)
+						{ //skip the saber-contents-only trace and get right to the full trace
+							trMask = (MASK_PLAYERSOLID|CONTENTS_LIGHTSABER|MASK_SHOT);
+						}
+						else
+						{
+							while (sN < MAX_CLIENTS)
+							{
+								if (g_entities[sN].inuse && g_entities[sN].client && g_entities[sN].r.linked && g_entities[sN].health > 0 && (g_entities[sN].r.contents & CONTENTS_BODY))
+								{ //Take this mask off before the saber trace, because we want to hit the saber first
+									g_entities[sN].r.contents &= ~CONTENTS_BODY;
+									clientUnlinked[sN] = qtrue;
+								}
+								else
+								{
+									clientUnlinked[sN] = qfalse;
+								}
+								sN++;
+							}
+						}
+
+						while (!gotHit)
+						{
+							if (!CheckSaberDamage(self, rSaberNum, rBladeNum, boltOrigin, end, qfalse, trMask, qfalse))
+							{
+								if (!CheckSaberDamage(self, rSaberNum, rBladeNum, boltOrigin, end, qtrue, trMask, qfalse))
+								{
+									vec3_t oldSaberStart;
+									vec3_t oldSaberEnd;
+									vec3_t saberAngleNow;
+									vec3_t saberAngleBefore;
+									vec3_t saberMidDir;
+									vec3_t saberMidAngle;
+									vec3_t saberMidPoint;
+									vec3_t saberMidEnd;
+									vec3_t saberSubBase;
+									float deltaX, deltaY, deltaZ;
+
+									VectorCopy(self->client->saber[rSaberNum].blade[rBladeNum].trail.base, oldSaberStart);
+									VectorCopy(self->client->saber[rSaberNum].blade[rBladeNum].trail.tip, oldSaberEnd);
+
+									VectorSubtract(oldSaberEnd, oldSaberStart, saberAngleBefore);
+									vectoangles(saberAngleBefore, saberAngleBefore);
+
+									VectorSubtract(end, boltOrigin, saberAngleNow);
+									vectoangles(saberAngleNow, saberAngleNow);
+
+									deltaX = AngleDelta(saberAngleBefore[0], saberAngleNow[0]);
+									deltaY = AngleDelta(saberAngleBefore[1], saberAngleNow[1]);
+									deltaZ = AngleDelta(saberAngleBefore[2], saberAngleNow[2]);
+
+									if ( (deltaX != 0 || deltaY != 0 || deltaZ != 0) && deltaX < 180 && deltaY < 180 && deltaZ < 180 && (BG_SaberInAttack(self->client->ps.saberMove) || PM_SaberInTransition(self->client->ps.saberMove)) )
+									{ //don't go beyond here if we aren't attacking/transitioning or the angle is too large.
+									//and don't bother if the angle is the same
+										saberMidAngle[0] = saberAngleBefore[0] + (deltaX/2);
+										saberMidAngle[1] = saberAngleBefore[1] + (deltaY/2);
+										saberMidAngle[2] = saberAngleBefore[2] + (deltaZ/2);
+
+										//Now that I have the angle, I'll just say the base for it is the difference between the two start
+										//points (even though that's quite possibly completely false)
+										VectorSubtract(boltOrigin, oldSaberStart, saberSubBase);
+										saberMidPoint[0] = boltOrigin[0] + (saberSubBase[0]*0.5);
+										saberMidPoint[1] = boltOrigin[1] + (saberSubBase[1]*0.5);
+										saberMidPoint[2] = boltOrigin[2] + (saberSubBase[2]*0.5);
+
+										AngleVectors(saberMidAngle, saberMidDir, 0, 0);
+										saberMidEnd[0] = saberMidPoint[0] + saberMidDir[0]*self->client->saber[rSaberNum].blade[rBladeNum].lengthMax;
+										saberMidEnd[1] = saberMidPoint[1] + saberMidDir[1]*self->client->saber[rSaberNum].blade[rBladeNum].lengthMax;
+										saberMidEnd[2] = saberMidPoint[2] + saberMidDir[2]*self->client->saber[rSaberNum].blade[rBladeNum].lengthMax;
+
+										//I'll just trace straight out and not even trace between positions to save speed.
+										if (CheckSaberDamage(self, rSaberNum, rBladeNum, saberMidPoint, saberMidEnd, qfalse, trMask, qfalse))
+										{
+											gotHit = qtrue;
+										}
+									}
+								}
+								else
+								{
+									gotHit = qtrue;
+								}
+							}
+							else
+							{
+								gotHit = qtrue;
+							}
+
+							if (g_saberTraceSaberFirst.integer)
+							{
+								sN = 0;
+								while (sN < MAX_CLIENTS)
+								{
+									if (clientUnlinked[sN])
+									{ //Make clients clip properly again.
+										if (g_entities[sN].inuse && g_entities[sN].health > 0)
+										{
+											g_entities[sN].r.contents |= CONTENTS_BODY;
+										}
+									}
+									sN++;
+								}
+							}
+
+							if (!gotHit)
+							{
+								if (trMask != (MASK_PLAYERSOLID|CONTENTS_LIGHTSABER|MASK_SHOT))
+								{
+									trMask = (MASK_PLAYERSOLID|CONTENTS_LIGHTSABER|MASK_SHOT);
+								}
+								else
+								{
+									gotHit = qtrue; //break out of the loop
+								}
+							}
+						}
+					}
+					else if (d_saberInterpolate.integer) //anything but 0 or 1, use the old plain method.
+					{
+						if (!CheckSaberDamage(self, rSaberNum, rBladeNum, boltOrigin, end, qfalse, (MASK_PLAYERSOLID|CONTENTS_LIGHTSABER|MASK_SHOT), qfalse))
+						{
+							CheckSaberDamage(self, rSaberNum, rBladeNum, boltOrigin, end, qtrue, (MASK_PLAYERSOLID|CONTENTS_LIGHTSABER|MASK_SHOT), qfalse);
+						}
+					}
+				}
+				else if ( d_saberSPStyleDamage.integer )
+				{
+					G_SPSaberDamageTraceLerped( self, rSaberNum, rBladeNum, boltOrigin, end, (MASK_PLAYERSOLID|CONTENTS_LIGHTSABER|MASK_SHOT) );
+				}
+				else
+				{
+					CheckSaberDamage(self, rSaberNum, rBladeNum, boltOrigin, end, qfalse, (MASK_PLAYERSOLID|CONTENTS_LIGHTSABER|MASK_SHOT), qfalse);
+				}
+
+				VectorCopy(boltOrigin, self->client->saber[rSaberNum].blade[rBladeNum].trail.base);
+				VectorCopy(end, self->client->saber[rSaberNum].blade[rBladeNum].trail.tip);
+				//VectorCopy(boltOrigin, self->client->lastSaberBase);
+				//VectorCopy(end, self->client->lastSaberTip);
+				self->client->hasCurrentPosition = qtrue;
+
+				rBladeNum++;
+			}
+
+			rSaberNum++;
+		}
+
+		//now actually go through and apply all the damage we did
+		WP_SaberApplyDamage( self );
+		WP_SaberDoClash();
+
+		if (mySaber && mySaber->inuse)
+		{
+			trap_LinkEntity(mySaber);
+		}
+
+		if (!self->client->ps.saberInFlight)
+		{
+			self->client->ps.saberEntityState = 0;
+		}
+	}
+finalUpdate:
+	if (clientOverride)
+	{ //if we get the client instance we don't even need to bother setting anims and stuff
+		return;
+	}
+
+	G_UpdateClientAnims(self, animSpeedScale);
+}
+
+int WP_MissileBlockForBlock( int saberBlock )
+{
+	switch( saberBlock )
+	{
+	case BLOCKED_UPPER_RIGHT:
+		return BLOCKED_UPPER_RIGHT_PROJ;
+		break;
+	case BLOCKED_UPPER_LEFT:
+		return BLOCKED_UPPER_LEFT_PROJ;
+		break;
+	case BLOCKED_LOWER_RIGHT:
+		return BLOCKED_LOWER_RIGHT_PROJ;
+		break;
+	case BLOCKED_LOWER_LEFT:
+		return BLOCKED_LOWER_LEFT_PROJ;
+		break;
+	case BLOCKED_TOP:
+		return BLOCKED_TOP_PROJ;
+		break;
+	}
+	return saberBlock;
+}
+
+void WP_SaberBlockNonRandom( gentity_t *self, vec3_t hitloc, qboolean missileBlock )
+{
+	vec3_t diff, fwdangles={0,0,0}, right;
+	vec3_t clEye;
+	float rightdot;
+	float zdiff;
+
+	VectorCopy(self->client->ps.origin, clEye);
+	clEye[2] += self->client->ps.viewheight;
+
+	VectorSubtract( hitloc, clEye, diff );
+	diff[2] = 0;
+	VectorNormalize( diff );
+
+	fwdangles[1] = self->client->ps.viewangles[1];
+	// Ultimately we might care if the shot was ahead or behind, but for now, just quadrant is fine.
+	AngleVectors( fwdangles, NULL, right, NULL );
+
+	rightdot = DotProduct(right, diff);
+	zdiff = hitloc[2] - clEye[2];
+	
+	if ( zdiff > 0 )
+	{
+		if ( rightdot > 0.3 )
+		{
+			self->client->ps.saberBlocked = BLOCKED_UPPER_RIGHT;
+		}
+		else if ( rightdot < -0.3 )
+		{
+			self->client->ps.saberBlocked = BLOCKED_UPPER_LEFT;
+		}
+		else
+		{
+			self->client->ps.saberBlocked = BLOCKED_TOP;
+		}
+	}
+	else if ( zdiff > -20 )//20 )
+	{
+		if ( zdiff < -10 )//30 )
+		{//hmm, pretty low, but not low enough to use the low block, so we need to duck
+			
+		}
+		if ( rightdot > 0.1 )
+		{
+			self->client->ps.saberBlocked = BLOCKED_UPPER_RIGHT;
+		}
+		else if ( rightdot < -0.1 )
+		{
+			self->client->ps.saberBlocked = BLOCKED_UPPER_LEFT;
+		}
+		else
+		{
+			self->client->ps.saberBlocked = BLOCKED_TOP;
+		}
+	}
+	else
+	{
+		if ( rightdot >= 0 )
+		{
+			self->client->ps.saberBlocked = BLOCKED_LOWER_RIGHT;
+		}
+		else
+		{
+			self->client->ps.saberBlocked = BLOCKED_LOWER_LEFT;
+		}
+	}
+
+	if ( missileBlock )
+	{
+		self->client->ps.saberBlocked = WP_MissileBlockForBlock( self->client->ps.saberBlocked );
+	}
+}
+
+void WP_SaberBlock( gentity_t *playerent, vec3_t hitloc, qboolean missileBlock )
+{
+	vec3_t diff, fwdangles={0,0,0}, right;
+	float rightdot;
+	float zdiff;
+
+	VectorSubtract(hitloc, playerent->client->ps.origin, diff);
+	VectorNormalize(diff);
+
+	fwdangles[1] = playerent->client->ps.viewangles[1];
+	// Ultimately we might care if the shot was ahead or behind, but for now, just quadrant is fine.
+	AngleVectors( fwdangles, NULL, right, NULL );
+
+	rightdot = DotProduct(right, diff) + RandFloat(-0.2f,0.2f);
+	zdiff = hitloc[2] - playerent->client->ps.origin[2] + Q_irand(-8,8);
+	
+	// Figure out what quadrant the block was in.
+	if (zdiff > 24)
+	{	// Attack from above
+		if (Q_irand(0,1))
+		{
+			playerent->client->ps.saberBlocked = BLOCKED_TOP;
+		}
+		else
+		{
+			playerent->client->ps.saberBlocked = BLOCKED_UPPER_LEFT;
+		}
+	}
+	else if (zdiff > 13)
+	{	// The upper half has three viable blocks...
+		if (rightdot > 0.25)
+		{	// In the right quadrant...
+			if (Q_irand(0,1))
+			{
+				playerent->client->ps.saberBlocked = BLOCKED_UPPER_LEFT;
+			}
+			else
+			{
+				playerent->client->ps.saberBlocked = BLOCKED_LOWER_LEFT;
+			}
+		}
+		else
+		{
+			switch(Q_irand(0,3))
+			{
+			case 0:
+				playerent->client->ps.saberBlocked = BLOCKED_UPPER_RIGHT;
+				break;
+			case 1:
+			case 2:
+				playerent->client->ps.saberBlocked = BLOCKED_LOWER_RIGHT;
+				break;
+			case 3:
+				playerent->client->ps.saberBlocked = BLOCKED_TOP;
+				break;
+			}
+		}
+	}
+	else
+	{	// The lower half is a bit iffy as far as block coverage.  Pick one of the "low" ones at random.
+		if (Q_irand(0,1))
+		{
+			playerent->client->ps.saberBlocked = BLOCKED_LOWER_RIGHT;
+		}
+		else
+		{
+			playerent->client->ps.saberBlocked = BLOCKED_LOWER_LEFT;
+		}
+	}
+
+	if ( missileBlock )
+	{
+		playerent->client->ps.saberBlocked = WP_MissileBlockForBlock( playerent->client->ps.saberBlocked );
+	}
+}
+
+int WP_SaberCanBlock(gentity_t *self, vec3_t point, int dflags, int mod, qboolean projectile, int attackStr)
+{
+	qboolean thrownSaber = qfalse;
+	float blockFactor = 0;
+
+	if (!self || !self->client || !point)
+	{
+		return 0;
+	}
+
+	if (attackStr == 999)
+	{
+		attackStr = 0;
+		thrownSaber = qtrue;
+	}
+
+	if (BG_SaberInAttack(self->client->ps.saberMove))
+	{
+		return 0;
+	}
+
+	if (PM_InSaberAnim(self->client->ps.torsoAnim) && !self->client->ps.saberBlocked &&
+		self->client->ps.saberMove != LS_READY && self->client->ps.saberMove != LS_NONE)
+	{
+		if ( self->client->ps.saberMove < LS_PARRY_UP || self->client->ps.saberMove > LS_REFLECT_LL )
+		{
+			return 0;
+		}
+	}
+
+	if (PM_SaberInBrokenParry(self->client->ps.saberMove))
+	{
+		return 0;
+	}
+
+	if (!self->client->ps.saberEntityNum)
+	{ //saber is knocked away
+		return 0;
+	}
+
+	if (BG_SabersOff( &self->client->ps ))
+	{
+		return 0;
+	}
+
+	if (self->client->ps.weapon != WP_SABER)
+	{
+		return 0;
+	}
+
+	if (self->client->ps.weaponstate == WEAPON_RAISING)
+	{
+		return 0;
+	}
+
+	if (self->client->ps.saberInFlight)
+	{
+		return 0;
+	}
+
+	if ((self->client->pers.cmd.buttons & BUTTON_ATTACK)/* &&
+		(projectile || attackStr == FORCE_LEVEL_3)*/)
+	{ //don't block when the player is trying to slash, if it's a projectile or he's doing a very strong attack
+		return 0;
+	}
+
+	//Removed this for now, the new broken parry stuff should handle it. This is how
+	//blocks were decided before the 1.03 patch (as you can see, it was STUPID.. for the most part)
+	/*
+	if (attackStr == FORCE_LEVEL_3)
+	{
+		if (self->client->ps.fd.forcePowerLevel[FP_SABER_DEFENSE] >= FORCE_LEVEL_3)
+		{
+			if (Q_irand(1, 10) < 3)
+			{
+				return 0;
+			}
+		}
+		else
+		{
+			return 0;
+		}
+	}
+
+	if (attackStr == FORCE_LEVEL_2 && Q_irand(1, 10) < 3)
+	{
+		if (self->client->ps.fd.forcePowerLevel[FP_SABER_DEFENSE] >= FORCE_LEVEL_3)
+		{
+			//do nothing for now
+		}
+		else if (self->client->ps.fd.forcePowerLevel[FP_SABER_DEFENSE] >= FORCE_LEVEL_2)
+		{
+			if (Q_irand(1, 10) < 5)
+			{
+				return 0;
+			}
+		}
+		else
+		{
+			return 0;
+		}
+	}
+	
+	if (attackStr == FORCE_LEVEL_1 && !self->client->ps.fd.forcePowerLevel[FP_SABER_DEFENSE] &&
+		Q_irand(1, 40) < 3)
+	{ //if I have no defense level at all then I might be unable to block a level 1 attack (but very rarely)
+		return 0;
+	}
+	*/
+
+	if (SaberAttacking(self))
+	{ //attacking, can't block now
+		return 0;
+	}
+
+	if (self->client->ps.saberMove != LS_READY &&
+		!self->client->ps.saberBlocking)
+	{
+		return 0;
+	}
+
+	if (self->client->ps.saberBlockTime >= level.time)
+	{
+		return 0;
+	}
+
+	if (self->client->ps.forceHandExtend != HANDEXTEND_NONE)
+	{
+		return 0;
+	}
+
+	if (self->client->ps.fd.forcePowerLevel[FP_SABER_DEFENSE] == FORCE_LEVEL_3)
+	{
+		if (d_saberGhoul2Collision.integer)
+		{
+			blockFactor = 0.3f;
+		}
+		else
+		{
+			blockFactor = 0.05f;
+		}
+	}
+	else if (self->client->ps.fd.forcePowerLevel[FP_SABER_DEFENSE] == FORCE_LEVEL_2)
+	{
+		blockFactor = 0.6f;
+	}
+	else if (self->client->ps.fd.forcePowerLevel[FP_SABER_DEFENSE] == FORCE_LEVEL_1)
+	{
+		blockFactor = 0.9f;
+	}
+	else
+	{ //for now we just don't get to autoblock with no def
+		return 0;
+	}
+
+	if (thrownSaber)
+	{
+		blockFactor -= 0.25f;
+	}
+
+	if (attackStr)
+	{ //blocking a saber, not a projectile.
+		blockFactor -= 0.25f;
+	}
+
+	if (!InFront( point, self->client->ps.origin, self->client->ps.viewangles, blockFactor )) //orig 0.2f
+	{
+		return 0;
+	}
+
+	if (projectile)
+	{
+		WP_SaberBlockNonRandom(self, point, projectile);
+	}
+	return 1;
+}
+
+qboolean HasSetSaberOnly(void)
+{
+	int i = 0;
+	int wDisable = 0;
+
+	if (g_gametype.integer == GT_JEDIMASTER)
+	{ //set to 0 
+		return qfalse;
+	}
+
+	if (g_gametype.integer == GT_DUEL || g_gametype.integer == GT_POWERDUEL)
+	{
+		wDisable = g_duelWeaponDisable.integer;
+	}
+	else
+	{
+		wDisable = g_weaponDisable.integer;
+	}
+
+	while (i < WP_NUM_WEAPONS)
+	{
+		if (!(wDisable & (1 << i)) &&
+			i != WP_SABER && i != WP_NONE)
+		{
+			return qfalse;
+		}
+
+		i++;
+	}
+
+	return qtrue;
+}
+
diff --git a/codemp/game/w_saber.h b/codemp/game/w_saber.h
new file mode 100644
index 0000000..336e87f
--- /dev/null
+++ b/codemp/game/w_saber.h
@@ -0,0 +1,74 @@
+#define ARMOR_EFFECT_TIME	500
+
+//saberEventFlags
+#define	SEF_HITENEMY	0x1		//Hit the enemy
+#define	SEF_HITOBJECT	0x2		//Hit some other object
+#define	SEF_HITWALL		0x4		//Hit a wall
+#define	SEF_PARRIED		0x8		//Parried a saber swipe
+#define	SEF_DEFLECTED	0x10	//Deflected a missile or saberInFlight
+#define	SEF_BLOCKED		0x20	//Was blocked by a parry
+#define	SEF_EVENTS		(SEF_HITENEMY|SEF_HITOBJECT|SEF_HITWALL|SEF_PARRIED|SEF_DEFLECTED|SEF_BLOCKED)
+#define	SEF_LOCKED		0x40	//Sabers locked with someone else
+#define	SEF_INWATER		0x80	//Saber is in water
+#define	SEF_LOCK_WON	0x100	//Won a saberLock
+//saberEntityState
+#define SES_LEAVING		1
+#define SES_HOVERING	1//2
+#define SES_RETURNING	1//3
+//This is a hack because ATM the saberEntityState is only non-0 if out or 0 if in, and we
+//at least want NPCs knowing when their saber is out regardless.
+
+
+#define JSF_AMBUSH		16	//ambusher Jedi
+
+#define SABER_RADIUS_STANDARD	3.0f
+#define	SABER_REFLECT_MISSILE_CONE	0.2f
+
+#define	FORCE_POWER_MAX	100
+#define MAX_GRIP_DISTANCE 256
+#define MAX_TRICK_DISTANCE 512
+#define FORCE_JUMP_CHARGE_TIME 6400//3000.0f
+#define GRIP_DRAIN_AMOUNT 30
+#define FORCE_LIGHTNING_RADIUS 300
+#define MAX_DRAIN_DISTANCE 512
+
+typedef enum
+{
+	FJ_FORWARD,
+	FJ_BACKWARD,
+	FJ_RIGHT,
+	FJ_LEFT,
+	FJ_UP
+};
+
+typedef enum
+{
+	EVASION_NONE = 0,
+	EVASION_PARRY,
+	EVASION_DUCK_PARRY,
+	EVASION_JUMP_PARRY,
+	EVASION_DODGE,
+	EVASION_JUMP,
+	EVASION_DUCK,
+	EVASION_FJUMP,
+	EVASION_CARTWHEEL,
+	EVASION_OTHER,
+	NUM_EVASION_TYPES
+} evasionType_t;
+
+extern vmCvar_t g_MaxHolocronCarry;
+
+#define SABERMINS_X -3.0f//-24.0f
+#define SABERMINS_Y -3.0f//-24.0f
+#define SABERMINS_Z -3.0f//-8.0f
+#define SABERMAXS_X 3.0f//24.0f
+#define SABERMAXS_Y 3.0f//24.0f
+#define SABERMAXS_Z 3.0f//8.0f
+#define	SABER_MIN_THROW_DIST	80.0f
+
+#include "../namespace_begin.h"
+extern int forcePowerNeeded[NUM_FORCE_POWER_LEVELS][NUM_FORCE_POWERS];
+extern float forceJumpHeight[NUM_FORCE_POWER_LEVELS];
+extern float forceJumpStrength[NUM_FORCE_POWER_LEVELS];
+extern float forcePushPullRadius[NUM_FORCE_POWER_LEVELS];
+#include "../namespace_end.h"
diff --git a/codemp/ghoul2/G2.h b/codemp/ghoul2/G2.h
new file mode 100644
index 0000000..69bf6d2
--- /dev/null
+++ b/codemp/ghoul2/G2.h
@@ -0,0 +1,40 @@
+#if defined (_MSC_VER) && (_MSC_VER >= 1020)
+#pragma once
+#endif
+#if !defined(G2_H_INC)
+#define G2_H_INC
+
+
+#define BONE_ANGLES_PREMULT			0x0001
+#define BONE_ANGLES_POSTMULT		0x0002
+#define BONE_ANGLES_REPLACE			0x0004
+
+//rww - RAGDOLL_BEGIN
+#define BONE_ANGLES_RAGDOLL			0x2000  // the rag flags give more details
+//rww - RAGDOLL_END
+#define BONE_ANGLES_IK				0x4000  // the rag flags give more details
+
+#define BONE_ANGLES_TOTAL			( BONE_ANGLES_PREMULT | BONE_ANGLES_POSTMULT | BONE_ANGLES_REPLACE )
+#define BONE_ANIM_OVERRIDE			0x0008
+#define BONE_ANIM_OVERRIDE_LOOP		0x0010
+#define BONE_ANIM_OVERRIDE_FREEZE	( 0x0040 + BONE_ANIM_OVERRIDE )
+#define BONE_ANIM_BLEND				0x0080
+#define BONE_ANIM_TOTAL				( BONE_ANIM_OVERRIDE | BONE_ANIM_OVERRIDE_LOOP | BONE_ANIM_OVERRIDE_FREEZE | BONE_ANIM_BLEND)
+
+
+// defines to setup the
+#define		ENTITY_WIDTH 12
+#define		MODEL_WIDTH	10
+#define		BOLT_WIDTH	10
+ 
+#define		MODEL_AND	((1<<MODEL_WIDTH)-1)
+#define		BOLT_AND	((1<<BOLT_WIDTH)-1)
+#define		ENTITY_AND	((1<<ENTITY_WIDTH)-1)
+
+#define		BOLT_SHIFT	0
+#define		MODEL_SHIFT	(BOLT_SHIFT + BOLT_WIDTH)
+#define		ENTITY_SHIFT (MODEL_SHIFT + MODEL_WIDTH)
+
+
+#endif // G2_H_INC
+
diff --git a/codemp/ghoul2/G2_API.cpp b/codemp/ghoul2/G2_API.cpp
new file mode 100644
index 0000000..b24719c
--- /dev/null
+++ b/codemp/ghoul2/G2_API.cpp
@@ -0,0 +1,2654 @@
+// leave this as first line for PCH reasons...
+//
+
+
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+#if !defined(TR_LOCAL_H)
+	#include "../renderer/tr_local.h"
+#endif
+
+#if !defined(G2_H_INC)
+	#include "G2.h"
+#endif
+#include "G2_local.h"
+
+#include "../qcommon/MiniHeap.h"
+
+//rww - RAGDOLL_BEGIN
+#include "G2_gore.h"
+//rww - RAGDOLL_END
+
+extern vm_t *gvm;
+extern vm_t *currentVM; //Yeah. So very wrong.
+
+#include <set>
+
+#pragma warning (push, 3)	//go back down to 3 for the stl include
+#include <list>
+#include <string>
+#pragma warning (pop)
+
+#ifdef _FULL_G2_LEAK_CHECKING
+int g_Ghoul2Allocations = 0;
+int g_G2ServerAlloc = 0;
+int g_G2ClientAlloc = 0;
+int g_G2AllocServer = 0;
+
+//stupid debug crap to track leaks in case they happen.
+//we used to shove everything into a map and delete it all and not care about
+//leaks, but that was not the Right Thing. -rww
+#define MAX_TRACKED_ALLOC					4096
+static bool g_G2AllocTrackInit = false; //want to keep this thing contained
+static CGhoul2Info_v *g_G2AllocTrack[MAX_TRACKED_ALLOC];
+
+void G2_DEBUG_InitPtrTracker(void)
+{
+	memset(g_G2AllocTrack, 0, sizeof(g_G2AllocTrack));
+	g_G2AllocTrackInit = true;
+}
+
+void G2_DEBUG_ReportLeaks(void)
+{
+	int i = 0;
+
+	if (!g_G2AllocTrackInit)
+	{
+		Com_Printf("g2 leak tracker was never initialized!\n");
+		return;
+	}
+
+    while (i < MAX_TRACKED_ALLOC)
+	{
+		if (g_G2AllocTrack[i])
+		{
+			Com_Printf("Bad guy found in slot %i, attempting to access...", i);
+			CGhoul2Info_v &g2v = *g_G2AllocTrack[i];
+			CGhoul2Info &g2 = g2v[0];
+
+			if (g2v.IsValid() && g2.mFileName && g2.mFileName[0])
+			{
+				Com_Printf("Bad guy's filename is %s\n", g2.mFileName);
+			}
+			else
+			{
+				Com_Printf("He's not valid! BURN HIM!\n");
+			}
+		}
+		i++;
+	}
+}
+
+void G2_DEBUG_ShovePtrInTracker(CGhoul2Info_v *g2)
+{
+	int i = 0;
+
+	if (!g_G2AllocTrackInit)
+	{
+		G2_DEBUG_InitPtrTracker();
+	}
+
+	if (!g_G2AllocTrackInit)
+	{
+		G2_DEBUG_InitPtrTracker();
+	}
+
+	while (i < MAX_TRACKED_ALLOC)
+	{
+		if (!g_G2AllocTrack[i])
+		{
+			g_G2AllocTrack[i] = g2;
+			return;
+		}
+		i++;
+	}
+
+	CGhoul2Info_v &g2v = *g2;
+
+	if (g2v[0].currentModel && g2v[0].currentModel->name && g2v[0].currentModel->name[0])
+	{
+		Com_Printf("%s could not be fit into g2 debug instance tracker.\n", g2v[0].currentModel->name);
+	}
+	else
+	{
+		Com_Printf("Crap g2 instance passed to instance tracker (in).\n");
+	}
+}
+
+void G2_DEBUG_RemovePtrFromTracker(CGhoul2Info_v *g2)
+{
+	int i = 0;
+
+	if (!g_G2AllocTrackInit)
+	{
+		G2_DEBUG_InitPtrTracker();
+	}
+
+	while (i < MAX_TRACKED_ALLOC)
+	{
+		if (g_G2AllocTrack[i] == g2)
+		{
+			g_G2AllocTrack[i] = NULL;
+			return;
+		}
+		i++;
+	}
+
+	CGhoul2Info_v &g2v = *g2;
+
+	if (g2v[0].currentModel && g2v[0].currentModel->name && g2v[0].currentModel->name[0])
+	{
+		Com_Printf("%s not in g2 debug instance tracker.\n", g2v[0].currentModel->name);
+	}
+	else
+	{
+		Com_Printf("Crap g2 instance passed to instance tracker (out).\n");
+	}
+}
+#endif
+
+extern mdxaBone_t		worldMatrix;
+extern mdxaBone_t		worldMatrixInv;
+
+qboolean G2_SetupModelPointers(CGhoul2Info *ghlInfo);
+qboolean G2_SetupModelPointers(CGhoul2Info_v &ghoul2);
+qboolean G2_TestModelPointers(CGhoul2Info *ghlInfo);
+
+//rww - RAGDOLL_BEGIN
+#define NUM_G2T_TIME (2)
+static int G2TimeBases[NUM_G2T_TIME];
+
+void G2API_SetTime(int currentTime,int clock)
+{
+	assert(clock>=0&&clock<NUM_G2T_TIME);
+#if G2_DEBUG_TIME
+	Com_Printf("Set Time: before c%6d  s%6d",G2TimeBases[1],G2TimeBases[0]);
+#endif
+	G2TimeBases[clock]=currentTime;
+	if (G2TimeBases[1]>G2TimeBases[0]+200)
+	{
+		G2TimeBases[1]=0; // use server time instead
+		return;
+	}
+#if G2_DEBUG_TIME
+	Com_Printf(" after c%6d  s%6d\n",G2TimeBases[1],G2TimeBases[0]);
+#endif
+}
+
+int	G2API_GetTime(int argTime) // this may or may not return arg depending on ghoul2_time cvar
+{
+	int ret=G2TimeBases[1];
+	if ( !ret )
+	{
+		ret = G2TimeBases[0];
+	}
+
+	return ret;
+}
+//rww - RAGDOLL_END
+
+//rww - Stuff to allow association of ghoul2 instances to entity numbers.
+//This way, on listen servers when both the client and server are doing
+//ghoul2 operations, we can copy relevant data off the client instance
+//directly onto the server instance and slash the transforms and whatnot
+//right in half.
+#ifdef _G2_LISTEN_SERVER_OPT
+CGhoul2Info_v *g2ClientAttachments[MAX_GENTITIES];
+#endif
+
+void G2API_AttachInstanceToEntNum(CGhoul2Info_v &ghoul2, int entityNum, qboolean server)
+{ //Assign the pointers in the arrays
+#ifdef _G2_LISTEN_SERVER_OPT
+	if (server)
+	{
+		ghoul2[0].entityNum = entityNum;
+	}
+	else
+	{
+		g2ClientAttachments[entityNum] = &ghoul2;
+	}
+#endif
+}
+
+void G2API_ClearAttachedInstance(int entityNum)
+{
+#ifdef _G2_LISTEN_SERVER_OPT
+	g2ClientAttachments[entityNum] = NULL;
+#endif
+}
+
+void G2API_CleanEntAttachments(void)
+{
+#ifdef _G2_LISTEN_SERVER_OPT
+	int i = 0;
+
+	while (i < MAX_GENTITIES)
+	{
+		g2ClientAttachments[i] = NULL;
+		i++;
+	}
+#endif
+}
+
+void RemoveBoneCache(CBoneCache *boneCache);
+#ifdef _G2_LISTEN_SERVER_OPT
+void CopyBoneCache(CBoneCache *to, CBoneCache *from);
+#endif
+
+qboolean G2API_OverrideServerWithClientData(CGhoul2Info *serverInstance)
+{
+#ifndef _G2_LISTEN_SERVER_OPT
+	return qfalse;
+#else
+	CGhoul2Info *clientInstance;
+
+	if (com_dedicated->integer)
+	{ //No client to get from!
+		return qfalse;
+	}
+
+	if (!g2ClientAttachments[serverInstance->entityNum])
+	{ //No clientside instance is attached to this entity
+		return qfalse;
+	}
+
+	CGhoul2Info_v &g2Ref = *g2ClientAttachments[serverInstance->entityNum];
+	clientInstance = &g2Ref[0];
+
+	int frameNum = G2API_GetTime(0);
+
+	if (clientInstance->mSkelFrameNum != frameNum)
+	{ //it has to be constructed already
+		return qfalse;
+	}
+
+	if (!clientInstance->mBoneCache)
+	{ //that just won't do
+		return qfalse;
+	}
+
+	//Just copy over the essentials
+	serverInstance->aHeader = clientInstance->aHeader;
+	serverInstance->animModel = clientInstance->animModel;
+	serverInstance->currentAnimModelSize = clientInstance->currentAnimModelSize;
+	serverInstance->currentModel = clientInstance->currentModel;
+	serverInstance->currentModelSize = clientInstance->currentModelSize;
+	serverInstance->mAnimFrameDefault = clientInstance->mAnimFrameDefault;
+	serverInstance->mModel = clientInstance->mModel;
+	serverInstance->mModelindex = clientInstance->mModelindex;
+	serverInstance->mSurfaceRoot = clientInstance->mSurfaceRoot;
+	serverInstance->mTransformedVertsArray = clientInstance->mTransformedVertsArray;
+
+	if (!serverInstance->mBoneCache)
+	{ //if this is the case.. I guess we can use the client one instead
+		serverInstance->mBoneCache = clientInstance->mBoneCache;
+	}
+
+	//Copy the contents of the client cache over the contents of the server cache
+	if (serverInstance->mBoneCache != clientInstance->mBoneCache)
+	{
+		CopyBoneCache(serverInstance->mBoneCache, clientInstance->mBoneCache);
+	}
+
+	serverInstance->mSkelFrameNum = clientInstance->mSkelFrameNum;
+	return qtrue;
+#endif
+}
+
+// must be a power of two
+#ifdef _XBOX
+#define MAX_G2_MODELS (512)
+#define G2_MODEL_BITS (9)
+#else
+#define MAX_G2_MODELS (1024)
+#define G2_MODEL_BITS (10)
+#endif
+
+#define G2_INDEX_MASK (MAX_G2_MODELS-1)
+
+class Ghoul2InfoArray : public IGhoul2InfoArray
+{
+	vector<CGhoul2Info>	mInfos[MAX_G2_MODELS];
+	int					mIds[MAX_G2_MODELS];
+	list<int>			mFreeIndecies;
+	void DeleteLow(int idx)
+	{
+		{
+			int				model;
+			for (model=0; model< mInfos[idx].size(); model++)
+			{
+				if (mInfos[idx][model].mBoneCache)
+				{
+					RemoveBoneCache(mInfos[idx][model].mBoneCache);
+					mInfos[idx][model].mBoneCache=0;
+				}
+			}
+		}
+		mInfos[idx].clear();
+
+		if ((mIds[idx]>>G2_MODEL_BITS)>(1<<(31-G2_MODEL_BITS)))
+		{
+			mIds[idx]=MAX_G2_MODELS+idx; //rollover reset id to minimum value
+			mFreeIndecies.push_back(idx);
+		}
+		else
+		{
+			mIds[idx]+=MAX_G2_MODELS;
+			mFreeIndecies.push_front(idx);
+		}
+	}
+public:
+	Ghoul2InfoArray()
+	{
+		int i;
+		for (i=0;i<MAX_G2_MODELS;i++)
+		{
+			mIds[i]=MAX_G2_MODELS+i;
+			mFreeIndecies.push_back(i);
+		}
+	}
+#if G2API_DEBUG
+	~Ghoul2InfoArray()
+	{
+		char mess[1000];
+		if (mFreeIndecies.size()<MAX_G2_MODELS)
+		{
+			sprintf(mess,"************************\nLeaked %d ghoul2info slots\n", MAX_G2_MODELS - mFreeIndecies.size());
+			OutputDebugString(mess);
+			int i;
+			for (i=0;i<MAX_G2_MODELS;i++)
+			{
+				list<int>::iterator j;
+				for (j=mFreeIndecies.begin();j!=mFreeIndecies.end();j++)
+				{
+					if (*j==i)
+						break;
+				}
+				if (j==mFreeIndecies.end())
+				{
+					sprintf(mess,"Leaked Info idx=%d id=%d sz=%d\n", i, mIds[i], mInfos[i].size());
+					OutputDebugString(mess);
+					if (mInfos[i].size())
+					{
+						sprintf(mess,"%s\n", mInfos[i][0].mFileName);
+						OutputDebugString(mess);
+					}
+				}
+			}
+		}
+		else
+		{
+			OutputDebugString("No ghoul2 info slots leaked\n");
+		}
+	}
+#endif
+	int New()
+	{
+		if (mFreeIndecies.empty())
+		{
+			assert(0);
+			Com_Error(ERR_FATAL, "Out of ghoul2 info slots");
+
+		}
+		// gonna pull from the front, doing a 
+		int idx=*mFreeIndecies.begin();
+		mFreeIndecies.erase(mFreeIndecies.begin());
+		return mIds[idx];
+	}
+	bool IsValid(int handle) const
+	{
+		if (!handle)
+		{
+			return false;
+		}
+		assert(handle>0); //negative handle???
+		assert((handle&G2_INDEX_MASK)>=0&&(handle&G2_INDEX_MASK)<MAX_G2_MODELS); //junk handle
+		if (mIds[handle&G2_INDEX_MASK]!=handle) // not a valid handle, could be old
+		{
+			return false;
+		}
+		return true;
+	}
+	void Delete(int handle)
+	{
+		if (!handle)
+		{
+			return;
+		}
+		assert(handle>0); //null handle
+		assert((handle&G2_INDEX_MASK)>=0&&(handle&G2_INDEX_MASK)<MAX_G2_MODELS); //junk handle
+		assert(mIds[handle&G2_INDEX_MASK]==handle); // not a valid handle, could be old or garbage
+		if (mIds[handle&G2_INDEX_MASK]==handle)
+		{
+			DeleteLow(handle&G2_INDEX_MASK);
+		}
+	}
+	vector<CGhoul2Info> &Get(int handle)
+	{
+		static vector<CGhoul2Info> null;
+		assert(handle>0); //null handle
+		assert((handle&G2_INDEX_MASK)>=0&&(handle&G2_INDEX_MASK)<MAX_G2_MODELS); //junk handle
+		assert(mIds[handle&G2_INDEX_MASK]==handle); // not a valid handle, could be old or garbage
+		if (handle<=0||(handle&G2_INDEX_MASK)<0||(handle&G2_INDEX_MASK)>=MAX_G2_MODELS||mIds[handle&G2_INDEX_MASK]!=handle)
+		{
+			null.clear();
+			return null;
+		}
+		return mInfos[handle&G2_INDEX_MASK];
+	}
+	const vector<CGhoul2Info> &Get(int handle) const
+	{
+		assert(handle>0);
+		assert(mIds[handle&G2_INDEX_MASK]==handle); // not a valid handle, could be old or garbage
+		return mInfos[handle&G2_INDEX_MASK];
+	}
+
+#if G2API_DEBUG
+	vector<CGhoul2Info> &GetDebug(int handle)
+	{
+		static vector<CGhoul2Info> null;
+		if (handle<=0||(handle&G2_INDEX_MASK)<0||(handle&G2_INDEX_MASK)>=MAX_G2_MODELS||mIds[handle&G2_INDEX_MASK]!=handle)
+		{
+			return *(vector<CGhoul2Info> *)0; // null reference, intentional
+		}
+		return mInfos[handle&G2_INDEX_MASK];
+	}
+	void TestAllAnims()
+	{
+		int j;
+		for (j=0;j<MAX_G2_MODELS;j++)
+		{
+			vector<CGhoul2Info> &ghoul2=mInfos[j];
+			int i;
+			for (i=0; i<ghoul2.size(); i++)
+			{
+				if (G2_SetupModelPointers(&ghoul2[i]))
+				{
+					G2ANIM(&ghoul2[i],"Test All");
+				}
+			}
+		}
+	}
+
+#endif
+};
+
+static Ghoul2InfoArray *singleton = NULL;
+IGhoul2InfoArray &TheGhoul2InfoArray()
+{
+	if(!singleton) {
+		singleton = new Ghoul2InfoArray;
+	}
+	return *singleton;
+}
+
+
+void Ghoul2InfoArray_Free(void)
+{
+	if(singleton) {
+		delete singleton;
+		singleton = NULL;
+	}
+}
+
+// this is the ONLY function to read entity states directly
+void G2API_CleanGhoul2Models(CGhoul2Info_v **ghoul2Ptr)
+{
+	if (*ghoul2Ptr)
+	{
+		CGhoul2Info_v &ghoul2 = *(*ghoul2Ptr);
+
+#if 0 //rwwFIXMEFIXME: Disable this before release!!!!!! I am just trying to find a crash bug.
+		extern int R_GetRNumEntities(void);
+		extern void R_SetRNumEntities(int num);
+		//check if this instance is actually on a refentity
+		int i = 0;
+		int r = R_GetRNumEntities();
+
+		while (i < r)
+		{
+			if ((CGhoul2Info_v *)backEndData->entities[i].e.ghoul2 == *ghoul2Ptr)
+			{
+				char fName[MAX_QPATH];
+				char mName[MAX_QPATH];
+
+				if (ghoul2[0].currentModel)
+				{
+					strcpy(mName, ghoul2[0].currentModel->name);
+				}
+				else
+				{
+					strcpy(mName, "NULL!");
+				}
+
+				if (ghoul2[0].mFileName && ghoul2[0].mFileName[0])
+				{
+					strcpy(fName, ghoul2[0].mFileName);
+				}
+				else
+				{
+					strcpy(fName, "None?!");
+				}
+
+				Com_Printf("ERROR, GHOUL2 INSTANCE BEING REMOVED BELONGS TO A REFENTITY!\nThis is in caps because it's important. Tell Rich and save the following text.\n\n");
+				Com_Printf("Ref num: %i\nModel: %s\nFilename: %s\n", i, mName, fName);
+
+				R_SetRNumEntities(0); //avoid recursive error
+				Com_Error(ERR_DROP, "Write down or save this error message, show it to Rich\nRef num: %i\nModel: %s\nFilename: %s\n", i, mName, fName);
+			}
+			i++;
+		}
+#endif
+
+#ifdef _G2_GORE
+		G2API_ClearSkinGore ( ghoul2 );
+#endif
+
+		ghoul2.~CGhoul2Info_v();
+
+#ifdef _FULL_G2_LEAK_CHECKING
+		if (g_G2AllocServer)
+		{
+			g_G2ServerAlloc -= sizeof(*ghoul2Ptr);
+		}
+		else
+		{
+			g_G2ClientAlloc -= sizeof(*ghoul2Ptr);
+		}
+		g_Ghoul2Allocations -= sizeof(*ghoul2Ptr);
+		G2_DEBUG_RemovePtrFromTracker(*ghoul2Ptr);
+#endif
+
+		delete *ghoul2Ptr;
+		*ghoul2Ptr = NULL;
+	}	
+}
+
+extern qboolean Com_TheHunkMarkHasBeenMade(void);
+extern qboolean ShaderHashTableExists(void);
+qboolean G2_ShouldRegisterServer(void)
+{
+	if (currentVM && currentVM == gvm)
+	{
+		if (com_cl_running && com_cl_running->integer &&
+			Com_TheHunkMarkHasBeenMade() && ShaderHashTableExists())
+		{ //if the hunk has been marked then we are now loading client assets so don't load on server.
+			return qfalse;
+		}
+
+		return qtrue;
+	}
+	return qfalse;
+}
+
+qhandle_t G2API_PrecacheGhoul2Model(const char *fileName)
+{
+	if (G2_ShouldRegisterServer())
+	{
+		return RE_RegisterServerModel((char *)fileName);
+	}
+	else
+	{
+		return RE_RegisterModel((char *)fileName);
+	}
+}
+
+void CL_InitRef( void );
+void R_Register( void );
+
+// initialise all that needs to be on a new Ghoul II model
+int G2API_InitGhoul2Model(CGhoul2Info_v **ghoul2Ptr, const char *fileName, int modelIndex, qhandle_t customSkin,
+						  qhandle_t customShader, int modelFlags, int lodBias)
+{
+	int				model;
+	CGhoul2Info		newModel;
+
+	// are we actually asking for a model to be loaded.
+	if (!fileName || !fileName[0])
+	{
+		assert(0);
+		return -1;
+	}
+
+	if (!(*ghoul2Ptr))
+	{
+		*ghoul2Ptr = new CGhoul2Info_v;
+#ifdef _FULL_G2_LEAK_CHECKING
+		if (g_G2AllocServer)
+		{
+			g_G2ServerAlloc += sizeof(CGhoul2Info_v);
+		}
+		else
+		{
+			g_G2ClientAlloc += sizeof(CGhoul2Info_v);
+		}
+		g_Ghoul2Allocations += sizeof(CGhoul2Info_v);
+		G2_DEBUG_ShovePtrInTracker(*ghoul2Ptr);
+#endif
+	}
+
+	CGhoul2Info_v &ghoul2 = *(*ghoul2Ptr);
+
+	// find a free spot in the list
+	for (model=0; model< ghoul2.size(); model++)
+	{
+		if (ghoul2[model].mModelindex == -1)
+		{
+			ghoul2[model]=CGhoul2Info();
+			break;
+		}
+	}
+	if (model==ghoul2.size())
+	{	//init should not be used to create additional models, only the first one
+		assert(ghoul2.size() < 4); //use G2API_CopySpecificG2Model to add models
+		ghoul2.push_back(CGhoul2Info()); 
+	}
+
+	strcpy(ghoul2[model].mFileName, fileName);
+	ghoul2[model].mModelindex = model;
+	if (!G2_TestModelPointers(&ghoul2[model]))
+	{
+		ghoul2[model].mFileName[0]=0;
+		ghoul2[model].mModelindex = -1;
+	}
+	else
+	{
+		G2_Init_Bone_List(ghoul2[model].mBlist);
+		G2_Init_Bolt_List(ghoul2[model].mBltlist);
+		ghoul2[model].mCustomShader = customShader;
+		ghoul2[model].mCustomSkin = customSkin;
+		ghoul2[model].mLodBias = lodBias;
+		ghoul2[model].mAnimFrameDefault = 0;
+		ghoul2[model].mFlags = 0;
+
+		ghoul2[model].mModelBoltLink = -1;
+	}
+	return ghoul2[model].mModelindex;
+}
+
+qboolean G2API_SetLodBias(CGhoul2Info *ghlInfo, int lodBias)
+{
+	if (ghlInfo)
+	{
+		ghlInfo->mLodBias = lodBias;
+		return qtrue;
+	}
+	return qfalse;
+}
+
+void G2_SetSurfaceOnOffFromSkin (CGhoul2Info *ghlInfo, qhandle_t renderSkin);
+qboolean G2API_SetSkin(CGhoul2Info *ghlInfo, qhandle_t customSkin, qhandle_t renderSkin)
+{
+	if (ghlInfo)
+	{
+		ghlInfo->mCustomSkin = customSkin;
+		if (renderSkin)
+		{//this is going to set the surfs on/off matching the skin file
+			G2_SetSurfaceOnOffFromSkin( ghlInfo, renderSkin );
+		}
+
+		return qtrue;
+	}
+	return qfalse;
+}
+
+qboolean G2API_SetShader(CGhoul2Info *ghlInfo, qhandle_t customShader)
+{
+	if (ghlInfo)
+	{
+		ghlInfo->mCustomShader = customShader;
+		return qtrue;
+	}
+	return qfalse;
+}
+
+qboolean G2API_SetSurfaceOnOff(CGhoul2Info_v &ghoul2, const char *surfaceName, const int flags)
+{
+	CGhoul2Info *ghlInfo = NULL;
+
+	if ((int)&ghoul2 && ghoul2.size()>0)
+	{
+		ghlInfo = &ghoul2[0];
+	}
+
+	if (G2_SetupModelPointers(ghlInfo))
+	{
+		// ensure we flush the cache
+		ghlInfo->mMeshFrameNum = 0;
+		return G2_SetSurfaceOnOff(ghlInfo, ghlInfo->mSlist, surfaceName, flags);
+	}
+	return qfalse;
+}
+
+int G2API_GetSurfaceOnOff(CGhoul2Info *ghlInfo, const char *surfaceName)
+{
+	if (ghlInfo)
+	{
+		return G2_IsSurfaceOff(ghlInfo, ghlInfo->mSlist, surfaceName);
+	}
+	return -1;
+}
+
+qboolean G2API_SetRootSurface(CGhoul2Info_v &ghoul2, const int modelIndex, const char *surfaceName)
+{
+	if (G2_SetupModelPointers(ghoul2))
+	{
+		return G2_SetRootSurface(ghoul2, modelIndex, surfaceName);
+	}
+
+	return qfalse;
+}
+
+int G2API_AddSurface(CGhoul2Info *ghlInfo, int surfaceNumber, int polyNumber, float BarycentricI, float BarycentricJ, int lod )
+{
+	if (G2_SetupModelPointers(ghlInfo))
+	{
+		// ensure we flush the cache
+		ghlInfo->mMeshFrameNum = 0;
+		return G2_AddSurface(ghlInfo, surfaceNumber, polyNumber, BarycentricI, BarycentricJ, lod);
+	}
+	return -1;
+}
+
+qboolean G2API_RemoveSurface(CGhoul2Info *ghlInfo, const int index)
+{
+	if (G2_SetupModelPointers(ghlInfo))
+	{
+		// ensure we flush the cache
+		ghlInfo->mMeshFrameNum = 0;
+		return G2_RemoveSurface(ghlInfo->mSlist, index);
+	}
+	return qfalse;
+}
+
+int G2API_GetParentSurface(CGhoul2Info *ghlInfo, const int index)
+{
+	if (G2_SetupModelPointers(ghlInfo))
+	{
+		return G2_GetParentSurface(ghlInfo, index);
+	}
+	return -1;
+}
+
+int G2API_GetSurfaceRenderStatus(CGhoul2Info *ghlInfo, const char *surfaceName)
+{
+	if (G2_SetupModelPointers(ghlInfo))
+	{
+		return G2_IsSurfaceRendered(ghlInfo, surfaceName, ghlInfo->mSlist);
+	}
+	return -1;
+}
+
+qboolean G2API_HasGhoul2ModelOnIndex(CGhoul2Info_v **ghlRemove, const int modelIndex)
+{
+	CGhoul2Info_v &ghlInfo = **ghlRemove;
+
+	if (!ghlInfo.size() || (ghlInfo.size() <= modelIndex) || (ghlInfo[modelIndex].mModelindex == -1))
+	{
+		return qfalse;
+	}
+
+	return qtrue;
+}
+
+qboolean G2API_RemoveGhoul2Model(CGhoul2Info_v **ghlRemove, const int modelIndex)
+{
+	CGhoul2Info_v &ghlInfo = **ghlRemove;
+
+	// sanity check
+	if (!ghlInfo.size() || (ghlInfo.size() <= modelIndex) || (ghlInfo[modelIndex].mModelindex == -1))
+	{
+		// if we hit this assert then we are trying to delete a ghoul2 model on a ghoul2 instance that
+		// one way or another is already gone.
+		assert(0);
+		return qfalse;
+	}
+
+	if (ghlInfo.size() > modelIndex)
+	{
+#ifdef _G2_GORE
+		// Cleanup the gore attached to this model
+		if ( ghlInfo[modelIndex].mGoreSetTag )
+		{
+			DeleteGoreSet ( ghlInfo[modelIndex].mGoreSetTag );
+			ghlInfo[modelIndex].mGoreSetTag = 0;
+		}
+#endif
+
+		if (ghlInfo[modelIndex].mBoneCache)
+		{
+			RemoveBoneCache(ghlInfo[modelIndex].mBoneCache);
+			ghlInfo[modelIndex].mBoneCache=0;
+		}
+
+		// clear out the vectors this model used.
+		ghlInfo[modelIndex].mBlist.clear();
+		ghlInfo[modelIndex].mBltlist.clear();
+		ghlInfo[modelIndex].mSlist.clear();
+
+	   	 // set us to be the 'not active' state
+		ghlInfo[modelIndex].mModelindex = -1;
+
+		int newSize = ghlInfo.size();
+		// now look through the list from the back and see if there is a block of -1's we can resize off the end of the list
+		for (int i=ghlInfo.size()-1; i>-1; i--)
+		{
+			if (ghlInfo[i].mModelindex == -1)
+			{
+				newSize = i;
+			}
+			// once we hit one that isn't a -1, we are done.
+			else
+			{
+				break;
+			}
+		}
+		// do we need to resize?
+		if (newSize != ghlInfo.size())
+		{
+			// yes, so lets do it
+			ghlInfo.resize(newSize);
+		}
+
+		// if we are not using any space, just delete the ghoul2 vector entirely
+		if (!ghlInfo.size())
+		{
+#ifdef _FULL_G2_LEAK_CHECKING
+			if (g_G2AllocServer)
+			{
+				g_G2ServerAlloc -= sizeof(*ghlRemove);
+			}
+			else
+			{
+				g_G2ClientAlloc -= sizeof(*ghlRemove);
+			}
+			g_Ghoul2Allocations -= sizeof(*ghlRemove);
+#endif
+			delete *ghlRemove;
+			*ghlRemove = NULL;
+		}
+	}
+
+
+	return qtrue;
+}
+
+qboolean G2API_RemoveGhoul2Models(CGhoul2Info_v **ghlRemove)
+{//remove 'em ALL!
+	CGhoul2Info_v &ghlInfo = **ghlRemove;
+	int	modelIndex = 0;
+	int newSize = 0;
+	int i;
+
+	// sanity check
+	if ( !ghlInfo.size() )
+	{// if we hit this then we are trying to delete a ghoul2 model on a ghoul2 instance that
+		// one way or another is already gone.
+		return qfalse;
+	}
+
+	for ( modelIndex = 0; modelIndex < ghlInfo.size(); modelIndex++ )
+	{
+		if ( ghlInfo[modelIndex].mModelindex == -1 )
+		{
+			continue;
+		}
+#ifdef _G2_GORE
+		// Cleanup the gore attached to this model
+		if ( ghlInfo[modelIndex].mGoreSetTag )
+		{
+			DeleteGoreSet ( ghlInfo[modelIndex].mGoreSetTag );
+			ghlInfo[modelIndex].mGoreSetTag = 0;
+		}
+#endif
+
+		if (ghlInfo[modelIndex].mBoneCache)
+		{
+			RemoveBoneCache(ghlInfo[modelIndex].mBoneCache);
+			ghlInfo[modelIndex].mBoneCache=0;
+		}
+
+		// clear out the vectors this model used.
+		ghlInfo[modelIndex].mBlist.clear();
+		ghlInfo[modelIndex].mBltlist.clear();
+		ghlInfo[modelIndex].mSlist.clear();
+
+	   	 // set us to be the 'not active' state
+		ghlInfo[modelIndex].mModelindex = -1;
+	}
+
+	newSize = ghlInfo.size();
+	// now look through the list from the back and see if there is a block of -1's we can resize off the end of the list
+	for (i=ghlInfo.size()-1; i>-1; i--)
+	{
+		if (ghlInfo[i].mModelindex == -1)
+		{
+			newSize = i;
+		}
+		// once we hit one that isn't a -1, we are done.
+		else
+		{
+			break;
+		}
+	}
+	// do we need to resize?
+	if (newSize != ghlInfo.size())
+	{
+		// yes, so lets do it
+		ghlInfo.resize(newSize);
+	}
+
+	// if we are not using any space, just delete the ghoul2 vector entirely
+	if (!ghlInfo.size())
+	{
+#ifdef _FULL_G2_LEAK_CHECKING
+		if (g_G2AllocServer)
+		{
+			g_G2ServerAlloc -= sizeof(*ghlRemove);
+		}
+		else
+		{
+			g_G2ClientAlloc -= sizeof(*ghlRemove);
+		}
+		g_Ghoul2Allocations -= sizeof(*ghlRemove);
+#endif
+		delete *ghlRemove;
+		*ghlRemove = NULL;
+	}
+	return qtrue;
+}
+
+//check if a bone exists on skeleton without actually adding to the bone list -rww
+qboolean G2API_DoesBoneExist(CGhoul2Info *ghlInfo, const char *boneName)
+{
+	if (G2_SetupModelPointers(ghlInfo))
+	{ //model is valid
+		mdxaHeader_t *mdxa = ghlInfo->currentModel->mdxa;
+		if (mdxa)
+		{ //get the skeleton data and iterate through the bones
+			int i;
+			mdxaSkel_t *skel;
+			mdxaSkelOffsets_t *offsets;
+
+			offsets = (mdxaSkelOffsets_t *)((byte *)mdxa + sizeof(mdxaHeader_t));
+
+ 			for (i = 0; i < mdxa->numBones; i++)
+ 			{
+ 				skel = (mdxaSkel_t *)((byte *)mdxa + sizeof(mdxaHeader_t) + offsets->offsets[i]);
+ 				if (!Q_stricmp(skel->name, boneName))
+				{ //got it
+					return qtrue;
+				}
+			}
+		}
+	}
+
+	//guess it doesn't exist
+	return qfalse;
+}
+
+//rww - RAGDOLL_BEGIN
+#define		GHOUL2_RAG_STARTED						0x0010
+#define		GHOUL2_RAG_FORCESOLVE					0x1000		//api-override, determine if ragdoll should be forced to continue solving even if it thinks it is settled
+//rww - RAGDOLL_END
+
+qboolean G2API_SetBoneAnimIndex(CGhoul2Info *ghlInfo, const int index, const int AstartFrame, const int AendFrame, const int flags, const float animSpeed, const int currentTime, const float AsetFrame, const int blendTime)
+{
+	qboolean setPtrs = qfalse;
+	qboolean res = qfalse;
+
+	//rww - RAGDOLL_BEGIN
+	if (ghlInfo)
+	{
+		res = G2_SetupModelPointers(ghlInfo);
+		setPtrs = qtrue;
+
+		if (res)
+		{
+			if (ghlInfo->mFlags & GHOUL2_RAG_STARTED)
+			{
+				return qfalse;
+			}
+		}
+	}
+	//rww - RAGDOLL_END
+
+	int endFrame=AendFrame;
+	int startFrame=AstartFrame;
+	float setFrame=AsetFrame;
+	assert(endFrame>0);
+	assert(startFrame>=0);
+	assert(endFrame<100000);
+	assert(startFrame<100000);
+	assert(setFrame>=0.0f||setFrame==-1.0f);
+	assert(setFrame<=100000.0f);
+	if (endFrame<=0)
+	{
+		endFrame=1;
+	}
+	if (endFrame>=100000)
+	{
+		endFrame=1;
+	}
+	if (startFrame<0)
+	{
+		startFrame=0;
+	}
+	if (startFrame>=100000)
+	{
+		startFrame=0;
+	}
+	if (setFrame<0.0f&&setFrame!=-1.0f)
+	{
+		setFrame=0.0f;
+	}
+	if (setFrame>100000.0f)
+	{
+		setFrame=0.0f;
+	}
+	if (!setPtrs)
+	{
+		res = G2_SetupModelPointers(ghlInfo);
+	}
+
+	if (res)
+	{
+		// ensure we flush the cache
+		ghlInfo->mSkelFrameNum = 0;
+ 		return G2_Set_Bone_Anim_Index(ghlInfo->mBlist, index, startFrame, endFrame, flags, animSpeed, currentTime, setFrame, blendTime, ghlInfo->aHeader->numFrames);
+	}
+	return qfalse;
+}
+
+#define _PLEASE_SHUT_THE_HELL_UP
+
+qboolean G2API_SetBoneAnim(CGhoul2Info_v &ghoul2, const int modelIndex, const char *boneName, const int AstartFrame, const int AendFrame, const int flags, const float animSpeed, const int currentTime, const float AsetFrame, const int blendTime)
+{
+	int endFrame=AendFrame;
+	int startFrame=AstartFrame;
+	float setFrame=AsetFrame;
+#ifndef _PLEASE_SHUT_THE_HELL_UP
+	assert(endFrame>0);
+	assert(startFrame>=0);
+	assert(endFrame<100000);
+	assert(startFrame<100000);
+	assert(setFrame>=0.0f||setFrame==-1.0f);
+	assert(setFrame<=100000.0f);
+#endif
+	if (endFrame<=0)
+	{
+		endFrame=1;
+	}
+	if (endFrame>=100000)
+	{
+		endFrame=1;
+	}
+	if (startFrame<0)
+	{
+		startFrame=0;
+	}
+	if (startFrame>=100000)
+	{
+		startFrame=0;
+	}
+	if (setFrame<0.0f&&setFrame!=-1.0f)
+	{
+		setFrame=0.0f;
+	}
+	if (setFrame>100000.0f)
+	{
+		setFrame=0.0f;
+	}
+	if ((int)&ghoul2 && ghoul2.size()>modelIndex)
+	{
+		CGhoul2Info *ghlInfo = &ghoul2[modelIndex];
+		qboolean setPtrs = qfalse;
+		qboolean res = qfalse;
+		
+		//rww - RAGDOLL_BEGIN
+		if (ghlInfo)
+		{
+			res = G2_SetupModelPointers(ghlInfo);
+			setPtrs = qtrue;
+
+			if (res)
+			{
+				if (ghlInfo->mFlags & GHOUL2_RAG_STARTED)
+				{
+					return qfalse;
+				}
+			}
+		}
+		//rww - RAGDOLL_END
+
+		if (!setPtrs)
+		{
+			res = G2_SetupModelPointers(ghlInfo);
+		}
+
+		if (res)
+		{
+			// ensure we flush the cache
+			ghlInfo->mSkelFrameNum = 0;
+ 			return G2_Set_Bone_Anim(ghlInfo, ghlInfo->mBlist, boneName, startFrame, endFrame, flags, animSpeed, currentTime, setFrame, blendTime);
+		}
+	}
+	return qfalse;
+}
+
+qboolean G2API_GetBoneAnim(CGhoul2Info *ghlInfo, const char *boneName, const int currentTime, float *currentFrame,
+						   int *startFrame, int *endFrame, int *flags, float *animSpeed, int *modelList)
+{
+	assert(startFrame!=endFrame); //this is bad
+	assert(startFrame!=flags); //this is bad
+	assert(endFrame!=flags); //this is bad
+	assert(currentFrame!=animSpeed); //this is bad
+	if (G2_SetupModelPointers(ghlInfo))
+	{
+		int aCurrentTime=G2API_GetTime(currentTime);
+ 		qboolean ret=G2_Get_Bone_Anim(ghlInfo, ghlInfo->mBlist, boneName, aCurrentTime, currentFrame,
+			startFrame, endFrame, flags, animSpeed, modelList, ghlInfo->mModelindex);
+#ifdef _DEBUG
+		/*
+		assert(*endFrame>0);
+		assert(*endFrame<100000);
+		assert(*startFrame>=0);
+		assert(*startFrame<100000);
+		assert(*currentFrame>=0.0f);
+		assert(*currentFrame<100000.0f);
+		*/
+		if (*endFrame<1)
+		{
+			*endFrame=1;
+		}
+		if (*endFrame>100000)
+		{
+			*endFrame=1;
+		}
+		if (*startFrame<0)
+		{
+			*startFrame=0;
+		}
+		if (*startFrame>100000)
+		{
+			*startFrame=1;
+		}
+		if (*currentFrame<0.0f)
+		{
+			*currentFrame=0.0f;
+		}
+		if (*currentFrame>100000)
+		{
+			*currentFrame=1;
+		}
+#endif
+		return ret;
+	}
+	return qfalse;
+}
+
+qboolean G2API_GetAnimRange(CGhoul2Info *ghlInfo, const char *boneName,	int *startFrame, int *endFrame)
+{
+	assert(startFrame!=endFrame); //this is bad
+	if (G2_SetupModelPointers(ghlInfo))
+	{
+ 		qboolean ret=G2_Get_Bone_Anim_Range(ghlInfo, ghlInfo->mBlist, boneName, startFrame, endFrame);
+#ifdef _DEBUG
+		assert(*endFrame>0);
+		assert(*endFrame<100000);
+		assert(*startFrame>=0);
+		assert(*startFrame<100000);
+		if (*endFrame<1)
+		{
+			*endFrame=1;
+		}
+		if (*endFrame>100000)
+		{
+			*endFrame=1;
+		}
+		if (*startFrame<0)
+		{
+			*startFrame=0;
+		}
+		if (*startFrame>100000)
+		{
+			*startFrame=1;
+		}
+#endif
+		return ret;
+	}
+	return qfalse;
+}
+
+
+qboolean G2API_PauseBoneAnim(CGhoul2Info *ghlInfo, const char *boneName, const int currentTime)
+{
+	if (G2_SetupModelPointers(ghlInfo))
+	{
+ 		return G2_Pause_Bone_Anim(ghlInfo, ghlInfo->mBlist, boneName, currentTime);
+	}
+	return qfalse;
+}
+
+qboolean	G2API_IsPaused(CGhoul2Info *ghlInfo, const char *boneName)
+{
+	if (G2_SetupModelPointers(ghlInfo))
+	{
+ 		return G2_IsPaused(ghlInfo->mFileName, ghlInfo->mBlist, boneName);
+	}
+	return qfalse;
+}
+
+qboolean G2API_StopBoneAnimIndex(CGhoul2Info *ghlInfo, const int index)
+{
+	if (G2_SetupModelPointers(ghlInfo))
+	{
+ 		return G2_Stop_Bone_Anim_Index(ghlInfo->mBlist, index);
+	}
+	return qfalse;
+}
+
+qboolean G2API_StopBoneAnim(CGhoul2Info *ghlInfo, const char *boneName)
+{
+	if (G2_SetupModelPointers(ghlInfo))
+	{
+ 		return G2_Stop_Bone_Anim(ghlInfo->mFileName, ghlInfo->mBlist, boneName);
+	}
+	return qfalse;
+}
+
+qboolean G2API_SetBoneAnglesIndex(CGhoul2Info *ghlInfo, const int index, const vec3_t angles, const int flags,
+							 const Eorientations yaw, const Eorientations pitch, const Eorientations roll,
+							 qhandle_t *modelList, int blendTime, int currentTime)
+{
+	qboolean setPtrs = qfalse;
+	qboolean res = qfalse;
+
+	//rww - RAGDOLL_BEGIN
+	if (ghlInfo)
+	{
+		res = G2_SetupModelPointers(ghlInfo);
+		setPtrs = qtrue;
+
+		if (res)
+		{
+			if (ghlInfo->mFlags & GHOUL2_RAG_STARTED)
+			{
+				return qfalse;
+			}
+		}
+	}
+	//rww - RAGDOLL_END
+
+	if (!setPtrs)
+	{
+		res = G2_SetupModelPointers(ghlInfo);
+	}
+
+	if (res)
+	{
+		// ensure we flush the cache
+		ghlInfo->mSkelFrameNum = 0;
+		return G2_Set_Bone_Angles_Index( ghlInfo->mBlist, index, angles, flags, yaw, pitch, roll, modelList, ghlInfo->mModelindex, blendTime, currentTime);
+	}
+	return qfalse;
+}
+
+qboolean G2API_SetBoneAngles(CGhoul2Info_v &ghoul2, const int modelIndex, const char *boneName, const vec3_t angles, const int flags,
+							 const Eorientations up, const Eorientations left, const Eorientations forward,
+							 qhandle_t *modelList, int blendTime, int currentTime )
+{
+	if ((int)&ghoul2 && ghoul2.size()>modelIndex)
+	{
+		CGhoul2Info *ghlInfo = &ghoul2[modelIndex];
+		qboolean setPtrs = qfalse;
+		qboolean res = qfalse;
+
+		//rww - RAGDOLL_BEGIN
+		if (ghlInfo)
+		{
+			res = G2_SetupModelPointers(ghlInfo);
+			setPtrs = qtrue;
+
+			if (res)
+			{
+				if (ghlInfo->mFlags & GHOUL2_RAG_STARTED)
+				{
+					return qfalse;
+				}
+			}
+		}
+		//rww - RAGDOLL_END
+
+		if (!setPtrs)
+		{
+			res = G2_SetupModelPointers(ghoul2);
+		}
+
+		if (res)
+		{
+				// ensure we flush the cache
+			ghlInfo->mSkelFrameNum = 0;
+			return G2_Set_Bone_Angles(ghlInfo, ghlInfo->mBlist, boneName, angles, flags, up, left, forward, modelList, ghlInfo->mModelindex, blendTime, currentTime);
+		}
+	}
+	return qfalse;
+}
+
+qboolean G2API_SetBoneAnglesMatrixIndex(CGhoul2Info *ghlInfo, const int index, const mdxaBone_t &matrix,
+								   const int flags, qhandle_t *modelList, int blendTime, int currentTime)
+{
+	if (G2_SetupModelPointers(ghlInfo))
+	{
+		// ensure we flush the cache
+		ghlInfo->mSkelFrameNum = 0;
+		return G2_Set_Bone_Angles_Matrix_Index(ghlInfo->mBlist, index, matrix, flags, modelList, ghlInfo->mModelindex, blendTime, currentTime);
+	}
+	return qfalse;
+}
+
+qboolean G2API_SetBoneAnglesMatrix(CGhoul2Info *ghlInfo, const char *boneName, const mdxaBone_t &matrix,
+								   const int flags, qhandle_t *modelList, int blendTime, int currentTime)
+{
+	if (G2_SetupModelPointers(ghlInfo))
+	{
+		// ensure we flush the cache
+		ghlInfo->mSkelFrameNum = 0;
+		return G2_Set_Bone_Angles_Matrix(ghlInfo->mFileName, ghlInfo->mBlist, boneName, matrix, flags, modelList, ghlInfo->mModelindex, blendTime, currentTime);
+	}
+	return qfalse;
+}
+
+qboolean G2API_StopBoneAnglesIndex(CGhoul2Info *ghlInfo, const int index)
+{
+	if (G2_SetupModelPointers(ghlInfo))
+	{
+		// ensure we flush the cache
+		ghlInfo->mSkelFrameNum = 0;
+ 		return G2_Stop_Bone_Angles_Index(ghlInfo->mBlist, index);
+	}
+	return qfalse;
+}
+
+qboolean G2API_StopBoneAngles(CGhoul2Info *ghlInfo, const char *boneName)
+{
+	if (G2_SetupModelPointers(ghlInfo))
+	{
+		// ensure we flush the cache
+		ghlInfo->mSkelFrameNum = 0;
+ 		return G2_Stop_Bone_Angles(ghlInfo->mFileName, ghlInfo->mBlist, boneName);
+	}
+	return qfalse;
+}
+
+
+void G2API_AbsurdSmoothing(CGhoul2Info_v &ghoul2, qboolean status)
+{
+	assert(ghoul2.size());
+	CGhoul2Info *ghlInfo = &ghoul2[0];
+
+	if (status)
+	{ //turn it on
+		ghlInfo->mFlags |= GHOUL2_CRAZY_SMOOTH;
+	}
+	else
+	{ //off
+		ghlInfo->mFlags &= ~GHOUL2_CRAZY_SMOOTH;
+	}
+}
+
+//rww - RAGDOLL_BEGIN
+class CRagDollParams;
+void G2_SetRagDoll(CGhoul2Info_v &ghoul2V,CRagDollParams *parms);
+void G2API_SetRagDoll(CGhoul2Info_v &ghoul2,CRagDollParams *parms)
+{
+	G2_SetRagDoll(ghoul2,parms);
+}
+
+void G2_ResetRagDoll(CGhoul2Info_v &ghoul2V);
+void G2API_ResetRagDoll(CGhoul2Info_v &ghoul2)
+{
+	G2_ResetRagDoll(ghoul2);
+}
+//rww - RAGDOLL_END
+
+qboolean G2API_RemoveBone(CGhoul2Info *ghlInfo, const char *boneName)
+{
+	if (G2_SetupModelPointers(ghlInfo))
+	{
+		// ensure we flush the cache
+		ghlInfo->mSkelFrameNum = 0;
+ 		return G2_Remove_Bone(ghlInfo, ghlInfo->mBlist, boneName);
+	}
+	return qfalse;
+}
+
+//rww - RAGDOLL_BEGIN
+#ifdef _DEBUG
+extern int ragTraceTime;
+extern int ragSSCount;
+extern int ragTraceCount;
+#endif
+
+void G2API_AnimateG2Models(CGhoul2Info_v &ghoul2, int AcurrentTime,CRagDollUpdateParams *params)
+{
+	int model;
+	int currentTime=G2API_GetTime(AcurrentTime);
+
+#ifdef _DEBUG
+	ragTraceTime = 0;
+	ragSSCount = 0;
+	ragTraceCount = 0;
+#endif
+
+	// Walk the list and find all models that are active
+	for (model = 0; model < ghoul2.size(); model++)
+	{
+		if (ghoul2[model].mModel)
+		{
+			G2_Animate_Bone_List(ghoul2,currentTime,model,params);	
+		}
+	}
+#ifdef _DEBUG
+	/*
+	if (ragTraceTime)
+	{
+		Com_Printf("Rag trace time: %i (%i STARTSOLID, %i TOTAL)\n", ragTraceTime, ragSSCount, ragTraceCount);
+	}
+	*/
+
+	//keep sane limits here, if it gets too slow an assert is proper.
+//	assert(ragTraceTime < 150);
+//	assert(ragTraceCount < 1500);
+#endif
+}
+//rww - RAGDOLL_END
+
+int G2_Find_Bone_Rag(CGhoul2Info *ghlInfo, boneInfo_v &blist, const char *boneName);
+#define RAG_PCJ						(0x00001)
+#define RAG_EFFECTOR				(0x00100)
+
+static inline boneInfo_t *G2_GetRagBoneConveniently(CGhoul2Info_v &ghoul2, const char *boneName)
+{
+	assert(ghoul2.size());
+	CGhoul2Info *ghlInfo = &ghoul2[0];
+
+	if (!(ghlInfo->mFlags & GHOUL2_RAG_STARTED))
+	{ //can't do this if not in ragdoll
+		return NULL;
+	}
+
+	int boneIndex = G2_Find_Bone_Rag(ghlInfo, ghlInfo->mBlist, boneName);
+
+	if (boneIndex < 0)
+	{ //bad bone specification
+		return NULL;
+	}
+
+	boneInfo_t *bone = &ghlInfo->mBlist[boneIndex];
+
+	if (!(bone->flags & BONE_ANGLES_RAGDOLL))
+	{ //only want to return rag bones
+		return NULL;
+	}
+
+	return bone;
+}
+
+qboolean G2API_RagPCJConstraint(CGhoul2Info_v &ghoul2, const char *boneName, vec3_t min, vec3_t max)
+{
+	boneInfo_t *bone = G2_GetRagBoneConveniently(ghoul2, boneName);
+
+	if (!bone)
+	{
+		return qfalse;
+	}
+
+	if (!(bone->RagFlags & RAG_PCJ))
+	{ //this function is only for PCJ bones
+		return qfalse;
+	}
+
+	VectorCopy(min, bone->minAngles);
+	VectorCopy(max, bone->maxAngles);
+
+	return qtrue;
+}
+
+qboolean G2API_RagPCJGradientSpeed(CGhoul2Info_v &ghoul2, const char *boneName, const float speed)
+{
+	boneInfo_t *bone = G2_GetRagBoneConveniently(ghoul2, boneName);
+
+	if (!bone)
+	{
+		return qfalse;
+	}
+
+	if (!(bone->RagFlags & RAG_PCJ))
+	{ //this function is only for PCJ bones
+		return qfalse;
+	}
+
+	bone->overGradSpeed = speed;
+
+	return qtrue;
+}
+
+qboolean G2API_RagEffectorGoal(CGhoul2Info_v &ghoul2, const char *boneName, vec3_t pos)
+{
+	boneInfo_t *bone = G2_GetRagBoneConveniently(ghoul2, boneName);
+
+	if (!bone)
+	{
+		return qfalse;
+	}
+
+	if (!(bone->RagFlags & RAG_EFFECTOR))
+	{ //this function is only for effectors
+		return qfalse;
+	}
+
+	if (!pos)
+	{ //go back to none in case we have one then
+		bone->hasOverGoal = false;
+	}
+	else
+	{
+		VectorCopy(pos, bone->overGoalSpot);
+		bone->hasOverGoal = true;
+	}
+	return qtrue;
+}
+
+qboolean G2API_GetRagBonePos(CGhoul2Info_v &ghoul2, const char *boneName, vec3_t pos, vec3_t entAngles, vec3_t entPos, vec3_t entScale)
+{ //do something?
+	return qfalse;
+}
+
+qboolean G2API_RagEffectorKick(CGhoul2Info_v &ghoul2, const char *boneName, vec3_t velocity)
+{
+	boneInfo_t *bone = G2_GetRagBoneConveniently(ghoul2, boneName);
+
+	if (!bone)
+	{
+		return qfalse;
+	}
+
+	if (!(bone->RagFlags & RAG_EFFECTOR))
+	{ //this function is only for effectors
+		return qfalse;
+	}
+
+	bone->epVelocity[2] = 0;
+	VectorAdd(bone->epVelocity, velocity, bone->epVelocity);
+	bone->physicsSettled = false;
+
+	return qtrue;
+}
+
+qboolean G2API_RagForceSolve(CGhoul2Info_v &ghoul2, qboolean force)
+{
+	assert(ghoul2.size());
+	CGhoul2Info *ghlInfo = &ghoul2[0];
+
+	if (!(ghlInfo->mFlags & GHOUL2_RAG_STARTED))
+	{ //can't do this if not in ragdoll
+		return qfalse;
+	}
+
+	if (force)
+	{
+		ghlInfo->mFlags |= GHOUL2_RAG_FORCESOLVE;
+	}
+	else
+	{
+		ghlInfo->mFlags &= ~GHOUL2_RAG_FORCESOLVE;
+	}
+
+	return qtrue;
+}
+
+qboolean G2_SetBoneIKState(CGhoul2Info_v &ghoul2, int time, const char *boneName, int ikState, sharedSetBoneIKStateParams_t *params);
+qboolean G2API_SetBoneIKState(CGhoul2Info_v &ghoul2, int time, const char *boneName, int ikState, sharedSetBoneIKStateParams_t *params)
+{
+	return G2_SetBoneIKState(ghoul2, time, boneName, ikState, params);
+}
+
+qboolean G2_IKMove(CGhoul2Info_v &ghoul2, int time, sharedIKMoveParams_t *params);
+qboolean G2API_IKMove(CGhoul2Info_v &ghoul2, int time, sharedIKMoveParams_t *params)
+{
+	return G2_IKMove(ghoul2, time, params);
+}
+
+qboolean G2API_RemoveBolt(CGhoul2Info *ghlInfo, const int index)
+{
+	if (G2_SetupModelPointers(ghlInfo))
+	{
+		return G2_Remove_Bolt( ghlInfo->mBltlist, index);
+	}
+	return qfalse;
+}
+
+int G2API_AddBolt(CGhoul2Info_v &ghoul2, const int modelIndex, const char *boneName)
+{
+	assert(ghoul2.size()>modelIndex);
+
+	if ((int)&ghoul2 && ghoul2.size()>modelIndex)
+	{
+		CGhoul2Info *ghlInfo = &ghoul2[modelIndex];
+		if (G2_SetupModelPointers(ghlInfo))
+		{
+			return G2_Add_Bolt(ghlInfo, ghlInfo->mBltlist, ghlInfo->mSlist, boneName);
+		}
+	}
+	return -1;
+}
+
+int G2API_AddBoltSurfNum(CGhoul2Info *ghlInfo, const int surfIndex)
+{
+	if (G2_SetupModelPointers(ghlInfo))
+	{
+		return G2_Add_Bolt_Surf_Num(ghlInfo, ghlInfo->mBltlist, ghlInfo->mSlist, surfIndex);
+	}
+	return -1;
+}
+
+
+qboolean G2API_AttachG2Model(CGhoul2Info_v &ghoul2From, int modelFrom, CGhoul2Info_v &ghoul2To, int toBoltIndex, int toModel)
+{
+	assert( toBoltIndex >= 0 );
+	if ( toBoltIndex < 0 )
+	{
+		return qfalse;
+	}
+	if (G2_SetupModelPointers(ghoul2From)&&G2_SetupModelPointers(ghoul2To))
+	{
+		// make sure we have a model to attach, a model to attach to, and a bolt on that model
+		if (((int)&ghoul2From) &&
+			((int)&ghoul2To) &&
+			(ghoul2From.size() > modelFrom) &&
+			(ghoul2To.size() > toModel) &&
+			((ghoul2To[toModel].mBltlist[toBoltIndex].boneNumber != -1) || (ghoul2To[toModel].mBltlist[toBoltIndex].surfaceNumber != -1)))
+		{
+			// encode the bolt address into the model bolt link
+		   toModel &= MODEL_AND;
+		   toBoltIndex &= BOLT_AND;
+		   ghoul2From[modelFrom].mModelBoltLink = (toModel << MODEL_SHIFT)  | (toBoltIndex << BOLT_SHIFT);
+		   return qtrue;
+		}
+	}
+	return qfalse;
+}
+
+void G2API_SetBoltInfo(CGhoul2Info_v &ghoul2, int modelIndex, int boltInfo)
+{
+	if ((int)&ghoul2)
+	{
+		if (ghoul2.size() > modelIndex)
+		{
+			ghoul2[modelIndex].mModelBoltLink = boltInfo;
+		}
+	}
+}
+
+qboolean G2API_DetachG2Model(CGhoul2Info *ghlInfo)
+{
+	if (G2_SetupModelPointers(ghlInfo))
+	{
+	   ghlInfo->mModelBoltLink = -1;
+	   return qtrue;
+	}
+	return qfalse;
+}
+
+qboolean G2API_AttachEnt(int *boltInfo, CGhoul2Info *ghlInfoTo, int toBoltIndex, int entNum, int toModelNum)
+{  	
+	if (boltInfo && G2_SetupModelPointers(ghlInfoTo))
+	{
+		// make sure we have a model to attach, a model to attach to, and a bolt on that model
+		if ( ghlInfoTo->mBltlist.size() && ((ghlInfoTo->mBltlist[toBoltIndex].boneNumber != -1) || (ghlInfoTo->mBltlist[toBoltIndex].surfaceNumber != -1)))
+		{
+			// encode the bolt address into the model bolt link
+		   toModelNum &= MODEL_AND;	
+		   toBoltIndex &= BOLT_AND;
+		   entNum &= ENTITY_AND;
+		   *boltInfo =  (toBoltIndex << BOLT_SHIFT) | (toModelNum << MODEL_SHIFT) | (entNum << ENTITY_SHIFT);
+		   return qtrue;
+		}
+	}
+	return qfalse;
+
+}
+
+qboolean gG2_GBMNoReconstruct;
+qboolean gG2_GBMUseSPMethod;
+
+qboolean G2API_GetBoltMatrix_SPMethod(CGhoul2Info_v &ghoul2, const int modelIndex, const int boltIndex, mdxaBone_t *matrix, const vec3_t angles, 
+							 const vec3_t position, const int frameNum, qhandle_t *modelList, const vec3_t scale )
+{
+	assert(ghoul2.size() > modelIndex);
+
+	if ((int)&ghoul2 && (ghoul2.size() > modelIndex))
+	{
+		CGhoul2Info *ghlInfo = &ghoul2[modelIndex];
+
+		//assert(boltIndex < ghlInfo->mBltlist.size());
+
+		if (ghlInfo && (boltIndex < ghlInfo->mBltlist.size()) && boltIndex >= 0 )
+		{
+			// make sure we have transformed the skeleton
+			if (!gG2_GBMNoReconstruct)
+			{
+				G2_ConstructGhoulSkeleton(ghoul2, frameNum, true, scale);
+			}
+
+			gG2_GBMNoReconstruct = qfalse;
+
+			mdxaBone_t scaled;
+			mdxaBone_t *use;
+			use=&ghlInfo->mBltlist[boltIndex].position;
+
+			if (scale[0]||scale[1]||scale[2])
+			{
+				scaled=*use;
+				use=&scaled;
+
+				// scale the bolt position by the scale factor for this model since at this point its still in model space
+				if (scale[0])
+				{
+					scaled.matrix[0][3] *= scale[0];
+				}
+				if (scale[1])
+				{
+					scaled.matrix[1][3] *= scale[1];
+				}
+				if (scale[2])
+				{
+					scaled.matrix[2][3] *= scale[2];
+				}
+			}
+			// pre generate the world matrix
+			G2_GenerateWorldMatrix(angles, position);
+
+			VectorNormalize((float*)use->matrix[0]);
+			VectorNormalize((float*)use->matrix[1]);
+			VectorNormalize((float*)use->matrix[2]);
+
+			Multiply_3x4Matrix(matrix, &worldMatrix, use);
+			return qtrue;
+		}
+	}
+	return qfalse;
+}
+
+#define G2ERROR(exp,m)		((void)0) //rwwFIXMEFIXME: This is because I'm lazy.
+#define G2WARNING(exp,m)     ((void)0)
+#define G2NOTE(exp,m)     ((void)0)
+#define G2ANIM(ghlInfo,m) ((void)0)
+bool G2_NeedsRecalc(CGhoul2Info *ghlInfo,int frameNum);
+void G2_GetBoltMatrixLow(CGhoul2Info &ghoul2,int boltNum,const vec3_t scale,mdxaBone_t &retMatrix);
+void G2_GetBoneMatrixLow(CGhoul2Info &ghoul2,int boneNum,const vec3_t scale,mdxaBone_t &retMatrix,mdxaBone_t *&retBasepose,mdxaBone_t *&retBaseposeInv);
+
+//qboolean G2API_GetBoltMatrix(CGhoul2Info_v &ghoul2, const int modelIndex, const int boltIndex, mdxaBone_t *matrix, const vec3_t angles, 
+//							 const vec3_t position, const int AframeNum, qhandle_t *modelList, const vec3_t scale )
+qboolean G2API_GetBoltMatrix(CGhoul2Info_v &ghoul2, const int modelIndex, const int boltIndex, mdxaBone_t *matrix, const vec3_t angles,
+							 const vec3_t position, const int frameNum, qhandle_t *modelList, vec3_t scale )
+{
+//	G2ERROR(ghoul2.IsValid(),"Invalid ghlInfo");
+	G2ERROR(matrix,"NULL matrix");
+	G2ERROR(modelIndex>=0&&modelIndex<ghoul2.size(),"Invalid ModelIndex");
+	const static mdxaBone_t		identityMatrix = 
+	{ 
+		0.0f, -1.0f, 0.0f, 0.0f,
+		1.0f, 0.0f, 0.0f, 0.0f,
+		0.0f, 0.0f, 1.0f, 0.0f
+	};
+	G2_GenerateWorldMatrix(angles, position);
+	if (G2_SetupModelPointers(ghoul2))
+	{
+		if (matrix&&modelIndex>=0&&modelIndex<ghoul2.size())
+		{
+			int tframeNum=G2API_GetTime(frameNum);
+			CGhoul2Info *ghlInfo = &ghoul2[modelIndex];
+			G2ERROR(boltIndex >= 0 && (boltIndex < ghlInfo->mBltlist.size()),va("Invalid Bolt Index (%d:%s)",boltIndex,ghlInfo->mFileName));
+
+			if (boltIndex >= 0 && ghlInfo && (boltIndex < ghlInfo->mBltlist.size()) )
+			{
+				mdxaBone_t bolt;
+
+#if 0 //yeah, screw it
+				if (!gG2_GBMNoReconstruct)
+				{ //This should only be used when you know what you're doing.
+					if (G2_NeedsRecalc(ghlInfo,tframeNum))
+					{
+						G2_ConstructGhoulSkeleton(ghoul2,tframeNum,true,scale);
+					}
+				}
+				else
+				{
+					gG2_GBMNoReconstruct = qfalse;
+				}
+#else
+				if (G2_NeedsRecalc(ghlInfo,tframeNum))
+				{
+					G2_ConstructGhoulSkeleton(ghoul2,tframeNum,true,scale);
+				}
+#endif
+
+				G2_GetBoltMatrixLow(*ghlInfo,boltIndex,scale,bolt);
+				// scale the bolt position by the scale factor for this model since at this point its still in model space
+				if (scale[0])
+				{
+					bolt.matrix[0][3] *= scale[0];
+				}
+				if (scale[1])
+				{
+					bolt.matrix[1][3] *= scale[1];
+				}
+				if (scale[2])
+				{
+					bolt.matrix[2][3] *= scale[2];
+				}
+				VectorNormalize((float*)&bolt.matrix[0]);
+				VectorNormalize((float*)&bolt.matrix[1]);
+				VectorNormalize((float*)&bolt.matrix[2]);
+
+				Multiply_3x4Matrix(matrix, &worldMatrix, &bolt);												
+#if G2API_DEBUG
+				for ( int i = 0; i < 3; i++ )
+				{
+					for ( int j = 0; j < 4; j++ )
+					{
+						assert( !_isnan(matrix->matrix[i][j]));
+					}
+				}
+#endif// _DEBUG
+				G2ANIM(ghlInfo,"G2API_GetBoltMatrix");
+
+				if (!gG2_GBMUseSPMethod)
+				{ //this is horribly stupid and I hate it. But lots of game code is written to assume this 90 degree offset thing.
+					mdxaBone_t	rotMat, tempMatrix;
+					vec3_t		newangles = {0,270,0};
+					Create_Matrix(newangles, &rotMat);
+					// make the model space matrix we have for this bolt into a world matrix
+					Multiply_3x4Matrix(&tempMatrix, &worldMatrix, &bolt);	
+					vec3_t origin;
+					origin[0] = tempMatrix.matrix[0][3];
+					origin[1] = tempMatrix.matrix[1][3];
+					origin[2] = tempMatrix.matrix[2][3];
+					tempMatrix.matrix[0][3] = tempMatrix.matrix[1][3] = tempMatrix.matrix[2][3] = 0;
+					Multiply_3x4Matrix(matrix, &tempMatrix, &rotMat);
+					matrix->matrix[0][3] = origin[0];
+					matrix->matrix[1][3] = origin[1];
+					matrix->matrix[2][3] = origin[2];
+				}
+				else
+				{ //reset it
+					gG2_GBMUseSPMethod = qfalse;
+				}
+
+				return qtrue;
+			}
+		}
+	}
+	else
+	{
+		G2WARNING(0,"G2API_GetBoltMatrix Failed on empty or bad model");
+	}
+	Multiply_3x4Matrix(matrix, &worldMatrix, (mdxaBone_t *)&identityMatrix);
+	return qfalse;
+}
+
+void G2API_ListSurfaces(CGhoul2Info *ghlInfo)
+{
+	if (G2_SetupModelPointers(ghlInfo))
+	{
+		G2_List_Model_Surfaces(ghlInfo->mFileName);
+	}
+}
+
+void G2API_ListBones(CGhoul2Info *ghlInfo, int frame)
+{
+	if (G2_SetupModelPointers(ghlInfo))
+	{
+		G2_List_Model_Bones(ghlInfo->mFileName, frame);
+	}
+}
+
+// decide if we have Ghoul2 models associated with this ghoul list or not
+qboolean G2API_HaveWeGhoul2Models(CGhoul2Info_v &ghoul2)
+{
+	int i;
+	if ((int)&ghoul2)
+	{
+		for (i=0; i<ghoul2.size();i++)
+		{
+			if (ghoul2[i].mModelindex != -1)
+			{
+				return qtrue;
+			}
+		}
+	}
+	return qfalse;
+}
+
+// run through the Ghoul2 models and set each of the mModel values to the correct one from the cgs.gameModel offset lsit
+void G2API_SetGhoul2ModelIndexes(CGhoul2Info_v &ghoul2, qhandle_t *modelList, qhandle_t *skinList)
+{
+	return;
+#if 0
+	int i;
+	if ((int)&ghoul2)
+	{
+		for (i=0; i<ghoul2.size(); i++)
+		{
+			if (ghoul2[i].mModelindex != -1)
+			{
+				// broken into 3 lines for debugging, STL is a pain to view...
+				//
+				int iModelIndex  = ghoul2[i].mModelindex;
+				qhandle_t mModel = modelList[iModelIndex];	
+				ghoul2[i].mModel = mModel;
+
+				ghoul2[i].mSkin = skinList[ghoul2[i].mCustomSkin];
+			}
+		}
+	}
+#endif
+}
+
+
+char *G2API_GetAnimFileNameIndex(qhandle_t modelIndex)
+{
+	model_t		*mod_m = R_GetModelByHandle(modelIndex);
+	return mod_m->mdxm->animName;
+}
+
+/************************************************************************************************
+ * G2API_GetAnimFileName
+ *    obtains the name of a model's .gla (animation) file 
+ *
+ * Input
+ *    pointer to list of CGhoul2Info's, WraithID of specific model in that list
+ *
+ * Output
+ *    true if a good filename was obtained, false otherwise
+ *
+ ************************************************************************************************/
+qboolean G2API_GetAnimFileName(CGhoul2Info *ghlInfo, char **filename)
+{
+	if (G2_SetupModelPointers(ghlInfo))
+	{
+		return G2_GetAnimFileName(ghlInfo->mFileName, filename);
+	}
+	return qfalse;
+}
+
+/*
+=======================
+SV_QsortEntityNumbers
+=======================
+*/
+static int QDECL QsortDistance( const void *a, const void *b ) {
+	const float	&ea = ((CollisionRecord_t*)a)->mDistance;
+	const float	&eb = ((CollisionRecord_t*)b)->mDistance;
+
+	if ( ea < eb ) {
+		return -1;
+	}
+	return 1;
+}
+
+
+void G2API_CollisionDetect(CollisionRecord_t *collRecMap, CGhoul2Info_v &ghoul2, const vec3_t angles, const vec3_t position,
+										  int frameNumber, int entNum, vec3_t rayStart, vec3_t rayEnd, vec3_t scale, CMiniHeap *G2VertSpace, int traceFlags, int useLod, float fRadius)
+{
+	if (G2_SetupModelPointers(ghoul2))
+	{
+		vec3_t	transRayStart, transRayEnd;
+
+		// make sure we have transformed the whole skeletons for each model
+		G2_ConstructGhoulSkeleton(ghoul2, frameNumber, true, scale);
+
+		// pre generate the world matrix - used to transform the incoming ray
+		G2_GenerateWorldMatrix(angles, position);
+
+		G2VertSpace->ResetHeap();
+
+		// now having done that, time to build the model
+#ifdef _G2_GORE
+		G2_TransformModel(ghoul2, frameNumber, scale, G2VertSpace, useLod, false);
+#else
+		G2_TransformModel(ghoul2, frameNumber, scale, G2VertSpace, useLod);
+#endif
+
+		// model is built. Lets check to see if any triangles are actually hit.
+		// first up, translate the ray to model space
+		TransformAndTranslatePoint(rayStart, transRayStart, &worldMatrixInv);
+		TransformAndTranslatePoint(rayEnd, transRayEnd, &worldMatrixInv);
+
+		// now walk each model and check the ray against each poly - sigh, this is SO expensive. I wish there was a better way to do this.
+#ifdef _G2_GORE
+		G2_TraceModels(ghoul2, transRayStart, transRayEnd, collRecMap, entNum, traceFlags, useLod, fRadius,0,0,0,0,0);
+#else
+		G2_TraceModels(ghoul2, transRayStart, transRayEnd, collRecMap, entNum, traceFlags, useLod, fRadius);
+#endif
+		int i;
+		for ( i = 0; i < MAX_G2_COLLISIONS && collRecMap[i].mEntityNum != -1; i ++ );
+
+		// now sort the resulting array of collision records so they are distance ordered
+		qsort( collRecMap, i, 
+			sizeof( CollisionRecord_t ), QsortDistance );
+	}
+}
+
+qboolean G2API_SetGhoul2ModelFlags(CGhoul2Info *ghlInfo, const int flags)
+{
+	if (G2_SetupModelPointers(ghlInfo))
+	{
+		ghlInfo->mFlags &= GHOUL2_NEWORIGIN;
+		ghlInfo->mFlags |= flags;
+		return qtrue;
+	}
+	return qfalse;
+}
+
+int G2API_GetGhoul2ModelFlags(CGhoul2Info *ghlInfo)
+{
+	if (G2_SetupModelPointers(ghlInfo))
+	{
+		return (ghlInfo->mFlags & ~GHOUL2_NEWORIGIN);
+	}
+	return 0;
+}
+
+// given a boltmatrix, return in vec a normalised vector for the axis requested in flags
+void G2API_GiveMeVectorFromMatrix(mdxaBone_t *boltMatrix, Eorientations flags, vec3_t vec)
+{
+	switch (flags)
+	{
+	case ORIGIN:
+		vec[0] = boltMatrix->matrix[0][3];
+		vec[1] = boltMatrix->matrix[1][3];
+		vec[2] = boltMatrix->matrix[2][3];
+		break;
+	case POSITIVE_Y:
+		vec[0] = boltMatrix->matrix[0][1];
+		vec[1] = boltMatrix->matrix[1][1];
+		vec[2] = boltMatrix->matrix[2][1];
+ 		break;
+	case POSITIVE_X:
+		vec[0] = boltMatrix->matrix[0][0];
+		vec[1] = boltMatrix->matrix[1][0];
+		vec[2] = boltMatrix->matrix[2][0];
+		break;
+	case POSITIVE_Z:
+		vec[0] = boltMatrix->matrix[0][2];
+		vec[1] = boltMatrix->matrix[1][2];
+		vec[2] = boltMatrix->matrix[2][2];
+		break;
+	case NEGATIVE_Y:
+		vec[0] = -boltMatrix->matrix[0][1];
+		vec[1] = -boltMatrix->matrix[1][1];
+		vec[2] = -boltMatrix->matrix[2][1];
+		break;
+	case NEGATIVE_X:
+		vec[0] = -boltMatrix->matrix[0][0];
+		vec[1] = -boltMatrix->matrix[1][0];
+		vec[2] = -boltMatrix->matrix[2][0];
+		break;
+	case NEGATIVE_Z:
+		vec[0] = -boltMatrix->matrix[0][2];
+		vec[1] = -boltMatrix->matrix[1][2];
+		vec[2] = -boltMatrix->matrix[2][2];
+		break;
+	}
+}
+
+
+int G2API_CopyGhoul2Instance(CGhoul2Info_v &g2From, CGhoul2Info_v &g2To, int modelIndex)
+{
+	assert(modelIndex==-1); // copy individual bolted parts is not used in jk2 and I didn't want to deal with it
+							// if ya want it, we will add it back correctly
+	
+	//G2ERROR(ghoul2From.IsValid(),"Invalid ghlInfo");
+	if (g2From.IsValid())
+	{
+#ifdef _DEBUG
+		if (g2To.IsValid())
+		{
+			assert(!"Copying to a valid g2 instance?!");
+
+			if (g2To[0].mBoneCache)
+			{
+				assert(!"Instance has a bonecache too.. it's gonna get stomped");
+			}
+		}
+#endif
+		g2To.DeepCopy(g2From);
+
+#ifdef _G2_GORE //check through gore stuff then, as well.
+		int model = 0;
+
+		while (model < g2To.size())
+		{
+			if ( g2To[model].mGoreSetTag )
+			{
+				CGoreSet* gore = FindGoreSet ( g2To[model].mGoreSetTag );
+				assert(gore);
+				gore->mRefCount++;
+			}
+
+			model++;
+		}
+#endif
+		//G2ANIM(ghoul2From,"G2API_CopyGhoul2Instance (source)");
+		//G2ANIM(ghoul2To,"G2API_CopyGhoul2Instance (dest)");
+	}
+
+	return -1;
+}
+
+void G2API_CopySpecificG2Model(CGhoul2Info_v &ghoul2From, int modelFrom, CGhoul2Info_v &ghoul2To, int modelTo)
+{
+#if 0
+	qboolean forceReconstruct = qtrue;
+#endif //model1 was not getting reconstructed like it should for thrown sabers?
+	   //might have been a bug in the reconstruct checking which has since been
+	   //mangled and probably fixed. -rww
+
+	// have we real ghoul2 models yet?
+	if (((int)&ghoul2From) && ((int)&ghoul2To))
+	{
+		// assume we actually have a model to copy from
+		if (ghoul2From.size() > modelFrom)
+		{
+			// if we don't have enough models on the to side, resize us so we do
+			if (ghoul2To.size() <= modelTo)
+			{
+				assert (modelTo < 5);
+				ghoul2To.resize(modelTo + 1);
+#if 0
+				forceReconstruct = qtrue;
+#endif
+			}
+			// do the copy
+
+			if (ghoul2To.IsValid() && ghoul2To.size() >= modelTo)
+			{ //remove the bonecache before we stomp over this instance.
+				if (ghoul2To[modelTo].mBoneCache)
+				{
+					RemoveBoneCache(ghoul2To[modelTo].mBoneCache);
+					ghoul2To[modelTo].mBoneCache = 0;
+				}
+			}
+			ghoul2To[modelTo] = ghoul2From[modelFrom];
+
+#if 0
+			if (forceReconstruct)
+			{ //rww - we should really do this shouldn't we? If we don't mark a reconstruct after this,
+			  //and we do a GetBoltMatrix in the same frame, it doesn't reconstruct the skeleton and returns
+			  //a completely invalid matrix
+				ghoul2To[0].mSkelFrameNum = 0;
+			}
+#endif
+		}
+	}
+}
+
+// This version will automatically copy everything about this model, and make a new one if necessary.
+void G2API_DuplicateGhoul2Instance(CGhoul2Info_v &g2From, CGhoul2Info_v **g2To)
+{
+	int ignore;
+
+	if (*g2To)
+	{	// This is bad.  We only want to do this if there is not yet a to declared.
+		assert(0);
+		return;
+	}
+
+	*g2To = new CGhoul2Info_v;
+#ifdef _FULL_G2_LEAK_CHECKING
+	if (g_G2AllocServer)
+	{
+		g_G2ServerAlloc += sizeof(CGhoul2Info_v);
+	}
+	else
+	{
+		g_G2ClientAlloc += sizeof(CGhoul2Info_v);
+	}
+	g_Ghoul2Allocations += sizeof(CGhoul2Info_v);
+	G2_DEBUG_ShovePtrInTracker(*g2To);
+#endif
+	CGhoul2Info_v &ghoul2 = *(*g2To);
+
+	ignore = G2API_CopyGhoul2Instance(g2From, ghoul2, -1);
+	
+	return;
+}
+
+char *G2API_GetSurfaceName(CGhoul2Info *ghlInfo, int surfNumber)
+{
+	static char noSurface[1] = "";
+	if (G2_SetupModelPointers(ghlInfo))
+	{
+		model_t	*mod = (model_t *)ghlInfo->currentModel;
+		mdxmSurface_t		*surf = 0;
+		mdxmSurfHierarchy_t	*surfInfo = 0;
+
+#ifndef FINAL_BUILD
+		if (!mod || !mod->mdxm)
+		{
+			Com_Error(ERR_DROP, "G2API_GetSurfaceName: Bad model on instance %s.", ghlInfo->mFileName);
+		}
+#endif
+
+		//ok, I guess it's semi-valid for the user to be passing in surface > numSurfs because they don't know how many surfs a model
+		//may have.. but how did they get that surf index to begin with? Oh well.
+		if (surfNumber < 0 || surfNumber >= mod->mdxm->numSurfaces)
+		{
+			Com_Printf("G2API_GetSurfaceName: You passed in an invalid surface number (%i) for model %s.\n", surfNumber, ghlInfo->mFileName);
+			return noSurface;
+		}
+
+
+		surf = (mdxmSurface_t *)G2_FindSurface((void *)mod, surfNumber, 0);
+		if (surf)
+		{
+#ifndef FINAL_BUILD
+			if (surf->thisSurfaceIndex < 0 || surf->thisSurfaceIndex >= mod->mdxm->numSurfaces)
+			{
+				Com_Error(ERR_DROP, "G2API_GetSurfaceName: Bad surf num (%i) on surf for instance %s.", surf->thisSurfaceIndex, ghlInfo->mFileName);
+			}
+#endif
+			mdxmHierarchyOffsets_t	*surfIndexes = (mdxmHierarchyOffsets_t *)((byte *)mod->mdxm + sizeof(mdxmHeader_t));
+			surfInfo = (mdxmSurfHierarchy_t *)((byte *)surfIndexes + surfIndexes->offsets[surf->thisSurfaceIndex]);
+			return surfInfo->name;
+		}
+	}
+	return noSurface;
+}
+
+
+int	G2API_GetSurfaceIndex(CGhoul2Info *ghlInfo, const char *surfaceName)
+{
+	if (G2_SetupModelPointers(ghlInfo))
+	{
+		return G2_GetSurfaceIndex(ghlInfo, surfaceName);
+	}
+	return -1;
+}
+
+char *G2API_GetGLAName(CGhoul2Info_v &ghoul2, int modelIndex)
+{
+	if (G2_SetupModelPointers(ghoul2))
+	{
+		if (((int)&ghoul2) && (ghoul2.size() > modelIndex))
+		{
+			//model_t	*mod = R_GetModelByHandle(RE_RegisterModel(ghoul2[modelIndex].mFileName));
+			//return mod->mdxm->animName;
+
+			assert(ghoul2[modelIndex].currentModel && ghoul2[modelIndex].currentModel->mdxm);
+			return ghoul2[modelIndex].currentModel->mdxm->animName;
+		}
+	}
+	return NULL;
+}
+
+qboolean G2API_SetNewOrigin(CGhoul2Info_v &ghoul2, const int boltIndex)
+{
+	CGhoul2Info *ghlInfo = NULL;
+
+	if ((int)&ghoul2 && ghoul2.size()>0)
+	{
+		ghlInfo = &ghoul2[0];
+	}
+
+	if (G2_SetupModelPointers(ghlInfo))
+	{
+		if (boltIndex < 0)
+		{
+            char modelName[MAX_QPATH];
+			if (ghlInfo->currentModel &&
+				ghlInfo->currentModel->name &&
+				ghlInfo->currentModel->name[0])
+			{
+				strcpy(modelName, ghlInfo->currentModel->name);
+			}
+			else
+			{
+				strcpy(modelName, "None?!");
+			}
+
+			Com_Error(ERR_DROP, "Bad boltindex (%i) trying to SetNewOrigin (naughty naughty!)\nModel %s\n", boltIndex, modelName);
+		}
+
+		ghlInfo->mNewOrigin = boltIndex;
+		ghlInfo->mFlags |= GHOUL2_NEWORIGIN;
+		return qtrue;
+	}
+	return qfalse;
+}
+
+int G2API_GetBoneIndex(CGhoul2Info *ghlInfo, const char *boneName)
+{
+	if (G2_SetupModelPointers(ghlInfo))
+	{
+		return G2_Get_Bone_Index(ghlInfo, boneName);
+	}
+	return -1;
+}
+
+qboolean G2API_SaveGhoul2Models(CGhoul2Info_v &ghoul2, char **buffer, int *size)
+{
+	return G2_SaveGhoul2Models(ghoul2, buffer, size);
+}
+
+void G2API_LoadGhoul2Models(CGhoul2Info_v &ghoul2, char *buffer)
+{
+	G2_LoadGhoul2Model(ghoul2, buffer);
+}
+
+void G2API_FreeSaveBuffer(char *buffer)
+{
+	Z_Free(buffer);
+}
+
+// this is kinda sad, but I need to call the destructor in this module (exe), not the game.dll...
+//
+void G2API_LoadSaveCodeDestructGhoul2Info(CGhoul2Info_v &ghoul2)
+{
+
+#ifdef _G2_GORE
+	G2API_ClearSkinGore ( ghoul2 );
+#endif
+	ghoul2.~CGhoul2Info_v();	// so I can load junk over it then memset to 0 without orphaning
+}
+
+//see if surfs have any shader info...
+qboolean G2API_SkinlessModel(CGhoul2Info *g2)
+{
+	if (G2_SetupModelPointers(g2))
+	{
+		model_t	*mod = (model_t *)g2->currentModel;
+
+		if (mod &&
+			mod->mdxm)
+		{
+            mdxmSurfHierarchy_t	*surf;
+			int i;
+
+			surf = (mdxmSurfHierarchy_t *) ( (byte *)mod->mdxm + mod->mdxm->ofsSurfHierarchy );
+
+			for (i = 0; i < mod->mdxm->numSurfaces; i++) 
+			{
+				if (surf->shader && surf->shader[0])
+				{ //found a surface with a shader name, ok.
+                    return qfalse;
+				}
+
+  				surf = (mdxmSurfHierarchy_t *)( (byte *)surf + (int)( &((mdxmSurfHierarchy_t *)0)->childIndexes[ surf->numChildren ] ));
+			}
+		}
+	}
+
+	//found nothing.
+	return qtrue;
+}
+
+//#ifdef _SOF2
+#ifdef _G2_GORE
+void ResetGoreTag(); // put here to reduce coupling
+
+//way of seeing how many marks are on a model currently -rww
+int G2API_GetNumGoreMarks(CGhoul2Info *g2)
+{
+	if (g2->mGoreSetTag)
+	{
+		CGoreSet *goreSet = FindGoreSet(g2->mGoreSetTag);
+
+		if (goreSet)
+		{
+			return goreSet->mGoreRecords.size();
+		}
+	}
+
+	return 0;
+}
+
+void G2API_ClearSkinGore ( CGhoul2Info_v &ghoul2 )
+{
+	int i;
+
+	for (i=0; i<ghoul2.size(); i++)
+	{
+		if ( ghoul2[i].mGoreSetTag )
+		{
+			DeleteGoreSet ( ghoul2[i].mGoreSetTag );
+			ghoul2[i].mGoreSetTag = 0;
+		}
+	}
+}
+
+int G2API_Ghoul2Size ( CGhoul2Info_v &ghoul2 )
+{
+	return ghoul2.size();
+}
+
+extern int		G2_DecideTraceLod(CGhoul2Info &ghoul2, int useLod);
+void G2API_AddSkinGore(CGhoul2Info_v &ghoul2,SSkinGoreData &gore)
+{
+	if (VectorLength(gore.rayDirection)<.1f)
+	{
+		assert(0); // can't add gore without a shot direction
+		return;
+	}
+
+	// make sure we have transformed the whole skeletons for each model
+	//G2_ConstructGhoulSkeleton(ghoul2, gore.currentTime, NULL, true, gore.angles, gore.position, gore.scale, false);
+	G2_ConstructGhoulSkeleton(ghoul2, gore.currentTime, true, gore.scale);
+
+	// pre generate the world matrix - used to transform the incoming ray
+	G2_GenerateWorldMatrix(gore.angles, gore.position);
+
+	// first up, translate the ray to model space
+	vec3_t	transRayDirection, transHitLocation;
+	TransformAndTranslatePoint(gore.hitLocation, transHitLocation, &worldMatrixInv);
+	TransformPoint(gore.rayDirection, transRayDirection, &worldMatrixInv);
+
+	int lod;
+	ResetGoreTag();
+	const int lodbias=Com_Clamp ( 0, 2,G2_DecideTraceLod(ghoul2[0],r_lodbias->integer));
+	const int maxLod =Com_Clamp (0,ghoul2[0].currentModel->numLods,3);	//limit to the number of lods the main model has
+	for(lod=lodbias;lod<maxLod;lod++)
+	{
+		// now having done that, time to build the model
+		G2VertSpaceServer->ResetHeap();
+
+		G2_TransformModel(ghoul2, gore.currentTime, gore.scale,G2VertSpaceServer,lod,true);
+
+		// now walk each model and compute new texture coordinates
+		G2_TraceModels(ghoul2, transHitLocation, transRayDirection, 0, gore.entNum, 0,lod,0.0f,gore.SSize,gore.TSize,gore.theta,gore.shader,&gore);
+	}
+}
+#endif
+
+qboolean G2_TestModelPointers(CGhoul2Info *ghlInfo) // returns true if the model is properly set up
+{
+	G2ERROR(ghlInfo,"NULL ghlInfo");
+	if (!ghlInfo)
+	{
+		return qfalse;
+	}
+	ghlInfo->mValid=false;
+	if (ghlInfo->mModelindex != -1)
+	{
+		if ((com_dedicated && com_dedicated->integer) ||
+			(G2_ShouldRegisterServer())) //supreme hackery!
+		{
+			ghlInfo->mModel = RE_RegisterServerModel(ghlInfo->mFileName);
+		}
+		else
+		{
+			ghlInfo->mModel = RE_RegisterModel(ghlInfo->mFileName);
+		}
+		ghlInfo->currentModel = R_GetModelByHandle(ghlInfo->mModel);
+		if (ghlInfo->currentModel)
+		{
+			if (ghlInfo->currentModel->mdxm)
+			{
+				if (ghlInfo->currentModelSize)
+				{
+					if (ghlInfo->currentModelSize!=ghlInfo->currentModel->mdxm->ofsEnd)
+					{
+						Com_Error(ERR_DROP, "Ghoul2 model was reloaded and has changed, map must be restarted.\n");
+					}
+				}
+				ghlInfo->currentModelSize=ghlInfo->currentModel->mdxm->ofsEnd;
+				ghlInfo->animModel =  R_GetModelByHandle(ghlInfo->currentModel->mdxm->animIndex);
+				if (ghlInfo->animModel)
+				{
+					ghlInfo->aHeader =ghlInfo->animModel->mdxa;
+					if (ghlInfo->aHeader)
+					{
+						if (ghlInfo->currentAnimModelSize)
+						{
+							if (ghlInfo->currentAnimModelSize!=ghlInfo->aHeader->ofsEnd)
+							{
+								Com_Error(ERR_DROP, "Ghoul2 model was reloaded and has changed, map must be restarted.\n");
+							}
+						}
+						ghlInfo->currentAnimModelSize=ghlInfo->aHeader->ofsEnd;
+						ghlInfo->mValid=true;
+					}
+				}
+			}
+		}
+	}
+	if (!ghlInfo->mValid)
+	{
+		ghlInfo->currentModel=0;
+		ghlInfo->currentModelSize=0;
+		ghlInfo->animModel=0;
+		ghlInfo->currentAnimModelSize=0;
+		ghlInfo->aHeader=0;
+	}
+	return (qboolean)ghlInfo->mValid;
+}
+
+#ifdef G2_PERFORMANCE_ANALYSIS
+#include "../qcommon/timing.h"
+extern timing_c G2PerformanceTimer_G2_SetupModelPointers;
+extern int G2Time_G2_SetupModelPointers;
+#endif
+
+qboolean G2_SetupModelPointers(CGhoul2Info *ghlInfo) // returns true if the model is properly set up
+{
+#ifdef G2_PERFORMANCE_ANALYSIS
+	G2PerformanceTimer_G2_SetupModelPointers.Start();
+#endif
+	G2ERROR(ghlInfo,"NULL ghlInfo");
+	if (!ghlInfo)
+	{
+		return qfalse;
+	}
+
+//	if (ghlInfo->mValid && ghlInfo->currentModel)
+	if (0)
+	{ //rww - Why are we bothering with all this? We can't change models like this anyway.
+	  //This function goes over 200k on the precision timer (in debug, but still), so I'm
+	  //cutting it off here because it gets called constantly.
+#ifdef G2_PERFORMANCE_ANALYSIS
+		G2Time_G2_SetupModelPointers += G2PerformanceTimer_G2_SetupModelPointers.End();
+#endif
+		return qtrue;
+	}
+
+	ghlInfo->mValid=false;
+
+//	G2WARNING(ghlInfo->mModelindex != -1,"Setup request on non-used info slot?");
+	if (ghlInfo->mModelindex != -1)
+	{
+		G2ERROR(ghlInfo->mFileName[0],"empty ghlInfo->mFileName");
+
+		// RJ - experimental optimization!
+		if (!ghlInfo->mModel || 1)
+		{	
+			if ((com_dedicated && com_dedicated->integer) ||
+				(G2_ShouldRegisterServer())) //supreme hackery!
+			{
+				ghlInfo->mModel = RE_RegisterServerModel(ghlInfo->mFileName);
+			}
+			else
+			{
+				ghlInfo->mModel = RE_RegisterModel(ghlInfo->mFileName);
+			}
+			ghlInfo->currentModel = R_GetModelByHandle(ghlInfo->mModel);
+		}
+
+		G2ERROR(ghlInfo->currentModel,va("NULL Model (glm) %s",ghlInfo->mFileName));
+		if (ghlInfo->currentModel)
+		{
+			G2ERROR(ghlInfo->currentModel->mdxm,va("Model has no mdxm (glm) %s",ghlInfo->mFileName));
+			if (ghlInfo->currentModel->mdxm)
+			{
+				if (ghlInfo->currentModelSize)
+				{
+					if (ghlInfo->currentModelSize!=ghlInfo->currentModel->mdxm->ofsEnd)
+					{
+						Com_Error(ERR_DROP, "Ghoul2 model was reloaded and has changed, map must be restarted.\n");
+					}
+				}
+				ghlInfo->currentModelSize=ghlInfo->currentModel->mdxm->ofsEnd;
+				G2ERROR(ghlInfo->currentModelSize,va("Zero sized Model? (glm) %s",ghlInfo->mFileName));
+
+				ghlInfo->animModel =  R_GetModelByHandle(ghlInfo->currentModel->mdxm->animIndex);
+				G2ERROR(ghlInfo->animModel,va("NULL Model (gla) %s",ghlInfo->mFileName));
+				if (ghlInfo->animModel)
+				{
+					ghlInfo->aHeader =ghlInfo->animModel->mdxa;
+					G2ERROR(ghlInfo->aHeader,va("Model has no mdxa (gla) %s",ghlInfo->mFileName));
+					if (ghlInfo->aHeader)
+					{
+						if (ghlInfo->currentAnimModelSize)
+						{
+							if (ghlInfo->currentAnimModelSize!=ghlInfo->aHeader->ofsEnd)
+							{
+								Com_Error(ERR_DROP, "Ghoul2 model was reloaded and has changed, map must be restarted.\n");
+							}
+						}
+						ghlInfo->currentAnimModelSize=ghlInfo->aHeader->ofsEnd;
+						G2ERROR(ghlInfo->currentAnimModelSize,va("Zero sized Model? (gla) %s",ghlInfo->mFileName));
+						ghlInfo->mValid=true;
+					}
+				}
+			}
+		}
+	}
+	if (!ghlInfo->mValid)
+	{
+		ghlInfo->currentModel=0;
+		ghlInfo->currentModelSize=0;
+		ghlInfo->animModel=0;
+		ghlInfo->currentAnimModelSize=0;
+		ghlInfo->aHeader=0;
+	}
+
+#ifdef G2_PERFORMANCE_ANALYSIS
+	G2Time_G2_SetupModelPointers += G2PerformanceTimer_G2_SetupModelPointers.End();
+#endif
+	return (qboolean)ghlInfo->mValid;
+}
+
+qboolean G2_SetupModelPointers(CGhoul2Info_v &ghoul2) // returns true if any model is properly set up
+{
+	bool ret=false;
+	int i;
+	for (i=0; i<ghoul2.size(); i++)
+	{
+		qboolean r = G2_SetupModelPointers(&ghoul2[i]);
+		ret=ret||r;
+	}
+	return (qboolean)ret;
+}
diff --git a/codemp/ghoul2/G2_bolts.cpp b/codemp/ghoul2/G2_bolts.cpp
new file mode 100644
index 0000000..f432ff8
--- /dev/null
+++ b/codemp/ghoul2/G2_bolts.cpp
@@ -0,0 +1,331 @@
+// leave this as first line for PCH reasons...
+//
+
+
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+#if !defined(TR_LOCAL_H)
+	#include "../renderer/tr_local.h"
+#endif
+
+#if !defined(G2_H_INC)
+	#include "G2.h"
+#endif
+	#include "G2_local.h"
+
+//=====================================================================================================================
+// Bolt List handling routines - so entities can attach themselves to any part of the model in question
+
+// Given a bone number, see if that bone is already in our bone list
+int G2_Find_Bolt_Bone_Num(boltInfo_v &bltlist, const int boneNum)
+{
+	int		i;
+
+	// look through entire list
+	for(i=0; i<bltlist.size(); i++)
+	{
+		// if this bone entry has no info in it, bounce over it
+		if (bltlist[i].boneNumber == -1)
+		{
+			continue;
+		}
+
+		if (bltlist[i].boneNumber == boneNum)
+		{
+			return i;
+		}
+	}
+
+	// didn't find it
+	return -1;
+}
+
+// Given a bone number, see if that surface is already in our surfacelist list
+int G2_Find_Bolt_Surface_Num(boltInfo_v &bltlist, const int surfaceNum, const int flags)
+{
+	int		i;
+
+	// look through entire list
+	for(i=0; i<bltlist.size(); i++)
+	{
+		// if this bone entry has no info in it, bounce over it
+		if (bltlist[i].surfaceNumber == -1)
+		{
+			continue;
+		}
+
+		if ((bltlist[i].surfaceNumber == surfaceNum) && ((bltlist[i].surfaceType & flags) == flags))
+		{
+			return i;
+		}
+	}
+
+	// didn't find it
+	return -1;
+}
+			
+//=========================================================================================
+//// Public Bolt Routines
+int G2_Add_Bolt_Surf_Num(CGhoul2Info *ghlInfo, boltInfo_v &bltlist, surfaceInfo_v &slist, const int surfNum)
+{
+	assert(ghlInfo && ghlInfo->mValid);
+	boltInfo_t			tempBolt;
+	int					i;
+
+	// first up, make sure have a surface first
+	if (surfNum >= slist.size())
+	{
+		return -1;
+	}
+
+	 // look through entire list - see if it's already there first
+	for(i=0; i<bltlist.size(); i++)
+	{
+		// already there??
+		if (bltlist[i].surfaceNumber == surfNum)
+		{
+			// increment the usage count
+			bltlist[i].boltUsed++;
+			return i;
+		}
+	}
+
+	// we have a surface 
+	// look through entire list - see if it's already there first
+	for(i=0; i<bltlist.size(); i++)
+	{
+		// if this surface entry has info in it, bounce over it
+	  	if (bltlist[i].boneNumber == -1 && bltlist[i].surfaceNumber == -1)
+		{
+			// if we found an entry that had a -1 for the bone / surface number, then we hit a surface / bone slot that was empty
+			bltlist[i].surfaceNumber = surfNum;
+			bltlist[i].surfaceType = G2SURFACEFLAG_GENERATED;
+			bltlist[i].boltUsed = 1;
+	 		return i;
+		}
+	}
+	
+	// ok, we didn't find an existing surface of that name, or an empty slot. Lets add an entry
+	tempBolt.surfaceNumber = surfNum;
+	tempBolt.surfaceType = G2SURFACEFLAG_GENERATED;
+	tempBolt.boneNumber = -1;
+	tempBolt.boltUsed = 1;
+	bltlist.push_back(tempBolt);
+	return bltlist.size()-1;
+
+}
+
+int G2_Add_Bolt(CGhoul2Info *ghlInfo, boltInfo_v &bltlist, surfaceInfo_v &slist, const char *boneName)
+{
+	assert(ghlInfo && ghlInfo->mValid);
+	model_t		*mod_m = (model_t *)ghlInfo->currentModel;
+	model_t		*mod_a = (model_t *)ghlInfo->animModel;
+	int					i, x, surfNum = -1;
+	mdxaSkel_t			*skel;
+	mdxaSkelOffsets_t	*offsets;
+	mdxmHierarchyOffsets_t	*surfOffsets;
+	boltInfo_t			tempBolt;
+	int					flags;
+  
+	surfOffsets = (mdxmHierarchyOffsets_t *)((byte*)mod_m->mdxm + sizeof(mdxmHeader_t));
+	// first up, we'll search for that which this bolt names in all the surfaces
+	surfNum = G2_IsSurfaceLegal((void*)mod_m, boneName, &flags);
+
+	// did we find it as a surface?
+	if (surfNum != -1)
+	{
+		 // look through entire list - see if it's already there first
+		for(i=0; i<bltlist.size(); i++)
+		{
+			// already there??
+			if (bltlist[i].surfaceNumber == surfNum)
+			{
+				// increment the usage count
+				bltlist[i].boltUsed++;
+				return i;
+			}
+		}
+
+		 // look through entire list - see if we can re-use one
+		for(i=0; i<bltlist.size(); i++)
+		{
+			// if this surface entry has info in it, bounce over it
+		  	if (bltlist[i].boneNumber == -1 && bltlist[i].surfaceNumber == -1)
+			{
+				// if we found an entry that had a -1 for the bone / surface number, then we hit a surface / bone slot that was empty
+				bltlist[i].surfaceNumber = surfNum;
+				bltlist[i].boltUsed = 1;
+				bltlist[i].surfaceType = 0;
+		 		return i;
+			}
+		}
+	
+		// ok, we didn't find an existing surface of that name, or an empty slot. Lets add an entry
+		tempBolt.surfaceNumber = surfNum;
+		tempBolt.boneNumber = -1;
+		tempBolt.boltUsed = 1;
+		tempBolt.surfaceType = 0;
+		bltlist.push_back(tempBolt);
+		return bltlist.size()-1;
+	}
+
+	// no, check to see if it's a bone then
+
+   	offsets = (mdxaSkelOffsets_t *)((byte *)mod_a->mdxa + sizeof(mdxaHeader_t));
+
+ 	// walk the entire list of bones in the gla file for this model and see if any match the name of the bone we want to find
+ 	for (x=0; x< mod_a->mdxa->numBones; x++)
+ 	{
+ 		skel = (mdxaSkel_t *)((byte *)mod_a->mdxa + sizeof(mdxaHeader_t) + offsets->offsets[x]);
+ 		// if name is the same, we found it
+ 		if (!stricmp(skel->name, boneName))
+		{
+			break;
+		}
+	}
+
+	// check to see we did actually make a match with a bone in the model
+	if (x == mod_a->mdxa->numBones)
+	{
+		// didn't find it? Error
+		//assert(0&&x == mod_a->mdxa->numBones);
+#ifdef _DEBUG
+//		Com_Printf("WARNING: %s not found on skeleton\n", boneName);
+#endif
+		return -1;
+	}
+
+	// look through entire list - see if it's already there first
+	for(i=0; i<bltlist.size(); i++)
+	{
+		// already there??
+		if (bltlist[i].boneNumber == x)
+		{
+			// increment the usage count
+			bltlist[i].boltUsed++;
+			return i;
+		}
+	}
+
+	// look through entire list - see if we can re-use it
+	for(i=0; i<bltlist.size(); i++)
+	{
+		// if this bone entry has info in it, bounce over it
+		if (bltlist[i].boneNumber == -1 && bltlist[i].surfaceNumber == -1)
+		{
+			// if we found an entry that had a -1 for the bonenumber, then we hit a bone slot that was empty
+			bltlist[i].boneNumber = x;
+			bltlist[i].boltUsed = 1;
+			bltlist[i].surfaceType = 0;
+	 		return i;
+		}
+	}
+	
+	// ok, we didn't find an existing bone of that name, or an empty slot. Lets add an entry
+	tempBolt.boneNumber = x;
+	tempBolt.surfaceNumber = -1;
+	tempBolt.boltUsed = 1;
+ 	tempBolt.surfaceType = 0;
+	bltlist.push_back(tempBolt);
+	return bltlist.size()-1;
+
+}
+
+// Given a model handle, and a bone name, we want to remove this bone from the bone override list
+qboolean G2_Remove_Bolt (boltInfo_v &bltlist, int index)
+{
+	// did we find it?
+	if (index != -1)
+	{
+		bltlist[index].boltUsed--;
+		if (!bltlist[index].boltUsed)
+		{
+			// set this bone to not used
+			bltlist[index].boneNumber = -1;
+			bltlist[index].surfaceNumber = -1;
+
+			unsigned int newSize = bltlist.size();
+			// now look through the list from the back and see if there is a block of -1's we can resize off the end of the list
+			for (int i=bltlist.size()-1; i>-1; i--)
+			{
+				if ((bltlist[i].surfaceNumber == -1) && (bltlist[i].boneNumber == -1))
+				{
+					newSize = i;
+				}
+				// once we hit one that isn't a -1, we are done.
+				else
+				{
+					break;
+				}
+			}
+			// do we need to resize?
+			if (newSize != bltlist.size())
+			{
+				// yes, so lets do it
+				bltlist.resize(newSize);
+			}
+
+		}
+		return qtrue;
+	}
+
+	assert(0);
+
+	// no
+	return qfalse;
+}
+
+// set the bolt list to all unused so the bone transformation routine ignores it.
+void G2_Init_Bolt_List(boltInfo_v &bltlist)
+{
+	bltlist.clear();
+}
+
+// remove any bolts that reference original surfaces, generated surfaces, or bones that aren't active anymore 
+void G2_RemoveRedundantBolts(boltInfo_v &bltlist, surfaceInfo_v &slist, int *activeSurfaces, int *activeBones)
+{
+	// walk the bolt list
+	for (int i=0; i<bltlist.size(); i++)
+	{
+		// are we using this bolt?
+		if ((bltlist[i].surfaceNumber != -1) || (bltlist[i].boneNumber != -1))
+		{
+			// is this referenceing a surface?
+			if (bltlist[i].surfaceNumber != -1)
+			{
+				// is this bolt looking at a generated surface?
+				if (bltlist[i].surfaceType)
+				{
+					// yes, so look for it in the surface list
+					if (!G2_FindOverrideSurface(bltlist[i].surfaceNumber, slist))
+					{
+						// no - we want to remove this bolt, regardless of how many people are using it
+						bltlist[i].boltUsed = 1;
+						G2_Remove_Bolt(bltlist, i);
+					}
+				}
+				// no, it's an original, so look for it in the active surfaces list
+				{
+					if (!activeSurfaces[bltlist[i].surfaceNumber])
+					{
+						// no - we want to remove this bolt, regardless of how many people are using it
+						bltlist[i].boltUsed = 1;
+						G2_Remove_Bolt(bltlist, i);
+					}
+				}
+			}
+			// no, must be looking at a bone then
+			else
+			{
+				// is that bone active then?
+				if (!activeBones[bltlist[i].boneNumber])
+				{
+					// no - we want to remove this bolt, regardless of how many people are using it
+					bltlist[i].boltUsed = 1;
+					G2_Remove_Bolt(bltlist, i);
+				}
+			}
+		}
+	}
+}
diff --git a/codemp/ghoul2/G2_bones.cpp b/codemp/ghoul2/G2_bones.cpp
new file mode 100644
index 0000000..ccf1269
--- /dev/null
+++ b/codemp/ghoul2/G2_bones.cpp
@@ -0,0 +1,4905 @@
+// leave this as first line for PCH reasons...
+//
+
+
+
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+
+#if !defined(TR_LOCAL_H)
+	#include "../renderer/tr_local.h"
+#endif
+
+#include "../renderer/matcomp.h"
+
+#if !defined(G2_H_INC)
+	#include "G2.h"
+#endif
+	#include "G2_local.h"
+	 
+//rww - RAGDOLL_BEGIN
+#ifndef __linux__
+#include <float.h>
+#else
+#include <math.h>
+#define _isnan isnan
+#endif 
+#include "G2_gore.h"
+
+//#define RAG_TRACE_DEBUG_LINES
+
+#include "../client/client.h" //while this is all "shared" code, there are some places where we want to make cgame callbacks (for ragdoll) only if the cgvm exists
+//rww - RAGDOLL_END
+
+//=====================================================================================================================
+// Bone List handling routines - so entities can override bone info on a bone by bone level, and also interrogate this info
+
+// Given a bone name, see if that bone is already in our bone list - note the model_t pointer that gets passed in here MUST point at the 
+// gla file, not the glm file type.
+int G2_Find_Bone(const model_t *mod, boneInfo_v &blist, const char *boneName)
+{
+	int					i;
+	mdxaSkel_t			*skel;
+	mdxaSkelOffsets_t	*offsets;
+   	offsets = (mdxaSkelOffsets_t *)((byte *)mod->mdxa + sizeof(mdxaHeader_t));
+	skel = (mdxaSkel_t *)((byte *)mod->mdxa + sizeof(mdxaHeader_t) + offsets->offsets[0]);
+
+	// look through entire list
+	for(i=0; i<blist.size(); i++)
+	{
+		// if this bone entry has no info in it, bounce over it
+		if (blist[i].boneNumber == -1)
+		{
+			continue;
+		}
+
+		// figure out what skeletal info structure this bone entry is looking at
+		skel = (mdxaSkel_t *)((byte *)mod->mdxa + sizeof(mdxaHeader_t) + offsets->offsets[blist[i].boneNumber]);
+
+		// if name is the same, we found it
+		if (!stricmp(skel->name, boneName))
+		{
+			return i;
+		}
+	}
+
+	// didn't find it
+	return -1;
+}
+
+// we need to add a bone to the list - find a free one and see if we can find a corresponding bone in the gla file
+int G2_Add_Bone (const model_t *mod, boneInfo_v &blist, const char *boneName)
+{
+	int i, x;
+	mdxaSkel_t			*skel;
+	mdxaSkelOffsets_t	*offsets;
+	boneInfo_t			tempBone;
+
+	//rww - RAGDOLL_BEGIN
+	memset(&tempBone, 0, sizeof(tempBone));
+	//rww - RAGDOLL_END
+	
+   	offsets = (mdxaSkelOffsets_t *)((byte *)mod->mdxa + sizeof(mdxaHeader_t));
+
+ 	// walk the entire list of bones in the gla file for this model and see if any match the name of the bone we want to find
+ 	for (x=0; x< mod->mdxa->numBones; x++)
+ 	{
+ 		skel = (mdxaSkel_t *)((byte *)mod->mdxa + sizeof(mdxaHeader_t) + offsets->offsets[x]);
+ 		// if name is the same, we found it
+ 		if (!stricmp(skel->name, boneName))
+		{
+			break;
+		}
+	}
+
+	// check to see we did actually make a match with a bone in the model
+	if (x == mod->mdxa->numBones)
+	{
+		// didn't find it? Error
+		//assert(0);
+#ifdef _DEBUG
+		Com_Printf("WARNING: Failed to add bone %s\n", boneName);
+#endif
+
+#ifdef _RAG_PRINT_TEST
+		Com_Printf("WARNING: Failed to add bone %s\n", boneName);
+#endif
+		return -1;
+	}
+
+	// look through entire list - see if it's already there first
+	for(i=0; i<blist.size(); i++)
+	{
+		// if this bone entry has info in it, bounce over it
+		if (blist[i].boneNumber != -1)
+		{
+			skel = (mdxaSkel_t *)((byte *)mod->mdxa + sizeof(mdxaHeader_t) + offsets->offsets[blist[i].boneNumber]);
+			// if name is the same, we found it
+			if (!stricmp(skel->name, boneName))
+			{
+				return i;
+			}
+		}
+		else
+		{
+			// if we found an entry that had a -1 for the bonenumber, then we hit a bone slot that was empty
+			blist[i].boneNumber = x;
+			blist[i].flags = 0;
+	 		return i;
+		}
+	}
+
+#ifdef _RAG_PRINT_TEST
+	Com_Printf("New bone added for %s\n", boneName);
+#endif
+	// ok, we didn't find an existing bone of that name, or an empty slot. Lets add an entry
+	tempBone.boneNumber = x;
+	tempBone.flags = 0;
+	blist.push_back(tempBone);
+	return blist.size()-1;
+}
+
+
+// Given a model handle, and a bone name, we want to remove this bone from the bone override list
+qboolean G2_Remove_Bone_Index ( boneInfo_v &blist, int index)
+{
+	if (index != -1)
+	{
+		if (blist[index].flags & BONE_ANGLES_RAGDOLL)
+		{
+			return qtrue; // don't accept any calls on ragdoll bones
+		}
+	}
+
+	// did we find it?
+	if (index != -1)
+	{
+		// check the flags first - if it's still being used Do NOT remove it
+		if (!blist[index].flags)
+		{
+
+			// set this bone to not used
+			blist[index].boneNumber = -1;
+
+		   	unsigned int newSize = blist.size();
+			// now look through the list from the back and see if there is a block of -1's we can resize off the end of the list
+			for (int i=blist.size()-1; i>-1; i--)
+			{
+				if (blist[i].boneNumber == -1)
+				{
+					newSize = i;
+				}
+				// once we hit one that isn't a -1, we are done.
+				else
+				{
+					break;
+				}
+			}
+			// do we need to resize?
+			if (newSize != blist.size())
+			{
+				// yes, so lets do it
+				blist.resize(newSize);
+			}
+		
+			return qtrue;
+		}
+	}
+
+//	assert(0);
+	// no
+	return qfalse;
+}
+
+// given a bone number, see if there is an override bone in the bone list
+int	G2_Find_Bone_In_List(boneInfo_v &blist, const int boneNum)
+{
+	int i; 
+	
+	// look through entire list
+	for(i=0; i<blist.size(); i++)
+	{
+		if (blist[i].boneNumber == boneNum)
+		{
+			return i;
+		}
+	}
+	return -1;
+}
+
+// given a model, bonelist and bonename, lets stop an anim if it's playing.
+qboolean G2_Stop_Bone_Index( boneInfo_v &blist, int index, int flags)
+{
+	// did we find it?
+	if (index != -1)
+	{
+		blist[index].flags &= ~(flags);
+		// try and remove this bone if we can
+		return G2_Remove_Bone_Index(blist, index);
+	}
+
+	assert(0);
+
+	return qfalse;
+}
+
+// generate a matrix for a given bone given some new angles for it.
+void G2_Generate_Matrix(const model_t *mod, boneInfo_v &blist, int index, const float *angles, int flags,
+						const Eorientations up, const Eorientations left, const Eorientations forward)
+{
+	mdxaSkel_t		*skel;
+	mdxaSkelOffsets_t *offsets;
+	mdxaBone_t		temp1;
+	mdxaBone_t		permutation;
+	mdxaBone_t		*boneOverride = &blist[index].matrix;
+	vec3_t			newAngles;
+
+	if (flags & (BONE_ANGLES_PREMULT | BONE_ANGLES_POSTMULT))
+	{
+		// build us a matrix out of the angles we are fed - but swap y and z because of wacky Quake setup
+		vec3_t	newAngles;
+
+		// determine what axis newAngles Yaw should revolve around
+		switch (up)
+		{
+		case NEGATIVE_X:
+			newAngles[1] = angles[2] + 180;
+			break;
+		case POSITIVE_X:
+			newAngles[1] = angles[2];
+			break;
+		case NEGATIVE_Y:
+			newAngles[1] = angles[0];
+			break;
+		case POSITIVE_Y:
+			newAngles[1] = angles[0];
+			break;
+		case NEGATIVE_Z:
+			newAngles[1] = angles[1] + 180;
+			break;
+		case POSITIVE_Z:
+			newAngles[1] = angles[1];
+			break;
+		}
+
+		// determine what axis newAngles pitch should revolve around
+		switch (left)
+		{
+		case NEGATIVE_X:
+			newAngles[0] = angles[2];
+			break;
+		case POSITIVE_X:
+			newAngles[0] = angles[2] + 180;
+			break;
+		case NEGATIVE_Y:
+			newAngles[0] = angles[0];
+			break;
+		case POSITIVE_Y:
+			newAngles[0] = angles[0] + 180;
+			break;
+		case NEGATIVE_Z:
+			newAngles[0] = angles[1];
+			break;
+		case POSITIVE_Z:
+			newAngles[0] = angles[1];
+			break;
+		}
+
+		// determine what axis newAngles Roll should revolve around
+		switch (forward)
+		{
+		case NEGATIVE_X:
+			newAngles[2] = angles[2];
+			break;
+		case POSITIVE_X:
+			newAngles[2] = angles[2];
+			break;
+		case NEGATIVE_Y:
+			newAngles[2] = angles[0];
+			break;
+		case POSITIVE_Y:
+			newAngles[2] = angles[0] + 180;
+			break;
+		case NEGATIVE_Z:
+			newAngles[2] = angles[1];
+			break;
+		case POSITIVE_Z:
+			newAngles[2] = angles[1] + 180;
+			break;
+		}
+
+		Create_Matrix(newAngles, boneOverride);
+
+		// figure out where the bone hirearchy info is
+		offsets = (mdxaSkelOffsets_t *)((byte *)mod->mdxa + sizeof(mdxaHeader_t));
+		skel = (mdxaSkel_t *)((byte *)mod->mdxa + sizeof(mdxaHeader_t) + offsets->offsets[blist[index].boneNumber]);
+
+		Multiply_3x4Matrix(&temp1,  boneOverride,&skel->BasePoseMatInv);
+		Multiply_3x4Matrix(boneOverride,&skel->BasePoseMat, &temp1);
+	
+	}
+	else
+	{
+		VectorCopy(angles, newAngles);
+
+		// why I should need do this Fuck alone knows. But I do.
+		if (left == POSITIVE_Y)
+		{
+			newAngles[0] +=180;
+		}
+
+		Create_Matrix(newAngles, &temp1);
+
+		permutation.matrix[0][0] = permutation.matrix[0][1] = permutation.matrix[0][2] = permutation.matrix[0][3] = 0;
+		permutation.matrix[1][0] = permutation.matrix[1][1] = permutation.matrix[1][2] = permutation.matrix[1][3] = 0;
+		permutation.matrix[2][0] = permutation.matrix[2][1] = permutation.matrix[2][2] = permutation.matrix[2][3] = 0;
+
+		// determine what axis newAngles Yaw should revolve around
+		switch (forward)
+		{
+		case NEGATIVE_X:
+			permutation.matrix[0][0] = -1;		// works
+			break;
+		case POSITIVE_X:
+			permutation.matrix[0][0] = 1;		// works
+			break;
+		case NEGATIVE_Y:
+			permutation.matrix[1][0] = -1;
+			break;
+		case POSITIVE_Y:
+			permutation.matrix[1][0] = 1;
+			break;
+		case NEGATIVE_Z:
+			permutation.matrix[2][0] = -1;
+			break;
+		case POSITIVE_Z:
+			permutation.matrix[2][0] = 1;
+			break;
+		}
+
+		// determine what axis newAngles pitch should revolve around
+		switch (left)
+		{
+		case NEGATIVE_X:
+			permutation.matrix[0][1] = -1;
+			break;
+		case POSITIVE_X:
+			permutation.matrix[0][1] = 1;
+			break;
+		case NEGATIVE_Y:
+			permutation.matrix[1][1] = -1;		// works
+			break;
+		case POSITIVE_Y:
+			permutation.matrix[1][1] = 1;		// works
+			break;
+		case NEGATIVE_Z:
+			permutation.matrix[2][1] = -1;
+			break;
+		case POSITIVE_Z:
+			permutation.matrix[2][1] = 1;
+			break;
+		}
+
+		// determine what axis newAngles Roll should revolve around
+		switch (up)
+		{
+		case NEGATIVE_X:
+			permutation.matrix[0][2] = -1;
+			break;
+		case POSITIVE_X:
+			permutation.matrix[0][2] = 1;
+			break;
+		case NEGATIVE_Y:
+			permutation.matrix[1][2] = -1;
+			break;
+		case POSITIVE_Y:
+			permutation.matrix[1][2] = 1;
+			break;
+		case NEGATIVE_Z:
+			permutation.matrix[2][2] = -1;		// works
+			break;
+		case POSITIVE_Z:
+			permutation.matrix[2][2] = 1;		// works
+			break;
+		}
+
+		Multiply_3x4Matrix(boneOverride, &temp1,&permutation);
+
+	}
+
+	// keep a copy of the matrix in the newmatrix which is actually what we use
+	memcpy(&blist[index].newMatrix, &blist[index].matrix, sizeof(mdxaBone_t));
+
+}
+
+//=========================================================================================
+//// Public Bone Routines
+
+
+// Given a model handle, and a bone name, we want to remove this bone from the bone override list
+qboolean G2_Remove_Bone (CGhoul2Info *ghlInfo, boneInfo_v &blist, const char *boneName)
+{
+	int index;
+
+	assert(ghlInfo->animModel);
+	index = G2_Find_Bone(ghlInfo->animModel, blist, boneName);
+ 
+	return G2_Remove_Bone_Index(blist, index);
+}
+
+#define DEBUG_PCJ (0)
+
+
+// Given a model handle, and a bone name, we want to set angles specifically for overriding
+qboolean G2_Set_Bone_Angles_Index( boneInfo_v &blist, const int index,
+							const float *angles, const int flags, const Eorientations yaw,
+							const Eorientations pitch, const Eorientations roll, qhandle_t *modelList,
+							const int modelIndex, const int blendTime, const int currentTime)
+{
+	if ((index >= blist.size()) || (blist[index].boneNumber == -1))
+	{
+		// we are attempting to set a bone override that doesn't exist
+		assert(0);
+		return qfalse;
+	}
+
+	if (index != -1)
+	{
+		if (blist[index].flags & BONE_ANGLES_RAGDOLL)
+		{
+			return qtrue; // don't accept any calls on ragdoll bones
+		}
+	}
+	
+	if (flags & (BONE_ANGLES_PREMULT | BONE_ANGLES_POSTMULT))
+	{
+		// you CANNOT call this with an index with these kinds of bone overrides - we need the model details for these kinds of bone angle overrides
+		assert(0);
+		return qfalse;
+	}
+
+	// yes, so set the angles and flags correctly
+	blist[index].flags &= ~(BONE_ANGLES_TOTAL);
+	blist[index].flags |= flags;
+	blist[index].boneBlendStart = currentTime;
+	blist[index].boneBlendTime = blendTime;
+#if DEBUG_PCJ
+	OutputDebugString(va("PCJ %2d %6d   (%6.2f,%6.2f,%6.2f) %d %d %d %d\n",index,currentTime,angles[0],angles[1],angles[2],yaw,pitch,roll,flags));
+#endif
+
+	G2_Generate_Matrix(NULL, blist, index, angles, flags, yaw, pitch, roll);
+	return qtrue;
+
+}
+
+// Given a model handle, and a bone name, we want to set angles specifically for overriding
+qboolean G2_Set_Bone_Angles(CGhoul2Info *ghlInfo, boneInfo_v &blist, const char *boneName, const float *angles,
+							const int flags, const Eorientations up, const Eorientations left, const Eorientations forward,
+							qhandle_t *modelList, const int modelIndex, const int blendTime, const int currentTime)
+{
+	model_t		*mod_m;
+	model_t		*mod_a;
+
+	mod_m = (model_t *)ghlInfo->currentModel;
+	mod_a = (model_t *)ghlInfo->animModel;
+
+	int			index = G2_Find_Bone(mod_a, blist, boneName);
+ 
+	// did we find it?
+	if (index != -1)
+	{
+		if (blist[index].flags & BONE_ANGLES_RAGDOLL)
+		{
+			return qtrue; // don't accept any calls on ragdoll bones
+		}
+
+		// yes, so set the angles and flags correctly
+		blist[index].flags &= ~(BONE_ANGLES_TOTAL);
+		blist[index].flags |= flags;
+		blist[index].boneBlendStart = currentTime;
+		blist[index].boneBlendTime = blendTime;
+#if DEBUG_PCJ
+		OutputDebugString(va("%2d %6d   (%6.2f,%6.2f,%6.2f) %d %d %d %d\n",index,currentTime,angles[0],angles[1],angles[2],up,left,forward,flags));
+#endif
+
+		G2_Generate_Matrix(mod_a, blist, index, angles, flags, up, left, forward);
+		return qtrue;
+	}
+
+	// no - lets try and add this bone in
+	index = G2_Add_Bone(mod_a, blist, boneName);
+
+	// did we find a free one?
+	if (index != -1)
+	{
+		// yes, so set the angles and flags correctly
+		blist[index].flags &= ~(BONE_ANGLES_TOTAL);
+		blist[index].flags |= flags;
+		blist[index].boneBlendStart = currentTime;
+		blist[index].boneBlendTime = blendTime;
+#if DEBUG_PCJ
+		OutputDebugString(va("%2d %6d   (%6.2f,%6.2f,%6.2f) %d %d %d %d\n",index,currentTime,angles[0],angles[1],angles[2],up,left,forward,flags));
+#endif
+
+		G2_Generate_Matrix(mod_a, blist, index, angles, flags, up, left, forward);
+		return qtrue;
+	}
+//	assert(0);
+	//Jeese, we don't need an assert here too. There's already a warning in G2_Add_Bone if it fails.
+
+	// no
+	return qfalse;
+}
+
+// Given a model handle, and a bone name, we want to set angles specifically for overriding - using a matrix directly
+qboolean G2_Set_Bone_Angles_Matrix_Index(boneInfo_v &blist, const int index,
+								   const mdxaBone_t &matrix, const int flags, qhandle_t *modelList,
+								   const int modelIndex, const int blendTime, const int currentTime)
+{
+
+	if ((index >= blist.size()) || (blist[index].boneNumber == -1))
+	{
+		// we are attempting to set a bone override that doesn't exist
+		assert(0);
+		return qfalse;
+	}
+	if (index != -1)
+	{
+		if (blist[index].flags & BONE_ANGLES_RAGDOLL)
+		{
+			return qtrue; // don't accept any calls on ragdoll bones
+		}
+	}
+	// yes, so set the angles and flags correctly
+	blist[index].flags &= ~(BONE_ANGLES_TOTAL);
+	blist[index].flags |= flags;
+	blist[index].boneBlendStart = currentTime;
+	blist[index].boneBlendTime = blendTime;
+
+	memcpy(&blist[index].matrix, &matrix, sizeof(mdxaBone_t));
+	memcpy(&blist[index].newMatrix, &matrix, sizeof(mdxaBone_t));
+	return qtrue;
+
+}
+
+// Given a model handle, and a bone name, we want to set angles specifically for overriding - using a matrix directly
+qboolean G2_Set_Bone_Angles_Matrix(const char *fileName, boneInfo_v &blist, const char *boneName, const mdxaBone_t &matrix,
+								   const int flags, qhandle_t *modelList, const int modelIndex, const int blendTime, const int currentTime)
+{
+		model_t		*mod_m;
+	if (!fileName[0])
+	{
+		mod_m = R_GetModelByHandle(modelList[modelIndex]);
+	}
+	else
+	{
+		mod_m = R_GetModelByHandle(RE_RegisterModel(fileName));
+	}
+	model_t		*mod_a = R_GetModelByHandle(mod_m->mdxm->animIndex); 
+	int			index = G2_Find_Bone(mod_a, blist, boneName);
+ 
+	if (index != -1)
+	{
+		if (blist[index].flags & BONE_ANGLES_RAGDOLL)
+		{
+			return qtrue; // don't accept any calls on ragdoll bones
+		}
+	}
+
+	// did we find it?
+	if (index != -1)
+	{
+		// yes, so set the angles and flags correctly
+		blist[index].flags &= ~(BONE_ANGLES_TOTAL);
+		blist[index].flags |= flags;
+
+		memcpy(&blist[index].matrix, &matrix, sizeof(mdxaBone_t));
+		memcpy(&blist[index].newMatrix, &matrix, sizeof(mdxaBone_t));
+		return qtrue;
+	}
+
+	// no - lets try and add this bone in
+	index = G2_Add_Bone(mod_a, blist, boneName);
+
+	// did we find a free one?
+	if (index != -1)
+	{
+		// yes, so set the angles and flags correctly
+		blist[index].flags &= ~(BONE_ANGLES_TOTAL);
+		blist[index].flags |= flags;
+
+		memcpy(&blist[index].matrix, &matrix, sizeof(mdxaBone_t));
+		memcpy(&blist[index].newMatrix, &matrix, sizeof(mdxaBone_t));
+		return qtrue;
+	}
+	assert(0);
+
+	// no
+	return qfalse;
+}
+
+#define DEBUG_G2_TIMING (0)
+
+// given a model, bone name, a bonelist, a start/end frame number, a anim speed and some anim flags, set up or modify an existing bone entry for a new set of anims
+qboolean G2_Set_Bone_Anim_Index(
+	boneInfo_v &blist, 
+	const int index, 
+	const int startFrame, 
+	const int endFrame, 
+	const int flags, 
+	const float animSpeed, 
+	const int currentTime, 
+	const float setFrame, 
+	const int blendTime,
+	const int numFrames)
+{
+	int			modFlags = flags;
+ 
+	if ((index >= blist.size()) || (blist[index].boneNumber == -1))
+	{
+		// we are attempting to set a bone override that doesn't exist
+		assert(0);
+		return qfalse;
+	}
+
+	if (index != -1)
+	{
+		if (blist[index].flags & BONE_ANGLES_RAGDOLL)
+		{
+			return qtrue; // don't accept any calls on ragdoll bones
+		}
+	}
+
+	if (setFrame != -1)
+	{
+		assert((setFrame >= startFrame) && (setFrame <= endFrame));
+	}
+	if (flags & BONE_ANIM_BLEND)
+	{
+		float	currentFrame, animSpeed; 
+		int 	startFrame, endFrame, flags;
+		// figure out where we are now
+		if (G2_Get_Bone_Anim_Index(blist, index, currentTime, &currentFrame, &startFrame, &endFrame, &flags, &animSpeed, NULL, numFrames))
+		{
+			if (blist[index].blendStart == currentTime)	//we're replacing a blend in progress which hasn't started
+			{
+				// set the amount of time it's going to take to blend this anim with the last frame of the last one
+				blist[index].blendTime = blendTime;
+			}
+			else
+			{
+				if (animSpeed<0.0f)
+				{
+					blist[index].blendFrame = floor(currentFrame);
+					blist[index].blendLerpFrame = floor(currentFrame);
+				}
+				else
+				{
+					blist[index].blendFrame = currentFrame;
+					blist[index].blendLerpFrame = currentFrame+1;
+					
+					// cope with if the lerp frame is actually off the end of the anim
+					if (blist[index].blendFrame >= endFrame )
+					{
+						// we only want to lerp with the first frame of the anim if we are looping 
+						if (blist[index].flags & BONE_ANIM_OVERRIDE_LOOP)
+						{
+							blist[index].blendFrame = startFrame;
+						}
+						// if we intend to end this anim or freeze after this, then just keep on the last frame
+						else
+						{
+						//	assert(endFrame>0);
+							if (endFrame <= 0)
+							{
+								blist[index].blendLerpFrame = 0;
+							}
+							else
+							{
+								blist[index].blendFrame = endFrame -1;
+							}
+						}
+					}
+					
+					// cope with if the lerp frame is actually off the end of the anim
+					if (blist[index].blendLerpFrame >= endFrame )
+					{
+						// we only want to lerp with the first frame of the anim if we are looping 
+						if (blist[index].flags & BONE_ANIM_OVERRIDE_LOOP)
+						{
+							blist[index].blendLerpFrame = startFrame;
+						}
+						// if we intend to end this anim or freeze after this, then just keep on the last frame
+						else
+						{
+						//	assert(endFrame>0);
+							if (endFrame <= 0)
+							{
+								blist[index].blendLerpFrame = 0;
+							}
+							else
+							{
+								blist[index].blendLerpFrame = endFrame - 1;
+							}
+						}
+					}
+				}
+				// set the amount of time it's going to take to blend this anim with the last frame of the last one
+				blist[index].blendTime = blendTime;
+				blist[index].blendStart = currentTime;
+
+			}
+		}
+		// hmm, we weren't animating on this bone. In which case disable the blend
+		else
+		{
+			blist[index].blendFrame = blist[index].blendLerpFrame = 0;
+			blist[index].blendTime = 0;
+			modFlags &= ~(BONE_ANIM_BLEND);
+		}
+	}
+	else
+	{
+		blist[index].blendFrame = blist[index].blendLerpFrame = 0;
+		blist[index].blendTime = blist[index].blendStart = 0;
+		// we aren't blending, so remove the option to do so
+		modFlags &= ~BONE_ANIM_BLEND;
+	}
+	// yes, so set the anim data and flags correctly
+	blist[index].endFrame = endFrame;
+	blist[index].startFrame = startFrame;
+	blist[index].animSpeed = animSpeed;
+	blist[index].pauseTime = 0;
+	// start up the animation:)
+	if (setFrame != -1)
+	{
+		blist[index].lastTime = blist[index].startTime = (currentTime - (((setFrame - (float)startFrame) * 50.0)/ animSpeed));
+	}
+	else
+	{
+		blist[index].lastTime = blist[index].startTime = currentTime;
+	}
+	blist[index].flags &= ~(BONE_ANIM_TOTAL);
+	if (blist[index].flags < 0)
+	{
+		blist[index].flags = 0;
+	}
+	blist[index].flags |= modFlags;
+
+#if DEBUG_G2_TIMING
+	if (index==2)
+	{
+		const boneInfo_t &bone=blist[index];
+		char mess[1000];
+		if (bone.flags&BONE_ANIM_BLEND)
+		{
+			sprintf(mess,"sab[%2d] %5d  %5d  (%5d-%5d) %4.2f %4x   bt(%5d-%5d) %7.2f %5d\n",
+				index,
+				currentTime,
+				bone.startTime,
+				bone.startFrame,
+				bone.endFrame,
+				bone.animSpeed,
+				bone.flags,
+				bone.blendStart,
+				bone.blendStart+bone.blendTime,
+				bone.blendFrame,
+				bone.blendLerpFrame
+				);
+		}
+		else
+		{
+			sprintf(mess,"saa[%2d] %5d  %5d  (%5d-%5d) %4.2f %4x\n",
+				index,
+				currentTime,
+				bone.startTime,
+				bone.startFrame,
+				bone.endFrame,
+				bone.animSpeed,
+				bone.flags
+				);
+		}
+		OutputDebugString(mess);
+	}
+#endif
+
+	return qtrue;
+
+}
+
+// given a model, bone name, a bonelist, a start/end frame number, a anim speed and some anim flags, set up or modify an existing bone entry for a new set of anims
+qboolean G2_Set_Bone_Anim(CGhoul2Info *ghlInfo, 
+						  boneInfo_v &blist, 
+						  const char *boneName, 
+						  const int startFrame, 
+						  const int endFrame, 
+						  const int flags, 
+						  const float animSpeed, 
+						  const int currentTime, 
+						  const float setFrame, 
+						  const int blendTime)
+{
+	model_t		*mod_a = (model_t *)ghlInfo->animModel; 
+
+	int			index = G2_Find_Bone(mod_a, blist, boneName);
+	if (index == -1)
+	{
+		index = G2_Add_Bone(mod_a, blist, boneName);
+	}
+
+	if (index != -1)
+	{
+		if (blist[index].flags & BONE_ANGLES_RAGDOLL)
+		{
+			return qtrue; // don't accept any calls on ragdoll bones
+		}
+	}
+
+	if (index != -1)
+	{
+		return G2_Set_Bone_Anim_Index(blist,index,startFrame,endFrame,flags,animSpeed,currentTime,setFrame,blendTime,ghlInfo->aHeader->numFrames);
+	}
+	return qfalse;
+}
+
+qboolean G2_Get_Bone_Anim_Range(CGhoul2Info *ghlInfo, boneInfo_v &blist, const char *boneName, int *startFrame, int *endFrame)
+{
+	model_t		*mod_a = (model_t *)ghlInfo->animModel;
+	int			index = G2_Find_Bone(mod_a, blist, boneName);
+ 
+	// did we find it?
+	if (index != -1)
+	{ 
+		// are we an animating bone?
+		if (blist[index].flags & (BONE_ANIM_OVERRIDE_LOOP | BONE_ANIM_OVERRIDE))
+		{
+			*startFrame = blist[index].startFrame;
+			*endFrame = blist[index].endFrame;
+			return qtrue;
+		}
+	}
+	return qfalse;
+}
+
+// given a model, bonelist and bonename, return the current frame, startframe and endframe of the current animation
+// NOTE if we aren't running an animation, then qfalse is returned
+void G2_TimingModel(boneInfo_t &bone,int currentTime,int numFramesInFile,int &currentFrame,int &newFrame,float &lerp);
+
+qboolean G2_Get_Bone_Anim_Index( boneInfo_v &blist, const int index, const int currentTime, 
+						  float *currentFrame, int *startFrame, int *endFrame, int *flags, float *retAnimSpeed, qhandle_t *modelList, int numFrames)
+{
+  
+	// did we find it?
+	if ((index>=0) && !((index >= blist.size()) || (blist[index].boneNumber == -1)))
+	{ 
+
+		// are we an animating bone?
+		if (blist[index].flags & (BONE_ANIM_OVERRIDE_LOOP | BONE_ANIM_OVERRIDE))
+		{
+			int lcurrentFrame,newFrame;
+			float lerp;
+			G2_TimingModel(blist[index],currentTime,numFrames,lcurrentFrame,newFrame,lerp);
+
+			*currentFrame =float(lcurrentFrame)+lerp;
+			*startFrame = blist[index].startFrame;
+			*endFrame = blist[index].endFrame;
+			*flags = blist[index].flags;
+			*retAnimSpeed = blist[index].animSpeed;
+			return qtrue;
+		}
+	}
+	*startFrame=0;
+	*endFrame=1;
+	*currentFrame=0.0f;
+	*flags=0;
+	*retAnimSpeed=0.0f;
+	return qfalse;
+}
+
+// given a model, bonelist and bonename, return the current frame, startframe and endframe of the current animation
+// NOTE if we aren't running an animation, then qfalse is returned
+qboolean G2_Get_Bone_Anim(CGhoul2Info *ghlInfo, boneInfo_v &blist, const char *boneName, const int currentTime, 
+						  float *currentFrame, int *startFrame, int *endFrame, int *flags, float *retAnimSpeed, qhandle_t *modelList, int modelIndex)
+{
+	model_t		*mod_a = (model_t *)ghlInfo->animModel;
+
+	int			index = G2_Find_Bone(mod_a, blist, boneName);
+ 
+	if (index==-1)
+	{
+		index = G2_Add_Bone(mod_a, blist, boneName);
+
+		if (index == -1)
+		{
+			return qfalse;
+		}
+	}
+ 
+	assert(ghlInfo->aHeader);
+
+	if (G2_Get_Bone_Anim_Index(blist, index, currentTime, currentFrame, startFrame, endFrame, flags, retAnimSpeed, modelList, ghlInfo->aHeader->numFrames))
+	{
+		assert(*startFrame>=0&&*startFrame<ghlInfo->aHeader->numFrames);
+		assert(*endFrame>0&&*endFrame<=ghlInfo->aHeader->numFrames);
+		assert(*currentFrame>=0.0f&&((int)(*currentFrame))<ghlInfo->aHeader->numFrames);
+		return qtrue;
+	}
+
+	return qfalse;
+}
+
+// given a model, bonelist and bonename, lets pause an anim if it's playing.
+qboolean G2_Pause_Bone_Anim(CGhoul2Info *ghlInfo, boneInfo_v &blist, const char *boneName, const int currentTime)
+{
+	model_t		*mod_a = (model_t *)ghlInfo->animModel; 
+
+	int			index = G2_Find_Bone(mod_a, blist, boneName);
+ 
+	// did we find it?
+	if (index != -1)
+	{
+		// are we pausing or un pausing?
+		if (blist[index].pauseTime)
+		{
+			int		startFrame, endFrame, flags;
+			float	currentFrame, animSpeed;
+
+			// figure out what frame we are on now
+			G2_Get_Bone_Anim(ghlInfo, blist, boneName, blist[index].pauseTime, &currentFrame, &startFrame, &endFrame, &flags, &animSpeed, NULL, 0);
+			// reset start time so we are actually on this frame right now
+			G2_Set_Bone_Anim(ghlInfo, blist, boneName, startFrame, endFrame, flags, animSpeed, currentTime, currentFrame, 0);
+			// no pausing anymore
+			blist[index].pauseTime = 0;
+		}
+		// ahh, just pausing, the easy bit
+		else
+		{
+			blist[index].pauseTime = currentTime;
+		}
+		
+		return qtrue;
+	}
+	assert(0);
+
+	return qfalse;
+}
+
+qboolean	G2_IsPaused(const char *fileName, boneInfo_v &blist, const char *boneName)
+{
+  	model_t		*mod_m = R_GetModelByHandle(RE_RegisterModel(fileName)); 
+	model_t		*mod_a = R_GetModelByHandle(mod_m->mdxm->animIndex); 
+	int			index = G2_Find_Bone(mod_a, blist, boneName);
+ 
+	// did we find it?
+	if (index != -1)
+	{
+		// are we paused?
+		if (blist[index].pauseTime)
+		{
+			// yup. paused.
+			return qtrue;
+		}
+		return qfalse;
+	}
+
+	return qfalse;
+}
+
+// given a model, bonelist and bonename, lets stop an anim if it's playing.
+qboolean G2_Stop_Bone_Anim_Index(boneInfo_v &blist, const int index)
+{
+ 
+	if ((index >= blist.size()) || (blist[index].boneNumber == -1))
+	{
+		// we are attempting to set a bone override that doesn't exist
+		assert(0);
+		return qfalse;
+	}
+
+	blist[index].flags &= ~(BONE_ANIM_TOTAL);
+	// try and remove this bone if we can
+	return G2_Remove_Bone_Index(blist, index);
+}
+
+// given a model, bonelist and bonename, lets stop an anim if it's playing.
+qboolean G2_Stop_Bone_Anim(const char *fileName, boneInfo_v &blist, const char *boneName)
+{
+  	model_t		*mod_m = R_GetModelByHandle(RE_RegisterModel(fileName)); 
+	model_t		*mod_a = R_GetModelByHandle(mod_m->mdxm->animIndex); 
+	int			index = G2_Find_Bone(mod_a, blist, boneName);
+ 
+	// did we find it?
+	if (index != -1)
+	{
+		blist[index].flags &= ~(BONE_ANIM_TOTAL);
+		// try and remove this bone if we can
+		return G2_Remove_Bone_Index(blist, index);
+	}
+	assert(0);
+
+	return qfalse;
+}
+
+// given a model, bonelist and bonename, lets stop an anim if it's playing.
+qboolean G2_Stop_Bone_Angles_Index(boneInfo_v &blist, const int index)
+{
+ 
+	if ((index >= blist.size()) || (blist[index].boneNumber == -1))
+	{
+		// we are attempting to set a bone override that doesn't exist
+		assert(0);
+		return qfalse;
+	} 
+
+	blist[index].flags &= ~(BONE_ANGLES_TOTAL);
+	// try and remove this bone if we can
+	return G2_Remove_Bone_Index(blist, index);
+
+}
+
+// given a model, bonelist and bonename, lets stop an anim if it's playing.
+qboolean G2_Stop_Bone_Angles(const char *fileName, boneInfo_v &blist, const char *boneName)
+{
+  	model_t		*mod_m = R_GetModelByHandle(RE_RegisterModel(fileName)); 
+	model_t		*mod_a = R_GetModelByHandle(mod_m->mdxm->animIndex); 
+	int			index = G2_Find_Bone(mod_a, blist, boneName);
+ 
+	// did we find it?
+	if (index != -1)
+	{
+		blist[index].flags &= ~(BONE_ANGLES_TOTAL);
+		// try and remove this bone if we can
+		return G2_Remove_Bone_Index(blist, index);
+	}
+	assert(0);
+
+	return qfalse;
+}
+
+
+// actually walk the bone list and update each and every bone if we have ended an animation for them.
+void G2_Animate_Bone_List(CGhoul2Info_v &ghoul2, const int currentTime, const int index )
+{
+	int i;
+	boneInfo_v &blist = ghoul2[index].mBlist;
+
+	// look through entire list
+	for(i=0; i<blist.size(); i++)
+	{
+		// we we a valid bone override?
+		if (blist[i].boneNumber != -1)
+		{
+			// are we animating?
+			if (blist[i].flags & (BONE_ANIM_OVERRIDE_LOOP | BONE_ANIM_OVERRIDE))
+			{
+				// yes - add in animation speed to current frame
+				float	animSpeed = blist[i].animSpeed;
+				float	endFrame = (float)blist[i].endFrame ;
+				float	time = (currentTime - blist[i].startTime) / 50.0f;
+				// are we a paused anim?
+				if (blist[i].pauseTime)
+				{
+					time = (blist[i].pauseTime - blist[i].startTime) / 50.0f;
+				}
+				if (time<0.0f)
+				{
+					time=0.0f;
+				}
+				float	newFrame_g = blist[i].startFrame + (time * animSpeed);
+
+				int		animSize = endFrame - blist[i].startFrame;
+				// we are supposed to be animating right?
+				if (animSize)
+				{
+					// did we run off the end?
+					if (((animSpeed > 0.0f) && (newFrame_g > endFrame-1 )) || 
+						((animSpeed < 0.0f) && (newFrame_g < endFrame+1 )))
+					{
+						// yep - decide what to do
+						if (blist[i].flags & BONE_ANIM_OVERRIDE_LOOP)
+						{
+							// get our new animation frame back within the bounds of the animation set
+							if (animSpeed < 0.0f)
+							{
+								if (newFrame_g <= endFrame+1)
+								{
+									newFrame_g=endFrame+fmod(newFrame_g-endFrame,animSize)-animSize;
+								}
+							}
+							else
+							{
+								if (newFrame_g >= endFrame)
+								{
+									newFrame_g=endFrame+fmod(newFrame_g-endFrame,animSize)-animSize;
+								}
+							}
+							// figure out new start time
+							float frameTime =  newFrame_g - blist[i].startFrame ;
+							blist[i].startTime = currentTime - (int)((frameTime / animSpeed) * 50.0f);
+							if (blist[i].startTime>currentTime)
+							{
+								blist[i].startTime=currentTime;
+							}
+							assert(blist[i].startTime <= currentTime);
+							blist[i].lastTime = blist[i].startTime;
+						}
+						else
+						{
+							if ((blist[i].flags & BONE_ANIM_OVERRIDE_FREEZE) != BONE_ANIM_OVERRIDE_FREEZE)
+							{
+								// nope, just stop it. And remove the bone if possible
+								G2_Stop_Bone_Index(blist, i, (BONE_ANIM_TOTAL));
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+//rww - RAGDOLL_BEGIN
+/*
+
+
+  rag stuff
+
+*/
+static void G2_RagDollSolve(CGhoul2Info_v &ghoul2V,int g2Index,float decay,int frameNum,const vec3_t currentOrg,bool LimitAngles,CRagDollUpdateParams *params = NULL);
+static void G2_RagDollCurrentPosition(CGhoul2Info_v &ghoul2V,int g2Index,int frameNum,const vec3_t angles,const vec3_t position,const vec3_t scale);
+static bool G2_RagDollSettlePositionNumeroTrois(CGhoul2Info_v &ghoul2V,const vec3_t currentOrg,CRagDollUpdateParams *params, int curTime);
+static bool G2_RagDollSetup(CGhoul2Info &ghoul2,int frameNum,bool resetOrigin,const vec3_t origin,bool anyRendered);
+
+void G2_GetBoneBasepose(CGhoul2Info &ghoul2,int boneNum,mdxaBone_t *&retBasepose,mdxaBone_t *&retBaseposeInv);
+int G2_GetBoneDependents(CGhoul2Info &ghoul2,int boneNum,int *tempDependents,int maxDep);
+void G2_GetBoneMatrixLow(CGhoul2Info &ghoul2,int boneNum,const vec3_t scale,mdxaBone_t &retMatrix,mdxaBone_t *&retBasepose,mdxaBone_t *&retBaseposeInv);
+int G2_GetParentBoneMatrixLow(CGhoul2Info &ghoul2,int boneNum,const vec3_t scale,mdxaBone_t &retMatrix,mdxaBone_t *&retBasepose,mdxaBone_t *&retBaseposeInv);
+bool G2_WasBoneRendered(CGhoul2Info &ghoul2,int boneNum);
+
+#define MAX_BONES_RAG (256)
+
+struct SRagEffector
+{
+	vec3_t		currentOrigin;
+	vec3_t		desiredDirection;
+	vec3_t		desiredOrigin;
+	float		radius;
+	float		weight;
+};
+
+#define RAG_MASK (CONTENTS_SOLID|CONTENTS_TERRAIN)//|CONTENTS_SHOTCLIP|CONTENTS_TERRAIN//(/*MASK_SOLID|*/CONTENTS_SOLID|CONTENTS_PLAYERCLIP|CONTENTS_SHOTCLIP|CONTENTS_TERRAIN|CONTENTS_BODY)
+
+extern cvar_t	*broadsword;
+extern cvar_t	*broadsword_kickbones;
+extern cvar_t	*broadsword_kickorigin;
+extern cvar_t	*broadsword_dontstopanim;
+extern cvar_t	*broadsword_waitforshot;
+extern cvar_t	*broadsword_playflop;
+
+extern cvar_t	*broadsword_effcorr;
+
+extern cvar_t	*broadsword_ragtobase;
+
+extern cvar_t	*broadsword_dircap;
+
+extern cvar_t	*broadsword_extra1;
+extern cvar_t	*broadsword_extra2;
+
+#define RAG_PCJ						(0x00001)
+#define RAG_PCJ_POST_MULT			(0x00002)	// has the pcj flag as well
+#define RAG_PCJ_MODEL_ROOT			(0x00004)	// has the pcj flag as well
+#define RAG_PCJ_PELVIS				(0x00008)	// has the pcj flag and POST_MULT as well
+#define RAG_EFFECTOR				(0x00100)
+#define RAG_WAS_NOT_RENDERED		(0x01000)		// not particularily reliable, more of a hint
+#define RAG_WAS_EVER_RENDERED		(0x02000)		// not particularily reliable, more of a hint
+#define RAG_BONE_LIGHTWEIGHT		(0x04000)		//used to indicate a bone's velocity treatment
+#define RAG_PCJ_IK_CONTROLLED		(0x08000)		//controlled from IK move input
+#define RAG_UNSNAPPABLE				(0x10000)		//cannot be broken out of constraints ever
+
+// thiese flags are on the model and correspond to...
+//#define		GHOUL2_RESERVED_FOR_RAGDOLL 0x0ff0  // these are not defined here for dependecies sake
+#define		GHOUL2_RAG_STARTED						0x0010  // we are actually a ragdoll
+#define		GHOUL2_RAG_PENDING						0x0100  // got start death anim but not end death anim
+#define		GHOUL2_RAG_DONE							0x0200		// got end death anim
+#define		GHOUL2_RAG_COLLISION_DURING_DEATH		0x0400		// ever have gotten a collision (da) event
+#define		GHOUL2_RAG_COLLISION_SLIDE				0x0800		// ever have gotten a collision (slide) event
+#define		GHOUL2_RAG_FORCESOLVE					0x1000		//api-override, determine if ragdoll should be forced to continue solving even if it thinks it is settled
+
+//#define flrand	Q_flrand
+
+static mdxaBone_t*		ragBasepose[MAX_BONES_RAG];
+static mdxaBone_t*		ragBaseposeInv[MAX_BONES_RAG];
+static mdxaBone_t		ragBones[MAX_BONES_RAG];
+static SRagEffector		ragEffectors[MAX_BONES_RAG];
+static boneInfo_t		*ragBoneData[MAX_BONES_RAG];
+static int				tempDependents[MAX_BONES_RAG];
+static int				ragBlistIndex[MAX_BONES_RAG];
+static int				numRags;
+static vec3_t			ragBoneMins;
+static vec3_t			ragBoneMaxs;
+static vec3_t			ragBoneCM;
+static bool				haveDesiredPelvisOffset=false;
+static vec3_t			desiredPelvisOffset; // this is for the root
+static float			ragOriginChange=0.0f;
+static vec3_t			ragOriginChangeDir;
+//debug
+static vec3_t			handPos={0,0,0};
+static vec3_t			handPos2={0,0,0};
+
+enum ERagState
+{
+	ERS_DYNAMIC,
+	ERS_SETTLING,
+	ERS_SETTLED
+};
+static int				ragState;
+
+static vector<boneInfo_t *>		rag;  // once we get the dependents precomputed this can be local
+
+
+static void G2_Generate_MatrixRag(
+			// caution this must not be called before the whole skeleton is "remembered"
+	boneInfo_v			&blist, 
+	int					index)
+{
+
+
+	boneInfo_t &bone=blist[index];//.sent;
+
+	memcpy(&bone.matrix,&bone.ragOverrideMatrix, sizeof(mdxaBone_t));
+#ifdef _DEBUG
+	int i,j;
+	for (i = 0; i < 3; i++ )
+	{
+		for (j = 0; j < 4; j++ )
+		{
+			assert( !_isnan(bone.matrix.matrix[i][j]));
+		}
+	}
+#endif// _DEBUG
+	memcpy(&blist[index].newMatrix,&bone.matrix, sizeof(mdxaBone_t));
+}
+
+int G2_Find_Bone_Rag(CGhoul2Info *ghlInfo, boneInfo_v &blist, const char *boneName)
+{
+	int					i;
+	mdxaSkel_t			*skel;
+	mdxaSkelOffsets_t	*offsets;
+
+   	offsets = (mdxaSkelOffsets_t *)((byte *)ghlInfo->aHeader + sizeof(mdxaHeader_t));
+	skel = (mdxaSkel_t *)((byte *)ghlInfo->aHeader + sizeof(mdxaHeader_t) + offsets->offsets[0]);
+
+	/*
+	model_t			*currentModel;
+	model_t			*animModel;
+	mdxaHeader_t	*aHeader;
+
+	currentModel = R_GetModelByHandle(RE_RegisterModel(ghlInfo->mFileName));
+	assert(currentModel);
+	animModel =  R_GetModelByHandle(currentModel->mdxm->animIndex);
+	assert(animModel);
+	aHeader = animModel->mdxa;
+	assert(aHeader);
+
+   	offsets = (mdxaSkelOffsets_t *)((byte *)aHeader + sizeof(mdxaHeader_t));
+	skel = (mdxaSkel_t *)((byte *)aHeader + sizeof(mdxaHeader_t) + offsets->offsets[0]);
+	*/
+
+	// look through entire list
+	for(i=0; i<blist.size(); i++)
+	{
+		// if this bone entry has no info in it, bounce over it
+		if (blist[i].boneNumber == -1)
+		{
+			continue;
+		}
+
+		// figure out what skeletal info structure this bone entry is looking at
+		skel = (mdxaSkel_t *)((byte *)ghlInfo->aHeader + sizeof(mdxaHeader_t) + offsets->offsets[blist[i].boneNumber]);
+		//skel = (mdxaSkel_t *)((byte *)aHeader + sizeof(mdxaHeader_t) + offsets->offsets[blist[i].boneNumber]);
+
+		// if name is the same, we found it
+		if (!stricmp(skel->name, boneName))
+		{
+			return i;
+		}
+	}
+#if _DEBUG
+//	G2_Bone_Not_Found(boneName,ghlInfo->mFileName);
+#endif	
+	// didn't find it
+	return -1;
+}
+
+static int G2_Set_Bone_Rag(const mdxaHeader_t *mod_a,
+	boneInfo_v &blist, 
+	const char *boneName,
+	CGhoul2Info &ghoul2,
+	const vec3_t scale,
+	const vec3_t origin)
+{
+	// do not change the state of the skeleton here
+	int	index = G2_Find_Bone_Rag(&ghoul2, blist, boneName);
+
+	if (index == -1)
+	{
+		index = G2_Add_Bone(ghoul2.animModel, blist, boneName);
+	}
+
+	if (index != -1)
+	{
+		boneInfo_t &bone=blist[index];
+		VectorCopy(origin,bone.extraVec1);
+
+		G2_GetBoneMatrixLow(ghoul2,bone.boneNumber,scale,bone.originalTrueBoneMatrix,bone.basepose,bone.baseposeInv);
+//		bone.parentRawBoneIndex=G2_GetParentBoneMatrixLow(ghoul2,bone.boneNumber,scale,bone.parentTrueBoneMatrix,bone.baseposeParent,bone.baseposeInvParent);
+		assert( !_isnan(bone.originalTrueBoneMatrix.matrix[1][1]));
+		assert( !_isnan(bone.originalTrueBoneMatrix.matrix[1][3]));
+		bone.originalOrigin[0]=bone.originalTrueBoneMatrix.matrix[0][3];
+		bone.originalOrigin[1]=bone.originalTrueBoneMatrix.matrix[1][3];
+		bone.originalOrigin[2]=bone.originalTrueBoneMatrix.matrix[2][3];
+	}
+	return index;
+}
+
+static int G2_Set_Bone_Angles_Rag(
+	CGhoul2Info &ghoul2,
+	const mdxaHeader_t *mod_a,
+	boneInfo_v &blist, 
+	const char *boneName,
+	const int flags,
+	const float radius,
+	const vec3_t angleMin=0,
+	const vec3_t angleMax=0,
+	const int blendTime=500)
+{
+	int			index = G2_Find_Bone_Rag(&ghoul2, blist, boneName);
+
+	if (index == -1)
+	{
+		index = G2_Add_Bone(ghoul2.animModel, blist, boneName);
+	}
+	if (index != -1)
+	{
+		boneInfo_t &bone=blist[index];
+		bone.flags &= ~(BONE_ANGLES_TOTAL);
+		bone.flags |= BONE_ANGLES_RAGDOLL;
+		if (flags&RAG_PCJ)
+		{
+			if (flags&RAG_PCJ_POST_MULT)
+			{
+				bone.flags |= BONE_ANGLES_POSTMULT;
+			}
+			else if (flags&RAG_PCJ_MODEL_ROOT)
+			{
+				bone.flags |= BONE_ANGLES_PREMULT;
+//				bone.flags |= BONE_ANGLES_POSTMULT;
+			}
+			else
+			{
+				assert(!"Invalid RAG PCJ\n");
+			}
+		}
+		bone.ragStartTime=G2API_GetTime(0);
+		bone.boneBlendStart = bone.ragStartTime;
+		bone.boneBlendTime = blendTime;
+		bone.radius=radius;
+		bone.weight=1.0f;
+
+		//init the others to valid values
+		bone.epGravFactor = 0;
+		VectorClear(bone.epVelocity);
+		bone.solidCount = 0;
+		bone.physicsSettled = false;
+		bone.snapped = false;
+
+		bone.parentBoneIndex = -1;
+
+		bone.offsetRotation = 0.0f;
+
+		bone.overGradSpeed = 0.0f;
+		VectorClear(bone.overGoalSpot);
+		bone.hasOverGoal = false;
+		bone.hasAnimFrameMatrix = -1;
+
+//		bone.weight=pow(radius,1.7f); //cubed was too harsh
+//		bone.weight=radius*radius*radius;
+		if (angleMin&&angleMax)
+		{
+			VectorCopy(angleMin,bone.minAngles);
+			VectorCopy(angleMax,bone.maxAngles);
+		}
+		else
+		{
+			VectorCopy(bone.currentAngles,bone.minAngles); // I guess this isn't a rag pcj then
+			VectorCopy(bone.currentAngles,bone.maxAngles);
+		}
+		if (!bone.lastTimeUpdated)
+		{
+			static mdxaBone_t		id = 
+			{ 
+				1.0f, 0.0f, 0.0f, 0.0f,
+				0.0f, 1.0f, 0.0f, 0.0f,
+				0.0f, 0.0f, 1.0f, 0.0f
+			};
+			memcpy(&bone.ragOverrideMatrix,&id, sizeof(mdxaBone_t));
+			VectorClear(bone.anglesOffset);
+			VectorClear(bone.positionOffset);
+			VectorClear(bone.velocityEffector);  // this is actually a velocity now
+			VectorClear(bone.velocityRoot);  // this is actually a velocity now
+			VectorClear(bone.lastPosition);
+			VectorClear(bone.lastShotDir);
+			bone.lastContents=0;
+			// if this is non-zero, we are in a dynamic state
+			bone.firstCollisionTime=bone.ragStartTime;
+			// if this is non-zero, we are in a settling state
+			bone.restTime=0;
+			// if they are both zero, we are in a settled state
+
+			bone.firstTime=0;
+
+			bone.RagFlags=flags;
+			bone.DependentRagIndexMask=0;
+
+			G2_Generate_MatrixRag(blist,index); // set everything to th id
+
+#if 0
+			VectorClear(bone.currentAngles);
+//			VectorAdd(bone.minAngles,bone.maxAngles,bone.currentAngles);
+//			VectorScale(bone.currentAngles,0.5f,bone.currentAngles);
+#else
+			{
+				if (
+					(flags&RAG_PCJ_MODEL_ROOT) ||
+					(flags&RAG_PCJ_PELVIS) ||
+					!(flags&RAG_PCJ))
+				{
+					VectorClear(bone.currentAngles);
+				}
+				else
+				{
+					int k;
+					for (k=0;k<3;k++)
+					{
+						float scalar=flrand(-1.0f,1.0f);
+						scalar*=flrand(-1.0f,1.0f)*flrand(-1.0f,1.0f);
+						// this is a heavily central distribution
+						// center it on .5 (and make it small)
+						scalar*=0.5f;
+						scalar+=0.5f;
+
+						bone.currentAngles[k]=(bone.minAngles[k]-bone.maxAngles[k])*scalar+bone.maxAngles[k];
+					}
+				}
+			}
+//			VectorClear(bone.currentAngles);
+#endif
+			VectorCopy(bone.currentAngles,bone.lastAngles);
+		}
+	}
+	return index;
+}
+
+class CRagDollParams;
+const mdxaHeader_t *G2_GetModA(CGhoul2Info &ghoul2);
+
+
+static void G2_RagDollMatchPosition()
+{
+	haveDesiredPelvisOffset=false;
+	int i;
+	for (i=0;i<numRags;i++)
+	{
+		boneInfo_t &bone=*ragBoneData[i];
+		SRagEffector &e=ragEffectors[i];
+
+		vec3_t &desiredPos=e.desiredOrigin; // we will save this
+
+		if (0&&(bone.RagFlags & RAG_PCJ_PELVIS))
+		{
+			// just move to quake origin
+			VectorCopy(bone.originalOrigin,desiredPos);
+			VectorSubtract(desiredPos,e.currentOrigin,desiredPelvisOffset); // last arg is dest
+			haveDesiredPelvisOffset=true;
+			VectorCopy(e.currentOrigin,bone.lastPosition); // last arg is dest
+			continue; 
+		}
+
+		if (!(bone.RagFlags & RAG_EFFECTOR))
+		{
+			continue; 
+		}
+		VectorCopy(bone.originalOrigin,desiredPos);
+		VectorSubtract(desiredPos,e.currentOrigin,e.desiredDirection);
+		VectorCopy(e.currentOrigin,bone.lastPosition); // last arg is dest
+	}
+}
+
+qboolean G2_Set_Bone_Anim_No_BS(CGhoul2Info &ghoul2, const mdxaHeader_t *mod,boneInfo_v &blist, const char *boneName, const int argStartFrame,
+						  const int argEndFrame, const int flags, const float animSpeed, const int currentTime, const float setFrame,
+						  const int blendTime, const int creationID, bool resetBonemap=true)
+{
+	int			index = G2_Find_Bone_Rag(&ghoul2, blist, boneName);
+	int			modFlags = flags;
+
+	int startFrame=argStartFrame;
+	int endFrame=argEndFrame;
+
+	if (index != -1)
+	{
+		blist[index].blendFrame = blist[index].blendLerpFrame = 0;
+		blist[index].blendTime = blist[index].blendStart = 0;
+		modFlags &= ~(BONE_ANIM_BLEND);
+
+		blist[index].endFrame = endFrame;
+		blist[index].startFrame = startFrame;
+		blist[index].animSpeed = animSpeed;
+		blist[index].pauseTime = 0;
+//		blist[index].boneMap = NULL;
+//		blist[index].lastTime = blist[index].startTime = (currentTime - (((setFrame - (float)startFrame) * 50.0)/ animSpeed));
+		blist[index].flags &= ~(BONE_ANIM_TOTAL);
+		blist[index].flags |= modFlags;
+
+		return qtrue;
+	}
+	
+	index = G2_Add_Bone(ghoul2.animModel, blist, boneName);
+
+	if (index != -1)
+	{
+		blist[index].blendFrame = blist[index].blendLerpFrame = 0;
+		blist[index].blendTime = 0;
+		modFlags &= ~(BONE_ANIM_BLEND);
+		blist[index].endFrame = endFrame;
+		blist[index].startFrame = startFrame;
+		blist[index].animSpeed = animSpeed;
+		blist[index].pauseTime = 0;
+//		blist[index].boneMap = NULL;
+//		blist[index].lastTime = blist[index].startTime = (currentTime - (((setFrame - (float)startFrame) * 50.0f)/ animSpeed));
+		blist[index].flags &= ~(BONE_ANIM_TOTAL);
+		blist[index].flags |= modFlags;
+
+		return qtrue;
+	}
+
+	assert(0);
+	return qfalse;
+}
+
+void G2_ResetRagDoll(CGhoul2Info_v &ghoul2V)
+{
+	int model;
+
+	for (model = 0; model < ghoul2V.size(); model++)
+	{
+		if (ghoul2V[model].mModelindex != -1)
+		{
+			break;
+		}
+	}
+	
+	if (model == ghoul2V.size())
+	{
+		return;
+	}
+
+	CGhoul2Info &ghoul2 = ghoul2V[model];
+
+	if (!(ghoul2.mFlags & GHOUL2_RAG_STARTED))
+	{ //no use in doing anything if we aren't ragging
+		return;
+	}
+
+	boneInfo_v &blist = ghoul2.mBlist;
+#if 1
+	//Eh, screw it. Ragdoll does a lot of terrible things to the bones that probably aren't directly reversible, so just reset it all.
+	G2_Init_Bone_List(blist);
+#else //The anims on every bone are messed up too, as are the angles. There's not really any way to get back to a normal state, so just clear the list
+	  //and let them re-set their anims/angles gameside.
+	int i = 0;
+	while (i < blist.size())
+	{
+		boneInfo_t &bone = blist[i];
+		if (bone.boneNumber != -1 && (bone.flags & BONE_ANGLES_RAGDOLL))
+		{
+			bone.flags &= ~BONE_ANGLES_RAGDOLL;
+			bone.flags &= ~BONE_ANGLES_IK;
+			bone.RagFlags = 0;
+			bone.lastTimeUpdated = 0;
+			VectorClear(bone.currentAngles);
+			bone.ragStartTime = 0;
+		}
+		i++;
+	}
+#endif
+	ghoul2.mFlags &= ~(GHOUL2_RAG_PENDING|GHOUL2_RAG_DONE|GHOUL2_RAG_STARTED);
+}
+
+void G2_SetRagDoll(CGhoul2Info_v &ghoul2V,CRagDollParams *parms)
+{
+	if (parms)
+	{
+		parms->CallRagDollBegin=qfalse;
+	}
+	if (!broadsword||!broadsword->integer||!parms)
+	{
+		return;
+	}
+	int model;
+	for (model = 0; model < ghoul2V.size(); model++)
+	{
+		if (ghoul2V[model].mModelindex != -1)
+		{
+			break;
+		}
+	}
+	if (model==ghoul2V.size())
+	{
+		return;
+	}
+	CGhoul2Info &ghoul2=ghoul2V[model];
+	const mdxaHeader_t *mod_a=G2_GetModA(ghoul2);
+	if (!mod_a)
+	{
+		return;
+	}
+	int curTime=G2API_GetTime(0);
+	boneInfo_v &blist = ghoul2.mBlist;
+	int	index = G2_Find_Bone_Rag(&ghoul2, blist, "model_root");
+#ifndef DEDICATED
+	switch (parms->RagPhase)
+	{
+	case CRagDollParams::ERagPhase::RP_START_DEATH_ANIM:
+		ghoul2.mFlags|=GHOUL2_RAG_PENDING;
+		return;  /// not doing anything with this yet
+		break;
+	case CRagDollParams::ERagPhase::RP_END_DEATH_ANIM:
+		ghoul2.mFlags|=GHOUL2_RAG_PENDING|GHOUL2_RAG_DONE;
+		if (broadsword_waitforshot &&
+			broadsword_waitforshot->integer)
+		{
+			if (broadsword_waitforshot->integer==2)
+			{
+				if (!(ghoul2.mFlags&(GHOUL2_RAG_COLLISION_DURING_DEATH|GHOUL2_RAG_COLLISION_SLIDE)))
+				{
+					//nothing was encountered, lets just wait for the first shot
+					return; // we ain't starting yet
+				}
+			}
+			else
+			{
+				return; // we ain't starting yet
+			}
+		}
+		break;
+	case CRagDollParams::ERagPhase::RP_DEATH_COLLISION:
+		if (parms->collisionType)
+		{
+			ghoul2.mFlags|=GHOUL2_RAG_COLLISION_SLIDE;
+		}
+		else
+		{
+			ghoul2.mFlags|=GHOUL2_RAG_COLLISION_DURING_DEATH;
+		}
+		if (broadsword_dontstopanim && broadsword_waitforshot &&
+			(broadsword_dontstopanim->integer || broadsword_waitforshot->integer)
+			)
+		{
+			if (!(ghoul2.mFlags&GHOUL2_RAG_DONE))
+			{
+				return; // we ain't starting yet
+			}
+		}
+		break;
+	case CRagDollParams::ERagPhase::RP_CORPSE_SHOT:
+		if (broadsword_kickorigin &&
+			broadsword_kickorigin->integer)
+		{
+			if (index>=0&&index<blist.size())
+			{
+				boneInfo_t &bone=blist[index];
+				if (bone.boneNumber>=0)
+				{
+					if (bone.flags & BONE_ANGLES_RAGDOLL)
+					{
+						//rww - Would need ent pointer here. But.. since this is SW, we aren't even having corpse shooting anyway I'd imagine.
+						/*
+						float magicFactor14=8.0f; //64.0f; // kick strength
+
+						if (parms->fShotStrength)
+						{ //if there is a shot strength, use it instead
+							magicFactor14 = parms->fShotStrength;
+						}
+
+						parms->me->s.pos.trType = TR_GRAVITY;
+						parms->me->s.pos.trDelta[0] += bone.lastShotDir[0]*magicFactor14;
+						parms->me->s.pos.trDelta[1] += bone.lastShotDir[1]*magicFactor14;
+						//parms->me->s.pos.trDelta[2] = fabsf(bone.lastShotDir[2])*magicFactor14;
+						//rww - The vertical portion of this doesn't seem to work very well
+						//I am just leaving it whatever it is for now, because my velocity scaling
+						//only works on x and y and the gravity stuff for NPCs is a bit unpleasent
+						//trying to change/work with
+						assert( !_isnan(bone.lastShotDir[1]));
+						*/
+					}
+				}
+			}
+		}
+		break;
+	case CRagDollParams::ERagPhase::RP_GET_PELVIS_OFFSET:
+		if (parms->RagPhase==CRagDollParams::ERagPhase::RP_GET_PELVIS_OFFSET)
+		{
+			VectorClear(parms->pelvisAnglesOffset);
+			VectorClear(parms->pelvisPositionOffset);
+		}
+		// intentional lack of a break
+	case CRagDollParams::ERagPhase::RP_SET_PELVIS_OFFSET:
+		if (index>=0&&index<blist.size())
+		{
+			boneInfo_t &bone=blist[index];
+			if (bone.boneNumber>=0)
+			{
+				if (bone.flags & BONE_ANGLES_RAGDOLL)
+				{
+					if (parms->RagPhase==CRagDollParams::ERagPhase::RP_GET_PELVIS_OFFSET)
+					{
+						VectorCopy(bone.anglesOffset,parms->pelvisAnglesOffset);
+						VectorCopy(bone.positionOffset,parms->pelvisPositionOffset);
+					}
+					else
+					{
+						VectorCopy(parms->pelvisAnglesOffset,bone.anglesOffset);
+						VectorCopy(parms->pelvisPositionOffset,bone.positionOffset);
+					}
+				}
+			}
+		}
+		return;
+		break;
+	case CRagDollParams::ERagPhase::RP_DISABLE_EFFECTORS:
+		// not doing anything with this yet
+		return;
+		break;
+	default:
+		assert(0);
+		return;
+		break;
+	}
+#endif  //!DEDICATED
+	if (ghoul2.mFlags&GHOUL2_RAG_STARTED)
+	{
+		// only going to begin ragdoll once, everything else depends on what happens to the origin
+		return;
+	}
+#if 0
+if (index>=0)
+{
+	OutputDebugString(va("death %d %d\n",blist[index].startFrame,blist[index].endFrame));
+}
+#endif
+
+	ghoul2.mFlags|=GHOUL2_RAG_PENDING|GHOUL2_RAG_DONE|GHOUL2_RAG_STARTED;  // well anyway we are going live
+	parms->CallRagDollBegin=qtrue;
+
+	G2_GenerateWorldMatrix(parms->angles, parms->position);
+	G2_ConstructGhoulSkeleton(ghoul2V, curTime, false, parms->scale);
+
+	G2_Set_Bone_Rag(mod_a,blist,"model_root",ghoul2,parms->scale,parms->position);
+	G2_Set_Bone_Rag(mod_a,blist,"pelvis",ghoul2,parms->scale,parms->position);
+
+	G2_Set_Bone_Rag(mod_a,blist,"lower_lumbar",ghoul2,parms->scale,parms->position);
+	G2_Set_Bone_Rag(mod_a,blist,"upper_lumbar",ghoul2,parms->scale,parms->position);
+	G2_Set_Bone_Rag(mod_a,blist,"thoracic",ghoul2,parms->scale,parms->position);
+	G2_Set_Bone_Rag(mod_a,blist,"cranium",ghoul2,parms->scale,parms->position);
+	G2_Set_Bone_Rag(mod_a,blist,"rhumerus",ghoul2,parms->scale,parms->position);
+	G2_Set_Bone_Rag(mod_a,blist,"lhumerus",ghoul2,parms->scale,parms->position);
+	G2_Set_Bone_Rag(mod_a,blist,"rradius",ghoul2,parms->scale,parms->position);
+	G2_Set_Bone_Rag(mod_a,blist,"lradius",ghoul2,parms->scale,parms->position);
+	G2_Set_Bone_Rag(mod_a,blist,"rfemurYZ",ghoul2,parms->scale,parms->position);
+	G2_Set_Bone_Rag(mod_a,blist,"lfemurYZ",ghoul2,parms->scale,parms->position);
+	G2_Set_Bone_Rag(mod_a,blist,"rtibia",ghoul2,parms->scale,parms->position);
+	G2_Set_Bone_Rag(mod_a,blist,"ltibia",ghoul2,parms->scale,parms->position);
+	G2_Set_Bone_Rag(mod_a,blist,"rhand",ghoul2,parms->scale,parms->position);
+	G2_Set_Bone_Rag(mod_a,blist,"lhand",ghoul2,parms->scale,parms->position);
+	//G2_Set_Bone_Rag(mod_a,blist,"rtarsal",ghoul2,parms->scale,parms->position);
+	//G2_Set_Bone_Rag(mod_a,blist,"ltarsal",ghoul2,parms->scale,parms->position);
+	G2_Set_Bone_Rag(mod_a,blist,"rtalus",ghoul2,parms->scale,parms->position);
+	G2_Set_Bone_Rag(mod_a,blist,"ltalus",ghoul2,parms->scale,parms->position);
+	G2_Set_Bone_Rag(mod_a,blist,"rradiusX",ghoul2,parms->scale,parms->position);
+	G2_Set_Bone_Rag(mod_a,blist,"lradiusX",ghoul2,parms->scale,parms->position);
+	G2_Set_Bone_Rag(mod_a,blist,"rfemurX",ghoul2,parms->scale,parms->position);
+	G2_Set_Bone_Rag(mod_a,blist,"lfemurX",ghoul2,parms->scale,parms->position);
+	G2_Set_Bone_Rag(mod_a,blist,"ceyebrow",ghoul2,parms->scale,parms->position);
+
+	//int startFrame = 3665, endFrame = 3665+1;
+	int startFrame = parms->startFrame, endFrame = parms->endFrame;
+
+	G2_Set_Bone_Anim_No_BS(ghoul2, mod_a,blist,"upper_lumbar",startFrame,endFrame-1,
+		BONE_ANIM_OVERRIDE_FREEZE|BONE_ANIM_BLEND,
+		1.0f,curTime,float(startFrame),150,0,true);
+	G2_Set_Bone_Anim_No_BS(ghoul2, mod_a,blist,"lower_lumbar",startFrame,endFrame-1,
+		BONE_ANIM_OVERRIDE_FREEZE|BONE_ANIM_BLEND,
+		1.0f,curTime,float(startFrame),150,0,true);
+	G2_Set_Bone_Anim_No_BS(ghoul2, mod_a,blist,"Motion",startFrame,endFrame-1,
+		BONE_ANIM_OVERRIDE_FREEZE|BONE_ANIM_BLEND,
+		1.0f,curTime,float(startFrame),150,0,true);
+//	G2_Set_Bone_Anim_No_BS(ghoul2, mod_a,blist,"model_root",startFrame,endFrame-1,
+//		BONE_ANIM_OVERRIDE_FREEZE|BONE_ANIM_BLEND,
+//		1.0f,curTime,float(startFrame),150,0,true);
+	G2_Set_Bone_Anim_No_BS(ghoul2, mod_a,blist,"lfemurYZ",startFrame,endFrame-1,
+		BONE_ANIM_OVERRIDE_FREEZE|BONE_ANIM_BLEND,
+		1.0f,curTime,float(startFrame),150,0,true);
+	G2_Set_Bone_Anim_No_BS(ghoul2, mod_a,blist,"rfemurYZ",startFrame,endFrame-1,
+		BONE_ANIM_OVERRIDE_FREEZE|BONE_ANIM_BLEND,
+		1.0f,curTime,float(startFrame),150,0,true);
+
+	G2_Set_Bone_Anim_No_BS(ghoul2, mod_a,blist,"rhumerus",startFrame,endFrame-1,
+		BONE_ANIM_OVERRIDE_FREEZE|BONE_ANIM_BLEND,
+		1.0f,curTime,float(startFrame),150,0,true);
+	G2_Set_Bone_Anim_No_BS(ghoul2, mod_a,blist,"lhumerus",startFrame,endFrame-1,
+		BONE_ANIM_OVERRIDE_FREEZE|BONE_ANIM_BLEND,
+		1.0f,curTime,float(startFrame),150,0,true);
+
+//    should already be set					G2_GenerateWorldMatrix(parms->angles, parms->position);
+	G2_ConstructGhoulSkeleton(ghoul2V, curTime, false, parms->scale);
+
+	static const float fRadScale = 0.3f;//0.5f;
+
+	vec3_t pcjMin,pcjMax;
+	VectorSet(pcjMin,-90.0f,-45.0f,-45.0f);
+	VectorSet(pcjMax,90.0f,45.0f,45.0f);
+	G2_Set_Bone_Angles_Rag(ghoul2, mod_a,blist,"model_root",RAG_PCJ_MODEL_ROOT|RAG_PCJ|RAG_UNSNAPPABLE,10.0f*fRadScale,pcjMin,pcjMax,100);
+	VectorSet(pcjMin,-45.0f,-45.0f,-45.0f);
+	VectorSet(pcjMax,45.0f,45.0f,45.0f);
+	G2_Set_Bone_Angles_Rag(ghoul2, mod_a,blist,"pelvis",RAG_PCJ_PELVIS|RAG_PCJ|RAG_PCJ_POST_MULT|RAG_UNSNAPPABLE,10.0f*fRadScale,pcjMin,pcjMax,100);
+
+#if 1
+	// new base anim, unconscious flop
+	int pcjflags=RAG_PCJ|RAG_PCJ_POST_MULT;//|RAG_EFFECTOR;
+
+	VectorSet(pcjMin,-15.0f,-15.0f,-15.0f);
+	VectorSet(pcjMax,15.0f,15.0f,15.0f);
+	G2_Set_Bone_Angles_Rag(ghoul2, mod_a,blist,"lower_lumbar",pcjflags|RAG_UNSNAPPABLE,10.0f*fRadScale,pcjMin,pcjMax,500);
+	G2_Set_Bone_Angles_Rag(ghoul2, mod_a,blist,"upper_lumbar",pcjflags|RAG_UNSNAPPABLE,10.0f*fRadScale,pcjMin,pcjMax,500);
+	VectorSet(pcjMin,-25.0f,-25.0f,-25.0f);
+	VectorSet(pcjMax,25.0f,25.0f,25.0f);
+	G2_Set_Bone_Angles_Rag(ghoul2, mod_a,blist,"thoracic",pcjflags|RAG_EFFECTOR|RAG_UNSNAPPABLE,12.0f*fRadScale,pcjMin,pcjMax,500);
+
+	VectorSet(pcjMin,-10.0f,-10.0f,-90.0f);
+	VectorSet(pcjMax,10.0f,10.0f,90.0f);
+	G2_Set_Bone_Angles_Rag(ghoul2, mod_a,blist,"cranium",pcjflags|RAG_BONE_LIGHTWEIGHT|RAG_UNSNAPPABLE,6.0f*fRadScale,pcjMin,pcjMax,500);
+
+	static const float sFactLeg = 1.0f;
+	static const float sFactArm = 1.0f;
+	static const float sRadArm = 1.0f;
+	static const float sRadLeg = 1.0f;
+
+	VectorSet(pcjMin,-100.0f,-40.0f,-15.0f);
+	VectorSet(pcjMax,-15.0f,80.0f,15.0f);
+	VectorScale(pcjMin, sFactArm, pcjMin);
+	VectorScale(pcjMax, sFactArm, pcjMax);
+	G2_Set_Bone_Angles_Rag(ghoul2, mod_a,blist,"rhumerus",pcjflags|RAG_BONE_LIGHTWEIGHT|RAG_UNSNAPPABLE,(4.0f*sRadArm)*fRadScale,pcjMin,pcjMax,500);
+	VectorSet(pcjMin,-50.0f,-80.0f,-15.0f);
+	VectorSet(pcjMax,15.0f,40.0f,15.0f);
+	VectorScale(pcjMin, sFactArm, pcjMin);
+	VectorScale(pcjMax, sFactArm, pcjMax);
+	G2_Set_Bone_Angles_Rag(ghoul2, mod_a,blist,"lhumerus",pcjflags|RAG_BONE_LIGHTWEIGHT|RAG_UNSNAPPABLE,(4.0f*sRadArm)*fRadScale,pcjMin,pcjMax,500);
+
+	VectorSet(pcjMin,-25.0f,-20.0f,-20.0f);
+	VectorSet(pcjMax,90.0f,20.0f,-20.0f);
+	VectorScale(pcjMin, sFactArm, pcjMin);
+	VectorScale(pcjMax, sFactArm, pcjMax);
+	G2_Set_Bone_Angles_Rag(ghoul2, mod_a,blist,"rradius",pcjflags|RAG_BONE_LIGHTWEIGHT,(3.0f*sRadArm)*fRadScale,pcjMin,pcjMax,500);
+	VectorSet(pcjMin,-90.0f,-20.0f,-20.0f);
+	VectorSet(pcjMax,30.0f,20.0f,-20.0f);
+	VectorScale(pcjMin, sFactArm, pcjMin);
+	VectorScale(pcjMax, sFactArm, pcjMax);
+	G2_Set_Bone_Angles_Rag(ghoul2, mod_a,blist,"lradius",pcjflags|RAG_BONE_LIGHTWEIGHT,(3.0f*sRadArm)*fRadScale,pcjMin,pcjMax,500);
+
+
+	VectorSet(pcjMin,-80.0f,-50.0f,-20.0f);
+	VectorSet(pcjMax,30.0f,5.0f,20.0f);
+	VectorScale(pcjMin, sFactLeg, pcjMin);
+	VectorScale(pcjMax, sFactLeg, pcjMax);
+	G2_Set_Bone_Angles_Rag(ghoul2, mod_a,blist,"rfemurYZ",pcjflags|RAG_BONE_LIGHTWEIGHT,(6.0f*sRadLeg)*fRadScale,pcjMin,pcjMax,500);
+	VectorSet(pcjMin,-60.0f,-5.0f,-20.0f);
+	VectorSet(pcjMax,50.0f,50.0f,20.0f);
+	VectorScale(pcjMin, sFactLeg, pcjMin);
+	VectorScale(pcjMax, sFactLeg, pcjMax);
+	G2_Set_Bone_Angles_Rag(ghoul2, mod_a,blist,"lfemurYZ",pcjflags|RAG_BONE_LIGHTWEIGHT,(6.0f*sRadLeg)*fRadScale,pcjMin,pcjMax,500);
+
+	VectorSet(pcjMin,-20.0f,-15.0f,-15.0f);
+	VectorSet(pcjMax,100.0f,15.0f,15.0f);
+	VectorScale(pcjMin, sFactLeg, pcjMin);
+	VectorScale(pcjMax, sFactLeg, pcjMax);
+	G2_Set_Bone_Angles_Rag(ghoul2, mod_a,blist,"rtibia",pcjflags|RAG_EFFECTOR|RAG_BONE_LIGHTWEIGHT,(4.0f*sRadLeg)*fRadScale,pcjMin,pcjMax,500);
+	VectorSet(pcjMin,20.0f,-15.0f,-15.0f);
+	VectorSet(pcjMax,100.0f,15.0f,15.0f);
+	VectorScale(pcjMin, sFactLeg, pcjMin);
+	VectorScale(pcjMax, sFactLeg, pcjMax);
+	G2_Set_Bone_Angles_Rag(ghoul2, mod_a,blist,"ltibia",pcjflags|RAG_EFFECTOR|RAG_BONE_LIGHTWEIGHT,(4.0f*sRadLeg)*fRadScale,pcjMin,pcjMax,500);
+#else
+	// old base anim
+	int pcjflags=RAG_PCJ|RAG_PCJ_POST_MULT|RAG_EFFECTOR;
+
+	VectorSet(pcjMin,-15.0f,-15.0f,-15.0f);
+	VectorSet(pcjMax,45.0f,15.0f,15.0f);
+	G2_Set_Bone_Angles_Rag(ghoul2, mod_a,blist,"lower_lumbar",pcjflags,10.0f,pcjMin,pcjMax,500);
+	G2_Set_Bone_Angles_Rag(ghoul2, mod_a,blist,"upper_lumbar",pcjflags,10.0f,pcjMin,pcjMax,500);
+	VectorSet(pcjMin,-45.0f,-45.0f,-45.0f);
+	VectorSet(pcjMax,45.0f,45.0f,45.0f);
+	G2_Set_Bone_Angles_Rag(ghoul2, mod_a,blist,"thoracic",pcjflags,10.0f,pcjMin,pcjMax,500);
+
+	VectorSet(pcjMin,-10.0f,-10.0f,-90.0f);
+	VectorSet(pcjMax,10.0f,10.0f,90.0f);
+	G2_Set_Bone_Angles_Rag(ghoul2, mod_a,blist,"cranium",pcjflags|RAG_BONE_LIGHTWEIGHT,6.0f,pcjMin,pcjMax,500);
+
+	//VectorSet(pcjMin,-45.0f,-90.0f,-100.0f);
+	VectorSet(pcjMin,-180.0f,-180.0f,-100.0f);
+	//VectorSet(pcjMax,60.0f,60.0f,45.0f);
+	VectorSet(pcjMax,180.0f,180.0f,45.0f);
+	G2_Set_Bone_Angles_Rag(ghoul2, mod_a,blist,"rhumerus",pcjflags|RAG_BONE_LIGHTWEIGHT,4.0f,pcjMin,pcjMax,500);
+	//VectorSet(pcjMin,-45.0f,-60.0f,-45.0f);
+	VectorSet(pcjMin,-180.0f,-180.0f,-100.0f);
+	//VectorSet(pcjMax,60.0f,90.0f,100.0f);
+	VectorSet(pcjMax,180.0f,180.0f,100.0f);
+	G2_Set_Bone_Angles_Rag(ghoul2, mod_a,blist,"lhumerus",pcjflags|RAG_BONE_LIGHTWEIGHT,4.0f,pcjMin,pcjMax,500);
+
+	//-120/120
+	VectorSet(pcjMin,-120.0f,-20.0f,-20.0f);
+	VectorSet(pcjMax,50.0f,20.0f,-20.0f);
+	G2_Set_Bone_Angles_Rag(ghoul2, mod_a,blist,"rradius",pcjflags|RAG_BONE_LIGHTWEIGHT,3.0f,pcjMin,pcjMax,500);
+	VectorSet(pcjMin,-120.0f,-20.0f,-20.0f);
+	VectorSet(pcjMax,5.0f,20.0f,-20.0f);
+	G2_Set_Bone_Angles_Rag(ghoul2, mod_a,blist,"lradius",pcjflags|RAG_BONE_LIGHTWEIGHT,3.0f,pcjMin,pcjMax,500);
+
+	VectorSet(pcjMin,-90.0f,-50.0f,-20.0f);
+	VectorSet(pcjMax,50.0f,20.0f,20.0f);
+	G2_Set_Bone_Angles_Rag(ghoul2, mod_a,blist,"rfemurYZ",pcjflags|RAG_BONE_LIGHTWEIGHT,6.0f,pcjMin,pcjMax,500);
+	VectorSet(pcjMin,-90.0f,-20.0f,-20.0f);
+	VectorSet(pcjMax,50.0f,50.0f,20.0f);
+	G2_Set_Bone_Angles_Rag(ghoul2, mod_a,blist,"lfemurYZ",pcjflags|RAG_BONE_LIGHTWEIGHT,6.0f,pcjMin,pcjMax,500);
+
+	//120
+	VectorSet(pcjMin,-20.0f,-15.0f,-15.0f);
+	VectorSet(pcjMax,120.0f,15.0f,15.0f);
+	G2_Set_Bone_Angles_Rag(ghoul2, mod_a,blist,"rtibia",pcjflags|RAG_EFFECTOR|RAG_BONE_LIGHTWEIGHT,4.0f,pcjMin,pcjMax,500);
+	VectorSet(pcjMin,20.0f,-15.0f,-15.0f);
+	VectorSet(pcjMax,120.0f,15.0f,15.0f);
+	G2_Set_Bone_Angles_Rag(ghoul2, mod_a,blist,"ltibia",pcjflags|RAG_EFFECTOR|RAG_BONE_LIGHTWEIGHT,4.0f,pcjMin,pcjMax,500);
+#endif
+
+
+	float sRadEArm = 1.2f;
+	float sRadELeg = 1.2f;
+
+//	int rhand=
+	G2_Set_Bone_Angles_Rag(ghoul2, mod_a,blist,"rhand",RAG_EFFECTOR|RAG_BONE_LIGHTWEIGHT,(6.0f*sRadEArm)*fRadScale);
+	G2_Set_Bone_Angles_Rag(ghoul2, mod_a,blist,"lhand",RAG_EFFECTOR|RAG_BONE_LIGHTWEIGHT,(6.0f*sRadEArm)*fRadScale);
+	//G2_Set_Bone_Angles_Rag(ghoul2, mod_a,blist,"rtarsal",RAG_EFFECTOR|RAG_BONE_LIGHTWEIGHT,(4.0f*sRadELeg)*fRadScale);
+	//G2_Set_Bone_Angles_Rag(ghoul2, mod_a,blist,"ltarsal",RAG_EFFECTOR|RAG_BONE_LIGHTWEIGHT,(4.0f*sRadELeg)*fRadScale);
+//	G2_Set_Bone_Angles_Rag(ghoul2, mod_a,blist,"rtibia",RAG_EFFECTOR|RAG_BONE_LIGHTWEIGHT,(4.0f*sRadELeg)*fRadScale);
+//	G2_Set_Bone_Angles_Rag(ghoul2, mod_a,blist,"ltibia",RAG_EFFECTOR|RAG_BONE_LIGHTWEIGHT,(4.0f*sRadELeg)*fRadScale);
+	G2_Set_Bone_Angles_Rag(ghoul2, mod_a,blist,"rtalus",RAG_EFFECTOR|RAG_BONE_LIGHTWEIGHT,(4.0f*sRadELeg)*fRadScale);
+	G2_Set_Bone_Angles_Rag(ghoul2, mod_a,blist,"ltalus",RAG_EFFECTOR|RAG_BONE_LIGHTWEIGHT,(4.0f*sRadELeg)*fRadScale);
+	G2_Set_Bone_Angles_Rag(ghoul2, mod_a,blist,"rradiusX",RAG_EFFECTOR|RAG_BONE_LIGHTWEIGHT,(6.0f*sRadEArm)*fRadScale);
+	G2_Set_Bone_Angles_Rag(ghoul2, mod_a,blist,"lradiusX",RAG_EFFECTOR|RAG_BONE_LIGHTWEIGHT,(6.0f*sRadEArm)*fRadScale);
+	G2_Set_Bone_Angles_Rag(ghoul2, mod_a,blist,"rfemurX",RAG_EFFECTOR|RAG_BONE_LIGHTWEIGHT,(10.0f*sRadELeg)*fRadScale);
+	G2_Set_Bone_Angles_Rag(ghoul2, mod_a,blist,"lfemurX",RAG_EFFECTOR|RAG_BONE_LIGHTWEIGHT,(10.0f*sRadELeg)*fRadScale);
+	//G2_Set_Bone_Angles_Rag(ghoul2, mod_a,blist,"ceyebrow",RAG_EFFECTOR|RAG_BONE_LIGHTWEIGHT,10.0f*fRadScale);
+	G2_Set_Bone_Angles_Rag(ghoul2, mod_a,blist,"ceyebrow",RAG_EFFECTOR|RAG_BONE_LIGHTWEIGHT,5.0f);
+//match the currrent animation
+	if (!G2_RagDollSetup(ghoul2,curTime,true,parms->position,false))
+	{
+		assert(!"failed to add any rag bones");
+		return;
+	}
+	G2_RagDollCurrentPosition(ghoul2V,model,curTime,parms->angles,parms->position,parms->scale);
+#if 0
+	if (rhand>0)
+	{
+		boneInfo_t &bone=blist[rhand];
+		SRagEffector &e=ragEffectors[bone.ragIndex];
+		VectorCopy(bone.originalOrigin,handPos);
+		VectorCopy(e.currentOrigin,handPos2);
+	}
+#endif
+	int k;
+
+	CRagDollUpdateParams fparms;
+	VectorCopy(parms->position, fparms.position);
+	VectorCopy(parms->angles, fparms.angles);
+	VectorCopy(parms->scale, fparms.scale);
+	VectorClear(fparms.velocity);
+	fparms.me = parms->me;
+	fparms.settleFrame = parms->endFrame;
+
+	//Guess I don't need to do this, do I?
+	G2_ConstructGhoulSkeleton(ghoul2V, curTime, false, parms->scale);
+
+	vec3_t dPos;
+	VectorCopy(parms->position, dPos);
+#ifdef _OLD_STYLE_SETTLE
+	dPos[2] -= 6;
+#endif
+
+	for (k=0;k</*10*/20;k++)
+	{
+		G2_RagDollSettlePositionNumeroTrois(ghoul2V,dPos,&fparms,curTime);
+
+		G2_RagDollCurrentPosition(ghoul2V,model,curTime,parms->angles,dPos,parms->scale);
+		G2_RagDollMatchPosition();
+		G2_RagDollSolve(ghoul2V,model,1.0f*(1.0f-k/40.0f),curTime,dPos,false);
+	}
+}
+
+void G2_SetRagDollBullet(CGhoul2Info &ghoul2,const vec3_t rayStart,const vec3_t hit)
+{
+	if (!broadsword||!broadsword->integer)
+	{
+		return;
+	}
+	vec3_t shotDir;
+	VectorSubtract(hit,rayStart,shotDir);
+	float len=VectorLength(shotDir);
+	if (len<1.0f)
+	{
+		return;
+	}
+	float lenr=1.0f/len;
+	shotDir[0]*=lenr;
+	shotDir[1]*=lenr;
+	shotDir[2]*=lenr;
+
+	bool firstOne=false;
+	if (broadsword_kickbones&&broadsword_kickbones->integer)
+	{
+		int i;
+		int		magicFactor13=150.0f; // squared radius multiplier for shot effects
+		boneInfo_v &blist = ghoul2.mBlist;
+		for(i=blist.size()-1;i>=0;i--)
+		{
+			boneInfo_t &bone=blist[i];
+			if ((bone.flags & BONE_ANGLES_TOTAL))
+			{
+				if (bone.flags & BONE_ANGLES_RAGDOLL)
+				{
+					if (!firstOne)
+					{
+						firstOne=true;
+#if 0
+						int curTime=G2API_GetTime(0);
+						const mdxaHeader_t *mod_a=G2_GetModA(ghoul2);
+						int startFrame = 0, endFrame = 0;
+#if 1
+						TheGhoul2Wraith()->GetAnimFrames(ghoul2.mID, "unconsciousdeadflop01", startFrame, endFrame);
+						if (startFrame == -1 && endFrame == -1)
+						{ //A bad thing happened! Just use the hardcoded numbers even though they could be wrong.
+							startFrame = 3573;
+							endFrame = 3583;
+							assert(0);
+						}
+						G2_Set_Bone_Anim_No_BS(mod_a,blist,"upper_lumbar",startFrame,endFrame-1,
+							BONE_ANIM_OVERRIDE_FREEZE|BONE_ANIM_BLEND,
+							1.0f,curTime,float(startFrame),75,0,true);
+						G2_Set_Bone_Anim_No_BS(mod_a,blist,"lfemurYZ",startFrame,endFrame-1,
+							BONE_ANIM_OVERRIDE_FREEZE|BONE_ANIM_BLEND,
+							1.0f,curTime,float(startFrame),75,0,true);
+						G2_Set_Bone_Anim_No_BS(mod_a,blist,"rfemurYZ",startFrame,endFrame-1,
+							BONE_ANIM_OVERRIDE_FREEZE|BONE_ANIM_BLEND,
+							1.0f,curTime,float(startFrame),75,0,true);
+#else
+						TheGhoul2Wraith()->GetAnimFrames(ghoul2.mID, "backdeadflop01", startFrame, endFrame);
+						if (startFrame == -1 && endFrame == -1)
+						{ //A bad thing happened! Just use the hardcoded numbers even though they could be wrong.
+							startFrame = 3581;
+							endFrame = 3592;
+							assert(0);
+						}
+						G2_Set_Bone_Anim_No_BS(mod_a,blist,"upper_lumbar",endFrame,startFrame+1,
+							BONE_ANIM_OVERRIDE_FREEZE,
+							-1.0f,curTime,float(endFrame-1),50,0,true);
+						G2_Set_Bone_Anim_No_BS(mod_a,blist,"lfemurYZ",endFrame,startFrame+1,
+							BONE_ANIM_OVERRIDE_FREEZE,
+							-1.0f,curTime,float(endFrame-1),50,0,true);
+						G2_Set_Bone_Anim_No_BS(mod_a,blist,"rfemurYZ",endFrame,startFrame+1,
+							BONE_ANIM_OVERRIDE_FREEZE,
+							-1.0f,curTime,float(endFrame-1),50,0,true);
+#endif
+#endif
+					}
+
+					VectorCopy(shotDir,bone.lastShotDir);
+					vec3_t dir;
+					VectorSubtract(bone.lastPosition,hit,dir);
+					len=VectorLength(dir);
+					if (len<1.0f)
+					{
+						len=1.0f;
+					}
+					lenr=1.0f/len;
+					float effect=lenr;
+					effect*=magicFactor13*effect; // this is cubed, one of them is absorbed by the next calc
+					bone.velocityEffector[0]=shotDir[0]*(effect+flrand(0.0f,0.05f));
+					bone.velocityEffector[1]=shotDir[1]*(effect+flrand(0.0f,0.05f));
+					bone.velocityEffector[2]=fabs(shotDir[2])*(effect+flrand(0.0f,0.05f));
+//					bone.velocityEffector[0]=shotDir[0]*(effect+flrand(0.0f,0.05f))*flrand(-0.1f,3.0f);
+//					bone.velocityEffector[1]=shotDir[1]*(effect+flrand(0.0f,0.05f))*flrand(-0.1f,3.0f);
+//					bone.velocityEffector[2]=fabs(shotDir[2])*(effect+flrand(0.0f,0.05f))*flrand(-0.1f,3.0f);
+					assert( !_isnan(shotDir[2]));
+	//				bone.currentAngles[0]+=flrand(-10.0f*lenr,10.0f*lenr);
+	//				bone.currentAngles[1]+=flrand(-10.0f*lenr,10.0f*lenr);
+	//				bone.currentAngles[2]+=flrand(-10.0f*lenr,10.0f*lenr);
+	//				bone.lastAngles[0]+=flrand(-10.0f*lenr,10.0f*lenr);
+	//				bone.lastAngles[1]+=flrand(-10.0f*lenr,10.0f*lenr);
+	//				bone.lastAngles[2]+=flrand(-10.0f*lenr,10.0f*lenr);
+
+					// go dynamic
+					bone.firstCollisionTime=G2API_GetTime(0);
+//					bone.firstCollisionTime=0;
+					bone.restTime=0;
+				}
+			}
+		}
+	}
+}
+
+
+static float G2_RagSetState(CGhoul2Info &ghoul2, boneInfo_t &bone,int frameNum,const vec3_t origin,bool &resetOrigin)
+{
+	ragOriginChange=DistanceSquared(origin,bone.extraVec1);
+	VectorSubtract(origin,bone.extraVec1,ragOriginChangeDir);
+
+	float decay=1.0f;
+
+	int dynamicTime=1000;
+	int settleTime=1000;
+
+	if (ghoul2.mFlags & GHOUL2_RAG_FORCESOLVE)
+	{
+		ragState=ERS_DYNAMIC;
+		if (frameNum>bone.firstCollisionTime+dynamicTime)
+		{
+			VectorCopy(origin,bone.extraVec1);
+			if (ragOriginChange>15.0f)
+			{ //if we moved, or if this bone is still in solid
+				bone.firstCollisionTime=frameNum;
+			}
+			else
+			{
+				// settle out
+				bone.firstCollisionTime=0;
+				bone.restTime=frameNum;
+				ragState=ERS_SETTLING;
+			}
+		}
+	}
+	else if (bone.firstCollisionTime>0)
+	{
+		ragState=ERS_DYNAMIC;
+		if (frameNum>bone.firstCollisionTime+dynamicTime)
+		{
+			VectorCopy(origin,bone.extraVec1);
+			if (ragOriginChange>15.0f)
+			{ //if we moved, or if this bone is still in solid
+				bone.firstCollisionTime=frameNum;
+			}
+			else
+			{
+				// settle out
+				bone.firstCollisionTime=0;
+				bone.restTime=frameNum;
+				ragState=ERS_SETTLING;
+			}
+		}
+//decay=0.0f;
+	}
+	else if (bone.restTime>0)
+	{
+		decay=1.0f-(frameNum-bone.restTime)/float(dynamicTime);
+		if (decay<0.0f)
+		{
+			decay=0.0f;
+		}
+		if (decay>1.0f)
+		{
+			decay=1.0f;
+		}
+		float	magicFactor8=1.0f; // Power for decay
+		decay=pow(decay,magicFactor8);
+		ragState=ERS_SETTLING;
+		if (frameNum>bone.restTime+settleTime)
+		{
+			VectorCopy(origin,bone.extraVec1);
+			if (ragOriginChange>15.0f)
+			{
+				bone.restTime=frameNum;
+			}
+			else
+			{
+				// stop
+				bone.restTime=0;
+				ragState=ERS_SETTLED;
+			}
+		}
+//decay=0.0f;
+	}
+	else
+	{
+		if (bone.RagFlags & RAG_PCJ_IK_CONTROLLED)
+		{
+			bone.firstCollisionTime=frameNum;
+			ragState=ERS_DYNAMIC;
+		}
+		else if (ragOriginChange>15.0f)
+		{
+			bone.firstCollisionTime=frameNum;
+			ragState=ERS_DYNAMIC;
+		}
+		else
+		{
+			ragState=ERS_SETTLED;
+		}
+		decay=0.0f;
+	}
+//			ragState=ERS_SETTLED;
+//			decay=0.0f;
+	return decay;
+}
+
+static bool G2_RagDollSetup(CGhoul2Info &ghoul2,int frameNum,bool resetOrigin,const vec3_t origin,bool anyRendered)
+{
+	int i;
+	int minSurvivingBone=10000;
+	int minSurvivingBoneAt=-1;
+	int minSurvivingBoneAlt=10000;
+	int minSurvivingBoneAtAlt=-1;
+
+	assert(ghoul2.mFileName[0]);
+	boneInfo_v &blist = ghoul2.mBlist;
+	rag.clear();
+	int numRendered=0;
+	int numNotRendered=0;
+	int pelvisAt=-1;
+	for(i=0; i<blist.size(); i++)
+	{
+		boneInfo_t &bone=blist[i];
+		if (bone.boneNumber>=0)
+		{
+			assert(bone.boneNumber<MAX_BONES_RAG);
+			if ((bone.flags & BONE_ANGLES_RAGDOLL) || (bone.flags & BONE_ANGLES_IK))
+			{
+				//rww - this was (!anyRendered) before. Isn't that wrong? (if anyRendered, then wasRendered should be true)
+				bool wasRendered=
+					(!anyRendered) ||   // offscreeen or something
+					G2_WasBoneRendered(ghoul2,bone.boneNumber);
+				if (!wasRendered)
+				{
+					bone.RagFlags|=RAG_WAS_NOT_RENDERED;
+					numNotRendered++;
+				}
+				else
+				{
+					bone.RagFlags&=~RAG_WAS_NOT_RENDERED;
+					bone.RagFlags|=RAG_WAS_EVER_RENDERED;
+					numRendered++;
+				}
+				if	(bone.RagFlags&RAG_PCJ_PELVIS)
+				{
+					pelvisAt=i;
+				}
+				else if	(bone.RagFlags&RAG_PCJ_MODEL_ROOT)
+				{
+				}
+				else if	(wasRendered && (bone.RagFlags&RAG_PCJ))
+				{
+					if (minSurvivingBone>bone.boneNumber)
+					{
+						minSurvivingBone=bone.boneNumber;
+						minSurvivingBoneAt=i;
+					}
+				}
+				else if	(wasRendered)
+				{
+					if (minSurvivingBoneAlt>bone.boneNumber)
+					{
+						minSurvivingBoneAlt=bone.boneNumber;
+						minSurvivingBoneAtAlt=i;
+					}
+				}
+				if (
+					anyRendered &&
+					(bone.RagFlags&RAG_WAS_EVER_RENDERED) &&
+					!(bone.RagFlags&RAG_PCJ_MODEL_ROOT) &&
+					!(bone.RagFlags&RAG_PCJ_PELVIS) &&
+					!wasRendered &&
+					(bone.RagFlags&RAG_EFFECTOR)
+					)
+				{
+					// this thing was rendered in the past, but wasn't now, although other bones were, lets get rid of it
+//					bone.flags &= ~BONE_ANGLES_RAGDOLL;
+//					bone.RagFlags = 0;
+//OutputDebugString(va("Deleted Effector %d\n",i));
+//					continue;
+				}
+				if (rag.size()<bone.boneNumber+1)
+				{
+					rag.resize(bone.boneNumber+1,0);
+				}
+				rag[bone.boneNumber]=&bone;
+				ragBlistIndex[bone.boneNumber]=i;
+
+				bone.lastTimeUpdated=frameNum;
+				if (resetOrigin)
+				{
+					VectorCopy(origin,bone.extraVec1); // this is only done incase a limb is removed
+				}
+			}
+		}
+	}
+#if 0
+	if (numRendered<5)  // I think this is a limb
+	{
+//OutputDebugString(va("limb %3d/%3d  (r,N).\n",numRendered,numNotRendered));
+		if (minSurvivingBoneAt<0)
+		{
+			// pelvis is gone, but we have no remaining pcj's
+			// just find any remain rag effector
+			minSurvivingBoneAt=minSurvivingBoneAtAlt;
+		}
+		if (
+			minSurvivingBoneAt>=0 &&
+			pelvisAt>=0)
+		{
+			{
+				 // remove the pelvis as a rag
+				boneInfo_t &bone=blist[minSurvivingBoneAt];
+				bone.flags&=~BONE_ANGLES_RAGDOLL;
+				bone.RagFlags=0;
+			}
+			{
+				// the root-est bone is now our "pelvis
+				boneInfo_t &bone=blist[minSurvivingBoneAt];
+				VectorSet(bone.minAngles,-14500.0f,-14500.0f,-14500.0f);
+				VectorSet(bone.maxAngles,14500.0f,14500.0f,14500.0f);
+				bone.RagFlags|=RAG_PCJ_PELVIS|RAG_PCJ; // this guy is our new "pelvis"
+				bone.flags |= BONE_ANGLES_POSTMULT;
+				bone.ragStartTime=G2API_GetTime(0);
+			}
+		}
+	}
+#endif
+	numRags=0;
+	int ragStartTime=0;
+	for(i=0; i<rag.size(); i++)
+	{
+		if (rag[i])
+		{
+			boneInfo_t &bone=*rag[i];
+			assert(bone.boneNumber>=0);
+			assert(numRags<MAX_BONES_RAG);
+
+			ragStartTime=bone.ragStartTime;
+
+			bone.ragIndex=numRags;
+			ragBoneData[numRags]=&bone;
+			ragEffectors[numRags].radius=bone.radius;
+			ragEffectors[numRags].weight=bone.weight;
+			G2_GetBoneBasepose(ghoul2,bone.boneNumber,bone.basepose,bone.baseposeInv);
+			numRags++;
+		}
+	}
+	if (!numRags)
+	{
+		return false;
+	}
+	return true;
+}
+
+static void G2_RagDoll(CGhoul2Info_v &ghoul2V,int g2Index,CRagDollUpdateParams *params, int curTime)
+{
+	int i;
+	if (!broadsword||!broadsword->integer)
+	{
+		return;
+	}
+
+	if (!params)
+	{
+		assert(0);
+		return;
+	}
+
+	vec3_t dPos;
+	VectorCopy(params->position, dPos);
+#ifdef _OLD_STYLE_SETTLE
+	dPos[2] -= 6;
+#endif
+
+//	params->DebugLine(handPos,handPos2,false);
+	int frameNum=G2API_GetTime(0);
+	CGhoul2Info &ghoul2=ghoul2V[g2Index];
+	assert(ghoul2.mFileName[0]);
+	boneInfo_v &blist = ghoul2.mBlist;
+
+	// hack for freezing ragdoll (no idea if it works)
+#if 0
+	if (0)
+	{
+		// we gotta hack this to basically freeze the timers
+		for(i=0; i<blist.size(); i++)
+		{
+			boneInfo_t &bone=blist[i];
+			if (bone.boneNumber>=0)
+			{
+				assert(bone.boneNumber<MAX_BONES_RAG);
+				if (bone.flags & BONE_ANGLES_RAGDOLL)
+				{
+					bone.ragStartTime+=50;
+					if (bone.firstTime)
+					{
+						bone.firstTime+=50;
+					}
+					if (bone.firstCollisionTime)
+					{
+						bone.firstCollisionTime+=50;
+					}
+					if (bone.restTime)
+					{
+						bone.restTime+=50;
+					}
+				}
+			}
+		}
+		return;
+	}
+#endif
+
+	float decay=1.0f;
+	bool resetOrigin=false;
+	bool anyRendered=false;
+
+	// this loop checks for settled
+	for(i=0; i<blist.size(); i++)
+	{
+		boneInfo_t &bone=blist[i];
+		if (bone.boneNumber>=0)
+		{
+			assert(bone.boneNumber<MAX_BONES_RAG);
+			if (bone.flags & BONE_ANGLES_RAGDOLL)
+			{
+				// check for state transitions
+				decay=G2_RagSetState(ghoul2,bone,frameNum,dPos,resetOrigin); // set the current state
+
+				if (ragState==ERS_SETTLED)
+				{
+#if 0
+					bool noneInSolid = true;
+
+					//first iterate through and make sure no bones are still in solid a lot
+					for(int j = 0; j < blist.size(); j++)
+					{
+						boneInfo_t &bone2 = blist[j];
+
+						if (bone2.boneNumber >= 0 && bone2.solidCount > 8)
+						{
+							noneInSolid = false;
+							break;
+						}
+					}
+
+					if (noneInSolid)
+					{ //we're settled then
+						params->RagDollSettled();
+						return;
+					}
+					else
+					{
+						continue;
+					}
+#else
+					params->RagDollSettled();
+					return;
+#endif
+				}
+				if (G2_WasBoneRendered(ghoul2,bone.boneNumber))
+				{
+					anyRendered=true;
+					break;
+				}
+			}
+		}
+	}
+	//int iters=(ragState==ERS_DYNAMIC)?2:1;
+	int iters=(ragState==ERS_DYNAMIC)?4:2;
+	bool kicked=false;
+	if (ragOriginChangeDir[2]<-100.0f)
+	{
+		kicked=true;
+		//iters*=8;
+		iters*=2; //rww - changed to this.. it was getting up to around 600 traces at times before (which is insane)
+	}
+	if (iters)
+	{
+		if (!G2_RagDollSetup(ghoul2,frameNum,resetOrigin,dPos,anyRendered))
+		{
+			return;
+		}
+		// ok, now our data structures are compact and set up in topological order
+
+		for (i=0;i<iters;i++)
+		{
+			G2_RagDollCurrentPosition(ghoul2V,g2Index,frameNum,params->angles,dPos,params->scale);
+
+			if (G2_RagDollSettlePositionNumeroTrois(ghoul2V,dPos,params,curTime))
+			{
+#if 0
+				//effectors are start solid alot, so this was pretty extreme
+				if (!kicked&&iters<4)
+				{
+					kicked=true;
+					//iters*=4;
+					iters*=2;
+				}
+#endif
+			}
+			//params->position[2] += 16;
+			G2_RagDollSolve(ghoul2V,g2Index,decay*2.0f,frameNum,dPos,true,params);
+		}
+	}
+
+	if (params->me != ENTITYNUM_NONE)
+	{
+#if 0
+		vec3_t worldMins,worldMaxs;
+		worldMins[0]=params->position[0]-17;
+		worldMins[1]=params->position[1]-17;
+		worldMins[2]=params->position[2];
+		worldMaxs[0]=params->position[0]+17;
+		worldMaxs[1]=params->position[1]+17;
+		worldMaxs[2]=params->position[2];
+//OutputDebugString(va("%f \n",worldMins[2]));
+//		params->DebugLine(worldMins,worldMaxs,true);
+#endif
+		G2_RagDollCurrentPosition(ghoul2V,g2Index,frameNum,params->angles,params->position,params->scale);
+//		SV_UnlinkEntity(params->me);
+//		params->me->SetMins(BB_SHOOTING_SIZE,ragBoneMins);
+//		params->me->SetMaxs(BB_SHOOTING_SIZE,ragBoneMaxs);
+//		SV_LinkEntity(params->me);
+	}
+}
+
+#ifdef _DEBUG
+#define _DEBUG_BONE_NAMES
+#endif
+
+static inline char *G2_Get_Bone_Name(CGhoul2Info *ghlInfo, boneInfo_v &blist, int boneNum)
+{
+	int					i;
+	mdxaSkel_t			*skel;
+	mdxaSkelOffsets_t	*offsets;
+   	offsets = (mdxaSkelOffsets_t *)((byte *)ghlInfo->aHeader + sizeof(mdxaHeader_t));
+	skel = (mdxaSkel_t *)((byte *)ghlInfo->aHeader + sizeof(mdxaHeader_t) + offsets->offsets[0]);
+
+	// look through entire list
+	for(i=0; i<blist.size(); i++)
+	{
+		// if this bone entry has no info in it, bounce over it
+		if (blist[i].boneNumber != boneNum)
+		{
+			continue;
+		}
+
+		// figure out what skeletal info structure this bone entry is looking at
+		skel = (mdxaSkel_t *)((byte *)ghlInfo->aHeader + sizeof(mdxaHeader_t) + offsets->offsets[blist[i].boneNumber]);
+
+		return skel->name;
+	}
+
+	// didn't find it
+	return "BONE_NOT_FOUND";
+}
+
+char *G2_GetBoneNameFromSkel(CGhoul2Info &ghoul2, int boneNum);
+
+static void G2_RagDollCurrentPosition(CGhoul2Info_v &ghoul2V,int g2Index,int frameNum,const vec3_t angles,const vec3_t position,const vec3_t scale)
+{
+	CGhoul2Info &ghoul2=ghoul2V[g2Index];
+	assert(ghoul2.mFileName[0]);
+//OutputDebugString(va("angles %f %f %f\n",angles[0],angles[1],angles[2]));
+	G2_GenerateWorldMatrix(angles,position);
+	G2_ConstructGhoulSkeleton(ghoul2V, frameNum, false, scale);
+
+	float totalWt=0.0f;
+	int i;
+	for (i=0;i<numRags;i++)
+	{
+		boneInfo_t &bone=*ragBoneData[i];
+		G2_GetBoneMatrixLow(ghoul2,bone.boneNumber,scale,ragBones[i],ragBasepose[i],ragBaseposeInv[i]);
+
+#ifdef _DEBUG_BONE_NAMES
+		char *debugBoneName = G2_Get_Bone_Name(&ghoul2, ghoul2.mBlist, bone.boneNumber);
+		assert(debugBoneName);
+#endif
+
+		int k;
+		//float cmweight=ragEffectors[numRags].weight;
+		float cmweight=1.0f;
+		for (k=0;k<3;k++)
+		{
+			ragEffectors[i].currentOrigin[k]=ragBones[i].matrix[k][3];
+			assert( !_isnan(ragEffectors[i].currentOrigin[k]));
+			if (!i)
+			{
+				// set mins, maxs and cm
+				ragBoneCM[k]=ragEffectors[i].currentOrigin[k]*cmweight;
+				ragBoneMaxs[k]=ragEffectors[i].currentOrigin[k];
+				ragBoneMins[k]=ragEffectors[i].currentOrigin[k];
+			}
+			else
+			{
+				ragBoneCM[k]+=ragEffectors[i].currentOrigin[k]*ragEffectors[i].weight;
+				if (ragEffectors[i].currentOrigin[k]>ragBoneMaxs[k])
+				{
+					ragBoneMaxs[k]=ragEffectors[i].currentOrigin[k];
+				}
+				if (ragEffectors[i].currentOrigin[k]<ragBoneMins[k])
+				{
+					ragBoneMins[k]=ragEffectors[i].currentOrigin[k];
+				}
+			}
+		}
+
+		totalWt+=cmweight;
+	}
+
+	assert(totalWt>0.0f);
+	int k;
+	{
+		float wtInv=1.0f/totalWt;
+		for (k=0;k<3;k++)
+		{
+			ragBoneMaxs[k]-=position[k];
+			ragBoneMins[k]-=position[k];
+			ragBoneMaxs[k]+=10.0f;
+			ragBoneMins[k]-=10.0f;
+			ragBoneCM[k]*=wtInv;
+
+			ragBoneCM[k]=ragEffectors[0].currentOrigin[k]; // use the pelvis
+		}
+	}
+}
+
+#ifdef _DEBUG
+int ragTraceTime = 0;
+int ragSSCount = 0;
+int ragTraceCount = 0;
+#endif
+
+void Rag_Trace( trace_t *results, const vec3_t start, const vec3_t mins, const vec3_t maxs, const vec3_t end, const int passEntityNum, const int contentmask, const EG2_Collision eG2TraceType, const int useLod )
+{
+#ifdef _DEBUG
+	int ragPreTrace = Sys_Milliseconds();
+#endif
+#ifndef DEDICATED
+	if (cgvm)
+	{
+		ragCallbackTraceLine_t *callData = (ragCallbackTraceLine_t *)cl.mSharedMemory;
+
+		VectorCopy(start, callData->start);
+		VectorCopy(end, callData->end);
+		VectorCopy(mins, callData->mins);
+		VectorCopy(maxs, callData->maxs);
+		callData->ignore = passEntityNum;
+		callData->mask = contentmask;
+
+		VM_Call(cgvm, CG_RAG_CALLBACK, RAG_CALLBACK_TRACELINE);
+
+		*results = callData->tr;
+	}
+	else
+#endif // !DEDICATED
+	{
+		results->entityNum = ENTITYNUM_NONE;
+		//SV_Trace(results, start, mins, maxs, end, passEntityNum, contentmask, eG2TraceType, useLod);
+		CM_BoxTrace(results, start, end, mins, maxs, 0, contentmask, 0);
+		results->entityNum = results->fraction != 1.0 ? ENTITYNUM_WORLD : ENTITYNUM_NONE;
+	}
+
+#ifdef _DEBUG
+	int ragPostTrace = Sys_Milliseconds();
+
+	ragTraceTime += (ragPostTrace - ragPreTrace);
+	if (results->startsolid)
+	{
+		ragSSCount++;
+	}
+	ragTraceCount++;
+#endif
+}
+
+//run advanced physics on each bone indivudually
+//an adaption of my "exphys" custom game physics model
+#define MAX_GRAVITY_PULL 256//512
+
+static inline bool G2_BoneOnGround(const vec3_t org, const vec3_t mins, const vec3_t maxs, const int ignoreNum)
+{
+	trace_t tr;
+	vec3_t gSpot;
+
+	VectorCopy(org, gSpot);
+	gSpot[2] -= 1.0f; //seems reasonable to me
+
+	Rag_Trace(&tr, org, mins, maxs, gSpot, ignoreNum, RAG_MASK, G2_NOCOLLIDE, 0);
+
+	if (tr.fraction != 1.0f && !tr.startsolid && !tr.allsolid)
+	{ //not in solid, and hit something. Guess it's ground.
+		return true;
+	}
+
+	return false;
+}
+
+static inline bool G2_ApplyRealBonePhysics(boneInfo_t &bone, SRagEffector &e, CRagDollUpdateParams *params, vec3_t goalSpot, const vec3_t testMins, const vec3_t testMaxs,
+										   const float gravity, const float mass, const float bounce)
+{
+	trace_t tr;
+	vec3_t projectedOrigin;
+	vec3_t vNorm;
+	vec3_t ground;
+	float velScaling = 0.1f;
+	float vTotal = 0.0f;
+	bool boneOnGround = false;
+
+	assert(mass <= 1.0f && mass >= 0.01f);
+
+	if (bone.physicsSettled)
+	{ //then we have no need to continue
+		return true;
+	}
+
+	if (gravity)
+	{ //factor it in before we do anything.
+		VectorCopy(e.currentOrigin, ground);
+		ground[2] -= 1.0f;
+
+		Rag_Trace(&tr, e.currentOrigin, testMins, testMaxs, ground, params->me, RAG_MASK, G2_NOCOLLIDE, 0);
+
+		if (tr.entityNum == ENTITYNUM_NONE)
+		{
+			boneOnGround = false;
+		}
+		else
+		{
+			boneOnGround = true;
+		}
+
+		if (!boneOnGround)
+		{
+			if (!params->velocity[2])
+			{ //only increase gravitational pull once the actual entity is still
+				bone.epGravFactor += gravity;
+			}
+
+			if (bone.epGravFactor > MAX_GRAVITY_PULL)
+			{ //cap it off if needed
+				bone.epGravFactor = MAX_GRAVITY_PULL;
+			}
+
+			bone.epVelocity[2] -= bone.epGravFactor;
+		}
+		else
+		{ //if we're sitting on something then reset the gravity factor.
+			bone.epGravFactor = 0;
+		}
+	}
+	else
+	{
+		boneOnGround = G2_BoneOnGround(e.currentOrigin, testMins, testMaxs, params->me);
+	}
+
+	if (!bone.epVelocity[0] && !bone.epVelocity[1] && !bone.epVelocity[2])
+	{ //nothing to do if we have no velocity even after gravity.
+		VectorCopy(e.currentOrigin, goalSpot);
+		return true;
+	}
+
+	//get the projected origin based on velocity.
+	VectorMA(e.currentOrigin, velScaling, bone.epVelocity, projectedOrigin);
+
+	//scale it down based on mass
+	VectorScale(bone.epVelocity, 1.0f-mass, bone.epVelocity);
+
+	VectorCopy(bone.epVelocity, vNorm);
+	vTotal = VectorNormalize(vNorm);
+
+	if (vTotal < 1 && boneOnGround)
+	{ //we've pretty much stopped moving anyway, just clear it out then.
+		VectorClear(bone.epVelocity);
+		bone.epGravFactor = 0;
+		VectorCopy(e.currentOrigin, goalSpot);
+		return true;
+	}
+
+	Rag_Trace(&tr, e.currentOrigin, testMins, testMaxs, projectedOrigin, params->me, RAG_MASK, G2_NOCOLLIDE, 0);
+
+	if (tr.startsolid || tr.allsolid)
+	{ //can't go anywhere from here
+		return false;
+	}
+
+	//Go ahead and set it to the trace endpoint regardless of what it hit
+	VectorCopy(tr.endpos, goalSpot);
+
+	if (tr.fraction == 1.0f)
+	{ //Nothing was in the way.
+		return true;
+	}
+
+	if (bounce)
+	{
+		vTotal *= bounce; //scale it by bounce
+
+		VectorScale(tr.plane.normal, vTotal, vNorm); //scale the trace plane normal by the bounce factor
+
+		if (vNorm[2] > 0)
+		{
+			bone.epGravFactor -= vNorm[2]*(1.0f-mass); //The lighter it is the more gravity will be reduced by bouncing vertically.
+			if (bone.epGravFactor < 0)
+			{
+				bone.epGravFactor = 0;
+			}
+		}
+
+		VectorAdd(bone.epVelocity, vNorm, bone.epVelocity); //add it into the existing velocity.
+
+		//I suppose it could be sort of neat to make a game callback here to actual do stuff
+		//when bones slam into things. But it could be slow too.
+		/*
+		if (tr.entityNum != ENTITYNUM_NONE && ent->touch)
+		{ //then call the touch function
+			ent->touch(ent, &g_entities[tr.entityNum], &tr);
+		}
+		*/
+	}
+	else
+	{ //if no bounce, kill when it hits something.
+		bone.epVelocity[0] = 0;
+		bone.epVelocity[1] = 0;
+
+		if (!gravity)
+		{
+			bone.epVelocity[2] = 0;
+		}
+	}
+	return true;
+}
+
+#ifdef _DEBUG_BONE_NAMES
+static inline void G2_RagDebugBox(vec3_t mins, vec3_t maxs, int duration)
+{
+#ifdef DEDICATED
+	return;
+#else
+	if (!cgvm)
+	{
+		return;
+	}
+
+	ragCallbackDebugBox_t *callData = (ragCallbackDebugBox_t *)cl.mSharedMemory;
+
+	callData->duration = duration;
+	VectorCopy(mins, callData->mins);
+	VectorCopy(maxs, callData->maxs);
+
+	VM_Call(cgvm, CG_RAG_CALLBACK, RAG_CALLBACK_DEBUGBOX);
+#endif 
+}
+
+static inline void G2_RagDebugLine(vec3_t start, vec3_t end, int time, int color, int radius)
+{
+#ifdef DEDICATED
+	return;
+#else
+	if (!cgvm)
+	{
+		return;
+	}
+
+	ragCallbackDebugLine_t *callData = (ragCallbackDebugLine_t *)cl.mSharedMemory;
+
+	VectorCopy(start, callData->start);
+	VectorCopy(end, callData->end);
+	callData->time = time;
+	callData->color = color;
+	callData->radius = radius;
+
+	VM_Call(cgvm, CG_RAG_CALLBACK, RAG_CALLBACK_DEBUGLINE);
+#endif // !DEDICATED
+}
+#endif
+
+#ifdef _OLD_STYLE_SETTLE
+static bool G2_RagDollSettlePositionNumeroTrois(CGhoul2Info_v &ghoul2V, const vec3_t currentOrg, CRagDollUpdateParams *params, int curTime)
+{
+	haveDesiredPelvisOffset=false;
+	vec3_t desiredPos;
+	int i;
+
+	assert(params);
+	//assert(params->me); //no longer valid, because me is an index!
+	int ignoreNum=params->me;
+
+	bool anyStartSolid=false;
+
+	vec3_t groundSpot={0,0,0};
+	// lets find the floor at our quake origin
+	{
+		vec3_t testStart;
+		VectorCopy(currentOrg,testStart); //last arg is dest
+		vec3_t testEnd;
+		VectorCopy(testStart,testEnd); //last arg is dest
+		testEnd[2]-=200.0f;
+
+		vec3_t testMins;
+		vec3_t testMaxs;
+		VectorSet(testMins,-10,-10,-10);
+		VectorSet(testMaxs,10,10,10);
+
+		{
+			trace_t		tr;
+			assert( !_isnan(testStart[1]));
+			assert( !_isnan(testEnd[1]));
+			assert( !_isnan(testMins[1]));
+			assert( !_isnan(testMaxs[1]));
+			Rag_Trace(&tr,testStart,testMins,testMaxs,testEnd,ignoreNum,RAG_MASK,G2_NOCOLLIDE,0/*SV_TRACE_NO_PLAYER*/);
+			if (tr.entityNum==0)
+			{
+				VectorAdvance(testStart,.5f,testEnd,tr.endpos);
+			}
+			if (tr.startsolid)
+			{
+				//hmmm, punt
+				VectorCopy(currentOrg,groundSpot); //last arg is dest
+				groundSpot[2]-=30.0f;
+			}
+			else
+			{
+				VectorCopy(tr.endpos,groundSpot); //last arg is dest
+			}
+		}
+	}
+
+	for (i=0;i<numRags;i++)
+	{
+		boneInfo_t &bone=*ragBoneData[i];
+		SRagEffector &e=ragEffectors[i];
+		if (bone.RagFlags & RAG_PCJ_PELVIS)
+		{
+			// just move to quake origin
+			VectorCopy(currentOrg,desiredPos);
+			//desiredPos[2]-=35.0f;
+			desiredPos[2]-=20.0f;
+//old deathflop			desiredPos[2]-=40.0f;
+			VectorSubtract(desiredPos,e.currentOrigin,desiredPelvisOffset); // last arg is dest
+			haveDesiredPelvisOffset=true;
+			VectorCopy(e.currentOrigin,bone.lastPosition); // last arg is dest
+			continue; 
+		}
+
+		if (!(bone.RagFlags & RAG_EFFECTOR))
+		{
+			continue; 
+		}
+		vec3_t testMins;
+		vec3_t testMaxs;
+		VectorSet(testMins,-e.radius,-e.radius,-e.radius);
+		VectorSet(testMaxs,e.radius,e.radius,e.radius);
+
+		// first we will see if we are start solid
+		// if so, we are gonna run some bonus iterations
+		bool iAmStartSolid=false;
+		vec3_t testStart;
+		VectorCopy(e.currentOrigin,testStart); //last arg is dest
+		testStart[2]+=12.0f; // we are no so concerned with minor penetration
+
+		vec3_t testEnd;
+		VectorCopy(testStart,testEnd); //last arg is dest
+		testEnd[2]-=8.0f;
+		assert( !_isnan(testStart[1]));
+		assert( !_isnan(testEnd[1]));
+		assert( !_isnan(testMins[1]));
+		assert( !_isnan(testMaxs[1]));
+		float vertEffectorTraceFraction=0.0f;
+		{
+			trace_t		tr;
+			Rag_Trace(&tr,testStart,testMins,testMaxs,testEnd,ignoreNum,RAG_MASK,G2_NOCOLLIDE,0);
+			if (tr.entityNum==0)
+			{
+				VectorAdvance(testStart,.5f,testEnd,tr.endpos);
+			}
+			if (tr.startsolid)
+			{
+				// above the origin, so lets try lower
+				if (e.currentOrigin[2] > groundSpot[2])
+				{
+					testStart[2]=groundSpot[2]+(e.radius-10.0f); 
+				}
+				else
+				{
+					// lets try higher
+					testStart[2]=groundSpot[2]+8.0f; 
+					Rag_Trace(&tr,testStart,testMins,testMaxs,testEnd,ignoreNum,RAG_MASK,G2_NOCOLLIDE,0);
+					if (tr.entityNum==0)
+					{
+						VectorAdvance(testStart,.5f,testEnd,tr.endpos);
+					}
+				}
+
+			}
+			if (tr.startsolid)
+			{
+				iAmStartSolid=true;
+				anyStartSolid=true;
+				// above the origin, so lets slide away
+				if (e.currentOrigin[2] > groundSpot[2])
+				{
+					if (params)
+					{
+						//SRagDollEffectorCollision args(e.currentOrigin,tr);
+						//params->EffectorCollision(args);
+#ifndef DEDICATED
+						if (cgvm)
+						{ //make a callback and see if the cgame wants to help us out
+							ragCallbackBoneInSolid_t *callData = (ragCallbackBoneInSolid_t *)cl.mSharedMemory;
+
+							VectorCopy(e.currentOrigin, callData->bonePos);
+							callData->entNum = params->me;
+							callData->solidCount = bone.solidCount;
+
+							VM_Call(cgvm, CG_RAG_CALLBACK, RAG_CALLBACK_BONEINSOLID);
+						}
+#endif 
+					}
+				}
+				else
+				{
+					//harumph, we are really screwed
+				}
+			}
+			else
+			{
+				vertEffectorTraceFraction=tr.fraction;
+				if (params && 
+					vertEffectorTraceFraction < .95f &&
+					fabsf(tr.plane.normal[2]) < .707f)
+				{
+					//SRagDollEffectorCollision args(e.currentOrigin,tr);
+					//args.useTracePlane=true;
+					//params->EffectorCollision(args);
+#ifndef DEDICATED
+					if (cgvm)
+					{ //make a callback and see if the cgame wants to help us out
+						ragCallbackBoneInSolid_t *callData = (ragCallbackBoneInSolid_t *)cl.mSharedMemory;
+
+						VectorCopy(e.currentOrigin, callData->bonePos);
+						callData->entNum = params->me;
+						callData->solidCount = bone.solidCount;
+
+						VM_Call(cgvm, CG_RAG_CALLBACK, RAG_CALLBACK_BONEINSOLID);
+					}
+#endif
+				}
+			}
+		}
+		vec3_t effectorGroundSpot;
+		VectorAdvance(testStart,vertEffectorTraceFraction,testEnd,effectorGroundSpot);//  VA(a,t,b,c)-> c := (1-t)a+tb
+		// trace from the quake origin horzontally to the effector
+		// gonna choose the maximum of the ground spot or the effector location 
+		// and clamp it to be roughly in the bbox
+		VectorCopy(groundSpot,testStart); //last arg is dest
+		if (iAmStartSolid)
+		{
+			// we don't have a meaningful ground spot
+			VectorCopy(e.currentOrigin,testEnd); //last arg is dest
+			bone.solidCount++;
+		}
+		else
+		{
+			VectorCopy(effectorGroundSpot,testEnd); //last arg is dest
+			bone.solidCount = 0;
+		}
+		assert( !_isnan(testStart[1]));
+		assert( !_isnan(testEnd[1]));
+		assert( !_isnan(testMins[1]));
+		assert( !_isnan(testMaxs[1]));
+
+		float ztest;
+
+		if (testEnd[2]>testStart[2])
+		{
+			ztest=testEnd[2];
+		}
+		else
+		{
+			ztest=testStart[2];
+		}
+		if (ztest<currentOrg[2]-30.0f)
+		{
+			ztest=currentOrg[2]-30.0f;
+		}
+		if (ztest<currentOrg[2]+10.0f)
+		{
+			ztest=currentOrg[2]+10.0f;			
+		}
+		testStart[2]=ztest;
+		testEnd[2]=ztest;
+
+		float		magicFactor44=1.0f; // going to trace a bit longer, this also serves as an expansion parameter
+		VectorAdvance(testStart,magicFactor44,testEnd,testEnd);//  VA(a,t,b,c)-> c := (1-t)a+tb
+
+		float horzontalTraceFraction=0.0f;
+		vec3_t HorizontalHitSpot={0,0,0};
+		{
+			trace_t		tr;
+			Rag_Trace(&tr,testStart,testMins,testMaxs,testEnd,ignoreNum,RAG_MASK,G2_NOCOLLIDE,0);
+			if (tr.entityNum==0)
+			{
+				VectorAdvance(testStart,.5f,testEnd,tr.endpos);
+			}
+			horzontalTraceFraction=tr.fraction;
+			if (tr.startsolid)
+			{
+				horzontalTraceFraction=1.0f;
+				// punt
+				VectorCopy(e.currentOrigin,HorizontalHitSpot);
+			}
+			else
+			{
+				VectorCopy(tr.endpos,HorizontalHitSpot);
+				int		magicFactor46=0.98f; // shorten percetage to make sure we can go down along a wall
+				//float		magicFactor46=0.98f; // shorten percetage to make sure we can go down along a wall
+				//rww - An..int?
+				VectorAdvance(tr.endpos,magicFactor46,testStart,HorizontalHitSpot);//  VA(a,t,b,c)-> c := (1-t)a+tb
+
+				// roughly speaking this is a wall
+				if (horzontalTraceFraction<0.9f)
+				{
+				
+					// roughly speaking this is a wall
+					if (fabsf(tr.plane.normal[2])<0.7f)
+					{
+						//SRagDollEffectorCollision args(e.currentOrigin,tr);
+						//args.useTracePlane=true;
+						//params->EffectorCollision(args);
+#ifndef DEDICATED
+						if (cgvm)
+						{ //make a callback and see if the cgame wants to help us out
+							ragCallbackBoneInSolid_t *callData = (ragCallbackBoneInSolid_t *)cl.mSharedMemory;
+
+							VectorCopy(e.currentOrigin, callData->bonePos);
+							callData->entNum = params->me;
+							callData->solidCount = bone.solidCount;
+
+							VM_Call(cgvm, CG_RAG_CALLBACK, RAG_CALLBACK_BONEINSOLID);
+						}
+#endif
+					}
+				}
+				else if (!iAmStartSolid &&
+					effectorGroundSpot[2] < groundSpot[2] - 8.0f)
+				{
+					// this is a situation where we have something dangling below the pelvis, we want to find the plane going downhill away from the origin
+					// for various reasons, without this correction the body will actually move away from places it can fall off.
+					//gotta run the trace backwards to get a plane
+					{
+						trace_t		tr;
+						VectorCopy(effectorGroundSpot,testStart);
+						VectorCopy(groundSpot,testEnd);
+
+						// this can be a line trace, we just want the plane normal
+						Rag_Trace(&tr,testEnd,0,0,testStart,ignoreNum,RAG_MASK,G2_NOCOLLIDE,0);
+						if (tr.entityNum==0)
+						{
+							VectorAdvance(testStart,.5f,testEnd,tr.endpos);
+						}
+						horzontalTraceFraction=tr.fraction;
+						if (!tr.startsolid && tr.fraction< 0.7f)
+						{
+							//SRagDollEffectorCollision args(e.currentOrigin,tr);
+							//args.useTracePlane=true;
+							//params->EffectorCollision(args);
+#ifndef DEDICATED
+							if (cgvm)
+							{ //make a callback and see if the cgame wants to help us out
+								ragCallbackBoneInSolid_t *callData = (ragCallbackBoneInSolid_t *)cl.mSharedMemory;
+
+								VectorCopy(e.currentOrigin, callData->bonePos);
+								callData->entNum = params->me;
+								callData->solidCount = bone.solidCount;
+
+								VM_Call(cgvm, CG_RAG_CALLBACK, RAG_CALLBACK_BONEINSOLID);
+							}
+#endif
+						}
+					}
+				}
+			}
+		}
+		vec3_t goalSpot={0,0,0};
+		// now lets trace down
+		VectorCopy(HorizontalHitSpot,testStart);
+		VectorCopy(testStart,testEnd); //last arg is dest
+		testEnd[2]=e.currentOrigin[2]-30.0f;
+		{
+			trace_t		tr;
+			Rag_Trace(&tr,testStart,NULL,NULL,testEnd,ignoreNum,RAG_MASK,G2_NOCOLLIDE,0);
+			if (tr.entityNum==0)
+			{
+				VectorAdvance(testStart,.5f,testEnd,tr.endpos);
+			}
+			if (tr.startsolid)
+			{
+				// punt, go to the origin I guess
+				VectorCopy(currentOrg,goalSpot);
+			}
+			else
+			{
+				VectorCopy(tr.endpos,goalSpot);
+				int		magicFactor47=0.5f; // shorten percentage to make sure we can go down along a wall
+				VectorAdvance(tr.endpos,magicFactor47,testStart,goalSpot);//  VA(a,t,b,c)-> c := (1-t)a+tb
+			}
+		}
+
+		// ok now as the horizontal trace fraction approaches zero, we want to head toward the horizontalHitSpot
+		//geeze I would like some reasonable trace fractions
+		assert(horzontalTraceFraction>=0.0f&&horzontalTraceFraction<=1.0f);
+		VectorAdvance(HorizontalHitSpot,horzontalTraceFraction*horzontalTraceFraction,goalSpot,goalSpot);//  VA(a,t,b,c)-> c := (1-t)a+tb
+#if 0
+		if ((bone.RagFlags & RAG_EFFECTOR) && (bone.RagFlags & RAG_BONE_LIGHTWEIGHT))
+		{ //new rule - don't even bother unless it's a lightweight effector
+			//rww - Factor object velocity into the final desired spot..
+			//We want the limbs with a "light" weight to drag behind the general mass.
+			//If we got here, we shouldn't be the pelvis or the root, so we should be
+			//fine to treat as lightweight. However, we can flag bones as being particularly
+			//light. They're given less downscale for the reduction factor.
+			vec3_t givenVelocity;
+			vec3_t vSpot;
+			trace_t vtr;
+			float vSpeed = 0;
+			float verticalSpeed = 0;
+			float vReductionFactor = 0.03f;
+			float verticalSpeedReductionFactor = 0.06f; //want this to be more obvious
+			float lwVReductionFactor = 0.1f;
+			float lwVerticalSpeedReductionFactor = 0.3f; //want this to be more obvious
+			
+
+			VectorCopy(params->velocity, givenVelocity);
+			vSpeed = VectorNormalize(givenVelocity);
+			vSpeed = -vSpeed; //go in the opposite direction of velocity
+
+			verticalSpeed = vSpeed;
+
+			if (bone.RagFlags & RAG_BONE_LIGHTWEIGHT)
+			{
+				vSpeed *= lwVReductionFactor;
+				verticalSpeed *= lwVerticalSpeedReductionFactor;
+			}
+			else
+			{
+				vSpeed *= vReductionFactor;
+				verticalSpeed *= verticalSpeedReductionFactor;
+			}
+
+			vSpot[0] = givenVelocity[0]*vSpeed;
+			vSpot[1] = givenVelocity[1]*vSpeed;
+			vSpot[2] = givenVelocity[2]*verticalSpeed;
+			VectorAdd(goalSpot, vSpot, vSpot);
+
+			if (vSpot[0] || vSpot[1] || vSpot[2])
+			{
+				Rag_Trace(&vtr, goalSpot, testMins, testMaxs, vSpot, ignoreNum, RAG_MASK, G2_NOCOLLIDE,0);
+				if (vtr.fraction == 1)
+				{
+					VectorCopy(vSpot, goalSpot);
+				}
+			}
+		}
+#endif
+
+		int k;
+		int		magicFactor12=0.8f; // dampening of velocity applied
+		int		magicFactor16=10.0f; // effect multiplier of velocity applied
+
+		if (iAmStartSolid)
+		{
+			magicFactor16 = 30.0f;
+		}
+
+		for (k=0;k<3;k++)
+		{
+			e.desiredDirection[k]=goalSpot[k]-e.currentOrigin[k];
+			e.desiredDirection[k]+=magicFactor16*bone.velocityEffector[k];
+			e.desiredDirection[k]+=flrand(-0.75f,0.75f)*flrand(-0.75f,0.75f);
+			bone.velocityEffector[k]*=magicFactor12;
+		}
+		VectorCopy(e.currentOrigin,bone.lastPosition); // last arg is dest
+	}
+	return anyStartSolid;
+}
+#else
+
+#if 0
+static inline int G2_RagIndexForBoneNum(int boneNum)
+{
+	for (int i = 0; i < numRags; i++)
+	{		
+		// these are used for affecting the end result
+		if (ragBoneData[i].boneNum == boneNum)
+		{
+			return i;
+		}
+	}
+
+	return -1;
+}
+#endif
+
+#ifdef _RAG_PRINT_TEST
+void G2_RagPrintMatrix(mdxaBone_t *mat)
+{
+	char x[1024];
+	x[0] = 0;
+	int n = 0;
+	while (n < 3)
+	{
+		int o = 0;
+		while (o < 4)
+		{
+            strcat(x, va("%f ", mat->matrix[n][o]));
+			o++;
+		}
+		n++;
+	}
+	strcat(x, "\n");
+	Com_Printf(x);
+}
+#endif
+
+extern mdxaBone_t		worldMatrix;
+void G2_RagGetBoneBasePoseMatrixLow(CGhoul2Info &ghoul2, int boneNum, mdxaBone_t &boneMatrix, mdxaBone_t &retMatrix, vec3_t scale);
+void G2_RagGetAnimMatrix(CGhoul2Info &ghoul2, const int boneNum, mdxaBone_t &matrix, const int frame);
+
+static inline void G2_RagGetWorldAnimMatrix(CGhoul2Info &ghoul2, boneInfo_t &bone, CRagDollUpdateParams *params, mdxaBone_t &retMatrix)
+{
+	static mdxaBone_t trueBaseMatrix, baseBoneMatrix;
+
+	//get matrix for the settleFrame to use as an ideal
+	G2_RagGetAnimMatrix(ghoul2, bone.boneNumber, trueBaseMatrix, params->settleFrame);
+	assert(bone.hasAnimFrameMatrix == params->settleFrame);
+
+	G2_RagGetBoneBasePoseMatrixLow(ghoul2, bone.boneNumber,
+		trueBaseMatrix, baseBoneMatrix, params->scale);
+
+	//Use params to multiply world coordinate/dir matrix into the
+	//bone matrix and give us a useable world position
+	Multiply_3x4Matrix(&retMatrix, &worldMatrix, &baseBoneMatrix);
+
+	assert(!_isnan(retMatrix.matrix[2][3]));
+}
+
+//get the current pelvis Z direction and the base anim matrix Z direction
+//so they can be compared and used to offset -rww
+void G2_GetRagBoneMatrixLow(CGhoul2Info &ghoul2, int boneNum, mdxaBone_t &retMatrix);
+void G2_GetBoltMatrixLow(CGhoul2Info &ghoul2,int boltNum,const vec3_t scale,mdxaBone_t &retMatrix);
+static inline void G2_RagGetPelvisLumbarOffsets(CGhoul2Info &ghoul2, CRagDollUpdateParams *params, vec3_t pos, vec3_t dir, vec3_t animPos, vec3_t animDir)
+{
+	static mdxaBone_t final;
+	static mdxaBone_t x;
+	static mdxaBone_t *unused1, *unused2;
+	//static vec3_t lumbarPos;
+
+	assert(ghoul2.animModel);
+	int boneIndex = G2_Find_Bone(ghoul2.animModel, ghoul2.mBlist, "pelvis");
+	assert(boneIndex != -1);
+
+	G2_RagGetWorldAnimMatrix(ghoul2, ghoul2.mBlist[boneIndex], params, final);
+	G2API_GiveMeVectorFromMatrix(&final, ORIGIN, animPos);
+	G2API_GiveMeVectorFromMatrix(&final, POSITIVE_X, animDir);
+
+#if 0
+	//We have the anim matrix pelvis pos now, so get the normal one as well
+	G2_GetBoneMatrixLow(ghoul2, boneIndex, params->scale, final, unused1, unused2);
+	G2API_GiveMeVectorFromMatrix(&final, ORIGIN, pos);
+	G2API_GiveMeVectorFromMatrix(&final, POSITIVE_X, dir);
+#else
+	//We have the anim matrix pelvis pos now, so get the normal one as well
+	//G2_GetRagBoneMatrixLow(ghoul2, boneIndex, x);
+	int bolt = G2_Add_Bolt(&ghoul2, ghoul2.mBltlist, ghoul2.mSlist, "pelvis");
+	G2_GetBoltMatrixLow(ghoul2, bolt, params->scale, x);
+	Multiply_3x4Matrix(&final, &worldMatrix, &x);
+	G2API_GiveMeVectorFromMatrix(&final, ORIGIN, pos);
+	G2API_GiveMeVectorFromMatrix(&final, POSITIVE_X, dir);
+#endif
+
+	/*
+	//now get lumbar
+	boneIndex = G2_Find_Bone(ghoul2.animModel, ghoul2.mBlist, "lower_lumbar");
+	assert(boneIndex != -1);
+
+	G2_RagGetWorldAnimMatrix(ghoul2, ghoul2.mBlist[boneIndex], params, final);
+	G2API_GiveMeVectorFromMatrix(&final, ORIGIN, lumbarPos);
+
+	VectorSubtract(animPos, lumbarPos, animDir);
+	VectorNormalize(animDir);
+
+	//We have the anim matrix lumbar dir now, so get the normal one as well
+	G2_GetBoneMatrixLow(ghoul2, boneIndex, params->scale, final, unused1, unused2);
+	G2API_GiveMeVectorFromMatrix(&final, ORIGIN, lumbarPos);
+
+	VectorSubtract(pos, lumbarPos, dir);
+	VectorNormalize(dir);
+	*/
+}
+
+static bool G2_RagDollSettlePositionNumeroTrois(CGhoul2Info_v &ghoul2V, const vec3_t currentOrg, CRagDollUpdateParams *params, int curTime)
+{ //now returns true if any bone was in solid, otherwise false
+	int ignoreNum = params->me;
+	static int i;
+	static vec3_t goalSpot;
+	static trace_t tr;
+	static trace_t solidTr;
+	static int k;
+	static const float velocityDampening = 1.0f;
+	static const float velocityMultiplier = 60.0f;
+	static vec3_t testMins;
+	static vec3_t testMaxs;
+	vec3_t velDir;
+	static bool startSolid;
+	bool anySolid = false;
+	static mdxaBone_t worldBaseMatrix;
+	static vec3_t parentOrigin;
+	static vec3_t basePos;
+	static vec3_t entScale;
+	static bool hasDaddy;
+	static bool hasBasePos;
+	static vec3_t animPelvisDir, pelvisDir, animPelvisPos, pelvisPos;
+
+	//Maybe customize per-bone?
+	static const float gravity = 3.0f;
+	static const float mass = 0.09f;
+	static const float bounce = 0.0f;//1.3f;
+	//Bouncing and stuff unfortunately does not work too well at the moment.
+	//Need to keep a seperate "physics origin" or make the filthy solve stuff
+	//better.
+
+	bool inAir = false;
+
+	if (params->velocity[0] || params->velocity[1] || params->velocity[2])
+	{
+		inAir = true;
+	}
+
+	if (!params->scale[0] && !params->scale[1] && !params->scale[2])
+	{
+		VectorSet(entScale, 1.0f, 1.0f, 1.0f);
+	}
+	else
+	{
+		VectorCopy(params->scale, entScale);
+	}
+
+	if (broadsword_ragtobase &&
+		broadsword_ragtobase->integer > 1)
+	{
+		//grab the pelvis directions to offset base positions for bones
+		G2_RagGetPelvisLumbarOffsets(ghoul2V[0], params, pelvisPos, pelvisDir, animPelvisPos,
+			animPelvisDir);
+
+		//don't care about the pitch offsets
+		pelvisDir[2] = 0;
+		animPelvisDir[2] = 0;
+
+		/*
+		vec3_t upelvisPos, uanimPelvisPos;
+		vec3_t blah;
+		VectorCopy(pelvisPos, upelvisPos);
+		VectorCopy(animPelvisPos, uanimPelvisPos);
+		upelvisPos[2] += 64;
+		uanimPelvisPos[2] += 64;
+
+		VectorMA(upelvisPos, 32.0f, pelvisDir, blah);
+		G2_RagDebugLine(upelvisPos, blah, 50, 0x00ff00, 1);
+		VectorMA(uanimPelvisPos, 32.0f, animPelvisDir, blah);
+		G2_RagDebugLine(uanimPelvisPos, blah, 50, 0xff0000, 1);
+		*/
+
+		//just convert to angles now, that's all we'll ever use them for
+		vectoangles(pelvisDir, pelvisDir);
+		vectoangles(animPelvisDir, animPelvisDir);
+	}
+
+	for (i = 0; i < numRags; i++)
+	{
+		boneInfo_t &bone = *ragBoneData[i];
+		SRagEffector &e = ragEffectors[i];
+
+		if (inAir)
+		{
+			bone.airTime = curTime + 30;
+		}
+
+		if (bone.RagFlags & RAG_PCJ_PELVIS)
+		{
+			VectorSet(goalSpot, params->position[0], params->position[1], (params->position[2]+DEFAULT_MINS_2)+((bone.radius*entScale[2])+2));
+
+			VectorSubtract(goalSpot, e.currentOrigin, desiredPelvisOffset);
+			haveDesiredPelvisOffset = true;
+			VectorCopy(e.currentOrigin, bone.lastPosition);
+			continue; 
+		}
+
+		if (!(bone.RagFlags & RAG_EFFECTOR))
+		{
+			continue; 
+		}
+
+		if (bone.hasOverGoal)
+		{ //api call was made to override the goal spot
+			VectorCopy(bone.overGoalSpot, goalSpot);
+			bone.solidCount = 0;
+			for (k = 0; k < 3; k++)
+			{
+				e.desiredDirection[k] = (goalSpot[k] - e.currentOrigin[k]);
+				e.desiredDirection[k] += (velocityMultiplier * bone.velocityEffector[k]);
+				bone.velocityEffector[k] *= velocityDampening;
+			}
+			VectorCopy(e.currentOrigin, bone.lastPosition);
+
+			continue;
+		}
+
+		VectorSet(testMins, -e.radius*entScale[0], -e.radius*entScale[1], -e.radius*entScale[2]);
+		VectorSet(testMaxs, e.radius*entScale[0], e.radius*entScale[1], e.radius*entScale[2]);
+
+		assert(ghoul2V[0].mBoneCache);
+
+		//get the parent bone's position
+		hasDaddy = false;
+		if (bone.boneNumber)
+		{
+			assert(ghoul2V[0].animModel);
+			assert(ghoul2V[0].aHeader);
+
+			if (bone.parentBoneIndex == -1)
+			{
+				mdxaSkel_t			*skel;
+				mdxaSkelOffsets_t	*offsets;
+				int bParentIndex, bParentListIndex = -1;
+
+				offsets = (mdxaSkelOffsets_t *)((byte *)ghoul2V[0].aHeader + sizeof(mdxaHeader_t));
+				skel = (mdxaSkel_t *)((byte *)ghoul2V[0].aHeader + sizeof(mdxaHeader_t) + offsets->offsets[bone.boneNumber]);
+
+				bParentIndex = skel->parent;
+
+				while (bParentIndex > 0)
+				{ //go upward through hierarchy searching for the first parent that is a rag bone
+					skel = (mdxaSkel_t *)((byte *)ghoul2V[0].aHeader + sizeof(mdxaHeader_t) + offsets->offsets[bParentIndex]);
+					bParentIndex = skel->parent;
+					bParentListIndex = G2_Find_Bone(ghoul2V[0].animModel, ghoul2V[0].mBlist, skel->name);
+
+					if (bParentListIndex != -1)
+					{
+						boneInfo_t &pbone = ghoul2V[0].mBlist[bParentListIndex];
+						if (pbone.flags & BONE_ANGLES_RAGDOLL)
+						{ //valid rag bone
+							break;
+						}
+					}
+
+					//didn't work out, reset to -1 again
+					bParentListIndex = -1;
+				}
+
+				bone.parentBoneIndex = bParentListIndex;
+			}
+
+			if (bone.parentBoneIndex != -1)
+			{
+				boneInfo_t &pbone = ghoul2V[0].mBlist[bone.parentBoneIndex];
+
+				if (pbone.flags & BONE_ANGLES_RAGDOLL)
+				{ //has origin calculated for us already
+					VectorCopy(ragEffectors[pbone.ragIndex].currentOrigin, parentOrigin);
+					hasDaddy = true;
+				}
+			}
+		}
+
+		//get the position this bone would be in if we were in the desired frame
+		hasBasePos = false;
+		if (broadsword_ragtobase &&
+			broadsword_ragtobase->integer)
+		{
+			vec3_t v, a;
+			float f;
+
+			G2_RagGetWorldAnimMatrix(ghoul2V[0], bone, params, worldBaseMatrix);
+			G2API_GiveMeVectorFromMatrix(&worldBaseMatrix, ORIGIN, basePos);
+
+			if (broadsword_ragtobase->integer > 1)
+			{
+				float fa = AngleNormalize180(animPelvisDir[YAW]-pelvisDir[YAW]);
+				float d = fa-bone.offsetRotation;
+
+				if (d > 16.0f ||
+					d < -16.0f)
+				{ //don't update unless x degrees away from the ideal to avoid moving goal spots too much if pelvis rotates
+					bone.offsetRotation = fa;
+				}
+				else
+				{
+					fa = bone.offsetRotation;
+				}
+				//Rotate the point around the pelvis based on the offsets between pelvis positions
+				VectorSubtract(basePos, animPelvisPos, v);
+				f = VectorLength(v);
+				vectoangles(v, a);
+				a[YAW] -= fa;
+				AngleVectors(a, v, 0, 0);
+				VectorNormalize(v);
+				VectorMA(animPelvisPos, f, v, basePos);
+
+				//re-orient the position of the bone to the current position of the pelvis
+				VectorSubtract(basePos, animPelvisPos, v);
+				//push the spots outward? (to stretch the skeleton more)
+				//v[0] *= 1.5f;
+				//v[1] *= 1.5f;
+				VectorAdd(pelvisPos, v, basePos);
+			}
+#if 0 //for debugging frame skeleton
+			mdxaSkel_t			*skel;
+			mdxaSkelOffsets_t	*offsets;
+
+			offsets = (mdxaSkelOffsets_t *)((byte *)ghoul2V[0].aHeader + sizeof(mdxaHeader_t));
+			skel = (mdxaSkel_t *)((byte *)ghoul2V[0].aHeader + sizeof(mdxaHeader_t) + offsets->offsets[bone.boneNumber]);
+
+			vec3_t pu;
+			VectorCopy(basePos, pu);
+			pu[2] += 32;
+			if (bone.boneNumber < 11)
+			{
+				G2_RagDebugLine(basePos, pu, 50, 0xff00ff, 1);
+			}
+			else if (skel->name[0] == 'l')
+			{
+				G2_RagDebugLine(basePos, pu, 50, 0xffff00, 1);
+			}
+			else if (skel->name[0] == 'r')
+			{
+				G2_RagDebugLine(basePos, pu, 50, 0xffffff, 1);
+			}
+			else
+			{
+				G2_RagDebugLine(basePos, pu, 50, 0x00ffff, 1);
+			}
+#endif
+			hasBasePos = true;
+		}
+
+		//Are we in solid?
+		if (hasDaddy)
+		{
+			Rag_Trace(&tr, e.currentOrigin, testMins, testMaxs, parentOrigin, ignoreNum, RAG_MASK, G2_NOCOLLIDE, 0);
+			//Rag_Trace(&tr, parentOrigin, testMins, testMaxs, e.currentOrigin, ignoreNum, RAG_MASK, G2_NOCOLLIDE, 0);
+		}
+		else
+		{
+			Rag_Trace(&tr, e.currentOrigin, testMins, testMaxs, params->position, ignoreNum, RAG_MASK, G2_NOCOLLIDE, 0);
+		}
+
+		if (tr.startsolid || tr.allsolid || tr.fraction != 1.0f)
+		{ //currently in solid, see what we can do about it
+			vec3_t vSub;
+
+			startSolid = true;
+			anySolid = true;
+
+			if (hasBasePos)// && bone.solidCount < 32)
+			{ //only go to the base pos for slightly in solid bones
+#if 0 //over-compensation
+				float fl;
+				float floorBase;
+
+				VectorSubtract(basePos, e.currentOrigin, vSub);
+				fl = VectorNormalize(vSub);
+				VectorMA(e.currentOrigin, /*fl*8.0f*/64.0f, vSub, goalSpot);
+
+				floorBase = ((params->position[2]-23)-testMins[2])+8;
+
+				if (goalSpot[2] > floorBase)
+				{
+					goalSpot[2] = floorBase;
+				}
+#else //just use the spot directly
+				VectorCopy(basePos, goalSpot);
+				goalSpot[2] = (params->position[2]-23)-testMins[2];
+#endif
+				//Com_Printf("%i: %f %f %f\n", bone.boneNumber, basePos[0], basePos[1], basePos[2]);
+			}
+			else
+			{ //if deep in solid want to try to rise up out of solid before hinting back to base
+				VectorSubtract(e.currentOrigin, params->position, vSub);
+				VectorNormalize(vSub);
+				VectorMA(params->position, 40.0f, vSub, goalSpot);
+
+				//should be 1 unit above the ground taking bounding box sizes into account
+				goalSpot[2] = (params->position[2]-23)-testMins[2];
+			}
+
+			//Trace from the entity origin in the direction between the origin and current bone position to
+			//find a good eventual goal position
+			Rag_Trace(&tr, params->position, testMins, testMaxs, goalSpot, params->me, RAG_MASK, G2_NOCOLLIDE, 0);
+			VectorCopy(tr.endpos, goalSpot);
+		}
+		else
+		{
+			startSolid = false;
+
+#if 1 //do hinting?
+			//Hint the bone back to the base origin
+			if (hasDaddy || hasBasePos)
+			{
+				if (hasBasePos)
+				{
+					VectorSubtract(basePos, e.currentOrigin, velDir);					
+				}
+				else
+				{
+					VectorSubtract(e.currentOrigin, parentOrigin, velDir);
+				}
+			}
+			else
+			{
+				VectorSubtract(e.currentOrigin, params->position, velDir);
+			}
+
+			if (VectorLength(velDir) > 2.0f)
+			{ //don't bother if already close
+				VectorNormalize(velDir);
+				VectorScale(velDir, 8.0f, velDir);
+				velDir[2] = 0; //don't want to nudge on Z, the gravity will take care of things.
+				VectorAdd(bone.epVelocity, velDir, bone.epVelocity);
+			}
+#endif
+
+			//Factor the object's velocity into the bone's velocity, by pushing the bone
+			//opposite the velocity to give the apperance the lighter limbs are being "dragged"
+			//behind those of greater mass.
+			if (bone.RagFlags & RAG_BONE_LIGHTWEIGHT)
+			{
+				vec3_t vel;
+				float vellen;
+
+				VectorCopy(params->velocity, vel);
+
+				//Scale down since our velocity scale is different from standard game physics
+				VectorScale(vel, 0.5f, vel);
+
+				vellen = VectorLength(vel);
+
+				if (vellen > 64.0f)
+				{ //cap it off
+					VectorScale(vel, 64.0f/vellen, vel);
+				}
+
+				//Invert the velocity so we go opposite the heavier parts and drag behind
+				VectorInverse(vel);
+
+				if (vel[2])
+				{ //want to override entirely instead then
+					VectorCopy(vel, bone.epVelocity);
+				}
+				else
+				{
+					VectorAdd(bone.epVelocity, vel, bone.epVelocity);
+				}
+			}
+
+			//We're not in solid so we can apply physics freely now.
+			if (!G2_ApplyRealBonePhysics(bone, e, params, goalSpot, testMins, testMaxs,
+				gravity, mass, bounce))
+			{ //if this is the case then somehow we failed to apply physics/get a good goal spot, just use the ent origin
+				VectorCopy(params->position, goalSpot);
+			}
+		}
+
+		//Set this now so we know what to do for angle limiting
+		if (startSolid)
+		{
+			bone.solidCount++;
+#if 0
+#ifndef DEDICATED
+			if (cgvm && bone.solidCount > 8)
+			{ //make a callback and see if the cgame wants to help us out
+				Rag_Trace(&solidTr, params->position, testMins, testMaxs, e.currentOrigin, ignoreNum, RAG_MASK, G2_NOCOLLIDE, 0);
+
+				if (solidTr.fraction != 1.0f &&
+					(solidTr.plane.normal[0] || solidTr.plane.normal[1]) &&
+					(solidTr.plane.normal[2] < 0.1f || solidTr.plane.normal[2] > -0.1f))// && //don't do anything against flat around
+				//	e.currentOrigin[2] > pelvisPos[2])
+				{
+					ragCallbackBoneInSolid_t *callData = (ragCallbackBoneInSolid_t *)cl.mSharedMemory;
+
+					VectorCopy(e.currentOrigin, callData->bonePos);
+					callData->entNum = params->me;
+					callData->solidCount = bone.solidCount;
+
+					VM_Call(cgvm, CG_RAG_CALLBACK, RAG_CALLBACK_BONEINSOLID);
+				}
+			}
+#endif
+#endif
+
+#ifdef _DEBUG_BONE_NAMES
+			if (bone.solidCount > 64)
+			{
+				char *debugBoneName = G2_Get_Bone_Name(&ghoul2V[0], ghoul2V[0].mBlist, bone.boneNumber);
+				vec3_t absmin, absmax;
+
+				assert(debugBoneName);
+
+				Com_Printf("High bone (%s, %i) solid count: %i\n", debugBoneName, bone.boneNumber, bone.solidCount);
+
+				VectorAdd(e.currentOrigin, testMins, absmin);
+				VectorAdd(e.currentOrigin, testMaxs, absmax);
+				G2_RagDebugBox(absmin, absmax, 50);
+
+				G2_RagDebugLine(e.currentOrigin, goalSpot, 50, 0x00ff00, 1);
+			}
+#endif
+		}
+		else
+		{
+			bone.solidCount = 0;
+		}
+
+#if 0 //standard goalSpot capping?
+		//unless we are really in solid, we should keep adjustments minimal
+        if (/*bone.epGravFactor < 64 &&*/ bone.solidCount < 2 &&
+			!inAir)
+		{
+			vec3_t moveDist;
+			const float extent = 32.0f;
+			float len;
+
+			VectorSubtract(goalSpot, e.currentOrigin, moveDist);
+			len = VectorLength(moveDist);
+
+			if (len > extent)
+			{ //if greater than the extent then scale the vector down to the extent and factor it back into the goalspot
+                VectorScale(moveDist, extent/len, moveDist);
+				VectorAdd(e.currentOrigin, moveDist, goalSpot);
+			}
+		}
+#endif
+
+		//Set the desired direction based on the goal position and other factors.
+		for (k = 0; k < 3; k++)
+		{
+			e.desiredDirection[k] = (goalSpot[k] - e.currentOrigin[k]);
+
+			if (broadsword_dircap &&
+				broadsword_dircap->value)
+			{
+				float cap = broadsword_dircap->value;
+
+				if (bone.solidCount > 5)
+				{
+					float solidFactor = bone.solidCount*0.2f;
+
+					if (solidFactor > 16.0f)
+					{ //don't go too high or something ugly might happen
+						solidFactor = 16.0f;
+					}
+
+					e.desiredDirection[k] *= solidFactor;
+					cap *= 8;
+				}
+
+				if (e.desiredDirection[k] > cap)
+				{
+					e.desiredDirection[k] = cap;
+				}
+				else if (e.desiredDirection[k] < -cap)
+				{
+					e.desiredDirection[k] = -cap;
+				}
+			}
+
+			e.desiredDirection[k] += (velocityMultiplier * bone.velocityEffector[k]);
+			e.desiredDirection[k] += (flrand(-0.75f, 0.75f) * flrand(-0.75f, 0.75f));
+
+			bone.velocityEffector[k] *= velocityDampening;
+		}
+		VectorCopy(e.currentOrigin, bone.lastPosition);
+	}
+
+	return anySolid;
+}
+#endif
+
+static float AngleNormZero(float theta)
+{
+	float ret=fmodf(theta,360.0f);
+	if (ret<-180.0f)
+	{
+		ret+=360.0f;
+	}
+	else if (ret>180.0f)
+	{
+		ret-=360.0f;
+	}
+	assert(ret>=-180.0f&&ret<=180.0f);
+	return ret;
+}
+
+static inline void G2_BoneSnap(CGhoul2Info_v &ghoul2V, boneInfo_t &bone, CRagDollUpdateParams *params)
+{
+#ifdef DEDICATED
+	return;
+#else
+	if (!cgvm || !params)
+	{
+		return;
+	}
+
+	ragCallbackBoneSnap_t *callData = (ragCallbackBoneSnap_t *)cl.mSharedMemory;
+
+	callData->entNum = params->me;
+	strcpy(callData->boneName, G2_Get_Bone_Name(&ghoul2V[0], ghoul2V[0].mBlist, bone.boneNumber));
+
+	VM_Call(cgvm, CG_RAG_CALLBACK, RAG_CALLBACK_BONESNAP);
+#endif
+}
+
+static void G2_RagDollSolve(CGhoul2Info_v &ghoul2V,int g2Index,float decay,int frameNum,const vec3_t currentOrg,bool limitAngles,CRagDollUpdateParams *params)
+{
+
+	int i;
+
+	CGhoul2Info &ghoul2=ghoul2V[g2Index];
+
+	mdxaBone_t N;
+	mdxaBone_t P;
+	mdxaBone_t temp1;
+	mdxaBone_t temp2;
+	mdxaBone_t curRot;
+	mdxaBone_t curRotInv;
+	mdxaBone_t Gs[3];
+	mdxaBone_t Enew[3];
+
+	assert(ghoul2.mFileName[0]);
+	boneInfo_v &blist = ghoul2.mBlist;
+
+
+	// END this is the objective function thing
+	for (i=0;i<numRags;i++)
+	{		
+		// these are used for affecting the end result
+		boneInfo_t &bone=*ragBoneData[i];
+		if (!(bone.RagFlags & RAG_PCJ))
+		{
+			continue; // not an active ragdoll PCJ
+		}
+						/* the situation is thus. (the dependent bone is in essence an effector)
+
+							The effector true bone matrix is:
+								Ecur = ragBones[depIndex] =
+									EntToWorld * [skeletal heirachy1] * 
+									MyAnimMatrix * ragBasepose[i] * current_rot_matrix * ragBaseposeInv[i] *
+									[skeletal heirachy2] * EffectorAnimMatrix * ragBasepose[depIndex]
+
+						My ( sub-i) true bone matrix is:
+								M = ragBones[i] = EntToWorld * [skeletal heirachry1] * 
+								MyAnimMatrix * ragBasepose[i] * current_rot_matrix * ragBaseposeInv[i] * ragBasepose[i]
+
+							Simplifies to:
+								M = ragBones[i] = EntToWorld * [skeletal heirachry1] * 
+								MyAnimMatrix * ragBasepose[i] * current_rot_matrix
+
+
+							Enew is:
+
+								Enew = M * 
+									inv(current_rot_matrix) * ragBaseposeInv[i] *
+									ragBasepose[i] * new_rot_matrix * ragBaseposeInv[i] *
+									inv(M*ragBaseposeInv[i]) * Ecur
+
+							We can simplify a bit:
+
+								Enew = M * 
+									inv(current_rot_matrix) * ragBaseposeInv[i] *
+									ragBasepose[i] * new_rot_matrix * ragBaseposeInv[i] *
+									ragBasepose[i] * inv(M) * Ecur
+
+								Enew = 
+									M * inv(current_rot_matrix) * 
+									new_rot_matrix * inv(M) * Ecur
+
+							We define P to be:
+								P = M * inv(current_rot_matrix)
+
+							We define N to be:
+								N = inv(M) 
+
+							then it is just:
+
+								Enew= P * new_rot_matrix * N * Ecur
+
+							Ri=new_rot_matrix (for each euler angle)
+							we are gonna use three R's, so will will precompute them as Gi = P * Ri * N
+
+
+							and then Enewi= Gi * Ecur
+
+							we are gonna evaluate Enewi for "goodness" and accumulate changes in delAngles
+
+						*/
+
+		Inverse_Matrix(&ragBones[i], &N);  // dest 2nd arg
+
+		int k;
+		vec3_t tAngles;
+		VectorCopy(bone.currentAngles,tAngles);
+		Create_Matrix(tAngles,&curRot);  //dest 2nd arg
+		Inverse_Matrix(&curRot,&curRotInv);  // dest 2nd arg
+
+		Multiply_3x4Matrix(&P,&ragBones[i],&curRotInv); //dest first arg
+
+
+
+		if (bone.RagFlags & RAG_PCJ_MODEL_ROOT)
+		{
+			if (haveDesiredPelvisOffset)
+			{
+				float	magicFactor12=0.25f; // dampfactor for pelvis pos
+				float	magicFactor13=0.20f; //controls the speed of the gradient descent (pelvis pos)
+				assert( !_isnan(bone.ragOverrideMatrix.matrix[2][3]));
+				vec3_t deltaInEntitySpace;
+				TransformPoint(desiredPelvisOffset,deltaInEntitySpace,&N); // dest middle arg
+				for (k=0;k<3;k++)
+				{
+					float moveTo=bone.velocityRoot[k]+deltaInEntitySpace[k]*magicFactor13;
+					bone.velocityRoot[k]=(bone.velocityRoot[k]-moveTo)*magicFactor12+moveTo;
+					/*
+					if (bone.velocityRoot[k]>50.0f)
+					{
+						bone.velocityRoot[k]=50.0f;
+					}
+					if (bone.velocityRoot[k]<-50.0f)
+					{
+						bone.velocityRoot[k]=-50.0f;
+					}
+					*/
+					//No -rww
+					bone.ragOverrideMatrix.matrix[k][3]=bone.velocityRoot[k];
+				}
+			}
+		}
+		else
+		{ 
+			vec3_t delAngles;
+			VectorClear(delAngles);
+
+			for (k=0;k<3;k++)
+			{
+				tAngles[k]+=0.5f;
+				Create_Matrix(tAngles,&temp2);  //dest 2nd arg
+				tAngles[k]-=0.5f;
+				Multiply_3x4Matrix(&temp1,&P,&temp2); //dest first arg
+				Multiply_3x4Matrix(&Gs[k],&temp1,&N); //dest first arg
+
+			}
+
+			int allSolidCount = 0;//bone.solidCount;
+
+			// fixme precompute this
+			int numDep=G2_GetBoneDependents(ghoul2,bone.boneNumber,tempDependents,MAX_BONES_RAG);
+			int j;
+			int numRagDep=0;
+			for (j=0;j<numDep;j++)
+			{
+				//fixme why do this for the special roots?
+				if (!(tempDependents[j]<rag.size()&&rag[tempDependents[j]]))
+				{
+					continue;
+				}
+				int depIndex=rag[tempDependents[j]]->ragIndex;
+				assert(depIndex>i); // these are supposed to be topologically sorted
+				assert(ragBoneData[depIndex]);
+				boneInfo_t &depBone=*ragBoneData[depIndex];
+				if (depBone.RagFlags & RAG_EFFECTOR)						// rag doll effector
+				{
+					// this is a dependent of me, and also a rag
+					numRagDep++;
+					for (k=0;k<3;k++)
+					{
+						Multiply_3x4Matrix(&Enew[k],&Gs[k],&ragBones[depIndex]); //dest first arg
+						vec3_t tPosition;
+						tPosition[0]=Enew[k].matrix[0][3];
+						tPosition[1]=Enew[k].matrix[1][3];
+						tPosition[2]=Enew[k].matrix[2][3];
+
+						vec3_t change;
+						VectorSubtract(tPosition,ragEffectors[depIndex].currentOrigin,change); // dest is last arg
+						float goodness=DotProduct(change,ragEffectors[depIndex].desiredDirection);
+						assert( !_isnan(goodness));
+						goodness*=depBone.weight;
+						delAngles[k]+=goodness; // keep bigger stuff more out of wall or something
+						assert( !_isnan(delAngles[k]));
+					}
+					allSolidCount += depBone.solidCount;
+				}
+			}
+
+			//bone.solidCount = allSolidCount;
+			allSolidCount += bone.solidCount;
+
+			VectorCopy(bone.currentAngles,bone.lastAngles);
+			//		Update angles
+			float	magicFactor9=0.75f; // dampfactor for angle changes
+			float	magicFactor1=0.40f; //controls the speed of the gradient descent
+			float	magicFactor32 = 1.5f;
+			float recip=0.0f;
+			if (numRagDep)
+			{
+				recip=sqrt(4.0f/float(numRagDep));
+			}
+
+			if (allSolidCount > 32)
+			{
+				magicFactor1 = 0.6f;
+			}
+			else if (allSolidCount > 10)
+			{
+				magicFactor1 = 0.5f;
+			}
+
+			if (bone.overGradSpeed)
+			{ //api call was made to specify a speed for this bone
+				magicFactor1 = bone.overGradSpeed;
+			}
+
+			float fac=decay*recip*magicFactor1;
+			assert(fac>=0.0f);
+#if 0
+			if (bone.RagFlags & RAG_PCJ_PELVIS) 
+			{
+				magicFactor9=.85f; // we don't want this swinging radically, make the whole thing kindof unstable
+			}
+#endif
+			if (ragState==ERS_DYNAMIC)
+			{
+				magicFactor9=.85f; // we don't want this swinging radically, make the whole thing kindof unstable
+			}
+
+#if 1 //constraint breaks?
+			if (bone.RagFlags & RAG_UNSNAPPABLE)
+			{
+				magicFactor32 = 1.0f;
+			}
+#endif
+
+			for (k=0;k<3;k++)
+			{
+				bone.currentAngles[k]+=delAngles[k]*fac;
+
+				bone.currentAngles[k]=(bone.lastAngles[k]-bone.currentAngles[k])*magicFactor9 + bone.currentAngles[k];
+				bone.currentAngles[k]=AngleNormZero(bone.currentAngles[k]);
+//	bone.currentAngles[k]=flrand(bone.minAngles[k],bone.maxAngles[k]);
+#if 1 //constraint breaks?
+				if (limitAngles && ( allSolidCount < 32 || (bone.RagFlags & RAG_UNSNAPPABLE) )) //32 tries and still in solid? Then we'll let you move freely
+#else
+				if (limitAngles)
+#endif
+				{
+					if (!bone.snapped || (bone.RagFlags & RAG_UNSNAPPABLE))
+					{
+						//magicFactor32 += (allSolidCount/32);
+
+						if (bone.currentAngles[k]>bone.maxAngles[k]*magicFactor32)
+						{
+							bone.currentAngles[k]=bone.maxAngles[k]*magicFactor32;
+						}
+						if (bone.currentAngles[k]<bone.minAngles[k]*magicFactor32)
+						{
+							bone.currentAngles[k]=bone.minAngles[k]*magicFactor32;
+						}
+					}
+				}
+			}
+
+			bool isSnapped = false;
+			for (k=0;k<3;k++)
+			{
+				if (bone.currentAngles[k]>bone.maxAngles[k]*magicFactor32)
+				{
+					isSnapped = true;
+					break;
+				}
+				if (bone.currentAngles[k]<bone.minAngles[k]*magicFactor32)
+				{
+					isSnapped = true;
+					break;
+				}
+			}
+
+			if (isSnapped != bone.snapped)
+			{
+				G2_BoneSnap(ghoul2V, bone, params);
+				bone.snapped = isSnapped;
+			}
+
+			Create_Matrix(bone.currentAngles,&temp1);
+			Multiply_3x4Matrix(&temp2,&temp1,bone.baseposeInv);
+			Multiply_3x4Matrix(&bone.ragOverrideMatrix,bone.basepose, &temp2);
+			assert( !_isnan(bone.ragOverrideMatrix.matrix[2][3]));
+		}
+		G2_Generate_MatrixRag(blist,ragBlistIndex[bone.boneNumber]);
+	}
+}
+
+static void G2_IKReposition(const vec3_t currentOrg,CRagDollUpdateParams *params)
+{
+	int i;
+
+	assert(params);
+
+	for (i=0;i<numRags;i++)
+	{
+		boneInfo_t &bone=*ragBoneData[i];
+		SRagEffector &e=ragEffectors[i];
+
+		if (!(bone.RagFlags & RAG_EFFECTOR))
+		{
+			continue; 
+		}
+		
+		//Most effectors are not going to be PCJ, so this is not appplicable.
+		//The actual desired angle of the PCJ is factored around the desired
+		//directions of the effectors which are dependant on it.
+		/*
+		if (!(bone.RagFlags & RAG_PCJ_IK_CONTROLLED))
+		{
+			continue; 
+		}
+		*/
+
+		int k;
+		float		magicFactor12=0.8f; // dampening of velocity applied
+		float		magicFactor16=10.0f; // effect multiplier of velocity applied
+		for (k=0;k<3;k++)
+		{
+			e.desiredDirection[k]=bone.ikPosition[k]-e.currentOrigin[k];
+			e.desiredDirection[k]+=magicFactor16*bone.velocityEffector[k];
+			e.desiredDirection[k]+=flrand(-0.75f,0.75f)*flrand(-0.75f,0.75f);
+			bone.velocityEffector[k]*=magicFactor12;
+		}
+		VectorCopy(e.currentOrigin,bone.lastPosition); // last arg is dest
+	}
+}
+
+static void G2_IKSolve(CGhoul2Info_v &ghoul2V,int g2Index,float decay,int frameNum,const vec3_t currentOrg,bool limitAngles)
+{
+	int i;
+
+	CGhoul2Info &ghoul2 = ghoul2V[g2Index];
+
+	mdxaBone_t N;
+	mdxaBone_t P;
+	mdxaBone_t temp1;
+	mdxaBone_t temp2;
+	mdxaBone_t curRot;
+	mdxaBone_t curRotInv;
+	mdxaBone_t Gs[3];
+	mdxaBone_t Enew[3];
+
+	assert(ghoul2.mFileName[0]);
+	boneInfo_v &blist = ghoul2.mBlist;
+
+	// END this is the objective function thing
+	for (i = 0; i < numRags; i++)
+	{		
+		// these are used for affecting the end result
+		boneInfo_t &bone = *ragBoneData[i];
+
+		if (bone.RagFlags & RAG_PCJ_MODEL_ROOT)
+		{
+			continue;
+		}
+
+		if (!(bone.RagFlags & RAG_PCJ_IK_CONTROLLED))
+		{
+			continue;
+		}
+
+		Inverse_Matrix(&ragBones[i], &N);  // dest 2nd arg
+		
+		int k;
+		vec3_t tAngles;
+		VectorCopy(bone.currentAngles, tAngles);
+		Create_Matrix(tAngles, &curRot);  //dest 2nd arg
+		Inverse_Matrix(&curRot, &curRotInv);  // dest 2nd arg
+
+		Multiply_3x4Matrix(&P, &ragBones[i], &curRotInv); //dest first arg
+
+
+		vec3_t delAngles;
+		VectorClear(delAngles);
+
+		for (k = 0; k < 3; k++)
+		{
+			tAngles[k] += 0.5f;
+			Create_Matrix(tAngles, &temp2);  //dest 2nd arg
+			tAngles[k] -= 0.5f;
+			Multiply_3x4Matrix(&temp1, &P, &temp2); //dest first arg
+			Multiply_3x4Matrix(&Gs[k], &temp1, &N); //dest first arg
+		}
+
+		// fixme precompute this
+		int numDep=G2_GetBoneDependents(ghoul2,bone.boneNumber,tempDependents,MAX_BONES_RAG);
+		int j;
+		int numRagDep=0;
+		for (j=0;j<numDep;j++)
+		{
+			//fixme why do this for the special roots?
+			if (!(tempDependents[j]<rag.size()&&rag[tempDependents[j]]))
+			{
+				continue;
+			}
+			int depIndex=rag[tempDependents[j]]->ragIndex;
+			if (!ragBoneData[depIndex])
+			{
+				continue;
+			}
+			boneInfo_t &depBone=*ragBoneData[depIndex];
+
+			if (depBone.RagFlags & RAG_EFFECTOR)
+			{
+				// this is a dependent of me, and also a rag
+				numRagDep++;
+				for (k=0;k<3;k++)
+				{
+					Multiply_3x4Matrix(&Enew[k],&Gs[k],&ragBones[depIndex]); //dest first arg
+					vec3_t tPosition;
+					tPosition[0]=Enew[k].matrix[0][3];
+					tPosition[1]=Enew[k].matrix[1][3];
+					tPosition[2]=Enew[k].matrix[2][3];
+
+					vec3_t change;
+					VectorSubtract(tPosition,ragEffectors[depIndex].currentOrigin,change); // dest is last arg
+					float goodness=DotProduct(change,ragEffectors[depIndex].desiredDirection);
+					assert( !_isnan(goodness));
+					goodness*=depBone.weight;
+					delAngles[k]+=goodness; // keep bigger stuff more out of wall or something
+					assert( !_isnan(delAngles[k]));
+				}
+			}
+		}
+
+		VectorCopy(bone.currentAngles, bone.lastAngles);
+
+		//		Update angles
+		float	magicFactor9 = 0.75f; // dampfactor for angle changes
+		float	magicFactor1 = bone.ikSpeed; //controls the speed of the gradient descent
+		float	magicFactor32 = 1.0f;
+		float	recip = 0.0f;
+		bool	freeThisBone = false;
+
+		if (!magicFactor1)
+		{
+			magicFactor1 = 0.40f;
+		}
+	
+		recip = sqrt(4.0f/1.0f);
+
+		float fac = (decay*recip*magicFactor1);
+		assert(fac >= 0.0f);
+
+		if (ragState == ERS_DYNAMIC)
+		{
+			magicFactor9 = 0.85f; // we don't want this swinging radically, make the whole thing kindof unstable
+		}
+
+
+		if (!bone.maxAngles[0] && !bone.maxAngles[1] && !bone.maxAngles[2] &&
+			!bone.minAngles[0] && !bone.minAngles[1] && !bone.minAngles[2])
+		{
+			freeThisBone = true;
+		}
+
+		for (k = 0; k < 3; k++)
+		{
+			bone.currentAngles[k] += delAngles[k]*fac;
+
+			bone.currentAngles[k] = (bone.lastAngles[k]-bone.currentAngles[k])*magicFactor9 + bone.currentAngles[k];
+			bone.currentAngles[k] = AngleNormZero(bone.currentAngles[k]);
+			if (limitAngles && !freeThisBone)
+			{
+				if (bone.currentAngles[k] > bone.maxAngles[k]*magicFactor32)
+				{
+					bone.currentAngles[k] = bone.maxAngles[k]*magicFactor32;
+				}
+				if (bone.currentAngles[k] < bone.minAngles[k]*magicFactor32)
+				{
+					bone.currentAngles[k] = bone.minAngles[k]*magicFactor32;
+				}
+			}
+		}
+		Create_Matrix(bone.currentAngles, &temp1);
+		Multiply_3x4Matrix(&temp2, &temp1, bone.baseposeInv);
+		Multiply_3x4Matrix(&bone.ragOverrideMatrix, bone.basepose, &temp2);
+		assert( !_isnan(bone.ragOverrideMatrix.matrix[2][3]));
+
+		G2_Generate_MatrixRag(blist, ragBlistIndex[bone.boneNumber]);
+	}
+}
+
+static void G2_DoIK(CGhoul2Info_v &ghoul2V,int g2Index,CRagDollUpdateParams *params)
+{
+	int i;
+
+	if (!params)
+	{
+		assert(0);
+		return;
+	}
+
+	int frameNum=G2API_GetTime(0);
+	CGhoul2Info &ghoul2=ghoul2V[g2Index];
+	assert(ghoul2.mFileName[0]);
+
+	float decay=1.0f;
+	bool resetOrigin=false;
+	bool anyRendered=false;
+
+	int iters = 12; //since we don't trace or anything, we can afford this.
+
+	if (iters)
+	{
+		if (!G2_RagDollSetup(ghoul2,frameNum,resetOrigin,params->position,anyRendered))
+		{
+			return;
+		}
+
+		// ok, now our data structures are compact and set up in topological order
+		for (i=0;i<iters;i++)
+		{
+			G2_RagDollCurrentPosition(ghoul2V,g2Index,frameNum,params->angles,params->position,params->scale);
+
+			G2_IKReposition(params->position, params);
+
+			G2_IKSolve(ghoul2V,g2Index,decay*2.0f,frameNum,params->position,true);
+		}
+	}
+
+	if (params->me != ENTITYNUM_NONE)
+	{
+		G2_RagDollCurrentPosition(ghoul2V,g2Index,frameNum,params->angles,params->position,params->scale);
+	}
+}
+
+//rww - cut out the entire non-ragdoll section of this..
+void G2_Animate_Bone_List(CGhoul2Info_v &ghoul2, const int currentTime, const int index,CRagDollUpdateParams *params)
+{
+	int i;
+	bool anyRagDoll=false;
+	bool anyIK = false;
+	for(i=0; i<ghoul2[index].mBlist.size(); i++)
+	{
+		if (ghoul2[index].mBlist[i].boneNumber != -1)
+		{
+			if (ghoul2[index].mBlist[i].flags & BONE_ANGLES_RAGDOLL)
+			{
+				if (ghoul2[index].mBlist[i].RagFlags & RAG_PCJ_IK_CONTROLLED)
+				{
+					anyIK = true;
+				}
+				anyRagDoll=true;
+
+				if (anyIK && anyRagDoll)
+				{
+					break;
+				}
+			}
+		}
+	}
+	if (!index&&params)
+	{
+		if (anyIK)
+		{ //we use ragdoll params so we know what our current position, etc. is.
+			G2_DoIK(ghoul2, 0, params);
+		}
+		else
+		{
+			G2_RagDoll(ghoul2,0,params,currentTime);
+		}
+	}
+}
+//rww - RAGDOLL_END
+
+static int G2_Set_Bone_Angles_IK(
+	CGhoul2Info &ghoul2,
+	const mdxaHeader_t *mod_a,
+	boneInfo_v &blist, 
+	const char *boneName,
+	const int flags,
+	const float radius,
+	const vec3_t angleMin=0,
+	const vec3_t angleMax=0,
+	const int blendTime=500)
+{
+	int			index = G2_Find_Bone_Rag(&ghoul2, blist, boneName);
+
+	if (index == -1)
+	{
+		index = G2_Add_Bone(ghoul2.animModel, blist, boneName);
+	}
+	if (index != -1)
+	{
+		boneInfo_t &bone=blist[index];
+		bone.flags |= BONE_ANGLES_IK;
+		bone.flags &= ~BONE_ANGLES_RAGDOLL;
+
+		bone.ragStartTime=G2API_GetTime(0);
+		bone.radius=radius;
+		bone.weight=1.0f;
+
+		if (angleMin&&angleMax)
+		{
+			VectorCopy(angleMin,bone.minAngles);
+			VectorCopy(angleMax,bone.maxAngles);
+		}
+		else
+		{
+			VectorCopy(bone.currentAngles,bone.minAngles); // I guess this isn't a rag pcj then
+			VectorCopy(bone.currentAngles,bone.maxAngles);
+		}
+		if (!bone.lastTimeUpdated)
+		{
+			static mdxaBone_t		id = 
+			{ 
+				1.0f, 0.0f, 0.0f, 0.0f,
+				0.0f, 1.0f, 0.0f, 0.0f,
+				0.0f, 0.0f, 1.0f, 0.0f
+			};
+			memcpy(&bone.ragOverrideMatrix,&id, sizeof(mdxaBone_t));
+			VectorClear(bone.anglesOffset);
+			VectorClear(bone.positionOffset);
+			VectorClear(bone.velocityEffector);  // this is actually a velocity now
+			VectorClear(bone.velocityRoot);  // this is actually a velocity now
+			VectorClear(bone.lastPosition);
+			VectorClear(bone.lastShotDir);
+			bone.lastContents=0;
+			// if this is non-zero, we are in a dynamic state
+			bone.firstCollisionTime=bone.ragStartTime;
+			// if this is non-zero, we are in a settling state
+			bone.restTime=0;
+			// if they are both zero, we are in a settled state
+
+			bone.firstTime=0;
+
+			bone.RagFlags=flags;
+			bone.DependentRagIndexMask=0;
+
+			G2_Generate_MatrixRag(blist,index); // set everything to th id
+
+			VectorClear(bone.currentAngles);
+			VectorCopy(bone.currentAngles,bone.lastAngles);
+		}
+	}
+	return index;
+}
+
+void G2_InitIK(CGhoul2Info_v &ghoul2V, sharedRagDollUpdateParams_t *parms, int time, const mdxaHeader_t *mod_a, int model)
+{
+	CGhoul2Info &ghoul2=ghoul2V[model];
+	int curTime=time;
+	boneInfo_v &blist = ghoul2.mBlist;
+
+	G2_GenerateWorldMatrix(parms->angles, parms->position);
+	G2_ConstructGhoulSkeleton(ghoul2V, curTime, false, parms->scale);
+
+	// new base anim, unconscious flop
+	int pcjFlags;
+#if 0
+	vec3_t pcjMin, pcjMax;
+	VectorClear(pcjMin);
+	VectorClear(pcjMax);
+
+	pcjFlags=RAG_PCJ|RAG_PCJ_POST_MULT;//|RAG_EFFECTOR;
+
+	G2_Set_Bone_Angles_IK(ghoul2, mod_a,blist,"model_root",RAG_PCJ_MODEL_ROOT|RAG_PCJ,10.0f,pcjMin,pcjMax,100);
+	G2_Set_Bone_Angles_IK(ghoul2, mod_a,blist,"pelvis",RAG_PCJ_PELVIS|RAG_PCJ|RAG_PCJ_POST_MULT,10.0f,pcjMin,pcjMax,100);
+
+	G2_Set_Bone_Angles_IK(ghoul2, mod_a,blist,"lower_lumbar",pcjFlags,10.0f,pcjMin,pcjMax,500);
+	G2_Set_Bone_Angles_IK(ghoul2, mod_a,blist,"upper_lumbar",pcjFlags,10.0f,pcjMin,pcjMax,500);
+	G2_Set_Bone_Angles_IK(ghoul2, mod_a,blist,"thoracic",pcjFlags|RAG_EFFECTOR,12.0f,pcjMin,pcjMax,500);
+	G2_Set_Bone_Angles_IK(ghoul2, mod_a,blist,"cranium",pcjFlags,6.0f,pcjMin,pcjMax,500);
+	G2_Set_Bone_Angles_IK(ghoul2, mod_a,blist,"rhumerus",pcjFlags,4.0f,pcjMin,pcjMax,500);
+	G2_Set_Bone_Angles_IK(ghoul2, mod_a,blist,"lhumerus",pcjFlags,4.0f,pcjMin,pcjMax,500);
+	G2_Set_Bone_Angles_IK(ghoul2, mod_a,blist,"rradius",pcjFlags,3.0f,pcjMin,pcjMax,500);
+	G2_Set_Bone_Angles_IK(ghoul2, mod_a,blist,"lradius",pcjFlags,3.0f,pcjMin,pcjMax,500);
+	G2_Set_Bone_Angles_IK(ghoul2, mod_a,blist,"rfemurYZ",pcjFlags,6.0f,pcjMin,pcjMax,500);
+	G2_Set_Bone_Angles_IK(ghoul2, mod_a,blist,"lfemurYZ",pcjFlags,6.0f,pcjMin,pcjMax,500);
+	G2_Set_Bone_Angles_IK(ghoul2, mod_a,blist,"rtibia",pcjFlags,4.0f,pcjMin,pcjMax,500);
+	G2_Set_Bone_Angles_IK(ghoul2, mod_a,blist,"ltibia",pcjFlags,4.0f,pcjMin,pcjMax,500);
+
+	G2_ConstructGhoulSkeleton(ghoul2V, curTime, false, parms->scale);
+#endif
+	//Only need the standard effectors for this.
+	pcjFlags = RAG_PCJ|RAG_PCJ_POST_MULT|RAG_EFFECTOR;
+
+	G2_Set_Bone_Angles_IK(ghoul2, mod_a,blist,"rhand",pcjFlags,6.0f);
+	G2_Set_Bone_Angles_IK(ghoul2, mod_a,blist,"lhand",pcjFlags,6.0f);
+//	G2_Set_Bone_Angles_IK(ghoul2, mod_a,blist,"rtarsal",pcjFlags,4.0f);
+//	G2_Set_Bone_Angles_IK(ghoul2, mod_a,blist,"ltarsal",pcjFlags,4.0f);
+	G2_Set_Bone_Angles_IK(ghoul2, mod_a,blist,"rtibia",pcjFlags,4.0f);
+	G2_Set_Bone_Angles_IK(ghoul2, mod_a,blist,"ltibia",pcjFlags,4.0f);
+	G2_Set_Bone_Angles_IK(ghoul2, mod_a,blist,"rtalus",pcjFlags,4.0f);
+	G2_Set_Bone_Angles_IK(ghoul2, mod_a,blist,"ltalus",pcjFlags,4.0f);
+	G2_Set_Bone_Angles_IK(ghoul2, mod_a,blist,"rradiusX",pcjFlags,6.0f);
+	G2_Set_Bone_Angles_IK(ghoul2, mod_a,blist,"lradiusX",pcjFlags,6.0f);
+	G2_Set_Bone_Angles_IK(ghoul2, mod_a,blist,"rfemurX",pcjFlags,10.0f);
+	G2_Set_Bone_Angles_IK(ghoul2, mod_a,blist,"lfemurX",pcjFlags,10.0f);
+	G2_Set_Bone_Angles_IK(ghoul2, mod_a,blist,"ceyebrow",pcjFlags,10.0f);
+}
+
+qboolean G2_SetBoneIKState(CGhoul2Info_v &ghoul2, int time, const char *boneName, int ikState, sharedSetBoneIKStateParams_t *params)
+{
+	model_t		*mod_a;
+	int g2index = 0;
+	int curTime = time;
+	CGhoul2Info &g2 = ghoul2[g2index];
+	const mdxaHeader_t *rmod_a = G2_GetModA(g2);
+
+	boneInfo_v &blist = g2.mBlist;
+	mod_a = (model_t *)g2.animModel;
+
+	if (!boneName)
+	{ //null bonename param means it's time to init the ik stuff on this instance
+		sharedRagDollUpdateParams_t sRDUP;
+
+		if (ikState == IKS_NONE)
+		{ //this means we want to reset the IK state completely.. run through the bone list, and reset all the appropriate flags
+			int i = 0;
+			while (i < blist.size())
+			{ //we can't use this method for ragdoll. However, since we expect them to set their anims/angles again on the PCJ
+			  //limb after they reset it gameside, it's reasonable for IK bones.
+				boneInfo_t &bone = blist[i];
+				if (bone.boneNumber != -1)
+				{
+					bone.flags &= ~BONE_ANGLES_RAGDOLL;
+					bone.flags &= ~BONE_ANGLES_IK;
+					bone.RagFlags = 0;
+					bone.lastTimeUpdated = 0;
+				}
+				i++;
+			}
+			return qtrue;
+		}
+		assert(params);
+
+		if (!params)
+		{
+			return qfalse;
+		}
+
+		sRDUP.me = 0;
+		VectorCopy(params->angles, sRDUP.angles);
+		VectorCopy(params->origin, sRDUP.position);
+		VectorCopy(params->scale, sRDUP.scale);
+		VectorClear(sRDUP.velocity);
+		G2_InitIK(ghoul2, &sRDUP, curTime, rmod_a, g2index);
+		return qtrue;
+	}
+
+	if (!rmod_a || !mod_a)
+	{
+		return qfalse;
+	}
+
+	int index = G2_Find_Bone(mod_a, blist, boneName);
+ 
+	if (index == -1)
+	{
+		index = G2_Add_Bone(mod_a, blist, boneName);
+	}
+
+	if (index == -1)
+	{ //couldn't find or add the bone..
+		return qfalse;
+	}
+
+	boneInfo_t &bone = blist[index];
+
+	if (ikState == IKS_NONE)
+	{ //remove the bone from the list then, so it has to reinit. I don't think this should hurt anything since
+	  //we don't store bone index handles gameside anywhere.
+		if (!(bone.flags & BONE_ANGLES_RAGDOLL))
+		{ //you can't set the ik state to none if it's not a rag/ik bone.
+			return qfalse;
+		}
+		//bone.flags = 0;
+		//G2_Remove_Bone_Index(blist, index);
+		//actually, I want to keep it on the rag list, and remove it as an IK bone instead.
+		bone.flags &= ~BONE_ANGLES_RAGDOLL;
+		bone.flags |= BONE_ANGLES_IK;
+		bone.RagFlags &= ~RAG_PCJ_IK_CONTROLLED;
+		return qtrue;
+	}
+
+	//need params if we're not resetting.
+	if (!params)
+	{
+		assert(0);
+		return qfalse;
+	}
+
+	if (bone.flags & BONE_ANGLES_RAGDOLL)
+	{ //otherwise if the bone is already flagged as rag, then we can't set it again. (non-active ik bones will be BONE_ANGLES_IK, active are considered rag)
+		return qfalse;
+	}
+#if 0 //this is wrong now.. we're only initing effectors with initik now.. which SHOULDN'T be used as pcj's
+	if (!(bone.flags & BONE_ANGLES_IK) && !(bone.flags & BONE_ANGLES_RAGDOLL))
+	{ //IK system has not been inited yet, because any bone that can be IK should be in the ragdoll list, not flagged as BONE_ANGLES_RAGDOLL but as BONE_ANGLES_IK
+		sharedRagDollUpdateParams_t sRDUP;
+		sRDUP.me = 0;
+		VectorCopy(params->angles, sRDUP.angles);
+		VectorCopy(params->origin, sRDUP.position);
+		VectorCopy(params->scale, sRDUP.scale);
+		VectorClear(sRDUP.velocity);
+		G2_InitIK(ghoul2, &sRDUP, curTime, rmod_a, g2index);
+
+		G2_ConstructGhoulSkeleton(ghoul2, curTime, false, params->scale);
+	}
+	else
+	{
+		G2_GenerateWorldMatrix(params->angles, params->origin);
+		G2_ConstructGhoulSkeleton(ghoul2, curTime, false, params->scale);
+	}
+#else
+	G2_GenerateWorldMatrix(params->angles, params->origin);
+	G2_ConstructGhoulSkeleton(ghoul2, curTime, false, params->scale);
+#endif
+
+	int pcjFlags = RAG_PCJ|RAG_PCJ_IK_CONTROLLED|RAG_PCJ_POST_MULT|RAG_EFFECTOR;
+
+	if (params->pcjOverrides)
+	{
+		pcjFlags = params->pcjOverrides;
+	}
+
+	bone.ikSpeed = 0.4f;
+	VectorClear(bone.ikPosition);
+
+	G2_Set_Bone_Rag(rmod_a, blist, boneName, g2, params->scale, params->origin);
+
+	int startFrame = params->startFrame, endFrame = params->endFrame;
+
+	if (bone.startFrame != startFrame || bone.endFrame != endFrame || params->forceAnimOnBone)
+	{ //if it's already on this anim leave it alone, to allow smooth transitions into IK on the current anim if it is so desired.
+		G2_Set_Bone_Anim_No_BS(g2, rmod_a, blist, boneName, startFrame, endFrame-1,
+			BONE_ANIM_OVERRIDE_FREEZE|BONE_ANIM_BLEND,
+			1.0f, curTime, float(startFrame), 150, 0, true);
+	}
+
+	G2_ConstructGhoulSkeleton(ghoul2, curTime, false, params->scale);
+
+	bone.lastTimeUpdated = 0;
+	G2_Set_Bone_Angles_Rag(g2, rmod_a, blist, boneName, pcjFlags, params->radius, params->pcjMins, params->pcjMaxs, params->blendTime);
+
+	if (!G2_RagDollSetup(g2,curTime,true,params->origin,false))
+	{
+		assert(!"failed to add any rag bones");
+		return qfalse;
+	}
+
+	return qtrue;
+}
+
+qboolean G2_IKMove(CGhoul2Info_v &ghoul2, int time, sharedIKMoveParams_t *params)
+{
+#if 0
+	model_t		*mod_a;
+	int g2index = 0;
+	int curTime = time;
+	CGhoul2Info &g2 = ghoul2[g2index];
+
+	boneInfo_v &blist = g2.mBlist;
+	mod_a = (model_t *)g2.animModel;
+
+	if (!mod_a)
+	{
+		return qfalse;
+	}
+
+	int index = G2_Find_Bone(mod_a, blist, params->boneName);
+ 
+	//don't add here if you can't find it.. ik bones should already be there, because they need to have special stuff done to them anyway.
+	if (index == -1)
+	{ //couldn't find the bone..
+		return qfalse;
+	}
+
+	if (!params)
+	{
+		assert(0);
+		return qfalse;
+	}
+
+	if (!(blist[index].flags & BONE_ANGLES_RAGDOLL) && !(blist[index].flags & BONE_ANGLES_IK))
+	{ //no-can-do, buddy
+		return qfalse;
+	}
+
+	VectorCopy(params->desiredOrigin, blist[index].ikPosition);
+	blist[index].ikSpeed = params->movementSpeed;
+#else
+	int g2index = 0;
+	int curTime = time;
+	CGhoul2Info &g2 = ghoul2[g2index];
+
+	//rwwFIXMEFIXME: Doing this on all bones at the moment, fix this later?
+	if (!G2_RagDollSetup(g2,curTime,true,params->origin,false))
+	{ //changed models, possibly.
+		return qfalse;
+	}
+
+	for (int i=0;i<numRags;i++)
+	{
+		boneInfo_t &bone=*ragBoneData[i];
+
+		//if (bone.boneNumber == blist[index].boneNumber)
+		{
+			VectorCopy(params->desiredOrigin, bone.ikPosition);
+			bone.ikSpeed = params->movementSpeed;
+		}
+	}
+#endif
+	return qtrue;
+}
+
+// set the bone list to all unused so the bone transformation routine ignores it.
+void G2_Init_Bone_List(boneInfo_v &blist)
+{
+	blist.clear();
+}
+
+void G2_RemoveRedundantBoneOverrides(boneInfo_v &blist, int *activeBones)
+{
+	int		i;
+
+	// walk the surface list, removing surface overrides or generated surfaces that are pointing at surfaces that aren't active anymore
+	for (i=0; i<blist.size(); i++)
+	{
+		if (blist[i].boneNumber != -1)
+		{
+			if (!activeBones[blist[i].boneNumber])
+			{
+				blist[i].flags = 0;
+				G2_Remove_Bone_Index(blist, i);
+			}
+		}
+	}
+}
+
+int	G2_Get_Bone_Index(CGhoul2Info *ghoul2, const char *boneName)
+{
+  	model_t		*mod_m = R_GetModelByHandle(RE_RegisterModel(ghoul2->mFileName)); 
+	model_t		*mod_a = R_GetModelByHandle(mod_m->mdxm->animIndex); 
+
+	return (G2_Find_Bone(mod_a, ghoul2->mBlist, boneName));
+}
\ No newline at end of file
diff --git a/codemp/ghoul2/G2_gore.h b/codemp/ghoul2/G2_gore.h
new file mode 100644
index 0000000..7d52892
--- /dev/null
+++ b/codemp/ghoul2/G2_gore.h
@@ -0,0 +1,201 @@
+#if defined (_MSC_VER) && (_MSC_VER >= 1020)
+#pragma once
+#endif
+#if !defined(G2_GORE_H_INC)
+#define G2_GORE_H_INC
+
+#ifdef _G2_GORE
+
+#define MAX_LODS (8)
+struct GoreTextureCoordinates
+{
+	float *tex[MAX_LODS];
+
+	GoreTextureCoordinates()
+	{
+		int i;
+		for (i=0;i<MAX_LODS;i++)
+		{
+			tex[i]=0;
+		}
+	}
+	~GoreTextureCoordinates()
+	{
+		int i;
+		for (i=0;i<MAX_LODS;i++)
+		{
+			if ( tex[i] )
+			{
+#ifdef _DEBUG
+				extern int g_goreTexAllocs;
+				g_goreTexAllocs--;
+#endif
+				Z_Free(tex[i]);
+				tex[i] = 0;
+			}
+		}
+	}
+};
+
+int AllocGoreRecord();
+GoreTextureCoordinates *FindGoreRecord(int tag);
+void DeleteGoreRecord(int tag);
+
+struct SGoreSurface
+{
+	int			shader;
+	int			mGoreTag;
+	int			mDeleteTime;
+	int			mFadeTime;
+	bool		mFadeRGB;
+
+	int			mGoreGrowStartTime;
+	int			mGoreGrowEndTime;    // set this to -1 to disable growing
+	//curscale = (curtime-mGoreGrowStartTime)*mGoreGrowFactor + mGoreGrowOffset;
+	float		mGoreGrowFactor;	
+	float		mGoreGrowOffset;	
+};
+
+class CGoreSet
+{
+public:
+	int		 mMyGoreSetTag;
+	unsigned char mRefCount;
+	multimap<int,SGoreSurface> mGoreRecords; // a map from surface index
+	CGoreSet(int tag) : mMyGoreSetTag(tag), mRefCount(0) {}
+	~CGoreSet();
+};
+
+CGoreSet	*FindGoreSet(int goreSetTag);
+CGoreSet	*NewGoreSet();
+void		DeleteGoreSet(int goreSetTag);
+
+#endif // _G2_GORE
+
+//rww - RAGDOLL_BEGIN
+
+/// ragdoll stuff
+
+#pragma warning(disable: 4512)
+
+struct SRagDollEffectorCollision
+{
+	vec3_t			effectorPosition;
+	const trace_t	&tr;
+	bool			useTracePlane;
+	SRagDollEffectorCollision(const vec3_t effectorPos,const trace_t &t) :
+		tr(t),
+		useTracePlane(false)
+	{
+		VectorCopy(effectorPos,effectorPosition);
+	}
+};
+
+class CRagDollUpdateParams
+{
+public:
+	vec3_t angles;
+	vec3_t position;
+	vec3_t scale;
+	vec3_t velocity;
+	//CServerEntity *me;
+	int	me; //index!
+	int settleFrame;
+
+	//at some point I'll want to make VM callbacks in here. For now I am just doing nothing.
+	virtual void EffectorCollision(const SRagDollEffectorCollision &data) 
+	{
+	//	assert(0); // you probably meant to override this
+	}
+	virtual void RagDollBegin() 
+	{
+	//	assert(0); // you probably meant to override this
+	}
+	virtual void RagDollSettled() 
+	{
+	//	assert(0); // you probably meant to override this
+	}
+
+	virtual void Collision() 
+	{
+	//	assert(0); // you probably meant to override this
+		// we had a collision, uhh I guess call SetRagDoll RP_DEATH_COLLISION
+	}  
+	
+#ifdef _DEBUG
+	virtual void DebugLine(const vec3_t p1,const vec3_t p2,bool bbox) {assert(0);}
+#endif
+};
+
+
+class CRagDollParams
+{
+public:
+
+	enum ERagPhase
+	{
+		RP_START_DEATH_ANIM,
+		RP_END_DEATH_ANIM,
+		RP_DEATH_COLLISION,
+		RP_CORPSE_SHOT,
+		RP_GET_PELVIS_OFFSET,  // this actually does nothing but set the pelvisAnglesOffset, and pelvisPositionOffset
+		RP_SET_PELVIS_OFFSET,  // this actually does nothing but set the pelvisAnglesOffset, and pelvisPositionOffset
+		RP_DISABLE_EFFECTORS  // this removes effectors given by the effectorsToTurnOff member
+	};
+	vec3_t angles;
+	vec3_t position;
+	vec3_t scale;
+	vec3_t pelvisAnglesOffset;    // always set on return, an argument for RP_SET_PELVIS_OFFSET
+	vec3_t pelvisPositionOffset; // always set on return, an argument for RP_SET_PELVIS_OFFSET
+
+	float fImpactStrength; //should be applicable when RagPhase is RP_DEATH_COLLISION
+	float fShotStrength; //should be applicable for setting velocity of corpse on shot (probably only on RP_CORPSE_SHOT)
+	//CServerEntity *me;
+	int me;
+
+	//rww - we have convenient animation/frame access in the game, so just send this info over from there.
+	int startFrame;
+	int endFrame;
+
+	int collisionType; // 1 = from a fall, 0 from effectors, this will be going away soon, hence no enum 
+
+	qboolean CallRagDollBegin; // a return value, means that we are now begininng ragdoll and the NPC stuff needs to happen
+
+	ERagPhase RagPhase;
+
+// effector control, used for RP_DISABLE_EFFECTORS call
+
+	enum ERagEffector
+	{
+		RE_MODEL_ROOT=			0x00000001, //"model_root"
+		RE_PELVIS=				0x00000002, //"pelvis"
+		RE_LOWER_LUMBAR=		0x00000004, //"lower_lumbar"
+		RE_UPPER_LUMBAR=		0x00000008, //"upper_lumbar"
+		RE_THORACIC=			0x00000010, //"thoracic"
+		RE_CRANIUM=				0x00000020, //"cranium"
+		RE_RHUMEROUS=			0x00000040, //"rhumerus"
+		RE_LHUMEROUS=			0x00000080, //"lhumerus"
+		RE_RRADIUS=				0x00000100, //"rradius"
+		RE_LRADIUS=				0x00000200, //"lradius"
+		RE_RFEMURYZ=			0x00000400, //"rfemurYZ"
+		RE_LFEMURYZ=			0x00000800, //"lfemurYZ"
+		RE_RTIBIA=				0x00001000, //"rtibia"
+		RE_LTIBIA=				0x00002000, //"ltibia"
+		RE_RHAND=				0x00004000, //"rhand"
+		RE_LHAND=				0x00008000, //"lhand"
+		RE_RTARSAL=				0x00010000, //"rtarsal"
+		RE_LTARSAL=				0x00020000, //"ltarsal"
+		RE_RTALUS=				0x00040000, //"rtalus"
+		RE_LTALUS=				0x00080000, //"ltalus"
+		RE_RRADIUSX=			0x00100000, //"rradiusX"
+		RE_LRADIUSX=			0x00200000, //"lradiusX"
+		RE_RFEMURX=				0x00400000, //"rfemurX"
+		RE_LFEMURX=				0x00800000, //"lfemurX"
+		RE_CEYEBROW=			0x01000000 //"ceyebrow"
+	};
+
+	ERagEffector effectorsToTurnOff;  // set this to an | of the above flags for a RP_DISABLE_EFFECTORS
+
+};
+#endif //G2_GORE_H_INC
+//rww - RAGDOLL_END
\ No newline at end of file
diff --git a/codemp/ghoul2/G2_local.h b/codemp/ghoul2/G2_local.h
new file mode 100644
index 0000000..949b468
--- /dev/null
+++ b/codemp/ghoul2/G2_local.h
@@ -0,0 +1,223 @@
+// defines to setup the
+
+#include "ghoul2_shared.h"
+
+
+//rww - RAGDOLL_BEGIN
+class CRagDollUpdateParams;
+//rww - RAGDOLL_END
+
+class CMiniHeap;
+
+#define		GHOUL2_CRAZY_SMOOTH						0x2000		//hack for smoothing during ugly situations. forgive me.
+
+
+// internal surface calls  G2_surfaces.cpp
+qboolean	G2_SetSurfaceOnOff (CGhoul2Info *ghlInfo, surfaceInfo_v &slist, const char *surfaceName, const int offFlags);
+int			G2_IsSurfaceOff (CGhoul2Info *ghlInfo, surfaceInfo_v &slist, const char *surfaceName);
+qboolean	G2_SetRootSurface( CGhoul2Info_v &ghoul2, const int modelIndex, const char *surfaceName);
+int			G2_AddSurface(CGhoul2Info *ghoul2, int surfaceNumber, int polyNumber, float BarycentricI, float BarycentricJ, int lod );
+qboolean	G2_RemoveSurface(surfaceInfo_v &slist, const int index);
+surfaceInfo_t *G2_FindOverrideSurface(int surfaceNum, surfaceInfo_v &surfaceList);
+int			G2_IsSurfaceLegal(void *mod, const char *surfaceName, int *flags);
+int			G2_GetParentSurface(CGhoul2Info *ghlInfo, const int index);
+int			G2_GetSurfaceIndex(CGhoul2Info *ghlInfo, const char *surfaceName);
+int			G2_IsSurfaceRendered(CGhoul2Info *ghlInfo, const char *surfaceName, surfaceInfo_v &slist);
+
+// internal bone calls - G2_Bones.cpp
+qboolean	G2_Set_Bone_Angles(CGhoul2Info *ghlInfo, boneInfo_v &blist, const char *boneName, const float *angles, const int flags,
+							   const Eorientations up, const Eorientations left, const Eorientations forward, qhandle_t *modelList,
+							   const int modelIndex, const int blendTime, const int currentTime);
+qboolean	G2_Remove_Bone (CGhoul2Info *ghlInfo, boneInfo_v &blist, const char *boneName);
+qboolean	G2_Set_Bone_Anim(CGhoul2Info *ghlInfo, boneInfo_v &blist, const char *boneName, const int startFrame, 
+							 const int endFrame, const int flags, const float animSpeed, const int currentTime, const float setFrame, const int blendTime);
+qboolean	G2_Get_Bone_Anim(CGhoul2Info *ghlInfo, boneInfo_v &blist, const char *boneName, const int currentTime, 
+						  float *currentFrame, int *startFrame, int *endFrame, int *flags, float *retAnimSpeed, qhandle_t *modelList, int modelIndex);
+qboolean	G2_Get_Bone_Anim_Range(CGhoul2Info *ghlInfo, boneInfo_v &blist, const char *boneName, int *startFrame, int *endFrame);
+qboolean	G2_Pause_Bone_Anim(CGhoul2Info *ghlInfo, boneInfo_v &blist, const char *boneName, const int currentTime );
+qboolean	G2_IsPaused(const char *fileName, boneInfo_v &blist, const char *boneName);
+qboolean	G2_Stop_Bone_Anim(const char *fileName, boneInfo_v &blist, const char *boneName);
+qboolean	G2_Stop_Bone_Angles(const char *fileName, boneInfo_v &blist, const char *boneName);
+//rww - RAGDOLL_BEGIN
+void		G2_Animate_Bone_List(CGhoul2Info_v &ghoul2, const int currentTime, const int index,CRagDollUpdateParams *params);
+//rww - RAGDOLL_END
+void		G2_Init_Bone_List(boneInfo_v &blist);
+int			G2_Find_Bone_In_List(boneInfo_v &blist, const int boneNum);
+void		G2_RemoveRedundantBoneOverrides(boneInfo_v &blist, int *activeBones);
+qboolean	G2_Set_Bone_Angles_Matrix(const char *fileName, boneInfo_v &blist, const char *boneName, const mdxaBone_t &matrix,
+									  const int flags, qhandle_t *modelList, const int modelIndex, const int blendTime, const int currentTime);
+int			G2_Get_Bone_Index(CGhoul2Info *ghoul2, const char *boneName);
+qboolean	G2_Set_Bone_Angles_Index(boneInfo_v &blist, const int index,
+							const float *angles, const int flags, const Eorientations yaw,
+							const Eorientations pitch, const Eorientations roll, qhandle_t *modelList,
+							const int modelIndex, const int blendTime, const int currentTime);
+qboolean	G2_Set_Bone_Angles_Matrix_Index(boneInfo_v &blist, const int index,
+								   const mdxaBone_t &matrix, const int flags, qhandle_t *modelList,
+								   const int modelIndex, const int blendTime, const int currentTime);
+qboolean	G2_Stop_Bone_Anim_Index(boneInfo_v &blist, const int index);
+qboolean	G2_Stop_Bone_Angles_Index(boneInfo_v &blist, const int index);
+qboolean	G2_Set_Bone_Anim_Index(boneInfo_v &blist, const int index, const int startFrame, 
+						  const int endFrame, const int flags, const float animSpeed, const int currentTime, const float setFrame, const int blendTime, const int numFrames);
+qboolean	G2_Get_Bone_Anim_Index( boneInfo_v &blist, const int index, const int currentTime, 
+						  float *currentFrame, int *startFrame, int *endFrame, int *flags, float *retAnimSpeed, qhandle_t *modelList, int modelIndex);
+
+// misc functions G2_misc.cpp
+void		G2_List_Model_Surfaces(const char *fileName);
+void		G2_List_Model_Bones(const char *fileName, int frame);
+qboolean	G2_GetAnimFileName(const char *fileName, char **filename);
+#ifdef _G2_GORE
+void		G2_TraceModels(CGhoul2Info_v &ghoul2, vec3_t rayStart, vec3_t rayEnd, CollisionRecord_t *collRecMap, int entNum, int traceFlags, int useLod, float fRadius, float ssize,float tsize,float theta,int shader, SSkinGoreData *gore);
+#else
+void		G2_TraceModels(CGhoul2Info_v &ghoul2, vec3_t rayStart, vec3_t rayEnd, CollisionRecord_t *collRecMap, int entNum, int traceFlags, int useLod, float fRadius);
+#endif
+void		TransformAndTranslatePoint (const vec3_t in, vec3_t out, mdxaBone_t *mat);
+#ifdef _G2_GORE
+void		G2_TransformModel(CGhoul2Info_v &ghoul2, const int frameNum, vec3_t scale, CMiniHeap *G2VertSpace, int useLod, bool ApplyGore);
+#else
+void		G2_TransformModel(CGhoul2Info_v &ghoul2, const int frameNum, vec3_t scale, CMiniHeap *G2VertSpace, int useLod);
+#endif
+void		G2_GenerateWorldMatrix(const vec3_t angles, const vec3_t origin);
+void		TransformPoint (const vec3_t in, vec3_t out, mdxaBone_t *mat);
+void		Inverse_Matrix(mdxaBone_t *src, mdxaBone_t *dest);
+void		*G2_FindSurface(void *mod, int index, int lod);
+qboolean	G2_SaveGhoul2Models(CGhoul2Info_v &ghoul2, char **buffer, int *size);
+void		G2_LoadGhoul2Model(CGhoul2Info_v &ghoul2, char *buffer);
+
+// internal bolt calls. G2_bolts.cpp
+int			G2_Add_Bolt(CGhoul2Info *ghlInfo, boltInfo_v &bltlist, surfaceInfo_v &slist, const char *boneName);
+qboolean	G2_Remove_Bolt (boltInfo_v &bltlist, int index);
+void		G2_Init_Bolt_List(boltInfo_v &bltlist);
+int			G2_Find_Bolt_Bone_Num(boltInfo_v &bltlist, const int boneNum);
+int			G2_Find_Bolt_Surface_Num(boltInfo_v &bltlist, const int surfaceNum, const int flags);
+int			G2_Add_Bolt_Surf_Num(CGhoul2Info *ghlInfo, boltInfo_v &bltlist, surfaceInfo_v &slist, const int surfNum);
+void		G2_RemoveRedundantBolts(boltInfo_v &bltlist, surfaceInfo_v &slist, int *activeSurfaces, int *activeBones);
+
+
+// API calls - G2_API.cpp
+void		G2API_SetTime(int currentTime, int clock);
+int			G2API_GetTime(int argTime);
+
+qhandle_t	G2API_PrecacheGhoul2Model(const char *fileName);
+
+int			G2API_InitGhoul2Model(CGhoul2Info_v **ghoul2Ptr, const char *fileName, int modelIndex, qhandle_t customSkin = NULL,
+								  qhandle_t customShader = NULL, int modelFlags = 0, int lodBias = 0);
+qboolean	G2API_SetLodBias(CGhoul2Info *ghlInfo, int lodBias);
+qboolean	G2API_SetSkin(CGhoul2Info *ghlInfo, qhandle_t customSkin, qhandle_t renderSkin);
+qboolean	G2API_SetShader(CGhoul2Info *ghlInfo, qhandle_t customShader);
+qboolean	G2API_HasGhoul2ModelOnIndex(CGhoul2Info_v **ghlRemove, const int modelIndex);
+qboolean	G2API_RemoveGhoul2Model(CGhoul2Info_v **ghlRemove, const int modelIndex);
+qboolean	G2API_RemoveGhoul2Models(CGhoul2Info_v **ghlRemove);
+qboolean	G2API_SetSurfaceOnOff(CGhoul2Info_v &ghoul2, const char *surfaceName, const int flags);
+int			G2API_GetSurfaceOnOff(CGhoul2Info *ghlInfo, const char *surfaceName);
+qboolean	G2API_SetRootSurface(CGhoul2Info_v &ghoul2, const int modelIndex, const char *surfaceName);
+qboolean	G2API_RemoveSurface(CGhoul2Info *ghlInfo, const int index);
+int			G2API_AddSurface(CGhoul2Info *ghlInfo, int surfaceNumber, int polyNumber, float BarycentricI, float BarycentricJ, int lod );
+qboolean	G2API_SetBoneAnim(CGhoul2Info_v &ghoul2, const int modelIndex, const char *boneName, const int startFrame, const int endFrame,
+							  const int flags, const float animSpeed, const int currentTime, const float setFrame = -1, const int blendTime = -1);
+qboolean	G2API_GetBoneAnim(CGhoul2Info *ghlInfo, const char *boneName, const int currentTime, float *currentFrame,
+							  int *startFrame, int *endFrame, int *flags, float *animSpeed, qhandle_t *modelList);
+qboolean	G2API_GetAnimRange(CGhoul2Info *ghlInfo, const char *boneName,	int *startFrame, int *endFrame);
+qboolean	G2API_PauseBoneAnim(CGhoul2Info *ghlInfo, const char *boneName, const int currentTime);
+qboolean	G2API_IsPaused(CGhoul2Info *ghlInfo, const char *boneName);
+qboolean	G2API_StopBoneAnim(CGhoul2Info *ghlInfo, const char *boneName);
+
+
+qboolean G2API_SetBoneAngles(CGhoul2Info_v &ghoul2, const int modelIndex, const char *boneName, const vec3_t angles, const int flags,
+							 const Eorientations up, const Eorientations left, const Eorientations forward,
+							 qhandle_t *modelList, int blendTime, int currentTime );
+
+qboolean	G2API_StopBoneAngles(CGhoul2Info *ghlInfo, const char *boneName);
+qboolean	G2API_RemoveBone(CGhoul2Info *ghlInfo, const char *boneName);
+void		G2API_AnimateG2Models(CGhoul2Info_v &ghoul2, float speedVar);
+qboolean	G2API_RemoveBolt(CGhoul2Info *ghlInfo, const int index);
+int			G2API_AddBolt(CGhoul2Info_v &ghoul2, const int modelIndex, const char *boneName);
+int			G2API_AddBoltSurfNum(CGhoul2Info *ghlInfo, const int surfIndex);
+void		G2API_SetBoltInfo(CGhoul2Info_v &ghoul2, int modelIndex, int boltInfo);
+qboolean	G2API_AttachG2Model(CGhoul2Info_v &ghoul2From, int modelFrom, CGhoul2Info_v &ghoul2To, int toBoltIndex, int toModel);
+qboolean	G2API_DetachG2Model(CGhoul2Info *ghlInfo);
+qboolean	G2API_AttachEnt(int *boltInfo, CGhoul2Info *ghlInfoTo, int toBoltIndex, int entNum, int toModelNum);
+void		G2API_DetachEnt(int *boltInfo);
+
+qboolean	G2API_GetBoltMatrix(CGhoul2Info_v &ghoul2, const int modelIndex, const int boltIndex, mdxaBone_t *matrix,
+								const vec3_t angles, const vec3_t position, const int frameNum, qhandle_t *modelList, vec3_t scale);
+
+void		G2API_ListSurfaces(CGhoul2Info *ghlInfo);
+void		G2API_ListBones(CGhoul2Info *ghlInfo, int frame);
+qboolean	G2API_HaveWeGhoul2Models(CGhoul2Info_v &ghoul2);
+void		G2API_SetGhoul2ModelIndexes(CGhoul2Info_v &ghoul2, qhandle_t *modelList, qhandle_t *skinList);
+qboolean	G2API_SetGhoul2ModelFlags(CGhoul2Info *ghlInfo, const int flags);
+int			G2API_GetGhoul2ModelFlags(CGhoul2Info *ghlInfo);
+
+qboolean	G2API_GetAnimFileName(CGhoul2Info *ghlInfo, char **filename);
+void		G2API_CollisionDetect(CollisionRecord_t *collRecMap, CGhoul2Info_v &ghoul2, const vec3_t angles, const vec3_t position,
+										  int frameNumber, int entNum, vec3_t rayStart, vec3_t rayEnd, vec3_t scale, CMiniHeap *G2VertSpace, int traceFlags, int useLod, float fRadius);
+
+void		G2API_GiveMeVectorFromMatrix(mdxaBone_t *boltMatrix, Eorientations flags, vec3_t vec);
+int			G2API_CopyGhoul2Instance(CGhoul2Info_v &g2From, CGhoul2Info_v &g2To, int modelIndex);
+void		G2API_CleanGhoul2Models(CGhoul2Info_v **ghoul2Ptr);
+int			G2API_GetParentSurface(CGhoul2Info *ghlInfo, const int index);
+int			G2API_GetSurfaceIndex(CGhoul2Info *ghlInfo, const char *surfaceName);
+char		*G2API_GetSurfaceName(CGhoul2Info *ghlInfo, int surfNumber);
+char		*G2API_GetGLAName(CGhoul2Info_v &ghoul2, int modelIndex);
+qboolean	G2API_SetBoneAnglesMatrix(CGhoul2Info *ghlInfo, const char *boneName, const mdxaBone_t &matrix, const int flags,
+									  qhandle_t *modelList, int blendTime = 0, int currentTime = 0);
+qboolean	G2API_SetNewOrigin(CGhoul2Info_v &ghoul2, const int boltIndex);
+int			G2API_GetBoneIndex(CGhoul2Info *ghlInfo, const char *boneName);
+qboolean	G2API_StopBoneAnglesIndex(CGhoul2Info *ghlInfo, const int index);
+qboolean	G2API_StopBoneAnimIndex(CGhoul2Info *ghlInfo, const int index);
+qboolean	G2API_SetBoneAnglesIndex(CGhoul2Info *ghlInfo, const int index, const vec3_t angles, const int flags,
+							 const int yaw, const int pitch, const int roll,
+							 qhandle_t *modelList, int blendTime, int currentTime);
+qboolean	G2API_SetBoneAnglesMatrixIndex(CGhoul2Info *ghlInfo, const int index, const mdxaBone_t &matrix,
+								   const int flags, qhandle_t *modelList, int blendTime, int currentTime);
+qboolean	G2API_DoesBoneExist(CGhoul2Info *ghlInfo, const char *boneName);
+qboolean	G2API_SetBoneAnimIndex(CGhoul2Info *ghlInfo, const int index, const int startFrame, const int endFrame, const int flags, const float animSpeed, const int currentTime, const float setFrame, const int blendTime);
+qboolean	G2API_SaveGhoul2Models(CGhoul2Info_v &ghoul2, char **buffer, int *size);
+void		G2API_LoadGhoul2Models(CGhoul2Info_v &ghoul2, char *buffer);
+void		G2API_LoadSaveCodeDestructGhoul2Info(CGhoul2Info_v &ghoul2);
+void		G2API_FreeSaveBuffer(char *buffer);
+char		*G2API_GetAnimFileNameIndex(qhandle_t modelIndex);
+int			G2API_GetSurfaceRenderStatus(CGhoul2Info *ghlInfo, const char *surfaceName);
+void		G2API_CopySpecificG2Model(CGhoul2Info_v &ghoul2From, int modelFrom, CGhoul2Info_v &ghoul2To, int modelTo);
+void		G2API_DuplicateGhoul2Instance(CGhoul2Info_v &g2From, CGhoul2Info_v **g2To);
+void		G2API_SetBoltInfo(CGhoul2Info_v &ghoul2, int modelIndex, int boltInfo);
+
+class CRagDollUpdateParams;
+class CRagDollParams;
+
+void		G2API_AbsurdSmoothing(CGhoul2Info_v &ghoul2, qboolean status);
+
+void		G2API_SetRagDoll(CGhoul2Info_v &ghoul2,CRagDollParams *parms);
+void		G2API_ResetRagDoll(CGhoul2Info_v &ghoul2);
+void		G2API_AnimateG2Models(CGhoul2Info_v &ghoul2, int AcurrentTime,CRagDollUpdateParams *params);
+
+qboolean	G2API_RagPCJConstraint(CGhoul2Info_v &ghoul2, const char *boneName, vec3_t min, vec3_t max);
+qboolean	G2API_RagPCJGradientSpeed(CGhoul2Info_v &ghoul2, const char *boneName, const float speed);
+qboolean	G2API_RagEffectorGoal(CGhoul2Info_v &ghoul2, const char *boneName, vec3_t pos);
+qboolean	G2API_GetRagBonePos(CGhoul2Info_v &ghoul2, const char *boneName, vec3_t pos, vec3_t entAngles, vec3_t entPos, vec3_t entScale);
+qboolean	G2API_RagEffectorKick(CGhoul2Info_v &ghoul2, const char *boneName, vec3_t velocity);
+qboolean	G2API_RagForceSolve(CGhoul2Info_v &ghoul2, qboolean force);
+
+qboolean	G2API_SetBoneIKState(CGhoul2Info_v &ghoul2, int time, const char *boneName, int ikState, sharedSetBoneIKStateParams_t *params);
+qboolean	G2API_IKMove(CGhoul2Info_v &ghoul2, int time, sharedIKMoveParams_t *params);
+
+void		G2API_AttachInstanceToEntNum(CGhoul2Info_v &ghoul2, int entityNum, qboolean server);
+void		G2API_ClearAttachedInstance(int entityNum);
+void		G2API_CleanEntAttachments(void);
+qboolean	G2API_OverrideServerWithClientData(CGhoul2Info *serverInstance);
+
+extern qboolean gG2_GBMNoReconstruct;
+extern qboolean gG2_GBMUseSPMethod;
+// From tr_ghoul2.cpp
+void		G2_ConstructGhoulSkeleton( CGhoul2Info_v &ghoul2,const int frameNum,bool checkForNewOrigin,const vec3_t scale);
+
+qboolean	G2API_SkinlessModel(CGhoul2Info *g2);
+
+#ifdef _G2_GORE
+int			G2API_GetNumGoreMarks(CGhoul2Info *g2);
+void		G2API_AddSkinGore(CGhoul2Info_v &ghoul2,SSkinGoreData &gore);
+void		G2API_ClearSkinGore ( CGhoul2Info_v &ghoul2 );
+#endif // _SOF2
+
+int			G2API_Ghoul2Size ( CGhoul2Info_v &ghoul2 );
+
diff --git a/codemp/ghoul2/G2_misc.cpp b/codemp/ghoul2/G2_misc.cpp
new file mode 100644
index 0000000..032e2d3
--- /dev/null
+++ b/codemp/ghoul2/G2_misc.cpp
@@ -0,0 +1,1926 @@
+// leave this as first line for PCH reasons...
+//
+
+
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+
+#if !defined(TR_LOCAL_H)
+	#include "../renderer/tr_local.h"
+#endif
+
+#include "../renderer/matcomp.h"
+
+#if !defined(G2_H_INC)
+	#include "G2.h"
+#endif
+
+#if !defined (MINIHEAP_H_INC)
+	#include "../qcommon/MiniHeap.h"
+#endif
+
+#include "../server/server.h"
+#include "G2_local.h"
+
+#ifdef _G2_GORE
+#include "G2_gore.h"
+
+#define GORE_TAG_UPPER (256)
+#define GORE_TAG_MASK (~255)
+
+static int CurrentTag=GORE_TAG_UPPER+1;
+static int CurrentTagUpper=GORE_TAG_UPPER;
+
+static map<int,GoreTextureCoordinates> GoreRecords;
+static map<pair<int,int>,int> GoreTagsTemp; // this is a surface index to gore tag map used only 
+								  // temporarily during the generation phase so we reuse gore tags per LOD
+int goreModelIndex;
+
+bool AddGoreToAllModels=false;
+
+GoreTextureCoordinates *FindGoreRecord(int tag);
+static inline void DestroyGoreTexCoordinates(int tag)
+{
+	GoreTextureCoordinates *gTC = FindGoreRecord(tag);
+	if (!gTC)
+	{
+		return;
+	}
+	gTC->~GoreTextureCoordinates();
+	//I don't know what's going on here, it should call the destructor for
+	//this when it erases the record but sometimes it doesn't. -rww
+}
+
+//TODO: This needs to be set via a scalability cvar with some reasonable minimum value if pgore is used at all
+#define MAX_GORE_RECORDS (500)
+
+int AllocGoreRecord()
+{
+	while (GoreRecords.size()>MAX_GORE_RECORDS)
+	{
+		int tagHigh=(*GoreRecords.begin()).first&GORE_TAG_MASK;
+		map<int,GoreTextureCoordinates>::iterator it;
+		GoreTextureCoordinates *gTC;
+
+		it = GoreRecords.begin();
+		gTC = &(*it).second;
+
+		if (gTC)
+		{
+			gTC->~GoreTextureCoordinates();
+		}
+		GoreRecords.erase(GoreRecords.begin());
+		while (GoreRecords.size())
+		{
+			if (((*GoreRecords.begin()).first&GORE_TAG_MASK)!=tagHigh)
+			{
+				break;
+			}
+			it = GoreRecords.begin();
+			gTC = &(*it).second;
+
+			if (gTC)
+			{
+				gTC->~GoreTextureCoordinates();
+			}
+			GoreRecords.erase(GoreRecords.begin());
+		}
+	}
+	int ret=CurrentTag;
+	GoreRecords[CurrentTag]=GoreTextureCoordinates();
+	CurrentTag++;
+	return ret;
+}
+
+void ResetGoreTag()
+{
+	GoreTagsTemp.clear();
+	CurrentTag=CurrentTagUpper;
+	CurrentTagUpper+=GORE_TAG_UPPER;
+}
+
+GoreTextureCoordinates *FindGoreRecord(int tag)
+{
+	map<int,GoreTextureCoordinates>::iterator i=GoreRecords.find(tag);
+	if (i!=GoreRecords.end())
+	{
+		return &(*i).second;
+	}
+	return 0;
+}
+
+void *G2_GetGoreRecord(int tag)
+{
+	return FindGoreRecord(tag);
+}
+
+void DeleteGoreRecord(int tag)
+{
+	DestroyGoreTexCoordinates(tag);
+	GoreRecords.erase(tag);
+}
+
+static int CurrentGoreSet=1; // this is a UUID for gore sets
+static map<int,CGoreSet *> GoreSets; // map from uuid to goreset
+
+CGoreSet *FindGoreSet(int goreSetTag)
+{
+	map<int,CGoreSet *>::iterator f=GoreSets.find(goreSetTag);
+	if (f!=GoreSets.end())
+	{
+		return (*f).second;
+	}
+	return 0;
+}
+
+#ifdef _DEBUG
+int g_goreAllocs = 0;
+int g_goreTexAllocs = 0;
+#endif
+
+CGoreSet *NewGoreSet()
+{
+	CGoreSet *ret=new CGoreSet(CurrentGoreSet++);
+#ifdef _DEBUG
+	g_goreAllocs++;
+#endif
+	GoreSets[ret->mMyGoreSetTag]=ret;
+	ret->mRefCount = 1;
+	return ret;
+}
+
+void DeleteGoreSet(int goreSetTag)
+{
+	map<int,CGoreSet *>::iterator f=GoreSets.find(goreSetTag);
+	if (f!=GoreSets.end())
+	{
+		if ( (*f).second->mRefCount == 0 || (*f).second->mRefCount - 1 == 0 )
+		{
+#ifdef _DEBUG
+			g_goreAllocs--;
+#endif
+			delete (*f).second;
+			GoreSets.erase(f);
+		}
+		else
+		{
+			(*f).second->mRefCount--;
+		}
+	}
+}
+
+
+CGoreSet::~CGoreSet()
+{
+	multimap<int,SGoreSurface>::iterator i;
+	for (i=mGoreRecords.begin();i!=mGoreRecords.end();i++)
+	{
+		DeleteGoreRecord((*i).second.mGoreTag);
+	}
+};
+#endif // _SOF2
+
+extern mdxaBone_t		worldMatrix;
+extern mdxaBone_t		worldMatrixInv;
+
+const mdxaBone_t &EvalBoneCache(int index,CBoneCache *boneCache);
+
+#pragma warning(disable : 4512)		//assignment op could not be genereated
+class CTraceSurface
+{
+public:
+	int					surfaceNum;
+	surfaceInfo_v		&rootSList;
+	model_t				*currentModel;
+	int					lod;
+	vec3_t				rayStart;
+	vec3_t				rayEnd;
+	CollisionRecord_t	*collRecMap;
+	int					entNum;
+	int					modelIndex;
+	skin_t				*skin;
+	shader_t			*cust_shader;
+	int					*TransformedVertsArray;
+	int					traceFlags;
+	bool				hitOne;
+	float				m_fRadius;
+
+#ifdef _G2_GORE
+	//gore application thing
+	float				ssize;
+	float				tsize;
+	float				theta;
+	int					goreShader;
+	CGhoul2Info			*ghoul2info;
+
+	//	Procedural-gore application things
+	SSkinGoreData		*gore;
+#endif
+
+	CTraceSurface(
+	int					initsurfaceNum,
+	surfaceInfo_v		&initrootSList,
+	model_t				*initcurrentModel,
+	int					initlod,
+	vec3_t				initrayStart,
+	vec3_t				initrayEnd,
+	CollisionRecord_t	*initcollRecMap,
+	int					initentNum,
+	int					initmodelIndex,
+	skin_t				*initskin,
+	shader_t			*initcust_shader,
+	int					*initTransformedVertsArray,
+	int					inittraceFlags,
+#ifdef _G2_GORE
+	float				fRadius,
+	float				initssize,
+	float				inittsize,
+	float				inittheta,
+	int					initgoreShader,
+	CGhoul2Info			*initghoul2info,
+	SSkinGoreData		*initgore):
+#else
+	float				fRadius):
+#endif
+
+	surfaceNum(initsurfaceNum),
+	rootSList(initrootSList),   
+	currentModel(initcurrentModel),
+	lod(initlod),          
+ 	collRecMap(initcollRecMap),  
+	entNum(initentNum),       
+	modelIndex(initmodelIndex),
+	skin(initskin),
+	cust_shader(initcust_shader),
+	traceFlags(inittraceFlags),
+	TransformedVertsArray(initTransformedVertsArray),
+#ifdef _G2_GORE
+	m_fRadius(fRadius),
+	ssize(initssize),
+	tsize(inittsize),
+	theta(inittheta),
+	goreShader(initgoreShader),
+	ghoul2info(initghoul2info),
+	gore(initgore)
+#else
+	m_fRadius(fRadius)
+#endif
+	{
+		VectorCopy(initrayStart, rayStart);
+		VectorCopy(initrayEnd, rayEnd);
+		hitOne = false;
+	}         
+
+};
+
+// assorted Ghoul 2 functions.
+// list all surfaces associated with a model
+void G2_List_Model_Surfaces(const char *fileName)
+{
+	int			i, x;
+  	model_t		*mod_m = R_GetModelByHandle(RE_RegisterModel(fileName));
+	mdxmSurfHierarchy_t	*surf;
+
+	surf = (mdxmSurfHierarchy_t *) ( (byte *)mod_m->mdxm + mod_m->mdxm->ofsSurfHierarchy );
+	mdxmSurface_t *surface = (mdxmSurface_t *)((byte *)mod_m->mdxm + mod_m->mdxm->ofsLODs + sizeof(mdxmLOD_t));
+
+	for ( x = 0 ; x < mod_m->mdxm->numSurfaces ; x++) 
+	{
+		Com_Printf("Surface %i Name %s\n", x, surf->name);
+		if (r_verbose->value)
+		{
+			Com_Printf("Num Descendants %i\n",  surf->numChildren);
+			for (i=0; i<surf->numChildren; i++)
+			{
+				Com_Printf("Descendant %i\n", surf->childIndexes[i]);
+			}
+		}
+		// find the next surface
+  		surf = (mdxmSurfHierarchy_t *)( (byte *)surf + (int)( &((mdxmSurfHierarchy_t *)0)->childIndexes[ surf->numChildren ] ));
+  		surface =(mdxmSurface_t *)( (byte *)surface + surface->ofsEnd );
+	}
+
+}
+
+// list all bones associated with a model
+void G2_List_Model_Bones(const char *fileName, int frame)
+{
+	int				x, i;
+	mdxaSkel_t		*skel;
+	mdxaSkelOffsets_t	*offsets;
+  	model_t			*mod_m = R_GetModelByHandle(RE_RegisterModel(fileName)); 
+	model_t			*mod_a = R_GetModelByHandle(mod_m->mdxm->animIndex);
+// 	mdxaFrame_t		*aframe=0;
+//	int				frameSize;
+	mdxaHeader_t	*header = mod_a->mdxa;
+
+	// figure out where the offset list is
+	offsets = (mdxaSkelOffsets_t *)((byte *)header + sizeof(mdxaHeader_t));
+
+//    frameSize = (int)( &((mdxaFrame_t *)0)->boneIndexes[ header->numBones ] );   
+
+//	aframe = (mdxaFrame_t *)((byte *)header + header->ofsFrames + (frame * frameSize));
+	// walk each bone and list it's name
+	for (x=0; x< mod_a->mdxa->numBones; x++)
+	{
+		skel = (mdxaSkel_t *)((byte *)header + sizeof(mdxaHeader_t) + offsets->offsets[x]);
+		Com_Printf("Bone %i Name %s\n", x, skel->name);
+
+		Com_Printf("X pos %f, Y pos %f, Z pos %f\n", skel->BasePoseMat.matrix[0][3], skel->BasePoseMat.matrix[1][3], skel->BasePoseMat.matrix[2][3]);
+
+		// if we are in verbose mode give us more details
+		if (r_verbose->value)
+		{
+			Com_Printf("Num Descendants %i\n",  skel->numChildren);
+			for (i=0; i<skel->numChildren; i++)
+			{
+				Com_Printf("Num Descendants %i\n",  skel->numChildren);
+			}
+		}
+	}
+}
+
+
+/************************************************************************************************
+ * G2_GetAnimFileName
+ *    obtain the .gla filename for a model
+ *
+ * Input
+ *    filename of model 
+ *
+ * Output
+ *    true if we successfully obtained a filename, false otherwise
+ *
+ ************************************************************************************************/
+qboolean G2_GetAnimFileName(const char *fileName, char **filename)
+{
+	// find the model we want
+	model_t				*mod = R_GetModelByHandle(RE_RegisterModel(fileName));
+
+	if (mod && mod->mdxm && (mod->mdxm->animName[0] != 0))
+	{
+		*filename = mod->mdxm->animName;
+		return qtrue;
+	}
+	return qfalse;
+}
+
+
+/////////////////////////////////////////////////////////////////////
+// 
+//	Code for collision detection for models gameside
+//
+/////////////////////////////////////////////////////////////////////
+
+int G2_DecideTraceLod(CGhoul2Info &ghoul2, int useLod)
+{
+	int returnLod = useLod;
+
+   	// if we are overriding the LOD at top level, then we can afford to only check this level of model
+   	if (ghoul2.mLodBias > returnLod)
+   	{
+   		returnLod =  ghoul2.mLodBias;
+   	}
+//	assert(G2_MODEL_OK(&ghoul2));
+	
+	assert(ghoul2.currentModel);
+	assert(ghoul2.currentModel->mdxm);
+	//what about r_lodBias?
+
+	// now ensure that we haven't selected a lod that doesn't exist for this model
+	if ( returnLod >= ghoul2.currentModel->mdxm->numLODs )
+ 	{
+ 		returnLod = ghoul2.currentModel->mdxm->numLODs - 1;
+ 	}
+
+	return returnLod;
+}
+
+#ifdef _XBOX
+// This is in tr_ghoul2 for various reasons.
+extern void R_TransformEachSurface( const mdxmSurface_t *surface, vec3_t scale, CMiniHeap *G2VertSpace, int *TransformedVertsArray,CBoneCache *boneCache);
+#else
+void R_TransformEachSurface( const mdxmSurface_t *surface, vec3_t scale, CMiniHeap *G2VertSpace, int *TransformedVertsArray,CBoneCache *boneCache) 
+{
+	int				 j, k;
+	mdxmVertex_t 	*v;
+	float			*TransformedVerts;
+
+	//
+	// deform the vertexes by the lerped bones
+	//
+	int *piBoneReferences = (int*) ((byte*)surface + surface->ofsBoneReferences);
+   
+	// alloc some space for the transformed verts to get put in
+	TransformedVerts = (float *)G2VertSpace->MiniHeapAlloc(surface->numVerts * 5 * 4);
+	TransformedVertsArray[surface->thisSurfaceIndex] = (int)TransformedVerts;
+	if (!TransformedVerts)
+	{
+		Com_Error(ERR_DROP, "Ran out of transform space for Ghoul2 Models. Adjust MiniHeapSize in SV_SpawnServer.\n");
+	}
+
+	// whip through and actually transform each vertex
+	const int numVerts = surface->numVerts;
+	v = (mdxmVertex_t *) ((byte *)surface + surface->ofsVerts);
+	mdxmVertexTexCoord_t *pTexCoords = (mdxmVertexTexCoord_t *) &v[numVerts];
+
+	// optimisation issue
+	if ((scale[0] != 1.0) || (scale[1] != 1.0) || (scale[2] != 1.0))
+	{
+		for ( j = 0; j < numVerts; j++ ) 
+		{
+			vec3_t			tempVert, tempNormal;
+//			mdxmWeight_t	*w;
+
+			VectorClear( tempVert );
+			VectorClear( tempNormal );
+//			w = v->weights;
+
+			const int iNumWeights = G2_GetVertWeights( v );
+
+			float fTotalWeight = 0.0f;
+			for ( k = 0 ; k < iNumWeights ; k++ ) 
+			{
+				int		iBoneIndex	= G2_GetVertBoneIndex( v, k );
+				float	fBoneWeight	= G2_GetVertBoneWeight( v, k, fTotalWeight, iNumWeights );
+
+				const mdxaBone_t &bone=EvalBoneCache(piBoneReferences[iBoneIndex],boneCache);
+
+				tempVert[0] += fBoneWeight * ( DotProduct( bone.matrix[0], v->vertCoords ) + bone.matrix[0][3] );
+				tempVert[1] += fBoneWeight * ( DotProduct( bone.matrix[1], v->vertCoords ) + bone.matrix[1][3] );
+				tempVert[2] += fBoneWeight * ( DotProduct( bone.matrix[2], v->vertCoords ) + bone.matrix[2][3] );
+
+				tempNormal[0] += fBoneWeight * DotProduct( bone.matrix[0], v->normal );
+				tempNormal[1] += fBoneWeight * DotProduct( bone.matrix[1], v->normal );
+				tempNormal[2] += fBoneWeight * DotProduct( bone.matrix[2], v->normal );
+			}
+			int pos = j * 5;
+
+			// copy tranformed verts into temp space
+			TransformedVerts[pos++] = tempVert[0] * scale[0];
+			TransformedVerts[pos++] = tempVert[1] * scale[1];
+			TransformedVerts[pos++] = tempVert[2] * scale[2];
+			// we will need the S & T coors too for hitlocation and hitmaterial stuff
+			TransformedVerts[pos++] = pTexCoords[j].texCoords[0];
+			TransformedVerts[pos] = pTexCoords[j].texCoords[1];
+
+			v++;// = (mdxmVertex_t *)&v->weights[/*v->numWeights*/surface->maxVertBoneWeights];
+		}
+	}
+	else
+	{
+		int pos = 0;
+	  	for ( j = 0; j < numVerts; j++ ) 
+		{
+			vec3_t			tempVert, tempNormal;
+//			const mdxmWeight_t	*w;
+
+			VectorClear( tempVert );
+			VectorClear( tempNormal );
+//			w = v->weights;
+
+			const int iNumWeights = G2_GetVertWeights( v );
+
+			float fTotalWeight = 0.0f;
+			for ( k = 0 ; k < iNumWeights ; k++ ) 
+			{
+				int		iBoneIndex	= G2_GetVertBoneIndex( v, k );
+				float	fBoneWeight	= G2_GetVertBoneWeight( v, k, fTotalWeight, iNumWeights );
+
+				const mdxaBone_t &bone=EvalBoneCache(piBoneReferences[iBoneIndex],boneCache);
+
+				tempVert[0] += fBoneWeight * ( DotProduct( bone.matrix[0], v->vertCoords ) + bone.matrix[0][3] );
+				tempVert[1] += fBoneWeight * ( DotProduct( bone.matrix[1], v->vertCoords ) + bone.matrix[1][3] );
+				tempVert[2] += fBoneWeight * ( DotProduct( bone.matrix[2], v->vertCoords ) + bone.matrix[2][3] );
+
+				tempNormal[0] += fBoneWeight * DotProduct( bone.matrix[0], v->normal );
+				tempNormal[1] += fBoneWeight * DotProduct( bone.matrix[1], v->normal );
+				tempNormal[2] += fBoneWeight * DotProduct( bone.matrix[2], v->normal );
+			}
+
+			// copy tranformed verts into temp space
+			TransformedVerts[pos++] = tempVert[0];
+			TransformedVerts[pos++] = tempVert[1];
+			TransformedVerts[pos++] = tempVert[2];
+			// we will need the S & T coors too for hitlocation and hitmaterial stuff
+			TransformedVerts[pos++] = pTexCoords[j].texCoords[0];
+			TransformedVerts[pos++] = pTexCoords[j].texCoords[1];
+
+			v++;// = (mdxmVertex_t *)&v->weights[/*v->numWeights*/surface->maxVertBoneWeights];
+		}
+	}
+}
+
+#endif // _XBOX
+
+void G2_TransformSurfaces(int surfaceNum, surfaceInfo_v &rootSList, 
+					CBoneCache *boneCache, const model_t *currentModel, int lod, vec3_t scale, CMiniHeap *G2VertSpace, int *TransformedVertArray, bool secondTimeAround)
+{
+	int	i;
+	assert(currentModel);
+	assert(currentModel->mdxm);
+	// back track and get the surfinfo struct for this surface
+	const mdxmSurface_t			*surface = (mdxmSurface_t *)G2_FindSurface((void*)currentModel, surfaceNum, lod);
+	const mdxmHierarchyOffsets_t	*surfIndexes = (mdxmHierarchyOffsets_t *)((byte *)currentModel->mdxm + sizeof(mdxmHeader_t));
+	const mdxmSurfHierarchy_t		*surfInfo = (mdxmSurfHierarchy_t *)((byte *)surfIndexes + surfIndexes->offsets[surface->thisSurfaceIndex]);
+	
+	// see if we have an override surface in the surface list
+	const surfaceInfo_t	*surfOverride = G2_FindOverrideSurface(surfaceNum, rootSList);
+
+	// really, we should use the default flags for this surface unless it's been overriden
+	int offFlags = surfInfo->flags;
+
+  	if (surfOverride)
+	{
+		offFlags = surfOverride->offFlags;
+	}
+	// if this surface is not off, add it to the shader render list
+	if (!offFlags)
+	{
+
+		R_TransformEachSurface(surface, scale, G2VertSpace, TransformedVertArray, boneCache);
+	}
+
+	// if we are turning off all descendants, then stop this recursion now
+	if (offFlags & G2SURFACEFLAG_NODESCENDANTS)
+	{
+		return;
+	}
+
+	// now recursively call for the children
+	for (i=0; i< surfInfo->numChildren; i++)
+	{
+		G2_TransformSurfaces(surfInfo->childIndexes[i], rootSList, boneCache, currentModel, lod, scale, G2VertSpace, TransformedVertArray, secondTimeAround);
+	}
+}
+
+// main calling point for the model transform for collision detection. At this point all of the skeleton has been transformed.
+#ifdef _G2_GORE
+void G2_TransformModel(CGhoul2Info_v &ghoul2, const int frameNum, vec3_t scale, CMiniHeap *G2VertSpace, int useLod, bool ApplyGore)
+#else
+void G2_TransformModel(CGhoul2Info_v &ghoul2, const int frameNum, vec3_t scale, CMiniHeap *G2VertSpace, int useLod)
+#endif
+{
+	int				i, lod;
+	vec3_t			correctScale;
+
+
+	VectorCopy(scale, correctScale);
+	// check for scales of 0 - that's the default I believe
+	if (!scale[0])
+	{
+		correctScale[0] = 1.0;
+	}
+	if (!scale[1])
+	{
+		correctScale[1] = 1.0;
+	}
+	if (!scale[2])
+	{
+		correctScale[2] = 1.0;
+	}
+
+	// walk each possible model for this entity and try rendering it out
+	for (i=0; i<ghoul2.size(); i++)
+	{
+		CGhoul2Info &g=ghoul2[i];
+		// don't bother with models that we don't care about.
+		if (!g.mValid)
+		{
+			continue;
+		}
+		assert(g.mBoneCache);
+//		assert(G2_MODEL_OK(&g));
+		// stop us building this model more than once per frame
+		g.mMeshFrameNum = frameNum;
+
+		// decide the LOD
+#ifdef _G2_GORE
+		if (ApplyGore)
+		{
+			lod=useLod;
+			assert(g.currentModel);
+			if (lod>=g.currentModel->numLods)
+			{
+				g.mTransformedVertsArray = 0;
+				return;
+			}
+		}
+		else
+		{
+#endif
+			lod = G2_DecideTraceLod(g, useLod);
+#ifdef _G2_GORE
+		}
+#endif
+
+		// give us space for the transformed vertex array to be put in
+		g.mTransformedVertsArray = (int*)G2VertSpace->MiniHeapAlloc(g.currentModel->mdxm->numSurfaces * 4);
+		if (!g.mTransformedVertsArray)
+		{
+			Com_Error(ERR_DROP, "Ran out of transform space for Ghoul2 Models. Adjust MiniHeapSize in SV_SpawnServer.\n");
+		}
+
+		memset(g.mTransformedVertsArray, 0,(g.currentModel->mdxm->numSurfaces * 4)); 
+
+		G2_FindOverrideSurface(-1,g.mSlist); //reset the quick surface override lookup;
+		// recursively call the model surface transform
+
+		G2_TransformSurfaces(g.mSurfaceRoot, g.mSlist, g.mBoneCache,  g.currentModel, lod, correctScale, G2VertSpace, g.mTransformedVertsArray, false);
+
+#ifdef _G2_GORE
+		if (ApplyGore&&!AddGoreToAllModels)
+		{
+			// we don't really need to do multiple models for gore.
+			break;
+		}
+#endif
+	}
+}
+
+
+// work out how much space a triangle takes
+static float	G2_AreaOfTri(const vec3_t A, const vec3_t B, const vec3_t C)
+{
+	vec3_t	cross, ab, cb;
+	VectorSubtract(A, B, ab);
+	VectorSubtract(C, B, cb);
+
+	CrossProduct(ab, cb, cross);
+
+	return VectorLength(cross);
+}
+
+// actually determine the S and T of the coordinate we hit in a given poly
+static void G2_BuildHitPointST( const vec3_t A, const float SA, const float TA,
+						 const vec3_t B, const float SB, const float TB,
+						 const vec3_t C, const float SC, const float TC,
+						 const vec3_t P, float *s, float *t,float &bary_i,float &bary_j)
+{
+	float	areaABC = G2_AreaOfTri(A, B, C);
+
+	float i = G2_AreaOfTri(P, B, C) / areaABC;
+	bary_i=i;
+	float j = G2_AreaOfTri(A, P, C) / areaABC;
+	bary_j=j;
+	float k = G2_AreaOfTri(A, B, P) / areaABC;
+
+	*s = SA * i + SB * j + SC * k;
+	*t = TA * i + TB * j + TC * k;
+
+	*s=fmod(*s, 1);
+	if (*s< 0)
+	{
+		*s+= 1.0;
+	}
+
+	*t=fmod(*t, 1);
+	if (*t< 0)
+	{
+		*t+= 1.0;
+	}
+
+}
+
+
+// routine that works out given a ray whether or not it hits a poly
+qboolean G2_SegmentTriangleTest( const vec3_t start, const vec3_t end,
+	const vec3_t A, const vec3_t B, const vec3_t C,
+	qboolean backFaces,qboolean frontFaces,vec3_t returnedPoint,vec3_t returnedNormal, float *denom)
+{
+	static const float tiny=1E-10f;
+	vec3_t returnedNormalT;
+	vec3_t edgeAC;
+
+	VectorSubtract(C, A, edgeAC);
+	VectorSubtract(B, A, returnedNormalT); 
+
+	CrossProduct(returnedNormalT, edgeAC, returnedNormal);
+	
+	vec3_t ray;
+	VectorSubtract(end, start, ray);
+
+	*denom=DotProduct(ray, returnedNormal);
+	
+	if (fabs(*denom)<tiny||        // triangle parallel to ray
+		(!backFaces && *denom>0)||		// not accepting back faces
+		(!frontFaces && *denom<0))		//not accepting front faces
+	{
+		return qfalse;
+	}
+
+	vec3_t toPlane;
+	VectorSubtract(A, start, toPlane);
+	
+	float t=DotProduct(toPlane, returnedNormal)/ *denom;
+	
+	if (t<0.0f||t>1.0f)
+	{
+		return qfalse; // off segment
+	}
+	
+	VectorScale(ray, t, ray);
+	
+	VectorAdd(ray, start, returnedPoint);
+
+	vec3_t edgePA;
+	VectorSubtract(A, returnedPoint, edgePA);
+
+	vec3_t edgePB;
+	VectorSubtract(B, returnedPoint, edgePB);
+
+	vec3_t edgePC;
+	VectorSubtract(C, returnedPoint, edgePC);
+	
+	vec3_t temp;
+	
+	CrossProduct(edgePA, edgePB, temp);
+	if (DotProduct(temp, returnedNormal)<0.0f)
+	{
+		return qfalse; // off triangle
+	}
+
+	CrossProduct(edgePC, edgePA, temp);
+	if (DotProduct(temp,returnedNormal)<0.0f)
+	{
+		return qfalse; // off triangle
+	}
+	
+	CrossProduct(edgePB, edgePC, temp);
+	if (DotProduct(temp, returnedNormal)<0.0f)
+	{
+		return qfalse; // off triangle
+	}	
+	return qtrue;
+}
+
+#ifdef _G2_GORE
+struct SVertexTemp
+{
+	int flags;
+	int touch;
+	int newindex;
+	float tex[2];
+	SVertexTemp()
+	{
+		touch=0;
+	}
+};
+
+#define MAX_GORE_VERTS (3000)
+static SVertexTemp GoreVerts[MAX_GORE_VERTS];
+static int GoreIndexCopy[MAX_GORE_VERTS];
+static int GoreTouch=1;
+
+#define MAX_GORE_INDECIES (6000)
+static int GoreIndecies[MAX_GORE_INDECIES];
+
+#define GORE_MARGIN (0.0f)
+int	G2API_GetTime(int argTime);
+
+// now we at poly level, check each model space transformed poly against the model world transfomed ray
+void G2_GorePolys( const mdxmSurface_t *surface, CTraceSurface &TS, const mdxmSurfHierarchy_t *surfInfo)
+{ 
+	int				j;
+	vec3_t basis1;
+	vec3_t basis2;
+	vec3_t taxis;
+	vec3_t saxis;
+
+	basis2[0]=0.0f;
+	basis2[1]=0.0f;
+	basis2[2]=1.0f;
+
+	CrossProduct(TS.rayEnd,basis2,basis1);
+
+	if (DotProduct(basis1,basis1)<.1f)
+	{
+		basis2[0]=0.0f;
+		basis2[1]=1.0f;
+		basis2[2]=0.0f;
+		CrossProduct(TS.rayEnd,basis2,basis1);
+	}
+
+	CrossProduct(TS.rayEnd,basis1,basis2);
+	// Give me a shot direction not a bunch of zeros :) -Gil
+	assert(DotProduct(basis1,basis1)>.0001f);
+	assert(DotProduct(basis2,basis2)>.0001f);
+
+	VectorNormalize(basis1);
+	VectorNormalize(basis2);
+
+	float c=cos(TS.theta);
+	float s=sin(TS.theta);
+
+	VectorScale(basis1,.5f*c/TS.tsize,taxis);
+	VectorMA(taxis,.5f*s/TS.tsize,basis2,taxis);
+
+	VectorScale(basis1,-.5f*s/TS.ssize,saxis);
+	VectorMA(saxis,.5f*c/TS.ssize,basis2,saxis);
+
+	float *verts = (float *)TS.TransformedVertsArray[surface->thisSurfaceIndex];
+	int numVerts = surface->numVerts;
+	int flags=15;
+	assert(numVerts<MAX_GORE_VERTS);
+	for ( j = 0; j < numVerts; j++ ) 
+	{
+		int pos=j*5;
+		vec3_t delta;
+		delta[0]=verts[pos+0]-TS.rayStart[0];
+		delta[1]=verts[pos+1]-TS.rayStart[1];
+		delta[2]=verts[pos+2]-TS.rayStart[2];
+		float s=DotProduct(delta,saxis)+0.5f;
+		float t=DotProduct(delta,taxis)+0.5f;
+		int vflags=0;
+		if (s>GORE_MARGIN)
+		{
+			vflags|=1;
+		}
+		if (s<1.0f-GORE_MARGIN)
+		{
+			vflags|=2;
+		}
+		if (t>GORE_MARGIN)
+		{
+			vflags|=4;
+		}
+		if (t<1.0f-GORE_MARGIN)
+		{
+			vflags|=8;
+		}
+		vflags=(~vflags);
+		flags&=vflags;
+		GoreVerts[j].flags=vflags;
+		GoreVerts[j].tex[0]=s;
+		GoreVerts[j].tex[1]=t;
+	}
+	if (flags)
+	{
+		return; // completely off the gore splotch.
+	}
+	int				numTris,newNumTris,newNumVerts;
+	numTris = surface->numTriangles;
+	mdxmTriangle_t	*tris;
+	tris = (mdxmTriangle_t *) ((byte *)surface + surface->ofsTriangles);
+	verts = (float *)TS.TransformedVertsArray[surface->thisSurfaceIndex];
+	newNumTris=0;
+	newNumVerts=0;
+	GoreTouch++;
+	if (!TS.gore)
+	{
+		return;
+	}
+	for ( j = 0; j < numTris; j++ ) 
+	{
+		assert(tris[j].indexes[0]>=0&&tris[j].indexes[0]<numVerts);
+		assert(tris[j].indexes[1]>=0&&tris[j].indexes[1]<numVerts);
+		assert(tris[j].indexes[2]>=0&&tris[j].indexes[2]<numVerts);
+		flags=15&
+			GoreVerts[tris[j].indexes[0]].flags&
+			GoreVerts[tris[j].indexes[1]].flags&
+			GoreVerts[tris[j].indexes[2]].flags;
+		if (flags)
+		{
+			continue;
+		}
+		if (!TS.gore->frontFaces || !TS.gore->backFaces)
+		{
+			// we need to back/front face cull
+			vec3_t e1,e2,n;
+
+			VectorSubtract(&verts[tris[j].indexes[1]*5],&verts[tris[j].indexes[0]*5],e1);
+			VectorSubtract(&verts[tris[j].indexes[2]*5],&verts[tris[j].indexes[0]*5],e2);
+			CrossProduct(e1,e2,n);
+			if (DotProduct(TS.rayEnd,n)>0.0f)
+			{
+				if (!TS.gore->frontFaces)
+				{
+					continue;
+				}
+			}
+			else
+			{
+				if (!TS.gore->backFaces)
+				{
+					continue;
+				}
+			}
+
+		}
+
+		int k;
+
+		assert(newNumTris*3+3<MAX_GORE_INDECIES);
+		for (k=0;k<3;k++)
+		{
+			if (GoreVerts[tris[j].indexes[k]].touch==GoreTouch)
+			{
+				GoreIndecies[newNumTris*3+k]=GoreVerts[tris[j].indexes[k]].newindex;
+			}
+			else
+			{
+				GoreVerts[tris[j].indexes[k]].touch=GoreTouch;
+				GoreVerts[tris[j].indexes[k]].newindex=newNumVerts;
+				GoreIndecies[newNumTris*3+k]=newNumVerts;
+				GoreIndexCopy[newNumVerts]=tris[j].indexes[k];
+				newNumVerts++;
+			}
+		}
+		newNumTris++;
+	}
+	if (!newNumVerts)
+	{
+		return;
+	}
+
+	int newTag;
+	map<pair<int,int>,int>::iterator f=GoreTagsTemp.find(pair<int,int>(goreModelIndex,TS.surfaceNum));
+	if (f==GoreTagsTemp.end()) // need to generate a record
+	{
+		newTag=AllocGoreRecord();
+		CGoreSet *goreSet=0;
+		if (TS.ghoul2info->mGoreSetTag)
+		{
+			goreSet=FindGoreSet(TS.ghoul2info->mGoreSetTag);
+		}
+		if (!goreSet)
+		{
+			goreSet=NewGoreSet();
+			TS.ghoul2info->mGoreSetTag=goreSet->mMyGoreSetTag;
+		}
+		assert(goreSet);
+		SGoreSurface add;
+		add.shader=TS.goreShader;
+		add.mDeleteTime=0;
+		if (TS.gore->lifeTime)
+		{
+			add.mDeleteTime=G2API_GetTime(0) + TS.gore->lifeTime;
+		}
+		add.mFadeTime = TS.gore->fadeOutTime;
+		add.mFadeRGB = !!(TS.gore->fadeRGB);
+		add.mGoreTag = newTag;
+
+		add.mGoreGrowStartTime=G2API_GetTime(0);
+		if( TS.gore->growDuration == -1)
+		{
+			add.mGoreGrowEndTime = -1;    // set this to -1 to disable growing
+		}
+		else
+		{
+			add.mGoreGrowEndTime = G2API_GetTime(0) + TS.gore->growDuration;
+		}
+
+		assert(TS.gore->growDuration != 0);
+		add.mGoreGrowFactor = ( 1.0f - TS.gore->goreScaleStartFraction) / (float)(TS.gore->growDuration);	//curscale = (curtime-mGoreGrowStartTime)*mGoreGrowFactor;
+		add.mGoreGrowOffset = TS.gore->goreScaleStartFraction;	
+
+		goreSet->mGoreRecords.insert(pair<int,SGoreSurface>(TS.surfaceNum,add));
+		GoreTagsTemp[pair<int,int>(goreModelIndex,TS.surfaceNum)]=newTag;
+	}
+	else
+	{
+		newTag=(*f).second;
+	}
+	GoreTextureCoordinates *gore=FindGoreRecord(newTag);
+	if (gore)
+	{
+		assert(sizeof(float)==sizeof(int));
+		// data block format:
+		unsigned int size=
+			sizeof(int)+ // num verts
+			sizeof(int)+ // num tris
+			sizeof(int)*newNumVerts+ // which verts to copy from original surface
+			sizeof(float)*4*newNumVerts+ // storgage for deformed verts
+			sizeof(float)*4*newNumVerts+ // storgage for deformed normal
+			sizeof(float)*2*newNumVerts+ // texture coordinates
+			sizeof(int)*newNumTris*3;  // new indecies
+
+		int *data=(int *)Z_Malloc ( sizeof(int)*size, TAG_GHOUL2_GORE, qtrue );
+
+#ifdef _DEBUG
+		g_goreTexAllocs++;
+#endif
+
+		if ( gore->tex[TS.lod] )
+		{
+			Z_Free(gore->tex[TS.lod]);
+#ifdef _DEBUG
+			g_goreTexAllocs--;
+#endif
+		}
+
+		gore->tex[TS.lod]=(float *)data;
+		*data++=newNumVerts;
+		*data++=newNumTris;
+
+		memcpy(data,GoreIndexCopy,sizeof(int)*newNumVerts);
+		data+=newNumVerts*9; // skip verts and normals
+		float *fdata=(float *)data;
+
+		for (j=0;j<newNumVerts;j++)
+		{
+			*fdata++=GoreVerts[GoreIndexCopy[j]].tex[0];
+			*fdata++=GoreVerts[GoreIndexCopy[j]].tex[1];
+		}
+		data=(int *)fdata;
+		memcpy(data,GoreIndecies,sizeof(int)*newNumTris*3);
+		data+=newNumTris*3;
+		assert((data-(int *)gore->tex[TS.lod])*sizeof(int)==size);
+		fdata = (float *)data;
+		// build the entity to gore matrix
+		VectorCopy(saxis,fdata+0);
+		VectorCopy(taxis,fdata+4);
+		VectorCopy(TS.rayEnd,fdata+8);
+		VectorNormalize(fdata+0);
+		VectorNormalize(fdata+4);
+		VectorNormalize(fdata+8);
+		fdata[3]=-0.5f; // subtract texture center
+		fdata[7]=-0.5f;
+		fdata[11]=0.0f;
+		vec3_t shotOriginInCurrentSpace; // unknown space
+		TransformPoint(TS.rayStart,shotOriginInCurrentSpace,(mdxaBone_t *)fdata); // dest middle arg
+		// this will insure the shot origin in our unknown space is now the shot origin, making it a known space
+		fdata[3]-=shotOriginInCurrentSpace[0];
+		fdata[7]-=shotOriginInCurrentSpace[1];
+		fdata[11]-=shotOriginInCurrentSpace[2];
+		Inverse_Matrix((mdxaBone_t *)fdata,(mdxaBone_t *)(fdata+12));  // dest 2nd arg
+		data+=24;
+
+//		assert((data - (int *)gore->tex[TS.lod]) * sizeof(int) == size);
+	}
+}
+#else
+struct SVertexTemp
+{
+	int flags;
+//	int touch;
+//	int newindex;
+//	float tex[2];
+	SVertexTemp()
+	{
+//		touch=0;
+	}
+};
+
+#define MAX_GORE_VERTS (3000)
+static SVertexTemp GoreVerts[MAX_GORE_VERTS];
+#endif
+
+// now we're at poly level, check each model space transformed poly against the model world transfomed ray
+static bool G2_TracePolys(const mdxmSurface_t *surface, const mdxmSurfHierarchy_t *surfInfo, CTraceSurface &TS)
+{
+	int				j, numTris;
+	
+	// whip through and actually transform each vertex
+	const mdxmTriangle_t *tris = (mdxmTriangle_t *) ((byte *)surface + surface->ofsTriangles);
+	const float *verts = (float *)TS.TransformedVertsArray[surface->thisSurfaceIndex];
+	numTris = surface->numTriangles;
+	for ( j = 0; j < numTris; j++ ) 
+	{
+		float			face;
+		vec3_t	hitPoint, normal;
+		// determine actual coords for this triangle
+		const float *point1 = &verts[(tris[j].indexes[0] * 5)];
+		const float *point2 = &verts[(tris[j].indexes[1] * 5)];
+		const float *point3 = &verts[(tris[j].indexes[2] * 5)];
+		// did we hit it?
+		int i;
+		if (G2_SegmentTriangleTest(TS.rayStart, TS.rayEnd, point1, point2, point3, qtrue, qtrue, hitPoint, normal, &face))
+		{	// find space in the collision records for this record
+			for (i=0; i<MAX_G2_COLLISIONS;i++)
+			{
+				if (TS.collRecMap[i].mEntityNum == -1)
+				{
+					CollisionRecord_t  	&newCol = TS.collRecMap[i];
+					vec3_t			  	distVect;
+					float				x_pos = 0, y_pos = 0;
+					
+					newCol.mPolyIndex = j;
+					newCol.mEntityNum = TS.entNum;
+					newCol.mSurfaceIndex = surface->thisSurfaceIndex;
+					newCol.mModelIndex = TS.modelIndex;
+					if (face>0)
+					{
+						newCol.mFlags = G2_FRONTFACE;
+					}
+					else
+					{
+						newCol.mFlags = G2_BACKFACE;
+					}
+
+					VectorSubtract(hitPoint, TS.rayStart, distVect);
+					newCol.mDistance = VectorLength(distVect);
+
+					// put the hit point back into world space
+					TransformAndTranslatePoint(hitPoint, newCol.mCollisionPosition, &worldMatrix);
+
+					// transform normal (but don't translate) into world angles
+					TransformPoint(normal, newCol.mCollisionNormal, &worldMatrix);
+					VectorNormalize(newCol.mCollisionNormal);
+
+					newCol.mMaterial = newCol.mLocation = 0;
+
+					// Determine our location within the texture, and barycentric coordinates
+					G2_BuildHitPointST(point1, point1[3], point1[4],
+									   point2, point2[3], point2[4],
+									   point3, point3[3], point3[4],
+									   hitPoint, &x_pos, &y_pos,newCol.mBarycentricI,newCol.mBarycentricJ); 
+									
+/*
+					const shader_t		*shader = 0;
+					// now, we know what surface this hit belongs to, we need to go get the shader handle so we can get the correct hit location and hit material info
+					if ( cust_shader ) 
+					{
+						shader = cust_shader;
+					} 
+					else if ( skin ) 
+					{
+						int		j;
+							
+						// match the surface name to something in the skin file
+						shader = tr.defaultShader;
+						for ( j = 0 ; j < skin->numSurfaces ; j++ )
+						{
+							// the names have both been lowercased
+							if ( !strcmp( skin->surfaces[j]->name, surfInfo->name ) ) 
+							{
+								shader = skin->surfaces[j]->shader;
+								break;
+							}
+						}
+					} 
+					else 
+					{
+						shader = R_GetShaderByHandle( surfInfo->shaderIndex );
+					}
+
+					// do we even care to decide what the hit or location area's are? If we don't have them in the shader there is little point
+					if ((shader->hitLocation) || (shader->hitMaterial))
+					{
+ 						// ok, we have a floating point position. - determine location in data we need to look at
+						if (shader->hitLocation)
+						{
+							newCol.mLocation = *(hitMatReg[shader->hitLocation].loc +
+												((int)(y_pos * hitMatReg[shader->hitLocation].height) * hitMatReg[shader->hitLocation].width) +
+												((int)(x_pos * hitMatReg[shader->hitLocation].width)));
+							Com_Printf("G2_TracePolys hit location: %d\n", newCol.mLocation); 
+						}
+
+						if (shader->hitMaterial)
+						{
+							newCol.mMaterial = *(hitMatReg[shader->hitMaterial].loc +
+												((int)(y_pos * hitMatReg[shader->hitMaterial].height) * hitMatReg[shader->hitMaterial].width) +
+												((int)(x_pos * hitMatReg[shader->hitMaterial].width)));
+						}
+					}
+*/
+					// exit now if we should
+					if (TS.traceFlags == G2_RETURNONHIT)
+					{
+						TS.hitOne = true;
+						return true;
+					}
+
+					break;
+				}
+			}
+			if (i==MAX_G2_COLLISIONS)
+			{
+				//assert(i!=MAX_G2_COLLISIONS);		// run out of collision record space - will probalbly never happen
+				//It happens. And the assert is bugging me.
+				TS.hitOne = true;	//force stop recursion
+				return true;	// return true to avoid wasting further time, but no hit will result without a record
+			}
+		}
+	}
+	return false;
+}
+
+// now we're at poly level, check each model space transformed poly against the model world transfomed ray
+static bool G2_RadiusTracePolys(
+								const mdxmSurface_t *surface, 
+								CTraceSurface &TS
+								)
+{
+	int		j;
+	vec3_t basis1;
+	vec3_t basis2;
+	vec3_t taxis;
+	vec3_t saxis;
+
+	basis2[0]=0.0f;
+	basis2[1]=0.0f;
+	basis2[2]=1.0f;
+
+	vec3_t v3RayDir;
+	VectorSubtract(TS.rayEnd, TS.rayStart, v3RayDir);
+
+	CrossProduct(v3RayDir,basis2,basis1);
+
+	if (DotProduct(basis1,basis1)<.1f)
+	{
+		basis2[0]=0.0f;
+		basis2[1]=1.0f;
+		basis2[2]=0.0f;
+		CrossProduct(v3RayDir,basis2,basis1);
+	}
+
+	CrossProduct(v3RayDir,basis1,basis2);
+	// Give me a shot direction not a bunch of zeros :) -Gil
+//	assert(DotProduct(basis1,basis1)>.0001f);
+//	assert(DotProduct(basis2,basis2)>.0001f);
+
+	VectorNormalize(basis1);
+	VectorNormalize(basis2);
+
+	const float c=cos(0.0f);//theta
+	const float s=sin(0.0f);//theta
+
+	VectorScale(basis1, 0.5f * c / TS.m_fRadius,taxis);
+	VectorMA(taxis,     0.5f * s / TS.m_fRadius,basis2,taxis);
+
+	VectorScale(basis1,-0.5f * s /TS.m_fRadius,saxis);
+	VectorMA(    saxis, 0.5f * c /TS.m_fRadius,basis2,saxis);
+
+	const float * const verts = (float *)TS.TransformedVertsArray[surface->thisSurfaceIndex];
+	const int numVerts = surface->numVerts;
+	
+	int flags=63;
+	//rayDir/=lengthSquared(raydir);
+	const float f = VectorLengthSquared(v3RayDir); 
+	v3RayDir[0]/=f;
+	v3RayDir[1]/=f;
+	v3RayDir[2]/=f;
+
+	for ( j = 0; j < numVerts; j++ ) 
+	{
+		const int pos=j*5;
+		vec3_t delta;
+		delta[0]=verts[pos+0]-TS.rayStart[0];
+		delta[1]=verts[pos+1]-TS.rayStart[1];
+		delta[2]=verts[pos+2]-TS.rayStart[2];
+		const float s=DotProduct(delta,saxis)+0.5f;
+		const float t=DotProduct(delta,taxis)+0.5f;
+		const float u=DotProduct(delta,v3RayDir);
+		int vflags=0;
+
+		if (s>0)
+		{
+			vflags|=1;
+		}
+		if (s<1)
+		{
+			vflags|=2;
+		}
+		if (t>0)
+		{
+			vflags|=4;
+		}
+		if (t<1)
+		{
+			vflags|=8;
+		}
+		if (u>0)
+		{
+			vflags|=16;
+		}
+		if (u<1)
+		{
+			vflags|=32;
+		}
+
+		vflags=(~vflags);
+		flags&=vflags;
+		GoreVerts[j].flags=vflags;
+	}
+
+	if (flags)
+	{
+		return false; // completely off the gore splotch  (so presumably hit nothing? -Ste)
+	}
+	const int numTris = surface->numTriangles;
+	const mdxmTriangle_t * const tris = (mdxmTriangle_t *) ((byte *)surface + surface->ofsTriangles);
+
+	for ( j = 0; j < numTris; j++ ) 
+	{
+		assert(tris[j].indexes[0]>=0&&tris[j].indexes[0]<numVerts);
+		assert(tris[j].indexes[1]>=0&&tris[j].indexes[1]<numVerts);
+		assert(tris[j].indexes[2]>=0&&tris[j].indexes[2]<numVerts);
+		flags=63&
+			GoreVerts[tris[j].indexes[0]].flags&
+			GoreVerts[tris[j].indexes[1]].flags&
+			GoreVerts[tris[j].indexes[2]].flags;
+		int i;
+		if (flags)
+		{
+			continue;
+		}
+		else
+		{
+			// we hit a triangle, so init a collision record...
+			//
+			for (i=0; i<MAX_G2_COLLISIONS;i++)
+			{
+				if (TS.collRecMap[i].mEntityNum == -1)
+				{
+					CollisionRecord_t  	&newCol = TS.collRecMap[i];
+					
+					newCol.mPolyIndex = j;
+					newCol.mEntityNum = TS.entNum;
+					newCol.mSurfaceIndex = surface->thisSurfaceIndex;
+					newCol.mModelIndex = TS.modelIndex;
+//					if (face>0)
+//					{
+						newCol.mFlags = G2_FRONTFACE;
+//					}
+//					else
+//					{
+//						newCol.mFlags = G2_BACKFACE;
+//					}
+
+					//get normal from triangle				
+					const float *A = &verts[(tris[j].indexes[0] * 5)];
+					const float *B = &verts[(tris[j].indexes[1] * 5)];
+					const float *C = &verts[(tris[j].indexes[2] * 5)];
+					vec3_t normal;
+					vec3_t edgeAC, edgeBA;
+
+					VectorSubtract(C, A, edgeAC);
+					VectorSubtract(B, A, edgeBA);
+					CrossProduct(edgeBA, edgeAC, normal);
+
+					// transform normal (but don't translate) into world angles
+					TransformPoint(normal, newCol.mCollisionNormal, &worldMatrix);
+					VectorNormalize(newCol.mCollisionNormal);
+
+					newCol.mMaterial = newCol.mLocation = 0;
+					// exit now if we should
+					if (TS.traceFlags == G2_RETURNONHIT)
+					{
+						TS.hitOne = true;
+						return true;
+					}
+
+
+					vec3_t			  distVect;
+#if 0
+					//i don't know the hitPoint, but let's just assume it's the first vert for now...
+					float *hitPoint = (float *)A;
+#else
+					//yeah, I want the collision point. Let's work out the impact point on the triangle. -rww
+					vec3_t hitPoint;
+					float side, side2;
+					float dist;
+					float third = -(A[0]*(B[1]*C[2] - C[1]*B[2]) + B[0]*(C[1]*A[2] - A[1]*C[2]) + C[0]*(A[1]*B[2] - B[1]*A[2]) );
+
+					VectorSubtract(TS.rayEnd, TS.rayStart, distVect);
+					side = normal[0]*TS.rayStart[0] + normal[1]*TS.rayStart[1] + normal[2]*TS.rayStart[2] + third;
+                    side2 = normal[0]*distVect[0] + normal[1]*distVect[1] + normal[2]*distVect[2];
+					dist = side/side2;
+					VectorMA(TS.rayStart, -dist, distVect, hitPoint);
+#endif
+
+					VectorSubtract(hitPoint, TS.rayStart, distVect);
+					newCol.mDistance = VectorLength(distVect);
+
+					// put the hit point back into world space
+					TransformAndTranslatePoint(hitPoint, newCol.mCollisionPosition, &worldMatrix);
+					newCol.mBarycentricI = newCol.mBarycentricJ = 0.0f;
+					break;
+				}
+			}
+			if (i==MAX_G2_COLLISIONS)
+			{
+				//assert(i!=MAX_G2_COLLISIONS);		// run out of collision record space - happens OFTEN
+				TS.hitOne = true;	//force stop recursion
+				return true;	// return true to avoid wasting further time, but no hit will result without a record
+			}
+		}
+	}
+
+	return false;
+}
+
+
+// look at a surface and then do the trace on each poly
+static void G2_TraceSurfaces(CTraceSurface &TS)
+{
+	int	i;
+	// back track and get the surfinfo struct for this surface
+	assert(TS.currentModel);
+	assert(TS.currentModel->mdxm);
+	const mdxmSurface_t		*surface = (mdxmSurface_t *)G2_FindSurface(TS.currentModel, TS.surfaceNum, TS.lod);
+	const mdxmHierarchyOffsets_t	*surfIndexes = (mdxmHierarchyOffsets_t *)((byte *)TS.currentModel->mdxm + sizeof(mdxmHeader_t));
+	const mdxmSurfHierarchy_t		*surfInfo = (mdxmSurfHierarchy_t *)((byte *)surfIndexes + surfIndexes->offsets[surface->thisSurfaceIndex]);
+	
+	// see if we have an override surface in the surface list
+	const surfaceInfo_t	*surfOverride = G2_FindOverrideSurface(TS.surfaceNum, TS.rootSList);
+
+	// don't allow recursion if we've already hit a polygon
+	if (TS.hitOne)
+	{
+		return;
+	}
+
+	// really, we should use the default flags for this surface unless it's been overriden
+	int offFlags = surfInfo->flags;
+
+	// set the off flags if we have some
+	if (surfOverride)
+	{
+		offFlags = surfOverride->offFlags;
+	}
+
+	// if this surface is not off, try to hit it
+	if (!offFlags)
+	{
+#ifdef _G2_GORE
+		if (TS.collRecMap)
+		{
+#endif
+			if (!(fabs(TS.m_fRadius) < 0.1))	// if not a point-trace
+			{
+				// .. then use radius check
+				//
+				if (G2_RadiusTracePolys(surface,		// const mdxmSurface_t *surface, 
+										TS
+										)
+					&& (TS.traceFlags == G2_RETURNONHIT)
+					)
+				{
+					TS.hitOne = true;
+					return;
+				}
+			}
+			else
+			{
+				// go away and trace the polys in this surface
+				if (G2_TracePolys(surface, surfInfo, TS)
+					&& (TS.traceFlags == G2_RETURNONHIT)
+					)
+				{
+					// ok, we hit one, *and* we want to return instantly because the returnOnHit is set
+					// so indicate we've hit one, so other surfaces don't get hit and return
+					TS.hitOne = true;
+					return;
+				}
+			}
+#ifdef _G2_GORE
+		}
+		else
+		{
+			G2_GorePolys(surface, TS, surfInfo);
+		}
+#endif
+	}
+
+	// if we are turning off all descendants, then stop this recursion now
+	if (offFlags & G2SURFACEFLAG_NODESCENDANTS)
+	{
+		return;
+	}
+
+	// now recursively call for the children
+	for (i=0; i< surfInfo->numChildren && !TS.hitOne; i++)
+	{
+		TS.surfaceNum = surfInfo->childIndexes[i];
+		G2_TraceSurfaces(TS);
+	}
+}
+
+#ifdef _G2_GORE
+void G2_TraceModels(CGhoul2Info_v &ghoul2, vec3_t rayStart, vec3_t rayEnd, CollisionRecord_t *collRecMap, int entNum, int eG2TraceType, int useLod, float fRadius, float ssize,float tsize,float theta,int shader, SSkinGoreData *gore)
+#else
+void G2_TraceModels(CGhoul2Info_v &ghoul2, vec3_t rayStart, vec3_t rayEnd, CollisionRecord_t *collRecMap, int entNum, int eG2TraceType, int useLod, float fRadius)
+#endif
+{
+	int				i, lod;
+	skin_t			*skin;
+	shader_t		*cust_shader;
+
+	// walk each possible model for this entity and try tracing against it
+	for (i=0; i<ghoul2.size(); i++)
+	{
+#ifdef _G2_GORE
+		goreModelIndex=i;
+		// don't bother with models that we don't care about.
+		if (ghoul2[i].mModelindex == -1)
+		{
+			continue;
+		}
+#endif
+
+		// don't bother with models that we don't care about.
+		if (!ghoul2[i].mValid)
+		{
+			continue;
+		}
+//		assert(G2_MODEL_OK(&ghoul2[i]));
+		// do we really want to collide with this object?
+		if (ghoul2[i].mFlags & GHOUL2_NOCOLLIDE) 
+		{
+			continue;
+		}
+		
+		if (ghoul2[i].mCustomShader && ghoul2[i].mCustomShader != -20) //rww - -20 is a server instance (hack)
+		{
+			cust_shader = R_GetShaderByHandle(ghoul2[i].mCustomShader );
+		}
+		else
+		{
+			cust_shader = NULL;
+		}
+
+		// figure out the custom skin thing
+		if ( ghoul2[i].mSkin > 0 && ghoul2[i].mSkin < tr.numSkins ) 
+		{
+			skin = R_GetSkinByHandle( ghoul2[i].mSkin );
+		}
+		else
+		{
+			skin = NULL;
+		}
+
+#ifdef _G2_GORE
+		if (collRecMap)
+		{
+			lod = G2_DecideTraceLod(ghoul2[i],useLod);
+		}
+		else
+		{
+			lod=useLod;
+			assert(ghoul2[i].currentModel);
+			if (lod>=ghoul2[i].currentModel->numLods)
+			{
+				return;
+			}
+		}
+#else
+		lod = G2_DecideTraceLod(ghoul2[i],useLod);
+#endif
+
+		//reset the quick surface override lookup
+		G2_FindOverrideSurface(-1, ghoul2[i].mSlist); 
+
+#ifdef _G2_GORE
+		CTraceSurface TS(ghoul2[i].mSurfaceRoot, ghoul2[i].mSlist,  (model_t *)ghoul2[i].currentModel, lod, rayStart, rayEnd, collRecMap, entNum, i, skin, cust_shader, ghoul2[i].mTransformedVertsArray, eG2TraceType, fRadius, ssize,	tsize, theta, shader, &ghoul2[i], gore);
+#else
+		CTraceSurface TS(ghoul2[i].mSurfaceRoot, ghoul2[i].mSlist,  (model_t *)ghoul2[i].currentModel, lod, rayStart, rayEnd, collRecMap, entNum, i, skin, cust_shader, ghoul2[i].mTransformedVertsArray, eG2TraceType, fRadius);
+#endif
+		// start the surface recursion loop
+		G2_TraceSurfaces(TS);
+
+		// if we've hit one surface on one model, don't bother doing the rest
+		if (TS.hitOne)
+		{
+			break;
+		}
+#ifdef _G2_GORE
+		if (!collRecMap&&!AddGoreToAllModels)
+		{
+			// we don't really need to do multiple models for gore.
+			break;
+		}
+#endif
+	}
+}
+
+void TransformPoint (const vec3_t in, vec3_t out, mdxaBone_t *mat) {
+	for (int i=0;i<3;i++)
+	{
+		out[i]= in[0]*mat->matrix[i][0] + in[1]*mat->matrix[i][1] + in[2]*mat->matrix[i][2];
+	}
+}
+
+void TransformAndTranslatePoint (const vec3_t in, vec3_t out, mdxaBone_t *mat) {
+
+	for (int i=0;i<3;i++)
+	{
+		out[i]= in[0]*mat->matrix[i][0] + in[1]*mat->matrix[i][1] + in[2]*mat->matrix[i][2] + mat->matrix[i][3];
+	}
+}
+
+
+// create a matrix using a set of angles
+void Create_Matrix(const float *angle, mdxaBone_t *matrix)
+{
+	vec3_t		axis[3];
+
+	// convert angles to axis
+	AnglesToAxis( angle, axis );
+	matrix->matrix[0][0] = axis[0][0];
+	matrix->matrix[1][0] = axis[0][1];
+	matrix->matrix[2][0] = axis[0][2];
+
+	matrix->matrix[0][1] = axis[1][0];
+	matrix->matrix[1][1] = axis[1][1];
+	matrix->matrix[2][1] = axis[1][2];
+
+	matrix->matrix[0][2] = axis[2][0];
+	matrix->matrix[1][2] = axis[2][1];
+	matrix->matrix[2][2] = axis[2][2];
+
+	matrix->matrix[0][3] = 0;
+	matrix->matrix[1][3] = 0;
+	matrix->matrix[2][3] = 0;
+
+
+}
+
+// given a matrix, generate the inverse of that matrix
+void Inverse_Matrix(mdxaBone_t *src, mdxaBone_t *dest)
+{
+	int i, j;
+
+    for (i = 0; i < 3; i++)
+	{
+        for (j = 0; j < 3; j++)
+		{
+            dest->matrix[i][j]=src->matrix[j][i];
+		}
+	}
+    for (i = 0; i < 3; i++)
+	{
+        dest->matrix[i][3]=0;
+        for (j = 0; j < 3; j++)
+		{
+            dest->matrix[i][3]-=dest->matrix[i][j]*src->matrix[j][3];
+		}
+	}
+}
+
+// generate the world matrix for a given set of angles and origin - called from lots of places
+void G2_GenerateWorldMatrix(const vec3_t angles, const vec3_t origin)
+{
+	Create_Matrix(angles, &worldMatrix);
+	worldMatrix.matrix[0][3] = origin[0];
+	worldMatrix.matrix[1][3] = origin[1];
+	worldMatrix.matrix[2][3] = origin[2];
+
+	Inverse_Matrix(&worldMatrix, &worldMatrixInv);
+}
+
+// go away and determine what the pointer for a specific surface definition within the model definition is
+void *G2_FindSurface(void *mod_t, int index, int lod)
+{
+	// damn include file dependancies
+	model_t	*mod = (model_t *)mod_t;
+
+	// point at first lod list
+	byte	*current = (byte*)((int)mod->mdxm + (int)mod->mdxm->ofsLODs);
+	int i;
+
+	//walk the lods
+	for (i=0; i<lod; i++)
+	{
+		mdxmLOD_t *lodData = (mdxmLOD_t *)current;
+		current += lodData->ofsEnd;
+	}
+
+	// avoid the lod pointer data structure
+	current += sizeof(mdxmLOD_t);
+
+	mdxmLODSurfOffset_t *indexes = (mdxmLODSurfOffset_t *)current;
+	// we are now looking at the offset array
+	current += indexes->offsets[index];
+
+	return (void *)current;
+}
+
+#define SURFACE_SAVE_BLOCK_SIZE	sizeof(surfaceInfo_t)
+#define BOLT_SAVE_BLOCK_SIZE (sizeof(boltInfo_t) - sizeof(mdxaBone_t))
+#define BONE_SAVE_BLOCK_SIZE sizeof(boneInfo_t)
+
+qboolean G2_SaveGhoul2Models(CGhoul2Info_v &ghoul2, char **buffer, int *size)
+{
+
+	// is there anything to save?
+	if (!ghoul2.size())
+	{
+		*buffer = (char *)Z_Malloc(4, TAG_GHOUL2, qtrue);
+		int *tempBuffer = (int *)*buffer;
+		*tempBuffer = 0;
+		*size = 4;
+		return qtrue;
+	}
+
+	// yeah, lets get busy
+	*size = 0;
+
+	// this one isn't a define since I couldn't work out how to figure it out at compile time
+	int ghoul2BlockSize = (int)&ghoul2[0].mTransformedVertsArray - (int)&ghoul2[0].mModelindex;
+
+	// add in count for number of ghoul2 models
+	*size += 4;	
+	// start out working out the total size of the buffer we need to allocate
+	int i; // Linux GCC is forcing new scoping rules
+	for (i=0; i<ghoul2.size();i++)
+	{
+		*size += ghoul2BlockSize;
+		// add in count for number of surfaces
+		*size += 4;	
+		*size += (ghoul2[i].mSlist.size() * SURFACE_SAVE_BLOCK_SIZE);
+		// add in count for number of bones
+		*size += 4;	
+		*size += (ghoul2[i].mBlist.size() * BONE_SAVE_BLOCK_SIZE);
+		// add in count for number of bolts
+		*size += 4;	
+		*size += (ghoul2[i].mBltlist.size() * BOLT_SAVE_BLOCK_SIZE);
+	}
+
+	// ok, we should know how much space we need now
+	*buffer = (char*)Z_Malloc(*size, TAG_GHOUL2, qtrue);
+
+	// now lets start putting the data we care about into the buffer
+	char *tempBuffer = *buffer;
+
+	// save out how many ghoul2 models we have
+	*(int *)tempBuffer = ghoul2.size();
+	tempBuffer +=4;
+
+	for (i=0; i<ghoul2.size();i++)
+	{
+		// first save out the ghoul2 details themselves
+//		OutputDebugString(va("G2_SaveGhoul2Models(): ghoul2[%d].mModelindex = %d\n",i,ghoul2[i].mModelindex));
+		memcpy(tempBuffer, &ghoul2[i].mModelindex, ghoul2BlockSize);
+		tempBuffer += ghoul2BlockSize;
+
+		// save out how many surfaces we have
+		*(int*)tempBuffer = ghoul2[i].mSlist.size();
+		tempBuffer +=4;
+
+		// now save the all the surface list info
+		int x;
+		for (x=0; x<ghoul2[i].mSlist.size(); x++)
+		{
+			memcpy(tempBuffer, &ghoul2[i].mSlist[x], SURFACE_SAVE_BLOCK_SIZE);
+			tempBuffer += SURFACE_SAVE_BLOCK_SIZE;
+		}
+		
+		// save out how many bones we have
+		*(int*)tempBuffer = ghoul2[i].mBlist.size();
+		tempBuffer +=4;
+
+		// now save the all the bone list info
+		for (x=0; x<ghoul2[i].mBlist.size(); x++)
+		{
+			memcpy(tempBuffer, &ghoul2[i].mBlist[x], BONE_SAVE_BLOCK_SIZE);
+			tempBuffer += BONE_SAVE_BLOCK_SIZE;
+		}
+
+		// save out how many bolts we have
+		*(int*)tempBuffer = ghoul2[i].mBltlist.size();
+		tempBuffer +=4;
+
+		// lastly save the all the bolt list info
+		for (x=0; x<ghoul2[i].mBltlist.size(); x++)
+		{
+			memcpy(tempBuffer, &ghoul2[i].mBltlist[x], BOLT_SAVE_BLOCK_SIZE);
+			tempBuffer += BOLT_SAVE_BLOCK_SIZE;
+		}
+	}
+
+	return qtrue;
+}
+
+// have to free space malloced in the save system here because the game DLL can't.
+void G2_FreeSaveBuffer(char *buffer)
+{
+	Z_Free(buffer);
+}
+
+int G2_FindConfigStringSpace(char *name, int start, int max)
+{
+	char	s[MAX_STRING_CHARS];
+	int i;
+	for ( i=1 ; i<max ; i++ ) 
+	{
+		SV_GetConfigstring( start + i, s, sizeof( s ) );
+		if ( !s[0] ) 
+		{
+			break;
+		}
+		if ( !stricmp( s, name ) ) 
+		{
+			return i;
+		}
+	}
+
+	SV_SetConfigstring(start + i, name);
+	return i;
+}
+
+qboolean G2_SetupModelPointers(CGhoul2Info *ghlInfo);
+qboolean G2_SetupModelPointers(CGhoul2Info_v &ghoul2);
+
+void G2_LoadGhoul2Model(CGhoul2Info_v &ghoul2, char *buffer)
+{
+	// first thing, lets see how many ghoul2 models we have, and resize our buffers accordingly
+	int newSize = *(int*)buffer;
+	ghoul2.resize(newSize);
+	buffer += 4;
+
+	// did we actually resize to a value?
+	if (!newSize)
+	{
+		// no, ok, well, done then.
+		return;
+	}
+
+	// this one isn't a define since I couldn't work out how to figure it out at compile time
+	int ghoul2BlockSize = (int)&ghoul2[0].mTransformedVertsArray - (int)&ghoul2[0].mModelindex;
+
+	// now we have enough instances, lets go through each one and load up the relevant details
+	for (int i=0; i<ghoul2.size(); i++)
+	{
+		ghoul2[i].mSkelFrameNum = 0;
+		ghoul2[i].mModelindex=-1;
+		ghoul2[i].mFileName[0]=0;
+		ghoul2[i].mValid=false;
+		// load the ghoul2 info from the buffer
+		memcpy(&ghoul2[i].mModelindex, buffer, ghoul2BlockSize);
+//		OutputDebugString(va("G2_LoadGhoul2Model(): ghoul2[%d].mModelindex = %d\n",i,ghoul2[i].mModelindex));
+		buffer +=ghoul2BlockSize;
+
+		if (ghoul2[i].mModelindex!=-1&&ghoul2[i].mFileName[0])
+		{
+			ghoul2[i].mModelindex = i;
+			G2_SetupModelPointers(&ghoul2[i]);
+		}
+
+		// give us enough surfaces to load up the data
+		ghoul2[i].mSlist.resize(*(int*)buffer);
+		buffer +=4;
+
+		// now load all the surfaces
+		int x;
+		for (x=0; x<ghoul2[i].mSlist.size(); x++)
+		{
+			memcpy(&ghoul2[i].mSlist[x], buffer, SURFACE_SAVE_BLOCK_SIZE);
+			buffer += SURFACE_SAVE_BLOCK_SIZE;
+		}
+
+		// give us enough bones to load up the data
+		ghoul2[i].mBlist.resize(*(int*)buffer);
+		buffer +=4;
+
+		// now load all the bones
+		for (x=0; x<ghoul2[i].mBlist.size(); x++)
+		{
+			memcpy(&ghoul2[i].mBlist[x], buffer, BONE_SAVE_BLOCK_SIZE);
+			buffer += BONE_SAVE_BLOCK_SIZE;
+		}
+
+		// give us enough bolts to load up the data
+		ghoul2[i].mBltlist.resize(*(int*)buffer);
+		buffer +=4;
+
+		// now load all the bolts
+		for (x=0; x<ghoul2[i].mBltlist.size(); x++)
+		{
+			memcpy(&ghoul2[i].mBltlist[x], buffer, BOLT_SAVE_BLOCK_SIZE);
+			buffer += BOLT_SAVE_BLOCK_SIZE;
+		}
+	}
+}
+
+void G2_LerpAngles(CGhoul2Info_v &ghoul2,CGhoul2Info_v &nextGhoul2, float interpolation)
+{
+	// loop each model
+	for (int i=0; i< ghoul2.size(); i++)
+	{
+		if (ghoul2[i].mModelindex != -1)
+		{
+			// now walk the bone list
+			for (int x = 0; x < ghoul2[i].mBlist.size(); x++)
+			{
+				boneInfo_t	&bone = ghoul2[i].mBlist[x];
+				// sure we have one to lerp to?
+				if ((nextGhoul2.size() > i) &&
+					(nextGhoul2[i].mModelindex != -1) &&
+					(nextGhoul2[i].mBlist.size() > x) &&
+					(nextGhoul2[i].mBlist[x].boneNumber != -1))
+				{
+					boneInfo_t	&nextBone = nextGhoul2[i].mBlist[x];
+					// does this bone override actually have anything in it, and if it does, is it a bone angles override?
+					if ((bone.boneNumber != -1) && ((bone.flags) & (BONE_ANGLES_TOTAL)))
+					{
+						float *nowMatrix = (float*) &bone.matrix;
+						float *nextMatrix = (float*) &nextBone.matrix;
+						float *newMatrix = (float*) &bone.newMatrix;
+						// now interpolate the matrix
+						for (int z=0; z < 12; z++)
+						{
+							newMatrix[z] = nowMatrix[z] + interpolation * ( nextMatrix[z] - nowMatrix[z] );
+						}
+					}
+				}
+				else
+				{
+					memcpy(&ghoul2[i].mBlist[x].newMatrix, &ghoul2[i].mBlist[x].matrix, sizeof(mdxaBone_t));
+				}
+			}
+		}
+	}
+}
diff --git a/codemp/ghoul2/G2_surfaces.cpp b/codemp/ghoul2/G2_surfaces.cpp
new file mode 100644
index 0000000..16dca4e
--- /dev/null
+++ b/codemp/ghoul2/G2_surfaces.cpp
@@ -0,0 +1,677 @@
+// leave this as first line for PCH reasons...
+//
+
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+
+#if !defined(TR_LOCAL_H)
+	#include "../renderer/tr_local.h"
+#endif
+
+#if !defined(G2_H_INC)
+	#include "G2.h"
+#endif
+	#include "G2_local.h"
+#pragma warning(disable : 4512)		//assignment op could not be genereated
+
+class CConstructBoneList
+{
+public:
+	int				surfaceNum;
+	int				*boneUsedList;
+	surfaceInfo_v	&rootSList;
+	model_t			*currentModel;
+	boneInfo_v		&boneList; 
+
+	CConstructBoneList(
+	int				initsurfaceNum,
+	int				*initboneUsedList,
+	surfaceInfo_v	&initrootSList,
+	model_t			*initcurrentModel,
+	boneInfo_v		&initboneList):
+
+	surfaceNum(initsurfaceNum),
+	boneUsedList(initboneUsedList),
+	rootSList(initrootSList),
+	currentModel(initcurrentModel),
+	boneList(initboneList) { }
+};
+
+extern void G2_ConstructUsedBoneList(CConstructBoneList &CBL);
+
+
+//=====================================================================================================================
+// Surface List handling routines - so entities can determine what surfaces attached to a model are operational or not.
+
+// find a particular surface in the surface override list
+surfaceInfo_t *G2_FindOverrideSurface(int surfaceNum, surfaceInfo_v &surfaceList)
+{
+	int i; 
+	
+	// look through entire list
+	for(i=0; i<surfaceList.size(); i++)
+	{
+		if (surfaceList[i].surface == surfaceNum)
+		{
+			return &surfaceList[i];
+		}
+	}
+	// didn't find it.
+	return NULL;
+}
+
+// given a surface name, lets see if it's legal in the model
+int G2_IsSurfaceLegal(void *mod, const char *surfaceName, int *flags)
+{
+	// damn include file dependancies
+	mdxmSurfHierarchy_t	*surf;
+	model_t *mod_m = (model_t *)mod;
+	surf = (mdxmSurfHierarchy_t *) ( (byte *)mod_m->mdxm + mod_m->mdxm->ofsSurfHierarchy );
+
+	for ( int i = 0 ; i < mod_m->mdxm->numSurfaces ; i++) 
+	{
+	 	if (!stricmp(surfaceName, surf->name))
+	 	{
+			*flags = surf->flags;
+			return i;
+		}
+		// find the next surface
+  		surf = (mdxmSurfHierarchy_t *)( (byte *)surf + (int)( &((mdxmSurfHierarchy_t *)0)->childIndexes[ surf->numChildren ] ));
+	}
+	return -1;
+}
+
+
+/************************************************************************************************
+ * G2_FindSurface
+ *    find a surface in a ghoul2 surface override list based on it's name
+ *
+ * Input
+ *    filename of model, surface list of model instance, name of surface, int to be filled in
+ * with the index of this surface (defaults to NULL)
+ *
+ * Output
+ *    pointer to surface if successful, false otherwise
+ *
+ ************************************************************************************************/
+mdxmSurface_t *G2_FindSurface(CGhoul2Info *ghlInfo, surfaceInfo_v &slist, const char *surfaceName,
+							 int *surfIndex/*NULL*/)
+{
+	int						i = 0;
+	// find the model we want
+	model_t				*mod = (model_t *)ghlInfo->currentModel;
+	mdxmHierarchyOffsets_t *surfIndexes = (mdxmHierarchyOffsets_t *)((byte *)mod->mdxm + sizeof(mdxmHeader_t));
+	mdxmSurfHierarchy_t	*surfInfo;
+
+	// did we find a ghoul 2 model or not?
+	if (!mod->mdxm)
+	{
+		assert(0);
+		if (surfIndex)
+		{
+			*surfIndex = -1;
+		}
+		return 0;
+	}
+   
+ 	// first find if we already have this surface in the list
+	for (i = slist.size() - 1; i >= 0; i--)
+	{
+		if ((slist[i].surface != 10000) && (slist[i].surface != -1))
+		{
+			mdxmSurface_t	*surf = (mdxmSurface_t *)G2_FindSurface((void *)mod, slist[i].surface, 0);
+			// back track and get the surfinfo struct for this surface
+			surfInfo = (mdxmSurfHierarchy_t *)((byte *)surfIndexes + surfIndexes->offsets[surf->thisSurfaceIndex]);
+
+  			// are these the droids we're looking for?
+			if (!stricmp (surfInfo->name, surfaceName))
+			{
+				// yup
+				if (surfIndex)
+				{
+					*surfIndex = i;
+				}
+				return surf;
+			}
+		}
+	}
+	// didn't find it
+	if (surfIndex)
+	{
+		*surfIndex = -1;
+	}
+	return 0;
+}
+
+// set a named surface offFlags - if it doesn't find a surface with this name in the list then it will add one.
+qboolean G2_SetSurfaceOnOff (CGhoul2Info *ghlInfo, surfaceInfo_v &slist, const char *surfaceName, const int offFlags)
+{
+	int					surfIndex = -1;
+	surfaceInfo_t		temp_slist_entry;
+	mdxmSurface_t		*surf;	
+	// find the model we want
+	model_t				*mod = (model_t *)ghlInfo->currentModel;
+
+	// did we find a ghoul 2 model or not?
+	if (!mod->mdxm)
+	{
+		assert(0);
+		return qfalse;
+	}
+ 
+ 	// first find if we already have this surface in the list
+	surf = G2_FindSurface(ghlInfo, slist, surfaceName, &surfIndex);
+	if (surf)
+	{
+		// set descendants value
+
+		// slist[surfIndex].offFlags = offFlags;
+		// seems to me that we shouldn't overwrite the other flags.
+		// the only bit we really care about in the incoming flags is the off bit
+		slist[surfIndex].offFlags &= ~(G2SURFACEFLAG_OFF | G2SURFACEFLAG_NODESCENDANTS);
+		slist[surfIndex].offFlags |= offFlags & (G2SURFACEFLAG_OFF | G2SURFACEFLAG_NODESCENDANTS);
+		return qtrue;
+	}
+	else
+	{
+		// ok, not in the list already - in that case, lets verify this surface exists in the model mesh
+		int	flags;
+		int surfaceNum = G2_IsSurfaceLegal((void*)mod, surfaceName, &flags);
+		if (surfaceNum != -1)
+		{
+			int newflags = flags;
+			// the only bit we really care about in the incoming flags is the off bit
+			newflags &= ~(G2SURFACEFLAG_OFF | G2SURFACEFLAG_NODESCENDANTS);
+			newflags |= offFlags & (G2SURFACEFLAG_OFF | G2SURFACEFLAG_NODESCENDANTS);
+
+			if (newflags != flags)
+			{	// insert here then because it changed, no need to add an override otherwise
+				temp_slist_entry.offFlags = newflags;
+				temp_slist_entry.surface = surfaceNum;
+				
+				slist.push_back(temp_slist_entry);
+			}
+			return qtrue;
+		}
+	}
+	return qfalse;
+}
+
+void G2_SetSurfaceOnOffFromSkin (CGhoul2Info *ghlInfo, qhandle_t renderSkin)
+{
+	int j;
+	const skin_t	*skin = R_GetSkinByHandle( renderSkin );
+
+	ghlInfo->mSlist.clear();	//remove any overrides we had before.
+	ghlInfo->mMeshFrameNum = 0;
+
+	for ( j = 0 ; j < skin->numSurfaces ; j++ )
+	{
+		// the names have both been lowercased
+		if ( !strcmp( skin->surfaces[j]->shader->name , "*off") ) 
+		{
+			G2_SetSurfaceOnOff(ghlInfo, ghlInfo->mSlist, skin->surfaces[j]->name, G2SURFACEFLAG_OFF);
+		}
+		else 
+		{
+			int	flags;
+			int surfaceNum = G2_IsSurfaceLegal((void *)ghlInfo->currentModel, skin->surfaces[j]->name, &flags);
+			if ( (surfaceNum != -1) && (!(flags&G2SURFACEFLAG_OFF)) )	//only turn on if it's not an "_off" surface
+			{
+				G2_SetSurfaceOnOff(ghlInfo, ghlInfo->mSlist, skin->surfaces[j]->name, 0);
+			}
+		}
+	}
+}
+
+// return a named surfaces off flags - should tell you if this surface is on or off.
+int G2_IsSurfaceOff (CGhoul2Info *ghlInfo, surfaceInfo_v &slist, const char *surfaceName)
+{
+	model_t				*mod = (model_t *)ghlInfo->currentModel;
+	int					surfIndex = -1;
+	mdxmSurface_t		*surf = 0;
+
+	// did we find a ghoul 2 model or not?
+	if (!mod->mdxm)
+	{
+		return 0;
+	}
+   
+ 	// first find if we already have this surface in the list
+	surf = G2_FindSurface(ghlInfo, slist, surfaceName, &surfIndex);
+	if (surf)
+	{
+		// set descendants value
+		return slist[surfIndex].offFlags;
+	}
+	// ok, we didn't find it in the surface list. Lets look at the original surface then.
+
+	mdxmSurfHierarchy_t	*surface = (mdxmSurfHierarchy_t *) ( (byte *)mod->mdxm + mod->mdxm->ofsSurfHierarchy );
+
+	for ( int i = 0 ; i < mod->mdxm->numSurfaces ; i++) 
+	{
+	 	if (!stricmp(surfaceName, surface->name))
+	 	{
+			return surface->flags;
+		}
+		// find the next surface
+  		surface = (mdxmSurfHierarchy_t *)( (byte *)surface + (int)( &((mdxmSurfHierarchy_t *)0)->childIndexes[ surface->numChildren ] ));
+	}
+
+	assert(0);
+	return 0;
+}
+
+void G2_FindRecursiveSurface(model_t *currentModel, int surfaceNum, surfaceInfo_v &rootList, int *activeSurfaces)
+{
+	int						i;
+ 	mdxmSurface_t			*surface = (mdxmSurface_t *)G2_FindSurface((void *)currentModel, surfaceNum, 0);
+	mdxmHierarchyOffsets_t	*surfIndexes = (mdxmHierarchyOffsets_t *)((byte *)currentModel->mdxm + sizeof(mdxmHeader_t));
+	mdxmSurfHierarchy_t		*surfInfo = (mdxmSurfHierarchy_t *)((byte *)surfIndexes + surfIndexes->offsets[surface->thisSurfaceIndex]);
+
+	// see if we have an override surface in the surface list
+	surfaceInfo_t	*surfOverride = G2_FindOverrideSurface(surfaceNum, rootList);
+
+	// really, we should use the default flags for this surface unless it's been overriden
+	int offFlags = surfInfo->flags;
+
+	// set the off flags if we have some
+	if (surfOverride)
+	{
+		offFlags = surfOverride->offFlags;
+	}
+
+	// if this surface is not off, indicate as such in the active surface list
+	if (!(offFlags & G2SURFACEFLAG_OFF))
+	{
+		activeSurfaces[surfaceNum] = 1;
+	}
+ 	else
+	// if we are turning off all descendants, then stop this recursion now
+	if (offFlags & G2SURFACEFLAG_NODESCENDANTS)
+	{
+		return;
+	}
+
+	// now recursively call for the children
+	for (i=0; i< surfInfo->numChildren; i++)
+	{
+		surfaceNum = surfInfo->childIndexes[i];
+		G2_FindRecursiveSurface(currentModel, surfaceNum, rootList, activeSurfaces);
+	}
+
+}
+
+void G2_RemoveRedundantGeneratedSurfaces(surfaceInfo_v &slist, int *activeSurfaces)
+{
+	int		i;
+
+	// walk the surface list, removing surface overrides or generated surfaces that are pointing at surfaces that aren't active anymore
+	for (i=0; i<slist.size(); i++)
+	{
+		if (slist[i].surface != -1)
+		{
+			// is this a generated surface?
+			if (slist[i].offFlags & G2SURFACEFLAG_GENERATED)
+			{
+				// if it's not in the list, remove it
+				if (!activeSurfaces[slist[i].genPolySurfaceIndex & 0xffff])
+				{
+					G2_RemoveSurface(slist, i);
+				}
+			}
+			// no, so it does point back at a legal surface
+			else
+			{
+				// if it's not in the list, remove it
+				if (!activeSurfaces[slist[i].surface])
+				{
+					G2_RemoveSurface(slist, i);
+				}
+			}
+		}
+	}
+}
+
+qboolean G2_SetRootSurface(CGhoul2Info_v &ghoul2, const int modelIndex, const char *surfaceName)
+{
+	int					surf;
+	int					flags;
+	int					*activeSurfaces, *activeBones;
+
+	assert(ghoul2[modelIndex].currentModel && ghoul2[modelIndex].animModel);
+
+	model_t				*mod_m = (model_t *)ghoul2[modelIndex].currentModel;
+	model_t				*mod_a = (model_t *)ghoul2[modelIndex].animModel;
+
+	// did we find a ghoul 2 model or not?
+	if (!mod_m->mdxm)
+	{
+		return qfalse;
+	}
+
+	// first find if we already have this surface in the list
+	surf = G2_IsSurfaceLegal(mod_m, surfaceName, &flags);
+	if (surf != -1)
+	{
+		// first see if this ghoul2 model already has this as a root surface
+		if (ghoul2[modelIndex].mSurfaceRoot == surf)
+		{
+			return qtrue;
+		}
+
+		// set the root surface
+		ghoul2[modelIndex].mSurfaceRoot = surf;
+
+		// ok, now the tricky bits.
+		// firstly, generate a list of active / on surfaces below the root point
+
+		// gimme some space to put this list into
+		activeSurfaces = (int *)Z_Malloc(mod_m->mdxm->numSurfaces * 4, TAG_GHOUL2, qtrue);
+		memset(activeSurfaces, 0, (mod_m->mdxm->numSurfaces * 4));
+		activeBones = (int *)Z_Malloc(mod_a->mdxa->numBones * 4, TAG_GHOUL2, qtrue);
+		memset(activeBones, 0, (mod_a->mdxa->numBones * 4));
+
+		G2_FindRecursiveSurface(mod_m, surf, ghoul2[modelIndex].mSlist, activeSurfaces);
+
+		// now generate the used bone list
+		CConstructBoneList	CBL(ghoul2[modelIndex].mSurfaceRoot, 
+							activeBones,
+							ghoul2[modelIndex].mSlist,
+							mod_m,
+							ghoul2[modelIndex].mBlist);
+
+		G2_ConstructUsedBoneList(CBL);
+
+		// now remove all procedural or override surfaces that refer to surfaces that arent on this list
+		G2_RemoveRedundantGeneratedSurfaces(ghoul2[modelIndex].mSlist, activeSurfaces);
+
+		// now remove all bones that are pointing at bones that aren't active
+		G2_RemoveRedundantBoneOverrides(ghoul2[modelIndex].mBlist, activeBones);
+
+		// then remove all bolts that point at surfaces or bones that *arent* active.
+		G2_RemoveRedundantBolts(ghoul2[modelIndex].mBltlist, ghoul2[modelIndex].mSlist, activeSurfaces, activeBones);
+
+		// then remove all models on this ghoul2 instance that use those bolts that are being removed.
+		for (int i=0; i<ghoul2.size(); i++)
+		{
+			// are we even bolted to anything?
+			if (ghoul2[i].mModelBoltLink != -1)
+			{
+				int	boltMod = (ghoul2[i].mModelBoltLink >> MODEL_SHIFT) & MODEL_AND;
+				int	boltNum = (ghoul2[i].mModelBoltLink >> BOLT_SHIFT) & BOLT_AND;
+				// if either the bolt list is too small, or the bolt we are pointing at references nothing, remove this model
+				if ((ghoul2[boltMod].mBltlist.size() <= boltNum) || 
+					((ghoul2[boltMod].mBltlist[boltNum].boneNumber == -1) && 
+					 (ghoul2[boltMod].mBltlist[boltNum].surfaceNumber == -1)))
+				{
+					CGhoul2Info_v *g2i = &ghoul2;
+					G2API_RemoveGhoul2Model((CGhoul2Info_v **)&g2i, i);
+				}
+			}
+		}
+		//No support for this, for now.
+
+		// remember to free what we used
+		Z_Free(activeSurfaces);
+		Z_Free(activeBones);
+
+		return (qtrue);
+	}
+/*
+//g2r	if (entstate->ghoul2)
+	{
+		CGhoul2Info_v &ghoul2 = *((CGhoul2Info_v *)entstate->ghoul2);
+		model_t				*mod_m = R_GetModelByHandle(RE_RegisterModel(ghoul2[modelIndex].mFileName));
+		model_t				*mod_a = R_GetModelByHandle(mod_m->mdxm->animIndex); 
+		int					surf;
+		int					flags;
+		int					*activeSurfaces, *activeBones;
+
+		// did we find a ghoul 2 model or not?
+		if (!mod_m->mdxm)
+		{
+			return qfalse;
+		}
+
+ 		// first find if we already have this surface in the list
+		surf = G2_IsSurfaceLegal(mod_m, surfaceName, &flags);
+		if (surf != -1)
+		{
+			// first see if this ghoul2 model already has this as a root surface
+			if (ghoul2[modelIndex].mSurfaceRoot == surf)
+			{
+				return qtrue;
+			}
+
+			// set the root surface
+			ghoul2[modelIndex].mSurfaceRoot = surf;
+
+			// ok, now the tricky bits.
+			// firstly, generate a list of active / on surfaces below the root point
+
+			// gimme some space to put this list into
+			activeSurfaces = (int *)Z_Malloc(mod_m->mdxm->numSurfaces * 4, TAG_GHOUL2, qtrue);
+			memset(activeSurfaces, 0, (mod_m->mdxm->numSurfaces * 4));
+			activeBones = (int *)Z_Malloc(mod_a->mdxa->numBones * 4, TAG_GHOUL2, qtrue);
+			memset(activeBones, 0, (mod_a->mdxa->numBones * 4));
+
+			G2_FindRecursiveSurface(mod_m, surf, ghoul2[modelIndex].mSlist, activeSurfaces);
+
+			// now generate the used bone list
+			CConstructBoneList	CBL(ghoul2[modelIndex].mSurfaceRoot, 
+								activeBones,
+								ghoul2[modelIndex].mSlist,
+								mod_m,
+								ghoul2[modelIndex].mBlist);
+
+			G2_ConstructUsedBoneList(CBL);
+
+			// now remove all procedural or override surfaces that refer to surfaces that arent on this list
+			G2_RemoveRedundantGeneratedSurfaces(ghoul2[modelIndex].mSlist, activeSurfaces);
+
+			// now remove all bones that are pointing at bones that aren't active
+			G2_RemoveRedundantBoneOverrides(ghoul2[modelIndex].mBlist, activeBones);
+
+			// then remove all bolts that point at surfaces or bones that *arent* active.
+			G2_RemoveRedundantBolts(ghoul2[modelIndex].mBltlist, ghoul2[modelIndex].mSlist, activeSurfaces, activeBones);
+
+			// then remove all models on this ghoul2 instance that use those bolts that are being removed.
+			for (int i=0; i<ghoul2.size(); i++)
+			{
+				// are we even bolted to anything?
+				if (ghoul2[i].mModelBoltLink != -1)
+				{
+					int	boltMod = (ghoul2[i].mModelBoltLink >> MODEL_SHIFT) & MODEL_AND;
+					int	boltNum = (ghoul2[i].mModelBoltLink >> BOLT_SHIFT) & BOLT_AND;
+					// if either the bolt list is too small, or the bolt we are pointing at references nothing, remove this model
+					if ((ghoul2[boltMod].mBltlist.size() <= boltNum) || 
+						((ghoul2[boltMod].mBltlist[boltNum].boneNumber == -1) && 
+						 (ghoul2[boltMod].mBltlist[boltNum].surfaceNumber == -1)))
+					{
+						G2API_RemoveGhoul2Model(entstate, i);
+					}
+				}
+			}
+
+			// remember to free what we used
+			Z_Free(activeSurfaces);
+			Z_Free(activeBones);
+
+			return (qtrue);
+		}
+	}
+	assert(0);*/
+	return qfalse;
+}
+
+
+extern int G2_DecideTraceLod(CGhoul2Info &ghoul2, int useLod);
+int G2_AddSurface(CGhoul2Info *ghoul2, int surfaceNumber, int polyNumber, float BarycentricI, float BarycentricJ, int lod )
+{
+
+	surfaceInfo_t temp_slist_entry;
+
+	// decide if LOD is legal
+	lod = G2_DecideTraceLod(*(CGhoul2Info *)(ghoul2), lod);
+
+	// first up, see if we have a free one already set up  - look only from the end of the constant surfaces onwards
+	for (int i=0; i<ghoul2->mSlist.size(); i++)
+	{
+		// is the surface count -1? That would indicate it's free
+		if (ghoul2->mSlist[i].surface == -1)
+		{
+			ghoul2->mSlist[i].offFlags = G2SURFACEFLAG_GENERATED;
+			ghoul2->mSlist[i].surface = 10000;		// no model will ever have 10000 surfaces
+			ghoul2->mSlist[i].genBarycentricI = BarycentricI;
+			ghoul2->mSlist[i].genBarycentricJ = BarycentricJ;
+			ghoul2->mSlist[i].genPolySurfaceIndex = ((polyNumber & 0xffff) << 16) | (surfaceNumber & 0xffff);
+			ghoul2->mSlist[i].genLod = lod;
+			return i;
+		}
+	}
+
+	// ok, didn't find one. Better create one
+
+	temp_slist_entry.offFlags = G2SURFACEFLAG_GENERATED;
+	temp_slist_entry.surface = 10000;
+	temp_slist_entry.genBarycentricI = BarycentricI;
+	temp_slist_entry.genBarycentricJ = BarycentricJ;
+	temp_slist_entry.genPolySurfaceIndex = ((polyNumber & 0xffff) << 16) | (surfaceNumber & 0xffff);
+	temp_slist_entry.genLod = lod;
+
+	ghoul2->mSlist.push_back(temp_slist_entry);
+
+	return (ghoul2->mSlist.size() -1 );
+}
+
+qboolean G2_RemoveSurface(surfaceInfo_v &slist, const int index)
+{
+		// did we find it?
+	if (index != -1)
+	{
+		 // set us to be the 'not active' state
+		slist[index].surface = -1;
+
+		unsigned int newSize = slist.size();
+		// now look through the list from the back and see if there is a block of -1's we can resize off the end of the list
+		for (int i=slist.size()-1; i>-1; i--)
+		{
+			if (slist[i].surface == -1)
+			{
+				newSize = i;
+			}
+			// once we hit one that isn't a -1, we are done.
+			else
+			{
+				break;
+			}
+		}
+		// do we need to resize?
+		if (newSize != slist.size())
+		{
+			// yes, so lets do it
+			slist.resize(newSize);
+		}
+
+		return qtrue;
+	}
+
+	assert(0);
+
+	// no
+	return qfalse;
+}
+
+
+int G2_GetParentSurface(CGhoul2Info *ghlInfo, const int index)
+{
+	model_t					*mod = (model_t *)ghlInfo->currentModel;
+	mdxmSurface_t			*surf = 0;
+	mdxmHierarchyOffsets_t	*surfIndexes = (mdxmHierarchyOffsets_t *)((byte *)mod->mdxm + sizeof(mdxmHeader_t));
+	mdxmSurfHierarchy_t		*surfInfo = 0;
+
+	// walk each surface and see if this index is listed in it's children
+	surf = (mdxmSurface_t *)G2_FindSurface((void *)mod, index, 0);
+	surfInfo = (mdxmSurfHierarchy_t *)((byte *)surfIndexes + surfIndexes->offsets[surf->thisSurfaceIndex]);
+
+	return surfInfo->parentIndex;
+
+}
+
+int G2_GetSurfaceIndex(CGhoul2Info *ghlInfo, const char *surfaceName)
+{
+	model_t		*mod = (model_t *)ghlInfo->currentModel;
+	int			flags;
+	
+	return G2_IsSurfaceLegal(mod, surfaceName, &flags);
+}
+
+int G2_IsSurfaceRendered(CGhoul2Info *ghlInfo, const char *surfaceName, surfaceInfo_v &slist)
+{
+	int						flags = 0;//, surfFlags = 0;
+	int						surfIndex = 0;
+	assert(ghlInfo->currentModel);
+	assert(ghlInfo->currentModel->mdxm);
+	if (!ghlInfo->currentModel->mdxm)
+	{
+		return -1;
+	}
+
+	// now travel up the skeleton to see if any of it's ancestors have a 'no descendants' turned on
+
+	// find the original surface in the surface list
+	int surfNum = G2_IsSurfaceLegal((model_t *)ghlInfo->currentModel, surfaceName, &flags);
+	if ( surfNum != -1 )
+	{//must be legal
+		const mdxmHierarchyOffsets_t	*surfIndexes = (mdxmHierarchyOffsets_t *)((byte *)ghlInfo->currentModel->mdxm + sizeof(mdxmHeader_t));
+		const mdxmSurfHierarchy_t *surfInfo = (mdxmSurfHierarchy_t *)((byte *)surfIndexes + surfIndexes->offsets[surfNum]);
+		surfNum = surfInfo->parentIndex;
+		// walk the surface hierarchy up until we hit the root
+		while (surfNum != -1)
+		{
+			const mdxmSurface_t		*parentSurf;
+			int						parentFlags;
+			const mdxmSurfHierarchy_t		*parentSurfInfo;
+
+			parentSurfInfo = (mdxmSurfHierarchy_t *)((byte *)surfIndexes + surfIndexes->offsets[surfNum]);
+
+			// find the original surface in the surface list
+			//G2 was bug, above comment was accurate, but we don't want the original flags, we want the parent flags
+			G2_IsSurfaceLegal((model_t *)ghlInfo->currentModel, parentSurfInfo->name, &parentFlags);
+
+			// now see if we already have overriden this surface in the slist 
+			parentSurf = G2_FindSurface(ghlInfo, slist, parentSurfInfo->name, &surfIndex);
+			if (parentSurf)
+			{
+				// set descendants value
+				parentFlags = slist[surfIndex].offFlags;
+			}
+			// now we have the parent flags, lets see if any have the 'no descendants' flag set
+			if (parentFlags & G2SURFACEFLAG_NODESCENDANTS)
+			{
+				flags |= G2SURFACEFLAG_OFF;
+				break; 
+			}
+			// set up scan of next parent
+			surfNum = parentSurfInfo->parentIndex;
+		}
+	}
+	else
+	{
+		return -1;
+	}
+	if ( flags == 0 )
+	{//it's not being overridden by a parent
+		// now see if we already have overriden this surface in the slist 
+		const mdxmSurface_t *surf = G2_FindSurface(ghlInfo, slist, surfaceName, &surfIndex);
+		if (surf)
+		{
+			// set descendants value
+			flags = slist[surfIndex].offFlags;
+		}
+	  	// ok, at this point in flags we have what this surface is set to, and the index of the surface itself
+	}
+	return flags;
+}
diff --git a/codemp/ghoul2/ghoul2_shared.h b/codemp/ghoul2/ghoul2_shared.h
new file mode 100644
index 0000000..f193fb2
--- /dev/null
+++ b/codemp/ghoul2/ghoul2_shared.h
@@ -0,0 +1,472 @@
+#if defined (_MSC_VER) && (_MSC_VER >= 1020)
+#pragma once
+#endif
+#if !defined(GHOUL2_SHARED_H_INC)
+#define GHOUL2_SHARED_H_INC
+
+/*
+Ghoul2 Insert Start
+*/
+#pragma warning (push, 3)	//go back down to 3 for the stl include
+#include <vector>
+#include <map>
+#pragma warning (pop)
+using namespace std;
+/*
+Ghoul2 Insert End
+*/
+
+#define MDXABONEDEF
+#include "../renderer/mdx_format.h"
+
+struct model_s;
+
+//rww - RAGDOLL_BEGIN
+#define G2T_SV_TIME (0)
+#define G2T_CG_TIME (1)
+#define NUM_G2T_TIME (2)
+
+void		G2API_SetTime(int currentTime,int clock);
+int			G2API_GetTime(int argTime); // this may or may not return arg depending on ghoul2_time cvar
+//rww - RAGDOLL_END
+
+//===================================================================
+//
+//   G H O U L  I I  D E F I N E S
+//
+// we save the whole surfaceInfo_t struct
+struct surfaceInfo_t 
+{
+	int			offFlags;		// what the flags are for this model
+	int			surface;		// index into array held inside the model definition of pointers to the actual surface data loaded in - used by both client and game
+	float		genBarycentricJ;	// point 0 barycentric coors
+	float		genBarycentricI;	// point 1 barycentric coors - point 2 is 1 - point0 - point1
+	int			genPolySurfaceIndex; // used to point back to the original surface and poly if this is a generated surface
+	int			genLod;			// used to determine original lod of original surface and poly hit location
+	
+surfaceInfo_t():
+	offFlags(0),
+	surface(0),
+	genBarycentricJ(0),
+	genBarycentricI(0),
+	genPolySurfaceIndex(0),
+	genLod(0)
+	{}
+
+};
+
+
+
+#define MDXABONEDEF				// used in the mdxformat.h file to stop redefinitions of the bone struct.
+
+// we save the whole structure here.
+struct  boneInfo_t
+{
+	int			boneNumber;		// what bone are we overriding?
+	mdxaBone_t	matrix;			// details of bone angle overrides - some are pre-done on the server, some in ghoul2
+	int			flags;			// flags for override
+	int			startFrame;		// start frame for animation
+	int			endFrame;		// end frame for animation NOTE anim actually ends on endFrame+1
+	int			startTime;		// time we started this animation
+	int			pauseTime;		// time we paused this animation - 0 if not paused
+	float		animSpeed;		// speed at which this anim runs. 1.0f means full speed of animation incoming - ie if anim is 20hrtz, we run at 20hrts. If 5hrts, we run at 5 hrts
+	float		blendFrame;		// frame PLUS LERP value to blend from
+	int			blendLerpFrame;	// frame to lerp the blend frame with.
+	int			blendTime;		// Duration time for blending - used to calc amount each frame of new anim is blended with last frame of the last anim
+	int			blendStart;		// Time when blending starts - not necessarily the same as startTime since we might start half way through an anim
+	int			boneBlendTime;	// time for duration of bone angle blend with normal animation
+	int			boneBlendStart;	// time bone angle blend with normal animation began
+	int			lastTime;		// this does not go across the network
+	mdxaBone_t	newMatrix;		// This is the lerped matrix that Ghoul2 uses on the client side - does not go across the network
+
+	//rww - RAGDOLL_BEGIN
+	int			lastTimeUpdated;  // if non-zero this is all intialized
+	int			lastContents;
+	vec3_t		lastPosition;
+	vec3_t		velocityEffector;
+	vec3_t		lastAngles;
+	vec3_t		minAngles;
+	vec3_t		maxAngles;
+	vec3_t		currentAngles;
+	vec3_t		anglesOffset;
+	vec3_t		positionOffset;
+	float		radius;
+	float		weight;   // current radius cubed
+	int			ragIndex;
+	vec3_t		velocityRoot;		// I am really tired of recomiling the whole game to add a param here
+	int			ragStartTime;
+	int			firstTime;
+	int			firstCollisionTime;
+	int			restTime;
+	int			RagFlags;
+	int			DependentRagIndexMask;
+	mdxaBone_t	originalTrueBoneMatrix;	
+	mdxaBone_t	parentTrueBoneMatrix;			// figure I will need this sooner or later
+	mdxaBone_t	parentOriginalTrueBoneMatrix;	// figure I will need this sooner or later
+	vec3_t		originalOrigin;
+	vec3_t		originalAngles;
+	vec3_t		lastShotDir;		
+	mdxaBone_t  *basepose;
+	mdxaBone_t  *baseposeInv;
+	mdxaBone_t  *baseposeParent;
+	mdxaBone_t  *baseposeInvParent;
+	int			parentRawBoneIndex;
+	mdxaBone_t	ragOverrideMatrix;	// figure I will need this sooner or later
+
+	mdxaBone_t	extraMatrix;	// figure I will need this sooner or later
+	vec3_t		extraVec1;		// I am really tired of recomiling the whole game to add a param here
+	float		extraFloat1;		
+	int			extraInt1;
+
+	vec3_t		ikPosition;
+	float		ikSpeed;
+
+	vec3_t		epVelocity; //velocity factor, can be set, and is also maintained by physics based on gravity, mass, etc.
+	float		epGravFactor; //gravity factor maintained by bone physics
+	int			solidCount; //incremented every time we try to move and are in solid - if we get out of solid, it is reset to 0
+	bool		physicsSettled; //true when the bone is on ground and finished bouncing, etc. but may still be pushed into solid by other bones
+	bool		snapped; //the bone is broken out of standard constraints
+
+	int			parentBoneIndex;
+
+	float		offsetRotation;
+
+	//user api overrides
+	float		overGradSpeed;
+
+	vec3_t		overGoalSpot;
+	bool		hasOverGoal;
+
+	mdxaBone_t	animFrameMatrix; //matrix for the bone in the desired settling pose -rww
+	int			hasAnimFrameMatrix;
+
+	int			airTime; //base is in air, be more quick and sensitive about collisions
+	//rww - RAGDOLL_END
+
+boneInfo_t():
+	boneNumber(-1),
+	flags(0),
+	startFrame(0),
+	endFrame(0),
+	startTime(0),
+	pauseTime(0),
+	animSpeed(0),
+	blendFrame(0),
+	blendLerpFrame(0),
+	blendTime(0),
+	blendStart(0),
+	boneBlendTime(0),
+	boneBlendStart(0),
+	lastTime(0),
+	RagFlags(0)
+	{
+		matrix.matrix[0][0] = matrix.matrix[0][1] = matrix.matrix[0][2] = matrix.matrix[0][3] = 
+		matrix.matrix[1][0] = matrix.matrix[1][1] = matrix.matrix[1][2] = matrix.matrix[1][3] = 
+		matrix.matrix[2][0] = matrix.matrix[2][1] = matrix.matrix[2][2] = matrix.matrix[2][3] = 0.0f;
+	}
+
+};
+//we save from top to boltUsed here. Don't bother saving the position, it gets rebuilt every frame anyway
+struct boltInfo_t{
+	int			boneNumber;		// bone number bolt attaches to	
+	int			surfaceNumber;	// surface number bolt attaches to 
+	int			surfaceType;	// if we attach to a surface, this tells us if it is an original surface or a generated one - doesn't go across the network
+	int			boltUsed;		// nor does this
+	mdxaBone_t	position;		// this does not go across the network
+	boltInfo_t():
+	boneNumber(-1),
+	surfaceNumber(-1),
+	surfaceType(0),
+	boltUsed(0)
+	{}
+};
+
+#ifdef _SOF2
+typedef enum
+{
+	PGORE_NONE,
+	PGORE_ARMOR,
+	PGORE_BULLETSMALL,
+	PGORE_BULLETMED,
+	PGORE_BULLETBIG,
+	PGORE_HEGRENADE,
+	PGORE_COUNT
+} goreEnum_t;
+
+struct goreEnumShader_t
+{
+	goreEnum_t		shaderEnum;
+	char			shaderName[MAX_QPATH];
+};
+
+struct SSkinGoreData
+{
+	vec3_t			angles;
+	vec3_t			position;
+	int				currentTime;
+	int				entNum;
+	vec3_t			rayDirection;	// in world space
+	vec3_t			hitLocation;	// in world space
+	vec3_t			scale;
+	float			SSize;			// size of splotch in the S texture direction in world units
+	float			TSize;			// size of splotch in the T texture direction in world units
+	float			theta;			// angle to rotate the splotch
+
+//	qhandle_t		shader;			// handle to shader for gore, this better be rendered after the shader of the underlying surface					
+									// this shader should also have "clamp" mode, not tiled.
+	goreEnum_t		shaderEnum;		// enum that'll get switched over to the shader's actual handle
+};
+#endif // _SOF2
+
+#define MAX_GHOUL_COUNT_BITS 8 // bits required to send across the MAX_G2_MODELS inside of the networking - this is the only restriction on ghoul models possible per entity
+
+typedef vector <surfaceInfo_t> surfaceInfo_v;
+typedef vector <boneInfo_t> boneInfo_v;
+typedef vector <boltInfo_t> boltInfo_v;
+typedef vector <pair<int,mdxaBone_t> > mdxaBone_v;
+
+// defines for stuff to go into the mflags
+#define		GHOUL2_NOCOLLIDE 0x001
+#define		GHOUL2_NORENDER	 0x002
+#define		GHOUL2_NOMODEL	 0x004
+#define		GHOUL2_NEWORIGIN 0x008
+
+class CBoneCache;
+
+// NOTE order in here matters. We save out from mModelindex to mFlags, but not the STL vectors that are at the top or the bottom.
+class CGhoul2Info
+{
+public:
+	surfaceInfo_v 	mSlist;
+	boltInfo_v		mBltlist;
+	boneInfo_v		mBlist;
+// save from here
+	int				mModelindex;
+	qhandle_t		mCustomShader;
+	qhandle_t		mCustomSkin;
+	int				mModelBoltLink;
+	int				mSurfaceRoot;
+	int				mLodBias;
+	int				mNewOrigin;	// this contains the bolt index of the new origin for this model
+#ifdef _G2_GORE
+	int				mGoreSetTag;
+#endif
+	qhandle_t		mModel;		// this and the next entries do NOT go across the network. They are for gameside access ONLY
+	char			mFileName[MAX_QPATH];
+	int				mAnimFrameDefault;
+	int				mSkelFrameNum;
+	int				mMeshFrameNum;
+	int				mFlags;	// used for determining whether to do full collision detection against this object
+// to here
+	int				*mTransformedVertsArray;	// used to create an array of pointers to transformed verts per surface for collision detection
+	CBoneCache		*mBoneCache;
+	int				mSkin;
+
+	// these occasionally are not valid (like after a vid_restart)
+	// call the questionably efficient G2_SetupModelPointers(this) to insure validity
+	bool				mValid; // all the below are proper and valid
+	const model_s		*currentModel;
+	int					currentModelSize;
+	const model_s		*animModel;
+	int					currentAnimModelSize;
+	const mdxaHeader_t	*aHeader;
+
+#ifdef _G2_LISTEN_SERVER_OPT
+	int					entityNum;
+#endif
+
+	CGhoul2Info():
+	mModelindex(-1),
+	mCustomShader(0),
+	mCustomSkin(0),
+	mModelBoltLink(0),
+	mModel(0),
+	mSurfaceRoot(0),
+	mAnimFrameDefault(0),
+	mSkelFrameNum(-1),
+	mMeshFrameNum(-1),
+	mFlags(0),
+	mTransformedVertsArray(0),
+	mLodBias(0),
+	mSkin(0),
+	mNewOrigin(-1),
+#ifdef _G2_GORE
+	mGoreSetTag(0),
+#endif
+	mBoneCache(0),
+	currentModel(0),
+	currentModelSize(0),
+	animModel(0),
+	currentAnimModelSize(0),
+	aHeader(0),
+#ifdef _G2_LISTEN_SERVER_OPT
+	entityNum(ENTITYNUM_NONE),
+#endif
+	mValid(false)
+	{
+		mFileName[0] = 0;
+	}
+}; 
+
+class CGhoul2Info_v;
+
+class IGhoul2InfoArray
+{
+public:
+	virtual int New()=0;
+	virtual void Delete(int handle)=0;
+	virtual bool IsValid(int handle) const=0;
+	virtual vector<CGhoul2Info> &Get(int handle)=0;
+	virtual const vector<CGhoul2Info> &Get(int handle) const=0;
+};
+
+IGhoul2InfoArray &TheGhoul2InfoArray();
+
+class CGhoul2Info_v
+{
+	IGhoul2InfoArray &InfoArray() const
+	{
+		return TheGhoul2InfoArray();
+	}
+
+	void Alloc()
+	{
+		assert(!mItem); //already alloced
+		mItem=InfoArray().New();
+		assert(!Array().size());
+	}
+	void Free()
+	{
+		if (mItem)
+		{
+			assert(InfoArray().IsValid(mItem));
+			InfoArray().Delete(mItem);
+			mItem=0;
+		}
+	}
+	vector<CGhoul2Info> &Array()
+	{
+		assert(InfoArray().IsValid(mItem));
+		return InfoArray().Get(mItem);
+	}
+	const vector<CGhoul2Info> &Array() const
+	{
+		assert(InfoArray().IsValid(mItem));
+		return InfoArray().Get(mItem);
+	}
+public:
+	int mItem;	//dont' be bad and muck with this
+	CGhoul2Info_v()
+	{
+		mItem=0;
+	}
+	CGhoul2Info_v(const int item)
+	{	//be VERY carefull with what you pass in here
+		mItem=item;
+	}
+	~CGhoul2Info_v()
+	{
+		Free(); //this had better be taken care of via the clean ghoul2 models call
+	}
+	void operator=(const CGhoul2Info_v &other)
+	{
+		mItem=other.mItem;
+	}
+	void operator=(const int otherItem)	//assigning one from the VM side item number
+	{
+		mItem=otherItem;
+	}
+	void DeepCopy(const CGhoul2Info_v &other)
+	{
+		Free();
+		if (other.mItem)
+		{
+			Alloc();
+			Array()=other.Array();
+			int i;
+			for (i=0;i<size();i++)
+			{
+				Array()[i].mBoneCache=0;
+				Array()[i].mTransformedVertsArray=0;
+				Array()[i].mSkelFrameNum=0;
+				Array()[i].mMeshFrameNum=0;
+			}
+		}
+	}
+	CGhoul2Info &operator[](int idx)
+	{
+		assert(mItem);
+		assert(idx>=0&&idx<size());
+		return Array()[idx];
+	}
+	const CGhoul2Info &operator[](int idx) const
+	{
+		assert(mItem);
+		assert(idx>=0&&idx<size());
+		return Array()[idx];
+	}
+	void resize(int num)
+	{
+		assert(num>=0);
+		if (num)
+		{
+			if (!mItem)
+			{
+				Alloc();
+			}
+		}
+		if (mItem||num)
+		{
+			Array().resize(num);
+		}
+	}
+	void clear()
+	{
+		Free();
+	}
+	void push_back(const CGhoul2Info &model)
+	{
+		if (!mItem)
+		{
+			Alloc();
+		}
+		Array().push_back(model);
+	}
+	int size() const
+	{
+		if (!IsValid())
+		{
+			return 0;
+		}
+		return Array().size();
+	}
+	bool IsValid() const
+	{
+		return InfoArray().IsValid(mItem);
+	}
+	void kill()
+	{
+		// this scary method zeros the infovector handle without actually freeing it
+		// it is used for some places where a copy is made, but we don't want to go through the trouble
+		// of making a deep copy
+		mItem=0;
+	}
+};
+
+// collision detection stuff
+#define G2_FRONTFACE 1
+#define	G2_BACKFACE	 0
+
+
+// calling defines for the trace function
+enum EG2_Collision
+{
+	G2_NOCOLLIDE,
+	G2_COLLIDE,
+	G2_RETURNONHIT
+};
+
+
+//====================================================================
+
+#endif // GHOUL2_SHARED_H_INC
diff --git a/codemp/ghoul2/vssver.scc b/codemp/ghoul2/vssver.scc
new file mode 100644
index 0000000..ad42de0
Binary files /dev/null and b/codemp/ghoul2/vssver.scc differ
diff --git a/codemp/goblib/goblib.cpp b/codemp/goblib/goblib.cpp
new file mode 100644
index 0000000..11553f7
--- /dev/null
+++ b/codemp/goblib/goblib.cpp
@@ -0,0 +1,1876 @@
+/*****************************************
+ *
+ * GOB File System
+ *
+ * Here's what Merriam-Webster says about "gob":  --Chuck
+ *		Entry:     gob
+ *		Function:  noun
+ *		Etymology: Middle English gobbe, from Middle French gobe large piece of food,
+ *		           back-formation from gobet
+ *		Date:      14th century
+ *		1 : LUMP
+ *		2 : a large amount -- usually used in plural <gobs of money>
+ *
+ * Purpose: Provide fast, efficient disk access on a variety of platforms.
+ *
+ * Implementation:
+ *		The GOB system maintains two files -- GOB and GFC.  The GOB file is actually
+ *		an archive of many files split into variable size, compressed blocks.  The GFC,
+ *		GOB File Control, contains 3 tables -- a block table, basic file table, and
+ *		extended file table.  The block table is analogous to a DOS FAT.  The basic
+ *		file table contains a minimal set of file information to handle basic reading
+ *		tasks.  The extended file table is optionally loaded and contains additional
+ *		file information.  File names are case insensitive.
+ *		  
+ *		Files can be read in a normal manner.  Open, read, seek and close
+ *		operations are all provided.  Files can only be written in a single
+ *		contiguous chunk of blocks at the end of an archive.  Reads are processed
+ *		through a configurable number of read ahead buffers to in an effort to
+ *		minimize both reads and seeks.  Other operations including delete, verify, 
+ *		access, and get size are also supported on files inside an archive.
+ *
+ *		The system supports read profiling.  By supplying a file read callback 
+ *		function, the library will output the block number of each read.  This can 
+ *		be used rearrange block in the archive to minimize seek times.  The 
+ *		GOBRearrange sorts files in an archive.
+ *
+ *		Supports block based caching.  Primarily aimed at caching files off a DVD/CD
+ *		to a faster hard disk.
+ *
+ * Future Work: 
+ *
+ * Dependencies: vvInt, snprintf, zlib
+ * Owner: Chris McEvoy
+ * History:
+ *     09/23/2001 Original version
+ *     10/28/2002 Merged into vvtech
+ *
+ * Copyright (C) 2002, Vicarious Visions, Inc.  All Rights Reserved.
+ *
+ * UNPUBLISHED -- Rights  reserved  under  the  copyright  laws  of the 
+ * United States.  Use  of a copyright notice is precautionary only and 
+ * does not imply publication or disclosure.                            
+ *                                                                      
+ * THIS DOCUMENTATION CONTAINS CONFIDENTIAL AND PROPRIETARY INFORMATION 
+ * OF    VICARIOUS   VISIONS,  INC.    ANY  DUPLICATION,  MODIFICATION, 
+ * DISTRIBUTION, OR DISCLOSURE IS STRICTLY PROHIBITED WITHOUT THE PRIOR 
+ * EXPRESS WRITTEN PERMISSION OF VICARIOUS VISIONS, INC.
+ *
+ *****************************************/
+
+/*
+	This is an unofficial branch of GOB, for Jedi Academy
+	Maintainer: Brian Osman
+*/
+
+#include "goblib.h"
+#include "../zlib/zlib.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+#include <assert.h>
+
+#if (VV_PLATFORM == VV_PLATFORM_WIN) || (VV_PLATFORM == VV_PLATFORM_XBOX)
+#	define CDECL __cdecl
+#else
+#	define CDECL 
+#endif
+
+// Profiling data
+static GOBProfileReadFunc ProfileReadCallback = NULL;
+static GOBBool ProfileEnabled = GOB_FALSE;
+
+// Indicates whether or not the library has been initialized
+static GOBBool LibraryInit = GOB_FALSE;
+
+// Callbacks for handling low-level compression/decompression
+static struct GOBCodecFuncSet CodecFuncs;
+
+// Callbacks for handling low-level memory alloc and free
+static struct GOBMemoryFuncSet MemFuncs;
+
+// Callbacks for handling low-level file access
+static struct GOBFileSysFuncSet FSFuncs;
+
+// Callbacks for handling block caching (ie Xbox temp space)
+static struct GOBCacheFileFuncSet CacheFileFuncs;
+static GOBBool CacheFileActive = GOB_FALSE;
+
+// Name of the GFC file
+static GOBChar ControlFileName[GOB_MAX_FILE_NAME_LEN];
+
+// Handle to the GOB archive
+static GOBFSHandle ArchiveHandle = (GOBFSHandle*)0xFFFFFFFF;
+
+// Size of the active GOB archive
+static GOBUInt32 ArchiveSize = 0;
+static GOBUInt32 ArchiveNumBlocks = 0;
+static GOBUInt32 ArchiveNumFiles = 0;
+
+// Cached blocks
+struct GOBBlockCache
+{
+	GOBChar* data;
+	GOBUInt32 block;
+	GOBUInt32 time;
+	GOBUInt32 size;
+};
+static struct GOBBlockCache* CacheBlocks = NULL;
+static GOBUInt32 NumCacheBlocks = 0;
+static GOBUInt32 CacheBlockCounter = 0;
+
+// Read ahead buffer
+struct GOBReadBuffer
+{
+	GOBChar* data;
+	GOBChar* dataStart;
+	GOBUInt32 pos;
+	GOBUInt32 size;
+};
+static struct GOBReadBuffer ReadBuffer;
+
+// Decompression buffer
+static GOBChar* DecompBuffer = NULL;
+
+// Stats gathering
+static struct GOBReadStats ReadStats;
+static GOBUInt32 CurrentArchivePos = 0;
+
+// File tables (from the GFC)
+static struct GOBFileTableBasicEntry* FileTableBasic = NULL;
+static struct GOBFileTableExtEntry* FileTableExt = NULL;
+
+// Block tables (from the GFC)
+static struct GOBBlockTableEntry* BlockTable = NULL;
+static GOBUInt32* BlockCRC = NULL;
+static GOBUInt32* CacheFileTable = NULL;
+
+// Do the tables need to be written?
+static GOBBool FileTableDirty = GOB_FALSE;
+
+// Information about open files
+struct OpenFileInfo
+{
+	GOBBool valid;
+	GOBUInt32 startBlock;
+	GOBUInt32 block;
+	GOBUInt32 offset;
+
+	GOBUInt32 pos;
+	GOBUInt32 size;
+};
+
+// Open file table -- indices in this array are passed
+// back to the caller as pseudo file handles.
+static struct OpenFileInfo OpenFiles[GOB_MAX_OPEN_FILES];
+
+// Converting text to lower case -- this isn't very
+// clean.  A common buffer is used to store lower case
+// text.  So its not thread safe... among other things. ;)
+static GOBChar LowerCaseBuffer[GOB_MAX_FILE_NAME_LEN];
+static GOBChar* LowerCase(const GOBChar* name)
+{
+	GOBInt32 i;
+	for (i = 0; name[i]; ++i) {
+		LowerCaseBuffer[i] = (GOBChar)tolower(name[i]);
+	}
+	LowerCaseBuffer[i] = 0;
+
+	return LowerCaseBuffer;
+}
+
+// Checks if a file handle is invalid
+static GOBBool InvalidHandle(GOBFSHandle h)
+{
+	return (GOBUInt32)h == 0xFFFFFFFF ? GOB_TRUE : GOB_FALSE;
+}
+
+// Endian conversion
+#if VV_ENDIAN == VV_ENDIAN_LITTLE
+static GOBUInt32 SwapBytes(GOBUInt32 x)
+{
+	return
+		(x >> 24) |
+		((x >> 8) & 0xFF00) |
+		((x << 8) & 0xFF0000) |
+		(x << 24);
+
+}
+#else
+static GOBUInt32 SwapBytes(GOBUInt32 x)
+{
+	return x;
+}
+#endif
+
+
+// Given a file name, get its index in the FileTable
+static GOBInt32 GetFileTableEntry(const GOBChar* file)
+{
+	GOBUInt32 entry;
+	GOBUInt32 hash;
+	
+	// hash the file name
+	hash = crc32(0L, Z_NULL, 0);
+	hash = crc32(hash, (const unsigned char*)file, strlen(file));
+
+	// linear search for matching a matching hash
+	for (entry = 0; entry < ArchiveNumFiles; ++entry) {
+		if (FileTableBasic[entry].block != GOB_INVALID_BLOCK &&
+			FileTableBasic[entry].hash == hash) 
+		{
+			return entry;
+		}
+	}
+
+	return -1;
+}
+
+// Mark the contents of cache and read buffer invalid
+static GOBVoid InvalidateCache(GOBVoid)
+{
+	GOBUInt32 i;
+	for (i = 0; i < NumCacheBlocks; ++i) {
+		CacheBlocks[i].block = 0xFFFFFFFF;
+	}
+	ReadBuffer.pos = 0xFFFFFFFF;
+}
+
+// Deallocate memory used by cache and read buffer
+static GOBVoid FreeCache(GOBVoid)
+{
+	GOBUInt32 i;
+
+	if (CacheBlocks) {
+		for (i = 0; i < NumCacheBlocks; ++i) {
+			if (CacheBlocks[i].data) MemFuncs.free(CacheBlocks[i].data);
+			CacheBlocks[i].data = NULL;
+		}
+
+		MemFuncs.free(CacheBlocks);
+		NumCacheBlocks = 0;
+		CacheBlocks = NULL;
+	}
+}
+
+// Write the file table to disk if the form of a GFC
+static GOBError CommitFileTable(GOBVoid)
+{
+	GOBUInt32 num;
+	struct GOBFileTableBasicEntry basic;
+	struct GOBFileTableExtEntry ext;
+	struct GOBBlockTableEntry block;
+	
+	// open the GFC
+	GOBFSHandle handle = FSFuncs.open(ControlFileName, GOBACCESS_WRITE);
+	if (InvalidHandle(handle)) return GOBERR_FILE_WRITE;
+
+	// write the magic identifier
+	num = SwapBytes(GOB_MAGIC_IDENTIFIER);
+	if (!FSFuncs.write(handle, &num, sizeof(num))) return GOBERR_FILE_WRITE;
+
+	// write the size of the GOB
+	num = SwapBytes(ArchiveSize);
+	if (!FSFuncs.write(handle, &num, sizeof(num))) return GOBERR_FILE_WRITE;
+
+	// write number of blocks in archive
+	num = SwapBytes(ArchiveNumBlocks);
+	if (!FSFuncs.write(handle, &num, sizeof(num))) return GOBERR_FILE_WRITE;
+
+	// write number of file in archive
+	num = SwapBytes(ArchiveNumFiles);
+	if (!FSFuncs.write(handle, &num, sizeof(num))) return GOBERR_FILE_WRITE;
+
+	// write block table -- with endian conversion
+	for (num = 0; num < ArchiveNumBlocks; ++num) {
+		block.next = SwapBytes(BlockTable[num].next);
+		block.offset = SwapBytes(BlockTable[num].offset);
+		block.size = SwapBytes(BlockTable[num].size);
+
+		if (!FSFuncs.write(handle, &block, sizeof(block))) return GOBERR_FILE_WRITE;
+	}
+	
+	// write block CRCs -- with endian conversion
+	for (num = 0; num < ArchiveNumBlocks; ++num) {
+		BlockCRC[num] = SwapBytes(BlockCRC[num]);
+		if (!FSFuncs.write(handle, &BlockCRC[num], sizeof(BlockCRC[num]))) {
+			return GOBERR_FILE_WRITE;
+		}
+	}
+	
+	// write each basic table entry -- with endian conversion
+	for (num = 0; num < ArchiveNumFiles; ++num) {
+		basic.hash = SwapBytes(FileTableBasic[num].hash);
+		basic.block = SwapBytes(FileTableBasic[num].block);
+		basic.size = SwapBytes(FileTableBasic[num].size);
+
+		if (!FSFuncs.write(handle, &basic, sizeof(basic))) return GOBERR_FILE_WRITE;
+	}
+	
+	// write each extended table entry -- with endian conversion
+	for (num = 0; num < ArchiveNumFiles; ++num) {
+		strcpy(ext.name, FileTableExt[num].name);
+		ext.crc = SwapBytes(FileTableExt[num].crc);
+		ext.time = SwapBytes(FileTableExt[num].time);
+
+		if (!FSFuncs.write(handle, &ext, sizeof(ext))) return GOBERR_FILE_WRITE;
+	}
+
+	// all done
+	FSFuncs.close(&handle);
+	FileTableDirty = GOB_FALSE;
+
+	return GOBERR_OK;
+}
+
+
+static GOBVoid DeallocTables(GOBVoid)
+{
+	if (BlockTable) {
+		// free the block table
+		MemFuncs.free(BlockTable);
+		BlockTable = NULL;
+	}
+
+	if (BlockCRC) {
+		// free the block crc table
+		MemFuncs.free(BlockCRC);
+		BlockCRC = NULL;
+	}
+
+	if (CacheFileTable)
+	{
+		// free the block cache table
+		MemFuncs.free(CacheFileTable);
+		CacheFileTable = NULL;
+	}
+
+	if (FileTableBasic) {
+		// free the basic file table
+		MemFuncs.free(FileTableBasic);
+		FileTableBasic = NULL;
+	}
+
+	if (FileTableExt) {
+		// free the extended file table
+		MemFuncs.free(FileTableExt);
+		FileTableExt = NULL;
+	}
+}
+
+static GOBError AllocTables(GOBUInt32 num_blocks, GOBUInt32 num_files, 
+	GOBBool extended, GOBBool safe)
+{
+	GOBUInt32 num;
+
+	// dump any old tables
+	DeallocTables();
+	
+	// allocate the block table
+	BlockTable = (struct GOBBlockTableEntry*)
+		MemFuncs.alloc(num_blocks * sizeof(struct GOBBlockTableEntry));
+	if (!BlockTable) return GOBERR_NO_MEMORY;
+
+	if (safe) {
+		// allocate the block crc table for verifying data validity
+		BlockCRC = (GOBUInt32*)MemFuncs.alloc(num_blocks * sizeof(GOBUInt32));
+		if (!BlockCRC) return GOBERR_NO_MEMORY;
+	}
+	else {
+		BlockCRC = NULL;
+	}
+
+	if (CacheFileActive)
+	{
+		// allocate the block cache bitfield
+		CacheFileTable = (GOBUInt32*)
+			MemFuncs.alloc((num_blocks / 32 + 1) * 4);
+		if (!CacheFileTable) return GOBERR_NO_MEMORY;
+	}
+
+	// allocate the basic file table
+	FileTableBasic = (struct GOBFileTableBasicEntry*)
+		MemFuncs.alloc(num_files * sizeof(struct GOBFileTableBasicEntry));
+	if (!FileTableBasic) return GOBERR_NO_MEMORY;
+
+	if (extended) {
+		// allocate the extended file table
+		FileTableExt = (struct GOBFileTableExtEntry*)
+			MemFuncs.alloc(num_files * sizeof(struct GOBFileTableExtEntry));
+		if (!FileTableExt) return GOBERR_NO_MEMORY;
+	}
+	else {
+		FileTableExt = NULL;
+	}
+
+	// clear the tables
+	for (num = 0; num < num_files; ++num) {
+		FileTableBasic[num].block = GOB_INVALID_BLOCK;
+		if (FileTableExt) FileTableExt[num].name[0] = 0;
+	}
+
+	for (num = 0; num < num_blocks; ++num) {
+		BlockTable[num].next = GOB_INVALID_BLOCK;
+		BlockTable[num].size = GOB_INVALID_SIZE;
+	}
+
+	return GOBERR_OK;
+}
+
+
+// GOBInit
+// Public function.  Initialize the library.
+GOBError GOBInit(struct GOBMemoryFuncSet* mem, 
+	struct GOBFileSysFuncSet* file, 
+	struct GOBCodecFuncSet* codec,
+	struct GOBCacheFileFuncSet* cache)
+{
+	GOBInt32 i;
+	GOBError err;
+	
+	if (LibraryInit) return GOBERR_ALREADY_INIT;
+	
+	// setup the callbacks
+	MemFuncs = *mem;
+	FSFuncs = *file;
+	CodecFuncs = *codec;
+	if (cache) {
+		CacheFileFuncs = *cache;
+		CacheFileActive = GOB_TRUE;
+	} else {
+		CacheFileActive = GOB_FALSE;
+	}
+
+	// allocate decompression buffer
+	DecompBuffer = (GOBChar*)MemFuncs.alloc(GOB_BLOCK_SIZE + GOB_COMPRESS_OVERHEAD);
+	if (!DecompBuffer) return GOBERR_NO_MEMORY;
+
+	// clear open table
+	for (i = 0; i < GOB_MAX_OPEN_FILES; ++i) {
+		OpenFiles[i].valid = GOB_FALSE;
+	}
+
+	LibraryInit = GOB_TRUE;
+
+	err = GOBSetCacheSize(1);
+	if (err != GOBERR_OK) {
+		LibraryInit = GOB_FALSE;
+		return err;
+	}
+
+	ReadBuffer.data = NULL;
+	err = GOBSetReadBufferSize(128*1024);
+	if (err != GOBERR_OK) {
+		LibraryInit = GOB_FALSE;
+		return err;
+	}
+
+	return GOBERR_OK;
+}
+
+// GOBShutdown
+// Public function.  Close the library.
+GOBError GOBShutdown(GOBVoid)
+{
+	if (!LibraryInit) return GOBERR_NOT_INIT;
+	
+	// if we have an open archive, close it
+	if (!InvalidHandle(ArchiveHandle)) GOBArchiveClose();
+	
+	FreeCache();
+
+	// free read ahead buffer
+	if (ReadBuffer.data) {
+		MemFuncs.free(ReadBuffer.data);
+		ReadBuffer.data = NULL;
+	}
+
+	// free decompression buffer
+	MemFuncs.free(DecompBuffer);
+
+	// free the file and block tables
+	DeallocTables();
+
+	LibraryInit = GOB_FALSE;
+	return GOBERR_OK;
+}
+
+
+// GOBArchiveCreate
+// Public function.  Create an empty GFC and GOB.
+GOBError GOBArchiveCreate(const GOBChar* file)
+{
+	GOBChar fname[GOB_MAX_FILE_NAME_LEN];
+	GOBFSHandle handle;
+	GOBError error;
+
+	if (!LibraryInit) return GOBERR_NOT_INIT;
+	if (!InvalidHandle(ArchiveHandle)) return GOBERR_ALREADY_OPEN;
+
+	// Allocate the max space for tables
+	error = AllocTables(GOB_MAX_BLOCKS, GOB_MAX_FILES, GOB_TRUE, GOB_TRUE);
+	if (GOBERR_OK != error) {
+		return error;
+	}
+	
+	// create an empty GFC
+	_snprintf(ControlFileName, GOB_MAX_FILE_NAME_LEN, "%s.gfc", file);
+
+	ArchiveSize = 0;
+	ArchiveNumBlocks = 0;
+	ArchiveNumFiles = 0;
+	CacheFileActive = GOB_FALSE;
+	
+	CommitFileTable();
+
+	// create an empty GOB
+	_snprintf(fname, GOB_MAX_FILE_NAME_LEN, "%s.gob", file);
+	handle = FSFuncs.open(fname, GOBACCESS_WRITE);
+	if (InvalidHandle(handle)) return GOBERR_CANNOT_CREATE;
+	
+	FSFuncs.close(&handle);
+
+	return GOBERR_OK;	
+}
+
+// GOBArchiveOpen
+// Public function.  Open a GOB file and cache file tables.
+GOBError GOBArchiveOpen(const GOBChar* file, GOBAccessType atype, 
+	GOBBool extended, GOBBool safe)
+{
+	GOBChar fname[GOB_MAX_FILE_NAME_LEN];
+	GOBFSHandle handle;
+	GOBUInt32 magic;
+	GOBUInt32 i;
+	GOBError error;
+
+	if (!LibraryInit) return GOBERR_NOT_INIT;
+	if (!InvalidHandle(ArchiveHandle)) return GOBERR_ALREADY_OPEN;
+
+	// open the GFC
+	_snprintf(ControlFileName, GOB_MAX_FILE_NAME_LEN, "%s.gfc", file);
+	handle = FSFuncs.open(ControlFileName, atype);
+	if (InvalidHandle(handle)) return GOBERR_FILE_NOT_FOUND;
+
+	// read and check the magic
+	if (!FSFuncs.read(handle, &magic, sizeof(magic))) return GOBERR_FILE_READ;
+	if (SwapBytes(magic) != GOB_MAGIC_IDENTIFIER) return GOBERR_NOT_GOB_FILE;
+
+	// read the GOB archive size
+	if (!FSFuncs.read(handle, &ArchiveSize, sizeof(ArchiveSize))) return GOBERR_FILE_READ;
+	ArchiveSize = SwapBytes(ArchiveSize);
+
+	// read the number of blocks
+	if (!FSFuncs.read(handle, &ArchiveNumBlocks, sizeof(ArchiveNumBlocks))) return GOBERR_FILE_READ;
+	ArchiveNumBlocks = SwapBytes(ArchiveNumBlocks);
+
+	// read the number of files
+	if (!FSFuncs.read(handle, &ArchiveNumFiles, sizeof(ArchiveNumFiles))) return GOBERR_FILE_READ;
+	ArchiveNumFiles = SwapBytes(ArchiveNumFiles);
+	
+	// Allocate the space for tables
+	if (atype == GOBACCESS_READ) {
+		error = AllocTables(ArchiveNumBlocks, ArchiveNumFiles, extended, safe);
+	}
+	else {
+		error = AllocTables(GOB_MAX_BLOCKS, GOB_MAX_FILES, extended, safe);
+	}
+	if (GOBERR_OK != error) {
+		return error;
+	}
+
+	// read the block table
+	if (ArchiveNumBlocks && 
+		!FSFuncs.read(handle, BlockTable, 
+		sizeof(struct GOBBlockTableEntry) * ArchiveNumBlocks))
+	{
+		return GOBERR_FILE_READ;
+	}
+
+	if (BlockCRC) {
+		// read the block CRCs
+		if (ArchiveNumBlocks && 
+			!FSFuncs.read(handle, BlockCRC, 
+			sizeof(GOBUInt32) * ArchiveNumBlocks))
+		{
+			return GOBERR_FILE_READ;
+		}
+	}
+	else {
+		// skip block CRCs
+		FSFuncs.seek(handle, sizeof(GOBUInt32) * ArchiveNumBlocks, 
+			GOBSEEK_CURRENT);
+	}
+
+	if (CacheFileActive)
+	{
+		// clear the block cache table
+		for (i = 0; i < ArchiveNumBlocks / 32; ++i) {
+			CacheFileTable[i] = 0;
+		}
+	}
+
+	// open the cache file
+	if (CacheFileActive && !CacheFileFuncs.open(ArchiveSize)) {
+		CacheFileActive = GOB_FALSE;
+	}
+
+	// endian convert the table
+	for (i = 0; i < ArchiveNumBlocks; ++i) {
+		BlockTable[i].next = SwapBytes(BlockTable[i].next);
+		BlockTable[i].offset = SwapBytes(BlockTable[i].offset);
+		BlockTable[i].size = SwapBytes(BlockTable[i].size);
+
+		if (BlockCRC) {
+			BlockCRC[i] = SwapBytes(BlockCRC[i]);
+		}
+	}
+
+	// read the basic file table
+	if (ArchiveNumFiles &&
+		!FSFuncs.read(handle, FileTableBasic, 
+		sizeof(struct GOBFileTableBasicEntry) * ArchiveNumFiles))
+	{
+		return GOBERR_FILE_READ;
+	}
+
+	// endian convert the table
+	for (i = 0; i < ArchiveNumFiles; ++i) {
+		FileTableBasic[i].hash = SwapBytes(FileTableBasic[i].hash);
+		FileTableBasic[i].block = SwapBytes(FileTableBasic[i].block);
+		FileTableBasic[i].size = SwapBytes(FileTableBasic[i].size);
+	}
+
+	// if we have memory for the extended file table
+	if (FileTableExt) {
+		// read the table
+		if (ArchiveNumFiles &&
+			!FSFuncs.read(handle, FileTableExt, 
+			sizeof(struct GOBFileTableExtEntry) * ArchiveNumFiles))
+		{
+			return GOBERR_FILE_READ;
+		}
+
+		// endian convert the table
+		for (i = 0; i < ArchiveNumFiles; ++i) {
+			FileTableExt[i].crc = SwapBytes(FileTableExt[i].crc);
+			FileTableExt[i].time = SwapBytes(FileTableExt[i].time);
+		}
+	}
+	
+	FSFuncs.close(&handle);
+
+	// open the GOB
+	_snprintf(fname, GOB_MAX_FILE_NAME_LEN, "%s.gob", file);
+	ArchiveHandle = FSFuncs.open(fname, atype);
+	if (InvalidHandle(ArchiveHandle)) return GOBERR_FILE_NOT_FOUND;
+
+	// initialize stats gathering
+	CurrentArchivePos = 0;
+	ReadStats.bufferUsed = 0;
+	ReadStats.bytesRead = 0;
+	ReadStats.cacheBytesRead = 0;
+	ReadStats.cacheBytesWrite = 0;
+	ReadStats.totalSeeks = 0;
+	ReadStats.farSeeks = 0;
+	ReadStats.filesOpened = 0;
+
+	return GOBERR_OK;
+}
+
+// GOBArchiveClose
+// Public function.  Close an open GOB archive.
+GOBError GOBArchiveClose(GOBVoid)
+{
+	GOBInt32 i;
+
+	if (!LibraryInit) return GOBERR_NOT_INIT;
+	if (InvalidHandle(ArchiveHandle)) return GOBERR_NOT_OPEN;
+
+	// close any open files
+	for (i = 0; i < GOB_MAX_OPEN_FILES; ++i) {
+		GOBClose(i);
+	}
+
+	// close the GOB
+	FSFuncs.close(&ArchiveHandle);
+	ArchiveHandle = (GOBFSHandle*)0xFFFFFFFF;
+
+	// commit the file table if we're updated it
+	if (FileTableDirty) {
+		CommitFileTable();
+	}
+	
+	// close the cache file
+	if (CacheFileActive) {
+		CacheFileFuncs.close();
+		CacheFileActive = GOB_FALSE;
+	}
+
+	return GOBERR_OK;
+}
+
+static int CDECL SortBlockDescsCallback(const void* elem1, const void* elem2)
+{
+	return (int)((struct GOBBlockTableEntry *)elem1)->offset - 
+		(int)((struct GOBBlockTableEntry *)elem2)->offset;
+}
+
+// GOBArchiveCheckMarkers
+// Public function.  Check start/end markers to check approximate validity of GOB file
+GOBError GOBArchiveCheckMarkers(GOBVoid)
+{
+	GOBUInt32 i;
+	GOBUInt32 valid_blocks;
+	struct GOBBlockTableEntry *blocks;
+	GOBUInt32 block;
+	GOBUInt32 start_marker;
+	GOBUInt32 end_marker;
+	GOBBool ok;
+
+	if (!LibraryInit) return GOBERR_NOT_INIT;
+	if (InvalidHandle(ArchiveHandle)) return GOBERR_NOT_OPEN;
+
+	// count valid blocks
+	valid_blocks = 0;
+	for (i = 0; i < ArchiveNumBlocks; i++)
+	{
+		if (BlockTable[i].size != GOB_INVALID_SIZE && 
+			BlockTable[i].next != GOB_INVALID_BLOCK)
+		{
+			valid_blocks++;
+		}
+	}
+
+	// arcvive is empty
+	if (valid_blocks == 0)
+	{
+		return GOBERR_OK;
+	}
+
+	// alloc mem for valid block list
+	blocks = (GOBBlockTableEntry *) MemFuncs.alloc(sizeof(*blocks) * valid_blocks);
+	if (blocks == NULL)
+	{
+		return GOBERR_NO_MEMORY;
+	}
+
+	// copy valid blocks descriptions
+	block = 0;
+	for (i = 0; i < ArchiveNumBlocks; ++i)
+	{
+		if (BlockTable[i].size != GOB_INVALID_SIZE && 
+			BlockTable[i].next != GOB_INVALID_BLOCK)
+		{
+			blocks[block++] = BlockTable[i];
+		}
+	}
+	assert(block == valid_blocks);
+
+	// and sort 'em
+	qsort(blocks, valid_blocks, sizeof(*blocks), SortBlockDescsCallback);
+
+	// suppress some warnings
+	start_marker = 0;
+	end_marker = 0;
+
+	// now scan entire archive for start-of-block and end-of-block markers
+	for (i = 0; i < valid_blocks; i++)
+	{
+		ok = GOB_TRUE;
+		ok = ok && !FSFuncs.seek(ArchiveHandle, blocks[i].offset, GOBSEEK_START);
+		ok = ok && FSFuncs.read(ArchiveHandle, &start_marker, sizeof(GOBUInt32)) == sizeof(GOBUInt32);
+		ok = ok && !FSFuncs.seek(ArchiveHandle, blocks[i].offset + blocks[i].size - sizeof(GOBUInt32), GOBSEEK_START);
+		ok = ok && FSFuncs.read(ArchiveHandle, &end_marker, sizeof(GOBUInt32)) == sizeof(GOBUInt32);
+		if (!ok || 
+			SwapBytes(start_marker) != GOBMARKER_STARTBLOCK || 
+			SwapBytes(end_marker) != GOBMARKER_ENDBLOCK)
+		{
+			MemFuncs.free(blocks);
+			
+			return GOBERR_NOT_GOB_FILE;
+		}
+	}
+	
+	MemFuncs.free(blocks);
+	
+	return GOBERR_OK;
+}
+
+// GOBArchiveCreate
+// Public function.  Create an empty GFC and GOB.
+GOBUInt32 GOBGetSlack(GOBUInt32 x)
+{
+	GOBUInt32 align = x % GOB_BLOCK_ALIGNMENT;
+	if (align) return GOB_BLOCK_ALIGNMENT - align;
+	return 0;
+}
+
+// GOBOpen
+// Public function.  Open a file inside a GOB.
+GOBError GOBOpen(GOBChar* file, GOBHandle* handle)
+{
+	GOBInt32 entry;
+	GOBChar* lfile;
+	
+	if (!LibraryInit) return GOBERR_NOT_INIT;
+	if (InvalidHandle(ArchiveHandle)) return GOBERR_NOT_OPEN;
+
+	// find a free handle
+	for (*handle = 0; *handle < GOB_MAX_OPEN_FILES; (*handle) += 1) {
+		if (!OpenFiles[*handle].valid) break;
+	}
+
+	if (*handle >= GOB_MAX_OPEN_FILES) return GOBERR_TOO_MANY_OPEN;
+
+	// find the file in the table
+	lfile = LowerCase(file);
+
+	entry = GetFileTableEntry(lfile);
+
+	if (entry == -1) return GOBERR_FILE_NOT_FOUND;
+
+	// setup the open file
+	OpenFiles[*handle].startBlock = OpenFiles[*handle].block = 
+		FileTableBasic[entry].block;
+	OpenFiles[*handle].size = FileTableBasic[entry].size;
+	OpenFiles[*handle].offset = 0;
+	OpenFiles[*handle].pos = 0;
+
+	OpenFiles[*handle].valid = GOB_TRUE;
+
+	++ReadStats.filesOpened;
+	
+	return GOBERR_OK;
+}
+
+// GOBOpenCode
+// Public function.  Open file with a code inside a GOB.
+GOBError GOBOpenCode(GOBInt32 code, GOBHandle* handle)
+{	
+	if (!LibraryInit) return GOBERR_NOT_INIT;
+	if (InvalidHandle(ArchiveHandle)) return GOBERR_NOT_OPEN;
+
+	// find a free handle
+	for (*handle = 0; *handle < GOB_MAX_OPEN_FILES; (*handle) += 1) {
+		if (!OpenFiles[*handle].valid) break;
+	}
+
+	if (*handle >= GOB_MAX_OPEN_FILES) return GOBERR_TOO_MANY_OPEN;
+
+	// setup the open file
+	OpenFiles[*handle].startBlock = OpenFiles[*handle].block = 
+		FileTableBasic[code].block;
+	OpenFiles[*handle].size = FileTableBasic[code].size;
+	OpenFiles[*handle].offset = 0;
+	OpenFiles[*handle].pos = 0;
+
+	OpenFiles[*handle].valid = GOB_TRUE;
+
+	++ReadStats.filesOpened;
+	
+	return GOBERR_OK;
+}
+
+// GOBClose
+// Public function.  Close a file.
+GOBError GOBClose(GOBHandle handle)
+{
+	if (!LibraryInit) return GOBERR_NOT_INIT;
+	if (InvalidHandle(ArchiveHandle)) return GOBERR_NOT_OPEN;
+	if (!OpenFiles[handle].valid) return GOBERR_NOT_OPEN;
+	
+	// close the file by simply invalidating the open
+	// file table entry
+	OpenFiles[handle].valid = GOB_FALSE;
+	
+	return GOBERR_OK;
+}
+
+static GOBUInt32 RawRead(GOBVoid* buffer, GOBUInt32 size, GOBUInt32 pos)
+{
+	GOBUInt32 bytes;
+
+	// Reads _must_ be aligned otherwise things get very slow
+	if (pos % GOB_BLOCK_ALIGNMENT) {
+		return 0;
+	}
+	if ((GOBUInt32)buffer % GOB_MEM_ALIGNMENT) {
+		return 0;
+	}
+	
+	// seek
+	if (FSFuncs.seek(ArchiveHandle, pos, GOBSEEK_START)) return 0;
+	
+	if (CurrentArchivePos != pos) ++ReadStats.totalSeeks;
+	if (pos > CurrentArchivePos + GOB_BLOCK_ALIGNMENT ||
+		CurrentArchivePos > pos + GOB_BLOCK_ALIGNMENT)
+	{
+		++ReadStats.farSeeks;
+	}
+
+	// read
+	bytes = FSFuncs.read(ArchiveHandle, buffer, size);
+	
+	ReadStats.bytesRead += bytes;
+	CurrentArchivePos = pos + bytes;
+	
+	return bytes;
+}
+
+static GOBUInt32 CacheRawRead(GOBVoid* buffer, GOBUInt32 size, GOBUInt32 pos)
+{
+	GOBUInt32 bytes;
+
+	// Reads _must_ be aligned otherwise things get very slow
+	if (pos % GOB_BLOCK_ALIGNMENT) {
+		return 0;
+	}
+	if ((GOBUInt32)buffer % GOB_MEM_ALIGNMENT) {
+		return 0;
+	}
+	
+	// seek
+	if (CacheFileFuncs.seek(pos)) return 0;
+	
+	// read
+	bytes = CacheFileFuncs.read(buffer, size);
+	ReadStats.cacheBytesRead += bytes;
+
+	return bytes;
+}
+
+static GOBUInt32 CacheRawWrite(GOBVoid* buffer, GOBUInt32 size, GOBUInt32 pos)
+{
+	GOBUInt32 bytes;
+
+	// Writes _must_ be aligned otherwise things get very slow
+	if (pos % GOB_BLOCK_ALIGNMENT) {
+		return 0;
+	}
+	if ((GOBUInt32)buffer % GOB_MEM_ALIGNMENT) {
+		return 0;
+	}
+	
+	// seek
+	if (CacheFileFuncs.seek(pos)) return 0;
+	
+	// write
+	bytes = CacheFileFuncs.write(buffer, size);	
+	ReadStats.cacheBytesWrite += bytes;
+	
+	return bytes;
+}
+
+static GOBInt32 BlockReadLow(GOBUInt32 block)
+{
+	GOBUInt32 pos;
+	GOBUInt32 bytes;
+	GOBBool cache_read;
+	GOBBool cache_write;
+	GOBBool cache_fail;
+
+	pos = 0;
+	cache_read = GOB_FALSE;
+	cache_write = GOB_FALSE;
+	cache_fail = GOB_FALSE;
+	
+	for (;;) {	
+		// is the block in the read ahead buffer?
+		if (ReadBuffer.pos <= BlockTable[block].offset + pos &&
+			ReadBuffer.pos + ReadBuffer.size > BlockTable[block].offset + pos)
+		{
+			GOBUInt32 buffer_offset;
+			GOBUInt32 buffer_size;
+			
+			// use data in the read buffer
+			buffer_offset = BlockTable[block].offset + pos - ReadBuffer.pos;
+			buffer_size = ReadBuffer.size - buffer_offset;
+
+			// clamp size
+			if (buffer_size > BlockTable[block].size - pos) {
+				buffer_size = BlockTable[block].size - pos;
+			}
+			
+			memcpy(&DecompBuffer[pos], &ReadBuffer.dataStart[buffer_offset], buffer_size);
+
+			pos += buffer_size;
+		}
+
+		// got enough data
+		if (pos == BlockTable[block].size) break;
+
+		// refill read buffer
+		ReadBuffer.pos = BlockTable[block].offset + pos;
+		ReadBuffer.pos -= ReadBuffer.pos % GOB_BLOCK_ALIGNMENT;
+
+		// check if block is in the external cache system
+		if (CacheFileActive &&
+			CacheFileTable[block / 32] & (1 << (block % 32)))
+		{
+			if (CacheRawRead(ReadBuffer.dataStart, 
+				ReadBuffer.size, ReadBuffer.pos))
+			{
+				cache_read = GOB_TRUE;
+				continue;
+			}
+		}
+
+		// read block from archive
+		bytes = RawRead(ReadBuffer.dataStart, ReadBuffer.size, ReadBuffer.pos);
+		if (bytes != ReadBuffer.size && 
+			bytes != ArchiveSize - ReadBuffer.pos) 
+		{
+			return -1; // Main read fail error code
+		}
+		
+		// write block to cache file
+		if (CacheFileActive)
+		{
+			if (CacheRawWrite(ReadBuffer.dataStart, bytes, 
+				ReadBuffer.pos) == bytes)
+			{
+				cache_write = GOB_TRUE;
+			}
+			else
+			{
+				cache_fail = GOB_TRUE;
+			}
+		}
+	}
+
+	if (cache_write) {
+		if (!cache_fail) return 2;
+		return 0;
+	}
+
+	if (cache_read) return 1;
+	return 0;
+}
+
+static GOBBool BlockReadWithCache(GOBUInt32 block)
+{
+	GOBInt32 i;
+	
+	for (i = 0; i < GOB_READ_RETRYS; ++i) {
+		GOBInt32 result;
+
+		// read the data
+		result = BlockReadLow(block);
+		if (result >= 0)
+		{
+			if (BlockCRC) {
+				// crc check
+				GOBUInt32 crc;
+
+				crc = adler32(0L, Z_NULL, 0);
+				crc = adler32(crc, (const unsigned char*)DecompBuffer, 
+					BlockTable[block].size);
+				
+				if (BlockCRC[block] != crc) {
+					// crc mismatch, we must have got bad data --
+					// try invalidating the cache and retrying...
+					if (CacheFileActive) {
+						CacheFileTable[block / 32] &= ~(1 << (block % 32));
+					}
+					ReadBuffer.pos = 0xFFFFFFFF;
+					continue;
+				}
+			}
+
+			// if cache write occurred -- mark block as cached
+			if (result == 2) {
+				CacheFileTable[block / 32] |= (1 << (block % 32));
+			}
+			
+			// read success, crc success (or no check performed)
+			return GOB_TRUE;
+		}
+	}
+
+	// multiple read/crc failures
+	return GOB_FALSE;
+}
+
+static GOBUInt32 BlockRead(GOBVoid* buffer, GOBUInt32 block)
+{
+	GOBUInt32 size;
+	GOBInt32 codec_index;
+	GOBChar *compressed_data;
+	
+	// read block from cache or archive
+	if (!BlockReadWithCache(block))
+	{
+		return GOB_INVALID_SIZE;
+	}
+	
+	// decompress
+	codec_index = 0;
+	size = 0; // Initialize to satisfy compiler
+	compressed_data = DecompBuffer + sizeof(GOBUInt32); // skip start-of-block marker
+	while (codec_index < CodecFuncs.codecs) {
+		// Check if codec matches
+		if (*compressed_data == CodecFuncs.codec[codec_index].tag) {
+			size = GOB_BLOCK_SIZE;
+			if (CodecFuncs.codec[codec_index].decompress(compressed_data + 1, 
+				BlockTable[block].size - 1 - sizeof(GOBUInt32) * 2, buffer, &size)) {
+				return GOB_INVALID_SIZE;
+			}
+			break;
+		}
+		codec_index++;
+	}
+
+	// If no suitable codecs were found, we're screwed
+	if (codec_index == CodecFuncs.codecs) {
+		return GOB_INVALID_SIZE;
+	}
+
+	if (ProfileReadCallback && ProfileEnabled) {
+		// register current read command
+		ProfileReadCallback(block);
+	}
+
+	return size;
+}
+
+static GOBVoid FillCacheBlock(GOBUInt32 block, GOBUInt32 index)
+{
+	CacheBlocks[index].time = CacheBlockCounter++;
+	CacheBlocks[index].block = block;
+	CacheBlocks[index].size = BlockRead(CacheBlocks[index].data, block);
+}
+
+static GOBInt32 FindBestCacheBlock(GOBUInt32 block)
+{
+	GOBInt32 i;
+	GOBUInt32 oldest_time;
+	GOBInt32 oldest_index;
+
+	oldest_time = 0xFFFFFFFF;
+	oldest_index = -1;
+
+	for (i = 0; i < (signed)NumCacheBlocks; ++i) {
+		if (CacheBlocks[i].block == block) {
+			// if block is in this read buffer, use it
+			return i;
+		}
+		
+		// find the buffer that hasn't been accessed
+		// for the longest time
+		if (CacheBlocks[i].time < oldest_time) {
+			oldest_time = CacheBlocks[i].time;
+			oldest_index = i;
+		}
+	}
+
+	// use the buffer that hasn't been accessed
+	// in the longest time
+	return oldest_index;
+}
+
+// GOBRead
+// Public function.  Read from an open file using
+// a funky read-ahead buffer system.
+GOBUInt32 GOBRead(GOBVoid* buffer, GOBUInt32 size, GOBHandle handle)
+{
+	GOBUInt32 pos;
+	GOBInt32 cache_id;
+	
+	if (!LibraryInit) return 0;
+	if (InvalidHandle(ArchiveHandle)) return 0;
+	if (!OpenFiles[handle].valid) return 0;
+
+	// make sure we're reading within the file
+	if (OpenFiles[handle].pos + size > OpenFiles[handle].size) {
+		size = OpenFiles[handle].size - OpenFiles[handle].pos;
+		if (!size) return 0;
+	}
+	
+	cache_id = FindBestCacheBlock(OpenFiles[handle].block);
+	if (cache_id < 0) return GOB_INVALID_SIZE;
+
+	pos = OpenFiles[handle].pos;
+
+	for (;;) {
+		// are looking for data inside the read buffer?
+		if (CacheBlocks[cache_id].block == OpenFiles[handle].block) {
+			// move any relevant data from the read buffer to the target buffer
+			GOBUInt32 buffer_size;
+			
+			// calc size of data we want from current buffer
+			buffer_size = CacheBlocks[cache_id].size - OpenFiles[handle].offset;
+			if (buffer_size > size) buffer_size = size;
+			
+			// move from read buffer into output buffer
+			memcpy(&((char*)buffer)[OpenFiles[handle].pos - pos], 
+				&CacheBlocks[cache_id].data[OpenFiles[handle].offset], 
+				buffer_size);
+
+			// update file position
+			OpenFiles[handle].pos += buffer_size;
+			OpenFiles[handle].offset += buffer_size;
+			
+			// if we've completed this block -- move to next
+			if (OpenFiles[handle].offset == CacheBlocks[cache_id].size) {
+				OpenFiles[handle].block = BlockTable[OpenFiles[handle].block].next;
+				OpenFiles[handle].offset = 0;
+			}
+			
+			CacheBlocks[cache_id].time = CacheBlockCounter++;
+		
+			ReadStats.bufferUsed += buffer_size;
+			size -= buffer_size;
+			if (size == 0) break;
+		}
+
+		// refill the buffer
+		FillCacheBlock(OpenFiles[handle].block, cache_id);
+		if (CacheBlocks[cache_id].size == GOB_INVALID_SIZE) {
+			CacheBlocks[cache_id].block = GOB_INVALID_BLOCK;
+			return GOB_INVALID_SIZE;
+		}
+
+		// reading off the end of the archive
+		if (CacheBlocks[cache_id].block != OpenFiles[handle].block) break;
+	}
+	
+	return OpenFiles[handle].pos - pos;
+}
+
+// GOBSeek
+// Public function.  Seek to a position in an open file.
+GOBError GOBSeek(GOBHandle handle, GOBUInt32 offset, GOBSeekType type, GOBUInt32* pos)
+{
+	GOBUInt32 blocks;
+	
+	if (!LibraryInit) return GOBERR_NOT_INIT;
+	if (InvalidHandle(ArchiveHandle)) return GOBERR_NOT_OPEN;
+	if (!OpenFiles[handle].valid) return GOBERR_NOT_OPEN;
+	
+	// find a new position based on the seek type
+	switch (type) {
+	case GOBSEEK_START:
+		*pos = offset;
+		break;
+
+	case GOBSEEK_CURRENT:
+		*pos = OpenFiles[handle].pos + offset;
+		break;
+
+	case GOBSEEK_END:
+		*pos = OpenFiles[handle].size + offset;
+		break;
+
+	default:
+		return GOBERR_INVALID_SEEK;
+	}
+
+	// check to make sure we're still in the file
+	if (*pos > OpenFiles[handle].size) {
+		return GOBERR_INVALID_SEEK;
+	}
+
+	// update the file position
+	OpenFiles[handle].pos = *pos;
+
+	// update block
+	blocks = *pos / GOB_BLOCK_SIZE;
+	OpenFiles[handle].block = OpenFiles[handle].startBlock;
+	while (blocks--) {
+		OpenFiles[handle].block = BlockTable[OpenFiles[handle].block].next;
+	}
+
+	// update position inside block
+	OpenFiles[handle].offset = *pos % GOB_BLOCK_SIZE;
+
+	return GOBERR_OK;
+}
+
+
+static GOBUInt32 FindFreeBlock(GOBVoid)
+{
+	GOBInt32 i;
+	for (i = 0; i < GOB_MAX_BLOCKS; ++i) {
+		if (BlockTable[i].next == GOB_INVALID_BLOCK) return i;
+	}
+	return GOB_MAX_BLOCKS;
+}
+
+// GOBWrite
+// Public function.  Write an entire file.  The file should not be open!
+GOBError GOBWrite(GOBVoid* buffer, GOBUInt32 size, GOBUInt32 mtime, const GOBChar* file, GOBUInt32 codec_mask)
+{
+	GOBHandle handle;
+	GOBInt32 slack;
+	GOBChar* lfile;
+	GOBUInt32 hash;
+	GOBUInt32 crc;
+	GOBInt32 i;
+	GOBChar* out;
+	GOBUInt32 pos;
+	GOBUInt32 last_block;
+	GOBInt32 codec_index;
+	GOBInt32 compression_ratio;
+	GOBChar* out_data;
+	GOBUInt32 compressed_size;
+	
+	if (!LibraryInit) return GOBERR_NOT_INIT;
+	if (InvalidHandle(ArchiveHandle)) return GOBERR_NOT_OPEN;
+	if (!FileTableExt) return GOBERR_NO_EXTENDED;
+	if (!BlockCRC) return GOBERR_NO_EXTENDED;
+
+	InvalidateCache();
+
+	// delete the file if it exists
+	GOBDelete(file);
+
+	// find a free entry in the file table
+	for (handle = 0; handle < GOB_MAX_FILES; ++handle) {
+		if (FileTableBasic[handle].block == GOB_INVALID_BLOCK) break;
+	}
+
+	if (handle >= GOB_MAX_FILES) return GOBERR_TOO_MANY_FILES;
+	if (handle >= (GOBInt32)ArchiveNumFiles) ArchiveNumFiles = handle + 1;
+
+	// move to the end of the GOB
+	if (FSFuncs.seek(ArchiveHandle, 0, GOBSEEK_END)) {
+		return GOBERR_FILE_WRITE;
+	}
+	
+	// alloc compression buffer
+	out = (GOBChar*)MemFuncs.alloc(GOB_BLOCK_SIZE + GOB_COMPRESS_OVERHEAD);
+
+	last_block = GOB_MAX_BLOCKS - 1;
+
+	for (pos = 0; pos < size; pos += GOB_BLOCK_SIZE) {
+		GOBUInt32 block;
+		GOBUInt32 in_size;
+
+		// get a free block
+		block = FindFreeBlock();
+		if (block >= GOB_MAX_BLOCKS) return GOBERR_TOO_MANY_BLOCKS;
+		if (block >= ArchiveNumBlocks) ArchiveNumBlocks = block + 1;
+
+		// if this is not the first block, mark next block for the last block
+		// else assign the first block in file table
+		if (pos != 0) BlockTable[last_block].next = block;
+		else FileTableBasic[handle].block = block;
+		
+		// invalidate the next block
+		BlockTable[block].next = GOB_MAX_BLOCKS;
+
+		// compute the decompressed block size
+		in_size = size - pos;
+		if (in_size > GOB_BLOCK_SIZE) in_size = GOB_BLOCK_SIZE;
+
+		// compress block
+		
+		for (
+			codec_index = 0;
+			codec_index < CodecFuncs.codecs;
+			codec_index++)
+		{
+			if ( ! (GOB_CODEC_MASK(codec_index) & codec_mask) )
+			{
+				// skip if this codec is not listed as one of the allowed ones
+				continue;
+			}
+			BlockTable[block].size = GOB_BLOCK_SIZE + GOB_COMPRESS_OVERHEAD;
+			out_data = out;
+			*(GOBUInt32*)out_data = SwapBytes(GOBMARKER_STARTBLOCK);
+			out_data += sizeof(GOBUInt32);
+			*out_data = CodecFuncs.codec[codec_index].tag;
+			out_data++;
+			if (CodecFuncs.codec[codec_index].compress(&((GOBChar*)buffer)[pos],
+				in_size, out_data, &BlockTable[block].size)) 
+			{
+				return GOBERR_COMPRESS_FAIL;
+			}
+			out_data += BlockTable[block].size;
+			*(GOBUInt32*)out_data = SwapBytes(GOBMARKER_ENDBLOCK);
+			out_data += sizeof(GOBUInt32);
+
+			// Adjust for the prefixed start-of-block marker and codec tag and trailing end-of-block marker
+			compressed_size = BlockTable[block].size;
+			BlockTable[block].size += 1 + sizeof(GOBUInt32) * 2;
+
+			// Check compression result
+			compression_ratio = compressed_size * 100 / in_size;
+			if (compression_ratio <= CodecFuncs.codec[codec_index].max_ratio)
+			{
+				// Compressed result is under par.  Let's go with it
+				break;
+			}
+
+			// Otherwise, try the next compressor
+		}
+
+		// If no suitable codecs were found, take our ball and go home
+		if (codec_index == CodecFuncs.codecs) return GOBERR_NO_SUITABLE_CODEC;
+
+		// compute and store the CRC
+		BlockCRC[block] = adler32(0L, Z_NULL, 0);
+		BlockCRC[block] = adler32(BlockCRC[block], (const unsigned char*)out, 
+					BlockTable[block].size);
+
+		// write block
+		if (FSFuncs.write(ArchiveHandle, out, BlockTable[block].size) != 
+			(signed)BlockTable[block].size) 
+		{
+			return GOBERR_FILE_WRITE;
+		}
+
+		// compute the slack (to keep alignment)
+		slack = GOBGetSlack(BlockTable[block].size);
+	
+		// write the slack space
+		memset(out, 0, slack);
+		if (FSFuncs.write(ArchiveHandle, out, slack) != slack) {
+			return GOBERR_FILE_WRITE;
+		}
+	
+		BlockTable[block].offset = ArchiveSize;
+		ArchiveSize += BlockTable[block].size + slack;
+
+		last_block = block;
+	}
+
+	MemFuncs.free(out);
+
+	lfile = LowerCase(file);
+
+	// calculate file name hash
+	hash = crc32(0L, Z_NULL, 0);
+	hash = crc32(hash, (const unsigned char*)lfile, strlen(lfile));
+	
+	// make sure hash is unique
+	for (i = 0; i < GOB_MAX_FILES; ++i) {
+		if (i != handle &&
+			FileTableBasic[i].block != GOB_INVALID_BLOCK && 
+			FileTableBasic[i].hash == hash) 
+		{
+			return GOBERR_DUP_HASH;
+		}
+	}
+
+	// update the file tables
+	FileTableBasic[handle].hash = hash;
+	FileTableBasic[handle].size = size;
+
+	strcpy(FileTableExt[handle].name, lfile);
+	
+	crc = crc32(0L, Z_NULL, 0);
+	crc = crc32(crc, (const unsigned char*)buffer, size);
+	FileTableExt[handle].crc = crc;
+	
+	FileTableExt[handle].time = mtime;
+
+	FileTableDirty = GOB_TRUE;
+	return GOBERR_OK;
+}
+
+// GOBDelete
+// Public function.  Delete a file from a GOB.  The file should not be open!
+GOBError GOBDelete(const GOBChar* file)
+{
+	GOBInt32 entry;
+	GOBChar* lfile;
+	GOBUInt32 block;
+
+	if (!LibraryInit) return GOBERR_NOT_INIT;
+	if (InvalidHandle(ArchiveHandle)) return GOBERR_NOT_OPEN;
+	if (!FileTableExt) return GOBERR_NO_EXTENDED;
+	if (!BlockCRC) return GOBERR_NO_EXTENDED;
+
+	// find the file in the table
+	lfile = LowerCase(file);
+	
+	entry = GetFileTableEntry(lfile);
+	if (entry == -1) return GOBERR_FILE_NOT_FOUND;
+
+	// invalidate blocks
+	block = FileTableBasic[entry].block;
+	do {
+		GOBUInt32 next;
+		next = BlockTable[block].next;
+		BlockTable[block].next = GOB_INVALID_BLOCK;
+		block = next;
+	 } while(block != GOB_MAX_BLOCKS);
+
+	// invalidate the file
+	FileTableBasic[entry].block = GOB_INVALID_BLOCK;
+
+	FileTableDirty = GOB_TRUE;
+
+	return GOBERR_OK;
+}
+
+// GOBRearrange
+// Public function.  Sorts the blocks in an archive.
+GOBError GOBRearrange(const GOBChar* file, const GOBUInt32* xlat, GOBFileSysRenameFunc _rename)
+{
+	GOBError err;
+	GOBVoid* buffer;
+	GOBInt32 slack;
+	GOBVoid* slack_buf;
+	GOBUInt32 i;
+	GOBUInt32 size;
+	GOBFSHandle temp_handle;
+	GOBChar full_name[GOB_MAX_FILE_NAME_LEN];
+	
+	if (!LibraryInit) return GOBERR_NOT_INIT;
+	if (!InvalidHandle(ArchiveHandle)) return GOBERR_ALREADY_OPEN;
+	if (!FileTableExt) return GOBERR_NO_EXTENDED;
+	if (!BlockCRC) return GOBERR_NO_EXTENDED;
+
+	// start things up
+	err = GOBArchiveOpen(file, GOBACCESS_READ, GOB_TRUE, GOB_TRUE);
+	if (err != GOBERR_OK) return err;
+
+	// create temporary file
+	temp_handle = FSFuncs.open("~temp.tmp", GOBACCESS_WRITE);
+	if (InvalidHandle(temp_handle)) return GOBERR_FILE_WRITE;
+
+	size = 0;
+
+	// create an empty buffer for slack
+	slack_buf = MemFuncs.alloc(GOB_BLOCK_ALIGNMENT);
+	if (!slack_buf) return GOBERR_NO_MEMORY;
+	memset(slack_buf, 0, GOB_BLOCK_ALIGNMENT);
+
+	// get memory for block
+	buffer = MemFuncs.alloc(GOB_BLOCK_SIZE + GOB_COMPRESS_OVERHEAD);
+	if (!buffer) return GOBERR_NO_MEMORY;
+
+	// copy files in new order to end of archive
+	for (i = 0; i < ArchiveNumBlocks; ++i) {
+		if (BlockTable[xlat[i]].next != GOB_INVALID_BLOCK) {
+			// seek to the block
+			if (FSFuncs.seek(ArchiveHandle, 
+				BlockTable[xlat[i]].offset, GOBSEEK_START)) 
+			{
+				return GOBERR_FILE_READ;
+			}
+			
+			// read the block
+			if (FSFuncs.read(ArchiveHandle, buffer, BlockTable[xlat[i]].size) !=
+				(signed)BlockTable[xlat[i]].size) 
+			{
+				return GOBERR_FILE_READ;
+			}
+
+			// write block
+			if (FSFuncs.write(temp_handle, buffer, BlockTable[xlat[i]].size) !=
+				(signed)BlockTable[xlat[i]].size) 
+			{
+				return GOBERR_FILE_WRITE;
+			}
+			
+			// write the slack
+			slack = GOBGetSlack(BlockTable[xlat[i]].size);
+			if (FSFuncs.write(temp_handle, slack_buf, slack) != slack) {
+				return GOBERR_FILE_WRITE;
+			}
+			
+			// update block pos
+			BlockTable[xlat[i]].offset = size;
+			size += BlockTable[xlat[i]].size + slack;
+		}
+	}
+
+	MemFuncs.free(buffer);
+	MemFuncs.free(slack_buf);
+	
+	// close the archive
+	err = GOBArchiveClose();
+	if (err != GOBERR_OK) return err;
+
+	// close temp file
+	FSFuncs.close(&temp_handle);
+
+	// overrwrite archive with temp file
+	_snprintf(full_name, GOB_MAX_FILE_NAME_LEN, "%s.gob", file);
+	if (_rename("~temp.tmp", full_name)) return GOBERR_FILE_RENAME;
+
+	ArchiveSize = size;
+
+	CommitFileTable();
+			
+	return GOBERR_OK;
+}
+
+
+// GOBVerify
+// Public function.  Verifies the integrity of a file.
+GOBError GOBVerify(const GOBChar* file, GOBBool* status)
+{
+	GOBHandle handle;
+	GOBError err;
+	GOBVoid* buffer;
+	GOBUInt32 size, junk;
+	GOBUInt32 crc;
+	GOBInt32 entry;
+	GOBChar* lfile;
+
+	if (!LibraryInit) return GOBERR_NOT_INIT;
+	if (InvalidHandle(ArchiveHandle)) return GOBERR_NOT_OPEN;
+	if (!FileTableExt) return GOBERR_NO_EXTENDED;
+	if (!BlockCRC) return GOBERR_NO_EXTENDED;
+
+	// get the file size
+	size = 0; // assign to avoid compiler warning
+	err = GOBGetSize(file, &size, &junk, &junk);
+	if (err != GOBERR_OK) return err;
+	
+	// open the file
+	err = GOBOpen((GOBChar*)file, &handle);
+	if (err != GOBERR_OK) return err;
+
+	lfile = LowerCase(file);
+	entry = GetFileTableEntry(lfile);
+
+	// alloc space for the file 
+	buffer = MemFuncs.alloc(size);
+	if (!buffer) return GOBERR_NO_MEMORY;
+
+	// read it into the buffer
+	crc = GOBRead(buffer, size, handle);
+	if (crc != size) return GOBERR_FILE_READ;
+	
+	// calc the crc
+	crc = crc32(0L, Z_NULL, 0);
+	crc = crc32(crc, (const unsigned char*)buffer, size);
+	
+	MemFuncs.free(buffer);
+
+	// verify the crc matches
+	if (crc != FileTableExt[entry].crc) *status = GOB_FALSE;
+	else *status = GOB_TRUE;
+	
+	err = GOBClose(handle);
+	if (err != GOBERR_OK) return err;
+	
+	return GOBERR_OK;
+}
+
+// GOBGetSize
+// Public function.  Get a file compressed, decompressed, slack sizes.
+GOBError GOBGetSize(const GOBChar* file, 
+	GOBUInt32* decomp, GOBUInt32* comp, GOBUInt32* slack)
+{
+	GOBInt32 entry;
+	GOBChar* lfile;
+	GOBUInt32 block;
+
+	if (!LibraryInit) return GOBERR_NOT_INIT;
+	if (InvalidHandle(ArchiveHandle)) return GOBERR_NOT_OPEN;
+
+	// get file table entry
+	lfile = LowerCase(file);
+	entry = GetFileTableEntry(lfile);
+	if (entry == -1) return GOBERR_FILE_NOT_FOUND;
+
+	// decompressed size from file table
+	*decomp = FileTableBasic[entry].size;
+	
+	// compressed size is sum of block sizes
+	*comp = 0;
+	*slack = 0;
+	block = FileTableBasic[entry].block;
+	while (block != GOB_MAX_BLOCKS) {
+		*comp += BlockTable[block].size;
+		*slack += GOBGetSlack(BlockTable[block].size);
+		block = BlockTable[block].next;
+	}
+
+	return GOBERR_OK;
+}
+
+// GOBGetTime
+// Public function.  Get a file modification time.
+GOBError GOBGetTime(const GOBChar* file, GOBUInt32* time)
+{
+	GOBInt32 entry;
+	GOBChar* lfile;
+
+	if (!LibraryInit) return GOBERR_NOT_INIT;
+	if (InvalidHandle(ArchiveHandle)) return GOBERR_NOT_OPEN;
+	if (!FileTableExt) return GOBERR_NO_EXTENDED;
+	if (!BlockCRC) return GOBERR_NO_EXTENDED;
+
+	lfile = LowerCase(file);
+	entry = GetFileTableEntry(lfile);
+	if (entry == -1) return GOBERR_FILE_NOT_FOUND;
+
+	*time = FileTableExt[entry].time;
+	return GOBERR_OK;
+}
+
+// GOBGetCRC
+// Public function.  Get a file CRC.
+GOBError GOBGetCRC(const GOBChar* file, GOBUInt32* crc)
+{
+	GOBInt32 entry;
+	GOBChar* lfile;
+
+	if (!LibraryInit) return GOBERR_NOT_INIT;
+	if (InvalidHandle(ArchiveHandle)) return GOBERR_NOT_OPEN;
+	if (!FileTableExt) return GOBERR_NO_EXTENDED;
+	if (!BlockCRC) return GOBERR_NO_EXTENDED;
+
+	lfile = LowerCase(file);
+	entry = GetFileTableEntry(lfile);
+	if (entry == -1) return GOBERR_FILE_NOT_FOUND;
+
+	*crc = FileTableExt[entry].crc;
+	return GOBERR_OK;
+}
+
+// GOBAccess
+// Public function.  Determine if a file exists in the archive.
+GOBError GOBAccess(const GOBChar* file, GOBBool* status)
+{
+	GOBInt32 entry;
+	GOBChar* lfile;
+
+	if (!LibraryInit) return GOBERR_NOT_INIT;
+	if (InvalidHandle(ArchiveHandle)) return GOBERR_NOT_OPEN;
+
+	lfile = LowerCase(file);
+	entry = GetFileTableEntry(lfile);
+	if (entry == -1) *status = GOB_FALSE;
+	else *status = GOB_TRUE;
+
+	return GOBERR_OK;
+}
+
+// GOBGetFileCode
+// Public function.  Find the index into the file table of a file.
+GOBInt32 GOBGetFileCode(const GOBChar* file)
+{
+	GOBInt32 entry;
+	GOBChar* lfile;
+
+	if (!LibraryInit) return -1;
+	if (InvalidHandle(ArchiveHandle)) return -1;
+
+	lfile = LowerCase(file);
+	entry = GetFileTableEntry(lfile);
+
+	return entry;
+}
+
+// GOBGetFileTables
+// Public function.  Return the active file tables.
+GOBError GOBGetFileTables(struct GOBFileTableBasicEntry** basic, 
+	struct GOBFileTableExtEntry** ext)
+{
+	if (!LibraryInit) return GOBERR_NOT_INIT;
+	if (InvalidHandle(ArchiveHandle)) return GOBERR_NOT_OPEN;
+	*basic = FileTableBasic;
+	*ext = FileTableExt;
+	return GOBERR_OK;
+}
+
+// GOBGetBlockTable
+// Public function.  Return the active block table.
+GOBError GOBGetBlockTable(struct GOBBlockTableEntry** table, GOBUInt32* num)
+{
+	if (!LibraryInit) return GOBERR_NOT_INIT;
+	if (InvalidHandle(ArchiveHandle)) return GOBERR_NOT_OPEN;
+	*table = BlockTable;
+	*num = ArchiveNumBlocks;
+	return GOBERR_OK;
+}
+
+// GOBSetCacheSize
+// Public function.  Allocates buffers to cache blocks.
+GOBError GOBSetCacheSize(GOBUInt32 num)
+{
+	GOBUInt32 i;
+
+	if (!LibraryInit) return GOBERR_NOT_INIT;
+
+	// only continue if we actually need to resize
+	if (num == NumCacheBlocks) return GOBERR_OK;
+
+	// free old cache buffers
+	FreeCache();
+
+	NumCacheBlocks = 0;
+	
+	CacheBlocks = (struct GOBBlockCache*)MemFuncs.alloc(
+			sizeof(struct GOBBlockCache) * num);
+	if (!CacheBlocks) return GOBERR_NO_MEMORY;
+
+	// allocate cache blocks and initialize
+	for (i = 0; i < num; ++i) {
+		CacheBlocks[i].data = (GOBChar*)MemFuncs.alloc(GOB_BLOCK_SIZE);
+		if (!CacheBlocks[i].data) return GOBERR_NO_MEMORY;
+		
+		CacheBlocks[i].size = 0;
+		CacheBlocks[i].time = 0;
+		CacheBlocks[i].block = 0xFFFFFFFF;
+		
+		++NumCacheBlocks;
+	}
+	
+	return GOBERR_OK;
+}
+
+// GOBSetReadBufferSize
+// Public function.  Allocate a read ahead buffer.
+GOBError GOBSetReadBufferSize(GOBUInt32 size)
+{
+	if (!LibraryInit) return GOBERR_NOT_INIT;
+
+	// only continue if we actually need to resize
+	if (size == ReadBuffer.size) return GOBERR_OK;
+
+	// remove old buffer
+	if (ReadBuffer.data) MemFuncs.free(ReadBuffer.data);
+
+	// allocate new buffer
+	ReadBuffer.data = (GOBChar*)MemFuncs.alloc(size + GOB_MEM_ALIGNMENT);
+	if (!ReadBuffer.data) return GOB_INVALID_SIZE;
+	
+	// set aligned pointer
+	ReadBuffer.dataStart = 
+		&ReadBuffer.data[GOB_MEM_ALIGNMENT - 
+		((GOBUInt32)(ReadBuffer.data) % GOB_MEM_ALIGNMENT)];
+
+	ReadBuffer.pos = 0xFFFFFFFF;
+	ReadBuffer.size = size;
+	
+	return GOBERR_OK;
+}
+
+// GOBGetReadStats
+// Public function.  Get file read statistics (seeks, sizes).
+struct GOBReadStats GOBGetReadStats(GOBVoid)
+{
+	return ReadStats;
+}
+
+
+GOBVoid GOBSetProfileFuncs(struct GOBProfileFuncSet* fset)
+{
+	ProfileReadCallback = fset->read;
+}
+
+GOBError GOBStartProfile(GOBVoid)
+{
+	if (ProfileEnabled) return GOBERR_PROFILE_ON;
+	ProfileEnabled = GOB_TRUE;
+	return GOBERR_OK;
+}
+
+GOBError GOBStopProfile(GOBVoid)
+{
+	if (!ProfileEnabled) return GOBERR_PROFILE_OFF;
+	ProfileEnabled = GOB_FALSE;
+	return GOBERR_OK;
+}
diff --git a/codemp/goblib/goblib.h b/codemp/goblib/goblib.h
new file mode 100644
index 0000000..d975935
--- /dev/null
+++ b/codemp/goblib/goblib.h
@@ -0,0 +1,299 @@
+/*****************************************
+ *
+ * GOB File System
+ *
+ * Here's what Merriam-Webster says about "gob":  --Chuck
+ *		Entry:     gob
+ *		Function:  noun
+ *		Etymology: Middle English gobbe, from Middle French gobe large piece of food,
+ *		           back-formation from gobet
+ *		Date:      14th century
+ *		1 : LUMP
+ *		2 : a large amount -- usually used in plural <gobs of money>
+ *
+ * Purpose: Provide fast, efficient disk access on a variety of platforms.
+ *
+ * Implementation:
+ *		The GOB system maintains two files -- GOB and GFC.  The GOB file is actually
+ *		an archive of many files split into variable size, compressed blocks.  The GFC,
+ *		GOB File Control, contains 3 tables -- a block table, basic file table, and
+ *		extended file table.  The block table is analogous to a DOS FAT.  The basic
+ *		file table contains a minimal set of file information to handle basic reading
+ *		tasks.  The extended file table is optionally loaded and contains additional
+ *		file information.  File names are case insensitive.
+ *		  
+ *		Files can be read in a normal manner.  Open, read, seek and close
+ *		operations are all provided.  Files can only be written in a single
+ *		contiguous chunk of blocks at the end of an archive.  Reads are processed
+ *		through a configurable number of read ahead buffers to in an effort to
+ *		minimize both reads and seeks.  Other operations including delete, verify, 
+ *		access, and get size are also supported on files inside an archive.
+ *
+ *		The system supports read profiling.  By supplying a file read callback 
+ *		function, the library will output the block number of each read.  This can 
+ *		be used rearrange block in the archive to minimize seek times.  The 
+ *		GOBRearrange sorts files in an archive.
+ *
+ *		Supports block based caching.  Primarily aimed at caching files off a DVD/CD
+ *		to a faster hard disk.
+ *
+ * Future Work: 
+ *
+ * Dependencies: vvInt, snprintf, zlib
+ * Owner: Chris McEvoy
+ * History:
+ *     09/23/2001 Original version
+ *     10/28/2002 Merged into vvtech
+ *
+ * Copyright (C) 2002, Vicarious Visions, Inc.  All Rights Reserved.
+ *
+ * UNPUBLISHED -- Rights  reserved  under  the  copyright  laws  of the 
+ * United States.  Use  of a copyright notice is precautionary only and 
+ * does not imply publication or disclosure.                            
+ *                                                                      
+ * THIS DOCUMENTATION CONTAINS CONFIDENTIAL AND PROPRIETARY INFORMATION 
+ * OF    VICARIOUS   VISIONS,  INC.    ANY  DUPLICATION,  MODIFICATION, 
+ * DISTRIBUTION, OR DISCLOSURE IS STRICTLY PROHIBITED WITHOUT THE PRIOR 
+ * EXPRESS WRITTEN PERMISSION OF VICARIOUS VISIONS, INC.
+ *
+ *****************************************/
+
+/*
+	This is an unofficial branch of GOB, for Jedi Academy
+	Maintainer: Brian Osman
+*/
+
+#ifndef GOBLIB_H__
+#define GOBLIB_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define GOB_MAGIC_IDENTIFIER		0x8008
+#define GOB_MAX_FILE_NAME_LEN		96
+#define GOB_MAX_OPEN_FILES			16
+#define GOB_MAX_CODECS				2
+#define GOB_INFINITE_RATIO			1000
+#define GOB_READ_RETRYS				3
+
+#define GOB_MAX_FILES				(16*1024)
+#define GOB_MAX_BLOCKS				32767
+
+#define GOB_BLOCK_SIZE				(64*1024)
+#define GOB_BLOCK_ALIGNMENT			2048
+#define GOB_MEM_ALIGNMENT			64
+#define GOB_COMPRESS_OVERHEAD		1024
+
+#define GOB_INVALID_SIZE			0xFFFFFFFF
+#define GOB_INVALID_BLOCK			0xFFFFFFFF
+
+#define GOB_TRUE					1
+#define GOB_FALSE					0
+
+#define GOBERR_OK					0
+#define GOBERR_NOT_INIT				1
+#define GOBERR_FILE_NOT_FOUND		2
+#define GOBERR_FILE_READ			3
+#define GOBERR_FILE_WRITE			4
+#define GOBERR_NO_MEMORY			5
+#define GOBERR_ALREADY_INIT			6
+#define GOBERR_ALREADY_OPEN			7
+#define GOBERR_INVALID_ACCESS		8
+#define GOBERR_NOT_GOB_FILE			9
+#define GOBERR_NOT_OPEN				10
+#define GOBERR_CANNOT_CREATE		11
+#define GOBERR_TOO_MANY_OPEN		12
+#define GOBERR_INVALID_SEEK			13
+#define GOBERR_TOO_MANY_FILES		14
+#define GOBERR_FILE_RENAME			15
+#define GOBERR_PROFILE_OFF			16
+#define GOBERR_PROFILE_ON			17
+#define GOBERR_NO_EXTENDED			18
+#define GOBERR_DUP_HASH				19
+#define GOBERR_TOO_MANY_BLOCKS		20
+#define GOBERR_COMPRESS_FAIL		21
+#define GOBERR_NO_SUITABLE_CODEC	22
+
+#define GOBACCESS_READ				0
+#define GOBACCESS_WRITE				1
+#define GOBACCESS_RW				2
+
+#define GOBSEEK_START				0
+#define GOBSEEK_CURRENT				1
+#define GOBSEEK_END					2
+
+#define GOB_CODEC_MASK(n)			((GOBUInt32)(1u<<(n)))
+#define GOB_CODEC_MASK_ANY			((GOBUInt32)(-1))
+
+#define GOBMARKER_STARTBLOCK		('L' | 'B' << 8 | 'T' << 16 | 'S' << 24)
+#define GOBMARKER_ENDBLOCK			('L' | 'B' << 8 | 'N' << 16 | 'E' << 24)
+
+typedef int						int32;
+typedef unsigned int			uint32;
+//#define bool					int
+//#define false					0
+//#define true					1
+typedef unsigned long			ulong;
+typedef unsigned char			byte;
+
+typedef int32					GOBInt32;
+typedef uint32					GOBUInt32;
+typedef char					GOBChar;
+typedef bool					GOBBool;
+typedef int32					GOBError;
+typedef int32					GOBSeekType;
+typedef int32					GOBHandle;
+typedef int32					GOBAccessType;
+typedef void*					GOBFSHandle;
+typedef void					GOBVoid;
+
+typedef GOBFSHandle (*GOBFileSysOpenFunc)(GOBChar*, GOBAccessType);
+typedef GOBBool (*GOBFileSysCloseFunc)(GOBFSHandle*);
+typedef GOBInt32 (*GOBFileSysReadFunc)(GOBFSHandle, GOBVoid*, GOBInt32);
+typedef GOBInt32 (*GOBFileSysWriteFunc)(GOBFSHandle, GOBVoid*, GOBInt32);
+typedef GOBInt32 (*GOBFileSysSeekFunc)(GOBFSHandle, GOBInt32, GOBSeekType);
+typedef GOBInt32 (*GOBFileSysRenameFunc)(GOBChar*, GOBChar*);
+
+typedef GOBVoid* (*GOBMemAllocFunc)(GOBUInt32);
+typedef GOBVoid (*GOBMemFreeFunc)(GOBVoid*);
+
+typedef GOBInt32 (*GOBCompressFunc)(GOBVoid*, GOBUInt32, GOBVoid*, GOBUInt32*);
+typedef GOBInt32 (*GOBDecompressFunc)(GOBVoid*, GOBUInt32, GOBVoid*, GOBUInt32*);
+
+typedef GOBBool (*GOBCacheFileOpenFunc)(GOBUInt32);
+typedef GOBBool (*GOBCacheFileCloseFunc)(GOBVoid);
+typedef GOBInt32 (*GOBCacheFileReadFunc)(GOBVoid*, GOBInt32);
+typedef GOBInt32 (*GOBCacheFileWriteFunc)(GOBVoid*, GOBInt32);
+typedef GOBInt32 (*GOBCacheFileSeekFunc)(GOBInt32);
+
+struct GOBBlockTableEntry
+{
+	GOBUInt32 size; // compressed size
+	GOBUInt32 offset;
+	GOBUInt32 next;
+};
+
+struct GOBFileTableBasicEntry
+{
+	GOBUInt32	hash;
+	GOBUInt32	size; // decompressed size
+	GOBUInt32	block;
+};
+
+struct GOBFileTableExtEntry
+{
+	GOBChar		name[GOB_MAX_FILE_NAME_LEN];
+	GOBUInt32	crc;
+	GOBUInt32	time;
+};
+
+struct GOBMemoryFuncSet
+{
+	GOBMemAllocFunc		alloc;
+	GOBMemFreeFunc		free;
+};
+
+struct GOBSingleCodecDesc
+{
+	GOBChar				tag;
+	GOBInt32			max_ratio;
+	GOBCompressFunc		compress;
+	GOBDecompressFunc	decompress;
+};
+
+struct GOBCodecFuncSet
+{
+	GOBInt32 codecs;
+	struct GOBSingleCodecDesc codec[GOB_MAX_CODECS];
+};
+
+struct GOBFileSysFuncSet
+{
+	GOBFileSysOpenFunc		open;
+	GOBFileSysCloseFunc		close;
+	GOBFileSysReadFunc		read;
+	GOBFileSysWriteFunc		write;
+	GOBFileSysSeekFunc		seek;
+};
+
+struct GOBCacheFileFuncSet
+{
+	GOBCacheFileOpenFunc		open;
+	GOBCacheFileCloseFunc		close;
+	GOBCacheFileReadFunc		read;
+	GOBCacheFileWriteFunc		write;
+	GOBCacheFileSeekFunc		seek;
+};
+
+struct GOBReadStats
+{
+	GOBUInt32 bufferUsed;
+	GOBUInt32 bytesRead;
+	GOBUInt32 cacheBytesRead;
+	GOBUInt32 cacheBytesWrite;
+	GOBUInt32 totalSeeks;
+	GOBUInt32 farSeeks;
+	GOBUInt32 filesOpened;
+};
+
+extern GOBError GOBInit(struct GOBMemoryFuncSet* mem, 
+	struct GOBFileSysFuncSet* file, 
+	struct GOBCodecFuncSet* codec,
+	struct GOBCacheFileFuncSet* cache);
+extern GOBError GOBShutdown(GOBVoid);
+
+extern GOBError GOBArchiveCreate(const GOBChar* file);
+extern GOBError GOBArchiveOpen(const GOBChar* file, GOBAccessType atype,
+	GOBBool extended, GOBBool safe);
+extern GOBError GOBArchiveClose(GOBVoid);
+extern GOBError GOBArchiveCheckMarkers(GOBVoid);
+
+extern GOBError GOBOpen(GOBChar* file, GOBHandle* handle);
+extern GOBError GOBOpenCode(GOBInt32 code, GOBHandle* handle);
+extern GOBError GOBClose(GOBHandle handle);
+
+extern GOBUInt32 GOBRead(GOBVoid* buffer, GOBUInt32 size, GOBHandle handle);
+extern GOBError GOBSeek(GOBHandle handle, GOBUInt32 offset, GOBSeekType type, GOBUInt32* pos);
+
+extern GOBError GOBWrite(GOBVoid* buffer, GOBUInt32 size, GOBUInt32 mtime, const GOBChar* file, GOBUInt32 codec_mask);
+extern GOBError GOBDelete(const GOBChar* file);
+
+extern GOBError GOBRearrange(const GOBChar* file, const GOBUInt32* xlat, GOBFileSysRenameFunc _rename);
+
+extern GOBError GOBVerify(const GOBChar* file, GOBBool* status);
+
+extern GOBError GOBGetSize(const GOBChar* file, GOBUInt32* decomp, GOBUInt32* comp, GOBUInt32* slack);
+extern GOBError GOBGetTime(const GOBChar* file, GOBUInt32* time);
+extern GOBError GOBGetCRC(const GOBChar* file, GOBUInt32* crc);
+
+extern GOBError GOBAccess(const GOBChar* file, GOBBool* status);
+extern GOBInt32 GOBGetFileCode(const GOBChar* file);
+
+extern GOBError GOBGetFileTables(struct GOBFileTableBasicEntry** basic, struct GOBFileTableExtEntry** ext);
+extern GOBError GOBGetBlockTable(struct GOBBlockTableEntry** table, GOBUInt32* num);
+extern GOBUInt32 GOBGetSlack(GOBUInt32 x);
+
+extern GOBError GOBSetCacheSize(GOBUInt32 num);
+extern GOBError GOBSetReadBufferSize(GOBUInt32 size);
+
+extern struct GOBReadStats GOBGetReadStats(GOBVoid);
+
+
+typedef GOBVoid (*GOBProfileReadFunc)(GOBUInt32);
+struct GOBProfileFuncSet
+{
+	GOBProfileReadFunc read;
+};
+extern GOBVoid GOBSetProfileFuncs(struct GOBProfileFuncSet* fset);
+
+extern GOBError GOBStartProfile(GOBVoid);
+extern GOBError GOBStopProfile(GOBVoid);
+
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+
+#endif /* GOBLIB_H__ */
diff --git a/codemp/goblib/goblib.vcproj b/codemp/goblib/goblib.vcproj
new file mode 100644
index 0000000..84482f6
--- /dev/null
+++ b/codemp/goblib/goblib.vcproj
@@ -0,0 +1,339 @@
+<?xml version="1.0" encoding = "Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="7.00"
+	Name="goblib"
+	ProjectGUID="{0959DD50-BCBA-4551-9617-E6FD4DF85298}"
+	Keyword="XboxProj">
+	<Platforms>
+		<Platform
+			Name="Xbox"/>
+	</Platforms>
+	<Configurations>
+		<Configuration
+			Name="Debug|Xbox"
+			OutputDirectory="Debug"
+			IntermediateDirectory="Debug"
+			ConfigurationType="4"
+			CharacterSet="2">
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				OptimizeForProcessor="2"
+				PreprocessorDefinitions="_DEBUG;_XBOX;_LIB"
+				MinimalRebuild="TRUE"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="1"
+				UsePrecompiledHeader="0"
+				PrecompiledHeaderFile="$(OutDir)/$(ProjectName).pch"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="FALSE"
+				DebugInformationFormat="4"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLibrarianTool"
+				OutputFile=".\..\x_exe\Debug\goblib.lib"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+		</Configuration>
+		<Configuration
+			Name="Release|Xbox"
+			OutputDirectory="Release"
+			IntermediateDirectory="Release"
+			ConfigurationType="4"
+			CharacterSet="2">
+			<Tool
+				Name="VCCLCompilerTool"
+				AdditionalOptions="/Oy-"
+				Optimization="2"
+				InlineFunctionExpansion="1"
+				OmitFramePointers="FALSE"
+				OptimizeForProcessor="2"
+				PreprocessorDefinitions="NDEBUG;_XBOX;_LIB"
+				StringPooling="TRUE"
+				RuntimeLibrary="0"
+				BufferSecurityCheck="TRUE"
+				EnableFunctionLevelLinking="TRUE"
+				EnableEnhancedInstructionSet="1"
+				UsePrecompiledHeader="0"
+				PrecompiledHeaderFile="$(OutDir)/$(ProjectName).pch"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="FALSE"
+				DebugInformationFormat="3"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLibrarianTool"
+				OutputFile=".\..\x_exe\Release\goblib.lib"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+		</Configuration>
+	</Configurations>
+	<Files>
+		<Filter
+			Name="Source Files"
+			Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm">
+			<File
+				RelativePath="..\zlib\adler32.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\zlib\compress.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\zlib\crc32.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\zlib\deflate.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="goblib.cpp">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\zlib\infblock.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\zlib\infcodes.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\zlib\inffast.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\zlib\inflate.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\zlib\inftrees.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\zlib\infutil.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\zlib\trees.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\zlib\uncompr.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\zlib\zutil.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+		</Filter>
+		<Filter
+			Name="Header Files"
+			Filter="h;hpp;hxx;hm;inl;inc">
+			<File
+				RelativePath="..\zlib\deflate.h">
+			</File>
+			<File
+				RelativePath="goblib.h">
+			</File>
+			<File
+				RelativePath="..\zlib\infblock.h">
+			</File>
+			<File
+				RelativePath="..\zlib\infcodes.h">
+			</File>
+			<File
+				RelativePath="..\zlib\inffast.h">
+			</File>
+			<File
+				RelativePath="..\zlib\inffixed.h">
+			</File>
+			<File
+				RelativePath="..\zlib\inftrees.h">
+			</File>
+			<File
+				RelativePath="..\zlib\infutil.h">
+			</File>
+			<File
+				RelativePath="..\zlib\trees.h">
+			</File>
+			<File
+				RelativePath="..\zlib\zconf.h">
+			</File>
+			<File
+				RelativePath="..\zlib\zlib.h">
+			</File>
+			<File
+				RelativePath="..\zlib\zutil.h">
+			</File>
+		</Filter>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>
diff --git a/codemp/goblib/mssccprj.scc b/codemp/goblib/mssccprj.scc
new file mode 100644
index 0000000..65afff4
--- /dev/null
+++ b/codemp/goblib/mssccprj.scc
@@ -0,0 +1,5 @@
+SCC = This is a Source Code Control file
+
+[goblib.vcproj]
+SCC_Aux_Path = "\\ravendata1\vss\central_code"
+SCC_Project_Name = "$/jedi/codemp/goblib", FBIAAAAA
diff --git a/codemp/goblib/vssver.scc b/codemp/goblib/vssver.scc
new file mode 100644
index 0000000..41e0b88
Binary files /dev/null and b/codemp/goblib/vssver.scc differ
diff --git a/codemp/icarus/BlockStream.cpp b/codemp/icarus/BlockStream.cpp
new file mode 100644
index 0000000..a0c9495
--- /dev/null
+++ b/codemp/icarus/BlockStream.cpp
@@ -0,0 +1,698 @@
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+// Interpreted Block Stream Functions
+//
+//	-- jweier
+
+// this include must remain at the top of every Icarus CPP file
+#include "icarus.h"
+
+
+#pragma warning(disable : 4100)  //unref formal parm
+#pragma warning(disable : 4710)  //member not inlined
+
+#include <string.h>
+#include "blockstream.h"
+
+/*
+===================================================================================================
+
+  CBlockMember
+
+===================================================================================================
+*/
+
+CBlockMember::CBlockMember( void )
+{
+	m_id = -1;
+	m_size = -1;
+	m_data = NULL;
+}
+
+CBlockMember::~CBlockMember( void )
+{
+	Free();
+}
+
+/*
+-------------------------
+Free
+-------------------------
+*/
+
+void CBlockMember::Free( void )
+{
+	if ( m_data != NULL )
+	{
+		ICARUS_Free ( m_data );
+		m_data = NULL;
+
+		m_id = m_size = -1;
+	}
+}
+
+/*
+-------------------------
+GetInfo
+-------------------------
+*/
+
+void CBlockMember::GetInfo( int *id, int *size, void **data )
+{	
+	*id = m_id;
+	*size = m_size;
+	*data = m_data;
+}
+
+/*
+-------------------------
+SetData overloads
+-------------------------
+*/
+
+void CBlockMember::SetData( const char *data )
+{
+	WriteDataPointer( data, strlen(data)+1 );
+}
+
+void CBlockMember::SetData( vector_t data )
+{
+	WriteDataPointer( data, 3 );
+}
+
+void CBlockMember::SetData( void *data, int size )
+{
+	if ( m_data )
+		ICARUS_Free( m_data );
+
+	m_data = ICARUS_Malloc( size );
+	memcpy( m_data, data, size );
+	m_size = size;
+}
+
+//	Member I/O functions
+
+/*
+-------------------------
+ReadMember
+-------------------------
+*/
+
+int CBlockMember::ReadMember( char **stream, long *streamPos )
+{
+	m_id = *(int *) (*stream + *streamPos);
+	*streamPos += sizeof( int );
+
+	if ( m_id == ID_RANDOM )
+	{//special case, need to initialize this member's data to Q3_INFINITE so we can randomize the number only the first time random is checked when inside a wait
+		m_size = sizeof( float );
+		*streamPos += sizeof( long );
+		m_data = ICARUS_Malloc( m_size );
+		float infinite = Q3_INFINITE;
+		memcpy( m_data, &infinite, m_size );
+	}
+	else
+	{
+		m_size = *(long *) (*stream + *streamPos);
+		*streamPos += sizeof( long );
+		m_data = ICARUS_Malloc( m_size );
+		memcpy( m_data, (*stream + *streamPos), m_size );
+	}
+	*streamPos += m_size;
+	
+	return true;
+}
+
+/*
+-------------------------
+WriteMember
+-------------------------
+*/
+
+int CBlockMember::WriteMember( FILE *m_fileHandle )
+{
+	fwrite( &m_id, sizeof(m_id), 1, m_fileHandle );
+	fwrite( &m_size, sizeof(m_size), 1, m_fileHandle );
+	fwrite( m_data, m_size, 1, m_fileHandle );
+
+	return true;
+}
+
+/*
+-------------------------
+Duplicate
+-------------------------
+*/
+
+CBlockMember *CBlockMember::Duplicate( void )
+{
+	CBlockMember	*newblock = new CBlockMember;
+
+	if ( newblock == NULL )
+		return NULL;
+
+	newblock->SetData( m_data, m_size );
+	newblock->SetSize( m_size );
+	newblock->SetID( m_id );
+
+	return newblock;
+}
+
+/*
+===================================================================================================
+
+  CBlock
+
+===================================================================================================
+*/
+
+CBlock::CBlock( void )
+{
+	m_flags			= 0;
+	m_id			= 0;
+}
+
+CBlock::~CBlock( void )
+{
+	Free();
+}
+
+/*
+-------------------------
+Init
+-------------------------
+*/
+
+int CBlock::Init( void )
+{
+	m_flags			= 0;
+	m_id			= 0;
+
+	return true;
+}
+
+/*
+-------------------------
+Create
+-------------------------
+*/
+
+int CBlock::Create( int block_id )
+{
+	Init();
+
+	m_id = block_id;
+
+	return true;
+}
+
+/*
+-------------------------
+Free
+-------------------------
+*/
+
+int CBlock::Free( void )
+{
+	int	numMembers = GetNumMembers();
+	CBlockMember	*bMember;
+
+	while ( numMembers-- )
+	{
+		bMember = GetMember( numMembers );
+
+		if (!bMember)
+			return false;
+
+		delete bMember;
+	}
+
+	m_members.clear();			//List of all CBlockMembers owned by this list
+
+	return true;
+}
+
+//	Write overloads
+
+/*
+-------------------------
+Write
+-------------------------
+*/
+
+int CBlock::Write( int member_id, const char *member_data )
+{
+	CBlockMember *bMember = new CBlockMember;
+
+	bMember->SetID( member_id );
+	
+	bMember->SetData( member_data );
+	bMember->SetSize( strlen(member_data) + 1 );
+
+	AddMember( bMember );
+
+	return true;
+}
+
+int CBlock::Write( int member_id, vector_t member_data )
+{
+	CBlockMember *bMember; 
+
+	bMember = new CBlockMember;
+
+	bMember->SetID( member_id );
+	bMember->SetData( member_data );
+	bMember->SetSize( sizeof(vector_t) );
+
+	AddMember( bMember );
+
+	return true;
+}
+
+int CBlock::Write( int member_id, float member_data )
+{
+	CBlockMember *bMember = new CBlockMember;
+
+	bMember->SetID( member_id );
+	bMember->WriteData( member_data );
+	bMember->SetSize( sizeof(member_data) );
+
+	AddMember( bMember );
+
+	return true;
+}
+
+int CBlock::Write( int member_id, int member_data )
+{
+	CBlockMember *bMember = new CBlockMember;
+
+	bMember->SetID( member_id );
+	bMember->WriteData( member_data );
+	bMember->SetSize( sizeof(member_data) );
+
+	AddMember( bMember );
+
+	return true;
+}
+
+
+int CBlock::Write( CBlockMember *bMember )
+{
+// findme: this is wrong:	bMember->SetSize( sizeof(bMember->GetData()) );
+	
+	AddMember( bMember );
+
+	return true;
+}
+
+// Member list functions
+
+/*
+-------------------------
+AddMember
+-------------------------
+*/
+
+int	CBlock::AddMember( CBlockMember *member )
+{
+	m_members.insert( m_members.end(), member );
+	return true;
+}
+
+/*
+-------------------------
+GetMember
+-------------------------
+*/
+
+CBlockMember *CBlock::GetMember( int memberNum )
+{
+	if ( memberNum > GetNumMembers()-1 )
+	{
+		return false;
+	}
+	return m_members[ memberNum ];
+}
+
+/*
+-------------------------
+GetMemberData
+-------------------------
+*/
+
+void *CBlock::GetMemberData( int memberNum )
+{
+	if ( memberNum > GetNumMembers()-1 )
+	{
+		return NULL;
+	}
+	return (void *) ((GetMember( memberNum ))->GetData());
+}
+
+/*
+-------------------------
+Duplicate
+-------------------------
+*/
+
+CBlock *CBlock::Duplicate( void )
+{
+	blockMember_v::iterator	mi;
+	CBlock					*newblock;
+
+	newblock = new CBlock;
+
+	if ( newblock == NULL )
+		return false;
+
+	newblock->Create( m_id );
+
+	//Duplicate entire block and return the cc
+	for ( mi = m_members.begin(); mi != m_members.end(); mi++ )
+	{
+		newblock->AddMember( (*mi)->Duplicate() );
+	}
+
+	return newblock;
+}
+
+/*
+===================================================================================================
+
+  CBlockStream
+
+===================================================================================================
+*/
+
+CBlockStream::CBlockStream( void )
+{
+	m_stream = NULL;
+	m_streamPos = 0;
+}
+
+CBlockStream::~CBlockStream( void )
+{
+}
+
+/*
+-------------------------
+GetChar
+-------------------------
+*/
+
+char CBlockStream::GetChar( void )
+{
+	char data;
+
+	data = *(char*) (m_stream + m_streamPos);
+	m_streamPos += sizeof( data );
+
+	return data;
+}
+
+/*
+-------------------------
+GetUnsignedInteger
+-------------------------
+*/
+
+unsigned CBlockStream::GetUnsignedInteger( void )
+{
+	unsigned data;
+
+	data = *(unsigned *) (m_stream + m_streamPos);
+	m_streamPos += sizeof( data );
+
+	return data;
+}
+
+/*
+-------------------------
+GetInteger
+-------------------------
+*/
+
+int	CBlockStream::GetInteger( void )
+{
+	int data;
+
+	data = *(int *) (m_stream + m_streamPos);
+	m_streamPos += sizeof( data );
+
+	return data;
+}
+
+/*
+-------------------------
+GetLong
+-------------------------
+*/
+
+long CBlockStream::GetLong( void )
+{
+	long data;
+
+	data = *(long *) (m_stream + m_streamPos);
+	m_streamPos += sizeof( data );
+
+	return data;
+}
+
+/*
+-------------------------
+GetFloat
+-------------------------
+*/
+
+float CBlockStream::GetFloat( void )
+{
+	float data;
+
+	data = *(float *) (m_stream + m_streamPos);
+	m_streamPos += sizeof( data );
+
+	return data;
+}
+
+//	Extension stripping utility
+
+/*
+-------------------------
+StripExtension
+-------------------------
+*/
+
+void CBlockStream::StripExtension( const char *in, char *out )
+{
+	int		i = strlen(in);
+	
+	while ( (in[i] != '.') && (i >= 0) )
+	 i--;
+
+	if ( i < 0 )
+	{
+		strcpy(out, in);
+		return;
+	}
+
+	strncpy(out, in, i);
+}
+
+/*
+-------------------------
+Free
+-------------------------
+*/
+
+int CBlockStream::Free( void )
+{
+	//NOTENOTE: It is assumed that the user will free the passed memory block (m_stream) immediately after the run call
+	//			That's why this doesn't free the memory, it only clears its internal pointer
+
+	m_stream = NULL;
+	m_streamPos = 0;
+
+	return true;
+}
+
+/*
+-------------------------
+Create
+-------------------------
+*/
+
+int CBlockStream::Create( char *filename )
+{
+	char	newName[MAX_FILENAME_LENGTH], *id_header = IBI_HEADER_ID;
+	float	version = IBI_VERSION;
+	
+	//Clear the temp string
+	memset(newName, 0, sizeof(newName));
+
+	//Strip the extension and add the BLOCK_EXT extension
+	strcpy((char *) m_fileName, filename);
+	StripExtension( (char *) m_fileName, (char *) &newName );
+	strcat((char *) newName, IBI_EXT);
+
+	//Recover that as the active filename
+	strcpy(m_fileName, newName);
+
+	if ( ((m_fileHandle = fopen(m_fileName, "wb")) == NULL) )
+	{
+		return false;
+	}
+
+	fwrite( id_header, 1, sizeof(id_header), m_fileHandle );
+	fwrite( &version, 1, sizeof(version), m_fileHandle );
+
+	return true;
+}
+
+/*
+-------------------------
+Init
+-------------------------
+*/
+
+int CBlockStream::Init( void )
+{
+	m_fileHandle = NULL;
+	memset(m_fileName, 0, sizeof(m_fileName));
+
+	m_stream = NULL;
+	m_streamPos = 0;
+
+	return true;
+}
+
+//	Block I/O functions
+
+/*
+-------------------------
+WriteBlock
+-------------------------
+*/
+
+int CBlockStream::WriteBlock( CBlock *block )
+{
+	CBlockMember	*bMember;
+	int				id = block->GetBlockID();
+	int				numMembers = block->GetNumMembers();
+	unsigned char	flags = block->GetFlags();
+
+	fwrite ( &id, sizeof(id), 1, m_fileHandle ); 
+	fwrite ( &numMembers, sizeof(numMembers), 1, m_fileHandle );
+	fwrite ( &flags, sizeof( flags ), 1, m_fileHandle );
+
+	for ( int i = 0; i < numMembers; i++ )
+	{	
+		bMember = block->GetMember( i );
+		bMember->WriteMember( m_fileHandle );
+	}
+
+	block->Free();
+
+	return true;
+}
+
+/*
+-------------------------
+BlockAvailable
+-------------------------
+*/
+
+int CBlockStream::BlockAvailable( void )
+{
+	if ( m_streamPos >= m_fileSize )
+		return false;
+
+	return true;
+}
+
+/*
+-------------------------
+ReadBlock
+-------------------------
+*/
+
+int CBlockStream::ReadBlock( CBlock *get )
+{
+	CBlockMember	*bMember;
+	int				b_id, numMembers;
+	unsigned char	flags;
+
+	if (!BlockAvailable())
+		return false;
+
+	b_id		= GetInteger();
+	numMembers	= GetInteger();
+	flags		= (unsigned char) GetChar();
+
+	if (numMembers < 0)
+		return false;
+
+	get->Create( b_id );
+	get->SetFlags( flags );
+
+	// Stream blocks are generally temporary as they
+	// are just used in an initial parsing phase...
+#ifdef _XBOX
+	extern void Z_SetNewDeleteTemporary(bool bTemp);
+	Z_SetNewDeleteTemporary(true);
+#endif
+
+	while ( numMembers-- > 0)
+	{	
+		bMember = new CBlockMember;
+		bMember->ReadMember( &m_stream, &m_streamPos );
+		get->AddMember( bMember );
+	}
+
+#ifdef _XBOX
+	Z_SetNewDeleteTemporary(false);
+#endif
+
+	return true;
+}
+
+/*
+-------------------------
+Open
+-------------------------
+*/
+
+int CBlockStream::Open( char *buffer, long size )
+{
+	char	id_header[sizeof(IBI_HEADER_ID)];
+	float	version;
+	
+	Init();
+
+	m_fileSize = size;
+
+	m_stream = buffer;
+
+	for ( int i = 0; i < sizeof( id_header ); i++ )
+	{
+		id_header[i] = GetChar();
+	}
+
+	version = GetFloat();
+
+	//Check for valid header
+	if ( strcmp( id_header, IBI_HEADER_ID ) )
+	{
+		Free();
+		return false;
+	}
+
+	//Check for valid version
+	if ( version != IBI_VERSION )
+	{
+		Free();
+		return false;
+	}
+
+	return true;
+}
diff --git a/codemp/icarus/GameInterface.cpp b/codemp/icarus/GameInterface.cpp
new file mode 100644
index 0000000..c085cd9
--- /dev/null
+++ b/codemp/icarus/GameInterface.cpp
@@ -0,0 +1,733 @@
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+// ICARUS Utility functions
+//rww - mangled to work in server exe setting.
+
+//#include "Q3_Interface.h"
+//#include "g_roff.h"
+#include "../game/g_public.h"
+#include "../server/server.h"
+#include "interface.h"
+#include "GameInterface.h"
+#include "../qcommon/RoffSystem.h"
+#include "Q3_Interface.h"
+
+ICARUS_Instance		*iICARUS;
+bufferlist_t		ICARUS_BufferList;
+entlist_t			ICARUS_EntList;
+
+extern unsigned Com_BlockChecksum (const void *buffer, int length);
+extern	void	Q3_DebugPrint( int level, const char *format, ... );
+
+int			ICARUS_entFilter = -1;
+
+/*
+=============
+ICARUS_GetScript
+
+gets the named script from the cache or disk if not already loaded
+=============
+*/
+
+int ICARUS_GetScript( const char *name, char **buf )
+{
+	bufferlist_t::iterator		ei;
+	//Make sure the caller is valid
+
+	//Attempt to retrieve a precached script
+	ei = ICARUS_BufferList.find( (char *) name );
+
+	//Not found, check the disk
+	if ( ei == ICARUS_BufferList.end() )
+	{
+		if ( ICARUS_RegisterScript( name ) == false )
+			return 0;
+
+		//Script is now inserted, retrieve it and pass through
+		ei = ICARUS_BufferList.find( (char *) name );
+
+		if ( ei == ICARUS_BufferList.end() )
+		{
+			//NOTENOTE: This is an internal error in STL if this happens...
+			assert(0);
+			return 0;
+		}
+	}
+
+	*buf = (*ei).second->buffer;
+	return (*ei).second->length;
+}
+
+/*
+=============
+ICARUS_RunScript
+
+Runs the script by the given name
+=============
+*/
+int ICARUS_RunScript( sharedEntity_t *ent, const char *name )
+{
+	char *buf;
+	int len;
+
+	//Make sure the caller is valid
+	if ( gSequencers[ent->s.number] == NULL )
+	{
+		//Com_Printf( "%s : entity is not a valid script user\n", ent->classname );
+		return false;
+	}
+#ifdef _HACK_FOR_TESTING_ONLY_1
+	char namex[1024];
+	char *blah = strstr(name, "stu/");
+	int r = blah - name;
+	if (blah)
+	{
+		int i = 0;
+		while (i < r)
+		{
+			namex[i] = name[i];
+			i++;
+		}
+		namex[i] = 0;
+		strcat(namex, "ignorethisfolder/");
+		i = strlen(namex);
+		while (name[r] != '/')
+		{
+			r++;
+		}
+		r++;
+
+		while (name[r])
+		{
+			namex[i] = name[r];
+			r++;
+			i++;
+		}
+		namex[i] = 0;
+	}
+	else
+	{
+		strcpy(namex, name);
+	}
+
+	len = ICARUS_GetScript (namex,  &buf);
+#else
+	len = ICARUS_GetScript (name,  &buf);
+#endif
+	if (len == 0)
+	{
+		return false;
+	}
+
+	//Attempt to run the script
+	if S_FAILED(gSequencers[ent->s.number]->Run( buf, len ))
+		return false;
+
+	if ( ( ICARUS_entFilter == -1 ) || ( ICARUS_entFilter == ent->s.number ) )
+	{
+		Q3_DebugPrint( WL_VERBOSE, "%d Script %s executed by %s %s\n", svs.time, (char *) name, ent->classname, ent->targetname );
+	}
+
+	return true;
+}
+
+/*
+=================
+ICARUS_Init
+
+Allocates a new ICARUS instance
+=================
+*/
+
+void ICARUS_Init( void )
+{
+	//Link all interface functions
+	Interface_Init( &interface_export );
+
+	//Create the ICARUS instance for this session
+	iICARUS = ICARUS_Instance::Create( &interface_export );
+
+	if ( iICARUS == NULL )
+	{
+		Com_Error( ERR_DROP, "Unable to initialize ICARUS instance\n" );
+		return;
+	}
+}
+
+/*
+=================
+ICARUS_Shutdown
+
+Frees up ICARUS resources from all entities
+=================
+*/
+
+void ICARUS_Shutdown( void )
+{
+	bufferlist_t::iterator	ei;
+	sharedEntity_t				*ent = SV_GentityNum(0);
+
+	//Release all ICARUS resources from the entities
+	for ( int i = 0; i < /*globals.num_entities*/MAX_GENTITIES; i++ ) 
+	{
+		ent = SV_GentityNum(i);
+		
+		if (gSequencers[i])
+		{
+			if (ent->s.number >= MAX_GENTITIES ||
+				ent->s.number < 0)
+			{
+				ent->s.number = i;
+				assert(0);
+			}
+			ICARUS_FreeEnt( ent );
+		}
+	}
+
+	//Clear out all precached scripts
+	for ( ei = ICARUS_BufferList.begin(); ei != ICARUS_BufferList.end(); ei++ )
+	{
+		//gi.Free( (*ei).second->buffer );
+		ICARUS_Free((*ei).second->buffer);
+		delete (*ei).second;
+	}
+
+	ICARUS_BufferList.clear();
+
+	//Clear the name map
+	ICARUS_EntList.clear();
+
+	//Free this instance
+	if ( iICARUS )
+	{
+		iICARUS->Delete();
+		iICARUS = NULL;
+	}
+}
+
+/*
+==============
+ICARUS_FreeEnt
+
+Frees all ICARUS resources on an entity
+
+WARNING!!! DO NOT DO THIS WHILE RUNNING A SCRIPT, ICARUS WILL CRASH!!!
+FIXME: shouldn't ICARUS handle this internally?
+
+==============
+*/
+void ICARUS_FreeEnt( sharedEntity_t *ent )
+{
+	assert( iICARUS );
+
+	if (ent->s.number >= MAX_GENTITIES ||
+		ent->s.number < 0)
+	{
+		assert(0);
+		return;
+	}
+
+	//Make sure the ent is valid
+	if ( gSequencers[ent->s.number] == NULL )
+		return;
+
+	//Remove them from the ICARUSE_EntList list so that when their g_entity index is reused, ICARUS doesn't try to affect the new (incorrect) ent.
+	if VALIDSTRING( ent->script_targetname )
+	{
+		char	temp[1024];
+		
+		strncpy( (char *) temp, ent->script_targetname, 1023 );
+		temp[ 1023 ] = 0;
+
+		entlist_t::iterator it = ICARUS_EntList.find( Q_strupr(temp) );
+
+		if (it != ICARUS_EntList.end())
+		{
+			ICARUS_EntList.erase(it);
+		}
+	}
+
+	//Delete the sequencer and the task manager
+	iICARUS->DeleteSequencer( gSequencers[ent->s.number] );
+	
+	//Clean up the pointers
+	gSequencers[ent->s.number]		= NULL;
+	gTaskManagers[ent->s.number]	= NULL;
+}
+
+
+/*
+==============
+ICARUS_ValidEnt
+
+Determines whether or not an entity needs ICARUS information  
+==============
+*/
+
+bool ICARUS_ValidEnt( sharedEntity_t *ent )
+{
+	int i;
+
+	//Targeted by a script
+	if VALIDSTRING( ent->script_targetname )
+		return true;
+
+	//Potentially able to call a script
+	for ( i = 0; i < NUM_BSETS; i++ )
+	{
+		if VALIDSTRING( ent->behaviorSet[i] )
+		{
+			//Com_Printf( "WARNING: Entity %d (%s) has behaviorSet but no script_targetname -- using targetname\n", ent->s.number, ent->targetname );
+
+			//ent->script_targetname = ent->targetname;
+			//rww - You CANNOT do things like this now. We're switching memory around to be able to read this memory from vm land,
+			//and while this allows us to read it on our "fake" entity here, we can't modify pointers like this. We can however do
+			//something completely hackish such as the following.
+			assert(ent->s.number >= 0 && ent->s.number < MAX_GENTITIES);
+			sharedEntity_t *trueEntity = SV_GentityNum(ent->s.number);
+			//This works because we're modifying the actual shared game vm data and turning one pointer into another.
+			//While these pointers both look like garbage to us in here, they are not.
+			trueEntity->script_targetname = trueEntity->targetname;
+			return true;
+		}
+	}
+
+	return false;
+}
+
+/*
+==============
+ICARUS_AssociateEnt
+
+Associate the entity's id and name so that it can be referenced later
+==============
+*/
+
+void ICARUS_AssociateEnt( sharedEntity_t *ent )
+{
+	char	temp[1024];
+	
+	if ( VALIDSTRING( ent->script_targetname ) == false )
+		return;
+
+	strncpy( (char *) temp, ent->script_targetname, 1023 );
+	temp[ 1023 ] = 0;
+
+	ICARUS_EntList[ Q_strupr( (char *) temp ) ] = ent->s.number;
+}
+
+/*
+==============
+ICARUS_RegisterScript
+
+Loads and caches a script
+==============
+*/
+
+bool ICARUS_RegisterScript( const char *name, qboolean bCalledDuringInterrogate /* = false */ )
+{
+	bufferlist_t::iterator	ei;
+	pscript_t	*pscript;
+	char		newname[MAX_FILENAME_LENGTH];
+	char		*buffer = NULL;	// lose compiler warning about uninitialised vars
+	long		length;
+
+	//Make sure this isn't already cached
+	ei = ICARUS_BufferList.find( (char *) name );
+
+	// note special return condition here, if doing interrogate and we already have this file then we MUST return
+	//	false (which stops the interrogator proceeding), this not only saves some time, but stops a potential
+	//	script recursion bug which could lock the program in an infinite loop...   Return TRUE for normal though!
+	//
+	if ( ei != ICARUS_BufferList.end() )
+		return (bCalledDuringInterrogate)?false:true;
+	
+	sprintf((char *) newname, "%s%s", name, IBI_EXT );	
+
+
+	// small update here, if called during interrogate, don't let gi.FS_ReadFile() complain because it can't
+	//	find stuff like BS_RUN_AND_SHOOT as scriptname...   During FINALBUILD the message won't appear anyway, hence
+	//	the ifndef, this just cuts down on internal error reports while testing release mode...
+	//
+	qboolean qbIgnoreFileRead = qfalse;
+	// 
+	// NOTENOTE: For the moment I've taken this back out, to avoid doubling the number of fopen()'s per file.
+#if 0//#ifndef FINAL_BUILD		
+	if (bCalledDuringInterrogate)
+	{
+		fileHandle_t file;
+
+		gi.FS_FOpenFile( newname, &file, FS_READ );
+		
+		if ( file == NULL )
+		{
+			qbIgnoreFileRead = qtrue;	// warn disk code further down not to try FS_ReadFile()
+		}
+		else
+		{
+			gi.FS_FCloseFile( file );
+		}
+	}
+#endif
+
+	length = qbIgnoreFileRead ? -1 : FS_ReadFile( newname, (void **) &buffer );
+
+	if ( length <= 0 )
+	{
+		// File not found, but keep quiet during interrogate stage, because of stuff like BS_RUN_AND_SHOOT as scriptname
+		//
+		if (!bCalledDuringInterrogate)	
+		{
+			Com_Printf(S_COLOR_RED"Could not open file '%s'\n", newname );
+		}
+		return false;
+	}
+
+	pscript = new pscript_t;
+
+	pscript->buffer = (char *) ICARUS_Malloc(length);//gi.Malloc(length, TAG_ICARUS, qfalse); 
+	memcpy (pscript->buffer, buffer, length);
+	pscript->length = length;
+
+	FS_FreeFile( buffer );
+
+	ICARUS_BufferList[ name ] = pscript;
+
+	return true;
+}
+
+void ICARUS_SoundPrecache(const char *filename)
+{
+	T_G_ICARUS_SOUNDINDEX *sharedMem = (T_G_ICARUS_SOUNDINDEX *)sv.mSharedMemory;
+
+	strcpy(sharedMem->filename, filename);
+
+	VM_Call(gvm, GAME_ICARUS_SOUNDINDEX);	
+}
+
+int ICARUS_GetIDForString( const char *string )
+{
+	T_G_ICARUS_GETSETIDFORSTRING *sharedMem = (T_G_ICARUS_GETSETIDFORSTRING *)sv.mSharedMemory;
+
+	strcpy(sharedMem->string, string);
+
+	return VM_Call(gvm, GAME_ICARUS_GETSETIDFORSTRING);
+}
+
+/*
+-------------------------
+ICARUS_InterrogateScript
+-------------------------
+*/
+
+// at this point the filename should have had the "scripts" (Q3_SCRIPT_DIR) added to it (but not the IBI extension)
+//
+void ICARUS_InterrogateScript( const char *filename )
+{
+	CBlockStream	stream;
+	CBlockMember	*blockMember;
+	CBlock			block;
+
+	if (!Q_stricmp(filename,"NULL") || !Q_stricmp(filename,"default"))
+		return;
+
+	//////////////////////////////////
+	//
+	// ensure "scripts" (Q3_SCRIPT_DIR), which will be missing if this was called recursively...
+	//
+	char sFilename[MAX_FILENAME_LENGTH];	// should really be MAX_QPATH (and 64 bytes instead of 1024), but this fits the rest of the code
+
+	if (!Q_stricmpn(filename,Q3_SCRIPT_DIR,strlen(Q3_SCRIPT_DIR)))
+	{
+		Q_strncpyz(sFilename,filename,sizeof(sFilename));
+	}
+	else
+	{
+		Q_strncpyz(sFilename,va("%s/%s",Q3_SCRIPT_DIR,filename),sizeof(sFilename));
+	}
+	//
+	//////////////////////////////////
+
+
+	//Attempt to register this script
+	if ( ICARUS_RegisterScript( sFilename, qtrue ) == false )	// true = bCalledDuringInterrogate
+		return;
+
+	char	*buf;
+	long	len;
+
+	//Attempt to retrieve the new script data
+	if ( ( len = ICARUS_GetScript ( sFilename,  &buf ) ) == 0 )
+		return;
+
+	//Open the stream
+	if ( stream.Open( buf, len ) == qfalse )
+		return;
+
+	const char	*sVal1, *sVal2;
+	char		temp[1024];
+	int			setID;
+
+	//Now iterate through all blocks of the script, searching for keywords
+	while ( stream.BlockAvailable() )
+	{
+		//Get a block
+		if ( stream.ReadBlock( &block ) == qfalse )
+			return;
+
+		//Determine what type of block this is
+		switch( block.GetBlockID() )
+		{
+		case ID_CAMERA:	// to cache ROFF files
+			{
+				float f = *(float *) block.GetMemberData( 0 );
+
+				if (f == TYPE_PATH)
+				{
+					sVal1 = (const char *) block.GetMemberData( 1 );
+
+					//we can do this I guess since the roff is loaded on the server.
+					theROFFSystem.Cache((char *)sVal1, qfalse);
+				}
+			}
+			break;
+
+		case ID_PLAY:	// to cache ROFF files
+			
+			sVal1 = (const char *) block.GetMemberData( 0 );
+
+			if (!Q_stricmp(sVal1,"PLAY_ROFF"))
+			{
+				sVal1 = (const char *) block.GetMemberData( 1 );
+
+				//we can do this I guess since the roff is loaded on the server.
+				theROFFSystem.Cache((char *)sVal1, qfalse);
+			}			
+			break;
+
+		//Run commands
+		case ID_RUN:
+			
+			sVal1 = (const char *) block.GetMemberData( 0 );
+			
+			COM_StripExtension( sVal1, (char *) temp );
+			ICARUS_InterrogateScript( (const char *) &temp );
+			
+			break;
+		
+		case ID_SOUND:
+			//We can't just call over to S_RegisterSound or whatever because this is on the server.
+			sVal1 = (const char *) block.GetMemberData( 1 );	//0 is channel, 1 is filename
+			ICARUS_SoundPrecache(sVal1);
+			break;
+
+		case ID_SET:
+			blockMember = block.GetMember( 0 );
+
+			//NOTENOTE: This will not catch special case get() inlines! (There's not really a good way to do that)
+
+			//Make sure we're testing against strings
+			if ( blockMember->GetID() == TK_STRING )
+			{
+				sVal1 = (const char *) block.GetMemberData( 0 );
+				sVal2 = (const char *) block.GetMemberData( 1 );
+		
+				//Get the id for this set identifier
+				setID = ICARUS_GetIDForString( sVal1 );
+
+				//Check against valid types
+				switch ( setID )
+				{
+				case SET_SPAWNSCRIPT:
+				case SET_USESCRIPT:
+				case SET_AWAKESCRIPT:
+				case SET_ANGERSCRIPT:
+				case SET_ATTACKSCRIPT:
+				case SET_VICTORYSCRIPT:
+				case SET_LOSTENEMYSCRIPT:
+				case SET_PAINSCRIPT:
+				case SET_FLEESCRIPT:
+				case SET_DEATHSCRIPT:
+				case SET_DELAYEDSCRIPT:
+				case SET_BLOCKEDSCRIPT:
+				case SET_FFIRESCRIPT:
+				case SET_FFDEATHSCRIPT:
+				case SET_MINDTRICKSCRIPT:
+				case SET_CINEMATIC_SKIPSCRIPT:
+					//Recursively obtain all embedded scripts
+					ICARUS_InterrogateScript( sVal2 );
+					break;
+				case SET_LOOPSOUND:		//like ID_SOUND, but set's looping
+					ICARUS_SoundPrecache(sVal2);
+					break;
+				case SET_VIDEO_PLAY:	//in game cinematic
+					//do nothing for MP.
+					break;
+				case SET_ADDRHANDBOLT_MODEL:
+				case SET_ADDLHANDBOLT_MODEL:
+					//do nothing for MP
+					break;
+				default:
+					break;
+				}
+			}
+			break;
+
+		default:
+			break;
+		}
+
+		//Clean out the block for the next pass
+		block.Free();
+	}
+
+	//All done
+	stream.Free();
+}
+
+#ifdef _XBOX	// We borrow the one in NPC_stats.c
+extern stringID_table_t BSTable[];
+#else
+stringID_table_t BSTable[] =
+{
+	ENUM2STRING(BS_DEFAULT),//# default behavior for that NPC
+	ENUM2STRING(BS_ADVANCE_FIGHT),//# Advance to captureGoal and shoot enemies if you can
+	ENUM2STRING(BS_SLEEP),//# Play awake script when startled by sound
+	ENUM2STRING(BS_FOLLOW_LEADER),//# Follow your leader and shoot any enemies you come across
+	ENUM2STRING(BS_JUMP),//# Face navgoal and jump to it.
+	ENUM2STRING(BS_SEARCH),//# Using current waypoint as a base), search the immediate branches of waypoints for enemies
+	ENUM2STRING(BS_WANDER),//# Wander down random waypoint paths
+	ENUM2STRING(BS_NOCLIP),//# Moves through walls), etc.
+	ENUM2STRING(BS_REMOVE),//# Waits for player to leave PVS then removes itself
+	ENUM2STRING(BS_CINEMATIC),//# Does nothing but face it's angles and move to a goal if it has one
+	//the rest are internal only
+	"",				-1,
+};
+#endif
+
+/*
+==============
+ICARUS_PrecacheEnt
+
+Precache all scripts being used by the entity
+==============
+*/
+
+void ICARUS_PrecacheEnt( sharedEntity_t *ent )
+{
+	char	newname[MAX_FILENAME_LENGTH];
+	int		i;
+
+	for ( i = 0; i < NUM_BSETS; i++ )
+	{
+		if ( ent->behaviorSet[i] == NULL )
+			continue;
+
+		if ( GetIDForString( BSTable, ent->behaviorSet[i] ) == -1 )
+		{//not a behavior set
+			sprintf((char *) newname, "%s/%s", Q3_SCRIPT_DIR, ent->behaviorSet[i] );
+
+			//Precache this, and all internally referenced scripts
+			ICARUS_InterrogateScript( newname );
+		}
+	}
+}
+
+/*
+==============
+ICARUS_InitEnt
+
+Allocates a sequencer and task manager only if an entity is a potential script user
+==============
+*/
+
+void Q3_TaskIDClear( int *taskID );
+void ICARUS_InitEnt( sharedEntity_t *ent )
+{
+	//Make sure this is a fresh ent
+	assert( iICARUS );
+	assert( gTaskManagers[ent->s.number] == NULL );
+	assert( gSequencers[ent->s.number] == NULL );
+
+	if ( gSequencers[ent->s.number] != NULL )
+		return;
+
+	if ( gTaskManagers[ent->s.number] != NULL )
+		return;
+
+	//Create the sequencer and setup the task manager
+	gSequencers[ent->s.number]		= iICARUS->GetSequencer( ent->s.number );
+	gTaskManagers[ent->s.number]	= gSequencers[ent->s.number]->GetTaskManager();
+
+	//Initialize all taskIDs to -1
+	memset( &ent->taskID, -1, sizeof( ent->taskID ) );
+
+	//Add this entity to a map of valid associated ents for quick retrieval later
+	ICARUS_AssociateEnt( ent );
+
+	//Precache all the entity's scripts
+	ICARUS_PrecacheEnt( ent );
+}
+
+/*
+-------------------------
+ICARUS_LinkEntity
+-------------------------
+*/
+
+int ICARUS_LinkEntity( int entID, CSequencer *sequencer, CTaskManager *taskManager )
+{
+	sharedEntity_t	*ent = SV_GentityNum(entID);
+
+	if ( ent == NULL )
+		return false;
+
+	gSequencers[ent->s.number] = sequencer;
+	gTaskManagers[ent->s.number] = taskManager;
+
+	ICARUS_AssociateEnt( ent );
+
+	return true;
+}
+
+/*
+-------------------------
+Svcmd_ICARUS_f
+-------------------------
+*/
+
+void Svcmd_ICARUS_f( void )
+{
+	//rwwFIXMEFIXME: Do something with this for debugging purposes at some point.
+	/*
+	char	*cmd = Cmd_Argv( 1 );
+
+	if ( Q_stricmp( cmd, "log" ) == 0 )
+	{
+		//g_ICARUSDebug->integer = WL_DEBUG;
+		if ( VALIDSTRING( Cmd_Argv( 2 ) ) )
+		{	
+			sharedEntity_t	*ent = G_Find( NULL, FOFS( script_targetname ), gi.argv(2) );
+
+			if ( ent == NULL )
+			{	
+				Com_Printf( "Entity \"%s\" not found!\n", gi.argv(2) );
+				return;
+			}
+
+			//Start logging
+			Com_Printf("Logging ICARUS info for entity %s\n", gi.argv(2) );
+
+			ICARUS_entFilter		= ( ent->s.number == ICARUS_entFilter ) ? -1 : ent->s.number;
+
+			return;
+		}
+	
+		Com_Printf("Logging ICARUS info for all entities\n");
+	
+		return;
+	}
+	*/
+	return;
+}
diff --git a/codemp/icarus/GameInterface.h b/codemp/icarus/GameInterface.h
new file mode 100644
index 0000000..5b63e49
--- /dev/null
+++ b/codemp/icarus/GameInterface.h
@@ -0,0 +1,36 @@
+#ifndef __G_ICARUS_H__
+#define __G_ICARUS_H__
+
+typedef struct pscript_s
+{
+	char	*buffer;
+	long	length;
+} pscript_t;
+
+typedef	map < string, int, less<string>, allocator<int> >		entlist_t;
+typedef map < string, pscript_t*, less<string>, allocator<pscript_t*> >	bufferlist_t;
+
+//ICARUS includes
+extern	interface_export_t	interface_export;
+
+extern	void Interface_Init( interface_export_t *pe );
+extern	int ICARUS_RunScript( sharedEntity_t *ent, const char *name );
+extern	bool ICARUS_RegisterScript( const char *name, qboolean bCalledDuringInterrogate = qfalse);
+extern ICARUS_Instance	*iICARUS;
+extern bufferlist_t		ICARUS_BufferList;
+extern entlist_t		ICARUS_EntList;
+
+//
+//	g_ICARUS.cpp
+//
+void ICARUS_Init( void );
+bool ICARUS_ValidEnt( sharedEntity_t *ent );
+void ICARUS_InitEnt( sharedEntity_t *ent );
+void ICARUS_FreeEnt( sharedEntity_t *ent );
+void ICARUS_AssociateEnt( sharedEntity_t *ent );
+void ICARUS_Shutdown( void );
+void Svcmd_ICARUS_f( void );
+
+extern int		ICARUS_entFilter;
+
+#endif//#ifndef __G_ICARUS_H__
diff --git a/codemp/icarus/Instance.cpp b/codemp/icarus/Instance.cpp
new file mode 100644
index 0000000..3a89f63
--- /dev/null
+++ b/codemp/icarus/Instance.cpp
@@ -0,0 +1,655 @@
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+// ICARUS Instance
+//
+//	-- jweier
+
+// this include must remain at the top of every Icarus CPP file
+#include "icarus.h"
+
+#include <assert.h>
+
+class CSequencer;
+class CTaskManager;
+
+//We can't put these on entity fields since all that stuff is in C
+//which can't be changed due to VMs. So we'll use a global array
+//and access by the entity index given.
+CSequencer		*gSequencers[MAX_GENTITIES];
+CTaskManager	*gTaskManagers[MAX_GENTITIES];
+
+// Instance
+
+ICARUS_Instance::ICARUS_Instance( void )
+{
+	m_GUID = 0;
+
+	//to be safe
+	memset(gSequencers,0, sizeof(gSequencers));
+	memset(gTaskManagers,0, sizeof(gTaskManagers));
+
+#ifdef _DEBUG
+
+	m_DEBUG_NumSequencerAlloc		= 0;
+	m_DEBUG_NumSequencerFreed		= 0;
+	m_DEBUG_NumSequencerResidual	= 0;
+
+	m_DEBUG_NumSequenceAlloc	= 0;
+	m_DEBUG_NumSequenceFreed	= 0;
+	m_DEBUG_NumSequenceResidual	= 0;
+
+#endif 
+
+}
+
+ICARUS_Instance::~ICARUS_Instance( void )
+{
+}
+
+/*
+-------------------------
+Create
+-------------------------
+*/
+
+ICARUS_Instance *ICARUS_Instance::Create( interface_export_t *ie )
+{
+	ICARUS_Instance *instance = new ICARUS_Instance;
+	instance->m_interface = ie;
+#ifndef __linux__
+	OutputDebugString( "ICARUS Instance successfully created\n" );
+#endif
+	return instance;
+}
+
+/*
+-------------------------
+Free
+-------------------------
+*/
+
+int ICARUS_Instance::Free( void )
+{
+	sequencer_l::iterator	sri;
+
+	//Delete any residual sequencers
+	STL_ITERATE( sri, m_sequencers )
+	{
+		delete (*sri);
+		
+#ifdef _DEBUG
+
+		m_DEBUG_NumSequencerResidual++;
+
+#endif
+
+	}
+
+	m_sequencers.clear();
+	//all these are deleted now so clear the global map.
+	memset(gSequencers,0, sizeof(gSequencers));
+	memset(gTaskManagers,0, sizeof(gTaskManagers));
+	m_signals.clear();
+
+	sequence_l::iterator	si;
+
+	//Delete any residual sequences
+	STL_ITERATE( si, m_sequences )
+	{
+		delete (*si);
+
+#ifdef _DEBUG
+
+		m_DEBUG_NumSequenceResidual++;
+
+#endif
+
+	}
+
+	m_sequences.clear();
+
+	return true;
+}
+
+/*
+-------------------------
+Delete
+-------------------------
+*/
+
+int ICARUS_Instance::Delete( void )
+{
+
+	Free();
+
+#ifdef _DEBUG
+	
+	char	buffer[1024];
+
+	OutputDebugString( "\nICARUS Instance Debug Info:\n---------------------------\n" );
+
+	sprintf( (char *) buffer, "Sequencers Allocated:\t%d\n", m_DEBUG_NumSequencerAlloc );
+	OutputDebugString( (const char *) &buffer );
+
+	sprintf( (char *) buffer, "Sequencers Freed:\t\t%d\n", m_DEBUG_NumSequencerFreed );
+	OutputDebugString( (const char *) &buffer );
+
+	sprintf( (char *) buffer, "Sequencers Residual:\t%d\n\n", m_DEBUG_NumSequencerResidual );
+	OutputDebugString( (const char *) &buffer );
+
+	sprintf( (char *) buffer, "Sequences Allocated:\t%d\n", m_DEBUG_NumSequenceAlloc );
+	OutputDebugString( (const char *) &buffer );
+
+	sprintf( (char *) buffer, "Sequences Freed:\t\t%d\n", m_DEBUG_NumSequenceFreed );
+	OutputDebugString( (const char *) &buffer );
+
+	sprintf( (char *) buffer, "Sequences Residual:\t\t%d\n\n", m_DEBUG_NumSequenceResidual );
+	OutputDebugString( (const char *) &buffer );
+
+	OutputDebugString( "\n" );
+
+#endif
+
+	delete this;
+
+	return true;
+}
+
+/*
+-------------------------
+GetSequencer
+-------------------------
+*/
+
+CSequencer *ICARUS_Instance::GetSequencer( int ownerID )
+{
+	CSequencer		*sequencer = CSequencer::Create();
+	CTaskManager	*taskManager = CTaskManager::Create();
+
+	sequencer->Init( ownerID, m_interface, taskManager, this );
+
+	taskManager->Init( sequencer );
+
+	STL_INSERT( m_sequencers, sequencer );
+
+#ifdef _DEBUG
+
+	m_DEBUG_NumSequencerAlloc++;
+
+#endif
+
+	return sequencer;
+}
+
+/*
+-------------------------
+DeleteSequencer
+-------------------------
+*/
+
+void ICARUS_Instance::DeleteSequencer( CSequencer *sequencer )
+{
+	// added 2/12/2 to properly delete blocks that were passed to the task manager
+	sequencer->Recall();
+
+	CTaskManager	*taskManager = sequencer->GetTaskManager();
+
+	if ( taskManager )
+	{
+		taskManager->Free();
+		delete taskManager;
+	}
+
+	m_sequencers.remove( sequencer );	
+
+	sequencer->Free();
+	delete sequencer;
+
+#ifdef _DEBUG
+
+	m_DEBUG_NumSequencerFreed++;
+
+#endif
+
+}
+
+/*
+-------------------------
+GetSequence
+-------------------------
+*/
+
+CSequence *ICARUS_Instance::GetSequence( void )
+{
+	CSequence	*sequence = CSequence::Create();
+
+	//Assign the GUID
+	sequence->SetID( m_GUID++ );
+	sequence->SetOwner( this );
+
+	STL_INSERT( m_sequences, sequence );
+
+#ifdef _DEBUG
+
+	m_DEBUG_NumSequenceAlloc++;
+
+#endif 
+
+	return sequence;
+}
+
+/*
+-------------------------
+GetSequence
+-------------------------
+*/
+
+CSequence *ICARUS_Instance::GetSequence( int id )
+{
+	sequence_l::iterator	si;
+	STL_ITERATE( si, m_sequences )
+	{
+		if ( (*si)->GetID() == id )
+			return (*si);
+	}
+
+	return NULL;
+}
+
+/*
+-------------------------
+DeleteSequence
+-------------------------
+*/
+
+void ICARUS_Instance::DeleteSequence( CSequence *sequence )
+{
+	m_sequences.remove( sequence );	
+
+	delete sequence;
+
+#ifdef _DEBUG
+
+	m_DEBUG_NumSequenceFreed++;
+
+#endif 
+}
+
+/*
+-------------------------
+AllocateSequences
+-------------------------
+*/
+
+int ICARUS_Instance::AllocateSequences( int numSequences, int *idTable )
+{
+	CSequence	*sequence;
+
+	for ( int i = 0; i < numSequences; i++ )
+	{
+		//If the GUID of this sequence is higher than the current, take this a the "current" GUID
+		if ( idTable[i] > m_GUID )
+			m_GUID = idTable[i];
+
+		//Allocate the container sequence
+		if ( ( sequence = GetSequence() ) == NULL )
+			return false;
+
+		//Override the given GUID with the real one
+		sequence->SetID( idTable[i] );
+	}
+
+	return true;
+}
+
+/*
+-------------------------
+SaveSequenceIDTable
+-------------------------
+*/
+
+int ICARUS_Instance::SaveSequenceIDTable( void )
+{
+	//Save out the number of sequences to follow
+	int		numSequences = m_sequences.size();
+	m_interface->I_WriteSaveData( '#SEQ', &numSequences, sizeof( numSequences ) );
+
+	//Sequences are saved first, by ID and information
+	sequence_l::iterator	sqi;
+
+	//First pass, save all sequences ID for reconstruction
+	int	*idTable = new int[ numSequences ];
+	int	itr = 0;
+
+	if ( idTable == NULL )
+		return false;
+
+	STL_ITERATE( sqi, m_sequences )
+	{
+		idTable[itr++] = (*sqi)->GetID();
+	}
+
+	m_interface->I_WriteSaveData( 'SQTB', idTable, sizeof( int ) * numSequences );
+
+	delete[] idTable;
+
+	return true;
+}
+
+/*
+-------------------------
+SaveSequences
+-------------------------
+*/
+
+int ICARUS_Instance::SaveSequences( void )
+{
+	//Save out a listing of all the used sequences by ID
+	SaveSequenceIDTable();
+
+	//Save all the information in order
+	sequence_l::iterator	sqi;
+	STL_ITERATE( sqi, m_sequences )
+	{
+		(*sqi)->Save();
+	}
+
+	return true;
+}
+
+/*
+-------------------------
+SaveSequencers
+-------------------------
+*/
+
+int ICARUS_Instance::SaveSequencers( void )
+{
+	//Save out the number of sequences to follow
+	int		numSequencers = m_sequencers.size();
+	m_interface->I_WriteSaveData( '#SQR', &numSequencers, sizeof( numSequencers ) );
+
+	//The sequencers are then saved
+	sequencer_l::iterator	si;
+	STL_ITERATE( si, m_sequencers )
+	{
+		(*si)->Save();
+	}
+
+	return true;
+}
+
+/*
+-------------------------
+SaveSignals
+-------------------------
+*/
+
+int ICARUS_Instance::SaveSignals( void )
+{
+	int	numSignals = m_signals.size();
+
+	m_interface->I_WriteSaveData( 'ISIG', &numSignals, sizeof( numSignals ) );
+
+	signal_m::iterator	si;
+	STL_ITERATE( si, m_signals )
+	{
+		//m_interface->I_WriteSaveData( 'ISIG', &numSignals, sizeof( numSignals ) );
+		const char *name = ((*si).first).c_str();
+		
+		//Make sure this is a valid string
+		assert( ( name != NULL ) && ( name[0] != NULL ) );
+
+		int length = strlen( name ) + 1;
+
+		//Save out the string size
+		m_interface->I_WriteSaveData( 'SIG#', &length, sizeof ( length ) );
+
+		//Write out the string
+		m_interface->I_WriteSaveData( 'SIGN', (void *) name, length );
+	}
+
+	return true;
+}
+
+/*
+-------------------------
+Save
+-------------------------
+*/
+
+int ICARUS_Instance::Save( void )
+{	
+	//Save out a ICARUS save block header with the ICARUS version
+	double	version = ICARUS_VERSION;
+	m_interface->I_WriteSaveData( 'ICAR', &version, sizeof( version ) );
+
+	//Save out the signals
+	if ( SaveSignals() == false )
+		return false;
+
+	//Save out the sequences
+	if ( SaveSequences() == false )
+		return false;
+
+	//Save out the sequencers
+	if ( SaveSequencers() == false )
+		return false;
+
+	m_interface->I_WriteSaveData( 'IEND', &version, sizeof( version ) );
+
+	return true;
+}
+
+/*
+-------------------------
+LoadSignals
+-------------------------
+*/
+
+int ICARUS_Instance::LoadSignals( void )
+{
+	int numSignals;
+
+	m_interface->I_ReadSaveData( 'ISIG', &numSignals, sizeof( numSignals ) );
+
+	for ( int i = 0; i < numSignals; i++ )
+	{
+		char	buffer[1024];
+		int		length;
+
+		//Get the size of the string
+		m_interface->I_ReadSaveData( 'SIG#', &length, sizeof( length ) );
+
+		assert( length < sizeof( buffer ) );
+
+		//Get the string
+		m_interface->I_ReadSaveData( 'SIGN', &buffer, length );
+
+		//Turn it on and add it to the system
+		Signal( (const char *) &buffer );
+	}
+
+	return true;
+}
+
+/*
+-------------------------
+LoadSequence
+-------------------------
+*/
+
+int ICARUS_Instance::LoadSequence( void )
+{
+	CSequence	*sequence = GetSequence();
+
+	//Load the sequence back in
+	sequence->Load();
+
+	//If this sequence had a higher GUID than the current, save it
+	if ( sequence->GetID() > m_GUID )
+		m_GUID = sequence->GetID();
+
+	return true;
+}
+
+/*
+-------------------------
+LoadSequence
+-------------------------
+*/
+
+int ICARUS_Instance::LoadSequences( void )
+{
+	CSequence	*sequence;
+	int			numSequences;
+
+	//Get the number of sequences to read in
+	m_interface->I_ReadSaveData( '#SEQ', &numSequences, sizeof( numSequences ) );
+
+	int	*idTable = new int[ numSequences ];
+
+	if ( idTable == NULL )
+		return false;
+
+	//Load the sequencer ID table
+	m_interface->I_ReadSaveData( 'SQTB', idTable, sizeof( int ) * numSequences );
+
+	//First pass, allocate all container sequences and give them their proper IDs
+	if ( AllocateSequences( numSequences, idTable ) == false )
+		return false;
+
+	//Second pass, load all sequences
+	for ( int i = 0; i < numSequences; i++ )
+	{
+		//Get the proper sequence for this load
+		if ( ( sequence = GetSequence( idTable[i] ) ) == NULL )
+			return false;
+
+		//Load the sequence
+		if ( ( sequence->Load() ) == false )
+			return false;
+	}
+
+	//Free the idTable
+	delete[] idTable;
+
+	return true;
+}
+
+/*
+-------------------------
+LoadSequencers
+-------------------------
+*/
+
+int ICARUS_Instance::LoadSequencers( void )
+{
+	CSequencer	*sequencer;
+	int			numSequencers;
+
+	//Get the number of sequencers to load
+	m_interface->I_ReadSaveData( '#SQR', &numSequencers, sizeof( &numSequencers ) );
+	
+	//Load all sequencers
+	for ( int i = 0; i < numSequencers; i++ )
+	{
+		//NOTENOTE: The ownerID will be replaced in the loading process
+		if ( ( sequencer = GetSequencer( -1 ) ) == NULL )
+			return false;
+
+		if ( sequencer->Load() == false )
+			return false;
+	}
+
+	return true;
+}
+
+/*
+-------------------------
+Load
+-------------------------
+*/
+
+int ICARUS_Instance::Load( void )
+{
+	//Clear out any old information
+	Free();
+
+	//Check to make sure we're at the ICARUS save block
+	double	version;
+	m_interface->I_ReadSaveData( 'ICAR', &version, sizeof( version ) );
+
+	//Versions must match!
+	if ( version != ICARUS_VERSION )
+	{
+		m_interface->I_DPrintf( WL_ERROR, "save game data contains outdated ICARUS version information!\n");
+		return false;
+	}
+
+	//Load all signals
+	if ( LoadSignals() == false )
+	{
+		m_interface->I_DPrintf( WL_ERROR, "failed to load signals from save game!\n");
+		return false;
+	}
+
+	//Load in all sequences
+	if ( LoadSequences() == false )
+	{
+		m_interface->I_DPrintf( WL_ERROR, "failed to load sequences from save game!\n");
+		return false;
+	}
+
+	//Load in all sequencers
+	if ( LoadSequencers() == false )
+	{
+		m_interface->I_DPrintf( WL_ERROR, "failed to load sequencers from save game!\n");
+		return false;
+	}
+
+	m_interface->I_ReadSaveData( 'IEND', &version, sizeof( version ) );
+
+	return true;
+}
+
+/*
+-------------------------
+Signal
+-------------------------
+*/
+
+void ICARUS_Instance::Signal( const char *identifier )
+{
+	m_signals[ identifier ] = 1;
+}
+
+/*
+-------------------------
+CheckSignal
+-------------------------
+*/
+
+bool ICARUS_Instance::CheckSignal( const char *identifier )
+{
+	signal_m::iterator	smi;
+
+	smi = m_signals.find( identifier );
+
+	if ( smi == m_signals.end() )
+		return false;
+
+	return true;
+}
+
+/*
+-------------------------
+ClearSignal
+-------------------------
+*/
+
+void ICARUS_Instance::ClearSignal( const char *identifier )
+{
+	m_signals.erase( identifier );
+}
diff --git a/codemp/icarus/Interface.cpp b/codemp/icarus/Interface.cpp
new file mode 100644
index 0000000..a5e6fd2
--- /dev/null
+++ b/codemp/icarus/Interface.cpp
@@ -0,0 +1,24 @@
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+// ICARUS Engine Interface File
+//
+//	This file is the only section of the ICARUS systems that 
+//	is not directly portable from engine to engine.
+//
+//	-- jweier
+
+#include "../game/g_public.h"
+
+#include "interface.h"
+/*
+void Interface_Init( interface_export_t *pe )
+{
+
+	//TODO: This is where you link up all your functions to the engine
+
+	//Example:
+	//
+	// pe->I_GetEntityByName = ENGINE_GetEntityByName;
+}
+*/
diff --git a/codemp/icarus/Interpreter.cpp b/codemp/icarus/Interpreter.cpp
new file mode 100644
index 0000000..9ef494e
--- /dev/null
+++ b/codemp/icarus/Interpreter.cpp
@@ -0,0 +1,2506 @@
+// Token Interpreter
+//
+//	-- jweier
+
+#include <direct.h>	//For getcwd()
+#include <conio.h>	//For getch()
+#include <stdio.h>
+
+#include "Tokenizer.h"
+#include "BlockStream.h"
+#include "Interpreter.h"
+
+/*
+===================================================================================================
+
+  Table Definitions
+
+===================================================================================================
+*/
+
+//FIXME: The following tables should be passed in to the interpreter for flexibility
+
+//Symbol Table
+
+keywordArray_t CInterpreter::m_symbolKeywords[] =
+{
+	//Blocks
+	"{",	TK_BLOCK_START,
+	"}",	TK_BLOCK_END,
+	
+	//Vectors
+	"<",	TK_VECTOR_START,
+	">",	TK_VECTOR_END,
+	
+	//Groups
+	"(",	TK_OPEN_PARENTHESIS,
+	")",	TK_CLOSED_PARENTHESIS,
+
+	"=",	TK_EQUALS,
+	"!",	TK_NOT,
+
+	//End
+	"",		TK_EOF,
+};
+
+keywordArray_t CInterpreter::m_conditionalKeywords[] =
+{
+	"",		TK_EOF,
+};
+
+//ID Table
+
+keywordArray_t CInterpreter::m_IDKeywords[] =
+{
+	"AFFECT",		ID_AFFECT,
+	"SOUND",		ID_SOUND,
+	"MOVE",			ID_MOVE,
+	"ROTATE",		ID_ROTATE,
+	"WAIT",			ID_WAIT,
+	"SET",			ID_SET,
+	"LOOP",			ID_LOOP,
+	"PRINT",		ID_PRINT,
+	"TAG",			ID_TAG,
+	"USE",			ID_USE,
+	"FLUSH",		ID_FLUSH,
+	"RUN",			ID_RUN,
+	"KILL",			ID_KILL,
+	"REMOVE",		ID_REMOVE,
+	"CAMERA",		ID_CAMERA,
+	"GET",			ID_GET,
+	"RANDOM",		ID_RANDOM,
+	"IF",			ID_IF,
+	"ELSE",			ID_ELSE,
+	"REM",			ID_REM,
+	"FLOAT",		TK_FLOAT,
+	"VECTOR",		TK_VECTOR,
+	"STRING",		TK_STRING,
+	"TASK",			ID_TASK,
+	"DO",			ID_DO,
+	"DECLARE",		ID_DECLARE,
+	"FREE",			ID_FREE,
+	"DOWAIT",		ID_DOWAIT,
+	"SIGNAL",		ID_SIGNAL,
+	"WAITSIGNAL",	ID_WAITSIGNAL,
+	"PLAY",			ID_PLAY,
+
+	"",			ID_EOF,
+};
+
+//Type Table
+
+keywordArray_t CInterpreter::m_typeKeywords[] =
+{
+	//Set types
+	"ANGLES",		TYPE_ANGLES,
+	"ORIGIN",		TYPE_ORIGIN,
+
+	//Affect types
+	"INSERT",		TYPE_INSERT,
+	"FLUSH",		TYPE_FLUSH,
+
+	//Get types
+	"FLOAT",		TK_FLOAT,
+	"INT",			TK_INT,
+	"VECTOR",		TK_VECTOR,
+	"STRING",		TK_STRING,
+
+	"PAN",			TYPE_PAN,
+	"ZOOM",			TYPE_ZOOM,
+	"MOVE",			TYPE_MOVE,
+	"FADE",			TYPE_FADE,
+	"PATH",			TYPE_PATH,
+	"ENABLE",		TYPE_ENABLE,
+	"DISABLE",		TYPE_DISABLE,
+	"SHAKE",		TYPE_SHAKE,
+	"ROLL",			TYPE_ROLL,
+	"TRACK",		TYPE_TRACK,
+	"FOLLOW",		TYPE_FOLLOW,
+	"DISTANCE",		TYPE_DISTANCE,
+
+	//End
+	"",				TYPE_EOF,
+};
+
+
+/*
+===================================================================================================
+
+  Constructor / Destructor
+
+===================================================================================================
+*/
+
+CInterpreter::CInterpreter()
+{
+}
+
+CInterpreter::~CInterpreter()
+{
+}
+
+/*
+===================================================================================================
+
+	Error Handling
+
+===================================================================================================
+*/
+
+int CInterpreter::Error( char *format, ... )
+{
+	va_list		argptr;
+	char		*error_file, error_msg[1024]="", work_dir[1024]="", out_msg[1024]="";
+	int			error_line = m_iCurrentLine;	// m_tokenizer->GetCurLine();
+
+	m_tokenizer->GetCurFilename( &error_file );
+	if (!error_file)	
+	{
+		// 99% of the time we'll get here now, because of pushed parse streams
+		//
+		error_file = (char *)m_sCurrentFile.c_str();
+	}
+
+	va_start (argptr, format);
+	vsprintf (error_msg, format, argptr);
+	va_end (argptr);
+
+	strcpy((char *) work_dir, getcwd( (char *) &work_dir, 1024 ) );
+
+	if (error_file[1] == ':')
+	{
+		sprintf((char *) out_msg, "%s (%d) : error: %s\n", error_file, error_line, error_msg);
+	}
+	else
+	{
+		sprintf((char *) out_msg, "%s\\%s (%d) : error: %s\n", work_dir, error_file, error_line, error_msg);
+	}
+
+	if (m_sCurrentLine.length())
+	{
+		strcat(out_msg, "\nLine:\n\n");
+		strcat(out_msg, m_sCurrentLine.c_str());
+		strcat(out_msg, "\n");
+	}
+
+#ifdef __POP_UPS__	
+
+	MessageBox( NULL, out_msg, "Error", MB_OK );
+
+#else
+
+	printf(out_msg);
+
+#endif
+
+	// A bit of kludge code that takes care of the case where there's some garbage at the beginning of the file
+	//	before any blocks are read as valid. This is needed because ints are incapable of containing 0
+	//
+	// This'll mean that technically it's saying block 1 is wrong, rather than the one in between them, but I can
+	//	live with that.
+	//
+	if (m_iBadCBlockNumber == 0)
+	{
+		m_iBadCBlockNumber = 1;
+	}
+	return false;
+}
+
+/*
+===================================================================================================
+
+	Local Variable Functions
+
+===================================================================================================
+*/
+
+/*
+-------------------------
+InitVars
+-------------------------
+*/
+
+void CInterpreter::InitVars( void )
+{
+	m_vars.clear();
+	m_varMap.clear();
+}
+
+/*
+-------------------------
+FreeVars
+-------------------------
+*/
+
+void CInterpreter::FreeVars( void )
+{
+	variable_v::iterator	vi;
+
+	for ( vi = m_vars.begin(); vi != m_vars.end(); vi++ )
+	{
+		delete (*vi);
+	}
+
+	InitVars();
+}
+
+/*
+-------------------------
+AddVar
+-------------------------
+*/
+
+variable_t *CInterpreter::AddVar( const char *name, int type )
+{
+	variable_t	*var;
+
+	var = new variable_t;
+
+	if ( var == NULL )
+		return NULL;
+
+	//Specify the type
+	var->type = type;
+
+	//Retain the name internally
+	strncpy( (char *) var->name, name, MAX_VAR_NAME );
+
+	//Associate it
+	m_varMap[ name ] = var;
+
+	return var;
+}
+
+/*
+-------------------------
+FindVar
+-------------------------
+*/
+
+variable_t *CInterpreter::FindVar( const char *name )
+{
+	variable_m::iterator	vmi;
+
+	vmi = m_varMap.find( name );
+
+	if ( vmi == m_varMap.end() )
+		return NULL;
+
+	return (*vmi).second;
+}
+
+/*
+-------------------------
+GetVariable
+-------------------------
+*/
+
+int CInterpreter::GetVariable( int type )
+{
+	const char	*varName;
+	variable_t	*var;
+	CToken		*token;
+
+	//Get the variable's name
+	token = m_tokenizer->GetToken( 0, 0 );
+	varName = token->GetStringValue();
+
+	//See if we already have a variable by this name
+	var = FindVar( varName );
+
+	//Variable names must be unique on creation
+	if ( var )
+		return Error( "\"%s\" : already exists\n", varName );
+
+	//Add the variable
+	AddVar( varName, type );
+
+	//Insert the variable into the stream
+
+	CBlock	block;
+
+	block.Create( TYPE_VARIABLE );
+	block.Write( TK_FLOAT, (float) type );
+	block.Write( TK_STRING, varName );
+
+	m_blockStream->WriteBlock( &block );
+
+	token->Delete();
+
+	return true;
+}
+
+/*
+===================================================================================================
+
+	ID Table Functions
+
+===================================================================================================
+*/
+
+int CInterpreter::GetVector( CBlock *block )
+{
+	//Look for a tag
+	if ( MatchTag() )
+	{
+		return GetTag( block );
+	}
+
+	//Look for a get
+	if ( MatchGet() )
+	{
+		return GetGet( block );
+	}
+
+	if ( Match( TK_VECTOR_START ) )
+	{
+		//Get the vector
+		block->Write( TK_VECTOR, (float) TK_VECTOR );
+
+		for (int i=0; i<3; i++)
+			GetFloat( block );
+
+		if (!Match( TK_VECTOR_END ))
+		{
+			return Error("syntax error : expected end of vector");
+		}
+
+		return true;
+	}
+
+	return false;
+}
+
+/*
+===================================================================================================
+
+  MatchTag()
+
+  Attempts to match to a tag identifier.
+
+===================================================================================================
+*/
+
+int CInterpreter::MatchTag( void )
+{
+	CToken		*token;
+	const char	*idName;
+	int			id;
+
+	token = m_tokenizer->GetToken( 0, 0 );
+	idName = token->GetStringValue();
+	id = FindSymbol( idName, m_IDKeywords );
+
+	if ( id != ID_TAG )
+	{
+		//Return the token
+		m_tokenizer->PutBackToken( token );
+		return false;
+	}
+
+	token->Delete();
+	return true;
+}
+
+/*
+===================================================================================================
+
+  MatchGet()
+
+  Attempts to match to a get identifier.
+
+===================================================================================================
+*/
+
+int CInterpreter::MatchGet( void )
+{
+	CToken		*token;
+	const char	*idName;
+	int			id;
+
+	token = m_tokenizer->GetToken( 0, 0 );
+	idName = token->GetStringValue();
+	id = FindSymbol( idName, m_IDKeywords );
+
+	if ( id != ID_GET )
+	{
+		//Return the token
+		m_tokenizer->PutBackToken( token );
+		return false;
+	}
+
+	token->Delete();
+	return true;
+}
+
+/*
+===================================================================================================
+
+  MatchRandom()
+
+  Attempts to match to a random identifier.
+
+===================================================================================================
+*/
+
+int CInterpreter::MatchRandom( void )
+{
+	CToken		*token;
+	const char	*idName;
+	int			id;
+
+	token = m_tokenizer->GetToken( 0, 0 );
+	idName = token->GetStringValue();
+	id = FindSymbol( idName, m_IDKeywords );
+
+	if ( id != ID_RANDOM )
+	{
+		//Return the token
+		m_tokenizer->PutBackToken( token );
+		return false;
+	}
+
+	token->Delete();
+	return true;
+}
+
+/*
+===================================================================================================
+
+  FindSymbol()
+
+  Searches the symbol table for the given name.  Returns the ID if found.
+
+===================================================================================================
+*/
+
+int CInterpreter::FindSymbol( const char *name,  keywordArray_t *table)
+{
+	keywordArray_t *ids;
+
+	for (ids = table; (strcmp(ids->m_keyword, "")); ids++)
+	{
+		if (!stricmp(name, ids->m_keyword))
+			return ids->m_tokenvalue;
+	}
+
+	return -1;
+}
+
+
+/*
+===================================================================================================
+
+  Match()
+
+  Looks ahead to the next token to try and match it to the passed token, consumes token on success.
+
+===================================================================================================
+*/
+
+//NOTENOTE:  LookAhead() was separated from Match() for clarity
+
+int CInterpreter::Match( int token_id )
+{
+	CToken	*token;
+
+	token = m_tokenizer->GetToken( 0, 0 );
+
+	if ( token->GetType() != token_id )
+	{
+		//This may have been a check, so don't loose the token
+		m_tokenizer->PutBackToken( token );
+		
+		return false;
+	}
+
+	return true;
+}
+
+/*
+-------------------------
+GetNextType
+-------------------------
+*/
+
+int CInterpreter::GetNextType( void )
+{
+	CToken	*token = m_tokenizer->GetToken( 0, 0 );
+	int		id = token->GetType();
+
+	m_tokenizer->PutBackToken( token );
+
+	return id;
+}
+
+/*
+===================================================================================================
+
+  LookAhead()
+
+  Looks ahead without consuming on success.
+
+===================================================================================================
+*/
+
+int CInterpreter::LookAhead( int token_id )
+{
+	CToken	*token;
+
+	token = m_tokenizer->GetToken( 0, 0 );
+
+	if ( token->GetType() != token_id )
+	{
+		m_tokenizer->PutBackToken( token );
+		
+		return false;
+	}
+
+	m_tokenizer->PutBackToken( token );
+
+	return true;
+}
+
+/*
+===================================================================================================
+
+  GetTokenName()
+
+  Returns the name of a token.
+
+===================================================================================================
+*/
+
+const char *CInterpreter::GetTokenName( int token_id )
+{
+	switch ( token_id )
+	{
+	case TK_STRING:
+		return "STRING";
+		break;
+
+	case TK_CHAR:
+		return "CHARACTER";
+		break;
+
+	case TK_IDENTIFIER:
+		return "IDENTIFIER";
+		break;
+
+	case TK_FLOAT:
+		return "FLOAT";
+		break;
+
+	case TK_INTEGER:
+		return "INTEGER";
+		break;
+
+	default:
+		return "UNKNOWN";
+		break;
+	}
+}
+
+/*
+===================================================================================================
+
+	Token Value Functions
+
+===================================================================================================
+*/
+
+/*
+===================================================================================================
+
+  GetFloat()
+
+  Attempts to match and retrieve the value of a float token.
+
+===================================================================================================
+*/
+
+int CInterpreter::GetFloat( CBlock *block )
+{
+	CToken	*token;
+	int		type;
+
+	//Look for a get
+	if ( MatchGet() )
+	{
+		return GetGet( block );
+	}
+
+	//Look for a random
+	if ( MatchRandom() )
+	{
+		return GetRandom( block );
+	}
+
+	token = m_tokenizer->GetToken(0,0);
+	type = token->GetType();
+
+	//Floats can accept either int or float values
+	if ( ( type != TK_FLOAT ) && ( type != TK_INT ) )
+	{
+		return Error("syntax error : expected float; found %s", GetTokenName(type) );
+	}
+	
+	if (type == TK_FLOAT)
+	{
+		block->Write( TK_FLOAT, (float) token->GetFloatValue() );
+	}
+	else
+	{
+		block->Write( TK_FLOAT, (float) token->GetIntValue() );
+	}
+
+	token->Delete();
+
+	return true;
+}
+
+/*
+===================================================================================================
+
+  GetInteger()
+
+  Attempts to match and retrieve the value of an integer token.
+
+===================================================================================================
+*/
+
+int CInterpreter::GetInteger( CBlock *block )
+{
+	return GetFloat( block );
+}
+
+/*
+===================================================================================================
+
+  GetString()
+
+  Attempts to match and retrieve the value of a string token.
+
+===================================================================================================
+*/
+
+int CInterpreter::GetString( CBlock *block )
+{
+	CToken	*token;
+	int		type;
+
+	//Look for a get
+	if ( MatchGet() )
+	{
+		return GetGet( block );
+	}
+
+	//Look for a random
+	if ( MatchRandom() )
+	{
+		return GetRandom( block );
+	}
+
+	token = m_tokenizer->GetToken(0, 0);
+	type = token->GetType();
+
+	if ( (type != TK_STRING) && (type != TK_CHAR) )
+	{
+		return Error("syntax error : expected string; found %s", GetTokenName(type));
+	}
+
+//UGLY HACK!!!
+
+	const char	*temptr;
+	char		temp[1024];
+
+	temptr = token->GetStringValue();
+
+	if ( strlen(temptr)+1 > sizeof( temp ) )
+	{
+		return false;
+	}
+
+	for ( int i = 0; i < (int)strlen( temptr ); i++ )
+	{
+		if ( temptr[i] == '#' )
+			temp[i] = '\n';
+		else
+			temp[i] = temptr[i];
+	}
+	
+	temp[ strlen( temptr ) ] = 0;
+
+//UGLY HACK END!!!
+
+	block->Write( TK_STRING, (const char *) &temp );
+
+	token->Delete();
+	
+	return true;
+}
+
+/*
+===================================================================================================
+
+  GetIdentifier()
+
+  Attempts to match and retrieve the value of an indentifier token.
+
+===================================================================================================
+*/
+
+int CInterpreter::GetIdentifier( CBlock *block )
+{
+	CToken	*token;
+	int		type;
+
+	//FIXME: Should identifiers do this?
+	if ( MatchGet() )
+	{
+		if ( GetGet( block ) == false )
+			return false;
+
+		return true;
+	}
+
+	token = m_tokenizer->GetToken(0, 0);
+	type = token->GetType();
+
+	if ( type != TK_IDENTIFIER )
+	{
+		return Error("syntax error : expected indentifier; found %s", GetTokenName(type));
+	}
+
+	block->Write( TK_IDENTIFIER, (const char *) token->GetStringValue() );
+
+	token->Delete();
+	
+	return true;
+}
+
+/*
+===================================================================================================
+
+  GetEvaluator()
+
+  Attempts to match and retrieve the value of an evaluator token.
+
+===================================================================================================
+*/
+
+int CInterpreter::GetEvaluator( CBlock *block )
+{
+	CToken	*token;
+	int		type;
+
+	if ( MatchGet() )
+		return false;
+
+	if ( MatchRandom() )
+		return false;
+
+	token = m_tokenizer->GetToken(0, 0);
+	type = token->GetType();
+	token->Delete();
+
+	switch ( type )
+	{
+	case TK_GREATER_THAN:
+	case TK_LESS_THAN:
+	case TK_EQUALS:
+	case TK_NOT:
+		break;
+
+	case TK_VECTOR_START:
+		type = TK_LESS_THAN;
+		break;
+
+	case TK_VECTOR_END:
+		type = TK_GREATER_THAN;
+		break;
+
+	default:
+		return Error("syntax error : expected operator type, found %s", GetTokenName( type ) );
+	}
+
+	block->Write( type, 0 );
+
+	return true;
+}
+
+/*
+===================================================================================================
+
+  GetAny()
+
+  Attempts to match and retrieve any valid data type.
+
+===================================================================================================
+*/
+
+int CInterpreter::GetAny( CBlock *block )
+{
+	CToken	*token;
+	int		type;
+
+	if ( MatchGet() )
+	{
+		if ( GetGet( block ) == false )
+			return false;
+
+		return true;
+	}
+
+	if ( MatchRandom() )
+	{
+		if ( GetRandom( block ) == false )
+			return false;
+
+		return true;
+	}
+
+	if ( MatchTag() )
+	{
+		if ( GetTag( block ) == false )
+			return false;
+
+		return true;
+	}
+
+	token = m_tokenizer->GetToken(0, 0);
+	type = token->GetType();
+
+	switch ( type )
+	{
+	case TK_FLOAT:
+		m_tokenizer->PutBackToken( token );
+		if ( GetFloat( block ) == false )
+			return false;
+
+		break;
+
+	case TK_INT:
+		m_tokenizer->PutBackToken( token );
+		if ( GetInteger( block ) == false )
+			return false;
+
+		break;
+
+	case TK_VECTOR_START:
+		m_tokenizer->PutBackToken( token );
+		if ( GetVector( block ) == false )
+			return false;
+
+		break;
+
+	case TK_STRING:
+	case TK_CHAR:
+		m_tokenizer->PutBackToken( token );
+		if ( GetString( block ) == false )
+			return false;
+
+		break;
+
+	case TK_IDENTIFIER:
+		m_tokenizer->PutBackToken( token );
+		if ( GetIdentifier( block ) == false )
+			return false;
+
+		break;
+
+	default:
+		return false;
+	}
+
+	return true;
+}
+
+/*
+===================================================================================================
+
+  GetType()
+
+  Attempts to match and retrieve the value of a type token.
+
+===================================================================================================
+*/
+
+int CInterpreter::GetType( char *get )
+{
+	CToken	*token;
+	char	*string;
+	int		type;
+
+	token = m_tokenizer->GetToken(0, 0);
+	type = token->GetType();
+
+	if ( type != TK_IDENTIFIER )
+	{
+		return Error("syntax error : expected identifier; found %s", GetTokenName(type));
+	}
+
+	string = (char *) token->GetStringValue();
+
+	if ( (strlen(string) + 1) > MAX_STRING_LENGTH)
+	{
+		Error("string exceeds 256 character limit");
+		return false;
+	}
+
+	strcpy(get, string);
+
+	return true;
+}
+
+/*
+===================================================================================================
+
+  GetID()
+
+  Attempts to match and interpret an identifier.
+
+===================================================================================================
+*/
+
+//FIXME: This should use an externally defined table to match ID and functions
+
+int CInterpreter::GetID( char *id_name )
+{
+	int		id;
+
+	id = FindSymbol( id_name, m_IDKeywords );
+
+	if ( id == -1 )
+		return Error("'%s' : unknown identifier", id_name);
+
+	//FIXME: Function pointers would be awfully nice.. but not inside a class!  Weee!!
+
+	switch (id)
+	{
+	
+	//Affect takes control of an entity
+
+	case ID_AFFECT:
+		return GetAffect();
+		break;
+
+	//Wait for a specified amount of time
+
+	case ID_WAIT:
+		return GetWait();
+		break;
+
+	//Generic set call
+
+	case ID_SET:
+		return GetSet();
+		break;
+
+	case ID_LOOP:
+		return GetLoop();
+		break;
+
+	case ID_PRINT:
+		return GetPrint();
+		break;
+
+	case ID_USE:
+		return GetUse();
+		break;
+
+	case ID_FLUSH:
+		return GetFlush();
+		break;
+		
+	case ID_RUN:
+		return GetRun();
+		break;
+
+	case ID_KILL:
+		return GetKill();
+		break;
+
+	case ID_REMOVE:
+		return GetRemove();
+		break;
+
+	case ID_CAMERA:
+		return GetCamera();
+		break;
+
+	case ID_SOUND:
+		return GetSound();
+		break;
+
+	case ID_MOVE:
+		return GetMove();
+		break;
+
+	case ID_ROTATE:
+		return GetRotate();
+		break;
+
+	case ID_IF:
+		return GetIf();
+		break;
+
+	case ID_ELSE:
+		//return Error("syntax error : else without matching if");
+		return GetElse();	//FIXME: Protect this call so that floating else's aren't allowed
+		break;
+
+	case ID_GET:
+		return Error("syntax error : illegal use of \"get\"");
+		break;
+
+	case ID_TAG:
+		return Error("syntax error : illegal use of \"tag\"");
+		break;
+
+	case ID_TASK:
+		return GetTask();
+		break;
+
+	case ID_DO:
+		return GetDo();
+		break;
+
+	case ID_DECLARE:
+		return GetDeclare();
+		break;
+
+	case ID_FREE:
+		return GetFree();
+		break;
+
+	case ID_REM:
+		GetRem();
+		break;
+
+	case ID_DOWAIT:
+		GetDoWait();
+		break;
+
+	case ID_SIGNAL:
+		GetSignal();
+		break;
+
+	case ID_WAITSIGNAL:
+		GetWaitSignal();
+		break;
+
+	case ID_PLAY:
+		GetPlay();	//Bad eighties slang joke...  yeah, it's not really funny, I know...
+		break;
+
+		//Local variable types
+	case TK_FLOAT:
+	case TK_INT:
+	case TK_STRING:
+	case TK_VECTOR:
+		GetVariable( id );
+		break;
+
+	//Unknown ID
+
+	default:
+	case -1:
+		return Error("'%s' : unknown identifier", id_name);
+		break;
+	}
+
+	return true;
+}
+
+/*
+===================================================================================================
+
+	ID Interpreting Functions
+
+===================================================================================================
+*/
+
+/*
+-------------------------
+GetDeclare
+-------------------------
+*/
+
+int CInterpreter::GetDeclare( void )
+{
+	CBlock	block;
+	char	typeName[MAX_STRING_LENGTH];
+	int		type;
+
+	block.Create( ID_DECLARE );
+
+	if (!Match( TK_OPEN_PARENTHESIS ))
+		return Error("syntax error : '(' not found");
+
+	if ( GetType( (char *) typeName ) == false )
+		return false;
+
+	type = FindSymbol( typeName, m_typeKeywords);
+
+	switch ( type )
+	{
+	case TK_FLOAT:
+	case TK_VECTOR:
+	case TK_STRING:
+		block.Write( TK_FLOAT, (float) type );
+		break;
+
+	default:
+		return Error("unknown identifier %s", typeName );
+		break;
+	}
+
+	if ( GetString( &block ) == false )
+		return false;
+
+	if (!Match( TK_CLOSED_PARENTHESIS ))
+		return Error("declare : too many parameters");
+
+	m_blockStream->WriteBlock( &block );
+
+	return true;
+}
+
+
+/*
+-------------------------
+GetFree
+-------------------------
+*/
+
+int CInterpreter::GetFree( void )
+{
+	CBlock	block;
+
+	block.Create( ID_FREE );
+
+	if ( Match( TK_OPEN_PARENTHESIS ) == false )
+		return Error("syntax error : '(' not found");
+
+	if ( GetString( &block ) == false )
+		return false;
+
+	if ( Match( TK_CLOSED_PARENTHESIS ) == false )
+		return Error("free : too many parameters");
+
+	m_blockStream->WriteBlock( &block );
+
+	return true;
+}
+
+/*
+===================================================================================================
+
+  GetIf()
+
+  Handles the if() conditional statement.
+
+===================================================================================================
+*/
+
+// if ( STRING ? STRING )
+
+int CInterpreter::GetIf( void )
+{
+	CBlock	block;
+
+	block.Create( ID_IF );
+
+	if ( Match( TK_OPEN_PARENTHESIS ) == false )
+		return Error("syntax error : '(' not found");
+
+	if ( GetAny( &block ) == false )
+		return false;
+
+	if ( GetEvaluator( &block ) == false )
+		return false;
+
+	if ( GetAny( &block ) == false )
+		return false;
+
+	if ( Match( TK_CLOSED_PARENTHESIS ) == false )
+		return Error("if : too many parameters");
+
+	m_blockStream->WriteBlock( &block );
+
+	return true;
+}
+
+/*
+===================================================================================================
+
+  GetElse()
+
+  Handles the else() conditional statement.
+
+===================================================================================================
+*/
+
+// else
+
+int CInterpreter::GetElse( void )
+{
+	CBlock	block;
+
+	block.Create( ID_ELSE );
+
+	/*
+	if ( Match( TK_OPEN_PARENTHESIS ) == false )
+		return Error("syntax error : '(' not found");
+	*/
+
+	/*
+	if ( GetAny( &block ) == false )
+		return false;
+
+	if ( GetEvaluator( &block ) == false )
+		return false;
+
+	if ( GetAny( &block ) == false )
+		return false;
+	*/
+
+	/*
+	if ( Match( TK_CLOSED_PARENTHESIS ) == false )
+		return Error("sound : too many parameters");
+	*/
+
+	m_blockStream->WriteBlock( &block );
+
+	return true;
+}
+
+/*
+===================================================================================================
+
+  GetTask()
+
+  Handles the task() sequence specifier.
+
+===================================================================================================
+*/
+
+//task ( name ) { }
+
+int CInterpreter::GetTask( void )
+{
+	CBlock	block;
+
+	block.Create( ID_TASK );
+
+	if (!Match( TK_OPEN_PARENTHESIS ))
+		return Error("syntax error : '(' not found");
+
+	if ( GetString( &block ) == false )
+		return false;
+
+	if (!Match( TK_CLOSED_PARENTHESIS ))
+		return Error("GetTask: too many parameters");
+
+	m_blockStream->WriteBlock( &block );
+
+	return true;
+
+}
+
+/*
+===================================================================================================
+
+  GetDo()
+
+  Handles the do() function.
+
+===================================================================================================
+*/
+
+//do ( taskName )
+
+int CInterpreter::GetDo( void )
+{
+	CBlock	block;
+
+	block.Create( ID_DO );
+
+	if (!Match( TK_OPEN_PARENTHESIS ))
+		return Error("syntax error : '(' not found");
+
+	if ( GetString( &block ) == false )
+		return false;
+
+	if (!Match( TK_CLOSED_PARENTHESIS ))
+		return Error("do : too many parameters");
+
+	m_blockStream->WriteBlock( &block );
+
+	return true;
+}
+
+/*
+===================================================================================================
+
+  GetGet()
+
+  Handles the get() function.
+
+===================================================================================================
+*/
+
+// get( TYPE, NAME );
+
+int CInterpreter::GetGet( CBlock *block )
+{
+	char	typeName[MAX_STRING_LENGTH];
+	int		type;
+
+	block->Write( ID_GET, (float) ID_GET );
+
+	if (!Match( TK_OPEN_PARENTHESIS ))
+		return Error("syntax error : '(' not found");
+
+	if ( GetType( (char *) typeName ) == false )
+		return false;
+
+	type = FindSymbol( typeName, m_typeKeywords);
+
+	switch ( type )
+	{
+	case TK_FLOAT:
+	case TK_INT:
+	case TK_VECTOR:
+	case TK_STRING:
+		block->Write( TK_FLOAT, (float) type );
+		break;
+
+	default:
+		return Error("unknown identifier %s", typeName );
+		break;
+	}
+
+	if ( GetString( block ) == false )
+		return false;
+
+	if (!Match( TK_CLOSED_PARENTHESIS ))
+		return Error("affect : too many parameters");
+
+	return true;
+}
+
+/*
+===================================================================================================
+
+  GetRandom()
+
+  Handles the random() function.
+
+===================================================================================================
+*/
+
+// random( low, high );
+
+int CInterpreter::GetRandom( CBlock *block )
+{
+	block->Write( ID_RANDOM, (float) ID_RANDOM );
+
+	if (!Match( TK_OPEN_PARENTHESIS ))
+		return Error("syntax error : '(' not found");
+
+	if ( GetFloat( block ) == false )
+		return false;
+
+	if ( GetFloat( block ) == false )
+		return false;
+
+	if (!Match( TK_CLOSED_PARENTHESIS ))
+		return Error("affect : too many parameters");
+
+	return true;
+}
+
+/*
+===================================================================================================
+
+  GetSound()
+
+  Handles the sound() function.
+
+===================================================================================================
+*/
+
+// sound( NAME );
+
+int CInterpreter::GetSound( void )
+{
+	CBlock	block;
+
+	block.Create( ID_SOUND );
+
+	if (!Match( TK_OPEN_PARENTHESIS ))
+		return Error("syntax error : '(' not found");
+
+	if ( GetIdentifier( &block ) == false )
+		return false;
+
+	if ( GetString( &block ) == false )
+		return false;
+
+	if (!Match( TK_CLOSED_PARENTHESIS ))
+		return Error("sound : too many parameters");
+
+	m_blockStream->WriteBlock( &block );
+
+	return true;
+}
+
+/*
+===================================================================================================
+
+  GetMove()
+
+  Handles the move() function.
+
+===================================================================================================
+*/
+
+// move( ORIGIN, ANGLES, DURATION );
+
+int CInterpreter::GetMove( void )
+{
+	CBlock	block;
+
+	block.Create( ID_MOVE );
+
+	if (!Match( TK_OPEN_PARENTHESIS ))
+		return Error("syntax error : '(' not found");
+
+	if ( GetVector( &block ) == false )
+		return false;
+
+	//Angles are optional
+	if ( LookAhead( TK_VECTOR_START ) || LookAhead( TK_IDENTIFIER ) )
+	{
+		if ( GetVector( &block ) == false )
+			return false;
+	}
+
+	if ( GetFloat( &block ) == false )
+		return false;
+
+	if (!Match( TK_CLOSED_PARENTHESIS ))
+		return Error("move : too many parameters");
+
+	m_blockStream->WriteBlock( &block );
+
+	return true;
+}
+
+/*
+===================================================================================================
+
+  GetRotate()
+
+  Handles the rotate() function.
+
+===================================================================================================
+*/
+
+// move( ANGLES, DURATION );
+
+int CInterpreter::GetRotate( void )
+{
+	CBlock	block;
+
+	block.Create( ID_ROTATE );
+
+	if (!Match( TK_OPEN_PARENTHESIS ))
+		return Error("syntax error : '(' not found");
+
+	if ( GetVector( &block ) == false )
+		return false;
+
+	if ( GetFloat( &block ) == false )
+		return false;
+
+	if (!Match( TK_CLOSED_PARENTHESIS ))
+		return Error("move : too many parameters");
+
+	m_blockStream->WriteBlock( &block );
+
+	return true;
+}
+
+/*
+===================================================================================================
+
+  GetAffect()
+
+  Handles the affect() function.
+
+===================================================================================================
+*/
+
+//FIXME:  This should be externally defined
+
+int CInterpreter::GetAffect( void )
+{
+	CBlock			block;
+	char			typeName[MAX_STRING_SIZE];
+	int				type;
+
+	block.Create( ID_AFFECT );
+
+	if (!Match( TK_OPEN_PARENTHESIS ))
+		return Error("syntax error : '(' not found");
+
+	if ( GetString( &block ) == false )	
+		return false;
+
+	if (!LookAhead( TK_IDENTIFIER ))
+		return Error("syntax error : identifier not found");
+
+	if ( MatchGet() )
+		return Error("syntax error : illegal use of \"get\"");
+
+	if ( GetType( (char *) typeName ) == false )
+		return false;
+
+	type = FindSymbol( typeName, m_typeKeywords);
+
+	switch ( type )
+	{
+	case TYPE_INSERT:
+	case TYPE_FLUSH:
+		
+		block.Write( TK_FLOAT, (float) type );
+		break;
+
+	default:
+		return Error("'%s': unknown affect type", typeName );
+		break;
+
+	}
+
+	if (!Match( TK_CLOSED_PARENTHESIS ))
+		return Error("affect : too many parameters");
+
+	if (!LookAhead( TK_BLOCK_START ))
+		return Error("syntax error : '{' not found");
+
+	m_blockStream->WriteBlock( &block );
+
+	return true;
+}
+
+/*
+===================================================================================================
+
+  GetWait()
+
+  Handles the wait() function.
+
+===================================================================================================
+*/
+
+//FIXME:  This should be externally defined
+
+int CInterpreter::GetWait( void )
+{
+	CBlock			block;
+
+	block.Create( ID_WAIT );
+
+	if (!Match( TK_OPEN_PARENTHESIS ))
+		return Error("syntax error : '(' not found");
+
+	if ( LookAhead( TK_STRING ) )
+	{
+		if ( GetString( &block ) == false )
+			return false;
+	}
+	else
+	{
+		if ( GetFloat( &block ) == false )
+			return false;
+	}
+
+	if (!Match( TK_CLOSED_PARENTHESIS ))
+		return Error("wait : too many parameters");
+
+	m_blockStream->WriteBlock( &block );
+
+	return true;
+}
+
+/*
+===================================================================================================
+
+  GetSet()
+
+  Handles the set() function.
+
+===================================================================================================
+*/
+
+//FIXME:  This should be externally defined
+
+int CInterpreter::GetSet( void )
+{
+	CBlock		block;
+
+	block.Create( ID_SET );
+
+	if (!Match( TK_OPEN_PARENTHESIS ))
+		return Error("syntax error : '(' not found");
+
+	if ( GetString( &block ) == false )
+		return false;
+
+	//Check for get placement
+	if ( MatchGet() )
+	{
+		if ( GetGet( &block ) == false )
+			return false;
+	}
+	else
+	{
+		switch( GetNextType() )
+		{
+		case TK_INT:
+			
+			if ( GetInteger( &block ) == false )
+				return false;
+
+			break;
+
+		case TK_FLOAT:
+
+			if ( GetFloat( &block ) == false )
+				return false;
+
+			break;
+
+		case TK_STRING:
+			
+			if ( GetString( &block ) == false )
+				return false;
+
+			break;
+
+		case TK_VECTOR_START:
+
+			if ( GetVector( &block ) == false )
+				return false;
+
+			break;
+		
+		default:
+
+			if ( MatchTag() )
+			{
+				GetTag( &block );
+				break;
+			}
+			
+			if ( MatchRandom() )
+			{
+				GetRandom( &block );
+				break;
+			}
+
+			return Error("unknown parameter type");
+			break;
+		}
+	}
+
+	if (!Match( TK_CLOSED_PARENTHESIS ))
+		return Error("set : too many parameters");
+
+	m_blockStream->WriteBlock( &block );
+
+	return true;
+}
+
+/*
+===================================================================================================
+
+  GetLoop()
+
+  Handles the loop() function.
+
+===================================================================================================
+*/
+
+int CInterpreter::GetLoop( void )
+{
+	CBlock			block;
+
+	block.Create( ID_LOOP );
+
+	if (!Match( TK_OPEN_PARENTHESIS ))
+		return Error("syntax error : '(' not found");
+
+	if ( LookAhead( TK_CLOSED_PARENTHESIS ) )
+	{
+		//-1 denotes an infinite loop
+		block.Write( TK_FLOAT, (float) -1);
+	}
+	else
+	{
+		if ( GetInteger( &block ) == false )
+			return false;
+	}
+
+	if (!Match( TK_CLOSED_PARENTHESIS ))
+		return Error("GetLoop : too many parameters");
+
+	m_blockStream->WriteBlock( &block );
+
+	return true;
+}
+
+/*
+===================================================================================================
+
+  GetPrint()
+
+  Handles the print() function.
+
+===================================================================================================
+*/
+
+int CInterpreter::GetPrint( void )
+{
+	CBlock			block;
+
+	block.Create( ID_PRINT );
+
+	if (!Match( TK_OPEN_PARENTHESIS ))
+		return Error("syntax error : '(' not found");
+
+	if ( GetString( &block ) == false )
+		return false;
+
+	if (!Match( TK_CLOSED_PARENTHESIS ))
+		return Error("print : too many parameters");
+
+	m_blockStream->WriteBlock( &block );
+
+	return true;
+}
+
+/*
+===================================================================================================
+
+  GetUse()
+
+  Handles the use() function.
+
+===================================================================================================
+*/
+
+int CInterpreter::GetUse( void )
+{
+	CBlock			block;
+
+	block.Create( ID_USE );
+
+	if (!Match( TK_OPEN_PARENTHESIS ))
+		return Error("syntax error : '(' not found");
+
+	if ( GetString( &block ) == false )
+		return false;
+
+	if (!Match( TK_CLOSED_PARENTHESIS ))
+		return Error("use : too many parameters");
+
+	m_blockStream->WriteBlock( &block );
+
+	return true;
+}
+
+/*
+===================================================================================================
+
+  GetFlush()
+
+  Handles the flush() function.
+
+===================================================================================================
+*/
+
+int CInterpreter::GetFlush( void )
+{
+	CBlock	block;
+
+	block.Create( ID_FLUSH );
+
+	if (!Match( TK_OPEN_PARENTHESIS ))
+		return Error("syntax error : '(' not found");
+
+	if (!Match( TK_CLOSED_PARENTHESIS ))
+		return Error("flush : too many parameters");
+
+	m_blockStream->WriteBlock( &block );
+
+	return true;
+}
+
+/*
+===================================================================================================
+
+  GetRun()
+
+  Handles the run() function.
+
+===================================================================================================
+*/
+
+int CInterpreter::GetRun( void )
+{
+	CBlock	block;
+
+	block.Create( ID_RUN );
+
+	if (!Match( TK_OPEN_PARENTHESIS ))
+		return Error("syntax error : '(' not found");
+
+	if ( GetString( &block ) == false )
+		return false;
+
+	if (!Match( TK_CLOSED_PARENTHESIS ))
+		return Error("run : too many parameters");
+
+	m_blockStream->WriteBlock( &block );
+
+	return true;
+}
+
+/*
+===================================================================================================
+
+  GetKill()
+
+  Handles the kill() function.
+
+===================================================================================================
+*/
+
+int CInterpreter::GetKill( void )
+{
+	CBlock	block;
+
+	block.Create( ID_KILL );
+
+	if (!Match( TK_OPEN_PARENTHESIS ))
+		return Error("syntax error : '(' not found");
+
+	if ( GetString( &block ) == false )
+		return false;
+
+	if (!Match( TK_CLOSED_PARENTHESIS ))
+		return Error("kill : too many parameters");
+
+	m_blockStream->WriteBlock( &block );
+
+	return true;
+}
+
+/*
+===================================================================================================
+
+  GetRemove()
+
+  Handles the remove() function.
+
+===================================================================================================
+*/
+
+int CInterpreter::GetRemove( void )
+{
+	CBlock	block;
+
+	block.Create( ID_REMOVE );
+
+	if (!Match( TK_OPEN_PARENTHESIS ))
+		return Error("syntax error : '(' not found");
+
+	if ( GetString( &block ) == false )
+		return false;
+
+	if (!Match( TK_CLOSED_PARENTHESIS ))
+		return Error("remove : too many parameters");
+
+	m_blockStream->WriteBlock( &block );
+
+	return true;
+}
+
+/*
+===================================================================================================
+
+  GetRem()
+
+  Handles the rem() function.
+
+===================================================================================================
+*/
+
+// this is just so people can put comments in scripts in BehavEd and not have them lost as normal comments would be.
+//
+int CInterpreter::GetRem( void )
+{	
+	CBlock	block;
+
+	block.Create( ID_REM );
+
+	if (!Match( TK_OPEN_PARENTHESIS ))
+		return Error("syntax error : '(' not found");
+
+	// optional string?
+
+	if (Match( TK_CLOSED_PARENTHESIS ))
+		return true;
+
+	GetString( &block );	
+
+	if (!Match( TK_CLOSED_PARENTHESIS ))
+		return Error("rem : function only takes 1 optional parameter");
+
+	return true;
+}
+
+
+/*
+===================================================================================================
+
+  GetCamera()
+
+  Handles the camera() function.
+
+===================================================================================================
+*/
+
+int CInterpreter::GetCamera( void )
+{
+	CBlock	block;
+	char	typeName[MAX_STRING_SIZE];
+	int		type;
+
+	block.Create( ID_CAMERA );
+
+	if (!Match( TK_OPEN_PARENTHESIS ))
+		return Error("syntax error : '(' not found");
+
+	if ( GetType( (char *) typeName ) == false )
+		return false;
+
+	type = FindSymbol( typeName, m_typeKeywords);
+
+	switch ( type )
+	{
+	case TYPE_PAN:		//PAN  ( ANGLES, DURATION )
+
+		block.Write( TK_FLOAT, (float) type );
+
+		if ( GetVector( &block ) == false )
+			return false;
+
+		if ( GetVector( &block ) == false )
+			return false;
+
+		if ( GetFloat( &block ) == false )
+			return false;
+
+		break;
+
+	case TYPE_ZOOM:		//ZOOM ( FOV, DURATION )
+		
+		block.Write( TK_FLOAT, (float) type );
+
+		if ( GetFloat( &block ) == false )
+			return false;
+		
+		if ( GetFloat( &block ) == false )
+			return false;
+
+		break;
+	
+	case TYPE_MOVE:		//MOVE ( ORIGIN, DURATION )
+
+		block.Write( TK_FLOAT, (float) type );
+
+		if ( GetVector( &block ) == false )
+			return false;
+
+		if ( GetFloat( &block ) == false )
+			return false;
+
+		break;
+	
+	case TYPE_FADE:		//FADE ( SOURCE(R,G,B,A), DEST(R,G,B,A), DURATION )
+		
+		block.Write( TK_FLOAT, (float) type );
+
+		//Source color
+		if ( GetVector( &block ) == false )
+			return false;
+		if ( GetFloat( &block ) == false )
+			return false;
+
+		//Dest color
+		if ( GetVector( &block ) == false )
+			return false;
+		if ( GetFloat( &block ) == false )
+			return false;
+
+		//Duration
+		if ( GetFloat( &block ) == false )
+			return false;
+
+		break;
+
+	case TYPE_PATH:		//PATH ( FILENAME )
+
+		block.Write( TK_FLOAT, (float) type );
+
+		//Filename
+		if ( GetString( &block ) == false )
+			return false;
+
+		break;
+
+	case TYPE_ENABLE:
+	case TYPE_DISABLE:
+
+		block.Write( TK_FLOAT, (float) type );
+		break;
+
+	case TYPE_SHAKE:	//SHAKE ( INTENSITY, DURATION )
+
+		block.Write( TK_FLOAT, (float) type );
+
+		//Intensity
+		if ( GetFloat( &block ) == false )
+			return false;
+
+		//Duration
+		if ( GetFloat( &block ) == false )
+			return false;
+
+		break;
+
+	case TYPE_ROLL:		//ROLL ( ANGLE, TIME )
+
+		block.Write( TK_FLOAT, (float) type );
+
+		//Angle
+		if ( GetFloat( &block ) == false )
+			return false;
+
+		//Time
+		if ( GetFloat( &block ) == false )
+			return false;
+
+		break;
+
+	case TYPE_TRACK:	//TRACK ( TARGETNAME, SPEED, INITLERP )
+
+		block.Write( TK_FLOAT, (float) type );
+
+		//Target name
+		if ( GetString( &block ) == false )
+			return false;
+
+		//Speed
+		if ( GetFloat( &block ) == false )
+			return false;
+
+		//Init lerp
+		if ( GetFloat( &block ) == false )
+			return false;
+
+		break;
+
+	case TYPE_FOLLOW:	//FOLLOW ( CAMERAGROUP, SPEED, INITLERP )
+
+		block.Write( TK_FLOAT, (float) type );
+
+		//Camera group
+		if ( GetString( &block ) == false )
+			return false;
+
+		//Speed
+		if ( GetFloat( &block ) == false )
+			return false;
+
+		//Init lerp
+		if ( GetFloat( &block ) == false )
+			return false;
+
+		break;
+
+	case TYPE_DISTANCE:	//DISTANCE ( DISTANCE, INITLERP )
+
+		block.Write( TK_FLOAT, (float) type );
+
+		//Distance
+		if ( GetFloat( &block ) == false )
+			return false;
+
+		//Init lerp
+		if ( GetFloat( &block ) == false )
+			return false;
+
+		break;
+	}
+
+	if (!Match( TK_CLOSED_PARENTHESIS ))
+		return Error("camera : too many parameters");
+
+	m_blockStream->WriteBlock( &block );
+
+	return true;
+}
+
+/*
+-------------------------
+GetDoWait
+-------------------------
+*/
+
+int CInterpreter::GetDoWait( void )
+{
+	CBlock	block;
+
+	//Write out the "do" portion
+	block.Create( ID_DO );
+
+	if (!Match( TK_OPEN_PARENTHESIS ))
+		return Error("syntax error : '(' not found");
+
+	if ( GetString( &block ) == false )
+		return false;
+
+	if (!Match( TK_CLOSED_PARENTHESIS ))
+		return Error("do : too many parameters");
+
+	//Write out the accompanying "wait"
+	char	*str = (char *) block.GetMemberData( 0 );
+
+	CBlock	block2;
+
+	block2.Create( ID_WAIT );
+
+	block2.Write( TK_STRING, (char *) str );
+
+	m_blockStream->WriteBlock( &block );
+	m_blockStream->WriteBlock( &block2 );
+
+	return true;
+}
+
+/*
+-------------------------
+GetSignal
+-------------------------
+*/
+
+int CInterpreter::GetSignal( void )
+{
+	CBlock			block;
+
+	block.Create( ID_SIGNAL );
+
+	if (!Match( TK_OPEN_PARENTHESIS ))
+		return Error("syntax error : '(' not found");
+
+	if ( GetString( &block ) == false )
+		return false;
+
+	if (!Match( TK_CLOSED_PARENTHESIS ))
+		return Error("signal : too many parameters");
+
+	m_blockStream->WriteBlock( &block );
+
+	return true;
+}
+
+/*
+-------------------------
+GetSignal
+-------------------------
+*/
+
+int CInterpreter::GetWaitSignal( void )
+{
+	CBlock			block;
+
+	block.Create( ID_WAITSIGNAL );
+
+	if (!Match( TK_OPEN_PARENTHESIS ))
+		return Error("syntax error : '(' not found");
+
+	if ( GetString( &block ) == false )
+		return false;
+
+	if (!Match( TK_CLOSED_PARENTHESIS ))
+		return Error("waitsignal : too many parameters");
+
+	m_blockStream->WriteBlock( &block );
+
+	return true;
+}
+
+/*
+-------------------------
+GetPlay
+-------------------------
+*/
+
+int CInterpreter::GetPlay( void )
+{
+	CBlock			block;
+
+	block.Create( ID_PLAY );
+
+	if (!Match( TK_OPEN_PARENTHESIS ))
+		return Error("syntax error : '(' not found");
+
+	if ( GetString( &block ) == false )
+		return false;
+
+	if ( GetString( &block ) == false )
+		return false;
+
+	if (!Match( TK_CLOSED_PARENTHESIS ))
+		return Error("waitsignal : too many parameters");
+
+	m_blockStream->WriteBlock( &block );
+
+	return true;
+}
+
+/*
+===================================================================================================
+
+  GetTag()
+
+  Handles the tag() identifier.
+
+===================================================================================================
+*/
+
+//NOTENOTE: The tag's information is included as block members, not as a separate block.
+
+int CInterpreter::GetTag( CBlock *block )
+{
+	char	typeName[MAX_STRING_SIZE];
+	int		typeID;
+
+	//Mark as a tag
+	block->Write( ID_TAG, (float) ID_TAG );
+
+	if (!Match( TK_OPEN_PARENTHESIS ))
+		return Error("syntax error : '(' not found");
+
+	//Get the tag name
+	if ( GetString( block ) == false )
+		return false;
+
+	//Get the lookup ID
+	GetType( (char *) typeName );
+
+	typeID = FindSymbol( (char *) typeName, m_typeKeywords);
+
+	//Tags only contain origin and angles lookups
+	if ( (typeID != TYPE_ORIGIN) && (typeID != TYPE_ANGLES) )
+	{
+		return Error("syntax error : 'tag' : %s is not a valid look up identifier", typeName );
+	}
+
+	block->Write( TK_FLOAT, (float) typeID );
+
+	if (!Match( TK_CLOSED_PARENTHESIS ))
+		return Error("tag : too many parameters");
+
+	return true;
+}
+
+/*
+===================================================================================================
+
+	Interpret function
+
+===================================================================================================
+*/
+
+// note new return type, this now returns the bad block number, else 0 for success.
+//
+//  I also return -ve block numbers for errors between blocks. Eg if you read 3 good blocks, then find an unexpected
+//		float in the script between blocks 3 & 4 then I return -3 to indicate the error is after that, but not block 4
+//
+int	CInterpreter::Interpret( CTokenizer *Tokenizer, CBlockStream *BlockStream, char *filename )
+{
+	CBlock		block;
+	CToken		*token;
+	int			type, blockLevel = 0, parenthesisLevel = 0;
+
+	m_sCurrentFile	= filename;		// used during error reporting because you can't ask tokenizer for pushed streams
+	
+	m_tokenizer		= Tokenizer;
+	m_blockStream	= BlockStream;
+
+	m_iCurrentLine = m_tokenizer->GetCurLine();
+	token = m_tokenizer->GetToEndOfLine(TK_STRING);		
+	m_sCurrentLine = token->GetStringValue();	
+	m_tokenizer->PutBackToken(token, false, NULL, true);
+	
+	m_iBadCBlockNumber = 0;
+
+	while (m_tokenizer->GetRemainingSize() > 0)
+	{
+		token = m_tokenizer->GetToken( TKF_USES_EOL, 0 );
+		type = token->GetType();
+
+		switch ( type )
+		{
+		case TK_UNDEFINED:
+			token->Delete();
+			m_iBadCBlockNumber = -m_iBadCBlockNumber;
+			Error("%d : undefined token", type);
+			return m_iBadCBlockNumber;
+			break;
+
+		case TK_EOF:
+			break;
+
+		case TK_EOL:
+			// read the next line, then put it back
+			token->Delete();
+			m_iCurrentLine = m_tokenizer->GetCurLine();
+			token = m_tokenizer->GetToEndOfLine(TK_STRING);			
+			m_sCurrentLine = token->GetStringValue();				
+			m_tokenizer->PutBackToken(token, false, NULL, true);
+			break;
+		
+		case TK_CHAR:
+		case TK_STRING:
+			token->Delete();
+			m_iBadCBlockNumber = -m_iBadCBlockNumber;
+			Error("syntax error : unexpected string");
+			return m_iBadCBlockNumber;
+			break;
+		
+		case TK_INT:
+			token->Delete();
+			m_iBadCBlockNumber = -m_iBadCBlockNumber;		
+			Error("syntax error : unexpected integer");
+			return m_iBadCBlockNumber;
+			break;
+		
+		case TK_FLOAT:
+			token->Delete();
+			m_iBadCBlockNumber = -m_iBadCBlockNumber;
+			Error("syntax error : unexpected float");
+			return m_iBadCBlockNumber;
+			break;
+		
+		case TK_IDENTIFIER:
+			m_iBadCBlockNumber++;
+			if (!GetID( (char *) token->GetStringValue() ))
+			{
+				token->Delete();
+				return m_iBadCBlockNumber;
+			}
+			token->Delete();
+			break;
+		
+		case TK_BLOCK_START:
+			token->Delete();
+			if (parenthesisLevel)
+			{
+				m_iBadCBlockNumber = -m_iBadCBlockNumber;
+				Error("syntax error : brace inside parenthesis");
+				return m_iBadCBlockNumber;
+			}
+
+			blockLevel++;
+			break;
+
+		case TK_BLOCK_END:
+			token->Delete();
+			if (parenthesisLevel)
+			{
+				m_iBadCBlockNumber = -m_iBadCBlockNumber;
+				Error("syntax error : brace inside parenthesis");
+				return m_iBadCBlockNumber;
+			}
+			
+			block.Create( ID_BLOCK_END );
+			m_blockStream->WriteBlock( &block );
+			block.Free();
+
+			blockLevel--;
+			break;
+
+		case TK_OPEN_PARENTHESIS:
+			token->Delete();
+			blockLevel++;
+			parenthesisLevel++;
+			break;
+
+		case TK_CLOSED_PARENTHESIS:
+			token->Delete();
+			blockLevel--;
+			parenthesisLevel--;
+
+			if (parenthesisLevel<0)
+			{
+				m_iBadCBlockNumber = -m_iBadCBlockNumber;
+				Error("syntax error : closed parenthesis with no opening match");
+				return m_iBadCBlockNumber;
+			}
+			break;
+
+		case TK_VECTOR_START:
+			token->Delete();
+			m_iBadCBlockNumber = -m_iBadCBlockNumber;
+			Error("syntax error : unexpected vector");
+			return m_iBadCBlockNumber;
+			break;
+
+		case TK_VECTOR_END:
+			token->Delete();
+			m_iBadCBlockNumber = -m_iBadCBlockNumber;
+			Error("syntax error : unexpected vector");
+			return m_iBadCBlockNumber;
+			break;
+		}
+	}
+
+	if ( blockLevel )
+	{
+		m_iBadCBlockNumber = -m_iBadCBlockNumber;
+		Error("error : open brace was not closed");
+		return m_iBadCBlockNumber;
+	}
+
+	if ( parenthesisLevel )
+	{
+		m_iBadCBlockNumber = -m_iBadCBlockNumber;
+		Error("error: open parenthesis");
+		return m_iBadCBlockNumber;
+	}
+
+	//Release all the variable information, because it's already been written out
+	FreeVars();
+
+	m_iBadCBlockNumber = 0;
+	return m_iBadCBlockNumber;	//true;
+}
+
diff --git a/codemp/icarus/Memory.cpp b/codemp/icarus/Memory.cpp
new file mode 100644
index 0000000..ef41be4
--- /dev/null
+++ b/codemp/icarus/Memory.cpp
@@ -0,0 +1,20 @@
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+#include "icarus.h"
+
+// leave these two as standard mallocs for the moment, there's something weird happening in ICARUS...
+//
+void *ICARUS_Malloc(int iSize)
+{
+	//return gi.Malloc(iSize, TAG_ICARUS);
+	//return malloc(iSize);
+	return Z_Malloc(iSize, TAG_ICARUS5, qfalse);
+}
+
+void ICARUS_Free(void *pMem)
+{
+	//gi.Free(pMem);
+	//free(pMem);
+	Z_Free(pMem);
+}
diff --git a/codemp/icarus/Q3_Interface.cpp b/codemp/icarus/Q3_Interface.cpp
new file mode 100644
index 0000000..afa2798
--- /dev/null
+++ b/codemp/icarus/Q3_Interface.cpp
@@ -0,0 +1,1013 @@
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+// ICARUS Engine Interface File
+//
+//	This file is the only section of the ICARUS systems that 
+//	is not directly portable from engine to engine.
+//
+//	-- jweier
+
+#include "../game/g_public.h"
+#include "../server/server.h"
+#include "interface.h"
+#include "GameInterface.h"
+#include "Q3_Interface.h"
+#include "Q3_Registers.h"
+
+#define stringIDExpand(str, strEnum)	str, strEnum, ENUM2STRING(strEnum)
+//#define stringIDExpand(str, strEnum)	str,strEnum
+
+/*
+stringID_table_t tagsTable [] = 
+{
+}
+*/
+
+//rwwFIXEFIXME: Put somewhere else
+inline float Q_flrand(float min, float max) {
+	return ((rand() * (max - min)) / 32768.0F) + min;
+}
+
+qboolean COM_ParseString( char **data, char **s ); 
+
+//=======================================================================
+
+interface_export_t	interface_export;
+
+
+/*
+============
+Q3_ReadScript
+  Description	: Reads in a file and attaches the script directory properly
+  Return type	: static int 
+  Argument		: const char *name
+  Argument		: void **buf
+============
+*/
+extern int ICARUS_GetScript( const char *name, char **buf );	//g_icarus.cpp
+static int Q3_ReadScript( const char *name, void **buf )
+{
+	return ICARUS_GetScript( va( "%s/%s", Q3_SCRIPT_DIR, name ), (char**)buf );	//get a (hopefully) cached file
+}
+
+/*
+============
+Q3_CenterPrint 
+  Description	: Prints a message in the center of the screen
+  Return type	: static void 
+  Argument		:  const char *format
+  Argument		: ...
+============
+*/
+static void Q3_CenterPrint ( const char *format, ... )
+{
+
+	va_list		argptr;
+	char		text[1024];
+
+	va_start (argptr, format);
+	vsprintf (text, format, argptr);
+	va_end (argptr);
+
+	// FIXME: added '!' so you can print something that's hasn't been precached, '@' searches only for precache text
+	// this is just a TEMPORARY placeholder until objectives are in!!!  -- dmv 11/26/01
+
+	if ((text[0] == '@') || text[0] == '!')	// It's a key
+	{
+		if( text[0] == '!')
+		{
+			SV_SendServerCommand( NULL, "cp \"%s\"", (text+1) );
+			return;
+		}
+
+		SV_SendServerCommand( NULL, "cp \"%s\"", text );
+	}
+
+	Q3_DebugPrint( WL_VERBOSE, "%s\n", text); 	// Just a developers note
+
+	return;
+}
+
+
+/*
+-------------------------
+void Q3_ClearTaskID( int *taskID )
+
+WARNING: Clearing a taskID will make that task never finish unless you intend to
+			return the same taskID from somewhere else.
+-------------------------
+*/
+#ifndef _XBOX	// We borrow the one in g_ICARUScb.c
+void Q3_TaskIDClear( int *taskID )
+{
+	*taskID = -1;
+}
+#endif
+
+/*
+-------------------------
+qboolean Q3_TaskIDPending( sharedEntity_t *ent, taskID_t taskType )
+-------------------------
+*/
+qboolean Q3_TaskIDPending( sharedEntity_t *ent, taskID_t taskType )
+{
+	if ( !gSequencers[ent->s.number] || !gTaskManagers[ent->s.number] )
+	{
+		return qfalse;
+	}
+
+	if ( taskType < TID_CHAN_VOICE || taskType >= NUM_TIDS )
+	{
+		return qfalse;
+	}
+
+	if ( ent->taskID[taskType] >= 0 )//-1 is none
+	{
+		return qtrue;
+	}
+
+	return qfalse;
+}
+
+/*
+-------------------------
+void Q3_TaskIDComplete( sharedEntity_t *ent, taskID_t taskType )
+-------------------------
+*/
+void Q3_TaskIDComplete( sharedEntity_t *ent, taskID_t taskType )
+{
+	if ( taskType < TID_CHAN_VOICE || taskType >= NUM_TIDS )
+	{
+		return;
+	}
+
+	if ( gTaskManagers[ent->s.number] && Q3_TaskIDPending( ent, taskType ) )
+	{//Complete it
+		gTaskManagers[ent->s.number]->Completed( ent->taskID[taskType] );
+
+		//See if any other tasks have the name number and clear them so we don't complete more than once
+		int	clearTask = ent->taskID[taskType];
+		for ( int tid = 0; tid < NUM_TIDS; tid++ )
+		{
+			if ( ent->taskID[tid] == clearTask )
+			{
+				Q3_TaskIDClear( &ent->taskID[tid] );
+			}
+		}
+
+		//clear it - should be cleared in for loop above
+		//Q3_TaskIDClear( &ent->taskID[taskType] );
+	}
+	//otherwise, wasn't waiting for a task to complete anyway
+}
+
+/*
+-------------------------
+void Q3_SetTaskID( sharedEntity_t *ent, taskID_t taskType, int taskID )
+-------------------------
+*/
+
+void Q3_TaskIDSet( sharedEntity_t *ent, taskID_t taskType, int taskID )
+{
+	if ( taskType < TID_CHAN_VOICE || taskType >= NUM_TIDS )
+	{
+		return;
+	}
+
+	//Might be stomping an old task, so complete and clear previous task if there was one
+	Q3_TaskIDComplete( ent, taskType );
+
+	ent->taskID[taskType] = taskID;
+}
+
+
+/*
+============
+Q3_CheckStringCounterIncrement
+  Description	: 
+  Return type	: static float 
+  Argument		: const char *string
+============
+*/
+static float Q3_CheckStringCounterIncrement( const char *string )
+{
+	char	*numString;
+	float	val = 0.0f;
+
+	if ( string[0] == '+' )
+	{//We want to increment whatever the value is by whatever follows the +
+		if ( string[1] )
+		{
+			numString = (char *)&string[1];
+			val = atof( numString );
+		}
+	}
+	else if ( string[0] == '-' )
+	{//we want to decrement
+		if ( string[1] )
+		{
+			numString = (char *)&string[1];
+			val = atof( numString ) * -1;
+		}
+	}
+
+	return val;
+}
+
+/*
+=============
+Q3_GetEntityByName
+
+Returns the sequencer of the entity by the given name
+=============
+*/
+static sharedEntity_t *Q3_GetEntityByName( const char *name )
+{
+	sharedEntity_t				*ent;
+	entlist_t::iterator		ei;
+	char					temp[1024];
+
+	if ( name == NULL || name[0] == NULL )
+		return NULL;
+
+	strncpy( (char *) temp, name, sizeof(temp) );
+	temp[sizeof(temp)-1] = 0;
+
+	ei = ICARUS_EntList.find( Q_strupr( (char *) temp ) );
+
+	if ( ei == ICARUS_EntList.end() )
+		return NULL;
+
+	ent = SV_GentityNum((*ei).second);
+
+	return ent;
+	// this now returns the ent instead of the sequencer -- dmv 06/27/01
+//	if (ent == NULL)
+//		return NULL;
+//	return gSequencers[ent->s.number];
+}
+
+/*
+=============
+Q3_GetTime
+
+Get the current game time
+=============
+*/
+static DWORD Q3_GetTime( void )
+{
+	return svs.time;
+}
+
+/*
+=============
+G_AddSexToMunroString
+
+Take any string, look for "kyle/" replace with "kyla/" based on "sex"
+And: Take any string, look for "/mr_" replace with "/ms_" based on "sex" 
+returns qtrue if changed to ms
+=============
+*/
+/*
+static qboolean G_AddSexToMunroString ( char *string, qboolean qDoBoth )
+{
+	char *start;
+
+	if VALIDSTRING( string ) {
+		if ( g_sex->string[0] == 'f' ) {
+			start = strstr( string, "kyle/" );
+			if ( start != NULL ) {
+				strncpy( start, "kyla", 5 );
+				return qtrue;
+			} else {
+				start = strrchr( string, '/' );		//get the last slash before the wav
+				if (start != NULL) {
+					if (!strncmp( start, "/mr_", 4) ) {
+						if (qDoBoth) {	//we want to change mr to ms
+							start[2] = 's';	//change mr to ms
+							return qtrue;
+						} else {	//IF qDoBoth
+							return qfalse;	//don't want this one
+						}
+					}
+				}	//IF found slash
+			}
+		}	//IF Female
+		else {	//i'm male
+			start = strrchr( string, '/' );		//get the last slash before the wav
+			if (start != NULL) {
+				if (!strncmp( start, "/ms_", 4) ) {
+					return qfalse;	//don't want this one
+				}
+			}	//IF found slash
+		}
+	}	//if VALIDSTRING
+	return qtrue;
+}
+*/
+
+/*
+=============
+Q3_PlaySound
+
+Plays a sound from an entity
+=============
+*/
+static int Q3_PlaySound( int taskID, int entID, const char *name, const char *channel )
+{
+	T_G_ICARUS_PLAYSOUND *sharedMem = (T_G_ICARUS_PLAYSOUND *)sv.mSharedMemory;
+
+	sharedMem->taskID = taskID;
+	sharedMem->entID = entID;
+	strcpy(sharedMem->name, name);
+	strcpy(sharedMem->channel, channel);
+
+	return VM_Call(gvm, GAME_ICARUS_PLAYSOUND);
+}
+
+
+/*
+============
+Q3_SetVar
+  Description	: 
+  Return type	: static void 
+  Argument		:  int taskID
+  Argument		: int entID
+  Argument		: const char *type_name
+  Argument		: const char *data
+============
+*/
+void Q3_SetVar( int taskID, int entID, const char *type_name, const char *data )
+{
+	int	vret = Q3_VariableDeclared( type_name ) ;
+	float	float_data;
+	float	val = 0.0f;
+
+	
+	if ( vret != VTYPE_NONE )
+	{
+		switch ( vret )
+		{
+		case VTYPE_FLOAT:
+			//Check to see if increment command
+			if ( (val = Q3_CheckStringCounterIncrement( data )) )
+			{
+				Q3_GetFloatVariable( type_name, &float_data );
+				float_data += val;
+			}
+			else
+			{
+				float_data = atof((char *) data);
+			}
+			Q3_SetFloatVariable( type_name, float_data );
+			break;
+
+		case VTYPE_STRING:
+			Q3_SetStringVariable( type_name, data );
+			break;
+
+		case VTYPE_VECTOR:
+			Q3_SetVectorVariable( type_name, (char *) data );
+			break;
+		}
+
+		return;
+	}
+
+	Q3_DebugPrint( WL_ERROR, "%s variable or field not found!\n", type_name );
+}
+
+/*
+============
+Q3_Set
+  Description	: 
+  Return type	: void 
+  Argument		:  int taskID
+  Argument		: int entID
+  Argument		: const char *type_name
+  Argument		: const char *data
+============
+*/
+static void Q3_Set( int taskID, int entID, const char *type_name, const char *data )
+{
+	T_G_ICARUS_SET *sharedMem = (T_G_ICARUS_SET *)sv.mSharedMemory;
+
+	sharedMem->taskID = taskID;
+	sharedMem->entID = entID;
+	strcpy(sharedMem->type_name, type_name);
+	strcpy(sharedMem->data, data);
+
+	if (VM_Call(gvm, GAME_ICARUS_SET))
+	{
+		gTaskManagers[entID]->Completed( taskID );
+	}
+}
+
+
+/*
+============
+Q3_Evaluate
+  Description	: 
+  Return type	: int 
+  Argument		:  int p1Type
+  Argument		: const char *p1
+  Argument		: int p2Type
+  Argument		: const char *p2
+  Argument		: int operatorType
+============
+*/
+static int Q3_Evaluate( int p1Type, const char *p1, int p2Type, const char *p2, int operatorType )
+{
+	float	f1=0, f2=0;
+	vec3_t	v1, v2;
+	char	*c1=0, *c2=0;
+	int		i1=0, i2=0;
+
+	//Always demote to int on float to integer comparisons
+	if ( ( ( p1Type == TK_FLOAT ) && ( p2Type == TK_INT ) ) || ( ( p1Type == TK_INT ) && ( p2Type == TK_FLOAT ) ) )
+	{
+		p1Type = TK_INT;
+		p2Type = TK_INT;
+	}
+
+	//Cannot compare two disimilar types
+	if ( p1Type != p2Type )
+	{
+		Q3_DebugPrint( WL_ERROR, "Q3_Evaluate comparing two disimilar types!\n");
+		return false;
+	}
+
+	//Format the parameters
+	switch ( p1Type )
+	{
+	case TK_FLOAT:
+		sscanf( p1, "%f", &f1 );
+		sscanf( p2, "%f", &f2 );
+		break;
+
+	case TK_INT:
+		sscanf( p1, "%d", &i1 );
+		sscanf( p2, "%d", &i2 );
+		break;
+
+	case TK_VECTOR:
+		sscanf( p1, "%f %f %f", &v1[0], &v1[1], &v1[2] );
+		sscanf( p2, "%f %f %f", &v2[0], &v2[1], &v2[2] );
+		break;
+
+	case TK_STRING:
+	case TK_IDENTIFIER:
+		c1 = (char *) p1;
+		c2 = (char *) p2;
+		break;
+
+	default:
+		Q3_DebugPrint( WL_WARNING, "Q3_Evaluate unknown type used!\n");
+		return false;
+	}
+
+	//Compare them and return the result
+
+	//FIXME: YUCK!!!  Better way to do this?
+
+	switch ( operatorType )
+	{
+
+	//
+	//	EQUAL TO
+	//
+
+	case TK_EQUALS:
+
+		switch ( p1Type )
+		{
+		case TK_FLOAT:
+			return (int) ( f1 == f2 );
+			break;
+
+		case TK_INT:
+			return (int) ( i1 == i2 );
+			break;
+
+		case TK_VECTOR:
+			return (int) VectorCompare( v1, v2 );
+			break;
+
+		case TK_STRING:
+		case TK_IDENTIFIER:
+			return (int) !stricmp( c1, c2 );	//NOTENOTE: The script uses proper string comparison logic (ex. ( a == a ) == true )
+			break;
+
+		default:
+			Q3_DebugPrint( WL_ERROR, "Q3_Evaluate unknown type used!\n");
+			return false;
+		}
+
+		break;
+
+	//
+	//	GREATER THAN
+	//
+
+	case TK_GREATER_THAN:
+
+		switch ( p1Type )
+		{
+		case TK_FLOAT:
+			return (int) ( f1 > f2 );
+			break;
+
+		case TK_INT:
+			return (int) ( i1 > i2 );
+			break;
+
+		case TK_VECTOR:
+			Q3_DebugPrint( WL_ERROR, "Q3_Evaluate vector comparisons of type GREATER THAN cannot be performed!");
+			return false;
+			break;
+
+		case TK_STRING:
+		case TK_IDENTIFIER:
+			Q3_DebugPrint( WL_ERROR, "Q3_Evaluate string comparisons of type GREATER THAN cannot be performed!");
+			return false;
+			break;
+
+		default:
+			Q3_DebugPrint( WL_ERROR, "Q3_Evaluate unknown type used!\n");
+			return false;
+		}
+
+		break;
+
+	//
+	//	LESS THAN
+	//
+
+	case TK_LESS_THAN:
+
+		switch ( p1Type )
+		{
+		case TK_FLOAT:
+			return (int) ( f1 < f2 );
+			break;
+
+		case TK_INT:
+			return (int) ( i1 < i2 );
+			break;
+
+		case TK_VECTOR:
+			Q3_DebugPrint( WL_ERROR, "Q3_Evaluate vector comparisons of type LESS THAN cannot be performed!");
+			return false;
+			break;
+
+		case TK_STRING:
+		case TK_IDENTIFIER:
+			Q3_DebugPrint( WL_ERROR, "Q3_Evaluate string comparisons of type LESS THAN cannot be performed!");
+			return false;
+			break;
+
+		default:
+			Q3_DebugPrint( WL_ERROR, "Q3_Evaluate unknown type used!\n");
+			return false;
+		}
+
+		break;
+
+	//
+	//	NOT
+	//
+
+	case TK_NOT:	//NOTENOTE: Implied "NOT EQUAL TO"
+
+		switch ( p1Type )
+		{
+		case TK_FLOAT:
+			return (int) ( f1 != f2 );
+			break;
+
+		case TK_INT:
+			return (int) ( i1 != i2 );
+			break;
+
+		case TK_VECTOR:
+			return (int) !VectorCompare( v1, v2 );
+			break;
+
+		case TK_STRING:
+		case TK_IDENTIFIER:
+			return (int) stricmp( c1, c2 );
+			break;
+
+		default:
+			Q3_DebugPrint( WL_ERROR, "Q3_Evaluate unknown type used!\n");
+			return false;
+		}
+
+		break;
+	
+	default:
+		Q3_DebugPrint( WL_ERROR, "Q3_Evaluate unknown operator used!\n");
+		break;
+	}
+
+	return false;
+}
+
+/*
+-------------------------
+Q3_CameraFade
+-------------------------
+*/
+static void Q3_CameraFade( float sr, float sg, float sb, float sa, float dr, float dg, float db, float da, float duration )
+{
+	Q3_DebugPrint( WL_WARNING, "Q3_CameraFade: NOT SUPPORTED IN MP\n");
+}
+
+/*
+-------------------------
+Q3_CameraPath
+-------------------------
+*/
+static void Q3_CameraPath( const char *name )
+{
+	Q3_DebugPrint( WL_WARNING, "Q3_CameraPath: NOT SUPPORTED IN MP\n");
+}
+
+/*
+-------------------------
+Q3_DebugPrint
+-------------------------
+*/
+void Q3_DebugPrint( int level, const char *format, ... )
+{
+	//Don't print messages they don't want to see
+	//if ( g_ICARUSDebug->integer < level )
+	if (!com_developer || !com_developer->integer)
+		return;
+
+	va_list		argptr;
+	char		text[1024];
+
+	va_start (argptr, format);
+	vsprintf (text, format, argptr);
+	va_end (argptr);
+
+	//Add the color formatting
+	switch ( level )
+	{
+		case WL_ERROR:
+			Com_Printf ( S_COLOR_RED"ERROR: %s", text );
+			break;
+		
+		case WL_WARNING:
+			Com_Printf ( S_COLOR_YELLOW"WARNING: %s", text );
+			break;
+		
+		case WL_DEBUG:
+			{
+				int		entNum;
+				char	*buffer;
+
+				sscanf( text, "%d", &entNum );
+
+				if ( ( ICARUS_entFilter >= 0 ) && ( ICARUS_entFilter != entNum ) )
+					return;
+
+				buffer = (char *) text;
+				buffer += 5;
+
+				if ( ( entNum < 0 ) || ( entNum > MAX_GENTITIES ) )
+					entNum = 0;
+
+				Com_Printf ( S_COLOR_BLUE"DEBUG: %s(%d): %s\n", SV_GentityNum(entNum)->script_targetname, entNum, buffer );
+				break;
+			}
+		default:
+		case WL_VERBOSE:
+			Com_Printf ( S_COLOR_GREEN"INFO: %s", text );
+			break;
+	}
+}
+
+void CGCam_Anything( void )
+{
+	Q3_DebugPrint( WL_WARNING, "Camera functions NOT SUPPORTED IN MP\n");
+}
+
+//These are useless for MP. Just taking it for now since I don't want to remove all calls to this in ICARUS.
+int AppendToSaveGame(unsigned long chid, void *data, int length)
+{
+	return 1;
+}
+
+// Changed by BTO (VV) - Visual C++ 7.1 doesn't allow default args on funcion pointers
+int ReadFromSaveGame(unsigned long chid, void *pvAddress, int iLength /* , void **ppvAddressPtr = NULL */ )
+{
+	return 1;
+}
+
+void CGCam_Enable( void )
+{
+	CGCam_Anything();
+}
+
+void CGCam_Disable( void )
+{
+	CGCam_Anything();
+}
+
+void CGCam_Zoom( float FOV, float duration )
+{
+	CGCam_Anything();
+}
+
+void CGCam_Pan( vec3_t dest, vec3_t panDirection, float duration )
+{
+	CGCam_Anything();
+}
+
+void CGCam_Move( vec3_t dest, float duration )
+{
+	CGCam_Anything();
+}
+
+#ifdef _XBOX
+void CGCam_Shake( float intensity, int duration );
+#else
+void CGCam_Shake( float intensity, int duration )
+{
+	CGCam_Anything();
+}
+#endif
+
+void CGCam_Follow( const char *cameraGroup, float speed, float initLerp )
+{
+	CGCam_Anything();
+}
+
+void CGCam_Track( const char *trackName, float speed, float initLerp )
+{
+	CGCam_Anything();
+}
+
+void CGCam_Distance( float distance, float initLerp )
+{
+	CGCam_Anything();
+}
+
+void CGCam_Roll( float	dest, float duration )
+{
+	CGCam_Anything();
+}
+
+int ICARUS_LinkEntity( int entID, CSequencer *sequencer, CTaskManager *taskManager );
+
+static DWORD Q3_GetTimeScale( void )
+{
+	return com_timescale->value;
+}
+
+static void Q3_Lerp2Pos( int taskID, int entID, vec3_t origin, vec3_t angles, float duration )
+{
+	T_G_ICARUS_LERP2POS *sharedMem = (T_G_ICARUS_LERP2POS *)sv.mSharedMemory;
+
+	sharedMem->taskID = taskID;
+	sharedMem->entID = entID;
+	VectorCopy(origin, sharedMem->origin);
+
+	if (angles)
+	{
+		VectorCopy(angles, sharedMem->angles);
+		sharedMem->nullAngles = qfalse;
+	}
+	else
+	{
+		sharedMem->nullAngles = qtrue;
+	}
+	sharedMem->duration = duration;
+
+	VM_Call(gvm, GAME_ICARUS_LERP2POS);
+	//We do this in case the values are modified in the game. It would be expected by icarus that
+	//the values passed in here are modified equally.
+	VectorCopy(sharedMem->origin, origin);
+
+	if (angles)
+	{
+		VectorCopy(sharedMem->angles, angles);
+	}
+}
+
+static void Q3_Lerp2Origin( int taskID, int entID, vec3_t origin, float duration )
+{
+	T_G_ICARUS_LERP2ORIGIN *sharedMem = (T_G_ICARUS_LERP2ORIGIN *)sv.mSharedMemory;
+
+	sharedMem->taskID = taskID;
+	sharedMem->entID = entID;
+	VectorCopy(origin, sharedMem->origin);
+	sharedMem->duration = duration;
+
+	VM_Call(gvm, GAME_ICARUS_LERP2ORIGIN);
+	VectorCopy(sharedMem->origin, origin);
+}
+
+static void Q3_Lerp2Angles( int taskID, int entID, vec3_t angles, float duration )
+{
+	T_G_ICARUS_LERP2ANGLES *sharedMem = (T_G_ICARUS_LERP2ANGLES *)sv.mSharedMemory;
+
+	sharedMem->taskID = taskID;
+	sharedMem->entID = entID;
+	VectorCopy(angles, sharedMem->angles);
+	sharedMem->duration = duration;
+
+	VM_Call(gvm, GAME_ICARUS_LERP2ANGLES);
+	VectorCopy(sharedMem->angles, angles);
+}
+
+static int	Q3_GetTag( int entID, const char *name, int lookup, vec3_t info )
+{
+	int r;
+	T_G_ICARUS_GETTAG *sharedMem = (T_G_ICARUS_GETTAG *)sv.mSharedMemory;
+
+	sharedMem->entID = entID;
+	strcpy(sharedMem->name, name);
+	sharedMem->lookup = lookup;
+	VectorCopy(info, sharedMem->info);
+
+	r = VM_Call(gvm, GAME_ICARUS_GETTAG);
+	VectorCopy(sharedMem->info, info);
+	return r;
+}
+
+static void Q3_Lerp2Start( int entID, int taskID, float duration )
+{
+	T_G_ICARUS_LERP2START *sharedMem = (T_G_ICARUS_LERP2START *)sv.mSharedMemory;
+
+	sharedMem->taskID = taskID;
+	sharedMem->entID = entID;
+	sharedMem->duration = duration;
+
+	VM_Call(gvm, GAME_ICARUS_LERP2START);
+}
+
+static void Q3_Lerp2End( int entID, int taskID, float duration )
+{
+	T_G_ICARUS_LERP2END *sharedMem = (T_G_ICARUS_LERP2END *)sv.mSharedMemory;
+
+	sharedMem->taskID = taskID;
+	sharedMem->entID = entID;
+	sharedMem->duration = duration;
+
+	VM_Call(gvm, GAME_ICARUS_LERP2END);
+}
+
+static void Q3_Use( int entID, const char *target )
+{
+	T_G_ICARUS_USE *sharedMem = (T_G_ICARUS_USE *)sv.mSharedMemory;
+
+	sharedMem->entID = entID;
+	strcpy(sharedMem->target, target);
+
+	VM_Call(gvm, GAME_ICARUS_USE);
+}
+
+static void Q3_Kill( int entID, const char *name )
+{
+	T_G_ICARUS_KILL *sharedMem = (T_G_ICARUS_KILL *)sv.mSharedMemory;
+
+	sharedMem->entID = entID;
+	strcpy(sharedMem->name, name);
+
+	VM_Call(gvm, GAME_ICARUS_KILL);
+}
+
+static void Q3_Remove( int entID, const char *name )
+{
+	T_G_ICARUS_REMOVE *sharedMem = (T_G_ICARUS_REMOVE *)sv.mSharedMemory;
+
+	sharedMem->entID = entID;
+	strcpy(sharedMem->name, name);
+
+	VM_Call(gvm, GAME_ICARUS_REMOVE);
+}
+
+static void Q3_Play( int taskID, int entID, const char *type, const char *name )
+{
+	T_G_ICARUS_PLAY *sharedMem = (T_G_ICARUS_PLAY *)sv.mSharedMemory;
+
+	sharedMem->taskID = taskID;
+	sharedMem->entID = entID;
+	strcpy(sharedMem->type, type);
+	strcpy(sharedMem->name, name);
+
+	VM_Call(gvm, GAME_ICARUS_PLAY);
+}
+
+static int Q3_GetFloat( int entID, int type, const char *name, float *value )
+{
+	int r;
+	T_G_ICARUS_GETFLOAT *sharedMem = (T_G_ICARUS_GETFLOAT *)sv.mSharedMemory;
+
+	sharedMem->entID = entID;
+	sharedMem->type = type;
+	strcpy(sharedMem->name, name);
+	sharedMem->value = 0;//*value;
+
+	r = VM_Call(gvm, GAME_ICARUS_GETFLOAT);
+	*value = sharedMem->value;
+	return r;
+}
+
+static int Q3_GetVector( int entID, int type, const char *name, vec3_t value )
+{
+	int r;
+	T_G_ICARUS_GETVECTOR *sharedMem = (T_G_ICARUS_GETVECTOR *)sv.mSharedMemory;
+
+	sharedMem->entID = entID;
+	sharedMem->type = type;
+	strcpy(sharedMem->name, name);
+	VectorCopy(value, sharedMem->value);
+
+	r = VM_Call(gvm, GAME_ICARUS_GETVECTOR);
+	VectorCopy(sharedMem->value, value);
+	return r;
+}
+
+static int Q3_GetString( int entID, int type, const char *name, char **value )
+{
+	int r;
+	T_G_ICARUS_GETSTRING *sharedMem = (T_G_ICARUS_GETSTRING *)sv.mSharedMemory;
+
+	sharedMem->entID = entID;
+	sharedMem->type = type;
+	strcpy(sharedMem->name, name);
+
+	r = VM_Call(gvm, GAME_ICARUS_GETSTRING);
+	//rww - careful with this, next time shared memory is altered this will get stomped
+	*value = &sharedMem->value[0];
+	return r;
+}
+
+
+/*
+============
+Interface_Init
+  Description	: Inits the interface for the game
+  Return type	: void 
+  Argument		: interface_export_t *pe
+============
+*/
+void Interface_Init( interface_export_t *pe )
+{
+	//TODO: This is where you link up all your functions to the engine
+
+	//General
+	pe->I_LoadFile				=	Q3_ReadScript;
+	pe->I_CenterPrint			=	Q3_CenterPrint;
+	pe->I_DPrintf				=	Q3_DebugPrint;
+	pe->I_GetEntityByName		=	Q3_GetEntityByName;
+	pe->I_GetTime				=	Q3_GetTime;
+	pe->I_GetTimeScale			=	Q3_GetTimeScale;
+	pe->I_PlaySound				=	Q3_PlaySound;
+	pe->I_Lerp2Pos				=	Q3_Lerp2Pos;
+	pe->I_Lerp2Origin			=	Q3_Lerp2Origin;
+	pe->I_Lerp2Angles			=	Q3_Lerp2Angles;
+	pe->I_GetTag				=	Q3_GetTag;
+	pe->I_Lerp2Start			=	Q3_Lerp2Start;
+	pe->I_Lerp2End				=	Q3_Lerp2End;	
+	pe->I_Use					=	Q3_Use;
+	pe->I_Kill					=	Q3_Kill;
+	pe->I_Remove				=	Q3_Remove;
+	pe->I_Set					=	Q3_Set;
+	pe->I_Random				=	Q_flrand;
+	pe->I_Play					=	Q3_Play;
+
+	//Camera functions
+	pe->I_CameraEnable			=	CGCam_Enable;
+	pe->I_CameraDisable			=	CGCam_Disable;
+	pe->I_CameraZoom			=	CGCam_Zoom;
+	pe->I_CameraMove			=	CGCam_Move;
+	pe->I_CameraPan				=	CGCam_Pan;
+	pe->I_CameraRoll			=	CGCam_Roll;
+	pe->I_CameraTrack			=	CGCam_Track;
+	pe->I_CameraFollow			=	CGCam_Follow;
+	pe->I_CameraDistance		=	CGCam_Distance;
+	pe->I_CameraShake			=	CGCam_Shake;
+	pe->I_CameraFade			=	Q3_CameraFade;
+	pe->I_CameraPath			=	Q3_CameraPath;
+
+	//Variable information
+	pe->I_GetFloat				=	Q3_GetFloat;
+	pe->I_GetVector				=	Q3_GetVector;
+	pe->I_GetString				=	Q3_GetString;
+
+	pe->I_Evaluate				=	Q3_Evaluate;
+
+	pe->I_DeclareVariable		=	Q3_DeclareVariable;
+	pe->I_FreeVariable			=	Q3_FreeVariable;
+
+	//Save / Load functions
+	pe->I_WriteSaveData			=	AppendToSaveGame;
+	pe->I_ReadSaveData			=	ReadFromSaveGame;
+	pe->I_LinkEntity			=	ICARUS_LinkEntity;
+}
diff --git a/codemp/icarus/Q3_Interface.h b/codemp/icarus/Q3_Interface.h
new file mode 100644
index 0000000..4174880
--- /dev/null
+++ b/codemp/icarus/Q3_Interface.h
@@ -0,0 +1,297 @@
+#ifndef __Q3_INTERFACE__
+#define __Q3_INTERFACE__
+
+//NOTENOTE: The enums and tables in this file will obviously bitch if they are included multiple times, don't do that
+
+typedef enum //# setType_e
+{
+	//# #sep Parm strings
+	SET_PARM1 = 0,//## %s="" # Set entity parm1
+	SET_PARM2,//## %s="" # Set entity parm2
+	SET_PARM3,//## %s="" # Set entity parm3
+	SET_PARM4,//## %s="" # Set entity parm4
+	SET_PARM5,//## %s="" # Set entity parm5
+	SET_PARM6,//## %s="" # Set entity parm6
+	SET_PARM7,//## %s="" # Set entity parm7
+	SET_PARM8,//## %s="" # Set entity parm8
+	SET_PARM9,//## %s="" # Set entity parm9
+	SET_PARM10,//## %s="" # Set entity parm10
+	SET_PARM11,//## %s="" # Set entity parm11
+	SET_PARM12,//## %s="" # Set entity parm12
+	SET_PARM13,//## %s="" # Set entity parm13
+	SET_PARM14,//## %s="" # Set entity parm14
+	SET_PARM15,//## %s="" # Set entity parm15
+	SET_PARM16,//## %s="" # Set entity parm16
+
+	// NOTE!!! If you add any other SET_xxxxxxSCRIPT types, make sure you update the 'case' statements in 
+	//	ICARUS_InterrogateScript() (game/g_ICARUS.cpp), or the script-precacher won't find them.
+
+	//# #sep Scripts and other file paths
+	SET_SPAWNSCRIPT,//## %s="NULL" !!"W:\game\base\scripts\!!#*.txt" # Script to run when spawned //0 - do not change these, these are equal to BSET_SPAWN, etc
+	SET_USESCRIPT,//## %s="NULL" !!"W:\game\base\scripts\!!#*.txt" # Script to run when used
+	SET_AWAKESCRIPT,//## %s="NULL" !!"W:\game\base\scripts\!!#*.txt" # Script to run when startled
+	SET_ANGERSCRIPT,//## %s="NULL" !!"W:\game\base\scripts\!!#*.txt" # Script run when find an enemy for the first time
+	SET_ATTACKSCRIPT,//## %s="NULL" !!"W:\game\base\scripts\!!#*.txt" # Script to run when you shoot
+	SET_VICTORYSCRIPT,//## %s="NULL" !!"W:\game\base\scripts\!!#*.txt" # Script to run when killed someone
+	SET_LOSTENEMYSCRIPT,//## %s="NULL" !!"W:\game\base\scripts\!!#*.txt" # Script to run when you can't find your enemy
+	SET_PAINSCRIPT,//## %s="NULL" !!"W:\game\base\scripts\!!#*.txt" # Script to run when hit
+	SET_FLEESCRIPT,//## %s="NULL" !!"W:\game\base\scripts\!!#*.txt" # Script to run when hit and low health
+	SET_DEATHSCRIPT,//## %s="NULL" !!"W:\game\base\scripts\!!#*.txt" # Script to run when killed
+	SET_DELAYEDSCRIPT,//## %s="NULL" !!"W:\game\base\scripts\!!#*.txt" # Script to run after a delay
+	SET_BLOCKEDSCRIPT,//## %s="NULL" !!"W:\game\base\scripts\!!#*.txt" # Script to run when blocked by teammate
+	SET_FFIRESCRIPT,//## %s="NULL" !!"W:\game\base\scripts\!!#*.txt" # Script to run when player has shot own team repeatedly
+	SET_FFDEATHSCRIPT,//## %s="NULL" !!"W:\game\base\scripts\!!#*.txt" # Script to run when player kills a teammate
+	SET_MINDTRICKSCRIPT,//## %s="NULL" !!"W:\game\base\scripts\!!#*.txt" # Script to run when player kills a teammate
+	SET_VIDEO_PLAY,//## %s="filename" !!"W:\game\base\video\!!#*.roq" # Play a video (inGame)
+	SET_CINEMATIC_SKIPSCRIPT, //## %s="filename" !!"W:\game\base\scripts\!!#*.txt" # Script to run when skipping the running cinematic 
+
+	//# #sep Standard strings
+	SET_ENEMY,//## %s="NULL" # Set enemy by targetname
+	SET_LEADER,//## %s="NULL" # Set for BS_FOLLOW_LEADER
+	SET_NAVGOAL,//## %s="NULL" # *Move to this navgoal then continue script
+	SET_CAPTURE,//## %s="NULL" # Set captureGoal by targetname
+	SET_VIEWTARGET,//## %s="NULL" # Set angles toward ent by targetname
+	SET_WATCHTARGET,//## %s="NULL" # Set angles toward ent by targetname, will *continue* to face them... only in BS_CINEMATIC
+	SET_TARGETNAME,//## %s="NULL" # Set/change your targetname
+	SET_PAINTARGET,//## %s="NULL" # Set/change what to use when hit
+	SET_CAMERA_GROUP,//## %s="NULL" # all ents with this cameraGroup will be focused on
+	SET_CAMERA_GROUP_TAG,//## %s="NULL" # What tag on all clients to try to track
+	SET_LOOK_TARGET,//## %s="NULL" # object for NPC to look at
+	SET_ADDRHANDBOLT_MODEL,			//## %s="NULL" # object to place on NPC right hand bolt
+	SET_REMOVERHANDBOLT_MODEL,		//## %s="NULL" # object to remove from NPC right hand bolt
+	SET_ADDLHANDBOLT_MODEL,			//## %s="NULL" # object to place on NPC left hand bolt
+	SET_REMOVELHANDBOLT_MODEL,		//## %s="NULL" # object to remove from NPC left hand bolt
+	SET_CAPTIONTEXTCOLOR,	//## %s=""  # Color of text RED,WHITE,BLUE, YELLOW
+	SET_CENTERTEXTCOLOR,	//## %s=""  # Color of text RED,WHITE,BLUE, YELLOW
+	SET_SCROLLTEXTCOLOR,	//## %s=""  # Color of text RED,WHITE,BLUE, YELLOW
+	SET_COPY_ORIGIN,//## %s="targetname"  # Copy the origin of the ent with targetname to your origin
+	SET_DEFEND_TARGET,//## %s="targetname"  # This NPC will attack the target NPC's enemies
+	SET_TARGET,//## %s="NULL" # Set/change your target
+	SET_TARGET2,//## %s="NULL" # Set/change your target2, on NPC's, this fires when they're knocked out by the red hypo
+	SET_LOCATION,//## %s="INVALID" # What trigger_location you're in - Can only be gotten, not set!
+	SET_REMOVE_TARGET,//## %s="NULL" # Target that is fired when someone completes the BS_REMOVE behaviorState
+	SET_LOADGAME,//## %s="exitholodeck" # Load the savegame that was auto-saved when you started the holodeck
+	SET_LOCKYAW,//## %s="off"  # Lock legs to a certain yaw angle (or "off" or "auto" uses current)
+	SET_FULLNAME,//## %s="NULL" # This name will appear when ent is scanned by tricorder
+	SET_VIEWENTITY,//## %s="NULL" # Make the player look through this ent's eyes - also shunts player movement control to this ent
+	SET_LOOPSOUND,//## %s="FILENAME" !!"W:\game\base\!!#sound\*.*" # Looping sound to play on entity
+	SET_ICARUS_FREEZE,//## %s="NULL" # Specify name of entity to freeze - !!!NOTE!!! since the ent is frozen, it cannot unfreeze itself, you must have some other entity unfreeze a frozen ent!!!
+	SET_ICARUS_UNFREEZE,//## %s="NULL" # Specify name of entity to unfreeze - !!!NOTE!!! since the ent is frozen, it cannot unfreeze itself, you must have some other entity unfreeze a frozen ent!!!
+
+	SET_SCROLLTEXT,	//## %s="" # key of text string to print
+	SET_LCARSTEXT,	//## %s="" # key of text string to print in LCARS frame
+
+	//# #sep vectors
+	SET_ORIGIN,//## %v="0.0 0.0 0.0" # Set origin explicitly or with TAG
+	SET_ANGLES,//## %v="0.0 0.0 0.0" # Set angles explicitly or with TAG
+	SET_TELEPORT_DEST,//## %v="0.0 0.0 0.0" # Set origin here as soon as the area is clear
+	
+	//# #sep floats
+	SET_XVELOCITY,//## %f="0.0" # Velocity along X axis
+	SET_YVELOCITY,//## %f="0.0" # Velocity along Y axis
+	SET_ZVELOCITY,//## %f="0.0" # Velocity along Z axis
+	SET_Z_OFFSET,//## %f="0.0" # Vertical offset from original origin... offset/ent's speed * 1000ms is duration
+	SET_DPITCH,//## %f="0.0" # Pitch for NPC to turn to
+	SET_DYAW,//## %f="0.0" # Yaw for NPC to turn to
+	SET_TIMESCALE,//## %f="0.0" # Speed-up slow down game (0 - 1.0)
+	SET_CAMERA_GROUP_Z_OFS,//## %s="NULL" # when following an ent with the camera, apply this z ofs
+	SET_VISRANGE,//## %f="0.0" # How far away NPC can see
+	SET_EARSHOT,//## %f="0.0" # How far an NPC can hear
+	SET_VIGILANCE,//## %f="0.0" # How often to look for enemies (0 - 1.0)
+	SET_GRAVITY,//## %f="0.0" # Change this ent's gravity - 800 default
+	SET_FACEAUX,		//## %f="0.0" # Set face to Aux expression for number of seconds
+	SET_FACEBLINK,		//## %f="0.0" # Set face to Blink expression for number of seconds
+	SET_FACEBLINKFROWN,	//## %f="0.0" # Set face to Blinkfrown expression for number of seconds
+	SET_FACEFROWN,		//## %f="0.0" # Set face to Frown expression for number of seconds
+	SET_FACENORMAL,		//## %f="0.0" # Set face to Normal expression for number of seconds
+	SET_FACEEYESCLOSED,	//## %f="0.0" # Set face to Eyes closed
+	SET_FACEEYESOPENED,	//## %f="0.0" # Set face to Eyes open
+	SET_WAIT,		//## %f="0.0" # Change an entity's wait field
+	SET_FOLLOWDIST,		//## %f="0.0" # How far away to stay from leader in BS_FOLLOW_LEADER
+	SET_SCALE,			//## %f="0.0" # Scale the entity model
+
+	//# #sep ints
+	SET_ANIM_HOLDTIME_LOWER,//## %d="0" # Hold lower anim for number of milliseconds
+	SET_ANIM_HOLDTIME_UPPER,//## %d="0" # Hold upper anim for number of milliseconds
+	SET_ANIM_HOLDTIME_BOTH,//## %d="0" # Hold lower and upper anims for number of milliseconds
+	SET_HEALTH,//## %d="0" # Change health
+	SET_ARMOR,//## %d="0" # Change armor
+	SET_WALKSPEED,//## %d="0" # Change walkSpeed
+	SET_RUNSPEED,//## %d="0" # Change runSpeed
+	SET_YAWSPEED,//## %d="0" # Change yawSpeed
+	SET_AGGRESSION,//## %d="0" # Change aggression 1-5
+	SET_AIM,//## %d="0" # Change aim 1-5
+	SET_FRICTION,//## %d="0" # Change ent's friction - 6 default
+	SET_SHOOTDIST,//## %d="0" # How far the ent can shoot - 0 uses weapon
+	SET_HFOV,//## %d="0" # Horizontal field of view
+	SET_VFOV,//## %d="0" # Vertical field of view
+	SET_DELAYSCRIPTTIME,//## %d="0" # How many milliseconds to wait before running delayscript
+	SET_FORWARDMOVE,//## %d="0" # NPC move forward -127(back) to 127
+	SET_RIGHTMOVE,//## %d="0" # NPC move right -127(left) to 127
+	SET_STARTFRAME,	//## %d="0" # frame to start animation sequence on
+	SET_ENDFRAME,	//## %d="0" # frame to end animation sequence on
+	SET_ANIMFRAME,	//## %d="0" # frame to set animation sequence to
+	SET_COUNT,	//## %d="0" # Change an entity's count field
+	SET_SHOT_SPACING,//## %d="1000" # Time between shots for an NPC - reset to defaults when changes weapon
+	SET_MISSIONSTATUSTIME,//## %d="0" # Amount of time until Mission Status should be shown after death
+	SET_WIDTH,//## %d="0.0" # Width of NPC bounding box.
+
+	//# #sep booleans
+	SET_IGNOREPAIN,//## %t="BOOL_TYPES" # Do not react to pain
+	SET_IGNOREENEMIES,//## %t="BOOL_TYPES" # Do not acquire enemies
+	SET_IGNOREALERTS,//## %t="BOOL_TYPES" # Do not get enemy set by allies in area(ambush)
+	SET_DONTSHOOT,//## %t="BOOL_TYPES" # Others won't shoot you
+	SET_NOTARGET,//## %t="BOOL_TYPES" # Others won't pick you as enemy
+	SET_DONTFIRE,//## %t="BOOL_TYPES" # Don't fire your weapon
+	SET_LOCKED_ENEMY,//## %t="BOOL_TYPES" # Keep current enemy until dead
+	SET_CROUCHED,//## %t="BOOL_TYPES" # Force NPC to crouch
+	SET_WALKING,//## %t="BOOL_TYPES" # Force NPC to move at walkSpeed
+	SET_RUNNING,//## %t="BOOL_TYPES" # Force NPC to move at runSpeed
+	SET_CHASE_ENEMIES,//## %t="BOOL_TYPES" # NPC will chase after enemies
+	SET_LOOK_FOR_ENEMIES,//## %t="BOOL_TYPES" # NPC will be on the lookout for enemies
+	SET_FACE_MOVE_DIR,//## %t="BOOL_TYPES" # NPC will face in the direction it's moving
+	SET_DONT_FLEE,//## %t="BOOL_TYPES" # NPC will not run from danger
+	SET_FORCED_MARCH,//## %t="BOOL_TYPES" # NPC will not move unless you aim at him
+	SET_UNDYING,//## %t="BOOL_TYPES" # Can take damage down to 1 but not die
+	SET_NOAVOID,//## %t="BOOL_TYPES" # Will not avoid other NPCs or architecture
+	SET_SOLID,//## %t="BOOL_TYPES" # Make yourself notsolid or solid
+	SET_PLAYER_USABLE,//## %t="BOOL_TYPES" # Can be activateby the player's "use" button
+	SET_LOOP_ANIM,//## %t="BOOL_TYPES" # For non-NPCs, loop your animation sequence
+	SET_INTERFACE,//## %t="BOOL_TYPES" # Player interface on/off
+	SET_SHIELDS,//## %t="BOOL_TYPES" # NPC has no shields (Borg do not adapt)
+	SET_INVISIBLE,//## %t="BOOL_TYPES" # Makes an NPC not solid and not visible
+	SET_VAMPIRE,//## %t="BOOL_TYPES" # Draws only in mirrors/portals
+	SET_FORCE_INVINCIBLE,//## %t="BOOL_TYPES" # Force Invincibility effect, also godmode
+	SET_GREET_ALLIES,//## %t="BOOL_TYPES" # Makes an NPC greet teammates
+	SET_VIDEO_FADE_IN,//## %t="BOOL_TYPES" # Makes video playback fade in
+	SET_VIDEO_FADE_OUT,//## %t="BOOL_TYPES" # Makes video playback fade out
+	SET_PLAYER_LOCKED,//## %t="BOOL_TYPES" # Makes it so player cannot move
+	SET_LOCK_PLAYER_WEAPONS,//## %t="BOOL_TYPES" # Makes it so player cannot switch weapons
+	SET_NO_IMPACT_DAMAGE,//## %t="BOOL_TYPES" # Stops this ent from taking impact damage
+	SET_NO_KNOCKBACK,//## %t="BOOL_TYPES" # Stops this ent from taking knockback from weapons
+	SET_ALT_FIRE,//## %t="BOOL_TYPES" # Force NPC to use altfire when shooting
+	SET_NO_RESPONSE,//## %t="BOOL_TYPES" # NPCs will do generic responses when this is on (usescripts override generic responses as well)
+	SET_INVINCIBLE,//## %t="BOOL_TYPES" # Completely unkillable
+	SET_MISSIONSTATUSACTIVE,	//# Turns on Mission Status Screen
+	SET_NO_COMBAT_TALK,//## %t="BOOL_TYPES" # NPCs will not do their combat talking noises when this is on
+	SET_NO_ALERT_TALK,//## %t="BOOL_TYPES" # NPCs will not do their combat talking noises when this is on
+	SET_TREASONED,//## %t="BOOL_TYPES" # Player has turned on his own- scripts will stop, NPCs will turn on him and level changes load the brig
+	SET_DISABLE_SHADER_ANIM,//## %t="BOOL_TYPES" # Allows turning off an animating shader in a script
+	SET_SHADER_ANIM,//## %t="BOOL_TYPES" # Sets a shader with an image map to be under frame control
+	SET_SABERACTIVE,//## %t="BOOL_TYPES" # Turns saber on/off
+	SET_ADJUST_AREA_PORTALS,//## %t="BOOL_TYPES" # Only set this on things you move with script commands that you *want* to open/close area portals.  Default is off.
+	SET_DMG_BY_HEAVY_WEAP_ONLY,//## %t="BOOL_TYPES" # When true, only a heavy weapon class missile/laser can damage this ent.
+	SET_SHIELDED,//## %t="BOOL_TYPES" # When true, ion_cannon is shielded from any kind of damage.
+	SET_NO_GROUPS,//## %t="BOOL_TYPES" # This NPC cannot alert groups or be part of a group
+	SET_FIRE_WEAPON,//## %t="BOOL_TYPES" # Makes NPC will hold down the fire button, until this is set to false
+	SET_NO_MINDTRICK,//## %t="BOOL_TYPES" # Makes NPC immune to jedi mind-trick
+	SET_INACTIVE,//## %t="BOOL_TYPES" # in lieu of using a target_activate or target_deactivate
+	SET_FUNC_USABLE_VISIBLE,//## %t="BOOL_TYPES" # provides an alternate way of changing func_usable to be visible or not, DOES NOT AFFECT SOLID
+	SET_SECRET_AREA_FOUND,//## %t="BOOL_TYPES" # Increment secret areas found counter
+	SET_MISSION_STATUS_SCREEN,//## %t="BOOL_TYPES" # Display Mission Status screen before advancing to next level
+	SET_END_SCREENDISSOLVE,//## %t="BOOL_TYPES" # End of game dissolve into star background and credits
+	SET_USE_CP_NEAREST,//## %t="BOOL_TYPES" # NPCs will use their closest combat points, not try and find ones next to the player, or flank player
+	SET_MORELIGHT,//## %t="BOOL_TYPES" # NPC will have a minlight of 96
+	SET_NO_FORCE,//## %t="BOOL_TYPES" # NPC will not be affected by force powers
+	SET_NO_FALLTODEATH,//## %t="BOOL_TYPES" # NPC will not scream and tumble and fall to hit death over large drops
+	SET_DISMEMBERABLE,//## %t="BOOL_TYPES" # NPC will not be dismemberable if you set this to false (default is true)
+	SET_NO_ACROBATICS,//## %t="BOOL_TYPES" # Jedi won't jump, roll or cartwheel
+	SET_USE_SUBTITLES,//## %t="BOOL_TYPES" # When true NPC will always display subtitle regardless of subtitle setting
+	SET_CLEAN_DAMAGING_ENTS,//## %t="BOOL_TYPES" # Removes entities that could muck up cinematics, explosives, turrets, seekers.
+	SET_HUD,//## %t="BOOL_TYPES" # Turns on/off HUD
+
+	//# #sep calls
+	SET_SKILL,//## %r%d="0" # Cannot set this, only get it - valid values are 0 through 3
+
+	//# #sep Special tables
+	SET_ANIM_UPPER,//## %t="ANIM_NAMES" # Torso and head anim
+	SET_ANIM_LOWER,//## %t="ANIM_NAMES" # Legs anim
+	SET_ANIM_BOTH,//## %t="ANIM_NAMES" # Set same anim on torso and legs
+	SET_PLAYER_TEAM,//## %t="TEAM_NAMES" # Your team
+	SET_ENEMY_TEAM,//## %t="TEAM_NAMES" # Team in which to look for enemies
+	SET_BEHAVIOR_STATE,//## %t="BSTATE_STRINGS" # Change current bState
+	SET_DEFAULT_BSTATE,//## %t="BSTATE_STRINGS" # Change fallback bState
+	SET_TEMP_BSTATE,//## %t="BSTATE_STRINGS" # Set/Chang a temp bState
+	SET_EVENT,//## %t="EVENT_NAMES" # Events you can initiate
+	SET_WEAPON,//## %t="WEAPON_NAMES" # Change/Stow/Drop weapon
+	SET_ITEM,//## %t="ITEM_NAMES" # Give items
+	SET_MUSIC_STATE,//## %t="MUSIC_STATES" # Set the state of the dynamic music
+
+	SET_FORCE_HEAL_LEVEL,//## %t="FORCE_LEVELS" # Change force power level
+	SET_FORCE_JUMP_LEVEL,//## %t="FORCE_LEVELS" # Change force power level
+	SET_FORCE_SPEED_LEVEL,//## %t="FORCE_LEVELS" # Change force power level
+	SET_FORCE_PUSH_LEVEL,//## %t="FORCE_LEVELS" # Change force power level
+	SET_FORCE_PULL_LEVEL,//## %t="FORCE_LEVELS" # Change force power level
+	SET_FORCE_MINDTRICK_LEVEL,//## %t="FORCE_LEVELS" # Change force power level
+	SET_FORCE_GRIP_LEVEL,//## %t="FORCE_LEVELS" # Change force power level
+	SET_FORCE_LIGHTNING_LEVEL,//## %t="FORCE_LEVELS" # Change force power level
+	SET_SABER_THROW,//## %t="FORCE_LEVELS" # Change force power level
+	SET_SABER_DEFENSE,//## %t="FORCE_LEVELS" # Change force power level
+	SET_SABER_OFFENSE,//## %t="FORCE_LEVELS" # Change force power level
+
+	SET_OBJECTIVE_SHOW,	//## %t="OBJECTIVES" # Show objective on mission screen
+	SET_OBJECTIVE_HIDE,	//## %t="OBJECTIVES" # Hide objective from mission screen
+	SET_OBJECTIVE_SUCCEEDED,//## %t="OBJECTIVES" # Mark objective as completed
+	SET_OBJECTIVE_FAILED,	//## %t="OBJECTIVES" # Mark objective as failed
+
+	SET_MISSIONFAILED,		//## %t="MISSIONFAILED" # Mission failed screen activates
+
+	SET_TACTICAL_SHOW,		//## %t="TACTICAL" # Show tactical info on mission objectives screen
+	SET_TACTICAL_HIDE,		//## %t="TACTICAL" # Hide tactical info on mission objectives screen
+	SET_OBJECTIVE_CLEARALL,	//## # Force all objectives to be hidden
+/*
+	SET_OBJECTIVEFOSTER,	
+*/
+	SET_MISSIONSTATUSTEXT,	//## %t="STATUSTEXT" # Text to appear in mission status screen
+	SET_MENU_SCREEN,//## %t="MENUSCREENS" # Brings up specified menu screen
+
+	SET_CLOSINGCREDITS,		//## # Show closing credits
+
+	//in-bhc tables
+	SET_LEAN,//## %t="LEAN_TYPES" # Lean left, right or stop leaning
+
+	//# #eol
+	SET_
+} setType_t;	
+
+#ifdef __cplusplus
+
+// this enum isn't used directly by the game, it's mainly for BehavEd to scan for...
+//
+typedef enum //# playType_e
+{
+	//# #sep Types of file to play
+	PLAY_ROFF = 0,//## %s="filename" !!"W:\game\base\scripts\!!#*.rof" # Play a ROFF file
+
+	//# #eol
+	PLAY_NUMBEROF
+
+} playType_t;
+
+
+const	int	Q3_TIME_SCALE	= 1;	//MILLISECONDS
+
+extern char	cinematicSkipScript[1024];
+
+//General
+extern	void		Q3_TaskIDClear( int *taskID );
+extern	qboolean	Q3_TaskIDPending( sharedEntity_t *ent, taskID_t taskType );
+extern	void		Q3_TaskIDComplete( sharedEntity_t *ent, taskID_t taskType );
+extern	void		Q3_DPrintf( const char *, ... );
+
+extern	void		Q3_CameraRoll( float angle, float duration );
+extern  void		Q3_CameraFollow( const char *name, float speed, float initLerp );
+extern  void		Q3_CameraTrack( const char *name, float speed, float initLerp );
+extern  void		Q3_CameraDistance( float distance, float initLerp );
+
+//Not referenced directly as script function - all are called through Q3_Set
+extern	void		Q3_SetAnimBoth( int entID, const char *anim_name );
+extern	void		Q3_SetVelocity( int entID, vec3_t angles );
+
+extern	void		Q3_DeclareVariable ( int type, const char *name );
+extern	void		Q3_FreeVariable( const char *name );
+
+extern	void		Q3_DebugPrint( int level, const char *format, ... );
+#endif //__cplusplus
+
+#endif	//__Q3_INTERFACE__
diff --git a/codemp/icarus/Q3_Registers.cpp b/codemp/icarus/Q3_Registers.cpp
new file mode 100644
index 0000000..207c359
--- /dev/null
+++ b/codemp/icarus/Q3_Registers.cpp
@@ -0,0 +1,429 @@
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+#include "../game/g_public.h"
+#include "Q3_Registers.h"
+
+extern	void	Q3_DebugPrint( int level, const char *format, ... );
+
+varString_m		varStrings;
+varFloat_m		varFloats;
+varString_m		varVectors;	//Work around for vector types
+
+int				numVariables = 0;
+
+/*
+-------------------------
+Q3_VariableDeclared
+-------------------------
+*/
+
+int Q3_VariableDeclared( const char *name )
+{
+	//Check the strings
+	varString_m::iterator	vsi = varStrings.find( name );
+
+	if ( vsi != varStrings.end() )
+		return VTYPE_STRING;
+
+	//Check the floats
+	varFloat_m::iterator	vfi = varFloats.find( name );
+
+	if ( vfi != varFloats.end() )
+		return VTYPE_FLOAT;
+
+	//Check the vectors
+	varString_m::iterator	vvi = varVectors.find( name );
+
+	if ( vvi != varVectors.end() )
+		return VTYPE_VECTOR;
+
+	return VTYPE_NONE;
+}
+
+/*
+-------------------------
+Q3_DeclareVariable
+-------------------------
+*/
+
+void Q3_DeclareVariable( int type, const char *name )
+{
+	//Cannot declare the same variable twice
+	if ( Q3_VariableDeclared( name ) != VTYPE_NONE )
+		return;
+
+	if ( numVariables > MAX_VARIABLES )
+	{
+		Q3_DebugPrint( WL_ERROR, "too many variables already declared, maximum is %d\n", MAX_VARIABLES );
+		return;
+	}
+
+	switch( type )
+	{
+	case TK_FLOAT:
+		varFloats[ name ] = 0.0f;
+		break;
+
+	case TK_STRING:		
+		varStrings[ name ] = "NULL";
+		break;
+
+	case TK_VECTOR:
+		varVectors[ name ] = "0.0 0.0 0.0";
+		break;
+
+	default:
+		Q3_DebugPrint( WL_ERROR, "unknown 'type' for declare() function!\n" );
+		return;
+		break;
+	}
+
+	numVariables++;
+}
+
+/*
+-------------------------
+Q3_FreeVariable
+-------------------------
+*/
+
+void Q3_FreeVariable( const char *name )
+{
+	//Check the strings
+	varString_m::iterator	vsi = varStrings.find( name );
+
+	if ( vsi != varStrings.end() )
+	{
+		varStrings.erase( vsi );
+		numVariables--;
+		return;
+	}
+
+	//Check the floats
+	varFloat_m::iterator	vfi = varFloats.find( name );
+
+	if ( vfi != varFloats.end() )
+	{
+		varFloats.erase( vfi );
+		numVariables--;
+		return;
+	}
+
+	//Check the strings
+	varString_m::iterator	vvi = varVectors.find( name );
+
+	if ( vvi != varVectors.end() )
+	{
+		varVectors.erase( vvi );
+		numVariables--;
+		return;
+	}
+}
+
+/*
+-------------------------
+Q3_GetFloatVariable
+-------------------------
+*/
+
+int Q3_GetFloatVariable( const char *name, float *value )
+{
+	//Check the floats
+	varFloat_m::iterator	vfi = varFloats.find( name );
+
+	if ( vfi != varFloats.end() )
+	{
+		*value = (*vfi).second;
+		return true;
+	}
+
+	return false;
+}
+
+/*
+-------------------------
+Q3_GetStringVariable
+-------------------------
+*/
+
+int Q3_GetStringVariable( const char *name, const char **value )
+{
+	//Check the strings
+	varString_m::iterator	vsi = varStrings.find( name );
+
+	if ( vsi != varStrings.end() )
+	{
+		*value = (const char *) ((*vsi).second).c_str();
+		return true;
+	}
+
+	return false;
+}
+
+/*
+-------------------------
+Q3_GetVectorVariable
+-------------------------
+*/
+
+int Q3_GetVectorVariable( const char *name, vec3_t value )
+{
+	//Check the strings
+	varString_m::iterator	vvi = varVectors.find( name );
+
+	if ( vvi != varVectors.end() )
+	{
+		const char *str = ((*vvi).second).c_str();
+
+		sscanf( str, "%f %f %f", &value[0], &value[1], &value[2] );
+		return true;
+	}
+
+	return false;
+}
+
+/*
+-------------------------
+Q3_InitVariables
+-------------------------
+*/
+
+void Q3_InitVariables( void )
+{
+	varStrings.clear();
+	varFloats.clear();
+	varVectors.clear();
+
+	if ( numVariables > 0 )
+		Q3_DebugPrint( WL_WARNING, "%d residual variables found!\n", numVariables );
+
+	numVariables = 0;
+}
+
+/*
+-------------------------
+Q3_SetVariable_Float
+-------------------------
+*/
+
+int Q3_SetFloatVariable( const char *name, float value )
+{
+	//Check the floats
+	varFloat_m::iterator	vfi = varFloats.find( name );
+
+	if ( vfi == varFloats.end() )
+		return VTYPE_FLOAT;
+
+	(*vfi).second = value;
+	
+	return true;
+}
+
+/*
+-------------------------
+Q3_SetVariable_String
+-------------------------
+*/
+
+int Q3_SetStringVariable( const char *name, const char *value )
+{
+	//Check the strings
+	varString_m::iterator	vsi = varStrings.find( name );
+
+	if ( vsi == varStrings.end() )
+		return false;
+
+	(*vsi).second = value;
+
+	return true;
+}
+
+/*
+-------------------------
+Q3_SetVariable_Vector
+-------------------------
+*/
+
+int Q3_SetVectorVariable( const char *name, const char *value )
+{
+	//Check the strings
+	varString_m::iterator	vvi = varVectors.find( name );
+
+	if ( vvi == varVectors.end() )
+		return false;
+
+	(*vvi).second = value;
+
+	return true;
+}
+
+/*
+-------------------------
+Q3_VariableSaveFloats
+-------------------------
+*/
+
+void Q3_VariableSaveFloats( varFloat_m &fmap )
+{
+	return;
+	/*
+	int numFloats = fmap.size();
+	gi.AppendToSaveGame( 'FVAR', &numFloats, sizeof( numFloats ) );
+
+	varFloat_m::iterator	vfi;
+	STL_ITERATE( vfi, fmap )
+	{
+		//Save out the map id
+		int	idSize = strlen( ((*vfi).first).c_str() );
+		
+		//Save out the real data
+		gi.AppendToSaveGame( 'FIDL', &idSize, sizeof( idSize ) );
+		gi.AppendToSaveGame( 'FIDS', (void *) ((*vfi).first).c_str(), idSize );
+
+		//Save out the float value
+		gi.AppendToSaveGame( 'FVAL', &((*vfi).second), sizeof( float ) );
+	}
+	*/
+}
+
+/*
+-------------------------
+Q3_VariableSaveStrings
+-------------------------
+*/
+
+void Q3_VariableSaveStrings( varString_m &smap )
+{
+	return;
+	/*
+	int numStrings = smap.size();
+	gi.AppendToSaveGame( 'SVAR', &numStrings, sizeof( numStrings ) );
+
+	varString_m::iterator	vsi;
+	STL_ITERATE( vsi, smap )
+	{
+		//Save out the map id
+		int	idSize = strlen( ((*vsi).first).c_str() );
+		
+		//Save out the real data
+		gi.AppendToSaveGame( 'SIDL', &idSize, sizeof( idSize ) );
+		gi.AppendToSaveGame( 'SIDS', (void *) ((*vsi).first).c_str(), idSize );
+
+		//Save out the string value
+		idSize = strlen( ((*vsi).second).c_str() );
+
+		gi.AppendToSaveGame( 'SVSZ', &idSize, sizeof( idSize ) );
+		gi.AppendToSaveGame( 'SVAL', (void *) ((*vsi).second).c_str(), idSize );
+	}
+	*/
+}
+
+/*
+-------------------------
+Q3_VariableSave
+-------------------------
+*/
+
+int Q3_VariableSave( void )
+{
+	Q3_VariableSaveFloats( varFloats );
+	Q3_VariableSaveStrings( varStrings );
+	Q3_VariableSaveStrings( varVectors);
+
+	return qtrue;
+}
+
+/*
+-------------------------
+Q3_VariableLoadFloats
+-------------------------
+*/
+
+void Q3_VariableLoadFloats( varFloat_m &fmap )
+{
+	return;
+	/*
+	int		numFloats;
+	char	tempBuffer[1024];
+
+	gi.ReadFromSaveGame( 'FVAR', &numFloats, sizeof( numFloats ) );
+
+	for ( int i = 0; i < numFloats; i++ )
+	{
+		int idSize;
+		
+		gi.ReadFromSaveGame( 'FIDL', &idSize, sizeof( idSize ) );
+		gi.ReadFromSaveGame( 'FIDS', &tempBuffer, idSize );
+		tempBuffer[ idSize ] = 0;
+
+		float	val;
+
+		gi.ReadFromSaveGame( 'FVAL', &val, sizeof( float ) );
+
+		Q3_DeclareVariable( TK_FLOAT, (const char *) &tempBuffer );
+		Q3_SetFloatVariable( (const char *) &tempBuffer, val );
+	}
+	*/
+}
+
+/*
+-------------------------
+Q3_VariableLoadStrings
+-------------------------
+*/
+
+void Q3_VariableLoadStrings( int type, varString_m &fmap )
+{
+	return;
+	/*
+	int		numFloats;
+	char	tempBuffer[1024];
+	char	tempBuffer2[1024];
+
+	gi.ReadFromSaveGame( 'SVAR', &numFloats, sizeof( numFloats ) );
+
+	for ( int i = 0; i < numFloats; i++ )
+	{
+		int idSize;
+		
+		gi.ReadFromSaveGame( 'SIDL', &idSize, sizeof( idSize ) );
+		gi.ReadFromSaveGame( 'SIDS', &tempBuffer, idSize );
+		tempBuffer[ idSize ] = 0;
+
+		gi.ReadFromSaveGame( 'SVSZ', &idSize, sizeof( idSize ) );
+		gi.ReadFromSaveGame( 'SVAL', &tempBuffer2, idSize );
+		tempBuffer2[ idSize ] = 0;
+
+		switch ( type )
+		{
+		case TK_STRING:
+			Q3_DeclareVariable( TK_STRING, (const char *) &tempBuffer );
+			Q3_SetStringVariable( (const char *) &tempBuffer, (const char *) &tempBuffer2 );
+			break;
+
+		case TK_VECTOR:
+			Q3_DeclareVariable( TK_VECTOR, (const char *) &tempBuffer );
+			Q3_SetVectorVariable( (const char *) &tempBuffer, (const char *) &tempBuffer2 );
+			break;
+		}
+	}
+	*/
+}
+
+/*
+-------------------------
+Q3_VariableLoad
+-------------------------
+*/
+
+int Q3_VariableLoad( void )
+{
+	Q3_InitVariables();
+
+	Q3_VariableLoadFloats( varFloats );
+	Q3_VariableLoadStrings( TK_STRING, varStrings );
+	Q3_VariableLoadStrings( TK_VECTOR, varVectors);
+
+	return qfalse;
+}
\ No newline at end of file
diff --git a/codemp/icarus/Q3_Registers.h b/codemp/icarus/Q3_Registers.h
new file mode 100644
index 0000000..dcc94f7
--- /dev/null
+++ b/codemp/icarus/Q3_Registers.h
@@ -0,0 +1,36 @@
+#ifndef __Q3_REGISTERS__
+#define __Q3_REGISTERS__
+
+enum
+{
+	VTYPE_NONE = 0,
+	VTYPE_FLOAT,
+	VTYPE_STRING,
+	VTYPE_VECTOR,
+};
+
+#ifdef __cplusplus
+
+#define	MAX_VARIABLES	32
+
+typedef map < string, string >		varString_m;
+typedef map < string, float >		varFloat_m;
+
+extern	varString_m	varStrings;
+extern	varFloat_m	varFloats;
+extern	varString_m	varVectors;
+
+extern void Q3_InitVariables( void );
+extern void Q3_DeclareVariable( int type, const char *name );
+extern void Q3_FreeVariable( const char *name );
+extern int  Q3_GetStringVariable( const char *name, const char **value );
+extern int  Q3_GetFloatVariable( const char *name, float *value );
+extern int  Q3_GetVectorVariable( const char *name, vec3_t value );
+extern int  Q3_VariableDeclared( const char *name );
+extern int  Q3_SetFloatVariable( const char *name, float value );
+extern int  Q3_SetStringVariable( const char *name, const char *value );
+extern int  Q3_SetVectorVariable( const char *name, const char *value );
+
+#endif //__cplusplus
+
+#endif	//__Q3_REGISTERS__
diff --git a/codemp/icarus/Sequence.cpp b/codemp/icarus/Sequence.cpp
new file mode 100644
index 0000000..6331aea
--- /dev/null
+++ b/codemp/icarus/Sequence.cpp
@@ -0,0 +1,559 @@
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+// Script Command Sequences
+//
+//	-- jweier
+
+// this include must remain at the top of every Icarus CPP file
+#include "icarus.h"
+
+#include <assert.h>
+
+CSequence::CSequence( void )
+{
+	m_numCommands	= 0;
+	m_flags			= 0;
+	m_iterations	= 1;
+
+	m_parent		= NULL;
+	m_return		= NULL;
+}
+
+CSequence::~CSequence( void )
+{
+	Delete();
+}
+
+/*
+-------------------------
+Create
+-------------------------
+*/
+
+CSequence *CSequence::Create( void )
+{
+	CSequence *seq = new CSequence;
+
+	//TODO: Emit warning
+	assert(seq);
+	if ( seq == NULL )
+		return NULL;
+
+	seq->SetFlag( SQ_COMMON );
+
+	return seq;
+}
+
+/*
+-------------------------
+Delete
+-------------------------
+*/
+
+void CSequence::Delete( void )
+{
+	block_l::iterator	bi;
+	sequence_l::iterator si;
+
+	//Notify the parent of the deletion
+	if ( m_parent )
+	{
+		m_parent->RemoveChild( this );
+	}
+
+	//Clear all children
+	if ( m_children.size() > 0 )
+	{
+		/*for ( iterSeq = m_childrenMap.begin(); iterSeq != m_childrenMap.end(); iterSeq++ )
+		{
+			(*iterSeq).second->SetParent( NULL );
+		}*/
+		
+		for ( si = m_children.begin(); si != m_children.end(); si++ )
+		{
+			(*si)->SetParent( NULL );
+		}
+	}
+	m_children.clear();
+
+	//Clear all held commands
+	for ( bi = m_commands.begin(); bi != m_commands.end(); bi++ )
+	{
+		delete (*bi);	//Free() handled internally
+	}
+
+	m_commands.clear();
+}
+
+
+/*
+-------------------------
+AddChild
+-------------------------
+*/
+
+void CSequence::AddChild( CSequence *child )
+{
+	assert( child );
+	if ( child == NULL )
+		return;
+
+	m_children.insert( m_children.end(), child );
+}
+
+/*
+-------------------------
+RemoveChild
+-------------------------
+*/
+
+void CSequence::RemoveChild( CSequence *child )
+{
+	assert( child );
+	if ( child == NULL )
+		return;
+	
+	//Remove the child
+	m_children.remove( child );
+}
+
+/*
+-------------------------
+HasChild
+-------------------------
+*/
+
+bool CSequence::HasChild( CSequence *sequence )
+{
+	sequence_l::iterator	ci;
+
+	for ( ci = m_children.begin(); ci != m_children.end(); ci++ )
+	{
+		if ( (*ci) == sequence )
+			return true;
+
+		if ( (*ci)->HasChild( sequence ) )
+			return true;
+	}
+
+	return false;
+}
+
+/*
+-------------------------
+SetParent
+-------------------------
+*/
+
+void CSequence::SetParent( CSequence *parent )
+{
+	m_parent = parent;
+
+	if ( parent == NULL )
+		return;
+
+	//Inherit the parent's properties (this avoids messy tree walks later on)
+	if ( parent->m_flags & SQ_RETAIN )
+		m_flags |= SQ_RETAIN;
+
+	if ( parent->m_flags & SQ_PENDING )
+		m_flags |= SQ_PENDING;	
+}
+
+/*
+-------------------------
+PopCommand
+-------------------------
+*/
+
+CBlock *CSequence::PopCommand( int type )
+{
+	CBlock	*command = NULL;
+
+	//Make sure everything is ok
+	assert( (type == POP_FRONT) || (type == POP_BACK) );
+
+	if ( m_commands.empty() )
+		return NULL;
+
+	switch ( type )
+	{
+	case POP_FRONT:
+
+		command = m_commands.front();
+		m_commands.pop_front();
+		m_numCommands--;
+	
+		return command;
+		break;
+
+	case POP_BACK:
+
+		command = m_commands.back();
+		m_commands.pop_back();
+		m_numCommands--;
+		
+		return command;
+		break;
+	}
+
+	//Invalid flag
+	return NULL;
+}
+
+/*
+-------------------------
+PushCommand
+-------------------------
+*/
+
+int CSequence::PushCommand( CBlock *block, int type )
+{
+	//Make sure everything is ok
+	assert( (type == PUSH_FRONT) || (type == PUSH_BACK) );
+	assert( block );
+
+	switch ( type )
+	{
+	case PUSH_FRONT:
+		
+		m_commands.push_front( block );
+		m_numCommands++;
+
+		return true;
+		break;
+
+	case PUSH_BACK:
+
+		m_commands.push_back( block );
+		m_numCommands++;
+
+		return true;
+		break;
+	}
+
+	//Invalid flag
+	return false;
+}
+
+/*
+-------------------------
+SetFlag
+-------------------------
+*/
+
+void CSequence::SetFlag( int flag )
+{
+	m_flags |= flag;
+}
+
+/*
+-------------------------
+RemoveFlag
+-------------------------
+*/
+
+void CSequence::RemoveFlag( int flag, bool children )
+{
+	m_flags &= ~flag;
+
+	if ( children )
+	{
+		sequence_l::iterator	si;
+
+		for ( si = m_children.begin(); si != m_children.end(); si++ )
+		{
+			(*si)->RemoveFlag( flag, true );
+		}
+	}
+}
+
+/*
+-------------------------
+HasFlag
+-------------------------
+*/
+
+int CSequence::HasFlag( int flag )
+{
+	return (m_flags & flag);
+}
+
+/*
+-------------------------
+SetReturn
+-------------------------
+*/
+
+void CSequence::SetReturn ( CSequence *sequence )
+{
+	assert( sequence != this );
+	m_return = sequence;
+}
+
+/*
+-------------------------
+GetChild
+-------------------------
+*/
+
+CSequence *CSequence::GetChildByIndex( int iIndex )
+{
+	if ( iIndex < 0 || iIndex >= (int)m_children.size() )
+		return NULL;
+
+	sequence_l::iterator iterSeq = m_children.begin();
+	for ( int i = 0; i < iIndex; i++  )
+	{
+		++iterSeq;
+	}
+	return (*iterSeq);
+}
+
+/*
+-------------------------
+SaveCommand
+-------------------------
+*/
+
+int CSequence::SaveCommand( CBlock *block )
+{
+	unsigned char	flags;
+	int				numMembers, bID, size;
+	CBlockMember	*bm;
+	
+	//Save out the block ID
+	bID = block->GetBlockID();
+	(m_owner->GetInterface())->I_WriteSaveData( 'BLID', &bID, sizeof ( bID ) );
+
+	//Save out the block's flags
+	flags = block->GetFlags();
+	(m_owner->GetInterface())->I_WriteSaveData( 'BFLG', &flags, sizeof ( flags ) );
+
+	//Save out the number of members to read
+	numMembers = block->GetNumMembers();
+	(m_owner->GetInterface())->I_WriteSaveData( 'BNUM', &numMembers, sizeof ( numMembers ) );
+
+	for ( int i = 0; i < numMembers; i++ )
+	{
+		bm = block->GetMember( i );
+
+		//Save the block id
+		bID = bm->GetID();
+		(m_owner->GetInterface())->I_WriteSaveData( 'BMID', &bID, sizeof ( bID ) );
+		
+		//Save out the data size
+		size = bm->GetSize();
+		(m_owner->GetInterface())->I_WriteSaveData( 'BSIZ', &size, sizeof( size ) );
+		
+		//Save out the raw data
+		(m_owner->GetInterface())->I_WriteSaveData( 'BMEM', bm->GetData(), size );
+	}
+
+	return true;
+}
+
+/*
+-------------------------
+Save
+-------------------------
+*/
+
+int CSequence::Save( void )
+{
+#if 0 //piss off, stupid function
+	sequence_l::iterator	ci;
+	block_l::iterator		bi;
+	int						id;
+
+	//Save the parent (by GUID)
+	id = ( m_parent != NULL ) ? m_parent->GetID() : -1;
+	(m_owner->GetInterface())->I_WriteSaveData( 'SPID', &id, sizeof( id ) );
+
+	//Save the return (by GUID)
+	id = ( m_return != NULL ) ? m_return->GetID() : -1;
+	(m_owner->GetInterface())->I_WriteSaveData( 'SRID', &id, sizeof( id ) );
+	
+	//Save the number of children
+//	(m_owner->GetInterface())->I_WriteSaveData( 'SNCH', &m_numChildren, sizeof( m_numChildren ) );
+
+	//Save out the children (only by GUID)
+	STL_ITERATE( ci, m_children )
+	{
+		id = (*ci)->GetID();
+		(m_owner->GetInterface())->I_WriteSaveData( 'SCHD', &id, sizeof( id ) );
+	}
+
+	//Save flags
+	(m_owner->GetInterface())->I_WriteSaveData( 'SFLG', &m_flags, sizeof( m_flags ) );
+
+	//Save iterations
+	(m_owner->GetInterface())->I_WriteSaveData( 'SITR', &m_iterations, sizeof( m_iterations ) );
+
+	//Save the number of commands
+	(m_owner->GetInterface())->I_WriteSaveData( 'SNMC', &m_numCommands, sizeof( m_numCommands ) );
+
+	//Save the commands
+	STL_ITERATE( bi, m_commands )
+	{
+		SaveCommand( (*bi) );
+	}
+
+	return true;
+#endif
+	return false;
+}
+
+/*
+-------------------------
+Load
+-------------------------
+*/
+
+int CSequence::Load( void )
+{
+#if 0 //piss off, stupid function
+	unsigned char	flags; 
+	CSequence		*sequence;
+	CBlock			*block;
+	int				id, numMembers;
+
+	int				bID, bSize;
+	void			*bData;
+
+	//Get the parent sequence
+	(m_owner->GetInterface())->I_ReadSaveData( 'SPID', &id, sizeof( id ) );
+	m_parent = ( id != -1 ) ? m_owner->GetSequence( id ) : NULL;
+	
+	//Get the return sequence
+	(m_owner->GetInterface())->I_ReadSaveData( 'SRID', &id, sizeof( id ) );
+	m_return = ( id != -1 ) ? m_owner->GetSequence( id ) : NULL;
+
+	//Get the number of children
+//	(m_owner->GetInterface())->I_ReadSaveData( 'SNCH', &m_numChildren, sizeof( m_numChildren ) );
+
+	//Reload all children
+	for ( int i = 0; i < m_numChildren; i++ )
+	{
+		//Get the child sequence ID
+		(m_owner->GetInterface())->I_ReadSaveData( 'SCHD', &id, sizeof( id ) );
+
+		//Get the desired sequence
+		if ( ( sequence = m_owner->GetSequence( id ) ) == NULL )
+			return false;
+		
+		//Insert this into the list
+		STL_INSERT( m_children, sequence );
+
+		//Restore the connection in the child / ID map
+//		m_childrenMap[ i ] = sequence;
+	}
+
+	
+	//Get the sequence flags
+	(m_owner->GetInterface())->I_ReadSaveData( 'SFLG', &m_flags, sizeof( m_flags ) );
+
+	//Get the number of iterations
+	(m_owner->GetInterface())->I_ReadSaveData( 'SITR', &m_iterations, sizeof( m_iterations ) );
+
+	int	numCommands;
+
+	//Get the number of commands
+	(m_owner->GetInterface())->I_ReadSaveData( 'SNMC', &numCommands, sizeof( m_numCommands ) );
+
+	//Get all the commands
+	for ( i = 0; i < numCommands; i++ )
+	{
+		//Get the block ID and create a new container
+		(m_owner->GetInterface())->I_ReadSaveData( 'BLID', &id, sizeof( id ) );
+		block = new CBlock;
+		
+		block->Create( id );
+		
+		//Read the block's flags
+		(m_owner->GetInterface())->I_ReadSaveData( 'BFLG', &flags, sizeof( flags ) );
+		block->SetFlags( flags );
+
+		//Get the number of block members
+		(m_owner->GetInterface())->I_ReadSaveData( 'BNUM', &numMembers, sizeof( numMembers ) );
+		
+		for ( int j = 0; j < numMembers; j++ )
+		{
+			//Get the member ID
+			(m_owner->GetInterface())->I_ReadSaveData( 'BMID', &bID, sizeof( bID ) );
+			
+			//Get the member size
+			(m_owner->GetInterface())->I_ReadSaveData( 'BSIZ', &bSize, sizeof( bSize ) );
+
+			//Get the member's data
+			if ( ( bData = ICARUS_Malloc( bSize ) ) == NULL )
+				return false;
+
+			//Get the actual raw data
+			(m_owner->GetInterface())->I_ReadSaveData( 'BMEM', bData, bSize );
+
+			//Write out the correct type
+			switch ( bID )
+			{
+			case TK_INT:
+				{
+					assert(0);
+					int data = *(int *) bData;
+					block->Write( TK_FLOAT, (float) data );
+				}
+				break;
+
+			case TK_FLOAT:
+				block->Write( TK_FLOAT, *(float *) bData );
+				break;
+
+			case TK_STRING:
+			case TK_IDENTIFIER:
+			case TK_CHAR:
+				block->Write( TK_STRING, (char *) bData );
+				break;
+
+			case TK_VECTOR:
+			case TK_VECTOR_START:
+				block->Write( TK_VECTOR, *(vec3_t *) bData );
+				break;
+
+			case ID_TAG:
+				block->Write( ID_TAG, (float) ID_TAG );
+				break;
+
+			case ID_GET:
+				block->Write( ID_GET, (float) ID_GET );
+				break;
+
+			case ID_RANDOM:
+				block->Write( ID_RANDOM, *(float *) bData );//(float) ID_RANDOM );
+				break;
+			
+			case TK_EQUALS:
+			case TK_GREATER_THAN:
+			case TK_LESS_THAN:
+			case TK_NOT:
+				block->Write( bID, 0 );
+				break;
+
+			default:
+				assert(0);
+				return false;
+				break;
+			}
+			
+			//Get rid of the temp memory
+			ICARUS_Free( bData );
+		}
+
+		//Save the block
+		//STL_INSERT( m_commands, block );
+		PushCommand( block, PUSH_BACK );
+	}
+
+	return true;
+#endif
+	return false;
+}
diff --git a/codemp/icarus/Sequencer.cpp b/codemp/icarus/Sequencer.cpp
new file mode 100644
index 0000000..c97be55
--- /dev/null
+++ b/codemp/icarus/Sequencer.cpp
@@ -0,0 +1,2483 @@
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+// Script Command Sequencer
+//
+//	-- jweier
+
+// this include must remain at the top of every Icarus CPP file
+#include "icarus.h"
+//#include "g_headers.h"
+
+#include "assert.h"
+
+// Sequencer 
+
+CSequencer::CSequencer( void )
+{
+	m_numCommands	= 0;
+
+	m_curStream		= NULL;
+	m_curSequence	= NULL;
+
+	m_elseValid = 0;
+	m_elseOwner = NULL;
+
+	m_curGroup = NULL;
+}
+
+CSequencer::~CSequencer( void )
+{
+	Free();	//Safe even if already freed
+}
+
+/*
+========================
+Create
+
+Static creation function
+========================
+*/
+
+CSequencer *CSequencer::Create ( void )
+{
+	CSequencer *sequencer = new CSequencer;
+
+	return sequencer;
+}
+
+/*
+========================
+Init
+
+Initializes the sequencer
+========================
+*/
+int CSequencer::Init( int ownerID, interface_export_t *ie, CTaskManager *taskManager, ICARUS_Instance *iICARUS )
+{
+	m_ownerID		= ownerID;
+	m_owner			= iICARUS;
+	m_taskManager	= taskManager;
+	m_ie			= ie;
+
+	return SEQ_OK;
+}
+
+/*
+========================
+Free
+
+Releases all resources and re-inits the sequencer
+========================
+*/
+int CSequencer::Free( void )
+{
+	sequence_l::iterator	sli;
+
+	//Flush the sequences
+	for ( sli = m_sequences.begin(); sli != m_sequences.end(); sli++ )
+	{
+		m_owner->DeleteSequence( (*sli) );
+	}
+
+	m_sequences.clear();
+	m_taskSequences.clear();
+
+	//Clean up any other info
+	m_numCommands = 0;
+	m_curSequence = NULL;
+
+	bstream_t *streamToDel;
+	while(!m_streamsCreated.empty())
+	{
+		streamToDel = m_streamsCreated.back();
+		DeleteStream(streamToDel);
+	}
+
+	return SEQ_OK;
+}
+
+/*
+-------------------------
+Flush
+-------------------------
+*/
+
+int CSequencer::Flush( CSequence *owner )
+{
+	if ( owner == NULL )
+		return SEQ_FAILED;
+	
+	Recall();
+
+	sequence_l::iterator	sli;
+
+	//Flush the sequences
+	for ( sli = m_sequences.begin(); sli != m_sequences.end(); )
+	{
+		if ( ( (*sli) == owner ) || ( owner->HasChild( (*sli) ) ) || ( (*sli)->HasFlag( SQ_PENDING ) ) || ( (*sli)->HasFlag( SQ_TASK ) ) )
+		{
+			sli++;
+			continue;
+		}
+
+		//Delete it, and remove all references
+		RemoveSequence( (*sli) );
+		m_owner->DeleteSequence( (*sli) );
+		
+		//Delete from the sequence list and move on
+		sli = m_sequences.erase( sli );
+	}
+
+	//Make sure this owner knows it's now the root sequence
+	owner->SetParent( NULL );
+	owner->SetReturn( NULL );
+
+	return SEQ_OK;
+}
+
+/*
+========================
+AddStream
+
+Creates a stream for parsing
+========================
+*/
+
+bstream_t *CSequencer::AddStream( void )
+{
+	bstream_t	*stream;
+
+	stream = new bstream_t;				//deleted in Route()
+	stream->stream = new CBlockStream;	//deleted in Route()
+	stream->last = m_curStream;
+
+	m_streamsCreated.push_back(stream);
+
+	return stream;
+}
+
+/*
+========================
+DeleteStream
+
+Deletes parsing stream
+========================
+*/
+void CSequencer::DeleteStream( bstream_t *bstream )
+{
+	vector<bstream_t*>::iterator finder = find(m_streamsCreated.begin(), m_streamsCreated.end(), bstream);
+	if(finder != m_streamsCreated.end())
+	{
+		m_streamsCreated.erase(finder);
+	}
+
+	bstream->stream->Free();
+	
+	delete bstream->stream;
+	delete bstream;
+
+	bstream = NULL;
+}
+
+/*
+-------------------------
+AddTaskSequence
+-------------------------
+*/
+
+void CSequencer::AddTaskSequence( CSequence *sequence, CTaskGroup *group )
+{
+	m_taskSequences[ group ] = sequence;
+}
+
+/*
+-------------------------
+GetTaskSequence
+-------------------------
+*/
+
+CSequence *CSequencer::GetTaskSequence( CTaskGroup *group )
+{
+	taskSequence_m::iterator	tsi;
+
+	tsi = m_taskSequences.find( group );
+
+	if ( tsi == m_taskSequences.end() )
+		return NULL;
+
+	return (*tsi).second;
+}
+
+/*
+========================
+AddSequence
+
+Creates and adds a sequence to the sequencer
+========================
+*/
+
+CSequence *CSequencer::AddSequence( void )
+{
+	CSequence	*sequence = m_owner->GetSequence();
+
+	assert( sequence );
+	if ( sequence == NULL )
+		return NULL;
+
+	//Add it to the list
+	m_sequences.insert( m_sequences.end(), sequence );
+
+	//FIXME: Temp fix
+	sequence->SetFlag( SQ_PENDING );
+
+	return sequence;
+}
+
+CSequence *CSequencer::AddSequence( CSequence *parent, CSequence *returnSeq, int flags )
+{
+	CSequence	*sequence = m_owner->GetSequence();
+
+	assert( sequence );
+	if ( sequence == NULL )
+		return NULL;
+
+	//Add it to the list
+	m_sequences.insert( m_sequences.end(), sequence );
+
+	sequence->SetFlags( flags );
+	sequence->SetParent( parent );
+	sequence->SetReturn( returnSeq );
+	
+	return sequence;
+}
+
+/*
+========================
+GetSequence
+
+Retrieves a sequence by its ID
+========================
+*/
+
+CSequence *CSequencer::GetSequence( int id )
+{
+/*	sequenceID_m::iterator mi;
+	
+	mi = m_sequenceMap.find( id );
+
+	if ( mi == m_sequenceMap.end() )
+		return NULL;
+	
+	return (*mi).second;*/
+	
+	sequence_l::iterator iterSeq;
+	STL_ITERATE( iterSeq, m_sequences )
+	{
+		if ( (*iterSeq)->GetID() == id )
+			return (*iterSeq);
+	}
+
+	return NULL;
+}
+
+/*
+-------------------------
+Interrupt
+-------------------------
+*/
+
+void CSequencer::Interrupt( void )
+{
+	CBlock	*command = m_taskManager->GetCurrentTask();
+
+	if ( command == NULL )
+		return;
+
+	//Save it
+	PushCommand( command, PUSH_BACK );
+}
+
+/*
+========================
+Run
+
+Runs a script
+========================
+*/
+int CSequencer::Run( char *buffer, long size )
+{
+	bstream_t		*blockStream;
+	
+	Recall();
+
+	//Create a new stream
+	blockStream = AddStream();
+	
+	//Open the stream as an IBI stream
+	if (!blockStream->stream->Open( buffer, size ))
+	{
+		m_ie->I_DPrintf( WL_ERROR, "invalid stream" );
+		return SEQ_FAILED;
+	}
+
+	CSequence *sequence = AddSequence( NULL, m_curSequence, SQ_COMMON );
+
+	// Interpret the command blocks and route them properly 
+	if ( S_FAILED( Route( sequence, blockStream )) )
+	{
+		//Error code is set inside of Route()
+		return SEQ_FAILED;
+	}
+
+	return SEQ_OK;
+}
+
+/*
+========================
+ParseRun
+
+Parses a user triggered run command
+========================
+*/
+
+int CSequencer::ParseRun( CBlock *block )
+{
+	CSequence	*new_sequence;
+	bstream_t	*new_stream;
+	char		*buffer;
+	char		newname[ MAX_STRING_SIZE ];
+	int			buffer_size;
+
+	//Get the name and format it
+	StripExtension( (char*) block->GetMemberData( 0 ), (char *) newname );
+
+	//Get the file from the game engine
+  	buffer_size = m_ie->I_LoadFile( newname, (void **) &buffer );
+
+	if ( buffer_size <= 0 )
+	{
+		m_ie->I_DPrintf( WL_ERROR, "'%s' : could not open file\n", (char*) block->GetMemberData( 0 ));
+		delete block;
+		block = NULL;
+		return SEQ_FAILED;
+	}
+
+	//Create a new stream for this file
+	new_stream = AddStream();
+
+	//Begin streaming the file
+	if (!new_stream->stream->Open( buffer, buffer_size ))
+	{
+		m_ie->I_DPrintf( WL_ERROR, "invalid stream" );
+		delete block;
+		block = NULL;
+		return SEQ_FAILED;
+	}
+
+	//Create a new sequence
+	new_sequence = AddSequence( m_curSequence, m_curSequence, ( SQ_RUN | SQ_PENDING ) );
+
+	m_curSequence->AddChild( new_sequence );
+
+	// Interpret the command blocks and route them properly 
+	if ( S_FAILED( Route( new_sequence, new_stream )) )
+	{
+		//Error code is set inside of Route()
+		delete block;
+		block = NULL;
+		return SEQ_FAILED;
+	}
+
+	m_curSequence = m_curSequence->GetReturn();
+
+	assert( m_curSequence );
+
+	block->Write( TK_FLOAT, (float) new_sequence->GetID() );
+	PushCommand( block, PUSH_FRONT );
+
+	return SEQ_OK;
+}
+
+/*
+========================
+ParseIf
+
+Parses an if statement
+========================
+*/
+
+int CSequencer::ParseIf( CBlock *block, bstream_t *bstream )
+{
+	CSequence	*sequence;
+		
+	//Create the container sequence
+	sequence = AddSequence( m_curSequence, m_curSequence, SQ_CONDITIONAL );
+	
+	assert( sequence );
+	if ( sequence == NULL )
+	{
+		m_ie->I_DPrintf( WL_ERROR, "ParseIf: failed to allocate container sequence" );
+		delete block;
+		block = NULL;
+		return SEQ_FAILED;
+	}
+
+	m_curSequence->AddChild( sequence );
+
+	//Add a unique conditional identifier to the block for reference later
+	block->Write( TK_FLOAT, (float) sequence->GetID() );
+
+	//Push this onto the stack to mark the conditional entrance
+	PushCommand( block, PUSH_FRONT );
+	
+	//Recursively obtain the conditional body
+	Route( sequence, bstream );
+
+	m_elseValid = 2;
+	m_elseOwner = block;
+
+	return SEQ_OK;
+}
+
+/*
+========================
+ParseElse
+
+Parses an else statement
+========================
+*/
+
+int CSequencer::ParseElse( CBlock *block, bstream_t *bstream )
+{
+	//The else is not retained
+	delete block;
+	block = NULL;
+	
+	CSequence	*sequence;
+		
+	//Create the container sequence
+	sequence = AddSequence( m_curSequence, m_curSequence, SQ_CONDITIONAL );
+	
+	assert( sequence );
+	if ( sequence == NULL )
+	{
+		m_ie->I_DPrintf( WL_ERROR, "ParseIf: failed to allocate container sequence" );
+		return SEQ_FAILED;
+	}
+
+	m_curSequence->AddChild( sequence );
+
+	//Add a unique conditional identifier to the block for reference later
+	//TODO: Emit warning
+	if ( m_elseOwner == NULL )
+	{
+		m_ie->I_DPrintf( WL_ERROR, "Invalid 'else' found!\n" );
+		return SEQ_FAILED;
+	}
+
+	m_elseOwner->Write( TK_FLOAT, (float) sequence->GetID() );
+	
+	m_elseOwner->SetFlag( BF_ELSE );
+
+	//Recursively obtain the conditional body
+	Route( sequence, bstream );
+
+	m_elseValid = 0;
+	m_elseOwner = NULL;
+
+	return SEQ_OK;
+}
+
+/*
+========================
+ParseLoop
+
+Parses a loop command
+========================
+*/
+
+int CSequencer::ParseLoop( CBlock *block, bstream_t *bstream )
+{
+	CSequence		*sequence;
+	CBlockMember	*bm;
+	float			min, max;
+	int				rIter;
+	int				memberNum = 0;
+		
+	//Set the parent
+	sequence = AddSequence( m_curSequence, m_curSequence, ( SQ_LOOP | SQ_RETAIN ) );
+	
+	assert( sequence );
+	if ( sequence == NULL )
+	{
+		m_ie->I_DPrintf( WL_ERROR, "ParseLoop : failed to allocate container sequence" );
+		delete block;
+		block = NULL;	
+		return SEQ_FAILED;
+	}
+
+	m_curSequence->AddChild( sequence );
+
+	//Set the number of iterations of this sequence
+	
+	bm = block->GetMember( memberNum++ );
+
+	if ( bm->GetID() == ID_RANDOM )
+	{
+		//Parse out the random number
+		min = *(float *) block->GetMemberData( memberNum++ );
+		max = *(float *) block->GetMemberData( memberNum++ );
+		
+		rIter = (int) m_ie->I_Random( min, max );
+		sequence->SetIterations( rIter );
+	}
+	else
+	{
+		sequence->SetIterations ( (int) (*(float *) bm->GetData()) );
+	}
+	
+	//Add a unique loop identifier to the block for reference later
+	block->Write( TK_FLOAT, (float) sequence->GetID() );
+
+	//Push this onto the stack to mark the loop entrance
+	PushCommand( block, PUSH_FRONT );
+	
+	//Recursively obtain the loop
+	Route( sequence, bstream );
+
+	return SEQ_OK;
+}
+
+/*
+========================
+AddAffect
+
+Adds a sequence that is saved until the affect is called by the parent
+========================
+*/
+
+int CSequencer::AddAffect( bstream_t *bstream, int retain, int *id )
+{
+	CSequence	*sequence = AddSequence();
+	bstream_t	new_stream;
+
+	sequence->SetFlag( SQ_AFFECT | SQ_PENDING );
+
+	if ( retain )
+		sequence->SetFlag( SQ_RETAIN );
+
+	//This will be replaced once it's actually used, but this will restore the route state properly
+	sequence->SetReturn( m_curSequence );
+	
+	//We need this as a temp holder
+	new_stream.last = m_curStream;
+	new_stream.stream = bstream->stream;
+
+	if S_FAILED( Route( sequence, &new_stream ) )
+	{
+		return SEQ_FAILED;
+	}
+
+	*id = sequence->GetID();
+
+	sequence->SetReturn( NULL );
+
+	return SEQ_OK;
+}
+
+/*
+========================
+ParseAffect
+
+Parses an affect command
+========================
+*/
+
+int CSequencer::ParseAffect( CBlock *block, bstream_t *bstream )
+{
+	CSequencer	*stream_sequencer = NULL;
+	char		*entname = NULL;
+	int			ret;
+	sharedEntity_t	*ent = 0;
+
+	entname	= (char*) block->GetMemberData( 0 );
+	ent		= m_ie->I_GetEntityByName( entname );
+
+	if( !ent ) // if there wasn't a valid entname in the affect, we need to check if it's a get command
+	{
+		//try to parse a 'get' command that is embeded in this 'affect'
+	
+		int				id;
+		char			*p1 = NULL;
+		char			*name = 0;
+		CBlockMember	*bm = NULL;
+		//
+		//	Get the first parameter (this should be the get)
+		//
+		bm = block->GetMember( 0 );
+		id = bm->GetID();
+	
+		switch ( id )
+		{
+			// these 3 cases probably aren't necessary
+			case TK_STRING:
+			case TK_IDENTIFIER:
+			case TK_CHAR:
+				p1 = (char *) bm->GetData();
+			break;
+
+			case ID_GET:		
+			{
+				int		type;				
+
+				//get( TYPE, NAME )
+				type = (int) (*(float *) block->GetMemberData( 1 ));
+				name = (char *) block->GetMemberData( 2 );
+
+				switch ( type ) // what type are they attempting to get
+				{
+			
+					case TK_STRING:
+						//only string is acceptable for affect, store result in p1
+						if ( m_ie->I_GetString( m_ownerID, type, name, &p1 ) == false)
+						{
+							delete block;
+							block = NULL;
+							return false;
+						}
+						break;
+					default:
+						//FIXME: Make an enum id for the error...
+						m_ie->I_DPrintf( WL_ERROR, "Invalid parameter type on affect _1" );
+						delete block;
+						block = NULL;
+						return false;
+						break;
+				}
+
+				break;
+			}
+
+			default:
+			//FIXME: Make an enum id for the error...
+				m_ie->I_DPrintf( WL_ERROR, "Invalid parameter type on affect _2" );
+				delete block;
+				block = NULL;
+				return false;
+				break;
+		}//end id switch
+
+		if(p1)
+		{
+			ent = m_ie->I_GetEntityByName( p1 );
+		}
+		if(!ent)
+		{	// a valid entity name was not returned from the get command
+			m_ie->I_DPrintf( WL_WARNING, "'%s' : invalid affect() target\n");
+		}
+	
+	} // end if(!ent)
+
+	if( ent )
+	{
+		stream_sequencer = gSequencers[ent->s.number];//ent->sequencer;
+	}
+
+	if (stream_sequencer == NULL)
+	{
+		m_ie->I_DPrintf( WL_WARNING, "'%s' : invalid affect() target\n", entname );
+		
+		//Fast-forward out of this affect block onto the next valid code
+		CSequence *backSeq = m_curSequence;
+
+		CSequence *trashSeq = m_owner->GetSequence();
+		Route( trashSeq, bstream );
+		Recall();
+		DestroySequence( trashSeq );
+		m_curSequence = backSeq;
+		delete block;
+		block = NULL;
+		return SEQ_OK;
+	}
+
+	if S_FAILED ( stream_sequencer->AddAffect( bstream, (int) m_curSequence->HasFlag( SQ_RETAIN ), &ret ) )
+	{
+		delete block;
+		block = NULL;
+		return SEQ_FAILED;
+	}
+
+	//Hold onto the id for later use
+	//FIXME: If the target sequence is freed, what then?		(!suspect!)
+
+	block->Write( TK_FLOAT, (float) ret );
+	
+	PushCommand( block, PUSH_FRONT );
+	/*
+	//Don't actually do these right now, we're just pre-processing (parsing) the affect
+	if( ent )
+	{	// ents need to update upon being affected 
+		ent->taskManager->Update();
+	}
+	*/
+
+	return SEQ_OK;
+}
+
+/*
+-------------------------
+ParseTask
+-------------------------
+*/
+
+int CSequencer::ParseTask( CBlock *block, bstream_t *bstream )
+{
+	CSequence	*sequence;
+	CTaskGroup	*group;
+	const char	*taskName;
+
+	//Setup the container sequence
+	sequence = AddSequence( m_curSequence, m_curSequence, SQ_TASK | SQ_RETAIN );
+	m_curSequence->AddChild( sequence );
+
+	//Get the name of this task for reference later
+	taskName = (const char *) block->GetMemberData( 0 );
+
+	//Get a new task group from the task manager
+	group = m_taskManager->AddTaskGroup( taskName );
+
+	if ( group == NULL )
+	{
+		m_ie->I_DPrintf( WL_ERROR, "error : unable to allocate a new task group" );
+		delete block;
+		block = NULL;
+		return SEQ_FAILED;
+	}
+
+	//The current group is set to this group, all subsequent commands (until a block end) will fall into this task group
+	group->SetParent( m_curGroup );
+	m_curGroup = group;
+	
+	//Keep an association between this task and the container sequence
+	AddTaskSequence( sequence, group );
+
+	//PushCommand( block, PUSH_FRONT );
+	delete block;
+	block = NULL;
+
+	//Recursively obtain the loop
+	Route( sequence, bstream );
+
+	return SEQ_OK;
+}
+
+/*
+========================
+Route
+
+Properly handles and routes commands to the sequencer
+========================
+*/
+
+//FIXME: Re-entering this code will produce unpredictable results if a script has already been routed and is running currently
+
+//FIXME: A sequencer cannot properly affect itself
+
+int CSequencer::Route( CSequence *sequence, bstream_t *bstream )
+{
+	CBlockStream	*stream;
+	CBlock			*block;
+
+	//Take the stream as the current stream
+	m_curStream = bstream;
+	stream = bstream->stream;
+
+	m_curSequence = sequence;
+
+	//Obtain all blocks
+	while ( stream->BlockAvailable() )
+	{
+		block = new CBlock;		//deleted in Free()
+		stream->ReadBlock( block );
+
+		//TEMP: HACK!
+		if ( m_elseValid )
+			m_elseValid--;
+
+		switch( block->GetBlockID() )
+		{
+		//Marks the end of a blocked section
+		case ID_BLOCK_END:
+			
+			//Save this as a pre-process marker
+			PushCommand( block, PUSH_FRONT );
+	
+			if ( m_curSequence->HasFlag( SQ_RUN ) || m_curSequence->HasFlag( SQ_AFFECT ) )
+			{
+				//Go back to the last stream
+				m_curStream = bstream->last;
+			}
+
+			if ( m_curSequence->HasFlag( SQ_TASK ) )
+			{
+				//Go back to the last stream
+				m_curStream = bstream->last;
+				m_curGroup = m_curGroup->GetParent();
+			}
+	
+			m_curSequence = m_curSequence->GetReturn();
+
+			return SEQ_OK;
+			break;
+
+		//Affect pre-processor
+		case ID_AFFECT:
+
+			if S_FAILED( ParseAffect( block, bstream ) )
+				return SEQ_FAILED;
+
+			break;
+
+		//Run pre-processor
+		case ID_RUN:
+
+			if S_FAILED( ParseRun( block ) )
+				return SEQ_FAILED;
+
+			break;
+
+		//Loop pre-processor
+		case ID_LOOP:
+			
+			if S_FAILED( ParseLoop( block, bstream ) )
+				return SEQ_FAILED;
+
+			break;
+
+		//Conditional pre-processor
+		case ID_IF:
+
+			if S_FAILED( ParseIf( block, bstream ) )
+				return SEQ_FAILED;
+
+			break;
+
+		case ID_ELSE:
+
+			//TODO: Emit warning
+			if ( m_elseValid == 0 )
+			{
+				m_ie->I_DPrintf( WL_ERROR, "Invalid 'else' found!\n" );
+				return SEQ_FAILED;
+			}
+
+			if S_FAILED( ParseElse( block, bstream ) )
+				return SEQ_FAILED;
+
+			break;
+
+		case ID_TASK:
+			
+			if S_FAILED( ParseTask( block, bstream ) )
+				return SEQ_FAILED;
+
+			break;
+
+		//FIXME: For now this is to catch problems, but can ultimately be removed
+		case ID_WAIT:
+		case ID_PRINT:
+		case ID_SOUND:
+		case ID_MOVE:
+		case ID_ROTATE:
+		case ID_SET:
+		case ID_USE:
+		case ID_REMOVE:
+		case ID_KILL:
+		case ID_FLUSH:
+		case ID_CAMERA:
+		case ID_DO:
+		case ID_DECLARE:
+		case ID_FREE:
+		case ID_SIGNAL:
+		case ID_WAITSIGNAL:
+		case ID_PLAY:
+
+			//Commands go directly into the sequence without pre-process
+			PushCommand( block, PUSH_FRONT );
+			break;
+
+		//Error
+		default:
+			
+			m_ie->I_DPrintf( WL_ERROR, "'%d' : invalid block ID", block->GetBlockID() );
+			
+			return SEQ_FAILED;
+			break;
+		}
+	}
+
+	//Check for a run sequence, it must be marked
+	if ( m_curSequence->HasFlag( SQ_RUN ) )
+	{
+		block = new CBlock;
+		block->Create( ID_BLOCK_END );
+		PushCommand( block, PUSH_FRONT );	//mark the end of the run
+
+		/*
+		//Free the stream
+		m_curStream = bstream->last;
+		DeleteStream( bstream );
+		*/
+
+		return SEQ_OK;
+	}
+
+	//Check to start the communication
+	if ( ( bstream->last == NULL ) && ( m_numCommands > 0 ) )
+	{	
+		//Everything is routed, so get it all rolling
+		Prime( m_taskManager, PopCommand( POP_BACK ) );
+	}
+
+	m_curStream = bstream->last;
+
+	//Free the stream
+	DeleteStream( bstream );
+		
+	return SEQ_OK;
+}
+
+/*
+========================
+CheckRun
+
+Checks for run command pre-processing
+========================
+*/
+
+//Directly changes the parameter to avoid excess push/pop
+
+void CSequencer::CheckRun( CBlock **command )
+{
+	CBlock	*block = *command;
+
+	if ( block == NULL )
+		return;
+
+	//Check for a run command
+	if ( block->GetBlockID() == ID_RUN )
+	{
+		int id = (int) (*(float *) block->GetMemberData( 1 ));
+
+		m_ie->I_DPrintf( WL_DEBUG, "%4d run( \"%s\" ); [%d]", m_ownerID, (char *) block->GetMemberData(0), m_ie->I_GetTime() );
+
+		if ( m_curSequence->HasFlag( SQ_RETAIN ) )
+		{
+			PushCommand( block, PUSH_FRONT );
+		}
+		else
+		{
+			delete block;
+			block = NULL;
+
+			*command = NULL;
+		}
+
+		m_curSequence = GetSequence( id );
+		
+		//TODO: Emit warning
+		assert( m_curSequence );
+		if ( m_curSequence == NULL )
+		{
+			m_ie->I_DPrintf( WL_ERROR, "Unable to find 'run' sequence!\n" );
+			*command = NULL;
+			return;
+		}
+
+		if ( m_curSequence->GetNumCommands() > 0 )
+		{
+			*command = PopCommand( POP_BACK );
+			
+			Prep( command );	//Account for any other pre-processes
+			return;
+		}
+
+		return;
+	}
+	
+	//Check for the end of a run
+	if ( ( block->GetBlockID() == ID_BLOCK_END ) && ( m_curSequence->HasFlag( SQ_RUN ) ) )
+	{
+		if ( m_curSequence->HasFlag( SQ_RETAIN ) )
+		{
+			PushCommand( block, PUSH_FRONT );
+		}
+		else
+		{
+			delete block;
+			block = NULL;
+			*command = NULL;
+		}
+
+		m_curSequence = ReturnSequence( m_curSequence );
+
+		if ( m_curSequence && m_curSequence->GetNumCommands() > 0 )
+		{
+			*command = PopCommand( POP_BACK );
+			
+			Prep( command );	//Account for any other pre-processes
+			return;
+		}	
+
+		//FIXME: Check this...
+	}
+}
+
+/*
+-------------------------
+EvaluateConditional
+-------------------------
+*/
+
+//FIXME: This function will be written better later once the functionality of the ideas here are tested
+
+int CSequencer::EvaluateConditional( CBlock *block )
+{
+	CBlockMember	*bm;
+	char			tempString1[128], tempString2[128];
+	vector_t		vec;
+	int				id, i, oper, memberNum = 0;
+	char			*p1 = NULL, *p2 = NULL;
+	int				t1, t2;
+
+	//
+	//	Get the first parameter
+	//
+
+	bm = block->GetMember( memberNum++ );
+	id = bm->GetID();
+
+	t1 = id;
+
+	switch ( id )
+	{
+	case TK_FLOAT:
+		sprintf( (char *) tempString1, "%.3f", *(float *) bm->GetData() );
+		p1 = (char *) tempString1;
+		break;
+
+	case TK_VECTOR:
+
+		tempString1[0] = NULL;
+
+		for ( i = 0; i < 3; i++ )
+		{
+			bm = block->GetMember( memberNum++ );
+			vec[i] = *(float *) bm->GetData();
+		}
+
+		sprintf( (char *) tempString1, "%.3f %.3f %.3f", vec[0], vec[1], vec[2] );
+		p1 = (char *) tempString1;
+
+		break;
+
+	case TK_STRING:
+	case TK_IDENTIFIER:
+	case TK_CHAR:
+
+		p1 = (char *) bm->GetData();
+		break;
+
+	case ID_GET:		
+	{
+			int		type;
+			char	*name;
+
+			//get( TYPE, NAME )
+			type = (int) (*(float *) block->GetMemberData( memberNum++ ));
+			name = (char *) block->GetMemberData( memberNum++ );
+
+			//Get the type returned and hold onto it
+			t1 = type;
+
+			switch ( type )
+			{
+			case TK_FLOAT:
+				{
+					float	fVal;
+
+					if ( m_ie->I_GetFloat( m_ownerID, type, name, &fVal ) == false)
+						return false;
+
+					sprintf( (char *) tempString1, "%.3f", fVal );
+					p1 = (char *) tempString1;
+				}
+				
+				break;
+
+			case TK_INT:
+				{
+					float	fVal;
+
+					if ( m_ie->I_GetFloat( m_ownerID, type, name, &fVal ) == false)
+						return false;
+
+					sprintf( (char *) tempString1, "%d", (int) fVal );
+					p1 = (char *) tempString1;
+				}
+				break;
+
+			case TK_STRING:
+
+				if ( m_ie->I_GetString( m_ownerID, type, name, &p1 ) == false)
+					return false;
+			
+				break;
+
+			case TK_VECTOR:
+				{
+					vector_t	vVal;
+
+					if ( m_ie->I_GetVector( m_ownerID, type, name, vVal ) == false)
+						return false;
+
+					sprintf( (char *) tempString1, "%.3f %.3f %.3f", vVal[0], vVal[1], vVal[2] );
+					p1 = (char *) tempString1;
+				}
+				
+				break;
+		}
+
+		break;
+	}
+
+	case ID_RANDOM:
+		{
+			float	min, max;
+			//FIXME: This will not account for nested random() statements
+
+			min	= *(float *) block->GetMemberData( memberNum++ );
+			max	= *(float *) block->GetMemberData( memberNum++ );
+
+			//A float value is returned from the function
+			t1 = TK_FLOAT;
+
+			sprintf( (char *) tempString1, "%.3f", m_ie->I_Random( min, max ) );
+			p1 = (char *) tempString1;
+		}
+
+		break;
+
+	case ID_TAG:
+		{
+			char	*name;
+			float	type;
+
+			name = (char *) block->GetMemberData( memberNum++ );
+			type = *(float *) block->GetMemberData( memberNum++ );
+
+			t1 = TK_VECTOR;
+
+			//TODO: Emit warning
+			if ( m_ie->I_GetTag( m_ownerID, name, (int) type, vec ) == false)
+			{
+				m_ie->I_DPrintf( WL_ERROR, "Unable to find tag \"%s\"!\n", name );
+				return false;
+			}
+
+			sprintf( (char *) tempString1, "%.3f %.3f %.3f", vec[0], vec[1], vec[2] );
+			p1 = (char *) tempString1;
+
+			break;
+		}
+
+	default:
+		//FIXME: Make an enum id for the error...
+		m_ie->I_DPrintf( WL_ERROR, "Invalid parameter type on conditional" );
+		return false;
+		break;
+	}
+
+	//
+	//	Get the comparison operator
+	//
+
+	bm = block->GetMember( memberNum++ );
+	id = bm->GetID();
+
+	switch ( id )
+	{
+	case TK_EQUALS:
+	case TK_GREATER_THAN:
+	case TK_LESS_THAN:
+	case TK_NOT:
+		oper = id;
+		break;
+
+	default:
+		m_ie->I_DPrintf( WL_ERROR, "Invalid operator type found on conditional!\n" );
+		return false;	//FIXME: Emit warning
+		break;
+	}
+
+	//
+	//	Get the second parameter
+	//
+
+	bm = block->GetMember( memberNum++ );
+	id = bm->GetID();
+
+	t2 = id;
+
+	switch ( id )
+	{
+	case TK_FLOAT:
+		sprintf( (char *) tempString2, "%.3f", *(float *) bm->GetData() );
+		p2 = (char *) tempString2;
+		break;
+
+	case TK_VECTOR:
+
+		tempString2[0] = NULL;
+
+		for ( i = 0; i < 3; i++ )
+		{
+			bm = block->GetMember( memberNum++ );
+			vec[i] = *(float *) bm->GetData();
+		}
+
+		sprintf( (char *) tempString2, "%.3f %.3f %.3f", vec[0], vec[1], vec[2] );
+		p2 = (char *) tempString2;
+
+		break;
+
+	case TK_STRING:
+	case TK_IDENTIFIER:
+	case TK_CHAR:
+
+		p2 = (char *) bm->GetData();
+		break;
+
+	case ID_GET:		
+	{
+			int		type;
+			char	*name;
+
+			//get( TYPE, NAME )
+			type = (int) (*(float *) block->GetMemberData( memberNum++ ));
+			name = (char *) block->GetMemberData( memberNum++ );
+
+			//Get the type returned and hold onto it
+			t2 = type;
+
+			switch ( type )
+			{
+			case TK_FLOAT:
+				{
+					float	fVal;
+
+					if ( m_ie->I_GetFloat( m_ownerID, type, name, &fVal ) == false)
+						return false;
+
+					sprintf( (char *) tempString2, "%.3f", fVal );
+					p2 = (char *) tempString2;
+				}
+				
+				break;
+
+			case TK_INT:
+				{
+					float	fVal;
+
+					if ( m_ie->I_GetFloat( m_ownerID, type, name, &fVal ) == false)
+						return false;
+
+					sprintf( (char *) tempString2, "%d", (int) fVal );
+					p2 = (char *) tempString2;
+				}
+				break;
+
+			case TK_STRING:
+
+				if ( m_ie->I_GetString( m_ownerID, type, name, &p2 ) == false)
+					return false;
+			
+				break;
+
+			case TK_VECTOR:
+				{
+					vector_t	vVal;
+
+					if ( m_ie->I_GetVector( m_ownerID, type, name, vVal ) == false)
+						return false;
+
+					sprintf( (char *) tempString2, "%.3f %.3f %.3f", vVal[0], vVal[1], vVal[2] );
+					p2 = (char *) tempString2;
+				}
+				
+				break;
+		}
+
+		break;
+	}
+
+	case ID_RANDOM:
+		
+		{
+			float	min, max;
+			//FIXME: This will not account for nested random() statements
+
+			min	= *(float *) block->GetMemberData( memberNum++ );
+			max	= *(float *) block->GetMemberData( memberNum++ );
+
+			//A float value is returned from the function
+			t2 = TK_FLOAT;
+
+			sprintf( (char *) tempString2, "%.3f", m_ie->I_Random( min, max ) );
+			p2 = (char *) tempString2;
+		}
+
+		break;
+
+	case ID_TAG:
+
+		{
+			char	*name;
+			float	type;
+
+			name = (char *) block->GetMemberData( memberNum++ );
+			type = *(float *) block->GetMemberData( memberNum++ );
+
+			t2 = TK_VECTOR;
+
+			//TODO: Emit warning
+			if ( m_ie->I_GetTag( m_ownerID, name, (int) type, vec ) == false)
+			{
+				m_ie->I_DPrintf( WL_ERROR, "Unable to find tag \"%s\"!\n", name );
+				return false;
+			}
+
+			sprintf( (char *) tempString2, "%.3f %.3f %.3f", vec[0], vec[1], vec[2] );
+			p2 = (char *) tempString2;
+
+			break;
+		}
+
+	default:
+		//FIXME: Make an enum id for the error...
+		m_ie->I_DPrintf( WL_ERROR, "Invalid parameter type on conditional" );
+		return false;
+		break;
+	}
+
+	return m_ie->I_Evaluate( t1, p1, t2, p2, oper );
+}
+
+/*
+========================
+CheckIf
+
+Checks for if statement pre-processing
+========================
+*/
+
+void CSequencer::CheckIf( CBlock **command )
+{
+	CBlock		*block = *command;
+	int			successID, failureID;
+	CSequence	*successSeq, *failureSeq;
+
+	if ( block == NULL )
+		return;
+
+	if ( block->GetBlockID() == ID_IF )
+	{
+		int ret = EvaluateConditional( block );
+
+		if ( ret /*TRUE*/ )
+		{
+			if ( block->HasFlag( BF_ELSE ) )
+			{
+				successID = (int) (*(float *) block->GetMemberData( block->GetNumMembers() - 2 ));
+			}
+			else
+			{
+				successID = (int) (*(float *) block->GetMemberData( block->GetNumMembers() - 1 ));
+			}
+
+			successSeq = GetSequence( successID );
+
+			//TODO: Emit warning
+			assert( successSeq );
+			if ( successSeq == NULL )
+			{
+				m_ie->I_DPrintf( WL_ERROR, "Unable to find conditional success sequence!\n" );
+				*command = NULL;
+				return;
+			}
+
+			//Only save the conditional statement if the calling sequence is retained
+			if ( m_curSequence->HasFlag( SQ_RETAIN ) )
+			{
+				PushCommand( block, PUSH_FRONT );
+			}
+			else
+			{
+				delete block;
+				block = NULL;
+				*command = NULL;
+			}
+			
+			m_curSequence = successSeq;
+
+			//Recursively work out any other pre-processors
+			*command = PopCommand( POP_BACK );
+			Prep( command );
+			
+			return;			
+		}
+
+		if ( ( ret == false ) && ( block->HasFlag( BF_ELSE ) ) )
+		{
+			failureID = (int) (*(float *) block->GetMemberData( block->GetNumMembers() - 1 ));
+			failureSeq = GetSequence( failureID );
+
+			//TODO: Emit warning
+			assert( failureSeq );
+			if ( failureSeq == NULL )
+			{
+				m_ie->I_DPrintf( WL_ERROR, "Unable to find conditional failure sequence!\n" );
+				*command = NULL;
+				return;
+			}
+
+			//Only save the conditional statement if the calling sequence is retained
+			if ( m_curSequence->HasFlag( SQ_RETAIN ) )
+			{
+				PushCommand( block, PUSH_FRONT );
+			}
+			else
+			{
+				delete block;
+				block = NULL;
+				*command = NULL;
+			}
+			
+			m_curSequence = failureSeq;
+
+			//Recursively work out any other pre-processors
+			*command = PopCommand( POP_BACK );
+			Prep( command );
+			
+			return;			
+		}
+
+		//Only save the conditional statement if the calling sequence is retained
+		if ( m_curSequence->HasFlag( SQ_RETAIN ) )
+		{
+			PushCommand( block, PUSH_FRONT );
+		}
+		else
+		{
+			delete block;
+			block = NULL;
+			*command = NULL;
+		}
+
+		//Conditional failed, just move on to the next command
+		*command = PopCommand( POP_BACK );
+		Prep( command );
+		
+		return;			
+	}
+
+	if ( ( block->GetBlockID() == ID_BLOCK_END ) && ( m_curSequence->HasFlag( SQ_CONDITIONAL ) ) )
+	{
+		assert( m_curSequence->GetReturn() );
+		if ( m_curSequence->GetReturn() == NULL )
+		{
+			*command = NULL;
+			return;
+		}
+
+		//Check to retain it
+		if ( m_curSequence->GetParent()->HasFlag( SQ_RETAIN ) )
+		{
+			PushCommand( block, PUSH_FRONT );
+		}
+		else
+		{
+			delete block;
+			block = NULL;
+			*command = NULL;
+		}
+		
+		//Back out of the conditional and resume the previous sequence
+		m_curSequence = ReturnSequence( m_curSequence );
+		
+		//This can safely happen
+		if ( m_curSequence == NULL )
+		{
+			*command = NULL;
+			return;
+		}
+
+		*command = PopCommand( POP_BACK );
+		Prep( command );
+	}
+}
+
+/*
+========================
+CheckLoop
+
+Checks for loop command pre-processing
+========================
+*/
+
+void CSequencer::CheckLoop( CBlock **command )
+{
+	CBlockMember	*bm;
+	CBlock			*block = *command;
+	float			min, max;
+	int				iterations;
+	int				loopID;
+	int				memberNum = 0;
+			
+	if ( block == NULL )
+		return;
+
+	//Check for a loop
+	if ( block->GetBlockID() == ID_LOOP )
+	{
+		//Get the loop ID
+		bm = block->GetMember( memberNum++ );
+
+		if ( bm->GetID() == ID_RANDOM )
+		{
+			//Parse out the random number
+			min = *(float *) block->GetMemberData( memberNum++ );
+			max = *(float *) block->GetMemberData( memberNum++ );
+			
+			iterations = (int) m_ie->I_Random( min, max );
+		}
+		else
+		{
+			iterations = (int) (*(float *) bm->GetData());
+		}
+		
+		loopID = (int) (*(float *) block->GetMemberData( memberNum++ ));
+
+		CSequence *loop = GetSequence( loopID );
+				
+		//TODO: Emit warning
+		assert( loop );
+		if ( loop == NULL )
+		{
+			m_ie->I_DPrintf( WL_ERROR, "Unable to find 'loop' sequence!\n" );
+			*command = NULL;
+			return;
+		}
+
+		assert( loop->GetParent() );
+		if ( loop->GetParent() == NULL )
+		{
+			*command = NULL;
+			return;
+		}
+
+		//Restore the count if it has been lost
+		loop->SetIterations( iterations );
+
+		//Only save the loop command if the calling sequence is retained
+		if ( m_curSequence->HasFlag( SQ_RETAIN ) )
+		{
+			PushCommand( block, PUSH_FRONT );
+		}
+		else
+		{
+			delete block;
+			block = NULL;
+			*command = NULL;
+		}
+		
+		m_curSequence = loop;
+
+		//Recursively work out any other pre-processors
+		*command = PopCommand( POP_BACK );
+		Prep( command );
+		
+		return;
+	}
+	
+	//Check for the end of the loop
+	if ( ( block->GetBlockID() == ID_BLOCK_END ) && ( m_curSequence->HasFlag( SQ_LOOP ) ) )
+	{
+		//We don't want to decrement -1
+		if ( m_curSequence->GetIterations() > 0 )
+			m_curSequence->SetIterations( m_curSequence->GetIterations()-1 );	//Nice, eh?
+
+		//Either there's another iteration, or it's infinite
+		if ( m_curSequence->GetIterations() != 0 )
+		{
+			//Another iteration is going to happen, so this will need to be considered again
+			PushCommand( block, PUSH_FRONT );
+			
+			*command = PopCommand( POP_BACK );
+			Prep( command );
+			
+			return;
+		}
+		else
+		{
+			assert( m_curSequence->GetReturn() );
+			if ( m_curSequence->GetReturn() == NULL )
+			{
+				*command = NULL;
+				return;
+			}
+
+			//Check to retain it
+			if ( m_curSequence->GetParent()->HasFlag( SQ_RETAIN ) )
+			{
+				PushCommand( block, PUSH_FRONT );
+			}
+			else
+			{
+				delete block;
+				block = NULL;
+				*command = NULL;
+			}
+			
+			//Back out of the loop and resume the previous sequence
+			m_curSequence = ReturnSequence( m_curSequence );
+			
+			//This can safely happen
+			if ( m_curSequence == NULL )
+			{
+				*command = NULL;
+				return;
+			}
+
+			*command = PopCommand( POP_BACK );
+			Prep( command );
+		}
+	}
+}
+
+/*
+========================
+CheckFlush
+
+Checks for flush command pre-processing
+========================
+*/
+
+void CSequencer::CheckFlush( CBlock **command )
+{
+	sequence_l::iterator	sli;
+	CBlock *block =			*command;
+
+	if ( block == NULL )
+		return;
+
+	if ( block->GetBlockID() == ID_FLUSH )
+	{
+		//Flush the sequence
+		Flush( m_curSequence );
+
+		//Check to retain it
+		if ( m_curSequence->HasFlag( SQ_RETAIN ) )
+		{
+			PushCommand( block, PUSH_FRONT );
+		}
+		else
+		{
+			delete block;
+			block = NULL;
+			*command = NULL;
+		}
+
+		*command = PopCommand( POP_BACK );
+		Prep( command );
+
+		return;
+	}
+}
+
+/*
+========================
+CheckAffect
+
+Checks for affect command pre-processing
+========================
+*/
+
+void CSequencer::CheckAffect( CBlock **command )
+{
+	CBlock *block = *command;
+	sharedEntity_t	*ent = NULL;
+	char		*entname = NULL;
+	int			memberNum = 0;
+
+	if ( block == NULL )
+	{
+		return;
+	}
+
+	if ( block->GetBlockID() == ID_AFFECT )
+	{
+		CSequencer *sequencer	= NULL;
+		entname = (char*) block->GetMemberData( memberNum++ );
+		ent		= m_ie->I_GetEntityByName( entname );
+		
+		if( !ent ) // if there wasn't a valid entname in the affect, we need to check if it's a get command
+		{
+			//try to parse a 'get' command that is embeded in this 'affect'
+		
+			int				id;
+			char			*p1 = NULL;
+			char			*name = 0;
+			CBlockMember	*bm = NULL;
+			//
+			//	Get the first parameter (this should be the get)
+			//
+			bm = block->GetMember( 0 );
+			id = bm->GetID();
+		
+			switch ( id )
+			{
+				// these 3 cases probably aren't necessary
+				case TK_STRING:
+				case TK_IDENTIFIER:
+				case TK_CHAR:
+					p1 = (char *) bm->GetData();
+				break;
+
+				case ID_GET:		
+				{
+					int		type;				
+
+					//get( TYPE, NAME )
+					type = (int) (*(float *) block->GetMemberData( memberNum++ ));
+					name = (char *) block->GetMemberData( memberNum++ );
+
+					switch ( type ) // what type are they attempting to get
+					{
+				
+						case TK_STRING:
+							//only string is acceptable for affect, store result in p1
+							if ( m_ie->I_GetString( m_ownerID, type, name, &p1 ) == false)
+							{
+								return;
+							}
+							break;
+						default:
+							//FIXME: Make an enum id for the error...
+							m_ie->I_DPrintf( WL_ERROR, "Invalid parameter type on affect _1" );
+							return;
+							break;
+					}
+
+					break;
+				}
+
+				default:
+				//FIXME: Make an enum id for the error...
+					m_ie->I_DPrintf( WL_ERROR, "Invalid parameter type on affect _2" );
+					return;
+					break;
+			}//end id switch
+
+			if(p1)
+			{
+				ent = m_ie->I_GetEntityByName( p1 );
+			}
+			if(!ent)
+			{	// a valid entity name was not returned from the get command
+				m_ie->I_DPrintf( WL_WARNING, "'%s' : invalid affect() target\n");
+			}
+		
+		} // end if(!ent)
+
+		if( ent )
+		{
+			sequencer = gSequencers[ent->s.number];//ent->sequencer;
+		}
+		if(memberNum == 0)
+		{	//there was no get, increment manually before next step
+			memberNum++;
+		}
+		int	type	= (int) (*(float *) block->GetMemberData( memberNum ));  
+		int	id		= (int) (*(float *) block->GetMemberData( memberNum+1 ));
+		
+		if ( m_curSequence->HasFlag( SQ_RETAIN ) )
+		{
+			PushCommand( block, PUSH_FRONT );
+		}
+		else
+		{
+			delete block;
+			block = NULL;
+			*command = NULL;
+		}
+		
+		//NOTENOTE: If this isn't found, continue on to the next command
+		if ( sequencer == NULL )
+		{
+			*command = PopCommand( POP_BACK );
+			Prep( command );
+			return;
+		}
+
+		sequencer->Affect( id, type );
+
+		*command = PopCommand( POP_BACK );
+		Prep( command );
+		if( ent )
+		{	// ents need to update upon being affected 
+			//ent->taskManager->Update();
+			gTaskManagers[ent->s.number]->Update();
+		}
+
+		return;
+	}
+
+	if ( ( block->GetBlockID() == ID_BLOCK_END ) && ( m_curSequence->HasFlag( SQ_AFFECT ) ) )
+	{
+		if ( m_curSequence->HasFlag( SQ_RETAIN ) )
+		{
+			PushCommand( block, PUSH_FRONT );
+		}
+		else
+		{
+			delete block;
+			block = NULL;
+			*command = NULL;
+		}
+		
+		m_curSequence = ReturnSequence( m_curSequence );
+
+		if ( m_curSequence == NULL )
+		{
+			*command = NULL;
+			return;
+		}
+
+		*command = PopCommand( POP_BACK );
+		Prep( command );
+		if( ent )
+		{	// ents need to update upon being affected 
+			//ent->taskManager->Update();
+			gTaskManagers[ent->s.number]->Update();
+		}
+
+	}
+}
+
+/*
+-------------------------
+CheckDo
+-------------------------
+*/
+
+void CSequencer::CheckDo( CBlock **command )
+{
+	CBlock *block = *command;
+
+	if ( block == NULL )
+		return;
+
+	if ( block->GetBlockID() == ID_DO )
+	{
+		//Get the sequence
+		const char	*groupName = (const char *) block->GetMemberData( 0 );
+		CTaskGroup	*group = m_taskManager->GetTaskGroup( groupName );
+		CSequence	*sequence = GetTaskSequence( group );
+
+		//TODO: Emit warning
+		assert( group );
+		if ( group == NULL )
+		{
+			//TODO: Give name/number of entity trying to execute, too
+			m_ie->I_DPrintf( WL_ERROR, "ICARUS Unable to find task group \"%s\"!\n", groupName );
+			*command = NULL;
+			return;
+		}
+
+		//TODO: Emit warning
+		assert( sequence );
+		if ( sequence == NULL )
+		{
+			//TODO: Give name/number of entity trying to execute, too
+			m_ie->I_DPrintf( WL_ERROR, "ICARUS Unable to find task 'group' sequence!\n", groupName );
+			*command = NULL;
+			return;
+		}
+
+		//Only save the loop command if the calling sequence is retained
+		if ( m_curSequence->HasFlag( SQ_RETAIN ) )
+		{
+			PushCommand( block, PUSH_FRONT );
+		}
+		else
+		{
+			delete block;
+			block = NULL;
+			*command = NULL;
+		}
+
+		//Set this to our current sequence
+		sequence->SetReturn( m_curSequence );
+		m_curSequence = sequence;
+
+		group->SetParent( m_curGroup );
+		m_curGroup = group;
+
+		//Mark all the following commands as being in the task
+		m_taskManager->MarkTask( group->GetGUID(), TASK_START );
+
+		//Recursively work out any other pre-processors
+		*command = PopCommand( POP_BACK );
+		Prep( command );
+		
+		return;
+	}
+
+	if ( ( block->GetBlockID() == ID_BLOCK_END ) && ( m_curSequence->HasFlag( SQ_TASK ) ) )
+	{
+		if ( m_curSequence->HasFlag( SQ_RETAIN ) )
+		{
+			PushCommand( block, PUSH_FRONT );
+		}
+		else
+		{
+			delete block;
+			block = NULL;
+			*command = NULL;
+		}
+		
+		m_taskManager->MarkTask( m_curGroup->GetGUID(), TASK_END );
+		m_curGroup = m_curGroup->GetParent();
+
+		CSequence *returnSeq = ReturnSequence( m_curSequence );
+		m_curSequence->SetReturn( NULL );
+		m_curSequence = returnSeq;
+
+		if ( m_curSequence == NULL )
+		{
+			*command = NULL;
+			return;
+		}
+
+		*command = PopCommand( POP_BACK );
+		Prep( command );
+	}
+}
+
+/*
+========================
+Prep
+
+Handles internal sequencer maintenance
+========================
+*/
+
+void CSequencer::Prep( CBlock **command )
+{
+	//Check all pre-processes
+	CheckAffect( command );
+	CheckFlush( command );
+	CheckLoop( command );
+	CheckRun( command );
+	CheckIf( command );
+	CheckDo( command );
+}
+
+/*
+========================
+Prime
+
+Starts communication between the task manager and this sequencer
+========================
+*/
+
+int CSequencer::Prime( CTaskManager *taskManager, CBlock *command )
+{
+	Prep( &command );
+
+	if ( command )
+	{
+		taskManager->SetCommand( command, PUSH_BACK );
+	}
+
+	return SEQ_OK;
+}
+
+/*
+========================
+Callback
+
+Handles a completed task and returns a new task to be completed
+========================
+*/
+
+int CSequencer::Callback( CTaskManager *taskManager, CBlock *block, int returnCode )
+{
+	CBlock	*command;
+
+	if (returnCode == TASK_RETURN_COMPLETE)
+	{
+		//There are no more pending commands
+		if ( m_curSequence == NULL )
+		{
+			delete block;
+			block = NULL;
+			return SEQ_OK;
+		}
+
+		//Check to retain the command
+		if ( m_curSequence->HasFlag( SQ_RETAIN ) )	//This isn't true for affect sequences...?
+		{
+			PushCommand( block, PUSH_FRONT );
+		}
+		else
+		{
+			delete block;
+			block = NULL;
+		}
+
+		//Check for pending commands
+		if ( m_curSequence->GetNumCommands() <= 0 )
+		{
+			if ( m_curSequence->GetReturn() == NULL)
+				return SEQ_OK;
+
+			m_curSequence = m_curSequence->GetReturn();
+		}
+
+		command = PopCommand( POP_BACK );
+		Prep( &command );
+
+		if ( command )
+			taskManager->SetCommand( command, PUSH_FRONT );
+
+		return SEQ_OK;
+	}
+
+	//FIXME: This could be more descriptive
+	m_ie->I_DPrintf( WL_ERROR,  "command could not be called back\n" );
+	assert(0);
+
+	return SEQ_FAILED;
+}
+
+/*
+-------------------------
+Recall
+-------------------------
+*/
+
+int CSequencer::Recall( void )
+{
+	CBlock	*block	= NULL;
+
+	if (!m_taskManager)
+	{ //uh.. ok.
+		assert(0);
+		return true;
+	}
+
+	while ( ( block = m_taskManager->RecallTask() ) != NULL )
+	{
+		if (m_curSequence)
+		{
+			PushCommand( block, PUSH_BACK );
+		}
+		else
+		{
+			delete block;
+			block = NULL;
+		}
+	}
+
+	return true;
+}
+
+/*
+-------------------------
+Affect
+-------------------------
+*/
+
+int CSequencer::Affect( int id, int type )
+{
+	CSequence	*sequence = GetSequence( id );
+
+	if ( sequence == NULL )
+	{
+		return SEQ_FAILED;
+	}
+
+	switch ( type )
+	{
+
+	case TYPE_FLUSH:
+
+		//Get rid of all old code
+		Flush( sequence );
+
+		sequence->RemoveFlag( SQ_PENDING, true );	
+		
+		m_curSequence = sequence;
+
+		Prime( m_taskManager, PopCommand( POP_BACK ) );
+
+		break;
+		
+	case TYPE_INSERT:
+
+		Recall();
+		
+		sequence->SetReturn( m_curSequence );
+		
+		sequence->RemoveFlag( SQ_PENDING, true );
+		
+		m_curSequence = sequence;
+
+		Prime( m_taskManager, PopCommand( POP_BACK ) );
+
+		break;
+
+
+	default:
+		m_ie->I_DPrintf( WL_ERROR, "unknown affect type found" );
+		break;
+	}
+
+	return SEQ_OK;
+}
+
+/*
+========================
+PushCommand
+
+Pushes a commands onto the current sequence
+========================
+*/
+
+int CSequencer::PushCommand( CBlock *command, int flag )
+{
+	//Make sure everything is ok
+	assert( m_curSequence );
+	if ( m_curSequence == NULL )
+		return SEQ_FAILED;
+
+	m_curSequence->PushCommand( command, flag );
+	m_numCommands++;
+	
+	//Invalid flag
+	return SEQ_OK;
+}
+
+/*
+========================
+PopCommand
+
+Pops a command off the current sequence
+========================
+*/
+
+CBlock *CSequencer::PopCommand( int flag )
+{
+	//Make sure everything is ok
+	assert( m_curSequence );
+	if ( m_curSequence == NULL )
+		return NULL;
+
+	CBlock *block = m_curSequence->PopCommand( flag );	
+
+	if ( block != NULL )
+		m_numCommands--;
+
+	return block;
+}
+
+/*
+========================
+StripExtension
+
+Filename ultility.  Probably get rid of this if I decided to use CStrings...
+========================
+*/
+
+void CSequencer::StripExtension( const char *in, char *out )
+{
+	int		i = strlen(in) + 1;
+	
+	while ( (in[i] != '.') && (i >= 0) )
+	 i--;
+
+	if ( i < 0 )
+	{
+		strcpy(out, in);
+		return;
+	}
+
+	strncpy(out, in, i);
+}
+
+
+/*
+-------------------------
+RemoveSequence
+-------------------------
+*/
+
+//NOTENOTE: This only removes references to the sequence, IT DOES NOT FREE THE ALLOCATED MEMORY!  You've be warned! =)
+
+int CSequencer::RemoveSequence( CSequence *sequence )
+{
+	CSequence *temp;
+
+	int numChildren = sequence->GetNumChildren();
+
+	//Add all the children
+	for ( int i = 0; i < numChildren; i++ )
+	{
+		temp = sequence->GetChildByIndex( i );
+
+		//TODO: Emit warning
+		assert( temp );
+		if ( temp == NULL )
+		{
+			m_ie->I_DPrintf( WL_WARNING, "Unable to find child sequence on RemoveSequence call!\n" );
+			continue;
+		}
+
+		//Remove the references to this sequence
+		temp->SetParent( NULL );
+		temp->SetReturn( NULL );
+
+	}
+		
+	return SEQ_OK;
+}
+
+int CSequencer::DestroySequence( CSequence *sequence )
+{
+	if ( !sequence )
+		return SEQ_FAILED;
+
+	//m_sequenceMap.erase( sequence->GetID() );
+	m_sequences.remove( sequence );
+
+	taskSequence_m::iterator	tsi;
+	for ( tsi = m_taskSequences.begin(); tsi != m_taskSequences.end(); )
+	{
+		if((*tsi).second == sequence)
+		{
+			tsi = m_taskSequences.erase(tsi);
+		}
+		else
+		{
+			++tsi;
+		}
+	}
+
+	CSequence* parent = sequence->GetParent();
+	if ( parent )
+	{
+		parent->RemoveChild( sequence );
+		parent = NULL;
+	}
+
+	int curChild = sequence->GetNumChildren();
+	while( curChild )
+	{
+		// Stop if we're about to go negative (invalid index!).
+		if ( curChild > 0 )
+		{
+			DestroySequence( sequence->GetChildByIndex( --curChild ) );
+		}
+		else
+			break;
+	}
+
+	m_owner->DeleteSequence( sequence );
+		
+	return SEQ_OK;
+}
+
+/*
+-------------------------
+ReturnSequence
+-------------------------
+*/
+
+inline CSequence *CSequencer::ReturnSequence( CSequence *sequence )
+{
+	while ( sequence->GetReturn() )
+	{
+		assert(sequence != sequence->GetReturn() );
+		if ( sequence == sequence->GetReturn() )
+			return NULL;
+
+		sequence = sequence->GetReturn();
+
+		if ( sequence->GetNumCommands() > 0 )
+			return sequence;
+	}
+	return NULL;
+}
+
+//Save / Load
+
+/*
+-------------------------
+Save
+-------------------------
+*/
+
+int	CSequencer::Save( void )
+{
+#if 0 //asfsfasadf
+	sequence_l::iterator		si;
+	taskSequence_m::iterator	ti;
+	int							numSequences = 0, id, numTasks;
+
+	//Get the number of sequences to save out
+	numSequences = m_sequences.size();
+
+	//Save out the owner sequence
+	m_ie->I_WriteSaveData( 'SQRE', &m_ownerID, sizeof( m_ownerID ) );
+
+	//Write out the number of sequences we need to read
+	m_ie->I_WriteSaveData( 'SQR#', &numSequences, sizeof( numSequences ) );
+
+	//Second pass, save out all sequences, in order
+	STL_ITERATE( si, m_sequences )
+	{
+		id = (*si)->GetID();
+		m_ie->I_WriteSaveData( 'SQRI', &id, sizeof( id ) );
+	}
+
+	//Save out the taskManager
+	m_taskManager->Save();
+
+	//Save out the task sequences mapping the name to the GUIDs
+	numTasks = m_taskSequences.size();
+	m_ie->I_WriteSaveData( 'SQT#', &numTasks, sizeof ( numTasks ) );
+
+	STL_ITERATE( ti, m_taskSequences )
+	{	
+		//Save the task group's ID
+		id = ((*ti).first)->GetGUID();
+		m_ie->I_WriteSaveData( 'STID', &id, sizeof( id ) );
+
+		//Save the sequence's ID
+		id = ((*ti).second)->GetID();
+		m_ie->I_WriteSaveData( 'SSID', &id, sizeof( id ) );
+	}
+
+	int	curGroupID = ( m_curGroup == NULL ) ? -1 : m_curGroup->GetGUID();
+
+	m_ie->I_WriteSaveData( 'SQCT', &curGroupID, sizeof ( m_numCommands ) );
+
+	//Output the number of commands
+	m_ie->I_WriteSaveData( 'SQ#C', &m_numCommands, sizeof ( m_numCommands ) );	//FIXME: This can be reconstructed
+
+	//Output the ID of the current sequence
+	id = ( m_curSequence != NULL ) ? m_curSequence->GetID() : -1;
+	m_ie->I_WriteSaveData( 'SQCS', &id, sizeof ( id ) );
+
+	return true;
+#endif
+	return false;
+}
+
+/*
+-------------------------
+Load
+-------------------------
+*/
+
+int	CSequencer::Load( void )
+{	
+#if 0 //asfsfasadf
+	//Get the owner of this sequencer
+	m_ie->I_ReadSaveData( 'SQRE', &m_ownerID, sizeof( m_ownerID ) );
+
+	//Link the entity back to the sequencer
+	m_ie->I_LinkEntity( m_ownerID, this, m_taskManager );
+
+	CTaskGroup	*taskGroup;
+	CSequence	*seq;
+	int			numSequences, seqID, taskID, numTasks;
+
+	//Get the number of sequences to read
+	m_ie->I_ReadSaveData( 'SQR#', &numSequences, sizeof( numSequences ) );
+
+	//Read in all the sequences
+	for ( int i = 0; i < numSequences; i++ )
+	{
+		m_ie->I_ReadSaveData( 'SQRI', &seqID, sizeof( seqID ) );
+
+		seq = m_owner->GetSequence( seqID );
+
+		assert( seq );
+
+		STL_INSERT( m_sequences, seq );
+		m_sequenceMap[ seqID ] = seq;
+	}
+
+	//Setup the task manager
+	m_taskManager->Init( this );
+
+	//Load the task manager
+	m_taskManager->Load();
+
+	//Get the number of tasks in the map
+	m_ie->I_ReadSaveData( 'SQT#', &numTasks, sizeof( numTasks ) );
+
+	//Read in, and reassociate the tasks to the sequences
+	for ( i = 0; i < numTasks; i++ )
+	{
+		//Read in the task's ID
+		m_ie->I_ReadSaveData( 'STID', &taskID, sizeof( taskID ) );
+		
+		//Read in the sequence's ID
+		m_ie->I_ReadSaveData( 'SSID', &seqID, sizeof( seqID ) );
+
+		taskGroup = m_taskManager->GetTaskGroup( taskID );
+
+		assert( taskGroup );
+
+		seq = m_owner->GetSequence( seqID );
+
+		assert( seq );
+
+		//Associate the values
+		m_taskSequences[ taskGroup ] = seq;
+	}
+
+	int	curGroupID;
+
+	//Get the current task group
+	m_ie->I_ReadSaveData( 'SQCT', &curGroupID, sizeof( curGroupID ) );
+
+	m_curGroup = ( curGroupID == -1 ) ? NULL : m_taskManager->GetTaskGroup( curGroupID );
+
+	//Get the number of commands
+	m_ie->I_ReadSaveData( 'SQ#C', &m_numCommands, sizeof( m_numCommands ) );
+
+	//Get the current sequence
+	m_ie->I_ReadSaveData( 'SQCS', &seqID, sizeof( seqID ) );
+
+	m_curSequence = ( seqID != -1 ) ? m_owner->GetSequence( seqID ) : NULL;
+
+	return true;
+#endif
+	return false;
+}
diff --git a/codemp/icarus/TaskManager.cpp b/codemp/icarus/TaskManager.cpp
new file mode 100644
index 0000000..9361135
--- /dev/null
+++ b/codemp/icarus/TaskManager.cpp
@@ -0,0 +1,1994 @@
+// Task Manager 
+//
+//	-- jweier
+
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+// this include must remain at the top of every Icarus CPP file
+#include "icarus.h"
+
+
+
+#include <assert.h>
+
+#define ICARUS_VALIDATE(a) if ( a == false ) return TASK_FAILED;
+
+#include "../server/server.h"
+
+/*
+=================================================
+
+CTask
+
+=================================================
+*/
+
+CTask::CTask( void )
+{
+}
+
+CTask::~CTask( void )
+{
+}
+
+CTask *CTask::Create( int GUID, CBlock *block )
+{
+	CTask *task = new CTask;
+
+	//TODO: Emit warning
+	assert( task );
+	if ( task == NULL )
+		return NULL;
+
+	task->SetTimeStamp( 0 );
+	task->SetBlock( block );
+	task->SetGUID( GUID );
+
+	return task;
+}
+
+/*
+-------------------------
+Free
+-------------------------
+*/
+
+void CTask::Free( void )
+{
+	//NOTENOTE: The block is not consumed by the task, it is the sequencer's job to clean blocks up	
+	delete this;
+}
+
+/*
+=================================================
+
+CTaskGroup
+
+=================================================
+*/
+
+CTaskGroup::CTaskGroup( void )
+{
+	Init();
+
+	m_GUID		= 0;
+	m_parent	= NULL;
+}
+
+CTaskGroup::~CTaskGroup( void )
+{
+	m_completedTasks.clear();
+}
+
+/*
+-------------------------
+SetGUID
+-------------------------
+*/
+
+void CTaskGroup::SetGUID( int GUID )
+{
+	m_GUID = GUID;
+}
+
+/*
+-------------------------
+Init
+-------------------------
+*/
+
+void CTaskGroup::Init( void )
+{
+	m_completedTasks.clear();
+
+	m_numCompleted	= 0;
+	m_parent		= NULL;
+}
+
+/*
+-------------------------
+Add
+-------------------------
+*/
+
+int CTaskGroup::Add( CTask *task )
+{
+	m_completedTasks[ task->GetGUID() ] = false;
+	return TASK_OK;	
+}
+
+/*
+-------------------------
+MarkTaskComplete
+-------------------------
+*/
+
+bool CTaskGroup::MarkTaskComplete( int id )
+{
+	if ( (m_completedTasks.find( id )) != m_completedTasks.end() )
+	{
+		m_completedTasks[ id ] = true;
+		m_numCompleted++;
+
+		return true;
+	}
+
+	return false;
+}
+
+/*
+=================================================
+
+CTaskManager
+
+=================================================
+*/
+
+CTaskManager::CTaskManager( void )
+{
+}
+
+CTaskManager::~CTaskManager( void )
+{
+}
+
+/*
+-------------------------
+Create
+-------------------------
+*/
+
+CTaskManager *CTaskManager::Create( void )
+{
+	return new CTaskManager;
+}
+
+/*
+-------------------------
+Init
+-------------------------
+*/
+
+int	CTaskManager::Init( CSequencer *owner )
+{
+	//TODO: Emit warning
+	if ( owner == NULL )
+		return TASK_FAILED;
+
+	m_tasks.clear();
+	m_owner		= owner;
+	m_ownerID	= owner->GetOwnerID();
+	m_curGroup	= NULL;
+	m_GUID		= 0;
+	m_resident	= false;
+
+	return TASK_OK;
+}
+
+/*
+-------------------------
+Free
+-------------------------
+*/
+
+int CTaskManager::Free( void )
+{
+	taskGroup_v::iterator	gi;
+	tasks_l::iterator		ti;
+
+	//Clear out all pending tasks
+	for ( ti = m_tasks.begin(); ti != m_tasks.end(); ti++ )
+	{
+		(*ti)->Free();
+	}
+
+	m_tasks.clear();
+
+	//Clear out all taskGroups
+	for ( gi = m_taskGroups.begin(); gi != m_taskGroups.end(); gi++ )
+	{
+		delete (*gi);
+	}
+	
+	m_taskGroups.clear();
+	m_taskGroupNameMap.clear();
+	m_taskGroupIDMap.clear();
+
+	return TASK_OK;
+}
+
+/*
+-------------------------
+Flush
+-------------------------
+*/
+
+int CTaskManager::Flush( void )
+{	
+	//FIXME: Rewrite
+	
+	return true;
+}
+
+/*
+-------------------------
+AddTaskGroup
+-------------------------
+*/
+
+CTaskGroup *CTaskManager::AddTaskGroup( const char *name )
+{
+	CTaskGroup *group;
+
+	//Collect any garbage
+	taskGroupName_m::iterator	tgni;
+	tgni = m_taskGroupNameMap.find( name );
+
+	if ( tgni != m_taskGroupNameMap.end() )
+	{
+		group = (*tgni).second;
+		
+		//Clear it and just move on
+		group->Init();
+		
+		return group;
+	}
+
+	//Allocate a new one
+	group = new CTaskGroup;;
+
+	//TODO: Emit warning
+	assert( group );
+	if ( group == NULL )
+	{
+		(m_owner->GetInterface())->I_DPrintf( WL_ERROR, "Unable to allocate task group \"%s\"\n", name );
+		return NULL;
+	}
+
+	//Setup the internal information
+	group->SetGUID( m_GUID++ );
+
+	//Add it to the list and associate it for retrieval later
+	m_taskGroups.insert( m_taskGroups.end(), group );
+	m_taskGroupNameMap[ name ] = group;
+	m_taskGroupIDMap[ group->GetGUID() ] = group;
+
+	return group;
+}
+
+/*
+-------------------------
+GetTaskGroup
+-------------------------
+*/
+
+CTaskGroup *CTaskManager::GetTaskGroup( const char *name )
+{
+	taskGroupName_m::iterator	tgi;
+
+	tgi = m_taskGroupNameMap.find( name );
+
+	if ( tgi == m_taskGroupNameMap.end() )
+	{
+		(m_owner->GetInterface())->I_DPrintf( WL_WARNING, "Could not find task group \"%s\"\n", name );
+		return NULL;
+	}
+
+	return (*tgi).second;
+}
+
+CTaskGroup *CTaskManager::GetTaskGroup( int id )
+{
+	taskGroupID_m::iterator	tgi;
+
+	tgi = m_taskGroupIDMap.find( id );
+
+	if ( tgi == m_taskGroupIDMap.end() )
+	{
+		(m_owner->GetInterface())->I_DPrintf( WL_WARNING, "Could not find task group \"%d\"\n", id );
+		return NULL;
+	}
+
+	return (*tgi).second;
+}
+
+/*
+-------------------------
+Update
+-------------------------
+*/
+
+int CTaskManager::Update( void )
+{
+	sharedEntity_t *owner = SV_GentityNum(m_ownerID);
+
+	if ( (owner->r.svFlags&SVF_ICARUS_FREEZE) )
+	{
+		return TASK_FAILED;
+	}
+	m_count = 0;	//Needed for runaway init
+	m_resident = true;
+
+	int returnVal = Go();
+
+	m_resident = false;
+
+	return returnVal;
+}
+
+/*
+-------------------------
+IsRunning
+-------------------------
+*/
+
+qboolean CTaskManager::IsRunning( void )
+{
+	return (qboolean)( m_tasks.empty() == false );
+}
+/*
+-------------------------
+Check
+-------------------------
+*/
+
+inline bool CTaskManager::Check( int targetID, CBlock *block, int memberNum )
+{
+	if ( (block->GetMember( memberNum ))->GetID() == targetID )
+		return true;
+
+	return false;
+}
+
+/*
+-------------------------
+GetFloat
+-------------------------
+*/
+
+int CTaskManager::GetFloat( int entID, CBlock *block, int &memberNum, float &value )
+{
+	char	*name;
+	int		type;
+
+	//See if this is a get() command replacement
+	if ( Check( ID_GET, block, memberNum ) )
+	{
+		//Update the member past the header id
+		memberNum++;
+
+		//get( TYPE, NAME )
+		type = (int) (*(float *) block->GetMemberData( memberNum++ ));
+		name = (char *) block->GetMemberData( memberNum++ );
+
+		//TODO: Emit warning
+		if ( type != TK_FLOAT )
+		{
+			(m_owner->GetInterface())->I_DPrintf( WL_ERROR, "Get() call tried to return a non-FLOAT parameter!\n" );
+			return false; 
+		}
+
+		return (m_owner->GetInterface())->I_GetFloat( entID, type, name, &value );
+	}
+
+	//Look for a random() inline call
+	if ( Check( ID_RANDOM, block, memberNum ) )
+	{
+		float	min, max;
+
+		memberNum++;
+
+		min	= *(float *) block->GetMemberData( memberNum++ );
+		max	= *(float *) block->GetMemberData( memberNum++ );
+
+		value = (m_owner->GetInterface())->I_Random( min, max );
+
+		return true;
+	}
+
+	//Look for a tag() inline call
+	if ( Check( ID_TAG, block, memberNum ) )
+	{
+		(m_owner->GetInterface())->I_DPrintf( WL_WARNING, "Invalid use of \"tag\" inline.  Not a valid replacement for type FLOAT\n" );
+		return false;
+	}
+
+	CBlockMember	*bm	= block->GetMember( memberNum );
+	
+	if ( bm->GetID() == TK_INT )
+	{
+		value = (float) (*(int *) block->GetMemberData( memberNum++ ));
+	}
+	else if ( bm->GetID() == TK_FLOAT )
+	{
+		value = *(float *) block->GetMemberData( memberNum++ );
+	}
+	else
+	{
+		assert(0);
+		(m_owner->GetInterface())->I_DPrintf( WL_WARNING, "Unexpected value; expected type FLOAT\n" );
+		return false;
+	}
+
+	return true;
+}
+
+/*
+-------------------------
+GetVector
+-------------------------
+*/
+
+int CTaskManager::GetVector( int entID, CBlock *block, int &memberNum, vector_t &value )
+{
+	char	*name;
+	int		type, i;
+
+	//See if this is a get() command replacement
+	if ( Check( ID_GET, block, memberNum ) )
+	{
+		//Update the member past the header id
+		memberNum++;
+
+		//get( TYPE, NAME )
+		type = (int) (*(float *) block->GetMemberData( memberNum++ ));
+		name = (char *) block->GetMemberData( memberNum++ );
+
+		//TODO: Emit warning
+		if ( type != TK_VECTOR )
+		{
+			(m_owner->GetInterface())->I_DPrintf( WL_ERROR, "Get() call tried to return a non-VECTOR parameter!\n" );
+		}
+
+		return (m_owner->GetInterface())->I_GetVector( entID, type, name, value );
+	}
+
+	//Look for a random() inline call
+	if ( Check( ID_RANDOM, block, memberNum ) )
+	{
+		float	min, max;
+
+		memberNum++;
+
+		min	= *(float *) block->GetMemberData( memberNum++ );
+		max	= *(float *) block->GetMemberData( memberNum++ );
+
+		for ( i = 0; i < 3; i++ )
+		{
+			value[i] = (float) (m_owner->GetInterface())->I_Random( min, max );	//FIXME: Just truncating it for now.. should be fine though
+		}
+
+		return true;
+	}
+
+	//Look for a tag() inline call
+	if ( Check( ID_TAG, block, memberNum ) )
+	{
+		char	*tagName;
+		float	tagLookup;
+
+		memberNum++;
+		ICARUS_VALIDATE ( Get( entID, block, memberNum, &tagName ) );
+		ICARUS_VALIDATE ( GetFloat( entID, block, memberNum, tagLookup ) );
+
+		if ( (m_owner->GetInterface())->I_GetTag( entID, tagName, (int) tagLookup, value ) == false)
+		{
+			(m_owner->GetInterface())->I_DPrintf( WL_ERROR, "Unable to find tag \"%s\" for ent %i!\n", tagName, entID );
+//			assert(0);
+			return TASK_FAILED;
+		}		
+
+		return true;
+	}
+
+	//Check for a real vector here
+	type = (int) (*(float *) block->GetMemberData( memberNum ));
+
+	if ( type != TK_VECTOR )
+	{
+//		(m_owner->GetInterface())->I_DPrintf( WL_WARNING, "Unexpected value; expected type VECTOR\n" );
+		return false;
+	}
+
+	memberNum++;
+
+	for ( i = 0; i < 3; i++ )
+	{
+		if ( GetFloat( entID, block, memberNum, value[i] ) == false )
+			return false;
+	}
+
+	return true;
+}
+
+/*
+-------------------------
+Get
+-------------------------
+*/
+
+int CTaskManager::Get( int entID, CBlock *block, int &memberNum, char **value )
+{
+	static	char	tempBuffer[128];	//FIXME: EEEK!
+	vector_t		vector;
+	char			*name, *tagName;
+	float			tagLookup;
+	int				type;
+
+	//Look for a get() inline call
+	if ( Check( ID_GET, block, memberNum ) )
+	{
+		//Update the member past the header id
+		memberNum++;
+
+		//get( TYPE, NAME )
+		type = (int) (*(float *) block->GetMemberData( memberNum++ ));
+		name = (char *) block->GetMemberData( memberNum++ );
+
+		//Format the return properly
+		//FIXME: This is probably doing double formatting in certain cases...
+		//FIXME: STRING MANAGEMENT NEEDS TO BE IMPLEMENTED, MY CURRENT SOLUTION IS NOT ACCEPTABLE!!
+		switch ( type )
+		{
+		case TK_STRING:
+			if ( ( m_owner->GetInterface())->I_GetString( entID, type, name, value ) == false )
+			{
+				(m_owner->GetInterface())->I_DPrintf( WL_ERROR, "Get() parameter \"%s\" could not be found!\n", name );
+				return false;
+			}
+			
+			return true;
+			break;
+
+		case TK_FLOAT:
+			{
+				float	temp;
+
+				if ( (m_owner->GetInterface())->I_GetFloat( entID, type, name, &temp ) == false )
+				{
+					(m_owner->GetInterface())->I_DPrintf( WL_ERROR, "Get() parameter \"%s\" could not be found!\n", name );	
+					return false;
+				}
+
+				sprintf( (char *) tempBuffer, "%f", temp );
+				*value = (char *) tempBuffer;
+			}
+			
+			return true;
+			break;
+
+		case TK_VECTOR:
+			{
+				vector_t	vval;
+
+				if ( (m_owner->GetInterface())->I_GetVector( entID, type, name, vval )  == false )
+				{
+					(m_owner->GetInterface())->I_DPrintf( WL_ERROR, "Get() parameter \"%s\" could not be found!\n", name );	
+					return false;
+				}
+
+				sprintf( (char *) tempBuffer, "%f %f %f", vval[0], vval[1], vval[2] );
+				*value = (char *) tempBuffer;
+			}
+			
+			return true;
+			break;
+
+		default:
+			(m_owner->GetInterface())->I_DPrintf( WL_ERROR, "Get() call tried to return an unknown type!\n" );
+			return false;
+			break;
+		}
+	}
+
+	//Look for a random() inline call
+	if ( Check( ID_RANDOM, block, memberNum ) )
+	{
+		float	min, max, ret;
+
+		memberNum++;
+
+		min	= *(float *) block->GetMemberData( memberNum++ );
+		max	= *(float *) block->GetMemberData( memberNum++ );
+
+		ret = ( m_owner->GetInterface())->I_Random( min, max );
+
+		sprintf( (char *) tempBuffer, "%f", ret );
+		*value = (char *) tempBuffer;
+
+		return true;
+	}
+
+	//Look for a tag() inline call
+	if ( Check( ID_TAG, block, memberNum ) )
+	{
+		memberNum++;
+		ICARUS_VALIDATE ( Get( entID, block, memberNum, &tagName ) );
+		ICARUS_VALIDATE ( GetFloat( entID, block, memberNum, tagLookup ) );
+
+		if ( ( m_owner->GetInterface())->I_GetTag( entID, tagName, (int) tagLookup, vector ) == false)
+		{
+			(m_owner->GetInterface())->I_DPrintf( WL_ERROR, "Unable to find tag \"%s\"!\n", tagName );
+			assert(0 && "Unable to find tag");
+			return false;
+		}
+
+		sprintf( (char *) tempBuffer, "%f %f %f", vector[0], vector[1], vector[2] );
+		*value = (char *) tempBuffer;
+
+		return true;
+	}
+
+	//Get an actual piece of data
+
+	CBlockMember	*bm	= block->GetMember( memberNum );
+
+	if ( bm->GetID() == TK_INT )
+	{
+		float fval = (float) (*(int *) block->GetMemberData( memberNum++ ));
+		sprintf( (char *) tempBuffer, "%f", fval );
+		*value = (char *) tempBuffer;
+
+		return true;
+	}
+	else if ( bm->GetID() == TK_FLOAT )
+	{
+		float fval = *(float *) block->GetMemberData( memberNum++ );
+		sprintf( (char *) tempBuffer, "%f", fval );
+		*value = (char *) tempBuffer;
+
+		return true;
+	}
+	else if ( bm->GetID() == TK_VECTOR )
+	{
+		vector_t	vval;
+
+		memberNum++;
+
+		for ( int i = 0; i < 3; i++ )
+		{
+			if ( GetFloat( entID, block, memberNum, vval[i] ) == false )
+				return false;
+
+			sprintf( (char *) tempBuffer, "%f %f %f", vval[0], vval[1], vval[2] );
+			*value = (char *) tempBuffer;
+		}
+		
+		return true;
+	}
+	else if ( ( bm->GetID() == TK_STRING ) || ( bm->GetID() == TK_IDENTIFIER ) )
+	{
+		*value = (char *) block->GetMemberData( memberNum++ );
+
+		return true;
+	}
+	
+	//TODO: Emit warning
+	assert( 0 );
+	(m_owner->GetInterface())->I_DPrintf( WL_WARNING, "Unexpected value; expected type STRING\n" );
+
+	return false;
+}
+
+/*
+-------------------------
+Go
+-------------------------
+*/
+
+int	CTaskManager::Go( void )
+{
+	CTask	*task = NULL;
+	bool	completed = false;
+
+	//Check for run away scripts
+	if ( m_count++ > RUNAWAY_LIMIT )
+	{
+		assert(0);
+		(m_owner->GetInterface())->I_DPrintf( WL_ERROR, "Runaway loop detected!\n" );
+		return TASK_FAILED;
+	}
+
+	//If there are tasks to complete, do so
+	if ( m_tasks.empty() == false )
+	{
+		//Get the next task
+		task = PopTask( POP_BACK );
+
+		assert( task );
+		if ( task == NULL )
+		{
+			(m_owner->GetInterface())->I_DPrintf( WL_ERROR, "Invalid task found in Go()!\n" );
+			return TASK_FAILED;
+		}
+	
+		//If this hasn't been stamped, do so
+		if ( task->GetTimeStamp() == 0 )
+			task->SetTimeStamp( ( m_owner->GetInterface())->I_GetTime() );
+			
+		//Switch and call the proper function
+		switch( task->GetID() )
+		{
+		case ID_WAIT:
+			
+			Wait( task, completed );
+
+			//Push it to consider it again on the next frame if not complete
+			if ( completed == false )
+			{
+				PushTask( task, PUSH_BACK );
+				return TASK_OK;
+			}
+
+			Completed( task->GetGUID() );
+
+			break;
+
+		case ID_WAITSIGNAL:
+			
+			WaitSignal( task, completed );
+
+			//Push it to consider it again on the next frame if not complete
+			if ( completed == false )
+			{
+				PushTask( task, PUSH_BACK );
+				return TASK_OK;
+			}
+
+			Completed( task->GetGUID() );
+
+			break;
+		
+		case ID_PRINT:	//print( STRING )
+			Print( task );
+			break;
+
+		case ID_SOUND:	//sound( name )
+			Sound( task );
+			break;
+
+		case ID_MOVE:	//move ( ORIGIN, ANGLES, DURATION )
+			Move( task );
+			break;
+
+		case ID_ROTATE:	//rotate( ANGLES, DURATION )
+			Rotate( task );
+			break;
+
+		case ID_KILL:	//kill( NAME )
+			Kill( task );
+			break;
+
+		case ID_REMOVE:	//remove( NAME )
+			Remove( task );
+			break;
+
+		case ID_CAMERA:	//camera( ? )
+			Camera( task );
+			break;
+
+		case ID_SET:	//set( NAME, ? )
+			Set( task );
+			break;
+
+		case ID_USE:	//use( NAME )
+			Use( task );
+			break;
+
+		case ID_DECLARE://declare( TYPE, NAME )
+			DeclareVariable( task );
+			break;
+
+		case ID_FREE:	//free( NAME )
+			FreeVariable( task );
+			break;
+
+		case ID_SIGNAL:	//signal( NAME )
+			Signal( task );
+			break;
+
+		case ID_PLAY:	//play ( NAME )
+			Play( task );
+			break;
+
+		default:
+			assert(0);
+			task->Free();
+			(m_owner->GetInterface())->I_DPrintf( WL_ERROR, "Found unknown task type!\n" );
+			return TASK_FAILED;
+			break;
+		}
+
+		//Pump the sequencer for another task
+		CallbackCommand( task, TASK_RETURN_COMPLETE );
+
+		task->Free();
+	}
+	
+	//FIXME: A command surge limiter could be implemented at this point to be sure a script doesn't
+	//		 execute too many commands in one cycle.  This may, however, cause timing errors to surface.
+	
+	return TASK_OK;
+}
+
+/*
+-------------------------
+SetCommand
+-------------------------
+*/
+
+int	CTaskManager::SetCommand( CBlock *command, int type )
+{
+	CTask	*task = CTask::Create( m_GUID++, command );
+
+	//If this is part of a task group, add it in
+	if ( m_curGroup )
+	{
+		m_curGroup->Add( task );
+	}
+
+	//TODO: Emit warning
+	assert( task );
+	if ( task == NULL )
+	{
+		(m_owner->GetInterface())->I_DPrintf( WL_ERROR, "Unable to allocate new task!\n" );
+		return TASK_FAILED;
+	}
+
+	PushTask( task, type );
+
+	return TASK_OK;
+}
+
+/*
+-------------------------
+MarkTask
+-------------------------
+*/
+
+int CTaskManager::MarkTask( int id, int operation )
+{
+	CTaskGroup *group	= GetTaskGroup( id );
+
+	assert( group );
+
+	if ( group == NULL )
+		return TASK_FAILED;
+
+	if ( operation == TASK_START )
+	{
+		//Reset all the completion information
+		group->Init();
+
+		group->SetParent( m_curGroup );
+		m_curGroup = group;
+	}
+	else if ( operation == TASK_END )
+	{
+		assert( m_curGroup );
+		if ( m_curGroup == NULL )
+			return TASK_FAILED;
+
+		m_curGroup = m_curGroup->GetParent();
+	}
+
+#ifdef _DEBUG
+	else
+	{
+		assert(0);
+	}
+#endif
+
+	return TASK_OK;
+}
+
+/*
+-------------------------
+Completed
+-------------------------
+*/
+
+int CTaskManager::Completed( int id )
+{
+	taskGroup_v::iterator	tgi;
+
+	//Mark the task as completed
+	for ( tgi = m_taskGroups.begin(); tgi != m_taskGroups.end(); tgi++ )
+	{
+		//If this returns true, then the task was marked properly
+		if ( (*tgi)->MarkTaskComplete( id ) )
+			break;
+	}
+
+	return TASK_OK;
+}
+
+/*
+-------------------------
+CallbackCommand
+-------------------------
+*/
+
+int	CTaskManager::CallbackCommand( CTask *task, int returnCode )
+{
+	if ( m_owner->Callback( this, task->GetBlock(), returnCode ) == SEQ_OK )
+		return Go( );
+
+	assert(0);
+
+	(m_owner->GetInterface())->I_DPrintf( WL_ERROR, "Command callback failure!\n" );
+	return TASK_FAILED;
+}
+
+/*
+-------------------------
+RecallTask
+-------------------------
+*/
+
+CBlock *CTaskManager::RecallTask( void )
+{
+	CTask	*task;
+
+	task = PopTask( POP_BACK );
+
+	if ( task )
+	{
+	// fixed 2/12/2 to free the task that has been popped (called from sequencer Recall)
+		CBlock* retBlock = task->GetBlock();
+		task->Free();
+
+		return retBlock;
+	//	return task->GetBlock();
+	}
+
+	return NULL;
+}
+
+/*
+-------------------------
+PushTask
+-------------------------
+*/
+
+int	CTaskManager::PushTask( CTask *task, int flag )
+{
+	assert( (flag == PUSH_FRONT) || (flag == PUSH_BACK) );
+
+	switch ( flag )
+	{
+	case PUSH_FRONT:
+		m_tasks.insert(m_tasks.begin(), task);
+
+		return TASK_OK;
+		break;
+
+	case PUSH_BACK:
+		m_tasks.insert(m_tasks.end(), task);
+
+		return TASK_OK;
+		break;
+	}
+
+	//Invalid flag
+	return SEQ_FAILED;
+}
+
+/*
+-------------------------
+PopTask
+-------------------------
+*/
+
+CTask *CTaskManager::PopTask( int flag )
+{
+	CTask	*task;
+
+	assert( (flag == POP_FRONT) || (flag == POP_BACK) );
+
+	if ( m_tasks.empty() )
+		return NULL;
+
+	switch ( flag )
+	{
+	case POP_FRONT:
+		task = m_tasks.front();
+		m_tasks.pop_front();
+		
+		return task;
+		break;
+
+	case POP_BACK:
+		task = m_tasks.back();
+		m_tasks.pop_back();
+		
+		return task;
+		break;
+	}
+
+	//Invalid flag
+	return NULL;
+}
+
+/*
+-------------------------
+GetCurrentTask
+-------------------------
+*/
+
+CBlock *CTaskManager::GetCurrentTask( void )
+{
+	CTask *task = PopTask( POP_BACK );
+
+	if ( task == NULL )
+		return NULL;
+// fixed 2/12/2 to free the task that has been popped (called from sequencer Interrupt)
+	CBlock* retBlock = task->GetBlock();
+	task->Free();
+
+	return retBlock;
+//	return task->GetBlock();
+}
+
+/*
+=================================================
+
+  Task Functions
+
+=================================================
+*/
+
+int CTaskManager::Wait( CTask *task, bool &completed  )
+{
+	CBlockMember	*bm;
+	CBlock			*block = task->GetBlock();	
+	char			*sVal;
+	float			dwtime;
+	int				memberNum = 0;
+
+	completed = false;
+
+	bm = block->GetMember( 0 );
+
+	//Check if this is a task completion wait
+	if ( bm->GetID() == TK_STRING )
+	{
+		ICARUS_VALIDATE( Get( m_ownerID, block, memberNum, &sVal ) );
+
+		if ( task->GetTimeStamp() == (m_owner->GetInterface())->I_GetTime() )
+		{
+			//Print out the debug info
+			(m_owner->GetInterface())->I_DPrintf( WL_DEBUG, "%4d wait(\"%s\"); [%d]", m_ownerID, sVal, task->GetTimeStamp() );
+		}
+
+		CTaskGroup	*group = GetTaskGroup( sVal );
+
+		if ( group == NULL )
+		{
+			//TODO: Emit warning
+			completed = false;
+			return TASK_FAILED;
+		}
+
+		completed = group->Complete();
+	}
+	else	//Otherwise it's a time completion wait
+	{
+		if ( Check( ID_RANDOM, block, memberNum ) )
+		{//get it random only the first time
+			float	min, max;
+
+			dwtime = *(float *) block->GetMemberData( memberNum++ );
+			if ( dwtime == Q3_INFINITE )
+			{//we have not evaluated this random yet
+				min	= *(float *) block->GetMemberData( memberNum++ );
+				max	= *(float *) block->GetMemberData( memberNum++ );
+
+				dwtime = (m_owner->GetInterface())->I_Random( min, max );
+
+				//store the result in the first member
+				bm->SetData( &dwtime, sizeof( dwtime ) );
+			}
+		}
+		else
+		{
+			ICARUS_VALIDATE( GetFloat( m_ownerID, block, memberNum, dwtime ) );
+		}
+		
+		if ( task->GetTimeStamp() == (m_owner->GetInterface())->I_GetTime() )
+		{
+			//Print out the debug info
+			(m_owner->GetInterface())->I_DPrintf( WL_DEBUG, "%4d wait( %d ); [%d]", m_ownerID, (int) dwtime, task->GetTimeStamp() );
+		}
+
+		if ( (task->GetTimeStamp() + dwtime) < ((m_owner->GetInterface())->I_GetTime()) )
+		{
+			completed = true;
+			memberNum = 0;
+			if ( Check( ID_RANDOM, block, memberNum ) )
+			{//set the data back to 0 so it will be re-randomized next time
+				dwtime = Q3_INFINITE;
+				bm->SetData( &dwtime, sizeof( dwtime ) );
+			}
+		}
+	}
+
+	return TASK_OK;
+}
+
+/*
+-------------------------
+WaitSignal
+-------------------------
+*/
+
+int CTaskManager::WaitSignal( CTask *task, bool &completed  )
+{
+	CBlock	*block = task->GetBlock();
+	char	*sVal;
+	int		memberNum = 0;
+
+	completed = false;
+
+	ICARUS_VALIDATE( Get( m_ownerID, block, memberNum, &sVal ) );
+
+	if ( task->GetTimeStamp() == (m_owner->GetInterface())->I_GetTime() )
+	{
+		//Print out the debug info
+		(m_owner->GetInterface())->I_DPrintf( WL_DEBUG, "%4d waitsignal(\"%s\"); [%d]", m_ownerID, sVal, task->GetTimeStamp() );
+	}
+
+	if ( (m_owner->GetOwner())->CheckSignal( sVal ) )
+	{
+		completed = true;
+		(m_owner->GetOwner())->ClearSignal( sVal );
+	}
+
+	return TASK_OK;
+}
+
+/*
+-------------------------
+Print
+-------------------------
+*/
+
+int CTaskManager::Print( CTask *task )
+{
+	CBlock	*block = task->GetBlock();
+	char	*sVal;
+	int		memberNum = 0;
+
+	ICARUS_VALIDATE( Get( m_ownerID, block, memberNum, &sVal ) );
+
+	(m_owner->GetInterface())->I_DPrintf( WL_DEBUG, "%4d print(\"%s\"); [%d]", m_ownerID, sVal, task->GetTimeStamp() );
+
+	(m_owner->GetInterface())->I_CenterPrint( sVal );
+
+	Completed( task->GetGUID() );
+	
+	return TASK_OK;
+}
+
+/*
+-------------------------
+Sound
+-------------------------
+*/
+
+int CTaskManager::Sound( CTask *task )
+{
+	CBlock	*block = task->GetBlock();
+	char	*sVal, *sVal2;
+	int		memberNum = 0;
+
+	ICARUS_VALIDATE( Get( m_ownerID, block, memberNum, &sVal ) );
+	ICARUS_VALIDATE( Get( m_ownerID, block, memberNum, &sVal2 ) );
+
+	(m_owner->GetInterface())->I_DPrintf( WL_DEBUG, "%4d sound(\"%s\", \"%s\"); [%d]", m_ownerID, sVal, sVal2, task->GetTimeStamp() );
+
+	//Only instantly complete if the user has requested it
+	if( (m_owner->GetInterface())->I_PlaySound( task->GetGUID(), m_ownerID, sVal2, sVal ) )
+		Completed( task->GetGUID() );
+	
+	return TASK_OK;
+}
+
+/*
+-------------------------
+Rotate
+-------------------------
+*/
+
+int CTaskManager::Rotate( CTask *task )
+{
+	vector_t	vector;
+	CBlock		*block = task->GetBlock();
+	char		*tagName;
+	float		tagLookup, duration;
+	int			memberNum = 0;
+
+	//Check for a tag reference
+	if ( Check( ID_TAG, block, memberNum ) )
+	{
+		memberNum++;
+
+		ICARUS_VALIDATE( Get( m_ownerID, block, memberNum, &tagName ) );
+		ICARUS_VALIDATE( GetFloat( m_ownerID, block, memberNum, tagLookup ) );
+
+		if ( (m_owner->GetInterface())->I_GetTag( m_ownerID, tagName, (int) tagLookup, vector ) == false )
+		{
+			//TODO: Emit warning
+			(m_owner->GetInterface())->I_DPrintf( WL_ERROR, "Unable to find tag \"%s\"!\n", tagName );
+			assert(0);
+			return TASK_FAILED;
+		}
+	}
+	else
+	{
+		//Get a normal vector
+		ICARUS_VALIDATE( GetVector( m_ownerID, block, memberNum, vector ) );
+	}
+
+	//Find the duration
+	ICARUS_VALIDATE( GetFloat( m_ownerID, block, memberNum, duration ) );
+
+	(m_owner->GetInterface())->I_DPrintf( WL_DEBUG, "%4d rotate( <%f,%f,%f>, %d); [%d]", m_ownerID, vector[0], vector[1], vector[2], (int) duration, task->GetTimeStamp() );
+	(m_owner->GetInterface())->I_Lerp2Angles( task->GetGUID(), m_ownerID, vector, duration );
+	
+	return TASK_OK;
+}
+
+/*
+-------------------------
+Remove
+-------------------------
+*/
+
+int CTaskManager::Remove( CTask *task )
+{
+	CBlock	*block = task->GetBlock();
+	char	*sVal;
+	int		memberNum = 0;
+
+	ICARUS_VALIDATE( Get( m_ownerID, block, memberNum, &sVal ) );
+	
+	(m_owner->GetInterface())->I_DPrintf( WL_DEBUG, "%4d remove(\"%s\"); [%d]", m_ownerID, sVal, task->GetTimeStamp() );
+	(m_owner->GetInterface())->I_Remove( m_ownerID, sVal );
+
+	Completed( task->GetGUID() );
+	
+	return TASK_OK;
+}
+
+/*
+-------------------------
+Camera
+-------------------------
+*/
+
+int CTaskManager::Camera( CTask *task )
+{
+	interface_export_t	*ie = ( m_owner->GetInterface() );
+	CBlock		*block = task->GetBlock();
+	vector_t	vector, vector2;
+	float		type, fVal, fVal2, fVal3;
+	char		*sVal;
+	int			memberNum = 0;
+
+	//Get the camera function type
+	ICARUS_VALIDATE( GetFloat( m_ownerID, block, memberNum, type ) );
+
+	switch ( (int) type )
+	{
+	case TYPE_PAN:
+		
+		ICARUS_VALIDATE( GetVector( m_ownerID, block, memberNum, vector ) );
+		ICARUS_VALIDATE( GetVector( m_ownerID, block, memberNum, vector2 ) );
+
+		ICARUS_VALIDATE( GetFloat( m_ownerID, block, memberNum, fVal ) );
+
+		(m_owner->GetInterface())->I_DPrintf( WL_DEBUG, "%4d camera( PAN, <%f %f %f>, <%f %f %f>, %f); [%d]", m_ownerID, vector[0], vector[1], vector[2], vector2[0], vector2[1], vector2[2], fVal, task->GetTimeStamp() );
+		ie->I_CameraPan( vector, vector2, fVal );
+		break;
+
+	case TYPE_ZOOM:
+		
+		ICARUS_VALIDATE( GetFloat( m_ownerID, block, memberNum, fVal ) );
+		ICARUS_VALIDATE( GetFloat( m_ownerID, block, memberNum, fVal2 ) );
+
+		(m_owner->GetInterface())->I_DPrintf( WL_DEBUG, "%4d camera( ZOOM, %f, %f); [%d]", m_ownerID, fVal, fVal2, task->GetTimeStamp() );
+		ie->I_CameraZoom( fVal, fVal2 );
+		break;
+
+	case TYPE_MOVE:
+
+		ICARUS_VALIDATE( GetVector( m_ownerID, block, memberNum, vector ) );
+		ICARUS_VALIDATE( GetFloat( m_ownerID, block, memberNum, fVal ) );
+
+		(m_owner->GetInterface())->I_DPrintf( WL_DEBUG, "%4d camera( MOVE, <%f %f %f>, %f); [%d]", m_ownerID, vector[0], vector[1], vector[2], fVal, task->GetTimeStamp() );
+		ie->I_CameraMove( vector, fVal );
+		break;
+
+	case TYPE_ROLL:
+
+		ICARUS_VALIDATE( GetFloat( m_ownerID, block, memberNum, fVal ) );
+		ICARUS_VALIDATE( GetFloat( m_ownerID, block, memberNum, fVal2 ) );
+
+		(m_owner->GetInterface())->I_DPrintf( WL_DEBUG, "%4d camera( ROLL, %f, %f); [%d]", m_ownerID, fVal, fVal2, task->GetTimeStamp() );
+		ie->I_CameraRoll( fVal, fVal2 );
+
+		break;
+
+	case TYPE_FOLLOW:
+
+		ICARUS_VALIDATE( Get( m_ownerID, block, memberNum, &sVal ) );
+		ICARUS_VALIDATE( GetFloat( m_ownerID, block, memberNum, fVal ) );
+		ICARUS_VALIDATE( GetFloat( m_ownerID, block, memberNum, fVal2 ) );
+
+		(m_owner->GetInterface())->I_DPrintf( WL_DEBUG, "%4d camera( FOLLOW, \"%s\", %f, %f); [%d]", m_ownerID, sVal, fVal, fVal2, task->GetTimeStamp() );
+		ie->I_CameraFollow( (const char *) sVal, fVal, fVal2 );
+
+		break;
+
+	case TYPE_TRACK:
+		
+		ICARUS_VALIDATE( Get( m_ownerID, block, memberNum, &sVal ) );
+		ICARUS_VALIDATE( GetFloat( m_ownerID, block, memberNum, fVal ) );
+		ICARUS_VALIDATE( GetFloat( m_ownerID, block, memberNum, fVal2 ) );
+
+		(m_owner->GetInterface())->I_DPrintf( WL_DEBUG, "%4d camera( TRACK, \"%s\", %f, %f); [%d]", m_ownerID, sVal, fVal, fVal2, task->GetTimeStamp() );
+		ie->I_CameraTrack( (const char *) sVal, fVal, fVal2 );
+		break;
+
+	case TYPE_DISTANCE:
+
+		ICARUS_VALIDATE( GetFloat( m_ownerID, block, memberNum, fVal ) );
+		ICARUS_VALIDATE( GetFloat( m_ownerID, block, memberNum, fVal2 ) );
+		
+		(m_owner->GetInterface())->I_DPrintf( WL_DEBUG, "%4d camera( DISTANCE, %f, %f); [%d]", m_ownerID, fVal, fVal2, task->GetTimeStamp() );
+		ie->I_CameraDistance( fVal, fVal2 );
+		break;
+
+	case TYPE_FADE:
+
+		ICARUS_VALIDATE( GetVector( m_ownerID, block, memberNum, vector ) );
+		ICARUS_VALIDATE( GetFloat( m_ownerID, block, memberNum, fVal ) );
+
+		ICARUS_VALIDATE( GetVector( m_ownerID, block, memberNum, vector2 ) );
+		ICARUS_VALIDATE( GetFloat( m_ownerID, block, memberNum, fVal2 ) );
+		
+		ICARUS_VALIDATE( GetFloat( m_ownerID, block, memberNum, fVal3 ) );
+
+		(m_owner->GetInterface())->I_DPrintf( WL_DEBUG, "%4d camera( FADE, <%f %f %f>, %f, <%f %f %f>, %f, %f); [%d]", m_ownerID, vector[0], vector[1], vector[2], fVal, vector2[0], vector2[1], vector2[2], fVal2, fVal3, task->GetTimeStamp() );
+		ie->I_CameraFade( vector[0], vector[1], vector[2], fVal, vector2[0], vector2[1], vector2[2], fVal2, fVal3 );
+		break;
+
+	case TYPE_PATH:
+		ICARUS_VALIDATE( Get( m_ownerID, block, memberNum, &sVal ) );
+
+		(m_owner->GetInterface())->I_DPrintf( WL_DEBUG, "%4d camera( PATH, \"%s\"); [%d]", m_ownerID, sVal, task->GetTimeStamp() );
+		ie->I_CameraPath( sVal );
+		break;
+
+	case TYPE_ENABLE:
+		(m_owner->GetInterface())->I_DPrintf( WL_DEBUG, "%4d camera( ENABLE ); [%d]", m_ownerID, task->GetTimeStamp() );
+		ie->I_CameraEnable();
+		break;
+
+	case TYPE_DISABLE:
+		(m_owner->GetInterface())->I_DPrintf( WL_DEBUG, "%4d camera( DISABLE ); [%d]", m_ownerID, task->GetTimeStamp() );
+		ie->I_CameraDisable();
+		break;
+	
+	case TYPE_SHAKE:
+		ICARUS_VALIDATE( GetFloat( m_ownerID, block, memberNum, fVal ) );
+		ICARUS_VALIDATE( GetFloat( m_ownerID, block, memberNum, fVal2 ) );
+
+		(m_owner->GetInterface())->I_DPrintf( WL_DEBUG, "%4d camera( SHAKE, %f, %f ); [%d]", m_ownerID, fVal, fVal2, task->GetTimeStamp() );
+		ie->I_CameraShake( fVal, (int) fVal2 );
+		break;
+	}
+
+	Completed( task->GetGUID() );
+
+	return TASK_OK;
+}
+
+/*
+-------------------------
+Move
+-------------------------
+*/
+
+int CTaskManager::Move( CTask *task )
+{
+	vector_t	vector, vector2;
+	CBlock		*block = task->GetBlock();
+	float		duration;
+	int			memberNum = 0;
+
+	//Get the goal position
+	ICARUS_VALIDATE( GetVector( m_ownerID, block, memberNum, vector ) );
+
+	//Check for possible angles field
+	if ( GetVector( m_ownerID, block, memberNum, vector2 ) == false )
+	{
+		ICARUS_VALIDATE( GetFloat( m_ownerID, block, memberNum, duration ) );
+		
+		
+		(m_owner->GetInterface())->I_DPrintf( WL_DEBUG, "%4d move( <%f %f %f>, %f ); [%d]", m_ownerID, vector[0], vector[1], vector[2], duration, task->GetTimeStamp() );
+		(m_owner->GetInterface())->I_Lerp2Pos( task->GetGUID(), m_ownerID, vector, NULL, duration );
+
+		return TASK_OK;
+	}
+
+	//Get the duration and make the call
+	ICARUS_VALIDATE( GetFloat( m_ownerID, block, memberNum, duration ) );
+	
+	(m_owner->GetInterface())->I_DPrintf( WL_DEBUG, "%4d move( <%f %f %f>, <%f %f %f>, %f ); [%d]", m_ownerID, vector[0], vector[1], vector[2], vector2[0], vector2[1], vector2[2], duration, task->GetTimeStamp() );
+	(m_owner->GetInterface())->I_Lerp2Pos( task->GetGUID(), m_ownerID, vector, vector2, duration );
+	
+	return TASK_OK;
+}
+
+/*
+-------------------------
+Kill
+-------------------------
+*/
+
+int CTaskManager::Kill( CTask *task )
+{
+	CBlock	*block = task->GetBlock();
+	char	*sVal;
+	int		memberNum = 0;
+
+	ICARUS_VALIDATE( Get( m_ownerID, block, memberNum, &sVal ) );
+
+	(m_owner->GetInterface())->I_DPrintf( WL_DEBUG, "%4d kill( \"%s\" ); [%d]", m_ownerID, sVal, task->GetTimeStamp() );
+	(m_owner->GetInterface())->I_Kill( m_ownerID, sVal );
+
+	Completed( task->GetGUID() );
+
+	return TASK_OK;
+}
+
+/*
+-------------------------
+Set
+-------------------------
+*/
+
+int CTaskManager::Set( CTask *task )
+{
+	CBlock			*block = task->GetBlock();
+	char			*sVal, *sVal2;
+	int				memberNum = 0;
+
+	ICARUS_VALIDATE( Get( m_ownerID, block, memberNum, &sVal ) );
+	ICARUS_VALIDATE( Get( m_ownerID, block, memberNum, &sVal2 ) );
+
+	(m_owner->GetInterface())->I_DPrintf( WL_DEBUG, "%4d set( \"%s\", \"%s\" ); [%d]", m_ownerID, sVal, sVal2, task->GetTimeStamp() );
+	(m_owner->GetInterface())->I_Set( task->GetGUID(), m_ownerID, sVal, sVal2 );
+
+	return TASK_OK;
+}
+
+/*
+-------------------------
+Use
+-------------------------
+*/
+
+int CTaskManager::Use( CTask *task )
+{
+	CBlock	*block = task->GetBlock();
+	char	*sVal;
+	int		memberNum = 0;
+
+	ICARUS_VALIDATE( Get( m_ownerID, block, memberNum, &sVal ) );
+
+	(m_owner->GetInterface())->I_DPrintf( WL_DEBUG, "%4d use( \"%s\" ); [%d]", m_ownerID, sVal, task->GetTimeStamp() );
+	(m_owner->GetInterface())->I_Use( m_ownerID, sVal );
+
+	Completed( task->GetGUID() );
+
+	return TASK_OK;
+}
+
+/*
+-------------------------
+DeclareVariable
+-------------------------
+*/
+
+int CTaskManager::DeclareVariable( CTask *task )
+{
+	CBlock	*block = task->GetBlock();
+	char	*sVal;
+	int		memberNum = 0;
+	float	fVal;
+
+	ICARUS_VALIDATE( GetFloat( m_ownerID, block, memberNum, fVal ) );
+	ICARUS_VALIDATE( Get( m_ownerID, block, memberNum, &sVal ) );
+
+	(m_owner->GetInterface())->I_DPrintf( WL_DEBUG, "%4d declare( %d, \"%s\" ); [%d]", m_ownerID, (int) fVal, sVal, task->GetTimeStamp() );
+	(m_owner->GetInterface())->I_DeclareVariable( (int) fVal, sVal );
+
+	Completed( task->GetGUID() );
+
+	return TASK_OK;
+
+}
+
+/*
+-------------------------
+FreeVariable
+-------------------------
+*/
+
+int CTaskManager::FreeVariable( CTask *task )
+{
+	CBlock	*block = task->GetBlock();
+	char	*sVal;
+	int		memberNum = 0;
+
+	ICARUS_VALIDATE( Get( m_ownerID, block, memberNum, &sVal ) );
+
+	(m_owner->GetInterface())->I_DPrintf( WL_DEBUG, "%4d free( \"%s\" ); [%d]", m_ownerID, sVal, task->GetTimeStamp() );
+	(m_owner->GetInterface())->I_FreeVariable( sVal );
+
+	Completed( task->GetGUID() );
+
+	return TASK_OK;
+
+}
+
+/*
+-------------------------
+Signal
+-------------------------
+*/
+
+int CTaskManager::Signal( CTask *task )
+{
+	CBlock	*block = task->GetBlock();
+	char	*sVal;
+	int		memberNum = 0;
+
+	ICARUS_VALIDATE( Get( m_ownerID, block, memberNum, &sVal ) );
+
+	(m_owner->GetInterface())->I_DPrintf( WL_DEBUG, "%4d signal( \"%s\" ); [%d]", m_ownerID, sVal, task->GetTimeStamp() );
+	m_owner->GetOwner()->Signal( (const char *) sVal );
+
+	Completed( task->GetGUID() );
+
+	return TASK_OK;
+}
+
+/*
+-------------------------
+Play
+-------------------------
+*/
+
+int CTaskManager::Play( CTask *task )
+{
+	CBlock	*block = task->GetBlock();
+	char	*sVal, *sVal2;
+	int		memberNum = 0;
+
+	ICARUS_VALIDATE( Get( m_ownerID, block, memberNum, &sVal ) );
+	ICARUS_VALIDATE( Get( m_ownerID, block, memberNum, &sVal2 ) );
+
+	(m_owner->GetInterface())->I_DPrintf( WL_DEBUG, "%4d play( \"%s\", \"%s\" ); [%d]", m_ownerID, sVal, sVal2, task->GetTimeStamp() );
+	(m_owner->GetInterface())->I_Play( task->GetGUID(), m_ownerID, (const char *) sVal, (const char *) sVal2 );
+
+	return TASK_OK;
+}
+
+/*
+-------------------------
+SaveCommand
+-------------------------
+*/
+
+//FIXME: ARGH!  This is duplicated from CSequence because I can't directly link it any other way...
+
+int CTaskManager::SaveCommand( CBlock *block )
+{
+	unsigned char	flags;
+	int				numMembers, bID, size;
+	CBlockMember	*bm;
+	
+	//Save out the block ID
+	bID = block->GetBlockID();
+	(m_owner->GetInterface())->I_WriteSaveData( 'BLID', &bID, sizeof ( bID ) );
+
+	//Save out the block's flags
+	flags = block->GetFlags();
+	(m_owner->GetInterface())->I_WriteSaveData( 'BFLG', &flags, sizeof ( flags ) );
+
+	//Save out the number of members to read
+	numMembers = block->GetNumMembers();
+	(m_owner->GetInterface())->I_WriteSaveData( 'BNUM', &numMembers, sizeof ( numMembers ) );
+
+	for ( int i = 0; i < numMembers; i++ )
+	{
+		bm = block->GetMember( i );
+
+		//Save the block id
+		bID = bm->GetID();
+		(m_owner->GetInterface())->I_WriteSaveData( 'BMID', &bID, sizeof ( bID ) );
+		
+		//Save out the data size
+		size = bm->GetSize();
+		(m_owner->GetInterface())->I_WriteSaveData( 'BSIZ', &size, sizeof( size ) );
+		
+		//Save out the raw data
+		(m_owner->GetInterface())->I_WriteSaveData( 'BMEM', bm->GetData(), size );
+	}
+
+	return true;
+}
+
+/*
+-------------------------
+Save
+-------------------------
+*/
+
+void CTaskManager::Save( void )
+{
+#if 0
+	CTaskGroup	*taskGroup;
+	const char	*name;
+	CBlock		*block;
+	DWORD		timeStamp;
+	bool		completed;
+	int			id, numCommands;
+	int			numWritten;
+
+	//Save the taskmanager's GUID
+	(m_owner->GetInterface())->I_WriteSaveData( 'TMID', &m_GUID, sizeof( m_GUID ) );	//FIXME: This can be reconstructed
+
+	//Save out the number of tasks that will follow
+	int iNumTasks = m_tasks.size();
+	(m_owner->GetInterface())->I_WriteSaveData( 'TSK#', &iNumTasks, sizeof(iNumTasks) );
+
+	//Save out all the tasks
+	tasks_l::iterator	ti;
+	
+	STL_ITERATE( ti, m_tasks )
+	{
+		//Save the GUID
+		id = (*ti)->GetGUID();
+		(m_owner->GetInterface())->I_WriteSaveData( 'TKID', &id, sizeof ( id ) );
+
+		//Save the timeStamp (FIXME: Although, this is going to be worthless if time is not consistent...)
+		timeStamp = (*ti)->GetTimeStamp();
+		(m_owner->GetInterface())->I_WriteSaveData( 'TKTS', &timeStamp, sizeof ( timeStamp ) );
+
+		//Save out the block
+		block = (*ti)->GetBlock();
+		SaveCommand( block );
+	}
+
+	//Save out the number of task groups
+	int numTaskGroups = m_taskGroups.size();
+	(m_owner->GetInterface())->I_WriteSaveData( 'TG#G', &numTaskGroups, sizeof( numTaskGroups ) );
+	//Save out the IDs of all the task groups
+	numWritten = 0;
+	taskGroup_v::iterator	tgi;
+	STL_ITERATE( tgi, m_taskGroups )
+	{
+		id = (*tgi)->GetGUID();
+		(m_owner->GetInterface())->I_WriteSaveData( 'TKG#', &id, sizeof( id ) );		
+		numWritten++;
+	}
+	assert (numWritten == numTaskGroups);
+
+	//Save out the task groups
+	numWritten = 0;
+	STL_ITERATE( tgi, m_taskGroups )
+	{
+		//Save out the parent
+		id = ( (*tgi)->GetParent() == NULL ) ? -1 : ((*tgi)->GetParent())->GetGUID();
+		(m_owner->GetInterface())->I_WriteSaveData( 'TKGP', &id, sizeof( id ) );
+
+		//Save out the number of commands
+		numCommands = (*tgi)->m_completedTasks.size();
+		(m_owner->GetInterface())->I_WriteSaveData( 'TGNC', &numCommands, sizeof( numCommands ) );
+
+		//Save out the command map
+		CTaskGroup::taskCallback_m::iterator	tci;
+		
+		STL_ITERATE( tci, (*tgi)->m_completedTasks )
+		{
+			//Write out the ID
+			id = (*tci).first;
+			(m_owner->GetInterface())->I_WriteSaveData( 'GMID', &id, sizeof( id ) );
+
+			//Write out the state of completion
+			completed = (*tci).second;
+			(m_owner->GetInterface())->I_WriteSaveData( 'GMDN', &completed, sizeof( completed ) );
+		}
+
+		//Save out the number of completed commands
+		id = (*tgi)->m_numCompleted;
+		(m_owner->GetInterface())->I_WriteSaveData( 'TGDN', &id, sizeof( id ) );	//FIXME: This can be reconstructed
+		numWritten++;
+	}
+	assert (numWritten == numTaskGroups);
+
+	//Only bother if we've got tasks present
+	if ( m_taskGroups.size() )
+	{
+		//Save out the currently active group
+		int	curGroupID = ( m_curGroup == NULL ) ? -1 : m_curGroup->GetGUID();
+		(m_owner->GetInterface())->I_WriteSaveData( 'TGCG', &curGroupID, sizeof( curGroupID ) );
+	}
+
+	//Save out the task group name maps
+	taskGroupName_m::iterator	tmi;
+	numWritten = 0;
+	STL_ITERATE( tmi, m_taskGroupNameMap )
+	{
+		name = ((*tmi).first).c_str();
+		
+		//Make sure this is a valid string
+		assert( ( name != NULL ) && ( name[0] != NULL ) );
+
+		int length = strlen( name ) + 1;
+
+		//Save out the string size
+		(m_owner->GetInterface())->I_WriteSaveData( 'TGNL', &length, sizeof ( length ) );
+
+		//Write out the string
+		(m_owner->GetInterface())->I_WriteSaveData( 'TGNS', (void *) name, length );
+
+		taskGroup = (*tmi).second;
+
+		id = taskGroup->GetGUID();
+
+		//Write out the ID
+		(m_owner->GetInterface())->I_WriteSaveData( 'TGNI', &id, sizeof( id ) );
+		numWritten++;
+	}
+	assert (numWritten == numTaskGroups);
+#endif
+}
+
+/*
+-------------------------
+Load
+-------------------------
+*/
+
+void CTaskManager::Load( void )
+{
+#if 0
+	unsigned char	flags;
+	CTaskGroup		*taskGroup;
+	CBlock			*block;
+	CTask			*task;
+	DWORD			timeStamp;
+	bool			completed;
+	void			*bData;
+	int				id, numTasks, numMembers;
+	int				bID, bSize;
+
+	//Get the GUID
+	(m_owner->GetInterface())->I_ReadSaveData( 'TMID', &m_GUID, sizeof( m_GUID ) );
+
+	//Get the number of tasks to follow
+	(m_owner->GetInterface())->I_ReadSaveData( 'TSK#', &numTasks, sizeof( numTasks ) );
+	
+	//Reload all the tasks
+	for ( int i = 0; i < numTasks; i++ )
+	{
+		task = new CTask;
+
+		assert( task );
+
+		//Get the GUID
+		(m_owner->GetInterface())->I_ReadSaveData( 'TKID', &id, sizeof( id ) );
+		task->SetGUID( id );
+
+		//Get the time stamp
+		(m_owner->GetInterface())->I_ReadSaveData( 'TKTS', &timeStamp, sizeof( timeStamp ) );
+		task->SetTimeStamp( timeStamp );
+
+		//
+		// BLOCK LOADING
+		//
+
+		//Get the block ID and create a new container
+		(m_owner->GetInterface())->I_ReadSaveData( 'BLID', &id, sizeof( id ) );
+		block = new CBlock;
+		
+		block->Create( id );
+		
+		//Read the block's flags
+		(m_owner->GetInterface())->I_ReadSaveData( 'BFLG', &flags, sizeof( flags ) );
+		block->SetFlags( flags );
+
+		//Get the number of block members
+		(m_owner->GetInterface())->I_ReadSaveData( 'BNUM', &numMembers, sizeof( numMembers ) );
+		
+		for ( int j = 0; j < numMembers; j++ )
+		{
+			//Get the member ID
+			(m_owner->GetInterface())->I_ReadSaveData( 'BMID', &bID, sizeof( bID ) );
+			
+			//Get the member size
+			(m_owner->GetInterface())->I_ReadSaveData( 'BSIZ', &bSize, sizeof( bSize ) );
+
+			//Get the member's data
+			if ( ( bData = ICARUS_Malloc( bSize ) ) == NULL )
+			{
+				assert( 0 );
+				return;
+			}
+
+			//Get the actual raw data
+			(m_owner->GetInterface())->I_ReadSaveData( 'BMEM', bData, bSize );
+
+			//Write out the correct type
+			switch ( bID )
+			{
+			case TK_FLOAT:
+				block->Write( TK_FLOAT, *(float *) bData );
+				break;
+
+			case TK_IDENTIFIER:
+				block->Write( TK_IDENTIFIER, (char *) bData );
+				break;
+
+			case TK_STRING:
+				block->Write( TK_STRING, (char *) bData );
+				break;
+
+			case TK_VECTOR:
+				block->Write( TK_VECTOR, *(vec3_t *) bData );
+				break;
+
+			case ID_RANDOM:
+				block->Write( ID_RANDOM, *(float *) bData );//ID_RANDOM );
+				break;
+
+			case ID_TAG:
+				block->Write( ID_TAG, (float) ID_TAG );
+				break;
+
+			case ID_GET:
+				block->Write( ID_GET, (float) ID_GET );
+				break;
+
+			default:
+				(m_owner->GetInterface())->I_DPrintf( WL_ERROR, "Invalid Block id %d\n", bID);
+				assert( 0 );
+				break;
+			}
+			
+			//Get rid of the temp memory
+			ICARUS_Free( bData );
+		}
+		
+		task->SetBlock( block );
+
+		STL_INSERT( m_tasks, task );
+	}
+
+	//Load the task groups
+	int numTaskGroups;
+	
+	(m_owner->GetInterface())->I_ReadSaveData( 'TG#G', &numTaskGroups, sizeof( numTaskGroups ) );
+
+	if ( numTaskGroups == 0 )
+		return;
+
+	int *taskIDs = new int[ numTaskGroups ];
+
+	//Get the task group IDs
+	for ( i = 0; i < numTaskGroups; i++ )
+	{
+		//Creat a new task group
+		taskGroup = new CTaskGroup;
+		assert( taskGroup );
+
+		//Get this task group's ID
+		(m_owner->GetInterface())->I_ReadSaveData( 'TKG#', &taskIDs[i], sizeof( taskIDs[i] ) );
+		taskGroup->m_GUID = taskIDs[i];
+		
+		m_taskGroupIDMap[ taskIDs[i] ] = taskGroup;
+
+		STL_INSERT( m_taskGroups, taskGroup );
+	}
+
+	//Recreate and load the task groups
+	for ( i = 0; i < numTaskGroups; i++ )
+	{
+		taskGroup = GetTaskGroup( taskIDs[i] );
+		assert( taskGroup );
+
+		//Load the parent ID
+		(m_owner->GetInterface())->I_ReadSaveData( 'TKGP', &id, sizeof( id ) );
+		
+		if ( id != -1 )
+			taskGroup->m_parent = ( GetTaskGroup( id ) != NULL ) ? GetTaskGroup( id ) : NULL;
+
+		//Get the number of commands in this group
+		(m_owner->GetInterface())->I_ReadSaveData( 'TGNC', &numMembers, sizeof( numMembers ) );
+
+		//Get each command and its completion state
+		for ( int j = 0; j < numMembers; j++ )
+		{
+			//Get the ID
+			(m_owner->GetInterface())->I_ReadSaveData( 'GMID', &id, sizeof( id ) );
+
+			//Write out the state of completion
+			(m_owner->GetInterface())->I_ReadSaveData( 'GMDN', &completed, sizeof( completed ) );
+
+			//Save it out
+			taskGroup->m_completedTasks[ id ] = completed;
+		}
+
+		//Get the number of completed tasks
+		(m_owner->GetInterface())->I_ReadSaveData( 'TGDN', &taskGroup->m_numCompleted, sizeof( taskGroup->m_numCompleted ) );
+	}
+
+	//Reload the currently active group
+	int curGroupID;
+
+	(m_owner->GetInterface())->I_ReadSaveData( 'TGCG', &curGroupID, sizeof( curGroupID ) );
+
+	//Reload the map entries
+	for ( i = 0; i < numTaskGroups; i++ )
+	{
+		char	name[1024];
+		int		length;
+		
+		//Get the size of the string
+		(m_owner->GetInterface())->I_ReadSaveData( 'TGNL', &length, sizeof( length ) );
+
+		//Get the string
+		(m_owner->GetInterface())->I_ReadSaveData( 'TGNS', &name, length );
+
+		//Get the id
+		(m_owner->GetInterface())->I_ReadSaveData( 'TGNI', &id, sizeof( id ) );
+
+		taskGroup = GetTaskGroup( id );
+		assert( taskGroup );
+
+		m_taskGroupNameMap[ name ] = taskGroup;
+		m_taskGroupIDMap[ taskGroup->GetGUID() ] = taskGroup;
+	}
+
+	m_curGroup = ( curGroupID == -1 ) ? NULL : m_taskGroupIDMap[curGroupID];
+
+	delete[] taskIDs;
+#endif
+}
diff --git a/codemp/icarus/Tokenizer.cpp b/codemp/icarus/Tokenizer.cpp
new file mode 100644
index 0000000..4b83279
--- /dev/null
+++ b/codemp/icarus/Tokenizer.cpp
@@ -0,0 +1,2837 @@
+// Tokenizer.cpp
+#ifndef NOT_USING_MODULES
+// !!! if you are not using modules, read BELOW !!!
+#include "Module.h" // if you are not using modules, 
+					// create an empty Module.h in your
+					// project -- use of modules allows
+					// the error handler to be overridden
+					// with a custom CErrHandler
+#endif
+#include "Tokenizer.h"
+
+#pragma warning(disable : 4100) //unreferenced formal parameter
+#pragma warning(disable : 4127) //conditional expression is constant
+#pragma warning(disable : 4189) //local variable is initialized but not referenced
+#pragma warning(disable : 4244) //conversion from x to x, possible loss of data
+
+enum
+{
+	DIR_INCLUDE = TK_USERDEF,
+	DIR_IFDEF,
+	DIR_IFNDEF,
+	DIR_ENDIF,
+	DIR_ELSE,
+	DIR_DEFINE,
+	DIR_UNDEFINE,
+};
+
+keywordArray_t CTokenizer::directiveKeywords[] =
+{
+	"include",		DIR_INCLUDE,
+	"ifdef",		DIR_IFDEF,
+	"ifndef",		DIR_IFNDEF,
+	"endif",		DIR_ENDIF,
+	"else",			DIR_ELSE,
+	"define",		DIR_DEFINE,
+	"undefine",		DIR_UNDEFINE,
+	"",				TK_EOF,
+};
+
+keywordArray_t CTokenizer::errorMessages[] =
+{
+	"No Error",							TKERR_NONE,
+	"Unknown Error",					TKERR_UNKNOWN,
+	"Buffer creation failed",			TKERR_BUFFERCREATE,
+	"Unrecognized symbol",				TKERR_UNRECOGNIZEDSYMBOL,
+	"Duplicate symbol",					TKERR_DUPLICATESYMBOL,
+	"String length exceeded",			TKERR_STRINGLENGTHEXCEEDED,
+	"Identifier length exceeded",		TKERR_IDENTIFIERLENGTHEXCEEDED,
+	"Expected integer",					TKERR_EXPECTED_INTEGER,
+	"Expected identifier",				TKERR_EXPECTED_IDENTIFIER,
+	"Expected string",					TKERR_EXPECTED_STRING,
+	"Expected char",					TKERR_EXPECTED_CHAR,
+	"Expected float",					TKERR_EXPECTED_FLOAT,
+	"Unexpected token",					TKERR_UNEXPECTED_TOKEN,
+	"Invalid directive",				TKERR_INVALID_DIRECTIVE,
+	"Include file not found",			TKERR_INCLUDE_FILE_NOTFOUND,
+	"Unmatched directive",				TKERR_UNMATCHED_DIRECTIVE,
+	"",									TKERR_USERERROR,
+};
+
+//
+// CSymbol
+//
+
+CSymbol::CSymbol()
+{
+}
+
+CSymbol::~CSymbol()
+{
+}
+
+CSymbol* CSymbol::Create(LPCTSTR symbolName)
+{
+	CSymbol* retval = new CSymbol();
+	retval->Init(symbolName);
+	return retval;
+}
+
+LPCTSTR CSymbol::GetName()
+{
+	if (m_symbolName == NULL)
+	{
+		return "";
+	}
+	return m_symbolName;
+}
+
+void CSymbol::Init(LPCTSTR symbolName)
+{
+	m_symbolName = (char*)malloc(strlen(symbolName) + 1);
+//	ASSERT(m_symbolName);
+	strcpy(m_symbolName, symbolName);
+}
+
+void CSymbol::Delete()
+{
+	if (m_symbolName != NULL)
+	{
+		free(m_symbolName);
+		m_symbolName = NULL;
+	}
+	delete this;
+}
+
+//
+// CDirectiveSymbol
+//
+
+CDirectiveSymbol::CDirectiveSymbol()
+{
+}
+
+CDirectiveSymbol::~CDirectiveSymbol()
+{
+}
+
+CDirectiveSymbol* CDirectiveSymbol::Create(LPCTSTR symbolName)
+{
+	CDirectiveSymbol* retval = new CDirectiveSymbol();
+	retval->Init(symbolName);
+	return retval;
+}
+
+void CDirectiveSymbol::Init(LPCTSTR symbolName)
+{
+	CSymbol::Init(symbolName);
+	m_value = NULL;
+}
+
+void CDirectiveSymbol::Delete()
+{
+	if (m_value != NULL)
+	{
+		free(m_value);
+		m_value = NULL;
+	}
+	CSymbol::Delete();
+}
+
+void CDirectiveSymbol::SetValue(LPCTSTR value)
+{
+	if (m_value != NULL)
+	{
+		free(m_value);
+	}
+	m_value = (char*)malloc(strlen(value) + 1);
+	strcpy(m_value, value);
+}
+
+LPCTSTR CDirectiveSymbol::GetValue()
+{
+	return m_value;
+}
+
+//
+// CIntSymbol
+//
+
+CIntSymbol::CIntSymbol()
+{
+}
+
+CIntSymbol* CIntSymbol::Create(LPCTSTR symbolName, int value)
+{
+	CIntSymbol* retval = new CIntSymbol();
+	retval->Init(symbolName, value);
+	return retval;
+}
+
+void CIntSymbol::Delete()
+{
+	CSymbol::Delete();
+}
+
+void CIntSymbol::Init(LPCTSTR symbolName, int value)
+{
+	CSymbol::Init(symbolName);
+	m_value = value;
+}
+
+int CIntSymbol::GetValue()
+{
+	return m_value;
+}
+
+//
+// CSymbolTable
+//
+
+CSymbolTable::CSymbolTable()
+{
+	Init();
+}
+
+CSymbolTable::~CSymbolTable()
+{
+}
+
+CSymbolTable* CSymbolTable::Create()
+{
+	CSymbolTable* retval = new CSymbolTable();
+	retval->Init();
+	return retval;
+}
+
+void CSymbolTable::Init()
+{
+}
+
+void CSymbolTable::DiscardSymbols()
+{
+	for (symbolmap_t::iterator isymbol = m_symbols.begin(); isymbol != m_symbols.end(); isymbol++)
+	{
+		(*isymbol).second->Delete();
+	}
+	m_symbols.erase(m_symbols.begin(), m_symbols.end());
+}
+
+void CSymbolTable::Delete()
+{
+	DiscardSymbols();
+	delete this;
+}
+
+bool CSymbolTable::AddSymbol(CSymbol* theSymbol)
+{
+	LPCTSTR name = theSymbol->GetName();
+	
+	symbolmap_t::iterator iter = m_symbols.find(name);
+	if (iter != m_symbols.end())
+	{
+		return false;
+	}
+	m_symbols.insert(symbolmap_t::value_type(name, theSymbol));
+	return true;
+}
+
+CSymbol* CSymbolTable::FindSymbol(LPCTSTR symbolName)
+{
+	symbolmap_t::iterator iter = m_symbols.find(symbolName);
+	if (iter != m_symbols.end())
+	{
+		return (*iter).second;
+	}
+	return NULL;
+}
+
+CSymbol* CSymbolTable::ExtractSymbol(LPCTSTR symbolName)
+{
+	symbolmap_t::iterator iter = m_symbols.find(symbolName);
+	if (iter != m_symbols.end())
+	{
+		CSymbol* retval = (*iter).second;
+		m_symbols.erase(iter);
+	}
+	return NULL;
+}
+
+void CSymbolTable::RemoveSymbol(LPCTSTR symbolName)
+{
+	m_symbols.erase(symbolName);
+}
+
+//
+// CParseStream
+//
+
+CParseStream::CParseStream()
+{
+}
+
+CParseStream::~CParseStream()
+{
+}
+
+CParseStream* CParseStream::Create()
+{
+	return NULL;
+}
+
+void CParseStream::Delete()
+{
+	delete this;
+}
+
+bool CParseStream::Init()
+{
+	m_next = NULL;
+
+	return true;
+}
+
+bool CParseStream::NextChar(byte& theByte)
+{
+	return false;
+}
+
+long CParseStream::GetRemainingSize()
+{
+	return 0;
+}
+
+CParseStream* CParseStream::GetNext()
+{
+	return m_next;
+}
+
+void CParseStream::SetNext(CParseStream* next)
+{
+	m_next = next;
+}
+
+int CParseStream::GetCurLine()
+{
+	return 0;
+}
+
+void CParseStream::GetCurFilename(char** theBuff)
+{
+	*theBuff = NULL;
+}
+
+bool CParseStream::IsThisDefinition(void* theDefinition)
+{
+	return false;
+}
+
+//
+// CParsePutBack
+//
+
+CParsePutBack::CParsePutBack()
+{
+}
+
+CParsePutBack::~CParsePutBack()
+{
+}
+
+CParsePutBack* CParsePutBack::Create(byte theByte, int curLine, LPCTSTR filename)
+{
+	CParsePutBack* curParsePutBack = new CParsePutBack();
+	curParsePutBack->Init(theByte, curLine, filename);
+	return curParsePutBack;
+}
+
+void CParsePutBack::Delete()
+{
+	if (m_curFile != NULL)
+	{
+		free(m_curFile);
+		m_curFile = NULL;
+	}
+	delete this;
+}
+
+bool CParsePutBack::NextChar(byte& theByte)
+{
+	if (m_consumed)
+	{
+		return false;
+	}
+	theByte = m_byte;
+	m_consumed = true;
+	return true;
+}
+
+void CParsePutBack::Init(byte theByte, int curLine, LPCTSTR filename)
+{
+	CParseStream::Init();
+	m_consumed = false;
+	m_byte = theByte;
+	m_curLine = curLine;
+	if (filename != NULL)
+	{
+		m_curFile = (char*)malloc(strlen(filename) + 1);
+		strcpy(m_curFile, filename);
+	}
+	else 
+	{
+		m_curFile = NULL;
+	}
+}
+
+long CParsePutBack::GetRemainingSize()
+{
+	if (m_consumed)
+	{
+		return 0;
+	}
+	else
+	{
+		return 1;
+	}
+}
+
+int CParsePutBack::GetCurLine()
+{
+	return m_curLine;
+}
+
+void CParsePutBack::GetCurFilename(char** theBuff)
+{
+	if (m_curFile == NULL)
+	{
+		*theBuff = NULL;
+		return;
+	}
+	*theBuff = (char*)malloc(strlen(m_curFile) + 1);
+	strcpy(*theBuff, m_curFile);
+}
+
+//
+// CParseFile
+//
+
+CParseFile::CParseFile()
+{
+}
+
+CParseFile::~CParseFile()
+{
+}
+
+CParseFile* CParseFile::Create()
+{
+	CParseFile* theParseFile = new CParseFile();
+	
+	if ( !theParseFile->Init() )
+	{
+		delete theParseFile;
+		return NULL;
+	}
+
+	return theParseFile;
+}
+
+CParseFile* CParseFile::Create(LPCTSTR filename, CTokenizer* tokenizer)
+{
+	CParseFile* theParseFile = new CParseFile();
+	
+	if ( theParseFile->Init(filename, tokenizer) )
+		return theParseFile;
+
+	return NULL;
+}
+
+void CParseFile::Delete()
+{
+	if (m_buff != NULL)
+	{
+		free(m_buff);
+		m_buff = NULL;
+	}
+	if (m_ownsFile && (m_fileHandle != NULL))
+	{
+		CloseHandle(m_fileHandle);
+		m_fileHandle = NULL;
+	}
+	if (m_fileName != NULL)
+	{
+		free(m_fileName);
+		m_fileName = NULL;
+	}
+	delete this;
+}
+
+bool CParseFile::Init()
+{
+	m_fileHandle = NULL;
+	m_buff = NULL;
+	m_ownsFile = false;
+	m_curByte = NULL;
+	m_curLine = 1;
+	m_fileName = NULL;
+	return CParseStream::Init();
+}
+
+DWORD CParseFile::GetFileSize()
+{
+	DWORD dwCur = SetFilePointer(m_fileHandle, 0L, NULL, FILE_CURRENT);
+	DWORD dwLen = SetFilePointer(m_fileHandle, 0, NULL, FILE_END);
+	SetFilePointer(m_fileHandle, dwCur, NULL, FILE_BEGIN);
+	return dwLen;
+}
+
+void CParseFile::Read(void* buff, UINT buffsize)
+{
+	DWORD bytesRead;
+	ReadFile(m_fileHandle, buff, buffsize, &bytesRead, NULL);
+}
+
+bool CParseFile::Init(LPCTSTR filename, CTokenizer* tokenizer)
+{
+	CParseStream::Init();
+	m_fileName = (char*)malloc(strlen(filename) + 1);
+	strcpy(m_fileName, filename);
+		DWORD dwAccess = GENERIC_READ;
+		DWORD dwShareMode = FILE_SHARE_WRITE | FILE_SHARE_READ;
+		SECURITY_ATTRIBUTES sa;
+		sa.nLength = sizeof(sa);
+		sa.lpSecurityDescriptor = NULL;
+		sa.bInheritHandle = 0;
+		DWORD dwCreateFlag = OPEN_EXISTING;
+
+		m_fileHandle = CreateFile(filename, dwAccess, dwShareMode, &sa, dwCreateFlag, FILE_ATTRIBUTE_NORMAL, NULL);
+
+		if (m_fileHandle == (HANDLE)-1)
+		{
+			tokenizer->Error(TKERR_INCLUDE_FILE_NOTFOUND);
+			Init();
+
+			return false;			
+		}
+
+		m_filesize = GetFileSize();
+		m_buff = (byte*)malloc(m_filesize);
+		if (m_buff == NULL)
+		{
+			tokenizer->Error(TKERR_BUFFERCREATE);
+			Init();
+			return false;
+		}
+		Read(m_buff, m_filesize);
+		m_curByte = 0;
+		m_curPos = 1;
+		m_ownsFile = true;
+		m_curLine = 1;
+
+	return true;
+}
+
+long CParseFile::GetRemainingSize()
+{
+	return m_filesize - m_curByte;
+}
+
+bool CParseFile::NextChar(byte& theByte)
+{
+	if (m_curByte < m_filesize)
+	{
+		if (m_buff[m_curByte] == '\n')
+		{
+			m_curLine += 1;
+			m_curPos = 1;
+		}
+		else
+		{
+			m_curPos++;
+		}
+		theByte = m_buff[m_curByte++];
+		return true;
+	}
+	else
+	{
+		return false;
+	}
+}
+
+int CParseFile::GetCurLine()
+{
+	return m_curLine;
+}
+
+void CParseFile::GetCurFilename(char** theBuff)
+{
+	*theBuff = NULL;
+	if (m_fileName != NULL)
+	{
+		*theBuff = (char*)malloc(strlen(m_fileName) + 1);
+		strcpy(*theBuff, m_fileName);
+	}
+}
+
+//
+// CParseMemory
+//
+
+CParseMemory::CParseMemory()
+{
+}
+
+CParseMemory::~CParseMemory()
+{
+}
+
+CParseMemory* CParseMemory::Create(byte* data, long datasize)
+{
+	CParseMemory* curParse = new CParseMemory();
+	curParse->Init(data, datasize);
+	return curParse;
+}
+
+void CParseMemory::Delete()
+{
+	delete this;
+}
+
+bool CParseMemory::NextChar(byte& theByte)
+{
+	if (m_offset < m_datasize)
+	{
+		if (m_data[m_offset] == '\n')
+		{
+			m_curLine += 1;
+			m_curPos = 1;
+		}
+		else
+		{
+			m_curPos++;
+		}
+		theByte = m_data[m_offset++];
+		return true;
+	}
+	else
+	{
+		return false;
+	}
+}
+
+void CParseMemory::Init(byte* data, long datasize)
+{
+	m_data = data;
+	m_curLine = 1;
+	m_curPos = 1;
+	m_offset = 0;
+	m_datasize = datasize;
+}
+
+long CParseMemory::GetRemainingSize()
+{
+	return m_datasize - m_offset;
+}
+
+int CParseMemory::GetCurLine()
+{
+	return m_curLine;
+}
+
+void CParseMemory::GetCurFilename(char** theBuff)
+{
+	*theBuff = NULL;
+}
+
+//
+// CParseBlock
+//
+
+CParseBlock::CParseBlock()
+{
+}
+
+CParseBlock::~CParseBlock()
+{
+}
+
+CParseBlock* CParseBlock::Create(byte* data, long datasize)
+{
+	CParseBlock* curParse = new CParseBlock();
+	curParse->Init(data, datasize);
+	return curParse;
+}
+
+void CParseBlock::Delete()
+{
+	if (m_data != NULL)
+	{
+		free(m_data);
+		m_data = NULL;
+	}
+	delete this;
+}
+
+void CParseBlock::Init(byte* data, long datasize)
+{
+	m_data = (byte*)malloc(datasize);
+	memcpy(m_data, data, datasize);
+	m_curLine = 1;
+	m_curPos = 1;
+	m_offset = 0;
+	m_datasize = datasize;
+}
+
+//
+// CParseToken
+//
+
+CParseToken::CParseToken()
+{
+}
+
+CParseToken::~CParseToken()
+{
+}
+
+CParseToken* CParseToken::Create(CToken* token)
+{
+	CParseToken* curParse = new CParseToken();
+	curParse->Init(token);
+	return curParse;
+}
+
+void CParseToken::Delete()
+{
+	if (m_data != NULL)
+	{
+		free(m_data);
+		m_data = NULL;
+	}
+	delete this;
+}
+
+bool CParseToken::NextChar(byte& theByte)
+{
+	if (m_offset < m_datasize)
+	{
+		if (m_data[m_offset] == '\n')
+		{
+			m_curLine += 1;
+			m_curPos = 1;
+		}
+		else
+		{
+			m_curPos++;
+		}
+		theByte = m_data[m_offset++];
+		return true;
+	}
+	else
+	{
+		return false;
+	}
+}
+
+void CParseToken::Init(CToken* token)
+{
+	LPCTSTR tokenString = token->GetStringValue();
+	m_datasize = strlen(tokenString);
+	if (m_datasize > 0)
+	{
+		m_data = (byte*) malloc(m_datasize);
+		memcpy(m_data, tokenString, m_datasize);
+	}
+	else
+	{
+		m_data = NULL;
+	}
+	m_curLine = 1;
+	m_curPos = 1;
+	m_offset = 0;
+	token->Delete();
+}
+
+long CParseToken::GetRemainingSize()
+{
+	return m_datasize - m_offset;
+}
+
+int CParseToken::GetCurLine()
+{
+	return m_curLine;
+}
+
+void CParseToken::GetCurFilename(char** theBuff)
+{
+	*theBuff = NULL;
+}
+
+//
+// CParseDefine
+//
+
+CParseDefine::CParseDefine()
+{
+}
+
+CParseDefine::~CParseDefine()
+{
+}
+
+CParseDefine* CParseDefine::Create(CDirectiveSymbol* definesymbol)
+{
+	CParseDefine* retval = new CParseDefine();
+	retval->Init(definesymbol);
+	return retval;
+}
+
+void CParseDefine::Delete()
+{
+	CParseMemory::Delete();
+}
+
+void CParseDefine::Init(CDirectiveSymbol* definesymbol)
+{
+	CParseMemory::Init((byte*)definesymbol->GetValue(), strlen(definesymbol->GetValue()));
+	m_defineSymbol = definesymbol;
+}
+
+bool CParseDefine::IsThisDefinition(void* theDefinition)
+{
+	return (CDirectiveSymbol*)theDefinition == m_defineSymbol;
+}
+
+//
+// CToken
+//
+
+CToken::CToken()
+{
+}
+
+CToken::~CToken()
+{
+}
+
+CToken* CToken::Create()
+{
+	CToken* theToken = new CToken();
+	theToken->Init();
+	return theToken;
+}
+
+void CToken::Delete()
+{
+	if (m_string != NULL)
+	{
+		free(m_string);
+		m_string = NULL;
+	}
+	delete this;
+}
+
+void CToken::Init()
+{
+	m_next = NULL;
+	m_string = NULL;
+}
+
+void CToken::SetNext(CToken* theToken)
+{
+	m_next = theToken;
+}
+
+CToken* CToken::GetNext()
+{
+	return m_next;
+}
+
+int CToken::GetType()
+{
+	return TK_EOF;
+}
+
+int CToken::GetIntValue()
+{
+	return 0;
+}
+
+LPCTSTR CToken::GetStringValue()
+{
+	if (m_string == NULL)
+	{
+		return "";
+	}
+	return m_string;
+}
+
+float CToken::GetFloatValue()
+{
+	return 0.0;
+}
+
+//
+// CCharToken
+//
+
+CCharToken::CCharToken()
+{
+}
+
+CCharToken::~CCharToken()
+{
+}
+
+CCharToken* CCharToken::Create(byte theByte)
+{
+	CCharToken* theToken = new CCharToken();
+	theToken->Init(theByte);
+	return theToken;
+}
+
+void CCharToken::Delete()
+{
+	CToken::Delete();
+}
+
+void CCharToken::Init(byte theByte)
+{
+	CToken::Init();
+	char charString[10];
+	switch(theByte)
+	{
+		case '\0':
+			strcpy(charString, "\\0");
+			break;
+		case '\n':
+			strcpy(charString, "\\n");
+			break;
+		case '\\':
+			strcpy(charString, "\\\\");
+			break;
+		case '\'':
+			strcpy(charString, "\\'");
+			break;
+		case '\?':
+			strcpy(charString, "\\?");
+			break;
+		case '\a':
+			strcpy(charString, "\\a");
+			break;
+		case '\b':
+			strcpy(charString, "\\b");
+			break;
+		case '\f':
+			strcpy(charString, "\\f");
+			break;
+		case '\r':
+			strcpy(charString, "\\r");
+			break;
+		case '\t':
+			strcpy(charString, "\\t");
+			break;
+		case '\v':
+			strcpy(charString, "\\v");
+			break;
+		default:
+			charString[0] = (char)theByte;
+			charString[1] = '\0';
+			break;
+	}
+	m_string = (char*)malloc(strlen(charString) + 1);
+	strcpy(m_string, charString);
+}
+
+int CCharToken::GetType()
+{
+	return TK_CHAR;
+}
+
+//
+// CStringToken
+//
+
+CStringToken::CStringToken()
+{
+}
+
+CStringToken::~CStringToken()
+{
+}
+
+CStringToken* CStringToken::Create(LPCTSTR theString)
+{
+	CStringToken* theToken = new CStringToken();
+	theToken->Init(theString);
+	return theToken;
+}
+
+void CStringToken::Delete()
+{
+	CToken::Delete();
+}
+
+void CStringToken::Init(LPCTSTR theString)
+{
+	CToken::Init();
+	m_string = (char*)malloc(strlen(theString) + 1);
+//	ASSERT(m_string);
+	strcpy(m_string, theString);
+}
+
+int CStringToken::GetType()
+{
+	return TK_STRING;
+}
+
+//
+// CIntToken
+//
+
+CIntToken::CIntToken()
+{
+}
+
+CIntToken::~CIntToken()
+{
+}
+
+CIntToken* CIntToken::Create(long value)
+{
+	CIntToken* theToken = new CIntToken();
+	theToken->Init(value);
+	return theToken;
+}
+
+void CIntToken::Delete()
+{
+	CToken::Delete();
+}
+
+void CIntToken::Init(long value)
+{
+	CToken::Init();
+	m_value = value;
+}
+
+int CIntToken::GetType()
+{
+	return TK_INT;
+}
+
+int CIntToken::GetIntValue()
+{
+	return m_value;
+}
+
+float CIntToken::GetFloatValue()
+{
+	return (float)m_value;
+}
+
+LPCTSTR CIntToken::GetStringValue()
+{
+	if (m_string != NULL)
+	{
+		free(m_string);
+		m_string = NULL;
+	}
+	char temp[128];
+	sprintf(temp, "%d", m_value);
+	m_string = (char*)malloc(strlen(temp) + 1);
+	strcpy(m_string, temp);
+	return m_string;
+}
+
+//
+// CFloatToken
+//
+
+CFloatToken::CFloatToken()
+{
+}
+
+CFloatToken::~CFloatToken()
+{
+}
+
+CFloatToken* CFloatToken::Create(float value)
+{
+	CFloatToken* theToken = new CFloatToken();
+	theToken->Init(value);
+	return theToken;
+}
+
+void CFloatToken::Delete()
+{
+	CToken::Delete();
+}
+
+void CFloatToken::Init(float value)
+{
+	CToken::Init();
+	m_value = value;
+}
+
+int CFloatToken::GetType()
+{
+	return TK_FLOAT;
+}
+
+float CFloatToken::GetFloatValue()
+{
+	return m_value;
+}
+
+LPCTSTR CFloatToken::GetStringValue()
+{
+	if (m_string != NULL)
+	{
+		free(m_string);
+		m_string = NULL;
+	}
+	char temp[128];
+	sprintf(temp, "%g", m_value);
+	m_string = (char*)malloc(strlen(temp) + 1);
+	strcpy(m_string, temp);
+	return m_string;
+}
+
+//
+// CIdentifierToken
+//
+
+CIdentifierToken::CIdentifierToken()
+{
+}
+
+CIdentifierToken::~CIdentifierToken()
+{
+}
+
+CIdentifierToken* CIdentifierToken::Create(LPCTSTR name)
+{
+	CIdentifierToken* theToken = new CIdentifierToken();
+	theToken->Init(name);
+	return theToken;
+}
+
+void CIdentifierToken::Delete()
+{
+	CToken::Delete();
+}
+
+void CIdentifierToken::Init(LPCTSTR name)
+{
+	CToken::Init();
+	m_string = (char*)malloc(strlen(name) + 1);
+//	ASSERT(m_string);
+	strcpy(m_string, name);
+}
+
+int CIdentifierToken::GetType()
+{
+	return TK_IDENTIFIER;
+}
+
+//
+// CCommentToken
+//
+
+CCommentToken::CCommentToken()
+{
+}
+
+CCommentToken::~CCommentToken()
+{
+}
+
+CCommentToken* CCommentToken::Create(LPCTSTR name)
+{
+	CCommentToken* theToken = new CCommentToken();
+	theToken->Init(name);
+	return theToken;
+}
+
+void CCommentToken::Delete()
+{
+	CToken::Delete();
+}
+
+void CCommentToken::Init(LPCTSTR name)
+{
+	CToken::Init();
+	m_string = (char*)malloc(strlen(name) + 1);
+//	ASSERT(m_string);
+	strcpy(m_string, name);
+}
+
+int CCommentToken::GetType()
+{
+	return TK_COMMENT;
+}
+
+//
+// CUserToken
+//
+
+CUserToken::CUserToken()
+{
+}
+
+CUserToken::~CUserToken()
+{
+}
+
+CUserToken* CUserToken::Create(int value, LPCTSTR string)
+{
+	CUserToken* theToken = new CUserToken();
+	theToken->Init(value, string);
+	return theToken;
+}
+
+void CUserToken::Delete()
+{
+	CToken::Delete();
+}
+
+void CUserToken::Init(int value, LPCTSTR string)
+{
+	CToken::Init();
+	m_value = value;
+	m_string = (char*)malloc(strlen(string) + 1);
+	strcpy(m_string, string);
+}
+
+int CUserToken::GetType()
+{
+	return m_value;
+}
+
+//
+// CUndefinedToken
+//
+
+CUndefinedToken::CUndefinedToken()
+{
+}
+
+CUndefinedToken::~CUndefinedToken()
+{
+}
+
+CUndefinedToken* CUndefinedToken::Create(LPCTSTR string)
+{
+	CUndefinedToken* theToken = new CUndefinedToken();
+	theToken->Init(string);
+	return theToken;
+}
+
+void CUndefinedToken::Delete()
+{
+	CToken::Delete();
+}
+
+void CUndefinedToken::Init(LPCTSTR string)
+{
+	CToken::Init();
+	m_string = (char*)malloc(strlen(string) + 1);
+	strcpy(m_string, string);
+}
+
+int CUndefinedToken::GetType()
+{
+	return TK_UNDEFINED;
+}
+
+//
+// CTokenizerState
+//
+
+CTokenizerState::CTokenizerState()
+{
+}
+
+CTokenizerState::~CTokenizerState()
+{
+}
+
+CTokenizerState* CTokenizerState::Create(bool skip)
+{
+	CTokenizerState* retval = new CTokenizerState();
+	retval->Init(skip);
+	return retval;
+}
+
+void CTokenizerState::Init(bool skip)
+{
+	m_next = NULL;
+	m_skip = skip;
+	m_elseHit = false;
+}
+
+void CTokenizerState::Delete()
+{
+	delete this;
+}
+
+CTokenizerState* CTokenizerState::GetNext()
+{
+	return m_next;
+}
+
+bool CTokenizerState::ProcessElse()
+{
+	if (!m_elseHit)
+	{
+		m_elseHit = true;
+		m_skip = !m_skip;
+	}
+	return m_elseHit;
+}
+
+void CTokenizerState::SetNext(CTokenizerState* next)
+{
+	m_next = next;
+}
+
+bool CTokenizerState::Skipping()
+{
+	return m_skip;
+}
+
+//
+// CTokenizerHolderState
+//
+
+CTokenizerHolderState::CTokenizerHolderState()
+{
+}
+
+CTokenizerHolderState::~CTokenizerHolderState()
+{
+}
+
+CTokenizerHolderState* CTokenizerHolderState::Create()
+{
+	CTokenizerHolderState* retval = new CTokenizerHolderState();
+	retval->Init();
+	return retval;
+}
+
+void CTokenizerHolderState::Init()
+{
+	CTokenizerState::Init(true);
+}
+
+void CTokenizerHolderState::Delete()
+{
+	delete this;
+}
+
+bool CTokenizerHolderState::ProcessElse()
+{
+	if (!m_elseHit)
+	{
+		m_elseHit = true;
+	}
+	return m_elseHit;
+}
+
+//
+// CKeywordTable
+//
+
+CKeywordTable::CKeywordTable(CTokenizer* tokenizer, keywordArray_t* keywords)
+{
+	m_tokenizer = tokenizer;
+	m_holdKeywords = tokenizer->SetKeywords(keywords);
+}
+
+CKeywordTable::~CKeywordTable()
+{
+	m_tokenizer->SetKeywords(m_holdKeywords);
+}
+
+//
+// CTokenizer
+//
+
+CTokenizer::CTokenizer()
+{
+}
+
+CTokenizer::~CTokenizer()
+{
+}
+
+CTokenizer* CTokenizer::Create(UINT dwFlags)
+{
+	CTokenizer* theTokenizer = new CTokenizer();
+	theTokenizer->Init(dwFlags);
+	return theTokenizer;
+}
+
+void CTokenizer::Delete()
+{
+	while (m_curParseStream != NULL)
+	{
+		CParseStream* curStream = m_curParseStream;
+		m_curParseStream = curStream->GetNext();
+		curStream->Delete();
+	}
+	if (m_symbolLookup != NULL)
+	{
+		m_symbolLookup->Delete();
+		m_symbolLookup = NULL;
+	}
+	while (m_nextToken != NULL)
+	{
+		CToken* curToken = m_nextToken;
+		m_nextToken = curToken->GetNext();
+		curToken->Delete();
+	}
+	while (m_state != NULL)
+	{
+		Error(TKERR_UNMATCHED_DIRECTIVE);
+		CTokenizerState* curState = m_state;
+		m_state = curState->GetNext();
+		curState->Delete();
+	}
+
+/*	if (m_lastErrMsg != NULL)
+	{
+		free(m_lastErrMsg);
+		m_lastErrMsg = NULL;
+	}*/
+	delete this;
+}
+
+void CTokenizer::Error(int theError)
+{
+	char errString[128];
+	char lookupstring[128];
+	int i = 0;
+	while ((errorMessages[i].m_tokenvalue != TKERR_USERERROR) && (errorMessages[i].m_tokenvalue != theError))
+	{
+		i++;
+	}
+	if ((errorMessages[i].m_tokenvalue == TKERR_USERERROR) && (m_errors != NULL))
+	{
+		i = 0;
+		while ((m_errors[i].m_tokenvalue != TK_EOF) && (m_errors[i].m_tokenvalue != theError))
+		{
+			i++;
+		}
+		strcpy(lookupstring, m_errors[i].m_keyword);
+	}
+	else
+	{
+		strcpy(lookupstring, errorMessages[i].m_keyword);
+	}
+	sprintf(errString, "Error -- %d, %s", theError, lookupstring);
+	Error(errString, theError);
+}
+
+void CTokenizer::Error(int theError, LPCTSTR errString)
+{
+	char errstring[128];
+	char lookupstring[128];
+	int i = 0;
+	while ((errorMessages[i].m_tokenvalue != TKERR_USERERROR) && (errorMessages[i].m_tokenvalue != theError))
+	{
+		i++;
+	}
+	if ((errorMessages[i].m_tokenvalue == TKERR_USERERROR) && (m_errors != NULL))
+	{
+		i = 0;
+		while ((m_errors[i].m_tokenvalue != TK_EOF) && (m_errors[i].m_tokenvalue != theError))
+		{
+			i++;
+		}
+		strcpy(lookupstring, m_errors[i].m_keyword);
+	}
+	else
+	{
+		strcpy(lookupstring, errorMessages[i].m_keyword);
+	}
+	sprintf(errstring, "Error -- %d, %s - %s", theError, lookupstring, errString);
+	Error(errstring, theError);
+}
+
+void CTokenizer::Error(LPCTSTR errString, int theError)
+{
+	if (m_errorProc != NULL)
+	{
+		m_errorProc(errString);
+	}
+#ifdef USES_MODULES
+	else 
+	{
+		ReportError(theError, errString);
+	}
+#endif
+}
+
+bool CTokenizer::AddParseFile(LPCTSTR filename)
+{
+	CParseStream* newStream = CParseFile::Create(filename, this);
+
+	if ( newStream != NULL )
+	{
+		newStream->SetNext(m_curParseStream);
+		m_curParseStream = newStream;
+		return true;
+	}
+
+	return false;
+}
+
+void CTokenizer::AddParseStream(byte* data, long datasize)
+{
+	CParseStream* newStream = CParseMemory::Create(data, datasize);
+	newStream->SetNext(m_curParseStream);
+	m_curParseStream = newStream;
+}
+
+long CTokenizer::GetRemainingSize()
+{
+	long retval = 0;
+	CParseStream* curStream = m_curParseStream;
+	while (curStream != NULL)
+	{
+		retval += curStream->GetRemainingSize();
+		curStream = curStream->GetNext();
+	}
+	return retval;
+}
+
+LPCTSTR CTokenizer::LookupToken(int tokenID, keywordArray_t* theTable)
+{
+	if (theTable == NULL)
+	{
+		theTable = m_keywords;
+	}
+	if (theTable == NULL)
+	{
+		return NULL;
+	}
+
+	int i = 0;
+	while (theTable[i].m_tokenvalue != TK_EOF)
+	{
+		if (theTable[i].m_tokenvalue == tokenID)
+		{
+			return theTable[i].m_keyword;
+		}
+		i++;
+	}
+	return NULL;
+}
+
+void CTokenizer::PutBackToken(CToken* theToken, bool commented, LPCTSTR addedChars, bool bIgnoreThisTokenType)
+{
+	if (commented)
+	{
+		CParseToken* newStream = CParseToken::Create(theToken);
+		newStream->SetNext(m_curParseStream);
+		m_curParseStream = newStream;
+
+		if (addedChars != NULL)
+		{
+			CParsePutBack* spacer = CParsePutBack::Create(' ', 0, NULL);
+			spacer->SetNext(m_curParseStream);
+			m_curParseStream = spacer;
+
+			CParseBlock* newBlock = CParseBlock::Create((byte*)addedChars, strlen(addedChars));
+			newBlock->SetNext(m_curParseStream);
+			m_curParseStream = newBlock;
+		}
+
+		char temp[] = "// * ";
+		CParseBlock* newBlock = CParseBlock::Create((byte*)temp, strlen(temp));
+		newBlock->SetNext(m_curParseStream);
+		m_curParseStream = newBlock;
+		return;
+	}
+
+	switch(theToken->GetType())
+	{
+	case TK_INT:
+	case TK_EOF:
+	case TK_UNDEFINED:
+	case TK_FLOAT:
+	case TK_CHAR:
+	case TK_STRING:
+	case TK_EOL:
+	case TK_COMMENT:
+		if (!bIgnoreThisTokenType)
+		{
+			theToken->SetNext(m_nextToken);
+			m_nextToken = theToken;
+			break;
+		}
+	default:
+		CParseToken* newStream = CParseToken::Create(theToken);
+		newStream->SetNext(m_curParseStream);
+		m_curParseStream = newStream;
+		break;
+	}
+
+	if (addedChars != NULL)
+	{
+		CParseBlock* newBlock = CParseBlock::Create((byte*)addedChars, strlen(addedChars));
+		newBlock->SetNext(m_curParseStream);
+		m_curParseStream = newBlock;
+	}
+}
+
+CToken* CTokenizer::GetToken(keywordArray_t* keywords, UINT onFlags, UINT offFlags)
+{
+	keywordArray_t* holdKeywords = SetKeywords(keywords);
+	CToken* retval = GetToken(onFlags, offFlags);
+	SetKeywords(holdKeywords);
+	return retval;
+}
+
+CToken* CTokenizer::GetToken(UINT onFlags, UINT offFlags)
+{
+	UINT holdFlags = m_flags;
+
+	m_flags |= onFlags;
+	m_flags &= (~offFlags);
+	CToken* theToken = NULL;
+	while (theToken == NULL)
+	{
+		theToken = FetchToken();
+		if (theToken == NULL)
+		{
+			continue;
+		}
+		if (theToken->GetType() == TK_EOF)
+		{
+			break;
+		}
+		if (m_state != NULL)
+		{
+			if (m_state->Skipping())
+			{
+				theToken->Delete();
+				theToken = NULL;
+			}
+		}
+	}
+
+	m_flags = holdFlags;
+	return theToken;
+}
+
+CToken* CTokenizer::GetToEndOfLine(int tokenType)
+{
+	// update, if you just want the whole line returned as a string, then allow a much bigger size than
+	//	the default string size of only 128 chars...
+	//
+	if (tokenType == TK_STRING)
+	{		
+		#define iRETURN_STRING_SIZE 2048
+		char theString[iRETURN_STRING_SIZE];
+		theString[0] = ' ';
+
+		for (int i = 1; i < iRETURN_STRING_SIZE; i++)
+		{
+			if (NextChar((byte&)theString[i]))
+			{
+				if (theString[i] != '\n')
+				{
+					continue;
+				}
+				PutBackChar(theString[i]);
+			}
+			theString[i] = '\0';
+
+			return CStringToken::Create(theString);			
+		}
+
+		// line would maks a string too big to fit in buffer...
+		//			
+		Error(TKERR_STRINGLENGTHEXCEEDED);
+	}
+	else
+	{		
+		char theString[MAX_IDENTIFIER_LENGTH];
+		theString[0] = ' ';
+		while (theString[0] == ' ')
+		{
+			if (!NextChar((byte&)theString[0]))
+			{
+				return NULL;
+			}
+		}
+		for (int i = 1; i < MAX_IDENTIFIER_LENGTH; i++)
+		{
+			if (NextChar((byte&)theString[i]))
+			{
+				if (theString[i] != '\n')
+				{
+					continue;
+				}
+				PutBackChar(theString[i]);
+			}
+			theString[i] = '\0';
+			switch(tokenType)
+			{
+			case TK_COMMENT:
+				return CCommentToken::Create(theString);
+			case TK_IDENTIFIER:
+			default:
+				return CIdentifierToken::Create(theString);
+			}
+		}
+		Error(TKERR_IDENTIFIERLENGTHEXCEEDED);
+	}	
+	return NULL;
+}
+
+void CTokenizer::SkipToLineEnd()
+{
+	byte theByte;
+	while(NextChar(theByte))
+	{
+		if (theByte == '\n')
+		{
+			break;
+		}
+	}
+}
+
+CToken* CTokenizer::FetchToken()
+{
+	if (m_nextToken != NULL)
+	{
+		CToken* curToken = m_nextToken;
+		m_nextToken = curToken->GetNext();
+		curToken->SetNext(NULL);
+		return curToken;
+	}
+	byte theByte;
+	CToken* theToken = NULL;
+
+	while (true)
+	{
+		if (!NextChar(theByte))
+		{
+			return CToken::Create();
+		}
+		if (theByte <= ' ')
+		{
+			if ((theByte == '\n') && ((TKF_USES_EOL & m_flags) != 0))
+			{
+				return CUserToken::Create(TK_EOL, "-EOLN-");
+			}
+			continue;
+		}
+		switch(theByte)
+		{
+		case '#':
+			if ((m_flags & TKF_IGNOREDIRECTIVES) == 0)
+			{
+				theToken = HandleDirective();
+			}
+			else
+			{
+				if ((m_flags & TKF_NODIRECTIVES) != 0)
+				{
+					return HandleSymbol('#');
+				}
+				SkipToLineEnd();
+			}
+			break;
+		case '/':
+			theToken = HandleSlash();
+			break;
+		case '"':
+			theToken = HandleString();
+			break;
+		case '\'':
+			theToken = HandleQuote();
+			break;
+		default:
+			if (((theByte >= 'a') && (theByte <= 'z'))
+				|| ((theByte >= 'A') && (theByte <= 'Z'))
+				|| ((theByte == '_') && ((m_flags & TKF_NOUNDERSCOREINIDENTIFIER) == 0)))
+			{
+				theToken = HandleIdentifier(theByte);
+			}
+			else if (((m_flags & TKF_NUMERICIDENTIFIERSTART) != 0) && (theByte >= '0') && (theByte <= '9'))
+			{
+				theToken = HandleIdentifier(theByte);
+			}
+			else if (((theByte >= '0') && (theByte <= '9')) || (theByte == '-'))
+			{
+				theToken = HandleNumeric(theByte);
+			}
+			else if (theByte == '.')
+			{
+				theToken = HandleDecimal();
+			}
+			else if (theByte <= ' ')
+			{
+				break;
+			}
+			else
+			{
+				theToken = HandleSymbol(theByte);
+			}
+		}
+		if (theToken != NULL)
+		{
+			return theToken;
+		}
+	}
+}
+
+bool CTokenizer::NextChar(byte& theByte)
+{
+	while (m_curParseStream != NULL)
+	{
+		if (m_curParseStream->NextChar(theByte))
+		{
+			return true;
+		}
+		CParseStream* curParseStream = m_curParseStream;
+		m_curParseStream = curParseStream->GetNext();
+		curParseStream->Delete();
+	}
+	return false;
+}
+
+bool CTokenizer::RequireToken(int tokenType)
+{
+	CToken* theToken = GetToken();
+	bool retValue = theToken->GetType() == tokenType;
+	theToken->Delete();
+	return retValue;
+}
+
+void CTokenizer::ScanUntilToken(int tokenType)
+{
+	CToken* curToken;
+	int tokenValue = TK_UNDEFINED;
+	while (tokenValue != tokenType)
+	{
+		curToken = GetToken();
+		tokenValue = curToken->GetType();
+		if (tokenValue == TK_EOF)
+		{
+			PutBackToken(curToken);
+			break;
+		}
+		if (tokenValue == tokenType)
+		{
+			PutBackToken(curToken);
+		}
+		else
+		{
+			curToken->Delete();
+		}
+	}
+}
+
+void CTokenizer::Init(UINT dwFlags)
+{
+	m_symbolLookup = NULL;
+	m_nextToken = NULL;
+	m_curParseStream = NULL;
+	m_keywords = NULL;
+	m_symbols = NULL;
+	m_errors = NULL;
+	m_state = NULL;
+	m_flags = dwFlags;
+	m_errorProc = NULL;
+}
+
+void CTokenizer::SetErrorProc(LPTokenizerErrorProc errorProc)
+{
+	m_errorProc = errorProc;
+}
+
+void CTokenizer::SetAdditionalErrors(keywordArray_t* theErrors)
+{
+	m_errors = theErrors;
+}
+
+keywordArray_t* CTokenizer::SetKeywords(keywordArray_t* theKeywords)
+{
+	keywordArray_t* retval = m_keywords;
+	m_keywords = theKeywords;
+	return retval;
+}
+
+void CTokenizer::SetSymbols(keywordArray_t* theSymbols)
+{
+	m_symbols = theSymbols;
+	if (m_symbolLookup != NULL)
+	{
+		m_symbolLookup->Delete();
+		m_symbolLookup = NULL;
+	}
+	int i = 0;
+	if (theSymbols == NULL)
+	{
+		return;
+	}
+	while(theSymbols[i].m_tokenvalue != TK_EOF)
+	{
+		InsertSymbol(theSymbols[i].m_keyword, theSymbols[i].m_tokenvalue);
+		i++;
+	}
+}
+
+void CTokenizer::InsertSymbol(LPCTSTR theSymbol, int theValue)
+{
+	CSymbolLookup** curHead = &m_symbolLookup;
+	CSymbolLookup* curParent = NULL;
+	CSymbolLookup* curLookup = NULL;
+
+	for (UINT i = 0; i < strlen(theSymbol); i++)
+	{
+		bool found = false;
+		curLookup = *curHead;
+		while (curLookup != NULL)
+		{
+			if (curLookup->GetByte() == theSymbol[i])
+			{
+				found = true;
+				break;
+			}
+			curLookup = curLookup->GetNext();
+		}
+		if (!found)
+		{
+			curLookup = CSymbolLookup::Create(theSymbol[i]);
+			curLookup->SetParent(curParent);
+			curLookup->SetNext(*curHead);
+			*curHead = curLookup;
+		}
+		curHead = curLookup->GetChildAddress();
+		curParent = curLookup;
+	}
+	if (curLookup->GetValue() != -1)
+	{
+		Error(TKERR_DUPLICATESYMBOL);
+	}
+	curLookup->SetValue(theValue);
+}
+
+CToken* CTokenizer::HandleString()
+{
+	char theString[MAX_STRING_LENGTH];
+	for (int i = 0; i < MAX_STRING_LENGTH; i++)
+	{
+		if (!NextChar((byte&)theString[i]))
+		{
+			return NULL;
+		}
+		if (theString[i] == '"')
+		{
+			theString[i] = '\0';
+			return CStringToken::Create(theString);
+		}
+		if (theString[i] == '\\')
+		{
+			theString[i] = Escapement();
+		}
+	}
+	Error(TKERR_STRINGLENGTHEXCEEDED);
+	return NULL;
+}
+
+void CTokenizer::GetCurFilename(char** filename)
+{
+	if (m_curParseStream == NULL)
+	{
+		*filename = (char*)malloc(1);
+		*filename[0] = '\0';
+		return;
+	}
+	m_curParseStream->GetCurFilename(filename);
+}
+
+int CTokenizer::GetCurLine()
+{
+	if (m_curParseStream == NULL)
+	{
+		return 0;
+	}
+	return m_curParseStream->GetCurLine();
+}
+
+void CTokenizer::PutBackChar(byte theByte, int curLine, LPCTSTR filename)
+{
+	CParseStream* newStream;
+	if (filename == NULL)
+	{
+		curLine = m_curParseStream->GetCurLine();
+		char* theFile = NULL;
+		m_curParseStream->GetCurFilename(&theFile);
+		newStream = CParsePutBack::Create(theByte, curLine, theFile);
+		if (theFile != NULL)
+		{
+			free(theFile);
+		}
+	}
+	else
+	{
+		newStream = CParsePutBack::Create(theByte, curLine, filename);
+	}
+	newStream->SetNext(m_curParseStream);
+	m_curParseStream = newStream;
+}
+
+byte CTokenizer::Escapement()
+{
+	byte theByte;
+	if (NextChar(theByte))
+	{
+		switch(theByte)
+		{
+		case 'n':
+			return '\n';
+		case '\\':
+			return '\\';
+		case '\'':
+			return '\'';
+		case '?':
+			return '\?';
+		case 'a':
+			return '\a';
+		case 'b':
+			return '\b';
+		case 'f':
+			return '\f';
+		case 'r':
+			return '\r';
+		case 't':
+			return '\t';
+		case 'v':
+			return '\v';
+		case '0':
+			return '\0';
+		// support for octal or hex sequences?? \000 or \xhhh
+		default:
+			PutBackChar(theByte);
+		}
+	}
+	return '\\';
+}
+
+bool CTokenizer::AddDefineSymbol(CDirectiveSymbol* definesymbol)
+{
+	CParseStream* curStream = m_curParseStream;
+	while(curStream != NULL)
+	{
+		if (curStream->IsThisDefinition(definesymbol))
+		{
+			return false;
+		}
+		curStream = curStream->GetNext();
+	}
+	CParseStream* newStream = CParseDefine::Create(definesymbol);
+	newStream->SetNext(m_curParseStream);
+	m_curParseStream = newStream;
+	return true;
+}
+
+CToken* CTokenizer::TokenFromName(LPCTSTR name)
+{
+	CDirectiveSymbol* defineSymbol = (CDirectiveSymbol*)m_defines.FindSymbol(name);
+	if (defineSymbol != NULL)
+	{
+		if (AddDefineSymbol(defineSymbol))
+		{
+			return FetchToken();
+		}
+	}
+	if ((m_keywords != NULL) && ((m_flags & TKF_IGNOREKEYWORDS) == 0))
+	{
+		int i = 0;
+		if ((m_flags & TKF_NOCASEKEYWORDS) == 0)
+		{
+			while (m_keywords[i].m_tokenvalue != TK_EOF)
+			{
+				if (strcmp(m_keywords[i].m_keyword, name) == 0)
+				{
+					return CUserToken::Create(m_keywords[i].m_tokenvalue, name);
+				}
+				i++;
+			}
+		}
+		else
+		{
+			while (m_keywords[i].m_tokenvalue != TK_EOF)
+			{
+				if (stricmp(m_keywords[i].m_keyword, name) == 0)
+				{
+					return CUserToken::Create(m_keywords[i].m_tokenvalue, name);
+				}
+				i++;
+			}
+		}
+	}
+	return CIdentifierToken::Create(name);
+}
+
+int CTokenizer::DirectiveFromName(LPCTSTR name)
+{
+	if (directiveKeywords != NULL)
+	{
+		int i = 0;
+		while (directiveKeywords[i].m_tokenvalue != TK_EOF)
+		{
+			if (strcmp(directiveKeywords[i].m_keyword, name) == 0)
+			{
+				return directiveKeywords[i].m_tokenvalue;
+			}
+			i++;
+		}
+	}
+	return -1;
+}
+
+CToken* CTokenizer::HandleIdentifier(byte theByte)
+{
+	char theString[MAX_IDENTIFIER_LENGTH];
+	theString[0] = theByte;
+	for (int i = 1; i < MAX_IDENTIFIER_LENGTH; i++)
+	{
+		if (NextChar((byte&)theString[i]))
+		{
+			if (((theString[i] != '_') || ((m_flags & TKF_NOUNDERSCOREINIDENTIFIER) == 0)) &&
+				((theString[i] != '-') || ((m_flags & TKF_NODASHINIDENTIFIER) == 0)))
+			{
+				if (((theString[i] >= 'A') && (theString[i] <= 'Z'))
+				 || ((theString[i] >= 'a') && (theString[i] <= 'z'))
+				 || ((theString[i] >= '0') && (theString[i] <= '9'))
+				 || (theString[i] == '_') || (theString[i] == '-'))
+				{
+					continue;
+				}
+			}
+			PutBackChar(theString[i]);
+		}
+		theString[i] = '\0';
+		return TokenFromName(theString);
+	}
+	Error(TKERR_IDENTIFIERLENGTHEXCEEDED);
+	return NULL;
+}
+
+CToken* CTokenizer::HandleSlash()
+{
+	byte theByte;
+	if (!NextChar(theByte))
+	{
+		return NULL;
+	}
+	if (theByte == '/')
+	{
+		if (m_flags & TKF_COMMENTTOKENS)
+		{
+			return GetToEndOfLine(TK_COMMENT);
+		}
+		SkipToLineEnd();
+		return NULL;
+	}
+	if (theByte == '*')
+	{
+		if (m_flags & TKF_COMMENTTOKENS)
+		{
+			char theString[MAX_IDENTIFIER_LENGTH + 1];
+			theString[0] = ' ';
+			while (theString[0] == ' ')
+			{
+				if (!NextChar((byte&)theString[0]))
+				{
+					return NULL;
+				}
+			}
+			for (int i = 1; i < MAX_IDENTIFIER_LENGTH; i++)
+			{
+				if (NextChar((byte&)theString[i]))
+				{
+					if (theString[i] != '*')
+					{
+						continue;
+					}
+					i++;
+					if (NextChar((byte&)theString[i]))
+					{
+						if (theString[i] == '/')
+						{
+							i--;
+							theString[i] = '\0';
+							return CCommentToken::Create(theString);
+						}
+					}
+				}
+			}
+			Error(TKERR_IDENTIFIERLENGTHEXCEEDED);
+			return NULL;
+		}
+		while(NextChar(theByte))
+		{
+			while(theByte == '*')
+			{
+				if (!NextChar(theByte))
+				{
+					break;
+				}
+				if (theByte == '/')
+				{
+					return NULL;
+				}
+			}
+		}
+		return NULL;
+	}
+	PutBackChar(theByte);
+	return HandleSymbol('/');
+}
+
+CToken* CTokenizer::HandleNumeric(byte theByte)
+{
+	bool thesign = theByte == '-';
+	if (thesign)
+	{
+		if (!NextChar(theByte))
+		{
+			return HandleSymbol('-');
+		}
+		if (theByte == '.')
+		{
+			return HandleDecimal(thesign);
+		}
+		if ((theByte < '0') || (theByte > '9'))
+		{
+			PutBackChar(theByte);
+			return HandleSymbol('-');
+		}
+	}
+	if (theByte == '0')
+	{
+		return HandleOctal(thesign);
+	}
+	long value = 0;
+	bool digithit = false;
+	while((theByte >= '0') && (theByte <= '9'))
+	{
+		value = (value * 10) + (theByte - '0');
+		if (!NextChar(theByte))
+		{
+			if (thesign)
+			{
+				value = -value;
+			}
+			return CIntToken::Create(value);
+		}
+		digithit = true;
+	}
+	if (theByte == '.')
+	{
+		if (digithit)
+		{
+			return HandleFloat(thesign, value);
+		}
+		if (thesign)
+		{
+			PutBackChar(theByte);
+			theByte = '-';
+		}
+		return HandleSymbol(theByte);
+	}
+	PutBackChar(theByte);
+	if (thesign)
+	{
+		value = -value;
+	}
+	return CIntToken::Create(value);
+}
+
+CToken* CTokenizer::HandleOctal(bool thesign)
+{
+	byte theByte;
+	int value = 0;
+
+	if (!NextChar(theByte))
+	{
+		return CIntToken::Create(value);
+	}
+	if (theByte == '.')
+	{
+		return HandleDecimal(thesign);
+	}
+	if ((theByte == 'x') || (theByte == 'X'))
+	{
+		return HandleHex(thesign);
+	}
+	while(true)
+	{
+		if((theByte >= '0') && (theByte <='7'))
+		{
+			value = (value * 8) + (theByte - '0');
+		}
+		else
+		{
+			PutBackChar(theByte);
+			if (thesign)
+			{
+				value = -value;
+			}
+			return CIntToken::Create(value);
+		}
+		if (!NextChar(theByte))
+		{
+			if (thesign)
+			{
+				value = -value;
+			}
+			return CIntToken::Create(value);
+		}
+	}
+}
+
+CToken* CTokenizer::HandleHex(bool thesign)
+{
+	int value = 0;
+
+	while (true)
+	{
+		byte theByte;
+		if (!NextChar(theByte))
+		{
+			if (thesign)
+			{
+				value = -value;
+			}
+			return CIntToken::Create(value);
+		}
+		switch (theByte)
+		{
+		case '0':
+		case '1':
+		case '2':
+		case '3':
+		case '4':
+		case '5':
+		case '6':
+		case '7':
+		case '8':
+		case '9':
+			theByte = theByte - '0';
+			break;
+		case 'A':
+		case 'B':
+		case 'C':
+		case 'D':
+		case 'E':
+		case 'F':
+			theByte = theByte - 'A' + 10;
+			break;
+		case 'a':
+		case 'b':
+		case 'c':
+		case 'd':
+		case 'e':
+		case 'f':
+			theByte = theByte - 'a' + 10;
+			break;
+		default:
+			PutBackChar(theByte);
+			if (thesign)
+			{
+				value = -value;
+			}
+			return CIntToken::Create(value);
+		}
+		value = (value * 16) + theByte;
+	}
+}
+
+CToken* CTokenizer::HandleDecimal(bool thesign)
+{
+	byte theByte;
+	if (!NextChar(theByte))
+	{
+		if (thesign)
+		{
+			PutBackChar('.');
+			return HandleSymbol('-');
+		}
+		HandleSymbol('.');
+	}
+	PutBackChar(theByte);
+	if ((theByte <= '9') && (theByte >= '0'))
+	{
+		return HandleFloat(thesign);
+	}
+	if (thesign)
+	{
+		PutBackChar('.');
+		theByte = '-';
+	}
+	else
+	{
+		theByte = '.';
+	}
+	return HandleSymbol(theByte);
+}
+
+CToken* CTokenizer::HandleFloat(bool thesign, long value)
+{
+	float lower = 1.0;
+	float newValue = (float)value;
+	byte theByte;
+	while(NextChar(theByte))
+	{
+		if ((theByte >= '0') && (theByte <= '9'))
+		{
+			lower = lower / 10;
+			newValue = newValue + ((theByte - '0') * lower);
+			continue;
+		}
+		PutBackChar(theByte);
+		break;
+	}
+	if (thesign)
+	{
+		newValue = -newValue;
+	}
+	return CFloatToken::Create(newValue);
+}
+
+CToken* CTokenizer::HandleQuote()
+{
+	byte theByte;
+	if (!NextChar(theByte))
+	{
+		Error(TKERR_EXPECTED_CHAR);
+		return NULL;
+	}
+	if (theByte == '\\')
+	{
+		theByte = Escapement();
+	}
+	byte dummy;
+	if (!NextChar(dummy))
+	{
+		Error(TKERR_EXPECTED_CHAR);
+		return NULL;
+	}
+	if (dummy != '\'')
+	{
+		PutBackChar(dummy);
+		PutBackChar(theByte);
+		Error(TKERR_EXPECTED_CHAR);
+		return NULL;
+	}
+	return CCharToken::Create(theByte);
+}
+
+void CTokenizer::SetFlags(UINT flags)
+{
+	m_flags = flags;
+}
+
+UINT CTokenizer::GetFlags()
+{
+	return m_flags;
+}
+
+CToken* CTokenizer::HandleSymbol(byte theByte)
+{
+	char symbolString[128];
+	int curStrLen = 0;
+	symbolString[0] = '\0';
+	bool consumed = false;
+
+	CSymbolLookup* curLookup;
+	if ((m_flags & TKF_RAWSYMBOLSONLY) == 0)
+	{
+		curLookup = m_symbolLookup;
+	}
+	else
+	{
+		curLookup = NULL;
+	}
+	CSymbolLookup* lastLookup = NULL;
+	while(curLookup != NULL)
+	{
+		if (curLookup->GetByte() == theByte)
+		{
+			symbolString[curStrLen++] = theByte;
+			symbolString[curStrLen] = '\0';
+			lastLookup = curLookup;
+			consumed = true;
+			if (curLookup->GetChild() == NULL)
+			{
+				break;
+			}
+			if (!NextChar(theByte))
+			{
+				PutBackToken(CToken::Create());
+				break;
+			}
+			consumed = false;
+			curLookup = curLookup->GetChild();
+			continue;
+		}
+		curLookup = curLookup->GetNext();
+	}
+	if ((!consumed) && (lastLookup != NULL))
+	{
+		PutBackChar(theByte);
+	}
+	while ((lastLookup != NULL) && (lastLookup->GetValue() == -1))
+	{
+		curStrLen--;
+		symbolString[curStrLen] = '\0';
+	//	symbolString = symbolString.Left(symbolString.GetLength() - 1);
+		if (lastLookup->GetParent() == NULL)
+		{
+			if ((m_flags & TKF_WANTUNDEFINED) == 0)
+			{
+				Error(TKERR_UNRECOGNIZEDSYMBOL);
+			}
+		}
+		else
+		{
+			PutBackChar(lastLookup->GetByte());
+		}
+		lastLookup = lastLookup->GetParent();
+	}
+	if (lastLookup == NULL)
+	{
+		if ((m_flags & TKF_WANTUNDEFINED) == 0)
+		{
+			return NULL;
+		}
+		curStrLen = 0;
+		symbolString[curStrLen++] = char(theByte);
+		symbolString[curStrLen] = '\0';
+		if ((m_flags & TKF_WIDEUNDEFINEDSYMBOLS) != 0)
+		{
+			while (true)
+			{
+				if (!NextChar(theByte))
+				{
+					PutBackToken(CToken::Create());
+					break;
+				}
+				if (theByte == ' ')
+				{
+					break;
+				}
+				if (((theByte >= 'a') && (theByte <= 'z')) || ((theByte >= 'A') && (theByte <= 'Z')) ||
+				((theByte >= '0') && (theByte <= '9')))
+				{
+					PutBackChar(theByte);
+					break;
+				}
+				if (theByte < ' ')
+				{
+					if ((theByte == '\n') && ((TKF_USES_EOL & m_flags) != 0))
+					{
+						PutBackToken(CUserToken::Create(TK_EOL, "-EOLN-"));
+						break;
+					}
+					continue;
+				}
+				symbolString[curStrLen++] = theByte;
+				symbolString[curStrLen] = '\0';
+			}
+		}
+		return CUndefinedToken::Create(symbolString);
+	}
+	return CUserToken::Create(lastLookup->GetValue(), symbolString);
+}
+
+CToken* CTokenizer::HandleDirective()
+{
+	int tokenValue = 0;
+	CToken* theToken = FetchToken();
+	if (theToken->GetType() == TK_EOF)
+	{
+		return theToken;
+	}
+	if (theToken->GetType() != TK_IDENTIFIER)
+	{
+		Error(TKERR_INVALID_DIRECTIVE);
+		theToken->Delete();
+		SkipToLineEnd();
+		return NULL;
+	}
+
+	CDirectiveSymbol* curSymbol;
+	CTokenizerState* state;
+	int theDirective = DirectiveFromName(theToken->GetStringValue());
+	theToken->Delete();
+	byte theByte;
+	switch(theDirective)
+	{
+	case DIR_INCLUDE:
+		if ((m_state != NULL) && (m_state->Skipping()))
+		{
+			break;
+		}
+		theToken = GetToken();
+		if (theToken->GetType() != TK_STRING)
+		{
+			Error(TKERR_INCLUDE_FILE_NOTFOUND);
+			theToken->Delete();
+			SkipToLineEnd();
+			break;
+		}
+		AddParseFile(theToken->GetStringValue());
+		theToken->Delete();
+		break;
+	case DIR_IFDEF:
+		if ((m_state != NULL) && (m_state->Skipping()))
+		{
+			state = CTokenizerHolderState::Create();
+			state->SetNext(m_state);
+			m_state = state;
+			break;
+		}
+		theToken = GetToken();
+		if (theToken->GetType() != TK_IDENTIFIER)
+		{
+			Error(TKERR_EXPECTED_IDENTIFIER);
+			theToken->Delete();
+			SkipToLineEnd();
+			break;
+		}
+		state = CTokenizerState::Create(m_defines.FindSymbol(theToken->GetStringValue()) == NULL);
+		theToken->Delete();
+		state->SetNext(m_state);
+		m_state = state;
+		break;
+	case DIR_IFNDEF:
+		if ((m_state != NULL) && (m_state->Skipping()))
+		{
+			state = CTokenizerHolderState::Create();
+			state->SetNext(m_state);
+			m_state = state;
+			break;
+		}
+		theToken = GetToken();
+		if (theToken->GetType() != TK_IDENTIFIER)
+		{
+			Error(TKERR_EXPECTED_IDENTIFIER);
+			theToken->Delete();
+			SkipToLineEnd();
+			break;
+		}
+		state = CTokenizerState::Create(m_defines.FindSymbol(theToken->GetStringValue()) != NULL);
+		theToken->Delete();
+		state->SetNext(m_state);
+		m_state = state;
+		break;
+	case DIR_ENDIF:
+		if (m_state == NULL)
+		{
+			Error(TKERR_UNMATCHED_DIRECTIVE);
+			break;
+		}
+		state = m_state;
+		m_state = state->GetNext();
+		state->Delete();
+		break;
+	case DIR_ELSE:
+		if (m_state == NULL)
+		{
+			Error(TKERR_UNMATCHED_DIRECTIVE);
+			break;
+		}
+		if (!m_state->ProcessElse())
+		{
+			Error(TKERR_UNMATCHED_DIRECTIVE);
+			break;
+		}
+		break;
+	case DIR_DEFINE:
+		if ((m_state != NULL) && (m_state->Skipping()))
+		{
+			break;
+		}
+		theToken = GetToken();
+		if (theToken->GetType() != TK_IDENTIFIER)
+		{
+			Error(TKERR_EXPECTED_IDENTIFIER);
+			theToken->Delete();
+			SkipToLineEnd();
+			break;
+		}
+		// blind add - should check first for value changes
+		{
+			curSymbol = CDirectiveSymbol::Create(theToken->GetStringValue());
+			char temp[128];
+			int tempsize = 0;
+			while(NextChar(theByte))
+			{
+				if (theByte == '\n')
+				{
+					break;
+				}
+				temp[tempsize++] = char(theByte);
+			}
+			temp[tempsize] = '\0';
+			curSymbol->SetValue(temp);
+			if (!m_defines.AddSymbol(curSymbol))
+			{
+				curSymbol->Delete();
+			}
+		}
+		break;
+	case DIR_UNDEFINE:
+		if ((m_state != NULL) && (m_state->Skipping()))
+		{
+			break;
+		}
+		theToken = GetToken();
+		if (theToken->GetType() != TK_IDENTIFIER)
+		{
+			Error(TKERR_EXPECTED_IDENTIFIER);
+			theToken->Delete();
+			SkipToLineEnd();
+			break;
+		}
+		m_defines.RemoveSymbol(theToken->GetStringValue());
+		break;
+	default:
+		Error(TKERR_INVALID_DIRECTIVE);
+		SkipToLineEnd();
+		break;
+	}
+	return NULL;
+}
+
+COLORREF CTokenizer::ParseRGB()
+{
+	CToken* theToken = GetToken();
+	if (theToken->GetType() != TK_INT)
+	{
+		Error(TKERR_EXPECTED_INTEGER);
+		theToken->Delete();
+		return RGB(0, 0, 0);
+	}
+	int red = theToken->GetIntValue();
+	theToken->Delete();
+	theToken = GetToken();
+	if (theToken->GetType() != TK_INT)
+	{
+		Error(TKERR_EXPECTED_INTEGER);
+		theToken->Delete();
+		return RGB(0, 0, 0);
+	}
+	int green = theToken->GetIntValue();
+	theToken->Delete();
+	theToken = GetToken();
+	if (theToken->GetType() != TK_INT)
+	{
+		Error(TKERR_EXPECTED_INTEGER);
+		theToken->Delete();
+		return RGB(0, 0, 0);
+	}
+	int blue = theToken->GetIntValue();
+	theToken->Delete();
+	return RGB(red, green, blue);
+}
+
+//
+// CSymbolLookup
+//
+
+CSymbolLookup::CSymbolLookup()
+{
+}
+
+CSymbolLookup::~CSymbolLookup()
+{
+}
+
+CSymbolLookup* CSymbolLookup::Create(byte theByte)
+{
+	CSymbolLookup* curLookup = new CSymbolLookup();
+	curLookup->Init(theByte);
+	return curLookup;
+}
+
+void CSymbolLookup::Delete()
+{
+	if (m_sibling != NULL)
+	{
+		m_sibling->Delete();
+		m_sibling = NULL;
+	}
+	if (m_child != NULL)
+	{
+		m_child->Delete();
+		m_child = NULL;
+	}
+	delete this;
+}
+
+void CSymbolLookup::Init(byte theByte)
+{
+	m_parent = NULL;
+	m_child = NULL;
+	m_sibling = NULL;
+	m_value = -1;
+	m_byte = theByte;
+}
+
+CSymbolLookup* CSymbolLookup::GetNext()
+{
+	return m_sibling;
+}
+
+void CSymbolLookup::SetNext(CSymbolLookup* next)
+{
+	m_sibling = next;
+}
+
+void CSymbolLookup::SetParent(CSymbolLookup* parent)
+{
+	m_parent = parent;
+}
+
+void CSymbolLookup::SetValue(int value)
+{
+	m_value = value;
+}
+
+int CSymbolLookup::GetValue()
+{
+	return m_value;
+}
+
+byte CSymbolLookup::GetByte()
+{
+	return m_byte;
+}
+
+CSymbolLookup** CSymbolLookup::GetChildAddress()
+{
+	return &m_child;
+}
+
+CSymbolLookup* CSymbolLookup::GetChild()
+{
+	return m_child;
+}
+
+CSymbolLookup* CSymbolLookup::GetParent()
+{
+	return m_parent;
+}
\ No newline at end of file
diff --git a/codemp/icarus/blockstream.h b/codemp/icarus/blockstream.h
new file mode 100644
index 0000000..b2ef76f
--- /dev/null
+++ b/codemp/icarus/blockstream.h
@@ -0,0 +1,198 @@
+// BlockStream.h
+
+#ifndef __INTERPRETED_BLOCK_STREAM__
+#define	__INTERPRETED_BLOCK_STREAM__
+
+#pragma warning(disable : 4786)  //identifier was truncated 
+#pragma warning(disable : 4514)  //unreffed inline func removed
+
+#include "../qcommon/qcommon.h"
+#include <stdio.h>
+
+#pragma warning (push, 3)	//go back down to 3 for the stl include
+#include <list>
+#include <vector>
+#pragma warning (pop)
+using namespace std;
+
+#define	IBI_EXT			".IBI"	//(I)nterpreted (B)lock (I)nstructions
+#define IBI_HEADER_ID	"IBI"
+
+const	float	IBI_VERSION			= 1.57f;
+const	int		MAX_FILENAME_LENGTH = 1024;
+
+typedef	float	vector_t[3];
+
+enum 
+{
+	POP_FRONT,
+	POP_BACK,
+	PUSH_FRONT,
+	PUSH_BACK
+};
+
+// Templates
+
+// CBlockMember
+
+class CBlockMember
+{
+public:
+
+	CBlockMember();	
+	~CBlockMember();
+
+	void Free( void );
+
+	int WriteMember ( FILE * );				//Writes the member's data, in block format, to FILE *
+	int	ReadMember( char **, long * );		//Reads the member's data, in block format, from FILE *
+
+	void SetID( int id )		{	m_id = id;		}	//Set the ID member variable
+	void SetSize( int size )	{	m_size = size;	}	//Set the size member variable
+
+	void GetInfo( int *, int *, void **);
+
+	//SetData overloads
+	void SetData( const char * );
+	void SetData( vector_t );
+	void SetData( void *data, int size );
+
+	int	GetID( void )		const	{	return m_id;	}	//Get ID member variables
+	void *GetData( void )	const	{	return m_data;	}	//Get data member variable
+	int	GetSize( void )		const	{	return m_size;	}	//Get size member variable
+
+	inline void *operator new( size_t size )
+	{	// Allocate the memory.
+		return Z_Malloc( size, TAG_ICARUS4, qtrue );
+	}
+	// Overloaded delete operator.
+	inline void operator delete( void *pRawData )
+	{	// Free the Memory.
+		Z_Free( pRawData );
+	}
+
+	CBlockMember *Duplicate( void );
+
+	template <class T> void WriteData(T &data)
+	{
+		if ( m_data )
+		{
+			ICARUS_Free( m_data );
+		}
+
+		m_data = ICARUS_Malloc( sizeof(T) );
+		*((T *) m_data) = data;
+		m_size = sizeof(T);
+	}
+
+	template <class T> void WriteDataPointer(const T *data, int num)
+	{
+		if ( m_data )
+		{
+			ICARUS_Free( m_data );
+		}
+
+		m_data = ICARUS_Malloc( num*sizeof(T) );
+		memcpy( m_data, data, num*sizeof(T) );
+		m_size = num*sizeof(T);
+	}
+
+protected:
+
+	int		m_id;		//ID of the value contained in data
+	int		m_size;		//Size of the data member variable
+	void	*m_data;	//Data for this member
+};
+	
+//CBlock
+
+class CBlock
+{
+	typedef vector< CBlockMember * >	blockMember_v;
+
+public:
+
+	CBlock();
+	~CBlock();
+
+	int Init( void );
+
+	int Create( int );
+	int Free();
+
+	//Write Overloads
+
+	int Write( int, vector_t );
+	int Write( int, float );
+	int Write( int, const char * );
+	int Write( int, int );
+	int Write( CBlockMember * );
+
+	//Member push / pop functions
+
+	int AddMember( CBlockMember * );
+	CBlockMember *GetMember( int memberNum );
+
+	void	*GetMemberData( int memberNum );
+
+	CBlock *Duplicate( void );
+
+	int	GetBlockID( void )		const	{	return m_id;			}	//Get the ID for the block
+	int	GetNumMembers( void )	const	{	return m_members.size();}	//Get the number of member in the block's list
+
+	void SetFlags( unsigned char flags )	{	m_flags = flags;	}
+	void SetFlag( unsigned char flag )		{	m_flags |= flag;	}
+	
+	int HasFlag( unsigned char flag )	const	{	return ( m_flags & flag );	}
+	unsigned char GetFlags( void )		const	{	return m_flags;				}
+
+protected:
+
+	blockMember_v				m_members;			//List of all CBlockMembers owned by this list
+	int							m_id;				//ID of the block
+	unsigned char				m_flags;
+};
+
+// CBlockStream
+
+class CBlockStream
+{
+public:
+
+	CBlockStream();
+	~CBlockStream();
+
+	int Init( void );
+
+	int Create( char * );
+	int Free( void );
+
+	// Stream I/O functions
+
+	int BlockAvailable( void );
+
+	int WriteBlock( CBlock * );	//Write the block out
+	int ReadBlock( CBlock * );	//Read the block in
+	
+	int Open( char *, long );	//Open a stream for reading / writing
+
+protected:
+
+	unsigned	GetUnsignedInteger( void );
+	int			GetInteger( void );
+	
+	char	GetChar( void );
+	long	GetLong( void );
+	float	GetFloat( void );
+
+	void	StripExtension( const char *, char * );	//Utility function to strip away file extensions
+
+	long	m_fileSize;							//Size of the file	
+	FILE	*m_fileHandle;						//Global file handle of current I/O source
+	char	m_fileName[MAX_FILENAME_LENGTH];	//Name of the current file
+
+	char	*m_stream;							//Stream of data to be parsed
+	long	m_streamPos;
+};
+
+#endif	//__INTERPRETED_BLOCK_STREAM__
\ No newline at end of file
diff --git a/codemp/icarus/icarus.h b/codemp/icarus/icarus.h
new file mode 100644
index 0000000..fdb93b0
--- /dev/null
+++ b/codemp/icarus/icarus.h
@@ -0,0 +1,32 @@
+// ICARUS Public Header File
+
+#pragma warning ( disable : 4786 )	//NOTENOTE: STL Debug name length warning
+
+#ifndef	__ICARUS__
+#define __ICARUS__
+
+#include "../game/g_public.h"
+
+#pragma warning( disable : 4786 )  // identifier was truncated 
+#pragma warning( disable : 4514 )  // unreferenced inline was removed
+#pragma warning( disable : 4710 )  // not inlined
+
+#pragma warning( push, 3 )	//save current state and change to 3
+
+#define STL_ITERATE( a, b )		for ( a = b.begin(); a != b.end(); a++ )
+#define STL_INSERT( a, b )		a.insert( a.end(), b );
+
+#include "tokenizer.h"
+#include "blockstream.h"
+#include "interpreter.h"
+#include "sequencer.h"
+#include "taskmanager.h"
+#include "instance.h"
+
+#pragma warning( pop )	//restore
+
+
+extern void *ICARUS_Malloc(int iSize);
+extern void  ICARUS_Free(void *pMem);
+
+#endif	//__ICARUS__
diff --git a/codemp/icarus/instance.h b/codemp/icarus/instance.h
new file mode 100644
index 0000000..0ca33f2
--- /dev/null
+++ b/codemp/icarus/instance.h
@@ -0,0 +1,81 @@
+// ICARUS Intance header
+
+#ifndef __INSTANCE__
+#define __INSTANCE__
+
+#include "blockstream.h"
+#include "interface.h"
+#include "taskmanager.h"
+#include "sequence.h"
+#include "sequencer.h"
+
+class ICARUS_Instance
+{
+public:
+
+	typedef list< CSequence * >				sequence_l;
+	typedef list< CSequencer * >			sequencer_l;
+	typedef map < string, unsigned char >	signal_m;
+
+	ICARUS_Instance( void );
+	~ICARUS_Instance( void );
+
+	static	ICARUS_Instance *Create( interface_export_t * );
+	int Delete( void );
+
+	CSequencer *GetSequencer( int );
+	void DeleteSequencer( CSequencer * );
+
+	CSequence *GetSequence( void );
+	CSequence *GetSequence( int id );
+	void DeleteSequence( CSequence * );
+
+	interface_export_t	*GetInterface( void )	const	{	return	m_interface;	}
+
+	//These are overriddable for "worst-case" save / loads
+	virtual int Save( void /*FIXME*/ );	
+	virtual int Load( void /*FIXME*/ );
+
+	void Signal( const char *identifier );
+	bool CheckSignal( const char *identifier );
+	void ClearSignal( const char *identifier );
+
+protected:
+
+	virtual int SaveSignals( void );
+	virtual int SaveSequences( void );
+	virtual int SaveSequenceIDTable( void );
+	virtual int SaveSequencers( void );
+
+	int AllocateSequences( int numSequences, int *idTable );
+
+	virtual	int LoadSignals( void );
+	virtual	int LoadSequencers( void );
+	virtual	int LoadSequences( void );
+	virtual int LoadSequence( void );
+
+	int Free( void );
+
+	interface_export_t	*m_interface;
+	int					m_GUID;
+
+	sequence_l			m_sequences;
+	sequencer_l			m_sequencers;
+
+	signal_m			m_signals;
+
+#ifdef _DEBUG
+
+	int	m_DEBUG_NumSequencerAlloc;
+	int	m_DEBUG_NumSequencerFreed;
+	int m_DEBUG_NumSequencerResidual;
+
+	int	m_DEBUG_NumSequenceAlloc;
+	int	m_DEBUG_NumSequenceFreed;
+	int m_DEBUG_NumSequenceResidual;
+
+#endif
+
+};
+
+#endif	//__INSTANCE__
diff --git a/codemp/icarus/interface.h b/codemp/icarus/interface.h
new file mode 100644
index 0000000..645d935
--- /dev/null
+++ b/codemp/icarus/interface.h
@@ -0,0 +1,72 @@
+// ICARUS Interface header file
+
+#ifndef __INTERFACE__
+#define __INTERFACE__
+
+//#include "../server/server.h"
+//#include "../game/g_public.h"
+
+typedef unsigned long       DWORD;
+
+typedef	float	vec_t;
+typedef	vec_t	vec3_t[3];
+
+class CSequencer;
+class CTaskManager;
+
+typedef struct interface_export_s
+{
+	//General
+	int				(*I_LoadFile)( const char *name, void **buf );
+	void			(*I_CenterPrint)( const char *format, ... );
+	void			(*I_DPrintf)( int, const char *, ... );
+	sharedEntity_t *(*I_GetEntityByName)( const char *name );		//Polls the engine for the sequencer of the entity matching the name passed
+	DWORD			(*I_GetTime)( void );							//Gets the current time
+	DWORD			(*I_GetTimeScale)(void );
+	int 			(*I_PlaySound)( int taskID, int entID, const char *name, const char *channel );	
+	void			(*I_Lerp2Pos)( int taskID, int entID, vec3_t origin, vec3_t angles, float duration );
+	void			(*I_Lerp2Origin)( int taskID, int entID, vec3_t origin, float duration );
+	void			(*I_Lerp2Angles)( int taskID, int entID, vec3_t angles, float duration );
+	int				(*I_GetTag)( int entID, const char *name, int lookup, vec3_t info );
+	void			(*I_Lerp2Start)( int taskID, int entID, float duration );
+	void			(*I_Lerp2End)( int taskID, int entID, float duration );
+	void			(*I_Set)( int taskID, int entID, const char *type_name, const char *data );
+	void			(*I_Use)( int entID, const char *name );
+	void			(*I_Kill)( int entID, const char *name );
+	void			(*I_Remove)( int entID, const char *name );
+	float			(*I_Random)( float min, float max );
+	void			(*I_Play)( int taskID, int entID, const char *type, const char *name );
+
+	//Camera functions
+	void			(*I_CameraPan)( vec3_t angles, vec3_t dir, float duration );
+	void			(*I_CameraMove)( vec3_t origin, float duration );
+	void			(*I_CameraZoom)( float fov, float duration );
+	void			(*I_CameraRoll)( float angle, float duration );
+	void			(*I_CameraFollow)( const char *name, float speed, float initLerp );
+	void			(*I_CameraTrack)( const char *name, float speed, float initLerp );
+	void			(*I_CameraDistance)( float dist, float initLerp );
+	void			(*I_CameraFade)( float sr, float sg, float sb, float sa, float dr, float dg, float db, float da, float duration );
+	void			(*I_CameraPath)( const char *name );
+	void			(*I_CameraEnable)( void );
+	void			(*I_CameraDisable)( void );
+	void			(*I_CameraShake)( float intensity, int duration );
+
+	int				(*I_GetFloat)( int entID, int type, const char *name, float *value );
+	int				(*I_GetVector)( int entID, int type, const char *name, vec3_t value );
+	int				(*I_GetString)( int entID, int type, const char *name, char **value );
+
+	int				(*I_Evaluate)( int p1Type, const char *p1, int p2Type, const char *p2, int operatorType );
+
+	void			(*I_DeclareVariable)( int type, const char *name );
+	void			(*I_FreeVariable)( const char *name );
+
+	//Save / Load functions
+
+	int				(*I_WriteSaveData)( unsigned long chid, void *data, int length );
+	// Below changed by BTO (VV). Visual C++ 7.1 compiler no longer allows default args on function pointers. Ack.
+	int				(*I_ReadSaveData)( unsigned long chid, void *address, int length /* , void **addressptr = NULL */ );
+	int				(*I_LinkEntity)( int entID, CSequencer *sequencer, CTaskManager *taskManager );
+
+} interface_export_t;
+
+#endif	//__INTERFACE__
\ No newline at end of file
diff --git a/codemp/icarus/interpreter.h b/codemp/icarus/interpreter.h
new file mode 100644
index 0000000..913dbca
--- /dev/null
+++ b/codemp/icarus/interpreter.h
@@ -0,0 +1,224 @@
+// Interpreter.h
+
+#ifndef __INTERPRETER__
+#define __INTERPRETER__
+
+#define ICARUS_VERSION	1.33
+
+#define MAX_STRING_SIZE	256
+#define	MAX_VAR_NAME	64
+
+typedef float	vector_t[3];
+
+//If you modify this, you MUST modify in g_ICARUScb.c as well.
+//Token defines
+enum 
+{
+	TK_BLOCK_START = TK_USERDEF,
+	TK_BLOCK_END,
+	TK_VECTOR_START,
+	TK_VECTOR_END,
+	TK_OPEN_PARENTHESIS,
+	TK_CLOSED_PARENTHESIS,
+	TK_VECTOR,
+	TK_GREATER_THAN,
+	TK_LESS_THAN,
+	TK_EQUALS,
+	TK_NOT,
+
+	NUM_USER_TOKENS
+};
+
+//ID defines
+enum
+{
+	ID_AFFECT = NUM_USER_TOKENS,
+	ID_SOUND,
+	ID_MOVE,
+	ID_ROTATE,
+	ID_WAIT,
+	ID_BLOCK_START,
+	ID_BLOCK_END,
+	ID_SET,
+	ID_LOOP,
+	ID_LOOPEND,
+	ID_PRINT,
+	ID_USE,
+	ID_FLUSH,
+	ID_RUN,
+	ID_KILL,
+	ID_REMOVE,
+	ID_CAMERA,
+	ID_GET,
+	ID_RANDOM,
+	ID_IF,
+	ID_ELSE,
+	ID_REM,
+	ID_TASK,
+	ID_DO,
+	ID_DECLARE,
+	ID_FREE,
+	ID_DOWAIT,
+	ID_SIGNAL,
+	ID_WAITSIGNAL,
+	ID_PLAY,
+
+	ID_TAG,
+	ID_EOF,
+	NUM_IDS
+};
+
+//Type defines
+enum
+{
+	//Wait types
+	TYPE_WAIT_COMPLETE	 = NUM_IDS,
+	TYPE_WAIT_TRIGGERED,
+
+	//Set types
+	TYPE_ANGLES,
+	TYPE_ORIGIN,
+
+	//Affect types
+	TYPE_INSERT,	
+	TYPE_FLUSH,	
+	
+	//Camera types
+	TYPE_PAN,
+	TYPE_ZOOM,
+	TYPE_MOVE,
+	TYPE_FADE,
+	TYPE_PATH,
+	TYPE_ENABLE,
+	TYPE_DISABLE,
+	TYPE_SHAKE,
+	TYPE_ROLL,
+	TYPE_TRACK,
+	TYPE_DISTANCE,
+	TYPE_FOLLOW,
+		
+	//Variable type
+	TYPE_VARIABLE,
+
+	TYPE_EOF,
+	NUM_TYPES
+};
+
+enum
+{
+	MSG_COMPLETED,
+	MSG_EOF,
+	NUM_MESSAGES,
+};
+
+#ifdef __cplusplus
+typedef struct variable_s
+{
+	char	name[MAX_VAR_NAME];
+	int		type;
+	void	*data;
+} variable_t;
+
+typedef map< string, variable_t * >	variable_m;
+typedef vector < variable_t * > variable_v;
+
+//CInterpreter
+
+class CInterpreter 
+{
+public:
+
+	CInterpreter();
+	~CInterpreter();
+
+	int Interpret( CTokenizer *, CBlockStream *, char *filename=NULL );	//Main interpretation function
+	
+	int Match( int );		//Looks ahead to the next token to try and match it to the passed token, consumes token on success
+	int LookAhead( int );	//Looks ahead without consuming on success
+
+	int FindSymbol( const char *,  keywordArray_t * );		//Searches the symbol table for the given name.  Returns the ID if found
+
+	int GetAffect( void );		//Handles the affect() function
+	int GetWait( void );		//Handles the wait() function
+	int GetSet( void );			//Handles the set() function
+	int GetBroadcast( void );	//Handles the broadcast() function
+	int GetLoop( void );		//Handles the loop() function
+	int GetPrint( void );		//Handles the print() function
+	int GetUse( void );			//Handles the use() function
+	int GetFlush( void );		//Handles the flush() function
+	int	GetRun( void );			//Handles the run() function
+	int	GetKill( void );		//Handles the kill() function
+	int	GetRemove( void );		//Handles the remove() function	
+	int GetCamera( void );		//Handles the camera() function
+	int GetIf( void );			//Handles the if() conditional statement
+	int GetSound( void );		//Handles the sound() function
+	int GetMove( void );		//Handles the move() function
+	int GetRotate( void );		//Handles the rotate() function
+	int GetRem( void );			//Handles the rem() function
+	int	GetTask( void );
+	int GetDo( void );
+	int GetElse( void );
+	int GetDeclare( void );
+	int GetFree( void );
+	int GetDoWait( void );
+	int GetSignal( void );
+	int GetWaitSignal( void );
+	int GetPlay( void );
+	
+	int GetRandom( CBlock *block );
+	int GetGet( CBlock *block );		//Heh
+	int	GetTag( CBlock *block );		//Handles the tag() identifier
+	int GetVector( CBlock *block );
+
+	int GetNextType( void );
+
+	int GetType( char *get );
+
+	int GetAny( CBlock *block );
+	int GetEvaluator( CBlock *block );
+	int GetString( CBlock *);			//Attempts to match and retrieve the value of a string token
+	int	GetIdentifier( CBlock *get );	//Attempts to match and retrieve the value of an identifier token
+	int	GetInteger( CBlock * );		//Attempts to match and retrieve the value of a int token
+	int GetFloat( CBlock * );		//Attempts to match and retrieve the value of a float token
+	int GetVariable( int type );
+
+	int GetID ( char * );	//Attempts to match and interpret an identifier
+	
+	keywordArray_t *GetSymbols( void )	{	return (keywordArray_t *) &m_symbolKeywords;	}	//Returns the interpreter's symbol table
+	keywordArray_t *GetIDs( void )		{	return (keywordArray_t *) &m_IDKeywords;		}	//Returns the interpreter's ID table
+	keywordArray_t *GetTypes( void )	{	return (keywordArray_t *) &m_typeKeywords;	}		//Returns the interpreter's type table
+
+protected:
+
+	void InitVars( void );
+	void FreeVars( void );
+	
+	variable_t *AddVar( const char *name, int type );
+	variable_t *FindVar( const char *name );
+
+	const char *GetTokenName( int );	//Returns the name of a token
+	int Error( char *, ... );			//Prints an error message
+	
+	int MatchTag( void );				//Attempts to match to a tag identifier
+	int MatchGet( void );				//Attempts to match to a get identifier
+	int	MatchRandom( void );			//Attempts to match to a random identifier
+
+	CTokenizer	*m_tokenizer;			//Pointer to the tokenizer
+	CBlockStream *m_blockStream;		//Pointer to the block stream
+
+	variable_v	m_vars;
+	variable_m	m_varMap;
+
+	string	m_sCurrentLine;				// used in IBIze error reporting for more clarity
+	string	m_sCurrentFile;				// full-pathed name of .TXT file (needed because of above, which affects parsestreams)
+	int		m_iCurrentLine;				// also needed now because of 'm_sCurrentLine'
+	int		m_iBadCBlockNumber;			// used for final app return code (NZ = err)
+
+	static keywordArray_t	m_symbolKeywords[];		//Symbols
+	static keywordArray_t	m_IDKeywords[];			//Identifiers
+	static keywordArray_t	m_typeKeywords[];			//Types
+	static keywordArray_t	m_conditionalKeywords[];	//Conditional
+};
+
+#endif __cplusplus
+#endif	//__INTERPRETER__
diff --git a/codemp/icarus/module.h b/codemp/icarus/module.h
new file mode 100644
index 0000000..6ae5319
--- /dev/null
+++ b/codemp/icarus/module.h
@@ -0,0 +1 @@
+//This needs to be present to make the tokenizer happy...
\ No newline at end of file
diff --git a/codemp/icarus/sequence.h b/codemp/icarus/sequence.h
new file mode 100644
index 0000000..0c137fa
--- /dev/null
+++ b/codemp/icarus/sequence.h
@@ -0,0 +1,98 @@
+// Sequence Header File
+
+#ifndef __SEQUENCE__
+#define __SEQUENCE__
+
+#include "blockstream.h"
+#include "interface.h"
+#include "taskmanager.h"
+
+class ICARUS_Instance;
+
+class CSequence
+{
+
+	typedef list < CSequence * >	sequence_l;
+	typedef	map	< int, CSequence *> sequenceID_m;
+	typedef list < CBlock * >		block_l;
+
+public:
+
+	//Constructors / Destructors
+	CSequence( void );
+	~CSequence( void );
+
+	//Creation and deletion
+	static CSequence *Create( void );
+	void Delete( void );
+
+	//Organization functions
+	void AddChild( CSequence * );
+	void RemoveChild( CSequence * );
+
+	void SetParent( CSequence * );
+	CSequence *GetParent( void )	const	{	return m_parent;	}
+
+	//Block manipulation
+	CBlock *PopCommand( int );
+	int PushCommand( CBlock *, int );
+
+	//Flag utilties
+	void SetFlag( int );
+	void RemoveFlag( int, bool = false );
+	int  HasFlag( int );
+	int	 GetFlags( void )		const	{	return m_flags;		}
+	void SetFlags( int flags )	{	m_flags = flags;	}
+
+	//Various encapsulation utilities
+	int GetIterations( void )		const	{	return m_iterations;	}
+	void SetIterations( int it )	{	m_iterations = it;		}
+
+	int GetID( void )		const	{	return m_id;			}
+	void SetID( int id )	{	m_id = id;				}
+
+	CSequence *GetReturn( void )	const	{	return m_return;		}
+
+	void SetReturn ( CSequence *sequence );
+
+	int GetNumCommands( void )	const	{	return m_numCommands;	}
+	int GetNumChildren( void )	const	{	return m_children.size();	}
+
+	CSequence *GetChildByIndex( int id );
+	bool HasChild( CSequence *sequence );
+
+	void SetOwner( ICARUS_Instance *owner )	{	m_owner = owner;	}
+
+	int Save( void );
+	int Load( void );
+
+	inline void *operator new( size_t size )
+	{	// Allocate the memory.
+		return Z_Malloc( size, TAG_ICARUS3, qtrue );
+	}
+	// Overloaded delete operator.
+	inline void operator delete( void *pRawData )
+	{	// Free the Memory.
+		Z_Free( pRawData );
+	}
+
+protected:
+
+	int SaveCommand( CBlock *block );
+
+	ICARUS_Instance			*m_owner;
+
+	//Organization information
+	sequence_l				m_children;
+	CSequence				*m_parent;
+	CSequence				*m_return;
+
+	//Data information
+	block_l					m_commands;
+	int						m_flags;
+	int						m_iterations;
+	int						m_id;
+	int						m_numCommands;
+};
+
+#endif	//__SEQUENCE__
\ No newline at end of file
diff --git a/codemp/icarus/sequencer.h b/codemp/icarus/sequencer.h
new file mode 100644
index 0000000..0730a9b
--- /dev/null
+++ b/codemp/icarus/sequencer.h
@@ -0,0 +1,189 @@
+// Sequencer Header File
+
+#ifndef __SEQUENCER__
+#define __SEQUENCER__
+
+#include "blockstream.h"
+#include "interface.h"
+#include "taskmanager.h"
+#include "sequence.h"
+
+#pragma warning(disable : 4786)	//identifier was truncated 
+
+#pragma warning (push, 3)	//go back down to 3 for the stl include
+#pragma warning (disable:4503)	// decorated name length xceeded, name was truncated
+#include <list>
+#include <vector>
+#include <map>
+#include <algorithm>
+#pragma warning (pop)
+#pragma warning (disable:4503)	// decorated name length xceeded, name was truncated
+using namespace std;
+
+//Defines
+
+#define SQ_COMMON		0x00000000 	//Common one-pass sequence
+#define	SQ_LOOP			0x00000001 	//Looping sequence
+#define SQ_RETAIN		0x00000002 	//Inside a looping sequence list, retain the information
+#define SQ_AFFECT		0x00000004 	//Affect sequence 
+#define SQ_RUN			0x00000008	//A run block
+#define SQ_PENDING		0x00000010	//Pending use, don't free when flushing the sequences
+#define SQ_CONDITIONAL	0x00000020	//Conditional statement
+#define SQ_TASK			0x00000040	//Task block
+
+#define	BF_ELSE			0x00000001	//Block has an else id	//FIXME: This was a sloppy fix for a problem that arose from conditionals
+
+#define S_FAILED(a) (a!=SEQ_OK)
+
+//const int MAX_ERROR_LENGTH	= 256;
+
+//Typedefs
+
+typedef struct bstream_s
+{
+	CBlockStream *stream;
+	bstream_s	 *last;
+} bstream_t;
+
+//Enumerations
+
+enum
+{
+	SEQ_OK,				//Command was successfully added
+	SEQ_FAILED,			//An error occured while trying to insert the command
+};
+
+// Sequencer
+
+class ICARUS_Instance;
+
+/*
+==================================================================================================
+
+  CSequencer
+
+==================================================================================================
+*/
+
+class CSequencer
+{
+//	typedef	map < int, CSequence * >			sequenceID_m;
+	typedef list < CSequence * >				sequence_l;
+	typedef map < CTaskGroup *, CSequence * >	taskSequence_m;
+
+public:
+
+	CSequencer();
+	~CSequencer();
+
+	int Init( int ownerID, interface_export_t *ie, CTaskManager *taskManager, ICARUS_Instance *iCARUS );
+	static CSequencer *Create ( void );
+	int Free( void );
+
+	int Run( char *buffer, long size );
+	int Callback( CTaskManager *taskManager, CBlock *block, int returnCode );
+
+	ICARUS_Instance	*GetOwner( void )	{	return m_owner;	}
+
+	void SetOwnerID( int owner )	{	m_ownerID = owner;}
+
+	int	GetOwnerID( void )						const	{	return m_ownerID;	}
+	interface_export_t *GetInterface( void )	const	{	return m_ie;			}
+	CTaskManager *GetTaskManager( void )		const	{	return m_taskManager;	}
+
+	void SetTaskManager( CTaskManager *tm)	{	if ( tm )	m_taskManager = tm;	}
+
+	int Save( void );
+	int Load( void );
+
+	// Overloaded new operator.
+	inline void *operator new( size_t size )
+	{	// Allocate the memory.
+		return Z_Malloc( size, TAG_ICARUS2, qtrue );
+	}
+	// Overloaded delete operator.
+	inline void operator delete( void *pRawData )
+	{	// Free the Memory.
+		Z_Free( pRawData );
+	}
+
+// moved to public on 2/12/2 to allow calling during shutdown
+	int Recall( void );
+protected:
+
+	int EvaluateConditional( CBlock *block );
+
+	int Route( CSequence *sequence, bstream_t *bstream );
+	int Flush( CSequence *owner );
+	void Interrupt( void );
+
+	bstream_t *AddStream( void );
+	void DeleteStream( bstream_t *bstream );
+
+	int AddAffect( bstream_t *bstream, int retain, int *id );
+
+	CSequence *AddSequence( void );
+	CSequence *AddSequence( CSequence *parent, CSequence *returnSeq, int flags );
+
+	CSequence *GetSequence( int id );
+
+	//NOTENOTE: This only removes references to the sequence, IT DOES NOT FREE THE ALLOCATED MEMORY!
+	int RemoveSequence( CSequence *sequence);
+	int DestroySequence( CSequence *sequence);
+
+	int PushCommand( CBlock *command, int flag );
+	CBlock *PopCommand( int flag );
+
+	inline CSequence *ReturnSequence( CSequence *sequence );
+
+	void CheckRun( CBlock ** );
+	void CheckLoop( CBlock ** );
+	void CheckAffect( CBlock ** );
+	void CheckIf( CBlock ** );
+	void CheckDo( CBlock ** );
+	void CheckFlush( CBlock ** );
+
+	void Prep( CBlock ** );
+
+	int Prime( CTaskManager *taskManager, CBlock *command );
+
+	void StripExtension( const char *in, char *out );
+
+	int ParseRun( CBlock *block );
+	int ParseLoop( CBlock *block, bstream_t *bstream );
+	int ParseAffect( CBlock *block, bstream_t *bstream );
+	int ParseIf( CBlock *block, bstream_t *bstream );
+	int ParseElse( CBlock *block, bstream_t *bstream );
+	int ParseTask( CBlock *block, bstream_t *bstream );
+
+	int Affect( int id, int type );
+
+	void AddTaskSequence( CSequence *sequence, CTaskGroup *group );
+	CSequence *GetTaskSequence( CTaskGroup *group );
+
+	//Member variables
+	
+	ICARUS_Instance		*m_owner;
+	int					m_ownerID;
+
+	CTaskManager		*m_taskManager;
+	interface_export_t	*m_ie;				//This is unique to the sequencer so that client side and server side sequencers could both
+											//operate under different interfaces (for client side scripting)
+
+	int					m_numCommands;		//Total number of commands for the sequencer (including all child sequences)
+
+//	sequenceID_m		m_sequenceMap;
+	sequence_l			m_sequences;
+	taskSequence_m		m_taskSequences;
+
+	CSequence			*m_curSequence;
+	CTaskGroup			*m_curGroup;
+
+	bstream_t			*m_curStream;
+
+	int					m_elseValid;
+	CBlock				*m_elseOwner;
+	vector<bstream_t*>  m_streamsCreated;
+};
+
+#endif	//__SEQUENCER__
\ No newline at end of file
diff --git a/codemp/icarus/taskmanager.h b/codemp/icarus/taskmanager.h
new file mode 100644
index 0000000..3dbe6ff
--- /dev/null
+++ b/codemp/icarus/taskmanager.h
@@ -0,0 +1,191 @@
+// Task Manager header file
+
+#ifndef __TASK_MANAGER__
+#define __TASK_MANAGER__
+
+#include <map>
+
+#include "sequencer.h"
+class CSequencer;
+
+#define MAX_TASK_NAME	64
+
+#define TASKFLAG_NORMAL	0x00000000
+
+const int RUNAWAY_LIMIT	= 256;
+
+enum
+{
+	TASK_RETURN_COMPLETE,
+	TASK_RETURN_FAILED,
+};
+
+enum 
+{
+	TASK_OK,
+	TASK_FAILED,
+	TASK_START,
+	TASK_END,
+};
+	
+// CTask
+
+class CTask
+{
+public:
+
+	CTask();
+	~CTask();
+
+	static CTask *Create( int GUID, CBlock *block );
+
+	void	Free( void );
+
+	DWORD	GetTimeStamp( void )	const	{	return m_timeStamp;				}
+	CBlock	*GetBlock( void )		const	{	return m_block;					}
+	int		GetGUID( void)			const	{	return m_id;					}
+	int		GetID( void )			const	{	return m_block->GetBlockID();	}
+
+	void	SetTimeStamp( DWORD	timeStamp )		{	m_timeStamp = timeStamp;	}
+	void	SetBlock( CBlock *block )			{	m_block = block;			}
+	void	SetGUID( int id )					{	m_id = id;					}
+
+protected:
+
+	int		m_id;
+	DWORD	m_timeStamp;
+	CBlock	*m_block;
+};
+
+// CTaskGroup
+
+class CTaskGroup
+{
+public:
+
+	typedef map < int, bool > taskCallback_m;
+
+	CTaskGroup( void );
+	~CTaskGroup( void );
+
+	void Init( void );
+
+	int Add( CTask *task );
+	
+	void SetGUID( int GUID );
+	void SetParent( CTaskGroup *group )	{	m_parent = group;	}
+
+	bool Complete(void)		const { return ( m_numCompleted == m_completedTasks.size() ); }
+
+	bool MarkTaskComplete( int id );
+
+	CTaskGroup *GetParent( void )	const	{	return m_parent;	}
+	int	GetGUID( void )				const	{	return m_GUID;		}
+
+//protected:
+
+	taskCallback_m	m_completedTasks;
+
+	CTaskGroup	*m_parent;
+
+	int		m_numCompleted;
+	int		m_GUID;
+};
+
+// CTaskManager
+
+class CTaskManager
+{
+
+	typedef	map < int, CTask * >			taskID_m;
+	typedef map < string, CTaskGroup * >	taskGroupName_m;
+	typedef map < int, CTaskGroup * >		taskGroupID_m;
+	typedef vector < CTaskGroup * >			taskGroup_v;
+	typedef list < CTask *>					tasks_l;
+
+public:
+
+	CTaskManager();
+	~CTaskManager();
+
+	static CTaskManager *Create( void );
+
+	CBlock *GetCurrentTask( void );
+
+	int Init( CSequencer *owner );
+	int	Free( void );
+
+	int	Flush( void );
+
+	int	SetCommand( CBlock *block, int type );
+	int Completed( int id );
+
+	int Update( void );
+	qboolean IsRunning( void );
+
+	CTaskGroup *AddTaskGroup( const char *name );
+	CTaskGroup *GetTaskGroup( const char *name );
+	CTaskGroup *GetTaskGroup( int id );
+
+	int MarkTask( int id, int operation );
+	CBlock *RecallTask( void );
+
+	void Save( void );
+	void Load( void );
+
+protected:
+
+	int	Go( void );	//Heartbeat function called once per game frame
+	int CallbackCommand( CTask *task, int returnCode );
+
+	inline bool Check( int targetID, CBlock *block, int memberNum );
+
+	int GetVector( int entID, CBlock *block, int &memberNum, vector_t &value );
+	int GetFloat( int entID, CBlock *block, int &memberNum, float &value );
+	int Get( int entID, CBlock *block, int &memberNum, char **value );
+
+	int	PushTask( CTask *task, int flag );
+	CTask *PopTask( int flag );
+
+	// Task functions
+	int Rotate( CTask *task );
+	int Remove( CTask *task );
+	int Camera( CTask *task );
+	int Print( CTask *task );
+	int Sound( CTask *task );
+	int Move( CTask *task );
+	int Kill( CTask *task );
+	int Set( CTask *task );
+	int Use( CTask *task );
+	int DeclareVariable( CTask *task );
+	int FreeVariable( CTask *task );
+	int Signal( CTask *task );
+	int Play( CTask *task );
+
+	int Wait( CTask *task, bool &completed );
+	int WaitSignal( CTask *task, bool &completed );
+
+	int	SaveCommand( CBlock *block );
+
+	// Variables
+
+	CSequencer				*m_owner;
+	int						m_ownerID;
+
+	CTaskGroup				*m_curGroup;
+
+	taskGroup_v				m_taskGroups;
+	tasks_l					m_tasks;
+
+	int						m_GUID;
+	int						m_count;
+	
+	taskGroupName_m			m_taskGroupNameMap;
+	taskGroupID_m			m_taskGroupIDMap;
+
+	bool					m_resident;
+
+	//CTask	*m_waitTask;		//Global pointer to the current task that is waiting for callback completion
+};
+
+#endif	//__TASK_MANAGER__
diff --git a/codemp/icarus/tokenizer.h b/codemp/icarus/tokenizer.h
new file mode 100644
index 0000000..8a7f68b
--- /dev/null
+++ b/codemp/icarus/tokenizer.h
@@ -0,0 +1,601 @@
+// Tokenizer.h
+//
+
+#ifndef __TOKENIZER_H
+#define __TOKENIZER_H
+
+#pragma warning( disable : 4786 )	// identifier was truncated 
+
+#pragma warning (push, 3)			// go back down to 3 for the stl include
+#pragma warning (disable:4503)		// decorated name length xceeded, name was truncated
+#include <string>
+#include <vector>
+#include <map>
+#pragma warning (pop)
+#pragma warning (disable:4503)		// decorated name length xceeded, name was truncated
+
+using namespace std;
+
+//#include <windows.h>
+#include "../qcommon/platform.h"
+
+typedef unsigned char byte;
+typedef unsigned short word;
+
+#define MAX_STRING_LENGTH		256
+#define MAX_IDENTIFIER_LENGTH	128
+
+#define TKF_IGNOREDIRECTIVES			0x00000001		// skip over lines starting with #
+#define TKF_USES_EOL					0x00000002		// generate end of line tokens
+#define TKF_NODIRECTIVES				0x00000004		// don't treat # in any special way
+#define TKF_WANTUNDEFINED				0x00000008		// if token not found in symbols create undefined token
+#define TKF_WIDEUNDEFINEDSYMBOLS		0x00000010		// when undefined token encountered, accumulate until space
+#define TKF_RAWSYMBOLSONLY				0x00000020
+#define TKF_NUMERICIDENTIFIERSTART		0x00000040
+#define TKF_IGNOREKEYWORDS				0x00000080
+#define TKF_NOCASEKEYWORDS				0x00000100
+#define TKF_NOUNDERSCOREINIDENTIFIER	0x00000200
+#define TKF_NODASHINIDENTIFIER			0x00000400
+#define TKF_COMMENTTOKENS				0x00000800
+
+enum
+{
+	TKERR_NONE,
+	TKERR_UNKNOWN,
+	TKERR_BUFFERCREATE,
+	TKERR_UNRECOGNIZEDSYMBOL,
+	TKERR_DUPLICATESYMBOL,
+	TKERR_STRINGLENGTHEXCEEDED,
+	TKERR_IDENTIFIERLENGTHEXCEEDED,
+	TKERR_EXPECTED_INTEGER,
+	TKERR_EXPECTED_IDENTIFIER,
+	TKERR_EXPECTED_STRING,
+	TKERR_EXPECTED_CHAR,
+	TKERR_EXPECTED_FLOAT,
+	TKERR_UNEXPECTED_TOKEN,
+	TKERR_INVALID_DIRECTIVE,
+	TKERR_INCLUDE_FILE_NOTFOUND,
+	TKERR_UNMATCHED_DIRECTIVE,
+	TKERR_USERERROR,
+};
+
+enum
+{
+	TK_EOF = -1,
+	TK_UNDEFINED,
+	TK_COMMENT,
+	TK_EOL,
+	TK_CHAR,
+	TK_STRING,
+	TK_INT,
+	TK_INTEGER = TK_INT,
+	TK_FLOAT,
+	TK_IDENTIFIER,
+	TK_USERDEF,
+};
+
+typedef struct
+{
+	char*		m_keyword;
+	int			m_tokenvalue;
+} keywordArray_t;
+
+class lessstr
+{
+public:
+	bool operator()(LPCTSTR str1, LPCTSTR str2) const {return (strcmp(str1, str2) < 0);};
+};
+
+class CParseStream
+{
+public:
+	CParseStream();
+	~CParseStream();
+	static CParseStream* Create();
+	virtual void Delete();
+	virtual bool NextChar(byte& theByte);
+	virtual int GetCurLine();
+	virtual void GetCurFilename(char** theBuff);
+	virtual long GetRemainingSize();
+
+	CParseStream* GetNext();
+	void SetNext(CParseStream* next);
+
+	virtual bool IsThisDefinition(void* theDefinition);
+
+protected:
+	virtual bool Init();
+
+	CParseStream*		m_next;
+};
+
+class CToken
+{
+public:
+	CToken();
+	~CToken();
+	static CToken* Create();
+	virtual void Delete();
+
+	virtual int GetType();
+	CToken* GetNext();
+	void SetNext(CToken* theToken);
+	virtual int GetIntValue();
+	virtual LPCTSTR GetStringValue();
+	virtual float GetFloatValue();
+
+protected:
+	virtual void Init();
+
+	char*			m_string;
+	CToken*			m_next;
+};
+
+class CCharToken : public CToken
+{
+public:
+	CCharToken();
+	~CCharToken();
+	static CCharToken* Create(byte theByte);
+	virtual void Delete();
+
+	virtual int GetType();
+
+protected:
+	virtual void Init(byte theByte);
+};
+
+class CStringToken : public CToken
+{
+public:
+	CStringToken();
+	~CStringToken();
+	static CStringToken* Create(LPCTSTR theString);
+	virtual void Delete();
+
+	virtual int GetType();
+
+protected:
+	virtual void Init(LPCTSTR theString);
+};
+
+class CIntToken : public CToken
+{
+public:
+	CIntToken();
+	~CIntToken();
+	static CIntToken* Create(long value);
+	virtual void Delete();
+
+	virtual int GetType();
+	virtual float GetFloatValue();
+	virtual int GetIntValue();
+	virtual LPCTSTR GetStringValue();
+
+protected:
+	virtual void Init(long value);
+	
+	long			m_value;
+};
+
+class CFloatToken : public CToken
+{
+public:
+	CFloatToken();
+	~CFloatToken();
+	static CFloatToken* Create(float value);
+	virtual void Delete();
+
+	virtual int GetType();
+	virtual float GetFloatValue();
+	virtual LPCTSTR GetStringValue();
+
+protected:
+	virtual void Init(float value);
+
+	float			m_value;
+};
+
+class CIdentifierToken : public CToken
+{
+public:
+	CIdentifierToken();
+	~CIdentifierToken();
+	static CIdentifierToken* Create(LPCTSTR name);
+	virtual void Delete();
+
+	virtual int GetType();
+
+protected:
+	virtual void Init(LPCTSTR name);
+};
+
+class CCommentToken : public CToken
+{
+public:
+	CCommentToken();
+	~CCommentToken();
+	static CCommentToken* Create(LPCTSTR name);
+	virtual void Delete();
+
+	virtual int GetType();
+
+protected:
+	virtual void Init(LPCTSTR name);
+};
+
+class CUserToken : public CToken
+{
+public:
+	CUserToken();
+	~CUserToken();
+	static CUserToken* Create(int value, LPCTSTR string);
+	virtual void Delete();
+
+	virtual int GetType();
+
+protected:
+	virtual void Init(int value, LPCTSTR string);
+
+	int				m_value;
+};
+
+class CUndefinedToken : public CToken
+{
+public:
+	CUndefinedToken();
+	~CUndefinedToken();
+	static CUndefinedToken* Create(LPCTSTR string);
+	virtual void Delete();
+
+	virtual int GetType();
+
+protected:
+	virtual void Init(LPCTSTR string);
+};
+
+class CSymbol
+{
+public:
+	CSymbol();
+	virtual ~CSymbol();
+	static CSymbol* Create(LPCTSTR symbolName);
+	virtual void Delete();
+
+	LPCTSTR GetName();
+
+protected:
+	virtual void Init(LPCTSTR symbolName);
+
+	char*			m_symbolName;
+};
+
+typedef map<LPCTSTR, CSymbol*, lessstr> symbolmap_t;
+
+class CDirectiveSymbol : public CSymbol
+{
+public:
+	CDirectiveSymbol();
+	~CDirectiveSymbol();
+	static CDirectiveSymbol* Create(LPCTSTR symbolName);
+	virtual void Delete();
+
+	void SetValue(LPCTSTR value);
+	LPCTSTR GetValue();
+
+protected:
+	virtual void Init(LPCTSTR symbolName);
+
+	char*			m_value;
+};
+
+class CIntSymbol : public CSymbol
+{
+public:
+	CIntSymbol();
+	static CIntSymbol* Create(LPCTSTR symbolName, int value);
+	virtual void Delete();
+
+	int GetValue();
+
+protected:
+	virtual void Init(LPCTSTR symbolName, int value);
+
+	int				m_value;
+};
+
+class CSymbolTable
+{
+public:
+	CSymbolTable();
+	~CSymbolTable();
+	static CSymbolTable* Create();
+	void Delete();
+
+	bool AddSymbol(CSymbol* theSymbol);
+	CSymbol* FindSymbol(LPCTSTR symbolName);
+	CSymbol* ExtractSymbol(LPCTSTR symbolName);
+	void RemoveSymbol(LPCTSTR symbolName);
+	void DiscardSymbols();
+
+protected:
+	void Init();
+	symbolmap_t			m_symbols;
+};
+
+class CSymbolLookup
+{
+public:
+	CSymbolLookup();
+	~CSymbolLookup();
+	static CSymbolLookup* Create(byte theByte);
+	virtual void Delete();
+	CSymbolLookup* GetNext();
+	void SetNext(CSymbolLookup* next);
+	void SetParent(CSymbolLookup* parent);
+	CSymbolLookup* GetParent();
+	void SetValue(int value);
+	int GetValue();
+	byte GetByte();
+
+protected:
+	void Init(byte theByte);
+
+	CSymbolLookup*		m_child;
+	CSymbolLookup*		m_sibling;
+	CSymbolLookup*		m_parent;
+	int					m_value;
+	byte				m_byte;
+};
+
+class CTokenizerState
+{
+public:
+	CTokenizerState();
+	~CTokenizerState();
+	static CTokenizerState* Create(bool skip);
+	virtual void Delete();
+	CTokenizerState* GetNext();
+	void SetNext(CTokenizerState* next);
+	virtual bool ProcessElse();
+	bool Skipping();
+
+protected:
+	void Init(bool skip);
+
+	bool				m_skip;
+	bool				m_elseHit;
+	CTokenizerState*	m_next;
+};
+
+class CTokenizerHolderState : public CTokenizerState
+{
+public:
+	CTokenizerHolderState();
+	~CTokenizerHolderState();
+	static CTokenizerHolderState* Create();
+	virtual void Delete();
+	virtual bool ProcessElse();
+
+protected:
+	void Init();
+};
+
+typedef void (*LPTokenizerErrorProc)(LPCTSTR errString);
+
+#ifdef USES_MODULES
+class CTokenizer : public CModule
+#else
+class CTokenizer
+#endif
+{
+public:
+	CTokenizer();
+	~CTokenizer();
+	static CTokenizer* Create(UINT dwFlags = 0);
+	virtual void Delete();
+	virtual void Error(int theError);
+	virtual void Error(int theError, LPCTSTR errString);
+	virtual void Error(LPCTSTR errString, int theError = TKERR_UNKNOWN);
+
+	CToken* GetToken(UINT onFlags = 0, UINT offFlags = 0);
+	CToken* GetToken(keywordArray_t* keywords, UINT onFlags, UINT offFlags);
+	void PutBackToken(CToken* theToken, bool commented = false, LPCTSTR addedChars = NULL, bool bIgnoreThisTokenType = false);
+	bool RequireToken(int tokenType);
+	void ScanUntilToken(int tokenType);
+	void SkipToLineEnd();
+	CToken* GetToEndOfLine(int tokenType = TK_IDENTIFIER);
+
+	keywordArray_t* SetKeywords(keywordArray_t* theKeywords);
+	void SetSymbols(keywordArray_t* theSymbols);
+	void SetAdditionalErrors(keywordArray_t* theErrors);
+	void SetErrorProc(LPTokenizerErrorProc errorProc);
+	void AddParseStream(byte* data, long datasize);
+	bool AddParseFile(LPCTSTR filename);
+	COLORREF ParseRGB();
+	long GetRemainingSize();
+
+	UINT GetFlags();
+	void SetFlags(UINT flags);
+
+	void GetCurFilename(char** filename);
+	int GetCurLine();
+
+	LPCTSTR LookupToken(int tokenID, keywordArray_t* theTable = NULL);
+
+protected:
+	void SetError(int theError, LPCTSTR errString); 
+	virtual void Init(UINT dwFlags = 0);
+	CToken* FetchToken();
+	bool AddDefineSymbol(CDirectiveSymbol* definesymbol);
+	bool NextChar(byte& theByte);
+	byte Escapement();
+	void InsertSymbol(LPCTSTR theSymbol, int theValue);
+	void PutBackChar(byte theByte, int curLine = 0, LPCTSTR filename = NULL);
+	CToken* TokenFromName(LPCTSTR name);
+	CToken* HandleDirective();
+	CToken* HandleSlash();
+	CToken* HandleString();
+	CToken* HandleQuote();
+	CToken* HandleIdentifier(byte theByte);
+	CToken* HandleNumeric(byte theByte);
+	CToken* HandleFloat(bool thesign = false, long value = 0);
+	CToken* HandleDecimal(bool thesign = false);
+	CToken* HandleSymbol(byte theByte);
+	CToken* HandleHex(bool thesize);
+	CToken* HandleOctal(bool thesize);
+	int DirectiveFromName(LPCTSTR name);
+
+	CParseStream*			m_curParseStream;
+	keywordArray_t*			m_keywords;
+	keywordArray_t*			m_symbols;
+	keywordArray_t*			m_errors;
+	CSymbolLookup*			m_symbolLookup;
+	CToken*					m_nextToken;
+	CSymbolTable			m_defines;
+	CTokenizerState*		m_state;
+	UINT					m_flags;
+	LPTokenizerErrorProc	m_errorProc;
+
+	static keywordArray_t errorMessages[];
+	static keywordArray_t directiveKeywords[];
+};
+
+class CKeywordTable
+{
+public:
+	CKeywordTable(CTokenizer* tokenizer, keywordArray_t* keywords);
+	~CKeywordTable();
+
+protected:
+	CTokenizer*			m_tokenizer;
+	keywordArray_t*		m_holdKeywords;
+};
+
+class CParsePutBack : public CParseStream
+{
+public:
+	CParsePutBack();
+	~CParsePutBack();
+	static CParsePutBack* Create(byte theByte, int curLine, LPCTSTR filename);
+	virtual void Delete();
+	virtual bool NextChar(byte& theByte);
+	virtual int GetCurLine();
+	virtual void GetCurFilename(char** theBuff);
+	virtual long GetRemainingSize();
+
+protected:
+	virtual void Init(byte theByte, int curLine, LPCTSTR filename);
+
+	byte			m_byte;
+	bool			m_consumed;
+	int				m_curLine;
+	char*			m_curFile;
+};
+
+class CParseMemory : public CParseStream
+{
+public:
+	CParseMemory();
+	~CParseMemory();
+	static CParseMemory* Create(byte* data, long datasize);
+	virtual void Delete();
+	virtual bool NextChar(byte& theByte);
+	virtual int GetCurLine();
+	virtual void GetCurFilename(char** theBuff);
+	virtual long GetRemainingSize();
+
+protected:
+	virtual void Init(byte* data, long datasize);
+
+	byte*			m_data;
+	int				m_curLine;
+	long			m_curPos;
+	long			m_datasize;
+	long			m_offset;
+};
+
+class CParseBlock : public CParseMemory
+{
+public:
+	CParseBlock();
+	~CParseBlock();
+	static CParseBlock* Create(byte* data, long datasize);
+	virtual void Delete();
+
+protected:
+	virtual void Init(byte* data, long datasize);
+};
+
+class CParseToken : public CParseStream
+{
+public:
+	CParseToken();
+	~CParseToken();
+	static CParseToken* Create(CToken* token);
+	virtual void Delete();
+	virtual bool NextChar(byte& theByte);
+	virtual int GetCurLine();
+	virtual void GetCurFilename(char** theBuff);
+	virtual long GetRemainingSize();
+
+protected:
+	virtual void Init(CToken* token);
+
+	byte*			m_data;
+	int				m_curLine;
+	long			m_curPos;
+	long			m_datasize;
+	long			m_offset;
+};
+
+class CParseDefine : public CParseMemory
+{
+public:
+	CParseDefine();
+	~CParseDefine();
+	static CParseDefine* Create(CDirectiveSymbol* definesymbol);
+	virtual void Delete();
+	virtual bool IsThisDefinition(void* theDefinition);
+
+protected:
+	virtual void Init(CDirectiveSymbol* definesymbol);
+
+	CDirectiveSymbol*			m_defineSymbol;
+};
+
+class CParseFile : public CParseStream
+{
+public:
+	CParseFile();
+	~CParseFile();
+	static CParseFile* Create();
+	static CParseFile* Create(LPCTSTR filename, CTokenizer* tokenizer);
+//	static CParseFile* Create(CFile* file, CTokenizer* tokenizer);
+	virtual void Delete();
+	virtual int GetCurLine();
+	virtual void GetCurFilename(char** theBuff);
+	virtual long GetRemainingSize();
+
+	virtual bool NextChar(byte& theByte);
+
+protected:
+	virtual bool Init();
+	virtual bool Init(LPCTSTR filename, CTokenizer* tokenizer);
+//	virtual void Init(CFile* file, CTokenizer* tokenizer);
+	DWORD GetFileSize();
+	void Read(void* buff, UINT buffsize);
+
+//	CFile*			m_file;
+	HANDLE			m_fileHandle;
+	char*			m_fileName;
+	int				m_curLine;
+	int				m_curPos;
+	byte*			m_buff;
+	DWORD			m_curByte;
+	DWORD			m_filesize;
+	bool			m_ownsFile;
+};
+
+
+#endif//__TOKENIZER_H
\ No newline at end of file
diff --git a/codemp/icarus/vssver.scc b/codemp/icarus/vssver.scc
new file mode 100644
index 0000000..ee3406d
Binary files /dev/null and b/codemp/icarus/vssver.scc differ
diff --git a/codemp/install.bat b/codemp/install.bat
new file mode 100644
index 0000000..95d1eb1
--- /dev/null
+++ b/codemp/install.bat
@@ -0,0 +1 @@
+tonet.bat
\ No newline at end of file
diff --git a/codemp/installvms.bat b/codemp/installvms.bat
new file mode 100644
index 0000000..43c7700
--- /dev/null
+++ b/codemp/installvms.bat
@@ -0,0 +1,4 @@
+xcopy/d/y release\jk2mp.exe w:\game
+xcopy/d/y base\vm\cgame.* w:\game\base\vm
+xcopy/d/y base\vm\jk2mpgame.* w:\game\base\vm
+xcopy/d/y base\vm\ui.* w:\game\base\vm
diff --git a/codemp/jk2mp.vcproj b/codemp/jk2mp.vcproj
new file mode 100644
index 0000000..a6c9608
--- /dev/null
+++ b/codemp/jk2mp.vcproj
@@ -0,0 +1,6986 @@
+<?xml version="1.0" encoding = "Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="7.00"
+	Name="exe"
+	SccProjectName="&quot;$/jedi/codemp&quot;, CAAAAAAA"
+	SccAuxPath=""
+	SccLocalPath="."
+	SccProvider="MSSCCI:Microsoft Visual SourceSafe">
+	<Platforms>
+		<Platform
+			Name="Win32"/>
+	</Platforms>
+	<Configurations>
+		<Configuration
+			Name="Final|Win32"
+			OutputDirectory=".\Final"
+			IntermediateDirectory=".\Final\jk2"
+			ConfigurationType="1"
+			UseOfMFC="0"
+			ATLMinimizesCRunTimeLibraryUsage="FALSE"
+			WholeProgramOptimization="TRUE">
+			<Tool
+				Name="VCCLCompilerTool"
+				GlobalOptimizations="TRUE"
+				InlineFunctionExpansion="2"
+				EnableIntrinsicFunctions="TRUE"
+				ImproveFloatingPointConsistency="TRUE"
+				FavorSizeOrSpeed="1"
+				OptimizeForProcessor="2"
+				OptimizeForWindowsApplication="TRUE"
+				PreprocessorDefinitions="_WIN32,NDEBUG,_WINDOWS,WIN32,_JK2,FINAL_BUILD,_JK2MP"
+				StringPooling="TRUE"
+				BufferSecurityCheck="FALSE"
+				EnableFunctionLevelLinking="FALSE"
+				UsePrecompiledHeader="0"
+				PrecompiledHeaderThrough=""
+				PrecompiledHeaderFile=".\Final\jk2/jk2mp.pch"
+				AssemblerListingLocation=".\Final\jk2/"
+				ObjectFile=".\Final\jk2/"
+				ProgramDataBaseFileName=".\Final\jk2/"
+				WarningLevel="4"
+				SuppressStartupBanner="TRUE"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalOptions="/MACHINE:I386"
+				AdditionalDependencies="ALut.lib OpenAL32.lib winmm.lib wsock32.lib"
+				OutputFile=".\Final/jamp.exe"
+				LinkIncremental="1"
+				SuppressStartupBanner="TRUE"
+				GenerateMapFile="TRUE"
+				MapFileName="Final/jamp.map"
+				MapLines="TRUE"
+				SubSystem="2"
+				StackReserveSize="8388608"
+				OptimizeReferences="2"
+				EnableCOMDATFolding="2"
+				SetChecksum="TRUE"/>
+			<Tool
+				Name="VCMIDLTool"
+				PreprocessorDefinitions="NDebug"
+				MkTypLibCompatible="TRUE"
+				SuppressStartupBanner="TRUE"
+				TargetEnvironment="1"
+				TypeLibraryName=".\Final/jk2mp.tlb"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="VCResourceCompilerTool"
+				PreprocessorDefinitions="NDebug"
+				Culture="1033"/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"/>
+			<Tool
+				Name="VCWebDeploymentTool"/>
+		</Configuration>
+		<Configuration
+			Name="Debug|Win32"
+			OutputDirectory=".\Debug"
+			IntermediateDirectory=".\Debug\jk2"
+			ConfigurationType="1"
+			UseOfMFC="0"
+			ATLMinimizesCRunTimeLibraryUsage="FALSE">
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				OptimizeForProcessor="2"
+				OptimizeForWindowsApplication="TRUE"
+				PreprocessorDefinitions="_DEBUG,WIN32,_WINDOWS,_JK2,_JK2MP"
+				MinimalRebuild="TRUE"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="5"
+				BufferSecurityCheck="FALSE"
+				EnableFunctionLevelLinking="TRUE"
+				UsePrecompiledHeader="0"
+				PrecompiledHeaderThrough=""
+				PrecompiledHeaderFile=".\Debug\jk2/jk2mp.pch"
+				AssemblerListingLocation=".\Debug\jk2/"
+				ObjectFile=".\Debug\jk2/"
+				ProgramDataBaseFileName=".\Debug\jk2/"
+				BrowseInformation="1"
+				WarningLevel="3"
+				SuppressStartupBanner="TRUE"
+				DebugInformationFormat="4"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalOptions="/MACHINE:I386"
+				AdditionalDependencies="ALut.lib OpenAL32.lib winmm.lib wsock32.lib"
+				OutputFile=".\Debug/jamp.exe"
+				LinkIncremental="2"
+				SuppressStartupBanner="TRUE"
+				GenerateDebugInformation="TRUE"
+				ProgramDatabaseFile=".\Debug/jamp.pdb"
+				GenerateMapFile="TRUE"
+				MapFileName="Debug/jamp.map"
+				SubSystem="2"
+				StackReserveSize="8388608"/>
+			<Tool
+				Name="VCMIDLTool"
+				PreprocessorDefinitions="_Debug"
+				MkTypLibCompatible="TRUE"
+				SuppressStartupBanner="TRUE"
+				TargetEnvironment="1"
+				TypeLibraryName=".\Debug/jk2mp.tlb"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="VCResourceCompilerTool"
+				PreprocessorDefinitions="_Debug"
+				Culture="1033"
+				ResourceOutputFileName="win32\winquake.res"/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"/>
+			<Tool
+				Name="VCWebDeploymentTool"/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			OutputDirectory=".\Release"
+			IntermediateDirectory=".\Release\jk2"
+			ConfigurationType="1"
+			UseOfMFC="0"
+			ATLMinimizesCRunTimeLibraryUsage="FALSE">
+			<Tool
+				Name="VCCLCompilerTool"
+				GlobalOptimizations="TRUE"
+				InlineFunctionExpansion="2"
+				EnableIntrinsicFunctions="TRUE"
+				ImproveFloatingPointConsistency="TRUE"
+				FavorSizeOrSpeed="1"
+				OptimizeForProcessor="2"
+				OptimizeForWindowsApplication="TRUE"
+				PreprocessorDefinitions="_WIN32,NDEBUG,WIN32,_WINDOWS,_JK2,_JK2MP"
+				StringPooling="TRUE"
+				MinimalRebuild="TRUE"
+				BufferSecurityCheck="FALSE"
+				EnableFunctionLevelLinking="TRUE"
+				UsePrecompiledHeader="0"
+				PrecompiledHeaderThrough=""
+				PrecompiledHeaderFile=".\Release\jk2/jk2mp.pch"
+				AssemblerListingLocation=".\Release\jk2/"
+				ObjectFile=".\Release\jk2/"
+				ProgramDataBaseFileName=".\Release\jk2/"
+				WarningLevel="4"
+				SuppressStartupBanner="TRUE"
+				DebugInformationFormat="3"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalOptions="/MACHINE:I386"
+				AdditionalDependencies="ALut.lib OpenAL32.lib winmm.lib wsock32.lib"
+				OutputFile=".\Release/jamp.exe"
+				LinkIncremental="1"
+				SuppressStartupBanner="TRUE"
+				GenerateDebugInformation="TRUE"
+				ProgramDatabaseFile=".\Release/jamp.pdb"
+				GenerateMapFile="TRUE"
+				MapFileName="Release/jamp.map"
+				SubSystem="2"
+				StackReserveSize="8388608"
+				OptimizeReferences="2"
+				EnableCOMDATFolding="2"
+				SetChecksum="TRUE"/>
+			<Tool
+				Name="VCMIDLTool"
+				PreprocessorDefinitions="NDebug"
+				MkTypLibCompatible="TRUE"
+				SuppressStartupBanner="TRUE"
+				TargetEnvironment="1"
+				TypeLibraryName=".\Release/jk2mp.tlb"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="VCResourceCompilerTool"
+				PreprocessorDefinitions="NDebug"
+				Culture="1033"/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"/>
+			<Tool
+				Name="VCWebDeploymentTool"/>
+		</Configuration>
+		<Configuration
+			Name="Debug(SH)|Win32"
+			OutputDirectory="Debug(SH)"
+			IntermediateDirectory="Debug(SH)"
+			ConfigurationType="1"
+			UseOfMFC="0"
+			ATLMinimizesCRunTimeLibraryUsage="FALSE">
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				OptimizeForProcessor="2"
+				OptimizeForWindowsApplication="TRUE"
+				PreprocessorDefinitions="_DEBUG,WIN32,_WINDOWS,_JK2,MEM_DEBUG,_JK2MP"
+				MinimalRebuild="TRUE"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="5"
+				BufferSecurityCheck="FALSE"
+				EnableFunctionLevelLinking="TRUE"
+				UsePrecompiledHeader="0"
+				PrecompiledHeaderFile=".\Debug\jk2/jk2mp.pch"
+				AssemblerListingLocation=".\Debug\jk2/"
+				ObjectFile=".\Debug\jk2/"
+				ProgramDataBaseFileName=".\Debug\jk2/"
+				BrowseInformation="1"
+				WarningLevel="3"
+				SuppressStartupBanner="TRUE"
+				DebugInformationFormat="4"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalOptions="/MACHINE:I386"
+				AdditionalDependencies="./debug/jk2/smrtheap.obj ALut.lib OpenAL32.lib winmm.lib wsock32.lib"
+				OutputFile=".\Debug/jamp.exe"
+				LinkIncremental="2"
+				SuppressStartupBanner="TRUE"
+				GenerateDebugInformation="TRUE"
+				ProgramDatabaseFile=".\Debug/jamp.pdb"
+				GenerateMapFile="TRUE"
+				MapFileName="Debug/jamp.map"
+				SubSystem="2"
+				StackReserveSize="8388608"/>
+			<Tool
+				Name="VCMIDLTool"
+				PreprocessorDefinitions="_Debug"
+				MkTypLibCompatible="TRUE"
+				SuppressStartupBanner="TRUE"
+				TargetEnvironment="1"
+				TypeLibraryName=".\Debug/jk2mp.tlb"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="VCResourceCompilerTool"
+				PreprocessorDefinitions="_Debug"
+				Culture="1033"
+				ResourceOutputFileName="win32\winquake.res"/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"/>
+			<Tool
+				Name="VCWebDeploymentTool"/>
+		</Configuration>
+	</Configurations>
+	<Files>
+		<Filter
+			Name="Header Files"
+			Filter="h;hpp;hxx;hm;inl;fi;fd">
+			<File
+				RelativePath=".\game\anims.h">
+			</File>
+			<File
+				RelativePath=".\game\bg_weapons.h">
+			</File>
+			<File
+				RelativePath=".\game\botlib.h">
+			</File>
+			<File
+				RelativePath=".\qcommon\disablewarnings.h">
+			</File>
+			<File
+				RelativePath="qcommon\platform.h">
+			</File>
+			<File
+				RelativePath=".\win32\resource.h">
+			</File>
+			<File
+				RelativePath=".\ui\ui_public.h">
+			</File>
+		</Filter>
+		<Filter
+			Name="Resource Files"
+			Filter="ico;cur;bmp;dlg;rc2;rct;bin;cnt;rtf;gif;jpg;jpeg;jpe">
+			<File
+				RelativePath=".\ALut.lib">
+			</File>
+			<File
+				RelativePath=".\EaxMan.dll">
+			</File>
+			<File
+				RelativePath=".\OpenAL32.dll">
+			</File>
+			<File
+				RelativePath=".\OpenAL32.lib">
+			</File>
+			<File
+				RelativePath=".\win32\qe3.ico">
+			</File>
+			<File
+				RelativePath=".\win32\winquake.rc">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCResourceCompilerTool"
+						AdditionalIncludeDirectories="win32;$(NoInherit)"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCResourceCompilerTool"
+						AdditionalIncludeDirectories="win32;$(NoInherit)"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCResourceCompilerTool"
+						AdditionalIncludeDirectories="win32;$(NoInherit)"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCResourceCompilerTool"
+						AdditionalIncludeDirectories="win32;$(NoInherit)"/>
+				</FileConfiguration>
+			</File>
+		</Filter>
+		<Filter
+			Name="Client"
+			Filter="">
+			<File
+				RelativePath=".\client\0_SH_Leak.cpp">
+				<FileConfiguration
+					Name="Final|Win32"
+					ExcludedFromBuild="TRUE">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32"
+					ExcludedFromBuild="TRUE">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32"
+					ExcludedFromBuild="TRUE">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\client\FXExport.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\client\FXExport.h">
+			</File>
+			<File
+				RelativePath=".\client\FxPrimitives.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\client\FxPrimitives.h">
+			</File>
+			<File
+				RelativePath=".\client\FxScheduler.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\client\FxScheduler.h">
+			</File>
+			<File
+				RelativePath=".\client\FxSystem.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\client\FxSystem.h">
+			</File>
+			<File
+				RelativePath=".\client\FxTemplate.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\client\FxUtil.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\client\FxUtil.h">
+			</File>
+			<File
+				RelativePath=".\client\cl_cgame.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\client\cl_cin.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\client\cl_console.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\client\cl_input.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\client\cl_keys.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\client\cl_main.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\client\cl_net_chan.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\client\cl_parse.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\client\cl_scrn.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\client\cl_ui.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\client\client.h">
+			</File>
+		</Filter>
+		<Filter
+			Name="Common"
+			Filter="">
+			<File
+				RelativePath=".\qcommon\CNetProfile.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\qcommon\GenericParser2.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\qcommon\GenericParser2.h">
+			</File>
+			<File
+				RelativePath=".\qcommon\INetProfile.h">
+			</File>
+			<File
+				RelativePath=".\qcommon\MiniHeap.h">
+			</File>
+			<File
+				RelativePath=".\qcommon\RoffSystem.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\qcommon\RoffSystem.h">
+			</File>
+			<File
+				RelativePath=".\game\bg_public.h">
+			</File>
+			<File
+				RelativePath=".\cgame\cg_public.h">
+			</File>
+			<File
+				RelativePath=".\qcommon\chash.h">
+			</File>
+			<File
+				RelativePath=".\qcommon\cm_draw.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\qcommon\cm_draw.h">
+			</File>
+			<File
+				RelativePath=".\qcommon\cm_landscape.h">
+			</File>
+			<File
+				RelativePath=".\qcommon\cm_load.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\qcommon\cm_local.h">
+			</File>
+			<File
+				RelativePath=".\qcommon\cm_patch.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\qcommon\cm_patch.h">
+			</File>
+			<File
+				RelativePath=".\qcommon\cm_polylib.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\qcommon\cm_polylib.h">
+			</File>
+			<File
+				RelativePath=".\qcommon\cm_public.h">
+			</File>
+			<File
+				RelativePath=".\qcommon\cm_randomterrain.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\qcommon\cm_randomterrain.h">
+			</File>
+			<File
+				RelativePath=".\qcommon\cm_shader.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\qcommon\cm_terrain.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\qcommon\cm_terrainmap.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\qcommon\cm_terrainmap.h">
+			</File>
+			<File
+				RelativePath=".\qcommon\cm_test.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\qcommon\cm_trace.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="qcommon\cmd_common.cpp">
+			</File>
+			<File
+				RelativePath="qcommon\cmd_pc.cpp">
+			</File>
+			<File
+				RelativePath=".\qcommon\common.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\qcommon\cvar.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="qcommon\exe_headers.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="1"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="1"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="1"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="1"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="qcommon\exe_headers.h">
+			</File>
+			<File
+				RelativePath="qcommon\files.h">
+			</File>
+			<File
+				RelativePath="qcommon\files_common.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="qcommon\files_pc.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\game\g_public.h">
+			</File>
+			<File
+				RelativePath=".\qcommon\game_version.h">
+			</File>
+			<File
+				RelativePath=".\qcommon\hstring.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\qcommon\hstring.h">
+			</File>
+			<File
+				RelativePath=".\qcommon\huffman.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\ui\keycodes.h">
+			</File>
+			<File
+				RelativePath=".\client\keys.h">
+			</File>
+			<File
+				RelativePath=".\qcommon\md4.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\qcommon\msg.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\qcommon\net_chan.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\game\q_math.c">
+				<FileConfiguration
+					Name="Final|Win32"
+					ExcludedFromBuild="TRUE">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32"
+					ExcludedFromBuild="TRUE">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32"
+					ExcludedFromBuild="TRUE">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32"
+					ExcludedFromBuild="TRUE">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\qcommon\q_math.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\game\q_shared.c">
+				<FileConfiguration
+					Name="Final|Win32"
+					ExcludedFromBuild="TRUE">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32"
+					ExcludedFromBuild="TRUE">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32"
+					ExcludedFromBuild="TRUE">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32"
+					ExcludedFromBuild="TRUE">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\qcommon\q_shared.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\game\q_shared.h">
+			</File>
+			<File
+				RelativePath=".\qcommon\qcommon.h">
+			</File>
+			<File
+				RelativePath=".\qcommon\qfiles.h">
+			</File>
+			<File
+				RelativePath=".\renderer\qgl.h">
+			</File>
+			<File
+				RelativePath=".\qcommon\sstring.h">
+			</File>
+			<File
+				RelativePath=".\qcommon\stringed_ingame.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\qcommon\stringed_ingame.h">
+			</File>
+			<File
+				RelativePath=".\qcommon\stringed_interface.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\qcommon\stringed_interface.h">
+			</File>
+			<File
+				RelativePath=".\game\surfaceflags.h">
+			</File>
+			<File
+				RelativePath=".\qcommon\tags.h">
+			</File>
+			<File
+				RelativePath=".\qcommon\timing.h">
+			</File>
+			<File
+				RelativePath=".\qcommon\unzip.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\qcommon\unzip.h">
+			</File>
+			<File
+				RelativePath=".\qcommon\vm.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\qcommon\vm_interpreted.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\qcommon\vm_local.h">
+			</File>
+			<File
+				RelativePath=".\qcommon\vm_x86.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="qcommon\z_memman_pc.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+		</Filter>
+		<Filter
+			Name="Win32"
+			Filter="">
+			<File
+				RelativePath="win32\AutoVersion.h">
+			</File>
+			<File
+				RelativePath=".\win32\glw_win.h">
+			</File>
+			<File
+				RelativePath=".\win32\win_input.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\win32\win_local.h">
+			</File>
+			<File
+				RelativePath=".\win32\win_main.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\win32\win_net.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\win32\win_shared.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\win32\win_snd.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\win32\win_syscon.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\win32\win_wndproc.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+		</Filter>
+		<Filter
+			Name="Server"
+			Filter="">
+			<File
+				RelativePath=".\server\server.h">
+			</File>
+			<File
+				RelativePath=".\server\sv_bot.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\server\sv_ccmds.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\server\sv_client.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\server\sv_game.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\server\sv_init.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\server\sv_main.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\server\sv_net_chan.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\server\sv_snapshot.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\server\sv_world.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<Filter
+				Name="NPCNav"
+				Filter="">
+				<File
+					RelativePath=".\server\NPCNav\gameCallbacks.cpp">
+					<FileConfiguration
+						Name="Final|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"
+							PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="Debug|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"
+							PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="Release|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"
+							PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="Debug(SH)|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"
+							PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+					</FileConfiguration>
+				</File>
+				<File
+					RelativePath=".\server\NPCNav\navigator.cpp">
+					<FileConfiguration
+						Name="Final|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"
+							PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="Debug|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"
+							PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="Release|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"
+							PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="Debug(SH)|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"
+							PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+					</FileConfiguration>
+				</File>
+				<File
+					RelativePath=".\server\NPCNav\navigator.h">
+				</File>
+			</Filter>
+		</Filter>
+		<Filter
+			Name="Sound"
+			Filter="">
+			<File
+				RelativePath=".\client\snd_ambient.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\client\snd_ambient.h">
+			</File>
+			<File
+				RelativePath=".\client\snd_dma.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\client\snd_local.h">
+			</File>
+			<File
+				RelativePath=".\client\snd_mem.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\client\snd_mix.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="client\snd_mp3.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="client\snd_mp3.h">
+			</File>
+			<File
+				RelativePath=".\client\snd_music.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\client\snd_music.h">
+			</File>
+			<File
+				RelativePath=".\client\snd_public.h">
+			</File>
+			<Filter
+				Name="MP3"
+				Filter="">
+				<File
+					RelativePath=".\mp3code\cdct.c">
+					<FileConfiguration
+						Name="Final|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="Debug|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="Release|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="Debug(SH)|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"/>
+					</FileConfiguration>
+				</File>
+				<File
+					RelativePath=".\mp3code\csbt.c">
+					<FileConfiguration
+						Name="Final|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="Debug|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="Release|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="Debug(SH)|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"/>
+					</FileConfiguration>
+				</File>
+				<File
+					RelativePath=".\mp3code\csbtb.c">
+					<FileConfiguration
+						Name="Final|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="Debug|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="Release|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="Debug(SH)|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"/>
+					</FileConfiguration>
+				</File>
+				<File
+					RelativePath=".\mp3code\csbtl3.c">
+					<FileConfiguration
+						Name="Final|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="Debug|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="Release|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="Debug(SH)|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"/>
+					</FileConfiguration>
+				</File>
+				<File
+					RelativePath=".\mp3code\cup.c">
+					<FileConfiguration
+						Name="Final|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="Debug|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="Release|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="Debug(SH)|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"/>
+					</FileConfiguration>
+				</File>
+				<File
+					RelativePath=".\mp3code\cupini.c">
+					<FileConfiguration
+						Name="Final|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="Debug|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="Release|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="Debug(SH)|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"/>
+					</FileConfiguration>
+				</File>
+				<File
+					RelativePath=".\mp3code\cupl1.c">
+					<FileConfiguration
+						Name="Final|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="Debug|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="Release|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="Debug(SH)|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"/>
+					</FileConfiguration>
+				</File>
+				<File
+					RelativePath=".\mp3code\cupl3.c">
+					<FileConfiguration
+						Name="Final|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="Debug|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="Release|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="Debug(SH)|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"/>
+					</FileConfiguration>
+				</File>
+				<File
+					RelativePath=".\mp3code\cwin.c">
+					<FileConfiguration
+						Name="Final|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="Debug|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="Release|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="Debug(SH)|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"/>
+					</FileConfiguration>
+				</File>
+				<File
+					RelativePath=".\mp3code\cwinb.c">
+					<FileConfiguration
+						Name="Final|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="Debug|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="Release|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="Debug(SH)|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"/>
+					</FileConfiguration>
+				</File>
+				<File
+					RelativePath=".\mp3code\cwinm.c">
+					<FileConfiguration
+						Name="Final|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="Debug|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="Release|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="Debug(SH)|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"/>
+					</FileConfiguration>
+				</File>
+				<File
+					RelativePath=".\mp3code\hwin.c">
+					<FileConfiguration
+						Name="Final|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="Debug|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="Release|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="Debug(SH)|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"/>
+					</FileConfiguration>
+				</File>
+				<File
+					RelativePath=".\mp3code\l3dq.c">
+					<FileConfiguration
+						Name="Final|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="Debug|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="Release|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="Debug(SH)|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"/>
+					</FileConfiguration>
+				</File>
+				<File
+					RelativePath=".\mp3code\l3init.c">
+					<FileConfiguration
+						Name="Final|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="Debug|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="Release|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="Debug(SH)|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"/>
+					</FileConfiguration>
+				</File>
+				<File
+					RelativePath=".\mp3code\mdct.c">
+					<FileConfiguration
+						Name="Final|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="Debug|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="Release|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="Debug(SH)|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"/>
+					</FileConfiguration>
+				</File>
+				<File
+					RelativePath=".\mp3code\mhead.c">
+					<FileConfiguration
+						Name="Final|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="Debug|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="Release|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="Debug(SH)|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"/>
+					</FileConfiguration>
+				</File>
+				<File
+					RelativePath=".\mp3code\msis.c">
+					<FileConfiguration
+						Name="Final|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="Debug|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="Release|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="Debug(SH)|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"/>
+					</FileConfiguration>
+				</File>
+				<File
+					RelativePath=".\mp3code\towave.c">
+					<FileConfiguration
+						Name="Final|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="Debug|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="Release|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="Debug(SH)|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"/>
+					</FileConfiguration>
+				</File>
+				<File
+					RelativePath=".\mp3code\uph.c">
+					<FileConfiguration
+						Name="Final|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="Debug|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="Release|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="Debug(SH)|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"/>
+					</FileConfiguration>
+				</File>
+				<File
+					RelativePath=".\mp3code\upsf.c">
+					<FileConfiguration
+						Name="Final|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="Debug|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="Release|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="Debug(SH)|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"/>
+					</FileConfiguration>
+				</File>
+				<File
+					RelativePath=".\mp3code\wavep.c">
+					<FileConfiguration
+						Name="Final|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="Debug|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="Release|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="Debug(SH)|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"/>
+					</FileConfiguration>
+				</File>
+				<Filter
+					Name="MP3 Headers"
+					Filter="">
+					<File
+						RelativePath=".\mp3code\config.h">
+					</File>
+					<File
+						RelativePath=".\mp3code\copyright.h">
+					</File>
+					<File
+						RelativePath=".\mp3code\htable.h">
+					</File>
+					<File
+						RelativePath=".\mp3code\jdw.h">
+					</File>
+					<File
+						RelativePath=".\mp3code\l3.h">
+					</File>
+					<File
+						RelativePath=".\mp3code\mhead.h">
+					</File>
+					<File
+						RelativePath=".\mp3code\mp3struct.h">
+					</File>
+					<File
+						RelativePath=".\mp3code\port.h">
+					</File>
+					<File
+						RelativePath=".\mp3code\small_header.h">
+					</File>
+					<File
+						RelativePath=".\mp3code\tableawd.h">
+					</File>
+				</Filter>
+			</Filter>
+			<Filter
+				Name="EAX"
+				Filter="">
+				<File
+					RelativePath=".\client\eax\EaxMan.h">
+				</File>
+				<File
+					RelativePath=".\client\eax\eax.h">
+				</File>
+			</Filter>
+			<Filter
+				Name="OpenAL"
+				Filter="">
+				<File
+					RelativePath=".\client\OpenAL\al.h">
+				</File>
+				<File
+					RelativePath=".\client\OpenAL\alc.h">
+				</File>
+				<File
+					RelativePath=".\client\OpenAL\alctypes.h">
+				</File>
+				<File
+					RelativePath=".\client\OpenAL\altypes.h">
+				</File>
+				<File
+					RelativePath=".\client\OpenAL\alu.h">
+				</File>
+				<File
+					RelativePath=".\client\OpenAL\alut.h">
+				</File>
+			</Filter>
+		</Filter>
+		<Filter
+			Name="Renderer"
+			Filter="">
+			<File
+				RelativePath=".\renderer\glext.h">
+			</File>
+			<File
+				RelativePath=".\renderer\matcomp.c">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\renderer\matcomp.h">
+			</File>
+			<File
+				RelativePath=".\renderer\tr_WorldEffects.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\renderer\tr_WorldEffects.h">
+			</File>
+			<File
+				RelativePath=".\renderer\tr_animation.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\renderer\tr_arioche.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\renderer\tr_backend.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\renderer\tr_bsp.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\renderer\tr_cmds.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\renderer\tr_curve.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\renderer\tr_font.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\renderer\tr_font.h">
+			</File>
+			<File
+				RelativePath=".\renderer\tr_ghoul2.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\renderer\tr_image.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\renderer\tr_init.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\renderer\tr_landscape.h">
+			</File>
+			<File
+				RelativePath=".\renderer\tr_light.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\renderer\tr_local.h">
+			</File>
+			<File
+				RelativePath=".\renderer\tr_main.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\renderer\tr_marks.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\renderer\tr_mesh.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\renderer\tr_model.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\renderer\tr_noise.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\renderer\tr_public.h">
+			</File>
+			<File
+				RelativePath=".\renderer\tr_quicksprite.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\renderer\tr_quicksprite.h">
+			</File>
+			<File
+				RelativePath=".\renderer\tr_scene.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\renderer\tr_shade.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\renderer\tr_shade_calc.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\renderer\tr_shader.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\renderer\tr_shadows.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\renderer\tr_sky.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\renderer\tr_surface.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\renderer\tr_surfacesprites.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\renderer\tr_terrain.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\cgame\tr_types.h">
+			</File>
+			<File
+				RelativePath=".\renderer\tr_world.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\win32\win_gamma.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\win32\win_glimp.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\win32\win_qgl.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<Filter
+				Name="jpeg files"
+				Filter="">
+				<Filter
+					Name="JPG Source"
+					Filter="">
+					<File
+						RelativePath=".\jpeg-6\jcapimin.cpp">
+						<FileConfiguration
+							Name="Final|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Debug|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Release|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Debug(SH)|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+					</File>
+					<File
+						RelativePath=".\jpeg-6\jccoefct.cpp">
+						<FileConfiguration
+							Name="Final|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Debug|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Release|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Debug(SH)|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+					</File>
+					<File
+						RelativePath=".\jpeg-6\jccolor.cpp">
+						<FileConfiguration
+							Name="Final|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Debug|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Release|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Debug(SH)|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+					</File>
+					<File
+						RelativePath=".\jpeg-6\jcdctmgr.cpp">
+						<FileConfiguration
+							Name="Final|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Debug|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Release|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Debug(SH)|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+					</File>
+					<File
+						RelativePath=".\jpeg-6\jchuff.cpp">
+						<FileConfiguration
+							Name="Final|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Debug|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Release|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Debug(SH)|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+					</File>
+					<File
+						RelativePath=".\jpeg-6\jcinit.cpp">
+						<FileConfiguration
+							Name="Final|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Debug|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Release|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Debug(SH)|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+					</File>
+					<File
+						RelativePath=".\jpeg-6\jcmainct.cpp">
+						<FileConfiguration
+							Name="Final|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Debug|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Release|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Debug(SH)|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+					</File>
+					<File
+						RelativePath=".\jpeg-6\jcmarker.cpp">
+						<FileConfiguration
+							Name="Final|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Debug|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Release|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Debug(SH)|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+					</File>
+					<File
+						RelativePath=".\jpeg-6\jcmaster.cpp">
+						<FileConfiguration
+							Name="Final|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Debug|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Release|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Debug(SH)|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+					</File>
+					<File
+						RelativePath=".\jpeg-6\jcomapi.cpp">
+						<FileConfiguration
+							Name="Final|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Debug|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Release|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Debug(SH)|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+					</File>
+					<File
+						RelativePath=".\jpeg-6\jcparam.cpp">
+						<FileConfiguration
+							Name="Final|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Debug|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Release|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Debug(SH)|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+					</File>
+					<File
+						RelativePath=".\jpeg-6\jcphuff.cpp">
+						<FileConfiguration
+							Name="Final|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Debug|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Release|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Debug(SH)|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+					</File>
+					<File
+						RelativePath=".\jpeg-6\jcprepct.cpp">
+						<FileConfiguration
+							Name="Final|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Debug|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Release|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Debug(SH)|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+					</File>
+					<File
+						RelativePath=".\jpeg-6\jcsample.cpp">
+						<FileConfiguration
+							Name="Final|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Debug|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Release|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Debug(SH)|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+					</File>
+					<File
+						RelativePath=".\jpeg-6\jctrans.cpp">
+						<FileConfiguration
+							Name="Final|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Debug|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Release|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Debug(SH)|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+					</File>
+					<File
+						RelativePath=".\jpeg-6\jdapimin.cpp">
+						<FileConfiguration
+							Name="Final|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Debug|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Release|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Debug(SH)|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+					</File>
+					<File
+						RelativePath=".\jpeg-6\jdapistd.cpp">
+						<FileConfiguration
+							Name="Final|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Debug|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Release|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Debug(SH)|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+					</File>
+					<File
+						RelativePath=".\jpeg-6\jdatadst.cpp">
+						<FileConfiguration
+							Name="Final|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Debug|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Release|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Debug(SH)|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+					</File>
+					<File
+						RelativePath=".\jpeg-6\jdatasrc.cpp">
+						<FileConfiguration
+							Name="Final|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Debug|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Release|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Debug(SH)|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+					</File>
+					<File
+						RelativePath=".\jpeg-6\jdcoefct.cpp">
+						<FileConfiguration
+							Name="Final|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Debug|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Release|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Debug(SH)|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+					</File>
+					<File
+						RelativePath=".\jpeg-6\jdcolor.cpp">
+						<FileConfiguration
+							Name="Final|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Debug|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Release|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Debug(SH)|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+					</File>
+					<File
+						RelativePath=".\jpeg-6\jddctmgr.cpp">
+						<FileConfiguration
+							Name="Final|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Debug|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Release|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Debug(SH)|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+					</File>
+					<File
+						RelativePath=".\jpeg-6\jdhuff.cpp">
+						<FileConfiguration
+							Name="Final|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Debug|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Release|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Debug(SH)|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+					</File>
+					<File
+						RelativePath=".\jpeg-6\jdinput.cpp">
+						<FileConfiguration
+							Name="Final|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Debug|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Release|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Debug(SH)|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+					</File>
+					<File
+						RelativePath=".\jpeg-6\jdmainct.cpp">
+						<FileConfiguration
+							Name="Final|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Debug|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Release|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Debug(SH)|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+					</File>
+					<File
+						RelativePath=".\jpeg-6\jdmarker.cpp">
+						<FileConfiguration
+							Name="Final|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Debug|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Release|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Debug(SH)|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+					</File>
+					<File
+						RelativePath=".\jpeg-6\jdmaster.cpp">
+						<FileConfiguration
+							Name="Final|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Debug|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Release|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Debug(SH)|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+					</File>
+					<File
+						RelativePath=".\jpeg-6\jdpostct.cpp">
+						<FileConfiguration
+							Name="Final|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Debug|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Release|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Debug(SH)|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+					</File>
+					<File
+						RelativePath=".\jpeg-6\jdsample.cpp">
+						<FileConfiguration
+							Name="Final|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Debug|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Release|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Debug(SH)|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+					</File>
+					<File
+						RelativePath=".\jpeg-6\jdtrans.cpp">
+						<FileConfiguration
+							Name="Final|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Debug|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Release|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Debug(SH)|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+					</File>
+					<File
+						RelativePath=".\jpeg-6\jerror.cpp">
+						<FileConfiguration
+							Name="Final|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Debug|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Release|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Debug(SH)|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+					</File>
+					<File
+						RelativePath=".\jpeg-6\jfdctflt.cpp">
+						<FileConfiguration
+							Name="Final|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Debug|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Release|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Debug(SH)|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+					</File>
+					<File
+						RelativePath=".\jpeg-6\jidctflt.cpp">
+						<FileConfiguration
+							Name="Final|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Debug|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Release|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Debug(SH)|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+					</File>
+					<File
+						RelativePath=".\jpeg-6\jmemmgr.cpp">
+						<FileConfiguration
+							Name="Final|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Debug|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Release|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Debug(SH)|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+					</File>
+					<File
+						RelativePath=".\jpeg-6\jmemnobs.cpp">
+						<FileConfiguration
+							Name="Final|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Debug|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Release|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Debug(SH)|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+					</File>
+					<File
+						RelativePath=".\jpeg-6\jutils.cpp">
+						<FileConfiguration
+							Name="Final|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Debug|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Release|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="Debug(SH)|Win32">
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="3"
+								PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+						</FileConfiguration>
+					</File>
+				</Filter>
+				<Filter
+					Name="JPG Headers"
+					Filter="">
+					<File
+						RelativePath=".\jpeg-6\jchuff.h">
+					</File>
+					<File
+						RelativePath=".\jpeg-6\jconfig.h">
+					</File>
+					<File
+						RelativePath=".\jpeg-6\jdct.h">
+					</File>
+					<File
+						RelativePath=".\jpeg-6\jdhuff.h">
+					</File>
+					<File
+						RelativePath=".\jpeg-6\jerror.h">
+					</File>
+					<File
+						RelativePath=".\jpeg-6\jinclude.h">
+					</File>
+					<File
+						RelativePath=".\jpeg-6\jmemsys.h">
+					</File>
+					<File
+						RelativePath=".\jpeg-6\jmorecfg.h">
+					</File>
+					<File
+						RelativePath=".\jpeg-6\jpegint.h">
+					</File>
+					<File
+						RelativePath=".\jpeg-6\jpeglib.h">
+					</File>
+					<File
+						RelativePath=".\jpeg-6\jversion.h">
+					</File>
+				</Filter>
+			</Filter>
+			<Filter
+				Name="png"
+				Filter="">
+				<File
+					RelativePath=".\png\png.cpp">
+					<FileConfiguration
+						Name="Final|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"
+							PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="Debug|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"
+							PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="Release|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"
+							PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+					</FileConfiguration>
+					<FileConfiguration
+						Name="Debug(SH)|Win32">
+						<Tool
+							Name="VCCLCompilerTool"
+							UsePrecompiledHeader="0"
+							PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+					</FileConfiguration>
+				</File>
+				<File
+					RelativePath=".\png\png.h">
+				</File>
+			</Filter>
+		</Filter>
+		<Filter
+			Name="Ghoul2"
+			Filter="">
+			<File
+				RelativePath=".\ghoul2\G2.h">
+			</File>
+			<File
+				RelativePath=".\ghoul2\G2_API.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\ghoul2\G2_bolts.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\ghoul2\G2_bones.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\ghoul2\G2_gore.h">
+			</File>
+			<File
+				RelativePath=".\ghoul2\G2_local.h">
+			</File>
+			<File
+				RelativePath=".\ghoul2\G2_misc.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\ghoul2\G2_surfaces.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\ghoul2\ghoul2_shared.h">
+			</File>
+			<File
+				RelativePath=".\renderer\mdx_format.h">
+			</File>
+		</Filter>
+		<Filter
+			Name="zlib32"
+			Filter="">
+			<File
+				RelativePath="zlib32\deflate.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="zlib32\deflate.h">
+			</File>
+			<File
+				RelativePath="zlib32\inflate.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="zlib32\inflate.h">
+			</File>
+			<File
+				RelativePath="zlib32\zip.h">
+			</File>
+			<File
+				RelativePath="zlib32\zipcommon.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+		</Filter>
+		<Filter
+			Name="SmartHeap"
+			Filter="">
+			<File
+				RelativePath=".\smartheap\HA312W32.DLL">
+				<FileConfiguration
+					Name="Final|Win32"
+					ExcludedFromBuild="TRUE">
+					<Tool
+						Name="VCCustomBuildTool"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32"
+					ExcludedFromBuild="TRUE">
+					<Tool
+						Name="VCCustomBuildTool"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32"
+					ExcludedFromBuild="TRUE">
+					<Tool
+						Name="VCCustomBuildTool"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\smartheap\HAW32M.LIB">
+				<FileConfiguration
+					Name="Final|Win32"
+					ExcludedFromBuild="TRUE">
+					<Tool
+						Name="VCCustomBuildTool"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32"
+					ExcludedFromBuild="TRUE">
+					<Tool
+						Name="VCCustomBuildTool"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32"
+					ExcludedFromBuild="TRUE">
+					<Tool
+						Name="VCCustomBuildTool"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\smartheap\HEAPAGNT.H">
+				<FileConfiguration
+					Name="Final|Win32"
+					ExcludedFromBuild="TRUE">
+					<Tool
+						Name="VCCustomBuildTool"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32"
+					ExcludedFromBuild="TRUE">
+					<Tool
+						Name="VCCustomBuildTool"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32"
+					ExcludedFromBuild="TRUE">
+					<Tool
+						Name="VCCustomBuildTool"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\smartheap\SHW32.DLL">
+				<FileConfiguration
+					Name="Final|Win32"
+					ExcludedFromBuild="TRUE">
+					<Tool
+						Name="VCCustomBuildTool"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32"
+					ExcludedFromBuild="TRUE">
+					<Tool
+						Name="VCCustomBuildTool"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32"
+					ExcludedFromBuild="TRUE">
+					<Tool
+						Name="VCCustomBuildTool"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\smartheap\SMRTHEAP.C">
+				<FileConfiguration
+					Name="Final|Win32"
+					ExcludedFromBuild="TRUE">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32"
+					ExcludedFromBuild="TRUE">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32"
+					ExcludedFromBuild="TRUE">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\smartheap\SMRTHEAP.H">
+				<FileConfiguration
+					Name="Final|Win32"
+					ExcludedFromBuild="TRUE">
+					<Tool
+						Name="VCCustomBuildTool"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32"
+					ExcludedFromBuild="TRUE">
+					<Tool
+						Name="VCCustomBuildTool"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32"
+					ExcludedFromBuild="TRUE">
+					<Tool
+						Name="VCCustomBuildTool"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\smartheap\smrtheap.hpp">
+				<FileConfiguration
+					Name="Final|Win32"
+					ExcludedFromBuild="TRUE">
+					<Tool
+						Name="VCCustomBuildTool"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32"
+					ExcludedFromBuild="TRUE">
+					<Tool
+						Name="VCCustomBuildTool"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32"
+					ExcludedFromBuild="TRUE">
+					<Tool
+						Name="VCCustomBuildTool"/>
+				</FileConfiguration>
+			</File>
+		</Filter>
+		<Filter
+			Name="Debug"
+			Filter="">
+			<File
+				RelativePath=".\Debug\HA312W32.DLL">
+				<FileConfiguration
+					Name="Final|Win32"
+					ExcludedFromBuild="TRUE">
+					<Tool
+						Name="VCCustomBuildTool"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32"
+					ExcludedFromBuild="TRUE">
+					<Tool
+						Name="VCCustomBuildTool"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32"
+					ExcludedFromBuild="TRUE">
+					<Tool
+						Name="VCCustomBuildTool"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\Debug\SHW32.DLL">
+				<FileConfiguration
+					Name="Final|Win32"
+					ExcludedFromBuild="TRUE">
+					<Tool
+						Name="VCCustomBuildTool"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32"
+					ExcludedFromBuild="TRUE">
+					<Tool
+						Name="VCCustomBuildTool"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32"
+					ExcludedFromBuild="TRUE">
+					<Tool
+						Name="VCCustomBuildTool"/>
+				</FileConfiguration>
+			</File>
+		</Filter>
+		<Filter
+			Name="RMG"
+			Filter="">
+			<File
+				RelativePath=".\RMG\RM_Area.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\RMG\RM_Area.h">
+			</File>
+			<File
+				RelativePath=".\RMG\RM_Headers.h">
+			</File>
+			<File
+				RelativePath=".\RMG\RM_Instance.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\RMG\RM_Instance.h">
+			</File>
+			<File
+				RelativePath=".\RMG\RM_InstanceFile.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\RMG\RM_InstanceFile.h">
+			</File>
+			<File
+				RelativePath=".\RMG\RM_Instance_BSP.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\RMG\RM_Instance_BSP.h">
+			</File>
+			<File
+				RelativePath=".\RMG\RM_Instance_Group.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\RMG\RM_Instance_Group.h">
+			</File>
+			<File
+				RelativePath=".\RMG\RM_Instance_Random.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\RMG\RM_Instance_Random.h">
+			</File>
+			<File
+				RelativePath=".\RMG\RM_Instance_Void.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\RMG\RM_Instance_Void.h">
+			</File>
+			<File
+				RelativePath=".\RMG\RM_Manager.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\RMG\RM_Manager.h">
+			</File>
+			<File
+				RelativePath=".\RMG\RM_Mission.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\RMG\RM_Mission.h">
+			</File>
+			<File
+				RelativePath=".\RMG\RM_Objective.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\RMG\RM_Objective.h">
+			</File>
+			<File
+				RelativePath=".\RMG\RM_Path.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\RMG\RM_Path.h">
+			</File>
+			<File
+				RelativePath=".\RMG\RM_Terrain.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\RMG\RM_Terrain.h">
+			</File>
+		</Filter>
+		<Filter
+			Name="ICARUS"
+			Filter="">
+			<File
+				RelativePath=".\icarus\BlockStream.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\icarus\GameInterface.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\icarus\GameInterface.h">
+			</File>
+			<File
+				RelativePath=".\icarus\Instance.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\icarus\Interface.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\icarus\Memory.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\icarus\Q3_Interface.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\icarus\Q3_Interface.h">
+			</File>
+			<File
+				RelativePath=".\icarus\Q3_Registers.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\icarus\Q3_Registers.h">
+			</File>
+			<File
+				RelativePath=".\icarus\Sequence.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\icarus\Sequencer.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\icarus\TaskManager.cpp">
+				<FileConfiguration
+					Name="Final|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="3"
+						PrecompiledHeaderThrough="../qcommon/exe_headers.h"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath=".\icarus\blockstream.h">
+			</File>
+			<File
+				RelativePath=".\icarus\icarus.h">
+			</File>
+			<File
+				RelativePath=".\icarus\instance.h">
+			</File>
+			<File
+				RelativePath=".\icarus\interface.h">
+			</File>
+			<File
+				RelativePath=".\icarus\interpreter.h">
+			</File>
+			<File
+				RelativePath=".\icarus\module.h">
+			</File>
+			<File
+				RelativePath=".\icarus\sequence.h">
+			</File>
+			<File
+				RelativePath=".\icarus\sequencer.h">
+			</File>
+			<File
+				RelativePath=".\icarus\taskmanager.h">
+			</File>
+			<File
+				RelativePath=".\icarus\tokenizer.h">
+			</File>
+		</Filter>
+		<Filter
+			Name="Ravl"
+			Filter="">
+			<File
+				RelativePath="Ravl\CVec.h">
+			</File>
+		</Filter>
+		<Filter
+			Name="Ratl"
+			Filter="">
+			<File
+				RelativePath="Ratl\bits_vs.h">
+			</File>
+			<File
+				RelativePath="Ratl\ratl_common.h">
+			</File>
+			<File
+				RelativePath="Ratl\vector_vs.h">
+			</File>
+		</Filter>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>
diff --git a/codemp/jk2mp.vcproj.vspscc b/codemp/jk2mp.vcproj.vspscc
new file mode 100644
index 0000000..794f014
--- /dev/null
+++ b/codemp/jk2mp.vcproj.vspscc
@@ -0,0 +1,10 @@
+""
+{
+"FILE_VERSION" = "9237"
+"ENLISTMENT_CHOICE" = "NEVER"
+"PROJECT_FILE_RELATIVE_PATH" = ""
+"NUMBER_OF_EXCLUDED_FILES" = "0"
+"ORIGINAL_PROJECT_FILE_PATH" = ""
+"NUMBER_OF_NESTED_PROJECTS" = "0"
+"SOURCE_CONTROL_SETTINGS_PROVIDER" = "PROJECT"
+}
diff --git a/codemp/jpeg-6/jcapimin.cpp b/codemp/jpeg-6/jcapimin.cpp
new file mode 100644
index 0000000..f41508f
--- /dev/null
+++ b/codemp/jpeg-6/jcapimin.cpp
@@ -0,0 +1,230 @@
+/*
+ * jcapimin.c
+ *
+ * Copyright (C) 1994-1995, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains application interface code for the compression half
+ * of the JPEG library.  These are the "minimum" API routines that may be
+ * needed in either the normal full-compression case or the transcoding-only
+ * case.
+ *
+ * Most of the routines intended to be called directly by an application
+ * are in this file or in jcapistd.c.  But also see jcparam.c for
+ * parameter-setup helper routines, jcomapi.c for routines shared by
+ * compression and decompression, and jctrans.c for the transcoding case.
+ */
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/*
+ * Initialization of a JPEG compression object.
+ * The error manager must already be set up (in case memory manager fails).
+ */
+
+GLOBAL void
+jpeg_create_compress (j_compress_ptr cinfo)
+{
+  int i;
+
+  /* For debugging purposes, zero the whole master structure.
+   * But error manager pointer is already there, so save and restore it.
+   */
+  {
+    struct jpeg_error_mgr * err = cinfo->err;
+    MEMZERO(cinfo, SIZEOF(struct jpeg_compress_struct));
+    cinfo->err = err;
+  }
+  cinfo->is_decompressor = FALSE;
+
+  /* Initialize a memory manager instance for this object */
+  jinit_memory_mgr((j_common_ptr) cinfo);
+
+  /* Zero out pointers to permanent structures. */
+  cinfo->progress = NULL;
+  cinfo->dest = NULL;
+
+  cinfo->comp_info = NULL;
+
+  for (i = 0; i < NUM_QUANT_TBLS; i++)
+    cinfo->quant_tbl_ptrs[i] = NULL;
+
+  for (i = 0; i < NUM_HUFF_TBLS; i++) {
+    cinfo->dc_huff_tbl_ptrs[i] = NULL;
+    cinfo->ac_huff_tbl_ptrs[i] = NULL;
+  }
+
+  cinfo->input_gamma = 1.0;	/* in case application forgets */
+
+  /* OK, I'm ready */
+  cinfo->global_state = CSTATE_START;
+}
+
+
+/*
+ * Destruction of a JPEG compression object
+ */
+
+GLOBAL void
+jpeg_destroy_compress (j_compress_ptr cinfo)
+{
+  jpeg_destroy((j_common_ptr) cinfo); /* use common routine */
+}
+
+
+/*
+ * Abort processing of a JPEG compression operation,
+ * but don't destroy the object itself.
+ */
+
+GLOBAL void
+jpeg_abort_compress (j_compress_ptr cinfo)
+{
+  jpeg_abort((j_common_ptr) cinfo); /* use common routine */
+}
+
+
+/*
+ * Forcibly suppress or un-suppress all quantization and Huffman tables.
+ * Marks all currently defined tables as already written (if suppress)
+ * or not written (if !suppress).  This will control whether they get emitted
+ * by a subsequent jpeg_start_compress call.
+ *
+ * This routine is exported for use by applications that want to produce
+ * abbreviated JPEG datastreams.  It logically belongs in jcparam.c, but
+ * since it is called by jpeg_start_compress, we put it here --- otherwise
+ * jcparam.o would be linked whether the application used it or not.
+ */
+
+GLOBAL void
+jpeg_suppress_tables (j_compress_ptr cinfo, boolean suppress)
+{
+  int i;
+  JQUANT_TBL * qtbl;
+  JHUFF_TBL * htbl;
+
+  for (i = 0; i < NUM_QUANT_TBLS; i++) {
+    if ((qtbl = cinfo->quant_tbl_ptrs[i]) != NULL)
+      qtbl->sent_table = suppress;
+  }
+
+  for (i = 0; i < NUM_HUFF_TBLS; i++) {
+    if ((htbl = cinfo->dc_huff_tbl_ptrs[i]) != NULL)
+      htbl->sent_table = suppress;
+    if ((htbl = cinfo->ac_huff_tbl_ptrs[i]) != NULL)
+      htbl->sent_table = suppress;
+  }
+}
+
+
+/*
+ * Finish JPEG compression.
+ *
+ * If a multipass operating mode was selected, this may do a great deal of
+ * work including most of the actual output.
+ */
+
+GLOBAL void
+jpeg_finish_compress (j_compress_ptr cinfo)
+{
+  JDIMENSION iMCU_row;
+
+  if (cinfo->global_state == CSTATE_SCANNING ||
+      cinfo->global_state == CSTATE_RAW_OK) {
+    /* Terminate first pass */
+    if (cinfo->next_scanline < cinfo->image_height)
+      ERREXIT(cinfo, JERR_TOO_LITTLE_DATA);
+    (*cinfo->master->finish_pass) (cinfo);
+  } else if (cinfo->global_state != CSTATE_WRCOEFS)
+    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+  /* Perform any remaining passes */
+  while (! cinfo->master->is_last_pass) {
+    (*cinfo->master->prepare_for_pass) (cinfo);
+    for (iMCU_row = 0; iMCU_row < cinfo->total_iMCU_rows; iMCU_row++) {
+      if (cinfo->progress != NULL) {
+	cinfo->progress->pass_counter = (long) iMCU_row;
+	cinfo->progress->pass_limit = (long) cinfo->total_iMCU_rows;
+	(*cinfo->progress->progress_monitor) ((j_common_ptr) cinfo);
+      }
+      /* We bypass the main controller and invoke coef controller directly;
+       * all work is being done from the coefficient buffer.
+       */
+      if (! (*cinfo->coef->compress_data) (cinfo, (JSAMPIMAGE) NULL))
+	ERREXIT(cinfo, JERR_CANT_SUSPEND);
+    }
+    (*cinfo->master->finish_pass) (cinfo);
+  }
+  /* Write EOI, do final cleanup */
+  (*cinfo->marker->write_file_trailer) (cinfo);
+  (*cinfo->dest->term_destination) (cinfo);
+  /* We can use jpeg_abort to release memory and reset global_state */
+  jpeg_abort((j_common_ptr) cinfo);
+}
+
+
+/*
+ * Write a special marker.
+ * This is only recommended for writing COM or APPn markers.
+ * Must be called after jpeg_start_compress() and before
+ * first call to jpeg_write_scanlines() or jpeg_write_raw_data().
+ */
+
+GLOBAL void
+jpeg_write_marker (j_compress_ptr cinfo, int marker,
+		   const JOCTET *dataptr, unsigned int datalen)
+{
+  if (cinfo->next_scanline != 0 ||
+      (cinfo->global_state != CSTATE_SCANNING &&
+       cinfo->global_state != CSTATE_RAW_OK &&
+       cinfo->global_state != CSTATE_WRCOEFS))
+    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+
+  (*cinfo->marker->write_any_marker) (cinfo, marker, dataptr, datalen);
+}
+
+
+/*
+ * Alternate compression function: just write an abbreviated table file.
+ * Before calling this, all parameters and a data destination must be set up.
+ *
+ * To produce a pair of files containing abbreviated tables and abbreviated
+ * image data, one would proceed as follows:
+ *
+ *		initialize JPEG object
+ *		set JPEG parameters
+ *		set destination to table file
+ *		jpeg_write_tables(cinfo);
+ *		set destination to image file
+ *		jpeg_start_compress(cinfo, FALSE);
+ *		write data...
+ *		jpeg_finish_compress(cinfo);
+ *
+ * jpeg_write_tables has the side effect of marking all tables written
+ * (same as jpeg_suppress_tables(..., TRUE)).  Thus a subsequent start_compress
+ * will not re-emit the tables unless it is passed write_all_tables=TRUE.
+ */
+
+GLOBAL void
+jpeg_write_tables (j_compress_ptr cinfo)
+{
+  if (cinfo->global_state != CSTATE_START)
+    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+
+  /* (Re)initialize error mgr and destination modules */
+  (*cinfo->err->reset_error_mgr) ((j_common_ptr) cinfo);
+  (*cinfo->dest->init_destination) (cinfo);
+  /* Initialize the marker writer ... bit of a crock to do it here. */
+  jinit_marker_writer(cinfo);
+  /* Write them tables! */
+  (*cinfo->marker->write_tables_only) (cinfo);
+  /* And clean up. */
+  (*cinfo->dest->term_destination) (cinfo);
+  /* We can use jpeg_abort to release memory. */
+  jpeg_abort((j_common_ptr) cinfo);
+}
diff --git a/codemp/jpeg-6/jccoefct.cpp b/codemp/jpeg-6/jccoefct.cpp
new file mode 100644
index 0000000..ca37502
--- /dev/null
+++ b/codemp/jpeg-6/jccoefct.cpp
@@ -0,0 +1,450 @@
+/*
+ * jccoefct.c
+ *
+ * Copyright (C) 1994-1995, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains the coefficient buffer controller for compression.
+ * This controller is the top level of the JPEG compressor proper.
+ * The coefficient buffer lies between forward-DCT and entropy encoding steps.
+ */
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/* We use a full-image coefficient buffer when doing Huffman optimization,
+ * and also for writing multiple-scan JPEG files.  In all cases, the DCT
+ * step is run during the first pass, and subsequent passes need only read
+ * the buffered coefficients.
+ */
+#ifdef ENTROPY_OPT_SUPPORTED
+#define FULL_COEF_BUFFER_SUPPORTED
+#else
+#ifdef C_MULTISCAN_FILES_SUPPORTED
+#define FULL_COEF_BUFFER_SUPPORTED
+#endif
+#endif
+
+
+/* Private buffer controller object */
+
+typedef struct {
+  struct jpeg_c_coef_controller pub; /* public fields */
+
+  JDIMENSION iMCU_row_num;	/* iMCU row # within image */
+  JDIMENSION mcu_ctr;		/* counts MCUs processed in current row */
+  int MCU_vert_offset;		/* counts MCU rows within iMCU row */
+  int MCU_rows_per_iMCU_row;	/* number of such rows needed */
+
+  /* For single-pass compression, it's sufficient to buffer just one MCU
+   * (although this may prove a bit slow in practice).  We allocate a
+   * workspace of C_MAX_BLOCKS_IN_MCU coefficient blocks, and reuse it for each
+   * MCU constructed and sent.  (On 80x86, the workspace is FAR even though
+   * it's not really very big; this is to keep the module interfaces unchanged
+   * when a large coefficient buffer is necessary.)
+   * In multi-pass modes, this array points to the current MCU's blocks
+   * within the virtual arrays.
+   */
+  JBLOCKROW MCU_buffer[C_MAX_BLOCKS_IN_MCU];
+
+  /* In multi-pass modes, we need a virtual block array for each component. */
+  jvirt_barray_ptr whole_image[MAX_COMPONENTS];
+} my_coef_controller;
+
+typedef my_coef_controller * my_coef_ptr;
+
+
+/* Forward declarations */
+METHODDEF boolean compress_data
+    JPP((j_compress_ptr cinfo, JSAMPIMAGE input_buf));
+#ifdef FULL_COEF_BUFFER_SUPPORTED
+METHODDEF boolean compress_first_pass
+    JPP((j_compress_ptr cinfo, JSAMPIMAGE input_buf));
+METHODDEF boolean compress_output
+    JPP((j_compress_ptr cinfo, JSAMPIMAGE input_buf));
+#endif
+
+
+LOCAL void
+start_iMCU_row (j_compress_ptr cinfo)
+/* Reset within-iMCU-row counters for a new row */
+{
+  my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
+
+  /* In an interleaved scan, an MCU row is the same as an iMCU row.
+   * In a noninterleaved scan, an iMCU row has v_samp_factor MCU rows.
+   * But at the bottom of the image, process only what's left.
+   */
+  if (cinfo->comps_in_scan > 1) {
+    coef->MCU_rows_per_iMCU_row = 1;
+  } else {
+    if (coef->iMCU_row_num < (cinfo->total_iMCU_rows-1))
+      coef->MCU_rows_per_iMCU_row = cinfo->cur_comp_info[0]->v_samp_factor;
+    else
+      coef->MCU_rows_per_iMCU_row = cinfo->cur_comp_info[0]->last_row_height;
+  }
+
+  coef->mcu_ctr = 0;
+  coef->MCU_vert_offset = 0;
+}
+
+
+/*
+ * Initialize for a processing pass.
+ */
+
+METHODDEF void
+start_pass_coef (j_compress_ptr cinfo, J_BUF_MODE pass_mode)
+{
+  my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
+
+  coef->iMCU_row_num = 0;
+  start_iMCU_row(cinfo);
+
+  switch (pass_mode) {
+  case JBUF_PASS_THRU:
+    if (coef->whole_image[0] != NULL)
+      ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+    coef->pub.compress_data = compress_data;
+    break;
+#ifdef FULL_COEF_BUFFER_SUPPORTED
+  case JBUF_SAVE_AND_PASS:
+    if (coef->whole_image[0] == NULL)
+      ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+    coef->pub.compress_data = compress_first_pass;
+    break;
+  case JBUF_CRANK_DEST:
+    if (coef->whole_image[0] == NULL)
+      ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+    coef->pub.compress_data = compress_output;
+    break;
+#endif
+  default:
+    ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+    break;
+  }
+}
+
+
+/*
+ * Process some data in the single-pass case.
+ * We process the equivalent of one fully interleaved MCU row ("iMCU" row)
+ * per call, ie, v_samp_factor block rows for each component in the image.
+ * Returns TRUE if the iMCU row is completed, FALSE if suspended.
+ *
+ * NB: input_buf contains a plane for each component in image.
+ * For single pass, this is the same as the components in the scan.
+ */
+
+METHODDEF boolean
+compress_data (j_compress_ptr cinfo, JSAMPIMAGE input_buf)
+{
+  my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
+  JDIMENSION MCU_col_num;	/* index of current MCU within row */
+  JDIMENSION last_MCU_col = cinfo->MCUs_per_row - 1;
+  JDIMENSION last_iMCU_row = cinfo->total_iMCU_rows - 1;
+  int blkn, bi, ci, yindex, yoffset, blockcnt;
+  JDIMENSION ypos, xpos;
+  jpeg_component_info *compptr;
+
+  /* Loop to write as much as one whole iMCU row */
+  for (yoffset = coef->MCU_vert_offset; yoffset < coef->MCU_rows_per_iMCU_row;
+       yoffset++) {
+    for (MCU_col_num = coef->mcu_ctr; MCU_col_num <= last_MCU_col;
+	 MCU_col_num++) {
+      /* Determine where data comes from in input_buf and do the DCT thing.
+       * Each call on forward_DCT processes a horizontal row of DCT blocks
+       * as wide as an MCU; we rely on having allocated the MCU_buffer[] blocks
+       * sequentially.  Dummy blocks at the right or bottom edge are filled in
+       * specially.  The data in them does not matter for image reconstruction,
+       * so we fill them with values that will encode to the smallest amount of
+       * data, viz: all zeroes in the AC entries, DC entries equal to previous
+       * block's DC value.  (Thanks to Thomas Kinsman for this idea.)
+       */
+      blkn = 0;
+      for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+	compptr = cinfo->cur_comp_info[ci];
+	blockcnt = (MCU_col_num < last_MCU_col) ? compptr->MCU_width
+						: compptr->last_col_width;
+	xpos = MCU_col_num * compptr->MCU_sample_width;
+	ypos = yoffset * DCTSIZE; /* ypos == (yoffset+yindex) * DCTSIZE */
+	for (yindex = 0; yindex < compptr->MCU_height; yindex++) {
+	  if (coef->iMCU_row_num < last_iMCU_row ||
+	      yoffset+yindex < compptr->last_row_height) {
+	    (*cinfo->fdct->forward_DCT) (cinfo, compptr,
+					 input_buf[ci], coef->MCU_buffer[blkn],
+					 ypos, xpos, (JDIMENSION) blockcnt);
+	    if (blockcnt < compptr->MCU_width) {
+	      /* Create some dummy blocks at the right edge of the image. */
+	      jzero_far((void FAR *) coef->MCU_buffer[blkn + blockcnt],
+			(compptr->MCU_width - blockcnt) * SIZEOF(JBLOCK));
+	      for (bi = blockcnt; bi < compptr->MCU_width; bi++) {
+		coef->MCU_buffer[blkn+bi][0][0] = coef->MCU_buffer[blkn+bi-1][0][0];
+	      }
+	    }
+	  } else {
+	    /* Create a row of dummy blocks at the bottom of the image. */
+	    jzero_far((void FAR *) coef->MCU_buffer[blkn],
+		      compptr->MCU_width * SIZEOF(JBLOCK));
+	    for (bi = 0; bi < compptr->MCU_width; bi++) {
+	      coef->MCU_buffer[blkn+bi][0][0] = coef->MCU_buffer[blkn-1][0][0];
+	    }
+	  }
+	  blkn += compptr->MCU_width;
+	  ypos += DCTSIZE;
+	}
+      }
+      /* Try to write the MCU.  In event of a suspension failure, we will
+       * re-DCT the MCU on restart (a bit inefficient, could be fixed...)
+       */
+      if (! (*cinfo->entropy->encode_mcu) (cinfo, coef->MCU_buffer)) {
+	/* Suspension forced; update state counters and exit */
+	coef->MCU_vert_offset = yoffset;
+	coef->mcu_ctr = MCU_col_num;
+	return FALSE;
+      }
+    }
+    /* Completed an MCU row, but perhaps not an iMCU row */
+    coef->mcu_ctr = 0;
+  }
+  /* Completed the iMCU row, advance counters for next one */
+  coef->iMCU_row_num++;
+  start_iMCU_row(cinfo);
+  return TRUE;
+}
+
+
+#ifdef FULL_COEF_BUFFER_SUPPORTED
+
+/*
+ * Process some data in the first pass of a multi-pass case.
+ * We process the equivalent of one fully interleaved MCU row ("iMCU" row)
+ * per call, ie, v_samp_factor block rows for each component in the image.
+ * This amount of data is read from the source buffer, DCT'd and quantized,
+ * and saved into the virtual arrays.  We also generate suitable dummy blocks
+ * as needed at the right and lower edges.  (The dummy blocks are constructed
+ * in the virtual arrays, which have been padded appropriately.)  This makes
+ * it possible for subsequent passes not to worry about real vs. dummy blocks.
+ *
+ * We must also emit the data to the entropy encoder.  This is conveniently
+ * done by calling compress_output() after we've loaded the current strip
+ * of the virtual arrays.
+ *
+ * NB: input_buf contains a plane for each component in image.  All
+ * components are DCT'd and loaded into the virtual arrays in this pass.
+ * However, it may be that only a subset of the components are emitted to
+ * the entropy encoder during this first pass; be careful about looking
+ * at the scan-dependent variables (MCU dimensions, etc).
+ */
+
+METHODDEF boolean
+compress_first_pass (j_compress_ptr cinfo, JSAMPIMAGE input_buf)
+{
+  my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
+  JDIMENSION last_iMCU_row = cinfo->total_iMCU_rows - 1;
+  JDIMENSION blocks_across, MCUs_across, MCUindex;
+  int bi, ci, h_samp_factor, block_row, block_rows, ndummy;
+  JCOEF lastDC;
+  jpeg_component_info *compptr;
+  JBLOCKARRAY buffer;
+  JBLOCKROW thisblockrow, lastblockrow;
+
+  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+       ci++, compptr++) {
+    /* Align the virtual buffer for this component. */
+    buffer = (*cinfo->mem->access_virt_barray)
+      ((j_common_ptr) cinfo, coef->whole_image[ci],
+       coef->iMCU_row_num * compptr->v_samp_factor,
+       (JDIMENSION) compptr->v_samp_factor, TRUE);
+    /* Count non-dummy DCT block rows in this iMCU row. */
+    if (coef->iMCU_row_num < last_iMCU_row)
+      block_rows = compptr->v_samp_factor;
+    else {
+      /* NB: can't use last_row_height here, since may not be set! */
+      block_rows = (int) (compptr->height_in_blocks % compptr->v_samp_factor);
+      if (block_rows == 0) block_rows = compptr->v_samp_factor;
+    }
+    blocks_across = compptr->width_in_blocks;
+    h_samp_factor = compptr->h_samp_factor;
+    /* Count number of dummy blocks to be added at the right margin. */
+    ndummy = (int) (blocks_across % h_samp_factor);
+    if (ndummy > 0)
+      ndummy = h_samp_factor - ndummy;
+    /* Perform DCT for all non-dummy blocks in this iMCU row.  Each call
+     * on forward_DCT processes a complete horizontal row of DCT blocks.
+     */
+    for (block_row = 0; block_row < block_rows; block_row++) {
+      thisblockrow = buffer[block_row];
+      (*cinfo->fdct->forward_DCT) (cinfo, compptr,
+				   input_buf[ci], thisblockrow,
+				   (JDIMENSION) (block_row * DCTSIZE),
+				   (JDIMENSION) 0, blocks_across);
+      if (ndummy > 0) {
+	/* Create dummy blocks at the right edge of the image. */
+	thisblockrow += blocks_across; /* => first dummy block */
+	jzero_far((void FAR *) thisblockrow, ndummy * SIZEOF(JBLOCK));
+	lastDC = thisblockrow[-1][0];
+	for (bi = 0; bi < ndummy; bi++) {
+	  thisblockrow[bi][0] = lastDC;
+	}
+      }
+    }
+    /* If at end of image, create dummy block rows as needed.
+     * The tricky part here is that within each MCU, we want the DC values
+     * of the dummy blocks to match the last real block's DC value.
+     * This squeezes a few more bytes out of the resulting file...
+     */
+    if (coef->iMCU_row_num == last_iMCU_row) {
+      blocks_across += ndummy;	/* include lower right corner */
+      MCUs_across = blocks_across / h_samp_factor;
+      for (block_row = block_rows; block_row < compptr->v_samp_factor;
+	   block_row++) {
+	thisblockrow = buffer[block_row];
+	lastblockrow = buffer[block_row-1];
+	jzero_far((void FAR *) thisblockrow,
+		  (size_t) (blocks_across * SIZEOF(JBLOCK)));
+	for (MCUindex = 0; MCUindex < MCUs_across; MCUindex++) {
+	  lastDC = lastblockrow[h_samp_factor-1][0];
+	  for (bi = 0; bi < h_samp_factor; bi++) {
+	    thisblockrow[bi][0] = lastDC;
+	  }
+	  thisblockrow += h_samp_factor; /* advance to next MCU in row */
+	  lastblockrow += h_samp_factor;
+	}
+      }
+    }
+  }
+  /* NB: compress_output will increment iMCU_row_num if successful.
+   * A suspension return will result in redoing all the work above next time.
+   */
+
+  /* Emit data to the entropy encoder, sharing code with subsequent passes */
+  return compress_output(cinfo, input_buf);
+}
+
+
+/*
+ * Process some data in subsequent passes of a multi-pass case.
+ * We process the equivalent of one fully interleaved MCU row ("iMCU" row)
+ * per call, ie, v_samp_factor block rows for each component in the scan.
+ * The data is obtained from the virtual arrays and fed to the entropy coder.
+ * Returns TRUE if the iMCU row is completed, FALSE if suspended.
+ *
+ * NB: input_buf is ignored; it is likely to be a NULL pointer.
+ */
+
+METHODDEF boolean
+compress_output (j_compress_ptr cinfo, JSAMPIMAGE input_buf)
+{
+  my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
+  JDIMENSION MCU_col_num;	/* index of current MCU within row */
+  int blkn, ci, xindex, yindex, yoffset;
+  JDIMENSION start_col;
+  JBLOCKARRAY buffer[MAX_COMPS_IN_SCAN];
+  JBLOCKROW buffer_ptr;
+  jpeg_component_info *compptr;
+
+  /* Align the virtual buffers for the components used in this scan.
+   * NB: during first pass, this is safe only because the buffers will
+   * already be aligned properly, so jmemmgr.c won't need to do any I/O.
+   */
+  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+    compptr = cinfo->cur_comp_info[ci];
+    buffer[ci] = (*cinfo->mem->access_virt_barray)
+      ((j_common_ptr) cinfo, coef->whole_image[compptr->component_index],
+       coef->iMCU_row_num * compptr->v_samp_factor,
+       (JDIMENSION) compptr->v_samp_factor, FALSE);
+  }
+
+  /* Loop to process one whole iMCU row */
+  for (yoffset = coef->MCU_vert_offset; yoffset < coef->MCU_rows_per_iMCU_row;
+       yoffset++) {
+    for (MCU_col_num = coef->mcu_ctr; MCU_col_num < cinfo->MCUs_per_row;
+	 MCU_col_num++) {
+      /* Construct list of pointers to DCT blocks belonging to this MCU */
+      blkn = 0;			/* index of current DCT block within MCU */
+      for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+	compptr = cinfo->cur_comp_info[ci];
+	start_col = MCU_col_num * compptr->MCU_width;
+	for (yindex = 0; yindex < compptr->MCU_height; yindex++) {
+	  buffer_ptr = buffer[ci][yindex+yoffset] + start_col;
+	  for (xindex = 0; xindex < compptr->MCU_width; xindex++) {
+	    coef->MCU_buffer[blkn++] = buffer_ptr++;
+	  }
+	}
+      }
+      /* Try to write the MCU. */
+      if (! (*cinfo->entropy->encode_mcu) (cinfo, coef->MCU_buffer)) {
+	/* Suspension forced; update state counters and exit */
+	coef->MCU_vert_offset = yoffset;
+	coef->mcu_ctr = MCU_col_num;
+	return FALSE;
+      }
+    }
+    /* Completed an MCU row, but perhaps not an iMCU row */
+    coef->mcu_ctr = 0;
+  }
+  /* Completed the iMCU row, advance counters for next one */
+  coef->iMCU_row_num++;
+  start_iMCU_row(cinfo);
+  return TRUE;
+}
+
+#endif /* FULL_COEF_BUFFER_SUPPORTED */
+
+
+/*
+ * Initialize coefficient buffer controller.
+ */
+
+GLOBAL void
+jinit_c_coef_controller (j_compress_ptr cinfo, boolean need_full_buffer)
+{
+  my_coef_ptr coef;
+
+  coef = (my_coef_ptr)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				SIZEOF(my_coef_controller));
+  cinfo->coef = (struct jpeg_c_coef_controller *) coef;
+  coef->pub.start_pass = start_pass_coef;
+
+  /* Create the coefficient buffer. */
+  if (need_full_buffer) {
+#ifdef FULL_COEF_BUFFER_SUPPORTED
+    /* Allocate a full-image virtual array for each component, */
+    /* padded to a multiple of samp_factor DCT blocks in each direction. */
+    int ci;
+    jpeg_component_info *compptr;
+
+    for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+	 ci++, compptr++) {
+      coef->whole_image[ci] = (*cinfo->mem->request_virt_barray)
+	((j_common_ptr) cinfo, JPOOL_IMAGE, FALSE,
+	 (JDIMENSION) jround_up((long) compptr->width_in_blocks,
+				(long) compptr->h_samp_factor),
+	 (JDIMENSION) jround_up((long) compptr->height_in_blocks,
+				(long) compptr->v_samp_factor),
+	 (JDIMENSION) compptr->v_samp_factor);
+    }
+#else
+    ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+#endif
+  } else {
+    /* We only need a single-MCU buffer. */
+    JBLOCKROW buffer;
+    int i;
+
+    buffer = (JBLOCKROW)
+      (*cinfo->mem->alloc_large) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				  C_MAX_BLOCKS_IN_MCU * SIZEOF(JBLOCK));
+    for (i = 0; i < C_MAX_BLOCKS_IN_MCU; i++) {
+      coef->MCU_buffer[i] = buffer + i;
+    }
+    coef->whole_image[0] = NULL; /* flag for no virtual arrays */
+  }
+}
diff --git a/codemp/jpeg-6/jccolor.cpp b/codemp/jpeg-6/jccolor.cpp
new file mode 100644
index 0000000..f22d36b
--- /dev/null
+++ b/codemp/jpeg-6/jccolor.cpp
@@ -0,0 +1,461 @@
+/*
+ * jccolor.c
+ *
+ * Copyright (C) 1991-1994, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains input colorspace conversion routines.
+ */
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/* Private subobject */
+
+typedef struct {
+  struct jpeg_color_converter pub; /* public fields */
+
+  /* Private state for RGB->YCC conversion */
+  INT32 * rgb_ycc_tab;		/* => table for RGB to YCbCr conversion */
+} my_color_converter;
+
+typedef my_color_converter * my_cconvert_ptr;
+
+
+/**************** RGB -> YCbCr conversion: most common case **************/
+
+/*
+ * YCbCr is defined per CCIR 601-1, except that Cb and Cr are
+ * normalized to the range 0..MAXJSAMPLE rather than -0.5 .. 0.5.
+ * The conversion equations to be implemented are therefore
+ *	Y  =  0.29900 * R + 0.58700 * G + 0.11400 * B
+ *	Cb = -0.16874 * R - 0.33126 * G + 0.50000 * B  + CENTERJSAMPLE
+ *	Cr =  0.50000 * R - 0.41869 * G - 0.08131 * B  + CENTERJSAMPLE
+ * (These numbers are derived from TIFF 6.0 section 21, dated 3-June-92.)
+ * Note: older versions of the IJG code used a zero offset of MAXJSAMPLE/2,
+ * rather than CENTERJSAMPLE, for Cb and Cr.  This gave equal positive and
+ * negative swings for Cb/Cr, but meant that grayscale values (Cb=Cr=0)
+ * were not represented exactly.  Now we sacrifice exact representation of
+ * maximum red and maximum blue in order to get exact grayscales.
+ *
+ * To avoid floating-point arithmetic, we represent the fractional constants
+ * as integers scaled up by 2^16 (about 4 digits precision); we have to divide
+ * the products by 2^16, with appropriate rounding, to get the correct answer.
+ *
+ * For even more speed, we avoid doing any multiplications in the inner loop
+ * by precalculating the constants times R,G,B for all possible values.
+ * For 8-bit JSAMPLEs this is very reasonable (only 256 entries per table);
+ * for 12-bit samples it is still acceptable.  It's not very reasonable for
+ * 16-bit samples, but if you want lossless storage you shouldn't be changing
+ * colorspace anyway.
+ * The CENTERJSAMPLE offsets and the rounding fudge-factor of 0.5 are included
+ * in the tables to save adding them separately in the inner loop.
+ */
+
+#define SCALEBITS	16	/* speediest right-shift on some machines */
+#define CBCR_OFFSET	((INT32) CENTERJSAMPLE << SCALEBITS)
+#define ONE_HALF	((INT32) 1 << (SCALEBITS-1))
+#define FIX(x)		((INT32) ((x) * (1L<<SCALEBITS) + 0.5))
+
+/* We allocate one big table and divide it up into eight parts, instead of
+ * doing eight alloc_small requests.  This lets us use a single table base
+ * address, which can be held in a register in the inner loops on many
+ * machines (more than can hold all eight addresses, anyway).
+ */
+
+#define R_Y_OFF		0			/* offset to R => Y section */
+#define G_Y_OFF		(1*(MAXJSAMPLE+1))	/* offset to G => Y section */
+#define B_Y_OFF		(2*(MAXJSAMPLE+1))	/* etc. */
+#define R_CB_OFF	(3*(MAXJSAMPLE+1))
+#define G_CB_OFF	(4*(MAXJSAMPLE+1))
+#define B_CB_OFF	(5*(MAXJSAMPLE+1))
+#define R_CR_OFF	B_CB_OFF		/* B=>Cb, R=>Cr are the same */
+#define G_CR_OFF	(6*(MAXJSAMPLE+1))
+#define B_CR_OFF	(7*(MAXJSAMPLE+1))
+#define TABLE_SIZE	(8*(MAXJSAMPLE+1))
+
+
+/*
+ * Initialize for RGB->YCC colorspace conversion.
+ */
+
+METHODDEF void
+rgb_ycc_start (j_compress_ptr cinfo)
+{
+  my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
+  INT32 * rgb_ycc_tab;
+  INT32 i;
+
+  /* Allocate and fill in the conversion tables. */
+  cconvert->rgb_ycc_tab = rgb_ycc_tab = (INT32 *)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				(TABLE_SIZE * SIZEOF(INT32)));
+
+  for (i = 0; i <= MAXJSAMPLE; i++) {
+    rgb_ycc_tab[i+R_Y_OFF] = FIX(0.29900) * i;
+    rgb_ycc_tab[i+G_Y_OFF] = FIX(0.58700) * i;
+    rgb_ycc_tab[i+B_Y_OFF] = FIX(0.11400) * i     + ONE_HALF;
+    rgb_ycc_tab[i+R_CB_OFF] = (-FIX(0.16874)) * i;
+    rgb_ycc_tab[i+G_CB_OFF] = (-FIX(0.33126)) * i;
+    /* We use a rounding fudge-factor of 0.5-epsilon for Cb and Cr.
+     * This ensures that the maximum output will round to MAXJSAMPLE
+     * not MAXJSAMPLE+1, and thus that we don't have to range-limit.
+     */
+    rgb_ycc_tab[i+B_CB_OFF] = FIX(0.50000) * i    + CBCR_OFFSET + ONE_HALF-1;
+/*  B=>Cb and R=>Cr tables are the same
+    rgb_ycc_tab[i+R_CR_OFF] = FIX(0.50000) * i    + CBCR_OFFSET + ONE_HALF-1;
+*/
+    rgb_ycc_tab[i+G_CR_OFF] = (-FIX(0.41869)) * i;
+    rgb_ycc_tab[i+B_CR_OFF] = (-FIX(0.08131)) * i;
+  }
+}
+
+
+/*
+ * Convert some rows of samples to the JPEG colorspace.
+ *
+ * Note that we change from the application's interleaved-pixel format
+ * to our internal noninterleaved, one-plane-per-component format.
+ * The input buffer is therefore three times as wide as the output buffer.
+ *
+ * A starting row offset is provided only for the output buffer.  The caller
+ * can easily adjust the passed input_buf value to accommodate any row
+ * offset required on that side.
+ */
+
+METHODDEF void
+rgb_ycc_convert (j_compress_ptr cinfo,
+		 JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+		 JDIMENSION output_row, int num_rows)
+{
+  my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
+  register int r, g, b;
+  register INT32 * ctab = cconvert->rgb_ycc_tab;
+  register JSAMPROW inptr;
+  register JSAMPROW outptr0, outptr1, outptr2;
+  register JDIMENSION col;
+  JDIMENSION num_cols = cinfo->image_width;
+
+  while (--num_rows >= 0) {
+    inptr = *input_buf++;
+    outptr0 = output_buf[0][output_row];
+    outptr1 = output_buf[1][output_row];
+    outptr2 = output_buf[2][output_row];
+    output_row++;
+    for (col = 0; col < num_cols; col++) {
+      r = GETJSAMPLE(inptr[RGB_RED]);
+      g = GETJSAMPLE(inptr[RGB_GREEN]);
+      b = GETJSAMPLE(inptr[RGB_BLUE]);
+      inptr += RGB_PIXELSIZE;
+      /* If the inputs are 0..MAXJSAMPLE, the outputs of these equations
+       * must be too; we do not need an explicit range-limiting operation.
+       * Hence the value being shifted is never negative, and we don't
+       * need the general RIGHT_SHIFT macro.
+       */
+      /* Y */
+      outptr0[col] = (JSAMPLE)
+		((ctab[r+R_Y_OFF] + ctab[g+G_Y_OFF] + ctab[b+B_Y_OFF])
+		 >> SCALEBITS);
+      /* Cb */
+      outptr1[col] = (JSAMPLE)
+		((ctab[r+R_CB_OFF] + ctab[g+G_CB_OFF] + ctab[b+B_CB_OFF])
+		 >> SCALEBITS);
+      /* Cr */
+      outptr2[col] = (JSAMPLE)
+		((ctab[r+R_CR_OFF] + ctab[g+G_CR_OFF] + ctab[b+B_CR_OFF])
+		 >> SCALEBITS);
+    }
+  }
+}
+
+
+/**************** Cases other than RGB -> YCbCr **************/
+
+
+/*
+ * Convert some rows of samples to the JPEG colorspace.
+ * This version handles RGB->grayscale conversion, which is the same
+ * as the RGB->Y portion of RGB->YCbCr.
+ * We assume rgb_ycc_start has been called (we only use the Y tables).
+ */
+
+METHODDEF void
+rgb_gray_convert (j_compress_ptr cinfo,
+		  JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+		  JDIMENSION output_row, int num_rows)
+{
+  my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
+  register int r, g, b;
+  register INT32 * ctab = cconvert->rgb_ycc_tab;
+  register JSAMPROW inptr;
+  register JSAMPROW outptr;
+  register JDIMENSION col;
+  JDIMENSION num_cols = cinfo->image_width;
+
+  while (--num_rows >= 0) {
+    inptr = *input_buf++;
+    outptr = output_buf[0][output_row];
+    output_row++;
+    for (col = 0; col < num_cols; col++) {
+      r = GETJSAMPLE(inptr[RGB_RED]);
+      g = GETJSAMPLE(inptr[RGB_GREEN]);
+      b = GETJSAMPLE(inptr[RGB_BLUE]);
+      inptr += RGB_PIXELSIZE;
+      /* Y */
+      outptr[col] = (JSAMPLE)
+		((ctab[r+R_Y_OFF] + ctab[g+G_Y_OFF] + ctab[b+B_Y_OFF])
+		 >> SCALEBITS);
+    }
+  }
+}
+
+
+/*
+ * Convert some rows of samples to the JPEG colorspace.
+ * This version handles Adobe-style CMYK->YCCK conversion,
+ * where we convert R=1-C, G=1-M, and B=1-Y to YCbCr using the same
+ * conversion as above, while passing K (black) unchanged.
+ * We assume rgb_ycc_start has been called.
+ */
+
+METHODDEF void
+cmyk_ycck_convert (j_compress_ptr cinfo,
+		   JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+		   JDIMENSION output_row, int num_rows)
+{
+  my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
+  register int r, g, b;
+  register INT32 * ctab = cconvert->rgb_ycc_tab;
+  register JSAMPROW inptr;
+  register JSAMPROW outptr0, outptr1, outptr2, outptr3;
+  register JDIMENSION col;
+  JDIMENSION num_cols = cinfo->image_width;
+
+  while (--num_rows >= 0) {
+    inptr = *input_buf++;
+    outptr0 = output_buf[0][output_row];
+    outptr1 = output_buf[1][output_row];
+    outptr2 = output_buf[2][output_row];
+    outptr3 = output_buf[3][output_row];
+    output_row++;
+    for (col = 0; col < num_cols; col++) {
+      r = MAXJSAMPLE - GETJSAMPLE(inptr[0]);
+      g = MAXJSAMPLE - GETJSAMPLE(inptr[1]);
+      b = MAXJSAMPLE - GETJSAMPLE(inptr[2]);
+      /* K passes through as-is */
+      outptr3[col] = inptr[3];	/* don't need GETJSAMPLE here */
+      inptr += 4;
+      /* If the inputs are 0..MAXJSAMPLE, the outputs of these equations
+       * must be too; we do not need an explicit range-limiting operation.
+       * Hence the value being shifted is never negative, and we don't
+       * need the general RIGHT_SHIFT macro.
+       */
+      /* Y */
+      outptr0[col] = (JSAMPLE)
+		((ctab[r+R_Y_OFF] + ctab[g+G_Y_OFF] + ctab[b+B_Y_OFF])
+		 >> SCALEBITS);
+      /* Cb */
+      outptr1[col] = (JSAMPLE)
+		((ctab[r+R_CB_OFF] + ctab[g+G_CB_OFF] + ctab[b+B_CB_OFF])
+		 >> SCALEBITS);
+      /* Cr */
+      outptr2[col] = (JSAMPLE)
+		((ctab[r+R_CR_OFF] + ctab[g+G_CR_OFF] + ctab[b+B_CR_OFF])
+		 >> SCALEBITS);
+    }
+  }
+}
+
+
+/*
+ * Convert some rows of samples to the JPEG colorspace.
+ * This version handles grayscale output with no conversion.
+ * The source can be either plain grayscale or YCbCr (since Y == gray).
+ */
+
+METHODDEF void
+grayscale_convert (j_compress_ptr cinfo,
+		   JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+		   JDIMENSION output_row, int num_rows)
+{
+  register JSAMPROW inptr;
+  register JSAMPROW outptr;
+  register JDIMENSION col;
+  JDIMENSION num_cols = cinfo->image_width;
+  int instride = cinfo->input_components;
+
+  while (--num_rows >= 0) {
+    inptr = *input_buf++;
+    outptr = output_buf[0][output_row];
+    output_row++;
+    for (col = 0; col < num_cols; col++) {
+      outptr[col] = inptr[0];	/* don't need GETJSAMPLE() here */
+      inptr += instride;
+    }
+  }
+}
+
+
+/*
+ * Convert some rows of samples to the JPEG colorspace.
+ * This version handles multi-component colorspaces without conversion.
+ * We assume input_components == num_components.
+ */
+
+METHODDEF void
+null_convert (j_compress_ptr cinfo,
+	      JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+	      JDIMENSION output_row, int num_rows)
+{
+  register JSAMPROW inptr;
+  register JSAMPROW outptr;
+  register JDIMENSION col;
+  register int ci;
+  int nc = cinfo->num_components;
+  JDIMENSION num_cols = cinfo->image_width;
+
+  while (--num_rows >= 0) {
+    /* It seems fastest to make a separate pass for each component. */
+    for (ci = 0; ci < nc; ci++) {
+      inptr = *input_buf;
+      outptr = output_buf[ci][output_row];
+      for (col = 0; col < num_cols; col++) {
+	outptr[col] = inptr[ci]; /* don't need GETJSAMPLE() here */
+	inptr += nc;
+      }
+    }
+    input_buf++;
+    output_row++;
+  }
+}
+
+
+/*
+ * Empty method for start_pass.
+ */
+
+METHODDEF void
+null_method (j_compress_ptr cinfo)
+{
+  /* no work needed */
+}
+
+
+/*
+ * Module initialization routine for input colorspace conversion.
+ */
+
+GLOBAL void
+jinit_color_converter (j_compress_ptr cinfo)
+{
+  my_cconvert_ptr cconvert;
+
+  cconvert = (my_cconvert_ptr)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				SIZEOF(my_color_converter));
+  cinfo->cconvert = (struct jpeg_color_converter *) cconvert;
+  /* set start_pass to null method until we find out differently */
+  cconvert->pub.start_pass = null_method;
+
+  /* Make sure input_components agrees with in_color_space */
+  switch (cinfo->in_color_space) {
+  case JCS_GRAYSCALE:
+    if (cinfo->input_components != 1)
+      ERREXIT(cinfo, JERR_BAD_IN_COLORSPACE);
+    break;
+
+  case JCS_RGB:
+#if RGB_PIXELSIZE != 3
+    if (cinfo->input_components != RGB_PIXELSIZE)
+      ERREXIT(cinfo, JERR_BAD_IN_COLORSPACE);
+    break;
+#endif /* else share code with YCbCr */
+
+  case JCS_YCbCr:
+    if (cinfo->input_components != 3)
+      ERREXIT(cinfo, JERR_BAD_IN_COLORSPACE);
+    break;
+
+  case JCS_CMYK:
+  case JCS_YCCK:
+    if (cinfo->input_components != 4)
+      ERREXIT(cinfo, JERR_BAD_IN_COLORSPACE);
+    break;
+
+  default:			/* JCS_UNKNOWN can be anything */
+    if (cinfo->input_components < 1)
+      ERREXIT(cinfo, JERR_BAD_IN_COLORSPACE);
+    break;
+  }
+
+  /* Check num_components, set conversion method based on requested space */
+  switch (cinfo->jpeg_color_space) {
+  case JCS_GRAYSCALE:
+    if (cinfo->num_components != 1)
+      ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
+    if (cinfo->in_color_space == JCS_GRAYSCALE)
+      cconvert->pub.color_convert = grayscale_convert;
+    else if (cinfo->in_color_space == JCS_RGB) {
+      cconvert->pub.start_pass = rgb_ycc_start;
+      cconvert->pub.color_convert = rgb_gray_convert;
+    } else if (cinfo->in_color_space == JCS_YCbCr)
+      cconvert->pub.color_convert = grayscale_convert;
+    else
+      ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
+    break;
+
+  case JCS_RGB:
+    if (cinfo->num_components != 3)
+      ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
+    if (cinfo->in_color_space == JCS_RGB && RGB_PIXELSIZE == 3)
+      cconvert->pub.color_convert = null_convert;
+    else
+      ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
+    break;
+
+  case JCS_YCbCr:
+    if (cinfo->num_components != 3)
+      ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
+    if (cinfo->in_color_space == JCS_RGB) {
+      cconvert->pub.start_pass = rgb_ycc_start;
+      cconvert->pub.color_convert = rgb_ycc_convert;
+    } else if (cinfo->in_color_space == JCS_YCbCr)
+      cconvert->pub.color_convert = null_convert;
+    else
+      ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
+    break;
+
+  case JCS_CMYK:
+    if (cinfo->num_components != 4)
+      ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
+    if (cinfo->in_color_space == JCS_CMYK)
+      cconvert->pub.color_convert = null_convert;
+    else
+      ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
+    break;
+
+  case JCS_YCCK:
+    if (cinfo->num_components != 4)
+      ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
+    if (cinfo->in_color_space == JCS_CMYK) {
+      cconvert->pub.start_pass = rgb_ycc_start;
+      cconvert->pub.color_convert = cmyk_ycck_convert;
+    } else if (cinfo->in_color_space == JCS_YCCK)
+      cconvert->pub.color_convert = null_convert;
+    else
+      ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
+    break;
+
+  default:			/* allow null conversion of JCS_UNKNOWN */
+    if (cinfo->jpeg_color_space != cinfo->in_color_space ||
+	cinfo->num_components != cinfo->input_components)
+      ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
+    cconvert->pub.color_convert = null_convert;
+    break;
+  }
+}
diff --git a/codemp/jpeg-6/jcdctmgr.cpp b/codemp/jpeg-6/jcdctmgr.cpp
new file mode 100644
index 0000000..20eb4ad
--- /dev/null
+++ b/codemp/jpeg-6/jcdctmgr.cpp
@@ -0,0 +1,393 @@
+/*
+ * jcdctmgr.c
+ *
+ * Copyright (C) 1994-1995, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains the forward-DCT management logic.
+ * This code selects a particular DCT implementation to be used,
+ * and it performs related housekeeping chores including coefficient
+ * quantization.
+ */
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jdct.h"		/* Private declarations for DCT subsystem */
+
+
+/* Private subobject for this module */
+
+typedef struct {
+  struct jpeg_forward_dct pub;	/* public fields */
+
+  /* Pointer to the DCT routine actually in use */
+  forward_DCT_method_ptr do_dct;
+
+  /* The actual post-DCT divisors --- not identical to the quant table
+   * entries, because of scaling (especially for an unnormalized DCT).
+   * Each table is given in normal array order; note that this must
+   * be converted from the zigzag order of the quantization tables.
+   */
+  DCTELEM * divisors[NUM_QUANT_TBLS];
+
+#ifdef DCT_FLOAT_SUPPORTED
+  /* Same as above for the floating-point case. */
+  float_DCT_method_ptr do_float_dct;
+  FAST_FLOAT * float_divisors[NUM_QUANT_TBLS];
+#endif
+} my_fdct_controller;
+
+typedef my_fdct_controller * my_fdct_ptr;
+
+
+/*
+ * Initialize for a processing pass.
+ * Verify that all referenced Q-tables are present, and set up
+ * the divisor table for each one.
+ * In the current implementation, DCT of all components is done during
+ * the first pass, even if only some components will be output in the
+ * first scan.  Hence all components should be examined here.
+ */
+
+METHODDEF void
+start_pass_fdctmgr (j_compress_ptr cinfo)
+{
+  my_fdct_ptr fdct = (my_fdct_ptr) cinfo->fdct;
+  int ci, qtblno, i;
+  jpeg_component_info *compptr;
+  JQUANT_TBL * qtbl;
+#ifdef DCT_ISLOW_SUPPORTED
+  DCTELEM * dtbl;
+#endif
+
+  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+       ci++, compptr++) {
+    qtblno = compptr->quant_tbl_no;
+    /* Make sure specified quantization table is present */
+    if (qtblno < 0 || qtblno >= NUM_QUANT_TBLS ||
+	cinfo->quant_tbl_ptrs[qtblno] == NULL)
+      ERREXIT1(cinfo, JERR_NO_QUANT_TABLE, qtblno);
+    qtbl = cinfo->quant_tbl_ptrs[qtblno];
+    /* Compute divisors for this quant table */
+    /* We may do this more than once for same table, but it's not a big deal */
+    switch (cinfo->dct_method) {
+#ifdef DCT_ISLOW_SUPPORTED
+    case JDCT_ISLOW:
+      /* For LL&M IDCT method, divisors are equal to raw quantization
+       * coefficients multiplied by 8 (to counteract scaling).
+       */
+      if (fdct->divisors[qtblno] == NULL) {
+	fdct->divisors[qtblno] = (DCTELEM *)
+	  (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				      DCTSIZE2 * SIZEOF(DCTELEM));
+      }
+      dtbl = fdct->divisors[qtblno];
+      for (i = 0; i < DCTSIZE2; i++) {
+	dtbl[i] = ((DCTELEM) qtbl->quantval[jpeg_zigzag_order[i]]) << 3;
+      }
+      break;
+#endif
+#ifdef DCT_IFAST_SUPPORTED
+    case JDCT_IFAST:
+      {
+	/* For AA&N IDCT method, divisors are equal to quantization
+	 * coefficients scaled by scalefactor[row]*scalefactor[col], where
+	 *   scalefactor[0] = 1
+	 *   scalefactor[k] = cos(k*PI/16) * sqrt(2)    for k=1..7
+	 * We apply a further scale factor of 8.
+	 */
+#define CONST_BITS 14
+	static const INT16 aanscales[DCTSIZE2] = {
+	  /* precomputed values scaled up by 14 bits: in natural order */
+	  16384, 22725, 21407, 19266, 16384, 12873,  8867,  4520,
+	  22725, 31521, 29692, 26722, 22725, 17855, 12299,  6270,
+	  21407, 29692, 27969, 25172, 21407, 16819, 11585,  5906,
+	  19266, 26722, 25172, 22654, 19266, 15137, 10426,  5315,
+	  16384, 22725, 21407, 19266, 16384, 12873,  8867,  4520,
+	  12873, 17855, 16819, 15137, 12873, 10114,  6967,  3552,
+	   8867, 12299, 11585, 10426,  8867,  6967,  4799,  2446,
+	   4520,  6270,  5906,  5315,  4520,  3552,  2446,  1247
+	};
+	SHIFT_TEMPS
+
+	if (fdct->divisors[qtblno] == NULL) {
+	  fdct->divisors[qtblno] = (DCTELEM *)
+	    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+					DCTSIZE2 * SIZEOF(DCTELEM));
+	}
+	dtbl = fdct->divisors[qtblno];
+	for (i = 0; i < DCTSIZE2; i++) {
+	  dtbl[i] = (DCTELEM)
+	    DESCALE(MULTIPLY16V16((INT32) qtbl->quantval[jpeg_zigzag_order[i]],
+				  (INT32) aanscales[i]),
+		    CONST_BITS-3);
+	}
+      }
+      break;
+#endif
+#ifdef DCT_FLOAT_SUPPORTED
+    case JDCT_FLOAT:
+      {
+	/* For float AA&N IDCT method, divisors are equal to quantization
+	 * coefficients scaled by scalefactor[row]*scalefactor[col], where
+	 *   scalefactor[0] = 1
+	 *   scalefactor[k] = cos(k*PI/16) * sqrt(2)    for k=1..7
+	 * We apply a further scale factor of 8.
+	 * What's actually stored is 1/divisor so that the inner loop can
+	 * use a multiplication rather than a division.
+	 */
+	FAST_FLOAT * fdtbl;
+	int row, col;
+	static const double aanscalefactor[DCTSIZE] = {
+	  1.0, 1.387039845, 1.306562965, 1.175875602,
+	  1.0, 0.785694958, 0.541196100, 0.275899379
+	};
+
+	if (fdct->float_divisors[qtblno] == NULL) {
+	  fdct->float_divisors[qtblno] = (FAST_FLOAT *)
+	    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+					DCTSIZE2 * SIZEOF(FAST_FLOAT));
+	}
+	fdtbl = fdct->float_divisors[qtblno];
+	i = 0;
+	for (row = 0; row < DCTSIZE; row++) {
+	  for (col = 0; col < DCTSIZE; col++) {
+	    fdtbl[i] = (FAST_FLOAT)
+	      (1.0 / (((double) qtbl->quantval[jpeg_zigzag_order[i]] *
+		       aanscalefactor[row] * aanscalefactor[col] * 8.0)));
+	    i++;
+	  }
+	}
+      }
+      break;
+#endif
+    default:
+      ERREXIT(cinfo, JERR_NOT_COMPILED);
+      break;
+    }
+  }
+}
+
+
+/*
+ * Perform forward DCT on one or more blocks of a component.
+ *
+ * The input samples are taken from the sample_data[] array starting at
+ * position start_row/start_col, and moving to the right for any additional
+ * blocks. The quantized coefficients are returned in coef_blocks[].
+ */
+
+#if 0 // bk001204
+METHODDEF void
+forward_DCT (j_compress_ptr cinfo, jpeg_component_info * compptr,
+	     JSAMPARRAY sample_data, JBLOCKROW coef_blocks,
+	     JDIMENSION start_row, JDIMENSION start_col,
+	     JDIMENSION num_blocks)
+/* This version is used for integer DCT implementations. */
+{
+  /* This routine is heavily used, so it's worth coding it tightly. */
+  my_fdct_ptr fdct = (my_fdct_ptr) cinfo->fdct;
+  forward_DCT_method_ptr do_dct = fdct->do_dct;
+  DCTELEM * divisors = fdct->divisors[compptr->quant_tbl_no];
+  DCTELEM workspace[DCTSIZE2];	/* work area for FDCT subroutine */
+  JDIMENSION bi;
+
+  sample_data += start_row;	/* fold in the vertical offset once */
+
+  for (bi = 0; bi < num_blocks; bi++, start_col += DCTSIZE) {
+    /* Load data into workspace, applying unsigned->signed conversion */
+    { register DCTELEM *workspaceptr;
+      register JSAMPROW elemptr;
+      register int elemr;
+
+      workspaceptr = workspace;
+      for (elemr = 0; elemr < DCTSIZE; elemr++) {
+	elemptr = sample_data[elemr] + start_col;
+#if DCTSIZE == 8		/* unroll the inner loop */
+	*workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
+	*workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
+	*workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
+	*workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
+	*workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
+	*workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
+	*workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
+	*workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
+#else
+	{ register int elemc;
+	  for (elemc = DCTSIZE; elemc > 0; elemc--) {
+	    *workspaceptr++ = GETJSAMPLE(*elemptr++) - CENTERJSAMPLE;
+	  }
+	}
+#endif
+      }
+    }
+
+    /* Perform the DCT */
+    (*do_dct) (workspace);
+
+    /* Quantize/descale the coefficients, and store into coef_blocks[] */
+    { register DCTELEM temp, qval;
+      register int i;
+      register JCOEFPTR output_ptr = coef_blocks[bi];
+
+      for (i = 0; i < DCTSIZE2; i++) {
+	qval = divisors[i];
+	temp = workspace[i];
+	/* Divide the coefficient value by qval, ensuring proper rounding.
+	 * Since C does not specify the direction of rounding for negative
+	 * quotients, we have to force the dividend positive for portability.
+	 *
+	 * In most files, at least half of the output values will be zero
+	 * (at default quantization settings, more like three-quarters...)
+	 * so we should ensure that this case is fast.  On many machines,
+	 * a comparison is enough cheaper than a divide to make a special test
+	 * a win.  Since both inputs will be nonnegative, we need only test
+	 * for a < b to discover whether a/b is 0.
+	 * If your machine's division is fast enough, define FAST_DIVIDE.
+	 */
+#ifdef FAST_DIVIDE
+#define DIVIDE_BY(a,b)	a /= b
+#else
+#define DIVIDE_BY(a,b)	if (a >= b) a /= b; else a = 0
+#endif
+	if (temp < 0) {
+	  temp = -temp;
+	  temp += qval>>1;	/* for rounding */
+	  DIVIDE_BY(temp, qval);
+	  temp = -temp;
+	} else {
+	  temp += qval>>1;	/* for rounding */
+	  DIVIDE_BY(temp, qval);
+	}
+	output_ptr[i] = (JCOEF) temp;
+      }
+    }
+  }
+}
+#endif // 0
+
+#ifdef DCT_FLOAT_SUPPORTED
+
+METHODDEF void
+forward_DCT_float (j_compress_ptr cinfo, jpeg_component_info * compptr,
+		   JSAMPARRAY sample_data, JBLOCKROW coef_blocks,
+		   JDIMENSION start_row, JDIMENSION start_col,
+		   JDIMENSION num_blocks)
+/* This version is used for floating-point DCT implementations. */
+{
+  /* This routine is heavily used, so it's worth coding it tightly. */
+  my_fdct_ptr fdct = (my_fdct_ptr) cinfo->fdct;
+  float_DCT_method_ptr do_dct = fdct->do_float_dct;
+  FAST_FLOAT * divisors = fdct->float_divisors[compptr->quant_tbl_no];
+  FAST_FLOAT workspace[DCTSIZE2]; /* work area for FDCT subroutine */
+  JDIMENSION bi;
+
+  sample_data += start_row;	/* fold in the vertical offset once */
+
+  for (bi = 0; bi < num_blocks; bi++, start_col += DCTSIZE) {
+    /* Load data into workspace, applying unsigned->signed conversion */
+    { register FAST_FLOAT *workspaceptr;
+      register JSAMPROW elemptr;
+      register int elemr;
+
+      workspaceptr = workspace;
+      for (elemr = 0; elemr < DCTSIZE; elemr++) {
+	elemptr = sample_data[elemr] + start_col;
+#if DCTSIZE == 8		/* unroll the inner loop */
+	*workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
+	*workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
+	*workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
+	*workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
+	*workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
+	*workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
+	*workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
+	*workspaceptr++ = (FAST_FLOAT)(GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
+#else
+	{ register int elemc;
+	  for (elemc = DCTSIZE; elemc > 0; elemc--) {
+	    *workspaceptr++ = (FAST_FLOAT)
+	      (GETJSAMPLE(*elemptr++) - CENTERJSAMPLE);
+	  }
+	}
+#endif
+      }
+    }
+
+    /* Perform the DCT */
+    (*do_dct) (workspace);
+
+    /* Quantize/descale the coefficients, and store into coef_blocks[] */
+    { register FAST_FLOAT temp;
+      register int i;
+      register JCOEFPTR output_ptr = coef_blocks[bi];
+
+      for (i = 0; i < DCTSIZE2; i++) {
+	/* Apply the quantization and scaling factor */
+	temp = workspace[i] * divisors[i];
+	/* Round to nearest integer.
+	 * Since C does not specify the direction of rounding for negative
+	 * quotients, we have to force the dividend positive for portability.
+	 * The maximum coefficient size is +-16K (for 12-bit data), so this
+	 * code should work for either 16-bit or 32-bit ints.
+	 */
+	output_ptr[i] = (JCOEF) ((int) (temp + (FAST_FLOAT) 16384.5) - 16384);
+      }
+    }
+  }
+}
+
+#endif /* DCT_FLOAT_SUPPORTED */
+
+
+/*
+ * Initialize FDCT manager.
+ */
+
+GLOBAL void
+jinit_forward_dct (j_compress_ptr cinfo)
+{
+  my_fdct_ptr fdct;
+  int i;
+
+  fdct = (my_fdct_ptr)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				SIZEOF(my_fdct_controller));
+  cinfo->fdct = (struct jpeg_forward_dct *) fdct;
+  fdct->pub.start_pass = start_pass_fdctmgr;
+
+  switch (cinfo->dct_method) {
+#ifdef DCT_ISLOW_SUPPORTED
+  case JDCT_ISLOW:
+    fdct->pub.forward_DCT = forward_DCT;
+    fdct->do_dct = jpeg_fdct_islow;
+    break;
+#endif
+#ifdef DCT_IFAST_SUPPORTED
+  case JDCT_IFAST:
+    fdct->pub.forward_DCT = forward_DCT;
+    fdct->do_dct = jpeg_fdct_ifast;
+    break;
+#endif
+#ifdef DCT_FLOAT_SUPPORTED
+  case JDCT_FLOAT:
+    fdct->pub.forward_DCT = forward_DCT_float;
+    fdct->do_float_dct = jpeg_fdct_float;
+    break;
+#endif
+  default:
+    ERREXIT(cinfo, JERR_NOT_COMPILED);
+    break;
+  }
+
+  /* Mark divisor tables unallocated */
+  for (i = 0; i < NUM_QUANT_TBLS; i++) {
+    fdct->divisors[i] = NULL;
+#ifdef DCT_FLOAT_SUPPORTED
+    fdct->float_divisors[i] = NULL;
+#endif
+  }
+}
diff --git a/codemp/jpeg-6/jchuff.cpp b/codemp/jpeg-6/jchuff.cpp
new file mode 100644
index 0000000..c9c8ff1
--- /dev/null
+++ b/codemp/jpeg-6/jchuff.cpp
@@ -0,0 +1,848 @@
+/*
+ * jchuff.c
+ *
+ * Copyright (C) 1991-1995, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains Huffman entropy encoding routines.
+ *
+ * Much of the complexity here has to do with supporting output suspension.
+ * If the data destination module demands suspension, we want to be able to
+ * back up to the start of the current MCU.  To do this, we copy state
+ * variables into local working storage, and update them back to the
+ * permanent JPEG objects only upon successful completion of an MCU.
+ */
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jchuff.h"		/* Declarations shared with jcphuff.c */
+
+
+/* Expanded entropy encoder object for Huffman encoding.
+ *
+ * The savable_state subrecord contains fields that change within an MCU,
+ * but must not be updated permanently until we complete the MCU.
+ */
+
+typedef struct {
+  INT32 put_buffer;		/* current bit-accumulation buffer */
+  int put_bits;			/* # of bits now in it */
+  int last_dc_val[MAX_COMPS_IN_SCAN]; /* last DC coef for each component */
+} savable_state;
+
+/* This macro is to work around compilers with missing or broken
+ * structure assignment.  You'll need to fix this code if you have
+ * such a compiler and you change MAX_COMPS_IN_SCAN.
+ */
+
+#ifndef NO_STRUCT_ASSIGN
+#define ASSIGN_STATE(dest,src)  ((dest) = (src))
+#else
+#if MAX_COMPS_IN_SCAN == 4
+#define ASSIGN_STATE(dest,src)  \
+	((dest).put_buffer = (src).put_buffer, \
+	 (dest).put_bits = (src).put_bits, \
+	 (dest).last_dc_val[0] = (src).last_dc_val[0], \
+	 (dest).last_dc_val[1] = (src).last_dc_val[1], \
+	 (dest).last_dc_val[2] = (src).last_dc_val[2], \
+	 (dest).last_dc_val[3] = (src).last_dc_val[3])
+#endif
+#endif
+
+
+typedef struct {
+  struct jpeg_entropy_encoder pub; /* public fields */
+
+  savable_state saved;		/* Bit buffer & DC state at start of MCU */
+
+  /* These fields are NOT loaded into local working state. */
+  unsigned int restarts_to_go;	/* MCUs left in this restart interval */
+  int next_restart_num;		/* next restart number to write (0-7) */
+
+  /* Pointers to derived tables (these workspaces have image lifespan) */
+  c_derived_tbl * dc_derived_tbls[NUM_HUFF_TBLS];
+  c_derived_tbl * ac_derived_tbls[NUM_HUFF_TBLS];
+
+#ifdef ENTROPY_OPT_SUPPORTED	/* Statistics tables for optimization */
+  long * dc_count_ptrs[NUM_HUFF_TBLS];
+  long * ac_count_ptrs[NUM_HUFF_TBLS];
+#endif
+} huff_entropy_encoder;
+
+typedef huff_entropy_encoder * huff_entropy_ptr;
+
+/* Working state while writing an MCU.
+ * This struct contains all the fields that are needed by subroutines.
+ */
+
+typedef struct {
+  JOCTET * next_output_byte;	/* => next byte to write in buffer */
+  size_t free_in_buffer;	/* # of byte spaces remaining in buffer */
+  savable_state cur;		/* Current bit buffer & DC state */
+  j_compress_ptr cinfo;		/* dump_buffer needs access to this */
+} working_state;
+
+
+/* Forward declarations */
+METHODDEF boolean encode_mcu_huff JPP((j_compress_ptr cinfo,
+				       JBLOCKROW *MCU_data));
+METHODDEF void finish_pass_huff JPP((j_compress_ptr cinfo));
+#ifdef ENTROPY_OPT_SUPPORTED
+METHODDEF boolean encode_mcu_gather JPP((j_compress_ptr cinfo,
+					 JBLOCKROW *MCU_data));
+METHODDEF void finish_pass_gather JPP((j_compress_ptr cinfo));
+#endif
+
+
+/*
+ * Initialize for a Huffman-compressed scan.
+ * If gather_statistics is TRUE, we do not output anything during the scan,
+ * just count the Huffman symbols used and generate Huffman code tables.
+ */
+
+METHODDEF void
+start_pass_huff (j_compress_ptr cinfo, boolean gather_statistics)
+{
+  huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
+  int ci, dctbl, actbl;
+  jpeg_component_info * compptr;
+
+  if (gather_statistics) {
+#ifdef ENTROPY_OPT_SUPPORTED
+    entropy->pub.encode_mcu = encode_mcu_gather;
+    entropy->pub.finish_pass = finish_pass_gather;
+#else
+    ERREXIT(cinfo, JERR_NOT_COMPILED);
+#endif
+  } else {
+    entropy->pub.encode_mcu = encode_mcu_huff;
+    entropy->pub.finish_pass = finish_pass_huff;
+  }
+
+  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+    compptr = cinfo->cur_comp_info[ci];
+    dctbl = compptr->dc_tbl_no;
+    actbl = compptr->ac_tbl_no;
+    /* Make sure requested tables are present */
+    /* (In gather mode, tables need not be allocated yet) */
+    if (dctbl < 0 || dctbl >= NUM_HUFF_TBLS ||
+	(cinfo->dc_huff_tbl_ptrs[dctbl] == NULL && !gather_statistics))
+      ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, dctbl);
+    if (actbl < 0 || actbl >= NUM_HUFF_TBLS ||
+	(cinfo->ac_huff_tbl_ptrs[actbl] == NULL && !gather_statistics))
+      ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, actbl);
+    if (gather_statistics) {
+#ifdef ENTROPY_OPT_SUPPORTED
+      /* Allocate and zero the statistics tables */
+      /* Note that jpeg_gen_optimal_table expects 257 entries in each table! */
+      if (entropy->dc_count_ptrs[dctbl] == NULL)
+	entropy->dc_count_ptrs[dctbl] = (long *)
+	  (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				      257 * SIZEOF(long));
+      MEMZERO(entropy->dc_count_ptrs[dctbl], 257 * SIZEOF(long));
+      if (entropy->ac_count_ptrs[actbl] == NULL)
+	entropy->ac_count_ptrs[actbl] = (long *)
+	  (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				      257 * SIZEOF(long));
+      MEMZERO(entropy->ac_count_ptrs[actbl], 257 * SIZEOF(long));
+#endif
+    } else {
+      /* Compute derived values for Huffman tables */
+      /* We may do this more than once for a table, but it's not expensive */
+      jpeg_make_c_derived_tbl(cinfo, cinfo->dc_huff_tbl_ptrs[dctbl],
+			      & entropy->dc_derived_tbls[dctbl]);
+      jpeg_make_c_derived_tbl(cinfo, cinfo->ac_huff_tbl_ptrs[actbl],
+			      & entropy->ac_derived_tbls[actbl]);
+    }
+    /* Initialize DC predictions to 0 */
+    entropy->saved.last_dc_val[ci] = 0;
+  }
+
+  /* Initialize bit buffer to empty */
+  entropy->saved.put_buffer = 0;
+  entropy->saved.put_bits = 0;
+
+  /* Initialize restart stuff */
+  entropy->restarts_to_go = cinfo->restart_interval;
+  entropy->next_restart_num = 0;
+}
+
+
+/*
+ * Compute the derived values for a Huffman table.
+ * Note this is also used by jcphuff.c.
+ */
+
+GLOBAL void
+jpeg_make_c_derived_tbl (j_compress_ptr cinfo, JHUFF_TBL * htbl,
+			 c_derived_tbl ** pdtbl)
+{
+  c_derived_tbl *dtbl;
+  int p, i, l, lastp, si;
+  char huffsize[257];
+  unsigned int huffcode[257];
+  unsigned int code;
+
+  /* Allocate a workspace if we haven't already done so. */
+  if (*pdtbl == NULL)
+    *pdtbl = (c_derived_tbl *)
+      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				  SIZEOF(c_derived_tbl));
+  dtbl = *pdtbl;
+  
+  /* Figure C.1: make table of Huffman code length for each symbol */
+  /* Note that this is in code-length order. */
+
+  p = 0;
+  for (l = 1; l <= 16; l++) {
+    for (i = 1; i <= (int) htbl->bits[l]; i++)
+      huffsize[p++] = (char) l;
+  }
+  huffsize[p] = 0;
+  lastp = p;
+  
+  /* Figure C.2: generate the codes themselves */
+  /* Note that this is in code-length order. */
+  
+  code = 0;
+  si = huffsize[0];
+  p = 0;
+  while (huffsize[p]) {
+    while (((int) huffsize[p]) == si) {
+      huffcode[p++] = code;
+      code++;
+    }
+    code <<= 1;
+    si++;
+  }
+  
+  /* Figure C.3: generate encoding tables */
+  /* These are code and size indexed by symbol value */
+
+  /* Set any codeless symbols to have code length 0;
+   * this allows emit_bits to detect any attempt to emit such symbols.
+   */
+  MEMZERO(dtbl->ehufsi, SIZEOF(dtbl->ehufsi));
+
+  for (p = 0; p < lastp; p++) {
+    dtbl->ehufco[htbl->huffval[p]] = huffcode[p];
+    dtbl->ehufsi[htbl->huffval[p]] = huffsize[p];
+  }
+}
+
+
+/* Outputting bytes to the file */
+
+/* Emit a byte, taking 'action' if must suspend. */
+#define emit_byte(state,val,action)  \
+	{ *(state)->next_output_byte++ = (JOCTET) (val);  \
+	  if (--(state)->free_in_buffer == 0)  \
+	    if (! dump_buffer(state))  \
+	      { action; } }
+
+
+LOCAL boolean
+dump_buffer (working_state * state)
+/* Empty the output buffer; return TRUE if successful, FALSE if must suspend */
+{
+  struct jpeg_destination_mgr * dest = state->cinfo->dest;
+
+  if (! (*dest->empty_output_buffer) (state->cinfo))
+    return FALSE;
+  /* After a successful buffer dump, must reset buffer pointers */
+  state->next_output_byte = dest->next_output_byte;
+  state->free_in_buffer = dest->free_in_buffer;
+  return TRUE;
+}
+
+
+/* Outputting bits to the file */
+
+/* Only the right 24 bits of put_buffer are used; the valid bits are
+ * left-justified in this part.  At most 16 bits can be passed to emit_bits
+ * in one call, and we never retain more than 7 bits in put_buffer
+ * between calls, so 24 bits are sufficient.
+ */
+
+INLINE
+LOCAL boolean
+emit_bits (working_state * state, unsigned int code, int size)
+/* Emit some bits; return TRUE if successful, FALSE if must suspend */
+{
+  /* This routine is heavily used, so it's worth coding tightly. */
+  register INT32 put_buffer = (INT32) code;
+  register int put_bits = state->cur.put_bits;
+
+  /* if size is 0, caller used an invalid Huffman table entry */
+  if (size == 0)
+    ERREXIT(state->cinfo, JERR_HUFF_MISSING_CODE);
+
+  put_buffer &= (((INT32) 1)<<size) - 1; /* mask off any extra bits in code */
+  
+  put_bits += size;		/* new number of bits in buffer */
+  
+  put_buffer <<= 24 - put_bits; /* align incoming bits */
+
+  put_buffer |= state->cur.put_buffer; /* and merge with old buffer contents */
+  
+  while (put_bits >= 8) {
+    int c = (int) ((put_buffer >> 16) & 0xFF);
+    
+    emit_byte(state, c, return FALSE);
+    if (c == 0xFF) {		/* need to stuff a zero byte? */
+      emit_byte(state, 0, return FALSE);
+    }
+    put_buffer <<= 8;
+    put_bits -= 8;
+  }
+
+  state->cur.put_buffer = put_buffer; /* update state variables */
+  state->cur.put_bits = put_bits;
+
+  return TRUE;
+}
+
+
+LOCAL boolean
+flush_bits (working_state * state)
+{
+  if (! emit_bits(state, 0x7F, 7)) /* fill any partial byte with ones */
+    return FALSE;
+  state->cur.put_buffer = 0;	/* and reset bit-buffer to empty */
+  state->cur.put_bits = 0;
+  return TRUE;
+}
+
+
+/* Encode a single block's worth of coefficients */
+
+LOCAL boolean
+encode_one_block (working_state * state, JCOEFPTR block, int last_dc_val,
+		  c_derived_tbl *dctbl, c_derived_tbl *actbl)
+{
+  register int temp, temp2;
+  register int nbits;
+  register int k, r, i;
+  
+  /* Encode the DC coefficient difference per section F.1.2.1 */
+  
+  temp = temp2 = block[0] - last_dc_val;
+
+  if (temp < 0) {
+    temp = -temp;		/* temp is abs value of input */
+    /* For a negative input, want temp2 = bitwise complement of abs(input) */
+    /* This code assumes we are on a two's complement machine */
+    temp2--;
+  }
+  
+  /* Find the number of bits needed for the magnitude of the coefficient */
+  nbits = 0;
+  while (temp) {
+    nbits++;
+    temp >>= 1;
+  }
+  
+  /* Emit the Huffman-coded symbol for the number of bits */
+  if (! emit_bits(state, dctbl->ehufco[nbits], dctbl->ehufsi[nbits]))
+    return FALSE;
+
+  /* Emit that number of bits of the value, if positive, */
+  /* or the complement of its magnitude, if negative. */
+  if (nbits)			/* emit_bits rejects calls with size 0 */
+    if (! emit_bits(state, (unsigned int) temp2, nbits))
+      return FALSE;
+
+  /* Encode the AC coefficients per section F.1.2.2 */
+  
+  r = 0;			/* r = run length of zeros */
+  
+  for (k = 1; k < DCTSIZE2; k++) {
+    if ((temp = block[jpeg_natural_order[k]]) == 0) {
+      r++;
+    } else {
+      /* if run length > 15, must emit special run-length-16 codes (0xF0) */
+      while (r > 15) {
+	if (! emit_bits(state, actbl->ehufco[0xF0], actbl->ehufsi[0xF0]))
+	  return FALSE;
+	r -= 16;
+      }
+
+      temp2 = temp;
+      if (temp < 0) {
+	temp = -temp;		/* temp is abs value of input */
+	/* This code assumes we are on a two's complement machine */
+	temp2--;
+      }
+      
+      /* Find the number of bits needed for the magnitude of the coefficient */
+      nbits = 1;		/* there must be at least one 1 bit */
+      while ((temp >>= 1))
+	nbits++;
+      
+      /* Emit Huffman symbol for run length / number of bits */
+      i = (r << 4) + nbits;
+      if (! emit_bits(state, actbl->ehufco[i], actbl->ehufsi[i]))
+	return FALSE;
+
+      /* Emit that number of bits of the value, if positive, */
+      /* or the complement of its magnitude, if negative. */
+      if (! emit_bits(state, (unsigned int) temp2, nbits))
+	return FALSE;
+      
+      r = 0;
+    }
+  }
+
+  /* If the last coef(s) were zero, emit an end-of-block code */
+  if (r > 0)
+    if (! emit_bits(state, actbl->ehufco[0], actbl->ehufsi[0]))
+      return FALSE;
+
+  return TRUE;
+}
+
+
+/*
+ * Emit a restart marker & resynchronize predictions.
+ */
+
+LOCAL boolean
+emit_restart (working_state * state, int restart_num)
+{
+  int ci;
+
+  if (! flush_bits(state))
+    return FALSE;
+
+  emit_byte(state, 0xFF, return FALSE);
+  emit_byte(state, JPEG_RST0 + restart_num, return FALSE);
+
+  /* Re-initialize DC predictions to 0 */
+  for (ci = 0; ci < state->cinfo->comps_in_scan; ci++)
+    state->cur.last_dc_val[ci] = 0;
+
+  /* The restart counter is not updated until we successfully write the MCU. */
+
+  return TRUE;
+}
+
+
+/*
+ * Encode and output one MCU's worth of Huffman-compressed coefficients.
+ */
+
+METHODDEF boolean
+encode_mcu_huff (j_compress_ptr cinfo, JBLOCKROW *MCU_data)
+{
+  huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
+  working_state state;
+  int blkn, ci;
+  jpeg_component_info * compptr;
+
+  /* Load up working state */
+  state.next_output_byte = cinfo->dest->next_output_byte;
+  state.free_in_buffer = cinfo->dest->free_in_buffer;
+  ASSIGN_STATE(state.cur, entropy->saved);
+  state.cinfo = cinfo;
+
+  /* Emit restart marker if needed */
+  if (cinfo->restart_interval) {
+    if (entropy->restarts_to_go == 0)
+      if (! emit_restart(&state, entropy->next_restart_num))
+	return FALSE;
+  }
+
+  /* Encode the MCU data blocks */
+  for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
+    ci = cinfo->MCU_membership[blkn];
+    compptr = cinfo->cur_comp_info[ci];
+    if (! encode_one_block(&state,
+			   MCU_data[blkn][0], state.cur.last_dc_val[ci],
+			   entropy->dc_derived_tbls[compptr->dc_tbl_no],
+			   entropy->ac_derived_tbls[compptr->ac_tbl_no]))
+      return FALSE;
+    /* Update last_dc_val */
+    state.cur.last_dc_val[ci] = MCU_data[blkn][0][0];
+  }
+
+  /* Completed MCU, so update state */
+  cinfo->dest->next_output_byte = state.next_output_byte;
+  cinfo->dest->free_in_buffer = state.free_in_buffer;
+  ASSIGN_STATE(entropy->saved, state.cur);
+
+  /* Update restart-interval state too */
+  if (cinfo->restart_interval) {
+    if (entropy->restarts_to_go == 0) {
+      entropy->restarts_to_go = cinfo->restart_interval;
+      entropy->next_restart_num++;
+      entropy->next_restart_num &= 7;
+    }
+    entropy->restarts_to_go--;
+  }
+
+  return TRUE;
+}
+
+
+/*
+ * Finish up at the end of a Huffman-compressed scan.
+ */
+
+METHODDEF void
+finish_pass_huff (j_compress_ptr cinfo)
+{
+  huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
+  working_state state;
+
+  /* Load up working state ... flush_bits needs it */
+  state.next_output_byte = cinfo->dest->next_output_byte;
+  state.free_in_buffer = cinfo->dest->free_in_buffer;
+  ASSIGN_STATE(state.cur, entropy->saved);
+  state.cinfo = cinfo;
+
+  /* Flush out the last data */
+  if (! flush_bits(&state))
+    ERREXIT(cinfo, JERR_CANT_SUSPEND);
+
+  /* Update state */
+  cinfo->dest->next_output_byte = state.next_output_byte;
+  cinfo->dest->free_in_buffer = state.free_in_buffer;
+  ASSIGN_STATE(entropy->saved, state.cur);
+}
+
+
+/*
+ * Huffman coding optimization.
+ *
+ * This actually is optimization, in the sense that we find the best possible
+ * Huffman table(s) for the given data.  We first scan the supplied data and
+ * count the number of uses of each symbol that is to be Huffman-coded.
+ * (This process must agree with the code above.)  Then we build an
+ * optimal Huffman coding tree for the observed counts.
+ *
+ * The JPEG standard requires Huffman codes to be no more than 16 bits long.
+ * If some symbols have a very small but nonzero probability, the Huffman tree
+ * must be adjusted to meet the code length restriction.  We currently use
+ * the adjustment method suggested in the JPEG spec.  This method is *not*
+ * optimal; it may not choose the best possible limited-length code.  But
+ * since the symbols involved are infrequently used, it's not clear that
+ * going to extra trouble is worthwhile.
+ */
+
+#ifdef ENTROPY_OPT_SUPPORTED
+
+
+/* Process a single block's worth of coefficients */
+
+LOCAL void
+htest_one_block (JCOEFPTR block, int last_dc_val,
+		 long dc_counts[], long ac_counts[])
+{
+  register int temp;
+  register int nbits;
+  register int k, r;
+  
+  /* Encode the DC coefficient difference per section F.1.2.1 */
+  
+  temp = block[0] - last_dc_val;
+  if (temp < 0)
+    temp = -temp;
+  
+  /* Find the number of bits needed for the magnitude of the coefficient */
+  nbits = 0;
+  while (temp) {
+    nbits++;
+    temp >>= 1;
+  }
+
+  /* Count the Huffman symbol for the number of bits */
+  dc_counts[nbits]++;
+  
+  /* Encode the AC coefficients per section F.1.2.2 */
+  
+  r = 0;			/* r = run length of zeros */
+  
+  for (k = 1; k < DCTSIZE2; k++) {
+    if ((temp = block[jpeg_natural_order[k]]) == 0) {
+      r++;
+    } else {
+      /* if run length > 15, must emit special run-length-16 codes (0xF0) */
+      while (r > 15) {
+	ac_counts[0xF0]++;
+	r -= 16;
+      }
+      
+      /* Find the number of bits needed for the magnitude of the coefficient */
+      if (temp < 0)
+	temp = -temp;
+      
+      /* Find the number of bits needed for the magnitude of the coefficient */
+      nbits = 1;		/* there must be at least one 1 bit */
+      while ((temp >>= 1))
+	nbits++;
+      
+      /* Count Huffman symbol for run length / number of bits */
+      ac_counts[(r << 4) + nbits]++;
+      
+      r = 0;
+    }
+  }
+
+  /* If the last coef(s) were zero, emit an end-of-block code */
+  if (r > 0)
+    ac_counts[0]++;
+}
+
+
+/*
+ * Trial-encode one MCU's worth of Huffman-compressed coefficients.
+ * No data is actually output, so no suspension return is possible.
+ */
+
+METHODDEF boolean
+encode_mcu_gather (j_compress_ptr cinfo, JBLOCKROW *MCU_data)
+{
+  huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
+  int blkn, ci;
+  jpeg_component_info * compptr;
+
+  /* Take care of restart intervals if needed */
+  if (cinfo->restart_interval) {
+    if (entropy->restarts_to_go == 0) {
+      /* Re-initialize DC predictions to 0 */
+      for (ci = 0; ci < cinfo->comps_in_scan; ci++)
+	entropy->saved.last_dc_val[ci] = 0;
+      /* Update restart state */
+      entropy->restarts_to_go = cinfo->restart_interval;
+    }
+    entropy->restarts_to_go--;
+  }
+
+  for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
+    ci = cinfo->MCU_membership[blkn];
+    compptr = cinfo->cur_comp_info[ci];
+    htest_one_block(MCU_data[blkn][0], entropy->saved.last_dc_val[ci],
+		    entropy->dc_count_ptrs[compptr->dc_tbl_no],
+		    entropy->ac_count_ptrs[compptr->ac_tbl_no]);
+    entropy->saved.last_dc_val[ci] = MCU_data[blkn][0][0];
+  }
+
+  return TRUE;
+}
+
+
+/*
+ * Generate the optimal coding for the given counts, fill htbl.
+ * Note this is also used by jcphuff.c.
+ */
+
+GLOBAL void
+jpeg_gen_optimal_table (j_compress_ptr cinfo, JHUFF_TBL * htbl, long freq[])
+{
+#define MAX_CLEN 32		/* assumed maximum initial code length */
+  UINT8 bits[MAX_CLEN+1];	/* bits[k] = # of symbols with code length k */
+  int codesize[257];		/* codesize[k] = code length of symbol k */
+  int others[257];		/* next symbol in current branch of tree */
+  int c1, c2;
+  int p, i, j;
+  long v;
+
+  /* This algorithm is explained in section K.2 of the JPEG standard */
+
+  MEMZERO(bits, SIZEOF(bits));
+  MEMZERO(codesize, SIZEOF(codesize));
+  for (i = 0; i < 257; i++)
+    others[i] = -1;		/* init links to empty */
+  
+  freq[256] = 1;		/* make sure there is a nonzero count */
+  /* Including the pseudo-symbol 256 in the Huffman procedure guarantees
+   * that no real symbol is given code-value of all ones, because 256
+   * will be placed in the largest codeword category.
+   */
+
+  /* Huffman's basic algorithm to assign optimal code lengths to symbols */
+
+  for (;;) {
+    /* Find the smallest nonzero frequency, set c1 = its symbol */
+    /* In case of ties, take the larger symbol number */
+    c1 = -1;
+    v = 1000000000L;
+    for (i = 0; i <= 256; i++) {
+      if (freq[i] && freq[i] <= v) {
+	v = freq[i];
+	c1 = i;
+      }
+    }
+
+    /* Find the next smallest nonzero frequency, set c2 = its symbol */
+    /* In case of ties, take the larger symbol number */
+    c2 = -1;
+    v = 1000000000L;
+    for (i = 0; i <= 256; i++) {
+      if (freq[i] && freq[i] <= v && i != c1) {
+	v = freq[i];
+	c2 = i;
+      }
+    }
+
+    /* Done if we've merged everything into one frequency */
+    if (c2 < 0)
+      break;
+    
+    /* Else merge the two counts/trees */
+    freq[c1] += freq[c2];
+    freq[c2] = 0;
+
+    /* Increment the codesize of everything in c1's tree branch */
+    codesize[c1]++;
+    while (others[c1] >= 0) {
+      c1 = others[c1];
+      codesize[c1]++;
+    }
+    
+    others[c1] = c2;		/* chain c2 onto c1's tree branch */
+    
+    /* Increment the codesize of everything in c2's tree branch */
+    codesize[c2]++;
+    while (others[c2] >= 0) {
+      c2 = others[c2];
+      codesize[c2]++;
+    }
+  }
+
+  /* Now count the number of symbols of each code length */
+  for (i = 0; i <= 256; i++) {
+    if (codesize[i]) {
+      /* The JPEG standard seems to think that this can't happen, */
+      /* but I'm paranoid... */
+      if (codesize[i] > MAX_CLEN)
+	ERREXIT(cinfo, JERR_HUFF_CLEN_OVERFLOW);
+
+      bits[codesize[i]]++;
+    }
+  }
+
+  /* JPEG doesn't allow symbols with code lengths over 16 bits, so if the pure
+   * Huffman procedure assigned any such lengths, we must adjust the coding.
+   * Here is what the JPEG spec says about how this next bit works:
+   * Since symbols are paired for the longest Huffman code, the symbols are
+   * removed from this length category two at a time.  The prefix for the pair
+   * (which is one bit shorter) is allocated to one of the pair; then,
+   * skipping the BITS entry for that prefix length, a code word from the next
+   * shortest nonzero BITS entry is converted into a prefix for two code words
+   * one bit longer.
+   */
+  
+  for (i = MAX_CLEN; i > 16; i--) {
+    while (bits[i] > 0) {
+      j = i - 2;		/* find length of new prefix to be used */
+      while (bits[j] == 0)
+	j--;
+      
+      bits[i] -= 2;		/* remove two symbols */
+      bits[i-1]++;		/* one goes in this length */
+      bits[j+1] += 2;		/* two new symbols in this length */
+      bits[j]--;		/* symbol of this length is now a prefix */
+    }
+  }
+
+  /* Remove the count for the pseudo-symbol 256 from the largest codelength */
+  while (bits[i] == 0)		/* find largest codelength still in use */
+    i--;
+  bits[i]--;
+  
+  /* Return final symbol counts (only for lengths 0..16) */
+  MEMCOPY(htbl->bits, bits, SIZEOF(htbl->bits));
+  
+  /* Return a list of the symbols sorted by code length */
+  /* It's not real clear to me why we don't need to consider the codelength
+   * changes made above, but the JPEG spec seems to think this works.
+   */
+  p = 0;
+  for (i = 1; i <= MAX_CLEN; i++) {
+    for (j = 0; j <= 255; j++) {
+      if (codesize[j] == i) {
+	htbl->huffval[p] = (UINT8) j;
+	p++;
+      }
+    }
+  }
+
+  /* Set sent_table FALSE so updated table will be written to JPEG file. */
+  htbl->sent_table = FALSE;
+}
+
+
+/*
+ * Finish up a statistics-gathering pass and create the new Huffman tables.
+ */
+
+METHODDEF void
+finish_pass_gather (j_compress_ptr cinfo)
+{
+  huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
+  int ci, dctbl, actbl;
+  jpeg_component_info * compptr;
+  JHUFF_TBL **htblptr;
+  boolean did_dc[NUM_HUFF_TBLS];
+  boolean did_ac[NUM_HUFF_TBLS];
+
+  /* It's important not to apply jpeg_gen_optimal_table more than once
+   * per table, because it clobbers the input frequency counts!
+   */
+  MEMZERO(did_dc, SIZEOF(did_dc));
+  MEMZERO(did_ac, SIZEOF(did_ac));
+
+  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+    compptr = cinfo->cur_comp_info[ci];
+    dctbl = compptr->dc_tbl_no;
+    actbl = compptr->ac_tbl_no;
+    if (! did_dc[dctbl]) {
+      htblptr = & cinfo->dc_huff_tbl_ptrs[dctbl];
+      if (*htblptr == NULL)
+	*htblptr = jpeg_alloc_huff_table((j_common_ptr) cinfo);
+      jpeg_gen_optimal_table(cinfo, *htblptr, entropy->dc_count_ptrs[dctbl]);
+      did_dc[dctbl] = TRUE;
+    }
+    if (! did_ac[actbl]) {
+      htblptr = & cinfo->ac_huff_tbl_ptrs[actbl];
+      if (*htblptr == NULL)
+	*htblptr = jpeg_alloc_huff_table((j_common_ptr) cinfo);
+      jpeg_gen_optimal_table(cinfo, *htblptr, entropy->ac_count_ptrs[actbl]);
+      did_ac[actbl] = TRUE;
+    }
+  }
+}
+
+
+#endif /* ENTROPY_OPT_SUPPORTED */
+
+
+/*
+ * Module initialization routine for Huffman entropy encoding.
+ */
+
+GLOBAL void
+jinit_huff_encoder (j_compress_ptr cinfo)
+{
+  huff_entropy_ptr entropy;
+  int i;
+
+  entropy = (huff_entropy_ptr)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				SIZEOF(huff_entropy_encoder));
+  cinfo->entropy = (struct jpeg_entropy_encoder *) entropy;
+  entropy->pub.start_pass = start_pass_huff;
+
+  /* Mark tables unallocated */
+  for (i = 0; i < NUM_HUFF_TBLS; i++) {
+    entropy->dc_derived_tbls[i] = entropy->ac_derived_tbls[i] = NULL;
+#ifdef ENTROPY_OPT_SUPPORTED
+    entropy->dc_count_ptrs[i] = entropy->ac_count_ptrs[i] = NULL;
+#endif
+  }
+}
diff --git a/codemp/jpeg-6/jchuff.h b/codemp/jpeg-6/jchuff.h
new file mode 100644
index 0000000..0a81d54
--- /dev/null
+++ b/codemp/jpeg-6/jchuff.h
@@ -0,0 +1,34 @@
+/*
+ * jchuff.h
+ *
+ * Copyright (C) 1991-1995, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains declarations for Huffman entropy encoding routines
+ * that are shared between the sequential encoder (jchuff.c) and the
+ * progressive encoder (jcphuff.c).  No other modules need to see these.
+ */
+
+/* Derived data constructed for each Huffman table */
+
+typedef struct {
+  unsigned int ehufco[256];	/* code for each symbol */
+  char ehufsi[256];		/* length of code for each symbol */
+  /* If no code has been allocated for a symbol S, ehufsi[S] contains 0 */
+} c_derived_tbl;
+
+/* Short forms of external names for systems with brain-damaged linkers. */
+
+#ifdef NEED_SHORT_EXTERNAL_NAMES
+#define jpeg_make_c_derived_tbl	jMkCDerived
+#define jpeg_gen_optimal_table	jGenOptTbl
+#endif /* NEED_SHORT_EXTERNAL_NAMES */
+
+/* Expand a Huffman table definition into the derived format */
+EXTERN void jpeg_make_c_derived_tbl JPP((j_compress_ptr cinfo,
+				JHUFF_TBL * htbl, c_derived_tbl ** pdtbl));
+
+/* Generate an optimal table definition given the specified counts */
+EXTERN void jpeg_gen_optimal_table JPP((j_compress_ptr cinfo,
+					JHUFF_TBL * htbl, long freq[]));
diff --git a/codemp/jpeg-6/jcinit.cpp b/codemp/jpeg-6/jcinit.cpp
new file mode 100644
index 0000000..16e4415
--- /dev/null
+++ b/codemp/jpeg-6/jcinit.cpp
@@ -0,0 +1,74 @@
+/*
+ * jcinit.c
+ *
+ * Copyright (C) 1991-1995, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains initialization logic for the JPEG compressor.
+ * This routine is in charge of selecting the modules to be executed and
+ * making an initialization call to each one.
+ *
+ * Logically, this code belongs in jcmaster.c.  It's split out because
+ * linking this routine implies linking the entire compression library.
+ * For a transcoding-only application, we want to be able to use jcmaster.c
+ * without linking in the whole library.
+ */
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/*
+ * Master selection of compression modules.
+ * This is done once at the start of processing an image.  We determine
+ * which modules will be used and give them appropriate initialization calls.
+ */
+
+GLOBAL void
+jinit_compress_master (j_compress_ptr cinfo)
+{
+  /* Initialize master control (includes parameter checking/processing) */
+  jinit_c_master_control(cinfo, FALSE /* full compression */);
+
+  /* Preprocessing */
+  if (! cinfo->raw_data_in) {
+    jinit_color_converter(cinfo);
+    jinit_downsampler(cinfo);
+    jinit_c_prep_controller(cinfo, FALSE /* never need full buffer here */);
+  }
+  /* Forward DCT */
+  jinit_forward_dct(cinfo);
+  /* Entropy encoding: either Huffman or arithmetic coding. */
+  if (cinfo->arith_code) {
+    ERREXIT(cinfo, JERR_ARITH_NOTIMPL);
+  } else {
+    if (cinfo->progressive_mode) {
+#ifdef C_PROGRESSIVE_SUPPORTED
+      jinit_phuff_encoder(cinfo);
+#else
+      ERREXIT(cinfo, JERR_NOT_COMPILED);
+#endif
+    } else
+      jinit_huff_encoder(cinfo);
+  }
+
+  /* Need a full-image coefficient buffer in any multi-pass mode. */
+  jinit_c_coef_controller(cinfo,
+			  (cinfo->num_scans > 1 || cinfo->optimize_coding));
+  jinit_c_main_controller(cinfo, FALSE /* never need full buffer here */);
+
+  jinit_marker_writer(cinfo);
+
+  /* We can now tell the memory manager to allocate virtual arrays. */
+  (*cinfo->mem->realize_virt_arrays) ((j_common_ptr) cinfo);
+
+  /* Write the datastream header (SOI) immediately.
+   * Frame and scan headers are postponed till later.
+   * This lets application insert special markers after the SOI.
+   */
+  (*cinfo->marker->write_file_header) (cinfo);
+}
diff --git a/codemp/jpeg-6/jcmainct.cpp b/codemp/jpeg-6/jcmainct.cpp
new file mode 100644
index 0000000..40885e4
--- /dev/null
+++ b/codemp/jpeg-6/jcmainct.cpp
@@ -0,0 +1,298 @@
+/*
+ * jcmainct.c
+ *
+ * Copyright (C) 1994-1995, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains the main buffer controller for compression.
+ * The main buffer lies between the pre-processor and the JPEG
+ * compressor proper; it holds downsampled data in the JPEG colorspace.
+ */
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/* Note: currently, there is no operating mode in which a full-image buffer
+ * is needed at this step.  If there were, that mode could not be used with
+ * "raw data" input, since this module is bypassed in that case.  However,
+ * we've left the code here for possible use in special applications.
+ */
+#undef FULL_MAIN_BUFFER_SUPPORTED
+
+
+/* Private buffer controller object */
+
+typedef struct {
+  struct jpeg_c_main_controller pub; /* public fields */
+
+  JDIMENSION cur_iMCU_row;	/* number of current iMCU row */
+  JDIMENSION rowgroup_ctr;	/* counts row groups received in iMCU row */
+  boolean suspended;		/* remember if we suspended output */
+  J_BUF_MODE pass_mode;		/* current operating mode */
+
+  /* If using just a strip buffer, this points to the entire set of buffers
+   * (we allocate one for each component).  In the full-image case, this
+   * points to the currently accessible strips of the virtual arrays.
+   */
+  JSAMPARRAY buffer[MAX_COMPONENTS];
+
+#ifdef FULL_MAIN_BUFFER_SUPPORTED
+  /* If using full-image storage, this array holds pointers to virtual-array
+   * control blocks for each component.  Unused if not full-image storage.
+   */
+  jvirt_sarray_ptr whole_image[MAX_COMPONENTS];
+#endif
+} my_main_controller;
+
+typedef my_main_controller * my_main_ptr;
+
+
+/* Forward declarations */
+METHODDEF void process_data_simple_main
+	JPP((j_compress_ptr cinfo, JSAMPARRAY input_buf,
+	     JDIMENSION *in_row_ctr, JDIMENSION in_rows_avail));
+#ifdef FULL_MAIN_BUFFER_SUPPORTED
+METHODDEF void process_data_buffer_main
+	JPP((j_compress_ptr cinfo, JSAMPARRAY input_buf,
+	     JDIMENSION *in_row_ctr, JDIMENSION in_rows_avail));
+#endif
+
+
+/*
+ * Initialize for a processing pass.
+ */
+
+METHODDEF void
+start_pass_main (j_compress_ptr cinfo, J_BUF_MODE pass_mode)
+{
+  // bk001204 - don't use main...
+  my_main_ptr jmain = (my_main_ptr) cinfo->main;
+
+  /* Do nothing in raw-data mode. */
+  if (cinfo->raw_data_in)
+    return;
+
+  jmain->cur_iMCU_row = 0;	/* initialize counters */
+  jmain->rowgroup_ctr = 0;
+  jmain->suspended = FALSE;
+  jmain->pass_mode = pass_mode;	/* save mode for use by process_data */
+
+  switch (pass_mode) {
+  case JBUF_PASS_THRU:
+#ifdef FULL_MAIN_BUFFER_SUPPORTED
+    if (jmain->whole_image[0] != NULL)
+      ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+#endif
+    jmain->pub.process_data = process_data_simple_main;
+    break;
+#ifdef FULL_MAIN_BUFFER_SUPPORTED
+  case JBUF_SAVE_SOURCE:
+  case JBUF_CRANK_DEST:
+  case JBUF_SAVE_AND_PASS:
+    if (jmain->whole_image[0] == NULL)
+      ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+    jmain->pub.process_data = process_data_buffer_main;
+    break;
+#endif
+  default:
+    ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+    break;
+  }
+}
+
+
+/*
+ * Process some data.
+ * This routine handles the simple pass-through mode,
+ * where we have only a strip buffer.
+ */
+
+METHODDEF void
+process_data_simple_main (j_compress_ptr cinfo,
+			  JSAMPARRAY input_buf, JDIMENSION *in_row_ctr,
+			  JDIMENSION in_rows_avail)
+{
+  // bk001204 - don't use main
+  my_main_ptr jmain = (my_main_ptr) cinfo->main;
+
+  while (jmain->cur_iMCU_row < cinfo->total_iMCU_rows) {
+    /* Read input data if we haven't filled the main buffer yet */
+    if (jmain->rowgroup_ctr < DCTSIZE)
+      (*cinfo->prep->pre_process_data) (cinfo,
+					input_buf, in_row_ctr, in_rows_avail,
+					jmain->buffer, &jmain->rowgroup_ctr,
+					(JDIMENSION) DCTSIZE);
+
+    /* If we don't have a full iMCU row buffered, return to application for
+     * more data.  Note that preprocessor will always pad to fill the iMCU row
+     * at the bottom of the image.
+     */
+    if (jmain->rowgroup_ctr != DCTSIZE)
+      return;
+
+    /* Send the completed row to the compressor */
+    if (! (*cinfo->coef->compress_data) (cinfo, jmain->buffer)) {
+      /* If compressor did not consume the whole row, then we must need to
+       * suspend processing and return to the application.  In this situation
+       * we pretend we didn't yet consume the last input row; otherwise, if
+       * it happened to be the last row of the image, the application would
+       * think we were done.
+       */
+      if (! jmain->suspended) {
+	(*in_row_ctr)--;
+	jmain->suspended = TRUE;
+      }
+      return;
+    }
+    /* We did finish the row.  Undo our little suspension hack if a previous
+     * call suspended; then mark the main buffer empty.
+     */
+    if (jmain->suspended) {
+      (*in_row_ctr)++;
+      jmain->suspended = FALSE;
+    }
+    jmain->rowgroup_ctr = 0;
+    jmain->cur_iMCU_row++;
+  }
+}
+
+
+#ifdef FULL_MAIN_BUFFER_SUPPORTED
+
+/*
+ * Process some data.
+ * This routine handles all of the modes that use a full-size buffer.
+ */
+
+METHODDEF void
+process_data_buffer_main (j_compress_ptr cinfo,
+			  JSAMPARRAY input_buf, JDIMENSION *in_row_ctr,
+			  JDIMENSION in_rows_avail)
+{
+  my_main_ptr main = (my_main_ptr) cinfo->main;
+  int ci;
+  jpeg_component_info *compptr;
+  boolean writing = (main->pass_mode != JBUF_CRANK_DEST);
+
+  while (main->cur_iMCU_row < cinfo->total_iMCU_rows) {
+    /* Realign the virtual buffers if at the start of an iMCU row. */
+    if (main->rowgroup_ctr == 0) {
+      for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+	   ci++, compptr++) {
+	main->buffer[ci] = (*cinfo->mem->access_virt_sarray)
+	  ((j_common_ptr) cinfo, main->whole_image[ci],
+	   main->cur_iMCU_row * (compptr->v_samp_factor * DCTSIZE),
+	   (JDIMENSION) (compptr->v_samp_factor * DCTSIZE), writing);
+      }
+      /* In a read pass, pretend we just read some source data. */
+      if (! writing) {
+	*in_row_ctr += cinfo->max_v_samp_factor * DCTSIZE;
+	main->rowgroup_ctr = DCTSIZE;
+      }
+    }
+
+    /* If a write pass, read input data until the current iMCU row is full. */
+    /* Note: preprocessor will pad if necessary to fill the last iMCU row. */
+    if (writing) {
+      (*cinfo->prep->pre_process_data) (cinfo,
+					input_buf, in_row_ctr, in_rows_avail,
+					main->buffer, &main->rowgroup_ctr,
+					(JDIMENSION) DCTSIZE);
+      /* Return to application if we need more data to fill the iMCU row. */
+      if (main->rowgroup_ctr < DCTSIZE)
+	return;
+    }
+
+    /* Emit data, unless this is a sink-only pass. */
+    if (main->pass_mode != JBUF_SAVE_SOURCE) {
+      if (! (*cinfo->coef->compress_data) (cinfo, main->buffer)) {
+	/* If compressor did not consume the whole row, then we must need to
+	 * suspend processing and return to the application.  In this situation
+	 * we pretend we didn't yet consume the last input row; otherwise, if
+	 * it happened to be the last row of the image, the application would
+	 * think we were done.
+	 */
+	if (! main->suspended) {
+	  (*in_row_ctr)--;
+	  main->suspended = TRUE;
+	}
+	return;
+      }
+      /* We did finish the row.  Undo our little suspension hack if a previous
+       * call suspended; then mark the main buffer empty.
+       */
+      if (main->suspended) {
+	(*in_row_ctr)++;
+	main->suspended = FALSE;
+      }
+    }
+
+    /* If get here, we are done with this iMCU row.  Mark buffer empty. */
+    main->rowgroup_ctr = 0;
+    main->cur_iMCU_row++;
+  }
+}
+
+#endif /* FULL_MAIN_BUFFER_SUPPORTED */
+
+
+/*
+ * Initialize main buffer controller.
+ */
+
+GLOBAL void
+jinit_c_main_controller (j_compress_ptr cinfo, boolean need_full_buffer)
+{
+  // bk001204 - don't use main
+  my_main_ptr jmain;
+  int ci;
+  jpeg_component_info *compptr;
+
+  jmain = (my_main_ptr)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				SIZEOF(my_main_controller));
+  cinfo->main = (struct jpeg_c_main_controller *) jmain;
+  jmain->pub.start_pass = start_pass_main;
+
+  /* We don't need to create a buffer in raw-data mode. */
+  if (cinfo->raw_data_in)
+    return;
+
+  /* Create the buffer.  It holds downsampled data, so each component
+   * may be of a different size.
+   */
+  if (need_full_buffer) {
+#ifdef FULL_MAIN_BUFFER_SUPPORTED
+    /* Allocate a full-image virtual array for each component */
+    /* Note we pad the bottom to a multiple of the iMCU height */
+    for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+	 ci++, compptr++) {
+      jmain->whole_image[ci] = (*cinfo->mem->request_virt_sarray)
+	((j_common_ptr) cinfo, JPOOL_IMAGE, FALSE,
+	 compptr->width_in_blocks * DCTSIZE,
+	 (JDIMENSION) jround_up((long) compptr->height_in_blocks,
+				(long) compptr->v_samp_factor) * DCTSIZE,
+	 (JDIMENSION) (compptr->v_samp_factor * DCTSIZE));
+    }
+#else
+    ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+#endif
+  } else {
+#ifdef FULL_MAIN_BUFFER_SUPPORTED
+    jmain->whole_image[0] = NULL; /* flag for no virtual arrays */
+#endif
+    /* Allocate a strip buffer for each component */
+    for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+	 ci++, compptr++) {
+      jmain->buffer[ci] = (*cinfo->mem->alloc_sarray)
+	((j_common_ptr) cinfo, JPOOL_IMAGE,
+	 compptr->width_in_blocks * DCTSIZE,
+	 (JDIMENSION) (compptr->v_samp_factor * DCTSIZE));
+    }
+  }
+}
diff --git a/codemp/jpeg-6/jcmarker.cpp b/codemp/jpeg-6/jcmarker.cpp
new file mode 100644
index 0000000..1d9c3be
--- /dev/null
+++ b/codemp/jpeg-6/jcmarker.cpp
@@ -0,0 +1,641 @@
+/*
+ * jcmarker.c
+ *
+ * Copyright (C) 1991-1995, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains routines to write JPEG datastream markers.
+ */
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+typedef enum {			/* JPEG marker codes */
+  M_SOF0  = 0xc0,
+  M_SOF1  = 0xc1,
+  M_SOF2  = 0xc2,
+  M_SOF3  = 0xc3,
+  
+  M_SOF5  = 0xc5,
+  M_SOF6  = 0xc6,
+  M_SOF7  = 0xc7,
+  
+  M_JPG   = 0xc8,
+  M_SOF9  = 0xc9,
+  M_SOF10 = 0xca,
+  M_SOF11 = 0xcb,
+  
+  M_SOF13 = 0xcd,
+  M_SOF14 = 0xce,
+  M_SOF15 = 0xcf,
+  
+  M_DHT   = 0xc4,
+  
+  M_DAC   = 0xcc,
+  
+  M_RST0  = 0xd0,
+  M_RST1  = 0xd1,
+  M_RST2  = 0xd2,
+  M_RST3  = 0xd3,
+  M_RST4  = 0xd4,
+  M_RST5  = 0xd5,
+  M_RST6  = 0xd6,
+  M_RST7  = 0xd7,
+  
+  M_SOI   = 0xd8,
+  M_EOI   = 0xd9,
+  M_SOS   = 0xda,
+  M_DQT   = 0xdb,
+  M_DNL   = 0xdc,
+  M_DRI   = 0xdd,
+  M_DHP   = 0xde,
+  M_EXP   = 0xdf,
+  
+  M_APP0  = 0xe0,
+  M_APP1  = 0xe1,
+  M_APP2  = 0xe2,
+  M_APP3  = 0xe3,
+  M_APP4  = 0xe4,
+  M_APP5  = 0xe5,
+  M_APP6  = 0xe6,
+  M_APP7  = 0xe7,
+  M_APP8  = 0xe8,
+  M_APP9  = 0xe9,
+  M_APP10 = 0xea,
+  M_APP11 = 0xeb,
+  M_APP12 = 0xec,
+  M_APP13 = 0xed,
+  M_APP14 = 0xee,
+  M_APP15 = 0xef,
+  
+  M_JPG0  = 0xf0,
+  M_JPG13 = 0xfd,
+  M_COM   = 0xfe,
+  
+  M_TEM   = 0x01,
+  
+  M_ERROR = 0x100
+} JPEG_MARKER;
+
+
+/*
+ * Basic output routines.
+ *
+ * Note that we do not support suspension while writing a marker.
+ * Therefore, an application using suspension must ensure that there is
+ * enough buffer space for the initial markers (typ. 600-700 bytes) before
+ * calling jpeg_start_compress, and enough space to write the trailing EOI
+ * (a few bytes) before calling jpeg_finish_compress.  Multipass compression
+ * modes are not supported at all with suspension, so those two are the only
+ * points where markers will be written.
+ */
+
+LOCAL void
+emit_byte (j_compress_ptr cinfo, int val)
+/* Emit a byte */
+{
+  struct jpeg_destination_mgr * dest = cinfo->dest;
+
+  *(dest->next_output_byte)++ = (JOCTET) val;
+  if (--dest->free_in_buffer == 0) {
+    if (! (*dest->empty_output_buffer) (cinfo))
+      ERREXIT(cinfo, JERR_CANT_SUSPEND);
+  }
+}
+
+
+LOCAL void
+emit_marker (j_compress_ptr cinfo, JPEG_MARKER mark)
+/* Emit a marker code */
+{
+  emit_byte(cinfo, 0xFF);
+  emit_byte(cinfo, (int) mark);
+}
+
+
+LOCAL void
+emit_2bytes (j_compress_ptr cinfo, int value)
+/* Emit a 2-byte integer; these are always MSB first in JPEG files */
+{
+  emit_byte(cinfo, (value >> 8) & 0xFF);
+  emit_byte(cinfo, value & 0xFF);
+}
+
+
+/*
+ * Routines to write specific marker types.
+ */
+
+LOCAL int
+emit_dqt (j_compress_ptr cinfo, int index)
+/* Emit a DQT marker */
+/* Returns the precision used (0 = 8bits, 1 = 16bits) for baseline checking */
+{
+  JQUANT_TBL * qtbl = cinfo->quant_tbl_ptrs[index];
+  int prec;
+  int i;
+
+  if (qtbl == NULL)
+    ERREXIT1(cinfo, JERR_NO_QUANT_TABLE, index);
+
+  prec = 0;
+  for (i = 0; i < DCTSIZE2; i++) {
+    if (qtbl->quantval[i] > 255)
+      prec = 1;
+  }
+
+  if (! qtbl->sent_table) {
+    emit_marker(cinfo, M_DQT);
+
+    emit_2bytes(cinfo, prec ? DCTSIZE2*2 + 1 + 2 : DCTSIZE2 + 1 + 2);
+
+    emit_byte(cinfo, index + (prec<<4));
+
+    for (i = 0; i < DCTSIZE2; i++) {
+      if (prec)
+	emit_byte(cinfo, qtbl->quantval[i] >> 8);
+      emit_byte(cinfo, qtbl->quantval[i] & 0xFF);
+    }
+
+    qtbl->sent_table = TRUE;
+  }
+
+  return prec;
+}
+
+
+LOCAL void
+emit_dht (j_compress_ptr cinfo, int index, boolean is_ac)
+/* Emit a DHT marker */
+{
+  JHUFF_TBL * htbl;
+  int length, i;
+  
+  if (is_ac) {
+    htbl = cinfo->ac_huff_tbl_ptrs[index];
+    index += 0x10;		/* output index has AC bit set */
+  } else {
+    htbl = cinfo->dc_huff_tbl_ptrs[index];
+  }
+
+  if (htbl == NULL)
+    ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, index);
+  
+  if (! htbl->sent_table) {
+    emit_marker(cinfo, M_DHT);
+    
+    length = 0;
+    for (i = 1; i <= 16; i++)
+      length += htbl->bits[i];
+    
+    emit_2bytes(cinfo, length + 2 + 1 + 16);
+    emit_byte(cinfo, index);
+    
+    for (i = 1; i <= 16; i++)
+      emit_byte(cinfo, htbl->bits[i]);
+    
+    for (i = 0; i < length; i++)
+      emit_byte(cinfo, htbl->huffval[i]);
+    
+    htbl->sent_table = TRUE;
+  }
+}
+
+
+LOCAL void
+emit_dac (j_compress_ptr cinfo)
+/* Emit a DAC marker */
+/* Since the useful info is so small, we want to emit all the tables in */
+/* one DAC marker.  Therefore this routine does its own scan of the table. */
+{
+#ifdef C_ARITH_CODING_SUPPORTED
+  char dc_in_use[NUM_ARITH_TBLS];
+  char ac_in_use[NUM_ARITH_TBLS];
+  int length, i;
+  jpeg_component_info *compptr;
+  
+  for (i = 0; i < NUM_ARITH_TBLS; i++)
+    dc_in_use[i] = ac_in_use[i] = 0;
+  
+  for (i = 0; i < cinfo->comps_in_scan; i++) {
+    compptr = cinfo->cur_comp_info[i];
+    dc_in_use[compptr->dc_tbl_no] = 1;
+    ac_in_use[compptr->ac_tbl_no] = 1;
+  }
+  
+  length = 0;
+  for (i = 0; i < NUM_ARITH_TBLS; i++)
+    length += dc_in_use[i] + ac_in_use[i];
+  
+  emit_marker(cinfo, M_DAC);
+  
+  emit_2bytes(cinfo, length*2 + 2);
+  
+  for (i = 0; i < NUM_ARITH_TBLS; i++) {
+    if (dc_in_use[i]) {
+      emit_byte(cinfo, i);
+      emit_byte(cinfo, cinfo->arith_dc_L[i] + (cinfo->arith_dc_U[i]<<4));
+    }
+    if (ac_in_use[i]) {
+      emit_byte(cinfo, i + 0x10);
+      emit_byte(cinfo, cinfo->arith_ac_K[i]);
+    }
+  }
+#endif /* C_ARITH_CODING_SUPPORTED */
+}
+
+
+LOCAL void
+emit_dri (j_compress_ptr cinfo)
+/* Emit a DRI marker */
+{
+  emit_marker(cinfo, M_DRI);
+  
+  emit_2bytes(cinfo, 4);	/* fixed length */
+
+  emit_2bytes(cinfo, (int) cinfo->restart_interval);
+}
+
+
+LOCAL void
+emit_sof (j_compress_ptr cinfo, JPEG_MARKER code)
+/* Emit a SOF marker */
+{
+  int ci;
+  jpeg_component_info *compptr;
+  
+  emit_marker(cinfo, code);
+  
+  emit_2bytes(cinfo, 3 * cinfo->num_components + 2 + 5 + 1); /* length */
+
+  /* Make sure image isn't bigger than SOF field can handle */
+  if ((long) cinfo->image_height > 65535L ||
+      (long) cinfo->image_width > 65535L)
+    ERREXIT1(cinfo, JERR_IMAGE_TOO_BIG, (unsigned int) 65535);
+
+  emit_byte(cinfo, cinfo->data_precision);
+  emit_2bytes(cinfo, (int) cinfo->image_height);
+  emit_2bytes(cinfo, (int) cinfo->image_width);
+
+  emit_byte(cinfo, cinfo->num_components);
+
+  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+       ci++, compptr++) {
+    emit_byte(cinfo, compptr->component_id);
+    emit_byte(cinfo, (compptr->h_samp_factor << 4) + compptr->v_samp_factor);
+    emit_byte(cinfo, compptr->quant_tbl_no);
+  }
+}
+
+
+LOCAL void
+emit_sos (j_compress_ptr cinfo)
+/* Emit a SOS marker */
+{
+  int i, td, ta;
+  jpeg_component_info *compptr;
+  
+  emit_marker(cinfo, M_SOS);
+  
+  emit_2bytes(cinfo, 2 * cinfo->comps_in_scan + 2 + 1 + 3); /* length */
+  
+  emit_byte(cinfo, cinfo->comps_in_scan);
+  
+  for (i = 0; i < cinfo->comps_in_scan; i++) {
+    compptr = cinfo->cur_comp_info[i];
+    emit_byte(cinfo, compptr->component_id);
+    td = compptr->dc_tbl_no;
+    ta = compptr->ac_tbl_no;
+    if (cinfo->progressive_mode) {
+      /* Progressive mode: only DC or only AC tables are used in one scan;
+       * furthermore, Huffman coding of DC refinement uses no table at all.
+       * We emit 0 for unused field(s); this is recommended by the P&M text
+       * but does not seem to be specified in the standard.
+       */
+      if (cinfo->Ss == 0) {
+	ta = 0;			/* DC scan */
+	if (cinfo->Ah != 0 && !cinfo->arith_code)
+	  td = 0;		/* no DC table either */
+      } else {
+	td = 0;			/* AC scan */
+      }
+    }
+    emit_byte(cinfo, (td << 4) + ta);
+  }
+
+  emit_byte(cinfo, cinfo->Ss);
+  emit_byte(cinfo, cinfo->Se);
+  emit_byte(cinfo, (cinfo->Ah << 4) + cinfo->Al);
+}
+
+
+LOCAL void
+emit_jfif_app0 (j_compress_ptr cinfo)
+/* Emit a JFIF-compliant APP0 marker */
+{
+  /*
+   * Length of APP0 block	(2 bytes)
+   * Block ID			(4 bytes - ASCII "JFIF")
+   * Zero byte			(1 byte to terminate the ID string)
+   * Version Major, Minor	(2 bytes - 0x01, 0x01)
+   * Units			(1 byte - 0x00 = none, 0x01 = inch, 0x02 = cm)
+   * Xdpu			(2 bytes - dots per unit horizontal)
+   * Ydpu			(2 bytes - dots per unit vertical)
+   * Thumbnail X size		(1 byte)
+   * Thumbnail Y size		(1 byte)
+   */
+  
+  emit_marker(cinfo, M_APP0);
+  
+  emit_2bytes(cinfo, 2 + 4 + 1 + 2 + 1 + 2 + 2 + 1 + 1); /* length */
+
+  emit_byte(cinfo, 0x4A);	/* Identifier: ASCII "JFIF" */
+  emit_byte(cinfo, 0x46);
+  emit_byte(cinfo, 0x49);
+  emit_byte(cinfo, 0x46);
+  emit_byte(cinfo, 0);
+  /* We currently emit version code 1.01 since we use no 1.02 features.
+   * This may avoid complaints from some older decoders.
+   */
+  emit_byte(cinfo, 1);		/* Major version */
+  emit_byte(cinfo, 1);		/* Minor version */
+  emit_byte(cinfo, cinfo->density_unit); /* Pixel size information */
+  emit_2bytes(cinfo, (int) cinfo->X_density);
+  emit_2bytes(cinfo, (int) cinfo->Y_density);
+  emit_byte(cinfo, 0);		/* No thumbnail image */
+  emit_byte(cinfo, 0);
+}
+
+
+LOCAL void
+emit_adobe_app14 (j_compress_ptr cinfo)
+/* Emit an Adobe APP14 marker */
+{
+  /*
+   * Length of APP14 block	(2 bytes)
+   * Block ID			(5 bytes - ASCII "Adobe")
+   * Version Number		(2 bytes - currently 100)
+   * Flags0			(2 bytes - currently 0)
+   * Flags1			(2 bytes - currently 0)
+   * Color transform		(1 byte)
+   *
+   * Although Adobe TN 5116 mentions Version = 101, all the Adobe files
+   * now in circulation seem to use Version = 100, so that's what we write.
+   *
+   * We write the color transform byte as 1 if the JPEG color space is
+   * YCbCr, 2 if it's YCCK, 0 otherwise.  Adobe's definition has to do with
+   * whether the encoder performed a transformation, which is pretty useless.
+   */
+  
+  emit_marker(cinfo, M_APP14);
+  
+  emit_2bytes(cinfo, 2 + 5 + 2 + 2 + 2 + 1); /* length */
+
+  emit_byte(cinfo, 0x41);	/* Identifier: ASCII "Adobe" */
+  emit_byte(cinfo, 0x64);
+  emit_byte(cinfo, 0x6F);
+  emit_byte(cinfo, 0x62);
+  emit_byte(cinfo, 0x65);
+  emit_2bytes(cinfo, 100);	/* Version */
+  emit_2bytes(cinfo, 0);	/* Flags0 */
+  emit_2bytes(cinfo, 0);	/* Flags1 */
+  switch (cinfo->jpeg_color_space) {
+  case JCS_YCbCr:
+    emit_byte(cinfo, 1);	/* Color transform = 1 */
+    break;
+  case JCS_YCCK:
+    emit_byte(cinfo, 2);	/* Color transform = 2 */
+    break;
+  default:
+    emit_byte(cinfo, 0);	/* Color transform = 0 */
+    break;
+  }
+}
+
+
+/*
+ * This routine is exported for possible use by applications.
+ * The intended use is to emit COM or APPn markers after calling
+ * jpeg_start_compress() and before the first jpeg_write_scanlines() call
+ * (hence, after write_file_header but before write_frame_header).
+ * Other uses are not guaranteed to produce desirable results.
+ */
+
+METHODDEF void
+write_any_marker (j_compress_ptr cinfo, int marker,
+		  const JOCTET *dataptr, unsigned int datalen)
+/* Emit an arbitrary marker with parameters */
+{
+  if (datalen <= (unsigned int) 65533) { /* safety check */
+    emit_marker(cinfo, (JPEG_MARKER) marker);
+  
+    emit_2bytes(cinfo, (int) (datalen + 2)); /* total length */
+
+    while (datalen--) {
+      emit_byte(cinfo, *dataptr);
+      dataptr++;
+    }
+  }
+}
+
+
+/*
+ * Write datastream header.
+ * This consists of an SOI and optional APPn markers.
+ * We recommend use of the JFIF marker, but not the Adobe marker,
+ * when using YCbCr or grayscale data.  The JFIF marker should NOT
+ * be used for any other JPEG colorspace.  The Adobe marker is helpful
+ * to distinguish RGB, CMYK, and YCCK colorspaces.
+ * Note that an application can write additional header markers after
+ * jpeg_start_compress returns.
+ */
+
+METHODDEF void
+write_file_header (j_compress_ptr cinfo)
+{
+  emit_marker(cinfo, M_SOI);	/* first the SOI */
+
+  if (cinfo->write_JFIF_header)	/* next an optional JFIF APP0 */
+    emit_jfif_app0(cinfo);
+  if (cinfo->write_Adobe_marker) /* next an optional Adobe APP14 */
+    emit_adobe_app14(cinfo);
+}
+
+
+/*
+ * Write frame header.
+ * This consists of DQT and SOFn markers.
+ * Note that we do not emit the SOF until we have emitted the DQT(s).
+ * This avoids compatibility problems with incorrect implementations that
+ * try to error-check the quant table numbers as soon as they see the SOF.
+ */
+
+METHODDEF void
+write_frame_header (j_compress_ptr cinfo)
+{
+  int ci, prec;
+  boolean is_baseline;
+  jpeg_component_info *compptr;
+  
+  /* Emit DQT for each quantization table.
+   * Note that emit_dqt() suppresses any duplicate tables.
+   */
+  prec = 0;
+  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+       ci++, compptr++) {
+    prec += emit_dqt(cinfo, compptr->quant_tbl_no);
+  }
+  /* now prec is nonzero iff there are any 16-bit quant tables. */
+
+  /* Check for a non-baseline specification.
+   * Note we assume that Huffman table numbers won't be changed later.
+   */
+  if (cinfo->arith_code || cinfo->progressive_mode ||
+      cinfo->data_precision != 8) {
+    is_baseline = FALSE;
+  } else {
+    is_baseline = TRUE;
+    for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+	 ci++, compptr++) {
+      if (compptr->dc_tbl_no > 1 || compptr->ac_tbl_no > 1)
+	is_baseline = FALSE;
+    }
+    if (prec && is_baseline) {
+      is_baseline = FALSE;
+      /* If it's baseline except for quantizer size, warn the user */
+      TRACEMS(cinfo, 0, JTRC_16BIT_TABLES);
+    }
+  }
+
+  /* Emit the proper SOF marker */
+  if (cinfo->arith_code) {
+    emit_sof(cinfo, M_SOF9);	/* SOF code for arithmetic coding */
+  } else {
+    if (cinfo->progressive_mode)
+      emit_sof(cinfo, M_SOF2);	/* SOF code for progressive Huffman */
+    else if (is_baseline)
+      emit_sof(cinfo, M_SOF0);	/* SOF code for baseline implementation */
+    else
+      emit_sof(cinfo, M_SOF1);	/* SOF code for non-baseline Huffman file */
+  }
+}
+
+
+/*
+ * Write scan header.
+ * This consists of DHT or DAC markers, optional DRI, and SOS.
+ * Compressed data will be written following the SOS.
+ */
+
+METHODDEF void
+write_scan_header (j_compress_ptr cinfo)
+{
+  int i;
+  jpeg_component_info *compptr;
+
+  if (cinfo->arith_code) {
+    /* Emit arith conditioning info.  We may have some duplication
+     * if the file has multiple scans, but it's so small it's hardly
+     * worth worrying about.
+     */
+    emit_dac(cinfo);
+  } else {
+    /* Emit Huffman tables.
+     * Note that emit_dht() suppresses any duplicate tables.
+     */
+    for (i = 0; i < cinfo->comps_in_scan; i++) {
+      compptr = cinfo->cur_comp_info[i];
+      if (cinfo->progressive_mode) {
+	/* Progressive mode: only DC or only AC tables are used in one scan */
+	if (cinfo->Ss == 0) {
+	  if (cinfo->Ah == 0)	/* DC needs no table for refinement scan */
+	    emit_dht(cinfo, compptr->dc_tbl_no, FALSE);
+	} else {
+	  emit_dht(cinfo, compptr->ac_tbl_no, TRUE);
+	}
+      } else {
+	/* Sequential mode: need both DC and AC tables */
+	emit_dht(cinfo, compptr->dc_tbl_no, FALSE);
+	emit_dht(cinfo, compptr->ac_tbl_no, TRUE);
+      }
+    }
+  }
+
+  /* Emit DRI if required --- note that DRI value could change for each scan.
+   * If it doesn't, a tiny amount of space is wasted in multiple-scan files.
+   * We assume DRI will never be nonzero for one scan and zero for a later one.
+   */
+  if (cinfo->restart_interval)
+    emit_dri(cinfo);
+
+  emit_sos(cinfo);
+}
+
+
+/*
+ * Write datastream trailer.
+ */
+
+METHODDEF void
+write_file_trailer (j_compress_ptr cinfo)
+{
+  emit_marker(cinfo, M_EOI);
+}
+
+
+/*
+ * Write an abbreviated table-specification datastream.
+ * This consists of SOI, DQT and DHT tables, and EOI.
+ * Any table that is defined and not marked sent_table = TRUE will be
+ * emitted.  Note that all tables will be marked sent_table = TRUE at exit.
+ */
+
+METHODDEF void
+write_tables_only (j_compress_ptr cinfo)
+{
+  int i;
+
+  emit_marker(cinfo, M_SOI);
+
+  for (i = 0; i < NUM_QUANT_TBLS; i++) {
+    if (cinfo->quant_tbl_ptrs[i] != NULL)
+      (void) emit_dqt(cinfo, i);
+  }
+
+  if (! cinfo->arith_code) {
+    for (i = 0; i < NUM_HUFF_TBLS; i++) {
+      if (cinfo->dc_huff_tbl_ptrs[i] != NULL)
+	emit_dht(cinfo, i, FALSE);
+      if (cinfo->ac_huff_tbl_ptrs[i] != NULL)
+	emit_dht(cinfo, i, TRUE);
+    }
+  }
+
+  emit_marker(cinfo, M_EOI);
+}
+
+
+/*
+ * Initialize the marker writer module.
+ */
+
+GLOBAL void
+jinit_marker_writer (j_compress_ptr cinfo)
+{
+  /* Create the subobject */
+  cinfo->marker = (struct jpeg_marker_writer *)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				SIZEOF(struct jpeg_marker_writer));
+  /* Initialize method pointers */
+  cinfo->marker->write_any_marker = write_any_marker;
+  cinfo->marker->write_file_header = write_file_header;
+  cinfo->marker->write_frame_header = write_frame_header;
+  cinfo->marker->write_scan_header = write_scan_header;
+  cinfo->marker->write_file_trailer = write_file_trailer;
+  cinfo->marker->write_tables_only = write_tables_only;
+}
diff --git a/codemp/jpeg-6/jcmaster.cpp b/codemp/jpeg-6/jcmaster.cpp
new file mode 100644
index 0000000..b3e804e
--- /dev/null
+++ b/codemp/jpeg-6/jcmaster.cpp
@@ -0,0 +1,580 @@
+/*
+ * jcmaster.c
+ *
+ * Copyright (C) 1991-1995, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains master control logic for the JPEG compressor.
+ * These routines are concerned with parameter validation, initial setup,
+ * and inter-pass control (determining the number of passes and the work 
+ * to be done in each pass).
+ */
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/* Private state */
+
+typedef enum {
+	main_pass,		/* input data, also do first output step */
+	huff_opt_pass,		/* Huffman code optimization pass */
+	output_pass		/* data output pass */
+} c_pass_type;
+
+typedef struct {
+  struct jpeg_comp_master pub;	/* public fields */
+
+  c_pass_type pass_type;	/* the type of the current pass */
+
+  int pass_number;		/* # of passes completed */
+  int total_passes;		/* total # of passes needed */
+
+  int scan_number;		/* current index in scan_info[] */
+} my_comp_master;
+
+typedef my_comp_master * my_master_ptr;
+
+
+/*
+ * Support routines that do various essential calculations.
+ */
+
+LOCAL void
+initial_setup (j_compress_ptr cinfo)
+/* Do computations that are needed before master selection phase */
+{
+  int ci;
+  jpeg_component_info *compptr;
+  long samplesperrow;
+  JDIMENSION jd_samplesperrow;
+
+  /* Sanity check on image dimensions */
+  if (cinfo->image_height <= 0 || cinfo->image_width <= 0
+      || cinfo->num_components <= 0 || cinfo->input_components <= 0)
+    ERREXIT(cinfo, JERR_EMPTY_IMAGE);
+
+  /* Make sure image isn't bigger than I can handle */
+  if ((long) cinfo->image_height > (long) JPEG_MAX_DIMENSION ||
+      (long) cinfo->image_width > (long) JPEG_MAX_DIMENSION)
+    ERREXIT1(cinfo, JERR_IMAGE_TOO_BIG, (unsigned int) JPEG_MAX_DIMENSION);
+
+  /* Width of an input scanline must be representable as JDIMENSION. */
+  samplesperrow = (long) cinfo->image_width * (long) cinfo->input_components;
+  jd_samplesperrow = (JDIMENSION) samplesperrow;
+  if ((long) jd_samplesperrow != samplesperrow)
+    ERREXIT(cinfo, JERR_WIDTH_OVERFLOW);
+
+  /* For now, precision must match compiled-in value... */
+  if (cinfo->data_precision != BITS_IN_JSAMPLE)
+    ERREXIT1(cinfo, JERR_BAD_PRECISION, cinfo->data_precision);
+
+  /* Check that number of components won't exceed internal array sizes */
+  if (cinfo->num_components > MAX_COMPONENTS)
+    ERREXIT2(cinfo, JERR_COMPONENT_COUNT, cinfo->num_components,
+	     MAX_COMPONENTS);
+
+  /* Compute maximum sampling factors; check factor validity */
+  cinfo->max_h_samp_factor = 1;
+  cinfo->max_v_samp_factor = 1;
+  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+       ci++, compptr++) {
+    if (compptr->h_samp_factor<=0 || compptr->h_samp_factor>MAX_SAMP_FACTOR ||
+	compptr->v_samp_factor<=0 || compptr->v_samp_factor>MAX_SAMP_FACTOR)
+      ERREXIT(cinfo, JERR_BAD_SAMPLING);
+    cinfo->max_h_samp_factor = MAX(cinfo->max_h_samp_factor,
+				   compptr->h_samp_factor);
+    cinfo->max_v_samp_factor = MAX(cinfo->max_v_samp_factor,
+				   compptr->v_samp_factor);
+  }
+
+  /* Compute dimensions of components */
+  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+       ci++, compptr++) {
+    /* Fill in the correct component_index value; don't rely on application */
+    compptr->component_index = ci;
+    /* For compression, we never do DCT scaling. */
+    compptr->DCT_scaled_size = DCTSIZE;
+    /* Size in DCT blocks */
+    compptr->width_in_blocks = (JDIMENSION)
+      jdiv_round_up((long) cinfo->image_width * (long) compptr->h_samp_factor,
+		    (long) (cinfo->max_h_samp_factor * DCTSIZE));
+    compptr->height_in_blocks = (JDIMENSION)
+      jdiv_round_up((long) cinfo->image_height * (long) compptr->v_samp_factor,
+		    (long) (cinfo->max_v_samp_factor * DCTSIZE));
+    /* Size in samples */
+    compptr->downsampled_width = (JDIMENSION)
+      jdiv_round_up((long) cinfo->image_width * (long) compptr->h_samp_factor,
+		    (long) cinfo->max_h_samp_factor);
+    compptr->downsampled_height = (JDIMENSION)
+      jdiv_round_up((long) cinfo->image_height * (long) compptr->v_samp_factor,
+		    (long) cinfo->max_v_samp_factor);
+    /* Mark component needed (this flag isn't actually used for compression) */
+    compptr->component_needed = TRUE;
+  }
+
+  /* Compute number of fully interleaved MCU rows (number of times that
+   * main controller will call coefficient controller).
+   */
+  cinfo->total_iMCU_rows = (JDIMENSION)
+    jdiv_round_up((long) cinfo->image_height,
+		  (long) (cinfo->max_v_samp_factor*DCTSIZE));
+}
+
+
+#ifdef C_MULTISCAN_FILES_SUPPORTED
+
+LOCAL void
+validate_script (j_compress_ptr cinfo)
+/* Verify that the scan script in cinfo->scan_info[] is valid; also
+ * determine whether it uses progressive JPEG, and set cinfo->progressive_mode.
+ */
+{
+  const jpeg_scan_info * scanptr;
+  int scanno, ncomps, ci, coefi, thisi;
+  int Ss, Se, Ah, Al;
+  boolean component_sent[MAX_COMPONENTS];
+#ifdef C_PROGRESSIVE_SUPPORTED
+  int * last_bitpos_ptr;
+  int last_bitpos[MAX_COMPONENTS][DCTSIZE2];
+  /* -1 until that coefficient has been seen; then last Al for it */
+#endif
+
+  if (cinfo->num_scans <= 0)
+    ERREXIT1(cinfo, JERR_BAD_SCAN_SCRIPT, 0);
+
+  /* For sequential JPEG, all scans must have Ss=0, Se=DCTSIZE2-1;
+   * for progressive JPEG, no scan can have this.
+   */
+  scanptr = cinfo->scan_info;
+  if (scanptr->Ss != 0 || scanptr->Se != DCTSIZE2-1) {
+#ifdef C_PROGRESSIVE_SUPPORTED
+    cinfo->progressive_mode = TRUE;
+    last_bitpos_ptr = & last_bitpos[0][0];
+    for (ci = 0; ci < cinfo->num_components; ci++) 
+      for (coefi = 0; coefi < DCTSIZE2; coefi++)
+	*last_bitpos_ptr++ = -1;
+#else
+    ERREXIT(cinfo, JERR_NOT_COMPILED);
+#endif
+  } else {
+    cinfo->progressive_mode = FALSE;
+    for (ci = 0; ci < cinfo->num_components; ci++) 
+      component_sent[ci] = FALSE;
+  }
+
+  for (scanno = 1; scanno <= cinfo->num_scans; scanptr++, scanno++) {
+    /* Validate component indexes */
+    ncomps = scanptr->comps_in_scan;
+    if (ncomps <= 0 || ncomps > MAX_COMPS_IN_SCAN)
+      ERREXIT2(cinfo, JERR_COMPONENT_COUNT, ncomps, MAX_COMPS_IN_SCAN);
+    for (ci = 0; ci < ncomps; ci++) {
+      thisi = scanptr->component_index[ci];
+      if (thisi < 0 || thisi >= cinfo->num_components)
+	ERREXIT1(cinfo, JERR_BAD_SCAN_SCRIPT, scanno);
+      /* Components must appear in SOF order within each scan */
+      if (ci > 0 && thisi <= scanptr->component_index[ci-1])
+	ERREXIT1(cinfo, JERR_BAD_SCAN_SCRIPT, scanno);
+    }
+    /* Validate progression parameters */
+    Ss = scanptr->Ss;
+    Se = scanptr->Se;
+    Ah = scanptr->Ah;
+    Al = scanptr->Al;
+    if (cinfo->progressive_mode) {
+#ifdef C_PROGRESSIVE_SUPPORTED
+      if (Ss < 0 || Ss >= DCTSIZE2 || Se < Ss || Se >= DCTSIZE2 ||
+	  Ah < 0 || Ah > 13 || Al < 0 || Al > 13)
+	ERREXIT1(cinfo, JERR_BAD_PROG_SCRIPT, scanno);
+      if (Ss == 0) {
+	if (Se != 0)		/* DC and AC together not OK */
+	  ERREXIT1(cinfo, JERR_BAD_PROG_SCRIPT, scanno);
+      } else {
+	if (ncomps != 1)	/* AC scans must be for only one component */
+	  ERREXIT1(cinfo, JERR_BAD_PROG_SCRIPT, scanno);
+      }
+      for (ci = 0; ci < ncomps; ci++) {
+	last_bitpos_ptr = & last_bitpos[scanptr->component_index[ci]][0];
+	if (Ss != 0 && last_bitpos_ptr[0] < 0) /* AC without prior DC scan */
+	  ERREXIT1(cinfo, JERR_BAD_PROG_SCRIPT, scanno);
+	for (coefi = Ss; coefi <= Se; coefi++) {
+	  if (last_bitpos_ptr[coefi] < 0) {
+	    /* first scan of this coefficient */
+	    if (Ah != 0)
+	      ERREXIT1(cinfo, JERR_BAD_PROG_SCRIPT, scanno);
+	  } else {
+	    /* not first scan */
+	    if (Ah != last_bitpos_ptr[coefi] || Al != Ah-1)
+	      ERREXIT1(cinfo, JERR_BAD_PROG_SCRIPT, scanno);
+	  }
+	  last_bitpos_ptr[coefi] = Al;
+	}
+      }
+#endif
+    } else {
+      /* For sequential JPEG, all progression parameters must be these: */
+      if (Ss != 0 || Se != DCTSIZE2-1 || Ah != 0 || Al != 0)
+	ERREXIT1(cinfo, JERR_BAD_PROG_SCRIPT, scanno);
+      /* Make sure components are not sent twice */
+      for (ci = 0; ci < ncomps; ci++) {
+	thisi = scanptr->component_index[ci];
+	if (component_sent[thisi])
+	  ERREXIT1(cinfo, JERR_BAD_SCAN_SCRIPT, scanno);
+	component_sent[thisi] = TRUE;
+      }
+    }
+  }
+
+  /* Now verify that everything got sent. */
+  if (cinfo->progressive_mode) {
+#ifdef C_PROGRESSIVE_SUPPORTED
+    /* For progressive mode, we only check that at least some DC data
+     * got sent for each component; the spec does not require that all bits
+     * of all coefficients be transmitted.  Would it be wiser to enforce
+     * transmission of all coefficient bits??
+     */
+    for (ci = 0; ci < cinfo->num_components; ci++) {
+      if (last_bitpos[ci][0] < 0)
+	ERREXIT(cinfo, JERR_MISSING_DATA);
+    }
+#endif
+  } else {
+    for (ci = 0; ci < cinfo->num_components; ci++) {
+      if (! component_sent[ci])
+	ERREXIT(cinfo, JERR_MISSING_DATA);
+    }
+  }
+}
+
+#endif /* C_MULTISCAN_FILES_SUPPORTED */
+
+
+LOCAL void
+select_scan_parameters (j_compress_ptr cinfo)
+/* Set up the scan parameters for the current scan */
+{
+  int ci;
+
+#ifdef C_MULTISCAN_FILES_SUPPORTED
+  if (cinfo->scan_info != NULL) {
+    /* Prepare for current scan --- the script is already validated */
+    my_master_ptr master = (my_master_ptr) cinfo->master;
+    const jpeg_scan_info * scanptr = cinfo->scan_info + master->scan_number;
+
+    cinfo->comps_in_scan = scanptr->comps_in_scan;
+    for (ci = 0; ci < scanptr->comps_in_scan; ci++) {
+      cinfo->cur_comp_info[ci] =
+	&cinfo->comp_info[scanptr->component_index[ci]];
+    }
+    cinfo->Ss = scanptr->Ss;
+    cinfo->Se = scanptr->Se;
+    cinfo->Ah = scanptr->Ah;
+    cinfo->Al = scanptr->Al;
+  }
+  else
+#endif
+  {
+    /* Prepare for single sequential-JPEG scan containing all components */
+    if (cinfo->num_components > MAX_COMPS_IN_SCAN)
+      ERREXIT2(cinfo, JERR_COMPONENT_COUNT, cinfo->num_components,
+	       MAX_COMPS_IN_SCAN);
+    cinfo->comps_in_scan = cinfo->num_components;
+    for (ci = 0; ci < cinfo->num_components; ci++) {
+      cinfo->cur_comp_info[ci] = &cinfo->comp_info[ci];
+    }
+    cinfo->Ss = 0;
+    cinfo->Se = DCTSIZE2-1;
+    cinfo->Ah = 0;
+    cinfo->Al = 0;
+  }
+}
+
+
+LOCAL void
+per_scan_setup (j_compress_ptr cinfo)
+/* Do computations that are needed before processing a JPEG scan */
+/* cinfo->comps_in_scan and cinfo->cur_comp_info[] are already set */
+{
+  int ci, mcublks, tmp;
+  jpeg_component_info *compptr;
+  
+  if (cinfo->comps_in_scan == 1) {
+    
+    /* Noninterleaved (single-component) scan */
+    compptr = cinfo->cur_comp_info[0];
+    
+    /* Overall image size in MCUs */
+    cinfo->MCUs_per_row = compptr->width_in_blocks;
+    cinfo->MCU_rows_in_scan = compptr->height_in_blocks;
+    
+    /* For noninterleaved scan, always one block per MCU */
+    compptr->MCU_width = 1;
+    compptr->MCU_height = 1;
+    compptr->MCU_blocks = 1;
+    compptr->MCU_sample_width = DCTSIZE;
+    compptr->last_col_width = 1;
+    /* For noninterleaved scans, it is convenient to define last_row_height
+     * as the number of block rows present in the last iMCU row.
+     */
+    tmp = (int) (compptr->height_in_blocks % compptr->v_samp_factor);
+    if (tmp == 0) tmp = compptr->v_samp_factor;
+    compptr->last_row_height = tmp;
+    
+    /* Prepare array describing MCU composition */
+    cinfo->blocks_in_MCU = 1;
+    cinfo->MCU_membership[0] = 0;
+    
+  } else {
+    
+    /* Interleaved (multi-component) scan */
+    if (cinfo->comps_in_scan <= 0 || cinfo->comps_in_scan > MAX_COMPS_IN_SCAN)
+      ERREXIT2(cinfo, JERR_COMPONENT_COUNT, cinfo->comps_in_scan,
+	       MAX_COMPS_IN_SCAN);
+    
+    /* Overall image size in MCUs */
+    cinfo->MCUs_per_row = (JDIMENSION)
+      jdiv_round_up((long) cinfo->image_width,
+		    (long) (cinfo->max_h_samp_factor*DCTSIZE));
+    cinfo->MCU_rows_in_scan = (JDIMENSION)
+      jdiv_round_up((long) cinfo->image_height,
+		    (long) (cinfo->max_v_samp_factor*DCTSIZE));
+    
+    cinfo->blocks_in_MCU = 0;
+    
+    for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+      compptr = cinfo->cur_comp_info[ci];
+      /* Sampling factors give # of blocks of component in each MCU */
+      compptr->MCU_width = compptr->h_samp_factor;
+      compptr->MCU_height = compptr->v_samp_factor;
+      compptr->MCU_blocks = compptr->MCU_width * compptr->MCU_height;
+      compptr->MCU_sample_width = compptr->MCU_width * DCTSIZE;
+      /* Figure number of non-dummy blocks in last MCU column & row */
+      tmp = (int) (compptr->width_in_blocks % compptr->MCU_width);
+      if (tmp == 0) tmp = compptr->MCU_width;
+      compptr->last_col_width = tmp;
+      tmp = (int) (compptr->height_in_blocks % compptr->MCU_height);
+      if (tmp == 0) tmp = compptr->MCU_height;
+      compptr->last_row_height = tmp;
+      /* Prepare array describing MCU composition */
+      mcublks = compptr->MCU_blocks;
+      if (cinfo->blocks_in_MCU + mcublks > C_MAX_BLOCKS_IN_MCU)
+	ERREXIT(cinfo, JERR_BAD_MCU_SIZE);
+      while (mcublks-- > 0) {
+	cinfo->MCU_membership[cinfo->blocks_in_MCU++] = ci;
+      }
+    }
+    
+  }
+
+  /* Convert restart specified in rows to actual MCU count. */
+  /* Note that count must fit in 16 bits, so we provide limiting. */
+  if (cinfo->restart_in_rows > 0) {
+    long nominal = (long) cinfo->restart_in_rows * (long) cinfo->MCUs_per_row;
+    cinfo->restart_interval = (unsigned int) MIN(nominal, 65535L);
+  }
+}
+
+
+/*
+ * Per-pass setup.
+ * This is called at the beginning of each pass.  We determine which modules
+ * will be active during this pass and give them appropriate start_pass calls.
+ * We also set is_last_pass to indicate whether any more passes will be
+ * required.
+ */
+
+METHODDEF void
+prepare_for_pass (j_compress_ptr cinfo)
+{
+  my_master_ptr master = (my_master_ptr) cinfo->master;
+
+  switch (master->pass_type) {
+  case main_pass:
+    /* Initial pass: will collect input data, and do either Huffman
+     * optimization or data output for the first scan.
+     */
+    select_scan_parameters(cinfo);
+    per_scan_setup(cinfo);
+    if (! cinfo->raw_data_in) {
+      (*cinfo->cconvert->start_pass) (cinfo);
+      (*cinfo->downsample->start_pass) (cinfo);
+      (*cinfo->prep->start_pass) (cinfo, JBUF_PASS_THRU);
+    }
+    (*cinfo->fdct->start_pass) (cinfo);
+    (*cinfo->entropy->start_pass) (cinfo, cinfo->optimize_coding);
+    (*cinfo->coef->start_pass) (cinfo,
+				(master->total_passes > 1 ?
+				 JBUF_SAVE_AND_PASS : JBUF_PASS_THRU));
+    (*cinfo->main->start_pass) (cinfo, JBUF_PASS_THRU);
+    if (cinfo->optimize_coding) {
+      /* No immediate data output; postpone writing frame/scan headers */
+      master->pub.call_pass_startup = FALSE;
+    } else {
+      /* Will write frame/scan headers at first jpeg_write_scanlines call */
+      master->pub.call_pass_startup = TRUE;
+    }
+    break;
+#ifdef ENTROPY_OPT_SUPPORTED
+  case huff_opt_pass:
+    /* Do Huffman optimization for a scan after the first one. */
+    select_scan_parameters(cinfo);
+    per_scan_setup(cinfo);
+    if (cinfo->Ss != 0 || cinfo->Ah == 0 || cinfo->arith_code) {
+      (*cinfo->entropy->start_pass) (cinfo, TRUE);
+      (*cinfo->coef->start_pass) (cinfo, JBUF_CRANK_DEST);
+      master->pub.call_pass_startup = FALSE;
+      break;
+    }
+    /* Special case: Huffman DC refinement scans need no Huffman table
+     * and therefore we can skip the optimization pass for them.
+     */
+    master->pass_type = output_pass;
+    master->pass_number++;
+    /*FALLTHROUGH*/
+#endif
+  case output_pass:
+    /* Do a data-output pass. */
+    /* We need not repeat per-scan setup if prior optimization pass did it. */
+    if (! cinfo->optimize_coding) {
+      select_scan_parameters(cinfo);
+      per_scan_setup(cinfo);
+    }
+    (*cinfo->entropy->start_pass) (cinfo, FALSE);
+    (*cinfo->coef->start_pass) (cinfo, JBUF_CRANK_DEST);
+    /* We emit frame/scan headers now */
+    if (master->scan_number == 0)
+      (*cinfo->marker->write_frame_header) (cinfo);
+    (*cinfo->marker->write_scan_header) (cinfo);
+    master->pub.call_pass_startup = FALSE;
+    break;
+  default:
+    ERREXIT(cinfo, JERR_NOT_COMPILED);
+  }
+
+  master->pub.is_last_pass = (master->pass_number == master->total_passes-1);
+
+  /* Set up progress monitor's pass info if present */
+  if (cinfo->progress != NULL) {
+    cinfo->progress->completed_passes = master->pass_number;
+    cinfo->progress->total_passes = master->total_passes;
+  }
+}
+
+
+/*
+ * Special start-of-pass hook.
+ * This is called by jpeg_write_scanlines if call_pass_startup is TRUE.
+ * In single-pass processing, we need this hook because we don't want to
+ * write frame/scan headers during jpeg_start_compress; we want to let the
+ * application write COM markers etc. between jpeg_start_compress and the
+ * jpeg_write_scanlines loop.
+ * In multi-pass processing, this routine is not used.
+ */
+
+METHODDEF void
+pass_startup (j_compress_ptr cinfo)
+{
+  cinfo->master->call_pass_startup = FALSE; /* reset flag so call only once */
+
+  (*cinfo->marker->write_frame_header) (cinfo);
+  (*cinfo->marker->write_scan_header) (cinfo);
+}
+
+
+/*
+ * Finish up at end of pass.
+ */
+
+METHODDEF void
+finish_pass_master (j_compress_ptr cinfo)
+{
+  my_master_ptr master = (my_master_ptr) cinfo->master;
+
+  /* The entropy coder always needs an end-of-pass call,
+   * either to analyze statistics or to flush its output buffer.
+   */
+  (*cinfo->entropy->finish_pass) (cinfo);
+
+  /* Update state for next pass */
+  switch (master->pass_type) {
+  case main_pass:
+    /* next pass is either output of scan 0 (after optimization)
+     * or output of scan 1 (if no optimization).
+     */
+    master->pass_type = output_pass;
+    if (! cinfo->optimize_coding)
+      master->scan_number++;
+    break;
+  case huff_opt_pass:
+    /* next pass is always output of current scan */
+    master->pass_type = output_pass;
+    break;
+  case output_pass:
+    /* next pass is either optimization or output of next scan */
+    if (cinfo->optimize_coding)
+      master->pass_type = huff_opt_pass;
+    master->scan_number++;
+    break;
+  }
+
+  master->pass_number++;
+}
+
+
+/*
+ * Initialize master compression control.
+ */
+
+GLOBAL void
+jinit_c_master_control (j_compress_ptr cinfo, boolean transcode_only)
+{
+  my_master_ptr master;
+
+  master = (my_master_ptr)
+      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				  SIZEOF(my_comp_master));
+  cinfo->master = (struct jpeg_comp_master *) master;
+  master->pub.prepare_for_pass = prepare_for_pass;
+  master->pub.pass_startup = pass_startup;
+  master->pub.finish_pass = finish_pass_master;
+  master->pub.is_last_pass = FALSE;
+
+  /* Validate parameters, determine derived values */
+  initial_setup(cinfo);
+
+  if (cinfo->scan_info != NULL) {
+#ifdef C_MULTISCAN_FILES_SUPPORTED
+    validate_script(cinfo);
+#else
+    ERREXIT(cinfo, JERR_NOT_COMPILED);
+#endif
+  } else {
+    cinfo->progressive_mode = FALSE;
+    cinfo->num_scans = 1;
+  }
+
+  if (cinfo->progressive_mode)	/*  TEMPORARY HACK ??? */
+    cinfo->optimize_coding = TRUE; /* assume default tables no good for progressive mode */
+
+  /* Initialize my private state */
+  if (transcode_only) {
+    /* no main pass in transcoding */
+    if (cinfo->optimize_coding)
+      master->pass_type = huff_opt_pass;
+    else
+      master->pass_type = output_pass;
+  } else {
+    /* for normal compression, first pass is always this type: */
+    master->pass_type = main_pass;
+  }
+  master->scan_number = 0;
+  master->pass_number = 0;
+  if (cinfo->optimize_coding)
+    master->total_passes = cinfo->num_scans * 2;
+  else
+    master->total_passes = cinfo->num_scans;
+}
diff --git a/codemp/jpeg-6/jcomapi.cpp b/codemp/jpeg-6/jcomapi.cpp
new file mode 100644
index 0000000..799e98e
--- /dev/null
+++ b/codemp/jpeg-6/jcomapi.cpp
@@ -0,0 +1,96 @@
+/*
+ * jcomapi.c
+ *
+ * Copyright (C) 1994, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains application interface routines that are used for both
+ * compression and decompression.
+ */
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/*
+ * Abort processing of a JPEG compression or decompression operation,
+ * but don't destroy the object itself.
+ *
+ * For this, we merely clean up all the nonpermanent memory pools.
+ * Note that temp files (virtual arrays) are not allowed to belong to
+ * the permanent pool, so we will be able to close all temp files here.
+ * Closing a data source or destination, if necessary, is the application's
+ * responsibility.
+ */
+
+GLOBAL void
+jpeg_abort (j_common_ptr cinfo)
+{
+  int pool;
+
+  /* Releasing pools in reverse order might help avoid fragmentation
+   * with some (brain-damaged) malloc libraries.
+   */
+  for (pool = JPOOL_NUMPOOLS-1; pool > JPOOL_PERMANENT; pool--) {
+    (*cinfo->mem->free_pool) (cinfo, pool);
+  }
+
+  /* Reset overall state for possible reuse of object */
+  cinfo->global_state = (cinfo->is_decompressor ? DSTATE_START : CSTATE_START);
+}
+
+
+/*
+ * Destruction of a JPEG object.
+ *
+ * Everything gets deallocated except the master jpeg_compress_struct itself
+ * and the error manager struct.  Both of these are supplied by the application
+ * and must be freed, if necessary, by the application.  (Often they are on
+ * the stack and so don't need to be freed anyway.)
+ * Closing a data source or destination, if necessary, is the application's
+ * responsibility.
+ */
+
+GLOBAL void
+jpeg_destroy (j_common_ptr cinfo)
+{
+  /* We need only tell the memory manager to release everything. */
+  /* NB: mem pointer is NULL if memory mgr failed to initialize. */
+  if (cinfo->mem != NULL)
+    (*cinfo->mem->self_destruct) (cinfo);
+  cinfo->mem = NULL;		/* be safe if jpeg_destroy is called twice */
+  cinfo->global_state = 0;	/* mark it destroyed */
+}
+
+
+/*
+ * Convenience routines for allocating quantization and Huffman tables.
+ * (Would jutils.c be a more reasonable place to put these?)
+ */
+
+GLOBAL JQUANT_TBL *
+jpeg_alloc_quant_table (j_common_ptr cinfo)
+{
+  JQUANT_TBL *tbl;
+
+  tbl = (JQUANT_TBL *)
+    (*cinfo->mem->alloc_small) (cinfo, JPOOL_PERMANENT, SIZEOF(JQUANT_TBL));
+  tbl->sent_table = FALSE;	/* make sure this is false in any new table */
+  return tbl;
+}
+
+
+GLOBAL JHUFF_TBL *
+jpeg_alloc_huff_table (j_common_ptr cinfo)
+{
+  JHUFF_TBL *tbl;
+
+  tbl = (JHUFF_TBL *)
+    (*cinfo->mem->alloc_small) (cinfo, JPOOL_PERMANENT, SIZEOF(JHUFF_TBL));
+  tbl->sent_table = FALSE;	/* make sure this is false in any new table */
+  return tbl;
+}
diff --git a/codemp/jpeg-6/jconfig.h b/codemp/jpeg-6/jconfig.h
new file mode 100644
index 0000000..187ecfc
--- /dev/null
+++ b/codemp/jpeg-6/jconfig.h
@@ -0,0 +1,41 @@
+/* jconfig.wat --- jconfig.h for Watcom C/C++ on MS-DOS or OS/2. */
+/* see jconfig.doc for explanations */
+
+#define HAVE_PROTOTYPES
+#define HAVE_UNSIGNED_CHAR
+#define HAVE_UNSIGNED_SHORT
+/* #define void char */
+/* #define const */
+#define CHAR_IS_UNSIGNED
+#define HAVE_STDDEF_H
+#define HAVE_STDLIB_H
+#undef NEED_BSD_STRINGS
+#undef NEED_SYS_TYPES_H
+#undef NEED_FAR_POINTERS	/* Watcom uses flat 32-bit addressing */
+#undef NEED_SHORT_EXTERNAL_NAMES
+#undef INCOMPLETE_TYPES_BROKEN
+
+#define JDCT_DEFAULT  JDCT_FLOAT
+#define JDCT_FASTEST  JDCT_FLOAT
+
+#ifdef JPEG_INTERNALS
+
+#undef RIGHT_SHIFT_IS_UNSIGNED
+
+#endif /* JPEG_INTERNALS */
+
+#ifdef JPEG_CJPEG_DJPEG
+
+#define BMP_SUPPORTED		/* BMP image file format */
+#define GIF_SUPPORTED		/* GIF image file format */
+#define PPM_SUPPORTED		/* PBMPLUS PPM/PGM image file format */
+#undef RLE_SUPPORTED		/* Utah RLE image file format */
+#define TARGA_SUPPORTED		/* Targa image file format */
+
+#undef TWO_FILE_COMMANDLINE	/* optional */
+#define USE_SETMODE		/* Needed to make one-file style work in Watcom */
+#undef NEED_SIGNAL_CATCHER	/* Define this if you use jmemname.c */
+#undef DONT_USE_B_MODE
+#undef PROGRESS_REPORT		/* optional */
+
+#endif /* JPEG_CJPEG_DJPEG */
diff --git a/codemp/jpeg-6/jcparam.cpp b/codemp/jpeg-6/jcparam.cpp
new file mode 100644
index 0000000..88fea67
--- /dev/null
+++ b/codemp/jpeg-6/jcparam.cpp
@@ -0,0 +1,577 @@
+/*
+ * jcparam.c
+ *
+ * Copyright (C) 1991-1995, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains optional default-setting code for the JPEG compressor.
+ * Applications do not have to use this file, but those that don't use it
+ * must know a lot more about the innards of the JPEG code.
+ */
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/*
+ * Quantization table setup routines
+ */
+
+GLOBAL void
+jpeg_add_quant_table (j_compress_ptr cinfo, int which_tbl,
+		      const unsigned int *basic_table,
+		      int scale_factor, boolean force_baseline)
+/* Define a quantization table equal to the basic_table times
+ * a scale factor (given as a percentage).
+ * If force_baseline is TRUE, the computed quantization table entries
+ * are limited to 1..255 for JPEG baseline compatibility.
+ */
+{
+  JQUANT_TBL ** qtblptr = & cinfo->quant_tbl_ptrs[which_tbl];
+  int i;
+  long temp;
+
+  /* Safety check to ensure start_compress not called yet. */
+  if (cinfo->global_state != CSTATE_START)
+    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+
+  if (*qtblptr == NULL)
+    *qtblptr = jpeg_alloc_quant_table((j_common_ptr) cinfo);
+
+  for (i = 0; i < DCTSIZE2; i++) {
+    temp = ((long) basic_table[i] * scale_factor + 50L) / 100L;
+    /* limit the values to the valid range */
+    if (temp <= 0L) temp = 1L;
+    if (temp > 32767L) temp = 32767L; /* max quantizer needed for 12 bits */
+    if (force_baseline && temp > 255L)
+      temp = 255L;		/* limit to baseline range if requested */
+    (*qtblptr)->quantval[i] = (UINT16) temp;
+  }
+
+  /* Initialize sent_table FALSE so table will be written to JPEG file. */
+  (*qtblptr)->sent_table = FALSE;
+}
+
+
+GLOBAL void
+jpeg_set_linear_quality (j_compress_ptr cinfo, int scale_factor,
+			 boolean force_baseline)
+/* Set or change the 'quality' (quantization) setting, using default tables
+ * and a straight percentage-scaling quality scale.  In most cases it's better
+ * to use jpeg_set_quality (below); this entry point is provided for
+ * applications that insist on a linear percentage scaling.
+ */
+{
+  /* This is the sample quantization table given in the JPEG spec section K.1,
+   * but expressed in zigzag order (as are all of our quant. tables).
+   * The spec says that the values given produce "good" quality, and
+   * when divided by 2, "very good" quality.
+   */
+  static const unsigned int std_luminance_quant_tbl[DCTSIZE2] = {
+    16,  11,  12,  14,  12,  10,  16,  14,
+    13,  14,  18,  17,  16,  19,  24,  40,
+    26,  24,  22,  22,  24,  49,  35,  37,
+    29,  40,  58,  51,  61,  60,  57,  51,
+    56,  55,  64,  72,  92,  78,  64,  68,
+    87,  69,  55,  56,  80, 109,  81,  87,
+    95,  98, 103, 104, 103,  62,  77, 113,
+    121, 112, 100, 120,  92, 101, 103,  99
+    };
+  static const unsigned int std_chrominance_quant_tbl[DCTSIZE2] = {
+    17,  18,  18,  24,  21,  24,  47,  26,
+    26,  47,  99,  66,  56,  66,  99,  99,
+    99,  99,  99,  99,  99,  99,  99,  99,
+    99,  99,  99,  99,  99,  99,  99,  99,
+    99,  99,  99,  99,  99,  99,  99,  99,
+    99,  99,  99,  99,  99,  99,  99,  99,
+    99,  99,  99,  99,  99,  99,  99,  99,
+    99,  99,  99,  99,  99,  99,  99,  99
+    };
+
+  /* Set up two quantization tables using the specified scaling */
+  jpeg_add_quant_table(cinfo, 0, std_luminance_quant_tbl,
+		       scale_factor, force_baseline);
+  jpeg_add_quant_table(cinfo, 1, std_chrominance_quant_tbl,
+		       scale_factor, force_baseline);
+}
+
+
+GLOBAL int
+jpeg_quality_scaling (int quality)
+/* Convert a user-specified quality rating to a percentage scaling factor
+ * for an underlying quantization table, using our recommended scaling curve.
+ * The input 'quality' factor should be 0 (terrible) to 100 (very good).
+ */
+{
+  /* Safety limit on quality factor.  Convert 0 to 1 to avoid zero divide. */
+  if (quality <= 0) quality = 1;
+  if (quality > 100) quality = 100;
+
+  /* The basic table is used as-is (scaling 100) for a quality of 50.
+   * Qualities 50..100 are converted to scaling percentage 200 - 2*Q;
+   * note that at Q=100 the scaling is 0, which will cause j_add_quant_table
+   * to make all the table entries 1 (hence, no quantization loss).
+   * Qualities 1..50 are converted to scaling percentage 5000/Q.
+   */
+  if (quality < 50)
+    quality = 5000 / quality;
+  else
+    quality = 200 - quality*2;
+
+  return quality;
+}
+
+
+GLOBAL void
+jpeg_set_quality (j_compress_ptr cinfo, int quality, boolean force_baseline)
+/* Set or change the 'quality' (quantization) setting, using default tables.
+ * This is the standard quality-adjusting entry point for typical user
+ * interfaces; only those who want detailed control over quantization tables
+ * would use the preceding three routines directly.
+ */
+{
+  /* Convert user 0-100 rating to percentage scaling */
+  quality = jpeg_quality_scaling(quality);
+
+  /* Set up standard quality tables */
+  jpeg_set_linear_quality(cinfo, quality, force_baseline);
+}
+
+
+/*
+ * Huffman table setup routines
+ */
+
+LOCAL void
+add_huff_table (j_compress_ptr cinfo,
+		JHUFF_TBL **htblptr, const UINT8 *bits, const UINT8 *val)
+/* Define a Huffman table */
+{
+  if (*htblptr == NULL)
+    *htblptr = jpeg_alloc_huff_table((j_common_ptr) cinfo);
+  
+  MEMCOPY((*htblptr)->bits, bits, SIZEOF((*htblptr)->bits));
+  MEMCOPY((*htblptr)->huffval, val, SIZEOF((*htblptr)->huffval));
+
+  /* Initialize sent_table FALSE so table will be written to JPEG file. */
+  (*htblptr)->sent_table = FALSE;
+}
+
+
+LOCAL void
+std_huff_tables (j_compress_ptr cinfo)
+/* Set up the standard Huffman tables (cf. JPEG standard section K.3) */
+/* IMPORTANT: these are only valid for 8-bit data precision! */
+{
+  static const UINT8 bits_dc_luminance[17] =
+    { /* 0-base */ 0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0 };
+  static const UINT8 val_dc_luminance[] =
+    { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
+  
+  static const UINT8 bits_dc_chrominance[17] =
+    { /* 0-base */ 0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0 };
+  static const UINT8 val_dc_chrominance[] =
+    { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
+  
+  static const UINT8 bits_ac_luminance[17] =
+    { /* 0-base */ 0, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 0x7d };
+  static const UINT8 val_ac_luminance[] =
+    { 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12,
+      0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07,
+      0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08,
+      0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0,
+      0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16,
+      0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28,
+      0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
+      0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
+      0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
+      0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
+      0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
+      0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
+      0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98,
+      0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
+      0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6,
+      0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5,
+      0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4,
+      0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2,
+      0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea,
+      0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
+      0xf9, 0xfa };
+  
+  static const UINT8 bits_ac_chrominance[17] =
+    { /* 0-base */ 0, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 0x77 };
+  static const UINT8 val_ac_chrominance[] =
+    { 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21,
+      0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
+      0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91,
+      0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0,
+      0x15, 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34,
+      0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26,
+      0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38,
+      0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,
+      0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
+      0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
+      0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
+      0x79, 0x7a, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
+      0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96,
+      0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5,
+      0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4,
+      0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3,
+      0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2,
+      0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda,
+      0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9,
+      0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
+      0xf9, 0xfa };
+  
+  add_huff_table(cinfo, &cinfo->dc_huff_tbl_ptrs[0],
+		 bits_dc_luminance, val_dc_luminance);
+  add_huff_table(cinfo, &cinfo->ac_huff_tbl_ptrs[0],
+		 bits_ac_luminance, val_ac_luminance);
+  add_huff_table(cinfo, &cinfo->dc_huff_tbl_ptrs[1],
+		 bits_dc_chrominance, val_dc_chrominance);
+  add_huff_table(cinfo, &cinfo->ac_huff_tbl_ptrs[1],
+		 bits_ac_chrominance, val_ac_chrominance);
+}
+
+
+/*
+ * Default parameter setup for compression.
+ *
+ * Applications that don't choose to use this routine must do their
+ * own setup of all these parameters.  Alternately, you can call this
+ * to establish defaults and then alter parameters selectively.  This
+ * is the recommended approach since, if we add any new parameters,
+ * your code will still work (they'll be set to reasonable defaults).
+ */
+
+GLOBAL void
+jpeg_set_defaults (j_compress_ptr cinfo)
+{
+  int i;
+
+  /* Safety check to ensure start_compress not called yet. */
+  if (cinfo->global_state != CSTATE_START)
+    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+
+  /* Allocate comp_info array large enough for maximum component count.
+   * Array is made permanent in case application wants to compress
+   * multiple images at same param settings.
+   */
+  if (cinfo->comp_info == NULL)
+    cinfo->comp_info = (jpeg_component_info *)
+      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
+				  MAX_COMPONENTS * SIZEOF(jpeg_component_info));
+
+  /* Initialize everything not dependent on the color space */
+
+  cinfo->data_precision = BITS_IN_JSAMPLE;
+  /* Set up two quantization tables using default quality of 75 */
+  jpeg_set_quality(cinfo, 75, TRUE);
+  /* Set up two Huffman tables */
+  std_huff_tables(cinfo);
+
+  /* Initialize default arithmetic coding conditioning */
+  for (i = 0; i < NUM_ARITH_TBLS; i++) {
+    cinfo->arith_dc_L[i] = 0;
+    cinfo->arith_dc_U[i] = 1;
+    cinfo->arith_ac_K[i] = 5;
+  }
+
+  /* Default is no multiple-scan output */
+  cinfo->scan_info = NULL;
+  cinfo->num_scans = 0;
+
+  /* Expect normal source image, not raw downsampled data */
+  cinfo->raw_data_in = FALSE;
+
+  /* Use Huffman coding, not arithmetic coding, by default */
+  cinfo->arith_code = FALSE;
+
+  /* By default, do extra passes to optimize entropy coding */
+  cinfo->optimize_coding = TRUE;
+  /* The standard Huffman tables are only valid for 8-bit data precision.
+   * If the precision is higher, force optimization on so that usable
+   * tables will be computed.  This test can be removed if default tables
+   * are supplied that are valid for the desired precision.
+   */
+  if (cinfo->data_precision > 8)
+    cinfo->optimize_coding = TRUE;
+
+  /* By default, use the simpler non-cosited sampling alignment */
+  cinfo->CCIR601_sampling = FALSE;
+
+  /* No input smoothing */
+  cinfo->smoothing_factor = 0;
+
+  /* DCT algorithm preference */
+  cinfo->dct_method = JDCT_DEFAULT;
+
+  /* No restart markers */
+  cinfo->restart_interval = 0;
+  cinfo->restart_in_rows = 0;
+
+  /* Fill in default JFIF marker parameters.  Note that whether the marker
+   * will actually be written is determined by jpeg_set_colorspace.
+   */
+  cinfo->density_unit = 0;	/* Pixel size is unknown by default */
+  cinfo->X_density = 1;		/* Pixel aspect ratio is square by default */
+  cinfo->Y_density = 1;
+
+  /* Choose JPEG colorspace based on input space, set defaults accordingly */
+
+  jpeg_default_colorspace(cinfo);
+}
+
+
+/*
+ * Select an appropriate JPEG colorspace for in_color_space.
+ */
+
+GLOBAL void
+jpeg_default_colorspace (j_compress_ptr cinfo)
+{
+  switch (cinfo->in_color_space) {
+  case JCS_GRAYSCALE:
+    jpeg_set_colorspace(cinfo, JCS_GRAYSCALE);
+    break;
+  case JCS_RGB:
+    jpeg_set_colorspace(cinfo, JCS_YCbCr);
+    break;
+  case JCS_YCbCr:
+    jpeg_set_colorspace(cinfo, JCS_YCbCr);
+    break;
+  case JCS_CMYK:
+    jpeg_set_colorspace(cinfo, JCS_CMYK); /* By default, no translation */
+    break;
+  case JCS_YCCK:
+    jpeg_set_colorspace(cinfo, JCS_YCCK);
+    break;
+  case JCS_UNKNOWN:
+    jpeg_set_colorspace(cinfo, JCS_UNKNOWN);
+    break;
+  default:
+    ERREXIT(cinfo, JERR_BAD_IN_COLORSPACE);
+  }
+}
+
+
+/*
+ * Set the JPEG colorspace, and choose colorspace-dependent default values.
+ */
+
+GLOBAL void
+jpeg_set_colorspace (j_compress_ptr cinfo, J_COLOR_SPACE colorspace)
+{
+  jpeg_component_info * compptr;
+  int ci;
+
+#define SET_COMP(index,id,hsamp,vsamp,quant,dctbl,actbl)  \
+  (compptr = &cinfo->comp_info[index], \
+   compptr->component_id = (id), \
+   compptr->h_samp_factor = (hsamp), \
+   compptr->v_samp_factor = (vsamp), \
+   compptr->quant_tbl_no = (quant), \
+   compptr->dc_tbl_no = (dctbl), \
+   compptr->ac_tbl_no = (actbl) )
+
+  /* Safety check to ensure start_compress not called yet. */
+  if (cinfo->global_state != CSTATE_START)
+    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+
+  /* For all colorspaces, we use Q and Huff tables 0 for luminance components,
+   * tables 1 for chrominance components.
+   */
+
+  cinfo->jpeg_color_space = colorspace;
+
+  cinfo->write_JFIF_header = FALSE; /* No marker for non-JFIF colorspaces */
+  cinfo->write_Adobe_marker = FALSE; /* write no Adobe marker by default */
+
+  switch (colorspace) {
+  case JCS_GRAYSCALE:
+    cinfo->write_JFIF_header = TRUE; /* Write a JFIF marker */
+    cinfo->num_components = 1;
+    /* JFIF specifies component ID 1 */
+    SET_COMP(0, 1, 1,1, 0, 0,0);
+    break;
+  case JCS_RGB:
+    cinfo->write_Adobe_marker = TRUE; /* write Adobe marker to flag RGB */
+    cinfo->num_components = 3;
+    SET_COMP(0, 0x52 /* 'R' */, 1,1, 0, 0,0);
+    SET_COMP(1, 0x47 /* 'G' */, 1,1, 0, 0,0);
+    SET_COMP(2, 0x42 /* 'B' */, 1,1, 0, 0,0);
+    break;
+  case JCS_YCbCr:
+    cinfo->write_JFIF_header = TRUE; /* Write a JFIF marker */
+    cinfo->num_components = 3;
+    /* JFIF specifies component IDs 1,2,3 */
+    /* We default to 2x2 subsamples of chrominance */
+    SET_COMP(0, 1, 2,2, 0, 0,0);
+    SET_COMP(1, 2, 1,1, 1, 1,1);
+    SET_COMP(2, 3, 1,1, 1, 1,1);
+    break;
+  case JCS_CMYK:
+    cinfo->write_Adobe_marker = TRUE; /* write Adobe marker to flag CMYK */
+    cinfo->num_components = 4;
+    SET_COMP(0, 0x43 /* 'C' */, 1,1, 0, 0,0);
+    SET_COMP(1, 0x4D /* 'M' */, 1,1, 0, 0,0);
+    SET_COMP(2, 0x59 /* 'Y' */, 1,1, 0, 0,0);
+    SET_COMP(3, 0x4B /* 'K' */, 1,1, 0, 0,0);
+    break;
+  case JCS_YCCK:
+    cinfo->write_Adobe_marker = TRUE; /* write Adobe marker to flag YCCK */
+    cinfo->num_components = 4;
+    SET_COMP(0, 1, 2,2, 0, 0,0);
+    SET_COMP(1, 2, 1,1, 1, 1,1);
+    SET_COMP(2, 3, 1,1, 1, 1,1);
+    SET_COMP(3, 4, 2,2, 0, 0,0);
+    break;
+  case JCS_UNKNOWN:
+    cinfo->num_components = cinfo->input_components;
+    if (cinfo->num_components < 1 || cinfo->num_components > MAX_COMPONENTS)
+      ERREXIT2(cinfo, JERR_COMPONENT_COUNT, cinfo->num_components,
+	       MAX_COMPONENTS);
+    for (ci = 0; ci < cinfo->num_components; ci++) {
+      SET_COMP(ci, ci, 1,1, 0, 0,0);
+    }
+    break;
+  default:
+    ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
+  }
+}
+
+
+#ifdef C_PROGRESSIVE_SUPPORTED
+
+LOCAL jpeg_scan_info *
+fill_a_scan (jpeg_scan_info * scanptr, int ci,
+	     int Ss, int Se, int Ah, int Al)
+/* Support routine: generate one scan for specified component */
+{
+  scanptr->comps_in_scan = 1;
+  scanptr->component_index[0] = ci;
+  scanptr->Ss = Ss;
+  scanptr->Se = Se;
+  scanptr->Ah = Ah;
+  scanptr->Al = Al;
+  scanptr++;
+  return scanptr;
+}
+
+LOCAL jpeg_scan_info *
+fill_scans (jpeg_scan_info * scanptr, int ncomps,
+	    int Ss, int Se, int Ah, int Al)
+/* Support routine: generate one scan for each component */
+{
+  int ci;
+
+  for (ci = 0; ci < ncomps; ci++) {
+    scanptr->comps_in_scan = 1;
+    scanptr->component_index[0] = ci;
+    scanptr->Ss = Ss;
+    scanptr->Se = Se;
+    scanptr->Ah = Ah;
+    scanptr->Al = Al;
+    scanptr++;
+  }
+  return scanptr;
+}
+
+LOCAL jpeg_scan_info *
+fill_dc_scans (jpeg_scan_info * scanptr, int ncomps, int Ah, int Al)
+/* Support routine: generate interleaved DC scan if possible, else N scans */
+{
+  int ci;
+
+  if (ncomps <= MAX_COMPS_IN_SCAN) {
+    /* Single interleaved DC scan */
+    scanptr->comps_in_scan = ncomps;
+    for (ci = 0; ci < ncomps; ci++)
+      scanptr->component_index[ci] = ci;
+    scanptr->Ss = scanptr->Se = 0;
+    scanptr->Ah = Ah;
+    scanptr->Al = Al;
+    scanptr++;
+  } else {
+    /* Noninterleaved DC scan for each component */
+    scanptr = fill_scans(scanptr, ncomps, 0, 0, Ah, Al);
+  }
+  return scanptr;
+}
+
+
+/*
+ * Create a recommended progressive-JPEG script.
+ * cinfo->num_components and cinfo->jpeg_color_space must be correct.
+ */
+
+GLOBAL void
+jpeg_simple_progression (j_compress_ptr cinfo)
+{
+  int ncomps = cinfo->num_components;
+  int nscans;
+  jpeg_scan_info * scanptr;
+
+  /* Safety check to ensure start_compress not called yet. */
+  if (cinfo->global_state != CSTATE_START)
+    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+
+  /* Figure space needed for script.  Calculation must match code below! */
+  if (ncomps == 3 && cinfo->jpeg_color_space == JCS_YCbCr) {
+    /* Custom script for YCbCr color images. */
+    nscans = 10;
+  } else {
+    /* All-purpose script for other color spaces. */
+    if (ncomps > MAX_COMPS_IN_SCAN)
+      nscans = 6 * ncomps;	/* 2 DC + 4 AC scans per component */
+    else
+      nscans = 2 + 4 * ncomps;	/* 2 DC scans; 4 AC scans per component */
+  }
+
+  /* Allocate space for script. */
+  /* We use permanent pool just in case application re-uses script. */
+  scanptr = (jpeg_scan_info *)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
+				nscans * SIZEOF(jpeg_scan_info));
+  cinfo->scan_info = scanptr;
+  cinfo->num_scans = nscans;
+
+  if (ncomps == 3 && cinfo->jpeg_color_space == JCS_YCbCr) {
+    /* Custom script for YCbCr color images. */
+    /* Initial DC scan */
+    scanptr = fill_dc_scans(scanptr, ncomps, 0, 1);
+    /* Initial AC scan: get some luma data out in a hurry */
+    scanptr = fill_a_scan(scanptr, 0, 1, 5, 0, 2);
+    /* Chroma data is too small to be worth expending many scans on */
+    scanptr = fill_a_scan(scanptr, 2, 1, 63, 0, 1);
+    scanptr = fill_a_scan(scanptr, 1, 1, 63, 0, 1);
+    /* Complete spectral selection for luma AC */
+    scanptr = fill_a_scan(scanptr, 0, 6, 63, 0, 2);
+    /* Refine next bit of luma AC */
+    scanptr = fill_a_scan(scanptr, 0, 1, 63, 2, 1);
+    /* Finish DC successive approximation */
+    scanptr = fill_dc_scans(scanptr, ncomps, 1, 0);
+    /* Finish AC successive approximation */
+    scanptr = fill_a_scan(scanptr, 2, 1, 63, 1, 0);
+    scanptr = fill_a_scan(scanptr, 1, 1, 63, 1, 0);
+    /* Luma bottom bit comes last since it's usually largest scan */
+    scanptr = fill_a_scan(scanptr, 0, 1, 63, 1, 0);
+  } else {
+    /* All-purpose script for other color spaces. */
+    /* Successive approximation first pass */
+    scanptr = fill_dc_scans(scanptr, ncomps, 0, 1);
+    scanptr = fill_scans(scanptr, ncomps, 1, 5, 0, 2);
+    scanptr = fill_scans(scanptr, ncomps, 6, 63, 0, 2);
+    /* Successive approximation second pass */
+    scanptr = fill_scans(scanptr, ncomps, 1, 63, 2, 1);
+    /* Successive approximation final pass */
+    scanptr = fill_dc_scans(scanptr, ncomps, 1, 0);
+    scanptr = fill_scans(scanptr, ncomps, 1, 63, 1, 0);
+  }
+}
+
+#endif /* C_PROGRESSIVE_SUPPORTED */
diff --git a/codemp/jpeg-6/jcphuff.cpp b/codemp/jpeg-6/jcphuff.cpp
new file mode 100644
index 0000000..2fadde6
--- /dev/null
+++ b/codemp/jpeg-6/jcphuff.cpp
@@ -0,0 +1,831 @@
+/*
+ * jcphuff.c
+ *
+ * Copyright (C) 1995, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains Huffman entropy encoding routines for progressive JPEG.
+ *
+ * We do not support output suspension in this module, since the library
+ * currently does not allow multiple-scan files to be written with output
+ * suspension.
+ */
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jchuff.h"		/* Declarations shared with jchuff.c */
+
+#ifdef C_PROGRESSIVE_SUPPORTED
+
+/* Expanded entropy encoder object for progressive Huffman encoding. */
+
+typedef struct {
+  struct jpeg_entropy_encoder pub; /* public fields */
+
+  /* Mode flag: TRUE for optimization, FALSE for actual data output */
+  boolean gather_statistics;
+
+  /* Bit-level coding status.
+   * next_output_byte/free_in_buffer are local copies of cinfo->dest fields.
+   */
+  JOCTET * next_output_byte;	/* => next byte to write in buffer */
+  size_t free_in_buffer;	/* # of byte spaces remaining in buffer */
+  INT32 put_buffer;		/* current bit-accumulation buffer */
+  int put_bits;			/* # of bits now in it */
+  j_compress_ptr cinfo;		/* link to cinfo (needed for dump_buffer) */
+
+  /* Coding status for DC components */
+  int last_dc_val[MAX_COMPS_IN_SCAN]; /* last DC coef for each component */
+
+  /* Coding status for AC components */
+  int ac_tbl_no;		/* the table number of the single component */
+  unsigned int EOBRUN;		/* run length of EOBs */
+  unsigned int BE;		/* # of buffered correction bits before MCU */
+  char * bit_buffer;		/* buffer for correction bits (1 per char) */
+  /* packing correction bits tightly would save some space but cost time... */
+
+  unsigned int restarts_to_go;	/* MCUs left in this restart interval */
+  int next_restart_num;		/* next restart number to write (0-7) */
+
+  /* Pointers to derived tables (these workspaces have image lifespan).
+   * Since any one scan codes only DC or only AC, we only need one set
+   * of tables, not one for DC and one for AC.
+   */
+  c_derived_tbl * derived_tbls[NUM_HUFF_TBLS];
+
+  /* Statistics tables for optimization; again, one set is enough */
+  long * count_ptrs[NUM_HUFF_TBLS];
+} phuff_entropy_encoder;
+
+typedef phuff_entropy_encoder * phuff_entropy_ptr;
+
+/* MAX_CORR_BITS is the number of bits the AC refinement correction-bit
+ * buffer can hold.  Larger sizes may slightly improve compression, but
+ * 1000 is already well into the realm of overkill.
+ * The minimum safe size is 64 bits.
+ */
+
+#define MAX_CORR_BITS  1000	/* Max # of correction bits I can buffer */
+
+/* IRIGHT_SHIFT is like RIGHT_SHIFT, but works on int rather than INT32.
+ * We assume that int right shift is unsigned if INT32 right shift is,
+ * which should be safe.
+ */
+
+#ifdef RIGHT_SHIFT_IS_UNSIGNED
+#define ISHIFT_TEMPS	int ishift_temp;
+#define IRIGHT_SHIFT(x,shft)  \
+	((ishift_temp = (x)) < 0 ? \
+	 (ishift_temp >> (shft)) | ((~0) << (16-(shft))) : \
+	 (ishift_temp >> (shft)))
+#else
+#define ISHIFT_TEMPS
+#define IRIGHT_SHIFT(x,shft)	((x) >> (shft))
+#endif
+
+/* Forward declarations */
+METHODDEF boolean encode_mcu_DC_first JPP((j_compress_ptr cinfo,
+					   JBLOCKROW *MCU_data));
+METHODDEF boolean encode_mcu_AC_first JPP((j_compress_ptr cinfo,
+					   JBLOCKROW *MCU_data));
+METHODDEF boolean encode_mcu_DC_refine JPP((j_compress_ptr cinfo,
+					    JBLOCKROW *MCU_data));
+METHODDEF boolean encode_mcu_AC_refine JPP((j_compress_ptr cinfo,
+					    JBLOCKROW *MCU_data));
+METHODDEF void finish_pass_phuff JPP((j_compress_ptr cinfo));
+METHODDEF void finish_pass_gather_phuff JPP((j_compress_ptr cinfo));
+
+
+/*
+ * Initialize for a Huffman-compressed scan using progressive JPEG.
+ */
+
+METHODDEF void
+start_pass_phuff (j_compress_ptr cinfo, boolean gather_statistics)
+{  
+  phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy;
+  boolean is_DC_band;
+  int ci, tbl;
+  jpeg_component_info * compptr;
+
+  entropy->cinfo = cinfo;
+  entropy->gather_statistics = gather_statistics;
+
+  is_DC_band = (cinfo->Ss == 0);
+
+  /* We assume jcmaster.c already validated the scan parameters. */
+
+  /* Select execution routines */
+  if (cinfo->Ah == 0) {
+    if (is_DC_band)
+      entropy->pub.encode_mcu = encode_mcu_DC_first;
+    else
+      entropy->pub.encode_mcu = encode_mcu_AC_first;
+  } else {
+    if (is_DC_band)
+      entropy->pub.encode_mcu = encode_mcu_DC_refine;
+    else {
+      entropy->pub.encode_mcu = encode_mcu_AC_refine;
+      /* AC refinement needs a correction bit buffer */
+      if (entropy->bit_buffer == NULL)
+	entropy->bit_buffer = (char *)
+	  (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				      MAX_CORR_BITS * SIZEOF(char));
+    }
+  }
+  if (gather_statistics)
+    entropy->pub.finish_pass = finish_pass_gather_phuff;
+  else
+    entropy->pub.finish_pass = finish_pass_phuff;
+
+  /* Only DC coefficients may be interleaved, so cinfo->comps_in_scan = 1
+   * for AC coefficients.
+   */
+  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+    compptr = cinfo->cur_comp_info[ci];
+    /* Initialize DC predictions to 0 */
+    entropy->last_dc_val[ci] = 0;
+    /* Make sure requested tables are present */
+    /* (In gather mode, tables need not be allocated yet) */
+    if (is_DC_band) {
+      if (cinfo->Ah != 0)	/* DC refinement needs no table */
+	continue;
+      tbl = compptr->dc_tbl_no;
+      if (tbl < 0 || tbl >= NUM_HUFF_TBLS ||
+	  (cinfo->dc_huff_tbl_ptrs[tbl] == NULL && !gather_statistics))
+	ERREXIT1(cinfo,JERR_NO_HUFF_TABLE, tbl);
+    } else {
+      entropy->ac_tbl_no = tbl = compptr->ac_tbl_no;
+      if (tbl < 0 || tbl >= NUM_HUFF_TBLS ||
+          (cinfo->ac_huff_tbl_ptrs[tbl] == NULL && !gather_statistics))
+        ERREXIT1(cinfo,JERR_NO_HUFF_TABLE, tbl);
+    }
+    if (gather_statistics) {
+      /* Allocate and zero the statistics tables */
+      /* Note that jpeg_gen_optimal_table expects 257 entries in each table! */
+      if (entropy->count_ptrs[tbl] == NULL)
+	entropy->count_ptrs[tbl] = (long *)
+	  (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				      257 * SIZEOF(long));
+      MEMZERO(entropy->count_ptrs[tbl], 257 * SIZEOF(long));
+    } else {
+      /* Compute derived values for Huffman tables */
+      /* We may do this more than once for a table, but it's not expensive */
+      if (is_DC_band)
+        jpeg_make_c_derived_tbl(cinfo, cinfo->dc_huff_tbl_ptrs[tbl],
+				& entropy->derived_tbls[tbl]);
+      else
+        jpeg_make_c_derived_tbl(cinfo, cinfo->ac_huff_tbl_ptrs[tbl],
+				& entropy->derived_tbls[tbl]);
+    }
+  }
+
+  /* Initialize AC stuff */
+  entropy->EOBRUN = 0;
+  entropy->BE = 0;
+
+  /* Initialize bit buffer to empty */
+  entropy->put_buffer = 0;
+  entropy->put_bits = 0;
+
+  /* Initialize restart stuff */
+  entropy->restarts_to_go = cinfo->restart_interval;
+  entropy->next_restart_num = 0;
+}
+
+
+/* Outputting bytes to the file.
+ * NB: these must be called only when actually outputting,
+ * that is, entropy->gather_statistics == FALSE.
+ */
+
+/* Emit a byte */
+#define emit_byte(entropy,val)  \
+	{ *(entropy)->next_output_byte++ = (JOCTET) (val);  \
+	  if (--(entropy)->free_in_buffer == 0)  \
+	    dump_buffer(entropy); }
+
+
+LOCAL void
+dump_buffer (phuff_entropy_ptr entropy)
+/* Empty the output buffer; we do not support suspension in this module. */
+{
+  struct jpeg_destination_mgr * dest = entropy->cinfo->dest;
+
+  if (! (*dest->empty_output_buffer) (entropy->cinfo))
+    ERREXIT(entropy->cinfo, JERR_CANT_SUSPEND);
+  /* After a successful buffer dump, must reset buffer pointers */
+  entropy->next_output_byte = dest->next_output_byte;
+  entropy->free_in_buffer = dest->free_in_buffer;
+}
+
+
+/* Outputting bits to the file */
+
+/* Only the right 24 bits of put_buffer are used; the valid bits are
+ * left-justified in this part.  At most 16 bits can be passed to emit_bits
+ * in one call, and we never retain more than 7 bits in put_buffer
+ * between calls, so 24 bits are sufficient.
+ */
+
+INLINE
+LOCAL void
+emit_bits (phuff_entropy_ptr entropy, unsigned int code, int size)
+/* Emit some bits, unless we are in gather mode */
+{
+  /* This routine is heavily used, so it's worth coding tightly. */
+  register INT32 put_buffer = (INT32) code;
+  register int put_bits = entropy->put_bits;
+
+  /* if size is 0, caller used an invalid Huffman table entry */
+  if (size == 0)
+    ERREXIT(entropy->cinfo, JERR_HUFF_MISSING_CODE);
+
+  if (entropy->gather_statistics)
+    return;			/* do nothing if we're only getting stats */
+
+  put_buffer &= (((INT32) 1)<<size) - 1; /* mask off any extra bits in code */
+  
+  put_bits += size;		/* new number of bits in buffer */
+  
+  put_buffer <<= 24 - put_bits; /* align incoming bits */
+
+  put_buffer |= entropy->put_buffer; /* and merge with old buffer contents */
+
+  while (put_bits >= 8) {
+    int c = (int) ((put_buffer >> 16) & 0xFF);
+    
+    emit_byte(entropy, c);
+    if (c == 0xFF) {		/* need to stuff a zero byte? */
+      emit_byte(entropy, 0);
+    }
+    put_buffer <<= 8;
+    put_bits -= 8;
+  }
+
+  entropy->put_buffer = put_buffer; /* update variables */
+  entropy->put_bits = put_bits;
+}
+
+
+LOCAL void
+flush_bits (phuff_entropy_ptr entropy)
+{
+  emit_bits(entropy, 0x7F, 7); /* fill any partial byte with ones */
+  entropy->put_buffer = 0;     /* and reset bit-buffer to empty */
+  entropy->put_bits = 0;
+}
+
+
+/*
+ * Emit (or just count) a Huffman symbol.
+ */
+
+INLINE
+LOCAL void
+emit_symbol (phuff_entropy_ptr entropy, int tbl_no, int symbol)
+{
+  if (entropy->gather_statistics)
+    entropy->count_ptrs[tbl_no][symbol]++;
+  else {
+    c_derived_tbl * tbl = entropy->derived_tbls[tbl_no];
+    emit_bits(entropy, tbl->ehufco[symbol], tbl->ehufsi[symbol]);
+  }
+}
+
+
+/*
+ * Emit bits from a correction bit buffer.
+ */
+
+LOCAL void
+emit_buffered_bits (phuff_entropy_ptr entropy, char * bufstart,
+		    unsigned int nbits)
+{
+  if (entropy->gather_statistics)
+    return;			/* no real work */
+
+  while (nbits > 0) {
+    emit_bits(entropy, (unsigned int) (*bufstart), 1);
+    bufstart++;
+    nbits--;
+  }
+}
+
+
+/*
+ * Emit any pending EOBRUN symbol.
+ */
+
+LOCAL void
+emit_eobrun (phuff_entropy_ptr entropy)
+{
+  register int temp, nbits;
+
+  if (entropy->EOBRUN > 0) {	/* if there is any pending EOBRUN */
+    temp = entropy->EOBRUN;
+    nbits = 0;
+    while ((temp >>= 1))
+      nbits++;
+
+    emit_symbol(entropy, entropy->ac_tbl_no, nbits << 4);
+    if (nbits)
+      emit_bits(entropy, entropy->EOBRUN, nbits);
+
+    entropy->EOBRUN = 0;
+
+    /* Emit any buffered correction bits */
+    emit_buffered_bits(entropy, entropy->bit_buffer, entropy->BE);
+    entropy->BE = 0;
+  }
+}
+
+
+/*
+ * Emit a restart marker & resynchronize predictions.
+ */
+
+LOCAL void
+emit_restart (phuff_entropy_ptr entropy, int restart_num)
+{
+  int ci;
+
+  emit_eobrun(entropy);
+
+  if (! entropy->gather_statistics) {
+    flush_bits(entropy);
+    emit_byte(entropy, 0xFF);
+    emit_byte(entropy, JPEG_RST0 + restart_num);
+  }
+
+  if (entropy->cinfo->Ss == 0) {
+    /* Re-initialize DC predictions to 0 */
+    for (ci = 0; ci < entropy->cinfo->comps_in_scan; ci++)
+      entropy->last_dc_val[ci] = 0;
+  } else {
+    /* Re-initialize all AC-related fields to 0 */
+    entropy->EOBRUN = 0;
+    entropy->BE = 0;
+  }
+}
+
+
+/*
+ * MCU encoding for DC initial scan (either spectral selection,
+ * or first pass of successive approximation).
+ */
+
+METHODDEF boolean
+encode_mcu_DC_first (j_compress_ptr cinfo, JBLOCKROW *MCU_data)
+{
+  phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy;
+  register int temp, temp2;
+  register int nbits;
+  int blkn, ci;
+  int Al = cinfo->Al;
+  JBLOCKROW block;
+  jpeg_component_info * compptr;
+  ISHIFT_TEMPS
+
+  entropy->next_output_byte = cinfo->dest->next_output_byte;
+  entropy->free_in_buffer = cinfo->dest->free_in_buffer;
+
+  /* Emit restart marker if needed */
+  if (cinfo->restart_interval)
+    if (entropy->restarts_to_go == 0)
+      emit_restart(entropy, entropy->next_restart_num);
+
+  /* Encode the MCU data blocks */
+  for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
+    block = MCU_data[blkn];
+    ci = cinfo->MCU_membership[blkn];
+    compptr = cinfo->cur_comp_info[ci];
+
+    /* Compute the DC value after the required point transform by Al.
+     * This is simply an arithmetic right shift.
+     */
+    temp2 = IRIGHT_SHIFT((int) ((*block)[0]), Al);
+
+    /* DC differences are figured on the point-transformed values. */
+    temp = temp2 - entropy->last_dc_val[ci];
+    entropy->last_dc_val[ci] = temp2;
+
+    /* Encode the DC coefficient difference per section G.1.2.1 */
+    temp2 = temp;
+    if (temp < 0) {
+      temp = -temp;		/* temp is abs value of input */
+      /* For a negative input, want temp2 = bitwise complement of abs(input) */
+      /* This code assumes we are on a two's complement machine */
+      temp2--;
+    }
+    
+    /* Find the number of bits needed for the magnitude of the coefficient */
+    nbits = 0;
+    while (temp) {
+      nbits++;
+      temp >>= 1;
+    }
+    
+    /* Count/emit the Huffman-coded symbol for the number of bits */
+    emit_symbol(entropy, compptr->dc_tbl_no, nbits);
+    
+    /* Emit that number of bits of the value, if positive, */
+    /* or the complement of its magnitude, if negative. */
+    if (nbits)			/* emit_bits rejects calls with size 0 */
+      emit_bits(entropy, (unsigned int) temp2, nbits);
+  }
+
+  cinfo->dest->next_output_byte = entropy->next_output_byte;
+  cinfo->dest->free_in_buffer = entropy->free_in_buffer;
+
+  /* Update restart-interval state too */
+  if (cinfo->restart_interval) {
+    if (entropy->restarts_to_go == 0) {
+      entropy->restarts_to_go = cinfo->restart_interval;
+      entropy->next_restart_num++;
+      entropy->next_restart_num &= 7;
+    }
+    entropy->restarts_to_go--;
+  }
+
+  return TRUE;
+}
+
+
+/*
+ * MCU encoding for AC initial scan (either spectral selection,
+ * or first pass of successive approximation).
+ */
+
+METHODDEF boolean
+encode_mcu_AC_first (j_compress_ptr cinfo, JBLOCKROW *MCU_data)
+{
+  phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy;
+  register int temp, temp2;
+  register int nbits;
+  register int r, k;
+  int Se = cinfo->Se;
+  int Al = cinfo->Al;
+  JBLOCKROW block;
+
+  entropy->next_output_byte = cinfo->dest->next_output_byte;
+  entropy->free_in_buffer = cinfo->dest->free_in_buffer;
+
+  /* Emit restart marker if needed */
+  if (cinfo->restart_interval)
+    if (entropy->restarts_to_go == 0)
+      emit_restart(entropy, entropy->next_restart_num);
+
+  /* Encode the MCU data block */
+  block = MCU_data[0];
+
+  /* Encode the AC coefficients per section G.1.2.2, fig. G.3 */
+  
+  r = 0;			/* r = run length of zeros */
+   
+  for (k = cinfo->Ss; k <= Se; k++) {
+    if ((temp = (*block)[jpeg_natural_order[k]]) == 0) {
+      r++;
+      continue;
+    }
+    /* We must apply the point transform by Al.  For AC coefficients this
+     * is an integer division with rounding towards 0.  To do this portably
+     * in C, we shift after obtaining the absolute value; so the code is
+     * interwoven with finding the abs value (temp) and output bits (temp2).
+     */
+    if (temp < 0) {
+      temp = -temp;		/* temp is abs value of input */
+      temp >>= Al;		/* apply the point transform */
+      /* For a negative coef, want temp2 = bitwise complement of abs(coef) */
+      temp2 = ~temp;
+    } else {
+      temp >>= Al;		/* apply the point transform */
+      temp2 = temp;
+    }
+    /* Watch out for case that nonzero coef is zero after point transform */
+    if (temp == 0) {
+      r++;
+      continue;
+    }
+
+    /* Emit any pending EOBRUN */
+    if (entropy->EOBRUN > 0)
+      emit_eobrun(entropy);
+    /* if run length > 15, must emit special run-length-16 codes (0xF0) */
+    while (r > 15) {
+      emit_symbol(entropy, entropy->ac_tbl_no, 0xF0);
+      r -= 16;
+    }
+
+    /* Find the number of bits needed for the magnitude of the coefficient */
+    nbits = 1;			/* there must be at least one 1 bit */
+    while ((temp >>= 1))
+      nbits++;
+
+    /* Count/emit Huffman symbol for run length / number of bits */
+    emit_symbol(entropy, entropy->ac_tbl_no, (r << 4) + nbits);
+
+    /* Emit that number of bits of the value, if positive, */
+    /* or the complement of its magnitude, if negative. */
+    emit_bits(entropy, (unsigned int) temp2, nbits);
+
+    r = 0;			/* reset zero run length */
+  }
+
+  if (r > 0) {			/* If there are trailing zeroes, */
+    entropy->EOBRUN++;		/* count an EOB */
+    if (entropy->EOBRUN == 0x7FFF)
+      emit_eobrun(entropy);	/* force it out to avoid overflow */
+  }
+
+  cinfo->dest->next_output_byte = entropy->next_output_byte;
+  cinfo->dest->free_in_buffer = entropy->free_in_buffer;
+
+  /* Update restart-interval state too */
+  if (cinfo->restart_interval) {
+    if (entropy->restarts_to_go == 0) {
+      entropy->restarts_to_go = cinfo->restart_interval;
+      entropy->next_restart_num++;
+      entropy->next_restart_num &= 7;
+    }
+    entropy->restarts_to_go--;
+  }
+
+  return TRUE;
+}
+
+
+/*
+ * MCU encoding for DC successive approximation refinement scan.
+ * Note: we assume such scans can be multi-component, although the spec
+ * is not very clear on the point.
+ */
+
+METHODDEF boolean
+encode_mcu_DC_refine (j_compress_ptr cinfo, JBLOCKROW *MCU_data)
+{
+  phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy;
+  register int temp;
+  int blkn;
+  int Al = cinfo->Al;
+  JBLOCKROW block;
+
+  entropy->next_output_byte = cinfo->dest->next_output_byte;
+  entropy->free_in_buffer = cinfo->dest->free_in_buffer;
+
+  /* Emit restart marker if needed */
+  if (cinfo->restart_interval)
+    if (entropy->restarts_to_go == 0)
+      emit_restart(entropy, entropy->next_restart_num);
+
+  /* Encode the MCU data blocks */
+  for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
+    block = MCU_data[blkn];
+
+    /* We simply emit the Al'th bit of the DC coefficient value. */
+    temp = (*block)[0];
+    emit_bits(entropy, (unsigned int) (temp >> Al), 1);
+  }
+
+  cinfo->dest->next_output_byte = entropy->next_output_byte;
+  cinfo->dest->free_in_buffer = entropy->free_in_buffer;
+
+  /* Update restart-interval state too */
+  if (cinfo->restart_interval) {
+    if (entropy->restarts_to_go == 0) {
+      entropy->restarts_to_go = cinfo->restart_interval;
+      entropy->next_restart_num++;
+      entropy->next_restart_num &= 7;
+    }
+    entropy->restarts_to_go--;
+  }
+
+  return TRUE;
+}
+
+
+/*
+ * MCU encoding for AC successive approximation refinement scan.
+ */
+
+METHODDEF boolean
+encode_mcu_AC_refine (j_compress_ptr cinfo, JBLOCKROW *MCU_data)
+{
+  phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy;
+  register int temp;
+  register int r, k;
+  int EOB;
+  char *BR_buffer;
+  unsigned int BR;
+  int Se = cinfo->Se;
+  int Al = cinfo->Al;
+  JBLOCKROW block;
+  int absvalues[DCTSIZE2];
+
+  entropy->next_output_byte = cinfo->dest->next_output_byte;
+  entropy->free_in_buffer = cinfo->dest->free_in_buffer;
+
+  /* Emit restart marker if needed */
+  if (cinfo->restart_interval)
+    if (entropy->restarts_to_go == 0)
+      emit_restart(entropy, entropy->next_restart_num);
+
+  /* Encode the MCU data block */
+  block = MCU_data[0];
+
+  /* It is convenient to make a pre-pass to determine the transformed
+   * coefficients' absolute values and the EOB position.
+   */
+  EOB = 0;
+  for (k = cinfo->Ss; k <= Se; k++) {
+    temp = (*block)[jpeg_natural_order[k]];
+    /* We must apply the point transform by Al.  For AC coefficients this
+     * is an integer division with rounding towards 0.  To do this portably
+     * in C, we shift after obtaining the absolute value.
+     */
+    if (temp < 0)
+      temp = -temp;		/* temp is abs value of input */
+    temp >>= Al;		/* apply the point transform */
+    absvalues[k] = temp;	/* save abs value for main pass */
+    if (temp == 1)
+      EOB = k;			/* EOB = index of last newly-nonzero coef */
+  }
+
+  /* Encode the AC coefficients per section G.1.2.3, fig. G.7 */
+  
+  r = 0;			/* r = run length of zeros */
+  BR = 0;			/* BR = count of buffered bits added now */
+  BR_buffer = entropy->bit_buffer + entropy->BE; /* Append bits to buffer */
+
+  for (k = cinfo->Ss; k <= Se; k++) {
+    if ((temp = absvalues[k]) == 0) {
+      r++;
+      continue;
+    }
+
+    /* Emit any required ZRLs, but not if they can be folded into EOB */
+    while (r > 15 && k <= EOB) {
+      /* emit any pending EOBRUN and the BE correction bits */
+      emit_eobrun(entropy);
+      /* Emit ZRL */
+      emit_symbol(entropy, entropy->ac_tbl_no, 0xF0);
+      r -= 16;
+      /* Emit buffered correction bits that must be associated with ZRL */
+      emit_buffered_bits(entropy, BR_buffer, BR);
+      BR_buffer = entropy->bit_buffer; /* BE bits are gone now */
+      BR = 0;
+    }
+
+    /* If the coef was previously nonzero, it only needs a correction bit.
+     * NOTE: a straight translation of the spec's figure G.7 would suggest
+     * that we also need to test r > 15.  But if r > 15, we can only get here
+     * if k > EOB, which implies that this coefficient is not 1.
+     */
+    if (temp > 1) {
+      /* The correction bit is the next bit of the absolute value. */
+      BR_buffer[BR++] = (char) (temp & 1);
+      continue;
+    }
+
+    /* Emit any pending EOBRUN and the BE correction bits */
+    emit_eobrun(entropy);
+
+    /* Count/emit Huffman symbol for run length / number of bits */
+    emit_symbol(entropy, entropy->ac_tbl_no, (r << 4) + 1);
+
+    /* Emit output bit for newly-nonzero coef */
+    temp = ((*block)[jpeg_natural_order[k]] < 0) ? 0 : 1;
+    emit_bits(entropy, (unsigned int) temp, 1);
+
+    /* Emit buffered correction bits that must be associated with this code */
+    emit_buffered_bits(entropy, BR_buffer, BR);
+    BR_buffer = entropy->bit_buffer; /* BE bits are gone now */
+    BR = 0;
+    r = 0;			/* reset zero run length */
+  }
+
+  if (r > 0 || BR > 0) {	/* If there are trailing zeroes, */
+    entropy->EOBRUN++;		/* count an EOB */
+    entropy->BE += BR;		/* concat my correction bits to older ones */
+    /* We force out the EOB if we risk either:
+     * 1. overflow of the EOB counter;
+     * 2. overflow of the correction bit buffer during the next MCU.
+     */
+    if (entropy->EOBRUN == 0x7FFF || entropy->BE > (MAX_CORR_BITS-DCTSIZE2+1))
+      emit_eobrun(entropy);
+  }
+
+  cinfo->dest->next_output_byte = entropy->next_output_byte;
+  cinfo->dest->free_in_buffer = entropy->free_in_buffer;
+
+  /* Update restart-interval state too */
+  if (cinfo->restart_interval) {
+    if (entropy->restarts_to_go == 0) {
+      entropy->restarts_to_go = cinfo->restart_interval;
+      entropy->next_restart_num++;
+      entropy->next_restart_num &= 7;
+    }
+    entropy->restarts_to_go--;
+  }
+
+  return TRUE;
+}
+
+
+/*
+ * Finish up at the end of a Huffman-compressed progressive scan.
+ */
+
+METHODDEF void
+finish_pass_phuff (j_compress_ptr cinfo)
+{   
+  phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy;
+
+  entropy->next_output_byte = cinfo->dest->next_output_byte;
+  entropy->free_in_buffer = cinfo->dest->free_in_buffer;
+
+  /* Flush out any buffered data */
+  emit_eobrun(entropy);
+  flush_bits(entropy);
+
+  cinfo->dest->next_output_byte = entropy->next_output_byte;
+  cinfo->dest->free_in_buffer = entropy->free_in_buffer;
+}
+
+
+/*
+ * Finish up a statistics-gathering pass and create the new Huffman tables.
+ */
+
+METHODDEF void
+finish_pass_gather_phuff (j_compress_ptr cinfo)
+{
+  phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy;
+  boolean is_DC_band;
+  int ci, tbl;
+  jpeg_component_info * compptr;
+  JHUFF_TBL **htblptr;
+  boolean did[NUM_HUFF_TBLS];
+
+  /* Flush out buffered data (all we care about is counting the EOB symbol) */
+  emit_eobrun(entropy);
+
+  is_DC_band = (cinfo->Ss == 0);
+
+  /* It's important not to apply jpeg_gen_optimal_table more than once
+   * per table, because it clobbers the input frequency counts!
+   */
+  MEMZERO(did, SIZEOF(did));
+
+  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+    compptr = cinfo->cur_comp_info[ci];
+    if (is_DC_band) {
+      if (cinfo->Ah != 0)	/* DC refinement needs no table */
+	continue;
+      tbl = compptr->dc_tbl_no;
+    } else {
+      tbl = compptr->ac_tbl_no;
+    }
+    if (! did[tbl]) {
+      if (is_DC_band)
+        htblptr = & cinfo->dc_huff_tbl_ptrs[tbl];
+      else
+        htblptr = & cinfo->ac_huff_tbl_ptrs[tbl];
+      if (*htblptr == NULL)
+        *htblptr = jpeg_alloc_huff_table((j_common_ptr) cinfo);
+      jpeg_gen_optimal_table(cinfo, *htblptr, entropy->count_ptrs[tbl]);
+      did[tbl] = TRUE;
+    }
+  }
+}
+
+
+/*
+ * Module initialization routine for progressive Huffman entropy encoding.
+ */
+
+GLOBAL void
+jinit_phuff_encoder (j_compress_ptr cinfo)
+{
+  phuff_entropy_ptr entropy;
+  int i;
+
+  entropy = (phuff_entropy_ptr)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				SIZEOF(phuff_entropy_encoder));
+  cinfo->entropy = (struct jpeg_entropy_encoder *) entropy;
+  entropy->pub.start_pass = start_pass_phuff;
+
+  /* Mark tables unallocated */
+  for (i = 0; i < NUM_HUFF_TBLS; i++) {
+    entropy->derived_tbls[i] = NULL;
+    entropy->count_ptrs[i] = NULL;
+  }
+  entropy->bit_buffer = NULL;	/* needed only in AC refinement scan */
+}
+
+#endif /* C_PROGRESSIVE_SUPPORTED */
diff --git a/codemp/jpeg-6/jcprepct.cpp b/codemp/jpeg-6/jcprepct.cpp
new file mode 100644
index 0000000..67eef2b
--- /dev/null
+++ b/codemp/jpeg-6/jcprepct.cpp
@@ -0,0 +1,373 @@
+/*
+ * jcprepct.c
+ *
+ * Copyright (C) 1994, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains the compression preprocessing controller.
+ * This controller manages the color conversion, downsampling,
+ * and edge expansion steps.
+ *
+ * Most of the complexity here is associated with buffering input rows
+ * as required by the downsampler.  See the comments at the head of
+ * jcsample.c for the downsampler's needs.
+ */
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/* At present, jcsample.c can request context rows only for smoothing.
+ * In the future, we might also need context rows for CCIR601 sampling
+ * or other more-complex downsampling procedures.  The code to support
+ * context rows should be compiled only if needed.
+ */
+#ifdef INPUT_SMOOTHING_SUPPORTED
+#define CONTEXT_ROWS_SUPPORTED
+#endif
+
+
+/*
+ * For the simple (no-context-row) case, we just need to buffer one
+ * row group's worth of pixels for the downsampling step.  At the bottom of
+ * the image, we pad to a full row group by replicating the last pixel row.
+ * The downsampler's last output row is then replicated if needed to pad
+ * out to a full iMCU row.
+ *
+ * When providing context rows, we must buffer three row groups' worth of
+ * pixels.  Three row groups are physically allocated, but the row pointer
+ * arrays are made five row groups high, with the extra pointers above and
+ * below "wrapping around" to point to the last and first real row groups.
+ * This allows the downsampler to access the proper context rows.
+ * At the top and bottom of the image, we create dummy context rows by
+ * copying the first or last real pixel row.  This copying could be avoided
+ * by pointer hacking as is done in jdmainct.c, but it doesn't seem worth the
+ * trouble on the compression side.
+ */
+
+
+/* Private buffer controller object */
+
+typedef struct {
+  struct jpeg_c_prep_controller pub; /* public fields */
+
+  /* Downsampling input buffer.  This buffer holds color-converted data
+   * until we have enough to do a downsample step.
+   */
+  JSAMPARRAY color_buf[MAX_COMPONENTS];
+
+  JDIMENSION rows_to_go;	/* counts rows remaining in source image */
+  int next_buf_row;		/* index of next row to store in color_buf */
+
+#ifdef CONTEXT_ROWS_SUPPORTED	/* only needed for context case */
+  int this_row_group;		/* starting row index of group to process */
+  int next_buf_stop;		/* downsample when we reach this index */
+#endif
+} my_prep_controller;
+
+typedef my_prep_controller * my_prep_ptr;
+
+
+/*
+ * Initialize for a processing pass.
+ */
+
+METHODDEF void
+start_pass_prep (j_compress_ptr cinfo, J_BUF_MODE pass_mode)
+{
+  my_prep_ptr prep = (my_prep_ptr) cinfo->prep;
+
+  if (pass_mode != JBUF_PASS_THRU)
+    ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+
+  /* Initialize total-height counter for detecting bottom of image */
+  prep->rows_to_go = cinfo->image_height;
+  /* Mark the conversion buffer empty */
+  prep->next_buf_row = 0;
+#ifdef CONTEXT_ROWS_SUPPORTED
+  /* Preset additional state variables for context mode.
+   * These aren't used in non-context mode, so we needn't test which mode.
+   */
+  prep->this_row_group = 0;
+  /* Set next_buf_stop to stop after two row groups have been read in. */
+  prep->next_buf_stop = 2 * cinfo->max_v_samp_factor;
+#endif
+}
+
+
+/*
+ * Expand an image vertically from height input_rows to height output_rows,
+ * by duplicating the bottom row.
+ */
+
+LOCAL void
+expand_bottom_edge (JSAMPARRAY image_data, JDIMENSION num_cols,
+		    int input_rows, int output_rows)
+{
+  register int row;
+
+  for (row = input_rows; row < output_rows; row++) {
+    jcopy_sample_rows(image_data, input_rows-1, image_data, row,
+		      1, num_cols);
+  }
+}
+
+
+/*
+ * Process some data in the simple no-context case.
+ *
+ * Preprocessor output data is counted in "row groups".  A row group
+ * is defined to be v_samp_factor sample rows of each component.
+ * Downsampling will produce this much data from each max_v_samp_factor
+ * input rows.
+ */
+
+METHODDEF void
+pre_process_data (j_compress_ptr cinfo,
+		  JSAMPARRAY input_buf, JDIMENSION *in_row_ctr,
+		  JDIMENSION in_rows_avail,
+		  JSAMPIMAGE output_buf, JDIMENSION *out_row_group_ctr,
+		  JDIMENSION out_row_groups_avail)
+{
+  my_prep_ptr prep = (my_prep_ptr) cinfo->prep;
+  int numrows, ci;
+  JDIMENSION inrows;
+  jpeg_component_info * compptr;
+
+  while (*in_row_ctr < in_rows_avail &&
+	 *out_row_group_ctr < out_row_groups_avail) {
+    /* Do color conversion to fill the conversion buffer. */
+    inrows = in_rows_avail - *in_row_ctr;
+    numrows = cinfo->max_v_samp_factor - prep->next_buf_row;
+    numrows = (int) MIN((JDIMENSION) numrows, inrows);
+    (*cinfo->cconvert->color_convert) (cinfo, input_buf + *in_row_ctr,
+				       prep->color_buf,
+				       (JDIMENSION) prep->next_buf_row,
+				       numrows);
+    *in_row_ctr += numrows;
+    prep->next_buf_row += numrows;
+    prep->rows_to_go -= numrows;
+    /* If at bottom of image, pad to fill the conversion buffer. */
+    if (prep->rows_to_go == 0 &&
+	prep->next_buf_row < cinfo->max_v_samp_factor) {
+      for (ci = 0; ci < cinfo->num_components; ci++) {
+	expand_bottom_edge(prep->color_buf[ci], cinfo->image_width,
+			   prep->next_buf_row, cinfo->max_v_samp_factor);
+      }
+      prep->next_buf_row = cinfo->max_v_samp_factor;
+    }
+    /* If we've filled the conversion buffer, empty it. */
+    if (prep->next_buf_row == cinfo->max_v_samp_factor) {
+      (*cinfo->downsample->downsample) (cinfo,
+					prep->color_buf, (JDIMENSION) 0,
+					output_buf, *out_row_group_ctr);
+      prep->next_buf_row = 0;
+      (*out_row_group_ctr)++;
+    }
+    /* If at bottom of image, pad the output to a full iMCU height.
+     * Note we assume the caller is providing a one-iMCU-height output buffer!
+     */
+    if (prep->rows_to_go == 0 &&
+	*out_row_group_ctr < out_row_groups_avail) {
+      for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+	   ci++, compptr++) {
+	expand_bottom_edge(output_buf[ci],
+			   compptr->width_in_blocks * DCTSIZE,
+			   (int) (*out_row_group_ctr * compptr->v_samp_factor),
+			   (int) (out_row_groups_avail * compptr->v_samp_factor));
+      }
+      *out_row_group_ctr = out_row_groups_avail;
+      break;			/* can exit outer loop without test */
+    }
+  }
+}
+
+
+#ifdef CONTEXT_ROWS_SUPPORTED
+
+/*
+ * Process some data in the context case.
+ */
+
+METHODDEF void
+pre_process_context (j_compress_ptr cinfo,
+		     JSAMPARRAY input_buf, JDIMENSION *in_row_ctr,
+		     JDIMENSION in_rows_avail,
+		     JSAMPIMAGE output_buf, JDIMENSION *out_row_group_ctr,
+		     JDIMENSION out_row_groups_avail)
+{
+  my_prep_ptr prep = (my_prep_ptr) cinfo->prep;
+  int numrows, ci;
+  int buf_height = cinfo->max_v_samp_factor * 3;
+  JDIMENSION inrows;
+  jpeg_component_info * compptr;
+
+  while (*out_row_group_ctr < out_row_groups_avail) {
+    if (*in_row_ctr < in_rows_avail) {
+      /* Do color conversion to fill the conversion buffer. */
+      inrows = in_rows_avail - *in_row_ctr;
+      numrows = prep->next_buf_stop - prep->next_buf_row;
+      numrows = (int) MIN((JDIMENSION) numrows, inrows);
+      (*cinfo->cconvert->color_convert) (cinfo, input_buf + *in_row_ctr,
+					 prep->color_buf,
+					 (JDIMENSION) prep->next_buf_row,
+					 numrows);
+      /* Pad at top of image, if first time through */
+      if (prep->rows_to_go == cinfo->image_height) {
+	for (ci = 0; ci < cinfo->num_components; ci++) {
+	  int row;
+	  for (row = 1; row <= cinfo->max_v_samp_factor; row++) {
+	    jcopy_sample_rows(prep->color_buf[ci], 0,
+			      prep->color_buf[ci], -row,
+			      1, cinfo->image_width);
+	  }
+	}
+      }
+      *in_row_ctr += numrows;
+      prep->next_buf_row += numrows;
+      prep->rows_to_go -= numrows;
+    } else {
+      /* Return for more data, unless we are at the bottom of the image. */
+      if (prep->rows_to_go != 0)
+	break;
+    }
+    /* If at bottom of image, pad to fill the conversion buffer. */
+    if (prep->rows_to_go == 0 &&
+	prep->next_buf_row < prep->next_buf_stop) {
+      for (ci = 0; ci < cinfo->num_components; ci++) {
+	expand_bottom_edge(prep->color_buf[ci], cinfo->image_width,
+			   prep->next_buf_row, prep->next_buf_stop);
+      }
+      prep->next_buf_row = prep->next_buf_stop;
+    }
+    /* If we've gotten enough data, downsample a row group. */
+    if (prep->next_buf_row == prep->next_buf_stop) {
+      (*cinfo->downsample->downsample) (cinfo,
+					prep->color_buf,
+					(JDIMENSION) prep->this_row_group,
+					output_buf, *out_row_group_ctr);
+      (*out_row_group_ctr)++;
+      /* Advance pointers with wraparound as necessary. */
+      prep->this_row_group += cinfo->max_v_samp_factor;
+      if (prep->this_row_group >= buf_height)
+	prep->this_row_group = 0;
+      if (prep->next_buf_row >= buf_height)
+	prep->next_buf_row = 0;
+      prep->next_buf_stop = prep->next_buf_row + cinfo->max_v_samp_factor;
+    }
+    /* If at bottom of image, pad the output to a full iMCU height.
+     * Note we assume the caller is providing a one-iMCU-height output buffer!
+     */
+    if (prep->rows_to_go == 0 &&
+	*out_row_group_ctr < out_row_groups_avail) {
+      for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+	   ci++, compptr++) {
+	expand_bottom_edge(output_buf[ci],
+			   compptr->width_in_blocks * DCTSIZE,
+			   (int) (*out_row_group_ctr * compptr->v_samp_factor),
+			   (int) (out_row_groups_avail * compptr->v_samp_factor));
+      }
+      *out_row_group_ctr = out_row_groups_avail;
+      break;			/* can exit outer loop without test */
+    }
+  }
+}
+
+
+/*
+ * Create the wrapped-around downsampling input buffer needed for context mode.
+ */
+
+LOCAL void
+create_context_buffer (j_compress_ptr cinfo)
+{
+  my_prep_ptr prep = (my_prep_ptr) cinfo->prep;
+  int rgroup_height = cinfo->max_v_samp_factor;
+  int ci, i;
+  jpeg_component_info * compptr;
+  JSAMPARRAY true_buffer, fake_buffer;
+
+  /* Grab enough space for fake row pointers for all the components;
+   * we need five row groups' worth of pointers for each component.
+   */
+  fake_buffer = (JSAMPARRAY)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				(cinfo->num_components * 5 * rgroup_height) *
+				SIZEOF(JSAMPROW));
+
+  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+       ci++, compptr++) {
+    /* Allocate the actual buffer space (3 row groups) for this component.
+     * We make the buffer wide enough to allow the downsampler to edge-expand
+     * horizontally within the buffer, if it so chooses.
+     */
+    true_buffer = (*cinfo->mem->alloc_sarray)
+      ((j_common_ptr) cinfo, JPOOL_IMAGE,
+       (JDIMENSION) (((long) compptr->width_in_blocks * DCTSIZE *
+		      cinfo->max_h_samp_factor) / compptr->h_samp_factor),
+       (JDIMENSION) (3 * rgroup_height));
+    /* Copy true buffer row pointers into the middle of the fake row array */
+    MEMCOPY(fake_buffer + rgroup_height, true_buffer,
+	    3 * rgroup_height * SIZEOF(JSAMPROW));
+    /* Fill in the above and below wraparound pointers */
+    for (i = 0; i < rgroup_height; i++) {
+      fake_buffer[i] = true_buffer[2 * rgroup_height + i];
+      fake_buffer[4 * rgroup_height + i] = true_buffer[i];
+    }
+    prep->color_buf[ci] = fake_buffer + rgroup_height;
+    fake_buffer += 5 * rgroup_height; /* point to space for next component */
+  }
+}
+
+#endif /* CONTEXT_ROWS_SUPPORTED */
+
+
+/*
+ * Initialize preprocessing controller.
+ */
+
+GLOBAL void
+jinit_c_prep_controller (j_compress_ptr cinfo, boolean need_full_buffer)
+{
+  my_prep_ptr prep;
+  int ci;
+  jpeg_component_info * compptr;
+
+  if (need_full_buffer)		/* safety check */
+    ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+
+  prep = (my_prep_ptr)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				SIZEOF(my_prep_controller));
+  cinfo->prep = (struct jpeg_c_prep_controller *) prep;
+  prep->pub.start_pass = start_pass_prep;
+
+  /* Allocate the color conversion buffer.
+   * We make the buffer wide enough to allow the downsampler to edge-expand
+   * horizontally within the buffer, if it so chooses.
+   */
+  if (cinfo->downsample->need_context_rows) {
+    /* Set up to provide context rows */
+#ifdef CONTEXT_ROWS_SUPPORTED
+    prep->pub.pre_process_data = pre_process_context;
+    create_context_buffer(cinfo);
+#else
+    ERREXIT(cinfo, JERR_NOT_COMPILED);
+#endif
+  } else {
+    /* No context, just make it tall enough for one row group */
+    prep->pub.pre_process_data = pre_process_data;
+    for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+	 ci++, compptr++) {
+      prep->color_buf[ci] = (*cinfo->mem->alloc_sarray)
+	((j_common_ptr) cinfo, JPOOL_IMAGE,
+	 (JDIMENSION) (((long) compptr->width_in_blocks * DCTSIZE *
+			cinfo->max_h_samp_factor) / compptr->h_samp_factor),
+	 (JDIMENSION) cinfo->max_v_samp_factor);
+    }
+  }
+}
diff --git a/codemp/jpeg-6/jcsample.cpp b/codemp/jpeg-6/jcsample.cpp
new file mode 100644
index 0000000..a0d3dca
--- /dev/null
+++ b/codemp/jpeg-6/jcsample.cpp
@@ -0,0 +1,521 @@
+/*
+ * jcsample.c
+ *
+ * Copyright (C) 1991-1994, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains downsampling routines.
+ *
+ * Downsampling input data is counted in "row groups".  A row group
+ * is defined to be max_v_samp_factor pixel rows of each component,
+ * from which the downsampler produces v_samp_factor sample rows.
+ * A single row group is processed in each call to the downsampler module.
+ *
+ * The downsampler is responsible for edge-expansion of its output data
+ * to fill an integral number of DCT blocks horizontally.  The source buffer
+ * may be modified if it is helpful for this purpose (the source buffer is
+ * allocated wide enough to correspond to the desired output width).
+ * The caller (the prep controller) is responsible for vertical padding.
+ *
+ * The downsampler may request "context rows" by setting need_context_rows
+ * during startup.  In this case, the input arrays will contain at least
+ * one row group's worth of pixels above and below the passed-in data;
+ * the caller will create dummy rows at image top and bottom by replicating
+ * the first or last real pixel row.
+ *
+ * An excellent reference for image resampling is
+ *   Digital Image Warping, George Wolberg, 1990.
+ *   Pub. by IEEE Computer Society Press, Los Alamitos, CA. ISBN 0-8186-8944-7.
+ *
+ * The downsampling algorithm used here is a simple average of the source
+ * pixels covered by the output pixel.  The hi-falutin sampling literature
+ * refers to this as a "box filter".  In general the characteristics of a box
+ * filter are not very good, but for the specific cases we normally use (1:1
+ * and 2:1 ratios) the box is equivalent to a "triangle filter" which is not
+ * nearly so bad.  If you intend to use other sampling ratios, you'd be well
+ * advised to improve this code.
+ *
+ * A simple input-smoothing capability is provided.  This is mainly intended
+ * for cleaning up color-dithered GIF input files (if you find it inadequate,
+ * we suggest using an external filtering program such as pnmconvol).  When
+ * enabled, each input pixel P is replaced by a weighted sum of itself and its
+ * eight neighbors.  P's weight is 1-8*SF and each neighbor's weight is SF,
+ * where SF = (smoothing_factor / 1024).
+ * Currently, smoothing is only supported for 2h2v sampling factors.
+ */
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/* Pointer to routine to downsample a single component */
+typedef JMETHOD(void, downsample1_ptr,
+		(j_compress_ptr cinfo, jpeg_component_info * compptr,
+		 JSAMPARRAY input_data, JSAMPARRAY output_data));
+
+/* Private subobject */
+
+typedef struct {
+  struct jpeg_downsampler pub;	/* public fields */
+
+  /* Downsampling method pointers, one per component */
+  downsample1_ptr methods[MAX_COMPONENTS];
+} my_downsampler;
+
+typedef my_downsampler * my_downsample_ptr;
+
+
+/*
+ * Initialize for a downsampling pass.
+ */
+
+METHODDEF void
+start_pass_downsample (j_compress_ptr cinfo)
+{
+  /* no work for now */
+}
+
+
+/*
+ * Expand a component horizontally from width input_cols to width output_cols,
+ * by duplicating the rightmost samples.
+ */
+
+LOCAL void
+expand_right_edge (JSAMPARRAY image_data, int num_rows,
+		   JDIMENSION input_cols, JDIMENSION output_cols)
+{
+  register JSAMPROW ptr;
+  register JSAMPLE pixval;
+  register int count;
+  int row;
+  int numcols = (int) (output_cols - input_cols);
+
+  if (numcols > 0) {
+    for (row = 0; row < num_rows; row++) {
+      ptr = image_data[row] + input_cols;
+      pixval = ptr[-1];		/* don't need GETJSAMPLE() here */
+      for (count = numcols; count > 0; count--)
+	*ptr++ = pixval;
+    }
+  }
+}
+
+
+/*
+ * Do downsampling for a whole row group (all components).
+ *
+ * In this version we simply downsample each component independently.
+ */
+
+METHODDEF void
+sep_downsample (j_compress_ptr cinfo,
+		JSAMPIMAGE input_buf, JDIMENSION in_row_index,
+		JSAMPIMAGE output_buf, JDIMENSION out_row_group_index)
+{
+  my_downsample_ptr downsample = (my_downsample_ptr) cinfo->downsample;
+  int ci;
+  jpeg_component_info * compptr;
+  JSAMPARRAY in_ptr, out_ptr;
+
+  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+       ci++, compptr++) {
+    in_ptr = input_buf[ci] + in_row_index;
+    out_ptr = output_buf[ci] + (out_row_group_index * compptr->v_samp_factor);
+    (*downsample->methods[ci]) (cinfo, compptr, in_ptr, out_ptr);
+  }
+}
+
+
+/*
+ * Downsample pixel values of a single component.
+ * One row group is processed per call.
+ * This version handles arbitrary integral sampling ratios, without smoothing.
+ * Note that this version is not actually used for customary sampling ratios.
+ */
+
+METHODDEF void
+int_downsample (j_compress_ptr cinfo, jpeg_component_info * compptr,
+		JSAMPARRAY input_data, JSAMPARRAY output_data)
+{
+  int inrow, outrow, h_expand, v_expand, numpix, numpix2, h, v;
+  JDIMENSION outcol, outcol_h;	/* outcol_h == outcol*h_expand */
+  JDIMENSION output_cols = compptr->width_in_blocks * DCTSIZE;
+  JSAMPROW inptr, outptr;
+  INT32 outvalue;
+
+  h_expand = cinfo->max_h_samp_factor / compptr->h_samp_factor;
+  v_expand = cinfo->max_v_samp_factor / compptr->v_samp_factor;
+  numpix = h_expand * v_expand;
+  numpix2 = numpix/2;
+
+  /* Expand input data enough to let all the output samples be generated
+   * by the standard loop.  Special-casing padded output would be more
+   * efficient.
+   */
+  expand_right_edge(input_data, cinfo->max_v_samp_factor,
+		    cinfo->image_width, output_cols * h_expand);
+
+  inrow = 0;
+  for (outrow = 0; outrow < compptr->v_samp_factor; outrow++) {
+    outptr = output_data[outrow];
+    for (outcol = 0, outcol_h = 0; outcol < output_cols;
+	 outcol++, outcol_h += h_expand) {
+      outvalue = 0;
+      for (v = 0; v < v_expand; v++) {
+	inptr = input_data[inrow+v] + outcol_h;
+	for (h = 0; h < h_expand; h++) {
+	  outvalue += (INT32) GETJSAMPLE(*inptr++);
+	}
+      }
+      *outptr++ = (JSAMPLE) ((outvalue + numpix2) / numpix);
+    }
+    inrow += v_expand;
+  }
+}
+
+
+/*
+ * Downsample pixel values of a single component.
+ * This version handles the special case of a full-size component,
+ * without smoothing.
+ */
+
+METHODDEF void
+fullsize_downsample (j_compress_ptr cinfo, jpeg_component_info * compptr,
+		     JSAMPARRAY input_data, JSAMPARRAY output_data)
+{
+  /* Copy the data */
+  jcopy_sample_rows(input_data, 0, output_data, 0,
+		    cinfo->max_v_samp_factor, cinfo->image_width);
+  /* Edge-expand */
+  expand_right_edge(output_data, cinfo->max_v_samp_factor,
+		    cinfo->image_width, compptr->width_in_blocks * DCTSIZE);
+}
+
+
+/*
+ * Downsample pixel values of a single component.
+ * This version handles the common case of 2:1 horizontal and 1:1 vertical,
+ * without smoothing.
+ *
+ * A note about the "bias" calculations: when rounding fractional values to
+ * integer, we do not want to always round 0.5 up to the next integer.
+ * If we did that, we'd introduce a noticeable bias towards larger values.
+ * Instead, this code is arranged so that 0.5 will be rounded up or down at
+ * alternate pixel locations (a simple ordered dither pattern).
+ */
+
+METHODDEF void
+h2v1_downsample (j_compress_ptr cinfo, jpeg_component_info * compptr,
+		 JSAMPARRAY input_data, JSAMPARRAY output_data)
+{
+  int outrow;
+  JDIMENSION outcol;
+  JDIMENSION output_cols = compptr->width_in_blocks * DCTSIZE;
+  register JSAMPROW inptr, outptr;
+  register int bias;
+
+  /* Expand input data enough to let all the output samples be generated
+   * by the standard loop.  Special-casing padded output would be more
+   * efficient.
+   */
+  expand_right_edge(input_data, cinfo->max_v_samp_factor,
+		    cinfo->image_width, output_cols * 2);
+
+  for (outrow = 0; outrow < compptr->v_samp_factor; outrow++) {
+    outptr = output_data[outrow];
+    inptr = input_data[outrow];
+    bias = 0;			/* bias = 0,1,0,1,... for successive samples */
+    for (outcol = 0; outcol < output_cols; outcol++) {
+      *outptr++ = (JSAMPLE) ((GETJSAMPLE(*inptr) + GETJSAMPLE(inptr[1])
+			      + bias) >> 1);
+      bias ^= 1;		/* 0=>1, 1=>0 */
+      inptr += 2;
+    }
+  }
+}
+
+
+/*
+ * Downsample pixel values of a single component.
+ * This version handles the standard case of 2:1 horizontal and 2:1 vertical,
+ * without smoothing.
+ */
+
+METHODDEF void
+h2v2_downsample (j_compress_ptr cinfo, jpeg_component_info * compptr,
+		 JSAMPARRAY input_data, JSAMPARRAY output_data)
+{
+  int inrow, outrow;
+  JDIMENSION outcol;
+  JDIMENSION output_cols = compptr->width_in_blocks * DCTSIZE;
+  register JSAMPROW inptr0, inptr1, outptr;
+  register int bias;
+
+  /* Expand input data enough to let all the output samples be generated
+   * by the standard loop.  Special-casing padded output would be more
+   * efficient.
+   */
+  expand_right_edge(input_data, cinfo->max_v_samp_factor,
+		    cinfo->image_width, output_cols * 2);
+
+  inrow = 0;
+  for (outrow = 0; outrow < compptr->v_samp_factor; outrow++) {
+    outptr = output_data[outrow];
+    inptr0 = input_data[inrow];
+    inptr1 = input_data[inrow+1];
+    bias = 1;			/* bias = 1,2,1,2,... for successive samples */
+    for (outcol = 0; outcol < output_cols; outcol++) {
+      *outptr++ = (JSAMPLE) ((GETJSAMPLE(*inptr0) + GETJSAMPLE(inptr0[1]) +
+			      GETJSAMPLE(*inptr1) + GETJSAMPLE(inptr1[1])
+			      + bias) >> 2);
+      bias ^= 3;		/* 1=>2, 2=>1 */
+      inptr0 += 2; inptr1 += 2;
+    }
+    inrow += 2;
+  }
+}
+
+
+#ifdef INPUT_SMOOTHING_SUPPORTED
+
+/*
+ * Downsample pixel values of a single component.
+ * This version handles the standard case of 2:1 horizontal and 2:1 vertical,
+ * with smoothing.  One row of context is required.
+ */
+
+METHODDEF void
+h2v2_smooth_downsample (j_compress_ptr cinfo, jpeg_component_info * compptr,
+			JSAMPARRAY input_data, JSAMPARRAY output_data)
+{
+  int inrow, outrow;
+  JDIMENSION colctr;
+  JDIMENSION output_cols = compptr->width_in_blocks * DCTSIZE;
+  register JSAMPROW inptr0, inptr1, above_ptr, below_ptr, outptr;
+  INT32 membersum, neighsum, memberscale, neighscale;
+
+  /* Expand input data enough to let all the output samples be generated
+   * by the standard loop.  Special-casing padded output would be more
+   * efficient.
+   */
+  expand_right_edge(input_data - 1, cinfo->max_v_samp_factor + 2,
+		    cinfo->image_width, output_cols * 2);
+
+  /* We don't bother to form the individual "smoothed" input pixel values;
+   * we can directly compute the output which is the average of the four
+   * smoothed values.  Each of the four member pixels contributes a fraction
+   * (1-8*SF) to its own smoothed image and a fraction SF to each of the three
+   * other smoothed pixels, therefore a total fraction (1-5*SF)/4 to the final
+   * output.  The four corner-adjacent neighbor pixels contribute a fraction
+   * SF to just one smoothed pixel, or SF/4 to the final output; while the
+   * eight edge-adjacent neighbors contribute SF to each of two smoothed
+   * pixels, or SF/2 overall.  In order to use integer arithmetic, these
+   * factors are scaled by 2^16 = 65536.
+   * Also recall that SF = smoothing_factor / 1024.
+   */
+
+  memberscale = 16384 - cinfo->smoothing_factor * 80; /* scaled (1-5*SF)/4 */
+  neighscale = cinfo->smoothing_factor * 16; /* scaled SF/4 */
+
+  inrow = 0;
+  for (outrow = 0; outrow < compptr->v_samp_factor; outrow++) {
+    outptr = output_data[outrow];
+    inptr0 = input_data[inrow];
+    inptr1 = input_data[inrow+1];
+    above_ptr = input_data[inrow-1];
+    below_ptr = input_data[inrow+2];
+
+    /* Special case for first column: pretend column -1 is same as column 0 */
+    membersum = GETJSAMPLE(*inptr0) + GETJSAMPLE(inptr0[1]) +
+		GETJSAMPLE(*inptr1) + GETJSAMPLE(inptr1[1]);
+    neighsum = GETJSAMPLE(*above_ptr) + GETJSAMPLE(above_ptr[1]) +
+	       GETJSAMPLE(*below_ptr) + GETJSAMPLE(below_ptr[1]) +
+	       GETJSAMPLE(*inptr0) + GETJSAMPLE(inptr0[2]) +
+	       GETJSAMPLE(*inptr1) + GETJSAMPLE(inptr1[2]);
+    neighsum += neighsum;
+    neighsum += GETJSAMPLE(*above_ptr) + GETJSAMPLE(above_ptr[2]) +
+		GETJSAMPLE(*below_ptr) + GETJSAMPLE(below_ptr[2]);
+    membersum = membersum * memberscale + neighsum * neighscale;
+    *outptr++ = (JSAMPLE) ((membersum + 32768) >> 16);
+    inptr0 += 2; inptr1 += 2; above_ptr += 2; below_ptr += 2;
+
+    for (colctr = output_cols - 2; colctr > 0; colctr--) {
+      /* sum of pixels directly mapped to this output element */
+      membersum = GETJSAMPLE(*inptr0) + GETJSAMPLE(inptr0[1]) +
+		  GETJSAMPLE(*inptr1) + GETJSAMPLE(inptr1[1]);
+      /* sum of edge-neighbor pixels */
+      neighsum = GETJSAMPLE(*above_ptr) + GETJSAMPLE(above_ptr[1]) +
+		 GETJSAMPLE(*below_ptr) + GETJSAMPLE(below_ptr[1]) +
+		 GETJSAMPLE(inptr0[-1]) + GETJSAMPLE(inptr0[2]) +
+		 GETJSAMPLE(inptr1[-1]) + GETJSAMPLE(inptr1[2]);
+      /* The edge-neighbors count twice as much as corner-neighbors */
+      neighsum += neighsum;
+      /* Add in the corner-neighbors */
+      neighsum += GETJSAMPLE(above_ptr[-1]) + GETJSAMPLE(above_ptr[2]) +
+		  GETJSAMPLE(below_ptr[-1]) + GETJSAMPLE(below_ptr[2]);
+      /* form final output scaled up by 2^16 */
+      membersum = membersum * memberscale + neighsum * neighscale;
+      /* round, descale and output it */
+      *outptr++ = (JSAMPLE) ((membersum + 32768) >> 16);
+      inptr0 += 2; inptr1 += 2; above_ptr += 2; below_ptr += 2;
+    }
+
+    /* Special case for last column */
+    membersum = GETJSAMPLE(*inptr0) + GETJSAMPLE(inptr0[1]) +
+		GETJSAMPLE(*inptr1) + GETJSAMPLE(inptr1[1]);
+    neighsum = GETJSAMPLE(*above_ptr) + GETJSAMPLE(above_ptr[1]) +
+	       GETJSAMPLE(*below_ptr) + GETJSAMPLE(below_ptr[1]) +
+	       GETJSAMPLE(inptr0[-1]) + GETJSAMPLE(inptr0[1]) +
+	       GETJSAMPLE(inptr1[-1]) + GETJSAMPLE(inptr1[1]);
+    neighsum += neighsum;
+    neighsum += GETJSAMPLE(above_ptr[-1]) + GETJSAMPLE(above_ptr[1]) +
+		GETJSAMPLE(below_ptr[-1]) + GETJSAMPLE(below_ptr[1]);
+    membersum = membersum * memberscale + neighsum * neighscale;
+    *outptr = (JSAMPLE) ((membersum + 32768) >> 16);
+
+    inrow += 2;
+  }
+}
+
+
+/*
+ * Downsample pixel values of a single component.
+ * This version handles the special case of a full-size component,
+ * with smoothing.  One row of context is required.
+ */
+
+METHODDEF void
+fullsize_smooth_downsample (j_compress_ptr cinfo, jpeg_component_info *compptr,
+			    JSAMPARRAY input_data, JSAMPARRAY output_data)
+{
+  int outrow;
+  JDIMENSION colctr;
+  JDIMENSION output_cols = compptr->width_in_blocks * DCTSIZE;
+  register JSAMPROW inptr, above_ptr, below_ptr, outptr;
+  INT32 membersum, neighsum, memberscale, neighscale;
+  int colsum, lastcolsum, nextcolsum;
+
+  /* Expand input data enough to let all the output samples be generated
+   * by the standard loop.  Special-casing padded output would be more
+   * efficient.
+   */
+  expand_right_edge(input_data - 1, cinfo->max_v_samp_factor + 2,
+		    cinfo->image_width, output_cols);
+
+  /* Each of the eight neighbor pixels contributes a fraction SF to the
+   * smoothed pixel, while the main pixel contributes (1-8*SF).  In order
+   * to use integer arithmetic, these factors are multiplied by 2^16 = 65536.
+   * Also recall that SF = smoothing_factor / 1024.
+   */
+
+  memberscale = 65536L - cinfo->smoothing_factor * 512L; /* scaled 1-8*SF */
+  neighscale = cinfo->smoothing_factor * 64; /* scaled SF */
+
+  for (outrow = 0; outrow < compptr->v_samp_factor; outrow++) {
+    outptr = output_data[outrow];
+    inptr = input_data[outrow];
+    above_ptr = input_data[outrow-1];
+    below_ptr = input_data[outrow+1];
+
+    /* Special case for first column */
+    colsum = GETJSAMPLE(*above_ptr++) + GETJSAMPLE(*below_ptr++) +
+	     GETJSAMPLE(*inptr);
+    membersum = GETJSAMPLE(*inptr++);
+    nextcolsum = GETJSAMPLE(*above_ptr) + GETJSAMPLE(*below_ptr) +
+		 GETJSAMPLE(*inptr);
+    neighsum = colsum + (colsum - membersum) + nextcolsum;
+    membersum = membersum * memberscale + neighsum * neighscale;
+    *outptr++ = (JSAMPLE) ((membersum + 32768) >> 16);
+    lastcolsum = colsum; colsum = nextcolsum;
+
+    for (colctr = output_cols - 2; colctr > 0; colctr--) {
+      membersum = GETJSAMPLE(*inptr++);
+      above_ptr++; below_ptr++;
+      nextcolsum = GETJSAMPLE(*above_ptr) + GETJSAMPLE(*below_ptr) +
+		   GETJSAMPLE(*inptr);
+      neighsum = lastcolsum + (colsum - membersum) + nextcolsum;
+      membersum = membersum * memberscale + neighsum * neighscale;
+      *outptr++ = (JSAMPLE) ((membersum + 32768) >> 16);
+      lastcolsum = colsum; colsum = nextcolsum;
+    }
+
+    /* Special case for last column */
+    membersum = GETJSAMPLE(*inptr);
+    neighsum = lastcolsum + (colsum - membersum) + colsum;
+    membersum = membersum * memberscale + neighsum * neighscale;
+    *outptr = (JSAMPLE) ((membersum + 32768) >> 16);
+
+  }
+}
+
+#endif /* INPUT_SMOOTHING_SUPPORTED */
+
+
+/*
+ * Module initialization routine for downsampling.
+ * Note that we must select a routine for each component.
+ */
+
+GLOBAL void
+jinit_downsampler (j_compress_ptr cinfo)
+{
+  my_downsample_ptr downsample;
+  int ci;
+  jpeg_component_info * compptr;
+  boolean smoothok = TRUE;
+
+  downsample = (my_downsample_ptr)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				SIZEOF(my_downsampler));
+  cinfo->downsample = (struct jpeg_downsampler *) downsample;
+  downsample->pub.start_pass = start_pass_downsample;
+  downsample->pub.downsample = sep_downsample;
+  downsample->pub.need_context_rows = FALSE;
+
+  if (cinfo->CCIR601_sampling)
+    ERREXIT(cinfo, JERR_CCIR601_NOTIMPL);
+
+  /* Verify we can handle the sampling factors, and set up method pointers */
+  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+       ci++, compptr++) {
+    if (compptr->h_samp_factor == cinfo->max_h_samp_factor &&
+	compptr->v_samp_factor == cinfo->max_v_samp_factor) {
+#ifdef INPUT_SMOOTHING_SUPPORTED
+      if (cinfo->smoothing_factor) {
+	downsample->methods[ci] = fullsize_smooth_downsample;
+	downsample->pub.need_context_rows = TRUE;
+      } else
+#endif
+	downsample->methods[ci] = fullsize_downsample;
+    } else if (compptr->h_samp_factor * 2 == cinfo->max_h_samp_factor &&
+	       compptr->v_samp_factor == cinfo->max_v_samp_factor) {
+      smoothok = FALSE;
+      downsample->methods[ci] = h2v1_downsample;
+    } else if (compptr->h_samp_factor * 2 == cinfo->max_h_samp_factor &&
+	       compptr->v_samp_factor * 2 == cinfo->max_v_samp_factor) {
+#ifdef INPUT_SMOOTHING_SUPPORTED
+      if (cinfo->smoothing_factor) {
+	downsample->methods[ci] = h2v2_smooth_downsample;
+	downsample->pub.need_context_rows = TRUE;
+      } else
+#endif
+	downsample->methods[ci] = h2v2_downsample;
+    } else if ((cinfo->max_h_samp_factor % compptr->h_samp_factor) == 0 &&
+	       (cinfo->max_v_samp_factor % compptr->v_samp_factor) == 0) {
+      smoothok = FALSE;
+      downsample->methods[ci] = int_downsample;
+    } else
+      ERREXIT(cinfo, JERR_FRACT_SAMPLE_NOTIMPL);
+  }
+
+#ifdef INPUT_SMOOTHING_SUPPORTED
+  if (cinfo->smoothing_factor && !smoothok)
+    TRACEMS(cinfo, 0, JTRC_SMOOTH_NOTIMPL);
+#endif
+}
diff --git a/codemp/jpeg-6/jctrans.cpp b/codemp/jpeg-6/jctrans.cpp
new file mode 100644
index 0000000..052836b
--- /dev/null
+++ b/codemp/jpeg-6/jctrans.cpp
@@ -0,0 +1,373 @@
+/*
+ * jctrans.c
+ *
+ * Copyright (C) 1995, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains library routines for transcoding compression,
+ * that is, writing raw DCT coefficient arrays to an output JPEG file.
+ * The routines in jcapimin.c will also be needed by a transcoder.
+ */
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/* Forward declarations */
+LOCAL void transencode_master_selection
+	JPP((j_compress_ptr cinfo, jvirt_barray_ptr * coef_arrays));
+LOCAL void transencode_coef_controller
+	JPP((j_compress_ptr cinfo, jvirt_barray_ptr * coef_arrays));
+
+
+/*
+ * Compression initialization for writing raw-coefficient data.
+ * Before calling this, all parameters and a data destination must be set up.
+ * Call jpeg_finish_compress() to actually write the data.
+ *
+ * The number of passed virtual arrays must match cinfo->num_components.
+ * Note that the virtual arrays need not be filled or even realized at
+ * the time write_coefficients is called; indeed, if the virtual arrays
+ * were requested from this compression object's memory manager, they
+ * typically will be realized during this routine and filled afterwards.
+ */
+
+GLOBAL void
+jpeg_write_coefficients (j_compress_ptr cinfo, jvirt_barray_ptr * coef_arrays)
+{
+  if (cinfo->global_state != CSTATE_START)
+    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+  /* Mark all tables to be written */
+  jpeg_suppress_tables(cinfo, FALSE);
+  /* (Re)initialize error mgr and destination modules */
+  (*cinfo->err->reset_error_mgr) ((j_common_ptr) cinfo);
+  (*cinfo->dest->init_destination) (cinfo);
+  /* Perform master selection of active modules */
+  transencode_master_selection(cinfo, coef_arrays);
+  /* Wait for jpeg_finish_compress() call */
+  cinfo->next_scanline = 0;	/* so jpeg_write_marker works */
+  cinfo->global_state = CSTATE_WRCOEFS;
+}
+
+
+/*
+ * Initialize the compression object with default parameters,
+ * then copy from the source object all parameters needed for lossless
+ * transcoding.  Parameters that can be varied without loss (such as
+ * scan script and Huffman optimization) are left in their default states.
+ */
+
+GLOBAL void
+jpeg_copy_critical_parameters (j_decompress_ptr srcinfo,
+			       j_compress_ptr dstinfo)
+{
+  JQUANT_TBL ** qtblptr;
+  jpeg_component_info *incomp, *outcomp;
+  JQUANT_TBL *c_quant, *slot_quant;
+  int tblno, ci, coefi;
+
+  /* Safety check to ensure start_compress not called yet. */
+  if (dstinfo->global_state != CSTATE_START)
+    ERREXIT1(dstinfo, JERR_BAD_STATE, dstinfo->global_state);
+  /* Copy fundamental image dimensions */
+  dstinfo->image_width = srcinfo->image_width;
+  dstinfo->image_height = srcinfo->image_height;
+  dstinfo->input_components = srcinfo->num_components;
+  dstinfo->in_color_space = srcinfo->jpeg_color_space;
+  /* Initialize all parameters to default values */
+  jpeg_set_defaults(dstinfo);
+  /* jpeg_set_defaults may choose wrong colorspace, eg YCbCr if input is RGB.
+   * Fix it to get the right header markers for the image colorspace.
+   */
+  jpeg_set_colorspace(dstinfo, srcinfo->jpeg_color_space);
+  dstinfo->data_precision = srcinfo->data_precision;
+  dstinfo->CCIR601_sampling = srcinfo->CCIR601_sampling;
+  /* Copy the source's quantization tables. */
+  for (tblno = 0; tblno < NUM_QUANT_TBLS; tblno++) {
+    if (srcinfo->quant_tbl_ptrs[tblno] != NULL) {
+      qtblptr = & dstinfo->quant_tbl_ptrs[tblno];
+      if (*qtblptr == NULL)
+	*qtblptr = jpeg_alloc_quant_table((j_common_ptr) dstinfo);
+      MEMCOPY((*qtblptr)->quantval,
+	      srcinfo->quant_tbl_ptrs[tblno]->quantval,
+	      SIZEOF((*qtblptr)->quantval));
+      (*qtblptr)->sent_table = FALSE;
+    }
+  }
+  /* Copy the source's per-component info.
+   * Note we assume jpeg_set_defaults has allocated the dest comp_info array.
+   */
+  dstinfo->num_components = srcinfo->num_components;
+  if (dstinfo->num_components < 1 || dstinfo->num_components > MAX_COMPONENTS)
+    ERREXIT2(dstinfo, JERR_COMPONENT_COUNT, dstinfo->num_components,
+	     MAX_COMPONENTS);
+  for (ci = 0, incomp = srcinfo->comp_info, outcomp = dstinfo->comp_info;
+       ci < dstinfo->num_components; ci++, incomp++, outcomp++) {
+    outcomp->component_id = incomp->component_id;
+    outcomp->h_samp_factor = incomp->h_samp_factor;
+    outcomp->v_samp_factor = incomp->v_samp_factor;
+    outcomp->quant_tbl_no = incomp->quant_tbl_no;
+    /* Make sure saved quantization table for component matches the qtable
+     * slot.  If not, the input file re-used this qtable slot.
+     * IJG encoder currently cannot duplicate this.
+     */
+    tblno = outcomp->quant_tbl_no;
+    if (tblno < 0 || tblno >= NUM_QUANT_TBLS ||
+	srcinfo->quant_tbl_ptrs[tblno] == NULL)
+      ERREXIT1(dstinfo, JERR_NO_QUANT_TABLE, tblno);
+    slot_quant = srcinfo->quant_tbl_ptrs[tblno];
+    c_quant = incomp->quant_table;
+    if (c_quant != NULL) {
+      for (coefi = 0; coefi < DCTSIZE2; coefi++) {
+	if (c_quant->quantval[coefi] != slot_quant->quantval[coefi])
+	  ERREXIT1(dstinfo, JERR_MISMATCHED_QUANT_TABLE, tblno);
+      }
+    }
+    /* Note: we do not copy the source's Huffman table assignments;
+     * instead we rely on jpeg_set_colorspace to have made a suitable choice.
+     */
+  }
+}
+
+
+/*
+ * Master selection of compression modules for transcoding.
+ * This substitutes for jcinit.c's initialization of the full compressor.
+ */
+
+LOCAL void
+transencode_master_selection (j_compress_ptr cinfo,
+			      jvirt_barray_ptr * coef_arrays)
+{
+  /* Although we don't actually use input_components for transcoding,
+   * jcmaster.c's initial_setup will complain if input_components is 0.
+   */
+  cinfo->input_components = 1;
+  /* Initialize master control (includes parameter checking/processing) */
+  jinit_c_master_control(cinfo, TRUE /* transcode only */);
+
+  /* Entropy encoding: either Huffman or arithmetic coding. */
+  if (cinfo->arith_code) {
+    ERREXIT(cinfo, JERR_ARITH_NOTIMPL);
+  } else {
+    if (cinfo->progressive_mode) {
+#ifdef C_PROGRESSIVE_SUPPORTED
+      jinit_phuff_encoder(cinfo);
+#else
+      ERREXIT(cinfo, JERR_NOT_COMPILED);
+#endif
+    } else
+      jinit_huff_encoder(cinfo);
+  }
+
+  /* We need a special coefficient buffer controller. */
+  transencode_coef_controller(cinfo, coef_arrays);
+
+  jinit_marker_writer(cinfo);
+
+  /* We can now tell the memory manager to allocate virtual arrays. */
+  (*cinfo->mem->realize_virt_arrays) ((j_common_ptr) cinfo);
+
+  /* Write the datastream header (SOI) immediately.
+   * Frame and scan headers are postponed till later.
+   * This lets application insert special markers after the SOI.
+   */
+  (*cinfo->marker->write_file_header) (cinfo);
+}
+
+
+/*
+ * The rest of this file is a special implementation of the coefficient
+ * buffer controller.  This is similar to jccoefct.c, but it handles only
+ * output from presupplied virtual arrays.  Furthermore, we generate any
+ * dummy padding blocks on-the-fly rather than expecting them to be present
+ * in the arrays.
+ */
+
+/* Private buffer controller object */
+
+typedef struct {
+  struct jpeg_c_coef_controller pub; /* public fields */
+
+  JDIMENSION iMCU_row_num;	/* iMCU row # within image */
+  JDIMENSION mcu_ctr;		/* counts MCUs processed in current row */
+  int MCU_vert_offset;		/* counts MCU rows within iMCU row */
+  int MCU_rows_per_iMCU_row;	/* number of such rows needed */
+
+  /* Virtual block array for each component. */
+  jvirt_barray_ptr * whole_image;
+
+  /* Workspace for constructing dummy blocks at right/bottom edges. */
+  JBLOCKROW dummy_buffer[C_MAX_BLOCKS_IN_MCU];
+} my_coef_controller;
+
+typedef my_coef_controller * my_coef_ptr;
+
+
+LOCAL void
+start_iMCU_row (j_compress_ptr cinfo)
+/* Reset within-iMCU-row counters for a new row */
+{
+  my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
+
+  /* In an interleaved scan, an MCU row is the same as an iMCU row.
+   * In a noninterleaved scan, an iMCU row has v_samp_factor MCU rows.
+   * But at the bottom of the image, process only what's left.
+   */
+  if (cinfo->comps_in_scan > 1) {
+    coef->MCU_rows_per_iMCU_row = 1;
+  } else {
+    if (coef->iMCU_row_num < (cinfo->total_iMCU_rows-1))
+      coef->MCU_rows_per_iMCU_row = cinfo->cur_comp_info[0]->v_samp_factor;
+    else
+      coef->MCU_rows_per_iMCU_row = cinfo->cur_comp_info[0]->last_row_height;
+  }
+
+  coef->mcu_ctr = 0;
+  coef->MCU_vert_offset = 0;
+}
+
+
+/*
+ * Initialize for a processing pass.
+ */
+
+METHODDEF void
+start_pass_coef (j_compress_ptr cinfo, J_BUF_MODE pass_mode)
+{
+  my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
+
+  if (pass_mode != JBUF_CRANK_DEST)
+    ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+
+  coef->iMCU_row_num = 0;
+  start_iMCU_row(cinfo);
+}
+
+
+/*
+ * Process some data.
+ * We process the equivalent of one fully interleaved MCU row ("iMCU" row)
+ * per call, ie, v_samp_factor block rows for each component in the scan.
+ * The data is obtained from the virtual arrays and fed to the entropy coder.
+ * Returns TRUE if the iMCU row is completed, FALSE if suspended.
+ *
+ * NB: input_buf is ignored; it is likely to be a NULL pointer.
+ */
+
+METHODDEF boolean
+compress_output (j_compress_ptr cinfo, JSAMPIMAGE input_buf)
+{
+  my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
+  JDIMENSION MCU_col_num;	/* index of current MCU within row */
+  JDIMENSION last_MCU_col = cinfo->MCUs_per_row - 1;
+  JDIMENSION last_iMCU_row = cinfo->total_iMCU_rows - 1;
+  int blkn, ci, xindex, yindex, yoffset, blockcnt;
+  JDIMENSION start_col;
+  JBLOCKARRAY buffer[MAX_COMPS_IN_SCAN];
+  JBLOCKROW MCU_buffer[C_MAX_BLOCKS_IN_MCU];
+  JBLOCKROW buffer_ptr;
+  jpeg_component_info *compptr;
+
+  /* Align the virtual buffers for the components used in this scan. */
+  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+    compptr = cinfo->cur_comp_info[ci];
+    buffer[ci] = (*cinfo->mem->access_virt_barray)
+      ((j_common_ptr) cinfo, coef->whole_image[compptr->component_index],
+       coef->iMCU_row_num * compptr->v_samp_factor,
+       (JDIMENSION) compptr->v_samp_factor, FALSE);
+  }
+
+  /* Loop to process one whole iMCU row */
+  for (yoffset = coef->MCU_vert_offset; yoffset < coef->MCU_rows_per_iMCU_row;
+       yoffset++) {
+    for (MCU_col_num = coef->mcu_ctr; MCU_col_num < cinfo->MCUs_per_row;
+	 MCU_col_num++) {
+      /* Construct list of pointers to DCT blocks belonging to this MCU */
+      blkn = 0;			/* index of current DCT block within MCU */
+      for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+	compptr = cinfo->cur_comp_info[ci];
+	start_col = MCU_col_num * compptr->MCU_width;
+	blockcnt = (MCU_col_num < last_MCU_col) ? compptr->MCU_width
+						: compptr->last_col_width;
+	for (yindex = 0; yindex < compptr->MCU_height; yindex++) {
+	  if (coef->iMCU_row_num < last_iMCU_row ||
+	      yindex+yoffset < compptr->last_row_height) {
+	    /* Fill in pointers to real blocks in this row */
+	    buffer_ptr = buffer[ci][yindex+yoffset] + start_col;
+	    for (xindex = 0; xindex < blockcnt; xindex++)
+	      MCU_buffer[blkn++] = buffer_ptr++;
+	  } else {
+	    /* At bottom of image, need a whole row of dummy blocks */
+	    xindex = 0;
+	  }
+	  /* Fill in any dummy blocks needed in this row.
+	   * Dummy blocks are filled in the same way as in jccoefct.c:
+	   * all zeroes in the AC entries, DC entries equal to previous
+	   * block's DC value.  The init routine has already zeroed the
+	   * AC entries, so we need only set the DC entries correctly.
+	   */
+	  for (; xindex < compptr->MCU_width; xindex++) {
+	    MCU_buffer[blkn] = coef->dummy_buffer[blkn];
+	    MCU_buffer[blkn][0][0] = MCU_buffer[blkn-1][0][0];
+	    blkn++;
+	  }
+	}
+      }
+      /* Try to write the MCU. */
+      if (! (*cinfo->entropy->encode_mcu) (cinfo, MCU_buffer)) {
+	/* Suspension forced; update state counters and exit */
+	coef->MCU_vert_offset = yoffset;
+	coef->mcu_ctr = MCU_col_num;
+	return FALSE;
+      }
+    }
+    /* Completed an MCU row, but perhaps not an iMCU row */
+    coef->mcu_ctr = 0;
+  }
+  /* Completed the iMCU row, advance counters for next one */
+  coef->iMCU_row_num++;
+  start_iMCU_row(cinfo);
+  return TRUE;
+}
+
+
+/*
+ * Initialize coefficient buffer controller.
+ *
+ * Each passed coefficient array must be the right size for that
+ * coefficient: width_in_blocks wide and height_in_blocks high,
+ * with unitheight at least v_samp_factor.
+ */
+
+LOCAL void
+transencode_coef_controller (j_compress_ptr cinfo,
+			     jvirt_barray_ptr * coef_arrays)
+{
+  my_coef_ptr coef;
+  JBLOCKROW buffer;
+  int i;
+
+  coef = (my_coef_ptr)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				SIZEOF(my_coef_controller));
+  cinfo->coef = (struct jpeg_c_coef_controller *) coef;
+  coef->pub.start_pass = start_pass_coef;
+  coef->pub.compress_data = compress_output;
+
+  /* Save pointer to virtual arrays */
+  coef->whole_image = coef_arrays;
+
+  /* Allocate and pre-zero space for dummy DCT blocks. */
+  buffer = (JBLOCKROW)
+    (*cinfo->mem->alloc_large) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				C_MAX_BLOCKS_IN_MCU * SIZEOF(JBLOCK));
+  jzero_far((void FAR *) buffer, C_MAX_BLOCKS_IN_MCU * SIZEOF(JBLOCK));
+  for (i = 0; i < C_MAX_BLOCKS_IN_MCU; i++) {
+    coef->dummy_buffer[i] = buffer + i;
+  }
+}
diff --git a/codemp/jpeg-6/jdapimin.cpp b/codemp/jpeg-6/jdapimin.cpp
new file mode 100644
index 0000000..42eb2ce
--- /dev/null
+++ b/codemp/jpeg-6/jdapimin.cpp
@@ -0,0 +1,400 @@
+/*
+ * jdapimin.c
+ *
+ * Copyright (C) 1994-1995, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains application interface code for the decompression half
+ * of the JPEG library.  These are the "minimum" API routines that may be
+ * needed in either the normal full-decompression case or the
+ * transcoding-only case.
+ *
+ * Most of the routines intended to be called directly by an application
+ * are in this file or in jdapistd.c.  But also see jcomapi.c for routines
+ * shared by compression and decompression, and jdtrans.c for the transcoding
+ * case.
+ */
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/*
+ * Initialization of a JPEG decompression object.
+ * The error manager must already be set up (in case memory manager fails).
+ */
+
+GLOBAL void
+jpeg_create_decompress (j_decompress_ptr cinfo)
+{
+  int i;
+
+  /* For debugging purposes, zero the whole master structure.
+   * But error manager pointer is already there, so save and restore it.
+   */
+  {
+    struct jpeg_error_mgr * err = cinfo->err;
+    MEMZERO(cinfo, SIZEOF(struct jpeg_decompress_struct));
+    cinfo->err = err;
+  }
+  cinfo->is_decompressor = TRUE;
+
+  /* Initialize a memory manager instance for this object */
+  jinit_memory_mgr((j_common_ptr) cinfo);
+
+  /* Zero out pointers to permanent structures. */
+  cinfo->progress = NULL;
+  cinfo->src = NULL;
+
+  for (i = 0; i < NUM_QUANT_TBLS; i++)
+    cinfo->quant_tbl_ptrs[i] = NULL;
+
+  for (i = 0; i < NUM_HUFF_TBLS; i++) {
+    cinfo->dc_huff_tbl_ptrs[i] = NULL;
+    cinfo->ac_huff_tbl_ptrs[i] = NULL;
+  }
+
+  /* Initialize marker processor so application can override methods
+   * for COM, APPn markers before calling jpeg_read_header.
+   */
+  jinit_marker_reader(cinfo);
+
+  /* And initialize the overall input controller. */
+  jinit_input_controller(cinfo);
+
+  /* OK, I'm ready */
+  cinfo->global_state = DSTATE_START;
+}
+
+
+/*
+ * Destruction of a JPEG decompression object
+ */
+
+GLOBAL void
+jpeg_destroy_decompress (j_decompress_ptr cinfo)
+{
+  jpeg_destroy((j_common_ptr) cinfo); /* use common routine */
+}
+
+
+/*
+ * Abort processing of a JPEG decompression operation,
+ * but don't destroy the object itself.
+ */
+
+GLOBAL void
+jpeg_abort_decompress (j_decompress_ptr cinfo)
+{
+  jpeg_abort((j_common_ptr) cinfo); /* use common routine */
+}
+
+
+/*
+ * Install a special processing method for COM or APPn markers.
+ */
+
+GLOBAL void
+jpeg_set_marker_processor (j_decompress_ptr cinfo, int marker_code,
+			   jpeg_marker_parser_method routine)
+{
+  if (marker_code == JPEG_COM)
+    cinfo->marker->process_COM = routine;
+  else if (marker_code >= JPEG_APP0 && marker_code <= JPEG_APP0+15)
+    cinfo->marker->process_APPn[marker_code-JPEG_APP0] = routine;
+  else
+    ERREXIT1(cinfo, JERR_UNKNOWN_MARKER, marker_code);
+}
+
+
+/*
+ * Set default decompression parameters.
+ */
+
+LOCAL void
+default_decompress_parms (j_decompress_ptr cinfo)
+{
+  /* Guess the input colorspace, and set output colorspace accordingly. */
+  /* (Wish JPEG committee had provided a real way to specify this...) */
+  /* Note application may override our guesses. */
+  switch (cinfo->num_components) {
+  case 1:
+    cinfo->jpeg_color_space = JCS_GRAYSCALE;
+    cinfo->out_color_space = JCS_GRAYSCALE;
+    break;
+    
+  case 3:
+    if (cinfo->saw_JFIF_marker) {
+      cinfo->jpeg_color_space = JCS_YCbCr; /* JFIF implies YCbCr */
+    } else if (cinfo->saw_Adobe_marker) {
+      switch (cinfo->Adobe_transform) {
+      case 0:
+	cinfo->jpeg_color_space = JCS_RGB;
+	break;
+      case 1:
+	cinfo->jpeg_color_space = JCS_YCbCr;
+	break;
+      default:
+	WARNMS1(cinfo, JWRN_ADOBE_XFORM, cinfo->Adobe_transform);
+	cinfo->jpeg_color_space = JCS_YCbCr; /* assume it's YCbCr */
+	break;
+      }
+    } else {
+      /* Saw no special markers, try to guess from the component IDs */
+      int cid0 = cinfo->comp_info[0].component_id;
+      int cid1 = cinfo->comp_info[1].component_id;
+      int cid2 = cinfo->comp_info[2].component_id;
+
+      if (cid0 == 1 && cid1 == 2 && cid2 == 3)
+	cinfo->jpeg_color_space = JCS_YCbCr; /* assume JFIF w/out marker */
+      else if (cid0 == 82 && cid1 == 71 && cid2 == 66)
+	cinfo->jpeg_color_space = JCS_RGB; /* ASCII 'R', 'G', 'B' */
+      else {
+	TRACEMS3(cinfo, 1, JTRC_UNKNOWN_IDS, cid0, cid1, cid2);
+	cinfo->jpeg_color_space = JCS_YCbCr; /* assume it's YCbCr */
+      }
+    }
+    /* Always guess RGB is proper output colorspace. */
+    cinfo->out_color_space = JCS_RGB;
+    break;
+    
+  case 4:
+    if (cinfo->saw_Adobe_marker) {
+      switch (cinfo->Adobe_transform) {
+      case 0:
+	cinfo->jpeg_color_space = JCS_CMYK;
+	break;
+      case 2:
+	cinfo->jpeg_color_space = JCS_YCCK;
+	break;
+      default:
+	WARNMS1(cinfo, JWRN_ADOBE_XFORM, cinfo->Adobe_transform);
+	cinfo->jpeg_color_space = JCS_YCCK; /* assume it's YCCK */
+	break;
+      }
+    } else {
+      /* No special markers, assume straight CMYK. */
+      cinfo->jpeg_color_space = JCS_CMYK;
+    }
+    cinfo->out_color_space = JCS_CMYK;
+    break;
+    
+  default:
+    cinfo->jpeg_color_space = JCS_UNKNOWN;
+    cinfo->out_color_space = JCS_UNKNOWN;
+    break;
+  }
+
+  /* Set defaults for other decompression parameters. */
+  cinfo->scale_num = 1;		/* 1:1 scaling */
+  cinfo->scale_denom = 1;
+  cinfo->output_gamma = 1.0;
+  cinfo->buffered_image = FALSE;
+  cinfo->raw_data_out = FALSE;
+  cinfo->dct_method = JDCT_DEFAULT;
+  cinfo->do_fancy_upsampling = TRUE;
+  cinfo->do_block_smoothing = TRUE;
+  cinfo->quantize_colors = FALSE;
+  /* We set these in case application only sets quantize_colors. */
+  cinfo->dither_mode = JDITHER_FS;
+#ifdef QUANT_2PASS_SUPPORTED
+  cinfo->two_pass_quantize = TRUE;
+#else
+  cinfo->two_pass_quantize = FALSE;
+#endif
+  cinfo->desired_number_of_colors = 256;
+  cinfo->colormap = NULL;
+  /* Initialize for no mode change in buffered-image mode. */
+  cinfo->enable_1pass_quant = FALSE;
+  cinfo->enable_external_quant = FALSE;
+  cinfo->enable_2pass_quant = FALSE;
+}
+
+
+/*
+ * Decompression startup: read start of JPEG datastream to see what's there.
+ * Need only initialize JPEG object and supply a data source before calling.
+ *
+ * This routine will read as far as the first SOS marker (ie, actual start of
+ * compressed data), and will save all tables and parameters in the JPEG
+ * object.  It will also initialize the decompression parameters to default
+ * values, and finally return JPEG_HEADER_OK.  On return, the application may
+ * adjust the decompression parameters and then call jpeg_start_decompress.
+ * (Or, if the application only wanted to determine the image parameters,
+ * the data need not be decompressed.  In that case, call jpeg_abort or
+ * jpeg_destroy to release any temporary space.)
+ * If an abbreviated (tables only) datastream is presented, the routine will
+ * return JPEG_HEADER_TABLES_ONLY upon reaching EOI.  The application may then
+ * re-use the JPEG object to read the abbreviated image datastream(s).
+ * It is unnecessary (but OK) to call jpeg_abort in this case.
+ * The JPEG_SUSPENDED return code only occurs if the data source module
+ * requests suspension of the decompressor.  In this case the application
+ * should load more source data and then re-call jpeg_read_header to resume
+ * processing.
+ * If a non-suspending data source is used and require_image is TRUE, then the
+ * return code need not be inspected since only JPEG_HEADER_OK is possible.
+ *
+ * This routine is now just a front end to jpeg_consume_input, with some
+ * extra error checking.
+ */
+
+GLOBAL int
+jpeg_read_header (j_decompress_ptr cinfo, boolean require_image)
+{
+  int retcode;
+
+  if (cinfo->global_state != DSTATE_START &&
+      cinfo->global_state != DSTATE_INHEADER)
+    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+
+  retcode = jpeg_consume_input(cinfo);
+
+  switch (retcode) {
+  case JPEG_REACHED_SOS:
+    retcode = JPEG_HEADER_OK;
+    break;
+  case JPEG_REACHED_EOI:
+    if (require_image)		/* Complain if application wanted an image */
+      ERREXIT(cinfo, JERR_NO_IMAGE);
+    /* Reset to start state; it would be safer to require the application to
+     * call jpeg_abort, but we can't change it now for compatibility reasons.
+     * A side effect is to free any temporary memory (there shouldn't be any).
+     */
+    jpeg_abort((j_common_ptr) cinfo); /* sets state = DSTATE_START */
+    retcode = JPEG_HEADER_TABLES_ONLY;
+    break;
+  case JPEG_SUSPENDED:
+    /* no work */
+    break;
+  }
+
+  return retcode;
+}
+
+
+/*
+ * Consume data in advance of what the decompressor requires.
+ * This can be called at any time once the decompressor object has
+ * been created and a data source has been set up.
+ *
+ * This routine is essentially a state machine that handles a couple
+ * of critical state-transition actions, namely initial setup and
+ * transition from header scanning to ready-for-start_decompress.
+ * All the actual input is done via the input controller's consume_input
+ * method.
+ */
+
+GLOBAL int
+jpeg_consume_input (j_decompress_ptr cinfo)
+{
+  int retcode = JPEG_SUSPENDED;
+
+  /* NB: every possible DSTATE value should be listed in this switch */
+  switch (cinfo->global_state) {
+  case DSTATE_START:
+    /* Start-of-datastream actions: reset appropriate modules */
+    (*cinfo->inputctl->reset_input_controller) (cinfo);
+    /* Initialize application's data source module */
+    (*cinfo->src->init_source) (cinfo);
+    cinfo->global_state = DSTATE_INHEADER;
+    /*FALLTHROUGH*/
+  case DSTATE_INHEADER:
+    retcode = (*cinfo->inputctl->consume_input) (cinfo);
+    if (retcode == JPEG_REACHED_SOS) { /* Found SOS, prepare to decompress */
+      /* Set up default parameters based on header data */
+      default_decompress_parms(cinfo);
+      /* Set global state: ready for start_decompress */
+      cinfo->global_state = DSTATE_READY;
+    }
+    break;
+  case DSTATE_READY:
+    /* Can't advance past first SOS until start_decompress is called */
+    retcode = JPEG_REACHED_SOS;
+    break;
+  case DSTATE_PRELOAD:
+  case DSTATE_PRESCAN:
+  case DSTATE_SCANNING:
+  case DSTATE_RAW_OK:
+  case DSTATE_BUFIMAGE:
+  case DSTATE_BUFPOST:
+  case DSTATE_STOPPING:
+    retcode = (*cinfo->inputctl->consume_input) (cinfo);
+    break;
+  default:
+    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+  }
+  return retcode;
+}
+
+
+/*
+ * Have we finished reading the input file?
+ */
+
+GLOBAL boolean
+jpeg_input_complete (j_decompress_ptr cinfo)
+{
+  /* Check for valid jpeg object */
+  if (cinfo->global_state < DSTATE_START ||
+      cinfo->global_state > DSTATE_STOPPING)
+    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+  return cinfo->inputctl->eoi_reached;
+}
+
+
+/*
+ * Is there more than one scan?
+ */
+
+GLOBAL boolean
+jpeg_has_multiple_scans (j_decompress_ptr cinfo)
+{
+  /* Only valid after jpeg_read_header completes */
+  if (cinfo->global_state < DSTATE_READY ||
+      cinfo->global_state > DSTATE_STOPPING)
+    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+  return cinfo->inputctl->has_multiple_scans;
+}
+
+
+/*
+ * Finish JPEG decompression.
+ *
+ * This will normally just verify the file trailer and release temp storage.
+ *
+ * Returns FALSE if suspended.  The return value need be inspected only if
+ * a suspending data source is used.
+ */
+
+GLOBAL boolean
+jpeg_finish_decompress (j_decompress_ptr cinfo)
+{
+  if ((cinfo->global_state == DSTATE_SCANNING ||
+       cinfo->global_state == DSTATE_RAW_OK) && ! cinfo->buffered_image) {
+    /* Terminate final pass of non-buffered mode */
+    if (cinfo->output_scanline < cinfo->output_height)
+      ERREXIT(cinfo, JERR_TOO_LITTLE_DATA);
+    (*cinfo->master->finish_output_pass) (cinfo);
+    cinfo->global_state = DSTATE_STOPPING;
+  } else if (cinfo->global_state == DSTATE_BUFIMAGE) {
+    /* Finishing after a buffered-image operation */
+    cinfo->global_state = DSTATE_STOPPING;
+  } else if (cinfo->global_state != DSTATE_STOPPING) {
+    /* STOPPING = repeat call after a suspension, anything else is error */
+    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+  }
+  /* Read until EOI */
+  while (! cinfo->inputctl->eoi_reached) {
+    if ((*cinfo->inputctl->consume_input) (cinfo) == JPEG_SUSPENDED)
+      return FALSE;		/* Suspend, come back later */
+  }
+  /* Do final cleanup */
+  (*cinfo->src->term_source) (cinfo);
+  /* We can use jpeg_abort to release memory and reset global_state */
+  jpeg_abort((j_common_ptr) cinfo);
+  return TRUE;
+}
diff --git a/codemp/jpeg-6/jdapistd.cpp b/codemp/jpeg-6/jdapistd.cpp
new file mode 100644
index 0000000..a3f6069
--- /dev/null
+++ b/codemp/jpeg-6/jdapistd.cpp
@@ -0,0 +1,277 @@
+/*
+ * jdapistd.c
+ *
+ * Copyright (C) 1994-1995, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains application interface code for the decompression half
+ * of the JPEG library.  These are the "standard" API routines that are
+ * used in the normal full-decompression case.  They are not used by a
+ * transcoding-only application.  Note that if an application links in
+ * jpeg_start_decompress, it will end up linking in the entire decompressor.
+ * We thus must separate this file from jdapimin.c to avoid linking the
+ * whole decompression library into a transcoder.
+ */
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/* Forward declarations */
+LOCAL boolean output_pass_setup JPP((j_decompress_ptr cinfo));
+
+
+/*
+ * Decompression initialization.
+ * jpeg_read_header must be completed before calling this.
+ *
+ * If a multipass operating mode was selected, this will do all but the
+ * last pass, and thus may take a great deal of time.
+ *
+ * Returns FALSE if suspended.  The return value need be inspected only if
+ * a suspending data source is used.
+ */
+
+GLOBAL boolean
+jpeg_start_decompress (j_decompress_ptr cinfo)
+{
+  if (cinfo->global_state == DSTATE_READY) {
+    /* First call: initialize master control, select active modules */
+    jinit_master_decompress(cinfo);
+    if (cinfo->buffered_image) {
+      /* No more work here; expecting jpeg_start_output next */
+      cinfo->global_state = DSTATE_BUFIMAGE;
+      return TRUE;
+    }
+    cinfo->global_state = DSTATE_PRELOAD;
+  }
+  if (cinfo->global_state == DSTATE_PRELOAD) {
+    /* If file has multiple scans, absorb them all into the coef buffer */
+    if (cinfo->inputctl->has_multiple_scans) {
+#ifdef D_MULTISCAN_FILES_SUPPORTED
+      for (;;) {
+	int retcode;
+	/* Call progress monitor hook if present */
+	if (cinfo->progress != NULL)
+	  (*cinfo->progress->progress_monitor) ((j_common_ptr) cinfo);
+	/* Absorb some more input */
+	retcode = (*cinfo->inputctl->consume_input) (cinfo);
+	if (retcode == JPEG_SUSPENDED)
+	  return FALSE;
+	if (retcode == JPEG_REACHED_EOI)
+	  break;
+	/* Advance progress counter if appropriate */
+	if (cinfo->progress != NULL &&
+	    (retcode == JPEG_ROW_COMPLETED || retcode == JPEG_REACHED_SOS)) {
+	  if (++cinfo->progress->pass_counter >= cinfo->progress->pass_limit) {
+	    /* jdmaster underestimated number of scans; ratchet up one scan */
+	    cinfo->progress->pass_limit += (long) cinfo->total_iMCU_rows;
+	  }
+	}
+      }
+#else
+      ERREXIT(cinfo, JERR_NOT_COMPILED);
+#endif /* D_MULTISCAN_FILES_SUPPORTED */
+    }
+    cinfo->output_scan_number = cinfo->input_scan_number;
+  } else if (cinfo->global_state != DSTATE_PRESCAN)
+    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+  /* Perform any dummy output passes, and set up for the final pass */
+  return output_pass_setup(cinfo);
+}
+
+
+/*
+ * Set up for an output pass, and perform any dummy pass(es) needed.
+ * Common subroutine for jpeg_start_decompress and jpeg_start_output.
+ * Entry: global_state = DSTATE_PRESCAN only if previously suspended.
+ * Exit: If done, returns TRUE and sets global_state for proper output mode.
+ *       If suspended, returns FALSE and sets global_state = DSTATE_PRESCAN.
+ */
+
+LOCAL boolean
+output_pass_setup (j_decompress_ptr cinfo)
+{
+  if (cinfo->global_state != DSTATE_PRESCAN) {
+    /* First call: do pass setup */
+    (*cinfo->master->prepare_for_output_pass) (cinfo);
+    cinfo->output_scanline = 0;
+    cinfo->global_state = DSTATE_PRESCAN;
+  }
+  /* Loop over any required dummy passes */
+  while (cinfo->master->is_dummy_pass) {
+#ifdef QUANT_2PASS_SUPPORTED
+    /* Crank through the dummy pass */
+    while (cinfo->output_scanline < cinfo->output_height) {
+      JDIMENSION last_scanline;
+      /* Call progress monitor hook if present */
+      if (cinfo->progress != NULL) {
+	cinfo->progress->pass_counter = (long) cinfo->output_scanline;
+	cinfo->progress->pass_limit = (long) cinfo->output_height;
+	(*cinfo->progress->progress_monitor) ((j_common_ptr) cinfo);
+      }
+      /* Process some data */
+      last_scanline = cinfo->output_scanline;
+      (*cinfo->main->process_data) (cinfo, (JSAMPARRAY) NULL,
+				    &cinfo->output_scanline, (JDIMENSION) 0);
+      if (cinfo->output_scanline == last_scanline)
+	return FALSE;		/* No progress made, must suspend */
+    }
+    /* Finish up dummy pass, and set up for another one */
+    (*cinfo->master->finish_output_pass) (cinfo);
+    (*cinfo->master->prepare_for_output_pass) (cinfo);
+    cinfo->output_scanline = 0;
+#else
+    ERREXIT(cinfo, JERR_NOT_COMPILED);
+#endif /* QUANT_2PASS_SUPPORTED */
+  }
+  /* Ready for application to drive output pass through
+   * jpeg_read_scanlines or jpeg_read_raw_data.
+   */
+  cinfo->global_state = cinfo->raw_data_out ? DSTATE_RAW_OK : DSTATE_SCANNING;
+  return TRUE;
+}
+
+
+/*
+ * Read some scanlines of data from the JPEG decompressor.
+ *
+ * The return value will be the number of lines actually read.
+ * This may be less than the number requested in several cases,
+ * including bottom of image, data source suspension, and operating
+ * modes that emit multiple scanlines at a time.
+ *
+ * Note: we warn about excess calls to jpeg_read_scanlines() since
+ * this likely signals an application programmer error.  However,
+ * an oversize buffer (max_lines > scanlines remaining) is not an error.
+ */
+
+GLOBAL JDIMENSION
+jpeg_read_scanlines (j_decompress_ptr cinfo, JSAMPARRAY scanlines,
+		     JDIMENSION max_lines)
+{
+  JDIMENSION row_ctr;
+
+  if (cinfo->global_state != DSTATE_SCANNING)
+    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+  if (cinfo->output_scanline >= cinfo->output_height) {
+    WARNMS(cinfo, JWRN_TOO_MUCH_DATA);
+    return 0;
+  }
+
+  /* Call progress monitor hook if present */
+  if (cinfo->progress != NULL) {
+    cinfo->progress->pass_counter = (long) cinfo->output_scanline;
+    cinfo->progress->pass_limit = (long) cinfo->output_height;
+    (*cinfo->progress->progress_monitor) ((j_common_ptr) cinfo);
+  }
+
+  /* Process some data */
+  row_ctr = 0;
+  (*cinfo->main->process_data) (cinfo, scanlines, &row_ctr, max_lines);
+  cinfo->output_scanline += row_ctr;
+  return row_ctr;
+}
+
+
+/*
+ * Alternate entry point to read raw data.
+ * Processes exactly one iMCU row per call, unless suspended.
+ */
+
+GLOBAL JDIMENSION
+jpeg_read_raw_data (j_decompress_ptr cinfo, JSAMPIMAGE data,
+		    JDIMENSION max_lines)
+{
+  JDIMENSION lines_per_iMCU_row;
+
+  if (cinfo->global_state != DSTATE_RAW_OK)
+    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+  if (cinfo->output_scanline >= cinfo->output_height) {
+    WARNMS(cinfo, JWRN_TOO_MUCH_DATA);
+    return 0;
+  }
+
+  /* Call progress monitor hook if present */
+  if (cinfo->progress != NULL) {
+    cinfo->progress->pass_counter = (long) cinfo->output_scanline;
+    cinfo->progress->pass_limit = (long) cinfo->output_height;
+    (*cinfo->progress->progress_monitor) ((j_common_ptr) cinfo);
+  }
+
+  /* Verify that at least one iMCU row can be returned. */
+  lines_per_iMCU_row = cinfo->max_v_samp_factor * cinfo->min_DCT_scaled_size;
+  if (max_lines < lines_per_iMCU_row)
+    ERREXIT(cinfo, JERR_BUFFER_SIZE);
+
+  /* Decompress directly into user's buffer. */
+  if (! (*cinfo->coef->decompress_data) (cinfo, data))
+    return 0;			/* suspension forced, can do nothing more */
+
+  /* OK, we processed one iMCU row. */
+  cinfo->output_scanline += lines_per_iMCU_row;
+  return lines_per_iMCU_row;
+}
+
+
+/* Additional entry points for buffered-image mode. */
+
+#ifdef D_MULTISCAN_FILES_SUPPORTED
+
+/*
+ * Initialize for an output pass in buffered-image mode.
+ */
+
+GLOBAL boolean
+jpeg_start_output (j_decompress_ptr cinfo, int scan_number)
+{
+  if (cinfo->global_state != DSTATE_BUFIMAGE &&
+      cinfo->global_state != DSTATE_PRESCAN)
+    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+  /* Limit scan number to valid range */
+  if (scan_number <= 0)
+    scan_number = 1;
+  if (cinfo->inputctl->eoi_reached &&
+      scan_number > cinfo->input_scan_number)
+    scan_number = cinfo->input_scan_number;
+  cinfo->output_scan_number = scan_number;
+  /* Perform any dummy output passes, and set up for the real pass */
+  return output_pass_setup(cinfo);
+}
+
+
+/*
+ * Finish up after an output pass in buffered-image mode.
+ *
+ * Returns FALSE if suspended.  The return value need be inspected only if
+ * a suspending data source is used.
+ */
+
+GLOBAL boolean
+jpeg_finish_output (j_decompress_ptr cinfo)
+{
+  if ((cinfo->global_state == DSTATE_SCANNING ||
+       cinfo->global_state == DSTATE_RAW_OK) && cinfo->buffered_image) {
+    /* Terminate this pass. */
+    /* We do not require the whole pass to have been completed. */
+    (*cinfo->master->finish_output_pass) (cinfo);
+    cinfo->global_state = DSTATE_BUFPOST;
+  } else if (cinfo->global_state != DSTATE_BUFPOST) {
+    /* BUFPOST = repeat call after a suspension, anything else is error */
+    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+  }
+  /* Read markers looking for SOS or EOI */
+  while (cinfo->input_scan_number <= cinfo->output_scan_number &&
+	 ! cinfo->inputctl->eoi_reached) {
+    if ((*cinfo->inputctl->consume_input) (cinfo) == JPEG_SUSPENDED)
+      return FALSE;		/* Suspend, come back later */
+  }
+  cinfo->global_state = DSTATE_BUFIMAGE;
+  return TRUE;
+}
+
+#endif /* D_MULTISCAN_FILES_SUPPORTED */
diff --git a/codemp/jpeg-6/jdatadst.cpp b/codemp/jpeg-6/jdatadst.cpp
new file mode 100644
index 0000000..9a05a0d
--- /dev/null
+++ b/codemp/jpeg-6/jdatadst.cpp
@@ -0,0 +1,153 @@
+/*
+ * jdatadst.c
+ *
+ * Copyright (C) 1994, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains compression data destination routines for the case of
+ * emitting JPEG data to a file (or any stdio stream).  While these routines
+ * are sufficient for most applications, some will want to use a different
+ * destination manager.
+ * IMPORTANT: we assume that fwrite() will correctly transcribe an array of
+ * JOCTETs into 8-bit-wide elements on external storage.  If char is wider
+ * than 8 bits on your machine, you may need to do some tweaking.
+ */
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+/* this is not a core library module, so it doesn't define JPEG_INTERNALS */
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jerror.h"
+
+
+/* Expanded data destination object for stdio output */
+
+typedef struct {
+  struct jpeg_destination_mgr pub; /* public fields */
+
+  FILE * outfile;		/* target stream */
+  JOCTET * buffer;		/* start of buffer */
+} my_destination_mgr;
+
+typedef my_destination_mgr * my_dest_ptr;
+
+#define OUTPUT_BUF_SIZE  4096	/* choose an efficiently fwrite'able size */
+
+
+/*
+ * Initialize destination --- called by jpeg_start_compress
+ * before any data is actually written.
+ */
+
+METHODDEF void
+init_destination (j_compress_ptr cinfo)
+{
+  my_dest_ptr dest = (my_dest_ptr) cinfo->dest;
+
+  /* Allocate the output buffer --- it will be released when done with image */
+  dest->buffer = (JOCTET *)
+      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				  OUTPUT_BUF_SIZE * SIZEOF(JOCTET));
+
+  dest->pub.next_output_byte = dest->buffer;
+  dest->pub.free_in_buffer = OUTPUT_BUF_SIZE;
+}
+
+
+/*
+ * Empty the output buffer --- called whenever buffer fills up.
+ *
+ * In typical applications, this should write the entire output buffer
+ * (ignoring the current state of next_output_byte & free_in_buffer),
+ * reset the pointer & count to the start of the buffer, and return TRUE
+ * indicating that the buffer has been dumped.
+ *
+ * In applications that need to be able to suspend compression due to output
+ * overrun, a FALSE return indicates that the buffer cannot be emptied now.
+ * In this situation, the compressor will return to its caller (possibly with
+ * an indication that it has not accepted all the supplied scanlines).  The
+ * application should resume compression after it has made more room in the
+ * output buffer.  Note that there are substantial restrictions on the use of
+ * suspension --- see the documentation.
+ *
+ * When suspending, the compressor will back up to a convenient restart point
+ * (typically the start of the current MCU). next_output_byte & free_in_buffer
+ * indicate where the restart point will be if the current call returns FALSE.
+ * Data beyond this point will be regenerated after resumption, so do not
+ * write it out when emptying the buffer externally.
+ */
+
+METHODDEF boolean
+empty_output_buffer (j_compress_ptr cinfo)
+{
+  my_dest_ptr dest = (my_dest_ptr) cinfo->dest;
+
+  if (JFWRITE(dest->outfile, dest->buffer, OUTPUT_BUF_SIZE) !=
+      (size_t) OUTPUT_BUF_SIZE)
+    ERREXIT(cinfo, JERR_FILE_WRITE);
+
+  dest->pub.next_output_byte = dest->buffer;
+  dest->pub.free_in_buffer = OUTPUT_BUF_SIZE;
+
+  return TRUE;
+}
+
+
+/*
+ * Terminate destination --- called by jpeg_finish_compress
+ * after all data has been written.  Usually needs to flush buffer.
+ *
+ * NB: *not* called by jpeg_abort or jpeg_destroy; surrounding
+ * application must deal with any cleanup that should happen even
+ * for error exit.
+ */
+
+METHODDEF void
+term_destination (j_compress_ptr cinfo)
+{
+  my_dest_ptr dest = (my_dest_ptr) cinfo->dest;
+  size_t datacount = OUTPUT_BUF_SIZE - dest->pub.free_in_buffer;
+
+  /* Write any data remaining in the buffer */
+  if (datacount > 0) {
+    if (JFWRITE(dest->outfile, dest->buffer, datacount) != datacount)
+      ERREXIT(cinfo, JERR_FILE_WRITE);
+  }
+  fflush(dest->outfile);
+  /* Make sure we wrote the output file OK */
+  if (ferror(dest->outfile))
+    ERREXIT(cinfo, JERR_FILE_WRITE);
+}
+
+
+/*
+ * Prepare for output to a stdio stream.
+ * The caller must have already opened the stream, and is responsible
+ * for closing it after finishing compression.
+ */
+
+GLOBAL void
+jpeg_stdio_dest (j_compress_ptr cinfo, FILE * outfile)
+{
+  my_dest_ptr dest;
+
+  /* The destination object is made permanent so that multiple JPEG images
+   * can be written to the same file without re-executing jpeg_stdio_dest.
+   * This makes it dangerous to use this manager and a different destination
+   * manager serially with the same JPEG object, because their private object
+   * sizes may be different.  Caveat programmer.
+   */
+  if (cinfo->dest == NULL) {	/* first time for this JPEG object? */
+    cinfo->dest = (struct jpeg_destination_mgr *)
+      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
+				  SIZEOF(my_destination_mgr));
+  }
+
+  dest = (my_dest_ptr) cinfo->dest;
+  dest->pub.init_destination = init_destination;
+  dest->pub.empty_output_buffer = empty_output_buffer;
+  dest->pub.term_destination = term_destination;
+  dest->outfile = outfile;
+}
diff --git a/codemp/jpeg-6/jdatasrc.cpp b/codemp/jpeg-6/jdatasrc.cpp
new file mode 100644
index 0000000..49a831d
--- /dev/null
+++ b/codemp/jpeg-6/jdatasrc.cpp
@@ -0,0 +1,206 @@
+/*
+ * jdatasrc.c
+ *
+ * Copyright (C) 1994, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains decompression data source routines for the case of
+ * reading JPEG data from a file (or any stdio stream).  While these routines
+ * are sufficient for most applications, some will want to use a different
+ * source manager.
+ * IMPORTANT: we assume that fread() will correctly transcribe an array of
+ * JOCTETs from 8-bit-wide elements on external storage.  If char is wider
+ * than 8 bits on your machine, you may need to do some tweaking.
+ */
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+
+/* this is not a core library module, so it doesn't define JPEG_INTERNALS */
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jerror.h"
+
+
+/* Expanded data source object for stdio input */
+
+typedef struct {
+  struct jpeg_source_mgr pub;	/* public fields */
+
+  unsigned char *infile;		/* source stream */
+  JOCTET * buffer;		/* start of buffer */
+  boolean start_of_file;	/* have we gotten any data yet? */
+} my_source_mgr;
+
+typedef my_source_mgr * my_src_ptr;
+
+#define INPUT_BUF_SIZE  4096	/* choose an efficiently fread'able size */
+
+
+/*
+ * Initialize source --- called by jpeg_read_header
+ * before any data is actually read.
+ */
+
+METHODDEF void
+init_source (j_decompress_ptr cinfo)
+{
+  my_src_ptr src = (my_src_ptr) cinfo->src;
+
+  /* We reset the empty-input-file flag for each image,
+   * but we don't clear the input buffer.
+   * This is correct behavior for reading a series of images from one source.
+   */
+  src->start_of_file = TRUE;
+}
+
+
+/*
+ * Fill the input buffer --- called whenever buffer is emptied.
+ *
+ * In typical applications, this should read fresh data into the buffer
+ * (ignoring the current state of next_input_byte & bytes_in_buffer),
+ * reset the pointer & count to the start of the buffer, and return TRUE
+ * indicating that the buffer has been reloaded.  It is not necessary to
+ * fill the buffer entirely, only to obtain at least one more byte.
+ *
+ * There is no such thing as an EOF return.  If the end of the file has been
+ * reached, the routine has a choice of ERREXIT() or inserting fake data into
+ * the buffer.  In most cases, generating a warning message and inserting a
+ * fake EOI marker is the best course of action --- this will allow the
+ * decompressor to output however much of the image is there.  However,
+ * the resulting error message is misleading if the real problem is an empty
+ * input file, so we handle that case specially.
+ *
+ * In applications that need to be able to suspend compression due to input
+ * not being available yet, a FALSE return indicates that no more data can be
+ * obtained right now, but more may be forthcoming later.  In this situation,
+ * the decompressor will return to its caller (with an indication of the
+ * number of scanlines it has read, if any).  The application should resume
+ * decompression after it has loaded more data into the input buffer.  Note
+ * that there are substantial restrictions on the use of suspension --- see
+ * the documentation.
+ *
+ * When suspending, the decompressor will back up to a convenient restart point
+ * (typically the start of the current MCU). next_input_byte & bytes_in_buffer
+ * indicate where the restart point will be if the current call returns FALSE.
+ * Data beyond this point must be rescanned after resumption, so move it to
+ * the front of the buffer rather than discarding it.
+ */
+
+METHODDEF boolean
+fill_input_buffer (j_decompress_ptr cinfo)
+{
+  my_src_ptr src = (my_src_ptr) cinfo->src;
+
+  memcpy( src->buffer, src->infile, INPUT_BUF_SIZE );
+
+  src->infile += INPUT_BUF_SIZE;
+
+  src->pub.next_input_byte = src->buffer;
+  src->pub.bytes_in_buffer = INPUT_BUF_SIZE;
+  src->start_of_file = FALSE;
+
+  return TRUE;
+}
+
+
+/*
+ * Skip data --- used to skip over a potentially large amount of
+ * uninteresting data (such as an APPn marker).
+ *
+ * Writers of suspendable-input applications must note that skip_input_data
+ * is not granted the right to give a suspension return.  If the skip extends
+ * beyond the data currently in the buffer, the buffer can be marked empty so
+ * that the next read will cause a fill_input_buffer call that can suspend.
+ * Arranging for additional bytes to be discarded before reloading the input
+ * buffer is the application writer's problem.
+ */
+
+METHODDEF void
+skip_input_data (j_decompress_ptr cinfo, long num_bytes)
+{
+  my_src_ptr src = (my_src_ptr) cinfo->src;
+
+  /* Just a dumb implementation for now.  Could use fseek() except
+   * it doesn't work on pipes.  Not clear that being smart is worth
+   * any trouble anyway --- large skips are infrequent.
+   */
+  if (num_bytes > 0) {
+    while (num_bytes > (long) src->pub.bytes_in_buffer) {
+      num_bytes -= (long) src->pub.bytes_in_buffer;
+      (void) fill_input_buffer(cinfo);
+      /* note we assume that fill_input_buffer will never return FALSE,
+       * so suspension need not be handled.
+       */
+    }
+    src->pub.next_input_byte += (size_t) num_bytes;
+    src->pub.bytes_in_buffer -= (size_t) num_bytes;
+  }
+}
+
+
+/*
+ * An additional method that can be provided by data source modules is the
+ * resync_to_restart method for error recovery in the presence of RST markers.
+ * For the moment, this source module just uses the default resync method
+ * provided by the JPEG library.  That method assumes that no backtracking
+ * is possible.
+ */
+
+
+/*
+ * Terminate source --- called by jpeg_finish_decompress
+ * after all data has been read.  Often a no-op.
+ *
+ * NB: *not* called by jpeg_abort or jpeg_destroy; surrounding
+ * application must deal with any cleanup that should happen even
+ * for error exit.
+ */
+
+METHODDEF void
+term_source (j_decompress_ptr cinfo)
+{
+  /* no work necessary here */
+}
+
+
+/*
+ * Prepare for input from a stdio stream.
+ * The caller must have already opened the stream, and is responsible
+ * for closing it after finishing decompression.
+ */
+
+GLOBAL void
+jpeg_stdio_src (j_decompress_ptr cinfo, unsigned char *infile)
+{
+  my_src_ptr src;
+
+  /* The source object and input buffer are made permanent so that a series
+   * of JPEG images can be read from the same file by calling jpeg_stdio_src
+   * only before the first one.  (If we discarded the buffer at the end of
+   * one image, we'd likely lose the start of the next one.)
+   * This makes it unsafe to use this manager and a different source
+   * manager serially with the same JPEG object.  Caveat programmer.
+   */
+  if (cinfo->src == NULL) {	/* first time for this JPEG object? */
+    cinfo->src = (struct jpeg_source_mgr *)
+      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
+				  SIZEOF(my_source_mgr));
+    src = (my_src_ptr) cinfo->src;
+    src->buffer = (JOCTET *)
+      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
+				  INPUT_BUF_SIZE * SIZEOF(JOCTET));
+  }
+
+  src = (my_src_ptr) cinfo->src;
+  src->pub.init_source = init_source;
+  src->pub.fill_input_buffer = fill_input_buffer;
+  src->pub.skip_input_data = skip_input_data;
+  src->pub.resync_to_restart = jpeg_resync_to_restart; /* use default method */
+  src->pub.term_source = term_source;
+  src->infile = infile;
+  src->pub.bytes_in_buffer = 0; /* forces fill_input_buffer on first read */
+  src->pub.next_input_byte = NULL; /* until buffer loaded */
+}
diff --git a/codemp/jpeg-6/jdcoefct.cpp b/codemp/jpeg-6/jdcoefct.cpp
new file mode 100644
index 0000000..63b6faf
--- /dev/null
+++ b/codemp/jpeg-6/jdcoefct.cpp
@@ -0,0 +1,727 @@
+/*
+ * jdcoefct.c
+ *
+ * Copyright (C) 1994-1995, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains the coefficient buffer controller for decompression.
+ * This controller is the top level of the JPEG decompressor proper.
+ * The coefficient buffer lies between entropy decoding and inverse-DCT steps.
+ *
+ * In buffered-image mode, this controller is the interface between
+ * input-oriented processing and output-oriented processing.
+ * Also, the input side (only) is used when reading a file for transcoding.
+ */
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+/* Block smoothing is only applicable for progressive JPEG, so: */
+#ifndef D_PROGRESSIVE_SUPPORTED
+#undef BLOCK_SMOOTHING_SUPPORTED
+#endif
+
+/* Private buffer controller object */
+
+typedef struct {
+  struct jpeg_d_coef_controller pub; /* public fields */
+
+  /* These variables keep track of the current location of the input side. */
+  /* cinfo->input_iMCU_row is also used for this. */
+  JDIMENSION MCU_ctr;		/* counts MCUs processed in current row */
+  int MCU_vert_offset;		/* counts MCU rows within iMCU row */
+  int MCU_rows_per_iMCU_row;	/* number of such rows needed */
+
+  /* The output side's location is represented by cinfo->output_iMCU_row. */
+
+  /* In single-pass modes, it's sufficient to buffer just one MCU.
+   * We allocate a workspace of D_MAX_BLOCKS_IN_MCU coefficient blocks,
+   * and let the entropy decoder write into that workspace each time.
+   * (On 80x86, the workspace is FAR even though it's not really very big;
+   * this is to keep the module interfaces unchanged when a large coefficient
+   * buffer is necessary.)
+   * In multi-pass modes, this array points to the current MCU's blocks
+   * within the virtual arrays; it is used only by the input side.
+   */
+  JBLOCKROW MCU_buffer[D_MAX_BLOCKS_IN_MCU];
+
+#ifdef D_MULTISCAN_FILES_SUPPORTED
+  /* In multi-pass modes, we need a virtual block array for each component. */
+  jvirt_barray_ptr whole_image[MAX_COMPONENTS];
+#endif
+
+#ifdef BLOCK_SMOOTHING_SUPPORTED
+  /* When doing block smoothing, we latch coefficient Al values here */
+  int * coef_bits_latch;
+#define SAVED_COEFS  6		/* we save coef_bits[0..5] */
+#endif
+} my_coef_controller;
+
+typedef my_coef_controller * my_coef_ptr;
+
+/* Forward declarations */
+METHODDEF int decompress_onepass
+	JPP((j_decompress_ptr cinfo, JSAMPIMAGE output_buf));
+#ifdef D_MULTISCAN_FILES_SUPPORTED
+METHODDEF int decompress_data
+	JPP((j_decompress_ptr cinfo, JSAMPIMAGE output_buf));
+#endif
+#ifdef BLOCK_SMOOTHING_SUPPORTED
+LOCAL boolean smoothing_ok JPP((j_decompress_ptr cinfo));
+METHODDEF int decompress_smooth_data
+	JPP((j_decompress_ptr cinfo, JSAMPIMAGE output_buf));
+#endif
+
+
+LOCAL void
+start_iMCU_row (j_decompress_ptr cinfo)
+/* Reset within-iMCU-row counters for a new row (input side) */
+{
+  my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
+
+  /* In an interleaved scan, an MCU row is the same as an iMCU row.
+   * In a noninterleaved scan, an iMCU row has v_samp_factor MCU rows.
+   * But at the bottom of the image, process only what's left.
+   */
+  if (cinfo->comps_in_scan > 1) {
+    coef->MCU_rows_per_iMCU_row = 1;
+  } else {
+    if (cinfo->input_iMCU_row < (cinfo->total_iMCU_rows-1))
+      coef->MCU_rows_per_iMCU_row = cinfo->cur_comp_info[0]->v_samp_factor;
+    else
+      coef->MCU_rows_per_iMCU_row = cinfo->cur_comp_info[0]->last_row_height;
+  }
+
+  coef->MCU_ctr = 0;
+  coef->MCU_vert_offset = 0;
+}
+
+
+/*
+ * Initialize for an input processing pass.
+ */
+
+METHODDEF void
+start_input_pass (j_decompress_ptr cinfo)
+{
+  cinfo->input_iMCU_row = 0;
+  start_iMCU_row(cinfo);
+}
+
+
+/*
+ * Initialize for an output processing pass.
+ */
+
+METHODDEF void
+start_output_pass (j_decompress_ptr cinfo)
+{
+#ifdef BLOCK_SMOOTHING_SUPPORTED
+  my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
+
+  /* If multipass, check to see whether to use block smoothing on this pass */
+  if (coef->pub.coef_arrays != NULL) {
+    if (cinfo->do_block_smoothing && smoothing_ok(cinfo))
+      coef->pub.decompress_data = decompress_smooth_data;
+    else
+      coef->pub.decompress_data = decompress_data;
+  }
+#endif
+  cinfo->output_iMCU_row = 0;
+}
+
+
+/*
+ * Decompress and return some data in the single-pass case.
+ * Always attempts to emit one fully interleaved MCU row ("iMCU" row).
+ * Input and output must run in lockstep since we have only a one-MCU buffer.
+ * Return value is JPEG_ROW_COMPLETED, JPEG_SCAN_COMPLETED, or JPEG_SUSPENDED.
+ *
+ * NB: output_buf contains a plane for each component in image.
+ * For single pass, this is the same as the components in the scan.
+ */
+
+METHODDEF int
+decompress_onepass (j_decompress_ptr cinfo, JSAMPIMAGE output_buf)
+{
+  my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
+  JDIMENSION MCU_col_num;	/* index of current MCU within row */
+  JDIMENSION last_MCU_col = cinfo->MCUs_per_row - 1;
+  JDIMENSION last_iMCU_row = cinfo->total_iMCU_rows - 1;
+  int blkn, ci, xindex, yindex, yoffset, useful_width;
+  JSAMPARRAY output_ptr;
+  JDIMENSION start_col, output_col;
+  jpeg_component_info *compptr;
+  inverse_DCT_method_ptr inverse_DCT;
+
+  /* Loop to process as much as one whole iMCU row */
+  for (yoffset = coef->MCU_vert_offset; yoffset < coef->MCU_rows_per_iMCU_row;
+       yoffset++) {
+    for (MCU_col_num = coef->MCU_ctr; MCU_col_num <= last_MCU_col;
+	 MCU_col_num++) {
+      /* Try to fetch an MCU.  Entropy decoder expects buffer to be zeroed. */
+      jzero_far((void FAR *) coef->MCU_buffer[0],
+		(size_t) (cinfo->blocks_in_MCU * SIZEOF(JBLOCK)));
+      if (! (*cinfo->entropy->decode_mcu) (cinfo, coef->MCU_buffer)) {
+	/* Suspension forced; update state counters and exit */
+	coef->MCU_vert_offset = yoffset;
+	coef->MCU_ctr = MCU_col_num;
+	return JPEG_SUSPENDED;
+      }
+      /* Determine where data should go in output_buf and do the IDCT thing.
+       * We skip dummy blocks at the right and bottom edges (but blkn gets
+       * incremented past them!).  Note the inner loop relies on having
+       * allocated the MCU_buffer[] blocks sequentially.
+       */
+      blkn = 0;			/* index of current DCT block within MCU */
+      for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+	compptr = cinfo->cur_comp_info[ci];
+	/* Don't bother to IDCT an uninteresting component. */
+	if (! compptr->component_needed) {
+	  blkn += compptr->MCU_blocks;
+	  continue;
+	}
+	inverse_DCT = cinfo->idct->inverse_DCT[compptr->component_index];
+	useful_width = (MCU_col_num < last_MCU_col) ? compptr->MCU_width
+						    : compptr->last_col_width;
+	output_ptr = output_buf[ci] + yoffset * compptr->DCT_scaled_size;
+	start_col = MCU_col_num * compptr->MCU_sample_width;
+	for (yindex = 0; yindex < compptr->MCU_height; yindex++) {
+	  if (cinfo->input_iMCU_row < last_iMCU_row ||
+	      yoffset+yindex < compptr->last_row_height) {
+	    output_col = start_col;
+	    for (xindex = 0; xindex < useful_width; xindex++) {
+	      (*inverse_DCT) (cinfo, compptr,
+			      (JCOEFPTR) coef->MCU_buffer[blkn+xindex],
+			      output_ptr, output_col);
+	      output_col += compptr->DCT_scaled_size;
+	    }
+	  }
+	  blkn += compptr->MCU_width;
+	  output_ptr += compptr->DCT_scaled_size;
+	}
+      }
+    }
+    /* Completed an MCU row, but perhaps not an iMCU row */
+    coef->MCU_ctr = 0;
+  }
+  /* Completed the iMCU row, advance counters for next one */
+  cinfo->output_iMCU_row++;
+  if (++(cinfo->input_iMCU_row) < cinfo->total_iMCU_rows) {
+    start_iMCU_row(cinfo);
+    return JPEG_ROW_COMPLETED;
+  }
+  /* Completed the scan */
+  (*cinfo->inputctl->finish_input_pass) (cinfo);
+  return JPEG_SCAN_COMPLETED;
+}
+
+
+/*
+ * Dummy consume-input routine for single-pass operation.
+ */
+
+METHODDEF int
+dummy_consume_data (j_decompress_ptr cinfo)
+{
+  return JPEG_SUSPENDED;	/* Always indicate nothing was done */
+}
+
+
+#ifdef D_MULTISCAN_FILES_SUPPORTED
+
+/*
+ * Consume input data and store it in the full-image coefficient buffer.
+ * We read as much as one fully interleaved MCU row ("iMCU" row) per call,
+ * ie, v_samp_factor block rows for each component in the scan.
+ * Return value is JPEG_ROW_COMPLETED, JPEG_SCAN_COMPLETED, or JPEG_SUSPENDED.
+ */
+
+METHODDEF int
+consume_data (j_decompress_ptr cinfo)
+{
+  my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
+  JDIMENSION MCU_col_num;	/* index of current MCU within row */
+  int blkn, ci, xindex, yindex, yoffset;
+  JDIMENSION start_col;
+  JBLOCKARRAY buffer[MAX_COMPS_IN_SCAN];
+  JBLOCKROW buffer_ptr;
+  jpeg_component_info *compptr;
+
+  /* Align the virtual buffers for the components used in this scan. */
+  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+    compptr = cinfo->cur_comp_info[ci];
+    buffer[ci] = (*cinfo->mem->access_virt_barray)
+      ((j_common_ptr) cinfo, coef->whole_image[compptr->component_index],
+       cinfo->input_iMCU_row * compptr->v_samp_factor,
+       (JDIMENSION) compptr->v_samp_factor, TRUE);
+    /* Note: entropy decoder expects buffer to be zeroed,
+     * but this is handled automatically by the memory manager
+     * because we requested a pre-zeroed array.
+     */
+  }
+
+  /* Loop to process one whole iMCU row */
+  for (yoffset = coef->MCU_vert_offset; yoffset < coef->MCU_rows_per_iMCU_row;
+       yoffset++) {
+    for (MCU_col_num = coef->MCU_ctr; MCU_col_num < cinfo->MCUs_per_row;
+	 MCU_col_num++) {
+      /* Construct list of pointers to DCT blocks belonging to this MCU */
+      blkn = 0;			/* index of current DCT block within MCU */
+      for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+	compptr = cinfo->cur_comp_info[ci];
+	start_col = MCU_col_num * compptr->MCU_width;
+	for (yindex = 0; yindex < compptr->MCU_height; yindex++) {
+	  buffer_ptr = buffer[ci][yindex+yoffset] + start_col;
+	  for (xindex = 0; xindex < compptr->MCU_width; xindex++) {
+	    coef->MCU_buffer[blkn++] = buffer_ptr++;
+	  }
+	}
+      }
+      /* Try to fetch the MCU. */
+      if (! (*cinfo->entropy->decode_mcu) (cinfo, coef->MCU_buffer)) {
+	/* Suspension forced; update state counters and exit */
+	coef->MCU_vert_offset = yoffset;
+	coef->MCU_ctr = MCU_col_num;
+	return JPEG_SUSPENDED;
+      }
+    }
+    /* Completed an MCU row, but perhaps not an iMCU row */
+    coef->MCU_ctr = 0;
+  }
+  /* Completed the iMCU row, advance counters for next one */
+  if (++(cinfo->input_iMCU_row) < cinfo->total_iMCU_rows) {
+    start_iMCU_row(cinfo);
+    return JPEG_ROW_COMPLETED;
+  }
+  /* Completed the scan */
+  (*cinfo->inputctl->finish_input_pass) (cinfo);
+  return JPEG_SCAN_COMPLETED;
+}
+
+
+/*
+ * Decompress and return some data in the multi-pass case.
+ * Always attempts to emit one fully interleaved MCU row ("iMCU" row).
+ * Return value is JPEG_ROW_COMPLETED, JPEG_SCAN_COMPLETED, or JPEG_SUSPENDED.
+ *
+ * NB: output_buf contains a plane for each component in image.
+ */
+
+METHODDEF int
+decompress_data (j_decompress_ptr cinfo, JSAMPIMAGE output_buf)
+{
+  my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
+  JDIMENSION last_iMCU_row = cinfo->total_iMCU_rows - 1;
+  JDIMENSION block_num;
+  int ci, block_row, block_rows;
+  JBLOCKARRAY buffer;
+  JBLOCKROW buffer_ptr;
+  JSAMPARRAY output_ptr;
+  JDIMENSION output_col;
+  jpeg_component_info *compptr;
+  inverse_DCT_method_ptr inverse_DCT;
+
+  /* Force some input to be done if we are getting ahead of the input. */
+  while (cinfo->input_scan_number < cinfo->output_scan_number ||
+	 (cinfo->input_scan_number == cinfo->output_scan_number &&
+	  cinfo->input_iMCU_row <= cinfo->output_iMCU_row)) {
+    if ((*cinfo->inputctl->consume_input)(cinfo) == JPEG_SUSPENDED)
+      return JPEG_SUSPENDED;
+  }
+
+  /* OK, output from the virtual arrays. */
+  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+       ci++, compptr++) {
+    /* Don't bother to IDCT an uninteresting component. */
+    if (! compptr->component_needed)
+      continue;
+    /* Align the virtual buffer for this component. */
+    buffer = (*cinfo->mem->access_virt_barray)
+      ((j_common_ptr) cinfo, coef->whole_image[ci],
+       cinfo->output_iMCU_row * compptr->v_samp_factor,
+       (JDIMENSION) compptr->v_samp_factor, FALSE);
+    /* Count non-dummy DCT block rows in this iMCU row. */
+    if (cinfo->output_iMCU_row < last_iMCU_row)
+      block_rows = compptr->v_samp_factor;
+    else {
+      /* NB: can't use last_row_height here; it is input-side-dependent! */
+      block_rows = (int) (compptr->height_in_blocks % compptr->v_samp_factor);
+      if (block_rows == 0) block_rows = compptr->v_samp_factor;
+    }
+    inverse_DCT = cinfo->idct->inverse_DCT[ci];
+    output_ptr = output_buf[ci];
+    /* Loop over all DCT blocks to be processed. */
+    for (block_row = 0; block_row < block_rows; block_row++) {
+      buffer_ptr = buffer[block_row];
+      output_col = 0;
+      for (block_num = 0; block_num < compptr->width_in_blocks; block_num++) {
+	(*inverse_DCT) (cinfo, compptr, (JCOEFPTR) buffer_ptr,
+			output_ptr, output_col);
+	buffer_ptr++;
+	output_col += compptr->DCT_scaled_size;
+      }
+      output_ptr += compptr->DCT_scaled_size;
+    }
+  }
+
+  if (++(cinfo->output_iMCU_row) < cinfo->total_iMCU_rows)
+    return JPEG_ROW_COMPLETED;
+  return JPEG_SCAN_COMPLETED;
+}
+
+#endif /* D_MULTISCAN_FILES_SUPPORTED */
+
+
+#ifdef BLOCK_SMOOTHING_SUPPORTED
+
+/*
+ * This code applies interblock smoothing as described by section K.8
+ * of the JPEG standard: the first 5 AC coefficients are estimated from
+ * the DC values of a DCT block and its 8 neighboring blocks.
+ * We apply smoothing only for progressive JPEG decoding, and only if
+ * the coefficients it can estimate are not yet known to full precision.
+ */
+
+/*
+ * Determine whether block smoothing is applicable and safe.
+ * We also latch the current states of the coef_bits[] entries for the
+ * AC coefficients; otherwise, if the input side of the decompressor
+ * advances into a new scan, we might think the coefficients are known
+ * more accurately than they really are.
+ */
+
+LOCAL boolean
+smoothing_ok (j_decompress_ptr cinfo)
+{
+  my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
+  boolean smoothing_useful = FALSE;
+  int ci, coefi;
+  jpeg_component_info *compptr;
+  JQUANT_TBL * qtable;
+  int * coef_bits;
+  int * coef_bits_latch;
+
+  if (! cinfo->progressive_mode || cinfo->coef_bits == NULL)
+    return FALSE;
+
+  /* Allocate latch area if not already done */
+  if (coef->coef_bits_latch == NULL)
+    coef->coef_bits_latch = (int *)
+      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				  cinfo->num_components *
+				  (SAVED_COEFS * SIZEOF(int)));
+  coef_bits_latch = coef->coef_bits_latch;
+
+  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+       ci++, compptr++) {
+    /* All components' quantization values must already be latched. */
+    if ((qtable = compptr->quant_table) == NULL)
+      return FALSE;
+    /* Verify DC & first 5 AC quantizers are nonzero to avoid zero-divide. */
+    for (coefi = 0; coefi <= 5; coefi++) {
+      if (qtable->quantval[coefi] == 0)
+	return FALSE;
+    }
+    /* DC values must be at least partly known for all components. */
+    coef_bits = cinfo->coef_bits[ci];
+    if (coef_bits[0] < 0)
+      return FALSE;
+    /* Block smoothing is helpful if some AC coefficients remain inaccurate. */
+    for (coefi = 1; coefi <= 5; coefi++) {
+      coef_bits_latch[coefi] = coef_bits[coefi];
+      if (coef_bits[coefi] != 0)
+	smoothing_useful = TRUE;
+    }
+    coef_bits_latch += SAVED_COEFS;
+  }
+
+  return smoothing_useful;
+}
+
+
+/*
+ * Variant of decompress_data for use when doing block smoothing.
+ */
+
+METHODDEF int
+decompress_smooth_data (j_decompress_ptr cinfo, JSAMPIMAGE output_buf)
+{
+  my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
+  JDIMENSION last_iMCU_row = cinfo->total_iMCU_rows - 1;
+  JDIMENSION block_num, last_block_column;
+  int ci, block_row, block_rows, access_rows;
+  JBLOCKARRAY buffer;
+  JBLOCKROW buffer_ptr, prev_block_row, next_block_row;
+  JSAMPARRAY output_ptr;
+  JDIMENSION output_col;
+  jpeg_component_info *compptr;
+  inverse_DCT_method_ptr inverse_DCT;
+  boolean first_row, last_row;
+  JBLOCK workspace;
+  int *coef_bits;
+  JQUANT_TBL *quanttbl;
+  INT32 Q00,Q01,Q02,Q10,Q11,Q20, num;
+  int DC1,DC2,DC3,DC4,DC5,DC6,DC7,DC8,DC9;
+  int Al, pred;
+
+  /* Force some input to be done if we are getting ahead of the input. */
+  while (cinfo->input_scan_number <= cinfo->output_scan_number &&
+	 ! cinfo->inputctl->eoi_reached) {
+    if (cinfo->input_scan_number == cinfo->output_scan_number) {
+      /* If input is working on current scan, we ordinarily want it to
+       * have completed the current row.  But if input scan is DC,
+       * we want it to keep one row ahead so that next block row's DC
+       * values are up to date.
+       */
+      JDIMENSION delta = (cinfo->Ss == 0) ? 1 : 0;
+      if (cinfo->input_iMCU_row > cinfo->output_iMCU_row+delta)
+	break;
+    }
+    if ((*cinfo->inputctl->consume_input)(cinfo) == JPEG_SUSPENDED)
+      return JPEG_SUSPENDED;
+  }
+
+  /* OK, output from the virtual arrays. */
+  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+       ci++, compptr++) {
+    /* Don't bother to IDCT an uninteresting component. */
+    if (! compptr->component_needed)
+      continue;
+    /* Count non-dummy DCT block rows in this iMCU row. */
+    if (cinfo->output_iMCU_row < last_iMCU_row) {
+      block_rows = compptr->v_samp_factor;
+      access_rows = block_rows * 2; /* this and next iMCU row */
+      last_row = FALSE;
+    } else {
+      /* NB: can't use last_row_height here; it is input-side-dependent! */
+      block_rows = (int) (compptr->height_in_blocks % compptr->v_samp_factor);
+      if (block_rows == 0) block_rows = compptr->v_samp_factor;
+      access_rows = block_rows; /* this iMCU row only */
+      last_row = TRUE;
+    }
+    /* Align the virtual buffer for this component. */
+    if (cinfo->output_iMCU_row > 0) {
+      access_rows += compptr->v_samp_factor; /* prior iMCU row too */
+      buffer = (*cinfo->mem->access_virt_barray)
+	((j_common_ptr) cinfo, coef->whole_image[ci],
+	 (cinfo->output_iMCU_row - 1) * compptr->v_samp_factor,
+	 (JDIMENSION) access_rows, FALSE);
+      buffer += compptr->v_samp_factor;	/* point to current iMCU row */
+      first_row = FALSE;
+    } else {
+      buffer = (*cinfo->mem->access_virt_barray)
+	((j_common_ptr) cinfo, coef->whole_image[ci],
+	 (JDIMENSION) 0, (JDIMENSION) access_rows, FALSE);
+      first_row = TRUE;
+    }
+    /* Fetch component-dependent info */
+    coef_bits = coef->coef_bits_latch + (ci * SAVED_COEFS);
+    quanttbl = compptr->quant_table;
+    Q00 = quanttbl->quantval[0];
+    Q01 = quanttbl->quantval[1];
+    Q10 = quanttbl->quantval[2];
+    Q20 = quanttbl->quantval[3];
+    Q11 = quanttbl->quantval[4];
+    Q02 = quanttbl->quantval[5];
+    inverse_DCT = cinfo->idct->inverse_DCT[ci];
+    output_ptr = output_buf[ci];
+    /* Loop over all DCT blocks to be processed. */
+    for (block_row = 0; block_row < block_rows; block_row++) {
+      buffer_ptr = buffer[block_row];
+      if (first_row && block_row == 0)
+	prev_block_row = buffer_ptr;
+      else
+	prev_block_row = buffer[block_row-1];
+      if (last_row && block_row == block_rows-1)
+	next_block_row = buffer_ptr;
+      else
+	next_block_row = buffer[block_row+1];
+      /* We fetch the surrounding DC values using a sliding-register approach.
+       * Initialize all nine here so as to do the right thing on narrow pics.
+       */
+      DC1 = DC2 = DC3 = (int) prev_block_row[0][0];
+      DC4 = DC5 = DC6 = (int) buffer_ptr[0][0];
+      DC7 = DC8 = DC9 = (int) next_block_row[0][0];
+      output_col = 0;
+      last_block_column = compptr->width_in_blocks - 1;
+      for (block_num = 0; block_num <= last_block_column; block_num++) {
+	/* Fetch current DCT block into workspace so we can modify it. */
+	jcopy_block_row(buffer_ptr, (JBLOCKROW) workspace, (JDIMENSION) 1);
+	/* Update DC values */
+	if (block_num < last_block_column) {
+	  DC3 = (int) prev_block_row[1][0];
+	  DC6 = (int) buffer_ptr[1][0];
+	  DC9 = (int) next_block_row[1][0];
+	}
+	/* Compute coefficient estimates per K.8.
+	 * An estimate is applied only if coefficient is still zero,
+	 * and is not known to be fully accurate.
+	 */
+	/* AC01 */
+	if ((Al=coef_bits[1]) != 0 && workspace[1] == 0) {
+	  num = 36 * Q00 * (DC4 - DC6);
+	  if (num >= 0) {
+	    pred = (int) (((Q01<<7) + num) / (Q01<<8));
+	    if (Al > 0 && pred >= (1<<Al))
+	      pred = (1<<Al)-1;
+	  } else {
+	    pred = (int) (((Q01<<7) - num) / (Q01<<8));
+	    if (Al > 0 && pred >= (1<<Al))
+	      pred = (1<<Al)-1;
+	    pred = -pred;
+	  }
+	  workspace[1] = (JCOEF) pred;
+	}
+	/* AC10 */
+	if ((Al=coef_bits[2]) != 0 && workspace[8] == 0) {
+	  num = 36 * Q00 * (DC2 - DC8);
+	  if (num >= 0) {
+	    pred = (int) (((Q10<<7) + num) / (Q10<<8));
+	    if (Al > 0 && pred >= (1<<Al))
+	      pred = (1<<Al)-1;
+	  } else {
+	    pred = (int) (((Q10<<7) - num) / (Q10<<8));
+	    if (Al > 0 && pred >= (1<<Al))
+	      pred = (1<<Al)-1;
+	    pred = -pred;
+	  }
+	  workspace[8] = (JCOEF) pred;
+	}
+	/* AC20 */
+	if ((Al=coef_bits[3]) != 0 && workspace[16] == 0) {
+	  num = 9 * Q00 * (DC2 + DC8 - 2*DC5);
+	  if (num >= 0) {
+	    pred = (int) (((Q20<<7) + num) / (Q20<<8));
+	    if (Al > 0 && pred >= (1<<Al))
+	      pred = (1<<Al)-1;
+	  } else {
+	    pred = (int) (((Q20<<7) - num) / (Q20<<8));
+	    if (Al > 0 && pred >= (1<<Al))
+	      pred = (1<<Al)-1;
+	    pred = -pred;
+	  }
+	  workspace[16] = (JCOEF) pred;
+	}
+	/* AC11 */
+	if ((Al=coef_bits[4]) != 0 && workspace[9] == 0) {
+	  num = 5 * Q00 * (DC1 - DC3 - DC7 + DC9);
+	  if (num >= 0) {
+	    pred = (int) (((Q11<<7) + num) / (Q11<<8));
+	    if (Al > 0 && pred >= (1<<Al))
+	      pred = (1<<Al)-1;
+	  } else {
+	    pred = (int) (((Q11<<7) - num) / (Q11<<8));
+	    if (Al > 0 && pred >= (1<<Al))
+	      pred = (1<<Al)-1;
+	    pred = -pred;
+	  }
+	  workspace[9] = (JCOEF) pred;
+	}
+	/* AC02 */
+	if ((Al=coef_bits[5]) != 0 && workspace[2] == 0) {
+	  num = 9 * Q00 * (DC4 + DC6 - 2*DC5);
+	  if (num >= 0) {
+	    pred = (int) (((Q02<<7) + num) / (Q02<<8));
+	    if (Al > 0 && pred >= (1<<Al))
+	      pred = (1<<Al)-1;
+	  } else {
+	    pred = (int) (((Q02<<7) - num) / (Q02<<8));
+	    if (Al > 0 && pred >= (1<<Al))
+	      pred = (1<<Al)-1;
+	    pred = -pred;
+	  }
+	  workspace[2] = (JCOEF) pred;
+	}
+	/* OK, do the IDCT */
+	(*inverse_DCT) (cinfo, compptr, (JCOEFPTR) workspace,
+			output_ptr, output_col);
+	/* Advance for next column */
+	DC1 = DC2; DC2 = DC3;
+	DC4 = DC5; DC5 = DC6;
+	DC7 = DC8; DC8 = DC9;
+	buffer_ptr++, prev_block_row++, next_block_row++;
+	output_col += compptr->DCT_scaled_size;
+      }
+      output_ptr += compptr->DCT_scaled_size;
+    }
+  }
+
+  if (++(cinfo->output_iMCU_row) < cinfo->total_iMCU_rows)
+    return JPEG_ROW_COMPLETED;
+  return JPEG_SCAN_COMPLETED;
+}
+
+#endif /* BLOCK_SMOOTHING_SUPPORTED */
+
+
+/*
+ * Initialize coefficient buffer controller.
+ */
+
+GLOBAL void
+jinit_d_coef_controller (j_decompress_ptr cinfo, boolean need_full_buffer)
+{
+  my_coef_ptr coef;
+
+  coef = (my_coef_ptr)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				SIZEOF(my_coef_controller));
+  cinfo->coef = (struct jpeg_d_coef_controller *) coef;
+  coef->pub.start_input_pass = start_input_pass;
+  coef->pub.start_output_pass = start_output_pass;
+#ifdef BLOCK_SMOOTHING_SUPPORTED
+  coef->coef_bits_latch = NULL;
+#endif
+
+  /* Create the coefficient buffer. */
+  if (need_full_buffer) {
+#ifdef D_MULTISCAN_FILES_SUPPORTED
+    /* Allocate a full-image virtual array for each component, */
+    /* padded to a multiple of samp_factor DCT blocks in each direction. */
+    /* Note we ask for a pre-zeroed array. */
+    int ci, access_rows;
+    jpeg_component_info *compptr;
+
+    for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+	 ci++, compptr++) {
+      access_rows = compptr->v_samp_factor;
+#ifdef BLOCK_SMOOTHING_SUPPORTED
+      /* If block smoothing could be used, need a bigger window */
+      if (cinfo->progressive_mode)
+	access_rows *= 3;
+#endif
+      coef->whole_image[ci] = (*cinfo->mem->request_virt_barray)
+	((j_common_ptr) cinfo, JPOOL_IMAGE, TRUE,
+	 (JDIMENSION) jround_up((long) compptr->width_in_blocks,
+				(long) compptr->h_samp_factor),
+	 (JDIMENSION) jround_up((long) compptr->height_in_blocks,
+				(long) compptr->v_samp_factor),
+	 (JDIMENSION) access_rows);
+    }
+    coef->pub.consume_data = consume_data;
+    coef->pub.decompress_data = decompress_data;
+    coef->pub.coef_arrays = coef->whole_image; /* link to virtual arrays */
+#else
+    ERREXIT(cinfo, JERR_NOT_COMPILED);
+#endif
+  } else {
+    /* We only need a single-MCU buffer. */
+    JBLOCKROW buffer;
+    int i;
+
+    buffer = (JBLOCKROW)
+      (*cinfo->mem->alloc_large) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				  D_MAX_BLOCKS_IN_MCU * SIZEOF(JBLOCK));
+    for (i = 0; i < D_MAX_BLOCKS_IN_MCU; i++) {
+      coef->MCU_buffer[i] = buffer + i;
+    }
+    coef->pub.consume_data = dummy_consume_data;
+    coef->pub.decompress_data = decompress_onepass;
+    coef->pub.coef_arrays = NULL; /* flag for no virtual arrays */
+  }
+}
diff --git a/codemp/jpeg-6/jdcolor.cpp b/codemp/jpeg-6/jdcolor.cpp
new file mode 100644
index 0000000..ef87ca3
--- /dev/null
+++ b/codemp/jpeg-6/jdcolor.cpp
@@ -0,0 +1,369 @@
+/*
+ * jdcolor.c
+ *
+ * Copyright (C) 1991-1995, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains output colorspace conversion routines.
+ */
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/* Private subobject */
+
+typedef struct {
+  struct jpeg_color_deconverter pub; /* public fields */
+
+  /* Private state for YCC->RGB conversion */
+  int * Cr_r_tab;		/* => table for Cr to R conversion */
+  int * Cb_b_tab;		/* => table for Cb to B conversion */
+  INT32 * Cr_g_tab;		/* => table for Cr to G conversion */
+  INT32 * Cb_g_tab;		/* => table for Cb to G conversion */
+} my_color_deconverter;
+
+typedef my_color_deconverter * my_cconvert_ptr;
+
+
+/**************** YCbCr -> RGB conversion: most common case **************/
+
+/*
+ * YCbCr is defined per CCIR 601-1, except that Cb and Cr are
+ * normalized to the range 0..MAXJSAMPLE rather than -0.5 .. 0.5.
+ * The conversion equations to be implemented are therefore
+ *	R = Y                + 1.40200 * Cr
+ *	G = Y - 0.34414 * Cb - 0.71414 * Cr
+ *	B = Y + 1.77200 * Cb
+ * where Cb and Cr represent the incoming values less CENTERJSAMPLE.
+ * (These numbers are derived from TIFF 6.0 section 21, dated 3-June-92.)
+ *
+ * To avoid floating-point arithmetic, we represent the fractional constants
+ * as integers scaled up by 2^16 (about 4 digits precision); we have to divide
+ * the products by 2^16, with appropriate rounding, to get the correct answer.
+ * Notice that Y, being an integral input, does not contribute any fraction
+ * so it need not participate in the rounding.
+ *
+ * For even more speed, we avoid doing any multiplications in the inner loop
+ * by precalculating the constants times Cb and Cr for all possible values.
+ * For 8-bit JSAMPLEs this is very reasonable (only 256 entries per table);
+ * for 12-bit samples it is still acceptable.  It's not very reasonable for
+ * 16-bit samples, but if you want lossless storage you shouldn't be changing
+ * colorspace anyway.
+ * The Cr=>R and Cb=>B values can be rounded to integers in advance; the
+ * values for the G calculation are left scaled up, since we must add them
+ * together before rounding.
+ */
+
+#define SCALEBITS	16	/* speediest right-shift on some machines */
+#define ONE_HALF	((INT32) 1 << (SCALEBITS-1))
+#define FIX(x)		((INT32) ((x) * (1L<<SCALEBITS) + 0.5))
+
+
+/*
+ * Initialize tables for YCC->RGB colorspace conversion.
+ */
+
+LOCAL void
+build_ycc_rgb_table (j_decompress_ptr cinfo)
+{
+  my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
+  int i;
+  INT32 x;
+  SHIFT_TEMPS
+
+  cconvert->Cr_r_tab = (int *)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				(MAXJSAMPLE+1) * SIZEOF(int));
+  cconvert->Cb_b_tab = (int *)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				(MAXJSAMPLE+1) * SIZEOF(int));
+  cconvert->Cr_g_tab = (INT32 *)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				(MAXJSAMPLE+1) * SIZEOF(INT32));
+  cconvert->Cb_g_tab = (INT32 *)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				(MAXJSAMPLE+1) * SIZEOF(INT32));
+
+  for (i = 0, x = -CENTERJSAMPLE; i <= MAXJSAMPLE; i++, x++) {
+    /* i is the actual input pixel value, in the range 0..MAXJSAMPLE */
+    /* The Cb or Cr value we are thinking of is x = i - CENTERJSAMPLE */
+    /* Cr=>R value is nearest int to 1.40200 * x */
+    cconvert->Cr_r_tab[i] = (int)
+		    RIGHT_SHIFT(FIX(1.40200) * x + ONE_HALF, SCALEBITS);
+    /* Cb=>B value is nearest int to 1.77200 * x */
+    cconvert->Cb_b_tab[i] = (int)
+		    RIGHT_SHIFT(FIX(1.77200) * x + ONE_HALF, SCALEBITS);
+    /* Cr=>G value is scaled-up -0.71414 * x */
+    cconvert->Cr_g_tab[i] = (- FIX(0.71414)) * x;
+    /* Cb=>G value is scaled-up -0.34414 * x */
+    /* We also add in ONE_HALF so that need not do it in inner loop */
+    cconvert->Cb_g_tab[i] = (- FIX(0.34414)) * x + ONE_HALF;
+  }
+}
+
+
+/*
+ * Convert some rows of samples to the output colorspace.
+ *
+ * Note that we change from noninterleaved, one-plane-per-component format
+ * to interleaved-pixel format.  The output buffer is therefore three times
+ * as wide as the input buffer.
+ * A starting row offset is provided only for the input buffer.  The caller
+ * can easily adjust the passed output_buf value to accommodate any row
+ * offset required on that side.
+ */
+
+METHODDEF void
+ycc_rgb_convert (j_decompress_ptr cinfo,
+		 JSAMPIMAGE input_buf, JDIMENSION input_row,
+		 JSAMPARRAY output_buf, int num_rows)
+{
+  my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
+  register int y, cb, cr;
+  register JSAMPROW outptr;
+  register JSAMPROW inptr0, inptr1, inptr2;
+  register JDIMENSION col;
+  JDIMENSION num_cols = cinfo->output_width;
+  /* copy these pointers into registers if possible */
+  register JSAMPLE * range_limit = cinfo->sample_range_limit;
+  register int * Crrtab = cconvert->Cr_r_tab;
+  register int * Cbbtab = cconvert->Cb_b_tab;
+  register INT32 * Crgtab = cconvert->Cr_g_tab;
+  register INT32 * Cbgtab = cconvert->Cb_g_tab;
+  SHIFT_TEMPS
+
+  while (--num_rows >= 0) {
+    inptr0 = input_buf[0][input_row];
+    inptr1 = input_buf[1][input_row];
+    inptr2 = input_buf[2][input_row];
+    input_row++;
+    outptr = *output_buf++;
+    for (col = 0; col < num_cols; col++) {
+      y  = GETJSAMPLE(inptr0[col]);
+      cb = GETJSAMPLE(inptr1[col]);
+      cr = GETJSAMPLE(inptr2[col]);
+      /* Range-limiting is essential due to noise introduced by DCT losses. */
+      outptr[RGB_RED] =   range_limit[y + Crrtab[cr]];
+      outptr[RGB_GREEN] = range_limit[y +
+			      ((int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],
+						 SCALEBITS))];
+      outptr[RGB_BLUE] =  range_limit[y + Cbbtab[cb]];
+      outptr += RGB_PIXELSIZE;
+    }
+  }
+}
+
+
+/**************** Cases other than YCbCr -> RGB **************/
+
+
+/*
+ * Color conversion for no colorspace change: just copy the data,
+ * converting from separate-planes to interleaved representation.
+ */
+
+METHODDEF void
+null_convert (j_decompress_ptr cinfo,
+	      JSAMPIMAGE input_buf, JDIMENSION input_row,
+	      JSAMPARRAY output_buf, int num_rows)
+{
+  register JSAMPROW inptr, outptr;
+  register JDIMENSION count;
+  register int num_components = cinfo->num_components;
+  JDIMENSION num_cols = cinfo->output_width;
+  int ci;
+
+  while (--num_rows >= 0) {
+    for (ci = 0; ci < num_components; ci++) {
+      inptr = input_buf[ci][input_row];
+      outptr = output_buf[0] + ci;
+      for (count = num_cols; count > 0; count--) {
+	*outptr = *inptr++;	/* needn't bother with GETJSAMPLE() here */
+	outptr += num_components;
+      }
+    }
+    input_row++;
+    output_buf++;
+  }
+}
+
+
+/*
+ * Color conversion for grayscale: just copy the data.
+ * This also works for YCbCr -> grayscale conversion, in which
+ * we just copy the Y (luminance) component and ignore chrominance.
+ */
+
+METHODDEF void
+grayscale_convert (j_decompress_ptr cinfo,
+		   JSAMPIMAGE input_buf, JDIMENSION input_row,
+		   JSAMPARRAY output_buf, int num_rows)
+{
+  jcopy_sample_rows(input_buf[0], (int) input_row, output_buf, 0,
+		    num_rows, cinfo->output_width);
+}
+
+
+/*
+ * Adobe-style YCCK->CMYK conversion.
+ * We convert YCbCr to R=1-C, G=1-M, and B=1-Y using the same
+ * conversion as above, while passing K (black) unchanged.
+ * We assume build_ycc_rgb_table has been called.
+ */
+
+METHODDEF void
+ycck_cmyk_convert (j_decompress_ptr cinfo,
+		   JSAMPIMAGE input_buf, JDIMENSION input_row,
+		   JSAMPARRAY output_buf, int num_rows)
+{
+  my_cconvert_ptr cconvert = (my_cconvert_ptr) cinfo->cconvert;
+  register int y, cb, cr;
+  register JSAMPROW outptr;
+  register JSAMPROW inptr0, inptr1, inptr2, inptr3;
+  register JDIMENSION col;
+  JDIMENSION num_cols = cinfo->output_width;
+  /* copy these pointers into registers if possible */
+  register JSAMPLE * range_limit = cinfo->sample_range_limit;
+  register int * Crrtab = cconvert->Cr_r_tab;
+  register int * Cbbtab = cconvert->Cb_b_tab;
+  register INT32 * Crgtab = cconvert->Cr_g_tab;
+  register INT32 * Cbgtab = cconvert->Cb_g_tab;
+  SHIFT_TEMPS
+
+  while (--num_rows >= 0) {
+    inptr0 = input_buf[0][input_row];
+    inptr1 = input_buf[1][input_row];
+    inptr2 = input_buf[2][input_row];
+    inptr3 = input_buf[3][input_row];
+    input_row++;
+    outptr = *output_buf++;
+    for (col = 0; col < num_cols; col++) {
+      y  = GETJSAMPLE(inptr0[col]);
+      cb = GETJSAMPLE(inptr1[col]);
+      cr = GETJSAMPLE(inptr2[col]);
+      /* Range-limiting is essential due to noise introduced by DCT losses. */
+      outptr[0] = range_limit[MAXJSAMPLE - (y + Crrtab[cr])];	/* red */
+      outptr[1] = range_limit[MAXJSAMPLE - (y +			/* green */
+			      ((int) RIGHT_SHIFT(Cbgtab[cb] + Crgtab[cr],
+						 SCALEBITS)))];
+      outptr[2] = range_limit[MAXJSAMPLE - (y + Cbbtab[cb])];	/* blue */
+      /* K passes through unchanged */
+      outptr[3] = inptr3[col];	/* don't need GETJSAMPLE here */
+      outptr += 4;
+    }
+  }
+}
+
+
+/*
+ * Empty method for start_pass.
+ */
+
+METHODDEF void
+start_pass_dcolor (j_decompress_ptr cinfo)
+{
+  /* no work needed */
+}
+
+
+/*
+ * Module initialization routine for output colorspace conversion.
+ */
+
+GLOBAL void
+jinit_color_deconverter (j_decompress_ptr cinfo)
+{
+  my_cconvert_ptr cconvert;
+  int ci;
+
+  cconvert = (my_cconvert_ptr)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				SIZEOF(my_color_deconverter));
+  cinfo->cconvert = (struct jpeg_color_deconverter *) cconvert;
+  cconvert->pub.start_pass = start_pass_dcolor;
+
+  /* Make sure num_components agrees with jpeg_color_space */
+  switch (cinfo->jpeg_color_space) {
+  case JCS_GRAYSCALE:
+    if (cinfo->num_components != 1)
+      ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
+    break;
+
+  case JCS_RGB:
+  case JCS_YCbCr:
+    if (cinfo->num_components != 3)
+      ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
+    break;
+
+  case JCS_CMYK:
+  case JCS_YCCK:
+    if (cinfo->num_components != 4)
+      ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
+    break;
+
+  default:			/* JCS_UNKNOWN can be anything */
+    if (cinfo->num_components < 1)
+      ERREXIT(cinfo, JERR_BAD_J_COLORSPACE);
+    break;
+  }
+
+  /* Set out_color_components and conversion method based on requested space.
+   * Also clear the component_needed flags for any unused components,
+   * so that earlier pipeline stages can avoid useless computation.
+   */
+
+  switch (cinfo->out_color_space) {
+  case JCS_GRAYSCALE:
+    cinfo->out_color_components = 1;
+    if (cinfo->jpeg_color_space == JCS_GRAYSCALE ||
+	cinfo->jpeg_color_space == JCS_YCbCr) {
+      cconvert->pub.color_convert = grayscale_convert;
+      /* For color->grayscale conversion, only the Y (0) component is needed */
+      for (ci = 1; ci < cinfo->num_components; ci++)
+	cinfo->comp_info[ci].component_needed = FALSE;
+    } else
+      ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
+    break;
+
+  case JCS_RGB:
+    cinfo->out_color_components = RGB_PIXELSIZE;
+    if (cinfo->jpeg_color_space == JCS_YCbCr) {
+      cconvert->pub.color_convert = ycc_rgb_convert;
+      build_ycc_rgb_table(cinfo);
+    } else if (cinfo->jpeg_color_space == JCS_RGB && RGB_PIXELSIZE == 3) {
+      cconvert->pub.color_convert = null_convert;
+    } else
+      ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
+    break;
+
+  case JCS_CMYK:
+    cinfo->out_color_components = 4;
+    if (cinfo->jpeg_color_space == JCS_YCCK) {
+      cconvert->pub.color_convert = ycck_cmyk_convert;
+      build_ycc_rgb_table(cinfo);
+    } else if (cinfo->jpeg_color_space == JCS_CMYK) {
+      cconvert->pub.color_convert = null_convert;
+    } else
+      ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
+    break;
+
+  default:
+    /* Permit null conversion to same output space */
+    if (cinfo->out_color_space == cinfo->jpeg_color_space) {
+      cinfo->out_color_components = cinfo->num_components;
+      cconvert->pub.color_convert = null_convert;
+    } else			/* unsupported non-null conversion */
+      ERREXIT(cinfo, JERR_CONVERSION_NOTIMPL);
+    break;
+  }
+
+  if (cinfo->quantize_colors)
+    cinfo->output_components = 1; /* single colormapped output component */
+  else
+    cinfo->output_components = cinfo->out_color_components;
+}
diff --git a/codemp/jpeg-6/jdct.h b/codemp/jpeg-6/jdct.h
new file mode 100644
index 0000000..1d66d4f
--- /dev/null
+++ b/codemp/jpeg-6/jdct.h
@@ -0,0 +1,176 @@
+/*
+ * jdct.h
+ *
+ * Copyright (C) 1994, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This include file contains common declarations for the forward and
+ * inverse DCT modules.  These declarations are private to the DCT managers
+ * (jcdctmgr.c, jddctmgr.c) and the individual DCT algorithms.
+ * The individual DCT algorithms are kept in separate files to ease 
+ * machine-dependent tuning (e.g., assembly coding).
+ */
+
+
+/*
+ * A forward DCT routine is given a pointer to a work area of type DCTELEM[];
+ * the DCT is to be performed in-place in that buffer.  Type DCTELEM is int
+ * for 8-bit samples, INT32 for 12-bit samples.  (NOTE: Floating-point DCT
+ * implementations use an array of type FAST_FLOAT, instead.)
+ * The DCT inputs are expected to be signed (range +-CENTERJSAMPLE).
+ * The DCT outputs are returned scaled up by a factor of 8; they therefore
+ * have a range of +-8K for 8-bit data, +-128K for 12-bit data.  This
+ * convention improves accuracy in integer implementations and saves some
+ * work in floating-point ones.
+ * Quantization of the output coefficients is done by jcdctmgr.c.
+ */
+
+#if BITS_IN_JSAMPLE == 8
+typedef int DCTELEM;		/* 16 or 32 bits is fine */
+#else
+typedef INT32 DCTELEM;		/* must have 32 bits */
+#endif
+
+typedef JMETHOD(void, forward_DCT_method_ptr, (DCTELEM * data));
+typedef JMETHOD(void, float_DCT_method_ptr, (FAST_FLOAT * data));
+
+
+/*
+ * An inverse DCT routine is given a pointer to the input JBLOCK and a pointer
+ * to an output sample array.  The routine must dequantize the input data as
+ * well as perform the IDCT; for dequantization, it uses the multiplier table
+ * pointed to by compptr->dct_table.  The output data is to be placed into the
+ * sample array starting at a specified column.  (Any row offset needed will
+ * be applied to the array pointer before it is passed to the IDCT code.)
+ * Note that the number of samples emitted by the IDCT routine is
+ * DCT_scaled_size * DCT_scaled_size.
+ */
+
+/* typedef inverse_DCT_method_ptr is declared in jpegint.h */
+
+/*
+ * Each IDCT routine has its own ideas about the best dct_table element type.
+ */
+
+typedef MULTIPLIER ISLOW_MULT_TYPE; /* short or int, whichever is faster */
+#if BITS_IN_JSAMPLE == 8
+typedef MULTIPLIER IFAST_MULT_TYPE; /* 16 bits is OK, use short if faster */
+#define IFAST_SCALE_BITS  2	/* fractional bits in scale factors */
+#else
+typedef INT32 IFAST_MULT_TYPE;	/* need 32 bits for scaled quantizers */
+#define IFAST_SCALE_BITS  13	/* fractional bits in scale factors */
+#endif
+typedef FAST_FLOAT FLOAT_MULT_TYPE; /* preferred floating type */
+
+
+/*
+ * Each IDCT routine is responsible for range-limiting its results and
+ * converting them to unsigned form (0..MAXJSAMPLE).  The raw outputs could
+ * be quite far out of range if the input data is corrupt, so a bulletproof
+ * range-limiting step is required.  We use a mask-and-table-lookup method
+ * to do the combined operations quickly.  See the comments with
+ * prepare_range_limit_table (in jdmaster.c) for more info.
+ */
+
+#define IDCT_range_limit(cinfo)  ((cinfo)->sample_range_limit + CENTERJSAMPLE)
+
+#define RANGE_MASK  (MAXJSAMPLE * 4 + 3) /* 2 bits wider than legal samples */
+
+
+/* Short forms of external names for systems with brain-damaged linkers. */
+
+#ifdef NEED_SHORT_EXTERNAL_NAMES
+#define jpeg_fdct_islow		jFDislow
+#define jpeg_fdct_ifast		jFDifast
+#define jpeg_fdct_float		jFDfloat
+#define jpeg_idct_islow		jRDislow
+#define jpeg_idct_ifast		jRDifast
+#define jpeg_idct_float		jRDfloat
+#define jpeg_idct_4x4		jRD4x4
+#define jpeg_idct_2x2		jRD2x2
+#define jpeg_idct_1x1		jRD1x1
+#endif /* NEED_SHORT_EXTERNAL_NAMES */
+
+/* Extern declarations for the forward and inverse DCT routines. */
+
+EXTERN void jpeg_fdct_islow JPP((DCTELEM * data));
+EXTERN void jpeg_fdct_ifast JPP((DCTELEM * data));
+EXTERN void jpeg_fdct_float JPP((FAST_FLOAT * data));
+
+EXTERN void jpeg_idct_islow
+    JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr,
+	 JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col));
+EXTERN void jpeg_idct_ifast
+    JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr,
+	 JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col));
+EXTERN void jpeg_idct_float
+    JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr,
+	 JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col));
+EXTERN void jpeg_idct_4x4
+    JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr,
+	 JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col));
+EXTERN void jpeg_idct_2x2
+    JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr,
+	 JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col));
+EXTERN void jpeg_idct_1x1
+    JPP((j_decompress_ptr cinfo, jpeg_component_info * compptr,
+	 JCOEFPTR coef_block, JSAMPARRAY output_buf, JDIMENSION output_col));
+
+
+/*
+ * Macros for handling fixed-point arithmetic; these are used by many
+ * but not all of the DCT/IDCT modules.
+ *
+ * All values are expected to be of type INT32.
+ * Fractional constants are scaled left by CONST_BITS bits.
+ * CONST_BITS is defined within each module using these macros,
+ * and may differ from one module to the next.
+ */
+
+#define ONE	((INT32) 1)
+#define CONST_SCALE (ONE << CONST_BITS)
+
+/* Convert a positive real constant to an integer scaled by CONST_SCALE.
+ * Caution: some C compilers fail to reduce "FIX(constant)" at compile time,
+ * thus causing a lot of useless floating-point operations at run time.
+ */
+
+#define FIX(x)	((INT32) ((x) * CONST_SCALE + 0.5))
+
+/* Descale and correctly round an INT32 value that's scaled by N bits.
+ * We assume RIGHT_SHIFT rounds towards minus infinity, so adding
+ * the fudge factor is correct for either sign of X.
+ */
+
+#define DESCALE(x,n)  RIGHT_SHIFT((x) + (ONE << ((n)-1)), n)
+
+/* Multiply an INT32 variable by an INT32 constant to yield an INT32 result.
+ * This macro is used only when the two inputs will actually be no more than
+ * 16 bits wide, so that a 16x16->32 bit multiply can be used instead of a
+ * full 32x32 multiply.  This provides a useful speedup on many machines.
+ * Unfortunately there is no way to specify a 16x16->32 multiply portably
+ * in C, but some C compilers will do the right thing if you provide the
+ * correct combination of casts.
+ */
+
+#ifdef SHORTxSHORT_32		/* may work if 'int' is 32 bits */
+#define MULTIPLY16C16(var,const)  (((INT16) (var)) * ((INT16) (const)))
+#endif
+#ifdef SHORTxLCONST_32		/* known to work with Microsoft C 6.0 */
+#define MULTIPLY16C16(var,const)  (((INT16) (var)) * ((INT32) (const)))
+#endif
+
+#ifndef MULTIPLY16C16		/* default definition */
+#define MULTIPLY16C16(var,const)  ((var) * (const))
+#endif
+
+/* Same except both inputs are variables. */
+
+#ifdef SHORTxSHORT_32		/* may work if 'int' is 32 bits */
+#define MULTIPLY16V16(var1,var2)  (((INT16) (var1)) * ((INT16) (var2)))
+#endif
+
+#ifndef MULTIPLY16V16		/* default definition */
+#define MULTIPLY16V16(var1,var2)  ((var1) * (var2))
+#endif
diff --git a/codemp/jpeg-6/jddctmgr.cpp b/codemp/jpeg-6/jddctmgr.cpp
new file mode 100644
index 0000000..c60b308
--- /dev/null
+++ b/codemp/jpeg-6/jddctmgr.cpp
@@ -0,0 +1,272 @@
+/*
+ * jddctmgr.c
+ *
+ * Copyright (C) 1994-1995, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains the inverse-DCT management logic.
+ * This code selects a particular IDCT implementation to be used,
+ * and it performs related housekeeping chores.  No code in this file
+ * is executed per IDCT step, only during output pass setup.
+ *
+ * Note that the IDCT routines are responsible for performing coefficient
+ * dequantization as well as the IDCT proper.  This module sets up the
+ * dequantization multiplier table needed by the IDCT routine.
+ */
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jdct.h"		/* Private declarations for DCT subsystem */
+
+
+/*
+ * The decompressor input side (jdinput.c) saves away the appropriate
+ * quantization table for each component at the start of the first scan
+ * involving that component.  (This is necessary in order to correctly
+ * decode files that reuse Q-table slots.)
+ * When we are ready to make an output pass, the saved Q-table is converted
+ * to a multiplier table that will actually be used by the IDCT routine.
+ * The multiplier table contents are IDCT-method-dependent.  To support
+ * application changes in IDCT method between scans, we can remake the
+ * multiplier tables if necessary.
+ * In buffered-image mode, the first output pass may occur before any data
+ * has been seen for some components, and thus before their Q-tables have
+ * been saved away.  To handle this case, multiplier tables are preset
+ * to zeroes; the result of the IDCT will be a neutral gray level.
+ */
+
+
+/* Private subobject for this module */
+
+typedef struct {
+  struct jpeg_inverse_dct pub;	/* public fields */
+
+  /* This array contains the IDCT method code that each multiplier table
+   * is currently set up for, or -1 if it's not yet set up.
+   * The actual multiplier tables are pointed to by dct_table in the
+   * per-component comp_info structures.
+   */
+  int cur_method[MAX_COMPONENTS];
+} my_idct_controller;
+
+typedef my_idct_controller * my_idct_ptr;
+
+
+/* Allocated multiplier tables: big enough for any supported variant */
+
+typedef union {
+  ISLOW_MULT_TYPE islow_array[DCTSIZE2];
+#ifdef DCT_IFAST_SUPPORTED
+  IFAST_MULT_TYPE ifast_array[DCTSIZE2];
+#endif
+#ifdef DCT_FLOAT_SUPPORTED
+  FLOAT_MULT_TYPE float_array[DCTSIZE2];
+#endif
+} multiplier_table;
+
+
+/* The current scaled-IDCT routines require ISLOW-style multiplier tables,
+ * so be sure to compile that code if either ISLOW or SCALING is requested.
+ */
+#ifdef DCT_ISLOW_SUPPORTED
+#define PROVIDE_ISLOW_TABLES
+#else
+#ifdef IDCT_SCALING_SUPPORTED
+#define PROVIDE_ISLOW_TABLES
+#endif
+#endif
+
+
+/*
+ * Prepare for an output pass.
+ * Here we select the proper IDCT routine for each component and build
+ * a matching multiplier table.
+ */
+
+METHODDEF void
+start_pass (j_decompress_ptr cinfo)
+{
+  my_idct_ptr idct = (my_idct_ptr) cinfo->idct;
+  int ci, i;
+  jpeg_component_info *compptr;
+  int method = 0;
+  inverse_DCT_method_ptr method_ptr = NULL;
+  JQUANT_TBL * qtbl;
+
+  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+       ci++, compptr++) {
+    /* Select the proper IDCT routine for this component's scaling */
+    switch (compptr->DCT_scaled_size) {
+#ifdef IDCT_SCALING_SUPPORTED
+    case 1:
+      method_ptr = jpeg_idct_1x1;
+      method = JDCT_ISLOW;	/* jidctred uses islow-style table */
+      break;
+    case 2:
+      method_ptr = jpeg_idct_2x2;
+      method = JDCT_ISLOW;	/* jidctred uses islow-style table */
+      break;
+    case 4:
+      method_ptr = jpeg_idct_4x4;
+      method = JDCT_ISLOW;	/* jidctred uses islow-style table */
+      break;
+#endif
+    case DCTSIZE:
+      switch (cinfo->dct_method) {
+#ifdef DCT_ISLOW_SUPPORTED
+      case JDCT_ISLOW:
+	method_ptr = jpeg_idct_islow;
+	method = JDCT_ISLOW;
+	break;
+#endif
+#ifdef DCT_IFAST_SUPPORTED
+      case JDCT_IFAST:
+	method_ptr = jpeg_idct_ifast;
+	method = JDCT_IFAST;
+	break;
+#endif
+#ifdef DCT_FLOAT_SUPPORTED
+      case JDCT_FLOAT:
+	method_ptr = jpeg_idct_float;
+	method = JDCT_FLOAT;
+	break;
+#endif
+      default:
+	ERREXIT(cinfo, JERR_NOT_COMPILED);
+	break;
+      }
+      break;
+    default:
+      ERREXIT1(cinfo, JERR_BAD_DCTSIZE, compptr->DCT_scaled_size);
+      break;
+    }
+    idct->pub.inverse_DCT[ci] = method_ptr;
+    /* Create multiplier table from quant table.
+     * However, we can skip this if the component is uninteresting
+     * or if we already built the table.  Also, if no quant table
+     * has yet been saved for the component, we leave the
+     * multiplier table all-zero; we'll be reading zeroes from the
+     * coefficient controller's buffer anyway.
+     */
+    if (! compptr->component_needed || idct->cur_method[ci] == method)
+      continue;
+    qtbl = compptr->quant_table;
+    if (qtbl == NULL)		/* happens if no data yet for component */
+      continue;
+    idct->cur_method[ci] = method;
+    switch (method) {
+#ifdef PROVIDE_ISLOW_TABLES
+    case JDCT_ISLOW:
+      {
+	/* For LL&M IDCT method, multipliers are equal to raw quantization
+	 * coefficients, but are stored in natural order as ints.
+	 */
+	ISLOW_MULT_TYPE * ismtbl = (ISLOW_MULT_TYPE *) compptr->dct_table;
+	for (i = 0; i < DCTSIZE2; i++) {
+	  ismtbl[i] = (ISLOW_MULT_TYPE) qtbl->quantval[jpeg_zigzag_order[i]];
+	}
+      }
+      break;
+#endif
+#ifdef DCT_IFAST_SUPPORTED
+    case JDCT_IFAST:
+      {
+	/* For AA&N IDCT method, multipliers are equal to quantization
+	 * coefficients scaled by scalefactor[row]*scalefactor[col], where
+	 *   scalefactor[0] = 1
+	 *   scalefactor[k] = cos(k*PI/16) * sqrt(2)    for k=1..7
+	 * For integer operation, the multiplier table is to be scaled by
+	 * IFAST_SCALE_BITS.  The multipliers are stored in natural order.
+	 */
+	IFAST_MULT_TYPE * ifmtbl = (IFAST_MULT_TYPE *) compptr->dct_table;
+#define CONST_BITS 14
+	static const INT16 aanscales[DCTSIZE2] = {
+	  /* precomputed values scaled up by 14 bits */
+	  16384, 22725, 21407, 19266, 16384, 12873,  8867,  4520,
+	  22725, 31521, 29692, 26722, 22725, 17855, 12299,  6270,
+	  21407, 29692, 27969, 25172, 21407, 16819, 11585,  5906,
+	  19266, 26722, 25172, 22654, 19266, 15137, 10426,  5315,
+	  16384, 22725, 21407, 19266, 16384, 12873,  8867,  4520,
+	  12873, 17855, 16819, 15137, 12873, 10114,  6967,  3552,
+	   8867, 12299, 11585, 10426,  8867,  6967,  4799,  2446,
+	   4520,  6270,  5906,  5315,  4520,  3552,  2446,  1247
+	};
+	SHIFT_TEMPS
+
+	for (i = 0; i < DCTSIZE2; i++) {
+	  ifmtbl[i] = (IFAST_MULT_TYPE)
+	    DESCALE(MULTIPLY16V16((INT32) qtbl->quantval[jpeg_zigzag_order[i]],
+				  (INT32) aanscales[i]),
+		    CONST_BITS-IFAST_SCALE_BITS);
+	}
+      }
+      break;
+#endif
+#ifdef DCT_FLOAT_SUPPORTED
+    case JDCT_FLOAT:
+      {
+	/* For float AA&N IDCT method, multipliers are equal to quantization
+	 * coefficients scaled by scalefactor[row]*scalefactor[col], where
+	 *   scalefactor[0] = 1
+	 *   scalefactor[k] = cos(k*PI/16) * sqrt(2)    for k=1..7
+	 * The multipliers are stored in natural order.
+	 */
+	FLOAT_MULT_TYPE * fmtbl = (FLOAT_MULT_TYPE *) compptr->dct_table;
+	int row, col;
+	static const double aanscalefactor[DCTSIZE] = {
+	  1.0, 1.387039845, 1.306562965, 1.175875602,
+	  1.0, 0.785694958, 0.541196100, 0.275899379
+	};
+
+	i = 0;
+	for (row = 0; row < DCTSIZE; row++) {
+	  for (col = 0; col < DCTSIZE; col++) {
+	    fmtbl[i] = (FLOAT_MULT_TYPE)
+	      ((double) qtbl->quantval[jpeg_zigzag_order[i]] *
+	       aanscalefactor[row] * aanscalefactor[col]);
+	    i++;
+	  }
+	}
+      }
+      break;
+#endif
+    default:
+      ERREXIT(cinfo, JERR_NOT_COMPILED);
+      break;
+    }
+  }
+}
+
+
+/*
+ * Initialize IDCT manager.
+ */
+
+GLOBAL void
+jinit_inverse_dct (j_decompress_ptr cinfo)
+{
+  my_idct_ptr idct;
+  int ci;
+  jpeg_component_info *compptr;
+
+  idct = (my_idct_ptr)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				SIZEOF(my_idct_controller));
+  cinfo->idct = (struct jpeg_inverse_dct *) idct;
+  idct->pub.start_pass = start_pass;
+
+  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+       ci++, compptr++) {
+    /* Allocate and pre-zero a multiplier table for each component */
+    compptr->dct_table =
+      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				  SIZEOF(multiplier_table));
+    MEMZERO(compptr->dct_table, SIZEOF(multiplier_table));
+    /* Mark multiplier table not yet set up for any method */
+    idct->cur_method[ci] = -1;
+  }
+}
diff --git a/codemp/jpeg-6/jdhuff.cpp b/codemp/jpeg-6/jdhuff.cpp
new file mode 100644
index 0000000..636be18
--- /dev/null
+++ b/codemp/jpeg-6/jdhuff.cpp
@@ -0,0 +1,576 @@
+/*
+ * jdhuff.c
+ *
+ * Copyright (C) 1991-1995, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains Huffman entropy decoding routines.
+ *
+ * Much of the complexity here has to do with supporting input suspension.
+ * If the data source module demands suspension, we want to be able to back
+ * up to the start of the current MCU.  To do this, we copy state variables
+ * into local working storage, and update them back to the permanent
+ * storage only upon successful completion of an MCU.
+ */
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jdhuff.h"		/* Declarations shared with jdphuff.c */
+
+
+/*
+ * Expanded entropy decoder object for Huffman decoding.
+ *
+ * The savable_state subrecord contains fields that change within an MCU,
+ * but must not be updated permanently until we complete the MCU.
+ */
+
+typedef struct {
+  int last_dc_val[MAX_COMPS_IN_SCAN]; /* last DC coef for each component */
+} savable_state;
+
+/* This macro is to work around compilers with missing or broken
+ * structure assignment.  You'll need to fix this code if you have
+ * such a compiler and you change MAX_COMPS_IN_SCAN.
+ */
+
+#ifndef NO_STRUCT_ASSIGN
+#define ASSIGN_STATE(dest,src)  ((dest) = (src))
+#else
+#if MAX_COMPS_IN_SCAN == 4
+#define ASSIGN_STATE(dest,src)  \
+	((dest).last_dc_val[0] = (src).last_dc_val[0], \
+	 (dest).last_dc_val[1] = (src).last_dc_val[1], \
+	 (dest).last_dc_val[2] = (src).last_dc_val[2], \
+	 (dest).last_dc_val[3] = (src).last_dc_val[3])
+#endif
+#endif
+
+
+typedef struct {
+  struct jpeg_entropy_decoder pub; /* public fields */
+
+  /* These fields are loaded into local variables at start of each MCU.
+   * In case of suspension, we exit WITHOUT updating them.
+   */
+  bitread_perm_state bitstate;	/* Bit buffer at start of MCU */
+  savable_state saved;		/* Other state at start of MCU */
+
+  /* These fields are NOT loaded into local working state. */
+  unsigned int restarts_to_go;	/* MCUs left in this restart interval */
+
+  /* Pointers to derived tables (these workspaces have image lifespan) */
+  d_derived_tbl * dc_derived_tbls[NUM_HUFF_TBLS];
+  d_derived_tbl * ac_derived_tbls[NUM_HUFF_TBLS];
+} huff_entropy_decoder;
+
+typedef huff_entropy_decoder * huff_entropy_ptr;
+
+
+/*
+ * Initialize for a Huffman-compressed scan.
+ */
+
+METHODDEF void
+start_pass_huff_decoder (j_decompress_ptr cinfo)
+{
+  huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
+  int ci, dctbl, actbl;
+  jpeg_component_info * compptr;
+
+  /* Check that the scan parameters Ss, Se, Ah/Al are OK for sequential JPEG.
+   * This ought to be an error condition, but we make it a warning because
+   * there are some baseline files out there with all zeroes in these bytes.
+   */
+  if (cinfo->Ss != 0 || cinfo->Se != DCTSIZE2-1 ||
+      cinfo->Ah != 0 || cinfo->Al != 0)
+    WARNMS(cinfo, JWRN_NOT_SEQUENTIAL);
+
+  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+    compptr = cinfo->cur_comp_info[ci];
+    dctbl = compptr->dc_tbl_no;
+    actbl = compptr->ac_tbl_no;
+    /* Make sure requested tables are present */
+    if (dctbl < 0 || dctbl >= NUM_HUFF_TBLS ||
+	cinfo->dc_huff_tbl_ptrs[dctbl] == NULL)
+      ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, dctbl);
+    if (actbl < 0 || actbl >= NUM_HUFF_TBLS ||
+	cinfo->ac_huff_tbl_ptrs[actbl] == NULL)
+      ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, actbl);
+    /* Compute derived values for Huffman tables */
+    /* We may do this more than once for a table, but it's not expensive */
+    jpeg_make_d_derived_tbl(cinfo, cinfo->dc_huff_tbl_ptrs[dctbl],
+			    & entropy->dc_derived_tbls[dctbl]);
+    jpeg_make_d_derived_tbl(cinfo, cinfo->ac_huff_tbl_ptrs[actbl],
+			    & entropy->ac_derived_tbls[actbl]);
+    /* Initialize DC predictions to 0 */
+    entropy->saved.last_dc_val[ci] = 0;
+  }
+
+  /* Initialize bitread state variables */
+  entropy->bitstate.bits_left = 0;
+  entropy->bitstate.get_buffer = 0; /* unnecessary, but keeps Purify quiet */
+  entropy->bitstate.printed_eod = FALSE;
+
+  /* Initialize restart counter */
+  entropy->restarts_to_go = cinfo->restart_interval;
+}
+
+
+/*
+ * Compute the derived values for a Huffman table.
+ * Note this is also used by jdphuff.c.
+ */
+
+GLOBAL void
+jpeg_make_d_derived_tbl (j_decompress_ptr cinfo, JHUFF_TBL * htbl,
+			 d_derived_tbl ** pdtbl)
+{
+  d_derived_tbl *dtbl;
+  int p, i, l, si;
+  int lookbits, ctr;
+  char huffsize[257];
+  unsigned int huffcode[257];
+  unsigned int code;
+
+  /* Allocate a workspace if we haven't already done so. */
+  if (*pdtbl == NULL)
+    *pdtbl = (d_derived_tbl *)
+      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				  SIZEOF(d_derived_tbl));
+  dtbl = *pdtbl;
+  dtbl->pub = htbl;		/* fill in back link */
+  
+  /* Figure C.1: make table of Huffman code length for each symbol */
+  /* Note that this is in code-length order. */
+
+  p = 0;
+  for (l = 1; l <= 16; l++) {
+    for (i = 1; i <= (int) htbl->bits[l]; i++)
+      huffsize[p++] = (char) l;
+  }
+  huffsize[p] = 0;
+  
+  /* Figure C.2: generate the codes themselves */
+  /* Note that this is in code-length order. */
+  
+  code = 0;
+  si = huffsize[0];
+  p = 0;
+  while (huffsize[p]) {
+    while (((int) huffsize[p]) == si) {
+      huffcode[p++] = code;
+      code++;
+    }
+    code <<= 1;
+    si++;
+  }
+
+  /* Figure F.15: generate decoding tables for bit-sequential decoding */
+
+  p = 0;
+  for (l = 1; l <= 16; l++) {
+    if (htbl->bits[l]) {
+      dtbl->valptr[l] = p; /* huffval[] index of 1st symbol of code length l */
+      dtbl->mincode[l] = huffcode[p]; /* minimum code of length l */
+      p += htbl->bits[l];
+      dtbl->maxcode[l] = huffcode[p-1]; /* maximum code of length l */
+    } else {
+      dtbl->maxcode[l] = -1;	/* -1 if no codes of this length */
+    }
+  }
+  dtbl->maxcode[17] = 0xFFFFFL; /* ensures jpeg_huff_decode terminates */
+
+  /* Compute lookahead tables to speed up decoding.
+   * First we set all the table entries to 0, indicating "too long";
+   * then we iterate through the Huffman codes that are short enough and
+   * fill in all the entries that correspond to bit sequences starting
+   * with that code.
+   */
+
+  MEMZERO(dtbl->look_nbits, SIZEOF(dtbl->look_nbits));
+
+  p = 0;
+  for (l = 1; l <= HUFF_LOOKAHEAD; l++) {
+    for (i = 1; i <= (int) htbl->bits[l]; i++, p++) {
+      /* l = current code's length, p = its index in huffcode[] & huffval[]. */
+      /* Generate left-justified code followed by all possible bit sequences */
+      lookbits = huffcode[p] << (HUFF_LOOKAHEAD-l);
+      for (ctr = 1 << (HUFF_LOOKAHEAD-l); ctr > 0; ctr--) {
+	dtbl->look_nbits[lookbits] = l;
+	dtbl->look_sym[lookbits] = htbl->huffval[p];
+	lookbits++;
+      }
+    }
+  }
+}
+
+
+/*
+ * Out-of-line code for bit fetching (shared with jdphuff.c).
+ * See jdhuff.h for info about usage.
+ * Note: current values of get_buffer and bits_left are passed as parameters,
+ * but are returned in the corresponding fields of the state struct.
+ *
+ * On most machines MIN_GET_BITS should be 25 to allow the full 32-bit width
+ * of get_buffer to be used.  (On machines with wider words, an even larger
+ * buffer could be used.)  However, on some machines 32-bit shifts are
+ * quite slow and take time proportional to the number of places shifted.
+ * (This is true with most PC compilers, for instance.)  In this case it may
+ * be a win to set MIN_GET_BITS to the minimum value of 15.  This reduces the
+ * average shift distance at the cost of more calls to jpeg_fill_bit_buffer.
+ */
+
+#ifdef SLOW_SHIFT_32
+#define MIN_GET_BITS  15	/* minimum allowable value */
+#else
+#define MIN_GET_BITS  (BIT_BUF_SIZE-7)
+#endif
+
+
+GLOBAL boolean
+jpeg_fill_bit_buffer (bitread_working_state * state,
+		      register bit_buf_type get_buffer, register int bits_left,
+		      int nbits)
+/* Load up the bit buffer to a depth of at least nbits */
+{
+  /* Copy heavily used state fields into locals (hopefully registers) */
+  register const JOCTET * next_input_byte = state->next_input_byte;
+  register size_t bytes_in_buffer = state->bytes_in_buffer;
+  register int c;
+
+  /* Attempt to load at least MIN_GET_BITS bits into get_buffer. */
+  /* (It is assumed that no request will be for more than that many bits.) */
+
+  while (bits_left < MIN_GET_BITS) {
+    /* Attempt to read a byte */
+    if (state->unread_marker != 0)
+      goto no_more_data;	/* can't advance past a marker */
+
+    if (bytes_in_buffer == 0) {
+      if (! (*state->cinfo->src->fill_input_buffer) (state->cinfo))
+	return FALSE;
+      next_input_byte = state->cinfo->src->next_input_byte;
+      bytes_in_buffer = state->cinfo->src->bytes_in_buffer;
+    }
+    bytes_in_buffer--;
+    c = GETJOCTET(*next_input_byte++);
+
+    /* If it's 0xFF, check and discard stuffed zero byte */
+    if (c == 0xFF) {
+      do {
+	if (bytes_in_buffer == 0) {
+	  if (! (*state->cinfo->src->fill_input_buffer) (state->cinfo))
+	    return FALSE;
+	  next_input_byte = state->cinfo->src->next_input_byte;
+	  bytes_in_buffer = state->cinfo->src->bytes_in_buffer;
+	}
+	bytes_in_buffer--;
+	c = GETJOCTET(*next_input_byte++);
+      } while (c == 0xFF);
+
+      if (c == 0) {
+	/* Found FF/00, which represents an FF data byte */
+	c = 0xFF;
+      } else {
+	/* Oops, it's actually a marker indicating end of compressed data. */
+	/* Better put it back for use later */
+	state->unread_marker = c;
+
+      no_more_data:
+	/* There should be enough bits still left in the data segment; */
+	/* if so, just break out of the outer while loop. */
+	if (bits_left >= nbits)
+	  break;
+	/* Uh-oh.  Report corrupted data to user and stuff zeroes into
+	 * the data stream, so that we can produce some kind of image.
+	 * Note that this code will be repeated for each byte demanded
+	 * for the rest of the segment.  We use a nonvolatile flag to ensure
+	 * that only one warning message appears.
+	 */
+	if (! *(state->printed_eod_ptr)) {
+	  WARNMS(state->cinfo, JWRN_HIT_MARKER);
+	  *(state->printed_eod_ptr) = TRUE;
+	}
+	c = 0;			/* insert a zero byte into bit buffer */
+      }
+    }
+
+    /* OK, load c into get_buffer */
+    get_buffer = (get_buffer << 8) | c;
+    bits_left += 8;
+  }
+
+  /* Unload the local registers */
+  state->next_input_byte = next_input_byte;
+  state->bytes_in_buffer = bytes_in_buffer;
+  state->get_buffer = get_buffer;
+  state->bits_left = bits_left;
+
+  return TRUE;
+}
+
+
+/*
+ * Out-of-line code for Huffman code decoding.
+ * See jdhuff.h for info about usage.
+ */
+
+GLOBAL int
+jpeg_huff_decode (bitread_working_state * state,
+		  register bit_buf_type get_buffer, register int bits_left,
+		  d_derived_tbl * htbl, int min_bits)
+{
+  register int l = min_bits;
+  register INT32 code;
+
+  /* HUFF_DECODE has determined that the code is at least min_bits */
+  /* bits long, so fetch that many bits in one swoop. */
+
+  CHECK_BIT_BUFFER(*state, l, return -1);
+  code = GET_BITS(l);
+
+  /* Collect the rest of the Huffman code one bit at a time. */
+  /* This is per Figure F.16 in the JPEG spec. */
+
+  while (code > htbl->maxcode[l]) {
+    code <<= 1;
+    CHECK_BIT_BUFFER(*state, 1, return -1);
+    code |= GET_BITS(1);
+    l++;
+  }
+
+  /* Unload the local registers */
+  state->get_buffer = get_buffer;
+  state->bits_left = bits_left;
+
+  /* With garbage input we may reach the sentinel value l = 17. */
+
+  if (l > 16) {
+    WARNMS(state->cinfo, JWRN_HUFF_BAD_CODE);
+    return 0;			/* fake a zero as the safest result */
+  }
+
+  return htbl->pub->huffval[ htbl->valptr[l] +
+			    ((int) (code - htbl->mincode[l])) ];
+}
+
+
+/*
+ * Figure F.12: extend sign bit.
+ * On some machines, a shift and add will be faster than a table lookup.
+ */
+
+#ifdef AVOID_TABLES
+
+#define HUFF_EXTEND(x,s)  ((x) < (1<<((s)-1)) ? (x) + (((-1)<<(s)) + 1) : (x))
+
+#else
+
+#define HUFF_EXTEND(x,s)  ((x) < extend_test[s] ? (x) + extend_offset[s] : (x))
+
+static const int extend_test[16] =   /* entry n is 2**(n-1) */
+  { 0, 0x0001, 0x0002, 0x0004, 0x0008, 0x0010, 0x0020, 0x0040, 0x0080,
+    0x0100, 0x0200, 0x0400, 0x0800, 0x1000, 0x2000, 0x4000 };
+
+static const int extend_offset[16] = /* entry n is (-1 << n) + 1 */
+  { 0, ((-1)<<1) + 1, ((-1)<<2) + 1, ((-1)<<3) + 1, ((-1)<<4) + 1,
+    ((-1)<<5) + 1, ((-1)<<6) + 1, ((-1)<<7) + 1, ((-1)<<8) + 1,
+    ((-1)<<9) + 1, ((-1)<<10) + 1, ((-1)<<11) + 1, ((-1)<<12) + 1,
+    ((-1)<<13) + 1, ((-1)<<14) + 1, ((-1)<<15) + 1 };
+
+#endif /* AVOID_TABLES */
+
+
+/*
+ * Check for a restart marker & resynchronize decoder.
+ * Returns FALSE if must suspend.
+ */
+
+LOCAL boolean
+process_restart (j_decompress_ptr cinfo)
+{
+  huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
+  int ci;
+
+  /* Throw away any unused bits remaining in bit buffer; */
+  /* include any full bytes in next_marker's count of discarded bytes */
+  cinfo->marker->discarded_bytes += entropy->bitstate.bits_left / 8;
+  entropy->bitstate.bits_left = 0;
+
+  /* Advance past the RSTn marker */
+  if (! (*cinfo->marker->read_restart_marker) (cinfo))
+    return FALSE;
+
+  /* Re-initialize DC predictions to 0 */
+  for (ci = 0; ci < cinfo->comps_in_scan; ci++)
+    entropy->saved.last_dc_val[ci] = 0;
+
+  /* Reset restart counter */
+  entropy->restarts_to_go = cinfo->restart_interval;
+
+  /* Next segment can get another out-of-data warning */
+  entropy->bitstate.printed_eod = FALSE;
+
+  return TRUE;
+}
+
+
+/*
+ * Decode and return one MCU's worth of Huffman-compressed coefficients.
+ * The coefficients are reordered from zigzag order into natural array order,
+ * but are not dequantized.
+ *
+ * The i'th block of the MCU is stored into the block pointed to by
+ * MCU_data[i].  WE ASSUME THIS AREA HAS BEEN ZEROED BY THE CALLER.
+ * (Wholesale zeroing is usually a little faster than retail...)
+ *
+ * Returns FALSE if data source requested suspension.  In that case no
+ * changes have been made to permanent state.  (Exception: some output
+ * coefficients may already have been assigned.  This is harmless for
+ * this module, since we'll just re-assign them on the next call.)
+ */
+
+METHODDEF boolean
+decode_mcu (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
+{
+  huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
+  register int s, k, r;
+  int blkn, ci;
+  JBLOCKROW block;
+  BITREAD_STATE_VARS;
+  savable_state state;
+  d_derived_tbl * dctbl;
+  d_derived_tbl * actbl;
+  jpeg_component_info * compptr;
+
+  /* Process restart marker if needed; may have to suspend */
+  if (cinfo->restart_interval) {
+    if (entropy->restarts_to_go == 0)
+      if (! process_restart(cinfo))
+	return FALSE;
+  }
+
+  /* Load up working state */
+  BITREAD_LOAD_STATE(cinfo,entropy->bitstate);
+  ASSIGN_STATE(state, entropy->saved);
+
+  /* Outer loop handles each block in the MCU */
+
+  for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
+    block = MCU_data[blkn];
+    ci = cinfo->MCU_membership[blkn];
+    compptr = cinfo->cur_comp_info[ci];
+    dctbl = entropy->dc_derived_tbls[compptr->dc_tbl_no];
+    actbl = entropy->ac_derived_tbls[compptr->ac_tbl_no];
+
+    /* Decode a single block's worth of coefficients */
+
+    /* Section F.2.2.1: decode the DC coefficient difference */
+    HUFF_DECODE(s, br_state, dctbl, return FALSE, label1);
+    if (s) {
+      CHECK_BIT_BUFFER(br_state, s, return FALSE);
+      r = GET_BITS(s);
+      s = HUFF_EXTEND(r, s);
+    }
+
+    /* Shortcut if component's values are not interesting */
+    if (! compptr->component_needed)
+      goto skip_ACs;
+
+    /* Convert DC difference to actual value, update last_dc_val */
+    s += state.last_dc_val[ci];
+    state.last_dc_val[ci] = s;
+    /* Output the DC coefficient (assumes jpeg_natural_order[0] = 0) */
+    (*block)[0] = (JCOEF) s;
+
+    /* Do we need to decode the AC coefficients for this component? */
+    if (compptr->DCT_scaled_size > 1) {
+
+      /* Section F.2.2.2: decode the AC coefficients */
+      /* Since zeroes are skipped, output area must be cleared beforehand */
+      for (k = 1; k < DCTSIZE2; k++) {
+	HUFF_DECODE(s, br_state, actbl, return FALSE, label2);
+      
+	r = s >> 4;
+	s &= 15;
+      
+	if (s) {
+	  k += r;
+	  CHECK_BIT_BUFFER(br_state, s, return FALSE);
+	  r = GET_BITS(s);
+	  s = HUFF_EXTEND(r, s);
+	  /* Output coefficient in natural (dezigzagged) order.
+	   * Note: the extra entries in jpeg_natural_order[] will save us
+	   * if k >= DCTSIZE2, which could happen if the data is corrupted.
+	   */
+	  (*block)[jpeg_natural_order[k]] = (JCOEF) s;
+	} else {
+	  if (r != 15)
+	    break;
+	  k += 15;
+	}
+      }
+
+    } else {
+skip_ACs:
+
+      /* Section F.2.2.2: decode the AC coefficients */
+      /* In this path we just discard the values */
+      for (k = 1; k < DCTSIZE2; k++) {
+	HUFF_DECODE(s, br_state, actbl, return FALSE, label3);
+      
+	r = s >> 4;
+	s &= 15;
+      
+	if (s) {
+	  k += r;
+	  CHECK_BIT_BUFFER(br_state, s, return FALSE);
+	  DROP_BITS(s);
+	} else {
+	  if (r != 15)
+	    break;
+	  k += 15;
+	}
+      }
+
+    }
+  }
+
+  /* Completed MCU, so update state */
+  BITREAD_SAVE_STATE(cinfo,entropy->bitstate);
+  ASSIGN_STATE(entropy->saved, state);
+
+  /* Account for restart interval (no-op if not using restarts) */
+  entropy->restarts_to_go--;
+
+  return TRUE;
+}
+
+
+/*
+ * Module initialization routine for Huffman entropy decoding.
+ */
+
+GLOBAL void
+jinit_huff_decoder (j_decompress_ptr cinfo)
+{
+  huff_entropy_ptr entropy;
+  int i;
+
+  entropy = (huff_entropy_ptr)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				SIZEOF(huff_entropy_decoder));
+  cinfo->entropy = (struct jpeg_entropy_decoder *) entropy;
+  entropy->pub.start_pass = start_pass_huff_decoder;
+  entropy->pub.decode_mcu = decode_mcu;
+
+  /* Mark tables unallocated */
+  for (i = 0; i < NUM_HUFF_TBLS; i++) {
+    entropy->dc_derived_tbls[i] = entropy->ac_derived_tbls[i] = NULL;
+  }
+}
diff --git a/codemp/jpeg-6/jdhuff.h b/codemp/jpeg-6/jdhuff.h
new file mode 100644
index 0000000..65f3054
--- /dev/null
+++ b/codemp/jpeg-6/jdhuff.h
@@ -0,0 +1,202 @@
+/*
+ * jdhuff.h
+ *
+ * Copyright (C) 1991-1995, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains declarations for Huffman entropy decoding routines
+ * that are shared between the sequential decoder (jdhuff.c) and the
+ * progressive decoder (jdphuff.c).  No other modules need to see these.
+ */
+
+/* Short forms of external names for systems with brain-damaged linkers. */
+
+#ifdef NEED_SHORT_EXTERNAL_NAMES
+#define jpeg_make_d_derived_tbl	jMkDDerived
+#define jpeg_fill_bit_buffer	jFilBitBuf
+#define jpeg_huff_decode	jHufDecode
+#endif /* NEED_SHORT_EXTERNAL_NAMES */
+
+
+/* Derived data constructed for each Huffman table */
+
+#define HUFF_LOOKAHEAD	8	/* # of bits of lookahead */
+
+typedef struct {
+  /* Basic tables: (element [0] of each array is unused) */
+  INT32 mincode[17];		/* smallest code of length k */
+  INT32 maxcode[18];		/* largest code of length k (-1 if none) */
+  /* (maxcode[17] is a sentinel to ensure jpeg_huff_decode terminates) */
+  int valptr[17];		/* huffval[] index of 1st symbol of length k */
+
+  /* Link to public Huffman table (needed only in jpeg_huff_decode) */
+  JHUFF_TBL *pub;
+
+  /* Lookahead tables: indexed by the next HUFF_LOOKAHEAD bits of
+   * the input data stream.  If the next Huffman code is no more
+   * than HUFF_LOOKAHEAD bits long, we can obtain its length and
+   * the corresponding symbol directly from these tables.
+   */
+  int look_nbits[1<<HUFF_LOOKAHEAD]; /* # bits, or 0 if too long */
+  UINT8 look_sym[1<<HUFF_LOOKAHEAD]; /* symbol, or unused */
+} d_derived_tbl;
+
+/* Expand a Huffman table definition into the derived format */
+EXTERN void jpeg_make_d_derived_tbl JPP((j_decompress_ptr cinfo,
+				JHUFF_TBL * htbl, d_derived_tbl ** pdtbl));
+
+
+/*
+ * Fetching the next N bits from the input stream is a time-critical operation
+ * for the Huffman decoders.  We implement it with a combination of inline
+ * macros and out-of-line subroutines.  Note that N (the number of bits
+ * demanded at one time) never exceeds 15 for JPEG use.
+ *
+ * We read source bytes into get_buffer and dole out bits as needed.
+ * If get_buffer already contains enough bits, they are fetched in-line
+ * by the macros CHECK_BIT_BUFFER and GET_BITS.  When there aren't enough
+ * bits, jpeg_fill_bit_buffer is called; it will attempt to fill get_buffer
+ * as full as possible (not just to the number of bits needed; this
+ * prefetching reduces the overhead cost of calling jpeg_fill_bit_buffer).
+ * Note that jpeg_fill_bit_buffer may return FALSE to indicate suspension.
+ * On TRUE return, jpeg_fill_bit_buffer guarantees that get_buffer contains
+ * at least the requested number of bits --- dummy zeroes are inserted if
+ * necessary.
+ */
+
+typedef INT32 bit_buf_type;	/* type of bit-extraction buffer */
+#define BIT_BUF_SIZE  32	/* size of buffer in bits */
+
+/* If long is > 32 bits on your machine, and shifting/masking longs is
+ * reasonably fast, making bit_buf_type be long and setting BIT_BUF_SIZE
+ * appropriately should be a win.  Unfortunately we can't do this with
+ * something like  #define BIT_BUF_SIZE (sizeof(bit_buf_type)*8)
+ * because not all machines measure sizeof in 8-bit bytes.
+ */
+
+typedef struct {		/* Bitreading state saved across MCUs */
+  bit_buf_type get_buffer;	/* current bit-extraction buffer */
+  int bits_left;		/* # of unused bits in it */
+  boolean printed_eod;		/* flag to suppress multiple warning msgs */
+} bitread_perm_state;
+
+typedef struct {		/* Bitreading working state within an MCU */
+  /* current data source state */
+  const JOCTET * next_input_byte; /* => next byte to read from source */
+  size_t bytes_in_buffer;	/* # of bytes remaining in source buffer */
+  int unread_marker;		/* nonzero if we have hit a marker */
+  /* bit input buffer --- note these values are kept in register variables,
+   * not in this struct, inside the inner loops.
+   */
+  bit_buf_type get_buffer;	/* current bit-extraction buffer */
+  int bits_left;		/* # of unused bits in it */
+  /* pointers needed by jpeg_fill_bit_buffer */
+  j_decompress_ptr cinfo;	/* back link to decompress master record */
+  boolean * printed_eod_ptr;	/* => flag in permanent state */
+} bitread_working_state;
+
+/* Macros to declare and load/save bitread local variables. */
+#define BITREAD_STATE_VARS  \
+	register bit_buf_type get_buffer;  \
+	register int bits_left;  \
+	bitread_working_state br_state
+
+#define BITREAD_LOAD_STATE(cinfop,permstate)  \
+	br_state.cinfo = cinfop; \
+	br_state.next_input_byte = cinfop->src->next_input_byte; \
+	br_state.bytes_in_buffer = cinfop->src->bytes_in_buffer; \
+	br_state.unread_marker = cinfop->unread_marker; \
+	get_buffer = permstate.get_buffer; \
+	bits_left = permstate.bits_left; \
+	br_state.printed_eod_ptr = & permstate.printed_eod
+
+#define BITREAD_SAVE_STATE(cinfop,permstate)  \
+	cinfop->src->next_input_byte = br_state.next_input_byte; \
+	cinfop->src->bytes_in_buffer = br_state.bytes_in_buffer; \
+	cinfop->unread_marker = br_state.unread_marker; \
+	permstate.get_buffer = get_buffer; \
+	permstate.bits_left = bits_left
+
+/*
+ * These macros provide the in-line portion of bit fetching.
+ * Use CHECK_BIT_BUFFER to ensure there are N bits in get_buffer
+ * before using GET_BITS, PEEK_BITS, or DROP_BITS.
+ * The variables get_buffer and bits_left are assumed to be locals,
+ * but the state struct might not be (jpeg_huff_decode needs this).
+ *	CHECK_BIT_BUFFER(state,n,action);
+ *		Ensure there are N bits in get_buffer; if suspend, take action.
+ *      val = GET_BITS(n);
+ *		Fetch next N bits.
+ *      val = PEEK_BITS(n);
+ *		Fetch next N bits without removing them from the buffer.
+ *	DROP_BITS(n);
+ *		Discard next N bits.
+ * The value N should be a simple variable, not an expression, because it
+ * is evaluated multiple times.
+ */
+
+#define CHECK_BIT_BUFFER(state,nbits,action) \
+	{ if (bits_left < (nbits)) {  \
+	    if (! jpeg_fill_bit_buffer(&(state),get_buffer,bits_left,nbits))  \
+	      { action; }  \
+	    get_buffer = (state).get_buffer; bits_left = (state).bits_left; } }
+
+#define GET_BITS(nbits) \
+	(((int) (get_buffer >> (bits_left -= (nbits)))) & ((1<<(nbits))-1))
+
+#define PEEK_BITS(nbits) \
+	(((int) (get_buffer >> (bits_left -  (nbits)))) & ((1<<(nbits))-1))
+
+#define DROP_BITS(nbits) \
+	(bits_left -= (nbits))
+
+/* Load up the bit buffer to a depth of at least nbits */
+EXTERN boolean jpeg_fill_bit_buffer JPP((bitread_working_state * state,
+		register bit_buf_type get_buffer, register int bits_left,
+		int nbits));
+
+
+/*
+ * Code for extracting next Huffman-coded symbol from input bit stream.
+ * Again, this is time-critical and we make the main paths be macros.
+ *
+ * We use a lookahead table to process codes of up to HUFF_LOOKAHEAD bits
+ * without looping.  Usually, more than 95% of the Huffman codes will be 8
+ * or fewer bits long.  The few overlength codes are handled with a loop,
+ * which need not be inline code.
+ *
+ * Notes about the HUFF_DECODE macro:
+ * 1. Near the end of the data segment, we may fail to get enough bits
+ *    for a lookahead.  In that case, we do it the hard way.
+ * 2. If the lookahead table contains no entry, the next code must be
+ *    more than HUFF_LOOKAHEAD bits long.
+ * 3. jpeg_huff_decode returns -1 if forced to suspend.
+ */
+
+#define HUFF_DECODE(result,state,htbl,failaction,slowlabel) \
+{ register int nb, look; \
+  if (bits_left < HUFF_LOOKAHEAD) { \
+    if (! jpeg_fill_bit_buffer(&state,get_buffer,bits_left, 0)) {failaction;} \
+    get_buffer = state.get_buffer; bits_left = state.bits_left; \
+    if (bits_left < HUFF_LOOKAHEAD) { \
+      nb = 1; goto slowlabel; \
+    } \
+  } \
+  look = PEEK_BITS(HUFF_LOOKAHEAD); \
+  if ((nb = htbl->look_nbits[look]) != 0) { \
+    DROP_BITS(nb); \
+    result = htbl->look_sym[look]; \
+  } else { \
+    nb = HUFF_LOOKAHEAD+1; \
+slowlabel: \
+    if ((result=jpeg_huff_decode(&state,get_buffer,bits_left,htbl,nb)) < 0) \
+	{ failaction; } \
+    get_buffer = state.get_buffer; bits_left = state.bits_left; \
+  } \
+}
+
+/* Out-of-line case for Huffman code fetching */
+EXTERN int jpeg_huff_decode JPP((bitread_working_state * state,
+		register bit_buf_type get_buffer, register int bits_left,
+		d_derived_tbl * htbl, int min_bits));
diff --git a/codemp/jpeg-6/jdinput.cpp b/codemp/jpeg-6/jdinput.cpp
new file mode 100644
index 0000000..5ec70b8
--- /dev/null
+++ b/codemp/jpeg-6/jdinput.cpp
@@ -0,0 +1,383 @@
+/*
+ * jdinput.c
+ *
+ * Copyright (C) 1991-1995, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains input control logic for the JPEG decompressor.
+ * These routines are concerned with controlling the decompressor's input
+ * processing (marker reading and coefficient decoding).  The actual input
+ * reading is done in jdmarker.c, jdhuff.c, and jdphuff.c.
+ */
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/* Private state */
+
+typedef struct {
+  struct jpeg_input_controller pub; /* public fields */
+
+  boolean inheaders;		/* TRUE until first SOS is reached */
+} my_input_controller;
+
+typedef my_input_controller * my_inputctl_ptr;
+
+
+/* Forward declarations */
+METHODDEF int consume_markers JPP((j_decompress_ptr cinfo));
+
+
+/*
+ * Routines to calculate various quantities related to the size of the image.
+ */
+
+LOCAL void
+initial_setup (j_decompress_ptr cinfo)
+/* Called once, when first SOS marker is reached */
+{
+  int ci;
+  jpeg_component_info *compptr;
+
+  /* Make sure image isn't bigger than I can handle */
+  if ((long) cinfo->image_height > (long) JPEG_MAX_DIMENSION ||
+      (long) cinfo->image_width > (long) JPEG_MAX_DIMENSION)
+    ERREXIT1(cinfo, JERR_IMAGE_TOO_BIG, (unsigned int) JPEG_MAX_DIMENSION);
+
+  /* For now, precision must match compiled-in value... */
+  if (cinfo->data_precision != BITS_IN_JSAMPLE)
+    ERREXIT1(cinfo, JERR_BAD_PRECISION, cinfo->data_precision);
+
+  /* Check that number of components won't exceed internal array sizes */
+  if (cinfo->num_components > MAX_COMPONENTS)
+    ERREXIT2(cinfo, JERR_COMPONENT_COUNT, cinfo->num_components,
+	     MAX_COMPONENTS);
+
+  /* Compute maximum sampling factors; check factor validity */
+  cinfo->max_h_samp_factor = 1;
+  cinfo->max_v_samp_factor = 1;
+  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+       ci++, compptr++) {
+    if (compptr->h_samp_factor<=0 || compptr->h_samp_factor>MAX_SAMP_FACTOR ||
+	compptr->v_samp_factor<=0 || compptr->v_samp_factor>MAX_SAMP_FACTOR)
+      ERREXIT(cinfo, JERR_BAD_SAMPLING);
+    cinfo->max_h_samp_factor = MAX(cinfo->max_h_samp_factor,
+				   compptr->h_samp_factor);
+    cinfo->max_v_samp_factor = MAX(cinfo->max_v_samp_factor,
+				   compptr->v_samp_factor);
+  }
+
+  /* We initialize DCT_scaled_size and min_DCT_scaled_size to DCTSIZE.
+   * In the full decompressor, this will be overridden by jdmaster.c;
+   * but in the transcoder, jdmaster.c is not used, so we must do it here.
+   */
+  cinfo->min_DCT_scaled_size = DCTSIZE;
+
+  /* Compute dimensions of components */
+  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+       ci++, compptr++) {
+    compptr->DCT_scaled_size = DCTSIZE;
+    /* Size in DCT blocks */
+    compptr->width_in_blocks = (JDIMENSION)
+      jdiv_round_up((long) cinfo->image_width * (long) compptr->h_samp_factor,
+		    (long) (cinfo->max_h_samp_factor * DCTSIZE));
+    compptr->height_in_blocks = (JDIMENSION)
+      jdiv_round_up((long) cinfo->image_height * (long) compptr->v_samp_factor,
+		    (long) (cinfo->max_v_samp_factor * DCTSIZE));
+    /* downsampled_width and downsampled_height will also be overridden by
+     * jdmaster.c if we are doing full decompression.  The transcoder library
+     * doesn't use these values, but the calling application might.
+     */
+    /* Size in samples */
+    compptr->downsampled_width = (JDIMENSION)
+      jdiv_round_up((long) cinfo->image_width * (long) compptr->h_samp_factor,
+		    (long) cinfo->max_h_samp_factor);
+    compptr->downsampled_height = (JDIMENSION)
+      jdiv_round_up((long) cinfo->image_height * (long) compptr->v_samp_factor,
+		    (long) cinfo->max_v_samp_factor);
+    /* Mark component needed, until color conversion says otherwise */
+    compptr->component_needed = TRUE;
+    /* Mark no quantization table yet saved for component */
+    compptr->quant_table = NULL;
+  }
+
+  /* Compute number of fully interleaved MCU rows. */
+  cinfo->total_iMCU_rows = (JDIMENSION)
+    jdiv_round_up((long) cinfo->image_height,
+		  (long) (cinfo->max_v_samp_factor*DCTSIZE));
+
+  /* Decide whether file contains multiple scans */
+  if (cinfo->comps_in_scan < cinfo->num_components || cinfo->progressive_mode)
+    cinfo->inputctl->has_multiple_scans = TRUE;
+  else
+    cinfo->inputctl->has_multiple_scans = FALSE;
+}
+
+
+LOCAL void
+per_scan_setup (j_decompress_ptr cinfo)
+/* Do computations that are needed before processing a JPEG scan */
+/* cinfo->comps_in_scan and cinfo->cur_comp_info[] were set from SOS marker */
+{
+  int ci, mcublks, tmp;
+  jpeg_component_info *compptr;
+  
+  if (cinfo->comps_in_scan == 1) {
+    
+    /* Noninterleaved (single-component) scan */
+    compptr = cinfo->cur_comp_info[0];
+    
+    /* Overall image size in MCUs */
+    cinfo->MCUs_per_row = compptr->width_in_blocks;
+    cinfo->MCU_rows_in_scan = compptr->height_in_blocks;
+    
+    /* For noninterleaved scan, always one block per MCU */
+    compptr->MCU_width = 1;
+    compptr->MCU_height = 1;
+    compptr->MCU_blocks = 1;
+    compptr->MCU_sample_width = compptr->DCT_scaled_size;
+    compptr->last_col_width = 1;
+    /* For noninterleaved scans, it is convenient to define last_row_height
+     * as the number of block rows present in the last iMCU row.
+     */
+    tmp = (int) (compptr->height_in_blocks % compptr->v_samp_factor);
+    if (tmp == 0) tmp = compptr->v_samp_factor;
+    compptr->last_row_height = tmp;
+    
+    /* Prepare array describing MCU composition */
+    cinfo->blocks_in_MCU = 1;
+    cinfo->MCU_membership[0] = 0;
+    
+  } else {
+    
+    /* Interleaved (multi-component) scan */
+    if (cinfo->comps_in_scan <= 0 || cinfo->comps_in_scan > MAX_COMPS_IN_SCAN)
+      ERREXIT2(cinfo, JERR_COMPONENT_COUNT, cinfo->comps_in_scan,
+	       MAX_COMPS_IN_SCAN);
+    
+    /* Overall image size in MCUs */
+    cinfo->MCUs_per_row = (JDIMENSION)
+      jdiv_round_up((long) cinfo->image_width,
+		    (long) (cinfo->max_h_samp_factor*DCTSIZE));
+    cinfo->MCU_rows_in_scan = (JDIMENSION)
+      jdiv_round_up((long) cinfo->image_height,
+		    (long) (cinfo->max_v_samp_factor*DCTSIZE));
+    
+    cinfo->blocks_in_MCU = 0;
+    
+    for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+      compptr = cinfo->cur_comp_info[ci];
+      /* Sampling factors give # of blocks of component in each MCU */
+      compptr->MCU_width = compptr->h_samp_factor;
+      compptr->MCU_height = compptr->v_samp_factor;
+      compptr->MCU_blocks = compptr->MCU_width * compptr->MCU_height;
+      compptr->MCU_sample_width = compptr->MCU_width * compptr->DCT_scaled_size;
+      /* Figure number of non-dummy blocks in last MCU column & row */
+      tmp = (int) (compptr->width_in_blocks % compptr->MCU_width);
+      if (tmp == 0) tmp = compptr->MCU_width;
+      compptr->last_col_width = tmp;
+      tmp = (int) (compptr->height_in_blocks % compptr->MCU_height);
+      if (tmp == 0) tmp = compptr->MCU_height;
+      compptr->last_row_height = tmp;
+      /* Prepare array describing MCU composition */
+      mcublks = compptr->MCU_blocks;
+      if (cinfo->blocks_in_MCU + mcublks > D_MAX_BLOCKS_IN_MCU)
+	ERREXIT(cinfo, JERR_BAD_MCU_SIZE);
+      while (mcublks-- > 0) {
+	cinfo->MCU_membership[cinfo->blocks_in_MCU++] = ci;
+      }
+    }
+    
+  }
+}
+
+
+/*
+ * Save away a copy of the Q-table referenced by each component present
+ * in the current scan, unless already saved during a prior scan.
+ *
+ * In a multiple-scan JPEG file, the encoder could assign different components
+ * the same Q-table slot number, but change table definitions between scans
+ * so that each component uses a different Q-table.  (The IJG encoder is not
+ * currently capable of doing this, but other encoders might.)  Since we want
+ * to be able to dequantize all the components at the end of the file, this
+ * means that we have to save away the table actually used for each component.
+ * We do this by copying the table at the start of the first scan containing
+ * the component.
+ * The JPEG spec prohibits the encoder from changing the contents of a Q-table
+ * slot between scans of a component using that slot.  If the encoder does so
+ * anyway, this decoder will simply use the Q-table values that were current
+ * at the start of the first scan for the component.
+ *
+ * The decompressor output side looks only at the saved quant tables,
+ * not at the current Q-table slots.
+ */
+
+LOCAL void
+latch_quant_tables (j_decompress_ptr cinfo)
+{
+  int ci, qtblno;
+  jpeg_component_info *compptr;
+  JQUANT_TBL * qtbl;
+
+  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
+    compptr = cinfo->cur_comp_info[ci];
+    /* No work if we already saved Q-table for this component */
+    if (compptr->quant_table != NULL)
+      continue;
+    /* Make sure specified quantization table is present */
+    qtblno = compptr->quant_tbl_no;
+    if (qtblno < 0 || qtblno >= NUM_QUANT_TBLS ||
+	cinfo->quant_tbl_ptrs[qtblno] == NULL)
+      ERREXIT1(cinfo, JERR_NO_QUANT_TABLE, qtblno);
+    /* OK, save away the quantization table */
+    qtbl = (JQUANT_TBL *)
+      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				  SIZEOF(JQUANT_TBL));
+    MEMCOPY(qtbl, cinfo->quant_tbl_ptrs[qtblno], SIZEOF(JQUANT_TBL));
+    compptr->quant_table = qtbl;
+  }
+}
+
+
+/*
+ * Initialize the input modules to read a scan of compressed data.
+ * The first call to this is done by jdmaster.c after initializing
+ * the entire decompressor (during jpeg_start_decompress).
+ * Subsequent calls come from consume_markers, below.
+ */
+
+METHODDEF void
+start_input_pass (j_decompress_ptr cinfo)
+{
+  per_scan_setup(cinfo);
+  latch_quant_tables(cinfo);
+  (*cinfo->entropy->start_pass) (cinfo);
+  (*cinfo->coef->start_input_pass) (cinfo);
+  cinfo->inputctl->consume_input = cinfo->coef->consume_data;
+}
+
+
+/*
+ * Finish up after inputting a compressed-data scan.
+ * This is called by the coefficient controller after it's read all
+ * the expected data of the scan.
+ */
+
+METHODDEF void
+finish_input_pass (j_decompress_ptr cinfo)
+{
+  cinfo->inputctl->consume_input = consume_markers;
+}
+
+
+/*
+ * Read JPEG markers before, between, or after compressed-data scans.
+ * Change state as necessary when a new scan is reached.
+ * Return value is JPEG_SUSPENDED, JPEG_REACHED_SOS, or JPEG_REACHED_EOI.
+ *
+ * The consume_input method pointer points either here or to the
+ * coefficient controller's consume_data routine, depending on whether
+ * we are reading a compressed data segment or inter-segment markers.
+ */
+
+METHODDEF int
+consume_markers (j_decompress_ptr cinfo)
+{
+  my_inputctl_ptr inputctl = (my_inputctl_ptr) cinfo->inputctl;
+  int val;
+
+  if (inputctl->pub.eoi_reached) /* After hitting EOI, read no further */
+    return JPEG_REACHED_EOI;
+
+  val = (*cinfo->marker->read_markers) (cinfo);
+
+  switch (val) {
+  case JPEG_REACHED_SOS:	/* Found SOS */
+    if (inputctl->inheaders) {	/* 1st SOS */
+      initial_setup(cinfo);
+      inputctl->inheaders = FALSE;
+      /* Note: start_input_pass must be called by jdmaster.c
+       * before any more input can be consumed.  jdapi.c is
+       * responsible for enforcing this sequencing.
+       */
+    } else {			/* 2nd or later SOS marker */
+      if (! inputctl->pub.has_multiple_scans)
+	ERREXIT(cinfo, JERR_EOI_EXPECTED); /* Oops, I wasn't expecting this! */
+      start_input_pass(cinfo);
+    }
+    break;
+  case JPEG_REACHED_EOI:	/* Found EOI */
+    inputctl->pub.eoi_reached = TRUE;
+    if (inputctl->inheaders) {	/* Tables-only datastream, apparently */
+      if (cinfo->marker->saw_SOF)
+	ERREXIT(cinfo, JERR_SOF_NO_SOS);
+    } else {
+      /* Prevent infinite loop in coef ctlr's decompress_data routine
+       * if user set output_scan_number larger than number of scans.
+       */
+      if (cinfo->output_scan_number > cinfo->input_scan_number)
+	cinfo->output_scan_number = cinfo->input_scan_number;
+    }
+    break;
+  case JPEG_SUSPENDED:
+    break;
+  }
+
+  return val;
+}
+
+
+/*
+ * Reset state to begin a fresh datastream.
+ */
+
+METHODDEF void
+reset_input_controller (j_decompress_ptr cinfo)
+{
+  my_inputctl_ptr inputctl = (my_inputctl_ptr) cinfo->inputctl;
+
+  inputctl->pub.consume_input = consume_markers;
+  inputctl->pub.has_multiple_scans = FALSE; /* "unknown" would be better */
+  inputctl->pub.eoi_reached = FALSE;
+  inputctl->inheaders = TRUE;
+  /* Reset other modules */
+  (*cinfo->err->reset_error_mgr) ((j_common_ptr) cinfo);
+  (*cinfo->marker->reset_marker_reader) (cinfo);
+  /* Reset progression state -- would be cleaner if entropy decoder did this */
+  cinfo->coef_bits = NULL;
+}
+
+
+/*
+ * Initialize the input controller module.
+ * This is called only once, when the decompression object is created.
+ */
+
+GLOBAL void
+jinit_input_controller (j_decompress_ptr cinfo)
+{
+  my_inputctl_ptr inputctl;
+
+  /* Create subobject in permanent pool */
+  inputctl = (my_inputctl_ptr)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
+				SIZEOF(my_input_controller));
+  cinfo->inputctl = (struct jpeg_input_controller *) inputctl;
+  /* Initialize method pointers */
+  inputctl->pub.consume_input = consume_markers;
+  inputctl->pub.reset_input_controller = reset_input_controller;
+  inputctl->pub.start_input_pass = start_input_pass;
+  inputctl->pub.finish_input_pass = finish_input_pass;
+  /* Initialize state: can't use reset_input_controller since we don't
+   * want to try to reset other modules yet.
+   */
+  inputctl->pub.has_multiple_scans = FALSE; /* "unknown" would be better */
+  inputctl->pub.eoi_reached = FALSE;
+  inputctl->inheaders = TRUE;
+}
diff --git a/codemp/jpeg-6/jdmainct.cpp b/codemp/jpeg-6/jdmainct.cpp
new file mode 100644
index 0000000..2077750
--- /dev/null
+++ b/codemp/jpeg-6/jdmainct.cpp
@@ -0,0 +1,522 @@
+/*
+ * jdmainct.c
+ *
+ * Copyright (C) 1994-1995, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains the main buffer controller for decompression.
+ * The main buffer lies between the JPEG decompressor proper and the
+ * post-processor; it holds downsampled data in the JPEG colorspace.
+ *
+ * Note that this code is bypassed in raw-data mode, since the application
+ * supplies the equivalent of the main buffer in that case.
+ */
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/*
+ * In the current system design, the main buffer need never be a full-image
+ * buffer; any full-height buffers will be found inside the coefficient or
+ * postprocessing controllers.  Nonetheless, the main controller is not
+ * trivial.  Its responsibility is to provide context rows for upsampling/
+ * rescaling, and doing this in an efficient fashion is a bit tricky.
+ *
+ * Postprocessor input data is counted in "row groups".  A row group
+ * is defined to be (v_samp_factor * DCT_scaled_size / min_DCT_scaled_size)
+ * sample rows of each component.  (We require DCT_scaled_size values to be
+ * chosen such that these numbers are integers.  In practice DCT_scaled_size
+ * values will likely be powers of two, so we actually have the stronger
+ * condition that DCT_scaled_size / min_DCT_scaled_size is an integer.)
+ * Upsampling will typically produce max_v_samp_factor pixel rows from each
+ * row group (times any additional scale factor that the upsampler is
+ * applying).
+ *
+ * The coefficient controller will deliver data to us one iMCU row at a time;
+ * each iMCU row contains v_samp_factor * DCT_scaled_size sample rows, or
+ * exactly min_DCT_scaled_size row groups.  (This amount of data corresponds
+ * to one row of MCUs when the image is fully interleaved.)  Note that the
+ * number of sample rows varies across components, but the number of row
+ * groups does not.  Some garbage sample rows may be included in the last iMCU
+ * row at the bottom of the image.
+ *
+ * Depending on the vertical scaling algorithm used, the upsampler may need
+ * access to the sample row(s) above and below its current input row group.
+ * The upsampler is required to set need_context_rows TRUE at global selection
+ * time if so.  When need_context_rows is FALSE, this controller can simply
+ * obtain one iMCU row at a time from the coefficient controller and dole it
+ * out as row groups to the postprocessor.
+ *
+ * When need_context_rows is TRUE, this controller guarantees that the buffer
+ * passed to postprocessing contains at least one row group's worth of samples
+ * above and below the row group(s) being processed.  Note that the context
+ * rows "above" the first passed row group appear at negative row offsets in
+ * the passed buffer.  At the top and bottom of the image, the required
+ * context rows are manufactured by duplicating the first or last real sample
+ * row; this avoids having special cases in the upsampling inner loops.
+ *
+ * The amount of context is fixed at one row group just because that's a
+ * convenient number for this controller to work with.  The existing
+ * upsamplers really only need one sample row of context.  An upsampler
+ * supporting arbitrary output rescaling might wish for more than one row
+ * group of context when shrinking the image; tough, we don't handle that.
+ * (This is justified by the assumption that downsizing will be handled mostly
+ * by adjusting the DCT_scaled_size values, so that the actual scale factor at
+ * the upsample step needn't be much less than one.)
+ *
+ * To provide the desired context, we have to retain the last two row groups
+ * of one iMCU row while reading in the next iMCU row.  (The last row group
+ * can't be processed until we have another row group for its below-context,
+ * and so we have to save the next-to-last group too for its above-context.)
+ * We could do this most simply by copying data around in our buffer, but
+ * that'd be very slow.  We can avoid copying any data by creating a rather
+ * strange pointer structure.  Here's how it works.  We allocate a workspace
+ * consisting of M+2 row groups (where M = min_DCT_scaled_size is the number
+ * of row groups per iMCU row).  We create two sets of redundant pointers to
+ * the workspace.  Labeling the physical row groups 0 to M+1, the synthesized
+ * pointer lists look like this:
+ *                   M+1                          M-1
+ * master pointer --> 0         master pointer --> 0
+ *                    1                            1
+ *                   ...                          ...
+ *                   M-3                          M-3
+ *                   M-2                           M
+ *                   M-1                          M+1
+ *                    M                           M-2
+ *                   M+1                          M-1
+ *                    0                            0
+ * We read alternate iMCU rows using each master pointer; thus the last two
+ * row groups of the previous iMCU row remain un-overwritten in the workspace.
+ * The pointer lists are set up so that the required context rows appear to
+ * be adjacent to the proper places when we pass the pointer lists to the
+ * upsampler.
+ *
+ * The above pictures describe the normal state of the pointer lists.
+ * At top and bottom of the image, we diddle the pointer lists to duplicate
+ * the first or last sample row as necessary (this is cheaper than copying
+ * sample rows around).
+ *
+ * This scheme breaks down if M < 2, ie, min_DCT_scaled_size is 1.  In that
+ * situation each iMCU row provides only one row group so the buffering logic
+ * must be different (eg, we must read two iMCU rows before we can emit the
+ * first row group).  For now, we simply do not support providing context
+ * rows when min_DCT_scaled_size is 1.  That combination seems unlikely to
+ * be worth providing --- if someone wants a 1/8th-size preview, they probably
+ * want it quick and dirty, so a context-free upsampler is sufficient.
+ */
+
+
+/* Private buffer controller object */
+
+typedef struct {
+  struct jpeg_d_main_controller pub; /* public fields */
+
+  /* Pointer to allocated workspace (M or M+2 row groups). */
+  JSAMPARRAY buffer[MAX_COMPONENTS];
+
+  boolean buffer_full;		/* Have we gotten an iMCU row from decoder? */
+  JDIMENSION rowgroup_ctr;	/* counts row groups output to postprocessor */
+
+  /* Remaining fields are only used in the context case. */
+
+  /* These are the master pointers to the funny-order pointer lists. */
+  JSAMPIMAGE xbuffer[2];	/* pointers to weird pointer lists */
+
+  int whichptr;			/* indicates which pointer set is now in use */
+  int context_state;		/* process_data state machine status */
+  JDIMENSION rowgroups_avail;	/* row groups available to postprocessor */
+  JDIMENSION iMCU_row_ctr;	/* counts iMCU rows to detect image top/bot */
+} my_main_controller;
+
+typedef my_main_controller * my_main_ptr;
+
+/* context_state values: */
+#define CTX_PREPARE_FOR_IMCU	0	/* need to prepare for MCU row */
+#define CTX_PROCESS_IMCU	1	/* feeding iMCU to postprocessor */
+#define CTX_POSTPONED_ROW	2	/* feeding postponed row group */
+
+
+/* Forward declarations */
+METHODDEF void process_data_simple_main
+	JPP((j_decompress_ptr cinfo, JSAMPARRAY output_buf,
+	     JDIMENSION *out_row_ctr, JDIMENSION out_rows_avail));
+METHODDEF void process_data_context_main
+	JPP((j_decompress_ptr cinfo, JSAMPARRAY output_buf,
+	     JDIMENSION *out_row_ctr, JDIMENSION out_rows_avail));
+#ifdef QUANT_2PASS_SUPPORTED
+METHODDEF void process_data_crank_post
+	JPP((j_decompress_ptr cinfo, JSAMPARRAY output_buf,
+	     JDIMENSION *out_row_ctr, JDIMENSION out_rows_avail));
+#endif
+
+
+LOCAL void
+alloc_funny_pointers (j_decompress_ptr cinfo)
+/* Allocate space for the funny pointer lists.
+ * This is done only once, not once per pass.
+ */
+{
+  // bk001204 - no use main
+  my_main_ptr jmain = (my_main_ptr) cinfo->main;
+  int ci, rgroup;
+  int M = cinfo->min_DCT_scaled_size;
+  jpeg_component_info *compptr;
+  JSAMPARRAY xbuf;
+
+  /* Get top-level space for component array pointers.
+   * We alloc both arrays with one call to save a few cycles.
+   */
+  jmain->xbuffer[0] = (JSAMPIMAGE)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				cinfo->num_components * 2 * SIZEOF(JSAMPARRAY));
+  jmain->xbuffer[1] = jmain->xbuffer[0] + cinfo->num_components;
+
+  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+       ci++, compptr++) {
+    rgroup = (compptr->v_samp_factor * compptr->DCT_scaled_size) /
+      cinfo->min_DCT_scaled_size; /* height of a row group of component */
+    /* Get space for pointer lists --- M+4 row groups in each list.
+     * We alloc both pointer lists with one call to save a few cycles.
+     */
+    xbuf = (JSAMPARRAY)
+      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				  2 * (rgroup * (M + 4)) * SIZEOF(JSAMPROW));
+    xbuf += rgroup;		/* want one row group at negative offsets */
+    jmain->xbuffer[0][ci] = xbuf;
+    xbuf += rgroup * (M + 4);
+    jmain->xbuffer[1][ci] = xbuf;
+  }
+}
+
+
+LOCAL void
+make_funny_pointers (j_decompress_ptr cinfo)
+/* Create the funny pointer lists discussed in the comments above.
+ * The actual workspace is already allocated (in main->buffer),
+ * and the space for the pointer lists is allocated too.
+ * This routine just fills in the curiously ordered lists.
+ * This will be repeated at the beginning of each pass.
+ */
+{
+ // bk001204 - no use main
+  my_main_ptr jmain = (my_main_ptr) cinfo->main;
+  int ci, i, rgroup;
+  int M = cinfo->min_DCT_scaled_size;
+  jpeg_component_info *compptr;
+  JSAMPARRAY buf, xbuf0, xbuf1;
+
+  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+       ci++, compptr++) {
+    rgroup = (compptr->v_samp_factor * compptr->DCT_scaled_size) /
+      cinfo->min_DCT_scaled_size; /* height of a row group of component */
+    xbuf0 = jmain->xbuffer[0][ci];
+    xbuf1 = jmain->xbuffer[1][ci];
+    /* First copy the workspace pointers as-is */
+    buf = jmain->buffer[ci];
+    for (i = 0; i < rgroup * (M + 2); i++) {
+      xbuf0[i] = xbuf1[i] = buf[i];
+    }
+    /* In the second list, put the last four row groups in swapped order */
+    for (i = 0; i < rgroup * 2; i++) {
+      xbuf1[rgroup*(M-2) + i] = buf[rgroup*M + i];
+      xbuf1[rgroup*M + i] = buf[rgroup*(M-2) + i];
+    }
+    /* The wraparound pointers at top and bottom will be filled later
+     * (see set_wraparound_pointers, below).  Initially we want the "above"
+     * pointers to duplicate the first actual data line.  This only needs
+     * to happen in xbuffer[0].
+     */
+    for (i = 0; i < rgroup; i++) {
+      xbuf0[i - rgroup] = xbuf0[0];
+    }
+  }
+}
+
+
+LOCAL void
+set_wraparound_pointers (j_decompress_ptr cinfo)
+/* Set up the "wraparound" pointers at top and bottom of the pointer lists.
+ * This changes the pointer list state from top-of-image to the normal state.
+ */
+{
+ // bk001204 - no use main
+  my_main_ptr jmain = (my_main_ptr) cinfo->main;
+  int ci, i, rgroup;
+  int M = cinfo->min_DCT_scaled_size;
+  jpeg_component_info *compptr;
+  JSAMPARRAY xbuf0, xbuf1;
+
+  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+       ci++, compptr++) {
+    rgroup = (compptr->v_samp_factor * compptr->DCT_scaled_size) /
+      cinfo->min_DCT_scaled_size; /* height of a row group of component */
+    xbuf0 = jmain->xbuffer[0][ci];
+    xbuf1 = jmain->xbuffer[1][ci];
+    for (i = 0; i < rgroup; i++) {
+      xbuf0[i - rgroup] = xbuf0[rgroup*(M+1) + i];
+      xbuf1[i - rgroup] = xbuf1[rgroup*(M+1) + i];
+      xbuf0[rgroup*(M+2) + i] = xbuf0[i];
+      xbuf1[rgroup*(M+2) + i] = xbuf1[i];
+    }
+  }
+}
+
+
+LOCAL void
+set_bottom_pointers (j_decompress_ptr cinfo)
+/* Change the pointer lists to duplicate the last sample row at the bottom
+ * of the image.  whichptr indicates which xbuffer holds the final iMCU row.
+ * Also sets rowgroups_avail to indicate number of nondummy row groups in row.
+ */
+{
+ // bk001204 - no use main
+  my_main_ptr jmain = (my_main_ptr) cinfo->main;
+  int ci, i, rgroup, iMCUheight, rows_left;
+  jpeg_component_info *compptr;
+  JSAMPARRAY xbuf;
+
+  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+       ci++, compptr++) {
+    /* Count sample rows in one iMCU row and in one row group */
+    iMCUheight = compptr->v_samp_factor * compptr->DCT_scaled_size;
+    rgroup = iMCUheight / cinfo->min_DCT_scaled_size;
+    /* Count nondummy sample rows remaining for this component */
+    rows_left = (int) (compptr->downsampled_height % (JDIMENSION) iMCUheight);
+    if (rows_left == 0) rows_left = iMCUheight;
+    /* Count nondummy row groups.  Should get same answer for each component,
+     * so we need only do it once.
+     */
+    if (ci == 0) {
+      jmain->rowgroups_avail = (JDIMENSION) ((rows_left-1) / rgroup + 1);
+    }
+    /* Duplicate the last real sample row rgroup*2 times; this pads out the
+     * last partial rowgroup and ensures at least one full rowgroup of context.
+     */
+    xbuf = jmain->xbuffer[jmain->whichptr][ci];
+    for (i = 0; i < rgroup * 2; i++) {
+      xbuf[rows_left + i] = xbuf[rows_left-1];
+    }
+  }
+}
+
+
+/*
+ * Initialize for a processing pass.
+ */
+
+METHODDEF void
+start_pass_main (j_decompress_ptr cinfo, J_BUF_MODE pass_mode)
+{
+  // bk001204 - no use main
+  my_main_ptr jmain = (my_main_ptr) cinfo->main;
+
+  switch (pass_mode) {
+  case JBUF_PASS_THRU:
+    if (cinfo->upsample->need_context_rows) {
+      jmain->pub.process_data = process_data_context_main;
+      make_funny_pointers(cinfo); /* Create the xbuffer[] lists */
+      jmain->whichptr = 0;	/* Read first iMCU row into xbuffer[0] */
+      jmain->context_state = CTX_PREPARE_FOR_IMCU;
+      jmain->iMCU_row_ctr = 0;
+    } else {
+      /* Simple case with no context needed */
+      jmain->pub.process_data = process_data_simple_main;
+    }
+    jmain->buffer_full = FALSE;	/* Mark buffer empty */
+    jmain->rowgroup_ctr = 0;
+    break;
+#ifdef QUANT_2PASS_SUPPORTED
+  case JBUF_CRANK_DEST:
+    /* For last pass of 2-pass quantization, just crank the postprocessor */
+    jmain->pub.process_data = process_data_crank_post;
+    break;
+#endif
+  default:
+    ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+    break;
+  }
+}
+
+
+/*
+ * Process some data.
+ * This handles the simple case where no context is required.
+ */
+
+METHODDEF void
+process_data_simple_main (j_decompress_ptr cinfo,
+			  JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
+			  JDIMENSION out_rows_avail)
+{
+  // bk001204 - no use main
+  my_main_ptr jmain = (my_main_ptr) cinfo->main;
+  JDIMENSION rowgroups_avail;
+
+  /* Read input data if we haven't filled the main buffer yet */
+  if (! jmain->buffer_full) {
+    if (! (*cinfo->coef->decompress_data) (cinfo, jmain->buffer))
+      return;			/* suspension forced, can do nothing more */
+    jmain->buffer_full = TRUE;	/* OK, we have an iMCU row to work with */
+  }
+
+  /* There are always min_DCT_scaled_size row groups in an iMCU row. */
+  rowgroups_avail = (JDIMENSION) cinfo->min_DCT_scaled_size;
+  /* Note: at the bottom of the image, we may pass extra garbage row groups
+   * to the postprocessor.  The postprocessor has to check for bottom
+   * of image anyway (at row resolution), so no point in us doing it too.
+   */
+
+  /* Feed the postprocessor */
+  (*cinfo->post->post_process_data) (cinfo, jmain->buffer,
+				     &jmain->rowgroup_ctr, rowgroups_avail,
+				     output_buf, out_row_ctr, out_rows_avail);
+
+  /* Has postprocessor consumed all the data yet? If so, mark buffer empty */
+  if (jmain->rowgroup_ctr >= rowgroups_avail) {
+    jmain->buffer_full = FALSE;
+    jmain->rowgroup_ctr = 0;
+  }
+}
+
+
+/*
+ * Process some data.
+ * This handles the case where context rows must be provided.
+ */
+
+METHODDEF void
+process_data_context_main (j_decompress_ptr cinfo,
+			   JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
+			   JDIMENSION out_rows_avail)
+{
+  // bk001204 - no use main
+  my_main_ptr jmain = (my_main_ptr) cinfo->main;
+
+  /* Read input data if we haven't filled the main buffer yet */
+  if (! jmain->buffer_full) {
+    if (! (*cinfo->coef->decompress_data) (cinfo,
+					   jmain->xbuffer[jmain->whichptr]))
+      return;			/* suspension forced, can do nothing more */
+    jmain->buffer_full = TRUE;	/* OK, we have an iMCU row to work with */
+    jmain->iMCU_row_ctr++;	/* count rows received */
+  }
+
+  /* Postprocessor typically will not swallow all the input data it is handed
+   * in one call (due to filling the output buffer first).  Must be prepared
+   * to exit and restart.  This switch lets us keep track of how far we got.
+   * Note that each case falls through to the next on successful completion.
+   */
+  switch (jmain->context_state) {
+  case CTX_POSTPONED_ROW:
+    /* Call postprocessor using previously set pointers for postponed row */
+    (*cinfo->post->post_process_data) (cinfo, jmain->xbuffer[jmain->whichptr],
+			&jmain->rowgroup_ctr, jmain->rowgroups_avail,
+			output_buf, out_row_ctr, out_rows_avail);
+    if (jmain->rowgroup_ctr < jmain->rowgroups_avail)
+      return;			/* Need to suspend */
+    jmain->context_state = CTX_PREPARE_FOR_IMCU;
+    if (*out_row_ctr >= out_rows_avail)
+      return;			/* Postprocessor exactly filled output buf */
+    /*FALLTHROUGH*/
+  case CTX_PREPARE_FOR_IMCU:
+    /* Prepare to process first M-1 row groups of this iMCU row */
+    jmain->rowgroup_ctr = 0;
+    jmain->rowgroups_avail = (JDIMENSION) (cinfo->min_DCT_scaled_size - 1);
+    /* Check for bottom of image: if so, tweak pointers to "duplicate"
+     * the last sample row, and adjust rowgroups_avail to ignore padding rows.
+     */
+    if (jmain->iMCU_row_ctr == cinfo->total_iMCU_rows)
+      set_bottom_pointers(cinfo);
+    jmain->context_state = CTX_PROCESS_IMCU;
+    /*FALLTHROUGH*/
+  case CTX_PROCESS_IMCU:
+    /* Call postprocessor using previously set pointers */
+    (*cinfo->post->post_process_data) (cinfo, jmain->xbuffer[jmain->whichptr],
+			&jmain->rowgroup_ctr, jmain->rowgroups_avail,
+			output_buf, out_row_ctr, out_rows_avail);
+    if (jmain->rowgroup_ctr < jmain->rowgroups_avail)
+      return;			/* Need to suspend */
+    /* After the first iMCU, change wraparound pointers to normal state */
+    if (jmain->iMCU_row_ctr == 1)
+      set_wraparound_pointers(cinfo);
+    /* Prepare to load new iMCU row using other xbuffer list */
+    jmain->whichptr ^= 1;	/* 0=>1 or 1=>0 */
+    jmain->buffer_full = FALSE;
+    /* Still need to process last row group of this iMCU row, */
+    /* which is saved at index M+1 of the other xbuffer */
+    jmain->rowgroup_ctr = (JDIMENSION) (cinfo->min_DCT_scaled_size + 1);
+    jmain->rowgroups_avail = (JDIMENSION) (cinfo->min_DCT_scaled_size + 2);
+    jmain->context_state = CTX_POSTPONED_ROW;
+  }
+}
+
+
+/*
+ * Process some data.
+ * Final pass of two-pass quantization: just call the postprocessor.
+ * Source data will be the postprocessor controller's internal buffer.
+ */
+
+#ifdef QUANT_2PASS_SUPPORTED
+
+METHODDEF void
+process_data_crank_post (j_decompress_ptr cinfo,
+			 JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
+			 JDIMENSION out_rows_avail)
+{
+  (*cinfo->post->post_process_data) (cinfo, (JSAMPIMAGE) NULL,
+				     (JDIMENSION *) NULL, (JDIMENSION) 0,
+				     output_buf, out_row_ctr, out_rows_avail);
+}
+
+#endif /* QUANT_2PASS_SUPPORTED */
+
+
+/*
+ * Initialize main buffer controller.
+ */
+
+GLOBAL void
+jinit_d_main_controller (j_decompress_ptr cinfo, boolean need_full_buffer)
+{
+  // bk001204 - no use main
+  my_main_ptr jmain;
+  int ci, rgroup, ngroups;
+  jpeg_component_info *compptr;
+
+  jmain = (my_main_ptr)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				SIZEOF(my_main_controller));
+  cinfo->main = (struct jpeg_d_main_controller *) jmain;
+  jmain->pub.start_pass = start_pass_main;
+
+  if (need_full_buffer)		/* shouldn't happen */
+    ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+
+  /* Allocate the workspace.
+   * ngroups is the number of row groups we need.
+   */
+  if (cinfo->upsample->need_context_rows) {
+    if (cinfo->min_DCT_scaled_size < 2) /* unsupported, see comments above */
+      ERREXIT(cinfo, JERR_NOTIMPL);
+    alloc_funny_pointers(cinfo); /* Alloc space for xbuffer[] lists */
+    ngroups = cinfo->min_DCT_scaled_size + 2;
+  } else {
+    ngroups = cinfo->min_DCT_scaled_size;
+  }
+
+  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+       ci++, compptr++) {
+    rgroup = (compptr->v_samp_factor * compptr->DCT_scaled_size) /
+      cinfo->min_DCT_scaled_size; /* height of a row group of component */
+    jmain->buffer[ci] = (*cinfo->mem->alloc_sarray)
+			((j_common_ptr) cinfo, JPOOL_IMAGE,
+			 compptr->width_in_blocks * compptr->DCT_scaled_size,
+			 (JDIMENSION) (rgroup * ngroups));
+  }
+}
diff --git a/codemp/jpeg-6/jdmarker.cpp b/codemp/jpeg-6/jdmarker.cpp
new file mode 100644
index 0000000..17832b4
--- /dev/null
+++ b/codemp/jpeg-6/jdmarker.cpp
@@ -0,0 +1,1054 @@
+/*
+ * jdmarker.c
+ *
+ * Copyright (C) 1991-1995, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains routines to decode JPEG datastream markers.
+ * Most of the complexity arises from our desire to support input
+ * suspension: if not all of the data for a marker is available,
+ * we must exit back to the application.  On resumption, we reprocess
+ * the marker.
+ */
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+typedef enum {			/* JPEG marker codes */
+  M_SOF0  = 0xc0,
+  M_SOF1  = 0xc1,
+  M_SOF2  = 0xc2,
+  M_SOF3  = 0xc3,
+  
+  M_SOF5  = 0xc5,
+  M_SOF6  = 0xc6,
+  M_SOF7  = 0xc7,
+  
+  M_JPG   = 0xc8,
+  M_SOF9  = 0xc9,
+  M_SOF10 = 0xca,
+  M_SOF11 = 0xcb,
+  
+  M_SOF13 = 0xcd,
+  M_SOF14 = 0xce,
+  M_SOF15 = 0xcf,
+  
+  M_DHT   = 0xc4,
+  
+  M_DAC   = 0xcc,
+  
+  M_RST0  = 0xd0,
+  M_RST1  = 0xd1,
+  M_RST2  = 0xd2,
+  M_RST3  = 0xd3,
+  M_RST4  = 0xd4,
+  M_RST5  = 0xd5,
+  M_RST6  = 0xd6,
+  M_RST7  = 0xd7,
+  
+  M_SOI   = 0xd8,
+  M_EOI   = 0xd9,
+  M_SOS   = 0xda,
+  M_DQT   = 0xdb,
+  M_DNL   = 0xdc,
+  M_DRI   = 0xdd,
+  M_DHP   = 0xde,
+  M_EXP   = 0xdf,
+  
+  M_APP0  = 0xe0,
+  M_APP1  = 0xe1,
+  M_APP2  = 0xe2,
+  M_APP3  = 0xe3,
+  M_APP4  = 0xe4,
+  M_APP5  = 0xe5,
+  M_APP6  = 0xe6,
+  M_APP7  = 0xe7,
+  M_APP8  = 0xe8,
+  M_APP9  = 0xe9,
+  M_APP10 = 0xea,
+  M_APP11 = 0xeb,
+  M_APP12 = 0xec,
+  M_APP13 = 0xed,
+  M_APP14 = 0xee,
+  M_APP15 = 0xef,
+  
+  M_JPG0  = 0xf0,
+  M_JPG13 = 0xfd,
+  M_COM   = 0xfe,
+  
+  M_TEM   = 0x01,
+  
+  M_ERROR = 0x100
+} JPEG_MARKER;
+
+
+/*
+ * Macros for fetching data from the data source module.
+ *
+ * At all times, cinfo->src->next_input_byte and ->bytes_in_buffer reflect
+ * the current restart point; we update them only when we have reached a
+ * suitable place to restart if a suspension occurs.
+ */
+
+/* Declare and initialize local copies of input pointer/count */
+#define INPUT_VARS(cinfo)  \
+	struct jpeg_source_mgr * datasrc = (cinfo)->src;  \
+	const JOCTET * next_input_byte = datasrc->next_input_byte;  \
+	size_t bytes_in_buffer = datasrc->bytes_in_buffer
+
+/* Unload the local copies --- do this only at a restart boundary */
+#define INPUT_SYNC(cinfo)  \
+	( datasrc->next_input_byte = next_input_byte,  \
+	  datasrc->bytes_in_buffer = bytes_in_buffer )
+
+/* Reload the local copies --- seldom used except in MAKE_BYTE_AVAIL */
+#define INPUT_RELOAD(cinfo)  \
+	( next_input_byte = datasrc->next_input_byte,  \
+	  bytes_in_buffer = datasrc->bytes_in_buffer )
+
+/* Internal macro for INPUT_BYTE and INPUT_2BYTES: make a byte available.
+ * Note we do *not* do INPUT_SYNC before calling fill_input_buffer,
+ * but we must reload the local copies after a successful fill.
+ */
+#define MAKE_BYTE_AVAIL(cinfo,action)  \
+	if (bytes_in_buffer == 0) {  \
+	  if (! (*datasrc->fill_input_buffer) (cinfo))  \
+	    { action; }  \
+	  INPUT_RELOAD(cinfo);  \
+	}  \
+	bytes_in_buffer--
+
+/* Read a byte into variable V.
+ * If must suspend, take the specified action (typically "return FALSE").
+ */
+#define INPUT_BYTE(cinfo,V,action)  \
+	MAKESTMT( MAKE_BYTE_AVAIL(cinfo,action); \
+		  V = GETJOCTET(*next_input_byte++); )
+
+/* As above, but read two bytes interpreted as an unsigned 16-bit integer.
+ * V should be declared unsigned int or perhaps INT32.
+ */
+#define INPUT_2BYTES(cinfo,V,action)  \
+	MAKESTMT( MAKE_BYTE_AVAIL(cinfo,action); \
+		  V = ((unsigned int) GETJOCTET(*next_input_byte++)) << 8; \
+		  MAKE_BYTE_AVAIL(cinfo,action); \
+		  V += GETJOCTET(*next_input_byte++); )
+
+
+/*
+ * Routines to process JPEG markers.
+ *
+ * Entry condition: JPEG marker itself has been read and its code saved
+ *   in cinfo->unread_marker; input restart point is just after the marker.
+ *
+ * Exit: if return TRUE, have read and processed any parameters, and have
+ *   updated the restart point to point after the parameters.
+ *   If return FALSE, was forced to suspend before reaching end of
+ *   marker parameters; restart point has not been moved.  Same routine
+ *   will be called again after application supplies more input data.
+ *
+ * This approach to suspension assumes that all of a marker's parameters can
+ * fit into a single input bufferload.  This should hold for "normal"
+ * markers.  Some COM/APPn markers might have large parameter segments,
+ * but we use skip_input_data to get past those, and thereby put the problem
+ * on the source manager's shoulders.
+ *
+ * Note that we don't bother to avoid duplicate trace messages if a
+ * suspension occurs within marker parameters.  Other side effects
+ * require more care.
+ */
+
+
+LOCAL boolean
+get_soi (j_decompress_ptr cinfo)
+/* Process an SOI marker */
+{
+  int i;
+  
+  TRACEMS(cinfo, 1, JTRC_SOI);
+
+  if (cinfo->marker->saw_SOI)
+    ERREXIT(cinfo, JERR_SOI_DUPLICATE);
+
+  /* Reset all parameters that are defined to be reset by SOI */
+
+  for (i = 0; i < NUM_ARITH_TBLS; i++) {
+    cinfo->arith_dc_L[i] = 0;
+    cinfo->arith_dc_U[i] = 1;
+    cinfo->arith_ac_K[i] = 5;
+  }
+  cinfo->restart_interval = 0;
+
+  /* Set initial assumptions for colorspace etc */
+
+  cinfo->jpeg_color_space = JCS_UNKNOWN;
+  cinfo->CCIR601_sampling = FALSE; /* Assume non-CCIR sampling??? */
+
+  cinfo->saw_JFIF_marker = FALSE;
+  cinfo->density_unit = 0;	/* set default JFIF APP0 values */
+  cinfo->X_density = 1;
+  cinfo->Y_density = 1;
+  cinfo->saw_Adobe_marker = FALSE;
+  cinfo->Adobe_transform = 0;
+
+  cinfo->marker->saw_SOI = TRUE;
+
+  return TRUE;
+}
+
+
+LOCAL boolean
+get_sof (j_decompress_ptr cinfo, boolean is_prog, boolean is_arith)
+/* Process a SOFn marker */
+{
+  INT32 length;
+  int c, ci;
+  jpeg_component_info * compptr;
+  INPUT_VARS(cinfo);
+
+  cinfo->progressive_mode = is_prog;
+  cinfo->arith_code = is_arith;
+
+  INPUT_2BYTES(cinfo, length, return FALSE);
+
+  INPUT_BYTE(cinfo, cinfo->data_precision, return FALSE);
+  INPUT_2BYTES(cinfo, cinfo->image_height, return FALSE);
+  INPUT_2BYTES(cinfo, cinfo->image_width, return FALSE);
+  INPUT_BYTE(cinfo, cinfo->num_components, return FALSE);
+
+  length -= 8;
+
+  TRACEMS4(cinfo, 1, JTRC_SOF, cinfo->unread_marker,
+	   (int) cinfo->image_width, (int) cinfo->image_height,
+	   cinfo->num_components);
+
+  if (cinfo->marker->saw_SOF)
+    ERREXIT(cinfo, JERR_SOF_DUPLICATE);
+
+  /* We don't support files in which the image height is initially specified */
+  /* as 0 and is later redefined by DNL.  As long as we have to check that,  */
+  /* might as well have a general sanity check. */
+  if (cinfo->image_height <= 0 || cinfo->image_width <= 0
+      || cinfo->num_components <= 0)
+    ERREXIT(cinfo, JERR_EMPTY_IMAGE);
+
+  if (length != (cinfo->num_components * 3))
+    ERREXIT(cinfo, JERR_BAD_LENGTH);
+
+  if (cinfo->comp_info == NULL)	/* do only once, even if suspend */
+    cinfo->comp_info = (jpeg_component_info *) (*cinfo->mem->alloc_small)
+			((j_common_ptr) cinfo, JPOOL_IMAGE,
+			 cinfo->num_components * SIZEOF(jpeg_component_info));
+  
+  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+       ci++, compptr++) {
+    compptr->component_index = ci;
+    INPUT_BYTE(cinfo, compptr->component_id, return FALSE);
+    INPUT_BYTE(cinfo, c, return FALSE);
+    compptr->h_samp_factor = (c >> 4) & 15;
+    compptr->v_samp_factor = (c     ) & 15;
+    INPUT_BYTE(cinfo, compptr->quant_tbl_no, return FALSE);
+
+    TRACEMS4(cinfo, 1, JTRC_SOF_COMPONENT,
+	     compptr->component_id, compptr->h_samp_factor,
+	     compptr->v_samp_factor, compptr->quant_tbl_no);
+  }
+
+  cinfo->marker->saw_SOF = TRUE;
+
+  INPUT_SYNC(cinfo);
+  return TRUE;
+}
+
+
+LOCAL boolean
+get_sos (j_decompress_ptr cinfo)
+/* Process a SOS marker */
+{
+  INT32 length;
+  int i, ci, n, c, cc;
+  jpeg_component_info * compptr;
+  INPUT_VARS(cinfo);
+
+  if (! cinfo->marker->saw_SOF)
+    ERREXIT(cinfo, JERR_SOS_NO_SOF);
+
+  INPUT_2BYTES(cinfo, length, return FALSE);
+
+  INPUT_BYTE(cinfo, n, return FALSE); /* Number of components */
+
+  if (length != (n * 2 + 6) || n < 1 || n > MAX_COMPS_IN_SCAN)
+    ERREXIT(cinfo, JERR_BAD_LENGTH);
+
+  TRACEMS1(cinfo, 1, JTRC_SOS, n);
+
+  cinfo->comps_in_scan = n;
+
+  /* Collect the component-spec parameters */
+
+  for (i = 0; i < n; i++) {
+    INPUT_BYTE(cinfo, cc, return FALSE);
+    INPUT_BYTE(cinfo, c, return FALSE);
+    
+    for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+	 ci++, compptr++) {
+      if (cc == compptr->component_id)
+	goto id_found;
+    }
+
+    ERREXIT1(cinfo, JERR_BAD_COMPONENT_ID, cc);
+
+  id_found:
+
+    cinfo->cur_comp_info[i] = compptr;
+    compptr->dc_tbl_no = (c >> 4) & 15;
+    compptr->ac_tbl_no = (c     ) & 15;
+    
+    TRACEMS3(cinfo, 1, JTRC_SOS_COMPONENT, cc,
+	     compptr->dc_tbl_no, compptr->ac_tbl_no);
+  }
+
+  /* Collect the additional scan parameters Ss, Se, Ah/Al. */
+  INPUT_BYTE(cinfo, c, return FALSE);
+  cinfo->Ss = c;
+  INPUT_BYTE(cinfo, c, return FALSE);
+  cinfo->Se = c;
+  INPUT_BYTE(cinfo, c, return FALSE);
+  cinfo->Ah = (c >> 4) & 15;
+  cinfo->Al = (c     ) & 15;
+
+  TRACEMS4(cinfo, 1, JTRC_SOS_PARAMS, cinfo->Ss, cinfo->Se,
+	   cinfo->Ah, cinfo->Al);
+
+  /* Prepare to scan data & restart markers */
+  cinfo->marker->next_restart_num = 0;
+
+  /* Count another SOS marker */
+  cinfo->input_scan_number++;
+
+  INPUT_SYNC(cinfo);
+  return TRUE;
+}
+
+
+METHODDEF boolean
+get_app0 (j_decompress_ptr cinfo)
+/* Process an APP0 marker */
+{
+#define JFIF_LEN 14
+  INT32 length;
+  UINT8 b[JFIF_LEN];
+  int buffp;
+  INPUT_VARS(cinfo);
+
+  INPUT_2BYTES(cinfo, length, return FALSE);
+  length -= 2;
+
+  /* See if a JFIF APP0 marker is present */
+
+  if (length >= JFIF_LEN) {
+    for (buffp = 0; buffp < JFIF_LEN; buffp++)
+      INPUT_BYTE(cinfo, b[buffp], return FALSE);
+    length -= JFIF_LEN;
+
+    if (b[0]==0x4A && b[1]==0x46 && b[2]==0x49 && b[3]==0x46 && b[4]==0) {
+      /* Found JFIF APP0 marker: check version */
+      /* Major version must be 1, anything else signals an incompatible change.
+       * We used to treat this as an error, but now it's a nonfatal warning,
+       * because some bozo at Hijaak couldn't read the spec.
+       * Minor version should be 0..2, but process anyway if newer.
+       */
+      if (b[5] != 1)
+	WARNMS2(cinfo, JWRN_JFIF_MAJOR, b[5], b[6]);
+      else if (b[6] > 2)
+	TRACEMS2(cinfo, 1, JTRC_JFIF_MINOR, b[5], b[6]);
+      /* Save info */
+      cinfo->saw_JFIF_marker = TRUE;
+      cinfo->density_unit = b[7];
+      cinfo->X_density = (b[8] << 8) + b[9];
+      cinfo->Y_density = (b[10] << 8) + b[11];
+      TRACEMS3(cinfo, 1, JTRC_JFIF,
+	       cinfo->X_density, cinfo->Y_density, cinfo->density_unit);
+      if (b[12] | b[13])
+	TRACEMS2(cinfo, 1, JTRC_JFIF_THUMBNAIL, b[12], b[13]);
+      if (length != ((INT32) b[12] * (INT32) b[13] * (INT32) 3))
+	TRACEMS1(cinfo, 1, JTRC_JFIF_BADTHUMBNAILSIZE, (int) length);
+    } else {
+      /* Start of APP0 does not match "JFIF" */
+      TRACEMS1(cinfo, 1, JTRC_APP0, (int) length + JFIF_LEN);
+    }
+  } else {
+    /* Too short to be JFIF marker */
+    TRACEMS1(cinfo, 1, JTRC_APP0, (int) length);
+  }
+
+  INPUT_SYNC(cinfo);
+  if (length > 0)		/* skip any remaining data -- could be lots */
+    (*cinfo->src->skip_input_data) (cinfo, (long) length);
+
+  return TRUE;
+}
+
+
+METHODDEF boolean
+get_app14 (j_decompress_ptr cinfo)
+/* Process an APP14 marker */
+{
+#define ADOBE_LEN 12
+  INT32 length;
+  UINT8 b[ADOBE_LEN];
+  int buffp;
+  unsigned int version, flags0, flags1, transform;
+  INPUT_VARS(cinfo);
+
+  INPUT_2BYTES(cinfo, length, return FALSE);
+  length -= 2;
+
+  /* See if an Adobe APP14 marker is present */
+
+  if (length >= ADOBE_LEN) {
+    for (buffp = 0; buffp < ADOBE_LEN; buffp++)
+      INPUT_BYTE(cinfo, b[buffp], return FALSE);
+    length -= ADOBE_LEN;
+
+    if (b[0]==0x41 && b[1]==0x64 && b[2]==0x6F && b[3]==0x62 && b[4]==0x65) {
+      /* Found Adobe APP14 marker */
+      version = (b[5] << 8) + b[6];
+      flags0 = (b[7] << 8) + b[8];
+      flags1 = (b[9] << 8) + b[10];
+      transform = b[11];
+      TRACEMS4(cinfo, 1, JTRC_ADOBE, version, flags0, flags1, transform);
+      cinfo->saw_Adobe_marker = TRUE;
+      cinfo->Adobe_transform = (UINT8) transform;
+    } else {
+      /* Start of APP14 does not match "Adobe" */
+      TRACEMS1(cinfo, 1, JTRC_APP14, (int) length + ADOBE_LEN);
+    }
+  } else {
+    /* Too short to be Adobe marker */
+    TRACEMS1(cinfo, 1, JTRC_APP14, (int) length);
+  }
+
+  INPUT_SYNC(cinfo);
+  if (length > 0)		/* skip any remaining data -- could be lots */
+    (*cinfo->src->skip_input_data) (cinfo, (long) length);
+
+  return TRUE;
+}
+
+
+LOCAL boolean
+get_dac (j_decompress_ptr cinfo)
+/* Process a DAC marker */
+{
+  INT32 length;
+  int index, val;
+  INPUT_VARS(cinfo);
+
+  INPUT_2BYTES(cinfo, length, return FALSE);
+  length -= 2;
+  
+  while (length > 0) {
+    INPUT_BYTE(cinfo, index, return FALSE);
+    INPUT_BYTE(cinfo, val, return FALSE);
+
+    length -= 2;
+
+    TRACEMS2(cinfo, 1, JTRC_DAC, index, val);
+
+    if (index < 0 || index >= (2*NUM_ARITH_TBLS))
+      ERREXIT1(cinfo, JERR_DAC_INDEX, index);
+
+    if (index >= NUM_ARITH_TBLS) { /* define AC table */
+      cinfo->arith_ac_K[index-NUM_ARITH_TBLS] = (UINT8) val;
+    } else {			/* define DC table */
+      cinfo->arith_dc_L[index] = (UINT8) (val & 0x0F);
+      cinfo->arith_dc_U[index] = (UINT8) (val >> 4);
+      if (cinfo->arith_dc_L[index] > cinfo->arith_dc_U[index])
+	ERREXIT1(cinfo, JERR_DAC_VALUE, val);
+    }
+  }
+
+  INPUT_SYNC(cinfo);
+  return TRUE;
+}
+
+
+LOCAL boolean
+get_dht (j_decompress_ptr cinfo)
+/* Process a DHT marker */
+{
+  INT32 length;
+  UINT8 bits[17];
+  UINT8 huffval[256];
+  int i, index, count;
+  JHUFF_TBL **htblptr;
+  INPUT_VARS(cinfo);
+
+  INPUT_2BYTES(cinfo, length, return FALSE);
+  length -= 2;
+  
+  while (length > 0) {
+    INPUT_BYTE(cinfo, index, return FALSE);
+
+    TRACEMS1(cinfo, 1, JTRC_DHT, index);
+      
+    bits[0] = 0;
+    count = 0;
+    for (i = 1; i <= 16; i++) {
+      INPUT_BYTE(cinfo, bits[i], return FALSE);
+      count += bits[i];
+    }
+
+    length -= 1 + 16;
+
+    TRACEMS8(cinfo, 2, JTRC_HUFFBITS,
+	     bits[1], bits[2], bits[3], bits[4],
+	     bits[5], bits[6], bits[7], bits[8]);
+    TRACEMS8(cinfo, 2, JTRC_HUFFBITS,
+	     bits[9], bits[10], bits[11], bits[12],
+	     bits[13], bits[14], bits[15], bits[16]);
+
+    if (count > 256 || ((INT32) count) > length)
+      ERREXIT(cinfo, JERR_DHT_COUNTS);
+
+    for (i = 0; i < count; i++)
+      INPUT_BYTE(cinfo, huffval[i], return FALSE);
+
+    length -= count;
+
+    if (index & 0x10) {		/* AC table definition */
+      index -= 0x10;
+      htblptr = &cinfo->ac_huff_tbl_ptrs[index];
+    } else {			/* DC table definition */
+      htblptr = &cinfo->dc_huff_tbl_ptrs[index];
+    }
+
+    if (index < 0 || index >= NUM_HUFF_TBLS)
+      ERREXIT1(cinfo, JERR_DHT_INDEX, index);
+
+    if (*htblptr == NULL)
+      *htblptr = jpeg_alloc_huff_table((j_common_ptr) cinfo);
+  
+    MEMCOPY((*htblptr)->bits, bits, SIZEOF((*htblptr)->bits));
+    MEMCOPY((*htblptr)->huffval, huffval, SIZEOF((*htblptr)->huffval));
+  }
+
+  INPUT_SYNC(cinfo);
+  return TRUE;
+}
+
+
+LOCAL boolean
+get_dqt (j_decompress_ptr cinfo)
+/* Process a DQT marker */
+{
+  INT32 length;
+  int n, i, prec;
+  unsigned int tmp;
+  JQUANT_TBL *quant_ptr;
+  INPUT_VARS(cinfo);
+
+  INPUT_2BYTES(cinfo, length, return FALSE);
+  length -= 2;
+
+  while (length > 0) {
+    INPUT_BYTE(cinfo, n, return FALSE);
+    prec = n >> 4;
+    n &= 0x0F;
+
+    TRACEMS2(cinfo, 1, JTRC_DQT, n, prec);
+
+    if (n >= NUM_QUANT_TBLS)
+      ERREXIT1(cinfo, JERR_DQT_INDEX, n);
+      
+    if (cinfo->quant_tbl_ptrs[n] == NULL)
+      cinfo->quant_tbl_ptrs[n] = jpeg_alloc_quant_table((j_common_ptr) cinfo);
+    quant_ptr = cinfo->quant_tbl_ptrs[n];
+
+    for (i = 0; i < DCTSIZE2; i++) {
+      if (prec)
+	INPUT_2BYTES(cinfo, tmp, return FALSE);
+      else
+	INPUT_BYTE(cinfo, tmp, return FALSE);
+      quant_ptr->quantval[i] = (UINT16) tmp;
+    }
+
+    for (i = 0; i < DCTSIZE2; i += 8) {
+      TRACEMS8(cinfo, 2, JTRC_QUANTVALS,
+	       quant_ptr->quantval[i  ], quant_ptr->quantval[i+1],
+	       quant_ptr->quantval[i+2], quant_ptr->quantval[i+3],
+	       quant_ptr->quantval[i+4], quant_ptr->quantval[i+5],
+	       quant_ptr->quantval[i+6], quant_ptr->quantval[i+7]);
+    }
+
+    length -= DCTSIZE2+1;
+    if (prec) length -= DCTSIZE2;
+  }
+
+  INPUT_SYNC(cinfo);
+  return TRUE;
+}
+
+
+LOCAL boolean
+get_dri (j_decompress_ptr cinfo)
+/* Process a DRI marker */
+{
+  INT32 length;
+  unsigned int tmp;
+  INPUT_VARS(cinfo);
+
+  INPUT_2BYTES(cinfo, length, return FALSE);
+  
+  if (length != 4)
+    ERREXIT(cinfo, JERR_BAD_LENGTH);
+
+  INPUT_2BYTES(cinfo, tmp, return FALSE);
+
+  TRACEMS1(cinfo, 1, JTRC_DRI, tmp);
+
+  cinfo->restart_interval = tmp;
+
+  INPUT_SYNC(cinfo);
+  return TRUE;
+}
+
+
+METHODDEF boolean
+skip_variable (j_decompress_ptr cinfo)
+/* Skip over an unknown or uninteresting variable-length marker */
+{
+  INT32 length;
+  INPUT_VARS(cinfo);
+
+  INPUT_2BYTES(cinfo, length, return FALSE);
+  
+  TRACEMS2(cinfo, 1, JTRC_MISC_MARKER, cinfo->unread_marker, (int) length);
+
+  INPUT_SYNC(cinfo);		/* do before skip_input_data */
+  (*cinfo->src->skip_input_data) (cinfo, (long) length - 2L);
+
+  return TRUE;
+}
+
+
+/*
+ * Find the next JPEG marker, save it in cinfo->unread_marker.
+ * Returns FALSE if had to suspend before reaching a marker;
+ * in that case cinfo->unread_marker is unchanged.
+ *
+ * Note that the result might not be a valid marker code,
+ * but it will never be 0 or FF.
+ */
+
+LOCAL boolean
+next_marker (j_decompress_ptr cinfo)
+{
+  int c;
+  INPUT_VARS(cinfo);
+
+  for (;;) {
+    INPUT_BYTE(cinfo, c, return FALSE);
+    /* Skip any non-FF bytes.
+     * This may look a bit inefficient, but it will not occur in a valid file.
+     * We sync after each discarded byte so that a suspending data source
+     * can discard the byte from its buffer.
+     */
+    while (c != 0xFF) {
+      cinfo->marker->discarded_bytes++;
+      INPUT_SYNC(cinfo);
+      INPUT_BYTE(cinfo, c, return FALSE);
+    }
+    /* This loop swallows any duplicate FF bytes.  Extra FFs are legal as
+     * pad bytes, so don't count them in discarded_bytes.  We assume there
+     * will not be so many consecutive FF bytes as to overflow a suspending
+     * data source's input buffer.
+     */
+    do {
+      INPUT_BYTE(cinfo, c, return FALSE);
+    } while (c == 0xFF);
+    if (c != 0)
+      break;			/* found a valid marker, exit loop */
+    /* Reach here if we found a stuffed-zero data sequence (FF/00).
+     * Discard it and loop back to try again.
+     */
+    cinfo->marker->discarded_bytes += 2;
+    INPUT_SYNC(cinfo);
+  }
+
+  if (cinfo->marker->discarded_bytes != 0) {
+    WARNMS2(cinfo, JWRN_EXTRANEOUS_DATA, cinfo->marker->discarded_bytes, c);
+    cinfo->marker->discarded_bytes = 0;
+  }
+
+  cinfo->unread_marker = c;
+
+  INPUT_SYNC(cinfo);
+  return TRUE;
+}
+
+
+LOCAL boolean
+first_marker (j_decompress_ptr cinfo)
+/* Like next_marker, but used to obtain the initial SOI marker. */
+/* For this marker, we do not allow preceding garbage or fill; otherwise,
+ * we might well scan an entire input file before realizing it ain't JPEG.
+ * If an application wants to process non-JFIF files, it must seek to the
+ * SOI before calling the JPEG library.
+ */
+{
+  int c, c2;
+  INPUT_VARS(cinfo);
+
+  INPUT_BYTE(cinfo, c, return FALSE);
+  INPUT_BYTE(cinfo, c2, return FALSE);
+  if (c != 0xFF || c2 != (int) M_SOI)
+    ERREXIT2(cinfo, JERR_NO_SOI, c, c2);
+
+  cinfo->unread_marker = c2;
+
+  INPUT_SYNC(cinfo);
+  return TRUE;
+}
+
+
+/*
+ * Read markers until SOS or EOI.
+ *
+ * Returns same codes as are defined for jpeg_consume_input:
+ * JPEG_SUSPENDED, JPEG_REACHED_SOS, or JPEG_REACHED_EOI.
+ */
+
+METHODDEF int
+read_markers (j_decompress_ptr cinfo)
+{
+  /* Outer loop repeats once for each marker. */
+  for (;;) {
+    /* Collect the marker proper, unless we already did. */
+    /* NB: first_marker() enforces the requirement that SOI appear first. */
+    if (cinfo->unread_marker == 0) {
+      if (! cinfo->marker->saw_SOI) {
+	if (! first_marker(cinfo))
+	  return JPEG_SUSPENDED;
+      } else {
+	if (! next_marker(cinfo))
+	  return JPEG_SUSPENDED;
+      }
+    }
+    /* At this point cinfo->unread_marker contains the marker code and the
+     * input point is just past the marker proper, but before any parameters.
+     * A suspension will cause us to return with this state still true.
+     */
+    switch (cinfo->unread_marker) {
+    case M_SOI:
+      if (! get_soi(cinfo))
+	return JPEG_SUSPENDED;
+      break;
+
+    case M_SOF0:		/* Baseline */
+    case M_SOF1:		/* Extended sequential, Huffman */
+      if (! get_sof(cinfo, FALSE, FALSE))
+	return JPEG_SUSPENDED;
+      break;
+
+    case M_SOF2:		/* Progressive, Huffman */
+      if (! get_sof(cinfo, TRUE, FALSE))
+	return JPEG_SUSPENDED;
+      break;
+
+    case M_SOF9:		/* Extended sequential, arithmetic */
+      if (! get_sof(cinfo, FALSE, TRUE))
+	return JPEG_SUSPENDED;
+      break;
+
+    case M_SOF10:		/* Progressive, arithmetic */
+      if (! get_sof(cinfo, TRUE, TRUE))
+	return JPEG_SUSPENDED;
+      break;
+
+    /* Currently unsupported SOFn types */
+    case M_SOF3:		/* Lossless, Huffman */
+    case M_SOF5:		/* Differential sequential, Huffman */
+    case M_SOF6:		/* Differential progressive, Huffman */
+    case M_SOF7:		/* Differential lossless, Huffman */
+    case M_JPG:			/* Reserved for JPEG extensions */
+    case M_SOF11:		/* Lossless, arithmetic */
+    case M_SOF13:		/* Differential sequential, arithmetic */
+    case M_SOF14:		/* Differential progressive, arithmetic */
+    case M_SOF15:		/* Differential lossless, arithmetic */
+      ERREXIT1(cinfo, JERR_SOF_UNSUPPORTED, cinfo->unread_marker);
+      break;
+
+    case M_SOS:
+      if (! get_sos(cinfo))
+	return JPEG_SUSPENDED;
+      cinfo->unread_marker = 0;	/* processed the marker */
+      return JPEG_REACHED_SOS;
+    
+    case M_EOI:
+      TRACEMS(cinfo, 1, JTRC_EOI);
+      cinfo->unread_marker = 0;	/* processed the marker */
+      return JPEG_REACHED_EOI;
+      
+    case M_DAC:
+      if (! get_dac(cinfo))
+	return JPEG_SUSPENDED;
+      break;
+      
+    case M_DHT:
+      if (! get_dht(cinfo))
+	return JPEG_SUSPENDED;
+      break;
+      
+    case M_DQT:
+      if (! get_dqt(cinfo))
+	return JPEG_SUSPENDED;
+      break;
+      
+    case M_DRI:
+      if (! get_dri(cinfo))
+	return JPEG_SUSPENDED;
+      break;
+      
+    case M_APP0:
+    case M_APP1:
+    case M_APP2:
+    case M_APP3:
+    case M_APP4:
+    case M_APP5:
+    case M_APP6:
+    case M_APP7:
+    case M_APP8:
+    case M_APP9:
+    case M_APP10:
+    case M_APP11:
+    case M_APP12:
+    case M_APP13:
+    case M_APP14:
+    case M_APP15:
+      if (! (*cinfo->marker->process_APPn[cinfo->unread_marker - (int) M_APP0]) (cinfo))
+	return JPEG_SUSPENDED;
+      break;
+      
+    case M_COM:
+      if (! (*cinfo->marker->process_COM) (cinfo))
+	return JPEG_SUSPENDED;
+      break;
+
+    case M_RST0:		/* these are all parameterless */
+    case M_RST1:
+    case M_RST2:
+    case M_RST3:
+    case M_RST4:
+    case M_RST5:
+    case M_RST6:
+    case M_RST7:
+    case M_TEM:
+      TRACEMS1(cinfo, 1, JTRC_PARMLESS_MARKER, cinfo->unread_marker);
+      break;
+
+    case M_DNL:			/* Ignore DNL ... perhaps the wrong thing */
+      if (! skip_variable(cinfo))
+	return JPEG_SUSPENDED;
+      break;
+
+    default:			/* must be DHP, EXP, JPGn, or RESn */
+      /* For now, we treat the reserved markers as fatal errors since they are
+       * likely to be used to signal incompatible JPEG Part 3 extensions.
+       * Once the JPEG 3 version-number marker is well defined, this code
+       * ought to change!
+       */
+      ERREXIT1(cinfo, JERR_UNKNOWN_MARKER, cinfo->unread_marker);
+      break;
+    }
+    /* Successfully processed marker, so reset state variable */
+    cinfo->unread_marker = 0;
+  } /* end loop */
+}
+
+
+/*
+ * Read a restart marker, which is expected to appear next in the datastream;
+ * if the marker is not there, take appropriate recovery action.
+ * Returns FALSE if suspension is required.
+ *
+ * This is called by the entropy decoder after it has read an appropriate
+ * number of MCUs.  cinfo->unread_marker may be nonzero if the entropy decoder
+ * has already read a marker from the data source.  Under normal conditions
+ * cinfo->unread_marker will be reset to 0 before returning; if not reset,
+ * it holds a marker which the decoder will be unable to read past.
+ */
+
+METHODDEF boolean
+read_restart_marker (j_decompress_ptr cinfo)
+{
+  /* Obtain a marker unless we already did. */
+  /* Note that next_marker will complain if it skips any data. */
+  if (cinfo->unread_marker == 0) {
+    if (! next_marker(cinfo))
+      return FALSE;
+  }
+
+  if (cinfo->unread_marker ==
+      ((int) M_RST0 + cinfo->marker->next_restart_num)) {
+    /* Normal case --- swallow the marker and let entropy decoder continue */
+    TRACEMS1(cinfo, 2, JTRC_RST, cinfo->marker->next_restart_num);
+    cinfo->unread_marker = 0;
+  } else {
+    /* Uh-oh, the restart markers have been messed up. */
+    /* Let the data source manager determine how to resync. */
+    if (! (*cinfo->src->resync_to_restart) (cinfo,
+					    cinfo->marker->next_restart_num))
+      return FALSE;
+  }
+
+  /* Update next-restart state */
+  cinfo->marker->next_restart_num = (cinfo->marker->next_restart_num + 1) & 7;
+
+  return TRUE;
+}
+
+
+/*
+ * This is the default resync_to_restart method for data source managers
+ * to use if they don't have any better approach.  Some data source managers
+ * may be able to back up, or may have additional knowledge about the data
+ * which permits a more intelligent recovery strategy; such managers would
+ * presumably supply their own resync method.
+ *
+ * read_restart_marker calls resync_to_restart if it finds a marker other than
+ * the restart marker it was expecting.  (This code is *not* used unless
+ * a nonzero restart interval has been declared.)  cinfo->unread_marker is
+ * the marker code actually found (might be anything, except 0 or FF).
+ * The desired restart marker number (0..7) is passed as a parameter.
+ * This routine is supposed to apply whatever error recovery strategy seems
+ * appropriate in order to position the input stream to the next data segment.
+ * Note that cinfo->unread_marker is treated as a marker appearing before
+ * the current data-source input point; usually it should be reset to zero
+ * before returning.
+ * Returns FALSE if suspension is required.
+ *
+ * This implementation is substantially constrained by wanting to treat the
+ * input as a data stream; this means we can't back up.  Therefore, we have
+ * only the following actions to work with:
+ *   1. Simply discard the marker and let the entropy decoder resume at next
+ *      byte of file.
+ *   2. Read forward until we find another marker, discarding intervening
+ *      data.  (In theory we could look ahead within the current bufferload,
+ *      without having to discard data if we don't find the desired marker.
+ *      This idea is not implemented here, in part because it makes behavior
+ *      dependent on buffer size and chance buffer-boundary positions.)
+ *   3. Leave the marker unread (by failing to zero cinfo->unread_marker).
+ *      This will cause the entropy decoder to process an empty data segment,
+ *      inserting dummy zeroes, and then we will reprocess the marker.
+ *
+ * #2 is appropriate if we think the desired marker lies ahead, while #3 is
+ * appropriate if the found marker is a future restart marker (indicating
+ * that we have missed the desired restart marker, probably because it got
+ * corrupted).
+ * We apply #2 or #3 if the found marker is a restart marker no more than
+ * two counts behind or ahead of the expected one.  We also apply #2 if the
+ * found marker is not a legal JPEG marker code (it's certainly bogus data).
+ * If the found marker is a restart marker more than 2 counts away, we do #1
+ * (too much risk that the marker is erroneous; with luck we will be able to
+ * resync at some future point).
+ * For any valid non-restart JPEG marker, we apply #3.  This keeps us from
+ * overrunning the end of a scan.  An implementation limited to single-scan
+ * files might find it better to apply #2 for markers other than EOI, since
+ * any other marker would have to be bogus data in that case.
+ */
+
+GLOBAL boolean
+jpeg_resync_to_restart (j_decompress_ptr cinfo, int desired)
+{
+  int marker = cinfo->unread_marker;
+  int action = 1;
+  
+  /* Always put up a warning. */
+  WARNMS2(cinfo, JWRN_MUST_RESYNC, marker, desired);
+  
+  /* Outer loop handles repeated decision after scanning forward. */
+  for (;;) {
+    if (marker < (int) M_SOF0)
+      action = 2;		/* invalid marker */
+    else if (marker < (int) M_RST0 || marker > (int) M_RST7)
+      action = 3;		/* valid non-restart marker */
+    else {
+      if (marker == ((int) M_RST0 + ((desired+1) & 7)) ||
+	  marker == ((int) M_RST0 + ((desired+2) & 7)))
+	action = 3;		/* one of the next two expected restarts */
+      else if (marker == ((int) M_RST0 + ((desired-1) & 7)) ||
+	       marker == ((int) M_RST0 + ((desired-2) & 7)))
+	action = 2;		/* a prior restart, so advance */
+      else
+	action = 1;		/* desired restart or too far away */
+    }
+    TRACEMS2(cinfo, 4, JTRC_RECOVERY_ACTION, marker, action);
+    switch (action) {
+    case 1:
+      /* Discard marker and let entropy decoder resume processing. */
+      cinfo->unread_marker = 0;
+      return TRUE;
+    case 2:
+      /* Scan to the next marker, and repeat the decision loop. */
+      if (! next_marker(cinfo))
+	return FALSE;
+      marker = cinfo->unread_marker;
+      break;
+    case 3:
+      /* Return without advancing past this marker. */
+      /* Entropy decoder will be forced to process an empty segment. */
+      return TRUE;
+    }
+  } /* end loop */
+}
+
+
+/*
+ * Reset marker processing state to begin a fresh datastream.
+ */
+
+METHODDEF void
+reset_marker_reader (j_decompress_ptr cinfo)
+{
+  cinfo->comp_info = NULL;		/* until allocated by get_sof */
+  cinfo->input_scan_number = 0;		/* no SOS seen yet */
+  cinfo->unread_marker = 0;		/* no pending marker */
+  cinfo->marker->saw_SOI = FALSE;	/* set internal state too */
+  cinfo->marker->saw_SOF = FALSE;
+  cinfo->marker->discarded_bytes = 0;
+}
+
+
+/*
+ * Initialize the marker reader module.
+ * This is called only once, when the decompression object is created.
+ */
+
+GLOBAL void
+jinit_marker_reader (j_decompress_ptr cinfo)
+{
+  int i;
+
+  /* Create subobject in permanent pool */
+  cinfo->marker = (struct jpeg_marker_reader *)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
+				SIZEOF(struct jpeg_marker_reader));
+  /* Initialize method pointers */
+  cinfo->marker->reset_marker_reader = reset_marker_reader;
+  cinfo->marker->read_markers = read_markers;
+  cinfo->marker->read_restart_marker = read_restart_marker;
+  cinfo->marker->process_COM = skip_variable;
+  for (i = 0; i < 16; i++)
+    cinfo->marker->process_APPn[i] = skip_variable;
+  cinfo->marker->process_APPn[0] = get_app0;
+  cinfo->marker->process_APPn[14] = get_app14;
+  /* Reset marker processing state */
+  reset_marker_reader(cinfo);
+}
diff --git a/codemp/jpeg-6/jdmaster.cpp b/codemp/jpeg-6/jdmaster.cpp
new file mode 100644
index 0000000..8a2c858
--- /dev/null
+++ b/codemp/jpeg-6/jdmaster.cpp
@@ -0,0 +1,559 @@
+/*
+ * jdmaster.c
+ *
+ * Copyright (C) 1991-1995, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains master control logic for the JPEG decompressor.
+ * These routines are concerned with selecting the modules to be executed
+ * and with determining the number of passes and the work to be done in each
+ * pass.
+ */
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/* Private state */
+
+typedef struct {
+  struct jpeg_decomp_master pub; /* public fields */
+
+  int pass_number;		/* # of passes completed */
+
+  boolean using_merged_upsample; /* TRUE if using merged upsample/cconvert */
+
+  /* Saved references to initialized quantizer modules,
+   * in case we need to switch modes.
+   */
+  struct jpeg_color_quantizer * quantizer_1pass;
+  struct jpeg_color_quantizer * quantizer_2pass;
+} my_decomp_master;
+
+typedef my_decomp_master * my_master_ptr;
+
+
+/*
+ * Determine whether merged upsample/color conversion should be used.
+ * CRUCIAL: this must match the actual capabilities of jdmerge.c!
+ */
+
+LOCAL boolean
+use_merged_upsample (j_decompress_ptr cinfo)
+{
+#ifdef UPSAMPLE_MERGING_SUPPORTED
+  /* Merging is the equivalent of plain box-filter upsampling */
+  if (cinfo->do_fancy_upsampling || cinfo->CCIR601_sampling)
+    return FALSE;
+  /* jdmerge.c only supports YCC=>RGB color conversion */
+  if (cinfo->jpeg_color_space != JCS_YCbCr || cinfo->num_components != 3 ||
+      cinfo->out_color_space != JCS_RGB ||
+      cinfo->out_color_components != RGB_PIXELSIZE)
+    return FALSE;
+  /* and it only handles 2h1v or 2h2v sampling ratios */
+  if (cinfo->comp_info[0].h_samp_factor != 2 ||
+      cinfo->comp_info[1].h_samp_factor != 1 ||
+      cinfo->comp_info[2].h_samp_factor != 1 ||
+      cinfo->comp_info[0].v_samp_factor >  2 ||
+      cinfo->comp_info[1].v_samp_factor != 1 ||
+      cinfo->comp_info[2].v_samp_factor != 1)
+    return FALSE;
+  /* furthermore, it doesn't work if we've scaled the IDCTs differently */
+  if (cinfo->comp_info[0].DCT_scaled_size != cinfo->min_DCT_scaled_size ||
+      cinfo->comp_info[1].DCT_scaled_size != cinfo->min_DCT_scaled_size ||
+      cinfo->comp_info[2].DCT_scaled_size != cinfo->min_DCT_scaled_size)
+    return FALSE;
+  /* ??? also need to test for upsample-time rescaling, when & if supported */
+  return TRUE;			/* by golly, it'll work... */
+#else
+  return FALSE;
+#endif
+}
+
+
+/*
+ * Compute output image dimensions and related values.
+ * NOTE: this is exported for possible use by application.
+ * Hence it mustn't do anything that can't be done twice.
+ * Also note that it may be called before the master module is initialized!
+ */
+
+GLOBAL void
+jpeg_calc_output_dimensions (j_decompress_ptr cinfo)
+/* Do computations that are needed before master selection phase */
+{
+#if 0	// JDC: commented out to remove warning
+  int ci;
+  jpeg_component_info *compptr;
+#endif
+
+  /* Prevent application from calling me at wrong times */
+  if (cinfo->global_state != DSTATE_READY)
+    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+
+#ifdef IDCT_SCALING_SUPPORTED
+
+  /* Compute actual output image dimensions and DCT scaling choices. */
+  if (cinfo->scale_num * 8 <= cinfo->scale_denom) {
+    /* Provide 1/8 scaling */
+    cinfo->output_width = (JDIMENSION)
+      jdiv_round_up((long) cinfo->image_width, 8L);
+    cinfo->output_height = (JDIMENSION)
+      jdiv_round_up((long) cinfo->image_height, 8L);
+    cinfo->min_DCT_scaled_size = 1;
+  } else if (cinfo->scale_num * 4 <= cinfo->scale_denom) {
+    /* Provide 1/4 scaling */
+    cinfo->output_width = (JDIMENSION)
+      jdiv_round_up((long) cinfo->image_width, 4L);
+    cinfo->output_height = (JDIMENSION)
+      jdiv_round_up((long) cinfo->image_height, 4L);
+    cinfo->min_DCT_scaled_size = 2;
+  } else if (cinfo->scale_num * 2 <= cinfo->scale_denom) {
+    /* Provide 1/2 scaling */
+    cinfo->output_width = (JDIMENSION)
+      jdiv_round_up((long) cinfo->image_width, 2L);
+    cinfo->output_height = (JDIMENSION)
+      jdiv_round_up((long) cinfo->image_height, 2L);
+    cinfo->min_DCT_scaled_size = 4;
+  } else {
+    /* Provide 1/1 scaling */
+    cinfo->output_width = cinfo->image_width;
+    cinfo->output_height = cinfo->image_height;
+    cinfo->min_DCT_scaled_size = DCTSIZE;
+  }
+  /* In selecting the actual DCT scaling for each component, we try to
+   * scale up the chroma components via IDCT scaling rather than upsampling.
+   * This saves time if the upsampler gets to use 1:1 scaling.
+   * Note this code assumes that the supported DCT scalings are powers of 2.
+   */
+  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+       ci++, compptr++) {
+    int ssize = cinfo->min_DCT_scaled_size;
+    while (ssize < DCTSIZE &&
+	   (compptr->h_samp_factor * ssize * 2 <=
+	    cinfo->max_h_samp_factor * cinfo->min_DCT_scaled_size) &&
+	   (compptr->v_samp_factor * ssize * 2 <=
+	    cinfo->max_v_samp_factor * cinfo->min_DCT_scaled_size)) {
+      ssize = ssize * 2;
+    }
+    compptr->DCT_scaled_size = ssize;
+  }
+
+  /* Recompute downsampled dimensions of components;
+   * application needs to know these if using raw downsampled data.
+   */
+  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+       ci++, compptr++) {
+    /* Size in samples, after IDCT scaling */
+    compptr->downsampled_width = (JDIMENSION)
+      jdiv_round_up((long) cinfo->image_width *
+		    (long) (compptr->h_samp_factor * compptr->DCT_scaled_size),
+		    (long) (cinfo->max_h_samp_factor * DCTSIZE));
+    compptr->downsampled_height = (JDIMENSION)
+      jdiv_round_up((long) cinfo->image_height *
+		    (long) (compptr->v_samp_factor * compptr->DCT_scaled_size),
+		    (long) (cinfo->max_v_samp_factor * DCTSIZE));
+  }
+
+#else /* !IDCT_SCALING_SUPPORTED */
+
+  /* Hardwire it to "no scaling" */
+  cinfo->output_width = cinfo->image_width;
+  cinfo->output_height = cinfo->image_height;
+  /* jdinput.c has already initialized DCT_scaled_size to DCTSIZE,
+   * and has computed unscaled downsampled_width and downsampled_height.
+   */
+
+#endif /* IDCT_SCALING_SUPPORTED */
+
+  /* Report number of components in selected colorspace. */
+  /* Probably this should be in the color conversion module... */
+  switch (cinfo->out_color_space) {
+  case JCS_GRAYSCALE:
+    cinfo->out_color_components = 1;
+    break;
+  case JCS_RGB:
+#if RGB_PIXELSIZE != 3
+    cinfo->out_color_components = RGB_PIXELSIZE;
+    break;
+#endif /* else share code with YCbCr */
+  case JCS_YCbCr:
+    cinfo->out_color_components = 3;
+    break;
+  case JCS_CMYK:
+  case JCS_YCCK:
+    cinfo->out_color_components = 4;
+    break;
+  default:			/* else must be same colorspace as in file */
+    cinfo->out_color_components = cinfo->num_components;
+    break;
+  }
+  cinfo->output_components = (cinfo->quantize_colors ? 1 :
+			      cinfo->out_color_components);
+
+  /* See if upsampler will want to emit more than one row at a time */
+  if (use_merged_upsample(cinfo))
+    cinfo->rec_outbuf_height = cinfo->max_v_samp_factor;
+  else
+    cinfo->rec_outbuf_height = 1;
+}
+
+
+/*
+ * Several decompression processes need to range-limit values to the range
+ * 0..MAXJSAMPLE; the input value may fall somewhat outside this range
+ * due to noise introduced by quantization, roundoff error, etc.  These
+ * processes are inner loops and need to be as fast as possible.  On most
+ * machines, particularly CPUs with pipelines or instruction prefetch,
+ * a (subscript-check-less) C table lookup
+ *		x = sample_range_limit[x];
+ * is faster than explicit tests
+ *		if (x < 0)  x = 0;
+ *		else if (x > MAXJSAMPLE)  x = MAXJSAMPLE;
+ * These processes all use a common table prepared by the routine below.
+ *
+ * For most steps we can mathematically guarantee that the initial value
+ * of x is within MAXJSAMPLE+1 of the legal range, so a table running from
+ * -(MAXJSAMPLE+1) to 2*MAXJSAMPLE+1 is sufficient.  But for the initial
+ * limiting step (just after the IDCT), a wildly out-of-range value is 
+ * possible if the input data is corrupt.  To avoid any chance of indexing
+ * off the end of memory and getting a bad-pointer trap, we perform the
+ * post-IDCT limiting thus:
+ *		x = range_limit[x & MASK];
+ * where MASK is 2 bits wider than legal sample data, ie 10 bits for 8-bit
+ * samples.  Under normal circumstances this is more than enough range and
+ * a correct output will be generated; with bogus input data the mask will
+ * cause wraparound, and we will safely generate a bogus-but-in-range output.
+ * For the post-IDCT step, we want to convert the data from signed to unsigned
+ * representation by adding CENTERJSAMPLE at the same time that we limit it.
+ * So the post-IDCT limiting table ends up looking like this:
+ *   CENTERJSAMPLE,CENTERJSAMPLE+1,...,MAXJSAMPLE,
+ *   MAXJSAMPLE (repeat 2*(MAXJSAMPLE+1)-CENTERJSAMPLE times),
+ *   0          (repeat 2*(MAXJSAMPLE+1)-CENTERJSAMPLE times),
+ *   0,1,...,CENTERJSAMPLE-1
+ * Negative inputs select values from the upper half of the table after
+ * masking.
+ *
+ * We can save some space by overlapping the start of the post-IDCT table
+ * with the simpler range limiting table.  The post-IDCT table begins at
+ * sample_range_limit + CENTERJSAMPLE.
+ *
+ * Note that the table is allocated in near data space on PCs; it's small
+ * enough and used often enough to justify this.
+ */
+
+LOCAL void
+prepare_range_limit_table (j_decompress_ptr cinfo)
+/* Allocate and fill in the sample_range_limit table */
+{
+  JSAMPLE * table;
+  int i;
+
+  table = (JSAMPLE *)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+		(5 * (MAXJSAMPLE+1) + CENTERJSAMPLE) * SIZEOF(JSAMPLE));
+  table += (MAXJSAMPLE+1);	/* allow negative subscripts of simple table */
+  cinfo->sample_range_limit = table;
+  /* First segment of "simple" table: limit[x] = 0 for x < 0 */
+  MEMZERO(table - (MAXJSAMPLE+1), (MAXJSAMPLE+1) * SIZEOF(JSAMPLE));
+  /* Main part of "simple" table: limit[x] = x */
+  for (i = 0; i <= MAXJSAMPLE; i++)
+    table[i] = (JSAMPLE) i;
+  table += CENTERJSAMPLE;	/* Point to where post-IDCT table starts */
+  /* End of simple table, rest of first half of post-IDCT table */
+  for (i = CENTERJSAMPLE; i < 2*(MAXJSAMPLE+1); i++)
+    table[i] = MAXJSAMPLE;
+  /* Second half of post-IDCT table */
+  MEMZERO(table + (2 * (MAXJSAMPLE+1)),
+	  (2 * (MAXJSAMPLE+1) - CENTERJSAMPLE) * SIZEOF(JSAMPLE));
+  MEMCOPY(table + (4 * (MAXJSAMPLE+1) - CENTERJSAMPLE),
+	  cinfo->sample_range_limit, CENTERJSAMPLE * SIZEOF(JSAMPLE));
+}
+
+
+/*
+ * Master selection of decompression modules.
+ * This is done once at jpeg_start_decompress time.  We determine
+ * which modules will be used and give them appropriate initialization calls.
+ * We also initialize the decompressor input side to begin consuming data.
+ *
+ * Since jpeg_read_header has finished, we know what is in the SOF
+ * and (first) SOS markers.  We also have all the application parameter
+ * settings.
+ */
+
+LOCAL void
+master_selection (j_decompress_ptr cinfo)
+{
+  my_master_ptr master = (my_master_ptr) cinfo->master;
+  boolean use_c_buffer;
+  long samplesperrow;
+  JDIMENSION jd_samplesperrow;
+
+  /* Initialize dimensions and other stuff */
+  jpeg_calc_output_dimensions(cinfo);
+  prepare_range_limit_table(cinfo);
+
+  /* Width of an output scanline must be representable as JDIMENSION. */
+  samplesperrow = (long) cinfo->output_width * (long) cinfo->out_color_components;
+  jd_samplesperrow = (JDIMENSION) samplesperrow;
+  if ((long) jd_samplesperrow != samplesperrow)
+    ERREXIT(cinfo, JERR_WIDTH_OVERFLOW);
+
+  /* Initialize my private state */
+  master->pass_number = 0;
+  master->using_merged_upsample = use_merged_upsample(cinfo);
+
+  /* Color quantizer selection */
+  master->quantizer_1pass = NULL;
+  master->quantizer_2pass = NULL;
+  /* No mode changes if not using buffered-image mode. */
+  if (! cinfo->quantize_colors || ! cinfo->buffered_image) {
+    cinfo->enable_1pass_quant = FALSE;
+    cinfo->enable_external_quant = FALSE;
+    cinfo->enable_2pass_quant = FALSE;
+  }
+  if (cinfo->quantize_colors) {
+    if (cinfo->raw_data_out)
+      ERREXIT(cinfo, JERR_NOTIMPL);
+    /* 2-pass quantizer only works in 3-component color space. */
+    if (cinfo->out_color_components != 3) {
+      cinfo->enable_1pass_quant = TRUE;
+      cinfo->enable_external_quant = FALSE;
+      cinfo->enable_2pass_quant = FALSE;
+      cinfo->colormap = NULL;
+    } else if (cinfo->colormap != NULL) {
+      cinfo->enable_external_quant = TRUE;
+    } else if (cinfo->two_pass_quantize) {
+      cinfo->enable_2pass_quant = TRUE;
+    } else {
+      cinfo->enable_1pass_quant = TRUE;
+    }
+
+    if (cinfo->enable_1pass_quant) {
+#ifdef QUANT_1PASS_SUPPORTED
+      jinit_1pass_quantizer(cinfo);
+      master->quantizer_1pass = cinfo->cquantize;
+#else
+      ERREXIT(cinfo, JERR_NOT_COMPILED);
+#endif
+    }
+
+    /* We use the 2-pass code to map to external colormaps. */
+    if (cinfo->enable_2pass_quant || cinfo->enable_external_quant) {
+#ifdef QUANT_2PASS_SUPPORTED
+      jinit_2pass_quantizer(cinfo);
+      master->quantizer_2pass = cinfo->cquantize;
+#else
+      ERREXIT(cinfo, JERR_NOT_COMPILED);
+#endif
+    }
+    /* If both quantizers are initialized, the 2-pass one is left active;
+     * this is necessary for starting with quantization to an external map.
+     */
+  }
+
+  /* Post-processing: in particular, color conversion first */
+  if (! cinfo->raw_data_out) {
+    if (master->using_merged_upsample) {
+#ifdef UPSAMPLE_MERGING_SUPPORTED
+      jinit_merged_upsampler(cinfo); /* does color conversion too */
+#else
+      ERREXIT(cinfo, JERR_NOT_COMPILED);
+#endif
+    } else {
+      jinit_color_deconverter(cinfo);
+      jinit_upsampler(cinfo);
+    }
+    jinit_d_post_controller(cinfo, cinfo->enable_2pass_quant);
+  }
+  /* Inverse DCT */
+  jinit_inverse_dct(cinfo);
+  /* Entropy decoding: either Huffman or arithmetic coding. */
+  if (cinfo->arith_code) {
+    ERREXIT(cinfo, JERR_ARITH_NOTIMPL);
+  } else {
+    if (cinfo->progressive_mode) {
+#ifdef D_PROGRESSIVE_SUPPORTED
+      jinit_phuff_decoder(cinfo);
+#else
+      ERREXIT(cinfo, JERR_NOT_COMPILED);
+#endif
+    } else
+      jinit_huff_decoder(cinfo);
+  }
+
+  /* Initialize principal buffer controllers. */
+  use_c_buffer = cinfo->inputctl->has_multiple_scans || cinfo->buffered_image;
+  jinit_d_coef_controller(cinfo, use_c_buffer);
+
+  if (! cinfo->raw_data_out)
+    jinit_d_main_controller(cinfo, FALSE /* never need full buffer here */);
+
+  /* We can now tell the memory manager to allocate virtual arrays. */
+  (*cinfo->mem->realize_virt_arrays) ((j_common_ptr) cinfo);
+
+  /* Initialize input side of decompressor to consume first scan. */
+  (*cinfo->inputctl->start_input_pass) (cinfo);
+
+#ifdef D_MULTISCAN_FILES_SUPPORTED
+  /* If jpeg_start_decompress will read the whole file, initialize
+   * progress monitoring appropriately.  The input step is counted
+   * as one pass.
+   */
+  if (cinfo->progress != NULL && ! cinfo->buffered_image &&
+      cinfo->inputctl->has_multiple_scans) {
+    int nscans;
+    /* Estimate number of scans to set pass_limit. */
+    if (cinfo->progressive_mode) {
+      /* Arbitrarily estimate 2 interleaved DC scans + 3 AC scans/component. */
+      nscans = 2 + 3 * cinfo->num_components;
+    } else {
+      /* For a nonprogressive multiscan file, estimate 1 scan per component. */
+      nscans = cinfo->num_components;
+    }
+    cinfo->progress->pass_counter = 0L;
+    cinfo->progress->pass_limit = (long) cinfo->total_iMCU_rows * nscans;
+    cinfo->progress->completed_passes = 0;
+    cinfo->progress->total_passes = (cinfo->enable_2pass_quant ? 3 : 2);
+    /* Count the input pass as done */
+    master->pass_number++;
+  }
+#endif /* D_MULTISCAN_FILES_SUPPORTED */
+}
+
+
+/*
+ * Per-pass setup.
+ * This is called at the beginning of each output pass.  We determine which
+ * modules will be active during this pass and give them appropriate
+ * start_pass calls.  We also set is_dummy_pass to indicate whether this
+ * is a "real" output pass or a dummy pass for color quantization.
+ * (In the latter case, jdapi.c will crank the pass to completion.)
+ */
+
+METHODDEF void
+prepare_for_output_pass (j_decompress_ptr cinfo)
+{
+  my_master_ptr master = (my_master_ptr) cinfo->master;
+
+  if (master->pub.is_dummy_pass) {
+#ifdef QUANT_2PASS_SUPPORTED
+    /* Final pass of 2-pass quantization */
+    master->pub.is_dummy_pass = FALSE;
+    (*cinfo->cquantize->start_pass) (cinfo, FALSE);
+    (*cinfo->post->start_pass) (cinfo, JBUF_CRANK_DEST);
+    (*cinfo->main->start_pass) (cinfo, JBUF_CRANK_DEST);
+#else
+    ERREXIT(cinfo, JERR_NOT_COMPILED);
+#endif /* QUANT_2PASS_SUPPORTED */
+  } else {
+    if (cinfo->quantize_colors && cinfo->colormap == NULL) {
+      /* Select new quantization method */
+      if (cinfo->two_pass_quantize && cinfo->enable_2pass_quant) {
+	cinfo->cquantize = master->quantizer_2pass;
+	master->pub.is_dummy_pass = TRUE;
+      } else if (cinfo->enable_1pass_quant) {
+	cinfo->cquantize = master->quantizer_1pass;
+      } else {
+	ERREXIT(cinfo, JERR_MODE_CHANGE);
+      }
+    }
+    (*cinfo->idct->start_pass) (cinfo);
+    (*cinfo->coef->start_output_pass) (cinfo);
+    if (! cinfo->raw_data_out) {
+      if (! master->using_merged_upsample)
+	(*cinfo->cconvert->start_pass) (cinfo);
+      (*cinfo->upsample->start_pass) (cinfo);
+      if (cinfo->quantize_colors)
+	(*cinfo->cquantize->start_pass) (cinfo, master->pub.is_dummy_pass);
+      (*cinfo->post->start_pass) (cinfo,
+	    (master->pub.is_dummy_pass ? JBUF_SAVE_AND_PASS : JBUF_PASS_THRU));
+      (*cinfo->main->start_pass) (cinfo, JBUF_PASS_THRU);
+    }
+  }
+
+  /* Set up progress monitor's pass info if present */
+  if (cinfo->progress != NULL) {
+    cinfo->progress->completed_passes = master->pass_number;
+    cinfo->progress->total_passes = master->pass_number +
+				    (master->pub.is_dummy_pass ? 2 : 1);
+    /* In buffered-image mode, we assume one more output pass if EOI not
+     * yet reached, but no more passes if EOI has been reached.
+     */
+    if (cinfo->buffered_image && ! cinfo->inputctl->eoi_reached) {
+      cinfo->progress->total_passes += (cinfo->enable_2pass_quant ? 2 : 1);
+    }
+  }
+}
+
+
+/*
+ * Finish up at end of an output pass.
+ */
+
+METHODDEF void
+finish_output_pass (j_decompress_ptr cinfo)
+{
+  my_master_ptr master = (my_master_ptr) cinfo->master;
+
+  if (cinfo->quantize_colors)
+    (*cinfo->cquantize->finish_pass) (cinfo);
+  master->pass_number++;
+}
+
+
+#ifdef D_MULTISCAN_FILES_SUPPORTED
+
+/*
+ * Switch to a new external colormap between output passes.
+ */
+
+GLOBAL void
+jpeg_new_colormap (j_decompress_ptr cinfo)
+{
+  my_master_ptr master = (my_master_ptr) cinfo->master;
+
+  /* Prevent application from calling me at wrong times */
+  if (cinfo->global_state != DSTATE_BUFIMAGE)
+    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+
+  if (cinfo->quantize_colors && cinfo->enable_external_quant &&
+      cinfo->colormap != NULL) {
+    /* Select 2-pass quantizer for external colormap use */
+    cinfo->cquantize = master->quantizer_2pass;
+    /* Notify quantizer of colormap change */
+    (*cinfo->cquantize->new_color_map) (cinfo);
+    master->pub.is_dummy_pass = FALSE; /* just in case */
+  } else
+    ERREXIT(cinfo, JERR_MODE_CHANGE);
+}
+
+#endif /* D_MULTISCAN_FILES_SUPPORTED */
+
+
+/*
+ * Initialize master decompression control and select active modules.
+ * This is performed at the start of jpeg_start_decompress.
+ */
+
+GLOBAL void
+jinit_master_decompress (j_decompress_ptr cinfo)
+{
+  my_master_ptr master;
+
+  master = (my_master_ptr)
+      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				  SIZEOF(my_decomp_master));
+  cinfo->master = (struct jpeg_decomp_master *) master;
+  master->pub.prepare_for_output_pass = prepare_for_output_pass;
+  master->pub.finish_output_pass = finish_output_pass;
+
+  master->pub.is_dummy_pass = FALSE;
+
+  master_selection(cinfo);
+}
diff --git a/codemp/jpeg-6/jdpostct.cpp b/codemp/jpeg-6/jdpostct.cpp
new file mode 100644
index 0000000..7d234b6
--- /dev/null
+++ b/codemp/jpeg-6/jdpostct.cpp
@@ -0,0 +1,292 @@
+/*
+ * jdpostct.c
+ *
+ * Copyright (C) 1994-1995, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains the decompression postprocessing controller.
+ * This controller manages the upsampling, color conversion, and color
+ * quantization/reduction steps; specifically, it controls the buffering
+ * between upsample/color conversion and color quantization/reduction.
+ *
+ * If no color quantization/reduction is required, then this module has no
+ * work to do, and it just hands off to the upsample/color conversion code.
+ * An integrated upsample/convert/quantize process would replace this module
+ * entirely.
+ */
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/* Private buffer controller object */
+
+typedef struct {
+  struct jpeg_d_post_controller pub; /* public fields */
+
+  /* Color quantization source buffer: this holds output data from
+   * the upsample/color conversion step to be passed to the quantizer.
+   * For two-pass color quantization, we need a full-image buffer;
+   * for one-pass operation, a strip buffer is sufficient.
+   */
+  jvirt_sarray_ptr whole_image;	/* virtual array, or NULL if one-pass */
+  JSAMPARRAY buffer;		/* strip buffer, or current strip of virtual */
+  JDIMENSION strip_height;	/* buffer size in rows */
+  /* for two-pass mode only: */
+  JDIMENSION starting_row;	/* row # of first row in current strip */
+  JDIMENSION next_row;		/* index of next row to fill/empty in strip */
+} my_post_controller;
+
+typedef my_post_controller * my_post_ptr;
+
+
+/* Forward declarations */
+METHODDEF void post_process_1pass
+	JPP((j_decompress_ptr cinfo,
+	     JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr,
+	     JDIMENSION in_row_groups_avail,
+	     JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
+	     JDIMENSION out_rows_avail));
+#ifdef QUANT_2PASS_SUPPORTED
+METHODDEF void post_process_prepass
+	JPP((j_decompress_ptr cinfo,
+	     JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr,
+	     JDIMENSION in_row_groups_avail,
+	     JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
+	     JDIMENSION out_rows_avail));
+METHODDEF void post_process_2pass
+	JPP((j_decompress_ptr cinfo,
+	     JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr,
+	     JDIMENSION in_row_groups_avail,
+	     JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
+	     JDIMENSION out_rows_avail));
+#endif
+
+
+/*
+ * Initialize for a processing pass.
+ */
+
+METHODDEF void
+start_pass_dpost (j_decompress_ptr cinfo, J_BUF_MODE pass_mode)
+{
+  my_post_ptr post = (my_post_ptr) cinfo->post;
+
+  switch (pass_mode) {
+  case JBUF_PASS_THRU:
+    if (cinfo->quantize_colors) {
+      /* Single-pass processing with color quantization. */
+      post->pub.post_process_data = post_process_1pass;
+      /* We could be doing buffered-image output before starting a 2-pass
+       * color quantization; in that case, jinit_d_post_controller did not
+       * allocate a strip buffer.  Use the virtual-array buffer as workspace.
+       */
+      if (post->buffer == NULL) {
+	post->buffer = (*cinfo->mem->access_virt_sarray)
+	  ((j_common_ptr) cinfo, post->whole_image,
+	   (JDIMENSION) 0, post->strip_height, TRUE);
+      }
+    } else {
+      /* For single-pass processing without color quantization,
+       * I have no work to do; just call the upsampler directly.
+       */
+      post->pub.post_process_data = cinfo->upsample->upsample;
+    }
+    break;
+#ifdef QUANT_2PASS_SUPPORTED
+  case JBUF_SAVE_AND_PASS:
+    /* First pass of 2-pass quantization */
+    if (post->whole_image == NULL)
+      ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+    post->pub.post_process_data = post_process_prepass;
+    break;
+  case JBUF_CRANK_DEST:
+    /* Second pass of 2-pass quantization */
+    if (post->whole_image == NULL)
+      ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+    post->pub.post_process_data = post_process_2pass;
+    break;
+#endif /* QUANT_2PASS_SUPPORTED */
+  default:
+    ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+    break;
+  }
+  post->starting_row = post->next_row = 0;
+}
+
+
+/*
+ * Process some data in the one-pass (strip buffer) case.
+ * This is used for color precision reduction as well as one-pass quantization.
+ */
+
+METHODDEF void
+post_process_1pass (j_decompress_ptr cinfo,
+		    JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr,
+		    JDIMENSION in_row_groups_avail,
+		    JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
+		    JDIMENSION out_rows_avail)
+{
+  my_post_ptr post = (my_post_ptr) cinfo->post;
+  JDIMENSION num_rows, max_rows;
+
+  /* Fill the buffer, but not more than what we can dump out in one go. */
+  /* Note we rely on the upsampler to detect bottom of image. */
+  max_rows = out_rows_avail - *out_row_ctr;
+  if (max_rows > post->strip_height)
+    max_rows = post->strip_height;
+  num_rows = 0;
+  (*cinfo->upsample->upsample) (cinfo,
+		input_buf, in_row_group_ctr, in_row_groups_avail,
+		post->buffer, &num_rows, max_rows);
+  /* Quantize and emit data. */
+  (*cinfo->cquantize->color_quantize) (cinfo,
+		post->buffer, output_buf + *out_row_ctr, (int) num_rows);
+  *out_row_ctr += num_rows;
+}
+
+
+#ifdef QUANT_2PASS_SUPPORTED
+
+/*
+ * Process some data in the first pass of 2-pass quantization.
+ */
+
+METHODDEF void
+post_process_prepass (j_decompress_ptr cinfo,
+		      JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr,
+		      JDIMENSION in_row_groups_avail,
+		      JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
+		      JDIMENSION out_rows_avail)
+{
+  my_post_ptr post = (my_post_ptr) cinfo->post;
+  JDIMENSION old_next_row, num_rows;
+
+  /* Reposition virtual buffer if at start of strip. */
+  if (post->next_row == 0) {
+    post->buffer = (*cinfo->mem->access_virt_sarray)
+	((j_common_ptr) cinfo, post->whole_image,
+	 post->starting_row, post->strip_height, TRUE);
+  }
+
+  /* Upsample some data (up to a strip height's worth). */
+  old_next_row = post->next_row;
+  (*cinfo->upsample->upsample) (cinfo,
+		input_buf, in_row_group_ctr, in_row_groups_avail,
+		post->buffer, &post->next_row, post->strip_height);
+
+  /* Allow quantizer to scan new data.  No data is emitted, */
+  /* but we advance out_row_ctr so outer loop can tell when we're done. */
+  if (post->next_row > old_next_row) {
+    num_rows = post->next_row - old_next_row;
+    (*cinfo->cquantize->color_quantize) (cinfo, post->buffer + old_next_row,
+					 (JSAMPARRAY) NULL, (int) num_rows);
+    *out_row_ctr += num_rows;
+  }
+
+  /* Advance if we filled the strip. */
+  if (post->next_row >= post->strip_height) {
+    post->starting_row += post->strip_height;
+    post->next_row = 0;
+  }
+}
+
+
+/*
+ * Process some data in the second pass of 2-pass quantization.
+ */
+
+METHODDEF void
+post_process_2pass (j_decompress_ptr cinfo,
+		    JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr,
+		    JDIMENSION in_row_groups_avail,
+		    JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
+		    JDIMENSION out_rows_avail)
+{
+  my_post_ptr post = (my_post_ptr) cinfo->post;
+  JDIMENSION num_rows, max_rows;
+
+  /* Reposition virtual buffer if at start of strip. */
+  if (post->next_row == 0) {
+    post->buffer = (*cinfo->mem->access_virt_sarray)
+	((j_common_ptr) cinfo, post->whole_image,
+	 post->starting_row, post->strip_height, FALSE);
+  }
+
+  /* Determine number of rows to emit. */
+  num_rows = post->strip_height - post->next_row; /* available in strip */
+  max_rows = out_rows_avail - *out_row_ctr; /* available in output area */
+  if (num_rows > max_rows)
+    num_rows = max_rows;
+  /* We have to check bottom of image here, can't depend on upsampler. */
+  max_rows = cinfo->output_height - post->starting_row;
+  if (num_rows > max_rows)
+    num_rows = max_rows;
+
+  /* Quantize and emit data. */
+  (*cinfo->cquantize->color_quantize) (cinfo,
+		post->buffer + post->next_row, output_buf + *out_row_ctr,
+		(int) num_rows);
+  *out_row_ctr += num_rows;
+
+  /* Advance if we filled the strip. */
+  post->next_row += num_rows;
+  if (post->next_row >= post->strip_height) {
+    post->starting_row += post->strip_height;
+    post->next_row = 0;
+  }
+}
+
+#endif /* QUANT_2PASS_SUPPORTED */
+
+
+/*
+ * Initialize postprocessing controller.
+ */
+
+GLOBAL void
+jinit_d_post_controller (j_decompress_ptr cinfo, boolean need_full_buffer)
+{
+  my_post_ptr post;
+
+  post = (my_post_ptr)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				SIZEOF(my_post_controller));
+  cinfo->post = (struct jpeg_d_post_controller *) post;
+  post->pub.start_pass = start_pass_dpost;
+  post->whole_image = NULL;	/* flag for no virtual arrays */
+  post->buffer = NULL;		/* flag for no strip buffer */
+
+  /* Create the quantization buffer, if needed */
+  if (cinfo->quantize_colors) {
+    /* The buffer strip height is max_v_samp_factor, which is typically
+     * an efficient number of rows for upsampling to return.
+     * (In the presence of output rescaling, we might want to be smarter?)
+     */
+    post->strip_height = (JDIMENSION) cinfo->max_v_samp_factor;
+    if (need_full_buffer) {
+      /* Two-pass color quantization: need full-image storage. */
+      /* We round up the number of rows to a multiple of the strip height. */
+#ifdef QUANT_2PASS_SUPPORTED
+      post->whole_image = (*cinfo->mem->request_virt_sarray)
+	((j_common_ptr) cinfo, JPOOL_IMAGE, FALSE,
+	 cinfo->output_width * cinfo->out_color_components,
+	 (JDIMENSION) jround_up((long) cinfo->output_height,
+				(long) post->strip_height),
+	 post->strip_height);
+#else
+      ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);
+#endif /* QUANT_2PASS_SUPPORTED */
+    } else {
+      /* One-pass color quantization: just make a strip buffer. */
+      post->buffer = (*cinfo->mem->alloc_sarray)
+	((j_common_ptr) cinfo, JPOOL_IMAGE,
+	 cinfo->output_width * cinfo->out_color_components,
+	 post->strip_height);
+    }
+  }
+}
diff --git a/codemp/jpeg-6/jdsample.cpp b/codemp/jpeg-6/jdsample.cpp
new file mode 100644
index 0000000..e020d30
--- /dev/null
+++ b/codemp/jpeg-6/jdsample.cpp
@@ -0,0 +1,480 @@
+/*
+ * jdsample.c
+ *
+ * Copyright (C) 1991-1994, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains upsampling routines.
+ *
+ * Upsampling input data is counted in "row groups".  A row group
+ * is defined to be (v_samp_factor * DCT_scaled_size / min_DCT_scaled_size)
+ * sample rows of each component.  Upsampling will normally produce
+ * max_v_samp_factor pixel rows from each row group (but this could vary
+ * if the upsampler is applying a scale factor of its own).
+ *
+ * An excellent reference for image resampling is
+ *   Digital Image Warping, George Wolberg, 1990.
+ *   Pub. by IEEE Computer Society Press, Los Alamitos, CA. ISBN 0-8186-8944-7.
+ */
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/* Pointer to routine to upsample a single component */
+typedef JMETHOD(void, upsample1_ptr,
+		(j_decompress_ptr cinfo, jpeg_component_info * compptr,
+		 JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr));
+
+/* Private subobject */
+
+typedef struct {
+  struct jpeg_upsampler pub;	/* public fields */
+
+  /* Color conversion buffer.  When using separate upsampling and color
+   * conversion steps, this buffer holds one upsampled row group until it
+   * has been color converted and output.
+   * Note: we do not allocate any storage for component(s) which are full-size,
+   * ie do not need rescaling.  The corresponding entry of color_buf[] is
+   * simply set to point to the input data array, thereby avoiding copying.
+   */
+  JSAMPARRAY color_buf[MAX_COMPONENTS];
+
+  /* Per-component upsampling method pointers */
+  upsample1_ptr methods[MAX_COMPONENTS];
+
+  int next_row_out;		/* counts rows emitted from color_buf */
+  JDIMENSION rows_to_go;	/* counts rows remaining in image */
+
+  /* Height of an input row group for each component. */
+  int rowgroup_height[MAX_COMPONENTS];
+
+  /* These arrays save pixel expansion factors so that int_expand need not
+   * recompute them each time.  They are unused for other upsampling methods.
+   */
+  UINT8 h_expand[MAX_COMPONENTS];
+  UINT8 v_expand[MAX_COMPONENTS];
+} my_upsampler;
+
+typedef my_upsampler * my_upsample_ptr;
+
+
+/*
+ * Initialize for an upsampling pass.
+ */
+
+METHODDEF void
+start_pass_upsample (j_decompress_ptr cinfo)
+{
+  my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample;
+
+  /* Mark the conversion buffer empty */
+  upsample->next_row_out = cinfo->max_v_samp_factor;
+  /* Initialize total-height counter for detecting bottom of image */
+  upsample->rows_to_go = cinfo->output_height;
+}
+
+
+/*
+ * Control routine to do upsampling (and color conversion).
+ *
+ * In this version we upsample each component independently.
+ * We upsample one row group into the conversion buffer, then apply
+ * color conversion a row at a time.
+ */
+
+METHODDEF void
+sep_upsample (j_decompress_ptr cinfo,
+	      JSAMPIMAGE input_buf, JDIMENSION *in_row_group_ctr,
+	      JDIMENSION in_row_groups_avail,
+	      JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
+	      JDIMENSION out_rows_avail)
+{
+  my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample;
+  int ci;
+  jpeg_component_info * compptr;
+  JDIMENSION num_rows;
+
+  /* Fill the conversion buffer, if it's empty */
+  if (upsample->next_row_out >= cinfo->max_v_samp_factor) {
+    for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+	 ci++, compptr++) {
+      /* Invoke per-component upsample method.  Notice we pass a POINTER
+       * to color_buf[ci], so that fullsize_upsample can change it.
+       */
+      (*upsample->methods[ci]) (cinfo, compptr,
+	input_buf[ci] + (*in_row_group_ctr * upsample->rowgroup_height[ci]),
+	upsample->color_buf + ci);
+    }
+    upsample->next_row_out = 0;
+  }
+
+  /* Color-convert and emit rows */
+
+  /* How many we have in the buffer: */
+  num_rows = (JDIMENSION) (cinfo->max_v_samp_factor - upsample->next_row_out);
+  /* Not more than the distance to the end of the image.  Need this test
+   * in case the image height is not a multiple of max_v_samp_factor:
+   */
+  if (num_rows > upsample->rows_to_go) 
+    num_rows = upsample->rows_to_go;
+  /* And not more than what the client can accept: */
+  out_rows_avail -= *out_row_ctr;
+  if (num_rows > out_rows_avail)
+    num_rows = out_rows_avail;
+
+  (*cinfo->cconvert->color_convert) (cinfo, upsample->color_buf,
+				     (JDIMENSION) upsample->next_row_out,
+				     output_buf + *out_row_ctr,
+				     (int) num_rows);
+
+  /* Adjust counts */
+  *out_row_ctr += num_rows;
+  upsample->rows_to_go -= num_rows;
+  upsample->next_row_out += num_rows;
+  /* When the buffer is emptied, declare this input row group consumed */
+  if (upsample->next_row_out >= cinfo->max_v_samp_factor)
+    (*in_row_group_ctr)++;
+}
+
+
+/*
+ * These are the routines invoked by sep_upsample to upsample pixel values
+ * of a single component.  One row group is processed per call.
+ */
+
+
+/*
+ * For full-size components, we just make color_buf[ci] point at the
+ * input buffer, and thus avoid copying any data.  Note that this is
+ * safe only because sep_upsample doesn't declare the input row group
+ * "consumed" until we are done color converting and emitting it.
+ */
+
+METHODDEF void
+fullsize_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr,
+		   JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr)
+{
+  *output_data_ptr = input_data;
+}
+
+
+/*
+ * This is a no-op version used for "uninteresting" components.
+ * These components will not be referenced by color conversion.
+ */
+
+METHODDEF void
+noop_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr,
+	       JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr)
+{
+  *output_data_ptr = NULL;	/* safety check */
+}
+
+
+/*
+ * This version handles any integral sampling ratios.
+ * This is not used for typical JPEG files, so it need not be fast.
+ * Nor, for that matter, is it particularly accurate: the algorithm is
+ * simple replication of the input pixel onto the corresponding output
+ * pixels.  The hi-falutin sampling literature refers to this as a
+ * "box filter".  A box filter tends to introduce visible artifacts,
+ * so if you are actually going to use 3:1 or 4:1 sampling ratios
+ * you would be well advised to improve this code.
+ */
+
+METHODDEF void
+int_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr,
+	      JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr)
+{
+  my_upsample_ptr upsample = (my_upsample_ptr) cinfo->upsample;
+  JSAMPARRAY output_data = *output_data_ptr;
+  register JSAMPROW inptr, outptr;
+  register JSAMPLE invalue;
+  register int h;
+  JSAMPROW outend;
+  int h_expand, v_expand;
+  int inrow, outrow;
+
+  h_expand = upsample->h_expand[compptr->component_index];
+  v_expand = upsample->v_expand[compptr->component_index];
+
+  inrow = outrow = 0;
+  while (outrow < cinfo->max_v_samp_factor) {
+    /* Generate one output row with proper horizontal expansion */
+    inptr = input_data[inrow];
+    outptr = output_data[outrow];
+    outend = outptr + cinfo->output_width;
+    while (outptr < outend) {
+      invalue = *inptr++;	/* don't need GETJSAMPLE() here */
+      for (h = h_expand; h > 0; h--) {
+	*outptr++ = invalue;
+      }
+    }
+    /* Generate any additional output rows by duplicating the first one */
+    if (v_expand > 1) {
+      jcopy_sample_rows(output_data, outrow, output_data, outrow+1,
+			v_expand-1, cinfo->output_width);
+    }
+    inrow++;
+    outrow += v_expand;
+  }
+}
+
+
+/*
+ * Fast processing for the common case of 2:1 horizontal and 1:1 vertical.
+ * It's still a box filter.
+ */
+
+METHODDEF void
+h2v1_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr,
+	       JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr)
+{
+  JSAMPARRAY output_data = *output_data_ptr;
+  register JSAMPROW inptr, outptr;
+  register JSAMPLE invalue;
+  JSAMPROW outend;
+  int inrow;
+
+  for (inrow = 0; inrow < cinfo->max_v_samp_factor; inrow++) {
+    inptr = input_data[inrow];
+    outptr = output_data[inrow];
+    outend = outptr + cinfo->output_width;
+    while (outptr < outend) {
+      invalue = *inptr++;	/* don't need GETJSAMPLE() here */
+      *outptr++ = invalue;
+      *outptr++ = invalue;
+    }
+  }
+}
+
+
+/*
+ * Fast processing for the common case of 2:1 horizontal and 2:1 vertical.
+ * It's still a box filter.
+ */
+
+METHODDEF void
+h2v2_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr,
+	       JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr)
+{
+  JSAMPARRAY output_data = *output_data_ptr;
+  register JSAMPROW inptr, outptr;
+  register JSAMPLE invalue;
+  JSAMPROW outend;
+  int inrow, outrow;
+
+  inrow = outrow = 0;
+  while (outrow < cinfo->max_v_samp_factor) {
+    inptr = input_data[inrow];
+    outptr = output_data[outrow];
+    outend = outptr + cinfo->output_width;
+    while (outptr < outend) {
+      invalue = *inptr++;	/* don't need GETJSAMPLE() here */
+      *outptr++ = invalue;
+      *outptr++ = invalue;
+    }
+    jcopy_sample_rows(output_data, outrow, output_data, outrow+1,
+		      1, cinfo->output_width);
+    inrow++;
+    outrow += 2;
+  }
+}
+
+
+/*
+ * Fancy processing for the common case of 2:1 horizontal and 1:1 vertical.
+ *
+ * The upsampling algorithm is linear interpolation between pixel centers,
+ * also known as a "triangle filter".  This is a good compromise between
+ * speed and visual quality.  The centers of the output pixels are 1/4 and 3/4
+ * of the way between input pixel centers.
+ *
+ * A note about the "bias" calculations: when rounding fractional values to
+ * integer, we do not want to always round 0.5 up to the next integer.
+ * If we did that, we'd introduce a noticeable bias towards larger values.
+ * Instead, this code is arranged so that 0.5 will be rounded up or down at
+ * alternate pixel locations (a simple ordered dither pattern).
+ */
+
+METHODDEF void
+h2v1_fancy_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr,
+		     JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr)
+{
+  JSAMPARRAY output_data = *output_data_ptr;
+  register JSAMPROW inptr, outptr;
+  register int invalue;
+  register JDIMENSION colctr;
+  int inrow;
+
+  for (inrow = 0; inrow < cinfo->max_v_samp_factor; inrow++) {
+    inptr = input_data[inrow];
+    outptr = output_data[inrow];
+    /* Special case for first column */
+    invalue = GETJSAMPLE(*inptr++);
+    *outptr++ = (JSAMPLE) invalue;
+    *outptr++ = (JSAMPLE) ((invalue * 3 + GETJSAMPLE(*inptr) + 2) >> 2);
+
+    for (colctr = compptr->downsampled_width - 2; colctr > 0; colctr--) {
+      /* General case: 3/4 * nearer pixel + 1/4 * further pixel */
+      invalue = GETJSAMPLE(*inptr++) * 3;
+      *outptr++ = (JSAMPLE) ((invalue + GETJSAMPLE(inptr[-2]) + 1) >> 2);
+      *outptr++ = (JSAMPLE) ((invalue + GETJSAMPLE(*inptr) + 2) >> 2);
+    }
+
+    /* Special case for last column */
+    invalue = GETJSAMPLE(*inptr);
+    *outptr++ = (JSAMPLE) ((invalue * 3 + GETJSAMPLE(inptr[-1]) + 1) >> 2);
+    *outptr++ = (JSAMPLE) invalue;
+  }
+}
+
+
+/*
+ * Fancy processing for the common case of 2:1 horizontal and 2:1 vertical.
+ * Again a triangle filter; see comments for h2v1 case, above.
+ *
+ * It is OK for us to reference the adjacent input rows because we demanded
+ * context from the main buffer controller (see initialization code).
+ */
+
+METHODDEF void
+h2v2_fancy_upsample (j_decompress_ptr cinfo, jpeg_component_info * compptr,
+		     JSAMPARRAY input_data, JSAMPARRAY * output_data_ptr)
+{
+  JSAMPARRAY output_data = *output_data_ptr;
+  register JSAMPROW inptr0, inptr1, outptr;
+#if BITS_IN_JSAMPLE == 8
+  register int thiscolsum, lastcolsum, nextcolsum;
+#else
+  register INT32 thiscolsum, lastcolsum, nextcolsum;
+#endif
+  register JDIMENSION colctr;
+  int inrow, outrow, v;
+
+  inrow = outrow = 0;
+  while (outrow < cinfo->max_v_samp_factor) {
+    for (v = 0; v < 2; v++) {
+      /* inptr0 points to nearest input row, inptr1 points to next nearest */
+      inptr0 = input_data[inrow];
+      if (v == 0)		/* next nearest is row above */
+	inptr1 = input_data[inrow-1];
+      else			/* next nearest is row below */
+	inptr1 = input_data[inrow+1];
+      outptr = output_data[outrow++];
+
+      /* Special case for first column */
+      thiscolsum = GETJSAMPLE(*inptr0++) * 3 + GETJSAMPLE(*inptr1++);
+      nextcolsum = GETJSAMPLE(*inptr0++) * 3 + GETJSAMPLE(*inptr1++);
+      *outptr++ = (JSAMPLE) ((thiscolsum * 4 + 8) >> 4);
+      *outptr++ = (JSAMPLE) ((thiscolsum * 3 + nextcolsum + 7) >> 4);
+      lastcolsum = thiscolsum; thiscolsum = nextcolsum;
+
+      for (colctr = compptr->downsampled_width - 2; colctr > 0; colctr--) {
+	/* General case: 3/4 * nearer pixel + 1/4 * further pixel in each */
+	/* dimension, thus 9/16, 3/16, 3/16, 1/16 overall */
+	nextcolsum = GETJSAMPLE(*inptr0++) * 3 + GETJSAMPLE(*inptr1++);
+	*outptr++ = (JSAMPLE) ((thiscolsum * 3 + lastcolsum + 8) >> 4);
+	*outptr++ = (JSAMPLE) ((thiscolsum * 3 + nextcolsum + 7) >> 4);
+	lastcolsum = thiscolsum; thiscolsum = nextcolsum;
+      }
+
+      /* Special case for last column */
+      *outptr++ = (JSAMPLE) ((thiscolsum * 3 + lastcolsum + 8) >> 4);
+      *outptr++ = (JSAMPLE) ((thiscolsum * 4 + 7) >> 4);
+    }
+    inrow++;
+  }
+}
+
+
+/*
+ * Module initialization routine for upsampling.
+ */
+
+GLOBAL void
+jinit_upsampler (j_decompress_ptr cinfo)
+{
+  my_upsample_ptr upsample;
+  int ci;
+  jpeg_component_info * compptr;
+  boolean need_buffer, do_fancy;
+  int h_in_group, v_in_group, h_out_group, v_out_group;
+
+  upsample = (my_upsample_ptr)
+    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+				SIZEOF(my_upsampler));
+  cinfo->upsample = (struct jpeg_upsampler *) upsample;
+  upsample->pub.start_pass = start_pass_upsample;
+  upsample->pub.upsample = sep_upsample;
+  upsample->pub.need_context_rows = FALSE; /* until we find out differently */
+
+  if (cinfo->CCIR601_sampling)	/* this isn't supported */
+    ERREXIT(cinfo, JERR_CCIR601_NOTIMPL);
+
+  /* jdmainct.c doesn't support context rows when min_DCT_scaled_size = 1,
+   * so don't ask for it.
+   */
+  do_fancy = cinfo->do_fancy_upsampling && cinfo->min_DCT_scaled_size > 1;
+
+  /* Verify we can handle the sampling factors, select per-component methods,
+   * and create storage as needed.
+   */
+  for (ci = 0, compptr = cinfo->comp_info; ci < cinfo->num_components;
+       ci++, compptr++) {
+    /* Compute size of an "input group" after IDCT scaling.  This many samples
+     * are to be converted to max_h_samp_factor * max_v_samp_factor pixels.
+     */
+    h_in_group = (compptr->h_samp_factor * compptr->DCT_scaled_size) /
+		 cinfo->min_DCT_scaled_size;
+    v_in_group = (compptr->v_samp_factor * compptr->DCT_scaled_size) /
+		 cinfo->min_DCT_scaled_size;
+    h_out_group = cinfo->max_h_samp_factor;
+    v_out_group = cinfo->max_v_samp_factor;
+    upsample->rowgroup_height[ci] = v_in_group; /* save for use later */
+    need_buffer = TRUE;
+    if (! compptr->component_needed) {
+      /* Don't bother to upsample an uninteresting component. */
+      upsample->methods[ci] = noop_upsample;
+      need_buffer = FALSE;
+    } else if (h_in_group == h_out_group && v_in_group == v_out_group) {
+      /* Fullsize components can be processed without any work. */
+      upsample->methods[ci] = fullsize_upsample;
+      need_buffer = FALSE;
+    } else if (h_in_group * 2 == h_out_group &&
+	       v_in_group == v_out_group) {
+      /* Special cases for 2h1v upsampling */
+      if (do_fancy && compptr->downsampled_width > 2)
+	upsample->methods[ci] = h2v1_fancy_upsample;
+      else
+	upsample->methods[ci] = h2v1_upsample;
+    } else if (h_in_group * 2 == h_out_group &&
+	       v_in_group * 2 == v_out_group) {
+      /* Special cases for 2h2v upsampling */
+      if (do_fancy && compptr->downsampled_width > 2) {
+	upsample->methods[ci] = h2v2_fancy_upsample;
+	upsample->pub.need_context_rows = TRUE;
+      } else
+	upsample->methods[ci] = h2v2_upsample;
+    } else if ((h_out_group % h_in_group) == 0 &&
+	       (v_out_group % v_in_group) == 0) {
+      /* Generic integral-factors upsampling method */
+      upsample->methods[ci] = int_upsample;
+      upsample->h_expand[ci] = (UINT8) (h_out_group / h_in_group);
+      upsample->v_expand[ci] = (UINT8) (v_out_group / v_in_group);
+    } else
+      ERREXIT(cinfo, JERR_FRACT_SAMPLE_NOTIMPL);
+    if (need_buffer) {
+      upsample->color_buf[ci] = (*cinfo->mem->alloc_sarray)
+	((j_common_ptr) cinfo, JPOOL_IMAGE,
+	 (JDIMENSION) jround_up((long) cinfo->output_width,
+				(long) cinfo->max_h_samp_factor),
+	 (JDIMENSION) cinfo->max_v_samp_factor);
+    }
+  }
+}
diff --git a/codemp/jpeg-6/jdtrans.cpp b/codemp/jpeg-6/jdtrans.cpp
new file mode 100644
index 0000000..d85fc90
--- /dev/null
+++ b/codemp/jpeg-6/jdtrans.cpp
@@ -0,0 +1,124 @@
+/*
+ * jdtrans.c
+ *
+ * Copyright (C) 1995, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains library routines for transcoding decompression,
+ * that is, reading raw DCT coefficient arrays from an input JPEG file.
+ * The routines in jdapimin.c will also be needed by a transcoder.
+ */
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/* Forward declarations */
+LOCAL void transdecode_master_selection JPP((j_decompress_ptr cinfo));
+
+
+/*
+ * Read the coefficient arrays from a JPEG file.
+ * jpeg_read_header must be completed before calling this.
+ *
+ * The entire image is read into a set of virtual coefficient-block arrays,
+ * one per component.  The return value is a pointer to the array of
+ * virtual-array descriptors.  These can be manipulated directly via the
+ * JPEG memory manager, or handed off to jpeg_write_coefficients().
+ * To release the memory occupied by the virtual arrays, call
+ * jpeg_finish_decompress() when done with the data.
+ *
+ * Returns NULL if suspended.  This case need be checked only if
+ * a suspending data source is used.
+ */
+
+GLOBAL jvirt_barray_ptr *
+jpeg_read_coefficients (j_decompress_ptr cinfo)
+{
+  if (cinfo->global_state == DSTATE_READY) {
+    /* First call: initialize active modules */
+    transdecode_master_selection(cinfo);
+    cinfo->global_state = DSTATE_RDCOEFS;
+  } else if (cinfo->global_state != DSTATE_RDCOEFS)
+    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+  /* Absorb whole file into the coef buffer */
+  for (;;) {
+    int retcode;
+    /* Call progress monitor hook if present */
+    if (cinfo->progress != NULL)
+      (*cinfo->progress->progress_monitor) ((j_common_ptr) cinfo);
+    /* Absorb some more input */
+    retcode = (*cinfo->inputctl->consume_input) (cinfo);
+    if (retcode == JPEG_SUSPENDED)
+      return NULL;
+    if (retcode == JPEG_REACHED_EOI)
+      break;
+    /* Advance progress counter if appropriate */
+    if (cinfo->progress != NULL &&
+	(retcode == JPEG_ROW_COMPLETED || retcode == JPEG_REACHED_SOS)) {
+      if (++cinfo->progress->pass_counter >= cinfo->progress->pass_limit) {
+	/* startup underestimated number of scans; ratchet up one scan */
+	cinfo->progress->pass_limit += (long) cinfo->total_iMCU_rows;
+      }
+    }
+  }
+  /* Set state so that jpeg_finish_decompress does the right thing */
+  cinfo->global_state = DSTATE_STOPPING;
+  return cinfo->coef->coef_arrays;
+}
+
+
+/*
+ * Master selection of decompression modules for transcoding.
+ * This substitutes for jdmaster.c's initialization of the full decompressor.
+ */
+
+LOCAL void
+transdecode_master_selection (j_decompress_ptr cinfo)
+{
+  /* Entropy decoding: either Huffman or arithmetic coding. */
+  if (cinfo->arith_code) {
+    ERREXIT(cinfo, JERR_ARITH_NOTIMPL);
+  } else {
+    if (cinfo->progressive_mode) {
+#ifdef D_PROGRESSIVE_SUPPORTED
+      jinit_phuff_decoder(cinfo);
+#else
+      ERREXIT(cinfo, JERR_NOT_COMPILED);
+#endif
+    } else
+      jinit_huff_decoder(cinfo);
+  }
+
+  /* Always get a full-image coefficient buffer. */
+  jinit_d_coef_controller(cinfo, TRUE);
+
+  /* We can now tell the memory manager to allocate virtual arrays. */
+  (*cinfo->mem->realize_virt_arrays) ((j_common_ptr) cinfo);
+
+  /* Initialize input side of decompressor to consume first scan. */
+  (*cinfo->inputctl->start_input_pass) (cinfo);
+
+  /* Initialize progress monitoring. */
+  if (cinfo->progress != NULL) {
+    int nscans;
+    /* Estimate number of scans to set pass_limit. */
+    if (cinfo->progressive_mode) {
+      /* Arbitrarily estimate 2 interleaved DC scans + 3 AC scans/component. */
+      nscans = 2 + 3 * cinfo->num_components;
+    } else if (cinfo->inputctl->has_multiple_scans) {
+      /* For a nonprogressive multiscan file, estimate 1 scan per component. */
+      nscans = cinfo->num_components;
+    } else {
+      nscans = 1;
+    }
+    cinfo->progress->pass_counter = 0L;
+    cinfo->progress->pass_limit = (long) cinfo->total_iMCU_rows * nscans;
+    cinfo->progress->completed_passes = 0;
+    cinfo->progress->total_passes = 1;
+  }
+}
diff --git a/codemp/jpeg-6/jerror.cpp b/codemp/jpeg-6/jerror.cpp
new file mode 100644
index 0000000..d3cc98d
--- /dev/null
+++ b/codemp/jpeg-6/jerror.cpp
@@ -0,0 +1,234 @@
+/*
+ * jerror.c
+ *
+ * Copyright (C) 1991-1994, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains simple error-reporting and trace-message routines.
+ * These are suitable for Unix-like systems and others where writing to
+ * stderr is the right thing to do.  Many applications will want to replace
+ * some or all of these routines.
+ *
+ * These routines are used by both the compression and decompression code.
+ */
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+/* this is not a core library module, so it doesn't define JPEG_INTERNALS */
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jversion.h"
+#include "jerror.h"
+
+#include "../renderer/tr_local.h"
+
+#ifndef EXIT_FAILURE		/* define exit() codes if not provided */
+#define EXIT_FAILURE  1
+#endif
+
+
+/*
+ * Create the message string table.
+ * We do this from the master message list in jerror.h by re-reading
+ * jerror.h with a suitable definition for macro JMESSAGE.
+ * The message table is made an external symbol just in case any applications
+ * want to refer to it directly.
+ */
+
+#ifdef NEED_SHORT_EXTERNAL_NAMES
+#define jpeg_std_message_table	jMsgTable
+#endif
+
+#define JMESSAGE(code,string)	string ,
+
+const char * const jpeg_std_message_table[] = {
+#include "jerror.h"
+  NULL
+};
+
+
+/*
+ * Error exit handler: must not return to caller.
+ *
+ * Applications may override this if they want to get control back after
+ * an error.  Typically one would longjmp somewhere instead of exiting.
+ * The setjmp buffer can be made a private field within an expanded error
+ * handler object.  Note that the info needed to generate an error message
+ * is stored in the error object, so you can generate the message now or
+ * later, at your convenience.
+ * You should make sure that the JPEG object is cleaned up (with jpeg_abort
+ * or jpeg_destroy) at some point.
+ */
+
+METHODDEF void
+error_exit (j_common_ptr cinfo)
+{
+  char buffer[JMSG_LENGTH_MAX];
+
+  /* Create the message */
+  (*cinfo->err->format_message) (cinfo, buffer);
+
+  /* Let the memory manager delete any temp files before we die */
+  jpeg_destroy(cinfo);
+
+  Com_Error( ERR_FATAL, "%s\n", buffer );
+}
+
+
+/*
+ * Actual output of an error or trace message.
+ * Applications may override this method to send JPEG messages somewhere
+ * other than stderr.
+ */
+
+METHODDEF void
+output_message (j_common_ptr cinfo)
+{
+  char buffer[JMSG_LENGTH_MAX];
+
+  /* Create the message */
+  (*cinfo->err->format_message) (cinfo, buffer);
+
+  /* Send it to stderr, adding a newline */
+  Com_Printf("%s\n", buffer);
+}
+
+
+/*
+ * Decide whether to emit a trace or warning message.
+ * msg_level is one of:
+ *   -1: recoverable corrupt-data warning, may want to abort.
+ *    0: important advisory messages (always display to user).
+ *    1: first level of tracing detail.
+ *    2,3,...: successively more detailed tracing messages.
+ * An application might override this method if it wanted to abort on warnings
+ * or change the policy about which messages to display.
+ */
+
+METHODDEF void
+emit_message (j_common_ptr cinfo, int msg_level)
+{
+  struct jpeg_error_mgr * err = cinfo->err;
+
+  if (msg_level < 0) {
+    /* It's a warning message.  Since corrupt files may generate many warnings,
+     * the policy implemented here is to show only the first warning,
+     * unless trace_level >= 3.
+     */
+    if (err->num_warnings == 0 || err->trace_level >= 3)
+      (*err->output_message) (cinfo);
+    /* Always count warnings in num_warnings. */
+    err->num_warnings++;
+  } else {
+    /* It's a trace message.  Show it if trace_level >= msg_level. */
+    if (err->trace_level >= msg_level)
+      (*err->output_message) (cinfo);
+  }
+}
+
+
+/*
+ * Format a message string for the most recent JPEG error or message.
+ * The message is stored into buffer, which should be at least JMSG_LENGTH_MAX
+ * characters.  Note that no '\n' character is added to the string.
+ * Few applications should need to override this method.
+ */
+
+METHODDEF void
+format_message (j_common_ptr cinfo, char * buffer)
+{
+  struct jpeg_error_mgr * err = cinfo->err;
+  int msg_code = err->msg_code;
+  const char * msgtext = NULL;
+  const char * msgptr;
+  char ch;
+  boolean isstring;
+
+  /* Look up message string in proper table */
+  if (msg_code > 0 && msg_code <= err->last_jpeg_message) {
+    msgtext = err->jpeg_message_table[msg_code];
+  } else if (err->addon_message_table != NULL &&
+	     msg_code >= err->first_addon_message &&
+	     msg_code <= err->last_addon_message) {
+    msgtext = err->addon_message_table[msg_code - err->first_addon_message];
+  }
+
+  /* Defend against bogus message number */
+  if (msgtext == NULL) {
+    err->msg_parm.i[0] = msg_code;
+    msgtext = err->jpeg_message_table[0];
+  }
+
+  /* Check for string parameter, as indicated by %s in the message text */
+  isstring = FALSE;
+  msgptr = msgtext;
+  while ((ch = *msgptr++) != '\0') {
+    if (ch == '%') {
+      if (*msgptr == 's') isstring = TRUE;
+      break;
+    }
+  }
+
+  /* Format the message into the passed buffer */
+  if (isstring)
+    sprintf(buffer, msgtext, err->msg_parm.s);
+  else
+    sprintf(buffer, msgtext,
+	    err->msg_parm.i[0], err->msg_parm.i[1],
+	    err->msg_parm.i[2], err->msg_parm.i[3],
+	    err->msg_parm.i[4], err->msg_parm.i[5],
+	    err->msg_parm.i[6], err->msg_parm.i[7]);
+}
+
+
+/*
+ * Reset error state variables at start of a new image.
+ * This is called during compression startup to reset trace/error
+ * processing to default state, without losing any application-specific
+ * method pointers.  An application might possibly want to override
+ * this method if it has additional error processing state.
+ */
+
+METHODDEF void
+reset_error_mgr (j_common_ptr cinfo)
+{
+  cinfo->err->num_warnings = 0;
+  /* trace_level is not reset since it is an application-supplied parameter */
+  cinfo->err->msg_code = 0;	/* may be useful as a flag for "no error" */
+}
+
+
+/*
+ * Fill in the standard error-handling methods in a jpeg_error_mgr object.
+ * Typical call is:
+ *	struct jpeg_compress_struct cinfo;
+ *	struct jpeg_error_mgr err;
+ *
+ *	cinfo.err = jpeg_std_error(&err);
+ * after which the application may override some of the methods.
+ */
+
+GLOBAL struct jpeg_error_mgr *
+jpeg_std_error (struct jpeg_error_mgr * err)
+{
+  err->error_exit = error_exit;
+  err->emit_message = emit_message;
+  err->output_message = output_message;
+  err->format_message = format_message;
+  err->reset_error_mgr = reset_error_mgr;
+
+  err->trace_level = 0;		/* default = no tracing */
+  err->num_warnings = 0;	/* no warnings emitted yet */
+  err->msg_code = 0;		/* may be useful as a flag for "no error" */
+
+  /* Initialize message table pointers */
+  err->jpeg_message_table = jpeg_std_message_table;
+  err->last_jpeg_message = (int) JMSG_LASTMSGCODE - 1;
+
+  err->addon_message_table = NULL;
+  err->first_addon_message = 0;	/* for safety */
+  err->last_addon_message = 0;
+
+  return err;
+}
diff --git a/codemp/jpeg-6/jerror.h b/codemp/jpeg-6/jerror.h
new file mode 100644
index 0000000..0ffb8b4
--- /dev/null
+++ b/codemp/jpeg-6/jerror.h
@@ -0,0 +1,273 @@
+/*
+ * jerror.h
+ *
+ * Copyright (C) 1994-1995, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file defines the error and message codes for the JPEG library.
+ * Edit this file to add new codes, or to translate the message strings to
+ * some other language.
+ * A set of error-reporting macros are defined too.  Some applications using
+ * the JPEG library may wish to include this file to get the error codes
+ * and/or the macros.
+ */
+
+/*
+ * To define the enum list of message codes, include this file without
+ * defining macro JMESSAGE.  To create a message string table, include it
+ * again with a suitable JMESSAGE definition (see jerror.c for an example).
+ */
+#ifndef JMESSAGE
+#ifndef JERROR_H
+/* First time through, define the enum list */
+#define JMAKE_ENUM_LIST
+#else
+/* Repeated inclusions of this file are no-ops unless JMESSAGE is defined */
+#define JMESSAGE(code,string)
+#endif /* JERROR_H */
+#endif /* JMESSAGE */
+
+#ifdef JMAKE_ENUM_LIST
+
+typedef enum {
+
+#define JMESSAGE(code,string)	code ,
+
+#endif /* JMAKE_ENUM_LIST */
+
+JMESSAGE(JMSG_NOMESSAGE, "Bogus message code %d") /* Must be first entry! */
+
+/* For maintenance convenience, list is alphabetical by message code name */
+JMESSAGE(JERR_ARITH_NOTIMPL,
+	 "Sorry, there are legal restrictions on arithmetic coding")
+JMESSAGE(JERR_BAD_ALIGN_TYPE, "ALIGN_TYPE is wrong, please fix")
+JMESSAGE(JERR_BAD_ALLOC_CHUNK, "MAX_ALLOC_CHUNK is wrong, please fix")
+JMESSAGE(JERR_BAD_BUFFER_MODE, "Bogus buffer control mode")
+JMESSAGE(JERR_BAD_COMPONENT_ID, "Invalid component ID %d in SOS")
+JMESSAGE(JERR_BAD_DCTSIZE, "IDCT output block size %d not supported")
+JMESSAGE(JERR_BAD_IN_COLORSPACE, "Bogus input colorspace")
+JMESSAGE(JERR_BAD_J_COLORSPACE, "Bogus JPEG colorspace")
+JMESSAGE(JERR_BAD_LENGTH, "Bogus marker length")
+JMESSAGE(JERR_BAD_MCU_SIZE, "Sampling factors too large for interleaved scan")
+JMESSAGE(JERR_BAD_POOL_ID, "Invalid memory pool code %d")
+JMESSAGE(JERR_BAD_PRECISION, "Unsupported JPEG data precision %d")
+JMESSAGE(JERR_BAD_PROGRESSION,
+	 "Invalid progressive parameters Ss=%d Se=%d Ah=%d Al=%d")
+JMESSAGE(JERR_BAD_PROG_SCRIPT,
+	 "Invalid progressive parameters at scan script entry %d")
+JMESSAGE(JERR_BAD_SAMPLING, "Bogus sampling factors")
+JMESSAGE(JERR_BAD_SCAN_SCRIPT, "Invalid scan script at entry %d")
+JMESSAGE(JERR_BAD_STATE, "Improper call to JPEG library in state %d")
+JMESSAGE(JERR_BAD_VIRTUAL_ACCESS, "Bogus virtual array access")
+JMESSAGE(JERR_BUFFER_SIZE, "Buffer passed to JPEG library is too small")
+JMESSAGE(JERR_CANT_SUSPEND, "Suspension not allowed here")
+JMESSAGE(JERR_CCIR601_NOTIMPL, "CCIR601 sampling not implemented yet")
+JMESSAGE(JERR_COMPONENT_COUNT, "Too many color components: %d, max %d")
+JMESSAGE(JERR_CONVERSION_NOTIMPL, "Unsupported color conversion request")
+JMESSAGE(JERR_DAC_INDEX, "Bogus DAC index %d")
+JMESSAGE(JERR_DAC_VALUE, "Bogus DAC value 0x%x")
+JMESSAGE(JERR_DHT_COUNTS, "Bogus DHT counts")
+JMESSAGE(JERR_DHT_INDEX, "Bogus DHT index %d")
+JMESSAGE(JERR_DQT_INDEX, "Bogus DQT index %d")
+JMESSAGE(JERR_EMPTY_IMAGE, "Empty JPEG image (DNL not supported)")
+JMESSAGE(JERR_EMS_READ, "Read from EMS failed")
+JMESSAGE(JERR_EMS_WRITE, "Write to EMS failed")
+JMESSAGE(JERR_EOI_EXPECTED, "Didn't expect more than one scan")
+JMESSAGE(JERR_FILE_READ, "Input file read error")
+JMESSAGE(JERR_FILE_WRITE, "Output file write error --- out of disk space?")
+JMESSAGE(JERR_FRACT_SAMPLE_NOTIMPL, "Fractional sampling not implemented yet")
+JMESSAGE(JERR_HUFF_CLEN_OVERFLOW, "Huffman code size table overflow")
+JMESSAGE(JERR_HUFF_MISSING_CODE, "Missing Huffman code table entry")
+JMESSAGE(JERR_IMAGE_TOO_BIG, "Maximum supported image dimension is %u pixels")
+JMESSAGE(JERR_INPUT_EMPTY, "Empty input file")
+JMESSAGE(JERR_INPUT_EOF, "Premature end of input file")
+JMESSAGE(JERR_MISMATCHED_QUANT_TABLE,
+	 "Cannot transcode due to multiple use of quantization table %d")
+JMESSAGE(JERR_MISSING_DATA, "Scan script does not transmit all data")
+JMESSAGE(JERR_MODE_CHANGE, "Invalid color quantization mode change")
+JMESSAGE(JERR_NOTIMPL, "Not implemented yet")
+JMESSAGE(JERR_NOT_COMPILED, "Requested feature was omitted at compile time")
+JMESSAGE(JERR_NO_BACKING_STORE, "Backing store not supported")
+JMESSAGE(JERR_NO_HUFF_TABLE, "Huffman table 0x%02x was not defined")
+JMESSAGE(JERR_NO_IMAGE, "JPEG datastream contains no image")
+JMESSAGE(JERR_NO_QUANT_TABLE, "Quantization table 0x%02x was not defined")
+JMESSAGE(JERR_NO_SOI, "Not a JPEG file: starts with 0x%02x 0x%02x")
+JMESSAGE(JERR_OUT_OF_MEMORY, "Insufficient memory (case %d)")
+JMESSAGE(JERR_QUANT_COMPONENTS,
+	 "Cannot quantize more than %d color components")
+JMESSAGE(JERR_QUANT_FEW_COLORS, "Cannot quantize to fewer than %d colors")
+JMESSAGE(JERR_QUANT_MANY_COLORS, "Cannot quantize to more than %d colors")
+JMESSAGE(JERR_SOF_DUPLICATE, "Invalid JPEG file structure: two SOF markers")
+JMESSAGE(JERR_SOF_NO_SOS, "Invalid JPEG file structure: missing SOS marker")
+JMESSAGE(JERR_SOF_UNSUPPORTED, "Unsupported JPEG process: SOF type 0x%02x")
+JMESSAGE(JERR_SOI_DUPLICATE, "Invalid JPEG file structure: two SOI markers")
+JMESSAGE(JERR_SOS_NO_SOF, "Invalid JPEG file structure: SOS before SOF")
+JMESSAGE(JERR_TFILE_CREATE, "Failed to create temporary file %s")
+JMESSAGE(JERR_TFILE_READ, "Read failed on temporary file")
+JMESSAGE(JERR_TFILE_SEEK, "Seek failed on temporary file")
+JMESSAGE(JERR_TFILE_WRITE,
+	 "Write failed on temporary file --- out of disk space?")
+JMESSAGE(JERR_TOO_LITTLE_DATA, "Application transferred too few scanlines")
+JMESSAGE(JERR_UNKNOWN_MARKER, "Unsupported marker type 0x%02x")
+JMESSAGE(JERR_VIRTUAL_BUG, "Virtual array controller messed up")
+JMESSAGE(JERR_WIDTH_OVERFLOW, "Image too wide for this implementation")
+JMESSAGE(JERR_XMS_READ, "Read from XMS failed")
+JMESSAGE(JERR_XMS_WRITE, "Write to XMS failed")
+JMESSAGE(JMSG_COPYRIGHT, JCOPYRIGHT)
+JMESSAGE(JMSG_VERSION, JVERSION)
+JMESSAGE(JTRC_16BIT_TABLES,
+	 "Caution: quantization tables are too coarse for baseline JPEG")
+JMESSAGE(JTRC_ADOBE,
+	 "Adobe APP14 marker: version %d, flags 0x%04x 0x%04x, transform %d")
+JMESSAGE(JTRC_APP0, "Unknown APP0 marker (not JFIF), length %u")
+JMESSAGE(JTRC_APP14, "Unknown APP14 marker (not Adobe), length %u")
+JMESSAGE(JTRC_DAC, "Define Arithmetic Table 0x%02x: 0x%02x")
+JMESSAGE(JTRC_DHT, "Define Huffman Table 0x%02x")
+JMESSAGE(JTRC_DQT, "Define Quantization Table %d  precision %d")
+JMESSAGE(JTRC_DRI, "Define Restart Interval %u")
+JMESSAGE(JTRC_EMS_CLOSE, "Freed EMS handle %u")
+JMESSAGE(JTRC_EMS_OPEN, "Obtained EMS handle %u")
+JMESSAGE(JTRC_EOI, "End Of Image")
+JMESSAGE(JTRC_HUFFBITS, "        %3d %3d %3d %3d %3d %3d %3d %3d")
+JMESSAGE(JTRC_JFIF, "JFIF APP0 marker, density %dx%d  %d")
+JMESSAGE(JTRC_JFIF_BADTHUMBNAILSIZE,
+	 "Warning: thumbnail image size does not match data length %u")
+JMESSAGE(JTRC_JFIF_MINOR, "Unknown JFIF minor revision number %d.%02d")
+JMESSAGE(JTRC_JFIF_THUMBNAIL, "    with %d x %d thumbnail image")
+JMESSAGE(JTRC_MISC_MARKER, "Skipping marker 0x%02x, length %u")
+JMESSAGE(JTRC_PARMLESS_MARKER, "Unexpected marker 0x%02x")
+JMESSAGE(JTRC_QUANTVALS, "        %4u %4u %4u %4u %4u %4u %4u %4u")
+JMESSAGE(JTRC_QUANT_3_NCOLORS, "Quantizing to %d = %d*%d*%d colors")
+JMESSAGE(JTRC_QUANT_NCOLORS, "Quantizing to %d colors")
+JMESSAGE(JTRC_QUANT_SELECTED, "Selected %d colors for quantization")
+JMESSAGE(JTRC_RECOVERY_ACTION, "At marker 0x%02x, recovery action %d")
+JMESSAGE(JTRC_RST, "RST%d")
+JMESSAGE(JTRC_SMOOTH_NOTIMPL,
+	 "Smoothing not supported with nonstandard sampling ratios")
+JMESSAGE(JTRC_SOF, "Start Of Frame 0x%02x: width=%u, height=%u, components=%d")
+JMESSAGE(JTRC_SOF_COMPONENT, "    Component %d: %dhx%dv q=%d")
+JMESSAGE(JTRC_SOI, "Start of Image")
+JMESSAGE(JTRC_SOS, "Start Of Scan: %d components")
+JMESSAGE(JTRC_SOS_COMPONENT, "    Component %d: dc=%d ac=%d")
+JMESSAGE(JTRC_SOS_PARAMS, "  Ss=%d, Se=%d, Ah=%d, Al=%d")
+JMESSAGE(JTRC_TFILE_CLOSE, "Closed temporary file %s")
+JMESSAGE(JTRC_TFILE_OPEN, "Opened temporary file %s")
+JMESSAGE(JTRC_UNKNOWN_IDS,
+	 "Unrecognized component IDs %d %d %d, assuming YCbCr")
+JMESSAGE(JTRC_XMS_CLOSE, "Freed XMS handle %u")
+JMESSAGE(JTRC_XMS_OPEN, "Obtained XMS handle %u")
+JMESSAGE(JWRN_ADOBE_XFORM, "Unknown Adobe color transform code %d")
+JMESSAGE(JWRN_BOGUS_PROGRESSION,
+	 "Inconsistent progression sequence for component %d coefficient %d")
+JMESSAGE(JWRN_EXTRANEOUS_DATA,
+	 "Corrupt JPEG data: %u extraneous bytes before marker 0x%02x")
+JMESSAGE(JWRN_HIT_MARKER, "Corrupt JPEG data: premature end of data segment")
+JMESSAGE(JWRN_HUFF_BAD_CODE, "Corrupt JPEG data: bad Huffman code")
+JMESSAGE(JWRN_JFIF_MAJOR, "Warning: unknown JFIF revision number %d.%02d")
+JMESSAGE(JWRN_JPEG_EOF, "Premature end of JPEG file")
+JMESSAGE(JWRN_MUST_RESYNC,
+	 "Corrupt JPEG data: found marker 0x%02x instead of RST%d")
+JMESSAGE(JWRN_NOT_SEQUENTIAL, "Invalid SOS parameters for sequential JPEG")
+JMESSAGE(JWRN_TOO_MUCH_DATA, "Application transferred too many scanlines")
+
+#ifdef JMAKE_ENUM_LIST
+
+  JMSG_LASTMSGCODE
+} J_MESSAGE_CODE;
+
+#undef JMAKE_ENUM_LIST
+#endif /* JMAKE_ENUM_LIST */
+
+/* Zap JMESSAGE macro so that future re-inclusions do nothing by default */
+#undef JMESSAGE
+
+
+#ifndef JERROR_H
+#define JERROR_H
+
+/* Macros to simplify using the error and trace message stuff */
+/* The first parameter is either type of cinfo pointer */
+
+/* Fatal errors (print message and exit) */
+#define ERREXIT(cinfo,code)  \
+  ((cinfo)->err->msg_code = (code), \
+   (*(cinfo)->err->error_exit) ((j_common_ptr) (cinfo)))
+#define ERREXIT1(cinfo,code,p1)  \
+  ((cinfo)->err->msg_code = (code), \
+   (cinfo)->err->msg_parm.i[0] = (p1), \
+   (*(cinfo)->err->error_exit) ((j_common_ptr) (cinfo)))
+#define ERREXIT2(cinfo,code,p1,p2)  \
+  ((cinfo)->err->msg_code = (code), \
+   (cinfo)->err->msg_parm.i[0] = (p1), \
+   (cinfo)->err->msg_parm.i[1] = (p2), \
+   (*(cinfo)->err->error_exit) ((j_common_ptr) (cinfo)))
+#define ERREXIT3(cinfo,code,p1,p2,p3)  \
+  ((cinfo)->err->msg_code = (code), \
+   (cinfo)->err->msg_parm.i[0] = (p1), \
+   (cinfo)->err->msg_parm.i[1] = (p2), \
+   (cinfo)->err->msg_parm.i[2] = (p3), \
+   (*(cinfo)->err->error_exit) ((j_common_ptr) (cinfo)))
+#define ERREXIT4(cinfo,code,p1,p2,p3,p4)  \
+  ((cinfo)->err->msg_code = (code), \
+   (cinfo)->err->msg_parm.i[0] = (p1), \
+   (cinfo)->err->msg_parm.i[1] = (p2), \
+   (cinfo)->err->msg_parm.i[2] = (p3), \
+   (cinfo)->err->msg_parm.i[3] = (p4), \
+   (*(cinfo)->err->error_exit) ((j_common_ptr) (cinfo)))
+#define ERREXITS(cinfo,code,str)  \
+  ((cinfo)->err->msg_code = (code), \
+   strncpy((cinfo)->err->msg_parm.s, (str), JMSG_STR_PARM_MAX), \
+   (*(cinfo)->err->error_exit) ((j_common_ptr) (cinfo)))
+
+#define MAKESTMT(stuff)		do { stuff } while (0)
+
+/* Nonfatal errors (we can keep going, but the data is probably corrupt) */
+#define WARNMS(cinfo,code)  \
+  ((cinfo)->err->msg_code = (code), \
+   (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), -1))
+#define WARNMS1(cinfo,code,p1)  \
+  ((cinfo)->err->msg_code = (code), \
+   (cinfo)->err->msg_parm.i[0] = (p1), \
+   (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), -1))
+#define WARNMS2(cinfo,code,p1,p2)  \
+  ((cinfo)->err->msg_code = (code), \
+   (cinfo)->err->msg_parm.i[0] = (p1), \
+   (cinfo)->err->msg_parm.i[1] = (p2), \
+   (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), -1))
+
+/* Informational/debugging messages */
+#define TRACEMS(cinfo,lvl,code)  \
+  ((cinfo)->err->msg_code = (code), \
+   (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), (lvl)))
+#define TRACEMS1(cinfo,lvl,code,p1)  \
+  ((cinfo)->err->msg_code = (code), \
+   (cinfo)->err->msg_parm.i[0] = (p1), \
+   (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), (lvl)))
+#define TRACEMS2(cinfo,lvl,code,p1,p2)  \
+  ((cinfo)->err->msg_code = (code), \
+   (cinfo)->err->msg_parm.i[0] = (p1), \
+   (cinfo)->err->msg_parm.i[1] = (p2), \
+   (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), (lvl)))
+#define TRACEMS3(cinfo,lvl,code,p1,p2,p3)  \
+  MAKESTMT(int * _mp = (cinfo)->err->msg_parm.i; \
+	   _mp[0] = (p1); _mp[1] = (p2); _mp[2] = (p3); \
+	   (cinfo)->err->msg_code = (code); \
+	   (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), (lvl)); )
+#define TRACEMS4(cinfo,lvl,code,p1,p2,p3,p4)  \
+  MAKESTMT(int * _mp = (cinfo)->err->msg_parm.i; \
+	   _mp[0] = (p1); _mp[1] = (p2); _mp[2] = (p3); _mp[3] = (p4); \
+	   (cinfo)->err->msg_code = (code); \
+	   (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), (lvl)); )
+#define TRACEMS8(cinfo,lvl,code,p1,p2,p3,p4,p5,p6,p7,p8)  \
+  MAKESTMT(int * _mp = (cinfo)->err->msg_parm.i; \
+	   _mp[0] = (p1); _mp[1] = (p2); _mp[2] = (p3); _mp[3] = (p4); \
+	   _mp[4] = (p5); _mp[5] = (p6); _mp[6] = (p7); _mp[7] = (p8); \
+	   (cinfo)->err->msg_code = (code); \
+	   (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), (lvl)); )
+#define TRACEMSS(cinfo,lvl,code,str)  \
+  ((cinfo)->err->msg_code = (code), \
+   strncpy((cinfo)->err->msg_parm.s, (str), JMSG_STR_PARM_MAX), \
+   (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), (lvl)))
+
+#endif /* JERROR_H */
diff --git a/codemp/jpeg-6/jfdctflt.cpp b/codemp/jpeg-6/jfdctflt.cpp
new file mode 100644
index 0000000..650f6c1
--- /dev/null
+++ b/codemp/jpeg-6/jfdctflt.cpp
@@ -0,0 +1,170 @@
+/*
+ * jfdctflt.c
+ *
+ * Copyright (C) 1994, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains a floating-point implementation of the
+ * forward DCT (Discrete Cosine Transform).
+ *
+ * This implementation should be more accurate than either of the integer
+ * DCT implementations.  However, it may not give the same results on all
+ * machines because of differences in roundoff behavior.  Speed will depend
+ * on the hardware's floating point capacity.
+ *
+ * A 2-D DCT can be done by 1-D DCT on each row followed by 1-D DCT
+ * on each column.  Direct algorithms are also available, but they are
+ * much more complex and seem not to be any faster when reduced to code.
+ *
+ * This implementation is based on Arai, Agui, and Nakajima's algorithm for
+ * scaled DCT.  Their original paper (Trans. IEICE E-71(11):1095) is in
+ * Japanese, but the algorithm is described in the Pennebaker & Mitchell
+ * JPEG textbook (see REFERENCES section in file README).  The following code
+ * is based directly on figure 4-8 in P&M.
+ * While an 8-point DCT cannot be done in less than 11 multiplies, it is
+ * possible to arrange the computation so that many of the multiplies are
+ * simple scalings of the final outputs.  These multiplies can then be
+ * folded into the multiplications or divisions by the JPEG quantization
+ * table entries.  The AA&N method leaves only 5 multiplies and 29 adds
+ * to be done in the DCT itself.
+ * The primary disadvantage of this method is that with a fixed-point
+ * implementation, accuracy is lost due to imprecise representation of the
+ * scaled quantization values.  However, that problem does not arise if
+ * we use floating point arithmetic.
+ */
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jdct.h"		/* Private declarations for DCT subsystem */
+
+#ifdef DCT_FLOAT_SUPPORTED
+
+
+/*
+ * This module is specialized to the case DCTSIZE = 8.
+ */
+
+#if DCTSIZE != 8
+  Sorry, this code only copes with 8x8 DCTs. /* deliberate syntax err */
+#endif
+
+
+/*
+ * Perform the forward DCT on one block of samples.
+ */
+
+GLOBAL void
+jpeg_fdct_float (FAST_FLOAT * data)
+{
+  FAST_FLOAT tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
+  FAST_FLOAT tmp10, tmp11, tmp12, tmp13;
+  FAST_FLOAT z1, z2, z3, z4, z5, z11, z13;
+  FAST_FLOAT *dataptr;
+  int ctr;
+
+  /* Pass 1: process rows. */
+
+  dataptr = data;
+  for (ctr = DCTSIZE-1; ctr >= 0; ctr--) {
+    tmp0 = dataptr[0] + dataptr[7];
+    tmp7 = dataptr[0] - dataptr[7];
+    tmp1 = dataptr[1] + dataptr[6];
+    tmp6 = dataptr[1] - dataptr[6];
+    tmp2 = dataptr[2] + dataptr[5];
+    tmp5 = dataptr[2] - dataptr[5];
+    tmp3 = dataptr[3] + dataptr[4];
+    tmp4 = dataptr[3] - dataptr[4];
+    
+    /* Even part */
+    
+    tmp10 = tmp0 + tmp3;	/* phase 2 */
+    tmp13 = tmp0 - tmp3;
+    tmp11 = tmp1 + tmp2;
+    tmp12 = tmp1 - tmp2;
+    
+    dataptr[0] = tmp10 + tmp11; /* phase 3 */
+    dataptr[4] = tmp10 - tmp11;
+    
+    z1 = (tmp12 + tmp13) * ((FAST_FLOAT) 0.707106781); /* c4 */
+    dataptr[2] = tmp13 + z1;	/* phase 5 */
+    dataptr[6] = tmp13 - z1;
+    
+    /* Odd part */
+
+    tmp10 = tmp4 + tmp5;	/* phase 2 */
+    tmp11 = tmp5 + tmp6;
+    tmp12 = tmp6 + tmp7;
+
+    /* The rotator is modified from fig 4-8 to avoid extra negations. */
+    z5 = (tmp10 - tmp12) * ((FAST_FLOAT) 0.382683433); /* c6 */
+    z2 = ((FAST_FLOAT) 0.541196100) * tmp10 + z5; /* c2-c6 */
+    z4 = ((FAST_FLOAT) 1.306562965) * tmp12 + z5; /* c2+c6 */
+    z3 = tmp11 * ((FAST_FLOAT) 0.707106781); /* c4 */
+
+    z11 = tmp7 + z3;		/* phase 5 */
+    z13 = tmp7 - z3;
+
+    dataptr[5] = z13 + z2;	/* phase 6 */
+    dataptr[3] = z13 - z2;
+    dataptr[1] = z11 + z4;
+    dataptr[7] = z11 - z4;
+
+    dataptr += DCTSIZE;		/* advance pointer to next row */
+  }
+
+  /* Pass 2: process columns. */
+
+  dataptr = data;
+  for (ctr = DCTSIZE-1; ctr >= 0; ctr--) {
+    tmp0 = dataptr[DCTSIZE*0] + dataptr[DCTSIZE*7];
+    tmp7 = dataptr[DCTSIZE*0] - dataptr[DCTSIZE*7];
+    tmp1 = dataptr[DCTSIZE*1] + dataptr[DCTSIZE*6];
+    tmp6 = dataptr[DCTSIZE*1] - dataptr[DCTSIZE*6];
+    tmp2 = dataptr[DCTSIZE*2] + dataptr[DCTSIZE*5];
+    tmp5 = dataptr[DCTSIZE*2] - dataptr[DCTSIZE*5];
+    tmp3 = dataptr[DCTSIZE*3] + dataptr[DCTSIZE*4];
+    tmp4 = dataptr[DCTSIZE*3] - dataptr[DCTSIZE*4];
+    
+    /* Even part */
+    
+    tmp10 = tmp0 + tmp3;	/* phase 2 */
+    tmp13 = tmp0 - tmp3;
+    tmp11 = tmp1 + tmp2;
+    tmp12 = tmp1 - tmp2;
+    
+    dataptr[DCTSIZE*0] = tmp10 + tmp11; /* phase 3 */
+    dataptr[DCTSIZE*4] = tmp10 - tmp11;
+    
+    z1 = (tmp12 + tmp13) * ((FAST_FLOAT) 0.707106781); /* c4 */
+    dataptr[DCTSIZE*2] = tmp13 + z1; /* phase 5 */
+    dataptr[DCTSIZE*6] = tmp13 - z1;
+    
+    /* Odd part */
+
+    tmp10 = tmp4 + tmp5;	/* phase 2 */
+    tmp11 = tmp5 + tmp6;
+    tmp12 = tmp6 + tmp7;
+
+    /* The rotator is modified from fig 4-8 to avoid extra negations. */
+    z5 = (tmp10 - tmp12) * ((FAST_FLOAT) 0.382683433); /* c6 */
+    z2 = ((FAST_FLOAT) 0.541196100) * tmp10 + z5; /* c2-c6 */
+    z4 = ((FAST_FLOAT) 1.306562965) * tmp12 + z5; /* c2+c6 */
+    z3 = tmp11 * ((FAST_FLOAT) 0.707106781); /* c4 */
+
+    z11 = tmp7 + z3;		/* phase 5 */
+    z13 = tmp7 - z3;
+
+    dataptr[DCTSIZE*5] = z13 + z2; /* phase 6 */
+    dataptr[DCTSIZE*3] = z13 - z2;
+    dataptr[DCTSIZE*1] = z11 + z4;
+    dataptr[DCTSIZE*7] = z11 - z4;
+
+    dataptr++;			/* advance pointer to next column */
+  }
+}
+
+#endif /* DCT_FLOAT_SUPPORTED */
diff --git a/codemp/jpeg-6/jidctflt.cpp b/codemp/jpeg-6/jidctflt.cpp
new file mode 100644
index 0000000..9415d25
--- /dev/null
+++ b/codemp/jpeg-6/jidctflt.cpp
@@ -0,0 +1,243 @@
+/*
+ * jidctflt.c
+ *
+ * Copyright (C) 1994, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains a floating-point implementation of the
+ * inverse DCT (Discrete Cosine Transform).  In the IJG code, this routine
+ * must also perform dequantization of the input coefficients.
+ *
+ * This implementation should be more accurate than either of the integer
+ * IDCT implementations.  However, it may not give the same results on all
+ * machines because of differences in roundoff behavior.  Speed will depend
+ * on the hardware's floating point capacity.
+ *
+ * A 2-D IDCT can be done by 1-D IDCT on each column followed by 1-D IDCT
+ * on each row (or vice versa, but it's more convenient to emit a row at
+ * a time).  Direct algorithms are also available, but they are much more
+ * complex and seem not to be any faster when reduced to code.
+ *
+ * This implementation is based on Arai, Agui, and Nakajima's algorithm for
+ * scaled DCT.  Their original paper (Trans. IEICE E-71(11):1095) is in
+ * Japanese, but the algorithm is described in the Pennebaker & Mitchell
+ * JPEG textbook (see REFERENCES section in file README).  The following code
+ * is based directly on figure 4-8 in P&M.
+ * While an 8-point DCT cannot be done in less than 11 multiplies, it is
+ * possible to arrange the computation so that many of the multiplies are
+ * simple scalings of the final outputs.  These multiplies can then be
+ * folded into the multiplications or divisions by the JPEG quantization
+ * table entries.  The AA&N method leaves only 5 multiplies and 29 adds
+ * to be done in the DCT itself.
+ * The primary disadvantage of this method is that with a fixed-point
+ * implementation, accuracy is lost due to imprecise representation of the
+ * scaled quantization values.  However, that problem does not arise if
+ * we use floating point arithmetic.
+ */
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jdct.h"		/* Private declarations for DCT subsystem */
+
+#ifdef DCT_FLOAT_SUPPORTED
+
+
+/*
+ * This module is specialized to the case DCTSIZE = 8.
+ */
+
+#if DCTSIZE != 8
+  Sorry, this code only copes with 8x8 DCTs. /* deliberate syntax err */
+#endif
+
+
+/* Dequantize a coefficient by multiplying it by the multiplier-table
+ * entry; produce a float result.
+ */
+
+#define DEQUANTIZE(coef,quantval)  (((FAST_FLOAT) (coef)) * (quantval))
+
+
+/*
+ * Perform dequantization and inverse DCT on one block of coefficients.
+ */
+
+GLOBAL void
+jpeg_idct_float (j_decompress_ptr cinfo, jpeg_component_info * compptr,
+		 JCOEFPTR coef_block,
+		 JSAMPARRAY output_buf, JDIMENSION output_col)
+{
+  FAST_FLOAT tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
+  FAST_FLOAT tmp10, tmp11, tmp12, tmp13;
+  FAST_FLOAT z5, z10, z11, z12, z13;
+  JCOEFPTR inptr;
+  FLOAT_MULT_TYPE * quantptr;
+  FAST_FLOAT * wsptr;
+  JSAMPROW outptr;
+  JSAMPLE *range_limit = IDCT_range_limit(cinfo);
+  int ctr;
+  FAST_FLOAT workspace[DCTSIZE2]; /* buffers data between passes */
+  SHIFT_TEMPS
+
+  /* Pass 1: process columns from input, store into work array. */
+
+  inptr = coef_block;
+  quantptr = (FLOAT_MULT_TYPE *) compptr->dct_table;
+  wsptr = workspace;
+  for (ctr = DCTSIZE; ctr > 0; ctr--) {
+    /* Due to quantization, we will usually find that many of the input
+     * coefficients are zero, especially the AC terms.  We can exploit this
+     * by short-circuiting the IDCT calculation for any column in which all
+     * the AC terms are zero.  In that case each output is equal to the
+     * DC coefficient (with scale factor as needed).
+     * With typical images and quantization tables, half or more of the
+     * column DCT calculations can be simplified this way.
+     */
+    
+    if ((inptr[DCTSIZE*1] | inptr[DCTSIZE*2] | inptr[DCTSIZE*3] |
+	 inptr[DCTSIZE*4] | inptr[DCTSIZE*5] | inptr[DCTSIZE*6] |
+	 inptr[DCTSIZE*7]) == 0) {
+      /* AC terms all zero */
+      FAST_FLOAT dcval = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
+      
+      wsptr[DCTSIZE*0] = dcval;
+      wsptr[DCTSIZE*1] = dcval;
+      wsptr[DCTSIZE*2] = dcval;
+      wsptr[DCTSIZE*3] = dcval;
+      wsptr[DCTSIZE*4] = dcval;
+      wsptr[DCTSIZE*5] = dcval;
+      wsptr[DCTSIZE*6] = dcval;
+      wsptr[DCTSIZE*7] = dcval;
+      
+      inptr++;			/* advance pointers to next column */
+      quantptr++;
+      wsptr++;
+      continue;
+    }
+    
+    /* Even part */
+
+    tmp0 = DEQUANTIZE(inptr[DCTSIZE*0], quantptr[DCTSIZE*0]);
+    tmp1 = DEQUANTIZE(inptr[DCTSIZE*2], quantptr[DCTSIZE*2]);
+    tmp2 = DEQUANTIZE(inptr[DCTSIZE*4], quantptr[DCTSIZE*4]);
+    tmp3 = DEQUANTIZE(inptr[DCTSIZE*6], quantptr[DCTSIZE*6]);
+
+    tmp10 = tmp0 + tmp2;	/* phase 3 */
+    tmp11 = tmp0 - tmp2;
+
+    tmp13 = tmp1 + tmp3;	/* phases 5-3 */
+    tmp12 = (tmp1 - tmp3) * ((FAST_FLOAT) 1.414213562) - tmp13; /* 2*c4 */
+
+    tmp0 = tmp10 + tmp13;	/* phase 2 */
+    tmp3 = tmp10 - tmp13;
+    tmp1 = tmp11 + tmp12;
+    tmp2 = tmp11 - tmp12;
+    
+    /* Odd part */
+
+    tmp4 = DEQUANTIZE(inptr[DCTSIZE*1], quantptr[DCTSIZE*1]);
+    tmp5 = DEQUANTIZE(inptr[DCTSIZE*3], quantptr[DCTSIZE*3]);
+    tmp6 = DEQUANTIZE(inptr[DCTSIZE*5], quantptr[DCTSIZE*5]);
+    tmp7 = DEQUANTIZE(inptr[DCTSIZE*7], quantptr[DCTSIZE*7]);
+
+    z13 = tmp6 + tmp5;		/* phase 6 */
+    z10 = tmp6 - tmp5;
+    z11 = tmp4 + tmp7;
+    z12 = tmp4 - tmp7;
+
+    tmp7 = z11 + z13;		/* phase 5 */
+    tmp11 = (z11 - z13) * ((FAST_FLOAT) 1.414213562); /* 2*c4 */
+
+    z5 = (z10 + z12) * ((FAST_FLOAT) 1.847759065); /* 2*c2 */
+    tmp10 = ((FAST_FLOAT) 1.082392200) * z12 - z5; /* 2*(c2-c6) */
+    tmp12 = ((FAST_FLOAT) -2.613125930) * z10 + z5; /* -2*(c2+c6) */
+
+    tmp6 = tmp12 - tmp7;	/* phase 2 */
+    tmp5 = tmp11 - tmp6;
+    tmp4 = tmp10 + tmp5;
+
+    wsptr[DCTSIZE*0] = tmp0 + tmp7;
+    wsptr[DCTSIZE*7] = tmp0 - tmp7;
+    wsptr[DCTSIZE*1] = tmp1 + tmp6;
+    wsptr[DCTSIZE*6] = tmp1 - tmp6;
+    wsptr[DCTSIZE*2] = tmp2 + tmp5;
+    wsptr[DCTSIZE*5] = tmp2 - tmp5;
+    wsptr[DCTSIZE*4] = tmp3 + tmp4;
+    wsptr[DCTSIZE*3] = tmp3 - tmp4;
+
+    inptr++;			/* advance pointers to next column */
+    quantptr++;
+    wsptr++;
+  }
+  
+  /* Pass 2: process rows from work array, store into output array. */
+  /* Note that we must descale the results by a factor of 8 == 2**3. */
+
+  wsptr = workspace;
+  for (ctr = 0; ctr < DCTSIZE; ctr++) {
+    outptr = output_buf[ctr] + output_col;
+    /* Rows of zeroes can be exploited in the same way as we did with columns.
+     * However, the column calculation has created many nonzero AC terms, so
+     * the simplification applies less often (typically 5% to 10% of the time).
+     * And testing floats for zero is relatively expensive, so we don't bother.
+     */
+    
+    /* Even part */
+
+    tmp10 = wsptr[0] + wsptr[4];
+    tmp11 = wsptr[0] - wsptr[4];
+
+    tmp13 = wsptr[2] + wsptr[6];
+    tmp12 = (wsptr[2] - wsptr[6]) * ((FAST_FLOAT) 1.414213562) - tmp13;
+
+    tmp0 = tmp10 + tmp13;
+    tmp3 = tmp10 - tmp13;
+    tmp1 = tmp11 + tmp12;
+    tmp2 = tmp11 - tmp12;
+
+    /* Odd part */
+
+    z13 = wsptr[5] + wsptr[3];
+    z10 = wsptr[5] - wsptr[3];
+    z11 = wsptr[1] + wsptr[7];
+    z12 = wsptr[1] - wsptr[7];
+
+    tmp7 = z11 + z13;
+    tmp11 = (z11 - z13) * ((FAST_FLOAT) 1.414213562);
+
+    z5 = (z10 + z12) * ((FAST_FLOAT) 1.847759065); /* 2*c2 */
+    tmp10 = ((FAST_FLOAT) 1.082392200) * z12 - z5; /* 2*(c2-c6) */
+    tmp12 = ((FAST_FLOAT) -2.613125930) * z10 + z5; /* -2*(c2+c6) */
+
+    tmp6 = tmp12 - tmp7;
+    tmp5 = tmp11 - tmp6;
+    tmp4 = tmp10 + tmp5;
+
+    /* Final output stage: scale down by a factor of 8 and range-limit */
+
+    outptr[0] = range_limit[(int) DESCALE((INT32) (tmp0 + tmp7), 3)
+			    & RANGE_MASK];
+    outptr[7] = range_limit[(int) DESCALE((INT32) (tmp0 - tmp7), 3)
+			    & RANGE_MASK];
+    outptr[1] = range_limit[(int) DESCALE((INT32) (tmp1 + tmp6), 3)
+			    & RANGE_MASK];
+    outptr[6] = range_limit[(int) DESCALE((INT32) (tmp1 - tmp6), 3)
+			    & RANGE_MASK];
+    outptr[2] = range_limit[(int) DESCALE((INT32) (tmp2 + tmp5), 3)
+			    & RANGE_MASK];
+    outptr[5] = range_limit[(int) DESCALE((INT32) (tmp2 - tmp5), 3)
+			    & RANGE_MASK];
+    outptr[4] = range_limit[(int) DESCALE((INT32) (tmp3 + tmp4), 3)
+			    & RANGE_MASK];
+    outptr[3] = range_limit[(int) DESCALE((INT32) (tmp3 - tmp4), 3)
+			    & RANGE_MASK];
+    
+    wsptr += DCTSIZE;		/* advance pointer to next row */
+  }
+}
+
+#endif /* DCT_FLOAT_SUPPORTED */
diff --git a/codemp/jpeg-6/jinclude.h b/codemp/jpeg-6/jinclude.h
new file mode 100644
index 0000000..99f535d
--- /dev/null
+++ b/codemp/jpeg-6/jinclude.h
@@ -0,0 +1,116 @@
+/*
+ * jinclude.h
+ *
+ * Copyright (C) 1991-1994, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file exists to provide a single place to fix any problems with
+ * including the wrong system include files.  (Common problems are taken
+ * care of by the standard jconfig symbols, but on really weird systems
+ * you may have to edit this file.)
+ *
+ * NOTE: this file is NOT intended to be included by applications using the
+ * JPEG library.  Most applications need only include jpeglib.h.
+ */
+
+
+#ifdef _WIN32
+
+#pragma warning(disable : 4018)     // signed/unsigned mismatch
+#pragma warning(disable : 4032)
+#pragma warning(disable : 4051)
+#pragma warning(disable : 4057)		// slightly different base types
+#pragma warning(disable : 4100)		// unreferenced formal parameter
+#pragma warning(disable : 4115)
+#pragma warning(disable : 4125)		// decimal digit terminates octal escape sequence
+#pragma warning(disable : 4127)		// conditional expression is constant
+#pragma warning(disable : 4136)
+#pragma warning(disable : 4152)		// nonstandard extension, function/data pointer conversion in expression
+#pragma warning(disable : 4201)
+#pragma warning(disable : 4214)
+#pragma warning(disable : 4244)
+#pragma warning(disable : 4305)		// truncation from const double to float
+#pragma warning(disable : 4310)		// cast truncates constant value
+#pragma warning(disable:  4505) 	// unreferenced local function has been removed
+#pragma warning(disable : 4514)
+#pragma warning(disable : 4702)		// unreachable code
+#pragma warning(disable : 4711)		// selected for automatic inline expansion
+#pragma warning(disable : 4220)		// varargs matches remaining parameters
+#pragma warning(disable : 4761)		// integral size mismatch 
+#endif
+
+/* Include auto-config file to find out which system include files we need. */
+
+#include "../jpeg-6/jconfig.h"		/* auto configuration options */
+#define JCONFIG_INCLUDED	/* so that jpeglib.h doesn't do it again */
+
+/*
+ * We need the NULL macro and size_t typedef.
+ * On an ANSI-conforming system it is sufficient to include <stddef.h>.
+ * Otherwise, we get them from <stdlib.h> or <stdio.h>; we may have to
+ * pull in <sys/types.h> as well.
+ * Note that the core JPEG library does not require <stdio.h>;
+ * only the default error handler and data source/destination modules do.
+ * But we must pull it in because of the references to FILE in jpeglib.h.
+ * You can remove those references if you want to compile without <stdio.h>.
+ */
+
+#ifdef HAVE_STDDEF_H
+#include <stddef.h>
+#endif
+
+#ifdef HAVE_STDLIB_H
+#include <stdlib.h>
+#endif
+
+#ifdef NEED_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+
+#include <stdio.h>
+
+/*
+ * We need memory copying and zeroing functions, plus strncpy().
+ * ANSI and System V implementations declare these in <string.h>.
+ * BSD doesn't have the mem() functions, but it does have bcopy()/bzero().
+ * Some systems may declare memset and memcpy in <memory.h>.
+ *
+ * NOTE: we assume the size parameters to these functions are of type size_t.
+ * Change the casts in these macros if not!
+ */
+
+#ifdef NEED_BSD_STRINGS
+
+#include <strings.h>
+#define MEMZERO(target,size)	bzero((void *)(target), (size_t)(size))
+#define MEMCOPY(dest,src,size)	bcopy((const void *)(src), (void *)(dest), (size_t)(size))
+
+#else /* not BSD, assume ANSI/SysV string lib */
+
+#include <string.h>
+#define MEMZERO(target,size)	memset((void *)(target), 0, (size_t)(size))
+#define MEMCOPY(dest,src,size)	memcpy((void *)(dest), (const void *)(src), (size_t)(size))
+
+#endif
+
+/*
+ * In ANSI C, and indeed any rational implementation, size_t is also the
+ * type returned by sizeof().  However, it seems there are some irrational
+ * implementations out there, in which sizeof() returns an int even though
+ * size_t is defined as long or unsigned long.  To ensure consistent results
+ * we always use this SIZEOF() macro in place of using sizeof() directly.
+ */
+
+#define SIZEOF(object)	((size_t) sizeof(object))
+
+/*
+ * The modules that use fread() and fwrite() always invoke them through
+ * these macros.  On some systems you may need to twiddle the argument casts.
+ * CAUTION: argument order is different from underlying functions!
+ */
+
+#define JFREAD(file,buf,sizeofbuf)  \
+  ((size_t) fread((void *) (buf), (size_t) 1, (size_t) (sizeofbuf), (file)))
+#define JFWRITE(file,buf,sizeofbuf)  \
+  ((size_t) fwrite((const void *) (buf), (size_t) 1, (size_t) (sizeofbuf), (file)))
diff --git a/codemp/jpeg-6/jmemmgr.cpp b/codemp/jpeg-6/jmemmgr.cpp
new file mode 100644
index 0000000..a639b31
--- /dev/null
+++ b/codemp/jpeg-6/jmemmgr.cpp
@@ -0,0 +1,1117 @@
+/*
+ * jmemmgr.c
+ *
+ * Copyright (C) 1991-1995, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains the JPEG system-independent memory management
+ * routines.  This code is usable across a wide variety of machines; most
+ * of the system dependencies have been isolated in a separate file.
+ * The major functions provided here are:
+ *   * pool-based allocation and freeing of memory;
+ *   * policy decisions about how to divide available memory among the
+ *     virtual arrays;
+ *   * control logic for swapping virtual arrays between main memory and
+ *     backing storage.
+ * The separate system-dependent file provides the actual backing-storage
+ * access code, and it contains the policy decision about how much total
+ * main memory to use.
+ * This file is system-dependent in the sense that some of its functions
+ * are unnecessary in some systems.  For example, if there is enough virtual
+ * memory so that backing storage will never be used, much of the virtual
+ * array control logic could be removed.  (Of course, if you have that much
+ * memory then you shouldn't care about a little bit of unused code...)
+ */
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+#define JPEG_INTERNALS
+#define AM_MEMORY_MANAGER	/* we define jvirt_Xarray_control structs */
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jmemsys.h"		/* import the system-dependent declarations */
+
+#ifndef NO_GETENV
+#ifndef HAVE_STDLIB_H		/* <stdlib.h> should declare getenv() */
+extern char * getenv JPP((const char * name));
+#endif
+#endif
+
+
+/*
+ * Some important notes:
+ *   The allocation routines provided here must never return NULL.
+ *   They should exit to error_exit if unsuccessful.
+ *
+ *   It's not a good idea to try to merge the sarray and barray routines,
+ *   even though they are textually almost the same, because samples are
+ *   usually stored as bytes while coefficients are shorts or ints.  Thus,
+ *   in machines where byte pointers have a different representation from
+ *   word pointers, the resulting machine code could not be the same.
+ */
+
+
+/*
+ * Many machines require storage alignment: longs must start on 4-byte
+ * boundaries, doubles on 8-byte boundaries, etc.  On such machines, malloc()
+ * always returns pointers that are multiples of the worst-case alignment
+ * requirement, and we had better do so too.
+ * There isn't any really portable way to determine the worst-case alignment
+ * requirement.  This module assumes that the alignment requirement is
+ * multiples of sizeof(ALIGN_TYPE).
+ * By default, we define ALIGN_TYPE as double.  This is necessary on some
+ * workstations (where doubles really do need 8-byte alignment) and will work
+ * fine on nearly everything.  If your machine has lesser alignment needs,
+ * you can save a few bytes by making ALIGN_TYPE smaller.
+ * The only place I know of where this will NOT work is certain Macintosh
+ * 680x0 compilers that define double as a 10-byte IEEE extended float.
+ * Doing 10-byte alignment is counterproductive because longwords won't be
+ * aligned well.  Put "#define ALIGN_TYPE long" in jconfig.h if you have
+ * such a compiler.
+ */
+
+#ifndef ALIGN_TYPE		/* so can override from jconfig.h */
+#define ALIGN_TYPE  double
+#endif
+
+
+/*
+ * We allocate objects from "pools", where each pool is gotten with a single
+ * request to jpeg_get_small() or jpeg_get_large().  There is no per-object
+ * overhead within a pool, except for alignment padding.  Each pool has a
+ * header with a link to the next pool of the same class.
+ * Small and large pool headers are identical except that the latter's
+ * link pointer must be FAR on 80x86 machines.
+ * Notice that the "real" header fields are union'ed with a dummy ALIGN_TYPE
+ * field.  This forces the compiler to make SIZEOF(small_pool_hdr) a multiple
+ * of the alignment requirement of ALIGN_TYPE.
+ */
+
+typedef union small_pool_struct * small_pool_ptr;
+
+typedef union small_pool_struct {
+  struct {
+    small_pool_ptr next;	/* next in list of pools */
+    size_t bytes_used;		/* how many bytes already used within pool */
+    size_t bytes_left;		/* bytes still available in this pool */
+  } hdr;
+  ALIGN_TYPE dummy;		/* included in union to ensure alignment */
+} small_pool_hdr;
+
+typedef union large_pool_struct FAR * large_pool_ptr;
+
+typedef union large_pool_struct {
+  struct {
+    large_pool_ptr next;	/* next in list of pools */
+    size_t bytes_used;		/* how many bytes already used within pool */
+    size_t bytes_left;		/* bytes still available in this pool */
+  } hdr;
+  ALIGN_TYPE dummy;		/* included in union to ensure alignment */
+} large_pool_hdr;
+
+
+/*
+ * Here is the full definition of a memory manager object.
+ */
+
+typedef struct {
+  struct jpeg_memory_mgr pub;	/* public fields */
+
+  /* Each pool identifier (lifetime class) names a linked list of pools. */
+  small_pool_ptr small_list[JPOOL_NUMPOOLS];
+  large_pool_ptr large_list[JPOOL_NUMPOOLS];
+
+  /* Since we only have one lifetime class of virtual arrays, only one
+   * linked list is necessary (for each datatype).  Note that the virtual
+   * array control blocks being linked together are actually stored somewhere
+   * in the small-pool list.
+   */
+  jvirt_sarray_ptr virt_sarray_list;
+  jvirt_barray_ptr virt_barray_list;
+
+  /* This counts total space obtained from jpeg_get_small/large */
+  long total_space_allocated;
+
+  /* alloc_sarray and alloc_barray set this value for use by virtual
+   * array routines.
+   */
+  JDIMENSION last_rowsperchunk;	/* from most recent alloc_sarray/barray */
+} my_memory_mgr;
+
+typedef my_memory_mgr * my_mem_ptr;
+
+
+/*
+ * The control blocks for virtual arrays.
+ * Note that these blocks are allocated in the "small" pool area.
+ * System-dependent info for the associated backing store (if any) is hidden
+ * inside the backing_store_info struct.
+ */
+
+struct jvirt_sarray_control {
+  JSAMPARRAY mem_buffer;	/* => the in-memory buffer */
+  JDIMENSION rows_in_array;	/* total virtual array height */
+  JDIMENSION samplesperrow;	/* width of array (and of memory buffer) */
+  JDIMENSION maxaccess;		/* max rows accessed by access_virt_sarray */
+  JDIMENSION rows_in_mem;	/* height of memory buffer */
+  JDIMENSION rowsperchunk;	/* allocation chunk size in mem_buffer */
+  JDIMENSION cur_start_row;	/* first logical row # in the buffer */
+  JDIMENSION first_undef_row;	/* row # of first uninitialized row */
+  boolean pre_zero;		/* pre-zero mode requested? */
+  boolean dirty;		/* do current buffer contents need written? */
+  boolean b_s_open;		/* is backing-store data valid? */
+  jvirt_sarray_ptr next;	/* link to next virtual sarray control block */
+  backing_store_info b_s_info;	/* System-dependent control info */
+};
+
+struct jvirt_barray_control {
+  JBLOCKARRAY mem_buffer;	/* => the in-memory buffer */
+  JDIMENSION rows_in_array;	/* total virtual array height */
+  JDIMENSION blocksperrow;	/* width of array (and of memory buffer) */
+  JDIMENSION maxaccess;		/* max rows accessed by access_virt_barray */
+  JDIMENSION rows_in_mem;	/* height of memory buffer */
+  JDIMENSION rowsperchunk;	/* allocation chunk size in mem_buffer */
+  JDIMENSION cur_start_row;	/* first logical row # in the buffer */
+  JDIMENSION first_undef_row;	/* row # of first uninitialized row */
+  boolean pre_zero;		/* pre-zero mode requested? */
+  boolean dirty;		/* do current buffer contents need written? */
+  boolean b_s_open;		/* is backing-store data valid? */
+  jvirt_barray_ptr next;	/* link to next virtual barray control block */
+  backing_store_info b_s_info;	/* System-dependent control info */
+};
+
+
+#ifdef MEM_STATS		/* optional extra stuff for statistics */
+
+LOCAL void
+print_mem_stats (j_common_ptr cinfo, int pool_id)
+{
+  my_mem_ptr mem = (my_mem_ptr) cinfo->mem;
+  small_pool_ptr shdr_ptr;
+  large_pool_ptr lhdr_ptr;
+
+  /* Since this is only a debugging stub, we can cheat a little by using
+   * fprintf directly rather than going through the trace message code.
+   * This is helpful because message parm array can't handle longs.
+   */
+  fprintf(stderr, "Freeing pool %d, total space = %ld\n",
+	  pool_id, mem->total_space_allocated);
+
+  for (lhdr_ptr = mem->large_list[pool_id]; lhdr_ptr != NULL;
+       lhdr_ptr = lhdr_ptr->hdr.next) {
+    fprintf(stderr, "  Large chunk used %ld\n",
+	    (long) lhdr_ptr->hdr.bytes_used);
+  }
+
+  for (shdr_ptr = mem->small_list[pool_id]; shdr_ptr != NULL;
+       shdr_ptr = shdr_ptr->hdr.next) {
+    fprintf(stderr, "  Small chunk used %ld free %ld\n",
+	    (long) shdr_ptr->hdr.bytes_used,
+	    (long) shdr_ptr->hdr.bytes_left);
+  }
+}
+
+#endif /* MEM_STATS */
+
+
+LOCAL void
+out_of_memory (j_common_ptr cinfo, int which)
+/* Report an out-of-memory error and stop execution */
+/* If we compiled MEM_STATS support, report alloc requests before dying */
+{
+#ifdef MEM_STATS
+  cinfo->err->trace_level = 2;	/* force self_destruct to report stats */
+#endif
+  ERREXIT1(cinfo, JERR_OUT_OF_MEMORY, which);
+}
+
+
+/*
+ * Allocation of "small" objects.
+ *
+ * For these, we use pooled storage.  When a new pool must be created,
+ * we try to get enough space for the current request plus a "slop" factor,
+ * where the slop will be the amount of leftover space in the new pool.
+ * The speed vs. space tradeoff is largely determined by the slop values.
+ * A different slop value is provided for each pool class (lifetime),
+ * and we also distinguish the first pool of a class from later ones.
+ * NOTE: the values given work fairly well on both 16- and 32-bit-int
+ * machines, but may be too small if longs are 64 bits or more.
+ */
+
+static const size_t first_pool_slop[JPOOL_NUMPOOLS] = 
+{
+	1600,			/* first PERMANENT pool */
+	16000			/* first IMAGE pool */
+};
+
+static const size_t extra_pool_slop[JPOOL_NUMPOOLS] = 
+{
+	0,			/* additional PERMANENT pools */
+	5000			/* additional IMAGE pools */
+};
+
+#define MIN_SLOP  50		/* greater than 0 to avoid futile looping */
+
+
+METHODDEF void *
+alloc_small (j_common_ptr cinfo, int pool_id, size_t sizeofobject)
+/* Allocate a "small" object */
+{
+  my_mem_ptr mem = (my_mem_ptr) cinfo->mem;
+  small_pool_ptr hdr_ptr, prev_hdr_ptr;
+  char * data_ptr;
+  size_t odd_bytes, min_request, slop;
+
+  /* Check for unsatisfiable request (do now to ensure no overflow below) */
+  if (sizeofobject > (size_t) (MAX_ALLOC_CHUNK-SIZEOF(small_pool_hdr)))
+    out_of_memory(cinfo, 1);	/* request exceeds malloc's ability */
+
+  /* Round up the requested size to a multiple of SIZEOF(ALIGN_TYPE) */
+  odd_bytes = sizeofobject % SIZEOF(ALIGN_TYPE);
+  if (odd_bytes > 0)
+    sizeofobject += SIZEOF(ALIGN_TYPE) - odd_bytes;
+
+  /* See if space is available in any existing pool */
+  if (pool_id < 0 || pool_id >= JPOOL_NUMPOOLS)
+    ERREXIT1(cinfo, JERR_BAD_POOL_ID, pool_id);	/* safety check */
+  prev_hdr_ptr = NULL;
+  hdr_ptr = mem->small_list[pool_id];
+  while (hdr_ptr != NULL) {
+    if (hdr_ptr->hdr.bytes_left >= sizeofobject)
+      break;			/* found pool with enough space */
+    prev_hdr_ptr = hdr_ptr;
+    hdr_ptr = hdr_ptr->hdr.next;
+  }
+
+  /* Time to make a new pool? */
+  if (hdr_ptr == NULL) {
+    /* min_request is what we need now, slop is what will be leftover */
+    min_request = sizeofobject + SIZEOF(small_pool_hdr);
+    if (prev_hdr_ptr == NULL)	/* first pool in class? */
+      slop = first_pool_slop[pool_id];
+    else
+      slop = extra_pool_slop[pool_id];
+    /* Don't ask for more than MAX_ALLOC_CHUNK */
+    if (slop > (size_t) (MAX_ALLOC_CHUNK-min_request))
+      slop = (size_t) (MAX_ALLOC_CHUNK-min_request);
+    /* Try to get space, if fail reduce slop and try again */
+    for (;;) {
+      hdr_ptr = (small_pool_ptr) jpeg_get_small(cinfo, min_request + slop);
+      if (hdr_ptr != NULL)
+	break;
+      slop /= 2;
+      if (slop < MIN_SLOP)	/* give up when it gets real small */
+	out_of_memory(cinfo, 2); /* jpeg_get_small failed */
+    }
+    mem->total_space_allocated += min_request + slop;
+    /* Success, initialize the new pool header and add to end of list */
+    hdr_ptr->hdr.next = NULL;
+    hdr_ptr->hdr.bytes_used = 0;
+    hdr_ptr->hdr.bytes_left = sizeofobject + slop;
+    if (prev_hdr_ptr == NULL)	/* first pool in class? */
+      mem->small_list[pool_id] = hdr_ptr;
+    else
+      prev_hdr_ptr->hdr.next = hdr_ptr;
+  }
+
+  /* OK, allocate the object from the current pool */
+  data_ptr = (char *) (hdr_ptr + 1); /* point to first data byte in pool */
+  data_ptr += hdr_ptr->hdr.bytes_used; /* point to place for object */
+  hdr_ptr->hdr.bytes_used += sizeofobject;
+  hdr_ptr->hdr.bytes_left -= sizeofobject;
+
+  return (void *) data_ptr;
+}
+
+
+/*
+ * Allocation of "large" objects.
+ *
+ * The external semantics of these are the same as "small" objects,
+ * except that FAR pointers are used on 80x86.  However the pool
+ * management heuristics are quite different.  We assume that each
+ * request is large enough that it may as well be passed directly to
+ * jpeg_get_large; the pool management just links everything together
+ * so that we can free it all on demand.
+ * Note: the major use of "large" objects is in JSAMPARRAY and JBLOCKARRAY
+ * structures.  The routines that create these structures (see below)
+ * deliberately bunch rows together to ensure a large request size.
+ */
+
+METHODDEF void FAR *
+alloc_large (j_common_ptr cinfo, int pool_id, size_t sizeofobject)
+/* Allocate a "large" object */
+{
+  my_mem_ptr mem = (my_mem_ptr) cinfo->mem;
+  large_pool_ptr hdr_ptr;
+  size_t odd_bytes;
+
+  /* Check for unsatisfiable request (do now to ensure no overflow below) */
+  if (sizeofobject > (size_t) (MAX_ALLOC_CHUNK-SIZEOF(large_pool_hdr)))
+    out_of_memory(cinfo, 3);	/* request exceeds malloc's ability */
+
+  /* Round up the requested size to a multiple of SIZEOF(ALIGN_TYPE) */
+  odd_bytes = sizeofobject % SIZEOF(ALIGN_TYPE);
+  if (odd_bytes > 0)
+    sizeofobject += SIZEOF(ALIGN_TYPE) - odd_bytes;
+
+  /* Always make a new pool */
+  if (pool_id < 0 || pool_id >= JPOOL_NUMPOOLS)
+    ERREXIT1(cinfo, JERR_BAD_POOL_ID, pool_id);	/* safety check */
+
+  hdr_ptr = (large_pool_ptr) jpeg_get_large(cinfo, sizeofobject +
+					    SIZEOF(large_pool_hdr));
+  if (hdr_ptr == NULL)
+    out_of_memory(cinfo, 4);	/* jpeg_get_large failed */
+  mem->total_space_allocated += sizeofobject + SIZEOF(large_pool_hdr);
+
+  /* Success, initialize the new pool header and add to list */
+  hdr_ptr->hdr.next = mem->large_list[pool_id];
+  /* We maintain space counts in each pool header for statistical purposes,
+   * even though they are not needed for allocation.
+   */
+  hdr_ptr->hdr.bytes_used = sizeofobject;
+  hdr_ptr->hdr.bytes_left = 0;
+  mem->large_list[pool_id] = hdr_ptr;
+
+  return (void FAR *) (hdr_ptr + 1); /* point to first data byte in pool */
+}
+
+
+/*
+ * Creation of 2-D sample arrays.
+ * The pointers are in near heap, the samples themselves in FAR heap.
+ *
+ * To minimize allocation overhead and to allow I/O of large contiguous
+ * blocks, we allocate the sample rows in groups of as many rows as possible
+ * without exceeding MAX_ALLOC_CHUNK total bytes per allocation request.
+ * NB: the virtual array control routines, later in this file, know about
+ * this chunking of rows.  The rowsperchunk value is left in the mem manager
+ * object so that it can be saved away if this sarray is the workspace for
+ * a virtual array.
+ */
+
+METHODDEF JSAMPARRAY
+alloc_sarray (j_common_ptr cinfo, int pool_id,
+	      JDIMENSION samplesperrow, JDIMENSION numrows)
+/* Allocate a 2-D sample array */
+{
+  my_mem_ptr mem = (my_mem_ptr) cinfo->mem;
+  JSAMPARRAY result;
+  JSAMPROW workspace;
+  JDIMENSION rowsperchunk, currow, i;
+  long ltemp;
+
+  /* Calculate max # of rows allowed in one allocation chunk */
+  ltemp = (MAX_ALLOC_CHUNK-SIZEOF(large_pool_hdr)) /
+	  ((long) samplesperrow * SIZEOF(JSAMPLE));
+  if (ltemp <= 0)
+    ERREXIT(cinfo, JERR_WIDTH_OVERFLOW);
+  if (ltemp < (long) numrows)
+    rowsperchunk = (JDIMENSION) ltemp;
+  else
+    rowsperchunk = numrows;
+  mem->last_rowsperchunk = rowsperchunk;
+
+  /* Get space for row pointers (small object) */
+  result = (JSAMPARRAY) alloc_small(cinfo, pool_id,
+				    (size_t) (numrows * SIZEOF(JSAMPROW)));
+
+  /* Get the rows themselves (large objects) */
+  currow = 0;
+  while (currow < numrows) {
+    rowsperchunk = MIN(rowsperchunk, numrows - currow);
+    workspace = (JSAMPROW) alloc_large(cinfo, pool_id,
+	(size_t) ((size_t) rowsperchunk * (size_t) samplesperrow
+		  * SIZEOF(JSAMPLE)));
+    for (i = rowsperchunk; i > 0; i--) {
+      result[currow++] = workspace;
+      workspace += samplesperrow;
+    }
+  }
+
+  return result;
+}
+
+
+/*
+ * Creation of 2-D coefficient-block arrays.
+ * This is essentially the same as the code for sample arrays, above.
+ */
+
+METHODDEF JBLOCKARRAY
+alloc_barray (j_common_ptr cinfo, int pool_id,
+	      JDIMENSION blocksperrow, JDIMENSION numrows)
+/* Allocate a 2-D coefficient-block array */
+{
+  my_mem_ptr mem = (my_mem_ptr) cinfo->mem;
+  JBLOCKARRAY result;
+  JBLOCKROW workspace;
+  JDIMENSION rowsperchunk, currow, i;
+  long ltemp;
+
+  /* Calculate max # of rows allowed in one allocation chunk */
+  ltemp = (MAX_ALLOC_CHUNK-SIZEOF(large_pool_hdr)) /
+	  ((long) blocksperrow * SIZEOF(JBLOCK));
+  if (ltemp <= 0)
+    ERREXIT(cinfo, JERR_WIDTH_OVERFLOW);
+  if (ltemp < (long) numrows)
+    rowsperchunk = (JDIMENSION) ltemp;
+  else
+    rowsperchunk = numrows;
+  mem->last_rowsperchunk = rowsperchunk;
+
+  /* Get space for row pointers (small object) */
+  result = (JBLOCKARRAY) alloc_small(cinfo, pool_id,
+				     (size_t) (numrows * SIZEOF(JBLOCKROW)));
+
+  /* Get the rows themselves (large objects) */
+  currow = 0;
+  while (currow < numrows) {
+    rowsperchunk = MIN(rowsperchunk, numrows - currow);
+    workspace = (JBLOCKROW) alloc_large(cinfo, pool_id,
+	(size_t) ((size_t) rowsperchunk * (size_t) blocksperrow
+		  * SIZEOF(JBLOCK)));
+    for (i = rowsperchunk; i > 0; i--) {
+      result[currow++] = workspace;
+      workspace += blocksperrow;
+    }
+  }
+
+  return result;
+}
+
+
+/*
+ * About virtual array management:
+ *
+ * The above "normal" array routines are only used to allocate strip buffers
+ * (as wide as the image, but just a few rows high).  Full-image-sized buffers
+ * are handled as "virtual" arrays.  The array is still accessed a strip at a
+ * time, but the memory manager must save the whole array for repeated
+ * accesses.  The intended implementation is that there is a strip buffer in
+ * memory (as high as is possible given the desired memory limit), plus a
+ * backing file that holds the rest of the array.
+ *
+ * The request_virt_array routines are told the total size of the image and
+ * the maximum number of rows that will be accessed at once.  The in-memory
+ * buffer must be at least as large as the maxaccess value.
+ *
+ * The request routines create control blocks but not the in-memory buffers.
+ * That is postponed until realize_virt_arrays is called.  At that time the
+ * total amount of space needed is known (approximately, anyway), so free
+ * memory can be divided up fairly.
+ *
+ * The access_virt_array routines are responsible for making a specific strip
+ * area accessible (after reading or writing the backing file, if necessary).
+ * Note that the access routines are told whether the caller intends to modify
+ * the accessed strip; during a read-only pass this saves having to rewrite
+ * data to disk.  The access routines are also responsible for pre-zeroing
+ * any newly accessed rows, if pre-zeroing was requested.
+ *
+ * In current usage, the access requests are usually for nonoverlapping
+ * strips; that is, successive access start_row numbers differ by exactly
+ * num_rows = maxaccess.  This means we can get good performance with simple
+ * buffer dump/reload logic, by making the in-memory buffer be a multiple
+ * of the access height; then there will never be accesses across bufferload
+ * boundaries.  The code will still work with overlapping access requests,
+ * but it doesn't handle bufferload overlaps very efficiently.
+ */
+
+
+METHODDEF jvirt_sarray_ptr
+request_virt_sarray (j_common_ptr cinfo, int pool_id, boolean pre_zero,
+		     JDIMENSION samplesperrow, JDIMENSION numrows,
+		     JDIMENSION maxaccess)
+/* Request a virtual 2-D sample array */
+{
+  my_mem_ptr mem = (my_mem_ptr) cinfo->mem;
+  jvirt_sarray_ptr result;
+
+  /* Only IMAGE-lifetime virtual arrays are currently supported */
+  if (pool_id != JPOOL_IMAGE)
+    ERREXIT1(cinfo, JERR_BAD_POOL_ID, pool_id);	/* safety check */
+
+  /* get control block */
+  result = (jvirt_sarray_ptr) alloc_small(cinfo, pool_id,
+					  SIZEOF(struct jvirt_sarray_control));
+
+  result->mem_buffer = NULL;	/* marks array not yet realized */
+  result->rows_in_array = numrows;
+  result->samplesperrow = samplesperrow;
+  result->maxaccess = maxaccess;
+  result->pre_zero = pre_zero;
+  result->b_s_open = FALSE;	/* no associated backing-store object */
+  result->next = mem->virt_sarray_list; /* add to list of virtual arrays */
+  mem->virt_sarray_list = result;
+
+  return result;
+}
+
+
+METHODDEF jvirt_barray_ptr
+request_virt_barray (j_common_ptr cinfo, int pool_id, boolean pre_zero,
+		     JDIMENSION blocksperrow, JDIMENSION numrows,
+		     JDIMENSION maxaccess)
+/* Request a virtual 2-D coefficient-block array */
+{
+  my_mem_ptr mem = (my_mem_ptr) cinfo->mem;
+  jvirt_barray_ptr result;
+
+  /* Only IMAGE-lifetime virtual arrays are currently supported */
+  if (pool_id != JPOOL_IMAGE)
+    ERREXIT1(cinfo, JERR_BAD_POOL_ID, pool_id);	/* safety check */
+
+  /* get control block */
+  result = (jvirt_barray_ptr) alloc_small(cinfo, pool_id,
+					  SIZEOF(struct jvirt_barray_control));
+
+  result->mem_buffer = NULL;	/* marks array not yet realized */
+  result->rows_in_array = numrows;
+  result->blocksperrow = blocksperrow;
+  result->maxaccess = maxaccess;
+  result->pre_zero = pre_zero;
+  result->b_s_open = FALSE;	/* no associated backing-store object */
+  result->next = mem->virt_barray_list; /* add to list of virtual arrays */
+  mem->virt_barray_list = result;
+
+  return result;
+}
+
+
+METHODDEF void
+realize_virt_arrays (j_common_ptr cinfo)
+/* Allocate the in-memory buffers for any unrealized virtual arrays */
+{
+  my_mem_ptr mem = (my_mem_ptr) cinfo->mem;
+  long space_per_minheight, maximum_space, avail_mem;
+  long minheights, max_minheights;
+  jvirt_sarray_ptr sptr;
+  jvirt_barray_ptr bptr;
+
+  /* Compute the minimum space needed (maxaccess rows in each buffer)
+   * and the maximum space needed (full image height in each buffer).
+   * These may be of use to the system-dependent jpeg_mem_available routine.
+   */
+  space_per_minheight = 0;
+  maximum_space = 0;
+  for (sptr = mem->virt_sarray_list; sptr != NULL; sptr = sptr->next) {
+    if (sptr->mem_buffer == NULL) { /* if not realized yet */
+      space_per_minheight += (long) sptr->maxaccess *
+			     (long) sptr->samplesperrow * SIZEOF(JSAMPLE);
+      maximum_space += (long) sptr->rows_in_array *
+		       (long) sptr->samplesperrow * SIZEOF(JSAMPLE);
+    }
+  }
+  for (bptr = mem->virt_barray_list; bptr != NULL; bptr = bptr->next) {
+    if (bptr->mem_buffer == NULL) { /* if not realized yet */
+      space_per_minheight += (long) bptr->maxaccess *
+			     (long) bptr->blocksperrow * SIZEOF(JBLOCK);
+      maximum_space += (long) bptr->rows_in_array *
+		       (long) bptr->blocksperrow * SIZEOF(JBLOCK);
+    }
+  }
+
+  if (space_per_minheight <= 0)
+    return;			/* no unrealized arrays, no work */
+
+  /* Determine amount of memory to actually use; this is system-dependent. */
+  avail_mem = jpeg_mem_available(cinfo, space_per_minheight, maximum_space,
+				 mem->total_space_allocated);
+
+  /* If the maximum space needed is available, make all the buffers full
+   * height; otherwise parcel it out with the same number of minheights
+   * in each buffer.
+   */
+  if (avail_mem >= maximum_space)
+    max_minheights = 1000000000L;
+  else {
+    max_minheights = avail_mem / space_per_minheight;
+    /* If there doesn't seem to be enough space, try to get the minimum
+     * anyway.  This allows a "stub" implementation of jpeg_mem_available().
+     */
+    if (max_minheights <= 0)
+      max_minheights = 1;
+  }
+
+  /* Allocate the in-memory buffers and initialize backing store as needed. */
+
+  for (sptr = mem->virt_sarray_list; sptr != NULL; sptr = sptr->next) {
+    if (sptr->mem_buffer == NULL) { /* if not realized yet */
+      minheights = ((long) sptr->rows_in_array - 1L) / sptr->maxaccess + 1L;
+      if (minheights <= max_minheights) {
+	/* This buffer fits in memory */
+	sptr->rows_in_mem = sptr->rows_in_array;
+      } else {
+	/* It doesn't fit in memory, create backing store. */
+	sptr->rows_in_mem = (JDIMENSION) (max_minheights * sptr->maxaccess);
+	jpeg_open_backing_store(cinfo, & sptr->b_s_info,
+				(long) sptr->rows_in_array *
+				(long) sptr->samplesperrow *
+				(long) SIZEOF(JSAMPLE));
+	sptr->b_s_open = TRUE;
+      }
+      sptr->mem_buffer = alloc_sarray(cinfo, JPOOL_IMAGE,
+				      sptr->samplesperrow, sptr->rows_in_mem);
+      sptr->rowsperchunk = mem->last_rowsperchunk;
+      sptr->cur_start_row = 0;
+      sptr->first_undef_row = 0;
+      sptr->dirty = FALSE;
+    }
+  }
+
+  for (bptr = mem->virt_barray_list; bptr != NULL; bptr = bptr->next) {
+    if (bptr->mem_buffer == NULL) { /* if not realized yet */
+      minheights = ((long) bptr->rows_in_array - 1L) / bptr->maxaccess + 1L;
+      if (minheights <= max_minheights) {
+	/* This buffer fits in memory */
+	bptr->rows_in_mem = bptr->rows_in_array;
+      } else {
+	/* It doesn't fit in memory, create backing store. */
+	bptr->rows_in_mem = (JDIMENSION) (max_minheights * bptr->maxaccess);
+	jpeg_open_backing_store(cinfo, & bptr->b_s_info,
+				(long) bptr->rows_in_array *
+				(long) bptr->blocksperrow *
+				(long) SIZEOF(JBLOCK));
+	bptr->b_s_open = TRUE;
+      }
+      bptr->mem_buffer = alloc_barray(cinfo, JPOOL_IMAGE,
+				      bptr->blocksperrow, bptr->rows_in_mem);
+      bptr->rowsperchunk = mem->last_rowsperchunk;
+      bptr->cur_start_row = 0;
+      bptr->first_undef_row = 0;
+      bptr->dirty = FALSE;
+    }
+  }
+}
+
+
+LOCAL void
+do_sarray_io (j_common_ptr cinfo, jvirt_sarray_ptr ptr, boolean writing)
+/* Do backing store read or write of a virtual sample array */
+{
+  long bytesperrow, file_offset, byte_count, rows, thisrow, i;
+
+  bytesperrow = (long) ptr->samplesperrow * SIZEOF(JSAMPLE);
+  file_offset = ptr->cur_start_row * bytesperrow;
+  /* Loop to read or write each allocation chunk in mem_buffer */
+  for (i = 0; i < (long) ptr->rows_in_mem; i += ptr->rowsperchunk) {
+    /* One chunk, but check for short chunk at end of buffer */
+    rows = MIN((long) ptr->rowsperchunk, (long) ptr->rows_in_mem - i);
+    /* Transfer no more than is currently defined */
+    thisrow = (long) ptr->cur_start_row + i;
+    rows = MIN(rows, (long) ptr->first_undef_row - thisrow);
+    /* Transfer no more than fits in file */
+    rows = MIN(rows, (long) ptr->rows_in_array - thisrow);
+    if (rows <= 0)		/* this chunk might be past end of file! */
+      break;
+    byte_count = rows * bytesperrow;
+    if (writing)
+      (*ptr->b_s_info.write_backing_store) (cinfo, & ptr->b_s_info,
+					    (void FAR *) ptr->mem_buffer[i],
+					    file_offset, byte_count);
+    else
+      (*ptr->b_s_info.read_backing_store) (cinfo, & ptr->b_s_info,
+					   (void FAR *) ptr->mem_buffer[i],
+					   file_offset, byte_count);
+    file_offset += byte_count;
+  }
+}
+
+
+LOCAL void
+do_barray_io (j_common_ptr cinfo, jvirt_barray_ptr ptr, boolean writing)
+/* Do backing store read or write of a virtual coefficient-block array */
+{
+  long bytesperrow, file_offset, byte_count, rows, thisrow, i;
+
+  bytesperrow = (long) ptr->blocksperrow * SIZEOF(JBLOCK);
+  file_offset = ptr->cur_start_row * bytesperrow;
+  /* Loop to read or write each allocation chunk in mem_buffer */
+  for (i = 0; i < (long) ptr->rows_in_mem; i += ptr->rowsperchunk) {
+    /* One chunk, but check for short chunk at end of buffer */
+    rows = MIN((long) ptr->rowsperchunk, (long) ptr->rows_in_mem - i);
+    /* Transfer no more than is currently defined */
+    thisrow = (long) ptr->cur_start_row + i;
+    rows = MIN(rows, (long) ptr->first_undef_row - thisrow);
+    /* Transfer no more than fits in file */
+    rows = MIN(rows, (long) ptr->rows_in_array - thisrow);
+    if (rows <= 0)		/* this chunk might be past end of file! */
+      break;
+    byte_count = rows * bytesperrow;
+    if (writing)
+      (*ptr->b_s_info.write_backing_store) (cinfo, & ptr->b_s_info,
+					    (void FAR *) ptr->mem_buffer[i],
+					    file_offset, byte_count);
+    else
+      (*ptr->b_s_info.read_backing_store) (cinfo, & ptr->b_s_info,
+					   (void FAR *) ptr->mem_buffer[i],
+					   file_offset, byte_count);
+    file_offset += byte_count;
+  }
+}
+
+
+METHODDEF JSAMPARRAY
+access_virt_sarray (j_common_ptr cinfo, jvirt_sarray_ptr ptr,
+		    JDIMENSION start_row, JDIMENSION num_rows,
+		    boolean writable)
+/* Access the part of a virtual sample array starting at start_row */
+/* and extending for num_rows rows.  writable is true if  */
+/* caller intends to modify the accessed area. */
+{
+  JDIMENSION end_row = start_row + num_rows;
+  JDIMENSION undef_row;
+
+  /* debugging check */
+  if (end_row > ptr->rows_in_array || num_rows > ptr->maxaccess ||
+      ptr->mem_buffer == NULL)
+    ERREXIT(cinfo, JERR_BAD_VIRTUAL_ACCESS);
+
+  /* Make the desired part of the virtual array accessible */
+  if (start_row < ptr->cur_start_row ||
+      end_row > ptr->cur_start_row+ptr->rows_in_mem) {
+    if (! ptr->b_s_open)
+      ERREXIT(cinfo, JERR_VIRTUAL_BUG);
+    /* Flush old buffer contents if necessary */
+    if (ptr->dirty) {
+      do_sarray_io(cinfo, ptr, TRUE);
+      ptr->dirty = FALSE;
+    }
+    /* Decide what part of virtual array to access.
+     * Algorithm: if target address > current window, assume forward scan,
+     * load starting at target address.  If target address < current window,
+     * assume backward scan, load so that target area is top of window.
+     * Note that when switching from forward write to forward read, will have
+     * start_row = 0, so the limiting case applies and we load from 0 anyway.
+     */
+    if (start_row > ptr->cur_start_row) {
+      ptr->cur_start_row = start_row;
+    } else {
+      /* use long arithmetic here to avoid overflow & unsigned problems */
+      long ltemp;
+
+      ltemp = (long) end_row - (long) ptr->rows_in_mem;
+      if (ltemp < 0)
+	ltemp = 0;		/* don't fall off front end of file */
+      ptr->cur_start_row = (JDIMENSION) ltemp;
+    }
+    /* Read in the selected part of the array.
+     * During the initial write pass, we will do no actual read
+     * because the selected part is all undefined.
+     */
+    do_sarray_io(cinfo, ptr, FALSE);
+  }
+  /* Ensure the accessed part of the array is defined; prezero if needed.
+   * To improve locality of access, we only prezero the part of the array
+   * that the caller is about to access, not the entire in-memory array.
+   */
+  if (ptr->first_undef_row < end_row) {
+    if (ptr->first_undef_row < start_row) {
+      if (writable)		/* writer skipped over a section of array */
+	ERREXIT(cinfo, JERR_BAD_VIRTUAL_ACCESS);
+      undef_row = start_row;	/* but reader is allowed to read ahead */
+    } else {
+      undef_row = ptr->first_undef_row;
+    }
+    if (writable)
+      ptr->first_undef_row = end_row;
+    if (ptr->pre_zero) {
+      size_t bytesperrow = (size_t) ptr->samplesperrow * SIZEOF(JSAMPLE);
+      undef_row -= ptr->cur_start_row; /* make indexes relative to buffer */
+      end_row -= ptr->cur_start_row;
+      while (undef_row < end_row) {
+	jzero_far((void FAR *) ptr->mem_buffer[undef_row], bytesperrow);
+	undef_row++;
+      }
+    } else {
+      if (! writable)		/* reader looking at undefined data */
+	ERREXIT(cinfo, JERR_BAD_VIRTUAL_ACCESS);
+    }
+  }
+  /* Flag the buffer dirty if caller will write in it */
+  if (writable)
+    ptr->dirty = TRUE;
+  /* Return address of proper part of the buffer */
+  return ptr->mem_buffer + (start_row - ptr->cur_start_row);
+}
+
+
+METHODDEF JBLOCKARRAY
+access_virt_barray (j_common_ptr cinfo, jvirt_barray_ptr ptr,
+		    JDIMENSION start_row, JDIMENSION num_rows,
+		    boolean writable)
+/* Access the part of a virtual block array starting at start_row */
+/* and extending for num_rows rows.  writable is true if  */
+/* caller intends to modify the accessed area. */
+{
+  JDIMENSION end_row = start_row + num_rows;
+  JDIMENSION undef_row;
+
+  /* debugging check */
+  if (end_row > ptr->rows_in_array || num_rows > ptr->maxaccess ||
+      ptr->mem_buffer == NULL)
+    ERREXIT(cinfo, JERR_BAD_VIRTUAL_ACCESS);
+
+  /* Make the desired part of the virtual array accessible */
+  if (start_row < ptr->cur_start_row ||
+      end_row > ptr->cur_start_row+ptr->rows_in_mem) {
+    if (! ptr->b_s_open)
+      ERREXIT(cinfo, JERR_VIRTUAL_BUG);
+    /* Flush old buffer contents if necessary */
+    if (ptr->dirty) {
+      do_barray_io(cinfo, ptr, TRUE);
+      ptr->dirty = FALSE;
+    }
+    /* Decide what part of virtual array to access.
+     * Algorithm: if target address > current window, assume forward scan,
+     * load starting at target address.  If target address < current window,
+     * assume backward scan, load so that target area is top of window.
+     * Note that when switching from forward write to forward read, will have
+     * start_row = 0, so the limiting case applies and we load from 0 anyway.
+     */
+    if (start_row > ptr->cur_start_row) {
+      ptr->cur_start_row = start_row;
+    } else {
+      /* use long arithmetic here to avoid overflow & unsigned problems */
+      long ltemp;
+
+      ltemp = (long) end_row - (long) ptr->rows_in_mem;
+      if (ltemp < 0)
+	ltemp = 0;		/* don't fall off front end of file */
+      ptr->cur_start_row = (JDIMENSION) ltemp;
+    }
+    /* Read in the selected part of the array.
+     * During the initial write pass, we will do no actual read
+     * because the selected part is all undefined.
+     */
+    do_barray_io(cinfo, ptr, FALSE);
+  }
+  /* Ensure the accessed part of the array is defined; prezero if needed.
+   * To improve locality of access, we only prezero the part of the array
+   * that the caller is about to access, not the entire in-memory array.
+   */
+  if (ptr->first_undef_row < end_row) {
+    if (ptr->first_undef_row < start_row) {
+      if (writable)		/* writer skipped over a section of array */
+	ERREXIT(cinfo, JERR_BAD_VIRTUAL_ACCESS);
+      undef_row = start_row;	/* but reader is allowed to read ahead */
+    } else {
+      undef_row = ptr->first_undef_row;
+    }
+    if (writable)
+      ptr->first_undef_row = end_row;
+    if (ptr->pre_zero) {
+      size_t bytesperrow = (size_t) ptr->blocksperrow * SIZEOF(JBLOCK);
+      undef_row -= ptr->cur_start_row; /* make indexes relative to buffer */
+      end_row -= ptr->cur_start_row;
+      while (undef_row < end_row) {
+	jzero_far((void FAR *) ptr->mem_buffer[undef_row], bytesperrow);
+	undef_row++;
+      }
+    } else {
+      if (! writable)		/* reader looking at undefined data */
+	ERREXIT(cinfo, JERR_BAD_VIRTUAL_ACCESS);
+    }
+  }
+  /* Flag the buffer dirty if caller will write in it */
+  if (writable)
+    ptr->dirty = TRUE;
+  /* Return address of proper part of the buffer */
+  return ptr->mem_buffer + (start_row - ptr->cur_start_row);
+}
+
+
+/*
+ * Release all objects belonging to a specified pool.
+ */
+
+METHODDEF void
+free_pool (j_common_ptr cinfo, int pool_id)
+{
+  my_mem_ptr mem = (my_mem_ptr) cinfo->mem;
+  small_pool_ptr shdr_ptr;
+  large_pool_ptr lhdr_ptr;
+  size_t space_freed;
+
+  if (pool_id < 0 || pool_id >= JPOOL_NUMPOOLS)
+    ERREXIT1(cinfo, JERR_BAD_POOL_ID, pool_id);	/* safety check */
+
+#ifdef MEM_STATS
+  if (cinfo->err->trace_level > 1)
+    print_mem_stats(cinfo, pool_id); /* print pool's memory usage statistics */
+#endif
+
+  /* If freeing IMAGE pool, close any virtual arrays first */
+  if (pool_id == JPOOL_IMAGE) {
+    jvirt_sarray_ptr sptr;
+    jvirt_barray_ptr bptr;
+
+    for (sptr = mem->virt_sarray_list; sptr != NULL; sptr = sptr->next) {
+      if (sptr->b_s_open) {	/* there may be no backing store */
+	sptr->b_s_open = FALSE;	/* prevent recursive close if error */
+	(*sptr->b_s_info.close_backing_store) (cinfo, & sptr->b_s_info);
+      }
+    }
+    mem->virt_sarray_list = NULL;
+    for (bptr = mem->virt_barray_list; bptr != NULL; bptr = bptr->next) {
+      if (bptr->b_s_open) {	/* there may be no backing store */
+	bptr->b_s_open = FALSE;	/* prevent recursive close if error */
+	(*bptr->b_s_info.close_backing_store) (cinfo, & bptr->b_s_info);
+      }
+    }
+    mem->virt_barray_list = NULL;
+  }
+
+  /* Release large objects */
+  lhdr_ptr = mem->large_list[pool_id];
+  mem->large_list[pool_id] = NULL;
+
+  while (lhdr_ptr != NULL) {
+    large_pool_ptr next_lhdr_ptr = lhdr_ptr->hdr.next;
+    space_freed = lhdr_ptr->hdr.bytes_used +
+		  lhdr_ptr->hdr.bytes_left +
+		  SIZEOF(large_pool_hdr);
+    jpeg_free_large(cinfo, (void FAR *) lhdr_ptr, space_freed);
+    mem->total_space_allocated -= space_freed;
+    lhdr_ptr = next_lhdr_ptr;
+  }
+
+  /* Release small objects */
+  shdr_ptr = mem->small_list[pool_id];
+  mem->small_list[pool_id] = NULL;
+
+  while (shdr_ptr != NULL) {
+    small_pool_ptr next_shdr_ptr = shdr_ptr->hdr.next;
+    space_freed = shdr_ptr->hdr.bytes_used +
+		  shdr_ptr->hdr.bytes_left +
+		  SIZEOF(small_pool_hdr);
+    jpeg_free_small(cinfo, (void *) shdr_ptr, space_freed);
+    mem->total_space_allocated -= space_freed;
+    shdr_ptr = next_shdr_ptr;
+  }
+}
+
+
+/*
+ * Close up shop entirely.
+ * Note that this cannot be called unless cinfo->mem is non-NULL.
+ */
+
+METHODDEF void
+self_destruct (j_common_ptr cinfo)
+{
+  int pool;
+
+  /* Close all backing store, release all memory.
+   * Releasing pools in reverse order might help avoid fragmentation
+   * with some (brain-damaged) malloc libraries.
+   */
+  for (pool = JPOOL_NUMPOOLS-1; pool >= JPOOL_PERMANENT; pool--) {
+    free_pool(cinfo, pool);
+  }
+
+  /* Release the memory manager control block too. */
+  jpeg_free_small(cinfo, (void *) cinfo->mem, SIZEOF(my_memory_mgr));
+  cinfo->mem = NULL;		/* ensures I will be called only once */
+
+  jpeg_mem_term(cinfo);		/* system-dependent cleanup */
+}
+
+
+/*
+ * Memory manager initialization.
+ * When this is called, only the error manager pointer is valid in cinfo!
+ */
+
+GLOBAL void
+jinit_memory_mgr (j_common_ptr cinfo)
+{
+  my_mem_ptr mem;
+  long max_to_use;
+  int pool;
+  size_t test_mac;
+
+  cinfo->mem = NULL;		/* for safety if init fails */
+
+  /* Check for configuration errors.
+   * SIZEOF(ALIGN_TYPE) should be a power of 2; otherwise, it probably
+   * doesn't reflect any real hardware alignment requirement.
+   * The test is a little tricky: for X>0, X and X-1 have no one-bits
+   * in common if and only if X is a power of 2, ie has only one one-bit.
+   * Some compilers may give an "unreachable code" warning here; ignore it.
+   */
+  if ((SIZEOF(ALIGN_TYPE) & (SIZEOF(ALIGN_TYPE)-1)) != 0)
+    ERREXIT(cinfo, JERR_BAD_ALIGN_TYPE);
+  /* MAX_ALLOC_CHUNK must be representable as type size_t, and must be
+   * a multiple of SIZEOF(ALIGN_TYPE).
+   * Again, an "unreachable code" warning may be ignored here.
+   * But a "constant too large" warning means you need to fix MAX_ALLOC_CHUNK.
+   */
+  test_mac = (size_t) MAX_ALLOC_CHUNK;
+  if ((long) test_mac != MAX_ALLOC_CHUNK ||
+      (MAX_ALLOC_CHUNK % SIZEOF(ALIGN_TYPE)) != 0)
+    ERREXIT(cinfo, JERR_BAD_ALLOC_CHUNK);
+
+  max_to_use = jpeg_mem_init(cinfo); /* system-dependent initialization */
+
+  /* Attempt to allocate memory manager's control block */
+  mem = (my_mem_ptr) jpeg_get_small(cinfo, SIZEOF(my_memory_mgr));
+
+  if (mem == NULL) {
+    jpeg_mem_term(cinfo);	/* system-dependent cleanup */
+    ERREXIT1(cinfo, JERR_OUT_OF_MEMORY, 0);
+  }
+
+  /* OK, fill in the method pointers */
+  mem->pub.alloc_small = alloc_small;
+  mem->pub.alloc_large = alloc_large;
+  mem->pub.alloc_sarray = alloc_sarray;
+  mem->pub.alloc_barray = alloc_barray;
+  mem->pub.request_virt_sarray = request_virt_sarray;
+  mem->pub.request_virt_barray = request_virt_barray;
+  mem->pub.realize_virt_arrays = realize_virt_arrays;
+  mem->pub.access_virt_sarray = access_virt_sarray;
+  mem->pub.access_virt_barray = access_virt_barray;
+  mem->pub.free_pool = free_pool;
+  mem->pub.self_destruct = self_destruct;
+
+  /* Initialize working state */
+  mem->pub.max_memory_to_use = max_to_use;
+
+  for (pool = JPOOL_NUMPOOLS-1; pool >= JPOOL_PERMANENT; pool--) {
+    mem->small_list[pool] = NULL;
+    mem->large_list[pool] = NULL;
+  }
+  mem->virt_sarray_list = NULL;
+  mem->virt_barray_list = NULL;
+
+  mem->total_space_allocated = SIZEOF(my_memory_mgr);
+
+  /* Declare ourselves open for business */
+  cinfo->mem = & mem->pub;
+
+  /* Check for an environment variable JPEGMEM; if found, override the
+   * default max_memory setting from jpeg_mem_init.  Note that the
+   * surrounding application may again override this value.
+   * If your system doesn't support getenv(), define NO_GETENV to disable
+   * this feature.
+   */
+#ifndef NO_GETENV
+  { char * memenv;
+
+    if ((memenv = getenv("JPEGMEM")) != NULL) {
+      char ch = 'x';
+
+      if (sscanf(memenv, "%ld%c", &max_to_use, &ch) > 0) {
+	if (ch == 'm' || ch == 'M')
+	  max_to_use *= 1000L;
+	mem->pub.max_memory_to_use = max_to_use * 1000L;
+      }
+    }
+  }
+#endif
+
+}
diff --git a/codemp/jpeg-6/jmemnobs.cpp b/codemp/jpeg-6/jmemnobs.cpp
new file mode 100644
index 0000000..c3b3e1b
--- /dev/null
+++ b/codemp/jpeg-6/jmemnobs.cpp
@@ -0,0 +1,107 @@
+/*
+ * jmemnobs.c
+ *
+ * Copyright (C) 1992-1994, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file provides a really simple implementation of the system-
+ * dependent portion of the JPEG memory manager.  This implementation
+ * assumes that no backing-store files are needed: all required space
+ * can be obtained from Z_Malloc().
+ * This is very portable in the sense that it'll compile on almost anything,
+ * but you'd better have lots of main memory (or virtual memory) if you want
+ * to process big images.
+ * Note that the max_memory_to_use option is ignored by this implementation.
+ */
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+#include "jmemsys.h"		/* import the system-dependent declarations */
+
+#include "../renderer/tr_local.h"
+
+/*
+ * Memory allocation and ri.Freeing are controlled by the regular library
+ * routines Z_Malloc() and Z_Free().
+ */
+
+GLOBAL void *
+jpeg_get_small (j_common_ptr cinfo, size_t sizeofobject)
+{
+  return (void *) Z_Malloc(sizeofobject, TAG_TEMP_WORKSPACE, qfalse);
+}
+
+GLOBAL void
+jpeg_free_small (j_common_ptr cinfo, void * object, size_t sizeofobject)
+{
+  Z_Free(object);
+}
+
+
+/*
+ * "Large" objects are treated the same as "small" ones.
+ * NB: although we include FAR keywords in the routine declarations,
+ * this file won't actually work in 80x86 small/medium model; at least,
+ * you probably won't be able to process useful-size images in only 64KB.
+ */
+
+GLOBAL void FAR *
+jpeg_get_large (j_common_ptr cinfo, size_t sizeofobject)
+{
+  return (void FAR *) Z_Malloc(sizeofobject, TAG_TEMP_WORKSPACE, qfalse);
+}
+
+GLOBAL void
+jpeg_free_large (j_common_ptr cinfo, void FAR * object, size_t sizeofobject)
+{
+  Z_Free(object);
+}
+
+
+/*
+ * This routine computes the total memory space available for allocation.
+ * Here we always say, "we got all you want bud!"
+ */
+
+GLOBAL long
+jpeg_mem_available (j_common_ptr cinfo, long min_bytes_needed,
+		    long max_bytes_needed, long already_allocated)
+{
+  return max_bytes_needed;
+}
+
+
+/*
+ * Backing store (temporary file) management.
+ * Since jpeg_mem_available always promised the moon,
+ * this should never be called and we can just error out.
+ */
+
+GLOBAL void
+jpeg_open_backing_store (j_common_ptr cinfo, backing_store_ptr info,
+			 long total_bytes_needed)
+{
+  ERREXIT(cinfo, JERR_NO_BACKING_STORE);
+}
+
+
+/*
+ * These routines take care of any system-dependent initialization and
+ * cleanup required.  Here, there isn't any.
+ */
+
+GLOBAL long
+jpeg_mem_init (j_common_ptr cinfo)
+{
+  return 0;			/* just set max_memory_to_use to 0 */
+}
+
+GLOBAL void
+jpeg_mem_term (j_common_ptr cinfo)
+{
+  /* no work */
+}
diff --git a/codemp/jpeg-6/jmemsys.h b/codemp/jpeg-6/jmemsys.h
new file mode 100644
index 0000000..0c7d7c1
--- /dev/null
+++ b/codemp/jpeg-6/jmemsys.h
@@ -0,0 +1,182 @@
+/*
+ * jmemsys.h
+ *
+ * Copyright (C) 1992-1994, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This include file defines the interface between the system-independent
+ * and system-dependent portions of the JPEG memory manager.  No other
+ * modules need include it.  (The system-independent portion is jmemmgr.c;
+ * there are several different versions of the system-dependent portion.)
+ *
+ * This file works as-is for the system-dependent memory managers supplied
+ * in the IJG distribution.  You may need to modify it if you write a
+ * custom memory manager.  If system-dependent changes are needed in
+ * this file, the best method is to #ifdef them based on a configuration
+ * symbol supplied in jconfig.h, as we have done with USE_MSDOS_MEMMGR.
+ */
+
+
+/* Short forms of external names for systems with brain-damaged linkers. */
+
+#ifdef NEED_SHORT_EXTERNAL_NAMES
+#define jpeg_get_small		jGetSmall
+#define jpeg_free_small		jFreeSmall
+#define jpeg_get_large		jGetLarge
+#define jpeg_free_large		jFreeLarge
+#define jpeg_mem_available	jMemAvail
+#define jpeg_open_backing_store	jOpenBackStore
+#define jpeg_mem_init		jMemInit
+#define jpeg_mem_term		jMemTerm
+#endif /* NEED_SHORT_EXTERNAL_NAMES */
+
+
+/*
+ * These two functions are used to allocate and release small chunks of
+ * memory.  (Typically the total amount requested through jpeg_get_small is
+ * no more than 20K or so; this will be requested in chunks of a few K each.)
+ * Behavior should be the same as for the standard library functions malloc
+ * and free; in particular, jpeg_get_small must return NULL on failure.
+ * On most systems, these ARE malloc and free.  jpeg_free_small is passed the
+ * size of the object being freed, just in case it's needed.
+ * On an 80x86 machine using small-data memory model, these manage near heap.
+ */
+
+EXTERN void * jpeg_get_small JPP((j_common_ptr cinfo, size_t sizeofobject));
+EXTERN void jpeg_free_small JPP((j_common_ptr cinfo, void * object,
+				 size_t sizeofobject));
+
+/*
+ * These two functions are used to allocate and release large chunks of
+ * memory (up to the total free space designated by jpeg_mem_available).
+ * The interface is the same as above, except that on an 80x86 machine,
+ * far pointers are used.  On most other machines these are identical to
+ * the jpeg_get/free_small routines; but we keep them separate anyway,
+ * in case a different allocation strategy is desirable for large chunks.
+ */
+
+EXTERN void FAR * jpeg_get_large JPP((j_common_ptr cinfo,size_t sizeofobject));
+EXTERN void jpeg_free_large JPP((j_common_ptr cinfo, void FAR * object,
+				 size_t sizeofobject));
+
+/*
+ * The macro MAX_ALLOC_CHUNK designates the maximum number of bytes that may
+ * be requested in a single call to jpeg_get_large (and jpeg_get_small for that
+ * matter, but that case should never come into play).  This macro is needed
+ * to model the 64Kb-segment-size limit of far addressing on 80x86 machines.
+ * On those machines, we expect that jconfig.h will provide a proper value.
+ * On machines with 32-bit flat address spaces, any large constant may be used.
+ *
+ * NB: jmemmgr.c expects that MAX_ALLOC_CHUNK will be representable as type
+ * size_t and will be a multiple of sizeof(align_type).
+ */
+
+#ifndef MAX_ALLOC_CHUNK		/* may be overridden in jconfig.h */
+#define MAX_ALLOC_CHUNK  1000000000L
+#endif
+
+/*
+ * This routine computes the total space still available for allocation by
+ * jpeg_get_large.  If more space than this is needed, backing store will be
+ * used.  NOTE: any memory already allocated must not be counted.
+ *
+ * There is a minimum space requirement, corresponding to the minimum
+ * feasible buffer sizes; jmemmgr.c will request that much space even if
+ * jpeg_mem_available returns zero.  The maximum space needed, enough to hold
+ * all working storage in memory, is also passed in case it is useful.
+ * Finally, the total space already allocated is passed.  If no better
+ * method is available, cinfo->mem->max_memory_to_use - already_allocated
+ * is often a suitable calculation.
+ *
+ * It is OK for jpeg_mem_available to underestimate the space available
+ * (that'll just lead to more backing-store access than is really necessary).
+ * However, an overestimate will lead to failure.  Hence it's wise to subtract
+ * a slop factor from the true available space.  5% should be enough.
+ *
+ * On machines with lots of virtual memory, any large constant may be returned.
+ * Conversely, zero may be returned to always use the minimum amount of memory.
+ */
+
+EXTERN long jpeg_mem_available JPP((j_common_ptr cinfo,
+				    long min_bytes_needed,
+				    long max_bytes_needed,
+				    long already_allocated));
+
+
+/*
+ * This structure holds whatever state is needed to access a single
+ * backing-store object.  The read/write/close method pointers are called
+ * by jmemmgr.c to manipulate the backing-store object; all other fields
+ * are private to the system-dependent backing store routines.
+ */
+
+#define TEMP_NAME_LENGTH   64	/* max length of a temporary file's name */
+
+#ifdef USE_MSDOS_MEMMGR		/* DOS-specific junk */
+
+typedef unsigned short XMSH;	/* type of extended-memory handles */
+typedef unsigned short EMSH;	/* type of expanded-memory handles */
+
+typedef union {
+  short file_handle;		/* DOS file handle if it's a temp file */
+  XMSH xms_handle;		/* handle if it's a chunk of XMS */
+  EMSH ems_handle;		/* handle if it's a chunk of EMS */
+} handle_union;
+
+#endif /* USE_MSDOS_MEMMGR */
+
+typedef struct backing_store_struct * backing_store_ptr;
+
+typedef struct backing_store_struct {
+  /* Methods for reading/writing/closing this backing-store object */
+  JMETHOD(void, read_backing_store, (j_common_ptr cinfo,
+				     backing_store_ptr info,
+				     void FAR * buffer_address,
+				     long file_offset, long byte_count));
+  JMETHOD(void, write_backing_store, (j_common_ptr cinfo,
+				      backing_store_ptr info,
+				      void FAR * buffer_address,
+				      long file_offset, long byte_count));
+  JMETHOD(void, close_backing_store, (j_common_ptr cinfo,
+				      backing_store_ptr info));
+
+  /* Private fields for system-dependent backing-store management */
+#ifdef USE_MSDOS_MEMMGR
+  /* For the MS-DOS manager (jmemdos.c), we need: */
+  handle_union handle;		/* reference to backing-store storage object */
+  char temp_name[TEMP_NAME_LENGTH]; /* name if it's a file */
+#else
+  /* For a typical implementation with temp files, we need: */
+  FILE * temp_file;		/* stdio reference to temp file */
+  char temp_name[TEMP_NAME_LENGTH]; /* name of temp file */
+#endif
+} backing_store_info;
+
+/*
+ * Initial opening of a backing-store object.  This must fill in the
+ * read/write/close pointers in the object.  The read/write routines
+ * may take an error exit if the specified maximum file size is exceeded.
+ * (If jpeg_mem_available always returns a large value, this routine can
+ * just take an error exit.)
+ */
+
+EXTERN void jpeg_open_backing_store JPP((j_common_ptr cinfo,
+					 backing_store_ptr info,
+					 long total_bytes_needed));
+
+
+/*
+ * These routines take care of any system-dependent initialization and
+ * cleanup required.  jpeg_mem_init will be called before anything is
+ * allocated (and, therefore, nothing in cinfo is of use except the error
+ * manager pointer).  It should return a suitable default value for
+ * max_memory_to_use; this may subsequently be overridden by the surrounding
+ * application.  (Note that max_memory_to_use is only important if
+ * jpeg_mem_available chooses to consult it ... no one else will.)
+ * jpeg_mem_term may assume that all requested memory has been freed and that
+ * all opened backing-store objects have been closed.
+ */
+
+EXTERN long jpeg_mem_init JPP((j_common_ptr cinfo));
+EXTERN void jpeg_mem_term JPP((j_common_ptr cinfo));
diff --git a/codemp/jpeg-6/jmorecfg.h b/codemp/jpeg-6/jmorecfg.h
new file mode 100644
index 0000000..08f332a
--- /dev/null
+++ b/codemp/jpeg-6/jmorecfg.h
@@ -0,0 +1,349 @@
+/*
+ * jmorecfg.h
+ *
+ * Copyright (C) 1991-1995, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains additional configuration options that customize the
+ * JPEG software for special applications or support machine-dependent
+ * optimizations.  Most users will not need to touch this file.
+ */
+
+
+/*
+ * Define BITS_IN_JSAMPLE as either
+ *   8   for 8-bit sample values (the usual setting)
+ *   12  for 12-bit sample values
+ * Only 8 and 12 are legal data precisions for lossy JPEG according to the
+ * JPEG standard, and the IJG code does not support anything else!
+ * We do not support run-time selection of data precision, sorry.
+ */
+
+#define BITS_IN_JSAMPLE  8	/* use 8 or 12 */
+
+
+/*
+ * Maximum number of components (color channels) allowed in JPEG image.
+ * To meet the letter of the JPEG spec, set this to 255.  However, darn
+ * few applications need more than 4 channels (maybe 5 for CMYK + alpha
+ * mask).  We recommend 10 as a reasonable compromise; use 4 if you are
+ * really short on memory.  (Each allowed component costs a hundred or so
+ * bytes of storage, whether actually used in an image or not.)
+ */
+
+#define MAX_COMPONENTS  10	/* maximum number of image components */
+
+
+/*
+ * Basic data types.
+ * You may need to change these if you have a machine with unusual data
+ * type sizes; for example, "char" not 8 bits, "short" not 16 bits,
+ * or "long" not 32 bits.  We don't care whether "int" is 16 or 32 bits,
+ * but it had better be at least 16.
+ */
+
+/* Representation of a single sample (pixel element value).
+ * We frequently allocate large arrays of these, so it's important to keep
+ * them small.  But if you have memory to burn and access to char or short
+ * arrays is very slow on your hardware, you might want to change these.
+ */
+
+#if BITS_IN_JSAMPLE == 8
+/* JSAMPLE should be the smallest type that will hold the values 0..255.
+ * You can use a signed char by having GETJSAMPLE mask it with 0xFF.
+ */
+
+#ifdef HAVE_UNSIGNED_CHAR
+
+typedef unsigned char JSAMPLE;
+#define GETJSAMPLE(value)  ((int) (value))
+
+#else /* not HAVE_UNSIGNED_CHAR */
+
+typedef char JSAMPLE;
+#ifdef CHAR_IS_UNSIGNED
+#define GETJSAMPLE(value)  ((int) (value))
+#else
+#define GETJSAMPLE(value)  ((int) (value) & 0xFF)
+#endif /* CHAR_IS_UNSIGNED */
+
+#endif /* HAVE_UNSIGNED_CHAR */
+
+#define MAXJSAMPLE	255
+#define CENTERJSAMPLE	128
+
+#endif /* BITS_IN_JSAMPLE == 8 */
+
+
+#if BITS_IN_JSAMPLE == 12
+/* JSAMPLE should be the smallest type that will hold the values 0..4095.
+ * On nearly all machines "short" will do nicely.
+ */
+
+typedef short JSAMPLE;
+#define GETJSAMPLE(value)  ((int) (value))
+
+#define MAXJSAMPLE	4095
+#define CENTERJSAMPLE	2048
+
+#endif /* BITS_IN_JSAMPLE == 12 */
+
+
+/* Representation of a DCT frequency coefficient.
+ * This should be a signed value of at least 16 bits; "short" is usually OK.
+ * Again, we allocate large arrays of these, but you can change to int
+ * if you have memory to burn and "short" is really slow.
+ */
+
+typedef short JCOEF;
+
+
+/* Compressed datastreams are represented as arrays of JOCTET.
+ * These must be EXACTLY 8 bits wide, at least once they are written to
+ * external storage.  Note that when using the stdio data source/destination
+ * managers, this is also the data type passed to fread/fwrite.
+ */
+
+#ifdef HAVE_UNSIGNED_CHAR
+
+typedef unsigned char JOCTET;
+#define GETJOCTET(value)  (value)
+
+#else /* not HAVE_UNSIGNED_CHAR */
+
+typedef char JOCTET;
+#ifdef CHAR_IS_UNSIGNED
+#define GETJOCTET(value)  (value)
+#else
+#define GETJOCTET(value)  ((value) & 0xFF)
+#endif /* CHAR_IS_UNSIGNED */
+
+#endif /* HAVE_UNSIGNED_CHAR */
+
+
+/* These typedefs are used for various table entries and so forth.
+ * They must be at least as wide as specified; but making them too big
+ * won't cost a huge amount of memory, so we don't provide special
+ * extraction code like we did for JSAMPLE.  (In other words, these
+ * typedefs live at a different point on the speed/space tradeoff curve.)
+ */
+
+/* UINT8 must hold at least the values 0..255. */
+
+#ifdef HAVE_UNSIGNED_CHAR
+typedef unsigned char UINT8;
+#else /* not HAVE_UNSIGNED_CHAR */
+#ifdef CHAR_IS_UNSIGNED
+typedef char UINT8;
+#else /* not CHAR_IS_UNSIGNED */
+typedef short UINT8;
+#endif /* CHAR_IS_UNSIGNED */
+#endif /* HAVE_UNSIGNED_CHAR */
+
+/* UINT16 must hold at least the values 0..65535. */
+
+#ifdef HAVE_UNSIGNED_SHORT
+typedef unsigned short UINT16;
+#else /* not HAVE_UNSIGNED_SHORT */
+typedef unsigned int UINT16;
+#endif /* HAVE_UNSIGNED_SHORT */
+
+// compile warning for VC6 with CPP being defined
+// typedef long INT32;
+
+/* INT16 must hold at least the values -32768..32767. */
+
+#ifndef XMD_H			/* X11/xmd.h correctly defines INT16 */
+typedef short INT16;
+#endif
+
+/* INT32 must hold at least signed 32-bit values. */
+
+//#ifndef XMD_H			/* X11/xmd.h correctly defines INT32 */
+//typedef long INT32;
+//#endif
+
+/* Datatype used for image dimensions.  The JPEG standard only supports
+ * images up to 64K*64K due to 16-bit fields in SOF markers.  Therefore
+ * "unsigned int" is sufficient on all machines.  However, if you need to
+ * handle larger images and you don't mind deviating from the spec, you
+ * can change this datatype.
+ */
+
+typedef unsigned int JDIMENSION;
+
+#define JPEG_MAX_DIMENSION  65500L  /* a tad under 64K to prevent overflows */
+
+
+/* These defines are used in all function definitions and extern declarations.
+ * You could modify them if you need to change function linkage conventions.
+ * Another application is to make all functions global for use with debuggers
+ * or code profilers that require it.
+ */
+
+#define METHODDEF static	/* a function called through method pointers */
+#define LOCAL	  static	/* a function used only in its module */
+#define GLOBAL			/* a function referenced thru EXTERNs */
+#define EXTERN	  extern	/* a reference to a GLOBAL function */
+
+
+/* Here is the pseudo-keyword for declaring pointers that must be "far"
+ * on 80x86 machines.  Most of the specialized coding for 80x86 is handled
+ * by just saying "FAR *" where such a pointer is needed.  In a few places
+ * explicit coding is needed; see uses of the NEED_FAR_POINTERS symbol.
+ */
+
+#ifdef NEED_FAR_POINTERS
+#undef FAR
+#define FAR  far
+#else
+#undef FAR
+#define FAR
+#endif
+
+
+/*
+ * On a few systems, type boolean and/or its values FALSE, TRUE may appear
+ * in standard header files.  Or you may have conflicts with application-
+ * specific header files that you want to include together with these files.
+ * Defining HAVE_BOOLEAN before including jpeglib.h should make it work.
+ */
+
+//#ifndef HAVE_BOOLEAN
+//typedef int boolean;
+//#endif
+#ifndef FALSE			/* in case these macros already exist */
+#define FALSE	0		/* values of boolean */
+#endif
+#ifndef TRUE
+#define TRUE	1
+#endif
+
+
+/*
+ * The remaining options affect code selection within the JPEG library,
+ * but they don't need to be visible to most applications using the library.
+ * To minimize application namespace pollution, the symbols won't be
+ * defined unless JPEG_INTERNALS or JPEG_INTERNAL_OPTIONS has been defined.
+ */
+
+#ifdef JPEG_INTERNALS
+#define JPEG_INTERNAL_OPTIONS
+#endif
+
+#ifdef JPEG_INTERNAL_OPTIONS
+
+
+/*
+ * These defines indicate whether to include various optional functions.
+ * Undefining some of these symbols will produce a smaller but less capable
+ * library.  Note that you can leave certain source files out of the
+ * compilation/linking process if you've #undef'd the corresponding symbols.
+ * (You may HAVE to do that if your compiler doesn't like null source files.)
+ */
+
+/* Arithmetic coding is unsupported for legal reasons.  Complaints to IBM. */
+
+/* Capability options common to encoder and decoder: */
+
+#undef DCT_ISLOW_SUPPORTED	/* slow but accurate integer algorithm */
+#undef DCT_IFAST_SUPPORTED	/* faster, less accurate integer method */
+#define DCT_FLOAT_SUPPORTED	/* floating-point: accurate, fast on fast HW */
+
+/* Encoder capability options: */
+
+#undef  C_ARITH_CODING_SUPPORTED    /* Arithmetic coding back end? */
+#define C_MULTISCAN_FILES_SUPPORTED /* Multiple-scan JPEG files? */
+#define C_PROGRESSIVE_SUPPORTED	    /* Progressive JPEG? (Requires MULTISCAN)*/
+#define ENTROPY_OPT_SUPPORTED	    /* Optimization of entropy coding parms? */
+/* Note: if you selected 12-bit data precision, it is dangerous to turn off
+ * ENTROPY_OPT_SUPPORTED.  The standard Huffman tables are only good for 8-bit
+ * precision, so jchuff.c normally uses entropy optimization to compute
+ * usable tables for higher precision.  If you don't want to do optimization,
+ * you'll have to supply different default Huffman tables.
+ * The exact same statements apply for progressive JPEG: the default tables
+ * don't work for progressive mode.  (This may get fixed, however.)
+ */
+#define INPUT_SMOOTHING_SUPPORTED   /* Input image smoothing option? */
+
+/* Decoder capability options: */
+
+#undef  D_ARITH_CODING_SUPPORTED    /* Arithmetic coding back end? */
+#undef D_MULTISCAN_FILES_SUPPORTED /* Multiple-scan JPEG files? */
+#undef D_PROGRESSIVE_SUPPORTED	    /* Progressive JPEG? (Requires MULTISCAN)*/
+#undef BLOCK_SMOOTHING_SUPPORTED   /* Block smoothing? (Progressive only) */
+#undef IDCT_SCALING_SUPPORTED	    /* Output rescaling via IDCT? */
+#undef  UPSAMPLE_SCALING_SUPPORTED  /* Output rescaling at upsample stage? */
+#undef UPSAMPLE_MERGING_SUPPORTED  /* Fast path for sloppy upsampling? */
+#undef QUANT_1PASS_SUPPORTED	    /* 1-pass color quantization? */
+#undef QUANT_2PASS_SUPPORTED	    /* 2-pass color quantization? */
+
+/* more capability options later, no doubt */
+
+
+/*
+ * Ordering of RGB data in scanlines passed to or from the application.
+ * If your application wants to deal with data in the order B,G,R, just
+ * change these macros.  You can also deal with formats such as R,G,B,X
+ * (one extra byte per pixel) by changing RGB_PIXELSIZE.  Note that changing
+ * the offsets will also change the order in which colormap data is organized.
+ * RESTRICTIONS:
+ * 1. The sample applications cjpeg,djpeg do NOT support modified RGB formats.
+ * 2. These macros only affect RGB<=>YCbCr color conversion, so they are not
+ *    useful if you are using JPEG color spaces other than YCbCr or grayscale.
+ * 3. The color quantizer modules will not behave desirably if RGB_PIXELSIZE
+ *    is not 3 (they don't understand about dummy color components!).  So you
+ *    can't use color quantization if you change that value.
+ */
+
+#define RGB_RED		0	/* Offset of Red in an RGB scanline element */
+#define RGB_GREEN	1	/* Offset of Green */
+#define RGB_BLUE	2	/* Offset of Blue */
+#define RGB_PIXELSIZE	4	/* JSAMPLEs per RGB scanline element */
+
+
+/* Definitions for speed-related optimizations. */
+
+
+/* If your compiler supports inline functions, define INLINE
+ * as the inline keyword; otherwise define it as empty.
+ */
+
+#ifndef INLINE
+#ifdef __GNUC__			/* for instance, GNU C knows about inline */
+#define INLINE __inline__
+#endif
+#ifndef INLINE
+#define INLINE			/* default is to define it as empty */
+#endif
+#endif
+
+
+/* On some machines (notably 68000 series) "int" is 32 bits, but multiplying
+ * two 16-bit shorts is faster than multiplying two ints.  Define MULTIPLIER
+ * as short on such a machine.  MULTIPLIER must be at least 16 bits wide.
+ */
+
+#ifndef MULTIPLIER
+#define MULTIPLIER  int		/* type for fastest integer multiply */
+#endif
+
+
+/* FAST_FLOAT should be either float or double, whichever is done faster
+ * by your compiler.  (Note that this type is only used in the floating point
+ * DCT routines, so it only matters if you've defined DCT_FLOAT_SUPPORTED.)
+ * Typically, float is faster in ANSI C compilers, while double is faster in
+ * pre-ANSI compilers (because they insist on converting to double anyway).
+ * The code below therefore chooses float if we have ANSI-style prototypes.
+ */
+
+#ifndef FAST_FLOAT
+#ifdef HAVE_PROTOTYPES
+#define FAST_FLOAT  float
+#else
+#define FAST_FLOAT  double
+#endif
+#endif
+
+#endif /* JPEG_INTERNAL_OPTIONS */
diff --git a/codemp/jpeg-6/jpegint.h b/codemp/jpeg-6/jpegint.h
new file mode 100644
index 0000000..b3b6a6d
--- /dev/null
+++ b/codemp/jpeg-6/jpegint.h
@@ -0,0 +1,388 @@
+/*
+ * jpegint.h
+ *
+ * Copyright (C) 1991-1995, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file provides common declarations for the various JPEG modules.
+ * These declarations are considered internal to the JPEG library; most
+ * applications using the library shouldn't need to include this file.
+ */
+
+
+/* Declarations for both compression & decompression */
+
+typedef enum {			/* Operating modes for buffer controllers */
+	JBUF_PASS_THRU,		/* Plain stripwise operation */
+	/* Remaining modes require a full-image buffer to have been created */
+	JBUF_SAVE_SOURCE,	/* Run source subobject only, save output */
+	JBUF_CRANK_DEST,	/* Run dest subobject only, using saved data */
+	JBUF_SAVE_AND_PASS	/* Run both subobjects, save output */
+} J_BUF_MODE;
+
+/* Values of global_state field (jdapi.c has some dependencies on ordering!) */
+#define CSTATE_START	100	/* after create_compress */
+#define CSTATE_SCANNING	101	/* start_compress done, write_scanlines OK */
+#define CSTATE_RAW_OK	102	/* start_compress done, write_raw_data OK */
+#define CSTATE_WRCOEFS	103	/* jpeg_write_coefficients done */
+#define DSTATE_START	200	/* after create_decompress */
+#define DSTATE_INHEADER	201	/* reading header markers, no SOS yet */
+#define DSTATE_READY	202	/* found SOS, ready for start_decompress */
+#define DSTATE_PRELOAD	203	/* reading multiscan file in start_decompress*/
+#define DSTATE_PRESCAN	204	/* performing dummy pass for 2-pass quant */
+#define DSTATE_SCANNING	205	/* start_decompress done, read_scanlines OK */
+#define DSTATE_RAW_OK	206	/* start_decompress done, read_raw_data OK */
+#define DSTATE_BUFIMAGE	207	/* expecting jpeg_start_output */
+#define DSTATE_BUFPOST	208	/* looking for SOS/EOI in jpeg_finish_output */
+#define DSTATE_RDCOEFS	209	/* reading file in jpeg_read_coefficients */
+#define DSTATE_STOPPING	210	/* looking for EOI in jpeg_finish_decompress */
+
+
+/* Declarations for compression modules */
+
+/* Master control module */
+struct jpeg_comp_master {
+  JMETHOD(void, prepare_for_pass, (j_compress_ptr cinfo));
+  JMETHOD(void, pass_startup, (j_compress_ptr cinfo));
+  JMETHOD(void, finish_pass, (j_compress_ptr cinfo));
+
+  /* State variables made visible to other modules */
+  boolean call_pass_startup;	/* True if pass_startup must be called */
+  boolean is_last_pass;		/* True during last pass */
+};
+
+/* Main buffer control (downsampled-data buffer) */
+struct jpeg_c_main_controller {
+  JMETHOD(void, start_pass, (j_compress_ptr cinfo, J_BUF_MODE pass_mode));
+  JMETHOD(void, process_data, (j_compress_ptr cinfo,
+			       JSAMPARRAY input_buf, JDIMENSION *in_row_ctr,
+			       JDIMENSION in_rows_avail));
+};
+
+/* Compression preprocessing (downsampling input buffer control) */
+struct jpeg_c_prep_controller {
+  JMETHOD(void, start_pass, (j_compress_ptr cinfo, J_BUF_MODE pass_mode));
+  JMETHOD(void, pre_process_data, (j_compress_ptr cinfo,
+				   JSAMPARRAY input_buf,
+				   JDIMENSION *in_row_ctr,
+				   JDIMENSION in_rows_avail,
+				   JSAMPIMAGE output_buf,
+				   JDIMENSION *out_row_group_ctr,
+				   JDIMENSION out_row_groups_avail));
+};
+
+/* Coefficient buffer control */
+struct jpeg_c_coef_controller {
+  JMETHOD(void, start_pass, (j_compress_ptr cinfo, J_BUF_MODE pass_mode));
+  JMETHOD(boolean, compress_data, (j_compress_ptr cinfo,
+				   JSAMPIMAGE input_buf));
+};
+
+/* Colorspace conversion */
+struct jpeg_color_converter {
+  JMETHOD(void, start_pass, (j_compress_ptr cinfo));
+  JMETHOD(void, color_convert, (j_compress_ptr cinfo,
+				JSAMPARRAY input_buf, JSAMPIMAGE output_buf,
+				JDIMENSION output_row, int num_rows));
+};
+
+/* Downsampling */
+struct jpeg_downsampler {
+  JMETHOD(void, start_pass, (j_compress_ptr cinfo));
+  JMETHOD(void, downsample, (j_compress_ptr cinfo,
+			     JSAMPIMAGE input_buf, JDIMENSION in_row_index,
+			     JSAMPIMAGE output_buf,
+			     JDIMENSION out_row_group_index));
+
+  boolean need_context_rows;	/* TRUE if need rows above & below */
+};
+
+/* Forward DCT (also controls coefficient quantization) */
+struct jpeg_forward_dct {
+  JMETHOD(void, start_pass, (j_compress_ptr cinfo));
+  /* perhaps this should be an array??? */
+  JMETHOD(void, forward_DCT, (j_compress_ptr cinfo,
+			      jpeg_component_info * compptr,
+			      JSAMPARRAY sample_data, JBLOCKROW coef_blocks,
+			      JDIMENSION start_row, JDIMENSION start_col,
+			      JDIMENSION num_blocks));
+};
+
+/* Entropy encoding */
+struct jpeg_entropy_encoder {
+  JMETHOD(void, start_pass, (j_compress_ptr cinfo, boolean gather_statistics));
+  JMETHOD(boolean, encode_mcu, (j_compress_ptr cinfo, JBLOCKROW *MCU_data));
+  JMETHOD(void, finish_pass, (j_compress_ptr cinfo));
+};
+
+/* Marker writing */
+struct jpeg_marker_writer {
+  /* write_any_marker is exported for use by applications */
+  /* Probably only COM and APPn markers should be written */
+  JMETHOD(void, write_any_marker, (j_compress_ptr cinfo, int marker,
+				   const JOCTET *dataptr, unsigned int datalen));
+  JMETHOD(void, write_file_header, (j_compress_ptr cinfo));
+  JMETHOD(void, write_frame_header, (j_compress_ptr cinfo));
+  JMETHOD(void, write_scan_header, (j_compress_ptr cinfo));
+  JMETHOD(void, write_file_trailer, (j_compress_ptr cinfo));
+  JMETHOD(void, write_tables_only, (j_compress_ptr cinfo));
+};
+
+
+/* Declarations for decompression modules */
+
+/* Master control module */
+struct jpeg_decomp_master {
+  JMETHOD(void, prepare_for_output_pass, (j_decompress_ptr cinfo));
+  JMETHOD(void, finish_output_pass, (j_decompress_ptr cinfo));
+
+  /* State variables made visible to other modules */
+  boolean is_dummy_pass;	/* True during 1st pass for 2-pass quant */
+};
+
+/* Input control module */
+struct jpeg_input_controller {
+  JMETHOD(int, consume_input, (j_decompress_ptr cinfo));
+  JMETHOD(void, reset_input_controller, (j_decompress_ptr cinfo));
+  JMETHOD(void, start_input_pass, (j_decompress_ptr cinfo));
+  JMETHOD(void, finish_input_pass, (j_decompress_ptr cinfo));
+
+  /* State variables made visible to other modules */
+  boolean has_multiple_scans;	/* True if file has multiple scans */
+  boolean eoi_reached;		/* True when EOI has been consumed */
+};
+
+/* Main buffer control (downsampled-data buffer) */
+struct jpeg_d_main_controller {
+  JMETHOD(void, start_pass, (j_decompress_ptr cinfo, J_BUF_MODE pass_mode));
+  JMETHOD(void, process_data, (j_decompress_ptr cinfo,
+			       JSAMPARRAY output_buf, JDIMENSION *out_row_ctr,
+			       JDIMENSION out_rows_avail));
+};
+
+/* Coefficient buffer control */
+struct jpeg_d_coef_controller {
+  JMETHOD(void, start_input_pass, (j_decompress_ptr cinfo));
+  JMETHOD(int, consume_data, (j_decompress_ptr cinfo));
+  JMETHOD(void, start_output_pass, (j_decompress_ptr cinfo));
+  JMETHOD(int, decompress_data, (j_decompress_ptr cinfo,
+				 JSAMPIMAGE output_buf));
+  /* Pointer to array of coefficient virtual arrays, or NULL if none */
+  jvirt_barray_ptr *coef_arrays;
+};
+
+/* Decompression postprocessing (color quantization buffer control) */
+struct jpeg_d_post_controller {
+  JMETHOD(void, start_pass, (j_decompress_ptr cinfo, J_BUF_MODE pass_mode));
+  JMETHOD(void, post_process_data, (j_decompress_ptr cinfo,
+				    JSAMPIMAGE input_buf,
+				    JDIMENSION *in_row_group_ctr,
+				    JDIMENSION in_row_groups_avail,
+				    JSAMPARRAY output_buf,
+				    JDIMENSION *out_row_ctr,
+				    JDIMENSION out_rows_avail));
+};
+
+/* Marker reading & parsing */
+struct jpeg_marker_reader {
+  JMETHOD(void, reset_marker_reader, (j_decompress_ptr cinfo));
+  /* Read markers until SOS or EOI.
+   * Returns same codes as are defined for jpeg_consume_input:
+   * JPEG_SUSPENDED, JPEG_REACHED_SOS, or JPEG_REACHED_EOI.
+   */
+  JMETHOD(int, read_markers, (j_decompress_ptr cinfo));
+  /* Read a restart marker --- exported for use by entropy decoder only */
+  jpeg_marker_parser_method read_restart_marker;
+  /* Application-overridable marker processing methods */
+  jpeg_marker_parser_method process_COM;
+  jpeg_marker_parser_method process_APPn[16];
+
+  /* State of marker reader --- nominally internal, but applications
+   * supplying COM or APPn handlers might like to know the state.
+   */
+  boolean saw_SOI;		/* found SOI? */
+  boolean saw_SOF;		/* found SOF? */
+  int next_restart_num;		/* next restart number expected (0-7) */
+  unsigned int discarded_bytes;	/* # of bytes skipped looking for a marker */
+};
+
+/* Entropy decoding */
+struct jpeg_entropy_decoder {
+  JMETHOD(void, start_pass, (j_decompress_ptr cinfo));
+  JMETHOD(boolean, decode_mcu, (j_decompress_ptr cinfo,
+				JBLOCKROW *MCU_data));
+};
+
+/* Inverse DCT (also performs dequantization) */
+typedef JMETHOD(void, inverse_DCT_method_ptr,
+		(j_decompress_ptr cinfo, jpeg_component_info * compptr,
+		 JCOEFPTR coef_block,
+		 JSAMPARRAY output_buf, JDIMENSION output_col));
+
+struct jpeg_inverse_dct {
+  JMETHOD(void, start_pass, (j_decompress_ptr cinfo));
+  /* It is useful to allow each component to have a separate IDCT method. */
+  inverse_DCT_method_ptr inverse_DCT[MAX_COMPONENTS];
+};
+
+/* Upsampling (note that upsampler must also call color converter) */
+struct jpeg_upsampler {
+  JMETHOD(void, start_pass, (j_decompress_ptr cinfo));
+  JMETHOD(void, upsample, (j_decompress_ptr cinfo,
+			   JSAMPIMAGE input_buf,
+			   JDIMENSION *in_row_group_ctr,
+			   JDIMENSION in_row_groups_avail,
+			   JSAMPARRAY output_buf,
+			   JDIMENSION *out_row_ctr,
+			   JDIMENSION out_rows_avail));
+
+  boolean need_context_rows;	/* TRUE if need rows above & below */
+};
+
+/* Colorspace conversion */
+struct jpeg_color_deconverter {
+  JMETHOD(void, start_pass, (j_decompress_ptr cinfo));
+  JMETHOD(void, color_convert, (j_decompress_ptr cinfo,
+				JSAMPIMAGE input_buf, JDIMENSION input_row,
+				JSAMPARRAY output_buf, int num_rows));
+};
+
+/* Color quantization or color precision reduction */
+struct jpeg_color_quantizer {
+  JMETHOD(void, start_pass, (j_decompress_ptr cinfo, boolean is_pre_scan));
+  JMETHOD(void, color_quantize, (j_decompress_ptr cinfo,
+				 JSAMPARRAY input_buf, JSAMPARRAY output_buf,
+				 int num_rows));
+  JMETHOD(void, finish_pass, (j_decompress_ptr cinfo));
+  JMETHOD(void, new_color_map, (j_decompress_ptr cinfo));
+};
+
+
+/* Miscellaneous useful macros */
+
+#undef MAX
+#define MAX(a,b)	((a) > (b) ? (a) : (b))
+#undef MIN
+#define MIN(a,b)	((a) < (b) ? (a) : (b))
+
+
+/* We assume that right shift corresponds to signed division by 2 with
+ * rounding towards minus infinity.  This is correct for typical "arithmetic
+ * shift" instructions that shift in copies of the sign bit.  But some
+ * C compilers implement >> with an unsigned shift.  For these machines you
+ * must define RIGHT_SHIFT_IS_UNSIGNED.
+ * RIGHT_SHIFT provides a proper signed right shift of an INT32 quantity.
+ * It is only applied with constant shift counts.  SHIFT_TEMPS must be
+ * included in the variables of any routine using RIGHT_SHIFT.
+ */
+
+#ifdef RIGHT_SHIFT_IS_UNSIGNED
+#define SHIFT_TEMPS	INT32 shift_temp;
+#define RIGHT_SHIFT(x,shft)  \
+	((shift_temp = (x)) < 0 ? \
+	 (shift_temp >> (shft)) | ((~((INT32) 0)) << (32-(shft))) : \
+	 (shift_temp >> (shft)))
+#else
+#define SHIFT_TEMPS
+#define RIGHT_SHIFT(x,shft)	((x) >> (shft))
+#endif
+
+
+/* Short forms of external names for systems with brain-damaged linkers. */
+
+#ifdef NEED_SHORT_EXTERNAL_NAMES
+#define jinit_compress_master	jICompress
+#define jinit_c_master_control	jICMaster
+#define jinit_c_main_controller	jICMainC
+#define jinit_c_prep_controller	jICPrepC
+#define jinit_c_coef_controller	jICCoefC
+#define jinit_color_converter	jICColor
+#define jinit_downsampler	jIDownsampler
+#define jinit_forward_dct	jIFDCT
+#define jinit_huff_encoder	jIHEncoder
+#define jinit_phuff_encoder	jIPHEncoder
+#define jinit_marker_writer	jIMWriter
+#define jinit_master_decompress	jIDMaster
+#define jinit_d_main_controller	jIDMainC
+#define jinit_d_coef_controller	jIDCoefC
+#define jinit_d_post_controller	jIDPostC
+#define jinit_input_controller	jIInCtlr
+#define jinit_marker_reader	jIMReader
+#define jinit_huff_decoder	jIHDecoder
+#define jinit_phuff_decoder	jIPHDecoder
+#define jinit_inverse_dct	jIIDCT
+#define jinit_upsampler		jIUpsampler
+#define jinit_color_deconverter	jIDColor
+#define jinit_1pass_quantizer	jI1Quant
+#define jinit_2pass_quantizer	jI2Quant
+#define jinit_merged_upsampler	jIMUpsampler
+#define jinit_memory_mgr	jIMemMgr
+#define jdiv_round_up		jDivRound
+#define jround_up		jRound
+#define jcopy_sample_rows	jCopySamples
+#define jcopy_block_row		jCopyBlocks
+#define jzero_far		jZeroFar
+#define jpeg_zigzag_order	jZIGTable
+#define jpeg_natural_order	jZAGTable
+#endif /* NEED_SHORT_EXTERNAL_NAMES */
+
+
+/* Compression module initialization routines */
+EXTERN void jinit_compress_master JPP((j_compress_ptr cinfo));
+EXTERN void jinit_c_master_control JPP((j_compress_ptr cinfo,
+					boolean transcode_only));
+EXTERN void jinit_c_main_controller JPP((j_compress_ptr cinfo,
+					 boolean need_full_buffer));
+EXTERN void jinit_c_prep_controller JPP((j_compress_ptr cinfo,
+					 boolean need_full_buffer));
+EXTERN void jinit_c_coef_controller JPP((j_compress_ptr cinfo,
+					 boolean need_full_buffer));
+EXTERN void jinit_color_converter JPP((j_compress_ptr cinfo));
+EXTERN void jinit_downsampler JPP((j_compress_ptr cinfo));
+EXTERN void jinit_forward_dct JPP((j_compress_ptr cinfo));
+EXTERN void jinit_huff_encoder JPP((j_compress_ptr cinfo));
+EXTERN void jinit_phuff_encoder JPP((j_compress_ptr cinfo));
+EXTERN void jinit_marker_writer JPP((j_compress_ptr cinfo));
+/* Decompression module initialization routines */
+EXTERN void jinit_master_decompress JPP((j_decompress_ptr cinfo));
+EXTERN void jinit_d_main_controller JPP((j_decompress_ptr cinfo,
+					 boolean need_full_buffer));
+EXTERN void jinit_d_coef_controller JPP((j_decompress_ptr cinfo,
+					 boolean need_full_buffer));
+EXTERN void jinit_d_post_controller JPP((j_decompress_ptr cinfo,
+					 boolean need_full_buffer));
+EXTERN void jinit_input_controller JPP((j_decompress_ptr cinfo));
+EXTERN void jinit_marker_reader JPP((j_decompress_ptr cinfo));
+EXTERN void jinit_huff_decoder JPP((j_decompress_ptr cinfo));
+EXTERN void jinit_phuff_decoder JPP((j_decompress_ptr cinfo));
+EXTERN void jinit_inverse_dct JPP((j_decompress_ptr cinfo));
+EXTERN void jinit_upsampler JPP((j_decompress_ptr cinfo));
+EXTERN void jinit_color_deconverter JPP((j_decompress_ptr cinfo));
+EXTERN void jinit_1pass_quantizer JPP((j_decompress_ptr cinfo));
+EXTERN void jinit_2pass_quantizer JPP((j_decompress_ptr cinfo));
+EXTERN void jinit_merged_upsampler JPP((j_decompress_ptr cinfo));
+/* Memory manager initialization */
+EXTERN void jinit_memory_mgr JPP((j_common_ptr cinfo));
+
+/* Utility routines in jutils.c */
+EXTERN long jdiv_round_up JPP((long a, long b));
+EXTERN long jround_up JPP((long a, long b));
+EXTERN void jcopy_sample_rows JPP((JSAMPARRAY input_array, int source_row,
+				   JSAMPARRAY output_array, int dest_row,
+				   int num_rows, JDIMENSION num_cols));
+EXTERN void jcopy_block_row JPP((JBLOCKROW input_row, JBLOCKROW output_row,
+				 JDIMENSION num_blocks));
+EXTERN void jzero_far JPP((void FAR * target, size_t bytestozero));
+/* Constant tables in jutils.c */
+extern const int jpeg_zigzag_order[]; /* natural coef order to zigzag order */
+extern const int jpeg_natural_order[]; /* zigzag coef order to natural order */
+
+/* Suppress undefined-structure complaints if necessary. */
+
+#ifdef INCOMPLETE_TYPES_BROKEN
+#ifndef AM_MEMORY_MANAGER	/* only jmemmgr.c defines these */
+struct jvirt_sarray_control { long dummy; };
+struct jvirt_barray_control { long dummy; };
+#endif
+#endif /* INCOMPLETE_TYPES_BROKEN */
diff --git a/codemp/jpeg-6/jpeglib.h b/codemp/jpeg-6/jpeglib.h
new file mode 100644
index 0000000..dee1545
--- /dev/null
+++ b/codemp/jpeg-6/jpeglib.h
@@ -0,0 +1,1055 @@
+/*
+ * jpeglib.h
+ *
+ * Copyright (C) 1991-1995, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file defines the application interface for the JPEG library.
+ * Most applications using the library need only include this file,
+ * and perhaps jerror.h if they want to know the exact error codes.
+ */
+
+#ifndef JPEGLIB_H
+#define JPEGLIB_H
+
+#if !defined(TR_LOCAL_H)
+	#include "../renderer/tr_local.h"
+#endif
+
+typedef unsigned char boolean;
+/*
+ * First we include the configuration files that record how this
+ * installation of the JPEG library is set up.  jconfig.h can be
+ * generated automatically for many systems.  jmorecfg.h contains
+ * manual configuration options that most people need not worry about.
+ */
+
+#ifndef JCONFIG_INCLUDED	/* in case jinclude.h already did */
+#include "../jpeg-6/jconfig.h"		/* widely used configuration options */
+#endif
+#include "../jpeg-6/jmorecfg.h"		/* seldom changed options */
+
+
+/* Version ID for the JPEG library.
+ * Might be useful for tests like "#if JPEG_LIB_VERSION >= 60".
+ */
+
+#define JPEG_LIB_VERSION  60	/* Version 6 */
+
+
+/* Various constants determining the sizes of things.
+ * All of these are specified by the JPEG standard, so don't change them
+ * if you want to be compatible.
+ */
+
+#define DCTSIZE		    8	/* The basic DCT block is 8x8 samples */
+#define DCTSIZE2	    64	/* DCTSIZE squared; # of elements in a block */
+#define NUM_QUANT_TBLS      4	/* Quantization tables are numbered 0..3 */
+#define NUM_HUFF_TBLS       4	/* Huffman tables are numbered 0..3 */
+#define NUM_ARITH_TBLS      16	/* Arith-coding tables are numbered 0..15 */
+#define MAX_COMPS_IN_SCAN   4	/* JPEG limit on # of components in one scan */
+#define MAX_SAMP_FACTOR     4	/* JPEG limit on sampling factors */
+/* Unfortunately, some bozo at Adobe saw no reason to be bound by the standard;
+ * the PostScript DCT filter can emit files with many more than 10 blocks/MCU.
+ * If you happen to run across such a file, you can up D_MAX_BLOCKS_IN_MCU
+ * to handle it.  We even let you do this from the jconfig.h file.  However,
+ * we strongly discourage changing C_MAX_BLOCKS_IN_MCU; just because Adobe
+ * sometimes emits noncompliant files doesn't mean you should too.
+ */
+#define C_MAX_BLOCKS_IN_MCU   10 /* compressor's limit on blocks per MCU */
+#ifndef D_MAX_BLOCKS_IN_MCU
+#define D_MAX_BLOCKS_IN_MCU   10 /* decompressor's limit on blocks per MCU */
+#endif
+
+
+/* This macro is used to declare a "method", that is, a function pointer.
+ * We want to supply prototype parameters if the compiler can cope.
+ * Note that the arglist parameter must be parenthesized!
+ */
+
+#ifdef HAVE_PROTOTYPES
+#define JMETHOD(type,methodname,arglist)  type (*methodname) arglist
+#else
+#define JMETHOD(type,methodname,arglist)  type (*methodname) ()
+#endif
+
+
+/* Data structures for images (arrays of samples and of DCT coefficients).
+ * On 80x86 machines, the image arrays are too big for near pointers,
+ * but the pointer arrays can fit in near memory.
+ */
+
+typedef JSAMPLE FAR *JSAMPROW;	/* ptr to one image row of pixel samples. */
+typedef JSAMPROW *JSAMPARRAY;	/* ptr to some rows (a 2-D sample array) */
+typedef JSAMPARRAY *JSAMPIMAGE;	/* a 3-D sample array: top index is color */
+
+typedef JCOEF JBLOCK[DCTSIZE2];	/* one block of coefficients */
+typedef JBLOCK FAR *JBLOCKROW;	/* pointer to one row of coefficient blocks */
+typedef JBLOCKROW *JBLOCKARRAY;		/* a 2-D array of coefficient blocks */
+typedef JBLOCKARRAY *JBLOCKIMAGE;	/* a 3-D array of coefficient blocks */
+
+typedef JCOEF FAR *JCOEFPTR;	/* useful in a couple of places */
+
+
+/* Types for JPEG compression parameters and working tables. */
+
+
+/* DCT coefficient quantization tables. */
+
+typedef struct {
+  /* This field directly represents the contents of a JPEG DQT marker.
+   * Note: the values are always given in zigzag order.
+   */
+  UINT16 quantval[DCTSIZE2];	/* quantization step for each coefficient */
+  /* This field is used only during compression.  It's initialized FALSE when
+   * the table is created, and set TRUE when it's been output to the file.
+   * You could suppress output of a table by setting this to TRUE.
+   * (See jpeg_suppress_tables for an example.)
+   */
+  boolean sent_table;		/* TRUE when table has been output */
+} JQUANT_TBL;
+
+
+/* Huffman coding tables. */
+
+typedef struct {
+  /* These two fields directly represent the contents of a JPEG DHT marker */
+  UINT8 bits[17];		/* bits[k] = # of symbols with codes of */
+				/* length k bits; bits[0] is unused */
+  UINT8 huffval[256];		/* The symbols, in order of incr code length */
+  /* This field is used only during compression.  It's initialized FALSE when
+   * the table is created, and set TRUE when it's been output to the file.
+   * You could suppress output of a table by setting this to TRUE.
+   * (See jpeg_suppress_tables for an example.)
+   */
+  boolean sent_table;		/* TRUE when table has been output */
+} JHUFF_TBL;
+
+
+/* Basic info about one component (color channel). */
+
+typedef struct {
+  /* These values are fixed over the whole image. */
+  /* For compression, they must be supplied by parameter setup; */
+  /* for decompression, they are read from the SOF marker. */
+  int component_id;		/* identifier for this component (0..255) */
+  int component_index;		/* its index in SOF or cinfo->comp_info[] */
+  int h_samp_factor;		/* horizontal sampling factor (1..4) */
+  int v_samp_factor;		/* vertical sampling factor (1..4) */
+  int quant_tbl_no;		/* quantization table selector (0..3) */
+  /* These values may vary between scans. */
+  /* For compression, they must be supplied by parameter setup; */
+  /* for decompression, they are read from the SOS marker. */
+  /* The decompressor output side may not use these variables. */
+  int dc_tbl_no;		/* DC entropy table selector (0..3) */
+  int ac_tbl_no;		/* AC entropy table selector (0..3) */
+  
+  /* Remaining fields should be treated as private by applications. */
+  
+  /* These values are computed during compression or decompression startup: */
+  /* Component's size in DCT blocks.
+   * Any dummy blocks added to complete an MCU are not counted; therefore
+   * these values do not depend on whether a scan is interleaved or not.
+   */
+  JDIMENSION width_in_blocks;
+  JDIMENSION height_in_blocks;
+  /* Size of a DCT block in samples.  Always DCTSIZE for compression.
+   * For decompression this is the size of the output from one DCT block,
+   * reflecting any scaling we choose to apply during the IDCT step.
+   * Values of 1,2,4,8 are likely to be supported.  Note that different
+   * components may receive different IDCT scalings.
+   */
+  int DCT_scaled_size;
+  /* The downsampled dimensions are the component's actual, unpadded number
+   * of samples at the main buffer (preprocessing/compression interface), thus
+   * downsampled_width = ceil(image_width * Hi/Hmax)
+   * and similarly for height.  For decompression, IDCT scaling is included, so
+   * downsampled_width = ceil(image_width * Hi/Hmax * DCT_scaled_size/DCTSIZE)
+   */
+  JDIMENSION downsampled_width;	 /* actual width in samples */
+  JDIMENSION downsampled_height; /* actual height in samples */
+  /* This flag is used only for decompression.  In cases where some of the
+   * components will be ignored (eg grayscale output from YCbCr image),
+   * we can skip most computations for the unused components.
+   */
+  boolean component_needed;	/* do we need the value of this component? */
+
+  /* These values are computed before starting a scan of the component. */
+  /* The decompressor output side may not use these variables. */
+  int MCU_width;		/* number of blocks per MCU, horizontally */
+  int MCU_height;		/* number of blocks per MCU, vertically */
+  int MCU_blocks;		/* MCU_width * MCU_height */
+  int MCU_sample_width;		/* MCU width in samples, MCU_width*DCT_scaled_size */
+  int last_col_width;		/* # of non-dummy blocks across in last MCU */
+  int last_row_height;		/* # of non-dummy blocks down in last MCU */
+
+  /* Saved quantization table for component; NULL if none yet saved.
+   * See jdinput.c comments about the need for this information.
+   * This field is not currently used by the compressor.
+   */
+  JQUANT_TBL * quant_table;
+
+  /* Private per-component storage for DCT or IDCT subsystem. */
+  void * dct_table;
+} jpeg_component_info;
+
+
+/* The script for encoding a multiple-scan file is an array of these: */
+
+typedef struct {
+  int comps_in_scan;		/* number of components encoded in this scan */
+  int component_index[MAX_COMPS_IN_SCAN]; /* their SOF/comp_info[] indexes */
+  int Ss, Se;			/* progressive JPEG spectral selection parms */
+  int Ah, Al;			/* progressive JPEG successive approx. parms */
+} jpeg_scan_info;
+
+
+/* Known color spaces. */
+
+typedef enum {
+	JCS_UNKNOWN,		/* error/unspecified */
+	JCS_GRAYSCALE,		/* monochrome */
+	JCS_RGB,		/* red/green/blue */
+	JCS_YCbCr,		/* Y/Cb/Cr (also known as YUV) */
+	JCS_CMYK,		/* C/M/Y/K */
+	JCS_YCCK		/* Y/Cb/Cr/K */
+} J_COLOR_SPACE;
+
+/* DCT/IDCT algorithm options. */
+
+typedef enum {
+	JDCT_ISLOW,		/* slow but accurate integer algorithm */
+	JDCT_IFAST,		/* faster, less accurate integer method */
+	JDCT_FLOAT		/* floating-point: accurate, fast on fast HW */
+} J_DCT_METHOD;
+
+#ifndef JDCT_DEFAULT		/* may be overridden in jconfig.h */
+#define JDCT_DEFAULT  JDCT_ISLOW
+#endif
+#ifndef JDCT_FASTEST		/* may be overridden in jconfig.h */
+#define JDCT_FASTEST  JDCT_IFAST
+#endif
+
+/* Dithering options for decompression. */
+
+typedef enum {
+	JDITHER_NONE,		/* no dithering */
+	JDITHER_ORDERED,	/* simple ordered dither */
+	JDITHER_FS		/* Floyd-Steinberg error diffusion dither */
+} J_DITHER_MODE;
+
+
+/* Common fields between JPEG compression and decompression master structs. */
+
+#define jpeg_common_fields \
+  struct jpeg_error_mgr * err;	/* Error handler module */\
+  struct jpeg_memory_mgr * mem;	/* Memory manager module */\
+  struct jpeg_progress_mgr * progress; /* Progress monitor, or NULL if none */\
+  boolean is_decompressor;	/* so common code can tell which is which */\
+  int global_state		/* for checking call sequence validity */
+
+/* Routines that are to be used by both halves of the library are declared
+ * to receive a pointer to this structure.  There are no actual instances of
+ * jpeg_common_struct, only of jpeg_compress_struct and jpeg_decompress_struct.
+ */
+struct jpeg_common_struct {
+  jpeg_common_fields;		/* Fields common to both master struct types */
+  /* Additional fields follow in an actual jpeg_compress_struct or
+   * jpeg_decompress_struct.  All three structs must agree on these
+   * initial fields!  (This would be a lot cleaner in C++.)
+   */
+};
+
+typedef struct jpeg_common_struct * j_common_ptr;
+typedef struct jpeg_compress_struct * j_compress_ptr;
+typedef struct jpeg_decompress_struct * j_decompress_ptr;
+
+
+/* Master record for a compression instance */
+
+struct jpeg_compress_struct {
+  jpeg_common_fields;		/* Fields shared with jpeg_decompress_struct */
+
+  /* Destination for compressed data */
+  struct jpeg_destination_mgr * dest;
+
+  /* Description of source image --- these fields must be filled in by
+   * outer application before starting compression.  in_color_space must
+   * be correct before you can even call jpeg_set_defaults().
+   */
+
+  JDIMENSION image_width;	/* input image width */
+  JDIMENSION image_height;	/* input image height */
+  int input_components;		/* # of color components in input image */
+  J_COLOR_SPACE in_color_space;	/* colorspace of input image */
+
+  double input_gamma;		/* image gamma of input image */
+
+  /* Compression parameters --- these fields must be set before calling
+   * jpeg_start_compress().  We recommend calling jpeg_set_defaults() to
+   * initialize everything to reasonable defaults, then changing anything
+   * the application specifically wants to change.  That way you won't get
+   * burnt when new parameters are added.  Also note that there are several
+   * helper routines to simplify changing parameters.
+   */
+
+  int data_precision;		/* bits of precision in image data */
+
+  int num_components;		/* # of color components in JPEG image */
+  J_COLOR_SPACE jpeg_color_space; /* colorspace of JPEG image */
+
+  jpeg_component_info * comp_info;
+  /* comp_info[i] describes component that appears i'th in SOF */
+  
+  JQUANT_TBL * quant_tbl_ptrs[NUM_QUANT_TBLS];
+  /* ptrs to coefficient quantization tables, or NULL if not defined */
+  
+  JHUFF_TBL * dc_huff_tbl_ptrs[NUM_HUFF_TBLS];
+  JHUFF_TBL * ac_huff_tbl_ptrs[NUM_HUFF_TBLS];
+  /* ptrs to Huffman coding tables, or NULL if not defined */
+  
+  UINT8 arith_dc_L[NUM_ARITH_TBLS]; /* L values for DC arith-coding tables */
+  UINT8 arith_dc_U[NUM_ARITH_TBLS]; /* U values for DC arith-coding tables */
+  UINT8 arith_ac_K[NUM_ARITH_TBLS]; /* Kx values for AC arith-coding tables */
+
+  int num_scans;		/* # of entries in scan_info array */
+  const jpeg_scan_info * scan_info; /* script for multi-scan file, or NULL */
+  /* The default value of scan_info is NULL, which causes a single-scan
+   * sequential JPEG file to be emitted.  To create a multi-scan file,
+   * set num_scans and scan_info to point to an array of scan definitions.
+   */
+
+  boolean raw_data_in;		/* TRUE=caller supplies downsampled data */
+  boolean arith_code;		/* TRUE=arithmetic coding, FALSE=Huffman */
+  boolean optimize_coding;	/* TRUE=optimize entropy encoding parms */
+  boolean CCIR601_sampling;	/* TRUE=first samples are cosited */
+  int smoothing_factor;		/* 1..100, or 0 for no input smoothing */
+  J_DCT_METHOD dct_method;	/* DCT algorithm selector */
+
+  /* The restart interval can be specified in absolute MCUs by setting
+   * restart_interval, or in MCU rows by setting restart_in_rows
+   * (in which case the correct restart_interval will be figured
+   * for each scan).
+   */
+  unsigned int restart_interval; /* MCUs per restart, or 0 for no restart */
+  int restart_in_rows;		/* if > 0, MCU rows per restart interval */
+
+  /* Parameters controlling emission of special markers. */
+
+  boolean write_JFIF_header;	/* should a JFIF marker be written? */
+  /* These three values are not used by the JPEG code, merely copied */
+  /* into the JFIF APP0 marker.  density_unit can be 0 for unknown, */
+  /* 1 for dots/inch, or 2 for dots/cm.  Note that the pixel aspect */
+  /* ratio is defined by X_density/Y_density even when density_unit=0. */
+  UINT8 density_unit;		/* JFIF code for pixel size units */
+  UINT16 X_density;		/* Horizontal pixel density */
+  UINT16 Y_density;		/* Vertical pixel density */
+  boolean write_Adobe_marker;	/* should an Adobe marker be written? */
+  
+  /* State variable: index of next scanline to be written to
+   * jpeg_write_scanlines().  Application may use this to control its
+   * processing loop, e.g., "while (next_scanline < image_height)".
+   */
+
+  JDIMENSION next_scanline;	/* 0 .. image_height-1  */
+
+  /* Remaining fields are known throughout compressor, but generally
+   * should not be touched by a surrounding application.
+   */
+
+  /*
+   * These fields are computed during compression startup
+   */
+  boolean progressive_mode;	/* TRUE if scan script uses progressive mode */
+  int max_h_samp_factor;	/* largest h_samp_factor */
+  int max_v_samp_factor;	/* largest v_samp_factor */
+
+  JDIMENSION total_iMCU_rows;	/* # of iMCU rows to be input to coef ctlr */
+  /* The coefficient controller receives data in units of MCU rows as defined
+   * for fully interleaved scans (whether the JPEG file is interleaved or not).
+   * There are v_samp_factor * DCTSIZE sample rows of each component in an
+   * "iMCU" (interleaved MCU) row.
+   */
+  
+  /*
+   * These fields are valid during any one scan.
+   * They describe the components and MCUs actually appearing in the scan.
+   */
+  int comps_in_scan;		/* # of JPEG components in this scan */
+  jpeg_component_info * cur_comp_info[MAX_COMPS_IN_SCAN];
+  /* *cur_comp_info[i] describes component that appears i'th in SOS */
+  
+  JDIMENSION MCUs_per_row;	/* # of MCUs across the image */
+  JDIMENSION MCU_rows_in_scan;	/* # of MCU rows in the image */
+  
+  int blocks_in_MCU;		/* # of DCT blocks per MCU */
+  int MCU_membership[C_MAX_BLOCKS_IN_MCU];
+  /* MCU_membership[i] is index in cur_comp_info of component owning */
+  /* i'th block in an MCU */
+
+  int Ss, Se, Ah, Al;		/* progressive JPEG parameters for scan */
+
+  /*
+   * Links to compression subobjects (methods and private variables of modules)
+   */
+  struct jpeg_comp_master * master;
+  struct jpeg_c_main_controller * main;
+  struct jpeg_c_prep_controller * prep;
+  struct jpeg_c_coef_controller * coef;
+  struct jpeg_marker_writer * marker;
+  struct jpeg_color_converter * cconvert;
+  struct jpeg_downsampler * downsample;
+  struct jpeg_forward_dct * fdct;
+  struct jpeg_entropy_encoder * entropy;
+};
+
+
+/* Master record for a decompression instance */
+
+struct jpeg_decompress_struct {
+  jpeg_common_fields;		/* Fields shared with jpeg_compress_struct */
+
+  /* Source of compressed data */
+  struct jpeg_source_mgr * src;
+
+  /* Basic description of image --- filled in by jpeg_read_header(). */
+  /* Application may inspect these values to decide how to process image. */
+
+  JDIMENSION image_width;	/* nominal image width (from SOF marker) */
+  JDIMENSION image_height;	/* nominal image height */
+  int num_components;		/* # of color components in JPEG image */
+  J_COLOR_SPACE jpeg_color_space; /* colorspace of JPEG image */
+
+  /* Decompression processing parameters --- these fields must be set before
+   * calling jpeg_start_decompress().  Note that jpeg_read_header() initializes
+   * them to default values.
+   */
+
+  J_COLOR_SPACE out_color_space; /* colorspace for output */
+
+  unsigned int scale_num, scale_denom; /* fraction by which to scale image */
+
+  double output_gamma;		/* image gamma wanted in output */
+
+  boolean buffered_image;	/* TRUE=multiple output passes */
+  boolean raw_data_out;		/* TRUE=downsampled data wanted */
+
+  J_DCT_METHOD dct_method;	/* IDCT algorithm selector */
+  boolean do_fancy_upsampling;	/* TRUE=apply fancy upsampling */
+  boolean do_block_smoothing;	/* TRUE=apply interblock smoothing */
+
+  boolean quantize_colors;	/* TRUE=colormapped output wanted */
+  /* the following are ignored if not quantize_colors: */
+  J_DITHER_MODE dither_mode;	/* type of color dithering to use */
+  boolean two_pass_quantize;	/* TRUE=use two-pass color quantization */
+  int desired_number_of_colors;	/* max # colors to use in created colormap */
+  /* these are significant only in buffered-image mode: */
+  boolean enable_1pass_quant;	/* enable future use of 1-pass quantizer */
+  boolean enable_external_quant;/* enable future use of external colormap */
+  boolean enable_2pass_quant;	/* enable future use of 2-pass quantizer */
+
+  /* Description of actual output image that will be returned to application.
+   * These fields are computed by jpeg_start_decompress().
+   * You can also use jpeg_calc_output_dimensions() to determine these values
+   * in advance of calling jpeg_start_decompress().
+   */
+
+  JDIMENSION output_width;	/* scaled image width */
+  JDIMENSION output_height;	/* scaled image height */
+  int out_color_components;	/* # of color components in out_color_space */
+  int output_components;	/* # of color components returned */
+  /* output_components is 1 (a colormap index) when quantizing colors;
+   * otherwise it equals out_color_components.
+   */
+  int rec_outbuf_height;	/* min recommended height of scanline buffer */
+  /* If the buffer passed to jpeg_read_scanlines() is less than this many rows
+   * high, space and time will be wasted due to unnecessary data copying.
+   * Usually rec_outbuf_height will be 1 or 2, at most 4.
+   */
+
+  /* When quantizing colors, the output colormap is described by these fields.
+   * The application can supply a colormap by setting colormap non-NULL before
+   * calling jpeg_start_decompress; otherwise a colormap is created during
+   * jpeg_start_decompress or jpeg_start_output.
+   * The map has out_color_components rows and actual_number_of_colors columns.
+   */
+  int actual_number_of_colors;	/* number of entries in use */
+  JSAMPARRAY colormap;		/* The color map as a 2-D pixel array */
+
+  /* State variables: these variables indicate the progress of decompression.
+   * The application may examine these but must not modify them.
+   */
+
+  /* Row index of next scanline to be read from jpeg_read_scanlines().
+   * Application may use this to control its processing loop, e.g.,
+   * "while (output_scanline < output_height)".
+   */
+  JDIMENSION output_scanline;	/* 0 .. output_height-1  */
+
+  /* Current input scan number and number of iMCU rows completed in scan.
+   * These indicate the progress of the decompressor input side.
+   */
+  int input_scan_number;	/* Number of SOS markers seen so far */
+  JDIMENSION input_iMCU_row;	/* Number of iMCU rows completed */
+
+  /* The "output scan number" is the notional scan being displayed by the
+   * output side.  The decompressor will not allow output scan/row number
+   * to get ahead of input scan/row, but it can fall arbitrarily far behind.
+   */
+  int output_scan_number;	/* Nominal scan number being displayed */
+  JDIMENSION output_iMCU_row;	/* Number of iMCU rows read */
+
+  /* Current progression status.  coef_bits[c][i] indicates the precision
+   * with which component c's DCT coefficient i (in zigzag order) is known.
+   * It is -1 when no data has yet been received, otherwise it is the point
+   * transform (shift) value for the most recent scan of the coefficient
+   * (thus, 0 at completion of the progression).
+   * This pointer is NULL when reading a non-progressive file.
+   */
+  int (*coef_bits)[DCTSIZE2];	/* -1 or current Al value for each coef */
+
+  /* Internal JPEG parameters --- the application usually need not look at
+   * these fields.  Note that the decompressor output side may not use
+   * any parameters that can change between scans.
+   */
+
+  /* Quantization and Huffman tables are carried forward across input
+   * datastreams when processing abbreviated JPEG datastreams.
+   */
+
+  JQUANT_TBL * quant_tbl_ptrs[NUM_QUANT_TBLS];
+  /* ptrs to coefficient quantization tables, or NULL if not defined */
+
+  JHUFF_TBL * dc_huff_tbl_ptrs[NUM_HUFF_TBLS];
+  JHUFF_TBL * ac_huff_tbl_ptrs[NUM_HUFF_TBLS];
+  /* ptrs to Huffman coding tables, or NULL if not defined */
+
+  /* These parameters are never carried across datastreams, since they
+   * are given in SOF/SOS markers or defined to be reset by SOI.
+   */
+
+  int data_precision;		/* bits of precision in image data */
+
+  jpeg_component_info * comp_info;
+  /* comp_info[i] describes component that appears i'th in SOF */
+
+  boolean progressive_mode;	/* TRUE if SOFn specifies progressive mode */
+  boolean arith_code;		/* TRUE=arithmetic coding, FALSE=Huffman */
+
+  UINT8 arith_dc_L[NUM_ARITH_TBLS]; /* L values for DC arith-coding tables */
+  UINT8 arith_dc_U[NUM_ARITH_TBLS]; /* U values for DC arith-coding tables */
+  UINT8 arith_ac_K[NUM_ARITH_TBLS]; /* Kx values for AC arith-coding tables */
+
+  unsigned int restart_interval; /* MCUs per restart interval, or 0 for no restart */
+
+  /* These fields record data obtained from optional markers recognized by
+   * the JPEG library.
+   */
+  boolean saw_JFIF_marker;	/* TRUE iff a JFIF APP0 marker was found */
+  /* Data copied from JFIF marker: */
+  UINT8 density_unit;		/* JFIF code for pixel size units */
+  UINT16 X_density;		/* Horizontal pixel density */
+  UINT16 Y_density;		/* Vertical pixel density */
+  boolean saw_Adobe_marker;	/* TRUE iff an Adobe APP14 marker was found */
+  UINT8 Adobe_transform;	/* Color transform code from Adobe marker */
+
+  boolean CCIR601_sampling;	/* TRUE=first samples are cosited */
+
+  /* Remaining fields are known throughout decompressor, but generally
+   * should not be touched by a surrounding application.
+   */
+
+  /*
+   * These fields are computed during decompression startup
+   */
+  int max_h_samp_factor;	/* largest h_samp_factor */
+  int max_v_samp_factor;	/* largest v_samp_factor */
+
+  int min_DCT_scaled_size;	/* smallest DCT_scaled_size of any component */
+
+  JDIMENSION total_iMCU_rows;	/* # of iMCU rows in image */
+  /* The coefficient controller's input and output progress is measured in
+   * units of "iMCU" (interleaved MCU) rows.  These are the same as MCU rows
+   * in fully interleaved JPEG scans, but are used whether the scan is
+   * interleaved or not.  We define an iMCU row as v_samp_factor DCT block
+   * rows of each component.  Therefore, the IDCT output contains
+   * v_samp_factor*DCT_scaled_size sample rows of a component per iMCU row.
+   */
+
+  JSAMPLE * sample_range_limit; /* table for fast range-limiting */
+
+  /*
+   * These fields are valid during any one scan.
+   * They describe the components and MCUs actually appearing in the scan.
+   * Note that the decompressor output side must not use these fields.
+   */
+  int comps_in_scan;		/* # of JPEG components in this scan */
+  jpeg_component_info * cur_comp_info[MAX_COMPS_IN_SCAN];
+  /* *cur_comp_info[i] describes component that appears i'th in SOS */
+
+  JDIMENSION MCUs_per_row;	/* # of MCUs across the image */
+  JDIMENSION MCU_rows_in_scan;	/* # of MCU rows in the image */
+
+  int blocks_in_MCU;		/* # of DCT blocks per MCU */
+  int MCU_membership[D_MAX_BLOCKS_IN_MCU];
+  /* MCU_membership[i] is index in cur_comp_info of component owning */
+  /* i'th block in an MCU */
+
+  int Ss, Se, Ah, Al;		/* progressive JPEG parameters for scan */
+
+  /* This field is shared between entropy decoder and marker parser.
+   * It is either zero or the code of a JPEG marker that has been
+   * read from the data source, but has not yet been processed.
+   */
+  int unread_marker;
+
+  /*
+   * Links to decompression subobjects (methods, private variables of modules)
+   */
+  struct jpeg_decomp_master * master;
+  struct jpeg_d_main_controller * main;
+  struct jpeg_d_coef_controller * coef;
+  struct jpeg_d_post_controller * post;
+  struct jpeg_input_controller * inputctl;
+  struct jpeg_marker_reader * marker;
+  struct jpeg_entropy_decoder * entropy;
+  struct jpeg_inverse_dct * idct;
+  struct jpeg_upsampler * upsample;
+  struct jpeg_color_deconverter * cconvert;
+  struct jpeg_color_quantizer * cquantize;
+};
+
+
+/* "Object" declarations for JPEG modules that may be supplied or called
+ * directly by the surrounding application.
+ * As with all objects in the JPEG library, these structs only define the
+ * publicly visible methods and state variables of a module.  Additional
+ * private fields may exist after the public ones.
+ */
+
+
+/* Error handler object */
+
+struct jpeg_error_mgr {
+  /* Error exit handler: does not return to caller */
+  JMETHOD(void, error_exit, (j_common_ptr cinfo));
+  /* Conditionally emit a trace or warning message */
+  JMETHOD(void, emit_message, (j_common_ptr cinfo, int msg_level));
+  /* Routine that actually outputs a trace or error message */
+  JMETHOD(void, output_message, (j_common_ptr cinfo));
+  /* Format a message string for the most recent JPEG error or message */
+  JMETHOD(void, format_message, (j_common_ptr cinfo, char * buffer));
+#define JMSG_LENGTH_MAX  200	/* recommended size of format_message buffer */
+  /* Reset error state variables at start of a new image */
+  JMETHOD(void, reset_error_mgr, (j_common_ptr cinfo));
+  
+  /* The message ID code and any parameters are saved here.
+   * A message can have one string parameter or up to 8 int parameters.
+   */
+  int msg_code;
+#define JMSG_STR_PARM_MAX  80
+  union {
+    int i[8];
+    char s[JMSG_STR_PARM_MAX];
+  } msg_parm;
+  
+  /* Standard state variables for error facility */
+  
+  int trace_level;		/* max msg_level that will be displayed */
+  
+  /* For recoverable corrupt-data errors, we emit a warning message,
+   * but keep going unless emit_message chooses to abort.  emit_message
+   * should count warnings in num_warnings.  The surrounding application
+   * can check for bad data by seeing if num_warnings is nonzero at the
+   * end of processing.
+   */
+  long num_warnings;		/* number of corrupt-data warnings */
+
+  /* These fields point to the table(s) of error message strings.
+   * An application can change the table pointer to switch to a different
+   * message list (typically, to change the language in which errors are
+   * reported).  Some applications may wish to add additional error codes
+   * that will be handled by the JPEG library error mechanism; the second
+   * table pointer is used for this purpose.
+   *
+   * First table includes all errors generated by JPEG library itself.
+   * Error code 0 is reserved for a "no such error string" message.
+   */
+  const char * const * jpeg_message_table; /* Library errors */
+  int last_jpeg_message;    /* Table contains strings 0..last_jpeg_message */
+  /* Second table can be added by application (see cjpeg/djpeg for example).
+   * It contains strings numbered first_addon_message..last_addon_message.
+   */
+  const char * const * addon_message_table; /* Non-library errors */
+  int first_addon_message;	/* code for first string in addon table */
+  int last_addon_message;	/* code for last string in addon table */
+};
+
+
+/* Progress monitor object */
+
+struct jpeg_progress_mgr {
+  JMETHOD(void, progress_monitor, (j_common_ptr cinfo));
+
+  long pass_counter;		/* work units completed in this pass */
+  long pass_limit;		/* total number of work units in this pass */
+  int completed_passes;		/* passes completed so far */
+  int total_passes;		/* total number of passes expected */
+};
+
+
+/* Data destination object for compression */
+
+struct jpeg_destination_mgr {
+  JOCTET * next_output_byte;	/* => next byte to write in buffer */
+  size_t free_in_buffer;	/* # of byte spaces remaining in buffer */
+
+  JMETHOD(void, init_destination, (j_compress_ptr cinfo));
+  JMETHOD(boolean, empty_output_buffer, (j_compress_ptr cinfo));
+  JMETHOD(void, term_destination, (j_compress_ptr cinfo));
+};
+
+
+/* Data source object for decompression */
+
+struct jpeg_source_mgr {
+  const JOCTET * next_input_byte; /* => next byte to read from buffer */
+  size_t bytes_in_buffer;	/* # of bytes remaining in buffer */
+
+  JMETHOD(void, init_source, (j_decompress_ptr cinfo));
+  JMETHOD(boolean, fill_input_buffer, (j_decompress_ptr cinfo));
+  JMETHOD(void, skip_input_data, (j_decompress_ptr cinfo, long num_bytes));
+  JMETHOD(boolean, resync_to_restart, (j_decompress_ptr cinfo, int desired));
+  JMETHOD(void, term_source, (j_decompress_ptr cinfo));
+};
+
+
+/* Memory manager object.
+ * Allocates "small" objects (a few K total), "large" objects (tens of K),
+ * and "really big" objects (virtual arrays with backing store if needed).
+ * The memory manager does not allow individual objects to be freed; rather,
+ * each created object is assigned to a pool, and whole pools can be freed
+ * at once.  This is faster and more convenient than remembering exactly what
+ * to free, especially where malloc()/free() are not too speedy.
+ * NB: alloc routines never return NULL.  They exit to error_exit if not
+ * successful.
+ */
+
+#define JPOOL_PERMANENT	0	/* lasts until master record is destroyed */
+#define JPOOL_IMAGE	1	/* lasts until done with image/datastream */
+#define JPOOL_NUMPOOLS	2
+
+typedef struct jvirt_sarray_control * jvirt_sarray_ptr;
+typedef struct jvirt_barray_control * jvirt_barray_ptr;
+
+
+struct jpeg_memory_mgr {
+  /* Method pointers */
+  JMETHOD(void *, alloc_small, (j_common_ptr cinfo, int pool_id,
+				size_t sizeofobject));
+  JMETHOD(void FAR *, alloc_large, (j_common_ptr cinfo, int pool_id,
+				     size_t sizeofobject));
+  JMETHOD(JSAMPARRAY, alloc_sarray, (j_common_ptr cinfo, int pool_id,
+				     JDIMENSION samplesperrow,
+				     JDIMENSION numrows));
+  JMETHOD(JBLOCKARRAY, alloc_barray, (j_common_ptr cinfo, int pool_id,
+				      JDIMENSION blocksperrow,
+				      JDIMENSION numrows));
+  JMETHOD(jvirt_sarray_ptr, request_virt_sarray, (j_common_ptr cinfo,
+						  int pool_id,
+						  boolean pre_zero,
+						  JDIMENSION samplesperrow,
+						  JDIMENSION numrows,
+						  JDIMENSION maxaccess));
+  JMETHOD(jvirt_barray_ptr, request_virt_barray, (j_common_ptr cinfo,
+						  int pool_id,
+						  boolean pre_zero,
+						  JDIMENSION blocksperrow,
+						  JDIMENSION numrows,
+						  JDIMENSION maxaccess));
+  JMETHOD(void, realize_virt_arrays, (j_common_ptr cinfo));
+  JMETHOD(JSAMPARRAY, access_virt_sarray, (j_common_ptr cinfo,
+					   jvirt_sarray_ptr ptr,
+					   JDIMENSION start_row,
+					   JDIMENSION num_rows,
+					   boolean writable));
+  JMETHOD(JBLOCKARRAY, access_virt_barray, (j_common_ptr cinfo,
+					    jvirt_barray_ptr ptr,
+					    JDIMENSION start_row,
+					    JDIMENSION num_rows,
+					    boolean writable));
+  JMETHOD(void, free_pool, (j_common_ptr cinfo, int pool_id));
+  JMETHOD(void, self_destruct, (j_common_ptr cinfo));
+
+  /* Limit on memory allocation for this JPEG object.  (Note that this is
+   * merely advisory, not a guaranteed maximum; it only affects the space
+   * used for virtual-array buffers.)  May be changed by outer application
+   * after creating the JPEG object.
+   */
+  long max_memory_to_use;
+};
+
+
+/* Routine signature for application-supplied marker processing methods.
+ * Need not pass marker code since it is stored in cinfo->unread_marker.
+ */
+typedef JMETHOD(boolean, jpeg_marker_parser_method, (j_decompress_ptr cinfo));
+
+
+/* Declarations for routines called by application.
+ * The JPP macro hides prototype parameters from compilers that can't cope.
+ * Note JPP requires double parentheses.
+ */
+
+#ifdef HAVE_PROTOTYPES
+#define JPP(arglist)	arglist
+#else
+#define JPP(arglist)	()
+#endif
+
+
+/* Short forms of external names for systems with brain-damaged linkers.
+ * We shorten external names to be unique in the first six letters, which
+ * is good enough for all known systems.
+ * (If your compiler itself needs names to be unique in less than 15 
+ * characters, you are out of luck.  Get a better compiler.)
+ */
+
+#ifdef NEED_SHORT_EXTERNAL_NAMES
+#define jpeg_std_error		jStdError
+#define jpeg_create_compress	jCreaCompress
+#define jpeg_create_decompress	jCreaDecompress
+#define jpeg_destroy_compress	jDestCompress
+#define jpeg_destroy_decompress	jDestDecompress
+#define jpeg_stdio_dest		jStdDest
+#define jpeg_stdio_src		jStdSrc
+#define jpeg_set_defaults	jSetDefaults
+#define jpeg_set_colorspace	jSetColorspace
+#define jpeg_default_colorspace	jDefColorspace
+#define jpeg_set_quality	jSetQuality
+#define jpeg_set_linear_quality	jSetLQuality
+#define jpeg_add_quant_table	jAddQuantTable
+#define jpeg_quality_scaling	jQualityScaling
+#define jpeg_simple_progression	jSimProgress
+#define jpeg_suppress_tables	jSuppressTables
+#define jpeg_alloc_quant_table	jAlcQTable
+#define jpeg_alloc_huff_table	jAlcHTable
+#define jpeg_start_compress	jStrtCompress
+#define jpeg_write_scanlines	jWrtScanlines
+#define jpeg_finish_compress	jFinCompress
+#define jpeg_write_raw_data	jWrtRawData
+#define jpeg_write_marker	jWrtMarker
+#define jpeg_write_tables	jWrtTables
+#define jpeg_read_header	jReadHeader
+#define jpeg_start_decompress	jStrtDecompress
+#define jpeg_read_scanlines	jReadScanlines
+#define jpeg_finish_decompress	jFinDecompress
+#define jpeg_read_raw_data	jReadRawData
+#define jpeg_has_multiple_scans	jHasMultScn
+#define jpeg_start_output	jStrtOutput
+#define jpeg_finish_output	jFinOutput
+#define jpeg_input_complete	jInComplete
+#define jpeg_new_colormap	jNewCMap
+#define jpeg_consume_input	jConsumeInput
+#define jpeg_calc_output_dimensions	jCalcDimensions
+#define jpeg_set_marker_processor	jSetMarker
+#define jpeg_read_coefficients	jReadCoefs
+#define jpeg_write_coefficients	jWrtCoefs
+#define jpeg_copy_critical_parameters	jCopyCrit
+#define jpeg_abort_compress	jAbrtCompress
+#define jpeg_abort_decompress	jAbrtDecompress
+#define jpeg_abort		jAbort
+#define jpeg_destroy		jDestroy
+#define jpeg_resync_to_restart	jResyncRestart
+#endif /* NEED_SHORT_EXTERNAL_NAMES */
+
+
+/* Default error-management setup */
+EXTERN struct jpeg_error_mgr *jpeg_std_error JPP((struct jpeg_error_mgr *err));
+
+/* Initialization and destruction of JPEG compression objects */
+/* NB: you must set up the error-manager BEFORE calling jpeg_create_xxx */
+EXTERN void jpeg_create_compress JPP((j_compress_ptr cinfo));
+EXTERN void jpeg_create_decompress JPP((j_decompress_ptr cinfo));
+EXTERN void jpeg_destroy_compress JPP((j_compress_ptr cinfo));
+EXTERN void jpeg_destroy_decompress JPP((j_decompress_ptr cinfo));
+
+/* Standard data source and destination managers: stdio streams. */
+/* Caller is responsible for opening the file before and closing after. */
+EXTERN void jpeg_stdio_dest JPP((j_compress_ptr cinfo, FILE * outfile));
+EXTERN void jpeg_stdio_src JPP((j_decompress_ptr cinfo, unsigned char *infile));
+
+/* Default parameter setup for compression */
+EXTERN void jpeg_set_defaults JPP((j_compress_ptr cinfo));
+/* Compression parameter setup aids */
+EXTERN void jpeg_set_colorspace JPP((j_compress_ptr cinfo,
+				     J_COLOR_SPACE colorspace));
+EXTERN void jpeg_default_colorspace JPP((j_compress_ptr cinfo));
+EXTERN void jpeg_set_quality JPP((j_compress_ptr cinfo, int quality,
+				  boolean force_baseline));
+EXTERN void jpeg_set_linear_quality JPP((j_compress_ptr cinfo,
+					 int scale_factor,
+					 boolean force_baseline));
+EXTERN void jpeg_add_quant_table JPP((j_compress_ptr cinfo, int which_tbl,
+				      const unsigned int *basic_table,
+				      int scale_factor,
+				      boolean force_baseline));
+EXTERN int jpeg_quality_scaling JPP((int quality));
+EXTERN void jpeg_simple_progression JPP((j_compress_ptr cinfo));
+EXTERN void jpeg_suppress_tables JPP((j_compress_ptr cinfo,
+				      boolean suppress));
+EXTERN JQUANT_TBL * jpeg_alloc_quant_table JPP((j_common_ptr cinfo));
+EXTERN JHUFF_TBL * jpeg_alloc_huff_table JPP((j_common_ptr cinfo));
+
+/* Main entry points for compression */
+EXTERN void jpeg_start_compress JPP((j_compress_ptr cinfo,
+				     boolean write_all_tables));
+EXTERN JDIMENSION jpeg_write_scanlines JPP((j_compress_ptr cinfo,
+					    JSAMPARRAY scanlines,
+					    JDIMENSION num_lines));
+EXTERN void jpeg_finish_compress JPP((j_compress_ptr cinfo));
+
+/* Replaces jpeg_write_scanlines when writing raw downsampled data. */
+EXTERN JDIMENSION jpeg_write_raw_data JPP((j_compress_ptr cinfo,
+					   JSAMPIMAGE data,
+					   JDIMENSION num_lines));
+
+/* Write a special marker.  See libjpeg.doc concerning safe usage. */
+EXTERN void jpeg_write_marker JPP((j_compress_ptr cinfo, int marker,
+				   const JOCTET *dataptr, unsigned int datalen));
+
+/* Alternate compression function: just write an abbreviated table file */
+EXTERN void jpeg_write_tables JPP((j_compress_ptr cinfo));
+
+/* Decompression startup: read start of JPEG datastream to see what's there */
+EXTERN int jpeg_read_header JPP((j_decompress_ptr cinfo,
+				 boolean require_image));
+/* Return value is one of: */
+#define JPEG_SUSPENDED		0 /* Suspended due to lack of input data */
+#define JPEG_HEADER_OK		1 /* Found valid image datastream */
+#define JPEG_HEADER_TABLES_ONLY	2 /* Found valid table-specs-only datastream */
+/* If you pass require_image = TRUE (normal case), you need not check for
+ * a TABLES_ONLY return code; an abbreviated file will cause an error exit.
+ * JPEG_SUSPENDED is only possible if you use a data source module that can
+ * give a suspension return (the stdio source module doesn't).
+ */
+
+/* Main entry points for decompression */
+EXTERN boolean jpeg_start_decompress JPP((j_decompress_ptr cinfo));
+EXTERN JDIMENSION jpeg_read_scanlines JPP((j_decompress_ptr cinfo,
+					   JSAMPARRAY scanlines,
+					   JDIMENSION max_lines));
+EXTERN boolean jpeg_finish_decompress JPP((j_decompress_ptr cinfo));
+
+/* Replaces jpeg_read_scanlines when reading raw downsampled data. */
+EXTERN JDIMENSION jpeg_read_raw_data JPP((j_decompress_ptr cinfo,
+					  JSAMPIMAGE data,
+					  JDIMENSION max_lines));
+
+/* Additional entry points for buffered-image mode. */
+EXTERN boolean jpeg_has_multiple_scans JPP((j_decompress_ptr cinfo));
+EXTERN boolean jpeg_start_output JPP((j_decompress_ptr cinfo,
+				      int scan_number));
+EXTERN boolean jpeg_finish_output JPP((j_decompress_ptr cinfo));
+EXTERN boolean jpeg_input_complete JPP((j_decompress_ptr cinfo));
+EXTERN void jpeg_new_colormap JPP((j_decompress_ptr cinfo));
+EXTERN int jpeg_consume_input JPP((j_decompress_ptr cinfo));
+/* Return value is one of: */
+/* #define JPEG_SUSPENDED	0    Suspended due to lack of input data */
+#define JPEG_REACHED_SOS	1 /* Reached start of new scan */
+#define JPEG_REACHED_EOI	2 /* Reached end of image */
+#define JPEG_ROW_COMPLETED	3 /* Completed one iMCU row */
+#define JPEG_SCAN_COMPLETED	4 /* Completed last iMCU row of a scan */
+
+/* Precalculate output dimensions for current decompression parameters. */
+EXTERN void jpeg_calc_output_dimensions JPP((j_decompress_ptr cinfo));
+
+/* Install a special processing method for COM or APPn markers. */
+EXTERN void jpeg_set_marker_processor JPP((j_decompress_ptr cinfo,
+					   int marker_code,
+					   jpeg_marker_parser_method routine));
+
+/* Read or write raw DCT coefficients --- useful for lossless transcoding. */
+EXTERN jvirt_barray_ptr * jpeg_read_coefficients JPP((j_decompress_ptr cinfo));
+EXTERN void jpeg_write_coefficients JPP((j_compress_ptr cinfo,
+					 jvirt_barray_ptr * coef_arrays));
+EXTERN void jpeg_copy_critical_parameters JPP((j_decompress_ptr srcinfo,
+					       j_compress_ptr dstinfo));
+
+/* If you choose to abort compression or decompression before completing
+ * jpeg_finish_(de)compress, then you need to clean up to release memory,
+ * temporary files, etc.  You can just call jpeg_destroy_(de)compress
+ * if you're done with the JPEG object, but if you want to clean it up and
+ * reuse it, call this:
+ */
+EXTERN void jpeg_abort_compress JPP((j_compress_ptr cinfo));
+EXTERN void jpeg_abort_decompress JPP((j_decompress_ptr cinfo));
+
+/* Generic versions of jpeg_abort and jpeg_destroy that work on either
+ * flavor of JPEG object.  These may be more convenient in some places.
+ */
+EXTERN void jpeg_abort JPP((j_common_ptr cinfo));
+EXTERN void jpeg_destroy JPP((j_common_ptr cinfo));
+
+/* Default restart-marker-resync procedure for use by data source modules */
+EXTERN boolean jpeg_resync_to_restart JPP((j_decompress_ptr cinfo,
+					   int desired));
+
+
+/* These marker codes are exported since applications and data source modules
+ * are likely to want to use them.
+ */
+
+#define JPEG_RST0	0xD0	/* RST0 marker code */
+#define JPEG_EOI	0xD9	/* EOI marker code */
+#define JPEG_APP0	0xE0	/* APP0 marker code */
+#define JPEG_COM	0xFE	/* COM marker code */
+
+
+/* If we have a brain-damaged compiler that emits warnings (or worse, errors)
+ * for structure definitions that are never filled in, keep it quiet by
+ * supplying dummy definitions for the various substructures.
+ */
+
+#ifdef INCOMPLETE_TYPES_BROKEN
+#ifndef JPEG_INTERNALS		/* will be defined in jpegint.h */
+struct jvirt_sarray_control { long dummy; };
+struct jvirt_barray_control { long dummy; };
+struct jpeg_comp_master { long dummy; };
+struct jpeg_c_main_controller { long dummy; };
+struct jpeg_c_prep_controller { long dummy; };
+struct jpeg_c_coef_controller { long dummy; };
+struct jpeg_marker_writer { long dummy; };
+struct jpeg_color_converter { long dummy; };
+struct jpeg_downsampler { long dummy; };
+struct jpeg_forward_dct { long dummy; };
+struct jpeg_entropy_encoder { long dummy; };
+struct jpeg_decomp_master { long dummy; };
+struct jpeg_d_main_controller { long dummy; };
+struct jpeg_d_coef_controller { long dummy; };
+struct jpeg_d_post_controller { long dummy; };
+struct jpeg_input_controller { long dummy; };
+struct jpeg_marker_reader { long dummy; };
+struct jpeg_entropy_decoder { long dummy; };
+struct jpeg_inverse_dct { long dummy; };
+struct jpeg_upsampler { long dummy; };
+struct jpeg_color_deconverter { long dummy; };
+struct jpeg_color_quantizer { long dummy; };
+#endif /* JPEG_INTERNALS */
+#endif /* INCOMPLETE_TYPES_BROKEN */
+
+
+/*
+ * The JPEG library modules define JPEG_INTERNALS before including this file.
+ * The internal structure declarations are read only when that is true.
+ * Applications using the library should not include jpegint.h, but may wish
+ * to include jerror.h.
+ */
+
+#ifdef JPEG_INTERNALS
+#include "../jpeg-6/jpegint.h"		/* fetch private declarations */
+#include "../jpeg-6/jerror.h"		/* fetch error codes too */
+#endif
+
+#endif /* JPEGLIB_H */
diff --git a/codemp/jpeg-6/jutils.cpp b/codemp/jpeg-6/jutils.cpp
new file mode 100644
index 0000000..ddd00f6
--- /dev/null
+++ b/codemp/jpeg-6/jutils.cpp
@@ -0,0 +1,177 @@
+/*
+ * jutils.c
+ *
+ * Copyright (C) 1991-1995, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains tables and miscellaneous utility routines needed
+ * for both compression and decompression.
+ * Note we prefix all global names with "j" to minimize conflicts with
+ * a surrounding application.
+ */
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+#define JPEG_INTERNALS
+#include "jinclude.h"
+#include "jpeglib.h"
+
+
+/*
+ * jpeg_zigzag_order[i] is the zigzag-order position of the i'th element
+ * of a DCT block read in natural order (left to right, top to bottom).
+ */
+
+const int jpeg_zigzag_order[DCTSIZE2] = {
+   0,  1,  5,  6, 14, 15, 27, 28,
+   2,  4,  7, 13, 16, 26, 29, 42,
+   3,  8, 12, 17, 25, 30, 41, 43,
+   9, 11, 18, 24, 31, 40, 44, 53,
+  10, 19, 23, 32, 39, 45, 52, 54,
+  20, 22, 33, 38, 46, 51, 55, 60,
+  21, 34, 37, 47, 50, 56, 59, 61,
+  35, 36, 48, 49, 57, 58, 62, 63
+};
+
+/*
+ * jpeg_natural_order[i] is the natural-order position of the i'th element
+ * of zigzag order.
+ *
+ * When reading corrupted data, the Huffman decoders could attempt
+ * to reference an entry beyond the end of this array (if the decoded
+ * zero run length reaches past the end of the block).  To prevent
+ * wild stores without adding an inner-loop test, we put some extra
+ * "63"s after the real entries.  This will cause the extra coefficient
+ * to be stored in location 63 of the block, not somewhere random.
+ * The worst case would be a run-length of 15, which means we need 16
+ * fake entries.
+ */
+
+const int jpeg_natural_order[DCTSIZE2+16] = {
+  0,  1,  8, 16,  9,  2,  3, 10,
+ 17, 24, 32, 25, 18, 11,  4,  5,
+ 12, 19, 26, 33, 40, 48, 41, 34,
+ 27, 20, 13,  6,  7, 14, 21, 28,
+ 35, 42, 49, 56, 57, 50, 43, 36,
+ 29, 22, 15, 23, 30, 37, 44, 51,
+ 58, 59, 52, 45, 38, 31, 39, 46,
+ 53, 60, 61, 54, 47, 55, 62, 63,
+ 63, 63, 63, 63, 63, 63, 63, 63, /* extra entries for safety in decoder */
+ 63, 63, 63, 63, 63, 63, 63, 63
+};
+
+
+/*
+ * Arithmetic utilities
+ */
+
+GLOBAL long
+jdiv_round_up (long a, long b)
+/* Compute a/b rounded up to next integer, ie, ceil(a/b) */
+/* Assumes a >= 0, b > 0 */
+{
+  return (a + b - 1L) / b;
+}
+
+
+GLOBAL long
+jround_up (long a, long b)
+/* Compute a rounded up to next multiple of b, ie, ceil(a/b)*b */
+/* Assumes a >= 0, b > 0 */
+{
+  a += b - 1L;
+  return a - (a % b);
+}
+
+
+/* On normal machines we can apply MEMCOPY() and MEMZERO() to sample arrays
+ * and coefficient-block arrays.  This won't work on 80x86 because the arrays
+ * are FAR and we're assuming a small-pointer memory model.  However, some
+ * DOS compilers provide far-pointer versions of memcpy() and memset() even
+ * in the small-model libraries.  These will be used if USE_FMEM is defined.
+ * Otherwise, the routines below do it the hard way.  (The performance cost
+ * is not all that great, because these routines aren't very heavily used.)
+ */
+
+#ifndef NEED_FAR_POINTERS	/* normal case, same as regular macros */
+#define FMEMCOPY(dest,src,size)	MEMCOPY(dest,src,size)
+#define FMEMZERO(target,size)	MEMZERO(target,size)
+#else				/* 80x86 case, define if we can */
+#ifdef USE_FMEM
+#define FMEMCOPY(dest,src,size)	_fmemcpy((void FAR *)(dest), (const void FAR *)(src), (size_t)(size))
+#define FMEMZERO(target,size)	_fmemset((void FAR *)(target), 0, (size_t)(size))
+#endif
+#endif
+
+
+GLOBAL void
+jcopy_sample_rows (JSAMPARRAY input_array, int source_row,
+		   JSAMPARRAY output_array, int dest_row,
+		   int num_rows, JDIMENSION num_cols)
+/* Copy some rows of samples from one place to another.
+ * num_rows rows are copied from input_array[source_row++]
+ * to output_array[dest_row++]; these areas may overlap for duplication.
+ * The source and destination arrays must be at least as wide as num_cols.
+ */
+{
+  register JSAMPROW inptr, outptr;
+#ifdef FMEMCOPY
+  register size_t count = (size_t) (num_cols * SIZEOF(JSAMPLE));
+#else
+  register JDIMENSION count;
+#endif
+  register int row;
+
+  input_array += source_row;
+  output_array += dest_row;
+
+  for (row = num_rows; row > 0; row--) {
+    inptr = *input_array++;
+    outptr = *output_array++;
+#ifdef FMEMCOPY
+    FMEMCOPY(outptr, inptr, count);
+#else
+    for (count = num_cols; count > 0; count--)
+      *outptr++ = *inptr++;	/* needn't bother with GETJSAMPLE() here */
+#endif
+  }
+}
+
+
+GLOBAL void
+jcopy_block_row (JBLOCKROW input_row, JBLOCKROW output_row,
+		 JDIMENSION num_blocks)
+/* Copy a row of coefficient blocks from one place to another. */
+{
+#ifdef FMEMCOPY
+  FMEMCOPY(output_row, input_row, num_blocks * (DCTSIZE2 * SIZEOF(JCOEF)));
+#else
+  register JCOEFPTR inptr, outptr;
+  register long count;
+
+  inptr = (JCOEFPTR) input_row;
+  outptr = (JCOEFPTR) output_row;
+  for (count = (long) num_blocks * DCTSIZE2; count > 0; count--) {
+    *outptr++ = *inptr++;
+  }
+#endif
+}
+
+
+GLOBAL void
+jzero_far (void FAR * target, size_t bytestozero)
+/* Zero out a chunk of FAR memory. */
+/* This might be sample-array data, block-array data, or alloc_large data. */
+{
+#ifdef FMEMZERO
+  FMEMZERO(target, bytestozero);
+#else
+  register char FAR * ptr = (char FAR *) target;
+  register size_t count;
+
+  for (count = bytestozero; count > 0; count--) {
+    *ptr++ = 0;
+  }
+#endif
+}
diff --git a/codemp/jpeg-6/jversion.h b/codemp/jpeg-6/jversion.h
new file mode 100644
index 0000000..02083ac
--- /dev/null
+++ b/codemp/jpeg-6/jversion.h
@@ -0,0 +1,14 @@
+/*
+ * jversion.h
+ *
+ * Copyright (C) 1991-1995, Thomas G. Lane.
+ * This file is part of the Independent JPEG Group's software.
+ * For conditions of distribution and use, see the accompanying README file.
+ *
+ * This file contains software version identification.
+ */
+
+
+#define JVERSION	"6  2-Aug-95"
+
+#define JCOPYRIGHT	"Copyright (C) 1995, Thomas G. Lane"
diff --git a/codemp/jpeg-6/vssver.scc b/codemp/jpeg-6/vssver.scc
new file mode 100644
index 0000000..7cd142b
Binary files /dev/null and b/codemp/jpeg-6/vssver.scc differ
diff --git a/codemp/mp3code/cdct.c b/codemp/mp3code/cdct.c
new file mode 100644
index 0000000..556270f
--- /dev/null
+++ b/codemp/mp3code/cdct.c
@@ -0,0 +1,320 @@
+/*____________________________________________________________________________
+	
+	FreeAmp - The Free MP3 Player
+
+        MP3 Decoder originally Copyright (C) 1995-1997 Xing Technology
+        Corp.  http://www.xingtech.com
+
+	Portions Copyright (C) 1998-1999 EMusic.com
+
+	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., 675 Mass Ave, Cambridge, MA 02139, USA.
+	
+	$Id: cdct.c,v 1.11 1999/10/19 07:13:08 elrod Exp $
+____________________________________________________________________________*/
+
+/****  cdct.c  ***************************************************
+
+mod 5/16/95 first stage in 8 pt dct does not drop last sb mono
+
+
+MPEG audio decoder, dct
+portable C
+
+******************************************************************/
+
+#include "config.h"
+#include <stdlib.h>
+#include <stdio.h>
+#include <float.h>
+#include <math.h>
+
+#pragma warning ( disable : 4711 )	// function 'xxxx' selected for automatic inline expansion
+
+float coef32[31];	/* 32 pt dct coefs */		// !!!!!!!!!!!!!!!!!! (only generated once (always to same value)
+
+/*------------------------------------------------------------*/
+float *dct_coef_addr()
+{
+   return coef32;
+}
+/*------------------------------------------------------------*/
+static void forward_bf(int m, int n, float x[], float f[], float coef[])
+{
+   int i, j, n2;
+   int p, q, p0, k;
+
+   p0 = 0;
+   n2 = n >> 1;
+   for (i = 0; i < m; i++, p0 += n)
+   {
+      k = 0;
+      p = p0;
+      q = p + n - 1;
+      for (j = 0; j < n2; j++, p++, q--, k++)
+      {
+	 f[p] = x[p] + x[q];
+	 f[n2 + p] = coef[k] * (x[p] - x[q]);
+      }
+   }
+}
+/*------------------------------------------------------------*/
+static void back_bf(int m, int n, float x[], float f[])
+{
+   int i, j, n2, n21;
+   int p, q, p0;
+
+   p0 = 0;
+   n2 = n >> 1;
+   n21 = n2 - 1;
+   for (i = 0; i < m; i++, p0 += n)
+   {
+      p = p0;
+      q = p0;
+      for (j = 0; j < n2; j++, p += 2, q++)
+	 f[p] = x[q];
+      p = p0 + 1;
+      for (j = 0; j < n21; j++, p += 2, q++)
+	 f[p] = x[q] + x[q + 1];
+      f[p] = x[q];
+   }
+}
+/*------------------------------------------------------------*/
+
+
+void fdct32(float x[], float c[])
+{
+   float a[32];			/* ping pong buffers */
+   float b[32];
+   int p, q;
+
+   float *src = x;
+
+/* special first stage */
+   for (p = 0, q = 31; p < 16; p++, q--)
+   {
+      a[p] = src[p] + src[q];
+      a[16 + p] = coef32[p] * (src[p] - src[q]);
+   }
+   forward_bf(2, 16, a, b, coef32 + 16);
+   forward_bf(4, 8, b, a, coef32 + 16 + 8);
+   forward_bf(8, 4, a, b, coef32 + 16 + 8 + 4);
+   forward_bf(16, 2, b, a, coef32 + 16 + 8 + 4 + 2);
+   back_bf(8, 4, a, b);
+   back_bf(4, 8, b, a);
+   back_bf(2, 16, a, b);
+   back_bf(1, 32, b, c);
+}
+/*------------------------------------------------------------*/
+void fdct32_dual(float x[], float c[])
+{
+   float a[32];			/* ping pong buffers */
+   float b[32];
+   int p, pp, qq;
+
+/* special first stage for dual chan (interleaved x) */
+   pp = 0;
+   qq = 2 * 31;
+   for (p = 0; p < 16; p++, pp += 2, qq -= 2)
+   {
+      a[p] = x[pp] + x[qq];
+      a[16 + p] = coef32[p] * (x[pp] - x[qq]);
+   }
+   forward_bf(2, 16, a, b, coef32 + 16);
+   forward_bf(4, 8, b, a, coef32 + 16 + 8);
+   forward_bf(8, 4, a, b, coef32 + 16 + 8 + 4);
+   forward_bf(16, 2, b, a, coef32 + 16 + 8 + 4 + 2);
+   back_bf(8, 4, a, b);
+   back_bf(4, 8, b, a);
+   back_bf(2, 16, a, b);
+   back_bf(1, 32, b, c);
+}
+/*---------------convert dual to mono------------------------------*/
+void fdct32_dual_mono(float x[], float c[])
+{
+   float a[32];			/* ping pong buffers */
+   float b[32];
+   float t1, t2;
+   int p, pp, qq;
+
+/* special first stage  */
+   pp = 0;
+   qq = 2 * 31;
+   for (p = 0; p < 16; p++, pp += 2, qq -= 2)
+   {
+      t1 = 0.5F * (x[pp] + x[pp + 1]);
+      t2 = 0.5F * (x[qq] + x[qq + 1]);
+      a[p] = t1 + t2;
+      a[16 + p] = coef32[p] * (t1 - t2);
+   }
+   forward_bf(2, 16, a, b, coef32 + 16);
+   forward_bf(4, 8, b, a, coef32 + 16 + 8);
+   forward_bf(8, 4, a, b, coef32 + 16 + 8 + 4);
+   forward_bf(16, 2, b, a, coef32 + 16 + 8 + 4 + 2);
+   back_bf(8, 4, a, b);
+   back_bf(4, 8, b, a);
+   back_bf(2, 16, a, b);
+   back_bf(1, 32, b, c);
+}
+/*------------------------------------------------------------*/
+/*---------------- 16 pt fdct -------------------------------*/
+void fdct16(float x[], float c[])
+{
+   float a[16];			/* ping pong buffers */
+   float b[16];
+   int p, q;
+
+/* special first stage (drop highest sb) */
+   a[0] = x[0];
+   a[8] = coef32[16] * x[0];
+   for (p = 1, q = 14; p < 8; p++, q--)
+   {
+      a[p] = x[p] + x[q];
+      a[8 + p] = coef32[16 + p] * (x[p] - x[q]);
+   }
+   forward_bf(2, 8, a, b, coef32 + 16 + 8);
+   forward_bf(4, 4, b, a, coef32 + 16 + 8 + 4);
+   forward_bf(8, 2, a, b, coef32 + 16 + 8 + 4 + 2);
+   back_bf(4, 4, b, a);
+   back_bf(2, 8, a, b);
+   back_bf(1, 16, b, c);
+}
+/*------------------------------------------------------------*/
+/*---------------- 16 pt fdct dual chan---------------------*/
+void fdct16_dual(float x[], float c[])
+{
+   float a[16];			/* ping pong buffers */
+   float b[16];
+   int p, pp, qq;
+
+/* special first stage for interleaved input */
+   a[0] = x[0];
+   a[8] = coef32[16] * x[0];
+   pp = 2;
+   qq = 2 * 14;
+   for (p = 1; p < 8; p++, pp += 2, qq -= 2)
+   {
+      a[p] = x[pp] + x[qq];
+      a[8 + p] = coef32[16 + p] * (x[pp] - x[qq]);
+   }
+   forward_bf(2, 8, a, b, coef32 + 16 + 8);
+   forward_bf(4, 4, b, a, coef32 + 16 + 8 + 4);
+   forward_bf(8, 2, a, b, coef32 + 16 + 8 + 4 + 2);
+   back_bf(4, 4, b, a);
+   back_bf(2, 8, a, b);
+   back_bf(1, 16, b, c);
+}
+/*------------------------------------------------------------*/
+/*---------------- 16 pt fdct dual to mono-------------------*/
+void fdct16_dual_mono(float x[], float c[])
+{
+   float a[16];			/* ping pong buffers */
+   float b[16];
+   float t1, t2;
+   int p, pp, qq;
+
+/* special first stage  */
+   a[0] = 0.5F * (x[0] + x[1]);
+   a[8] = coef32[16] * a[0];
+   pp = 2;
+   qq = 2 * 14;
+   for (p = 1; p < 8; p++, pp += 2, qq -= 2)
+   {
+      t1 = 0.5F * (x[pp] + x[pp + 1]);
+      t2 = 0.5F * (x[qq] + x[qq + 1]);
+      a[p] = t1 + t2;
+      a[8 + p] = coef32[16 + p] * (t1 - t2);
+   }
+   forward_bf(2, 8, a, b, coef32 + 16 + 8);
+   forward_bf(4, 4, b, a, coef32 + 16 + 8 + 4);
+   forward_bf(8, 2, a, b, coef32 + 16 + 8 + 4 + 2);
+   back_bf(4, 4, b, a);
+   back_bf(2, 8, a, b);
+   back_bf(1, 16, b, c);
+}
+/*------------------------------------------------------------*/
+/*---------------- 8 pt fdct -------------------------------*/
+void fdct8(float x[], float c[])
+{
+   float a[8];			/* ping pong buffers */
+   float b[8];
+   int p, q;
+
+/* special first stage  */
+
+   b[0] = x[0] + x[7];
+   b[4] = coef32[16 + 8] * (x[0] - x[7]);
+   for (p = 1, q = 6; p < 4; p++, q--)
+   {
+      b[p] = x[p] + x[q];
+      b[4 + p] = coef32[16 + 8 + p] * (x[p] - x[q]);
+   }
+
+   forward_bf(2, 4, b, a, coef32 + 16 + 8 + 4);
+   forward_bf(4, 2, a, b, coef32 + 16 + 8 + 4 + 2);
+   back_bf(2, 4, b, a);
+   back_bf(1, 8, a, c);
+}
+/*------------------------------------------------------------*/
+/*---------------- 8 pt fdct dual chan---------------------*/
+void fdct8_dual(float x[], float c[])
+{
+   float a[8];			/* ping pong buffers */
+   float b[8];
+   int p, pp, qq;
+
+/* special first stage for interleaved input */
+   b[0] = x[0] + x[14];
+   b[4] = coef32[16 + 8] * (x[0] - x[14]);
+   pp = 2;
+   qq = 2 * 6;
+   for (p = 1; p < 4; p++, pp += 2, qq -= 2)
+   {
+      b[p] = x[pp] + x[qq];
+      b[4 + p] = coef32[16 + 8 + p] * (x[pp] - x[qq]);
+   }
+   forward_bf(2, 4, b, a, coef32 + 16 + 8 + 4);
+   forward_bf(4, 2, a, b, coef32 + 16 + 8 + 4 + 2);
+   back_bf(2, 4, b, a);
+   back_bf(1, 8, a, c);
+}
+/*------------------------------------------------------------*/
+/*---------------- 8 pt fdct dual to mono---------------------*/
+void fdct8_dual_mono(float x[], float c[])
+{
+   float a[8];			/* ping pong buffers */
+   float b[8];
+   float t1, t2;
+   int p, pp, qq;
+
+/* special first stage  */
+   t1 = 0.5F * (x[0] + x[1]);
+   t2 = 0.5F * (x[14] + x[15]);
+   b[0] = t1 + t2;
+   b[4] = coef32[16 + 8] * (t1 - t2);
+   pp = 2;
+   qq = 2 * 6;
+   for (p = 1; p < 4; p++, pp += 2, qq -= 2)
+   {
+      t1 = 0.5F * (x[pp] + x[pp + 1]);
+      t2 = 0.5F * (x[qq] + x[qq + 1]);
+      b[p] = t1 + t2;
+      b[4 + p] = coef32[16 + 8 + p] * (t1 - t2);
+   }
+   forward_bf(2, 4, b, a, coef32 + 16 + 8 + 4);
+   forward_bf(4, 2, a, b, coef32 + 16 + 8 + 4 + 2);
+   back_bf(2, 4, b, a);
+   back_bf(1, 8, a, c);
+}
+/*------------------------------------------------------------*/
diff --git a/codemp/mp3code/config.h b/codemp/mp3code/config.h
new file mode 100644
index 0000000..a5da233
--- /dev/null
+++ b/codemp/mp3code/config.h
@@ -0,0 +1,136 @@
+/*____________________________________________________________________________
+	
+	FreeAmp - The Free MP3 Player
+
+	Portions Copyright (C) 1998-1999 EMusic.com
+
+	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., 675 Mass Ave, Cambridge, MA 02139, USA.
+	
+	$Id: config.win32,v 1.16 1999/12/09 08:44:07 elrod Exp $
+____________________________________________________________________________*/
+
+#ifndef CONFIG_H
+#define CONFIG_H
+
+#if !defined(RC_INVOKED)
+
+#include <limits.h>
+
+#define HAVE_IO_H 1
+#define HAVE_ERRNO_H 1
+
+#if HAVE_UNISTD_H
+#define RD_BNRY_FLAGS O_RDONLY
+#elif HAVE_IO_H
+#define RD_BNRY_FLAGS O_RDONLY | O_BINARY
+#endif
+
+/* Endian Issues */
+#ifdef LINUX
+#include <endian.h>
+#endif
+
+#ifdef WIN32
+#define __LITTLE_ENDIAN 1234
+#define __BIG_ENDIAN    4321
+#define __PDP_ENDIAN    3412
+#define __BYTE_ORDER    __LITTLE_ENDIAN
+#define usleep(x) ::Sleep(x/1000)
+#define strcasecmp(a,b) stricmp(a,b)
+#define strncasecmp(a,b,c) strnicmp(a,b,c)
+typedef int socklen_t;
+#endif
+
+#ifndef _MAX_PATH
+#define _MAX_PATH 260
+#endif
+
+/* define our datatypes */
+// real number
+typedef double real;
+
+#if UCHAR_MAX == 0xff
+
+typedef unsigned char	uint8;
+typedef signed char		int8;
+
+#else
+#error This machine has no 8-bit type
+#endif
+
+#if UINT_MAX == 0xffff
+
+typedef unsigned int	uint16;
+typedef int				int16;
+
+#elif USHRT_MAX == 0xffff
+
+typedef unsigned short	uint16;
+typedef short			int16;
+
+#else
+#error This machine has no 16-bit type
+#endif
+
+
+#if UINT_MAX == 0xfffffffful
+
+typedef unsigned int	uint32;
+typedef int				int32;
+
+#elif ULONG_MAX == 0xfffffffful
+
+typedef unsigned long	uint32;
+typedef long			int32;
+
+#elif USHRT_MAX == 0xfffffffful
+
+typedef unsigned short	uint32;
+typedef short			int32;
+
+#else
+#error This machine has no 32-bit type
+#endif
+
+
+// What character marks the end of a directory entry? For DOS and
+// Windows, it is "\"; in UNIX it is "/".
+#if defined(WIN32) || defined(OS2) || defined(__DOS__)
+#define DIR_MARKER '\\'
+#define DIR_MARKER_STR "\\"
+#else
+#define DIR_MARKER '/'
+#define DIR_MARKER_STR "/"
+#endif /* WIN32 */
+
+// What character(s) marks the end of a line in a text file? 
+// For DOS and Windows, it is "\r\n"; in UNIX it is "\r".
+#if defined(WIN32) || defined(OS2) || defined(__DOS__)
+#define LINE_END_MARKER_STR "\r\n"
+#else
+#define LINE_END_MARKER_STR "\n"
+#endif /* WIN32 */
+
+#ifndef NULL
+#ifdef  __cplusplus
+#define NULL    0
+#else
+#define NULL    ((void *)0)
+#endif
+#endif /* NULL */
+
+#endif /* RC_INVOKED */
+
+#endif /* CONFIG_H */
diff --git a/codemp/mp3code/copyright.h b/codemp/mp3code/copyright.h
new file mode 100644
index 0000000..5f75427
--- /dev/null
+++ b/codemp/mp3code/copyright.h
@@ -0,0 +1,19 @@
+//############################################################################
+//##                                                                        ##
+//##  MSS 4.0 Miles Sound Studio                                            ##
+//##                                                                        ##
+//##  V1.00 of 18-Mar-96: Initial version                                   ##
+//##                                                                        ##
+//##  C source compatible with Microsoft C v9.0 or later                    ##
+//##                                                                        ##
+//##   Author: Jeff Roberts                                                 ##
+//##                                                                        ##
+//############################################################################
+//##                                                                        ##
+//##  Copyright (C) RAD Game Tools, Inc.                                    ##
+//##                                                                        ##
+//##  For technical support, contact RAD Game Tools at 425-893-4300.        ##
+//##                                                                        ##
+//############################################################################
+
+#define MSS_COPYRIGHT "Copyright (C) 1991-2000, RAD Game Tools, Inc."
diff --git a/codemp/mp3code/csbt.c b/codemp/mp3code/csbt.c
new file mode 100644
index 0000000..a88d338
--- /dev/null
+++ b/codemp/mp3code/csbt.c
@@ -0,0 +1,355 @@
+/*____________________________________________________________________________
+	
+	FreeAmp - The Free MP3 Player
+
+        MP3 Decoder originally Copyright (C) 1995-1997 Xing Technology
+        Corp.  http://www.xingtech.com
+
+	Portions Copyright (C) 1998 EMusic.com
+
+	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., 675 Mass Ave, Cambridge, MA 02139, USA.
+	
+	$Id: csbt.c,v 1.2 1999/10/19 07:13:08 elrod Exp $
+____________________________________________________________________________*/
+
+/****  csbt.c  ***************************************************
+
+MPEG audio decoder, dct and window
+portable C
+
+1/7/96 mod for Layer III
+  
+******************************************************************/
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <float.h>
+#include <math.h>
+
+void fdct32(float *, float *);
+void fdct32_dual(float *, float *);
+void fdct32_dual_mono(float *, float *);
+void fdct16(float *, float *);
+void fdct16_dual(float *, float *);
+void fdct16_dual_mono(float *, float *);
+void fdct8(float *, float *);
+void fdct8_dual(float *, float *);
+void fdct8_dual_mono(float *, float *);
+
+void window(float *vbuf, int vb_ptr, short *pcm);
+void window_dual(float *vbuf, int vb_ptr, short *pcm);
+void window16(float *vbuf, int vb_ptr, short *pcm);
+void window16_dual(float *vbuf, int vb_ptr, short *pcm);
+void window8(float *vbuf, int vb_ptr, short *pcm);
+void window8_dual(float *vbuf, int vb_ptr, short *pcm);
+
+/*-------------------------------------------------------------------------*/
+/* circular window buffers */
+#include "mp3struct.h"
+////static signed int vb_ptr;	// !!!!!!!!!!!!!
+////static signed int vb2_ptr;	// !!!!!!!!!!!!!
+////static float pMP3Stream->vbuf[512];		// !!!!!!!!!!!!!
+////static float vbuf2[512];	// !!!!!!!!!!!!!
+
+float *dct_coef_addr();
+
+/*======================================================================*/
+static void gencoef()		/* gen coef for N=32 (31 coefs) */
+{
+	static int iOnceOnly = 0;
+   int p, n, i, k;
+   double t, pi;
+   float *coef32;
+
+   if (!iOnceOnly++)
+   {
+	   coef32 = dct_coef_addr();
+
+	   pi = 4.0 * atan(1.0);
+	   n = 16;
+	   k = 0;
+	   for (i = 0; i < 5; i++, n = n / 2)
+	   {
+
+		  for (p = 0; p < n; p++, k++)
+		  {
+		 t = (pi / (4 * n)) * (2 * p + 1);
+		 coef32[k] = (float) (0.50 / cos(t));
+		  }
+	   }
+   }
+}
+/*------------------------------------------------------------*/
+void sbt_init()
+{
+   int i;
+   static int first_pass = 1;
+
+   if (first_pass)
+   {
+      gencoef();
+      first_pass = 0;
+   }
+
+/* clear window pMP3Stream->vbuf */
+   for (i = 0; i < 512; i++)
+   {
+      pMP3Stream->vbuf[i] = 0.0F;
+      pMP3Stream->vbuf2[i] = 0.0F;
+   }
+   pMP3Stream->vb2_ptr = pMP3Stream->vb_ptr = 0;
+
+}
+/*============================================================*/
+/*============================================================*/
+/*============================================================*/
+void sbt_mono(float *sample, short *pcm, int n)
+{
+   int i;
+
+   for (i = 0; i < n; i++)
+   {
+      fdct32(sample, pMP3Stream->vbuf + pMP3Stream->vb_ptr);
+      window(pMP3Stream->vbuf, pMP3Stream->vb_ptr, pcm);
+      sample += 64;
+      pMP3Stream->vb_ptr = (pMP3Stream->vb_ptr - 32) & 511;
+      pcm += 32;
+   }
+
+}
+/*------------------------------------------------------------*/
+void sbt_dual(float *sample, short *pcm, int n)
+{
+   int i;
+
+   for (i = 0; i < n; i++)
+   {
+      fdct32_dual(sample, pMP3Stream->vbuf + pMP3Stream->vb_ptr);
+      fdct32_dual(sample + 1, pMP3Stream->vbuf2 + pMP3Stream->vb_ptr);
+      window_dual(pMP3Stream->vbuf, pMP3Stream->vb_ptr, pcm);
+      window_dual(pMP3Stream->vbuf2, pMP3Stream->vb_ptr, pcm + 1);
+      sample += 64;
+      pMP3Stream->vb_ptr = (pMP3Stream->vb_ptr - 32) & 511;
+      pcm += 64;
+   }
+
+
+}
+/*------------------------------------------------------------*/
+/* convert dual to mono */
+void sbt_dual_mono(float *sample, short *pcm, int n)
+{
+   int i;
+
+   for (i = 0; i < n; i++)
+   {
+      fdct32_dual_mono(sample, pMP3Stream->vbuf + pMP3Stream->vb_ptr);
+      window(pMP3Stream->vbuf, pMP3Stream->vb_ptr, pcm);
+      sample += 64;
+      pMP3Stream->vb_ptr = (pMP3Stream->vb_ptr - 32) & 511;
+      pcm += 32;
+   }
+
+}
+/*------------------------------------------------------------*/
+/* convert dual to left */
+void sbt_dual_left(float *sample, short *pcm, int n)
+{
+   int i;
+
+   for (i = 0; i < n; i++)
+   {
+      fdct32_dual(sample, pMP3Stream->vbuf + pMP3Stream->vb_ptr);
+      window(pMP3Stream->vbuf, pMP3Stream->vb_ptr, pcm);
+      sample += 64;
+      pMP3Stream->vb_ptr = (pMP3Stream->vb_ptr - 32) & 511;
+      pcm += 32;
+   }
+}
+/*------------------------------------------------------------*/
+/* convert dual to right */
+void sbt_dual_right(float *sample, short *pcm, int n)
+{
+   int i;
+
+   sample++;			/* point to right chan */
+   for (i = 0; i < n; i++)
+   {
+      fdct32_dual(sample, pMP3Stream->vbuf + pMP3Stream->vb_ptr);
+      window(pMP3Stream->vbuf, pMP3Stream->vb_ptr, pcm);
+      sample += 64;
+      pMP3Stream->vb_ptr = (pMP3Stream->vb_ptr - 32) & 511;
+      pcm += 32;
+   }
+}
+/*------------------------------------------------------------*/
+/*---------------- 16 pt sbt's  -------------------------------*/
+/*------------------------------------------------------------*/
+void sbt16_mono(float *sample, short *pcm, int n)
+{
+   int i;
+
+   for (i = 0; i < n; i++)
+   {
+      fdct16(sample, pMP3Stream->vbuf + pMP3Stream->vb_ptr);
+      window16(pMP3Stream->vbuf, pMP3Stream->vb_ptr, pcm);
+      sample += 64;
+      pMP3Stream->vb_ptr = (pMP3Stream->vb_ptr - 16) & 255;
+      pcm += 16;
+   }
+
+
+}
+/*------------------------------------------------------------*/
+void sbt16_dual(float *sample, short *pcm, int n)
+{
+   int i;
+
+   for (i = 0; i < n; i++)
+   {
+      fdct16_dual(sample, pMP3Stream->vbuf + pMP3Stream->vb_ptr);
+      fdct16_dual(sample + 1, pMP3Stream->vbuf2 + pMP3Stream->vb_ptr);
+      window16_dual(pMP3Stream->vbuf, pMP3Stream->vb_ptr, pcm);
+      window16_dual(pMP3Stream->vbuf2, pMP3Stream->vb_ptr, pcm + 1);
+      sample += 64;
+      pMP3Stream->vb_ptr = (pMP3Stream->vb_ptr - 16) & 255;
+      pcm += 32;
+   }
+}
+/*------------------------------------------------------------*/
+void sbt16_dual_mono(float *sample, short *pcm, int n)
+{
+   int i;
+
+   for (i = 0; i < n; i++)
+   {
+      fdct16_dual_mono(sample, pMP3Stream->vbuf + pMP3Stream->vb_ptr);
+      window16(pMP3Stream->vbuf, pMP3Stream->vb_ptr, pcm);
+      sample += 64;
+      pMP3Stream->vb_ptr = (pMP3Stream->vb_ptr - 16) & 255;
+      pcm += 16;
+   }
+}
+/*------------------------------------------------------------*/
+void sbt16_dual_left(float *sample, short *pcm, int n)
+{
+   int i;
+
+   for (i = 0; i < n; i++)
+   {
+      fdct16_dual(sample, pMP3Stream->vbuf + pMP3Stream->vb_ptr);
+      window16(pMP3Stream->vbuf, pMP3Stream->vb_ptr, pcm);
+      sample += 64;
+      pMP3Stream->vb_ptr = (pMP3Stream->vb_ptr - 16) & 255;
+      pcm += 16;
+   }
+}
+/*------------------------------------------------------------*/
+void sbt16_dual_right(float *sample, short *pcm, int n)
+{
+   int i;
+
+   sample++;
+   for (i = 0; i < n; i++)
+   {
+      fdct16_dual(sample, pMP3Stream->vbuf + pMP3Stream->vb_ptr);
+      window16(pMP3Stream->vbuf, pMP3Stream->vb_ptr, pcm);
+      sample += 64;
+      pMP3Stream->vb_ptr = (pMP3Stream->vb_ptr - 16) & 255;
+      pcm += 16;
+   }
+}
+/*------------------------------------------------------------*/
+/*---------------- 8 pt sbt's  -------------------------------*/
+/*------------------------------------------------------------*/
+void sbt8_mono(float *sample, short *pcm, int n)
+{
+   int i;
+
+   for (i = 0; i < n; i++)
+   {
+      fdct8(sample, pMP3Stream->vbuf + pMP3Stream->vb_ptr);
+      window8(pMP3Stream->vbuf, pMP3Stream->vb_ptr, pcm);
+      sample += 64;
+      pMP3Stream->vb_ptr = (pMP3Stream->vb_ptr - 8) & 127;
+      pcm += 8;
+   }
+
+}
+/*------------------------------------------------------------*/
+void sbt8_dual(float *sample, short *pcm, int n)
+{
+   int i;
+
+   for (i = 0; i < n; i++)
+   {
+      fdct8_dual(sample, pMP3Stream->vbuf + pMP3Stream->vb_ptr);
+      fdct8_dual(sample + 1, pMP3Stream->vbuf2 + pMP3Stream->vb_ptr);
+      window8_dual(pMP3Stream->vbuf, pMP3Stream->vb_ptr, pcm);
+      window8_dual(pMP3Stream->vbuf2, pMP3Stream->vb_ptr, pcm + 1);
+      sample += 64;
+      pMP3Stream->vb_ptr = (pMP3Stream->vb_ptr - 8) & 127;
+      pcm += 16;
+   }
+}
+/*------------------------------------------------------------*/
+void sbt8_dual_mono(float *sample, short *pcm, int n)
+{
+   int i;
+
+   for (i = 0; i < n; i++)
+   {
+      fdct8_dual_mono(sample, pMP3Stream->vbuf + pMP3Stream->vb_ptr);
+      window8(pMP3Stream->vbuf, pMP3Stream->vb_ptr, pcm);
+      sample += 64;
+      pMP3Stream->vb_ptr = (pMP3Stream->vb_ptr - 8) & 127;
+      pcm += 8;
+   }
+}
+/*------------------------------------------------------------*/
+void sbt8_dual_left(float *sample, short *pcm, int n)
+{
+   int i;
+
+   for (i = 0; i < n; i++)
+   {
+      fdct8_dual(sample, pMP3Stream->vbuf + pMP3Stream->vb_ptr);
+      window8(pMP3Stream->vbuf, pMP3Stream->vb_ptr, pcm);
+      sample += 64;
+      pMP3Stream->vb_ptr = (pMP3Stream->vb_ptr - 8) & 127;
+      pcm += 8;
+   }
+}
+/*------------------------------------------------------------*/
+void sbt8_dual_right(float *sample, short *pcm, int n)
+{
+   int i;
+
+   sample++;
+   for (i = 0; i < n; i++)
+   {
+      fdct8_dual(sample, pMP3Stream->vbuf + pMP3Stream->vb_ptr);
+      window8(pMP3Stream->vbuf, pMP3Stream->vb_ptr, pcm);
+      sample += 64;
+      pMP3Stream->vb_ptr = (pMP3Stream->vb_ptr - 8) & 127;
+      pcm += 8;
+   }
+}
+/*------------------------------------------------------------*/
+/*------------------------------------------------------------*/
+#define COMPILE_ME
+#include "csbtb.c"		/* 8 bit output */
+#include "csbtL3.c"		/* Layer III */
+/*------------------------------------------------------------*/
diff --git a/codemp/mp3code/csbtb.c b/codemp/mp3code/csbtb.c
new file mode 100644
index 0000000..48be054
--- /dev/null
+++ b/codemp/mp3code/csbtb.c
@@ -0,0 +1,279 @@
+#pragma warning(disable:4206)	// nonstandard extension used : translation unit is empty
+#ifdef COMPILE_ME
+/*____________________________________________________________________________
+	
+	FreeAmp - The Free MP3 Player
+
+        MP3 Decoder originally Copyright (C) 1995-1997 Xing Technology
+        Corp.  http://www.xingtech.com
+
+	Portions Copyright (C) 1998 EMusic.com
+
+	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., 675 Mass Ave, Cambridge, MA 02139, USA.
+	
+	$Id: csbtb.c,v 1.2 1999/10/19 07:13:08 elrod Exp $
+____________________________________________________________________________*/
+
+/****  csbtb.c  ***************************************************
+include to csbt.c
+
+MPEG audio decoder, dct and window - byte (8 pcm bit output)
+portable C
+
+******************************************************************/
+/*============================================================*/
+/*============================================================*/
+void windowB(float *vbuf, int vb_ptr, unsigned char *pcm);
+void windowB_dual(float *vbuf, int vb_ptr, unsigned char *pcm);
+void windowB16(float *vbuf, int vb_ptr, unsigned char *pcm);
+void windowB16_dual(float *vbuf, int vb_ptr, unsigned char *pcm);
+void windowB8(float *vbuf, int vb_ptr, unsigned char *pcm);
+void windowB8_dual(float *vbuf, int vb_ptr, unsigned char *pcm);
+
+/*============================================================*/
+void sbtB_mono(float *sample, unsigned char *pcm, int n)
+{
+   int i;
+
+   for (i = 0; i < n; i++)
+   {
+      fdct32(sample, pMP3Stream->vbuf + pMP3Stream->vb_ptr);
+      windowB(pMP3Stream->vbuf, pMP3Stream->vb_ptr, pcm);
+      sample += 64;
+      pMP3Stream->vb_ptr = (pMP3Stream->vb_ptr - 32) & 511;
+      pcm += 32;
+   }
+
+}
+/*------------------------------------------------------------*/
+void sbtB_dual(float *sample, unsigned char *pcm, int n)
+{
+   int i;
+
+   for (i = 0; i < n; i++)
+   {
+      fdct32_dual(sample, pMP3Stream->vbuf + pMP3Stream->vb_ptr);
+      fdct32_dual(sample + 1, pMP3Stream->vbuf2 + pMP3Stream->vb_ptr);
+      windowB_dual(pMP3Stream->vbuf, pMP3Stream->vb_ptr, pcm);
+      windowB_dual(pMP3Stream->vbuf2, pMP3Stream->vb_ptr, pcm + 1);
+      sample += 64;
+      pMP3Stream->vb_ptr = (pMP3Stream->vb_ptr - 32) & 511;
+      pcm += 64;
+   }
+
+
+}
+/*------------------------------------------------------------*/
+/* convert dual to mono */
+void sbtB_dual_mono(float *sample, unsigned char *pcm, int n)
+{
+   int i;
+
+   for (i = 0; i < n; i++)
+   {
+      fdct32_dual_mono(sample, pMP3Stream->vbuf + pMP3Stream->vb_ptr);
+      windowB(pMP3Stream->vbuf, pMP3Stream->vb_ptr, pcm);
+      sample += 64;
+      pMP3Stream->vb_ptr = (pMP3Stream->vb_ptr - 32) & 511;
+      pcm += 32;
+   }
+
+}
+/*------------------------------------------------------------*/
+/* convert dual to left */
+void sbtB_dual_left(float *sample, unsigned char *pcm, int n)
+{
+   int i;
+
+   for (i = 0; i < n; i++)
+   {
+      fdct32_dual(sample, pMP3Stream->vbuf + pMP3Stream->vb_ptr);
+      windowB(pMP3Stream->vbuf, pMP3Stream->vb_ptr, pcm);
+      sample += 64;
+      pMP3Stream->vb_ptr = (pMP3Stream->vb_ptr - 32) & 511;
+      pcm += 32;
+   }
+}
+/*------------------------------------------------------------*/
+/* convert dual to right */
+void sbtB_dual_right(float *sample, unsigned char *pcm, int n)
+{
+   int i;
+
+   sample++;			/* point to right chan */
+   for (i = 0; i < n; i++)
+   {
+      fdct32_dual(sample, pMP3Stream->vbuf + pMP3Stream->vb_ptr);
+      windowB(pMP3Stream->vbuf, pMP3Stream->vb_ptr, pcm);
+      sample += 64;
+      pMP3Stream->vb_ptr = (pMP3Stream->vb_ptr - 32) & 511;
+      pcm += 32;
+   }
+}
+/*------------------------------------------------------------*/
+/*---------------- 16 pt sbt's  -------------------------------*/
+/*------------------------------------------------------------*/
+void sbtB16_mono(float *sample, unsigned char *pcm, int n)
+{
+   int i;
+
+   for (i = 0; i < n; i++)
+   {
+      fdct16(sample, pMP3Stream->vbuf + pMP3Stream->vb_ptr);
+      windowB16(pMP3Stream->vbuf, pMP3Stream->vb_ptr, pcm);
+      sample += 64;
+      pMP3Stream->vb_ptr = (pMP3Stream->vb_ptr - 16) & 255;
+      pcm += 16;
+   }
+
+
+}
+/*------------------------------------------------------------*/
+void sbtB16_dual(float *sample, unsigned char *pcm, int n)
+{
+   int i;
+
+   for (i = 0; i < n; i++)
+   {
+      fdct16_dual(sample, pMP3Stream->vbuf + pMP3Stream->vb_ptr);
+      fdct16_dual(sample + 1, pMP3Stream->vbuf2 + pMP3Stream->vb_ptr);
+      windowB16_dual(pMP3Stream->vbuf, pMP3Stream->vb_ptr, pcm);
+      windowB16_dual(pMP3Stream->vbuf2, pMP3Stream->vb_ptr, pcm + 1);
+      sample += 64;
+      pMP3Stream->vb_ptr = (pMP3Stream->vb_ptr - 16) & 255;
+      pcm += 32;
+   }
+}
+/*------------------------------------------------------------*/
+void sbtB16_dual_mono(float *sample, unsigned char *pcm, int n)
+{
+   int i;
+
+   for (i = 0; i < n; i++)
+   {
+      fdct16_dual_mono(sample, pMP3Stream->vbuf + pMP3Stream->vb_ptr);
+      windowB16(pMP3Stream->vbuf, pMP3Stream->vb_ptr, pcm);
+      sample += 64;
+      pMP3Stream->vb_ptr = (pMP3Stream->vb_ptr - 16) & 255;
+      pcm += 16;
+   }
+}
+/*------------------------------------------------------------*/
+void sbtB16_dual_left(float *sample, unsigned char *pcm, int n)
+{
+   int i;
+
+   for (i = 0; i < n; i++)
+   {
+      fdct16_dual(sample, pMP3Stream->vbuf + pMP3Stream->vb_ptr);
+      windowB16(pMP3Stream->vbuf, pMP3Stream->vb_ptr, pcm);
+      sample += 64;
+      pMP3Stream->vb_ptr = (pMP3Stream->vb_ptr - 16) & 255;
+      pcm += 16;
+   }
+}
+/*------------------------------------------------------------*/
+void sbtB16_dual_right(float *sample, unsigned char *pcm, int n)
+{
+   int i;
+
+   sample++;
+   for (i = 0; i < n; i++)
+   {
+      fdct16_dual(sample, pMP3Stream->vbuf + pMP3Stream->vb_ptr);
+      windowB16(pMP3Stream->vbuf, pMP3Stream->vb_ptr, pcm);
+      sample += 64;
+      pMP3Stream->vb_ptr = (pMP3Stream->vb_ptr - 16) & 255;
+      pcm += 16;
+   }
+}
+/*------------------------------------------------------------*/
+/*---------------- 8 pt sbt's  -------------------------------*/
+/*------------------------------------------------------------*/
+void sbtB8_mono(float *sample, unsigned char *pcm, int n)
+{
+   int i;
+
+   for (i = 0; i < n; i++)
+   {
+      fdct8(sample, pMP3Stream->vbuf + pMP3Stream->vb_ptr);
+      windowB8(pMP3Stream->vbuf, pMP3Stream->vb_ptr, pcm);
+      sample += 64;
+      pMP3Stream->vb_ptr = (pMP3Stream->vb_ptr - 8) & 127;
+      pcm += 8;
+   }
+
+}
+/*------------------------------------------------------------*/
+void sbtB8_dual(float *sample, unsigned char *pcm, int n)
+{
+   int i;
+
+   for (i = 0; i < n; i++)
+   {
+      fdct8_dual(sample, pMP3Stream->vbuf + pMP3Stream->vb_ptr);
+      fdct8_dual(sample + 1, pMP3Stream->vbuf2 + pMP3Stream->vb_ptr);
+      windowB8_dual(pMP3Stream->vbuf, pMP3Stream->vb_ptr, pcm);
+      windowB8_dual(pMP3Stream->vbuf2, pMP3Stream->vb_ptr, pcm + 1);
+      sample += 64;
+      pMP3Stream->vb_ptr = (pMP3Stream->vb_ptr - 8) & 127;
+      pcm += 16;
+   }
+}
+/*------------------------------------------------------------*/
+void sbtB8_dual_mono(float *sample, unsigned char *pcm, int n)
+{
+   int i;
+
+   for (i = 0; i < n; i++)
+   {
+      fdct8_dual_mono(sample, pMP3Stream->vbuf + pMP3Stream->vb_ptr);
+      windowB8(pMP3Stream->vbuf, pMP3Stream->vb_ptr, pcm);
+      sample += 64;
+      pMP3Stream->vb_ptr = (pMP3Stream->vb_ptr - 8) & 127;
+      pcm += 8;
+   }
+}
+/*------------------------------------------------------------*/
+void sbtB8_dual_left(float *sample, unsigned char *pcm, int n)
+{
+   int i;
+
+   for (i = 0; i < n; i++)
+   {
+      fdct8_dual(sample, pMP3Stream->vbuf + pMP3Stream->vb_ptr);
+      windowB8(pMP3Stream->vbuf, pMP3Stream->vb_ptr, pcm);
+      sample += 64;
+      pMP3Stream->vb_ptr = (pMP3Stream->vb_ptr - 8) & 127;
+      pcm += 8;
+   }
+}
+/*------------------------------------------------------------*/
+void sbtB8_dual_right(float *sample, unsigned char *pcm, int n)
+{
+   int i;
+
+   sample++;
+   for (i = 0; i < n; i++)
+   {
+      fdct8_dual(sample, pMP3Stream->vbuf + pMP3Stream->vb_ptr);
+      windowB8(pMP3Stream->vbuf, pMP3Stream->vb_ptr, pcm);
+      sample += 64;
+      pMP3Stream->vb_ptr = (pMP3Stream->vb_ptr - 8) & 127;
+      pcm += 8;
+   }
+}
+/*------------------------------------------------------------*/
+#endif	// #ifdef COMPILE_ME
diff --git a/codemp/mp3code/csbtl3.c b/codemp/mp3code/csbtl3.c
new file mode 100644
index 0000000..6e9537d
--- /dev/null
+++ b/codemp/mp3code/csbtl3.c
@@ -0,0 +1,309 @@
+#pragma warning(disable:4206)	// nonstandard extension used : translation unit is empty
+#ifdef COMPILE_ME
+/*____________________________________________________________________________
+	
+	FreeAmp - The Free MP3 Player
+
+        MP3 Decoder originally Copyright (C) 1995-1997 Xing Technology
+        Corp.  http://www.xingtech.com
+
+	Portions Copyright (C) 1998 EMusic.com
+
+	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., 675 Mass Ave, Cambridge, MA 02139, USA.
+	
+	$Id: csbtL3.c,v 1.2 1999/10/19 07:13:08 elrod Exp $
+____________________________________________________________________________*/
+
+/****  csbtL3.c  ***************************************************
+
+layer III
+
+  include to  csbt.c
+
+******************************************************************/
+/*============================================================*/
+/*============ Layer III =====================================*/
+/*============================================================*/
+void sbt_mono_L3(float *sample, short *pcm, int ch)
+{
+	int i;
+	
+	ch = 0;
+	for (i = 0; i < 18; i++)
+	{
+		fdct32(sample, pMP3Stream->vbuf + pMP3Stream->vb_ptr);
+		window(pMP3Stream->vbuf, pMP3Stream->vb_ptr, pcm);
+		sample += 32;
+		pMP3Stream->vb_ptr = (pMP3Stream->vb_ptr - 32) & 511;
+		pcm += 32;
+	}	
+}
+/*------------------------------------------------------------*/
+void sbt_dual_L3(float *sample, short *pcm, int ch)
+{
+	int i;
+	
+	if (ch == 0)
+	{
+		for (i = 0; i < 18; i++)
+		{
+			fdct32(sample, pMP3Stream->vbuf + pMP3Stream->vb_ptr);
+			window_dual(pMP3Stream->vbuf, pMP3Stream->vb_ptr, pcm);
+			sample += 32;
+			pMP3Stream->vb_ptr = (pMP3Stream->vb_ptr - 32) & 511;
+			pcm += 64;
+		}
+	}
+	else
+	{
+		for (i = 0; i < 18; i++)
+		{
+			fdct32(sample, pMP3Stream->vbuf2 + pMP3Stream->vb2_ptr);
+			window_dual(pMP3Stream->vbuf2, pMP3Stream->vb2_ptr, pcm + 1);
+			sample += 32;
+			pMP3Stream->vb2_ptr = (pMP3Stream->vb2_ptr - 32) & 511;
+			pcm += 64;
+		}
+	}
+}
+/*------------------------------------------------------------*/
+/*------------------------------------------------------------*/
+/*---------------- 16 pt sbt's  -------------------------------*/
+/*------------------------------------------------------------*/
+void sbt16_mono_L3(float *sample, short *pcm, int ch)
+{
+	int i;
+	
+	ch = 0;
+	for (i = 0; i < 18; i++)
+	{
+		fdct16(sample, pMP3Stream->vbuf + pMP3Stream->vb_ptr);
+		window16(pMP3Stream->vbuf, pMP3Stream->vb_ptr, pcm);
+		sample += 32;
+		pMP3Stream->vb_ptr = (pMP3Stream->vb_ptr - 16) & 255;
+		pcm += 16;
+	}
+}
+/*------------------------------------------------------------*/
+void sbt16_dual_L3(float *sample, short *pcm, int ch)
+{
+   int i;
+
+   if (ch == 0)
+   {
+	   for (i = 0; i < 18; i++)
+	   {
+		   fdct16(sample, pMP3Stream->vbuf + pMP3Stream->vb_ptr);
+		   window16_dual(pMP3Stream->vbuf, pMP3Stream->vb_ptr, pcm);
+		   sample += 32;
+		   pMP3Stream->vb_ptr = (pMP3Stream->vb_ptr - 16) & 255;
+		   pcm += 32;
+	   }
+   }
+   else
+   {
+	   for (i = 0; i < 18; i++)
+	   {
+		   fdct16(sample, pMP3Stream->vbuf2 + pMP3Stream->vb2_ptr);
+		   window16_dual(pMP3Stream->vbuf2, pMP3Stream->vb2_ptr, pcm + 1);
+		   sample += 32;
+		   pMP3Stream->vb2_ptr = (pMP3Stream->vb2_ptr - 16) & 255;
+		   pcm += 32;
+	   }
+   }   
+}
+/*------------------------------------------------------------*/
+/*---------------- 8 pt sbt's  -------------------------------*/
+/*------------------------------------------------------------*/
+void sbt8_mono_L3(float *sample, short *pcm, int ch)
+{
+	int i;
+	
+	ch = 0;
+	for (i = 0; i < 18; i++)
+	{
+		fdct8(sample, pMP3Stream->vbuf + pMP3Stream->vb_ptr);
+		window8(pMP3Stream->vbuf, pMP3Stream->vb_ptr, pcm);
+		sample += 32;
+		pMP3Stream->vb_ptr = (pMP3Stream->vb_ptr - 8) & 127;
+		pcm += 8;
+	}
+}
+/*------------------------------------------------------------*/
+void sbt8_dual_L3(float *sample, short *pcm, int ch)
+{
+	int i;
+	
+	if (ch == 0)
+	{
+		for (i = 0; i < 18; i++)
+		{
+			fdct8(sample, pMP3Stream->vbuf + pMP3Stream->vb_ptr);
+			window8_dual(pMP3Stream->vbuf, pMP3Stream->vb_ptr, pcm);
+			sample += 32;
+			pMP3Stream->vb_ptr = (pMP3Stream->vb_ptr - 8) & 127;
+			pcm += 16;
+		}
+	}
+	else
+	{
+		for (i = 0; i < 18; i++)
+		{
+			fdct8(sample, pMP3Stream->vbuf2 + pMP3Stream->vb2_ptr);
+			window8_dual(pMP3Stream->vbuf2, pMP3Stream->vb2_ptr, pcm + 1);
+			sample += 32;
+			pMP3Stream->vb2_ptr = (pMP3Stream->vb2_ptr - 8) & 127;
+			pcm += 16;
+		}
+	}
+}
+/*------------------------------------------------------------*/
+/*------- 8 bit output ---------------------------------------*/
+/*------------------------------------------------------------*/
+void sbtB_mono_L3(float *sample, unsigned char *pcm, int ch)
+{
+	int i;
+	
+	ch = 0;
+	for (i = 0; i < 18; i++)
+	{
+		fdct32(sample, pMP3Stream->vbuf + pMP3Stream->vb_ptr);
+		windowB(pMP3Stream->vbuf, pMP3Stream->vb_ptr, pcm);
+		sample += 32;
+		pMP3Stream->vb_ptr = (pMP3Stream->vb_ptr - 32) & 511;
+		pcm += 32;
+	}
+}
+/*------------------------------------------------------------*/
+void sbtB_dual_L3(float *sample, unsigned char *pcm, int ch)
+{
+	int i;
+	
+	if (ch == 0)
+	{
+		for (i = 0; i < 18; i++)
+		{
+			fdct32(sample, pMP3Stream->vbuf + pMP3Stream->vb_ptr);
+			windowB_dual(pMP3Stream->vbuf, pMP3Stream->vb_ptr, pcm);
+			sample += 32;
+			pMP3Stream->vb_ptr = (pMP3Stream->vb_ptr - 32) & 511;
+			pcm += 64;
+		}
+	}
+	else
+	{
+		for (i = 0; i < 18; i++)
+		{
+			fdct32(sample, pMP3Stream->vbuf2 + pMP3Stream->vb2_ptr);
+			windowB_dual(pMP3Stream->vbuf2, pMP3Stream->vb2_ptr, pcm + 1);
+			sample += 32;
+			pMP3Stream->vb2_ptr = (pMP3Stream->vb2_ptr - 32) & 511;
+			pcm += 64;
+		}
+	}
+}
+/*------------------------------------------------------------*/
+/*------------------------------------------------------------*/
+/*---------------- 16 pt sbtB's  -------------------------------*/
+/*------------------------------------------------------------*/
+void sbtB16_mono_L3(float *sample, unsigned char *pcm, int ch)
+{
+	int i;
+	
+	ch = 0;
+	for (i = 0; i < 18; i++)
+	{
+		fdct16(sample, pMP3Stream->vbuf + pMP3Stream->vb_ptr);
+		windowB16(pMP3Stream->vbuf, pMP3Stream->vb_ptr, pcm);
+		sample += 32;
+		pMP3Stream->vb_ptr = (pMP3Stream->vb_ptr - 16) & 255;
+		pcm += 16;
+	}
+}
+/*------------------------------------------------------------*/
+void sbtB16_dual_L3(float *sample, unsigned char *pcm, int ch)
+{
+	int i;
+	
+	if (ch == 0)
+	{
+		for (i = 0; i < 18; i++)
+		{
+			fdct16(sample, pMP3Stream->vbuf + pMP3Stream->vb_ptr);
+			windowB16_dual(pMP3Stream->vbuf, pMP3Stream->vb_ptr, pcm);
+			sample += 32;
+			pMP3Stream->vb_ptr = (pMP3Stream->vb_ptr - 16) & 255;
+			pcm += 32;
+		}
+	}
+	else
+	{
+		for (i = 0; i < 18; i++)
+		{
+			fdct16(sample, pMP3Stream->vbuf2 + pMP3Stream->vb2_ptr);
+			windowB16_dual(pMP3Stream->vbuf2, pMP3Stream->vb2_ptr, pcm + 1);
+			sample += 32;
+			pMP3Stream->vb2_ptr = (pMP3Stream->vb2_ptr - 16) & 255;
+			pcm += 32;
+		}
+	}
+}
+/*------------------------------------------------------------*/
+/*---------------- 8 pt sbtB's  -------------------------------*/
+/*------------------------------------------------------------*/
+void sbtB8_mono_L3(float *sample, unsigned char *pcm, int ch)
+{
+	int i;
+	
+	ch = 0;
+	for (i = 0; i < 18; i++)
+	{
+		fdct8(sample, pMP3Stream->vbuf + pMP3Stream->vb_ptr);
+		windowB8(pMP3Stream->vbuf, pMP3Stream->vb_ptr, pcm);
+		sample += 32;
+		pMP3Stream->vb_ptr = (pMP3Stream->vb_ptr - 8) & 127;
+		pcm += 8;
+	}
+}
+/*------------------------------------------------------------*/
+void sbtB8_dual_L3(float *sample, unsigned char *pcm, int ch)
+{
+	int i;
+	
+	if (ch == 0)
+	{
+		for (i = 0; i < 18; i++)
+		{
+			fdct8(sample, pMP3Stream->vbuf + pMP3Stream->vb_ptr);
+			windowB8_dual(pMP3Stream->vbuf, pMP3Stream->vb_ptr, pcm);
+			sample += 32;
+			pMP3Stream->vb_ptr = (pMP3Stream->vb_ptr - 8) & 127;
+			pcm += 16;
+		}
+	}
+	else
+	{
+		for (i = 0; i < 18; i++)
+		{
+			fdct8(sample, pMP3Stream->vbuf2 + pMP3Stream->vb2_ptr);
+			windowB8_dual(pMP3Stream->vbuf2, pMP3Stream->vb2_ptr, pcm + 1);
+			sample += 32;
+			pMP3Stream->vb2_ptr = (pMP3Stream->vb2_ptr - 8) & 127;
+			pcm += 16;
+		}
+	}
+}
+/*------------------------------------------------------------*/
+#endif	// #ifdef COMPILE_ME
diff --git a/codemp/mp3code/cup.c b/codemp/mp3code/cup.c
new file mode 100644
index 0000000..6277d4b
--- /dev/null
+++ b/codemp/mp3code/cup.c
@@ -0,0 +1,546 @@
+/*____________________________________________________________________________
+	
+	FreeAmp - The Free MP3 Player
+
+        MP3 Decoder originally Copyright (C) 1995-1997 Xing Technology
+        Corp.  http://www.xingtech.com
+
+	Portions Copyright (C) 1998-1999 EMusic.com
+
+	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., 675 Mass Ave, Cambridge, MA 02139, USA.
+	
+	$Id: cup.c,v 1.3 1999/10/19 07:13:08 elrod Exp $
+____________________________________________________________________________*/
+
+/****  cup.c  ***************************************************
+
+MPEG audio decoder Layer I/II  mpeg1 and mpeg2
+should be portable ANSI C, should be endian independent
+
+
+mod  2/21/95 2/21/95  add bit skip, sb limiting
+
+mods 11/15/95 for Layer I
+
+******************************************************************/
+/******************************************************************
+
+       MPEG audio software decoder portable ANSI c.
+       Decodes all Layer I/II to 16 bit linear pcm.
+       Optional stereo to mono conversion.  Optional
+       output sample rate conversion to half or quarter of
+       native mpeg rate. dec8.c adds oupuut conversion features.
+
+-------------------------------------
+int audio_decode_init(MPEG_HEAD *h, int framebytes_arg,
+         int reduction_code, int transform_code, int convert_code,
+         int freq_limit)
+
+initilize decoder:
+       return 0 = fail, not 0 = success
+
+MPEG_HEAD *h    input, mpeg header info (returned by call to head_info)
+pMP3Stream->framebytes      input, mpeg frame size (returned by call to head_info)
+reduction_code  input, sample rate reduction code
+                    0 = full rate
+                    1 = half rate
+                    2 = quarter rate
+
+transform_code  input, ignored
+convert_code    input, channel conversion
+                  convert_code:  0 = two chan output
+                                 1 = convert two chan to mono
+                                 2 = convert two chan to left chan
+                                 3 = convert two chan to right chan
+freq_limit      input, limits bandwidth of pcm output to specified
+                frequency.  Special use. Set to 24000 for normal use.
+
+
+---------------------------------
+void audio_decode_info( DEC_INFO *info)
+
+information return:
+          Call after audio_decode_init.  See mhead.h for
+          information returned in DEC_INFO structure.
+
+
+---------------------------------
+IN_OUT audio_decode(unsigned char *bs, void *pcmbuf)
+
+decode one mpeg audio frame:
+bs        input, mpeg bitstream, must start with
+          sync word.  Caution: may read up to 3 bytes
+          beyond end of frame.
+pcmbuf    output, pcm samples.
+
+IN_OUT structure returns:
+          Number bytes conceptually removed from mpeg bitstream.
+          Returns 0 if sync loss.
+          Number bytes of pcm output.
+
+*******************************************************************/
+
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <float.h>
+#include <math.h>
+#include "mhead.h"		/* mpeg header structure */
+
+
+#ifdef _MSC_VER
+#pragma warning(disable: 4709)
+#endif
+
+#include "mp3struct.h"
+
+
+/*-------------------------------------------------------
+NOTE:  Decoder may read up to three bytes beyond end of
+frame.  Calling application must ensure that this does
+not cause a memory access violation (protection fault)
+---------------------------------------------------------*/
+
+/*====================================================================*/
+/*----------------*/
+//@@@@ This next one (decinfo) is ok:
+DEC_INFO decinfo;		/* global for Layer III */	// only written into by decode init funcs, then copied to stack struct higher up
+
+/*----------------*/
+static float look_c_value[18];	/* built by init */	// effectively constant
+
+/*----------------*/
+////@@@@static int pMP3Stream->outbytes;		// !!!!!!!!!!!!!!?
+////@@@@static int pMP3Stream->framebytes;		// !!!!!!!!!!!!!!!!
+////@@@@static int pMP3Stream->outvalues;		// !!!!!!!!!!!!?
+////@@@@static int pad;
+static const int look_joint[16] =
+{				/* lookup stereo sb's by mode+ext */
+   64, 64, 64, 64,		/* stereo */
+   2 * 4, 2 * 8, 2 * 12, 2 * 16,	/* joint */
+   64, 64, 64, 64,		/* dual */
+   32, 32, 32, 32,		/* mono */
+};
+
+/*----------------*/
+////@@@@static int max_sb;		// !!!!!!!!! L1, 2 3
+////@@@@static int stereo_sb;
+
+/*----------------*/
+////@@@@static int pMP3Stream->nsb_limit = 6;
+////@@@@static int bit_skip;
+static const int bat_bit_master[] =
+{
+   0, 5, 7, 9, 10, 12, 15, 18, 21, 24, 27, 30, 33, 36, 39, 42, 45, 48};
+
+/*----------------*/
+////@@@@static int nbat[4] = {3, 8, 12, 7};	// !!!!!!!!!!!!! not constant!!!!
+////@@@@static int bat[4][16];	// built as constant, but built according to header type (sigh)
+static int ballo[64];		/* set by unpack_ba */					// scratchpad
+static unsigned int samp_dispatch[66];	/* set by unpack_ba */		// scratchpad?
+static float c_value[64];	/* set by unpack_ba */					// scratchpad
+
+/*----------------*/
+static unsigned int sf_dispatch[66];	/* set by unpack_ba */		// scratchpad?
+static float sf_table[64];		// effectively constant
+////@@@@ static float cs_factor[3][64];
+
+/*----------------*/
+////@@@@FINDME - groan....  (I shoved a *2 in just in case it needed it for stereo. This whole thing is crap now
+float sample[2304*2];		/* global for use by Later 3 */	// !!!!!!!!!!!!!!!!!!!!!! // scratchpad?
+static signed char group3_table[32][3];		// effectively constant
+static signed char group5_table[128][3];	// effectively constant
+static signed short group9_table[1024][3];	// effectively constant
+
+/*----------------*/
+
+////@@@@typedef void (*SBT_FUNCTION) (float *sample, short *pcm, int n);
+void sbt_mono(float *sample, short *pcm, int n);
+void sbt_dual(float *sample, short *pcm, int n);
+////@@@@static SBT_FUNCTION sbt = sbt_mono;
+
+
+typedef IN_OUT(*AUDIO_DECODE_ROUTINE) (unsigned char *bs, signed short *pcm);
+IN_OUT L2audio_decode(unsigned char *bs, signed short *pcm);
+static AUDIO_DECODE_ROUTINE audio_decode_routine = L2audio_decode;
+
+/*======================================================================*/
+/*======================================================================*/
+/* get bits from bitstream in endian independent way */
+////@@@@ FINDME - this stuff doesn't appear to be used by any of our samples (phew)
+static unsigned char *bs_ptr;
+static unsigned long bitbuf;
+static int bits;
+static long bitval;
+
+/*------------- initialize bit getter -------------*/
+static void load_init(unsigned char *buf)
+{
+   bs_ptr = buf;
+   bits = 0;
+   bitbuf = 0;
+}
+/*------------- get n bits from bitstream -------------*/
+static long load(int n)
+{
+   unsigned long x;
+
+   if (bits < n)
+   {				/* refill bit buf if necessary */
+      while (bits <= 24)
+      {
+	 bitbuf = (bitbuf << 8) | *bs_ptr++;
+	 bits += 8;
+      }
+   }
+   bits -= n;
+   x = bitbuf >> bits;
+   bitbuf -= x << bits;
+   return x;
+}
+/*------------- skip over n bits in bitstream -------------*/
+static void skip(int n)
+{
+   int k;
+
+   if (bits < n)
+   {
+      n -= bits;
+      k = n >> 3;
+/*--- bytes = n/8 --*/
+      bs_ptr += k;
+      n -= k << 3;
+      bitbuf = *bs_ptr++;
+      bits = 8;
+   }
+   bits -= n;
+   bitbuf -= (bitbuf >> bits) << bits;
+}
+/*--------------------------------------------------------------*/
+#define mac_load_check(n) if( bits < (n) ) {                           \
+          while( bits <= 24 ) {               \
+             bitbuf = (bitbuf << 8) | *bs_ptr++;  \
+             bits += 8;                       \
+          }                                   \
+   }
+/*--------------------------------------------------------------*/
+#define mac_load(n) ( bits -= n,                    \
+         bitval = bitbuf >> bits,      \
+         bitbuf -= bitval << bits,     \
+         bitval )
+/*======================================================================*/
+static void unpack_ba()
+{
+   int i, j, k;
+   static int nbit[4] =
+   {4, 4, 3, 2};
+   int nstereo;
+
+   pMP3Stream->bit_skip = 0;
+   nstereo = pMP3Stream->stereo_sb;
+   k = 0;
+   for (i = 0; i < 4; i++)
+   {
+      for (j = 0; j < pMP3Stream->nbat[i]; j++, k++)
+      {
+	 mac_load_check(4);
+	 ballo[k] = samp_dispatch[k] = pMP3Stream->bat[i][mac_load(nbit[i])];
+	 if (k >= pMP3Stream->nsb_limit)
+	    pMP3Stream->bit_skip += bat_bit_master[samp_dispatch[k]];
+	 c_value[k] = look_c_value[samp_dispatch[k]];
+	 if (--nstereo < 0)
+	 {
+	    ballo[k + 1] = ballo[k];
+	    samp_dispatch[k] += 18;	/* flag as joint */
+	    samp_dispatch[k + 1] = samp_dispatch[k];	/* flag for sf */
+	    c_value[k + 1] = c_value[k];
+	    k++;
+	    j++;
+	 }
+      }
+   }
+   samp_dispatch[pMP3Stream->nsb_limit] = 37;	/* terminate the dispatcher with skip */
+   samp_dispatch[k] = 36;	/* terminate the dispatcher */
+
+}
+/*-------------------------------------------------------------------------*/
+static void unpack_sfs()	/* unpack scale factor selectors */
+{
+   int i;
+
+   for (i = 0; i < pMP3Stream->max_sb; i++)
+   {
+      mac_load_check(2);
+      if (ballo[i])
+	 sf_dispatch[i] = mac_load(2);
+      else
+	 sf_dispatch[i] = 4;	/* no allo */
+   }
+   sf_dispatch[i] = 5;		/* terminate dispatcher */
+}
+/*-------------------------------------------------------------------------*/
+static void unpack_sf()		/* unpack scale factor */
+{				/* combine dequant and scale factors */
+   int i;
+
+   i = -1;
+ dispatch:switch (sf_dispatch[++i])
+   {
+      case 0:			/* 3 factors 012 */
+	 mac_load_check(18);
+	 pMP3Stream->cs_factor[0][i] = c_value[i] * sf_table[mac_load(6)];
+	 pMP3Stream->cs_factor[1][i] = c_value[i] * sf_table[mac_load(6)];
+	 pMP3Stream->cs_factor[2][i] = c_value[i] * sf_table[mac_load(6)];
+	 goto dispatch;
+      case 1:			/* 2 factors 002 */
+	 mac_load_check(12);
+	 pMP3Stream->cs_factor[1][i] = pMP3Stream->cs_factor[0][i] = c_value[i] * sf_table[mac_load(6)];
+	 pMP3Stream->cs_factor[2][i] = c_value[i] * sf_table[mac_load(6)];
+	 goto dispatch;
+      case 2:			/* 1 factor 000 */
+	 mac_load_check(6);
+	 pMP3Stream->cs_factor[2][i] = pMP3Stream->cs_factor[1][i] = pMP3Stream->cs_factor[0][i] =
+	    c_value[i] * sf_table[mac_load(6)];
+	 goto dispatch;
+      case 3:			/* 2 factors 022 */
+	 mac_load_check(12);
+	 pMP3Stream->cs_factor[0][i] = c_value[i] * sf_table[mac_load(6)];
+	 pMP3Stream->cs_factor[2][i] = pMP3Stream->cs_factor[1][i] = c_value[i] * sf_table[mac_load(6)];
+	 goto dispatch;
+      case 4:			/* no allo */
+/*-- pMP3Stream->cs_factor[2][i] = pMP3Stream->cs_factor[1][i] = pMP3Stream->cs_factor[0][i] = 0.0;  --*/
+	 goto dispatch;
+      case 5:			/* all done */
+	 ;
+   }				/* end switch */
+}
+/*-------------------------------------------------------------------------*/
+#define UNPACK_N(n) s[k]     =  pMP3Stream->cs_factor[i][k]*(load(n)-((1 << (n-1)) -1));   \
+    s[k+64]  =  pMP3Stream->cs_factor[i][k]*(load(n)-((1 << (n-1)) -1));   \
+    s[k+128] =  pMP3Stream->cs_factor[i][k]*(load(n)-((1 << (n-1)) -1));   \
+    goto dispatch;
+#define UNPACK_N2(n) mac_load_check(3*n);                                         \
+    s[k]     =  pMP3Stream->cs_factor[i][k]*(mac_load(n)-((1 << (n-1)) -1));   \
+    s[k+64]  =  pMP3Stream->cs_factor[i][k]*(mac_load(n)-((1 << (n-1)) -1));   \
+    s[k+128] =  pMP3Stream->cs_factor[i][k]*(mac_load(n)-((1 << (n-1)) -1));   \
+    goto dispatch;
+#define UNPACK_N3(n) mac_load_check(2*n);                                         \
+    s[k]     =  pMP3Stream->cs_factor[i][k]*(mac_load(n)-((1 << (n-1)) -1));   \
+    s[k+64]  =  pMP3Stream->cs_factor[i][k]*(mac_load(n)-((1 << (n-1)) -1));   \
+    mac_load_check(n);                                           \
+    s[k+128] =  pMP3Stream->cs_factor[i][k]*(mac_load(n)-((1 << (n-1)) -1));   \
+    goto dispatch;
+#define UNPACKJ_N(n) tmp        =  (load(n)-((1 << (n-1)) -1));                \
+    s[k]       =  pMP3Stream->cs_factor[i][k]*tmp;                       \
+    s[k+1]     =  pMP3Stream->cs_factor[i][k+1]*tmp;                     \
+    tmp        =  (load(n)-((1 << (n-1)) -1));                 \
+    s[k+64]    =  pMP3Stream->cs_factor[i][k]*tmp;                       \
+    s[k+64+1]  =  pMP3Stream->cs_factor[i][k+1]*tmp;                     \
+    tmp        =  (load(n)-((1 << (n-1)) -1));                 \
+    s[k+128]   =  pMP3Stream->cs_factor[i][k]*tmp;                       \
+    s[k+128+1] =  pMP3Stream->cs_factor[i][k+1]*tmp;                     \
+    k++;       /* skip right chan dispatch */                \
+    goto dispatch;
+/*-------------------------------------------------------------------------*/
+static void unpack_samp()	/* unpack samples */
+{
+   int i, j, k;
+   float *s;
+   int n;
+   long tmp;
+
+   s = sample;
+   for (i = 0; i < 3; i++)
+   {				/* 3 groups of scale factors */
+      for (j = 0; j < 4; j++)
+      {
+	 k = -1;
+       dispatch:switch (samp_dispatch[++k])
+	 {
+	    case 0:
+	       s[k + 128] = s[k + 64] = s[k] = 0.0F;
+	       goto dispatch;
+	    case 1:		/* 3 levels grouped 5 bits */
+	       mac_load_check(5);
+	       n = mac_load(5);
+	       s[k] = pMP3Stream->cs_factor[i][k] * group3_table[n][0];
+	       s[k + 64] = pMP3Stream->cs_factor[i][k] * group3_table[n][1];
+	       s[k + 128] = pMP3Stream->cs_factor[i][k] * group3_table[n][2];
+	       goto dispatch;
+	    case 2:		/* 5 levels grouped 7 bits */
+	       mac_load_check(7);
+	       n = mac_load(7);
+	       s[k] = pMP3Stream->cs_factor[i][k] * group5_table[n][0];
+	       s[k + 64] = pMP3Stream->cs_factor[i][k] * group5_table[n][1];
+	       s[k + 128] = pMP3Stream->cs_factor[i][k] * group5_table[n][2];
+	       goto dispatch;
+	    case 3:
+	       UNPACK_N2(3)	/* 7 levels */
+	    case 4:		/* 9 levels grouped 10 bits */
+	       mac_load_check(10);
+	       n = mac_load(10);
+	       s[k] = pMP3Stream->cs_factor[i][k] * group9_table[n][0];
+	       s[k + 64] = pMP3Stream->cs_factor[i][k] * group9_table[n][1];
+	       s[k + 128] = pMP3Stream->cs_factor[i][k] * group9_table[n][2];
+	       goto dispatch;
+	    case 5:
+	       UNPACK_N2(4)	/* 15 levels */
+	    case 6:
+	       UNPACK_N2(5)	/* 31 levels */
+	    case 7:
+	       UNPACK_N2(6)	/* 63 levels */
+	    case 8:
+	       UNPACK_N2(7)	/* 127 levels */
+	    case 9:
+	       UNPACK_N2(8)	/* 255 levels */
+	    case 10:
+	       UNPACK_N3(9)	/* 511 levels */
+	    case 11:
+	       UNPACK_N3(10)	/* 1023 levels */
+	    case 12:
+	       UNPACK_N3(11)	/* 2047 levels */
+	    case 13:
+	       UNPACK_N3(12)	/* 4095 levels */
+	    case 14:
+	       UNPACK_N(13)	/* 8191 levels */
+	    case 15:
+	       UNPACK_N(14)	/* 16383 levels */
+	    case 16:
+	       UNPACK_N(15)	/* 32767 levels */
+	    case 17:
+	       UNPACK_N(16)	/* 65535 levels */
+/* -- joint ---- */
+	    case 18 + 0:
+	       s[k + 128 + 1] = s[k + 128] = s[k + 64 + 1] = s[k + 64] = s[k + 1] = s[k] = 0.0F;
+	       k++;		/* skip right chan dispatch */
+	       goto dispatch;
+	    case 18 + 1:	/* 3 levels grouped 5 bits */
+	       n = load(5);
+	       s[k] = pMP3Stream->cs_factor[i][k] * group3_table[n][0];
+	       s[k + 1] = pMP3Stream->cs_factor[i][k + 1] * group3_table[n][0];
+	       s[k + 64] = pMP3Stream->cs_factor[i][k] * group3_table[n][1];
+	       s[k + 64 + 1] = pMP3Stream->cs_factor[i][k + 1] * group3_table[n][1];
+	       s[k + 128] = pMP3Stream->cs_factor[i][k] * group3_table[n][2];
+	       s[k + 128 + 1] = pMP3Stream->cs_factor[i][k + 1] * group3_table[n][2];
+	       k++;		/* skip right chan dispatch */
+	       goto dispatch;
+	    case 18 + 2:	/* 5 levels grouped 7 bits */
+	       n = load(7);
+	       s[k] = pMP3Stream->cs_factor[i][k] * group5_table[n][0];
+	       s[k + 1] = pMP3Stream->cs_factor[i][k + 1] * group5_table[n][0];
+	       s[k + 64] = pMP3Stream->cs_factor[i][k] * group5_table[n][1];
+	       s[k + 64 + 1] = pMP3Stream->cs_factor[i][k + 1] * group5_table[n][1];
+	       s[k + 128] = pMP3Stream->cs_factor[i][k] * group5_table[n][2];
+	       s[k + 128 + 1] = pMP3Stream->cs_factor[i][k + 1] * group5_table[n][2];
+	       k++;		/* skip right chan dispatch */
+	       goto dispatch;
+	    case 18 + 3:
+	       UNPACKJ_N(3)	/* 7 levels */
+	    case 18 + 4:	/* 9 levels grouped 10 bits */
+	       n = load(10);
+	       s[k] = pMP3Stream->cs_factor[i][k] * group9_table[n][0];
+	       s[k + 1] = pMP3Stream->cs_factor[i][k + 1] * group9_table[n][0];
+	       s[k + 64] = pMP3Stream->cs_factor[i][k] * group9_table[n][1];
+	       s[k + 64 + 1] = pMP3Stream->cs_factor[i][k + 1] * group9_table[n][1];
+	       s[k + 128] = pMP3Stream->cs_factor[i][k] * group9_table[n][2];
+	       s[k + 128 + 1] = pMP3Stream->cs_factor[i][k + 1] * group9_table[n][2];
+	       k++;		/* skip right chan dispatch */
+	       goto dispatch;
+	    case 18 + 5:
+	       UNPACKJ_N(4)	/* 15 levels */
+	    case 18 + 6:
+	       UNPACKJ_N(5)	/* 31 levels */
+	    case 18 + 7:
+	       UNPACKJ_N(6)	/* 63 levels */
+	    case 18 + 8:
+	       UNPACKJ_N(7)	/* 127 levels */
+	    case 18 + 9:
+	       UNPACKJ_N(8)	/* 255 levels */
+	    case 18 + 10:
+	       UNPACKJ_N(9)	/* 511 levels */
+	    case 18 + 11:
+	       UNPACKJ_N(10)	/* 1023 levels */
+	    case 18 + 12:
+	       UNPACKJ_N(11)	/* 2047 levels */
+	    case 18 + 13:
+	       UNPACKJ_N(12)	/* 4095 levels */
+	    case 18 + 14:
+	       UNPACKJ_N(13)	/* 8191 levels */
+	    case 18 + 15:
+	       UNPACKJ_N(14)	/* 16383 levels */
+	    case 18 + 16:
+	       UNPACKJ_N(15)	/* 32767 levels */
+	    case 18 + 17:
+	       UNPACKJ_N(16)	/* 65535 levels */
+/* -- end of dispatch -- */
+	    case 37:
+	       skip(pMP3Stream->bit_skip);
+	    case 36:
+	       s += 3 * 64;
+	 }			/* end switch */
+      }				/* end j loop */
+   }				/* end i loop */
+
+
+}
+/*-------------------------------------------------------------------------*/
+unsigned char *gpNextByteAfterData = NULL;
+IN_OUT audio_decode(unsigned char *bs, signed short *pcm, unsigned char *pNextByteAfterData)
+{
+	gpNextByteAfterData = pNextByteAfterData;	// sigh....
+   return audio_decode_routine(bs, pcm);
+}
+/*-------------------------------------------------------------------------*/
+IN_OUT L2audio_decode(unsigned char *bs, signed short *pcm)
+{
+   int sync, prot;
+   IN_OUT in_out;
+
+   load_init(bs);		/* initialize bit getter */
+/* test sync */
+   in_out.in_bytes = 0;		/* assume fail */
+   in_out.out_bytes = 0;
+   sync = load(12);
+   if (sync != 0xFFF)
+      return in_out;		/* sync fail */
+
+   load(3);			/* skip id and option (checked by init) */
+   prot = load(1);		/* load prot bit */
+   load(6);			/* skip to pad */
+   pMP3Stream->pad = load(1);
+   load(1);			/* skip to mode */
+   pMP3Stream->stereo_sb = look_joint[load(4)];
+   if (prot)
+      load(4);			/* skip to data */
+   else
+      load(20);			/* skip crc */
+
+   unpack_ba();			/* unpack bit allocation */
+   unpack_sfs();		/* unpack scale factor selectors */
+   unpack_sf();			/* unpack scale factor */
+   unpack_samp();		/* unpack samples */
+
+   pMP3Stream->sbt(sample, pcm, 36);
+/*-----------*/
+   in_out.in_bytes = pMP3Stream->framebytes + pMP3Stream->pad;
+   in_out.out_bytes = pMP3Stream->outbytes;
+
+   return in_out;
+}
+/*-------------------------------------------------------------------------*/
+#define COMPILE_ME
+#include "cupini.c"		/* initialization */
+#include "cupL1.c"		/* Layer I */
+/*-------------------------------------------------------------------------*/
diff --git a/codemp/mp3code/cupini.c b/codemp/mp3code/cupini.c
new file mode 100644
index 0000000..4a7d4c9
--- /dev/null
+++ b/codemp/mp3code/cupini.c
@@ -0,0 +1,401 @@
+#pragma warning(disable:4206)	// nonstandard extension used : translation unit is empty
+#ifdef COMPILE_ME
+/*____________________________________________________________________________
+	
+	FreeAmp - The Free MP3 Player
+
+        MP3 Decoder originally Copyright (C) 1995-1997 Xing Technology
+        Corp.  http://www.xingtech.com
+
+	Portions Copyright (C) 1998-1999 EMusic.com
+
+	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., 675 Mass Ave, Cambridge, MA 02139, USA.
+	
+	$Id: cupini.c,v 1.3 1999/10/19 07:13:08 elrod Exp $
+____________________________________________________________________________*/
+
+/*=========================================================
+ initialization for cup.c - include to cup.c
+ mpeg audio decoder portable "c"
+
+mod 8/6/96 add 8 bit output
+
+mod 5/10/95 add quick (low precision) window
+
+mod 5/16/95 sb limit for reduced samprate output
+            changed from 94% to 100% of Nyquist sb
+
+mod 11/15/95 for Layer I
+
+
+=========================================================*/
+/*-- compiler bug, floating constant overflow w/ansi --*/
+#ifdef _MSC_VER
+#pragma warning(disable:4056)
+#endif
+
+
+
+
+static const long steps[18] =
+{
+   0, 3, 5, 7, 9, 15, 31, 63, 127,
+   255, 511, 1023, 2047, 4095, 8191, 16383, 32767, 65535};
+
+
+/* ABCD_INDEX = lookqt[mode][sr_index][br_index]  */
+/* -1 = invalid  */
+static const signed char lookqt[4][3][16] =
+{
+ {{1, -1, -1, -1, 2, -1, 2, 0, 0, 0, 1, 1, 1, 1, 1, -1},	/*  44ks stereo */
+  {0, -1, -1, -1, 2, -1, 2, 0, 0, 0, 0, 0, 0, 0, 0, -1},	/*  48ks */
+  {1, -1, -1, -1, 3, -1, 3, 0, 0, 0, 1, 1, 1, 1, 1, -1}},	/*  32ks */
+ {{1, -1, -1, -1, 2, -1, 2, 0, 0, 0, 1, 1, 1, 1, 1, -1},	/*  44ks joint stereo */
+  {0, -1, -1, -1, 2, -1, 2, 0, 0, 0, 0, 0, 0, 0, 0, -1},	/*  48ks */
+  {1, -1, -1, -1, 3, -1, 3, 0, 0, 0, 1, 1, 1, 1, 1, -1}},	/*  32ks */
+ {{1, -1, -1, -1, 2, -1, 2, 0, 0, 0, 1, 1, 1, 1, 1, -1},	/*  44ks dual chan */
+  {0, -1, -1, -1, 2, -1, 2, 0, 0, 0, 0, 0, 0, 0, 0, -1},	/*  48ks */
+  {1, -1, -1, -1, 3, -1, 3, 0, 0, 0, 1, 1, 1, 1, 1, -1}},	/*  32ks */
+// mono extended beyond legal br index
+//  1,2,2,0,0,0,1,1,1,1,1,1,1,1,1,-1,          /*  44ks single chan */
+//  0,2,2,0,0,0,0,0,0,0,0,0,0,0,0,-1,          /*  48ks */
+//  1,3,3,0,0,0,1,1,1,1,1,1,1,1,1,-1,          /*  32ks */
+// legal mono
+ {{1, 2, 2, 0, 0, 0, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1},	/*  44ks single chan */
+  {0, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, -1, -1, -1, -1, -1},	/*  48ks */
+  {1, 3, 3, 0, 0, 0, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1}},	/*  32ks */
+};
+
+static const long sr_table[8] =
+{22050L, 24000L, 16000L, 1L,
+ 44100L, 48000L, 32000L, 1L};
+
+/* bit allocation table look up */
+/* table per mpeg spec tables 3b2a/b/c/d  /e is mpeg2 */
+/* look_bat[abcd_index][4][16]  */
+static const unsigned char look_bat[5][4][16] =
+{
+/* LOOK_BATA */
+ {{0, 1, 3, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17},
+  {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 17},
+  {0, 1, 2, 3, 4, 5, 6, 17, 0, 0, 0, 0, 0, 0, 0, 0},
+  {0, 1, 2, 17, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
+/* LOOK_BATB */
+ {{0, 1, 3, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17},
+  {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 17},
+  {0, 1, 2, 3, 4, 5, 6, 17, 0, 0, 0, 0, 0, 0, 0, 0},
+  {0, 1, 2, 17, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
+/* LOOK_BATC */
+ {{0, 1, 2, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16},
+  {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+  {0, 1, 2, 4, 5, 6, 7, 8, 0, 0, 0, 0, 0, 0, 0, 0},
+  {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
+/* LOOK_BATD */
+ {{0, 1, 2, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16},
+  {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+  {0, 1, 2, 4, 5, 6, 7, 8, 0, 0, 0, 0, 0, 0, 0, 0},
+  {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
+/* LOOK_BATE */
+ {{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15},
+  {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+  {0, 1, 2, 4, 5, 6, 7, 8, 0, 0, 0, 0, 0, 0, 0, 0},
+  {0, 1, 2, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
+};
+
+/* look_nbat[abcd_index]][4] */
+static const unsigned char look_nbat[5][4] =
+{
+  {3, 8, 12, 4},
+  {3, 8, 12, 7},
+  {2, 0, 6, 0},
+  {2, 0, 10, 0},
+  {4, 0, 7, 19},
+};
+
+
+void sbt_mono(float *sample, short *pcm, int n);
+void sbt_dual(float *sample, short *pcm, int n);
+void sbt_dual_mono(float *sample, short *pcm, int n);
+void sbt_dual_left(float *sample, short *pcm, int n);
+void sbt_dual_right(float *sample, short *pcm, int n);
+void sbt16_mono(float *sample, short *pcm, int n);
+void sbt16_dual(float *sample, short *pcm, int n);
+void sbt16_dual_mono(float *sample, short *pcm, int n);
+void sbt16_dual_left(float *sample, short *pcm, int n);
+void sbt16_dual_right(float *sample, short *pcm, int n);
+void sbt8_mono(float *sample, short *pcm, int n);
+void sbt8_dual(float *sample, short *pcm, int n);
+void sbt8_dual_mono(float *sample, short *pcm, int n);
+void sbt8_dual_left(float *sample, short *pcm, int n);
+void sbt8_dual_right(float *sample, short *pcm, int n);
+
+/*--- 8 bit output ---*/
+void sbtB_mono(float *sample, unsigned char *pcm, int n);
+void sbtB_dual(float *sample, unsigned char *pcm, int n);
+void sbtB_dual_mono(float *sample, unsigned char *pcm, int n);
+void sbtB_dual_left(float *sample, unsigned char *pcm, int n);
+void sbtB_dual_right(float *sample, unsigned char *pcm, int n);
+void sbtB16_mono(float *sample, unsigned char *pcm, int n);
+void sbtB16_dual(float *sample, unsigned char *pcm, int n);
+void sbtB16_dual_mono(float *sample, unsigned char *pcm, int n);
+void sbtB16_dual_left(float *sample, unsigned char *pcm, int n);
+void sbtB16_dual_right(float *sample, unsigned char *pcm, int n);
+void sbtB8_mono(float *sample, unsigned char *pcm, int n);
+void sbtB8_dual(float *sample, unsigned char *pcm, int n);
+void sbtB8_dual_mono(float *sample, unsigned char *pcm, int n);
+void sbtB8_dual_left(float *sample, unsigned char *pcm, int n);
+void sbtB8_dual_right(float *sample, unsigned char *pcm, int n);
+
+
+static const SBT_FUNCTION sbt_table[2][3][5] =
+{
+ {{sbt_mono, sbt_dual, sbt_dual_mono, sbt_dual_left, sbt_dual_right},
+  {sbt16_mono, sbt16_dual, sbt16_dual_mono, sbt16_dual_left, sbt16_dual_right},
+  {sbt8_mono, sbt8_dual, sbt8_dual_mono, sbt8_dual_left, sbt8_dual_right}},
+ {{(SBT_FUNCTION) sbtB_mono,
+   (SBT_FUNCTION) sbtB_dual,
+   (SBT_FUNCTION) sbtB_dual_mono,
+   (SBT_FUNCTION) sbtB_dual_left,
+   (SBT_FUNCTION) sbtB_dual_right},
+  {(SBT_FUNCTION) sbtB16_mono,
+   (SBT_FUNCTION) sbtB16_dual,
+   (SBT_FUNCTION) sbtB16_dual_mono,
+   (SBT_FUNCTION) sbtB16_dual_left,
+   (SBT_FUNCTION) sbtB16_dual_right},
+  {(SBT_FUNCTION) sbtB8_mono,
+   (SBT_FUNCTION) sbtB8_dual,
+   (SBT_FUNCTION) sbtB8_dual_mono,
+   (SBT_FUNCTION) sbtB8_dual_left,
+   (SBT_FUNCTION) sbtB8_dual_right}},
+};
+
+static const int out_chans[5] =
+{1, 2, 1, 1, 1};
+
+
+int audio_decode_initL1(MPEG_HEAD * h, int framebytes_arg,
+		   int reduction_code, int transform_code, int convert_code,
+			int freq_limit);
+void sbt_init();
+
+
+IN_OUT L1audio_decode(unsigned char *bs, signed short *pcm);
+IN_OUT L2audio_decode(unsigned char *bs, signed short *pcm);
+IN_OUT L3audio_decode(unsigned char *bs, unsigned char *pcm);
+static const AUDIO_DECODE_ROUTINE decode_routine_table[4] =
+{
+   L2audio_decode,
+   (AUDIO_DECODE_ROUTINE)L3audio_decode,
+   L2audio_decode,
+   L1audio_decode,};
+
+/*---------------------------------------------------------*/
+static void table_init()
+{
+   int i, j;
+   int code;
+   static int iOnceOnly=0;
+
+   if (!iOnceOnly++)
+   {
+	/*--  c_values (dequant) --*/
+	   for (i = 1; i < 18; i++)
+		  look_c_value[i] = 2.0F / steps[i];
+
+	/*--  scale factor table, scale by 32768 for 16 pcm output  --*/
+	   for (i = 0; i < 64; i++)
+		  sf_table[i] = (float) (32768.0 * 2.0 * pow(2.0, -i / 3.0));   
+
+	/*--  grouped 3 level lookup table 5 bit token --*/
+	   for (i = 0; i < 32; i++)
+	   {
+		  code = i;
+		  for (j = 0; j < 3; j++)
+		  {
+		 group3_table[i][j] = (char) ((code % 3) - 1);
+		 code /= 3;
+		  }
+	   }
+   
+	/*--  grouped 5 level lookup table 7 bit token --*/
+	   for (i = 0; i < 128; i++)
+	   {
+		  code = i;
+		  for (j = 0; j < 3; j++)
+		  {
+		 group5_table[i][j] = (char) ((code % 5) - 2);
+		 code /= 5;
+		  }
+	   }
+
+	/*--  grouped 9 level lookup table 10 bit token --*/
+	   for (i = 0; i < 1024; i++)
+	   {
+		  code = i;
+		  for (j = 0; j < 3; j++)
+		  {
+		 group9_table[i][j] = (short) ((code % 9) - 4);
+		 code /= 9;
+		  }
+	   }
+   }
+}
+/*---------------------------------------------------------*/
+int L1audio_decode_init(MPEG_HEAD * h, int framebytes_arg,
+		   int reduction_code, int transform_code, int convert_code,
+			int freq_limit);
+int L3audio_decode_init(MPEG_HEAD * h, int framebytes_arg,
+		   int reduction_code, int transform_code, int convert_code,
+			int freq_limit);
+
+/*---------------------------------------------------------*/
+/* mpeg_head defined in mhead.h  frame bytes is without pad */
+int audio_decode_init(MPEG_HEAD * h, int framebytes_arg,
+		   int reduction_code, int transform_code, int convert_code,
+		      int freq_limit)
+{
+   int i, j, k;
+   static int first_pass = 1;
+   int abcd_index;
+   long samprate;
+   int limit;
+   int bit_code;
+
+   if (first_pass)
+   {
+      table_init();
+      first_pass = 0;
+   }
+
+/* select decoder routine Layer I,II,III */
+   audio_decode_routine = decode_routine_table[h->option & 3];
+
+
+   if (h->option == 3)		/* layer I */
+      return L1audio_decode_init(h, framebytes_arg,
+		  reduction_code, transform_code, convert_code, freq_limit);
+
+   if (h->option == 1)		/* layer III */
+      return L3audio_decode_init(h, framebytes_arg,
+		  reduction_code, transform_code, convert_code, freq_limit);
+
+
+
+   transform_code = transform_code;	/* not used, asm compatability */
+   bit_code = 0;
+   if (convert_code & 8)
+      bit_code = 1;
+   convert_code = convert_code & 3;	/* higher bits used by dec8 freq cvt */
+   if (reduction_code < 0)
+      reduction_code = 0;
+   if (reduction_code > 2)
+      reduction_code = 2;
+   if (freq_limit < 1000)
+      freq_limit = 1000;
+
+
+   pMP3Stream->framebytes = framebytes_arg;
+/* check if code handles */
+   if (h->option != 2)
+      return 0;			/* layer II only */
+   if (h->sr_index == 3)
+      return 0;			/* reserved */
+
+/* compute abcd index for bit allo table selection */
+   if (h->id)			/* mpeg 1 */
+      abcd_index = lookqt[h->mode][h->sr_index][h->br_index];
+   else
+      abcd_index = 4;		/* mpeg 2 */
+
+   if (abcd_index < 0)
+      return 0;			// fail invalid Layer II bit rate index
+
+   for (i = 0; i < 4; i++)
+      for (j = 0; j < 16; j++)
+		pMP3Stream->bat[i][j] = look_bat[abcd_index][i][j];
+   for (i = 0; i < 4; i++)
+      pMP3Stream->nbat[i] = look_nbat[abcd_index][i];
+   pMP3Stream->max_sb = pMP3Stream->nbat[0] + pMP3Stream->nbat[1] + pMP3Stream->nbat[2] + pMP3Stream->nbat[3];
+/*----- compute pMP3Stream->nsb_limit --------*/
+   samprate = sr_table[4 * h->id + h->sr_index];
+   pMP3Stream->nsb_limit = (freq_limit * 64L + samprate / 2) / samprate;
+/*- caller limit -*/
+/*---- limit = 0.94*(32>>reduction_code);  ----*/
+   limit = (32 >> reduction_code);
+   if (limit > 8)
+      limit--;
+   if (pMP3Stream->nsb_limit > limit)
+      pMP3Stream->nsb_limit = limit;
+   if (pMP3Stream->nsb_limit > pMP3Stream->max_sb)
+      pMP3Stream->nsb_limit = pMP3Stream->max_sb;
+
+   pMP3Stream->outvalues = 1152 >> reduction_code;
+   if (h->mode != 3)
+   {				/* adjust for 2 channel modes */
+      for (i = 0; i < 4; i++)
+		pMP3Stream->nbat[i] *= 2;
+      pMP3Stream->max_sb *= 2;
+      pMP3Stream->nsb_limit *= 2;
+   }
+
+/* set sbt function */
+   k = 1 + convert_code;
+   if (h->mode == 3)
+   {
+      k = 0;
+   }
+   pMP3Stream->sbt = sbt_table[bit_code][reduction_code][k];
+   pMP3Stream->outvalues *= out_chans[k];
+   if (bit_code)
+      pMP3Stream->outbytes = pMP3Stream->outvalues;
+   else
+      pMP3Stream->outbytes = sizeof(short) * pMP3Stream->outvalues;
+
+   decinfo.channels = out_chans[k];
+   decinfo.outvalues = pMP3Stream->outvalues;
+   decinfo.samprate = samprate >> reduction_code;
+   if (bit_code)
+      decinfo.bits = 8;
+   else
+      decinfo.bits = sizeof(short) * 8;
+
+   decinfo.framebytes = pMP3Stream->framebytes;
+   decinfo.type = 0;
+
+
+
+/* clear sample buffer, unused sub bands must be 0 */
+   for (i = 0; i < 2304*2; i++)	// the *2 here was inserted by me just in case, since the array is now *2, because of stereo files unpacking at 4608 bytes per frame (which may or may not be relevant, but in any case I don't think we use the L1 versions of MP3 now anyway
+      sample[i] = 0.0F;
+
+
+/* init sub-band transform */
+   sbt_init();
+
+   return 1;
+}
+/*---------------------------------------------------------*/
+void audio_decode_info(DEC_INFO * info)
+{
+   *info = decinfo;		/* info return, call after init */
+}
+/*---------------------------------------------------------*/
+void decode_table_init()
+{
+/* dummy for asm version compatability */
+}
+/*---------------------------------------------------------*/
+#endif	// #ifdef COMPILE_ME
+
diff --git a/codemp/mp3code/cupl1.c b/codemp/mp3code/cupl1.c
new file mode 100644
index 0000000..f3b664d
--- /dev/null
+++ b/codemp/mp3code/cupl1.c
@@ -0,0 +1,325 @@
+#pragma warning(disable:4206)	// nonstandard extension used : translation unit is empty
+#pragma warning(disable:4711)	// function 'xxxx' selected for automatic inline expansion
+#ifdef COMPILE_ME
+/*____________________________________________________________________________
+	
+	FreeAmp - The Free MP3 Player
+
+        MP3 Decoder originally Copyright (C) 1995-1997 Xing Technology
+        Corp.  http://www.xingtech.com
+
+	Portions Copyright (C) 1998-1999 EMusic.com
+
+	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., 675 Mass Ave, Cambridge, MA 02139, USA.
+	
+	$Id: cupL1.c,v 1.3 1999/10/19 07:13:08 elrod Exp $
+____________________________________________________________________________*/
+
+/****  cupL1.c  ***************************************************
+
+MPEG audio decoder Layer I mpeg1 and mpeg2
+
+include to clup.c
+
+
+******************************************************************/
+/*======================================================================*/
+static const int bat_bit_masterL1[] =
+{
+   0, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16
+};
+////@@@@static float *pMP3Stream->cs_factorL1 = &pMP3Stream->cs_factor[0];	// !!!!!!!!!!!!!!!!
+static float look_c_valueL1[16];	// effectively constant
+////@@@@static int nbatL1 = 32;
+
+/*======================================================================*/
+static void unpack_baL1()
+{
+   int j;
+   int nstereo;
+
+   pMP3Stream->bit_skip = 0;
+   nstereo = pMP3Stream->stereo_sb;
+
+   for (j = 0; j < pMP3Stream->nbatL1; j++)
+   {
+      mac_load_check(4);
+      ballo[j] = samp_dispatch[j] = mac_load(4);
+      if (j >= pMP3Stream->nsb_limit)
+		pMP3Stream->bit_skip += bat_bit_masterL1[samp_dispatch[j]];
+      c_value[j] = look_c_valueL1[samp_dispatch[j]];
+      if (--nstereo < 0)
+      {
+	 ballo[j + 1] = ballo[j];
+	 samp_dispatch[j] += 15;	/* flag as joint */
+	 samp_dispatch[j + 1] = samp_dispatch[j];	/* flag for sf */
+	 c_value[j + 1] = c_value[j];
+	 j++;
+      }
+   }
+/*-- terminate with bit skip and end --*/
+   samp_dispatch[pMP3Stream->nsb_limit] = 31;
+   samp_dispatch[j] = 30;
+}
+/*-------------------------------------------------------------------------*/
+static void unpack_sfL1(void)	/* unpack scale factor */
+{				/* combine dequant and scale factors */
+   int i;
+
+   for (i = 0; i < pMP3Stream->nbatL1; i++)
+   {
+      if (ballo[i])
+      {
+	 mac_load_check(6);
+	 pMP3Stream->cs_factorL1[i] = c_value[i] * sf_table[mac_load(6)];
+      }
+   }
+/*-- done --*/
+}
+/*-------------------------------------------------------------------------*/
+#define UNPACKL1_N(n) s[k]     =  pMP3Stream->cs_factorL1[k]*(load(n)-((1 << (n-1)) -1));  \
+    goto dispatch;
+#define UNPACKL1J_N(n) tmp        =  (load(n)-((1 << (n-1)) -1));                 \
+    s[k]       =  pMP3Stream->cs_factorL1[k]*tmp;                        \
+    s[k+1]     =  pMP3Stream->cs_factorL1[k+1]*tmp;                      \
+    k++;                                                     \
+    goto dispatch;
+/*-------------------------------------------------------------------------*/
+static void unpack_sampL1()	/* unpack samples */
+{
+   int j, k;
+   float *s;
+   long tmp;
+
+   s = sample;
+   for (j = 0; j < 12; j++)
+   {
+      k = -1;
+    dispatch:switch (samp_dispatch[++k])
+      {
+	 case 0:
+	    s[k] = 0.0F;
+	    goto dispatch;
+	 case 1:
+	    UNPACKL1_N(2)	/*  3 levels */
+	 case 2:
+	    UNPACKL1_N(3)	/*  7 levels */
+	 case 3:
+	    UNPACKL1_N(4)	/* 15 levels */
+	 case 4:
+	    UNPACKL1_N(5)	/* 31 levels */
+	 case 5:
+	    UNPACKL1_N(6)	/* 63 levels */
+	 case 6:
+	    UNPACKL1_N(7)	/* 127 levels */
+	 case 7:
+	    UNPACKL1_N(8)	/* 255 levels */
+	 case 8:
+	    UNPACKL1_N(9)	/* 511 levels */
+	 case 9:
+	    UNPACKL1_N(10)	/* 1023 levels */
+	 case 10:
+	    UNPACKL1_N(11)	/* 2047 levels */
+	 case 11:
+	    UNPACKL1_N(12)	/* 4095 levels */
+	 case 12:
+	    UNPACKL1_N(13)	/* 8191 levels */
+	 case 13:
+	    UNPACKL1_N(14)	/* 16383 levels */
+	 case 14:
+	    UNPACKL1_N(15)	/* 32767 levels */
+/* -- joint ---- */
+	 case 15 + 0:
+	    s[k + 1] = s[k] = 0.0F;
+	    k++;		/* skip right chan dispatch */
+	    goto dispatch;
+/* -- joint ---- */
+	 case 15 + 1:
+	    UNPACKL1J_N(2)	/*  3 levels */
+	 case 15 + 2:
+	    UNPACKL1J_N(3)	/*  7 levels */
+	 case 15 + 3:
+	    UNPACKL1J_N(4)	/* 15 levels */
+	 case 15 + 4:
+	    UNPACKL1J_N(5)	/* 31 levels */
+	 case 15 + 5:
+	    UNPACKL1J_N(6)	/* 63 levels */
+	 case 15 + 6:
+	    UNPACKL1J_N(7)	/* 127 levels */
+	 case 15 + 7:
+	    UNPACKL1J_N(8)	/* 255 levels */
+	 case 15 + 8:
+	    UNPACKL1J_N(9)	/* 511 levels */
+	 case 15 + 9:
+	    UNPACKL1J_N(10)	/* 1023 levels */
+	 case 15 + 10:
+	    UNPACKL1J_N(11)	/* 2047 levels */
+	 case 15 + 11:
+	    UNPACKL1J_N(12)	/* 4095 levels */
+	 case 15 + 12:
+	    UNPACKL1J_N(13)	/* 8191 levels */
+	 case 15 + 13:
+	    UNPACKL1J_N(14)	/* 16383 levels */
+	 case 15 + 14:
+	    UNPACKL1J_N(15)	/* 32767 levels */
+
+/* -- end of dispatch -- */
+	 case 31:
+	    skip(pMP3Stream->bit_skip);
+	 case 30:
+	    s += 64;
+      }				/* end switch */
+   }				/* end j loop */
+
+/*-- done --*/
+}
+/*-------------------------------------------------------------------*/
+IN_OUT L1audio_decode(unsigned char *bs, signed short *pcm)
+{
+   int sync, prot;
+   IN_OUT in_out;
+
+   load_init(bs);		/* initialize bit getter */
+/* test sync */
+   in_out.in_bytes = 0;		/* assume fail */
+   in_out.out_bytes = 0;
+   sync = load(12);
+   if (sync != 0xFFF)
+      return in_out;		/* sync fail */
+
+
+   load(3);			/* skip id and option (checked by init) */
+   prot = load(1);		/* load prot bit */
+   load(6);			/* skip to pad */
+   pMP3Stream->pad = (load(1)) << 2;
+   load(1);			/* skip to mode */
+   pMP3Stream->stereo_sb = look_joint[load(4)];
+   if (prot)
+      load(4);			/* skip to data */
+   else
+      load(20);			/* skip crc */
+
+   unpack_baL1();		/* unpack bit allocation */
+   unpack_sfL1();		/* unpack scale factor */
+   unpack_sampL1();		/* unpack samples */
+
+   pMP3Stream->sbt(sample, pcm, 12);
+/*-----------*/
+   in_out.in_bytes = pMP3Stream->framebytes + pMP3Stream->pad;
+   in_out.out_bytes = pMP3Stream->outbytes;
+
+   return in_out;
+}
+/*-------------------------------------------------------------------------*/
+int L1audio_decode_init(MPEG_HEAD * h, int framebytes_arg,
+		   int reduction_code, int transform_code, int convert_code,
+			int freq_limit)
+{
+   int i, k;
+   static int first_pass = 1;
+   long samprate;
+   int limit;
+   long step;
+   int bit_code;
+
+/*--- sf init done by layer II init ---*/
+   if (first_pass)
+   {
+      for (step = 4, i = 1; i < 16; i++, step <<= 1)
+	 look_c_valueL1[i] = (float) (2.0 / (step - 1));
+      first_pass = 0;
+   }
+   pMP3Stream->cs_factorL1 = pMP3Stream->cs_factor[0];
+
+   transform_code = transform_code;	/* not used, asm compatability */
+
+   bit_code = 0;
+   if (convert_code & 8)
+      bit_code = 1;
+   convert_code = convert_code & 3;	/* higher bits used by dec8 freq cvt */
+   if (reduction_code < 0)
+      reduction_code = 0;
+   if (reduction_code > 2)
+      reduction_code = 2;
+   if (freq_limit < 1000)
+      freq_limit = 1000;
+
+
+   pMP3Stream->framebytes = framebytes_arg;
+/* check if code handles */
+   if (h->option != 3)
+      return 0;			/* layer I only */
+
+   pMP3Stream->nbatL1 = 32;
+   pMP3Stream->max_sb = pMP3Stream->nbatL1;
+/*----- compute pMP3Stream->nsb_limit --------*/
+   samprate = sr_table[4 * h->id + h->sr_index];
+   pMP3Stream->nsb_limit = (freq_limit * 64L + samprate / 2) / samprate;
+/*- caller limit -*/
+/*---- limit = 0.94*(32>>reduction_code);  ----*/
+   limit = (32 >> reduction_code);
+   if (limit > 8)
+      limit--;
+   if (pMP3Stream->nsb_limit > limit)
+      pMP3Stream->nsb_limit = limit;
+   if (pMP3Stream->nsb_limit > pMP3Stream->max_sb)
+      pMP3Stream->nsb_limit = pMP3Stream->max_sb;
+
+   pMP3Stream->outvalues = 384 >> reduction_code;
+   if (h->mode != 3)
+   {				/* adjust for 2 channel modes */
+      pMP3Stream->nbatL1 *= 2;
+      pMP3Stream->max_sb *= 2;
+      pMP3Stream->nsb_limit *= 2;
+   }
+
+/* set sbt function */
+   k = 1 + convert_code;
+   if (h->mode == 3)
+   {
+      k = 0;
+   }
+   pMP3Stream->sbt = sbt_table[bit_code][reduction_code][k];
+   pMP3Stream->outvalues *= out_chans[k];
+
+   if (bit_code)
+      pMP3Stream->outbytes = pMP3Stream->outvalues;
+   else
+      pMP3Stream->outbytes = sizeof(short) * pMP3Stream->outvalues;
+
+   decinfo.channels = out_chans[k];
+   decinfo.outvalues = pMP3Stream->outvalues;
+   decinfo.samprate = samprate >> reduction_code;
+   if (bit_code)
+      decinfo.bits = 8;
+   else
+      decinfo.bits = sizeof(short) * 8;
+
+   decinfo.framebytes = pMP3Stream->framebytes;
+   decinfo.type = 0;
+
+
+/* clear sample buffer, unused sub bands must be 0 */
+   for (i = 0; i < 768; i++)
+      sample[i] = 0.0F;
+
+
+/* init sub-band transform */
+   sbt_init();
+
+   return 1;
+}
+/*---------------------------------------------------------*/
+#endif	// #ifdef COMPILE_ME
diff --git a/codemp/mp3code/cupl3.c b/codemp/mp3code/cupl3.c
new file mode 100644
index 0000000..e3cba5b
--- /dev/null
+++ b/codemp/mp3code/cupl3.c
@@ -0,0 +1,1287 @@
+/*____________________________________________________________________________
+	
+	FreeAmp - The Free MP3 Player
+
+        MP3 Decoder originally Copyright (C) 1995-1997 Xing Technology
+        Corp.  http://www.xingtech.com
+
+	Portions Copyright (C) 1998-1999 EMusic.com
+
+	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., 675 Mass Ave, Cambridge, MA 02139, USA.
+	
+	$Id: cupl3.c,v 1.8 1999/10/19 07:13:08 elrod Exp $
+____________________________________________________________________________*/
+
+/****  cupL3.c  ***************************************************
+unpack Layer III
+
+
+mod 8/18/97  bugfix crc problem
+
+mod 10/9/97  add pMP3Stream->band_limit12 for short blocks
+
+mod 10/22/97  zero buf_ptrs in init
+
+mod 5/15/98 mpeg 2.5
+
+mod 8/19/98 decode 22 sf bands
+
+******************************************************************/
+
+/*---------------------------------------
+TO DO: Test mixed blocks (mixed long/short)
+  No mixed blocks in mpeg-1 test stream being used for development
+
+-----------------------------------------*/
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <float.h>
+#include <math.h>
+#include <memory.h>
+#include <string.h>
+#include <assert.h>
+#include "mhead.h"		/* mpeg header structure */
+#include "L3.h"
+#include "jdw.h"
+
+#include "mp3struct.h"
+
+/*====================================================================*/
+static const int mp_sr20_table[2][4] =
+{{441, 480, 320, -999}, {882, 960, 640, -999}};
+static const int mp_br_tableL3[2][16] =
+{{0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160, 0},	/* mpeg 2 */
+ {0, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 0}};
+
+/*====================================================================*/
+
+/*-- global band tables */
+/*-- short portion is 3*x !! --*/
+////@@@@int nBand[2][22];		/* [long/short][cb] */		
+////@@@@int sfBandIndex[2][22];		/* [long/short][cb] */	
+
+/*====================================================================*/
+
+/*----------------*/
+extern DEC_INFO decinfo;	////@@@@ this is ok, only written to during init, then chucked.
+
+/*----------------*/
+////@@@@static int pMP3Stream->mpeg25_flag;		// L3 only
+
+//int iframe;
+
+/*-------*/
+////@@@@static int pMP3Stream->band_limit = (576);		// L3 only
+////@@@@static int pMP3Stream->band_limit21 = (576);	// limit for sf band 21	// L3 only
+////@@@@static int pMP3Stream->band_limit12 = (576);	// limit for sf band 12 short	//L3 only
+
+////@@@@int band_limit_nsb = 32;	/* global for hybrid */	
+////@@@@static int pMP3Stream->nsb_limit = 32;	
+////@@@@static int pMP3Stream->gain_adjust = 0;	/* adjust gain e.g. cvt to mono */	// L3 only
+////@@@@static int id; // L3 only
+////@@@@static int pMP3Stream->ncbl_mixed;		/* number of long cb's in mixed block 8 or 6 */		// L3 only
+////@@@@static int pMP3Stream->sr_index;	// L3 only (99%)
+
+//@@@@
+////@@@@static int pMP3Stream->outvalues;		//
+////@@@@static int pMP3Stream->outbytes;		//
+////@@@@static int pMP3Stream->half_outbytes;	// L3 only
+////@@@@static int pMP3Stream->framebytes;		//
+
+//static int padframebytes;
+////@@@@static int pMP3Stream->crcbytes;		// L3 only
+////@@@@static int pMP3Stream->pad;				//
+//static int stereo_flag;	// only written to
+////@@@@static int pMP3Stream->nchan;			// L3 only
+////@@@@static int pMP3Stream->ms_mode;			// L3 only (99%)
+////@@@@static int pMP3Stream->is_mode;			// L3 only
+////@@@@static unsigned int pMP3Stream->zero_level_pcm = 0;	// L3 only
+
+/* cb_info[igr][ch], compute by dequant, used by joint */
+static CB_INFO cb_info[2][2];	// L3 only	############ I think this is ok, only a scratchpad?
+static IS_SF_INFO is_sf_info;	/* MPEG-2 intensity stereo */	// L3 only	 ############## scratchpad?
+
+/*---------------------------------*/
+//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+/* main data bit buffer */
+/*@@@@
+#define NBUF (8*1024)
+#define BUF_TRIGGER (NBUF-1500)
+static unsigned char buf[NBUF];
+static int buf_ptr0 = 0;	// !!!!!!!!!!!
+static int buf_ptr1 = 0;	// !!!!!!!!!!!
+static int main_pos_bit;
+*/
+/*---------------------------------*/
+static SIDE_INFO side_info;		// ####### scratchpad?
+
+static SCALEFACT sf[2][2];	/* [gr][ch] */	 // ########## scratchpad?
+
+static int nsamp[2][2];		/* must start = 0, for nsamp[igr_prev] */	// ########## scratchpad?
+
+/*- sample union of int/float  sample[ch][gr][576] */
+/* static SAMPLE sample[2][2][576]; */
+// @@@@FINDME
+////@@@@extern SAMPLE sample[2][2][576];						////////////????? suspicious, mainly used in decode loop, but zeroed init code
+static float yout[576];		/* hybrid out, sbt in */	//////////// scratchpad
+
+////@@@@typedef void (*SBT_FUNCTION) (float *sample, short *pcm, int ch);
+void sbt_dual_L3(float *sample, short *pcm, int n);
+////@@@@static SBT_FUNCTION sbt_L3 = sbt_dual_L3;	// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+////@@@@typedef void (*XFORM_FUNCTION) (void *pcm, int igr);
+static void Xform_dual(void *pcm, int igr);
+////@@@@static XFORM_FUNCTION Xform = Xform_dual;	// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+IN_OUT L3audio_decode_MPEG1(unsigned char *bs, unsigned char *pcm);
+IN_OUT L3audio_decode_MPEG2(unsigned char *bs, unsigned char *pcm);
+////@@@@typedef IN_OUT(*DECODE_FUNCTION) (unsigned char *bs, unsigned char *pcm);
+////@@@@static DECODE_FUNCTION decode_function = L3audio_decode_MPEG1;		<------------------ needs streaming, ditto above!!!
+
+
+/*====================================================================*/
+int hybrid(void *xin, void *xprev, float *y,
+	   int btype, int nlong, int ntot, int nprev);
+int hybrid_sum(void *xin, void *xin_left, float *y,
+	       int btype, int nlong, int ntot);
+void sum_f_bands(void *a, void *b, int n);
+void FreqInvert(float *y, int n);
+void antialias(void *x, int n);
+void ms_process(void *x, int n);	/* sum-difference stereo */
+void is_process_MPEG1(void *x,	/* intensity stereo */
+		      SCALEFACT * sf,
+		      CB_INFO cb_info[2],	/* [ch] */
+		      int nsamp, int ms_mode);
+void is_process_MPEG2(void *x,	/* intensity stereo */
+		      SCALEFACT * sf,
+		      CB_INFO cb_info[2],	/* [ch] */
+		      IS_SF_INFO * is_sf_info,
+		      int nsamp, int ms_mode);
+
+void unpack_huff(void *xy, int n, int ntable);
+int unpack_huff_quad(void *vwxy, int n, int nbits, int ntable);
+void dequant(SAMPLE sample[], int *nsamp,
+	     SCALEFACT * sf,
+	     GR * gr,
+	     CB_INFO * cb_info, int ncbl_mixed);
+void unpack_sf_sub_MPEG1(SCALEFACT * scalefac, GR * gr,
+			 int scfsi,	/* bit flag */
+			 int igr);
+void unpack_sf_sub_MPEG2(SCALEFACT sf[],	/* return intensity scale */
+			 GR * grdat,
+			 int is_and_ch, IS_SF_INFO * is_sf_info);
+
+/*====================================================================*/
+/* get bits from bitstream in endian independent way */
+
+BITDAT bitdat;			/* global for inline use by Huff */		// !!!!!!!!!!!!!!!!!!!
+
+/*------------- initialize bit getter -------------*/
+static void bitget_init(unsigned char *buf)
+{
+   bitdat.bs_ptr0 = bitdat.bs_ptr = buf;
+   bitdat.bits = 0;
+   bitdat.bitbuf = 0;
+}
+/*------------- initialize bit getter -------------*/
+static void bitget_init_end(unsigned char *buf_end)
+{
+   bitdat.bs_ptr_end = buf_end;
+}
+/*------------- get n bits from bitstream -------------*/
+int bitget_bits_used()
+{
+   int n;			/* compute bits used from last init call */
+
+   n = ((bitdat.bs_ptr - bitdat.bs_ptr0) << 3) - bitdat.bits;
+   return n;
+}
+/*------------- check for n bits in bitbuf -------------*/
+void bitget_check(int n)
+{
+   if (bitdat.bits < n)
+   {
+      while (bitdat.bits <= 24)
+      {
+	 bitdat.bitbuf = (bitdat.bitbuf << 8) | *bitdat.bs_ptr++;
+	 bitdat.bits += 8;
+      }
+   }
+}
+/*------------- get n bits from bitstream -------------*/
+unsigned int bitget(int n)
+{
+   unsigned int x;
+
+   if (bitdat.bits < n)
+   {				/* refill bit buf if necessary */
+      while (bitdat.bits <= 24)
+      {
+	 bitdat.bitbuf = (bitdat.bitbuf << 8) | *bitdat.bs_ptr++;
+	 bitdat.bits += 8;
+      }
+   }
+   bitdat.bits -= n;
+   x = bitdat.bitbuf >> bitdat.bits;
+   bitdat.bitbuf -= x << bitdat.bits;
+   return x;
+}
+/*------------- get 1 bit from bitstream -------------*/
+unsigned int bitget_1bit()
+{
+   unsigned int x;
+
+   if (bitdat.bits <= 0)
+   {				/* refill bit buf if necessary */
+      while (bitdat.bits <= 24)
+      {
+	 bitdat.bitbuf = (bitdat.bitbuf << 8) | *bitdat.bs_ptr++;
+	 bitdat.bits += 8;
+      }
+   }
+   bitdat.bits--;
+   x = bitdat.bitbuf >> bitdat.bits;
+   bitdat.bitbuf -= x << bitdat.bits;
+   return x;
+}
+/*====================================================================*/
+static void Xform_mono(void *pcm, int igr)
+{
+   int igr_prev, n1, n2;
+
+/*--- hybrid + sbt ---*/
+   n1 = n2 = nsamp[igr][0];	/* total number bands */
+   if (side_info.gr[igr][0].block_type == 2)
+   {				/* long bands */
+      n1 = 0;
+      if (side_info.gr[igr][0].mixed_block_flag)
+	 n1 = pMP3Stream->sfBandIndex[0][pMP3Stream->ncbl_mixed - 1];
+   }
+   if (n1 > pMP3Stream->band_limit)
+      n1 = pMP3Stream->band_limit;
+   if (n2 > pMP3Stream->band_limit)
+      n2 = pMP3Stream->band_limit;
+   igr_prev = igr ^ 1;
+
+   nsamp[igr][0] = hybrid(pMP3Stream->sample[0][igr], pMP3Stream->sample[0][igr_prev],
+	 yout, side_info.gr[igr][0].block_type, n1, n2, nsamp[igr_prev][0]);
+   FreqInvert(yout, nsamp[igr][0]);
+   pMP3Stream->sbt_L3(yout, pcm, 0);
+
+}
+/*--------------------------------------------------------------------*/
+static void Xform_dual_right(void *pcm, int igr)
+{
+   int igr_prev, n1, n2;
+
+/*--- hybrid + sbt ---*/
+   n1 = n2 = nsamp[igr][1];	/* total number bands */
+   if (side_info.gr[igr][1].block_type == 2)
+   {				/* long bands */
+      n1 = 0;
+      if (side_info.gr[igr][1].mixed_block_flag)
+	 n1 = pMP3Stream->sfBandIndex[0][pMP3Stream->ncbl_mixed - 1];
+   }
+   if (n1 > pMP3Stream->band_limit)
+      n1 = pMP3Stream->band_limit;
+   if (n2 > pMP3Stream->band_limit)
+      n2 = pMP3Stream->band_limit;
+   igr_prev = igr ^ 1;
+   nsamp[igr][1] = hybrid(pMP3Stream->sample[1][igr], pMP3Stream->sample[1][igr_prev],
+	 yout, side_info.gr[igr][1].block_type, n1, n2, nsamp[igr_prev][1]);
+   FreqInvert(yout, nsamp[igr][1]);
+   pMP3Stream->sbt_L3(yout, pcm, 0);
+
+}
+/*--------------------------------------------------------------------*/
+static void Xform_dual(void *pcm, int igr)
+{
+   int ch;
+   int igr_prev, n1, n2;
+
+/*--- hybrid + sbt ---*/
+   igr_prev = igr ^ 1;
+   for (ch = 0; ch < pMP3Stream->nchan; ch++)
+   {
+      n1 = n2 = nsamp[igr][ch];	/* total number bands */
+      if (side_info.gr[igr][ch].block_type == 2)
+      {				/* long bands */
+	 n1 = 0;
+	 if (side_info.gr[igr][ch].mixed_block_flag)
+	    n1 = pMP3Stream->sfBandIndex[0][pMP3Stream->ncbl_mixed - 1];
+      }
+      if (n1 > pMP3Stream->band_limit)
+	 n1 = pMP3Stream->band_limit;
+      if (n2 > pMP3Stream->band_limit)
+	 n2 = pMP3Stream->band_limit;
+      nsamp[igr][ch] = hybrid(pMP3Stream->sample[ch][igr], pMP3Stream->sample[ch][igr_prev],
+       yout, side_info.gr[igr][ch].block_type, n1, n2, nsamp[igr_prev][ch]);
+      FreqInvert(yout, nsamp[igr][ch]);
+      pMP3Stream->sbt_L3(yout, pcm, ch);
+   }
+
+}
+/*--------------------------------------------------------------------*/
+static void Xform_dual_mono(void *pcm, int igr)
+{
+   int igr_prev, n1, n2, n3;
+
+/*--- hybrid + sbt ---*/
+   igr_prev = igr ^ 1;
+   if ((side_info.gr[igr][0].block_type == side_info.gr[igr][1].block_type)
+       && (side_info.gr[igr][0].mixed_block_flag == 0)
+       && (side_info.gr[igr][1].mixed_block_flag == 0))
+   {
+
+      n2 = nsamp[igr][0];	/* total number bands max of L R */
+      if (n2 < nsamp[igr][1])
+	 n2 = nsamp[igr][1];
+      if (n2 > pMP3Stream->band_limit)
+	 n2 = pMP3Stream->band_limit;
+      n1 = n2;			/* n1 = number long bands */
+      if (side_info.gr[igr][0].block_type == 2)
+	 n1 = 0;
+      sum_f_bands(pMP3Stream->sample[0][igr], pMP3Stream->sample[1][igr], n2);
+      n3 = nsamp[igr][0] = hybrid(pMP3Stream->sample[0][igr], pMP3Stream->sample[0][igr_prev],
+	 yout, side_info.gr[igr][0].block_type, n1, n2, nsamp[igr_prev][0]);
+   }
+   else
+   {				/* transform and then sum (not tested - never happens in test) */
+/*-- left chan --*/
+      n1 = n2 = nsamp[igr][0];	/* total number bands */
+      if (side_info.gr[igr][0].block_type == 2)
+      {
+	 n1 = 0;		/* long bands */
+	 if (side_info.gr[igr][0].mixed_block_flag)
+	    n1 = pMP3Stream->sfBandIndex[0][pMP3Stream->ncbl_mixed - 1];
+      }
+      n3 = nsamp[igr][0] = hybrid(pMP3Stream->sample[0][igr], pMP3Stream->sample[0][igr_prev],
+	 yout, side_info.gr[igr][0].block_type, n1, n2, nsamp[igr_prev][0]);
+/*-- right chan --*/
+      n1 = n2 = nsamp[igr][1];	/* total number bands */
+      if (side_info.gr[igr][1].block_type == 2)
+      {
+	 n1 = 0;		/* long bands */
+	 if (side_info.gr[igr][1].mixed_block_flag)
+	    n1 = pMP3Stream->sfBandIndex[0][pMP3Stream->ncbl_mixed - 1];
+      }
+      nsamp[igr][1] = hybrid_sum(pMP3Stream->sample[1][igr], pMP3Stream->sample[0][igr],
+			     yout, side_info.gr[igr][1].block_type, n1, n2);
+      if (n3 < nsamp[igr][1])
+	 n1 = nsamp[igr][1];
+   }
+
+/*--------*/
+   FreqInvert(yout, n3);
+   pMP3Stream->sbt_L3(yout, pcm, 0);
+
+}
+/*--------------------------------------------------------------------*/
+/*====================================================================*/
+static int unpack_side_MPEG1()
+{
+   int prot;
+   int br_index;
+   int igr, ch;
+   int side_bytes;
+
+/* decode partial header plus initial side info */
+/* at entry bit getter points at id, sync skipped by caller */
+
+   pMP3Stream->id = bitget(1);		/* id */
+   bitget(2);			/* skip layer */
+   prot = bitget(1);		/* bitget prot bit */
+   br_index = bitget(4);
+   pMP3Stream->sr_index = bitget(2);
+   pMP3Stream->pad = bitget(1);
+   bitget(1);			/* skip to mode */
+   side_info.mode = bitget(2);	/* mode */
+   side_info.mode_ext = bitget(2);	/* mode ext */
+
+   if (side_info.mode != 1)
+      side_info.mode_ext = 0;
+
+/* adjust global gain in ms mode to avoid having to mult by 1/sqrt(2) */
+   pMP3Stream->ms_mode = side_info.mode_ext >> 1;
+   pMP3Stream->is_mode = side_info.mode_ext & 1;
+
+
+   pMP3Stream->crcbytes = 0;
+   if (prot)
+      bitget(4);		/* skip to data */
+   else
+   {
+      bitget(20);		/* skip crc */
+      pMP3Stream->crcbytes = 2;
+   }
+
+   if (br_index > 0)		/* pMP3Stream->framebytes fixed for free format */
+	{
+      pMP3Stream->framebytes =
+	 2880 * mp_br_tableL3[pMP3Stream->id][br_index] / mp_sr20_table[pMP3Stream->id][pMP3Stream->sr_index];
+   }
+
+   side_info.main_data_begin = bitget(9);
+   if (side_info.mode == 3)
+   {
+      side_info.private_bits = bitget(5);
+      pMP3Stream->nchan = 1;
+//      stereo_flag = 0;
+      side_bytes = (4 + 17);
+/*-- with header --*/
+   }
+   else
+   {
+      side_info.private_bits = bitget(3);
+      pMP3Stream->nchan = 2;
+//      stereo_flag = 1;
+      side_bytes = (4 + 32);
+/*-- with header --*/
+   }
+   for (ch = 0; ch < pMP3Stream->nchan; ch++)
+      side_info.scfsi[ch] = bitget(4);
+/* this always 0 (both igr) for short blocks */
+
+   for (igr = 0; igr < 2; igr++)
+   {
+      for (ch = 0; ch < pMP3Stream->nchan; ch++)
+      {
+	 side_info.gr[igr][ch].part2_3_length = bitget(12);
+	 side_info.gr[igr][ch].big_values = bitget(9);
+	 side_info.gr[igr][ch].global_gain = bitget(8) + pMP3Stream->gain_adjust;
+	 if (pMP3Stream->ms_mode)
+	    side_info.gr[igr][ch].global_gain -= 2;
+	 side_info.gr[igr][ch].scalefac_compress = bitget(4);
+	 side_info.gr[igr][ch].window_switching_flag = bitget(1);
+	 if (side_info.gr[igr][ch].window_switching_flag)
+	 {
+	    side_info.gr[igr][ch].block_type = bitget(2);
+	    side_info.gr[igr][ch].mixed_block_flag = bitget(1);
+	    side_info.gr[igr][ch].table_select[0] = bitget(5);
+	    side_info.gr[igr][ch].table_select[1] = bitget(5);
+	    side_info.gr[igr][ch].subblock_gain[0] = bitget(3);
+	    side_info.gr[igr][ch].subblock_gain[1] = bitget(3);
+	    side_info.gr[igr][ch].subblock_gain[2] = bitget(3);
+	  /* region count set in terms of long block cb's/bands */
+	  /* r1 set so r0+r1+1 = 21 (lookup produces 576 bands ) */
+	  /* if(window_switching_flag) always 36 samples in region0 */
+	    side_info.gr[igr][ch].region0_count = (8 - 1);	/* 36 samples */
+	    side_info.gr[igr][ch].region1_count = 20 - (8 - 1);
+	 }
+	 else
+	 {
+	    side_info.gr[igr][ch].mixed_block_flag = 0;
+	    side_info.gr[igr][ch].block_type = 0;
+	    side_info.gr[igr][ch].table_select[0] = bitget(5);
+	    side_info.gr[igr][ch].table_select[1] = bitget(5);
+	    side_info.gr[igr][ch].table_select[2] = bitget(5);
+	    side_info.gr[igr][ch].region0_count = bitget(4);
+	    side_info.gr[igr][ch].region1_count = bitget(3);
+	 }
+	 side_info.gr[igr][ch].preflag = bitget(1);
+	 side_info.gr[igr][ch].scalefac_scale = bitget(1);
+	 side_info.gr[igr][ch].count1table_select = bitget(1);
+      }
+   }
+
+
+
+/* return  bytes in header + side info */
+   return side_bytes;
+}
+/*====================================================================*/
+static int unpack_side_MPEG2(int igr)
+{
+   int prot;
+   int br_index;
+   int ch;
+   int side_bytes;
+
+/* decode partial header plus initial side info */
+/* at entry bit getter points at id, sync skipped by caller */
+
+   pMP3Stream->id = bitget(1);		/* id */
+   bitget(2);			/* skip layer */
+   prot = bitget(1);		/* bitget prot bit */
+   br_index = bitget(4);
+   pMP3Stream->sr_index = bitget(2);
+   pMP3Stream->pad = bitget(1);
+   bitget(1);			/* skip to mode */
+   side_info.mode = bitget(2);	/* mode */
+   side_info.mode_ext = bitget(2);	/* mode ext */
+
+   if (side_info.mode != 1)
+      side_info.mode_ext = 0;
+
+/* adjust global gain in ms mode to avoid having to mult by 1/sqrt(2) */
+   pMP3Stream->ms_mode = side_info.mode_ext >> 1;
+   pMP3Stream->is_mode = side_info.mode_ext & 1;
+
+   pMP3Stream->crcbytes = 0;
+   if (prot)
+      bitget(4);		/* skip to data */
+   else
+   {
+      bitget(20);		/* skip crc */
+      pMP3Stream->crcbytes = 2;
+   }
+
+   if (br_index > 0)
+   {				/* pMP3Stream->framebytes fixed for free format */
+      if (pMP3Stream->mpeg25_flag == 0)
+      {
+	 pMP3Stream->framebytes =
+	    1440 * mp_br_tableL3[pMP3Stream->id][br_index] / mp_sr20_table[pMP3Stream->id][pMP3Stream->sr_index];
+      }
+      else
+      {
+	 pMP3Stream->framebytes =
+	    2880 * mp_br_tableL3[pMP3Stream->id][br_index] / mp_sr20_table[pMP3Stream->id][pMP3Stream->sr_index];
+       //if( pMP3Stream->sr_index == 2 ) return 0;  // fail mpeg25 8khz
+      }
+   }
+   side_info.main_data_begin = bitget(8);
+   if (side_info.mode == 3)
+   {
+      side_info.private_bits = bitget(1);
+      pMP3Stream->nchan = 1;
+//      stereo_flag = 0;
+      side_bytes = (4 + 9);
+/*-- with header --*/
+   }
+   else
+   {
+      side_info.private_bits = bitget(2);
+      pMP3Stream->nchan = 2;
+//      stereo_flag = 1;
+      side_bytes = (4 + 17);
+/*-- with header --*/
+   }
+   side_info.scfsi[1] = side_info.scfsi[0] = 0;
+
+
+   for (ch = 0; ch < pMP3Stream->nchan; ch++)
+   {
+      side_info.gr[igr][ch].part2_3_length = bitget(12);
+      side_info.gr[igr][ch].big_values = bitget(9);
+      side_info.gr[igr][ch].global_gain = bitget(8) + pMP3Stream->gain_adjust;
+      if (pMP3Stream->ms_mode)
+	 side_info.gr[igr][ch].global_gain -= 2;
+      side_info.gr[igr][ch].scalefac_compress = bitget(9);
+      side_info.gr[igr][ch].window_switching_flag = bitget(1);
+      if (side_info.gr[igr][ch].window_switching_flag)
+      {
+	 side_info.gr[igr][ch].block_type = bitget(2);
+	 side_info.gr[igr][ch].mixed_block_flag = bitget(1);
+	 side_info.gr[igr][ch].table_select[0] = bitget(5);
+	 side_info.gr[igr][ch].table_select[1] = bitget(5);
+	 side_info.gr[igr][ch].subblock_gain[0] = bitget(3);
+	 side_info.gr[igr][ch].subblock_gain[1] = bitget(3);
+	 side_info.gr[igr][ch].subblock_gain[2] = bitget(3);
+       /* region count set in terms of long block cb's/bands  */
+       /* r1 set so r0+r1+1 = 21 (lookup produces 576 bands ) */
+       /* bt=1 or 3       54 samples */
+       /* bt=2 mixed=0    36 samples */
+       /* bt=2 mixed=1    54 (8 long sf) samples? or maybe 36 */
+       /* region0 discussion says 54 but this would mix long */
+       /* and short in region0 if scale factors switch */
+       /* at band 36 (6 long scale factors) */
+	 if ((side_info.gr[igr][ch].block_type == 2))
+	 {
+	    side_info.gr[igr][ch].region0_count = (6 - 1);	/* 36 samples */
+	    side_info.gr[igr][ch].region1_count = 20 - (6 - 1);
+	 }
+	 else
+	 {			/* long block type 1 or 3 */
+	    side_info.gr[igr][ch].region0_count = (8 - 1);	/* 54 samples */
+	    side_info.gr[igr][ch].region1_count = 20 - (8 - 1);
+	 }
+      }
+      else
+      {
+	 side_info.gr[igr][ch].mixed_block_flag = 0;
+	 side_info.gr[igr][ch].block_type = 0;
+	 side_info.gr[igr][ch].table_select[0] = bitget(5);
+	 side_info.gr[igr][ch].table_select[1] = bitget(5);
+	 side_info.gr[igr][ch].table_select[2] = bitget(5);
+	 side_info.gr[igr][ch].region0_count = bitget(4);
+	 side_info.gr[igr][ch].region1_count = bitget(3);
+      }
+      side_info.gr[igr][ch].preflag = 0;
+      side_info.gr[igr][ch].scalefac_scale = bitget(1);
+      side_info.gr[igr][ch].count1table_select = bitget(1);
+   }
+
+/* return  bytes in header + side info */
+   return side_bytes;
+}
+/*-----------------------------------------------------------------*/
+static void unpack_main(unsigned char *pcm, int igr)
+{
+   int ch;
+   int bit0;
+   int n1, n2, n3, n4, nn2, nn3;
+   int nn4;
+   int qbits;
+   int m0;
+
+
+   for (ch = 0; ch < pMP3Stream->nchan; ch++)
+   {
+      bitget_init(pMP3Stream->buf + (pMP3Stream->main_pos_bit >> 3));
+      bit0 = (pMP3Stream->main_pos_bit & 7);
+      if (bit0)
+	 bitget(bit0);
+      pMP3Stream->main_pos_bit += side_info.gr[igr][ch].part2_3_length;
+      bitget_init_end(pMP3Stream->buf + ((pMP3Stream->main_pos_bit + 39) >> 3));
+/*-- scale factors --*/
+      if (pMP3Stream->id)
+	 unpack_sf_sub_MPEG1(&sf[igr][ch],
+			  &side_info.gr[igr][ch], side_info.scfsi[ch], igr);
+      else
+	 unpack_sf_sub_MPEG2(&sf[igr][ch],
+			 &side_info.gr[igr][ch], pMP3Stream->is_mode & ch, &is_sf_info);
+/*--- huff data ---*/
+      n1 = pMP3Stream->sfBandIndex[0][side_info.gr[igr][ch].region0_count];
+      n2 = pMP3Stream->sfBandIndex[0][side_info.gr[igr][ch].region0_count
+			  + side_info.gr[igr][ch].region1_count + 1];
+      n3 = side_info.gr[igr][ch].big_values;
+      n3 = n3 + n3;
+
+
+      if (n3 > pMP3Stream->band_limit)
+	 n3 = pMP3Stream->band_limit;
+      if (n2 > n3)
+	 n2 = n3;
+      if (n1 > n3)
+	 n1 = n3;
+      nn3 = n3 - n2;
+      nn2 = n2 - n1;
+      unpack_huff(pMP3Stream->sample[ch][igr], n1, side_info.gr[igr][ch].table_select[0]);
+      unpack_huff(pMP3Stream->sample[ch][igr] + n1, nn2, side_info.gr[igr][ch].table_select[1]);
+      unpack_huff(pMP3Stream->sample[ch][igr] + n2, nn3, side_info.gr[igr][ch].table_select[2]);
+      qbits = side_info.gr[igr][ch].part2_3_length - (bitget_bits_used() - bit0);
+      nn4 = unpack_huff_quad(pMP3Stream->sample[ch][igr] + n3, pMP3Stream->band_limit - n3, qbits,
+			     side_info.gr[igr][ch].count1table_select);
+      n4 = n3 + nn4;
+      nsamp[igr][ch] = n4;
+    //limit n4 or allow deqaunt to sf band 22
+      if (side_info.gr[igr][ch].block_type == 2)
+	 n4 = min(n4, pMP3Stream->band_limit12);
+      else
+	 n4 = min(n4, pMP3Stream->band_limit21);
+      if (n4 < 576)
+	 memset(pMP3Stream->sample[ch][igr] + n4, 0, sizeof(SAMPLE) * (576 - n4));
+      if (bitdat.bs_ptr > bitdat.bs_ptr_end)
+      {				// bad data overrun
+
+	 memset(pMP3Stream->sample[ch][igr], 0, sizeof(SAMPLE) * (576));
+      }
+   }
+
+
+
+/*--- dequant ---*/
+   for (ch = 0; ch < pMP3Stream->nchan; ch++)
+   {
+      dequant(pMP3Stream->sample[ch][igr],
+	      &nsamp[igr][ch],	/* nsamp updated for shorts */
+	      &sf[igr][ch], &side_info.gr[igr][ch],
+	      &cb_info[igr][ch], pMP3Stream->ncbl_mixed);
+   }
+
+/*--- ms stereo processing  ---*/
+   if (pMP3Stream->ms_mode)
+   {
+      if (pMP3Stream->is_mode == 0)
+      {
+	 m0 = nsamp[igr][0];	/* process to longer of left/right */
+	 if (m0 < nsamp[igr][1])
+	    m0 = nsamp[igr][1];
+      }
+      else
+      {				/* process to last cb in right */
+	 m0 = pMP3Stream->sfBandIndex[cb_info[igr][1].cbtype][cb_info[igr][1].cbmax];
+      }
+      ms_process(pMP3Stream->sample[0][igr], m0);
+   }
+
+/*--- is stereo processing  ---*/
+   if (pMP3Stream->is_mode)
+   {
+      if (pMP3Stream->id)
+	 is_process_MPEG1(pMP3Stream->sample[0][igr], &sf[igr][1],
+			  cb_info[igr], nsamp[igr][0], pMP3Stream->ms_mode);
+      else
+	 is_process_MPEG2(pMP3Stream->sample[0][igr], &sf[igr][1],
+			  cb_info[igr], &is_sf_info,
+			  nsamp[igr][0], pMP3Stream->ms_mode);
+   }
+
+/*-- adjust ms and is modes to max of left/right */
+   if (side_info.mode_ext)
+   {
+      if (nsamp[igr][0] < nsamp[igr][1])
+	 nsamp[igr][0] = nsamp[igr][1];
+      else
+	 nsamp[igr][1] = nsamp[igr][0];
+   }
+
+/*--- antialias ---*/
+   for (ch = 0; ch < pMP3Stream->nchan; ch++)
+   {
+      if (cb_info[igr][ch].ncbl == 0)
+	 continue;		/* have no long blocks */
+      if (side_info.gr[igr][ch].mixed_block_flag)
+	 n1 = 1;		/* 1 -> 36 samples */
+      else
+	 n1 = (nsamp[igr][ch] + 7) / 18;
+      if (n1 > 31)
+	 n1 = 31;
+      antialias(pMP3Stream->sample[ch][igr], n1);
+      n1 = 18 * n1 + 8;		/* update number of samples */
+      if (n1 > nsamp[igr][ch])
+	 nsamp[igr][ch] = n1;
+   }
+
+
+
+/*--- hybrid + sbt ---*/
+   pMP3Stream->Xform(pcm, igr);
+
+
+/*-- done --*/
+}
+/*--------------------------------------------------------------------*/
+/*-----------------------------------------------------------------*/
+IN_OUT L3audio_decode(unsigned char *bs, unsigned char *pcm)
+{
+   return pMP3Stream->decode_function(bs, pcm);
+}
+
+/*--------------------------------------------------------------------*/
+extern unsigned char *gpNextByteAfterData;
+IN_OUT L3audio_decode_MPEG1(unsigned char *bs, unsigned char *pcm)
+{
+   int sync;
+   IN_OUT in_out;
+   int side_bytes;
+   int nbytes;
+
+   int padframebytes;	////@@@@
+   
+//   iframe++;
+
+   bitget_init(bs);		/* initialize bit getter */
+/* test sync */
+   in_out.in_bytes = 0;		/* assume fail */
+   in_out.out_bytes = 0;
+   sync = bitget(12);
+
+   if (sync != 0xFFF)
+      return in_out;		/* sync fail */
+/*-----------*/
+
+/*-- unpack side info --*/
+   side_bytes = unpack_side_MPEG1();
+   padframebytes = pMP3Stream->framebytes + pMP3Stream->pad;
+
+   if (bs + padframebytes > gpNextByteAfterData)
+	   return in_out;	// error check if we're about to read off the end of the legal memory (caused by certain MP3 writers' goofy comment formats) -ste.
+   in_out.in_bytes = padframebytes;
+
+/*-- load main data and update buf pointer --*/
+/*------------------------------------------- 
+   if start point < 0, must just cycle decoder 
+   if jumping into middle of stream, 
+w---------------------------------------------*/
+   pMP3Stream->buf_ptr0 = pMP3Stream->buf_ptr1 - side_info.main_data_begin;	/* decode start point */
+   if (pMP3Stream->buf_ptr1 > BUF_TRIGGER)
+   {				/* shift buffer */
+      memmove(pMP3Stream->buf, pMP3Stream->buf + pMP3Stream->buf_ptr0, side_info.main_data_begin);
+      pMP3Stream->buf_ptr0 = 0;
+      pMP3Stream->buf_ptr1 = side_info.main_data_begin;
+   }
+   nbytes = padframebytes - side_bytes - pMP3Stream->crcbytes;
+
+   // RAK: This is no bueno. :-(
+	if (nbytes < 0 || nbytes > NBUF)
+	{
+	    in_out.in_bytes = 0;
+		 return in_out;
+   }
+
+	if (bFastEstimateOnly)
+	{
+		in_out.out_bytes = pMP3Stream->outbytes;
+		return in_out;
+	}
+
+   memmove(pMP3Stream->buf + pMP3Stream->buf_ptr1, bs + side_bytes + pMP3Stream->crcbytes, nbytes);
+   pMP3Stream->buf_ptr1 += nbytes;
+/*-----------------------*/
+
+   if (pMP3Stream->buf_ptr0 >= 0)
+   {
+// dump_frame(buf+buf_ptr0, 64);
+      pMP3Stream->main_pos_bit = pMP3Stream->buf_ptr0 << 3;
+      unpack_main(pcm, 0);
+      unpack_main(pcm + pMP3Stream->half_outbytes, 1);
+      in_out.out_bytes = pMP3Stream->outbytes;
+   }
+   else
+   {
+      memset(pcm, pMP3Stream->zero_level_pcm, pMP3Stream->outbytes);	/* fill out skipped frames */
+      in_out.out_bytes = pMP3Stream->outbytes;
+/* iframe--;  in_out.out_bytes = 0;  // test test */
+   }
+
+   return in_out;
+}
+/*--------------------------------------------------------------------*/
+/*--------------------------------------------------------------------*/
+IN_OUT L3audio_decode_MPEG2(unsigned char *bs, unsigned char *pcm)
+{
+   int sync;
+   IN_OUT in_out;
+   int side_bytes;
+   int nbytes;
+   static int igr = 0;
+
+   int padframebytes;	////@@@@
+
+//   iframe++;
+
+
+   bitget_init(bs);		/* initialize bit getter */
+/* test sync */
+   in_out.in_bytes = 0;		/* assume fail */
+   in_out.out_bytes = 0;
+   sync = bitget(12);
+
+// if( sync != 0xFFF ) return in_out;       /* sync fail */
+
+   pMP3Stream->mpeg25_flag = 0;
+   if (sync != 0xFFF)
+   {
+      pMP3Stream->mpeg25_flag = 1;		/* mpeg 2.5 sync */
+      if (sync != 0xFFE)
+	 return in_out;		/* sync fail */
+   }
+/*-----------*/
+
+
+/*-- unpack side info --*/
+   side_bytes = unpack_side_MPEG2(igr);
+   padframebytes = pMP3Stream->framebytes + pMP3Stream->pad;
+   in_out.in_bytes = padframebytes;
+
+   pMP3Stream->buf_ptr0 = pMP3Stream->buf_ptr1 - side_info.main_data_begin;	/* decode start point */
+   if (pMP3Stream->buf_ptr1 > BUF_TRIGGER)
+   {				/* shift buffer */
+      memmove(pMP3Stream->buf, pMP3Stream->buf + pMP3Stream->buf_ptr0, side_info.main_data_begin);
+      pMP3Stream->buf_ptr0 = 0;
+      pMP3Stream->buf_ptr1 = side_info.main_data_begin;
+   }
+   nbytes = padframebytes - side_bytes - pMP3Stream->crcbytes;
+   // RAK: This is no bueno. :-(
+	if (nbytes < 0 || nbytes > NBUF)
+	{
+	    in_out.in_bytes = 0;
+		 return in_out;
+   }
+
+	if (bFastEstimateOnly)
+	{
+		in_out.out_bytes = pMP3Stream->outbytes;
+		return in_out;
+	}
+
+   memmove(pMP3Stream->buf + pMP3Stream->buf_ptr1, bs + side_bytes + pMP3Stream->crcbytes, nbytes);
+   pMP3Stream->buf_ptr1 += nbytes;
+/*-----------------------*/
+
+   if (pMP3Stream->buf_ptr0 >= 0)
+   {
+      pMP3Stream->main_pos_bit = pMP3Stream->buf_ptr0 << 3;
+      unpack_main(pcm, igr);
+      in_out.out_bytes = pMP3Stream->outbytes;
+   }
+   else
+   {
+      memset(pcm, pMP3Stream->zero_level_pcm, pMP3Stream->outbytes);	/* fill out skipped frames */
+      in_out.out_bytes = pMP3Stream->outbytes;
+// iframe--;  in_out.out_bytes = 0; return in_out;// test test */
+   }
+
+
+
+   igr = igr ^ 1;
+   return in_out;
+}
+/*--------------------------------------------------------------------*/
+/*--------------------------------------------------------------------*/
+/*--------------------------------------------------------------------*/
+static const int sr_table[8] =
+{22050, 24000, 16000, 1,
+ 44100, 48000, 32000, 1};
+
+static const struct
+{
+   int l[23];
+   int s[14];
+}
+sfBandIndexTable[3][3] =
+{
+/* mpeg-2 */
+   {
+      {
+	 {
+	    0, 6, 12, 18, 24, 30, 36, 44, 54, 66, 80, 96, 116, 140, 168, 200, 238, 284, 336, 396, 464, 522, 576
+	 }
+	 ,
+	 {
+	    0, 4, 8, 12, 18, 24, 32, 42, 56, 74, 100, 132, 174, 192
+	 }
+      }
+      ,
+      {
+	 {
+	    0, 6, 12, 18, 24, 30, 36, 44, 54, 66, 80, 96, 114, 136, 162, 194, 232, 278, 332, 394, 464, 540, 576
+	 }
+	 ,
+	 {
+	    0, 4, 8, 12, 18, 26, 36, 48, 62, 80, 104, 136, 180, 192
+	 }
+      }
+      ,
+      {
+	 {
+	    0, 6, 12, 18, 24, 30, 36, 44, 54, 66, 80, 96, 116, 140, 168, 200, 238, 284, 336, 396, 464, 522, 576
+	 }
+	 ,
+	 {
+	    0, 4, 8, 12, 18, 26, 36, 48, 62, 80, 104, 134, 174, 192
+	 }
+      }
+      ,
+   }
+   ,
+/* mpeg-1 */
+   {
+      {
+	 {
+	    0, 4, 8, 12, 16, 20, 24, 30, 36, 44, 52, 62, 74, 90, 110, 134, 162, 196, 238, 288, 342, 418, 576
+	 }
+	 ,
+	 {
+	    0, 4, 8, 12, 16, 22, 30, 40, 52, 66, 84, 106, 136, 192
+	 }
+      }
+      ,
+      {
+	 {
+	    0, 4, 8, 12, 16, 20, 24, 30, 36, 42, 50, 60, 72, 88, 106, 128, 156, 190, 230, 276, 330, 384, 576
+	 }
+	 ,
+	 {
+	    0, 4, 8, 12, 16, 22, 28, 38, 50, 64, 80, 100, 126, 192
+	 }
+      }
+      ,
+      {
+	 {
+	    0, 4, 8, 12, 16, 20, 24, 30, 36, 44, 54, 66, 82, 102, 126, 156, 194, 240, 296, 364, 448, 550, 576
+	 }
+	 ,
+	 {
+	    0, 4, 8, 12, 16, 22, 30, 42, 58, 78, 104, 138, 180, 192
+	 }
+      }
+   }
+   ,
+
+/* mpeg-2.5, 11 & 12 KHz seem ok, 8 ok */
+   {
+      {
+	 {
+	    0, 6, 12, 18, 24, 30, 36, 44, 54, 66, 80, 96, 116, 140, 168, 200, 238, 284, 336, 396, 464, 522, 576
+	 }
+	 ,
+	 {
+	    0, 4, 8, 12, 18, 26, 36, 48, 62, 80, 104, 134, 174, 192
+	 }
+      }
+      ,
+      {
+	 {
+	    0, 6, 12, 18, 24, 30, 36, 44, 54, 66, 80, 96, 116, 140, 168, 200, 238, 284, 336, 396, 464, 522, 576
+	 }
+	 ,
+	 {
+	    0, 4, 8, 12, 18, 26, 36, 48, 62, 80, 104, 134, 174, 192
+	 }
+      }
+      ,
+// this 8khz table, and only 8khz, from mpeg123)
+      {
+	 {
+	    0, 12, 24, 36, 48, 60, 72, 88, 108, 132, 160, 192, 232, 280, 336, 400, 476, 566, 568, 570, 572, 574, 576
+	 }
+	 ,
+	 {
+	    0, 8, 16, 24, 36, 52, 72, 96, 124, 160, 162, 164, 166, 192
+	 }
+      }
+      ,
+   }
+   ,
+};
+
+
+void sbt_mono_L3(float *sample, signed short *pcm, int ch);
+void sbt_dual_L3(float *sample, signed short *pcm, int ch);
+void sbt16_mono_L3(float *sample, signed short *pcm, int ch);
+void sbt16_dual_L3(float *sample, signed short *pcm, int ch);
+void sbt8_mono_L3(float *sample, signed short *pcm, int ch);
+void sbt8_dual_L3(float *sample, signed short *pcm, int ch);
+
+void sbtB_mono_L3(float *sample, unsigned char *pcm, int ch);
+void sbtB_dual_L3(float *sample, unsigned char *pcm, int ch);
+void sbtB16_mono_L3(float *sample, unsigned char *pcm, int ch);
+void sbtB16_dual_L3(float *sample, unsigned char *pcm, int ch);
+void sbtB8_mono_L3(float *sample, unsigned char *pcm, int ch);
+void sbtB8_dual_L3(float *sample, unsigned char *pcm, int ch);
+
+
+
+static const SBT_FUNCTION sbt_table[2][3][2] =
+{
+{{ (SBT_FUNCTION) sbt_mono_L3,
+   (SBT_FUNCTION) sbt_dual_L3 } ,
+ { (SBT_FUNCTION) sbt16_mono_L3,
+   (SBT_FUNCTION) sbt16_dual_L3 } ,
+ { (SBT_FUNCTION) sbt8_mono_L3,
+   (SBT_FUNCTION) sbt8_dual_L3 }} ,
+/*-- 8 bit output -*/
+{{ (SBT_FUNCTION) sbtB_mono_L3,
+   (SBT_FUNCTION) sbtB_dual_L3 },
+ { (SBT_FUNCTION) sbtB16_mono_L3,
+   (SBT_FUNCTION) sbtB16_dual_L3 },
+ { (SBT_FUNCTION) sbtB8_mono_L3,
+   (SBT_FUNCTION) sbtB8_dual_L3 }}
+};
+
+
+void Xform_mono(void *pcm, int igr);
+void Xform_dual(void *pcm, int igr);
+void Xform_dual_mono(void *pcm, int igr);
+void Xform_dual_right(void *pcm, int igr);
+
+static XFORM_FUNCTION xform_table[5] =
+{
+   Xform_mono,
+   Xform_dual,
+   Xform_dual_mono,
+   Xform_mono,			/* left */
+   Xform_dual_right,
+};
+int L3table_init();
+void msis_init();
+void sbt_init();
+typedef int iARRAY22[22];
+iARRAY22 *quant_init_band_addr();
+iARRAY22 *msis_init_band_addr();
+
+/*---------------------------------------------------------*/
+/* mpeg_head defined in mhead.h  frame bytes is without pMP3Stream->pad */
+////@@@@INIT
+int L3audio_decode_init(MPEG_HEAD * h, int framebytes_arg,
+		   int reduction_code, int transform_code, int convert_code,
+			int freq_limit)
+{
+   int i, j, k;
+   // static int first_pass = 1;
+   int samprate;
+   int limit;
+   int bit_code;
+   int out_chans;
+
+   pMP3Stream->buf_ptr0 = 0;
+   pMP3Stream->buf_ptr1 = 0;
+
+/* check if code handles */
+   if (h->option != 1)
+      return 0;			/* layer III only */
+
+   if (h->id)
+      pMP3Stream->ncbl_mixed = 8;		/* mpeg-1 */
+   else
+      pMP3Stream->ncbl_mixed = 6;		/* mpeg-2 */
+
+   pMP3Stream->framebytes = framebytes_arg;
+
+   transform_code = transform_code;	/* not used, asm compatability */
+   bit_code = 0;
+   if (convert_code & 8)
+      bit_code = 1;
+   convert_code = convert_code & 3;	/* higher bits used by dec8 freq cvt */
+   if (reduction_code < 0)
+      reduction_code = 0;
+   if (reduction_code > 2)
+      reduction_code = 2;
+   if (freq_limit < 1000)
+      freq_limit = 1000;
+
+
+   samprate = sr_table[4 * h->id + h->sr_index];
+   if ((h->sync & 1) == 0)
+      samprate = samprate / 2;	// mpeg 2.5 
+/*----- compute pMP3Stream->nsb_limit --------*/
+   pMP3Stream->nsb_limit = (freq_limit * 64L + samprate / 2) / samprate;
+/*- caller limit -*/
+   limit = (32 >> reduction_code);
+   if (limit > 8)
+      limit--;
+   if (pMP3Stream->nsb_limit > limit)
+      pMP3Stream->nsb_limit = limit;
+   limit = 18 * pMP3Stream->nsb_limit;
+
+   k = h->id;
+   if ((h->sync & 1) == 0)
+      k = 2;			// mpeg 2.5 
+
+   if (k == 1)
+   {
+      pMP3Stream->band_limit12 = 3 * sfBandIndexTable[k][h->sr_index].s[13];
+      pMP3Stream->band_limit = pMP3Stream->band_limit21 = sfBandIndexTable[k][h->sr_index].l[22];
+   }
+   else
+   {
+      pMP3Stream->band_limit12 = 3 * sfBandIndexTable[k][h->sr_index].s[12];
+      pMP3Stream->band_limit = pMP3Stream->band_limit21 = sfBandIndexTable[k][h->sr_index].l[21];
+   }
+   pMP3Stream->band_limit += 8;		/* allow for antialias */
+   if (pMP3Stream->band_limit > limit)
+      pMP3Stream->band_limit = limit;
+
+   if (pMP3Stream->band_limit21 > pMP3Stream->band_limit)
+      pMP3Stream->band_limit21 = pMP3Stream->band_limit;
+   if (pMP3Stream->band_limit12 > pMP3Stream->band_limit)
+      pMP3Stream->band_limit12 = pMP3Stream->band_limit;
+
+
+   pMP3Stream->band_limit_nsb = (pMP3Stream->band_limit + 17) / 18;	/* limit nsb's rounded up */
+/*----------------------------------------------*/
+   pMP3Stream->gain_adjust = 0;		/* adjust gain e.g. cvt to mono sum channel */
+   if ((h->mode != 3) && (convert_code == 1))
+      pMP3Stream->gain_adjust = -4;
+
+   pMP3Stream->outvalues = 1152 >> reduction_code;
+   if (h->id == 0)
+      pMP3Stream->outvalues /= 2;
+
+   out_chans = 2;
+   if (h->mode == 3)
+      out_chans = 1;
+   if (convert_code)
+      out_chans = 1;
+
+   pMP3Stream->sbt_L3 = sbt_table[bit_code][reduction_code][out_chans - 1];
+   k = 1 + convert_code;
+   if (h->mode == 3)
+      k = 0;
+   pMP3Stream->Xform = xform_table[k];
+
+
+   pMP3Stream->outvalues *= out_chans;
+
+   if (bit_code)
+      pMP3Stream->outbytes = pMP3Stream->outvalues;
+   else
+      pMP3Stream->outbytes = sizeof(short) * pMP3Stream->outvalues;
+
+   if (bit_code)
+      pMP3Stream->zero_level_pcm = 128;	/* 8 bit output */
+   else
+      pMP3Stream->zero_level_pcm = 0;
+
+
+   decinfo.channels = out_chans;
+   decinfo.outvalues = pMP3Stream->outvalues;
+   decinfo.samprate = samprate >> reduction_code;
+   if (bit_code)
+      decinfo.bits = 8;
+   else
+      decinfo.bits = sizeof(short) * 8;
+
+   decinfo.framebytes = pMP3Stream->framebytes;
+   decinfo.type = 0;
+
+   pMP3Stream->half_outbytes = pMP3Stream->outbytes / 2;
+/*------------------------------------------*/
+
+/*- init band tables --*/
+
+
+   k = h->id;
+   if ((h->sync & 1) == 0)
+      k = 2;			// mpeg 2.5 
+
+   for (i = 0; i < 22; i++)
+      pMP3Stream->sfBandIndex[0][i] = sfBandIndexTable[k][h->sr_index].l[i + 1];
+   for (i = 0; i < 13; i++)
+      pMP3Stream->sfBandIndex[1][i] = 3 * sfBandIndexTable[k][h->sr_index].s[i + 1];
+   for (i = 0; i < 22; i++)
+      pMP3Stream->nBand[0][i] = sfBandIndexTable[k][h->sr_index].l[i + 1] - sfBandIndexTable[k][h->sr_index].l[i];
+   for (i = 0; i < 13; i++)
+      pMP3Stream->nBand[1][i] = sfBandIndexTable[k][h->sr_index].s[i + 1] - sfBandIndexTable[k][h->sr_index].s[i];
+
+
+/* init tables */
+   L3table_init();
+/* init ms and is stereo modes */
+   msis_init();
+
+/*----- init sbt ---*/
+   sbt_init();
+
+
+
+/*--- clear buffers --*/
+   for (i = 0; i < 576; i++)
+      yout[i] = 0.0f;
+   for (j = 0; j < 2; j++)
+   {
+      for (k = 0; k < 2; k++)
+      {
+	 for (i = 0; i < 576; i++)
+	 {
+	    pMP3Stream->sample[j][k][i].x = 0.0f;
+	    pMP3Stream->sample[j][k][i].s = 0;
+	 }
+      }
+   }
+
+   if (h->id == 1)
+      pMP3Stream->decode_function = L3audio_decode_MPEG1;
+   else
+      pMP3Stream->decode_function = L3audio_decode_MPEG2;
+
+   return 1;
+}
+/*---------------------------------------------------------*/
+/*==========================================================*/
diff --git a/codemp/mp3code/cwin.c b/codemp/mp3code/cwin.c
new file mode 100644
index 0000000..884abb1
--- /dev/null
+++ b/codemp/mp3code/cwin.c
@@ -0,0 +1,470 @@
+#pragma warning(disable:4206)	// nonstandard extension used : translation unit is empty
+#ifdef COMPILE_ME
+/*____________________________________________________________________________
+	
+	FreeAmp - The Free MP3 Player
+
+        MP3 Decoder originally Copyright (C) 1995-1997 Xing Technology
+        Corp.  http://www.xingtech.com
+
+	Portions Copyright (C) 1998-1999 EMusic.com
+
+	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., 675 Mass Ave, Cambridge, MA 02139, USA.
+	
+	$Id: cwin.c,v 1.7 1999/10/19 07:13:08 elrod Exp $
+____________________________________________________________________________*/
+
+/****  cwin.c  ***************************************************
+
+include to cwinm.c
+
+MPEG audio decoder, float window routines
+portable C
+
+******************************************************************/
+
+#include "config.h"
+
+/*-------------------------------------------------------------------------*/
+void window(float *vbuf, int vb_ptr, short *pcm)
+{
+   int i, j;
+   int si, bx;
+   const float *coef;
+   float sum;
+   long tmp;
+
+   si = vb_ptr + 16;
+   bx = (si + 32) & 511;
+   coef = wincoef;
+
+/*-- first 16 --*/
+   for (i = 0; i < 16; i++)
+   {
+      sum = 0.0F;
+      for (j = 0; j < 8; j++)
+      {
+	 sum += (*coef++) * vbuf[si];
+	 si = (si + 64) & 511;
+	 sum -= (*coef++) * vbuf[bx];
+	 bx = (bx + 64) & 511;
+      }
+      si++;
+      bx--;
+      tmp = (long) sum;
+      if (tmp > 32767)
+	 tmp = 32767;
+      else if (tmp < -32768)
+	 tmp = -32768;
+      *pcm++ = tmp;
+   }
+/*--  special case --*/
+   sum = 0.0F;
+   for (j = 0; j < 8; j++)
+   {
+      sum += (*coef++) * vbuf[bx];
+      bx = (bx + 64) & 511;
+   }
+   tmp = (long) sum;
+   if (tmp > 32767)
+      tmp = 32767;
+   else if (tmp < -32768)
+      tmp = -32768;
+   *pcm++ = tmp;
+/*-- last 15 --*/
+   coef = wincoef + 255;	/* back pass through coefs */
+   for (i = 0; i < 15; i++)
+   {
+      si--;
+      bx++;
+      sum = 0.0F;
+      for (j = 0; j < 8; j++)
+      {
+	 sum += (*coef--) * vbuf[si];
+	 si = (si + 64) & 511;
+	 sum += (*coef--) * vbuf[bx];
+	 bx = (bx + 64) & 511;
+      }
+      tmp = (long) sum;
+      if (tmp > 32767)
+	 tmp = 32767;
+      else if (tmp < -32768)
+	 tmp = -32768;
+      *pcm++ = tmp;
+   }
+}
+
+
+
+/*------------------------------------------------------------*/
+void window_dual(float *vbuf, int vb_ptr, short *pcm)
+{
+   int i, j;			/* dual window interleaves output */
+   int si, bx;
+   const float *coef;
+   float sum;
+   long tmp;
+
+   si = vb_ptr + 16;
+   bx = (si + 32) & 511;
+   coef = wincoef;
+
+/*-- first 16 --*/
+   for (i = 0; i < 16; i++)
+   {
+      sum = 0.0F;
+      for (j = 0; j < 8; j++)
+      {
+	 sum += (*coef++) * vbuf[si];
+	 si = (si + 64) & 511;
+	 sum -= (*coef++) * vbuf[bx];
+	 bx = (bx + 64) & 511;
+      }
+      si++;
+      bx--;
+      tmp = (long) sum;
+      if (tmp > 32767)
+	 tmp = 32767;
+      else if (tmp < -32768)
+	 tmp = -32768;
+      *pcm = tmp;
+      pcm += 2;
+   }
+/*--  special case --*/
+   sum = 0.0F;
+   for (j = 0; j < 8; j++)
+   {
+      sum += (*coef++) * vbuf[bx];
+      bx = (bx + 64) & 511;
+   }
+   tmp = (long) sum;
+   if (tmp > 32767)
+      tmp = 32767;
+   else if (tmp < -32768)
+      tmp = -32768;
+   *pcm = tmp;
+   pcm += 2;
+/*-- last 15 --*/
+   coef = wincoef + 255;	/* back pass through coefs */
+   for (i = 0; i < 15; i++)
+   {
+      si--;
+      bx++;
+      sum = 0.0F;
+      for (j = 0; j < 8; j++)
+      {
+	 sum += (*coef--) * vbuf[si];
+	 si = (si + 64) & 511;
+	 sum += (*coef--) * vbuf[bx];
+	 bx = (bx + 64) & 511;
+      }
+      tmp = (long) sum;
+      if (tmp > 32767)
+	 tmp = 32767;
+      else if (tmp < -32768)
+	 tmp = -32768;
+      *pcm = tmp;
+      pcm += 2;
+   }
+}
+/*------------------------------------------------------------*/
+/*------------------- 16 pt window ------------------------------*/
+void window16(float *vbuf, int vb_ptr, short *pcm)
+{
+   int i, j;
+   unsigned char si, bx;
+   const float *coef;
+   float sum;
+   long tmp;
+
+   si = vb_ptr + 8;
+   bx = si + 16;
+   coef = wincoef;
+
+/*-- first 8 --*/
+   for (i = 0; i < 8; i++)
+   {
+      sum = 0.0F;
+      for (j = 0; j < 8; j++)
+      {
+	 sum += (*coef++) * vbuf[si];
+	 si += 32;
+	 sum -= (*coef++) * vbuf[bx];
+	 bx += 32;
+      }
+      si++;
+      bx--;
+      coef += 16;
+      tmp = (long) sum;
+      if (tmp > 32767)
+	 tmp = 32767;
+      else if (tmp < -32768)
+	 tmp = -32768;
+      *pcm++ = tmp;
+   }
+/*--  special case --*/
+   sum = 0.0F;
+   for (j = 0; j < 8; j++)
+   {
+      sum += (*coef++) * vbuf[bx];
+      bx += 32;
+   }
+   tmp = (long) sum;
+   if (tmp > 32767)
+      tmp = 32767;
+   else if (tmp < -32768)
+      tmp = -32768;
+   *pcm++ = tmp;
+/*-- last 7 --*/
+   coef = wincoef + 255;	/* back pass through coefs */
+   for (i = 0; i < 7; i++)
+   {
+      coef -= 16;
+      si--;
+      bx++;
+      sum = 0.0F;
+      for (j = 0; j < 8; j++)
+      {
+	 sum += (*coef--) * vbuf[si];
+	 si += 32;
+	 sum += (*coef--) * vbuf[bx];
+	 bx += 32;
+      }
+      tmp = (long) sum;
+      if (tmp > 32767)
+	 tmp = 32767;
+      else if (tmp < -32768)
+	 tmp = -32768;
+      *pcm++ = tmp;
+   }
+}
+/*--------------- 16 pt dual window (interleaved output) -----------------*/
+void window16_dual(float *vbuf, int vb_ptr, short *pcm)
+{
+   int i, j;
+   unsigned char si, bx;
+   const float *coef;
+   float sum;
+   long tmp;
+
+   si = vb_ptr + 8;
+   bx = si + 16;
+   coef = wincoef;
+
+/*-- first 8 --*/
+   for (i = 0; i < 8; i++)
+   {
+      sum = 0.0F;
+      for (j = 0; j < 8; j++)
+      {
+	 sum += (*coef++) * vbuf[si];
+	 si += 32;
+	 sum -= (*coef++) * vbuf[bx];
+	 bx += 32;
+      }
+      si++;
+      bx--;
+      coef += 16;
+      tmp = (long) sum;
+      if (tmp > 32767)
+	 tmp = 32767;
+      else if (tmp < -32768)
+	 tmp = -32768;
+      *pcm = tmp;
+      pcm += 2;
+   }
+/*--  special case --*/
+   sum = 0.0F;
+   for (j = 0; j < 8; j++)
+   {
+      sum += (*coef++) * vbuf[bx];
+      bx += 32;
+   }
+   tmp = (long) sum;
+   if (tmp > 32767)
+      tmp = 32767;
+   else if (tmp < -32768)
+      tmp = -32768;
+   *pcm = tmp;
+   pcm += 2;
+/*-- last 7 --*/
+   coef = wincoef + 255;	/* back pass through coefs */
+   for (i = 0; i < 7; i++)
+   {
+      coef -= 16;
+      si--;
+      bx++;
+      sum = 0.0F;
+      for (j = 0; j < 8; j++)
+      {
+	 sum += (*coef--) * vbuf[si];
+	 si += 32;
+	 sum += (*coef--) * vbuf[bx];
+	 bx += 32;
+      }
+      tmp = (long) sum;
+      if (tmp > 32767)
+	 tmp = 32767;
+      else if (tmp < -32768)
+	 tmp = -32768;
+      *pcm = tmp;
+      pcm += 2;
+   }
+}
+/*------------------- 8 pt window ------------------------------*/
+void window8(float *vbuf, int vb_ptr, short *pcm)
+{
+   int i, j;
+   int si, bx;
+   const float *coef;
+   float sum;
+   long tmp;
+
+   si = vb_ptr + 4;
+   bx = (si + 8) & 127;
+   coef = wincoef;
+
+/*-- first 4 --*/
+   for (i = 0; i < 4; i++)
+   {
+      sum = 0.0F;
+      for (j = 0; j < 8; j++)
+      {
+	 sum += (*coef++) * vbuf[si];
+	 si = (si + 16) & 127;
+	 sum -= (*coef++) * vbuf[bx];
+	 bx = (bx + 16) & 127;
+      }
+      si++;
+      bx--;
+      coef += 48;
+      tmp = (long) sum;
+      if (tmp > 32767)
+	 tmp = 32767;
+      else if (tmp < -32768)
+	 tmp = -32768;
+      *pcm++ = tmp;
+   }
+/*--  special case --*/
+   sum = 0.0F;
+   for (j = 0; j < 8; j++)
+   {
+      sum += (*coef++) * vbuf[bx];
+      bx = (bx + 16) & 127;
+   }
+   tmp = (long) sum;
+   if (tmp > 32767)
+      tmp = 32767;
+   else if (tmp < -32768)
+      tmp = -32768;
+   *pcm++ = tmp;
+/*-- last 3 --*/
+   coef = wincoef + 255;	/* back pass through coefs */
+   for (i = 0; i < 3; i++)
+   {
+      coef -= 48;
+      si--;
+      bx++;
+      sum = 0.0F;
+      for (j = 0; j < 8; j++)
+      {
+	 sum += (*coef--) * vbuf[si];
+	 si = (si + 16) & 127;
+	 sum += (*coef--) * vbuf[bx];
+	 bx = (bx + 16) & 127;
+      }
+      tmp = (long) sum;
+      if (tmp > 32767)
+	 tmp = 32767;
+      else if (tmp < -32768)
+	 tmp = -32768;
+      *pcm++ = tmp;
+   }
+}
+/*--------------- 8 pt dual window (interleaved output) -----------------*/
+void window8_dual(float *vbuf, int vb_ptr, short *pcm)
+{
+   int i, j;
+   int si, bx;
+   const float *coef;
+   float sum;
+   long tmp;
+
+   si = vb_ptr + 4;
+   bx = (si + 8) & 127;
+   coef = wincoef;
+
+/*-- first 4 --*/
+   for (i = 0; i < 4; i++)
+   {
+      sum = 0.0F;
+      for (j = 0; j < 8; j++)
+      {
+	 sum += (*coef++) * vbuf[si];
+	 si = (si + 16) & 127;
+	 sum -= (*coef++) * vbuf[bx];
+	 bx = (bx + 16) & 127;
+      }
+      si++;
+      bx--;
+      coef += 48;
+      tmp = (long) sum;
+      if (tmp > 32767)
+	 tmp = 32767;
+      else if (tmp < -32768)
+	 tmp = -32768;
+      *pcm = tmp;
+      pcm += 2;
+   }
+/*--  special case --*/
+   sum = 0.0F;
+   for (j = 0; j < 8; j++)
+   {
+      sum += (*coef++) * vbuf[bx];
+      bx = (bx + 16) & 127;
+   }
+   tmp = (long) sum;
+   if (tmp > 32767)
+      tmp = 32767;
+   else if (tmp < -32768)
+      tmp = -32768;
+   *pcm = tmp;
+   pcm += 2;
+/*-- last 3 --*/
+   coef = wincoef + 255;	/* back pass through coefs */
+   for (i = 0; i < 3; i++)
+   {
+      coef -= 48;
+      si--;
+      bx++;
+      sum = 0.0F;
+      for (j = 0; j < 8; j++)
+      {
+	 sum += (*coef--) * vbuf[si];
+	 si = (si + 16) & 127;
+	 sum += (*coef--) * vbuf[bx];
+	 bx = (bx + 16) & 127;
+      }
+      tmp = (long) sum;
+      if (tmp > 32767)
+	 tmp = 32767;
+      else if (tmp < -32768)
+	 tmp = -32768;
+      *pcm = tmp;
+      pcm += 2;
+   }
+}
+/*------------------------------------------------------------*/
+#endif	// #ifdef COMPILE_ME
diff --git a/codemp/mp3code/cwinb.c b/codemp/mp3code/cwinb.c
new file mode 100644
index 0000000..537a4b7
--- /dev/null
+++ b/codemp/mp3code/cwinb.c
@@ -0,0 +1,465 @@
+#pragma warning(disable:4206)	// nonstandard extension used : translation unit is empty
+#ifdef COMPILE_ME
+/*____________________________________________________________________________
+	
+	FreeAmp - The Free MP3 Player
+
+        MP3 Decoder originally Copyright (C) 1995-1997 Xing Technology
+        Corp.  http://www.xingtech.com
+
+	Portions Copyright (C) 1998-1999 EMusic.com
+
+	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., 675 Mass Ave, Cambridge, MA 02139, USA.
+	
+	$Id: cwinb.c,v 1.4 1999/10/19 07:13:08 elrod Exp $
+____________________________________________________________________________*/
+
+/****  cwin.c  ***************************************************
+
+include to cwinm.c
+
+MPEG audio decoder, float window routines - 8 bit output
+portable C
+
+******************************************************************/
+/*-------------------------------------------------------------------------*/
+
+void windowB(float *vbuf, int vb_ptr, unsigned char *pcm)
+{
+   int i, j;
+   int si, bx;
+   const float *coef;
+   float sum;
+   long tmp;
+
+   si = vb_ptr + 16;
+   bx = (si + 32) & 511;
+   coef = wincoef;
+
+/*-- first 16 --*/
+   for (i = 0; i < 16; i++)
+   {
+      sum = 0.0F;
+      for (j = 0; j < 8; j++)
+      {
+	 sum += (*coef++) * vbuf[si];
+	 si = (si + 64) & 511;
+	 sum -= (*coef++) * vbuf[bx];
+	 bx = (bx + 64) & 511;
+      }
+      si++;
+      bx--;
+      tmp = (long) sum;
+      if (tmp > 32767)
+	 tmp = 32767;
+      else if (tmp < -32768)
+	 tmp = -32768;
+      *pcm++ = ((unsigned char) (tmp >> 8)) ^ 0x80;
+   }
+/*--  special case --*/
+   sum = 0.0F;
+   for (j = 0; j < 8; j++)
+   {
+      sum += (*coef++) * vbuf[bx];
+      bx = (bx + 64) & 511;
+   }
+   tmp = (long) sum;
+   if (tmp > 32767)
+      tmp = 32767;
+   else if (tmp < -32768)
+      tmp = -32768;
+   *pcm++ = ((unsigned char) (tmp >> 8)) ^ 0x80;
+/*-- last 15 --*/
+   coef = wincoef + 255;	/* back pass through coefs */
+   for (i = 0; i < 15; i++)
+   {
+      si--;
+      bx++;
+      sum = 0.0F;
+      for (j = 0; j < 8; j++)
+      {
+	 sum += (*coef--) * vbuf[si];
+	 si = (si + 64) & 511;
+	 sum += (*coef--) * vbuf[bx];
+	 bx = (bx + 64) & 511;
+      }
+      tmp = (long) sum;
+      if (tmp > 32767)
+	 tmp = 32767;
+      else if (tmp < -32768)
+	 tmp = -32768;
+      *pcm++ = ((unsigned char) (tmp >> 8)) ^ 0x80;
+   }
+}
+/*------------------------------------------------------------*/
+void windowB_dual(float *vbuf, int vb_ptr, unsigned char *pcm)
+{
+   int i, j;			/* dual window interleaves output */
+   int si, bx;
+   const float *coef;
+   float sum;
+   long tmp;
+
+   si = vb_ptr + 16;
+   bx = (si + 32) & 511;
+   coef = wincoef;
+
+/*-- first 16 --*/
+   for (i = 0; i < 16; i++)
+   {
+      sum = 0.0F;
+      for (j = 0; j < 8; j++)
+      {
+	 sum += (*coef++) * vbuf[si];
+	 si = (si + 64) & 511;
+	 sum -= (*coef++) * vbuf[bx];
+	 bx = (bx + 64) & 511;
+      }
+      si++;
+      bx--;
+      tmp = (long) sum;
+      if (tmp > 32767)
+	 tmp = 32767;
+      else if (tmp < -32768)
+	 tmp = -32768;
+      *pcm = ((unsigned char) (tmp >> 8)) ^ 0x80;
+      pcm += 2;
+   }
+/*--  special case --*/
+   sum = 0.0F;
+   for (j = 0; j < 8; j++)
+   {
+      sum += (*coef++) * vbuf[bx];
+      bx = (bx + 64) & 511;
+   }
+   tmp = (long) sum;
+   if (tmp > 32767)
+      tmp = 32767;
+   else if (tmp < -32768)
+      tmp = -32768;
+   *pcm = ((unsigned char) (tmp >> 8)) ^ 0x80;
+   pcm += 2;
+/*-- last 15 --*/
+   coef = wincoef + 255;	/* back pass through coefs */
+   for (i = 0; i < 15; i++)
+   {
+      si--;
+      bx++;
+      sum = 0.0F;
+      for (j = 0; j < 8; j++)
+      {
+	 sum += (*coef--) * vbuf[si];
+	 si = (si + 64) & 511;
+	 sum += (*coef--) * vbuf[bx];
+	 bx = (bx + 64) & 511;
+      }
+      tmp = (long) sum;
+      if (tmp > 32767)
+	 tmp = 32767;
+      else if (tmp < -32768)
+	 tmp = -32768;
+      *pcm = ((unsigned char) (tmp >> 8)) ^ 0x80;
+      pcm += 2;
+   }
+}
+/*------------------------------------------------------------*/
+/*------------------- 16 pt window ------------------------------*/
+void windowB16(float *vbuf, int vb_ptr, unsigned char *pcm)
+{
+   int i, j;
+   unsigned char si, bx;
+   const float *coef;
+   float sum;
+   long tmp;
+
+   si = vb_ptr + 8;
+   bx = si + 16;
+   coef = wincoef;
+
+/*-- first 8 --*/
+   for (i = 0; i < 8; i++)
+   {
+      sum = 0.0F;
+      for (j = 0; j < 8; j++)
+      {
+	 sum += (*coef++) * vbuf[si];
+	 si += 32;
+	 sum -= (*coef++) * vbuf[bx];
+	 bx += 32;
+      }
+      si++;
+      bx--;
+      coef += 16;
+      tmp = (long) sum;
+      if (tmp > 32767)
+	 tmp = 32767;
+      else if (tmp < -32768)
+	 tmp = -32768;
+      *pcm++ = ((unsigned char) (tmp >> 8)) ^ 0x80;
+   }
+/*--  special case --*/
+   sum = 0.0F;
+   for (j = 0; j < 8; j++)
+   {
+      sum += (*coef++) * vbuf[bx];
+      bx += 32;
+   }
+   tmp = (long) sum;
+   if (tmp > 32767)
+      tmp = 32767;
+   else if (tmp < -32768)
+      tmp = -32768;
+   *pcm++ = ((unsigned char) (tmp >> 8)) ^ 0x80;
+/*-- last 7 --*/
+   coef = wincoef + 255;	/* back pass through coefs */
+   for (i = 0; i < 7; i++)
+   {
+      coef -= 16;
+      si--;
+      bx++;
+      sum = 0.0F;
+      for (j = 0; j < 8; j++)
+      {
+	 sum += (*coef--) * vbuf[si];
+	 si += 32;
+	 sum += (*coef--) * vbuf[bx];
+	 bx += 32;
+      }
+      tmp = (long) sum;
+      if (tmp > 32767)
+	 tmp = 32767;
+      else if (tmp < -32768)
+	 tmp = -32768;
+      *pcm++ = ((unsigned char) (tmp >> 8)) ^ 0x80;
+   }
+}
+/*--------------- 16 pt dual window (interleaved output) -----------------*/
+void windowB16_dual(float *vbuf, int vb_ptr, unsigned char *pcm)
+{
+   int i, j;
+   unsigned char si, bx;
+   const float *coef;
+   float sum;
+   long tmp;
+
+   si = vb_ptr + 8;
+   bx = si + 16;
+   coef = wincoef;
+
+/*-- first 8 --*/
+   for (i = 0; i < 8; i++)
+   {
+      sum = 0.0F;
+      for (j = 0; j < 8; j++)
+      {
+	 sum += (*coef++) * vbuf[si];
+	 si += 32;
+	 sum -= (*coef++) * vbuf[bx];
+	 bx += 32;
+      }
+      si++;
+      bx--;
+      coef += 16;
+      tmp = (long) sum;
+      if (tmp > 32767)
+	 tmp = 32767;
+      else if (tmp < -32768)
+	 tmp = -32768;
+      *pcm = ((unsigned char) (tmp >> 8)) ^ 0x80;
+      pcm += 2;
+   }
+/*--  special case --*/
+   sum = 0.0F;
+   for (j = 0; j < 8; j++)
+   {
+      sum += (*coef++) * vbuf[bx];
+      bx += 32;
+   }
+   tmp = (long) sum;
+   if (tmp > 32767)
+      tmp = 32767;
+   else if (tmp < -32768)
+      tmp = -32768;
+   *pcm = ((unsigned char) (tmp >> 8)) ^ 0x80;
+   pcm += 2;
+/*-- last 7 --*/
+   coef = wincoef + 255;	/* back pass through coefs */
+   for (i = 0; i < 7; i++)
+   {
+      coef -= 16;
+      si--;
+      bx++;
+      sum = 0.0F;
+      for (j = 0; j < 8; j++)
+      {
+	 sum += (*coef--) * vbuf[si];
+	 si += 32;
+	 sum += (*coef--) * vbuf[bx];
+	 bx += 32;
+      }
+      tmp = (long) sum;
+      if (tmp > 32767)
+	 tmp = 32767;
+      else if (tmp < -32768)
+	 tmp = -32768;
+      *pcm = ((unsigned char) (tmp >> 8)) ^ 0x80;
+      pcm += 2;
+   }
+}
+/*------------------- 8 pt window ------------------------------*/
+void windowB8(float *vbuf, int vb_ptr, unsigned char *pcm)
+{
+   int i, j;
+   int si, bx;
+   const float *coef;
+   float sum;
+   long tmp;
+
+   si = vb_ptr + 4;
+   bx = (si + 8) & 127;
+   coef = wincoef;
+
+/*-- first 4 --*/
+   for (i = 0; i < 4; i++)
+   {
+      sum = 0.0F;
+      for (j = 0; j < 8; j++)
+      {
+	 sum += (*coef++) * vbuf[si];
+	 si = (si + 16) & 127;
+	 sum -= (*coef++) * vbuf[bx];
+	 bx = (bx + 16) & 127;
+      }
+      si++;
+      bx--;
+      coef += 48;
+      tmp = (long) sum;
+      if (tmp > 32767)
+	 tmp = 32767;
+      else if (tmp < -32768)
+	 tmp = -32768;
+      *pcm++ = ((unsigned char) (tmp >> 8)) ^ 0x80;
+   }
+/*--  special case --*/
+   sum = 0.0F;
+   for (j = 0; j < 8; j++)
+   {
+      sum += (*coef++) * vbuf[bx];
+      bx = (bx + 16) & 127;
+   }
+   tmp = (long) sum;
+   if (tmp > 32767)
+      tmp = 32767;
+   else if (tmp < -32768)
+      tmp = -32768;
+   *pcm++ = ((unsigned char) (tmp >> 8)) ^ 0x80;
+/*-- last 3 --*/
+   coef = wincoef + 255;	/* back pass through coefs */
+   for (i = 0; i < 3; i++)
+   {
+      coef -= 48;
+      si--;
+      bx++;
+      sum = 0.0F;
+      for (j = 0; j < 8; j++)
+      {
+	 sum += (*coef--) * vbuf[si];
+	 si = (si + 16) & 127;
+	 sum += (*coef--) * vbuf[bx];
+	 bx = (bx + 16) & 127;
+      }
+      tmp = (long) sum;
+      if (tmp > 32767)
+	 tmp = 32767;
+      else if (tmp < -32768)
+	 tmp = -32768;
+      *pcm++ = ((unsigned char) (tmp >> 8)) ^ 0x80;
+   }
+}
+/*--------------- 8 pt dual window (interleaved output) -----------------*/
+void windowB8_dual(float *vbuf, int vb_ptr, unsigned char *pcm)
+{
+   int i, j;
+   int si, bx;
+   const float *coef;
+   float sum;
+   long tmp;
+
+   si = vb_ptr + 4;
+   bx = (si + 8) & 127;
+   coef = wincoef;
+
+/*-- first 4 --*/
+   for (i = 0; i < 4; i++)
+   {
+      sum = 0.0F;
+      for (j = 0; j < 8; j++)
+      {
+	 sum += (*coef++) * vbuf[si];
+	 si = (si + 16) & 127;
+	 sum -= (*coef++) * vbuf[bx];
+	 bx = (bx + 16) & 127;
+      }
+      si++;
+      bx--;
+      coef += 48;
+      tmp = (long) sum;
+      if (tmp > 32767)
+	 tmp = 32767;
+      else if (tmp < -32768)
+	 tmp = -32768;
+      *pcm = ((unsigned char) (tmp >> 8)) ^ 0x80;
+      pcm += 2;
+   }
+/*--  special case --*/
+   sum = 0.0F;
+   for (j = 0; j < 8; j++)
+   {
+      sum += (*coef++) * vbuf[bx];
+      bx = (bx + 16) & 127;
+   }
+   tmp = (long) sum;
+   if (tmp > 32767)
+      tmp = 32767;
+   else if (tmp < -32768)
+      tmp = -32768;
+   *pcm = ((unsigned char) (tmp >> 8)) ^ 0x80;
+   pcm += 2;
+/*-- last 3 --*/
+   coef = wincoef + 255;	/* back pass through coefs */
+   for (i = 0; i < 3; i++)
+   {
+      coef -= 48;
+      si--;
+      bx++;
+      sum = 0.0F;
+      for (j = 0; j < 8; j++)
+      {
+	 sum += (*coef--) * vbuf[si];
+	 si = (si + 16) & 127;
+	 sum += (*coef--) * vbuf[bx];
+	 bx = (bx + 16) & 127;
+      }
+      tmp = (long) sum;
+      if (tmp > 32767)
+	 tmp = 32767;
+      else if (tmp < -32768)
+	 tmp = -32768;
+      *pcm = ((unsigned char) (tmp >> 8)) ^ 0x80;
+      pcm += 2;
+   }
+}
+/*------------------------------------------------------------*/
+#endif	// #ifdef COMPILE_ME
diff --git a/codemp/mp3code/cwinm.c b/codemp/mp3code/cwinm.c
new file mode 100644
index 0000000..8a18f0d
--- /dev/null
+++ b/codemp/mp3code/cwinm.c
@@ -0,0 +1,55 @@
+/*____________________________________________________________________________
+	
+	FreeAmp - The Free MP3 Player
+
+        MP3 Decoder originally Copyright (C) 1995-1997 Xing Technology
+        Corp.  http://www.xingtech.com
+
+	Portions Copyright (C) 1998-1999 EMusic.com
+
+	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., 675 Mass Ave, Cambridge, MA 02139, USA.
+	
+	$Id: cwinm.c,v 1.3 1999/10/19 07:13:08 elrod Exp $
+____________________________________________________________________________*/
+
+/****  cwinm.c  ***************************************************
+
+MPEG audio decoder, window master routine
+portable C
+
+
+******************************************************************/
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <float.h>
+#include <math.h>
+
+
+/* disable precision loss warning on type conversion */
+#ifdef _MSC_VER
+#pragma warning(disable:4244 4056)
+#endif
+
+const float wincoef[264] =
+{				/* window coefs */
+#include "tableawd.h"
+};
+
+/*--------------------------------------------------------*/
+#define COMPILE_ME
+#include "cwin.c"
+#include "cwinb.c"
+/*--------------------------------------------------------*/
diff --git a/codemp/mp3code/htable.h b/codemp/mp3code/htable.h
new file mode 100644
index 0000000..3131bd5
--- /dev/null
+++ b/codemp/mp3code/htable.h
@@ -0,0 +1,999 @@
+/*____________________________________________________________________________
+	
+	FreeAmp - The Free MP3 Player
+
+        MP3 Decoder originally Copyright (C) 1995-1997 Xing Technology
+        Corp.  http://www.xingtech.com
+
+	Portions Copyright (C) 1998-1999 EMusic.com
+
+	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.}, {675 Mass Ave}, {Cambridge}, {MA 02139}, {USA.
+	
+	$Id: htable.h,v 1.2 1999/10/19 07:13:08 elrod Exp $
+____________________________________________________________________________*/
+
+/* TABLE  1    4 entries  maxbits  3  linbits  0 */
+static const HUFF_ELEMENT huff_table_1[] =
+{
+  {0xFF000003}, {0x03010102}, {0x03010001}, {0x02000101}, {0x02000101},	/*  4 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},
+};
+
+/* max table bits  3 */
+
+/* TABLE  2    9 entries  maxbits  6  linbits  0 */
+static const HUFF_ELEMENT huff_table_2[] =
+{
+  {0xFF000006}, {0x06020202}, {0x06020001}, {0x05020102}, {0x05020102},	/*  4 */
+  {0x05010202}, {0x05010202}, {0x05000201}, {0x05000201}, {0x03010102},	/*  9 */
+  {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102},	/* 14 */
+  {0x03010102}, {0x03010102}, {0x03010001}, {0x03010001}, {0x03010001},	/* 19 */
+  {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001},	/* 24 */
+  {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101},	/* 29 */
+  {0x03000101}, {0x03000101}, {0x03000101}, {0x01000000}, {0x01000000},	/* 34 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 39 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 44 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 49 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 54 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 59 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, /* 64 */
+};
+
+/* max table bits  6 */
+
+/* TABLE  3    9 entries  maxbits  6  linbits  0 */
+static const HUFF_ELEMENT huff_table_3[] =
+{
+  {0xFF000006}, {0x06020202}, {0x06020001}, {0x05020102}, {0x05020102},	/*  4 */
+  {0x05010202}, {0x05010202}, {0x05000201}, {0x05000201}, {0x03000101},	/*  9 */
+  {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101},	/* 14 */
+  {0x03000101}, {0x03000101}, {0x02010102}, {0x02010102}, {0x02010102},	/* 19 */
+  {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102},	/* 24 */
+  {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102},	/* 29 */
+  {0x02010102}, {0x02010102}, {0x02010102}, {0x02010001}, {0x02010001},	/* 34 */
+  {0x02010001}, {0x02010001}, {0x02010001}, {0x02010001}, {0x02010001},	/* 39 */
+  {0x02010001}, {0x02010001}, {0x02010001}, {0x02010001}, {0x02010001},	/* 44 */
+  {0x02010001}, {0x02010001}, {0x02010001}, {0x02010001}, {0x02000000},	/* 49 */
+  {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000},	/* 54 */
+  {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000},	/* 59 */
+  {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, /* 64 */
+};
+
+/* max table bits  6 */
+/* NO XING TABLE 4 */
+
+/* TABLE  5   16 entries  maxbits  8  linbits  0 */
+static const HUFF_ELEMENT huff_table_5[] =
+{
+  {0xFF000008}, {0x08030302}, {0x08030202}, {0x07020302}, {0x07020302},	/*  4 */
+  {0x06010302}, {0x06010302}, {0x06010302}, {0x06010302}, {0x07030102},	/*  9 */
+  {0x07030102}, {0x07030001}, {0x07030001}, {0x07000301}, {0x07000301},	/* 14 */
+  {0x07020202}, {0x07020202}, {0x06020102}, {0x06020102}, {0x06020102},	/* 19 */
+  {0x06020102}, {0x06010202}, {0x06010202}, {0x06010202}, {0x06010202},	/* 24 */
+  {0x06020001}, {0x06020001}, {0x06020001}, {0x06020001}, {0x06000201},	/* 29 */
+  {0x06000201}, {0x06000201}, {0x06000201}, {0x03010102}, {0x03010102},	/* 34 */
+  {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102},	/* 39 */
+  {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102},	/* 44 */
+  {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102},	/* 49 */
+  {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102},	/* 54 */
+  {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102},	/* 59 */
+  {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102},	/* 64 */
+  {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001},	/* 69 */
+  {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001},	/* 74 */
+  {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001},	/* 79 */
+  {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001},	/* 84 */
+  {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001},	/* 89 */
+  {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001},	/* 94 */
+  {0x03010001}, {0x03010001}, {0x03000101}, {0x03000101}, {0x03000101},	/* 99 */
+  {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101},	/* 104 */
+  {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101},	/* 109 */
+  {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101},	/* 114 */
+  {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101},	/* 119 */
+  {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101},	/* 124 */
+  {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x01000000},	/* 129 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 134 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 139 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 144 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 149 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 154 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 159 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 164 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 169 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 174 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 179 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 184 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 189 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 194 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 199 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 204 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 209 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 214 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 219 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 224 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 229 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 234 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 239 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 244 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 249 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 254 */
+  {0x01000000}, {0x01000000},
+};
+
+/* max table bits  8 */
+
+/* TABLE  6   16 entries  maxbits  7  linbits  0 */
+static const HUFF_ELEMENT huff_table_6[] =
+{
+  {0xFF000007}, {0x07030302}, {0x07030001}, {0x06030202}, {0x06030202},	/*  4 */
+  {0x06020302}, {0x06020302}, {0x06000301}, {0x06000301}, {0x05030102},	/*  9 */
+  {0x05030102}, {0x05030102}, {0x05030102}, {0x05010302}, {0x05010302},	/* 14 */
+  {0x05010302}, {0x05010302}, {0x05020202}, {0x05020202}, {0x05020202},	/* 19 */
+  {0x05020202}, {0x05020001}, {0x05020001}, {0x05020001}, {0x05020001},	/* 24 */
+  {0x04020102}, {0x04020102}, {0x04020102}, {0x04020102}, {0x04020102},	/* 29 */
+  {0x04020102}, {0x04020102}, {0x04020102}, {0x04010202}, {0x04010202},	/* 34 */
+  {0x04010202}, {0x04010202}, {0x04010202}, {0x04010202}, {0x04010202},	/* 39 */
+  {0x04010202}, {0x04000201}, {0x04000201}, {0x04000201}, {0x04000201},	/* 44 */
+  {0x04000201}, {0x04000201}, {0x04000201}, {0x04000201}, {0x03010001},	/* 49 */
+  {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001},	/* 54 */
+  {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001},	/* 59 */
+  {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001},	/* 64 */
+  {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102},	/* 69 */
+  {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102},	/* 74 */
+  {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102},	/* 79 */
+  {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102},	/* 84 */
+  {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102},	/* 89 */
+  {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102},	/* 94 */
+  {0x02010102}, {0x02010102}, {0x03000101}, {0x03000101}, {0x03000101},	/* 99 */
+  {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101},	/* 104 */
+  {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101},	/* 109 */
+  {0x03000101}, {0x03000101}, {0x03000101}, {0x03000000}, {0x03000000},	/* 114 */
+  {0x03000000}, {0x03000000}, {0x03000000}, {0x03000000}, {0x03000000},	/* 119 */
+  {0x03000000}, {0x03000000}, {0x03000000}, {0x03000000}, {0x03000000},	/* 124 */
+  {0x03000000}, {0x03000000}, {0x03000000}, {0x03000000},
+};
+
+/* max table bits  7 */
+
+/* TABLE  7   36 entries  maxbits 10  linbits  0 */
+static const HUFF_ELEMENT huff_table_7[] =
+{
+  {0xFF000006}, {0x00000041}, {0x00000052}, {0x0000005B}, {0x00000060},	/*  4 */
+  {0x00000063}, {0x00000068}, {0x0000006B}, {0x06020102}, {0x05010202},	/*  9 */
+  {0x05010202}, {0x06020001}, {0x06000201}, {0x04010102}, {0x04010102},	/* 14 */
+  {0x04010102}, {0x04010102}, {0x03010001}, {0x03010001}, {0x03010001},	/* 19 */
+  {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001},	/* 24 */
+  {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101},	/* 29 */
+  {0x03000101}, {0x03000101}, {0x03000101}, {0x01000000}, {0x01000000},	/* 34 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 39 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 44 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 49 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 54 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 59 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 64 */
+  {0xFF000004}, {0x04050502}, {0x04050402}, {0x04040502}, {0x04030502},	/* 69 */
+  {0x03050302}, {0x03050302}, {0x03040402}, {0x03040402}, {0x03050202},	/* 74 */
+  {0x03050202}, {0x03020502}, {0x03020502}, {0x02050102}, {0x02050102},	/* 79 */
+  {0x02050102}, {0x02050102}, {0xFF000003}, {0x02010502}, {0x02010502},	/* 84 */
+  {0x03050001}, {0x03040302}, {0x02000501}, {0x02000501}, {0x03030402},	/* 89 */
+  {0x03030302}, {0xFF000002}, {0x02040202}, {0x02020402}, {0x01040102},	/* 94 */
+  {0x01040102}, {0xFF000001}, {0x01010402}, {0x01000401}, {0xFF000002},	/* 99 */
+  {0x02040001}, {0x02030202}, {0x02020302}, {0x02030001}, {0xFF000001},	/* 104 */
+  {0x01030102}, {0x01010302}, {0xFF000001}, {0x01000301}, {0x01020202}, /* 109 */
+};
+
+/* max table bits  6 */
+
+/* TABLE  8   36 entries  maxbits 11  linbits  0 */
+static const HUFF_ELEMENT huff_table_8[] =
+{
+  {0xFF000008}, {0x00000101}, {0x0000010A}, {0x0000010F}, {0x08050102},	/*  4 */
+  {0x08010502}, {0x00000112}, {0x00000115}, {0x08040202}, {0x08020402},	/*  9 */
+  {0x08040102}, {0x07010402}, {0x07010402}, {0x08040001}, {0x08000401},	/* 14 */
+  {0x08030202}, {0x08020302}, {0x08030102}, {0x08010302}, {0x08030001},	/* 19 */
+  {0x08000301}, {0x06020202}, {0x06020202}, {0x06020202}, {0x06020202},	/* 24 */
+  {0x06020001}, {0x06020001}, {0x06020001}, {0x06020001}, {0x06000201},	/* 29 */
+  {0x06000201}, {0x06000201}, {0x06000201}, {0x04020102}, {0x04020102},	/* 34 */
+  {0x04020102}, {0x04020102}, {0x04020102}, {0x04020102}, {0x04020102},	/* 39 */
+  {0x04020102}, {0x04020102}, {0x04020102}, {0x04020102}, {0x04020102},	/* 44 */
+  {0x04020102}, {0x04020102}, {0x04020102}, {0x04020102}, {0x04010202},	/* 49 */
+  {0x04010202}, {0x04010202}, {0x04010202}, {0x04010202}, {0x04010202},	/* 54 */
+  {0x04010202}, {0x04010202}, {0x04010202}, {0x04010202}, {0x04010202},	/* 59 */
+  {0x04010202}, {0x04010202}, {0x04010202}, {0x04010202}, {0x04010202},	/* 64 */
+  {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102},	/* 69 */
+  {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102},	/* 74 */
+  {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102},	/* 79 */
+  {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102},	/* 84 */
+  {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102},	/* 89 */
+  {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102},	/* 94 */
+  {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102},	/* 99 */
+  {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102},	/* 104 */
+  {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102},	/* 109 */
+  {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102},	/* 114 */
+  {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102},	/* 119 */
+  {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102},	/* 124 */
+  {0x02010102}, {0x02010102}, {0x02010102}, {0x02010102}, {0x03010001},	/* 129 */
+  {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001},	/* 134 */
+  {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001},	/* 139 */
+  {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001},	/* 144 */
+  {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001},	/* 149 */
+  {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001},	/* 154 */
+  {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001},	/* 159 */
+  {0x03010001}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101},	/* 164 */
+  {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101},	/* 169 */
+  {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101},	/* 174 */
+  {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101},	/* 179 */
+  {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101},	/* 184 */
+  {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101},	/* 189 */
+  {0x03000101}, {0x03000101}, {0x03000101}, {0x02000000}, {0x02000000},	/* 194 */
+  {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000},	/* 199 */
+  {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000},	/* 204 */
+  {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000},	/* 209 */
+  {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000},	/* 214 */
+  {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000},	/* 219 */
+  {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000},	/* 224 */
+  {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000},	/* 229 */
+  {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000},	/* 234 */
+  {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000},	/* 239 */
+  {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000},	/* 244 */
+  {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000},	/* 249 */
+  {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000},	/* 254 */
+  {0x02000000}, {0x02000000}, {0xFF000003}, {0x03050502}, {0x03040502},	/* 259 */
+  {0x02050402}, {0x02050402}, {0x01030502}, {0x01030502}, {0x01030502},	/* 264 */
+  {0x01030502}, {0xFF000002}, {0x02050302}, {0x02040402}, {0x01050202},	/* 269 */
+  {0x01050202}, {0xFF000001}, {0x01020502}, {0x01050001}, {0xFF000001},	/* 274 */
+  {0x01040302}, {0x01030402}, {0xFF000001}, {0x01000501}, {0x01030302}, /* 279 */
+};
+
+/* max table bits  8 */
+
+/* TABLE  9   36 entries  maxbits  9  linbits  0 */
+static const HUFF_ELEMENT huff_table_9[] =
+{
+  {0xFF000006}, {0x00000041}, {0x0000004A}, {0x0000004F}, {0x00000052},	/*  4 */
+  {0x00000057}, {0x0000005A}, {0x06040102}, {0x06010402}, {0x06030202},	/*  9 */
+  {0x06020302}, {0x05030102}, {0x05030102}, {0x05010302}, {0x05010302},	/* 14 */
+  {0x06030001}, {0x06000301}, {0x05020202}, {0x05020202}, {0x05020001},	/* 19 */
+  {0x05020001}, {0x04020102}, {0x04020102}, {0x04020102}, {0x04020102},	/* 24 */
+  {0x04010202}, {0x04010202}, {0x04010202}, {0x04010202}, {0x04000201},	/* 29 */
+  {0x04000201}, {0x04000201}, {0x04000201}, {0x03010102}, {0x03010102},	/* 34 */
+  {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102},	/* 39 */
+  {0x03010102}, {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001},	/* 44 */
+  {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, {0x03000101},	/* 49 */
+  {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101},	/* 54 */
+  {0x03000101}, {0x03000101}, {0x03000000}, {0x03000000}, {0x03000000},	/* 59 */
+  {0x03000000}, {0x03000000}, {0x03000000}, {0x03000000}, {0x03000000},	/* 64 */
+  {0xFF000003}, {0x03050502}, {0x03050402}, {0x02050302}, {0x02050302},	/* 69 */
+  {0x02030502}, {0x02030502}, {0x03040502}, {0x03050001}, {0xFF000002},	/* 74 */
+  {0x02040402}, {0x02050202}, {0x02020502}, {0x02050102}, {0xFF000001},	/* 79 */
+  {0x01010502}, {0x01040302}, {0xFF000002}, {0x01030402}, {0x01030402},	/* 84 */
+  {0x02000501}, {0x02040001}, {0xFF000001}, {0x01040202}, {0x01020402},	/* 89 */
+  {0xFF000001}, {0x01030302}, {0x01000401},
+};
+
+/* max table bits  6 */
+
+/* TABLE 10   64 entries  maxbits 11  linbits  0 */
+static const HUFF_ELEMENT huff_table_10[] =
+{
+  {0xFF000008}, {0x00000101}, {0x0000010A}, {0x0000010F}, {0x00000118},	/*  4 */
+  {0x0000011B}, {0x00000120}, {0x00000125}, {0x08070102}, {0x08010702},	/*  9 */
+  {0x0000012A}, {0x0000012D}, {0x00000132}, {0x08060102}, {0x08010602},	/* 14 */
+  {0x08000601}, {0x00000137}, {0x0000013A}, {0x0000013D}, {0x08040102},	/* 19 */
+  {0x08010402}, {0x08000401}, {0x08030202}, {0x08020302}, {0x08030001},	/* 24 */
+  {0x07030102}, {0x07030102}, {0x07010302}, {0x07010302}, {0x07000301},	/* 29 */
+  {0x07000301}, {0x07020202}, {0x07020202}, {0x06020102}, {0x06020102},	/* 34 */
+  {0x06020102}, {0x06020102}, {0x06010202}, {0x06010202}, {0x06010202},	/* 39 */
+  {0x06010202}, {0x06020001}, {0x06020001}, {0x06020001}, {0x06020001},	/* 44 */
+  {0x06000201}, {0x06000201}, {0x06000201}, {0x06000201}, {0x04010102},	/* 49 */
+  {0x04010102}, {0x04010102}, {0x04010102}, {0x04010102}, {0x04010102},	/* 54 */
+  {0x04010102}, {0x04010102}, {0x04010102}, {0x04010102}, {0x04010102},	/* 59 */
+  {0x04010102}, {0x04010102}, {0x04010102}, {0x04010102}, {0x04010102},	/* 64 */
+  {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001},	/* 69 */
+  {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001},	/* 74 */
+  {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001},	/* 79 */
+  {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001},	/* 84 */
+  {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001},	/* 89 */
+  {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001},	/* 94 */
+  {0x03010001}, {0x03010001}, {0x03000101}, {0x03000101}, {0x03000101},	/* 99 */
+  {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101},	/* 104 */
+  {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101},	/* 109 */
+  {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101},	/* 114 */
+  {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101},	/* 119 */
+  {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101},	/* 124 */
+  {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x01000000},	/* 129 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 134 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 139 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 144 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 149 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 154 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 159 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 164 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 169 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 174 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 179 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 184 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 189 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 194 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 199 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 204 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 209 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 214 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 219 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 224 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 229 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 234 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 239 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 244 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 249 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 254 */
+  {0x01000000}, {0x01000000}, {0xFF000003}, {0x03070702}, {0x03070602},	/* 259 */
+  {0x03060702}, {0x03070502}, {0x03050702}, {0x03060602}, {0x02070402},	/* 264 */
+  {0x02070402}, {0xFF000002}, {0x02040702}, {0x02060502}, {0x02050602},	/* 269 */
+  {0x02070302}, {0xFF000003}, {0x02030702}, {0x02030702}, {0x02060402},	/* 274 */
+  {0x02060402}, {0x03050502}, {0x03040502}, {0x02030602}, {0x02030602},	/* 279 */
+  {0xFF000001}, {0x01070202}, {0x01020702}, {0xFF000002}, {0x02040602},	/* 284 */
+  {0x02070001}, {0x01000701}, {0x01000701}, {0xFF000002}, {0x01020602},	/* 289 */
+  {0x01020602}, {0x02050402}, {0x02050302}, {0xFF000002}, {0x01060001},	/* 294 */
+  {0x01060001}, {0x02030502}, {0x02040402}, {0xFF000001}, {0x01060302},	/* 299 */
+  {0x01060202}, {0xFF000002}, {0x02050202}, {0x02020502}, {0x01050102},	/* 304 */
+  {0x01050102}, {0xFF000002}, {0x01010502}, {0x01010502}, {0x02040302},	/* 309 */
+  {0x02030402}, {0xFF000001}, {0x01050001}, {0x01000501}, {0xFF000001},	/* 314 */
+  {0x01040202}, {0x01020402}, {0xFF000001}, {0x01030302}, {0x01040001}, /* 319 */
+};
+
+/* max table bits  8 */
+
+/* TABLE 11   64 entries  maxbits 11  linbits  0 */
+static const HUFF_ELEMENT huff_table_11[] =
+{
+  {0xFF000008}, {0x00000101}, {0x00000106}, {0x0000010F}, {0x00000114},	/*  4 */
+  {0x00000117}, {0x08070202}, {0x08020702}, {0x0000011C}, {0x07010702},	/*  9 */
+  {0x07010702}, {0x08070102}, {0x08000701}, {0x08060302}, {0x08030602},	/* 14 */
+  {0x08000601}, {0x0000011F}, {0x00000122}, {0x08050102}, {0x07020602},	/* 19 */
+  {0x07020602}, {0x08060202}, {0x08060001}, {0x07060102}, {0x07060102},	/* 24 */
+  {0x07010602}, {0x07010602}, {0x08010502}, {0x08040302}, {0x08000501},	/* 29 */
+  {0x00000125}, {0x08040202}, {0x08020402}, {0x08040102}, {0x08010402},	/* 34 */
+  {0x08040001}, {0x08000401}, {0x07030202}, {0x07030202}, {0x07020302},	/* 39 */
+  {0x07020302}, {0x06030102}, {0x06030102}, {0x06030102}, {0x06030102},	/* 44 */
+  {0x06010302}, {0x06010302}, {0x06010302}, {0x06010302}, {0x07030001},	/* 49 */
+  {0x07030001}, {0x07000301}, {0x07000301}, {0x06020202}, {0x06020202},	/* 54 */
+  {0x06020202}, {0x06020202}, {0x05010202}, {0x05010202}, {0x05010202},	/* 59 */
+  {0x05010202}, {0x05010202}, {0x05010202}, {0x05010202}, {0x05010202},	/* 64 */
+  {0x04020102}, {0x04020102}, {0x04020102}, {0x04020102}, {0x04020102},	/* 69 */
+  {0x04020102}, {0x04020102}, {0x04020102}, {0x04020102}, {0x04020102},	/* 74 */
+  {0x04020102}, {0x04020102}, {0x04020102}, {0x04020102}, {0x04020102},	/* 79 */
+  {0x04020102}, {0x05020001}, {0x05020001}, {0x05020001}, {0x05020001},	/* 84 */
+  {0x05020001}, {0x05020001}, {0x05020001}, {0x05020001}, {0x05000201},	/* 89 */
+  {0x05000201}, {0x05000201}, {0x05000201}, {0x05000201}, {0x05000201},	/* 94 */
+  {0x05000201}, {0x05000201}, {0x03010102}, {0x03010102}, {0x03010102},	/* 99 */
+  {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102},	/* 104 */
+  {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102},	/* 109 */
+  {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102},	/* 114 */
+  {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102},	/* 119 */
+  {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102},	/* 124 */
+  {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102}, {0x03010001},	/* 129 */
+  {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001},	/* 134 */
+  {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001},	/* 139 */
+  {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001},	/* 144 */
+  {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001},	/* 149 */
+  {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001},	/* 154 */
+  {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001},	/* 159 */
+  {0x03010001}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101},	/* 164 */
+  {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101},	/* 169 */
+  {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101},	/* 174 */
+  {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101},	/* 179 */
+  {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101},	/* 184 */
+  {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101},	/* 189 */
+  {0x03000101}, {0x03000101}, {0x03000101}, {0x02000000}, {0x02000000},	/* 194 */
+  {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000},	/* 199 */
+  {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000},	/* 204 */
+  {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000},	/* 209 */
+  {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000},	/* 214 */
+  {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000},	/* 219 */
+  {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000},	/* 224 */
+  {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000},	/* 229 */
+  {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000},	/* 234 */
+  {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000},	/* 239 */
+  {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000},	/* 244 */
+  {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000},	/* 249 */
+  {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000}, {0x02000000},	/* 254 */
+  {0x02000000}, {0x02000000}, {0xFF000002}, {0x02070702}, {0x02070602},	/* 259 */
+  {0x02060702}, {0x02050702}, {0xFF000003}, {0x02060602}, {0x02060602},	/* 264 */
+  {0x02070402}, {0x02070402}, {0x02040702}, {0x02040702}, {0x03070502},	/* 269 */
+  {0x03050502}, {0xFF000002}, {0x02060502}, {0x02050602}, {0x01070302},	/* 274 */
+  {0x01070302}, {0xFF000001}, {0x01030702}, {0x01060402}, {0xFF000002},	/* 279 */
+  {0x02050402}, {0x02040502}, {0x02050302}, {0x02030502}, {0xFF000001},	/* 284 */
+  {0x01040602}, {0x01070001}, {0xFF000001}, {0x01040402}, {0x01050202},	/* 289 */
+  {0xFF000001}, {0x01020502}, {0x01050001}, {0xFF000001}, {0x01030402},	/* 294 */
+  {0x01030302},
+};
+
+/* max table bits  8 */
+
+/* TABLE 12   64 entries  maxbits 10  linbits  0 */
+static const HUFF_ELEMENT huff_table_12[] =
+{
+  {0xFF000007}, {0x00000081}, {0x0000008A}, {0x0000008F}, {0x00000092},	/*  4 */
+  {0x00000097}, {0x0000009A}, {0x0000009D}, {0x000000A2}, {0x000000A5},	/*  9 */
+  {0x000000A8}, {0x07060202}, {0x07020602}, {0x07010602}, {0x000000AD},	/* 14 */
+  {0x000000B0}, {0x000000B3}, {0x07050102}, {0x07010502}, {0x07040302},	/* 19 */
+  {0x07030402}, {0x000000B6}, {0x07040202}, {0x07020402}, {0x07040102},	/* 24 */
+  {0x06030302}, {0x06030302}, {0x06010402}, {0x06010402}, {0x06030202},	/* 29 */
+  {0x06030202}, {0x06020302}, {0x06020302}, {0x07000401}, {0x07030001},	/* 34 */
+  {0x06000301}, {0x06000301}, {0x05030102}, {0x05030102}, {0x05030102},	/* 39 */
+  {0x05030102}, {0x05010302}, {0x05010302}, {0x05010302}, {0x05010302},	/* 44 */
+  {0x05020202}, {0x05020202}, {0x05020202}, {0x05020202}, {0x04020102},	/* 49 */
+  {0x04020102}, {0x04020102}, {0x04020102}, {0x04020102}, {0x04020102},	/* 54 */
+  {0x04020102}, {0x04020102}, {0x04010202}, {0x04010202}, {0x04010202},	/* 59 */
+  {0x04010202}, {0x04010202}, {0x04010202}, {0x04010202}, {0x04010202},	/* 64 */
+  {0x05020001}, {0x05020001}, {0x05020001}, {0x05020001}, {0x05000201},	/* 69 */
+  {0x05000201}, {0x05000201}, {0x05000201}, {0x04000000}, {0x04000000},	/* 74 */
+  {0x04000000}, {0x04000000}, {0x04000000}, {0x04000000}, {0x04000000},	/* 79 */
+  {0x04000000}, {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102},	/* 84 */
+  {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102},	/* 89 */
+  {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102},	/* 94 */
+  {0x03010102}, {0x03010102}, {0x03010001}, {0x03010001}, {0x03010001},	/* 99 */
+  {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001},	/* 104 */
+  {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001}, {0x03010001},	/* 109 */
+  {0x03010001}, {0x03010001}, {0x03010001}, {0x03000101}, {0x03000101},	/* 114 */
+  {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101},	/* 119 */
+  {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101},	/* 124 */
+  {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0xFF000003},	/* 129 */
+  {0x03070702}, {0x03070602}, {0x02060702}, {0x02060702}, {0x02070502},	/* 134 */
+  {0x02070502}, {0x02050702}, {0x02050702}, {0xFF000002}, {0x02060602},	/* 139 */
+  {0x02070402}, {0x02040702}, {0x02050602}, {0xFF000001}, {0x01060502},	/* 144 */
+  {0x01070302}, {0xFF000002}, {0x02030702}, {0x02050502}, {0x01070202},	/* 149 */
+  {0x01070202}, {0xFF000001}, {0x01020702}, {0x01060402}, {0xFF000001},	/* 154 */
+  {0x01040602}, {0x01070102}, {0xFF000002}, {0x01010702}, {0x01010702},	/* 159 */
+  {0x02070001}, {0x02000701}, {0xFF000001}, {0x01060302}, {0x01030602},	/* 164 */
+  {0xFF000001}, {0x01050402}, {0x01040502}, {0xFF000002}, {0x01040402},	/* 169 */
+  {0x01040402}, {0x02060001}, {0x02050001}, {0xFF000001}, {0x01060102},	/* 174 */
+  {0x01000601}, {0xFF000001}, {0x01050302}, {0x01030502}, {0xFF000001},	/* 179 */
+  {0x01050202}, {0x01020502}, {0xFF000001}, {0x01000501}, {0x01040001}, /* 184 */
+};
+
+/* max table bits  7 */
+
+/* TABLE 13  256 entries  maxbits 19  linbits  0 */
+static const HUFF_ELEMENT huff_table_13[] =
+{
+  {0xFF000006}, {0x00000041}, {0x00000082}, {0x000000C3}, {0x000000E4},	/*  4 */
+  {0x00000105}, {0x00000116}, {0x0000011F}, {0x00000130}, {0x00000139},	/*  9 */
+  {0x0000013E}, {0x00000143}, {0x00000146}, {0x06020102}, {0x06010202},	/* 14 */
+  {0x06020001}, {0x06000201}, {0x04010102}, {0x04010102}, {0x04010102},	/* 19 */
+  {0x04010102}, {0x04010001}, {0x04010001}, {0x04010001}, {0x04010001},	/* 24 */
+  {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101},	/* 29 */
+  {0x03000101}, {0x03000101}, {0x03000101}, {0x01000000}, {0x01000000},	/* 34 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 39 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 44 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 49 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 54 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 59 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 64 */
+  {0xFF000006}, {0x00000108}, {0x00000111}, {0x0000011A}, {0x00000123},	/* 69 */
+  {0x0000012C}, {0x00000131}, {0x00000136}, {0x0000013F}, {0x00000144},	/* 74 */
+  {0x00000147}, {0x0000014C}, {0x00000151}, {0x00000156}, {0x0000015B},	/* 79 */
+  {0x060F0102}, {0x06010F02}, {0x06000F01}, {0x00000160}, {0x00000163},	/* 84 */
+  {0x00000166}, {0x06020E02}, {0x00000169}, {0x060E0102}, {0x06010E02},	/* 89 */
+  {0x0000016C}, {0x0000016F}, {0x00000172}, {0x00000175}, {0x00000178},	/* 94 */
+  {0x0000017B}, {0x06060C02}, {0x060D0302}, {0x0000017E}, {0x060D0202},	/* 99 */
+  {0x06020D02}, {0x060D0102}, {0x06070B02}, {0x00000181}, {0x00000184},	/* 104 */
+  {0x06030C02}, {0x00000187}, {0x060B0402}, {0x05010D02}, {0x05010D02},	/* 109 */
+  {0x060D0001}, {0x06000D01}, {0x060A0802}, {0x06080A02}, {0x060C0402},	/* 114 */
+  {0x06040C02}, {0x060B0602}, {0x06060B02}, {0x050C0302}, {0x050C0302},	/* 119 */
+  {0x050C0202}, {0x050C0202}, {0x05020C02}, {0x05020C02}, {0x050B0502},	/* 124 */
+  {0x050B0502}, {0x06050B02}, {0x06090802}, {0x050C0102}, {0x050C0102},	/* 129 */
+  {0xFF000006}, {0x05010C02}, {0x05010C02}, {0x06080902}, {0x060C0001},	/* 134 */
+  {0x05000C01}, {0x05000C01}, {0x06040B02}, {0x060A0602}, {0x06060A02},	/* 139 */
+  {0x06090702}, {0x050B0302}, {0x050B0302}, {0x05030B02}, {0x05030B02},	/* 144 */
+  {0x06080802}, {0x060A0502}, {0x050B0202}, {0x050B0202}, {0x06050A02},	/* 149 */
+  {0x06090602}, {0x05040A02}, {0x05040A02}, {0x06080702}, {0x06070802},	/* 154 */
+  {0x05040902}, {0x05040902}, {0x06070702}, {0x06060702}, {0x04020B02},	/* 159 */
+  {0x04020B02}, {0x04020B02}, {0x04020B02}, {0x040B0102}, {0x040B0102},	/* 164 */
+  {0x040B0102}, {0x040B0102}, {0x04010B02}, {0x04010B02}, {0x04010B02},	/* 169 */
+  {0x04010B02}, {0x050B0001}, {0x050B0001}, {0x05000B01}, {0x05000B01},	/* 174 */
+  {0x05060902}, {0x05060902}, {0x050A0402}, {0x050A0402}, {0x050A0302},	/* 179 */
+  {0x050A0302}, {0x05030A02}, {0x05030A02}, {0x05090502}, {0x05090502},	/* 184 */
+  {0x05050902}, {0x05050902}, {0x040A0202}, {0x040A0202}, {0x040A0202},	/* 189 */
+  {0x040A0202}, {0x04020A02}, {0x04020A02}, {0x04020A02}, {0x04020A02},	/* 194 */
+  {0xFF000005}, {0x040A0102}, {0x040A0102}, {0x04010A02}, {0x04010A02},	/* 199 */
+  {0x050A0001}, {0x05080602}, {0x04000A01}, {0x04000A01}, {0x05060802},	/* 204 */
+  {0x05090402}, {0x04030902}, {0x04030902}, {0x05090302}, {0x05080502},	/* 209 */
+  {0x05050802}, {0x05070602}, {0x04090202}, {0x04090202}, {0x04020902},	/* 214 */
+  {0x04020902}, {0x05070502}, {0x05050702}, {0x04080302}, {0x04080302},	/* 219 */
+  {0x04030802}, {0x04030802}, {0x05060602}, {0x05070402}, {0x05040702},	/* 224 */
+  {0x05060502}, {0x05050602}, {0x05030702}, {0xFF000005}, {0x03090102},	/* 229 */
+  {0x03090102}, {0x03090102}, {0x03090102}, {0x03010902}, {0x03010902},	/* 234 */
+  {0x03010902}, {0x03010902}, {0x04090001}, {0x04090001}, {0x04000901},	/* 239 */
+  {0x04000901}, {0x04080402}, {0x04080402}, {0x04040802}, {0x04040802},	/* 244 */
+  {0x04020702}, {0x04020702}, {0x05060402}, {0x05040602}, {0x03080202},	/* 249 */
+  {0x03080202}, {0x03080202}, {0x03080202}, {0x03020802}, {0x03020802},	/* 254 */
+  {0x03020802}, {0x03020802}, {0x03080102}, {0x03080102}, {0x03080102},	/* 259 */
+  {0x03080102}, {0xFF000004}, {0x04070302}, {0x04070202}, {0x03070102},	/* 264 */
+  {0x03070102}, {0x03010702}, {0x03010702}, {0x04050502}, {0x04070001},	/* 269 */
+  {0x04000701}, {0x04060302}, {0x04030602}, {0x04050402}, {0x04040502},	/* 274 */
+  {0x04060202}, {0x04020602}, {0x04050302}, {0xFF000003}, {0x02010802},	/* 279 */
+  {0x02010802}, {0x03080001}, {0x03000801}, {0x03060102}, {0x03010602},	/* 284 */
+  {0x03060001}, {0x03000601}, {0xFF000004}, {0x04030502}, {0x04040402},	/* 289 */
+  {0x03050202}, {0x03050202}, {0x03020502}, {0x03020502}, {0x03050001},	/* 294 */
+  {0x03050001}, {0x02050102}, {0x02050102}, {0x02050102}, {0x02050102},	/* 299 */
+  {0x02010502}, {0x02010502}, {0x02010502}, {0x02010502}, {0xFF000003},	/* 304 */
+  {0x03040302}, {0x03030402}, {0x03000501}, {0x03040202}, {0x03020402},	/* 309 */
+  {0x03030302}, {0x02040102}, {0x02040102}, {0xFF000002}, {0x01010402},	/* 314 */
+  {0x01010402}, {0x02040001}, {0x02000401}, {0xFF000002}, {0x02030202},	/* 319 */
+  {0x02020302}, {0x01030102}, {0x01030102}, {0xFF000001}, {0x01010302},	/* 324 */
+  {0x01030001}, {0xFF000001}, {0x01000301}, {0x01020202}, {0xFF000003},	/* 329 */
+  {0x00000082}, {0x0000008B}, {0x0000008E}, {0x00000091}, {0x00000094},	/* 334 */
+  {0x00000097}, {0x030C0E02}, {0x030D0D02}, {0xFF000003}, {0x00000093},	/* 339 */
+  {0x030E0B02}, {0x030B0E02}, {0x030F0902}, {0x03090F02}, {0x030A0E02},	/* 344 */
+  {0x030D0B02}, {0x030B0D02}, {0xFF000003}, {0x030F0802}, {0x03080F02},	/* 349 */
+  {0x030C0C02}, {0x0000008D}, {0x030E0802}, {0x00000090}, {0x02070F02},	/* 354 */
+  {0x02070F02}, {0xFF000003}, {0x020A0D02}, {0x020A0D02}, {0x030D0A02},	/* 359 */
+  {0x030C0B02}, {0x030B0C02}, {0x03060F02}, {0x020F0602}, {0x020F0602},	/* 364 */
+  {0xFF000002}, {0x02080E02}, {0x020F0502}, {0x020D0902}, {0x02090D02},	/* 369 */
+  {0xFF000002}, {0x02050F02}, {0x02070E02}, {0x020C0A02}, {0x020B0B02},	/* 374 */
+  {0xFF000003}, {0x020F0402}, {0x020F0402}, {0x02040F02}, {0x02040F02},	/* 379 */
+  {0x030A0C02}, {0x03060E02}, {0x02030F02}, {0x02030F02}, {0xFF000002},	/* 384 */
+  {0x010F0302}, {0x010F0302}, {0x020D0802}, {0x02080D02}, {0xFF000001},	/* 389 */
+  {0x010F0202}, {0x01020F02}, {0xFF000002}, {0x020E0602}, {0x020C0902},	/* 394 */
+  {0x010F0001}, {0x010F0001}, {0xFF000002}, {0x02090C02}, {0x020E0502},	/* 399 */
+  {0x010B0A02}, {0x010B0A02}, {0xFF000002}, {0x020D0702}, {0x02070D02},	/* 404 */
+  {0x010E0402}, {0x010E0402}, {0xFF000002}, {0x02080C02}, {0x02060D02},	/* 409 */
+  {0x010E0302}, {0x010E0302}, {0xFF000002}, {0x01090B02}, {0x01090B02},	/* 414 */
+  {0x020B0902}, {0x020A0A02}, {0xFF000001}, {0x010A0B02}, {0x01050E02},	/* 419 */
+  {0xFF000001}, {0x01040E02}, {0x010C0802}, {0xFF000001}, {0x010D0602},	/* 424 */
+  {0x01030E02}, {0xFF000001}, {0x010E0202}, {0x010E0001}, {0xFF000001},	/* 429 */
+  {0x01000E01}, {0x010D0502}, {0xFF000001}, {0x01050D02}, {0x010C0702},	/* 434 */
+  {0xFF000001}, {0x01070C02}, {0x010D0402}, {0xFF000001}, {0x010B0802},	/* 439 */
+  {0x01080B02}, {0xFF000001}, {0x01040D02}, {0x010A0902}, {0xFF000001},	/* 444 */
+  {0x01090A02}, {0x010C0602}, {0xFF000001}, {0x01030D02}, {0x010B0702},	/* 449 */
+  {0xFF000001}, {0x010C0502}, {0x01050C02}, {0xFF000001}, {0x01090902},	/* 454 */
+  {0x010A0702}, {0xFF000001}, {0x01070A02}, {0x01070902}, {0xFF000003},	/* 459 */
+  {0x00000023}, {0x030D0F02}, {0x020D0E02}, {0x020D0E02}, {0x010F0F02},	/* 464 */
+  {0x010F0F02}, {0x010F0F02}, {0x010F0F02}, {0xFF000001}, {0x010F0E02},	/* 469 */
+  {0x010F0D02}, {0xFF000001}, {0x010E0E02}, {0x010F0C02}, {0xFF000001},	/* 474 */
+  {0x010E0D02}, {0x010F0B02}, {0xFF000001}, {0x010B0F02}, {0x010E0C02},	/* 479 */
+  {0xFF000002}, {0x010C0D02}, {0x010C0D02}, {0x020F0A02}, {0x02090E02},	/* 484 */
+  {0xFF000001}, {0x010A0F02}, {0x010D0C02}, {0xFF000001}, {0x010E0A02},	/* 489 */
+  {0x010E0902}, {0xFF000001}, {0x010F0702}, {0x010E0702}, {0xFF000001},	/* 494 */
+  {0x010E0F02}, {0x010C0F02},
+};
+
+/* max table bits  6 */
+/* NO XING TABLE 14 */
+
+/* TABLE 15  256 entries  maxbits 13  linbits  0 */
+static const HUFF_ELEMENT huff_table_15[] =
+{
+  {0xFF000008}, {0x00000101}, {0x00000122}, {0x00000143}, {0x00000154},	/*  4 */
+  {0x00000165}, {0x00000176}, {0x0000017F}, {0x00000188}, {0x00000199},	/*  9 */
+  {0x000001A2}, {0x000001AB}, {0x000001B4}, {0x000001BD}, {0x000001C2},	/* 14 */
+  {0x000001CB}, {0x000001D4}, {0x000001D9}, {0x000001DE}, {0x000001E3},	/* 19 */
+  {0x000001E8}, {0x000001ED}, {0x000001F2}, {0x000001F7}, {0x000001FC},	/* 24 */
+  {0x00000201}, {0x00000204}, {0x00000207}, {0x0000020A}, {0x0000020F},	/* 29 */
+  {0x00000212}, {0x00000215}, {0x0000021A}, {0x0000021D}, {0x00000220},	/* 34 */
+  {0x08010902}, {0x00000223}, {0x00000226}, {0x00000229}, {0x0000022C},	/* 39 */
+  {0x0000022F}, {0x08080202}, {0x08020802}, {0x08080102}, {0x08010802},	/* 44 */
+  {0x00000232}, {0x00000235}, {0x00000238}, {0x0000023B}, {0x08070202},	/* 49 */
+  {0x08020702}, {0x08040602}, {0x08070102}, {0x08050502}, {0x08010702},	/* 54 */
+  {0x0000023E}, {0x08060302}, {0x08030602}, {0x08050402}, {0x08040502},	/* 59 */
+  {0x08060202}, {0x08020602}, {0x08060102}, {0x00000241}, {0x08050302},	/* 64 */
+  {0x07010602}, {0x07010602}, {0x08030502}, {0x08040402}, {0x07050202},	/* 69 */
+  {0x07050202}, {0x07020502}, {0x07020502}, {0x07050102}, {0x07050102},	/* 74 */
+  {0x07010502}, {0x07010502}, {0x08050001}, {0x08000501}, {0x07040302},	/* 79 */
+  {0x07040302}, {0x07030402}, {0x07030402}, {0x07040202}, {0x07040202},	/* 84 */
+  {0x07020402}, {0x07020402}, {0x07030302}, {0x07030302}, {0x06010402},	/* 89 */
+  {0x06010402}, {0x06010402}, {0x06010402}, {0x07040102}, {0x07040102},	/* 94 */
+  {0x07040001}, {0x07040001}, {0x06030202}, {0x06030202}, {0x06030202},	/* 99 */
+  {0x06030202}, {0x06020302}, {0x06020302}, {0x06020302}, {0x06020302},	/* 104 */
+  {0x07000401}, {0x07000401}, {0x07030001}, {0x07030001}, {0x06030102},	/* 109 */
+  {0x06030102}, {0x06030102}, {0x06030102}, {0x06010302}, {0x06010302},	/* 114 */
+  {0x06010302}, {0x06010302}, {0x06000301}, {0x06000301}, {0x06000301},	/* 119 */
+  {0x06000301}, {0x05020202}, {0x05020202}, {0x05020202}, {0x05020202},	/* 124 */
+  {0x05020202}, {0x05020202}, {0x05020202}, {0x05020202}, {0x05020102},	/* 129 */
+  {0x05020102}, {0x05020102}, {0x05020102}, {0x05020102}, {0x05020102},	/* 134 */
+  {0x05020102}, {0x05020102}, {0x05010202}, {0x05010202}, {0x05010202},	/* 139 */
+  {0x05010202}, {0x05010202}, {0x05010202}, {0x05010202}, {0x05010202},	/* 144 */
+  {0x05020001}, {0x05020001}, {0x05020001}, {0x05020001}, {0x05020001},	/* 149 */
+  {0x05020001}, {0x05020001}, {0x05020001}, {0x05000201}, {0x05000201},	/* 154 */
+  {0x05000201}, {0x05000201}, {0x05000201}, {0x05000201}, {0x05000201},	/* 159 */
+  {0x05000201}, {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102},	/* 164 */
+  {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102},	/* 169 */
+  {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102},	/* 174 */
+  {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102},	/* 179 */
+  {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102},	/* 184 */
+  {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102}, {0x03010102},	/* 189 */
+  {0x03010102}, {0x03010102}, {0x03010102}, {0x04010001}, {0x04010001},	/* 194 */
+  {0x04010001}, {0x04010001}, {0x04010001}, {0x04010001}, {0x04010001},	/* 199 */
+  {0x04010001}, {0x04010001}, {0x04010001}, {0x04010001}, {0x04010001},	/* 204 */
+  {0x04010001}, {0x04010001}, {0x04010001}, {0x04010001}, {0x04000101},	/* 209 */
+  {0x04000101}, {0x04000101}, {0x04000101}, {0x04000101}, {0x04000101},	/* 214 */
+  {0x04000101}, {0x04000101}, {0x04000101}, {0x04000101}, {0x04000101},	/* 219 */
+  {0x04000101}, {0x04000101}, {0x04000101}, {0x04000101}, {0x04000101},	/* 224 */
+  {0x03000000}, {0x03000000}, {0x03000000}, {0x03000000}, {0x03000000},	/* 229 */
+  {0x03000000}, {0x03000000}, {0x03000000}, {0x03000000}, {0x03000000},	/* 234 */
+  {0x03000000}, {0x03000000}, {0x03000000}, {0x03000000}, {0x03000000},	/* 239 */
+  {0x03000000}, {0x03000000}, {0x03000000}, {0x03000000}, {0x03000000},	/* 244 */
+  {0x03000000}, {0x03000000}, {0x03000000}, {0x03000000}, {0x03000000},	/* 249 */
+  {0x03000000}, {0x03000000}, {0x03000000}, {0x03000000}, {0x03000000},	/* 254 */
+  {0x03000000}, {0x03000000}, {0xFF000005}, {0x050F0F02}, {0x050F0E02},	/* 259 */
+  {0x050E0F02}, {0x050F0D02}, {0x040E0E02}, {0x040E0E02}, {0x050D0F02},	/* 264 */
+  {0x050F0C02}, {0x050C0F02}, {0x050E0D02}, {0x050D0E02}, {0x050F0B02},	/* 269 */
+  {0x040B0F02}, {0x040B0F02}, {0x050E0C02}, {0x050C0E02}, {0x040D0D02},	/* 274 */
+  {0x040D0D02}, {0x040F0A02}, {0x040F0A02}, {0x040A0F02}, {0x040A0F02},	/* 279 */
+  {0x040E0B02}, {0x040E0B02}, {0x040B0E02}, {0x040B0E02}, {0x040D0C02},	/* 284 */
+  {0x040D0C02}, {0x040C0D02}, {0x040C0D02}, {0x040F0902}, {0x040F0902},	/* 289 */
+  {0xFF000005}, {0x04090F02}, {0x04090F02}, {0x040A0E02}, {0x040A0E02},	/* 294 */
+  {0x040D0B02}, {0x040D0B02}, {0x040B0D02}, {0x040B0D02}, {0x040F0802},	/* 299 */
+  {0x040F0802}, {0x04080F02}, {0x04080F02}, {0x040C0C02}, {0x040C0C02},	/* 304 */
+  {0x040E0902}, {0x040E0902}, {0x04090E02}, {0x04090E02}, {0x040F0702},	/* 309 */
+  {0x040F0702}, {0x04070F02}, {0x04070F02}, {0x040D0A02}, {0x040D0A02},	/* 314 */
+  {0x040A0D02}, {0x040A0D02}, {0x040C0B02}, {0x040C0B02}, {0x040F0602},	/* 319 */
+  {0x040F0602}, {0x050E0A02}, {0x050F0001}, {0xFF000004}, {0x030B0C02},	/* 324 */
+  {0x030B0C02}, {0x03060F02}, {0x03060F02}, {0x040E0802}, {0x04080E02},	/* 329 */
+  {0x040F0502}, {0x040D0902}, {0x03050F02}, {0x03050F02}, {0x030E0702},	/* 334 */
+  {0x030E0702}, {0x03070E02}, {0x03070E02}, {0x030C0A02}, {0x030C0A02},	/* 339 */
+  {0xFF000004}, {0x030A0C02}, {0x030A0C02}, {0x030B0B02}, {0x030B0B02},	/* 344 */
+  {0x04090D02}, {0x040D0802}, {0x030F0402}, {0x030F0402}, {0x03040F02},	/* 349 */
+  {0x03040F02}, {0x030F0302}, {0x030F0302}, {0x03030F02}, {0x03030F02},	/* 354 */
+  {0x03080D02}, {0x03080D02}, {0xFF000004}, {0x03060E02}, {0x03060E02},	/* 359 */
+  {0x030F0202}, {0x030F0202}, {0x03020F02}, {0x03020F02}, {0x040E0602},	/* 364 */
+  {0x04000F01}, {0x030F0102}, {0x030F0102}, {0x03010F02}, {0x03010F02},	/* 369 */
+  {0x030C0902}, {0x030C0902}, {0x03090C02}, {0x03090C02}, {0xFF000003},	/* 374 */
+  {0x030E0502}, {0x030B0A02}, {0x030A0B02}, {0x03050E02}, {0x030D0702},	/* 379 */
+  {0x03070D02}, {0x030E0402}, {0x03040E02}, {0xFF000003}, {0x030C0802},	/* 384 */
+  {0x03080C02}, {0x030E0302}, {0x030D0602}, {0x03060D02}, {0x03030E02},	/* 389 */
+  {0x030B0902}, {0x03090B02}, {0xFF000004}, {0x030E0202}, {0x030E0202},	/* 394 */
+  {0x030A0A02}, {0x030A0A02}, {0x03020E02}, {0x03020E02}, {0x030E0102},	/* 399 */
+  {0x030E0102}, {0x03010E02}, {0x03010E02}, {0x040E0001}, {0x04000E01},	/* 404 */
+  {0x030D0502}, {0x030D0502}, {0x03050D02}, {0x03050D02}, {0xFF000003},	/* 409 */
+  {0x030C0702}, {0x03070C02}, {0x030D0402}, {0x030B0802}, {0x02040D02},	/* 414 */
+  {0x02040D02}, {0x03080B02}, {0x030A0902}, {0xFF000003}, {0x03090A02},	/* 419 */
+  {0x030C0602}, {0x03060C02}, {0x030D0302}, {0x02030D02}, {0x02030D02},	/* 424 */
+  {0x02020D02}, {0x02020D02}, {0xFF000003}, {0x030D0202}, {0x030D0001},	/* 429 */
+  {0x020D0102}, {0x020D0102}, {0x020B0702}, {0x020B0702}, {0x02070B02},	/* 434 */
+  {0x02070B02}, {0xFF000003}, {0x02010D02}, {0x02010D02}, {0x030C0502},	/* 439 */
+  {0x03000D01}, {0x02050C02}, {0x02050C02}, {0x020A0802}, {0x020A0802},	/* 444 */
+  {0xFF000002}, {0x02080A02}, {0x020C0402}, {0x02040C02}, {0x020B0602},	/* 449 */
+  {0xFF000003}, {0x02060B02}, {0x02060B02}, {0x03090902}, {0x030C0001},	/* 454 */
+  {0x020C0302}, {0x020C0302}, {0x02030C02}, {0x02030C02}, {0xFF000003},	/* 459 */
+  {0x020A0702}, {0x020A0702}, {0x02070A02}, {0x02070A02}, {0x02060A02},	/* 464 */
+  {0x02060A02}, {0x03000C01}, {0x030B0001}, {0xFF000002}, {0x01020C02},	/* 469 */
+  {0x01020C02}, {0x020C0202}, {0x020B0502}, {0xFF000002}, {0x02050B02},	/* 474 */
+  {0x020C0102}, {0x02090802}, {0x02080902}, {0xFF000002}, {0x02010C02},	/* 479 */
+  {0x020B0402}, {0x02040B02}, {0x020A0602}, {0xFF000002}, {0x020B0302},	/* 484 */
+  {0x02090702}, {0x01030B02}, {0x01030B02}, {0xFF000002}, {0x02070902},	/* 489 */
+  {0x02080802}, {0x020B0202}, {0x020A0502}, {0xFF000002}, {0x01020B02},	/* 494 */
+  {0x01020B02}, {0x02050A02}, {0x020B0102}, {0xFF000002}, {0x01010B02},	/* 499 */
+  {0x01010B02}, {0x02000B01}, {0x02090602}, {0xFF000002}, {0x02060902},	/* 504 */
+  {0x020A0402}, {0x02040A02}, {0x02080702}, {0xFF000002}, {0x02070802},	/* 509 */
+  {0x020A0302}, {0x01030A02}, {0x01030A02}, {0xFF000001}, {0x01090502},	/* 514 */
+  {0x01050902}, {0xFF000001}, {0x010A0202}, {0x01020A02}, {0xFF000001},	/* 519 */
+  {0x010A0102}, {0x01010A02}, {0xFF000002}, {0x020A0001}, {0x02000A01},	/* 524 */
+  {0x01080602}, {0x01080602}, {0xFF000001}, {0x01060802}, {0x01090402},	/* 529 */
+  {0xFF000001}, {0x01040902}, {0x01090302}, {0xFF000002}, {0x01030902},	/* 534 */
+  {0x01030902}, {0x02070702}, {0x02090001}, {0xFF000001}, {0x01080502},	/* 539 */
+  {0x01050802}, {0xFF000001}, {0x01090202}, {0x01070602}, {0xFF000001},	/* 544 */
+  {0x01060702}, {0x01020902}, {0xFF000001}, {0x01090102}, {0x01000901},	/* 549 */
+  {0xFF000001}, {0x01080402}, {0x01040802}, {0xFF000001}, {0x01070502},	/* 554 */
+  {0x01050702}, {0xFF000001}, {0x01080302}, {0x01030802}, {0xFF000001},	/* 559 */
+  {0x01060602}, {0x01070402}, {0xFF000001}, {0x01040702}, {0x01080001},	/* 564 */
+  {0xFF000001}, {0x01000801}, {0x01060502}, {0xFF000001}, {0x01050602},	/* 569 */
+  {0x01070302}, {0xFF000001}, {0x01030702}, {0x01060402}, {0xFF000001},	/* 574 */
+  {0x01070001}, {0x01000701}, {0xFF000001}, {0x01060001}, {0x01000601}, /* 579 */
+};
+
+/* max table bits  8 */
+
+/* TABLE 16  256 entries  maxbits 17  linbits  0 */
+static const HUFF_ELEMENT huff_table_16[] =
+{
+  {0xFF000008}, {0x00000101}, {0x0000010A}, {0x00000113}, {0x080F0F02},	/*  4 */
+  {0x00000118}, {0x0000011D}, {0x00000120}, {0x08020F02}, {0x00000131},	/*  9 */
+  {0x080F0102}, {0x08010F02}, {0x00000134}, {0x00000145}, {0x00000156},	/* 14 */
+  {0x00000167}, {0x00000178}, {0x00000189}, {0x0000019A}, {0x000001A3},	/* 19 */
+  {0x000001AC}, {0x000001B5}, {0x000001BE}, {0x000001C7}, {0x000001D0},	/* 24 */
+  {0x000001D9}, {0x000001DE}, {0x000001E3}, {0x000001E6}, {0x000001EB},	/* 29 */
+  {0x000001F0}, {0x08010502}, {0x000001F3}, {0x000001F6}, {0x000001F9},	/* 34 */
+  {0x000001FC}, {0x08040102}, {0x08010402}, {0x000001FF}, {0x08030202},	/* 39 */
+  {0x08020302}, {0x07030102}, {0x07030102}, {0x07010302}, {0x07010302},	/* 44 */
+  {0x08030001}, {0x08000301}, {0x07020202}, {0x07020202}, {0x06020102},	/* 49 */
+  {0x06020102}, {0x06020102}, {0x06020102}, {0x06010202}, {0x06010202},	/* 54 */
+  {0x06010202}, {0x06010202}, {0x06020001}, {0x06020001}, {0x06020001},	/* 59 */
+  {0x06020001}, {0x06000201}, {0x06000201}, {0x06000201}, {0x06000201},	/* 64 */
+  {0x04010102}, {0x04010102}, {0x04010102}, {0x04010102}, {0x04010102},	/* 69 */
+  {0x04010102}, {0x04010102}, {0x04010102}, {0x04010102}, {0x04010102},	/* 74 */
+  {0x04010102}, {0x04010102}, {0x04010102}, {0x04010102}, {0x04010102},	/* 79 */
+  {0x04010102}, {0x04010001}, {0x04010001}, {0x04010001}, {0x04010001},	/* 84 */
+  {0x04010001}, {0x04010001}, {0x04010001}, {0x04010001}, {0x04010001},	/* 89 */
+  {0x04010001}, {0x04010001}, {0x04010001}, {0x04010001}, {0x04010001},	/* 94 */
+  {0x04010001}, {0x04010001}, {0x03000101}, {0x03000101}, {0x03000101},	/* 99 */
+  {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101},	/* 104 */
+  {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101},	/* 109 */
+  {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101},	/* 114 */
+  {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101},	/* 119 */
+  {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101},	/* 124 */
+  {0x03000101}, {0x03000101}, {0x03000101}, {0x03000101}, {0x01000000},	/* 129 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 134 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 139 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 144 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 149 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 154 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 159 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 164 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 169 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 174 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 179 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 184 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 189 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 194 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 199 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 204 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 209 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 214 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 219 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 224 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 229 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 234 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 239 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 244 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 249 */
+  {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000}, {0x01000000},	/* 254 */
+  {0x01000000}, {0x01000000}, {0xFF000003}, {0x030F0E02}, {0x030E0F02},	/* 259 */
+  {0x030F0D02}, {0x030D0F02}, {0x030F0C02}, {0x030C0F02}, {0x030F0B02},	/* 264 */
+  {0x030B0F02}, {0xFF000003}, {0x020F0A02}, {0x020F0A02}, {0x030A0F02},	/* 269 */
+  {0x030F0902}, {0x03090F02}, {0x03080F02}, {0x020F0802}, {0x020F0802},	/* 274 */
+  {0xFF000002}, {0x020F0702}, {0x02070F02}, {0x020F0602}, {0x02060F02},	/* 279 */
+  {0xFF000002}, {0x020F0502}, {0x02050F02}, {0x010F0402}, {0x010F0402},	/* 284 */
+  {0xFF000001}, {0x01040F02}, {0x01030F02}, {0xFF000004}, {0x01000F01},	/* 289 */
+  {0x01000F01}, {0x01000F01}, {0x01000F01}, {0x01000F01}, {0x01000F01},	/* 294 */
+  {0x01000F01}, {0x01000F01}, {0x020F0302}, {0x020F0302}, {0x020F0302},	/* 299 */
+  {0x020F0302}, {0x000000E2}, {0x000000F3}, {0x000000FC}, {0x00000105},	/* 304 */
+  {0xFF000001}, {0x010F0202}, {0x010F0001}, {0xFF000004}, {0x000000FA},	/* 309 */
+  {0x000000FF}, {0x00000104}, {0x00000109}, {0x0000010C}, {0x00000111},	/* 314 */
+  {0x00000116}, {0x00000119}, {0x0000011E}, {0x00000123}, {0x00000128},	/* 319 */
+  {0x04030E02}, {0x0000012D}, {0x00000130}, {0x00000133}, {0x00000136},	/* 324 */
+  {0xFF000004}, {0x00000128}, {0x0000012B}, {0x0000012E}, {0x040D0001},	/* 329 */
+  {0x00000131}, {0x00000134}, {0x00000137}, {0x040C0302}, {0x0000013A},	/* 334 */
+  {0x040C0102}, {0x04000C01}, {0x0000013D}, {0x03020E02}, {0x03020E02},	/* 339 */
+  {0x040E0202}, {0x040E0102}, {0xFF000004}, {0x04030D02}, {0x040D0202},	/* 344 */
+  {0x04020D02}, {0x04010D02}, {0x040B0302}, {0x0000012F}, {0x030D0102},	/* 349 */
+  {0x030D0102}, {0x04040C02}, {0x040B0602}, {0x04030C02}, {0x04070A02},	/* 354 */
+  {0x030C0202}, {0x030C0202}, {0x04020C02}, {0x04050B02}, {0xFF000004},	/* 359 */
+  {0x04010C02}, {0x040C0001}, {0x040B0402}, {0x04040B02}, {0x040A0602},	/* 364 */
+  {0x04060A02}, {0x03030B02}, {0x03030B02}, {0x040A0502}, {0x04050A02},	/* 369 */
+  {0x030B0202}, {0x030B0202}, {0x03020B02}, {0x03020B02}, {0x030B0102},	/* 374 */
+  {0x030B0102}, {0xFF000004}, {0x03010B02}, {0x03010B02}, {0x040B0001},	/* 379 */
+  {0x04000B01}, {0x04090602}, {0x04060902}, {0x040A0402}, {0x04040A02},	/* 384 */
+  {0x04080702}, {0x04070802}, {0x03030A02}, {0x03030A02}, {0x040A0302},	/* 389 */
+  {0x04090502}, {0x030A0202}, {0x030A0202}, {0xFF000004}, {0x04050902},	/* 394 */
+  {0x04080602}, {0x03010A02}, {0x03010A02}, {0x04060802}, {0x04070702},	/* 399 */
+  {0x03040902}, {0x03040902}, {0x04090402}, {0x04070502}, {0x03070602},	/* 404 */
+  {0x03070602}, {0x02020A02}, {0x02020A02}, {0x02020A02}, {0x02020A02},	/* 409 */
+  {0xFF000003}, {0x020A0102}, {0x020A0102}, {0x030A0001}, {0x03000A01},	/* 414 */
+  {0x03090302}, {0x03030902}, {0x03080502}, {0x03050802}, {0xFF000003},	/* 419 */
+  {0x02090202}, {0x02090202}, {0x02020902}, {0x02020902}, {0x03060702},	/* 424 */
+  {0x03090001}, {0x02090102}, {0x02090102}, {0xFF000003}, {0x02010902},	/* 429 */
+  {0x02010902}, {0x03000901}, {0x03080402}, {0x03040802}, {0x03050702},	/* 434 */
+  {0x03080302}, {0x03030802}, {0xFF000003}, {0x03060602}, {0x03080202},	/* 439 */
+  {0x02020802}, {0x02020802}, {0x03070402}, {0x03040702}, {0x02080102},	/* 444 */
+  {0x02080102}, {0xFF000003}, {0x02010802}, {0x02010802}, {0x02000801},	/* 449 */
+  {0x02000801}, {0x03080001}, {0x03060502}, {0x02070302}, {0x02070302},	/* 454 */
+  {0xFF000003}, {0x02030702}, {0x02030702}, {0x03050602}, {0x03060402},	/* 459 */
+  {0x02070202}, {0x02070202}, {0x02020702}, {0x02020702}, {0xFF000003},	/* 464 */
+  {0x03040602}, {0x03050502}, {0x02070001}, {0x02070001}, {0x01070102},	/* 469 */
+  {0x01070102}, {0x01070102}, {0x01070102}, {0xFF000002}, {0x01010702},	/* 474 */
+  {0x01010702}, {0x02000701}, {0x02060302}, {0xFF000002}, {0x02030602},	/* 479 */
+  {0x02050402}, {0x02040502}, {0x02060202}, {0xFF000001}, {0x01020602},	/* 484 */
+  {0x01060102}, {0xFF000002}, {0x01010602}, {0x01010602}, {0x02060001},	/* 489 */
+  {0x02000601}, {0xFF000002}, {0x01030502}, {0x01030502}, {0x02050302},	/* 494 */
+  {0x02040402}, {0xFF000001}, {0x01050202}, {0x01020502}, {0xFF000001},	/* 499 */
+  {0x01050102}, {0x01050001}, {0xFF000001}, {0x01040302}, {0x01030402},	/* 504 */
+  {0xFF000001}, {0x01000501}, {0x01040202}, {0xFF000001}, {0x01020402},	/* 509 */
+  {0x01030302}, {0xFF000001}, {0x01040001}, {0x01000401}, {0xFF000004},	/* 514 */
+  {0x040E0C02}, {0x00000086}, {0x030E0D02}, {0x030E0D02}, {0x03090E02},	/* 519 */
+  {0x03090E02}, {0x040A0E02}, {0x04090D02}, {0x020E0E02}, {0x020E0E02},	/* 524 */
+  {0x020E0E02}, {0x020E0E02}, {0x030D0E02}, {0x030D0E02}, {0x030B0E02},	/* 529 */
+  {0x030B0E02}, {0xFF000003}, {0x020E0B02}, {0x020E0B02}, {0x020D0C02},	/* 534 */
+  {0x020D0C02}, {0x030C0D02}, {0x030B0D02}, {0x020E0A02}, {0x020E0A02},	/* 539 */
+  {0xFF000003}, {0x020C0C02}, {0x020C0C02}, {0x030D0A02}, {0x030A0D02},	/* 544 */
+  {0x030E0702}, {0x030C0A02}, {0x020A0C02}, {0x020A0C02}, {0xFF000003},	/* 549 */
+  {0x03090C02}, {0x030D0702}, {0x020E0502}, {0x020E0502}, {0x010D0B02},	/* 554 */
+  {0x010D0B02}, {0x010D0B02}, {0x010D0B02}, {0xFF000002}, {0x010E0902},	/* 559 */
+  {0x010E0902}, {0x020C0B02}, {0x020B0C02}, {0xFF000002}, {0x020E0802},	/* 564 */
+  {0x02080E02}, {0x020D0902}, {0x02070E02}, {0xFF000002}, {0x020B0B02},	/* 569 */
+  {0x020D0802}, {0x02080D02}, {0x020E0602}, {0xFF000001}, {0x01060E02},	/* 574 */
+  {0x010C0902}, {0xFF000002}, {0x020B0A02}, {0x020A0B02}, {0x02050E02},	/* 579 */
+  {0x02070D02}, {0xFF000002}, {0x010E0402}, {0x010E0402}, {0x02040E02},	/* 584 */
+  {0x020C0802}, {0xFF000001}, {0x01080C02}, {0x010E0302}, {0xFF000002},	/* 589 */
+  {0x010D0602}, {0x010D0602}, {0x02060D02}, {0x020B0902}, {0xFF000002},	/* 594 */
+  {0x02090B02}, {0x020A0A02}, {0x01010E02}, {0x01010E02}, {0xFF000002},	/* 599 */
+  {0x01040D02}, {0x01040D02}, {0x02080B02}, {0x02090A02}, {0xFF000002},	/* 604 */
+  {0x010B0702}, {0x010B0702}, {0x02070B02}, {0x02000D01}, {0xFF000001},	/* 609 */
+  {0x010E0001}, {0x01000E01}, {0xFF000001}, {0x010D0502}, {0x01050D02},	/* 614 */
+  {0xFF000001}, {0x010C0702}, {0x01070C02}, {0xFF000001}, {0x010D0402},	/* 619 */
+  {0x010B0802}, {0xFF000001}, {0x010A0902}, {0x010C0602}, {0xFF000001},	/* 624 */
+  {0x01060C02}, {0x010D0302}, {0xFF000001}, {0x010C0502}, {0x01050C02},	/* 629 */
+  {0xFF000001}, {0x010A0802}, {0x01080A02}, {0xFF000001}, {0x01090902},	/* 634 */
+  {0x010C0402}, {0xFF000001}, {0x01060B02}, {0x010A0702}, {0xFF000001},	/* 639 */
+  {0x010B0502}, {0x01090802}, {0xFF000001}, {0x01080902}, {0x01090702},	/* 644 */
+  {0xFF000001}, {0x01070902}, {0x01080802}, {0xFF000001}, {0x010C0E02},	/* 649 */
+  {0x010D0D02},
+};
+
+/* max table bits  8 */
+/* NO XING TABLE 17 */
+/* NO XING TABLE 18 */
+/* NO XING TABLE 19 */
+/* NO XING TABLE 20 */
+/* NO XING TABLE 21 */
+/* NO XING TABLE 22 */
+/* NO XING TABLE 23 */
+
+/* TABLE 24  256 entries  maxbits 12  linbits  0 */
+static const HUFF_ELEMENT huff_table_24[] =
+{
+  {0xFF000009}, {0x080F0E02}, {0x080F0E02}, {0x080E0F02}, {0x080E0F02},	/*  4 */
+  {0x080F0D02}, {0x080F0D02}, {0x080D0F02}, {0x080D0F02}, {0x080F0C02},	/*  9 */
+  {0x080F0C02}, {0x080C0F02}, {0x080C0F02}, {0x080F0B02}, {0x080F0B02},	/* 14 */
+  {0x080B0F02}, {0x080B0F02}, {0x070A0F02}, {0x070A0F02}, {0x070A0F02},	/* 19 */
+  {0x070A0F02}, {0x080F0A02}, {0x080F0A02}, {0x080F0902}, {0x080F0902},	/* 24 */
+  {0x07090F02}, {0x07090F02}, {0x07090F02}, {0x07090F02}, {0x07080F02},	/* 29 */
+  {0x07080F02}, {0x07080F02}, {0x07080F02}, {0x080F0802}, {0x080F0802},	/* 34 */
+  {0x080F0702}, {0x080F0702}, {0x07070F02}, {0x07070F02}, {0x07070F02},	/* 39 */
+  {0x07070F02}, {0x070F0602}, {0x070F0602}, {0x070F0602}, {0x070F0602},	/* 44 */
+  {0x07060F02}, {0x07060F02}, {0x07060F02}, {0x07060F02}, {0x070F0502},	/* 49 */
+  {0x070F0502}, {0x070F0502}, {0x070F0502}, {0x07050F02}, {0x07050F02},	/* 54 */
+  {0x07050F02}, {0x07050F02}, {0x070F0402}, {0x070F0402}, {0x070F0402},	/* 59 */
+  {0x070F0402}, {0x07040F02}, {0x07040F02}, {0x07040F02}, {0x07040F02},	/* 64 */
+  {0x070F0302}, {0x070F0302}, {0x070F0302}, {0x070F0302}, {0x07030F02},	/* 69 */
+  {0x07030F02}, {0x07030F02}, {0x07030F02}, {0x070F0202}, {0x070F0202},	/* 74 */
+  {0x070F0202}, {0x070F0202}, {0x07020F02}, {0x07020F02}, {0x07020F02},	/* 79 */
+  {0x07020F02}, {0x07010F02}, {0x07010F02}, {0x07010F02}, {0x07010F02},	/* 84 */
+  {0x080F0102}, {0x080F0102}, {0x08000F01}, {0x08000F01}, {0x090F0001},	/* 89 */
+  {0x00000201}, {0x00000206}, {0x0000020B}, {0x00000210}, {0x00000215},	/* 94 */
+  {0x0000021A}, {0x0000021F}, {0x040F0F02}, {0x040F0F02}, {0x040F0F02},	/* 99 */
+  {0x040F0F02}, {0x040F0F02}, {0x040F0F02}, {0x040F0F02}, {0x040F0F02},	/* 104 */
+  {0x040F0F02}, {0x040F0F02}, {0x040F0F02}, {0x040F0F02}, {0x040F0F02},	/* 109 */
+  {0x040F0F02}, {0x040F0F02}, {0x040F0F02}, {0x040F0F02}, {0x040F0F02},	/* 114 */
+  {0x040F0F02}, {0x040F0F02}, {0x040F0F02}, {0x040F0F02}, {0x040F0F02},	/* 119 */
+  {0x040F0F02}, {0x040F0F02}, {0x040F0F02}, {0x040F0F02}, {0x040F0F02},	/* 124 */
+  {0x040F0F02}, {0x040F0F02}, {0x040F0F02}, {0x040F0F02}, {0x00000224},	/* 129 */
+  {0x00000229}, {0x00000232}, {0x00000237}, {0x0000023A}, {0x0000023F},	/* 134 */
+  {0x00000242}, {0x00000245}, {0x0000024A}, {0x0000024D}, {0x00000250},	/* 139 */
+  {0x00000253}, {0x00000256}, {0x00000259}, {0x0000025C}, {0x0000025F},	/* 144 */
+  {0x00000262}, {0x00000265}, {0x00000268}, {0x0000026B}, {0x0000026E},	/* 149 */
+  {0x00000271}, {0x00000274}, {0x00000277}, {0x0000027A}, {0x0000027D},	/* 154 */
+  {0x00000280}, {0x00000283}, {0x00000288}, {0x0000028B}, {0x0000028E},	/* 159 */
+  {0x00000291}, {0x00000294}, {0x00000297}, {0x0000029A}, {0x0000029F},	/* 164 */
+  {0x09040B02}, {0x000002A4}, {0x000002A7}, {0x000002AA}, {0x09030B02},	/* 169 */
+  {0x09080802}, {0x000002AF}, {0x09020B02}, {0x000002B2}, {0x000002B5},	/* 174 */
+  {0x09060902}, {0x09040A02}, {0x000002B8}, {0x09070802}, {0x090A0302},	/* 179 */
+  {0x09030A02}, {0x09090502}, {0x09050902}, {0x090A0202}, {0x09020A02},	/* 184 */
+  {0x09010A02}, {0x09080602}, {0x09060802}, {0x09070702}, {0x09090402},	/* 189 */
+  {0x09040902}, {0x09090302}, {0x09030902}, {0x09080502}, {0x09050802},	/* 194 */
+  {0x09090202}, {0x09070602}, {0x09060702}, {0x09020902}, {0x09090102},	/* 199 */
+  {0x09010902}, {0x09080402}, {0x09040802}, {0x09070502}, {0x09050702},	/* 204 */
+  {0x09080302}, {0x09030802}, {0x09060602}, {0x09080202}, {0x09020802},	/* 209 */
+  {0x09080102}, {0x09070402}, {0x09040702}, {0x09010802}, {0x000002BB},	/* 214 */
+  {0x09060502}, {0x09050602}, {0x09070102}, {0x000002BE}, {0x08030702},	/* 219 */
+  {0x08030702}, {0x09070302}, {0x09070202}, {0x08020702}, {0x08020702},	/* 224 */
+  {0x08060402}, {0x08060402}, {0x08040602}, {0x08040602}, {0x08050502},	/* 229 */
+  {0x08050502}, {0x08010702}, {0x08010702}, {0x08060302}, {0x08060302},	/* 234 */
+  {0x08030602}, {0x08030602}, {0x08050402}, {0x08050402}, {0x08040502},	/* 239 */
+  {0x08040502}, {0x08060202}, {0x08060202}, {0x08020602}, {0x08020602},	/* 244 */
+  {0x08060102}, {0x08060102}, {0x08010602}, {0x08010602}, {0x09060001},	/* 249 */
+  {0x09000601}, {0x08050302}, {0x08050302}, {0x08030502}, {0x08030502},	/* 254 */
+  {0x08040402}, {0x08040402}, {0x08050202}, {0x08050202}, {0x08020502},	/* 259 */
+  {0x08020502}, {0x08050102}, {0x08050102}, {0x09050001}, {0x09000501},	/* 264 */
+  {0x07010502}, {0x07010502}, {0x07010502}, {0x07010502}, {0x08040302},	/* 269 */
+  {0x08040302}, {0x08030402}, {0x08030402}, {0x07040202}, {0x07040202},	/* 274 */
+  {0x07040202}, {0x07040202}, {0x07020402}, {0x07020402}, {0x07020402},	/* 279 */
+  {0x07020402}, {0x07030302}, {0x07030302}, {0x07030302}, {0x07030302},	/* 284 */
+  {0x07040102}, {0x07040102}, {0x07040102}, {0x07040102}, {0x07010402},	/* 289 */
+  {0x07010402}, {0x07010402}, {0x07010402}, {0x08040001}, {0x08040001},	/* 294 */
+  {0x08000401}, {0x08000401}, {0x07030202}, {0x07030202}, {0x07030202},	/* 299 */
+  {0x07030202}, {0x07020302}, {0x07020302}, {0x07020302}, {0x07020302},	/* 304 */
+  {0x06030102}, {0x06030102}, {0x06030102}, {0x06030102}, {0x06030102},	/* 309 */
+  {0x06030102}, {0x06030102}, {0x06030102}, {0x06010302}, {0x06010302},	/* 314 */
+  {0x06010302}, {0x06010302}, {0x06010302}, {0x06010302}, {0x06010302},	/* 319 */
+  {0x06010302}, {0x07030001}, {0x07030001}, {0x07030001}, {0x07030001},	/* 324 */
+  {0x07000301}, {0x07000301}, {0x07000301}, {0x07000301}, {0x06020202},	/* 329 */
+  {0x06020202}, {0x06020202}, {0x06020202}, {0x06020202}, {0x06020202},	/* 334 */
+  {0x06020202}, {0x06020202}, {0x05020102}, {0x05020102}, {0x05020102},	/* 339 */
+  {0x05020102}, {0x05020102}, {0x05020102}, {0x05020102}, {0x05020102},	/* 344 */
+  {0x05020102}, {0x05020102}, {0x05020102}, {0x05020102}, {0x05020102},	/* 349 */
+  {0x05020102}, {0x05020102}, {0x05020102}, {0x05010202}, {0x05010202},	/* 354 */
+  {0x05010202}, {0x05010202}, {0x05010202}, {0x05010202}, {0x05010202},	/* 359 */
+  {0x05010202}, {0x05010202}, {0x05010202}, {0x05010202}, {0x05010202},	/* 364 */
+  {0x05010202}, {0x05010202}, {0x05010202}, {0x05010202}, {0x06020001},	/* 369 */
+  {0x06020001}, {0x06020001}, {0x06020001}, {0x06020001}, {0x06020001},	/* 374 */
+  {0x06020001}, {0x06020001}, {0x06000201}, {0x06000201}, {0x06000201},	/* 379 */
+  {0x06000201}, {0x06000201}, {0x06000201}, {0x06000201}, {0x06000201},	/* 384 */
+  {0x04010102}, {0x04010102}, {0x04010102}, {0x04010102}, {0x04010102},	/* 389 */
+  {0x04010102}, {0x04010102}, {0x04010102}, {0x04010102}, {0x04010102},	/* 394 */
+  {0x04010102}, {0x04010102}, {0x04010102}, {0x04010102}, {0x04010102},	/* 399 */
+  {0x04010102}, {0x04010102}, {0x04010102}, {0x04010102}, {0x04010102},	/* 404 */
+  {0x04010102}, {0x04010102}, {0x04010102}, {0x04010102}, {0x04010102},	/* 409 */
+  {0x04010102}, {0x04010102}, {0x04010102}, {0x04010102}, {0x04010102},	/* 414 */
+  {0x04010102}, {0x04010102}, {0x04010001}, {0x04010001}, {0x04010001},	/* 419 */
+  {0x04010001}, {0x04010001}, {0x04010001}, {0x04010001}, {0x04010001},	/* 424 */
+  {0x04010001}, {0x04010001}, {0x04010001}, {0x04010001}, {0x04010001},	/* 429 */
+  {0x04010001}, {0x04010001}, {0x04010001}, {0x04010001}, {0x04010001},	/* 434 */
+  {0x04010001}, {0x04010001}, {0x04010001}, {0x04010001}, {0x04010001},	/* 439 */
+  {0x04010001}, {0x04010001}, {0x04010001}, {0x04010001}, {0x04010001},	/* 444 */
+  {0x04010001}, {0x04010001}, {0x04010001}, {0x04010001}, {0x04000101},	/* 449 */
+  {0x04000101}, {0x04000101}, {0x04000101}, {0x04000101}, {0x04000101},	/* 454 */
+  {0x04000101}, {0x04000101}, {0x04000101}, {0x04000101}, {0x04000101},	/* 459 */
+  {0x04000101}, {0x04000101}, {0x04000101}, {0x04000101}, {0x04000101},	/* 464 */
+  {0x04000101}, {0x04000101}, {0x04000101}, {0x04000101}, {0x04000101},	/* 469 */
+  {0x04000101}, {0x04000101}, {0x04000101}, {0x04000101}, {0x04000101},	/* 474 */
+  {0x04000101}, {0x04000101}, {0x04000101}, {0x04000101}, {0x04000101},	/* 479 */
+  {0x04000101}, {0x04000000}, {0x04000000}, {0x04000000}, {0x04000000},	/* 484 */
+  {0x04000000}, {0x04000000}, {0x04000000}, {0x04000000}, {0x04000000},	/* 489 */
+  {0x04000000}, {0x04000000}, {0x04000000}, {0x04000000}, {0x04000000},	/* 494 */
+  {0x04000000}, {0x04000000}, {0x04000000}, {0x04000000}, {0x04000000},	/* 499 */
+  {0x04000000}, {0x04000000}, {0x04000000}, {0x04000000}, {0x04000000},	/* 504 */
+  {0x04000000}, {0x04000000}, {0x04000000}, {0x04000000}, {0x04000000},	/* 509 */
+  {0x04000000}, {0x04000000}, {0x04000000}, {0xFF000002}, {0x020E0E02},	/* 514 */
+  {0x020E0D02}, {0x020D0E02}, {0x020E0C02}, {0xFF000002}, {0x020C0E02},	/* 519 */
+  {0x020D0D02}, {0x020E0B02}, {0x020B0E02}, {0xFF000002}, {0x020D0C02},	/* 524 */
+  {0x020C0D02}, {0x020E0A02}, {0x020A0E02}, {0xFF000002}, {0x020D0B02},	/* 529 */
+  {0x020B0D02}, {0x020C0C02}, {0x020E0902}, {0xFF000002}, {0x02090E02},	/* 534 */
+  {0x020D0A02}, {0x020A0D02}, {0x020C0B02}, {0xFF000002}, {0x020B0C02},	/* 539 */
+  {0x020E0802}, {0x02080E02}, {0x020D0902}, {0xFF000002}, {0x02090D02},	/* 544 */
+  {0x020E0702}, {0x02070E02}, {0x020C0A02}, {0xFF000002}, {0x020A0C02},	/* 549 */
+  {0x020B0B02}, {0x020D0802}, {0x02080D02}, {0xFF000003}, {0x030E0001},	/* 554 */
+  {0x03000E01}, {0x020D0001}, {0x020D0001}, {0x01060E02}, {0x01060E02},	/* 559 */
+  {0x01060E02}, {0x01060E02}, {0xFF000002}, {0x020E0602}, {0x020C0902},	/* 564 */
+  {0x01090C02}, {0x01090C02}, {0xFF000001}, {0x010E0502}, {0x010A0B02},	/* 569 */
+  {0xFF000002}, {0x01050E02}, {0x01050E02}, {0x020B0A02}, {0x020D0702},	/* 574 */
+  {0xFF000001}, {0x01070D02}, {0x01040E02}, {0xFF000001}, {0x010C0802},	/* 579 */
+  {0x01080C02}, {0xFF000002}, {0x020E0402}, {0x020E0202}, {0x010E0302},	/* 584 */
+  {0x010E0302}, {0xFF000001}, {0x010D0602}, {0x01060D02}, {0xFF000001},	/* 589 */
+  {0x01030E02}, {0x010B0902}, {0xFF000001}, {0x01090B02}, {0x010A0A02},	/* 594 */
+  {0xFF000001}, {0x01020E02}, {0x010E0102}, {0xFF000001}, {0x01010E02},	/* 599 */
+  {0x010D0502}, {0xFF000001}, {0x01050D02}, {0x010C0702}, {0xFF000001},	/* 604 */
+  {0x01070C02}, {0x010D0402}, {0xFF000001}, {0x010B0802}, {0x01080B02},	/* 609 */
+  {0xFF000001}, {0x01040D02}, {0x010A0902}, {0xFF000001}, {0x01090A02},	/* 614 */
+  {0x010C0602}, {0xFF000001}, {0x01060C02}, {0x010D0302}, {0xFF000001},	/* 619 */
+  {0x01030D02}, {0x010D0202}, {0xFF000001}, {0x01020D02}, {0x010D0102},	/* 624 */
+  {0xFF000001}, {0x010B0702}, {0x01070B02}, {0xFF000001}, {0x01010D02},	/* 629 */
+  {0x010C0502}, {0xFF000001}, {0x01050C02}, {0x010A0802}, {0xFF000001},	/* 634 */
+  {0x01080A02}, {0x01090902}, {0xFF000001}, {0x010C0402}, {0x01040C02},	/* 639 */
+  {0xFF000001}, {0x010B0602}, {0x01060B02}, {0xFF000002}, {0x02000D01},	/* 644 */
+  {0x020C0001}, {0x010C0302}, {0x010C0302}, {0xFF000001}, {0x01030C02},	/* 649 */
+  {0x010A0702}, {0xFF000001}, {0x01070A02}, {0x010C0202}, {0xFF000001},	/* 654 */
+  {0x01020C02}, {0x010B0502}, {0xFF000001}, {0x01050B02}, {0x010C0102},	/* 659 */
+  {0xFF000001}, {0x01090802}, {0x01080902}, {0xFF000001}, {0x01010C02},	/* 664 */
+  {0x010B0402}, {0xFF000002}, {0x02000C01}, {0x020B0001}, {0x010B0302},	/* 669 */
+  {0x010B0302}, {0xFF000002}, {0x02000B01}, {0x020A0001}, {0x010A0102},	/* 674 */
+  {0x010A0102}, {0xFF000001}, {0x010A0602}, {0x01060A02}, {0xFF000001},	/* 679 */
+  {0x01090702}, {0x01070902}, {0xFF000002}, {0x02000A01}, {0x02090001},	/* 684 */
+  {0x01000901}, {0x01000901}, {0xFF000001}, {0x010B0202}, {0x010A0502},	/* 689 */
+  {0xFF000001}, {0x01050A02}, {0x010B0102}, {0xFF000001}, {0x01010B02},	/* 694 */
+  {0x01090602}, {0xFF000001}, {0x010A0402}, {0x01080702}, {0xFF000001},	/* 699 */
+  {0x01080001}, {0x01000801}, {0xFF000001}, {0x01070001}, {0x01000701}, /* 704 */
+};
+
+/* max table bits  9 */
+/* NO XING TABLE 25 */
+/* NO XING TABLE 26 */
+/* NO XING TABLE 27 */
+/* NO XING TABLE 28 */
+/* NO XING TABLE 29 */
+/* NO XING TABLE 30 */
+/* NO XING TABLE 31 */
+/* done */
diff --git a/codemp/mp3code/hwin.c b/codemp/mp3code/hwin.c
new file mode 100644
index 0000000..26d7dd8
--- /dev/null
+++ b/codemp/mp3code/hwin.c
@@ -0,0 +1,264 @@
+/*____________________________________________________________________________
+	
+	FreeAmp - The Free MP3 Player
+
+        MP3 Decoder originally Copyright (C) 1995-1997 Xing Technology
+        Corp.  http://www.xingtech.com
+
+	Portions Copyright (C) 1998-1999 EMusic.com
+
+	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., 675 Mass Ave, Cambridge, MA 02139, USA.
+	
+	$Id: hwin.c,v 1.5 1999/10/19 07:13:08 elrod Exp $
+____________________________________________________________________________*/
+
+/****  hwin.c  ***************************************************
+
+Layer III 
+
+hybrid window/filter 
+
+******************************************************************/
+#include <stdlib.h>
+#include <stdio.h>
+#include <float.h>
+#include <math.h>
+
+#include "mp3struct.h"
+////@@@@extern int band_limit_nsb;
+
+typedef float ARRAY36[36];
+
+/*-- windows by block type --*/
+static float win[4][36];	// effectively a constant
+
+
+/*====================================================================*/
+void imdct18(float f[]);	/* 18 point */
+void imdct6_3(float f[]);	/* 6 point */
+
+/*====================================================================*/
+ARRAY36 *hwin_init_addr()
+{
+   return win;
+}
+
+
+/*====================================================================*/
+int hybrid(float xin[], float xprev[], float y[18][32],
+	   int btype, int nlong, int ntot, int nprev)
+{
+   int i, j;
+   float *x, *x0;
+   float xa, xb;
+   int n;
+   int nout;
+
+
+
+   if (btype == 2)
+      btype = 0;
+   x = xin;
+   x0 = xprev;
+
+/*-- do long blocks (if any) --*/
+   n = (nlong + 17) / 18;	/* number of dct's to do */
+   for (i = 0; i < n; i++)
+   {
+      imdct18(x);
+      for (j = 0; j < 9; j++)
+      {
+	 y[j][i] = x0[j] + win[btype][j] * x[9 + j];
+	 y[9 + j][i] = x0[9 + j] + win[btype][9 + j] * x[17 - j];
+      }
+    /* window x for next time x0 */
+      for (j = 0; j < 4; j++)
+      {
+	 xa = x[j];
+	 xb = x[8 - j];
+	 x[j] = win[btype][18 + j] * xb;
+	 x[8 - j] = win[btype][(18 + 8) - j] * xa;
+	 x[9 + j] = win[btype][(18 + 9) + j] * xa;
+	 x[17 - j] = win[btype][(18 + 17) - j] * xb;
+      }
+      xa = x[j];
+      x[j] = win[btype][18 + j] * xa;
+      x[9 + j] = win[btype][(18 + 9) + j] * xa;
+
+      x += 18;
+      x0 += 18;
+   }
+
+/*-- do short blocks (if any) --*/
+   n = (ntot + 17) / 18;	/* number of 6 pt dct's triples to do */
+   for (; i < n; i++)
+   {
+      imdct6_3(x);
+      for (j = 0; j < 3; j++)
+      {
+	 y[j][i] = x0[j];
+	 y[3 + j][i] = x0[3 + j];
+
+	 y[6 + j][i] = x0[6 + j] + win[2][j] * x[3 + j];
+	 y[9 + j][i] = x0[9 + j] + win[2][3 + j] * x[5 - j];
+
+	 y[12 + j][i] = x0[12 + j] + win[2][6 + j] * x[2 - j] + win[2][j] * x[(6 + 3) + j];
+	 y[15 + j][i] = x0[15 + j] + win[2][9 + j] * x[j] + win[2][3 + j] * x[(6 + 5) - j];
+      }
+    /* window x for next time x0 */
+      for (j = 0; j < 3; j++)
+      {
+	 x[j] = win[2][6 + j] * x[(6 + 2) - j] + win[2][j] * x[(12 + 3) + j];
+	 x[3 + j] = win[2][9 + j] * x[6 + j] + win[2][3 + j] * x[(12 + 5) - j];
+      }
+      for (j = 0; j < 3; j++)
+      {
+	 x[6 + j] = win[2][6 + j] * x[(12 + 2) - j];
+	 x[9 + j] = win[2][9 + j] * x[12 + j];
+      }
+      for (j = 0; j < 3; j++)
+      {
+	 x[12 + j] = 0.0f;
+	 x[15 + j] = 0.0f;
+      }
+      x += 18;
+      x0 += 18;
+   }
+
+/*--- overlap prev if prev longer that current --*/
+   n = (nprev + 17) / 18;
+   for (; i < n; i++)
+   {
+      for (j = 0; j < 18; j++)
+	 y[j][i] = x0[j];
+      x0 += 18;
+   }
+   nout = 18 * i;
+
+/*--- clear remaining only to band limit --*/
+   for (; i < pMP3Stream->band_limit_nsb; i++)
+   {
+      for (j = 0; j < 18; j++)
+	 y[j][i] = 0.0f;
+   }
+
+   return nout;
+}
+
+
+/*--------------------------------------------------------------------*/
+/*--------------------------------------------------------------------*/
+/*-- convert to mono, add curr result to y,
+    window and add next time to current left */
+int hybrid_sum(float xin[], float xin_left[], float y[18][32],
+	       int btype, int nlong, int ntot)
+{
+   int i, j;
+   float *x, *x0;
+   float xa, xb;
+   int n;
+   int nout;
+
+
+
+   if (btype == 2)
+      btype = 0;
+   x = xin;
+   x0 = xin_left;
+
+/*-- do long blocks (if any) --*/
+   n = (nlong + 17) / 18;	/* number of dct's to do */
+   for (i = 0; i < n; i++)
+   {
+      imdct18(x);
+      for (j = 0; j < 9; j++)
+      {
+	 y[j][i] += win[btype][j] * x[9 + j];
+	 y[9 + j][i] += win[btype][9 + j] * x[17 - j];
+      }
+    /* window x for next time x0 */
+      for (j = 0; j < 4; j++)
+      {
+	 xa = x[j];
+	 xb = x[8 - j];
+	 x0[j] += win[btype][18 + j] * xb;
+	 x0[8 - j] += win[btype][(18 + 8) - j] * xa;
+	 x0[9 + j] += win[btype][(18 + 9) + j] * xa;
+	 x0[17 - j] += win[btype][(18 + 17) - j] * xb;
+      }
+      xa = x[j];
+      x0[j] += win[btype][18 + j] * xa;
+      x0[9 + j] += win[btype][(18 + 9) + j] * xa;
+
+      x += 18;
+      x0 += 18;
+   }
+
+/*-- do short blocks (if any) --*/
+   n = (ntot + 17) / 18;	/* number of 6 pt dct's triples to do */
+   for (; i < n; i++)
+   {
+      imdct6_3(x);
+      for (j = 0; j < 3; j++)
+      {
+	 y[6 + j][i] += win[2][j] * x[3 + j];
+	 y[9 + j][i] += win[2][3 + j] * x[5 - j];
+
+	 y[12 + j][i] += win[2][6 + j] * x[2 - j] + win[2][j] * x[(6 + 3) + j];
+	 y[15 + j][i] += win[2][9 + j] * x[j] + win[2][3 + j] * x[(6 + 5) - j];
+      }
+    /* window x for next time */
+      for (j = 0; j < 3; j++)
+      {
+	 x0[j] += win[2][6 + j] * x[(6 + 2) - j] + win[2][j] * x[(12 + 3) + j];
+	 x0[3 + j] += win[2][9 + j] * x[6 + j] + win[2][3 + j] * x[(12 + 5) - j];
+      }
+      for (j = 0; j < 3; j++)
+      {
+	 x0[6 + j] += win[2][6 + j] * x[(12 + 2) - j];
+	 x0[9 + j] += win[2][9 + j] * x[12 + j];
+      }
+      x += 18;
+      x0 += 18;
+   }
+
+   nout = 18 * i;
+
+   return nout;
+}
+/*--------------------------------------------------------------------*/
+void sum_f_bands(float a[], float b[], int n)
+{
+   int i;
+
+   for (i = 0; i < n; i++)
+      a[i] += b[i];
+}
+/*--------------------------------------------------------------------*/
+/*--------------------------------------------------------------------*/
+void FreqInvert(float y[18][32], int n)
+{
+   int i, j;
+
+   n = (n + 17) / 18;
+   for (j = 0; j < 18; j += 2)
+   {
+      for (i = 0; i < n; i += 2)
+      {
+	 y[1 + j][1 + i] = -y[1 + j][1 + i];
+      }
+   }
+}
+/*--------------------------------------------------------------------*/
diff --git a/codemp/mp3code/jdw.h b/codemp/mp3code/jdw.h
new file mode 100644
index 0000000..c8751f9
--- /dev/null
+++ b/codemp/mp3code/jdw.h
@@ -0,0 +1,28 @@
+/*____________________________________________________________________________
+	
+	FreeAmp - The Free MP3 Player
+
+	Copyright (C) 1998 EMusic.com
+
+	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., 675 Mass Ave, Cambridge, MA 02139, USA.
+	
+	$Id: jdw.h,v 1.2 1999/10/19 07:13:08 elrod Exp $
+____________________________________________________________________________*/
+
+/* LOL */
+
+#ifndef min
+#define min(a,b) ((a>b)?b:a)
+#endif
diff --git a/codemp/mp3code/l3.h b/codemp/mp3code/l3.h
new file mode 100644
index 0000000..f7cfee4
--- /dev/null
+++ b/codemp/mp3code/l3.h
@@ -0,0 +1,187 @@
+/*____________________________________________________________________________
+	
+	FreeAmp - The Free MP3 Player
+
+        MP3 Decoder originally Copyright (C) 1996-1997 Xing Technology
+        Corp.  http://www.xingtech.com
+
+	Portions Copyright (C) 1998-1999 Emusic.com
+
+	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., 675 Mass Ave, Cambridge, MA 02139, USA.
+	
+	$Id: L3.h,v 1.7 1999/12/10 07:16:42 elrod Exp $
+____________________________________________________________________________*/
+
+/****  L3.h  ***************************************************
+
+  Layer III structures
+
+  *** Layer III is 32 bit only          ***
+  *** Layer III code assumes 32 bit int ***
+
+******************************************************************/
+#ifndef L3_H
+#define L3_H
+
+#include "config.h"
+
+#define GLOBAL_GAIN_SCALE (4*15)
+/* #define GLOBAL_GAIN_SCALE 0 */
+
+
+#ifdef _M_IX86
+#define LITTLE_ENDIAN 1
+#endif
+
+#ifdef _M_ALPHA
+#define LITTLE_ENDIAN 1
+#endif
+
+#ifdef sparc
+#define LITTLE_ENDIAN 0
+#endif
+
+#if defined(__POWERPC__)
+#define LITTLE_ENDIAN 0
+#elif defined(__INTEL__)
+#define LITTLE_ENDIAN 1
+#endif
+
+#ifndef LITTLE_ENDIAN
+#error Layer III LITTLE_ENDIAN must be defined 0 or 1
+#endif
+
+/*-----------------------------------------------------------*/
+/*---- huffman lookup tables ---*/
+/* endian dependent !!! */
+#if LITTLE_ENDIAN
+typedef union
+{
+   int ptr;
+   struct
+   {
+      unsigned char signbits;
+      unsigned char x;
+      unsigned char y;
+      unsigned char purgebits;	// 0 = esc
+
+   }
+   b;
+}
+HUFF_ELEMENT;
+
+#else /* big endian machines */
+typedef union
+{
+   int ptr;			/* int must be 32 bits or more */
+   struct
+   {
+      unsigned char purgebits;	// 0 = esc
+
+      unsigned char y;
+      unsigned char x;
+      unsigned char signbits;
+   }
+   b;
+}
+HUFF_ELEMENT;
+
+#endif
+/*--------------------------------------------------------------*/
+typedef struct
+{
+   unsigned int bitbuf;
+   int bits;
+   unsigned char *bs_ptr;
+   unsigned char *bs_ptr0;
+   unsigned char *bs_ptr_end;	// optional for overrun test
+
+}
+BITDAT;
+
+/*-- side info ---*/
+typedef struct
+{
+   int part2_3_length;
+   int big_values;
+   int global_gain;
+   int scalefac_compress;
+   int window_switching_flag;
+   int block_type;
+   int mixed_block_flag;
+   int table_select[3];
+   int subblock_gain[3];
+   int region0_count;
+   int region1_count;
+   int preflag;
+   int scalefac_scale;
+   int count1table_select;
+}
+GR;
+typedef struct
+{
+   int mode;
+   int mode_ext;
+/*---------------*/
+   int main_data_begin;		/* beginning, not end, my spec wrong */
+   int private_bits;
+/*---------------*/
+   int scfsi[2];		/* 4 bit flags [ch] */
+   GR gr[2][2];			/* [gran][ch] */
+}
+SIDE_INFO;
+
+/*-----------------------------------------------------------*/
+/*-- scale factors ---*/
+// check dimensions - need 21 long, 3*12 short
+// plus extra for implicit sf=0 above highest cb
+typedef struct
+{
+   int l[23];			/* [cb] */
+   int s[3][13];		/* [window][cb] */
+}
+SCALEFACT;
+
+/*-----------------------------------------------------------*/
+typedef struct
+{
+   int cbtype;			/* long=0 short=1 */
+   int cbmax;			/* max crit band */
+//   int lb_type;			/* long block type 0 1 3 */
+   int cbs0;			/* short band start index 0 3 12 (12=no shorts */
+   int ncbl;			/* number long cb's 0 8 21 */
+   int cbmax_s[3];		/* cbmax by individual short blocks */
+}
+CB_INFO;
+
+/*-----------------------------------------------------------*/
+/* scale factor infor for MPEG2 intensity stereo  */
+typedef struct
+{
+   int nr[3];
+   int slen[3];
+   int intensity_scale;
+}
+IS_SF_INFO;
+
+
+#ifndef SAMPLE
+#include "small_header.h"
+#endif
+
+/*-----------------------------------------------------------*/
+
+#endif	// #ifndef L3_H
+
diff --git a/codemp/mp3code/l3dq.c b/codemp/mp3code/l3dq.c
new file mode 100644
index 0000000..dda1881
--- /dev/null
+++ b/codemp/mp3code/l3dq.c
@@ -0,0 +1,262 @@
+/*____________________________________________________________________________
+	
+	FreeAmp - The Free MP3 Player
+
+        MP3 Decoder originally Copyright (C) 1995-1997 Xing Technology
+        Corp.  http://www.xingtech.com
+
+	Portions Copyright (C) 1998-1999 EMusic.com
+
+	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., 675 Mass Ave, Cambridge, MA 02139, USA.
+	
+	$Id: l3dq.c,v 1.6 1999/10/19 07:13:09 elrod Exp $
+____________________________________________________________________________*/
+
+/****  quant.c  ***************************************************
+  Layer III  dequant
+
+  does reordering of short blocks
+
+  mod 8/19/98 decode 22 sf bands
+
+******************************************************************/
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <float.h>
+#include <math.h>
+#include <string.h>
+#include "L3.h"
+
+#include "mp3struct.h"
+
+/*----------
+static struct  {
+int l[23];
+int s[14];} sfBandTable[3] =   
+{{{0,4,8,12,16,20,24,30,36,44,52,62,74,90,110,134,162,196,238,288,342,418,576},
+ {0,4,8,12,16,22,30,40,52,66,84,106,136,192}},
+{{0,4,8,12,16,20,24,30,36,42,50,60,72,88,106,128,156,190,230,276,330,384,576},
+ {0,4,8,12,16,22,28,38,50,64,80,100,126,192}},
+{{0,4,8,12,16,20,24,30,36,44,54,66,82,102,126,156,194,240,296,364,448,550,576},
+ {0,4,8,12,16,22,30,42,58,78,104,138,180,192}}};
+----------*/
+
+/*--------------------------------*/
+static const int pretab[2][22] =
+{
+   {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+   {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 3, 3, 3, 2, 0},
+};
+
+
+////@@@@extern int nBand[2][22];	/* long = nBand[0][i], short = nBand[1][i] */
+
+/* 8 bit plus 2 lookup x = pow(2.0, 0.25*(global_gain-210)) */
+/* two extra slots to do 1/sqrt(2) scaling for ms */
+/* 4 extra slots to do 1/2 scaling for cvt to mono */
+static float look_global[256 + 2 + 4];		// effectively constant
+
+/*-------- scaling lookup
+x = pow(2.0, -0.5*(1+scalefact_scale)*scalefac + preemp)
+look_scale[scalefact_scale][preemp][scalefac]
+-----------------------*/
+static float look_scale[2][4][32];			// effectively constant
+typedef float LS[4][32];
+
+
+/*--- iSample**(4/3) lookup, -32<=i<=31 ---*/
+#define ISMAX 32
+static float look_pow[2 * ISMAX];			// effectively constant
+
+/*-- pow(2.0, -0.25*8.0*subblock_gain) --*/
+static float look_subblock[8];				// effectively constant
+
+/*-- reorder buffer ---*/
+static float re_buf[192][3];				// used by dequant() below, but only during func (as workspace)
+typedef float ARRAY3[3];
+
+
+/*=============================================================*/
+float *quant_init_global_addr()
+{
+   return look_global;
+}
+/*-------------------------------------------------------------*/
+LS *quant_init_scale_addr()
+{
+   return look_scale;
+}
+/*-------------------------------------------------------------*/
+float *quant_init_pow_addr()
+{
+   return look_pow;
+}
+/*-------------------------------------------------------------*/
+float *quant_init_subblock_addr()
+{
+   return look_subblock;
+}
+/*=============================================================*/
+
+#ifdef _MSC_VER
+#pragma warning(disable: 4056)
+#endif
+
+void dequant(SAMPLE Sample[], int *nsamp,
+	     SCALEFACT * sf,
+	     GR * gr,
+	     CB_INFO * cb_info, int ncbl_mixed)
+{
+   int i, j;
+   int cb, n, w;
+   float x0, xs;
+   float xsb[3];
+   double tmp;
+   int ncbl;
+   int cbs0;
+   ARRAY3 *buf;			/* short block reorder */
+   int nbands;
+   int i0;
+   int non_zero;
+   int cbmax[3];
+
+   nbands = *nsamp;
+
+
+   ncbl = 22;			/* long block cb end */
+   cbs0 = 12;			/* short block cb start */
+/* ncbl_mixed = 8 or 6  mpeg1 or 2 */
+   if (gr->block_type == 2)
+   {
+      ncbl = 0;
+      cbs0 = 0;
+      if (gr->mixed_block_flag)
+      {
+	 ncbl = ncbl_mixed;
+	 cbs0 = 3;
+      }
+   }
+/* fill in cb_info -- */
+   /* This doesn't seem used anywhere...
+   cb_info->lb_type = gr->block_type;
+   if (gr->block_type == 2)
+      cb_info->lb_type;
+   */
+   cb_info->cbs0 = cbs0;
+   cb_info->ncbl = ncbl;
+
+   cbmax[2] = cbmax[1] = cbmax[0] = 0;
+/* global gain pre-adjusted by 2 if ms_mode, 0 otherwise */
+   x0 = look_global[(2 + 4) + gr->global_gain];
+   i = 0;
+/*----- long blocks ---*/
+   for (cb = 0; cb < ncbl; cb++)
+   {
+      non_zero = 0;
+      xs = x0 * look_scale[gr->scalefac_scale][pretab[gr->preflag][cb]][sf->l[cb]];
+      n = pMP3Stream->nBand[0][cb];
+      for (j = 0; j < n; j++, i++)
+      {
+	 if (Sample[i].s == 0)
+	    Sample[i].x = 0.0F;
+	 else
+	 {
+	    non_zero = 1;
+	    if ((Sample[i].s >= (-ISMAX)) && (Sample[i].s < ISMAX))
+	       Sample[i].x = xs * look_pow[ISMAX + Sample[i].s];
+	    else
+	    {
+		float tmpConst = (float)(1.0/3.0);
+	       tmp = (double) Sample[i].s;
+	       Sample[i].x = (float) (xs * tmp * pow(fabs(tmp), tmpConst));
+	    }
+	 }
+      }
+      if (non_zero)
+	 cbmax[0] = cb;
+      if (i >= nbands)
+	 break;
+   }
+
+   cb_info->cbmax = cbmax[0];
+   cb_info->cbtype = 0;		// type = long
+
+   if (cbs0 >= 12)
+      return;
+/*---------------------------
+block type = 2  short blocks
+----------------------------*/
+   cbmax[2] = cbmax[1] = cbmax[0] = cbs0;
+   i0 = i;			/* save for reorder */
+   buf = re_buf;
+   for (w = 0; w < 3; w++)
+      xsb[w] = x0 * look_subblock[gr->subblock_gain[w]];
+   for (cb = cbs0; cb < 13; cb++)
+   {
+      n = pMP3Stream->nBand[1][cb];
+      for (w = 0; w < 3; w++)
+      {
+	 non_zero = 0;
+	 xs = xsb[w] * look_scale[gr->scalefac_scale][0][sf->s[w][cb]];
+	 for (j = 0; j < n; j++, i++)
+	 {
+	    if (Sample[i].s == 0)
+	       buf[j][w] = 0.0F;
+	    else
+	    {
+	       non_zero = 1;
+	       if ((Sample[i].s >= (-ISMAX)) && (Sample[i].s < ISMAX))
+		  buf[j][w] = xs * look_pow[ISMAX + Sample[i].s];
+	       else
+	       {
+		  float tmpConst = (float)(1.0/3.0);
+		  tmp = (double) Sample[i].s;
+		  buf[j][w] = (float) (xs * tmp * pow(fabs(tmp), tmpConst));
+	       }
+	    }
+	 }
+	 if (non_zero)
+	    cbmax[w] = cb;
+      }
+      if (i >= nbands)
+	 break;
+      buf += n;
+   }
+
+
+   memmove(&Sample[i0].x, &re_buf[0][0], sizeof(float) * (i - i0));
+
+   *nsamp = i;			/* update nsamp */
+   cb_info->cbmax_s[0] = cbmax[0];
+   cb_info->cbmax_s[1] = cbmax[1];
+   cb_info->cbmax_s[2] = cbmax[2];
+   if (cbmax[1] > cbmax[0])
+      cbmax[0] = cbmax[1];
+   if (cbmax[2] > cbmax[0])
+      cbmax[0] = cbmax[2];
+
+   cb_info->cbmax = cbmax[0];
+   cb_info->cbtype = 1;		/* type = short */
+
+
+   return;
+}
+
+#ifdef _MSC_VER
+#pragma warning(default: 4056)
+#endif
+
+/*-------------------------------------------------------------*/
diff --git a/codemp/mp3code/l3init.c b/codemp/mp3code/l3init.c
new file mode 100644
index 0000000..aaf1ad7
--- /dev/null
+++ b/codemp/mp3code/l3init.c
@@ -0,0 +1,422 @@
+/*____________________________________________________________________________
+	
+	FreeAmp - The Free MP3 Player
+
+        MP3 Decoder originally Copyright (C) 1995-1997 Xing Technology
+        Corp.  http://www.xingtech.com
+
+	Portions Copyright (C) 1998 EMusic.com
+
+	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., 675 Mass Ave, Cambridge, MA 02139, USA.
+	
+	$Id: l3init.c,v 1.2 1999/10/19 07:13:09 elrod Exp $
+____________________________________________________________________________*/
+
+/****  tinit.c  ***************************************************
+  Layer III  init tables
+
+
+******************************************************************/
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <float.h>
+#include <math.h>
+#include "L3.h"
+
+/* get rid of precision loss warnings on conversion */
+#ifdef _MSC_VER
+#pragma warning(disable:4244 4056)
+#endif
+
+
+/*---------- quant ---------------------------------*/
+/* 8 bit lookup x = pow(2.0, 0.25*(global_gain-210)) */
+float *quant_init_global_addr();
+
+
+/* x = pow(2.0, -0.5*(1+scalefact_scale)*scalefac + preemp) */
+typedef float LS[4][32];
+LS *quant_init_scale_addr();
+
+
+float *quant_init_pow_addr();
+float *quant_init_subblock_addr();
+
+typedef int iARRAY22[22];
+iARRAY22 *quant_init_band_addr();
+
+/*---------- antialias ---------------------------------*/
+typedef float PAIR[2];
+PAIR *alias_init_addr();
+
+static const float Ci[8] =
+{
+   -0.6f, -0.535f, -0.33f, -0.185f, -0.095f, -0.041f, -0.0142f, -0.0037f};
+
+
+void hwin_init();		/* hybrid windows -- */
+void imdct_init();
+typedef struct
+{
+   float *w;
+   float *w2;
+   void *coef;
+}
+IMDCT_INIT_BLOCK;
+
+void msis_init();
+void msis_init_MPEG2();
+
+/*=============================================================*/
+int L3table_init()
+{
+   int i;
+   float *x;
+   LS *ls;
+   int scalefact_scale, preemp, scalefac;
+   double tmp;
+   PAIR *csa;
+
+   static int iOnceOnly = 0;
+
+   	if (!iOnceOnly++)
+	{
+/*================ quant ===============================*/
+
+	/* 8 bit plus 2 lookup x = pow(2.0, 0.25*(global_gain-210)) */
+	/* extra 2 for ms scaling by 1/sqrt(2) */
+	/* extra 4 for cvt to mono scaling by 1/2 */
+	   x = quant_init_global_addr();
+	   for (i = 0; i < 256 + 2 + 4; i++)
+		  x[i] = (float) pow(2.0, 0.25 * ((i - (2 + 4)) - 210 + GLOBAL_GAIN_SCALE));
+
+
+
+	/* x = pow(2.0, -0.5*(1+scalefact_scale)*scalefac + preemp) */
+	   ls = quant_init_scale_addr();
+	   for (scalefact_scale = 0; scalefact_scale < 2; scalefact_scale++)
+	   {
+		  for (preemp = 0; preemp < 4; preemp++)
+		  {
+		 for (scalefac = 0; scalefac < 32; scalefac++)
+		 {
+			ls[scalefact_scale][preemp][scalefac] =
+			   (float) pow(2.0, -0.5 * (1 + scalefact_scale) * (scalefac + preemp));
+		 }
+		  }
+	   }
+
+	/*--- iSample**(4/3) lookup, -32<=i<=31 ---*/
+	   x = quant_init_pow_addr();
+	   for (i = 0; i < 64; i++)
+	   {
+		  tmp = i - 32;
+		  x[i] = (float) (tmp * pow(fabs(tmp), (1.0 / 3.0)));
+	   }
+
+
+	/*-- pow(2.0, -0.25*8.0*subblock_gain)  3 bits --*/
+	   x = quant_init_subblock_addr();
+	   for (i = 0; i < 8; i++)
+	   {
+		  x[i] = (float) pow(2.0, 0.25 * -8.0 * i);
+	   }
+
+	/*-------------------------*/
+	// quant_init_sf_band(sr_index);   replaced by code in sup.c
+
+
+/*================ antialias ===============================*/
+	   // onceonly!!!!!!!!!!!!!!!!!!!!!
+	   csa = alias_init_addr();
+	   for (i = 0; i < 8; i++)
+	   {
+		  csa[i][0] = (float) (1.0 / sqrt(1.0 + Ci[i] * Ci[i]));
+		  csa[i][1] = (float) (Ci[i] / sqrt(1.0 + Ci[i] * Ci[i]));
+	   }
+   }
+
+   // these 4 are iOnceOnly-protected inside...
+
+/*================ msis ===============================*/
+   msis_init();
+   msis_init_MPEG2();
+
+/*================ imdct ===============================*/
+   imdct_init();
+
+/*--- hybrid windows ------------*/
+   hwin_init();
+
+   return 0;
+}
+/*====================================================================*/
+typedef float ARRAY36[36];
+ARRAY36 *hwin_init_addr();
+
+/*--------------------------------------------------------------------*/
+void hwin_init()
+{
+   int i, j;
+   double pi;
+   ARRAY36 *win;
+
+   static int iOnceOnly = 0;
+
+   if (!iOnceOnly++)
+   {
+	   win = hwin_init_addr();
+
+	   pi = 4.0 * atan(1.0);
+
+	/* type 0 */
+	   for (i = 0; i < 36; i++)
+		  win[0][i] = (float) sin(pi / 36 * (i + 0.5));
+
+	/* type 1 */
+	   for (i = 0; i < 18; i++)
+		  win[1][i] = (float) sin(pi / 36 * (i + 0.5));
+	   for (i = 18; i < 24; i++)
+		  win[1][i] = 1.0F;
+	   for (i = 24; i < 30; i++)
+		  win[1][i] = (float) sin(pi / 12 * (i + 0.5 - 18));
+	   for (i = 30; i < 36; i++)
+		  win[1][i] = 0.0F;
+
+	/* type 3 */
+	   for (i = 0; i < 6; i++)
+		  win[3][i] = 0.0F;
+	   for (i = 6; i < 12; i++)
+		  win[3][i] = (float) sin(pi / 12 * (i + 0.5 - 6));
+	   for (i = 12; i < 18; i++)
+		  win[3][i] = 1.0F;
+	   for (i = 18; i < 36; i++)
+		  win[3][i] = (float) sin(pi / 36 * (i + 0.5));
+
+	/* type 2 */
+	   for (i = 0; i < 12; i++)
+		  win[2][i] = (float) sin(pi / 12 * (i + 0.5));
+	   for (i = 12; i < 36; i++)
+		  win[2][i] = 0.0F;
+
+	/*--- invert signs by region to match mdct 18pt --> 36pt mapping */
+	   for (j = 0; j < 4; j++)
+	   {
+		  if (j == 2)
+		 continue;
+		  for (i = 9; i < 36; i++)
+		 win[j][i] = -win[j][i];
+	   }
+
+	/*-- invert signs for short blocks --*/
+	   for (i = 3; i < 12; i++)
+		  win[2][i] = -win[2][i];
+   }   
+}
+/*=============================================================*/
+typedef float ARRAY4[4];
+const IMDCT_INIT_BLOCK *imdct_init_addr_18();
+const IMDCT_INIT_BLOCK *imdct_init_addr_6();
+
+/*-------------------------------------------------------------*/
+void imdct_init()
+{
+   int k, p, n;
+   double t, pi;
+   const IMDCT_INIT_BLOCK *addr;
+   float *w, *w2;
+   float *v, *v2, *coef87;
+   ARRAY4 *coef;
+
+   static int iOnceOnly = 0;
+
+   if (!iOnceOnly++)
+   {
+	/*--- 18 point --*/
+	   addr = imdct_init_addr_18();
+	   w = addr->w;
+	   w2 = addr->w2;
+	   coef = addr->coef;
+	/*----*/
+	   n = 18;
+	   pi = 4.0 * atan(1.0);
+	   t = pi / (4 * n);
+	   for (p = 0; p < n; p++)
+		  w[p] = (float) (2.0 * cos(t * (2 * p + 1)));
+	   for (p = 0; p < 9; p++)
+		  w2[p] = (float) 2.0 *cos(2 * t * (2 * p + 1));
+
+	   t = pi / (2 * n);
+	   for (k = 0; k < 9; k++)
+	   {
+		  for (p = 0; p < 4; p++)
+		 coef[k][p] = (float) cos(t * (2 * k) * (2 * p + 1));
+	   }
+
+	/*--- 6 point */
+	   addr = imdct_init_addr_6();
+	   v = addr->w;
+	   v2 = addr->w2;
+	   coef87 = addr->coef;
+	/*----*/
+	   n = 6;
+	   pi = 4.0 * atan(1.0);
+	   t = pi / (4 * n);
+	   for (p = 0; p < n; p++)
+		  v[p] = (float) 2.0 *cos(t * (2 * p + 1));
+
+	   for (p = 0; p < 3; p++)
+		  v2[p] = (float) 2.0 *cos(2 * t * (2 * p + 1));
+
+	   t = pi / (2 * n);
+	   k = 1;
+	   p = 0;
+	   *coef87 = (float) cos(t * (2 * k) * (2 * p + 1));
+	/* adjust scaling to save a few mults */
+	   for (p = 0; p < 6; p++)
+		  v[p] = v[p] / 2.0f;
+	   *coef87 = (float) 2.0 *(*coef87);
+
+   }   
+}
+/*===============================================================*/
+typedef float ARRAY8_2[8][2];
+ARRAY8_2 *msis_init_addr();
+
+/*-------------------------------------------------------------*/
+void msis_init()
+{
+   int i;
+   double s, c;
+   double pi;
+   double t;
+   ARRAY8_2 *lr;
+
+   static int iOnceOnly = 0;
+
+   if (!iOnceOnly++)
+   {
+	   lr = msis_init_addr();
+
+
+	   pi = 4.0 * atan(1.0);
+	   t = pi / 12.0;
+	   for (i = 0; i < 7; i++)
+	   {
+		  s = sin(i * t);
+		  c = cos(i * t);
+		/* ms_mode = 0 */
+		  lr[0][i][0] = (float) (s / (s + c));
+		  lr[0][i][1] = (float) (c / (s + c));
+		/* ms_mode = 1 */
+		  lr[1][i][0] = (float) (sqrt(2.0) * (s / (s + c)));
+		  lr[1][i][1] = (float) (sqrt(2.0) * (c / (s + c)));
+	   }
+	/* sf = 7 */
+	/* ms_mode = 0 */
+	   lr[0][i][0] = 1.0f;
+	   lr[0][i][1] = 0.0f;
+	/* ms_mode = 1, in is bands is routine does ms processing */
+	   lr[1][i][0] = 1.0f;
+	   lr[1][i][1] = 1.0f;
+
+
+	/*-------
+	for(i=0;i<21;i++) nBand[0][i] = 
+				sfBandTable[sr_index].l[i+1] - sfBandTable[sr_index].l[i];
+	for(i=0;i<12;i++) nBand[1][i] = 
+				sfBandTable[sr_index].s[i+1] - sfBandTable[sr_index].s[i];
+	-------------*/
+   }
+}
+/*-------------------------------------------------------------*/
+/*===============================================================*/
+typedef float ARRAY2_64_2[2][64][2];
+ARRAY2_64_2 *msis_init_addr_MPEG2();
+
+/*-------------------------------------------------------------*/
+void msis_init_MPEG2()
+{
+   int k, n;
+   double t;
+   ARRAY2_64_2 *lr2;
+   int intensity_scale, ms_mode, sf, sflen;
+   float ms_factor[2];
+
+   static int iOnceOnly = 0;
+
+   if (!iOnceOnly++)
+   {
+	   ms_factor[0] = 1.0;
+	   ms_factor[1] = (float) sqrt(2.0);
+
+	   lr2 = msis_init_addr_MPEG2();
+
+	/* intensity stereo MPEG2 */
+	/* lr2[intensity_scale][ms_mode][sflen_offset+sf][left/right] */
+
+	   for (intensity_scale = 0; intensity_scale < 2; intensity_scale++)
+	   {
+		  t = pow(2.0, -0.25 * (1 + intensity_scale));
+		  for (ms_mode = 0; ms_mode < 2; ms_mode++)
+		  {
+
+		 n = 1;
+		 k = 0;
+		 for (sflen = 0; sflen < 6; sflen++)
+		 {
+			for (sf = 0; sf < (n - 1); sf++, k++)
+			{
+			   if (sf == 0)
+			   {
+			  lr2[intensity_scale][ms_mode][k][0] = ms_factor[ms_mode] * 1.0f;
+			  lr2[intensity_scale][ms_mode][k][1] = ms_factor[ms_mode] * 1.0f;
+			   }
+			   else if ((sf & 1))
+			   {
+			  lr2[intensity_scale][ms_mode][k][0] =
+				 (float) (ms_factor[ms_mode] * pow(t, (sf + 1) / 2));
+			  lr2[intensity_scale][ms_mode][k][1] = ms_factor[ms_mode] * 1.0f;
+			   }
+			   else
+			   {
+			  lr2[intensity_scale][ms_mode][k][0] = ms_factor[ms_mode] * 1.0f;
+			  lr2[intensity_scale][ms_mode][k][1] =
+				 (float) (ms_factor[ms_mode] * pow(t, sf / 2));
+			   }
+			}
+
+		  /* illegal is_pos used to do ms processing */
+			if (ms_mode == 0)
+			{			/* ms_mode = 0 */
+			   lr2[intensity_scale][ms_mode][k][0] = 1.0f;
+			   lr2[intensity_scale][ms_mode][k][1] = 0.0f;
+			}
+			else
+			{
+			 /* ms_mode = 1, in is bands is routine does ms processing */
+			   lr2[intensity_scale][ms_mode][k][0] = 1.0f;
+			   lr2[intensity_scale][ms_mode][k][1] = 1.0f;
+			}
+			k++;
+			n = n + n;
+		 }
+		  }
+	   }
+   }
+
+}
+/*-------------------------------------------------------------*/
diff --git a/codemp/mp3code/mdct.c b/codemp/mp3code/mdct.c
new file mode 100644
index 0000000..10c21cf
--- /dev/null
+++ b/codemp/mp3code/mdct.c
@@ -0,0 +1,229 @@
+/*____________________________________________________________________________
+	
+	FreeAmp - The Free MP3 Player
+
+        MP3 Decoder originally Copyright (C) 1995-1997 Xing Technology
+        Corp.  http://www.xingtech.com
+
+	Portions Copyright (C) 1998-1999 EMusic.com
+
+	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., 675 Mass Ave, Cambridge, MA 02139, USA.
+	
+	$Id: mdct.c,v 1.4 1999/10/19 07:13:09 elrod Exp $
+____________________________________________________________________________*/
+
+/****  mdct.c  ***************************************************
+
+Layer III 
+
+  cos transform for n=18, n=6
+
+computes  c[k] =  Sum( cos((pi/4*n)*(2*k+1)*(2*p+1))*f[p] )
+                k = 0, ...n-1,  p = 0...n-1
+
+
+inplace ok.
+
+******************************************************************/
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <float.h>
+#include <math.h>
+
+
+/*------ 18 point xform -------*/
+float mdct18w[18];		// effectively constant
+float mdct18w2[9];		//  "  "
+float coef[9][4];		//  "  "
+
+float mdct6_3v[6];		//  "  "
+float mdct6_3v2[3];		//  "  "
+float coef87;			//  "  "
+
+typedef struct
+{
+   float *w;
+   float *w2;
+   void *coef;
+}
+IMDCT_INIT_BLOCK;
+
+static const IMDCT_INIT_BLOCK imdct_info_18 =
+{mdct18w, mdct18w2, coef};
+static const IMDCT_INIT_BLOCK imdct_info_6 =
+{mdct6_3v, mdct6_3v2, &coef87};
+
+
+
+/*====================================================================*/
+const IMDCT_INIT_BLOCK *imdct_init_addr_18()
+{
+   return &imdct_info_18;
+}
+const IMDCT_INIT_BLOCK *imdct_init_addr_6()
+{
+   return &imdct_info_6;
+}
+/*--------------------------------------------------------------------*/
+void imdct18(float f[18])	/* 18 point */
+{
+   int p;
+   float a[9], b[9];
+   float ap, bp, a8p, b8p;
+   float g1, g2;
+
+
+   for (p = 0; p < 4; p++)
+   {
+      g1 = mdct18w[p] * f[p];
+      g2 = mdct18w[17 - p] * f[17 - p];
+      ap = g1 + g2;		// a[p]
+
+      bp = mdct18w2[p] * (g1 - g2);	// b[p]
+
+      g1 = mdct18w[8 - p] * f[8 - p];
+      g2 = mdct18w[9 + p] * f[9 + p];
+      a8p = g1 + g2;		// a[8-p]
+
+      b8p = mdct18w2[8 - p] * (g1 - g2);	// b[8-p]
+
+      a[p] = ap + a8p;
+      a[5 + p] = ap - a8p;
+      b[p] = bp + b8p;
+      b[5 + p] = bp - b8p;
+   }
+   g1 = mdct18w[p] * f[p];
+   g2 = mdct18w[17 - p] * f[17 - p];
+   a[p] = g1 + g2;
+   b[p] = mdct18w2[p] * (g1 - g2);
+
+
+   f[0] = 0.5f * (a[0] + a[1] + a[2] + a[3] + a[4]);
+   f[1] = 0.5f * (b[0] + b[1] + b[2] + b[3] + b[4]);
+
+   f[2] = coef[1][0] * a[5] + coef[1][1] * a[6] + coef[1][2] * a[7]
+      + coef[1][3] * a[8];
+   f[3] = coef[1][0] * b[5] + coef[1][1] * b[6] + coef[1][2] * b[7]
+      + coef[1][3] * b[8] - f[1];
+   f[1] = f[1] - f[0];
+   f[2] = f[2] - f[1];
+
+   f[4] = coef[2][0] * a[0] + coef[2][1] * a[1] + coef[2][2] * a[2]
+      + coef[2][3] * a[3] - a[4];
+   f[5] = coef[2][0] * b[0] + coef[2][1] * b[1] + coef[2][2] * b[2]
+      + coef[2][3] * b[3] - b[4] - f[3];
+   f[3] = f[3] - f[2];
+   f[4] = f[4] - f[3];
+
+   f[6] = coef[3][0] * (a[5] - a[7] - a[8]);
+   f[7] = coef[3][0] * (b[5] - b[7] - b[8]) - f[5];
+   f[5] = f[5] - f[4];
+   f[6] = f[6] - f[5];
+
+   f[8] = coef[4][0] * a[0] + coef[4][1] * a[1] + coef[4][2] * a[2]
+      + coef[4][3] * a[3] + a[4];
+   f[9] = coef[4][0] * b[0] + coef[4][1] * b[1] + coef[4][2] * b[2]
+      + coef[4][3] * b[3] + b[4] - f[7];
+   f[7] = f[7] - f[6];
+   f[8] = f[8] - f[7];
+
+   f[10] = coef[5][0] * a[5] + coef[5][1] * a[6] + coef[5][2] * a[7]
+      + coef[5][3] * a[8];
+   f[11] = coef[5][0] * b[5] + coef[5][1] * b[6] + coef[5][2] * b[7]
+      + coef[5][3] * b[8] - f[9];
+   f[9] = f[9] - f[8];
+   f[10] = f[10] - f[9];
+
+   f[12] = 0.5f * (a[0] + a[2] + a[3]) - a[1] - a[4];
+   f[13] = 0.5f * (b[0] + b[2] + b[3]) - b[1] - b[4] - f[11];
+   f[11] = f[11] - f[10];
+   f[12] = f[12] - f[11];
+
+   f[14] = coef[7][0] * a[5] + coef[7][1] * a[6] + coef[7][2] * a[7]
+      + coef[7][3] * a[8];
+   f[15] = coef[7][0] * b[5] + coef[7][1] * b[6] + coef[7][2] * b[7]
+      + coef[7][3] * b[8] - f[13];
+   f[13] = f[13] - f[12];
+   f[14] = f[14] - f[13];
+
+   f[16] = coef[8][0] * a[0] + coef[8][1] * a[1] + coef[8][2] * a[2]
+      + coef[8][3] * a[3] + a[4];
+   f[17] = coef[8][0] * b[0] + coef[8][1] * b[1] + coef[8][2] * b[2]
+      + coef[8][3] * b[3] + b[4] - f[15];
+   f[15] = f[15] - f[14];
+   f[16] = f[16] - f[15];
+   f[17] = f[17] - f[16];
+
+
+   return;
+}
+/*--------------------------------------------------------------------*/
+/* does 3, 6 pt dct.  changes order from f[i][window] c[window][i] */
+void imdct6_3(float f[])	/* 6 point */
+{
+   int w;
+   float buf[18];
+   float *a, *c;		// b[i] = a[3+i]
+
+   float g1, g2;
+   float a02, b02;
+
+   c = f;
+   a = buf;
+   for (w = 0; w < 3; w++)
+   {
+      g1 = mdct6_3v[0] * f[3 * 0];
+      g2 = mdct6_3v[5] * f[3 * 5];
+      a[0] = g1 + g2;
+      a[3 + 0] = mdct6_3v2[0] * (g1 - g2);
+
+      g1 = mdct6_3v[1] * f[3 * 1];
+      g2 = mdct6_3v[4] * f[3 * 4];
+      a[1] = g1 + g2;
+      a[3 + 1] = mdct6_3v2[1] * (g1 - g2);
+
+      g1 = mdct6_3v[2] * f[3 * 2];
+      g2 = mdct6_3v[3] * f[3 * 3];
+      a[2] = g1 + g2;
+      a[3 + 2] = mdct6_3v2[2] * (g1 - g2);
+
+      a += 6;
+      f++;
+   }
+
+   a = buf;
+   for (w = 0; w < 3; w++)
+   {
+      a02 = (a[0] + a[2]);
+      b02 = (a[3 + 0] + a[3 + 2]);
+      c[0] = a02 + a[1];
+      c[1] = b02 + a[3 + 1];
+      c[2] = coef87 * (a[0] - a[2]);
+      c[3] = coef87 * (a[3 + 0] - a[3 + 2]) - c[1];
+      c[1] = c[1] - c[0];
+      c[2] = c[2] - c[1];
+      c[4] = a02 - a[1] - a[1];
+      c[5] = b02 - a[3 + 1] - a[3 + 1] - c[3];
+      c[3] = c[3] - c[2];
+      c[4] = c[4] - c[3];
+      c[5] = c[5] - c[4];
+      a += 6;
+      c += 6;
+   }
+
+   return;
+}
+/*--------------------------------------------------------------------*/
diff --git a/codemp/mp3code/mhead.c b/codemp/mp3code/mhead.c
new file mode 100644
index 0000000..496ff4a
--- /dev/null
+++ b/codemp/mp3code/mhead.c
@@ -0,0 +1,328 @@
+/*____________________________________________________________________________
+	
+	FreeAmp - The Free MP3 Player
+
+        MP3 Decoder originally Copyright (C) 1995-1997 Xing Technology
+        Corp.  http://www.xingtech.com
+
+	Portions Copyright (C) 1998-1999 EMusic.com
+
+	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., 675 Mass Ave, Cambridge, MA 02139, USA.
+	
+	$Id: mhead.c,v 1.7 1999/10/19 07:13:09 elrod Exp $
+____________________________________________________________________________*/
+
+/*------------ mhead.c ----------------------------------------------
+  mpeg audio
+  extract info from mpeg header
+  portable version (adapted from c:\eco\mhead.c
+
+  add Layer III
+
+  mods 6/18/97 re mux restart, 32 bit ints
+
+  mod 5/7/98 parse mpeg 2.5
+
+---------------------------------------------------------------------*/
+#include <stdlib.h>
+#include <stdio.h>
+#include <float.h>
+#include <math.h>
+#include "mhead.h"		/* mpeg header structure */
+
+static const int mp_br_table[2][16] =
+{{0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160, 0},
+ {0, 32, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 384, 0}};
+static const int mp_sr20_table[2][4] =
+{{441, 480, 320, -999}, {882, 960, 640, -999}};
+
+static const int mp_br_tableL1[2][16] =
+{{0, 32, 48, 56, 64, 80, 96, 112, 128, 144, 160, 176, 192, 224, 256, 0},/* mpeg2 */
+ {0, 32, 64, 96, 128, 160, 192, 224, 256, 288, 320, 352, 384, 416, 448, 0}};
+
+static const int mp_br_tableL3[2][16] =
+{{0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160, 0},      /* mpeg 2 */
+ {0, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 0}};
+
+
+
+static int find_sync(unsigned char *buf, int n);
+static int sync_scan(unsigned char *buf, int n, int i0);
+static int sync_test(unsigned char *buf, int n, int isync, int padbytes);
+
+
+/*--------------------------------------------------------------*/
+int head_info(unsigned char *buf, unsigned int n, MPEG_HEAD * h)
+{
+   int framebytes;
+   int mpeg25_flag;
+  
+   if (n > 10000)
+      n = 10000;		/* limit scan for free format */
+
+
+
+   h->sync = 0;
+   //if ((buf[0] == 0xFF) && ((buf[1] & 0xF0) == 0xF0))
+   if ((buf[0] == 0xFF) && ((buf[0+1] & 0xF0) == 0xF0))
+   {
+      mpeg25_flag = 0;		// mpeg 1 & 2
+
+   }
+   else if ((buf[0] == 0xFF) && ((buf[0+1] & 0xF0) == 0xE0))
+   {
+      mpeg25_flag = 1;		// mpeg 2.5
+
+   }
+   else
+      return 0;			// sync fail
+
+   h->sync = 1;
+   if (mpeg25_flag)
+      h->sync = 2;		//low bit clear signals mpeg25 (as in 0xFFE)
+
+   h->id = (buf[0+1] & 0x08) >> 3;
+   h->option = (buf[0+1] & 0x06) >> 1;
+   h->prot = (buf[0+1] & 0x01);
+
+   h->br_index = (buf[0+2] & 0xf0) >> 4;
+   h->sr_index = (buf[0+2] & 0x0c) >> 2;
+   h->pad = (buf[0+2] & 0x02) >> 1;
+   h->private_bit = (buf[0+2] & 0x01);
+   h->mode = (buf[0+3] & 0xc0) >> 6;
+   h->mode_ext = (buf[0+3] & 0x30) >> 4;
+   h->cr = (buf[0+3] & 0x08) >> 3;
+   h->original = (buf[0+3] & 0x04) >> 2;
+   h->emphasis = (buf[0+3] & 0x03);
+
+
+// if( mpeg25_flag ) {
+ //    if( h->sr_index == 2 ) return 0;   // fail 8khz
+ //}
+
+
+/* compute framebytes for Layer I, II, III */
+   if (h->option < 1)
+      return 0;
+   if (h->option > 3)
+      return 0;
+
+   framebytes = 0;
+
+   if (h->br_index > 0)
+   {
+      if (h->option == 3)
+      {				/* layer I */
+	 framebytes =
+	    240 * mp_br_tableL1[h->id][h->br_index]
+	    / mp_sr20_table[h->id][h->sr_index];
+	 framebytes = 4 * framebytes;
+      }
+      else if (h->option == 2)
+      {				/* layer II */
+	 framebytes =
+	    2880 * mp_br_table[h->id][h->br_index]
+	    / mp_sr20_table[h->id][h->sr_index];
+      }
+      else if (h->option == 1)
+      {				/* layer III */
+	 if (h->id)
+	 {			// mpeg1
+
+	    framebytes =
+	       2880 * mp_br_tableL3[h->id][h->br_index]
+	       / mp_sr20_table[h->id][h->sr_index];
+	 }
+	 else
+	 {			// mpeg2
+
+	    if (mpeg25_flag)
+	    {			// mpeg2.2
+
+	       framebytes =
+		  2880 * mp_br_tableL3[h->id][h->br_index]
+		  / mp_sr20_table[h->id][h->sr_index];
+	    }
+	    else
+	    {
+	       framebytes =
+		  1440 * mp_br_tableL3[h->id][h->br_index]
+		  / mp_sr20_table[h->id][h->sr_index];
+	    }
+	 }
+      }
+   }
+   else
+      framebytes = find_sync(buf, n);	/* free format */
+
+  return framebytes;
+}
+
+int head_info3(unsigned char *buf, unsigned int n, MPEG_HEAD *h, int *br, unsigned int *searchForward) {
+	unsigned int pBuf = 0;
+
+	// jdw insertion...
+   while ((pBuf < n) && !((buf[pBuf] == 0xFF) && 
+          ((buf[pBuf+1] & 0xF0) == 0xF0 || (buf[pBuf+1] & 0xF0) == 0xE0))) 
+   {
+		pBuf++;
+   }
+
+   if (pBuf == n) return 0;
+
+   *searchForward = pBuf;
+   return head_info2(&(buf[pBuf]),n,h,br);
+}
+
+/*--------------------------------------------------------------*/
+int head_info2(unsigned char *buf, unsigned int n, MPEG_HEAD * h, int *br)
+{
+	int framebytes;
+	
+	/*---  return br (in bits/sec) in addition to frame bytes ---*/
+	
+	*br = 0;
+	/*-- assume fail --*/
+	framebytes = head_info(buf, n, h);
+	
+	if (framebytes == 0)
+		return 0; 
+	
+	switch (h->option)
+	{
+		case 1:	/* layer III */
+		{
+			if (h->br_index > 0)
+				*br = 1000 * mp_br_tableL3[h->id][h->br_index];
+			else
+			{
+				if (h->id)		// mpeg1
+					
+					*br = 1000 * framebytes * mp_sr20_table[h->id][h->sr_index] / (144 * 20);
+				else
+				{			// mpeg2
+					
+					if ((h->sync & 1) == 0)	//  flags mpeg25
+						
+						*br = 500 * framebytes * mp_sr20_table[h->id][h->sr_index] / (72 * 20);
+					else
+						*br = 1000 * framebytes * mp_sr20_table[h->id][h->sr_index] / (72 * 20);
+				}
+			}
+		}
+		break;
+
+		case 2:	/* layer II */
+		{
+			if (h->br_index > 0)
+				*br = 1000 * mp_br_table[h->id][h->br_index];
+			else
+				*br = 1000 * framebytes * mp_sr20_table[h->id][h->sr_index]	/ (144 * 20);
+		}
+		break;
+
+		case 3:	/* layer I */
+		{
+			if (h->br_index > 0)
+				*br = 1000 * mp_br_tableL1[h->id][h->br_index];
+			else
+				*br = 1000 * framebytes * mp_sr20_table[h->id][h->sr_index]	/ (48 * 20);
+		}
+		break;
+
+		default:
+
+			return 0;	// fuck knows what this is, but it ain't one of ours...
+	}
+		
+		
+	return framebytes;
+}
+/*--------------------------------------------------------------*/
+static int compare(unsigned char *buf, unsigned char *buf2)
+{
+   if (buf[0] != buf2[0])
+      return 0;
+   if (buf[1] != buf2[1])
+      return 0;
+   return 1;
+}
+/*----------------------------------------------------------*/
+/*-- does not scan for initial sync, initial sync assumed --*/
+static int find_sync(unsigned char *buf, int n)
+{
+   int i0, isync, nmatch, pad;
+   int padbytes, option;
+
+/* mod 4/12/95 i0 change from 72, allows as low as 8kbits for mpeg1 */
+   i0 = 24;
+   padbytes = 1;
+   option = (buf[1] & 0x06) >> 1;
+   if (option == 3)
+   {
+      padbytes = 4;
+      i0 = 24;			/* for shorter layer I frames */
+   }
+
+   pad = (buf[2] & 0x02) >> 1;
+
+   n -= 3;			/*  need 3 bytes of header  */
+
+   while (i0 < 2000)
+   {
+      isync = sync_scan(buf, n, i0);
+      i0 = isync + 1;
+      isync -= pad;
+      if (isync <= 0)
+	 return 0;
+      nmatch = sync_test(buf, n, isync, padbytes);
+      if (nmatch > 0)
+	 return isync;
+   }
+
+   return 0;
+}
+/*------------------------------------------------------*/
+/*---- scan for next sync, assume start is valid -------*/
+/*---- return number bytes to next sync ----------------*/
+static int sync_scan(unsigned char *buf, int n, int i0)
+{
+   int i;
+
+   for (i = i0; i < n; i++)
+      if (compare(buf, buf + i))
+	 return i;
+
+   return 0;
+}
+/*------------------------------------------------------*/
+/*- test consecutative syncs, input isync without pad --*/
+static int sync_test(unsigned char *buf, int n, int isync, int padbytes)
+{
+   int i, nmatch, pad;
+
+   nmatch = 0;
+   for (i = 0;;)
+   {
+      pad = padbytes * ((buf[i + 2] & 0x02) >> 1);
+      i += (pad + isync);
+      if (i > n)
+	 break;
+      if (!compare(buf, buf + i))
+	 return -nmatch;
+      nmatch++;
+   }
+   return nmatch;
+}
diff --git a/codemp/mp3code/mhead.h b/codemp/mp3code/mhead.h
new file mode 100644
index 0000000..3a526b1
--- /dev/null
+++ b/codemp/mp3code/mhead.h
@@ -0,0 +1,102 @@
+#ifndef MHEAD_H
+#define MHEAD_H
+
+
+/*____________________________________________________________________________
+	
+	FreeAmp - The Free MP3 Player
+
+        MP3 Decoder originally Copyright (C) 1995-1997 Xing Technology
+        Corp.  http://www.xingtech.com
+
+	Portions Copyright (C) 1998 EMusic.com
+
+	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., 675 Mass Ave, Cambridge, MA 02139, USA.
+	
+	$Id: mhead.h,v 1.3 1999/10/19 07:13:08 elrod Exp $
+____________________________________________________________________________*/
+
+/* portable copy of eco\mhead.h */
+/* mpeg audio header   */
+typedef struct
+{
+   int sync;			/* 1 if valid sync */
+   int id;
+   int option;
+   int prot;
+   int br_index;
+   int sr_index;
+   int pad;
+   int private_bit;
+   int mode;
+   int mode_ext;
+   int cr;
+   int original;
+   int emphasis;
+}
+MPEG_HEAD;
+
+/* portable mpeg audio decoder, decoder functions */
+
+#ifndef IN_OUT
+#include "small_header.h"
+#endif
+
+typedef struct
+{
+   int channels;
+   int outvalues;
+   long samprate;
+   int bits;
+   int framebytes;
+   int type;
+}
+DEC_INFO;
+
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+   int head_info(unsigned char *buf, unsigned int n, MPEG_HEAD * h);
+   int head_info2(unsigned char *buf,
+	   unsigned int n, MPEG_HEAD * h, int *br);
+	int head_info3(unsigned char *buf, unsigned int n, MPEG_HEAD *h, int*br, unsigned int *searchForward);
+/* head_info returns framebytes > 0 for success */
+/* audio_decode_init returns 1 for success, 0 for fail */
+/* audio_decode returns in_bytes = 0 on sync loss */
+
+   int audio_decode_init(MPEG_HEAD * h, int framebytes_arg,
+		   int reduction_code, int transform_code, int convert_code,
+			 int freq_limit);
+   void audio_decode_info(DEC_INFO * info);
+   IN_OUT audio_decode(unsigned char *bs, short *pcm, unsigned char *pNextByteAfterData);
+
+   int audio_decode8_init(MPEG_HEAD * h, int framebytes_arg,
+		   int reduction_code, int transform_code, int convert_code,
+			  int freq_limit);
+   void audio_decode8_info(DEC_INFO * info);
+   IN_OUT audio_decode8(unsigned char *bs, short *pcmbuf);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#pragma warning(disable:4711)	// function 'xxxx' selected for automatic inline expansion
+
+#endif	// #ifndef MHEAD_H
+
diff --git a/codemp/mp3code/mp3struct.h b/codemp/mp3code/mp3struct.h
new file mode 100644
index 0000000..74299a5
--- /dev/null
+++ b/codemp/mp3code/mp3struct.h
@@ -0,0 +1,140 @@
+// Filename:	mp3struct.h
+//
+// this file is my struct to gather all loose MP3 global vars into one struct so we can do multiple-stream decompression
+//
+
+#ifndef MP3STRUCT_H
+#define MP3STRUCT_H
+
+#pragma warning (disable : 4201 )	// nonstandard extension used : nameless struct/union
+
+#include "small_header.h"	// for SAMPLE and IN_OUT
+
+typedef void (*SBT_FUNCTION) (float *sample, short *pcm, int n);
+typedef void (*XFORM_FUNCTION) (void *pcm, int igr);
+typedef IN_OUT(*DECODE_FUNCTION) (unsigned char *bs, unsigned char *pcm);
+
+typedef struct
+{
+	union
+	{
+		struct
+		{
+			SBT_FUNCTION sbt;	
+
+			float	cs_factor[3][64];	// 768 bytes
+
+			int		nbat[4];
+			int		bat[4][16];
+			int		max_sb;		
+			int		stereo_sb;
+			int		bit_skip;
+
+			float*	cs_factorL1;
+			int		nbatL1;
+
+		};//L1_2;
+
+		struct 
+		{
+			SBT_FUNCTION sbt_L3;
+			XFORM_FUNCTION Xform;
+			DECODE_FUNCTION decode_function;
+
+			SAMPLE	sample[2][2][576];		// if this isn't kept per stream then the decode breaks up
+
+		// the 4k version of these 2 seems to work for everything, but I'm reverting to original 8k for safety jic.
+		//
+		#define NBUF (8*1024)
+		#define BUF_TRIGGER (NBUF-1500)
+//		#define NBUF (4096)	// 2048 works for all except 133+ kbps VBR files, 4096 copes with these
+//		#define BUF_TRIGGER ((NBUF/4)*3)
+
+			unsigned char buf[NBUF];
+			int		buf_ptr0;
+			int		buf_ptr1;
+			int		main_pos_bit;
+
+
+			int		band_limit_nsb;
+			int			nBand[2][22];		/* [long/short][cb] */
+			int			sfBandIndex[2][22];		/* [long/short][cb] */
+			int			half_outbytes;
+			int			crcbytes;
+			int			nchan;
+			int			ms_mode;
+			int			is_mode;
+			unsigned int zero_level_pcm;
+			int			mpeg25_flag;
+			int			band_limit;
+			int			band_limit21;
+			int			band_limit12;
+			int			gain_adjust;
+			int			ncbl_mixed;
+		};//L3;
+	};
+	// from csbt.c...
+	//
+	// if this isn't kept per stream then the decode breaks up
+	signed int	vb_ptr;			// 
+	signed int	vb2_ptr;		// 
+	float		vbuf[512];		//
+	float		vbuf2[512];		// this can be lost if we stick to mono samples
+
+	// L3 only...
+	//
+	int			sr_index;	// L3 only (99%)
+	int			id;
+
+	// any type...
+	//
+	int			outvalues;
+	int			outbytes;
+	int			framebytes;
+	int			pad;
+	int			nsb_limit;	
+
+	// stuff added now that the game uses streaming MP3s...
+	//
+	byte		*pbSourceData;			// a useful dup ptr only, this whole struct will be owned by an sfx_t struct that has the actual data ptr field
+	int			iSourceBytesRemaining;
+	int			iSourceReadIndex;
+	int			iSourceFrameBytes;
+#ifdef _DEBUG
+	int			iSourceFrameCounter;	// not really important
+#endif
+	int			iBytesDecodedTotal;
+	int			iBytesDecodedThisPacket;// not sure how useful this will be, it's only per-frame, so will always be full frame size (eg 2304 or below for mono) except possibly for the last frame?
+
+	int			iRewind_FinalReductionCode;
+	int			iRewind_FinalConvertCode;
+	int			iRewind_SourceBytesRemaining;
+	int			iRewind_SourceReadIndex;
+	byte		bDecodeBuffer[2304*2];	// *2 to allow for stereo now
+	int			iCopyOffset;			// used for painting to DMA-feeder, since 2304 won't match the size it wants
+
+	// some new stuff added for dynamic music, to allow "how many seconds left to play" queries...
+	//
+	// ( m_lengthInSeconds = ((iUnpackedDataLength / iRate) / iChannels) / iWidth; )
+	//
+	// Note that these fields are only valid/initialised if MP3Stream_InitPlayingTimeFields() was called.
+	//	If not, this->iTimeQuery_UnpackedLength will be zero.
+	//
+	int			iTimeQuery_UnpackedLength;	
+	int			iTimeQuery_SampleRate;
+	int			iTimeQuery_Channels;
+	int			iTimeQuery_Width;
+
+} MP3STREAM, *LP_MP3STREAM;
+
+
+extern LP_MP3STREAM pMP3Stream;
+extern int bFastEstimateOnly;
+
+#pragma warning (default : 4201 )	// nonstandard extension used : nameless struct/union
+#pragma warning (disable : 4711 )	// function 'xxxx' selected for automatic inline expansion
+
+#endif	// #ifndef MP3STRUCT_H
+
+////////////////// eof /////////////////////
+
diff --git a/codemp/mp3code/msis.c b/codemp/mp3code/msis.c
new file mode 100644
index 0000000..6e7ef24
--- /dev/null
+++ b/codemp/mp3code/msis.c
@@ -0,0 +1,296 @@
+/*____________________________________________________________________________
+	
+	FreeAmp - The Free MP3 Player
+
+        MP3 Decoder originally Copyright (C) 1995-1997 Xing Technology
+        Corp.  http://www.xingtech.com
+
+	Portions Copyright (C) 1998-1999 EMusic.com
+
+	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., 675 Mass Ave, Cambridge, MA 02139, USA.
+	
+	$Id: msis.c,v 1.4 1999/10/19 07:13:09 elrod Exp $
+____________________________________________________________________________*/
+
+/****  msis.c  ***************************************************
+  Layer III  
+ antialias, ms and is stereo precessing
+
+**** is_process assumes never switch 
+      from short to long in is region *****
+     
+is_process does ms or stereo in "forbidded sf regions"
+    //ms_mode = 0 
+    lr[0][i][0] = 1.0f;
+    lr[0][i][1] = 0.0f;
+    // ms_mode = 1, in is bands is routine does ms processing 
+    lr[1][i][0] = 1.0f;
+    lr[1][i][1] = 1.0f;
+
+******************************************************************/
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <float.h>
+#include <math.h>
+#include "L3.h"
+
+#include "mp3struct.h"
+
+typedef float ARRAY2[2];
+typedef float ARRAY8_2[8][2];
+
+float csa[8][2];		/* antialias */		// effectively constant
+
+/* pMP3Stream->nBand[0] = long, pMP3Stream->nBand[1] = short */
+////@@@@extern int pMP3Stream->nBand[2][22];
+////@@@@extern int pMP3Stream->sfBandIndex[2][22];	/* [long/short][cb] */
+
+/* intensity stereo */
+/* if ms mode quant pre-scales all values by 1.0/sqrt(2.0) ms_mode in table
+   compensates   */
+static float lr[2][8][2];	/* [ms_mode 0/1][sf][left/right]  */	// effectively constant
+
+
+/* intensity stereo MPEG2 */
+/* lr2[intensity_scale][ms_mode][sflen_offset+sf][left/right] */
+typedef float ARRAY2_64_2[2][64][2];
+typedef float ARRAY64_2[64][2];
+static float lr2[2][2][64][2];		// effectively constant
+
+
+/*===============================================================*/
+ARRAY2 *alias_init_addr()
+{
+   return csa;
+}
+/*-----------------------------------------------------------*/
+ARRAY8_2 *msis_init_addr()
+{
+/*-------
+pi = 4.0*atan(1.0);
+t = pi/12.0;
+for(i=0;i<7;i++) {
+    s = sin(i*t);
+    c = cos(i*t);
+    // ms_mode = 0 
+    lr[0][i][0] = (float)(s/(s+c));
+    lr[0][i][1] = (float)(c/(s+c));
+    // ms_mode = 1 
+    lr[1][i][0] = (float)(sqrt(2.0)*(s/(s+c)));
+    lr[1][i][1] = (float)(sqrt(2.0)*(c/(s+c)));
+}
+//sf = 7 
+//ms_mode = 0 
+lr[0][i][0] = 1.0f;
+lr[0][i][1] = 0.0f;
+// ms_mode = 1, in is bands is routine does ms processing 
+lr[1][i][0] = 1.0f;
+lr[1][i][1] = 1.0f;
+------------*/
+
+   return lr;
+}
+/*-------------------------------------------------------------*/
+ARRAY2_64_2 *msis_init_addr_MPEG2()
+{
+   return lr2;
+}
+/*===============================================================*/
+void antialias(float x[], int n)
+{
+   int i, k;
+   float a, b;
+
+   for (k = 0; k < n; k++)
+   {
+      for (i = 0; i < 8; i++)
+      {
+	 a = x[17 - i];
+	 b = x[18 + i];
+	 x[17 - i] = a * csa[i][0] - b * csa[i][1];
+	 x[18 + i] = b * csa[i][0] + a * csa[i][1];
+      }
+      x += 18;
+   }
+}
+/*===============================================================*/
+void ms_process(float x[][1152], int n)		/* sum-difference stereo */
+{
+   int i;
+   float xl, xr;
+
+/*-- note: sqrt(2) done scaling by dequant ---*/
+   for (i = 0; i < n; i++)
+   {
+      xl = x[0][i] + x[1][i];
+      xr = x[0][i] - x[1][i];
+      x[0][i] = xl;
+      x[1][i] = xr;
+   }
+   return;
+}
+/*===============================================================*/
+void is_process_MPEG1(float x[][1152],	/* intensity stereo */
+		      SCALEFACT * sf,
+		      CB_INFO cb_info[2],	/* [ch] */
+		      int nsamp, int ms_mode)
+{
+   int i, j, n, cb, w;
+   float fl, fr;
+   int m;
+   int isf;
+   float fls[3], frs[3];
+   int cb0;
+
+
+   cb0 = cb_info[1].cbmax;	/* start at end of right */
+   i = pMP3Stream->sfBandIndex[cb_info[1].cbtype][cb0];
+   cb0++;
+   m = nsamp - i;		/* process to len of left */
+
+   if (cb_info[1].cbtype)
+      goto short_blocks;
+/*------------------------*/
+/* long_blocks: */
+   for (cb = cb0; cb < 21; cb++)
+   {
+      isf = sf->l[cb];
+      n = pMP3Stream->nBand[0][cb];
+      fl = lr[ms_mode][isf][0];
+      fr = lr[ms_mode][isf][1];
+      for (j = 0; j < n; j++, i++)
+      {
+	 if (--m < 0)
+	    goto exit;
+	 x[1][i] = fr * x[0][i];
+	 x[0][i] = fl * x[0][i];
+      }
+   }
+   return;
+/*------------------------*/
+ short_blocks:
+   for (cb = cb0; cb < 12; cb++)
+   {
+      for (w = 0; w < 3; w++)
+      {
+	 isf = sf->s[w][cb];
+	 fls[w] = lr[ms_mode][isf][0];
+	 frs[w] = lr[ms_mode][isf][1];
+      }
+      n = pMP3Stream->nBand[1][cb];
+      for (j = 0; j < n; j++)
+      {
+	 m -= 3;
+	 if (m < 0)
+	    goto exit;
+	 x[1][i] = frs[0] * x[0][i];
+	 x[0][i] = fls[0] * x[0][i];
+	 x[1][1 + i] = frs[1] * x[0][1 + i];
+	 x[0][1 + i] = fls[1] * x[0][1 + i];
+	 x[1][2 + i] = frs[2] * x[0][2 + i];
+	 x[0][2 + i] = fls[2] * x[0][2 + i];
+	 i += 3;
+      }
+   }
+
+ exit:
+   return;
+}
+/*===============================================================*/
+void is_process_MPEG2(float x[][1152],	/* intensity stereo */
+		      SCALEFACT * sf,
+		      CB_INFO cb_info[2],	/* [ch] */
+		      IS_SF_INFO * is_sf_info,
+		      int nsamp, int ms_mode)
+{
+   int i, j, k, n, cb, w;
+   float fl, fr;
+   int m;
+   int isf;
+   int il[21];
+   int tmp;
+   int r;
+   ARRAY2 *lr;
+   int cb0, cb1;
+
+   lr = lr2[is_sf_info->intensity_scale][ms_mode];
+
+   if (cb_info[1].cbtype)
+      goto short_blocks;
+
+/*------------------------*/
+/* long_blocks: */
+   cb0 = cb_info[1].cbmax;	/* start at end of right */
+   i = pMP3Stream->sfBandIndex[0][cb0];
+   m = nsamp - i;		/* process to len of left */
+/* gen sf info */
+   for (k = r = 0; r < 3; r++)
+   {
+      tmp = (1 << is_sf_info->slen[r]) - 1;
+      for (j = 0; j < is_sf_info->nr[r]; j++, k++)
+	 il[k] = tmp;
+   }
+   for (cb = cb0 + 1; cb < 21; cb++)
+   {
+      isf = il[cb] + sf->l[cb];
+      fl = lr[isf][0];
+      fr = lr[isf][1];
+      n = pMP3Stream->nBand[0][cb];
+      for (j = 0; j < n; j++, i++)
+      {
+	 if (--m < 0)
+	    goto exit;
+	 x[1][i] = fr * x[0][i];
+	 x[0][i] = fl * x[0][i];
+      }
+   }
+   return;
+/*------------------------*/
+ short_blocks:
+
+   for (k = r = 0; r < 3; r++)
+   {
+      tmp = (1 << is_sf_info->slen[r]) - 1;
+      for (j = 0; j < is_sf_info->nr[r]; j++, k++)
+	 il[k] = tmp;
+   }
+
+   for (w = 0; w < 3; w++)
+   {
+      cb0 = cb_info[1].cbmax_s[w];	/* start at end of right */
+      i = pMP3Stream->sfBandIndex[1][cb0] + w;
+      cb1 = cb_info[0].cbmax_s[w];	/* process to end of left */
+
+      for (cb = cb0 + 1; cb <= cb1; cb++)
+      {
+	 isf = il[cb] + sf->s[w][cb];
+	 fl = lr[isf][0];
+	 fr = lr[isf][1];
+	 n = pMP3Stream->nBand[1][cb];
+	 for (j = 0; j < n; j++)
+	 {
+	    x[1][i] = fr * x[0][i];
+	    x[0][i] = fl * x[0][i];
+	    i += 3;
+	 }
+      }
+
+   }
+
+ exit:
+   return;
+}
+/*===============================================================*/
diff --git a/codemp/mp3code/port.h b/codemp/mp3code/port.h
new file mode 100644
index 0000000..78ad088
--- /dev/null
+++ b/codemp/mp3code/port.h
@@ -0,0 +1,80 @@
+/*____________________________________________________________________________
+	
+	FreeAmp - The Free MP3 Player
+
+        MP3 Decoder originally Copyright (C) 1995-1997 Xing Technology
+        Corp.  http://www.xingtech.com
+
+	Portions Copyright (C) 1998-1999 EMusic.com
+
+	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., 675 Mass Ave, Cambridge, MA 02139, USA.
+	
+	$Id: port.h,v 1.2 1999/10/19 07:13:08 elrod Exp $
+____________________________________________________________________________*/
+
+#ifndef O_BINARY
+#define O_BINARY 0
+#endif
+
+
+/*--- no kb function unless DOS ---*/
+
+#ifndef KB_OK
+#ifdef __MSDOS__
+#define KB_OK
+#endif
+#ifdef _CONSOLE
+#define KB_OK
+#endif
+#endif
+
+/*-- no pcm conversion to wave required 
+ if short = 16 bits and little endian ---*/
+
+/* mods 1/9/97 LITTLE_SHORT16 detect */
+
+#ifndef LITTLE_SHORT16
+  #ifdef __MSDOS__
+    #undef LITTLE_SHORT16
+    #define LITTLE_SHORT16
+  #endif
+  #ifdef WIN32
+    #undef LITTLE_SHORT16
+    #define LITTLE_SHORT16
+  #endif
+  #ifdef _M_IX86
+    #undef LITTLE_SHORT16
+    #define LITTLE_SHORT16
+  #endif
+#endif
+
+
+// JDW //
+//#ifdef LITTLE_SHORT16
+//#define cvt_to_wave_init(a)
+//#define cvt_to_wave(a, b)  b
+//#else
+//void cvt_to_wave_init(int bits);
+//unsigned int cvt_to_wave(void *a, unsigned int b);
+//
+//#endif
+#ifdef LITTLE_SHORT16
+#define cvt_to_wave_init(a)
+#define cvt_to_wave(a, b) b
+#else
+void cvt_to_wave_init(int);
+unsigned int cvt_to_wave(unsigned char *,unsigned int);
+#endif
+
diff --git a/codemp/mp3code/small_header.h b/codemp/mp3code/small_header.h
new file mode 100644
index 0000000..bfbe7cf
--- /dev/null
+++ b/codemp/mp3code/small_header.h
@@ -0,0 +1,34 @@
+// Filename:-	small_header.h
+//
+// This file is just used so I can isolate a few small structs from various horrible MP3 header files without
+//	externalising code protos etc. This can now be included by both main game sound code (through sfx_t) and MP3 C code.
+//
+
+#ifndef SMALL_HEADER_H
+#define SMALL_HEADER_H
+
+
+typedef union
+{
+   int s;
+   float x;
+}
+SAMPLE;
+
+typedef struct
+{
+   int in_bytes;
+   int out_bytes;
+}
+IN_OUT;
+
+#ifdef WIN32 // Damn linux gcc isn't detecting byte as defined
+#ifndef byte
+typedef unsigned char byte;
+#endif
+#endif
+
+#endif	// #ifndef SMALL_HEADER_H
+
+/////////////// eof ////////////
+
diff --git a/codemp/mp3code/tableawd.h b/codemp/mp3code/tableawd.h
new file mode 100644
index 0000000..4f08dd7
--- /dev/null
+++ b/codemp/mp3code/tableawd.h
@@ -0,0 +1,93 @@
+/*____________________________________________________________________________
+	
+	FreeAmp - The Free MP3 Player
+
+        MP3 Decoder originally Copyright (C) 1995-1997 Xing Technology
+        Corp.  http://www.xingtech.com
+
+	Portions Copyright (C) 1998 EMusic.com
+
+	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., 675 Mass Ave, Cambridge, MA 02139, USA.
+	
+	$Id: tableawd.h,v 1.2 1999/10/19 07:13:08 elrod Exp $
+____________________________________________________________________________*/
+
+/* decoder analysis window gen by dinit.c (asm version table gen) */
+0.000000000f, 0.000442505f, -0.003250122f, 0.007003784f,
+-0.031082151f, 0.078628540f, -0.100311279f, 0.572036743f,
+-1.144989014f, -0.572036743f, -0.100311279f, -0.078628540f,
+-0.031082151f, -0.007003784f, -0.003250122f, -0.000442505f,
+0.000015259f, 0.000473022f, -0.003326416f, 0.007919312f,
+-0.030517576f, 0.084182739f, -0.090927124f, 0.600219727f,
+-1.144287109f, -0.543823242f, -0.108856201f, -0.073059082f,
+-0.031478882f, -0.006118774f, -0.003173828f, -0.000396729f,
+0.000015259f, 0.000534058f, -0.003387451f, 0.008865356f,
+-0.029785154f, 0.089706421f, -0.080688477f, 0.628295898f,
+-1.142211914f, -0.515609741f, -0.116577141f, -0.067520142f,
+-0.031738281f, -0.005294800f, -0.003082275f, -0.000366211f,
+0.000015259f, 0.000579834f, -0.003433228f, 0.009841919f,
+-0.028884888f, 0.095169067f, -0.069595337f, 0.656219482f,
+-1.138763428f, -0.487472534f, -0.123474121f, -0.061996460f,
+-0.031845093f, -0.004486084f, -0.002990723f, -0.000320435f,
+0.000015259f, 0.000625610f, -0.003463745f, 0.010848999f,
+-0.027801514f, 0.100540161f, -0.057617184f, 0.683914185f,
+-1.133926392f, -0.459472656f, -0.129577637f, -0.056533810f,
+-0.031814575f, -0.003723145f, -0.002899170f, -0.000289917f,
+0.000015259f, 0.000686646f, -0.003479004f, 0.011886597f,
+-0.026535034f, 0.105819702f, -0.044784546f, 0.711318970f,
+-1.127746582f, -0.431655884f, -0.134887695f, -0.051132202f,
+-0.031661987f, -0.003005981f, -0.002792358f, -0.000259399f,
+0.000015259f, 0.000747681f, -0.003479004f, 0.012939452f,
+-0.025085449f, 0.110946655f, -0.031082151f, 0.738372803f,
+-1.120223999f, -0.404083252f, -0.139450073f, -0.045837402f,
+-0.031387329f, -0.002334595f, -0.002685547f, -0.000244141f,
+0.000030518f, 0.000808716f, -0.003463745f, 0.014022826f,
+-0.023422241f, 0.115921021f, -0.016510010f, 0.765029907f,
+-1.111373901f, -0.376800537f, -0.143264771f, -0.040634155f,
+-0.031005858f, -0.001693726f, -0.002578735f, -0.000213623f,
+0.000030518f, 0.000885010f, -0.003417969f, 0.015121460f,
+-0.021575928f, 0.120697014f, -0.001068115f, 0.791213989f,
+-1.101211548f, -0.349868774f, -0.146362305f, -0.035552979f,
+-0.030532837f, -0.001098633f, -0.002456665f, -0.000198364f,
+0.000030518f, 0.000961304f, -0.003372192f, 0.016235352f,
+-0.019531250f, 0.125259399f, 0.015228271f, 0.816864014f,
+-1.089782715f, -0.323318481f, -0.148773193f, -0.030609131f,
+-0.029937742f, -0.000549316f, -0.002349854f, -0.000167847f,
+0.000030518f, 0.001037598f, -0.003280640f, 0.017349243f,
+-0.017257690f, 0.129562378f, 0.032379150f, 0.841949463f,
+-1.077117920f, -0.297210693f, -0.150497437f, -0.025817871f,
+-0.029281614f, -0.000030518f, -0.002243042f, -0.000152588f,
+0.000045776f, 0.001113892f, -0.003173828f, 0.018463135f,
+-0.014801024f, 0.133590698f, 0.050354004f, 0.866363525f,
+-1.063217163f, -0.271591187f, -0.151596069f, -0.021179199f,
+-0.028533936f, 0.000442505f, -0.002120972f, -0.000137329f,
+0.000045776f, 0.001205444f, -0.003051758f, 0.019577026f,
+-0.012115479f, 0.137298584f, 0.069168091f, 0.890090942f,
+-1.048156738f, -0.246505737f, -0.152069092f, -0.016708374f,
+-0.027725220f, 0.000869751f, -0.002014160f, -0.000122070f,
+0.000061035f, 0.001296997f, -0.002883911f, 0.020690918f,
+-0.009231566f, 0.140670776f, 0.088775635f, 0.913055420f,
+-1.031936646f, -0.221984863f, -0.151962280f, -0.012420653f,
+-0.026840210f, 0.001266479f, -0.001907349f, -0.000106812f,
+0.000061035f, 0.001388550f, -0.002700806f, 0.021789551f,
+-0.006134033f, 0.143676758f, 0.109161377f, 0.935195923f,
+-1.014617920f, -0.198059082f, -0.151306152f, -0.008316040f,
+-0.025909424f, 0.001617432f, -0.001785278f, -0.000106812f,
+0.000076294f, 0.001480103f, -0.002487183f, 0.022857666f,
+-0.002822876f, 0.146255493f, 0.130310059f, 0.956481934f,
+-0.996246338f, -0.174789429f, -0.150115967f, -0.004394531f,
+-0.024932859f, 0.001937866f, -0.001693726f, -0.000091553f,
+-0.001586914f, -0.023910521f, -0.148422241f, -0.976852417f,
+0.152206421f, 0.000686646f, -0.002227783f, 0.000076294f,
diff --git a/codemp/mp3code/towave.c b/codemp/mp3code/towave.c
new file mode 100644
index 0000000..9f3f717
--- /dev/null
+++ b/codemp/mp3code/towave.c
@@ -0,0 +1,760 @@
+/*____________________________________________________________________________
+	
+	FreeAmp - The Free MP3 Player
+
+        MP3 Decoder originally Copyright (C) 1995-1997 Xing Technology
+        Corp.  http://www.xingtech.com
+
+	Portions Copyright (C) 1998-1999 EMusic.com
+
+	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., 675 Mass Ave, Cambridge, MA 02139, USA.
+	
+	$Id: towave.c,v 1.3 1999/10/19 07:13:09 elrod Exp $
+____________________________________________________________________________*/
+
+/* ------------------------------------------------------------------------
+
+      NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE
+
+        This file exists for reference only. It is not actually used
+        in the FreeAmp project. There is no need to mess with this 
+        file. There is no need to flatten the beavers, either.
+
+      NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE
+
+/*---- towave.c --------------------------------------------
+  32 bit version only
+
+decode mpeg Layer I/II/III file using portable ANSI C decoder,
+output to pcm wave file.
+
+mod 8/19/98 decode 22 sf bands
+
+mod 5/14/98  allow mpeg25 (dec8 not supported for mpeg25 samp rate)
+
+mod 3/4/98 bs_trigger  bs_bufbytes  made signed, unsigned may 
+            not terminate properly.  Also extra test in bs_fill.
+
+mod 8/6/96 add 8 bit output to standard decoder
+
+ver 1.4 mods 7/18/96 32 bit and add asm option
+
+mods 6/29/95  allow MS wave file for u-law.  bugfix u-law table dec8.c
+
+mods 2/95 add sample rate reduction, freq_limit and conversions.
+          add _decode8 for 8Ks output, 16bit 8bit, u-law output.
+          add additional control parameters to init.
+          add _info function
+
+mod 5/12/95 add quick window cwinq.c
+
+mod 5/19/95 change from stream io to handle io
+
+mod 11/16/95 add Layer I
+
+mod 1/5/95   integer overflow mod iup.c
+
+ver 1.3
+mod 2/5/96   portability mods
+             drop Tom and Gloria pcm file types
+
+ver 2.0
+mod 1/7/97   Layer 3 (float mpeg-1 only)
+    2/6/97   Layer 3 MPEG-2
+
+ver 3.01     Layer III bugfix crc problem 8/18/97
+ver 3.02     Layer III fix wannabe.mp3 problem 10/9/97
+ver 3.03     allow mpeg 2.5  5/14/98
+  
+Decoder functions for _decode8 are defined in dec8.c.  Useage
+is same as regular decoder.
+
+Towave illustrates use of decoder.  Towave converts
+mpeg audio files to 16 bit (short) pcm.  Default pcm file
+format is wave. Other formats can be accommodated by
+adding alternative write_pcm_header and write_pcm_tailer
+functions.  The functions kbhit and getch used in towave.c
+may not port to other systems.
+
+The decoder handles all mpeg1 and mpeg2 Layer I/II  bitstreams.  
+
+For compatability with the asm decoder and future C versions,
+source code users are discouraged from making modifications
+to the decoder proper.  MS Windows applications can use wrapper
+functions in a separate module if decoder functions need to
+be exported.
+
+NOTE additional control parameters.
+
+mod 8/6/96 standard decoder adds 8 bit output
+
+decode8 (8Ks output) convert_code:
+   convert_code = 4*bit_code + chan_code
+       bit_code:   1 = 16 bit linear pcm
+                   2 =  8 bit (unsigned) linear pcm
+                   3 = u-law (8 bits unsigned)
+       chan_code:  0 = convert two chan to mono
+                   1 = convert two chan to mono
+                   2 = convert two chan to left chan
+                   3 = convert two chan to right chan
+
+decode (standard decoder) convert_code:
+             0 = two chan output
+             1 = convert two chan to mono
+             2 = convert two chan to left chan
+             3 = convert two chan to right chan
+     or with 8 = 8 bit output 
+          (other bits ignored)
+
+decode (standard decoder) reduction_code:
+             0 = full sample rate output
+             1 = half rate
+             2 = quarter rate
+
+-----------------------------------------------------------*/
+#include <stdlib.h>
+#include <stdio.h>
+#include <float.h>
+#include <math.h>
+#include <string.h>
+#ifdef WIN32
+#include <io.h>
+#endif
+#include <fcntl.h>		/* file open flags */
+#include <sys/types.h>		/* someone wants for port */
+#include <sys/stat.h>		/* forward slash for portability */
+#include "mhead.h"		/* mpeg header structure, decode protos */
+
+#include "port.h"
+
+// JDW
+#ifdef __linux__
+#include <sys/ioctl.h>
+#include <sys/soundcard.h>
+#include <fcntl.h>
+#include <errno.h>
+#endif
+// JDW
+
+#include "mp3struct.h"
+#include <assert.h>
+
+
+#ifndef byte
+typedef unsigned char byte;
+#endif
+
+
+
+typedef struct id3v1_1 {
+    char id[3];
+    char title[30];		// <file basename>
+    char artist[30];	// "Raven Software"
+    char album[30];		// "#UNCOMP %d"		// needed
+    char year[4];		// "2000"
+    char comment[28];	// "#MAXVOL %g"		// needed
+    char zero;
+    char track;
+    char genre;
+} id3v1_1;	// 128 bytes in size
+
+id3v1_1 *gpTAG;
+#define BYTESREMAINING_ACCOUNT_FOR_REAR_TAG(_pvData, _iBytesRemaining)								\
+																									\
+	/* account for trailing ID3 tag in _iBytesRemaining */											\
+	gpTAG = (id3v1_1*) (((byte *)_pvData + _iBytesRemaining)-sizeof(id3v1_1));	/* sizeof = 128	*/	\
+	if (!strncmp(gpTAG->id, "TAG", 3))																\
+	{																								\
+		_iBytesRemaining -= sizeof(id3v1_1);														\
+	}
+
+
+
+
+
+/********  pcm buffer ********/
+
+#define PCM_BUFBYTES  60000U	// more than enough to cover the largest that one packet will ever expand to
+char PCM_Buffer[PCM_BUFBYTES];	// better off being declared, so we don't do mallocs in this module (MAC reasons)
+
+   typedef struct
+   {
+      int (*decode_init) (MPEG_HEAD * h, int framebytes_arg,
+			  int reduction_code, int transform_code,
+			  int convert_code, int freq_limit);
+      void (*decode_info) (DEC_INFO * info);      
+	  IN_OUT(*decode) (unsigned char *bs, short *pcm, unsigned char *pNextByteAfterData);
+   }
+   AUDIO;
+   
+#if 0
+   // stuff this...
+   static AUDIO audio_table[2][2] =
+   {
+      {
+	 {audio_decode_init, audio_decode_info, audio_decode},
+	 {audio_decode8_init, audio_decode8_info, audio_decode8},
+      },
+      {
+	 {i_audio_decode_init, i_audio_decode_info, i_audio_decode},
+	 {audio_decode8_init, audio_decode8_info, audio_decode8},
+      }
+   };
+#else
+   static AUDIO audio_table[2][2] =
+   {
+      {
+		{audio_decode_init, audio_decode_info, audio_decode},
+		{audio_decode_init, audio_decode_info, audio_decode},
+      },
+      {
+		{audio_decode_init, audio_decode_info, audio_decode},
+		{audio_decode_init, audio_decode_info, audio_decode},			
+      }
+   };
+#endif
+
+   static const AUDIO audio = {audio_decode_init, audio_decode_info, audio_decode};	//audio_table[0][0];
+
+
+// Do NOT change these, ever!!!!!!!!!!!!!!!!!!
+//
+const int reduction_code	= 0;		// unpack at full sample rate output
+const int convert_code_mono	= 1;		
+const int convert_code_stereo = 0;
+const int freq_limit		= 24000;	// no idea what this is about, but it's always this value so...
+
+// the entire decode mechanism uses this now...
+//
+MP3STREAM _MP3Stream;
+LP_MP3STREAM pMP3Stream = &_MP3Stream;
+int bFastEstimateOnly = 0;	// MUST DEFAULT TO THIS VALUE!!!!!!!!!
+
+
+// char *return is NZ for any errors (no trailing CR!)
+//
+char *C_MP3_IsValid(void *pvData, int iDataLen, int bStereoDesired)
+{
+//	char sTemp[1024];	/////////////////////////////////////////////////
+	unsigned int iRealDataStart;
+	MPEG_HEAD head;
+	DEC_INFO  decinfo;
+
+	int iBitRate;
+	int iFrameBytes;
+
+//#ifdef _DEBUG
+//	int iIgnoreThisForNowIJustNeedItToBreakpointOnToReadAValue = sizeof(MP3STREAM);
+//#endif
+
+	memset(pMP3Stream,0,sizeof(*pMP3Stream));
+
+	iFrameBytes = head_info3( pvData, iDataLen/2, &head, &iBitRate, &iRealDataStart);
+	if (iFrameBytes == 0)
+	{
+		return "MP3ERR: Bad or unsupported file!";
+	}
+
+	// check for files with bad frame unpack sizes (that would crash the game), or stereo files.
+	//
+	// although the decoder can convert stereo to mono (apparently), we want to know about stereo files
+	//	because they're a waste of source space... (all FX are mono, and moved via panning)
+	//
+	if (head.mode != 3 && !bStereoDesired)	//3 seems to mean mono
+	{
+		if (iDataLen > 98000) {	// we'll allow it for small files even if stereo
+			return "MP3ERR: Sound file is stereo!";
+		}
+	}		
+	if (audio.decode_init(&head, iFrameBytes, reduction_code, iRealDataStart, bStereoDesired?convert_code_stereo:convert_code_mono, freq_limit))
+	{
+		if (bStereoDesired)
+		{
+			if (pMP3Stream->outbytes > 4608)
+			{
+				return "MP3ERR: Source file has output packet size > 2304 (*2 for stereo) bytes!";
+			}
+		}		
+		else
+		{
+			if (pMP3Stream->outbytes > 2304)
+			{
+				return "MP3ERR: Source file has output packet size > 2304 bytes!";
+			}
+		}		
+
+		audio.decode_info(&decinfo);
+
+		if (decinfo.bits != 16)
+		{
+			return "MP3ERR: Source file is not 16bit!";	// will this ever happen? oh well...
+		}
+
+		if (decinfo.samprate != 44100)
+		{
+			return "MP3ERR: Source file is not sampled @ 44100!";
+		}
+
+		if (bStereoDesired && decinfo.channels != 2)
+		{
+			return "MP3ERR: Source file is not stereo!";	// sod it, I'm going to count this as an error now
+		}		
+	}
+	else
+	{
+		return "MP3ERR: Decoder failed to initialise";
+	}
+
+	// file seems to be valid...
+	//
+	return NULL;
+}
+
+
+
+// char *return is NZ for any errors (no trailing CR!)
+//
+char* C_MP3_GetHeaderData(void *pvData, int iDataLen, int *piRate, int *piWidth, int *piChannels, int bStereoDesired)
+{
+	unsigned int iRealDataStart;
+	MPEG_HEAD head;
+	DEC_INFO  decinfo;
+
+	int iBitRate;
+	int iFrameBytes;
+
+	memset(pMP3Stream,0,sizeof(*pMP3Stream));
+
+	iFrameBytes = head_info3( pvData, iDataLen/2, &head, &iBitRate, &iRealDataStart);
+	if (iFrameBytes == 0)
+	{
+		return "MP3ERR: Bad or unsupported file!";
+	}
+
+	if (audio.decode_init(&head, iFrameBytes, reduction_code, iRealDataStart, bStereoDesired?convert_code_stereo:convert_code_mono, freq_limit))
+	{
+		audio.decode_info(&decinfo);
+
+		*piRate		= decinfo.samprate;	// rate (eg 22050, 44100 etc)
+		*piWidth	= decinfo.bits/8;	// 1 for 8bit, 2 for 16 bit
+		*piChannels	= decinfo.channels;	// 1 for mono, 2 for stereo
+	}
+	else
+	{
+		return "MP3ERR: Decoder failed to initialise";
+	}
+
+	// everything ok...
+	//
+	return NULL;
+}
+
+
+
+
+// this duplicates work done in C_MP3_IsValid(), but it avoids global structs, and means that you can call this anytime
+//	if you just want info for some reason
+//
+// ( size is now workd out just by decompressing each packet header, not the whole stream. MUCH faster :-)
+//
+// char *return is NZ for any errors (no trailing CR!)
+//
+char *C_MP3_GetUnpackedSize(void *pvData, int iSourceBytesRemaining, int *piUnpackedSize, int bStereoDesired )
+{
+	int iReadLimit;
+	unsigned int iRealDataStart;
+	MPEG_HEAD head;
+	int iBitRate;
+
+	char *pPCM_Buffer = PCM_Buffer;
+	char *psReturn = NULL;
+//	int  iSourceReadIndex = 0;
+	int	 iDestWriteIndex = 0;
+
+	int iFrameBytes;
+	int iFrameCounter;
+
+	DEC_INFO decinfo;
+	IN_OUT	 x;
+	
+	memset(pMP3Stream,0,sizeof(*pMP3Stream));
+
+#define iSourceReadIndex iRealDataStart
+
+//	iFrameBytes = head_info2( pvData, 0, &head, &iBitRate);
+	iFrameBytes = head_info3( pvData, iSourceBytesRemaining/2, &head, &iBitRate, &iRealDataStart);
+	
+	BYTESREMAINING_ACCOUNT_FOR_REAR_TAG(pvData, iSourceBytesRemaining)
+	iSourceBytesRemaining -= iRealDataStart;
+
+	iReadLimit = iSourceReadIndex + iSourceBytesRemaining;
+
+	if (iFrameBytes)
+	{
+		//pPCM_Buffer = malloc(PCM_BUFBYTES);
+
+		//if (pPCM_Buffer)
+		{
+			// init decoder...
+
+			if (audio.decode_init(&head, iFrameBytes, reduction_code, iRealDataStart, bStereoDesired?convert_code_stereo:convert_code_mono, freq_limit))
+			{
+				audio.decode_info(&decinfo);
+
+				// decode...
+				//
+				for (iFrameCounter = 0;;iFrameCounter++)
+				{
+					if ( iSourceBytesRemaining == 0 || iSourceBytesRemaining < iFrameBytes)
+						break;	// end of file
+
+					bFastEstimateOnly = 1;	///////////////////////////////
+
+							x = audio.decode((unsigned char *)pvData + iSourceReadIndex, (short *) ((char *)pPCM_Buffer
+																							//+ iDestWriteIndex		// keep decoding over the same spot since we're only counting bytes in this function
+																							),
+											(unsigned char *)pvData + iReadLimit
+											);
+
+					bFastEstimateOnly = 0;	///////////////////////////////
+					
+					iSourceReadIndex		+= x.in_bytes;
+					iSourceBytesRemaining	-= x.in_bytes;
+					iDestWriteIndex			+= x.out_bytes;
+
+					if (x.in_bytes <= 0)
+					{
+						//psReturn = "MP3ERR: Bad sync in file";
+						break;
+					}
+				}
+
+				*piUnpackedSize = iDestWriteIndex;	// yeeehaaa!
+			}
+			else
+			{
+				psReturn = "MP3ERR: Decoder failed to initialise";
+			}
+		}
+//		else
+//		{
+//			psReturn = "MP3ERR: Unable to alloc temp decomp buffer";		
+//		}
+	}
+	else
+	{
+		psReturn = "MP3ERR: Bad or Unsupported MP3 file!";
+	}
+
+
+//	if (pPCM_Buffer)
+//	{
+//		free(pPCM_Buffer);
+//		pPCM_Buffer = NULL;	// I know, I know...
+//	}
+
+	return psReturn;
+
+#undef iSourceReadIndex
+}
+
+
+
+
+char *C_MP3_UnpackRawPCM( void *pvData, int iSourceBytesRemaining, int *piUnpackedSize, void *pbUnpackBuffer, int bStereoDesired)
+{
+	int iReadLimit;
+	unsigned int iRealDataStart;
+	MPEG_HEAD head;
+	int iBitRate;
+	
+	char *psReturn = NULL;
+//	int  iSourceReadIndex = 0;
+	int	 iDestWriteIndex = 0;
+
+	int iFrameBytes;
+	int iFrameCounter;
+
+	DEC_INFO decinfo;
+	IN_OUT	 x;
+
+	memset(pMP3Stream,0,sizeof(*pMP3Stream));
+
+#define iSourceReadIndex iRealDataStart
+
+//	iFrameBytes = head_info2( pvData, 0, &head, &iBitRate);
+	iFrameBytes = head_info3( pvData, iSourceBytesRemaining/2, &head, &iBitRate, &iRealDataStart);
+
+	BYTESREMAINING_ACCOUNT_FOR_REAR_TAG(pvData, iSourceBytesRemaining)
+	iSourceBytesRemaining -= iRealDataStart;
+
+	iReadLimit = iSourceReadIndex + iSourceBytesRemaining;
+
+	if (iFrameBytes)
+	{
+//		if (1)////////////////////////pPCM_Buffer)
+		{
+			// init decoder...
+
+			if (audio.decode_init(&head, iFrameBytes, reduction_code, iRealDataStart, bStereoDesired?convert_code_stereo:convert_code_mono, freq_limit))
+			{
+				audio.decode_info(&decinfo);
+
+//				printf("\n output samprate = %6ld",decinfo.samprate);
+//				printf("\n output channels = %6d", decinfo.channels);
+//				printf("\n output bits     = %6d", decinfo.bits);
+//				printf("\n output type     = %6d", decinfo.type);
+
+//===============
+				
+				// decode...
+				//
+				for (iFrameCounter = 0;;iFrameCounter++)
+				{
+					if ( iSourceBytesRemaining == 0 || iSourceBytesRemaining < iFrameBytes)
+						break;	// end of file
+
+					x = audio.decode((unsigned char *)pvData + iSourceReadIndex, (short *) ((char *)pbUnpackBuffer + iDestWriteIndex),									 
+									 (unsigned char *)pvData + iReadLimit
+									);	
+					
+					iSourceReadIndex		+= x.in_bytes;
+					iSourceBytesRemaining	-= x.in_bytes;
+					iDestWriteIndex			+= x.out_bytes;
+
+					if (x.in_bytes <= 0)
+					{
+						//psReturn = "MP3ERR: Bad sync in file";
+						break;
+					}
+				}
+
+				*piUnpackedSize = iDestWriteIndex;	// yeeehaaa!
+			}
+			else
+			{
+				psReturn = "MP3ERR: Decoder failed to initialise";
+			}
+		}
+	}
+	else
+	{
+		psReturn = "MP3ERR: Bad or Unsupported MP3 file!";
+	}
+
+	return psReturn;
+
+#undef iSourceReadIndex
+}
+
+
+// called once, after we've decided to keep something as MP3. This just sets up the decoder for subsequent stream-calls.
+// 					  
+// (the struct pSFX_MP3Stream is cleared internally, so pass as args anything you want stored in it)
+//
+// char * return is NULL for ok, else error string
+//
+// NEW CODE NOTE: Now that this function is being called for raw data that's going to be runtime-stored in a link-list
+//	chunk format for SOF2 instead of just one alloc then you must re-init pMP3Stream->pbSourceData after you've called
+//	this, or it'll be pointing at the deallocated original raw data, not the first chunk of the link list
+//
+char *C_MP3Stream_DecodeInit( LP_MP3STREAM pSFX_MP3Stream, void *pvSourceData, int iSourceBytesRemaining,
+							  int iGameAudioSampleRate, int iGameAudioSampleBits, int bStereoDesired )
+{
+	char			*psReturn = NULL;
+	MPEG_HEAD		head;			// only relevant within this function during init	
+	DEC_INFO		decinfo;		//   " "
+	int				iBitRate;		// not used after being filled in by head_info3()
+
+	pMP3Stream = pSFX_MP3Stream;
+
+	memset(pMP3Stream,0,sizeof(*pMP3Stream));
+
+	pMP3Stream->pbSourceData			= (byte *) pvSourceData;	// this MUST be re-initialised to link-mem outside here for SOF2, since raw data is now link-listed
+	pMP3Stream->iSourceBytesRemaining	= iSourceBytesRemaining;
+	pMP3Stream->iSourceFrameBytes		= head_info3( (byte *) pvSourceData, iSourceBytesRemaining/2, &head, &iBitRate, (unsigned int*)&pMP3Stream->iSourceReadIndex );	
+
+	// hack, do NOT do this for stereo, since music files are now streamed and therefore the data isn't actually fully
+	//	loaded at this point, only about 4k or so for the header is actually in memory!!!...
+	//
+	if (!bStereoDesired)
+	{
+		BYTESREMAINING_ACCOUNT_FOR_REAR_TAG(pvSourceData, pMP3Stream->iSourceBytesRemaining);
+		pMP3Stream->iSourceBytesRemaining  -= pMP3Stream->iSourceReadIndex;
+	}
+
+	// backup a couple of fields so we can play this again later...
+	//
+	pMP3Stream->iRewind_SourceReadIndex		= pMP3Stream->iSourceReadIndex;
+	pMP3Stream->iRewind_SourceBytesRemaining= pMP3Stream->iSourceBytesRemaining;
+
+	assert(pMP3Stream->iSourceFrameBytes);
+	if (pMP3Stream->iSourceFrameBytes)
+	{
+		if (audio.decode_init(&head, pMP3Stream->iSourceFrameBytes, reduction_code, pMP3Stream->iSourceReadIndex, bStereoDesired?convert_code_stereo:convert_code_mono, freq_limit))
+		{
+			pMP3Stream->iRewind_FinalReductionCode = reduction_code;	// default = 0 (no reduction), 1=half, 2 = quarter
+
+			pMP3Stream->iRewind_FinalConvertCode   = bStereoDesired?convert_code_stereo:convert_code_mono;
+																		// default = 1 (mono), OR with 8 for 8-bit output
+
+			// only now can we ask what kind of properties this file has, and then adjust to fit what the game wants...
+			//
+			audio.decode_info(&decinfo);
+
+//			printf("\n output samprate = %6ld",decinfo.samprate);
+//			printf("\n output channels = %6d", decinfo.channels);
+//			printf("\n output bits     = %6d", decinfo.bits);
+//			printf("\n output type     = %6d", decinfo.type);
+
+			// decoder offers half or quarter rate adjustement only...
+			//
+			if (iGameAudioSampleRate == decinfo.samprate>>1)
+				pMP3Stream->iRewind_FinalReductionCode = 1;
+			else
+			if (iGameAudioSampleRate == decinfo.samprate>>2)
+				pMP3Stream->iRewind_FinalReductionCode = 2;
+
+			if (iGameAudioSampleBits == decinfo.bits>>1)	// if game wants 8 bit sounds, then setup for that
+				pMP3Stream->iRewind_FinalConvertCode |= 8;
+
+			if (audio.decode_init(&head, pMP3Stream->iSourceFrameBytes, pMP3Stream->iRewind_FinalReductionCode, pMP3Stream->iSourceReadIndex, pMP3Stream->iRewind_FinalConvertCode, freq_limit))
+			{
+				audio.decode_info(&decinfo);
+#ifdef _DEBUG
+				assert( iGameAudioSampleRate == decinfo.samprate );
+				assert( iGameAudioSampleBits == decinfo.bits );
+#endif
+
+				// sod it, no harm in one last check... (should never happen)
+				//
+				if ( iGameAudioSampleRate != decinfo.samprate || iGameAudioSampleBits != decinfo.bits )
+				{
+					psReturn = "MP3ERR: Decoder unable to convert to current game audio settings";
+				}
+			}
+			else
+			{
+				psReturn = "MP3ERR: Decoder failed to initialise for pass 2 sample adjust";
+			}
+		}
+		else
+		{
+			psReturn = "MP3ERR: Decoder failed to initialise";
+		}
+	}
+	else
+	{
+		psReturn = "MP3ERR: Errr.... something's broken with this MP3 file";	// should never happen by this point
+	}
+
+	// restore global stream ptr before returning to normal functions (so the rest of the MP3 code still works)...
+	//
+	pMP3Stream = &_MP3Stream;
+
+	return psReturn;
+}
+
+// return value is decoded bytes for this packet, which is effectively a BOOL, NZ for not finished decoding yet...
+//
+unsigned int C_MP3Stream_Decode( LP_MP3STREAM pSFX_MP3Stream )
+{
+	unsigned int uiDecoded = 0;	// default to "finished"
+	IN_OUT	 x;
+
+	pMP3Stream = pSFX_MP3Stream;
+
+	do
+	{
+		if ( pSFX_MP3Stream->iSourceBytesRemaining == 0)// || pSFX_MP3Stream->iSourceBytesRemaining < pSFX_MP3Stream->iSourceFrameBytes)
+		{
+			uiDecoded = 0;	// finished
+			break;
+		}
+
+		x = audio.decode(pSFX_MP3Stream->pbSourceData + pSFX_MP3Stream->iSourceReadIndex, (short *) (pSFX_MP3Stream->bDecodeBuffer),
+						 pSFX_MP3Stream->pbSourceData + pSFX_MP3Stream->iRewind_SourceReadIndex + pSFX_MP3Stream->iRewind_SourceBytesRemaining
+						);
+
+#ifdef _DEBUG
+		pSFX_MP3Stream->iSourceFrameCounter++;
+#endif
+
+		pSFX_MP3Stream->iSourceReadIndex		+= x.in_bytes;
+		pSFX_MP3Stream->iSourceBytesRemaining	-= x.in_bytes;
+		pSFX_MP3Stream->iBytesDecodedTotal		+= x.out_bytes;
+		pSFX_MP3Stream->iBytesDecodedThisPacket	 = x.out_bytes;
+
+		uiDecoded = x.out_bytes;
+
+		if (x.in_bytes <= 0)
+		{
+			//psReturn = "MP3ERR: Bad sync in file";			
+			uiDecoded= 0;	// finished
+			break;
+		}
+	}
+	#pragma warning (disable : 4127 )	// conditional expression is constant
+	while (0);	// <g>
+	#pragma warning (default : 4127 )	// conditional expression is constant
+	
+	// restore global stream ptr before returning to normal functions (so the rest of the MP3 code still works)...
+	//
+	pMP3Stream = &_MP3Stream;
+
+	return uiDecoded;
+}
+
+
+// ret is char* errstring, else NULL for ok
+//
+char *C_MP3Stream_Rewind( LP_MP3STREAM pSFX_MP3Stream )
+{
+	char*		psReturn = NULL;
+	MPEG_HEAD	head;			// only relevant within this function during init	
+	int			iBitRate;		// ditto
+	int			iNULL;			
+
+	pMP3Stream = pSFX_MP3Stream;
+
+	pMP3Stream->iSourceReadIndex		= pMP3Stream->iRewind_SourceReadIndex;
+	pMP3Stream->iSourceBytesRemaining	= pMP3Stream->iRewind_SourceBytesRemaining;	// already adjusted for tags etc	
+
+	// I'm not sure that this is needed, but where else does decode_init get passed useful data ptrs?...
+	//
+	if (pMP3Stream->iSourceFrameBytes == head_info3( pMP3Stream->pbSourceData, pMP3Stream->iSourceBytesRemaining/2, &head, &iBitRate, (unsigned int*)&iNULL ) )
+	{	
+		if (audio.decode_init(&head, pMP3Stream->iSourceFrameBytes, pMP3Stream->iRewind_FinalReductionCode, pMP3Stream->iSourceReadIndex, pMP3Stream->iRewind_FinalConvertCode, freq_limit))
+		{
+			// we should always get here...
+			//
+		}
+		else
+		{
+			psReturn = "MP3ERR: Failed to re-init decoder for rewind!";
+		}
+	}
+	else
+	{
+		psReturn = "MP3ERR: Frame bytes mismatch during rewind header-read!";
+	}
+
+	// restore global stream ptr before returning to normal functions (so the rest of the MP3 code still works)...
+	//
+	pMP3Stream = &_MP3Stream;
+
+	return psReturn;
+}
+
diff --git a/codemp/mp3code/uph.c b/codemp/mp3code/uph.c
new file mode 100644
index 0000000..18f9e88
--- /dev/null
+++ b/codemp/mp3code/uph.c
@@ -0,0 +1,507 @@
+/*____________________________________________________________________________
+	
+	FreeAmp - The Free MP3 Player
+
+        MP3 Decoder originally Copyright (C) 1995-1997 Xing Technology
+        Corp.  http://www.xingtech.com
+
+	Portions Copyright (C) 1998-1999 EMusic.com
+
+	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., 675 Mass Ave, Cambridge, MA 02139, USA.
+	
+	$Id: uph.c,v 1.3 1999/10/19 07:13:09 elrod Exp $
+____________________________________________________________________________*/
+
+/****  uph.c  ***************************************************
+
+Layer 3 audio
+ huffman decode
+
+
+******************************************************************/
+#include <stdlib.h>
+#include <stdio.h>
+#include <float.h>
+#include <math.h>
+
+#include "L3.h"
+
+#pragma warning ( disable : 4711 )	// function 'xxxx' selected for automatic inline expansion
+
+
+#ifdef _MSC_VER
+#pragma warning(disable: 4505)
+#endif
+
+/*===============================================================*/
+
+/* max bits required for any lookup - change if htable changes */
+/* quad required 10 bit w/signs  must have (MAXBITS+2) >= 10   */
+#define MAXBITS 9
+
+static const HUFF_ELEMENT huff_table_0[4] =
+{{0}, {0}, {0}, {64}};			/* dummy must not use */
+
+#include "htable.h"
+
+/*-- 6 bit lookup (purgebits, value) --*/
+static const unsigned char quad_table_a[][2] =
+{
+  {6, 11}, {6, 15}, {6, 13}, {6, 14}, {6, 7}, {6, 5}, {5, 9},
+  {5, 9}, {5, 6}, {5, 6}, {5, 3}, {5, 3}, {5, 10}, {5, 10},
+  {5, 12}, {5, 12}, {4, 2}, {4, 2}, {4, 2}, {4, 2}, {4, 1},
+  {4, 1}, {4, 1}, {4, 1}, {4, 4}, {4, 4}, {4, 4}, {4, 4},
+  {4, 8}, {4, 8}, {4, 8}, {4, 8}, {1, 0}, {1, 0}, {1, 0},
+  {1, 0}, {1, 0}, {1, 0}, {1, 0}, {1, 0}, {1, 0}, {1, 0},
+  {1, 0}, {1, 0}, {1, 0}, {1, 0}, {1, 0}, {1, 0}, {1, 0},
+  {1, 0}, {1, 0}, {1, 0}, {1, 0}, {1, 0}, {1, 0}, {1, 0},
+  {1, 0}, {1, 0}, {1, 0}, {1, 0}, {1, 0}, {1, 0}, {1, 0},
+  {1, 0},
+};
+
+
+typedef struct
+{
+   const HUFF_ELEMENT *table;
+   int linbits;
+   int ncase;
+}
+HUFF_SETUP;
+
+#define no_bits       0
+#define one_shot      1
+#define no_linbits    2
+#define have_linbits  3
+#define quad_a        4
+#define quad_b        5
+
+
+static const HUFF_SETUP table_look[] =
+{
+  {huff_table_0, 0, no_bits},
+  {huff_table_1, 0, one_shot},
+  {huff_table_2, 0, one_shot},
+  {huff_table_3, 0, one_shot},
+  {huff_table_0, 0, no_bits},
+  {huff_table_5, 0, one_shot},
+  {huff_table_6, 0, one_shot},
+  {huff_table_7, 0, no_linbits},
+  {huff_table_8, 0, no_linbits},
+  {huff_table_9, 0, no_linbits},
+  {huff_table_10, 0, no_linbits},
+  {huff_table_11, 0, no_linbits},
+  {huff_table_12, 0, no_linbits},
+  {huff_table_13, 0, no_linbits},
+  {huff_table_0, 0, no_bits},
+  {huff_table_15, 0, no_linbits},
+  {huff_table_16, 1, have_linbits},
+  {huff_table_16, 2, have_linbits},
+  {huff_table_16, 3, have_linbits},
+  {huff_table_16, 4, have_linbits},
+  {huff_table_16, 6, have_linbits},
+  {huff_table_16, 8, have_linbits},
+  {huff_table_16, 10, have_linbits},
+  {huff_table_16, 13, have_linbits},
+  {huff_table_24, 4, have_linbits},
+  {huff_table_24, 5, have_linbits},
+  {huff_table_24, 6, have_linbits},
+  {huff_table_24, 7, have_linbits},
+  {huff_table_24, 8, have_linbits},
+  {huff_table_24, 9, have_linbits},
+  {huff_table_24, 11, have_linbits},
+  {huff_table_24, 13, have_linbits},
+  {huff_table_0, 0, quad_a},
+  {huff_table_0, 0, quad_b},
+};
+
+/*========================================================*/
+extern BITDAT bitdat;
+
+/*------------- get n bits from bitstream -------------*/
+/* unused
+static unsigned int bitget(int n)
+{
+   unsigned int x;
+
+   if (bitdat.bits < n)
+   {			*/	/* refill bit buf if necessary */
+/*      while (bitdat.bits <= 24)
+      {
+	 bitdat.bitbuf = (bitdat.bitbuf << 8) | *bitdat.bs_ptr++;
+	 bitdat.bits += 8;
+      }
+   }
+   bitdat.bits -= n;
+   x = bitdat.bitbuf >> bitdat.bits;
+   bitdat.bitbuf -= x << bitdat.bits;
+   return x;
+}
+*/
+/*----- get n bits  - checks for n+2 avail bits (linbits+sign) -----*/
+static unsigned int bitget_lb(int n)
+{
+   unsigned int x;
+
+   if (bitdat.bits < (n + 2))
+   {				/* refill bit buf if necessary */
+      while (bitdat.bits <= 24)
+      {
+	 bitdat.bitbuf = (bitdat.bitbuf << 8) | *bitdat.bs_ptr++;
+	 bitdat.bits += 8;
+      }
+   }
+   bitdat.bits -= n;
+   x = bitdat.bitbuf >> bitdat.bits;
+   bitdat.bitbuf -= x << bitdat.bits;
+   return x;
+}
+
+
+
+
+/*------------- get n bits but DO NOT remove from bitstream --*/
+static unsigned int bitget2(int n)
+{
+   unsigned int x;
+
+   if (bitdat.bits < (MAXBITS + 2))
+   {				/* refill bit buf if necessary */
+      while (bitdat.bits <= 24)
+      {
+	 bitdat.bitbuf = (bitdat.bitbuf << 8) | *bitdat.bs_ptr++;
+	 bitdat.bits += 8;
+      }
+   }
+   x = bitdat.bitbuf >> (bitdat.bits - n);
+   return x;
+}
+/*------------- remove n bits from bitstream ---------*/
+/* unused
+static void bitget_purge(int n)
+{
+   bitdat.bits -= n;
+   bitdat.bitbuf -= (bitdat.bitbuf >> bitdat.bits) << bitdat.bits;
+}
+*/
+/*------------- get 1 bit from bitstream NO CHECK -------------*/
+/* unused
+static unsigned int bitget_1bit()
+{
+   unsigned int x;
+
+   bitdat.bits--;
+   x = bitdat.bitbuf >> bitdat.bits;
+   bitdat.bitbuf -= x << bitdat.bits;
+   return x;
+}
+*/
+/*========================================================*/
+/*========================================================*/
+#define mac_bitget_check(n) if( bitdat.bits < (n) ) {                   \
+    while( bitdat.bits <= 24 ) {            \
+        bitdat.bitbuf = (bitdat.bitbuf << 8) | *bitdat.bs_ptr++; \
+        bitdat.bits += 8;                   \
+    }                                       \
+}
+/*---------------------------------------------------------*/
+#define mac_bitget2(n)  (bitdat.bitbuf >> (bitdat.bits-n));
+/*---------------------------------------------------------*/
+#define mac_bitget(n) ( bitdat.bits -= n,           \
+         code  = bitdat.bitbuf >> bitdat.bits,     \
+         bitdat.bitbuf -= code << bitdat.bits,     \
+         code )
+/*---------------------------------------------------------*/
+#define mac_bitget_purge(n) bitdat.bits -= n,                    \
+    bitdat.bitbuf -= (bitdat.bitbuf >> bitdat.bits) << bitdat.bits;
+/*---------------------------------------------------------*/
+#define mac_bitget_1bit() ( bitdat.bits--,                           \
+         code  = bitdat.bitbuf >> bitdat.bits,    \
+         bitdat.bitbuf -= code << bitdat.bits,  \
+         code )
+/*========================================================*/
+/*========================================================*/
+void unpack_huff(int xy[][2], int n, int ntable)
+{
+   int i;
+   const HUFF_ELEMENT *t;
+   const HUFF_ELEMENT *t0;
+   int linbits;
+   int bits;
+   int code;
+   int x, y;
+
+   if (n <= 0)
+      return;
+   n = n >> 1;			/* huff in pairs */
+/*-------------*/
+   t0 = table_look[ntable].table;
+   linbits = table_look[ntable].linbits;
+   switch (table_look[ntable].ncase)
+   {
+      default:
+/*------------------------------------------*/
+      case no_bits:
+/*- table 0, no data, x=y=0--*/
+	 for (i = 0; i < n; i++)
+	 {
+	    xy[i][0] = 0;
+	    xy[i][1] = 0;
+	 }
+	 return;
+/*------------------------------------------*/
+      case one_shot:
+/*- single lookup, no escapes -*/
+	 for (i = 0; i < n; i++)
+	 {
+	    mac_bitget_check((MAXBITS + 2));
+	    bits = t0[0].b.signbits;
+	    code = mac_bitget2(bits);
+	    mac_bitget_purge(t0[1 + code].b.purgebits);
+	    x = t0[1 + code].b.x;
+	    y = t0[1 + code].b.y;
+	    if (x)
+	       if (mac_bitget_1bit())
+		  x = -x;
+	    if (y)
+	       if (mac_bitget_1bit())
+		  y = -y;
+	    xy[i][0] = x;
+	    xy[i][1] = y;
+	    if (bitdat.bs_ptr > bitdat.bs_ptr_end)
+	       break;		// bad data protect
+
+	 }
+	 return;
+/*------------------------------------------*/
+      case no_linbits:
+	 for (i = 0; i < n; i++)
+	 {
+	    t = t0;
+	    for (;;)
+	    {
+	       mac_bitget_check((MAXBITS + 2));
+	       bits = t[0].b.signbits;
+	       code = mac_bitget2(bits);
+	       if (t[1 + code].b.purgebits)
+		  break;
+	       t += t[1 + code].ptr;	/* ptr include 1+code */
+	       mac_bitget_purge(bits);
+	    }
+	    mac_bitget_purge(t[1 + code].b.purgebits);
+	    x = t[1 + code].b.x;
+	    y = t[1 + code].b.y;
+	    if (x)
+	       if (mac_bitget_1bit())
+		  x = -x;
+	    if (y)
+	       if (mac_bitget_1bit())
+		  y = -y;
+	    xy[i][0] = x;
+	    xy[i][1] = y;
+	    if (bitdat.bs_ptr > bitdat.bs_ptr_end)
+	       break;		// bad data protect
+
+	 }
+	 return;
+/*------------------------------------------*/
+      case have_linbits:
+	 for (i = 0; i < n; i++)
+	 {
+	    t = t0;
+	    for (;;)
+	    {
+	       bits = t[0].b.signbits;
+	       code = bitget2(bits);
+	       if (t[1 + code].b.purgebits)
+		  break;
+	       t += t[1 + code].ptr;	/* ptr includes 1+code */
+	       mac_bitget_purge(bits);
+	    }
+	    mac_bitget_purge(t[1 + code].b.purgebits);
+	    x = t[1 + code].b.x;
+	    y = t[1 + code].b.y;
+	    if (x == 15)
+	       x += bitget_lb(linbits);
+	    if (x)
+	       if (mac_bitget_1bit())
+		  x = -x;
+	    if (y == 15)
+	       y += bitget_lb(linbits);
+	    if (y)
+	       if (mac_bitget_1bit())
+		  y = -y;
+	    xy[i][0] = x;
+	    xy[i][1] = y;
+	    if (bitdat.bs_ptr > bitdat.bs_ptr_end)
+	       break;		// bad data protect
+
+	 }
+	 return;
+   }
+/*--- end switch ---*/
+
+}
+/*==========================================================*/
+int unpack_huff_quad(int vwxy[][4], int n, int nbits, int ntable)
+{
+   int i;
+   int code;
+   int x, y, v, w;
+   int tmp;
+   int i_non_zero, tmp_nz;
+
+   tmp_nz = 15;
+   i_non_zero = -1;
+
+   n = n >> 2;			/* huff in quads */
+
+   if (ntable)
+      goto case_quad_b;
+
+/* case_quad_a: */
+   for (i = 0; i < n; i++)
+   {
+      if (nbits <= 0)
+	 break;
+      mac_bitget_check(10);
+      code = mac_bitget2(6);
+      nbits -= quad_table_a[code][0];
+      mac_bitget_purge(quad_table_a[code][0]);
+      tmp = quad_table_a[code][1];
+      if (tmp)
+      {
+	 i_non_zero = i;
+	 tmp_nz = tmp;
+      }
+      v = (tmp >> 3) & 1;
+      w = (tmp >> 2) & 1;
+      x = (tmp >> 1) & 1;
+      y = tmp & 1;
+      if (v)
+      {
+	 if (mac_bitget_1bit())
+	    v = -v;
+	 nbits--;
+      }
+      if (w)
+      {
+	 if (mac_bitget_1bit())
+	    w = -w;
+	 nbits--;
+      }
+      if (x)
+      {
+	 if (mac_bitget_1bit())
+	    x = -x;
+	 nbits--;
+      }
+      if (y)
+      {
+	 if (mac_bitget_1bit())
+	    y = -y;
+	 nbits--;
+      }
+      vwxy[i][0] = v;
+      vwxy[i][1] = w;
+      vwxy[i][2] = x;
+      vwxy[i][3] = y;
+      if (bitdat.bs_ptr > bitdat.bs_ptr_end)
+	 break;			// bad data protect
+
+   }
+   if (i && nbits < 0)
+   {
+      i--;
+      vwxy[i][0] = 0;
+      vwxy[i][1] = 0;
+      vwxy[i][2] = 0;
+      vwxy[i][3] = 0;
+   }
+
+   i_non_zero = (i_non_zero + 1) << 2;
+
+   if ((tmp_nz & 3) == 0)
+      i_non_zero -= 2;
+
+   return i_non_zero;
+
+/*--------------------*/
+ case_quad_b:
+   for (i = 0; i < n; i++)
+   {
+      if (nbits < 4)
+		break;
+      nbits -= 4;
+      mac_bitget_check(8);
+      tmp = mac_bitget(4) ^ 15;	/* one's complement of bitstream */
+      if (tmp)
+      {
+	 i_non_zero = i;
+	 tmp_nz = tmp;
+      }
+      v = (tmp >> 3) & 1;
+      w = (tmp >> 2) & 1;
+      x = (tmp >> 1) & 1;
+      y = tmp & 1;
+      if (v)
+      {
+	 if (mac_bitget_1bit())
+	    v = -v;
+	 nbits--;
+      }
+      if (w)
+      {
+	 if (mac_bitget_1bit())
+	    w = -w;
+	 nbits--;
+      }
+      if (x)
+      {
+	 if (mac_bitget_1bit())
+	    x = -x;
+	 nbits--;
+      }
+      if (y)
+      {
+	 if (mac_bitget_1bit())
+	    y = -y;
+	 nbits--;
+      }
+      vwxy[i][0] = v;
+      vwxy[i][1] = w;
+      vwxy[i][2] = x;
+      vwxy[i][3] = y;
+      if (bitdat.bs_ptr > bitdat.bs_ptr_end)
+	 break;			// bad data protect
+
+   }
+   if (nbits < 0)
+   {
+      i--;
+      vwxy[i][0] = 0;
+      vwxy[i][1] = 0;
+      vwxy[i][2] = 0;
+      vwxy[i][3] = 0;
+   }
+
+   i_non_zero = (i_non_zero + 1) << 2;
+
+   if ((tmp_nz & 3) == 0)
+      i_non_zero -= 2;
+
+   return i_non_zero;		/* return non-zero sample (to nearest pair) */
+
+}
+/*-----------------------------------------------------*/
diff --git a/codemp/mp3code/upsf.c b/codemp/mp3code/upsf.c
new file mode 100644
index 0000000..e538229
--- /dev/null
+++ b/codemp/mp3code/upsf.c
@@ -0,0 +1,404 @@
+/*____________________________________________________________________________
+	
+	FreeAmp - The Free MP3 Player
+
+        MP3 Decoder originally Copyright (C) 1995-1997 Xing Technology
+        Corp.  http://www.xingtech.com
+
+	Portions Copyright (C) 1998-1999 EMusic.com
+
+	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., 675 Mass Ave, Cambridge, MA 02139, USA.
+	
+	$Id: upsf.c,v 1.3 1999/10/19 07:13:09 elrod Exp $
+____________________________________________________________________________*/
+
+/****  upsf.c  ***************************************************
+
+Layer III 
+    unpack scale factors
+
+
+
+******************************************************************/
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <float.h>
+#include <math.h>
+#include "L3.h"
+
+//extern int iframe;
+
+unsigned int bitget(int n);
+
+/*------------------------------------------------------------*/
+static const int slen_table[16][2] =
+{
+  {0, 0}, {0, 1},
+  {0, 2}, {0, 3},
+  {3, 0}, {1, 1},
+  {1, 2}, {1, 3},
+  {2, 1}, {2, 2},
+  {2, 3}, {3, 1},
+  {3, 2}, {3, 3},
+  {4, 2}, {4, 3},
+};
+
+/* nr_table[size+3*is_right][block type 0,1,3  2, 2+mixed][4]  */
+/* for bt=2 nr is count for group of 3 */
+static const int nr_table[6][3][4] =
+{
+ {{6, 5, 5, 5},
+  {3, 3, 3, 3},
+  {6, 3, 3, 3}},
+
+ {{6, 5, 7, 3},
+  {3, 3, 4, 2},
+  {6, 3, 4, 2}},
+
+ {{11, 10, 0, 0},
+  {6, 6, 0, 0},
+  {6, 3, 6, 0}},			/* adjusted *//* 15, 18, 0, 0,   */
+/*-intensity stereo right chan--*/
+ {{7, 7, 7, 0},
+  {4, 4, 4, 0},
+  {6, 5, 4, 0}},
+
+ {{6, 6, 6, 3},
+  {4, 3, 3, 2},
+  {6, 4, 3, 2}},
+
+ {{8, 8, 5, 0},
+  {5, 4, 3, 0},
+  {6, 6, 3, 0}},
+};
+
+/*=============================================================*/
+void unpack_sf_sub_MPEG1(SCALEFACT sf[],
+			 GR * grdat,
+			 int scfsi,	/* bit flag */
+			 int gr)
+{
+   int sfb;
+   int slen0, slen1;
+   int block_type, mixed_block_flag, scalefac_compress;
+
+
+   block_type = grdat->block_type;
+   mixed_block_flag = grdat->mixed_block_flag;
+   scalefac_compress = grdat->scalefac_compress;
+
+   slen0 = slen_table[scalefac_compress][0];
+   slen1 = slen_table[scalefac_compress][1];
+
+
+   if (block_type == 2)
+   {
+      if (mixed_block_flag)
+      {				/* mixed */
+	 for (sfb = 0; sfb < 8; sfb++)
+	    sf[0].l[sfb] = bitget(slen0);
+	 for (sfb = 3; sfb < 6; sfb++)
+	 {
+	    sf[0].s[0][sfb] = bitget(slen0);
+	    sf[0].s[1][sfb] = bitget(slen0);
+	    sf[0].s[2][sfb] = bitget(slen0);
+	 }
+	 for (sfb = 6; sfb < 12; sfb++)
+	 {
+	    sf[0].s[0][sfb] = bitget(slen1);
+	    sf[0].s[1][sfb] = bitget(slen1);
+	    sf[0].s[2][sfb] = bitget(slen1);
+	 }
+	 return;
+      }
+      for (sfb = 0; sfb < 6; sfb++)
+      {
+	 sf[0].s[0][sfb] = bitget(slen0);
+	 sf[0].s[1][sfb] = bitget(slen0);
+	 sf[0].s[2][sfb] = bitget(slen0);
+      }
+      for (; sfb < 12; sfb++)
+      {
+	 sf[0].s[0][sfb] = bitget(slen1);
+	 sf[0].s[1][sfb] = bitget(slen1);
+	 sf[0].s[2][sfb] = bitget(slen1);
+      }
+      return;
+   }
+
+/* long blocks types 0 1 3, first granule */
+   if (gr == 0)
+   {
+      for (sfb = 0; sfb < 11; sfb++)
+	 sf[0].l[sfb] = bitget(slen0);
+      for (; sfb < 21; sfb++)
+	 sf[0].l[sfb] = bitget(slen1);
+      return;
+   }
+
+/* long blocks 0, 1, 3, second granule */
+   sfb = 0;
+   if (scfsi & 8)
+      for (; sfb < 6; sfb++)
+	 sf[0].l[sfb] = sf[-2].l[sfb];
+   else
+      for (; sfb < 6; sfb++)
+	 sf[0].l[sfb] = bitget(slen0);
+   if (scfsi & 4)
+      for (; sfb < 11; sfb++)
+	 sf[0].l[sfb] = sf[-2].l[sfb];
+   else
+      for (; sfb < 11; sfb++)
+	 sf[0].l[sfb] = bitget(slen0);
+   if (scfsi & 2)
+      for (; sfb < 16; sfb++)
+	 sf[0].l[sfb] = sf[-2].l[sfb];
+   else
+      for (; sfb < 16; sfb++)
+	 sf[0].l[sfb] = bitget(slen1);
+   if (scfsi & 1)
+      for (; sfb < 21; sfb++)
+	 sf[0].l[sfb] = sf[-2].l[sfb];
+   else
+      for (; sfb < 21; sfb++)
+	 sf[0].l[sfb] = bitget(slen1);
+
+
+
+   return;
+}
+/*=============================================================*/
+void unpack_sf_sub_MPEG2(SCALEFACT sf[],
+			 GR * grdat,
+			 int is_and_ch, IS_SF_INFO * sf_info)
+{
+   int sfb;
+   int slen1, slen2, slen3, slen4;
+   int nr1, nr2, nr3, nr4;
+   int i, k;
+   int preflag, intensity_scale;
+   int block_type, mixed_block_flag, scalefac_compress;
+
+
+   block_type = grdat->block_type;
+   mixed_block_flag = grdat->mixed_block_flag;
+   scalefac_compress = grdat->scalefac_compress;
+
+   preflag = 0;
+   intensity_scale = 0;		/* to avoid compiler warning */
+   if (is_and_ch == 0)
+   {
+      if (scalefac_compress < 400)
+      {
+	 slen2 = scalefac_compress >> 4;
+	 slen1 = slen2 / 5;
+	 slen2 = slen2 % 5;
+	 slen4 = scalefac_compress & 15;
+	 slen3 = slen4 >> 2;
+	 slen4 = slen4 & 3;
+	 k = 0;
+      }
+      else if (scalefac_compress < 500)
+      {
+	 scalefac_compress -= 400;
+	 slen2 = scalefac_compress >> 2;
+	 slen1 = slen2 / 5;
+	 slen2 = slen2 % 5;
+	 slen3 = scalefac_compress & 3;
+	 slen4 = 0;
+	 k = 1;
+      }
+      else
+      {
+	 scalefac_compress -= 500;
+	 slen1 = scalefac_compress / 3;
+	 slen2 = scalefac_compress % 3;
+	 slen3 = slen4 = 0;
+	 if (mixed_block_flag)
+	 {
+	    slen3 = slen2;	/* adjust for long/short mix logic */
+	    slen2 = slen1;
+	 }
+	 preflag = 1;
+	 k = 2;
+      }
+   }
+   else
+   {				/* intensity stereo ch = 1 (right) */
+      intensity_scale = scalefac_compress & 1;
+      scalefac_compress >>= 1;
+      if (scalefac_compress < 180)
+      {
+	 slen1 = scalefac_compress / 36;
+	 slen2 = scalefac_compress % 36;
+	 slen3 = slen2 % 6;
+	 slen2 = slen2 / 6;
+	 slen4 = 0;
+	 k = 3 + 0;
+      }
+      else if (scalefac_compress < 244)
+      {
+	 scalefac_compress -= 180;
+	 slen3 = scalefac_compress & 3;
+	 scalefac_compress >>= 2;
+	 slen2 = scalefac_compress & 3;
+	 slen1 = scalefac_compress >> 2;
+	 slen4 = 0;
+	 k = 3 + 1;
+      }
+      else
+      {
+	 scalefac_compress -= 244;
+	 slen1 = scalefac_compress / 3;
+	 slen2 = scalefac_compress % 3;
+	 slen3 = slen4 = 0;
+	 k = 3 + 2;
+      }
+   }
+
+   i = 0;
+   if (block_type == 2)
+      i = (mixed_block_flag & 1) + 1;
+   nr1 = nr_table[k][i][0];
+   nr2 = nr_table[k][i][1];
+   nr3 = nr_table[k][i][2];
+   nr4 = nr_table[k][i][3];
+
+
+/* return is scale factor info (for right chan is mode) */
+   if (is_and_ch)
+   {
+      sf_info->nr[0] = nr1;
+      sf_info->nr[1] = nr2;
+      sf_info->nr[2] = nr3;
+      sf_info->slen[0] = slen1;
+      sf_info->slen[1] = slen2;
+      sf_info->slen[2] = slen3;
+      sf_info->intensity_scale = intensity_scale;
+   }
+   grdat->preflag = preflag;	/* return preflag */
+
+/*--------------------------------------*/
+   if (block_type == 2)
+   {
+      if (mixed_block_flag)
+      {				/* mixed */
+	 if (slen1 != 0)	/* long block portion */
+	    for (sfb = 0; sfb < 6; sfb++)
+	       sf[0].l[sfb] = bitget(slen1);
+	 else
+	    for (sfb = 0; sfb < 6; sfb++)
+	       sf[0].l[sfb] = 0;
+	 sfb = 3;		/* start sfb for short */
+      }
+      else
+      {				/* all short, initial short blocks */
+	 sfb = 0;
+	 if (slen1 != 0)
+	    for (i = 0; i < nr1; i++, sfb++)
+	    {
+	       sf[0].s[0][sfb] = bitget(slen1);
+	       sf[0].s[1][sfb] = bitget(slen1);
+	       sf[0].s[2][sfb] = bitget(slen1);
+	    }
+	 else
+	    for (i = 0; i < nr1; i++, sfb++)
+	    {
+	       sf[0].s[0][sfb] = 0;
+	       sf[0].s[1][sfb] = 0;
+	       sf[0].s[2][sfb] = 0;
+	    }
+      }
+/* remaining short blocks */
+      if (slen2 != 0)
+	 for (i = 0; i < nr2; i++, sfb++)
+	 {
+	    sf[0].s[0][sfb] = bitget(slen2);
+	    sf[0].s[1][sfb] = bitget(slen2);
+	    sf[0].s[2][sfb] = bitget(slen2);
+	 }
+      else
+	 for (i = 0; i < nr2; i++, sfb++)
+	 {
+	    sf[0].s[0][sfb] = 0;
+	    sf[0].s[1][sfb] = 0;
+	    sf[0].s[2][sfb] = 0;
+	 }
+      if (slen3 != 0)
+	 for (i = 0; i < nr3; i++, sfb++)
+	 {
+	    sf[0].s[0][sfb] = bitget(slen3);
+	    sf[0].s[1][sfb] = bitget(slen3);
+	    sf[0].s[2][sfb] = bitget(slen3);
+	 }
+      else
+	 for (i = 0; i < nr3; i++, sfb++)
+	 {
+	    sf[0].s[0][sfb] = 0;
+	    sf[0].s[1][sfb] = 0;
+	    sf[0].s[2][sfb] = 0;
+	 }
+      if (slen4 != 0)
+	 for (i = 0; i < nr4; i++, sfb++)
+	 {
+	    sf[0].s[0][sfb] = bitget(slen4);
+	    sf[0].s[1][sfb] = bitget(slen4);
+	    sf[0].s[2][sfb] = bitget(slen4);
+	 }
+      else
+	 for (i = 0; i < nr4; i++, sfb++)
+	 {
+	    sf[0].s[0][sfb] = 0;
+	    sf[0].s[1][sfb] = 0;
+	    sf[0].s[2][sfb] = 0;
+	 }
+      return;
+   }
+
+
+/* long blocks types 0 1 3 */
+   sfb = 0;
+   if (slen1 != 0)
+      for (i = 0; i < nr1; i++, sfb++)
+	 sf[0].l[sfb] = bitget(slen1);
+   else
+      for (i = 0; i < nr1; i++, sfb++)
+	 sf[0].l[sfb] = 0;
+
+   if (slen2 != 0)
+      for (i = 0; i < nr2; i++, sfb++)
+	 sf[0].l[sfb] = bitget(slen2);
+   else
+      for (i = 0; i < nr2; i++, sfb++)
+	 sf[0].l[sfb] = 0;
+
+   if (slen3 != 0)
+      for (i = 0; i < nr3; i++, sfb++)
+	 sf[0].l[sfb] = bitget(slen3);
+   else
+      for (i = 0; i < nr3; i++, sfb++)
+	 sf[0].l[sfb] = 0;
+
+   if (slen4 != 0)
+      for (i = 0; i < nr4; i++, sfb++)
+	 sf[0].l[sfb] = bitget(slen4);
+   else
+      for (i = 0; i < nr4; i++, sfb++)
+	 sf[0].l[sfb] = 0;
+
+
+}
+/*-------------------------------------------------*/
diff --git a/codemp/mp3code/vssver.scc b/codemp/mp3code/vssver.scc
new file mode 100644
index 0000000..8a610cc
Binary files /dev/null and b/codemp/mp3code/vssver.scc differ
diff --git a/codemp/mp3code/wavep.c b/codemp/mp3code/wavep.c
new file mode 100644
index 0000000..6ff6af2
--- /dev/null
+++ b/codemp/mp3code/wavep.c
@@ -0,0 +1,96 @@
+#pragma warning(disable:4206)	// nonstandard extension used : translation unit is empty
+#if 0
+/*____________________________________________________________________________
+	
+	FreeAmp - The Free MP3 Player
+
+        MP3 Decoder originally Copyright (C) 1995-1997 Xing Technology
+        Corp.  http://www.xingtech.com
+
+	Portions Copyright (C) 1998-1999 EMusic.com
+
+	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., 675 Mass Ave, Cambridge, MA 02139, USA.
+	
+	$Id: wavep.c,v 1.3 1999/10/19 07:13:09 elrod Exp $
+____________________________________________________________________________*/
+
+/*---- wavep.c --------------------------------------------
+
+WAVE FILE HEADER ROUTINES
+with conditional pcm conversion to MS wave format
+portable version
+
+-----------------------------------------------------------*/
+#include <stdlib.h>
+#include <stdio.h>
+#include <float.h>
+#include <math.h>
+#ifdef WIN32
+#include <io.h>
+#else
+#include <unistd.h>
+#endif
+#include "port.h"
+
+typedef struct
+{
+   unsigned char riff[4];
+   unsigned char size[4];
+   unsigned char wave[4];
+   unsigned char fmt[4];
+   unsigned char fmtsize[4];
+   unsigned char tag[2];
+   unsigned char nChannels[2];
+   unsigned char nSamplesPerSec[4];
+   unsigned char nAvgBytesPerSec[4];
+   unsigned char nBlockAlign[2];
+   unsigned char nBitsPerSample[2];
+   unsigned char data[4];
+   unsigned char pcm_bytes[4];
+}
+BYTE_WAVE;
+
+static const BYTE_WAVE wave =
+{
+   "RIFF",
+   {(sizeof(BYTE_WAVE) - 8), 0, 0, 0},
+   "WAVE",
+   "fmt ",
+   {16, 0, 0, 0},
+   {1, 0},
+   {1, 0},
+   {34, 86, 0, 0},		/* 86 * 256 + 34 = 22050 */
+   {172, 68, 0, 0},		/* 172 * 256 + 68 = 44100 */
+   {2, 0},
+   {16, 0},
+   "data",
+   {0, 0, 0, 0}
+};
+
+/*----------------------------------------------------------------
+  pcm conversion to wave format
+
+  This conversion code required for big endian machine, or,
+  if sizeof(short) != 16 bits.
+  Conversion routines may be used on any machine, but if
+  not required, the do nothing macros in port.h can be used instead
+  to reduce overhead.
+
+-----------------------------------------------------------------*/
+#ifndef LITTLE_SHORT16
+#include "wcvt.c"
+#endif
+/*-----------------------------------------------*/
+#endif
diff --git a/codemp/mssccprj.scc b/codemp/mssccprj.scc
new file mode 100644
index 0000000..34e1057
--- /dev/null
+++ b/codemp/mssccprj.scc
@@ -0,0 +1,17 @@
+SCC = This is a Source Code Control file
+
+[jk2mp.vcproj]
+SCC_Aux_Path = "\\ravendata1\vss\central_code"
+SCC_Project_Name = "$/jedi/codemp", CAAAAAAA
+
+[JKA_mp.sln]
+SCC_Aux_Path = "\\ravendata1\vss\central_code"
+SCC_Project_Name = "$/jedi/codemp", CAAAAAAA
+
+[WinDed.dsp]
+SCC_Aux_Path = "\\ravendata1\vss\central_code"
+SCC_Project_Name = "$/jedi/codemp", CAAAAAAA
+
+[WinDed.vcproj]
+SCC_Aux_Path = "\\ravendata1\vss\central_code"
+SCC_Project_Name = "$/jedi/codemp", CAAAAAAA
diff --git a/codemp/namespace_begin.h b/codemp/namespace_begin.h
new file mode 100644
index 0000000..1a76e25
--- /dev/null
+++ b/codemp/namespace_begin.h
@@ -0,0 +1,15 @@
+#ifdef _XBOX
+
+#ifdef _GAME
+namespace game {
+#elif defined _CGAME
+namespace cgame {
+#elif defined _UI
+namespace ui {
+#else
+// Hmmm. Some of the module headers end up included in EXE code.
+// Let's hope that the apocalpyse can be held at bay.
+// #error Including namespace_begin.h, but not in UI/GAME/CGAME
+#endif
+
+#endif // _XBOX
\ No newline at end of file
diff --git a/codemp/namespace_end.h b/codemp/namespace_end.h
new file mode 100644
index 0000000..b176307
--- /dev/null
+++ b/codemp/namespace_end.h
@@ -0,0 +1,17 @@
+#ifdef _XBOX
+
+#ifdef _GAME
+}
+using namespace game;
+#elif defined _CGAME
+}
+using namespace cgame;
+#elif defined _UI
+}
+using namespace ui;
+#else
+// See comment int namespace_begin.h
+//#error Including namespace_end.h, but not in UI/GAME/CGAME
+#endif
+
+#endif _XBOX
\ No newline at end of file
diff --git a/codemp/null/mac_net.c b/codemp/null/mac_net.c
new file mode 100644
index 0000000..6232aff
--- /dev/null
+++ b/codemp/null/mac_net.c
@@ -0,0 +1,44 @@
+
+#include "../game/q_shared.h"
+#include "../qcommon/qcommon.h"
+
+/*
+=============
+NET_StringToAdr
+
+localhost
+idnewt
+idnewt:28000
+192.246.40.70
+192.246.40.70:28000
+=============
+*/
+qboolean	NET_StringToAdr (char *s, netadr_t *a)
+{	
+	if (!strcmp (s, "localhost")) {
+		memset (a, 0, sizeof(*a));
+		a->type = NA_LOOPBACK;
+		return true;
+	}
+
+	return false;
+}
+
+/*
+==================
+Sys_SendPacket
+==================
+*/
+void Sys_SendPacket( int length, void *data, netadr_t to ) {
+}
+
+/*
+==================
+Sys_GetPacket
+
+Never called by the game logic, just the system event queing
+==================
+*/
+qboolean	Sys_GetPacket ( netadr_t *net_from, msg_t *net_message ) {
+	return false;
+}
diff --git a/codemp/null/null_client.cpp b/codemp/null/null_client.cpp
new file mode 100644
index 0000000..421efb9
--- /dev/null
+++ b/codemp/null/null_client.cpp
@@ -0,0 +1,68 @@
+
+#include "../client/client.h"
+
+
+char	cl_cdkey[17] = "123456789";
+
+cvar_t *cl_shownet;
+
+void CL_Shutdown( void ) {
+}
+
+void CL_Init( void ) {
+	cl_shownet = Cvar_Get ("cl_shownet", "0", CVAR_TEMP );
+}
+
+void CL_MouseEvent( int dx, int dy, int time ) {
+}
+
+void Key_WriteBindings( fileHandle_t f ) {
+}
+
+void CL_Frame ( int msec ) {
+}
+
+void CL_PacketEvent( netadr_t from, msg_t *msg ) {
+}
+
+void CL_CharEvent( int key ) {
+}
+
+void CL_Disconnect( qboolean showMainMenu ) {
+}
+
+void CL_MapLoading( void ) {
+}
+
+qboolean CL_GameCommand( void ) {
+	return qfalse;
+}
+
+void CL_KeyEvent (int key, qboolean down, unsigned time) {
+}
+
+qboolean UI_GameCommand( void ) {
+	return qfalse;
+}
+
+void CL_ForwardCommandToServer( const char *string ) {
+}
+
+void CL_ConsolePrint( const char *txt, qboolean silent ) {
+}
+
+void CL_JoystickEvent( int axis, int value, int time ) {
+}
+
+void CL_InitKeyCommands( void ) {
+}
+
+void CL_CDDialog( const char *msg ) {
+}
+
+void CL_FlushMemory( void ) {
+}
+
+void CL_StartHunkUsers( void ) {
+}
+
diff --git a/codemp/null/null_glimp.cpp b/codemp/null/null_glimp.cpp
new file mode 100644
index 0000000..0c59867
--- /dev/null
+++ b/codemp/null/null_glimp.cpp
@@ -0,0 +1,74 @@
+#include "../game/q_shared.h"
+#include "../renderer/tr_local.h"
+#ifdef __linux__
+typedef unsigned int GLenum;
+#endif
+
+#ifdef _WIN32
+#include <windows.h>
+BOOL (WINAPI * qwglSwapIntervalEXT)( int interval );
+//void (APIENTRY * qglMultiTexCoord2fARB )( GLenum texture, float s, float t );
+//void (APIENTRY * qglActiveTextureARB )( GLenum texture );
+//void (APIENTRY * qglClientActiveTextureARB )( GLenum texture );
+
+
+void (APIENTRY * qglLockArraysEXT)( int, int);
+void (APIENTRY * qglUnlockArraysEXT) ( void );
+
+
+void		GLimp_EndFrame( void ) {
+}
+
+void 		GLimp_Init( void )
+{
+}
+
+void		GLimp_Shutdown( void ) {
+}
+
+void		GLimp_EnableLogging( qboolean enable ) {
+}
+
+void GLimp_LogComment( char *comment ) {
+}
+
+qboolean QGL_Init( const char *dllname ) {
+	return qtrue;
+}
+
+void		QGL_Shutdown( void ) {
+}
+#else
+qboolean ( * qwglSwapIntervalEXT)( int interval );
+void ( * qglMultiTexCoord2fARB )( GLenum texture, float s, float t );
+void ( * qglActiveTextureARB )( GLenum texture );
+void ( * qglClientActiveTextureARB )( GLenum texture );
+
+
+void ( * qglLockArraysEXT)( int, int);
+void ( * qglUnlockArraysEXT) ( void );
+
+
+void		GLimp_EndFrame( void ) {
+}
+
+void 		GLimp_Init( void )
+{
+}
+
+void		GLimp_Shutdown( void ) {
+}
+
+void		GLimp_EnableLogging( qboolean enable ) {
+}
+
+void GLimp_LogComment( char *comment ) {
+}
+
+qboolean QGL_Init( const char *dllname ) {
+	return qtrue;
+}
+
+void		QGL_Shutdown( void ) {
+}
+#endif // !WIN32
diff --git a/codemp/null/null_input.cpp b/codemp/null/null_input.cpp
new file mode 100644
index 0000000..7f79d2f
--- /dev/null
+++ b/codemp/null/null_input.cpp
@@ -0,0 +1,14 @@
+#include "../client/client.h"
+
+void IN_Init( void ) {
+}
+
+void IN_Frame (void) {
+}
+
+void IN_Shutdown( void ) {
+}
+
+void Sys_SendKeyEvents (void) {
+}
+
diff --git a/codemp/null/null_main.c b/codemp/null/null_main.c
new file mode 100644
index 0000000..cab5b0d
--- /dev/null
+++ b/codemp/null/null_main.c
@@ -0,0 +1,95 @@
+// sys_null.h -- null system driver to aid porting efforts
+
+#include <errno.h>
+#include <stdio.h>
+#include "../qcommon/qcommon.h"
+
+int			sys_curtime;
+
+
+//===================================================================
+
+void Sys_BeginStreamedFile( FILE *f, int readAhead ) {
+}
+
+void Sys_EndStreamedFile( FILE *f ) {
+}
+
+int Sys_StreamedRead( void *buffer, int size, int count, FILE *f ) {
+	return fread( buffer, size, count, f );
+}
+
+void Sys_StreamSeek( FILE *f, int offset, int origin ) {
+	fseek( f, offset, origin );
+}
+
+
+//===================================================================
+
+
+void Sys_mkdir ( const char *path ) {
+}
+
+void Sys_Error (char *error, ...) {
+	va_list		argptr;
+
+	printf ("Sys_Error: ");	
+	va_start (argptr,error);
+	vprintf (error,argptr);
+	va_end (argptr);
+	printf ("\n");
+
+	exit (1);
+}
+
+void Sys_Quit (void) {
+	exit (0);
+}
+
+void	Sys_UnloadGame (void) {
+}
+
+void	*Sys_GetGameAPI (void *parms) {
+	return NULL;
+}
+
+char *Sys_GetClipboardData( void ) {
+	return NULL;
+}
+
+int		Sys_Milliseconds (void) {
+	return 0;
+}
+
+void	Sys_Mkdir (char *path) {
+}
+
+char	*Sys_FindFirst (char *path, unsigned musthave, unsigned canthave) {
+	return NULL;
+}
+
+char	*Sys_FindNext (unsigned musthave, unsigned canthave) {
+	return NULL;
+}
+
+void	Sys_FindClose (void) {
+}
+
+void	Sys_Init (void) {
+}
+
+
+void	Sys_EarlyOutput( char *string ) {
+	printf( "%s", string );
+}
+
+
+void main (int argc, char **argv) {
+	Com_Init (argc, argv);
+
+	while (1) {
+		Com_Frame( );
+	}
+}
+
+
diff --git a/codemp/null/null_net.c b/codemp/null/null_net.c
new file mode 100644
index 0000000..2973a8d
--- /dev/null
+++ b/codemp/null/null_net.c
@@ -0,0 +1,43 @@
+
+#include "../qcommon/qcommon.h"
+
+/*
+=============
+NET_StringToAdr
+
+localhost
+idnewt
+idnewt:28000
+192.246.40.70
+192.246.40.70:28000
+=============
+*/
+qboolean	NET_StringToAdr (char *s, netadr_t *a)
+{	
+	if (!strcmp (s, "localhost")) {
+		memset (a, 0, sizeof(*a));
+		a->type = NA_LOOPBACK;
+		return true;
+	}
+
+	return false;
+}
+
+/*
+==================
+Sys_SendPacket
+==================
+*/
+void Sys_SendPacket( int length, void *data, netadr_t to ) {
+}
+
+/*
+==================
+Sys_GetPacket
+
+Never called by the game logic, just the system event queing
+==================
+*/
+qboolean	Sys_GetPacket ( netadr_t *net_from, msg_t *net_message ) {
+	return false;
+}
diff --git a/codemp/null/null_renderer.cpp b/codemp/null/null_renderer.cpp
new file mode 100644
index 0000000..dadb28c
--- /dev/null
+++ b/codemp/null/null_renderer.cpp
@@ -0,0 +1,21 @@
+/* Null renderer functions */
+
+void RB_StageIteratorGeneric(void)
+{
+}
+
+void RB_StageIteratorSky(void)
+{
+}
+
+void RB_StageIteratorVertexLitTexture(void)
+{
+}
+
+void RB_StageIteratorLightmappedMultitexture(void)
+{
+}
+
+void R_SyncRenderThread(void)
+{
+}
diff --git a/codemp/null/null_snddma.cpp b/codemp/null/null_snddma.cpp
new file mode 100644
index 0000000..eb2afce
--- /dev/null
+++ b/codemp/null/null_snddma.cpp
@@ -0,0 +1,49 @@
+
+// snddma_null.c
+// all other sound mixing is portable
+
+#include "../client/client.h"
+
+qboolean gbInsideLoadSound = qfalse; // important to default to this!!!
+
+qboolean SNDDMA_Init(void)
+{
+	return qfalse;
+}
+
+int	SNDDMA_GetDMAPos(void)
+{
+	return 0;
+}
+
+void SNDDMA_Shutdown(void)
+{
+}
+
+void SNDDMA_BeginPainting (void)
+{
+}
+
+void SNDDMA_Submit(void)
+{
+}
+
+sfxHandle_t S_RegisterSound( const char *name ) {
+	return 0;
+}
+
+void S_StartLocalSound( sfxHandle_t sfxHandle, int channelNum ) {
+}
+
+void S_ClearSoundBuffer( void ) {
+}
+
+qboolean SND_RegisterAudio_LevelLoadEnd(qboolean something)
+{
+	return qfalse;
+}
+
+int SND_FreeOldestSound(void)
+{
+	return 0;
+}
\ No newline at end of file
diff --git a/codemp/null/vssver.scc b/codemp/null/vssver.scc
new file mode 100644
index 0000000..7a02421
Binary files /dev/null and b/codemp/null/vssver.scc differ
diff --git a/codemp/null/win_main.cpp b/codemp/null/win_main.cpp
new file mode 100644
index 0000000..21f1cc1
--- /dev/null
+++ b/codemp/null/win_main.cpp
@@ -0,0 +1,1482 @@
+// win_main.c
+
+#include "../client/client.h"
+#include "../qcommon/qcommon.h"
+#include "../win32/win_local.h"
+#include "../win32/resource.h"
+#include <errno.h>
+#include <float.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <direct.h>
+#include <io.h>
+#include <conio.h>
+#include "../qcommon/stringed_ingame.h"
+
+#define	CD_BASEDIR	"gamedata\\gamedata"
+#define	CD_EXE		"jamp.exe"
+#define	CD_BASEDIR_LINUX	"bin\\x86\\glibc-2.1"
+#define	CD_EXE_LINUX "jamp"
+#define	CD_VOLUME	"JEDIACAD"
+#define MEM_THRESHOLD 128*1024*1024
+
+static char		sys_cmdline[MAX_STRING_CHARS];
+clientStatic_t	cls;
+
+static int	sys_monkeySpank;
+static int	sys_checksum;
+
+
+void *Sys_GetBotAIAPI (void *parms ) {
+	return NULL;
+}
+
+void Conbuf_AppendText( const char *pMsg )
+{
+	char		msg[4096];
+	strcpy(msg, pMsg);
+	printf(Q_CleanStr(msg));
+	printf("\n");
+}
+
+/*
+==================
+Sys_LowPhysicalMemory()
+==================
+*/
+
+qboolean Sys_LowPhysicalMemory() {
+	MEMORYSTATUS stat;
+	GlobalMemoryStatus (&stat);
+	return (stat.dwTotalPhys <= MEM_THRESHOLD) ? qtrue : qfalse;
+}
+
+/*
+==================
+Sys_FunctionCmp
+==================
+*/
+int Sys_FunctionCmp(void *f1, void *f2) {
+
+	int i, j, l;
+	byte func_end[32] = {0xC3, 0x90, 0x90, 0x00};
+	byte *ptr, *ptr2;
+	byte *f1_ptr, *f2_ptr;
+
+	ptr = (byte *) f1;
+	if (*(byte *)ptr == 0xE9) {
+		//Com_Printf("f1 %p1 jmp %d\n", (int *) f1, *(int*)(ptr+1));
+		f1_ptr = (byte*)(((byte*)f1) + (*(int *)(ptr+1)) + 5);
+	}
+	else {
+		f1_ptr = ptr;
+	}
+	//Com_Printf("f1 ptr %p\n", f1_ptr);
+
+	ptr = (byte *) f2;
+	if (*(byte *)ptr == 0xE9) {
+		//Com_Printf("f2 %p jmp %d\n", (int *) f2, *(int*)(ptr+1));
+		f2_ptr = (byte*)(((byte*)f2) + (*(int *)(ptr+1)) + 5);
+	}
+	else {
+		f2_ptr = ptr;
+	}
+	//Com_Printf("f2 ptr %p\n", f2_ptr);
+
+#ifdef _DEBUG
+	sprintf((char *)func_end, "%c%c%c%c%c%c%c", 0x5F, 0x5E, 0x5B, 0x8B, 0xE5, 0x5D, 0xC3);
+#endif
+	for (i = 0; i < 1024; i++) {
+		for (j = 0; func_end[j]; j++) {
+			if (f1_ptr[i+j] != func_end[j])
+				break;
+		}
+		if (!func_end[j]) {
+			break;
+		}
+	}
+#ifdef _DEBUG
+	l = i + 7;
+#else
+	l = i + 2;
+#endif
+	//Com_Printf("function length = %d\n", l);
+
+	for (i = 0; i < l; i++) {
+		// check for a potential function call
+		if (*((byte *) &f1_ptr[i]) == 0xE8) {
+			// get the function pointers in case this really is a function call
+			ptr = (byte *) (((byte *) &f1_ptr[i]) + (*(int *) &f1_ptr[i+1])) + 5;
+			ptr2 = (byte *) (((byte *) &f2_ptr[i]) + (*(int *) &f2_ptr[i+1])) + 5;
+			// if it was a function call and both f1 and f2 call the same function
+			if (ptr == ptr2) {
+				i += 4;
+				continue;
+			}
+		}
+		if (f1_ptr[i] != f2_ptr[i])
+			return qfalse;
+	}
+	return qtrue;
+}
+
+/*
+==================
+Sys_FunctionCheckSum
+==================
+*/
+int Sys_FunctionCheckSum(void *f1) {
+
+	int i, j, l;
+	byte func_end[32] = {0xC3, 0x90, 0x90, 0x00};
+	byte *ptr;
+	byte *f1_ptr;
+
+	ptr = (byte *) f1;
+	if (*(byte *)ptr == 0xE9) {
+		//Com_Printf("f1 %p1 jmp %d\n", (int *) f1, *(int*)(ptr+1));
+		f1_ptr = (byte*)(((byte*)f1) + (*(int *)(ptr+1)) + 5);
+	}
+	else {
+		f1_ptr = ptr;
+	}
+	//Com_Printf("f1 ptr %p\n", f1_ptr);
+
+#ifdef _DEBUG
+	sprintf((char *)func_end, "%c%c%c%c%c%c%c", 0x5F, 0x5E, 0x5B, 0x8B, 0xE5, 0x5D, 0xC3);
+#endif
+	for (i = 0; i < 1024; i++) {
+		for (j = 0; func_end[j]; j++) {
+			if (f1_ptr[i+j] != func_end[j])
+				break;
+		}
+		if (!func_end[j]) {
+			break;
+		}
+	}
+#ifdef _DEBUG
+	l = i + 7;
+#else
+	l = i + 2;
+#endif
+	//Com_Printf("function length = %d\n", l);
+	return Com_BlockChecksum( f1_ptr, l );
+}
+
+/*
+==================
+Sys_MonkeyShouldBeSpanked
+==================
+*/
+int Sys_MonkeyShouldBeSpanked( void ) {
+	return sys_monkeySpank;
+}
+
+
+/*
+==================
+Sys_VerifyCodeChecksum
+==================
+*/
+void Sys_VerifyCodeChecksum( void *codeBase ) {
+}
+
+/*
+===============
+PrintMatches
+
+===============
+*/
+static char g_consoleField1[256];
+static char g_consoleField2[256];
+
+static void PrintMatches( const char *s ) {
+	if ( !Q_stricmpn( s, g_consoleField1, strlen( g_consoleField1 ) ) ) {
+		printf( "    %s\n", s );
+	}
+}
+
+//qboolean stdin_active = qtrue;
+char *Sys_ConsoleInput(void)
+{
+	const char ClearLine[] = "\r                                                                               \r";
+
+	static int	len=0;
+	static bool bPendingExtended = false;
+	
+	if (!kbhit()) return NULL;
+
+	if (len == 0) memset(g_consoleField1,0,sizeof(g_consoleField1));
+	
+	g_consoleField1[len] = getch();
+	
+	if (bPendingExtended)
+	{
+		switch (g_consoleField1[len])
+		{
+			case 'H':	//up
+				strcpy(g_consoleField1, g_consoleField2);
+				printf(ClearLine);
+				printf("%s",g_consoleField1);
+				len = strlen(g_consoleField1);
+			break;
+
+			case 'K':	//left
+			break;
+
+			case 'M':	//right
+			break;
+
+			case 'P':	//down
+			break;
+		}
+		g_consoleField1[len] = 0;	//erase last key hit
+		bPendingExtended = false;
+	}
+	else
+	switch ((unsigned char) g_consoleField1[len])
+	{
+	case 0x00:	//fkey is next
+	case 0xe0:	//extended = arrow keys
+		g_consoleField1[len] = 0;	//erase last key hit
+		bPendingExtended = true;
+		break;
+	case 8: // backspace
+		printf("%c %c",g_consoleField1[len],g_consoleField1[len]);
+		g_consoleField1[len] = 0;
+		if (len > 0) len--;
+		g_consoleField1[len] = 0;
+		break;
+	case 9:	//Tab
+		if (len) {
+			g_consoleField1[len] = 0;	//erase last key hit
+			printf( "\n");
+			// run through again, printing matches
+			Cmd_CommandCompletion( PrintMatches );
+			Cvar_CommandCompletion( PrintMatches );
+			printf( "\n%s", g_consoleField1);
+		}
+		break;
+	case 27: // esc	
+		// clear the line
+		printf(ClearLine);
+		len = 0;
+		break;
+	case '\r':	//enter
+		g_consoleField1[len] = 0;	//erase last key hit
+		printf("\n");
+		if (len) {
+			len = 0;
+			strcpy(g_consoleField2, g_consoleField1);
+			return g_consoleField1;
+		}
+		break;
+	case 'v' - 'a' + 1:	// ctrl-v is paste
+		g_consoleField1[len] = 0;	//erase last key hit
+		char *cbd;
+		cbd = Sys_GetClipboardData();
+		if (cbd) {
+			strncpy (&g_consoleField1[len], cbd, sizeof(g_consoleField1) );
+			printf("%s",cbd);
+			len += strlen(cbd);
+			Z_Free( cbd );
+			if (len == sizeof(g_consoleField1))
+			{
+				len = 0;
+				return g_consoleField1;
+			}
+		}
+		break;
+	default:
+		printf("%c",g_consoleField1[len]);
+		len++;
+		if (len == sizeof(g_consoleField1))
+		{
+			len = 0;
+			return g_consoleField1;
+		}
+		break;
+	}
+
+	return NULL;
+}
+
+/*
+==================
+Sys_BeginProfiling
+==================
+*/
+void Sys_BeginProfiling( void ) {
+	// this is just used on the mac build
+}
+
+void Sys_ShowConsole( int visLevel, qboolean quitOnClose )
+{
+}
+
+/*
+=============
+Sys_Error
+
+Show the early console as an error dialog
+=============
+*/
+void QDECL Sys_Error( const char *error, ... ) {
+	va_list		argptr;
+	char		text[4096];
+    MSG        msg;
+
+	va_start (argptr, error);
+	vsprintf (text, error, argptr);
+	va_end (argptr);
+
+	Conbuf_AppendText( text );
+	Conbuf_AppendText( "\n" );
+
+//	Sys_SetErrorText( text );
+	Sys_ShowConsole( 1, qtrue );
+
+	timeEndPeriod( 1 );
+
+	IN_Shutdown();
+
+	// wait for the user to quit
+	while ( 1 ) {
+		if (!GetMessage (&msg, NULL, 0, 0))
+			Com_Quit_f ();
+		TranslateMessage (&msg);
+      	DispatchMessage (&msg);
+	}
+
+//	Sys_DestroyConsole();
+	Com_ShutdownZoneMemory();
+ 	Com_ShutdownHunkMemory();
+
+	exit (1);
+}
+
+/*
+==============
+Sys_Quit
+==============
+*/
+void Sys_Quit( void ) {
+	timeEndPeriod( 1 );
+	IN_Shutdown();
+//	Sys_DestroyConsole();
+	Com_ShutdownZoneMemory();
+ 	Com_ShutdownHunkMemory();
+
+	exit (0);
+}
+
+/*
+==============
+Sys_Print
+==============
+*/
+void Sys_Print( const char *msg ) {
+	Conbuf_AppendText( msg );
+}
+
+
+/*
+==============
+Sys_Mkdir
+==============
+*/
+void Sys_Mkdir( const char *path ) {
+	_mkdir (path);
+}
+
+/*
+==============
+Sys_Cwd
+==============
+*/
+char *Sys_Cwd( void ) {
+	static char cwd[MAX_OSPATH];
+
+	_getcwd( cwd, sizeof( cwd ) - 1 );
+	cwd[MAX_OSPATH-1] = 0;
+
+	return cwd;
+}
+
+/*
+==============
+Sys_DefaultCDPath
+==============
+*/
+char *Sys_DefaultCDPath( void ) {
+	return "";
+}
+
+/*
+==============
+Sys_DefaultBasePath
+==============
+*/
+char *Sys_DefaultBasePath( void ) {
+	return Sys_Cwd();
+}
+
+/*
+==============================================================
+
+DIRECTORY SCANNING
+
+==============================================================
+*/
+
+#define	MAX_FOUND_FILES	0x1000
+
+void Sys_ListFilteredFiles( const char *basedir, char *subdirs, char *filter, char **psList, int *numfiles ) {
+	char		search[MAX_OSPATH], newsubdirs[MAX_OSPATH];
+	char		filename[MAX_OSPATH];
+	int			findhandle;
+	struct _finddata_t findinfo;
+
+	if ( *numfiles >= MAX_FOUND_FILES - 1 ) {
+		return;
+	}
+
+	if (strlen(subdirs)) {
+		Com_sprintf( search, sizeof(search), "%s\\%s\\*", basedir, subdirs );
+	}
+	else {
+		Com_sprintf( search, sizeof(search), "%s\\*", basedir );
+	}
+
+	findhandle = _findfirst (search, &findinfo);
+	if (findhandle == -1) {
+		return;
+	}
+
+	do {
+		if (findinfo.attrib & _A_SUBDIR) {
+			if (Q_stricmp(findinfo.name, ".") && Q_stricmp(findinfo.name, "..")) {
+				if (strlen(subdirs)) {
+					Com_sprintf( newsubdirs, sizeof(newsubdirs), "%s\\%s", subdirs, findinfo.name);
+				}
+				else {
+					Com_sprintf( newsubdirs, sizeof(newsubdirs), "%s", findinfo.name);
+				}
+				Sys_ListFilteredFiles( basedir, newsubdirs, filter, psList, numfiles );
+			}
+		}
+		if ( *numfiles >= MAX_FOUND_FILES - 1 ) {
+			break;
+		}
+		Com_sprintf( filename, sizeof(filename), "%s\\%s", subdirs, findinfo.name );
+		if (!Com_FilterPath( filter, filename, qfalse ))
+			continue;
+		psList[ *numfiles ] = CopyString( filename );
+		(*numfiles)++;
+	} while ( _findnext (findhandle, &findinfo) != -1 );
+
+	_findclose (findhandle);
+}
+
+static qboolean strgtr(const char *s0, const char *s1) {
+	int l0, l1, i;
+
+	l0 = strlen(s0);
+	l1 = strlen(s1);
+
+	if (l1<l0) {
+		l0 = l1;
+	}
+
+	for(i=0;i<l0;i++) {
+		if (s1[i] > s0[i]) {
+			return qtrue;
+		}
+		if (s1[i] < s0[i]) {
+			return qfalse;
+		}
+	}
+	return qfalse;
+}
+
+char **Sys_ListFiles( const char *directory, const char *extension, char *filter, int *numfiles, qboolean wantsubs ) {
+	char		search[MAX_OSPATH];
+	int			nfiles;
+	char		**listCopy;
+	char		*list[MAX_FOUND_FILES];
+	struct _finddata_t findinfo;
+	int			findhandle;
+	int			flag;
+	int			i;
+
+	if (filter) {
+
+		nfiles = 0;
+		Sys_ListFilteredFiles( directory, "", filter, list, &nfiles );
+
+		list[ nfiles ] = 0;
+		*numfiles = nfiles;
+
+		if (!nfiles)
+			return NULL;
+
+		listCopy = (char **)Z_Malloc( ( nfiles + 1 ) * sizeof( *listCopy ), TAG_FILESYS );
+		for ( i = 0 ; i < nfiles ; i++ ) {
+			listCopy[i] = list[i];
+		}
+		listCopy[i] = NULL;
+
+		return listCopy;
+	}
+
+	if ( !extension) {
+		extension = "";
+	}
+
+	// passing a slash as extension will find directories
+	if ( extension[0] == '/' && extension[1] == 0 ) {
+		extension = "";
+		flag = 0;
+	} else {
+		flag = _A_SUBDIR;
+	}
+
+	Com_sprintf( search, sizeof(search), "%s\\*%s", directory, extension );
+
+	// search
+	nfiles = 0;
+
+	findhandle = _findfirst (search, &findinfo);
+	if (findhandle == -1) {
+		*numfiles = 0;
+		return NULL;
+	}
+
+	do {
+		if ( (!wantsubs && flag ^ ( findinfo.attrib & _A_SUBDIR )) || (wantsubs && findinfo.attrib & _A_SUBDIR) ) {
+			if ( nfiles == MAX_FOUND_FILES - 1 ) {
+				break;
+			}
+			list[ nfiles ] = CopyString( findinfo.name );
+			nfiles++;
+		}
+	} while ( _findnext (findhandle, &findinfo) != -1 );
+
+	list[ nfiles ] = 0;
+
+	_findclose (findhandle);
+
+	// return a copy of the list
+	*numfiles = nfiles;
+
+	if ( !nfiles ) {
+		return NULL;
+	}
+
+	listCopy = (char **)Z_Malloc( ( nfiles + 1 ) * sizeof( *listCopy ), TAG_FILESYS );
+	for ( i = 0 ; i < nfiles ; i++ ) {
+		listCopy[i] = list[i];
+	}
+	listCopy[i] = NULL;
+
+	do {
+		flag = 0;
+		for(i=1; i<nfiles; i++) {
+			if (strgtr(listCopy[i-1], listCopy[i])) {
+				char *temp = listCopy[i];
+				listCopy[i] = listCopy[i-1];
+				listCopy[i-1] = temp;
+				flag = 1;
+			}
+		}
+	} while(flag);
+
+	return listCopy;
+}
+
+void	Sys_FreeFileList( char **psList ) {
+	int		i;
+
+	if ( !psList ) {
+		return;
+	}
+
+	for ( i = 0 ; psList[i] ; i++ ) {
+		Z_Free( psList[i] );
+	}
+
+	Z_Free( psList );
+}
+
+//========================================================
+
+
+/*
+================
+Sys_ScanForCD
+
+Search all the drives to see if there is a valid CD to grab
+the cddir from
+================
+*/
+#ifdef FINAL_BUILD
+static qboolean Sys_ScanForCD( void ) {
+	char		drive[4];
+	FILE		*f;
+	char		test[MAX_OSPATH];
+
+	drive[0] = 'c';
+	drive[1] = ':';
+	drive[2] = '\\';
+	drive[3] = 0;
+
+	// scan the drives
+	for ( drive[0] = 'c' ; drive[0] <= 'z' ; drive[0]++ ) {
+		if ( GetDriveType (drive) == DRIVE_CDROM ) {
+			BOOL Result;
+			char VolumeName[MAX_PATH],FileSystemName[MAX_PATH];
+			DWORD VolumeSerialNumber,MaximumComponentLength,FileSystemFlags;
+			
+			Result = GetVolumeInformation(drive,VolumeName,sizeof(VolumeName),&VolumeSerialNumber,
+				&MaximumComponentLength,&FileSystemFlags,FileSystemName,sizeof(FileSystemName));
+			
+			if (Result && (strcmpi(VolumeName,"JEDIOUTCAST") == 0 ) )
+			{
+				sprintf (test, "%s%s\\%s",drive, CD_BASEDIR, CD_EXE);
+				f = fopen( test, "r" );
+				if ( f ) {
+					fclose (f);
+					return qtrue;
+				} else {
+					sprintf(test, "%s%s\\%s", drive, CD_BASEDIR, CD_EXE_LINUX);
+					f = fopen( test, "r" );
+					if ( f ) {
+						fclose (f);
+						return qtrue;
+					}
+				}
+			}
+		}
+	}
+
+	return qfalse;
+}
+#endif
+/*
+================
+Sys_CheckCD
+
+Return true if the proper CD is in the drive
+================
+*/
+qboolean	Sys_CheckCD( void ) {
+#ifdef FINAL_BUILD
+//	return Sys_ScanForCD();
+#else
+	return qtrue;
+#endif
+}
+
+
+/*
+================
+Sys_GetClipboardData
+
+================
+*/
+char *Sys_GetClipboardData( void ) {
+	char *data = NULL;
+	char *cliptext;
+
+	if ( OpenClipboard( NULL ) != 0 ) {
+		HANDLE hClipboardData;
+
+		if ( ( hClipboardData = GetClipboardData( CF_TEXT ) ) != 0 ) {
+			if ( ( cliptext = (char *)GlobalLock( hClipboardData ) ) != 0 ) {
+				data = (char *)Z_Malloc( GlobalSize( hClipboardData ) + 1, TAG_CLIPBOARD);
+				Q_strncpyz( data, cliptext, GlobalSize( hClipboardData )+1 );
+				GlobalUnlock( hClipboardData );
+				
+				strtok( data, "\n\r\b" );
+			}
+		}
+		CloseClipboard();
+	}
+	return data;
+}
+
+
+/*
+========================================================================
+
+LOAD/UNLOAD DLL
+
+========================================================================
+*/
+
+/*
+=================
+Sys_UnloadDll
+
+=================
+*/
+void Sys_UnloadDll( void *dllHandle ) {
+	if ( !dllHandle ) {
+		return;
+	}
+	if ( !FreeLibrary( (struct HINSTANCE__ *)dllHandle ) ) {
+		Com_Error (ERR_FATAL, "Sys_UnloadDll FreeLibrary failed");
+	}
+}
+
+/*
+=================
+Sys_LoadDll
+
+Used to load a development dll instead of a virtual machine
+=================
+*/
+extern char		*FS_BuildOSPath( const char *base, const char *game, const char *qpath );
+
+void * QDECL Sys_LoadDll( const char *name, int (QDECL **entryPoint)(int, ...),
+				  int (QDECL *systemcalls)(int, ...) ) {
+	static int	lastWarning = 0;
+	HINSTANCE	libHandle;
+	void	(QDECL *dllEntry)( int (QDECL *syscallptr)(int, ...) );
+	char	*basepath;
+	char	*cdpath;
+	char	*gamedir;
+	char	*fn;
+#ifdef NDEBUG
+	int		timestamp;
+  int   ret;
+#endif
+	char	filename[MAX_QPATH];
+
+	Com_sprintf( filename, sizeof( filename ), "%sx86.dll", name );
+
+#ifdef NDEBUG
+	timestamp = Sys_Milliseconds();
+//	if( ((timestamp - lastWarning) > (5 * 60000)) && !Cvar_VariableIntegerValue( "dedicated" )
+//		&& !Cvar_VariableIntegerValue( "com_blindlyLoadDLLs" ) ) {
+	if (0) {
+		if (FS_FileExists(filename)) {
+			lastWarning = timestamp;
+			ret = MessageBoxEx( NULL, "You are about to load a .DLL executable that\n"
+				  "has not been verified for use with Quake III Arena.\n"
+				  "This type of file can compromise the security of\n"
+				  "your computer.\n\n"
+				  "Select 'OK' if you choose to load it anyway.",
+				  "Security Warning", MB_OKCANCEL | MB_ICONEXCLAMATION | MB_DEFBUTTON2 | MB_TOPMOST | MB_SETFOREGROUND,
+				  MAKELANGID( LANG_NEUTRAL, SUBLANG_DEFAULT ) );
+			if( ret != IDOK ) {
+				return NULL;
+			}
+		}
+	}
+#endif
+
+
+// rjr disable for final release #ifndef NDEBUG
+	libHandle = LoadLibrary( filename );
+	if ( !libHandle ) {
+//#endif
+	basepath = Cvar_VariableString( "fs_basepath" );
+	cdpath = Cvar_VariableString( "fs_cdpath" );
+	gamedir = Cvar_VariableString( "fs_game" );
+
+	fn = FS_BuildOSPath( basepath, gamedir, filename );
+	libHandle = LoadLibrary( fn );
+
+	if ( !libHandle ) {
+		if( cdpath[0] ) {
+			fn = FS_BuildOSPath( cdpath, gamedir, filename );
+			libHandle = LoadLibrary( fn );
+		}
+
+		if ( !libHandle ) {
+			return NULL;
+		}
+	}
+//#ifndef NDEBUG
+	}
+//#endif
+
+	dllEntry = ( void (QDECL *)( int (QDECL *)( int, ... ) ) )GetProcAddress( libHandle, "dllEntry" ); 
+	*entryPoint = (int (QDECL *)(int,...))GetProcAddress( libHandle, "vmMain" );
+	if ( !*entryPoint || !dllEntry ) {
+		FreeLibrary( libHandle );
+		return NULL;
+	}
+	dllEntry( systemcalls );
+
+	return libHandle;
+}
+
+
+/*
+========================================================================
+
+BACKGROUND FILE STREAMING
+
+========================================================================
+*/
+
+#if 1
+
+void Sys_InitStreamThread( void ) {
+}
+
+void Sys_ShutdownStreamThread( void ) {
+}
+
+void Sys_BeginStreamedFile( fileHandle_t f, int readAhead ) {
+}
+
+void Sys_EndStreamedFile( fileHandle_t f ) {
+}
+
+int Sys_StreamedRead( void *buffer, int size, int count, fileHandle_t f ) {
+   return FS_Read( buffer, size * count, f );
+}
+
+void Sys_StreamSeek( fileHandle_t f, int offset, int origin ) {
+   FS_Seek( f, offset, origin );
+}
+
+
+#else
+
+typedef struct {
+	fileHandle_t	file;
+	byte	*buffer;
+	qboolean	eof;
+	qboolean	active;
+	int		bufferSize;
+	int		streamPosition;	// next byte to be returned by Sys_StreamRead
+	int		threadPosition;	// next byte to be read from file
+} streamsIO_t;
+
+typedef struct {
+	HANDLE				threadHandle;
+	int					threadId;
+	CRITICAL_SECTION	crit;
+	streamsIO_t			sIO[MAX_FILE_HANDLES];
+} streamState_t;
+
+streamState_t	stream;
+
+/*
+===============
+Sys_StreamThread
+
+A thread will be sitting in this loop forever
+================
+*/
+void Sys_StreamThread( void ) {
+	int		buffer;
+	int		count;
+	int		readCount;
+	int		bufferPoint;
+	int		r, i;
+
+	while (1) {
+		Sleep( 10 );
+//		EnterCriticalSection (&stream.crit);
+
+		for (i=1;i<MAX_FILE_HANDLES;i++) {
+			// if there is any space left in the buffer, fill it up
+			if ( stream.sIO[i].active  && !stream.sIO[i].eof ) {
+				count = stream.sIO[i].bufferSize - (stream.sIO[i].threadPosition - stream.sIO[i].streamPosition);
+				if ( !count ) {
+					continue;
+				}
+
+				bufferPoint = stream.sIO[i].threadPosition % stream.sIO[i].bufferSize;
+				buffer = stream.sIO[i].bufferSize - bufferPoint;
+				readCount = buffer < count ? buffer : count;
+
+				r = FS_Read( stream.sIO[i].buffer + bufferPoint, readCount, stream.sIO[i].file );
+				stream.sIO[i].threadPosition += r;
+
+				if ( r != readCount ) {
+					stream.sIO[i].eof = qtrue;
+				}
+			}
+		}
+//		LeaveCriticalSection (&stream.crit);
+	}
+}
+
+/*
+===============
+Sys_InitStreamThread
+
+================
+*/
+void Sys_InitStreamThread( void ) {
+	int i;
+
+	InitializeCriticalSection ( &stream.crit );
+
+	// don't leave the critical section until there is a
+	// valid file to stream, which will cause the StreamThread
+	// to sleep without any overhead
+//	EnterCriticalSection( &stream.crit );
+
+	stream.threadHandle = CreateThread(
+	   NULL,	// LPSECURITY_ATTRIBUTES lpsa,
+	   0,		// DWORD cbStack,
+	   (LPTHREAD_START_ROUTINE)Sys_StreamThread,	// LPTHREAD_START_ROUTINE lpStartAddr,
+	   0,			// LPVOID lpvThreadParm,
+	   0,			//   DWORD fdwCreate,
+	   &stream.threadId);
+	for(i=0;i<MAX_FILE_HANDLES;i++) {
+		stream.sIO[i].active = qfalse;
+	}
+}
+
+/*
+===============
+Sys_ShutdownStreamThread
+
+================
+*/
+void Sys_ShutdownStreamThread( void ) {
+}
+
+
+/*
+===============
+Sys_BeginStreamedFile
+
+================
+*/
+void Sys_BeginStreamedFile( fileHandle_t f, int readAhead ) {
+	if ( stream.sIO[f].file ) {
+		Sys_EndStreamedFile( stream.sIO[f].file );
+	}
+
+	stream.sIO[f].file = f;
+	stream.sIO[f].buffer = Z_Malloc( readAhead );
+	stream.sIO[f].bufferSize = readAhead;
+	stream.sIO[f].streamPosition = 0;
+	stream.sIO[f].threadPosition = 0;
+	stream.sIO[f].eof = qfalse;
+	stream.sIO[f].active = qtrue;
+
+	// let the thread start running
+//	LeaveCriticalSection( &stream.crit );
+}
+
+/*
+===============
+Sys_EndStreamedFile
+
+================
+*/
+void Sys_EndStreamedFile( fileHandle_t f ) {
+	if ( f != stream.sIO[f].file ) {
+		Com_Error( ERR_FATAL, "Sys_EndStreamedFile: wrong file");
+	}
+	// don't leave critical section until another stream is started
+	EnterCriticalSection( &stream.crit );
+
+	stream.sIO[f].file = 0;
+	stream.sIO[f].active = qfalse;
+
+	Z_Free( stream.sIO[f].buffer );
+
+	LeaveCriticalSection( &stream.crit );
+}
+
+
+/*
+===============
+Sys_StreamedRead
+
+================
+*/
+int Sys_StreamedRead( void *buffer, int size, int count, fileHandle_t f ) {
+	int		available;
+	int		remaining;
+	int		sleepCount;
+	int		copy;
+	int		bufferCount;
+	int		bufferPoint;
+	byte	*dest;
+
+	if (stream.sIO[f].active == qfalse) {
+		Com_Error( ERR_FATAL, "Streamed read with non-streaming file" );
+	}
+
+	dest = (byte *)buffer;
+	remaining = size * count;
+
+	if ( remaining <= 0 ) {
+		Com_Error( ERR_FATAL, "Streamed read with non-positive size" );
+	}
+
+	sleepCount = 0;
+	while ( remaining > 0 ) {
+		available = stream.sIO[f].threadPosition - stream.sIO[f].streamPosition;
+		if ( !available ) {
+			if ( stream.sIO[f].eof ) {
+				break;
+			}
+			if ( sleepCount == 1 ) {
+				Com_DPrintf( "Sys_StreamedRead: waiting\n" );
+			}
+			if ( ++sleepCount > 100 ) {
+				Com_Error( ERR_FATAL, "Sys_StreamedRead: thread has died");
+			}
+			Sleep( 10 );
+			continue;
+		}
+
+		EnterCriticalSection( &stream.crit );
+
+		bufferPoint = stream.sIO[f].streamPosition % stream.sIO[f].bufferSize;
+		bufferCount = stream.sIO[f].bufferSize - bufferPoint;
+
+		copy = available < bufferCount ? available : bufferCount;
+		if ( copy > remaining ) {
+			copy = remaining;
+		}
+		memcpy( dest, stream.sIO[f].buffer + bufferPoint, copy );
+		stream.sIO[f].streamPosition += copy;
+		dest += copy;
+		remaining -= copy;
+
+		LeaveCriticalSection( &stream.crit );
+	}
+
+	return (count * size - remaining) / size;
+}
+
+/*
+===============
+Sys_StreamSeek
+
+================
+*/
+void Sys_StreamSeek( fileHandle_t f, int offset, int origin ) {
+
+	// halt the thread
+	EnterCriticalSection( &stream.crit );
+
+	// clear to that point
+	FS_Seek( f, offset, origin );
+	stream.sIO[f].streamPosition = 0;
+	stream.sIO[f].threadPosition = 0;
+	stream.sIO[f].eof = qfalse;
+
+	// let the thread start running at the new position
+	LeaveCriticalSection( &stream.crit );
+}
+
+#endif
+
+/*
+========================================================================
+
+EVENT LOOP
+
+========================================================================
+*/
+
+#define	MAX_QUED_EVENTS		256
+#define	MASK_QUED_EVENTS	( MAX_QUED_EVENTS - 1 )
+
+sysEvent_t	eventQue[MAX_QUED_EVENTS];
+static int	eventHead=0;
+static int	eventTail=0;
+byte		sys_packetReceived[MAX_MSGLEN];
+
+/*
+================
+Sys_QueEvent
+
+A time of 0 will get the current time
+Ptr should either be null, or point to a block of data that can
+be freed by the game later.
+================
+*/
+void Sys_QueEvent( int time, sysEventType_t type, int value, int value2, int ptrLength, void *ptr ) {
+	sysEvent_t	*ev;
+
+	ev = &eventQue[ eventHead & MASK_QUED_EVENTS ];
+	if ( eventHead - eventTail >= MAX_QUED_EVENTS ) {
+		Com_Printf("Sys_QueEvent: overflow\n");
+		// we are discarding an event, but don't leak memory
+		if ( ev->evPtr ) {
+			Z_Free( ev->evPtr );
+		}
+		eventTail++;
+	}
+
+	eventHead++;
+
+	if ( time == 0 ) {
+		time = Sys_Milliseconds();
+	}
+
+	ev->evTime = time;
+	ev->evType = type;
+	ev->evValue = value;
+	ev->evValue2 = value2;
+	ev->evPtrLength = ptrLength;
+	ev->evPtr = ptr;
+}
+
+/*
+================
+Sys_GetEvent
+
+================
+*/
+sysEvent_t Sys_GetEvent( void ) {
+    MSG			msg;
+	sysEvent_t	ev;
+	char		*s;
+	msg_t		netmsg;
+	netadr_t	adr;
+
+	// return if we have data
+	if ( eventHead > eventTail ) {
+		eventTail++;
+		return eventQue[ ( eventTail - 1 ) & MASK_QUED_EVENTS ];
+	}
+
+	// pump the message loop
+	while (PeekMessage (&msg, NULL, 0, 0, PM_NOREMOVE)) {
+		if ( !GetMessage (&msg, NULL, 0, 0) ) {
+			Com_Quit_f();
+		}
+
+		// save the msg time, because wndprocs don't have access to the timestamp
+//		g_wv.sysMsgTime = msg.time;
+
+		TranslateMessage (&msg);
+      	DispatchMessage (&msg);
+	}
+
+	// check for console commands
+	s = Sys_ConsoleInput();
+	if ( s ) {
+		char	*b;
+		int		len;
+
+		len = strlen( s ) + 1;
+		b = (char *)Z_Malloc( len, TAG_EVENT );
+		Q_strncpyz( b, s, len );
+		Sys_QueEvent( 0, SE_CONSOLE, 0, 0, len, b );
+	}
+
+	// check for network packets
+	MSG_Init( &netmsg, sys_packetReceived, sizeof( sys_packetReceived ) );
+	if ( Sys_GetPacket ( &adr, &netmsg ) ) {
+		netadr_t		*buf;
+		int				len;
+
+		// copy out to a seperate buffer for qeueing
+		// the readcount stepahead is for SOCKS support
+		len = sizeof( netadr_t ) + netmsg.cursize - netmsg.readcount;
+		buf = (netadr_t *)Z_Malloc( len, TAG_EVENT, qtrue );
+		*buf = adr;
+		memcpy( buf+1, &netmsg.data[netmsg.readcount], netmsg.cursize - netmsg.readcount );
+		Sys_QueEvent( 0, SE_PACKET, 0, 0, len, buf );
+	}
+
+	// return if we have data
+	if ( eventHead > eventTail ) {
+		eventTail++;
+		return eventQue[ ( eventTail - 1 ) & MASK_QUED_EVENTS ];
+	}
+
+	// create an empty event to return
+
+	memset( &ev, 0, sizeof( ev ) );
+	ev.evTime = timeGetTime();
+
+	return ev;
+}
+
+//================================================================
+
+/*
+=================
+Sys_In_Restart_f
+
+Restart the input subsystem
+=================
+*/
+void Sys_In_Restart_f( void ) {
+	IN_Shutdown();
+	IN_Init();
+}
+
+
+/*
+=================
+Sys_Net_Restart_f
+
+Restart the network subsystem
+=================
+*/
+void Sys_Net_Restart_f( void ) {
+	NET_Restart();
+}
+
+
+/*
+================
+Sys_Init
+
+Called after the common systems (cvars, files, etc)
+are initialized
+================
+*/
+#define OSR2_BUILD_NUMBER 1111
+#define WIN98_BUILD_NUMBER 1998
+
+void Sys_Init( void ) {
+	int cpuid;
+
+	// make sure the timer is high precision, otherwise
+	// NT gets 18ms resolution
+	timeBeginPeriod( 1 );
+
+	Cmd_AddCommand ("in_restart", Sys_In_Restart_f);
+	Cmd_AddCommand ("net_restart", Sys_Net_Restart_f);
+
+//	g_wv.osversion.dwOSVersionInfoSize = sizeof( g_wv.osversion );
+
+//	if (!GetVersionEx (&g_wv.osversion))
+//		Sys_Error ("Couldn't get OS info");
+
+//	if (g_wv.osversion.dwMajorVersion < 4)
+//		Sys_Error ("This game requires Windows version 4 or greater");
+//	if (g_wv.osversion.dwPlatformId == VER_PLATFORM_WIN32s)
+//		Sys_Error ("This game doesn't run on Win32s");
+
+//	if ( g_wv.osversion.dwPlatformId == VER_PLATFORM_WIN32_NT )
+//	{
+//		Cvar_Set( "arch", "winnt" );
+//	}
+//	else if ( g_wv.osversion.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS )
+//	{
+//		if ( LOWORD( g_wv.osversion.dwBuildNumber ) >= WIN98_BUILD_NUMBER )
+//		{
+//			Cvar_Set( "arch", "win98" );
+//		}
+//		else if ( LOWORD( g_wv.osversion.dwBuildNumber ) >= OSR2_BUILD_NUMBER )
+//		{
+//			Cvar_Set( "arch", "win95 osr2.x" );
+//		}
+//		else
+//		{
+//			Cvar_Set( "arch", "win95" );
+//		}
+//	}
+//	else
+//	{
+//		Cvar_Set( "arch", "unknown Windows variant" );
+//	}
+
+	// save out a couple things in rom cvars for the renderer to access
+//	Cvar_Get( "win_hinstance", va("%i", (int)g_wv.hInstance), CVAR_ROM );
+//	Cvar_Get( "win_wndproc", va("%i", (int)MainWndProc), CVAR_ROM );
+
+	//
+	// figure out our CPU
+	//
+	Cvar_Get( "sys_cpustring", "detect", 0 );
+	if ( !Q_stricmp( Cvar_VariableString( "sys_cpustring"), "detect" ) )
+	{
+		Com_Printf( "...detecting CPU, found " );
+
+		cpuid = Sys_GetProcessorId();
+
+		switch ( cpuid )
+		{
+		case CPUID_GENERIC:
+			Cvar_Set( "sys_cpustring", "generic" );
+			break;
+		case CPUID_INTEL_UNSUPPORTED:
+			Cvar_Set( "sys_cpustring", "x86 (pre-Pentium)" );
+			break;
+		case CPUID_INTEL_PENTIUM:
+			Cvar_Set( "sys_cpustring", "x86 (P5/PPro, non-MMX)" );
+			break;
+		case CPUID_INTEL_MMX:
+			Cvar_Set( "sys_cpustring", "x86 (P5/Pentium2, MMX)" );
+			break;
+		case CPUID_INTEL_KATMAI:
+			Cvar_Set( "sys_cpustring", "Intel Pentium III" );
+			break;
+		case CPUID_INTEL_WILLIAMETTE:
+			Cvar_Set( "sys_cpustring", "Intel Pentium IV" );
+			break;
+		case CPUID_AMD_3DNOW:
+			Cvar_Set( "sys_cpustring", "AMD w/ 3DNow!" );
+			break;
+		case CPUID_AXP:
+			Cvar_Set( "sys_cpustring", "Alpha AXP" );
+			break;
+		default:
+			Com_Error( ERR_FATAL, "Unknown cpu type %d\n", cpuid );
+			break;
+		}
+	}
+	else
+	{
+		Com_Printf( "...forcing CPU type to " );
+		if ( !Q_stricmp( Cvar_VariableString( "sys_cpustring" ), "generic" ) )
+		{
+			cpuid = CPUID_GENERIC;
+		}
+		else if ( !Q_stricmp( Cvar_VariableString( "sys_cpustring" ), "x87" ) )
+		{
+			cpuid = CPUID_INTEL_PENTIUM;
+		}
+		else if ( !Q_stricmp( Cvar_VariableString( "sys_cpustring" ), "mmx" ) )
+		{
+			cpuid = CPUID_INTEL_MMX;
+		}
+		else if ( !Q_stricmp( Cvar_VariableString( "sys_cpustring" ), "3dnow" ) )
+		{
+			cpuid = CPUID_AMD_3DNOW;
+		}
+		else if ( !Q_stricmp( Cvar_VariableString( "sys_cpustring" ), "PentiumIII" ) )
+		{
+			cpuid = CPUID_INTEL_KATMAI;
+		}
+		else if ( !Q_stricmp( Cvar_VariableString( "sys_cpustring" ), "PentiumIV" ) )
+		{
+			cpuid = CPUID_INTEL_WILLIAMETTE;
+		}
+		else if ( !Q_stricmp( Cvar_VariableString( "sys_cpustring" ), "axp" ) )
+		{
+			cpuid = CPUID_AXP;
+		}
+		else
+		{
+			Com_Printf( "WARNING: unknown sys_cpustring '%s'\n", Cvar_VariableString( "sys_cpustring" ) );
+			cpuid = CPUID_GENERIC;
+		}
+	}
+	Cvar_SetValue( "sys_cpuid", cpuid );
+	Com_Printf( "%s\n", Cvar_VariableString( "sys_cpustring" ) );
+
+	Cvar_Set( "username", Sys_GetCurrentUser() );
+
+	IN_Init();		// FIXME: not in dedicated?
+}
+
+
+//=======================================================================
+//int	totalMsec, countMsec;
+
+/*
+==================
+WinMain
+
+==================
+*/
+//int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow) {
+int main(int argc, char **argv)
+{
+	char		cwd[MAX_OSPATH];
+	char *cmdline;
+	int i,len;
+//	int			startTime, endTime;
+
+    // should never get a previous instance in Win32
+//    if ( hPrevInstance ) {
+//        return 0;
+//	}
+
+//	sys_checksum = Sys_CodeInMemoryChecksum( hInstance );
+//	Sys_VerifyCodeChecksum( hInstance );
+
+	// merge the command line, this is kinda silly
+	for (len = 1, i = 1; i < argc; i++)
+		len += strlen(argv[i]) + 1;
+	cmdline = (char *)malloc(len);
+	*cmdline = 0;
+	for (i = 1; i < argc; i++) {
+		if (i > 1)
+			strcat(cmdline, " ");
+		strcat(cmdline, argv[i]);
+	}
+
+//	g_wv.hInstance = hInstance;
+//	Q_strncpyz( sys_cmdline, lpCmdLine, sizeof( sys_cmdline ) );
+
+
+	// done before Com/Sys_Init since we need this for error output
+//	Sys_CreateConsole();
+
+	// no abort/retry/fail errors
+	SetErrorMode( SEM_FAILCRITICALERRORS );
+
+	// get the initial time base
+	Sys_Milliseconds();
+
+#if 0
+	// if we find the CD, add a +set cddir xxx command line
+	Sys_ScanForCD();
+#endif
+
+
+	Sys_InitStreamThread();
+
+	Com_Init( cmdline );
+
+	NET_Init();
+
+	_getcwd (cwd, sizeof(cwd));
+	Com_Printf("Working directory: %s\n", cwd);
+
+	// hide the early console since we've reached the point where we
+	// have a working graphics subsystems
+	if ( !com_dedicated->integer && !com_viewlog->integer ) {
+		Sys_ShowConsole( 0, qfalse );
+	}
+
+#ifdef _DEBUG
+	if ( sys_monkeySpank ) {
+		Cvar_Set("cl_trn", "666");
+	}
+#endif
+
+    // main game loop
+	while( 1 ) {
+		// if not running as a game client, sleep a bit
+//		if ( g_wv.isMinimized || ( com_dedicated && com_dedicated->integer ) ) {
+			Sleep( 5 );
+//		}
+
+		// set low precision every frame, because some system calls
+		// reset it arbitrarily
+//		_controlfp( _PC_24, _MCW_PC );
+ 
+//		startTime = Sys_Milliseconds();
+
+		// make sure mouse and joystick are only called once a frame
+		IN_Frame();
+
+		// run the game
+		Com_Frame();
+
+//		endTime = Sys_Milliseconds();
+//		totalMsec += endTime - startTime;
+//		countMsec++;
+	}
+
+	// never gets here
+	return 0;
+}
+
+
diff --git a/codemp/png/png.cpp b/codemp/png/png.cpp
new file mode 100644
index 0000000..66d4a47
--- /dev/null
+++ b/codemp/png/png.cpp
@@ -0,0 +1,783 @@
+// Generic PNG file loading code
+
+// leave this as first line for PCH reasons...
+//
+#include "../game/q_shared.h"
+#include "../qcommon/qcommon.h"
+
+#include "../zlib32/zip.h"
+#include "png.h"
+//#include "../qcommon/memory.h"
+
+// Error returns
+
+#define PNG_ERROR_OK			0
+#define PNG_ERROR_DECOMP		1
+#define PNG_ERROR_COMP			2
+#define PNG_ERROR_MEMORY		3
+#define PNG_ERROR_NOSIG	   		4
+#define PNG_ERROR_TOO_SMALL	   	5
+#define PNG_ERROR_WNP2	   		6
+#define PNG_ERROR_HNP2	   		7
+#define PNG_ERROR_NOT_TC	   	8
+#define PNG_ERROR_INV_FIL	   	9
+#define PNG_ERROR_FAILED_CRC	10
+#define PNG_ERROR_CREATE_FAIL	11
+#define PNG_ERROR_WRITE			12
+#define PNG_ERROR_NOT_PALETTE	13
+#define PNG_ERROR_NOT8BIT		14
+#define PNG_ERROR_TOO_LARGE		15
+
+static int png_error = PNG_ERROR_OK;
+
+static const byte png_signature[8] = { 0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a };
+static const char png_copyright[] = "Copyright\0Raven Software Inc. 2001";
+static const char *png_errors[] = 
+{
+	"OK.",
+	"Error decompressing image data.",
+	"Error compressing image data.",
+	"Error allocating memory.",
+	"PNG signature not found.",
+	"Image is too small to load.",
+	"Width is not a power of two.",
+	"Height is not a power of two.",
+	"Image is not 24 or 32 bit.",
+	"Invalid filter or compression type.",
+	"Failed CRC check.",
+	"Could not create file.",
+	"Error writing to file.",
+	"Image is not indexed colour.",
+	"Image does not have 8 bits per sample.",
+	"Image is too large",
+};
+
+// Gets the error string for a failed PNG operation
+
+const char *PNG_GetError(void)
+{
+	return(png_errors[png_error]);
+}
+
+// Create a header chunk
+
+void PNG_CreateHeader(png_ihdr_t *header, int width, int height, int bytedepth)
+{
+	header->width = BigLong(width);
+	header->height = BigLong(height);
+	header->bitdepth = 8;
+
+	if(bytedepth == 3)
+	{
+		header->colortype = 2;
+	}
+	if(bytedepth == 4)
+	{
+		header->colortype = 6;
+	}
+	header->compression = 0;
+	header->filter = 0;
+	header->interlace = 0;
+}
+
+// Processes the header chunk and checks to see if all the data is valid
+
+bool PNG_HandleIHDR(const byte *data, png_image_t *image)
+{
+	png_ihdr_t *ihdr = (png_ihdr_t *)data;
+
+	image->width = BigLong(ihdr->width);
+	image->height = BigLong(ihdr->height);
+
+	// Make sure image is a reasonable size
+	if((image->width < 2) || (image->height < 2))
+	{
+		png_error = PNG_ERROR_TOO_SMALL;
+		return(false);
+	}
+	if(image->width > MAX_PNG_WIDTH)
+	{
+		png_error = PNG_ERROR_TOO_LARGE;
+		return(false);
+	}
+	if(ihdr->bitdepth != 8)
+	{
+		png_error = PNG_ERROR_NOT8BIT;
+		return(false);
+	}
+	// Check for non power of two size (but not for data files)
+	if(image->isimage)
+	{
+		if(image->width & (image->width - 1))
+		{
+			png_error = PNG_ERROR_WNP2;
+			return(false);
+		}
+		if(image->height & (image->height - 1))
+		{
+			png_error = PNG_ERROR_HNP2;
+			return(false);
+		}
+	}
+	// Make sure we have a 24 or 32 bit image (for images)
+	if(image->isimage)
+	{
+		if((ihdr->colortype != 2) && (ihdr->colortype != 6))
+		{
+			png_error = PNG_ERROR_NOT_TC;
+			return(false);
+		}
+	}
+	// Make sure we have an 8 bit grayscale image for data files
+	if(!image->isimage)
+	{
+		if(ihdr->colortype && (ihdr->colortype != 3))
+		{
+			png_error = PNG_ERROR_NOT_PALETTE;
+			return(false);
+		}
+	}
+	// Make sure we aren't using any wacky compression or filter algos
+	if(ihdr->compression || ihdr->filter)
+	{
+		png_error = PNG_ERROR_INV_FIL;
+		return(false);
+	}
+	// Extract the data we need
+	if(!ihdr->colortype || (ihdr->colortype == 3))
+	{
+		image->bytedepth = 1;
+	}
+	if(ihdr->colortype == 2)
+	{
+		image->bytedepth = 3;
+	}
+	if(ihdr->colortype == 6)
+	{
+		image->bytedepth = 4;
+	}
+	return(true);
+}
+
+// Filter a row of data
+
+void PNG_Filter(byte *out, byte filter, const byte *in, const byte *lastline, ulong rowbytes, ulong bpp)
+{
+	ulong		i;
+
+	switch(filter)
+	{
+	case PNG_FILTER_VALUE_NONE:
+		memcpy(out, in, rowbytes);
+		break;
+	case PNG_FILTER_VALUE_SUB:
+		for(i = 0; i < bpp; i++)
+		{
+			*out++ = *in++;
+		}
+		for(i = bpp; i < rowbytes; i++)
+		{
+			*out++ = *in - *(in - bpp);
+			in++;
+		}
+		break;
+	case PNG_FILTER_VALUE_UP:
+		for(i = 0; i < rowbytes; i++)
+		{
+			if(lastline)
+			{
+				*out++ = *in++ - *lastline++;
+			}
+			else
+			{
+				*out++ = *in++;
+			}
+		}
+		break;
+	case PNG_FILTER_VALUE_AVG:
+		for(i = 0; i < bpp; i++)
+		{
+			if(lastline)
+			{
+				*out++ = *in++ - (*lastline++ >> 1);
+			}
+			else
+			{
+				*out++ = *in++;
+			}
+		}
+		for(i = bpp; i < rowbytes; i++)
+		{
+			if(lastline)
+			{
+				*out++ = *in - ((*lastline++ + *(in - bpp)) >> 1);
+			}
+			else
+			{
+				*out++ = *in - (*(in - bpp) >> 1);
+			}
+			in++;
+		}
+		break;
+	case PNG_FILTER_VALUE_PAETH:
+		int			a, b, c;
+		int			pa, pb, pc, p;
+
+		for(i = 0; i < bpp; i++)
+		{
+			if(lastline)
+			{
+				*out++ = *in++ - *lastline++;
+			}
+			else
+			{
+				*out++ = *in++;
+			}
+		}
+		for(i = bpp; i < rowbytes; i++)
+		{
+			a = *(in - bpp);
+			c = 0;
+			b = 0;
+			if(lastline)
+			{
+				c = *(lastline - bpp);
+				b = *lastline++;
+			}
+
+			p = b - c;
+			pc = a - c;
+
+			pa = p < 0 ? -p : p;
+			pb = pc < 0 ? -pc : pc;
+			pc = (p + pc) < 0 ? -(p + pc) : p + pc;
+
+			p = (pa <= pb && pa <= pc) ? a : (pb <= pc) ? b : c;
+
+			*out++ = *in++ - p;
+		}
+		break;
+	}
+}
+
+// Unfilters a row of data
+
+void PNG_Unfilter(byte *out, byte filter, const byte *lastline, ulong rowbytes, ulong bpp)
+{
+	ulong	i;
+
+	switch(filter)
+	{
+	case PNG_FILTER_VALUE_NONE:
+		break;
+	case PNG_FILTER_VALUE_SUB:
+		out += bpp;
+		for(i = bpp; i < rowbytes; i++)
+		{
+			*out += *(out - bpp);
+			out++;
+		}
+		break;
+	case PNG_FILTER_VALUE_UP:   
+		for(i = 0; i < rowbytes; i++)
+		{
+			if(lastline)
+			{
+				*out += *lastline++;
+			}
+			out++;
+		}
+		break;
+	case PNG_FILTER_VALUE_AVG:  
+		for(i = 0; i < bpp; i++)
+		{
+			if(lastline)
+			{
+				*out += *lastline++ >> 1;
+			}
+			out++;
+		}
+		for(i = bpp; i < rowbytes; i++)
+		{
+			if(lastline)
+			{
+				*out += (*lastline++ + *(out - bpp)) >> 1;
+			}
+			else
+			{
+				*out += *(out - bpp) >> 1;
+			}
+			out++;
+		}
+		break;
+	case PNG_FILTER_VALUE_PAETH:
+		int			a, b, c;
+		int			pa, pb, pc, p;
+
+		for(i = 0; i < bpp; i++)
+		{
+			if(lastline)
+			{
+				*out += *lastline++;
+			}
+			out++;
+		}
+		for(i = bpp; i < rowbytes; i++)
+		{
+			a = *(out - bpp);
+			c = 0;
+			b = 0;
+			if(lastline)
+			{
+				c = *(lastline - bpp);
+				b = *lastline++;
+			}
+			p = b - c;
+			pc = a - c;
+
+			pa = p < 0 ? -p : p;
+			pb = pc < 0 ? -pc : pc;
+			pc = (p + pc) < 0 ? -(p + pc) : p + pc;
+
+			p = (pa <= pb && pa <= pc) ? a : (pb <= pc) ? b : c;
+
+			*out++ += p;
+		}
+		break;
+	default:
+		break;
+	}
+}
+
+// Pack up the image data line by line
+
+bool PNG_Pack(byte *out, ulong *size, ulong maxsize, byte *data, int width, int height, int bytedepth)
+{
+	z_stream		zdata;
+	ulong			rowbytes;
+	ulong			y;
+	const byte		*lastline, *source;
+	// Storage for filter type and filtered row
+	byte			workline[(MAX_PNG_WIDTH * MAX_PNG_DEPTH) + 1];
+
+	// Number of bytes per row
+	rowbytes = width * bytedepth;
+
+	memset(&zdata, 0, sizeof(z_stream));
+	if(deflateInit(&zdata, Z_FAST_COMPRESSION_HIGH) != Z_OK)
+	{
+		png_error = PNG_ERROR_COMP;
+		return(false);
+	}
+
+	zdata.next_out = out;
+	zdata.avail_out = maxsize;
+
+	lastline = NULL;
+	source = data + ((height - 1) * rowbytes);
+	for(y = 0; y < height; y++)
+	{
+		// Refilter using the most compressable filter algo
+		// Assume paeth to speed things up
+		workline[0] = (byte)PNG_FILTER_VALUE_PAETH;
+		PNG_Filter(workline + 1, (byte)PNG_FILTER_VALUE_PAETH, source, lastline, rowbytes, bytedepth);
+
+		zdata.next_in = workline;
+		zdata.avail_in = rowbytes + 1;
+		if(deflate(&zdata, Z_SYNC_FLUSH) != Z_OK)
+		{
+			deflateEnd(&zdata);
+			png_error = PNG_ERROR_COMP;
+			return(false);
+		}
+		lastline = source;
+		source -= rowbytes;
+	}
+	if(deflate(&zdata, Z_FINISH) != Z_STREAM_END)
+	{
+		png_error = PNG_ERROR_COMP;
+		return(false);
+	}
+	*size = zdata.total_out;
+	deflateEnd(&zdata);
+	return(true);
+}
+
+// Unpack the image data, line by line
+
+bool PNG_Unpack(const byte *data, const ulong datasize, png_image_t *image)
+{
+	ulong		rowbytes, zerror, y;
+	byte		filter;
+	z_stream	zdata;
+	byte		*lastline, *out;
+
+//	MD_PushTag(TAG_ZIP_TEMP);
+
+	memset(&zdata, 0, sizeof(z_stream));
+	if(inflateInit(&zdata, Z_SYNC_FLUSH) != Z_OK)
+	{
+		png_error = PNG_ERROR_DECOMP;
+//		MD_PopTag();
+		return(false);
+	}
+	zdata.next_in = (byte *)data;
+	zdata.avail_in = datasize;
+
+	rowbytes = image->width * image->bytedepth;
+
+	lastline = NULL;
+	out = image->data;
+	for(y = 0; y < image->height; y++)
+	{
+		// Inflate a row of data
+		zdata.next_out = &filter;
+		zdata.avail_out = 1;
+		if(inflate(&zdata) != Z_OK)
+		{
+			inflateEnd(&zdata);
+			png_error = PNG_ERROR_DECOMP;
+//			MD_PopTag();
+			return(false);
+		}
+		zdata.next_out = out;
+		zdata.avail_out = rowbytes;
+		zerror = inflate(&zdata);
+		if((zerror != Z_OK) && (zerror != Z_STREAM_END))
+		{
+			inflateEnd(&zdata);
+			png_error = PNG_ERROR_DECOMP;
+//			MD_PopTag();
+			return(false);
+		}
+
+		// Unfilter a row of data
+		PNG_Unfilter(out, filter, lastline, rowbytes, image->bytedepth);
+
+		lastline = out;
+		out += rowbytes;
+	}
+	inflateEnd(&zdata);
+//	MD_PopTag();
+	return(true);
+}
+
+// Scan through all chunks and process each one
+
+bool PNG_Load(const byte *data, ulong datasize, png_image_t *image)
+{
+	bool			moredata;
+	const byte		*next;
+	byte			*workspace, *work;
+	ulong			length, type, crc, totallength;
+
+	png_error = PNG_ERROR_OK;
+
+	if(memcmp(data, png_signature, sizeof(png_signature)))
+	{
+		png_error = PNG_ERROR_NOSIG;
+		return(false);
+	}
+	data += sizeof(png_signature);
+
+	workspace = (byte *)Z_Malloc(datasize, TAG_TEMP_PNG, qfalse);
+	work = workspace;
+	totallength = 0;
+
+	moredata = true;
+	while(moredata)
+	{
+		length = BigLong(*(ulong *)data);
+		data += sizeof(ulong);
+
+		type = BigLong(*(ulong *)data);
+		const byte *crcbase = data;
+		data += sizeof(ulong);
+
+		// CRC checksum location
+		next = data + length + sizeof(ulong);
+
+		// CRC checksum includes header field
+		crc = crc32(0, crcbase, length + sizeof(ulong));
+		if(crc != (ulong)BigLong(*(ulong *)(next - 4)))
+		{
+			if(image->data)
+			{
+				Z_Free(image->data);
+				image->data = NULL;
+			}
+			Z_Free(workspace);
+			png_error = PNG_ERROR_FAILED_CRC;
+			return(false);		
+		}
+		switch(type)
+		{
+		case PNG_IHDR:
+			if(!PNG_HandleIHDR(data, image))
+			{
+				Z_Free(workspace);
+				return(false);
+			}
+			image->data = (byte *)Z_Malloc(image->width * image->height * image->bytedepth, TAG_TEMP_PNG, qfalse);
+			break;
+		case PNG_IDAT:
+			// Need to copy all the various IDAT chunks into one big one
+			// Everything but 3dsmax has one IDAT chunk
+			memcpy(work, data, length);
+			work += length;
+			totallength += length;
+			break;
+		case PNG_IEND:
+			if(!PNG_Unpack(workspace, totallength, image))
+			{
+				Z_Free(workspace);
+				Z_Free(image->data);
+				image->data = NULL;
+				return(false);
+			}
+			moredata = false;
+			break;
+		default:
+			break;
+		}
+		data = next;
+	}
+	Z_Free(workspace);
+	return(true);
+}
+
+// Outputs a crc'd chunk of PNG data
+
+bool PNG_OutputChunk(fileHandle_t fp, ulong type, byte *data, ulong size)
+{
+	ulong	crc, little, outcount;
+
+	// Output a standard PNG chunk - length, type, data, crc
+	little = BigLong(size);
+	outcount = FS_Write(&little, sizeof(little), fp);
+
+	little = BigLong(type);
+	crc = crc32(0, (byte *)&little, sizeof(little));
+	outcount += FS_Write(&little, sizeof(little), fp);
+
+	if(size)
+	{
+		crc = crc32(crc, data, size);
+		outcount += FS_Write(data, size, fp);
+	}
+
+	little = BigLong(crc);
+	outcount += FS_Write(&little, sizeof(little), fp);
+
+	if(outcount != (size + 12))
+	{
+		png_error = PNG_ERROR_WRITE;
+		return(false);
+	}
+	return(true);
+}
+
+// Saves a PNG format compressed image
+
+bool PNG_Save(const char *name, byte *data, int width, int height, int bytedepth)
+{
+	byte			*work;
+	fileHandle_t	fp;
+	int				maxsize;
+	ulong			size, outcount;
+	png_ihdr_t		png_header;
+
+	png_error = PNG_ERROR_OK;
+
+	// Create the file
+	fp = FS_FOpenFileWrite(name);
+	if(!fp)
+	{
+		png_error = PNG_ERROR_CREATE_FAIL;
+		return(false);
+	}
+	// Write out the PNG signature
+	outcount = FS_Write(png_signature, sizeof(png_signature), fp);
+	if(outcount != sizeof(png_signature))
+	{
+		FS_FCloseFile(fp);
+		png_error = PNG_ERROR_WRITE;
+		return(false);
+	}
+	// Create and output a valid header
+	PNG_CreateHeader(&png_header, width, height, bytedepth);
+	if(!PNG_OutputChunk(fp, PNG_IHDR, (byte *)&png_header, sizeof(png_header)))
+	{
+		FS_FCloseFile(fp);
+		return(false);
+	}
+	// Create and output the copyright info
+ 	if(!PNG_OutputChunk(fp, PNG_tEXt, (byte *)png_copyright, sizeof(png_copyright)))
+	{
+		FS_FCloseFile(fp);
+		return(false);
+	}
+	// Max size of compressed image (source size + 0.1% + 12)
+	maxsize = (width * height * bytedepth) + 4096;
+	work = (byte *)Z_Malloc(maxsize, TAG_TEMP_PNG, qtrue);	// fixme: optimise to qfalse sometime - ok?
+  
+	// Pack up the image data
+	if(!PNG_Pack(work, &size, maxsize, data, width, height, bytedepth))
+	{
+		Z_Free(work);
+		FS_FCloseFile(fp);
+		return(false);
+	}
+	// Write out the compressed image data
+	if(!PNG_OutputChunk(fp, PNG_IDAT, (byte *)work, size))
+	{
+		Z_Free(work);
+		FS_FCloseFile(fp);
+		return(false);
+	}
+	Z_Free(work);
+	// Output terminating chunk
+	if(!PNG_OutputChunk(fp, PNG_IEND, NULL, 0))
+	{
+		FS_FCloseFile(fp);
+		return(false);
+	}
+	FS_FCloseFile(fp);
+	return(true);
+}
+
+/*
+=============
+PNG_ConvertTo32
+=============
+*/
+
+void PNG_ConvertTo32(png_image_t *image)
+{
+	byte	*temp;
+	byte	*old, *old2;
+	ulong	i;
+
+	temp = (byte *)Z_Malloc(image->width * image->height * 4, TAG_TEMP_PNG, qtrue);
+	old = image->data;
+	old2 = old;
+	image->data = temp;
+	image->bytedepth = 4;
+
+	for(i = 0; i < image->width * image->height; i++)
+	{
+		*temp++ = *old++;
+		*temp++ = *old++;
+		*temp++ = *old++;
+		*temp++ = 0xff;
+	}
+	Z_Free(old2);
+}
+
+/*
+=============
+LoadPNG32
+=============
+*/
+bool LoadPNG32 (char *name, byte **pixels, int *width, int *height, int *bytedepth)
+{
+	byte		*buffer;
+	byte		**bufferptr = &buffer;
+	int			nLen;
+	png_image_t	png_image;
+
+	if(!pixels)
+	{
+		bufferptr = NULL;
+	}
+	nLen = FS_ReadFile ( ( char * ) name, (void **)bufferptr);
+	if (nLen == -1) 
+	{
+		if(pixels)
+		{
+			*pixels = NULL;
+		}
+		return(false);
+	}
+	if(!pixels)
+	{
+		return(true);
+	}
+	*pixels = NULL;
+	png_image.isimage = true;
+	if(!PNG_Load(buffer, nLen, &png_image))
+	{
+		Com_Printf ("Error parsing %s: %s\n", name, PNG_GetError());
+		return(false);
+	}
+	if(png_image.bytedepth != 4)
+	{
+		PNG_ConvertTo32(&png_image);
+	}
+	*pixels = png_image.data;
+	if(width)
+	{
+		*width = png_image.width;
+	}
+	if(height)
+	{
+		*height = png_image.height;
+	}
+	if(bytedepth)
+	{
+		*bytedepth = png_image.bytedepth;
+	}
+	FS_FreeFile(buffer);
+	return(true);
+}
+
+/*
+=============
+LoadPNG8
+=============
+*/
+bool LoadPNG8 (char *name, byte **pixels, int *width, int *height)
+{
+	byte		*buffer;
+	byte		**bufferptr = &buffer;
+	int			nLen;
+	png_image_t	png_image;
+
+	if(!pixels)
+	{
+		bufferptr = NULL;
+	}
+	nLen = FS_ReadFile ( ( char * ) name, (void **)bufferptr);
+	if (nLen == -1) 
+	{
+		if(pixels)
+		{
+			*pixels = NULL;
+		}
+		return(false);
+	}
+	if(!pixels)
+	{
+		return(true);
+	}
+	*pixels = NULL;
+	png_image.isimage = false;
+	if(!PNG_Load(buffer, nLen, &png_image))
+	{
+		Com_Printf ("Error parsing %s: %s\n", name, PNG_GetError());
+		return(false);
+	}
+	*pixels = png_image.data;
+	if(width)
+	{
+		*width = png_image.width;
+	}
+	if(height)
+	{
+		*height = png_image.height;
+	}
+	FS_FreeFile(buffer);
+	return(true);
+}
+
+// end
\ No newline at end of file
diff --git a/codemp/png/png.h b/codemp/png/png.h
new file mode 100644
index 0000000..7a3580a
--- /dev/null
+++ b/codemp/png/png.h
@@ -0,0 +1,73 @@
+// Known chunk types
+
+#define PNG_IHDR		'IHDR'
+#define PNG_IDAT		'IDAT' 
+#define PNG_IEND 		'IEND'
+#define PNG_tEXt 		'tEXt'
+
+#define PNG_PLTE 		'PLTE'
+#define PNG_bKGD 		'bKGD'
+#define PNG_cHRM 		'cHRM'
+#define PNG_gAMA 		'gAMA'
+#define PNG_hIST 		'hIST'
+#define PNG_iCCP 		'iCCP'
+#define PNG_iTXt 		'iTXt'
+#define PNG_oFFs 		'oFFs'
+#define PNG_pCAL 		'pCAL'
+#define PNG_sCAL 		'sCAL'
+#define PNG_pHYs 		'pHYs'
+#define PNG_sBIT 		'sBIT'
+#define PNG_sPLT 		'sPLT'
+#define PNG_sRGB 		'sRGB'
+#define PNG_tIME 		'tIME'
+#define PNG_tRNS 		'tRNS'
+#define PNG_zTXt 		'zTXt'
+
+// Filter values 
+
+#define PNG_FILTER_VALUE_NONE	0
+#define PNG_FILTER_VALUE_SUB	1
+#define PNG_FILTER_VALUE_UP		2
+#define PNG_FILTER_VALUE_AVG	3
+#define PNG_FILTER_VALUE_PAETH	4
+#define PNG_FILTER_NUM			5
+
+// Common defines and typedefs
+
+#define MAX_PNG_WIDTH			4096
+#define MAX_PNG_DEPTH			4
+
+typedef unsigned char	byte;
+typedef unsigned short	word;
+typedef unsigned long	ulong;
+
+#pragma pack(push)
+#pragma pack(1)
+
+typedef struct png_ihdr_s
+{
+	ulong			width;
+	ulong			height;
+	byte			bitdepth;			// Bits per sample (not per pixel)
+	byte			colortype;			// bit 0 - palette; bit 1 - RGB; bit 2 - alpha channel
+	byte			compression;		// 0 for zip - error otherwise
+	byte			filter;				// 0 for adaptive with the 5 basic types - error otherwise
+	byte			interlace;			// 0 for no interlace - 1 for Adam7 interlace
+} png_ihdr_t;
+
+#pragma pack(pop)
+
+typedef struct png_image_s
+{
+	byte			*data;
+	ulong			width;
+	ulong			height;
+	ulong			bytedepth;
+	bool			isimage;
+} png_image_t;
+
+bool LoadPNG32 (char *name, byte **pixels, int *width, int *height, int *bytedepth);
+bool LoadPNG8 (char *name, byte **pixels, int *width, int *height);
+bool PNG_Save(const char *name, byte *data, int width, int height, int bytedepth);
+
+// end
\ No newline at end of file
diff --git a/codemp/png/vssver.scc b/codemp/png/vssver.scc
new file mode 100644
index 0000000..5b6ff21
Binary files /dev/null and b/codemp/png/vssver.scc differ
diff --git a/codemp/qcommon/CNetProfile.cpp b/codemp/qcommon/CNetProfile.cpp
new file mode 100644
index 0000000..c0de3a3
--- /dev/null
+++ b/codemp/qcommon/CNetProfile.cpp
@@ -0,0 +1,97 @@
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+#ifdef _DONETPROFILE_
+
+#pragma warning( disable : 4786) 
+#pragma warning( disable : 4100) 
+#pragma warning( disable : 4663) 
+
+#include <windows.h>
+#include <stdio.h>
+#include <assert.h>
+#include "hstring.h"
+#include "INetProfile.h"
+
+using namespace std;
+
+class CNetProfile : public INetProfile
+{
+	float						mElapsedTime;
+	map <hstring,unsigned int>	mFieldCounts;
+	float						mFrameCount;
+
+public:
+	void Reset(void)
+	{
+		mFieldCounts.clear();
+		mFrameCount=0;
+	}
+
+	void AddField(char *fieldName,int sizeBytes)
+	{
+		assert(sizeBytes>=0);
+		if(sizeBytes==0)
+		{
+			return;
+		}
+		map<hstring,unsigned int>::iterator f=mFieldCounts.find(fieldName);
+		if(f==mFieldCounts.end())
+		{
+			mFieldCounts[fieldName]=(unsigned int)sizeBytes;
+		}
+		else
+		{
+			mFieldCounts[fieldName]+=(unsigned int)sizeBytes;
+		}
+	}
+	
+	void IncTime(int msec)
+	{
+		mElapsedTime+=msec;
+	}
+
+	void ShowTotals(void)
+	{
+		float									totalBytes=0;
+		multimap<unsigned int,hstring>			sort;
+		map<hstring,unsigned int>::iterator		f;		
+		for(f=mFieldCounts.begin();f!=mFieldCounts.end();f++)
+		{
+			sort.insert(pair<unsigned int,hstring> ((*f).second,(*f).first));
+			totalBytes+=(*f).second;
+		}
+
+		multimap<unsigned int,hstring>::iterator	j;
+		char										msg[1024];
+		float										percent;
+		sprintf(msg,
+			    "******** Totals: bytes %d : bytes per sec %d ********\n",
+			    (unsigned int)totalBytes,
+			    (unsigned int)((totalBytes/mElapsedTime)*1000));
+		Sleep(10);
+		OutputDebugString(msg);
+		for(j=sort.begin();j!=sort.end();j++)
+		{
+			percent=(((float)(*j).first)/totalBytes)*100.0f;
+			assert(strlen((*j).second.c_str())<1024);
+			sprintf(msg,"%36s : %3.4f percent : %d bytes \n",(*j).second.c_str(),percent,(*j).first);
+			Sleep(10);
+			OutputDebugString(msg);
+		}
+	}
+};
+
+INetProfile &ClReadProf(void)
+{
+	static CNetProfile theClReadProf;
+	return(theClReadProf);
+}
+
+INetProfile &ClSendProf(void)
+{
+	static CNetProfile theClSendProf;
+	return(theClSendProf);
+}
+
+#endif // _DONETPROFILE_
\ No newline at end of file
diff --git a/codemp/qcommon/GenericParser2.cpp b/codemp/qcommon/GenericParser2.cpp
new file mode 100644
index 0000000..da3775a
--- /dev/null
+++ b/codemp/qcommon/GenericParser2.cpp
@@ -0,0 +1,1203 @@
+// this include must remain at the top of every CPP file
+
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+#if !defined(GENERICPARSER2_H_INC)
+	#include "GenericParser2.h"
+#endif
+
+#define _EXE
+
+#define MAX_TOKEN_SIZE	1024
+static char	token[MAX_TOKEN_SIZE];
+
+static char *GetToken(char **text, bool allowLineBreaks, bool readUntilEOL = false)
+{
+	char	*pointer = *text;
+	int		length = 0;
+	int		c = 0;
+	bool	foundLineBreak;
+
+	token[0] = 0;
+	if (!pointer)
+	{
+		return token;
+	}
+
+	while(1)
+	{
+		foundLineBreak = false;
+		while(1)
+		{
+			c = *pointer;
+			if (c > ' ')
+			{
+				break;
+			}
+			if (!c)
+			{
+				*text = 0;
+				return token;
+			}
+			if (c == '\n')
+			{
+				foundLineBreak = true;
+			}
+			pointer++;
+		}
+		if (foundLineBreak && !allowLineBreaks)
+		{
+			*text = pointer;
+			return token;
+		}
+
+		c = *pointer;
+
+		// skip single line comment
+		if (c == '/' && pointer[1] == '/')
+		{
+			pointer += 2;
+			while (*pointer && *pointer != '\n') 
+			{
+				pointer++;
+			}
+		}
+		// skip multi line comments
+		else if (c == '/' && pointer[1] == '*') 
+		{
+			pointer += 2;
+			while (*pointer && (*pointer != '*' || pointer[1] != '/')) 
+			{
+				pointer++;
+			}
+			if (*pointer) 
+			{
+				pointer += 2;
+			}
+		}
+		else
+		{	// found the start of a token
+			break;
+		}
+	}
+
+	if (c == '\"')
+	{	// handle a string
+		pointer++;
+		while (1)
+		{
+			c = *pointer++;
+			if (c == '\"')
+			{
+//				token[length++] = c;
+				break;
+			}
+			else if (!c)
+			{
+				break;
+			}
+			else if (length < MAX_TOKEN_SIZE)
+			{
+				token[length++] = c;
+			}
+		}
+	}
+	else if (readUntilEOL)
+	{
+		// absorb all characters until EOL
+		while(c != '\n' && c != '\r')
+		{
+			if (c == '/' && ((*(pointer+1)) == '/' || (*(pointer+1)) == '*'))
+			{
+				break;
+			}
+
+			if (length < MAX_TOKEN_SIZE)
+			{
+				token[length++] = c;
+			}
+			pointer++;
+			c = *pointer;
+		}
+		// remove trailing white space
+		while(length && token[length-1] < ' ')
+		{
+			length--;
+		}
+	}
+	else
+	{
+		while(c > ' ')
+		{
+			if (length < MAX_TOKEN_SIZE)
+			{
+				token[length++] = c;
+			}
+			pointer++;
+			c = *pointer;
+		}
+	}
+
+	if (token[0] == '\"')
+	{	// remove start quote
+		length--;
+		memmove(token, token+1, length);
+
+		if (length && token[length-1] == '\"')
+		{	// remove end quote
+			length--;
+		}
+	}
+
+	if (length >= MAX_TOKEN_SIZE)
+	{
+		length = 0;
+	}
+	token[length] = 0;
+	*text = (char *)pointer;
+
+	return token;
+}
+
+
+
+
+CTextPool::CTextPool(int initSize) :
+	mNext(0),
+	mSize(initSize),
+	mUsed(0)
+{
+#ifdef _EXE
+//	mPool = (char *)Z_Malloc(mSize, TAG_GP2);
+	mPool = (char *)Z_Malloc(mSize, TAG_TEXTPOOL, qtrue);
+#else
+	mPool = (char *)trap_Z_Malloc(mSize, TAG_GP2);
+#endif
+}
+
+CTextPool::~CTextPool(void)
+{
+#ifdef _EXE
+	Z_Free(mPool);
+#else
+	trap_Z_Free(mPool);
+#endif
+}
+
+char *CTextPool::AllocText(char *text, bool addNULL, CTextPool **poolPtr)
+{
+	int	length = strlen(text) + (addNULL ? 1 : 0);
+
+	if (mUsed + length + 1> mSize)
+	{	// extra 1 to put a null on the end
+		if (poolPtr)
+		{
+			(*poolPtr)->SetNext(new CTextPool(mSize));
+			*poolPtr = (*poolPtr)->GetNext();
+
+			return (*poolPtr)->AllocText(text, addNULL);
+		}
+
+		return 0;
+	}
+
+	strcpy(mPool + mUsed, text);
+	mUsed += length;
+	mPool[mUsed] = 0;
+
+	return mPool + mUsed - length;
+}
+
+void CleanTextPool(CTextPool *pool)
+{
+	CTextPool *next;
+
+	while(pool)
+	{
+		next = pool->GetNext();
+		delete pool;
+		pool = next;
+	}
+}
+
+
+
+
+
+
+
+CGPObject::CGPObject(const char *initName) :
+	mName(initName),
+	mNext(0),
+	mInOrderNext(0),
+	mInOrderPrevious(0)
+{
+}
+
+bool CGPObject::WriteText(CTextPool **textPool, const char *text)
+{
+   if (strchr(text, ' ') || !text[0])
+   {
+	   (*textPool)->AllocText("\"", false, textPool);
+	   (*textPool)->AllocText((char *)text, false, textPool);
+	   (*textPool)->AllocText("\"", false, textPool);
+   }
+   else
+   {
+	   (*textPool)->AllocText((char *)text, false, textPool);
+   }
+
+   return true;
+}
+
+
+	
+	
+	
+
+
+
+
+
+
+	
+	
+
+CGPValue::CGPValue(const char *initName, const char *initValue) :
+	CGPObject(initName),
+	mList(0)
+{
+	if (initValue)
+	{
+		AddValue(initValue);
+	}
+}
+
+CGPValue::~CGPValue(void)
+{
+	CGPObject	*next;
+
+	while(mList)
+	{
+		next = mList->GetNext();
+		delete mList;
+		mList = next;
+	}
+}
+
+CGPValue *CGPValue::Duplicate(CTextPool **textPool)
+{
+	CGPValue	*newValue;
+	CGPObject	*iterator;
+	char		*name;
+
+	if (textPool)
+	{
+		name = (*textPool)->AllocText((char *)mName, true, textPool);
+	}
+	else
+	{
+		name = (char *)mName;
+	}
+
+	newValue = new CGPValue(name);
+	iterator = mList;
+	while(iterator)
+	{
+		if (textPool)
+		{
+			name = (*textPool)->AllocText((char *)iterator->GetName(), true, textPool);
+		}
+		else
+		{
+			name = (char *)iterator->GetName();
+		}
+		newValue->AddValue(name);
+		iterator = iterator->GetNext();
+	}
+
+	return newValue;
+}
+
+bool CGPValue::IsList(void)
+{
+	if (!mList || !mList->GetNext())
+	{
+		return false;
+	}
+
+	return true;
+}
+
+const char *CGPValue::GetTopValue(void) 
+{ 
+	if (mList)
+	{
+		return mList->GetName();
+	}
+
+	return 0;
+}
+
+void CGPValue::AddValue(const char *newValue, CTextPool **textPool)
+{
+	if (textPool)
+	{
+		newValue = (*textPool)->AllocText((char *)newValue, true, textPool);
+	}
+
+	if (mList == 0)
+	{
+		mList = new CGPObject(newValue);
+		mList->SetInOrderNext(mList);
+	}
+	else
+	{
+		mList->GetInOrderNext()->SetNext(new CGPObject(newValue));
+		mList->SetInOrderNext(mList->GetInOrderNext()->GetNext());
+	}
+}
+
+bool CGPValue::Parse(char **dataPtr, CTextPool **textPool)
+{
+	char		*token;
+	char		*value;
+
+	while(1)
+	{
+		token = GetToken(dataPtr, true, true);
+
+		if (!token[0])
+		{	// end of data - error!
+			return false;
+		}
+		else if (Q_stricmp(token, "]") == 0)
+		{	// ending brace for this list
+			break;
+		}
+
+		value = (*textPool)->AllocText(token, true, textPool);
+		AddValue(value);
+	}
+
+	return true;
+}
+
+bool CGPValue::Write(CTextPool **textPool, int depth)
+{
+	int				i;
+	CGPObject	*next;
+
+	if (!mList)
+	{
+		return true;
+	}
+
+	for(i=0;i<depth;i++)
+	{
+		(*textPool)->AllocText("\t", false, textPool);
+	}
+
+	WriteText(textPool, mName);
+
+	if (!mList->GetNext())
+	{
+		(*textPool)->AllocText("\t\t", false, textPool);
+		mList->WriteText(textPool, mList->GetName());
+		(*textPool)->AllocText("\r\n", false, textPool);
+	}
+	else
+	{
+		(*textPool)->AllocText("\r\n", false, textPool);
+
+		for(i=0;i<depth;i++)
+		{
+			(*textPool)->AllocText("\t", false, textPool);
+		}
+		(*textPool)->AllocText("[\r\n", false, textPool);
+
+		next = mList;
+		while(next)
+		{
+			for(i=0;i<depth+1;i++)
+			{
+				(*textPool)->AllocText("\t", false, textPool);
+			}
+			mList->WriteText(textPool, next->GetName());
+			(*textPool)->AllocText("\r\n", false, textPool);
+
+			next = next->GetNext();
+		}
+
+		for(i=0;i<depth;i++)
+		{
+			(*textPool)->AllocText("\t", false, textPool);
+		}
+		(*textPool)->AllocText("]\r\n", false, textPool);
+	}
+
+	return true;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+CGPGroup::CGPGroup(const char *initName, CGPGroup *initParent) :
+	CGPObject(initName),
+	mPairs(0),
+	mInOrderPairs(0),
+	mCurrentPair(0),
+	mSubGroups(0),
+	mInOrderSubGroups(0),
+	mCurrentSubGroup(0),
+	mParent(initParent),
+	mWriteable(false)
+{
+}
+
+CGPGroup::~CGPGroup(void)
+{
+	Clean();
+}
+
+int CGPGroup::GetNumSubGroups(void)
+{
+	int			count;
+	CGPGroup	*group;
+
+	count = 0;
+	group = mSubGroups;
+	do
+	{
+		count++;
+		group = (CGPGroup *)group->GetNext();
+	}
+	while(group);
+
+	return(count);
+}
+
+int CGPGroup::GetNumPairs(void)
+{
+	int			count;
+	CGPValue	*pair;
+
+	count = 0;
+	pair = mPairs;
+	do
+	{
+		count++;
+		pair = (CGPValue *)pair->GetNext();
+	}
+	while(pair);
+
+	return(count);
+}
+
+void CGPGroup::Clean(void)
+{
+	while(mPairs)
+	{
+		mCurrentPair = (CGPValue *)mPairs->GetNext();
+		delete mPairs;
+		mPairs = mCurrentPair;
+	}
+
+	while(mSubGroups)
+	{
+		mCurrentSubGroup = (CGPGroup *)mSubGroups->GetNext();
+		delete mSubGroups;
+		mSubGroups = mCurrentSubGroup;
+	}
+
+	mPairs = mInOrderPairs = mCurrentPair = 0;
+	mSubGroups = mInOrderSubGroups = mCurrentSubGroup = 0;
+	mParent = 0;
+	mWriteable = false;
+}
+
+CGPGroup *CGPGroup::Duplicate(CTextPool **textPool, CGPGroup *initParent)
+{
+	CGPGroup	*newGroup, *subSub, *newSub;
+	CGPValue	*newPair, *subPair;
+	char		*name;
+
+	if (textPool)
+	{
+		name = (*textPool)->AllocText((char *)mName, true, textPool);
+	}
+	else
+	{
+		name = (char *)mName;
+	}
+
+	newGroup = new CGPGroup(name);
+
+	subSub = mSubGroups;
+	while(subSub)
+	{
+		newSub = subSub->Duplicate(textPool, newGroup);
+		newGroup->AddGroup(newSub);
+
+		subSub = (CGPGroup *)subSub->GetNext();
+	}
+
+	subPair = mPairs;
+	while(subPair)
+	{
+		newPair = subPair->Duplicate(textPool);
+		newGroup->AddPair(newPair);
+
+		subPair = (CGPValue *)subPair->GetNext();
+	}
+
+	return newGroup;
+}
+
+void CGPGroup::SortObject(CGPObject *object, CGPObject **unsortedList, CGPObject **sortedList,
+							 CGPObject **lastObject)
+{
+	CGPObject	*test, *last;
+
+	if (!*unsortedList)
+	{
+		*unsortedList = *sortedList = object;
+	}
+	else
+	{
+		(*lastObject)->SetNext(object);
+
+		test = *sortedList;
+		last = 0;
+		while(test)
+		{
+			if (Q_stricmp(object->GetName(), test->GetName()) < 0)
+			{
+				break;
+			}
+
+			last = test;
+			test = test->GetInOrderNext();
+		}
+
+		if (test)
+		{
+			test->SetInOrderPrevious(object);
+			object->SetInOrderNext(test);
+		}
+		if (last)
+		{
+			last->SetInOrderNext(object);
+			object->SetInOrderPrevious(last);
+		}
+		else
+		{
+			*sortedList = object;
+		}
+	}
+
+	*lastObject = object;
+}
+
+CGPValue *CGPGroup::AddPair(const char *name, const char *value, CTextPool **textPool)
+{
+	CGPValue	*newPair;
+
+	if (textPool)
+	{
+		name = (*textPool)->AllocText((char *)name, true, textPool);
+		if (value)
+		{
+			value = (*textPool)->AllocText((char *)value, true, textPool);
+		}
+	}
+
+	newPair = new CGPValue(name, value);
+
+	AddPair(newPair);
+
+	return newPair;
+}
+
+void CGPGroup::AddPair(CGPValue *NewPair)
+{
+	SortObject(NewPair, (CGPObject **)&mPairs, (CGPObject **)&mInOrderPairs, 
+		(CGPObject **)&mCurrentPair);
+}
+
+CGPGroup *CGPGroup::AddGroup(const char *name, CTextPool **textPool)
+{
+	CGPGroup	*newGroup;
+
+	if (textPool)
+	{
+		name = (*textPool)->AllocText((char *)name, true, textPool);
+	}
+
+	newGroup = new CGPGroup(name, this);
+
+	AddGroup(newGroup);
+
+	return newGroup;
+}
+	
+void CGPGroup::AddGroup(CGPGroup *NewGroup)
+{
+	SortObject(NewGroup, (CGPObject **)&mSubGroups, (CGPObject **)&mInOrderSubGroups, 
+		(CGPObject **)&mCurrentSubGroup);
+}
+	
+CGPGroup *CGPGroup::FindSubGroup(const char *name)
+{
+	CGPGroup	*group;
+
+	group = mSubGroups;
+	while(group)
+	{
+		if(!stricmp(name, group->GetName()))
+		{
+			return(group);
+		}
+		group = (CGPGroup *)group->GetNext();
+	}
+	return(NULL);
+}
+
+bool CGPGroup::Parse(char **dataPtr, CTextPool **textPool)
+{
+	char		*token;
+	char		lastToken[MAX_TOKEN_SIZE];
+	CGPGroup	*newSubGroup;
+	CGPValue	*newPair;
+
+	while(1)
+	{
+		token = GetToken(dataPtr, true);
+
+		if (!token[0])
+		{	// end of data - error!
+			if (mParent)
+			{
+				return false;
+			}
+			else
+			{
+				break;
+			}
+		}
+		else if (Q_stricmp(token, "}") == 0)
+		{	// ending brace for this group
+			break;
+		}
+
+		strcpy(lastToken, token);
+
+		// read ahead to see what we are doing
+		token = GetToken(dataPtr, true, true);
+		if (Q_stricmp(token, "{") == 0)
+		{	// new sub group
+			newSubGroup = AddGroup(lastToken, textPool);
+			newSubGroup->SetWriteable(mWriteable);
+			if (!newSubGroup->Parse(dataPtr, textPool))
+			{
+				return false;
+			}
+		}
+		else if (Q_stricmp(token, "[") == 0)
+		{	// new pair list
+			newPair = AddPair(lastToken, 0, textPool);
+			if (!newPair->Parse(dataPtr, textPool))
+			{
+				return false;
+			}
+		}
+		else
+		{	// new pair
+			AddPair(lastToken, token, textPool);
+		}
+	}
+
+	return true;
+}
+
+bool CGPGroup::Write(CTextPool **textPool, int depth)
+{
+	int				i;
+	CGPValue		*mPair = mPairs;
+	CGPGroup		*mSubGroup = mSubGroups;
+
+	if (depth >= 0)
+	{
+		for(i=0;i<depth;i++)
+		{
+			(*textPool)->AllocText("\t", false, textPool);
+		}
+		WriteText(textPool, mName);
+		(*textPool)->AllocText("\r\n", false, textPool);
+		
+		for(i=0;i<depth;i++)
+		{
+			(*textPool)->AllocText("\t", false, textPool);
+		}
+		(*textPool)->AllocText("{\r\n", false, textPool);
+	}
+
+	while(mPair)
+	{
+		mPair->Write(textPool, depth+1);
+		mPair = (CGPValue *)mPair->GetNext();
+	}
+
+	while(mSubGroup)
+	{
+		mSubGroup->Write(textPool, depth+1);
+		mSubGroup = (CGPGroup *)mSubGroup->GetNext();
+	}
+
+	if (depth >= 0)
+	{
+		for(i=0;i<depth;i++)
+		{
+			(*textPool)->AllocText("\t", false, textPool);
+		}
+		(*textPool)->AllocText("}\r\n", false, textPool);
+	}
+
+	return true;
+}
+
+/************************************************************************************************
+ * CGPGroup::FindPair
+ *    This function will search for the pair with the specified key name.  Multiple keys may be  
+ *    searched if you specify "||" inbetween each key name in the string.  The first key to be     
+ *    found (from left to right) will be returned.                                               
+ *                                                                                               
+ * Input                                                                                         
+ *    key: the name of the key(s) to be searched for.                                            
+ *                                                                                               
+ * Output / Return                                                                               
+ *    the group belonging to the first key found or 0 if no group was found.                     
+ *                                                                                               
+ ************************************************************************************************/
+CGPValue *CGPGroup::FindPair(const char *key)
+{
+	CGPValue		*pair;
+	int				length;
+	const char		*pos, *separator, *next;
+
+	pos = key;
+	while(pos[0])
+	{
+		separator = strstr(pos, "||");
+		if (separator)
+		{
+			length = separator - pos;
+			next = separator + 2;
+		}
+		else
+		{
+			length = strlen(pos);
+			next = pos + length;
+		}
+
+		pair = mPairs;
+		while(pair)
+		{
+			if (strlen(pair->GetName()) == length &&
+				Q_stricmpn(pair->GetName(), pos, length) == 0)
+			{
+				return pair;
+			}
+
+			pair = pair->GetNext();
+		}
+
+		pos = next;
+	}
+
+	return 0;	
+}
+
+const char *CGPGroup::FindPairValue(const char *key, const char *defaultVal)
+{
+	CGPValue		*pair = FindPair(key);
+
+	if (pair)
+	{
+		return pair->GetTopValue();
+	}
+
+	return defaultVal;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+CGenericParser2::CGenericParser2(void) :
+	mTextPool(0),
+	mWriteable(false)
+{
+}
+
+CGenericParser2::~CGenericParser2(void)
+{
+	Clean();
+}
+
+bool CGenericParser2::Parse(char **dataPtr, bool cleanFirst, bool writeable)
+{
+	CTextPool	*topPool;
+
+#ifdef _XBOX
+	// Parsers are temporary structures.  They exist mainly at load time.
+	extern void Z_SetNewDeleteTemporary(bool bTemp);
+	Z_SetNewDeleteTemporary(true);
+#endif
+
+	if (cleanFirst)
+	{
+		Clean();
+	}
+
+	if (!mTextPool)
+	{
+		mTextPool = new CTextPool;
+	}
+
+	SetWriteable(writeable);
+	mTopLevel.SetWriteable(writeable);
+	topPool = mTextPool;
+	bool ret = mTopLevel.Parse(dataPtr, &topPool);
+
+#ifdef _XBOX
+	Z_SetNewDeleteTemporary(false);
+#endif
+
+	return ret;
+}
+
+void CGenericParser2::Clean(void)
+{
+	mTopLevel.Clean();
+
+	CleanTextPool(mTextPool);
+	mTextPool = 0;
+}
+
+bool CGenericParser2::Write(CTextPool *textPool)
+{
+	return mTopLevel.Write(&textPool, -1);
+}
+
+
+
+
+
+
+
+
+
+// The following groups of routines are used for a C interface into GP2.
+// C++ users should just use the objects as normally and not call these routines below
+//
+// CGenericParser2 (void *) routines
+TGenericParser2 GP_Parse(char **dataPtr, bool cleanFirst, bool writeable)
+{
+	CGenericParser2		*parse;
+
+	parse = new CGenericParser2;
+	if (parse->Parse(dataPtr, cleanFirst, writeable))
+	{
+		return parse;
+	}
+
+	delete parse;
+	return 0;
+}
+
+void GP_Clean(TGenericParser2 GP2)
+{
+	if (!GP2)
+	{
+		return;
+	}
+
+	((CGenericParser2 *)GP2)->Clean();
+}
+
+void GP_Delete(TGenericParser2 *GP2)
+{
+	if (!GP2 || !(*GP2))
+	{
+		return;
+	}
+
+	delete ((CGenericParser2 *)(*GP2));
+	(*GP2) = 0;
+}
+
+TGPGroup GP_GetBaseParseGroup(TGenericParser2 GP2)
+{
+	if (!GP2)
+	{
+		return 0;
+	}
+	
+	return ((CGenericParser2 *)GP2)->GetBaseParseGroup();
+}
+
+
+
+
+// CGPGroup (void *) routines
+const char	*GPG_GetName(TGPGroup GPG)
+{
+	if (!GPG)
+	{
+		return "";
+	}
+
+	return ((CGPGroup *)GPG)->GetName();
+}
+
+bool GPG_GetName(TGPGroup GPG, char *Value)
+{
+	if (!GPG)
+	{
+		Value[0] = 0;
+		return false;
+	}
+
+	strcpy(Value, ((CGPGroup *)GPG)->GetName());
+	return true;
+}
+
+TGPGroup GPG_GetNext(TGPGroup GPG)
+{
+	if (!GPG)
+	{
+		return 0;
+	}
+
+	return ((CGPGroup *)GPG)->GetNext();
+}
+
+TGPGroup GPG_GetInOrderNext(TGPGroup GPG)
+{
+	if (!GPG)
+	{
+		return 0;
+	}
+
+	return ((CGPGroup *)GPG)->GetInOrderNext();
+}
+
+TGPGroup GPG_GetInOrderPrevious(TGPGroup GPG)
+{
+	if (!GPG)
+	{
+		return 0;
+	}
+
+	return ((CGPGroup *)GPG)->GetInOrderPrevious();
+}
+
+TGPGroup GPG_GetPairs(TGPGroup GPG)
+{
+	if (!GPG)
+	{
+		return 0;
+	}
+
+	return ((CGPGroup *)GPG)->GetPairs();
+}
+
+TGPGroup GPG_GetInOrderPairs(TGPGroup GPG)
+{
+	if (!GPG)
+	{
+		return 0;
+	}
+
+	return ((CGPGroup *)GPG)->GetInOrderPairs();
+}
+
+TGPGroup GPG_GetSubGroups(TGPGroup GPG)
+{
+	if (!GPG)
+	{
+		return 0;
+	}
+
+	return ((CGPGroup *)GPG)->GetSubGroups();
+}
+
+TGPGroup GPG_GetInOrderSubGroups(TGPGroup GPG)
+{
+	if (!GPG)
+	{
+		return 0;
+	}
+
+	return ((CGPGroup *)GPG)->GetInOrderSubGroups();
+}
+
+TGPGroup GPG_FindSubGroup(TGPGroup GPG, const char *name)
+{
+	if (!GPG)
+	{
+		return 0;
+	}
+
+	return ((CGPGroup *)GPG)->FindSubGroup(name);
+}
+
+TGPValue GPG_FindPair(TGPGroup GPG, const char *key)
+{
+	if (!GPG)
+	{
+		return 0;
+	}
+
+	return ((CGPGroup *)GPG)->FindPair(key);
+}
+
+const char *GPG_FindPairValue(TGPGroup GPG, const char *key, const char *defaultVal)
+{
+	if (!GPG)
+	{
+		return defaultVal;
+	}
+
+	return ((CGPGroup *)GPG)->FindPairValue(key, defaultVal);
+}
+
+bool GPG_FindPairValue(TGPGroup GPG, const char *key, const char *defaultVal, char *Value)
+{
+	strcpy(Value, GPG_FindPairValue(GPG, key, defaultVal));
+
+	return true;
+}
+
+
+
+
+// CGPValue (void *) routines
+const char	*GPV_GetName(TGPValue GPV)
+{
+	if (!GPV)
+	{
+		return "";
+	}
+
+	return ((CGPValue *)GPV)->GetName();
+}
+
+bool GPV_GetName(TGPValue GPV, char *Value)
+{
+	if (!GPV)
+	{
+		Value[0] = 0;
+		return false;
+	}
+
+	strcpy(Value, ((CGPValue *)GPV)->GetName());
+	return true;
+}
+
+TGPValue GPV_GetNext(TGPValue GPV)
+{
+	if (!GPV)
+	{
+		return 0;
+	}
+
+	return ((CGPValue *)GPV)->GetNext();
+}
+
+TGPValue GPV_GetInOrderNext(TGPValue GPV)
+{
+	if (!GPV)
+	{
+		return 0;
+	}
+
+	return ((CGPValue *)GPV)->GetInOrderNext();
+}
+
+TGPValue GPV_GetInOrderPrevious(TGPValue GPV)
+{
+	if (!GPV)
+	{
+		return 0;
+	}
+
+	return ((CGPValue *)GPV)->GetInOrderPrevious();
+}
+
+bool GPV_IsList(TGPValue GPV)
+{
+	if (!GPV)
+	{
+		return 0;
+	}
+
+	return ((CGPValue *)GPV)->IsList();
+}
+
+const char *GPV_GetTopValue(TGPValue GPV)
+{
+	if (!GPV)
+	{
+		return "";
+	}
+
+	return ((CGPValue *)GPV)->GetTopValue();
+}
+
+bool GPV_GetTopValue(TGPValue GPV, char *Value)
+{
+	if (!GPV)
+	{
+		Value[0] = 0;
+		return false;
+	}
+
+	strcpy(Value, ((CGPValue *)GPV)->GetTopValue());
+	
+	return true;
+}
+
+TGPValue GPV_GetList(TGPValue GPV)
+{
+	if (!GPV)
+	{
+		return 0;
+	}
+
+	return ((CGPValue *)GPV)->GetList();
+}
diff --git a/codemp/qcommon/GenericParser2.h b/codemp/qcommon/GenericParser2.h
new file mode 100644
index 0000000..3f0ca3c
--- /dev/null
+++ b/codemp/qcommon/GenericParser2.h
@@ -0,0 +1,204 @@
+#pragma once
+#if !defined(GENERICPARSER2_H_INC)
+#define GENERICPARSER2_H_INC
+
+#ifdef DEBUG_LINKING
+	#pragma message("...including GenericParser2.h")
+#endif
+
+#include "disablewarnings.h"
+
+#ifdef USE_LOCAL_GENERICPARSER
+#include <memory.h>
+#include <malloc.h>
+#include <string.h>
+
+#define trap_Z_Malloc(x, y)		malloc(x)
+#define trap_Z_Free(x)			free(x)
+
+#endif
+
+class CTextPool;
+class CGPObject;
+
+class CTextPool
+{
+private:
+	char		*mPool;
+	CTextPool	*mNext;
+	int			mSize, mUsed;
+
+public:
+	CTextPool(int initSize = 10240);
+	~CTextPool(void);
+
+	CTextPool	*GetNext(void) { return mNext; }
+	void		SetNext(CTextPool *which) { mNext = which; }
+	char		*GetPool(void) { return mPool; }
+	int			GetUsed(void) { return mUsed; }
+
+	char		*AllocText(char *text, bool addNULL = true, CTextPool **poolPtr = 0);
+};
+
+void CleanTextPool(CTextPool *pool);
+
+class CGPObject
+{
+protected:
+	const char	*mName;
+	CGPObject	*mNext, *mInOrderNext, *mInOrderPrevious;
+
+public:
+				CGPObject(const char *initName);
+
+	const char	*GetName(void) { return mName; }
+
+	CGPObject	*GetNext(void) { return mNext; }
+	void		SetNext(CGPObject *which) { mNext = which; }
+	CGPObject	*GetInOrderNext(void) { return mInOrderNext; }
+	void		SetInOrderNext(CGPObject *which) { mInOrderNext = which; }
+	CGPObject	*GetInOrderPrevious(void) { return mInOrderPrevious; }
+	void		SetInOrderPrevious(CGPObject *which) { mInOrderPrevious = which; }
+
+	bool		WriteText(CTextPool **textPool, const char *text);
+};
+
+
+
+class CGPValue : public CGPObject
+{
+private:
+	CGPObject	*mList;
+
+public:
+					CGPValue(const char *initName, const char *initValue = 0);
+					~CGPValue(void);
+
+	CGPValue		*GetNext(void) { return (CGPValue *)mNext; }
+
+	CGPValue		*Duplicate(CTextPool **textPool = 0);
+
+	bool			IsList(void);
+	const char		*GetTopValue(void);
+	CGPObject		*GetList(void) { return mList; }
+	void			AddValue(const char *newValue, CTextPool **textPool = 0);
+
+	bool			Parse(char **dataPtr, CTextPool **textPool);
+
+	bool			Write(CTextPool **textPool, int depth);
+};
+
+
+
+class CGPGroup : public CGPObject
+{
+private:
+	CGPValue			*mPairs, *mInOrderPairs;
+	CGPValue			*mCurrentPair;
+	CGPGroup			*mSubGroups, *mInOrderSubGroups;
+	CGPGroup			*mCurrentSubGroup;
+	CGPGroup			*mParent;
+	bool				mWriteable;
+
+	void	SortObject(CGPObject *object, CGPObject **unsortedList, CGPObject **sortedList, 
+					   CGPObject **lastObject);
+
+public:
+				CGPGroup(const char *initName = "Top Level", CGPGroup *initParent = 0);
+				~CGPGroup(void);
+
+	CGPGroup	*GetParent(void) { return mParent; }
+	CGPGroup	*GetNext(void) { return (CGPGroup *)mNext; }
+	int			GetNumSubGroups(void); 
+	int			GetNumPairs(void);
+
+	void		Clean(void); 
+	CGPGroup	*Duplicate(CTextPool **textPool = 0, CGPGroup *initParent = 0);
+
+	void		SetWriteable(const bool writeable) { mWriteable = writeable; }
+	CGPValue	*GetPairs(void) { return mPairs; }
+	CGPValue	*GetInOrderPairs(void) { return mInOrderPairs; }
+	CGPGroup	*GetSubGroups(void) { return mSubGroups; }
+	CGPGroup	*GetInOrderSubGroups(void) { return mInOrderSubGroups; }
+
+	CGPValue	*AddPair(const char *name, const char *value, CTextPool **textPool = 0);
+	void		AddPair(CGPValue *NewPair);
+	CGPGroup	*AddGroup(const char *name, CTextPool **textPool = 0);
+	void		AddGroup(CGPGroup *NewGroup);
+	CGPGroup	*FindSubGroup(const char *name);
+	bool		Parse(char **dataPtr, CTextPool **textPool);
+	bool		Write(CTextPool **textPool, int depth);
+
+	CGPValue	*FindPair(const char *key);
+	const char	*FindPairValue(const char *key, const char *defaultVal = 0);
+};
+
+class CGenericParser2
+{
+private:
+	CGPGroup		mTopLevel;
+	CTextPool		*mTextPool;
+	bool			mWriteable;
+
+public:
+	CGenericParser2(void);
+	~CGenericParser2(void);
+
+	void		SetWriteable(const bool writeable) { mWriteable = writeable; }
+	CGPGroup	*GetBaseParseGroup(void) { return &mTopLevel; }
+
+	bool	Parse(char **dataPtr, bool cleanFirst = true, bool writeable = false);
+	bool	Parse(char *dataPtr, bool cleanFirst = true, bool writeable = false)
+	{
+		return Parse(&dataPtr, cleanFirst, writeable);
+	}
+	void	Clean(void);
+
+	bool	Write(CTextPool *textPool);
+};
+
+
+
+// The following groups of routines are used for a C interface into GP2.
+// C++ users should just use the objects as normally and not call these routines below
+//
+
+typedef		void	*TGenericParser2;
+typedef		void	*TGPGroup;
+typedef		void	*TGPValue;
+
+// CGenericParser2 (void *) routines
+TGenericParser2		GP_Parse(char **dataPtr, bool cleanFirst, bool writeable);
+void				GP_Clean(TGenericParser2 GP2);
+void				GP_Delete(TGenericParser2 *GP2);
+TGPGroup			GP_GetBaseParseGroup(TGenericParser2 GP2);
+
+// CGPGroup (void *) routines
+const char	*GPG_GetName(TGPGroup GPG);
+bool		GPG_GetName(TGPGroup GPG, char *Value);
+TGPGroup	GPG_GetNext(TGPGroup GPG);
+TGPGroup	GPG_GetInOrderNext(TGPGroup GPG);
+TGPGroup	GPG_GetInOrderPrevious(TGPGroup GPG);
+TGPGroup	GPG_GetPairs(TGPGroup GPG);
+TGPGroup	GPG_GetInOrderPairs(TGPGroup GPG);
+TGPGroup	GPG_GetSubGroups(TGPGroup GPG);
+TGPGroup	GPG_GetInOrderSubGroups(TGPGroup GPG);
+TGPGroup	GPG_FindSubGroup(TGPGroup GPG, const char *name);
+TGPValue	GPG_FindPair(TGPGroup GPG, const char *key);
+const char	*GPG_FindPairValue(TGPGroup GPG, const char *key, const char *defaultVal);
+bool		GPG_FindPairValue(TGPGroup GPG, const char *key, const char *defaultVal, char *Value);
+
+// CGPValue (void *) routines
+const char	*GPV_GetName(TGPValue GPV);
+bool		GPV_GetName(TGPValue GPV, char *Value);
+TGPValue	GPV_GetNext(TGPValue GPV);
+TGPValue	GPV_GetInOrderNext(TGPValue GPV);
+TGPValue	GPV_GetInOrderPrevious(TGPValue GPV);
+bool		GPV_IsList(TGPValue GPV);
+const char	*GPV_GetTopValue(TGPValue GPV);
+bool		GPV_GetTopValue(TGPValue GPV, char *Value);
+TGPValue	GPV_GetList(TGPValue GPV);
+
+
+
+#endif // GENERICPARSER2_H_INC
diff --git a/codemp/qcommon/INetProfile.h b/codemp/qcommon/INetProfile.h
new file mode 100644
index 0000000..9dd9600
--- /dev/null
+++ b/codemp/qcommon/INetProfile.h
@@ -0,0 +1,20 @@
+#ifdef _DONETPROFILE_
+
+#define _INETPROFILE_H_
+#ifdef _INETPROFILE_H_
+
+class INetProfile
+{
+public:
+	virtual void Reset(void)=0;
+	virtual void AddField(char *fieldName,int sizeBytes)=0;
+	virtual void IncTime(int msec)=0;
+	virtual void ShowTotals(void)=0;
+};
+
+INetProfile &ClReadProf(void);
+INetProfile &ClSendProf(void);
+
+#endif // _INETPROFILE_H_
+
+#endif // _DONETPROFILE_
\ No newline at end of file
diff --git a/codemp/qcommon/MiniHeap.h b/codemp/qcommon/MiniHeap.h
new file mode 100644
index 0000000..711f5a4
--- /dev/null
+++ b/codemp/qcommon/MiniHeap.h
@@ -0,0 +1,57 @@
+#if !defined(MINIHEAP_H_INC)
+#define MINIHEAP_H_INC
+
+
+class CMiniHeap
+{
+private:
+	char	*mHeap;
+	char	*mCurrentHeap;
+	int		mSize;
+public:
+
+// reset the heap back to the start
+void ResetHeap()
+{
+	mCurrentHeap = mHeap;
+}
+
+// initialise the heap
+CMiniHeap(int size)
+{
+	mHeap = (char *)malloc(size);
+	mSize = size;
+	if (mHeap)
+	{
+		ResetHeap();
+	}
+}
+
+// free up the heap
+~CMiniHeap()
+{
+	if (mHeap)
+	{
+		free(mHeap);
+	}
+}
+
+// give me some space from the heap please
+char *MiniHeapAlloc(int size)
+{
+	if (size < (mSize - ((int)mCurrentHeap - (int)mHeap)))
+	{
+		char *tempAddress =  mCurrentHeap;
+		mCurrentHeap += size;
+		return tempAddress;
+	}
+	return NULL;
+}
+
+};
+
+extern CMiniHeap *G2VertSpaceServer;
+extern CMiniHeap *G2VertSpaceClient;
+
+
+#endif	//MINIHEAP_H_INC
diff --git a/codemp/qcommon/RoffSystem.cpp b/codemp/qcommon/RoffSystem.cpp
new file mode 100644
index 0000000..b88863a
--- /dev/null
+++ b/codemp/qcommon/RoffSystem.cpp
@@ -0,0 +1,1040 @@
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+#include "RoffSystem.h"
+#include "../client/client.h"
+
+// The one and only instance...
+CROFFSystem theROFFSystem;
+
+//---------------------------------------------------------------------------
+// CROFFSystem::CROFF::CROFF
+//	Simple constructor for CROFF object
+//
+// INPUTS:
+//	pass in the filepath and the id of the roff object to create
+//
+// RETURN:
+//	none
+//---------------------------------------------------------------------------
+CROFFSystem::CROFF::CROFF( const char *file, int id )
+{
+	strcpy( mROFFFilePath, file );
+
+	mID				= id;
+	mMoveRotateList = NULL;
+	mNoteTrackIndexes = 0;
+	mUsedByClient = mUsedByServer = qfalse; 
+}
+
+
+//---------------------------------------------------------------------------
+// CROFFSystem::CROFF::~CROFF()
+//	Frees any resources when the CROFF object dies
+//
+// INPUTS:
+//	none
+//
+// RETURN:
+//	none
+//---------------------------------------------------------------------------
+CROFFSystem::CROFF::~CROFF()
+{ 
+	if ( mMoveRotateList )
+	{
+		delete [] mMoveRotateList; 
+	}
+
+	if (mNoteTrackIndexes)
+	{
+		delete mNoteTrackIndexes[0];
+		delete [] mNoteTrackIndexes;
+	}
+}
+
+
+//---------------------------------------------------------------------------
+// CROFFSystem::Restart
+//	Cleans up the roff system, not sure how useful this really is
+//
+// INPUTS:
+//	none
+//
+// RETURN:
+//	success or failure
+//---------------------------------------------------------------------------
+qboolean CROFFSystem::Restart()
+{
+	TROFFList::iterator itr = mROFFList.begin();
+
+	// remove everything from the list
+	while( itr != mROFFList.end() )
+	{
+		delete ((CROFF *)(*itr).second);
+
+		mROFFList.erase( itr );
+		itr = mROFFList.begin();
+	}
+
+	// clear CROFFSystem unique ID counter
+	mID = 0; 
+
+	return qtrue;
+}
+
+
+//---------------------------------------------------------------------------
+// CROFFSystem::IsROFF
+//	Makes sure that the requested file is actually a ROFF
+//
+// INPUTS:
+//	pass in the file data
+//
+// RETURN:
+//	returns test success or failure
+//---------------------------------------------------------------------------
+qboolean CROFFSystem::IsROFF( unsigned char *data )
+{
+	TROFFHeader		*hdr = (TROFFHeader *)data;
+	TROFF2Header	*hdr2 = (TROFF2Header *)data;
+
+	if ( !strcmp( hdr->mHeader, ROFF_STRING ))
+	{ // bad header
+		return qfalse;
+	}
+
+	if (hdr->mVersion != ROFF_VERSION && hdr->mVersion != ROFF_NEW_VERSION)
+	{	// bad version
+		return qfalse;
+	}
+
+	if (hdr->mVersion == ROFF_VERSION && hdr->mCount <= 0.0)
+	{	// bad count
+		return qfalse;
+	}
+
+	if (hdr->mVersion == ROFF_NEW_VERSION && hdr2->mCount <= 0)
+	{	// bad count
+		return qfalse;
+	}
+		
+	return qtrue;
+}
+
+
+//---------------------------------------------------------------------------
+// CROFFSystem::InitROFF
+//	Handles stuffing the roff data in the CROFF object
+//
+// INPUTS:
+//	pass in the file data and the object to stuff the data into.
+//
+// RETURN:
+//	returns initialization success or failure
+//---------------------------------------------------------------------------
+qboolean CROFFSystem::InitROFF( unsigned char *data, CROFF *obj )
+{
+	int	i;
+
+	TROFFHeader *hdr = (TROFFHeader *)data;
+
+	if (hdr->mVersion == ROFF_NEW_VERSION)
+	{
+		return InitROFF2(data, obj);
+	}
+
+	obj->mROFFEntries		= hdr->mCount;
+	obj->mMoveRotateList	= new TROFF2Entry[((int)hdr->mCount)];
+	obj->mFrameTime			= 1000 / ROFF_SAMPLE_RATE;		// default 10 hz
+	obj->mLerp				= ROFF_SAMPLE_RATE;
+	obj->mNumNoteTracks		= 0;
+	obj->mNoteTrackIndexes	= 0;
+
+	if ( obj->mMoveRotateList != 0 )
+	{ // Step past the header to get to the goods
+		TROFFEntry *roff_data = ( TROFFEntry *)&hdr[1];
+
+		// Copy all of the goods into our ROFF cache
+		for ( i = 0; i < hdr->mCount; i++ )
+		{
+			VectorCopy( roff_data[i].mOriginOffset, obj->mMoveRotateList[i].mOriginOffset );
+			VectorCopy( roff_data[i].mRotateOffset, obj->mMoveRotateList[i].mRotateOffset );
+			obj->mMoveRotateList[i].mStartNote = -1;
+			obj->mMoveRotateList[i].mNumNotes = 0;
+		}
+
+		FixBadAngles(obj);
+	}
+	else
+	{
+		return qfalse;
+	}
+
+	return qtrue;
+}
+
+
+//---------------------------------------------------------------------------
+// CROFFSystem::InitROFF2
+//	Handles stuffing the roff data in the CROFF object for version 2
+//
+// INPUTS:
+//	pass in the file data and the object to stuff the data into.
+//
+// RETURN:
+//	returns initialization success or failure
+//---------------------------------------------------------------------------
+qboolean CROFFSystem::InitROFF2( unsigned char *data, CROFF *obj )
+{
+	int	i;
+
+	TROFF2Header *hdr = (TROFF2Header *)data;
+
+	obj->mROFFEntries		= hdr->mCount;
+	obj->mMoveRotateList	= new TROFF2Entry[(hdr->mCount)];
+	obj->mFrameTime			= hdr->mFrameRate;
+	obj->mLerp				= 1000 / hdr->mFrameRate;
+	obj->mNumNoteTracks		= hdr->mNumNotes;
+
+	if ( obj->mMoveRotateList != 0 )
+	{ // Step past the header to get to the goods
+		TROFF2Entry *roff_data = ( TROFF2Entry *)&hdr[1];
+
+		// Copy all of the goods into our ROFF cache
+		for ( i = 0; i < hdr->mCount; i++ )
+		{
+			VectorCopy( roff_data[i].mOriginOffset, obj->mMoveRotateList[i].mOriginOffset );
+			VectorCopy( roff_data[i].mRotateOffset, obj->mMoveRotateList[i].mRotateOffset );
+			obj->mMoveRotateList[i].mStartNote = roff_data[i].mStartNote;
+			obj->mMoveRotateList[i].mNumNotes = roff_data[i].mNumNotes;
+		}
+
+		FixBadAngles(obj);
+
+		if (obj->mNumNoteTracks)
+		{
+			int		size;
+			char	*ptr, *start;
+
+			ptr = start = (char *)&roff_data[i];
+			size = 0;
+
+			for(i=0;i<obj->mNumNoteTracks;i++)
+			{
+				size += strlen(ptr) + 1;
+				ptr += strlen(ptr) + 1;
+			}
+
+			obj->mNoteTrackIndexes = new char *[obj->mNumNoteTracks];
+			ptr = obj->mNoteTrackIndexes[0] = new char[size];
+			memcpy(obj->mNoteTrackIndexes[0], start, size);
+
+			for(i=1;i<obj->mNumNoteTracks;i++)
+			{
+				ptr += strlen(ptr) + 1;
+				obj->mNoteTrackIndexes[i] = ptr;
+			}
+		}
+	}
+	else
+	{
+		return qfalse;
+	}
+
+	return qtrue;
+}
+
+/************************************************************************************************
+ * CROFFSystem::FixBadAngles                                                                    *
+ *    This function will attempt to fix bad angles (large) that come in from the exporter.      *
+ *                                                                                              *
+ * Input                                                                                        *
+ *    obj: the ROFF object                                                                      *
+ *                                                                                              *
+ * Output / Return                                                                              *
+ *    none                                                                                      *
+ *                                                                                              *
+ ************************************************************************************************/
+void CROFFSystem::FixBadAngles(CROFF *obj)
+{
+// Ideally we would fix the ROFF exporter, if that doesn't happen, this may be an adequate solution
+#ifdef ROFF_AUTO_FIX_BAD_ANGLES
+	int		index, t;
+
+	// Attempt to fix bad angles
+
+	for(index=0;index<obj->mROFFEntries;index++)
+	{
+		for ( t = 0; t < 3; t++ )
+		{
+			if ( obj->mMoveRotateList[index].mRotateOffset[t] > 180.0f )
+			{ // found a bad angle
+			//	Com_Printf( S_COLOR_YELLOW"Fixing bad roff angle\n <%6.2f> changed to <%6.2f>.\n", 
+			//				roff_data[i].mRotateOffset[t], roff_data[i].mRotateOffset[t] - 360.0f );
+				obj->mMoveRotateList[index].mRotateOffset[t] -= 360.0f;
+			}
+			else if ( obj->mMoveRotateList[index].mRotateOffset[t] < -180.0f )
+			{ // found a bad angle
+			//	Com_Printf( S_COLOR_YELLOW"Fixing bad roff angle\n <%6.2f> changed to <%6.2f>.\n", 
+			//				roff_data[i].mRotateOffset[t], roff_data[i].mRotateOffset[t] + 360.0f );
+				obj->mMoveRotateList[index].mRotateOffset[t] += 360.0f;
+			}
+		}
+	}
+#endif // ROFF_AUTO_FIX_BAD_ANGLES
+}
+
+//---------------------------------------------------------------------------
+// CROFFSystem::Cache
+//	Pre-caches roff data to avoid file hits during gameplay.  Disallows
+//		repeated caches of existing roffs.
+//
+// INPUTS:
+//	pass in the filepath of the roff to cache
+//
+// RETURN:
+//	returns ID of the roff, whether its an existing one or new one.
+//---------------------------------------------------------------------------
+int CROFFSystem::Cache( const char *file, qboolean isClient )
+{
+	// See if this item is already cached
+	int				len;
+	int				id = GetID( file );
+	unsigned char	*data;	
+	CROFF			*cROFF;
+
+	if ( id )
+	{
+#ifdef _DEBUG
+		Com_Printf( S_COLOR_YELLOW"Ignoring. File '%s' already cached.\n", file );
+#endif
+	}
+	else
+	{ // Read the file in one fell swoop
+		len = FS_ReadFile( file, (void**) &data);
+
+		if ( len <= 0 )
+		{
+			char otherPath[1024];
+			COM_StripExtension(file, otherPath);
+			len = FS_ReadFile( va("scripts/%s.rof", otherPath), (void**) &data);
+			if (len <= 0)
+			{
+				Com_Printf( S_COLOR_RED"Could not open .ROF file '%s'\n", file );
+				return 0;
+			}
+		}
+
+		// Make sure that the file is roff
+		if ( !IsROFF( data ) )
+		{
+			Com_Printf( S_COLOR_RED"cache failed: roff <%s> does not exist or is not a valid roff\n", file );
+			FS_FreeFile( data );
+
+			return 0;
+		}
+
+		// Things are looking good so far, so create a new CROFF object
+		id = NewID();
+
+		cROFF = new CROFF( file, id );
+	
+		mROFFList[id] = cROFF;
+
+		if ( !InitROFF( data, cROFF ) )
+		{ // something failed, so get rid of the object
+			Unload( id );
+			id = 0;
+		}
+
+		FS_FreeFile( data );
+	}
+
+	cROFF = (*mROFFList.find( id )).second;
+	if (isClient)
+	{
+		cROFF->mUsedByClient = qtrue;
+	}
+	else
+	{
+		cROFF->mUsedByServer = qtrue;
+	}
+
+	// If we haven't requested a new ID, we'll just be returning the ID of the existing roff
+	return id;
+}
+
+
+//---------------------------------------------------------------------------
+// CROFFSystem::GetID
+//	Finds the associated (internal) ID of the specified roff file
+//
+// INPUTS:
+//	pass in the roff file path
+//
+// RETURN:
+//	returns ID if there is one, zero if nothing was found
+//---------------------------------------------------------------------------
+int	CROFFSystem::GetID( const char *file )
+{
+	TROFFList::iterator itr;
+
+	// Attempt to find the requested roff
+	for ( itr = mROFFList.begin(); itr != mROFFList.end(); ++itr )
+	{
+		if ( !strcmp( ((CROFF *)((*itr).second))->mROFFFilePath, file ) )
+		{ // return the ID to this roff
+			return (*itr).first;
+		}
+	}
+
+	// Not found
+	return 0;
+}
+
+
+//---------------------------------------------------------------------------
+// CROFFSystem::Unload
+//	Removes the roff from the list, deleting it to free up any used resources
+//
+// INPUTS:
+//	pass in the id of the roff to delete, use GetID if you only know the roff
+//		filepath
+//
+// RETURN:
+//	qtrue if item was in the list, qfalse otherwise
+//---------------------------------------------------------------------------
+qboolean CROFFSystem::Unload( int id )
+{
+	TROFFList::iterator itr;
+
+	itr = mROFFList.find( id );
+
+	if ( itr != mROFFList.end() )
+	{ // requested item found in the list, free mem, then remove from list
+		delete ((CROFF *)(*itr).second);
+
+#ifndef __linux__
+		itr = mROFFList.erase( itr );
+#else
+		// darn stl differences
+		TROFFList::iterator titr;
+		titr = itr;
+		itr++;
+		mROFFList.erase(titr);
+#endif
+
+#ifdef _DEBUG
+		Com_Printf( S_COLOR_GREEN"roff unloaded\n" );
+#endif
+
+		return qtrue;
+	}
+	else
+	{ // not found
+
+#ifdef _DEBUG
+		Com_Printf( S_COLOR_RED"unload failed: roff <%i> does not exist\n", id );
+#endif
+		return qfalse;
+	}
+}
+
+//---------------------------------------------------------------------------
+// CROFFSystem::Clean
+//	Cleans out all Roffs, freeing up any used resources
+//
+// INPUTS:
+//	none
+//
+// RETURN:
+//	success of operation
+//---------------------------------------------------------------------------
+qboolean CROFFSystem::Clean(qboolean isClient)
+{
+#if 0
+	TROFFList::iterator			itr, next;
+	TROFFEntList::iterator		entI, nextEnt;
+	itr = mROFFList.begin();
+	while ( itr != mROFFList.end() )
+	{
+		next = itr;
+		next++;
+
+		if (isClient)
+		{
+			(*itr).second->mUsedByClient = qfalse;
+		}
+		else
+		{
+			(*itr).second->mUsedByServer = qfalse;
+		}
+		if ((*itr).second->mUsedByClient == qfalse && (*itr).second->mUsedByServer == qfalse)
+		{	// we are not used on both client and server, so unload
+			Unload( (*itr).first );
+		}
+
+		itr = next;
+	}
+
+	entI = mROFFEntList.begin();
+	while ( entI != mROFFEntList.end() )
+	{
+		nextEnt = entI;
+		nextEnt++;
+
+		if ((*entI)->mIsClient == isClient)
+		{
+			delete (*entI);
+			mROFFEntList.erase( entI );
+		}
+
+		entI = nextEnt;
+	}
+	mROFFEntList.clear();
+
+	return qtrue;
+#else
+	TROFFList::iterator itr;
+
+	itr = mROFFList.begin();
+
+	while ( itr != mROFFList.end() )
+	{
+		Unload( (*itr).first );
+
+		itr = mROFFList.begin();
+	}
+	return qtrue;
+#endif
+}
+
+//---------------------------------------------------------------------------
+// CROFFSystem::List
+//	Dumps the file path to the current set of cached roffs, for debug purposes
+//
+// INPUTS:
+//	none
+//
+// RETURN:
+//	none
+//---------------------------------------------------------------------------
+void CROFFSystem::List()
+{
+	TROFFList::iterator itr;
+
+	Com_Printf( S_COLOR_GREEN"\n--Cached ROFF files--\n" );
+	Com_Printf( S_COLOR_GREEN"ID   FILE\n" );
+
+	for ( itr = mROFFList.begin(); itr != mROFFList.end(); ++itr )
+	{
+		Com_Printf( S_COLOR_GREEN"%2i - %s\n", (*itr).first, ((CROFF *)((*itr).second))->mROFFFilePath );
+	}
+
+	Com_Printf( S_COLOR_GREEN"\nFiles: %i\n", mROFFList.size() );
+}
+
+
+//---------------------------------------------------------------------------
+// CROFFSystem::List
+//	Overloaded version of List, dumps the specified roff data to the console
+//
+// INPUTS:
+//	id of roff to display
+//
+// RETURN:
+//	success or failure of operation
+//---------------------------------------------------------------------------
+qboolean CROFFSystem::List( int id )
+{
+	TROFFList::iterator itr;
+
+	itr = mROFFList.find( id );
+
+	if ( itr != mROFFList.end() )
+	{ // requested item found in the list
+		CROFF		*obj = ((CROFF *)((*itr).second));
+		TROFF2Entry	*dat = obj->mMoveRotateList;
+
+		Com_Printf( S_COLOR_GREEN"File: %s\n", obj->mROFFFilePath );
+		Com_Printf( S_COLOR_GREEN"ID: %i\n", id );
+		Com_Printf( S_COLOR_GREEN"Entries: %i\n\n", obj->mROFFEntries );
+
+		Com_Printf( S_COLOR_GREEN"MOVE                 ROTATE\n" );
+
+		for ( int i = 0; i < obj->mROFFEntries; i++ )
+		{
+			Com_Printf( S_COLOR_GREEN"%6.2f %6.2f %6.2f   %6.2f %6.2f %6.2f\n", 
+						dat[i].mOriginOffset[0], dat[i].mOriginOffset[1], dat[i].mOriginOffset[2],
+						dat[i].mRotateOffset[0], dat[i].mRotateOffset[1], dat[i].mRotateOffset[2] );
+		}
+
+		return qtrue;
+	}
+
+	Com_Printf( S_COLOR_YELLOW"ROFF not found: id <%d>\n", id );
+
+	return qfalse;
+}
+
+
+//---------------------------------------------------------------------------
+// CROFFSystem::Play
+//	Start roff playback on an entity
+//
+// INPUTS:
+//	the id of the entity that will be roffed
+//	the id of the roff to play
+//
+// RETURN:
+//	success or failure of add operation
+//---------------------------------------------------------------------------
+qboolean CROFFSystem::Play( int entID, int id, qboolean doTranslation, qboolean isClient )
+{
+	sharedEntity_t *ent = SV_GentityNum( entID );
+
+	ent->r.mIsRoffing = qtrue;
+/*rjr	if(ent->GetPhysics() == PHYSICS_TYPE_NONE)
+	{
+		ent->SetPhysics(PHYSICS_TYPE_BRUSHMODEL);
+	}*/
+	//bjg TODO: reset this latter? 
+
+	if ( ent == 0 )
+	{ // shame on you..
+		return qfalse;
+	}
+
+	SROFFEntity *roffing_ent = new SROFFEntity;
+
+	roffing_ent->mEntID			= entID;
+	roffing_ent->mROFFID		= id;
+	roffing_ent->mNextROFFTime	= svs.time;
+	roffing_ent->mROFFFrame		= 0;
+	roffing_ent->mKill			= qfalse;
+	roffing_ent->mSignal		= qtrue; // TODO: hook up the real signal code
+	roffing_ent->mTranslated	= doTranslation;
+	roffing_ent->mIsClient		= isClient;
+
+	VectorCopy(ent->s.apos.trBase, roffing_ent->mStartAngles);
+
+	mROFFEntList.push_back( roffing_ent );
+
+	return qtrue;
+}
+
+
+//---------------------------------------------------------------------------
+// CROFFSystem::ListEnts
+//	List all of the ents in the roff system
+//
+// INPUTS:
+//	none
+//
+// RETURN:
+//	none
+//---------------------------------------------------------------------------
+void CROFFSystem::ListEnts()
+{
+/*	char	*name, *file;
+	int		id;
+
+	TROFFEntList::iterator itr = mROFFEntList.begin();
+	TROFFList::iterator itrRoff;
+
+	Com_Printf( S_COLOR_GREEN"\n--ROFFing Entities--\n" );
+	Com_Printf( S_COLOR_GREEN"EntID EntName       RoffFile\n" );
+
+	// display everything in the end list
+	for ( itr = mROFFEntList.begin(); itr != mROFFEntList.end(); ++itr )
+	{
+		// Entity ID
+		id = ((SROFFEntity *)(*itr))->mEntID;
+		// Entity Name
+		name = entitySystem->GetEntityFromID( id )->GetName();
+		// ROFF object that will contain the roff file name
+		itrRoff = mROFFList.find( ((SROFFEntity *)(*itr))->mROFFID );
+
+		if ( itrRoff != mROFFList.end() )
+		{ // grab our filename
+			file = ((CROFF *)((*itrRoff).second ))->mROFFFilePath;
+		}
+		else
+		{ // roff filename not found == bad
+			file = "Error:  Unknown";
+		}
+
+		Com_Printf( S_COLOR_GREEN"%3i  %s    %s\n", id, name, file );
+	}
+
+	Com_Printf( S_COLOR_GREEN"\nEntities: %i\n", mROFFEntList.size() );*/
+}
+
+
+//---------------------------------------------------------------------------
+// CROFFSystem::PurgeEnt
+//	Prematurely purge an entity from the roff system
+//
+// INPUTS:
+//	the id of the entity to purge
+//
+// RETURN:
+//	success or failure of purge operation
+//---------------------------------------------------------------------------
+qboolean CROFFSystem::PurgeEnt( int entID, qboolean isClient )
+{
+	TROFFEntList::iterator itr = mROFFEntList.begin();
+
+	for ( itr = mROFFEntList.begin(); itr != mROFFEntList.end(); ++itr )
+	{
+		if ( (*itr)->mIsClient == isClient && (*itr)->mEntID == entID)
+		{
+			// Make sure it won't stay lerping
+			ClearLerp( (*itr) );
+
+			delete (*itr);
+
+			mROFFEntList.erase( itr );
+			return qtrue;
+		}
+	}
+
+	Com_Printf( S_COLOR_RED"Purge failed:  Entity <%i> not found\n", entID );
+
+	return qfalse;
+}
+
+
+
+//---------------------------------------------------------------------------
+// CROFFSystem::PurgeEnt
+//	Prematurely purge an entity from the roff system
+//
+// INPUTS:
+//	the name fo the entity to purge
+//
+// RETURN:
+//	success or failure of purge operation
+//---------------------------------------------------------------------------
+qboolean CROFFSystem::PurgeEnt( char *name )
+{
+/* rjr	CEntity *ent = entitySystem->GetEntityFromName( NULL, name );
+
+	if ( ent && ent->GetInUse() == qtrue )
+	{
+		return PurgeEnt( ent->GetID() );
+	}
+	else
+	{
+		Com_Printf( S_COLOR_RED"Entity <%s> not found or not in use\n", name );
+		return qfalse;
+	}*/
+
+	return qfalse;
+}
+
+//---------------------------------------------------------------------------
+// CROFFSystem::UpdateEntities
+//	Update all of the entities in the system
+//
+// INPUTS:
+//	none
+//
+// RETURN:
+//	none
+//---------------------------------------------------------------------------
+void CROFFSystem::UpdateEntities(qboolean isClient)
+{
+	TROFFEntList::iterator itr = mROFFEntList.begin();
+	TROFFList::iterator itrRoff;
+
+	// display everything in the entity list
+	for ( itr = mROFFEntList.begin(); itr != mROFFEntList.end(); ++itr )
+	{
+		if ((*itr)->mIsClient != isClient)
+		{
+			continue;
+		}
+
+		// Get this entities ROFF object
+		itrRoff = mROFFList.find( ((SROFFEntity *)(*itr))->mROFFID );
+
+		if ( itrRoff != mROFFList.end() )
+		{ // roff that baby!
+			if ( !ApplyROFF( ((SROFFEntity *)(*itr)), ((CROFF *)((*itrRoff).second ))))
+			{ // done roffing, mark for death
+				((SROFFEntity *)(*itr))->mKill = qtrue;
+			}
+		}
+		else
+		{ // roff not found == bad, dump an error message and purge this ent
+			Com_Printf( S_COLOR_RED"ROFF System Error:\n" );
+//			Com_Printf( S_COLOR_RED" -ROFF not found for entity <%s>\n", 
+//					entitySystem->GetEntityFromID(((SROFFEntity *)(*itr))->mEntID)->GetName() );
+
+			((SROFFEntity *)(*itr))->mKill = qtrue;
+
+			ClearLerp( (*itr) );
+		}
+	}
+
+	itr = mROFFEntList.begin();
+
+	// Delete killed ROFFers from the list
+	// Man, there just has to be a better way to do this
+	while ( itr != mROFFEntList.end() )
+	{
+		if ((*itr)->mIsClient != isClient)
+		{
+			itr++;
+			continue;
+		}
+
+		if ( ((SROFFEntity *)(*itr))->mKill == qtrue )
+		{ 
+			//make sure ICARUS knows ROFF is stopped
+//			CICARUSGameInterface::TaskIDComplete(
+//				entitySystem->GetEntityFromID(((SROFFEntity *)(*itr))->mEntID), TID_MOVE);
+			// trash this guy from the list
+			delete (*itr);
+			mROFFEntList.erase( itr );
+			itr = mROFFEntList.begin();			
+		}
+		else
+		{
+			itr++;
+		}
+	}
+}
+
+//---------------------------------------------------------------------------
+// CROFFSystem::ApplyROFF
+//	Does the dirty work of applying the raw ROFF data
+//
+// INPUTS:
+//	The the roff_entity struct and the raw roff data
+//
+// RETURN:
+//	True == success;  False == roff playback complete or failure
+//---------------------------------------------------------------------------
+qboolean CROFFSystem::ApplyROFF( SROFFEntity *roff_ent, CROFFSystem::CROFF *roff )
+{
+	vec3_t			f, r, u, result;
+	sharedEntity_t	*ent = NULL;
+	trajectory_t	*originTrajectory, *angleTrajectory;
+	vec_t			*origin, *angle;
+
+
+	if ( svs.time < roff_ent->mNextROFFTime )
+	{ // Not time to roff yet
+		return qtrue;
+	}
+
+	if (roff_ent->mIsClient)
+	{
+#ifndef DEDICATED
+		vec3_t		originTemp, angleTemp;
+		originTrajectory = (trajectory_t *)VM_Call( cgvm, CG_GET_ORIGIN_TRAJECTORY, roff_ent->mEntID );
+		angleTrajectory = (trajectory_t *)VM_Call( cgvm, CG_GET_ANGLE_TRAJECTORY, roff_ent->mEntID );
+		VM_Call( cgvm, CG_GET_ORIGIN, roff_ent->mEntID, originTemp );
+		origin = originTemp;
+		VM_Call( cgvm, CG_GET_ANGLES, roff_ent->mEntID, angleTemp );
+		angle = angleTemp;
+#endif
+	}
+	else
+	{
+		// Find the entity to apply the roff to
+		ent = SV_GentityNum( roff_ent->mEntID );
+
+		if ( ent == 0 )
+		{	// bad stuff
+			return qfalse;
+		}
+
+		originTrajectory = &ent->s.pos;
+		angleTrajectory = &ent->s.apos;
+		origin = ent->r.currentOrigin;
+		angle = ent->r.currentAngles;
+	}
+
+
+	if ( roff_ent->mROFFFrame >= roff->mROFFEntries )
+	{ // we are done roffing, so stop moving and flag this ent to be removed
+		SetLerp( originTrajectory, TR_STATIONARY, origin, NULL, svs.time, roff->mLerp );
+		SetLerp( angleTrajectory, TR_STATIONARY, angle, NULL, svs.time, roff->mLerp );
+		if (!roff_ent->mIsClient)
+		{
+			ent->r.mIsRoffing = qfalse;
+		}
+		return qfalse;
+	}
+
+	if (roff_ent->mTranslated)
+	{
+		AngleVectors(roff_ent->mStartAngles, f, r, u );
+		VectorScale(f, roff->mMoveRotateList[roff_ent->mROFFFrame].mOriginOffset[0], result);
+		VectorMA(result, -roff->mMoveRotateList[roff_ent->mROFFFrame].mOriginOffset[1], r, result);
+		VectorMA(result, roff->mMoveRotateList[roff_ent->mROFFFrame].mOriginOffset[2], u, result);
+	}
+	else
+	{
+		VectorCopy(roff->mMoveRotateList[roff_ent->mROFFFrame].mOriginOffset, result);
+	}
+
+	// Set up our origin interpolation
+	SetLerp( originTrajectory, TR_LINEAR, origin, result, svs.time, roff->mLerp );
+
+	// Set up our angle interpolation
+	SetLerp( angleTrajectory, TR_LINEAR, angle, 
+				roff->mMoveRotateList[roff_ent->mROFFFrame].mRotateOffset, svs.time, roff->mLerp );
+
+	if (roff->mMoveRotateList[roff_ent->mROFFFrame].mStartNote >= 0)
+	{
+		int		i;
+
+		for(i=0;i<roff->mMoveRotateList[roff_ent->mROFFFrame].mNumNotes;i++)
+		{
+			ProcessNote(roff_ent, roff->mNoteTrackIndexes[roff->mMoveRotateList[roff_ent->mROFFFrame].mStartNote + i]);
+		}
+	}
+
+	// Advance ROFF frames and lock to a 10hz cycle
+	roff_ent->mROFFFrame++;
+	roff_ent->mNextROFFTime = svs.time + roff->mFrameTime;
+
+	//rww - npcs need to know when they're getting roff'd
+	ent->next_roff_time = roff_ent->mNextROFFTime;
+
+
+	return qtrue;
+}
+
+
+/************************************************************************************************
+ * CROFFSystem::ProcessNote                                                                     *
+ *    This function will send the note to the client.  It will parse through the note for       *
+ *    leading or trailing white space (thus making each line feed a separate function call).    *
+ *                                                                                              *
+ * Input                                                                                        *
+ *    ent: the entity for which the roff is being played                                        *
+ *    note: the note that should be passed on                                                   *
+ *                                                                                              *
+ * Output / Return                                                                              *
+ *    none                                                                                      *
+ *                                                                                              *
+ ************************************************************************************************/
+void CROFFSystem::ProcessNote(SROFFEntity *roff_ent, char *note)
+{
+	char	temp[1024];
+	int		pos, size;
+
+	pos = 0;
+	while(note[pos])
+	{
+		size = 0;
+		while(note[pos] && note[pos] < ' ')
+		{
+			pos++;
+		}
+
+		while(note[pos] && note[pos] >= ' ')
+		{
+			temp[size++] = note[pos++];
+		}
+		temp[size] = 0;
+
+		if (size)
+		{
+			if (roff_ent->mIsClient)
+			{
+#ifndef DEDICATED
+				VM_Call( cgvm, CG_ROFF_NOTETRACK_CALLBACK, roff_ent->mEntID, temp );
+#endif
+			}
+			else
+			{
+				VM_Call( gvm, GAME_ROFF_NOTETRACK_CALLBACK, roff_ent->mEntID, temp );
+			}
+		}
+	}
+}
+
+//---------------------------------------------------------------------------
+// CROFFSystem::ClearLerp
+//	Helper function to clear a given entities lerp fields
+//
+// INPUTS:
+//	The ID of the entity to clear
+//
+// RETURN:
+//	success or failure of the operation
+//---------------------------------------------------------------------------
+qboolean CROFFSystem::ClearLerp( SROFFEntity *roff_ent )
+{
+	sharedEntity_t	*ent;
+	trajectory_t	*originTrajectory, *angleTrajectory;
+	vec_t			*origin, *angle;
+
+	if (roff_ent->mIsClient)
+	{
+#ifndef DEDICATED
+		vec3_t		originTemp, angleTemp;
+		originTrajectory = (trajectory_t *)VM_Call( cgvm, CG_GET_ORIGIN_TRAJECTORY, roff_ent->mEntID );
+		angleTrajectory = (trajectory_t *)VM_Call( cgvm, CG_GET_ANGLE_TRAJECTORY, roff_ent->mEntID );
+		VM_Call( cgvm, CG_GET_ORIGIN, roff_ent->mEntID, originTemp );
+		origin = originTemp;
+		VM_Call( cgvm, CG_GET_ANGLES, roff_ent->mEntID, angleTemp );
+		angle = angleTemp;
+#endif
+	}
+	else
+	{
+		// Find the entity to apply the roff to
+		ent = SV_GentityNum( roff_ent->mEntID );
+
+		if ( ent == 0 )
+		{	// bad stuff
+			return qfalse;
+		}
+
+		originTrajectory = &ent->s.pos;
+		angleTrajectory = &ent->s.apos;
+		origin = ent->r.currentOrigin;
+		angle = ent->r.currentAngles;
+	}
+
+	SetLerp( originTrajectory, TR_STATIONARY, origin, NULL, svs.time, ROFF_SAMPLE_RATE );
+	SetLerp( angleTrajectory, TR_STATIONARY, angle, NULL, svs.time, ROFF_SAMPLE_RATE );
+
+	return qtrue;
+}
+
+//---------------------------------------------------------------------------
+// CROFFSystem::SetLerp
+//	Helper function to set up a positional or angular interpolation
+//
+// INPUTS:
+//	The entity trajectory field to modify, the interpolation type, the base origin,
+//		and the interpolation start time
+//
+// RETURN:
+//	none
+//---------------------------------------------------------------------------
+void CROFFSystem::SetLerp( trajectory_t *tr, trType_t type, vec3_t origin, vec3_t delta, int time, int rate)
+{
+	tr->trType = type;
+	tr->trTime = time;
+	VectorCopy( origin, tr->trBase );
+
+	// Check for a NULL delta
+	if ( delta )
+	{
+		VectorScale( delta, rate, tr->trDelta );
+	}
+	else
+	{
+		VectorClear( tr->trDelta );
+	}
+}
+
diff --git a/codemp/qcommon/RoffSystem.h b/codemp/qcommon/RoffSystem.h
new file mode 100644
index 0000000..dbfe1f0
--- /dev/null
+++ b/codemp/qcommon/RoffSystem.h
@@ -0,0 +1,185 @@
+#if defined (_MSC_VER) && (_MSC_VER >= 1020)
+#pragma once
+#endif
+
+#if !defined(CROFFSYSTEM_H_INC)
+#define CROFFSYSTEM_H_INC
+
+#ifndef __Q_SHARED_H
+	#include "../game/q_shared.h"	//needs to be in here for entityState_t
+#endif
+
+#if !defined(SERVER_H_INC)
+	#include "../server/server.h"
+#endif
+
+#pragma warning (push, 3)	//go back down to 3 for the stl include
+#include <vector>
+#include <map>
+#pragma warning (pop)
+using namespace std;
+
+// ROFF Defines
+//-------------------
+#define ROFF_VERSION				1
+#define ROFF_NEW_VERSION			2
+#define ROFF_STRING					"ROFF"
+#define ROFF_SAMPLE_RATE			10	// 10hz
+#define ROFF_AUTO_FIX_BAD_ANGLES	// exporter can mess up angles, 
+									//	defining this attempts to detect and fix these problems
+
+
+// The CROFFSystem object provides all of the functionality of ROFF
+//	caching, playback, and clean-up, plus some useful debug features.
+//--------------------------------------
+class CROFFSystem
+//--------------------------------------
+{
+private:
+//------
+
+	// forward declarations
+	class			CROFF;
+	struct			SROFFEntity;
+
+	typedef	map		<int, CROFF *> TROFFList;
+	typedef vector	<SROFFEntity *> TROFFEntList;
+
+	TROFFList		mROFFList;				// List of cached roffs
+	int				mID;					// unique ID generator for new roff objects
+
+	TROFFEntList	mROFFEntList;			// List of roffing entities
+
+	// ROFF Header file definition, nothing else needs to see this
+	typedef struct tROFFHeader
+	//-------------------------------
+	{
+		char	mHeader[4];				// should match roff_string defined above
+		long	mVersion;				// version num, supported version defined above
+		float	mCount;					// I think this is a float because of a limitation of the roff exporter
+
+	} TROFFHeader;
+
+	// ROFF Entry, nothing else needs to see this
+	typedef struct tROFFEntry 
+	//-------------------------------
+	{
+		float		mOriginOffset[3];
+		float		mRotateOffset[3];
+	} TROFFEntry;
+
+	typedef struct tROFF2Header
+	//-------------------------------
+	{
+		char	mHeader[4];				// should match roff_string defined above
+		long	mVersion;				// version num, supported version defined above
+		int		mCount;					// I think this is a float because of a limitation of the roff exporter
+		int		mFrameRate;				// Frame rate the roff should be played at
+		int		mNumNotes;				// number of notes (null terminated strings) after the roff data
+
+	} TROFF2Header;
+
+	// ROFF Entry, nothing else needs to see this
+	typedef struct tROFF2Entry 
+	//-------------------------------
+	{
+		float		mOriginOffset[3];
+		float		mRotateOffset[3];
+		int			mStartNote, mNumNotes;		// note track info
+	} TROFF2Entry;
+
+	// An individual ROFF object, 
+	//	contains actual rotation/offset information
+	//--------------------------------------
+	class CROFF
+	//--------------------------------------
+	{
+	public:
+	//------
+
+		int			mID;						// id for this roff file
+		char		mROFFFilePath[MAX_QPATH];	// roff file path
+		int			mROFFEntries;				// count of move/rotate commands
+		int			mFrameTime;					// frame rate
+		int			mLerp;						// Lerp rate (FPS)
+		TROFF2Entry	*mMoveRotateList;			// move rotate/command list
+		int			mNumNoteTracks;
+		char		**mNoteTrackIndexes;
+		qboolean	mUsedByClient;
+		qboolean	mUsedByServer;
+
+		CROFF() 
+		{ 
+			mUsedByClient = mUsedByServer = qfalse; 
+		}
+		CROFF( const char *file, int id );
+		~CROFF();
+
+	}; // class CROFF
+
+
+	// The roff system tracks entities that are 
+	//	roffing, so this is the internal structure
+	//	that represents these objects.
+	//--------------------------------------
+	struct SROFFEntity
+	//--------------------------------------
+	{
+		int			mEntID;			// the entity that is currently roffing
+
+		int			mROFFID;		// the roff to be applied to that entity
+		int			mNextROFFTime;	// next time we should roff
+		int			mROFFFrame;		// current roff frame we are applying
+
+		qboolean		mKill;			// flag to kill a roffing ent
+		qboolean		mSignal;		// TODO:  Need to implement some sort of signal to Icarus when roff is done.
+		qboolean	mTranslated;	// should this roff be "rotated" to fit the entity's initial position?
+		qboolean	mIsClient;
+		vec3_t		mStartAngles;	// initial angle of the entity
+	}; // struct SROFFEntity
+
+
+	qboolean	IsROFF( byte *file );				// Makes sure the file is a valid roff file
+	qboolean	InitROFF( byte *file, CROFF *obj );	// Handles stashing raw roff data into the roff object
+	qboolean	InitROFF2( byte *file, CROFF *obj );	// Handles stashing raw roff data into the roff object
+	void	FixBadAngles(CROFF *obj);
+	int		NewID() { return ++mID; }			// Increment before return so we can use zero as failed return val
+	qboolean	ApplyROFF( SROFFEntity *roff_ent,
+					CROFFSystem::CROFF *roff );	// True = success; False = roff complete
+
+	void	ProcessNote(SROFFEntity *roff_ent, char *note);
+
+	void	SetLerp( trajectory_t *tr, 
+					trType_t, vec3_t origin, 
+					vec3_t delta, int time, int rate );
+
+	qboolean	ClearLerp( SROFFEntity *roff_ent );				// Clears out the angular and position lerp fields
+
+public:
+//------
+
+	CROFFSystem()	{	mID = 0; mROFFEntList.clear();	}
+	~CROFFSystem()	{	Restart();	}
+
+
+	qboolean		Restart();						// Free up all system resources and reset the ID counter
+
+	int			Cache( const char *file, qboolean isClient );			// roffs should be precached at the start of each level
+	int			GetID( const char *file );			// find the roff id by filename
+	qboolean		Unload( int id );				// when a roff is done, it can be removed to free up resources
+	qboolean	Clean(qboolean isClient);					// should be called when level is done, frees all roff resources
+	void		List(void);						// dumps a list of all cached roff files to the console
+	qboolean		List( int id );					// dumps the contents of the specified roff to the console
+
+	qboolean	Play( int entID, int roffID, qboolean doTranslation, qboolean isClient);	// TODO: implement signal on playback completion.
+	void		ListEnts();						// List the entities that are currently roffing
+	qboolean	PurgeEnt( int entID, qboolean isClient );			// Purge the specified entity from the entity list by id
+	qboolean		PurgeEnt( char *file );			// Purge the specified entity from the entity list by name
+	void		UpdateEntities(qboolean isClient);			// applys roff data to roffing entities.
+
+}; // class CROFFSystem
+
+
+extern CROFFSystem theROFFSystem;
+
+#endif // CROFFSYSTEM_H_INC
diff --git a/codemp/qcommon/chash.h b/codemp/qcommon/chash.h
new file mode 100644
index 0000000..b9f5cb1
--- /dev/null
+++ b/codemp/qcommon/chash.h
@@ -0,0 +1,162 @@
+// Notes
+// Make sure extension is stripped if it needs to be
+
+// Template class must have
+// 1. A GetName() accessor - a null terminated string case insensitive
+// 2. A Destroy() function - normally "delete this"
+// 3. SetNext(T *) and T *GetNext() functions
+
+#define HASH_SIZE	1024
+
+template <class T, int TSize = HASH_SIZE, int (*TCompare)(const char *, const char *) = &strcmp>
+
+class CHash
+{
+private:
+	T		*mHashTable[TSize];
+	T		*mNext;
+	int		mCount;
+	T		*mPrevious;					// Internal work variable
+	long	mHash;						// Internal work variable
+
+	// Creates the hash value and sets the mHash member
+	void CreateHash(const char *key)
+	{
+		int		i = 0;
+		char	letter;
+
+		mHash = 0;
+		letter = *key++;
+		while (letter)
+		{
+			mHash += (long)(letter) * (i + 119);
+
+			i++;
+			letter = *key++;
+		}
+		mHash &= TSize - 1;
+	}
+public:
+	// Constructor
+	CHash(void)
+	{
+		memset(mHashTable, NULL, sizeof(mHashTable));
+		mNext = NULL;
+		mCount = 0;
+		mPrevious = NULL;
+		mHash = 0;
+	}
+	// Destructor
+	~CHash(void)
+	{
+#ifdef _DEBUG
+//		Com_OPrintf("Shutting down %s hash table .....", typeid(T).name());
+#endif
+		clear();
+#ifdef _DEBUG
+		Com_OPrintf(" done\n");
+#endif
+	}
+	// Returns the total number of entries in the hash table
+	int count(void) const { return(mCount); }
+
+	// Inserts an item into the hash table
+	void insert(T *item)
+	{
+		CreateHash(item->GetName());
+		item->SetNext(mHashTable[mHash]);
+		mHashTable[mHash] = item;
+		mCount++;
+	}
+	// Finds an item in the hash table (sets the mPrevious member)
+	T *find(const char *key)
+	{
+		CreateHash(key);
+		T *item = mHashTable[mHash];
+		mPrevious = NULL;
+		while(item)
+		{
+			mNext = item->GetNext();
+			if(!TCompare(item->GetName(), key))
+			{
+				return(item);
+			}
+			mPrevious = item;
+			item = mNext;
+		}
+		return(NULL);
+	}
+	// Remove item from the hash table referenced by key
+	bool remove(const char *key)
+	{
+		T *item = find(key);
+		if(item)
+		{
+			T *next = item->GetNext();
+			if(mPrevious)
+			{
+				mPrevious->SetNext(next);
+			}
+			else
+			{
+				mHashTable[mHash] = next;
+			}
+			item->Destroy();
+			mCount--;
+			return(true);
+		}
+		return(false);
+	}
+	// Remove item from hash referenced by item
+	bool remove(T *item)
+	{
+		return(remove(item->GetName()));
+	}
+	// Returns the first valid entry
+	T *head(void)
+	{
+		mHash = -1;
+		mNext = NULL;
+		return(next());
+	}
+	// Returns the next entry in the hash table
+	T *next(void)
+	{
+		T *item;
+
+		assert(mHash < TSize);
+
+		if(mNext)
+		{
+			item = mNext;
+			mNext = item->GetNext();
+			return(item);
+		}
+		mHash++;
+
+		for( ; mHash < TSize; mHash++)
+		{
+			item = mHashTable[mHash];
+			if(item)
+			{
+				mNext = item->GetNext();
+				return(item);
+			}
+		}
+		return(NULL);
+	}
+	// Destroy all entries in the hash table
+	void clear(void)
+	{
+		T *item = head();
+		while(item)
+		{
+			remove(item);
+			item = next();
+		}
+	}
+	// Override the [] operator
+	T *operator[](const char *key) { return(find(key)); }
+};
+
+// end
\ No newline at end of file
diff --git a/codemp/qcommon/cm_draw.cpp b/codemp/qcommon/cm_draw.cpp
new file mode 100644
index 0000000..80db6bd
--- /dev/null
+++ b/codemp/qcommon/cm_draw.cpp
@@ -0,0 +1,1490 @@
+///////////////////////////////////////////////////////////////////////////////
+// CDraw32 Class Implementation
+//
+// Basic drawing routines for 32-bit buffer
+///////////////////////////////////////////////////////////////////////////////
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+
+#include "cm_local.h"
+#include "cm_draw.h"
+
+
+///////////// statics for CDraw32 //////////////////////////////////
+// Used by all drawing routines as the "current" drawing context
+CPixel32* CDraw32::buffer = NULL; 	// pointer to 32-bit deep pixel buffer
+long	CDraw32::buf_width=0;		// width of buffer in pixels
+long	CDraw32::buf_height=0;		// height of buffer in pixels
+long	CDraw32::stride = 0;		// stride in pixels
+long	CDraw32::clip_min_x=0;		// clip bounds
+long	CDraw32::clip_min_y=0;		// clip bounds
+long	CDraw32::clip_max_x=0;		// clip bounds
+long	CDraw32::clip_max_y=0;		// clip bounds
+long*	CDraw32::row_off = NULL;	// Table for quick Y calculations
+
+CDraw32::CDraw32() 
+//USE:	constructor
+{
+}
+
+CDraw32::~CDraw32()
+//USE:	Destructor
+{
+}
+
+int	imgKernel[5][5] = 
+{
+	{-1,-1,-1,-1, 0},
+	{-1,-1,-1, 0, 1},
+	{-1,-1, 0, 1, 1},
+	{-1, 0, 1, 1, 1},
+	{ 0, 1, 1, 1, 1}
+};
+
+const int KWIDTH = 2;
+
+void CDraw32::Emboss(long dstX, long dstY, long width, long height, 
+					 CPixel32* clrImage, long clrX, long clrY, long clrStride)
+{
+	CPixel32 	*dst;
+	CPixel32 	*clr;
+	int			x,y,i,j;
+	int			dstNextLine;
+	int			clrNextLine;
+
+	assert(buffer != NULL);
+
+	BlitClip(dstX, dstY, width, height, clrX, clrY);
+
+	if (width < 1 || height < 1)
+		return;
+
+	dst = &buffer[PIXPOS(dstX,dstY,stride)];
+	clr = &clrImage[PIXPOS(clrX,clrY,clrStride)];
+
+	dstNextLine = (stride - width);
+	clrNextLine = (clrStride - width);
+
+	for (y = 0; y < height; y++)
+	{
+		for (x = 0; x < width; x++)
+		{
+			int accum = 0;
+			for (j = -KWIDTH; j<=KWIDTH; j++)
+				for (i = -KWIDTH; i<=KWIDTH; i++)
+				{
+					int xk = CLAMP(x + i, clrX, clrX+width-1);
+					int yk = CLAMP(y + j, clrY, clrY+height-1);
+					accum += clrImage[PIXPOS(xk,yk,clrStride)].a * imgKernel[j+KWIDTH][i+KWIDTH];
+				}
+			*dst = LIGHT_PIX(*clr, accum);
+			dst->a = 255;
+			++dst;
+			++clr;
+		}
+		dst += dstNextLine;
+		clr += clrNextLine;
+	}
+
+
+}
+
+bool CDraw32::SetBufferSize(long width,long height,long stride_len)
+//USE:	setup for a particular size drawing buffer
+//			(do not re-setup if buffer size has not changed)
+//IN:		width,height	- size of buffer
+//			stride_len		- distance to next line
+//OUT:	true if everything goes OK, otherwise false
+{
+	long		i;
+
+	assert(width!=0);
+	assert(height!=0);
+	assert(stride_len!=0);
+
+	if (buf_width != width || buf_height != height ||
+		  stride_len != stride)
+	{	// need to re-create row_off table
+		buf_width  = width;
+		buf_height = height;
+		stride = stride_len;
+
+		if (row_off)
+  			delete [] row_off;
+
+		// row offsets used for quick pixel address calcs
+		row_off = new long[height];
+
+		assert(row_off != NULL);
+		if (row_off == NULL)
+			return false;
+
+		// table for quick pixel lookups
+		for (i=0; i<height; i++)
+			row_off[i] = i * stride;
+	}
+	// set default clip bounds
+	SetClip(0, 0, width-1, height-1);
+
+	return true;
+}
+
+void CDraw32::ClearLines(CPixel32 color,long start,long end)
+//USE:	clear screen buffer to color provided for lines
+//IN:		color	 				- 32-bit color value
+//			start through end		- line numbers
+//OUT:	none
+{
+	CPixel32 	*dest;
+	int			line,i,next_line;
+
+	assert(buffer!=NULL);
+	assert(start>=0);
+	assert(end<buf_height);
+
+	dest = &buffer[row_off[start]];
+
+	next_line = stride - buf_width;
+	line = end - start + 1;
+
+	while (line-- != 0)
+	{	 // very simple-minded fill loop
+		i = buf_width;
+		while (i--)
+			*dest++ = color;
+		dest += next_line;
+	}
+}
+
+void CDraw32::SetAlphaLines(byte alpha,long start,long end)
+//USE:	set the alpha value only
+//IN:		alpha	 				- 8-bit alpha value
+//			start through end		- line numbers
+//OUT:	none
+{
+	CPixel32 	*dest;
+	int			line,i,next_line;
+
+	assert(buffer!=NULL);
+	assert(start>=0);
+	assert(end<buf_height);
+
+	dest = &buffer[row_off[start]];
+
+	next_line = stride - buf_width;
+	line = end - start + 1;
+
+	while (line-- != 0)
+	{	 // very simple-minded fill loop
+		i = buf_width;
+		while (i--)
+		{
+			dest->a = alpha;
+			++dest;
+		}
+		dest += next_line;
+	}
+}
+
+#define LEFT   1 // code bits
+#define RIGHT  2
+#define TOP    4
+#define BOTTOM 8
+
+static long code(long x,long y)
+//USE:	determines where a point is in relation to a bounding box
+//IN:		x,y		- coordinate pair
+//OUT:	clipping code compaired to global clip context
+{
+	long c;
+
+	c = 0;
+	if (x < CDraw32::clip_min_x) c |= LEFT;
+	if (x > CDraw32::clip_max_x) c |= RIGHT;
+	if (y < CDraw32::clip_min_y) c |= BOTTOM;
+	if (y > CDraw32::clip_max_y) c |= TOP;
+
+	return c;
+}
+
+bool CDraw32::ClipLine(long& x1, long& y1, long& x2, long& y2)
+//USE:	clip a line from (x1,y1) to (x2,y2) to clip bounds
+//IN:		(x1,y1)-(x2,y2) line
+//OUT:	return true if something left to draw, otherwise false
+{
+	long c1,c2,c,x,y,f;
+	x = x1;
+	y = y1;
+
+	c1 = code(x1,y1); // find where first pt. is
+	c2 = code(x2,y2); // find where second pt. is
+
+	if ((c1 & c2) == 0)
+  	{   // the line may be visible
+	  	while (c1 | c2)
+    	{   // where there is 2D clipping to be done
+	    	if (c1 & c2)
+			{
+				return false;  // if both on same side, quit
+			}
+
+			c = c1;
+    		if (c==0)
+			{
+				c = c2; // pick a point
+			}
+
+	    	if (c & TOP)
+		  	{
+      			f = ((clip_max_y-y1) << 15)/(y2-y1);
+		      	x = x1 + (((x2-x1)*f + 16384) >> 15);
+      			y = clip_max_y;
+	      	}
+			else if (c & BOTTOM)
+      		{
+	      		f = ((clip_min_y-y1) << 15)/(y2-y1);
+		  		x = x1 + (((x2-x1)*f + 16384) >> 15);
+      			y = clip_min_y;
+      		}
+	      	else if (c & LEFT)
+       		{
+	     		f = ((clip_min_x-x1) << 15)/(x2-x1);
+    	 		y = y1 + (((y2-y1)*f + 16384) >> 15);
+       			x = clip_min_x;
+       		}
+      		else if (c & RIGHT)
+   			{
+       			f = ((clip_max_x-x1) << 15)/(x2-x1);
+   	   			y = y1 + (((y2-y1)*f + 16384) >> 15);
+       			x = clip_max_x;
+   			}
+	    	if (c==c1)
+		  	{
+				x1=x; y1=y; c1=code(x1,y1);
+			}
+    		else
+	      	{
+				x2=x; y2=y; c2=code(x2,y2);
+			}
+    	} // while still needs clipping
+  	}
+	else
+	{	// line not visible
+  		return false;
+	}
+	return true;
+}
+
+void CDraw32::DrawLineNC(long x1, long y1, long x2, long y2, CPixel32 color)
+//USE:	draw a line from (x1,y1) to (x2,y2) in color (no clip)
+//IN:		(x1,y1)			- starting coordinate
+//			(x2,y2)			- ending coordinate
+//			color			- 32-bit color value
+//OUT:	none
+{
+	long		d, ax, ay, sx, sy, dx, dy;
+	CPixel32*	dest;
+
+	assert(buffer != NULL);
+
+	dx = x2-x1;
+	ax = ABS(dx) << 1;
+	sx = SIGN(dx);
+	dy = y2-y1;
+	ay = ABS(dy) << 1;
+	sy = SIGN(dy);
+
+	if (255 == color.a)
+	{
+		if (dy == 0)
+		{ // horz line
+			if (dx >= 0)
+			{
+				dest = &buffer[row_off[y1] + x1];
+				int i = dx+1;
+				while (i--)
+					*dest++ = color;
+			}
+			else
+			{
+				dest = &buffer[row_off[y1] + x1 + dx];
+				int i = -dx+1;
+				while (i--)
+					*dest++ = color;
+			}
+			return;
+		}
+
+		if (dx == 0)
+		{ // vert line
+			if (dy >= 0)
+			{
+				dest = &buffer[row_off[y1] + x1];
+				dy++;
+			}
+			else
+			{
+				dest = &buffer[row_off[y2] + x1];
+				dy = -dy + 1;
+			}
+
+			while (dy-- != 0)
+			{
+				*dest = color;
+				dest += stride;
+			}
+			return;
+		}
+	}
+
+	// bressenham's algorithm
+	if (ax > ay)
+	{
+		d = ay - (ax >> 1);
+		while(x1 != x2)
+   		{
+			PutPixAlphaNC(x1,y1,color);
+
+	    	if (d >= 0)
+    		{
+		   		y1 += sy;
+    			d  -= ax;
+    		}
+	    	x1 += sx;
+			d  += ay;
+   		}
+	}
+	else
+	{
+		d = ax - (ay >> 1);
+		while(y1 != y2)
+    	{
+			PutPixAlphaNC(x1,y1,color);
+			if (d >= 0)
+    		{
+    			x1 += sx;
+    			d  -= ay;
+    		}
+	    	y1 += sy;
+			d  += ax;
+    	}
+	}
+	PutPixAlphaNC(x1,y1,color);
+}
+
+void CDraw32::DrawLineAveNC(long x1, long y1, long x2, long y2, CPixel32 color)
+//USE:	draw a translucent line from (x1,y1) to (x2,y2) in color (no clip)
+//IN:		(x1,y1)			- starting coordinate
+//			(x2,y2)			- ending coordinate
+//			color 			- 32-bit color value
+//OUT:	none
+{
+	long		d, ax, ay, sx, sy, dx, dy;
+	CPixel32*	dest;
+
+	assert(buffer != NULL);
+
+	dx = x2-x1;
+	ax = ABS(dx) << 1;
+	sx = SIGN(dx);
+	dy = y2-y1;
+	ay = ABS(dy) << 1;
+	sy = SIGN(dy);
+
+	if (dy == 0)
+	{ // horz line
+		if (dx >= 0)
+		{
+			dest = &buffer[row_off[y1] + x1];
+			int i = dx+1;
+			while (i--)
+				*dest++ = AVE_PIX(*dest, color);
+		}
+		else
+		{
+			dest = &buffer[row_off[y1] + x1 + dx];
+			int i = -dx+1;
+			while (i--)
+				*dest++ = AVE_PIX(*dest, color);
+		}
+		return;
+	}
+
+	if (dx == 0)
+	{ // vert line
+		if (dy >= 0)
+		{
+			dest = &buffer[row_off[y1] + x1];
+			dy++;
+		}
+		else
+		{
+			dest = &buffer[row_off[y2] + x1];
+			dy = -dy + 1;
+		}
+
+		while (dy-- != 0)
+		{
+			*dest = AVE_PIX(*dest, color);
+			dest += stride;
+		}
+		return;
+	}
+
+	// bressenham's algorithm
+	if (ax > ay)
+	{
+		d = ay - (ax >> 1);
+		while(x1 != x2)
+   		{
+			PutPixAveNC(x1,y1,color);
+
+	    	if (d >= 0)
+    		{
+		   		y1 += sy;
+    			d  -= ax;
+    		}
+	    	x1 += sx;
+			d  += ay;
+   		}
+	}
+	else
+	{
+		d = ax - (ay >> 1);
+		while(y1 != y2)
+    	{
+			PutPixAveNC(x1,y1,color);
+			if (d >= 0)
+    		{
+    			x1 += sx;
+    			d  -= ay;
+    		}
+	    	y1 += sy;
+			d  += ax;
+    	}
+	}
+	PutPixAveNC(x1,y1,color);
+}
+
+void CDraw32::DrawLineAANC(long x0, long y0, long x1, long y1, CPixel32 color)
+// Wu antialiased line drawer.
+//USE:	Function to draw an antialiased line from (x0,y0) to (x1,y1), using an
+//			antialiasing approach published by Xiaolin Wu in the July 1991 issue of
+//			Computer Graphics (SIGGRAPH proceedings). 
+//
+//IN:		(x0,y0),(x1,y1) = line to draw
+//			color = 32-bit color
+//OUT:	none
+{
+	assert(buffer != NULL);
+
+	// Make sure the line runs top to bottom 
+	if (y0 > y1) 
+	{
+		SWAP(y0,y1);
+		SWAP(x0,x1);
+	}
+
+	long	DeltaX = x1 - x0;
+	long	DeltaY = y1 - y0;
+	long	XDir;
+
+	// Draw the initial pixel, which is always exactly intersected by
+ 	// the line and so needs no Alpha 
+	PutPixAlphaNC(x0, y0, color);
+
+	if (DeltaX >= 0) 
+	{
+ 		XDir = 1;
+	} 
+	else 
+	{
+ 		XDir = -1;
+ 		DeltaX = -DeltaX; // make DeltaX positive 
+	}
+
+	// Special-case horizontal, vertical, and diagonal lines, which
+ 	//	require no Alpha because they go right through the center of
+ 	//	every pixel 
+	if (DeltaY == 0) 
+	{	// Horizontal line 
+ 		while (DeltaX-- != 0) 
+		{
+ 			x0 += XDir;
+			PutPixAlphaNC(x0, y0, color);
+		}
+ 		return;
+	}
+	if (DeltaX == 0) 
+	{	// Vertical line 
+ 		do 
+		{
+ 			y0++;
+			PutPixAlphaNC(x0, y0, color);
+		} 
+		while (--DeltaY != 0);
+ 		return;
+	}
+	if (DeltaX == DeltaY) 
+	{	// Diagonal line 
+ 		do 
+		{
+ 			x0 += XDir;
+ 			y0++;
+			PutPixAlphaNC(x0, y0, color);
+ 		}
+		while (--DeltaY != 0);
+ 		return;
+	}
+
+	// Line is not horizontal, diagonal, or vertical 
+	unsigned short ErrorAcc = 0;  // initialize the line error accumulator to 0 
+
+	// # of bits by which to shift ErrorAcc to get intensity level 
+	const unsigned long	IntensityShift = 16 - 8;
+	
+	// Is this an X-major or Y-major line? 
+	if (DeltaY > DeltaX) 
+	{
+ 		// Y-major line; calculate 16-bit fixed-point fractional part of a
+ 		// pixel that X advances each time Y advances 1 pixel, truncating the
+ 		// result so that we won't overrun the endpoint along the X axis 
+ 		unsigned short	ErrorAdj = unsigned short 
+				(((unsigned long) DeltaX << 16) / (unsigned long) DeltaY);
+
+ 		// Draw all pixels other than the first and last 
+ 		while (--DeltaY) 
+		{
+ 			unsigned short	ErrorAccTemp = ErrorAcc;   // remember currrent accumulated error 
+ 			ErrorAcc += ErrorAdj;      // calculate error for next pixel 
+ 			if (ErrorAcc <= ErrorAccTemp) 
+			{	// The error accumulator turned over, so advance the X coord 
+ 				x0 += XDir;
+			}
+ 			y0++; // Y-major, so always advance Y 
+ 			// The IntensityBits most significant bits of ErrorAcc give us the
+ 			// intensity Alpha for this pixel, and the complement of the
+ 			// Alpha for the paired pixel 
+ 			unsigned long	Alpha = ErrorAcc >> IntensityShift;
+			unsigned long	InvAlpha = 256-Alpha;
+
+			PutPixAlphaNC(x0, y0, 
+				ALPHA_PIX(GetPix(x0, y0), color, Alpha, InvAlpha));
+			PutPixAlphaNC(x0+XDir, y0, 
+				ALPHA_PIX(GetPix(x0+XDir, y0), color, InvAlpha, Alpha));
+ 		}
+ 		// Draw the final pixel, which is always exactly intersected by the line
+ 		// and so needs no Alpha 
+		PutPixAlphaNC(x1, y1, color);
+ 		return;
+	}
+	// It's an X-major line; calculate 16-bit fixed-point fractional part of a
+ 	// pixel that Y advances each time X advances 1 pixel, truncating the
+ 	// result to avoid overrunning the endpoint along the X axis 
+	unsigned short	ErrorAdj = unsigned short 
+		(((unsigned long) DeltaY << 16) / (unsigned long) DeltaX);
+	// Draw all pixels other than the first and last 
+	while (--DeltaX) 
+	{
+ 		unsigned short	ErrorAccTemp = ErrorAcc;   // remember currrent accumulated error 
+ 		ErrorAcc += ErrorAdj;      // calculate error for next pixel 
+ 		if (ErrorAcc <= ErrorAccTemp) 
+		{	// The error accumulator turned over, so advance the Y coord 
+ 			y0++;
+		}
+ 		x0 += XDir; // X-major, so always advance X 
+ 		// The IntensityBits most significant bits of ErrorAcc give us the
+ 		// intensity Alpha for this pixel, and the complement of the
+ 		// Alpha for the paired pixel 
+ 		unsigned long	Alpha = ErrorAcc >> IntensityShift;
+		unsigned long	InvAlpha = 256-Alpha;
+		PutPixAlphaNC(x0, y0, 
+			ALPHA_PIX(GetPix(x0, y0), color, Alpha, InvAlpha));
+		PutPixAlphaNC(x0, y0+1, 
+			ALPHA_PIX(GetPix(x0, y0+1), color, InvAlpha, Alpha));
+	}
+	// Draw the final pixel, which is always exactly intersected by the line
+ 	// and so needs no Alpha 
+	PutPixAlphaNC(x1, y1, color);
+}
+
+void CDraw32::DrawRectNC(long ulx, long uly, long width, long height, CPixel32 color)
+//USE:	draw rectangle in solid color, no clipping
+//IN:		(ulx,uly)			- coordinates of upper-left corner of rect
+//			width, height		- dimensions of rectangle
+//			color				- color value
+//OUT:	none
+{
+
+	assert(buffer != NULL);
+	assert(ulx>=0);
+	assert(uly>=0);
+	assert(ulx+width<buf_width);
+	assert(uly+height<buf_height);
+
+	if (height < 1 || width < 1)
+		return;
+
+	while (height-- != 0)
+	{
+		DrawLineNC(ulx, uly, ulx+width-1, uly, color);
+		uly++;
+	}
+}
+
+void CDraw32::DrawRect(long ulx, long uly, long width, long height, CPixel32 color)
+//USE:	draw rectangle in solid color
+//IN:		(ulx,uly)			- coordinates of upper-left corner of rect
+//			width, height		- dimensions of rectangle
+//			color				- color value
+//OUT:	none
+{
+	assert(buffer != NULL);
+
+	if (height < 1 || width < 1)
+		return;
+
+	while (height-- != 0)
+	{
+		DrawLine(ulx, uly, ulx+width-1, uly, color);
+		uly++;
+	}
+}
+
+void CDraw32::DrawRectAve(long ulx, long uly, long width, long height, CPixel32 color)
+//USE:	draw rectangle in solid color, translucent
+//IN:		(ulx,uly)			- coordinates of upper-left corner of rect
+//			width, height		- dimensions of rectangle
+//			color				- color value
+//OUT:	none
+{
+	assert(buffer != NULL);
+
+	if (height < 1 || width < 1)
+		return;
+
+	while (height-- != 0)
+	{
+		DrawLineAve(ulx, uly, ulx+width-1, uly, color);
+		uly++;
+	}
+}
+
+void CDraw32::DrawBoxNC(long ulx, long uly, long width, long height, CPixel32 color)
+//USE:	Draw an empty box, no clipping
+//IN:		(ulx,uly)		- coordinates of upper-left corner of box
+//			width, height	- dimensions of box
+//			color			- color value
+//OUT:	none
+{
+	assert(buffer != NULL);
+
+	if (height < 1 || width < 1)
+		return;
+
+	DrawLineNC(ulx, uly, ulx+width-1, uly, color);
+	DrawLineNC(ulx, uly+height-1, ulx+width-1, uly+height-1, color);
+	DrawLineNC(ulx, uly, ulx, uly+height-1, color);
+	DrawLineNC(ulx+width-1, uly, ulx+width-1, uly+height-1, color);
+}
+
+void CDraw32::DrawBox(long ulx, long uly, long width, long height, CPixel32 color)
+//USE:	Draw an empty box
+//IN:		(ulx,uly)		- coordinates of upper-left corner of rect
+//			width, height	- dimensions of rectangle
+//			color			- color value
+//OUT:	none
+{
+	assert(buffer != NULL);
+
+	if (height < 1 || width < 1)
+		return;
+
+	DrawLine(ulx, uly, ulx+width-1, uly, color);
+	DrawLine(ulx, uly+height-1, ulx+width-1, uly+height-1, color);
+	DrawLine(ulx, uly, ulx, uly+height-1, color);
+	DrawLine(ulx+width-1, uly, ulx+width-1, uly+height-1, color);
+}
+
+void CDraw32::DrawBoxAve(long ulx, long uly, long width, long height, CPixel32 color)
+//USE: Draw an empty box, translucent
+//IN:		(ulx,uly)		- coordinates of upper-left corner of rect
+//			width, height	- dimensions of rectangle
+//			color			- color value
+//OUT:	none
+{
+	assert(buffer!=NULL);
+
+	if (height < 1 || width < 1)
+		return;
+
+	DrawLineAve(ulx, uly, ulx+width-1, uly, color);
+	DrawLineAve(ulx, uly+height-1, ulx+width-1, uly+height-1, color);
+	DrawLineAve(ulx, uly, ulx, uly+height-1, color);
+	DrawLineAve(ulx+width-1, uly, ulx+width-1, uly+height-1, color);
+}
+
+void CDraw32::DrawCircle(long xc, long yc, long r, CPixel32 edge, CPixel32 fill)
+//USE:	Draw a simple circle in current color with Bresenham's
+//		circle algorithm.
+// See PROCEDURAL ELEMENTS FOR COMPUTER GRAPHICS
+// David F. Rogers Pg. 48.
+//
+//IN:   xc,yc - center
+//      r     - radius
+//      edge  - edge color 
+//      fill  - fill color 
+//
+//OUT: NONE (a circle drawn in the off-screen buffer)
+{
+	long		x,y;
+	long		limit,di,delta;
+	long		last_x,last_y;
+
+	assert(buffer != NULL);
+
+	if (r < 1)
+		return;
+
+	// draw fill
+	if (fill.a != 0)
+	{
+		x = 0; last_x = x;
+		y = r; last_y = y;
+		di = 2*(1-r);
+		limit = 0;
+
+		do
+    	{
+	    	if (y >= limit)
+    		{
+				if (di < 0)
+       			{
+	     			delta = 2*di + 2*y - 1;
+		 			if (delta <= 0)
+       				{ 	// move horizontal
+     					last_x = x;
+     					x++;
+	     				di += (2*x + 1);
+		   			}
+     			else
+       				{ 	// move diagonal
+     					last_x = x;
+     					x++;
+	     				y--;
+		 				di += (2*x - 2*y + 2);
+       				}
+       			}
+    			else
+				{
+        			if (di > 0)
+        			{
+	        			delta = 2*di - 2*x -1;
+		    			if (delta <= 0)
+         				{ 	// move diagonal
+							last_x = x;
+	       					x++;
+    	   					y--;
+         					di += (2*x - 2*y + 2);
+         				}
+	        			else
+		      			{ 	// move vertical
+				  			y--;
+          					di += (1 - 2*y);
+	          			}
+	    			}
+		    		else /* di = 0 */
+        			{  // move diagonal
+			    		last_x = x;
+	    	    		x++;
+		    			y--;
+						di += (2*x - 2*y + 2);
+        			}
+				}
+    		}
+
+	    	if (y != last_y)
+    		{ // circle fill
+		    	DrawLine(xc-last_x,yc+last_y,xc+last_x,yc+last_y,fill);
+				if (last_y > limit)
+				{
+      				DrawLine(xc-last_x,yc-last_y,xc+last_x,yc-last_y,fill);
+				}
+	    		last_y = y;
+    		}
+    	}  while (y >= limit);
+	}
+
+	// draw edge
+	if (edge.a != 0)
+	{
+		x = 0;
+		y = r;
+		limit = 0;
+		di = 2*(1-r);
+
+		do
+   		{
+	    	// circle edge
+			PutPix(xc+x, yc+y, edge);
+    		PutPix(xc-x, yc+y, edge);
+	    	if (y > limit)
+    		{
+		   		PutPix(xc+x, yc-y, edge);
+    			PutPix(xc-x, yc-y, edge);
+    		}
+
+	    	if (y >= limit)
+    		{
+    			if (di < 0)
+     			{
+	     			delta = 2*di + 2*y - 1;
+		 			if (delta <= 0)
+       				{ 	// move horizontal
+     					x++;
+     					di += (2*x + 1);
+	       			}
+		 			else
+       				{ 	// move diagonal
+     					x++;
+	     				y--;
+		       			di += (2*x - 2*y + 2);
+       				}
+       			}
+	    		else
+				{
+		      		if (di > 0)
+       				{
+      					delta = 2*di - 2*x -1;
+		      			if (delta <= 0)
+			 			{ // move diagonal
+       						x++;
+       						y--;
+		       				di += (2*x - 2*y + 2);
+			 			}
+      					else
+	        			{ // move vertical
+			   				y--;
+       						di += (1 - 2*y);
+         				}
+	       			}
+			  		else /* di = 0 */
+	       			{  	// move diagonal
+			  			x++;
+      					y--;
+		      			di += (2*x - 2*y + 2);
+	     			}
+				}
+    		}
+    	}  while (y >= limit);
+	}
+} // DrawCircle
+
+void CDraw32::DrawCircleAve(long xc, long yc, long r, CPixel32 edge, CPixel32 fill)
+//USE:	Draw a simple circle in current color with Bresenham's
+//			circle algorithm.
+//			a circle with fill and edge colors averaged with dest (-1 = no color)
+// See PROCEDURAL ELEMENTS FOR COMPUTER GRAPHICS
+// David F. Rogers Pg. 48.
+//
+//IN:   xc,yc - center
+//      r     - radius
+//      edge  - edge color 
+//      fill  - fill color 
+//
+//OUT:	none (a circle on in the off-screen buffer)
+{
+	long		x,y;
+	long		limit,di,delta;
+	long		last_x,last_y;
+	long		f;
+
+	assert(buffer != NULL);
+
+	if (r < 1)
+		return;
+
+	// draw fill
+	if (fill.a != 0)
+	{
+		x = 0; last_x = x;
+		y = r; last_y = y;
+		di = 2*(1-r);
+		limit = 0;
+
+		do
+    	{
+	    	if (y >= limit)
+    		{
+				if (di < 0)
+       			{
+     				delta = 2*di + 2*y - 1;
+	     			if (delta <= 0)
+		   			{ 	// move horizontal
+     					last_x = x;
+     					x++;
+     					di += (2*x + 1);
+	       			}
+		 			else
+       				{ 	// move diagonal
+	     				last_x = x;
+		 				x++;
+     					y--;
+     					di += (2*x - 2*y + 2);
+       				}
+	       		}
+				else
+				{
+					if (di > 0)
+	        		{
+			    		delta = 2*di - 2*x -1;
+		        		if (delta <= 0)
+			 			{ 	// move diagonal
+		        			last_x = x;
+				   			x++;
+		    	   			y--;
+				 			di += (2*x - 2*y + 2);
+         				}
+		        		else
+			      		{ 	// move vertical
+			          		y--;
+			          		di += (1 - 2*y);
+          				}
+	        		}
+			    	else /* di = 0 */
+	        		{  // move diagonal
+			        	last_x = x;
+		    	    	x++;
+						y--;
+		        		di += (2*x - 2*y + 2);
+					}
+				}
+    		}
+
+	    	if (y != last_y)
+    		{ // circle fill
+				for (f=xc-last_x; f<=xc+last_x; f++)
+					PutPixAve(f, yc+last_y, fill);
+	    		if (last_y > limit)
+				{
+					for (f=xc-last_x; f<=xc+last_x; f++)
+						PutPixAve(f, yc-last_y, fill);
+				}
+	    		last_y = y;
+    		}
+    	}  while (y >= limit);
+	}
+
+	// draw edge
+	if (edge.a != 0)
+	{
+		x = 0;
+		y = r;
+		limit = 0;
+		di = 2*(1-r);
+
+		do
+   		{
+	    	// circle edge
+			PutPixAve(xc+x, yc+y, edge);
+	    	PutPixAve(xc-x, yc+y, edge);
+			if (y > limit)
+    		{
+	   			PutPixAve(xc+x, yc-y, edge);
+	    		PutPixAve(xc-x, yc-y, edge);
+    		}
+			if (y >= limit)
+    		{
+    			if (di < 0)
+     			{
+     				delta = 2*di + 2*y - 1;
+	     			if (delta <= 0)
+	       			{ 	// move horizontal
+		 				x++;
+     					di += (2*x + 1);
+       				}
+     				else
+	       			{ 	// move diagonal
+		 				x++;
+			 			y--;
+	       				di += (2*x - 2*y + 2);
+		   			}
+       			}
+    			else
+				{
+		      		if (di > 0)
+		   			{
+	      				delta = 2*di - 2*x -1;
+			  			if (delta <= 0)
+	         			{ // move diagonal
+			   				x++;
+       						y--;
+		       				di += (2*x - 2*y + 2);
+			 			}
+      					else
+	        			{ // move vertical
+			   				y--;
+       						di += (1 - 2*y);
+	         			}
+		   			}
+		      		else /* di = 0 */
+       				{  	// move diagonal
+		      			x++;
+      					y--;
+		      			di += (2*x - 2*y + 2);
+	     			}
+				}
+    		}
+    	}  while (y >= limit);
+	}
+} // DrawCircleAve
+
+////////////////////////////////////////////////////////////////////////////
+//Concave Polygon Scan Conversion
+////////////////////////////////////////////////////////////////////////////
+
+// concave: scan convert nvert-sided concave non-simple polygon
+// with vertices at (point[i].x, point[i].y) for i in
+// [0..nvert-1] within the window win by
+// calling spanproc for each visible span of pixels.
+//
+// Polygon can be clockwise or counterclockwise.
+//
+// Algorithm does uniform point sampling at pixel centers.
+// Inside-outside test done by even-odd rule: a point is
+// considered inside if an emanating ray intersects the polygon
+// an odd number of times.
+//
+// spanproc should fill in pixels from xl to xr inclusive on scanline y,
+//
+// e.g:
+//	spanproc(short y, short xl, short xr)
+//	{
+//	    short x;
+//	    for (x=xl; x<=xr; x++)
+//			pixel_write(x, y, pixelvalue);
+//	}
+
+typedef struct
+{	   	        // a polygon edge
+             	// these are fixed point long ints for some accuracy & speed
+	long   x;		// x coordinate of edge's intersection with current scanline
+	long   dx;	// change in x with respect to y
+	long   i;		// edge number: edge i goes from pt[i] to
+       				// pt[i+1]
+} POLYEDGE;
+
+#define INT_SHIFT 13
+
+// global for speed
+static long   	 n;				// number of vertices
+static POINT  	*pt;		  	// vertices
+
+static long	    nact;	  		// number of active edges
+static POLYEDGE active[256];	// active edge list:edges crossing scanline y
+static long     ind[256];		// list of vertex indices, sorted by
+	    		                // pt[ind[j]].y
+
+static void del_edge(long i)
+// remove edge i from active list
+{
+	int  j;
+
+	for (j = 0; j < nact && active[j].i != i; j++)
+		;
+
+	// edge not in active list; happens at cliprect->top
+	if (j >= nact)
+	{
+		return;
+	}
+
+	nact--;
+	memcpy(&active[j], &active[j + 1], (nact - j) * sizeof(active[0]));
+}
+
+static void ins_edge(long i, long y)
+// append edge i to end of active list
+{
+	int 		j;
+	long    dx;
+	POINT   *p;
+	POINT   *q;
+
+	j = i < n - 1 ? i + 1 : 0;
+	if (pt[i].y < pt[j].y)
+	{
+		p = &pt[i];
+		q = &pt[j];
+	}
+	else
+	{
+		p = &pt[j];
+		q = &pt[i];
+	}
+
+	// initialize x position at intersection of edge with scanline y
+	if ((q->y - p->y) != 0)
+	{
+		dx =  (((long)q->x - (long)p->x) * (long)(1<<INT_SHIFT));
+		dx /= (((long)q->y - (long)p->y));
+	}
+	else
+	{
+		// horizontal line
+		dx = 0;
+	}
+
+	active[nact].dx = dx;
+	active[nact].x = (dx * (long)(y - p->y)) + ((long)p->x << INT_SHIFT);
+	active[nact].i = i;
+	nact++;
+}
+
+// comparison routines for shellsort
+int compare_ind(long *u, long *v)
+{
+	return (pt[*u].y <= pt[*v].y ? -1 : 1);
+}
+
+int compare_active(POLYEDGE *u, POLYEDGE *v)
+{
+	return (u->x <= v->x ? -1 : 1);
+}
+
+void shell_sort(void *vec, long n, long siz,
+                int (*compare)(void*,void*))
+// USE:  shell sort aka heap sort. Best sort algorithm for almost sorted list.
+{
+	byte *a;
+	byte v[128]; // temp object
+	long 		i,j,h;
+
+	a = (byte *)vec;
+
+	// choose size of "heap"
+	for (h = 1; h <= n/9; h = 3*h+1)
+		;
+
+	// divide and conq.
+	for ( ; h > 0; h /= 3)
+	{
+		for (i = h; i < n; i++)
+   		{
+	    	// v = a[i];
+			memcpy(v,(a+i*siz),siz);
+	    	j = i;
+			// j >= h && a[j-h] > v
+    		while ((j >= h) && compare((void*)(a+(j-h)*siz),(void*)v) > 0)
+    		{
+	    		// a[j] = a[j-h]
+				memcpy((a+j*siz),(a+(j-h)*siz),siz);
+    			j -= h;
+    		}
+	    	// a[j] = v;
+			memcpy((a+j*siz),v,siz);
+   		}
+	}
+}
+
+void CDraw32::DrawPolygon(long nvert, POINT *point, CPixel32 edge, CPixel32 fill)
+//USE:    Scan convert a polygon
+//IN:     nvert:        Number of vertices
+//        point:        Vertices of polygon
+//        edge:         edge color
+//        fill:         fill color
+//OUT:		none
+{
+	long	k,
+	        y0,
+	        y1,
+	        y,
+	        i,
+	        j,
+	        xl,
+	        xr;
+
+	assert(buffer != NULL);
+
+	n = nvert;
+
+	if (n <= 0)
+	{	// nothing to do
+		return;
+	}
+
+	pt = point;
+
+	if (fill.a != 0)
+	{ // draw fill
+
+		// create y-sorted array of indices ind[k] into vertex list
+		for (k = 0; k < n; k++)
+		{
+			ind[k] = k;
+		}
+
+		// sort ind by pt[ind[k]].y
+		shell_sort(ind, n, sizeof(long), (int (*)(void*,void*)) compare_ind);
+
+		nact = 0;					   // start with empty active list
+		k = 0;						   // ind[k] is next vertex to process
+
+		// ymin of polygon
+		y0 = MAX(clip_min_y-1, pt[ind[0]].y);
+
+		// ymax of polygon
+		y1 = MIN(clip_max_y+1, pt[ind[n-1]].y);
+
+		// step through scanlines
+		for (y = y0; y < y1; y++)
+    	{
+			// Check vertices between previous scanline
+			// and current one, if any
+			for (; (k < n) && (pt[ind[k]].y <= y); k++)
+    		{
+				i = ind[k];
+				//  insert or delete edges before and after vertex i
+	    		//  (i-1 to i, and i to i+1)
+				//  from active list if they cross scanline y
+				j = i > 0 ? i - 1 : n - 1;	// vertex previous to i
+				if (pt[j].y < y)
+				{
+					// old edge, remove from active list
+					del_edge(j);
+				}
+				else
+				{
+					if (pt[j].y > y)
+					{
+						// new edge, add to active list
+						ins_edge(j, y);
+					}
+		 		}
+				j = i < n - 1 ? i + 1 : 0;	// vertex next after i
+				if (pt[j].y < y)
+				{
+					// old edge, remove from active list
+					del_edge(i);
+				}
+				else
+				{
+					if (pt[j].y > y)
+					{
+						// new edge, add to active list
+						ins_edge(i, y);
+					}
+				}
+   			}
+
+			// sort active edge list by active[j].x
+			shell_sort(active, nact, sizeof(POLYEDGE), (int (*)(void*,void*))compare_active);
+
+			// draw horizontal segments for scanline y
+			for (j = 0; j < nact; j += 2)
+    		{	// draw horizontal segments
+				// span 'tween j & j+1 is inside, span tween
+				// j+1 & j+2 is outside
+
+				// left end of span
+	    		// convert back from fixed point - round down
+				xl = (long) (active[j].x >> INT_SHIFT);
+  				if (xl < clip_min_x-1)
+				{
+  					xl = clip_min_x-1;
+			 	}
+
+	    		// right end of span
+				// convert back from fixed point - round down
+				xr = (long) (active[j + 1].x >> INT_SHIFT);
+  				if (xr > clip_max_x)
+				{
+  					xr = clip_max_x;
+				}
+
+				if (xl < xr)
+	        	{
+  					// draw pixels in span
+		        	DrawLine(xl+1,y,xr,y,fill);
+	        	}
+
+				// increment edge coords
+				active[j].x += active[j].dx;
+				active[j + 1].x += active[j + 1].dx;
+				}
+  			}
+
+			// sort active edge list by active[j].x
+			shell_sort(active, nact, sizeof(POLYEDGE), (int (*)(void*,void*))compare_active);
+
+			// draw horizontal segments for scanline y
+			for (j = 0; j < nact; j += 2)
+    		{	// draw horizontal segments
+				// span 'tween j & j+1 is inside, span tween
+				// j+1 & j+2 is outside
+
+				// left end of span
+    			// convert back from fixed point - round down
+		    	xl = (long) (active[j].x >> INT_SHIFT);
+		  		if (xl < clip_min_x-1)
+				{
+  					xl = clip_min_x-1;
+				}
+
+		    	// right end of span
+		    	// convert back from fixed point - round up
+				xr = (long) (active[j + 1].x >> INT_SHIFT);
+		  		if (xr > clip_max_x)
+				{
+  					xr = clip_max_x;
+				}
+
+				if (xl < xr)
+				{
+  					// draw pixels in span
+		    		DrawLine(xl+1,y,xr,y,fill);
+    			}
+
+				// increment edge coords
+				active[j].x += active[j].dx;
+				active[j + 1].x += active[j + 1].dx;
+			}
+		}
+
+		if (edge.a != 0)
+		{ // draw edges
+			for (k = 0; k < n-1; k++)
+			{
+    			DrawLineAA(pt[k].x,pt[k].y,pt[k+1].x,pt[k+1].y,edge);
+			}
+
+			DrawLineAA(pt[n-1].x,pt[n-1].y,pt[0].x,pt[0].y,edge);
+		}
+
+	return;
+}
+
+void CDraw32::Blit(long dstX, long dstY, long width, long height, 
+				   CPixel32* srcImage, long srcX, long srcY, long srcStride)
+//USE:	simple blit
+//IN:	dstX, dstY				- upper left corner of where image will land in buffer
+//		width, height			- width and height of image
+//		srcImage				- src image buffer
+//		srcX, srcY				- upper left corner in src image
+//		srcStride				- number of pixels per line in src image
+//OUT:	none
+{
+	CPixel32 	*dst;
+	CPixel32 	*src;
+	int			x,y;
+
+	assert(buffer != NULL);
+
+	BlitClip(dstX, dstY, width, height, srcX, srcY);
+
+	if (width < 1 || height < 1)
+		return;
+
+	dst = &buffer[PIXPOS(dstX,dstY,stride)];
+	src = &srcImage[PIXPOS(srcX,srcY,srcStride)];
+
+	for (y = 0; y < height; y++)
+	{
+		for (x = 0; x < width; x++)
+		{
+//			*dst++ = *src++;
+			byte alpha = src->a;
+			byte dst_alpha = dst->a;
+			*dst = ALPHA_PIX(*src, *dst, alpha, 256-alpha);
+			dst->a = dst_alpha;
+			++dst;
+			++src;
+		}
+		dst += (stride - width);
+		src += (srcStride - width);
+	}
+}
+
+void CDraw32::BlitClip(long& dstX, long& dstY, 
+					   long& width, long& height, 
+					   long& srcX, long& srcY)
+//USE:	simple blit clip
+//IN:	dstX, dstY				- upper left corner of where image will land in buffer
+//		width, height			- width and height of image
+//		srcX, srcY				- upper left corner in src image
+//OUT:	none
+{
+
+	// clip to our buffer size
+	if (dstX < clip_min_x)
+	{
+		int dif = (clip_min_x - dstX);
+		dstX += dif;
+		srcX += dif;
+		width -= dif;
+	}
+
+	if (dstY < clip_min_y)
+	{
+		int dif = (clip_min_y - dstY);
+		dstY += dif;
+		srcY += dif;
+		height -= dif;
+	}
+
+	if (dstX+width-1 > clip_max_x)
+	{
+		width -= (dstX+width-1 - clip_max_x);
+	}
+
+	if (dstY+height-1 > clip_max_y)
+	{
+		height -= (dstY+height-1 - clip_max_y);
+	}
+}
+
+void CDraw32::BlitColor(long dstX, long dstY, long width, long height, 
+					    CPixel32* srcImage, long srcX, long srcY, long srcStride, CPixel32 color)
+//USE:	blit using image alpha as mask
+//IN:	dstX, dstY				- upper left corner of where image will land in buffer
+//		width, height			- width and height of image
+//		srcImage				- src image buffer
+//		srcX, srcY				- upper left corner in src image
+//		srcStride				- number of pixels per line in src image
+//		color					- color to apply to srcImage
+//OUT:	none
+{
+	CPixel32 	*dst;
+	CPixel32 	*src;
+	int			x,y;
+	int			dstNextLine;
+	int			srcNextLine;
+
+	assert(buffer != NULL);
+
+	BlitClip(dstX, dstY, width, height, srcX, srcY);
+
+	if (width < 1 || height < 1)
+		return;
+
+	dst = &buffer[PIXPOS(dstX,dstY,stride)];
+	src = &srcImage[PIXPOS(srcX,srcY,srcStride)];
+
+	dstNextLine = (stride - width);
+	srcNextLine = (srcStride - width);
+
+	for (y = 0; y < height; y++)
+	{
+		for (x = 0; x < width; x++)
+		{
+			byte alpha = src->a;
+			*dst = ALPHA_PIX(color, *dst, alpha, 256-alpha);
+			++dst;
+			++src;
+		}
+		dst += dstNextLine;
+		src += srcNextLine;
+	}
+}
+
diff --git a/codemp/qcommon/cm_draw.h b/codemp/qcommon/cm_draw.h
new file mode 100644
index 0000000..a093ef1
--- /dev/null
+++ b/codemp/qcommon/cm_draw.h
@@ -0,0 +1,250 @@
+///////////////////////////////////////////////////////////////////////////////
+// CDraw32 Class Interface
+//
+// Basic drawing routines for 32-bit per pixel buffer
+///////////////////////////////////////////////////////////////////////////////
+
+#if !defined(CM_DRAW_H_INC)
+#define CM_DRAW_H_INC
+
+#ifndef __linux__
+//#include <windows.h>
+#include "../qcommon/platform.h"
+#endif
+
+// calc offset into image array for a pixel at (x,y)
+#define PIXPOS(x,y,stride) (((y)*(stride))+(x))
+
+#ifndef MIN
+// handy macros
+#define MIN(a,b) ((a) < (b) ? (a) : (b))
+#define MAX(a,b) ((a) > (b) ? (a) : (b))
+#define ABS(x) ((x)<0 ? -(x):(x))
+#define SIGN(x)  (((x) < 0) ? -1 : (((x) > 0) ? 1 : 0))
+#endif
+
+#ifndef CLAMP
+#define SWAP(a,b) { a^=b; b^=a; a^=b; }
+#define SQR(a)  ((a)*(a))
+#define CLAMP(v,l,h)    ((v)<(l) ? (l) : (v) > (h) ? (h) : (v))
+#define LERP(t, a, b) (((b)-(a))*(t) + (a))
+
+// round a to nearest integer towards 0
+#define FLOOR(a)        ((a)>0 ? (int)(a) : -(int)(-a))
+
+// round a to nearest integer away from 0
+#define CEILING(a) \
+((a)==(int)(a) ? (a) : (a)>0 ? 1+(int)(a) : -(1+(int)(-a)))
+
+#include <stdlib.h>
+#endif
+
+class CPixel32
+{
+public:
+	byte r;
+	byte g;
+	byte b;
+	byte a;
+
+	CPixel32(byte R = 0, byte G = 0, byte B = 0, byte A = 255) : r(R), g(G), b(B), a(A) {}
+	CPixel32(long l) {r = (l >> 24) & 0xff; g = (l >> 16) & 0xff; b = (l >> 8) & 0xff; a = l & 0xff;};
+
+	~CPixel32()
+	{}
+};
+
+#define PIX32_SIZE sizeof(CPixel32)
+
+// standard image operator macros
+#define IMAGE_SIZE(width,height) ((width)*(height)*(PIX32_SIZE))
+
+
+inline CPixel32 AVE_PIX (CPixel32 x, CPixel32 y) 
+	{ CPixel32 t; t.r = (byte)(((int)x.r + (int)y.r)>>1); 
+				  t.g = (byte)(((int)x.g + (int)y.g)>>1); 
+				  t.b = (byte)(((int)x.b + (int)y.b)>>1); 
+				  t.a = (byte)(((int)x.a + (int)y.a)>>1); return t;}
+
+inline CPixel32 ALPHA_PIX (CPixel32 x, CPixel32 y, long alpha, long inv_alpha) 
+	{ CPixel32 t; t.r = (byte)((x.r*alpha + y.r*inv_alpha)>>8); 
+				  t.g = (byte)((x.g*alpha + y.g*inv_alpha)>>8); 
+				  t.b = (byte)((x.b*alpha + y.b*inv_alpha)>>8); 
+//				  t.a = (byte)((x.a*alpha + y.a*inv_alpha)>>8);  return t;}
+				  t.a = y.a;  return t;}
+
+inline CPixel32 LIGHT_PIX (CPixel32 p, long light) 
+{ CPixel32 t; 
+  t.r = (byte)CLAMP(((p.r * light)>>10) + p.r, 0, 255); 
+  t.g = (byte)CLAMP(((p.g * light)>>10) + p.g, 0, 255); 
+  t.b = (byte)CLAMP(((p.b * light)>>10) + p.b, 0, 255); 
+  t.a = p.a;  return t;}
+
+// Colors are 32-bit RGBA
+
+// draw class
+class CDraw32
+{
+public: // static drawing context - static so we set only ONCE for many draw calls
+	static	CPixel32*	buffer;	   			// pointer to pixel buffer (one active)
+	static	long	buf_width;				// size of buffer
+	static	long	buf_height;				// size of buffer
+	static	long	stride;					// stride of buffer in pixels
+	static	long	clip_min_x;				// clip bounds
+	static	long	clip_min_y;				// clip bounds
+	static	long	clip_max_x;				// clip bounds
+	static	long	clip_max_y;				// clip bounds
+	static	long*	row_off;				// Table for quick Y calculations
+
+private:
+	void BlitClip(long& dstX, long& dstY, 
+		 		  long& width, long& height, 
+				  long& srcX, long& srcY);
+
+protected:
+public:
+	CDraw32();						// constructor
+	~CDraw32();						// destructor
+
+	// set the rect to clip drawing functions to
+	static void	SetClip(long min_x, long min_y,long max_x, long max_y)
+						{clip_min_x = MAX(min_x,0); clip_max_x = MIN(max_x,buf_width-1);
+						 clip_min_y = MAX(min_y,0); clip_max_y = MIN(max_y,buf_height-1);}
+
+	static void GetClip(long& min_x, long& min_y,long& max_x, long& max_y)
+						{min_x = clip_min_x; min_y = clip_min_y;
+						 max_x = clip_max_x; max_y = clip_max_y; }
+
+	// set the buffer to use for drawing off-screen
+	static void	SetBuffer(CPixel32* buf) {buffer = buf;};
+
+	// set the dimensions of the off-screen buffer
+	static bool	SetBufferSize(long width,long height,long stride_len);
+
+	// call this to free the table for quick y calcs before the program ends
+	static void CleanUp(void) 
+		{if (row_off) delete [] row_off; row_off=NULL; buf_width=0; buf_height=0;}
+
+	// set a pixel at (x,y) to color (no clipping)
+	void				PutPixNC(long x, long y, CPixel32 color)
+		{buffer[row_off[y] + x] = color;}
+
+	// set a pixel at (x,y) to color
+	void				PutPix(long x, long y, CPixel32 color)
+		{	// clipping check
+			if (x < clip_min_x || x > clip_max_x ||
+			    y < clip_min_y || y > clip_max_y)
+	  			return;
+			PutPixNC(x,y,color);
+		}
+
+	// get the color of a pixel at (x,y)
+	CPixel32			GetPix(long x, long y)
+		{return buffer[row_off[y] + x];}
+
+	// set a pixel at (x,y) with 50% translucency (no clip)
+	void				PutPixAveNC(long x, long y, CPixel32 color)
+		{	PutPixNC(x,y,AVE_PIX(GetPix(x, y), color)); }
+
+	// set a pixel at (x,y) with 50% translucency
+	void				PutPixAve(long x, long y, CPixel32 color)
+		{	// clipping check
+			if (x < clip_min_x || x > clip_max_x ||
+				y < clip_min_y || y > clip_max_y)
+		  		return;
+			PutPixNC(x,y,AVE_PIX(GetPix(x, y), color));
+		}
+
+	// set a pixel at (x,y) with translucency level (no clip)
+	void				PutPixAlphaNC(long x, long y, CPixel32 color)
+		{	PutPixNC(x,y,ALPHA_PIX(color, GetPix(x, y), color.a, 256-color.a));}
+
+	// set a pixel at (x,y) with translucency level
+	void				PutPixAlpha(long x, long y, CPixel32 color)
+		{	// clipping check
+		if (x < clip_min_x || x > clip_max_x ||
+		    y < clip_min_y || y > clip_max_y)
+  		return;
+		PutPixNC(x,y,ALPHA_PIX(color, GetPix(x, y), color.a, 256-color.a));}
+
+	// clear screen buffer to color from start to end line
+	void				ClearLines(CPixel32 color,long start,long end);
+
+	// clear screen buffer to color provided
+	void				ClearBuffer(CPixel32 color)
+		{ClearLines(color,0,buf_height-1);};
+
+	// fill buffer alpha from start to end line
+	void				SetAlphaLines(byte alpha,long start,long end);
+
+	// clear screen buffer to color provided
+	void				SetAlphaBuffer(byte alpha)
+		{SetAlphaLines(alpha,0,buf_height-1);};
+
+	// clip a line segment to the clip rect
+	bool				ClipLine(long& x1, long& y1, long& x2, long& y2);
+
+	// draw a solid colored line, no clipping
+	void				DrawLineNC(long x1, long y1, long x2, long y2, CPixel32 color);
+	
+	// draw a solid color line
+	void				DrawLine(long x1, long y1, long x2, long y2, CPixel32 color)
+		{	if (ClipLine(x1,y1,x2,y2)) DrawLineNC(x1,y1,x2,y2,color);}
+
+	void				DrawLineAveNC(long x1, long y1, long x2, long y2, CPixel32 color);
+
+	// draw a translucent solid color line
+	void				DrawLineAve(long x1, long y1, long x2, long y2, CPixel32 color)
+		{	if (ClipLine(x1,y1,x2,y2)) DrawLineAveNC(x1,y1,x2,y2,color);}
+
+	// draw an anti-aliased line, no clipping
+	void				DrawLineAANC(long x0, long y0, long x1, long y1, CPixel32 color);
+
+	// draw an anti-aliased line
+	void				DrawLineAA(long x1, long y1, long x2, long y2, CPixel32 color)
+		{	if (ClipLine(x1,y1,x2,y2)) DrawLineAANC(x1,y1,x2,y2,color);}
+
+	// draw a filled rectangle, no clipping
+	void				DrawRectNC(long ulx, long uly, long width, long height,CPixel32 color);
+	
+	// draw a filled rectangle
+	void				DrawRect(long ulx, long uly, long width, long height, CPixel32 color);
+
+	// draw a filled rectangle
+	void				DrawRectAve(long ulx, long uly, long width, long height,CPixel32 color);
+
+	// draw a box (unfilled rectangle) no clip
+	void				DrawBoxNC(long ulx, long uly, long width, long height, CPixel32 color);
+
+	// draw a box (unfilled rectangle)
+	void				DrawBox(long ulx, long uly, long width, long height, CPixel32 color);
+
+	// draw a box (unfilled rectangle)
+	void				DrawBoxAve(long ulx, long uly, long width, long height, CPixel32 color);
+
+	// draw a circle with fill and edge colors 
+	void				DrawCircle(long xc, long yc, long r, CPixel32 edge, CPixel32 fill);
+
+	// draw a circle with fill and edge colors averaged with dest 
+	void				DrawCircleAve(long xc, long yc, long r, CPixel32 edge, CPixel32 fill);
+
+	// draw a polygon (complex) with fill and edge colors 
+	void				DrawPolygon(long nvert, POINT *point, CPixel32 edge, CPixel32 fill);
+
+	// simple blit function
+	void				BlitNC(long dstX, long dstY, long dstWidth, long dstHeight, 
+							   CPixel32* srcImage, long srcX, long srcY, long srcStride);
+
+	void				Blit(long dstX, long dstY, long dstWidth, long dstHeight, 
+							   CPixel32* srcImage, long srcX, long srcY, long srcStride);
+
+	// blit image times color
+	void				BlitColor(long dstX, long dstY, long dstWidth, long dstHeight, 
+								  CPixel32* srcImage, long srcX, long srcY, long srcStride, CPixel32 color);
+
+	void				Emboss(long dstX, long dstY, long width, long height, 
+							    CPixel32* clrImage, long clrX, long clrY, long clrStride);
+};
+
+///////////////////////////////////////////////////////////////////////////////
+#endif
diff --git a/codemp/qcommon/cm_landscape.h b/codemp/qcommon/cm_landscape.h
new file mode 100644
index 0000000..872171f
--- /dev/null
+++ b/codemp/qcommon/cm_landscape.h
@@ -0,0 +1,271 @@
+#if !defined(CM_LANDSCAPE_H_INC)
+#define CM_LANDSCAPE_H_INC
+
+#pragma warning (push, 3)	//go back down to 3 for the stl include
+#include <list>
+#pragma warning (pop)
+
+using namespace std;
+
+// These are the root classes using data shared in both the server and the renderer.
+// This common data is also available to physics
+
+#define HEIGHT_RESOLUTION		256
+
+// Trying to make a guess at the optimal step through the patches
+// This is the average of 1 side and the diagonal presuming a square patch
+#define TERRAIN_STEP_MAGIC		(1.0f / 1.2071f)
+
+#define MIN_TERXELS				2
+#define MAX_TERXELS				8
+// Defined as 1 << (sqrt(MAX_TERXELS) + 1)
+#define MAX_VARIANCE_SIZE		16
+
+// Maximum number of instances to pick from an instance file
+#define MAX_INSTANCE_TYPES		16
+
+// Types of areas
+
+typedef enum
+{
+	AT_NONE,
+	AT_FLAT,
+	AT_BSP,
+	AT_NPC,
+	AT_GROUP,
+	AT_RIVER,
+	AT_OBJECTIVE,
+	AT_PLAYER,
+
+} areaType_t;
+
+class CArea
+{
+private:
+	vec3_t		mPosition;
+	float		mRadius;
+	float		mAngle;
+	float		mAngleDiff;
+	int			mType;
+	int			mVillageID;
+public:
+	CArea(void) {}
+	~CArea(void) {}
+
+	void Init(vec3_t pos, float radius, float angle = 0.0f, int type = AT_NONE, float angleDiff = 0.0f, int villageID = 0) 
+	{ 
+		VectorCopy(pos, mPosition); 
+		mRadius = radius; 
+		mAngle = angle; 
+		mAngleDiff = angleDiff; 
+		mType = type; 
+		mVillageID = villageID;
+	}
+	float GetRadius(void) const { return(mRadius); }
+	float GetAngle(void) const { return(mAngle); }
+	float GetAngleDiff(void) const { return(mAngleDiff); }
+	vec3_t &GetPosition(void) { return(mPosition); }
+	int GetType(void) const { return(mType); }
+	int GetVillageID(void) const { return(mVillageID); }
+};
+
+typedef list<CArea*>					areaList_t;
+typedef list<CArea*>::iterator			areaIter_t;
+
+class CCMHeightDetails
+{
+private:
+	int						mContents;
+	int						mSurfaceFlags;
+public:
+	CCMHeightDetails(void) {}
+	~CCMHeightDetails(void) {}
+
+	// Accessors
+	const int GetSurfaceFlags(void) const { return(mSurfaceFlags); }
+	const int GetContents(void) const { return(mContents); }
+	void SetFlags(const int con, const int sf) { mContents = con; mSurfaceFlags = sf; }
+};
+
+class CCMPatch
+{
+protected:
+	class CCMLandScape		*owner;										// Owning landscape
+	int						mHx, mHy;									// Terxel coords of patch
+	byte					*mHeightMap;				 				// Pointer to height map to use
+	byte					mCornerHeights[4]; 							// Heights at the corners of the patch
+	vec3_t					mWorldCoords;				 				// World coordinate offset of this patch.
+	vec3pair_t 				mBounds;									// mins and maxs of the patch for culling
+	int						mNumBrushes;								// number of brushes to collide with in the patch
+	struct cbrush_s			*mPatchBrushData;							// List of brushes that make up the patch
+	int						mSurfaceFlags;								// surfaceflag of the heightshader
+	int						mContentFlags;								// contents of the heightshader
+public:
+	// Constructors
+	CCMPatch(void) {}
+	~CCMPatch(void);
+
+	// Accessors
+	const vec3_t &GetWorld(void) const { return(mWorldCoords); }
+	const vec3_t &GetMins(void) const { return(mBounds[0]); }
+	const vec3_t &GetMaxs(void) const { return(mBounds[1]); }
+	const vec3pair_t &GetBounds(void) const { return(mBounds); }
+	const int GetHeightMapX(void) const { return(mHx); }
+	const int GetHeightMapY(void) const { return(mHy); }
+	const int GetHeight(int corner) const { return(mCornerHeights[corner]); }
+	const int GetNumBrushes(void) const { return(mNumBrushes); }
+	struct cbrush_s *GetCollisionData(void) const { return(mPatchBrushData); }
+
+	void SetSurfaceFlags(const int in) { mSurfaceFlags = in; }
+	const int GetSurfaceFlags(void) const { return(mSurfaceFlags); }
+	void SetContents(const int in) { mContentFlags = in; }
+	const int GetContents(void) const { return(mContentFlags); }
+
+	// Prototypes
+	void Init(CCMLandScape *ls, int heightX, int heightY, vec3_t world, byte *hMap, byte *patchBrushData);
+	void InitPlane(struct cbrushside_s *side, cplane_t *plane, vec3_t p0, vec3_t p1, vec3_t p2);
+	void CreatePatchPlaneData(void);
+	
+	void*	GetAdjacentBrushX ( int x, int y );
+	void*	GetAdjacentBrushY ( int x, int y );
+};
+
+class CRandomTerrain;
+
+class CCMLandScape
+{
+private:
+	int						mRefCount;									// Number of times this class is referenced
+	thandle_t				mTerrainHandle;
+	byte					*mHeightMap;								// Pointer to byte array of height samples
+	byte					*mFlattenMap;								// Pointer to byte array of flatten samples
+	int						mWidth, mHeight;							// Width and height of heightMap excluding the 1 pixel edge
+	int						mTerxels;									// Number of terxels per patch side
+	vec3_t					mTerxelSize;								// Vector to scale heightMap samples to real world coords
+	vec3pair_t				mBounds;									// Real world bounds of terrain brush
+	vec3_t					mSize;										// Size of terrain brush in real world coords excluding 1 patch edge
+	vec3_t					mPatchSize;									// Size of each patch in the x and y directions only
+	float					mPatchScalarSize;							// Horizontal size of the patch
+	int						mBlockWidth, mBlockHeight;					// Width and height of heightfield on blocks
+	CCMPatch 				*mPatches;
+	byte					*mPatchBrushData;							// Base memory from which the patch brush data is taken
+	bool					mHasPhysics;								// Set to true unless disabled
+	CRandomTerrain			*mRandomTerrain;
+							
+	int						mBaseWaterHeight;							// Base water height in terxels
+	float					mWaterHeight;								// Real world height of the water
+	int						mWaterContents;								// Contents of the water shader
+	int						mWaterSurfaceFlags;							// Surface flags of the water shader
+
+	unsigned long			holdrand;
+	
+	list<CArea *>			mAreas;										// List of flattened areas on this landscape
+	list<CArea *>::iterator	mAreasIt;
+
+	CCMHeightDetails		mHeightDetails[HEIGHT_RESOLUTION];			// Surfaceflags per height
+	vec3_t					*mCoords;									// Temp storage for real world coords
+
+public:
+	CCMLandScape(const char *configstring, bool server);
+	~CCMLandScape(void);
+
+	CCMPatch *GetPatch(int x, int y);
+
+	// Prototypes
+	void PatchCollide(struct traceWork_s *tw, trace_t &trace, const vec3_t start, const vec3_t end, int checkcount);
+	void TerrainPatchIterate(void (*IterateFunc)( CCMPatch *, void * ), void *userdata) const;
+	float GetWorldHeight(vec3_t origin, const vec3pair_t bounds, bool aboveGround) const;
+	float WaterCollide(const vec3_t begin, const vec3_t end, float fraction) const;
+	void UpdatePatches(void);
+	void GetTerxelLocalCoords ( int x, int y, vec3_t coords[8] );
+	void LoadTerrainDef(const char *td);
+	void SetShaders(int height, class CCMShader *shader);
+	void FlattenArea(CArea *area, int height, bool save, bool forceHeight, bool smooth);
+	void CarveLine ( vec3_t start, vec3_t end, int depth, int width );
+	void CarveBezierCurve ( int numCtlPoints, vec3_t* ctlPoints, int steps, int depth, int size );
+	void SaveArea(CArea *area);
+	float FractionBelowLevel(CArea *area, int height);
+	bool AreaCollision(CArea *area, int *areaTypes, int areaTypeCount);
+	CArea *GetFirstArea(void);
+	CArea *GetFirstObjectiveArea(void);
+	CArea *GetPlayerArea(void);
+	CArea *GetNextArea(void);
+	CArea *GetNextObjectiveArea(void);
+
+	// Accessors
+	const int GetRefCount(void) const { return(mRefCount); }
+	void IncreaseRefCount(void) { mRefCount++; }
+	void DecreaseRefCount(void) { mRefCount--; }
+	const vec3pair_t &GetBounds(void) const { return(mBounds); }
+	const vec3_t &GetMins(void) const { return(mBounds[0]); }
+	const vec3_t &GetMaxs(void) const { return(mBounds[1]); }
+	const vec3_t &GetSize(void) const { return(mSize); }
+	const vec3_t &GetTerxelSize(void) const { return(mTerxelSize); }
+	const vec3_t &GetPatchSize(void) const { return(mPatchSize); }
+	const float GetPatchWidth(void) const { return(mPatchSize[0]); }
+	const float GetPatchHeight(void) const { return(mPatchSize[1]); }
+	const float GetPatchScalarSize(void) const { return(mPatchScalarSize); }
+	const int GetTerxels(void) const { return(mTerxels); }
+	const int GetRealWidth(void) const { return(mWidth + 1); }
+	const int GetRealHeight(void) const { return(mHeight + 1); }
+	const int GetRealArea(void) const { return((mWidth + 1) * (mHeight + 1)); }
+	const int GetWidth(void) const { return(mWidth); }
+	const int GetHeight(void) const { return(mHeight); }
+	const int GetArea(void) const { return(mWidth * mHeight); }
+	const int GetBlockWidth(void) const { return(mBlockWidth); }
+	const int GetBlockHeight(void) const { return(mBlockHeight); }
+	const int GetBlockCount(void) const { return(mBlockWidth * mBlockHeight); }
+	byte *GetHeightMap(void) const { return(mHeightMap); }
+	byte *GetFlattenMap(void) const { return(mFlattenMap); }
+	const thandle_t GetTerrainId(void) const { return(mTerrainHandle); }
+	void SetTerrainId(const thandle_t terrainId) { mTerrainHandle = terrainId; }
+	const float CalcWorldHeight(int height) const { return((height * mTerxelSize[2]) + mBounds[0][2]); }
+	const bool GetHasPhysics(void) const { return(mHasPhysics); }
+	const bool GetIsRandom(void) const { return(mRandomTerrain != 0); }
+	const int GetSurfaceFlags(int height) const { return(mHeightDetails[height].GetSurfaceFlags()); }
+	const int GetContentFlags(int height) const { return(mHeightDetails[height].GetContents()); }
+	void CalcRealCoords(void);
+	vec3_t *GetCoords(void) const { return(mCoords); }
+
+	int GetBaseWaterHeight(void) const { return(mBaseWaterHeight); }
+	void SetRealWaterHeight(int height) { mWaterHeight = height * mTerxelSize[2]; }
+	float GetWaterHeight(void) const { return(mWaterHeight); }
+	int GetWaterContents(void) const { return(mWaterContents); }
+	int GetWaterSurfaceFlags(void) const { return(mWaterSurfaceFlags); }
+
+	CRandomTerrain			*GetRandomTerrain(void) { return mRandomTerrain; }
+
+	void			rand_seed(int seed);
+	unsigned long	get_rand_seed(void) { return holdrand; }
+
+	float			flrand(float min, float max);
+	int				irand(int min, int max);
+};
+
+void CM_TerrainPatchIterate(const class CCMLandScape *ls, void (*IterateFunc)( CCMPatch *, void * ), void *userdata);
+class CCMLandScape *CM_InitTerrain(const char *configstring, thandle_t terrainId, bool server);
+float CM_GetWorldHeight(const CCMLandScape *landscape, vec3_t origin, const vec3pair_t bounds, bool aboveGround);
+void CM_FlattenArea(CCMLandScape *landscape, CArea *area, int height, bool save, bool forceHeight, bool smooth);
+void CM_CarveBezierCurve (CCMLandScape *landscape, int numCtls, vec3_t* ctls, int steps, int depth, int size );
+void CM_SaveArea(CCMLandScape *landscape, CArea *area);
+float CM_FractionBelowLevel(CCMLandScape *landscape, CArea *area, int height);
+bool CM_AreaCollision(class CCMLandScape *landscape, class CArea *area, int *areaTypes, int areaTypeCount);
+CArea *CM_GetFirstArea(CCMLandScape *landscape);
+CArea *CM_GetFirstObjectiveArea(CCMLandScape *landscape);
+CArea *CM_GetPlayerArea(class CCMLandScape *common);
+CArea *CM_GetNextArea(CCMLandScape *landscape);
+CArea *CM_GetNextObjectiveArea(CCMLandScape *landscape);
+void CM_CircularIterate(byte *data, int width, int height, int xo, int yo, int insideRadius, int outsideRadius, int *user, void (*callback)(byte *, float, int *));
+
+CRandomTerrain *CreateRandomTerrain(const char *config, CCMLandScape *landscape, byte *heightmap, int width, int height);
+
+void SV_LoadMissionDef(const char *configstring, class CCMLandScape *landscape);
+void CL_CreateRandomTerrain(const char *config, class CCMLandScape *landscape, byte *image, int width, int height);
+void CL_LoadInstanceDef(const char *configstring, class CCMLandScape *landscape);
+void CL_LoadMissionDef(const char *configstring, class CCMLandScape *landscape);
+
+extern cvar_t	*com_terrainPhysics;
+
+#endif
+
+// end
diff --git a/codemp/qcommon/cm_load.cpp b/codemp/qcommon/cm_load.cpp
new file mode 100644
index 0000000..a199356
--- /dev/null
+++ b/codemp/qcommon/cm_load.cpp
@@ -0,0 +1,1184 @@
+// cmodel.c -- model loading
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+#include "cm_local.h"
+#include "cm_landscape.h" //rwwRMG - include
+#include "../RMG/RM_Headers.h" //rwwRMG - include
+
+#ifdef BSPC
+
+#include "../bspc/l_qfiles.h"
+
+void SetPlaneSignbits (cplane_t *out) {
+	int	bits, j;
+
+	// for fast box on planeside test
+	bits = 0;
+	for (j=0 ; j<3 ; j++) {
+		if (out->normal[j] < 0) {
+			bits |= 1<<j;
+		}
+	}
+	out->signbits = bits;
+}
+#endif //BSPC
+
+// to allow boxes to be treated as brush models, we allocate
+// some extra indexes along with those needed by the map
+#define	BOX_BRUSHES		1
+#define	BOX_SIDES		6
+#define	BOX_LEAFS		2
+#define	BOX_PLANES		12
+
+#define	LL(x) x=LittleLong(x)
+
+
+clipMap_t	cmg; //rwwRMG - changed from cm
+int			c_pointcontents;
+int			c_traces, c_brush_traces, c_patch_traces;
+
+
+byte		*cmod_base;
+
+#ifndef BSPC
+cvar_t		*cm_noAreas;
+cvar_t		*cm_noCurves;
+cvar_t		*cm_playerCurveClip;
+#endif
+
+cmodel_t	box_model;
+cplane_t	*box_planes;
+cbrush_t	*box_brush;
+
+
+
+void	CM_InitBoxHull (void);
+void	CM_FloodAreaConnections (clipMap_t &cm);
+
+//rwwRMG - added:
+clipMap_t	SubBSP[MAX_SUB_BSP];
+int			NumSubBSP, TotalSubModels;
+
+/*
+===============================================================================
+
+					MAP LOADING
+
+===============================================================================
+*/
+
+/*
+=================
+CMod_LoadShaders
+=================
+*/
+void CMod_LoadShaders( lump_t *l, clipMap_t	&cm ) 
+{
+	dshader_t	*in;
+	int			i, count;
+	CCMShader	*out;
+
+	in = (dshader_t *)(cmod_base + l->fileofs);
+	if (l->filelen % sizeof(*in)) {
+		Com_Error (ERR_DROP, "CMod_LoadShaders: funny lump size");
+	}
+	count = l->filelen / sizeof(*in);
+
+	if (count < 1) {
+		Com_Error (ERR_DROP, "Map with no shaders");
+	}
+	cm.shaders = (CCMShader *)Hunk_Alloc( (1+count) * sizeof( *cm.shaders ), h_high );
+	cm.numShaders = count;
+
+	out = cm.shaders;
+	for ( i = 0; i < count; i++, in++, out++ ) 
+	{
+		Q_strncpyz(out->shader, in->shader, MAX_QPATH);
+		out->contentFlags = LittleLong( in->contentFlags );
+		out->surfaceFlags = LittleLong( in->surfaceFlags );
+	}
+}
+
+
+/*
+=================
+CMod_LoadSubmodels
+=================
+*/
+void CMod_LoadSubmodels( lump_t *l, clipMap_t &cm ) {
+	dmodel_t	*in;
+	cmodel_t	*out;
+	int			i, j, count;
+	int			*indexes;
+
+	in = (dmodel_t *)(cmod_base + l->fileofs);
+	if (l->filelen % sizeof(*in))
+		Com_Error (ERR_DROP, "CMod_LoadSubmodels: funny lump size");
+	count = l->filelen / sizeof(*in);
+
+	if (count < 1)
+		Com_Error (ERR_DROP, "Map with no models");
+	cm.cmodels = (struct cmodel_s *)Hunk_Alloc( count * sizeof( *cm.cmodels ), h_high );
+	cm.numSubModels = count;
+
+	if ( count > MAX_SUBMODELS ) {
+		Com_Error( ERR_DROP, "MAX_SUBMODELS exceeded" );
+	}
+
+	for ( i=0 ; i<count ; i++, in++, out++)
+	{
+		out = &cm.cmodels[i];
+
+		for (j=0 ; j<3 ; j++)
+		{	// spread the mins / maxs by a pixel
+			out->mins[j] = LittleFloat (in->mins[j]) - 1;
+			out->maxs[j] = LittleFloat (in->maxs[j]) + 1;
+		}
+
+		//rwwRMG - sof2 doesn't have to add this &cm == &cmg check.
+		//Are they getting leaf data elsewhere? (the reason this needs to be done is
+		//in sub bsp instances the first brush model isn't necessary a world model and might be
+		//real architecture)
+		if ( i == 0 && &cm == &cmg ) {
+			out->firstNode = 0;
+			continue;	// world model doesn't need other info
+		}
+
+		// make a "leaf" just to hold the model's brushes and surfaces
+		out->firstNode = -1;
+
+		// make a "leaf" just to hold the model's brushes and surfaces
+		out->leaf.numLeafBrushes = LittleLong( in->numBrushes );
+		indexes = (int *)Hunk_Alloc( out->leaf.numLeafBrushes * 4, h_high );
+		out->leaf.firstLeafBrush = indexes - cm.leafbrushes;
+		for ( j = 0 ; j < out->leaf.numLeafBrushes ; j++ ) {
+			indexes[j] = LittleLong( in->firstBrush ) + j;
+		}
+
+		out->leaf.numLeafSurfaces = LittleLong( in->numSurfaces );
+		indexes = (int *)Hunk_Alloc( out->leaf.numLeafSurfaces * 4, h_high );
+		out->leaf.firstLeafSurface = indexes - cm.leafsurfaces;
+		for ( j = 0 ; j < out->leaf.numLeafSurfaces ; j++ ) {
+			indexes[j] = LittleLong( in->firstSurface ) + j;
+		}
+	}
+}
+
+
+/*
+=================
+CMod_LoadNodes
+
+=================
+*/
+void CMod_LoadNodes( lump_t *l, clipMap_t &cm ) {
+	dnode_t		*in;
+	int			child;
+	cNode_t		*out;
+	int			i, j, count;
+	
+	in = (dnode_t *)(cmod_base + l->fileofs);
+	if (l->filelen % sizeof(*in))
+		Com_Error (ERR_DROP, "MOD_LoadBmodel: funny lump size");
+	count = l->filelen / sizeof(*in);
+
+	if (count < 1)
+		Com_Error (ERR_DROP, "Map has no nodes");
+	cm.nodes = (cNode_t *)Hunk_Alloc( count * sizeof( *cm.nodes ), h_high );
+	cm.numNodes = count;
+
+	out = cm.nodes;
+
+	for (i=0 ; i<count ; i++, out++, in++)
+	{
+		out->plane = cm.planes + LittleLong( in->planeNum );
+		for (j=0 ; j<2 ; j++)
+		{
+			child = LittleLong (in->children[j]);
+			out->children[j] = child;
+		}
+	}
+
+}
+
+/*
+=================
+CM_BoundBrush
+
+=================
+*/
+void CM_BoundBrush( cbrush_t *b ) {
+	b->bounds[0][0] = -b->sides[0].plane->dist;
+	b->bounds[1][0] = b->sides[1].plane->dist;
+
+	b->bounds[0][1] = -b->sides[2].plane->dist;
+	b->bounds[1][1] = b->sides[3].plane->dist;
+
+	b->bounds[0][2] = -b->sides[4].plane->dist;
+	b->bounds[1][2] = b->sides[5].plane->dist;
+}
+
+
+/*
+=================
+CMod_LoadBrushes
+
+=================
+*/
+void CMod_LoadBrushes( lump_t *l, clipMap_t	&cm ) {
+	dbrush_t	*in;
+	cbrush_t	*out;
+	int			i, count;
+
+	in = (dbrush_t *)(cmod_base + l->fileofs);
+	if (l->filelen % sizeof(*in)) {
+		Com_Error (ERR_DROP, "MOD_LoadBmodel: funny lump size");
+	}
+	count = l->filelen / sizeof(*in);
+
+	cm.brushes = (cbrush_t *)Hunk_Alloc( ( BOX_BRUSHES + count ) * sizeof( *cm.brushes ), h_high );
+	cm.numBrushes = count;
+
+	out = cm.brushes;
+
+	for ( i=0 ; i<count ; i++, out++, in++ ) {
+		out->sides = cm.brushsides + LittleLong(in->firstSide);
+		out->numsides = LittleLong(in->numSides);
+
+		out->shaderNum = LittleLong( in->shaderNum );
+		if ( out->shaderNum < 0 || out->shaderNum >= cm.numShaders ) {
+			Com_Error( ERR_DROP, "CMod_LoadBrushes: bad shaderNum: %i", out->shaderNum );
+		}
+		out->contents = cm.shaders[out->shaderNum].contentFlags;
+
+		// Landscapes are set up afterwards in the entity spawning
+		//out->landscape = NULL;	//the memory was cleared already by hunk_alloc
+		//out->checkcount=0;
+
+		CM_BoundBrush( out );
+	}
+
+}
+
+/*
+=================
+CMod_LoadLeafs
+=================
+*/
+void CMod_LoadLeafs (lump_t *l, clipMap_t &cm)
+{
+	int			i;
+	cLeaf_t		*out;
+	dleaf_t 	*in;
+	int			count;
+	
+	in = (dleaf_t *)(cmod_base + l->fileofs);
+	if (l->filelen % sizeof(*in))
+		Com_Error (ERR_DROP, "MOD_LoadBmodel: funny lump size");
+	count = l->filelen / sizeof(*in);
+
+	if (count < 1)
+		Com_Error (ERR_DROP, "Map with no leafs");
+
+	cm.leafs = (cLeaf_t *)Hunk_Alloc( ( BOX_LEAFS + count ) * sizeof( *cm.leafs ), h_high );
+	cm.numLeafs = count;
+
+	out = cm.leafs;	
+	for ( i=0 ; i<count ; i++, in++, out++)
+	{
+		out->cluster = LittleLong (in->cluster);
+		out->area = LittleLong (in->area);
+		out->firstLeafBrush = LittleLong (in->firstLeafBrush);
+		out->numLeafBrushes = LittleLong (in->numLeafBrushes);
+		out->firstLeafSurface = LittleLong (in->firstLeafSurface);
+		out->numLeafSurfaces = LittleLong (in->numLeafSurfaces);
+
+		if (out->cluster >= cm.numClusters)
+			cm.numClusters = out->cluster + 1;
+		if (out->area >= cm.numAreas)
+			cm.numAreas = out->area + 1;
+	}
+
+	cm.areas = (cArea_t *)Hunk_Alloc( cm.numAreas * sizeof( *cm.areas ), h_high );
+	cm.areaPortals = (int *)Hunk_Alloc( cm.numAreas * cm.numAreas * sizeof( *cm.areaPortals ), h_high );
+}
+
+/*
+=================
+CMod_LoadPlanes
+=================
+*/
+void CMod_LoadPlanes (lump_t *l, clipMap_t &cm)
+{
+	int			i, j;
+	cplane_t	*out;
+	dplane_t 	*in;
+	int			count;
+	int			bits;
+	
+	in = (dplane_t *)(cmod_base + l->fileofs);
+	if (l->filelen % sizeof(*in))
+		Com_Error (ERR_DROP, "MOD_LoadBmodel: funny lump size");
+	count = l->filelen / sizeof(*in);
+
+	if (count < 1)
+		Com_Error (ERR_DROP, "Map with no planes");
+	cm.planes = (struct cplane_s *)Hunk_Alloc( ( BOX_PLANES + count ) * sizeof( *cm.planes ), h_high );
+	cm.numPlanes = count;
+
+	out = cm.planes;	
+
+	for ( i=0 ; i<count ; i++, in++, out++)
+	{
+		bits = 0;
+		for (j=0 ; j<3 ; j++)
+		{
+			out->normal[j] = LittleFloat (in->normal[j]);
+			if (out->normal[j] < 0)
+				bits |= 1<<j;
+		}
+
+		out->dist = LittleFloat (in->dist);
+		out->type = PlaneTypeForNormal( out->normal );
+		out->signbits = bits;
+	}
+}
+
+/*
+=================
+CMod_LoadLeafBrushes
+=================
+*/
+void CMod_LoadLeafBrushes (lump_t *l, clipMap_t	&cm)
+{
+	int			i;
+	int			*out;
+	int		 	*in;
+	int			count;
+	
+	in = (int *)(cmod_base + l->fileofs);
+	if (l->filelen % sizeof(*in))
+		Com_Error (ERR_DROP, "MOD_LoadBmodel: funny lump size");
+	count = l->filelen / sizeof(*in);
+
+	cm.leafbrushes = (int *)Hunk_Alloc( (count + BOX_BRUSHES) * sizeof( *cm.leafbrushes ), h_high );
+	cm.numLeafBrushes = count;
+
+	out = cm.leafbrushes;
+
+	for ( i=0 ; i<count ; i++, in++, out++) {
+		*out = LittleLong (*in);
+	}
+}
+
+/*
+=================
+CMod_LoadLeafSurfaces
+=================
+*/
+void CMod_LoadLeafSurfaces( lump_t *l, clipMap_t &cm )
+{
+	int			i;
+	int			*out;
+	int		 	*in;
+	int			count;
+	
+	in = (int *)(cmod_base + l->fileofs);
+	if (l->filelen % sizeof(*in))
+		Com_Error (ERR_DROP, "MOD_LoadBmodel: funny lump size");
+	count = l->filelen / sizeof(*in);
+
+	cm.leafsurfaces = (int *)Hunk_Alloc( count * sizeof( *cm.leafsurfaces ), h_high );
+	cm.numLeafSurfaces = count;
+
+	out = cm.leafsurfaces;
+
+	for ( i=0 ; i<count ; i++, in++, out++) {
+		*out = LittleLong (*in);
+	}
+}
+
+/*
+=================
+CMod_LoadBrushSides
+=================
+*/
+void CMod_LoadBrushSides (lump_t *l, clipMap_t &cm)
+{
+	int				i;
+	cbrushside_t	*out;
+	dbrushside_t 	*in;
+	int				count;
+	int				num;
+
+	in = (dbrushside_t *)(cmod_base + l->fileofs);
+	if ( l->filelen % sizeof(*in) ) {
+		Com_Error (ERR_DROP, "MOD_LoadBmodel: funny lump size");
+	}
+	count = l->filelen / sizeof(*in);
+
+	cm.brushsides = (cbrushside_t *)Hunk_Alloc( ( BOX_SIDES + count ) * sizeof( *cm.brushsides ), h_high );
+	cm.numBrushSides = count;
+
+	out = cm.brushsides;	
+
+	for ( i=0 ; i<count ; i++, in++, out++) {
+		num = LittleLong( in->planeNum );
+		out->plane = &cm.planes[num];
+		out->shaderNum = LittleLong( in->shaderNum );
+		if ( out->shaderNum < 0 || out->shaderNum >= cm.numShaders ) {
+			Com_Error( ERR_DROP, "CMod_LoadBrushSides: bad shaderNum: %i", out->shaderNum );
+		}
+	}
+}
+
+
+/*
+=================
+CMod_LoadEntityString
+=================
+*/
+void CMod_LoadEntityString( lump_t *l, clipMap_t &cm ) {
+	cm.entityString = (char *)Hunk_Alloc( l->filelen, h_high );
+	cm.numEntityChars = l->filelen;
+	Com_Memcpy (cm.entityString, cmod_base + l->fileofs, l->filelen);
+}
+
+/*
+=================
+CMod_LoadVisibility
+=================
+*/
+#define	VIS_HEADER	8
+void CMod_LoadVisibility( lump_t *l, clipMap_t &cm ) {
+	int		len;
+	byte	*buf;
+
+    len = l->filelen;
+	if ( !len ) {
+		cm.clusterBytes = ( cm.numClusters + 31 ) & ~31;
+		cm.visibility = (unsigned char *)Hunk_Alloc( cm.clusterBytes, h_high );
+		Com_Memset( cm.visibility, 255, cm.clusterBytes );
+		return;
+	}
+	buf = cmod_base + l->fileofs;
+
+	cm.vised = qtrue;
+	cm.visibility = (unsigned char *)Hunk_Alloc( len, h_high );
+	cm.numClusters = LittleLong( ((int *)buf)[0] );
+	cm.clusterBytes = LittleLong( ((int *)buf)[1] );
+	Com_Memcpy (cm.visibility, buf + VIS_HEADER, len - VIS_HEADER );
+}
+
+//==================================================================
+
+
+/*
+=================
+CMod_LoadPatches
+=================
+*/
+#define	MAX_PATCH_VERTS		1024
+void CMod_LoadPatches( lump_t *surfs, lump_t *verts, clipMap_t &cm ) {
+	drawVert_t	*dv, *dv_p;
+	dsurface_t	*in;
+	int			count;
+	int			i, j;
+	int			c;
+	cPatch_t	*patch;
+	vec3_t		points[MAX_PATCH_VERTS];
+	int			width, height;
+	int			shaderNum;
+
+	in = (dsurface_t *)(cmod_base + surfs->fileofs);
+	if (surfs->filelen % sizeof(*in))
+		Com_Error (ERR_DROP, "MOD_LoadBmodel: funny lump size");
+	cm.numSurfaces = count = surfs->filelen / sizeof(*in);
+	cm.surfaces = (cPatch_t ** )Hunk_Alloc( cm.numSurfaces * sizeof( cm.surfaces[0] ), h_high );
+
+	dv = (drawVert_t *)(cmod_base + verts->fileofs);
+	if (verts->filelen % sizeof(*dv))
+		Com_Error (ERR_DROP, "MOD_LoadBmodel: funny lump size");
+
+	// scan through all the surfaces, but only load patches,
+	// not planar faces
+	for ( i = 0 ; i < count ; i++, in++ ) {
+		if ( LittleLong( in->surfaceType ) != MST_PATCH ) {
+			continue;		// ignore other surfaces
+		}
+		// FIXME: check for non-colliding patches
+
+		cm.surfaces[ i ] = patch = (cPatch_t *)Hunk_Alloc( sizeof( *patch ), h_high );
+
+		// load the full drawverts onto the stack
+		width = LittleLong( in->patchWidth );
+		height = LittleLong( in->patchHeight );
+		c = width * height;
+		if ( c > MAX_PATCH_VERTS ) {
+			Com_Error( ERR_DROP, "ParseMesh: MAX_PATCH_VERTS" );
+		}
+
+		dv_p = dv + LittleLong( in->firstVert );
+		for ( j = 0 ; j < c ; j++, dv_p++ ) {
+			points[j][0] = LittleFloat( dv_p->xyz[0] );
+			points[j][1] = LittleFloat( dv_p->xyz[1] );
+			points[j][2] = LittleFloat( dv_p->xyz[2] );
+		}
+
+		shaderNum = LittleLong( in->shaderNum );
+		patch->contents = cm.shaders[shaderNum].contentFlags;
+		patch->surfaceFlags = cm.shaders[shaderNum].surfaceFlags;
+
+		// create the internal facet structure
+		patch->pc = CM_GeneratePatchCollide( width, height, points );
+	}
+}
+
+//==================================================================
+
+unsigned CM_LumpChecksum(lump_t *lump) {
+	return LittleLong (Com_BlockChecksum (cmod_base + lump->fileofs, lump->filelen));
+}
+
+unsigned CM_Checksum(dheader_t *header) {
+	unsigned checksums[16];
+	checksums[0] = CM_LumpChecksum(&header->lumps[LUMP_SHADERS]);
+	checksums[1] = CM_LumpChecksum(&header->lumps[LUMP_LEAFS]);
+	checksums[2] = CM_LumpChecksum(&header->lumps[LUMP_LEAFBRUSHES]);
+	checksums[3] = CM_LumpChecksum(&header->lumps[LUMP_LEAFSURFACES]);
+	checksums[4] = CM_LumpChecksum(&header->lumps[LUMP_PLANES]);
+	checksums[5] = CM_LumpChecksum(&header->lumps[LUMP_BRUSHSIDES]);
+	checksums[6] = CM_LumpChecksum(&header->lumps[LUMP_BRUSHES]);
+	checksums[7] = CM_LumpChecksum(&header->lumps[LUMP_MODELS]);
+	checksums[8] = CM_LumpChecksum(&header->lumps[LUMP_NODES]);
+	checksums[9] = CM_LumpChecksum(&header->lumps[LUMP_SURFACES]);
+	checksums[10] = CM_LumpChecksum(&header->lumps[LUMP_DRAWVERTS]);
+
+	return LittleLong(Com_BlockChecksum(checksums, 11 * 4));
+}
+
+/*
+==================
+CM_LoadMap
+
+Loads in the map and all submodels
+==================
+*/
+void *gpvCachedMapDiskImage = NULL;
+char  gsCachedMapDiskImage[MAX_QPATH];
+qboolean gbUsingCachedMapDataRightNow = qfalse;	// if true, signifies that you can't delete this at the moment!! (used during z_malloc()-fail recovery attempt)
+
+// called in response to a "devmapbsp blah" or "devmapall blah" command, do NOT use inside CM_Load unless you pass in qtrue
+//
+// new bool return used to see if anything was freed, used during z_malloc failure re-try
+//
+qboolean CM_DeleteCachedMap(qboolean bGuaranteedOkToDelete)
+{
+	qboolean bActuallyFreedSomething = qfalse;
+
+	if (bGuaranteedOkToDelete || !gbUsingCachedMapDataRightNow)
+	{
+		// dump cached disk image...
+		//
+		if (gpvCachedMapDiskImage)
+		{
+			Z_Free(	gpvCachedMapDiskImage );
+					gpvCachedMapDiskImage = NULL;
+
+			bActuallyFreedSomething = qtrue;
+		}
+		gsCachedMapDiskImage[0] = '\0';
+		
+		// force map loader to ignore cached internal BSP structures for next level CM_LoadMap() call...
+		//
+		cmg.name[0] = '\0';
+	}
+
+	return bActuallyFreedSomething;
+}
+
+
+
+
+
+static void CM_LoadMap_Actual( const char *name, qboolean clientload, int *checksum, clipMap_t &cm )
+{ //rwwRMG - function needs heavy modification
+	int				*buf;
+	int				i;
+	dheader_t		header;	
+	static unsigned	last_checksum;
+	char			origName[MAX_OSPATH];
+	void			*newBuff = 0;
+
+	if ( !name || !name[0] ) {
+		Com_Error( ERR_DROP, "CM_LoadMap: NULL name" );
+	}
+
+#ifndef BSPC
+	cm_noAreas = Cvar_Get ("cm_noAreas", "0", CVAR_CHEAT);
+	cm_noCurves = Cvar_Get ("cm_noCurves", "0", CVAR_CHEAT);
+	cm_playerCurveClip = Cvar_Get ("cm_playerCurveClip", "1", CVAR_ARCHIVE|CVAR_CHEAT );
+#endif
+	Com_DPrintf( "CM_LoadMap( %s, %i )\n", name, clientload );
+
+	if ( !strcmp( cm.name, name ) && clientload ) {
+		*checksum = last_checksum;
+		return;
+	}
+
+	strcpy(origName, name);
+
+	if (&cm == &cmg)
+	{	
+		// free old stuff
+		CM_ClearMap();
+		CM_ClearLevelPatches();
+	}
+
+	// free old stuff
+	Com_Memset( &cm, 0, sizeof( cm ) );
+
+	if ( !name[0] ) {
+		cm.numLeafs = 1;
+		cm.numClusters = 1;
+		cm.numAreas = 1;
+		cm.cmodels = (struct cmodel_s *)Hunk_Alloc( sizeof( *cm.cmodels ), h_high );
+		*checksum = 0;
+		return;
+	}
+
+	//
+	// load the file
+	//
+	//rww - Doesn't this sort of defeat the purpose? We're clearing it even if the map is the same as the last one!
+	//Not touching it though in case I'm just overlooking something.
+	if (gpvCachedMapDiskImage && &cm == &cmg)	// MP code: this'll only be NZ if we got an ERR_DROP during last map load,
+	{							//	so it's really just a safety measure.
+		Z_Free(	gpvCachedMapDiskImage);
+				gpvCachedMapDiskImage = NULL;
+	}
+
+#ifndef BSPC
+	//
+	// load the file into a buffer that we either discard as usual at the bottom, or if we've got enough memory
+	//	then keep it long enough to save the renderer re-loading it (if not dedicated server), 
+	//	then discard it after that...
+	//
+	buf = NULL;	
+	fileHandle_t h;	
+	const int iBSPLen = FS_FOpenFileRead( name, &h, qfalse );
+	if (h)
+	{			
+		newBuff = Z_Malloc( iBSPLen, TAG_BSP_DISKIMAGE );
+		FS_Read( newBuff, iBSPLen, h);
+		FS_FCloseFile( h );
+
+		buf = (int*) newBuff;	// so the rest of the code works as normal
+		if (&cm == &cmg)
+		{
+			gpvCachedMapDiskImage = newBuff;
+			newBuff = 0;
+		}
+
+		// carry on as before...
+		//	
+	}
+#else
+	const int iBSPLen = LoadQuakeFile((quakefile_t *) name, (void **)&buf);
+#endif
+
+	if ( !buf ) {
+		Com_Error (ERR_DROP, "Couldn't load %s", name);
+	}
+
+	last_checksum = LittleLong (Com_BlockChecksum (buf, iBSPLen));
+	*checksum = last_checksum;
+
+	header = *(dheader_t *)buf;
+	for (i=0 ; i<sizeof(dheader_t)/4 ; i++) {
+		((int *)&header)[i] = LittleLong ( ((int *)&header)[i]);
+	}
+
+	if ( header.version != BSP_VERSION ) {
+		Z_Free(	gpvCachedMapDiskImage);
+				gpvCachedMapDiskImage = NULL;
+
+		Com_Error (ERR_DROP, "CM_LoadMap: %s has wrong version number (%i should be %i)"
+		, name, header.version, BSP_VERSION );
+	}
+
+	cmod_base = (byte *)buf;
+
+	// load into heap
+	CMod_LoadShaders( &header.lumps[LUMP_SHADERS], cm );
+	CMod_LoadLeafs (&header.lumps[LUMP_LEAFS], cm);
+	CMod_LoadLeafBrushes (&header.lumps[LUMP_LEAFBRUSHES], cm);
+	CMod_LoadLeafSurfaces (&header.lumps[LUMP_LEAFSURFACES], cm);
+	CMod_LoadPlanes (&header.lumps[LUMP_PLANES], cm);
+	CMod_LoadBrushSides (&header.lumps[LUMP_BRUSHSIDES], cm);
+	CMod_LoadBrushes (&header.lumps[LUMP_BRUSHES], cm);
+	CMod_LoadSubmodels (&header.lumps[LUMP_MODELS], cm);
+	CMod_LoadNodes (&header.lumps[LUMP_NODES], cm);
+	CMod_LoadEntityString (&header.lumps[LUMP_ENTITIES], cm);
+	CMod_LoadVisibility( &header.lumps[LUMP_VISIBILITY], cm );
+	CMod_LoadPatches( &header.lumps[LUMP_SURFACES], &header.lumps[LUMP_DRAWVERTS], cm );
+
+	TotalSubModels += cm.numSubModels;
+
+	if (&cm == &cmg)
+	{
+		// Load in the shader text - return instantly if already loaded
+#if !defined(BSPC)
+		CM_LoadShaderText(qfalse);
+#endif
+		CM_InitBoxHull ();
+#if !defined(BSPC)
+		CM_SetupShaderProperties();
+#endif
+	}
+
+#ifndef BSPC	// I hope we can lose this crap soon
+	//
+	// if we've got enough memory, and it's not a dedicated-server, then keep the loaded map binary around
+	//	for the renderer to chew on... (but not if this gets ported to a big-endian machine, because some of the
+	//	map data will have been Little-Long'd, but some hasn't).
+	//
+	if (Sys_LowPhysicalMemory() 
+		|| com_dedicated->integer
+//		|| we're on a big-endian machine
+		)
+	{
+		Z_Free(	gpvCachedMapDiskImage );
+				gpvCachedMapDiskImage = NULL;
+	}
+	else
+	{
+		// ... do nothing, and let the renderer free it after it's finished playing with it...
+		//
+	}
+#else
+	FS_FreeFile (buf);
+#endif
+
+	CM_FloodAreaConnections (cm);
+
+	// allow this to be cached if it is loaded by the server
+	if ( !clientload ) {
+		Q_strncpyz( cm.name, origName, sizeof( cm.name ) );
+	}
+}
+
+
+// need a wrapper function around this because of multiple returns, need to ensure bool is correct...
+//
+void CM_LoadMap( const char *name, qboolean clientload, int *checksum )
+{
+	gbUsingCachedMapDataRightNow = qtrue;	// !!!!!!!!!!!!!!!!!!
+
+		CM_LoadMap_Actual( name, clientload, checksum, cmg );
+
+	gbUsingCachedMapDataRightNow = qfalse;	// !!!!!!!!!!!!!!!!!!
+}
+
+
+
+/*
+==================
+CM_ClearMap
+==================
+*/
+void CM_ClearMap( void ) 
+{
+	int		i;
+
+#if !defined(BSPC)
+	CM_ShutdownShaderProperties();
+//	MAT_Shutdown();
+#endif
+
+	if (TheRandomMissionManager)
+	{
+		delete TheRandomMissionManager;
+		TheRandomMissionManager = 0;
+	}
+
+	if (cmg.landScape)
+	{
+		delete cmg.landScape;
+		cmg.landScape = NULL;
+	}
+
+	Com_Memset( &cmg, 0, sizeof( cmg ) );
+	CM_ClearLevelPatches();
+
+	for(i = 0; i < NumSubBSP; i++)
+	{
+		memset(&SubBSP[i], 0, sizeof(SubBSP[0]));
+	}
+	NumSubBSP = 0;
+	TotalSubModels = 0;
+}
+
+/*
+==================
+CM_ClipHandleToModel
+==================
+*/
+cmodel_t	*CM_ClipHandleToModel( clipHandle_t handle, clipMap_t **clipMap ) {
+	int		i;
+	int		count;
+
+	if ( handle < 0 ) 
+	{
+		Com_Error( ERR_DROP, "CM_ClipHandleToModel: bad handle %i", handle );
+	}
+	if ( handle < cmg.numSubModels ) 
+	{
+		if (clipMap)
+		{
+			*clipMap = &cmg;
+		}
+		return &cmg.cmodels[handle];
+	}
+	if ( handle == BOX_MODEL_HANDLE ) 
+	{
+		if (clipMap)
+		{
+			*clipMap = &cmg;
+		}
+		return &box_model;
+	}
+
+	count = cmg.numSubModels;
+	for(i = 0; i < NumSubBSP; i++)
+	{
+		if (handle < count + SubBSP[i].numSubModels)
+		{
+			if (clipMap)
+			{
+				*clipMap = &SubBSP[i];
+			}
+			return &SubBSP[i].cmodels[handle - count];
+		}
+		count += SubBSP[i].numSubModels;
+	}
+
+	if ( handle < MAX_SUBMODELS ) 
+	{
+		Com_Error( ERR_DROP, "CM_ClipHandleToModel: bad handle %i < %i < %i", 
+			cmg.numSubModels, handle, MAX_SUBMODELS );
+	}
+	Com_Error( ERR_DROP, "CM_ClipHandleToModel: bad handle %i", handle + MAX_SUBMODELS );
+
+	return NULL;
+}
+
+/*
+==================
+CM_InlineModel
+==================
+*/
+clipHandle_t	CM_InlineModel( int index ) {
+	if ( index < 0 || index >= TotalSubModels )
+	{
+		Com_Error (ERR_DROP, "CM_InlineModel: bad number: %d > %d", index, TotalSubModels);
+	}
+	return index;
+}
+
+int		CM_NumClusters( void ) {
+	return cmg.numClusters;
+}
+
+int		CM_NumInlineModels( void ) {
+	return cmg.numSubModels;
+}
+
+char	*CM_EntityString( void ) {
+	return cmg.entityString;
+}
+
+char *CM_SubBSPEntityString( int index ) 
+{
+	return SubBSP[index].entityString;
+}
+
+int		CM_LeafCluster( int leafnum ) {
+	if (leafnum < 0 || leafnum >= cmg.numLeafs) {
+		Com_Error (ERR_DROP, "CM_LeafCluster: bad number");
+	}
+	return cmg.leafs[leafnum].cluster;
+}
+
+int		CM_LeafArea( int leafnum ) {
+	if ( leafnum < 0 || leafnum >= cmg.numLeafs ) {
+		Com_Error (ERR_DROP, "CM_LeafArea: bad number");
+	}
+	return cmg.leafs[leafnum].area;
+}
+
+//=======================================================================
+
+
+/*
+===================
+CM_InitBoxHull
+
+Set up the planes and nodes so that the six floats of a bounding box
+can just be stored out and get a proper clipping hull structure.
+===================
+*/
+void CM_InitBoxHull (void)
+{
+	int			i;
+	int			side;
+	cplane_t	*p;
+	cbrushside_t	*s;
+
+	box_planes = &cmg.planes[cmg.numPlanes];
+
+	box_brush = &cmg.brushes[cmg.numBrushes];
+	box_brush->numsides = 6;
+	box_brush->sides = cmg.brushsides + cmg.numBrushSides;
+	box_brush->contents = CONTENTS_BODY;
+
+	box_model.firstNode = -1;
+	box_model.leaf.numLeafBrushes = 1;
+//	box_model.leaf.firstLeafBrush = cmg.numBrushes;
+	box_model.leaf.firstLeafBrush = cmg.numLeafBrushes;
+	cmg.leafbrushes[cmg.numLeafBrushes] = cmg.numBrushes;
+
+	for (i=0 ; i<6 ; i++)
+	{
+		side = i&1;
+
+		// brush sides
+		s = &cmg.brushsides[cmg.numBrushSides+i];
+		s->plane = 	cmg.planes + (cmg.numPlanes+i*2+side);
+		s->shaderNum = cmg.numShaders;
+
+		// planes
+		p = &box_planes[i*2];
+		p->type = i>>1;
+		p->signbits = 0;
+		VectorClear (p->normal);
+		p->normal[i>>1] = 1;
+
+		p = &box_planes[i*2+1];
+		p->type = 3 + (i>>1);
+		p->signbits = 0;
+		VectorClear (p->normal);
+		p->normal[i>>1] = -1;
+
+		SetPlaneSignbits( p );
+	}	
+}
+
+/*
+===================
+CM_TempBoxModel
+
+To keep everything totally uniform, bounding boxes are turned into small
+BSP trees instead of being compared directly.
+Capsules are handled differently though.
+===================
+*/
+clipHandle_t CM_TempBoxModel( const vec3_t mins, const vec3_t maxs, int capsule ) {
+
+	VectorCopy( mins, box_model.mins );
+	VectorCopy( maxs, box_model.maxs );
+
+	if ( capsule ) {
+		return CAPSULE_MODEL_HANDLE;
+	}
+
+	box_planes[0].dist = maxs[0];
+	box_planes[1].dist = -maxs[0];
+	box_planes[2].dist = mins[0];
+	box_planes[3].dist = -mins[0];
+	box_planes[4].dist = maxs[1];
+	box_planes[5].dist = -maxs[1];
+	box_planes[6].dist = mins[1];
+	box_planes[7].dist = -mins[1];
+	box_planes[8].dist = maxs[2];
+	box_planes[9].dist = -maxs[2];
+	box_planes[10].dist = mins[2];
+	box_planes[11].dist = -mins[2];
+
+	VectorCopy( mins, box_brush->bounds[0] );
+	VectorCopy( maxs, box_brush->bounds[1] );
+
+	return BOX_MODEL_HANDLE;
+}
+
+/*
+===================
+CM_ModelBounds
+===================
+*/
+void CM_ModelBounds( clipHandle_t model, vec3_t mins, vec3_t maxs ) {
+	cmodel_t	*cmod;
+
+	cmod = CM_ClipHandleToModel( model );
+	VectorCopy( cmod->mins, mins );
+	VectorCopy( cmod->maxs, maxs );
+}
+
+/*
+===================
+CM_RegisterTerrain
+
+Allows physics to examine the terrain data.
+===================
+*/
+#if !defined(BSPC)
+CCMLandScape *CM_RegisterTerrain(const char *config, bool server)
+{
+	CCMLandScape	*ls;
+
+	if(cmg.landScape)
+	{
+		// Already spawned so just return
+		ls = cmg.landScape;
+		ls->IncreaseRefCount();
+		return(ls);
+	}
+	// Doesn't exist so create and link in
+	ls = CM_InitTerrain(config, 0, server);
+
+	// Increment for the next instance
+	if (cmg.landScape)
+	{
+		Com_Error(ERR_DROP, "You cannot have more than one terrain brush.\n");
+	}
+	cmg.landScape = ls;
+	return(ls);
+}
+
+/*
+===================
+CM_ShutdownTerrain
+===================
+*/
+
+void CM_ShutdownTerrain( thandle_t terrainId)
+{
+	CCMLandScape	*landscape;
+
+	landscape = cmg.landScape;
+
+	if (landscape)
+	{
+		landscape->DecreaseRefCount();
+		if(landscape->GetRefCount() <= 0)
+		{
+			delete landscape;
+			cmg.landScape = NULL;
+		}
+	}
+}
+#endif
+
+int CM_LoadSubBSP(const char *name, qboolean clientload)
+{
+	int		i;
+	int		checksum;
+	int		count;
+
+	count = cmg.numSubModels;
+	for(i = 0; i < NumSubBSP; i++)
+	{
+		if (!stricmp(name, SubBSP[i].name))
+		{
+			return count;
+		}
+		count += SubBSP[i].numSubModels;
+	}
+
+	if (NumSubBSP == MAX_SUB_BSP)
+	{
+		Com_Error (ERR_DROP, "CM_LoadSubBSP: too many unique sub BSPs");
+	}
+
+	CM_LoadMap_Actual(name, clientload, &checksum, SubBSP[NumSubBSP] );
+	NumSubBSP++;
+
+	return count;
+}
+
+int CM_FindSubBSP(int modelIndex)
+{
+	int		i;
+	int		count;
+
+	count = cmg.numSubModels;
+	if (modelIndex < count)
+	{	// belongs to the main bsp
+		return -1;
+	}
+
+	for(i = 0; i < NumSubBSP; i++)
+	{
+		count += SubBSP[i].numSubModels;
+		if (modelIndex < count)
+		{
+			return i;
+		}
+	}
+	return -1;
+}
+
+void CM_GetWorldBounds ( vec3_t mins, vec3_t maxs )
+{
+	VectorCopy ( cmg.cmodels[0].mins, mins );
+	VectorCopy ( cmg.cmodels[0].maxs, maxs );
+}
+
+int CM_ModelContents_Actual( clipHandle_t model, clipMap_t *cm ) 
+{
+	cmodel_t	*cmod;
+	int			contents = 0;
+	int			i;
+
+	if (!cm)
+	{
+		cm = &cmg;
+	}
+
+	cmod = CM_ClipHandleToModel( model, &cm );
+
+	//MCG ADDED - return the contents, too
+	if( cmod->leaf.numLeafBrushes )		// check for brush
+	{
+		int brushNum;
+		for ( i = cmod->leaf.firstLeafBrush; i < cmod->leaf.firstLeafBrush+cmod->leaf.numLeafBrushes; i++ )
+		{
+			brushNum = cm->leafbrushes[i];
+			contents |= cm->brushes[brushNum].contents;
+		}
+	}
+	if( cmod->leaf.numLeafSurfaces )	// if not brush, check for patch
+	{	
+		int surfaceNum;
+		for ( i = cmod->leaf.firstLeafSurface; i < cmod->leaf.firstLeafSurface+cmod->leaf.numLeafSurfaces; i++ )
+		{
+			surfaceNum = cm->leafsurfaces[i];
+			if ( cm->surfaces[surfaceNum] != NULL )
+			{//HERNH?  How could we have a null surf within our cmod->leaf.numLeafSurfaces?
+				contents |= cm->surfaces[surfaceNum]->contents;
+			}
+		}
+	}
+	return contents;
+}
+
+int CM_ModelContents(  clipHandle_t model, int subBSPIndex )
+{
+	if (subBSPIndex < 0)
+	{
+		return CM_ModelContents_Actual(model, NULL);
+	}
+
+	return CM_ModelContents_Actual(model, &SubBSP[subBSPIndex]);
+}
diff --git a/codemp/qcommon/cm_load_xbox.cpp b/codemp/qcommon/cm_load_xbox.cpp
new file mode 100644
index 0000000..c3f05c9
--- /dev/null
+++ b/codemp/qcommon/cm_load_xbox.cpp
@@ -0,0 +1,1127 @@
+// cmodel.c -- model loading
+#include "../qcommon/exe_headers.h"
+
+#include "cm_local.h"
+#include "cm_landscape.h" //rwwRMG - include
+#include "cm_patch.h"
+#include "../rmg/rm_headers.h" //rwwRMG - include
+
+#include "sparc.h"
+#include "../zlib/zlib.h"
+
+static SPARC<byte> visData;
+
+void *SparcAllocator(unsigned int size)
+{
+	return Z_Malloc(size, TAG_BSP, false);
+}
+
+void SparcDeallocator(void *ptr)
+{
+	Z_Free(ptr);
+}
+
+
+void CM_LoadShaderText(bool forceReload);
+
+#ifdef BSPC
+
+#include "../bspc/l_qfiles.h"
+
+void SetPlaneSignbits (cplane_t *out) {
+	int	bits, j;
+
+	// for fast box on planeside test
+	bits = 0;
+	for (j=0 ; j<3 ; j++) {
+		if (out->normal[j] < 0) {
+			bits |= 1<<j;
+		}
+	}
+	out->signbits = bits;
+}
+#endif //BSPC
+
+// to allow boxes to be treated as brush models, we allocate
+// some extra indexes along with those needed by the map
+#define	BOX_BRUSHES		1
+#define	BOX_SIDES		6
+#define	BOX_LEAFS		2
+#define	BOX_PLANES		12
+
+#define	LL(x) x=LittleLong(x)
+
+clipMap_t	cmg;
+int			c_pointcontents;
+int			c_traces, c_brush_traces, c_patch_traces;
+
+
+byte		*cmod_base;
+
+#ifndef BSPC
+cvar_t		*cm_noAreas;
+cvar_t		*cm_noCurves;
+cvar_t		*cm_playerCurveClip;
+#endif
+
+cmodel_t	box_model;
+cplane_t	*box_planes;
+cbrush_t	*box_brush;
+
+
+
+void	CM_InitBoxHull (void);
+void	CM_FloodAreaConnections (void);
+
+clipMap_t	SubBSP[MAX_SUB_BSP];
+int			NumSubBSP, TotalSubModels;
+
+/*
+===============================================================================
+
+					MAP LOADING
+
+===============================================================================
+*/
+
+/*
+=================
+CMod_LoadShaders
+=================
+*/
+void CMod_LoadShaders( void *data, int len ) {
+	dshader_t	*in;
+	int			i, count;
+	CCMShader	*out;
+
+	in = (dshader_t *)(data);
+	if (len % sizeof(*in)) {
+		Com_Error (ERR_DROP, "CMod_LoadShaders: funny lump size");
+	}
+	count = len / sizeof(*in);
+
+	if (count < 1) {
+		Com_Error (ERR_DROP, "Map with no shaders");
+	}
+	cmg.shaders = (CCMShader *)Hunk_Alloc( (1+count) * sizeof( *cmg.shaders ), h_high );
+	cmg.numShaders = count;
+
+	out = cmg.shaders;
+	for ( i = 0; i < count; i++, in++, out++ ) 
+	{
+		Q_strncpyz(out->shader, in->shader, MAX_QPATH);
+		out->contentFlags = in->contentFlags;
+		out->surfaceFlags = in->surfaceFlags;
+	}
+}
+
+
+/*
+=================
+CMod_LoadSubmodels
+=================
+*/
+void CMod_LoadSubmodels( void *data, int len ) {
+	dmodel_t	*in;
+	cmodel_t	*out;
+	int			i, j, count;
+	int			*indexes;
+
+	in = (dmodel_t *)(data);
+	if (len % sizeof(*in))
+		Com_Error (ERR_DROP, "CMod_LoadSubmodels: funny lump size");
+	count = len / sizeof(*in);
+
+	if (count < 1) {
+		Com_Error (ERR_DROP, "Map with no models");
+	}
+
+	if ( count > MAX_SUBMODELS ) {
+		Com_Error( ERR_DROP, "MAX_SUBMODELS (%d) exceeded by %d", MAX_SUBMODELS, count-MAX_SUBMODELS );
+	}
+
+	cmg.cmodels = (struct cmodel_s *)Hunk_Alloc( count * sizeof( *cmg.cmodels ), h_high );
+	cmg.numSubModels = count;
+
+	for ( i=0 ; i<count ; i++, in++, out++)
+	{
+		out = &cmg.cmodels[i];
+
+		for (j=0 ; j<3 ; j++)
+		{	// spread the mins / maxs by a pixel
+			out->mins[j] = in->mins[j] - 1;
+			out->maxs[j] = in->maxs[j] + 1;
+		}
+
+		if ( i == 0 ) {
+			out->firstNode = 0;
+			continue;	// world model doesn't need other info
+		}
+
+		out->firstNode = -1;
+
+		// make a "leaf" just to hold the model's brushes and surfaces
+		out->leaf.numLeafBrushes = in->numBrushes;
+		indexes = (int *)Hunk_Alloc( out->leaf.numLeafBrushes * 4, h_high );
+		out->leaf.firstLeafBrush = indexes - cmg.leafbrushes;
+		for ( j = 0 ; j < out->leaf.numLeafBrushes ; j++ ) {
+			indexes[j] = in->firstBrush + j;
+		}
+
+		out->leaf.numLeafSurfaces = in->numSurfaces;
+		indexes = (int *)Hunk_Alloc( out->leaf.numLeafSurfaces * 4, h_high );
+		out->leaf.firstLeafSurface = indexes - cmg.leafsurfaces;
+		for ( j = 0 ; j < out->leaf.numLeafSurfaces ; j++ ) {
+			indexes[j] = in->firstSurface + j;
+		}
+	}
+}
+
+/*
+=================
+CMod_LoadNodes
+
+=================
+*/
+void CMod_LoadNodes( void *data, int len ) {
+	dnode_t		*in;
+	cNode_t		*out;
+	int			i, count;
+	
+	in = (dnode_t *)(data);
+	if (len % sizeof(*in))
+		Com_Error (ERR_DROP, "MOD_LoadBmodel: funny lump size");
+	count = len / sizeof(*in);
+
+	if (count < 1)
+		Com_Error (ERR_DROP, "Map has no nodes");
+	cmg.nodes = (cNode_t *)Hunk_Alloc( count * sizeof( *cmg.nodes ), h_high );
+	cmg.numNodes = count;
+
+	out = cmg.nodes;
+
+	for (i=0 ; i<count ; i++, out++, in++)
+	{
+		out->planeNum = in->planeNum;
+		out->children[0] = in->children[0];
+		out->children[1] = in->children[1];
+	}
+}
+
+/*
+=================
+CM_BoundBrush
+
+=================
+*/
+void CM_BoundBrush( cbrush_t *b ) {
+	b->bounds[0][0] = -cmg.planes[b->sides[0].planeNum.GetValue()].dist;
+	b->bounds[1][0] = cmg.planes[b->sides[1].planeNum.GetValue()].dist;
+
+	b->bounds[0][1] = -cmg.planes[b->sides[2].planeNum.GetValue()].dist;
+	b->bounds[1][1] = cmg.planes[b->sides[3].planeNum.GetValue()].dist;
+
+	b->bounds[0][2] = -cmg.planes[b->sides[4].planeNum.GetValue()].dist;
+	b->bounds[1][2] = cmg.planes[b->sides[5].planeNum.GetValue()].dist;
+}
+
+
+/*
+=================
+CMod_LoadBrushes
+
+=================
+*/
+void CMod_LoadBrushes( void *data, int len ) {
+	dbrush_t	*in;
+	cbrush_t	*out;
+	int			i, count;
+
+	in = (dbrush_t *)(data);
+	if (len % sizeof(*in)) {
+		Com_Error (ERR_DROP, "MOD_LoadBmodel: funny lump size");
+	}
+	count = len / sizeof(*in);
+
+	cmg.brushes = (cbrush_t *)Hunk_Alloc( ( BOX_BRUSHES + count ) * sizeof( *cmg.brushes ), h_high );
+	cmg.numBrushes = count;
+
+	out = cmg.brushes;
+
+	for ( i=0 ; i<count ; i++, out++, in++ ) {
+		out->sides = cmg.brushsides + in->firstSide;
+		out->numsides = in->numSides;
+
+		out->shaderNum = in->shaderNum;
+		if ( out->shaderNum < 0 || out->shaderNum >= cmg.numShaders ) {
+			Com_Error( ERR_DROP, "CMod_LoadBrushes: bad shaderNum: %i", out->shaderNum );
+		}
+		out->contents = cmg.shaders[out->shaderNum].contentFlags;
+		
+		CM_BoundBrush( out );
+	}
+
+}
+
+/*
+=================
+CMod_LoadLeafs
+=================
+*/
+void CMod_LoadLeafs (void *data, int len)
+{
+	int			i;
+	cLeaf_t		*out;
+	dleaf_t 	*in;
+	int			count;
+	
+	in = (dleaf_t *)(data);
+	if (len % sizeof(*in))
+		Com_Error (ERR_DROP, "MOD_LoadBmodel: funny lump size");
+	count = len / sizeof(*in);
+
+	if (count < 1)
+		Com_Error (ERR_DROP, "Map with no leafs");
+
+	cmg.leafs = (cLeaf_t *)Hunk_Alloc( ( BOX_LEAFS + count ) * sizeof( *cmg.leafs ), h_high );
+	cmg.numLeafs = count;
+	out = cmg.leafs;	
+
+	for ( i=0 ; i<count ; i++, in++, out++)
+	{
+		out->cluster = in->cluster;
+		out->area = in->area;
+		out->firstLeafBrush = in->firstLeafBrush;
+		out->numLeafBrushes = in->numLeafBrushes;
+		out->firstLeafSurface = in->firstLeafSurface;
+		out->numLeafSurfaces = in->numLeafSurfaces;
+
+		if (out->cluster >= cmg.numClusters)
+			cmg.numClusters = out->cluster + 1;
+		if (out->area >= cmg.numAreas)
+			cmg.numAreas = out->area + 1;
+	}
+
+	cmg.areas = (cArea_t *)Hunk_Alloc( cmg.numAreas * sizeof( *cmg.areas ), h_high );
+	cmg.areaPortals = (int *)Hunk_Alloc( cmg.numAreas * cmg.numAreas * sizeof( *cmg.areaPortals ), h_high );
+}
+
+/*
+=================
+CMod_LoadPlanes
+=================
+*/
+void CMod_LoadPlanes (void *data, int len)
+{
+	int			i, j;
+	cplane_t	*out;
+	dplane_t 	*in;
+	int			count;
+	int			bits;
+	
+	in = (dplane_t *)(data);
+	if (len % sizeof(*in))
+		Com_Error (ERR_DROP, "MOD_LoadBmodel: funny lump size");
+	count = len / sizeof(*in);
+
+	if (count < 1)
+		Com_Error (ERR_DROP, "Map with no planes");
+	cmg.planes = (struct cplane_s *)Hunk_Alloc( ( BOX_PLANES + count ) * sizeof( *cmg.planes ), h_high );
+	cmg.numPlanes = count;
+
+	out = cmg.planes;	
+
+	for ( i=0 ; i<count ; i++, in++, out++)
+	{
+		bits = 0;
+		for (j=0 ; j<3 ; j++)
+		{
+			out->normal[j] = in->normal[j];
+			if (out->normal[j] < 0)
+				bits |= 1<<j;
+		}
+
+		out->dist = in->dist;
+		out->type = PlaneTypeForNormal( out->normal );
+		out->signbits = bits;
+	}
+}
+
+/*
+=================
+CMod_LoadLeafBrushes
+=================
+*/
+void CMod_LoadLeafBrushes (void *data, int len)
+{
+	int			*out;
+	int		 	*in;
+	int			count;
+	
+	in = (int *)(data);
+	if (len % sizeof(*in))
+		Com_Error (ERR_DROP, "MOD_LoadBmodel: funny lump size");
+	count = len / sizeof(*in);
+
+	cmg.leafbrushes = (int *)Hunk_Alloc( (count + BOX_BRUSHES) * sizeof( *cmg.leafbrushes ), h_high );
+	cmg.numLeafBrushes = count;
+
+	out = cmg.leafbrushes;
+
+	memcpy(out, in, len);
+}
+
+
+void CMod_LoadLeafSurfaces( void *data, int len )
+{
+	int			i;
+	int			*out;
+	int		 	*in;
+	int			count;
+	
+	in = (int *)(data);
+	if (len % sizeof(*in))
+		Com_Error (ERR_DROP, "MOD_LoadBmodel: funny lump size");
+	count = len / sizeof(*in);
+
+	cmg.leafsurfaces = (int *)Hunk_Alloc( count * sizeof( *cmg.leafsurfaces ), h_high );
+	cmg.numLeafSurfaces = count;
+
+	out = cmg.leafsurfaces;
+
+	memcpy(out, in, len);
+}
+
+/*
+=================
+CMod_LoadBrushSides
+=================
+*/
+void CMod_LoadBrushSides (void *data, int len)
+{
+	int				i;
+	cbrushside_t	*out;
+	dbrushside_t 	*in;
+	int				count;
+
+	in = (dbrushside_t *)(data);
+	if ( len % sizeof(*in) ) {
+		Com_Error (ERR_DROP, "MOD_LoadBmodel: funny lump size");
+	}
+	count = len / sizeof(*in);
+
+	cmg.brushsides = (cbrushside_t *)Hunk_Alloc( ( BOX_SIDES + count ) * sizeof( *cmg.brushsides ), h_high );
+	cmg.numBrushSides = count;
+
+	out = cmg.brushsides;	
+
+	for ( i=0 ; i<count ; i++, in++, out++) {
+		out->planeNum = in->planeNum;
+		assert(in->planeNum == out->planeNum.GetValue());
+
+		out->shaderNum = in->shaderNum;
+		if ( out->shaderNum < 0 || out->shaderNum >= cmg.numShaders ) {
+			Com_Error( ERR_DROP, "CMod_LoadBrushSides: bad shaderNum: %i", out->shaderNum );
+		}
+	}
+}
+
+
+/*
+=================
+CMod_LoadEntityString
+=================
+*/
+void CMod_LoadEntityString( void *data, int len ) {
+	cmg.entityString = (char *)Hunk_Alloc( len, h_high );
+	cmg.numEntityChars = len;
+	memcpy (cmg.entityString, data, len);
+}
+
+/*
+=================
+CMod_LoadVisibility
+=================
+*/
+void RE_SetWorldVisData( SPARC<byte> *vis );
+
+#define	VIS_HEADER	8
+void CMod_LoadVisibility( void *data, int len ) {
+	char	*buf;
+
+	if ( !len ) {
+		cmg.visibility = NULL;
+		return;
+	}
+	buf = (char*)data;
+
+	visData.SetAllocator(SparcAllocator, SparcDeallocator);
+
+	cmg.vised = qtrue;
+	cmg.numClusters = ((int *)buf)[0];
+	cmg.clusterBytes = ((int *)buf)[1];
+	visData.Load(buf + VIS_HEADER, len - VIS_HEADER);
+	cmg.visibility = &visData;
+	RE_SetWorldVisData(&visData);
+}
+
+//==================================================================
+
+
+/*
+=================
+CMod_LoadPatches
+=================
+*/
+#define	MAX_PATCH_VERTS		1024
+
+void CMod_LoadPatches( void *verts, int vertlen, void *surfaces, int surfacelen, int numsurfs ) {
+	mapVert_t	*dv, *dv_p;
+	dpatch_t	*in;
+	int			count;
+	int			i, j;
+	int			c;
+	cPatch_t	*patch;
+	vec3_t		points[MAX_PATCH_VERTS];
+	int			width, height;
+	int			shaderNum;
+
+	count = surfacelen / sizeof(*in);
+
+	cmg.numSurfaces = numsurfs;
+	cmg.surfaces = (cPatch_t **)Hunk_Alloc( cmg.numSurfaces * sizeof( cmg.surfaces[0] ), h_high );
+
+	dv = (mapVert_t *)(verts);
+	if (vertlen % sizeof(*dv))
+		Com_Error (ERR_DROP, "MOD_LoadBmodel: funny lump size");
+
+	unsigned char* patchScratch = (unsigned char*)Z_Malloc( sizeof( *patch ) * count, TAG_BSP, qtrue);
+	
+	extern void CM_GridAlloc();
+	extern void CM_PatchCollideFromGridTempAlloc();
+	extern void CM_PreparePatchCollide(int num);
+	extern void CM_TempPatchPlanesAlloc();
+	CM_GridAlloc();
+	CM_PatchCollideFromGridTempAlloc();
+	CM_PreparePatchCollide(count);
+	CM_TempPatchPlanesAlloc();
+
+	facetLoad_t *facetbuf = (facetLoad_t*)Z_Malloc(
+		MAX_PATCH_PLANES*sizeof(facetLoad_t), TAG_TEMP_WORKSPACE, qfalse);
+	
+	int *gridbuf = (int*)Z_Malloc(
+		CM_MAX_GRID_SIZE*CM_MAX_GRID_SIZE*2*sizeof(int), TAG_TEMP_WORKSPACE, qfalse);
+
+	for ( i = 0 ; i < count ; i++) {
+		in = (dpatch_t *)surfaces + i;
+
+		cmg.surfaces[ in->code ] = patch = (cPatch_t *) patchScratch;
+		patchScratch += sizeof( *patch );
+
+		// load the full drawverts onto the stack
+		width = in->patchWidth;
+		height = in->patchHeight;
+		c = width * height;
+		if ( c > MAX_PATCH_VERTS ) {
+			Com_Error( ERR_DROP, "ParseMesh: MAX_PATCH_VERTS" );
+		}
+
+		dv_p = dv + (in->verts >> 12);
+		for ( j = 0 ; j < c ; j++, dv_p++ ) {
+			points[j][0] = dv_p->xyz[0];
+			points[j][1] = dv_p->xyz[1];
+			points[j][2] = dv_p->xyz[2];
+		}
+
+		shaderNum = in->shaderNum;
+		patch->contents = cmg.shaders[shaderNum].contentFlags;
+		patch->surfaceFlags = cmg.shaders[shaderNum].surfaceFlags;
+
+		// create the internal facet structure
+		patch->pc = CM_GeneratePatchCollide( width, height, points, facetbuf, gridbuf );
+	}
+
+	extern void CM_GridDealloc();
+	extern void CM_PatchCollideFromGridTempDealloc();
+	extern void CM_TempPatchPlanesDealloc();
+	CM_PatchCollideFromGridTempDealloc();
+	CM_GridDealloc();
+	CM_TempPatchPlanesDealloc();
+
+	Z_Free(gridbuf);
+	Z_Free(facetbuf);
+}
+
+
+/*
+==================
+CM_LoadMap
+
+Loads in the map and all submodels
+==================
+*/
+void *gpvCachedMapDiskImage = NULL;
+char  gsCachedMapDiskImage[MAX_QPATH];
+qboolean gbUsingCachedMapDataRightNow = qfalse;	// if true, signifies that you can't delete this at the moment!! (used during z_malloc()-fail recovery attempt)
+
+// called in response to a "devmapbsp blah" or "devmapall blah" command, do NOT use inside CM_Load unless you pass in qtrue
+//
+// new bool return used to see if anything was freed, used during z_malloc failure re-try
+//
+qboolean CM_DeleteCachedMap(qboolean bGuaranteedOkToDelete)
+{
+	qboolean bActuallyFreedSomething = qfalse;
+
+	if (bGuaranteedOkToDelete || !gbUsingCachedMapDataRightNow)
+	{
+		// dump cached disk image...
+		//
+		if (gpvCachedMapDiskImage)
+		{
+			Z_Free(	gpvCachedMapDiskImage );
+					gpvCachedMapDiskImage = NULL;
+
+			bActuallyFreedSomething = qtrue;
+		}
+		gsCachedMapDiskImage[0] = '\0';
+		
+		// force map loader to ignore cached internal BSP structures for next level CM_LoadMap() call...
+		//
+		cmg.name[0] = '\0';
+	}
+
+	return bActuallyFreedSomething;
+}
+
+void CM_Free(void) 
+{
+	CM_ClearLevelPatches();
+	visData.Release();
+	Z_TagFree(TAG_BSP);
+}
+
+
+static void CM_LoadMap_Actual( const char *name, qboolean clientload, int *checksum ) {
+	const int		*buf = NULL;
+	const int		*surfBuf = NULL;
+	static unsigned	last_checksum;
+	char			lmName[MAX_QPATH];
+	char			stripName[MAX_QPATH];
+	Lump			outputLump;
+
+	if ( !name || !name[0] ) {
+		Com_Error( ERR_DROP, "CM_LoadMap: NULL name" );
+	}
+
+#ifndef BSPC
+	cm_noAreas = Cvar_Get ("cm_noAreas", "0", CVAR_CHEAT);
+	cm_noCurves = Cvar_Get ("cm_noCurves", "0", CVAR_CHEAT);
+	cm_playerCurveClip = Cvar_Get ("cm_playerCurveClip", "1", CVAR_ARCHIVE|CVAR_CHEAT );
+#endif
+	Com_DPrintf( "CM_LoadMap( %s, %i )\n", name, clientload );
+
+	if ( !strcmp( cmg.name, name ) && clientload ) {
+		*checksum = last_checksum;
+		return;
+	}
+
+	CM_ClearMap();
+	CM_ClearLevelPatches();
+
+	// free old stuff
+	memset( &cmg, 0, sizeof( cmg ) );
+	
+	if ( !name[0] ) {
+		cmg.numLeafs = 1; 
+		cmg.numClusters = 1;
+		cmg.numAreas = 1;
+		cmg.cmodels = (struct cmodel_s *) Z_Malloc( sizeof( *cmg.cmodels ), TAG_BSP, qtrue );
+		*checksum = 0;
+		return;
+	}
+	
+	last_checksum = crc32(0, (const Bytef *)name, strlen(name));
+	COM_StripExtension(name, stripName);
+
+	// load into heap
+	outputLump.load(stripName, "shaders");
+	CMod_LoadShaders( outputLump.data, outputLump.len );
+
+	outputLump.load(stripName, "leafs");
+	CMod_LoadLeafs (outputLump.data, outputLump.len);
+
+	outputLump.load(stripName, "leafbrushes");
+	CMod_LoadLeafBrushes (outputLump.data, outputLump.len);
+
+	outputLump.load(stripName, "leafsurfaces");
+	CMod_LoadLeafSurfaces (outputLump.data, outputLump.len);
+
+	outputLump.load(stripName, "planes");
+	CMod_LoadPlanes (outputLump.data, outputLump.len);
+
+	outputLump.load(stripName, "brushsides");
+	CMod_LoadBrushSides (outputLump.data, outputLump.len);
+
+	outputLump.load(stripName, "brushes");
+	CMod_LoadBrushes (outputLump.data, outputLump.len);
+
+	outputLump.load(stripName, "models");
+	CMod_LoadSubmodels (outputLump.data, outputLump.len);
+
+	outputLump.load(stripName, "nodes");
+	CMod_LoadNodes (outputLump.data, outputLump.len);
+
+	outputLump.load(stripName, "entities");
+	CMod_LoadEntityString (outputLump.data, outputLump.len);
+
+	outputLump.load(stripName, "visibility");
+	CMod_LoadVisibility( outputLump.data, outputLump.len);
+	
+	Lump misc;
+	misc.load(stripName, "misc");
+		
+	int num_surfs = *(int*)misc.data;
+	misc.clear();
+
+	Lump verts;
+	verts.load(stripName, "verts");
+
+	Lump patches;
+	patches.load(stripName, "patches");
+	CMod_LoadPatches(verts.data, verts.len, patches.data, patches.len, num_surfs );
+	patches.clear();
+
+	TotalSubModels += cmg.numSubModels;
+	
+#if !defined(BSPC)
+	CM_LoadShaderText(qfalse);
+#endif
+	CM_InitBoxHull ();
+#if !defined(BSPC)
+	CM_SetupShaderProperties();
+#endif
+
+	*checksum = last_checksum;	
+
+	// do this whether or not the map was cached from last load...
+	//
+	CM_FloodAreaConnections ();
+
+	// allow this to be cached if it is loaded by the server
+	if ( !clientload ) {
+		Q_strncpyz( cmg.name, name, sizeof( cmg.name ) );
+	}
+}
+
+// need a wrapper function around this because of multiple returns, need to ensure bool is correct...
+//
+void CM_LoadMap( const char *name, qboolean clientload, int *checksum )
+{
+	CM_LoadMap_Actual( name, clientload, checksum );
+}
+
+
+/*
+==================
+CM_ClearMap
+==================
+*/
+void CM_ClearMap( void ) 
+{
+	int		i;
+
+#if !defined(BSPC)
+	CM_ShutdownShaderProperties();
+//	MAT_Shutdown();
+#endif
+
+	if (TheRandomMissionManager)
+	{
+		delete TheRandomMissionManager;
+		TheRandomMissionManager = 0;
+	}
+
+	if (cmg.landScape)
+	{
+		delete cmg.landScape;
+		cmg.landScape = 0;
+	}
+
+	Com_Memset( &cmg, 0, sizeof( cmg ) );
+	CM_ClearLevelPatches();
+
+	for(i = 0; i < NumSubBSP; i++)
+	{
+		memset(&SubBSP[i], 0, sizeof(SubBSP[0]));
+	}
+	NumSubBSP = 0;
+	TotalSubModels = 0;
+}
+
+/*
+==================
+CM_ClipHandleToModel
+==================
+*/
+cmodel_t	*CM_ClipHandleToModel( clipHandle_t handle, clipMap_t **clipMap )
+{
+	int		i;
+	int		count;
+
+	if ( handle < 0 ) 
+	{
+		Com_Error( ERR_DROP, "CM_ClipHandleToModel: bad handle %i", handle );
+	}
+	if ( handle < cmg.numSubModels ) 
+	{
+		if (clipMap)
+		{
+			*clipMap = &cmg;
+		}
+		return &cmg.cmodels[handle];
+	}
+	if ( handle == BOX_MODEL_HANDLE ) 
+	{
+		if (clipMap)
+		{
+			*clipMap = &cmg;
+		}
+		return &box_model;
+	}
+
+	count = cmg.numSubModels;
+	for(i = 0; i < NumSubBSP; i++)
+	{
+		if (handle < count + SubBSP[i].numSubModels)
+		{
+			if (clipMap)
+			{
+				*clipMap = &SubBSP[i];
+			}
+			return &SubBSP[i].cmodels[handle - count];
+		}
+		count += SubBSP[i].numSubModels;
+	}
+
+	if ( handle < MAX_SUBMODELS ) 
+	{
+		Com_Error( ERR_DROP, "CM_ClipHandleToModel: bad handle %i < %i < %i", 
+			cmg.numSubModels, handle, MAX_SUBMODELS );
+	}
+	Com_Error( ERR_DROP, "CM_ClipHandleToModel: bad handle %i", handle + MAX_SUBMODELS );
+
+	return NULL;
+}
+/*
+==================
+CM_InlineModel
+==================
+*/
+clipHandle_t	CM_InlineModel( int index ) {
+	if ( index < 0 || index >= TotalSubModels ) {
+		Com_Error (ERR_DROP, "CM_InlineModel: bad number (may need to re-BSP map?)");
+	}
+	return index;
+}
+
+int		CM_NumClusters( void ) {
+	return cmg.numClusters;
+}
+
+int		CM_NumInlineModels( void ) {
+	return cmg.numSubModels;
+}
+
+char	*CM_EntityString( void ) {
+	return cmg.entityString;
+}
+
+char *CM_SubBSPEntityString( int index ) 
+{
+	return SubBSP[index].entityString;
+}
+
+int		CM_LeafCluster( int leafnum ) {
+	if (leafnum < 0 || leafnum >= cmg.numLeafs) {
+		Com_Error (ERR_DROP, "CM_LeafCluster: bad number");
+	}
+	return cmg.leafs[leafnum].cluster;
+}
+
+int		CM_LeafArea( int leafnum ) {
+	if ( leafnum < 0 || leafnum >= cmg.numLeafs ) {
+		Com_Error (ERR_DROP, "CM_LeafArea: bad number");
+	}
+	return cmg.leafs[leafnum].area;
+}
+
+//=======================================================================
+
+
+/*
+===================
+CM_InitBoxHull
+
+Set up the planes and nodes so that the six floats of a bounding box
+can just be stored out and get a proper clipping hull structure.
+===================
+*/
+void CM_InitBoxHull (void)
+{
+	int			i;
+	int			side;
+	cplane_t	*p;
+	cbrushside_t	*s;
+
+	box_planes = &cmg.planes[cmg.numPlanes];
+
+	box_brush = &cmg.brushes[cmg.numBrushes];
+	box_brush->numsides = 6;
+	box_brush->sides = cmg.brushsides + cmg.numBrushSides;
+	box_brush->contents = CONTENTS_BODY;
+
+	box_model.firstNode = -1;
+	box_model.leaf.numLeafBrushes = 1;
+//	box_model.leaf.firstLeafBrush = cmg.numBrushes;
+	box_model.leaf.firstLeafBrush = cmg.numLeafBrushes;
+	cmg.leafbrushes[cmg.numLeafBrushes] = cmg.numBrushes;
+
+	for (i=0 ; i<6 ; i++)
+	{
+		side = i&1;
+
+		// brush sides
+		s = &cmg.brushsides[cmg.numBrushSides+i];
+		s->planeNum = cmg.numPlanes+i*2+side;
+		s->shaderNum = cmg.numShaders;
+
+		// planes
+		p = &box_planes[i*2];
+		p->type = i>>1;
+		p->signbits = 0;
+		VectorClear (p->normal);
+		p->normal[i>>1] = 1;
+
+		p = &box_planes[i*2+1];
+		p->type = 3 + (i>>1);
+		p->signbits = 0;
+		VectorClear (p->normal);
+		p->normal[i>>1] = -1;
+
+		SetPlaneSignbits( p );
+	}	
+}
+
+
+
+/*
+===================
+CM_HeadnodeForBox
+
+To keep everything totally uniform, bounding boxes are turned into small
+BSP trees instead of being compared directly.
+===================
+*/
+clipHandle_t CM_TempBoxModel( const vec3_t mins, const vec3_t maxs, int capsule ) {
+	VectorCopy( mins, box_model.mins );
+	VectorCopy( maxs, box_model.maxs );
+
+	if ( capsule ) {
+		return CAPSULE_MODEL_HANDLE;
+	}
+
+	box_planes[0].dist = maxs[0];
+	box_planes[1].dist = -maxs[0];
+	box_planes[2].dist = mins[0];
+	box_planes[3].dist = -mins[0];
+	box_planes[4].dist = maxs[1];
+	box_planes[5].dist = -maxs[1];
+	box_planes[6].dist = mins[1];
+	box_planes[7].dist = -mins[1];
+	box_planes[8].dist = maxs[2];
+	box_planes[9].dist = -maxs[2];
+	box_planes[10].dist = mins[2];
+	box_planes[11].dist = -mins[2];
+
+	VectorCopy( mins, box_brush->bounds[0] );
+	VectorCopy( maxs, box_brush->bounds[1] );
+
+	return BOX_MODEL_HANDLE;
+}
+
+
+
+/*
+===================
+CM_ModelBounds
+===================
+*/
+void CM_ModelBounds( clipHandle_t model, vec3_t mins, vec3_t maxs ) {
+	cmodel_t	*cmod;
+
+	cmod = CM_ClipHandleToModel( model );
+	VectorCopy( cmod->mins, mins );
+	VectorCopy( cmod->maxs, maxs );
+}
+
+/*
+===================
+CM_RegisterTerrain
+
+Allows physics to examine the terrain data.
+===================
+*/
+#if !defined(BSPC)
+CCMLandScape *CM_RegisterTerrain(const char *config, bool server)
+{
+	CCMLandScape	*ls;
+
+	if(cmg.landScape)
+	{
+		// Already spawned so just return
+		ls = cmg.landScape;
+		ls->IncreaseRefCount();
+		return(ls);
+	}
+	// Doesn't exist so create and link in
+	ls = CM_InitTerrain(config, 0, server);
+
+	// Increment for the next instance
+	if (cmg.landScape)
+	{
+		Com_Error(ERR_DROP, "You cannot have more than one terrain brush.\n");
+	}
+	cmg.landScape = ls;
+	return(ls);
+}
+
+/*
+===================
+CM_ShutdownTerrain
+===================
+*/
+
+void CM_ShutdownTerrain( thandle_t terrainId)
+{
+	CCMLandScape	*landscape;
+
+	landscape = cmg.landScape;
+	if (landscape)
+	{
+		landscape->DecreaseRefCount();
+		if(landscape->GetRefCount() <= 0)
+		{
+			delete landscape;
+			cmg.landScape = NULL;
+		}
+	}
+}
+#endif
+
+int CM_LoadSubBSP(const char *name, qboolean clientload)
+{
+	int		i;
+	int		checksum;
+	int		count;
+
+	count = cmg.numSubModels;
+	for(i = 0; i < NumSubBSP; i++)
+	{
+		if (!stricmp(name, SubBSP[i].name))
+		{
+			return count;
+		}
+		count += SubBSP[i].numSubModels;
+	}
+
+	if (NumSubBSP == MAX_SUB_BSP)
+	{
+		Com_Error (ERR_DROP, "CM_LoadSubBSP: too many unique sub BSPs");
+	}
+
+#ifdef _XBOX
+	assert(0); // MATT! - testing now - fix this later!
+#else
+	CM_LoadMap_Actual( name, clientload, &checksum, SubBSP[NumSubBSP] );
+#endif
+	NumSubBSP++;
+
+	return count;
+}
+
+int CM_FindSubBSP(int modelIndex)
+{
+	int		i;
+	int		count;
+
+	count = cmg.numSubModels;
+	if (modelIndex < count)
+	{	// belongs to the main bsp
+		return -1;
+	}
+
+	for(i = 0; i < NumSubBSP; i++)
+	{
+		count += SubBSP[i].numSubModels;
+		if (modelIndex < count)
+		{
+			return i;
+		}
+	}
+	return -1;
+}
+
+void CM_GetWorldBounds ( vec3_t mins, vec3_t maxs )
+{
+	VectorCopy ( cmg.cmodels[0].mins, mins );
+	VectorCopy ( cmg.cmodels[0].maxs, maxs );
+}
+
+int CM_ModelContents_Actual( clipHandle_t model, clipMap_t *cm ) 
+{
+	cmodel_t	*cmod;
+	int			contents = 0;
+	int			i;
+
+	if (!cm)
+	{
+		cm = &cmg;
+	}
+
+	cmod = CM_ClipHandleToModel( model, &cm );
+
+	//MCG ADDED - return the contents, too
+	if( cmod->leaf.numLeafBrushes )		// check for brush
+	{
+		int brushNum;
+		for ( i = cmod->leaf.firstLeafBrush; i < cmod->leaf.firstLeafBrush+cmod->leaf.numLeafBrushes; i++ )
+		{
+			brushNum = cm->leafbrushes[i];
+			contents |= cm->brushes[brushNum].contents;
+		}
+	}
+	if( cmod->leaf.numLeafSurfaces )	// if not brush, check for patch
+	{	
+		int surfaceNum;
+		for ( i = cmod->leaf.firstLeafSurface; i < cmod->leaf.firstLeafSurface+cmod->leaf.numLeafSurfaces; i++ )
+		{
+			surfaceNum = cm->leafsurfaces[i];
+			if ( cm->surfaces[surfaceNum] != NULL )
+			{//HERNH?  How could we have a null surf within our cmod->leaf.numLeafSurfaces?
+				contents |= cm->surfaces[surfaceNum]->contents;
+			}
+		}
+	}
+	return contents;
+}
+
+int CM_ModelContents(  clipHandle_t model, int subBSPIndex )
+{
+	if (subBSPIndex < 0)
+	{
+		return CM_ModelContents_Actual(model, NULL);
+	}
+
+	return CM_ModelContents_Actual(model, &SubBSP[subBSPIndex]);
+}
+
diff --git a/codemp/qcommon/cm_local.h b/codemp/qcommon/cm_local.h
new file mode 100644
index 0000000..f97a97e
--- /dev/null
+++ b/codemp/qcommon/cm_local.h
@@ -0,0 +1,310 @@
+#pragma once
+#if !defined(CM_LOCAL_H_INC)
+#define CM_LOCAL_H_INC //rwwRMG - include guard
+
+#include "cm_polylib.h"
+#include "cm_landscape.h" //rwwRMG - include
+
+#ifdef _XBOX
+#include "sparc.h"
+#endif
+
+#define	MAX_SUBMODELS			512
+#define	BOX_MODEL_HANDLE		(MAX_SUBMODELS-1)
+#define CAPSULE_MODEL_HANDLE	(MAX_SUBMODELS-2)
+
+
+#ifdef _XBOX
+#pragma pack(push, 1)
+typedef struct {
+	int			planeNum;
+	short		children[2];		// negative numbers are leafs
+} cNode_t;
+#pragma pack(pop)
+
+#else // _XBOX
+
+typedef struct {
+	cplane_t	*plane;
+	int			children[2];		// negative numbers are leafs
+} cNode_t;
+
+#endif // _XBOX
+
+typedef struct {
+	int			cluster;
+	int			area;
+
+	int			firstLeafBrush;
+	int			numLeafBrushes;
+
+	int			firstLeafSurface;
+	int			numLeafSurfaces;
+} cLeaf_t;
+
+typedef struct cmodel_s {
+	vec3_t		mins, maxs;
+	cLeaf_t		leaf;			// submodels don't reference the main tree
+	int			firstNode;		// only for cmodel[0] (for the main and bsp instances)
+} cmodel_t;
+
+#ifdef _XBOX
+#pragma pack (push, 1)
+typedef struct cbrushside_s {
+	NotSoShort planeNum;
+	unsigned char	shaderNum;
+} cbrushside_t;
+#pragma pack(pop)
+
+#else // _XBOX
+
+typedef struct cbrushside_s {
+	cplane_t	*plane;
+	int			shaderNum;
+} cbrushside_t;
+
+#endif // _XBOX
+
+typedef struct cbrush_s {
+	int					shaderNum;		// the shader that determined the contents
+	int					contents;
+	vec3_t				bounds[2];
+	cbrushside_t		*sides;
+	unsigned short		numsides;
+	unsigned short		checkcount;		// to avoid repeated testings
+} cbrush_t;
+
+class CCMShader
+{
+public:
+	char		shader[MAX_QPATH];
+	class CCMShader	*mNext;
+	int			surfaceFlags;
+	int			contentFlags;
+
+	const char	*GetName(void) const { return(shader); }
+	class CCMShader *GetNext(void) const { return(mNext); }
+	void	SetNext(class CCMShader *next) { mNext = next; }
+	void	Destroy(void) { }
+};
+
+typedef struct {
+	int			checkcount;				// to avoid repeated testings
+	int			surfaceFlags;
+	int			contents;
+	struct patchCollide_s	*pc;
+} cPatch_t;
+
+
+typedef struct {
+	int			floodnum;
+	int			floodvalid;
+} cArea_t;
+
+#ifdef _XBOX
+template <class T>
+class SPARC;
+typedef struct {
+	char		name[MAX_QPATH];
+
+	int			numShaders;
+	CCMShader	*shaders;
+
+	int			numBrushSides;
+	cbrushside_t *brushsides;
+
+	int			numPlanes;
+	cplane_t	*planes;
+
+	int			numNodes;
+	cNode_t		*nodes;
+
+	int			numLeafs;
+	cLeaf_t		*leafs;
+
+	int			numLeafBrushes;
+	int			*leafbrushes;
+
+	int			numLeafSurfaces;
+	int			*leafsurfaces;
+
+	int			numSubModels;
+	cmodel_t	*cmodels;
+
+	int			numBrushes;
+	cbrush_t	*brushes;
+
+	int			numClusters;
+	int			clusterBytes;
+	SPARC<byte>	*visibility;
+	qboolean	vised;			// if false, visibility is just a single cluster of ffs
+
+	int			numEntityChars;
+	char		*entityString;
+
+	int			numAreas;
+	cArea_t		*areas;
+	int			*areaPortals;	// [ numAreas*numAreas ] reference counts
+
+	int			numSurfaces;
+	cPatch_t	**surfaces;			// non-patches will be NULL
+
+	int			floodvalid;
+	int			checkcount;					// incremented on each trace
+
+	CCMLandScape	*landScape;
+	qboolean	haswater;
+} clipMap_t;
+
+#else // _XBOX
+
+typedef struct {
+	char		name[MAX_QPATH];
+
+	int			numShaders;
+	CCMShader	*shaders;
+
+	int			numBrushSides;
+	cbrushside_t *brushsides;
+
+	int			numPlanes;
+	cplane_t	*planes;
+
+	int			numNodes;
+	cNode_t		*nodes;
+
+	int			numLeafs;
+	cLeaf_t		*leafs;
+
+	int			numLeafBrushes;
+	int			*leafbrushes;
+
+	int			numLeafSurfaces;
+	int			*leafsurfaces;
+
+	int			numSubModels;
+	cmodel_t	*cmodels;
+
+	int			numBrushes;
+	cbrush_t	*brushes;
+
+	int			numClusters;
+	int			clusterBytes;
+	byte		*visibility;
+	qboolean	vised;			// if false, visibility is just a single cluster of ffs
+
+	int			numEntityChars;
+	char		*entityString;
+
+	int			numAreas;
+	cArea_t		*areas;
+	int			*areaPortals;	// [ numAreas*numAreas ] reference counts
+
+	int			numSurfaces;
+	cPatch_t	**surfaces;			// non-patches will be NULL
+
+	int			floodvalid;
+	int			checkcount;					// incremented on each trace
+
+	//rwwRMG - added:
+	CCMLandScape	*landScape;
+} clipMap_t;
+
+#endif // _XBOX
+
+
+// keep 1/8 unit away to keep the position valid before network snapping
+// and to avoid various numeric issues
+#define	SURFACE_CLIP_EPSILON	(0.125)
+
+extern	clipMap_t	cmg; //rwwRMG - changed from cm
+extern	int			c_pointcontents;
+extern	int			c_traces, c_brush_traces, c_patch_traces;
+extern	cvar_t		*cm_noAreas;
+extern	cvar_t		*cm_noCurves;
+extern	cvar_t		*cm_playerCurveClip;
+
+// cm_test.c
+
+// Used for oriented capsule collision detection
+typedef struct
+{
+	qboolean	use;
+	float		radius;
+	float		halfheight;
+	vec3_t		offset;
+} sphere_t;
+
+typedef struct traceWork_s { //rwwRMG - modified
+	vec3_t		start;
+	vec3_t		end;
+	vec3_t		size[2];	// size of the box being swept through the model
+	vec3_t		offsets[8];	// [signbits][x] = either size[0][x] or size[1][x]
+	float		maxOffset;	// longest corner length from origin
+	vec3_t		extents;	// greatest of abs(size[0]) and abs(size[1])
+	vec3_t		modelOrigin;// origin of the model tracing through
+	int			contents;	// ored contents of the model tracing through
+	qboolean	isPoint;	// optimized case
+//	trace_t		trace;		// returned from trace call
+	sphere_t	sphere;		// sphere for oriendted capsule collision
+
+	//rwwRMG - added:
+	vec3pair_t		bounds;			// enclosing box of start and end surrounding by size
+	vec3pair_t		localBounds;	// enclosing box of start and end surrounding by size for a segment
+
+	float			baseEnterFrac;	// global enter fraction (before processing subsections of the brush)	
+	float			baseLeaveFrac;	// global leave fraction (before processing subsections of the brush)	
+	float			enterFrac;		// fraction where the ray enters the brush
+	float			leaveFrac;		// fraction where the ray leaves the brush
+	cbrushside_t	*leadside;
+	cplane_t		*clipplane;
+	bool			startout;
+	bool			getout;
+
+} traceWork_t;
+
+typedef struct leafList_s {
+	int		count;
+	int		maxcount;
+	qboolean	overflowed;
+	int		*list;
+	vec3_t	bounds[2];
+	int		lastLeaf;		// for overflows where each leaf can't be stored individually
+	void	(*storeLeafs)( struct leafList_s *ll, int nodenum );
+} leafList_t;
+
+
+int CM_BoxBrushes( const vec3_t mins, const vec3_t maxs, cbrush_t **boxList, int listsize );
+//rwwRMG - changed to boxList to not conflict with list type
+
+bool CM_CullWorldBox (const cplane_t *frustum, const vec3pair_t bounds); //rwwRMG - added
+
+void CM_StoreLeafs( leafList_t *ll, int nodenum );
+void CM_StoreBrushes( leafList_t *ll, int nodenum );
+
+void CM_BoxLeafnums_r( leafList_t *ll, int nodenum );
+
+cmodel_t	*CM_ClipHandleToModel( clipHandle_t handle, clipMap_t **clipMap = 0 );
+
+// cm_patch.c
+
+struct patchCollide_s	*CM_GeneratePatchCollide( int width, int height, vec3_t *points );
+void CM_TraceThroughPatchCollide( traceWork_t *tw, trace_t &trace, const struct patchCollide_s *pc );
+qboolean CM_PositionTestInPatchCollide( traceWork_t *tw, const struct patchCollide_s *pc );
+void CM_ClearLevelPatches( void );
+
+//rwwRMG - added
+CCMLandScape *CM_RegisterTerrain(const char *config, bool server);
+void CM_ShutdownTerrain( thandle_t terrainId );
+
+// cm_shader.cpp
+void CM_SetupShaderProperties( void );
+void CM_ShutdownShaderProperties(void);
+CCMShader *CM_GetShaderInfo( const char *name );
+CCMShader *CM_GetShaderInfo( int shaderNum );
+void		CM_GetModelFormalName ( const char* model, const char* skin, char* name, int size );
+
+// cm_load.cpp
+void CM_GetWorldBounds ( vec3_t mins, vec3_t maxs );
+
+#endif
diff --git a/codemp/qcommon/cm_patch.cpp b/codemp/qcommon/cm_patch.cpp
new file mode 100644
index 0000000..48f4847
--- /dev/null
+++ b/codemp/qcommon/cm_patch.cpp
@@ -0,0 +1,1809 @@
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+#include "cm_local.h"
+#include "cm_patch.h"
+
+/*
+
+This file does not reference any globals, and has these entry points:
+
+void CM_ClearLevelPatches( void );
+struct patchCollide_s	*CM_GeneratePatchCollide( int width, int height, const vec3_t *points );
+void CM_TraceThroughPatchCollide( traceWork_t *tw, const struct patchCollide_s *pc );
+qboolean CM_PositionTestInPatchCollide( traceWork_t *tw, const struct patchCollide_s *pc );
+void CM_DrawDebugSurface( void (*drawPoly)(int color, int numPoints, flaot *points) );
+
+
+Issues for collision against curved surfaces:
+
+Surface edges need to be handled differently than surface planes
+
+Plane expansion causes raw surfaces to expand past expanded bounding box
+
+Position test of a volume against a surface is tricky.
+
+Position test of a point against a surface is not well defined, because the surface has no volume.
+
+
+Tracing leading edge points instead of volumes?
+Position test by tracing corner to corner? (8*7 traces -- ouch)
+
+coplanar edges
+triangulated patches
+degenerate patches
+
+  endcaps
+  degenerate
+
+WARNING: this may misbehave with meshes that have rows or columns that only
+degenerate a few triangles.  Completely degenerate rows and columns are handled
+properly.
+*/
+
+/*
+#define	MAX_FACETS			1024
+#define	MAX_PATCH_PLANES	2048
+
+typedef struct {
+	float	plane[4];
+	int		signbits;		// signx + (signy<<1) + (signz<<2), used as lookup during collision
+} patchPlane_t;
+
+typedef struct {
+	int			surfacePlane;
+	int			numBorders;		// 3 or four + 6 axial bevels + 4 or 3 * 4 edge bevels
+	int			borderPlanes[4+6+16];
+	int			borderInward[4+6+16];
+	qboolean	borderNoAdjust[4+6+16];
+} facet_t;
+
+typedef struct patchCollide_s {
+	vec3_t	bounds[2];
+	int		numPlanes;			// surface planes plus edge planes
+	patchPlane_t	*planes;
+	int		numFacets;
+	facet_t	*facets;
+} patchCollide_t;
+
+
+#define	MAX_GRID_SIZE	129
+
+typedef struct {
+	int			width;
+	int			height;
+	qboolean	wrapWidth;
+	qboolean	wrapHeight;
+	vec3_t	points[MAX_GRID_SIZE][MAX_GRID_SIZE];	// [width][height]
+} cGrid_t;
+
+#define	SUBDIVIDE_DISTANCE	16	//4	// never more than this units away from curve
+#define	PLANE_TRI_EPSILON	0.1
+#define	WRAP_POINT_EPSILON	0.1
+*/
+
+int	c_totalPatchBlocks;
+int	c_totalPatchSurfaces;
+int	c_totalPatchEdges;
+
+static const patchCollide_t	*debugPatchCollide;
+static const facet_t		*debugFacet;
+static qboolean		debugBlock;
+static vec3_t		debugBlockPoints[4];
+
+#if defined(BSPC)
+extern void *Hunk_Alloc( int size );
+
+static void *Hunk_Alloc( int size, ha_pref preference )
+{
+	return Hunk_Alloc( size );
+}
+#endif
+
+/*
+=================
+CM_ClearLevelPatches
+=================
+*/
+void CM_ClearLevelPatches( void ) {
+	debugPatchCollide = NULL;
+	debugFacet = NULL;
+}
+
+/*
+=================
+CM_SignbitsForNormal
+=================
+*/
+static inline int CM_SignbitsForNormal( vec3_t normal ) {
+	int	bits, j;
+
+	bits = 0;
+	for (j=0 ; j<3 ; j++) {
+		if ( normal[j] < 0 ) {
+			bits |= 1<<j;
+		}
+	}
+	return bits;
+}
+
+/*
+=====================
+CM_PlaneFromPoints
+
+Returns false if the triangle is degenrate.
+The normal will point out of the clock for clockwise ordered points
+=====================
+*/
+static inline qboolean CM_PlaneFromPoints( vec4_t plane, vec3_t a, vec3_t b, vec3_t c ) {
+	vec3_t	d1, d2;
+
+	VectorSubtract( b, a, d1 );
+	VectorSubtract( c, a, d2 );
+	CrossProduct( d2, d1, plane );
+	if ( VectorNormalize( plane ) == 0 ) {
+		return qfalse;
+	}
+
+	plane[3] = DotProduct( a, plane );
+	return qtrue;
+}
+
+
+/*
+================================================================================
+
+GRID SUBDIVISION
+
+================================================================================
+*/
+
+/*
+=================
+CM_NeedsSubdivision
+
+Returns true if the given quadratic curve is not flat enough for our
+collision detection purposes
+=================
+*/
+static qboolean	CM_NeedsSubdivision( vec3_t a, vec3_t b, vec3_t c ) {
+	vec3_t		cmid;
+	vec3_t		lmid;
+	vec3_t		delta;
+	float		dist;
+	int			i;
+
+	// calculate the linear midpoint
+	for ( i = 0 ; i < 3 ; i++ ) {
+		lmid[i] = 0.5*(a[i] + c[i]);
+	}
+
+	// calculate the exact curve midpoint
+	for ( i = 0 ; i < 3 ; i++ ) {
+		cmid[i] = 0.5 * ( 0.5*(a[i] + b[i]) + 0.5*(b[i] + c[i]) );
+	}
+
+	// see if the curve is far enough away from the linear mid
+	VectorSubtract( cmid, lmid, delta );
+	dist = VectorLengthSquared( delta );
+	
+	return (qboolean)(dist >= SUBDIVIDE_DISTANCE * SUBDIVIDE_DISTANCE);
+}
+
+/*
+===============
+CM_Subdivide
+
+a, b, and c are control points.
+the subdivided sequence will be: a, out1, out2, out3, c
+===============
+*/
+static void CM_Subdivide( vec3_t a, vec3_t b, vec3_t c, vec3_t out1, vec3_t out2, vec3_t out3 ) {
+	int		i;
+
+	for ( i = 0 ; i < 3 ; i++ ) {
+		out1[i] = 0.5 * (a[i] + b[i]);
+		out3[i] = 0.5 * (b[i] + c[i]);
+		out2[i] = 0.5 * (out1[i] + out3[i]);
+	}
+}
+
+/*
+=================
+CM_TransposeGrid
+
+Swaps the rows and columns in place
+=================
+*/
+static void CM_TransposeGrid( cGrid_t *grid ) {
+	int			i, j, l;
+	vec3_t		temp;
+	qboolean	tempWrap;
+
+	if ( grid->width > grid->height ) {
+		for ( i = 0 ; i < grid->height ; i++ ) {
+			for ( j = i + 1 ; j < grid->width ; j++ ) {
+				if ( j < grid->height ) {
+					// swap the value
+					VectorCopy( grid->points[i][j], temp );
+					VectorCopy( grid->points[j][i], grid->points[i][j] );
+					VectorCopy( temp, grid->points[j][i] );
+				} else {
+					// just copy
+					VectorCopy( grid->points[j][i], grid->points[i][j] );
+				}
+			}
+		}
+	} else {
+		for ( i = 0 ; i < grid->width ; i++ ) {
+			for ( j = i + 1 ; j < grid->height ; j++ ) {
+				if ( j < grid->width ) {
+					// swap the value
+					VectorCopy( grid->points[j][i], temp );
+					VectorCopy( grid->points[i][j], grid->points[j][i] );
+					VectorCopy( temp, grid->points[i][j] );
+				} else {
+					// just copy
+					VectorCopy( grid->points[i][j], grid->points[j][i] );
+				}
+			}
+		}
+	}
+
+	l = grid->width;
+	grid->width = grid->height;
+	grid->height = l;
+
+	tempWrap = grid->wrapWidth;
+	grid->wrapWidth = grid->wrapHeight;
+	grid->wrapHeight = tempWrap;
+}
+
+/*
+===================
+CM_SetGridWrapWidth
+
+If the left and right columns are exactly equal, set grid->wrapWidth qtrue
+===================
+*/
+static void CM_SetGridWrapWidth( cGrid_t *grid ) {
+	int		i, j;
+	float	d;
+
+	for ( i = 0 ; i < grid->height ; i++ ) {
+		for ( j = 0 ; j < 3 ; j++ ) {
+			d = grid->points[0][i][j] - grid->points[grid->width-1][i][j];
+			if ( d < -WRAP_POINT_EPSILON || d > WRAP_POINT_EPSILON ) {
+				break;
+			}
+		}
+		if ( j != 3 ) {
+			break;
+		}
+	}
+	if ( i == grid->height ) {
+		grid->wrapWidth = qtrue;
+	} else {
+		grid->wrapWidth = qfalse;
+	}
+}
+
+
+/*
+=================
+CM_SubdivideGridColumns
+
+Adds columns as necessary to the grid until
+all the aproximating points are within SUBDIVIDE_DISTANCE
+from the true curve
+=================
+*/
+static void CM_SubdivideGridColumns( cGrid_t *grid ) {
+	int		i, j, k;
+
+	for ( i = 0 ; i < grid->width - 2 ;  ) {
+		// grid->points[i][x] is an interpolating control point
+		// grid->points[i+1][x] is an aproximating control point
+		// grid->points[i+2][x] is an interpolating control point
+
+		//
+		// first see if we can collapse the aproximating collumn away
+		//
+		for ( j = 0 ; j < grid->height ; j++ ) {
+			if ( CM_NeedsSubdivision( grid->points[i][j], grid->points[i+1][j], grid->points[i+2][j] ) ) {
+				break;
+			}
+		}
+		if ( j == grid->height ) {
+			// all of the points were close enough to the linear midpoints
+			// that we can collapse the entire column away
+			for ( j = 0 ; j < grid->height ; j++ ) {
+				// remove the column
+				for ( k = i + 2 ; k < grid->width ; k++ ) {
+					VectorCopy( grid->points[k][j], grid->points[k-1][j] );
+				}
+			}
+
+			grid->width--;
+
+			// go to the next curve segment
+			i++;
+			continue;
+		}
+
+		//
+		// we need to subdivide the curve
+		//
+		for ( j = 0 ; j < grid->height ; j++ ) {
+			vec3_t	prev, mid, next;
+
+			// save the control points now
+			VectorCopy( grid->points[i][j], prev );
+			VectorCopy( grid->points[i+1][j], mid );
+			VectorCopy( grid->points[i+2][j], next );
+
+			// make room for two additional columns in the grid
+			// columns i+1 will be replaced, column i+2 will become i+4
+			// i+1, i+2, and i+3 will be generated
+			for ( k = grid->width - 1 ; k > i + 1 ; k-- ) {
+				VectorCopy( grid->points[k][j], grid->points[k+2][j] );
+			}
+
+			// generate the subdivided points
+			CM_Subdivide( prev, mid, next, grid->points[i+1][j], grid->points[i+2][j], grid->points[i+3][j] );
+		}
+
+		grid->width += 2;
+
+		// the new aproximating point at i+1 may need to be removed
+		// or subdivided farther, so don't advance i
+	}
+}
+
+
+/*
+======================
+CM_ComparePoints
+======================
+*/
+#define	POINT_EPSILON	0.1
+static qboolean CM_ComparePoints( float *a, float *b ) {
+	float		d;
+
+	d = a[0] - b[0];
+	if ( d < -POINT_EPSILON || d > POINT_EPSILON ) {
+		return qfalse;
+	}
+	d = a[1] - b[1];
+	if ( d < -POINT_EPSILON || d > POINT_EPSILON ) {
+		return qfalse;
+	}
+	d = a[2] - b[2];
+	if ( d < -POINT_EPSILON || d > POINT_EPSILON ) {
+		return qfalse;
+	}
+	return qtrue;
+}
+
+/*
+=================
+CM_RemoveDegenerateColumns
+
+If there are any identical columns, remove them
+=================
+*/
+static void CM_RemoveDegenerateColumns( cGrid_t *grid ) {
+	int		i, j, k;
+
+	for ( i = 0 ; i < grid->width - 1 ; i++ ) {
+		for ( j = 0 ; j < grid->height ; j++ ) {
+			if ( !CM_ComparePoints( grid->points[i][j], grid->points[i+1][j] ) ) {
+				break;
+			}
+		}
+
+		if ( j != grid->height ) {
+			continue;	// not degenerate
+		}
+
+		for ( j = 0 ; j < grid->height ; j++ ) {
+			// remove the column
+			for ( k = i + 2 ; k < grid->width ; k++ ) {
+				VectorCopy( grid->points[k][j], grid->points[k-1][j] );
+			}
+		}
+		grid->width--;
+
+		// check against the next column
+		i--;
+	}
+}
+
+/*
+================================================================================
+
+PATCH COLLIDE GENERATION
+
+================================================================================
+*/
+
+static	int				numPlanes;
+static	patchPlane_t	planes[MAX_PATCH_PLANES];
+
+//static	int				numFacets;
+//static	facet_t			facets[MAX_PATCH_PLANES]; //maybe MAX_FACETS ??
+static		facet_t			*facets = NULL;
+
+#define	NORMAL_EPSILON	0.0001
+#define	DIST_EPSILON	0.02
+
+static inline int CM_PlaneEqual(patchPlane_t *p, float plane[4], int *flipped) {
+	float invplane[4];
+
+	if (
+	   Q_fabs(p->plane[0] - plane[0]) < NORMAL_EPSILON
+	&& Q_fabs(p->plane[1] - plane[1]) < NORMAL_EPSILON
+	&& Q_fabs(p->plane[2] - plane[2]) < NORMAL_EPSILON
+	&& Q_fabs(p->plane[3] - plane[3]) < DIST_EPSILON )
+	{
+		*flipped = qfalse;
+		return qtrue;
+	}
+
+	VectorNegate(plane, invplane);
+	invplane[3] = -plane[3];
+
+	if (
+	   Q_fabs(p->plane[0] - invplane[0]) < NORMAL_EPSILON
+	&& Q_fabs(p->plane[1] - invplane[1]) < NORMAL_EPSILON
+	&& Q_fabs(p->plane[2] - invplane[2]) < NORMAL_EPSILON
+	&& Q_fabs(p->plane[3] - invplane[3]) < DIST_EPSILON )
+	{
+		*flipped = qtrue;
+		return qtrue;
+	}
+
+	return qfalse;
+}
+
+static inline void CM_SnapVector(vec3_t normal) {
+	int		i;
+
+	for (i=0 ; i<3 ; i++)
+	{
+		if ( Q_fabs(normal[i] - 1) < NORMAL_EPSILON )
+		{
+			VectorClear (normal);
+			normal[i] = 1;
+			break;
+		}
+		if ( Q_fabs(normal[i] - -1) < NORMAL_EPSILON )
+		{
+			VectorClear (normal);
+			normal[i] = -1;
+			break;
+		}
+	}
+}
+
+static inline int CM_FindPlane2(float plane[4], int *flipped) {
+	int i;
+
+	// see if the points are close enough to an existing plane
+	for ( i = 0 ; i < numPlanes ; i++ ) {
+		if (CM_PlaneEqual(&planes[i], plane, flipped)) return i;
+	}
+
+	// add a new plane
+	if ( numPlanes == MAX_PATCH_PLANES ) {
+		Com_Error( ERR_DROP, "MAX_PATCH_PLANES" );
+	}
+
+	Vector4Copy( plane, planes[numPlanes].plane );
+	planes[numPlanes].signbits = CM_SignbitsForNormal( plane );
+
+	numPlanes++;
+
+	*flipped = qfalse;
+
+	return numPlanes-1;
+}
+
+/*
+==================
+CM_FindPlane
+==================
+*/
+static inline int CM_FindPlane( float *p1, float *p2, float *p3 ) {
+	float	plane[4];
+	int		i;
+	float	d;
+
+	if ( !CM_PlaneFromPoints( plane, p1, p2, p3 ) ) {
+		return -1;
+	}
+
+	// see if the points are close enough to an existing plane
+	for ( i = 0 ; i < numPlanes ; i++ ) {
+		if ( DotProduct( plane, planes[i].plane ) < 0 ) {
+			continue;	// allow backwards planes?
+		}
+
+		d = DotProduct( p1, planes[i].plane ) - planes[i].plane[3];
+		if ( d < -PLANE_TRI_EPSILON || d > PLANE_TRI_EPSILON ) {
+			continue;
+		}
+
+		d = DotProduct( p2, planes[i].plane ) - planes[i].plane[3];
+		if ( d < -PLANE_TRI_EPSILON || d > PLANE_TRI_EPSILON ) {
+			continue;
+		}
+
+		d = DotProduct( p3, planes[i].plane ) - planes[i].plane[3];
+		if ( d < -PLANE_TRI_EPSILON || d > PLANE_TRI_EPSILON ) {
+			continue;
+		}
+
+		// found it
+		return i;
+	}
+
+	// add a new plane
+	if ( numPlanes == MAX_PATCH_PLANES ) {
+		Com_Error( ERR_DROP, "MAX_PATCH_PLANES" );
+	}
+
+	Vector4Copy( plane, planes[numPlanes].plane );
+	planes[numPlanes].signbits = CM_SignbitsForNormal( plane );
+
+	numPlanes++;
+
+	return numPlanes-1;
+}
+
+
+/*
+==================
+CM_PointOnPlaneSide
+==================
+*/
+static inline int CM_PointOnPlaneSide( float *p, int planeNum ) {
+	float	*plane;
+	float	d;
+
+	if ( planeNum == -1 ) {
+		return SIDE_ON;
+	}
+	plane = planes[ planeNum ].plane;
+
+	d = DotProduct( p, plane ) - plane[3];
+
+	if ( d > PLANE_TRI_EPSILON ) {
+		return SIDE_FRONT;
+	}
+
+	if ( d < -PLANE_TRI_EPSILON ) {
+		return SIDE_BACK;
+	}
+
+	return SIDE_ON;
+}
+
+static inline int	CM_GridPlane( int gridPlanes[MAX_GRID_SIZE][MAX_GRID_SIZE][2], int i, int j, int tri ) {
+	int		p;
+
+	p = gridPlanes[i][j][tri];
+	if ( p != -1 ) {
+		return p;
+	}
+	p = gridPlanes[i][j][!tri];
+	if ( p != -1 ) {
+		return p;
+	}
+
+	// should never happen
+	Com_Printf( "WARNING: CM_GridPlane unresolvable\n" );
+	return -1;
+}
+
+
+/*
+==================
+CM_EdgePlaneNum
+==================
+*/
+static inline int CM_EdgePlaneNum( cGrid_t *grid, int gridPlanes[MAX_GRID_SIZE][MAX_GRID_SIZE][2], int i, int j, int k ) {
+	float	*p1, *p2;
+	vec3_t		up;
+	int			p;
+
+	switch ( k ) {
+	case 0:	// top border
+		p1 = grid->points[i][j];
+		p2 = grid->points[i+1][j];
+		p = CM_GridPlane( gridPlanes, i, j, 0 );
+		VectorMA( p1, 4, planes[ p ].plane, up );
+		return CM_FindPlane( p1, p2, up );
+
+	case 2:	// bottom border
+		p1 = grid->points[i][j+1];
+		p2 = grid->points[i+1][j+1];
+		p = CM_GridPlane( gridPlanes, i, j, 1 );
+		VectorMA( p1, 4, planes[ p ].plane, up );
+		return CM_FindPlane( p2, p1, up );
+
+	case 3: // left border
+		p1 = grid->points[i][j];
+		p2 = grid->points[i][j+1];
+		p = CM_GridPlane( gridPlanes, i, j, 1 );
+		VectorMA( p1, 4, planes[ p ].plane, up );
+		return CM_FindPlane( p2, p1, up );
+
+	case 1:	// right border
+		p1 = grid->points[i+1][j];
+		p2 = grid->points[i+1][j+1];
+		p = CM_GridPlane( gridPlanes, i, j, 0 );
+		VectorMA( p1, 4, planes[ p ].plane, up );
+		return CM_FindPlane( p1, p2, up );
+
+	case 4:	// diagonal out of triangle 0
+		p1 = grid->points[i+1][j+1];
+		p2 = grid->points[i][j];
+		p = CM_GridPlane( gridPlanes, i, j, 0 );
+		VectorMA( p1, 4, planes[ p ].plane, up );
+		return CM_FindPlane( p1, p2, up );
+
+	case 5:	// diagonal out of triangle 1
+		p1 = grid->points[i][j];
+		p2 = grid->points[i+1][j+1];
+		p = CM_GridPlane( gridPlanes, i, j, 1 );
+		VectorMA( p1, 4, planes[ p ].plane, up );
+		return CM_FindPlane( p1, p2, up );
+
+	}
+
+	Com_Error( ERR_DROP, "CM_EdgePlaneNum: bad k" );
+	return -1;
+}
+
+
+/*
+===================
+CM_SetBorderInward
+===================
+*/
+static inline void CM_SetBorderInward( facet_t *facet, cGrid_t *grid, int gridPlanes[MAX_GRID_SIZE][MAX_GRID_SIZE][2],
+						  int i, int j, int which ) {
+	int		k, l;
+	float	*points[4];
+	int		numPoints;
+
+	switch ( which ) {
+	case -1:
+		points[0] = grid->points[i][j];
+		points[1] = grid->points[i+1][j];
+		points[2] = grid->points[i+1][j+1];
+		points[3] = grid->points[i][j+1];
+		numPoints = 4;
+		break;
+	case 0:
+		points[0] = grid->points[i][j];
+		points[1] = grid->points[i+1][j];
+		points[2] = grid->points[i+1][j+1];
+		numPoints = 3;
+		break;
+	case 1:
+		points[0] = grid->points[i+1][j+1];
+		points[1] = grid->points[i][j+1];
+		points[2] = grid->points[i][j];
+		numPoints = 3;
+		break;
+	default:
+		Com_Error( ERR_FATAL, "CM_SetBorderInward: bad parameter" );
+		numPoints = 0;
+		break;
+	}
+
+	for ( k = 0 ; k < facet->numBorders ; k++ ) {
+		int		front, back;
+
+		front = 0;
+		back = 0;
+
+		for ( l = 0 ; l < numPoints ; l++ ) {
+			int		side;
+
+			side = CM_PointOnPlaneSide( points[l], facet->borderPlanes[k] );
+			if ( side == SIDE_FRONT ) {
+				front++;
+			} if ( side == SIDE_BACK ) {
+				back++;
+			}
+		}
+
+		if ( front && !back ) {
+			facet->borderInward[k] = qtrue;
+		} else if ( back && !front ) {
+			facet->borderInward[k] = qfalse;
+		} else if ( !front && !back ) {
+			// flat side border
+			facet->borderPlanes[k] = -1;
+		} else {
+			// bisecting side border
+#ifndef BSPC
+			Com_DPrintf( "WARNING: CM_SetBorderInward: mixed plane sides\n" );
+#endif
+			facet->borderInward[k] = qfalse;
+			if ( !debugBlock ) {
+				debugBlock = qtrue;
+				VectorCopy( grid->points[i][j], debugBlockPoints[0] );
+				VectorCopy( grid->points[i+1][j], debugBlockPoints[1] );
+				VectorCopy( grid->points[i+1][j+1], debugBlockPoints[2] );
+				VectorCopy( grid->points[i][j+1], debugBlockPoints[3] );
+			}
+		}
+	}
+}
+
+/*
+==================
+CM_ValidateFacet
+
+If the facet isn't bounded by its borders, we screwed up.
+==================
+*/
+static inline qboolean CM_ValidateFacet( facet_t *facet ) {
+	float		plane[4];
+	int			j;
+	winding_t	*w;
+	vec3_t		bounds[2];
+
+	if ( facet->surfacePlane == -1 ) {
+		return qfalse;
+	}
+
+	Vector4Copy( planes[ facet->surfacePlane ].plane, plane );
+	w = BaseWindingForPlane( plane,  plane[3] );
+	for ( j = 0 ; j < facet->numBorders && w ; j++ ) {
+		if ( facet->borderPlanes[j] == -1 ) {
+			FreeWinding(w);
+			return qfalse;
+		}
+		Vector4Copy( planes[ facet->borderPlanes[j] ].plane, plane );
+		if ( !facet->borderInward[j] ) {
+			VectorSubtract( vec3_origin, plane, plane );
+			plane[3] = -plane[3];
+		}
+		ChopWindingInPlace( &w, plane, plane[3], 0.1f );
+	}
+
+	if ( !w ) {
+		return qfalse;		// winding was completely chopped away
+	}
+
+	// see if the facet is unreasonably large
+	WindingBounds( w, bounds[0], bounds[1] );
+	FreeWinding( w );
+	
+	for ( j = 0 ; j < 3 ; j++ ) {
+		if ( bounds[1][j] - bounds[0][j] > MAX_MAP_BOUNDS ) {
+			return qfalse;		// we must be missing a plane
+		}
+		if ( bounds[0][j] >= MAX_MAP_BOUNDS ) {
+			return qfalse;
+		}
+		if ( bounds[1][j] <= -MAX_MAP_BOUNDS ) {
+			return qfalse;
+		}
+	}
+	return qtrue;		// winding is fine
+}
+
+/*
+==================
+CM_AddFacetBevels
+==================
+*/
+static inline void CM_AddFacetBevels( facet_t *facet ) {
+
+	int i, j, k, l;
+	int axis, dir, order, flipped;
+	float plane[4], d, newplane[4];
+	winding_t *w, *w2;
+	vec3_t mins, maxs, vec, vec2;
+
+	Vector4Copy( planes[ facet->surfacePlane ].plane, plane );
+
+	w = BaseWindingForPlane( plane,  plane[3] );
+	for ( j = 0 ; j < facet->numBorders && w ; j++ ) {
+		if (facet->borderPlanes[j] == facet->surfacePlane) continue;
+		Vector4Copy( planes[ facet->borderPlanes[j] ].plane, plane );
+
+		if ( !facet->borderInward[j] ) {
+			VectorSubtract( vec3_origin, plane, plane );
+			plane[3] = -plane[3];
+		}
+
+		ChopWindingInPlace( &w, plane, plane[3], 0.1f );
+	}
+	if ( !w ) {
+		return;
+	}
+
+	WindingBounds(w, mins, maxs);
+
+	// add the axial planes
+	order = 0;
+	for ( axis = 0 ; axis < 3 ; axis++ )
+	{
+		for ( dir = -1 ; dir <= 1 ; dir += 2, order++ )
+		{
+			VectorClear(plane);
+			plane[axis] = dir;
+			if (dir == 1) {
+				plane[3] = maxs[axis];
+			}
+			else {
+				plane[3] = -mins[axis];
+			}
+			//if it's the surface plane
+			if (CM_PlaneEqual(&planes[facet->surfacePlane], plane, &flipped)) {
+				continue;
+			}
+			// see if the plane is allready present
+			for ( i = 0 ; i < facet->numBorders ; i++ ) {
+				if (CM_PlaneEqual(&planes[facet->borderPlanes[i]], plane, &flipped))
+					break;
+			}
+
+			if ( i == facet->numBorders ) {
+				if (facet->numBorders > 4 + 6 + 16) Com_Printf("ERROR: too many bevels\n");
+				facet->borderPlanes[facet->numBorders] = CM_FindPlane2(plane, &flipped);
+				facet->borderNoAdjust[facet->numBorders] = (qboolean)0;
+				facet->borderInward[facet->numBorders] = flipped;
+				facet->numBorders++;
+			}
+		}
+	}
+	//
+	// add the edge bevels
+	//
+	// test the non-axial plane edges
+	for ( j = 0 ; j < w->numpoints ; j++ )
+	{
+		k = (j+1)%w->numpoints;
+		VectorSubtract (w->p[j], w->p[k], vec);
+		//if it's a degenerate edge
+		if (VectorNormalize (vec) < 0.5)
+			continue;
+		CM_SnapVector(vec);
+		for ( k = 0; k < 3 ; k++ )
+			if ( vec[k] == -1 || vec[k] == 1 )
+				break;	// axial
+		if ( k < 3 )
+			continue;	// only test non-axial edges
+
+		// try the six possible slanted axials from this edge
+		for ( axis = 0 ; axis < 3 ; axis++ )
+		{
+			for ( dir = -1 ; dir <= 1 ; dir += 2 )
+			{
+				// construct a plane
+				VectorClear (vec2);
+				vec2[axis] = dir;
+				CrossProduct (vec, vec2, plane);
+				if (VectorNormalize (plane) < 0.5)
+					continue;
+				plane[3] = DotProduct (w->p[j], plane);
+
+				// if all the points of the facet winding are
+				// behind this plane, it is a proper edge bevel
+				for ( l = 0 ; l < w->numpoints ; l++ )
+				{
+					d = DotProduct (w->p[l], plane) - plane[3];
+					if (d > 0.1)
+						break;	// point in front
+				}
+				if ( l < w->numpoints )
+					continue;
+
+				//if it's the surface plane
+				if (CM_PlaneEqual(&planes[facet->surfacePlane], plane, &flipped)) {
+					continue;
+				}
+				// see if the plane is allready present
+				for ( i = 0 ; i < facet->numBorders ; i++ ) {
+					if (CM_PlaneEqual(&planes[facet->borderPlanes[i]], plane, &flipped)) {
+							break;
+					}
+				}
+
+				if ( i == facet->numBorders ) {
+					if (facet->numBorders > 4 + 6 + 16) Com_Printf("ERROR: too many bevels\n");
+					facet->borderPlanes[facet->numBorders] = CM_FindPlane2(plane, &flipped);
+
+					for ( k = 0 ; k < facet->numBorders ; k++ ) {
+						if (facet->borderPlanes[facet->numBorders] ==
+							facet->borderPlanes[k]) Com_Printf("WARNING: bevel plane already used\n");
+					}
+
+					facet->borderNoAdjust[facet->numBorders] = (qboolean)0;
+					facet->borderInward[facet->numBorders] = flipped;
+					//
+					w2 = CopyWinding(w);
+					Vector4Copy(planes[facet->borderPlanes[facet->numBorders]].plane, newplane);
+					if (!facet->borderInward[facet->numBorders])
+					{
+						VectorNegate(newplane, newplane);
+						newplane[3] = -newplane[3];
+					} //end if
+					ChopWindingInPlace( &w2, newplane, newplane[3], 0.1f );
+					if (!w2) {
+#ifndef BSPC
+						Com_DPrintf("WARNING: CM_AddFacetBevels... invalid bevel\n");
+#endif
+						continue;
+					}
+					else {
+						FreeWinding(w2);
+					}
+					//
+					facet->numBorders++;
+					//already got a bevel
+//					break;
+				}
+			}
+		}
+	}
+	FreeWinding( w );
+
+#ifndef BSPC
+	//add opposite plane
+	facet->borderPlanes[facet->numBorders] = facet->surfacePlane;
+	facet->borderNoAdjust[facet->numBorders] = (qboolean)0;
+	facet->borderInward[facet->numBorders] = qtrue;
+	facet->numBorders++;
+#endif //BSPC
+
+}
+
+
+typedef enum {
+	EN_TOP,
+	EN_RIGHT,
+	EN_BOTTOM,
+	EN_LEFT
+} edgeName_t;
+
+/*
+==================
+CM_PatchCollideFromGrid
+==================
+*/
+static inline void CM_PatchCollideFromGrid( cGrid_t *grid, patchCollide_t *pf ) {
+	int				i, j;
+	float			*p1, *p2, *p3;
+	MAC_STATIC int				gridPlanes[MAX_GRID_SIZE][MAX_GRID_SIZE][2];
+	facet_t			*facet;
+	int				borders[4];
+	int				noAdjust[4];
+
+	int numFacets;
+	facets = (facet_t*) Z_Malloc(MAX_FACETS*sizeof(facet_t), TAG_TEMP_WORKSPACE, qfalse, 4);
+
+	numPlanes = 0;
+	numFacets = 0;
+
+	// find the planes for each triangle of the grid
+	for ( i = 0 ; i < grid->width - 1 ; i++ ) {
+		for ( j = 0 ; j < grid->height - 1 ; j++ ) {
+			p1 = grid->points[i][j];
+			p2 = grid->points[i+1][j];
+			p3 = grid->points[i+1][j+1];
+			gridPlanes[i][j][0] = CM_FindPlane( p1, p2, p3 );
+
+			p1 = grid->points[i+1][j+1];
+			p2 = grid->points[i][j+1];
+			p3 = grid->points[i][j];
+			gridPlanes[i][j][1] = CM_FindPlane( p1, p2, p3 );
+		}
+	}
+
+	// create the borders for each facet
+	for ( i = 0 ; i < grid->width - 1 ; i++ ) {
+		for ( j = 0 ; j < grid->height - 1 ; j++ ) {
+			 
+			borders[EN_TOP] = -1;
+			if ( j > 0 ) {
+				borders[EN_TOP] = gridPlanes[i][j-1][1];
+			} else if ( grid->wrapHeight ) {
+				borders[EN_TOP] = gridPlanes[i][grid->height-2][1];
+			} 
+			noAdjust[EN_TOP] = ( borders[EN_TOP] == gridPlanes[i][j][0] );
+			if ( borders[EN_TOP] == -1 || noAdjust[EN_TOP] ) {
+				borders[EN_TOP] = CM_EdgePlaneNum( grid, gridPlanes, i, j, 0 );
+			}
+
+			borders[EN_BOTTOM] = -1;
+			if ( j < grid->height - 2 ) {
+				borders[EN_BOTTOM] = gridPlanes[i][j+1][0];
+			} else if ( grid->wrapHeight ) {
+				borders[EN_BOTTOM] = gridPlanes[i][0][0];
+			}
+			noAdjust[EN_BOTTOM] = ( borders[EN_BOTTOM] == gridPlanes[i][j][1] );
+			if ( borders[EN_BOTTOM] == -1 || noAdjust[EN_BOTTOM] ) {
+				borders[EN_BOTTOM] = CM_EdgePlaneNum( grid, gridPlanes, i, j, 2 );
+			}
+
+			borders[EN_LEFT] = -1;
+			if ( i > 0 ) {
+				borders[EN_LEFT] = gridPlanes[i-1][j][0];
+			} else if ( grid->wrapWidth ) {
+				borders[EN_LEFT] = gridPlanes[grid->width-2][j][0];
+			}
+			noAdjust[EN_LEFT] = ( borders[EN_LEFT] == gridPlanes[i][j][1] );
+			if ( borders[EN_LEFT] == -1 || noAdjust[EN_LEFT] ) {
+				borders[EN_LEFT] = CM_EdgePlaneNum( grid, gridPlanes, i, j, 3 );
+			}
+
+			borders[EN_RIGHT] = -1;
+			if ( i < grid->width - 2 ) {
+				borders[EN_RIGHT] = gridPlanes[i+1][j][1];
+			} else if ( grid->wrapWidth ) {
+				borders[EN_RIGHT] = gridPlanes[0][j][1];
+			}
+			noAdjust[EN_RIGHT] = ( borders[EN_RIGHT] == gridPlanes[i][j][0] );
+			if ( borders[EN_RIGHT] == -1 || noAdjust[EN_RIGHT] ) {
+				borders[EN_RIGHT] = CM_EdgePlaneNum( grid, gridPlanes, i, j, 1 );
+			}
+
+			if ( numFacets == MAX_FACETS ) {
+				Com_Error( ERR_DROP, "MAX_FACETS" );
+			}
+			facet = &facets[numFacets];
+			Com_Memset( facet, 0, sizeof( *facet ) );
+
+			if ( gridPlanes[i][j][0] == gridPlanes[i][j][1] ) {
+				if ( gridPlanes[i][j][0] == -1 ) {
+					continue;		// degenrate
+				}
+				facet->surfacePlane = gridPlanes[i][j][0];
+				facet->numBorders = 4;
+				facet->borderPlanes[0] = borders[EN_TOP];
+				facet->borderNoAdjust[0] = (qboolean)noAdjust[EN_TOP];
+				facet->borderPlanes[1] = borders[EN_RIGHT];
+				facet->borderNoAdjust[1] = (qboolean)noAdjust[EN_RIGHT];
+				facet->borderPlanes[2] = borders[EN_BOTTOM];
+				facet->borderNoAdjust[2] = (qboolean)noAdjust[EN_BOTTOM];
+				facet->borderPlanes[3] = borders[EN_LEFT];
+				facet->borderNoAdjust[3] = (qboolean)noAdjust[EN_LEFT];
+				CM_SetBorderInward( facet, grid, gridPlanes, i, j, -1 );
+				if ( CM_ValidateFacet( facet ) ) {
+					CM_AddFacetBevels( facet );
+					numFacets++;
+				}
+			} else {
+				// two seperate triangles
+				facet->surfacePlane = gridPlanes[i][j][0];
+				facet->numBorders = 3;
+				facet->borderPlanes[0] = borders[EN_TOP];
+				facet->borderNoAdjust[0] = (qboolean)noAdjust[EN_TOP];
+				facet->borderPlanes[1] = borders[EN_RIGHT];
+				facet->borderNoAdjust[1] = (qboolean)noAdjust[EN_RIGHT];
+				facet->borderPlanes[2] = gridPlanes[i][j][1];
+				if ( facet->borderPlanes[2] == -1 ) {
+					facet->borderPlanes[2] = borders[EN_BOTTOM];
+					if ( facet->borderPlanes[2] == -1 ) {
+						facet->borderPlanes[2] = CM_EdgePlaneNum( grid, gridPlanes, i, j, 4 );
+					}
+				}
+ 				CM_SetBorderInward( facet, grid, gridPlanes, i, j, 0 );
+				if ( CM_ValidateFacet( facet ) ) {
+					CM_AddFacetBevels( facet );
+					numFacets++;
+				}
+
+				if ( numFacets == MAX_FACETS ) {
+					Com_Error( ERR_DROP, "MAX_FACETS" );
+				}
+				facet = &facets[numFacets];
+				Com_Memset( facet, 0, sizeof( *facet ) );
+
+				facet->surfacePlane = gridPlanes[i][j][1];
+				facet->numBorders = 3;
+				facet->borderPlanes[0] = borders[EN_BOTTOM];
+				facet->borderNoAdjust[0] = (qboolean)noAdjust[EN_BOTTOM];
+				facet->borderPlanes[1] = borders[EN_LEFT];
+				facet->borderNoAdjust[1] = (qboolean)noAdjust[EN_LEFT];
+				facet->borderPlanes[2] = gridPlanes[i][j][0];
+				if ( facet->borderPlanes[2] == -1 ) {
+					facet->borderPlanes[2] = borders[EN_TOP];
+					if ( facet->borderPlanes[2] == -1 ) {
+						facet->borderPlanes[2] = CM_EdgePlaneNum( grid, gridPlanes, i, j, 5 );
+					}
+				}
+				CM_SetBorderInward( facet, grid, gridPlanes, i, j, 1 );
+				if ( CM_ValidateFacet( facet ) ) {
+					CM_AddFacetBevels( facet );
+					numFacets++;
+				}
+			}
+		}
+	}
+
+	// copy the results out
+	pf->numPlanes = numPlanes;
+	pf->numFacets = numFacets;
+	if (numFacets)
+	{
+		pf->facets = (facet_t *)Hunk_Alloc( numFacets * sizeof( *pf->facets ), h_high );
+		Com_Memcpy( pf->facets, facets, numFacets * sizeof( *pf->facets ) );
+	}
+	else
+	{
+		pf->facets = 0;
+	}
+	pf->planes = (patchPlane_t *)Hunk_Alloc( numPlanes * sizeof( *pf->planes ), h_high );
+	Com_Memcpy( pf->planes, planes, numPlanes * sizeof( *pf->planes ) );
+
+	Z_Free(facets);
+}
+
+
+/*
+===================
+CM_GeneratePatchCollide
+
+Creates an internal structure that will be used to perform
+collision detection with a patch mesh.
+
+Points is packed as concatenated rows.
+===================
+*/
+struct patchCollide_s	*CM_GeneratePatchCollide( int width, int height, vec3_t *points ) {
+	patchCollide_t	*pf;
+	MAC_STATIC cGrid_t			grid;
+	int				i, j;
+
+	if ( width <= 2 || height <= 2 || !points ) {
+		Com_Error( ERR_DROP, "CM_GeneratePatchFacets: bad parameters: (%i, %i, %p)",
+			width, height, points );
+	}
+
+	if ( !(width & 1) || !(height & 1) ) {
+		Com_Error( ERR_DROP, "CM_GeneratePatchFacets: even sizes are invalid for quadratic meshes" );
+	}
+
+	if ( width > MAX_GRID_SIZE || height > MAX_GRID_SIZE ) {
+		Com_Error( ERR_DROP, "CM_GeneratePatchFacets: source is > MAX_GRID_SIZE" );
+	}
+
+	// build a grid
+	grid.width = width;
+	grid.height = height;
+	grid.wrapWidth = qfalse;
+	grid.wrapHeight = qfalse;
+	for ( i = 0 ; i < width ; i++ ) {
+		for ( j = 0 ; j < height ; j++ ) {
+			VectorCopy( points[j*width + i], grid.points[i][j] );
+		}
+	}
+
+	// subdivide the grid
+	CM_SetGridWrapWidth( &grid );
+	CM_SubdivideGridColumns( &grid );
+	CM_RemoveDegenerateColumns( &grid );
+
+	CM_TransposeGrid( &grid );
+
+	CM_SetGridWrapWidth( &grid );
+	CM_SubdivideGridColumns( &grid );
+	CM_RemoveDegenerateColumns( &grid );
+
+	// we now have a grid of points exactly on the curve
+	// the aproximate surface defined by these points will be
+	// collided against
+	pf = (struct patchCollide_s *)Hunk_Alloc( sizeof( *pf ), h_high );
+	ClearBounds( pf->bounds[0], pf->bounds[1] );
+	for ( i = 0 ; i < grid.width ; i++ ) {
+		for ( j = 0 ; j < grid.height ; j++ ) {
+			AddPointToBounds( grid.points[i][j], pf->bounds[0], pf->bounds[1] );
+		}
+	}
+
+	c_totalPatchBlocks += ( grid.width - 1 ) * ( grid.height - 1 );
+
+	// generate a bsp tree for the surface
+	CM_PatchCollideFromGrid( &grid, pf );
+
+	// expand by one unit for epsilon purposes
+	pf->bounds[0][0] -= 1;
+	pf->bounds[0][1] -= 1;
+	pf->bounds[0][2] -= 1;
+
+	pf->bounds[1][0] += 1;
+	pf->bounds[1][1] += 1;
+	pf->bounds[1][2] += 1;
+
+	return pf;
+}
+
+/*
+================================================================================
+
+TRACE TESTING
+
+================================================================================
+*/
+
+/*
+====================
+CM_TracePointThroughPatchCollide
+
+  special case for point traces because the patch collide "brushes" have no volume
+====================
+*/
+static inline void CM_TracePointThroughPatchCollide( traceWork_t *tw, trace_t &trace, const struct patchCollide_s *pc ) {
+	qboolean	frontFacing[MAX_PATCH_PLANES];
+	float		intersection[MAX_PATCH_PLANES];
+	float		intersect;
+	const patchPlane_t	*planes;
+	const facet_t	*facet;
+	int			i, j, k;
+	float		offset;
+	float		d1, d2;
+#ifndef BSPC
+	static cvar_t *cv;
+#endif //BSPC
+
+#ifndef BSPC
+	if ( !cm_playerCurveClip->integer || !tw->isPoint ) {
+		return;
+	}
+#endif
+
+	// determine the trace's relationship to all planes
+	planes = pc->planes;
+	for ( i = 0 ; i < pc->numPlanes ; i++, planes++ ) {
+		offset = DotProduct( tw->offsets[ planes->signbits ], planes->plane );
+		d1 = DotProduct( tw->start, planes->plane ) - planes->plane[3] + offset;
+		d2 = DotProduct( tw->end, planes->plane ) - planes->plane[3] + offset;
+		if ( d1 <= 0 ) {
+			frontFacing[i] = qfalse;
+		} else {
+			frontFacing[i] = qtrue;
+		}
+		if ( d1 == d2 ) {
+			intersection[i] = 99999;
+		} else {
+			intersection[i] = d1 / ( d1 - d2 );
+			if ( intersection[i] <= 0 ) {
+				intersection[i] = 99999;
+			}
+		}
+	}
+
+
+	// see if any of the surface planes are intersected
+	facet = pc->facets;
+	for ( i = 0 ; i < pc->numFacets ; i++, facet++ ) {
+		if ( !frontFacing[facet->surfacePlane] ) {
+			continue;
+		}
+		intersect = intersection[facet->surfacePlane];
+		if ( intersect < 0 ) {
+			continue;		// surface is behind the starting point
+		}
+		if ( intersect > trace.fraction ) {
+			continue;		// already hit something closer
+		}
+		for ( j = 0 ; j < facet->numBorders ; j++ ) {
+			k = facet->borderPlanes[j];
+			if ( frontFacing[k] ^ facet->borderInward[j] ) {
+				if ( intersection[k] > intersect ) {
+					break;
+				}
+			} else {
+				if ( intersection[k] < intersect ) {
+					break;
+				}
+			}
+		}
+		if ( j == facet->numBorders ) {
+			// we hit this facet
+#ifndef BSPC
+			if (!cv) {
+				cv = Cvar_Get( "r_debugSurfaceUpdate", "1", 0 );
+			}
+			if (cv->integer) {
+				debugPatchCollide = pc;
+				debugFacet = facet;
+			}
+#endif //BSPC
+			planes = &pc->planes[facet->surfacePlane];
+
+			// calculate intersection with a slight pushoff
+			offset = DotProduct( tw->offsets[ planes->signbits ], planes->plane );
+			d1 = DotProduct( tw->start, planes->plane ) - planes->plane[3] + offset;
+			d2 = DotProduct( tw->end, planes->plane ) - planes->plane[3] + offset;
+			trace.fraction = ( d1 - SURFACE_CLIP_EPSILON ) / ( d1 - d2 );
+
+			if ( trace.fraction < 0 ) {
+				trace.fraction = 0;
+			}
+
+			VectorCopy( planes->plane,  trace.plane.normal );
+			trace.plane.dist = planes->plane[3];
+		}
+	}
+}
+
+/*
+====================
+CM_CheckFacetPlane
+====================
+*/
+static inline int CM_CheckFacetPlane(float *plane, vec3_t start, vec3_t end, float *enterFrac, float *leaveFrac, int *hit) {
+	float d1, d2, f;
+
+	*hit = qfalse;
+
+	d1 = DotProduct( start, plane ) - plane[3];
+	d2 = DotProduct( end, plane ) - plane[3];
+
+	// if completely in front of face, no intersection with the entire facet
+	if (d1 > 0 && ( d2 >= SURFACE_CLIP_EPSILON || d2 >= d1 )  ) {
+		return qfalse;
+	}
+
+	// if it doesn't cross the plane, the plane isn't relevent
+	if (d1 <= 0 && d2 <= 0 ) {
+		return qtrue;
+	}
+
+	// crosses face
+	if (d1 > d2) {	// enter
+		f = (d1-SURFACE_CLIP_EPSILON) / (d1-d2);
+		if ( f < 0 ) {
+			f = 0;
+		}
+		//always favor previous plane hits and thus also the surface plane hit
+		if (f > *enterFrac) {
+			*enterFrac = f;
+			*hit = qtrue;
+		}
+	} else {	// leave
+		f = (d1+SURFACE_CLIP_EPSILON) / (d1-d2);
+		if ( f > 1 ) {
+			f = 1;
+		}
+		if (f < *leaveFrac) {
+			*leaveFrac = f;
+		}
+	}
+	return qtrue;
+}
+
+/*
+====================
+CM_TraceThroughPatchCollide
+====================
+*/
+void CM_TraceThroughPatchCollide( traceWork_t *tw, trace_t &trace, const struct patchCollide_s *pc )
+{
+	int i, j, hit, hitnum;
+	float offset, enterFrac, leaveFrac, t;
+	patchPlane_t *planes;
+	facet_t	*facet;
+	float plane[4], bestplane[4];
+	vec3_t startp, endp;
+#ifndef BSPC
+	static cvar_t *cv;
+#endif //BSPC
+
+#ifndef CULL_BBOX
+	// I'm not sure if test is strictly correct.  Are all
+	// bboxes axis aligned?  Do I care?  It seems to work
+	// good enough...
+	for ( i = 0 ; i < 3 ; i++ ) {
+		if ( tw->bounds[0][i] > pc->bounds[1][i]
+			|| tw->bounds[1][i] < pc->bounds[0][i] ) {
+			return;
+		}
+	}
+#endif
+
+	if (tw->isPoint) {
+		CM_TracePointThroughPatchCollide( tw, trace, pc );
+		return;
+	}
+	//
+	facet = pc->facets;
+	for ( i = 0 ; i < pc->numFacets ; i++, facet++ ) {
+		enterFrac = -1.0;
+		leaveFrac = 1.0;
+		hitnum = -1;
+		//
+		planes = &pc->planes[ facet->surfacePlane ];
+		VectorCopy(planes->plane, plane);
+		plane[3] = planes->plane[3];
+		if ( tw->sphere.use ) {
+			// adjust the plane distance apropriately for radius
+			plane[3] += tw->sphere.radius;
+
+			// find the closest point on the capsule to the plane
+			t = DotProduct( plane, tw->sphere.offset );
+			if ( t > 0.0f )
+			{
+				VectorSubtract( tw->start, tw->sphere.offset, startp );
+				VectorSubtract( tw->end, tw->sphere.offset, endp );
+			}
+			else
+			{
+				VectorAdd( tw->start, tw->sphere.offset, startp );
+				VectorAdd( tw->end, tw->sphere.offset, endp );
+			}
+		}
+		else {
+			offset = DotProduct( tw->offsets[ planes->signbits ], plane);
+			plane[3] -= offset;
+			VectorCopy( tw->start, startp );
+			VectorCopy( tw->end, endp );
+		}
+		//
+		if (!CM_CheckFacetPlane(plane, startp, endp, &enterFrac, &leaveFrac, &hit))
+			continue;
+		if (hit) {
+			Vector4Copy(plane, bestplane);
+		}
+		//
+		for ( j = 0 ; j < facet->numBorders ; j++ ) {
+			planes = &pc->planes[ facet->borderPlanes[j] ];
+			if (facet->borderInward[j]) {
+				VectorNegate(planes->plane, plane);
+				plane[3] = -planes->plane[3];
+			}
+			else {
+				VectorCopy(planes->plane, plane);
+				plane[3] = planes->plane[3];
+			}
+			if ( tw->sphere.use ) {
+				// adjust the plane distance apropriately for radius
+				plane[3] += tw->sphere.radius;
+
+				// find the closest point on the capsule to the plane
+				t = DotProduct( plane, tw->sphere.offset );
+				if ( t > 0.0f )
+				{
+					VectorSubtract( tw->start, tw->sphere.offset, startp );
+					VectorSubtract( tw->end, tw->sphere.offset, endp );
+				}
+				else
+				{
+					VectorAdd( tw->start, tw->sphere.offset, startp );
+					VectorAdd( tw->end, tw->sphere.offset, endp );
+				}
+			}
+			else {
+				// NOTE: this works even though the plane might be flipped because the bbox is centered
+				offset = DotProduct( tw->offsets[ planes->signbits ], plane);
+				plane[3] += fabs(offset);
+				VectorCopy( tw->start, startp );
+				VectorCopy( tw->end, endp );
+			}
+			//
+			if (!CM_CheckFacetPlane(plane, startp, endp, &enterFrac, &leaveFrac, &hit))
+				break;
+			if (hit) {
+				hitnum = j;
+				Vector4Copy(plane, bestplane);
+			}
+		}
+		if (j < facet->numBorders) continue;
+		//never clip against the back side
+		if (hitnum == facet->numBorders - 1) continue;
+		//
+		if (enterFrac < leaveFrac && enterFrac >= 0) {
+			if (enterFrac < trace.fraction) {
+				if (enterFrac < 0) {
+					enterFrac = 0;
+				}
+#ifndef BSPC
+				if (!cv) {
+					cv = Cvar_Get( "r_debugSurfaceUpdate", "1", 0 );
+				}
+				if (cv && cv->integer) {
+					debugPatchCollide = pc;
+					debugFacet = facet;
+				}
+#endif // BSPC
+
+				trace.fraction = enterFrac;
+				VectorCopy( bestplane, trace.plane.normal );
+				trace.plane.dist = bestplane[3];
+			}
+		}
+	}
+}
+
+
+/*
+=======================================================================
+
+POSITION DETECTION
+
+=======================================================================
+*/
+
+/*
+====================
+CM_PositionTestInPatchCollide
+
+Modifies tr->tr if any of the facets effect the trace
+====================
+*/
+qboolean CM_PositionTestInPatchCollide( traceWork_t *tw, const struct patchCollide_s *pc ) {
+	int i, j;
+	float offset, t;
+	patchPlane_t *planes;
+	facet_t	*facet;
+	float plane[4];
+	vec3_t startp;
+
+	if (tw->isPoint) {
+		return qfalse;
+	}
+	//
+	facet = pc->facets;
+	for ( i = 0 ; i < pc->numFacets ; i++, facet++ ) {
+		planes = &pc->planes[ facet->surfacePlane ];
+		VectorCopy(planes->plane, plane);
+		plane[3] = planes->plane[3];
+		if ( tw->sphere.use ) {
+			// adjust the plane distance apropriately for radius
+			plane[3] += tw->sphere.radius;
+
+			// find the closest point on the capsule to the plane
+			t = DotProduct( plane, tw->sphere.offset );
+			if ( t > 0 ) {
+				VectorSubtract( tw->start, tw->sphere.offset, startp );
+			}
+			else {
+				VectorAdd( tw->start, tw->sphere.offset, startp );
+			}
+		}
+		else {
+			offset = DotProduct( tw->offsets[ planes->signbits ], plane);
+			plane[3] -= offset;
+			VectorCopy( tw->start, startp );
+		}
+
+		if ( DotProduct( plane, startp ) - plane[3] > 0.0f ) {
+			continue;
+		}
+
+		for ( j = 0; j < facet->numBorders; j++ ) {
+			planes = &pc->planes[ facet->borderPlanes[j] ];
+			if (facet->borderInward[j]) {
+				VectorNegate(planes->plane, plane);
+				plane[3] = -planes->plane[3];
+			}
+			else {
+				VectorCopy(planes->plane, plane);
+				plane[3] = planes->plane[3];
+			}
+			if ( tw->sphere.use ) {
+				// adjust the plane distance apropriately for radius
+				plane[3] += tw->sphere.radius;
+
+				// find the closest point on the capsule to the plane
+				t = DotProduct( plane, tw->sphere.offset );
+				if ( t > 0.0f ) {
+					VectorSubtract( tw->start, tw->sphere.offset, startp );
+				}
+				else {
+					VectorAdd( tw->start, tw->sphere.offset, startp );
+				}
+			}
+			else {
+				// NOTE: this works even though the plane might be flipped because the bbox is centered
+				offset = DotProduct( tw->offsets[ planes->signbits ], plane);
+				plane[3] += fabs(offset);
+				VectorCopy( tw->start, startp );
+			}
+
+			if ( DotProduct( plane, startp ) - plane[3] > 0.0f ) {
+				break;
+			}
+		}
+		if (j < facet->numBorders) {
+			continue;
+
+		}
+		// inside this patch facet
+		return qtrue;
+	}
+
+	return qfalse;
+}
+
+
+/*
+=======================================================================
+
+DEBUGGING
+
+=======================================================================
+*/
+
+
+/*
+==================
+CM_DrawDebugSurface
+
+Called from the renderer
+==================
+*/
+#ifndef BSPC
+void BotDrawDebugPolygons(void (*drawPoly)(int color, int numPoints, float *points), int value);
+#endif
+
+void CM_DrawDebugSurface( void (*drawPoly)(int color, int numPoints, float *points) ) {
+	static cvar_t	*cv;
+#ifndef BSPC
+	static cvar_t	*cv2;
+#endif
+	const patchCollide_t	*pc;
+	facet_t			*facet;
+	winding_t		*w;
+	int				i, j, k, n;
+	int				curplanenum, planenum, curinward, inward;
+	float			plane[4];
+	vec3_t mins = {-15, -15, -28}, maxs = {15, 15, 28};
+	//vec3_t mins = {0, 0, 0}, maxs = {0, 0, 0};
+	vec3_t v1, v2;
+
+#ifndef BSPC
+	if ( !cv2 )
+	{
+		cv2 = Cvar_Get( "r_debugSurface", "0", 0 );
+	}
+
+	if (cv2->integer != 1)
+	{
+		BotDrawDebugPolygons(drawPoly, cv2->integer);
+		return;
+	}
+#endif
+
+	if ( !debugPatchCollide ) {
+		return;
+	}
+
+#ifndef BSPC
+	if ( !cv ) {
+		cv = Cvar_Get( "cm_debugSize", "2", 0 );
+	}
+#endif
+	pc = debugPatchCollide;
+
+	for ( i = 0, facet = pc->facets ; i < pc->numFacets ; i++, facet++ ) {
+
+		for ( k = 0 ; k < facet->numBorders + 1; k++ ) {
+			//
+			if (k < facet->numBorders) {
+				planenum = facet->borderPlanes[k];
+				inward = facet->borderInward[k];
+			}
+			else {
+				planenum = facet->surfacePlane;
+				inward = qfalse;
+				//continue;
+			}
+
+			Vector4Copy( pc->planes[ planenum ].plane, plane );
+
+			//planenum = facet->surfacePlane;
+			if ( inward ) {
+				VectorSubtract( vec3_origin, plane, plane );
+				plane[3] = -plane[3];
+			}
+
+			plane[3] += cv->value;
+			//*
+			for (n = 0; n < 3; n++)
+			{
+				if (plane[n] > 0) v1[n] = maxs[n];
+				else v1[n] = mins[n];
+			} //end for
+			VectorNegate(plane, v2);
+			plane[3] += fabs(DotProduct(v1, v2));
+			//*/
+
+			w = BaseWindingForPlane( plane,  plane[3] );
+			for ( j = 0 ; j < facet->numBorders + 1 && w; j++ ) {
+				//
+				if (j < facet->numBorders) {
+					curplanenum = facet->borderPlanes[j];
+					curinward = facet->borderInward[j];
+				}
+				else {
+					curplanenum = facet->surfacePlane;
+					curinward = qfalse;
+					//continue;
+				}
+				//
+				if (curplanenum == planenum) continue;
+
+				Vector4Copy( pc->planes[ curplanenum ].plane, plane );
+				if ( !curinward ) {
+					VectorSubtract( vec3_origin, plane, plane );
+					plane[3] = -plane[3];
+				}
+		//			if ( !facet->borderNoAdjust[j] ) {
+					plane[3] -= cv->value;
+		//			}
+				for (n = 0; n < 3; n++)
+				{
+					if (plane[n] > 0) v1[n] = maxs[n];
+					else v1[n] = mins[n];
+				} //end for
+				VectorNegate(plane, v2);
+				plane[3] -= fabs(DotProduct(v1, v2));
+
+				ChopWindingInPlace( &w, plane, plane[3], 0.1f );
+			}
+			if ( w ) {
+				if ( facet == debugFacet ) {
+					drawPoly( 4, w->numpoints, w->p[0] );
+					//Com_Printf("blue facet has %d border planes\n", facet->numBorders);
+				} else {
+					drawPoly( 1, w->numpoints, w->p[0] );
+				}
+				FreeWinding( w );
+			}
+			else
+				Com_Printf("winding chopped away by border planes\n");
+		}
+	}
+
+	// draw the debug block
+	{
+		vec3_t			v[3];
+
+		VectorCopy( debugBlockPoints[0], v[0] );
+		VectorCopy( debugBlockPoints[1], v[1] );
+		VectorCopy( debugBlockPoints[2], v[2] );
+		drawPoly( 2, 3, v[0] );
+
+		VectorCopy( debugBlockPoints[2], v[0] );
+		VectorCopy( debugBlockPoints[3], v[1] );
+		VectorCopy( debugBlockPoints[0], v[2] );
+		drawPoly( 2, 3, v[0] );
+	}
+
+#if 0
+	vec3_t			v[4];
+
+	v[0][0] = pc->bounds[1][0];
+	v[0][1] = pc->bounds[1][1];
+	v[0][2] = pc->bounds[1][2];
+
+	v[1][0] = pc->bounds[1][0];
+	v[1][1] = pc->bounds[0][1];
+	v[1][2] = pc->bounds[1][2];
+
+	v[2][0] = pc->bounds[0][0];
+	v[2][1] = pc->bounds[0][1];
+	v[2][2] = pc->bounds[1][2];
+
+	v[3][0] = pc->bounds[0][0];
+	v[3][1] = pc->bounds[1][1];
+	v[3][2] = pc->bounds[1][2];
+
+	drawPoly( 4, v[0] );
+#endif
+}
+
+
+
diff --git a/codemp/qcommon/cm_patch.h b/codemp/qcommon/cm_patch.h
new file mode 100644
index 0000000..486ed21
--- /dev/null
+++ b/codemp/qcommon/cm_patch.h
@@ -0,0 +1,128 @@
+
+//#define	CULL_BBOX
+
+/*
+
+This file does not reference any globals, and has these entry points:
+
+void CM_ClearLevelPatches( void );
+struct patchCollide_s	*CM_GeneratePatchCollide( int width, int height, const vec3_t *points );
+void CM_TraceThroughPatchCollide( traceWork_t *tw, const struct patchCollide_s *pc );
+qboolean CM_PositionTestInPatchCollide( traceWork_t *tw, const struct patchCollide_s *pc );
+void CM_DrawDebugSurface( void (*drawPoly)(int color, int numPoints, flaot *points) );
+
+
+Issues for collision against curved surfaces:
+
+Surface edges need to be handled differently than surface planes
+
+Plane expansion causes raw surfaces to expand past expanded bounding box
+
+Position test of a volume against a surface is tricky.
+
+Position test of a point against a surface is not well defined, because the surface has no volume.
+
+
+Tracing leading edge points instead of volumes?
+Position test by tracing corner to corner? (8*7 traces -- ouch)
+
+coplanar edges
+triangulated patches
+degenerate patches
+
+  endcaps
+  degenerate
+
+WARNING: this may misbehave with meshes that have rows or columns that only
+degenerate a few triangles.  Completely degenerate rows and columns are handled
+properly.
+*/
+
+
+#define	MAX_FACETS			1024
+#define	MAX_PATCH_PLANES	2048
+
+typedef struct {
+	float	plane[4];
+	int		signbits;		// signx + (signy<<1) + (signz<<2), used as lookup during collision
+} patchPlane_t;
+
+#ifdef _XBOX
+//Facets are now two structures - a maximum sized version that's used
+//temporarily during load time, and smaller version that only allocates
+//as much memory as needed.  The load version is copied into the small
+//version after it's been assembled.
+#pragma pack(push, 1)
+typedef struct {
+	int			surfacePlane;
+	int			numBorders;		// 3 or four + 6 axial bevels + 4 or 3 * 4 edge bevels
+	short	borderPlanes[4+6+16];
+	unsigned char	borderInward[4+6+16];
+	unsigned char  borderNoAdjust[4+6+16];
+} facetLoad_t;
+
+typedef struct {
+	int			surfacePlane;
+	int			numBorders;		// 3 or four + 6 axial bevels + 4 or 3 * 4 edge bevels
+	char *data;
+
+	short *GetBorderPlanes(void) { return (short*)data; }
+	char *GetBorderInward(void) { return data + (numBorders * 2); }
+	char *GetBorderNoAdjust(void) 
+			{ return data + (numBorders * 2) + numBorders; }
+
+	const short *GetBorderPlanes(void) const { return (short*)data; }
+	const char *GetBorderInward(void) const { return data + (numBorders * 2); }
+	const char *GetBorderNoAdjust(void) const 
+			{ return data + (numBorders * 2) + numBorders; }
+} facet_t;
+#pragma pack(pop)
+
+#else // _XBOX
+
+typedef struct {
+	int			surfacePlane;
+	int			numBorders;		// 3 or four + 6 axial bevels + 4 or 3 * 4 edge bevels
+	int			borderPlanes[4+6+16];
+	int			borderInward[4+6+16];
+	qboolean	borderNoAdjust[4+6+16];
+} facet_t;
+
+#endif // _XBOX
+
+typedef struct patchCollide_s {
+	vec3_t	bounds[2];
+	int		numPlanes;			// surface planes plus edge planes
+	patchPlane_t	*planes;
+	int		numFacets;
+	facet_t	*facets;
+} patchCollide_t;
+
+#ifdef _XBOX
+#define CM_MAX_GRID_SIZE	129
+#else
+#define	MAX_GRID_SIZE	129
+#endif
+
+typedef struct {
+	int			width;
+	int			height;
+	qboolean	wrapWidth;
+	qboolean	wrapHeight;
+#ifdef _XBOX
+	vec3_t	points[CM_MAX_GRID_SIZE][CM_MAX_GRID_SIZE];	// [width][height]
+#else
+	vec3_t	points[MAX_GRID_SIZE][MAX_GRID_SIZE];	// [width][height]
+#endif
+} cGrid_t;
+
+#define	SUBDIVIDE_DISTANCE	16	//4	// never more than this units away from curve
+#define	PLANE_TRI_EPSILON	0.1
+#define	WRAP_POINT_EPSILON	0.1
+
+#ifdef _XBOX
+struct patchCollide_s	*CM_GeneratePatchCollide( int width, int height, vec3_t *points,
+												 facetLoad_t *facetbuf, int *gridbuf );
+#else
+struct patchCollide_s	*CM_GeneratePatchCollide( int width, int height, vec3_t *points );
+#endif
diff --git a/codemp/qcommon/cm_patch_xbox.cpp b/codemp/qcommon/cm_patch_xbox.cpp
new file mode 100644
index 0000000..c86ff8e
--- /dev/null
+++ b/codemp/qcommon/cm_patch_xbox.cpp
@@ -0,0 +1,1782 @@
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+#include "cm_local.h"
+#include "cm_patch.h"
+
+/*
+
+This file does not reference any globals, and has these entry points:
+
+void CM_ClearLevelPatches( void );
+struct patchCollide_s	*CM_GeneratePatchCollide( int width, int height, const vec3_t *points );
+void CM_TraceThroughPatchCollide( traceWork_t *tw, const struct patchCollide_s *pc );
+qboolean CM_PositionTestInPatchCollide( traceWork_t *tw, const struct patchCollide_s *pc );
+void CM_DrawDebugSurface( void (*drawPoly)(int color, int numPoints, flaot *points) );
+
+
+Issues for collision against curved surfaces:
+
+Surface edges need to be handled differently than surface planes
+
+Plane expansion causes raw surfaces to expand past expanded bounding box
+
+Position test of a volume against a surface is tricky.
+
+Position test of a point against a surface is not well defined, because the surface has no volume.
+
+
+Tracing leading edge points instead of volumes?
+Position test by tracing corner to corner? (8*7 traces -- ouch)
+
+coplanar edges
+triangulated patches
+degenerate patches
+
+  endcaps
+  degenerate
+
+WARNING: this may misbehave with meshes that have rows or columns that only
+degenerate a few triangles.  Completely degenerate rows and columns are handled
+properly.
+*/
+
+/*
+#define	MAX_FACETS			1024
+#define	MAX_PATCH_PLANES	2048
+
+typedef struct {
+	float	plane[4];
+	int		signbits;		// signx + (signy<<1) + (signz<<2), used as lookup during collision
+} patchPlane_t;
+
+typedef struct {
+	int			surfacePlane;
+	int			numBorders;		// 3 or four + 6 axial bevels + 4 or 3 * 4 edge bevels
+	int			borderPlanes[4+6+16];
+	int			borderInward[4+6+16];
+	qboolean	borderNoAdjust[4+6+16];
+} facet_t;
+
+typedef struct patchCollide_s {
+	vec3_t	bounds[2];
+	int		numPlanes;			// surface planes plus edge planes
+	patchPlane_t	*planes;
+	int		numFacets;
+	facet_t	*facets;
+} patchCollide_t;
+
+
+#define	MAX_GRID_SIZE	129
+
+typedef struct {
+	int			width;
+	int			height;
+	qboolean	wrapWidth;
+	qboolean	wrapHeight;
+	vec3_t	points[MAX_GRID_SIZE][MAX_GRID_SIZE];	// [width][height]
+} cGrid_t;
+
+#define	SUBDIVIDE_DISTANCE	16	//4	// never more than this units away from curve
+#define	PLANE_TRI_EPSILON	0.1
+#define	WRAP_POINT_EPSILON	0.1
+*/
+
+int	c_totalPatchBlocks;
+int	c_totalPatchSurfaces;
+int	c_totalPatchEdges;
+
+static const patchCollide_t	*debugPatchCollide;
+static const facet_t		*debugFacet;
+static qboolean		debugBlock;
+static vec3_t		debugBlockPoints[4];
+
+#if defined(BSPC)
+extern void *Hunk_Alloc( int size );
+
+static void *Hunk_Alloc( int size, ha_pref preference )
+{
+	return Hunk_Alloc( size );
+}
+#endif
+
+/*
+=================
+CM_ClearLevelPatches
+=================
+*/
+void CM_ClearLevelPatches( void ) {
+	debugPatchCollide = NULL;
+	debugFacet = NULL;
+}
+
+/*
+=================
+CM_SignbitsForNormal
+=================
+*/
+static inline int CM_SignbitsForNormal( vec3_t normal ) {
+	int	bits, j;
+
+	bits = 0;
+	for (j=0 ; j<3 ; j++) {
+		if ( normal[j] < 0 ) {
+			bits |= 1<<j;
+		}
+	}
+	return bits;
+}
+
+/*
+=====================
+CM_PlaneFromPoints
+
+Returns false if the triangle is degenrate.
+The normal will point out of the clock for clockwise ordered points
+=====================
+*/
+static inline qboolean CM_PlaneFromPoints( vec4_t plane, vec3_t a, vec3_t b, vec3_t c ) {
+	vec3_t	d1, d2;
+
+	VectorSubtract( b, a, d1 );
+	VectorSubtract( c, a, d2 );
+	CrossProduct( d2, d1, plane );
+	if ( VectorNormalize( plane ) == 0 ) {
+		return qfalse;
+	}
+
+	plane[3] = DotProduct( a, plane );
+	return qtrue;
+}
+
+
+/*
+================================================================================
+
+GRID SUBDIVISION
+
+================================================================================
+*/
+
+/*
+=================
+CM_NeedsSubdivision
+
+Returns true if the given quadratic curve is not flat enough for our
+collision detection purposes
+=================
+*/
+static qboolean	CM_NeedsSubdivision( vec3_t a, vec3_t b, vec3_t c ) {
+	vec3_t		cmid;
+	vec3_t		lmid;
+	vec3_t		delta;
+	float		dist;
+	int			i;
+
+	// calculate the linear midpoint
+	for ( i = 0 ; i < 3 ; i++ ) {
+		lmid[i] = 0.5*(a[i] + c[i]);
+	}
+
+	// calculate the exact curve midpoint
+	for ( i = 0 ; i < 3 ; i++ ) {
+		cmid[i] = 0.5 * ( 0.5*(a[i] + b[i]) + 0.5*(b[i] + c[i]) );
+	}
+
+	// see if the curve is far enough away from the linear mid
+	VectorSubtract( cmid, lmid, delta );
+	dist = VectorLengthSquared( delta );
+	
+	return (qboolean)(dist >= SUBDIVIDE_DISTANCE * SUBDIVIDE_DISTANCE);
+}
+
+/*
+===============
+CM_Subdivide
+
+a, b, and c are control points.
+the subdivided sequence will be: a, out1, out2, out3, c
+===============
+*/
+static void CM_Subdivide( vec3_t a, vec3_t b, vec3_t c, vec3_t out1, vec3_t out2, vec3_t out3 ) {
+	int		i;
+
+	for ( i = 0 ; i < 3 ; i++ ) {
+		out1[i] = 0.5 * (a[i] + b[i]);
+		out3[i] = 0.5 * (b[i] + c[i]);
+		out2[i] = 0.5 * (out1[i] + out3[i]);
+	}
+}
+
+/*
+=================
+CM_TransposeGrid
+
+Swaps the rows and columns in place
+=================
+*/
+static void CM_TransposeGrid( cGrid_t *grid ) {
+	int			i, j, l;
+	vec3_t		temp;
+	qboolean	tempWrap;
+
+	if ( grid->width > grid->height ) {
+		for ( i = 0 ; i < grid->height ; i++ ) {
+			for ( j = i + 1 ; j < grid->width ; j++ ) {
+				if ( j < grid->height ) {
+					// swap the value
+					VectorCopy( grid->points[i][j], temp );
+					VectorCopy( grid->points[j][i], grid->points[i][j] );
+					VectorCopy( temp, grid->points[j][i] );
+				} else {
+					// just copy
+					VectorCopy( grid->points[j][i], grid->points[i][j] );
+				}
+			}
+		}
+	} else {
+		for ( i = 0 ; i < grid->width ; i++ ) {
+			for ( j = i + 1 ; j < grid->height ; j++ ) {
+				if ( j < grid->width ) {
+					// swap the value
+					VectorCopy( grid->points[j][i], temp );
+					VectorCopy( grid->points[i][j], grid->points[j][i] );
+					VectorCopy( temp, grid->points[i][j] );
+				} else {
+					// just copy
+					VectorCopy( grid->points[i][j], grid->points[j][i] );
+				}
+			}
+		}
+	}
+
+	l = grid->width;
+	grid->width = grid->height;
+	grid->height = l;
+
+	tempWrap = grid->wrapWidth;
+	grid->wrapWidth = grid->wrapHeight;
+	grid->wrapHeight = tempWrap;
+}
+
+/*
+===================
+CM_SetGridWrapWidth
+
+If the left and right columns are exactly equal, set grid->wrapWidth qtrue
+===================
+*/
+static void CM_SetGridWrapWidth( cGrid_t *grid ) {
+	int		i, j;
+	float	d;
+
+	for ( i = 0 ; i < grid->height ; i++ ) {
+		for ( j = 0 ; j < 3 ; j++ ) {
+			d = grid->points[0][i][j] - grid->points[grid->width-1][i][j];
+			if ( d < -WRAP_POINT_EPSILON || d > WRAP_POINT_EPSILON ) {
+				break;
+			}
+		}
+		if ( j != 3 ) {
+			break;
+		}
+	}
+	if ( i == grid->height ) {
+		grid->wrapWidth = qtrue;
+	} else {
+		grid->wrapWidth = qfalse;
+	}
+}
+
+
+/*
+=================
+CM_SubdivideGridColumns
+
+Adds columns as necessary to the grid until
+all the aproximating points are within SUBDIVIDE_DISTANCE
+from the true curve
+=================
+*/
+static void CM_SubdivideGridColumns( cGrid_t *grid ) {
+	int		i, j, k;
+
+	for ( i = 0 ; i < grid->width - 2 ;  ) {
+		// grid->points[i][x] is an interpolating control point
+		// grid->points[i+1][x] is an aproximating control point
+		// grid->points[i+2][x] is an interpolating control point
+
+		//
+		// first see if we can collapse the aproximating collumn away
+		//
+		for ( j = 0 ; j < grid->height ; j++ ) {
+			if ( CM_NeedsSubdivision( grid->points[i][j], grid->points[i+1][j], grid->points[i+2][j] ) ) {
+				break;
+			}
+		}
+		if ( j == grid->height ) {
+			// all of the points were close enough to the linear midpoints
+			// that we can collapse the entire column away
+			for ( j = 0 ; j < grid->height ; j++ ) {
+				// remove the column
+				for ( k = i + 2 ; k < grid->width ; k++ ) {
+					VectorCopy( grid->points[k][j], grid->points[k-1][j] );
+				}
+			}
+
+			grid->width--;
+
+			// go to the next curve segment
+			i++;
+			continue;
+		}
+
+		//
+		// we need to subdivide the curve
+		//
+		for ( j = 0 ; j < grid->height ; j++ ) {
+			vec3_t	prev, mid, next;
+
+			// save the control points now
+			VectorCopy( grid->points[i][j], prev );
+			VectorCopy( grid->points[i+1][j], mid );
+			VectorCopy( grid->points[i+2][j], next );
+
+			// make room for two additional columns in the grid
+			// columns i+1 will be replaced, column i+2 will become i+4
+			// i+1, i+2, and i+3 will be generated
+			for ( k = grid->width - 1 ; k > i + 1 ; k-- ) {
+				VectorCopy( grid->points[k][j], grid->points[k+2][j] );
+			}
+
+			// generate the subdivided points
+			CM_Subdivide( prev, mid, next, grid->points[i+1][j], grid->points[i+2][j], grid->points[i+3][j] );
+		}
+
+		grid->width += 2;
+
+		// the new aproximating point at i+1 may need to be removed
+		// or subdivided farther, so don't advance i
+	}
+}
+
+
+/*
+======================
+CM_ComparePoints
+======================
+*/
+#define	POINT_EPSILON	0.1
+static qboolean CM_ComparePoints( float *a, float *b ) {
+	float		d;
+
+	d = a[0] - b[0];
+	if ( d < -POINT_EPSILON || d > POINT_EPSILON ) {
+		return qfalse;
+	}
+	d = a[1] - b[1];
+	if ( d < -POINT_EPSILON || d > POINT_EPSILON ) {
+		return qfalse;
+	}
+	d = a[2] - b[2];
+	if ( d < -POINT_EPSILON || d > POINT_EPSILON ) {
+		return qfalse;
+	}
+	return qtrue;
+}
+
+/*
+=================
+CM_RemoveDegenerateColumns
+
+If there are any identical columns, remove them
+=================
+*/
+static void CM_RemoveDegenerateColumns( cGrid_t *grid ) {
+	int		i, j, k;
+
+	for ( i = 0 ; i < grid->width - 1 ; i++ ) {
+		for ( j = 0 ; j < grid->height ; j++ ) {
+			if ( !CM_ComparePoints( grid->points[i][j], grid->points[i+1][j] ) ) {
+				break;
+			}
+		}
+
+		if ( j != grid->height ) {
+			continue;	// not degenerate
+		}
+
+		for ( j = 0 ; j < grid->height ; j++ ) {
+			// remove the column
+			for ( k = i + 2 ; k < grid->width ; k++ ) {
+				VectorCopy( grid->points[k][j], grid->points[k-1][j] );
+			}
+		}
+		grid->width--;
+
+		// check against the next column
+		i--;
+	}
+}
+
+/*
+================================================================================
+
+PATCH COLLIDE GENERATION
+
+================================================================================
+*/
+
+static	int				numPlanes;
+static	patchPlane_t	*planes = NULL;
+
+void CM_TempPatchPlanesAlloc(void)
+{
+	if(!planes) {
+		planes = (patchPlane_t*)Z_Malloc(MAX_PATCH_PLANES*sizeof(patchPlane_t), 
+				TAG_TEMP_WORKSPACE, qfalse);
+	}
+}
+
+void CM_TempPatchPlanesDealloc(void)
+{
+	if(planes) {
+		Z_Free(planes);
+		planes = NULL;
+	}
+}
+
+//static	int				numFacets;
+//static	facet_t			facets[MAX_PATCH_PLANES]; //maybe MAX_FACETS ??
+static		facet_t			*facets = NULL;
+
+#define	NORMAL_EPSILON	0.0001
+#define	DIST_EPSILON	0.02
+
+static inline int CM_PlaneEqual(patchPlane_t *p, float plane[4], int *flipped) {
+	float invplane[4];
+
+	if (
+	   Q_fabs(p->plane[0] - plane[0]) < NORMAL_EPSILON
+	&& Q_fabs(p->plane[1] - plane[1]) < NORMAL_EPSILON
+	&& Q_fabs(p->plane[2] - plane[2]) < NORMAL_EPSILON
+	&& Q_fabs(p->plane[3] - plane[3]) < DIST_EPSILON )
+	{
+		*flipped = qfalse;
+		return qtrue;
+	}
+
+	VectorNegate(plane, invplane);
+	invplane[3] = -plane[3];
+
+	if (
+	   Q_fabs(p->plane[0] - invplane[0]) < NORMAL_EPSILON
+	&& Q_fabs(p->plane[1] - invplane[1]) < NORMAL_EPSILON
+	&& Q_fabs(p->plane[2] - invplane[2]) < NORMAL_EPSILON
+	&& Q_fabs(p->plane[3] - invplane[3]) < DIST_EPSILON )
+	{
+		*flipped = qtrue;
+		return qtrue;
+	}
+
+	return qfalse;
+}
+
+static inline void CM_SnapVector(vec3_t normal) {
+	int		i;
+
+	for (i=0 ; i<3 ; i++)
+	{
+		if ( Q_fabs(normal[i] - 1) < NORMAL_EPSILON )
+		{
+			VectorClear (normal);
+			normal[i] = 1;
+			break;
+		}
+		if ( Q_fabs(normal[i] - -1) < NORMAL_EPSILON )
+		{
+			VectorClear (normal);
+			normal[i] = -1;
+			break;
+		}
+	}
+}
+
+static inline int CM_FindPlane2(float plane[4], int *flipped) {
+	int i;
+
+	// see if the points are close enough to an existing plane
+	for ( i = 0 ; i < numPlanes ; i++ ) {
+		if (CM_PlaneEqual(&planes[i], plane, flipped)) return i;
+	}
+
+	// add a new plane
+	if ( numPlanes == MAX_PATCH_PLANES ) {
+		Com_Error( ERR_DROP, "MAX_PATCH_PLANES" );
+	}
+
+	Vector4Copy( plane, planes[numPlanes].plane );
+	planes[numPlanes].signbits = CM_SignbitsForNormal( plane );
+
+	numPlanes++;
+
+	*flipped = qfalse;
+
+	return numPlanes-1;
+}
+
+/*
+==================
+CM_FindPlane
+==================
+*/
+static inline int CM_FindPlane( float *p1, float *p2, float *p3 ) {
+	float	plane[4];
+	int		i;
+	float	d;
+
+	if ( !CM_PlaneFromPoints( plane, p1, p2, p3 ) ) {
+		return -1;
+	}
+
+	// see if the points are close enough to an existing plane
+	for ( i = 0 ; i < numPlanes ; i++ ) {
+		if ( DotProduct( plane, planes[i].plane ) < 0 ) {
+			continue;	// allow backwards planes?
+		}
+
+		d = DotProduct( p1, planes[i].plane ) - planes[i].plane[3];
+		if ( d < -PLANE_TRI_EPSILON || d > PLANE_TRI_EPSILON ) {
+			continue;
+		}
+
+		d = DotProduct( p2, planes[i].plane ) - planes[i].plane[3];
+		if ( d < -PLANE_TRI_EPSILON || d > PLANE_TRI_EPSILON ) {
+			continue;
+		}
+
+		d = DotProduct( p3, planes[i].plane ) - planes[i].plane[3];
+		if ( d < -PLANE_TRI_EPSILON || d > PLANE_TRI_EPSILON ) {
+			continue;
+		}
+
+		// found it
+		return i;
+	}
+
+	// add a new plane
+	if ( numPlanes == MAX_PATCH_PLANES ) {
+		Com_Error( ERR_DROP, "MAX_PATCH_PLANES" );
+	}
+
+	Vector4Copy( plane, planes[numPlanes].plane );
+	planes[numPlanes].signbits = CM_SignbitsForNormal( plane );
+
+	numPlanes++;
+
+	return numPlanes-1;
+}
+
+
+/*
+==================
+CM_PointOnPlaneSide
+==================
+*/
+static inline int CM_PointOnPlaneSide( float *p, int planeNum ) {
+	float	*plane;
+	float	d;
+
+	if ( planeNum == -1 ) {
+		return SIDE_ON;
+	}
+	plane = planes[ planeNum ].plane;
+
+	d = DotProduct( p, plane ) - plane[3];
+
+	if ( d > PLANE_TRI_EPSILON ) {
+		return SIDE_FRONT;
+	}
+
+	if ( d < -PLANE_TRI_EPSILON ) {
+		return SIDE_BACK;
+	}
+
+	return SIDE_ON;
+}
+
+static inline int	CM_GridPlane( int* gridPlanes, int i, int j, int tri ) {
+	int		p;
+
+	p = gridPlanes[i*CM_MAX_GRID_SIZE*2+j*2+tri];
+	if ( p != -1 ) {
+		return p;
+	}
+	p = gridPlanes[i*CM_MAX_GRID_SIZE*2+j*2+(!tri)];
+	if ( p != -1 ) {
+		return p;
+	}
+
+	// should never happen
+	Com_Printf( "WARNING: CM_GridPlane unresolvable\n" );
+	return -1;
+}
+
+/*
+==================
+CM_EdgePlaneNum
+==================
+*/
+static int CM_EdgePlaneNum( cGrid_t *grid, int* gridPlanes/*[PATCH_MAX_GRID_SIZE][PATCH_MAX_GRID_SIZE][2]*/, int i, int j, int k ) {
+	float	*p1, *p2;
+	vec3_t		up;
+	int			p;
+
+	switch ( k ) {
+	case 0:	// top border
+		p1 = grid->points[i][j];
+		p2 = grid->points[i+1][j];
+		p = CM_GridPlane( gridPlanes, i, j, 0 );
+		VectorMA( p1, 4, planes[ p ].plane, up );
+		return CM_FindPlane( p1, p2, up );
+
+	case 2:	// bottom border
+		p1 = grid->points[i][j+1];
+		p2 = grid->points[i+1][j+1];
+		p = CM_GridPlane( gridPlanes, i, j, 1 );
+		VectorMA( p1, 4, planes[ p ].plane, up );
+		return CM_FindPlane( p2, p1, up );
+
+	case 3: // left border
+		p1 = grid->points[i][j];
+		p2 = grid->points[i][j+1];
+		p = CM_GridPlane( gridPlanes, i, j, 1 );
+		VectorMA( p1, 4, planes[ p ].plane, up );
+		return CM_FindPlane( p2, p1, up );
+
+	case 1:	// right border
+		p1 = grid->points[i+1][j];
+		p2 = grid->points[i+1][j+1];
+		p = CM_GridPlane( gridPlanes, i, j, 0 );
+		VectorMA( p1, 4, planes[ p ].plane, up );
+		return CM_FindPlane( p1, p2, up );
+
+	case 4:	// diagonal out of triangle 0
+		p1 = grid->points[i+1][j+1];
+		p2 = grid->points[i][j];
+		p = CM_GridPlane( gridPlanes, i, j, 0 );
+		VectorMA( p1, 4, planes[ p ].plane, up );
+		return CM_FindPlane( p1, p2, up );
+
+	case 5:	// diagonal out of triangle 1
+		p1 = grid->points[i][j];
+		p2 = grid->points[i+1][j+1];
+		p = CM_GridPlane( gridPlanes, i, j, 1 );
+		VectorMA( p1, 4, planes[ p ].plane, up );
+		return CM_FindPlane( p1, p2, up );
+
+	}
+
+	Com_Error( ERR_DROP, "CM_EdgePlaneNum: bad k" );
+	return -1;
+}
+
+/*
+===================
+CM_SetBorderInward
+===================
+*/
+static inline void CM_SetBorderInward( facetLoad_t *facet, cGrid_t *grid,
+						  int i, int j, int which ) {
+	int		k, l;
+	float	*points[4];
+	int		numPoints;
+
+	switch ( which ) {
+	case -1:
+		points[0] = grid->points[i][j];
+		points[1] = grid->points[i+1][j];
+		points[2] = grid->points[i+1][j+1];
+		points[3] = grid->points[i][j+1];
+		numPoints = 4;
+		break;
+	case 0:
+		points[0] = grid->points[i][j];
+		points[1] = grid->points[i+1][j];
+		points[2] = grid->points[i+1][j+1];
+		numPoints = 3;
+		break;
+	case 1:
+		points[0] = grid->points[i+1][j+1];
+		points[1] = grid->points[i][j+1];
+		points[2] = grid->points[i][j];
+		numPoints = 3;
+		break;
+	default:
+		Com_Error( ERR_FATAL, "CM_SetBorderInward: bad parameter" );
+		numPoints = 0;
+		break;
+	}
+
+	for ( k = 0 ; k < facet->numBorders ; k++ ) {
+		int		front, back;
+
+		front = 0;
+		back = 0;
+
+		for ( l = 0 ; l < numPoints ; l++ ) {
+			int		side;
+
+			side = CM_PointOnPlaneSide( points[l], facet->borderPlanes[k] );
+			if ( side == SIDE_FRONT ) {
+				front++;
+			} if ( side == SIDE_BACK ) {
+				back++;
+			}
+		}
+
+		if ( front && !back ) {
+			facet->borderInward[k] = qtrue;
+		} else if ( back && !front ) {
+			facet->borderInward[k] = qfalse;
+		} else if ( !front && !back ) {
+			// flat side border
+			facet->borderPlanes[k] = -1;
+		} else {
+			// bisecting side border
+			Com_DPrintf( "WARNING: CM_SetBorderInward: mixed plane sides\n" );
+			facet->borderInward[k] = qfalse;
+			if ( !debugBlock ) {
+				debugBlock = qtrue;
+				VectorCopy( grid->points[i][j], debugBlockPoints[0] );
+				VectorCopy( grid->points[i+1][j], debugBlockPoints[1] );
+				VectorCopy( grid->points[i+1][j+1], debugBlockPoints[2] );
+				VectorCopy( grid->points[i][j+1], debugBlockPoints[3] );
+			}
+		}
+	}
+}
+
+/*
+==================
+CM_ValidateFacet
+
+If the facet isn't bounded by its borders, we screwed up.
+==================
+*/
+static inline qboolean CM_ValidateFacet( facetLoad_t *facet ) {
+	float		plane[4];
+	int			j;
+	winding_t	*w;
+	vec3_t		bounds[2];
+
+	if ( facet->surfacePlane == -1 ) {
+		return qfalse;
+	}
+
+	Vector4Copy( planes[ facet->surfacePlane ].plane, plane );
+	w = BaseWindingForPlane( plane,  plane[3] );
+	for ( j = 0 ; j < facet->numBorders && w ; j++ ) {
+		if ( facet->borderPlanes[j] == -1 ) {
+			FreeWinding(w);
+			return qfalse;
+		}
+		Vector4Copy( planes[ facet->borderPlanes[j] ].plane, plane );
+		if ( !facet->borderInward[j] ) {
+			VectorSubtract( vec3_origin, plane, plane );
+			plane[3] = -plane[3];
+		}
+		ChopWindingInPlace( &w, plane, plane[3], 0.1f );
+	}
+
+	if ( !w ) {
+		return qfalse;		// winding was completely chopped away
+	}
+
+	// see if the facet is unreasonably large
+	WindingBounds( w, bounds[0], bounds[1] );
+	FreeWinding( w );
+	
+	for ( j = 0 ; j < 3 ; j++ ) {
+		if ( bounds[1][j] - bounds[0][j] > MAX_MAP_BOUNDS ) {
+			return qfalse;		// we must be missing a plane
+		}
+		if ( bounds[0][j] >= MAX_MAP_BOUNDS ) {
+			return qfalse;
+		}
+		if ( bounds[1][j] <= -MAX_MAP_BOUNDS ) {
+			return qfalse;
+		}
+	}
+	return qtrue;		// winding is fine
+}
+
+/*
+==================
+CM_AddFacetBevels
+==================
+*/
+inline void CM_AddFacetBevels( facetLoad_t *facet ) {
+
+	int i, j, k, l;
+	int axis, dir, order, flipped;
+	float plane[4], d, newplane[4];
+	winding_t *w, *w2;
+	vec3_t mins, maxs, vec, vec2;
+
+#ifndef ADDBEVELS
+	return;
+#endif
+
+	Vector4Copy( planes[ facet->surfacePlane ].plane, plane );
+
+	w = BaseWindingForPlane( plane,  plane[3] );
+	for ( j = 0 ; j < facet->numBorders && w ; j++ ) {
+		if (facet->borderPlanes[j] == facet->surfacePlane) continue;
+		Vector4Copy( planes[ facet->borderPlanes[j] ].plane, plane );
+
+		if ( !facet->borderInward[j] ) {
+			VectorSubtract( vec3_origin, plane, plane );
+			plane[3] = -plane[3];
+		}
+
+		ChopWindingInPlace( &w, plane, plane[3], 0.1f );
+	}
+	if ( !w ) {
+		return;
+	}
+
+	WindingBounds(w, mins, maxs);
+
+	// add the axial planes
+	order = 0;
+	for ( axis = 0 ; axis < 3 ; axis++ )
+	{
+		for ( dir = -1 ; dir <= 1 ; dir += 2, order++ )
+		{
+			VectorClear(plane);
+			plane[axis] = dir;
+			if (dir == 1) {
+				plane[3] = maxs[axis];
+			}
+			else {
+				plane[3] = -mins[axis];
+			}
+			//if it's the surface plane
+			if (CM_PlaneEqual(&planes[facet->surfacePlane], plane, &flipped)) {
+				continue;
+			}
+			// see if the plane is allready present
+			for ( i = 0 ; i < facet->numBorders ; i++ ) {
+				if (CM_PlaneEqual(&planes[facet->borderPlanes[i]], plane, &flipped))
+					break;
+			}
+
+			if ( i == facet->numBorders ) {
+				if (facet->numBorders > 4 + 6 + 16) Com_Printf(S_COLOR_RED"ERROR: too many bevels\n");
+				int num = CM_FindPlane2(plane, &flipped);
+				assert(num > -32768 && num < 32768);
+				facet->borderPlanes[facet->numBorders] = num;
+				facet->borderNoAdjust[facet->numBorders] = 0;
+				facet->borderInward[facet->numBorders] = flipped;
+				facet->numBorders++;
+			}
+		}
+	}
+	//
+	// add the edge bevels
+	//
+	// test the non-axial plane edges
+	for ( j = 0 ; j < w->numpoints ; j++ )
+	{
+		k = (j+1)%w->numpoints;
+		VectorSubtract (w->p[j], w->p[k], vec);
+		//if it's a degenerate edge
+		if (VectorNormalize (vec) < 0.5)
+			continue;
+		CM_SnapVector(vec);
+		for ( k = 0; k < 3 ; k++ )
+			if ( vec[k] == -1 || vec[k] == 1 )
+				break;	// axial
+		if ( k < 3 )
+			continue;	// only test non-axial edges
+
+		// try the six possible slanted axials from this edge
+		for ( axis = 0 ; axis < 3 ; axis++ )
+		{
+			for ( dir = -1 ; dir <= 1 ; dir += 2 )
+			{
+				// construct a plane
+				VectorClear (vec2);
+				vec2[axis] = dir;
+				CrossProduct (vec, vec2, plane);
+				if (VectorNormalize (plane) < 0.5)
+					continue;
+				plane[3] = DotProduct (w->p[j], plane);
+
+				// if all the points of the facet winding are
+				// behind this plane, it is a proper edge bevel
+				for ( l = 0 ; l < w->numpoints ; l++ )
+				{
+					d = DotProduct (w->p[l], plane) - plane[3];
+					if (d > 0.1)
+						break;	// point in front
+				}
+				if ( l < w->numpoints )
+					continue;
+
+				//if it's the surface plane
+				if (CM_PlaneEqual(&planes[facet->surfacePlane], plane, &flipped)) {
+					continue;
+				}
+				// see if the plane is allready present
+				for ( i = 0 ; i < facet->numBorders ; i++ ) {
+					if (CM_PlaneEqual(&planes[facet->borderPlanes[i]], plane, &flipped)) {
+							break;
+					}
+				}
+
+				if ( i == facet->numBorders ) {
+					if (facet->numBorders > 4 + 6 + 16) Com_Printf(S_COLOR_RED"ERROR: too many bevels\n");
+					int num = CM_FindPlane2(plane, &flipped);
+					assert(num > -32768 && num < 32768);
+					facet->borderPlanes[facet->numBorders] = num;
+
+					for ( k = 0 ; k < facet->numBorders ; k++ ) {
+						if (facet->borderPlanes[facet->numBorders] ==
+							facet->borderPlanes[k]) Com_Printf("WARNING: bevel plane already used\n");
+					}
+
+					facet->borderNoAdjust[facet->numBorders] = 0;
+					facet->borderInward[facet->numBorders] = flipped;
+					//
+					w2 = CopyWinding(w);
+					Vector4Copy(planes[facet->borderPlanes[facet->numBorders]].plane, newplane);
+					if (!facet->borderInward[facet->numBorders])
+					{
+						VectorNegate(newplane, newplane);
+						newplane[3] = -newplane[3];
+					} //end if
+					ChopWindingInPlace( &w2, newplane, newplane[3], 0.1f );
+					if (!w2) {
+						Com_DPrintf("WARNING: CM_AddFacetBevels... invalid bevel\n");
+						continue;
+					}
+					else {
+						FreeWinding(w2);
+					}
+					//
+					facet->numBorders++;
+					//already got a bevel
+//					break;
+				}
+			}
+		}
+	}
+	FreeWinding( w );
+
+#ifndef BSPC
+	//add opposite plane
+	assert(facet->surfacePlane > -32768 && facet->surfacePlane < 32768);
+	facet->borderPlanes[facet->numBorders] = facet->surfacePlane;
+	facet->borderNoAdjust[facet->numBorders] = 0;
+	facet->borderInward[facet->numBorders] = qtrue;
+	facet->numBorders++;
+#endif //BSPC
+}
+
+typedef enum {
+	EN_TOP,
+	EN_RIGHT,
+	EN_BOTTOM,
+	EN_LEFT
+} edgeName_t;
+
+
+facetLoad_t*	cm_facets = 0;
+int*		cm_gridPlanes = 0;
+void CM_PatchCollideFromGridTempAlloc()
+{
+	if (!cm_facets)
+	{
+		cm_facets = (facetLoad_t*)Z_Malloc(MAX_PATCH_PLANES*sizeof(facetLoad_t), TAG_TEMP_WORKSPACE, qfalse);
+	}
+	if (!cm_gridPlanes)
+	{
+		cm_gridPlanes = (int*)Z_Malloc(CM_MAX_GRID_SIZE*CM_MAX_GRID_SIZE*2*sizeof(int), TAG_TEMP_WORKSPACE, qfalse);
+	}
+}
+
+void CM_PatchCollideFromGridTempDealloc()
+{
+	Z_Free(cm_gridPlanes);
+	Z_Free(cm_facets);
+	cm_gridPlanes = 0;
+	cm_facets = 0;
+}
+
+
+/*
+==================
+CM_PatchCollideFromGrid
+==================
+*/
+int min1 = 0, max1 = 0, min2 = 0, max2 = 0;
+static inline void CM_PatchCollideFromGrid( cGrid_t *grid, patchCollide_t *pf,
+									facetLoad_t *facetbuf, int *gridbuf ) {
+	int				i, j;
+	float			*p1, *p2, *p3;
+	int				*gridPlanes;
+	facetLoad_t			*facet;
+	int				borders[4];
+	int				noAdjust[4];
+	facetLoad_t			*facets;
+	int				numFacets;
+
+	facets = cm_facets;
+	if (facets == 0)
+	{
+		facets = facetbuf;
+	}
+	gridPlanes = cm_gridPlanes;
+	if (gridPlanes == 0)
+	{
+		gridPlanes = gridbuf;
+	}
+	
+	numPlanes = 0;
+	numFacets = 0;
+
+	// find the planes for each triangle of the grid
+	for ( i = 0 ; i < grid->width - 1 ; i++ ) {
+		for ( j = 0 ; j < grid->height - 1 ; j++ ) {
+			p1 = grid->points[i][j];
+			p2 = grid->points[i+1][j];
+			p3 = grid->points[i+1][j+1];
+			gridPlanes[i*CM_MAX_GRID_SIZE*2+j*2+0] = CM_FindPlane( p1, p2, p3 );
+
+			p1 = grid->points[i+1][j+1];
+			p2 = grid->points[i][j+1];
+			p3 = grid->points[i][j];
+			gridPlanes[i*CM_MAX_GRID_SIZE*2+j*2+1] = CM_FindPlane( p1, p2, p3 );
+		}
+	}
+
+	// create the borders for each facet
+	for ( i = 0 ; i < grid->width - 1 ; i++ ) {
+		for ( j = 0 ; j < grid->height - 1 ; j++ ) {
+			 
+			borders[EN_TOP] = -1;
+			if ( j > 0 ) {
+				borders[EN_TOP] = gridPlanes[i*CM_MAX_GRID_SIZE*2+(j-1)*2+1];
+			} else if ( grid->wrapHeight ) {
+				borders[EN_TOP] = gridPlanes[i*CM_MAX_GRID_SIZE*2+(grid->height-2)*2+1];
+			} 
+			noAdjust[EN_TOP] = ( borders[EN_TOP] == gridPlanes[i*CM_MAX_GRID_SIZE*2+j*2+0] );
+			if ( borders[EN_TOP] == -1 || noAdjust[EN_TOP] ) {
+				borders[EN_TOP] = CM_EdgePlaneNum( grid, gridPlanes, i, j, 0 );
+			}
+
+			borders[EN_BOTTOM] = -1;
+			if ( j < grid->height - 2 ) {
+				borders[EN_BOTTOM] = gridPlanes[i*CM_MAX_GRID_SIZE*2+(j+1)*2+0];
+			} else if ( grid->wrapHeight ) {
+				borders[EN_BOTTOM] = gridPlanes[i*CM_MAX_GRID_SIZE*2+0*2+0];
+			}
+			noAdjust[EN_BOTTOM] = ( borders[EN_BOTTOM] == gridPlanes[i*CM_MAX_GRID_SIZE*2+j*2+1] );
+			if ( borders[EN_BOTTOM] == -1 || noAdjust[EN_BOTTOM] ) {
+				borders[EN_BOTTOM] = CM_EdgePlaneNum( grid, gridPlanes, i, j, 2 );
+			}
+
+			borders[EN_LEFT] = -1;
+			if ( i > 0 ) {
+				borders[EN_LEFT] = gridPlanes[(i-1)*CM_MAX_GRID_SIZE*2+j*2+0];
+			} else if ( grid->wrapWidth ) {
+				borders[EN_LEFT] = gridPlanes[(grid->width-2)*CM_MAX_GRID_SIZE*2+j*2+0];
+			}
+			noAdjust[EN_LEFT] = ( borders[EN_LEFT] == gridPlanes[i*CM_MAX_GRID_SIZE*2+j*2+1] );
+			if ( borders[EN_LEFT] == -1 || noAdjust[EN_LEFT] ) {
+				borders[EN_LEFT] = CM_EdgePlaneNum( grid, gridPlanes, i, j, 3 );
+			}
+
+			borders[EN_RIGHT] = -1;
+			if ( i < grid->width - 2 ) {
+				borders[EN_RIGHT] = gridPlanes[(i+1)*CM_MAX_GRID_SIZE*2+j*2+1];
+			} else if ( grid->wrapWidth ) {
+				borders[EN_RIGHT] = gridPlanes[0*CM_MAX_GRID_SIZE*2+j*2+1];
+			}
+			noAdjust[EN_RIGHT] = ( borders[EN_RIGHT] == gridPlanes[i*CM_MAX_GRID_SIZE*2+j*2+0] );
+			if ( borders[EN_RIGHT] == -1 || noAdjust[EN_RIGHT] ) {
+				borders[EN_RIGHT] = CM_EdgePlaneNum( grid, gridPlanes, i, j, 1 );
+			}
+
+			if ( numFacets == MAX_FACETS ) {
+				Com_Error( ERR_DROP, "MAX_FACETS" );
+			}
+			facet = &facets[numFacets];
+			memset( facet, 0, sizeof( *facet ) );
+
+			if ( gridPlanes[i*CM_MAX_GRID_SIZE*2+j*2+0] == gridPlanes[i*CM_MAX_GRID_SIZE*2+j*2+1] ) {
+				if ( gridPlanes[i*CM_MAX_GRID_SIZE*2+j*2+0] == -1 ) {
+					continue;		// degenrate
+				}
+				facet->surfacePlane = gridPlanes[i*CM_MAX_GRID_SIZE*2+j*2+0];
+				facet->numBorders = 4;
+				facet->borderPlanes[0] = borders[EN_TOP];
+				assert(borders[EN_TOP] > -32768 && borders[EN_TOP] < 32768);
+				facet->borderNoAdjust[0] = noAdjust[EN_TOP];
+				assert(noAdjust[EN_TOP] >= 0 && noAdjust[EN_TOP] < 256);
+				facet->borderPlanes[1] = borders[EN_RIGHT];
+				assert(borders[EN_RIGHT] > -32768 && borders[EN_RIGHT] < 32768);
+				facet->borderNoAdjust[1] = noAdjust[EN_RIGHT];
+				assert(noAdjust[EN_RIGHT] >= 0 && noAdjust[EN_RIGHT] < 256);
+				facet->borderPlanes[2] = borders[EN_BOTTOM];
+				assert(borders[EN_BOTTOM] > -32768 && 
+						borders[EN_BOTTOM] < 32768);
+				facet->borderNoAdjust[2] = noAdjust[EN_BOTTOM];
+				assert(noAdjust[EN_BOTTOM] >= 0 && noAdjust[EN_BOTTOM] < 256);
+				facet->borderPlanes[3] = borders[EN_LEFT];
+				assert(borders[EN_LEFT] > -32768 && borders[EN_LEFT] < 32768);
+				facet->borderNoAdjust[3] = noAdjust[EN_LEFT];
+				assert(noAdjust[EN_LEFT] >= 0 && noAdjust[EN_LEFT] < 256);
+				CM_SetBorderInward( facet, grid, i, j, -1 );
+				if ( CM_ValidateFacet( facet ) ) {
+					CM_AddFacetBevels( facet );
+					numFacets++;
+				}
+			} else {
+				// two seperate triangles
+				facet->surfacePlane = gridPlanes[i*CM_MAX_GRID_SIZE*2+j*2+0];
+				facet->numBorders = 3;
+				facet->borderPlanes[0] = borders[EN_TOP];
+				assert(borders[EN_TOP] > -32768 && borders[EN_TOP] < 32768);
+				assert(noAdjust[EN_TOP] >= 0 && noAdjust[EN_TOP] < 256);
+				facet->borderNoAdjust[0] = noAdjust[EN_TOP];
+				facet->borderPlanes[1] = borders[EN_RIGHT];
+				assert(borders[EN_RIGHT] > -32768 && borders[EN_RIGHT] < 32768);
+				facet->borderNoAdjust[1] = noAdjust[EN_RIGHT];
+				assert(noAdjust[EN_RIGHT] >= 0 && noAdjust[EN_RIGHT] < 256);
+				facet->borderPlanes[2] = gridPlanes[i*CM_MAX_GRID_SIZE*2+j*2+1];
+				assert(gridPlanes[i*CM_MAX_GRID_SIZE*2+j*2+1] > -32768 &&
+						gridPlanes[i*CM_MAX_GRID_SIZE*2+j*2+1] < 32768);
+				if ( facet->borderPlanes[2] == -1 ) {
+					facet->borderPlanes[2] = borders[EN_BOTTOM];
+					assert(borders[EN_BOTTOM] > -32768 && 
+							borders[EN_BOTTOM] < 32768);
+					if ( facet->borderPlanes[2] == -1 ) {
+						int num = CM_EdgePlaneNum( grid, gridPlanes, i, j, 4 );
+						assert(num > -32768 && num < 32768);
+						facet->borderPlanes[2] = num;
+					}
+				}
+ 				CM_SetBorderInward( facet, grid, i, j, 0 );
+				if ( CM_ValidateFacet( facet ) ) {
+					CM_AddFacetBevels( facet );
+					numFacets++;
+				}
+
+				if ( numFacets == MAX_FACETS ) {
+					Com_Error( ERR_DROP, "MAX_FACETS" );
+				}
+				facet = &facets[numFacets];
+				memset( facet, 0, sizeof( *facet ) );
+
+				facet->surfacePlane = gridPlanes[i*CM_MAX_GRID_SIZE*2+j*2+1];
+				facet->numBorders = 3;
+				facet->borderPlanes[0] = borders[EN_BOTTOM];
+				assert(borders[EN_BOTTOM] > -32768 && 
+						borders[EN_BOTTOM] < 32768);
+				facet->borderNoAdjust[0] = noAdjust[EN_BOTTOM];
+				assert(noAdjust[EN_BOTTOM] >= 0 && noAdjust[EN_BOTTOM] < 256);
+				facet->borderPlanes[1] = borders[EN_LEFT];
+				assert(borders[EN_LEFT] > -32768 && borders[EN_LEFT] < 32768);
+				facet->borderNoAdjust[1] = noAdjust[EN_LEFT];
+				assert(noAdjust[EN_LEFT] >= 0 && noAdjust[EN_LEFT] < 256);
+				facet->borderPlanes[2] = gridPlanes[i*CM_MAX_GRID_SIZE*2+j*2+0];
+				assert(gridPlanes[i*CM_MAX_GRID_SIZE*2+j*2+0] > -32768 &&
+						gridPlanes[i*CM_MAX_GRID_SIZE*2+j*2+0] < 32768);
+				if ( facet->borderPlanes[2] == -1 ) {
+					facet->borderPlanes[2] = borders[EN_TOP];
+					assert(borders[EN_TOP] > -32768 && 
+							borders[EN_TOP] < 32768);
+					if ( facet->borderPlanes[2] == -1 ) {
+						int num = CM_EdgePlaneNum( grid, gridPlanes, i, j, 5 );
+						assert(num > -32768 && num < 32768);
+						facet->borderPlanes[2] = num;
+					}
+				}
+				CM_SetBorderInward( facet, grid, i, j, 1 );
+				if ( CM_ValidateFacet( facet ) ) {
+					CM_AddFacetBevels( facet );
+					numFacets++;
+				}
+			}
+		}
+	}
+
+	// copy the results out
+	pf->numPlanes = numPlanes;
+	pf->numFacets = numFacets;
+	if (numFacets)
+	{
+		pf->facets = (facet_t *) Z_Malloc( numFacets * sizeof( *pf->facets ), TAG_BSP, qfalse);
+		for(i=0; i<numFacets; i++) {
+			pf->facets[i].data = (char*)Z_Malloc(facets[i].numBorders * 4,
+					TAG_BSP, qfalse);
+			pf->facets[i].surfacePlane = facets[i].surfacePlane;
+			pf->facets[i].numBorders = facets[i].numBorders;
+			short *bp = pf->facets[i].GetBorderPlanes();
+			char *bi = pf->facets[i].GetBorderInward();
+			char *bna = pf->facets[i].GetBorderNoAdjust();
+			for(j=0; j<facets[i].numBorders; j++) {
+				bp[j] = facets[i].borderPlanes[j];
+				bi[j] = facets[i].borderInward[j];
+				bna[j] = facets[i].borderNoAdjust[j];
+			}
+		}
+	}
+	else 
+	{
+		pf->facets = 0;
+	}
+	pf->planes = (patchPlane_t *) Z_Malloc( numPlanes * sizeof( *pf->planes ), TAG_BSP, qfalse);
+	memcpy( pf->planes, planes, numPlanes * sizeof( *pf->planes ) );
+}
+
+static patchCollide_t *pfScratch = 0;
+void CM_PreparePatchCollide(int num)
+{
+	pfScratch = (patchCollide_t *) Z_Malloc( sizeof( *pfScratch ) * num, TAG_BSP, qfalse );
+}
+
+cGrid_t *cm_grid = 0;
+void CM_GridAlloc()
+{
+	if (cm_grid) return;
+	cm_grid = (cGrid_t*)Z_Malloc(sizeof(cGrid_t), TAG_TEMP_WORKSPACE, qfalse);
+}
+
+void CM_GridDealloc()
+{
+	Z_Free(cm_grid);
+	cm_grid = 0;
+}
+
+/*
+===================
+CM_GeneratePatchCollide
+
+Creates an internal structure that will be used to perform
+collision detection with a patch mesh.
+
+Points is packed as concatenated rows.
+===================
+*/
+struct patchCollide_s	*CM_GeneratePatchCollide( int width, int height, vec3_t *points,
+												 facetLoad_t *facetbuf, int *gridbuf ) {
+	patchCollide_t	*pf;
+// --AAA--AAA--
+//	cGrid_t			*grid = new cGrid_t;
+	cGrid_t			*grid = cm_grid;
+// --AAA--AAA--
+	int				i, j;
+
+	memset(grid, 0, sizeof(cGrid_t));
+	if ( width <= 2 || height <= 2 || !points ) {
+		Com_Error( ERR_DROP, "CM_GeneratePatchFacets: bad parameters: (%i, %i, %p)",
+			width, height, points );
+	}
+
+	if ( !(width & 1) || !(height & 1) ) {
+		Com_Error( ERR_DROP, "CM_GeneratePatchFacets: even sizes are invalid for quadratic meshes" );
+	}
+
+	if ( width > CM_MAX_GRID_SIZE || height > CM_MAX_GRID_SIZE ) {
+		Com_Error( ERR_DROP, "CM_GeneratePatchFacets: source is > CM_MAX_GRID_SIZE" );
+	}
+
+	// build a grid
+	grid->width = width;
+	grid->height = height;
+	grid->wrapWidth = qfalse;
+	grid->wrapHeight = qfalse;
+	for ( i = 0 ; i < width ; i++ ) {
+		for ( j = 0 ; j < height ; j++ ) {
+			VectorCopy( points[j*width + i], grid->points[i][j] );
+		}
+	}
+
+	// subdivide the grid
+	CM_SetGridWrapWidth( grid );
+	CM_SubdivideGridColumns( grid );
+	CM_RemoveDegenerateColumns( grid );
+
+	CM_TransposeGrid( grid );
+
+	CM_SetGridWrapWidth( grid );
+	CM_SubdivideGridColumns( grid );
+	CM_RemoveDegenerateColumns( grid );
+
+	// we now have a grid of points exactly on the curve
+	// the aproximate surface defined by these points will be
+	// collided against
+	
+	// --AAA--AAA--
+//	pf = (patchCollide_t *) Z_Malloc( sizeof( *pf ), TAG_BSP, qfalse );
+	pf = pfScratch++;
+	// --AAA--AAA--
+	
+	ClearBounds( pf->bounds[0], pf->bounds[1] );
+	for ( i = 0 ; i < grid->width ; i++ ) {
+		for ( j = 0 ; j < grid->height ; j++ ) {
+			AddPointToBounds( grid->points[i][j], pf->bounds[0], pf->bounds[1] );
+		}
+	}
+
+	c_totalPatchBlocks += ( grid->width - 1 ) * ( grid->height - 1 );
+
+	// generate a bsp tree for the surface
+	CM_PatchCollideFromGrid( grid, pf, facetbuf, gridbuf );
+
+	// expand by one unit for epsilon purposes
+	pf->bounds[0][0] -= 1;
+	pf->bounds[0][1] -= 1;
+	pf->bounds[0][2] -= 1;
+
+	pf->bounds[1][0] += 1;
+	pf->bounds[1][1] += 1;
+	pf->bounds[1][2] += 1;
+
+// --AAA--AAA--
+//	delete grid;
+// --AAA--AAA--
+
+	return pf;
+}
+
+/*
+================================================================================
+
+TRACE TESTING
+
+================================================================================
+*/
+
+/*
+====================
+CM_TracePointThroughPatchCollide
+
+  special case for point traces because the patch collide "brushes" have no volume
+====================
+*/
+static inline void CM_TracePointThroughPatchCollide( traceWork_t *tw, trace_t &trace, const struct patchCollide_s *pc ) {
+	qboolean	frontFacing[MAX_PATCH_PLANES];
+	float		intersection[MAX_PATCH_PLANES];
+	float		intersect;
+	const patchPlane_t	*planes;
+	const facet_t	*facet;
+	int			i, j, k;
+	float		offset;
+	float		d1, d2;
+#ifndef BSPC
+	static cvar_t *cv;
+#endif //BSPC
+
+#ifndef BSPC
+	if ( !cm_playerCurveClip->integer && !tw->isPoint ) {
+		return;		// FIXME: until I get player sized clipping working right
+	}
+#endif
+
+	if (!pc->numFacets)
+	{	//not gonna do anything anyhow?
+		return;
+	}
+	// determine the trace's relationship to all planes
+	planes = pc->planes;
+	for ( i = 0 ; i < pc->numPlanes ; i++, planes++ ) {
+		offset = DotProduct( tw->offsets[ planes->signbits ], planes->plane );
+		d1 = DotProduct( tw->start, planes->plane ) - planes->plane[3] + offset;
+		d2 = DotProduct( tw->end, planes->plane ) - planes->plane[3] + offset;
+		if ( d1 <= 0 ) {
+			frontFacing[i] = qfalse;
+		} else {
+			frontFacing[i] = qtrue;
+		}
+		if ( d1 == d2 ) {
+			intersection[i] = WORLD_SIZE;
+		} else {
+			intersection[i] = d1 / ( d1 - d2 );
+			if ( intersection[i] <= 0 ) {
+				intersection[i] = WORLD_SIZE;
+			}
+		}
+	}
+
+
+	// see if any of the surface planes are intersected
+	facet = pc->facets;
+	for ( i = 0 ; i < pc->numFacets ; i++, facet++ ) {
+		if ( !frontFacing[facet->surfacePlane] ) {
+			continue;
+		}
+		intersect = intersection[facet->surfacePlane];
+		if ( intersect < 0 ) {
+			continue;		// surface is behind the starting point
+		}
+		if ( intersect > trace.fraction ) {
+			continue;		// already hit something closer
+		}
+		for ( j = 0 ; j < facet->numBorders ; j++ ) {
+			k = facet->GetBorderPlanes()[j];
+			if ( frontFacing[k] ^ facet->GetBorderInward()[j] ) {
+				if ( intersection[k] > intersect ) {
+					break;
+				}
+			} else {
+				if ( intersection[k] < intersect ) {
+					break;
+				}
+			}
+		}
+		if ( j == facet->numBorders ) {
+			// we hit this facet
+#ifndef BSPC
+			if (!cv) {
+				cv = Cvar_Get( "r_debugSurfaceUpdate", "1", 0 );
+			}
+			if (cv->integer) {
+				debugPatchCollide = pc;
+				debugFacet = facet;
+			}
+#endif //BSPC
+			planes = &pc->planes[facet->surfacePlane];
+
+			// calculate intersection with a slight pushoff
+			offset = DotProduct( tw->offsets[ planes->signbits ], planes->plane );
+			d1 = DotProduct( tw->start, planes->plane ) - planes->plane[3] + offset;
+			d2 = DotProduct( tw->end, planes->plane ) - planes->plane[3] + offset;
+			trace.fraction = ( d1 - SURFACE_CLIP_EPSILON ) / ( d1 - d2 );
+
+			if ( trace.fraction < 0 ) {
+				trace.fraction = 0;
+			}
+
+			VectorCopy( planes->plane,  trace.plane.normal );
+			trace.plane.dist = planes->plane[3];
+		}
+	}
+}
+
+/*
+====================
+CM_CheckFacetPlane
+====================
+*/
+static inline int CM_CheckFacetPlane(float *plane, vec3_t start, vec3_t end, float *enterFrac, float *leaveFrac, int *hit) {
+	float d1, d2, f;
+
+	*hit = qfalse;
+
+	d1 = DotProduct( start, plane ) - plane[3];
+	d2 = DotProduct( end, plane ) - plane[3];
+
+	// if completely in front of face, no intersection with the entire facet
+	if (d1 > 0 && ( d2 >= SURFACE_CLIP_EPSILON || d2 >= d1 )  ) {
+		return qfalse;
+	}
+
+	// if it doesn't cross the plane, the plane isn't relevent
+	if (d1 <= 0 && d2 <= 0 ) {
+		return qtrue;
+	}
+
+	// crosses face
+	if (d1 > d2) {	// enter
+		f = (d1-SURFACE_CLIP_EPSILON) / (d1-d2);
+		if ( f < 0 ) {
+			f = 0;
+		}
+		//always favor previous plane hits and thus also the surface plane hit
+		if (f > *enterFrac) {
+			*enterFrac = f;
+			*hit = qtrue;
+		}
+	} else {	// leave
+		f = (d1+SURFACE_CLIP_EPSILON) / (d1-d2);
+		if ( f > 1 ) {
+			f = 1;
+		}
+		if (f < *leaveFrac) {
+			*leaveFrac = f;
+		}
+	}
+	return qtrue;
+}
+
+/*
+====================
+CM_TraceThroughPatchCollide
+====================
+*/
+void CM_TraceThroughPatchCollide( traceWork_t *tw, trace_t &trace, const struct patchCollide_s *pc )
+{
+	int i, j, hit, hitnum;
+	float offset, enterFrac, leaveFrac, t;
+	patchPlane_t *planes;
+	facet_t	*facet;
+	float plane[4], bestplane[4];
+	vec3_t startp, endp;
+#ifndef BSPC
+	static cvar_t *cv;
+#endif //BSPC
+
+#ifndef CULL_BBOX
+	// I'm not sure if test is strictly correct.  Are all
+	// bboxes axis aligned?  Do I care?  It seems to work
+	// good enough...
+	for ( i = 0 ; i < 3 ; i++ ) {
+		if ( tw->bounds[0][i] > pc->bounds[1][i]
+			|| tw->bounds[1][i] < pc->bounds[0][i] ) {
+			return;
+		}
+	}
+#endif
+
+	if (tw->isPoint) {
+
+		CM_TracePointThroughPatchCollide( tw, trace, pc );
+		return;
+	}
+	//
+	facet = pc->facets;
+	for ( i = 0 ; i < pc->numFacets ; i++, facet++ ) {
+		enterFrac = -1.0;
+		leaveFrac = 1.0;
+		hitnum = -1;
+		//
+		planes = &pc->planes[ facet->surfacePlane ];
+		VectorCopy(planes->plane, plane);
+		plane[3] = planes->plane[3];
+		if ( tw->sphere.use ) {
+			// adjust the plane distance apropriately for radius
+			plane[3] += tw->sphere.radius;
+
+			// find the closest point on the capsule to the plane
+			t = DotProduct( plane, tw->sphere.offset );
+			if ( t > 0.0f )
+			{
+				VectorSubtract( tw->start, tw->sphere.offset, startp );
+				VectorSubtract( tw->end, tw->sphere.offset, endp );
+			}
+			else
+			{
+				VectorAdd( tw->start, tw->sphere.offset, startp );
+				VectorAdd( tw->end, tw->sphere.offset, endp );
+			}
+		}
+		else {
+			offset = DotProduct( tw->offsets[ planes->signbits ], plane);
+			plane[3] -= offset;
+			VectorCopy( tw->start, startp );
+			VectorCopy( tw->end, endp );
+		}
+		if (!CM_CheckFacetPlane(plane, startp, endp, &enterFrac, &leaveFrac, &hit)) {
+			continue;
+		}
+		if (hit) {
+			Vector4Copy(plane, bestplane);
+		}
+		for ( j = 0 ; j < facet->numBorders ; j++ ) {
+			planes = &pc->planes[ facet->GetBorderPlanes()[j] ];
+			if (facet->GetBorderInward()[j]) {
+				VectorNegate(planes->plane, plane);
+				plane[3] = -planes->plane[3];
+			}
+			else {
+				VectorCopy(planes->plane, plane);
+				plane[3] = planes->plane[3];
+			}
+			if ( tw->sphere.use ) {
+				// adjust the plane distance apropriately for radius
+				plane[3] += tw->sphere.radius;
+
+				// find the closest point on the capsule to the plane
+				t = DotProduct( plane, tw->sphere.offset );
+				if ( t > 0.0f )
+				{
+					VectorSubtract( tw->start, tw->sphere.offset, startp );
+					VectorSubtract( tw->end, tw->sphere.offset, endp );
+				}
+				else
+				{
+					VectorAdd( tw->start, tw->sphere.offset, startp );
+					VectorAdd( tw->end, tw->sphere.offset, endp );
+				}
+			}
+			else {
+				// NOTE: this works even though the plane might be flipped because the bbox is centered
+				offset = DotProduct( tw->offsets[ planes->signbits ], plane);
+				plane[3] += Q_fabs(offset);
+				VectorCopy( tw->start, startp );
+				VectorCopy( tw->end, endp );
+			}
+			if (!CM_CheckFacetPlane(plane, startp, endp, &enterFrac, &leaveFrac, &hit)) {
+				break;
+			}
+			if (hit) {
+				hitnum = j;
+				Vector4Copy(plane, bestplane);
+			}
+		}
+		if (j < facet->numBorders) continue;
+		//never clip against the back side
+		if (hitnum == facet->numBorders - 1) continue;
+		if (enterFrac < leaveFrac && enterFrac >= 0) {
+			if (enterFrac < trace.fraction) {
+				if (enterFrac < 0) {
+					enterFrac = 0;
+				}
+#ifndef BSPC
+				if (!cv) {
+					cv = Cvar_Get( "r_debugSurfaceUpdate", "1", 0 );
+				}
+				if (cv && cv->integer) {
+					debugPatchCollide = pc;
+					debugFacet = facet;
+				}
+#endif // BSPC
+
+				trace.fraction = enterFrac;
+				VectorCopy( bestplane, trace.plane.normal );
+				trace.plane.dist = bestplane[3];
+			}
+		}
+	}
+}
+
+/*
+=======================================================================
+
+POSITION DETECTION
+
+=======================================================================
+*/
+
+/*
+====================
+CM_PositionTestInPatchCollide
+
+Modifies tr->tr if any of the facets effect the trace
+====================
+*/
+qboolean CM_PositionTestInPatchCollide( traceWork_t *tw, const struct patchCollide_s *pc ) {
+	int i, j;
+	float offset, t;
+	patchPlane_t *planes;
+	facet_t	*facet;
+	float plane[4];
+	vec3_t startp;
+
+	if (tw->isPoint) {
+		return qfalse;
+	}
+	//
+	facet = pc->facets;
+	for ( i = 0 ; i < pc->numFacets ; i++, facet++ ) {
+		planes = &pc->planes[ facet->surfacePlane ];
+		VectorCopy(planes->plane, plane);
+		plane[3] = planes->plane[3];
+		if ( tw->sphere.use ) {
+			// adjust the plane distance apropriately for radius
+			plane[3] += tw->sphere.radius;
+
+			// find the closest point on the capsule to the plane
+			t = DotProduct( plane, tw->sphere.offset );
+			if ( t > 0 ) {
+				VectorSubtract( tw->start, tw->sphere.offset, startp );
+			}
+			else {
+				VectorAdd( tw->start, tw->sphere.offset, startp );
+			}
+		}
+		else {
+			offset = DotProduct( tw->offsets[ planes->signbits ], plane);
+			plane[3] -= offset;
+			VectorCopy( tw->start, startp );
+		}
+
+		if ( DotProduct( plane, startp ) - plane[3] > 0.0f ) {
+			continue;
+		}
+
+		for ( j = 0; j < facet->numBorders; j++ ) {
+//			planes = &pc->planes[ facet->borderPlanes[j] ];
+			planes = &pc->planes[ facet->GetBorderPlanes()[j] ];
+//			if (facet->borderInward[j]) {
+			if (facet->GetBorderInward()[j]) {
+				VectorNegate(planes->plane, plane);
+				plane[3] = -planes->plane[3];
+			}
+			else {
+				VectorCopy(planes->plane, plane);
+				plane[3] = planes->plane[3];
+			}
+			if ( tw->sphere.use ) {
+				// adjust the plane distance apropriately for radius
+				plane[3] += tw->sphere.radius;
+
+				// find the closest point on the capsule to the plane
+				t = DotProduct( plane, tw->sphere.offset );
+				if ( t > 0.0f ) {
+					VectorSubtract( tw->start, tw->sphere.offset, startp );
+				}
+				else {
+					VectorAdd( tw->start, tw->sphere.offset, startp );
+				}
+			}
+			else {
+				// NOTE: this works even though the plane might be flipped because the bbox is centered
+				offset = DotProduct( tw->offsets[ planes->signbits ], plane);
+				plane[3] += fabs(offset);
+				VectorCopy( tw->start, startp );
+			}
+
+			if ( DotProduct( plane, startp ) - plane[3] > 0.0f ) {
+				break;
+			}
+		}
+		if (j < facet->numBorders) {
+			continue;
+
+		}
+		// inside this patch facet
+		return qtrue;
+	}
+
+	return qfalse;
+}
+
+/*
+=======================================================================
+
+DEBUGGING
+
+=======================================================================
+*/
+
+
+/*
+==================
+CM_DrawDebugSurface
+
+Called from the renderer
+==================
+*/
+#ifndef BSPC
+void BotDrawDebugPolygons(void (*drawPoly)(int color, int numPoints, float *points), int value);
+#endif
+
+void CM_DrawDebugSurface( void (*drawPoly)(int color, int numPoints, float *points) ) {
+
+}
\ No newline at end of file
diff --git a/codemp/qcommon/cm_polylib.cpp b/codemp/qcommon/cm_polylib.cpp
new file mode 100644
index 0000000..61f2526
--- /dev/null
+++ b/codemp/qcommon/cm_polylib.cpp
@@ -0,0 +1,713 @@
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+// this is only used for visualization tools in cm_ debug functions
+
+
+#include "cm_local.h"
+
+
+// counters are only bumped when running single threaded,
+// because they are an awefull coherence problem
+int	c_active_windings;
+int	c_peak_windings;
+int	c_winding_allocs;
+int	c_winding_points;
+
+void pw(winding_t *w)
+{
+	int		i;
+	for (i=0 ; i<w->numpoints ; i++)
+		printf ("(%5.1f, %5.1f, %5.1f)\n",w->p[i][0], w->p[i][1],w->p[i][2]);
+}
+
+
+/*
+=============
+AllocWinding
+=============
+*/
+winding_t	*AllocWinding (int points)
+{
+	winding_t	*w;
+	int			s;
+
+	c_winding_allocs++;
+	c_winding_points += points;
+	c_active_windings++;
+	if (c_active_windings > c_peak_windings)
+		c_peak_windings = c_active_windings;
+
+	s = sizeof(vec_t)*3*points + sizeof(int);
+	w = (winding_t *)Z_Malloc (s, TAG_BSP, qtrue);
+//	Com_Memset (w, 0, s); // qtrue param in Z_Malloc does this
+	return w;
+}
+
+void FreeWinding (winding_t *w)
+{
+	if (*(unsigned *)w == 0xdeaddead)
+		Com_Error (ERR_FATAL, "FreeWinding: freed a freed winding");
+	*(unsigned *)w = 0xdeaddead;
+
+	c_active_windings--;
+	Z_Free (w);
+}
+
+/*
+============
+RemoveColinearPoints
+============
+*/
+int	c_removed;
+
+void	RemoveColinearPoints (winding_t *w)
+{
+	int		i, j, k;
+	vec3_t	v1, v2;
+	int		nump;
+	vec3_t	p[MAX_POINTS_ON_WINDING];
+
+	nump = 0;
+	for (i=0 ; i<w->numpoints ; i++)
+	{
+		j = (i+1)%w->numpoints;
+		k = (i+w->numpoints-1)%w->numpoints;
+		VectorSubtract (w->p[j], w->p[i], v1);
+		VectorSubtract (w->p[i], w->p[k], v2);
+		VectorNormalize2(v1,v1);
+		VectorNormalize2(v2,v2);
+		if (DotProduct(v1, v2) < 0.999)
+		{
+			VectorCopy (w->p[i], p[nump]);
+			nump++;
+		}
+	}
+
+	if (nump == w->numpoints)
+		return;
+
+	c_removed += w->numpoints - nump;
+	w->numpoints = nump;
+	Com_Memcpy (w->p, p, nump*sizeof(p[0]));
+}
+
+/*
+============
+WindingPlane
+============
+*/
+void WindingPlane (winding_t *w, vec3_t normal, vec_t *dist)
+{
+	vec3_t	v1, v2;
+
+	VectorSubtract (w->p[1], w->p[0], v1);
+	VectorSubtract (w->p[2], w->p[0], v2);
+	CrossProduct (v2, v1, normal);
+	VectorNormalize2(normal, normal);
+	*dist = DotProduct (w->p[0], normal);
+
+}
+
+/*
+=============
+WindingArea
+=============
+*/
+vec_t	WindingArea (winding_t *w)
+{
+	int		i;
+	vec3_t	d1, d2, cross;
+	vec_t	total;
+
+	total = 0;
+	for (i=2 ; i<w->numpoints ; i++)
+	{
+		VectorSubtract (w->p[i-1], w->p[0], d1);
+		VectorSubtract (w->p[i], w->p[0], d2);
+		CrossProduct (d1, d2, cross);
+		total += 0.5 * VectorLength ( cross );
+	}
+	return total;
+}
+
+void	WindingBounds (winding_t *w, vec3_t mins, vec3_t maxs)
+{
+	vec_t	v;
+	int		i,j;
+
+	mins[0] = mins[1] = mins[2] = MAX_MAP_BOUNDS;
+	maxs[0] = maxs[1] = maxs[2] = -MAX_MAP_BOUNDS;
+
+	for (i=0 ; i<w->numpoints ; i++)
+	{
+		for (j=0 ; j<3 ; j++)
+		{
+			v = w->p[i][j];
+			if (v < mins[j])
+				mins[j] = v;
+			if (v > maxs[j])
+				maxs[j] = v;
+		}
+	}
+}
+
+/*
+=============
+WindingCenter
+=============
+*/
+void	WindingCenter (winding_t *w, vec3_t center)
+{
+	int		i;
+	float	scale;
+
+	VectorCopy (vec3_origin, center);
+	for (i=0 ; i<w->numpoints ; i++)
+		VectorAdd (w->p[i], center, center);
+
+	scale = 1.0/w->numpoints;
+	VectorScale (center, scale, center);
+}
+
+/*
+=================
+BaseWindingForPlane
+=================
+*/
+winding_t *BaseWindingForPlane (vec3_t normal, vec_t dist)
+{
+	int		i, x;
+	vec_t	max, v;
+	vec3_t	org, vright, vup;
+	winding_t	*w;
+	
+// find the major axis
+
+	max = -MAX_MAP_BOUNDS;
+	x = -1;
+	for (i=0 ; i<3; i++)
+	{
+		v = fabs(normal[i]);
+		if (v > max)
+		{
+			x = i;
+			max = v;
+		}
+	}
+	if (x==-1)
+		Com_Error (ERR_DROP, "BaseWindingForPlane: no axis found");
+		
+	VectorCopy (vec3_origin, vup);	
+	switch (x)
+	{
+	case 0:
+	case 1:
+		vup[2] = 1;
+		break;		
+	case 2:
+		vup[0] = 1;
+		break;		
+	}
+
+	v = DotProduct (vup, normal);
+	VectorMA (vup, -v, normal, vup);
+	VectorNormalize2(vup, vup);
+		
+	VectorScale (normal, dist, org);
+	
+	CrossProduct (vup, normal, vright);
+	
+	VectorScale (vup, MAX_MAP_BOUNDS, vup);
+	VectorScale (vright, MAX_MAP_BOUNDS, vright);
+
+// project a really big	axis aligned box onto the plane
+	w = AllocWinding (4);
+	
+	VectorSubtract (org, vright, w->p[0]);
+	VectorAdd (w->p[0], vup, w->p[0]);
+	
+	VectorAdd (org, vright, w->p[1]);
+	VectorAdd (w->p[1], vup, w->p[1]);
+	
+	VectorAdd (org, vright, w->p[2]);
+	VectorSubtract (w->p[2], vup, w->p[2]);
+	
+	VectorSubtract (org, vright, w->p[3]);
+	VectorSubtract (w->p[3], vup, w->p[3]);
+	
+	w->numpoints = 4;
+	
+	return w;	
+}
+
+/*
+==================
+CopyWinding
+==================
+*/
+winding_t	*CopyWinding (winding_t *w)
+{
+	int			size;
+	winding_t	*c;
+
+	c = AllocWinding (w->numpoints);
+	size = (int)((winding_t *)0)->p[w->numpoints];
+	Com_Memcpy (c, w, size);
+	return c;
+}
+
+/*
+==================
+ReverseWinding
+==================
+*/
+winding_t	*ReverseWinding (winding_t *w)
+{
+	int			i;
+	winding_t	*c;
+
+	c = AllocWinding (w->numpoints);
+	for (i=0 ; i<w->numpoints ; i++)
+	{
+		VectorCopy (w->p[w->numpoints-1-i], c->p[i]);
+	}
+	c->numpoints = w->numpoints;
+	return c;
+}
+
+
+/*
+=============
+ClipWindingEpsilon
+=============
+*/
+void	ClipWindingEpsilon (winding_t *in, vec3_t normal, vec_t dist, 
+				vec_t epsilon, winding_t **front, winding_t **back)
+{
+	vec_t	dists[MAX_POINTS_ON_WINDING+4];
+	int		sides[MAX_POINTS_ON_WINDING+4];
+	int		counts[3];
+	static	vec_t	dot;		// VC 4.2 optimizer bug if not static
+	int		i, j;
+	vec_t	*p1, *p2;
+	vec3_t	mid;
+	winding_t	*f, *b;
+	int		maxpts;
+	
+	counts[0] = counts[1] = counts[2] = 0;
+
+// determine sides for each point
+	for (i=0 ; i<in->numpoints ; i++)
+	{
+		dot = DotProduct (in->p[i], normal);
+		dot -= dist;
+		dists[i] = dot;
+		if (dot > epsilon)
+			sides[i] = SIDE_FRONT;
+		else if (dot < -epsilon)
+			sides[i] = SIDE_BACK;
+		else
+		{
+			sides[i] = SIDE_ON;
+		}
+		counts[sides[i]]++;
+	}
+	sides[i] = sides[0];
+	dists[i] = dists[0];
+	
+	*front = *back = NULL;
+
+	if (!counts[0])
+	{
+		*back = CopyWinding (in);
+		return;
+	}
+	if (!counts[1])
+	{
+		*front = CopyWinding (in);
+		return;
+	}
+
+	maxpts = in->numpoints+4;	// cant use counts[0]+2 because
+								// of fp grouping errors
+
+	*front = f = AllocWinding (maxpts);
+	*back = b = AllocWinding (maxpts);
+		
+	for (i=0 ; i<in->numpoints ; i++)
+	{
+		p1 = in->p[i];
+		
+		if (sides[i] == SIDE_ON)
+		{
+			VectorCopy (p1, f->p[f->numpoints]);
+			f->numpoints++;
+			VectorCopy (p1, b->p[b->numpoints]);
+			b->numpoints++;
+			continue;
+		}
+	
+		if (sides[i] == SIDE_FRONT)
+		{
+			VectorCopy (p1, f->p[f->numpoints]);
+			f->numpoints++;
+		}
+		if (sides[i] == SIDE_BACK)
+		{
+			VectorCopy (p1, b->p[b->numpoints]);
+			b->numpoints++;
+		}
+
+		if (sides[i+1] == SIDE_ON || sides[i+1] == sides[i])
+			continue;
+			
+	// generate a split point
+		p2 = in->p[(i+1)%in->numpoints];
+		
+		dot = dists[i] / (dists[i]-dists[i+1]);
+		for (j=0 ; j<3 ; j++)
+		{	// avoid round off error when possible
+			if (normal[j] == 1)
+				mid[j] = dist;
+			else if (normal[j] == -1)
+				mid[j] = -dist;
+			else
+				mid[j] = p1[j] + dot*(p2[j]-p1[j]);
+		}
+			
+		VectorCopy (mid, f->p[f->numpoints]);
+		f->numpoints++;
+		VectorCopy (mid, b->p[b->numpoints]);
+		b->numpoints++;
+	}
+	
+	if (f->numpoints > maxpts || b->numpoints > maxpts)
+		Com_Error (ERR_DROP, "ClipWinding: points exceeded estimate");
+	if (f->numpoints > MAX_POINTS_ON_WINDING || b->numpoints > MAX_POINTS_ON_WINDING)
+		Com_Error (ERR_DROP, "ClipWinding: MAX_POINTS_ON_WINDING");
+}
+
+
+/*
+=============
+ChopWindingInPlace
+=============
+*/
+void ChopWindingInPlace (winding_t **inout, vec3_t normal, vec_t dist, vec_t epsilon)
+{
+	winding_t	*in;
+	vec_t	dists[MAX_POINTS_ON_WINDING+4];
+	int		sides[MAX_POINTS_ON_WINDING+4];
+	int		counts[3];
+	static	vec_t	dot;		// VC 4.2 optimizer bug if not static
+	int		i, j;
+	vec_t	*p1, *p2;
+	vec3_t	mid;
+	winding_t	*f;
+	int		maxpts;
+
+	in = *inout;
+	counts[0] = counts[1] = counts[2] = 0;
+
+// determine sides for each point
+	for (i=0 ; i<in->numpoints ; i++)
+	{
+		dot = DotProduct (in->p[i], normal);
+		dot -= dist;
+		dists[i] = dot;
+		if (dot > epsilon)
+			sides[i] = SIDE_FRONT;
+		else if (dot < -epsilon)
+			sides[i] = SIDE_BACK;
+		else
+		{
+			sides[i] = SIDE_ON;
+		}
+		counts[sides[i]]++;
+	}
+	sides[i] = sides[0];
+	dists[i] = dists[0];
+	
+	if (!counts[0])
+	{
+		FreeWinding (in);
+		*inout = NULL;
+		return;
+	}
+	if (!counts[1])
+		return;		// inout stays the same
+
+	maxpts = in->numpoints+4;	// cant use counts[0]+2 because
+								// of fp grouping errors
+
+	f = AllocWinding (maxpts);
+		
+	for (i=0 ; i<in->numpoints ; i++)
+	{
+		p1 = in->p[i];
+		
+		if (sides[i] == SIDE_ON)
+		{
+			VectorCopy (p1, f->p[f->numpoints]);
+			f->numpoints++;
+			continue;
+		}
+	
+		if (sides[i] == SIDE_FRONT)
+		{
+			VectorCopy (p1, f->p[f->numpoints]);
+			f->numpoints++;
+		}
+
+		if (sides[i+1] == SIDE_ON || sides[i+1] == sides[i])
+			continue;
+			
+	// generate a split point
+		p2 = in->p[(i+1)%in->numpoints];
+		
+		dot = dists[i] / (dists[i]-dists[i+1]);
+		for (j=0 ; j<3 ; j++)
+		{	// avoid round off error when possible
+			if (normal[j] == 1)
+				mid[j] = dist;
+			else if (normal[j] == -1)
+				mid[j] = -dist;
+			else
+				mid[j] = p1[j] + dot*(p2[j]-p1[j]);
+		}
+			
+		VectorCopy (mid, f->p[f->numpoints]);
+		f->numpoints++;
+	}
+	
+	if (f->numpoints > maxpts)
+		Com_Error (ERR_DROP, "ClipWinding: points exceeded estimate");
+	if (f->numpoints > MAX_POINTS_ON_WINDING)
+		Com_Error (ERR_DROP, "ClipWinding: MAX_POINTS_ON_WINDING");
+
+	FreeWinding (in);
+	*inout = f;
+}
+
+
+/*
+=================
+ChopWinding
+
+Returns the fragment of in that is on the front side
+of the cliping plane.  The original is freed.
+=================
+*/
+winding_t	*ChopWinding (winding_t *in, vec3_t normal, vec_t dist)
+{
+	winding_t	*f, *b;
+
+	ClipWindingEpsilon (in, normal, dist, ON_EPSILON, &f, &b);
+	FreeWinding (in);
+	if (b)
+		FreeWinding (b);
+	return f;
+}
+
+
+/*
+=================
+CheckWinding
+
+=================
+*/
+void CheckWinding (winding_t *w)
+{
+	int		i, j;
+	vec_t	*p1, *p2;
+	vec_t	d, edgedist;
+	vec3_t	dir, edgenormal, facenormal;
+	vec_t	area;
+	vec_t	facedist;
+
+	if (w->numpoints < 3)
+		Com_Error (ERR_DROP, "CheckWinding: %i points",w->numpoints);
+	
+	area = WindingArea(w);
+	if (area < 1)
+		Com_Error (ERR_DROP, "CheckWinding: %f area", area);
+
+	WindingPlane (w, facenormal, &facedist);
+	
+	for (i=0 ; i<w->numpoints ; i++)
+	{
+		p1 = w->p[i];
+
+		for (j=0 ; j<3 ; j++)
+			if (p1[j] > MAX_MAP_BOUNDS || p1[j] < -MAX_MAP_BOUNDS)
+				Com_Error (ERR_DROP, "CheckFace: BUGUS_RANGE: %f",p1[j]);
+
+		j = i+1 == w->numpoints ? 0 : i+1;
+		
+	// check the point is on the face plane
+		d = DotProduct (p1, facenormal) - facedist;
+		if (d < -ON_EPSILON || d > ON_EPSILON)
+			Com_Error (ERR_DROP, "CheckWinding: point off plane");
+	
+	// check the edge isnt degenerate
+		p2 = w->p[j];
+		VectorSubtract (p2, p1, dir);
+		
+		if (VectorLength (dir) < ON_EPSILON)
+			Com_Error (ERR_DROP, "CheckWinding: degenerate edge");
+			
+		CrossProduct (facenormal, dir, edgenormal);
+		VectorNormalize2 (edgenormal, edgenormal);
+		edgedist = DotProduct (p1, edgenormal);
+		edgedist += ON_EPSILON;
+		
+	// all other points must be on front side
+		for (j=0 ; j<w->numpoints ; j++)
+		{
+			if (j == i)
+				continue;
+			d = DotProduct (w->p[j], edgenormal);
+			if (d > edgedist)
+				Com_Error (ERR_DROP, "CheckWinding: non-convex");
+		}
+	}
+}
+
+
+/*
+============
+WindingOnPlaneSide
+============
+*/
+int		WindingOnPlaneSide (winding_t *w, vec3_t normal, vec_t dist)
+{
+	qboolean	front, back;
+	int			i;
+	vec_t		d;
+
+	front = qfalse;
+	back = qfalse;
+	for (i=0 ; i<w->numpoints ; i++)
+	{
+		d = DotProduct (w->p[i], normal) - dist;
+		if (d < -ON_EPSILON)
+		{
+			if (front)
+				return SIDE_CROSS;
+			back = qtrue;
+			continue;
+		}
+		if (d > ON_EPSILON)
+		{
+			if (back)
+				return SIDE_CROSS;
+			front = qtrue;
+			continue;
+		}
+	}
+
+	if (back)
+		return SIDE_BACK;
+	if (front)
+		return SIDE_FRONT;
+	return SIDE_ON;
+}
+
+
+/*
+=================
+AddWindingToConvexHull
+
+Both w and *hull are on the same plane
+=================
+*/
+#define	MAX_HULL_POINTS		128
+void	AddWindingToConvexHull( winding_t *w, winding_t **hull, vec3_t normal ) {
+	int			i, j, k;
+	float		*p, *copy;
+	vec3_t		dir;
+	float		d;
+	int			numHullPoints, numNew;
+	vec3_t		hullPoints[MAX_HULL_POINTS];
+	vec3_t		newHullPoints[MAX_HULL_POINTS];
+	vec3_t		hullDirs[MAX_HULL_POINTS];
+	qboolean	hullSide[MAX_HULL_POINTS];
+	qboolean	outside;
+
+	if ( !*hull ) {
+		*hull = CopyWinding( w );
+		return;
+	}
+
+	numHullPoints = (*hull)->numpoints;
+	Com_Memcpy( hullPoints, (*hull)->p, numHullPoints * sizeof(vec3_t) );
+
+	for ( i = 0 ; i < w->numpoints ; i++ ) {
+		p = w->p[i];
+
+		// calculate hull side vectors
+		for ( j = 0 ; j < numHullPoints ; j++ ) {
+			k = ( j + 1 ) % numHullPoints;
+
+			VectorSubtract( hullPoints[k], hullPoints[j], dir );
+			VectorNormalize2( dir, dir );
+			CrossProduct( normal, dir, hullDirs[j] );
+		}
+
+		outside = qfalse;
+		for ( j = 0 ; j < numHullPoints ; j++ ) {
+			VectorSubtract( p, hullPoints[j], dir );
+			d = DotProduct( dir, hullDirs[j] );
+			if ( d >= ON_EPSILON ) {
+				outside = qtrue;
+			}
+			if ( d >= -ON_EPSILON ) {
+				hullSide[j] = qtrue;
+			} else {
+				hullSide[j] = qfalse;
+			}
+		}
+
+		// if the point is effectively inside, do nothing
+		if ( !outside ) {
+			continue;
+		}
+
+		// find the back side to front side transition
+		for ( j = 0 ; j < numHullPoints ; j++ ) {
+			if ( !hullSide[ j % numHullPoints ] && hullSide[ (j + 1) % numHullPoints ] ) {
+				break;
+			}
+		}
+		if ( j == numHullPoints ) {
+			continue;
+		}
+
+		// insert the point here
+		VectorCopy( p, newHullPoints[0] );
+		numNew = 1;
+
+		// copy over all points that aren't double fronts
+		j = (j+1)%numHullPoints;
+		for ( k = 0 ; k < numHullPoints ; k++ ) {
+			if ( hullSide[ (j+k) % numHullPoints ] && hullSide[ (j+k+1) % numHullPoints ] ) {
+				continue;
+			}
+			copy = hullPoints[ (j+k+1) % numHullPoints ];
+			VectorCopy( copy, newHullPoints[numNew] );
+			numNew++;
+		}
+
+		numHullPoints = numNew;
+		Com_Memcpy( hullPoints, newHullPoints, numHullPoints * sizeof(vec3_t) );
+	}
+
+	FreeWinding( *hull );
+	w = AllocWinding( numHullPoints );
+	w->numpoints = numHullPoints;
+	*hull = w;
+	Com_Memcpy( w->p, hullPoints, numHullPoints * sizeof(vec3_t) );
+}
+
+
diff --git a/codemp/qcommon/cm_polylib.h b/codemp/qcommon/cm_polylib.h
new file mode 100644
index 0000000..d010769
--- /dev/null
+++ b/codemp/qcommon/cm_polylib.h
@@ -0,0 +1,47 @@
+
+// this is only used for visualization tools in cm_ debug functions
+
+typedef struct
+{
+	int		numpoints;
+	vec3_t	p[4];		// variable sized
+} winding_t;
+
+#define	MAX_POINTS_ON_WINDING	64
+
+#define	SIDE_FRONT	0
+#define	SIDE_BACK	1
+#define	SIDE_ON		2
+#define	SIDE_CROSS	3
+
+#define	CLIP_EPSILON	0.1f
+
+#define MAX_MAP_BOUNDS			65535
+
+// you can define on_epsilon in the makefile as tighter
+#ifndef	ON_EPSILON
+#define	ON_EPSILON	0.1f
+#endif
+
+winding_t	*AllocWinding (int points);
+vec_t	WindingArea (winding_t *w);
+void	WindingCenter (winding_t *w, vec3_t center);
+void	ClipWindingEpsilon (winding_t *in, vec3_t normal, vec_t dist, 
+				vec_t epsilon, winding_t **front, winding_t **back);
+winding_t	*ChopWinding (winding_t *in, vec3_t normal, vec_t dist);
+winding_t	*CopyWinding (winding_t *w);
+winding_t	*ReverseWinding (winding_t *w);
+winding_t	*BaseWindingForPlane (vec3_t normal, vec_t dist);
+void	CheckWinding (winding_t *w);
+void	WindingPlane (winding_t *w, vec3_t normal, vec_t *dist);
+void	RemoveColinearPoints (winding_t *w);
+int		WindingOnPlaneSide (winding_t *w, vec3_t normal, vec_t dist);
+void	FreeWinding (winding_t *w);
+void	WindingBounds (winding_t *w, vec3_t mins, vec3_t maxs);
+
+void	AddWindingToConvexHull( winding_t *w, winding_t **hull, vec3_t normal );
+
+void	ChopWindingInPlace (winding_t **w, vec3_t normal, vec_t dist, vec_t epsilon);
+// frees the original if clipped
+
+void pw(winding_t *w);
diff --git a/codemp/qcommon/cm_public.h b/codemp/qcommon/cm_public.h
new file mode 100644
index 0000000..6f925d4
--- /dev/null
+++ b/codemp/qcommon/cm_public.h
@@ -0,0 +1,74 @@
+#include "../game/q_shared.h"
+#include "qfiles.h"
+
+#ifdef _XBOX
+void		CM_LoadMap( const char *name, qboolean clientload, int *checksum);
+#else
+void		CM_LoadMap( const char *name, qboolean clientload, int *checksum);
+#endif
+
+void		CM_ClearMap( void );
+clipHandle_t CM_InlineModel( int index );		// 0 = world, 1 + are bmodels
+clipHandle_t CM_TempBoxModel( const vec3_t mins, const vec3_t maxs, int capsule );
+
+void		CM_ModelBounds( clipHandle_t model, vec3_t mins, vec3_t maxs );
+
+int			CM_NumClusters (void);
+int			CM_NumInlineModels( void );
+char		*CM_EntityString (void);
+
+// returns an ORed contents mask
+int			CM_PointContents( const vec3_t p, clipHandle_t model );
+int			CM_TransformedPointContents( const vec3_t p, clipHandle_t model, const vec3_t origin, const vec3_t angles );
+
+void		CM_BoxTrace ( trace_t *results, const vec3_t start, const vec3_t end,
+						  const vec3_t mins, const vec3_t maxs,
+						  clipHandle_t model, int brushmask, int capsule );
+void		CM_TransformedBoxTrace( trace_t *results, const vec3_t start, const vec3_t end,
+						  const vec3_t mins, const vec3_t maxs,
+						  clipHandle_t model, int brushmask,
+						  const vec3_t origin, const vec3_t angles, int capsule );
+
+#ifdef _XBOX
+const byte	*CM_ClusterPVS (int cluster);
+#else
+byte		*CM_ClusterPVS (int cluster);
+#endif
+
+int			CM_PointLeafnum( const vec3_t p );
+
+// only returns non-solid leafs
+// overflow if return listsize and if *lastLeaf != list[listsize-1]
+int			CM_BoxLeafnums( const vec3_t mins, const vec3_t maxs, int *boxList,
+		 					int listsize, int *lastLeaf );
+//rwwRMG - changed to boxList to not conflict with list type
+
+int			CM_LeafCluster (int leafnum);
+int			CM_LeafArea (int leafnum);
+
+void		CM_AdjustAreaPortalState( int area1, int area2, qboolean open );
+qboolean	CM_AreasConnected( int area1, int area2 );
+
+int			CM_WriteAreaBits( byte *buffer, int area );
+
+//rwwRMG - added:
+bool		CM_GenericBoxCollide(const vec3pair_t abounds, const vec3pair_t bbounds);
+void		CM_HandlePatchCollision(struct traceWork_s *tw, trace_t &trace, const vec3_t tStart, const vec3_t tEnd, class CCMPatch *patch, int checkcount);
+void		CM_CalcExtents(const vec3_t start, const vec3_t end, const struct traceWork_s *tw, vec3pair_t bounds);
+
+// cm_tag.c
+int			CM_LerpTag( orientation_t *tag,  clipHandle_t model, int startFrame, int endFrame, 
+					 float frac, const char *tagName );
+
+
+// cm_marks.c
+int	CM_MarkFragments( int numPoints, const vec3_t *points, const vec3_t projection,
+				   int maxPoints, vec3_t pointBuffer, int maxFragments, markFragment_t *fragmentBuffer );
+
+// cm_patch.c
+void CM_DrawDebugSurface( void (*drawPoly)(int color, int numPoints, float *points) );
+
+// cm_shader.cpp
+const char *CM_GetShaderText(const char *key);
+void CM_FreeShaderText(void);
+void CM_LoadShaderText(qboolean forceReload);
diff --git a/codemp/qcommon/cm_randomterrain.cpp b/codemp/qcommon/cm_randomterrain.cpp
new file mode 100644
index 0000000..7fc5951
--- /dev/null
+++ b/codemp/qcommon/cm_randomterrain.cpp
@@ -0,0 +1,1091 @@
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+#include "cm_local.h"
+#include "cm_patch.h"
+#include "cm_landscape.h"
+#include "../qcommon/GenericParser2.h"
+#include "cm_randomterrain.h"
+
+
+#define NOISE_SIZE			256
+#define NOISE_MASK			(NOISE_SIZE - 1)
+
+static float					noiseTable[NOISE_SIZE];
+static int						noisePerm[NOISE_SIZE];
+
+#if 0
+static void CM_NoiseInit( CCMLandScape *landscape )
+{
+	int		i;
+
+	for ( i = 0; i < NOISE_SIZE; i++ )
+	{
+		noiseTable[i] = landscape->flrand(-1.0f, 1.0f);
+		noisePerm[i] = (byte)landscape->irand(0, 255);
+	}
+}
+#endif
+
+#define VAL( a ) noisePerm[ ( a ) & ( NOISE_MASK )]
+#define INDEX( x, y, z, t ) VAL( x + VAL( y + VAL( z + VAL( t ) ) ) )
+
+#define LERP( a, b, w ) ( a * ( 1.0f - w ) + b * w )
+
+static float GetNoiseValue( int x, int y, int z, int t )
+{
+	int index = INDEX( ( int ) x, ( int ) y, ( int ) z, ( int ) t );
+
+	return noiseTable[index];
+}
+
+#if 0
+static float GetNoiseTime( int t )
+{
+	int index = VAL( t );
+
+	return (1 + noiseTable[index]);
+}
+#endif
+
+static float CM_NoiseGet4f( float x, float y, float z, float t )
+{
+	int i;
+	int ix, iy, iz, it;
+	float fx, fy, fz, ft;
+	float front[4];
+	float back[4];
+	float fvalue, bvalue, value[2], finalvalue;
+
+	ix = ( int ) floor( x );
+	fx = x - ix;
+	iy = ( int ) floor( y );
+	fy = y - iy;
+	iz = ( int ) floor( z );
+	fz = z - iz;
+	it = ( int ) floor( t );
+	ft = t - it;
+
+	for ( i = 0; i < 2; i++ )
+	{
+		front[0] = GetNoiseValue( ix, iy, iz, it + i );
+		front[1] = GetNoiseValue( ix+1, iy, iz, it + i );
+		front[2] = GetNoiseValue( ix, iy+1, iz, it + i );
+		front[3] = GetNoiseValue( ix+1, iy+1, iz, it + i );
+
+		back[0] = GetNoiseValue( ix, iy, iz + 1, it + i );
+		back[1] = GetNoiseValue( ix+1, iy, iz + 1, it + i );
+		back[2] = GetNoiseValue( ix, iy+1, iz + 1, it + i );
+		back[3] = GetNoiseValue( ix+1, iy+1, iz + 1, it + i );
+
+		fvalue = LERP( LERP( front[0], front[1], fx ), LERP( front[2], front[3], fx ), fy );
+		bvalue = LERP( LERP( back[0], back[1], fx ), LERP( back[2], back[3], fx ), fy );
+
+		value[i] = LERP( fvalue, bvalue, fz );
+	}
+
+	finalvalue = LERP( value[0], value[1], ft );
+	return finalvalue;
+}
+
+
+
+
+
+
+
+
+/****** lincrv.c ******/
+/* Ken Shoemake, 1994 */
+
+/* Perform a generic vector unary operation. */
+#define V_Op(vdst,gets,vsrc,n) {register int V_i;\
+    for(V_i=(n)-1;V_i>=0;V_i--) (vdst)[V_i] gets ((vsrc)[V_i]);}
+
+static void lerp(float t, float a0, float a1, vec4_t p0, vec4_t p1, int m, vec4_t p)
+{
+    register float t0=(a1-t)/(a1-a0), t1=1-t0;
+    register int i;
+    for (i=m-1; i>=0; i--) p[i] = t0*p0[i] + t1*p1[i];
+}
+
+/* DialASpline(t,a,p,m,n,work,Cn,interp,val) computes a point val at parameter
+    t on a spline with knot values a and control points p. The curve will have
+    Cn continuity, and if interp is TRUE it will interpolate the control points.
+    Possibilities include Langrange interpolants, Bezier curves, Catmull-Rom
+    interpolating splines, and B-spline curves. Points have m coordinates, and
+    n+1 of them are provided. The work array must have room for n+1 points.
+ */
+static int DialASpline(float t, float a[], vec4_t p[], int m, int n, vec4_t work[],
+                    unsigned int Cn, bool interp, vec4_t val)
+{
+    register int i, j, k, h, lo, hi;
+
+    if (Cn>n-1) Cn = n-1;       /* Anything greater gives one polynomial */
+    for (k=0; t> a[k]; k++);    /* Find enclosing knot interval */
+    for (h=k; t==a[k]; k++);    /* May want to use fewer legs */
+    if (k>n) {k = n; if (h>k) h = k;}
+    h = 1+Cn - (k-h); k--;
+    lo = k-Cn; hi = k+1+Cn;
+
+    if (interp) {               /* Lagrange interpolation steps */
+        int drop=0;
+        if (lo<0) {lo = 0; drop += Cn-k;
+                   if (hi-lo<Cn) {drop += Cn-hi; hi = Cn;}}
+        if (hi>n) {hi = n; drop += k+1+Cn-n;
+                   if (hi-lo<Cn) {drop += lo-(n-Cn); lo = n-Cn;}}
+        for (i=lo; i<=hi; i++) V_Op(work[i],=,p[i],m);
+        for (j=1; j<=Cn; j++) {
+            for (i=lo; i<=hi-j; i++) {
+                lerp(t,a[i],a[i+j],work[i],work[i+1],m,work[i]);
+            }
+        }
+        h = 1+Cn-drop;
+    } else {                    /* Prepare for B-spline steps */
+        if (lo<0) {h += lo; lo = 0;}
+        for (i=lo; i<=lo+h; i++) V_Op(work[i],=,p[i],m);
+        if (h<0) h = 0;
+    }
+    for (j=0; j<h; j++) {
+        int tmp = 1+Cn-j;
+        for (i=h-1; i>=j; i--) {
+            lerp(t,a[lo+i],a[lo+i+tmp],work[lo+i],work[lo+i+1],m,work[lo+i+1]);
+        }
+    }
+    V_Op(val,=,work[lo+h],m);
+    return (k);
+}
+
+#define BIG (1.0e12)
+
+static vec_t Vector2Normalize( vec2_t v ) 
+{
+	float	length, ilength;
+
+	length = v[0]*v[0] + v[1]*v[1];
+	length = sqrt (length);
+
+	if ( length ) 
+	{
+		ilength = 1/length;
+		v[0] *= ilength;
+		v[1] *= ilength;
+	}
+		
+	return length;
+}
+
+CPathInfo::CPathInfo(CCMLandScape *landscape, int numPoints, float bx, float by, float ex, float ey, 
+					 float minWidth, float maxWidth, float depth, float deviation, float breadth,
+					 CPathInfo *Connected, unsigned CreationFlags) :
+	mNumPoints(numPoints),
+	mMinWidth(minWidth),
+	mMaxWidth(maxWidth),
+	mDepth(depth),
+	mDeviation(deviation),
+	mBreadth(breadth)
+{
+	int		i, numConnected, index;
+	float	position, goal, deltaGoal;
+//	float	random, delta;
+	bool	horizontal;
+	float	*point;
+	float	currentWidth;
+	float	currentPosition;
+	vec2_t	testPoint, percPoint, diffPoint, normalizedPath;
+	float	distance, length;
+	
+	CreateCircle();
+
+	numConnected = -1;
+	if (Connected)
+	{	// we are connecting to an existing spline
+		numConnected = Connected->GetNumPoints();
+		if (numConnected >= SPLINE_MERGE_SIZE)
+		{	// plenty of points to choose from
+			mNumPoints += SPLINE_MERGE_SIZE;
+		}
+		else
+		{	// the existing spline doesn't have enough points
+			mNumPoints += numConnected;
+		}
+	}
+
+	mPoints = (vec4_t *)malloc(sizeof(vec4_t) * mNumPoints);
+	mWork = (vec4_t *)malloc(sizeof(vec4_t) * (mNumPoints+1));
+	mWeights = (vec_t *)malloc(sizeof(vec_t) * (mNumPoints+1));
+
+	length = sqrt((ex-bx)*(ex-bx) + (ey-by)*(ey-by));
+	if (fabs(ex - bx) >= fabs(ey - by))
+	{	// this appears to be a horizontal path
+		mInc = 1.0 / fabs(ex - bx);
+		horizontal = true;
+		position = by;
+		goal = ey;
+		deltaGoal = (ey-by) / (numPoints-1);
+	}
+	else
+	{	// this appears to be a vertical path
+		mInc = 1.0 / fabs(ey - by);
+		horizontal = false;
+		position = bx;
+		goal = ex;
+		deltaGoal = (ex-bx) / (numPoints-1);
+	}
+	normalizedPath[0] = (ex-bx);
+	normalizedPath[1] = (ey-by);
+	Vector2Normalize(normalizedPath);
+	// approx calculate how much we need to iterate through the spline to hit every point
+	mInc /= 16;
+
+	currentWidth = landscape->flrand(minWidth, maxWidth);
+	currentPosition = 0.0;
+
+	for(i=0;i<mNumPoints;i++)
+	{
+		// weights are evenly distributed
+		mWeights[i] = (float)i / (mNumPoints-1);
+
+		if (i < numConnected && i < SPLINE_MERGE_SIZE)
+		{	// we are connecting to an existing spline, so copy over the first few points
+			if (CreationFlags & PATH_CREATION_CONNECT_FRONT)
+			{	// copy from the front
+				index = i;
+			}
+			else
+			{	// copy from the end
+				index = numConnected-SPLINE_MERGE_SIZE+i;
+			}
+			point = Connected->GetPoint(index);
+			mPoints[i][0] = point[0];
+			mPoints[i][1] = point[1];
+			mPoints[i][3] = point[3];
+		}
+		else
+		{
+			if (horizontal)
+			{	// we appear to be going horizontal, so spread the randomness across the vertical
+				mPoints[i][0] = ((ex - bx) * currentPosition) + bx;
+				mPoints[i][1] = position;
+			}
+			else
+			{	// we appear to be going vertical, so spread the randomness across the horizontal
+				mPoints[i][0] = position;
+				mPoints[i][1] = ((ey - by) * currentPosition) + by;
+			}
+			currentPosition += 1.0 / (numPoints-1);
+
+			// set the width of the spline
+			mPoints[i][3] = currentWidth;
+			currentWidth += landscape->flrand(-0.10, 0.10);
+			if (currentWidth < minWidth)
+			{
+				currentWidth = minWidth;
+			}
+			else if (currentWidth > maxWidth)
+			{
+				currentWidth = maxWidth;
+			}
+
+			// see how far we are from the goal
+/*			delta = (goal - position) * currentPosition;
+			// calculate the randomness we are allowed at this place
+			random = landscape->flrand(-mDeviation/1.0, mDeviation/1.0) * (1.0 - currentPosition);
+			position += delta + random;*/
+
+			if (i == mNumPoints-2)
+			{	// -2 because we are calculating for the next point
+				position = goal;
+			}
+			else
+			{
+				if (i == 0)
+				{
+					position += deltaGoal + landscape->flrand(-mDeviation/10.0, mDeviation/10.0);
+				}
+				else
+				{
+					position += deltaGoal + landscape->flrand(-mDeviation*1.5, mDeviation*1.5);
+				}
+			}
+
+
+			if (position > 0.9)
+			{	// too far over, so move back a bit
+				position = 0.9 - landscape->flrand(0.02, 0.1);
+			}
+			if (position < 0.1)
+			{	// too near, so move bakc a bit
+				position = 0.1 + landscape->flrand(0.02, 0.1);
+			}
+
+			// check our deviation from the straight line to the end
+			if (horizontal)
+			{
+				testPoint[0] = ((ex - bx) * currentPosition) + bx;
+				testPoint[1] = position;
+			}
+			else
+			{
+				testPoint[0] = position;
+				testPoint[1] = ((ey - by) * currentPosition) + by;
+			}
+			// dot product of the normal of the path to the point we are at
+			distance = ((testPoint[0]-bx)*normalizedPath[0]) + ((testPoint[1]-by)*normalizedPath[1]);
+			// find the perpendicular place that is intersected by the point and the path
+			percPoint[0] = (distance * normalizedPath[0]) + bx;
+			percPoint[1] = (distance * normalizedPath[1]) + by;
+			// calculate the difference between the perpendicular point and the test point
+			diffPoint[0] = testPoint[0] - percPoint[0];
+			diffPoint[1] = testPoint[1] - percPoint[1];
+			// calculate the distance
+			distance = sqrt((diffPoint[0]*diffPoint[0]) + (diffPoint[1]*diffPoint[1]));
+			if (distance > mDeviation)
+			{	// we are beyond our allowed deviation, so head back
+				if (horizontal)
+				{
+					position = (ey-by) * currentPosition + by;
+				}
+				else
+				{
+					position = (ex-bx) * currentPosition + bx;
+				}
+				position += landscape->flrand(-mDeviation/2.0, mDeviation/2.0);
+			}
+		}
+	}
+	mWeights[mNumPoints] = BIG;
+}
+
+CPathInfo::~CPathInfo(void)
+{
+	free(mWeights);
+	free(mWork);
+	free(mPoints);
+}
+
+void CPathInfo::CreateCircle(void)
+{
+	int		x, y;
+	float	r, d;
+
+	memset(mCircleStamp, 0, sizeof(mCircleStamp));
+	r = CIRCLE_STAMP_SIZE;
+	for(x=0;x<CIRCLE_STAMP_SIZE;x++)
+	{
+		for(y=0;y<CIRCLE_STAMP_SIZE;y++)
+		{
+			d = sqrt((float)(x*x + y*y));
+			if (d > r)
+			{
+				mCircleStamp[y][x] = 255;
+			}
+			else
+			{
+				mCircleStamp[y][x] = pow(sin(d / r * M_PI / 2), mBreadth) * 255;
+			}
+		}
+	}
+}
+
+void CPathInfo::Stamp(int x, int y, int size, int depth, unsigned char *Data, int DataWidth, int DataHeight)
+{
+//	int xPos;
+//	float yPos;
+	int		dx, dy, fx, fy;
+	float	offset;
+	byte	value;
+	byte	invDepth;
+
+	offset = (float)(CIRCLE_STAMP_SIZE-1) / size;
+	invDepth = 255-depth;
+
+	for(dx = -size; dx <= size; dx++)
+	{
+		for ( dy = -size; dy <= size; dy ++ )
+		{
+			float d;
+
+			d = dx * dx + dy * dy ;
+			if ( d > size * size )
+			{
+				continue;
+			}
+
+			fx = x + dx;
+			if (fx < 2 || fx > DataWidth-2)
+			{
+				continue;
+			}
+			
+			fy = y + dy;
+			if (fy < 2 || fy > DataHeight-2)
+			{
+				continue;
+			}
+
+			value = pow ( sin ( d / (size * size) * M_PI / 2), mBreadth ) * invDepth + depth;
+			if (value < Data[(fy * DataWidth) + fx])
+			{
+				Data[(fy * DataWidth) + fx] = value;
+			}
+		}
+	}
+/*
+
+		fx = x + dx;
+		if (fx < 2 || fx > DataWidth-2)
+		{
+			continue;
+		}
+		xPos = abs((int)(dx*offset));
+		yPos = offset*size + offset;
+		for(dy = -size; dy < 0; dy++)
+		{
+			yPos -= offset;
+			fy = y + dy;
+			if (fy < 2 || fy > DataHeight-2)
+			{
+				continue;
+			}
+
+			value = (invDepth * mCircleStamp[(int)yPos][xPos] / 256) + depth;
+			if (value < Data[(fy * DataWidth) + fx])
+			{
+				Data[(fy * DataWidth) + fx] = value;
+			}
+		}
+
+		yPos = -offset;
+		for(; dy <= size; dy++)
+		{
+			yPos += offset;
+
+			fy = y + dy;
+			if (fy < 2 || fy > DataHeight-2)
+			{
+				continue;
+			}
+
+			value = (invDepth * mCircleStamp[(int)yPos][xPos] / 256) + depth;
+			if (value < Data[(fy * DataWidth) + fx])
+			{
+				Data[(fy * DataWidth) + fx] = value;
+			}
+		}
+	}
+*/
+}
+
+void CPathInfo::GetInfo(float PercentInto, vec4_t Coord, vec4_t Vector)
+{
+	vec4_t	before, after;
+	float	testPercent;
+
+	DialASpline(PercentInto, mWeights, mPoints, sizeof(vec4_t) / sizeof(vec_t), mNumPoints-1, mWork, 2, true, Coord);
+
+	testPercent = PercentInto - 0.01;
+	if (testPercent < 0)
+	{
+		testPercent = 0;
+	}
+	DialASpline(testPercent, mWeights, mPoints, sizeof(vec4_t) / sizeof(vec_t), mNumPoints-1, mWork, 2, true, before);
+
+	testPercent = PercentInto + 0.01;
+	if (testPercent > 1.0)
+	{
+		testPercent = 1.0;
+	}
+	DialASpline(testPercent, mWeights, mPoints, sizeof(vec4_t) / sizeof(vec_t), mNumPoints-1, mWork, 2, true, after);
+
+	Coord[2] = mDepth;
+
+	Vector[0] = after[0] - before[0];
+	Vector[1] = after[1] - before[1];
+}
+
+void CPathInfo::DrawPath(unsigned char *Data, int DataWidth, int DataHeight )
+{
+	float			t;
+	vec4_t			val, vector;//, perp;
+	int				size;
+	float			inc;
+	int				x, y, lastX, lastY;
+	float			depth;
+
+	inc = mInc / DataWidth;
+
+	lastX = lastY = -999;
+
+	for (t=0.0; t<=1.0; t+=inc) 
+	{
+		GetInfo(t, val, vector);
+
+/*		perp[0] = -vector[1];
+		perp[1] = vector[0];
+
+		if (fabs(perp[0]) > fabs(perp[1]))
+		{
+			perp[1] /= fabs(perp[0]);
+			perp[0] /= fabs(perp[0]);
+		}
+		else
+		{
+			perp[0] /= fabs(perp[1]);
+			perp[1] /= fabs(perp[1]);
+		}
+*/
+		x = val[0] * DataWidth;
+		y = val[1] * DataHeight;
+
+		if (x == lastX && y == lastY)
+		{
+			continue;
+		}
+
+		lastX = x;
+		lastY = y;
+
+		size = val[3] * DataWidth;
+
+		depth = mDepth * 255.0f;
+
+		Stamp(x, y, size, (int)depth, Data, DataWidth, DataHeight);
+	}
+}
+
+
+
+
+
+
+
+CRandomTerrain::CRandomTerrain(void)
+{
+	memset(mPaths, 0, sizeof(mPaths));
+}
+
+CRandomTerrain::~CRandomTerrain(void)
+{
+	Shutdown();
+}
+
+void CRandomTerrain::Init(CCMLandScape *landscape, byte *grid, int width, int height)
+{
+	Shutdown();
+	mLandScape = landscape;
+	mWidth = width;
+	mHeight = height;
+	mArea = mWidth * mHeight;
+	mBorder = (width + height) >> 6;
+	mGrid = grid;
+}
+
+void CRandomTerrain::ClearPaths(void)
+{
+	int	i;
+
+	for(i=0;i<MAX_RANDOM_PATHS;i++)
+	{
+		if (mPaths[i])
+		{
+			delete mPaths[i];
+			mPaths[i] = 0;
+		}
+	}
+
+	memset(mPaths, 0, sizeof(mPaths));
+}
+
+void CRandomTerrain::Shutdown(void)
+{
+	ClearPaths ( );
+}
+
+bool CRandomTerrain::CreatePath(int PathID, int ConnectedID, unsigned CreationFlags, int numPoints, 
+					float bx, float by, float ex, float ey, 
+					float minWidth, float maxWidth, float depth, float deviation, float breadth )
+{
+	CPathInfo	*connected = 0;
+
+	if (PathID < 0 || PathID >= MAX_RANDOM_PATHS || mPaths[PathID])
+	{
+		return false;
+	}
+
+	if (ConnectedID >= 0 && ConnectedID < MAX_RANDOM_PATHS)
+	{
+		connected = mPaths[ConnectedID];
+	}
+
+	mPaths[PathID] = new CPathInfo(mLandScape, numPoints, bx, by, ex, ey, 
+		minWidth, maxWidth, depth, deviation, breadth,
+		connected, CreationFlags );
+
+	return true;
+}
+
+bool CRandomTerrain::GetPathInfo(int PathNum, float PercentInto, vec4_t Coord, vec4_t Vector)
+{
+	if (PathNum < 0 || PathNum >= MAX_RANDOM_PATHS || !mPaths[PathNum])
+	{
+		return false;
+	}
+
+	mPaths[PathNum]->GetInfo(PercentInto, Coord, Vector);
+
+	return true;
+}
+
+void CRandomTerrain::ParseGenerate(const char *GenerateFile)
+{
+}
+
+void CRandomTerrain::Smooth ( void )
+{
+	// Scale down to 1/4 size then back up to smooth out the terrain
+	byte	*temp;
+	int		x, y, o;
+
+	temp = mLandScape->GetFlattenMap ( );
+
+	// Copy over anything in the flatten map
+	for ( o = 0; o < mHeight * mWidth; o++)
+	{
+		if ( temp[o] > 0 )
+		{
+			mGrid[o] = (byte)temp[o] & 0x7F;
+		}
+	}
+
+	temp = (byte *)Z_Malloc(mWidth * mHeight, TAG_RESAMPLE);
+#if 1
+	unsigned	total, count;
+	for(x=1;x<mWidth-1;x++)
+	{
+		for(y=1;y<mHeight-1;y++)
+		{
+			total = 0;
+			count = 2;
+
+			// Left
+			total += mGrid[((y)*mWidth)+(x-1)];
+			count++;
+
+			// Right
+			total += mGrid[((y)*mWidth)+(x+1)];
+			count++;
+
+			// Up
+			total += mGrid[((y-1)*mWidth)+(x)];
+			count++;
+
+			// Down
+			total += mGrid[((y+1)*mWidth)+(x)];
+			count++;
+
+			// Up-Left
+			total += mGrid[((y-1)*mWidth)+(x-1)];
+			count++;
+
+			// Down-Left
+			total += mGrid[((y+1)*mWidth)+(x-1)];
+			count++;
+
+			// Up-Right
+			total += mGrid[((y-1)*mWidth)+(x+1)];
+			count++;
+
+			// Down-Right
+			total += mGrid[((y+1)*mWidth)+(x+1)];
+			count++;
+
+			total += (unsigned)mGrid[((y)*mWidth)+(x)] * 2;
+
+			temp[((y)*mWidth)+(x)] = total / count;
+		}
+	}
+
+	memcpy(mGrid, temp, mWidth * mHeight);
+
+#else
+	float	smoothKernel[FILTER_SIZE][FILTER_SIZE];
+	int		xx, yy, dx, dy;
+	float	total, num;
+
+	R_Resample(mGrid, mWidth, mHeight, temp, mWidth >> 1, mHeight >> 1, 1);
+	R_Resample(temp, mWidth >> 1, mHeight >> 1, mGrid, mWidth, mHeight, 1);
+
+	// now lets filter it.
+	memcpy(temp, mGrid, mWidth * mHeight);
+
+	for (dy = -KERNEL_SIZE; dy <= KERNEL_SIZE; dy++)
+	{
+		for (dx = -KERNEL_SIZE; dx <= KERNEL_SIZE; dx++)
+		{
+			smoothKernel[dy + KERNEL_SIZE][dx + KERNEL_SIZE] =
+				1.0f / (1.0f + fabs(float(dx) * float(dx) * float(dx)) + fabs(float(dy) * float(dy) * float(dy)));
+		}
+	}
+
+	for (y = 0; y < mHeight; y++)
+	{
+		for (x = 0; x < mWidth; x++)
+		{
+			total = 0.0f;
+			num = 0.0f;
+			for (dy = -KERNEL_SIZE; dy <= KERNEL_SIZE; dy++)
+			{
+				for (dx = -KERNEL_SIZE; dx <= KERNEL_SIZE; dx++)
+				{
+					xx = x + dx;
+					if (xx >= 0 && xx < mWidth)
+					{
+						yy = y + dy;
+						if (yy >= 0 && yy < mHeight)
+						{
+							total += smoothKernel[dy + KERNEL_SIZE][dx + KERNEL_SIZE] * (float)temp[yy * mWidth + xx];
+							num += smoothKernel[dy + KERNEL_SIZE][dx + KERNEL_SIZE];
+						}
+					}
+				}
+			}
+			total /= num;
+			mGrid[y * mWidth + x] = (byte)Com_Clamp(0, 255, (int)Round(total));
+		}
+	}
+#endif
+
+	Z_Free(temp);
+
+/* Uncomment to see the symmetry line on the map
+
+	for ( x = 0; x < mWidth; x ++ )
+	{
+		mGrid[x * mWidth + x] = 255;
+	}
+*/
+}
+
+void CRandomTerrain::Generate(int symmetric)
+{
+	int	i,j;
+	int x, y;
+
+	// Clear out all existing data
+	memset(mGrid, 255, mArea);
+
+	// make landscape a little bumpy
+	float t1 = mLandScape->flrand(0, 2);
+#if 0
+	float t2 = mLandScape->flrand(0, 2);
+	float t3 = mLandScape->flrand(0, 2);
+#endif
+
+/*
+	CM_NoiseInit(mLandScape);
+
+	for (y = 0; y < mHeight; y++)
+		for (x = 0; x < mWidth; x++)
+		{
+			i = x + y*mWidth;
+			byte val = (byte)Com_Clamp(0, 255, (int)(220 + (CM_NoiseGet4f( x*0.25, y*0.25, 0, t3 ) * 20)) + (CM_NoiseGet4f( x*0.5, y*0.5, 0, t2 ) * 15));
+			mGrid[i] = val;
+		}
+*/
+
+	for ( i = 0; mPaths[i] != 0; i ++ )
+	{
+		mPaths[i]->DrawPath(mGrid, mWidth, mHeight);
+	}
+
+	for (y = 0; y < mHeight; y++)
+		for (x = 0; x < mWidth; x++)
+		{
+			i = x + y*mWidth;
+			byte val = (byte)Com_Clamp(0, 255, (int)(mGrid[i] + (CM_NoiseGet4f( x, y, 0, t1 ) * 5))); 
+			mGrid[i] = val;
+		}
+
+	// if symmetric, do this now
+	if (symmetric)
+	{
+		assert (mWidth == mHeight); // must be square
+
+		for (y = 0; y < mHeight; y++)
+			for (x = 0; x < (mWidth-y); x++)
+			{
+				i = x + y*mWidth;
+				j = (mWidth-1 - x) + (mHeight-1 - y)*mWidth;
+				byte val = mGrid[i] < mGrid[j] ? mGrid[i] : mGrid[j];
+				mGrid[i] = mGrid[j] = val;
+			}
+	}
+}
+
+
+
+
+typedef enum
+{
+	CP_NONE					= -1,
+	CP_CONSONANT,
+	CP_COMPLEX_CONSONANT,
+	CP_VOWEL,
+	CP_COMPLEX_VOWEL,
+	CP_ENDING,
+
+	CP_NUM_PIECES,
+} ECPType;
+
+typedef struct SCharacterPiece
+{
+	char	*mPiece;
+	int		mCommonality;
+} TCharacterPiece;
+
+static TCharacterPiece	Consonants[] = 
+{
+	{	"b", 6 },
+	{	"c", 8 },
+	{	"d", 6 },
+	{	"f", 5 },
+	{	"g", 4 },
+	{	"h", 5 },
+	{	"j", 2 },
+	{	"k", 4 },
+	{	"l", 4 },
+	{	"m", 7 },
+	{	"n", 7 },
+	{	"r", 6 },
+	{	"s", 10 },
+	{	"t", 10 },
+	{	"v", 1 },
+	{	"w", 2 },
+	{	"x", 1 },
+	{	"z", 1 },
+
+	{	0, 0 }
+};
+
+static TCharacterPiece	ComplexConsonants[] = 
+{
+	{	"st", 10 },
+	{	"ck", 10 },
+	{	"ss", 10 },
+	{	"tt", 7 },
+	{	"ll", 8 },
+	{	"nd", 10 },
+	{	"rn", 6 },
+	{	"nc", 6 },
+	{	"mp", 4 },
+	{	"sc", 10 }, 
+	{	"sl", 10 }, 
+	{	"tch", 6 }, 
+	{	"th", 4 }, 
+	{	"rn", 5 }, 
+	{	"cl", 10 }, 
+	{	"sp", 10 }, 
+	{	"st", 10 }, 
+	{	"fl", 4 }, 
+	{	"sh", 7 }, 
+	{	"ng", 4 }, 
+//	{	"" },
+
+	{	0, 0 }
+};
+
+static TCharacterPiece	Vowels[] = 
+{
+	{	"a", 10 },
+	{	"e", 10 },
+	{	"i", 10 },
+	{	"o", 10 },
+	{	"u", 2 },
+//	{	"" },
+
+	{	0, 0 }
+};
+
+static TCharacterPiece	ComplexVowels[] = 
+{
+	{	"ea", 10  },
+	{	"ue", 3 },
+	{	"oi", 10 },
+	{	"ai", 8 },
+	{	"oo", 10 },
+	{	"io", 10 },
+	{	"oe", 10 },
+	{	"au", 3 },
+	{	"ee", 7 },
+	{	"ei", 7 },
+	{	"ou", 7 }, 
+	{	"ia", 4 }, 
+//	{	"" },
+
+	{	0, 0 }
+};
+
+static TCharacterPiece	Endings[] = 
+{
+	{	"ing", 10 },
+	{	"ed", 10 },
+	{	"ute", 10 },
+	{	"ance", 10 },
+	{	"ey", 10 },
+	{	"ation", 10 },
+	{	"ous", 10 },
+	{	"ent", 10 },
+	{	"ate", 10 },
+	{	"ible", 10 },
+	{	"age", 10 },
+	{	"ity", 10 },
+	{	"ist", 10 },
+	{	"ism", 10 },
+	{	"ime", 10 },
+	{	"ic", 10 },
+	{	"ant", 10 },
+	{	"etry", 10 },
+	{	"ious", 10 },
+	{	"ative", 10 },
+	{	"er", 10 },
+	{	"ize", 10 }, 
+	{	"able", 10 }, 
+	{	"itude", 10 }, 
+//	{	"" },
+
+	{	0, 0 }
+};
+
+static void FindPiece(ECPType type, char *&pos)
+{
+	TCharacterPiece		*search, *start;
+	int					count = 0;
+
+	switch(type)
+	{
+		case CP_CONSONANT:
+		default:
+			start = Consonants;
+			break;
+
+		case CP_COMPLEX_CONSONANT:
+			start = ComplexConsonants;
+			break;
+
+		case CP_VOWEL:
+			start = Vowels;
+			break;
+
+		case CP_COMPLEX_VOWEL:
+			start = ComplexVowels;
+			break;
+
+		case CP_ENDING:
+			start = Endings;
+			break;
+	}
+
+	search = start;
+	while(search->mPiece)
+	{
+		count += search->mCommonality;
+		search++;
+	}
+
+	count = irand(0, count-1);
+	search = start;
+	while(count > search->mCommonality)
+	{
+		count -= search->mCommonality;
+		search++;
+	}
+
+	strcpy(pos, search->mPiece);
+	pos += strlen(search->mPiece);
+}
+
+unsigned RMG_CreateSeed(char *TextSeed)
+{
+	int			Length;
+	char		Ending[256], *pos;
+	int			ComplexVowelChance, ComplexConsonantChance;
+	ECPType		LookingFor;
+	unsigned	SeedValue = 0, high;
+
+	Length = irand(4, 9);
+
+	if (irand(0, 100) < 20)
+	{ 
+		LookingFor = CP_VOWEL;
+	}
+	else
+	{
+		LookingFor = CP_CONSONANT;
+	}
+
+	Ending[0] = 0;
+
+	if (irand(0, 100) < 55)
+	{
+		pos = Ending;
+		FindPiece(CP_ENDING, pos);
+		Length -= (pos - Ending);
+	}
+
+	pos = TextSeed;
+	*pos = 0;
+
+	ComplexVowelChance = -1;
+	ComplexConsonantChance	= -1;
+
+	while((pos - TextSeed) < Length || LookingFor == CP_CONSONANT)
+	{
+		if (LookingFor == CP_VOWEL)
+		{
+			if (irand(0, 100) < ComplexVowelChance)
+			{
+				ComplexVowelChance = -1;
+				LookingFor = CP_COMPLEX_VOWEL;
+			}
+			else
+			{
+				ComplexVowelChance += 10;
+			}
+
+			FindPiece(LookingFor, pos);
+			LookingFor = CP_CONSONANT;
+		}
+		else
+		{
+			if (irand(0, 100) < ComplexConsonantChance)
+			{
+				ComplexConsonantChance = -1;
+				LookingFor = CP_COMPLEX_CONSONANT;
+			}
+			else
+			{
+				ComplexConsonantChance += 45;
+			}
+
+			FindPiece(LookingFor, pos);
+			LookingFor = CP_VOWEL;
+		}
+	}
+
+	if (Ending[0])
+	{
+		strcpy(pos, Ending);
+	}
+
+	pos = TextSeed;
+	while(*pos)
+	{
+		high = SeedValue >> 28;
+		SeedValue ^= (SeedValue << 4) + ((*pos)-'a');
+		SeedValue ^= high;
+		pos++;
+	}
+
+	return SeedValue;
+}
diff --git a/codemp/qcommon/cm_randomterrain.h b/codemp/qcommon/cm_randomterrain.h
new file mode 100644
index 0000000..4f97432
--- /dev/null
+++ b/codemp/qcommon/cm_randomterrain.h
@@ -0,0 +1,89 @@
+#pragma once
+#if !defined(CM_RANDOMTERRAIN_H_INC)
+#define CM_RANDOMTERRAIN_H_INC
+
+#ifdef DEBUG_LINKING
+	#pragma message("...including cm_randomterrain.h")
+#endif
+
+//class CPathInfo;
+
+#define SPLINE_MERGE_SIZE	3
+#define	CIRCLE_STAMP_SIZE	128
+
+
+class CPathInfo
+{
+private:
+	vec4_t		*mPoints, *mWork;
+	vec_t		*mWeights;
+	int			mNumPoints;
+	float		mMinWidth, mMaxWidth;
+	float		mInc;
+	float		mDepth, mBreadth;
+	float		mDeviation;
+	byte		mCircleStamp[CIRCLE_STAMP_SIZE][CIRCLE_STAMP_SIZE];
+
+	void		CreateCircle(void);
+	void		Stamp(int x, int y, int size, int depth, unsigned char *Data, int DataWidth, int DataHeight);
+
+public:
+	CPathInfo(CCMLandScape *landscape, int numPoints, float bx, float by, float ex, float ey, 
+		float minWidth, float maxWidth, float depth, float deviation, float breadth,
+		CPathInfo *Connected, unsigned CreationFlags);
+	~CPathInfo(void);
+
+	int		GetNumPoints(void) { return mNumPoints; }
+	float	*GetPoint(int index) { return mPoints[index]; }
+	float	GetWidth(int index) { return mPoints[index][3]; }
+
+	void	GetInfo(float PercentInto, vec4_t Coord, vec4_t Vector);
+	void	DrawPath(unsigned char *Data, int DataWidth, int DataHeight );
+};
+
+
+const int			MAX_RANDOM_PATHS	= 30;
+
+// Path Creation Flags
+#define		PATH_CREATION_CONNECT_FRONT		0x00000001
+
+
+
+class CRandomTerrain
+{
+private:
+
+	class CCMLandScape	*mLandScape;
+	int					mWidth;
+	int					mHeight;
+	int					mArea;
+	int					mBorder;
+	byte				*mGrid;
+	CPathInfo			*mPaths[MAX_RANDOM_PATHS];
+
+public:
+	CRandomTerrain(void);
+	~CRandomTerrain(void);
+
+	CCMLandScape		*GetLandScape(void) { return mLandScape; }
+	const vec3pair_t	&GetBounds(void) const { return mLandScape->GetBounds(); }
+	void				rand_seed(int seed) { mLandScape->rand_seed(seed); }
+	int					get_rand_seed(void) { return mLandScape->get_rand_seed();}
+	float				flrand(float min, float max) { return mLandScape->flrand(min, max); }
+	int					irand(int min, int max) { return mLandScape->irand(min, max); }
+
+	void	Init(class CCMLandScape *landscape, byte *data, int width, int height);
+	void	Shutdown(void);
+	bool	CreatePath(int PathID, int ConnectedID, unsigned CreationFlags, int numPoints, 
+						float bx, float by, float ex, float ey, 
+						float minWidth, float maxWidth, float depth, float deviation, float breadth );
+	bool	GetPathInfo(int PathNum, float PercentInto, vec2_t Coord, vec2_t Vector);
+	void	ParseGenerate(const char *GenerateFile);
+	void	Smooth ( void );
+	void	Generate(int symmetric);
+	void	ClearPaths(void);
+};
+
+unsigned RMG_CreateSeed(char *TextSeed);
+
+#endif // CM_RANDOM_H_INC
diff --git a/codemp/qcommon/cm_shader.cpp b/codemp/qcommon/cm_shader.cpp
new file mode 100644
index 0000000..d4597c0
--- /dev/null
+++ b/codemp/qcommon/cm_shader.cpp
@@ -0,0 +1,538 @@
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+#include "cm_local.h"
+#include "memory.h"
+#include "chash.h"
+
+class CCMShaderText
+{
+private:
+	char					mName[MAX_QPATH];
+	class CCMShaderText		*mNext;
+	const char				*mData;
+public:
+	// Constructors
+	CCMShaderText(const char *name, const char *data) { Q_strncpyz(mName, name, MAX_QPATH); mNext = NULL; mData = data; }
+	~CCMShaderText(void) {}
+
+	// Accessors
+	const char *GetName(void) const { return(mName); }
+	class CCMShaderText *GetNext(void) const { return(mNext); }
+	void SetNext(class CCMShaderText *next) { mNext = next; }
+	void Destroy(void) { delete this; }
+
+	const char *GetData(void) const { return(mData); }
+};
+
+char			   		*shaderText = NULL;
+CHash<CCMShaderText>	shaderTextTable;
+CHash<CCMShader>		cmShaderTable;
+
+/*
+====================
+CM_CreateShaderTextHash
+=====================
+*/
+void CM_CreateShaderTextHash(void)
+{
+	const char			*p;
+	qboolean			hasNewLines;
+	char				*token;
+	CCMShaderText		*shader;
+
+	p = shaderText;
+	// look for label
+	while (p) 
+	{
+		p = SkipWhitespace(p, &hasNewLines);
+		token = COM_ParseExt( &p, qtrue );
+		if ( !token[0] ) 
+		{
+			break;
+		}
+		shader = new CCMShaderText(token, p);
+		shaderTextTable.insert(shader);
+
+		SkipBracedSection(&p);
+	}
+}
+
+/*
+====================
+CM_LoadShaderFiles
+
+Finds and loads all .shader files, combining them into
+a single large text block that can be scanned for shader names
+=====================
+*/
+#define	MAX_SHADER_FILES	1024
+
+void CM_LoadShaderFiles( void )
+{
+	char	**shaderFiles1;
+	int		numShaders1;
+#ifndef FINAL_BUILD
+	char	**shaderFiles2;
+	int		numShaders2;
+#endif
+	char	*buffers[MAX_SHADER_FILES];
+	int		numShaders;
+	int		i;
+	int		sum = 0;
+
+	// scan for shader files
+	shaderFiles1 = FS_ListFiles( "shaders", ".shader", &numShaders1 );
+#ifndef FINAL_BUILD
+	shaderFiles2 = FS_ListFiles( "shaders/test", ".shader", &numShaders2 );
+#endif
+
+	if ( !shaderFiles1 || !numShaders1 )
+	{
+		Com_Printf( S_COLOR_YELLOW "WARNING: no shader files found\n" );
+		return;
+	}
+
+#ifndef FINAL_BUILD
+	numShaders = numShaders1 + numShaders2;
+#else
+	numShaders = numShaders1;
+#endif
+	if ( numShaders > MAX_SHADER_FILES ) 
+	{
+		numShaders = MAX_SHADER_FILES;
+	}
+
+	// load and parse shader files
+	for ( i = 0; i < numShaders1; i++ )
+	{
+		char filename[MAX_QPATH];
+
+		Com_sprintf( filename, sizeof( filename ), "shaders/%s", shaderFiles1[i] );
+		Com_DPrintf( "...loading '%s'\n", filename );
+		sum += FS_ReadFile( filename, (void **)&buffers[i] );
+		if ( !buffers[i] ) 
+		{
+			Com_Error( ERR_FATAL, "Couldn't load %s", filename );
+		}
+	}
+#ifndef FINAL_BUILD
+	for ( ; i < numShaders; i++ )
+	{
+		char filename[MAX_QPATH];
+
+		Com_sprintf( filename, sizeof( filename ), "shaders/test/%s", shaderFiles2[i - numShaders1] );
+		Com_DPrintf( "...loading '%s'\n", filename );
+		sum += FS_ReadFile( filename, (void **)&buffers[i] );
+		if ( !buffers[i] ) 
+		{
+			Com_Error( ERR_DROP, "Couldn't load %s", filename );
+		}
+	}
+#endif
+
+	// build single large buffer
+	shaderText = (char *)Z_Malloc( sum + numShaders * 2, TAG_SHADERTEXT, qtrue);
+
+	// free in reverse order, so the temp files are all dumped
+	for ( i = numShaders - 1; i >= 0 ; i-- ) 
+	{
+		strcat( shaderText, "\n" );
+		strcat( shaderText, buffers[i] );
+		FS_FreeFile( buffers[i] );
+	}
+
+	// free up memory
+	FS_FreeFileList( shaderFiles1 );
+#ifndef FINAL_BUILD
+	FS_FreeFileList( shaderFiles2 );
+#endif
+}
+
+/*
+==================
+CM_GetShaderText
+==================
+*/
+
+const char *CM_GetShaderText(const char *key)
+{
+	CCMShaderText	*st;
+
+	st = shaderTextTable[key];
+	if(st)
+	{
+		return(st->GetData());
+	}
+	return(NULL);
+}
+
+/*
+==================
+CM_FreeShaderText
+==================
+*/
+
+void CM_FreeShaderText(void)
+{
+	shaderTextTable.clear();
+	if(shaderText)
+	{
+		Z_Free(shaderText);
+		shaderText = NULL;
+	}
+}
+
+/*
+==================
+CM_LoadShaderText
+
+  Loads in all the .shader files so it can be accessed by the server and the renderer
+  Creates a hash table to quickly access the shader text
+==================
+*/
+
+void CM_LoadShaderText(qboolean forceReload)
+{
+	if(forceReload)
+	{
+		CM_FreeShaderText();
+	}
+	if(shaderText)
+	{
+		return;
+	}
+//	Com_Printf("Loading shader text .....\n");
+	CM_LoadShaderFiles();
+	CM_CreateShaderTextHash();
+
+	//Com_Printf("..... %d shader definitions loaded\n", shaderTextTable.count());
+}
+
+/*
+===============
+ParseSurfaceParm
+
+surfaceparm <name>
+===============
+*/
+
+typedef struct 
+{
+	char	*name;
+	int		clearSolid, surfaceFlags, contents;
+} infoParm_t;
+
+infoParm_t	svInfoParms[] =
+{
+	// Game surface flags
+	{"sky",					-1,					SURF_SKY,			0 },						// emit light from an environment map
+	{"slick",				-1,					SURF_SLICK,			0 },						
+																								
+	{"nodamage",			-1,					SURF_NODAMAGE,		0 },						
+	{"noimpact",			-1,					SURF_NOIMPACT,		0 },						// don't make impact explosions or marks
+	{"nomarks",				-1,					SURF_NOMARKS,		0 },						// don't make impact marks, but still explode
+	{"nodraw",				-1,					SURF_NODRAW,		0 },						// don't generate a drawsurface (or a lightmap)
+	{"nosteps",				-1,					SURF_NOSTEPS,		0 },						
+	{"nodlight",			-1,					SURF_NODLIGHT,		0 },						// don't ever add dynamic lights
+
+	// Game content flags
+	{"nonsolid", 			~CONTENTS_SOLID,	0, 					0 },						// special hack to clear solid flag
+	{"nonopaque", 			~CONTENTS_OPAQUE,	0, 					0 },						// special hack to clear opaque flag
+	{"lava",				~CONTENTS_SOLID,	0,					CONTENTS_LAVA },			// very damaging
+	{"water",				~CONTENTS_SOLID,	0,					CONTENTS_WATER },
+	{"fog",					~CONTENTS_SOLID,	0,					CONTENTS_FOG},				// carves surfaces entering
+	{"playerclip",			~CONTENTS_SOLID,	0,					CONTENTS_PLAYERCLIP },
+	{"monsterclip",			~CONTENTS_SOLID,	0,					CONTENTS_MONSTERCLIP },
+	{"botclip",				~CONTENTS_SOLID,	0,					CONTENTS_BOTCLIP },			// for bots
+	{"shotclip",			~CONTENTS_SOLID,	0,					CONTENTS_SHOTCLIP },
+	{"trigger",				~CONTENTS_SOLID,	0,					CONTENTS_TRIGGER },
+	{"nodrop",				~CONTENTS_SOLID,	0,					CONTENTS_NODROP },			// don't drop items or leave bodies (death fog, lava, etc)
+	{"terrain",				~CONTENTS_SOLID,	0,					CONTENTS_TERRAIN },			// use special terrain collsion
+	{"ladder",				~CONTENTS_SOLID,	0,					CONTENTS_LADDER },			// climb up in it like water
+	{"abseil",				~CONTENTS_SOLID,	0,					CONTENTS_ABSEIL },			// can abseil down this brush
+	{"outside",				~CONTENTS_SOLID,	0,					CONTENTS_OUTSIDE },			// volume is considered to be in the outside (i.e. not indoors)
+	{"inside",				~CONTENTS_SOLID,	0,					CONTENTS_INSIDE },			// volume is considered to be inside (i.e. indoors)
+																	
+	{"detail",				-1,					0,					CONTENTS_DETAIL },			// don't include in structural bsp
+	{"trans",				-1,					0,					CONTENTS_TRANSLUCENT },		// surface has an alpha component
+};
+
+void SV_ParseSurfaceParm( CCMShader * shader, const char **text ) 
+{
+	char	*token;
+	int		numsvInfoParms = sizeof(svInfoParms) / sizeof(svInfoParms[0]);
+	int		i;
+
+	token = COM_ParseExt( text, qfalse );
+	for ( i = 0 ; i < numsvInfoParms ; i++ ) 
+	{
+		if ( !Q_stricmp( token, svInfoParms[i].name ) ) 
+		{
+			shader->surfaceFlags |= svInfoParms[i].surfaceFlags;
+			shader->contentFlags |= svInfoParms[i].contents;
+			shader->contentFlags &= svInfoParms[i].clearSolid;
+			break;
+		}
+	}
+}
+
+/*
+=================
+ParseMaterial
+=================
+*/
+const char *svMaterialNames[MATERIAL_LAST] =
+{
+	MATERIALS
+};
+
+void SV_ParseMaterial( CCMShader *shader, const char **text ) 
+{
+	char	*token;
+	int		i;
+
+	token = COM_ParseExt( text, qfalse );
+	if ( !token[0] ) 
+	{
+		Com_Printf( S_COLOR_YELLOW "WARNING: missing material in shader '%s'\n", shader->shader );
+		return;
+	}
+	for(i = 0; i < MATERIAL_LAST; i++)
+	{
+		if ( !Q_stricmp( token, svMaterialNames[i] ) ) 
+		{
+			shader->surfaceFlags |= i;
+			break;
+		}
+	}
+}
+
+/*
+===============
+ParseVector
+===============
+*/
+static qboolean CM_ParseVector( CCMShader *shader, const char **text, int count, float *v ) 
+{
+	char	*token;
+	int		i;
+
+	// FIXME: spaces are currently required after parens, should change parseext...
+	token = COM_ParseExt( text, qfalse );
+	if ( strcmp( token, "(" ) ) 
+	{
+		Com_Printf( S_COLOR_YELLOW "WARNING: missing parenthesis in shader '%s'\n", shader->shader );
+		return qfalse;
+	}
+
+	for ( i = 0 ; i < count ; i++ ) 
+	{
+		token = COM_ParseExt( text, qfalse );
+		if ( !token[0] ) 
+		{
+			Com_Printf( S_COLOR_YELLOW "WARNING: missing vector element in shader '%s'\n", shader->shader );
+			return qfalse;
+		}
+		v[i] = atof( token );
+	}
+
+	token = COM_ParseExt( text, qfalse );
+	if ( strcmp( token, ")" ) ) 
+	{
+		Com_Printf( S_COLOR_YELLOW "WARNING: missing parenthesis in shader '%s'\n", shader->shader );
+		return qfalse;
+	}
+	return qtrue;
+}
+
+/*
+=================
+CM_ParseShader
+
+The current text pointer is at the explicit text definition of the
+shader.  Parse it into the global shader variable.
+
+This extracts all the info from the shader required for physics and collision
+It is designed to *NOT* load any image files and not require any of the renderer to 
+be initialised.
+=================
+*/
+static void CM_ParseShader( CCMShader *shader, const char **text )
+{
+	char	*token;
+
+	token = COM_ParseExt( text, qtrue );
+	if ( token[0] != '{' )
+	{
+		Com_Printf( S_COLOR_YELLOW "WARNING: expecting '{', found '%s' instead in shader '%s'\n", token, shader->shader );
+		return;
+	}
+
+	while ( true )
+	{
+		token = COM_ParseExt( text, qtrue );
+		if ( !token[0] )
+		{
+			Com_Printf( S_COLOR_YELLOW "WARNING: no concluding '}' in shader %s\n", shader->shader );
+			return;
+		}
+
+		// end of shader definition
+		if ( token[0] == '}' )
+		{
+			break;
+		}
+		// stage definition
+		else if ( token[0] == '{' )
+		{
+			SkipBracedSection( text );
+			continue;
+		}
+		// material deprecated as of 11 Jan 01
+		// material undeprecated as of 7 May 01 - q3map_material deprecated
+		else if ( !Q_stricmp( token, "material" ) || !Q_stricmp( token, "q3map_material" ) )
+		{
+			SV_ParseMaterial( shader, text );
+		}
+		// sun parms
+		// q3map_sun deprecated as of 11 Jan 01
+		else if ( !Q_stricmp( token, "sun" ) || !Q_stricmp( token, "q3map_sun" ) ) 
+		{
+//			float	a, b;
+
+			token = COM_ParseExt( text, qfalse );
+//			shader->sunLight[0] = atof( token );
+			token = COM_ParseExt( text, qfalse );
+//			shader->sunLight[1] = atof( token );
+			token = COM_ParseExt( text, qfalse );
+//			shader->sunLight[2] = atof( token );
+			
+//			VectorNormalize( shader->sunLight );
+
+			token = COM_ParseExt( text, qfalse );
+//			a = atof( token );
+//			VectorScale( shader->sunLight, a, shader->sunLight);
+
+			token = COM_ParseExt( text, qfalse );
+//			a = DEG2RAD(atof( token ));
+
+			token = COM_ParseExt( text, qfalse );
+//			b = DEG2RAD(atof( token ));
+
+//			shader->sunDirection[0] = cos( a ) * cos( b );
+//			shader->sunDirection[1] = sin( a ) * cos( b );
+//			shader->sunDirection[2] = sin( b );
+		}
+		else if ( !Q_stricmp( token, "surfaceParm" ) ) 
+		{
+			SV_ParseSurfaceParm( shader, text );
+			continue;
+		}
+		else if ( !Q_stricmp( token, "fogParms" ) ) 
+		{
+			vec3_t				fogColor;
+			if ( !CM_ParseVector( shader, text, 3, fogColor ) ) 
+			{
+				return;
+			}
+
+			token = COM_ParseExt( text, qfalse );
+			if ( !token[0] ) 
+			{
+				Com_Printf( S_COLOR_YELLOW "WARNING: missing parm for 'fogParms' keyword in shader '%s'\n", shader->shader );
+				continue;
+			}
+//			shader->depthForOpaque = atof( token );
+
+			// skip any old gradient directions
+			SkipRestOfLine( (const char **)text );
+			continue;
+		}
+	}
+	return;
+}
+
+/*
+=================
+CM_SetupShaderProperties
+
+  Scans thru the shaders loaded for the map, parses the text of that shader and
+  extracts the interesting info *WITHOUT* loading up any images or requiring
+  the renderer to be active.
+=================
+*/
+
+void CM_SetupShaderProperties(void)
+{
+	int			i;
+	const char	*def;
+	CCMShader	*shader;
+
+	// Add all basic shaders to the cmShaderTable
+	for(i = 0; i < cmg.numShaders; i++)
+	{
+		cmShaderTable.insert(CM_GetShaderInfo(i));
+	}
+	// Go through and parse evaluate shader names to shadernums
+	for(i = 0; i < cmg.numShaders; i++)
+	{
+		shader = CM_GetShaderInfo(i);
+		def = CM_GetShaderText(shader->shader);
+		if(def)
+		{
+			CM_ParseShader(shader, &def);
+		}
+	}
+}
+
+void CM_ShutdownShaderProperties(void)
+{
+	if(cmShaderTable.count())
+	{
+//		Com_Printf("Shutting down cmShaderTable .....\n");
+		cmShaderTable.clear();
+	}
+}
+
+CCMShader *CM_GetShaderInfo( const char *name )
+{
+	CCMShader	*out;
+	const char	*def;
+
+	out = cmShaderTable[name];
+	if(out)
+	{
+		return(out);
+	}
+
+	// Create a new CCMShader class
+	out = (CCMShader *)Hunk_Alloc( sizeof( CCMShader ), h_high );
+	// Set defaults
+	Q_strncpyz(out->shader, name, MAX_QPATH);
+	out->contentFlags = CONTENTS_SOLID | CONTENTS_OPAQUE;
+
+	// Parse in any text if it exists
+	def = CM_GetShaderText(name);
+	if(def)
+	{
+		CM_ParseShader(out, &def);
+	}
+
+	cmShaderTable.insert(out);
+	return(out);
+}
+
+CCMShader *CM_GetShaderInfo( int shaderNum )
+{
+	CCMShader	*out;
+
+	if((shaderNum < 0) || (shaderNum >= cmg.numShaders))
+	{
+		return(NULL);
+	}
+	out = cmg.shaders + shaderNum;
+	return(out);
+}
+
+// end
diff --git a/codemp/qcommon/cm_terrain.cpp b/codemp/qcommon/cm_terrain.cpp
new file mode 100644
index 0000000..884b91c
--- /dev/null
+++ b/codemp/qcommon/cm_terrain.cpp
@@ -0,0 +1,1720 @@
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+#include "cm_local.h"
+#include "cm_patch.h"
+#include "cm_landscape.h"
+#include "../qcommon/GenericParser2.h"
+#include "cm_randomterrain.h"
+
+#ifdef _WIN32
+#pragma optimize("p", on)
+#endif
+
+void R_LoadDataImage	( const char *name, byte **pic, int *width, int *height);
+void R_InvertImage		( byte *data, int width, int height, int depth);
+void R_Resample			( byte *source, int swidth, int sheight, byte *dest, int dwidth, int dheight, int components);
+
+#define _SMOOTH_TERXEL_BRUSH
+
+#ifdef _SMOOTH_TERXEL_BRUSH
+#define BRUSH_SIDES_PER_TERXEL	8
+#else
+#define BRUSH_SIDES_PER_TERXEL	5
+#endif
+
+void CCMLandScape::SetShaders(int height, CCMShader *shader)
+{
+	int		i;
+
+	for(i = height; shader && (i < HEIGHT_RESOLUTION); i++)
+	{
+		if(!mHeightDetails[i].GetSurfaceFlags())
+		{
+			mHeightDetails[i].SetFlags(shader->contentFlags, shader->surfaceFlags);
+		}
+	}
+}
+
+void CCMLandScape::LoadTerrainDef(const char *td)
+{
+	char				terrainDef[MAX_QPATH];
+	CGenericParser2		parse;
+	CGPGroup			*basegroup, *classes, *items;
+
+	Com_sprintf(terrainDef, MAX_QPATH, "ext_data/RMG/%s.terrain", Info_ValueForKey(td, "terrainDef"));
+	Com_DPrintf("CM_Terrain: Loading and parsing terrainDef %s.....\n", Info_ValueForKey(td, "terrainDef"));
+
+	if(!Com_ParseTextFile(terrainDef, parse))
+	{
+		Com_sprintf(terrainDef, MAX_QPATH, "ext_data/arioche/%s.terrain", Info_ValueForKey(td, "terrainDef"));
+		if(!Com_ParseTextFile(terrainDef, parse))
+		{
+			Com_Printf("Could not open %s\n", terrainDef);
+			return;
+		}
+	}
+	// The whole file....
+	basegroup = parse.GetBaseParseGroup();
+
+	// The root { } struct
+	classes = basegroup->GetSubGroups();
+	while(classes)
+	{
+		items = classes->GetSubGroups();
+		while(items)
+		{
+			if(!stricmp(items->GetName(), "altitudetexture"))
+			{
+				int			height;
+				const char	*shaderName;
+				CCMShader	*shader;
+
+				// Height must exist - the rest are optional
+				height = atol(items->FindPairValue("height", "0"));
+
+				// Shader for this height
+				shaderName = items->FindPairValue("shader", "");
+				if(strlen(shaderName))
+				{
+					shader = CM_GetShaderInfo(shaderName);
+					if(shader)
+					{
+						SetShaders(height, shader); 
+					}
+				}
+			}
+			else if(!stricmp(items->GetName(), "water"))
+			{
+				const char	*shaderName;
+				CCMShader	*shader;
+
+				// Grab the height of the water
+				mBaseWaterHeight = atol(items->FindPairValue("height", "0"));
+				SetRealWaterHeight(mBaseWaterHeight);
+
+				// Grab the material of the water
+				shaderName = items->FindPairValue("shader", "");
+				shader = CM_GetShaderInfo(shaderName);
+				if(shader)
+				{
+					mWaterContents = shader->contentFlags;
+					mWaterSurfaceFlags = shader->surfaceFlags;
+				}
+			}
+			items = (CGPGroup *)items->GetNext();
+		}
+		classes = (CGPGroup *)classes->GetNext();
+	}
+	Com_ParseTextFileDestroy(parse);
+}
+
+CCMPatch::~CCMPatch(void)
+{
+}
+
+CCMLandScape::CCMLandScape(const char *configstring, bool server)
+{
+	int			numPatches, numBrushesPerPatch, size, seed;
+	char		heightMap[MAX_QPATH];
+	char		*ptr;
+
+	holdrand = 0x89abcdef;
+
+	// Clear out the height details
+	memset(mHeightDetails, 0, sizeof(CCMHeightDetails) * HEIGHT_RESOLUTION);
+	mBaseWaterHeight = 0;
+	mWaterHeight = 0.0f;
+
+	// When constructed, referenced once
+	mRefCount = 1;
+
+	// Extract the relevant data from the config string
+	Com_sprintf(heightMap, MAX_QPATH, "%s", Info_ValueForKey(configstring, "heightMap"));
+	numPatches = atol(Info_ValueForKey(configstring, "numPatches"));
+	mTerxels = atol(Info_ValueForKey(configstring, "terxels"));
+	mHasPhysics = !!atol(Info_ValueForKey(configstring, "physics"));
+	seed = strtoul(Info_ValueForKey(configstring, "seed"), &ptr, 10);
+
+	mBounds[0][0] = (float)atof(Info_ValueForKey(configstring, "minx"));
+	mBounds[0][1] = (float)atof(Info_ValueForKey(configstring, "miny"));
+	mBounds[0][2] = (float)atof(Info_ValueForKey(configstring, "minz"));
+	mBounds[1][0] = (float)atof(Info_ValueForKey(configstring, "maxx"));
+	mBounds[1][1] = (float)atof(Info_ValueForKey(configstring, "maxy"));
+	mBounds[1][2] = (float)atof(Info_ValueForKey(configstring, "maxz"));
+
+	// Calculate size of the brush
+	VectorSubtract(mBounds[1], mBounds[0], mSize);
+
+	// Work out the dimensions of the brush in blocks - the object is to make the blocks as square as possible
+	mBlockWidth = Round(sqrtf(numPatches * mSize[0] / mSize[1]));
+	mBlockHeight = Round(sqrtf(numPatches * mSize[1] / mSize[0]));
+
+	// ...which lets us get the size of the heightmap
+	mWidth = mBlockWidth * mTerxels;
+	mHeight = mBlockHeight * mTerxels;
+
+	mHeightMap = (byte *)Z_Malloc(GetRealArea(), TAG_CM_TERRAIN);
+	mFlattenMap = (byte *)Z_Malloc(GetRealArea(), TAG_CM_TERRAIN);
+	
+	// Zero means unused.
+	memset ( mFlattenMap, 0, GetRealArea() );
+
+	if(strlen(heightMap))
+	{
+		byte	*imageData;
+		int		iWidth, iHeight;
+
+		Com_DPrintf("CM_Terrain: Loading heightmap %s.....\n", heightMap);
+		mRandomTerrain = 0;
+#ifdef DEDICATED
+		imageData=NULL;
+#else
+		R_LoadDataImage(heightMap, &imageData, &iWidth, &iHeight); 
+		if(imageData)
+		{
+			if(strstr(heightMap, "random_"))
+			{
+				mRandomTerrain = CreateRandomTerrain ( configstring, this, mHeightMap, GetRealWidth(), GetRealHeight());
+			}
+			else
+			{
+				// Flip to make the same as GenSurf
+				R_InvertImage(imageData, iWidth, iHeight, 1);
+				R_Resample(imageData, iWidth, iHeight, mHeightMap, GetRealWidth(), GetRealHeight(), 1);
+			}
+			Z_Free(imageData);
+		}
+#endif
+	}
+	else
+	{
+		Com_Error(ERR_FATAL, "Terrain has no heightmap specified\n");
+	}
+
+	// Work out the dimensions of the terxel - should be almost square
+	mTerxelSize[0] = mSize[0] / mWidth;
+	mTerxelSize[1] = mSize[1] / mHeight;
+	mTerxelSize[2] = mSize[2] / 255.0f;
+
+	// Work out the patchsize
+	mPatchSize[0] = mSize[0] / mBlockWidth;
+	mPatchSize[1] = mSize[1] / mBlockHeight;
+	mPatchSize[2] = 1.0f;
+	mPatchScalarSize = VectorLength(mPatchSize);
+
+	// Loads in the water height and properties
+	// Gets the shader properties for the blended shaders
+	LoadTerrainDef(configstring);
+
+	Com_DPrintf("CM_Terrain: Creating patches.....\n");
+	mPatches = (CCMPatch *)Z_Malloc(sizeof(CCMPatch) * GetBlockCount(), TAG_CM_TERRAIN);
+
+	numBrushesPerPatch = mTerxels * mTerxels * 2;
+	size = (numBrushesPerPatch * sizeof(cbrush_t)) + (numBrushesPerPatch * BRUSH_SIDES_PER_TERXEL * 2 * (sizeof(cbrushside_t) + sizeof(cplane_t)));
+	mPatchBrushData = (byte *)Z_Malloc(size * GetBlockCount(), TAG_CM_TERRAIN);
+
+	// Initialize all terrain patches
+	UpdatePatches();
+}
+
+// Initialise a plane from 3 coords
+
+void CCMPatch::InitPlane(struct cbrushside_s *side, cplane_t *plane, vec3_t p0, vec3_t p1, vec3_t p2)
+{
+	vec3_t	dx, dy;
+
+	VectorSubtract(p1, p0, dx);
+	VectorSubtract(p2, p0, dy);
+	CrossProduct(dx, dy, plane->normal);
+	VectorNormalize(plane->normal);
+
+	plane->dist = DotProduct(p0, plane->normal);
+	plane->type = PlaneTypeForNormal(plane->normal);
+	SetPlaneSignbits(plane);
+
+#ifdef _XBOX
+	cmg.planes[side->planeNum.GetValue()] = *plane;
+#else
+	side->plane = plane;
+#endif
+}
+
+// Create the planes required for collision detection
+// 2 brushes per terxel - each brush has 5 sides and 5 planes
+
+void* CCMPatch::GetAdjacentBrushY ( int x, int y )
+{
+	int			yo1 = y % owner->GetTerxels();
+	int			yo2 = (y-1) % owner->GetTerxels();
+	int			xo  = x % owner->GetTerxels();
+	CCMPatch*	patch;
+	
+	// Different patch
+	if ( yo2 > yo1 )
+	{
+		patch = owner->GetPatch ( x / owner->GetTerxels(), (y-1) / owner->GetTerxels() );
+	}
+	else
+	{
+		patch = this;
+	}
+
+	cbrush_t *brush;
+	
+	brush =  patch->mPatchBrushData;
+	brush += ((yo2 * owner->GetTerxels ( ) + xo) * 2);
+	brush ++;
+
+	return brush;
+}
+
+void* CCMPatch::GetAdjacentBrushX ( int x, int y )
+{
+	int			xo1 = x % owner->GetTerxels();
+	int			xo2 = (x-1) % owner->GetTerxels();
+	int			yo  = y % owner->GetTerxels();
+	CCMPatch*	patch;
+	
+	// Different patch
+	if ( xo2 > xo1 )
+	{
+		patch = owner->GetPatch ( (x-1) / owner->GetTerxels(), y / owner->GetTerxels() );
+	}
+	else
+	{
+		patch = this;
+	}
+
+	cbrush_t *brush;
+	
+	brush =  patch->mPatchBrushData;
+	brush += ((yo * owner->GetTerxels ( ) + xo2) * 2);
+
+	if ( ! ((x+y) & 1) )
+	{		
+		brush ++;
+	}
+
+	return brush;
+}
+
+void CCMPatch::CreatePatchPlaneData(void)
+{				
+#ifndef PRE_RELEASE_DEMO
+	int				realWidth;
+	int				x, y, i, j;
+#if	0
+	int				n;
+#endif
+	cbrush_t		*brush;
+	cbrushside_t	*side;
+	cplane_t		*plane;
+	vec3_t			*coords;
+	vec3_t			localCoords[8];
+
+	mNumBrushes = owner->GetTerxels() * owner->GetTerxels() * 2;
+	realWidth = owner->GetRealWidth();
+	coords = owner->GetCoords();
+
+	brush = mPatchBrushData;
+	side = (cbrushside_t *)(mPatchBrushData + mNumBrushes);
+	plane = (cplane_t *)(side + (mNumBrushes * BRUSH_SIDES_PER_TERXEL * 2));
+	for(y = mHy; y < mHy + owner->GetTerxels(); y++)
+	{
+		for(x = mHx; x < mHx + owner->GetTerxels(); x++)
+		{
+			int		offsets[4];
+
+			if ( (x+y)&1 )
+			{
+				offsets[0] = (y * realWidth) + x;				// TL
+				offsets[1] = (y * realWidth) + x + 1;			// TR
+				offsets[2] = ((y + 1) * realWidth) + x;			// BL
+				offsets[3] = ((y + 1) * realWidth) + x + 1;		// BR
+			}
+			else
+			{
+				offsets[2] = (y * realWidth) + x;				// TL
+				offsets[0] = (y * realWidth) + x + 1;			// TR
+				offsets[3] = ((y + 1) * realWidth) + x;			// BL
+				offsets[1] = ((y + 1) * realWidth) + x + 1;		// BR
+			}
+
+			for(i = 0; i < 4; i++)
+			{
+				VectorCopy(coords[offsets[i]], localCoords[i]);
+				VectorCopy(coords[offsets[i]], localCoords[i + 4]);
+				// Set z of base of brush to bottom of landscape brush
+				localCoords[i + 4][2] = owner->GetMins()[2];
+			}
+
+			// Set the bounds of the terxel
+			VectorSet(brush[0].bounds[0], MAX_WORLD_COORD, MAX_WORLD_COORD, MAX_WORLD_COORD);
+			VectorSet(brush[0].bounds[1], MIN_WORLD_COORD, MIN_WORLD_COORD, MIN_WORLD_COORD);
+
+			for(i = 0; i < 8; i++)
+			{
+				for(j = 0; j < 3; j++)
+				{
+					// mins
+					if(localCoords[i][j] < brush[0].bounds[0][j])
+					{
+						brush[0].bounds[0][j] = localCoords[i][j];
+					}
+					// maxs
+					if(localCoords[i][j] > brush[0].bounds[1][j])
+					{
+						brush[0].bounds[1][j] = localCoords[i][j];
+					}
+				}
+			}
+			VectorDec(brush[0].bounds[0]);
+			VectorInc(brush[0].bounds[1]);
+			VectorCopy(brush[0].bounds[0], brush[1].bounds[0]);
+			VectorCopy(brush[0].bounds[1], brush[1].bounds[1]);
+
+			brush[0].contents = mContentFlags;
+			brush[1].contents = mContentFlags;
+
+#ifndef _SMOOTH_TERXEL_BRUSH
+
+			// Set up sides of the brushes
+			brush[0].numsides = 5;
+			brush[0].sides = side;
+			brush[1].numsides = 5;
+			brush[1].sides = side + 5;
+								  			
+			for ( i = 0; i < 8 ; i ++ )
+			{
+				localCoords[i][0] = (int)localCoords[i][0];
+				localCoords[i][1] = (int)localCoords[i][1];
+				localCoords[i][2] = (int)localCoords[i][2];
+			}
+	
+			// Create the planes of the 2 triangles that make up the tops of the brushes
+			InitPlane(side + 0, plane + 0, localCoords[0], localCoords[1], localCoords[2]);
+			InitPlane(side + 5, plane + 5, localCoords[3], localCoords[2], localCoords[1]);
+
+			// Create the bottom face of the brushes
+			InitPlane(side + 1, plane + 1, localCoords[6], localCoords[5], localCoords[4]);
+			InitPlane(side + 6, plane + 6, localCoords[5], localCoords[6], localCoords[7]);
+
+			// Create the 3 vertical faces
+			InitPlane(side + 2, plane + 2, localCoords[0], localCoords[2], localCoords[4]);
+			InitPlane(side + 7, plane + 7, localCoords[3], localCoords[1], localCoords[7]);
+
+			InitPlane(side + 3, plane + 3, localCoords[0], localCoords[4], localCoords[1]);
+			InitPlane(side + 8, plane + 8, localCoords[3], localCoords[7], localCoords[2]);
+
+			InitPlane(side + 4, plane + 4, localCoords[2], localCoords[1], localCoords[6]);
+			InitPlane(side + 9, plane + 9, localCoords[5], localCoords[1], localCoords[6]);
+
+			// Increment to next terxel
+			brush += 2;
+			side += 10;
+			plane += 10;
+
+			
+
+#else
+
+			// Set up sides of the brushes
+			brush[0].numsides = 5;
+			brush[0].sides = side;
+			brush[1].numsides = 5;
+			brush[1].sides = side + 8;
+
+
+			// Create the planes of the 2 triangles that make up the tops of the brushes
+			InitPlane(side + 0, plane + 0, localCoords[0], localCoords[1], localCoords[2]);
+			InitPlane(side + 8, plane + 8, localCoords[3], localCoords[2], localCoords[1]);
+
+			// Create the bottom face of the brushes
+			InitPlane(side + 1, plane + 1, localCoords[4], localCoords[6], localCoords[5]);
+			InitPlane(side + 9, plane + 9, localCoords[7], localCoords[5], localCoords[6]);
+
+			// Create the 3 vertical faces
+			InitPlane(side + 2, plane + 2, localCoords[0], localCoords[2], localCoords[4]);
+			InitPlane(side + 10, plane + 10, localCoords[3], localCoords[1], localCoords[7]);
+
+			InitPlane(side + 3, plane + 3, localCoords[0], localCoords[4], localCoords[1]);
+			InitPlane(side + 11, plane + 11, localCoords[3], localCoords[7], localCoords[2]);
+
+			InitPlane(side + 4, plane + 4, localCoords[2], localCoords[1], localCoords[6]);
+			InitPlane(side + 12, plane + 12, localCoords[5], localCoords[1], localCoords[6]);
+
+			float V = DotProduct ( (plane + 8)->normal, localCoords[0] ) - (plane + 8)->dist;
+
+			if ( V < 0 )
+			{
+				InitPlane ( brush[0].sides + brush[0].numsides, plane + brush[0].numsides, localCoords[3], localCoords[2], localCoords[1]);
+				brush[0].numsides++;			
+
+				InitPlane ( brush[1].sides + brush[1].numsides, plane + 8 + brush[1].numsides, localCoords[0], localCoords[1], localCoords[2]);
+				brush[1].numsides++;			
+			}
+
+			// Determine if we need to smooth the brush transition from the brush above us
+			if ( y > 0 && y < owner->GetPatchHeight ( ) - 1 )
+			{
+				cbrush_t* abovebrush = (cbrush_t*)GetAdjacentBrushY ( x, y );
+#ifdef _XBOX
+				cplane_t* aboveplane = &cmg.planes[abovebrush->sides->planeNum.GetValue()];
+#else
+				cplane_t* aboveplane = abovebrush->sides->plane;
+#endif
+
+				V = DotProduct ( aboveplane->normal, ((y+x)&1)?(localCoords[2]):(localCoords[1]) ) - aboveplane->dist;
+
+				if ( V < 0 )
+				{
+					memcpy ( brush[0].sides + brush[0].numsides, abovebrush->sides, sizeof(cbrushside_t) );
+					brush[0].numsides++;
+
+					memcpy ( abovebrush->sides + abovebrush->numsides, side + 0, sizeof(cbrushside_t) );
+					abovebrush->numsides++;
+				}
+			}
+			
+			// Determine if we need to smooth the brush transition from the brush to the left of us
+			if ( x > 0 && x < owner->GetPatchWidth ( ) - 1 )
+			{
+				cbrush_t* abovebrush = (cbrush_t*)GetAdjacentBrushX ( x, y );
+
+#ifdef _XBOX
+				cplane_t* aboveplane = &cmg.planes[abovebrush->sides->planeNum.GetValue()];
+#else
+				cplane_t* aboveplane = abovebrush->sides->plane;
+#endif
+
+				V = DotProduct ( aboveplane->normal, localCoords[1] ) - aboveplane->dist;
+
+				if ( V < 0 )
+				{
+					if ( (x+y)&1 )
+					{
+						memcpy ( brush[0].sides + brush[0].numsides, abovebrush->sides, sizeof(cbrushside_t) );
+						brush[0].numsides++;
+
+						memcpy ( abovebrush->sides + abovebrush->numsides, side + 0, sizeof(cbrushside_t) );
+						abovebrush->numsides++;
+					}
+					else
+					{
+						memcpy ( brush[1].sides + brush[1].numsides, abovebrush->sides, sizeof(cbrushside_t) );
+						brush[1].numsides++;
+
+						memcpy ( abovebrush->sides + abovebrush->numsides, side + 8, sizeof(cbrushside_t) );
+						abovebrush->numsides++;
+					}
+				}
+			}
+
+			// Increment to next terxel
+			brush += 2;
+			side += 16;
+			plane += 16;
+#endif
+		}
+	}
+#endif // PRE_RELEASE_DEMO
+}
+
+void CCMPatch::Init(CCMLandScape *ls, int heightX, int heightY, vec3_t world, byte *hMap, byte *patchBrushData)
+{
+#ifndef PRE_RELEASE_DEMO
+	int		min, max, x, y, height;
+
+	// Set owning landscape
+	owner = ls;
+
+	// Store the base of the top left corner
+	VectorCopy(world, mWorldCoords);
+
+	// Store pointer to first byte of the height data for this patch.
+	mHx = heightX;
+	mHy = heightY;
+	mHeightMap = hMap + ((heightY * owner->GetRealWidth()) + heightX);
+
+	// Calculate the bounds for culling 
+	// Use the dimensions 1 terxel outside the patch to allow for sloping of edge terxels
+	min = 256;
+	max = -1;
+	for(y = heightY - 1; y < heightY + owner->GetTerxels() + 1; y++)
+	{
+		if(y >= 0)
+		{
+			for(x = heightX - 1; x < heightX + owner->GetTerxels() + 1; x++)
+			{
+				if(x >= 0)
+				{
+					height = hMap[(y * owner->GetRealWidth()) + x];
+
+					if(height > max)
+					{
+						max = height;
+					}
+					if(height < min)
+					{
+						min = height;
+					}
+				}
+			}
+		}
+	}
+
+	// Mins
+	mBounds[0][0] = world[0];
+	mBounds[0][1] = world[1];
+	mBounds[0][2] = world[2] + (min * owner->GetTerxelSize()[2]);
+
+	// Maxs
+	mBounds[1][0] = world[0] + (owner->GetPatchSize()[0]);
+	mBounds[1][1] = world[1] + (owner->GetPatchSize()[1]);
+	mBounds[1][2] = world[2] + (max * owner->GetTerxelSize()[2]);
+
+	// Corner heights
+	mCornerHeights[0] = mHeightMap[0];
+	mCornerHeights[1] = mHeightMap[owner->GetTerxels()];
+	mCornerHeights[2] = mHeightMap[owner->GetTerxels() * owner->GetRealWidth()];
+	mCornerHeights[3] = mHeightMap[(owner->GetTerxels() * owner->GetRealWidth()) + owner->GetTerxels()];
+
+	// Set the surfaceFlags using average height (may want a more complex algo here)
+	mSurfaceFlags = owner->GetSurfaceFlags((min + max) >> 1);
+	mContentFlags = owner->GetContentFlags((min + max) >> 1);
+
+	// Set base of brush data from big array
+	mPatchBrushData = (cbrush_t *)patchBrushData; 
+	CreatePatchPlaneData();
+#endif // PRE_RELEASE_DEMO
+}
+
+CCMPatch *CCMLandScape::GetPatch(int x, int y)
+{
+	return(mPatches + ((y * mBlockWidth) + x));
+}
+
+extern cvar_t	*com_newtrace;		
+
+void CCMLandScape::PatchCollide(struct traceWork_s *tw, trace_t &trace, const vec3_t start, const vec3_t end, int checkcount)
+{
+	vec3pair_t	tBounds;
+
+	// Convert to valid bounding box
+	CM_CalcExtents(start, end, tw, tBounds);
+
+	//if (com_newtrace->integer)
+	if (1)
+	{
+		float		slope, offset;
+		float		startPatchLoc, endPatchLoc, startPos, endPos;
+		float		patchDirection = 1;
+		float		checkDirection = 1;
+		int			countPatches, count;
+		CCMPatch	*patch;
+		float		fraction = trace.fraction;
+
+		if (fabs(end[0]-start[0]) >= fabs(fabs(end[1]-start[1])))
+		{	// x travels more than y
+			// calculate line slope and offset
+			if (end[0] - start[0])
+			{
+				slope = (end[1] - start[1]) / (end[0] - start[0]);
+			}
+			else
+			{
+				slope = 0;
+			}
+			offset = start[1] - (start[0] * slope);
+
+			// find the starting 
+			startPatchLoc = floor((start[0] - mBounds[0][0]) / mPatchSize[0]);
+			endPatchLoc = floor((end[0] - mBounds[0][0]) / mPatchSize[0]);
+
+			if (startPatchLoc <= endPatchLoc)
+			{	// moving along slope in a positive direction
+				endPatchLoc++;
+				startPatchLoc--;
+				countPatches = endPatchLoc - startPatchLoc + 1;
+			}
+			else
+			{	// moving along slope in a negative direction
+				endPatchLoc--;
+				startPatchLoc++;
+				patchDirection = -1;
+				countPatches = startPatchLoc - endPatchLoc + 1;
+			}
+			if (slope < 0.0)
+			{
+				checkDirection = -1;
+			}
+			
+			// first calculate the real world location
+			startPos = ((startPatchLoc * mPatchSize[0] + mBounds[0][0]) * slope) + offset;
+			// calculate it back into patch coords
+			startPos = floor((startPos - mBounds[0][1] + tw->size[0][1]) / mPatchSize[1]);
+			do
+			{
+				if (startPatchLoc >= 0 && startPatchLoc < mBlockWidth)
+				{	// valid location
+					// first calculate the real world location
+					endPos = (((startPatchLoc+patchDirection) * mPatchSize[0] + mBounds[0][0]) * slope) + offset;
+					// calculate it back into patch coords
+					endPos = floor((endPos - mBounds[0][1] + tw->size[1][1]) / mPatchSize[1]);
+					
+					if (checkDirection < 0)
+					{
+						startPos++;
+						endPos--;
+					}
+					else
+					{
+						startPos--;
+						endPos++;
+					}
+					count = fabs(endPos - startPos) + 1;
+					while(count)
+					{
+						if (startPos  >= 0 && startPos < mBlockHeight)
+						{	// valid location
+							patch = GetPatch(startPatchLoc, startPos);
+							// Collide with every patch to find the minimum fraction
+							CM_HandlePatchCollision(tw, trace, tBounds[0], tBounds[1], patch, checkcount);
+
+							if (trace.fraction <= 0.0)
+							{
+								return;
+							}
+						}
+						startPos += checkDirection;
+						count--;
+					}
+
+					if (trace.fraction < fraction)
+					{
+						return;
+					}
+				}
+				// move to the next spot
+				// we still stay one behind, to get the opposite edge of the terrain patch
+				startPos = ((startPatchLoc * mPatchSize[0] + mBounds[0][0]) * slope) + offset;
+				startPatchLoc += patchDirection;
+				// first calculate the real world location
+				// calculate it back into patch coords
+				startPos = floor((startPos - mBounds[0][1] + tw->size[0][1]) / mPatchSize[1]);
+
+				countPatches--;
+			}
+			while (countPatches);
+		}
+		else
+		{
+			// calculate line slope and offset
+			slope = (end[0] - start[0]) / (end[1] - start[1]);
+			offset = start[0] - (start[1] * slope);
+
+			// find the starting 
+			startPatchLoc = floor((start[1] - mBounds[0][1]) / mPatchSize[1]);
+			endPatchLoc = floor((end[1] - mBounds[0][1]) / mPatchSize[1]);
+
+			if (startPatchLoc <= endPatchLoc)
+			{	// moving along slope in a positive direction
+				endPatchLoc++;
+				startPatchLoc--;
+				countPatches = endPatchLoc - startPatchLoc + 1;
+			}
+			else
+			{	// moving along slope in a negative direction
+				endPatchLoc--;
+				startPatchLoc++;
+				patchDirection = -1;
+				countPatches = startPatchLoc - endPatchLoc + 1;
+			}
+			if (slope < 0.0)
+			{
+				checkDirection = -1;
+			}
+			
+			// first calculate the real world location
+			startPos = ((startPatchLoc * mPatchSize[1] + mBounds[0][1]) * slope) + offset;
+			// calculate it back into patch coords
+			startPos = floor((startPos - mBounds[0][0] + tw->size[0][0]) / mPatchSize[0]);
+			do
+			{
+				if (startPatchLoc >= 0 && startPatchLoc < mBlockHeight)
+				{	// valid location
+					// first calculate the real world location
+					endPos = (((startPatchLoc+patchDirection) * mPatchSize[1] + mBounds[0][1]) * slope) + offset;
+					// calculate it back into patch coords
+					endPos = floor((endPos - mBounds[0][0] + tw->size[1][0]) / mPatchSize[0]);
+
+					if (checkDirection < 0)
+					{
+						startPos++;
+						endPos--;
+					}
+					else
+					{
+						startPos--;
+						endPos++;
+					}
+					
+					count = fabs(endPos - startPos) + 1;
+					while(count)
+					{
+						if (startPos >= 0 && startPos < mBlockWidth)
+						{	// valid location
+							patch = GetPatch(startPos, startPatchLoc);
+							// Collide with every patch to find the minimum fraction
+							CM_HandlePatchCollision(tw, trace, tBounds[0], tBounds[1], patch, checkcount);
+
+							if (trace.fraction <= 0.0)
+							{
+								return;
+							}
+						}
+						startPos += checkDirection;
+						count--;
+					}
+
+					if (trace.fraction < fraction)
+					{
+						return;
+					}
+				}
+
+				// move to the next spot
+				// we still stay one behind, to get the opposite edge of the terrain patch
+				startPos = ((startPatchLoc * mPatchSize[1] + mBounds[0][1]) * slope) + offset;
+				startPatchLoc += patchDirection;
+				// first calculate the real world location
+				// calculate it back into patch coords
+				startPos = floor((startPos - mBounds[0][0] + tw->size[0][0]) / mPatchSize[0]);
+				countPatches--;
+			}
+			while (countPatches);
+		}
+	}
+	else
+	{
+		int			x, y;
+		vec3_t		tWork;
+		vec3_t		pStart, pEnd;
+		int			minx, maxx, miny, maxy;
+		CCMPatch	*patch;
+
+		// Work out and grab the relevant patches
+		VectorSubtract(tBounds[0], mBounds[0], tWork);
+		VectorInverseScaleVector(tWork, mPatchSize, pStart);
+		VectorSubtract(tBounds[1], mBounds[0], tWork);
+		VectorInverseScaleVector(tWork, mPatchSize, pEnd);
+
+		minx = Com_Clamp(0, mBlockWidth - 1, floorf(pStart[0]));
+		maxx = Com_Clamp(0, mBlockWidth - 1, ceilf(pEnd[0]));
+		miny = Com_Clamp(0, mBlockHeight - 1, floorf(pStart[1]));
+		maxy = Com_Clamp(0, mBlockHeight - 1, ceilf(pEnd[1]));
+
+		// generic box collide with each one
+		for(y = miny; y <= maxy; y++)
+		{
+			for(x = minx; x <= maxx; x++)
+			{
+				patch = GetPatch(x, y);
+				// Collide with every patch to find the minimum fraction
+				CM_HandlePatchCollision(tw, trace, tBounds[0], tBounds[1], patch, checkcount);
+
+				if (trace.fraction <= 0.0)
+				{
+					break;
+				}
+			}
+		}
+	}
+}
+
+float CCMLandScape::WaterCollide(const vec3_t begin, const vec3_t end, float fraction) const
+{
+	// Check for completely above water
+	if((begin[2] > mWaterHeight) && (end[2] > mWaterHeight))
+	{
+		return(fraction);
+	}
+	// Check for completely below water
+	if((begin[2] < mWaterHeight) && (end[2] < mWaterHeight))
+	{
+		return(fraction);
+	}
+	// Check for starting in water and leaving
+	if(begin[2] < mWaterHeight - SURFACE_CLIP_EPSILON)
+	{
+		fraction = ((mWaterHeight - SURFACE_CLIP_EPSILON) - begin[2]) / (end[2] - begin[2]);
+		return(fraction);
+	}
+	// Now the trace must be entering the water
+	if(begin[2] > mWaterHeight + SURFACE_CLIP_EPSILON)
+	{
+		fraction = (begin[2] - (mWaterHeight + SURFACE_CLIP_EPSILON)) / (begin[2] - end[2]);
+	}
+	return(fraction);
+}
+
+void CCMLandScape::GetTerxelLocalCoords ( int x, int y, vec3_t localCoords[8] )
+{
+	int		realWidth;
+	vec3_t* coords;
+	int		offsets[4];
+	int		i;
+
+	coords = GetCoords ( );
+	realWidth = GetRealWidth ( );
+
+	if ( (x+y)&1 )
+	{
+		offsets[0] = (y * realWidth) + x;				// TL
+		offsets[1] = (y * realWidth) + x + 1;			// TR
+		offsets[2] = ((y + 1) * realWidth) + x;			// BL
+		offsets[3] = ((y + 1) * realWidth) + x + 1;		// BR
+	}
+	else
+	{
+		offsets[2] = (y * realWidth) + x;				// TL
+		offsets[0] = (y * realWidth) + x + 1;			// TR
+		offsets[3] = ((y + 1) * realWidth) + x;			// BL
+		offsets[1] = ((y + 1) * realWidth) + x + 1;		// BR
+	}
+
+	for( i = 0; i < 4; i++ )
+	{
+		VectorCopy(coords[offsets[i]], localCoords[i]);
+		VectorCopy(coords[offsets[i]], localCoords[i + 4]);
+		
+		// Set z of base of brush to bottom of landscape brush
+		localCoords[i + 4][2] = GetMins()[2];
+	}
+}
+
+
+void CCMLandScape::UpdatePatches(void)
+{
+	CCMPatch	*patch;
+	int			x, y, ix, iy, numBrushesPerPatch;
+	vec3_t		world;
+	int			size;
+
+/*	for(y=0;y<GetRealHeight();y++)
+	{
+		for(x=0;x<GetRealWidth();x++)
+		{
+			Com_Printf("(%d,%d) = %u\n", x, y, (unsigned)mHeightMap[y*GetRealWidth() + x]);
+		}
+	}
+*/
+	// Calculate real world coordinates from the heightmap
+	CalcRealCoords();
+
+	numBrushesPerPatch = mTerxels * mTerxels * 2;
+	size = (numBrushesPerPatch * sizeof(cbrush_t)) + (numBrushesPerPatch * BRUSH_SIDES_PER_TERXEL * 2 * (sizeof(cbrushside_t) + sizeof(cplane_t)));
+
+	patch = mPatches;
+	for(y = 0, iy = 0; y < mHeight; y += mTerxels, iy++)
+	{
+		for(x = 0, ix = 0; x < mWidth; x += mTerxels, ix++, patch++)
+		{
+			VectorSet(world, mBounds[0][0] + (x * mTerxelSize[0]), mBounds[0][1] + (y * mTerxelSize[1]), mBounds[0][2]);
+			patch->Init(this, x, y, world, mHeightMap, mPatchBrushData + (size * (ix + (iy * mBlockWidth))));
+		}
+	}
+
+/*	
+	for ( y = mTerxels; y < mHeight - mTerxels; y ++ )
+	{
+		for ( x = mTerxels; x < mWidth - mTerxels; x ++ )
+		{
+			int xo     = x % mTerxels;
+			int yo     = y % mTerxels;
+			int xor    = (x + 1) % mTerxels;
+			int yob    = (y + 1) % mTerxels;
+
+			CCMPatch*	patch  = mPatches + (mWidth / mTerxels) * y + (x / mTerxels);
+			CCMPatch*	rpatch = mPatches + (mWidth / mTerxels) * y + ((x+1) / mTerxels);
+			CCMPatch*	bpatch = mPatches + (mWidth / mTerxels) * (y + 1) + (x / mTerxels);
+
+			int		offsets[4];
+			vec3_t	localCoords[8];
+			vec3_t	localCoordsR[8];
+			vec3_t	localCoordsL[8];
+
+			GetTerxelLocalCoords ( x, y, localCoords );
+			GetTerxelLocalCoords ( x + 1, y, localCoordsR );
+			GetTerxelLocalCoords ( x, y + 1, localCoordsB );
+
+			brush = patch->GetCollisionData ( );;
+			side  = (cbrushside_t *)(mPatchBrushData + patch->GetNumBrushes ( ) );
+			plane = (cplane_t *)(side + (mNumBrushes * BRUSH_SIDES_PER_TERXEL * 2));
+			
+
+			float V = DotProduct ( (plane + 8)->normal, localCoords[0] ) + plane->dist;
+
+			if ( V < 0 )
+			{
+				InitPlane ( brush[0].sides + brush[0].numsides, plane + brush[0].numsides, localCoords[3], localCoords[2], localCoords[1]);
+				brush[0].numsides++;			
+
+				InitPlane ( brush[1].sides + brush[1].numsides, plane + 8 + brush[1].numsides, localCoords[0], localCoords[1], localCoords[2]);
+				brush[1].numsides++;			
+			}			
+		}
+	}
+*/
+
+	// Cleanup coord array
+	Z_Free(mCoords);
+}
+
+void CCMLandScape::CalcRealCoords(void)
+{
+	int		x, y;
+
+	mCoords = (vec3_t *)Z_Malloc(sizeof(vec3_t) * GetRealWidth() * GetRealHeight(), TAG_CM_TERRAIN_TEMP);
+
+	// Work out the real world coordinates of each heightmap entry
+	for(y = 0; y < GetRealHeight(); y++)
+	{
+		for(x = 0; x < GetRealWidth(); x++)
+		{
+			ivec3_t		icoords;
+			int			offset;
+
+			offset = (y * GetRealWidth()) + x;
+
+			VectorSet(icoords, x, y, mHeightMap[offset]);
+			VectorScaleVectorAdd(GetMins(), icoords, GetTerxelSize(), mCoords[offset]);
+		}
+	}
+}
+
+void CCMLandScape::TerrainPatchIterate(void (*IterateFunc)( CCMPatch *, void * ), void *userdata) const
+{
+	int			i;
+	CCMPatch	*patch;
+
+	patch = mPatches;
+	for(i = 0; i < GetBlockCount(); i++, patch++)
+	{
+		IterateFunc(patch, userdata);
+	}
+}
+
+#define LERP(t, a, b) (((b)-(a))*(t) + (a))
+
+float CCMLandScape::GetWorldHeight(vec3_t origin, const vec3pair_t bounds, bool aboveGround) const
+{ 
+	vec3_t		work;
+	int			minx, maxx, miny, maxy;
+	int			TL, TR, BL, BR;
+	int			final;
+
+	VectorSubtract(origin, mBounds[0], work);
+	VectorInverseScaleVector(work, mTerxelSize, work);
+
+	// Presume the bases of all misc models are less than 1 terxel square
+	minx = Com_Clamp(0, GetWidth(), (int)floorf(work[0]));
+	maxx = Com_Clamp(0, GetWidth(), (int)ceilf(work[0]));
+	miny = Com_Clamp(0, GetHeight(), (int)floorf(work[1]));
+	maxy = Com_Clamp(0, GetHeight(), (int)ceilf(work[1]));
+
+	TL = mHeightMap[(miny * GetRealWidth()) + minx];
+	TR = mHeightMap[(miny * GetRealWidth()) + maxx];
+	BL = mHeightMap[(maxy * GetRealWidth()) + minx];
+	BR = mHeightMap[(maxy * GetRealWidth()) + maxx];
+
+	if(aboveGround)
+	{
+//		int			max1, max2;
+//		max1 = maximum(TL, TR);
+//		max2 = maximum(BL, BR);
+//		final = maximum(max1, max2);
+		float h1, h2;
+		float tx, ty;
+		tx = (work[0] - minx)/((float)(maxx-minx));
+		ty = (work[1] - miny)/((float)(maxy-miny));
+		h1 = LERP(tx, TL, TR);
+		h2 = LERP(tx, BL, BR);
+		final = LERP(ty, h1, h2);
+	}
+	else
+	{
+		int			min1, min2;
+
+		min1 = minimum(TL, TR);
+		min2 = minimum(BL, BR);
+		final = minimum(min1, min2);
+	}
+	origin[2] = (final * mTerxelSize[2]) + mBounds[0][2]; 
+
+	// compute slope at this spot
+	if (maxx == minx)
+		maxx = Com_Clamp(0, GetWidth(), minx+1);
+	if (maxy == miny)
+		maxy = Com_Clamp(0, GetHeight(), miny+1);
+	BR = mHeightMap[(maxy * GetRealWidth()) + maxx];
+
+	// rise over run
+	return (fabs((float)(BR - TL)) * mTerxelSize[2]) / mTerxelSize[0];
+}
+
+void CM_CircularIterate(byte *data, int width, int height, int xo, int yo, int insideRadius, int outsideRadius, int *user, void (*callback)(byte *, float, int *))
+{
+	int		x, y, offset;
+	byte	*work;
+
+	for(y = -outsideRadius; y < outsideRadius + 1; y++)
+	{
+		if(y + yo >= 0 && y + yo < height)
+		{
+			offset = sqrtf((outsideRadius * outsideRadius) - (y * y));
+			for(x = -offset; x < offset + 1; x++)
+			{
+		 		if(x + xo >= 0 && x + xo < width)
+		 		{
+					float radius = sqrt((float)(x*x+y*y));
+
+					if ( radius >= insideRadius )
+					{
+		 				work = data + (x + xo) + ((y + yo) * width);
+		 				callback( work, (radius - (float)insideRadius) / (float)(outsideRadius - insideRadius), user);
+					}
+		 		}
+			}
+		}
+	}
+}
+
+void CM_ForceHeight( byte *work, float lerp, int *user)
+{
+	*work = (byte)Com_Clamp(0, 255, (int)*user);
+}
+
+
+void CM_GetAverage( byte *work, float lerp, int *user)
+{
+	user[0] += *work;
+	user[1]++;
+}
+
+void CM_Smooth ( byte* work, float lerp, int *user )
+{
+	float smooth = sin ( M_PI/2*3 + (1.0f-lerp) * (M_PI / 2) ) + 1.0f;
+//	float smooth = (1.0f - lerp);
+
+	*work = *work + (int)((float)(*user - *work) * smooth);
+}
+
+void CM_MakeAverage( byte *work, float lerp, int *user)
+{
+	int		height, diff;
+
+	height = (int)*work;
+	diff = *user - height;
+	if(abs(diff) > 3)
+	{
+		diff >>= 2;
+	}
+	height += diff;
+	*work = (byte)Com_Clamp(0, 255, height);
+}
+
+void CCMLandScape::SaveArea(CArea *area)
+{
+	mAreas.push_back(area);
+}
+
+void CCMLandScape::CarveLine ( vec3_t start, vec3_t end, int depth, int width )
+{
+	int	x, x1, x2, deltax;
+	int	y, y1, y2, deltay;
+	int	xinc1, xinc2;
+	int yinc1, yinc2;
+	int	den, num;
+	int count, add;
+	int	i;
+	float	heightStart;
+	float	heightEnd;
+	float	heightStep;
+
+	x1 = (int) start[0];
+	y1 = (int) start[1];
+	x2 = (int) end[0];
+	y2 = (int) end[1];	
+
+	deltax = abs(x2 - x1);
+	deltay = abs(y2 - y1);
+	x = x1;
+	y = y1;
+
+	// The x-values are increasing
+	if (x2 >= x1)
+	{
+		xinc1 = 1;
+		xinc2 = 1;
+	}
+	// The x-values are decreasing
+	else                          
+	{
+		xinc1 = -1;
+		xinc2 = -1;
+	}
+
+	// The y-values are increasing
+	if (y2 >= y1)                 
+	{
+		yinc1 = 1;
+		yinc2 = 1;
+	}
+	// The y-values are decreasing
+	else                          
+	{
+		yinc1 = -1;
+		yinc2 = -1;
+	}
+
+	if (deltax >= deltay)         // There is at least one x-value for every y-value
+	{
+		xinc1 = 0;                  // Don't change the x when numerator >= denominator
+		yinc2 = 0;                  // Don't change the y for every iteration
+		den   = deltax;
+		num   = deltax / 2;
+		add   = deltay;
+		count = deltax;				// There are more x-values than y-values
+	}
+	else                          // There is at least one y-value for every x-value
+	{
+		xinc2 = 0;                  // Don't change the x for every iteration
+		yinc1 = 0;                  // Don't change the y when numerator >= denominator
+		den   = deltay;
+		num   = deltay / 2;
+		add   = deltax;
+		count = deltay;         // There are more y-values than x-values
+	}
+
+	vec3_t pt;
+	vec3_t bounds[2] = {{-1,-1,-1},{1,1,1}};
+	
+	pt[0] = start[0];
+	pt[1] = start[1];
+	GetWorldHeight ( pt, bounds, false );
+	heightStart = pt[2];
+
+	pt[0] = end[0];
+	pt[1] = end[1];
+	GetWorldHeight ( pt, bounds, false );
+	heightEnd = pt[2];
+
+	heightStep = (heightEnd-heightStart) / count;
+
+	for ( i = 0; i <= count; i++ )
+	{
+		// Flatten the current location
+		CArea area;
+
+		pt[0] = x;
+		pt[1] = y;
+		area.Init ( pt, width / 2 + (irand(0, width/2)) );
+	 	FlattenArea ( &area, heightStart + (heightStep * i) - (depth/2 - (irand(0, depth/2))), false, true, true );
+
+		// Increase the numerator by the top of the fraction
+		num += add;					
+  
+		if (num >= den)             
+		{
+			// Calculate the new numerator value
+			num -= den;
+			
+			// Change the x and y as appropriate
+			x += xinc1;
+			y += yinc1;
+		}
+		
+		// Change the x and y as appropriate
+		x += xinc2;                 
+		y += yinc2;                 
+	}
+}
+
+void CCMLandScape::CarveBezierCurve ( int numCtlPoints, vec3_t* ctlPoints, int steps, int depth, int size )
+{
+	int		i;
+	int		choose;
+	int		n;
+	float	u;
+	float	t;
+	float	tt;
+	float	t1;
+	float	step;
+	vec3_t	pt;
+	vec3_t  lastpt;
+	vec3_t	b[10];
+
+	n      = numCtlPoints - 1;
+	choose = 1;
+
+	for ( i = 1; i <= n; i ++ )
+	{
+		if ( i == 1 )
+			choose = n;
+		else
+			choose = choose * (n-i+1) / i;
+
+		(*(ctlPoints+i))[0] *= choose;
+		(*(ctlPoints+i))[1] *= choose;
+	}
+	
+	step = 1.0f / (float)steps;
+	for ( choose = 0, t = step; t < 1; t += step, choose++ )
+	{
+		b[0][0] = (*(ctlPoints+0))[0];
+		b[0][1] = (*(ctlPoints+0))[1];
+
+		for ( u = t, i = 1; i <= n; i ++ )
+		{
+			b[i][0] = (*(ctlPoints+i))[0] * u;
+			b[i][1] = (*(ctlPoints+i))[1] * u;
+
+			u = u * t;
+		}
+
+		pt[0] = b[n][0];
+		pt[1] = b[n][1];
+
+		t1 = 1 - t;
+		tt = t1;
+
+		for ( i = n - 1; i >= 0; i -- )
+		{
+			pt[0] += b[i][0] * tt;
+			pt[1] += b[i][1] * tt;
+
+			tt = tt * t1;
+		}
+
+		if ( choose != 0 )
+		{
+			CarveLine ( lastpt, pt, depth, size );
+		}
+
+		// Save this point for next time around
+		lastpt[0] = pt[0];
+		lastpt[1] = pt[1];
+	}
+}
+
+void CCMLandScape::FlattenArea(CArea *area, int height, bool save, bool forceHeight, bool smooth )
+{
+	vec3_t	temp;
+	ivec3_t	icoords;
+	int		radius;
+	int		height2;
+
+	if(save)
+	{
+		SaveArea(area);
+	//	mAreas.push_back(*area);
+	}
+
+	// Work out coords in the heightmap
+	VectorSubtract(area->GetPosition(), mBounds[0], temp);
+	icoords[0] = temp[0] / (mBounds[1][0] - mBounds[0][0]) * (float)GetRealWidth ( );
+	icoords[1] = temp[1] / (mBounds[1][1] - mBounds[0][1]) * (float)GetRealHeight ( );
+
+//	VectorInverseScaleVector(temp, mTerxelSize, icoords);
+
+	// round up, we'd rather have a little more area flattened than have less then what was requested
+	radius = (int)ceilf( (area->GetRadius() / mTerxelSize[1]) );
+
+	// Work out the average height of the surrounding terrain
+	height2 = height;
+	if(height < 0)
+	{
+		ivec3_t info;
+
+		info[0] = 0;
+		info[1] = 0;
+		CM_CircularIterate(mHeightMap, GetRealWidth(), GetRealHeight(), icoords[0], icoords[1], 0, radius, info, CM_GetAverage);
+		if(info[1])
+		{
+			height = info[0] / info[1];
+		}
+	}
+	else
+	{
+		height = height & 0x7F;
+	}
+
+	if ( smooth )
+	{
+		CM_CircularIterate(mHeightMap, GetRealWidth(), GetRealHeight(), icoords[0], icoords[1], radius, radius * 3, &height, CM_Smooth);
+	}
+
+	if ( forceHeight )
+	{		
+		CM_CircularIterate(mHeightMap, GetRealWidth(), GetRealHeight(), icoords[0], icoords[1], 0, radius + 1, &height, CM_ForceHeight );
+		CM_CircularIterate(mFlattenMap, GetRealWidth(), GetRealHeight(), icoords[0], icoords[1], 0, radius + 1, &height2, CM_ForceHeight );
+	}
+	else if ( smooth ) 
+	{
+		CM_CircularIterate(mHeightMap, GetRealWidth(), GetRealHeight(), icoords[0], icoords[1], 0, radius, &height, CM_Smooth);
+	}
+}
+
+void CM_BelowLevel(byte *data, float lerp, int *info)
+{
+	info[1]++;
+	if(*data < info[2])
+	{
+		info[0]++;
+	}
+}
+
+float CCMLandScape::FractionBelowLevel(CArea *area, int height)
+{
+	vec3_t	temp;
+	ivec3_t	icoords, info;
+	int		count;
+	float	level;
+
+	// Work out coords in the heightmap
+	VectorSubtract(area->GetPosition(), mBounds[0], temp);
+	VectorInverseScaleVector(temp, mTerxelSize, icoords);
+
+	// Work out radius of area in heightmap entries
+	count = area->GetRadius() / mTerxelSize[1];
+
+	info[0] = 0;
+	info[1] = 0;
+
+	info[2] = height;
+	if(height < 0)
+	{
+		info[2] = mBaseWaterHeight;
+	}
+	CM_CircularIterate(mHeightMap, GetRealWidth(), GetRealHeight(), icoords[0], icoords[1], 0, count, info, CM_BelowLevel);
+
+	level = 0.0f;
+	if(info[1])
+	{
+		level = (float)info[0] / info[1];
+	}
+
+	return(level);
+}
+
+CArea *CCMLandScape::GetFirstArea(void)
+{
+	if(!mAreas.size())
+	{
+		return(NULL);
+	}
+	mAreasIt = mAreas.begin();
+	return (*mAreasIt);
+}
+
+CArea *CCMLandScape::GetFirstObjectiveArea(void)
+{
+	if(!mAreas.size())
+	{
+		return(NULL);
+	}
+	mAreasIt = mAreas.begin();
+
+	while (mAreasIt != mAreas.end())
+	{
+		// run through the areas to find the player area
+		if((*mAreasIt)->GetType() == AT_OBJECTIVE)
+		{
+			return (*mAreasIt);
+		}
+		mAreasIt++;
+	}
+	return(NULL);
+}
+
+CArea *CCMLandScape::GetPlayerArea(void)
+{ // do me
+	if(!mAreas.size())
+	{
+		return(NULL);
+	}
+	mAreasIt = mAreas.begin();
+
+	while (mAreasIt != mAreas.end())
+	{
+		// run through the areas to find the player area
+		if((*mAreasIt)->GetType() == AT_PLAYER)
+		{
+			return (*mAreasIt);
+		}
+		mAreasIt++;
+	}
+	return(NULL);
+}
+
+CArea *CCMLandScape::GetNextArea(void)
+{
+	mAreasIt++;
+	if(mAreasIt == mAreas.end())
+	{
+		return(NULL);
+	}
+	return (*mAreasIt);
+}
+
+CArea *CCMLandScape::GetNextObjectiveArea(void)
+{
+	mAreasIt++;
+
+	while (mAreasIt != mAreas.end())
+	{
+		// run through the areas to find the player area
+		if((*mAreasIt)->GetType() == AT_OBJECTIVE)
+		{
+			return (*mAreasIt);
+		}
+		mAreasIt++;
+	}
+	return(NULL);
+}
+
+bool CCMLandScape::AreaCollision(CArea *area, int *areaTypes, int areaTypeCount)
+{
+	CArea	*areas;
+	int		i;
+	float	segment;
+	bool	collision;
+
+	areas = GetFirstArea();
+	while(areas)
+	{
+		collision = false;
+
+		if(area->GetVillageID() == areas->GetVillageID())
+		{
+			// Check for being too close angularly
+			if(area->GetAngleDiff() && areas->GetAngleDiff())
+			{
+				segment = areas->GetAngle() - area->GetAngle();
+				if(segment < M_PI)
+				{
+					segment += 2 * M_PI;
+				}						
+				if(segment > M_PI)
+				{
+					segment -= 2 * M_PI;
+				}						
+				if(fabsf(segment) < areas->GetAngleDiff() + area->GetAngleDiff())
+				{
+					collision = true;
+				}
+			}
+		}
+
+		// Check for buildings being too close together
+		if(Distance(areas->GetPosition(), area->GetPosition()) < areas->GetRadius() + area->GetRadius())
+		{
+			collision = true;
+		}
+
+		if(collision)
+		{
+			// If no area type list was specified then all areas are fair game
+			if ( !areaTypes )
+			{
+				return true;
+			}
+
+			for(i = 0; i < areaTypeCount; i++)
+			{
+				if(areas->GetType() == areaTypes[i])
+				{
+					return(true);
+				}
+			}
+		}
+		areas = GetNextArea();
+	}
+	return(false);
+}
+
+void CCMLandScape::rand_seed(int seed)
+{
+	holdrand = seed;
+	Com_Printf("rand_seed = %d\n", holdrand);
+} 
+
+float CCMLandScape::flrand(float min, float max)
+{
+	float	result;
+
+	assert((max - min) < 32768);
+
+	holdrand = (holdrand * 214013L) + 2531011L;
+	result = (float)(holdrand >> 17);						// 0 - 32767 range
+	result = ((result * (max - min)) / 32768.0F) + min;
+//	Com_Printf("flrand: Seed = %d\n", holdrand);
+
+	return(result);
+}
+
+int CCMLandScape::irand(int min, int max)
+{
+	int		result;
+
+	assert((max - min) < 32768);
+
+	max++;
+	holdrand = (holdrand * 214013L) + 2531011L;
+	result = holdrand >> 17;
+	result = ((result * (max - min)) >> 15) + min;
+//	Com_Printf("irand: Seed = %d\n", holdrand);
+
+	return(result);
+}
+
+CCMLandScape::~CCMLandScape(void)
+{
+	if(mHeightMap) 
+	{ 
+		Z_Free(mHeightMap); 
+		mHeightMap = NULL;
+	}
+	if(mFlattenMap)
+	{
+		Z_Free(mFlattenMap);
+		mFlattenMap = NULL;
+	}
+	if(mPatchBrushData)
+	{
+		Z_Free(mPatchBrushData);
+		mPatchBrushData = NULL;
+	}
+	if(mPatches) 
+	{ 
+		Z_Free(mPatches); 
+		mPatches = NULL;
+	}
+	if (mRandomTerrain)
+	{
+		delete mRandomTerrain;
+	}
+
+	for(mAreasIt=mAreas.begin(); mAreasIt != mAreas.end(); mAreasIt++)
+	{
+		delete (*mAreasIt);
+	}
+
+	mAreas.clear();
+}
+
+class CCMLandScape *CM_InitTerrain(const char *configstring, thandle_t terrainId, bool server)
+{
+	CCMLandScape	*ls;
+
+	ls = new CCMLandScape(configstring, server);
+	ls->SetTerrainId(terrainId);
+
+	return(ls);
+}
+
+void CM_TerrainPatchIterate(const class CCMLandScape *landscape, void (*IterateFunc)( CCMPatch *, void * ), void *userdata)
+{
+	landscape->TerrainPatchIterate(IterateFunc, userdata);
+}
+
+float CM_GetWorldHeight(const CCMLandScape *landscape, vec3_t origin, const vec3pair_t bounds, bool aboveGround)
+{
+	return landscape->GetWorldHeight(origin, bounds, aboveGround);
+}
+
+void CM_FlattenArea(CCMLandScape *landscape, CArea *area, int height, bool save, bool forceHeight, bool smooth )
+{
+	landscape->FlattenArea(area, height, save, forceHeight, smooth );
+}
+
+void CM_CarveBezierCurve(CCMLandScape *landscape, int numCtls, vec3_t* ctls, int steps, int depth, int size )
+{
+	landscape->CarveBezierCurve(numCtls, ctls, steps, depth, size );
+}
+
+void CM_SaveArea(CCMLandScape *landscape, CArea *area)
+{
+	landscape->SaveArea(area);
+}
+
+float CM_FractionBelowLevel(CCMLandScape *landscape, CArea *area, int height)
+{
+	return(landscape->FractionBelowLevel(area, height));
+}
+
+bool CM_AreaCollision(class CCMLandScape *landscape, class CArea *area, int *areaTypes, int areaTypeCount)
+{
+	return(landscape->AreaCollision(area, areaTypes, areaTypeCount));
+}
+
+CArea *CM_GetFirstArea(CCMLandScape *landscape)
+{
+	return(landscape->GetFirstArea());
+}
+
+CArea *CM_GetFirstObjectiveArea(CCMLandScape *landscape)
+{
+	return(landscape->GetFirstObjectiveArea());
+}
+
+CArea *CM_GetPlayerArea(CCMLandScape *landscape)
+{
+	return(landscape->GetPlayerArea());
+}
+
+CArea *CM_GetNextArea(CCMLandScape *landscape)
+{
+	return(landscape->GetNextArea());
+}
+
+CArea *CM_GetNextObjectiveArea(CCMLandScape *landscape)
+{
+	return(landscape->GetNextObjectiveArea());
+}
+
+CRandomTerrain *CreateRandomTerrain(const char *config, CCMLandScape *landscape, byte *heightmap, int width, int height)
+{
+	CRandomTerrain	*RandomTerrain = 0;
+
+#ifndef PRE_RELEASE_DEMO
+	char			*ptr;
+	unsigned long	seed;
+
+	seed = strtoul(Info_ValueForKey(config, "seed"), &ptr, 10);
+
+	landscape->rand_seed(seed);
+	
+	RandomTerrain = new CRandomTerrain;
+	RandomTerrain->Init(landscape, heightmap, width, height);
+#endif // #ifndef PRE_RELEASE_DEMO
+
+/*
+	RandomTerrain->CreatePath(0, -1, 0, 9, 0.1, 0.5, 0.5, 0.5, 0.05, 0.08, 0.31, 0.1, 3);
+	RandomTerrain->CreatePath(1, 0, 0, 6, 0.5, 0.5, 0.9, 0.1, 0.08, 0.1, 0.31, 0.1, 0.9);
+	RandomTerrain->CreatePath(2, 0, 0, 6, 0.5, 0.5, 0.9, 0.9, 0.08, 0.1, 0.31, 0.1, 0.9);
+
+	RandomTerrain->Generate();
+*/
+
+	return RandomTerrain;
+}
+
+
+// end
+
+#ifdef _WIN32
+#pragma optimize("p", off)
+#endif
diff --git a/codemp/qcommon/cm_terrainmap.cpp b/codemp/qcommon/cm_terrainmap.cpp
new file mode 100644
index 0000000..11c3405
--- /dev/null
+++ b/codemp/qcommon/cm_terrainmap.cpp
@@ -0,0 +1,497 @@
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+#include "cm_local.h"
+#include "cm_patch.h"
+#include "cm_landscape.h"
+#include "../qcommon/GenericParser2.h"
+//#include "image.h"
+//#include "../qcommon/q_imath.h"
+#include "cm_terrainmap.h"
+#include "cm_draw.h"
+#include "../png/png.h"
+
+static CTerrainMap	*TerrainMap = 0;
+
+// Hack. This shouldn't be here, but it's easier than including tr_local.h
+typedef unsigned int GLenum;
+
+#ifdef _XBOX
+void R_LoadImage( const char *shortname, byte **pic, int *width, int *height, int *mipcount, GLenum *format );
+#else
+void R_LoadImage( const char *name, byte **pic, int *width, int *height, GLenum *format ) ;
+#endif
+
+void R_CreateAutomapImage( const char *name, const byte *pic, int width, int height, 
+					   qboolean mipmap, qboolean allowPicmip, qboolean allowTC, int glWrapClampMode );
+
+// simple function for getting a proper color for a side
+inline CPixel32 SideColor(int side)
+{
+	CPixel32 col(255,255,255);
+	switch (side)
+	{
+		default:
+			break;
+		case SIDE_BLUE:
+			col = CPixel32(0,0,192);
+			break;
+		case SIDE_RED:
+			col = CPixel32(192,0,0);
+			break;
+	}
+	return col;
+}
+
+CTerrainMap::CTerrainMap(CCMLandScape *landscape) :
+	mLandscape(landscape)
+{
+	ApplyBackground();
+	ApplyHeightmap();
+
+	CDraw32 draw;
+	draw.SetBuffer((CPixel32*) mImage);
+	draw.SetBufferSize(TM_WIDTH,TM_HEIGHT,TM_WIDTH);
+
+	// create version with paths and water shown
+	int x,y;
+	int water;
+	int land;
+
+	for (y=0; y<TM_HEIGHT; y++)
+		for (x=0; x<TM_WIDTH; x++)
+		{
+			CPixel32 cp = ((CPixel32*)mBufImage)[PIXPOS(x,y,TM_WIDTH)];
+			land = CLAMP(((255 - cp.a)*2)/3,0,255);
+			water = CLAMP((landscape->GetBaseWaterHeight() - cp.a)*4, 0, 255);
+			cp.a = 255;
+
+			if (x > TM_BORDER && x < (TM_WIDTH-TM_BORDER) &&
+				y > TM_BORDER && y < (TM_WIDTH-TM_BORDER))
+			{
+				cp = ALPHA_PIX (CPixel32(0,0,0), cp, land, 256-land);
+				if (water > 0)
+					cp = ALPHA_PIX (CPixel32(0,0,255), cp, water, 256-water);
+			}
+
+			draw.PutPix(x, y, cp);
+		}
+
+	// Load icons for symbols on map
+	GLenum	format;
+#ifdef _XBOX
+	int mipcount;
+
+	R_LoadImage("gfx/menus/rmg/start", (byte**)&mSymStart, &mSymStartWidth, &mSymStartHeight, &mipcount, &format);
+	R_LoadImage("gfx/menus/rmg/end", (byte**)&mSymEnd, &mSymEndWidth, &mSymEndHeight, &mipcount, &format);
+	R_LoadImage("gfx/menus/rmg/objective", (byte**)&mSymObjective, &mSymObjectiveWidth, &mSymObjectiveHeight, &mipcount, &format);
+
+	R_LoadImage("gfx/menus/rmg/building", (byte**)&mSymBld, &mSymBldWidth, &mSymBldHeight, &mipcount, &format);
+#else
+	R_LoadImage("gfx/menus/rmg/start", (byte**)&mSymStart, &mSymStartWidth, &mSymStartHeight, &format);
+	R_LoadImage("gfx/menus/rmg/end", (byte**)&mSymEnd, &mSymEndWidth, &mSymEndHeight, &format);
+	R_LoadImage("gfx/menus/rmg/objective", (byte**)&mSymObjective, &mSymObjectiveWidth, &mSymObjectiveHeight, &format);
+
+	R_LoadImage("gfx/menus/rmg/building", (byte**)&mSymBld, &mSymBldWidth, &mSymBldHeight, &format);
+#endif
+}
+
+CTerrainMap::~CTerrainMap()
+{
+	if (mSymStart)
+	{
+		Z_Free(mSymStart);
+		mSymStart = NULL;
+	}
+
+	if (mSymEnd)
+	{
+		Z_Free(mSymEnd);
+		mSymEnd = NULL;
+	}
+
+	if (mSymBld)
+	{
+		Z_Free(mSymBld);
+		mSymBld = NULL;
+	}
+
+	if (mSymObjective)
+	{
+		Z_Free(mSymObjective);
+		mSymObjective = NULL;
+	}
+
+	CDraw32::CleanUp(); 
+}
+
+void CTerrainMap::ApplyBackground(void)
+{
+	int		x, y;
+	byte	*outPos;
+	float	xRel, yRel, xInc, yInc;
+	byte	*backgroundImage;
+	int		backgroundWidth, backgroundHeight, backgroundDepth;
+	int		pos;
+	GLenum	format;
+
+	memset(mImage, 255, sizeof(mBufImage));
+//	R_LoadImage("textures\\kamchatka\\ice", &backgroundImage, &backgroundWidth, &backgroundHeight, &format);0
+	backgroundDepth = 4;
+#ifdef _XBOX
+	int mipcount;
+
+	R_LoadImage("gfx\\menus\\rmg\\01_bg", &backgroundImage, &backgroundWidth, &backgroundHeight, &mipcount, &format);
+#else
+	R_LoadImage("gfx\\menus\\rmg\\01_bg", &backgroundImage, &backgroundWidth, &backgroundHeight, &format);
+#endif
+	if (backgroundImage)
+	{
+		outPos = (byte *)mBufImage;
+		xInc = (float)backgroundWidth / (float)TM_WIDTH;
+		yInc = (float)backgroundHeight / (float)TM_HEIGHT;
+
+		yRel = 0.0;
+		for(y=0;y<TM_HEIGHT;y++)
+		{
+			xRel = 0.0;
+			for(x=0;x<TM_WIDTH;x++)
+			{
+				pos = ((((int)yRel)*backgroundWidth) + ((int)xRel)) * 4;
+				*outPos = backgroundImage[pos++];
+				outPos++;
+				*outPos = backgroundImage[pos++];
+				outPos++;
+				*outPos = backgroundImage[pos];
+				outPos+=2;
+				xRel += xInc;
+			}
+			yRel += yInc;
+		}
+		Z_Free(backgroundImage);
+	}
+}
+
+void CTerrainMap::ApplyHeightmap(void)
+{
+	int			x, y;
+	byte		*inPos = mLandscape->GetHeightMap();
+	int			width = mLandscape->GetRealWidth();
+	int			height = mLandscape->GetRealHeight();
+	byte		*outPos;
+	unsigned	tempColor;
+	float		xRel, yRel, xInc, yInc;
+	int			count;
+
+	outPos = (byte *)mBufImage;
+	outPos += (((TM_BORDER * TM_WIDTH) + TM_BORDER) * 4);
+	xInc = (float)width / (float)(TM_REAL_WIDTH);
+	yInc = (float)height / (float)(TM_REAL_HEIGHT);
+	
+	// add in height map as alpha 
+	yRel = 0.0;
+	for(y=0;y<TM_REAL_HEIGHT;y++)
+	{
+		// x is flipped!
+		xRel = width;
+		for(x=0;x<TM_REAL_WIDTH;x++)
+		{
+			count = 1;
+			tempColor = inPos[(((int)yRel)*width) + ((int)xRel)];
+			if (yRel >= 1.0)
+			{
+				tempColor += inPos[(((int)(yRel-0.5))*width) + ((int)xRel)];
+				count++;
+			}
+			if (yRel <= height-2)
+			{
+				tempColor += inPos[(((int)(yRel+0.5))*width) + ((int)xRel)];
+				count++;
+			}
+			if (xRel >= 1.0)
+			{
+				tempColor += inPos[(((int)(yRel))*width) + ((int)(xRel-0.5))];
+				count++;
+			}
+			if (xRel <= width-2)
+			{
+				tempColor += inPos[(((int)(yRel))*width) + ((int)(xRel+0.5))];
+				count++;
+			}
+			tempColor /= count;
+
+			outPos[3] = tempColor;
+			outPos += 4;
+
+			// x is flipped!
+			xRel -= xInc;
+		}
+		outPos += TM_BORDER * 4 * 2;
+
+		yRel += yInc;
+	}
+}
+
+// Convert position in game coords to automap coords
+void CTerrainMap::ConvertPos(int& x, int& y)
+{
+	x = ((x - mLandscape->GetMins()[0]) / mLandscape->GetSize()[0]) * TM_REAL_WIDTH;
+	y = ((y - mLandscape->GetMins()[1]) / mLandscape->GetSize()[1]) * TM_REAL_HEIGHT;
+
+	// x is flipped!
+	x = TM_REAL_WIDTH - x - 1;
+
+	// border
+	x += TM_BORDER;
+	y += TM_BORDER;
+}
+
+void CTerrainMap::AddStart(int x, int y, int side)
+{
+	ConvertPos(x, y);
+
+	CDraw32 draw;
+	draw.BlitColor(x-mSymStartWidth/2, y-mSymStartHeight/2, mSymStartWidth, mSymStartHeight, 
+			  (CPixel32*)mSymStart, 0, 0, mSymStartWidth, SideColor(side));
+}
+
+void CTerrainMap::AddEnd(int x, int y, int side)
+{
+	ConvertPos(x, y);
+
+	CDraw32 draw;
+	draw.BlitColor(x-mSymEndWidth/2, y-mSymEndHeight/2, mSymEndWidth, mSymEndHeight, 
+			  (CPixel32*)mSymEnd, 0, 0, mSymEndWidth, SideColor(side));
+}
+
+void CTerrainMap::AddObjective(int x, int y, int side)
+{
+	ConvertPos(x, y);
+
+	CDraw32 draw;
+	draw.BlitColor(x-mSymObjectiveWidth/2, y-mSymObjectiveHeight/2, mSymObjectiveWidth, mSymObjectiveHeight, 
+			  (CPixel32*)mSymObjective, 0, 0, mSymObjectiveWidth, SideColor(side));
+}
+
+void CTerrainMap::AddBuilding(int x, int y, int side)
+{
+	ConvertPos(x, y);
+
+	CDraw32 draw;
+	draw.BlitColor(x-mSymBldWidth/2, y-mSymBldHeight/2, mSymBldWidth, mSymBldHeight, 
+			  (CPixel32*)mSymBld, 0, 0, mSymBldWidth, SideColor(side));
+}
+
+void CTerrainMap::AddNPC(int x, int y, bool friendly)
+{
+	ConvertPos(x, y);
+
+	CDraw32 draw;
+	if (friendly)
+		draw.DrawCircle(x,y,3, CPixel32(0,192,0), CPixel32(0,0,0,0));
+	else
+		draw.DrawCircle(x,y,3, CPixel32(192,0,0), CPixel32(0,0,0,0));
+}
+
+void CTerrainMap::AddNode(int x, int y)
+{
+	ConvertPos(x, y);
+
+	CDraw32 draw;
+	draw.DrawCircle(x,y,20, CPixel32(255,255,255), CPixel32(0,0,0,0));
+}
+
+void CTerrainMap::AddWallRect(int x, int y, int side)
+{
+	ConvertPos(x, y);
+
+	CDraw32 draw;
+	switch (side)
+	{
+		default:
+			draw.DrawBox(x-1,y-1,3,3,CPixel32(192,192,192,128));
+			break;
+		case SIDE_BLUE:
+			draw.DrawBox(x-1,y-1,3,3,CPixel32(0,0,192,128));
+			break;
+		case SIDE_RED:
+			draw.DrawBox(x-1,y-1,3,3,CPixel32(192,0,0,128));
+			break;
+	}
+}
+
+void CTerrainMap::AddPlayer(vec3_t origin, vec3_t angles)
+{
+	// draw player start on automap
+	CDraw32 draw;
+
+	vec3_t up;
+	vec3_t pt[4] = {{0,0,0},{-5,-5,0},{10,0,0},{-5,5,0}};
+	vec3_t p;
+	int x,y,i;
+	float facing;
+	POINT poly[4];
+
+	facing = angles[1];
+	
+	up[0] = 0;
+	up[1] = 0;
+	up[2] = 1;
+
+	x = (int)origin[0];
+	y = (int)origin[1];
+	ConvertPos(x, y);
+	x++; y++;
+
+	for (i=0; i<4; i++)
+	{
+		RotatePointAroundVector( p, up, pt[i], facing );
+		poly[i].x = (int)(-p[0] + x);
+		poly[i].y = (int)(p[1] + y);
+	}
+
+	// draw arrowhead shadow
+	draw.DrawPolygon(4, poly, CPixel32(0,0,0,128), CPixel32(0,0,0,128));
+
+	// draw arrowhead
+	for (i=0; i<4; i++)
+	{
+		poly[i].x--;
+		poly[i].y--;
+	}
+	draw.DrawPolygon(4, poly, CPixel32(255,255,255), CPixel32(255,255,255));
+}
+
+void CTerrainMap::Upload(vec3_t player_origin, vec3_t player_angles)
+{
+	CDraw32		draw;
+
+	// copy completed map to mBufImage
+	draw.SetBuffer((CPixel32*) mBufImage);
+	draw.SetBufferSize(TM_WIDTH,TM_HEIGHT,TM_WIDTH);
+
+	draw.Blit(0, 0, TM_WIDTH, TM_HEIGHT, 
+			  (CPixel32*)mImage, 0, 0, TM_WIDTH);
+
+	// now draw player's location on map
+	if (player_origin)
+	{
+		AddPlayer(player_origin, player_angles);
+	}
+
+	draw.SetAlphaBuffer(255);
+	
+	R_CreateAutomapImage("*automap", (unsigned char *)draw.buffer, TM_WIDTH, TM_HEIGHT, qfalse, qfalse, qtrue, qfalse);
+
+	draw.SetBuffer((CPixel32*) mImage);
+}
+
+void CTerrainMap::SaveImageToDisk(const char * terrainName, const char * missionName, const char * seed)
+{
+	//ri.COM_SavePNG(va("save/%s_%s_%s.png", terrainName, missionName, seed), 
+	//		(unsigned char *)mImage, TM_WIDTH, TM_HEIGHT, 4);
+	PNG_Save(va("save/%s_%s_%s.png", terrainName, missionName, seed), 
+			(unsigned char *)mImage, TM_WIDTH, TM_HEIGHT, 4);
+}
+
+void CM_TM_Create(CCMLandScape *landscape)
+{
+	if (TerrainMap)
+	{
+		CM_TM_Free();
+	}
+
+	TerrainMap = new CTerrainMap(landscape);
+}
+
+void CM_TM_Free(void)
+{
+	if (TerrainMap)
+	{
+		delete TerrainMap;
+		TerrainMap = 0;
+	}
+}
+
+void CM_TM_AddStart(int x, int y, int side)
+{
+	if (TerrainMap)
+	{
+		TerrainMap->AddStart(x, y, side);
+	}
+}
+
+void CM_TM_AddEnd(int x, int y, int side)
+{
+	if (TerrainMap)
+	{
+		TerrainMap->AddEnd(x, y, side);
+	}
+}
+
+void CM_TM_AddObjective(int x, int y, int side)
+{
+	if (TerrainMap)
+	{
+		TerrainMap->AddObjective(x, y, side);
+	}
+}
+
+void CM_TM_AddNPC(int x, int y, bool friendly)
+{
+	if (TerrainMap)
+	{
+		TerrainMap->AddNPC(x, y, friendly);
+	}
+}
+
+void CM_TM_AddNode(int x, int y)
+{
+	if (TerrainMap)
+	{
+		TerrainMap->AddNode(x, y);
+	}
+}
+
+void CM_TM_AddBuilding(int x, int y, int side)
+{
+	if (TerrainMap)
+	{
+		TerrainMap->AddBuilding(x, y, side);
+	}
+}
+
+void CM_TM_AddWallRect(int x, int y, int side)
+{
+	if (TerrainMap)
+	{
+		TerrainMap->AddWallRect(x, y, side);
+	}
+}
+
+void CM_TM_Upload(vec3_t player_origin, vec3_t player_angles)
+{
+	if (TerrainMap)
+	{
+		TerrainMap->Upload(player_origin, player_angles);
+	}
+}
+
+void CM_TM_SaveImageToDisk(const char * terrainName, const char * missionName, const char * seed)
+{
+	if (TerrainMap)
+	{	// write out automap
+		TerrainMap->SaveImageToDisk(terrainName, missionName, seed);
+	}
+}
+
+void CM_TM_ConvertPosition(int &x, int &y, int Width, int Height)
+{
+	if (TerrainMap)
+	{
+		TerrainMap->ConvertPos(x, y);
+		x = x * Width / TM_WIDTH;
+		y = y * Height / TM_HEIGHT;
+	}
+}
+
diff --git a/codemp/qcommon/cm_terrainmap.h b/codemp/qcommon/cm_terrainmap.h
new file mode 100644
index 0000000..62cf9b8
--- /dev/null
+++ b/codemp/qcommon/cm_terrainmap.h
@@ -0,0 +1,83 @@
+#pragma once
+#if !defined(CM_TERRAINMAP_H_INC)
+#define CM_TERRAINMAP_H_INC
+
+#ifdef _XBOX
+#define TM_WIDTH		64
+#define TM_HEIGHT		64
+#define	TM_BORDER		4
+#else
+#define TM_WIDTH		512
+#define TM_HEIGHT		512
+#define	TM_BORDER		16
+#endif
+#define TM_REAL_WIDTH	(TM_WIDTH-TM_BORDER-TM_BORDER)
+#define TM_REAL_HEIGHT	(TM_HEIGHT-TM_BORDER-TM_BORDER)
+
+class CTerrainMap
+{
+private:
+	byte			mImage[TM_HEIGHT][TM_WIDTH][4];	// image to output
+	byte			mBufImage[TM_HEIGHT][TM_WIDTH][4];	// src data for image, color and bump
+
+	byte*			mSymBld;
+	int				mSymBldWidth;
+	int				mSymBldHeight;
+
+	byte*			mSymStart;
+	int				mSymStartWidth;
+	int				mSymStartHeight;
+
+	byte*			mSymEnd;
+	int				mSymEndWidth;
+	int				mSymEndHeight;
+
+	byte*			mSymObjective;
+	int				mSymObjectiveWidth;
+	int				mSymObjectiveHeight;
+
+	CCMLandScape	*mLandscape;
+
+	void	ApplyBackground(void);
+	void	ApplyHeightmap(void);
+
+public:
+	CTerrainMap(CCMLandScape *landscape);
+	~CTerrainMap();
+	
+	void	ConvertPos(int& x, int& y);
+	void	AddBuilding(int x, int y, int side);
+	void	AddStart(int x, int y, int side);
+	void	AddEnd(int x, int y, int side);
+	void	AddObjective(int x, int y, int side);
+	void	AddNPC(int x, int y, bool friendly);
+	void	AddWallRect(int x, int y, int side);
+	void	AddNode(int x, int y);
+	void	AddPlayer(vec3_t origin, vec3_t angles);
+
+	void	Upload(vec3_t player_origin, vec3_t player_angles);
+	void	SaveImageToDisk(const char * terrainName, const char * missionName, const char * seed);
+};
+
+enum
+{
+	SIDE_NONE =0,
+	SIDE_BLUE =1,
+	SIDE_RED = 2
+};
+
+void	CM_TM_Create(CCMLandScape *landscape);
+void	CM_TM_Free(void);
+void	CM_TM_AddStart(int x, int y, int side = SIDE_NONE);
+void	CM_TM_AddEnd(int x, int y, int side = SIDE_NONE);
+void	CM_TM_AddObjective(int x, int y, int side = SIDE_NONE);
+void	CM_TM_AddNPC(int x, int y, bool friendly);
+void	CM_TM_AddWallRect(int x, int y, int side = SIDE_NONE);
+void	CM_TM_AddNode(int x, int y);
+void	CM_TM_AddBuilding(int x, int y, int side = SIDE_NONE);
+void	CM_TM_Upload(vec3_t player_origin, vec3_t player_angles);
+void	CM_TM_SaveImageToDisk(const char * terrainName, const char * missionName, const char * seed);
+void	CM_TM_ConvertPosition(int &x, int &y, int Width, int Height);
+
+#endif CM_TERRAINMAP_H_INC
+
diff --git a/codemp/qcommon/cm_test.cpp b/codemp/qcommon/cm_test.cpp
new file mode 100644
index 0000000..7cd325d
--- /dev/null
+++ b/codemp/qcommon/cm_test.cpp
@@ -0,0 +1,573 @@
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+#include "cm_local.h"
+
+#ifdef _XBOX
+#include "../renderer/tr_local.h"
+#endif
+
+/*
+==================
+CM_PointLeafnum_r
+
+==================
+*/
+int CM_PointLeafnum_r( const vec3_t p, int num, clipMap_t *local ) {
+	float		d;
+	cNode_t		*node;
+	cplane_t	*plane;
+
+	while (num >= 0)
+	{
+		node = local->nodes + num;
+
+#ifdef _XBOX
+		plane = cmg.planes + node->planeNum;//tr.world->nodes[num].planeNum;
+#else
+		plane = node->plane;
+#endif
+		
+		if (plane->type < 3)
+			d = p[plane->type] - plane->dist;
+		else
+			d = DotProduct (plane->normal, p) - plane->dist;
+		if (d < 0)
+			num = node->children[1];
+		else
+			num = node->children[0];
+	}
+
+	c_pointcontents++;		// optimize counter
+
+	return -1 - num;
+}
+
+int CM_PointLeafnum( const vec3_t p ) {
+	if ( !cmg.numNodes ) {	// map not loaded
+		return 0;
+	}
+	return CM_PointLeafnum_r (p, 0, &cmg);
+}
+
+
+/*
+======================================================================
+
+LEAF LISTING
+
+======================================================================
+*/
+
+
+void CM_StoreLeafs( leafList_t *ll, int nodenum ) {
+	int		leafNum;
+
+	leafNum = -1 - nodenum;
+
+	// store the lastLeaf even if the list is overflowed
+	if ( cmg.leafs[ leafNum ].cluster != -1 ) {
+		ll->lastLeaf = leafNum;
+	}
+
+	if ( ll->count >= ll->maxcount) {
+		ll->overflowed = qtrue;
+		return;
+	}
+	ll->list[ ll->count++ ] = leafNum;
+}
+
+void CM_StoreBrushes( leafList_t *ll, int nodenum ) {
+	int			i, k;
+	int			leafnum;
+	int			brushnum;
+	cLeaf_t		*leaf;
+	cbrush_t	*b;
+
+	leafnum = -1 - nodenum;
+
+	leaf = &cmg.leafs[leafnum];
+
+	for ( k = 0 ; k < leaf->numLeafBrushes ; k++ ) {
+		brushnum = cmg.leafbrushes[leaf->firstLeafBrush+k];
+		b = &cmg.brushes[brushnum];
+		if ( b->checkcount == cmg.checkcount ) {
+			continue;	// already checked this brush in another leaf
+		}
+		b->checkcount = cmg.checkcount;
+		for ( i = 0 ; i < 3 ; i++ ) {
+			if ( b->bounds[0][i] >= ll->bounds[1][i] || b->bounds[1][i] <= ll->bounds[0][i] ) {
+				break;
+			}
+		}
+		if ( i != 3 ) {
+			continue;
+		}
+		if ( ll->count >= ll->maxcount) {
+			ll->overflowed = qtrue;
+			return;
+		}
+		((cbrush_t **)ll->list)[ ll->count++ ] = b;
+	}
+#if 0
+	// store patches?
+	for ( k = 0 ; k < leaf->numLeafSurfaces ; k++ ) {
+		patch = cm.surfaces[ cm.leafsurfaces[ leaf->firstleafsurface + k ] ];
+		if ( !patch ) {
+			continue;
+		}
+	}
+#endif
+}
+
+/*
+=============
+CM_BoxLeafnums
+
+Fills in a list of all the leafs touched
+=============
+*/
+void CM_BoxLeafnums_r( leafList_t *ll, int nodenum ) {
+	cplane_t	*plane;
+	cNode_t		*node;
+	int			s;
+
+	while (1) {
+		if (nodenum < 0) {
+			ll->storeLeafs( ll, nodenum );
+			return;
+		}
+	
+		node = &cmg.nodes[nodenum];
+
+#ifdef _XBOX
+		plane = cmg.planes + node->planeNum;//tr.world->nodes[nodenum].planeNum;
+#else
+		plane = node->plane;
+#endif
+
+		s = BoxOnPlaneSide( ll->bounds[0], ll->bounds[1], plane );
+		if (s == 1) {
+			nodenum = node->children[0];
+		} else if (s == 2) {
+			nodenum = node->children[1];
+		} else {
+			// go down both
+			CM_BoxLeafnums_r( ll, node->children[0] );
+			nodenum = node->children[1];
+		}
+
+	}
+}
+
+/*
+==================
+CM_BoxLeafnums
+==================
+*/
+int	CM_BoxLeafnums( const vec3_t mins, const vec3_t maxs, int *boxList, int listsize, int *lastLeaf) {
+	//rwwRMG - changed to boxList to not conflict with list type
+	leafList_t	ll;
+
+	cmg.checkcount++;
+
+	VectorCopy( mins, ll.bounds[0] );
+	VectorCopy( maxs, ll.bounds[1] );
+	ll.count = 0;
+	ll.maxcount = listsize;
+	ll.list = boxList;
+	ll.storeLeafs = CM_StoreLeafs;
+	ll.lastLeaf = 0;
+	ll.overflowed = qfalse;
+
+	CM_BoxLeafnums_r( &ll, 0 );
+
+	*lastLeaf = ll.lastLeaf;
+	return ll.count;
+}
+
+/*
+==================
+CM_BoxBrushes
+==================
+*/
+int CM_BoxBrushes( const vec3_t mins, const vec3_t maxs, cbrush_t **boxList, int listsize ) {
+	//rwwRMG - changed to boxList to not conflict with list type
+	leafList_t	ll;
+
+	cmg.checkcount++;
+
+	VectorCopy( mins, ll.bounds[0] );
+	VectorCopy( maxs, ll.bounds[1] );
+	ll.count = 0;
+	ll.maxcount = listsize;
+	ll.list = (int *)boxList;
+	ll.storeLeafs = CM_StoreBrushes;
+	ll.lastLeaf = 0;
+	ll.overflowed = qfalse;
+	
+	CM_BoxLeafnums_r( &ll, 0 );
+
+	return ll.count;
+}
+
+
+//====================================================================
+
+
+/*
+==================
+CM_PointContents
+
+==================
+*/
+int CM_PointContents( const vec3_t p, clipHandle_t model ) {
+	int			leafnum;
+	int			i, k;
+	int			brushnum;
+	cLeaf_t		*leaf;
+	cbrush_t	*b;
+	int			contents;
+	float		d;
+	cmodel_t	*clipm;
+	clipMap_t	*local;
+
+	if (!cmg.numNodes) {	// map not loaded
+		return 0;
+	}
+
+	if ( model ) 
+	{
+		clipm = CM_ClipHandleToModel( model, &local );
+		if (clipm->firstNode != -1)
+		{
+			leafnum = CM_PointLeafnum_r (p, 0, local);
+			leaf = &local->leafs[leafnum];
+		}
+		else
+		{
+			leaf = &clipm->leaf;
+		}
+	} 
+	else 
+	{
+		local = &cmg;
+		leafnum = CM_PointLeafnum_r (p, 0, &cmg);
+		leaf = &local->leafs[leafnum];
+	}
+
+	contents = 0;
+	for (k=0 ; k<leaf->numLeafBrushes ; k++) {
+		brushnum = local->leafbrushes[leaf->firstLeafBrush+k];
+		b = &local->brushes[brushnum];
+
+		// see if the point is in the brush
+		for ( i = 0 ; i < b->numsides ; i++ ) {
+#ifdef _XBOX
+			d = DotProduct( p, cmg.planes[b->sides[i].planeNum.GetValue()].normal );
+#else
+			d = DotProduct( p, b->sides[i].plane->normal );
+#endif
+// FIXME test for Cash
+//			if ( d >= b->sides[i].plane->dist ) {
+#ifdef _XBOX
+			if ( d > cmg.planes[b->sides[i].planeNum.GetValue()].dist ) {
+#else
+			if ( d > b->sides[i].plane->dist ) {
+#endif
+				break;
+			}
+		}
+
+		if ( i == b->numsides ) 
+		{
+			contents |= b->contents;
+			if(cmg.landScape && (contents & CONTENTS_TERRAIN))
+			{
+				if(p[2] < cmg.landScape->GetWaterHeight())
+				{
+					contents |= cmg.landScape->GetWaterContents();
+				}
+			}
+		}
+	}
+
+	return contents;
+}
+
+/*
+==================
+CM_TransformedPointContents
+
+Handles offseting and rotation of the end points for moving and
+rotating entities
+==================
+*/
+int	CM_TransformedPointContents( const vec3_t p, clipHandle_t model, const vec3_t origin, const vec3_t angles) {
+	vec3_t		p_l;
+	vec3_t		temp;
+	vec3_t		forward, right, up;
+
+	// subtract origin offset
+	VectorSubtract (p, origin, p_l);
+
+	// rotate start and end into the models frame of reference
+	if ( model != BOX_MODEL_HANDLE && 
+	(angles[0] || angles[1] || angles[2]) )
+	{
+		AngleVectors (angles, forward, right, up);
+
+		VectorCopy (p_l, temp);
+		p_l[0] = DotProduct (temp, forward);
+		p_l[1] = -DotProduct (temp, right);
+		p_l[2] = DotProduct (temp, up);
+	}
+
+	return CM_PointContents( p_l, model );
+}
+
+
+
+/*
+===============================================================================
+
+PVS
+
+===============================================================================
+*/
+#ifdef _XBOX
+extern trGlobals_t tr;
+const byte	*CM_ClusterPVS (int cluster) {
+	if (cluster < 0 || cluster >= cmg.numClusters || !cmg.vised ) {
+		return NULL;
+	}
+
+	return cmg.visibility->Decompress(cluster * cmg.clusterBytes,
+			cmg.numClusters);
+}
+
+#else
+
+byte	*CM_ClusterPVS (int cluster) {
+	if (cluster < 0 || cluster >= cmg.numClusters || !cmg.vised ) {
+		return cmg.visibility;
+	}
+
+	return cmg.visibility + cluster * cmg.clusterBytes;
+}
+
+#endif // _XBOX
+
+
+
+/*
+===============================================================================
+
+AREAPORTALS
+
+===============================================================================
+*/
+#ifdef _XBOX
+void CM_FloodArea_r( int areaNum, int floodnum) {
+	int		i;
+	cArea_t *area;
+	int		*con;
+
+	area = &cmg.areas[ areaNum ];
+
+	if ( area->floodvalid == cmg.floodvalid ) {
+		if (area->floodnum == floodnum)
+			return;
+		Com_Error (ERR_DROP, "FloodArea_r: reflooded");
+	}
+
+	area->floodnum = floodnum;
+	area->floodvalid = cmg.floodvalid;
+	con = cmg.areaPortals + areaNum * cmg.numAreas;
+	for ( i=0 ; i < cmg.numAreas  ; i++ ) {
+		if ( con[i] > 0 ) {
+			CM_FloodArea_r( i, floodnum );
+		}
+	}
+}
+#else  // _XBOX
+
+void CM_FloodArea_r( int areaNum, int floodnum, clipMap_t &cm ) {
+	int		i;
+	cArea_t *area;
+	int		*con;
+
+	area = &cm.areas[ areaNum ];
+
+	if ( area->floodvalid == cm.floodvalid ) {
+		if (area->floodnum == floodnum)
+			return;
+		Com_Error (ERR_DROP, "FloodArea_r: reflooded");
+	}
+
+	area->floodnum = floodnum;
+	area->floodvalid = cm.floodvalid;
+	con = cm.areaPortals + areaNum * cm.numAreas;
+	for ( i=0 ; i < cm.numAreas  ; i++ ) {
+		if ( con[i] > 0 ) {
+			CM_FloodArea_r( i, floodnum, cm );
+		}
+	}
+}
+
+#endif // _XBOX
+
+/*
+====================
+CM_FloodAreaConnections
+
+====================
+*/
+#ifdef _XBOX
+void	CM_FloodAreaConnections( void ) {
+	int		i;
+	cArea_t	*area;
+	int		floodnum;
+
+	// all current floods are now invalid
+	cmg.floodvalid++;
+	floodnum = 0;
+
+	for (i = 0 ; i < cmg.numAreas ; i++) {
+		area = &cmg.areas[i];
+		if (area->floodvalid == cmg.floodvalid) {
+			continue;		// already flooded into
+		}
+		floodnum++;
+		CM_FloodArea_r (i, floodnum);
+	}
+
+}
+#else // _XBOX
+
+void	CM_FloodAreaConnections( clipMap_t &cm ) {
+	int		i;
+	cArea_t	*area;
+	int		floodnum;
+
+	// all current floods are now invalid
+	cm.floodvalid++;
+	floodnum = 0;
+
+	for (i = 0 ; i < cm.numAreas ; i++) {
+		area = &cm.areas[i];
+		if (area->floodvalid == cm.floodvalid) {
+			continue;		// already flooded into
+		}
+		floodnum++;
+		CM_FloodArea_r (i, floodnum, cm);
+	}
+
+}
+
+#endif // _XBOX
+
+/*
+====================
+CM_AdjustAreaPortalState
+
+====================
+*/
+void	CM_AdjustAreaPortalState( int area1, int area2, qboolean open ) {
+	if ( area1 < 0 || area2 < 0 ) {
+		return;
+	}
+
+	if ( area1 >= cmg.numAreas || area2 >= cmg.numAreas ) {
+		Com_Error (ERR_DROP, "CM_ChangeAreaPortalState: bad area number");
+	}
+
+	if ( open ) {
+		cmg.areaPortals[ area1 * cmg.numAreas + area2 ]++;
+		cmg.areaPortals[ area2 * cmg.numAreas + area1 ]++;
+	} else {
+		cmg.areaPortals[ area1 * cmg.numAreas + area2 ]--;
+		cmg.areaPortals[ area2 * cmg.numAreas + area1 ]--;
+		if ( cmg.areaPortals[ area2 * cmg.numAreas + area1 ] < 0 ) {
+			Com_Error (ERR_DROP, "CM_AdjustAreaPortalState: negative reference count");
+		}
+	}
+
+#ifdef _XBOX
+	CM_FloodAreaConnections ();
+#else
+	CM_FloodAreaConnections (cmg);
+#endif
+}
+
+/*
+====================
+CM_AreasConnected
+
+====================
+*/
+qboolean	CM_AreasConnected( int area1, int area2 ) {
+#ifndef BSPC
+	if ( cm_noAreas->integer ) {
+		return qtrue;
+	}
+#endif
+
+	if ( area1 < 0 || area2 < 0 ) {
+		return qfalse;
+	}
+
+	if (area1 >= cmg.numAreas || area2 >= cmg.numAreas) {
+		Com_Error (ERR_DROP, "area >= cmg.numAreas");
+	}
+
+	if (cmg.areas[area1].floodnum == cmg.areas[area2].floodnum) {
+		return qtrue;
+	}
+	return qfalse;
+}
+
+
+/*
+=================
+CM_WriteAreaBits
+
+Writes a bit vector of all the areas
+that are in the same flood as the area parameter
+Returns the number of bytes needed to hold all the bits.
+
+The bits are OR'd in, so you can CM_WriteAreaBits from multiple
+viewpoints and get the union of all visible areas.
+
+This is used to cull non-visible entities from snapshots
+=================
+*/
+int CM_WriteAreaBits (byte *buffer, int area)
+{
+	int		i;
+	int		floodnum;
+	int		bytes;
+
+	bytes = (cmg.numAreas+7)>>3;
+
+#ifndef BSPC
+	if (cm_noAreas->integer || area == -1)
+#else
+	if ( area == -1)
+#endif
+	{	// for debugging, send everything
+		Com_Memset (buffer, 255, bytes);
+	}
+	else
+	{
+		floodnum = cmg.areas[area].floodnum;
+		for (i=0 ; i<cmg.numAreas ; i++)
+		{
+			if (cmg.areas[i].floodnum == floodnum || area == -1)
+				buffer[i>>3] |= 1<<(i&7);
+		}
+	}
+
+	return bytes;
+}
+
diff --git a/codemp/qcommon/cm_trace.cpp b/codemp/qcommon/cm_trace.cpp
new file mode 100644
index 0000000..f0e28e2
--- /dev/null
+++ b/codemp/qcommon/cm_trace.cpp
@@ -0,0 +1,1992 @@
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+#include "cm_local.h"
+#include "cm_landscape.h"
+
+#ifdef _XBOX
+#include "../renderer/tr_local.h"
+#endif
+
+// always use bbox vs. bbox collision and never capsule vs. bbox or vice versa
+//#define ALWAYS_BBOX_VS_BBOX
+// always use capsule vs. capsule collision and never capsule vs. bbox or vice versa
+//#define ALWAYS_CAPSULE_VS_CAPSULE
+
+//#define CAPSULE_DEBUG
+
+void CM_TraceThroughTerrain( traceWork_t *tw, trace_t &trace, cbrush_t *brush );
+
+//#define TEST_TERRAIN_PHYSICS
+
+#ifdef TEST_TERRAIN_PHYSICS
+
+Be sure to un-link entity in		void SP_terrain(gentity_t *ent)			(yeah, left this uncommented to cause error / attention )
+
+
+	void CM_TraceThroughTerrain( traceWork_t *tw, trace_t &trace, CCMLandScape *landscape);
+#endif
+
+/*
+===============================================================================
+
+BASIC MATH
+
+===============================================================================
+*/
+
+/*
+================
+RotatePoint
+================
+*/
+void RotatePoint(vec3_t point, /*const*/ vec3_t matrix[3]) { // bk: FIXME 
+	vec3_t tvec;
+
+	VectorCopy(point, tvec);
+	point[0] = DotProduct(matrix[0], tvec);
+	point[1] = DotProduct(matrix[1], tvec);
+	point[2] = DotProduct(matrix[2], tvec);
+}
+
+/*
+================
+TransposeMatrix
+================
+*/
+void TransposeMatrix(/*const*/ vec3_t matrix[3], vec3_t transpose[3]) { // bk: FIXME
+	int i, j;
+	for (i = 0; i < 3; i++) {
+		for (j = 0; j < 3; j++) {
+			transpose[i][j] = matrix[j][i];
+		}
+	}
+}
+
+/*
+================
+CreateRotationMatrix
+================
+*/
+void CreateRotationMatrix(const vec3_t angles, vec3_t matrix[3]) {
+	AngleVectors(angles, matrix[0], matrix[1], matrix[2]);
+	VectorInverse(matrix[1]);
+}
+
+/*
+================
+CM_ProjectPointOntoVector
+================
+*/
+void CM_ProjectPointOntoVector( vec3_t point, vec3_t vStart, vec3_t vDir, vec3_t vProj )
+{
+	vec3_t pVec;
+
+	VectorSubtract( point, vStart, pVec );
+	// project onto the directional vector for this segment
+	VectorMA( vStart, DotProduct( pVec, vDir ), vDir, vProj );
+}
+
+/*
+================
+CM_DistanceFromLineSquared
+================
+*/
+float CM_DistanceFromLineSquared(vec3_t p, vec3_t lp1, vec3_t lp2, vec3_t dir) {
+	vec3_t proj, t;
+	int j;
+
+	CM_ProjectPointOntoVector(p, lp1, dir, proj);
+	for (j = 0; j < 3; j++) 
+		if ((proj[j] > lp1[j] && proj[j] > lp2[j]) ||
+			(proj[j] < lp1[j] && proj[j] < lp2[j]))
+			break;
+	if (j < 3) {
+		if (fabs(proj[j] - lp1[j]) < fabs(proj[j] - lp2[j]))
+			VectorSubtract(p, lp1, t);
+		else
+			VectorSubtract(p, lp2, t);
+		return VectorLengthSquared(t);
+	}
+	VectorSubtract(p, proj, t);
+	return VectorLengthSquared(t);
+}
+
+/*
+================
+CM_VectorDistanceSquared
+================
+*/
+float CM_VectorDistanceSquared(vec3_t p1, vec3_t p2) {
+	vec3_t dir;
+
+	VectorSubtract(p2, p1, dir);
+	return VectorLengthSquared(dir);
+}
+
+/*
+================
+SquareRootFloat
+================
+*/
+float SquareRootFloat(float number) {
+	long i;
+	float x, y;
+	const float f = 1.5F;
+
+	x = number * 0.5F;
+	y  = number;
+	i  = * ( long * ) &y;
+	i  = 0x5f3759df - ( i >> 1 );
+	y  = * ( float * ) &i;
+	y  = y * ( f - ( x * y * y ) );
+	y  = y * ( f - ( x * y * y ) );
+	return number * y;
+}
+
+
+/*
+===============================================================================
+
+POSITION TESTING
+
+===============================================================================
+*/
+
+/*
+================
+CM_TestBoxInBrush
+================
+*/
+void CM_TestBoxInBrush( traceWork_t *tw, trace_t &trace, cbrush_t *brush ) {
+	int			i;
+	cplane_t	*plane;
+	float		dist;
+	float		d1;
+	cbrushside_t	*side;
+	float		t;
+	vec3_t		startp;
+
+	if (!brush->numsides) {
+		return;
+	}
+
+	// special test for axial
+	if ( tw->bounds[0][0] > brush->bounds[1][0]
+		|| tw->bounds[0][1] > brush->bounds[1][1]
+		|| tw->bounds[0][2] > brush->bounds[1][2]
+		|| tw->bounds[1][0] < brush->bounds[0][0]
+		|| tw->bounds[1][1] < brush->bounds[0][1]
+		|| tw->bounds[1][2] < brush->bounds[0][2]
+		) {
+		return;
+	}
+
+   if ( tw->sphere.use ) {
+		// the first six planes are the axial planes, so we only
+		// need to test the remainder
+		for ( i = 6 ; i < brush->numsides ; i++ ) {
+			side = brush->sides + i;
+
+#ifdef _XBOX
+			plane = &cmg.planes[side->planeNum.GetValue()];
+#else
+			plane = side->plane;
+#endif
+
+			// adjust the plane distance apropriately for radius
+			dist = plane->dist + tw->sphere.radius;
+			// find the closest point on the capsule to the plane
+			t = DotProduct( plane->normal, tw->sphere.offset );
+			if ( t > 0 )
+			{
+				VectorSubtract( tw->start, tw->sphere.offset, startp );
+			}
+			else
+			{
+				VectorAdd( tw->start, tw->sphere.offset, startp );
+			}
+			d1 = DotProduct( startp, plane->normal ) - dist;
+			// if completely in front of face, no intersection
+			if ( d1 > 0 ) {
+				return;
+			}
+		}
+	} else {
+		// the first six planes are the axial planes, so we only
+		// need to test the remainder
+		for ( i = 6 ; i < brush->numsides ; i++ ) {
+			side = brush->sides + i;
+
+#ifdef _XBOX
+			plane = &cmg.planes[side->planeNum.GetValue()];
+#else
+			plane = side->plane;
+#endif
+
+			// adjust the plane distance apropriately for mins/maxs
+			dist = plane->dist - DotProduct( tw->offsets[ plane->signbits ], plane->normal );
+
+			d1 = DotProduct( tw->start, plane->normal ) - dist;
+
+			// if completely in front of face, no intersection
+			if ( d1 > 0 ) {
+				return;
+			}
+		}
+	}
+
+	// inside this brush
+	trace.startsolid = trace.allsolid = qtrue;
+	trace.fraction = 0;
+	trace.contents = brush->contents;
+}
+
+
+#ifdef _XBOX
+static int CM_GetSurfaceIndex(int firstLeafSurface)
+{
+	if(firstLeafSurface > tr.world->nummarksurfaces || firstLeafSurface < 0) {
+		return cmg.leafsurfaces[ firstLeafSurface ] ;
+	} else {
+		return tr.world->marksurfaces[firstLeafSurface] - tr.world->surfaces;
+	}
+}
+#endif
+
+/*
+================
+CM_TestInLeaf
+================
+*/
+void CM_TestInLeaf( traceWork_t *tw, trace_t &trace, cLeaf_t *leaf, clipMap_t *local ) 
+{
+	int			k;
+	int			brushnum;
+	cbrush_t	*b;
+	cPatch_t	*patch;
+
+	// test box position against all brushes in the leaf
+	for (k=0 ; k<leaf->numLeafBrushes ; k++) {
+		brushnum = local->leafbrushes[leaf->firstLeafBrush+k];
+		b = &local->brushes[brushnum];
+		if (b->checkcount == local->checkcount) {
+			continue;	// already checked this brush in another leaf
+		}
+		b->checkcount = local->checkcount;
+
+		if ( !(b->contents & tw->contents)) {
+			continue;
+		}
+		
+#ifndef BSPC
+		if (com_terrainPhysics->integer && cmg.landScape && (b->contents & CONTENTS_TERRAIN) )
+		{
+			// Invalidate the checkcount for terrain as the terrain brush has to be processed
+			// many times.
+			b->checkcount--;
+
+			CM_TraceThroughTerrain( tw, trace, b );
+			// If inside a terrain brush don't bother with regular brush collision
+			continue;
+		}
+#endif
+		CM_TestBoxInBrush( tw, trace, b );
+		if ( trace.allsolid ) {
+			return;
+		}
+	}
+
+	// test against all patches
+#ifdef BSPC
+	if (1) {
+#else
+	if ( !cm_noCurves->integer ) {
+#endif //BSPC
+		for ( k = 0 ; k < leaf->numLeafSurfaces ; k++ ) {
+//#ifdef _XBOX
+//			int index = CM_GetSurfaceIndex(leaf->firstLeafSurface + k);
+//			patch = local->surfaces[ index ];
+//#else
+			patch = local->surfaces[ local->leafsurfaces[ leaf->firstLeafSurface + k ] ];
+//#endif
+			if ( !patch ) {
+				continue;
+			}
+			if ( patch->checkcount == local->checkcount ) {
+				continue;	// already checked this brush in another leaf
+			}
+			patch->checkcount = local->checkcount;
+
+			if ( !(patch->contents & tw->contents)) {
+				continue;
+			}
+			
+			if ( CM_PositionTestInPatchCollide( tw, patch->pc ) ) {
+				trace.startsolid = trace.allsolid = qtrue;
+				trace.fraction = 0;
+				trace.contents = patch->contents;
+				return;
+			}
+		}
+	}
+}
+
+/*
+==================
+CM_TestCapsuleInCapsule
+
+capsule inside capsule check
+==================
+*/
+void CM_TestCapsuleInCapsule( traceWork_t *tw, trace_t &trace, clipHandle_t model ) {
+	int i;
+	vec3_t mins, maxs;
+	vec3_t top, bottom;
+	vec3_t p1, p2, tmp;
+	vec3_t offset, symetricSize[2];
+	float radius, halfwidth, halfheight, offs, r;
+
+	CM_ModelBounds(model, mins, maxs);
+
+	VectorAdd(tw->start, tw->sphere.offset, top);
+	VectorSubtract(tw->start, tw->sphere.offset, bottom);
+	for ( i = 0 ; i < 3 ; i++ ) {
+		offset[i] = ( mins[i] + maxs[i] ) * 0.5;
+		symetricSize[0][i] = mins[i] - offset[i];
+		symetricSize[1][i] = maxs[i] - offset[i];
+	}
+	halfwidth = symetricSize[ 1 ][ 0 ];
+	halfheight = symetricSize[ 1 ][ 2 ];
+	radius = ( halfwidth > halfheight ) ? halfheight : halfwidth;
+	offs = halfheight - radius;
+
+	r = Square(tw->sphere.radius + radius);
+	// check if any of the spheres overlap
+	VectorCopy(offset, p1);
+	p1[2] += offs;
+	VectorSubtract(p1, top, tmp);
+	if ( VectorLengthSquared(tmp) < r ) {
+		trace.startsolid = trace.allsolid = qtrue;
+		trace.fraction = 0;
+	}
+	VectorSubtract(p1, bottom, tmp);
+	if ( VectorLengthSquared(tmp) < r ) {
+		trace.startsolid = trace.allsolid = qtrue;
+		trace.fraction = 0;
+	}
+	VectorCopy(offset, p2);
+	p2[2] -= offs;
+	VectorSubtract(p2, top, tmp);
+	if ( VectorLengthSquared(tmp) < r ) {
+		trace.startsolid = trace.allsolid = qtrue;
+		trace.fraction = 0;
+	}
+	VectorSubtract(p2, bottom, tmp);
+	if ( VectorLengthSquared(tmp) < r ) {
+		trace.startsolid = trace.allsolid = qtrue;
+		trace.fraction = 0;
+	}
+	// if between cylinder up and lower bounds
+	if ( (top[2] >= p1[2] && top[2] <= p2[2]) ||
+		(bottom[2] >= p1[2] && bottom[2] <= p2[2]) ) {
+		// 2d coordinates
+		top[2] = p1[2] = 0;
+		// if the cylinders overlap
+		VectorSubtract(top, p1, tmp);
+		if ( VectorLengthSquared(tmp) < r ) {
+			trace.startsolid = trace.allsolid = qtrue;
+			trace.fraction = 0;
+		}
+	}
+}
+
+/*
+==================
+CM_TestBoundingBoxInCapsule
+
+bounding box inside capsule check
+==================
+*/
+void CM_TestBoundingBoxInCapsule( traceWork_t *tw, trace_t &trace, clipHandle_t model ) {
+	vec3_t mins, maxs, offset, size[2];
+	clipHandle_t h;
+	cmodel_t *cmod;
+	int i;
+
+	// mins maxs of the capsule
+	CM_ModelBounds(model, mins, maxs);
+
+	// offset for capsule center
+	for ( i = 0 ; i < 3 ; i++ ) {
+		offset[i] = ( mins[i] + maxs[i] ) * 0.5;
+		size[0][i] = mins[i] - offset[i];
+		size[1][i] = maxs[i] - offset[i];
+		tw->start[i] -= offset[i];
+		tw->end[i] -= offset[i];
+	}
+
+	// replace the bounding box with the capsule
+	tw->sphere.use = qtrue;
+	tw->sphere.radius = ( size[1][0] > size[1][2] ) ? size[1][2]: size[1][0];
+	tw->sphere.halfheight = size[1][2];
+	VectorSet( tw->sphere.offset, 0, 0, size[1][2] - tw->sphere.radius );
+
+	// replace the capsule with the bounding box
+	h = CM_TempBoxModel(tw->size[0], tw->size[1], qfalse);
+	// calculate collision
+	cmod = CM_ClipHandleToModel( h );
+	CM_TestInLeaf( tw, trace, &cmod->leaf, &cmg );
+}
+
+/*
+==================
+CM_PositionTest
+==================
+*/
+#define	MAX_POSITION_LEAFS	1024
+void CM_PositionTest( traceWork_t *tw, trace_t &trace ) {
+	int		leafs[MAX_POSITION_LEAFS];
+	int		i;
+	leafList_t	ll;
+
+	// identify the leafs we are touching
+	VectorAdd( tw->start, tw->size[0], ll.bounds[0] );
+	VectorAdd( tw->start, tw->size[1], ll.bounds[1] );
+
+	for (i=0 ; i<3 ; i++) {
+		ll.bounds[0][i] -= 1;
+		ll.bounds[1][i] += 1;
+	}
+
+	ll.count = 0;
+	ll.maxcount = MAX_POSITION_LEAFS;
+	ll.list = leafs;
+	ll.storeLeafs = CM_StoreLeafs;
+	ll.lastLeaf = 0;
+	ll.overflowed = qfalse;
+
+	cmg.checkcount++;
+
+	CM_BoxLeafnums_r( &ll, 0 );
+
+
+	cmg.checkcount++;
+
+	// test the contents of the leafs
+	for (i=0 ; i < ll.count ; i++) {
+		CM_TestInLeaf( tw, trace, &cmg.leafs[leafs[i]], &cmg );
+		if ( trace.allsolid ) {
+			break;
+		}
+	}
+}
+
+/*
+===============================================================================
+
+TRACING
+
+===============================================================================
+*/
+
+
+/*
+================
+CM_TraceThroughPatch
+================
+*/
+
+void CM_TraceThroughPatch( traceWork_t *tw, trace_t &trace, cPatch_t *patch ) {
+	float		oldFrac;
+
+	c_patch_traces++;
+
+	oldFrac = trace.fraction;
+
+	CM_TraceThroughPatchCollide( tw, trace, patch->pc );
+
+	if ( trace.fraction < oldFrac ) {
+		trace.surfaceFlags = patch->surfaceFlags;
+		trace.contents = patch->contents;
+	}
+}
+
+/*
+================
+CM_PlaneCollision
+
+  Returns false for a quick getout
+================
+*/
+
+bool CM_PlaneCollision(traceWork_t *tw, cbrushside_t *side)
+{
+	float			dist, f;
+	float			d1, d2;
+
+#ifdef _XBOX
+	cplane_t		*plane = &cmg.planes[side->planeNum.GetValue()];
+#else
+	cplane_t		*plane = side->plane;
+#endif
+
+	// adjust the plane distance apropriately for mins/maxs
+	dist = plane->dist - DotProduct( tw->offsets[ plane->signbits ], plane->normal );
+
+	d1 = DotProduct( tw->start, plane->normal ) - dist;
+	d2 = DotProduct( tw->end, plane->normal ) - dist;
+
+	if (d2 > 0.0f) 
+	{
+		// endpoint is not in solid
+		tw->getout = true;	
+	}
+	if (d1 > 0.0f) 
+	{
+		// startpoint is not in solid
+		tw->startout = true;
+	}
+
+	// if completely in front of face, no intersection with the entire brush
+	if ((d1 > 0.0f) && ( (d2 >= SURFACE_CLIP_EPSILON) || (d2 >= d1) ) ) 
+	{
+		return(false);
+	}
+
+	// if it doesn't cross the plane, the plane isn't relevent
+	if ((d1 <= 0.0f) && (d2 <= 0.0f)) 
+	{
+		return(true);
+	}
+	// crosses face
+	if (d1 > d2) 
+	{	// enter
+		f = (d1 - SURFACE_CLIP_EPSILON);
+		if ( f < 0.0f ) 
+		{
+			f = 0.0f;
+			if (f > tw->enterFrac) 
+			{
+				tw->enterFrac = f;
+				tw->clipplane = plane;
+				tw->leadside = side;
+			}
+		}
+		else if (f > tw->enterFrac * (d1 - d2) ) 
+		{
+			tw->enterFrac = f / (d1 - d2);
+			tw->clipplane = plane;
+			tw->leadside = side;
+		}
+	}
+	else
+	{	// leave
+		f = (d1 + SURFACE_CLIP_EPSILON);
+		if ( f < (d1 - d2) ) 
+		{
+			f = 1.0f;
+			if (f < tw->leaveFrac) 
+			{
+				tw->leaveFrac = f;
+			}
+		}
+		else if (f > tw->leaveFrac * (d1 - d2) ) 
+		{
+			tw->leaveFrac = f / (d1 - d2);
+		}
+	}
+	return(true);
+}
+
+/*
+================
+CM_TraceThroughBrush
+================
+*/
+void CM_TraceThroughBrush( traceWork_t *tw, trace_t &trace, cbrush_t *brush, bool infoOnly ) 
+{
+	int				i;
+	cbrushside_t	*side;
+
+	tw->enterFrac = -1.0f;
+	tw->leaveFrac = 1.0f;
+	tw->clipplane = NULL;
+
+	if ( !brush->numsides ) 
+	{
+		return;
+	}
+
+	// I'm not sure if test is strictly correct.  Are all
+	// bboxes axis aligned?  Do I care?  It seems to work
+	// good enough...
+	if ( tw->bounds[0][0] > brush->bounds[1][0]
+		|| tw->bounds[0][1] > brush->bounds[1][1]
+		|| tw->bounds[0][2] > brush->bounds[1][2]
+		|| tw->bounds[1][0] < brush->bounds[0][0]
+		|| tw->bounds[1][1] < brush->bounds[0][1]
+		|| tw->bounds[1][2] < brush->bounds[0][2]
+		) {
+		return;
+	}
+
+	tw->getout = false;
+	tw->startout = false;						   
+	tw->leadside = NULL;
+
+	//
+	// compare the trace against all planes of the brush
+	// find the latest time the trace crosses a plane towards the interior
+	// and the earliest time the trace crosses a plane towards the exterior
+	//
+	for (i = 0; i < brush->numsides; i++) 
+	{
+		side = brush->sides + i;
+
+		if(!CM_PlaneCollision(tw, side))
+		{
+			return;
+		}
+	}
+
+	//
+	// all planes have been checked, and the trace was not
+	// completely outside the brush
+	//
+	if (!tw->startout) 
+	{	
+		if(!infoOnly)
+		{
+			// original point was inside brush
+			trace.startsolid = qtrue;
+			if (!tw->getout) 
+			{
+				trace.allsolid = qtrue;
+				trace.fraction = 0.0f;
+			}
+		}
+		tw->enterFrac = 0.0f;
+		return;
+	}
+	
+	if (tw->enterFrac < tw->leaveFrac) 
+	{
+		if ((tw->enterFrac > -1.0f) && (tw->enterFrac < trace.fraction)) 
+		{
+			if (tw->enterFrac < 0.0f) 
+			{
+				tw->enterFrac = 0.0f;
+			}
+			if(!infoOnly)
+			{
+				trace.fraction = tw->enterFrac;
+				trace.plane = *tw->clipplane;
+				trace.surfaceFlags = cmg.shaders[tw->leadside->shaderNum].surfaceFlags;
+				trace.contents = brush->contents;
+			}
+		}
+	}
+}
+
+/*
+================
+CM_TraceThroughTerrain
+
+  During this routine the fraction is internal to the brush
+  and converted to a global fraction on exit.
+================
+*/
+
+#ifndef BSPC
+
+void CM_TraceThroughTerrain( traceWork_t *tw, trace_t &trace, cbrush_t *brush )
+{
+	CCMLandScape		*landscape;
+	vec3_t				tBegin, tEnd, tDistance, tStep;
+	vec3_t				baseStart;
+	vec3_t				baseEnd;
+	int					count;
+	int					i;
+	float				fraction;
+
+	// At this point we know we may be colliding with a terrain brush (and we know we have a valid terrain structure)
+	landscape = (CCMLandScape *)cmg.landScape;
+
+	// Check for absolutely no connection
+	if(!CM_GenericBoxCollide(tw->bounds, landscape->GetBounds()))
+	{
+		return;
+	}
+	// Now we know that at least some part of the trace needs to collide with the terrain
+	// The regular brush collision is handled elsewhere, so advance the ray to an edge in the terrain brush
+	CM_TraceThroughBrush( tw, trace, brush, true );
+	
+	// Remember the base entering and leaving fractions
+	tw->baseEnterFrac = tw->enterFrac;
+	tw->baseLeaveFrac = tw->leaveFrac;
+	// Reset to full spread within the brush
+	tw->enterFrac = -1.0f;
+	tw->leaveFrac = 1.0f;
+
+	// Work out the corners of the AABB when the trace first hits the terrain brush and when it leaves
+	VectorAdvance(tw->start, tw->baseEnterFrac, tw->end, tBegin);
+	VectorAdvance(tw->start, tw->baseLeaveFrac, tw->end, tEnd);
+	VectorSubtract(tEnd, tBegin, tDistance);
+
+	// Calculate number of iterations to process
+	count = ceilf(VectorLength(tDistance) / (landscape->GetPatchScalarSize() * TERRAIN_STEP_MAGIC));
+	count = 1;
+	fraction = trace.fraction;
+	VectorScale(tDistance, 1.0f / count, tStep);
+
+	// Save the base start and end vectors
+	VectorCopy ( tw->start, baseStart );
+	VectorCopy ( tw->end, baseEnd );
+
+	// Use the terrain vectors.  Start both at the beginning since the
+	// step will be added to the end as the first step of the loop
+	VectorCopy ( tBegin, tw->start );
+	VectorCopy ( tBegin, tw->end );
+
+	// Step thru terrain patches moving on about 1 patch at a time
+	for ( i = 0; i < count; i ++ )
+	{
+		// Add the step to the end
+		VectorAdd(tw->end, tStep, tw->end);
+
+		CM_CalcExtents(tBegin, tw->end, tw, tw->localBounds);
+
+		landscape->PatchCollide(tw, trace, tw->start, tw->end, brush->checkcount);
+	
+		// If collision with something closer than water then just stop here
+		if ( trace.fraction < fraction )
+		{
+			// Convert the fraction of this sub tract into the full trace's fraction
+			trace.fraction = i * (1.0f / count) + (1.0f / count) * trace.fraction;
+			break;
+		}
+
+		// Move the end to the start so the next trace starts
+		// where this one left off
+		VectorCopy(tw->end, tw->start);
+	}
+
+	// Put the original start and end back
+	VectorCopy ( baseStart, tw->start );
+	VectorCopy ( baseEnd, tw->end );
+
+	// Convert to global fraction only if something was hit along the way
+	if ( trace.fraction != 1.0 )
+	{
+		trace.fraction = tw->baseEnterFrac + ((tw->baseLeaveFrac - tw->baseEnterFrac) * trace.fraction);
+		trace.contents = brush->contents;
+	}
+
+	// Collide with any water
+	if ( tw->contents & CONTENTS_WATER )
+	{
+		fraction = landscape->WaterCollide(tw->start, tw->end, trace.fraction);
+		if( fraction < trace.fraction )
+		{
+			VectorSet(trace.plane.normal, 0.0f, 0.0f, 1.0f);
+			trace.contents = landscape->GetWaterContents();
+			trace.fraction = fraction;
+			trace.surfaceFlags = landscape->GetWaterSurfaceFlags();
+		}
+	}
+}
+
+#ifdef TEST_TERRAIN_PHYSICS
+
+void CM_TraceThroughTerrain( traceWork_t *tw, trace_t &trace, CCMLandScape *landscape)
+{
+	vec3_t				tBegin, tEnd, tDistance, tStep;
+	vec3_t				baseStart;
+	vec3_t				baseEnd;
+	int					count;
+	int					i;
+	float				fraction;
+
+	// Check for absolutely no connection
+	if(!CM_GenericBoxCollide(tw->bounds, landscape->GetBounds()))
+	{
+		return;
+	}
+	
+	tw->enterFrac = 0.0f;
+	tw->leaveFrac = 1.0f;
+	tw->clipplane = NULL;
+	tw->getout = false;
+	tw->startout = false;						   
+	tw->leadside = NULL;
+
+	// Remember the base entering and leaving fractions
+	tw->baseEnterFrac = tw->enterFrac;
+	tw->baseLeaveFrac = tw->leaveFrac;
+	// Reset to full spread within the brush
+	tw->enterFrac = -1.0f;
+	tw->leaveFrac = 1.0f;
+
+	// Work out the corners of the AABB when the trace first hits the terrain brush and when it leaves
+	VectorAdvance(tw->start, tw->baseEnterFrac, tw->end, tBegin);
+	VectorAdvance(tw->start, tw->baseLeaveFrac, tw->end, tEnd);
+	VectorSubtract(tEnd, tBegin, tDistance);
+
+	// Calculate number of iterations to process
+	count = ceilf(VectorLength(tDistance) / (landscape->GetPatchScalarSize() * TERRAIN_STEP_MAGIC));
+	count = 1;
+	fraction = trace.fraction;
+	VectorScale(tDistance, 1.0f / count, tStep);
+
+	// Save the base start and end vectors
+	VectorCopy ( tw->start, baseStart );
+	VectorCopy ( tw->end, baseEnd );
+
+	// Use the terrain vectors.  Start both at the beginning since the
+	// step will be added to the end as the first step of the loop
+	VectorCopy ( tBegin, tw->start );
+	VectorCopy ( tBegin, tw->end );
+
+	// Step thru terrain patches moving on about 1 patch at a time
+	for ( i = 0; i < count; i ++ )
+	{
+		// Add the step to the end
+		VectorAdd(tw->end, tStep, tw->end);
+
+		CM_CalcExtents(tBegin, tw->end, tw, tw->localBounds);
+
+		landscape->PatchCollide(tw, trace, tw->start, tw->end, cmg.checkcount);
+	
+		// If collision with something closer than water then just stop here
+		if ( trace.fraction < fraction )
+		{
+			// Convert the fraction of this sub tract into the full trace's fraction
+			trace.fraction = i * (1.0f / count) + (1.0f / count) * trace.fraction;
+			break;
+		}
+
+		// Move the end to the start so the next trace starts
+		// where this one left off
+		VectorCopy(tw->end, tw->start);
+	}
+
+	// Put the original start and end back
+	VectorCopy ( baseStart, tw->start );
+	VectorCopy ( baseEnd, tw->end );
+
+	// Convert to global fraction only if something was hit along the way
+	if ( trace.fraction != 1.0 )
+	{
+//		trace.fraction = tw->baseEnterFrac + ((tw->baseLeaveFrac - tw->baseEnterFrac) * trace.fraction);
+		trace.contents = CONTENTS_TERRAIN | CONTENTS_OUTSIDE;
+	}
+
+	// Collide with any water
+	if ( tw->contents & CONTENTS_WATER )
+	{
+		fraction = landscape->WaterCollide(tw->start, tw->end, trace.fraction);
+		if( fraction < trace.fraction )
+		{
+			VectorSet(trace.plane.normal, 0.0f, 0.0f, 1.0f);
+			trace.contents = landscape->GetWaterContents();
+			trace.fraction = fraction;
+			trace.surfaceFlags = landscape->GetWaterSurfaceFlags();
+		}
+	}
+}
+
+#endif // #ifdef TEST_TERRAIN_PHYSICS
+
+#endif
+
+/*
+================
+CM_PatchCollide
+
+  By the time we get here we know the AABB is within the patch AABB ie there is a chance of collision
+  The collision data is made up of bounds, 2 triangle planes
+  There is an BB check for the terxel check to see if it is worth checking the planes.
+  Collide with both triangles to find the shortest fraction
+================
+*/
+
+void CM_HandlePatchCollision(struct traceWork_s *tw, trace_t &trace, const vec3_t tStart, const vec3_t tEnd, CCMPatch *patch, int checkcount)
+{
+	int				numBrushes, i;
+	cbrush_t		*brush;
+
+	// Get the collision data
+	brush = patch->GetCollisionData();
+	numBrushes = patch->GetNumBrushes();
+
+	for(i = 0; i < numBrushes; i++, brush++)
+	{
+		if(brush->checkcount == checkcount)
+		{
+			return;
+		}
+
+		// Generic collision of terxel bounds to line segment bounds
+		if(!CM_GenericBoxCollide(brush->bounds, tw->localBounds))
+		{
+			continue;
+		}
+
+		brush->checkcount = checkcount;
+
+		CM_TraceThroughBrush(tw, trace, brush, false );
+		if (trace.fraction <= 0.0)
+		{
+			break;
+		}
+	}
+}
+
+/*
+================
+CM_GenericBoxCollide
+================
+*/
+
+bool CM_GenericBoxCollide(const vec3pair_t abounds, const vec3pair_t bbounds)
+{
+	int		i;
+
+	// Check for completely no intersection
+	for(i = 0; i < 3; i++)
+	{
+		if(abounds[1][i] < bbounds[0][i])
+		{
+			return(false);
+		}
+		if(abounds[0][i] > bbounds[1][i])
+		{
+			return(false);
+		}
+	}
+	return(true);
+}
+
+/*
+================
+CM_TraceThroughLeaf
+================
+*/
+void CM_TraceThroughLeaf( traceWork_t *tw, trace_t &trace, clipMap_t *local, cLeaf_t *leaf ) {
+	int			k;
+	int			brushnum;
+	cbrush_t	*b;
+	cPatch_t	*patch;
+
+	// trace line against all brushes in the leaf
+	for ( k = 0 ; k < leaf->numLeafBrushes ; k++ ) {
+		brushnum = local->leafbrushes[leaf->firstLeafBrush+k];
+
+		b = &local->brushes[brushnum];
+		if ( b->checkcount == local->checkcount ) {
+			continue;	// already checked this brush in another leaf
+		}
+		b->checkcount = local->checkcount;
+
+		if ( !(b->contents & tw->contents) ) {
+			continue;
+		}
+
+#ifndef BSPC
+		if (com_terrainPhysics->integer && cmg.landScape && (b->contents & CONTENTS_TERRAIN) )
+		{
+			// Invalidate the checkcount for terrain as the terrain brush has to be processed
+			// many times.
+			b->checkcount--;
+
+			CM_TraceThroughTerrain( tw, trace, b );
+		}
+		else
+#endif
+		{
+			CM_TraceThroughBrush( tw, trace, b, false );
+		}
+
+		if ( !trace.fraction ) {
+			return;
+		}
+	}
+
+	// trace line against all patches in the leaf
+#ifdef BSPC
+	if (1) {
+#else
+	if ( !cm_noCurves->integer ) {
+#endif
+		for ( k = 0 ; k < leaf->numLeafSurfaces ; k++ ) {
+//#ifdef _XBOX
+//			int index = CM_GetSurfaceIndex(leaf->firstLeafSurface + k);
+//			patch = local->surfaces[ index ];
+//#else
+			patch = local->surfaces[ local->leafsurfaces[ leaf->firstLeafSurface + k ] ];
+//#endif
+			if ( !patch ) {
+				continue;
+			}
+			if ( patch->checkcount == local->checkcount ) {
+				continue;	// already checked this patch in another leaf
+			}
+			patch->checkcount = local->checkcount;
+
+			if ( !(patch->contents & tw->contents) ) {
+				continue;
+			}
+			
+			CM_TraceThroughPatch( tw, trace, patch );
+			if ( !trace.fraction ) {
+				return;
+			}
+		}
+	}
+}
+
+#define RADIUS_EPSILON		1.0f
+
+/*
+================
+CM_TraceThroughSphere
+
+get the first intersection of the ray with the sphere
+================
+*/
+void CM_TraceThroughSphere( traceWork_t *tw, trace_t &trace, vec3_t origin, float radius, vec3_t start, vec3_t end ) {
+	float l1, l2, length, scale, fraction;
+	float a, b, c, d, sqrtd;
+	vec3_t v1, dir, intersection;
+
+	// if inside the sphere
+	VectorSubtract(start, origin, dir);
+	l1 = VectorLengthSquared(dir);
+	if (l1 < Square(radius)) {
+		trace.fraction = 0;
+		trace.startsolid = qtrue;
+		// test for allsolid
+		VectorSubtract(end, origin, dir);
+		l1 = VectorLengthSquared(dir);
+		if (l1 < Square(radius)) {
+			trace.allsolid = qtrue;
+		}
+		return;
+	}
+	//
+	VectorSubtract(end, start, dir);
+	length = VectorNormalize(dir);
+	//
+	l1 = CM_DistanceFromLineSquared(origin, start, end, dir);
+	VectorSubtract(end, origin, v1);
+	l2 = VectorLengthSquared(v1);
+	// if no intersection with the sphere and the end point is at least an epsilon away
+	if (l1 >= Square(radius) && l2 > Square(radius+SURFACE_CLIP_EPSILON)) {
+		return;
+	}
+	//
+	//	| origin - (start + t * dir) | = radius
+	//	a = dir[0]^2 + dir[1]^2 + dir[2]^2;
+	//	b = 2 * (dir[0] * (start[0] - origin[0]) + dir[1] * (start[1] - origin[1]) + dir[2] * (start[2] - origin[2]));
+	//	c = (start[0] - origin[0])^2 + (start[1] - origin[1])^2 + (start[2] - origin[2])^2 - radius^2;
+	//
+	VectorSubtract(start, origin, v1);
+	// dir is normalized so a = 1
+	a = 1.0f;//dir[0] * dir[0] + dir[1] * dir[1] + dir[2] * dir[2];
+	b = 2.0f * (dir[0] * v1[0] + dir[1] * v1[1] + dir[2] * v1[2]);
+	c = v1[0] * v1[0] + v1[1] * v1[1] + v1[2] * v1[2] - (radius+RADIUS_EPSILON) * (radius+RADIUS_EPSILON);
+
+	d = b * b - 4.0f * c;// * a;
+	if (d > 0) {
+		sqrtd = SquareRootFloat(d);
+		// = (- b + sqrtd) * 0.5f; // / (2.0f * a);
+		fraction = (- b - sqrtd) * 0.5f; // / (2.0f * a);
+		//
+		if (fraction < 0) {
+			fraction = 0;
+		}
+		else {
+			fraction /= length;
+		}
+		if ( fraction < trace.fraction ) {
+			trace.fraction = fraction;
+			VectorSubtract(end, start, dir);
+			VectorMA(start, fraction, dir, intersection);
+			VectorSubtract(intersection, origin, dir);
+			#ifdef CAPSULE_DEBUG
+				l2 = VectorLength(dir);
+				if (l2 < radius) {
+					int bah = 1;
+				}
+			#endif
+			scale = 1 / (radius+RADIUS_EPSILON);
+			VectorScale(dir, scale, dir);
+			VectorCopy(dir, trace.plane.normal);
+			VectorAdd( tw->modelOrigin, intersection, intersection);
+			trace.plane.dist = DotProduct(trace.plane.normal, intersection);
+			trace.contents = CONTENTS_BODY;
+		}
+	}
+	else if (d == 0) {
+		//t1 = (- b ) / 2;
+		// slide along the sphere
+	}
+	// no intersection at all
+}
+
+/*
+================
+CM_TraceThroughVerticalCylinder
+
+get the first intersection of the ray with the cylinder
+the cylinder extends halfheight above and below the origin
+================
+*/
+void CM_TraceThroughVerticalCylinder( traceWork_t *tw, trace_t &trace, vec3_t origin, float radius, float halfheight, vec3_t start, vec3_t end) {
+	float length, scale, fraction, l1, l2;
+	float a, b, c, d, sqrtd;
+	vec3_t v1, dir, start2d, end2d, org2d, intersection;
+
+	// 2d coordinates
+	VectorSet(start2d, start[0], start[1], 0);
+	VectorSet(end2d, end[0], end[1], 0);
+	VectorSet(org2d, origin[0], origin[1], 0);
+	// if between lower and upper cylinder bounds
+	if (start[2] <= origin[2] + halfheight &&
+				start[2] >= origin[2] - halfheight) {
+		// if inside the cylinder
+		VectorSubtract(start2d, org2d, dir);
+		l1 = VectorLengthSquared(dir);
+		if (l1 < Square(radius)) {
+			trace.fraction = 0;
+			trace.startsolid = qtrue;
+			VectorSubtract(end2d, org2d, dir);
+			l1 = VectorLengthSquared(dir);
+			if (l1 < Square(radius)) {
+				trace.allsolid = qtrue;
+			}
+			return;
+		}
+	}
+	//
+	VectorSubtract(end2d, start2d, dir);
+	length = VectorNormalize(dir);
+	//
+	l1 = CM_DistanceFromLineSquared(org2d, start2d, end2d, dir);
+	VectorSubtract(end2d, org2d, v1);
+	l2 = VectorLengthSquared(v1);
+	// if no intersection with the cylinder and the end point is at least an epsilon away
+	if (l1 >= Square(radius) && l2 > Square(radius+SURFACE_CLIP_EPSILON)) {
+		return;
+	}
+	//
+	//
+	// (start[0] - origin[0] - t * dir[0]) ^ 2 + (start[1] - origin[1] - t * dir[1]) ^ 2 = radius ^ 2
+	// (v1[0] + t * dir[0]) ^ 2 + (v1[1] + t * dir[1]) ^ 2 = radius ^ 2;
+	// v1[0] ^ 2 + 2 * v1[0] * t * dir[0] + (t * dir[0]) ^ 2 +
+	//						v1[1] ^ 2 + 2 * v1[1] * t * dir[1] + (t * dir[1]) ^ 2 = radius ^ 2
+	// t ^ 2 * (dir[0] ^ 2 + dir[1] ^ 2) + t * (2 * v1[0] * dir[0] + 2 * v1[1] * dir[1]) +
+	//						v1[0] ^ 2 + v1[1] ^ 2 - radius ^ 2 = 0
+	//
+	VectorSubtract(start, origin, v1);
+	// dir is normalized so we can use a = 1
+	a = 1.0f;// * (dir[0] * dir[0] + dir[1] * dir[1]);
+	b = 2.0f * (v1[0] * dir[0] + v1[1] * dir[1]);
+	c = v1[0] * v1[0] + v1[1] * v1[1] - (radius+RADIUS_EPSILON) * (radius+RADIUS_EPSILON);
+
+	d = b * b - 4.0f * c;// * a;
+	if (d > 0) {
+		sqrtd = SquareRootFloat(d);
+		// = (- b + sqrtd) * 0.5f;// / (2.0f * a);
+		fraction = (- b - sqrtd) * 0.5f;// / (2.0f * a);
+		//
+		if (fraction < 0) {
+			fraction = 0;
+		}
+		else {
+			fraction /= length;
+		}
+		if ( fraction < trace.fraction ) {
+			VectorSubtract(end, start, dir);
+			VectorMA(start, fraction, dir, intersection);
+			// if the intersection is between the cylinder lower and upper bound
+			if (intersection[2] <= origin[2] + halfheight &&
+						intersection[2] >= origin[2] - halfheight) {
+				//
+				trace.fraction = fraction;
+				VectorSubtract(intersection, origin, dir);
+				dir[2] = 0;
+				#ifdef CAPSULE_DEBUG
+					l2 = VectorLength(dir);
+					if (l2 <= radius) {
+						int bah = 1;
+					}
+				#endif
+				scale = 1 / (radius+RADIUS_EPSILON);
+				VectorScale(dir, scale, dir);
+				VectorCopy(dir, trace.plane.normal);
+				VectorAdd( tw->modelOrigin, intersection, intersection);
+				trace.plane.dist = DotProduct(trace.plane.normal, intersection);
+				trace.contents = CONTENTS_BODY;
+			}
+		}
+	}
+	else if (d == 0) {
+		//t[0] = (- b ) / 2 * a;
+		// slide along the cylinder
+	}
+	// no intersection at all
+}
+
+/*
+================
+CM_TraceCapsuleThroughCapsule
+
+capsule vs. capsule collision (not rotated)
+================
+*/
+void CM_TraceCapsuleThroughCapsule( traceWork_t *tw, trace_t &trace, clipHandle_t model ) {
+	int i;
+	vec3_t mins, maxs;
+	vec3_t top, bottom, starttop, startbottom, endtop, endbottom;
+	vec3_t offset, symetricSize[2];
+	float radius, halfwidth, halfheight, offs, h;
+
+	CM_ModelBounds(model, mins, maxs);
+	// test trace bounds vs. capsule bounds
+	if ( tw->bounds[0][0] > maxs[0] + RADIUS_EPSILON
+		|| tw->bounds[0][1] > maxs[1] + RADIUS_EPSILON
+		|| tw->bounds[0][2] > maxs[2] + RADIUS_EPSILON
+		|| tw->bounds[1][0] < mins[0] - RADIUS_EPSILON
+		|| tw->bounds[1][1] < mins[1] - RADIUS_EPSILON
+		|| tw->bounds[1][2] < mins[2] - RADIUS_EPSILON
+		) {
+		return;
+	}
+	// top origin and bottom origin of each sphere at start and end of trace
+	VectorAdd(tw->start, tw->sphere.offset, starttop);
+	VectorSubtract(tw->start, tw->sphere.offset, startbottom);
+	VectorAdd(tw->end, tw->sphere.offset, endtop);
+	VectorSubtract(tw->end, tw->sphere.offset, endbottom);
+
+	// calculate top and bottom of the capsule spheres to collide with
+	for ( i = 0 ; i < 3 ; i++ ) {
+		offset[i] = ( mins[i] + maxs[i] ) * 0.5;
+		symetricSize[0][i] = mins[i] - offset[i];
+		symetricSize[1][i] = maxs[i] - offset[i];
+	}
+	halfwidth = symetricSize[ 1 ][ 0 ];
+	halfheight = symetricSize[ 1 ][ 2 ];
+	radius = ( halfwidth > halfheight ) ? halfheight : halfwidth;
+	offs = halfheight - radius;
+	VectorCopy(offset, top);
+	top[2] += offs;
+	VectorCopy(offset, bottom);
+	bottom[2] -= offs;
+	// expand radius of spheres
+	radius += tw->sphere.radius;
+	// if there is horizontal movement
+	if ( tw->start[0] != tw->end[0] || tw->start[1] != tw->end[1] ) {
+		// height of the expanded cylinder is the height of both cylinders minus the radius of both spheres
+		h = halfheight + tw->sphere.halfheight - radius;
+		// if the cylinder has a height
+		if ( h > 0 ) {
+			// test for collisions between the cylinders
+			CM_TraceThroughVerticalCylinder(tw, trace, offset, radius, h, tw->start, tw->end);
+		}
+	}
+	// test for collision between the spheres
+	CM_TraceThroughSphere(tw, trace, top, radius, startbottom, endbottom);
+	CM_TraceThroughSphere(tw, trace, bottom, radius, starttop, endtop);
+}
+
+/*
+================
+CM_TraceBoundingBoxThroughCapsule
+
+bounding box vs. capsule collision
+================
+*/
+void CM_TraceBoundingBoxThroughCapsule( traceWork_t *tw, trace_t &trace, clipHandle_t model ) {
+	vec3_t mins, maxs, offset, size[2];
+	clipHandle_t h;
+	cmodel_t *cmod;
+	int i;
+
+	// mins maxs of the capsule
+	CM_ModelBounds(model, mins, maxs);
+
+	// offset for capsule center
+	for ( i = 0 ; i < 3 ; i++ ) {
+		offset[i] = ( mins[i] + maxs[i] ) * 0.5;
+		size[0][i] = mins[i] - offset[i];
+		size[1][i] = maxs[i] - offset[i];
+		tw->start[i] -= offset[i];
+		tw->end[i] -= offset[i];
+	}
+
+	// replace the bounding box with the capsule
+	tw->sphere.use = qtrue;
+	tw->sphere.radius = ( size[1][0] > size[1][2] ) ? size[1][2]: size[1][0];
+	tw->sphere.halfheight = size[1][2];
+	VectorSet( tw->sphere.offset, 0, 0, size[1][2] - tw->sphere.radius );
+
+	// replace the capsule with the bounding box
+	h = CM_TempBoxModel(tw->size[0], tw->size[1], qfalse);
+	// calculate collision
+	cmod = CM_ClipHandleToModel( h );
+	CM_TraceThroughLeaf( tw, trace, &cmg, &cmod->leaf );
+}
+
+//=========================================================================================
+
+/*
+================
+CM_TraceToLeaf
+================
+*/
+void CM_TraceToLeaf( traceWork_t *tw, trace_t &trace, cLeaf_t *leaf, clipMap_t *local ) 
+{
+	int			k;
+	int			brushnum;
+	cbrush_t	*b;
+	cPatch_t	*patch;
+
+	// trace line against all brushes in the leaf
+	for ( k = 0 ; k < leaf->numLeafBrushes ; k++ ) 
+	{
+		brushnum = local->leafbrushes[leaf->firstLeafBrush + k];
+
+		b = &local->brushes[brushnum];
+		if ( b->checkcount == local->checkcount )
+		{
+			continue;	// already checked this brush in another leaf
+		}
+		b->checkcount = local->checkcount;
+
+		if ( !(b->contents & tw->contents) )
+		{
+			continue;
+		}
+
+#ifndef BSPC
+		if ( com_terrainPhysics->integer && cmg.landScape && (b->contents & CONTENTS_TERRAIN) )
+		{
+			// Invalidate the checkcount for terrain as the terrain brush has to be processed
+			// many times.
+			b->checkcount--;
+
+			CM_TraceThroughTerrain( tw, trace, b );
+			// If inside a terrain brush don't bother with regular brush collision
+			continue;
+		}
+#endif
+
+		CM_TraceThroughBrush( tw, trace, b, false);
+		if ( !trace.fraction )
+		{
+			return;
+		}
+	}
+
+	// trace line against all patches in the leaf
+#ifdef BSPC
+	if (1) {
+#else
+	if ( !cm_noCurves->integer ) {
+#endif
+		for ( k = 0 ; k < leaf->numLeafSurfaces ; k++ ) {
+			patch = local->surfaces[ local->leafsurfaces[ leaf->firstLeafSurface + k ] ];
+			if ( !patch ) {
+				continue;
+			}
+			if ( patch->checkcount == local->checkcount ) {
+				continue;	// already checked this patch in another leaf
+			}
+			patch->checkcount = local->checkcount;
+
+			if ( !(patch->contents & tw->contents) ) {
+				continue;
+			}
+			
+			CM_TraceThroughPatch( tw, trace, patch );
+			if ( !trace.fraction ) {
+				return;
+			}
+		}
+	}
+}
+
+/*
+==================
+CM_TraceThroughTree
+
+Traverse all the contacted leafs from the start to the end position.
+If the trace is a point, they will be exactly in order, but for larger
+trace volumes it is possible to hit something in a later leaf with
+a smaller intercept fraction.
+==================
+*/
+void CM_TraceThroughTree( traceWork_t *tw, trace_t &trace, clipMap_t *local, int num, float p1f, float p2f, vec3_t p1, vec3_t p2) {
+	cNode_t		*node;
+	cplane_t	*plane;
+	float		t1, t2, offset;
+	float		frac, frac2;
+	float		idist;
+	vec3_t		mid;
+	int			side;
+	float		midf;
+
+	if (trace.fraction <= p1f) {
+		return;		// already hit something nearer
+	}
+
+	// if < 0, we are in a leaf node
+	if (num < 0) {
+		CM_TraceThroughLeaf( tw, trace, local, &local->leafs[-1-num] );
+		return;
+	}
+
+	//
+	// find the point distances to the seperating plane
+	// and the offset for the size of the box
+	//
+	node = local->nodes + num;
+#ifdef _XBOX
+	plane = cmg.planes + node->planeNum;//tr.world->nodes[num].planeNum;
+#else   
+	plane = node->plane;
+#endif
+
+	// adjust the plane distance apropriately for mins/maxs
+	if ( plane->type < 3 ) {
+		t1 = p1[plane->type] - plane->dist;
+		t2 = p2[plane->type] - plane->dist;
+		offset = tw->extents[plane->type];
+	} else {
+		t1 = DotProduct (plane->normal, p1) - plane->dist;
+		t2 = DotProduct (plane->normal, p2) - plane->dist;
+		if ( tw->isPoint ) {
+			offset = 0;
+		} else {
+#if 0 // bk010201 - DEAD
+			// an axial brush right behind a slanted bsp plane
+			// will poke through when expanded, so adjust
+			// by sqrt(3)
+			offset = fabs(tw->extents[0]*plane->normal[0]) +
+				fabs(tw->extents[1]*plane->normal[1]) +
+				fabs(tw->extents[2]*plane->normal[2]);
+
+			offset *= 2;
+			offset = tw->maxOffset;
+#endif
+			// this is silly
+			offset = 2048;
+		}
+	}
+
+	// see which sides we need to consider
+	if ( t1 >= offset + 1 && t2 >= offset + 1 ) {
+		CM_TraceThroughTree( tw, trace, local, node->children[0], p1f, p2f, p1, p2 );
+		return;
+	}
+	if ( t1 < -offset - 1 && t2 < -offset - 1 ) {
+		CM_TraceThroughTree( tw, trace, local, node->children[1], p1f, p2f, p1, p2 );
+		return;
+	}
+
+	// put the crosspoint SURFACE_CLIP_EPSILON pixels on the near side
+	if ( t1 < t2 ) {
+		idist = 1.0/(t1-t2);
+		side = 1;
+		frac2 = (t1 + offset + SURFACE_CLIP_EPSILON)*idist;
+		frac = (t1 - offset + SURFACE_CLIP_EPSILON)*idist;
+	} else if (t1 > t2) {
+		idist = 1.0/(t1-t2);
+		side = 0;
+		frac2 = (t1 - offset - SURFACE_CLIP_EPSILON)*idist;
+		frac = (t1 + offset + SURFACE_CLIP_EPSILON)*idist;
+	} else {
+		side = 0;
+		frac = 1;
+		frac2 = 0;
+	}
+
+	// move up to the node
+	if ( frac < 0 ) {
+		frac = 0;
+	}
+	if ( frac > 1 ) {
+		frac = 1;
+	}
+		
+	midf = p1f + (p2f - p1f)*frac;
+
+	mid[0] = p1[0] + frac*(p2[0] - p1[0]);
+	mid[1] = p1[1] + frac*(p2[1] - p1[1]);
+	mid[2] = p1[2] + frac*(p2[2] - p1[2]);
+
+	CM_TraceThroughTree( tw, trace, local, node->children[side], p1f, midf, p1, mid );
+
+
+	// go past the node
+	if ( frac2 < 0 ) {
+		frac2 = 0;
+	}
+	if ( frac2 > 1 ) {
+		frac2 = 1;
+	}
+		
+	midf = p1f + (p2f - p1f)*frac2;
+
+	mid[0] = p1[0] + frac2*(p2[0] - p1[0]);
+	mid[1] = p1[1] + frac2*(p2[1] - p1[1]);
+	mid[2] = p1[2] + frac2*(p2[2] - p1[2]);
+
+	CM_TraceThroughTree( tw, trace, local, node->children[side^1], midf, p2f, mid, p2 );
+}
+
+void CM_CalcExtents(const vec3_t start, const vec3_t end, const traceWork_t *tw, vec3pair_t bounds)
+{
+	int		i;
+
+	for ( i = 0 ; i < 3 ; i++ )
+	{
+		if ( start[i] < end[i] )
+		{
+			bounds[0][i] = start[i] + tw->size[0][i];
+			bounds[1][i] = end[i] + tw->size[1][i];
+		}
+		else
+		{
+			bounds[0][i] = end[i] + tw->size[0][i];
+			bounds[1][i] = start[i] + tw->size[1][i];
+		}
+	}
+}
+
+//======================================================================
+
+
+/*
+==================
+CM_Trace
+==================
+*/
+void CM_Trace( trace_t *trace, const vec3_t start, const vec3_t end,
+						  const vec3_t mins, const vec3_t maxs,
+						  clipHandle_t model, const vec3_t origin, int brushmask, int capsule, sphere_t *sphere ) {
+	int			i;
+	traceWork_t	tw;
+	vec3_t		offset;
+	cmodel_t	*cmod;
+	clipMap_t	*local = 0;
+
+	cmod = CM_ClipHandleToModel( model, &local );
+
+	local->checkcount++;		// for multi-check avoidance
+
+	c_traces++;				// for statistics, may be zeroed
+
+	// fill in a default trace
+	Com_Memset( &tw, 0, sizeof(tw) );
+	memset(trace, 0, sizeof(*trace));
+	trace->fraction = 1;	// assume it goes the entire distance until shown otherwise
+	VectorCopy(origin, tw.modelOrigin);
+
+	if (!local->numNodes) {
+		return;	// map not loaded, shouldn't happen
+	}
+
+	// allow NULL to be passed in for 0,0,0
+	if ( !mins ) {
+		mins = vec3_origin;
+	}
+	if ( !maxs ) {
+		maxs = vec3_origin;
+	}
+
+	// set basic parms
+	tw.contents = brushmask;
+
+	// adjust so that mins and maxs are always symetric, which
+	// avoids some complications with plane expanding of rotated
+	// bmodels
+	for ( i = 0 ; i < 3 ; i++ ) {
+		offset[i] = ( mins[i] + maxs[i] ) * 0.5;
+		tw.size[0][i] = mins[i] - offset[i];
+		tw.size[1][i] = maxs[i] - offset[i];
+		tw.start[i] = start[i] + offset[i];
+		tw.end[i] = end[i] + offset[i];
+	}
+
+	// if a sphere is already specified
+	if ( sphere ) {
+		tw.sphere = *sphere;
+	}
+	else {
+		tw.sphere.use = (qboolean)capsule;
+		tw.sphere.radius = ( tw.size[1][0] > tw.size[1][2] ) ? tw.size[1][2]: tw.size[1][0];
+		tw.sphere.halfheight = tw.size[1][2];
+		VectorSet( tw.sphere.offset, 0, 0, tw.size[1][2] - tw.sphere.radius );
+	}
+
+	tw.maxOffset = tw.size[1][0] + tw.size[1][1] + tw.size[1][2];
+
+	// tw.offsets[signbits] = vector to apropriate corner from origin
+	tw.offsets[0][0] = tw.size[0][0];
+	tw.offsets[0][1] = tw.size[0][1];
+	tw.offsets[0][2] = tw.size[0][2];
+
+	tw.offsets[1][0] = tw.size[1][0];
+	tw.offsets[1][1] = tw.size[0][1];
+	tw.offsets[1][2] = tw.size[0][2];
+
+	tw.offsets[2][0] = tw.size[0][0];
+	tw.offsets[2][1] = tw.size[1][1];
+	tw.offsets[2][2] = tw.size[0][2];
+
+	tw.offsets[3][0] = tw.size[1][0];
+	tw.offsets[3][1] = tw.size[1][1];
+	tw.offsets[3][2] = tw.size[0][2];
+
+	tw.offsets[4][0] = tw.size[0][0];
+	tw.offsets[4][1] = tw.size[0][1];
+	tw.offsets[4][2] = tw.size[1][2];
+
+	tw.offsets[5][0] = tw.size[1][0];
+	tw.offsets[5][1] = tw.size[0][1];
+	tw.offsets[5][2] = tw.size[1][2];
+
+	tw.offsets[6][0] = tw.size[0][0];
+	tw.offsets[6][1] = tw.size[1][1];
+	tw.offsets[6][2] = tw.size[1][2];
+
+	tw.offsets[7][0] = tw.size[1][0];
+	tw.offsets[7][1] = tw.size[1][1];
+	tw.offsets[7][2] = tw.size[1][2];
+
+	//
+	// calculate bounds
+	//
+	if ( tw.sphere.use ) {
+		for ( i = 0 ; i < 3 ; i++ ) {
+			if ( tw.start[i] < tw.end[i] ) {
+				tw.bounds[0][i] = tw.start[i] - fabs(tw.sphere.offset[i]) - tw.sphere.radius;
+				tw.bounds[1][i] = tw.end[i] + fabs(tw.sphere.offset[i]) + tw.sphere.radius;
+			} else {
+				tw.bounds[0][i] = tw.end[i] - fabs(tw.sphere.offset[i]) - tw.sphere.radius;
+				tw.bounds[1][i] = tw.start[i] + fabs(tw.sphere.offset[i]) + tw.sphere.radius;
+			}
+		}
+	}
+	else {
+		for ( i = 0 ; i < 3 ; i++ ) {
+			if ( tw.start[i] < tw.end[i] ) {
+				tw.bounds[0][i] = tw.start[i] + tw.size[0][i];
+				tw.bounds[1][i] = tw.end[i] + tw.size[1][i];
+			} else {
+				tw.bounds[0][i] = tw.end[i] + tw.size[0][i];
+				tw.bounds[1][i] = tw.start[i] + tw.size[1][i];
+			}
+		}
+	}
+
+	//
+	// check for position test special case
+	//
+	if (start[0] == end[0] && start[1] == end[1] && start[2] == end[2] && 
+		tw.size[0][0] == 0 && tw.size[0][1] == 0 && tw.size[0][2] == 0) 
+	{
+		if ( model && cmod->firstNode == -1) 
+		{
+#ifdef ALWAYS_BBOX_VS_BBOX // bk010201 - FIXME - compile time flag?
+			if ( model == BOX_MODEL_HANDLE || model == CAPSULE_MODEL_HANDLE) 
+			{
+				tw.sphere.use = qfalse;
+				CM_TestInLeaf( &tw, &cmod->leaf );
+			}
+			else
+#elif defined(ALWAYS_CAPSULE_VS_CAPSULE)
+			if ( model == BOX_MODEL_HANDLE || model == CAPSULE_MODEL_HANDLE) 
+			{
+				CM_TestCapsuleInCapsule( &tw, model );
+			}
+			else
+#endif
+			if ( model == CAPSULE_MODEL_HANDLE ) 
+			{
+				if ( tw.sphere.use ) 
+				{
+					CM_TestCapsuleInCapsule( &tw, *trace, model );
+				}
+				else 
+				{
+					CM_TestBoundingBoxInCapsule( &tw, *trace, model );
+				}
+			}
+			else 
+			{
+				CM_TestInLeaf( &tw, *trace, &cmod->leaf, local );
+			}
+		} 
+#ifdef TEST_TERRAIN_PHYSICS
+		else if (cmg.landScape && !model && !cmod->firstNode)
+		{
+			CM_TraceThroughTerrain( &tw, *trace, cmg.landScape );
+		}
+#endif // #ifdef TEST_TERRAIN_PHYSICS
+		else if (cmod->firstNode == -1)
+		{
+			CM_PositionTest( &tw, *trace );
+		}
+		else
+		{
+			CM_TraceThroughTree( &tw, *trace, local, cmod->firstNode, 0, 1, tw.start, tw.end );
+		}
+	} 
+	else 
+	{
+		//
+		// check for point special case
+		//
+		if ( tw.size[0][0] == 0 && tw.size[0][1] == 0 && tw.size[0][2] == 0 ) 
+		{
+			tw.isPoint = qtrue;
+			VectorClear( tw.extents );
+		} 
+		else 
+		{
+			tw.isPoint = qfalse;
+			tw.extents[0] = tw.size[1][0];
+			tw.extents[1] = tw.size[1][1];
+			tw.extents[2] = tw.size[1][2];
+		}
+
+		//
+		// general sweeping through world
+		//
+		if ( model && cmod->firstNode == -1) 
+		{
+#ifdef ALWAYS_BBOX_VS_BBOX
+			if ( model == BOX_MODEL_HANDLE || model == CAPSULE_MODEL_HANDLE) 
+			{
+				tw.sphere.use = qfalse;
+				CM_TraceThroughLeaf( &tw, &cmod->leaf );
+			}
+			else
+#elif defined(ALWAYS_CAPSULE_VS_CAPSULE)
+			if ( model == BOX_MODEL_HANDLE || model == CAPSULE_MODEL_HANDLE) 
+			{
+				CM_TraceCapsuleThroughCapsule( &tw, model );
+			}
+			else
+#endif
+			if ( model == CAPSULE_MODEL_HANDLE ) 
+			{
+				if ( tw.sphere.use ) 
+				{
+					CM_TraceCapsuleThroughCapsule( &tw, *trace, model );
+				}
+				else 
+				{
+					CM_TraceBoundingBoxThroughCapsule( &tw, *trace, model );
+				}
+			}
+			else 
+			{
+				CM_TraceThroughLeaf( &tw, *trace, local, &cmod->leaf );
+			}
+		} 
+#ifdef TEST_TERRAIN_PHYSICS
+		else if (cmg.landScape && !model && !cmod->firstNode)
+		{
+			CM_TraceThroughTerrain( &tw, *trace, cmg.landScape );
+		}
+#endif // #ifdef TEST_TERRAIN_PHYSICS
+		else 
+		{
+			CM_TraceThroughTree( &tw, *trace, local, cmod->firstNode, 0, 1, tw.start, tw.end );
+		}
+	}
+
+	// generate endpos from the original, unmodified start/end
+	if ( trace->fraction == 1 ) {
+		VectorCopy (end, trace->endpos);
+	} else {
+		for ( i=0 ; i<3 ; i++ ) {
+			trace->endpos[i] = start[i] + trace->fraction * (end[i] - start[i]);
+		}
+	}
+
+        // If allsolid is set (was entirely inside something solid), the plane is not valid.
+        // If fraction == 1.0, we never hit anything, and thus the plane is not valid.
+        // Otherwise, the normal on the plane should have unit length
+        assert(trace->allsolid ||
+               trace->fraction == 1.0 ||
+               VectorLengthSquared(trace->plane.normal) > 0.9999);
+}
+
+/*
+==================
+CM_BoxTrace
+==================
+*/
+void CM_BoxTrace( trace_t *results, const vec3_t start, const vec3_t end,
+						  const vec3_t mins, const vec3_t maxs,
+						  clipHandle_t model, int brushmask, int capsule ) {
+	CM_Trace( results, start, end, mins, maxs, model, vec3_origin, brushmask, capsule, NULL );
+}
+
+/*
+==================
+CM_TransformedBoxTrace
+
+Handles offseting and rotation of the end points for moving and
+rotating entities
+==================
+*/
+void CM_TransformedBoxTrace( trace_t *trace, const vec3_t start, const vec3_t end,
+						  const vec3_t mins, const vec3_t maxs,
+						  clipHandle_t model, int brushmask,
+						  const vec3_t origin, const vec3_t angles, int capsule ) {
+	vec3_t		start_l, end_l;
+	qboolean	rotated;
+	vec3_t		offset;
+	vec3_t		symetricSize[2];
+	vec3_t		matrix[3], transpose[3];
+	int			i;
+	float		halfwidth;
+	float		halfheight;
+	float		t;
+	sphere_t	sphere;
+
+	if ( !mins ) {
+		mins = vec3_origin;
+	}
+	if ( !maxs ) {
+		maxs = vec3_origin;
+	}
+
+	// adjust so that mins and maxs are always symetric, which
+	// avoids some complications with plane expanding of rotated
+	// bmodels
+	for ( i = 0 ; i < 3 ; i++ ) {
+		offset[i] = ( mins[i] + maxs[i] ) * 0.5;
+		symetricSize[0][i] = mins[i] - offset[i];
+		symetricSize[1][i] = maxs[i] - offset[i];
+		start_l[i] = start[i] + offset[i];
+		end_l[i] = end[i] + offset[i];
+	}
+
+	// subtract origin offset
+	VectorSubtract( start_l, origin, start_l );
+	VectorSubtract( end_l, origin, end_l );
+
+	// rotate start and end into the models frame of reference
+	if ( model != BOX_MODEL_HANDLE && 
+		(angles[0] || angles[1] || angles[2]) ) {
+		rotated = qtrue;
+	} else {
+		rotated = qfalse;
+	}
+
+	halfwidth = symetricSize[ 1 ][ 0 ];
+	halfheight = symetricSize[ 1 ][ 2 ];
+
+	sphere.use = (qboolean)capsule;
+	sphere.radius = ( halfwidth > halfheight ) ? halfheight : halfwidth;
+	sphere.halfheight = halfheight;
+	t = halfheight - sphere.radius;
+
+	if (rotated) {
+		// rotation on trace line (start-end) instead of rotating the bmodel
+		// NOTE: This is still incorrect for bounding boxes because the actual bounding
+		//		 box that is swept through the model is not rotated. We cannot rotate
+		//		 the bounding box or the bmodel because that would make all the brush
+		//		 bevels invalid.
+		//		 However this is correct for capsules since a capsule itself is rotated too.
+		CreateRotationMatrix(angles, matrix);
+		RotatePoint(start_l, matrix);
+		RotatePoint(end_l, matrix);
+		// rotated sphere offset for capsule
+		sphere.offset[0] = matrix[0][ 2 ] * t;
+		sphere.offset[1] = -matrix[1][ 2 ] * t;
+		sphere.offset[2] = matrix[2][ 2 ] * t;
+	}
+	else {
+		VectorSet( sphere.offset, 0, 0, t );
+	}
+
+	// sweep the box through the model
+	CM_Trace( trace, start_l, end_l, symetricSize[0], symetricSize[1], model, origin, brushmask, capsule, &sphere );
+
+	// if the bmodel was rotated and there was a collision
+	if ( rotated && trace->fraction != 1.0 ) {
+		// rotation of bmodel collision plane
+		TransposeMatrix(matrix, transpose);
+		RotatePoint(trace->plane.normal, transpose);
+	}
+
+	// re-calculate the end position of the trace because the trace.endpos
+	// calculated by CM_Trace could be rotated and have an offset
+	trace->endpos[0] = start[0] + trace->fraction * (end[0] - start[0]);
+	trace->endpos[1] = start[1] + trace->fraction * (end[1] - start[1]);
+	trace->endpos[2] = start[2] + trace->fraction * (end[2] - start[2]);
+}
+
+/*
+=================
+CM_CullBox
+
+Returns true if culled out
+=================
+*/
+
+bool CM_CullBox(const cplane_t *frustum, const vec3_t transformed[8])
+{
+	int				i, j;
+	const cplane_t	*frust;
+
+	// check against frustum planes
+	for (i=0, frust=frustum; i<4 ; i++, frust++) 
+	{
+		for (j=0 ; j<8 ; j++) 
+		{
+			if (DotProduct(transformed[j], frust->normal) > frust->dist) 
+			{	// a point is in front
+				break;
+			} 
+		}
+
+		if (j == 8) 
+		{	// all points were behind one of the planes
+			return true;
+		}
+	}
+	return false;
+}
+
+/*
+=================
+CM_CullWorldBox
+
+Returns true if culled out
+=================
+*/
+
+bool CM_CullWorldBox (const cplane_t *frustum, const vec3pair_t bounds) 
+{
+	int			i;
+	vec3_t		transformed[8];
+
+	for (i = 0 ; i < 8 ; i++) 
+	{
+		transformed[i][0] = bounds[i & 1][0];
+		transformed[i][1] = bounds[(i >> 1) & 1][1];
+		transformed[i][2] = bounds[(i >> 2) & 1][2];
+	}
+
+	return(CM_CullBox(frustum, transformed));
+}
diff --git a/codemp/qcommon/cmd_common.cpp b/codemp/qcommon/cmd_common.cpp
new file mode 100644
index 0000000..a4980f9
--- /dev/null
+++ b/codemp/qcommon/cmd_common.cpp
@@ -0,0 +1,508 @@
+// cmd.c -- Quake script command processing module
+
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+
+#define	MAX_CMD_BUFFER	16384
+#define	MAX_CMD_LINE	1024
+
+typedef struct {
+	byte	*data;
+	int		maxsize;
+	int		cursize;
+} cmd_t;
+
+int			cmd_wait;
+cmd_t		cmd_text;
+byte		cmd_text_buf[MAX_CMD_BUFFER];
+
+
+//=============================================================================
+
+/*
+============
+Cmd_Wait_f
+
+Causes execution of the remainder of the command buffer to be delayed until
+next frame.  This allows commands like:
+bind g "cmd use rocket ; +attack ; wait ; -attack ; cmd use blaster"
+============
+*/
+void Cmd_Wait_f( void ) {
+	if ( Cmd_Argc() == 2 ) {
+		cmd_wait = atoi( Cmd_Argv( 1 ) );
+	} else {
+		cmd_wait = 1;
+	}
+}
+
+
+/*
+=============================================================================
+
+						COMMAND BUFFER
+
+=============================================================================
+*/
+
+/*
+============
+Cbuf_Init
+============
+*/
+void Cbuf_Init (void)
+{
+	cmd_text.data = cmd_text_buf;
+	cmd_text.maxsize = MAX_CMD_BUFFER;
+	cmd_text.cursize = 0;
+}
+
+/*
+============
+Cbuf_AddText
+
+Adds command text at the end of the buffer, does NOT add a final \n
+============
+*/
+void Cbuf_AddText( const char *text ) {
+	int		l;
+	
+	l = strlen (text);
+
+	if (cmd_text.cursize + l >= cmd_text.maxsize)
+	{
+		Com_Printf ("Cbuf_AddText: overflow\n");
+		return;
+	}
+	Com_Memcpy(&cmd_text.data[cmd_text.cursize], text, l);
+	cmd_text.cursize += l;
+}
+
+
+/*
+============
+Cbuf_InsertText
+
+Adds command text immediately after the current command
+Adds a \n to the text
+============
+*/
+void Cbuf_InsertText( const char *text ) {
+	int		len;
+	int		i;
+
+	len = strlen( text ) + 1;
+	if ( len + cmd_text.cursize > cmd_text.maxsize ) {
+		Com_Printf( "Cbuf_InsertText overflowed\n" );
+		return;
+	}
+
+	// move the existing command text
+	for ( i = cmd_text.cursize - 1 ; i >= 0 ; i-- ) {
+		cmd_text.data[ i + len ] = cmd_text.data[ i ];
+	}
+
+	// copy the new text in
+	Com_Memcpy( cmd_text.data, text, len - 1 );
+
+	// add a \n
+	cmd_text.data[ len - 1 ] = '\n';
+
+	cmd_text.cursize += len;
+}
+
+
+/*
+============
+Cbuf_ExecuteText
+============
+*/
+void Cbuf_ExecuteText (int exec_when, const char *text)
+{
+	switch (exec_when)
+	{
+	case EXEC_NOW:
+		if (text && strlen(text) > 0) {
+			Cmd_ExecuteString (text);
+		} else {
+			Cbuf_Execute();
+		}
+		break;
+	case EXEC_INSERT:
+		Cbuf_InsertText (text);
+		break;
+	case EXEC_APPEND:
+		Cbuf_AddText (text);
+		break;
+	default:
+		Com_Error (ERR_FATAL, "Cbuf_ExecuteText: bad exec_when");
+	}
+}
+
+/*
+============
+Cbuf_Execute
+============
+*/
+void Cbuf_Execute (void)
+{
+	int		i;
+	char	*text;
+	char	line[MAX_CMD_LINE];
+	int		quotes;
+
+	while (cmd_text.cursize)
+	{
+		if ( cmd_wait )	{
+			// skip out while text still remains in buffer, leaving it
+			// for next frame
+			cmd_wait--;
+			break;
+		}
+
+		// find a \n or ; line break
+		text = (char *)cmd_text.data;
+
+		quotes = 0;
+		for (i=0 ; i< cmd_text.cursize ; i++)
+		{
+			if (text[i] == '"')
+				quotes++;
+			if ( !(quotes&1) &&  text[i] == ';')
+				break;	// don't break if inside a quoted string
+			if (text[i] == '\n' || text[i] == '\r' )
+				break;
+		}
+
+		if( i >= (MAX_CMD_LINE - 1)) {
+			i = MAX_CMD_LINE - 1;
+		}
+				
+		Com_Memcpy (line, text, i);
+		line[i] = 0;
+		
+// delete the text from the command buffer and move remaining commands down
+// this is necessary because commands (exec) can insert data at the
+// beginning of the text buffer
+
+		if (i == cmd_text.cursize)
+			cmd_text.cursize = 0;
+		else
+		{
+			i++;
+			cmd_text.cursize -= i;
+			memmove (text, text+i, cmd_text.cursize);
+		}
+
+// execute the command line
+
+		Cmd_ExecuteString (line);		
+	}
+}
+
+
+/*
+==============================================================================
+
+						SCRIPT COMMANDS
+
+==============================================================================
+*/
+
+
+/*
+===============
+Cmd_Exec_f
+===============
+*/
+void Cmd_Exec_f( void ) {
+	char	*f;
+	int		len;
+	char	filename[MAX_QPATH];
+
+	if (Cmd_Argc () != 2) {
+		Com_Printf ("exec <filename> : execute a script file\n");
+		return;
+	}
+
+	Q_strncpyz( filename, Cmd_Argv(1), sizeof( filename ) );
+	COM_DefaultExtension( filename, sizeof( filename ), ".cfg" ); 
+	len = FS_ReadFile( filename, (void **)&f);
+	if (!f) {
+		Com_Printf ("couldn't exec %s\n",Cmd_Argv(1));
+		return;
+	}
+	Com_Printf ("execing %s\n",Cmd_Argv(1));
+	
+	Cbuf_InsertText (f);
+
+	FS_FreeFile (f);
+}
+
+
+/*
+===============
+Cmd_Vstr_f
+
+Inserts the current value of a variable as command text
+===============
+*/
+void Cmd_Vstr_f( void ) {
+	char	*v;
+
+	if (Cmd_Argc () != 2) {
+		Com_Printf ("vstr <variablename> : execute a variable command\n");
+		return;
+	}
+
+	v = Cvar_VariableString( Cmd_Argv( 1 ) );
+	Cbuf_InsertText( va("%s\n", v ) );
+}
+
+
+/*
+===============
+Cmd_Echo_f
+
+Just prints the rest of the line to the console
+===============
+*/
+void Cmd_Echo_f (void)
+{
+	int		i;
+	
+	for (i=1 ; i<Cmd_Argc() ; i++)
+		Com_Printf ("%s ",Cmd_Argv(i));
+	Com_Printf ("\n");
+}
+
+
+/*
+=============================================================================
+
+					COMMAND EXECUTION
+
+=============================================================================
+*/
+
+
+static	int			cmd_argc;
+static	char		*cmd_argv[MAX_STRING_TOKENS];		// points into cmd_tokenized
+static	char		cmd_tokenized[BIG_INFO_STRING+MAX_STRING_TOKENS];	// will have 0 bytes inserted
+
+
+/*
+============
+Cmd_Argc
+============
+*/
+int		Cmd_Argc( void ) {
+	return cmd_argc;
+}
+
+/*
+============
+Cmd_Argv
+============
+*/
+char	*Cmd_Argv( int arg ) {
+	if ( (unsigned)arg >= cmd_argc ) {
+		return "";
+	}
+	return cmd_argv[arg];	
+}
+
+/*
+============
+Cmd_ArgvBuffer
+
+The interpreted versions use this because
+they can't have pointers returned to them
+============
+*/
+void	Cmd_ArgvBuffer( int arg, char *buffer, int bufferLength ) {
+	Q_strncpyz( buffer, Cmd_Argv( arg ), bufferLength );
+}
+
+
+/*
+============
+Cmd_Args
+
+Returns a single string containing argv(1) to argv(argc()-1)
+============
+*/
+char	*Cmd_Args( void ) {
+	static	char		cmd_args[MAX_STRING_CHARS];
+	int		i;
+
+	cmd_args[0] = 0;
+	for ( i = 1 ; i < cmd_argc ; i++ ) {
+		strcat( cmd_args, cmd_argv[i] );
+		if ( i != cmd_argc-1 ) {
+			strcat( cmd_args, " " );
+		}
+	}
+
+	return cmd_args;
+}
+
+/*
+============
+Cmd_Args
+
+Returns a single string containing argv(arg) to argv(argc()-1)
+============
+*/
+char *Cmd_ArgsFrom( int arg ) {
+	static	char		cmd_args[BIG_INFO_STRING];
+	int		i;
+
+	cmd_args[0] = 0;
+	if (arg < 0)
+		arg = 0;
+	for ( i = arg ; i < cmd_argc ; i++ ) {
+		strcat( cmd_args, cmd_argv[i] );
+		if ( i != cmd_argc-1 ) {
+			strcat( cmd_args, " " );
+		}
+	}
+
+	return cmd_args;
+}
+
+/*
+============
+Cmd_ArgsBuffer
+
+The interpreted versions use this because
+they can't have pointers returned to them
+============
+*/
+void	Cmd_ArgsBuffer( char *buffer, int bufferLength ) {
+	Q_strncpyz( buffer, Cmd_Args(), bufferLength );
+}
+
+
+/*
+============
+Cmd_TokenizeString
+
+Parses the given string into command line tokens.
+The text is copied to a seperate buffer and 0 characters
+are inserted in the apropriate place, The argv array
+will point into this temporary buffer.
+============
+*/
+void Cmd_TokenizeString( const char *text_in ) {
+	const char	*text;
+	char	*textOut;
+
+	// clear previous args
+	cmd_argc = 0;
+
+	if ( !text_in ) {
+		return;
+	}
+
+	text = text_in;
+	textOut = cmd_tokenized;
+
+	while ( 1 ) {
+		if ( cmd_argc == MAX_STRING_TOKENS ) {
+			return;			// this is usually something malicious
+		}
+
+		while ( 1 ) {
+			// skip whitespace
+			while ( *text && *text <= ' ' ) {
+				text++;
+			}
+			if ( !*text ) {
+				return;			// all tokens parsed
+			}
+
+			// skip // comments
+			if ( text[0] == '/' && text[1] == '/' ) {
+				return;			// all tokens parsed
+			}
+
+			// skip /* */ comments
+			if ( text[0] == '/' && text[1] =='*' ) {
+				while ( *text && ( text[0] != '*' || text[1] != '/' ) ) {
+					text++;
+				}
+				if ( !*text ) {
+					return;		// all tokens parsed
+				}
+				text += 2;
+			} else {
+				break;			// we are ready to parse a token
+			}
+		}
+
+		// handle quoted strings
+		if ( *text == '"' ) {
+			cmd_argv[cmd_argc] = textOut;
+			cmd_argc++;
+			text++;
+			while ( *text && *text != '"' ) {
+				*textOut++ = *text++;
+			}
+			*textOut++ = 0;
+			if ( !*text ) {
+				return;		// all tokens parsed
+			}
+			text++;
+			continue;
+		}
+
+		// regular token
+		cmd_argv[cmd_argc] = textOut;
+		cmd_argc++;
+
+		// skip until whitespace, quote, or command
+		while ( *(const unsigned char* /*eurofix*/)text > ' ' ) 
+		{
+			if ( text[0] == '"' ) {
+				break;
+			}
+
+			if ( text[0] == '/' && text[1] == '/' ) {
+				break;
+			}
+
+			// skip /* */ comments
+			if ( text[0] == '/' && text[1] =='*' ) {
+				break;
+			}
+
+			*textOut++ = *text++;
+		}
+
+		*textOut++ = 0;
+
+		if ( !*text ) {
+			return;		// all tokens parsed
+		}
+	}
+	
+}
+
+
+
+/*
+============
+Cmd_Init
+============
+*/
+extern void Cmd_List_f(void);
+void Cmd_Init (void) {
+	Cmd_AddCommand ("cmdlist",Cmd_List_f);
+	Cmd_AddCommand ("exec",Cmd_Exec_f);
+	Cmd_AddCommand ("vstr",Cmd_Vstr_f);
+	Cmd_AddCommand ("echo",Cmd_Echo_f);
+	Cmd_AddCommand ("wait", Cmd_Wait_f);
+}
+
diff --git a/codemp/qcommon/cmd_console.cpp b/codemp/qcommon/cmd_console.cpp
new file mode 100644
index 0000000..5088e91
--- /dev/null
+++ b/codemp/qcommon/cmd_console.cpp
@@ -0,0 +1,165 @@
+#include "../qcommon/exe_headers.h"
+
+#define CMD_MAX_NUM 512
+#define CMD_MAX_NAME 32
+
+typedef struct cmd_function_s
+{
+	char					name[CMD_MAX_NAME];
+	xcommand_t				function;
+} cmd_function_t;
+
+
+static	cmd_function_t	cmd_functions[CMD_MAX_NUM] = {0};		// possible commands to execute
+
+
+/*
+============
+Cmd_AddCommand
+============
+*/
+void	Cmd_AddCommand( const char *cmd_name, xcommand_t function ) {
+	cmd_function_t	*cmd;
+	cmd_function_t	*add = NULL;
+	int i;
+	
+	// fail if the command already exists
+	for (i=0; i<CMD_MAX_NUM; i++) {
+		cmd = cmd_functions + i;
+		if ( !strcmp( cmd_name, cmd->name ) ) {
+			// allow completion-only commands to be silently doubled
+			if ( function != NULL ) {
+				Com_Printf ("Cmd_AddCommand: %s already defined\n", cmd_name);
+			}
+			return;
+		}
+
+		if(add == NULL && cmd->name[0] == 0) {
+			add = cmd;
+		}
+	}
+
+	if(!add) {
+		Com_Printf("Cmd_AddCommand: Too many commands registered\n");
+		return;
+	}
+
+	if(strlen(cmd_name) >= CMD_MAX_NAME - 1) {
+		Com_Printf("Cmd_AddCommand: Excessively long command name\n");
+	} else {
+		Q_strncpyz(add->name, cmd_name, CMD_MAX_NAME);
+		add->function = function;
+	}
+}
+
+/*
+============
+Cmd_RemoveCommand
+============
+*/
+void	Cmd_RemoveCommand( const char *cmd_name ) {
+	cmd_function_t	*cmd;
+	int i;
+
+	for(i=0; i<CMD_MAX_NUM; i++) {
+		cmd = cmd_functions + i;
+		if ( !strcmp( cmd_name, cmd->name ) ) {
+			cmd->name[0] = 0;
+			return;
+		}
+	}
+}
+
+
+
+/*
+============
+Cmd_ExecuteString
+
+A complete command line has been parsed, so try to execute it
+============
+*/
+void	Cmd_ExecuteString( const char *text ) {	
+	int i;
+
+	// execute the command line
+	Cmd_TokenizeString( text );		
+	if ( !Cmd_Argc() ) {
+		return;		// no tokens
+	}
+
+	// check registered command functions	
+	for(i=0; i<CMD_MAX_NUM; i++) {
+		if ( !Q_stricmp( Cmd_Argv(0), cmd_functions[i].name ) ) {
+			// rearrange the links so that the command will be
+			// near the head of the list next time it is used
+			cmd_function_t temp = cmd_functions[i];
+			cmd_functions[i] = cmd_functions[0];
+			cmd_functions[0] = temp;
+
+			// perform the action
+			if ( !temp.function ) {
+				// let the cgame or game handle it
+				break;
+			} else {
+				temp.function ();
+			}
+			return;
+		}
+	}
+	
+	// check cvars
+	if ( Cvar_Command() ) {
+		return;
+	}
+
+	// check client game commands
+	if ( com_cl_running && com_cl_running->integer && CL_GameCommand() ) {
+		return;
+	}
+
+	// check server game commands
+	if ( com_sv_running && com_sv_running->integer && SV_GameCommand() ) {
+		return;
+	}
+
+	// check ui commands
+	if ( com_cl_running && com_cl_running->integer && UI_GameCommand() ) {
+		return;
+	}
+
+	// send it as a server command if we are connected
+	// this will usually result in a chat message
+	//CL_ForwardCommandToServer ( text );
+	CL_ForwardCommandToServer ( text );
+}
+
+
+/*
+============
+Cmd_List_f
+============
+*/
+void Cmd_List_f (void)
+{
+	cmd_function_t	*cmd;
+	int				i;
+	char			*match;
+
+	if ( Cmd_Argc() > 1 ) {
+		match = Cmd_Argv( 1 );
+	} else {
+		match = NULL;
+	}
+
+	i = 0;
+	for(int c=0; c<CMD_MAX_NUM; c++) { 
+		cmd = cmd_functions + c;
+		if (match && !Com_Filter(match, cmd->name, qfalse)) continue;
+
+		Com_Printf ("%s\n", cmd->name);
+		i++;
+	}
+	Com_Printf ("%i commands\n", i);
+}
+
diff --git a/codemp/qcommon/cmd_pc.cpp b/codemp/qcommon/cmd_pc.cpp
new file mode 100644
index 0000000..b93be6f
--- /dev/null
+++ b/codemp/qcommon/cmd_pc.cpp
@@ -0,0 +1,174 @@
+#include "../qcommon/exe_headers.h"
+
+typedef struct cmd_function_s
+{
+	struct cmd_function_s	*next;
+	char					*name;
+	xcommand_t				function;
+} cmd_function_t;
+
+
+static	cmd_function_t	*cmd_functions;		// possible commands to execute
+
+
+/*
+============
+Cmd_AddCommand
+============
+*/
+void	Cmd_AddCommand( const char *cmd_name, xcommand_t function ) {
+	cmd_function_t	*cmd;
+	
+	// fail if the command already exists
+	for ( cmd = cmd_functions ; cmd ; cmd=cmd->next ) {
+		if ( !strcmp( cmd_name, cmd->name ) ) {
+			// allow completion-only commands to be silently doubled
+			if ( function != NULL ) {
+				Com_Printf ("Cmd_AddCommand: %s already defined\n", cmd_name);
+			}
+			return;
+		}
+	}
+
+	// use a small malloc to avoid zone fragmentation
+	cmd = (struct cmd_function_s *)S_Malloc (sizeof(cmd_function_t));
+	cmd->name = CopyString( cmd_name );
+	cmd->function = function;
+	cmd->next = cmd_functions;
+	cmd_functions = cmd;
+}
+
+/*
+============
+Cmd_RemoveCommand
+============
+*/
+void	Cmd_RemoveCommand( const char *cmd_name ) {
+	cmd_function_t	*cmd, **back;
+
+	back = &cmd_functions;
+	while( 1 ) {
+		cmd = *back;
+		if ( !cmd ) {
+			// command wasn't active
+			return;
+		}
+		if ( !strcmp( cmd_name, cmd->name ) ) {
+			*back = cmd->next;
+			if (cmd->name) {
+				Z_Free(cmd->name);
+			}
+			Z_Free (cmd);
+			return;
+		}
+		back = &cmd->next;
+	}
+}
+
+
+
+/*
+============
+Cmd_CommandCompletion
+============
+*/
+void	Cmd_CommandCompletion( void(*callback)(const char *s) ) {
+	cmd_function_t	*cmd;
+	
+	for (cmd=cmd_functions ; cmd ; cmd=cmd->next) {
+		callback( cmd->name );
+	}
+}
+
+
+/*
+============
+Cmd_ExecuteString
+
+A complete command line has been parsed, so try to execute it
+============
+*/
+void	Cmd_ExecuteString( const char *text ) {	
+	cmd_function_t	*cmd, **prev;
+
+	// execute the command line
+	Cmd_TokenizeString( text );		
+	if ( !Cmd_Argc() ) {
+		return;		// no tokens
+	}
+
+	// check registered command functions	
+	for ( prev = &cmd_functions ; *prev ; prev = &cmd->next ) {
+		cmd = *prev;
+		if ( !Q_stricmp( Cmd_Argv(0), cmd->name ) ) {
+			// rearrange the links so that the command will be
+			// near the head of the list next time it is used
+			*prev = cmd->next;
+			cmd->next = cmd_functions;
+			cmd_functions = cmd;
+
+			// perform the action
+			if ( !cmd->function ) {
+				// let the cgame or game handle it
+				break;
+			} else {
+				cmd->function ();
+			}
+			return;
+		}
+	}
+	
+	// check cvars
+	if ( Cvar_Command() ) {
+		return;
+	}
+
+	// check client game commands
+	if ( com_cl_running && com_cl_running->integer && CL_GameCommand() ) {
+		return;
+	}
+
+	// check server game commands
+	if ( com_sv_running && com_sv_running->integer && SV_GameCommand() ) {
+		return;
+	}
+
+	// check ui commands
+	if ( com_cl_running && com_cl_running->integer && UI_GameCommand() ) {
+		return;
+	}
+
+	// send it as a server command if we are connected
+	// this will usually result in a chat message
+	//CL_ForwardCommandToServer ( text );
+	CL_ForwardCommandToServer ( text );
+}
+
+
+/*
+============
+Cmd_List_f
+============
+*/
+void Cmd_List_f (void)
+{
+	cmd_function_t	*cmd;
+	int				i;
+	char			*match;
+
+	if ( Cmd_Argc() > 1 ) {
+		match = Cmd_Argv( 1 );
+	} else {
+		match = NULL;
+	}
+
+	i = 0;
+	for (cmd=cmd_functions ; cmd ; cmd=cmd->next) {
+		if (match && !Com_Filter(match, cmd->name, qfalse)) continue;
+
+		Com_Printf ("%s\n", cmd->name);
+		i++;
+	}
+	Com_Printf ("%i commands\n", i);
+}
+
diff --git a/codemp/qcommon/common.cpp b/codemp/qcommon/common.cpp
new file mode 100644
index 0000000..60c57e9
--- /dev/null
+++ b/codemp/qcommon/common.cpp
@@ -0,0 +1,2236 @@
+// common.c -- misc functions used in client and server
+
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+#include "GenericParser2.h"
+#include "stringed_ingame.h"
+#include "../qcommon/game_version.h"
+#ifndef __linux__
+//#include <windows.h>
+#include "../qcommon/platform.h"
+#endif
+
+#ifdef _XBOX
+#include "../xbox/XBLive.h"
+#endif
+
+#define	MAXPRINTMSG	4096
+
+#define MAX_NUM_ARGVS	50
+
+int		com_argc;
+char	*com_argv[MAX_NUM_ARGVS+1];
+
+
+#ifdef USE_CD_KEY
+
+extern char cl_cdkey[34];
+
+#endif // USE_CD_KEY
+
+FILE *debuglogfile;
+fileHandle_t logfile;
+fileHandle_t	com_journalFile;			// events are written here
+fileHandle_t	com_journalDataFile;		// config files are written here
+
+cvar_t	*com_viewlog;
+cvar_t	*com_speeds;
+cvar_t	*com_developer;
+cvar_t	*com_vmdebug;
+cvar_t	*com_dedicated;
+cvar_t	*com_timescale;
+cvar_t	*com_fixedtime;
+cvar_t	*com_dropsim;		// 0.0 to 1.0, simulated packet drops
+cvar_t	*com_journal;
+cvar_t	*com_maxfps;
+cvar_t	*com_timedemo;
+cvar_t	*com_sv_running;
+cvar_t	*com_cl_running;
+cvar_t	*com_logfile;		// 1 = buffer log, 2 = flush after each print
+cvar_t	*com_showtrace;
+
+#ifdef G2_PERFORMANCE_ANALYSIS
+cvar_t	*com_G2Report;
+#endif
+
+cvar_t	*com_terrainPhysics; //rwwRMG - added
+
+cvar_t	*com_version;
+cvar_t	*com_blood;
+cvar_t	*com_buildScript;	// for automated data building scripts
+cvar_t	*com_introPlayed;
+cvar_t	*cl_paused;
+cvar_t	*sv_paused;
+cvar_t	*com_cameraMode;
+#if defined(_WIN32) && defined(_DEBUG)
+cvar_t	*com_noErrorInterrupt;
+#endif
+
+cvar_t	*com_RMG;
+
+// com_speeds times
+int		time_game;
+int		time_frontend;		// renderer frontend time
+int		time_backend;		// renderer backend time
+
+int			com_frameTime;
+int			com_frameMsec;
+int			com_frameNumber;
+
+qboolean	com_errorEntered;
+qboolean	com_fullyInitialized;
+
+char	com_errorMessage[MAXPRINTMSG];
+
+void Com_WriteConfig_f( void );
+
+//============================================================================
+
+static char	*rd_buffer;
+static int	rd_buffersize;
+static void	(*rd_flush)( char *buffer );
+
+void Com_BeginRedirect (char *buffer, int buffersize, void (*flush)( char *) )
+{
+	if (!buffer || !buffersize || !flush)
+		return;
+	rd_buffer = buffer;
+	rd_buffersize = buffersize;
+	rd_flush = flush;
+
+	*rd_buffer = 0;
+}
+
+void Com_EndRedirect (void)
+{
+	if ( rd_flush ) {
+		rd_flush(rd_buffer);
+	}
+
+	rd_buffer = NULL;
+	rd_buffersize = 0;
+	rd_flush = NULL;
+}
+
+/*
+=============
+Com_Printf
+
+Both client and server can use this, and it will output
+to the apropriate place.
+
+A raw string should NEVER be passed as fmt, because of "%f" type crashers.
+=============
+*/
+void QDECL Com_Printf( const char *fmt, ... ) {
+	va_list		argptr;
+	char		msg[MAXPRINTMSG];
+	qboolean	silent;
+
+	va_start (argptr,fmt);
+	vsprintf (msg,fmt,argptr);
+	va_end (argptr);
+
+	if ( rd_buffer ) {
+		if ((strlen (msg) + strlen(rd_buffer)) > (rd_buffersize - 1)) {
+			rd_flush(rd_buffer);
+			*rd_buffer = 0;
+		}
+		Q_strcat(rd_buffer, rd_buffersize, msg);
+		rd_flush(rd_buffer);			
+		*rd_buffer = 0;
+		return;
+	}
+
+	// * means dont draw this console message on the player screen
+	// but put it on the console
+	silent = qfalse;
+	if ( msg[0] == '*' )
+	{
+		strcpy ( msg, msg + 1 );
+
+		if ( msg[1] != '*' )
+		{
+			silent = qtrue;
+		}
+	}
+
+	// echo to console if we're not a dedicated server
+	if ( com_dedicated && !com_dedicated->integer ) {
+		CL_ConsolePrint( msg, silent );
+	}
+
+	// echo to dedicated console and early console
+	Sys_Print( msg );
+
+	// logfile
+#ifndef _XBOX
+	if ( com_logfile && com_logfile->integer ) {
+		if ( !logfile && FS_Initialized() ) {
+			struct tm *newtime;
+			time_t aclock;
+
+			time( &aclock );
+			newtime = localtime( &aclock );
+
+			logfile = FS_FOpenFileWrite( "qconsole.log" );
+			Com_Printf( "logfile opened on %s\n", asctime( newtime ) );
+			if ( com_logfile->integer > 1 ) {
+				// force it to not buffer so we get valid
+				// data even if we are crashing
+				FS_ForceFlush(logfile);
+			}
+		}
+		if ( logfile && FS_Initialized()) {
+			FS_Write(msg, strlen(msg), logfile);
+		}
+	}
+#endif
+
+#if defined(_WIN32) && defined(_DEBUG) && !defined(_XBOX)	
+	if ( *msg )
+	{
+		OutputDebugString ( Q_CleanStr(msg) );
+		OutputDebugString ("\n");
+	}
+#endif
+}
+
+
+/*
+================
+Com_DPrintf
+
+A Com_Printf that only shows up if the "developer" cvar is set
+================
+*/
+void QDECL Com_DPrintf( const char *fmt, ...) {
+	va_list		argptr;
+	char		msg[MAXPRINTMSG];
+		
+	if ( !com_developer || !com_developer->integer ) {
+		return;			// don't confuse non-developers with techie stuff...
+	}
+
+	va_start (argptr,fmt);
+	vsprintf (msg,fmt,argptr);
+	va_end (argptr);
+	
+	Com_Printf ("%s", msg);
+}
+
+// Outputs to the VC / Windows Debug window (only in debug compile)
+void QDECL Com_OPrintf( const char *fmt, ...) 
+{
+	va_list		argptr;
+	char		msg[MAXPRINTMSG];
+		
+	va_start (argptr,fmt);
+	vsprintf (msg,fmt,argptr);
+	va_end (argptr);
+#ifndef __linux__	
+	OutputDebugString(msg);
+#else
+	printf(msg);
+#endif
+}
+
+/*
+=============
+Com_Error
+
+Both client and server can use this, and it will
+do the apropriate things.
+=============
+*/
+void QDECL Com_Error( int code, const char *fmt, ... ) {
+	va_list		argptr;
+	static int	lastErrorTime;
+	static int	errorCount;
+	int			currentTime;
+#ifdef _XBOX
+	int			wasRunningServer = com_sv_running->integer;
+#endif
+
+#if defined(_WIN32) && defined(_DEBUG)
+	if ( code != ERR_DISCONNECT && code != ERR_NEED_CD ) {
+		if (com_noErrorInterrupt && !com_noErrorInterrupt->integer) {
+			__asm {
+				int 0x03
+			}
+		}
+	}
+#endif
+
+	// when we are running automated scripts, make sure we
+	// know if anything failed
+	if ( com_buildScript && com_buildScript->integer ) {
+		code = ERR_FATAL;
+	}
+
+	// make sure we can get at our local stuff
+	FS_PureServerSetLoadedPaks( "", "" );
+
+	// if we are getting a solid stream of ERR_DROP, do an ERR_FATAL
+	currentTime = Sys_Milliseconds();
+	if ( currentTime - lastErrorTime < 100 ) {
+		if ( ++errorCount > 3 ) {
+			code = ERR_FATAL;
+		}
+	} else {
+		errorCount = 0;
+	}
+	lastErrorTime = currentTime;
+
+	if ( com_errorEntered ) {
+		Sys_Error( "recursive error after: %s", com_errorMessage );
+	}
+	com_errorEntered = qtrue;
+
+	va_start (argptr,fmt);
+	vsprintf (com_errorMessage,fmt,argptr);
+	va_end (argptr);
+
+	if ( code != ERR_DISCONNECT ) {
+		Cvar_Get("com_errorMessage", "", CVAR_ROM);	//give com_errorMessage a default so it won't come back to life after a resetDefaults
+		Cvar_Set("com_errorMessage", com_errorMessage);
+	}
+
+	if ( code == ERR_SERVERDISCONNECT ) {
+		CL_Disconnect( qtrue );
+		CL_FlushMemory( );
+		com_errorEntered = qfalse;
+
+#ifdef _XBOX
+		// I THINK this only happens on client
+		Net_XboxDisconnect();
+#endif
+
+		throw ("DISCONNECTED\n");
+	} else if ( code == ERR_DROP || code == ERR_DISCONNECT ) {
+		Com_Printf ("********************\nERROR: %s\n********************\n", com_errorMessage);
+		SV_Shutdown (va("Server crashed: %s\n",  com_errorMessage));
+		CL_Disconnect( qtrue );
+		CL_FlushMemory( );
+		com_errorEntered = qfalse;
+
+#ifdef _XBOX
+		// Clients (only) need to do connection cleanup now
+		if (!wasRunningServer)
+			Net_XboxDisconnect();
+#endif
+
+		throw ("DROPPED\n");
+	} else if ( code == ERR_NEED_CD ) {
+		SV_Shutdown( "Server didn't have CD\n" );
+		if ( com_cl_running && com_cl_running->integer ) {
+			CL_Disconnect( qtrue );
+			CL_FlushMemory( );
+			com_errorEntered = qfalse;
+		} else {
+			Com_Printf("Server didn't have CD\n" );
+		}
+		throw ("NEED CD\n");
+	} else {
+		CL_Shutdown ();
+		SV_Shutdown (va("Server fatal crashed: %s\n", com_errorMessage));
+	}
+
+	Com_Shutdown ();
+
+	Sys_Error ("%s", com_errorMessage);
+}
+
+
+/*
+=============
+Com_Quit_f
+
+Both client and server can use this, and it will
+do the apropriate things.
+=============
+*/
+void Com_Quit_f( void ) {
+	// don't try to shutdown if we are in a recursive error
+	if ( !com_errorEntered ) {
+		SV_Shutdown ("Server quit\n");
+		CL_Shutdown ();
+		Com_Shutdown ();
+		FS_Shutdown(qtrue);
+	}
+	Sys_Quit ();
+}
+
+
+
+/*
+============================================================================
+
+COMMAND LINE FUNCTIONS
+
++ characters seperate the commandLine string into multiple console
+command lines.
+
+All of these are valid:
+
+quake3 +set test blah +map test
+quake3 set test blah+map test
+quake3 set test blah + map test
+
+============================================================================
+*/
+
+#define	MAX_CONSOLE_LINES	32
+int		com_numConsoleLines;
+char	*com_consoleLines[MAX_CONSOLE_LINES];
+
+/*
+==================
+Com_ParseCommandLine
+
+Break it up into multiple console lines
+==================
+*/
+void Com_ParseCommandLine( char *commandLine ) {
+	com_consoleLines[0] = commandLine;
+	com_numConsoleLines = 1;
+
+	while ( *commandLine ) {
+		// look for a + seperating character
+		// if commandLine came from a file, we might have real line seperators
+		if ( *commandLine == '+' || *commandLine == '\n' ) {
+			if ( com_numConsoleLines == MAX_CONSOLE_LINES ) {
+				return;
+			}
+			com_consoleLines[com_numConsoleLines] = commandLine + 1;
+			com_numConsoleLines++;
+			*commandLine = 0;
+		}
+		commandLine++;
+	}
+}
+
+
+/*
+===================
+Com_SafeMode
+
+Check for "safe" on the command line, which will
+skip loading of jampconfig.cfg
+===================
+*/
+qboolean Com_SafeMode( void ) {
+	int		i;
+
+	for ( i = 0 ; i < com_numConsoleLines ; i++ ) {
+		Cmd_TokenizeString( com_consoleLines[i] );
+		if ( !Q_stricmp( Cmd_Argv(0), "safe" )
+			|| !Q_stricmp( Cmd_Argv(0), "cvar_restart" ) ) {
+			com_consoleLines[i][0] = 0;
+			return qtrue;
+		}
+	}
+	return qfalse;
+}
+
+
+/*
+===============
+Com_StartupVariable
+
+Searches for command line parameters that are set commands.
+If match is not NULL, only that cvar will be looked for.
+That is necessary because cddir and basedir need to be set
+before the filesystem is started, but all other sets shouls
+be after execing the config and default.
+===============
+*/
+void Com_StartupVariable( const char *match ) {
+	int		i;
+	char	*s;
+	cvar_t	*cv;
+
+	for (i=0 ; i < com_numConsoleLines ; i++) {
+		Cmd_TokenizeString( com_consoleLines[i] );
+		if ( strcmp( Cmd_Argv(0), "set" ) ) {
+			continue;
+		}
+
+		s = Cmd_Argv(1);
+		if ( !match || !strcmp( s, match ) ) {
+			Cvar_Set( s, Cmd_Argv(2) );
+			cv = Cvar_Get( s, "", 0 );
+			cv->flags |= CVAR_USER_CREATED;
+//			com_consoleLines[i] = 0;
+		}
+	}
+}
+
+
+/*
+=================
+Com_AddStartupCommands
+
+Adds command line parameters as script statements
+Commands are seperated by + signs
+
+Returns qtrue if any late commands were added, which
+will keep the demoloop from immediately starting
+=================
+*/
+qboolean Com_AddStartupCommands( void ) {
+	int		i;
+	qboolean	added;
+
+	added = qfalse;
+	// quote every token, so args with semicolons can work
+	for (i=0 ; i < com_numConsoleLines ; i++) {
+		if ( !com_consoleLines[i] || !com_consoleLines[i][0] ) {
+			continue;
+		}
+
+		// set commands won't override menu startup
+		if ( Q_stricmpn( com_consoleLines[i], "set", 3 ) ) {
+			added = qtrue;
+		}
+		Cbuf_AddText( com_consoleLines[i] );
+		Cbuf_AddText( "\n" );
+	}
+
+	return added;
+}
+
+
+//============================================================================
+
+void Info_Print( const char *s ) {
+	char	key[512];
+	char	value[512];
+	char	*o;
+	int		l;
+
+	if (*s == '\\')
+		s++;
+	while (*s)
+	{
+		o = key;
+		while (*s && *s != '\\')
+			*o++ = *s++;
+
+		l = o - key;
+		if (l < 20)
+		{
+			Com_Memset (o, ' ', 20-l);
+			key[20] = 0;
+		}
+		else
+			*o = 0;
+		Com_Printf ("%s", key);
+
+		if (!*s)
+		{
+			Com_Printf ("MISSING VALUE\n");
+			return;
+		}
+
+		o = value;
+		s++;
+		while (*s && *s != '\\')
+			*o++ = *s++;
+		*o = 0;
+
+		if (*s)
+			s++;
+		Com_Printf ("%s\n", value);
+	}
+}
+
+/*
+============
+Com_StringContains
+============
+*/
+char *Com_StringContains(char *str1, char *str2, int casesensitive) {
+	int len, i, j;
+
+	len = strlen(str1) - strlen(str2);
+	for (i = 0; i <= len; i++, str1++) {
+		for (j = 0; str2[j]; j++) {
+			if (casesensitive) {
+				if (str1[j] != str2[j]) {
+					break;
+				}
+			}
+			else {
+				if (toupper(str1[j]) != toupper(str2[j])) {
+					break;
+				}
+			}
+		}
+		if (!str2[j]) {
+			return str1;
+		}
+	}
+	return NULL;
+}
+
+/*
+============
+Com_Filter
+============
+*/
+int Com_Filter(char *filter, char *name, int casesensitive)
+{
+	char buf[MAX_TOKEN_CHARS];
+	char *ptr;
+	int i, found;
+
+	while(*filter) {
+		if (*filter == '*') {
+			filter++;
+			for (i = 0; *filter; i++) {
+				if (*filter == '*' || *filter == '?') break;
+				buf[i] = *filter;
+				filter++;
+			}
+			buf[i] = '\0';
+			if (strlen(buf)) {
+				ptr = Com_StringContains(name, buf, casesensitive);
+				if (!ptr) return qfalse;
+				name = ptr + strlen(buf);
+			}
+		}
+		else if (*filter == '?') {
+			filter++;
+			name++;
+		}
+		else if (*filter == '[' && *(filter+1) == '[') {
+			filter++;
+		}
+		else if (*filter == '[') {
+			filter++;
+			found = qfalse;
+			while(*filter && !found) {
+				if (*filter == ']' && *(filter+1) != ']') break;
+				if (*(filter+1) == '-' && *(filter+2) && (*(filter+2) != ']' || *(filter+3) == ']')) {
+					if (casesensitive) {
+						if (*name >= *filter && *name <= *(filter+2)) found = qtrue;
+					}
+					else {
+						if (toupper(*name) >= toupper(*filter) &&
+							toupper(*name) <= toupper(*(filter+2))) found = qtrue;
+					}
+					filter += 3;
+				}
+				else {
+					if (casesensitive) {
+						if (*filter == *name) found = qtrue;
+					}
+					else {
+						if (toupper(*filter) == toupper(*name)) found = qtrue;
+					}
+					filter++;
+				}
+			}
+			if (!found) return qfalse;
+			while(*filter) {
+				if (*filter == ']' && *(filter+1) != ']') break;
+				filter++;
+			}
+			filter++;
+			name++;
+		}
+		else {
+			if (casesensitive) {
+				if (*filter != *name) return qfalse;
+			}
+			else {
+				if (toupper(*filter) != toupper(*name)) return qfalse;
+			}
+			filter++;
+			name++;
+		}
+	}
+	return qtrue;
+}
+
+/*
+============
+Com_FilterPath
+============
+*/
+int Com_FilterPath(char *filter, char *name, int casesensitive)
+{
+	int i;
+	char new_filter[MAX_QPATH];
+	char new_name[MAX_QPATH];
+
+	for (i = 0; i < MAX_QPATH-1 && filter[i]; i++) {
+		if ( filter[i] == '\\' || filter[i] == ':' ) {
+			new_filter[i] = '/';
+		}
+		else {
+			new_filter[i] = filter[i];
+		}
+	}
+	new_filter[i] = '\0';
+	for (i = 0; i < MAX_QPATH-1 && name[i]; i++) {
+		if ( name[i] == '\\' || name[i] == ':' ) {
+			new_name[i] = '/';
+		}
+		else {
+			new_name[i] = name[i];
+		}
+	}
+	new_name[i] = '\0';
+	return Com_Filter(new_filter, new_name, casesensitive);
+}
+
+/*
+============
+Com_HashKey
+============
+*/
+int Com_HashKey(char *string, int maxlen) {
+	int register hash, i;
+
+	hash = 0;
+	for (i = 0; i < maxlen && string[i] != '\0'; i++) {
+		hash += string[i] * (119 + i);
+	}
+	hash = (hash ^ (hash >> 10) ^ (hash >> 20));
+	return hash;
+}
+
+/*
+================
+Com_RealTime
+================
+*/
+int Com_RealTime(qtime_t *qtime) {
+	time_t t;
+	struct tm *tms;
+
+	t = time(NULL);
+	if (!qtime)
+		return t;
+	tms = localtime(&t);
+	if (tms) {
+		qtime->tm_sec = tms->tm_sec;
+		qtime->tm_min = tms->tm_min;
+		qtime->tm_hour = tms->tm_hour;
+		qtime->tm_mday = tms->tm_mday;
+		qtime->tm_mon = tms->tm_mon;
+		qtime->tm_year = tms->tm_year;
+		qtime->tm_wday = tms->tm_wday;
+		qtime->tm_yday = tms->tm_yday;
+		qtime->tm_isdst = tms->tm_isdst;
+	}
+	return t;
+}
+
+
+/*
+===================================================================
+
+EVENTS AND JOURNALING
+
+In addition to these events, .cfg files are also copied to the
+journaled file
+===================================================================
+*/
+
+// bk001129 - here we go again: upped from 64
+#define	MAX_PUSHED_EVENTS	            1024
+// bk001129 - init, also static
+static int		com_pushedEventsHead = 0;
+static int             com_pushedEventsTail = 0;
+// bk001129 - static
+static sysEvent_t	com_pushedEvents[MAX_PUSHED_EVENTS];
+
+/*
+=================
+Com_InitJournaling
+=================
+*/
+void Com_InitJournaling( void ) {
+	Com_StartupVariable( "journal" );
+	com_journal = Cvar_Get ("journal", "0", CVAR_INIT);
+	if ( !com_journal->integer ) {
+		return;
+	}
+
+	if ( com_journal->integer == 1 ) {
+		Com_Printf( "Journaling events\n");
+		com_journalFile = FS_FOpenFileWrite( "journal.dat" );
+		com_journalDataFile = FS_FOpenFileWrite( "journaldata.dat" );
+	} else if ( com_journal->integer == 2 ) {
+		Com_Printf( "Replaying journaled events\n");
+		FS_FOpenFileRead( "journal.dat", &com_journalFile, qtrue );
+		FS_FOpenFileRead( "journaldata.dat", &com_journalDataFile, qtrue );
+	}
+
+	if ( !com_journalFile || !com_journalDataFile ) {
+		Cvar_Set( "com_journal", "0" );
+		com_journalFile = 0;
+		com_journalDataFile = 0;
+		Com_Printf( "Couldn't open journal files\n" );
+	}
+}
+
+/*
+=================
+Com_GetRealEvent
+=================
+*/
+sysEvent_t	Com_GetRealEvent( void ) {
+	int			r;
+	sysEvent_t	ev;
+
+	// either get an event from the system or the journal file
+	if ( com_journal->integer == 2 ) {
+		r = FS_Read( &ev, sizeof(ev), com_journalFile );
+		if ( r != sizeof(ev) ) {
+			Com_Error( ERR_FATAL, "Error reading from journal file" );
+		}
+		if ( ev.evPtrLength ) {
+			ev.evPtr = Z_Malloc( ev.evPtrLength, TAG_EVENT, qtrue );
+			r = FS_Read( ev.evPtr, ev.evPtrLength, com_journalFile );
+			if ( r != ev.evPtrLength ) {
+				Com_Error( ERR_FATAL, "Error reading from journal file" );
+			}
+		}
+	} else {
+		ev = Sys_GetEvent();
+
+		// write the journal value out if needed
+		if ( com_journal->integer == 1 ) {
+			r = FS_Write( &ev, sizeof(ev), com_journalFile );
+			if ( r != sizeof(ev) ) {
+				Com_Error( ERR_FATAL, "Error writing to journal file" );
+			}
+			if ( ev.evPtrLength ) {
+				r = FS_Write( ev.evPtr, ev.evPtrLength, com_journalFile );
+				if ( r != ev.evPtrLength ) {
+					Com_Error( ERR_FATAL, "Error writing to journal file" );
+				}
+			}
+		}
+	}
+
+	return ev;
+}
+
+
+/*
+=================
+Com_InitPushEvent
+=================
+*/
+// bk001129 - added
+void Com_InitPushEvent( void ) {
+  // clear the static buffer array
+  // this requires SE_NONE to be accepted as a valid but NOP event
+  memset( com_pushedEvents, 0, sizeof(com_pushedEvents) );
+  // reset counters while we are at it
+  // beware: GetEvent might still return an SE_NONE from the buffer
+  com_pushedEventsHead = 0;
+  com_pushedEventsTail = 0;
+}
+
+
+/*
+=================
+Com_PushEvent
+=================
+*/
+void Com_PushEvent( sysEvent_t *event ) {
+	sysEvent_t		*ev;
+	static int printedWarning = 0; // bk001129 - init, bk001204 - explicit int
+
+	ev = &com_pushedEvents[ com_pushedEventsHead & (MAX_PUSHED_EVENTS-1) ];
+
+	if ( com_pushedEventsHead - com_pushedEventsTail >= MAX_PUSHED_EVENTS ) {
+
+		// don't print the warning constantly, or it can give time for more...
+		if ( !printedWarning ) {
+			printedWarning = qtrue;
+			Com_Printf( "WARNING: Com_PushEvent overflow\n" );
+		}
+
+		if ( ev->evPtr ) {
+			Z_Free( ev->evPtr );
+		}
+		com_pushedEventsTail++;
+	} else {
+		printedWarning = qfalse;
+	}
+
+	*ev = *event;
+	com_pushedEventsHead++;
+}
+
+/*
+=================
+Com_GetEvent
+=================
+*/
+sysEvent_t	Com_GetEvent( void ) {
+	if ( com_pushedEventsHead > com_pushedEventsTail ) {
+		com_pushedEventsTail++;
+		return com_pushedEvents[ (com_pushedEventsTail-1) & (MAX_PUSHED_EVENTS-1) ];
+	}
+	return Com_GetRealEvent();
+}
+
+/*
+=================
+Com_RunAndTimeServerPacket
+=================
+*/
+void Com_RunAndTimeServerPacket( netadr_t *evFrom, msg_t *buf ) {
+	int		t1, t2, msec;
+
+	t1 = 0;
+
+	if ( com_speeds->integer ) {
+		t1 = Sys_Milliseconds ();
+	}
+
+	SV_PacketEvent( *evFrom, buf );
+
+	if ( com_speeds->integer ) {
+		t2 = Sys_Milliseconds ();
+		msec = t2 - t1;
+		if ( com_speeds->integer == 3 ) {
+			Com_Printf( "SV_PacketEvent time: %i\n", msec );
+		}
+	}
+}
+
+/*
+=================
+Com_EventLoop
+
+Returns last event time
+=================
+*/
+int Com_EventLoop( void ) {
+	sysEvent_t	ev;
+	netadr_t	evFrom;
+	byte		bufData[MAX_MSGLEN];
+	msg_t		buf;
+
+	MSG_Init( &buf, bufData, sizeof( bufData ) );
+
+	while ( 1 ) {
+		ev = Com_GetEvent();
+
+		// if no more events are available
+		if ( ev.evType == SE_NONE ) {
+			// manually send packet events for the loopback channel
+			while ( NET_GetLoopPacket( NS_CLIENT, &evFrom, &buf ) ) {
+				CL_PacketEvent( evFrom, &buf );
+			}
+
+			while ( NET_GetLoopPacket( NS_SERVER, &evFrom, &buf ) ) {
+				// if the server just shut down, flush the events
+				if ( com_sv_running->integer ) {
+					Com_RunAndTimeServerPacket( &evFrom, &buf );
+				}
+			}
+
+			return ev.evTime;
+		}
+
+
+		switch ( ev.evType ) {
+		default:
+		  // bk001129 - was ev.evTime
+			Com_Error( ERR_FATAL, "Com_EventLoop: bad event type %i", ev.evType );
+			break;
+        case SE_NONE:
+            break;
+		case SE_KEY:
+			CL_KeyEvent( ev.evValue, (qboolean)ev.evValue2, ev.evTime );
+			break;
+		case SE_CHAR:
+			CL_CharEvent( ev.evValue );
+			break;
+		case SE_MOUSE:
+			CL_MouseEvent( ev.evValue, ev.evValue2, ev.evTime );
+			break;
+		case SE_JOYSTICK_AXIS:
+			CL_JoystickEvent( ev.evValue, ev.evValue2, ev.evTime );
+			break;
+		case SE_CONSOLE:
+			if ( ((char *)ev.evPtr)[0] == '\\' || ((char *)ev.evPtr)[0] == '/' ) 
+			{
+				Cbuf_AddText( (char *)ev.evPtr+1 );	
+			}
+			else
+			{
+				Cbuf_AddText( (char *)ev.evPtr );
+			}
+			Cbuf_AddText( "\n" );
+			break;
+		case SE_PACKET:
+			// this cvar allows simulation of connections that
+			// drop a lot of packets.  Note that loopback connections
+			// don't go through here at all.
+			if ( com_dropsim->value > 0 ) {
+				static int seed;
+
+				if ( Q_random( &seed ) < com_dropsim->value ) {
+					break;		// drop this packet
+				}
+			}
+
+			evFrom = *(netadr_t *)ev.evPtr;
+			buf.cursize = ev.evPtrLength - sizeof( evFrom );
+
+			// we must copy the contents of the message out, because
+			// the event buffers are only large enough to hold the
+			// exact payload, but channel messages need to be large
+			// enough to hold fragment reassembly
+			if ( (unsigned)buf.cursize > buf.maxsize ) {
+				Com_Printf("Com_EventLoop: oversize packet\n");
+				continue;
+			}
+			Com_Memcpy( buf.data, (byte *)((netadr_t *)ev.evPtr + 1), buf.cursize );
+			if ( com_sv_running->integer ) {
+				Com_RunAndTimeServerPacket( &evFrom, &buf );
+			} else {
+				CL_PacketEvent( evFrom, &buf );
+			}
+			break;
+		}
+
+		// free any block data
+		if ( ev.evPtr ) {
+			Z_Free( ev.evPtr );
+		}
+	}
+
+	return 0;	// never reached
+}
+
+/*
+================
+Com_Milliseconds
+
+Can be used for profiling, but will be journaled accurately
+================
+*/
+int Com_Milliseconds (void) {
+	sysEvent_t	ev;
+
+	// get events and push them until we get a null event with the current time
+	do {
+
+		ev = Com_GetRealEvent();
+		if ( ev.evType != SE_NONE ) {
+			Com_PushEvent( &ev );
+		}
+	} while ( ev.evType != SE_NONE );
+	
+	return ev.evTime;
+}
+
+//============================================================================
+
+/*
+=============
+Com_Error_f
+
+Just throw a fatal error to
+test error shutdown procedures
+=============
+*/
+static void Com_Error_f (void) {
+	if ( Cmd_Argc() > 1 ) {
+		Com_Error( ERR_DROP, "Testing drop error" );
+	} else {
+		Com_Error( ERR_FATAL, "Testing fatal error" );
+	}
+}
+
+
+/*
+=============
+Com_Freeze_f
+
+Just freeze in place for a given number of seconds to test
+error recovery
+=============
+*/
+static void Com_Freeze_f (void) {
+	float	s;
+	int		start, now;
+
+	if ( Cmd_Argc() != 2 ) {
+		Com_Printf( "freeze <seconds>\n" );
+		return;
+	}
+	s = atof( Cmd_Argv(1) );
+
+	start = Com_Milliseconds();
+
+	while ( 1 ) {
+		now = Com_Milliseconds();
+		if ( ( now - start ) * 0.001 > s ) {
+			break;
+		}
+	}
+}
+
+/*
+=================
+Com_Crash_f
+
+A way to force a bus error for development reasons
+=================
+*/
+static void Com_Crash_f( void ) {
+	* ( int * ) 0 = 0x12345678;
+}
+
+#ifdef USE_CD_KEY
+
+qboolean CL_CDKeyValidate( const char *key, const char *checksum );
+
+/*
+=================
+Com_ReadCDKey
+=================
+*/
+void Com_ReadCDKey( const char *filename ) {
+	fileHandle_t	f;
+	char			buffer[33];
+	char			fbuffer[MAX_OSPATH];
+
+	sprintf(fbuffer, "%s/q3key", filename);
+
+	FS_SV_FOpenFileRead( fbuffer, &f );
+	if ( !f ) {
+		Q_strncpyz( cl_cdkey, "                ", 17 );
+		return;
+	}
+
+	Com_Memset( buffer, 0, sizeof(buffer) );
+
+	FS_Read( buffer, 16, f );
+	FS_FCloseFile( f );
+
+	if (CL_CDKeyValidate(buffer, NULL)) {
+		Q_strncpyz( cl_cdkey, buffer, 17 );
+	} else {
+		Q_strncpyz( cl_cdkey, "                ", 17 );
+	}
+}
+
+/*
+=================
+Com_AppendCDKey
+=================
+*/
+void Com_AppendCDKey( const char *filename ) {
+	fileHandle_t	f;
+	char			buffer[33];
+	char			fbuffer[MAX_OSPATH];
+
+	sprintf(fbuffer, "%s/q3key", filename);
+
+	FS_SV_FOpenFileRead( fbuffer, &f );
+	if (!f) {
+		Q_strncpyz( &cl_cdkey[16], "                ", 17 );
+		return;
+	}
+
+	Com_Memset( buffer, 0, sizeof(buffer) );
+
+	FS_Read( buffer, 16, f );
+	FS_FCloseFile( f );
+
+	if (CL_CDKeyValidate(buffer, NULL)) {
+		strcat( &cl_cdkey[16], buffer );
+	} else {
+		Q_strncpyz( &cl_cdkey[16], "                ", 17 );
+	}
+}
+
+#ifndef DEDICATED // bk001204
+/*
+=================
+Com_WriteCDKey
+=================
+*/
+static void Com_WriteCDKey( const char *filename, const char *ikey ) {
+#ifndef _XBOX
+	fileHandle_t	f;
+	char			fbuffer[MAX_OSPATH];
+	char			key[17];
+
+
+	sprintf(fbuffer, "%s/q3key", filename);
+
+
+	Q_strncpyz( key, ikey, 17 );
+
+	if(!CL_CDKeyValidate(key, NULL) ) {
+		return;
+	}
+
+	f = FS_SV_FOpenFileWrite( fbuffer );
+	if ( !f ) {
+		Com_Printf ("Couldn't write %s.\n", filename );
+		return;
+	}
+
+	FS_Write( key, 16, f );
+
+	FS_Printf( f, "\n// generated by jamp, do not modify\r\n" );
+	FS_Printf( f, "// Do not give this file to ANYONE.\r\n" );
+	FS_Printf( f, "// id Software and Activision will NOT ask you to send this file to them.\r\n");
+
+	FS_FCloseFile( f );
+#endif
+}
+#endif
+
+#endif // USE_CD_KEY
+
+
+#ifdef MEM_DEBUG
+	void SH_Register(void);
+#endif
+
+/*
+=================
+Com_Init
+=================
+*/
+void Com_Init( char *commandLine ) {
+	char	*s;
+
+	Com_Printf( "%s %s %s\n", Q3_VERSION, CPUSTRING, __DATE__ );
+
+	try
+	{
+	  // bk001129 - do this before anything else decides to push events
+	  Com_InitPushEvent();
+
+		Cvar_Init ();
+
+		// prepare enough of the subsystems to handle
+		// cvar and command buffer management
+		Com_ParseCommandLine( commandLine );
+
+	//	Swap_Init ();
+		Cbuf_Init ();
+
+		Com_InitZoneMemory();
+
+#ifdef _XBOX
+		extern void WF_Init();
+		WF_Init();
+#endif
+
+		Cmd_Init ();
+
+		// override anything from the config files with command line args
+		Com_StartupVariable( NULL );
+
+		// Seed the random number generator
+		Rand_Init(Sys_Milliseconds(true));
+
+		// get the developer cvar set as early as possible
+		Com_StartupVariable( "developer" );
+
+		// done early so bind command exists
+		CL_InitKeyCommands();
+
+#ifdef _XBOX
+		extern void Sys_InitFileCodes();
+		extern void Sys_FilecodeScan_f();
+		Sys_InitFileCodes();
+		Cmd_AddCommand("filecodes", Sys_FilecodeScan_f);
+
+		extern void Sys_StreamInit();
+		Sys_StreamInit();
+#endif
+
+		FS_InitFilesystem ();
+
+		Com_InitJournaling();
+
+		Cbuf_AddText ("exec mpdefault.cfg\n");
+
+		// skip the jampconfig.cfg if "safe" is on the command line
+		if ( !Com_SafeMode() ) {
+#ifdef DEDICATED
+			Cbuf_AddText ("exec jampserver.cfg\n");
+#else
+			Cbuf_AddText ("exec jampconfig.cfg\n");
+#endif
+		}
+
+		Cbuf_AddText ("exec autoexec.cfg\n");
+
+		Cbuf_Execute ();
+
+		// override anything from the config files with command line args
+		Com_StartupVariable( NULL );
+
+	  // get dedicated here for proper hunk megs initialization
+	#ifdef DEDICATED
+		com_dedicated = Cvar_Get ("dedicated", "2", CVAR_ROM);
+	#else
+		com_dedicated = Cvar_Get ("dedicated", "0", CVAR_LATCH);
+	#endif
+		// allocate the stack based hunk allocator
+		Com_InitHunkMemory();
+
+		// if any archived cvars are modified after this, we will trigger a writing
+		// of the config file
+		cvar_modifiedFlags &= ~CVAR_ARCHIVE;
+
+		//
+		// init commands and vars
+		//
+		com_maxfps = Cvar_Get ("com_maxfps", "85", CVAR_ARCHIVE);
+		com_blood = Cvar_Get ("com_blood", "1", CVAR_ARCHIVE);
+
+		com_developer = Cvar_Get ("developer", "0", CVAR_TEMP );
+		com_vmdebug = Cvar_Get ("vmdebug", "0", CVAR_TEMP );
+		com_logfile = Cvar_Get ("logfile", "0", CVAR_TEMP );
+
+		com_timescale = Cvar_Get ("timescale", "1", CVAR_CHEAT | CVAR_SYSTEMINFO );
+		com_fixedtime = Cvar_Get ("fixedtime", "0", CVAR_CHEAT);
+		com_showtrace = Cvar_Get ("com_showtrace", "0", CVAR_CHEAT);
+
+		com_terrainPhysics = Cvar_Get ("com_terrainPhysics", "1", CVAR_CHEAT);
+
+		com_dropsim = Cvar_Get ("com_dropsim", "0", CVAR_CHEAT);
+		com_viewlog = Cvar_Get( "viewlog", "0", CVAR_CHEAT );
+		com_speeds = Cvar_Get ("com_speeds", "0", 0);
+		com_timedemo = Cvar_Get ("timedemo", "0", 0);
+		com_cameraMode = Cvar_Get ("com_cameraMode", "0", CVAR_CHEAT);
+
+		cl_paused = Cvar_Get ("cl_paused", "0", CVAR_ROM);
+		sv_paused = Cvar_Get ("sv_paused", "0", CVAR_ROM);
+		com_sv_running = Cvar_Get ("sv_running", "0", CVAR_ROM);
+		com_cl_running = Cvar_Get ("cl_running", "0", CVAR_ROM);
+		com_buildScript = Cvar_Get( "com_buildScript", "0", 0 );
+
+#ifdef G2_PERFORMANCE_ANALYSIS
+		com_G2Report = Cvar_Get("com_G2Report", "0", 0);
+#endif
+
+		com_RMG = Cvar_Get("RMG", "0", 0);
+
+		Cvar_Get ("RMG_seed", "0", 0);
+		Cvar_Get ("RMG_time", "day", 0);
+		Cvar_Get ("RMG_soundset", "", 0);
+
+		Cvar_Get ("RMG_textseed", "0", CVAR_SYSTEMINFO|CVAR_ARCHIVE);
+		Cvar_Get ("RMG_map", "small", CVAR_ARCHIVE|CVAR_SYSTEMINFO);
+		Cvar_Get ("RMG_timefile", "day", CVAR_ARCHIVE);
+		Cvar_Get ("RMG_terrain", "grassyhills", CVAR_ARCHIVE);
+
+		Cvar_Get ("RMG_sky", "", CVAR_SYSTEMINFO );
+		Cvar_Get ("RMG_fog", "", CVAR_SYSTEMINFO );
+		Cvar_Get ("RMG_weather", "", CVAR_SYSTEMINFO|CVAR_SERVERINFO|CVAR_CHEAT );
+		Cvar_Get ("RMG_instances", "colombia", CVAR_SYSTEMINFO );
+		Cvar_Get ("RMG_miscents", "deciduous", 0);
+		Cvar_Get ("RMG_music", "music/dm_kam1", 0);
+		Cvar_Get ("RMG_mission", "ctf", CVAR_SYSTEMINFO );
+		Cvar_Get ("RMG_course", "standard", CVAR_SYSTEMINFO );
+		Cvar_Get ("RMG_distancecull", "5000", CVAR_CHEAT );
+
+		com_introPlayed = Cvar_Get( "com_introplayed", "0", CVAR_ARCHIVE);
+
+	#if defined(_WIN32) && defined(_DEBUG)
+		com_noErrorInterrupt = Cvar_Get( "com_noErrorInterrupt", "0", 0 );
+	#endif
+
+		if ( com_dedicated->integer ) {
+			if ( !com_viewlog->integer ) {
+				Cvar_Set( "viewlog", "1" );
+			}
+		}
+
+		if ( com_developer && com_developer->integer ) {
+			Cmd_AddCommand ("error", Com_Error_f);
+			Cmd_AddCommand ("crash", Com_Crash_f );
+			Cmd_AddCommand ("freeze", Com_Freeze_f);
+		}
+		Cmd_AddCommand ("quit", Com_Quit_f);
+		Cmd_AddCommand ("changeVectors", MSG_ReportChangeVectors_f );
+		Cmd_AddCommand ("writeconfig", Com_WriteConfig_f );
+
+		s = va("%s %s %s", Q3_VERSION, CPUSTRING, __DATE__ );
+		com_version = Cvar_Get ("version", s, CVAR_ROM | CVAR_SERVERINFO );
+
+		SE_Init();
+
+		Sys_Init();
+		Netchan_Init( Com_Milliseconds() & 0xffff );	// pick a port value that should be nice and random
+		VM_Init();
+		SV_Init();
+#ifdef _XBOX
+		//Load this earlier so it doesn't create a fragment in the middle of
+		//the zone.
+		extern int PC_LoadGlobalDefines(const char*);
+		PC_LoadGlobalDefines("ui/jamp/menudef.h");
+#endif
+
+		com_dedicated->modified = qfalse;
+		if ( !com_dedicated->integer ) {
+			CL_Init();
+			Sys_ShowConsole( com_viewlog->integer, qfalse );
+		}
+
+		// set com_frameTime so that if a map is started on the
+		// command line it will still be able to count on com_frameTime
+		// being random enough for a serverid
+		com_frameTime = Com_Milliseconds();
+
+
+		// add + commands from command line
+		if ( !Com_AddStartupCommands() ) 
+		{
+			// if the user didn't give any commands, run default action
+			if ( !com_dedicated->integer ) 
+			{
+#ifndef _DEBUG
+				Cbuf_AddText ("cinematic openinglogos.roq\n");
+#endif
+				// intro.roq is iD's.
+//				if( !com_introPlayed->integer ) {
+//					Cvar_Set( com_introPlayed->name, "1" );
+//					Cvar_Set( "nextmap", "cinematic intro.RoQ" );
+//				}
+			}
+		}
+
+		// start in full screen ui mode
+		Cvar_Set("r_uiFullScreen", "1");
+
+		CL_StartHunkUsers();
+
+		// make sure single player is off by default
+		Cvar_Set("ui_singlePlayerActive", "0");
+
+#ifdef MEM_DEBUG
+		SH_Register();
+#endif
+
+		com_fullyInitialized = qtrue;
+		Com_Printf ("--- Common Initialization Complete ---\n");	
+
+	}
+
+	catch (const char* reason) {
+		Sys_Error ("Error during initialization: %s", reason);
+	}
+}
+
+//==================================================================
+
+void Com_WriteConfigToFile( const char *filename ) {
+#ifndef _XBOX
+	fileHandle_t	f;
+
+	f = FS_FOpenFileWrite( filename );
+	if ( !f ) {
+		Com_Printf ("Couldn't write %s.\n", filename );
+		return;
+	}
+
+	FS_Printf (f, "// generated by Star Wars Jedi Academy MP, do not modify\n");
+	Key_WriteBindings (f);
+	Cvar_WriteVariables (f);
+	FS_FCloseFile( f );
+#endif
+}
+
+
+/*
+===============
+Com_WriteConfiguration
+
+Writes key bindings and archived cvars to config file if modified
+===============
+*/
+void Com_WriteConfiguration( void ) {
+#ifndef DEDICATED // bk001204
+#ifdef USE_CD_KEY
+	cvar_t	*fs;
+#endif	// USE_CD_KEY
+#endif
+	// if we are quiting without fully initializing, make sure
+	// we don't write out anything
+	if ( !com_fullyInitialized ) {
+		return;
+	}
+
+	if ( !(cvar_modifiedFlags & CVAR_ARCHIVE ) ) {
+		return;
+	}
+	cvar_modifiedFlags &= ~CVAR_ARCHIVE;
+
+#ifdef DEDICATED
+	Com_WriteConfigToFile( "jampserver.cfg" );
+#else
+	Com_WriteConfigToFile( "jampconfig.cfg" );
+#endif
+
+	// bk001119 - tentative "not needed for dedicated"
+#ifndef DEDICATED
+#ifdef USE_CD_KEY
+	fs = Cvar_Get ("fs_game", "", CVAR_INIT|CVAR_SYSTEMINFO );
+	if (UI_usesUniqueCDKey() && fs && fs->string[0] != 0) {
+		Com_WriteCDKey( fs->string, &cl_cdkey[16] );
+	} else {
+		Com_WriteCDKey( "base", cl_cdkey );
+	}
+#endif	// USE_CD_KEY
+#endif
+}
+
+
+/*
+===============
+Com_WriteConfig_f
+
+Write the config file to a specific name
+===============
+*/
+void Com_WriteConfig_f( void ) {
+	char	filename[MAX_QPATH];
+
+	if ( Cmd_Argc() != 2 ) {
+		Com_Printf( "Usage: writeconfig <filename>\n" );
+		return;
+	}
+
+	Q_strncpyz( filename, Cmd_Argv(1), sizeof( filename ) );
+	COM_DefaultExtension( filename, sizeof( filename ), ".cfg" );
+	Com_Printf( "Writing %s.\n", filename );
+	Com_WriteConfigToFile( filename );
+}
+
+/*
+================
+Com_ModifyMsec
+================
+*/
+int Com_ModifyMsec( int msec ) {
+	int		clampTime;
+
+	//
+	// modify time for debugging values
+	//
+	if ( com_fixedtime->integer ) {
+		msec = com_fixedtime->integer;
+	} else if ( com_timescale->value ) {
+		msec *= com_timescale->value;
+	} else if (com_cameraMode->integer) {
+		msec *= com_timescale->value;
+	}
+	
+	// don't let it scale below 1 msec
+	if ( msec < 1 && com_timescale->value) {
+		msec = 1;
+	}
+
+	if ( com_dedicated->integer ) {
+		// dedicated servers don't want to clamp for a much longer
+		// period, because it would mess up all the client's views
+		// of time.
+		if ( msec > 500 ) {
+			Com_Printf( "Hitch warning: %i msec frame time\n", msec );
+		}
+		clampTime = 5000;
+	} else 
+	if ( !com_sv_running->integer ) {
+		// clients of remote servers do not want to clamp time, because
+		// it would skew their view of the server's time temporarily
+		clampTime = 5000;
+	} else {
+		// for local single player gaming
+		// we may want to clamp the time to prevent players from
+		// flying off edges when something hitches.
+		clampTime = 200;
+	}
+
+	if ( msec > clampTime ) {
+		msec = clampTime;
+	}
+
+	return msec;
+}
+
+#ifdef G2_PERFORMANCE_ANALYSIS
+#include "../qcommon/timing.h"
+void G2Time_ResetTimers(void);
+void G2Time_ReportTimers(void);
+extern timing_c G2PerformanceTimer_PreciseFrame;
+extern int G2Time_PreciseFrame;
+#endif
+
+/*
+=================
+Com_Frame
+=================
+*/
+void Com_Frame( void ) {
+
+try
+{
+#ifdef G2_PERFORMANCE_ANALYSIS
+	G2PerformanceTimer_PreciseFrame.Start();
+#endif
+	int		msec, minMsec;
+	static int	lastTime;
+	int key;
+ 
+	int		timeBeforeFirstEvents;
+	int           timeBeforeServer;
+	int           timeBeforeEvents;
+	int           timeBeforeClient;
+	int           timeAfter;
+
+
+	// bk001204 - init to zero.
+	//  also:  might be clobbered by `longjmp' or `vfork'
+	timeBeforeFirstEvents =0;
+	timeBeforeServer =0;
+	timeBeforeEvents =0;
+	timeBeforeClient = 0;
+	timeAfter = 0;
+
+
+	// old net chan encryption key
+	key = 0x87243987;
+
+	// write config file if anything changed
+	Com_WriteConfiguration(); 
+
+	// if "viewlog" has been modified, show or hide the log console
+	if ( com_viewlog->modified ) {
+		if ( !com_dedicated->value ) {
+			Sys_ShowConsole( com_viewlog->integer, qfalse );
+		}
+		com_viewlog->modified = qfalse;
+	}
+
+	//
+	// main event loop
+	//
+	if ( com_speeds->integer ) {
+		timeBeforeFirstEvents = Sys_Milliseconds ();
+	}
+
+	// we may want to spin here if things are going too fast
+	if ( !com_dedicated->integer && com_maxfps->integer > 0 && !com_timedemo->integer ) {
+		minMsec = 1000 / com_maxfps->integer;
+	} else {
+		minMsec = 1;
+	}
+	do {
+		com_frameTime = Com_EventLoop();
+		if ( lastTime > com_frameTime ) {
+			lastTime = com_frameTime;		// possible on first frame
+		}
+		msec = com_frameTime - lastTime;
+	} while ( msec < minMsec );
+	Cbuf_Execute ();
+
+	lastTime = com_frameTime;
+
+	// mess with msec if needed
+	com_frameMsec = msec;
+	msec = Com_ModifyMsec( msec );
+
+	//
+	// server side
+	//
+	if ( com_speeds->integer ) {
+		timeBeforeServer = Sys_Milliseconds ();
+	}
+
+	SV_Frame( msec );
+
+	// if "dedicated" has been modified, start up
+	// or shut down the client system.
+	// Do this after the server may have started,
+	// but before the client tries to auto-connect
+	if ( com_dedicated->modified ) {
+		// get the latched value
+		Cvar_Get( "dedicated", "0", 0 );
+		com_dedicated->modified = qfalse;
+		if ( !com_dedicated->integer ) {
+			CL_Init();
+			Sys_ShowConsole( com_viewlog->integer, qfalse );
+			CL_StartHunkUsers();	//fire up the UI!
+		} else {
+			CL_Shutdown();
+			Sys_ShowConsole( 1, qtrue );
+		}
+	}
+
+	//
+	// client system
+	//
+	if ( !com_dedicated->integer ) {
+		//
+		// run event loop a second time to get server to client packets
+		// without a frame of latency
+		//
+		if ( com_speeds->integer ) {
+			timeBeforeEvents = Sys_Milliseconds ();
+		}
+		Com_EventLoop();
+		Cbuf_Execute ();
+
+
+		//
+		// client side
+		//
+		if ( com_speeds->integer ) {
+			timeBeforeClient = Sys_Milliseconds ();
+		}
+
+		CL_Frame( msec );
+
+		if ( com_speeds->integer ) {
+			timeAfter = Sys_Milliseconds ();
+		}
+	}
+
+	//
+	// report timing information
+	//
+	if ( com_speeds->integer ) {
+		int			all, sv, ev, cl;
+
+		all = timeAfter - timeBeforeServer;
+		sv = timeBeforeEvents - timeBeforeServer;
+		ev = timeBeforeServer - timeBeforeFirstEvents + timeBeforeClient - timeBeforeEvents;
+		cl = timeAfter - timeBeforeClient;
+		sv -= time_game;
+		cl -= time_frontend + time_backend;
+
+		Com_Printf ("frame:%i all:%3i sv:%3i ev:%3i cl:%3i gm:%3i rf:%3i bk:%3i\n", 
+					 com_frameNumber, all, sv, ev, cl, time_game, time_frontend, time_backend );
+	}	
+
+	//
+	// trace optimization tracking
+	//
+	if ( com_showtrace->integer ) {
+	
+		extern	int c_traces, c_brush_traces, c_patch_traces;
+		extern	int	c_pointcontents;
+
+		Com_Printf ("%4i traces  (%ib %ip) %4i points\n", c_traces,
+			c_brush_traces, c_patch_traces, c_pointcontents);
+		c_traces = 0;
+		c_brush_traces = 0;
+		c_patch_traces = 0;
+		c_pointcontents = 0;
+	}
+
+	// old net chan encryption key
+	key = lastTime * 0x87243987;
+
+	com_frameNumber++;
+
+#ifdef _XBOX
+	// Need to do Xbox Live frame here, because it can trigger an ERR_DROP
+	XBL_Tick();
+#endif
+
+}//try
+	catch (const char* reason) {
+		Com_Printf (reason);
+		return;			// an ERR_DROP was thrown
+	}
+
+#ifdef G2_PERFORMANCE_ANALYSIS
+	G2Time_PreciseFrame += G2PerformanceTimer_PreciseFrame.End();
+
+	if (com_G2Report && com_G2Report->integer)
+	{
+		G2Time_ReportTimers();
+	}
+
+	G2Time_ResetTimers();
+#endif
+}
+
+/*
+=================
+Com_Shutdown
+=================
+*/
+void MSG_shutdownHuffman();
+void Com_Shutdown (void) 
+{
+	CM_ClearMap();
+
+	if (logfile) {
+		FS_FCloseFile (logfile);
+		logfile = 0;
+		com_logfile->integer = 0;//don't open up the log file again!!
+	}
+
+	if ( com_journalFile ) {
+		FS_FCloseFile( com_journalFile );
+		com_journalFile = 0;
+	}
+
+	MSG_shutdownHuffman();
+/*
+	// Only used for testing changes to huffman frequency table when tuning.
+	{
+		extern float Huff_GetCR(void);
+		char mess[256];
+		sprintf(mess,"Eff. CR = %f\n",Huff_GetCR());
+		OutputDebugString(mess);
+	}
+*/
+}
+
+#if !( defined __linux__ || defined __FreeBSD__ )  // r010123 - include FreeBSD 
+#if ((!id386) && (!defined __i386__)) // rcg010212 - for PPC
+
+void Com_Memcpy (void* dest, const void* src, const size_t count)
+{
+	memcpy(dest, src, count);
+}
+
+void Com_Memset (void* dest, const int val, const size_t count)
+{
+	memset(dest, val, count);
+}
+
+#else
+
+typedef enum
+{
+	PRE_READ,									// prefetch assuming that buffer is used for reading only
+	PRE_WRITE,									// prefetch assuming that buffer is used for writing only
+	PRE_READ_WRITE								// prefetch assuming that buffer is used for both reading and writing
+} e_prefetch;
+
+void Com_Prefetch (const void *s, const unsigned int bytes, e_prefetch type);
+
+#define EMMS_INSTRUCTION	__asm emms
+
+void _copyDWord (unsigned int* dest, const unsigned int constant, const unsigned int count) {
+	__asm
+	{
+			mov		edx,dest
+			mov		eax,constant
+			mov		ecx,count
+			and		ecx,~7
+			jz		padding
+			sub		ecx,8
+			jmp		loopu
+			align	16
+loopu:		
+			test	[edx+ecx*4 + 28],ebx		// fetch next block destination to L1 cache
+			mov		[edx+ecx*4 + 0],eax
+			mov		[edx+ecx*4 + 4],eax
+			mov		[edx+ecx*4 + 8],eax
+			mov		[edx+ecx*4 + 12],eax
+			mov		[edx+ecx*4 + 16],eax
+			mov		[edx+ecx*4 + 20],eax
+			mov		[edx+ecx*4 + 24],eax
+			mov		[edx+ecx*4 + 28],eax
+			sub		ecx,8
+			jge		loopu
+padding:	mov		ecx,count
+			mov		ebx,ecx
+			and		ecx,7
+			jz		outta
+			and		ebx,~7
+			lea		edx,[edx+ebx*4]				// advance dest pointer
+			test	[edx+0],eax					// fetch destination to L1 cache
+			cmp		ecx,4
+			jl		skip4
+			mov		[edx+0],eax
+			mov		[edx+4],eax
+			mov		[edx+8],eax
+			mov		[edx+12],eax
+			add		edx,16
+			sub		ecx,4
+skip4:		cmp		ecx,2
+			jl		skip2
+			mov		[edx+0],eax
+			mov		[edx+4],eax
+			add		edx,8
+			sub		ecx,2
+skip2:		cmp		ecx,1
+			jl		outta
+			mov		[edx+0],eax
+outta:
+	}
+}
+
+// optimized memory copy routine that handles all alignment
+// cases and block sizes efficiently
+void Com_Memcpy (void* dest, const void* src, const size_t count) {
+	Com_Prefetch (src, count, PRE_READ);
+	__asm
+	{
+		push	edi
+		push	esi
+		mov		ecx,count
+		cmp		ecx,0						// count = 0 check (just to be on the safe side)
+		je		outta
+		mov		edx,dest
+		mov		ebx,src
+		cmp		ecx,32						// padding only?
+		jl		padding
+
+		mov		edi,ecx					
+		and		edi,~31					// edi = count&~31
+		sub		edi,32
+
+		align 16
+loopMisAligned:
+		mov		eax,[ebx + edi + 0 + 0*8]
+		mov		esi,[ebx + edi + 4 + 0*8]
+		mov		[edx+edi+0 + 0*8],eax
+		mov		[edx+edi+4 + 0*8],esi
+		mov		eax,[ebx + edi + 0 + 1*8]
+		mov		esi,[ebx + edi + 4 + 1*8]
+		mov		[edx+edi+0 + 1*8],eax
+		mov		[edx+edi+4 + 1*8],esi
+		mov		eax,[ebx + edi + 0 + 2*8]
+		mov		esi,[ebx + edi + 4 + 2*8]
+		mov		[edx+edi+0 + 2*8],eax
+		mov		[edx+edi+4 + 2*8],esi
+		mov		eax,[ebx + edi + 0 + 3*8]
+		mov		esi,[ebx + edi + 4 + 3*8]
+		mov		[edx+edi+0 + 3*8],eax
+		mov		[edx+edi+4 + 3*8],esi
+		sub		edi,32
+		jge		loopMisAligned
+		
+		mov		edi,ecx
+		and		edi,~31
+		add		ebx,edi					// increase src pointer
+		add		edx,edi					// increase dst pointer
+		and		ecx,31					// new count
+		jz		outta					// if count = 0, get outta here
+
+padding:
+		cmp		ecx,16
+		jl		skip16
+		mov		eax,dword ptr [ebx]
+		mov		dword ptr [edx],eax
+		mov		eax,dword ptr [ebx+4]
+		mov		dword ptr [edx+4],eax
+		mov		eax,dword ptr [ebx+8]
+		mov		dword ptr [edx+8],eax
+		mov		eax,dword ptr [ebx+12]
+		mov		dword ptr [edx+12],eax
+		sub		ecx,16
+		add		ebx,16
+		add		edx,16
+skip16:
+		cmp		ecx,8
+		jl		skip8
+		mov		eax,dword ptr [ebx]
+		mov		dword ptr [edx],eax
+		mov		eax,dword ptr [ebx+4]
+		sub		ecx,8
+		mov		dword ptr [edx+4],eax
+		add		ebx,8
+		add		edx,8
+skip8:
+		cmp		ecx,4
+		jl		skip4
+		mov		eax,dword ptr [ebx]	// here 4-7 bytes
+		add		ebx,4
+		sub		ecx,4
+		mov		dword ptr [edx],eax
+		add		edx,4
+skip4:							// 0-3 remaining bytes
+		cmp		ecx,2
+		jl		skip2
+		mov		ax,word ptr [ebx]	// two bytes
+		cmp		ecx,3				// less than 3?
+		mov		word ptr [edx],ax
+		jl		outta
+		mov		al,byte ptr [ebx+2]	// last byte
+		mov		byte ptr [edx+2],al
+		jmp		outta
+skip2:
+		cmp		ecx,1
+		jl		outta
+		mov		al,byte ptr [ebx]
+		mov		byte ptr [edx],al
+outta:
+		pop		esi
+		pop		edi
+	}
+}
+
+void Com_Memset (void* dest, const int val, const size_t count)
+{
+	unsigned int fillval;
+
+	if (count < 8)
+	{
+		__asm
+		{
+			mov		edx,dest
+			mov		eax, val
+			mov		ah,al
+			mov		ebx,eax
+			and		ebx, 0xffff
+			shl		eax,16
+			add		eax,ebx				// eax now contains pattern
+			mov		ecx,count
+			cmp		ecx,4
+			jl		skip4
+			mov		[edx],eax			// copy first dword
+			add		edx,4
+			sub		ecx,4
+	skip4:	cmp		ecx,2
+			jl		skip2
+			mov		word ptr [edx],ax	// copy 2 bytes
+			add		edx,2
+			sub		ecx,2
+	skip2:	cmp		ecx,0
+			je		skip1
+			mov		byte ptr [edx],al	// copy single byte
+	skip1:
+		}
+		return;
+	}
+
+	fillval = val;
+	
+	fillval = fillval|(fillval<<8);
+	fillval = fillval|(fillval<<16);		// fill dword with 8-bit pattern
+
+	_copyDWord ((unsigned int*)(dest),fillval, count/4);
+	
+	__asm									// padding of 0-3 bytes
+	{
+		mov		ecx,count
+		mov		eax,ecx
+		and		ecx,3
+		jz		skipA
+		and		eax,~3
+		mov		ebx,dest
+		add		ebx,eax
+		mov		eax,fillval
+		cmp		ecx,2
+		jl		skipB
+		mov		word ptr [ebx],ax
+		cmp		ecx,2
+		je		skipA					
+		mov		byte ptr [ebx+2],al		
+		jmp		skipA
+skipB:		
+		cmp		ecx,0
+		je		skipA
+		mov		byte ptr [ebx],al
+skipA:
+	}
+}
+
+qboolean Com_Memcmp (const void *src0, const void *src1, const unsigned int count)
+{
+	unsigned int i;
+	// MMX version anyone?
+
+	if (count >= 16)
+	{
+		unsigned int *dw = (unsigned int*)(src0);
+		unsigned int *sw = (unsigned int*)(src1);
+
+		unsigned int nm2 = count/16;
+		for (i = 0; i < nm2; i+=4)
+		{
+			unsigned int tmp = (dw[i+0]-sw[i+0])|(dw[i+1]-sw[i+1])|
+						  (dw[i+2]-sw[i+2])|(dw[i+3]-sw[i+3]);
+			if (tmp)
+				return qfalse;
+		}
+	}
+	if (count & 15)
+	{
+		byte *d = (byte*)src0;
+		byte *s = (byte*)src1;
+		for (i = count & 0xfffffff0; i < count; i++)
+		if (d[i]!=s[i])
+			return qfalse;
+	}
+
+	return qtrue;
+}
+
+void Com_Prefetch (const void *s, const unsigned int bytes, e_prefetch type)
+{
+	// write buffer prefetching is performed only if
+	// the processor benefits from it. Read and read/write
+	// prefetching is always performed.
+
+	switch (type)
+	{
+		case PRE_WRITE : break;
+		case PRE_READ:
+		case PRE_READ_WRITE:
+
+		__asm
+		{
+			mov		ebx,s
+			mov		ecx,bytes
+			cmp		ecx,4096				// clamp to 4kB
+			jle		skipClamp
+			mov		ecx,4096
+skipClamp:
+			add		ecx,0x1f
+			shr		ecx,5					// number of cache lines
+			jz		skip
+			jmp		loopie
+
+			align 16
+	loopie:	test	byte ptr [ebx],al
+			add		ebx,32
+			dec		ecx
+			jnz		loopie
+	skip:
+		}
+
+		break;
+	}
+}
+
+#endif 
+#endif // bk001208 - memset/memcpy assembly, Q_acos needed (RC4)
+//------------------------------------------------------------------------
+
+
+/*
+=====================
+Q_acos
+
+the msvc acos doesn't always return a value between -PI and PI:
+
+int i;
+i = 1065353246;
+acos(*(float*) &i) == -1.#IND0
+
+	This should go in q_math but it is too late to add new traps
+	to game and ui
+=====================
+*/
+float Q_acos(float c) {
+	float angle;
+
+	angle = acos(c);
+
+	if (angle > M_PI) {
+		return (float)M_PI;
+	}
+	if (angle < -M_PI) {
+		return (float)M_PI;
+	}
+	return angle;
+}
+
+float Q_asin(float c) 
+{
+	float angle;
+
+	angle = asin(c);
+
+	if (angle > M_PI) {
+		return (float)M_PI;
+	}
+	if (angle < -M_PI) {
+		return (float)M_PI;
+	}
+	return angle;
+}
+
+//rwwRMG: Inserted:
+/*
+============
+ParseTextFile
+============
+*/
+
+bool Com_ParseTextFile(const char *file, class CGenericParser2 &parser, bool cleanFirst)
+{
+	fileHandle_t	f;
+	int				length = 0;
+	char			*buf = 0, *bufParse = 0;
+
+	length = FS_FOpenFileByMode( file, &f, FS_READ );
+	if (!f || !length)		
+	{
+		return false;
+	}
+
+	buf = new char [length + 1];
+	FS_Read( buf, length, f );
+	buf[length] = 0;
+
+	bufParse = buf;
+	parser.Parse(&bufParse, cleanFirst);
+	delete buf;
+
+	FS_FCloseFile( f );
+
+	return true;
+}
+
+void Com_ParseTextFileDestroy(class CGenericParser2 &parser)
+{
+	parser.Clean();
+}
+
+CGenericParser2 *Com_ParseTextFile(const char *file, bool cleanFirst, bool writeable)
+{
+	fileHandle_t	f;
+	int				length = 0;
+	char			*buf = 0, *bufParse = 0;
+	CGenericParser2 *parse;
+
+	length = FS_FOpenFileByMode( file, &f, FS_READ );
+	if (!f || !length)		
+	{
+		return 0;
+	}
+
+	buf = new char [length + 1];
+	FS_Read( buf, length, f );
+	FS_FCloseFile( f );
+	buf[length] = 0;
+
+	bufParse = buf;
+
+	parse = new CGenericParser2;
+	if (!parse->Parse(&bufParse, cleanFirst, writeable))
+	{
+		delete parse;
+		parse = 0;
+	}
+
+	delete buf;
+
+	return parse;
+}
+
diff --git a/codemp/qcommon/cvar.cpp b/codemp/qcommon/cvar.cpp
new file mode 100644
index 0000000..da08f69
--- /dev/null
+++ b/codemp/qcommon/cvar.cpp
@@ -0,0 +1,1019 @@
+// cvar.c -- dynamic variable tracking
+
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+cvar_t		*cvar_vars;
+cvar_t		*cvar_cheats;
+int			cvar_modifiedFlags;
+
+#define	MAX_CVARS	1224
+cvar_t		cvar_indexes[MAX_CVARS];
+int			cvar_numIndexes;
+
+#define FILE_HASH_SIZE		256
+static	cvar_t*		hashTable[FILE_HASH_SIZE];
+
+cvar_t *Cvar_Set2( const char *var_name, const char *value, qboolean force);
+
+
+static char *lastMemPool = NULL;
+static int memPoolSize;
+
+
+//If the string came from the memory pool, don't really free it.  The entire
+//memory pool will be wiped during the next level load.
+static void Cvar_FreeString(char *string)
+{
+	if(!lastMemPool || string < lastMemPool ||
+			string >= lastMemPool + memPoolSize) { 
+		Z_Free(string);
+	}
+}
+
+
+
+/*
+================
+return a hash value for the filename
+================
+*/
+static long generateHashValue( const char *fname ) {
+	int		i;
+	long	hash;
+	char	letter;
+
+	hash = 0;
+	i = 0;
+	while (fname[i] != '\0') {
+		letter = tolower((unsigned char)fname[i]);
+		hash+=(long)(letter)*(i+119);
+		i++;
+	}
+	hash &= (FILE_HASH_SIZE-1);
+	return hash;
+}
+
+/*
+============
+Cvar_ValidateString
+============
+*/
+static qboolean Cvar_ValidateString( const char *s ) {
+	if ( !s ) {
+		return qfalse;
+	}
+	if ( strchr( s, '\\' ) ) {
+		return qfalse;
+	}
+	if ( strchr( s, '\"' ) ) {
+		return qfalse;
+	}
+	if ( strchr( s, ';' ) ) {
+		return qfalse;
+	}
+	return qtrue;
+}
+
+/*
+============
+Cvar_FindVar
+============
+*/
+static cvar_t *Cvar_FindVar( const char *var_name ) {
+	cvar_t	*var;
+	long hash;
+
+	hash = generateHashValue(var_name);
+	
+	for (var=hashTable[hash] ; var ; var=var->hashNext) {
+		if (!Q_stricmp(var_name, var->name)) {
+			return var;
+		}
+	}
+
+	return NULL;
+}
+
+/*
+============
+Cvar_VariableValue
+============
+*/
+float Cvar_VariableValue( const char *var_name ) {
+	cvar_t	*var;
+	
+	var = Cvar_FindVar (var_name);
+	if (!var)
+		return 0;
+	return var->value;
+}
+
+
+/*
+============
+Cvar_VariableIntegerValue
+============
+*/
+int Cvar_VariableIntegerValue( const char *var_name ) {
+	cvar_t	*var;
+	
+	var = Cvar_FindVar (var_name);
+	if (!var)
+		return 0;
+	return var->integer;
+}
+
+
+/*
+============
+Cvar_VariableString
+============
+*/
+char *Cvar_VariableString( const char *var_name ) {
+	cvar_t *var;
+	
+	var = Cvar_FindVar (var_name);
+	if (!var)
+		return "";
+	return var->string;
+}
+
+
+/*
+============
+Cvar_VariableStringBuffer
+============
+*/
+void Cvar_VariableStringBuffer( const char *var_name, char *buffer, int bufsize ) {
+	cvar_t *var;
+	
+	var = Cvar_FindVar (var_name);
+	if (!var) {
+		*buffer = 0;
+	}
+	else {
+		Q_strncpyz( buffer, var->string, bufsize );
+	}
+}
+
+
+/*
+============
+Cvar_CommandCompletion
+============
+*/
+void	Cvar_CommandCompletion( void(*callback)(const char *s) ) {
+	cvar_t		*cvar;
+	
+	for ( cvar = cvar_vars ; cvar ; cvar = cvar->next ) {
+		// Dont show internal cvars
+		if ( cvar->flags & CVAR_INTERNAL )
+		{
+			continue;
+		}
+		callback( cvar->name );
+	}
+}
+
+
+/*
+============
+Cvar_Get
+
+If the variable already exists, the value will not be set unless CVAR_ROM
+The flags will be or'ed in if the variable exists.
+============
+*/
+cvar_t *Cvar_Get( const char *var_name, const char *var_value, int flags ) {
+	cvar_t	*var;
+	long	hash;
+
+    if ( !var_name || ! var_value ) {
+		Com_Error( ERR_FATAL, "Cvar_Get: NULL parameter" );
+    }
+
+	if ( !Cvar_ValidateString( var_name ) ) {
+		Com_Printf("invalid cvar name string: %s\n", var_name );
+		var_name = "BADNAME";
+	}
+
+#if 0		// FIXME: values with backslash happen
+	if ( !Cvar_ValidateString( var_value ) ) {
+		Com_Printf("invalid cvar value string: %s\n", var_value );
+		var_value = "BADVALUE";
+	}
+#endif
+
+	var = Cvar_FindVar (var_name);
+	if ( var ) {
+		// if the C code is now specifying a variable that the user already
+		// set a value for, take the new value as the reset value
+		if ( ( var->flags & CVAR_USER_CREATED ) && !( flags & CVAR_USER_CREATED )
+			&& var_value[0] ) {
+			var->flags &= ~CVAR_USER_CREATED;
+			Cvar_FreeString( var->resetString );
+			var->resetString = CopyString( var_value );
+
+			// ZOID--needs to be set so that cvars the game sets as 
+			// SERVERINFO get sent to clients
+			cvar_modifiedFlags |= flags;
+		}
+
+		var->flags |= flags;
+		// only allow one non-empty reset string without a warning
+		if ( !var->resetString[0] ) {
+			// we don't have a reset string yet
+			Cvar_FreeString( var->resetString );
+			var->resetString = CopyString( var_value );
+		} else if ( var_value[0] && strcmp( var->resetString, var_value ) ) {
+			Com_DPrintf( "Warning: cvar \"%s\" given initial values: \"%s\" and \"%s\"\n",
+				var_name, var->resetString, var_value );
+		}
+		// if we have a latched string, take that value now
+		if ( var->latchedString ) {
+			char *s;
+
+			s = var->latchedString;
+			var->latchedString = NULL;	// otherwise cvar_set2 would free it
+			Cvar_Set2( var_name, s, qtrue );
+			Cvar_FreeString( s );
+		}
+
+// use a CVAR_SET for rom sets, get won't override
+#if 0
+		// CVAR_ROM always overrides
+		if ( flags & CVAR_ROM ) {
+			Cvar_Set2( var_name, var_value, qtrue );
+		}
+#endif
+		return var;
+	}
+
+	//
+	// allocate a new cvar
+	//
+	if ( cvar_numIndexes >= MAX_CVARS ) {
+		Com_Error( ERR_FATAL, "MAX_CVARS" );
+	}
+	var = &cvar_indexes[cvar_numIndexes];
+	cvar_numIndexes++;
+	var->name = CopyString (var_name);
+	var->string = CopyString (var_value);
+	var->modified = qtrue;
+	var->modificationCount = 1;
+	var->value = atof (var->string);
+	var->integer = atoi(var->string);
+	var->resetString = CopyString( var_value );
+
+	// link the variable in
+	var->next = cvar_vars;
+	cvar_vars = var;
+
+	var->flags = flags;
+
+	hash = generateHashValue(var_name);
+	var->hashNext = hashTable[hash];
+	hashTable[hash] = var;
+
+	return var;
+}
+
+/*
+============
+Cvar_Set2
+============
+*/
+cvar_t *Cvar_Set2( const char *var_name, const char *value, qboolean force ) {
+	cvar_t	*var;
+
+	if ( !Cvar_ValidateString( var_name ) ) {
+		Com_Printf("invalid cvar name string: %s\n", var_name );
+		var_name = "BADNAME";
+	}
+
+#if 0	// FIXME
+	if ( value && !Cvar_ValidateString( value ) ) {
+		Com_Printf("invalid cvar value string: %s\n", value );
+		var_value = "BADVALUE";
+	}
+#endif
+
+	var = Cvar_FindVar (var_name);
+	if (!var) {
+		if ( !value ) {
+			return NULL;
+		}
+		// create it
+		if ( !force ) {
+			return Cvar_Get( var_name, value, CVAR_USER_CREATED );
+		} else {
+			return Cvar_Get (var_name, value, 0);
+		}
+	}
+
+	// Dont display the update when its internal
+	if ( !(var->flags & CVAR_INTERNAL) )
+	{
+		Com_DPrintf( "Cvar_Set2: %s %s\n", var_name, value );
+	}
+
+	if (!value ) {
+		value = var->resetString;
+	}
+
+	if (!strcmp(value,var->string)) {
+		return var;
+	}
+	// note what types of cvars have been modified (userinfo, archive, serverinfo, systeminfo)
+	cvar_modifiedFlags |= var->flags;
+
+	if (!force)
+	{
+		if (var->flags & CVAR_ROM)
+		{
+			Com_Printf ("%s is read only.\n", var_name);
+			return var;
+		}
+
+		if (var->flags & CVAR_INIT)
+		{
+			Com_Printf ("%s is write protected.\n", var_name);
+			return var;
+		}
+
+		if (var->flags & CVAR_LATCH)
+		{
+			if (var->latchedString)
+			{
+				if (strcmp(value, var->latchedString) == 0)
+					return var;
+				Cvar_FreeString (var->latchedString);
+			}
+			else
+			{
+				if (strcmp(value, var->string) == 0)
+					return var;
+			}
+
+			Com_Printf ("%s will be changed upon restarting.\n", var_name);
+			var->latchedString = CopyString(value);
+			var->modified = qtrue;
+			var->modificationCount++;
+			return var;
+		}
+
+		if ( (var->flags & CVAR_CHEAT) && !cvar_cheats->integer )
+		{
+			Com_Printf ("%s is cheat protected.\n", var_name);
+			return var;
+		}
+
+	}
+	else
+	{
+		if (var->latchedString)
+		{
+			Cvar_FreeString (var->latchedString);
+			var->latchedString = NULL;
+		}
+	}
+
+	if (!strcmp(value, var->string))
+		return var;		// not changed
+
+	var->modified = qtrue;
+	var->modificationCount++;
+	
+	Cvar_FreeString (var->string);	// free the old value string
+	
+	var->string = CopyString(value);
+	var->value = atof (var->string);
+	var->integer = atoi (var->string);
+
+	return var;
+}
+
+/*
+============
+Cvar_Set
+============
+*/
+void Cvar_Set( const char *var_name, const char *value) {
+	Cvar_Set2 (var_name, value, qtrue);
+}
+
+/*
+============
+Cvar_SetLatched
+============
+*/
+void Cvar_SetLatched( const char *var_name, const char *value) {
+	Cvar_Set2 (var_name, value, qfalse);
+}
+
+/*
+============
+Cvar_SetValue
+============
+*/
+void Cvar_SetValue( const char *var_name, float value) {
+	char	val[32];
+
+	if ( value == (int)value ) {
+		Com_sprintf (val, sizeof(val), "%i",(int)value);
+	} else {
+		Com_sprintf (val, sizeof(val), "%f",value);
+	}
+	Cvar_Set (var_name, val);
+}
+
+
+/*
+============
+Cvar_Reset
+============
+*/
+void Cvar_Reset( const char *var_name ) {
+	Cvar_Set2( var_name, NULL, qfalse );
+}
+
+
+/*
+============
+Cvar_SetCheatState
+
+Any testing variables will be reset to the safe values
+============
+*/
+void Cvar_SetCheatState( void ) {
+	cvar_t	*var;
+
+	// set all default vars to the safe value
+	for ( var = cvar_vars ; var ; var = var->next ) {
+		if ( var->flags & CVAR_CHEAT ) {
+			// the CVAR_LATCHED|CVAR_CHEAT vars might escape the reset here 
+			// because of a different var->latchedString
+			if (var->latchedString)
+			{
+				Cvar_FreeString(var->latchedString);
+				var->latchedString = NULL;
+			}
+			if (strcmp(var->resetString,var->string)) {
+				Cvar_Set( var->name, var->resetString );
+			}
+		}
+	}
+}
+
+/*
+============
+Cvar_Command
+
+Handles variable inspection and changing from the console
+============
+*/
+qboolean Cvar_Command( void ) {
+	cvar_t			*v;
+
+	// check variables
+	v = Cvar_FindVar (Cmd_Argv(0));
+	if (!v) {
+		return qfalse;
+	}
+
+	// perform a variable print or set
+	if ( Cmd_Argc() == 1 ) 
+	{
+/*		if (v->flags & CVAR_INTERNAL) // don't display
+		{
+			return qtrue;
+		}
+*/
+		Com_Printf ("\"%s\" is:\"%s" S_COLOR_WHITE "\" default:\"%s" S_COLOR_WHITE "\"\n", v->name, v->string, v->resetString );
+		if ( v->latchedString ) {
+			Com_Printf( "latched: \"%s\"\n", v->latchedString );
+		}
+		return qtrue;
+	}
+
+//JFM toggle test
+	char *value;
+	value = Cmd_Argv(1);
+	if (value[0] =='!')	//toggle
+	{
+		char buff[5];
+		sprintf(buff,"%i",!v->value);
+		Cvar_Set2 (v->name, buff, qfalse);// toggle the value
+	}
+	else
+	{
+		Cvar_Set2 (v->name, value, qfalse);// set the value if forcing isn't required
+	}
+	
+	return qtrue;
+}
+
+
+/*
+============
+Cvar_Toggle_f
+
+Toggles a cvar for easy single key binding
+============
+*/
+void Cvar_Toggle_f( void ) {
+	int		v;
+
+	if ( Cmd_Argc() != 2 ) {
+		Com_Printf ("usage: toggle <variable>\n");
+		return;
+	}
+
+	v = Cvar_VariableValue( Cmd_Argv( 1 ) );
+	v = !v;
+
+	Cvar_Set2 (Cmd_Argv(1), va("%i", v), qfalse);
+}
+
+/*
+============
+Cvar_Set_f
+
+Allows setting and defining of arbitrary cvars from console, even if they
+weren't declared in C code.
+============
+*/
+void Cvar_Set_f( void ) {
+	int		i, c, l, len;
+	char	combined[MAX_STRING_TOKENS];
+
+	c = Cmd_Argc();
+	if ( c < 3 ) {
+		Com_Printf ("usage: set <variable> <value>\n");
+		return;
+	}
+
+	combined[0] = 0;
+	l = 0;
+	for ( i = 2 ; i < c ; i++ ) {
+		len = strlen ( Cmd_Argv( i ) + 1 );
+		if ( l + len >= MAX_STRING_TOKENS - 2 ) {
+			break;
+		}
+		strcat( combined, Cmd_Argv( i ) );
+		if ( i != c-1 ) {
+			strcat( combined, " " );
+		}
+		l += len;
+	}
+	Cvar_Set2 (Cmd_Argv(1), combined, qfalse);
+}
+
+/*
+============
+Cvar_SetU_f
+
+As Cvar_Set, but also flags it as userinfo
+============
+*/
+void Cvar_SetU_f( void ) {
+	cvar_t	*v;
+
+	if ( Cmd_Argc() != 3 ) {
+		Com_Printf ("usage: setu <variable> <value>\n");
+		return;
+	}
+	Cvar_Set_f();
+	v = Cvar_FindVar( Cmd_Argv( 1 ) );
+	if ( !v ) {
+		return;
+	}
+	v->flags |= CVAR_USERINFO;
+}
+
+/*
+============
+Cvar_SetS_f
+
+As Cvar_Set, but also flags it as userinfo
+============
+*/
+void Cvar_SetS_f( void ) {
+	cvar_t	*v;
+
+	if ( Cmd_Argc() != 3 ) {
+		Com_Printf ("usage: sets <variable> <value>\n");
+		return;
+	}
+	Cvar_Set_f();
+	v = Cvar_FindVar( Cmd_Argv( 1 ) );
+	if ( !v ) {
+		return;
+	}
+	v->flags |= CVAR_SERVERINFO;
+}
+
+/*
+============
+Cvar_SetA_f
+
+As Cvar_Set, but also flags it as archived
+============
+*/
+void Cvar_SetA_f( void ) {
+	cvar_t	*v;
+
+	if ( Cmd_Argc() != 3 ) {
+		Com_Printf ("usage: seta <variable> <value>\n");
+		return;
+	}
+	Cvar_Set_f();
+	v = Cvar_FindVar( Cmd_Argv( 1 ) );
+	if ( !v ) {
+		return;
+	}
+	v->flags |= CVAR_ARCHIVE;
+}
+
+/*
+============
+Cvar_Reset_f
+============
+*/
+void Cvar_Reset_f( void ) {
+	if ( Cmd_Argc() != 2 ) {
+		Com_Printf ("usage: reset <variable>\n");
+		return;
+	}
+	Cvar_Reset( Cmd_Argv( 1 ) );
+}
+
+/*
+============
+Cvar_WriteVariables
+
+Appends lines containing "set variable value" for all variables
+with the archive flag set to qtrue.
+============
+*/
+void Cvar_WriteVariables( fileHandle_t f ) {
+	cvar_t	*var;
+	char	buffer[1024];
+
+	for (var = cvar_vars ; var ; var = var->next) {
+#ifdef USE_CD_KEY
+		if( Q_stricmp( var->name, "cl_cdkey" ) == 0 ) {
+			continue;
+		}
+#endif // USE_CD_KEY
+		if( var->flags & CVAR_ARCHIVE ) {
+			// write the latched value, even if it hasn't taken effect yet
+			if ( var->latchedString ) {
+				Com_sprintf (buffer, sizeof(buffer), "seta %s \"%s\"\n", var->name, var->latchedString);
+			} else {
+				Com_sprintf (buffer, sizeof(buffer), "seta %s \"%s\"\n", var->name, var->string);
+			}
+			FS_Printf (f, "%s", buffer);
+		}
+	}
+}
+
+/*
+============
+Cvar_List_f
+============
+*/
+void Cvar_List_f( void ) {
+	cvar_t	*var;
+	int		i;
+	char	*match;
+
+	if ( Cmd_Argc() > 1 ) {
+		match = Cmd_Argv( 1 );
+	} else {
+		match = NULL;
+	}
+
+	i = 0;
+	for (var = cvar_vars ; var ; var = var->next, i++)
+	{
+		// Dont show internal cvars
+		if ( var->flags & CVAR_INTERNAL )
+		{
+			continue;
+		}
+
+		if (match && !Com_Filter(match, var->name, qfalse)) continue;
+
+		if (var->flags & CVAR_SERVERINFO) {
+			Com_Printf("S");
+		} else {
+			Com_Printf(" ");
+		}
+		if (var->flags & CVAR_USERINFO) {
+			Com_Printf("U");
+		} else {
+			Com_Printf(" ");
+		}
+		if (var->flags & CVAR_ROM) {
+			Com_Printf("R");
+		} else {
+			Com_Printf(" ");
+		}
+		if (var->flags & CVAR_INIT) {
+			Com_Printf("I");
+		} else {
+			Com_Printf(" ");
+		}
+		if (var->flags & CVAR_ARCHIVE) {
+			Com_Printf("A");
+		} else {
+			Com_Printf(" ");
+		}
+		if (var->flags & CVAR_LATCH) {
+			Com_Printf("L");
+		} else {
+			Com_Printf(" ");
+		}
+		if (var->flags & CVAR_CHEAT) {
+			Com_Printf("C");
+		} else {
+			Com_Printf(" ");
+		}
+
+		Com_Printf (" %s \"%s\"\n", var->name, var->string);
+	}
+
+	Com_Printf ("\n%i total cvars\n", i);
+	Com_Printf ("%i cvar indexes\n", cvar_numIndexes);
+}
+
+/*
+============
+Cvar_Restart_f
+
+Resets all cvars to their hardcoded values
+============
+*/
+void Cvar_Restart_f( void ) {
+	cvar_t	*var;
+	cvar_t	**prev;
+
+	prev = &cvar_vars;
+	while ( 1 ) {
+		var = *prev;
+		if ( !var ) {
+			break;
+		}
+
+		// don't mess with rom values, or some inter-module
+		// communication will get broken (com_cl_running, etc)
+		if ( var->flags & ( CVAR_ROM | CVAR_INIT | CVAR_NORESTART ) ) {
+			prev = &var->next;
+			continue;
+		}
+
+		// throw out any variables the user created
+		if ( var->flags & CVAR_USER_CREATED ) {
+			*prev = var->next;
+			if ( var->name ) {
+				Cvar_FreeString( var->name );
+			}
+			if ( var->string ) {
+				Cvar_FreeString( var->string );
+			}
+			if ( var->latchedString ) {
+				Cvar_FreeString( var->latchedString );
+			}
+			if ( var->resetString ) {
+				Cvar_FreeString( var->resetString );
+			}
+			// clear the var completely, since we
+			// can't remove the index from the list
+			Com_Memset( var, 0, sizeof( var ) );
+			continue;
+		}
+
+		Cvar_Set( var->name, var->resetString );
+
+		prev = &var->next;
+	}
+}
+
+
+
+/*
+=====================
+Cvar_InfoString
+=====================
+*/
+char	*Cvar_InfoString( int bit ) {
+	static char	info[MAX_INFO_STRING];
+	cvar_t	*var;
+
+	info[0] = 0;
+
+	for (var = cvar_vars ; var ; var = var->next)
+	{
+		if (!(var->flags & CVAR_INTERNAL) &&
+			(var->flags & bit))
+		{
+			Info_SetValueForKey (info, var->name, var->string);
+		}
+	}
+
+	/*
+	for (var = cvar_vars ; var ; var = var->next)
+	{
+		if ((var->flags & CVAR_INTERNAL) &&
+			(var->flags & bit) &&
+			!Q_stricmp(var->name, "g_debugMelee"))
+		{ //this one must go first
+			Info_SetValueForKey (info, var->name, var->string);
+			kungFuSafety = true;
+			break;
+		}
+	}
+	if (!kungFuSafety)
+	{ //even if it was not found, it must be in the info string
+		Info_SetValueForKey (info, "g_debugMelee", "1");
+	}
+	*/
+
+	return info;
+}
+
+/*
+=====================
+Cvar_InfoString_Big
+
+  handles large info strings ( CS_SYSTEMINFO )
+=====================
+*/
+char	*Cvar_InfoString_Big( int bit ) {
+	static char	info[BIG_INFO_STRING];
+	cvar_t	*var;
+
+	info[0] = 0;
+
+	for (var = cvar_vars ; var ; var = var->next)
+	{
+		if (!(var->flags & CVAR_INTERNAL) &&
+			(var->flags & bit))
+		{
+			Info_SetValueForKey_Big (info, var->name, var->string);
+		}
+	}
+	return info;
+}
+
+
+
+/*
+=====================
+Cvar_InfoStringBuffer
+=====================
+*/
+void Cvar_InfoStringBuffer( int bit, char* buff, int buffsize ) {
+	Q_strncpyz(buff,Cvar_InfoString(bit),buffsize);
+}
+
+/*
+=====================
+Cvar_Register
+
+basically a slightly modified Cvar_Get for the interpreted modules
+=====================
+*/
+void	Cvar_Register( vmCvar_t *vmCvar, const char *varName, const char *defaultValue, int flags ) {
+	cvar_t	*cv;
+
+	cv = Cvar_Get( varName, defaultValue, flags );
+	if ( !vmCvar ) {
+		return;
+	}
+	vmCvar->handle = cv - cvar_indexes;
+	vmCvar->modificationCount = -1;
+	Cvar_Update( vmCvar );
+}
+
+
+/*
+=====================
+Cvar_Register
+
+updates an interpreted modules' version of a cvar
+=====================
+*/
+void	Cvar_Update( vmCvar_t *vmCvar ) {
+	cvar_t	*cv = NULL; // bk001129
+	assert(vmCvar); // bk
+
+	if ( (unsigned)vmCvar->handle >= cvar_numIndexes ) {
+		Com_Error( ERR_DROP, "Cvar_Update: handle out of range" );
+	}
+
+	cv = cvar_indexes + vmCvar->handle;
+
+	if ( cv->modificationCount == vmCvar->modificationCount ) {
+		return;
+	}
+	if ( !cv->string ) {
+		return;		// variable might have been cleared by a cvar_restart
+	}
+	vmCvar->modificationCount = cv->modificationCount;
+	// bk001129 - mismatches.
+	if ( strlen(cv->string)+1 > MAX_CVAR_VALUE_STRING ) 
+	  Com_Error( ERR_DROP, "Cvar_Update: src %s length %d exceeds MAX_CVAR_VALUE_STRING",
+		     cv->string, 
+		     strlen(cv->string), 
+		     sizeof(vmCvar->string) );
+	// bk001212 - Q_strncpyz guarantees zero padding and dest[MAX_CVAR_VALUE_STRING-1]==0 
+	// bk001129 - paranoia. Never trust the destination string.
+	// bk001129 - beware, sizeof(char*) is always 4 (for cv->string). 
+	//            sizeof(vmCvar->string) always MAX_CVAR_VALUE_STRING
+	//Q_strncpyz( vmCvar->string, cv->string, sizeof( vmCvar->string ) ); // id
+	Q_strncpyz( vmCvar->string, cv->string,  MAX_CVAR_VALUE_STRING ); 
+
+	vmCvar->value = cv->value;
+	vmCvar->integer = cv->integer;
+}
+
+
+/*
+============
+Cvar_Init
+
+Reads in all archived cvars
+============
+*/
+void Cvar_Init (void) {
+	cvar_cheats = Cvar_Get("sv_cheats", "0", CVAR_ROM | CVAR_SYSTEMINFO );
+
+	Cmd_AddCommand ("toggle", Cvar_Toggle_f);
+	Cmd_AddCommand ("set", Cvar_Set_f);
+	Cmd_AddCommand ("sets", Cvar_SetS_f);
+	Cmd_AddCommand ("setu", Cvar_SetU_f);
+	Cmd_AddCommand ("seta", Cvar_SetA_f);
+	Cmd_AddCommand ("reset", Cvar_Reset_f);
+	Cmd_AddCommand ("cvarlist", Cvar_List_f);
+	Cmd_AddCommand ("cvar_restart", Cvar_Restart_f);
+}
+
+
+static void Cvar_Realloc(char **string, char *memPool, int &memPoolUsed)
+{
+	if(string && *string)
+	{
+		char *temp = memPool + memPoolUsed;
+		strcpy(temp, *string);
+		memPoolUsed += strlen(*string) + 1;
+		Cvar_FreeString(*string);
+		*string = temp;
+	}
+}
+
+
+//Turns many small allocation blocks into one big one.
+void Cvar_Defrag(void)
+{
+	cvar_t	*var;
+	int totalMem = 0;
+	int nextMemPoolSize;
+	
+	for (var = cvar_vars; var; var = var->next)
+	{
+		if (var->name) {
+			totalMem += strlen(var->name) + 1;
+		}
+		if (var->string) {
+			totalMem += strlen(var->string) + 1;
+		}
+		if (var->resetString) {
+			totalMem += strlen(var->resetString) + 1;
+		}
+		if (var->latchedString) {
+			totalMem += strlen(var->latchedString) + 1;
+		}
+	}
+
+	char *mem = (char*)Z_Malloc(totalMem, TAG_SMALL, qfalse);
+	nextMemPoolSize = totalMem;
+	totalMem = 0;
+
+	for (var = cvar_vars; var; var = var->next)
+	{
+		Cvar_Realloc(&var->name, mem, totalMem);
+		Cvar_Realloc(&var->string, mem, totalMem);
+		Cvar_Realloc(&var->resetString, mem, totalMem);
+		Cvar_Realloc(&var->latchedString, mem, totalMem);
+	}
+
+	if(lastMemPool) {
+		Z_Free(lastMemPool);
+	}
+	lastMemPool = mem;
+	memPoolSize = nextMemPoolSize;
+}
+
diff --git a/codemp/qcommon/disablewarnings.h b/codemp/qcommon/disablewarnings.h
new file mode 100644
index 0000000..971ed5e
--- /dev/null
+++ b/codemp/qcommon/disablewarnings.h
@@ -0,0 +1,38 @@
+// hide these nasty warnings
+
+#ifdef _WIN32
+
+#pragma warning(disable : 4018)     // signed/unsigned mismatch
+#pragma warning(disable : 4032)
+#pragma warning(disable : 4051)
+#pragma warning(disable : 4057)		// slightly different base types
+#pragma warning(disable : 4100)		// unreferenced formal parameter
+#pragma warning(disable : 4115)
+#pragma warning(disable : 4125)		// decimal digit terminates octal escape sequence
+#pragma warning(disable : 4127)		// conditional expression is constant
+#pragma warning(disable : 4136)
+#pragma warning(disable : 4152)		// nonstandard extension, function/data pointer conversion in expression
+#pragma warning(disable : 4201)
+#pragma warning(disable : 4214)
+#pragma warning(disable : 4244)		// conversion from double to float
+#pragma warning(disable : 4284)		// return type not UDT
+#pragma warning(disable : 4305)		// truncation from const double to float
+#pragma warning(disable : 4310)		// cast truncates constant value
+#pragma warning(disable : 4389)		// signed/unsigned mismatch
+#pragma warning(disable : 4503)		// decorated name length truncated
+//#pragma warning(disable:  4505)!!!remove these to reduce vm size!! // unreferenced local function has been removed
+#pragma warning(disable : 4511)		//copy ctor could not be genned
+#pragma warning(disable : 4512)		//assignment op could not be genned
+#pragma warning(disable : 4514)		// unreffed inline removed
+#pragma warning(disable : 4663)		// c++ lang change
+#pragma warning(disable : 4702)		// unreachable code
+#pragma warning(disable : 4710)		// not inlined
+#pragma warning(disable : 4711)		// selected for automatic inline expansion
+#pragma warning(disable : 4220)		// varargs matches remaining parameters
+#pragma warning(disable : 4786)		//identifier was truncated
+
+//rww (for vc.net, warning numbers changed apparently):
+#pragma warning(disable : 4213)		//nonstandard extension used : cast on l-value
+#pragma warning(disable : 4245)		//signed/unsigned mismatch
+
+#endif
diff --git a/codemp/qcommon/exe_headers.cpp b/codemp/qcommon/exe_headers.cpp
new file mode 100644
index 0000000..e3f18c6
--- /dev/null
+++ b/codemp/qcommon/exe_headers.cpp
@@ -0,0 +1,3 @@
+//This file creates the PCH for the rest of the project to use
+
+#include "../qcommon/exe_headers.h"
diff --git a/codemp/qcommon/exe_headers.h b/codemp/qcommon/exe_headers.h
new file mode 100644
index 0000000..2655b29
--- /dev/null
+++ b/codemp/qcommon/exe_headers.h
@@ -0,0 +1,5 @@
+//This is shared by client and server so it's best to keep that in mind
+//for the sake of ds builds.
+
+#include "../game/q_shared.h"
+#include "../qcommon/qcommon.h"
diff --git a/codemp/qcommon/files.cpp b/codemp/qcommon/files.cpp
new file mode 100644
index 0000000..fc54025
--- /dev/null
+++ b/codemp/qcommon/files.cpp
@@ -0,0 +1,3614 @@
+/*****************************************************************************
+ * name:		files.c
+ *
+ * desc:		handle based filesystem for Quake III Arena 
+ *
+ * $Archive: /MissionPack/code/qcommon/files.c $
+ * $Author: Zaphod $ 
+ * $Revision: 81 $
+ * $Modtime: 5/30/01 2:31p $
+ * $Date: 5/30/01 2:31p $
+ *
+ *****************************************************************************/
+
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+#include "../client/client.h"
+#include "../zlib32/zip.h"
+#include "unzip.h"
+
+//#include <windows.h> //rww - included to make fs_copyfiles 2 related functions happy.
+#include "platform.h"
+
+/*
+=============================================================================
+
+QUAKE3 FILESYSTEM
+
+All of Quake's data access is through a hierarchical file system, but the contents of 
+the file system can be transparently merged from several sources.
+
+A "qpath" is a reference to game file data.  MAX_ZPATH is 256 characters, which must include
+a terminating zero. "..", "\\", and ":" are explicitly illegal in qpaths to prevent any
+references outside the quake directory system.
+
+The "base path" is the path to the directory holding all the game directories and usually
+the executable.  It defaults to ".", but can be overridden with a "+set fs_basepath c:\quake3"
+command line to allow code debugging in a different directory.  Basepath cannot
+be modified at all after startup.  Any files that are created (demos, screenshots,
+etc) will be created reletive to the base path, so base path should usually be writable.
+
+The "cd path" is the path to an alternate hierarchy that will be searched if a file
+is not located in the base path.  A user can do a partial install that copies some
+data to a base path created on their hard drive and leave the rest on the cd.  Files
+are never writen to the cd path.  It defaults to a value set by the installer, like
+"e:\quake3", but it can be overridden with "+set ds_cdpath g:\quake3".
+
+If a user runs the game directly from a CD, the base path would be on the CD.  This
+should still function correctly, but all file writes will fail (harmlessly).
+
+The "home path" is the path used for all write access. On win32 systems we have "base path"
+== "home path", but on *nix systems the base installation is usually readonly, and
+"home path" points to ~/.q3a or similar
+
+The user can also install custom mods and content in "home path", so it should be searched
+along with "home path" and "cd path" for game content.
+
+
+The "base game" is the directory under the paths where data comes from by default, and
+can be either "base" or "demo".
+
+The "current game" may be the same as the base game, or it may be the name of another
+directory under the paths that should be searched for files before looking in the base game.
+This is the basis for addons.
+
+Clients automatically set the game directory after receiving a gamestate from a server,
+so only servers need to worry about +set fs_game.
+
+No other directories outside of the base game and current game will ever be referenced by
+filesystem functions.
+
+To save disk space and speed loading, directory trees can be collapsed into zip files.
+The files use a ".pk3" extension to prevent users from unzipping them accidentally, but
+otherwise the are simply normal uncompressed zip files.  A game directory can have multiple
+zip files of the form "pak0.pk3", "pak1.pk3", etc.  Zip files are searched in decending order
+from the highest number to the lowest, and will always take precedence over the filesystem.
+This allows a pk3 distributed as a patch to override all existing data.
+
+Because we will have updated executables freely available online, there is no point to
+trying to restrict demo / oem versions of the game with code changes.  Demo / oem versions
+should be exactly the same executables as release versions, but with different data that
+automatically restricts where game media can come from to prevent add-ons from working.
+
+After the paths are initialized, quake will look for the product.txt file.  If not
+found and verified, the game will run in restricted mode.  In restricted mode, only 
+files contained in demoq3/pak0.pk3 will be available for loading, and only if the zip header is
+verified to not have been modified.  A single exception is made for jk2mpconfig.cfg.  Files
+can still be written out in restricted mode, so screenshots and demos are allowed.
+Restricted mode can be tested by setting "+set fs_restrict 1" on the command line, even
+if there is a valid product.txt under the basepath or cdpath.
+
+If not running in restricted mode, and a file is not found in any local filesystem,
+an attempt will be made to download it and save it under the base path.
+
+If the "fs_copyfiles" cvar is set to 1, then every time a file is sourced from the cd
+path, it will be copied over to the base path.  This is a development aid to help build
+test releases and to copy working sets over slow network links.
+(If set to 2, copying will only take place if the two filetimes are NOT EQUAL)
+
+File search order: when FS_FOpenFileRead gets called it will go through the fs_searchpaths
+structure and stop on the first successful hit. fs_searchpaths is built with successive
+calls to FS_AddGameDirectory
+
+Additionaly, we search in several subdirectories:
+current game is the current mode
+base game is a variable to allow mods based on other mods
+(such as base + missionpack content combination in a mod for instance)
+BASEGAME is the hardcoded base game ("base")
+
+e.g. the qpath "sound/newstuff/test.wav" would be searched for in the following places:
+
+home path + current game's zip files
+home path + current game's directory
+base path + current game's zip files
+base path + current game's directory
+cd path + current game's zip files
+cd path + current game's directory
+
+home path + base game's zip file
+home path + base game's directory
+base path + base game's zip file
+base path + base game's directory
+cd path + base game's zip file
+cd path + base game's directory
+
+home path + BASEGAME's zip file
+home path + BASEGAME's directory
+base path + BASEGAME's zip file
+base path + BASEGAME's directory
+cd path + BASEGAME's zip file
+cd path + BASEGAME's directory
+
+server download, to be written to home path + current game's directory
+
+
+The filesystem can be safely shutdown and reinitialized with different
+basedir / cddir / game combinations, but all other subsystems that rely on it
+(sound, video) must also be forced to restart.
+
+Because the same files are loaded by both the clip model (CM_) and renderer (TR_)
+subsystems, a simple single-file caching scheme is used.  The CM_ subsystems will
+load the file with a request to cache.  Only one file will be kept cached at a time,
+so any models that are going to be referenced by both subsystems should alternate
+between the CM_ load function and the ref load function.
+
+TODO: A qpath that starts with a leading slash will always refer to the base game, even if another
+game is currently active.  This allows character models, skins, and sounds to be downloaded
+to a common directory no matter which game is active.
+
+How to prevent downloading zip files?
+Pass pk3 file names in systeminfo, and download before FS_Restart()?
+
+Aborting a download disconnects the client from the server.
+
+How to mark files as downloadable?  Commercial add-ons won't be downloadable.
+
+Non-commercial downloads will want to download the entire zip file.
+the game would have to be reset to actually read the zip in
+
+Auto-update information
+
+Path separators
+
+Casing
+
+  separate server gamedir and client gamedir, so if the user starts
+  a local game after having connected to a network game, it won't stick
+  with the network game.
+
+  allow menu options for game selection?
+
+Read / write config to floppy option.
+
+Different version coexistance?
+
+When building a pak file, make sure a jk2mpconfig.cfg isn't present in it,
+or configs will never get loaded from disk!
+
+  todo:
+
+  downloading (outside fs?)
+  game directory passing and restarting
+
+=============================================================================
+
+*/
+
+#define	BASEGAME			"base"
+#define	DEMOGAME			"demo"
+
+// every time a new demo pk3 file is built, this checksum must be updated.
+// the easiest way to get it is to just run the game and see what it spits out
+#define	DEMO_PAK_CHECKSUM	437558517u
+
+// if this is defined, the executable positively won't work with any paks other
+// than the demo pak, even if productid is present.  This is only used for our
+// last demo release to prevent the mac and linux users from using the demo
+// executable with the production windows pak before the mac/linux products
+// hit the shelves a little later
+// NOW defined in build files
+//#define PRE_RELEASE_TADEMO
+
+#define MAX_ZPATH			256
+#define	MAX_SEARCH_PATHS	4096
+#define MAX_FILEHASH_SIZE	1024
+
+typedef struct fileInPack_s {
+	char					*name;		// name of the file
+	unsigned long			pos;		// file info position in zip
+	struct	fileInPack_s*	next;		// next file in the hash
+} fileInPack_t;
+
+typedef struct {
+	char			pakFilename[MAX_OSPATH];	// c:\quake3\base\pak0.pk3
+	char			pakBasename[MAX_OSPATH];	// pak0
+	char			pakGamename[MAX_OSPATH];	// base
+	unzFile			handle;						// handle to zip file
+	int				checksum;					// regular checksum
+	int				pure_checksum;				// checksum for pure
+	int				numfiles;					// number of files in pk3
+	int				referenced;					// referenced file flags
+	int				hashSize;					// hash table size (power of 2)
+	fileInPack_t*	*hashTable;					// hash table
+	fileInPack_t*	buildBuffer;				// buffer with the filenames etc.
+} pack_t;
+
+typedef struct {
+	char		path[MAX_OSPATH];		// c:\jk2
+	char		gamedir[MAX_OSPATH];	// base
+} directory_t;
+
+typedef struct searchpath_s {
+	struct searchpath_s *next;
+
+	pack_t		*pack;		// only one of pack / dir will be non NULL
+	directory_t	*dir;
+} searchpath_t;
+
+static	char		fs_gamedir[MAX_OSPATH];	// this will be a single file name with no separators
+static	cvar_t		*fs_debug;
+static	cvar_t		*fs_homepath;
+static	cvar_t		*fs_basepath;
+static	cvar_t		*fs_basegame;
+static	cvar_t		*fs_cdpath;
+static	cvar_t		*fs_copyfiles;
+/*static*/ cvar_t	*fs_gamedirvar;
+static	cvar_t		*fs_restrict;
+static	cvar_t		*fs_dirbeforepak; //rww - when building search path, keep directories at top and insert pk3's under them
+static	searchpath_t	*fs_searchpaths;
+static	int			fs_readCount;			// total bytes read
+static	int			fs_loadCount;			// total files read
+static	int			fs_loadStack;			// total files in memory
+static	int			fs_packFiles;			// total number of files in packs
+
+static int fs_fakeChkSum;
+static int fs_checksumFeed;
+
+typedef union qfile_gus {
+	FILE*		o;
+	unzFile		z;
+} qfile_gut;
+
+typedef struct qfile_us {
+	qfile_gut	file;
+	qboolean	unique;
+} qfile_ut;
+
+typedef struct {
+	qfile_ut	handleFiles;
+	qboolean	handleSync;
+	int			baseOffset;
+	int			fileSize;
+	int			zipFilePos;
+	qboolean	zipFile;
+	qboolean	streamed;
+	char		name[MAX_ZPATH];
+} fileHandleData_t;
+
+static fileHandleData_t	fsh[MAX_FILE_HANDLES];
+
+// never load anything from pk3 files that are not present at the server when pure
+static int		fs_numServerPaks;
+static int		fs_serverPaks[MAX_SEARCH_PATHS];				// checksums
+static char		*fs_serverPakNames[MAX_SEARCH_PATHS];			// pk3 names
+
+// only used for autodownload, to make sure the client has at least
+// all the pk3 files that are referenced at the server side
+static int		fs_numServerReferencedPaks;
+static int		fs_serverReferencedPaks[MAX_SEARCH_PATHS];			// checksums
+static char		*fs_serverReferencedPakNames[MAX_SEARCH_PATHS];		// pk3 names
+
+// last valid game folder used
+char lastValidBase[MAX_OSPATH];
+char lastValidGame[MAX_OSPATH];
+
+// productId: This file is copyright 2000 Raven Software, and may not be duplicated except during a licensed installation of the full commercial version of Star Wars: Jedi Outcast
+static byte fs_scrambledProductId[165] = {
+ 42, 143, 149, 190,  10, 197, 225, 133, 243,  63, 189, 182, 226,  56, 143,  17, 215,  37, 197, 218,  50, 103,  24, 235, 246, 191, 180, 149, 160, 170, 230,
+ 52, 176, 231,  15, 194, 236, 247, 159, 168, 132, 154,  24, 133,  67,  85,  36,  97,  99,  86, 117, 189, 212, 156, 236, 153,  68,  10, 196, 241,  39,
+219, 156,  88,  93, 198, 200, 232, 142,  67,  45, 209,  53, 186, 228, 241, 162, 127, 213,  83,   7, 121,  11,  93, 123, 243, 148, 240, 229,  42,  42,
+  6, 215, 239, 112, 120, 240, 244, 104,  12,  38,  47, 201, 253, 223, 208, 154,  69, 141, 157,  32, 117, 166, 146, 236,  59,  15, 223,  52,  89, 133,
+ 64, 201,  56, 119,  25, 211, 152, 159,  11,  92,  59, 207,  81, 123,   0, 121, 241, 116,  42,  36, 251,  51, 149,  79, 165,  12, 106, 187, 225, 203,
+ 99, 102,  69,  97,  81,  27, 107,  95, 164,  42,  36, 189,  94, 126
+};
+
+#ifdef FS_MISSING
+FILE*		missingFiles = NULL;
+#endif
+
+/*
+==============
+FS_Initialized
+==============
+*/
+
+qboolean FS_Initialized() {
+	return (qboolean)(fs_searchpaths != NULL);
+}
+
+/*
+=================
+FS_PakIsPure
+=================
+*/
+qboolean FS_PakIsPure( pack_t *pack ) {
+	int i;
+
+	if ( fs_numServerPaks ) {
+    // NOTE TTimo we are matching checksums without checking the pak names
+    //   this means you can have the same pk3 as the server under a different name, you will still get through sv_pure validation
+    //   (what happens when two pk3's have the same checkums? is it a likely situation?)
+    //   also, if there's a wrong checksumed pk3 and autodownload is enabled, the checksum will be appended to the downloaded pk3 name
+		for ( i = 0 ; i < fs_numServerPaks ; i++ ) {
+			// FIXME: also use hashed file names
+			if ( pack->checksum == fs_serverPaks[i] ) {
+				return qtrue;		// on the aproved list
+			}
+		}
+		return qfalse;	// not on the pure server pak list
+	}
+	return qtrue;
+}
+
+
+/*
+=================
+FS_LoadStack
+return load stack
+=================
+*/
+int FS_LoadStack()
+{
+	return fs_loadStack;
+}
+                      
+/*
+================
+return a hash value for the filename
+================
+*/
+static long FS_HashFileName( const char *fname, int hashSize ) {
+	int		i;
+	long	hash;
+	char	letter;
+
+	hash = 0;
+	i = 0;
+	while (fname[i] != '\0') {
+		letter = tolower(fname[i]);
+		if (letter =='.') break;				// don't include extension
+		if (letter =='\\') letter = '/';		// damn path names
+		if (letter == PATH_SEP) letter = '/';		// damn path names
+		hash+=(long)(letter)*(i+119);
+		i++;
+	}
+	hash = (hash ^ (hash >> 10) ^ (hash >> 20));
+	hash &= (hashSize-1);
+	return hash;
+}
+
+static fileHandle_t	FS_HandleForFile(void) {
+	int		i;
+
+	for ( i = 1 ; i < MAX_FILE_HANDLES ; i++ ) {
+		if ( fsh[i].handleFiles.file.o == NULL ) {
+			return i;
+		}
+	}
+	Com_Error( ERR_DROP, "FS_HandleForFile: none free" );
+	return 0;
+}
+
+static FILE	*FS_FileForHandle( fileHandle_t f ) {
+	if ( f < 0 || f > MAX_FILE_HANDLES ) {
+		Com_Error( ERR_DROP, "FS_FileForHandle: out of reange" );
+	}
+	if (fsh[f].zipFile == qtrue) {
+		Com_Error( ERR_DROP, "FS_FileForHandle: can't get FILE on zip file" );
+	}
+	if ( ! fsh[f].handleFiles.file.o ) {
+		Com_Error( ERR_DROP, "FS_FileForHandle: NULL" );
+	}
+	
+	return fsh[f].handleFiles.file.o;
+}
+
+void	FS_ForceFlush( fileHandle_t f ) {
+	FILE *file;
+
+	file = FS_FileForHandle(f);
+	setvbuf( file, NULL, _IONBF, 0 );
+}
+
+/*
+================
+FS_filelength
+
+If this is called on a non-unique FILE (from a pak file),
+it will return the size of the pak file, not the expected
+size of the file.
+================
+*/
+int FS_filelength( fileHandle_t f ) {
+	int		pos;
+	int		end;
+	FILE*	h;
+
+	h = FS_FileForHandle(f);
+	pos = ftell (h);
+	fseek (h, 0, SEEK_END);
+	end = ftell (h);
+	fseek (h, pos, SEEK_SET);
+
+	return end;
+}
+
+/*
+====================
+FS_ReplaceSeparators
+
+Fix things up differently for win/unix/mac
+====================
+*/
+static void FS_ReplaceSeparators( char *path ) {
+	char	*s;
+
+	for ( s = path ; *s ; s++ ) {
+		if ( *s == '/' || *s == '\\' ) {
+			*s = PATH_SEP;
+		}
+	}
+}
+
+/*
+===================
+FS_BuildOSPath
+
+Qpath may have either forward or backwards slashes
+===================
+*/
+
+char *FS_BuildOSPath( const char *qpath )
+{
+	char	temp[MAX_OSPATH];
+	static char ospath[2][MAX_OSPATH];
+	static int toggle;
+	
+	toggle ^= 1;		// flip-flop to allow two returns without clash
+
+	Com_sprintf( temp, sizeof(temp), "/%s/%s", fs_gamedirvar->string, qpath );
+
+	FS_ReplaceSeparators( temp );	
+	Com_sprintf( ospath[toggle], sizeof( ospath[0] ), "%s%s", 
+		fs_basepath->string, temp );
+	
+	return ospath[toggle];
+}
+
+char *FS_BuildOSPath( const char *base, const char *game, const char *qpath ) {
+	char	temp[MAX_OSPATH];
+	static char ospath[4][MAX_OSPATH];
+	static int toggle;
+	
+	//pre-fs_cf2
+	//toggle ^= 1;		// flip-flop to allow two returns without clash
+	//post-fs_cf2
+	toggle = (++toggle)&3;	// allows four returns without clash (increased from 2 during fs_copyfiles 2 enhancement)
+
+	if( !game || !game[0] ) {
+		game = fs_gamedir;
+	}
+
+	Com_sprintf( temp, sizeof(temp), "/%s/%s", game, qpath );
+	FS_ReplaceSeparators( temp );	
+	Com_sprintf( ospath[toggle], sizeof( ospath[0] ), "%s%s", base, temp );
+	
+	return ospath[toggle];
+}
+
+
+/*
+============
+FS_CreatePath
+
+Creates any directories needed to store the given filename
+============
+*/
+static qboolean FS_CreatePath (char *OSPath) {
+	char	*ofs;
+	
+	// make absolutely sure that it can't back up the path
+	// FIXME: is c: allowed???
+	if ( strstr( OSPath, ".." ) || strstr( OSPath, "::" ) ) {
+		Com_Printf( "WARNING: refusing to create relative path \"%s\"\n", OSPath );
+		return qtrue;
+	}
+
+	for (ofs = OSPath+1 ; *ofs ; ofs++) {
+		if (*ofs == PATH_SEP) {	
+			// create the directory
+			*ofs = 0;
+			Sys_Mkdir (OSPath);
+			*ofs = PATH_SEP;
+		}
+	}
+	return qfalse;
+}
+
+/*
+=================
+FS_CopyFile
+
+Copy a fully specified file from one place to another
+=================
+*/
+static void FS_CopyFile( char *fromOSPath, char *toOSPath ) {
+	FILE	*f;
+	int		len;
+	byte	*buf;
+
+	Com_Printf( "copy %s to %s\n", fromOSPath, toOSPath );
+
+	if (strstr(fromOSPath, "journal.dat") || strstr(fromOSPath, "journaldata.dat")) {
+		Com_Printf( "Ignoring journal files\n");
+		return;
+	}
+
+	f = fopen( fromOSPath, "rb" );
+	if ( !f ) {
+		return;
+	}
+	fseek (f, 0, SEEK_END);
+	len = ftell (f);
+	fseek (f, 0, SEEK_SET);
+
+	// we are using direct malloc instead of Z_Malloc here, so it
+	// probably won't work on a mac... Its only for developers anyway...
+	buf = (unsigned char *)malloc( len );
+	if (fread( buf, 1, len, f ) != len)
+		Com_Error( ERR_FATAL, "Short read in FS_Copyfiles()\n" );
+	fclose( f );
+
+	if( FS_CreatePath( toOSPath ) ) {
+		return;
+	}
+
+	f = fopen( toOSPath, "wb" );
+	if ( !f ) {
+		return;
+	}
+	if (fwrite( buf, 1, len, f ) != len)
+		Com_Error( ERR_FATAL, "Short write in FS_Copyfiles()\n" );
+	fclose( f );
+	free( buf );
+}
+
+/*
+===========
+FS_Remove
+
+===========
+*/
+static void FS_Remove( const char *osPath ) {
+	remove( osPath );
+}
+
+/*
+================
+FS_FileExists
+
+Tests if the file exists in the current gamedir, this DOES NOT
+search the paths.  This is to determine if opening a file to write
+(which always goes into the current gamedir) will cause any overwrites.
+NOTE TTimo: this goes with FS_FOpenFileWrite for opening the file afterwards
+================
+*/
+qboolean FS_FileExists( const char *file )
+{
+	FILE *f;
+	char *testpath;
+
+	testpath = FS_BuildOSPath( fs_homepath->string, fs_gamedir, file );
+
+	f = fopen( testpath, "rb" );
+	if (f) {
+		fclose( f );
+		return qtrue;
+	}
+	return qfalse;
+}
+
+/*
+================
+FS_SV_FileExists
+
+Tests if the file exists 
+================
+*/
+qboolean FS_SV_FileExists( const char *file )
+{
+	FILE *f;
+	char *testpath;
+
+	testpath = FS_BuildOSPath( fs_homepath->string, file, "");
+	testpath[strlen(testpath)-1] = '\0';
+
+	f = fopen( testpath, "rb" );
+	if (f) {
+		fclose( f );
+		return qtrue;
+	}
+	return qfalse;
+}
+
+
+/*
+===========
+FS_SV_FOpenFileWrite
+
+===========
+*/
+fileHandle_t FS_SV_FOpenFileWrite( const char *filename ) {
+	char *ospath;
+	fileHandle_t	f;
+
+	if ( !fs_searchpaths ) {
+		Com_Error( ERR_FATAL, "Filesystem call made without initialization\n" );
+	}
+
+	ospath = FS_BuildOSPath( fs_homepath->string, filename, "" );
+	ospath[strlen(ospath)-1] = '\0';
+
+	f = FS_HandleForFile();
+	fsh[f].zipFile = qfalse;
+
+	if ( fs_debug->integer ) {
+		Com_Printf( "FS_SV_FOpenFileWrite: %s\n", ospath );
+	}
+
+	if( FS_CreatePath( ospath ) ) {
+		return 0;
+	}
+
+	Com_DPrintf( "writing to: %s\n", ospath );
+	fsh[f].handleFiles.file.o = fopen( ospath, "wb" );
+
+	Q_strncpyz( fsh[f].name, filename, sizeof( fsh[f].name ) );
+
+	fsh[f].handleSync = qfalse;
+	if (!fsh[f].handleFiles.file.o) {
+		f = 0;
+	}
+	return f;
+}
+
+/*
+===========
+FS_SV_FOpenFileRead
+search for a file somewhere below the home path, base path or cd path
+we search in that order, matching FS_SV_FOpenFileRead order
+===========
+*/
+int FS_SV_FOpenFileRead( const char *filename, fileHandle_t *fp ) {
+	char *ospath;
+	fileHandle_t	f = 0; // bk001129 - from cvs1.17
+
+	if ( !fs_searchpaths ) {
+		Com_Error( ERR_FATAL, "Filesystem call made without initialization\n" );
+	}
+
+	f = FS_HandleForFile();
+	fsh[f].zipFile = qfalse;
+
+	Q_strncpyz( fsh[f].name, filename, sizeof( fsh[f].name ) );
+
+	// don't let sound stutter
+	S_ClearSoundBuffer();
+
+  // search homepath
+	ospath = FS_BuildOSPath( fs_homepath->string, filename, "" );
+	// remove trailing slash
+	ospath[strlen(ospath)-1] = '\0';
+
+	if ( fs_debug->integer ) {
+		Com_Printf( "FS_SV_FOpenFileRead (fs_homepath): %s\n", ospath );
+	}
+
+	fsh[f].handleFiles.file.o = fopen( ospath, "rb" );
+	fsh[f].handleSync = qfalse;
+  if (!fsh[f].handleFiles.file.o)
+  {
+    // NOTE TTimo on non *nix systems, fs_homepath == fs_basepath, might want to avoid
+    if (Q_stricmp(fs_homepath->string,fs_basepath->string))
+    {
+      // search basepath
+      ospath = FS_BuildOSPath( fs_basepath->string, filename, "" );
+      ospath[strlen(ospath)-1] = '\0';
+
+      if ( fs_debug->integer )
+      {
+        Com_Printf( "FS_SV_FOpenFileRead (fs_basepath): %s\n", ospath );
+      }
+
+      fsh[f].handleFiles.file.o = fopen( ospath, "rb" );
+      fsh[f].handleSync = qfalse;
+
+      if ( !fsh[f].handleFiles.file.o )
+      {
+        f = 0;
+      }
+    }
+  }
+
+	if (!fsh[f].handleFiles.file.o) {
+    // search cd path
+    ospath = FS_BuildOSPath( fs_cdpath->string, filename, "" );
+    ospath[strlen(ospath)-1] = '\0';
+
+    if (fs_debug->integer)
+    {
+      Com_Printf( "FS_SV_FOpenFileRead (fs_cdpath) : %s\n", ospath );
+    }
+
+	  fsh[f].handleFiles.file.o = fopen( ospath, "rb" );
+	  fsh[f].handleSync = qfalse;
+
+	  if( !fsh[f].handleFiles.file.o ) {
+	    f = 0;
+	  }
+  }
+  
+	*fp = f;
+	if (f) {
+		return FS_filelength(f);
+	}
+	return 0;
+}
+
+
+/*
+===========
+FS_SV_Rename
+
+===========
+*/
+void FS_SV_Rename( const char *from, const char *to ) {
+	char			*from_ospath, *to_ospath;
+
+	if ( !fs_searchpaths ) {
+		Com_Error( ERR_FATAL, "Filesystem call made without initialization\n" );
+	}
+
+	// don't let sound stutter
+	S_ClearSoundBuffer();
+
+	from_ospath = FS_BuildOSPath( fs_homepath->string, from, "" );
+	to_ospath = FS_BuildOSPath( fs_homepath->string, to, "" );
+	from_ospath[strlen(from_ospath)-1] = '\0';
+	to_ospath[strlen(to_ospath)-1] = '\0';
+
+	if ( fs_debug->integer ) {
+		Com_Printf( "FS_SV_Rename: %s --> %s\n", from_ospath, to_ospath );
+	}
+
+	if (rename( from_ospath, to_ospath )) {
+		// Failed, try copying it and deleting the original
+		FS_CopyFile ( from_ospath, to_ospath );
+		FS_Remove ( from_ospath );
+	}
+}
+
+
+
+/*
+===========
+FS_Rename
+
+===========
+*/
+void FS_Rename( const char *from, const char *to ) {
+	char			*from_ospath, *to_ospath;
+
+	if ( !fs_searchpaths ) {
+		Com_Error( ERR_FATAL, "Filesystem call made without initialization\n" );
+	}
+
+	// don't let sound stutter
+	S_ClearSoundBuffer();
+
+	from_ospath = FS_BuildOSPath( fs_homepath->string, fs_gamedir, from );
+	to_ospath = FS_BuildOSPath( fs_homepath->string, fs_gamedir, to );
+
+	if ( fs_debug->integer ) {
+		Com_Printf( "FS_Rename: %s --> %s\n", from_ospath, to_ospath );
+	}
+
+	if (rename( from_ospath, to_ospath )) {
+		// Failed, try copying it and deleting the original
+		FS_CopyFile ( from_ospath, to_ospath );
+		FS_Remove ( from_ospath );
+	}
+}
+
+/*
+==============
+FS_FCloseFile
+
+If the FILE pointer is an open pak file, leave it open.
+
+For some reason, other dll's can't just cal fclose()
+on files returned by FS_FOpenFile...
+==============
+*/
+void FS_FCloseFile( fileHandle_t f ) {
+	if ( !fs_searchpaths ) {
+		Com_Error( ERR_FATAL, "Filesystem call made without initialization\n" );
+	}
+
+	if (fsh[f].streamed) {
+		Sys_EndStreamedFile(f);
+	}
+	if (fsh[f].zipFile == qtrue) {
+		unzCloseCurrentFile( fsh[f].handleFiles.file.z );
+		if ( fsh[f].handleFiles.unique ) {
+			unzClose( fsh[f].handleFiles.file.z );
+		}
+		Com_Memset( &fsh[f], 0, sizeof( fsh[f] ) );
+		return;
+	}
+
+	// we didn't find it as a pak, so close it as a unique file
+	if (fsh[f].handleFiles.file.o) {
+		fclose (fsh[f].handleFiles.file.o);
+	}
+	Com_Memset( &fsh[f], 0, sizeof( fsh[f] ) );
+}
+
+/*
+===========
+FS_FOpenFileWrite
+
+===========
+*/
+fileHandle_t FS_FOpenFileWrite( const char *filename ) {
+	char			*ospath;
+	fileHandle_t	f;
+
+	if ( !fs_searchpaths ) {
+		Com_Error( ERR_FATAL, "Filesystem call made without initialization\n" );
+	}
+
+	f = FS_HandleForFile();
+	fsh[f].zipFile = qfalse;
+
+	ospath = FS_BuildOSPath( fs_homepath->string, fs_gamedir, filename );
+
+	if ( fs_debug->integer ) {
+		Com_Printf( "FS_FOpenFileWrite: %s\n", ospath );
+	}
+
+	if( FS_CreatePath( ospath ) ) {
+		return 0;
+	}
+
+	// enabling the following line causes a recursive function call loop
+	// when running with +set logfile 1 +set developer 1
+	//Com_DPrintf( "writing to: %s\n", ospath );
+	fsh[f].handleFiles.file.o = fopen( ospath, "wb" );
+
+	Q_strncpyz( fsh[f].name, filename, sizeof( fsh[f].name ) );
+
+	fsh[f].handleSync = qfalse;
+	if (!fsh[f].handleFiles.file.o) {
+		f = 0;
+	}
+	return f;
+}
+
+/*
+===========
+FS_FOpenFileAppend
+
+===========
+*/
+fileHandle_t FS_FOpenFileAppend( const char *filename ) {
+	char			*ospath;
+	fileHandle_t	f;
+
+	if ( !fs_searchpaths ) {
+		Com_Error( ERR_FATAL, "Filesystem call made without initialization\n" );
+	}
+
+	f = FS_HandleForFile();
+	fsh[f].zipFile = qfalse;
+
+	Q_strncpyz( fsh[f].name, filename, sizeof( fsh[f].name ) );
+
+	// don't let sound stutter
+	S_ClearSoundBuffer();
+
+	ospath = FS_BuildOSPath( fs_homepath->string, fs_gamedir, filename );
+
+	if ( fs_debug->integer ) {
+		Com_Printf( "FS_FOpenFileAppend: %s\n", ospath );
+	}
+
+	if( FS_CreatePath( ospath ) ) {
+		return 0;
+	}
+
+	fsh[f].handleFiles.file.o = fopen( ospath, "ab" );
+	fsh[f].handleSync = qfalse;
+	if (!fsh[f].handleFiles.file.o) {
+		f = 0;
+	}
+	return f;
+}
+
+/*
+===========
+FS_FilenameCompare
+
+Ignore case and seprator char distinctions
+===========
+*/
+qboolean FS_FilenameCompare( const char *s1, const char *s2 ) {
+	int		c1, c2;
+	
+	do {
+		c1 = *s1++;
+		c2 = *s2++;
+
+		if (c1 >= 'a' && c1 <= 'z') {
+			c1 -= ('a' - 'A');
+		}
+		if (c2 >= 'a' && c2 <= 'z') {
+			c2 -= ('a' - 'A');
+		}
+
+		if ( c1 == '\\' || c1 == ':' ) {
+			c1 = '/';
+		}
+		if ( c2 == '\\' || c2 == ':' ) {
+			c2 = '/';
+		}
+		
+		if (c1 != c2) {
+			return (qboolean)-1;		// strings not equal
+		}
+	} while (c1);
+	
+	return (qboolean)0;		// strings are equal
+}
+
+static bool Sys_GetFileTime(LPCSTR psFileName, FILETIME &ft)
+{
+	bool bSuccess = false;
+	HANDLE hFile = INVALID_HANDLE_VALUE;	
+
+	hFile = CreateFile(	psFileName,	// LPCTSTR lpFileName,          // pointer to name of the file
+						GENERIC_READ,			// DWORD dwDesiredAccess,       // access (read-write) mode
+						FILE_SHARE_READ,		// DWORD dwShareMode,           // share mode
+						NULL,					// LPSECURITY_ATTRIBUTES lpSecurityAttributes,	// pointer to security attributes
+						OPEN_EXISTING,			// DWORD dwCreationDisposition,  // how to create
+						FILE_FLAG_NO_BUFFERING,// DWORD dwFlagsAndAttributes,   // file attributes
+						NULL					// HANDLE hTemplateFile          // handle to file with attributes to 
+						);
+
+	if (hFile != INVALID_HANDLE_VALUE)
+	{			
+		if (GetFileTime(hFile,	// handle to file
+						NULL,	// LPFILETIME lpCreationTime
+						NULL,	// LPFILETIME lpLastAccessTime
+						&ft		// LPFILETIME lpLastWriteTime
+						)
+			)
+		{
+			bSuccess = true;
+		}
+
+		CloseHandle(hFile);
+	}
+
+	return bSuccess;
+}
+
+static bool Sys_FileOutOfDate( LPCSTR psFinalFileName /* dest */, LPCSTR psDataFileName /* src */ )
+{
+	FILETIME ftFinalFile, ftDataFile;
+
+	if (Sys_GetFileTime(psFinalFileName, ftFinalFile) && Sys_GetFileTime(psDataFileName, ftDataFile))
+	{
+		// timer res only accurate to within 2 seconds on FAT, so can't do exact compare...
+		//
+		//LONG l = CompareFileTime( &ftFinalFile, &ftDataFile );
+		if (  (abs(ftFinalFile.dwLowDateTime - ftDataFile.dwLowDateTime) <= 20000000 ) &&
+				  ftFinalFile.dwHighDateTime == ftDataFile.dwHighDateTime				
+			)
+		{
+			return false;	// file not out of date, ie use it.
+		}
+		return true;	// flag return code to copy over a replacement version of this file
+	}
+
+
+	// extra error check, report as suspicious if you find a file locally but not out on the net.,.
+	//
+	if (com_developer->integer)
+	{
+		if (!Sys_GetFileTime(psDataFileName, ftDataFile))
+		{
+			Com_Printf( "Sys_FileOutOfDate: reading %s but it's not on the net!\n", psFinalFileName);
+		}
+	}
+
+	return false;
+}
+					
+static bool FS_FileCacheable(const char* const filename) 
+{
+	return( strchr(filename, '/') && strnicmp(filename, "ext_data/", 9) );
+}
+
+/*
+===========
+FS_ShiftedStrStr
+===========
+*/
+char *FS_ShiftedStrStr(const char *string, const char *substring, int shift) {
+	char buf[MAX_STRING_TOKENS];
+	int i;
+
+	for (i = 0; substring[i]; i++) {
+		buf[i] = substring[i] + shift;
+	}
+	buf[i] = '\0';
+	return strstr(string, buf);
+}
+
+/*
+===========
+FS_FOpenFileRead
+
+Finds the file in the search path.
+Returns filesize and an open FILE pointer.
+Used for streaming data out of either a
+separate file or a ZIP file.
+===========
+*/
+extern qboolean		com_fullyInitialized;
+
+int FS_FOpenFileRead( const char *filename, fileHandle_t *file, qboolean uniqueFILE ) {
+	searchpath_t	*search;
+	char			*netpath;
+	pack_t			*pak;
+	fileInPack_t	*pakFile;
+	directory_t		*dir;
+	long			hash;
+	unz_s			*zfi;
+	ZIP_FILE		*temp;
+	int				l;
+	char demoExt[16];
+
+	hash = 0;
+
+	if ( !fs_searchpaths ) {
+		Com_Error( ERR_FATAL, "Filesystem call made without initialization\n" );
+	}
+
+	if ( file == NULL ) {
+		Com_Error( ERR_FATAL, "FS_FOpenFileRead: NULL 'file' parameter passed\n" );
+	}
+
+	if ( !filename ) {
+		Com_Error( ERR_FATAL, "FS_FOpenFileRead: NULL 'filename' parameter passed\n" );
+	}
+
+	Com_sprintf (demoExt, sizeof(demoExt), ".dm_%d",PROTOCOL_VERSION );
+	// qpaths are not supposed to have a leading slash
+	if ( filename[0] == '/' || filename[0] == '\\' ) {
+		filename++;
+	}
+
+	// make absolutely sure that it can't back up the path.
+	// The searchpaths do guarantee that something will always
+	// be prepended, so we don't need to worry about "c:" or "//limbo" 
+	if ( strstr( filename, ".." ) || strstr( filename, "::" ) ) {
+		*file = 0;
+		return -1;
+	}
+
+	// make sure the q3key file is only readable by the quake3.exe at initialization
+	// any other time the key should only be accessed in memory using the provided functions
+	if( com_fullyInitialized && strstr( filename, "q3key" ) ) {
+		*file = 0;
+		return -1;
+	}
+
+	//
+	// search through the path, one element at a time
+	//
+
+	*file = FS_HandleForFile();
+	fsh[*file].handleFiles.unique = uniqueFILE;
+
+	// this new bool is in for an optimisation, if you (eg) opened a BSP file under fs_copyfiles==2,
+	//	then it triggered a copy operation to update your local HD version, then this will re-open the
+	//	file handle on your local version, not the net build. This uses a bit more CPU to re-do the loop
+	//	logic, but should read faster than accessing the net version a second time.
+	//
+	qboolean bFasterToReOpenUsingNewLocalFile = qfalse;
+
+	do
+	{
+		bFasterToReOpenUsingNewLocalFile = qfalse;
+
+		for ( search = fs_searchpaths ; search ; search = search->next ) {
+			//
+			if ( search->pack ) {
+				hash = FS_HashFileName(filename, search->pack->hashSize);
+			}
+			// is the element a pak file?
+			if ( search->pack && search->pack->hashTable[hash] ) {
+				// disregard if it doesn't match one of the allowed pure pak files
+				if ( !FS_PakIsPure(search->pack) ) {
+					continue;
+				}
+
+				// look through all the pak file elements
+				pak = search->pack;
+				pakFile = pak->hashTable[hash];
+				do {
+					// case and separator insensitive comparisons
+					if ( !FS_FilenameCompare( pakFile->name, filename ) ) {
+						// found it!
+
+						// mark the pak as having been referenced and mark specifics on cgame and ui
+						// shaders, txt, arena files  by themselves do not count as a reference as 
+						// these are loaded from all pk3s 
+						// from every pk3 file.. 
+						l = strlen( filename );
+						if ( !(pak->referenced & FS_GENERAL_REF)) {
+							if ( Q_stricmp(filename + l - 7, ".shader") != 0 &&
+								Q_stricmp(filename + l - 4, ".txt") != 0 &&
+								Q_stricmp(filename + l - 4, ".cfg") != 0 &&
+								Q_stricmp(filename + l - 4, ".fcf") != 0 &&
+								Q_stricmp(filename + l - 7, ".config") != 0 &&
+								strstr(filename, "levelshots") == NULL &&
+								Q_stricmp(filename + l - 4, ".bot") != 0 &&
+								Q_stricmp(filename + l - 6, ".arena") != 0 &&
+								Q_stricmp(filename + l - 5, ".menu") != 0) {
+								pak->referenced |= FS_GENERAL_REF;
+							}
+						}
+
+						/*
+						FS_ShiftedStrStr(filename, "jk2mpgamex86.dll", -13);
+												  //]^%`cZT`Xk+)!W__
+						FS_ShiftedStrStr(filename, "cgamex86.dll", -7);
+												  //\`Zf^q1/']ee
+						FS_ShiftedStrStr(filename, "uix86.dll", -5);
+												  //pds31)_gg
+						*/
+
+						// jk2mpgame.qvm	- 13
+						// ]^%`cZT`X!di`
+						if (!(pak->referenced & FS_QAGAME_REF))
+						{
+							if (FS_ShiftedStrStr(filename, "]^%`cZT`X!di`", 13) ||
+								FS_ShiftedStrStr(filename, "]^%`cZT`Xk+)!W__", 13))
+							{
+								pak->referenced |= FS_QAGAME_REF;
+							}
+						}
+						// cgame.qvm	- 7
+						// \`Zf^'jof
+						if (!(pak->referenced & FS_CGAME_REF))
+						{
+							if (FS_ShiftedStrStr(filename , "\\`Zf^'jof", 7) ||
+								FS_ShiftedStrStr(filename , "\\`Zf^q1/']ee", 7))
+							{
+								pak->referenced |= FS_CGAME_REF;
+							}
+						}
+						// ui.qvm		- 5
+						// pd)lqh
+						if (!(pak->referenced & FS_UI_REF))
+						{
+							if (FS_ShiftedStrStr(filename , "pd)lqh", 5) ||
+								FS_ShiftedStrStr(filename , "pds31)_gg", 5))
+							{
+								pak->referenced |= FS_UI_REF;
+							}
+						}
+
+						if ( uniqueFILE ) {
+							// open a new file on the pakfile
+							fsh[*file].handleFiles.file.z = unzReOpen (pak->pakFilename, pak->handle);
+							if (fsh[*file].handleFiles.file.z == NULL) {
+								Com_Error (ERR_FATAL, "Couldn't reopen %s", pak->pakFilename);
+							}
+						} else {
+							fsh[*file].handleFiles.file.z = pak->handle;
+						}
+						Q_strncpyz( fsh[*file].name, filename, sizeof( fsh[*file].name ) );
+						fsh[*file].zipFile = qtrue;
+						zfi = (unz_s *)fsh[*file].handleFiles.file.z;
+						// in case the file was new
+						temp = zfi->file;
+						// set the file position in the zip file (also sets the current file info)
+						unzSetCurrentFileInfoPosition(pak->handle, pakFile->pos);
+						// copy the file info into the unzip structure
+						Com_Memcpy( zfi, pak->handle, sizeof(unz_s) );
+						// we copy this back into the structure
+						zfi->file = temp;
+						// open the file in the zip
+						unzOpenCurrentFile( fsh[*file].handleFiles.file.z );
+						fsh[*file].zipFilePos = pakFile->pos;
+
+						if ( fs_debug->integer ) {
+							Com_Printf( "FS_FOpenFileRead: %s (found in '%s')\n", 
+								filename, pak->pakFilename );
+						}
+	#ifndef DEDICATED
+	#ifndef FINAL_BUILD
+						// Check for unprecached files when in game but not in the menus
+						if((cls.state == CA_ACTIVE) && !(cls.keyCatchers & KEYCATCH_UI))
+						{
+							Com_Printf(S_COLOR_YELLOW "WARNING: File %s not precached\n", filename);
+						}
+	#endif
+	#endif // DEDICATED
+						return zfi->cur_file_info.uncompressed_size;
+					}
+					pakFile = pakFile->next;
+				} while(pakFile != NULL);
+			} else if ( search->dir ) {
+				// check a file in the directory tree
+
+				// if we are running restricted, the only files we
+				// will allow to come from the directory are .cfg files
+				l = strlen( filename );
+		  // FIXME TTimo I'm not sure about the fs_numServerPaks test
+		  // if you are using FS_ReadFile to find out if a file exists,
+		  //   this test can make the search fail although the file is in the directory
+		  // I had the problem on https://zerowing.idsoftware.com/bugzilla/show_bug.cgi?id=8
+		  // turned out I used FS_FileExists instead
+				if ( fs_restrict->integer || fs_numServerPaks ) {
+
+					if ( Q_stricmp( filename + l - 4, ".cfg" )		// for config files
+						&& Q_stricmp( filename + l - 4, ".fcf" )	// force configuration files
+						&& Q_stricmp( filename + l - 5, ".menu" )	// menu files
+						&& Q_stricmp( filename + l - 5, ".game" )	// menu files
+						&& Q_stricmp( filename + l - strlen(demoExt), demoExt )	// menu files
+						&& Q_stricmp( filename + l - 4, ".dat" ) ) {	// for journal files
+						continue;
+					}
+				}
+
+				dir = search->dir;
+				
+				netpath = FS_BuildOSPath( dir->path, dir->gamedir, filename );
+				fsh[*file].handleFiles.file.o = fopen (netpath, "rb");
+				if ( !fsh[*file].handleFiles.file.o ) {
+					continue;
+				}
+
+				if ( Q_stricmp( filename + l - 4, ".cfg" )		// for config files
+					&& Q_stricmp( filename + l - 4, ".fcf" )	// force configuration files
+					&& Q_stricmp( filename + l - 5, ".menu" )	// menu files
+					&& Q_stricmp( filename + l - 5, ".game" )	// menu files
+					&& Q_stricmp( filename + l - strlen(demoExt), demoExt )	// menu files
+					&& Q_stricmp( filename + l - 4, ".dat" ) ) {	// for journal files
+					fs_fakeChkSum = random();
+				}
+				
+				// if running with fs_copyfiles 2, and search path == local, then we need to fail to open
+				//	if the time/date stamp != the network version (so it'll loop round again and use the network path,
+				//	which comes later in the search order)
+				//
+				if ( fs_copyfiles->integer == 2 && fs_cdpath->string[0] && !Q_stricmp( dir->path, fs_basepath->string ) 
+					&& FS_FileCacheable(filename) )
+				{
+					if ( Sys_FileOutOfDate( netpath, FS_BuildOSPath( fs_cdpath->string, dir->gamedir, filename ) ))
+					{
+						fclose(fsh[*file].handleFiles.file.o);
+						fsh[*file].handleFiles.file.o = 0;
+						continue;	//carry on to find the cdpath version.
+					}
+				}      
+
+				Q_strncpyz( fsh[*file].name, filename, sizeof( fsh[*file].name ) );
+				fsh[*file].zipFile = qfalse;
+				if ( fs_debug->integer ) {
+					Com_Printf( "FS_FOpenFileRead: %s (found in '%s/%s')\n", filename,
+						dir->path, dir->gamedir );
+				}
+
+				// if we are getting it from the cdpath, optionally copy it
+				//  to the basepath
+				if ( fs_copyfiles->integer && !Q_stricmp( dir->path, fs_cdpath->string ) ) {
+					char	*copypath;
+
+					copypath = FS_BuildOSPath( fs_basepath->string, dir->gamedir, filename );
+					switch ( fs_copyfiles->integer )
+					{
+						default:
+						case 1:
+						{
+							FS_CopyFile( netpath, copypath );
+						}
+						break;
+
+						case 2:
+						{
+					
+							if (FS_FileCacheable(filename) )
+							{
+								// maybe change this to Com_DPrintf?   On the other hand...
+								//
+								Com_Printf( "fs_copyfiles(2), Copying: %s to %s\n", netpath, copypath );
+								
+								FS_CreatePath( copypath );
+
+								bool bOk = true;
+								if (!CopyFile( netpath, copypath, FALSE ))
+								{
+									DWORD dwAttrs = GetFileAttributes(copypath);
+									SetFileAttributes(copypath, dwAttrs & ~FILE_ATTRIBUTE_READONLY);
+									bOk = !!CopyFile( netpath, copypath, FALSE );
+								}
+
+								if (bOk)
+								{
+									// clear this handle and setup for re-opening of the new local copy...
+									//
+									bFasterToReOpenUsingNewLocalFile = qtrue;
+									fclose(fsh[*file].handleFiles.file.o);
+									fsh[*file].handleFiles.file.o = NULL;
+								}
+							}
+						}
+						break;
+					}
+				}
+
+				if (bFasterToReOpenUsingNewLocalFile)
+				{
+					break;	// and re-read the local copy, not the net version
+				}
+
+	#ifndef DEDICATED
+	#ifndef FINAL_BUILD
+				// Check for unprecached files when in game but not in the menus
+				if((cls.state == CA_ACTIVE) && !(cls.keyCatchers & KEYCATCH_UI))
+				{
+					Com_Printf(S_COLOR_YELLOW "WARNING: File %s not precached\n", filename);
+				}
+	#endif
+	#endif // dedicated
+				return FS_filelength (*file);
+			}		
+		}
+	}
+	while ( bFasterToReOpenUsingNewLocalFile );
+	
+	Com_DPrintf ("Can't find %s\n", filename);
+#ifdef FS_MISSING
+	if (missingFiles) {
+		fprintf(missingFiles, "%s\n", filename);
+	}
+#endif
+	*file = 0;
+	return -1;
+}
+
+
+/*
+=================
+FS_Read
+
+Properly handles partial reads
+=================
+*/
+int FS_Read2( void *buffer, int len, fileHandle_t f ) {
+	if ( !fs_searchpaths ) {
+		Com_Error( ERR_FATAL, "Filesystem call made without initialization\n" );
+	}
+
+	if ( !f ) {
+		return 0;
+	}
+	if (fsh[f].streamed) {
+		int r;
+		fsh[f].streamed = qfalse;
+		r = Sys_StreamedRead( buffer, len, 1, f);
+		fsh[f].streamed = qtrue;
+		return r;
+	} else {
+		return FS_Read( buffer, len, f);
+	}
+}
+
+int FS_Read( void *buffer, int len, fileHandle_t f ) {
+	int		block, remaining;
+	int		read;
+	byte	*buf;
+	int		tries;
+
+	if ( !fs_searchpaths ) {
+		Com_Error( ERR_FATAL, "Filesystem call made without initialization\n" );
+	}
+
+	if ( !f ) {
+		return 0;
+	}
+
+	buf = (byte *)buffer;
+	fs_readCount += len;
+
+	if (fsh[f].zipFile == qfalse) {
+		remaining = len;
+		tries = 0;
+		while (remaining) {
+			block = remaining;
+			read = fread (buf, 1, block, fsh[f].handleFiles.file.o);
+			if (read == 0) {
+				// we might have been trying to read from a CD, which
+				// sometimes returns a 0 read on windows
+				if (!tries) {
+					tries = 1;
+				} else {
+					return len-remaining;	//Com_Error (ERR_FATAL, "FS_Read: 0 bytes read");
+				}
+			}
+
+			if (read == -1) {
+				Com_Error (ERR_FATAL, "FS_Read: -1 bytes read");
+			}
+
+			remaining -= read;
+			buf += read;
+		}
+		return len;
+	} else {
+		return unzReadCurrentFile(fsh[f].handleFiles.file.z, buffer, len);
+	}
+}
+
+/*
+=================
+FS_Write
+
+Properly handles partial writes
+=================
+*/
+int FS_Write( const void *buffer, int len, fileHandle_t h ) {
+	int		block, remaining;
+	int		written;
+	byte	*buf;
+	int		tries;
+	FILE	*f;
+
+	if ( !fs_searchpaths ) {
+		Com_Error( ERR_FATAL, "Filesystem call made without initialization\n" );
+	}
+
+	if ( !h ) {
+		return 0;
+	}
+
+	f = FS_FileForHandle(h);
+	buf = (byte *)buffer;
+
+	remaining = len;
+	tries = 0;
+	while (remaining) {
+		block = remaining;
+		written = fwrite (buf, 1, block, f);
+		if (written == 0) {
+			if (!tries) {
+				tries = 1;
+			} else {
+				Com_Printf( "FS_Write: 0 bytes written\n" );
+				return 0;
+			}
+		}
+
+		if (written == -1) {
+			Com_Printf( "FS_Write: -1 bytes written\n" );
+			return 0;
+		}
+
+		remaining -= written;
+		buf += written;
+	}
+	if ( fsh[h].handleSync ) {
+		fflush( f );
+	}
+	return len;
+}
+
+#define	MAXPRINTMSG	4096
+void QDECL FS_Printf( fileHandle_t h, const char *fmt, ... ) {
+	va_list		argptr;
+	char		msg[MAXPRINTMSG];
+
+	va_start (argptr,fmt);
+	vsprintf (msg,fmt,argptr);
+	va_end (argptr);
+
+	FS_Write(msg, strlen(msg), h);
+}
+
+/*
+=================
+FS_Seek
+
+=================
+*/
+int FS_Seek( fileHandle_t f, long offset, int origin ) {
+	int		_origin;
+	char	foo[65536];
+
+	if ( !fs_searchpaths ) {
+		Com_Error( ERR_FATAL, "Filesystem call made without initialization\n" );
+		return -1;
+	}
+
+	if (fsh[f].streamed) {
+		fsh[f].streamed = qfalse;
+		Sys_StreamSeek( f, offset, origin );
+		fsh[f].streamed = qtrue;
+	}
+
+	if (fsh[f].zipFile == qtrue) {
+		if (offset == 0 && origin == FS_SEEK_SET) {
+			// set the file position in the zip file (also sets the current file info)
+			unzSetCurrentFileInfoPosition(fsh[f].handleFiles.file.z, fsh[f].zipFilePos);
+			return unzOpenCurrentFile(fsh[f].handleFiles.file.z);
+		} else if (offset<65536) {
+			// set the file position in the zip file (also sets the current file info)
+			unzSetCurrentFileInfoPosition(fsh[f].handleFiles.file.z, fsh[f].zipFilePos);
+			unzOpenCurrentFile(fsh[f].handleFiles.file.z);
+			return FS_Read(foo, offset, f);
+		} else {
+			Com_Error( ERR_FATAL, "ZIP FILE FSEEK NOT YET IMPLEMENTED\n" );
+			return -1;
+		}
+	} else {
+		FILE *file;
+		file = FS_FileForHandle(f);
+		switch( origin ) {
+		case FS_SEEK_CUR:
+			_origin = SEEK_CUR;
+			break;
+		case FS_SEEK_END:
+			_origin = SEEK_END;
+			break;
+		case FS_SEEK_SET:
+			_origin = SEEK_SET;
+			break;
+		default:
+			_origin = SEEK_CUR;
+			Com_Error( ERR_FATAL, "Bad origin in FS_Seek\n" );
+			break;
+		}
+
+		return fseek( file, offset, _origin );
+	}
+}
+
+
+/*
+======================================================================================
+
+CONVENIENCE FUNCTIONS FOR ENTIRE FILES
+
+======================================================================================
+*/
+
+int	FS_FileIsInPAK(const char *filename, int *pChecksum ) {
+	searchpath_t	*search;
+	pack_t			*pak;
+	fileInPack_t	*pakFile;
+	long			hash = 0;
+
+	if ( !fs_searchpaths ) {
+		Com_Error( ERR_FATAL, "Filesystem call made without initialization\n" );
+	}
+
+	if ( !filename ) {
+		Com_Error( ERR_FATAL, "FS_FOpenFileRead: NULL 'filename' parameter passed\n" );
+	}
+
+	// qpaths are not supposed to have a leading slash
+	if ( filename[0] == '/' || filename[0] == '\\' ) {
+		filename++;
+	}
+
+	// make absolutely sure that it can't back up the path.
+	// The searchpaths do guarantee that something will always
+	// be prepended, so we don't need to worry about "c:" or "//limbo" 
+	if ( strstr( filename, ".." ) || strstr( filename, "::" ) ) {
+		return -1;
+	}
+
+	//
+	// search through the path, one element at a time
+	//
+
+	for ( search = fs_searchpaths ; search ; search = search->next ) {
+		//
+		if (search->pack) {
+			hash = FS_HashFileName(filename, search->pack->hashSize);
+		}
+		// is the element a pak file?
+		if ( search->pack && search->pack->hashTable[hash] ) {
+			// disregard if it doesn't match one of the allowed pure pak files
+			if ( !FS_PakIsPure(search->pack) ) {
+				continue;
+			}
+
+			// look through all the pak file elements
+			pak = search->pack;
+			pakFile = pak->hashTable[hash];
+			do {
+				// case and separator insensitive comparisons
+				if ( !FS_FilenameCompare( pakFile->name, filename ) ) {
+					if (pChecksum) {
+						*pChecksum = pak->pure_checksum;
+					}
+					return 1;
+				}
+				pakFile = pakFile->next;
+			} while(pakFile != NULL);
+		}
+	}
+	return -1;
+}
+
+/*
+============
+FS_ReadFile
+
+Filename are relative to the quake search path
+a null buffer will just return the file length without loading
+============
+*/
+int FS_ReadFile( const char *qpath, void **buffer ) {
+	fileHandle_t	h;
+	byte*			buf;
+	qboolean		isConfig;
+	int				len;
+
+	if ( !fs_searchpaths ) {
+		Com_Error( ERR_FATAL, "Filesystem call made without initialization\n" );
+	}
+
+	if ( !qpath || !qpath[0] ) {
+		Com_Error( ERR_FATAL, "FS_ReadFile with empty name\n" );
+	}
+
+	buf = NULL;	// quiet compiler warning
+
+	// if this is a .cfg file and we are playing back a journal, read
+	// it from the journal file
+#ifndef _XBOX	// VVXXX
+	if ( strstr( qpath, ".cfg" ) ) {
+		isConfig = qtrue;
+		if ( com_journal && com_journal->integer == 2 ) {
+			int		r;
+
+			Com_DPrintf( "Loading %s from journal file.\n", qpath );
+			r = FS_Read( &len, sizeof( len ), com_journalDataFile );
+			if ( r != sizeof( len ) ) {
+				if (buffer != NULL) *buffer = NULL;
+				return -1;
+			}
+			// if the file didn't exist when the journal was created
+			if (!len) {
+				if (buffer == NULL) {
+					return 1;			// hack for old journal files
+				}
+				*buffer = NULL;
+				return -1;
+			}
+			if (buffer == NULL) {
+				return len;
+			}
+
+			buf = (unsigned char *)Hunk_AllocateTempMemory(len+1);
+			*buffer = buf;
+
+			r = FS_Read( buf, len, com_journalDataFile );
+			if ( r != len ) {
+				Com_Error( ERR_FATAL, "Read from journalDataFile failed" );
+			}
+
+			fs_loadCount++;
+			fs_loadStack++;
+
+			// guarantee that it will have a trailing 0 for string operations
+			buf[len] = 0;
+
+			return len;
+		}
+	} else {
+		isConfig = qfalse;
+	}
+#endif
+
+	// look for it in the filesystem or pack files
+	len = FS_FOpenFileRead( qpath, &h, qfalse );
+	if ( h == 0 ) {
+		if ( buffer ) {
+			*buffer = NULL;
+		}
+		// if we are journalling and it is a config file, write a zero to the journal file
+#ifndef _XBOX	// VVXXX
+		if ( isConfig && com_journal && com_journal->integer == 1 ) {
+			Com_DPrintf( "Writing zero for %s to journal file.\n", qpath );
+			len = 0;
+			FS_Write( &len, sizeof( len ), com_journalDataFile );
+			FS_Flush( com_journalDataFile );
+		}
+#endif
+		return -1;
+	}
+	
+	if ( !buffer ) {
+#ifndef _XBOX	// VVXXX
+		if ( isConfig && com_journal && com_journal->integer == 1 ) {
+			Com_DPrintf( "Writing len for %s to journal file.\n", qpath );
+			FS_Write( &len, sizeof( len ), com_journalDataFile );
+			FS_Flush( com_journalDataFile );
+		}
+#endif
+		FS_FCloseFile( h);
+		return len;
+	}
+
+	fs_loadCount++;
+/*	fs_loadStack++;
+
+	buf = (unsigned char *)Hunk_AllocateTempMemory(len+1);
+	*buffer = buf;*/
+
+	buf = (byte*)Z_Malloc( len+1, TAG_FILESYS, qfalse);
+	buf[len]='\0';	// because we're not calling Z_Malloc with optional trailing 'bZeroIt' bool
+	*buffer = buf;	
+
+//	Z_Label(buf, qpath);
+
+	FS_Read (buf, len, h);
+
+	// guarantee that it will have a trailing 0 for string operations
+	buf[len] = 0;
+	FS_FCloseFile( h );
+
+	// if we are journalling and it is a config file, write it to the journal file
+#ifndef _XBOX	// VVXXX
+	if ( isConfig && com_journal && com_journal->integer == 1 ) {
+		Com_DPrintf( "Writing %s to journal file.\n", qpath );
+		FS_Write( &len, sizeof( len ), com_journalDataFile );
+		FS_Write( buf, len, com_journalDataFile );
+		FS_Flush( com_journalDataFile );
+	}
+#endif
+	return len;
+}
+
+/*
+=============
+FS_FreeFile
+=============
+*/
+void FS_FreeFile( void *buffer ) {
+	/*	
+	if ( !fs_searchpaths ) {
+		Com_Error( ERR_FATAL, "Filesystem call made without initialization\n" );
+	}
+	if ( !buffer ) {
+		Com_Error( ERR_FATAL, "FS_FreeFile( NULL )" );
+	}
+	fs_loadStack--;
+
+	Hunk_FreeTempMemory( buffer );
+
+	// if all of our temp files are free, clear all of our space
+	if ( fs_loadStack == 0 ) {
+		Hunk_ClearTempMemory();
+	}
+	*/
+
+	if ( !fs_searchpaths ) {
+		Com_Error( ERR_FATAL, "Filesystem call made without initialization\n" );
+	}
+	if ( !buffer ) {
+		Com_Error( ERR_FATAL, "FS_FreeFile( NULL )" );
+	}
+
+	Z_Free( buffer );
+}
+
+/*
+============
+FS_WriteFile
+
+Filename are reletive to the quake search path
+============
+*/
+void FS_WriteFile( const char *qpath, const void *buffer, int size ) {
+	fileHandle_t f;
+
+	if ( !fs_searchpaths ) {
+		Com_Error( ERR_FATAL, "Filesystem call made without initialization\n" );
+	}
+
+	if ( !qpath || !buffer ) {
+		Com_Error( ERR_FATAL, "FS_WriteFile: NULL parameter" );
+	}
+
+	f = FS_FOpenFileWrite( qpath );
+	if ( !f ) {
+		Com_Printf( "Failed to open %s\n", qpath );
+		return;
+	}
+
+	FS_Write( buffer, size, f );
+
+	FS_FCloseFile( f );
+}
+
+
+
+/*
+==========================================================================
+
+ZIP FILE LOADING
+
+==========================================================================
+*/
+
+/*
+=================
+FS_LoadZipFile
+
+Creates a new pak_t in the search chain for the contents
+of a zip file.
+=================
+*/
+static pack_t *FS_LoadZipFile( char *zipfile, const char *basename )
+{
+	fileInPack_t	*buildBuffer;
+	pack_t			*pack;
+	unzFile			uf;
+	int				err;
+	unz_global_info gi;
+	char			filename_inzip[MAX_ZPATH];
+	unz_file_info	file_info;
+	int				i, len;
+	long			hash;
+	int				fs_numHeaderLongs;
+	int				*fs_headerLongs;
+	char			*namePtr;
+
+	fs_numHeaderLongs = 0;
+
+	uf = unzOpen(zipfile);
+	err = unzGetGlobalInfo (uf,&gi);
+
+	if (err != UNZ_OK)
+		return NULL;
+
+	fs_packFiles += gi.number_entry;
+
+	len = 0;
+	unzGoToFirstFile(uf);
+	for (i = 0; i < gi.number_entry; i++)
+	{
+		err = unzGetCurrentFileInfo(uf, &file_info, filename_inzip, sizeof(filename_inzip), NULL, 0, NULL, 0);
+		if (err != UNZ_OK) {
+			break;
+		}
+		len += strlen(filename_inzip) + 1;
+		unzGoToNextFile(uf);
+	}
+
+	buildBuffer = (struct fileInPack_s *)Z_Malloc( (gi.number_entry * sizeof( fileInPack_t )) + len, TAG_FILESYS, qtrue );
+	namePtr = ((char *) buildBuffer) + gi.number_entry * sizeof( fileInPack_t );
+	fs_headerLongs = (int *)Z_Malloc( gi.number_entry * sizeof(int), TAG_FILESYS, qtrue );
+
+	// get the hash table size from the number of files in the zip
+	// because lots of custom pk3 files have less than 32 or 64 files
+	for (i = 1; i <= MAX_FILEHASH_SIZE; i <<= 1) {
+		if (i > gi.number_entry) {
+			break;
+		}
+	}
+
+	pack = (pack_t *)Z_Malloc( sizeof( pack_t ) + i * sizeof(fileInPack_t *), TAG_FILESYS, qtrue );
+	pack->hashSize = i;
+	pack->hashTable = (fileInPack_t **) (((char *) pack) + sizeof( pack_t ));
+	for(i = 0; i < pack->hashSize; i++) {
+		pack->hashTable[i] = NULL;
+	}
+
+	Q_strncpyz( pack->pakFilename, zipfile, sizeof( pack->pakFilename ) );
+	Q_strncpyz( pack->pakBasename, basename, sizeof( pack->pakBasename ) );
+
+	// strip .pk3 if needed
+	if ( strlen( pack->pakBasename ) > 4 && !Q_stricmp( pack->pakBasename + strlen( pack->pakBasename ) - 4, ".pk3" ) ) {
+		pack->pakBasename[strlen( pack->pakBasename ) - 4] = 0;
+	}
+
+	pack->handle = uf;
+	pack->numfiles = gi.number_entry;
+	unzGoToFirstFile(uf);
+
+	for (i = 0; i < gi.number_entry; i++)
+	{
+		err = unzGetCurrentFileInfo(uf, &file_info, filename_inzip, sizeof(filename_inzip), NULL, 0, NULL, 0);
+		if (err != UNZ_OK) {
+			break;
+		}
+		if (file_info.uncompressed_size > 0) {
+			fs_headerLongs[fs_numHeaderLongs++] = LittleLong(file_info.crc);
+		}
+		Q_strlwr( filename_inzip );
+		hash = FS_HashFileName(filename_inzip, pack->hashSize);
+		buildBuffer[i].name = namePtr;
+		strcpy( buildBuffer[i].name, filename_inzip );
+		namePtr += strlen(filename_inzip) + 1;
+		// store the file position in the zip
+		unzGetCurrentFileInfoPosition(uf, &buildBuffer[i].pos);
+		//
+		buildBuffer[i].next = pack->hashTable[hash];
+		pack->hashTable[hash] = &buildBuffer[i];
+		unzGoToNextFile(uf);
+	}
+
+	pack->checksum = Com_BlockChecksum( fs_headerLongs, 4 * fs_numHeaderLongs );
+	pack->pure_checksum = Com_BlockChecksumKey( fs_headerLongs, 4 * fs_numHeaderLongs, LittleLong(fs_checksumFeed) );
+	pack->checksum = LittleLong( pack->checksum );
+	pack->pure_checksum = LittleLong( pack->pure_checksum );
+
+	Z_Free(fs_headerLongs);
+
+	pack->buildBuffer = buildBuffer;
+	return pack;
+}
+
+/*
+=================================================================================
+
+DIRECTORY SCANNING FUNCTIONS
+
+=================================================================================
+*/
+
+#define	MAX_FOUND_FILES	0x1000
+
+static int FS_ReturnPath( const char *zname, char *zpath, int *depth ) {
+	int len, at, newdep;
+
+	newdep = 0;
+	zpath[0] = 0;
+	len = 0;
+	at = 0;
+
+	while(zname[at] != 0)
+	{
+		if (zname[at]=='/' || zname[at]=='\\') {
+			len = at;
+			newdep++;
+		}
+		at++;
+	}
+	strcpy(zpath, zname);
+	zpath[len] = 0;
+	*depth = newdep;
+
+	return len;
+}
+
+/*
+==================
+FS_AddFileToList
+==================
+*/
+static int FS_AddFileToList( char *name, char *list[MAX_FOUND_FILES], int nfiles ) {
+	int		i;
+
+	if ( nfiles == MAX_FOUND_FILES - 1 ) {
+		return nfiles;
+	}
+	for ( i = 0 ; i < nfiles ; i++ ) {
+		if ( !Q_stricmp( name, list[i] ) ) {
+			return nfiles;		// allready in list
+		}
+	}
+	list[nfiles] = CopyString( name );
+	nfiles++;
+
+	return nfiles;
+}
+
+/*
+===============
+FS_ListFilteredFiles
+
+Returns a uniqued list of files that match the given criteria
+from all search paths
+===============
+*/
+char **FS_ListFilteredFiles( const char *path, const char *extension, char *filter, int *numfiles ) {
+	int				nfiles;
+	char			**listCopy;
+	char			*list[MAX_FOUND_FILES];
+	searchpath_t	*search;
+	int				i;
+	int				pathLength;
+	int				extensionLength;
+	int				length, pathDepth, temp;
+	pack_t			*pak;
+	fileInPack_t	*buildBuffer;
+	char			zpath[MAX_ZPATH];
+
+	if ( !fs_searchpaths ) {
+		Com_Error( ERR_FATAL, "Filesystem call made without initialization\n" );
+	}
+
+	if ( !path ) {
+		*numfiles = 0;
+		return NULL;
+	}
+	if ( !extension ) {
+		extension = "";
+	}
+
+	pathLength = strlen( path );
+	if ( path[pathLength-1] == '\\' || path[pathLength-1] == '/' ) {
+		pathLength--;
+	}
+	extensionLength = strlen( extension );
+	nfiles = 0;
+	FS_ReturnPath(path, zpath, &pathDepth);
+
+	//
+	// search through the path, one element at a time, adding to list
+	//
+	for (search = fs_searchpaths ; search ; search = search->next) {
+		// is the element a pak file?
+		if (search->pack) {
+
+			//ZOID:  If we are pure, don't search for files on paks that
+			// aren't on the pure list
+			if ( !FS_PakIsPure(search->pack) ) {
+				continue;
+			}
+
+			// look through all the pak file elements
+			pak = search->pack;
+			buildBuffer = pak->buildBuffer;
+			for (i = 0; i < pak->numfiles; i++) {
+				char	*name;
+				int		zpathLen, depth;
+
+				// check for directory match
+				name = buildBuffer[i].name;
+				//
+				if (filter) {
+					// case insensitive
+					if (!Com_FilterPath( filter, name, qfalse ))
+						continue;
+					// unique the match
+					nfiles = FS_AddFileToList( name, list, nfiles );
+				}
+				else {
+
+					zpathLen = FS_ReturnPath(name, zpath, &depth);
+
+					if ( (depth-pathDepth)>2 || pathLength > zpathLen || Q_stricmpn( name, path, pathLength ) ) {
+						continue;
+					}
+
+					// check for extension match
+					length = strlen( name );
+					if ( length < extensionLength ) {
+						continue;
+					}
+
+					if ( Q_stricmp( name + length - extensionLength, extension ) ) {
+						continue;
+					}
+					// unique the match
+
+					temp = pathLength;
+					if (pathLength) {
+						temp++;		// include the '/'
+					}
+					nfiles = FS_AddFileToList( name + temp, list, nfiles );
+				}
+			}
+		} else if (search->dir) { // scan for files in the filesystem
+			char	*netpath;
+			int		numSysFiles;
+			char	**sysFiles;
+			char	*name;
+
+			// don't scan directories for files if we are pure or restricted
+			if ( (fs_restrict->integer || fs_numServerPaks) &&
+				 (!extension || Q_stricmp(extension, "fcf") || fs_restrict->integer) )
+			{
+				//rww - allow scanning for fcf files outside of pak even if pure
+			    continue;
+		    }
+			else
+			{
+				netpath = FS_BuildOSPath( search->dir->path, search->dir->gamedir, path );
+				sysFiles = Sys_ListFiles( netpath, extension, filter, &numSysFiles, qfalse );
+				for ( i = 0 ; i < numSysFiles ; i++ ) {
+					// unique the match
+					name = sysFiles[i];
+					nfiles = FS_AddFileToList( name, list, nfiles );
+				}
+				Sys_FreeFileList( sysFiles );
+			}
+		}		
+	}
+
+	// return a copy of the list
+	*numfiles = nfiles;
+
+	if ( !nfiles ) {
+		return NULL;
+	}
+
+	listCopy = (char **)Z_Malloc( ( nfiles + 1 ) * sizeof( *listCopy ), TAG_FILESYS );
+	for ( i = 0 ; i < nfiles ; i++ ) {
+		listCopy[i] = list[i];
+	}
+	listCopy[i] = NULL;
+
+	return listCopy;
+}
+
+/*
+=================
+FS_ListFiles
+=================
+*/
+char **FS_ListFiles( const char *path, const char *extension, int *numfiles ) {
+	return FS_ListFilteredFiles( path, extension, NULL, numfiles );
+}
+
+/*
+=================
+FS_FreeFileList
+=================
+*/
+void FS_FreeFileList( char **fileList ) {
+	//rwwRMG - changed to fileList to not conflict with list type
+	int		i;
+
+	if ( !fs_searchpaths ) {
+		Com_Error( ERR_FATAL, "Filesystem call made without initialization\n" );
+	}
+
+	if ( !fileList ) {
+		return;
+	}
+
+	for ( i = 0 ; fileList[i] ; i++ ) {
+		Z_Free( fileList[i] );
+	}
+
+	Z_Free( fileList );
+}
+
+
+/*
+================
+FS_GetFileList
+================
+*/
+int	FS_GetFileList(  const char *path, const char *extension, char *listbuf, int bufsize ) {
+	int		nFiles, i, nTotal, nLen;
+	char **pFiles = NULL;
+
+	*listbuf = 0;
+	nFiles = 0;
+	nTotal = 0;
+
+	if (Q_stricmp(path, "$modlist") == 0) {
+		return FS_GetModList(listbuf, bufsize);
+	}
+
+	pFiles = FS_ListFiles(path, extension, &nFiles);
+
+	for (i =0; i < nFiles; i++) {
+		nLen = strlen(pFiles[i]) + 1;
+		if (nTotal + nLen + 1 < bufsize) {
+			strcpy(listbuf, pFiles[i]);
+			listbuf += nLen;
+			nTotal += nLen;
+		}
+		else {
+			nFiles = i;
+			break;
+		}
+	}
+
+	FS_FreeFileList(pFiles);
+
+	return nFiles;
+}
+
+// NOTE: could prolly turn out useful for the win32 version too, but it's used only by linux and Mac OS X
+//#if defined(__linux__) || defined(MACOS_X)
+/*
+=======================
+Sys_ConcatenateFileLists
+
+mkv: Naive implementation. Concatenates three lists into a
+     new list, and frees the old lists from the heap.
+bk001129 - from cvs1.17 (mkv)
+
+FIXME TTimo those two should move to common.c next to Sys_ListFiles
+=======================
+ */
+static unsigned int Sys_CountFileList(char **list)
+{
+  int i = 0;
+
+  if (list)
+  {
+    while (*list)
+    {
+      list++;
+      i++;
+    }
+  }
+  return i;
+}
+
+static char** Sys_ConcatenateFileLists( char **list0, char **list1, char **list2 )
+{
+        int totalLength = 0;
+	char** cat = NULL, **dst, **src;
+
+        totalLength += Sys_CountFileList(list0);
+        totalLength += Sys_CountFileList(list1);
+        totalLength += Sys_CountFileList(list2);
+        
+	/* Create new list. */
+	dst = cat = (char **)Z_Malloc( ( totalLength + 1 ) * sizeof( char* ), TAG_FILESYS, qtrue );
+        
+	/* Copy over lists. */
+        if (list0) {
+            for (src = list0; *src; src++, dst++)
+                *dst = *src;
+        }
+        if (list1) {
+            for (src = list1; *src; src++, dst++)
+                *dst = *src;
+        }
+        if (list2) {
+            for (src = list2; *src; src++, dst++)
+                *dst = *src;
+        }
+
+        // Terminate the list
+	*dst = NULL;
+
+  // Free our old lists.
+  // NOTE: not freeing their content, it's been merged in dst and still being used
+  if (list0) Z_Free( list0 );
+  if (list1) Z_Free( list1 );
+  if (list2) Z_Free( list2 );
+
+	return cat;
+}
+//#endif
+
+/*
+================
+FS_GetModList
+
+Returns a list of mod directory names
+A mod directory is a peer to base with a pk3 in it
+The directories are searched in base path, cd path and home path
+================
+*/
+int	FS_GetModList( char *listbuf, int bufsize ) {
+  int		nMods, i, j, nTotal, nLen, nPaks, nPotential, nDescLen;
+  char **pFiles = NULL;
+  char **pPaks = NULL;
+  char *name, *path;
+  char descPath[MAX_OSPATH];
+  fileHandle_t descHandle;
+
+  int dummy;
+  char **pFiles0 = NULL;
+  char **pFiles1 = NULL;
+  char **pFiles2 = NULL;
+  qboolean bDrop = qfalse;
+
+  *listbuf = 0;
+  nMods = nPotential = nTotal = 0;
+
+  pFiles0 = Sys_ListFiles( fs_homepath->string, NULL, NULL, &dummy, qtrue );
+  pFiles1 = Sys_ListFiles( fs_basepath->string, NULL, NULL, &dummy, qtrue );
+  pFiles2 = Sys_ListFiles( fs_cdpath->string, NULL, NULL, &dummy, qtrue );
+  // we searched for mods in the three paths
+  // it is likely that we have duplicate names now, which we will cleanup below
+  pFiles = Sys_ConcatenateFileLists( pFiles0, pFiles1, pFiles2 );
+  nPotential = Sys_CountFileList(pFiles);
+
+  for ( i = 0 ; i < nPotential ; i++ ) {
+    name = pFiles[i];
+    // NOTE: cleaner would involve more changes
+    // ignore duplicate mod directories
+    if (i!=0) {
+      bDrop = qfalse;
+      for(j=0; j<i; j++)
+      {
+        if (Q_stricmp(pFiles[j],name)==0) {
+          // this one can be dropped
+          bDrop = qtrue;
+          break;
+        }
+      }
+    }
+    if (bDrop) {
+      continue;
+    }
+    // we drop "base" "." and ".."
+    if (Q_stricmp(name, "base") && Q_stricmpn(name, ".", 1)) {
+      // now we need to find some .pk3 files to validate the mod
+      // NOTE TTimo: (actually I'm not sure why .. what if it's a mod under developement with no .pk3?)
+      // we didn't keep the information when we merged the directory names, as to what OS Path it was found under
+      //   so it could be in base path, cd path or home path
+      //   we will try each three of them here (yes, it's a bit messy)
+      path = FS_BuildOSPath( fs_basepath->string, name, "" );
+      nPaks = 0;
+      pPaks = Sys_ListFiles(path, ".pk3", NULL, &nPaks, qfalse); 
+      Sys_FreeFileList( pPaks ); // we only use Sys_ListFiles to check wether .pk3 files are present
+
+      /* Try on cd path */
+      if( nPaks <= 0 ) {
+        path = FS_BuildOSPath( fs_cdpath->string, name, "" );
+        nPaks = 0;
+        pPaks = Sys_ListFiles( path, ".pk3", NULL, &nPaks, qfalse );
+        Sys_FreeFileList( pPaks );
+      }
+
+      /* try on home path */
+      if ( nPaks <= 0 )
+      {
+        path = FS_BuildOSPath( fs_homepath->string, name, "" );
+        nPaks = 0;
+        pPaks = Sys_ListFiles( path, ".pk3", NULL, &nPaks, qfalse );
+        Sys_FreeFileList( pPaks );
+      }
+
+      if (nPaks > 0) {
+        nLen = strlen(name) + 1;
+        // nLen is the length of the mod path
+        // we need to see if there is a description available
+        descPath[0] = '\0';
+        strcpy(descPath, name);
+        strcat(descPath, "/description.txt");
+        nDescLen = FS_SV_FOpenFileRead( descPath, &descHandle );
+        if ( nDescLen > 0 && descHandle) {
+          FILE *file;
+          file = FS_FileForHandle(descHandle);
+          Com_Memset( descPath, 0, sizeof( descPath ) );
+          nDescLen = fread(descPath, 1, 48, file);
+          if (nDescLen >= 0) {
+            descPath[nDescLen] = '\0';
+          }
+          FS_FCloseFile(descHandle);
+        } else {
+          strcpy(descPath, name);
+        }
+        nDescLen = strlen(descPath) + 1;
+
+        if (nTotal + nLen + 1 + nDescLen + 1 < bufsize) {
+          strcpy(listbuf, name);
+          listbuf += nLen;
+          strcpy(listbuf, descPath);
+          listbuf += nDescLen;
+          nTotal += nLen + nDescLen;
+          nMods++;
+        }
+        else {
+          break;
+        }
+      }
+    }
+  }
+  Sys_FreeFileList( pFiles );
+
+  return nMods;
+}
+
+
+
+
+//============================================================================
+
+/*
+================
+FS_Dir_f
+================
+*/
+void FS_Dir_f( void ) {
+	char	*path;
+	char	*extension;
+	char	**dirnames;
+	int		ndirs;
+	int		i;
+
+	if ( Cmd_Argc() < 2 || Cmd_Argc() > 3 ) {
+		Com_Printf( "usage: dir <directory> [extension]\n" );
+		return;
+	}
+
+	if ( Cmd_Argc() == 2 ) {
+		path = Cmd_Argv( 1 );
+		extension = "";
+	} else {
+		path = Cmd_Argv( 1 );
+		extension = Cmd_Argv( 2 );
+	}
+
+	Com_Printf( "Directory of %s %s\n", path, extension );
+	Com_Printf( "---------------\n" );
+
+	dirnames = FS_ListFiles( path, extension, &ndirs );
+
+	for ( i = 0; i < ndirs; i++ ) {
+		Com_Printf( "%s\n", dirnames[i] );
+	}
+	FS_FreeFileList( dirnames );
+}
+
+/*
+===========
+FS_ConvertPath
+===========
+*/
+void FS_ConvertPath( char *s ) {
+	while (*s) {
+		if ( *s == '\\' || *s == ':' ) {
+			*s = '/';
+		}
+		s++;
+	}
+}
+
+/*
+===========
+FS_PathCmp
+
+Ignore case and seprator char distinctions
+===========
+*/
+int FS_PathCmp( const char *s1, const char *s2 ) {
+	int		c1, c2;
+	
+	do {
+		c1 = *s1++;
+		c2 = *s2++;
+
+		if (c1 >= 'a' && c1 <= 'z') {
+			c1 -= ('a' - 'A');
+		}
+		if (c2 >= 'a' && c2 <= 'z') {
+			c2 -= ('a' - 'A');
+		}
+
+		if ( c1 == '\\' || c1 == ':' ) {
+			c1 = '/';
+		}
+		if ( c2 == '\\' || c2 == ':' ) {
+			c2 = '/';
+		}
+		
+		if (c1 < c2) {
+			return -1;		// strings not equal
+		}
+		if (c1 > c2) {
+			return 1;
+		}
+	} while (c1);
+	
+	return 0;		// strings are equal
+}
+
+/*
+================
+FS_SortFileList
+================
+*/
+void FS_SortFileList(char **filelist, int numfiles) {
+	int i, j, k, numsortedfiles;
+	char **sortedlist;
+
+	sortedlist = (char **)Z_Malloc( ( numfiles + 1 ) * sizeof( *sortedlist ), TAG_FILESYS, qtrue );
+	sortedlist[0] = NULL;
+	numsortedfiles = 0;
+	for (i = 0; i < numfiles; i++) {
+		for (j = 0; j < numsortedfiles; j++) {
+			if (FS_PathCmp(filelist[i], sortedlist[j]) < 0) {
+				break;
+			}
+		}
+		for (k = numsortedfiles; k > j; k--) {
+			sortedlist[k] = sortedlist[k-1];
+		}
+		sortedlist[j] = filelist[i];
+		numsortedfiles++;
+	}
+	Com_Memcpy(filelist, sortedlist, numfiles * sizeof( *filelist ) );
+	Z_Free(sortedlist);
+}
+
+/*
+================
+FS_NewDir_f
+================
+*/
+void FS_NewDir_f( void ) {
+	char	*filter;
+	char	**dirnames;
+	int		ndirs;
+	int		i;
+
+	if ( Cmd_Argc() < 2 ) {
+		Com_Printf( "usage: fdir <filter>\n" );
+		Com_Printf( "example: fdir *q3dm*.bsp\n");
+		return;
+	}
+
+	filter = Cmd_Argv( 1 );
+
+	Com_Printf( "---------------\n" );
+
+	dirnames = FS_ListFilteredFiles( "", "", filter, &ndirs );
+
+	FS_SortFileList(dirnames, ndirs);
+
+	for ( i = 0; i < ndirs; i++ ) {
+		FS_ConvertPath(dirnames[i]);
+		Com_Printf( "%s\n", dirnames[i] );
+	}
+	Com_Printf( "%d files listed\n", ndirs );
+	FS_FreeFileList( dirnames );
+}
+
+/*
+============
+FS_Path_f
+
+============
+*/
+void FS_Path_f( void ) {
+	searchpath_t	*s;
+	int				i;
+
+	Com_Printf ("Current search path:\n");
+	for (s = fs_searchpaths; s; s = s->next) {
+		if (s->pack) {
+			Com_Printf ("%s (%i files)\n", s->pack->pakFilename, s->pack->numfiles);
+			if ( fs_numServerPaks ) {
+				if ( !FS_PakIsPure(s->pack) ) {
+					Com_Printf( "    not on the pure list\n" );
+				} else {
+					Com_Printf( "    on the pure list\n" );
+				}
+			}
+		} else {
+			Com_Printf ("%s/%s\n", s->dir->path, s->dir->gamedir );
+		}
+	}
+
+
+	Com_Printf( "\n" );
+	for ( i = 1 ; i < MAX_FILE_HANDLES ; i++ ) {
+		if ( fsh[i].handleFiles.file.o ) {
+			Com_Printf( "handle %i: %s\n", i, fsh[i].name );
+		}
+	}
+}
+
+/*
+============
+FS_TouchFile_f
+
+The only purpose of this function is to allow game script files to copy
+arbitrary files furing an "fs_copyfiles 1" run.
+============
+*/
+void FS_TouchFile_f( void ) {
+	fileHandle_t	f;
+
+	if ( Cmd_Argc() != 2 ) {
+		Com_Printf( "Usage: touchFile <file>\n" );
+		return;
+	}
+
+	FS_FOpenFileRead( Cmd_Argv( 1 ), &f, qfalse );
+	if ( f ) {
+		FS_FCloseFile( f );
+	}
+}
+
+//===========================================================================
+
+
+static int QDECL paksort( const void *a, const void *b ) {
+	char	*aa, *bb;
+
+	aa = *(char **)a;
+	bb = *(char **)b;
+
+	return FS_PathCmp( aa, bb );
+}
+
+/*
+================
+FS_AddGameDirectory
+
+Sets fs_gamedir, adds the directory to the head of the path,
+then loads the zip headers
+================
+*/
+#define	MAX_PAKFILES	1024
+static void FS_AddGameDirectory( const char *path, const char *dir ) {
+	searchpath_t	*sp;
+	int				i;
+	searchpath_t	*search;
+	searchpath_t	*thedir;
+	pack_t			*pak;
+	char			*pakfile;
+	int				numfiles;
+	char			**pakfiles;
+	char			*sorted[MAX_PAKFILES];
+
+	// this fixes the case where fs_basepath is the same as fs_cdpath
+	// which happens on full installs
+	for ( sp = fs_searchpaths ; sp ; sp = sp->next ) {
+		if ( sp->dir && !Q_stricmp(sp->dir->path, path) && !Q_stricmp(sp->dir->gamedir, dir)) {
+			return;			// we've already got this one
+		}
+	}
+	
+	Q_strncpyz( fs_gamedir, dir, sizeof( fs_gamedir ) );
+
+	//
+	// add the directory to the search path
+	//
+	search = (struct searchpath_s *)Z_Malloc (sizeof(searchpath_t), TAG_FILESYS, qtrue);
+	search->dir = (directory_t *)Z_Malloc( sizeof( *search->dir ), TAG_FILESYS, qtrue );
+
+	Q_strncpyz( search->dir->path, path, sizeof( search->dir->path ) );
+	Q_strncpyz( search->dir->gamedir, dir, sizeof( search->dir->gamedir ) );
+	search->next = fs_searchpaths;
+	fs_searchpaths = search;
+
+	thedir = search;
+
+	// find all pak files in this directory
+	pakfile = FS_BuildOSPath( path, dir, "" );
+	pakfile[ strlen(pakfile) - 1 ] = 0;	// strip the trailing slash
+
+	pakfiles = Sys_ListFiles( pakfile, ".pk3", NULL, &numfiles, qfalse );
+
+	// sort them so that later alphabetic matches override
+	// earlier ones.  This makes pak1.pk3 override pak0.pk3
+	if ( numfiles > MAX_PAKFILES ) {
+		numfiles = MAX_PAKFILES;
+	}
+	for ( i = 0 ; i < numfiles ; i++ ) {
+		sorted[i] = pakfiles[i];
+	}
+
+	qsort( sorted, numfiles, 4, paksort );
+
+	for ( i = 0 ; i < numfiles ; i++ ) {
+		pakfile = FS_BuildOSPath( path, dir, sorted[i] );
+		if ( ( pak = FS_LoadZipFile( pakfile, sorted[i] ) ) == 0 )
+			continue;
+		// store the game name for downloading
+		strcpy(pak->pakGamename, dir);
+
+		search = (searchpath_s *)Z_Malloc (sizeof(searchpath_t), TAG_FILESYS, qtrue);
+		search->pack = pak;
+
+		if (fs_dirbeforepak && fs_dirbeforepak->integer && thedir)
+		{
+			searchpath_t *oldnext = thedir->next;
+			thedir->next = search;
+
+			while (oldnext)
+			{
+				search->next = oldnext;
+				search = search->next;
+				oldnext = oldnext->next;
+			}
+		}
+		else
+		{
+			search->next = fs_searchpaths;
+			fs_searchpaths = search;
+		}
+	}
+
+	// done
+	Sys_FreeFileList( pakfiles );
+}
+
+/*
+================
+FS_idPak
+================
+*/
+qboolean FS_idPak( char *pak, char *base ) {
+	int i;
+
+	for (i = 0; i < NUM_ID_PAKS; i++) {
+		if ( !FS_FilenameCompare(pak, va("%s/assets%d", base, i)) ) {
+			break;
+		}
+	}
+	if (i < NUM_ID_PAKS) {
+		return qtrue;
+	}
+	return qfalse;
+}
+
+/*
+================
+FS_ComparePaks
+
+if dlstring == qtrue
+
+Returns a list of pak files that we should download from the server. They all get stored
+in the current gamedir and an FS_Restart will be fired up after we download them all.
+
+The string is the format:
+
+@remotename@localname [repeat]
+
+static int		fs_numServerReferencedPaks;
+static int		fs_serverReferencedPaks[MAX_SEARCH_PATHS];
+static char		*fs_serverReferencedPakNames[MAX_SEARCH_PATHS];
+
+----------------
+dlstring == qfalse
+
+we are not interested in a download string format, we want something human-readable
+(this is used for diagnostics while connecting to a pure server)
+================
+*/
+qboolean FS_ComparePaks( char *neededpaks, int len, qboolean dlstring ) {
+	searchpath_t	*sp;
+	qboolean havepak, badchecksum;
+	int i;
+
+	if ( !fs_numServerReferencedPaks ) {
+		return qfalse; // Server didn't send any pack information along
+	}
+
+	*neededpaks = 0;
+
+	for ( i = 0 ; i < fs_numServerReferencedPaks ; i++ ) {
+		// Ok, see if we have this pak file
+		badchecksum = qfalse;
+		havepak = qfalse;
+
+		// never autodownload any of the id paks
+		if ( FS_idPak(fs_serverReferencedPakNames[i], "base") || FS_idPak(fs_serverReferencedPakNames[i], "missionpack") ) {
+			continue;
+		}
+
+		for ( sp = fs_searchpaths ; sp ; sp = sp->next ) {
+			if ( sp->pack && sp->pack->checksum == fs_serverReferencedPaks[i] ) {
+				havepak = qtrue; // This is it!
+				break;
+			}
+		}
+
+		if ( !havepak && fs_serverReferencedPakNames[i] && *fs_serverReferencedPakNames[i] ) { 
+			// Don't got it
+			
+			if (dlstring)
+			{
+				// Remote name
+				Q_strcat( neededpaks, len, "@");
+				Q_strcat( neededpaks, len, fs_serverReferencedPakNames[i] );
+				Q_strcat( neededpaks, len, ".pk3" );
+				
+				// Local name
+				Q_strcat( neededpaks, len, "@");
+				// Do we have one with the same name?
+				if ( FS_SV_FileExists( va( "%s.pk3", fs_serverReferencedPakNames[i] ) ) ) {
+					char st[MAX_ZPATH];
+					// We already have one called this, we need to download it to another name
+					// Make something up with the checksum in it
+					Com_sprintf( st, sizeof( st ), "%s.%08x.pk3", fs_serverReferencedPakNames[i], fs_serverReferencedPaks[i] );
+					Q_strcat( neededpaks, len, st );
+				} else {
+					Q_strcat( neededpaks, len, fs_serverReferencedPakNames[i] );
+					Q_strcat( neededpaks, len, ".pk3" );
+				}
+			}
+			else
+			{
+				Q_strcat( neededpaks, len, fs_serverReferencedPakNames[i] );
+				Q_strcat( neededpaks, len, ".pk3" );
+				// Do we have one with the same name?
+				if ( FS_SV_FileExists( va( "%s.pk3", fs_serverReferencedPakNames[i] ) ) )
+				{
+					Q_strcat( neededpaks, len, " (local file exists with wrong checksum)");
+				}
+				Q_strcat( neededpaks, len, "\n");
+			}
+		}
+	}
+	if ( *neededpaks ) {
+		return qtrue;
+	}
+
+	return qfalse; // We have them all
+}
+
+/*
+================
+FS_Shutdown
+
+Frees all resources and closes all files
+================
+*/
+void FS_Shutdown( qboolean closemfp ) {
+	searchpath_t	*p, *next;
+	int	i;
+
+	for(i = 0; i < MAX_FILE_HANDLES; i++) {
+		if (fsh[i].fileSize) {
+			FS_FCloseFile(i);
+		}
+	}
+
+	// free everything
+	for ( p = fs_searchpaths ; p ; p = next ) {
+		next = p->next;
+
+		if ( p->pack ) {
+			unzClose(p->pack->handle);
+			Z_Free( p->pack->buildBuffer );
+			Z_Free( p->pack );
+		}
+		if ( p->dir ) {
+			Z_Free( p->dir );
+		}
+		Z_Free( p );
+	}
+
+	// any FS_ calls will now be an error until reinitialized
+	fs_searchpaths = NULL;
+
+	Cmd_RemoveCommand( "path" );
+	Cmd_RemoveCommand( "dir" );
+	Cmd_RemoveCommand( "fdir" );
+	Cmd_RemoveCommand( "touchFile" );
+
+#ifdef FS_MISSING
+	if (closemfp) {
+		fclose(missingFiles);
+	}
+#endif
+}
+
+#ifdef USE_CD_KEY
+
+void Com_AppendCDKey( const char *filename );
+void Com_ReadCDKey( const char *filename );
+
+#endif // USE_CD_KEY
+
+//rww - add search paths in for received svc_setgame
+void FS_UpdateGamedir(void)
+{
+	if ( fs_gamedirvar->string[0] && Q_stricmp( fs_gamedirvar->string, BASEGAME ) )
+	{
+		if (fs_cdpath->string[0])
+		{
+			FS_AddGameDirectory(fs_cdpath->string, fs_gamedirvar->string);
+		}
+		if (fs_basepath->string[0])
+		{
+			FS_AddGameDirectory(fs_basepath->string, fs_gamedirvar->string);
+		}
+		if (fs_homepath->string[0] && Q_stricmp(fs_homepath->string,fs_basepath->string))
+		{
+			FS_AddGameDirectory(fs_homepath->string, fs_gamedirvar->string);
+		}
+	}
+}
+
+/*
+================
+FS_Startup
+================
+*/
+static void FS_Startup( const char *gameName ) {
+        const char *homePath;
+#ifdef USE_CD_KEY
+	cvar_t	*fs;
+#endif	// USE_CD_KEY
+
+	Com_Printf( "----- FS_Startup -----\n" );
+
+	fs_debug = Cvar_Get( "fs_debug", "0", 0 );
+	fs_copyfiles = Cvar_Get( "fs_copyfiles", "0", CVAR_INIT );
+	fs_cdpath = Cvar_Get ("fs_cdpath", Sys_DefaultCDPath(), CVAR_INIT );
+	fs_basepath = Cvar_Get ("fs_basepath", Sys_DefaultInstallPath(), CVAR_INIT );
+	fs_basegame = Cvar_Get ("fs_basegame", "", CVAR_INIT );
+  homePath = Sys_DefaultHomePath();
+  if (!homePath || !homePath[0]) {
+		homePath = fs_basepath->string;
+	}
+	fs_homepath = Cvar_Get ("fs_homepath", homePath, CVAR_INIT );
+	fs_gamedirvar = Cvar_Get ("fs_game", "", CVAR_INIT|CVAR_SYSTEMINFO );
+	fs_restrict = Cvar_Get ("fs_restrict", "", CVAR_INIT );
+
+	fs_dirbeforepak = Cvar_Get("fs_dirbeforepak", "0", CVAR_INIT);
+
+	// add search path elements in reverse priority order
+	if (fs_cdpath->string[0]) {
+		FS_AddGameDirectory( fs_cdpath->string, gameName );
+	}
+	if (fs_basepath->string[0]) {
+		FS_AddGameDirectory( fs_basepath->string, gameName );
+	}
+  // fs_homepath is somewhat particular to *nix systems, only add if relevant
+  // NOTE: same filtering below for mods and basegame
+	if (fs_basepath->string[0] && Q_stricmp(fs_homepath->string,fs_basepath->string)) {
+		FS_AddGameDirectory ( fs_homepath->string, gameName );
+	}
+        
+	// check for additional base game so mods can be based upon other mods
+	if ( fs_basegame->string[0] && !Q_stricmp( gameName, BASEGAME ) && Q_stricmp( fs_basegame->string, gameName ) ) {
+		if (fs_cdpath->string[0]) {
+			FS_AddGameDirectory(fs_cdpath->string, fs_basegame->string);
+		}
+		if (fs_basepath->string[0]) {
+			FS_AddGameDirectory(fs_basepath->string, fs_basegame->string);
+		}
+		if (fs_homepath->string[0] && Q_stricmp(fs_homepath->string,fs_basepath->string)) {
+			FS_AddGameDirectory(fs_homepath->string, fs_basegame->string);
+		}
+	}
+
+	// check for additional game folder for mods
+	if ( fs_gamedirvar->string[0] && !Q_stricmp( gameName, BASEGAME ) && Q_stricmp( fs_gamedirvar->string, gameName ) ) {
+		if (fs_cdpath->string[0]) {
+			FS_AddGameDirectory(fs_cdpath->string, fs_gamedirvar->string);
+		}
+		if (fs_basepath->string[0]) {
+			FS_AddGameDirectory(fs_basepath->string, fs_gamedirvar->string);
+		}
+		if (fs_homepath->string[0] && Q_stricmp(fs_homepath->string,fs_basepath->string)) {
+			FS_AddGameDirectory(fs_homepath->string, fs_gamedirvar->string);
+		}
+	}
+
+#ifdef USE_CD_KEY
+	Com_ReadCDKey( "base" );
+	fs = Cvar_Get ("fs_game", "", CVAR_INIT|CVAR_SYSTEMINFO );
+	if (fs && fs->string[0] != 0) {
+		Com_AppendCDKey( fs->string );
+	}
+#endif // USE_CD_KEY
+
+	// add our commands
+	Cmd_AddCommand ("path", FS_Path_f);
+	Cmd_AddCommand ("dir", FS_Dir_f );
+	Cmd_AddCommand ("fdir", FS_NewDir_f );
+	Cmd_AddCommand ("touchFile", FS_TouchFile_f );
+
+	// print the current search paths
+	FS_Path_f();
+
+	fs_gamedirvar->modified = qfalse; // We just loaded, it's not modified
+
+	Com_Printf( "----------------------\n" );
+
+#ifdef FS_MISSING
+	if (missingFiles == NULL) {
+		missingFiles = fopen( "\\missing.txt", "ab" );
+	}
+#endif
+	Com_Printf( "%d files in pk3 files\n", fs_packFiles );
+}
+
+
+/*
+===================
+FS_SetRestrictions
+
+Looks for product keys and restricts media add on ability
+if the full version is not found
+===================
+*/
+static void FS_SetRestrictions( void ) {
+	searchpath_t	*path;
+
+#ifndef PRE_RELEASE_DEMO
+	char	*productId;
+
+	// if fs_restrict is set, don't even look for the id file,
+	// which allows the demo release to be tested even if
+	// the full game is present
+	if ( !fs_restrict->integer ) {
+		// look for the full game id
+		FS_ReadFile( "productid.txt", (void **)&productId );
+		if ( productId ) {
+			// check against the hardcoded string
+			int		seed, i;
+
+			seed = 102270;
+			for ( i = 0 ; i < sizeof( fs_scrambledProductId ) ; i++ ) {
+				if ( ( fs_scrambledProductId[i] ^ (seed&255) ) != productId[i] ) {
+					break;
+				}
+				seed = (69069 * seed + 1);
+			}
+
+			FS_FreeFile( productId );
+
+			if ( i == sizeof( fs_scrambledProductId ) ) {
+				return;	// no restrictions
+			}
+			Com_Error( ERR_FATAL, "Invalid product identification" );
+		}
+	}
+#endif
+	Cvar_Set( "fs_restrict", "1" );
+
+	Com_Printf( "\nRunning in restricted demo mode.\n\n" );
+
+	// restart the filesystem with just the demo directory
+	FS_Shutdown(qfalse);
+	FS_Startup( DEMOGAME );
+
+	// make sure that the pak file has the header checksum we expect
+	for ( path = fs_searchpaths ; path ; path = path->next ) {
+		if ( path->pack ) {
+			// a tiny attempt to keep the checksum from being scannable from the exe
+			if ( (path->pack->checksum ^ 0x02261994u) != (DEMO_PAK_CHECKSUM ^ 0x02261994u) ) {
+				Com_Error( ERR_FATAL, "Corrupted pak0.pk3: %u", path->pack->checksum );
+			}
+		}
+	}
+}
+
+/*
+=====================
+FS_GamePureChecksum
+
+Returns the checksum of the pk3 from which the server loaded the qagame.qvm
+=====================
+*/
+const char *FS_GamePureChecksum( void ) {
+	static char	info[MAX_STRING_TOKENS];
+	searchpath_t *search;
+
+	info[0] = 0;
+
+	for ( search = fs_searchpaths ; search ; search = search->next ) {
+		// is the element a pak file?
+		if ( search->pack ) {
+			if (search->pack->referenced & FS_QAGAME_REF) {
+				Com_sprintf(info, sizeof(info), "%d", search->pack->checksum);
+			}
+		}
+	}
+
+	return info;
+}
+
+/*
+=====================
+FS_LoadedPakChecksums
+
+Returns a space separated string containing the checksums of all loaded pk3 files.
+Servers with sv_pure set will get this string and pass it to clients.
+=====================
+*/
+const char *FS_LoadedPakChecksums( void ) {
+	static char	info[BIG_INFO_STRING];
+	searchpath_t	*search;
+
+	info[0] = 0;
+
+	for ( search = fs_searchpaths ; search ; search = search->next ) {
+		// is the element a pak file? 
+		if ( !search->pack ) {
+			continue;
+		}
+
+		Q_strcat( info, sizeof( info ), va("%i ", search->pack->checksum ) );
+	}
+
+	return info;
+}
+
+/*
+=====================
+FS_LoadedPakNames
+
+Returns a space separated string containing the names of all loaded pk3 files.
+Servers with sv_pure set will get this string and pass it to clients.
+=====================
+*/
+const char *FS_LoadedPakNames( void ) {
+	static char	info[BIG_INFO_STRING];
+	searchpath_t	*search;
+
+	info[0] = 0;
+
+	for ( search = fs_searchpaths ; search ; search = search->next ) {
+		// is the element a pak file?
+		if ( !search->pack ) {
+			continue;
+		}
+
+		if (*info) {
+			Q_strcat(info, sizeof( info ), " " );
+		}
+		Q_strcat( info, sizeof( info ), search->pack->pakBasename );
+	}
+
+	return info;
+}
+
+/*
+=====================
+FS_LoadedPakPureChecksums
+
+Returns a space separated string containing the pure checksums of all loaded pk3 files.
+Servers with sv_pure use these checksums to compare with the checksums the clients send
+back to the server.
+=====================
+*/
+const char *FS_LoadedPakPureChecksums( void ) {
+	static char	info[BIG_INFO_STRING];
+	searchpath_t	*search;
+
+	info[0] = 0;
+
+	for ( search = fs_searchpaths ; search ; search = search->next ) {
+		// is the element a pak file? 
+		if ( !search->pack ) {
+			continue;
+		}
+
+		Q_strcat( info, sizeof( info ), va("%i ", search->pack->pure_checksum ) );
+	}
+
+	return info;
+}
+
+/*
+=====================
+FS_ReferencedPakChecksums
+
+Returns a space separated string containing the checksums of all referenced pk3 files.
+The server will send this to the clients so they can check which files should be auto-downloaded. 
+=====================
+*/
+const char *FS_ReferencedPakChecksums( void ) {
+	static char	info[BIG_INFO_STRING];
+	searchpath_t *search;
+
+	info[0] = 0;
+
+
+	for ( search = fs_searchpaths ; search ; search = search->next ) {
+		// is the element a pak file?
+		if ( search->pack ) {
+			if (search->pack->referenced || Q_stricmpn(search->pack->pakGamename, BASEGAME, strlen(BASEGAME))) {
+				Q_strcat( info, sizeof( info ), va("%i ", search->pack->checksum ) );
+			}
+		}
+	}
+
+	return info;
+}
+
+/*
+=====================
+FS_ReferencedPakPureChecksums
+
+Returns a space separated string containing the pure checksums of all referenced pk3 files.
+Servers with sv_pure set will get this string back from clients for pure validation 
+
+The string has a specific order, "cgame ui @ ref1 ref2 ref3 ..."
+=====================
+*/
+const char *FS_ReferencedPakPureChecksums( void ) {
+	static char	info[BIG_INFO_STRING];
+	searchpath_t	*search;
+	int nFlags, numPaks, checksum;
+
+	info[0] = 0;
+
+	checksum = fs_checksumFeed;
+	numPaks = 0;
+	for (nFlags = FS_CGAME_REF; nFlags; nFlags = nFlags >> 1) {
+		if (nFlags & FS_GENERAL_REF) {
+			// add a delimter between must haves and general refs
+			//Q_strcat(info, sizeof(info), "@ ");
+			info[strlen(info)+1] = '\0';
+			info[strlen(info)+2] = '\0';
+			info[strlen(info)] = '@';
+			info[strlen(info)] = ' ';
+		}
+		for ( search = fs_searchpaths ; search ; search = search->next ) {
+			// is the element a pak file and has it been referenced based on flag?
+			if ( search->pack && (search->pack->referenced & nFlags)) {
+				Q_strcat( info, sizeof( info ), va("%i ", search->pack->pure_checksum ) );
+				if (nFlags & (FS_CGAME_REF | FS_UI_REF)) {
+					break;
+				}
+				checksum ^= search->pack->pure_checksum;
+				numPaks++;
+			}
+		}
+		if (fs_fakeChkSum != 0) {
+			// only added if a non-pure file is referenced
+			Q_strcat( info, sizeof( info ), va("%i ", fs_fakeChkSum ) );
+		}
+	}
+	// last checksum is the encoded number of referenced pk3s
+	checksum ^= numPaks;
+	Q_strcat( info, sizeof( info ), va("%i ", checksum ) );
+
+	return info;
+}
+
+/*
+=====================
+FS_ReferencedPakNames
+
+Returns a space separated string containing the names of all referenced pk3 files.
+The server will send this to the clients so they can check which files should be auto-downloaded. 
+=====================
+*/
+const char *FS_ReferencedPakNames( void ) {
+	static char	info[BIG_INFO_STRING];
+	searchpath_t	*search;
+
+	info[0] = 0;
+
+	// we want to return ALL pk3's from the fs_game path
+	// and referenced one's from base
+	for ( search = fs_searchpaths ; search ; search = search->next ) {
+		// is the element a pak file?
+		if ( search->pack ) {
+			if (*info) {
+				Q_strcat(info, sizeof( info ), " " );
+			}
+			if (search->pack->referenced || Q_stricmpn(search->pack->pakGamename, BASEGAME, strlen(BASEGAME))) {
+				Q_strcat( info, sizeof( info ), search->pack->pakGamename );
+				Q_strcat( info, sizeof( info ), "/" );
+				Q_strcat( info, sizeof( info ), search->pack->pakBasename );
+			}
+		}
+	}
+
+	return info;
+}
+
+/*
+=====================
+FS_ClearPakReferences
+=====================
+*/
+void FS_ClearPakReferences( int flags ) {
+	searchpath_t *search;
+
+	if ( !flags ) {
+		flags = -1;
+	}
+	for ( search = fs_searchpaths; search; search = search->next ) {
+		// is the element a pak file and has it been referenced?
+		if ( search->pack ) {
+			search->pack->referenced &= ~flags;
+		}
+	}
+}
+
+
+/*
+=====================
+FS_PureServerSetLoadedPaks
+
+If the string is empty, all data sources will be allowed.
+If not empty, only pk3 files that match one of the space
+separated checksums will be checked for files, with the
+exception of .cfg and .dat files.
+=====================
+*/
+void FS_PureServerSetLoadedPaks( const char *pakSums, const char *pakNames ) {
+	int		i, c, d;
+
+	Cmd_TokenizeString( pakSums );
+
+	c = Cmd_Argc();
+	if ( c > MAX_SEARCH_PATHS ) {
+		c = MAX_SEARCH_PATHS;
+	}
+
+	fs_numServerPaks = c;
+
+	for ( i = 0 ; i < c ; i++ ) {
+		fs_serverPaks[i] = atoi( Cmd_Argv( i ) );
+	}
+
+	if (fs_numServerPaks) {
+		Com_DPrintf( "Connected to a pure server.\n" );
+	}
+
+	for ( i = 0 ; i < c ; i++ ) {
+		if (fs_serverPakNames[i]) {
+			Z_Free(fs_serverPakNames[i]);
+		}
+		fs_serverPakNames[i] = NULL;
+	}
+	if ( pakNames && *pakNames ) {
+		Cmd_TokenizeString( pakNames );
+
+		d = Cmd_Argc();
+		if ( d > MAX_SEARCH_PATHS ) {
+			d = MAX_SEARCH_PATHS;
+		}
+
+		for ( i = 0 ; i < d ; i++ ) {
+			fs_serverPakNames[i] = CopyString( Cmd_Argv( i ) );
+		}
+	}
+}
+
+/*
+=====================
+FS_PureServerSetReferencedPaks
+
+The checksums and names of the pk3 files referenced at the server
+are sent to the client and stored here. The client will use these
+checksums to see if any pk3 files need to be auto-downloaded. 
+=====================
+*/
+void FS_PureServerSetReferencedPaks( const char *pakSums, const char *pakNames ) {
+	int		i, c, d;
+
+	Cmd_TokenizeString( pakSums );
+
+	c = Cmd_Argc();
+	if ( c > MAX_SEARCH_PATHS ) {
+		c = MAX_SEARCH_PATHS;
+	}
+
+	fs_numServerReferencedPaks = c;
+
+	for ( i = 0 ; i < c ; i++ ) {
+		fs_serverReferencedPaks[i] = atoi( Cmd_Argv( i ) );
+	}
+
+	for ( i = 0 ; i < c ; i++ ) {
+		if (fs_serverReferencedPakNames[i]) {
+			Z_Free(fs_serverReferencedPakNames[i]);
+		}
+		fs_serverReferencedPakNames[i] = NULL;
+	}
+	if ( pakNames && *pakNames ) {
+		Cmd_TokenizeString( pakNames );
+
+		d = Cmd_Argc();
+		if ( d > MAX_SEARCH_PATHS ) {
+			d = MAX_SEARCH_PATHS;
+		}
+
+		for ( i = 0 ; i < d ; i++ ) {
+			fs_serverReferencedPakNames[i] = CopyString( Cmd_Argv( i ) );
+		}
+	}
+}
+
+/*
+================
+FS_InitFilesystem
+
+Called only at inital startup, not when the filesystem
+is resetting due to a game change
+================
+*/
+void FS_InitFilesystem( void ) {
+	// allow command line parms to override our defaults
+	// we have to specially handle this, because normal command
+	// line variable sets don't happen until after the filesystem
+	// has already been initialized
+	Com_StartupVariable( "fs_cdpath" );
+	Com_StartupVariable( "fs_basepath" );
+	Com_StartupVariable( "fs_homepath" );
+	Com_StartupVariable( "fs_game" );
+	Com_StartupVariable( "fs_copyfiles" );
+	Com_StartupVariable( "fs_restrict" );
+
+	// try to start up normally
+	FS_Startup( BASEGAME );
+
+	// see if we are going to allow add-ons
+	FS_SetRestrictions();
+
+	// if we can't find default.cfg, assume that the paths are
+	// busted and error out now, rather than getting an unreadable
+	// graphics screen when the font fails to load
+	if ( FS_ReadFile( "mpdefault.cfg", NULL ) <= 0 ) {
+		Com_Error( ERR_FATAL, "Couldn't load mpdefault.cfg" );
+		// bk001208 - SafeMode see below, FIXME?
+	}
+
+	Q_strncpyz(lastValidBase, fs_basepath->string, sizeof(lastValidBase));
+	Q_strncpyz(lastValidGame, fs_gamedirvar->string, sizeof(lastValidGame));
+
+  // bk001208 - SafeMode see below, FIXME?
+}
+
+
+/*
+================
+FS_Restart
+================
+*/
+void FS_Restart( int checksumFeed ) {
+
+	// free anything we currently have loaded
+	FS_Shutdown(qfalse);
+
+	// set the checksum feed
+	fs_checksumFeed = checksumFeed;
+
+	// clear pak references
+	FS_ClearPakReferences(0);
+
+	// try to start up normally
+	FS_Startup( BASEGAME );
+
+	// see if we are going to allow add-ons
+	FS_SetRestrictions();
+
+	// if we can't find default.cfg, assume that the paths are
+	// busted and error out now, rather than getting an unreadable
+	// graphics screen when the font fails to load
+	if ( FS_ReadFile( "mpdefault.cfg", NULL ) <= 0 ) {
+		// this might happen when connecting to a pure server not using BASEGAME/pak0.pk3
+		// (for instance a TA demo server)
+		if (lastValidBase[0]) {
+			FS_PureServerSetLoadedPaks("", "");
+			Cvar_Set("fs_basepath", lastValidBase);
+			Cvar_Set("fs_gamedirvar", lastValidGame);
+			lastValidBase[0] = '\0';
+			lastValidGame[0] = '\0';
+			Cvar_Set( "fs_restrict", "0" );
+			FS_Restart(checksumFeed);
+			Com_Error( ERR_DROP, "Invalid game folder\n" );
+			return;
+		}
+		Com_Error( ERR_FATAL, "Couldn't load mpdefault.cfg" );
+	}
+
+	// bk010116 - new check before safeMode
+	if ( Q_stricmp(fs_gamedirvar->string, lastValidGame) ) {
+		// skip the jk2mpconfig.cfg if "safe" is on the command line
+		if ( !Com_SafeMode() ) {
+#ifdef DEDICATED
+			Cbuf_AddText ("exec jk2mpserver.cfg\n");
+#else
+			Cbuf_AddText ("exec jk2mpconfig.cfg\n");
+#endif
+		}
+	}
+
+	Q_strncpyz(lastValidBase, fs_basepath->string, sizeof(lastValidBase));
+	Q_strncpyz(lastValidGame, fs_gamedirvar->string, sizeof(lastValidGame));
+
+}
+
+/*
+=================
+FS_ConditionalRestart
+restart if necessary
+=================
+*/
+qboolean FS_ConditionalRestart( int checksumFeed ) {
+	if( fs_gamedirvar->modified || checksumFeed != fs_checksumFeed ) {
+		FS_Restart( checksumFeed );
+		return qtrue;
+	}
+	return qfalse;
+}
+
+/*
+========================================================================================
+
+Handle based file calls for virtual machines
+
+========================================================================================
+*/
+
+int		FS_FOpenFileByMode( const char *qpath, fileHandle_t *f, fsMode_t mode ) {
+	int		r;
+	qboolean	sync;
+
+	sync = qfalse;
+
+	switch( mode ) {
+	case FS_READ:
+		r = FS_FOpenFileRead( qpath, f, qtrue );
+		break;
+	case FS_WRITE:
+		*f = FS_FOpenFileWrite( qpath );
+		r = 0;
+		if (*f == 0) {
+			r = -1;
+		}
+		break;
+	case FS_APPEND_SYNC:
+		sync = qtrue;
+	case FS_APPEND:
+		*f = FS_FOpenFileAppend( qpath );
+		r = 0;
+		if (*f == 0) {
+			r = -1;
+		}
+		break;
+	default:
+		Com_Error( ERR_FATAL, "FSH_FOpenFile: bad mode" );
+		return -1;
+	}
+
+	if (!f) {
+		return r;
+	}
+
+	if ( *f ) {
+		if (fsh[*f].zipFile == qtrue) {
+			fsh[*f].baseOffset = unztell(fsh[*f].handleFiles.file.z);
+		} else {
+			fsh[*f].baseOffset = ftell(fsh[*f].handleFiles.file.o);
+		}
+		fsh[*f].fileSize = r;
+		fsh[*f].streamed = qfalse;
+
+		if (mode == FS_READ) {
+			Sys_BeginStreamedFile( *f, 0x4000 );
+			fsh[*f].streamed = qtrue;
+		}
+	}
+	fsh[*f].handleSync = sync;
+
+	return r;
+}
+
+int		FS_FTell( fileHandle_t f ) {
+	int pos;
+	if (fsh[f].zipFile == qtrue) {
+		pos = unztell(fsh[f].handleFiles.file.z);
+	} else {
+		pos = ftell(fsh[f].handleFiles.file.o);
+	}
+	return pos;
+}
+
+void	FS_Flush( fileHandle_t f ) {
+	fflush(fsh[f].handleFiles.file.o);
+}
+
diff --git a/codemp/qcommon/files.h b/codemp/qcommon/files.h
new file mode 100644
index 0000000..390ec45
--- /dev/null
+++ b/codemp/qcommon/files.h
@@ -0,0 +1,158 @@
+#ifndef __FILES_H
+#define __FILES_H
+
+/*
+   Structures local to the files_* modules.
+*/
+
+#ifdef _XBOX
+#include "../goblib/goblib.h"
+
+typedef int wfhandle_t;
+#else
+#include "../zlib32/zip.h"
+#include "unzip.h"
+#endif
+
+#define	BASEGAME			"base"
+#define	DEMOGAME			"demo"
+
+// every time a new demo pk3 file is built, this checksum must be updated.
+// the easiest way to get it is to just run the game and see what it spits out
+#define	DEMO_PAK_CHECKSUM	437558517u
+
+// if this is defined, the executable positively won't work with any paks other
+// than the demo pak, even if productid is present.  This is only used for our
+// last demo release to prevent the mac and linux users from using the demo
+// executable with the production windows pak before the mac/linux products
+// hit the shelves a little later
+// NOW defined in build files
+//#define PRE_RELEASE_TADEMO
+
+#define MAX_ZPATH			256
+#define	MAX_SEARCH_PATHS	4096
+#define MAX_FILEHASH_SIZE	1024
+
+typedef struct fileInPack_s {
+	char					*name;		// name of the file
+	unsigned long			pos;		// file info position in zip
+	struct	fileInPack_s*	next;		// next file in the hash
+} fileInPack_t;
+
+typedef struct {
+	char			pakFilename[MAX_OSPATH];	// c:\quake3\base\pak0.pk3
+	char			pakBasename[MAX_OSPATH];	// pak0
+	char			pakGamename[MAX_OSPATH];	// base
+#ifndef _XBOX
+	unzFile			handle;						// handle to zip file
+#endif
+	int				checksum;					// regular checksum
+	int				pure_checksum;				// checksum for pure
+	int				numfiles;					// number of files in pk3
+	int				referenced;					// referenced file flags
+	int				hashSize;					// hash table size (power of 2)
+	fileInPack_t*	*hashTable;					// hash table
+	fileInPack_t*	buildBuffer;				// buffer with the filenames etc.
+} pack_t;
+
+typedef struct {
+	char		path[MAX_OSPATH];		// c:\jk2
+	char		gamedir[MAX_OSPATH];	// base
+} directory_t;
+
+typedef struct searchpath_s {
+	struct searchpath_s *next;
+
+	pack_t		*pack;		// only one of pack / dir will be non NULL
+	directory_t	*dir;
+} searchpath_t;
+
+
+typedef union qfile_gus {
+	FILE*		o;
+#ifndef _XBOX
+	unzFile		z;
+#endif
+} qfile_gut;
+
+typedef struct qfile_us {
+	qfile_gut	file;
+	qboolean	unique;
+} qfile_ut;
+
+
+typedef struct {
+	qfile_ut	handleFiles;
+	qboolean	handleSync;
+	int			baseOffset;
+	int			fileSize;
+	int			zipFilePos;
+	qboolean	zipFile;
+	qboolean	streamed;
+	char		name[MAX_ZPATH];
+
+#ifdef _XBOX
+	GOBHandle	ghandle;
+	qboolean	gob;
+	qboolean	used;
+	wfhandle_t  whandle;
+#endif
+} fileHandleData_t;
+
+
+extern char			fs_gamedir[MAX_OSPATH];	// this will be a single file name with no separators
+extern cvar_t		*fs_debug;
+extern cvar_t		*fs_homepath;
+extern cvar_t		*fs_basepath;
+extern cvar_t		*fs_basegame;
+extern cvar_t		*fs_cdpath;
+extern cvar_t		*fs_copyfiles;
+extern cvar_t		*fs_gamedirvar;
+extern cvar_t		*fs_restrict;
+extern cvar_t		*fs_dirbeforepak; //rww - when building search path, keep directories at top and insert pk3's under them
+extern searchpath_t	*fs_searchpaths;
+extern int			fs_readCount;			// total bytes read
+extern int			fs_loadCount;			// total files read
+extern int			fs_loadStack;			// total files in memory
+extern int			fs_packFiles;			// total number of files in packs
+
+extern int			fs_fakeChkSum;
+extern int			fs_checksumFeed;
+
+extern fileHandleData_t	fsh[MAX_FILE_HANDLES];
+
+extern qboolean		initialized;
+
+// never load anything from pk3 files that are not present at the server when pure
+extern int		fs_numServerPaks;
+extern int		fs_serverPaks[MAX_SEARCH_PATHS];				// checksums
+extern char		*fs_serverPakNames[MAX_SEARCH_PATHS];			// pk3 names
+
+// only used for autodownload, to make sure the client has at least
+// all the pk3 files that are referenced at the server side
+extern int		fs_numServerReferencedPaks;
+extern int		fs_serverReferencedPaks[MAX_SEARCH_PATHS];			// checksums
+extern char		*fs_serverReferencedPakNames[MAX_SEARCH_PATHS];		// pk3 names
+
+// last valid game folder used
+extern char		lastValidBase[MAX_OSPATH];
+extern char		lastValidGame[MAX_OSPATH];
+
+#ifdef FS_MISSING
+extern FILE*	missingFiles;
+#endif
+
+
+void			FS_Startup( const char *gameName );
+qboolean		FS_CreatePath(char *OSPath);
+char			*FS_BuildOSPath( const char *base, const char *game, const char *qpath );
+char			*FS_BuildOSPath( const char *qpath );
+fileHandle_t	FS_HandleForFile(void);
+qboolean		FS_FilenameCompare( const char *s1, const char *s2 );
+int				FS_SV_FOpenFileRead( const char *filename, fileHandle_t *fp );
+void			FS_Shutdown( void );
+void			FS_SetRestrictions(void);
+void			FS_CheckInit(void);
+void			FS_ReplaceSeparators( char *path );
+
+#endif
diff --git a/codemp/qcommon/files_common.cpp b/codemp/qcommon/files_common.cpp
new file mode 100644
index 0000000..ce4bd75
--- /dev/null
+++ b/codemp/qcommon/files_common.cpp
@@ -0,0 +1,512 @@
+/*****************************************************************************
+ * name:		files.c
+ *
+ * desc:		handle based filesystem for Quake III Arena 
+ *
+ *****************************************************************************/
+
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+#include "../client/client.h"
+//#include "../zlib32/zip.h"
+//#include "unzip.h"
+#include "files.h"
+
+//#include <windows.h> //rww - included to make fs_copyfiles 2 related functions happy.
+#include "platform.h"
+
+/*
+=============================================================================
+
+QUAKE3 FILESYSTEM
+
+All of Quake's data access is through a hierarchical file system, but the contents of 
+the file system can be transparently merged from several sources.
+
+A "qpath" is a reference to game file data.  MAX_ZPATH is 256 characters, which must include
+a terminating zero. "..", "\\", and ":" are explicitly illegal in qpaths to prevent any
+references outside the quake directory system.
+
+The "base path" is the path to the directory holding all the game directories and usually
+the executable.  It defaults to ".", but can be overridden with a "+set fs_basepath c:\quake3"
+command line to allow code debugging in a different directory.  Basepath cannot
+be modified at all after startup.  Any files that are created (demos, screenshots,
+etc) will be created reletive to the base path, so base path should usually be writable.
+
+The "cd path" is the path to an alternate hierarchy that will be searched if a file
+is not located in the base path.  A user can do a partial install that copies some
+data to a base path created on their hard drive and leave the rest on the cd.  Files
+are never writen to the cd path.  It defaults to a value set by the installer, like
+"e:\quake3", but it can be overridden with "+set ds_cdpath g:\quake3".
+
+If a user runs the game directly from a CD, the base path would be on the CD.  This
+should still function correctly, but all file writes will fail (harmlessly).
+
+The "home path" is the path used for all write access. On win32 systems we have "base path"
+== "home path", but on *nix systems the base installation is usually readonly, and
+"home path" points to ~/.q3a or similar
+
+The user can also install custom mods and content in "home path", so it should be searched
+along with "home path" and "cd path" for game content.
+
+
+The "base game" is the directory under the paths where data comes from by default, and
+can be either "base" or "demo".
+
+The "current game" may be the same as the base game, or it may be the name of another
+directory under the paths that should be searched for files before looking in the base game.
+This is the basis for addons.
+
+Clients automatically set the game directory after receiving a gamestate from a server,
+so only servers need to worry about +set fs_game.
+
+No other directories outside of the base game and current game will ever be referenced by
+filesystem functions.
+
+To save disk space and speed loading, directory trees can be collapsed into zip files.
+The files use a ".pk3" extension to prevent users from unzipping them accidentally, but
+otherwise the are simply normal uncompressed zip files.  A game directory can have multiple
+zip files of the form "pak0.pk3", "pak1.pk3", etc.  Zip files are searched in decending order
+from the highest number to the lowest, and will always take precedence over the filesystem.
+This allows a pk3 distributed as a patch to override all existing data.
+
+Because we will have updated executables freely available online, there is no point to
+trying to restrict demo / oem versions of the game with code changes.  Demo / oem versions
+should be exactly the same executables as release versions, but with different data that
+automatically restricts where game media can come from to prevent add-ons from working.
+
+After the paths are initialized, quake will look for the product.txt file.  If not
+found and verified, the game will run in restricted mode.  In restricted mode, only 
+files contained in demoq3/pak0.pk3 will be available for loading, and only if the zip header is
+verified to not have been modified.  A single exception is made for jampconfig.cfg.  Files
+can still be written out in restricted mode, so screenshots and demos are allowed.
+Restricted mode can be tested by setting "+set fs_restrict 1" on the command line, even
+if there is a valid product.txt under the basepath or cdpath.
+
+If not running in restricted mode, and a file is not found in any local filesystem,
+an attempt will be made to download it and save it under the base path.
+
+If the "fs_copyfiles" cvar is set to 1, then every time a file is sourced from the cd
+path, it will be copied over to the base path.  This is a development aid to help build
+test releases and to copy working sets over slow network links.
+(If set to 2, copying will only take place if the two filetimes are NOT EQUAL)
+
+File search order: when FS_FOpenFileRead gets called it will go through the fs_searchpaths
+structure and stop on the first successful hit. fs_searchpaths is built with successive
+calls to FS_AddGameDirectory
+
+Additionaly, we search in several subdirectories:
+current game is the current mode
+base game is a variable to allow mods based on other mods
+(such as base + missionpack content combination in a mod for instance)
+BASEGAME is the hardcoded base game ("base")
+
+e.g. the qpath "sound/newstuff/test.wav" would be searched for in the following places:
+
+home path + current game's zip files
+home path + current game's directory
+base path + current game's zip files
+base path + current game's directory
+cd path + current game's zip files
+cd path + current game's directory
+
+home path + base game's zip file
+home path + base game's directory
+base path + base game's zip file
+base path + base game's directory
+cd path + base game's zip file
+cd path + base game's directory
+
+home path + BASEGAME's zip file
+home path + BASEGAME's directory
+base path + BASEGAME's zip file
+base path + BASEGAME's directory
+cd path + BASEGAME's zip file
+cd path + BASEGAME's directory
+
+server download, to be written to home path + current game's directory
+
+
+The filesystem can be safely shutdown and reinitialized with different
+basedir / cddir / game combinations, but all other subsystems that rely on it
+(sound, video) must also be forced to restart.
+
+Because the same files are loaded by both the clip model (CM_) and renderer (TR_)
+subsystems, a simple single-file caching scheme is used.  The CM_ subsystems will
+load the file with a request to cache.  Only one file will be kept cached at a time,
+so any models that are going to be referenced by both subsystems should alternate
+between the CM_ load function and the ref load function.
+
+TODO: A qpath that starts with a leading slash will always refer to the base game, even if another
+game is currently active.  This allows character models, skins, and sounds to be downloaded
+to a common directory no matter which game is active.
+
+How to prevent downloading zip files?
+Pass pk3 file names in systeminfo, and download before FS_Restart()?
+
+Aborting a download disconnects the client from the server.
+
+How to mark files as downloadable?  Commercial add-ons won't be downloadable.
+
+Non-commercial downloads will want to download the entire zip file.
+the game would have to be reset to actually read the zip in
+
+Auto-update information
+
+Path separators
+
+Casing
+
+  separate server gamedir and client gamedir, so if the user starts
+  a local game after having connected to a network game, it won't stick
+  with the network game.
+
+  allow menu options for game selection?
+
+Read / write config to floppy option.
+
+Different version coexistance?
+
+When building a pak file, make sure a jampconfig.cfg isn't present in it,
+or configs will never get loaded from disk!
+
+  todo:
+
+  downloading (outside fs?)
+  game directory passing and restarting
+
+=============================================================================
+
+*/
+
+char		fs_gamedir[MAX_OSPATH];	// this will be a single file name with no separators
+cvar_t		*fs_debug;
+cvar_t		*fs_homepath;
+cvar_t		*fs_basepath;
+cvar_t		*fs_basegame;
+cvar_t		*fs_cdpath;
+cvar_t		*fs_copyfiles;
+cvar_t	*fs_gamedirvar;
+cvar_t		*fs_restrict;
+cvar_t		*fs_dirbeforepak; //rww - when building search path, keep directories at top and insert pk3's under them
+searchpath_t	*fs_searchpaths;
+int			fs_readCount;			// total bytes read
+int			fs_loadCount;			// total files read
+int			fs_loadStack;			// total files in memory
+int			fs_packFiles;			// total number of files in packs
+
+int			fs_fakeChkSum;
+int			fs_checksumFeed;
+
+fileHandleData_t	fsh[MAX_FILE_HANDLES];
+
+
+// never load anything from pk3 files that are not present at the server when pure
+int		fs_numServerPaks;
+int		fs_serverPaks[MAX_SEARCH_PATHS];				// checksums
+char		*fs_serverPakNames[MAX_SEARCH_PATHS];			// pk3 names
+
+// only used for autodownload, to make sure the client has at least
+// all the pk3 files that are referenced at the server side
+int		fs_numServerReferencedPaks;
+int		fs_serverReferencedPaks[MAX_SEARCH_PATHS];			// checksums
+char	*fs_serverReferencedPakNames[MAX_SEARCH_PATHS];		// pk3 names
+
+// last valid game folder used
+char lastValidBase[MAX_OSPATH];
+char lastValidGame[MAX_OSPATH];
+
+#ifdef FS_MISSING
+FILE*		missingFiles = NULL;
+#endif
+
+qboolean initialized = qfalse;
+
+/*
+	Extra utility for checking that FS is up and running
+*/
+void FS_CheckInit(void)
+{
+	if (!initialized)
+	{
+		Com_Error( ERR_FATAL, "Filesystem call made without initialization\n" );
+	}
+}
+
+/*
+==============
+FS_Initialized
+==============
+*/
+
+qboolean FS_Initialized() {
+	return (qboolean)(fs_searchpaths != NULL);
+}
+
+/*
+=================
+FS_LoadStack
+return load stack
+=================
+*/
+int FS_LoadStack()
+{
+	return fs_loadStack;
+}
+
+fileHandle_t FS_HandleForFile(void) {
+	int		i;
+
+	for ( i = 1 ; i < MAX_FILE_HANDLES ; i++ ) {
+		if ( fsh[i].handleFiles.file.o == NULL ) {
+			return i;
+		}
+	}
+	Com_Error( ERR_DROP, "FS_HandleForFile: none free" );
+	return 0;
+}
+
+/*
+====================
+FS_ReplaceSeparators
+
+Fix things up differently for win/unix/mac
+====================
+*/
+void FS_ReplaceSeparators( char *path ) {
+	char	*s;
+
+	for ( s = path ; *s ; s++ ) {
+		if ( *s == '/' || *s == '\\' ) {
+			*s = PATH_SEP;
+		}
+	}
+}
+
+/*
+===================
+FS_BuildOSPath
+
+Qpath may have either forward or backwards slashes
+===================
+*/
+char *FS_BuildOSPath( const char *qpath )
+{
+	char	temp[MAX_OSPATH];
+	static char ospath[2][MAX_OSPATH];
+	static int toggle;
+	
+	toggle ^= 1;		// flip-flop to allow two returns without clash
+
+	// Fix for filenames that are given to FS with a leading "/" (/botfiles/Foo)
+	if (qpath[0] == '\\' || qpath[0] == '/')
+		qpath++;
+
+	// FIXME VVFIXME Holy crap this is wrong.
+//	Com_sprintf( temp, sizeof(temp), "/%s/%s", fs_gamedirvar->string, qpath );
+	Com_sprintf( temp, sizeof(temp), "/%s/%s", "base", qpath );
+
+	FS_ReplaceSeparators( temp );	
+	Com_sprintf( ospath[toggle], sizeof( ospath[0] ), "%s%s", 
+		fs_basepath->string, temp );
+	
+	return ospath[toggle];
+}
+
+char *FS_BuildOSPath( const char *base, const char *game, const char *qpath ) {
+	char	temp[MAX_OSPATH];
+	static char ospath[4][MAX_OSPATH];
+	static int toggle;
+	
+	//pre-fs_cf2
+	//toggle ^= 1;		// flip-flop to allow two returns without clash
+	//post-fs_cf2
+	toggle = (++toggle)&3;	// allows four returns without clash (increased from 2 during fs_copyfiles 2 enhancement)
+
+	if( !game || !game[0] ) {
+		game = fs_gamedir;
+	}
+
+	Com_sprintf( temp, sizeof(temp), "/%s/%s", game, qpath );
+	FS_ReplaceSeparators( temp );	
+	Com_sprintf( ospath[toggle], sizeof( ospath[0] ), "%s%s", base, temp );
+	
+	return ospath[toggle];
+}
+
+/*
+===========
+FS_FilenameCompare
+
+Ignore case and seprator char distinctions
+===========
+*/
+qboolean FS_FilenameCompare( const char *s1, const char *s2 ) {
+	int		c1, c2;
+	
+	do {
+		c1 = *s1++;
+		c2 = *s2++;
+
+		if (c1 >= 'a' && c1 <= 'z') {
+			c1 -= ('a' - 'A');
+		}
+		if (c2 >= 'a' && c2 <= 'z') {
+			c2 -= ('a' - 'A');
+		}
+
+		if ( c1 == '\\' || c1 == ':' ) {
+			c1 = '/';
+		}
+		if ( c2 == '\\' || c2 == ':' ) {
+			c2 = '/';
+		}
+		
+		if (c1 != c2) {
+			return (qboolean)-1;		// strings not equal
+		}
+	} while (c1);
+	
+	return (qboolean)0;		// strings are equal
+}
+
+#define	MAXPRINTMSG	4096
+void QDECL FS_Printf( fileHandle_t h, const char *fmt, ... ) {
+	va_list		argptr;
+	char		msg[MAXPRINTMSG];
+
+	va_start (argptr,fmt);
+	vsprintf (msg,fmt,argptr);
+	va_end (argptr);
+
+	FS_Write(msg, strlen(msg), h);
+}
+
+/*
+======================================================================================
+
+CONVENIENCE FUNCTIONS FOR ENTIRE FILES
+
+======================================================================================
+*/
+
+/*
+============
+FS_WriteFile
+
+Filename are reletive to the quake search path
+============
+*/
+void FS_WriteFile( const char *qpath, const void *buffer, int size ) {
+	fileHandle_t f;
+
+	if ( !fs_searchpaths ) {
+		Com_Error( ERR_FATAL, "Filesystem call made without initialization\n" );
+	}
+
+	if ( !qpath || !buffer ) {
+		Com_Error( ERR_FATAL, "FS_WriteFile: NULL parameter" );
+	}
+
+	f = FS_FOpenFileWrite( qpath );
+	if ( !f ) {
+		Com_Printf( "Failed to open %s\n", qpath );
+		return;
+	}
+
+	FS_Write( buffer, size, f );
+
+	FS_FCloseFile( f );
+}
+
+/*
+================
+FS_Shutdown
+
+Frees all resources and closes all files
+================
+*/
+void FS_Shutdown( qboolean closemfp ) {
+	searchpath_t	*p, *next;
+	int	i;
+
+	for(i = 0; i < MAX_FILE_HANDLES; i++) {
+		if (fsh[i].fileSize) {
+			FS_FCloseFile(i);
+		}
+	}
+
+	// free everything
+	for ( p = fs_searchpaths ; p ; p = next ) {
+		next = p->next;
+
+		if ( p->pack ) {
+#ifndef _XBOX
+			unzClose(p->pack->handle);
+#endif
+			Z_Free( p->pack->buildBuffer );
+			Z_Free( p->pack );
+		}
+		if ( p->dir ) {
+			Z_Free( p->dir );
+		}
+		Z_Free( p );
+	}
+
+	// any FS_ calls will now be an error until reinitialized
+	fs_searchpaths = NULL;
+
+	Cmd_RemoveCommand( "path" );
+	Cmd_RemoveCommand( "dir" );
+	Cmd_RemoveCommand( "fdir" );
+	Cmd_RemoveCommand( "touchFile" );
+
+#ifdef FS_MISSING
+	if (closemfp) {
+		fclose(missingFiles);
+	}
+#endif
+}
+
+/*
+================
+FS_InitFilesystem
+
+Called only at inital startup, not when the filesystem
+is resetting due to a game change
+================
+*/
+void FS_InitFilesystem( void ) {
+	// allow command line parms to override our defaults
+	// we have to specially handle this, because normal command
+	// line variable sets don't happen until after the filesystem
+	// has already been initialized
+	Com_StartupVariable( "fs_cdpath" );
+	Com_StartupVariable( "fs_basepath" );
+	Com_StartupVariable( "fs_homepath" );
+	Com_StartupVariable( "fs_game" );
+	Com_StartupVariable( "fs_copyfiles" );
+	Com_StartupVariable( "fs_restrict" );
+
+	// try to start up normally
+	FS_Startup( BASEGAME );
+	initialized = qtrue;
+
+	// see if we are going to allow add-ons
+	FS_SetRestrictions();
+
+	// if we can't find default.cfg, assume that the paths are
+	// busted and error out now, rather than getting an unreadable
+	// graphics screen when the font fails to load
+	if ( FS_ReadFile( "mpdefault.cfg", NULL ) <= 0 ) {
+		Com_Error( ERR_FATAL, "Couldn't load mpdefault.cfg" );
+		// bk001208 - SafeMode see below, FIXME?
+	}
+
+	Q_strncpyz(lastValidBase, fs_basepath->string, sizeof(lastValidBase));
+	Q_strncpyz(lastValidGame, fs_gamedirvar->string, sizeof(lastValidGame));
+
+  // bk001208 - SafeMode see below, FIXME?
+}
+
diff --git a/codemp/qcommon/files_console.cpp b/codemp/qcommon/files_console.cpp
new file mode 100644
index 0000000..51ee5fc
--- /dev/null
+++ b/codemp/qcommon/files_console.cpp
@@ -0,0 +1,1031 @@
+
+#include "../game/q_shared.h"
+#include "qcommon.h"
+#include "files.h"
+#include "../win32/win_file.h"
+#include "../zlib/zlib.h"
+
+
+
+static	cvar_t		*fs_openorder;
+
+
+// Zlib Tech Ref says decompression should use about 44kb.  I'll
+// go with 64kb as a safety factor...
+#define ZI_STACKSIZE (64*1024)
+
+static char* zi_stackTop = NULL;
+static char* zi_stackBase = NULL;
+
+
+
+//GOB stuff
+//===========================================================================
+
+struct gi_handleTable
+{
+	wfhandle_t file;
+	bool used;
+};
+
+static gi_handleTable *gi_handles = NULL;
+static int gi_cacheHandle = 0;
+
+static GOBFSHandle gi_open(GOBChar* name, GOBAccessType type)
+{
+	if (type != GOBACCESS_READ) return (GOBFSHandle)0xFFFFFFFF;
+
+	int f;
+	for (f = 0; f < MAX_FILE_HANDLES; ++f)
+	{
+		if (!gi_handles[f].used) break;
+	}
+
+	if (f == MAX_FILE_HANDLES) return (GOBFSHandle)0xFFFFFFFF;
+	
+	gi_handles[f].file = WF_Open(name, true, strstr(name, "assets.gob") ? true : false);
+	if (gi_handles[f].file < 0) return (GOBFSHandle)0xFFFFFFFF;
+	gi_handles[f].used = true;
+
+	return (GOBFSHandle)f;
+}
+
+static GOBBool gi_close(GOBFSHandle* handle)
+{
+	WF_Close(gi_handles[(int)*handle].file);
+	gi_handles[(int)*handle].used = false;
+	return GOB_TRUE;
+}
+
+static GOBInt32 gi_read(GOBFSHandle handle, GOBVoid* buffer, GOBInt32 size)
+{
+	return WF_Read(buffer, size, gi_handles[(int)handle].file);
+}
+
+static GOBInt32 gi_seek(GOBFSHandle handle, GOBInt32 offset, GOBSeekType type)
+{
+	int _type;
+	switch (type) {
+	case GOBSEEK_START: _type = SEEK_SET; break;
+	case GOBSEEK_CURRENT: _type = SEEK_CUR; break;
+	case GOBSEEK_END: _type = SEEK_END; break;
+	default: assert(0); _type = SEEK_SET; break;
+	}
+
+	return WF_Seek(offset, _type, gi_handles[(int)handle].file);
+}
+
+static GOBVoid* gi_alloc(GOBUInt32 size)
+{
+	return Z_Malloc(size, TAG_FILESYS, qfalse, 32);
+}
+
+static GOBVoid gi_free(GOBVoid* ptr)
+{
+	Z_Free(ptr);
+}
+
+static GOBBool cache_open(GOBUInt32 size)
+{
+	for (gi_cacheHandle = 0; gi_cacheHandle < MAX_FILE_HANDLES; ++gi_cacheHandle)
+	{
+		if (!gi_handles[gi_cacheHandle].used) break;
+	}
+
+	if (gi_cacheHandle == MAX_FILE_HANDLES) return GOB_FALSE;
+	
+	gi_handles[gi_cacheHandle].file = WF_Open("z:\\jedi.swap", false, true);
+	if (gi_handles[gi_cacheHandle].file < 0) return GOB_FALSE;
+
+	if (!WF_Resize(size, gi_handles[gi_cacheHandle].file))
+	{
+		WF_Close(gi_handles[gi_cacheHandle].file);
+		return GOB_FALSE;
+	}
+
+	gi_handles[gi_cacheHandle].used = true;
+
+	return GOB_TRUE;
+}
+
+static GOBBool cache_close(GOBVoid)
+{
+	WF_Close(gi_handles[gi_cacheHandle].file);
+	gi_handles[gi_cacheHandle].used = false;
+	return GOB_TRUE;
+}
+
+static GOBInt32 cache_read(GOBVoid* buffer, GOBInt32 size)
+{
+	return WF_Read(buffer, size, gi_handles[gi_cacheHandle].file);
+}
+
+static GOBInt32 cache_write(GOBVoid* buffer, GOBInt32 size)
+{
+	return WF_Write(buffer, size, gi_handles[gi_cacheHandle].file);
+}
+
+static GOBInt32 cache_seek(GOBInt32 offset)
+{
+	return WF_Seek(offset, SEEK_SET, gi_handles[gi_cacheHandle].file);
+}
+
+static voidpf zi_alloc(voidpf opaque, uInt items, uInt size)
+{
+	voidpf ret = zi_stackTop;
+	
+	zi_stackTop += items * size;
+	assert(zi_stackTop < zi_stackBase + ZI_STACKSIZE);
+
+	return ret;
+}
+
+static void zi_free(voidpf opaque, voidpf address)
+{
+}
+
+static GOBInt32 gi_decompress_zlib(GOBVoid* source, GOBUInt32 sourceLen, 
+	GOBVoid* dest, GOBUInt32* destLen)
+{
+	// Copied and modified version of zlib's uncompress()...
+
+	z_stream stream;
+	int err;
+
+	stream.next_in = (Bytef*)source;
+	stream.avail_in = (uInt)sourceLen;
+
+	stream.next_out = (Bytef*)dest;
+	stream.avail_out = (uInt)*destLen;
+	if ((uLong)stream.avail_out != *destLen) return Z_BUF_ERROR;
+
+	stream.zalloc = zi_alloc;
+	stream.zfree = zi_free;
+	zi_stackTop = zi_stackBase;
+
+	err = inflateInit(&stream);
+	if (err != Z_OK) return err;
+
+	err = inflate(&stream, Z_FINISH);
+	if (err != Z_STREAM_END) {
+		inflateEnd(&stream);
+		return err == Z_OK ? Z_BUF_ERROR : err;
+	}
+	*destLen = stream.total_out;
+
+	err = inflateEnd(&stream);
+	return err;
+}
+
+GOBInt32 gi_decompress_null(GOBVoid* source, GOBUInt32 sourceLen, 
+	GOBVoid* dest, GOBUInt32* destLen)
+{
+	if (sourceLen > *destLen) return -1;
+	*destLen = sourceLen;
+
+	memcpy(dest, source, sourceLen);
+	return 0;
+}
+
+#ifdef GOB_PROFILE
+static GOBVoid gi_profileread(GOBUInt32 code)
+{
+	code = LittleLong(code);
+	Sys_Log("gob-prof.dat", &code, sizeof(code), true);
+}
+#endif
+
+//===========================================================================
+
+
+
+
+static void FS_CheckUsed(fileHandle_t f)
+{
+	if (!fsh[f].used)
+	{
+		Com_Error( ERR_FATAL, "Filesystem call attempting to use invalid handle\n" );
+	}
+}
+
+
+int FS_filelength( fileHandle_t f )
+{
+	FS_CheckInit();
+	FS_CheckUsed(f);
+	
+	if (fsh[f].gob)
+	{
+		GOBUInt32 cur, end, crap;
+		GOBSeek(fsh[f].ghandle, 0, GOBSEEK_CURRENT, &cur);
+		GOBSeek(fsh[f].ghandle, 0, GOBSEEK_END, &end);
+		GOBSeek(fsh[f].ghandle, cur, GOBSEEK_START, &crap);
+		
+		return end;
+	}
+	else
+	{
+		int pos = WF_Tell(fsh[f].whandle);
+		WF_Seek(0, SEEK_END, fsh[f].whandle);
+		int end = WF_Tell(fsh[f].whandle);
+		WF_Seek(pos, SEEK_SET, fsh[f].whandle);
+
+		return end;
+	}
+}
+
+
+void FS_FCloseFile( fileHandle_t f )
+{
+	FS_CheckInit();
+	FS_CheckUsed(f);
+
+	if (fsh[f].gob)
+		GOBClose(fsh[f].ghandle);
+	else
+		WF_Close(fsh[f].whandle);
+
+	fsh[f].used = qfalse;
+}
+
+
+fileHandle_t FS_FOpenFileWrite( const char *filename )
+{
+	FS_CheckInit();
+	
+	fileHandle_t f = FS_HandleForFile();
+
+	char* osname = FS_BuildOSPath( filename );
+	fsh[f].whandle = WF_Open(osname, false, false);
+	if (fsh[f].whandle >= 0)
+	{
+		fsh[f].used = qtrue;
+		fsh[f].gob = qfalse;
+		return f;
+	}
+
+	return 0;
+}
+
+
+/*
+===========
+FS_FOpenFileRead
+
+Finds the file in the search path.
+Returns filesize and an open FILE pointer.
+Used for streaming data out of either a
+separate file or a ZIP file.
+===========
+*/
+
+static int FS_FOpenFileReadOS( const char *filename, fileHandle_t f )
+{
+	if (Sys_GetFileCode(filename) != -1)
+	{
+		char* osname = FS_BuildOSPath( filename );
+		fsh[f].whandle = WF_Open(osname, true, false);
+		if (fsh[f].whandle >= 0)
+		{
+			fsh[f].used = qtrue;
+			fsh[f].gob = qfalse;
+			return FS_filelength(f);
+		}
+	}
+	return -1;
+}
+
+
+/*
+===================
+FS_BuildGOBPath
+
+Qpath may have either forward or backwards slashes
+===================
+*/
+static char *FS_BuildGOBPath(const char *qpath )
+{
+	static char path[2][MAX_OSPATH];
+	static int toggle;
+	
+	toggle ^= 1;		// flip-flop to allow two returns without clash
+
+	if (qpath[0] == '\\' || qpath[0] == '/')
+	{
+		Com_sprintf( path[toggle], sizeof( path[0] ), ".%s", qpath );
+	}
+	else
+	{
+		Com_sprintf( path[toggle], sizeof( path[0] ), ".\\%s", qpath );
+	}
+
+//	FS_ReplaceSeparators( path[toggle], '\\' );
+	FS_ReplaceSeparators( path[toggle] );
+	
+	return path[toggle];
+}
+
+
+static int FS_FOpenFileReadGOB( const char *filename, fileHandle_t f )
+{
+	char* gobname = FS_BuildGOBPath( filename );
+	if (GOBOpen(gobname, &fsh[f].ghandle) == GOBERR_OK)
+	{
+		fsh[f].used = qtrue;
+		fsh[f].gob = qtrue;
+		return FS_filelength(f);
+	}
+	return -1;
+}
+
+
+/*
+===========
+FS_FOpenFileRead
+
+Finds the file in the search path.
+Returns filesize and an open FILE pointer.
+Used for streaming data out of either a
+separate file or a ZIP file.
+===========
+*/
+int FS_FOpenFileRead( const char *filename, fileHandle_t *file, qboolean uniqueFILE )
+{
+	FS_CheckInit();
+	
+	if ( file == NULL ) {
+		Com_Error( ERR_FATAL, "FS_FOpenFileRead: NULL 'file' parameter passed\n" );
+	}
+
+	if ( !filename ) {
+		Com_Error( ERR_FATAL, "FS_FOpenFileRead: NULL 'filename' parameter passed\n" );
+	}
+
+	*file = FS_HandleForFile();
+
+	int len;
+	
+	if (fs_openorder->integer == 0)
+	{
+		// Release mode -- read from GOB first
+		len = FS_FOpenFileReadGOB(filename, *file);
+		if (len < 0) len = FS_FOpenFileReadOS(filename, *file);
+	}
+	else
+	{
+		// Debug mode -- external files override GOB
+		len = FS_FOpenFileReadOS(filename, *file);
+		if (len < 0) len = FS_FOpenFileReadGOB(filename, *file);
+	}
+
+	if (len >= 0) return len;
+
+	Com_DPrintf ("Can't find %s\n", filename);
+	
+	*file = 0;
+	return -1;
+}
+
+
+/*
+=================
+FS_Read
+
+Properly handles partial reads
+=================
+*/
+int FS_Read( void *buffer, int len, fileHandle_t f )
+{
+	FS_CheckInit();
+	FS_CheckUsed(f);
+
+	if ( !f )
+	{
+		return 0;
+	}
+	
+	if ( f <= 0  || f >= MAX_FILE_HANDLES )
+	{
+		Com_Error( ERR_FATAL, "FS_Read: Invalid handle %d\n", f );
+	}
+
+	if (fsh[f].gob)
+	{
+		GOBUInt32 size = GOBRead(buffer, len, fsh[f].ghandle);
+		if (size == GOB_INVALID_SIZE)
+		{
+#if defined(FINAL_BUILD)
+			extern void ERR_DiscFail(bool);
+			ERR_DiscFail(false);
+#else
+			Com_Error( ERR_FATAL, "Failed to read from GOB" );
+#endif
+		}
+		return size;
+	}
+	else
+	{
+		return WF_Read(buffer, len, fsh[f].whandle);
+	}
+}
+
+/*
+	MP has FS_Read2 which is supposed to do some extra logic.
+	We don't care, and just call FS_Read()
+*/
+int FS_Read2( void *buffer, int len, fileHandle_t f )
+{
+	return FS_Read(buffer, len, f);
+}
+
+/*
+=================
+FS_Write
+=================
+*/
+int FS_Write( const void *buffer, int len, fileHandle_t f )
+{
+	FS_CheckInit();
+	FS_CheckUsed(f);
+
+	if ( !f )
+	{
+		return 0;
+	}
+	
+	if ( f <= 0  || f >= MAX_FILE_HANDLES )
+	{
+		Com_Error( ERR_FATAL, "FS_Read: Invalid handle %d\n", f );
+	}
+
+	if (fsh[f].gob)
+	{
+		Com_Error( ERR_FATAL, "FS_Write: Cannot write to GOB files %d\n", f );
+	}
+	else
+	{
+		return WF_Write(buffer, len, fsh[f].whandle);
+	}
+
+	return 0;
+}
+
+
+/*
+=================
+FS_Seek
+
+=================
+*/
+int FS_Seek( fileHandle_t f, long offset, int origin )
+{
+	FS_CheckInit();
+	FS_CheckUsed(f);
+
+	if (fsh[f].gob)
+	{
+		int _origin;
+		switch( origin ) {
+		case FS_SEEK_CUR: _origin = GOBSEEK_CURRENT; break;
+		case FS_SEEK_END: _origin = GOBSEEK_END; break;
+		case FS_SEEK_SET: _origin = GOBSEEK_START; break;
+		default:
+			_origin = GOBSEEK_CURRENT;
+			Com_Error( ERR_FATAL, "Bad origin in FS_Seek\n" );
+			break;
+		}
+
+		GOBUInt32 pos;
+		GOBSeek(fsh[f].ghandle, offset, _origin, &pos);
+		return pos;
+	}
+	else
+	{
+		int _origin;
+		switch( origin ) {
+		case FS_SEEK_CUR: _origin = SEEK_CUR; break;
+		case FS_SEEK_END: _origin = SEEK_END; break;
+		case FS_SEEK_SET: _origin = SEEK_SET; break;
+		default:
+			_origin = SEEK_CUR;
+			Com_Error( ERR_FATAL, "Bad origin in FS_Seek\n" );
+			break;
+		}
+
+		return WF_Seek(offset, _origin, fsh[f].whandle);
+	}
+}
+
+
+/*
+=================
+FS_Access
+=================
+*/
+qboolean FS_Access( const char *filename )
+{
+	GOBBool status;
+	
+	FS_CheckInit();
+
+	char* gobname = FS_BuildGOBPath( filename );
+	if (GOBAccess(gobname, &status) != GOBERR_OK || status != GOB_TRUE)
+	{
+		return Sys_GetFileCode( filename ) != -1;
+	}
+
+	return qtrue;
+}
+
+
+/*
+======================================================================================
+
+CONVENIENCE FUNCTIONS FOR ENTIRE FILES
+
+======================================================================================
+*/
+
+#ifdef _JK2MP
+int	FS_FileIsInPAK(const char *filename, int *pChecksum)
+#else
+int	FS_FileIsInPAK(const char *filename)
+#endif
+{
+	FS_CheckInit();
+
+	if ( !filename ) {
+		Com_Error( ERR_FATAL, "FS_FOpenFileRead: NULL 'filename' parameter passed\n" );
+	}
+
+	GOBBool exists;
+	GOBAccess(const_cast<GOBChar*>(filename), &exists);
+
+#ifdef _JK2MP
+	*pChecksum = 0;
+#endif
+
+	return exists ? 1 : -1;
+}
+
+/*
+============
+FS_ReadFile
+
+Filename are relative to the quake search path
+a null buffer will just return the file length without loading
+============
+*/
+int FS_ReadFile( const char *qpath, void **buffer )
+{
+	FS_CheckInit();
+	
+	if ( !qpath || !qpath[0] ) {
+		Com_Error( ERR_FATAL, "FS_ReadFile with empty name\n" );
+	}
+
+	// stop sounds from repeating
+	S_ClearSoundBuffer();
+
+	fileHandle_t h;
+	int len = FS_FOpenFileRead( qpath, &h, qfalse );
+	if ( h == 0 )
+	{
+		if ( buffer ) *buffer = NULL;
+		return -1;
+	}
+	
+	if ( !buffer )
+	{
+		FS_FCloseFile(h);
+		return len;
+	}
+
+	// assume temporary....
+	byte* buf = (byte*)Z_Malloc( len+1, TAG_TEMP_WORKSPACE, qfalse, 32);
+	buf[len]='\0';
+
+//	Z_Label(buf, qpath);
+
+	FS_Read(buf, len, h);
+
+	// guarantee that it will have a trailing 0 for string operations
+	buf[len] = 0;
+	FS_FCloseFile( h );
+
+	*buffer = buf;
+	return len;
+}
+
+
+/*
+=============
+FS_FreeFile
+=============
+*/
+void FS_FreeFile( void *buffer )
+{
+	FS_CheckInit();
+
+	if ( !buffer ) {
+		Com_Error( ERR_FATAL, "FS_FreeFile( NULL )" );
+	}
+
+	Z_Free( buffer );
+}
+
+
+int	FS_FOpenFileByMode( const char *qpath, fileHandle_t *f, fsMode_t mode )
+{
+	FS_CheckInit();
+
+	if (mode != FS_READ)
+	{
+		Com_Error( ERR_FATAL, "FSH_FOpenFile: bad mode" );
+		return -1;
+	}
+	
+	return FS_FOpenFileRead( qpath, f, qtrue );
+}
+
+
+int	FS_FTell( fileHandle_t f )
+{
+	FS_CheckInit();
+	FS_CheckUsed(f);
+
+	if (fsh[f].gob)
+	{
+		GOBUInt32 pos;
+		GOBSeek(fsh[f].ghandle, 0, GOBSEEK_CURRENT, &pos);
+		return pos;
+	}
+	else
+	{
+		return WF_Tell(fsh[f].whandle);
+	}
+}
+
+/*
+================
+FS_Startup
+================
+*/
+void FS_Startup( const char *gameName )
+{
+	Com_Printf( "----- FS_Startup -----\n" );
+
+	fs_openorder = Cvar_Get( "fs_openorder", "0", 0 );
+	fs_debug = Cvar_Get( "fs_debug", "0", 0 );
+	fs_copyfiles = Cvar_Get( "fs_copyfiles", "0", CVAR_INIT );
+	fs_cdpath = Cvar_Get ("fs_cdpath", Sys_DefaultCDPath(), CVAR_INIT );	
+	fs_basepath = Cvar_Get ("fs_basepath", Sys_DefaultBasePath(), CVAR_INIT );
+	fs_gamedirvar = Cvar_Get ("fs_game", "base", CVAR_INIT|CVAR_SERVERINFO );
+	fs_restrict = Cvar_Get ("fs_restrict", "", CVAR_INIT );
+
+	gi_handles = new gi_handleTable[MAX_FILE_HANDLES];
+	for (int f = 0; f < MAX_FILE_HANDLES; ++f)
+	{
+		fsh[f].used = false;
+		gi_handles[f].used = false;
+	}
+
+	zi_stackBase = (char*)Z_Malloc(ZI_STACKSIZE, TAG_FILESYS, qfalse);
+
+	GOBMemoryFuncSet mem;
+	mem.alloc = gi_alloc;
+	mem.free = gi_free;
+	
+	GOBFileSysFuncSet file;
+	file.close = gi_close;
+	file.open = gi_open;
+	file.read = gi_read;
+	file.seek = gi_seek;
+	file.write = NULL;
+	
+	GOBCacheFileFuncSet cache;
+	cache.close = cache_close;
+	cache.open = cache_open;
+	cache.read = cache_read;
+	cache.seek = cache_seek;
+	cache.write = cache_write;
+
+	GOBCodecFuncSet codec = {
+		2, // codecs
+		{
+			{ // Codec 0 - zlib
+				'z', GOB_INFINITE_RATIO, // tag, ratio (ratio is meaningless for decomp)
+				NULL,
+				gi_decompress_zlib,
+			},
+			{ // Codec 1 - null
+				'0', GOB_INFINITE_RATIO, // tag, ratio (ratio is meaningless for decomp)
+				NULL,
+				gi_decompress_null,
+			},
+		}
+	};
+
+	if (
+#ifdef _XBOX
+		GOBInit(&mem, &file, &codec, &cache)
+#else
+		GOBInit(&mem, &file, &codec, NULL)
+#endif
+		!= GOBERR_OK)
+	{
+		Com_Error( ERR_FATAL, "Could not initialize GOB" );
+	}
+
+	char* archive = FS_BuildOSPath( "assets" );
+	if (GOBArchiveOpen(archive, GOBACCESS_READ, GOB_FALSE, GOB_TRUE) != GOBERR_OK)
+	{
+#if defined(FINAL_BUILD)
+		/*
+		extern void ERR_DiscFail(bool);
+		ERR_DiscFail(false);
+		*/
+#else
+		//Com_Error( ERR_FATAL, "Could not initialize GOB" );
+		Cvar_Set("fs_openorder", "1");
+#endif
+	}
+	
+	GOBSetCacheSize(1);
+	GOBSetReadBufferSize(32 * 1024);
+
+#ifdef GOB_PROFILE
+	GOBProfileFuncSet profile = {
+		gi_profileread
+	};
+	GOBSetProfileFuncs(&profile);
+	GOBStartProfile();
+#endif
+
+	Com_Printf( "----------------------\n" );
+}
+
+/*
+============================
+
+DIRECTORY SCANNING FUCNTIONS
+
+============================
+*/
+
+#define	MAX_FOUND_FILES	0x1000
+
+/*
+==================
+FS_AddFileToList
+==================
+*/
+static int FS_AddFileToList( char *name, char *list[MAX_FOUND_FILES], int nfiles ) {
+	int		i;
+
+	if ( nfiles == MAX_FOUND_FILES - 1 ) {
+		return nfiles;
+	}
+	for ( i = 0 ; i < nfiles ; i++ ) {
+		if ( !stricmp( name, list[i] ) ) {
+			return nfiles;		// allready in list
+		}
+	}
+//	list[nfiles] = CopyString( name );
+	list[nfiles] = (char *) Z_Malloc( strlen(name) + 1, TAG_LISTFILES, qfalse );
+	strcpy(list[nfiles], name);
+	nfiles++;
+
+	return nfiles;
+}
+
+/*
+===============
+FS_ListFiles
+
+Returns a uniqued list of files that match the given criteria
+from all search paths
+===============
+*/
+char **FS_ListFiles( const char *path, const char *extension, int *numfiles )
+{
+	char			*netpath;
+	int				numSysFiles;
+	char			**sysFiles;
+	char			*name;
+	int				nfiles = 0;
+	char			**listCopy;
+	char			*list[MAX_FOUND_FILES];
+	int				i;
+
+	FS_CheckInit();
+
+	if ( !path ) {
+		*numfiles = 0;
+		return NULL;
+	}
+
+	// We don't do any fancy searchpath magic here, it's all in the meta-file
+	// that Sys_ListFiles will return
+	netpath = FS_BuildOSPath( path );
+#ifdef _JK2MP
+	sysFiles = Sys_ListFiles( netpath, extension, NULL, &numSysFiles, qfalse );
+#else
+	sysFiles = Sys_ListFiles( netpath, extension, &numSysFiles, qfalse );
+#endif
+	for ( i = 0 ; i < numSysFiles ; i++ ) {
+		// unique the match
+		name = sysFiles[i];
+		nfiles = FS_AddFileToList( name, list, nfiles );
+	}
+	Sys_FreeFileList( sysFiles );
+
+	// return a copy of the list
+	*numfiles = nfiles;
+
+	if ( !nfiles ) {
+		return NULL;
+	}
+
+	listCopy = (char**)Z_Malloc( ( nfiles + 1 ) * sizeof( *listCopy ), TAG_LISTFILES, qfalse);
+	for ( i = 0 ; i < nfiles ; i++ ) {
+		listCopy[i] = list[i];
+	}
+	listCopy[i] = NULL;
+
+	return listCopy;
+}
+
+
+/*
+=================
+FS_FreeFileList
+=================
+*/
+void FS_FreeFileList( char **filelist )
+{
+	int		i;
+
+	FS_CheckInit();
+
+	if ( !filelist ) {
+		return;
+	}
+
+	for ( i = 0 ; filelist[i] ; i++ ) {
+		Z_Free( filelist[i] );
+	}
+
+	Z_Free( filelist );
+}
+
+/*
+===============
+FS_AddFileToListBuf
+===============
+*/
+static int FS_AddFileToListBuf( char *name, char *listbuf, int bufsize, int nfiles )
+{
+	char	*p;
+
+	if ( nfiles == MAX_FOUND_FILES - 1 ) {
+		return nfiles;
+	}
+
+	if (name[0] == '/' || name[0] == '\\') {
+		name++;
+	}
+
+	p = listbuf;
+	while ( *p ) {
+		if ( !stricmp( name, p ) ) {
+			return nfiles;		// already in list
+		}
+		p += strlen( p ) + 1;
+	}
+
+	if ( ( p + strlen( name ) + 2 - listbuf ) > bufsize ) {
+		return nfiles;		// list is full
+	}
+
+	strcpy( p, name );
+	p += strlen( p ) + 1;
+	*p = 0;
+
+	return nfiles + 1;
+}
+
+/*
+================
+FS_GetFileList
+
+Returns a uniqued list of files that match the given criteria
+from all search paths
+================
+*/
+int	FS_GetFileList(  const char *path, const char *extension, char *listbuf, int bufsize )
+{
+	int				nfiles = 0;
+	int				i;
+	char			*netpath;
+	int				numSysFiles;
+	char			**sysFiles;
+	char			*name;
+
+	FS_CheckInit();
+
+	if ( !path ) {
+		return 0;
+	}
+	if ( !extension ) {
+		extension = "";
+	}
+
+	// Prime the file list buffer
+	listbuf[0] = '\0';
+	netpath = FS_BuildOSPath( path );
+#ifdef _JK2MP
+	sysFiles = Sys_ListFiles( netpath, extension, NULL, &numSysFiles, qfalse );
+#else
+	sysFiles = Sys_ListFiles( netpath, extension, &numSysFiles, qfalse );
+#endif
+	for ( i = 0 ; i < numSysFiles ; i++ ) {
+		// unique the match
+		name = sysFiles[i];
+		nfiles = FS_AddFileToListBuf( name, listbuf, bufsize, nfiles );
+	}
+	Sys_FreeFileList( sysFiles );
+
+	return nfiles;
+}
+
+/*
+=================
+ Filesytem STUBS
+=================
+*/
+
+qboolean FS_ConditionalRestart(int checksumFeed)
+{
+	return qfalse;
+}
+
+void FS_ClearPakReferences(int flags)
+{
+	return;
+}
+
+const char *FS_LoadedPakNames(void)
+{
+	return "";
+}
+
+const char *FS_ReferencedPakNames(void)
+{
+	return "";
+}
+
+void FS_SetRestrictions(void)
+{
+	return;
+}
+
+#ifdef _JK2MP
+void FS_Restart(int checksumFeed)
+#else
+void FS_Restart(void)
+#endif
+{
+	return;
+}
+
+qboolean FS_FileExists(const char *file)
+{
+	assert(!"FS_FileExists not implemented on Xbox");
+	return qfalse;
+}
+
+void FS_UpdateGamedir(void)
+{
+	return;
+}
+
+void FS_PureServerSetReferencedPaks(const char *pakSums, const char *pakNames)
+{
+	return;
+}
+
+void FS_PureServerSetLoadedPaks(const char *pakSums, const char *pakNames)
+{
+	return;
+}
+
+const char *FS_ReferencedPakChecksums(void)
+{
+	return "";
+}
+
+const char *FS_LoadedPakChecksums(void)
+{
+	return "";
+}
diff --git a/codemp/qcommon/files_pc.cpp b/codemp/qcommon/files_pc.cpp
new file mode 100644
index 0000000..be51e16
--- /dev/null
+++ b/codemp/qcommon/files_pc.cpp
@@ -0,0 +1,3125 @@
+/*****************************************************************************
+ * name:		files_pc.cpp
+ *
+ * desc:		PC-specific file code
+ *
+ *****************************************************************************/
+
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+#include "../client/client.h"
+//#include "../zlib32/zip.h"
+//#include "unzip.h"
+#include "files.h"
+
+//#include <windows.h> //rww - included to make fs_copyfiles 2 related functions happy.
+#include "platform.h"
+
+// TTimo - https://zerowing.idsoftware.com/bugzilla/show_bug.cgi?id=540
+// wether we did a reorder on the current search path when joining the server
+static qboolean fs_reordered;
+
+// productId: This file is copyright 2003 Raven Software, and may not be duplicated except during a licensed installation of the full commercial version of Star Wars: Jedi Academy
+static const byte fs_scrambledProductId[] = {
+42, 143, 149, 190,  10, 197, 225, 133, 243,  63, 189, 182, 226,  56, 143,  17, 215,  37, 197, 218,  50, 103,  24, 235, 246, 191, 183, 149, 160, 170,
+230,  52, 176, 231,  15, 194, 236, 247, 159, 168, 132, 154,  24, 133,  67,  85,  36,  97,  99,  86, 117, 189, 212, 156, 236, 153,  68,  10, 196, 241,
+39, 219, 156,  88,  93, 198, 200, 232, 142,  67,  45, 209,  53, 186, 228, 241, 162, 127, 213,  83,   7, 121,  11,  93, 123, 243, 148, 240, 229,  42,
+42,   6, 215, 239, 112, 120, 240, 244, 104,  12,  38,  47, 201, 253, 223, 208, 154,  69, 141, 157,  32, 117, 166, 146, 236,  59,  15, 223,  52,  89,
+133,  64, 201,  56, 119,  25, 211, 152, 159,  11,  92,  59, 207,  81, 123,   0, 121, 241, 116,  42,  36, 251,  51, 149,  79, 165,  12, 106, 187, 225,
+203,  99, 102,  69,  97,  81,  27, 107,  81, 178,  63,  35, 185,  64, 115 
+};
+
+
+/*
+=================
+FS_PakIsPure
+=================
+*/
+qboolean FS_PakIsPure( pack_t *pack ) {
+	int i;
+
+	if ( fs_numServerPaks ) {
+    // NOTE TTimo we are matching checksums without checking the pak names
+    //   this means you can have the same pk3 as the server under a different name, you will still get through sv_pure validation
+    //   (what happens when two pk3's have the same checkums? is it a likely situation?)
+    //   also, if there's a wrong checksumed pk3 and autodownload is enabled, the checksum will be appended to the downloaded pk3 name
+		for ( i = 0 ; i < fs_numServerPaks ; i++ ) {
+			// FIXME: also use hashed file names
+			if ( pack->checksum == fs_serverPaks[i] ) {
+				return qtrue;		// on the aproved list
+			}
+		}
+		return qfalse;	// not on the pure server pak list
+	}
+	return qtrue;
+}
+
+
+/*
+================
+return a hash value for the filename
+================
+*/
+static long FS_HashFileName( const char *fname, int hashSize ) {
+	int		i;
+	long	hash;
+	char	letter;
+
+	hash = 0;
+	i = 0;
+	while (fname[i] != '\0') {
+		letter = tolower(fname[i]);
+		if (letter =='.') break;				// don't include extension
+		if (letter =='\\') letter = '/';		// damn path names
+		if (letter == PATH_SEP) letter = '/';		// damn path names
+		hash+=(long)(letter)*(i+119);
+		i++;
+	}
+	hash = (hash ^ (hash >> 10) ^ (hash >> 20));
+	hash &= (hashSize-1);
+	return hash;
+}
+
+
+static FILE	*FS_FileForHandle( fileHandle_t f ) {
+	if ( f < 0 || f > MAX_FILE_HANDLES ) {
+		Com_Error( ERR_DROP, "FS_FileForHandle: out of reange" );
+	}
+	if (fsh[f].zipFile == qtrue) {
+		Com_Error( ERR_DROP, "FS_FileForHandle: can't get FILE on zip file" );
+	}
+	if ( ! fsh[f].handleFiles.file.o ) {
+		Com_Error( ERR_DROP, "FS_FileForHandle: NULL" );
+	}
+	
+	return fsh[f].handleFiles.file.o;
+}
+
+
+void	FS_ForceFlush( fileHandle_t f ) {
+	FILE *file;
+
+	file = FS_FileForHandle(f);
+	setvbuf( file, NULL, _IONBF, 0 );
+}
+
+
+/*
+================
+FS_filelength
+
+If this is called on a non-unique FILE (from a pak file),
+it will return the size of the pak file, not the expected
+size of the file.
+================
+*/
+int FS_filelength( fileHandle_t f ) {
+	int		pos;
+	int		end;
+	FILE*	h;
+
+	h = FS_FileForHandle(f);
+	pos = ftell (h);
+	fseek (h, 0, SEEK_END);
+	end = ftell (h);
+	fseek (h, pos, SEEK_SET);
+
+	return end;
+}
+
+/*
+============
+FS_CreatePath
+
+Creates any directories needed to store the given filename
+============
+*/
+qboolean FS_CreatePath (char *OSPath) {
+	char	*ofs;
+	
+	// make absolutely sure that it can't back up the path
+	// FIXME: is c: allowed???
+	if ( strstr( OSPath, ".." ) || strstr( OSPath, "::" ) ) {
+		Com_Printf( "WARNING: refusing to create relative path \"%s\"\n", OSPath );
+		return qtrue;
+	}
+
+	for (ofs = OSPath+1 ; *ofs ; ofs++) {
+		if (*ofs == PATH_SEP) {	
+			// create the directory
+			*ofs = 0;
+			Sys_Mkdir (OSPath);
+			*ofs = PATH_SEP;
+		}
+	}
+	return qfalse;
+}
+
+/*
+=================
+FS_CopyFile
+
+Copy a fully specified file from one place to another
+=================
+*/
+void FS_CopyFile( char *fromOSPath, char *toOSPath ) {
+	FILE	*f;
+	int		len;
+	byte	*buf;
+
+	Com_Printf( "copy %s to %s\n", fromOSPath, toOSPath );
+
+	if (strstr(fromOSPath, "journal.dat") || strstr(fromOSPath, "journaldata.dat")) {
+		Com_Printf( "Ignoring journal files\n");
+		return;
+	}
+
+	f = fopen( fromOSPath, "rb" );
+	if ( !f ) {
+		return;
+	}
+	fseek (f, 0, SEEK_END);
+	len = ftell (f);
+	fseek (f, 0, SEEK_SET);
+
+	// we are using direct malloc instead of Z_Malloc here, so it
+	// probably won't work on a mac... Its only for developers anyway...
+	buf = (unsigned char *)malloc( len );
+	if (fread( buf, 1, len, f ) != len)
+		Com_Error( ERR_FATAL, "Short read in FS_Copyfiles()\n" );
+	fclose( f );
+
+	if( FS_CreatePath( toOSPath ) ) {
+		return;
+	}
+
+	f = fopen( toOSPath, "wb" );
+	if ( !f ) {
+		return;
+	}
+	if (fwrite( buf, 1, len, f ) != len)
+		Com_Error( ERR_FATAL, "Short write in FS_Copyfiles()\n" );
+	fclose( f );
+	free( buf );
+}
+
+/*
+===========
+FS_Remove
+
+===========
+*/
+void FS_Remove( const char *osPath ) {
+	remove( osPath );
+}
+
+/*
+================
+FS_FileExists
+
+Tests if the file exists in the current gamedir, this DOES NOT
+search the paths.  This is to determine if opening a file to write
+(which always goes into the current gamedir) will cause any overwrites.
+NOTE TTimo: this goes with FS_FOpenFileWrite for opening the file afterwards
+================
+*/
+qboolean FS_FileExists( const char *file )
+{
+	FILE *f;
+	char *testpath;
+
+	testpath = FS_BuildOSPath( fs_homepath->string, fs_gamedir, file );
+
+	f = fopen( testpath, "rb" );
+	if (f) {
+		fclose( f );
+		return qtrue;
+	}
+	return qfalse;
+}
+
+/*
+================
+FS_SV_FileExists
+
+Tests if the file exists 
+================
+*/
+qboolean FS_SV_FileExists( const char *file )
+{
+	FILE *f;
+	char *testpath;
+
+	testpath = FS_BuildOSPath( fs_homepath->string, file, "");
+	testpath[strlen(testpath)-1] = '\0';
+
+	f = fopen( testpath, "rb" );
+	if (f) {
+		fclose( f );
+		return qtrue;
+	}
+	return qfalse;
+}
+
+
+/*
+===========
+FS_SV_FOpenFileWrite
+
+===========
+*/
+fileHandle_t FS_SV_FOpenFileWrite( const char *filename ) {
+	char *ospath;
+	fileHandle_t	f;
+
+	if ( !fs_searchpaths ) {
+		Com_Error( ERR_FATAL, "Filesystem call made without initialization\n" );
+	}
+
+	ospath = FS_BuildOSPath( fs_homepath->string, filename, "" );
+	ospath[strlen(ospath)-1] = '\0';
+
+	f = FS_HandleForFile();
+	fsh[f].zipFile = qfalse;
+
+	if ( fs_debug->integer ) {
+		Com_Printf( "FS_SV_FOpenFileWrite: %s\n", ospath );
+	}
+
+	if( FS_CreatePath( ospath ) ) {
+		return 0;
+	}
+
+	Com_DPrintf( "writing to: %s\n", ospath );
+	fsh[f].handleFiles.file.o = fopen( ospath, "wb" );
+
+	Q_strncpyz( fsh[f].name, filename, sizeof( fsh[f].name ) );
+
+	fsh[f].handleSync = qfalse;
+	if (!fsh[f].handleFiles.file.o) {
+		f = 0;
+	}
+	return f;
+}
+
+/*
+===========
+FS_SV_FOpenFileRead
+search for a file somewhere below the home path, base path or cd path
+we search in that order, matching FS_SV_FOpenFileRead order
+===========
+*/
+int FS_SV_FOpenFileRead( const char *filename, fileHandle_t *fp ) {
+	char *ospath;
+	fileHandle_t	f = 0; // bk001129 - from cvs1.17
+
+	if ( !fs_searchpaths ) {
+		Com_Error( ERR_FATAL, "Filesystem call made without initialization\n" );
+	}
+
+	f = FS_HandleForFile();
+	fsh[f].zipFile = qfalse;
+
+	Q_strncpyz( fsh[f].name, filename, sizeof( fsh[f].name ) );
+
+	// don't let sound stutter
+	S_ClearSoundBuffer();
+
+  // search homepath
+	ospath = FS_BuildOSPath( fs_homepath->string, filename, "" );
+	// remove trailing slash
+	ospath[strlen(ospath)-1] = '\0';
+
+	if ( fs_debug->integer ) {
+		Com_Printf( "FS_SV_FOpenFileRead (fs_homepath): %s\n", ospath );
+	}
+
+	fsh[f].handleFiles.file.o = fopen( ospath, "rb" );
+	fsh[f].handleSync = qfalse;
+  if (!fsh[f].handleFiles.file.o)
+  {
+    // NOTE TTimo on non *nix systems, fs_homepath == fs_basepath, might want to avoid
+    if (Q_stricmp(fs_homepath->string,fs_basepath->string))
+    {
+      // search basepath
+      ospath = FS_BuildOSPath( fs_basepath->string, filename, "" );
+      ospath[strlen(ospath)-1] = '\0';
+
+      if ( fs_debug->integer )
+      {
+        Com_Printf( "FS_SV_FOpenFileRead (fs_basepath): %s\n", ospath );
+      }
+
+      fsh[f].handleFiles.file.o = fopen( ospath, "rb" );
+      fsh[f].handleSync = qfalse;
+
+      if ( !fsh[f].handleFiles.file.o )
+      {
+        f = 0;
+      }
+    }
+  }
+
+	if (!fsh[f].handleFiles.file.o) {
+    // search cd path
+    ospath = FS_BuildOSPath( fs_cdpath->string, filename, "" );
+    ospath[strlen(ospath)-1] = '\0';
+
+    if (fs_debug->integer)
+    {
+      Com_Printf( "FS_SV_FOpenFileRead (fs_cdpath) : %s\n", ospath );
+    }
+
+	  fsh[f].handleFiles.file.o = fopen( ospath, "rb" );
+	  fsh[f].handleSync = qfalse;
+
+	  if( !fsh[f].handleFiles.file.o ) {
+	    f = 0;
+	  }
+  }
+  
+	*fp = f;
+	if (f) {
+		return FS_filelength(f);
+	}
+	return 0;
+}
+
+/*
+===========
+FS_SV_Rename
+
+===========
+*/
+void FS_SV_Rename( const char *from, const char *to ) {
+	char			*from_ospath, *to_ospath;
+
+	if ( !fs_searchpaths ) {
+		Com_Error( ERR_FATAL, "Filesystem call made without initialization\n" );
+	}
+
+	// don't let sound stutter
+	S_ClearSoundBuffer();
+
+	from_ospath = FS_BuildOSPath( fs_homepath->string, from, "" );
+	to_ospath = FS_BuildOSPath( fs_homepath->string, to, "" );
+	from_ospath[strlen(from_ospath)-1] = '\0';
+	to_ospath[strlen(to_ospath)-1] = '\0';
+
+	if ( fs_debug->integer ) {
+		Com_Printf( "FS_SV_Rename: %s --> %s\n", from_ospath, to_ospath );
+	}
+
+	if (rename( from_ospath, to_ospath )) {
+		// Failed, try copying it and deleting the original
+		FS_CopyFile ( from_ospath, to_ospath );
+		FS_Remove ( from_ospath );
+	}
+}
+
+/*
+===========
+FS_Rename
+
+===========
+*/
+void FS_Rename( const char *from, const char *to ) {
+	char			*from_ospath, *to_ospath;
+
+	if ( !fs_searchpaths ) {
+		Com_Error( ERR_FATAL, "Filesystem call made without initialization\n" );
+	}
+
+	// don't let sound stutter
+	S_ClearSoundBuffer();
+
+	from_ospath = FS_BuildOSPath( fs_homepath->string, fs_gamedir, from );
+	to_ospath = FS_BuildOSPath( fs_homepath->string, fs_gamedir, to );
+
+	if ( fs_debug->integer ) {
+		Com_Printf( "FS_Rename: %s --> %s\n", from_ospath, to_ospath );
+	}
+
+	if (rename( from_ospath, to_ospath )) {
+		// Failed, try copying it and deleting the original
+		FS_CopyFile ( from_ospath, to_ospath );
+		FS_Remove ( from_ospath );
+	}
+}
+
+/*
+==============
+FS_FCloseFile
+
+If the FILE pointer is an open pak file, leave it open.
+
+For some reason, other dll's can't just cal fclose()
+on files returned by FS_FOpenFile...
+==============
+*/
+void FS_FCloseFile( fileHandle_t f ) {
+	if ( !fs_searchpaths ) {
+		Com_Error( ERR_FATAL, "Filesystem call made without initialization\n" );
+	}
+
+	if (fsh[f].streamed) {
+		Sys_EndStreamedFile(f);
+	}
+	if (fsh[f].zipFile == qtrue) {
+		unzCloseCurrentFile( fsh[f].handleFiles.file.z );
+		if ( fsh[f].handleFiles.unique ) {
+			unzClose( fsh[f].handleFiles.file.z );
+		}
+		Com_Memset( &fsh[f], 0, sizeof( fsh[f] ) );
+		return;
+	}
+
+	// we didn't find it as a pak, so close it as a unique file
+	if (fsh[f].handleFiles.file.o) {
+		fclose (fsh[f].handleFiles.file.o);
+	}
+	Com_Memset( &fsh[f], 0, sizeof( fsh[f] ) );
+}
+
+/*
+===========
+FS_FOpenFileWrite
+
+===========
+*/
+fileHandle_t FS_FOpenFileWrite( const char *filename ) {
+	char			*ospath;
+	fileHandle_t	f;
+
+	if ( !fs_searchpaths ) {
+		Com_Error( ERR_FATAL, "Filesystem call made without initialization\n" );
+	}
+
+	f = FS_HandleForFile();
+	fsh[f].zipFile = qfalse;
+
+	ospath = FS_BuildOSPath( fs_homepath->string, fs_gamedir, filename );
+
+	if ( fs_debug->integer ) {
+		Com_Printf( "FS_FOpenFileWrite: %s\n", ospath );
+	}
+
+	if( FS_CreatePath( ospath ) ) {
+		return 0;
+	}
+
+	// enabling the following line causes a recursive function call loop
+	// when running with +set logfile 1 +set developer 1
+	//Com_DPrintf( "writing to: %s\n", ospath );
+	fsh[f].handleFiles.file.o = fopen( ospath, "wb" );
+
+	Q_strncpyz( fsh[f].name, filename, sizeof( fsh[f].name ) );
+
+	fsh[f].handleSync = qfalse;
+	if (!fsh[f].handleFiles.file.o) {
+		f = 0;
+	}
+	return f;
+}
+
+/*
+===========
+FS_FOpenFileAppend
+
+===========
+*/
+fileHandle_t FS_FOpenFileAppend( const char *filename ) {
+	char			*ospath;
+	fileHandle_t	f;
+
+	if ( !fs_searchpaths ) {
+		Com_Error( ERR_FATAL, "Filesystem call made without initialization\n" );
+	}
+
+	f = FS_HandleForFile();
+	fsh[f].zipFile = qfalse;
+
+	Q_strncpyz( fsh[f].name, filename, sizeof( fsh[f].name ) );
+
+	// don't let sound stutter
+	S_ClearSoundBuffer();
+
+	ospath = FS_BuildOSPath( fs_homepath->string, fs_gamedir, filename );
+
+	if ( fs_debug->integer ) {
+		Com_Printf( "FS_FOpenFileAppend: %s\n", ospath );
+	}
+
+	if( FS_CreatePath( ospath ) ) {
+		return 0;
+	}
+
+	fsh[f].handleFiles.file.o = fopen( ospath, "ab" );
+	fsh[f].handleSync = qfalse;
+	if (!fsh[f].handleFiles.file.o) {
+		f = 0;
+	}
+	return f;
+}
+
+bool Sys_GetFileTime(LPCSTR psFileName, FILETIME &ft)
+{
+	bool bSuccess = false;
+	HANDLE hFile = INVALID_HANDLE_VALUE;	
+
+	hFile = CreateFile(	psFileName,	// LPCTSTR lpFileName,          // pointer to name of the file
+						GENERIC_READ,			// DWORD dwDesiredAccess,       // access (read-write) mode
+						FILE_SHARE_READ,		// DWORD dwShareMode,           // share mode
+						NULL,					// LPSECURITY_ATTRIBUTES lpSecurityAttributes,	// pointer to security attributes
+						OPEN_EXISTING,			// DWORD dwCreationDisposition,  // how to create
+						FILE_FLAG_NO_BUFFERING,// DWORD dwFlagsAndAttributes,   // file attributes
+						NULL					// HANDLE hTemplateFile          // handle to file with attributes to 
+						);
+
+	if (hFile != INVALID_HANDLE_VALUE)
+	{			
+		if (GetFileTime(hFile,	// handle to file
+						NULL,	// LPFILETIME lpCreationTime
+						NULL,	// LPFILETIME lpLastAccessTime
+						&ft		// LPFILETIME lpLastWriteTime
+						)
+			)
+		{
+			bSuccess = true;
+		}
+
+		CloseHandle(hFile);
+	}
+
+	return bSuccess;
+}
+
+bool Sys_FileOutOfDate( LPCSTR psFinalFileName /* dest */, LPCSTR psDataFileName /* src */ )
+{
+	FILETIME ftFinalFile, ftDataFile;
+
+	if (Sys_GetFileTime(psFinalFileName, ftFinalFile) && Sys_GetFileTime(psDataFileName, ftDataFile))
+	{
+		// timer res only accurate to within 2 seconds on FAT, so can't do exact compare...
+		//
+		//LONG l = CompareFileTime( &ftFinalFile, &ftDataFile );
+		if (  (abs(ftFinalFile.dwLowDateTime - ftDataFile.dwLowDateTime) <= 20000000 ) &&
+				  ftFinalFile.dwHighDateTime == ftDataFile.dwHighDateTime				
+			)
+		{
+			return false;	// file not out of date, ie use it.
+		}
+		return true;	// flag return code to copy over a replacement version of this file
+	}
+
+
+	// extra error check, report as suspicious if you find a file locally but not out on the net.,.
+	//
+	if (com_developer->integer)
+	{
+		if (!Sys_GetFileTime(psDataFileName, ftDataFile))
+		{
+			Com_Printf( "Sys_FileOutOfDate: reading %s but it's not on the net!\n", psFinalFileName);
+		}
+	}
+
+	return false;
+}
+
+bool FS_FileCacheable(const char* const filename) 
+{
+	extern	cvar_t	*com_buildScript;
+	if (com_buildScript && com_buildScript->integer)
+	{ 
+		return true;
+	}
+	return( strchr(filename, '/') != 0 );
+}
+
+/*
+===========
+FS_ShiftedStrStr
+===========
+*/
+char *FS_ShiftedStrStr(const char *string, const char *substring, int shift) {
+	char buf[MAX_STRING_TOKENS];
+	int i;
+
+	for (i = 0; substring[i]; i++) {
+		buf[i] = substring[i] + shift;
+	}
+	buf[i] = '\0';
+	return strstr(string, buf);
+}
+
+/*
+===========
+FS_FOpenFileRead
+
+Finds the file in the search path.
+Returns filesize and an open FILE pointer.
+Used for streaming data out of either a
+separate file or a ZIP file.
+===========
+*/
+extern qboolean		com_fullyInitialized;
+
+int FS_FOpenFileRead( const char *filename, fileHandle_t *file, qboolean uniqueFILE ) {
+	searchpath_t	*search;
+	char			*netpath;
+	pack_t			*pak;
+	fileInPack_t	*pakFile;
+	directory_t		*dir;
+	long			hash;
+	unz_s			*zfi;
+	ZIP_FILE		*temp;
+	int				l;
+	char demoExt[16];
+
+	hash = 0;
+
+	if ( !fs_searchpaths ) {
+		Com_Error( ERR_FATAL, "Filesystem call made without initialization\n" );
+	}
+
+	if ( file == NULL ) {
+		Com_Error( ERR_FATAL, "FS_FOpenFileRead: NULL 'file' parameter passed\n" );
+	}
+
+	if ( !filename ) {
+		Com_Error( ERR_FATAL, "FS_FOpenFileRead: NULL 'filename' parameter passed\n" );
+	}
+
+	Com_sprintf (demoExt, sizeof(demoExt), ".dm_%d",PROTOCOL_VERSION );
+	// qpaths are not supposed to have a leading slash
+	if ( filename[0] == '/' || filename[0] == '\\' ) {
+		filename++;
+	}
+
+	// make absolutely sure that it can't back up the path.
+	// The searchpaths do guarantee that something will always
+	// be prepended, so we don't need to worry about "c:" or "//limbo" 
+	if ( strstr( filename, ".." ) || strstr( filename, "::" ) ) {
+		*file = 0;
+		return -1;
+	}
+
+	// make sure the q3key file is only readable by the quake3.exe at initialization
+	// any other time the key should only be accessed in memory using the provided functions
+	if( com_fullyInitialized && strstr( filename, "q3key" ) ) {
+		*file = 0;
+		return -1;
+	}
+
+	//
+	// search through the path, one element at a time
+	//
+
+	*file = FS_HandleForFile();
+	fsh[*file].handleFiles.unique = uniqueFILE;
+
+	// this new bool is in for an optimisation, if you (eg) opened a BSP file under fs_copyfiles==2,
+	//	then it triggered a copy operation to update your local HD version, then this will re-open the
+	//	file handle on your local version, not the net build. This uses a bit more CPU to re-do the loop
+	//	logic, but should read faster than accessing the net version a second time.
+	//
+	qboolean bFasterToReOpenUsingNewLocalFile = qfalse;
+
+	do
+	{
+		bFasterToReOpenUsingNewLocalFile = qfalse;
+
+		for ( search = fs_searchpaths ; search ; search = search->next ) {
+			//
+			if ( search->pack ) {
+				hash = FS_HashFileName(filename, search->pack->hashSize);
+			}
+			// is the element a pak file?
+			if ( search->pack && search->pack->hashTable[hash] ) {
+				// disregard if it doesn't match one of the allowed pure pak files
+				if ( !FS_PakIsPure(search->pack) ) {
+					continue;
+				}
+
+				// look through all the pak file elements
+				pak = search->pack;
+				pakFile = pak->hashTable[hash];
+				do {
+					// case and separator insensitive comparisons
+					if ( !FS_FilenameCompare( pakFile->name, filename ) ) {
+						// found it!
+
+						// mark the pak as having been referenced and mark specifics on cgame and ui
+						// shaders, txt, arena files  by themselves do not count as a reference as 
+						// these are loaded from all pk3s 
+						// from every pk3 file.. 
+						l = strlen( filename );
+						if ( !(pak->referenced & FS_GENERAL_REF)) {
+							if ( Q_stricmp(filename + l - 7, ".shader") != 0 &&
+								Q_stricmp(filename + l - 4, ".txt") != 0 &&
+								Q_stricmp(filename + l - 4, ".str") != 0 &&
+								Q_stricmp(filename + l - 4, ".cfg") != 0 &&
+								Q_stricmp(filename + l - 4, ".fcf") != 0 &&
+								Q_stricmp(filename + l - 7, ".config") != 0 &&
+								strstr(filename, "levelshots") == NULL &&
+								Q_stricmp(filename + l - 4, ".bot") != 0 &&
+								Q_stricmp(filename + l - 6, ".arena") != 0 &&
+								Q_stricmp(filename + l - 5, ".menu") != 0) {
+								pak->referenced |= FS_GENERAL_REF;
+							}
+						}
+
+						/*
+						FS_ShiftedStrStr(filename, "jampgamex86.dll", -13);
+												  //]^&`cZT`Xk+)!W__
+						FS_ShiftedStrStr(filename, "cgamex86.dll", -7);
+												  //\`Zf^q1/']ee
+						FS_ShiftedStrStr(filename, "uix86.dll", -5);
+												  //pds31)_gg
+						*/
+
+						// jampgame.qvm	- 13
+						// ]^&`cZT`X!di`
+						if (!(pak->referenced & FS_QAGAME_REF))
+						{
+							if (FS_ShiftedStrStr(filename, "]T`cZT`X!di`", 13) ||
+								FS_ShiftedStrStr(filename, "]T`cZT`Xk+)!W__", 13))
+							{
+								pak->referenced |= FS_QAGAME_REF;
+							}
+						}
+						// cgame.qvm	- 7
+						// \`Zf^'jof
+						if (!(pak->referenced & FS_CGAME_REF))
+						{
+							if (FS_ShiftedStrStr(filename , "\\`Zf^'jof", 7) ||
+								FS_ShiftedStrStr(filename , "\\`Zf^q1/']ee", 7))
+							{
+								pak->referenced |= FS_CGAME_REF;
+							}
+						}
+						// ui.qvm		- 5
+						// pd)lqh
+						if (!(pak->referenced & FS_UI_REF))
+						{
+							if (FS_ShiftedStrStr(filename , "pd)lqh", 5) ||
+								FS_ShiftedStrStr(filename , "pds31)_gg", 5))
+							{
+								pak->referenced |= FS_UI_REF;
+							}
+						}
+
+						if ( uniqueFILE ) {
+							// open a new file on the pakfile
+							fsh[*file].handleFiles.file.z = unzReOpen (pak->pakFilename, pak->handle);
+							if (fsh[*file].handleFiles.file.z == NULL) {
+								Com_Error (ERR_FATAL, "Couldn't reopen %s", pak->pakFilename);
+							}
+						} else {
+							fsh[*file].handleFiles.file.z = pak->handle;
+						}
+						Q_strncpyz( fsh[*file].name, filename, sizeof( fsh[*file].name ) );
+						fsh[*file].zipFile = qtrue;
+						zfi = (unz_s *)fsh[*file].handleFiles.file.z;
+						// in case the file was new
+						temp = zfi->file;
+						// set the file position in the zip file (also sets the current file info)
+						unzSetCurrentFileInfoPosition(pak->handle, pakFile->pos);
+						// copy the file info into the unzip structure
+						Com_Memcpy( zfi, pak->handle, sizeof(unz_s) );
+						// we copy this back into the structure
+						zfi->file = temp;
+						// open the file in the zip
+						unzOpenCurrentFile( fsh[*file].handleFiles.file.z );
+						fsh[*file].zipFilePos = pakFile->pos;
+
+						if ( fs_debug->integer ) {
+							Com_Printf( "FS_FOpenFileRead: %s (found in '%s')\n", 
+								filename, pak->pakFilename );
+						}
+	#ifndef DEDICATED
+	#ifndef FINAL_BUILD
+						// Check for unprecached files when in game but not in the menus
+						if((cls.state == CA_ACTIVE) && !(cls.keyCatchers & KEYCATCH_UI))
+						{
+							Com_Printf(S_COLOR_YELLOW "WARNING: File %s not precached\n", filename);
+						}
+	#endif
+	#endif // DEDICATED
+						return zfi->cur_file_info.uncompressed_size;
+					}
+					pakFile = pakFile->next;
+				} while(pakFile != NULL);
+			} else if ( search->dir ) {
+				// check a file in the directory tree
+
+				// if we are running restricted, the only files we
+				// will allow to come from the directory are .cfg files
+				l = strlen( filename );
+		  // FIXME TTimo I'm not sure about the fs_numServerPaks test
+		  // if you are using FS_ReadFile to find out if a file exists,
+		  //   this test can make the search fail although the file is in the directory
+		  // I had the problem on https://zerowing.idsoftware.com/bugzilla/show_bug.cgi?id=8
+		  // turned out I used FS_FileExists instead
+				if ( fs_restrict->integer || fs_numServerPaks ) {
+
+					if ( Q_stricmp( filename + l - 4, ".cfg" )		// for config files
+						&& Q_stricmp( filename + l - 4, ".fcf" )	// force configuration files
+						&& Q_stricmp( filename + l - 5, ".menu" )	// menu files
+						&& Q_stricmp( filename + l - 5, ".game" )	// menu files
+						&& Q_stricmp( filename + l - strlen(demoExt), demoExt )	// menu files
+						&& Q_stricmp( filename + l - 4, ".dat" ) ) {	// for journal files
+						continue;
+					}
+				}
+
+				dir = search->dir;
+				
+				netpath = FS_BuildOSPath( dir->path, dir->gamedir, filename );
+				fsh[*file].handleFiles.file.o = fopen (netpath, "rb");
+				if ( !fsh[*file].handleFiles.file.o ) {
+					continue;
+				}
+
+				if ( Q_stricmp( filename + l - 4, ".cfg" )		// for config files
+					&& Q_stricmp( filename + l - 4, ".fcf" )	// force configuration files
+					&& Q_stricmp( filename + l - 5, ".menu" )	// menu files
+					&& Q_stricmp( filename + l - 5, ".game" )	// menu files
+					&& Q_stricmp( filename + l - strlen(demoExt), demoExt )	// menu files
+					&& Q_stricmp( filename + l - 4, ".dat" ) ) {	// for journal files
+					fs_fakeChkSum = random();
+				}
+				
+				// if running with fs_copyfiles 2, and search path == local, then we need to fail to open
+				//	if the time/date stamp != the network version (so it'll loop round again and use the network path,
+				//	which comes later in the search order)
+				//
+				if ( fs_copyfiles->integer == 2 && fs_cdpath->string[0] && !Q_stricmp( dir->path, fs_basepath->string ) 
+					&& FS_FileCacheable(filename) )
+				{
+					if ( Sys_FileOutOfDate( netpath, FS_BuildOSPath( fs_cdpath->string, dir->gamedir, filename ) ))
+					{
+						fclose(fsh[*file].handleFiles.file.o);
+						fsh[*file].handleFiles.file.o = 0;
+						continue;	//carry on to find the cdpath version.
+					}
+				}      
+
+				Q_strncpyz( fsh[*file].name, filename, sizeof( fsh[*file].name ) );
+				fsh[*file].zipFile = qfalse;
+				if ( fs_debug->integer ) {
+					Com_Printf( "FS_FOpenFileRead: %s (found in '%s/%s')\n", filename,
+						dir->path, dir->gamedir );
+				}
+
+				// if we are getting it from the cdpath, optionally copy it
+				//  to the basepath
+				if ( fs_copyfiles->integer && !Q_stricmp( dir->path, fs_cdpath->string ) ) {
+					char	*copypath;
+
+					copypath = FS_BuildOSPath( fs_basepath->string, dir->gamedir, filename );
+					switch ( fs_copyfiles->integer )
+					{
+						default:
+						case 1:
+						{
+							FS_CopyFile( netpath, copypath );
+						}
+						break;
+
+						case 2:
+						{
+					
+							if (FS_FileCacheable(filename) )
+							{
+								// maybe change this to Com_DPrintf?   On the other hand...
+								//
+								Com_Printf( "fs_copyfiles(2), Copying: %s to %s\n", netpath, copypath );
+								
+								FS_CreatePath( copypath );
+
+								bool bOk = true;
+								if (!CopyFile( netpath, copypath, FALSE ))
+								{
+									DWORD dwAttrs = GetFileAttributes(copypath);
+									SetFileAttributes(copypath, dwAttrs & ~FILE_ATTRIBUTE_READONLY);
+									bOk = !!CopyFile( netpath, copypath, FALSE );
+								}
+
+								if (bOk)
+								{
+									// clear this handle and setup for re-opening of the new local copy...
+									//
+									bFasterToReOpenUsingNewLocalFile = qtrue;
+									fclose(fsh[*file].handleFiles.file.o);
+									fsh[*file].handleFiles.file.o = NULL;
+								}
+							}
+						}
+						break;
+					}
+				}
+
+				if (bFasterToReOpenUsingNewLocalFile)
+				{
+					break;	// and re-read the local copy, not the net version
+				}
+
+	#ifndef DEDICATED
+	#ifndef FINAL_BUILD
+				// Check for unprecached files when in game but not in the menus
+				if((cls.state == CA_ACTIVE) && !(cls.keyCatchers & KEYCATCH_UI))
+				{
+					Com_Printf(S_COLOR_YELLOW "WARNING: File %s not precached\n", filename);
+				}
+	#endif
+	#endif // dedicated
+				return FS_filelength (*file);
+			}		
+		}
+	}
+	while ( bFasterToReOpenUsingNewLocalFile );
+	
+	Com_DPrintf ("Can't find %s\n", filename);
+#ifdef FS_MISSING
+	if (missingFiles) {
+		fprintf(missingFiles, "%s\n", filename);
+	}
+#endif
+	*file = 0;
+	return -1;
+}
+
+
+/*
+=================
+FS_Read
+
+Properly handles partial reads
+=================
+*/
+int FS_Read2( void *buffer, int len, fileHandle_t f ) {
+	if ( !fs_searchpaths ) {
+		Com_Error( ERR_FATAL, "Filesystem call made without initialization\n" );
+	}
+
+	if ( !f ) {
+		return 0;
+	}
+	if (fsh[f].streamed) {
+		int r;
+		fsh[f].streamed = qfalse;
+		r = Sys_StreamedRead( buffer, len, 1, f);
+		fsh[f].streamed = qtrue;
+		return r;
+	} else {
+		return FS_Read( buffer, len, f);
+	}
+}
+
+int FS_Read( void *buffer, int len, fileHandle_t f ) {
+	int		block, remaining;
+	int		read;
+	byte	*buf;
+	int		tries;
+
+	if ( !fs_searchpaths ) {
+		Com_Error( ERR_FATAL, "Filesystem call made without initialization\n" );
+	}
+
+	if ( !f ) {
+		return 0;
+	}
+
+	buf = (byte *)buffer;
+	fs_readCount += len;
+
+	if (fsh[f].zipFile == qfalse) {
+		remaining = len;
+		tries = 0;
+		while (remaining) {
+			block = remaining;
+			read = fread (buf, 1, block, fsh[f].handleFiles.file.o);
+			if (read == 0) {
+				// we might have been trying to read from a CD, which
+				// sometimes returns a 0 read on windows
+				if (!tries) {
+					tries = 1;
+				} else {
+					return len-remaining;	//Com_Error (ERR_FATAL, "FS_Read: 0 bytes read");
+				}
+			}
+
+			if (read == -1) {
+				Com_Error (ERR_FATAL, "FS_Read: -1 bytes read");
+			}
+
+			remaining -= read;
+			buf += read;
+		}
+		return len;
+	} else {
+		return unzReadCurrentFile(fsh[f].handleFiles.file.z, buffer, len);
+	}
+}
+
+/*
+=================
+FS_Write
+
+Properly handles partial writes
+=================
+*/
+int FS_Write( const void *buffer, int len, fileHandle_t h ) {
+	int		block, remaining;
+	int		written;
+	byte	*buf;
+	int		tries;
+	FILE	*f;
+
+	if ( !fs_searchpaths ) {
+		Com_Error( ERR_FATAL, "Filesystem call made without initialization\n" );
+	}
+
+	if ( !h ) {
+		return 0;
+	}
+
+	f = FS_FileForHandle(h);
+	buf = (byte *)buffer;
+
+	remaining = len;
+	tries = 0;
+	while (remaining) {
+		block = remaining;
+		written = fwrite (buf, 1, block, f);
+		if (written == 0) {
+			if (!tries) {
+				tries = 1;
+			} else {
+				Com_Printf( "FS_Write: 0 bytes written\n" );
+				return 0;
+			}
+		}
+
+		if (written == -1) {
+			Com_Printf( "FS_Write: -1 bytes written\n" );
+			return 0;
+		}
+
+		remaining -= written;
+		buf += written;
+	}
+	if ( fsh[h].handleSync ) {
+		fflush( f );
+	}
+	return len;
+}
+
+/*
+=================
+FS_Seek
+
+=================
+*/
+int FS_Seek( fileHandle_t f, long offset, int origin ) {
+	int		_origin;
+	char	foo[65536];
+
+	if ( !fs_searchpaths ) {
+		Com_Error( ERR_FATAL, "Filesystem call made without initialization\n" );
+		return -1;
+	}
+
+	if (fsh[f].streamed) {
+		fsh[f].streamed = qfalse;
+		Sys_StreamSeek( f, offset, origin );
+		fsh[f].streamed = qtrue;
+	}
+
+	if (fsh[f].zipFile == qtrue) {
+		if (offset == 0 && origin == FS_SEEK_SET) {
+			// set the file position in the zip file (also sets the current file info)
+			unzSetCurrentFileInfoPosition(fsh[f].handleFiles.file.z, fsh[f].zipFilePos);
+			return unzOpenCurrentFile(fsh[f].handleFiles.file.z);
+		} else if (offset<65536) {
+			// set the file position in the zip file (also sets the current file info)
+			unzSetCurrentFileInfoPosition(fsh[f].handleFiles.file.z, fsh[f].zipFilePos);
+			unzOpenCurrentFile(fsh[f].handleFiles.file.z);
+			return FS_Read(foo, offset, f);
+		} else {
+			Com_Error( ERR_FATAL, "ZIP FILE FSEEK NOT YET IMPLEMENTED\n" );
+			return -1;
+		}
+	} else {
+		FILE *file;
+		file = FS_FileForHandle(f);
+		switch( origin ) {
+		case FS_SEEK_CUR:
+			_origin = SEEK_CUR;
+			break;
+		case FS_SEEK_END:
+			_origin = SEEK_END;
+			break;
+		case FS_SEEK_SET:
+			_origin = SEEK_SET;
+			break;
+		default:
+			_origin = SEEK_CUR;
+			Com_Error( ERR_FATAL, "Bad origin in FS_Seek\n" );
+			break;
+		}
+
+		return fseek( file, offset, _origin );
+	}
+}
+
+/*
+======================================================================================
+
+CONVENIENCE FUNCTIONS FOR ENTIRE FILES
+
+======================================================================================
+*/
+
+int	FS_FileIsInPAK(const char *filename, int *pChecksum ) {
+	searchpath_t	*search;
+	pack_t			*pak;
+	fileInPack_t	*pakFile;
+	long			hash = 0;
+
+	if ( !fs_searchpaths ) {
+		Com_Error( ERR_FATAL, "Filesystem call made without initialization\n" );
+	}
+
+	if ( !filename ) {
+		Com_Error( ERR_FATAL, "FS_FOpenFileRead: NULL 'filename' parameter passed\n" );
+	}
+
+	// qpaths are not supposed to have a leading slash
+	if ( filename[0] == '/' || filename[0] == '\\' ) {
+		filename++;
+	}
+
+	// make absolutely sure that it can't back up the path.
+	// The searchpaths do guarantee that something will always
+	// be prepended, so we don't need to worry about "c:" or "//limbo" 
+	if ( strstr( filename, ".." ) || strstr( filename, "::" ) ) {
+		return -1;
+	}
+
+	//
+	// search through the path, one element at a time
+	//
+
+	for ( search = fs_searchpaths ; search ; search = search->next ) {
+		//
+		if (search->pack) {
+			hash = FS_HashFileName(filename, search->pack->hashSize);
+		}
+		// is the element a pak file?
+		if ( search->pack && search->pack->hashTable[hash] ) {
+			// disregard if it doesn't match one of the allowed pure pak files
+			if ( !FS_PakIsPure(search->pack) ) {
+				continue;
+			}
+
+			// look through all the pak file elements
+			pak = search->pack;
+			pakFile = pak->hashTable[hash];
+			do {
+				// case and separator insensitive comparisons
+				if ( !FS_FilenameCompare( pakFile->name, filename ) ) {
+					if (pChecksum) {
+						*pChecksum = pak->pure_checksum;
+					}
+					return 1;
+				}
+				pakFile = pakFile->next;
+			} while(pakFile != NULL);
+		}
+	}
+	return -1;
+}
+
+/*
+============
+FS_ReadFile
+
+Filename are relative to the quake search path
+a null buffer will just return the file length without loading
+============
+*/
+int FS_ReadFile( const char *qpath, void **buffer ) {
+	fileHandle_t	h;
+	byte*			buf;
+	qboolean		isConfig;
+	int				len;
+
+	if ( !fs_searchpaths ) {
+		Com_Error( ERR_FATAL, "Filesystem call made without initialization\n" );
+	}
+
+	if ( !qpath || !qpath[0] ) {
+		Com_Error( ERR_FATAL, "FS_ReadFile with empty name\n" );
+	}
+
+	buf = NULL;	// quiet compiler warning
+
+	// if this is a .cfg file and we are playing back a journal, read
+	// it from the journal file
+	if ( strstr( qpath, ".cfg" ) ) {
+		isConfig = qtrue;
+		if ( com_journal && com_journal->integer == 2 ) {
+			int		r;
+
+			Com_DPrintf( "Loading %s from journal file.\n", qpath );
+			r = FS_Read( &len, sizeof( len ), com_journalDataFile );
+			if ( r != sizeof( len ) ) {
+				if (buffer != NULL) *buffer = NULL;
+				return -1;
+			}
+			// if the file didn't exist when the journal was created
+			if (!len) {
+				if (buffer == NULL) {
+					return 1;			// hack for old journal files
+				}
+				*buffer = NULL;
+				return -1;
+			}
+			if (buffer == NULL) {
+				return len;
+			}
+
+			buf = (unsigned char *)Hunk_AllocateTempMemory(len+1);
+			*buffer = buf;
+
+			r = FS_Read( buf, len, com_journalDataFile );
+			if ( r != len ) {
+				Com_Error( ERR_FATAL, "Read from journalDataFile failed" );
+			}
+
+			fs_loadCount++;
+			fs_loadStack++;
+
+			// guarantee that it will have a trailing 0 for string operations
+			buf[len] = 0;
+
+			return len;
+		}
+	} else {
+		isConfig = qfalse;
+	}
+
+	// look for it in the filesystem or pack files
+	len = FS_FOpenFileRead( qpath, &h, qfalse );
+	if ( h == 0 ) {
+		if ( buffer ) {
+			*buffer = NULL;
+		}
+		// if we are journalling and it is a config file, write a zero to the journal file
+		if ( isConfig && com_journal && com_journal->integer == 1 ) {
+			Com_DPrintf( "Writing zero for %s to journal file.\n", qpath );
+			len = 0;
+			FS_Write( &len, sizeof( len ), com_journalDataFile );
+			FS_Flush( com_journalDataFile );
+		}
+		return -1;
+	}
+	
+	if ( !buffer ) {
+		if ( isConfig && com_journal && com_journal->integer == 1 ) {
+			Com_DPrintf( "Writing len for %s to journal file.\n", qpath );
+			FS_Write( &len, sizeof( len ), com_journalDataFile );
+			FS_Flush( com_journalDataFile );
+		}
+		FS_FCloseFile( h);
+		return len;
+	}
+
+	fs_loadCount++;
+/*	fs_loadStack++;
+
+	buf = (unsigned char *)Hunk_AllocateTempMemory(len+1);
+	*buffer = buf;*/
+
+	buf = (byte*)Z_Malloc( len+1, TAG_FILESYS, qfalse);
+	buf[len]='\0';	// because we're not calling Z_Malloc with optional trailing 'bZeroIt' bool
+	*buffer = buf;	
+
+//	Z_Label(buf, qpath);
+
+	FS_Read (buf, len, h);
+
+	// guarantee that it will have a trailing 0 for string operations
+	buf[len] = 0;
+	FS_FCloseFile( h );
+
+	// if we are journalling and it is a config file, write it to the journal file
+	if ( isConfig && com_journal && com_journal->integer == 1 ) {
+		Com_DPrintf( "Writing %s to journal file.\n", qpath );
+		FS_Write( &len, sizeof( len ), com_journalDataFile );
+		FS_Write( buf, len, com_journalDataFile );
+		FS_Flush( com_journalDataFile );
+	}
+	return len;
+}
+
+/*
+=============
+FS_FreeFile
+=============
+*/
+void FS_FreeFile( void *buffer ) {
+	/*	
+	if ( !fs_searchpaths ) {
+		Com_Error( ERR_FATAL, "Filesystem call made without initialization\n" );
+	}
+	if ( !buffer ) {
+		Com_Error( ERR_FATAL, "FS_FreeFile( NULL )" );
+	}
+	fs_loadStack--;
+
+	Hunk_FreeTempMemory( buffer );
+
+	// if all of our temp files are free, clear all of our space
+	if ( fs_loadStack == 0 ) {
+		Hunk_ClearTempMemory();
+	}
+	*/
+
+	if ( !fs_searchpaths ) {
+		Com_Error( ERR_FATAL, "Filesystem call made without initialization\n" );
+	}
+	if ( !buffer ) {
+		Com_Error( ERR_FATAL, "FS_FreeFile( NULL )" );
+	}
+
+	Z_Free( buffer );
+}
+
+/*
+==========================================================================
+
+ZIP FILE LOADING
+
+==========================================================================
+*/
+
+/*
+=================
+FS_LoadZipFile
+
+Creates a new pak_t in the search chain for the contents
+of a zip file.
+=================
+*/
+static pack_t *FS_LoadZipFile( char *zipfile, const char *basename )
+{
+	fileInPack_t	*buildBuffer;
+	pack_t			*pack;
+	unzFile			uf;
+	int				err;
+	unz_global_info gi;
+	char			filename_inzip[MAX_ZPATH];
+	unz_file_info	file_info;
+	int				i, len;
+	long			hash;
+	int				fs_numHeaderLongs;
+	int				*fs_headerLongs;
+	char			*namePtr;
+
+	fs_numHeaderLongs = 0;
+
+	uf = unzOpen(zipfile);
+	err = unzGetGlobalInfo (uf,&gi);
+
+	if (err != UNZ_OK)
+		return NULL;
+
+	fs_packFiles += gi.number_entry;
+
+	len = 0;
+	unzGoToFirstFile(uf);
+	for (i = 0; i < gi.number_entry; i++)
+	{
+		err = unzGetCurrentFileInfo(uf, &file_info, filename_inzip, sizeof(filename_inzip), NULL, 0, NULL, 0);
+		if (err != UNZ_OK) {
+			break;
+		}
+		len += strlen(filename_inzip) + 1;
+		unzGoToNextFile(uf);
+	}
+
+	buildBuffer = (struct fileInPack_s *)Z_Malloc( (gi.number_entry * sizeof( fileInPack_t )) + len, TAG_FILESYS, qtrue );
+	namePtr = ((char *) buildBuffer) + gi.number_entry * sizeof( fileInPack_t );
+	fs_headerLongs = (int *)Z_Malloc( gi.number_entry * sizeof(int), TAG_FILESYS, qtrue );
+
+	// get the hash table size from the number of files in the zip
+	// because lots of custom pk3 files have less than 32 or 64 files
+	for (i = 1; i <= MAX_FILEHASH_SIZE; i <<= 1) {
+		if (i > gi.number_entry) {
+			break;
+		}
+	}
+
+	pack = (pack_t *)Z_Malloc( sizeof( pack_t ) + i * sizeof(fileInPack_t *), TAG_FILESYS, qtrue );
+	pack->hashSize = i;
+	pack->hashTable = (fileInPack_t **) (((char *) pack) + sizeof( pack_t ));
+	for(i = 0; i < pack->hashSize; i++) {
+		pack->hashTable[i] = NULL;
+	}
+
+	Q_strncpyz( pack->pakFilename, zipfile, sizeof( pack->pakFilename ) );
+	Q_strncpyz( pack->pakBasename, basename, sizeof( pack->pakBasename ) );
+
+	// strip .pk3 if needed
+	if ( strlen( pack->pakBasename ) > 4 && !Q_stricmp( pack->pakBasename + strlen( pack->pakBasename ) - 4, ".pk3" ) ) {
+		pack->pakBasename[strlen( pack->pakBasename ) - 4] = 0;
+	}
+
+	pack->handle = uf;
+	pack->numfiles = gi.number_entry;
+	unzGoToFirstFile(uf);
+
+	for (i = 0; i < gi.number_entry; i++)
+	{
+		err = unzGetCurrentFileInfo(uf, &file_info, filename_inzip, sizeof(filename_inzip), NULL, 0, NULL, 0);
+		if (err != UNZ_OK) {
+			break;
+		}
+		if (file_info.uncompressed_size > 0) {
+			fs_headerLongs[fs_numHeaderLongs++] = LittleLong(file_info.crc);
+		}
+		Q_strlwr( filename_inzip );
+		hash = FS_HashFileName(filename_inzip, pack->hashSize);
+		buildBuffer[i].name = namePtr;
+		strcpy( buildBuffer[i].name, filename_inzip );
+		namePtr += strlen(filename_inzip) + 1;
+		// store the file position in the zip
+		unzGetCurrentFileInfoPosition(uf, &buildBuffer[i].pos);
+		//
+		buildBuffer[i].next = pack->hashTable[hash];
+		pack->hashTable[hash] = &buildBuffer[i];
+		unzGoToNextFile(uf);
+	}
+
+	pack->checksum = Com_BlockChecksum( fs_headerLongs, 4 * fs_numHeaderLongs );
+	pack->pure_checksum = Com_BlockChecksumKey( fs_headerLongs, 4 * fs_numHeaderLongs, LittleLong(fs_checksumFeed) );
+	pack->checksum = LittleLong( pack->checksum );
+	pack->pure_checksum = LittleLong( pack->pure_checksum );
+
+	Z_Free(fs_headerLongs);
+
+	pack->buildBuffer = buildBuffer;
+	return pack;
+}
+
+/*
+=================================================================================
+
+DIRECTORY SCANNING FUNCTIONS
+
+=================================================================================
+*/
+
+#define	MAX_FOUND_FILES	0x1000
+
+static int FS_ReturnPath( const char *zname, char *zpath, int *depth ) {
+	int len, at, newdep;
+
+	newdep = 0;
+	zpath[0] = 0;
+	len = 0;
+	at = 0;
+
+	while(zname[at] != 0)
+	{
+		if (zname[at]=='/' || zname[at]=='\\') {
+			len = at;
+			newdep++;
+		}
+		at++;
+	}
+	strcpy(zpath, zname);
+	zpath[len] = 0;
+	*depth = newdep;
+
+	return len;
+}
+
+/*
+==================
+FS_AddFileToList
+==================
+*/
+static int FS_AddFileToList( char *name, char *list[MAX_FOUND_FILES], int nfiles ) {
+	int		i;
+
+	if ( nfiles == MAX_FOUND_FILES - 1 ) {
+		return nfiles;
+	}
+	for ( i = 0 ; i < nfiles ; i++ ) {
+		if ( !Q_stricmp( name, list[i] ) ) {
+			return nfiles;		// allready in list
+		}
+	}
+	list[nfiles] = CopyString( name );
+	nfiles++;
+
+	return nfiles;
+}
+
+/*
+===============
+FS_ListFilteredFiles
+
+Returns a uniqued list of files that match the given criteria
+from all search paths
+===============
+*/
+char **FS_ListFilteredFiles( const char *path, const char *extension, char *filter, int *numfiles ) {
+	int				nfiles;
+	char			**listCopy;
+	char			*list[MAX_FOUND_FILES];
+	searchpath_t	*search;
+	int				i;
+	int				pathLength;
+	int				extensionLength;
+	int				length, pathDepth, temp;
+	pack_t			*pak;
+	fileInPack_t	*buildBuffer;
+	char			zpath[MAX_ZPATH];
+
+	if ( !fs_searchpaths ) {
+		Com_Error( ERR_FATAL, "Filesystem call made without initialization\n" );
+	}
+
+	if ( !path ) {
+		*numfiles = 0;
+		return NULL;
+	}
+	if ( !extension ) {
+		extension = "";
+	}
+
+	pathLength = strlen( path );
+	if ( path[pathLength-1] == '\\' || path[pathLength-1] == '/' ) {
+		pathLength--;
+	}
+	extensionLength = strlen( extension );
+	nfiles = 0;
+	FS_ReturnPath(path, zpath, &pathDepth);
+
+	//
+	// search through the path, one element at a time, adding to list
+	//
+	for (search = fs_searchpaths ; search ; search = search->next) {
+		// is the element a pak file?
+		if (search->pack) {
+
+			//ZOID:  If we are pure, don't search for files on paks that
+			// aren't on the pure list
+			if ( !FS_PakIsPure(search->pack) ) {
+				continue;
+			}
+
+			// look through all the pak file elements
+			pak = search->pack;
+			buildBuffer = pak->buildBuffer;
+			for (i = 0; i < pak->numfiles; i++) {
+				char	*name;
+				int		zpathLen, depth;
+
+				// check for directory match
+				name = buildBuffer[i].name;
+				//
+				if (filter) {
+					// case insensitive
+					if (!Com_FilterPath( filter, name, qfalse ))
+						continue;
+					// unique the match
+					nfiles = FS_AddFileToList( name, list, nfiles );
+				}
+				else {
+
+					zpathLen = FS_ReturnPath(name, zpath, &depth);
+
+					if ( (depth-pathDepth)>2 || pathLength > zpathLen || Q_stricmpn( name, path, pathLength ) ) {
+						continue;
+					}
+
+					// check for extension match
+					length = strlen( name );
+					if ( length < extensionLength ) {
+						continue;
+					}
+
+					if ( Q_stricmp( name + length - extensionLength, extension ) ) {
+						continue;
+					}
+					// unique the match
+
+					temp = pathLength;
+					if (pathLength) {
+						temp++;		// include the '/'
+					}
+					nfiles = FS_AddFileToList( name + temp, list, nfiles );
+				}
+			}
+		} else if (search->dir) { // scan for files in the filesystem
+			char	*netpath;
+			int		numSysFiles;
+			char	**sysFiles;
+			char	*name;
+
+			// don't scan directories for files if we are pure or restricted
+			if ( (fs_restrict->integer || fs_numServerPaks) &&
+				 (!extension || Q_stricmp(extension, "fcf") || fs_restrict->integer) )
+			{
+				//rww - allow scanning for fcf files outside of pak even if pure
+			    continue;
+		    }
+			else
+			{
+				netpath = FS_BuildOSPath( search->dir->path, search->dir->gamedir, path );
+				sysFiles = Sys_ListFiles( netpath, extension, filter, &numSysFiles, qfalse );
+				for ( i = 0 ; i < numSysFiles ; i++ ) {
+					// unique the match
+					name = sysFiles[i];
+					nfiles = FS_AddFileToList( name, list, nfiles );
+				}
+				Sys_FreeFileList( sysFiles );
+			}
+		}		
+	}
+
+	// return a copy of the list
+	*numfiles = nfiles;
+
+	if ( !nfiles ) {
+		return NULL;
+	}
+
+	listCopy = (char **)Z_Malloc( ( nfiles + 1 ) * sizeof( *listCopy ), TAG_FILESYS );
+	for ( i = 0 ; i < nfiles ; i++ ) {
+		listCopy[i] = list[i];
+	}
+	listCopy[i] = NULL;
+
+	return listCopy;
+}
+
+/*
+=================
+FS_ListFiles
+=================
+*/
+char **FS_ListFiles( const char *path, const char *extension, int *numfiles ) {
+	return FS_ListFilteredFiles( path, extension, NULL, numfiles );
+}
+
+/*
+=================
+FS_FreeFileList
+=================
+*/
+void FS_FreeFileList( char **fileList ) {
+	//rwwRMG - changed to fileList to not conflict with list type
+	int		i;
+
+	if ( !fs_searchpaths ) {
+		Com_Error( ERR_FATAL, "Filesystem call made without initialization\n" );
+	}
+
+	if ( !fileList ) {
+		return;
+	}
+
+	for ( i = 0 ; fileList[i] ; i++ ) {
+		Z_Free( fileList[i] );
+	}
+
+	Z_Free( fileList );
+}
+
+
+/*
+================
+FS_GetFileList
+================
+*/
+int	FS_GetFileList(  const char *path, const char *extension, char *listbuf, int bufsize ) {
+	int		nFiles, i, nTotal, nLen;
+	char **pFiles = NULL;
+
+	*listbuf = 0;
+	nFiles = 0;
+	nTotal = 0;
+
+	if (Q_stricmp(path, "$modlist") == 0) {
+		return FS_GetModList(listbuf, bufsize);
+	}
+
+	pFiles = FS_ListFiles(path, extension, &nFiles);
+
+	for (i =0; i < nFiles; i++) {
+		nLen = strlen(pFiles[i]) + 1;
+		if (nTotal + nLen + 1 < bufsize) {
+			strcpy(listbuf, pFiles[i]);
+			listbuf += nLen;
+			nTotal += nLen;
+		}
+		else {
+			nFiles = i;
+			break;
+		}
+	}
+
+	FS_FreeFileList(pFiles);
+
+	return nFiles;
+}
+
+// NOTE: could prolly turn out useful for the win32 version too, but it's used only by linux and Mac OS X
+//#if defined(__linux__) || defined(MACOS_X)
+/*
+=======================
+Sys_ConcatenateFileLists
+
+mkv: Naive implementation. Concatenates three lists into a
+     new list, and frees the old lists from the heap.
+bk001129 - from cvs1.17 (mkv)
+
+FIXME TTimo those two should move to common.c next to Sys_ListFiles
+=======================
+ */
+static unsigned int Sys_CountFileList(char **list)
+{
+  int i = 0;
+
+  if (list)
+  {
+    while (*list)
+    {
+      list++;
+      i++;
+    }
+  }
+  return i;
+}
+
+static char** Sys_ConcatenateFileLists( char **list0, char **list1, char **list2 )
+{
+        int totalLength = 0;
+	char** cat = NULL, **dst, **src;
+
+        totalLength += Sys_CountFileList(list0);
+        totalLength += Sys_CountFileList(list1);
+        totalLength += Sys_CountFileList(list2);
+        
+	/* Create new list. */
+	dst = cat = (char **)Z_Malloc( ( totalLength + 1 ) * sizeof( char* ), TAG_FILESYS, qtrue );
+        
+	/* Copy over lists. */
+        if (list0) {
+            for (src = list0; *src; src++, dst++)
+                *dst = *src;
+        }
+        if (list1) {
+            for (src = list1; *src; src++, dst++)
+                *dst = *src;
+        }
+        if (list2) {
+            for (src = list2; *src; src++, dst++)
+                *dst = *src;
+        }
+
+        // Terminate the list
+	*dst = NULL;
+
+  // Free our old lists.
+  // NOTE: not freeing their content, it's been merged in dst and still being used
+  if (list0) Z_Free( list0 );
+  if (list1) Z_Free( list1 );
+  if (list2) Z_Free( list2 );
+
+	return cat;
+}
+//#endif
+
+/*
+================
+FS_GetModList
+
+Returns a list of mod directory names
+A mod directory is a peer to base with a pk3 in it
+The directories are searched in base path, cd path and home path
+================
+*/
+int	FS_GetModList( char *listbuf, int bufsize ) {
+  int		nMods, i, j, nTotal, nLen, nPaks, nPotential, nDescLen;
+  char **pFiles = NULL;
+  char **pPaks = NULL;
+  char *name, *path;
+  char descPath[MAX_OSPATH];
+  fileHandle_t descHandle;
+
+  int dummy;
+  char **pFiles0 = NULL;
+  char **pFiles1 = NULL;
+  char **pFiles2 = NULL;
+  qboolean bDrop = qfalse;
+
+  *listbuf = 0;
+  nMods = nPotential = nTotal = 0;
+
+  pFiles0 = Sys_ListFiles( fs_homepath->string, NULL, NULL, &dummy, qtrue );
+  pFiles1 = Sys_ListFiles( fs_basepath->string, NULL, NULL, &dummy, qtrue );
+  pFiles2 = Sys_ListFiles( fs_cdpath->string, NULL, NULL, &dummy, qtrue );
+  // we searched for mods in the three paths
+  // it is likely that we have duplicate names now, which we will cleanup below
+  pFiles = Sys_ConcatenateFileLists( pFiles0, pFiles1, pFiles2 );
+  nPotential = Sys_CountFileList(pFiles);
+
+  for ( i = 0 ; i < nPotential ; i++ ) {
+    name = pFiles[i];
+    // NOTE: cleaner would involve more changes
+    // ignore duplicate mod directories
+    if (i!=0) {
+      bDrop = qfalse;
+      for(j=0; j<i; j++)
+      {
+        if (Q_stricmp(pFiles[j],name)==0) {
+          // this one can be dropped
+          bDrop = qtrue;
+          break;
+        }
+      }
+    }
+    if (bDrop) {
+      continue;
+    }
+    // we drop "base" "." and ".."
+    if (Q_stricmp(name, "base") && Q_stricmpn(name, ".", 1)) {
+      // now we need to find some .pk3 files to validate the mod
+      // NOTE TTimo: (actually I'm not sure why .. what if it's a mod under developement with no .pk3?)
+      // we didn't keep the information when we merged the directory names, as to what OS Path it was found under
+      //   so it could be in base path, cd path or home path
+      //   we will try each three of them here (yes, it's a bit messy)
+      path = FS_BuildOSPath( fs_basepath->string, name, "" );
+      nPaks = 0;
+      pPaks = Sys_ListFiles(path, ".pk3", NULL, &nPaks, qfalse); 
+      Sys_FreeFileList( pPaks ); // we only use Sys_ListFiles to check wether .pk3 files are present
+
+      /* Try on cd path */
+      if( nPaks <= 0 ) {
+        path = FS_BuildOSPath( fs_cdpath->string, name, "" );
+        nPaks = 0;
+        pPaks = Sys_ListFiles( path, ".pk3", NULL, &nPaks, qfalse );
+        Sys_FreeFileList( pPaks );
+      }
+
+      /* try on home path */
+      if ( nPaks <= 0 )
+      {
+        path = FS_BuildOSPath( fs_homepath->string, name, "" );
+        nPaks = 0;
+        pPaks = Sys_ListFiles( path, ".pk3", NULL, &nPaks, qfalse );
+        Sys_FreeFileList( pPaks );
+      }
+
+      if (nPaks > 0) {
+        nLen = strlen(name) + 1;
+        // nLen is the length of the mod path
+        // we need to see if there is a description available
+        descPath[0] = '\0';
+        strcpy(descPath, name);
+        strcat(descPath, "/description.txt");
+        nDescLen = FS_SV_FOpenFileRead( descPath, &descHandle );
+        if ( nDescLen > 0 && descHandle) {
+          FILE *file;
+          file = FS_FileForHandle(descHandle);
+          Com_Memset( descPath, 0, sizeof( descPath ) );
+          nDescLen = fread(descPath, 1, 48, file);
+          if (nDescLen >= 0) {
+            descPath[nDescLen] = '\0';
+          }
+          FS_FCloseFile(descHandle);
+        } else {
+          strcpy(descPath, name);
+        }
+        nDescLen = strlen(descPath) + 1;
+
+        if (nTotal + nLen + 1 + nDescLen + 1 < bufsize) {
+          strcpy(listbuf, name);
+          listbuf += nLen;
+          strcpy(listbuf, descPath);
+          listbuf += nDescLen;
+          nTotal += nLen + nDescLen;
+          nMods++;
+        }
+        else {
+          break;
+        }
+      }
+    }
+  }
+  Sys_FreeFileList( pFiles );
+
+  return nMods;
+}
+
+
+
+
+//============================================================================
+
+/*
+================
+FS_Dir_f
+================
+*/
+void FS_Dir_f( void ) {
+	char	*path;
+	char	*extension;
+	char	**dirnames;
+	int		ndirs;
+	int		i;
+
+	if ( Cmd_Argc() < 2 || Cmd_Argc() > 3 ) {
+		Com_Printf( "usage: dir <directory> [extension]\n" );
+		return;
+	}
+
+	if ( Cmd_Argc() == 2 ) {
+		path = Cmd_Argv( 1 );
+		extension = "";
+	} else {
+		path = Cmd_Argv( 1 );
+		extension = Cmd_Argv( 2 );
+	}
+
+	Com_Printf( "Directory of %s %s\n", path, extension );
+	Com_Printf( "---------------\n" );
+
+	dirnames = FS_ListFiles( path, extension, &ndirs );
+
+	for ( i = 0; i < ndirs; i++ ) {
+		Com_Printf( "%s\n", dirnames[i] );
+	}
+	FS_FreeFileList( dirnames );
+}
+
+/*
+===========
+FS_ConvertPath
+===========
+*/
+void FS_ConvertPath( char *s ) {
+	while (*s) {
+		if ( *s == '\\' || *s == ':' ) {
+			*s = '/';
+		}
+		s++;
+	}
+}
+
+/*
+===========
+FS_PathCmp
+
+Ignore case and seprator char distinctions
+===========
+*/
+int FS_PathCmp( const char *s1, const char *s2 ) {
+	int		c1, c2;
+	
+	do {
+		c1 = *s1++;
+		c2 = *s2++;
+
+		if (c1 >= 'a' && c1 <= 'z') {
+			c1 -= ('a' - 'A');
+		}
+		if (c2 >= 'a' && c2 <= 'z') {
+			c2 -= ('a' - 'A');
+		}
+
+		if ( c1 == '\\' || c1 == ':' ) {
+			c1 = '/';
+		}
+		if ( c2 == '\\' || c2 == ':' ) {
+			c2 = '/';
+		}
+		
+		if (c1 < c2) {
+			return -1;		// strings not equal
+		}
+		if (c1 > c2) {
+			return 1;
+		}
+	} while (c1);
+	
+	return 0;		// strings are equal
+}
+
+/*
+================
+FS_SortFileList
+================
+*/
+void FS_SortFileList(char **filelist, int numfiles) {
+	int i, j, k, numsortedfiles;
+	char **sortedlist;
+
+	sortedlist = (char **)Z_Malloc( ( numfiles + 1 ) * sizeof( *sortedlist ), TAG_FILESYS, qtrue );
+	sortedlist[0] = NULL;
+	numsortedfiles = 0;
+	for (i = 0; i < numfiles; i++) {
+		for (j = 0; j < numsortedfiles; j++) {
+			if (FS_PathCmp(filelist[i], sortedlist[j]) < 0) {
+				break;
+			}
+		}
+		for (k = numsortedfiles; k > j; k--) {
+			sortedlist[k] = sortedlist[k-1];
+		}
+		sortedlist[j] = filelist[i];
+		numsortedfiles++;
+	}
+	Com_Memcpy(filelist, sortedlist, numfiles * sizeof( *filelist ) );
+	Z_Free(sortedlist);
+}
+
+/*
+================
+FS_NewDir_f
+================
+*/
+void FS_NewDir_f( void ) {
+	char	*filter;
+	char	**dirnames;
+	int		ndirs;
+	int		i;
+
+	if ( Cmd_Argc() < 2 ) {
+		Com_Printf( "usage: fdir <filter>\n" );
+		Com_Printf( "example: fdir *q3dm*.bsp\n");
+		return;
+	}
+
+	filter = Cmd_Argv( 1 );
+
+	Com_Printf( "---------------\n" );
+
+	dirnames = FS_ListFilteredFiles( "", "", filter, &ndirs );
+
+	FS_SortFileList(dirnames, ndirs);
+
+	for ( i = 0; i < ndirs; i++ ) {
+		FS_ConvertPath(dirnames[i]);
+		Com_Printf( "%s\n", dirnames[i] );
+	}
+	Com_Printf( "%d files listed\n", ndirs );
+	FS_FreeFileList( dirnames );
+}
+
+/*
+============
+FS_Path_f
+
+============
+*/
+void FS_Path_f( void ) {
+	searchpath_t	*s;
+	int				i;
+
+	Com_Printf ("Current search path:\n");
+	for (s = fs_searchpaths; s; s = s->next) {
+		if (s->pack) {
+			Com_Printf ("%s (%i files)\n", s->pack->pakFilename, s->pack->numfiles);
+			if ( fs_numServerPaks ) {
+				if ( !FS_PakIsPure(s->pack) ) {
+					Com_Printf( "    not on the pure list\n" );
+				} else {
+					Com_Printf( "    on the pure list\n" );
+				}
+			}
+		} else {
+			Com_Printf ("%s/%s\n", s->dir->path, s->dir->gamedir );
+		}
+	}
+
+
+	Com_Printf( "\n" );
+	for ( i = 1 ; i < MAX_FILE_HANDLES ; i++ ) {
+		if ( fsh[i].handleFiles.file.o ) {
+			Com_Printf( "handle %i: %s\n", i, fsh[i].name );
+		}
+	}
+}
+
+/*
+============
+FS_TouchFile_f
+
+The only purpose of this function is to allow game script files to copy
+arbitrary files furing an "fs_copyfiles 1" run.
+============
+*/
+void FS_TouchFile_f( void ) {
+	fileHandle_t	f;
+
+	if ( Cmd_Argc() != 2 ) {
+		Com_Printf( "Usage: touchFile <file>\n" );
+		return;
+	}
+
+	FS_FOpenFileRead( Cmd_Argv( 1 ), &f, qfalse );
+	if ( f ) {
+		FS_FCloseFile( f );
+	}
+}
+
+//===========================================================================
+
+
+static int QDECL paksort( const void *a, const void *b ) {
+	char	*aa, *bb;
+
+	aa = *(char **)a;
+	bb = *(char **)b;
+
+	return FS_PathCmp( aa, bb );
+}
+
+/*
+================
+FS_AddGameDirectory
+
+Sets fs_gamedir, adds the directory to the head of the path,
+then loads the zip headers
+================
+*/
+#define	MAX_PAKFILES	1024
+static void FS_AddGameDirectory( const char *path, const char *dir ) {
+	searchpath_t	*sp;
+	int				i;
+	searchpath_t	*search;
+	searchpath_t	*thedir;
+	pack_t			*pak;
+	char			*pakfile;
+	int				numfiles;
+	char			**pakfiles;
+	char			*sorted[MAX_PAKFILES];
+
+	// this fixes the case where fs_basepath is the same as fs_cdpath
+	// which happens on full installs
+	for ( sp = fs_searchpaths ; sp ; sp = sp->next ) {
+		if ( sp->dir && !Q_stricmp(sp->dir->path, path) && !Q_stricmp(sp->dir->gamedir, dir)) {
+			return;			// we've already got this one
+		}
+	}
+	
+	Q_strncpyz( fs_gamedir, dir, sizeof( fs_gamedir ) );
+
+	//
+	// add the directory to the search path
+	//
+	search = (struct searchpath_s *)Z_Malloc (sizeof(searchpath_t), TAG_FILESYS, qtrue);
+	search->dir = (directory_t *)Z_Malloc( sizeof( *search->dir ), TAG_FILESYS, qtrue );
+
+	Q_strncpyz( search->dir->path, path, sizeof( search->dir->path ) );
+	Q_strncpyz( search->dir->gamedir, dir, sizeof( search->dir->gamedir ) );
+	search->next = fs_searchpaths;
+	fs_searchpaths = search;
+
+	thedir = search;
+
+	// find all pak files in this directory
+	pakfile = FS_BuildOSPath( path, dir, "" );
+	pakfile[ strlen(pakfile) - 1 ] = 0;	// strip the trailing slash
+
+	pakfiles = Sys_ListFiles( pakfile, ".pk3", NULL, &numfiles, qfalse );
+
+	// sort them so that later alphabetic matches override
+	// earlier ones.  This makes pak1.pk3 override pak0.pk3
+	if ( numfiles > MAX_PAKFILES ) {
+		numfiles = MAX_PAKFILES;
+	}
+	for ( i = 0 ; i < numfiles ; i++ ) {
+		sorted[i] = pakfiles[i];
+	}
+
+	qsort( sorted, numfiles, 4, paksort );
+
+	for ( i = 0 ; i < numfiles ; i++ ) {
+		pakfile = FS_BuildOSPath( path, dir, sorted[i] );
+		if ( ( pak = FS_LoadZipFile( pakfile, sorted[i] ) ) == 0 )
+			continue;
+		// store the game name for downloading
+		strcpy(pak->pakGamename, dir);
+
+		search = (searchpath_s *)Z_Malloc (sizeof(searchpath_t), TAG_FILESYS, qtrue);
+		search->pack = pak;
+
+		if (fs_dirbeforepak && fs_dirbeforepak->integer && thedir)
+		{
+			searchpath_t *oldnext = thedir->next;
+			thedir->next = search;
+
+			while (oldnext)
+			{
+				search->next = oldnext;
+				search = search->next;
+				oldnext = oldnext->next;
+			}
+		}
+		else
+		{
+			search->next = fs_searchpaths;
+			fs_searchpaths = search;
+		}
+	}
+
+	// done
+	Sys_FreeFileList( pakfiles );
+}
+
+/*
+================
+FS_idPak
+================
+*/
+qboolean FS_idPak( char *pak, char *base ) {
+	int i;
+
+	for (i = 0; i < NUM_ID_PAKS; i++) {
+		if ( !FS_FilenameCompare(pak, va("%s/assets%d", base, i)) ) {
+			break;
+		}
+	}
+	if (i < NUM_ID_PAKS) {
+		return qtrue;
+	}
+	return qfalse;
+}
+
+/*
+================
+FS_ComparePaks
+
+if dlstring == qtrue
+
+Returns a list of pak files that we should download from the server. They all get stored
+in the current gamedir and an FS_Restart will be fired up after we download them all.
+
+The string is the format:
+
+@remotename@localname [repeat]
+
+static int		fs_numServerReferencedPaks;
+static int		fs_serverReferencedPaks[MAX_SEARCH_PATHS];
+static char		*fs_serverReferencedPakNames[MAX_SEARCH_PATHS];
+
+----------------
+dlstring == qfalse
+
+we are not interested in a download string format, we want something human-readable
+(this is used for diagnostics while connecting to a pure server)
+================
+*/
+qboolean FS_ComparePaks( char *neededpaks, int len, qboolean dlstring ) {
+	searchpath_t	*sp;
+	qboolean havepak, badchecksum;
+	int i;
+
+	if ( !fs_numServerReferencedPaks ) {
+		return qfalse; // Server didn't send any pack information along
+	}
+
+	*neededpaks = 0;
+
+	for ( i = 0 ; i < fs_numServerReferencedPaks ; i++ ) {
+		// Ok, see if we have this pak file
+		badchecksum = qfalse;
+		havepak = qfalse;
+
+		// never autodownload any of the id paks
+		if ( FS_idPak(fs_serverReferencedPakNames[i], "base") || FS_idPak(fs_serverReferencedPakNames[i], "missionpack") ) {
+			continue;
+		}
+
+		for ( sp = fs_searchpaths ; sp ; sp = sp->next ) {
+			if ( sp->pack && sp->pack->checksum == fs_serverReferencedPaks[i] ) {
+				havepak = qtrue; // This is it!
+				break;
+			}
+		}
+
+		if ( !havepak && fs_serverReferencedPakNames[i] && *fs_serverReferencedPakNames[i] ) { 
+			// Don't got it
+			
+			if (dlstring)
+			{
+				// Remote name
+				Q_strcat( neededpaks, len, "@");
+				Q_strcat( neededpaks, len, fs_serverReferencedPakNames[i] );
+				Q_strcat( neededpaks, len, ".pk3" );
+				
+				// Local name
+				Q_strcat( neededpaks, len, "@");
+				// Do we have one with the same name?
+				if ( FS_SV_FileExists( va( "%s.pk3", fs_serverReferencedPakNames[i] ) ) ) {
+					char st[MAX_ZPATH];
+					// We already have one called this, we need to download it to another name
+					// Make something up with the checksum in it
+					Com_sprintf( st, sizeof( st ), "%s.%08x.pk3", fs_serverReferencedPakNames[i], fs_serverReferencedPaks[i] );
+					Q_strcat( neededpaks, len, st );
+				} else {
+					Q_strcat( neededpaks, len, fs_serverReferencedPakNames[i] );
+					Q_strcat( neededpaks, len, ".pk3" );
+				}
+			}
+			else
+			{
+				Q_strcat( neededpaks, len, fs_serverReferencedPakNames[i] );
+				Q_strcat( neededpaks, len, ".pk3" );
+				// Do we have one with the same name?
+				if ( FS_SV_FileExists( va( "%s.pk3", fs_serverReferencedPakNames[i] ) ) )
+				{
+					Q_strcat( neededpaks, len, " (local file exists with wrong checksum)");
+				}
+				Q_strcat( neededpaks, len, "\n");
+			}
+		}
+	}
+	if ( *neededpaks ) {
+		return qtrue;
+	}
+
+	return qfalse; // We have them all
+}
+
+#ifdef USE_CD_KEY
+
+void Com_AppendCDKey( const char *filename );
+void Com_ReadCDKey( const char *filename );
+
+#endif // USE_CD_KEY
+
+//rww - add search paths in for received svc_setgame
+void FS_UpdateGamedir(void)
+{
+	if ( fs_gamedirvar->string[0] && Q_stricmp( fs_gamedirvar->string, BASEGAME ) )
+	{
+		if (fs_cdpath->string[0])
+		{
+			FS_AddGameDirectory(fs_cdpath->string, fs_gamedirvar->string);
+		}
+		if (fs_basepath->string[0])
+		{
+			FS_AddGameDirectory(fs_basepath->string, fs_gamedirvar->string);
+		}
+		if (fs_homepath->string[0] && Q_stricmp(fs_homepath->string,fs_basepath->string))
+		{
+			FS_AddGameDirectory(fs_homepath->string, fs_gamedirvar->string);
+		}
+	}
+}
+
+/*
+================
+FS_ReorderPurePaks
+NOTE TTimo: the reordering that happens here is not reflected in the cvars (\cvarlist *pak*)
+  this can lead to misleading situations, see https://zerowing.idsoftware.com/bugzilla/show_bug.cgi?id=540
+================
+*/
+static void FS_ReorderPurePaks()
+{
+	searchpath_t *s;
+	int i;
+	searchpath_t **p_insert_index, // for linked list reordering
+		**p_previous; // when doing the scan
+	
+	// only relevant when connected to pure server
+	if ( !fs_numServerPaks )
+		return;
+	
+	fs_reordered = qfalse;
+	
+	p_insert_index = &fs_searchpaths; // we insert in order at the beginning of the list 
+	for ( i = 0 ; i < fs_numServerPaks ; i++ ) {
+		p_previous = p_insert_index; // track the pointer-to-current-item
+		for (s = *p_insert_index; s; s = s->next) {
+			// the part of the list before p_insert_index has been sorted already
+			if (s->pack && fs_serverPaks[i] == s->pack->checksum) {
+				fs_reordered = qtrue;
+				// move this element to the insert list
+				*p_previous = s->next;
+				s->next = *p_insert_index;
+				*p_insert_index = s;
+				// increment insert list
+				p_insert_index = &s->next;
+				break; // iterate to next server pack
+			}
+			p_previous = &s->next; 
+		}
+	}
+}
+
+/*
+================
+FS_Startup
+================
+*/
+void FS_Startup( const char *gameName ) {
+        const char *homePath;
+#ifdef USE_CD_KEY
+	cvar_t	*fs;
+#endif	// USE_CD_KEY
+
+	Com_Printf( "----- FS_Startup -----\n" );
+
+	fs_debug = Cvar_Get( "fs_debug", "0", 0 );
+	fs_copyfiles = Cvar_Get( "fs_copyfiles", "0", CVAR_INIT );
+	fs_cdpath = Cvar_Get ("fs_cdpath", Sys_DefaultCDPath(), CVAR_INIT );
+	fs_basepath = Cvar_Get ("fs_basepath", Sys_DefaultInstallPath(), CVAR_INIT );
+	fs_basegame = Cvar_Get ("fs_basegame", "", CVAR_INIT );
+  homePath = Sys_DefaultHomePath();
+  if (!homePath || !homePath[0]) {
+		homePath = fs_basepath->string;
+	}
+	fs_homepath = Cvar_Get ("fs_homepath", homePath, CVAR_INIT );
+	fs_gamedirvar = Cvar_Get ("fs_game", "", CVAR_INIT|CVAR_SYSTEMINFO );
+	fs_restrict = Cvar_Get ("fs_restrict", "", CVAR_INIT );
+
+	fs_dirbeforepak = Cvar_Get("fs_dirbeforepak", "0", CVAR_INIT);
+
+	// add search path elements in reverse priority order
+	if (fs_cdpath->string[0]) {
+		FS_AddGameDirectory( fs_cdpath->string, gameName );
+	}
+	if (fs_basepath->string[0]) {
+		FS_AddGameDirectory( fs_basepath->string, gameName );
+	}
+  // fs_homepath is somewhat particular to *nix systems, only add if relevant
+  // NOTE: same filtering below for mods and basegame
+	if (fs_basepath->string[0] && Q_stricmp(fs_homepath->string,fs_basepath->string)) {
+		FS_AddGameDirectory ( fs_homepath->string, gameName );
+	}
+        
+	// check for additional base game so mods can be based upon other mods
+	if ( fs_basegame->string[0] && !Q_stricmp( gameName, BASEGAME ) && Q_stricmp( fs_basegame->string, gameName ) ) {
+		if (fs_cdpath->string[0]) {
+			FS_AddGameDirectory(fs_cdpath->string, fs_basegame->string);
+		}
+		if (fs_basepath->string[0]) {
+			FS_AddGameDirectory(fs_basepath->string, fs_basegame->string);
+		}
+		if (fs_homepath->string[0] && Q_stricmp(fs_homepath->string,fs_basepath->string)) {
+			FS_AddGameDirectory(fs_homepath->string, fs_basegame->string);
+		}
+	}
+
+	// check for additional game folder for mods
+	if ( fs_gamedirvar->string[0] && !Q_stricmp( gameName, BASEGAME ) && Q_stricmp( fs_gamedirvar->string, gameName ) ) {
+		if (fs_cdpath->string[0]) {
+			FS_AddGameDirectory(fs_cdpath->string, fs_gamedirvar->string);
+		}
+		if (fs_basepath->string[0]) {
+			FS_AddGameDirectory(fs_basepath->string, fs_gamedirvar->string);
+		}
+		if (fs_homepath->string[0] && Q_stricmp(fs_homepath->string,fs_basepath->string)) {
+			FS_AddGameDirectory(fs_homepath->string, fs_gamedirvar->string);
+		}
+	}
+
+#ifdef USE_CD_KEY
+	Com_ReadCDKey( "base" );
+	fs = Cvar_Get ("fs_game", "", CVAR_INIT|CVAR_SYSTEMINFO );
+	if (fs && fs->string[0] != 0) {
+		Com_AppendCDKey( fs->string );
+	}
+#endif // USE_CD_KEY
+
+	// add our commands
+	Cmd_AddCommand ("path", FS_Path_f);
+	Cmd_AddCommand ("dir", FS_Dir_f );
+	Cmd_AddCommand ("fdir", FS_NewDir_f );
+	Cmd_AddCommand ("touchFile", FS_TouchFile_f );
+
+	// https://zerowing.idsoftware.com/bugzilla/show_bug.cgi?id=506
+	// reorder the pure pk3 files according to server order
+	FS_ReorderPurePaks();
+
+	// print the current search paths
+	FS_Path_f();
+
+	fs_gamedirvar->modified = qfalse; // We just loaded, it's not modified
+
+	Com_Printf( "----------------------\n" );
+
+#ifdef FS_MISSING
+	if (missingFiles == NULL) {
+		missingFiles = fopen( "\\missing.txt", "ab" );
+	}
+#endif
+	Com_Printf( "%d files in pk3 files\n", fs_packFiles );
+}
+
+
+/*
+===================
+FS_SetRestrictions
+
+Looks for product keys and restricts media add on ability
+if the full version is not found
+===================
+*/
+void FS_SetRestrictions( void ) {
+	searchpath_t	*path;
+
+#ifndef PRE_RELEASE_DEMO
+	char	*productId;
+
+	// if fs_restrict is set, don't even look for the id file,
+	// which allows the demo release to be tested even if
+	// the full game is present
+	if ( !fs_restrict->integer ) {
+		// look for the full game id
+		FS_ReadFile( "productid.txt", (void **)&productId );
+		if ( productId ) {
+			// check against the hardcoded string
+			int		seed, i;
+
+			seed = 102270;
+			for ( i = 0 ; i < sizeof( fs_scrambledProductId ) ; i++ ) {
+				if ( ( fs_scrambledProductId[i] ^ (seed&255) ) != productId[i] ) {
+					break;
+				}
+				seed = (69069 * seed + 1);
+			}
+
+			FS_FreeFile( productId );
+
+			if ( i == sizeof( fs_scrambledProductId ) ) {
+				return;	// no restrictions
+			}
+			Com_Error( ERR_FATAL, "Invalid product identification" );
+		}
+	}
+#endif
+	Cvar_Set( "fs_restrict", "1" );
+
+	Com_Printf( "\nRunning in restricted demo mode.\n\n" );
+
+	// restart the filesystem with just the demo directory
+	FS_Shutdown(qfalse);
+	FS_Startup( DEMOGAME );
+
+	// make sure that the pak file has the header checksum we expect
+	for ( path = fs_searchpaths ; path ; path = path->next ) {
+		if ( path->pack ) {
+			// a tiny attempt to keep the checksum from being scannable from the exe
+			if ( (path->pack->checksum ^ 0x02261994u) != (DEMO_PAK_CHECKSUM ^ 0x02261994u) ) {
+				Com_Error( ERR_FATAL, "Corrupted pak0.pk3: %u", path->pack->checksum );
+			}
+		}
+	}
+}
+
+/*
+=====================
+FS_GamePureChecksum
+
+Returns the checksum of the pk3 from which the server loaded the qagame.qvm
+=====================
+*/
+const char *FS_GamePureChecksum( void ) {
+	static char	info[MAX_STRING_TOKENS];
+	searchpath_t *search;
+
+	info[0] = 0;
+
+	for ( search = fs_searchpaths ; search ; search = search->next ) {
+		// is the element a pak file?
+		if ( search->pack ) {
+			if (search->pack->referenced & FS_QAGAME_REF) {
+				Com_sprintf(info, sizeof(info), "%d", search->pack->checksum);
+			}
+		}
+	}
+
+	return info;
+}
+
+/*
+=====================
+FS_LoadedPakChecksums
+
+Returns a space separated string containing the checksums of all loaded pk3 files.
+Servers with sv_pure set will get this string and pass it to clients.
+=====================
+*/
+const char *FS_LoadedPakChecksums( void ) {
+	static char	info[BIG_INFO_STRING];
+	searchpath_t	*search;
+
+	info[0] = 0;
+
+	for ( search = fs_searchpaths ; search ; search = search->next ) {
+		// is the element a pak file? 
+		if ( !search->pack ) {
+			continue;
+		}
+
+		Q_strcat( info, sizeof( info ), va("%i ", search->pack->checksum ) );
+	}
+
+	return info;
+}
+
+/*
+=====================
+FS_LoadedPakNames
+
+Returns a space separated string containing the names of all loaded pk3 files.
+Servers with sv_pure set will get this string and pass it to clients.
+=====================
+*/
+const char *FS_LoadedPakNames( void ) {
+	static char	info[BIG_INFO_STRING];
+	searchpath_t	*search;
+
+	info[0] = 0;
+
+	for ( search = fs_searchpaths ; search ; search = search->next ) {
+		// is the element a pak file?
+		if ( !search->pack ) {
+			continue;
+		}
+
+		if (*info) {
+			Q_strcat(info, sizeof( info ), " " );
+		}
+		Q_strcat( info, sizeof( info ), search->pack->pakBasename );
+	}
+
+	return info;
+}
+
+/*
+=====================
+FS_LoadedPakPureChecksums
+
+Returns a space separated string containing the pure checksums of all loaded pk3 files.
+Servers with sv_pure use these checksums to compare with the checksums the clients send
+back to the server.
+=====================
+*/
+const char *FS_LoadedPakPureChecksums( void ) {
+	static char	info[BIG_INFO_STRING];
+	searchpath_t	*search;
+
+	info[0] = 0;
+
+	for ( search = fs_searchpaths ; search ; search = search->next ) {
+		// is the element a pak file? 
+		if ( !search->pack ) {
+			continue;
+		}
+
+		Q_strcat( info, sizeof( info ), va("%i ", search->pack->pure_checksum ) );
+	}
+
+	return info;
+}
+
+/*
+=====================
+FS_ReferencedPakChecksums
+
+Returns a space separated string containing the checksums of all referenced pk3 files.
+The server will send this to the clients so they can check which files should be auto-downloaded. 
+=====================
+*/
+const char *FS_ReferencedPakChecksums( void ) {
+	static char	info[BIG_INFO_STRING];
+	searchpath_t *search;
+
+	info[0] = 0;
+
+
+	for ( search = fs_searchpaths ; search ; search = search->next ) {
+		// is the element a pak file?
+		if ( search->pack ) {
+			if (search->pack->referenced || Q_stricmpn(search->pack->pakGamename, BASEGAME, strlen(BASEGAME))) {
+				Q_strcat( info, sizeof( info ), va("%i ", search->pack->checksum ) );
+			}
+		}
+	}
+
+	return info;
+}
+
+/*
+=====================
+FS_ReferencedPakPureChecksums
+
+Returns a space separated string containing the pure checksums of all referenced pk3 files.
+Servers with sv_pure set will get this string back from clients for pure validation 
+
+The string has a specific order, "cgame ui @ ref1 ref2 ref3 ..."
+=====================
+*/
+const char *FS_ReferencedPakPureChecksums( void ) {
+	static char	info[BIG_INFO_STRING];
+	searchpath_t	*search;
+	int nFlags, numPaks, checksum;
+
+	info[0] = 0;
+
+	checksum = fs_checksumFeed;
+	numPaks = 0;
+	for (nFlags = FS_CGAME_REF; nFlags; nFlags = nFlags >> 1) {
+		if (nFlags & FS_GENERAL_REF) {
+			// add a delimter between must haves and general refs
+			//Q_strcat(info, sizeof(info), "@ ");
+			info[strlen(info)+1] = '\0';
+			info[strlen(info)+2] = '\0';
+			info[strlen(info)] = '@';
+			info[strlen(info)] = ' ';
+		}
+		for ( search = fs_searchpaths ; search ; search = search->next ) {
+			// is the element a pak file and has it been referenced based on flag?
+			if ( search->pack && (search->pack->referenced & nFlags)) {
+				Q_strcat( info, sizeof( info ), va("%i ", search->pack->pure_checksum ) );
+				if (nFlags & (FS_CGAME_REF | FS_UI_REF)) {
+					break;
+				}
+				checksum ^= search->pack->pure_checksum;
+				numPaks++;
+			}
+		}
+		if (fs_fakeChkSum != 0) {
+			// only added if a non-pure file is referenced
+			Q_strcat( info, sizeof( info ), va("%i ", fs_fakeChkSum ) );
+		}
+	}
+	// last checksum is the encoded number of referenced pk3s
+	checksum ^= numPaks;
+	Q_strcat( info, sizeof( info ), va("%i ", checksum ) );
+
+	return info;
+}
+
+/*
+=====================
+FS_ReferencedPakNames
+
+Returns a space separated string containing the names of all referenced pk3 files.
+The server will send this to the clients so they can check which files should be auto-downloaded. 
+=====================
+*/
+const char *FS_ReferencedPakNames( void ) {
+	static char	info[BIG_INFO_STRING];
+	searchpath_t	*search;
+
+	info[0] = 0;
+
+	// we want to return ALL pk3's from the fs_game path
+	// and referenced one's from base
+	for ( search = fs_searchpaths ; search ; search = search->next ) {
+		// is the element a pak file?
+		if ( search->pack ) {
+			if (*info) {
+				Q_strcat(info, sizeof( info ), " " );
+			}
+			if (search->pack->referenced || Q_stricmpn(search->pack->pakGamename, BASEGAME, strlen(BASEGAME))) {
+				Q_strcat( info, sizeof( info ), search->pack->pakGamename );
+				Q_strcat( info, sizeof( info ), "/" );
+				Q_strcat( info, sizeof( info ), search->pack->pakBasename );
+			}
+		}
+	}
+
+	return info;
+}
+
+/*
+=====================
+FS_ClearPakReferences
+=====================
+*/
+void FS_ClearPakReferences( int flags ) {
+	searchpath_t *search;
+
+	if ( !flags ) {
+		flags = -1;
+	}
+	for ( search = fs_searchpaths; search; search = search->next ) {
+		// is the element a pak file and has it been referenced?
+		if ( search->pack ) {
+			search->pack->referenced &= ~flags;
+		}
+	}
+}
+
+
+/*
+=====================
+FS_PureServerSetLoadedPaks
+
+If the string is empty, all data sources will be allowed.
+If not empty, only pk3 files that match one of the space
+separated checksums will be checked for files, with the
+exception of .cfg and .dat files.
+=====================
+*/
+void FS_PureServerSetLoadedPaks( const char *pakSums, const char *pakNames ) {
+	int		i, c, d;
+
+	Cmd_TokenizeString( pakSums );
+
+	c = Cmd_Argc();
+	if ( c > MAX_SEARCH_PATHS ) {
+		c = MAX_SEARCH_PATHS;
+	}
+
+	fs_numServerPaks = c;
+
+	for ( i = 0 ; i < c ; i++ ) {
+		fs_serverPaks[i] = atoi( Cmd_Argv( i ) );
+	}
+
+	if (fs_numServerPaks) {
+		Com_DPrintf( "Connected to a pure server.\n" );
+	}
+	else
+	{
+		if (fs_reordered)
+		{
+			// https://zerowing.idsoftware.com/bugzilla/show_bug.cgi?id=540
+			// force a restart to make sure the search order will be correct
+			Com_DPrintf( "FS search reorder is required\n" );
+			FS_Restart(fs_checksumFeed);
+			return;
+		}
+	}
+
+	for ( i = 0 ; i < c ; i++ ) {
+		if (fs_serverPakNames[i]) {
+			Z_Free(fs_serverPakNames[i]);
+		}
+		fs_serverPakNames[i] = NULL;
+	}
+	if ( pakNames && *pakNames ) {
+		Cmd_TokenizeString( pakNames );
+
+		d = Cmd_Argc();
+		if ( d > MAX_SEARCH_PATHS ) {
+			d = MAX_SEARCH_PATHS;
+		}
+
+		for ( i = 0 ; i < d ; i++ ) {
+			fs_serverPakNames[i] = CopyString( Cmd_Argv( i ) );
+		}
+	}
+}
+
+/*
+=====================
+FS_PureServerSetReferencedPaks
+
+The checksums and names of the pk3 files referenced at the server
+are sent to the client and stored here. The client will use these
+checksums to see if any pk3 files need to be auto-downloaded. 
+=====================
+*/
+void FS_PureServerSetReferencedPaks( const char *pakSums, const char *pakNames ) {
+	int		i, c, d;
+
+	Cmd_TokenizeString( pakSums );
+
+	c = Cmd_Argc();
+	if ( c > MAX_SEARCH_PATHS ) {
+		c = MAX_SEARCH_PATHS;
+	}
+
+	fs_numServerReferencedPaks = c;
+
+	for ( i = 0 ; i < c ; i++ ) {
+		fs_serverReferencedPaks[i] = atoi( Cmd_Argv( i ) );
+	}
+
+	for ( i = 0 ; i < c ; i++ ) {
+		if (fs_serverReferencedPakNames[i]) {
+			Z_Free(fs_serverReferencedPakNames[i]);
+		}
+		fs_serverReferencedPakNames[i] = NULL;
+	}
+	if ( pakNames && *pakNames ) {
+		Cmd_TokenizeString( pakNames );
+
+		d = Cmd_Argc();
+		if ( d > MAX_SEARCH_PATHS ) {
+			d = MAX_SEARCH_PATHS;
+		}
+
+		for ( i = 0 ; i < d ; i++ ) {
+			fs_serverReferencedPakNames[i] = CopyString( Cmd_Argv( i ) );
+		}
+	}
+}
+
+/*
+================
+FS_Restart
+================
+*/
+void FS_Restart( int checksumFeed ) {
+
+	// free anything we currently have loaded
+	FS_Shutdown(qfalse);
+
+	// set the checksum feed
+	fs_checksumFeed = checksumFeed;
+
+	// clear pak references
+	FS_ClearPakReferences(0);
+
+	// try to start up normally
+	FS_Startup( BASEGAME );
+
+	// see if we are going to allow add-ons
+	FS_SetRestrictions();
+
+	// if we can't find default.cfg, assume that the paths are
+	// busted and error out now, rather than getting an unreadable
+	// graphics screen when the font fails to load
+	if ( FS_ReadFile( "mpdefault.cfg", NULL ) <= 0 ) {
+		// this might happen when connecting to a pure server not using BASEGAME/pak0.pk3
+		// (for instance a TA demo server)
+		if (lastValidBase[0]) {
+			FS_PureServerSetLoadedPaks("", "");
+			Cvar_Set("fs_basepath", lastValidBase);
+			Cvar_Set("fs_gamedirvar", lastValidGame);
+			lastValidBase[0] = '\0';
+			lastValidGame[0] = '\0';
+			Cvar_Set( "fs_restrict", "0" );
+			FS_Restart(checksumFeed);
+			Com_Error( ERR_DROP, "Invalid game folder\n" );
+			return;
+		}
+		Com_Error( ERR_FATAL, "Couldn't load mpdefault.cfg" );
+	}
+
+	// bk010116 - new check before safeMode
+	if ( Q_stricmp(fs_gamedirvar->string, lastValidGame) ) {
+		// skip the jampconfig.cfg if "safe" is on the command line
+		if ( !Com_SafeMode() ) {
+#ifdef DEDICATED
+			Cbuf_AddText ("exec jampserver.cfg\n");
+#else
+			Cbuf_AddText ("exec jampconfig.cfg\n");
+#endif
+		}
+	}
+
+	Q_strncpyz(lastValidBase, fs_basepath->string, sizeof(lastValidBase));
+	Q_strncpyz(lastValidGame, fs_gamedirvar->string, sizeof(lastValidGame));
+
+}
+
+/*
+=================
+FS_ConditionalRestart
+restart if necessary
+=================
+*/
+qboolean FS_ConditionalRestart( int checksumFeed ) {
+	if( fs_gamedirvar->modified || checksumFeed != fs_checksumFeed ) {
+		FS_Restart( checksumFeed );
+		return qtrue;
+	}
+	return qfalse;
+}
+
+/*
+========================================================================================
+
+Handle based file calls for virtual machines
+
+========================================================================================
+*/
+
+int		FS_FOpenFileByMode( const char *qpath, fileHandle_t *f, fsMode_t mode ) {
+	int		r;
+	qboolean	sync;
+
+	sync = qfalse;
+
+	switch( mode ) {
+	case FS_READ:
+		r = FS_FOpenFileRead( qpath, f, qtrue );
+		break;
+	case FS_WRITE:
+		*f = FS_FOpenFileWrite( qpath );
+		r = 0;
+		if (*f == 0) {
+			r = -1;
+		}
+		break;
+	case FS_APPEND_SYNC:
+		sync = qtrue;
+	case FS_APPEND:
+		*f = FS_FOpenFileAppend( qpath );
+		r = 0;
+		if (*f == 0) {
+			r = -1;
+		}
+		break;
+	default:
+		Com_Error( ERR_FATAL, "FSH_FOpenFile: bad mode" );
+		return -1;
+	}
+
+	if (!f) {
+		return r;
+	}
+
+	if ( *f ) {
+		if (fsh[*f].zipFile == qtrue) {
+			fsh[*f].baseOffset = unztell(fsh[*f].handleFiles.file.z);
+		} else {
+			fsh[*f].baseOffset = ftell(fsh[*f].handleFiles.file.o);
+		}
+		fsh[*f].fileSize = r;
+		fsh[*f].streamed = qfalse;
+
+		if (mode == FS_READ) {
+			Sys_BeginStreamedFile( *f, 0x4000 );
+			fsh[*f].streamed = qtrue;
+		}
+	}
+	fsh[*f].handleSync = sync;
+
+	return r;
+}
+
+int		FS_FTell( fileHandle_t f ) {
+	int pos;
+	if (fsh[f].zipFile == qtrue) {
+		pos = unztell(fsh[f].handleFiles.file.z);
+	} else {
+		pos = ftell(fsh[f].handleFiles.file.o);
+	}
+	return pos;
+}
+
+void	FS_Flush( fileHandle_t f ) {
+	fflush(fsh[f].handleFiles.file.o);
+}
diff --git a/codemp/qcommon/fixedmap.h b/codemp/qcommon/fixedmap.h
new file mode 100644
index 0000000..f50e529
--- /dev/null
+++ b/codemp/qcommon/fixedmap.h
@@ -0,0 +1,148 @@
+#ifndef __FIXEDMAP_H
+#define __FIXEDMAP_H
+
+
+/*
+   An STL map-like container.  Quickly thrown together to replace STL maps
+   in specific instances.  Many gotchas.  Use with caution.
+*/
+
+
+#include <stdlib.h>
+
+
+template < class T, class U >
+class VVFixedMap
+{
+private:
+	struct Data {
+		T data;
+		U key;
+	};
+
+	Data *items;
+	unsigned int numItems;
+	unsigned int maxItems;
+
+	VVFixedMap(void) {}
+
+public:
+	VVFixedMap(unsigned int maxItems)
+	{
+		items = new Data[maxItems];
+		numItems = 0;
+		this->maxItems = maxItems;
+	}
+
+
+	~VVFixedMap(void)
+	{
+		items -= ( maxItems - numItems );
+		delete [] items;
+		numItems = 0;
+	}
+
+
+	bool Insert(const T &newItem, const U &key)
+	{
+		Data *storage = NULL;
+
+		//Check for fullness.
+		if(numItems >= maxItems) {
+			return false;
+		}
+
+		//Check for reuse.
+		if(!FindUnsorted(key, storage)) {
+		   storage = items + numItems;
+		   numItems++;
+		}	   
+
+		storage->data = newItem;
+		storage->key = key;
+
+		return true;
+	}
+
+
+	void Sort(void) 
+	{
+		qsort(items, numItems, sizeof(Data), 
+				VVFixedMap< T, U >::FixedMapSorter);
+	}
+
+
+	//Binary search, items must have been sorted!
+	T *Find(const U &key)
+	{
+		int i;
+		int high;
+		int low;
+
+		for(low = -1, high = numItems; high - low > 1; ) {
+			i = (high + low) / 2;
+			if(key < items[i].key) {
+				high = i;
+			} else if(key > items[i].key) {
+				low = i;
+			} else {
+				return &items[i].data;
+			}
+		}
+
+		if(items[i+1].key == key) {
+			return &items[i+1].data;
+		} else if(items[i-1].key == key) {
+			return &items[i-1].data;
+		}
+
+		return NULL;
+	}
+
+
+	//Slower, but don't need to call sort first.
+	T *FindUnsorted(const U &key, Data *&storage)
+	{
+		int i;
+
+		for(i=0; i<numItems; i++) {
+			if(items[i].key == key) {
+				storage = items + i;
+				return &items[i].data;
+			}
+		}
+
+		return NULL;
+	}
+
+	// returns the top item's data
+	// and removes the item from the map
+	T *Pop(void)
+	{
+		T* top = NULL;
+
+		if(numItems)
+		{
+			top	= &items[0].data;
+			items++;
+			numItems--;
+		}
+
+		return top;
+	}
+
+
+	static int FixedMapSorter(const void *a, const void *b)
+	{
+		if(((Data*)a)->key > ((Data*)b)->key) {
+			return 1;
+		} else if(((Data*)a)->key == ((Data*)b)->key) {
+			return 0;
+		} else {
+			return -1;
+		}
+	}
+};
+
+
+#endif
diff --git a/codemp/qcommon/game_version.h b/codemp/qcommon/game_version.h
new file mode 100644
index 0000000..cc33834
--- /dev/null
+++ b/codemp/qcommon/game_version.h
@@ -0,0 +1,14 @@
+// Copyright (C) 2000-2002 Raven Software, Inc.
+//
+#include "../win32/AutoVersion.h"
+
+// Current version of the multi player game
+#ifdef _DEBUG
+	#define	Q3_VERSION		"(debug)JAmp: v"VERSION_STRING_DOTTED
+#elif defined FINAL_BUILD
+	#define	Q3_VERSION		"JAmp: v"VERSION_STRING_DOTTED
+#else
+	#define	Q3_VERSION		"(internal)JAmp: v"VERSION_STRING_DOTTED
+#endif
+
+//end
diff --git a/codemp/qcommon/hstring.cpp b/codemp/qcommon/hstring.cpp
new file mode 100644
index 0000000..22b9029
--- /dev/null
+++ b/codemp/qcommon/hstring.cpp
@@ -0,0 +1,501 @@
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+#ifdef _DONETPROFILE_
+#include <assert.h>
+#include "hstring.h"
+
+using namespace std;
+
+// mapPoolBlockCount is defined differently in the executable (sv_main.cpp) and the game dll (g_main.cpp) cuz
+//we likely don't need as many blocks in the executable as we do in the game
+extern int		mapPoolBlockCount;
+
+// Used to fool optimizer during compilation of mem touch routines.
+int HaHaOptimizer2=0;
+
+CMapPoolLow &GetMapPool()
+{
+	// this may need to be ifdefed to be different for different modules
+	static CMapPoolLow thePool;
+	return thePool;
+}
+
+#define MAPBLOCK_SIZE_NODES	(1024)
+#define MAPNODE_FREE		(0xa1)
+#define MAPNODE_INUSE		(0x94)
+
+struct SMapNode
+{
+	unsigned char mData[MAP_NODE_SIZE-2];
+	unsigned char mMapBlockNum;
+	unsigned char mTag;
+};
+
+class CMapBlock
+{
+	int			mId;
+	char		mRaw[(MAPBLOCK_SIZE_NODES+1)*MAP_NODE_SIZE];
+	SMapNode	*mNodes;
+	int			mLastNode;
+
+public:
+	CMapBlock(int id,vector <void *> &freeList) :
+		mLastNode(0)
+	{
+		// Alloc node storage for MAPBLOCK_SIZE_NODES worth of nodes.
+		mNodes=(SMapNode *)((((unsigned long)mRaw)+MAP_NODE_SIZE)&~(unsigned long)0x1f);
+		// Set all nodes to initially be free.
+		int i;
+		for(i=0;i<MAPBLOCK_SIZE_NODES;i++)
+		{
+			mNodes[i].mMapBlockNum=id;
+			mNodes[i].mTag=MAPNODE_FREE;
+			freeList.push_back((void *)&mNodes[i]);
+		}
+	}
+
+	bool bOwnsNode(void *node)
+	{
+		return((((SMapNode *)node)>=&mNodes[0])&&(((SMapNode *)node)<&mNodes[MAPBLOCK_SIZE_NODES]));
+	}
+};
+
+CMapPoolLow::CMapPoolLow()
+{
+	mLastBlockNum=-1;	
+}
+
+CMapPoolLow::~CMapPoolLow()
+{
+#if _DEBUG
+#if _GAME
+	if(mFreeList.size()<mMapBlocks.size()*MAPBLOCK_SIZE_NODES)
+	{
+//		Com_Printf("[MEM][GAME]  !!!! Map Pool Leaked %d nodes\n",(MAPBLOCK_SIZE_NODES*mMapBlocks.size())-mFreeList.size());
+	}
+//	Com_Printf("[MEM][GAME]  Map Pool max. mem used = %d\n",mMapBlocks.size()*MAPBLOCK_SIZE_NODES*MAP_NODE_SIZE);
+#elif _CGAME
+	if (mFreeList.size()<mMapBlocks.size()*MAPBLOCK_SIZE_NODES)
+	{
+//		Com_Printf("[MEM][CGAME]  !!!! Map Pool Leaked %d nodes\n",(MAPBLOCK_SIZE_NODES*mMapBlocks.size())-mFreeList.size());
+	}
+//	Com_Printf("[MEM][CGAME] Map Pool max. mem used = %d\n",mMapBlocks.size()*MAPBLOCK_SIZE_NODES*MAP_NODE_SIZE);
+#else
+	if (mFreeList.size()<mMapBlocks.size()*MAPBLOCK_SIZE_NODES)
+	{
+//		Com_Printf("[MEM][EXE]  !!!! Map Pool Leaked %d nodes\n",(MAPBLOCK_SIZE_NODES*mMapBlocks.size())-mFreeList.size());
+	}
+//	Com_Printf("[MEM][EXE] Map Pool max. mem used = %d\n",mMapBlocks.size()*MAPBLOCK_SIZE_NODES*MAP_NODE_SIZE);
+#endif
+#endif
+
+	int i;
+	for (i=0;i<mMapBlocks.size();i++)
+	{
+		delete mMapBlocks[i];
+	}
+}
+
+void *CMapPoolLow::Alloc()
+{
+	// Try to request a node. First we look in the free-list, but if that
+	// happens to be empty, we allocate more storage in the current CMapBlock.
+	void *node=0;
+	if(mFreeList.size())
+	{
+		// Retrieve the node to be recycled.
+		node=(void *)mFreeList[mFreeList.size()-1];
+		mFreeList.pop_back();
+	}
+	else
+	{
+		// None free, so alloc another block.
+		CMapBlock *block=new CMapBlock(mLastBlockNum+1,mFreeList);
+		assert(block);
+		mMapBlocks.push_back(block);
+		mLastBlockNum++;
+		node=(void *)mFreeList[mFreeList.size()-1];
+		mFreeList.pop_back();
+	}
+
+	// Validate we aren't somehow grabbing something that is already in use
+	// and also that the end marker is intact.
+	assert(((SMapNode *)node)->mTag==MAPNODE_FREE);
+	assert((((SMapNode *)node)->mMapBlockNum)>=0);
+	assert((((SMapNode *)node)->mMapBlockNum)<256);
+	assert((((SMapNode *)node)->mMapBlockNum)<=mLastBlockNum);
+	assert(mMapBlocks[((SMapNode *)node)->mMapBlockNum]->bOwnsNode(node));
+
+	// Ok, mark the node as in use.
+	((SMapNode *)node)->mTag=MAPNODE_INUSE;
+
+	return(node);
+}
+
+void CMapPoolLow::Free(void *p)
+{
+	// Validate that someone isn't trying to double free this node and also
+	// that the end marker is intact. 
+	assert(((SMapNode *)p)->mTag==MAPNODE_INUSE);
+	assert((((SMapNode *)p)->mMapBlockNum)>=0);
+	assert((((SMapNode *)p)->mMapBlockNum)<256);
+	assert((((SMapNode *)p)->mMapBlockNum)<=mLastBlockNum);
+	assert(mMapBlocks[((SMapNode *)p)->mMapBlockNum]->bOwnsNode(p));
+
+	// Ok, mark the the node as free.
+	((SMapNode *)p)->mTag=MAPNODE_FREE;
+
+	// Add a new freelist entry to point at this node.
+	mFreeList.push_back(p);
+}
+
+void CMapPoolLow::TouchMem()
+{
+	int				i,j;
+	unsigned char	*memory;
+	int				totSize=0;
+	for(i=0;i<mMapBlocks.size();i++)
+	{
+		memory=(unsigned char *)mMapBlocks[i];
+		totSize+=sizeof(CMapBlock);
+		for(j=0;j<sizeof(CMapBlock);j+=256)
+		{
+			HaHaOptimizer2+=memory[j];
+		}
+	}
+#ifdef _DEBUG
+//	Com_Printf("MapPool: Bytes touched %i\n",totSize);
+#endif
+}
+
+////////////
+// hString stuff
+////////////
+#define MAX_HASH (65536*2)
+
+// Max number of strings we can ever deal with.
+#define MAX_STRINGS 100000
+
+// Size of a string storage block in bytes.
+#define	BLOCK_SIZE	65536
+
+
+int HashFunction(const char *key)
+{
+	long	hash=0;
+	int		i=0;
+	unsigned char	letter;
+
+	letter = (unsigned char)*key++;
+	while (letter)
+	{
+		hash += (long)(letter) * (i + 119);
+		i++;
+		letter = (unsigned char)*key++;
+	}
+	hash &= MAX_HASH - 1;
+	return (int)hash;
+}
+
+
+class CHashHelper
+{
+	int mHashes[MAX_HASH];
+	int mFindPtr;
+	int mFindPtrStart;
+public:
+	CHashHelper() 
+	{
+		int i;
+		for (i=0;i<MAX_HASH;i++)
+		{
+			mHashes[i]=0;
+		}
+	}
+	void Add(int hash,int value)
+	{
+		assert(hash>=0&&hash<MAX_HASH);
+		assert(value); // 0 is the empty marker
+		int i=hash;
+		while (mHashes[i])
+		{
+			assert(mHashes[i]!=value); //please don't insert things twice
+			i=(i+1)&(MAX_HASH-1);
+			assert(i!=hash); //hash table is full?
+		}
+		mHashes[i]=value;
+	}
+	int FindFirst(int hash)
+	{
+		mFindPtr=hash;
+		mFindPtrStart=hash;
+		return FindNext();
+	}
+	int FindNext()
+	{
+		assert(mFindPtr>=0&&mFindPtr<MAX_HASH);
+		int val=mHashes[mFindPtr];
+		mFindPtr=(mFindPtr+1)&(MAX_HASH-1);
+		assert(mFindPtr!=mFindPtrStart); //hash table full?
+		return val;
+	}
+	void TouchMem()
+	{
+		int	i;
+		for(i=0;i<sizeof(mHashes);i+=256)
+		{
+			HaHaOptimizer2+=((unsigned char	*)mHashes)[i];
+		}
+#ifdef _DEBUG
+//		Com_Printf("Hash helper: Bytes touched %i\n",sizeof(mHashes));
+#endif
+	}
+};
+
+CHashHelper &HashHelper()
+{
+	static CHashHelper It;
+	return It;
+}
+
+static char	*gCharPtrs[MAX_STRINGS];
+
+class CHSBlock
+{
+	int		mBytesUsed;
+	char	mRaw[BLOCK_SIZE];
+
+public:
+	CHSBlock(void) :
+		mBytesUsed(0)
+	{
+		// So we can do a comparison of blocks for debug purposes.
+		memset(mRaw,0,BLOCK_SIZE);
+	};
+
+	char *Alloc(int sizeBytes)
+	{
+		// Remember to include 0 termintor in size.
+		sizeBytes++;
+
+		// Is it WAAAY to big? If so we complain loudly.
+		assert(sizeBytes<=BLOCK_SIZE);
+
+		// If we don't have space in the current block, return failure.
+		if(sizeBytes>(BLOCK_SIZE-mBytesUsed))
+		{
+			return(0);
+		}
+		
+		// Return the pointer to the start of allocated space.
+		char *ret=&mRaw[mBytesUsed];
+		mBytesUsed+=sizeBytes;
+		return ret;
+	}
+
+	bool operator== (const CHSBlock &block) const
+	{
+		if(!memcmp(mRaw,block.mRaw,BLOCK_SIZE))
+		{
+			return(true);
+		}
+		return(false);
+	}
+};
+
+class CPool
+{
+	vector<CHSBlock *>	mBlockVec;
+
+public:
+	int					mNextStringId;
+	int					mLastBlockNum;
+
+	CPool(void) :
+		mNextStringId(1),
+		mLastBlockNum(-1)
+	{
+		memset(gCharPtrs,0,MAX_STRINGS*4);
+	}
+
+	~CPool(void)
+	{
+		int i;
+		for (i=0;i<mBlockVec.size();i++)
+		{
+			delete mBlockVec[i];
+		}
+	}
+
+	char *Alloc(int sizeBytes,int &id)
+	{
+		// Can't alloc more than MAX_STRINGS.
+		assert(mNextStringId<MAX_STRINGS);
+		char *raw=0;
+		if (mLastBlockNum>=0)
+		{
+			// Get the pointer to the start of allocated space in the current block.
+			raw=mBlockVec[mLastBlockNum]->Alloc(sizeBytes);
+		}
+		if(!raw)
+		{
+			// Ok, make a new empty block and append it.
+			CHSBlock *block=new(CHSBlock);
+			mBlockVec.push_back(block);
+			mLastBlockNum++;
+			raw=mBlockVec[mLastBlockNum]->Alloc(sizeBytes);
+		}
+		// Should never really happen!!
+		assert(raw);
+
+		id=mNextStringId;
+		gCharPtrs[mNextStringId]=raw;
+		mNextStringId++;
+
+		return(raw);
+	}
+
+	bool operator== (const CPool &pool) const
+	{
+		int i;
+		for(i=0;i<mBlockVec.size();i++)
+		{
+			if(!(*mBlockVec[i]==*pool.mBlockVec[i]))
+			{
+				return(false);
+			}
+		}
+		return(true);
+	}
+
+	void TouchMem()
+	{
+		int				i,j;
+		unsigned char	*memory;
+		int				totSize=0;
+		for(i=0;i<mBlockVec.size();i++)
+		{
+			memory=(unsigned char *)mBlockVec[i];
+			totSize+=sizeof(CHSBlock);
+			for(j=0;j<sizeof(CHSBlock);j+=256)
+			{
+				HaHaOptimizer2+=memory[j];
+			}
+		}
+#ifdef _DEBUG
+//		Com_Printf("String Pool: Bytes touched %i\n",totSize);
+#endif
+	}
+};
+
+#ifdef _DEBUG
+CPool &TheDebugPool(void);
+CPool &ThePool(void);
+
+class CPoolChecker
+{
+public:
+	~CPoolChecker()
+	{
+#if 0
+		int i;
+		for (i=1;i<ThePool().mNextStringId;i++)
+		{
+			OutputDebugString(gCharPtrs[i]);
+			OutputDebugString("\n");
+		}
+#endif
+#if _DEBUG
+#if _GAME
+//		Com_Printf("[MEM][GAME]  String Pool %d unique strings, %dK\n",ThePool().mNextStringId,(ThePool().mLastBlockNum+1)*BLOCK_SIZE/1024);
+#elif _CGAME
+//		Com_Printf("[MEM][CGAME]  String Pool %d unique strings, %dK\n",ThePool().mNextStringId,(ThePool().mLastBlockNum+1)*BLOCK_SIZE/1024);
+#else
+//		Com_Printf("[MEM][EXE]  String Pool %d unique strings, %dK\n",ThePool().mNextStringId,(ThePool().mLastBlockNum+1)*BLOCK_SIZE/1024);
+#endif
+#endif
+		// if this fails it means the string storage is CORRUPTED, let someone know
+		assert(TheDebugPool()==ThePool());
+	}
+};
+
+static CPoolChecker TheCPoolChecker;
+
+CPool &TheDebugPool(void)
+{
+	static CPool theDebugPool;
+	return(theDebugPool);
+}
+
+
+#endif
+
+CPool &ThePool(void)
+{
+	static CPool thePool;
+	return(thePool);
+}
+
+void TouchStringPool(void)
+{
+	ThePool().TouchMem();
+	HashHelper().TouchMem();
+}
+
+//
+// Now the rest of the hString class.
+//
+
+void hstring::Init(const char *str)
+{
+	if(!str)
+	{
+		mId=0;
+		return;
+	}
+	int hash=HashFunction(str);
+	int id=HashHelper().FindFirst(hash);
+	while (id)
+	{
+		assert(id>0&&id<ThePool().mNextStringId);
+		if (!strcmp(str,gCharPtrs[id]))
+		{
+			mId=id;
+			return;
+		}
+		id=HashHelper().FindNext();
+	}
+	char *raw=ThePool().Alloc(strlen(str),mId);
+	strcpy(raw,str);
+	HashHelper().Add(hash,mId);
+#ifdef _DEBUG
+	int test;
+	raw=TheDebugPool().Alloc(strlen(str),test);
+	assert(test==mId);
+	strcpy(raw,str);
+#endif
+
+}
+
+const char *hstring::c_str(void) const
+{
+	if(!mId)
+	{
+		return("");
+	}
+	assert(mId>0&&mId<ThePool().mNextStringId);
+	return(gCharPtrs[mId]);
+}
+
+string hstring::str(void) const
+{
+	if(!mId)
+	{
+		return(string());
+	}
+	assert(mId>0&&mId<ThePool().mNextStringId);
+	return string(gCharPtrs[mId]);
+}
+
+#endif // _DONETPROFILE_
\ No newline at end of file
diff --git a/codemp/qcommon/hstring.h b/codemp/qcommon/hstring.h
new file mode 100644
index 0000000..c88009e
--- /dev/null
+++ b/codemp/qcommon/hstring.h
@@ -0,0 +1,229 @@
+#ifdef _DONETPROFILE_
+
+#if !defined hString_H
+#define hString_H
+
+#include <map>
+#include <list>
+#include <set>
+#include <vector>
+#include <string>
+
+using namespace std;
+
+class hstring
+{
+	int mId;
+	void Init(const char *str);
+public:
+	hstring()
+	{
+		mId=0;
+	}
+	hstring(const char *str)
+	{
+		Init(str);
+	}
+	hstring(const string &str)
+	{
+		Init(str.c_str());
+	}
+	hstring(const hstring &str) 
+	{
+		mId=str.mId;
+	}
+
+	operator string () const
+	{
+		return str();
+	}
+
+	const char *c_str(void) const;
+	string str(void) const;
+	
+	hstring& operator= (const char *str)
+	{
+		Init(str);
+		return *this;
+	}
+	hstring& operator= (const string &str)
+	{
+		Init(str.c_str());
+		return *this;
+	}
+	hstring& operator= (const hstring &str)
+	{
+		mId=str.mId;
+		return *this;
+	}
+
+	bool operator== (const hstring &str) const
+	{
+		return((mId==str.mId)?true:false);
+	}
+
+	int compare(const hstring &str) const
+	{
+		return strcmp(c_str(),str.c_str());
+	}
+
+	bool operator< (const hstring &str) const
+	{
+		return((mId<str.mId)?true:false);
+	}
+	int length() const
+	{
+		return strlen(c_str());
+	}
+};
+
+void TouchStringPool(void);
+
+////////////
+// MapPool
+////////////
+#define MAP_NODE_SIZE (32)
+
+class CMapBlock;
+class CMapPoolLow
+{
+	vector <CMapBlock *>	mMapBlocks;
+	vector <void *>			mFreeList;
+	int						mLastBlockNum;
+
+public:
+	CMapPoolLow();
+	~CMapPoolLow();
+	void *Alloc();
+	void Free(void *p);
+	void TouchMem();
+};
+
+CMapPoolLow &GetMapPool();
+
+template<class T>
+class CMapPool
+{
+	CMapPoolLow &mPool;
+public:
+	CMapPool() : mPool(GetMapPool())
+	{
+
+	}
+	template <class U>
+	CMapPool(const U&) : mPool(GetMapPool())
+	{
+	}
+	~CMapPool()
+	{
+	}
+
+	typedef T        value_type;
+	typedef T*       pointer;
+	typedef const T* const_pointer;
+	typedef T&       reference;
+	typedef const T& const_reference;
+	typedef size_t    size_type;
+	typedef ptrdiff_t difference_type;
+	
+	template <class U>
+	struct rebind 
+	{
+	   typedef CMapPool<U> other;
+	};
+	
+	// return address of values
+	pointer address (reference value) const 
+	{
+	   return &value;
+	}
+	const_pointer address (const_reference value) const 
+	{
+	   return &value;
+	}
+		
+	// return maximum number of elements that can be allocated
+	size_type max_size () const
+	{
+	   return 0xfffffff;
+	}
+	
+	// allocate but don't initialize num elements of type T
+	pointer allocate (size_type num, const void* = 0) 
+	{
+		assert(sizeof(T)<=(MAP_NODE_SIZE-2)); // to big for this pool
+		assert(num==1); //allocator not design for this
+		return (T*)mPool.Alloc();
+	}
+	void *_Charalloc(size_type size)
+	{
+		assert(size<=(MAP_NODE_SIZE-2)); // to big for this pool
+		return mPool.Alloc();
+	}
+	
+	// initialize elements of allocated storage p with value value
+	void construct (pointer p, const T& value) 
+	{
+	   // initialize memory with placement new
+	   new((void*)p)T(value);
+	}
+	
+	// destroy elements of initialized storage p
+	void destroy (pointer p) 
+	{
+	   // destroy objects by calling their destructor
+	   p->~T();
+	}
+	
+	// deallocate storage p of deleted elements
+	template<class U>
+	void deallocate (U *p, size_type num) 
+	{
+		assert(num==1); //allocator not design for this
+		mPool.Free(p);
+	}
+};
+
+
+template <class T1,class T2>
+bool operator== (const CMapPool<T1>&,
+                const CMapPool<T2>&)
+{
+   return false;
+}
+template <class T1,class T2>
+bool operator!= (const CMapPool<T1>&,
+                const CMapPool<T2>&)
+{
+   return true;
+}
+
+template <class K,class V,class Compare = less<K> >
+class hmap : public map<K,V,Compare,CMapPool<V> >{};
+
+template <class K,class V,class Compare = less<K> >
+class hmultimap : public multimap<K,V,Compare,CMapPool<V> >{};
+
+template <class K,class Compare = less<K> >
+class hset : public set<K,Compare,CMapPool<K> >{};
+
+template <class K,class Compare = less<K> >
+class hmultiset : public multiset<K,Compare,CMapPool<K> >{};
+
+template <class K>
+class hlist : public list<K,CMapPool<K> >{};
+
+// General purpose allocator/deallocator.
+template <class X> X *XAlloc(void)
+{
+	assert(sizeof(X)<=(MAP_NODE_SIZE-2));
+	return((X *)GetMapPool().Alloc());
+}
+
+template<class X> void XFree(X *x)
+{
+	GetMapPool().Free((void *)x);
+}
+#endif // hString_H
+
+#endif // _DONETPROFILE_
\ No newline at end of file
diff --git a/codemp/qcommon/huffman.cpp b/codemp/qcommon/huffman.cpp
new file mode 100644
index 0000000..3d1e9ae
--- /dev/null
+++ b/codemp/qcommon/huffman.cpp
@@ -0,0 +1,417 @@
+
+/* This is based on the Adaptive Huffman algorithm described in Sayood's Data
+ * Compression book.  The ranks are not actually stored, but implicitly defined
+ * by the location of a node within a doubly-linked list */
+
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+
+static int			bloc = 0;
+
+void	Huff_putBit( int bit, byte *fout, int *offset) {
+	bloc = *offset;
+	if ((bloc&7) == 0) {
+		fout[(bloc>>3)] = 0;
+	}
+	fout[(bloc>>3)] |= bit << (bloc&7);
+	bloc++;
+	*offset = bloc;
+}
+
+int		Huff_getBit( byte *fin, int *offset) {
+	int t;
+	bloc = *offset;
+	t = (fin[(bloc>>3)] >> (bloc&7)) & 0x1;
+	bloc++;
+	*offset = bloc;
+	return t;
+}
+
+/* Add a bit to the output file (buffered) */
+static void add_bit (char bit, byte *fout) {
+	if ((bloc&7) == 0) {
+		fout[(bloc>>3)] = 0;
+	}
+	fout[(bloc>>3)] |= bit << (bloc&7);
+	bloc++;
+}
+
+/* Receive one bit from the input file (buffered) */
+static int get_bit (byte *fin) {
+	int t;
+	t = (fin[(bloc>>3)] >> (bloc&7)) & 0x1;
+	bloc++;
+	return t;
+}
+
+static node_t **get_ppnode(huff_t* huff) {
+	node_t **tppnode;
+	if (!huff->freelist) {
+		return &(huff->nodePtrs[huff->blocPtrs++]);
+	} else {
+		tppnode = huff->freelist;
+		huff->freelist = (node_t **)*tppnode;
+		return tppnode;
+	}
+}
+
+static void free_ppnode(huff_t* huff, node_t **ppnode) {
+	*ppnode = (node_t *)huff->freelist;
+	huff->freelist = ppnode;
+}
+
+/* Swap the location of these two nodes in the tree */
+static void swap (huff_t* huff, node_t *node1, node_t *node2) { 
+	node_t *par1, *par2;
+
+	par1 = node1->parent;
+	par2 = node2->parent;
+
+	if (par1) {
+		if (par1->left == node1) {
+			par1->left = node2;
+		} else {
+	      par1->right = node2;
+		}
+	} else {
+		huff->tree = node2;
+	}
+
+	if (par2) {
+		if (par2->left == node2) {
+			par2->left = node1;
+		} else {
+			par2->right = node1;
+		}
+	} else {
+		huff->tree = node1;
+	}
+  
+	node1->parent = par2;
+	node2->parent = par1;
+}
+
+/* Swap these two nodes in the linked list (update ranks) */
+static void swaplist(node_t *node1, node_t *node2) {
+	node_t *par1;
+
+	par1 = node1->next;
+	node1->next = node2->next;
+	node2->next = par1;
+
+	par1 = node1->prev;
+	node1->prev = node2->prev;
+	node2->prev = par1;
+
+	if (node1->next == node1) {
+		node1->next = node2;
+	}
+	if (node2->next == node2) {
+		node2->next = node1;
+	}
+	if (node1->next) {
+		node1->next->prev = node1;
+	}
+	if (node2->next) {
+		node2->next->prev = node2;
+	}
+	if (node1->prev) {
+		node1->prev->next = node1;
+	}
+	if (node2->prev) {
+		node2->prev->next = node2;
+	}
+}
+
+/* Do the increments */
+static void increment(huff_t* huff, node_t *node) {
+	node_t *lnode;
+
+	if (!node) {
+		return;
+	}
+
+	if (node->next != NULL && node->next->weight == node->weight) {
+	    lnode = *node->head;
+		if (lnode != node->parent) {
+			swap(huff, lnode, node);
+		}
+		swaplist(lnode, node);
+	}
+	if (node->prev && node->prev->weight == node->weight) {
+		*node->head = node->prev;
+	} else {
+	    *node->head = NULL;
+		free_ppnode(huff, node->head);
+	}
+	node->weight++;
+	if (node->next && node->next->weight == node->weight) {
+		node->head = node->next->head;
+	} else { 
+		node->head = get_ppnode(huff);
+		*node->head = node;
+	}
+	if (node->parent) {
+		increment(huff, node->parent);
+		if (node->prev == node->parent) {
+			swaplist(node, node->parent);
+			if (*node->head == node) {
+				*node->head = node->parent;
+			}
+		}
+	}
+}
+
+void Huff_addRef(huff_t* huff, byte ch) {
+	node_t *tnode, *tnode2;
+	if (huff->loc[ch] == NULL) { /* if this is the first transmission of this node */
+		tnode = &(huff->nodeList[huff->blocNode++]);
+		tnode2 = &(huff->nodeList[huff->blocNode++]);
+
+		tnode2->symbol = INTERNAL_NODE;
+		tnode2->weight = 1;
+		tnode2->next = huff->lhead->next;
+		if (huff->lhead->next) {
+			huff->lhead->next->prev = tnode2;
+			if (huff->lhead->next->weight == 1) {
+				tnode2->head = huff->lhead->next->head;
+			} else {
+				tnode2->head = get_ppnode(huff);
+				*tnode2->head = tnode2;
+			}
+		} else {
+			tnode2->head = get_ppnode(huff);
+			*tnode2->head = tnode2;
+		}
+		huff->lhead->next = tnode2;
+		tnode2->prev = huff->lhead;
+ 
+		tnode->symbol = ch;
+		tnode->weight = 1;
+		tnode->next = huff->lhead->next;
+		if (huff->lhead->next) {
+			huff->lhead->next->prev = tnode;
+			if (huff->lhead->next->weight == 1) {
+				tnode->head = huff->lhead->next->head;
+			} else {
+				/* this should never happen */
+				tnode->head = get_ppnode(huff);
+				*tnode->head = tnode2;
+		    }
+		} else {
+			/* this should never happen */
+			tnode->head = get_ppnode(huff);
+			*tnode->head = tnode;
+		}
+		huff->lhead->next = tnode;
+		tnode->prev = huff->lhead;
+		tnode->left = tnode->right = NULL;
+ 
+		if (huff->lhead->parent) {
+			if (huff->lhead->parent->left == huff->lhead) { /* lhead is guaranteed to by the NYT */
+				huff->lhead->parent->left = tnode2;
+			} else {
+				huff->lhead->parent->right = tnode2;
+			}
+		} else {
+			huff->tree = tnode2; 
+		}
+ 
+		tnode2->right = tnode;
+		tnode2->left = huff->lhead;
+ 
+		tnode2->parent = huff->lhead->parent;
+		huff->lhead->parent = tnode->parent = tnode2;
+     
+		huff->loc[ch] = tnode;
+ 
+		increment(huff, tnode2->parent);
+	} else {
+		increment(huff, huff->loc[ch]);
+	}
+}
+
+/* Get a symbol */
+int Huff_Receive (node_t *node, int *ch, byte *fin) {
+	while (node && node->symbol == INTERNAL_NODE) {
+		if (get_bit(fin)) {
+			node = node->right;
+		} else {
+			node = node->left;
+		}
+	}
+	if (!node) {
+		return 0;
+//		Com_Error(ERR_DROP, "Illegal tree!\n");
+	}
+	return (*ch = node->symbol);
+}
+
+/* Get a symbol */
+void Huff_offsetReceive (node_t *node, int *ch, byte *fin, int *offset) {
+	bloc = *offset;
+	while (node && node->symbol == INTERNAL_NODE) {
+		if (get_bit(fin)) {
+			node = node->right;
+		} else {
+			node = node->left;
+		}
+	}
+	if (!node) {
+		*ch = 0;
+		return;
+//		Com_Error(ERR_DROP, "Illegal tree!\n");
+	}
+	*ch = node->symbol;
+	*offset = bloc;
+}
+
+/* Send the prefix code for this node */
+static void send(node_t *node, node_t *child, byte *fout) {
+	if (node->parent) {
+		send(node->parent, node, fout);
+	}
+	if (child) {
+		if (node->right == child) {
+			add_bit(1, fout);
+		} else {
+			add_bit(0, fout);
+		}
+	}
+}
+
+/* Send a symbol */
+void Huff_transmit (huff_t *huff, int ch, byte *fout) {
+	int i;
+	if (huff->loc[ch] == NULL) { 
+		/* node_t hasn't been transmitted, send a NYT, then the symbol */
+		Huff_transmit(huff, NYT, fout);
+		for (i = 7; i >= 0; i--) {
+			add_bit((char)((ch >> i) & 0x1), fout);
+		}
+	} else {
+		send(huff->loc[ch], NULL, fout);
+	}
+}
+
+void Huff_offsetTransmit (huff_t *huff, int ch, byte *fout, int *offset) {
+	bloc = *offset;
+	send(huff->loc[ch], NULL, fout);
+	*offset = bloc;
+}
+
+void Huff_Decompress(msg_t *mbuf, int offset) {
+	int			ch, cch, i, j, size;
+	byte		seq[65536];
+	byte*		buffer;
+	huff_t		huff;
+
+	size = mbuf->cursize - offset;
+	buffer = mbuf->data + offset;
+
+	if ( size <= 0 ) {
+		return;
+	}
+
+	Com_Memset(&huff, 0, sizeof(huff_t));
+	// Initialize the tree & list with the NYT node 
+	huff.tree = huff.lhead = huff.ltail = huff.loc[NYT] = &(huff.nodeList[huff.blocNode++]);
+	huff.tree->symbol = NYT;
+	huff.tree->weight = 0;
+	huff.lhead->next = huff.lhead->prev = NULL;
+	huff.tree->parent = huff.tree->left = huff.tree->right = NULL;
+
+	cch = buffer[0]*256 + buffer[1];
+	// don't overflow with bad messages
+	if ( cch > mbuf->maxsize - offset ) {
+		cch = mbuf->maxsize - offset;
+	}
+	bloc = 16;
+
+	for ( j = 0; j < cch; j++ ) {
+		ch = 0;
+		// don't overflow reading from the messages
+		// FIXME: would it be better to have a overflow check in get_bit ?
+		if ( (bloc >> 3) > size ) {
+			seq[j] = 0;
+			break;
+		}
+		Huff_Receive(huff.tree, &ch, buffer);				/* Get a character */
+		if ( ch == NYT ) {								/* We got a NYT, get the symbol associated with it */
+			ch = 0;
+			for ( i = 0; i < 8; i++ ) {
+				ch = (ch<<1) + get_bit(buffer);
+			}
+		}
+    
+		seq[j] = ch;									/* Write symbol */
+
+		Huff_addRef(&huff, (byte)ch);								/* Increment node */
+	}
+	mbuf->cursize = cch + offset;
+	Com_Memcpy(mbuf->data + offset, seq, cch);
+}
+
+extern 	int oldsize;
+
+void Huff_Compress(msg_t *mbuf, int offset) {
+	int			i, ch, size;
+	byte		seq[65536];
+	byte*		buffer;
+	huff_t		huff;
+
+	size = mbuf->cursize - offset;
+	buffer = mbuf->data+ + offset;
+
+	if (size<=0) {
+		return;
+	}
+
+	Com_Memset(&huff, 0, sizeof(huff_t));
+	// Add the NYT (not yet transmitted) node into the tree/list */
+	huff.tree = huff.lhead = huff.loc[NYT] =  &(huff.nodeList[huff.blocNode++]);
+	huff.tree->symbol = NYT;
+	huff.tree->weight = 0;
+	huff.lhead->next = huff.lhead->prev = NULL;
+	huff.tree->parent = huff.tree->left = huff.tree->right = NULL;
+	huff.loc[NYT] = huff.tree;
+
+	seq[0] = (size>>8);
+	seq[1] = size&0xff;
+
+	bloc = 16;
+
+	for (i=0; i<size; i++ ) {
+		ch = buffer[i];
+		Huff_transmit(&huff, ch, seq);						/* Transmit symbol */
+		Huff_addRef(&huff, (byte)ch);								/* Do update */
+	}
+
+	bloc += 8;												// next byte
+
+	mbuf->cursize = (bloc>>3) + offset;
+	Com_Memcpy(mbuf->data+offset, seq, (bloc>>3));
+}
+
+void Huff_Init(huffman_t *huff) {
+
+	Com_Memset(&huff->compressor, 0, sizeof(huff_t));
+	Com_Memset(&huff->decompressor, 0, sizeof(huff_t));
+
+	// Initialize the tree & list with the NYT node 
+	huff->decompressor.tree = huff->decompressor.lhead = huff->decompressor.ltail = huff->decompressor.loc[NYT] = &(huff->decompressor.nodeList[huff->decompressor.blocNode++]);
+	huff->decompressor.tree->symbol = NYT;
+	huff->decompressor.tree->weight = 0;
+	huff->decompressor.lhead->next = huff->decompressor.lhead->prev = NULL;
+	huff->decompressor.tree->parent = huff->decompressor.tree->left = huff->decompressor.tree->right = NULL;
+
+	// Add the NYT (not yet transmitted) node into the tree/list */
+	huff->compressor.tree = huff->compressor.lhead = huff->compressor.loc[NYT] =  &(huff->compressor.nodeList[huff->compressor.blocNode++]);
+	huff->compressor.tree->symbol = NYT;
+	huff->compressor.tree->weight = 0;
+	huff->compressor.lhead->next = huff->compressor.lhead->prev = NULL;
+	huff->compressor.tree->parent = huff->compressor.tree->left = huff->compressor.tree->right = NULL;
+	huff->compressor.loc[NYT] = huff->compressor.tree;
+}
+
diff --git a/codemp/qcommon/md4.cpp b/codemp/qcommon/md4.cpp
new file mode 100644
index 0000000..f7e7eee
--- /dev/null
+++ b/codemp/qcommon/md4.cpp
@@ -0,0 +1,296 @@
+/* GLOBAL.H - RSAREF types and constants */
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+#include <string.h>
+#if defined(_WIN32)
+#pragma warning(disable : 4711)		// selected for automatic inline expansion
+#endif
+
+/* POINTER defines a generic pointer type */
+typedef unsigned char *POINTER;
+
+/* UINT2 defines a two byte word */
+typedef unsigned short int UINT2;
+
+/* UINT4 defines a four byte word */
+typedef unsigned long int UINT4;
+
+  
+/* MD4.H - header file for MD4C.C */
+
+/* Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. 
+
+All rights reserved.
+  
+License to copy and use this software is granted provided that it is identified as the “RSA Data Security, Inc. MD4 Message-Digest Algorithm” in all material mentioning or referencing this software or this function.
+License is also granted to make and use derivative works provided that such works are identified as “derived from the RSA Data Security, Inc. MD4 Message-Digest Algorithm” in all material mentioning or referencing the derived work.
+RSA Data Security, Inc. makes no representations concerning either the merchantability of this software or the suitability of this software for any particular purpose. It is provided “as is” without express or implied warranty of any kind.
+  
+These notices must be retained in any copies of any part of this documentation and/or software. */
+
+/* MD4 context. */
+typedef struct {
+	UINT4 state[4];				/* state (ABCD) */
+	UINT4 count[2];				/* number of bits, modulo 2^64 (lsb first) */
+	unsigned char buffer[64]; 			/* input buffer */
+} MD4_CTX;
+
+void MD4Init (MD4_CTX *);
+void MD4Update (MD4_CTX *, const unsigned char *, unsigned int);
+void MD4Final (unsigned char [16], MD4_CTX *);
+  
+void Com_Memset (void* dest, const int val, const size_t count);
+void Com_Memcpy (void* dest, const void* src, const size_t count);
+  
+/* MD4C.C - RSA Data Security, Inc., MD4 message-digest algorithm */
+/* Copyright (C) 1990-2, RSA Data Security, Inc. All rights reserved.
+  
+License to copy and use this software is granted provided that it is identified as the
+RSA Data Security, Inc. MD4 Message-Digest Algorithm
+ in all material mentioning or referencing this software or this function.
+License is also granted to make and use derivative works provided that such works are identified as 
+derived from the RSA Data Security, Inc. MD4 Message-Digest Algorithm
+in all material mentioning or referencing the derived work.
+RSA Data Security, Inc. makes no representations concerning either the merchantability of this software or the suitability of this software for any particular purpose. It is provided
+as is without express or implied warranty of any kind.
+  
+These notices must be retained in any copies of any part of this documentation and/or software. */
+
+/* Constants for MD4Transform routine.  */
+#define S11 3
+#define S12 7
+#define S13 11
+#define S14 19
+#define S21 3
+#define S22 5
+#define S23 9
+#define S24 13
+#define S31 3
+#define S32 9
+#define S33 11
+#define S34 15
+
+static void MD4Transform (UINT4 [4], const unsigned char [64]);
+static void Encode (unsigned char *, UINT4 *, unsigned int);
+static void Decode (UINT4 *, const unsigned char *, unsigned int);
+
+static unsigned char PADDING[64] = {
+0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
+};
+
+/* F, G and H are basic MD4 functions. */
+#define F(x, y, z) (((x) & (y)) | ((~x) & (z)))
+#define G(x, y, z) (((x) & (y)) | ((x) & (z)) | ((y) & (z)))
+#define H(x, y, z) ((x) ^ (y) ^ (z))
+
+/* ROTATE_LEFT rotates x left n bits. */
+#define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32-(n))))
+
+/* FF, GG and HH are transformations for rounds 1, 2 and 3 */
+/* Rotation is separate from addition to prevent recomputation */
+#define FF(a, b, c, d, x, s) {(a) += F ((b), (c), (d)) + (x); (a) = ROTATE_LEFT ((a), (s));}
+
+#define GG(a, b, c, d, x, s) {(a) += G ((b), (c), (d)) + (x) + (UINT4)0x5a827999; (a) = ROTATE_LEFT ((a), (s));}
+
+#define HH(a, b, c, d, x, s) {(a) += H ((b), (c), (d)) + (x) + (UINT4)0x6ed9eba1; (a) = ROTATE_LEFT ((a), (s));}
+
+
+/* MD4 initialization. Begins an MD4 operation, writing a new context. */
+void MD4Init (MD4_CTX *context)
+{
+	context->count[0] = context->count[1] = 0;
+
+/* Load magic initialization constants.*/
+context->state[0] = 0x67452301;
+context->state[1] = 0xefcdab89;
+context->state[2] = 0x98badcfe;
+context->state[3] = 0x10325476;
+}
+
+/* MD4 block update operation. Continues an MD4 message-digest operation, processing another message block, and updating the context. */
+void MD4Update (MD4_CTX *context, const unsigned char *input, unsigned int inputLen)
+{
+	unsigned int i, index, partLen;
+
+	/* Compute number of bytes mod 64 */
+	index = (unsigned int)((context->count[0] >> 3) & 0x3F);
+
+	/* Update number of bits */
+	if ((context->count[0] += ((UINT4)inputLen << 3))< ((UINT4)inputLen << 3))
+		context->count[1]++;
+
+	context->count[1] += ((UINT4)inputLen >> 29);
+
+	partLen = 64 - index;
+
+	/* Transform as many times as possible.*/
+	if (inputLen >= partLen)
+	{
+ 		Com_Memcpy((POINTER)&context->buffer[index], (POINTER)input, partLen);
+ 		MD4Transform (context->state, context->buffer);
+
+ 		for (i = partLen; i + 63 < inputLen; i += 64)
+ 			MD4Transform (context->state, &input[i]);
+
+ 		index = 0;
+	}
+	else
+ 		i = 0;
+
+	/* Buffer remaining input */
+	Com_Memcpy ((POINTER)&context->buffer[index], (POINTER)&input[i], inputLen-i);
+}
+
+
+/* MD4 finalization. Ends an MD4 message-digest operation, writing the the message digest and zeroizing the context. */
+void MD4Final (unsigned char digest[16], MD4_CTX *context)
+{
+	unsigned char bits[8];
+	unsigned int index, padLen;
+
+	/* Save number of bits */
+	Encode (bits, context->count, 8);
+
+	/* Pad out to 56 mod 64.*/
+	index = (unsigned int)((context->count[0] >> 3) & 0x3f);
+	padLen = (index < 56) ? (56 - index) : (120 - index);
+	MD4Update (context, PADDING, padLen);
+
+	/* Append length (before padding) */
+	MD4Update (context, bits, 8);
+	
+	/* Store state in digest */
+	Encode (digest, context->state, 16);
+
+	/* Zeroize sensitive information.*/
+	Com_Memset ((POINTER)context, 0, sizeof (*context));
+}
+
+
+/* MD4 basic transformation. Transforms state based on block. */
+static void MD4Transform (UINT4 state[4], const unsigned char block[64])
+{
+	UINT4 a = state[0], b = state[1], c = state[2], d = state[3], x[16];
+
+	Decode (x, block, 64);
+
+/* Round 1 */
+FF (a, b, c, d, x[ 0], S11); 				/* 1 */
+FF (d, a, b, c, x[ 1], S12); 				/* 2 */
+FF (c, d, a, b, x[ 2], S13); 				/* 3 */
+FF (b, c, d, a, x[ 3], S14); 				/* 4 */
+FF (a, b, c, d, x[ 4], S11); 				/* 5 */
+FF (d, a, b, c, x[ 5], S12); 				/* 6 */
+FF (c, d, a, b, x[ 6], S13); 				/* 7 */
+FF (b, c, d, a, x[ 7], S14); 				/* 8 */
+FF (a, b, c, d, x[ 8], S11); 				/* 9 */
+FF (d, a, b, c, x[ 9], S12); 				/* 10 */
+FF (c, d, a, b, x[10], S13); 			/* 11 */
+FF (b, c, d, a, x[11], S14); 			/* 12 */
+FF (a, b, c, d, x[12], S11); 			/* 13 */
+FF (d, a, b, c, x[13], S12); 			/* 14 */
+FF (c, d, a, b, x[14], S13); 			/* 15 */
+FF (b, c, d, a, x[15], S14); 			/* 16 */
+
+/* Round 2 */
+GG (a, b, c, d, x[ 0], S21); 			/* 17 */
+GG (d, a, b, c, x[ 4], S22); 			/* 18 */
+GG (c, d, a, b, x[ 8], S23); 			/* 19 */
+GG (b, c, d, a, x[12], S24); 			/* 20 */
+GG (a, b, c, d, x[ 1], S21); 			/* 21 */
+GG (d, a, b, c, x[ 5], S22); 			/* 22 */
+GG (c, d, a, b, x[ 9], S23); 			/* 23 */
+GG (b, c, d, a, x[13], S24); 			/* 24 */
+GG (a, b, c, d, x[ 2], S21); 			/* 25 */
+GG (d, a, b, c, x[ 6], S22); 			/* 26 */
+GG (c, d, a, b, x[10], S23); 			/* 27 */
+GG (b, c, d, a, x[14], S24); 			/* 28 */
+GG (a, b, c, d, x[ 3], S21); 			/* 29 */
+GG (d, a, b, c, x[ 7], S22); 			/* 30 */
+GG (c, d, a, b, x[11], S23); 			/* 31 */
+GG (b, c, d, a, x[15], S24); 			/* 32 */
+
+/* Round 3 */
+HH (a, b, c, d, x[ 0], S31);				/* 33 */
+HH (d, a, b, c, x[ 8], S32); 			/* 34 */
+HH (c, d, a, b, x[ 4], S33); 			/* 35 */
+HH (b, c, d, a, x[12], S34); 			/* 36 */
+HH (a, b, c, d, x[ 2], S31); 			/* 37 */
+HH (d, a, b, c, x[10], S32); 			/* 38 */
+HH (c, d, a, b, x[ 6], S33); 			/* 39 */
+HH (b, c, d, a, x[14], S34); 			/* 40 */
+HH (a, b, c, d, x[ 1], S31); 			/* 41 */
+HH (d, a, b, c, x[ 9], S32); 			/* 42 */
+HH (c, d, a, b, x[ 5], S33); 			/* 43 */
+HH (b, c, d, a, x[13], S34); 			/* 44 */
+HH (a, b, c, d, x[ 3], S31); 			/* 45 */
+HH (d, a, b, c, x[11], S32); 			/* 46 */
+HH (c, d, a, b, x[ 7], S33); 			/* 47 */
+HH (b, c, d, a, x[15], S34);			/* 48 */
+
+state[0] += a;
+state[1] += b;
+state[2] += c;
+state[3] += d;
+
+	/* Zeroize sensitive information.*/
+	Com_Memset ((POINTER)x, 0, sizeof (x));
+}
+
+
+/* Encodes input (UINT4) into output (unsigned char). Assumes len is a multiple of 4. */
+static void Encode (unsigned char *output, UINT4 *input, unsigned int len)
+{
+	unsigned int i, j;
+
+	for (i = 0, j = 0; j < len; i++, j += 4) {
+ 		output[j] = (unsigned char)(input[i] & 0xff);
+ 		output[j+1] = (unsigned char)((input[i] >> 8) & 0xff);
+ 		output[j+2] = (unsigned char)((input[i] >> 16) & 0xff);
+ 		output[j+3] = (unsigned char)((input[i] >> 24) & 0xff);
+	}
+}
+
+
+/* Decodes input (unsigned char) into output (UINT4). Assumes len is a multiple of 4. */
+static void Decode (UINT4 *output, const unsigned char *input, unsigned int len)
+{
+unsigned int i, j;
+
+for (i = 0, j = 0; j < len; i++, j += 4)
+ 	output[i] = ((UINT4)input[j]) | (((UINT4)input[j+1]) << 8) | (((UINT4)input[j+2]) << 16) | (((UINT4)input[j+3]) << 24);
+}
+
+//===================================================================
+
+unsigned Com_BlockChecksum (const void *buffer, int length)
+{
+	int			digest[4];
+	unsigned	val;
+	MD4_CTX		ctx;
+
+	MD4Init (&ctx);
+	MD4Update (&ctx, (unsigned char *)buffer, length);
+	MD4Final ( (unsigned char *)digest, &ctx);
+	
+	val = digest[0] ^ digest[1] ^ digest[2] ^ digest[3];
+
+	return val;
+}
+
+unsigned Com_BlockChecksumKey (void *buffer, int length, int key)
+{
+	int			digest[4];
+	unsigned	val;
+	MD4_CTX		ctx;
+
+	MD4Init (&ctx);
+	MD4Update (&ctx, (unsigned char *)&key, 4);
+	MD4Update (&ctx, (unsigned char *)buffer, length);
+	MD4Final ( (unsigned char *)digest, &ctx);
+	
+	val = digest[0] ^ digest[1] ^ digest[2] ^ digest[3];
+
+	return val;
+}
diff --git a/codemp/qcommon/msg.cpp b/codemp/qcommon/msg.cpp
new file mode 100644
index 0000000..7dddcd4
--- /dev/null
+++ b/codemp/qcommon/msg.cpp
@@ -0,0 +1,3318 @@
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+#ifdef _DONETPROFILE_
+#include "INetProfile.h"
+#endif
+
+// rjr: this is only used when cl_shownet is turned on and the server and client are in the same session
+#include "../game/g_public.h"
+#include "../server/server.h"
+
+extern	cvar_t	*cl_shownet;
+
+
+
+//#define _NEWHUFFTABLE_		// Build "c:\\netchan.bin"
+//#define _USINGNEWHUFFTABLE_		// Build a new frequency table to cut and paste.
+
+static huffman_t		msgHuff;
+
+static qboolean			msgInit = qfalse;
+static FILE				*fp=0;
+
+/*
+==============================================================================
+
+			MESSAGE IO FUNCTIONS
+
+Handles byte ordering and avoids alignment errors
+==============================================================================
+*/
+
+#ifndef FINAL_BUILD
+	int gLastBitIndex = 0;
+#endif
+
+int oldsize = 0;
+
+#ifndef _XBOX	// No mods on Xbox
+bool g_nOverrideChecked = false;
+void MSG_CheckNETFPSFOverrides(qboolean psfOverrides);
+#endif
+
+void MSG_initHuffman();
+
+void MSG_Init( msg_t *buf, byte *data, int length ) {
+#ifndef _XBOX	// No mods on Xbox
+	if (!g_nOverrideChecked)
+	{
+		//Check for netf overrides
+		MSG_CheckNETFPSFOverrides(qfalse);
+		
+		//Then for psf overrides
+		MSG_CheckNETFPSFOverrides(qtrue);
+
+		g_nOverrideChecked = true;
+	}
+#endif
+
+	if (!msgInit)
+	{
+		MSG_initHuffman();
+	}
+
+	Com_Memset (buf, 0, sizeof(*buf));
+	buf->data = data;
+	buf->maxsize = length;
+}
+
+void MSG_InitOOB( msg_t *buf, byte *data, int length ) {
+#ifndef _XBOX	// No mods on Xbox
+	if (!g_nOverrideChecked)
+	{
+		//Check for netf overrides
+		MSG_CheckNETFPSFOverrides(qfalse);
+		
+		//Then for psf overrides
+		MSG_CheckNETFPSFOverrides(qtrue);
+
+		g_nOverrideChecked = true;
+	}
+#endif	// _XBOX
+
+	if (!msgInit)
+	{
+		MSG_initHuffman();
+	}
+	Com_Memset (buf, 0, sizeof(*buf));
+	buf->data = data;
+	buf->maxsize = length;
+	buf->oob = qtrue;
+}
+
+void MSG_Clear( msg_t *buf ) {
+	buf->cursize = 0;
+	buf->overflowed = qfalse;
+	buf->bit = 0;					//<- in bits
+}
+
+
+void MSG_Bitstream( msg_t *buf ) {
+	buf->oob = qfalse;
+}
+
+void MSG_BeginReading( msg_t *msg ) {
+	msg->readcount = 0;
+	msg->bit = 0;
+	msg->oob = qfalse;
+}
+
+void MSG_BeginReadingOOB( msg_t *msg ) {
+	msg->readcount = 0;
+	msg->bit = 0;
+	msg->oob = qtrue;
+}
+
+
+/*
+=============================================================================
+
+bit functions
+  
+=============================================================================
+*/
+
+int	overflows;
+
+// negative bit values include signs
+void MSG_WriteBits( msg_t *msg, int value, int bits ) {
+	int	i;
+
+	oldsize += bits;
+
+	// this isn't an exact overflow check, but close enough
+	if ( msg->maxsize - msg->cursize < 4 ) {
+		msg->overflowed = qtrue;
+		return;
+	}
+
+	if ( bits == 0 || bits < -31 || bits > 32 ) {
+		Com_Error( ERR_DROP, "MSG_WriteBits: bad bits %i", bits );
+	}
+
+	// check for overflows
+	if ( bits != 32 ) {
+		if ( bits > 0 ) {
+			if ( value > ( ( 1 << bits ) - 1 ) || value < 0 ) {
+				overflows++;
+#ifndef FINAL_BUILD
+//				Com_Printf ("MSG_WriteBits: overflow writing %d in %d bits [index %i]\n", value, bits, gLastBitIndex);
+#endif
+			}
+		} else {
+			int	r;
+
+			r = 1 << (bits-1);
+
+			if ( value >  r - 1 || value < -r ) {
+				overflows++;
+#ifndef FINAL_BUILD
+//				Com_Printf ("MSG_WriteBits: overflow writing %d in %d bits [index %i]\n", value, bits, gLastBitIndex);
+#endif
+			}
+		}
+	}
+	if ( bits < 0 ) {
+		bits = -bits;
+	}
+	if (msg->oob) {
+		if (bits==8) {
+			msg->data[msg->cursize] = value;
+			msg->cursize += 1;
+			msg->bit += 8;
+		} else if (bits==16) {
+			unsigned short *sp = (unsigned short *)&msg->data[msg->cursize];
+			*sp = LittleShort(value);
+			msg->cursize += 2;
+			msg->bit += 16;
+		} else if (bits==32) {
+			unsigned int *ip = (unsigned int *)&msg->data[msg->cursize];
+			*ip = LittleLong(value);
+			msg->cursize += 4;
+			msg->bit += 8;
+		} else {
+			Com_Error(ERR_DROP, "can't read %d bits\n", bits);
+		}
+	} else {
+		value &= (0xffffffff>>(32-bits));
+		if (bits&7) {
+			int nbits;
+			nbits = bits&7;
+			for(i=0;i<nbits;i++) {
+				Huff_putBit((value&1), msg->data, &msg->bit);
+				value = (value>>1);
+			}
+			bits = bits - nbits;
+		}
+		if (bits) {
+			for(i=0;i<bits;i+=8) {
+#ifdef _NEWHUFFTABLE_
+				fwrite(&value, 1, 1, fp);
+#endif // _NEWHUFFTABLE_
+				Huff_offsetTransmit (&msgHuff.compressor, (value&0xff), msg->data, &msg->bit);
+				value = (value>>8);
+			}
+		}
+		msg->cursize = (msg->bit>>3)+1;
+	}
+}
+
+int MSG_ReadBits( msg_t *msg, int bits ) {
+	int			value;
+	int			get;
+	qboolean	sgn;
+	int			i, nbits;
+	value = 0;
+
+	if ( bits < 0 ) {
+		bits = -bits;
+		sgn = qtrue;
+	} else {
+		sgn = qfalse;
+	}
+
+	if (msg->oob) {
+		if (bits==8) {
+			value = msg->data[msg->readcount];
+			msg->readcount += 1;
+			msg->bit += 8;
+		} else if (bits==16) {
+			unsigned short *sp = (unsigned short *)&msg->data[msg->readcount];
+			value = LittleShort(*sp);
+			msg->readcount += 2;
+			msg->bit += 16;
+		} else if (bits==32) {
+			unsigned int *ip = (unsigned int *)&msg->data[msg->readcount];
+			value = LittleLong(*ip);
+			msg->readcount += 4;
+			msg->bit += 32;
+		} else {
+			Com_Error(ERR_DROP, "can't read %d bits\n", bits);
+		}
+	} else {
+		nbits = 0;
+		if (bits&7) {
+			nbits = bits&7;
+			for(i=0;i<nbits;i++) {
+				value |= (Huff_getBit(msg->data, &msg->bit)<<i);
+			}
+			bits = bits - nbits;
+		}
+		if (bits) {
+			for(i=0;i<bits;i+=8) {
+				Huff_offsetReceive (msgHuff.decompressor.tree, &get, msg->data, &msg->bit);
+#ifdef _NEWHUFFTABLE_
+				fwrite(&get, 1, 1, fp);
+#endif // _NEWHUFFTABLE_
+				value |= (get<<(i+nbits));
+			}
+		}
+		msg->readcount = (msg->bit>>3)+1;
+	}
+	if ( sgn ) {
+		if ( value & ( 1 << ( bits - 1 ) ) ) {
+			value |= -1 ^ ( ( 1 << bits ) - 1 );
+		}
+	}
+
+	return value;
+}
+
+
+
+//================================================================================
+
+//
+// writing functions
+//
+
+void MSG_WriteChar( msg_t *sb, int c ) {
+#ifdef PARANOID
+	if (c < -128 || c > 127)
+		Com_Error (ERR_FATAL, "MSG_WriteChar: range error");
+#endif
+
+	MSG_WriteBits( sb, c, 8 );
+}
+
+void MSG_WriteByte( msg_t *sb, int c ) {
+#ifdef PARANOID
+	if (c < 0 || c > 255)
+		Com_Error (ERR_FATAL, "MSG_WriteByte: range error");
+#endif
+
+	MSG_WriteBits( sb, c, 8 );
+}
+
+void MSG_WriteData( msg_t *buf, const void *data, int length ) {
+	int i;
+	for(i=0;i<length;i++) {
+		MSG_WriteByte(buf, ((byte *)data)[i]);
+	}
+}
+
+void MSG_WriteShort( msg_t *sb, int c ) {
+#ifdef PARANOID
+	if (c < ((short)0x8000) || c > (short)0x7fff)
+		Com_Error (ERR_FATAL, "MSG_WriteShort: range error");
+#endif
+
+	MSG_WriteBits( sb, c, 16 );
+}
+
+void MSG_WriteLong( msg_t *sb, int c ) {
+	MSG_WriteBits( sb, c, 32 );
+}
+
+void MSG_WriteFloat( msg_t *sb, float f ) {
+	union {
+		float	f;
+		int	l;
+	} dat;
+	
+	dat.f = f;
+	MSG_WriteBits( sb, dat.l, 32 );
+}
+
+void MSG_WriteString( msg_t *sb, const char *s ) {
+	if ( !s ) {
+		MSG_WriteData (sb, "", 1);
+	} else {
+		int		l;
+		char	string[MAX_STRING_CHARS];
+
+		l = strlen( s );
+		if ( l >= MAX_STRING_CHARS ) {
+			Com_Printf( "MSG_WriteString: MAX_STRING_CHARS" );
+			MSG_WriteData (sb, "", 1);
+			return;
+		}
+		Q_strncpyz( string, s, sizeof( string ) );
+
+// eurofix: eliminating this means you can chat in european languages. WTF are "old clients" anyway?	-ste
+//
+//		// get rid of 0xff chars, because old clients don't like them
+//		for ( int i = 0 ; i < l ; i++ ) {
+//			if ( ((byte *)string)[i] > 127 ) {
+//				string[i] = '.';
+//			}
+//		}
+
+		MSG_WriteData (sb, string, l+1);
+	}
+}
+
+void MSG_WriteBigString( msg_t *sb, const char *s ) {
+	if ( !s ) {
+		MSG_WriteData (sb, "", 1);
+	} else {
+		int		l;
+		char	string[BIG_INFO_STRING];
+
+		l = strlen( s );
+		if ( l >= BIG_INFO_STRING ) {
+			Com_Printf( "MSG_WriteString: BIG_INFO_STRING" );
+			MSG_WriteData (sb, "", 1);
+			return;
+		}
+		Q_strncpyz( string, s, sizeof( string ) );
+
+// eurofix: remove this so we can chat in european languages...	-ste
+/*
+		// get rid of 0xff chars, because old clients don't like them
+		for ( int i = 0 ; i < l ; i++ ) {
+			if ( ((byte *)string)[i] > 127 ) {
+				string[i] = '.';
+			}
+		}
+*/
+
+		MSG_WriteData (sb, string, l+1);
+	}
+}
+
+void MSG_WriteAngle( msg_t *sb, float f ) {
+	MSG_WriteByte (sb, (int)(f*256/360) & 255);
+}
+
+void MSG_WriteAngle16( msg_t *sb, float f ) {
+	MSG_WriteShort (sb, ANGLE2SHORT(f));
+}
+
+
+//============================================================
+
+//
+// reading functions
+//
+
+// returns -1 if no more characters are available
+int MSG_ReadChar (msg_t *msg ) {
+	int	c;
+	
+	c = (signed char)MSG_ReadBits( msg, 8 );
+	if ( msg->readcount > msg->cursize ) {
+		c = -1;
+	}	
+	
+	return c;
+}
+
+int MSG_ReadByte( msg_t *msg ) {
+	int	c;
+	
+	c = (unsigned char)MSG_ReadBits( msg, 8 );
+	if ( msg->readcount > msg->cursize ) {
+		c = -1;
+	}	
+	return c;
+}
+
+int MSG_ReadShort( msg_t *msg ) {
+	int	c;
+	
+	c = (short)MSG_ReadBits( msg, 16 );
+	if ( msg->readcount > msg->cursize ) {
+		c = -1;
+	}	
+
+	return c;
+}
+
+int MSG_ReadLong( msg_t *msg ) {
+	int	c;
+	
+	c = MSG_ReadBits( msg, 32 );
+	if ( msg->readcount > msg->cursize ) {
+		c = -1;
+	}	
+	
+	return c;
+}
+
+float MSG_ReadFloat( msg_t *msg ) {
+	union {
+		byte	b[4];
+		float	f;
+		int	l;
+	} dat;
+	
+	dat.l = MSG_ReadBits( msg, 32 );
+	if ( msg->readcount > msg->cursize ) {
+		dat.f = -1;
+	}	
+	
+	return dat.f;	
+}
+
+char *MSG_ReadString( msg_t *msg ) {
+	static char	string[MAX_STRING_CHARS];
+	int		l,c;
+	
+	l = 0;
+	do {
+		c = MSG_ReadByte(msg);		// use ReadByte so -1 is out of bounds
+		if ( c == -1 || c == 0 ) {
+			break;
+		}
+		// translate all fmt spec to avoid crash bugs
+		if ( c == '%' ) {
+			c = '.';
+		}
+// eurofix: remove this so we can chat in european languages...	-ste
+//
+//		// don't allow higher ascii values
+//		if ( c > 127 ) {
+//			c = '.';
+//		}
+
+		string[l] = c;
+		l++;
+	} while (l <= sizeof(string)-1);
+	
+	// some bonus protection, shouldn't occur cause server doesn't write such things
+	if (l <= sizeof(string)-1)
+	{
+		string[l] = 0;
+	}
+	else
+	{
+		string[sizeof(string)-1] = 0;
+	}
+	
+	return string;
+}
+
+char *MSG_ReadBigString( msg_t *msg ) {
+	static char	string[BIG_INFO_STRING];
+	int		l,c;
+	
+	l = 0;
+	do {
+		c = MSG_ReadByte(msg);		// use ReadByte so -1 is out of bounds
+		if ( c == -1 || c == 0 ) {
+			break;
+		}
+		// translate all fmt spec to avoid crash bugs
+		if ( c == '%' ) {
+			c = '.';
+		}
+
+		string[l] = c;
+		l++;
+	} while (l < sizeof(string)-1);
+	
+	string[l] = 0;
+	
+	return string;
+}
+
+char *MSG_ReadStringLine( msg_t *msg ) {
+	static char	string[MAX_STRING_CHARS];
+	int		l,c;
+
+	l = 0;
+	do {
+		c = MSG_ReadByte(msg);		// use ReadByte so -1 is out of bounds
+		if (c == -1 || c == 0 || c == '\n') {
+			break;
+		}
+		// translate all fmt spec to avoid crash bugs
+		if ( c == '%' ) {
+			c = '.';
+		}
+		string[l] = c;
+		l++;
+	} while (l < sizeof(string)-1);
+	
+	string[l] = 0;
+	
+	return string;
+}
+
+float MSG_ReadAngle16( msg_t *msg ) {
+	return SHORT2ANGLE(MSG_ReadShort(msg));
+}
+
+void MSG_ReadData( msg_t *msg, void *data, int len ) {
+	int		i;
+
+	for (i=0 ; i<len ; i++) {
+		((byte *)data)[i] = MSG_ReadByte (msg);
+	}
+}
+
+
+/*
+=============================================================================
+
+delta functions
+  
+=============================================================================
+*/
+
+#define	LOG(x) if( cl_shownet->integer == 4 ) { Com_Printf("%s ", x ); };
+
+void MSG_WriteDelta( msg_t *msg, int oldV, int newV, int bits ) {
+	if ( oldV == newV ) {
+		MSG_WriteBits( msg, 0, 1 );
+		return;
+	}
+	MSG_WriteBits( msg, 1, 1 );
+	MSG_WriteBits( msg, newV, bits );
+}
+
+int	MSG_ReadDelta( msg_t *msg, int oldV, int bits ) {
+	if ( MSG_ReadBits( msg, 1 ) ) {
+		return MSG_ReadBits( msg, bits );
+	}
+	return oldV;
+}
+
+void MSG_WriteDeltaFloat( msg_t *msg, float oldV, float newV ) {
+	if ( oldV == newV ) {
+		MSG_WriteBits( msg, 0, 1 );
+		return;
+	}
+	MSG_WriteBits( msg, 1, 1 );
+	MSG_WriteBits( msg, *(int *)&newV, 32 );
+}
+
+float MSG_ReadDeltaFloat( msg_t *msg, float oldV ) {
+	if ( MSG_ReadBits( msg, 1 ) ) {
+		float	newV;
+
+		*(int *)&newV = MSG_ReadBits( msg, 32 );
+		return newV;
+	}
+	return oldV;
+}
+
+/*
+=============================================================================
+
+delta functions with keys
+  
+=============================================================================
+*/
+
+int kbitmask[32] = {
+	0x00000001, 0x00000003, 0x00000007, 0x0000000F,
+	0x0000001F,	0x0000003F,	0x0000007F,	0x000000FF,
+	0x000001FF,	0x000003FF,	0x000007FF,	0x00000FFF,
+	0x00001FFF,	0x00003FFF,	0x00007FFF,	0x0000FFFF,
+	0x0001FFFF,	0x0003FFFF,	0x0007FFFF,	0x000FFFFF,
+	0x001FFFFf,	0x003FFFFF,	0x007FFFFF,	0x00FFFFFF,
+	0x01FFFFFF,	0x03FFFFFF,	0x07FFFFFF,	0x0FFFFFFF,
+	0x1FFFFFFF,	0x3FFFFFFF,	0x7FFFFFFF,	0xFFFFFFFF,
+};
+
+void MSG_WriteDeltaKey( msg_t *msg, int key, int oldV, int newV, int bits ) 
+{
+	if ( oldV == newV ) 
+	{
+		MSG_WriteBits( msg, 0, 1 );
+		return;
+	}
+	MSG_WriteBits( msg, 1, 1 );
+	MSG_WriteBits( msg, (newV ^ key) & ((1 << bits) - 1), bits );
+}
+
+int	MSG_ReadDeltaKey( msg_t *msg, int key, int oldV, int bits ) {
+	if ( MSG_ReadBits( msg, 1 ) ) {
+		return MSG_ReadBits( msg, bits ) ^ (key & kbitmask[bits]);
+	}
+	return oldV;
+}
+
+void MSG_WriteDeltaKeyFloat( msg_t *msg, int key, float oldV, float newV ) {
+	if ( oldV == newV ) {
+		MSG_WriteBits( msg, 0, 1 );
+		return;
+	}
+	MSG_WriteBits( msg, 1, 1 );
+	MSG_WriteBits( msg, (*(int *)&newV) ^ key, 32 );
+}
+
+float MSG_ReadDeltaKeyFloat( msg_t *msg, int key, float oldV ) {
+	if ( MSG_ReadBits( msg, 1 ) ) {
+		float	newV;
+
+		*(int *)&newV = MSG_ReadBits( msg, 32 ) ^ key;
+		return newV;
+	}
+	return oldV;
+}
+
+
+/*
+============================================================================
+
+usercmd_t communication
+
+============================================================================
+*/
+
+// ms is allways sent, the others are optional
+#define	CM_ANGLE1 	(1<<0)
+#define	CM_ANGLE2 	(1<<1)
+#define	CM_ANGLE3 	(1<<2)
+#define	CM_FORWARD	(1<<3)
+#define	CM_SIDE		(1<<4)
+#define	CM_UP		(1<<5)
+#define	CM_BUTTONS	(1<<6)
+#define CM_WEAPON	(1<<7)
+//rww - these are new
+#define CM_FORCE	(1<<8)
+#define CM_INVEN	(1<<9)
+
+/*
+=====================
+MSG_WriteDeltaUsercmd
+=====================
+*/
+void MSG_WriteDeltaUsercmd( msg_t *msg, usercmd_t *from, usercmd_t *to ) {
+	if ( to->serverTime - from->serverTime < 256 ) {
+		MSG_WriteBits( msg, 1, 1 );
+		MSG_WriteBits( msg, to->serverTime - from->serverTime, 8 );
+	} else {
+		MSG_WriteBits( msg, 0, 1 );
+		MSG_WriteBits( msg, to->serverTime, 32 );
+	}
+	MSG_WriteDelta( msg, from->angles[0], to->angles[0], 16 );
+	MSG_WriteDelta( msg, from->angles[1], to->angles[1], 16 );
+	MSG_WriteDelta( msg, from->angles[2], to->angles[2], 16 );
+	MSG_WriteDelta( msg, from->forwardmove, to->forwardmove, 8 );
+	MSG_WriteDelta( msg, from->rightmove, to->rightmove, 8 );
+	MSG_WriteDelta( msg, from->upmove, to->upmove, 8 );
+	MSG_WriteDelta( msg, from->buttons, to->buttons, 16 );
+	MSG_WriteDelta( msg, from->weapon, to->weapon, 8 );
+
+	MSG_WriteDelta( msg, from->forcesel, to->forcesel, 8 );
+	MSG_WriteDelta( msg, from->invensel, to->invensel, 8 );
+
+	MSG_WriteDelta( msg, from->generic_cmd, to->generic_cmd, 8 );
+}
+
+
+/*
+=====================
+MSG_ReadDeltaUsercmd
+=====================
+*/
+void MSG_ReadDeltaUsercmd( msg_t *msg, usercmd_t *from, usercmd_t *to ) {
+	if ( MSG_ReadBits( msg, 1 ) ) {
+		to->serverTime = from->serverTime + MSG_ReadBits( msg, 8 );
+	} else {
+		to->serverTime = MSG_ReadBits( msg, 32 );
+	}
+	to->angles[0] = MSG_ReadDelta( msg, from->angles[0], 16);
+	to->angles[1] = MSG_ReadDelta( msg, from->angles[1], 16);
+	to->angles[2] = MSG_ReadDelta( msg, from->angles[2], 16);
+	to->forwardmove = MSG_ReadDelta( msg, from->forwardmove, 8);
+	to->rightmove = MSG_ReadDelta( msg, from->rightmove, 8);
+	to->upmove = MSG_ReadDelta( msg, from->upmove, 8);
+	to->buttons = MSG_ReadDelta( msg, from->buttons, 16);
+	to->weapon = MSG_ReadDelta( msg, from->weapon, 8);
+
+	to->forcesel = MSG_ReadDelta( msg, from->forcesel, 8);
+	to->invensel = MSG_ReadDelta( msg, from->invensel, 8);
+
+	to->generic_cmd = MSG_ReadDelta( msg, from->generic_cmd, 8);
+}
+
+/*
+=====================
+MSG_WriteDeltaUsercmd
+=====================
+*/
+void MSG_WriteDeltaUsercmdKey( msg_t *msg, int key, usercmd_t *from, usercmd_t *to ) {
+	if ( to->serverTime - from->serverTime < 256 ) {
+		MSG_WriteBits( msg, 1, 1 );
+		MSG_WriteBits( msg, to->serverTime - from->serverTime, 8 );
+	} else {
+		MSG_WriteBits( msg, 0, 1 );
+		MSG_WriteBits( msg, to->serverTime, 32 );
+	}
+	if (from->angles[0] == to->angles[0] &&
+		from->angles[1] == to->angles[1] &&
+		from->angles[2] == to->angles[2] &&
+		from->forwardmove == to->forwardmove &&
+		from->rightmove == to->rightmove &&
+		from->upmove == to->upmove &&
+		from->buttons == to->buttons &&
+		from->weapon == to->weapon &&
+		from->forcesel == to->forcesel &&
+		from->invensel == to->invensel &&
+		from->generic_cmd == to->generic_cmd) {
+			MSG_WriteBits( msg, 0, 1 );				// no change
+			oldsize += 7;
+			return;
+	}
+	key ^= to->serverTime;
+	MSG_WriteBits( msg, 1, 1 );
+	MSG_WriteDeltaKey( msg, key, from->angles[0], to->angles[0], 16 );
+	MSG_WriteDeltaKey( msg, key, from->angles[1], to->angles[1], 16 );
+	MSG_WriteDeltaKey( msg, key, from->angles[2], to->angles[2], 16 );
+	MSG_WriteDeltaKey( msg, key, from->forwardmove, to->forwardmove, 8 );
+	MSG_WriteDeltaKey( msg, key, from->rightmove, to->rightmove, 8 );
+	MSG_WriteDeltaKey( msg, key, from->upmove, to->upmove, 8 );
+	MSG_WriteDeltaKey( msg, key, from->buttons, to->buttons, 16 );
+	MSG_WriteDeltaKey( msg, key, from->weapon, to->weapon, 8 );
+
+	MSG_WriteDeltaKey( msg, key, from->forcesel, to->forcesel, 8 );
+	MSG_WriteDeltaKey( msg, key, from->invensel, to->invensel, 8 );
+
+	MSG_WriteDeltaKey( msg, key, from->generic_cmd, to->generic_cmd, 8 );
+}
+
+
+/*
+=====================
+MSG_ReadDeltaUsercmd
+=====================
+*/
+void MSG_ReadDeltaUsercmdKey( msg_t *msg, int key, usercmd_t *from, usercmd_t *to ) {
+	if ( MSG_ReadBits( msg, 1 ) ) {
+		to->serverTime = from->serverTime + MSG_ReadBits( msg, 8 );
+	} else {
+		to->serverTime = MSG_ReadBits( msg, 32 );
+	}
+	if ( MSG_ReadBits( msg, 1 ) ) {
+		key ^= to->serverTime;
+		to->angles[0] = MSG_ReadDeltaKey( msg, key, from->angles[0], 16);
+		to->angles[1] = MSG_ReadDeltaKey( msg, key, from->angles[1], 16);
+		to->angles[2] = MSG_ReadDeltaKey( msg, key, from->angles[2], 16);
+		to->forwardmove = MSG_ReadDeltaKey( msg, key, from->forwardmove, 8);
+		to->rightmove = MSG_ReadDeltaKey( msg, key, from->rightmove, 8);
+		to->upmove = MSG_ReadDeltaKey( msg, key, from->upmove, 8);
+		to->buttons = MSG_ReadDeltaKey( msg, key, from->buttons, 16);
+		to->weapon = MSG_ReadDeltaKey( msg, key, from->weapon, 8);
+
+		to->forcesel = MSG_ReadDeltaKey( msg, key, from->forcesel, 8);
+		to->invensel = MSG_ReadDeltaKey( msg, key, from->invensel, 8);
+
+		to->generic_cmd = MSG_ReadDeltaKey( msg, key, from->generic_cmd, 8);
+	} else {
+		to->angles[0] = from->angles[0];
+		to->angles[1] = from->angles[1];
+		to->angles[2] = from->angles[2];
+		to->forwardmove = from->forwardmove;
+		to->rightmove = from->rightmove;
+		to->upmove = from->upmove;
+		to->buttons = from->buttons;
+		to->weapon = from->weapon;
+
+		to->forcesel = from->forcesel;
+		to->invensel = from->invensel;
+
+		to->generic_cmd = from->generic_cmd;
+	}
+}
+
+/*
+=============================================================================
+
+entityState_t communication
+  
+=============================================================================
+*/
+
+
+typedef struct {
+	char	*name;
+	int		offset;
+#ifdef _XBOX
+	int		realSize;	// in bytes (1, 2, 4)
+#endif
+	int		bits;		// 0 = float
+#ifndef FINAL_BUILD
+	unsigned	mCount;
+#endif
+
+} netField_t;
+
+// using the stringizing operator to save typing...
+#ifdef _XBOX
+#define	NETF(x) #x,(int)&((entityState_t*)0)->x,sizeof(((entityState_t*)0)->x)
+#else
+#define	NETF(x) #x,(int)&((entityState_t*)0)->x
+#endif
+
+//rww - Remember to update ext_data/MP/netf_overrides.txt if you change any of this!
+//(for the sake of being consistent)
+
+// BTO - This was mis-documented before. We do allow datatypes less than 32 bits on Xbox
+// now, but our macros and such handle it all automagically. No need to be anal about
+// keeping q_shared.h in sync with this.
+netField_t	entityStateFields[] = 
+{
+{ NETF(pos.trTime), 32 },
+{ NETF(pos.trBase[1]), 0 },
+{ NETF(pos.trBase[0]), 0 },
+{ NETF(apos.trBase[1]), 0 },
+{ NETF(pos.trBase[2]), 0 },
+{ NETF(apos.trBase[0]), 0 },
+{ NETF(pos.trDelta[0]), 0 },
+{ NETF(pos.trDelta[1]), 0 },
+{ NETF(eType), 8 },
+{ NETF(angles[1]), 0 },
+{ NETF(pos.trDelta[2]), 0 },
+{ NETF(origin[0]), 0 },
+{ NETF(origin[1]), 0 },
+{ NETF(origin[2]), 0 },
+// does this need to be 8 bits?
+{ NETF(weapon), 8 },
+{ NETF(apos.trType), 8 },
+// changed from 12 to 16
+{ NETF(legsAnim), 16 },			// Maximum number of animation sequences is 2048.  Top bit is reserved for the togglebit
+// suspicious
+{ NETF(torsoAnim), 16 },		// Maximum number of animation sequences is 2048.  Top bit is reserved for the togglebit
+// large use beyond GENTITYNUM_BITS - should use generic1 insead
+{ NETF(genericenemyindex), 32 }, //Do not change to GENTITYNUM_BITS, used as a time offset for seeker
+{ NETF(eFlags), 32 },
+{ NETF(pos.trDuration), 32 },
+// might be able to reduce
+{ NETF(teamowner), 8 },
+{ NETF(groundEntityNum), GENTITYNUM_BITS },
+{ NETF(pos.trType), 8 },
+{ NETF(angles[2]), 0 },
+{ NETF(angles[0]), 0 },
+{ NETF(solid), 24 },
+// flag states barely used - could be moved elsewhere
+{ NETF(fireflag), 2 },
+{ NETF(event), 10 },			// There is a maximum of 256 events (8 bits transmission, 2 high bits for uniqueness)
+// used mostly for players and npcs - appears to be static / never changing
+{ NETF(customRGBA[3]), 8 }, //0-255
+// used mostly for players and npcs - appears to be static / never changing
+{ NETF(customRGBA[0]), 8 }, //0-255
+// only used in fx system (which rick did) and chunks
+{ NETF(speed), 0 },
+// why are npc's clientnum's that big?
+{ NETF(clientNum), GENTITYNUM_BITS }, //with npc's clientnum can be > MAX_CLIENTS so use entnum bits now instead.
+{ NETF(apos.trBase[2]), 0 },
+{ NETF(apos.trTime), 32 },
+// used mostly for players and npcs - appears to be static / never changing
+{ NETF(customRGBA[1]), 8 }, //0-255
+// used mostly for players and npcs - appears to be static / never changing
+{ NETF(customRGBA[2]), 8 }, //0-255
+// multiple meanings
+{ NETF(saberEntityNum), GENTITYNUM_BITS },
+// could probably just eliminate and assume a big number
+{ NETF(g2radius), 8 },
+{ NETF(otherEntityNum2), GENTITYNUM_BITS },
+// used all over the place
+{ NETF(owner), GENTITYNUM_BITS },
+{ NETF(modelindex2), 8 },
+// why was this changed from 0 to 8 ?
+{ NETF(eventParm), 8 },
+// unknown about size?
+{ NETF(saberMove), 8 },
+{ NETF(apos.trDelta[1]), 0 },
+{ NETF(boneAngles1[1]), 0 },
+// why raised from 8 to -16?
+{ NETF(modelindex), -16 },
+// barely used, could probably be replaced
+{ NETF(emplacedOwner), 32 }, //As above, also used as a time value (for electricity render time)
+{ NETF(apos.trDelta[0]), 0 },
+{ NETF(apos.trDelta[2]), 0 },
+// shouldn't these be better off as flags?  otherwise, they may consume more bits this way
+{ NETF(torsoFlip), 1 },
+{ NETF(angles2[1]), 0 },
+// used mostly in saber and npc
+{ NETF(lookTarget), GENTITYNUM_BITS },
+{ NETF(origin2[2]), 0 },
+// randomly used, not sure why this was used instead of svc_noclient
+//	if (cent->currentState.modelGhoul2 == 127)
+//	{ //not ready to be drawn or initialized..
+//		return;
+//	}
+{ NETF(modelGhoul2), 8 },
+{ NETF(loopSound), 8 },
+{ NETF(origin2[0]), 0 },
+// multiple purpose bit flag
+{ NETF(shouldtarget), 1 },
+// widely used, does not appear that they have to be 16 bits
+{ NETF(trickedentindex), 16 }, //See note in PSF
+{ NETF(otherEntityNum), GENTITYNUM_BITS },
+{ NETF(origin2[1]), 0 },
+{ NETF(time2), 32 },
+{ NETF(legsFlip), 1 },
+// fully used
+{ NETF(bolt2), GENTITYNUM_BITS },
+{ NETF(constantLight), 32 },
+{ NETF(time), 32 },
+// why doesn't lookTarget just indicate this?
+{ NETF(hasLookTarget), 1 },
+{ NETF(boneAngles1[2]), 0 },
+// used for both force pass and an emplaced gun - gun is just a flag indicator
+{ NETF(activeForcePass), 6 },
+// used to indicate health
+{ NETF(health), 10 }, //if something's health exceeds 1024, then.. too bad!
+// appears to have multiple means, could be eliminated by indicating a sound set differently
+{ NETF(loopIsSoundset), 1 },
+{ NETF(saberHolstered), 2 },
+//NPC-SPECIFIC:
+// both are used for NPCs sabers, though limited
+{ NETF(npcSaber1), 9 },
+{ NETF(maxhealth), 10 },
+{ NETF(trickedentindex2), 16 },
+// appear to only be 18 powers?
+{ NETF(forcePowersActive), 32 },
+// used, doesn't appear to be flexible
+{ NETF(iModelScale), 10 }, //0-1024 (guess it's gotta be increased if we want larger allowable scale.. but 1024% is pretty big)
+// full bits used
+{ NETF(powerups), 16 },
+// can this be reduced?
+{ NETF(soundSetIndex), 8 }, //rww - if MAX_AMBIENT_SETS is changed from 256, REMEMBER TO CHANGE THIS
+// looks like this can be reduced to 4? (ship parts = 4, people parts = 2)
+{ NETF(brokenLimbs), 8 }, //up to 8 limbs at once (not that that many are used)
+{ NETF(csSounds_Std), 8 }, //soundindex must be 8 unless max sounds is changed
+// used extensively
+{ NETF(saberInFlight), 1 },
+{ NETF(angles2[0]), 0 },
+{ NETF(frame), 16 },
+{ NETF(angles2[2]), 0 },
+// why not use torsoAnim and set a flag to do the same thing as forceFrame (saberLockFrame)
+{ NETF(forceFrame), 16 }, //if you have over 65536 frames, then this will explode. Of course if you have that many things then lots of things will probably explode.
+{ NETF(generic1), 8 },
+// do we really need 4 indexes?
+{ NETF(boneIndex1), 6 }, //up to 64 bones can be accessed by this indexing method
+// only 54 classes, could cut down 2 bits
+{ NETF(NPC_class), 8 },
+{ NETF(apos.trDuration), 32 },
+// there appears to be only 2 different version of parms passed - a flag would better be suited
+{ NETF(boneOrient), 9 }, //3 bits per orientation dir
+// this looks to be a single bit flag
+{ NETF(bolt1), 8 },
+{ NETF(trickedentindex3), 16 },
+// in use for vehicles
+{ NETF(m_iVehicleNum), GENTITYNUM_BITS }, // 10 bits fits all possible entity nums (2^10 = 1024). - AReis
+{ NETF(trickedentindex4), 16 },
+// but why is there an opposite state of surfaces field?
+{ NETF(surfacesOff), 32 },
+{ NETF(eFlags2), 10 },
+// should be bit field
+{ NETF(isJediMaster), 1 },
+// should be bit field
+{ NETF(isPortalEnt), 1 },
+// possible multiple definitions
+{ NETF(heldByClient), 6 },
+// this does not appear to be used in any production or non-cheat fashion - REMOVE
+{ NETF(ragAttach), GENTITYNUM_BITS },
+// used only in one spot for seige
+{ NETF(boltToPlayer), 6 },
+{ NETF(npcSaber2), 9 },
+{ NETF(csSounds_Combat), 8 },
+{ NETF(csSounds_Extra), 8 },
+{ NETF(csSounds_Jedi), 8 },
+// used only for surfaces on NPCs
+{ NETF(surfacesOn), 32 }, //allow up to 32 surfaces in the bitflag
+{ NETF(boneIndex2), 6 },
+{ NETF(boneIndex3), 6 },
+{ NETF(boneIndex4), 6 },
+{ NETF(boneAngles1[0]), 0 },
+{ NETF(boneAngles2[0]), 0 },
+{ NETF(boneAngles2[1]), 0 },
+{ NETF(boneAngles2[2]), 0 },
+{ NETF(boneAngles3[0]), 0 },
+{ NETF(boneAngles3[1]), 0 },
+{ NETF(boneAngles3[2]), 0 },
+{ NETF(boneAngles4[0]), 0 },
+{ NETF(boneAngles4[1]), 0 },
+{ NETF(boneAngles4[2]), 0 },
+
+//rww - for use by mod authors only
+#ifndef _XBOX
+{ NETF(userInt1), 1 },
+{ NETF(userInt2), 1 },
+{ NETF(userInt3), 1 },
+{ NETF(userFloat1), 1 },
+{ NETF(userFloat2), 1 },
+{ NETF(userFloat3), 1 },
+{ NETF(userVec1[0]), 1 },
+{ NETF(userVec1[1]), 1 },
+{ NETF(userVec1[2]), 1 },
+{ NETF(userVec2[0]), 1 },
+{ NETF(userVec2[1]), 1 },
+{ NETF(userVec2[2]), 1 }
+#endif
+};
+
+// if (int)f == f and (int)f + ( 1<<(FLOAT_INT_BITS-1) ) < ( 1 << FLOAT_INT_BITS )
+// the float will be sent with FLOAT_INT_BITS, otherwise all 32 bits will be sent
+#define	FLOAT_INT_BITS	13
+#define	FLOAT_INT_BIAS	(1<<(FLOAT_INT_BITS-1))
+
+/*
+==================
+MSG_WriteDeltaEntity
+
+Writes part of a packetentities message, including the entity number.
+Can delta from either a baseline or a previous packet_entity
+If to is NULL, a remove entity update will be sent
+If force is not set, then nothing at all will be generated if the entity is
+identical, under the assumption that the in-order delta code will catch it.
+==================
+*/
+void MSG_WriteDeltaEntity( msg_t *msg, struct entityState_s *from, struct entityState_s *to, 
+						   qboolean force ) {
+	int			i, lc;
+	int			numFields;
+	netField_t	*field;
+	int			trunc;
+	float		fullFloat;
+	int			*fromF, *toF;
+
+	numFields = sizeof(entityStateFields)/sizeof(entityStateFields[0]);
+
+	// all fields should be 32 bits to avoid any compiler packing issues
+	// the "number" field is not part of the field list
+	// if this assert fails, someone added a field to the entityState_t
+	// struct without updating the message fields
+#ifndef _XBOX	// No longer true, although we should keep some kind of check.
+	assert( numFields + 1 == sizeof( *from )/4 );
+#endif
+
+	// a NULL to is a delta remove message
+	if ( to == NULL ) {
+		if ( from == NULL ) {
+			return;
+		}
+		MSG_WriteBits( msg, from->number, GENTITYNUM_BITS );
+		MSG_WriteBits( msg, 1, 1 );
+		return;
+	}
+
+	if ( to->number < 0 || to->number >= MAX_GENTITIES ) {
+		Com_Error (ERR_FATAL, "MSG_WriteDeltaEntity: Bad entity number: %i", to->number );
+	}
+
+	lc = 0;
+	// build the change vector as bytes so it is endien independent
+	// TODO: OPTIMIZE: How about we do this in reverse order so we can
+	// just break out at the first changed field we find?
+	for ( i = 0, field = entityStateFields ; i < numFields ; i++, field++ ) {
+		fromF = (int *)( (byte *)from + field->offset );
+		toF = (int *)( (byte *)to + field->offset );
+#ifdef _XBOX
+		if (((field->realSize == 4) && (*fromF != *toF)) ||
+			((field->realSize == 2) && (*(short *)fromF != *(short *)toF)) ||
+			((field->realSize == 1) && (*(char *)fromF != *(char *)toF)))
+		{
+			lc = i+1;
+		}
+#else
+		if ( *fromF != *toF ) {
+			lc = i+1;
+#ifndef FINAL_BUILD
+			field->mCount++;
+#endif
+		}
+#endif
+	}
+
+	if ( lc == 0 ) {
+		// nothing at all changed
+		if ( !force ) {
+			return;		// nothing at all
+		}
+		// write two bits for no change
+		MSG_WriteBits( msg, to->number, GENTITYNUM_BITS );
+		MSG_WriteBits( msg, 0, 1 );		// not removed
+		MSG_WriteBits( msg, 0, 1 );		// no delta
+		return;
+	}
+
+	MSG_WriteBits( msg, to->number, GENTITYNUM_BITS );
+	MSG_WriteBits( msg, 0, 1 );			// not removed
+	MSG_WriteBits( msg, 1, 1 );			// we have a delta
+
+	MSG_WriteByte( msg, lc );	// # of changes
+
+	oldsize += numFields;
+
+	for ( i = 0, field = entityStateFields ; i < lc ; i++, field++ ) {
+		fromF = (int *)( (byte *)from + field->offset );
+		toF = (int *)( (byte *)to + field->offset );
+
+#ifdef _XBOX
+		if (((field->realSize == 4) && (*fromF == *toF)) ||
+			((field->realSize == 2) && (*(short *)fromF == *(short *)toF)) ||
+			((field->realSize == 1) && (*(char *)fromF == *(char *)toF)))
+		{
+			MSG_WriteBits( msg, 0, 1 );	// no change
+			continue;
+		}
+#else
+		if ( *fromF == *toF ) {
+			MSG_WriteBits( msg, 0, 1 );	// no change
+			continue;
+		}
+#endif
+
+		MSG_WriteBits( msg, 1, 1 );	// changed
+
+		if ( field->bits == 0 ) {
+			// float
+			fullFloat = *(float *)toF;
+			trunc = (int)fullFloat;
+
+			if (fullFloat == 0.0f) {
+					MSG_WriteBits( msg, 0, 1 );
+					oldsize += FLOAT_INT_BITS;
+			} else {
+				MSG_WriteBits( msg, 1, 1 );
+				if ( trunc == fullFloat && trunc + FLOAT_INT_BIAS >= 0 && 
+					trunc + FLOAT_INT_BIAS < ( 1 << FLOAT_INT_BITS ) ) {
+					// send as small integer
+					MSG_WriteBits( msg, 0, 1 );
+					MSG_WriteBits( msg, trunc + FLOAT_INT_BIAS, FLOAT_INT_BITS );
+				} else {
+					// send as full floating point value
+					MSG_WriteBits( msg, 1, 1 );
+					MSG_WriteBits( msg, *toF, 32 );
+				}
+			}
+		} else {
+#ifdef _XBOX
+			if (((field->realSize == 4) && (*toF == 0)) ||
+				((field->realSize == 2) && (*(short *)toF == 0)) ||
+				((field->realSize == 1) && (*(char *)toF == 0))) {
+				MSG_WriteBits( msg, 0, 1 );
+			} else {
+				MSG_WriteBits( msg, 1, 1 );
+				// integer
+				MSG_WriteBits( msg,
+					(field->realSize == 4) ? *toF :
+					(field->realSize == 2) ? *(short *)toF : *(char *)toF,
+					field->bits );
+			}
+#else
+			if (*toF == 0) {
+				MSG_WriteBits( msg, 0, 1 );
+			} else {
+				MSG_WriteBits( msg, 1, 1 );
+				// integer
+				MSG_WriteBits( msg, *toF, field->bits );
+			}
+#endif
+		}
+	}
+}
+
+/*
+==================
+MSG_ReadDeltaEntity
+
+The entity number has already been read from the message, which
+is how the from state is identified.
+
+If the delta removes the entity, entityState_t->number will be set to MAX_GENTITIES-1
+
+Can go from either a baseline or a previous packet_entity
+==================
+*/
+
+void MSG_ReadDeltaEntity( msg_t *msg, entityState_t *from, entityState_t *to, 
+						 int number) {
+	int			i, lc;
+	int			numFields;
+	netField_t	*field;
+	int			*fromF, *toF;
+	int			print;
+	int			trunc;
+	int			startBit, endBit;
+
+	if ( number < 0 || number >= MAX_GENTITIES) {
+		Com_Error( ERR_DROP, "Bad delta entity number: %i", number );
+	}
+
+	startBit = msg->bit;
+
+	// check for a remove
+	if ( MSG_ReadBits( msg, 1 ) == 1 ) {
+		Com_Memset( to, 0, sizeof( *to ) );	
+		to->number = MAX_GENTITIES - 1;
+		if ( cl_shownet->integer >= 2 || cl_shownet->integer == -1 ) {
+			Com_Printf( "%3i: #%-3i remove\n", msg->readcount, number );
+		}
+		return;
+	}
+
+	// check for no delta
+	if ( MSG_ReadBits( msg, 1 ) == 0 ) {
+		*to = *from;
+		to->number = number;
+		return;
+	}
+
+	numFields = sizeof(entityStateFields)/sizeof(entityStateFields[0]);
+	lc = MSG_ReadByte(msg);
+
+	// shownet 2/3 will interleave with other printed info, -1 will
+	// just print the delta records`
+	if ( cl_shownet->integer >= 2 || cl_shownet->integer == -1 ) {
+		print = 1;
+		if (sv.state)
+		{
+			Com_Printf( "%3i: #%-3i (%s) ", msg->readcount, number, SV_GentityNum(number)->classname );
+		}
+		else
+		{
+			Com_Printf( "%3i: #%-3i ", msg->readcount, number );
+		}
+	} else {
+		print = 0;
+	}
+
+	to->number = number;
+
+#ifdef _DONETPROFILE_
+	int startBytes,endBytes;
+#endif
+
+	for ( i = 0, field = entityStateFields ; i < lc ; i++, field++ ) {
+		fromF = (int *)( (byte *)from + field->offset );
+		toF = (int *)( (byte *)to + field->offset );
+
+#ifdef _DONETPROFILE_
+		startBytes=msg->readcount;
+#endif
+		if ( ! MSG_ReadBits( msg, 1 ) ) {
+			// no change
+#ifdef _XBOX
+			if (field->realSize == 4)
+				*toF = *fromF;
+			else if (field->realSize == 2)
+				*(short *)toF = *(short *)fromF;
+			else
+				*(char *)toF = *(char *)fromF;
+#else
+			*toF = *fromF;
+#endif
+		} else {
+			if ( field->bits == 0 ) {
+				// float
+				if ( MSG_ReadBits( msg, 1 ) == 0 ) {
+						*(float *)toF = 0.0f; 
+				} else {
+					if ( MSG_ReadBits( msg, 1 ) == 0 ) {
+						// integral float
+						trunc = MSG_ReadBits( msg, FLOAT_INT_BITS );
+						// bias to allow equal parts positive and negative
+						trunc -= FLOAT_INT_BIAS;
+						*(float *)toF = trunc; 
+						if ( print ) {
+							Com_Printf( "%s:%i ", field->name, trunc );
+						}
+					} else {
+						// full floating point value
+						*toF = MSG_ReadBits( msg, 32 );
+						if ( print ) {
+							Com_Printf( "%s:%f ", field->name, *(float *)toF );
+						}
+					}
+				}
+			} else {
+				if ( MSG_ReadBits( msg, 1 ) == 0 ) {
+#ifdef _XBOX
+					if (field->realSize == 4)
+						*toF = 0;
+					else if (field->realSize == 2)
+						*(short *)toF = 0;
+					else
+						*(char *)toF = 0;
+#else
+					*toF = 0;
+#endif
+				} else {
+					// integer
+#ifdef _XBOX
+					if (field->realSize == 4)
+						*toF = MSG_ReadBits( msg, field->bits );
+					else if (field->realSize == 2)
+						*(short *)toF = MSG_ReadBits( msg, field->bits );
+					else
+						*(char *)toF = MSG_ReadBits( msg, field->bits );
+#else
+					*toF = MSG_ReadBits( msg, field->bits );
+#endif
+					if ( print ) {
+						Com_Printf( "%s:%i ", field->name, *toF );
+					}
+				}
+			}
+		}
+#ifdef _DONETPROFILE_
+		endBytes=msg->readcount;
+		ClReadProf().AddField(field->name,endBytes-startBytes);
+#endif
+	}
+	for ( i = lc, field = &entityStateFields[lc] ; i < numFields ; i++, field++ ) {
+		fromF = (int *)( (byte *)from + field->offset );
+		toF = (int *)( (byte *)to + field->offset );
+		// no change
+#ifdef _XBOX
+		if (field->realSize == 4)
+			*toF = *fromF;
+		else if (field->realSize == 2)
+			*(short *)toF = *(short *)fromF;
+		else
+			*(char *)toF = *(char *)fromF;
+#else
+		*toF = *fromF;
+#endif
+	}
+
+	if ( print ) {
+		endBit = msg->bit;
+		Com_Printf( " (%i bits)\n", endBit - startBit  );
+	}
+}
+
+/*
+============================================================================
+
+plyer_state_t communication
+
+============================================================================
+*/
+
+// using the stringizing operator to save typing...
+#ifdef _XBOX
+#define	PSF(x) #x,(int)&((playerState_t*)0)->x,sizeof(((playerState_t*)0)->x)
+#else
+#define	PSF(x) #x,(int)&((playerState_t*)0)->x
+#endif
+
+//rww - Remember to update ext_data/MP/psf_overrides.txt if you change any of this!
+//(for the sake of being consistent)
+
+//=====_OPTIMIZED_VEHICLE_NETWORKING=======================================================================
+#ifdef _OPTIMIZED_VEHICLE_NETWORKING
+//Instead of sending 2 full playerStates for the pilot and the vehicle, send a smaller,
+//specialized pilot playerState and vehicle playerState.  Also removes some vehicle
+//fields from the normal playerState -mcg
+//=====_OPTIMIZED_VEHICLE_NETWORKING=======================================================================
+
+netField_t	playerStateFields[] = 
+{
+{ PSF(commandTime), 32 },				
+{ PSF(origin[1]), 0 },
+{ PSF(origin[0]), 0 },
+{ PSF(viewangles[1]), 0 },
+{ PSF(viewangles[0]), 0 },
+{ PSF(origin[2]), 0 },
+{ PSF(velocity[0]), 0 },
+{ PSF(velocity[1]), 0 },
+{ PSF(velocity[2]), 0 },
+{ PSF(bobCycle), 8 },
+{ PSF(weaponTime), -16 },
+{ PSF(delta_angles[1]), 16 },
+{ PSF(speed), 0 }, //sadly, the vehicles require negative speed values, so..
+{ PSF(legsAnim), 16 },			// Maximum number of animation sequences is 2048.  Top bit is reserved for the togglebit
+{ PSF(delta_angles[0]), 16 },
+{ PSF(torsoAnim), 16 },			// Maximum number of animation sequences is 2048.  Top bit is reserved for the togglebit
+{ PSF(groundEntityNum), GENTITYNUM_BITS },
+{ PSF(eFlags), 32 },
+{ PSF(fd.forcePower), 8 },
+{ PSF(eventSequence), 16 },
+{ PSF(torsoTimer), 16 },
+{ PSF(legsTimer), 16 },
+{ PSF(viewheight), -8 },
+{ PSF(fd.saberAnimLevel), 4 },
+{ PSF(rocketLockIndex), GENTITYNUM_BITS },
+{ PSF(fd.saberDrawAnimLevel), 4 },
+{ PSF(genericEnemyIndex), 32 }, //NOTE: This isn't just an index all the time, it's often used as a time value, and thus needs 32 bits
+{ PSF(events[0]), 10 },			// There is a maximum of 256 events (8 bits transmission, 2 high bits for uniqueness)
+{ PSF(events[1]), 10 },			// There is a maximum of 256 events (8 bits transmission, 2 high bits for uniqueness)
+{ PSF(customRGBA[0]), 8 }, //0-255
+{ PSF(movementDir), 4 },
+{ PSF(saberEntityNum), GENTITYNUM_BITS }, //Also used for channel tracker storage, but should never exceed entity number
+{ PSF(customRGBA[3]), 8 }, //0-255
+{ PSF(weaponstate), 4 },
+{ PSF(saberMove), 32 }, //This value sometimes exceeds the max LS_ value and gets set to a crazy amount, so it needs 32 bits
+{ PSF(standheight), 10 },
+{ PSF(crouchheight), 10 },
+{ PSF(basespeed), -16 },
+{ PSF(pm_flags), 16 },
+{ PSF(jetpackFuel), 8 },
+{ PSF(cloakFuel), 8 },
+{ PSF(pm_time), -16 },
+{ PSF(customRGBA[1]), 8 }, //0-255
+{ PSF(clientNum), GENTITYNUM_BITS },
+{ PSF(duelIndex), GENTITYNUM_BITS },
+{ PSF(customRGBA[2]), 8 }, //0-255
+{ PSF(gravity), 16 },
+{ PSF(weapon), 8 },
+{ PSF(delta_angles[2]), 16 },
+{ PSF(saberCanThrow), 1 },
+{ PSF(viewangles[2]), 0 },
+{ PSF(fd.forcePowersKnown), 32 },
+{ PSF(fd.forcePowerLevel[FP_LEVITATION]), 2 }, //unfortunately we need this for fall damage calculation (client needs to know the distance for the fall noise)
+{ PSF(fd.forcePowerDebounce[FP_LEVITATION]), 32 },
+{ PSF(fd.forcePowerSelected), 8 },
+{ PSF(torsoFlip), 1 },
+{ PSF(externalEvent), 10 },
+{ PSF(damageYaw), 8 },
+{ PSF(damageCount), 8 },
+{ PSF(inAirAnim), 1 }, //just transmit it for the sake of knowing right when on the client to play a land anim, it's only 1 bit
+{ PSF(eventParms[1]), 8 },
+{ PSF(fd.forceSide), 2 }, //so we know if we should apply greyed out shaders to dark/light force enlightenment
+{ PSF(saberAttackChainCount), 4 },
+{ PSF(pm_type), 8 },					
+{ PSF(externalEventParm), 8 },
+{ PSF(eventParms[0]), -16 },
+{ PSF(lookTarget), GENTITYNUM_BITS },
+//{ PSF(vehOrientation[0]), 0 },
+{ PSF(weaponChargeSubtractTime), 32 }, //? really need 32 bits??
+//{ PSF(vehOrientation[1]), 0 },
+//{ PSF(moveDir[1]), 0 },
+//{ PSF(moveDir[0]), 0 },
+{ PSF(weaponChargeTime), 32 }, //? really need 32 bits??
+//{ PSF(vehOrientation[2]), 0 },
+{ PSF(legsFlip), 1 },
+{ PSF(damageEvent), 8 },
+//{ PSF(moveDir[2]), 0 },
+{ PSF(rocketTargetTime), 32 },
+{ PSF(activeForcePass), 6 },
+{ PSF(electrifyTime), 32 },
+{ PSF(fd.forceJumpZStart), 0 },
+{ PSF(loopSound), 16 }, //rwwFIXMEFIXME: max sounds is 256, doesn't this only need to be 8?
+{ PSF(hasLookTarget), 1 },
+{ PSF(saberBlocked), 8 },
+{ PSF(damageType), 2 },
+{ PSF(rocketLockTime), 32 },
+{ PSF(forceHandExtend), 8 },
+{ PSF(saberHolstered), 2 },
+{ PSF(fd.forcePowersActive), 32 },
+{ PSF(damagePitch), 8 },
+{ PSF(m_iVehicleNum), GENTITYNUM_BITS }, // 10 bits fits all possible entity nums (2^10 = 1024). - AReis
+//{ PSF(vehTurnaroundTime), 32 },//only used by vehicle?
+{ PSF(generic1), 8 },
+{ PSF(jumppad_ent), 10 },
+{ PSF(hasDetPackPlanted), 1 },
+{ PSF(saberInFlight), 1 },
+{ PSF(forceDodgeAnim), 16 },
+{ PSF(zoomMode), 2 }, // NOTENOTE Are all of these necessary?
+{ PSF(hackingTime), 32 },
+{ PSF(zoomTime), 32 },	// NOTENOTE Are all of these necessary?
+{ PSF(brokenLimbs), 8 }, //up to 8 limbs at once (not that that many are used)
+{ PSF(zoomLocked), 1 },	// NOTENOTE Are all of these necessary?
+{ PSF(zoomFov), 0 },	// NOTENOTE Are all of these necessary?
+{ PSF(fd.forceRageRecoveryTime), 32 },
+{ PSF(fallingToDeath), 32 },
+{ PSF(fd.forceMindtrickTargetIndex), 16 }, //NOTE: Not just an index, used as a (1 << val) bitflag for up to 16 clients
+{ PSF(fd.forceMindtrickTargetIndex2), 16 }, //NOTE: Not just an index, used as a (1 << val) bitflag for up to 16 clients
+//{ PSF(vehWeaponsLinked), 1 },//only used by vehicle?
+{ PSF(lastHitLoc[2]), 0 },
+//{ PSF(hyperSpaceTime), 32 },//only used by vehicle?
+{ PSF(fd.forceMindtrickTargetIndex3), 16 }, //NOTE: Not just an index, used as a (1 << val) bitflag for up to 16 clients
+{ PSF(lastHitLoc[0]), 0 },
+{ PSF(eFlags2), 10 },
+{ PSF(fd.forceMindtrickTargetIndex4), 16 }, //NOTE: Not just an index, used as a (1 << val) bitflag for up to 16 clients
+//{ PSF(hyperSpaceAngles[1]), 0 },//only used by vehicle?
+{ PSF(lastHitLoc[1]), 0 }, //currently only used so client knows to orient disruptor disintegration.. seems a bit much for just that though.
+//{ PSF(vehBoarding), 1 }, //only used by vehicle? not like the normal boarding value, this is a simple "1 or 0" value
+{ PSF(fd.sentryDeployed), 1 },
+{ PSF(saberLockTime), 32 },
+{ PSF(saberLockFrame), 16 },
+//{ PSF(vehTurnaroundIndex), GENTITYNUM_BITS },//only used by vehicle?
+//{ PSF(vehSurfaces), 16 }, //only used by vehicle? allow up to 16 surfaces in the flag I guess
+{ PSF(fd.forcePowerLevel[FP_SEE]), 2 }, //needed for knowing when to display players through walls
+{ PSF(saberLockEnemy), GENTITYNUM_BITS },
+{ PSF(fd.forceGripCripple), 1 }, //should only be 0 or 1 ever
+{ PSF(emplacedIndex), GENTITYNUM_BITS },
+{ PSF(holocronBits), 32 },
+{ PSF(isJediMaster), 1 },
+{ PSF(forceRestricted), 1 },
+{ PSF(trueJedi), 1 },
+{ PSF(trueNonJedi), 1 },
+{ PSF(duelTime), 32 },
+{ PSF(duelInProgress), 1 },
+{ PSF(saberLockAdvance), 1 },
+{ PSF(heldByClient), 6 },
+{ PSF(ragAttach), GENTITYNUM_BITS },
+{ PSF(iModelScale), 10 }, //0-1024 (guess it's gotta be increased if we want larger allowable scale.. but 1024% is pretty big)
+{ PSF(hackingBaseTime), 16 }, //up to 65536ms, over 10 seconds would just be silly anyway
+//{ PSF(hyperSpaceAngles[0]), 0 },//only used by vehicle?
+//{ PSF(hyperSpaceAngles[2]), 0 },//only used by vehicle?
+
+//rww - for use by mod authors only
+#ifndef _XBOX
+{ PSF(userInt1), 1 },
+{ PSF(userInt2), 1 },
+{ PSF(userInt3), 1 },
+{ PSF(userFloat1), 1 },
+{ PSF(userFloat2), 1 },
+{ PSF(userFloat3), 1 },
+{ PSF(userVec1[0]), 1 },
+{ PSF(userVec1[1]), 1 },
+{ PSF(userVec1[2]), 1 },
+{ PSF(userVec2[0]), 1 },
+{ PSF(userVec2[1]), 1 },
+{ PSF(userVec2[2]), 1 }
+#endif
+};
+
+netField_t	pilotPlayerStateFields[] = 
+{
+{ PSF(commandTime), 32 },				
+{ PSF(origin[1]), 0 },
+{ PSF(origin[0]), 0 },
+{ PSF(viewangles[1]), 0 },
+{ PSF(viewangles[0]), 0 },
+{ PSF(origin[2]), 0 },
+{ PSF(weaponTime), -16 },
+{ PSF(delta_angles[1]), 16 },
+{ PSF(delta_angles[0]), 16 },
+{ PSF(eFlags), 32 },
+{ PSF(eventSequence), 16 },
+{ PSF(rocketLockIndex), GENTITYNUM_BITS },
+{ PSF(events[0]), 10 },			// There is a maximum of 256 events (8 bits transmission, 2 high bits for uniqueness)
+{ PSF(events[1]), 10 },			// There is a maximum of 256 events (8 bits transmission, 2 high bits for uniqueness)
+{ PSF(weaponstate), 4 },
+{ PSF(pm_flags), 16 },
+{ PSF(pm_time), -16 },
+{ PSF(clientNum), GENTITYNUM_BITS },
+{ PSF(weapon), 8 },
+{ PSF(delta_angles[2]), 16 },
+{ PSF(viewangles[2]), 0 },
+{ PSF(externalEvent), 10 },
+{ PSF(eventParms[1]), 8 },
+{ PSF(pm_type), 8 },					
+{ PSF(externalEventParm), 8 },
+{ PSF(eventParms[0]), -16 },
+{ PSF(weaponChargeSubtractTime), 32 }, //? really need 32 bits??
+{ PSF(weaponChargeTime), 32 }, //? really need 32 bits??
+{ PSF(rocketTargetTime), 32 },
+{ PSF(fd.forceJumpZStart), 0 },
+{ PSF(rocketLockTime), 32 },
+{ PSF(m_iVehicleNum), GENTITYNUM_BITS }, // 10 bits fits all possible entity nums (2^10 = 1024). - AReis
+{ PSF(generic1), 8 },//used by passengers
+{ PSF(eFlags2), 10 },
+
+//===THESE SHOULD NOT BE CHANGING OFTEN====================================================================
+{ PSF(legsAnim), 16 },			// Maximum number of animation sequences is 2048.  Top bit is reserved for the togglebit
+{ PSF(torsoAnim), 16 },			// Maximum number of animation sequences is 2048.  Top bit is reserved for the togglebit
+{ PSF(torsoTimer), 16 },
+{ PSF(legsTimer), 16 },
+{ PSF(jetpackFuel), 8 },
+{ PSF(cloakFuel), 8 },
+{ PSF(saberCanThrow), 1 },
+{ PSF(fd.forcePowerDebounce[FP_LEVITATION]), 32 },
+{ PSF(torsoFlip), 1 },
+{ PSF(legsFlip), 1 },
+{ PSF(fd.forcePowersActive), 32 },
+{ PSF(hasDetPackPlanted), 1 },
+{ PSF(fd.forceRageRecoveryTime), 32 },
+{ PSF(saberInFlight), 1 },
+{ PSF(fd.forceMindtrickTargetIndex), 16 }, //NOTE: Not just an index, used as a (1 << val) bitflag for up to 16 clients
+{ PSF(fd.forceMindtrickTargetIndex2), 16 }, //NOTE: Not just an index, used as a (1 << val) bitflag for up to 16 clients
+{ PSF(fd.forceMindtrickTargetIndex3), 16 }, //NOTE: Not just an index, used as a (1 << val) bitflag for up to 16 clients
+{ PSF(fd.forceMindtrickTargetIndex4), 16 }, //NOTE: Not just an index, used as a (1 << val) bitflag for up to 16 clients
+{ PSF(fd.sentryDeployed), 1 },
+{ PSF(fd.forcePowerLevel[FP_SEE]), 2 }, //needed for knowing when to display players through walls
+{ PSF(holocronBits), 32 },
+{ PSF(fd.forcePower), 8 },
+
+//===THE REST OF THESE SHOULD NOT BE RELEVANT, BUT, FOR SAFETY, INCLUDE THEM ANYWAY, JUST AT THE BOTTOM===============================================================
+{ PSF(velocity[0]), 0 },
+{ PSF(velocity[1]), 0 },
+{ PSF(velocity[2]), 0 },
+{ PSF(bobCycle), 8 },
+{ PSF(speed), 0 }, //sadly, the vehicles require negative speed values, so..
+{ PSF(groundEntityNum), GENTITYNUM_BITS },
+{ PSF(viewheight), -8 },
+{ PSF(fd.saberAnimLevel), 4 },
+{ PSF(fd.saberDrawAnimLevel), 4 },
+{ PSF(genericEnemyIndex), 32 }, //NOTE: This isn't just an index all the time, it's often used as a time value, and thus needs 32 bits
+{ PSF(customRGBA[0]), 8 }, //0-255
+{ PSF(movementDir), 4 },
+{ PSF(saberEntityNum), GENTITYNUM_BITS }, //Also used for channel tracker storage, but should never exceed entity number
+{ PSF(customRGBA[3]), 8 }, //0-255
+{ PSF(saberMove), 32 }, //This value sometimes exceeds the max LS_ value and gets set to a crazy amount, so it needs 32 bits
+{ PSF(standheight), 10 },
+{ PSF(crouchheight), 10 },
+{ PSF(basespeed), -16 },
+{ PSF(customRGBA[1]), 8 }, //0-255
+{ PSF(duelIndex), GENTITYNUM_BITS },
+{ PSF(customRGBA[2]), 8 }, //0-255
+{ PSF(gravity), 16 },
+{ PSF(fd.forcePowersKnown), 32 },
+{ PSF(fd.forcePowerLevel[FP_LEVITATION]), 2 }, //unfortunately we need this for fall damage calculation (client needs to know the distance for the fall noise)
+{ PSF(fd.forcePowerSelected), 8 },
+{ PSF(damageYaw), 8 },
+{ PSF(damageCount), 8 },
+{ PSF(inAirAnim), 1 }, //just transmit it for the sake of knowing right when on the client to play a land anim, it's only 1 bit
+{ PSF(fd.forceSide), 2 }, //so we know if we should apply greyed out shaders to dark/light force enlightenment
+{ PSF(saberAttackChainCount), 4 },
+{ PSF(lookTarget), GENTITYNUM_BITS },
+{ PSF(moveDir[1]), 0 },
+{ PSF(moveDir[0]), 0 },
+{ PSF(damageEvent), 8 },
+{ PSF(moveDir[2]), 0 },
+{ PSF(activeForcePass), 6 },
+{ PSF(electrifyTime), 32 },
+{ PSF(damageType), 2 },
+{ PSF(loopSound), 16 }, //rwwFIXMEFIXME: max sounds is 256, doesn't this only need to be 8?
+{ PSF(hasLookTarget), 1 },
+{ PSF(saberBlocked), 8 },
+{ PSF(forceHandExtend), 8 },
+{ PSF(saberHolstered), 2 },
+{ PSF(damagePitch), 8 },
+{ PSF(jumppad_ent), 10 },
+{ PSF(forceDodgeAnim), 16 },
+{ PSF(zoomMode), 2 }, // NOTENOTE Are all of these necessary?
+{ PSF(hackingTime), 32 },
+{ PSF(zoomTime), 32 },	// NOTENOTE Are all of these necessary?
+{ PSF(brokenLimbs), 8 }, //up to 8 limbs at once (not that that many are used)
+{ PSF(zoomLocked), 1 },	// NOTENOTE Are all of these necessary?
+{ PSF(zoomFov), 0 },	// NOTENOTE Are all of these necessary?
+{ PSF(fallingToDeath), 32 },
+{ PSF(lastHitLoc[2]), 0 },
+{ PSF(lastHitLoc[0]), 0 },
+{ PSF(lastHitLoc[1]), 0 }, //currently only used so client knows to orient disruptor disintegration.. seems a bit much for just that though.
+{ PSF(saberLockTime), 32 },
+{ PSF(saberLockFrame), 16 },
+{ PSF(saberLockEnemy), GENTITYNUM_BITS },
+{ PSF(fd.forceGripCripple), 1 }, //should only be 0 or 1 ever
+{ PSF(emplacedIndex), GENTITYNUM_BITS },
+{ PSF(isJediMaster), 1 },
+{ PSF(forceRestricted), 1 },
+{ PSF(trueJedi), 1 },
+{ PSF(trueNonJedi), 1 },
+{ PSF(duelTime), 32 },
+{ PSF(duelInProgress), 1 },
+{ PSF(saberLockAdvance), 1 },
+{ PSF(heldByClient), 6 },
+{ PSF(ragAttach), GENTITYNUM_BITS },
+{ PSF(iModelScale), 10 }, //0-1024 (guess it's gotta be increased if we want larger allowable scale.. but 1024% is pretty big)
+{ PSF(hackingBaseTime), 16 }, //up to 65536ms, over 10 seconds would just be silly anyway
+//===NEVER SEND THESE, ONLY USED BY VEHICLES==============================================================
+
+//{ PSF(vehOrientation[0]), 0 },
+//{ PSF(vehOrientation[1]), 0 },
+//{ PSF(vehOrientation[2]), 0 },
+//{ PSF(vehTurnaroundTime), 32 },//only used by vehicle?
+//{ PSF(vehWeaponsLinked), 1 },//only used by vehicle?
+//{ PSF(hyperSpaceTime), 32 },//only used by vehicle?
+//{ PSF(vehTurnaroundIndex), GENTITYNUM_BITS },//only used by vehicle?
+//{ PSF(vehSurfaces), 16 }, //only used by vehicle? allow up to 16 surfaces in the flag I guess
+//{ PSF(vehBoarding), 1 }, //only used by vehicle? not like the normal boarding value, this is a simple "1 or 0" value
+//{ PSF(hyperSpaceAngles[1]), 0 },//only used by vehicle?
+//{ PSF(hyperSpaceAngles[0]), 0 },//only used by vehicle?
+//{ PSF(hyperSpaceAngles[2]), 0 },//only used by vehicle?
+
+//rww - for use by mod authors only
+#ifndef _XBOX
+{ PSF(userInt1), 1 },
+{ PSF(userInt2), 1 },
+{ PSF(userInt3), 1 },
+{ PSF(userFloat1), 1 },
+{ PSF(userFloat2), 1 },
+{ PSF(userFloat3), 1 },
+{ PSF(userVec1[0]), 1 },
+{ PSF(userVec1[1]), 1 },
+{ PSF(userVec1[2]), 1 },
+{ PSF(userVec2[0]), 1 },
+{ PSF(userVec2[1]), 1 },
+{ PSF(userVec2[2]), 1 }
+#endif
+};
+
+netField_t	vehPlayerStateFields[] = 
+{
+{ PSF(commandTime), 32 },				
+{ PSF(origin[1]), 0 },
+{ PSF(origin[0]), 0 },
+{ PSF(viewangles[1]), 0 },
+{ PSF(viewangles[0]), 0 },
+{ PSF(origin[2]), 0 },
+{ PSF(velocity[0]), 0 },
+{ PSF(velocity[1]), 0 },
+{ PSF(velocity[2]), 0 },
+{ PSF(weaponTime), -16 },
+{ PSF(delta_angles[1]), 16 },
+{ PSF(speed), 0 }, //sadly, the vehicles require negative speed values, so..
+{ PSF(legsAnim), 16 },			// Maximum number of animation sequences is 2048.  Top bit is reserved for the togglebit
+{ PSF(delta_angles[0]), 16 },
+{ PSF(groundEntityNum), GENTITYNUM_BITS },
+{ PSF(eFlags), 32 },
+{ PSF(eventSequence), 16 },
+{ PSF(legsTimer), 16 },
+{ PSF(rocketLockIndex), GENTITYNUM_BITS },
+//{ PSF(genericEnemyIndex), 32 }, //NOTE: This isn't just an index all the time, it's often used as a time value, and thus needs 32 bits
+{ PSF(events[0]), 10 },			// There is a maximum of 256 events (8 bits transmission, 2 high bits for uniqueness)
+{ PSF(events[1]), 10 },			// There is a maximum of 256 events (8 bits transmission, 2 high bits for uniqueness)
+//{ PSF(customRGBA[0]), 8 }, //0-255
+//{ PSF(movementDir), 4 },
+//{ PSF(customRGBA[3]), 8 }, //0-255
+{ PSF(weaponstate), 4 },
+//{ PSF(basespeed), -16 },
+{ PSF(pm_flags), 16 },
+{ PSF(pm_time), -16 },
+//{ PSF(customRGBA[1]), 8 }, //0-255
+{ PSF(clientNum), GENTITYNUM_BITS },
+//{ PSF(duelIndex), GENTITYNUM_BITS },
+//{ PSF(customRGBA[2]), 8 }, //0-255
+{ PSF(gravity), 16 },
+{ PSF(weapon), 8 },
+{ PSF(delta_angles[2]), 16 },
+{ PSF(viewangles[2]), 0 },
+{ PSF(externalEvent), 10 },
+{ PSF(eventParms[1]), 8 },
+{ PSF(pm_type), 8 },					
+{ PSF(externalEventParm), 8 },
+{ PSF(eventParms[0]), -16 },
+{ PSF(vehOrientation[0]), 0 },
+{ PSF(vehOrientation[1]), 0 },
+{ PSF(moveDir[1]), 0 },
+{ PSF(moveDir[0]), 0 },
+{ PSF(vehOrientation[2]), 0 },
+{ PSF(moveDir[2]), 0 },
+{ PSF(rocketTargetTime), 32 },
+//{ PSF(activeForcePass), 6 },//actually, you only need to know this for other vehicles, not your own
+{ PSF(electrifyTime), 32 },
+//{ PSF(fd.forceJumpZStart), 0 },//set on rider by vehicle, but not used by vehicle
+{ PSF(loopSound), 16 }, //rwwFIXMEFIXME: max sounds is 256, doesn't this only need to be 8?
+{ PSF(rocketLockTime), 32 },
+{ PSF(m_iVehicleNum), GENTITYNUM_BITS }, // 10 bits fits all possible entity nums (2^10 = 1024). - AReis
+{ PSF(vehTurnaroundTime), 32 },
+//{ PSF(generic1), 8 },//used by passengers of vehicles, but not vehicles themselves
+{ PSF(hackingTime), 32 },
+{ PSF(brokenLimbs), 8 }, //up to 8 limbs at once (not that that many are used)
+{ PSF(vehWeaponsLinked), 1 },
+{ PSF(hyperSpaceTime), 32 },
+{ PSF(eFlags2), 10 },
+{ PSF(hyperSpaceAngles[1]), 0 },
+{ PSF(vehBoarding), 1 }, //not like the normal boarding value, this is a simple "1 or 0" value
+{ PSF(vehTurnaroundIndex), GENTITYNUM_BITS },
+{ PSF(vehSurfaces), 16 }, //allow up to 16 surfaces in the flag I guess
+{ PSF(hyperSpaceAngles[0]), 0 },
+{ PSF(hyperSpaceAngles[2]), 0 },
+
+//rww - for use by mod authors only
+#ifndef _XBOX
+{ PSF(userInt1), 1 },
+{ PSF(userInt2), 1 },
+{ PSF(userInt3), 1 },
+{ PSF(userFloat1), 1 },
+{ PSF(userFloat2), 1 },
+{ PSF(userFloat3), 1 },
+{ PSF(userVec1[0]), 1 },
+{ PSF(userVec1[1]), 1 },
+{ PSF(userVec1[2]), 1 },
+{ PSF(userVec2[0]), 1 },
+{ PSF(userVec2[1]), 1 },
+{ PSF(userVec2[2]), 1 }
+#endif
+};
+
+//=====_OPTIMIZED_VEHICLE_NETWORKING=======================================================================
+#else//_OPTIMIZED_VEHICLE_NETWORKING
+//The unoptimized way, throw *all* the vehicle stuff into the playerState along with everything else... :(
+//=====_OPTIMIZED_VEHICLE_NETWORKING=======================================================================
+
+netField_t	playerStateFields[] = 
+{
+{ PSF(commandTime), 32 },				
+{ PSF(origin[1]), 0 },
+{ PSF(origin[0]), 0 },
+{ PSF(viewangles[1]), 0 },
+{ PSF(viewangles[0]), 0 },
+{ PSF(origin[2]), 0 },
+{ PSF(velocity[0]), 0 },
+{ PSF(velocity[1]), 0 },
+{ PSF(velocity[2]), 0 },
+{ PSF(bobCycle), 8 },
+{ PSF(weaponTime), -16 },
+{ PSF(delta_angles[1]), 16 },
+{ PSF(speed), 0 }, //sadly, the vehicles require negative speed values, so..
+{ PSF(legsAnim), 16 },			// Maximum number of animation sequences is 2048.  Top bit is reserved for the togglebit
+{ PSF(delta_angles[0]), 16 },
+{ PSF(torsoAnim), 16 },			// Maximum number of animation sequences is 2048.  Top bit is reserved for the togglebit
+{ PSF(groundEntityNum), GENTITYNUM_BITS },
+{ PSF(eFlags), 32 },
+{ PSF(fd.forcePower), 8 },
+{ PSF(eventSequence), 16 },
+{ PSF(torsoTimer), 16 },
+{ PSF(legsTimer), 16 },
+{ PSF(viewheight), -8 },
+{ PSF(fd.saberAnimLevel), 4 },
+{ PSF(rocketLockIndex), GENTITYNUM_BITS },
+{ PSF(fd.saberDrawAnimLevel), 4 },
+{ PSF(genericEnemyIndex), 32 }, //NOTE: This isn't just an index all the time, it's often used as a time value, and thus needs 32 bits
+{ PSF(events[0]), 10 },			// There is a maximum of 256 events (8 bits transmission, 2 high bits for uniqueness)
+{ PSF(events[1]), 10 },			// There is a maximum of 256 events (8 bits transmission, 2 high bits for uniqueness)
+{ PSF(customRGBA[0]), 8 }, //0-255
+{ PSF(movementDir), 4 },
+{ PSF(saberEntityNum), GENTITYNUM_BITS }, //Also used for channel tracker storage, but should never exceed entity number
+{ PSF(customRGBA[3]), 8 }, //0-255
+{ PSF(weaponstate), 4 },
+{ PSF(saberMove), 32 }, //This value sometimes exceeds the max LS_ value and gets set to a crazy amount, so it needs 32 bits
+{ PSF(standheight), 10 },
+{ PSF(crouchheight), 10 },
+{ PSF(basespeed), -16 },
+{ PSF(pm_flags), 16 },
+{ PSF(jetpackFuel), 8 },
+{ PSF(cloakFuel), 8 },
+{ PSF(pm_time), -16 },
+{ PSF(customRGBA[1]), 8 }, //0-255
+{ PSF(clientNum), GENTITYNUM_BITS },
+{ PSF(duelIndex), GENTITYNUM_BITS },
+{ PSF(customRGBA[2]), 8 }, //0-255
+{ PSF(gravity), 16 },
+{ PSF(weapon), 8 },
+{ PSF(delta_angles[2]), 16 },
+{ PSF(saberCanThrow), 1 },
+{ PSF(viewangles[2]), 0 },
+{ PSF(fd.forcePowersKnown), 32 },
+{ PSF(fd.forcePowerLevel[FP_LEVITATION]), 2 }, //unfortunately we need this for fall damage calculation (client needs to know the distance for the fall noise)
+{ PSF(fd.forcePowerDebounce[FP_LEVITATION]), 32 },
+{ PSF(fd.forcePowerSelected), 8 },
+{ PSF(torsoFlip), 1 },
+{ PSF(externalEvent), 10 },
+{ PSF(damageYaw), 8 },
+{ PSF(damageCount), 8 },
+{ PSF(inAirAnim), 1 }, //just transmit it for the sake of knowing right when on the client to play a land anim, it's only 1 bit
+{ PSF(eventParms[1]), 8 },
+{ PSF(fd.forceSide), 2 }, //so we know if we should apply greyed out shaders to dark/light force enlightenment
+{ PSF(saberAttackChainCount), 4 },
+{ PSF(pm_type), 8 },					
+{ PSF(externalEventParm), 8 },
+{ PSF(eventParms[0]), -16 },
+{ PSF(lookTarget), GENTITYNUM_BITS },
+{ PSF(vehOrientation[0]), 0 },
+{ PSF(weaponChargeSubtractTime), 32 }, //? really need 32 bits??
+{ PSF(vehOrientation[1]), 0 },
+{ PSF(moveDir[1]), 0 },
+{ PSF(moveDir[0]), 0 },
+{ PSF(weaponChargeTime), 32 }, //? really need 32 bits??
+{ PSF(vehOrientation[2]), 0 },
+{ PSF(legsFlip), 1 },
+{ PSF(damageEvent), 8 },
+{ PSF(moveDir[2]), 0 },
+{ PSF(rocketTargetTime), 32 },
+{ PSF(activeForcePass), 6 },
+{ PSF(electrifyTime), 32 },
+{ PSF(fd.forceJumpZStart), 0 },
+{ PSF(loopSound), 16 }, //rwwFIXMEFIXME: max sounds is 256, doesn't this only need to be 8?
+{ PSF(hasLookTarget), 1 },
+{ PSF(saberBlocked), 8 },
+{ PSF(damageType), 2 },
+{ PSF(rocketLockTime), 32 },
+{ PSF(forceHandExtend), 8 },
+{ PSF(saberHolstered), 2 },
+{ PSF(fd.forcePowersActive), 32 },
+{ PSF(damagePitch), 8 },
+{ PSF(m_iVehicleNum), GENTITYNUM_BITS }, // 10 bits fits all possible entity nums (2^10 = 1024). - AReis
+{ PSF(vehTurnaroundTime), 32 },
+{ PSF(generic1), 8 },
+{ PSF(jumppad_ent), 10 },
+{ PSF(hasDetPackPlanted), 1 },
+{ PSF(saberInFlight), 1 },
+{ PSF(forceDodgeAnim), 16 },
+{ PSF(zoomMode), 2 }, // NOTENOTE Are all of these necessary?
+{ PSF(hackingTime), 32 },
+{ PSF(zoomTime), 32 },	// NOTENOTE Are all of these necessary?
+{ PSF(brokenLimbs), 8 }, //up to 8 limbs at once (not that that many are used)
+{ PSF(zoomLocked), 1 },	// NOTENOTE Are all of these necessary?
+{ PSF(zoomFov), 0 },	// NOTENOTE Are all of these necessary?
+{ PSF(fd.forceRageRecoveryTime), 32 },
+{ PSF(fallingToDeath), 32 },
+{ PSF(fd.forceMindtrickTargetIndex), 16 }, //NOTE: Not just an index, used as a (1 << val) bitflag for up to 16 clients
+{ PSF(fd.forceMindtrickTargetIndex2), 16 }, //NOTE: Not just an index, used as a (1 << val) bitflag for up to 16 clients
+{ PSF(vehWeaponsLinked), 1 },
+{ PSF(lastHitLoc[2]), 0 },
+{ PSF(hyperSpaceTime), 32 },
+{ PSF(fd.forceMindtrickTargetIndex3), 16 }, //NOTE: Not just an index, used as a (1 << val) bitflag for up to 16 clients
+{ PSF(lastHitLoc[0]), 0 },
+{ PSF(eFlags2), 10 },
+{ PSF(fd.forceMindtrickTargetIndex4), 16 }, //NOTE: Not just an index, used as a (1 << val) bitflag for up to 16 clients
+{ PSF(hyperSpaceAngles[1]), 0 },
+{ PSF(lastHitLoc[1]), 0 }, //currently only used so client knows to orient disruptor disintegration.. seems a bit much for just that though.
+{ PSF(vehBoarding), 1 }, //not like the normal boarding value, this is a simple "1 or 0" value
+{ PSF(fd.sentryDeployed), 1 },
+{ PSF(saberLockTime), 32 },
+{ PSF(saberLockFrame), 16 },
+{ PSF(vehTurnaroundIndex), GENTITYNUM_BITS },
+{ PSF(vehSurfaces), 16 }, //allow up to 16 surfaces in the flag I guess
+{ PSF(fd.forcePowerLevel[FP_SEE]), 2 }, //needed for knowing when to display players through walls
+{ PSF(saberLockEnemy), GENTITYNUM_BITS },
+{ PSF(fd.forceGripCripple), 1 }, //should only be 0 or 1 ever
+{ PSF(emplacedIndex), GENTITYNUM_BITS },
+{ PSF(holocronBits), 32 },
+{ PSF(isJediMaster), 1 },
+{ PSF(forceRestricted), 1 },
+{ PSF(trueJedi), 1 },
+{ PSF(trueNonJedi), 1 },
+{ PSF(duelTime), 32 },
+{ PSF(duelInProgress), 1 },
+{ PSF(saberLockAdvance), 1 },
+{ PSF(heldByClient), 6 },
+{ PSF(ragAttach), GENTITYNUM_BITS },
+{ PSF(iModelScale), 10 }, //0-1024 (guess it's gotta be increased if we want larger allowable scale.. but 1024% is pretty big)
+{ PSF(hackingBaseTime), 16 }, //up to 65536ms, over 10 seconds would just be silly anyway
+{ PSF(hyperSpaceAngles[0]), 0 },
+{ PSF(hyperSpaceAngles[2]), 0 },
+
+//rww - for use by mod authors only
+#ifndef _XBOX
+{ PSF(userInt1), 1 },
+{ PSF(userInt2), 1 },
+{ PSF(userInt3), 1 },
+{ PSF(userFloat1), 1 },
+{ PSF(userFloat2), 1 },
+{ PSF(userFloat3), 1 },
+{ PSF(userVec1[0]), 1 },
+{ PSF(userVec1[1]), 1 },
+{ PSF(userVec1[2]), 1 },
+{ PSF(userVec2[0]), 1 },
+{ PSF(userVec2[1]), 1 },
+{ PSF(userVec2[2]), 1 }
+#endif
+};
+
+//=====_OPTIMIZED_VEHICLE_NETWORKING=======================================================================
+#endif//_OPTIMIZED_VEHICLE_NETWORKING
+//=====_OPTIMIZED_VEHICLE_NETWORKING=======================================================================
+
+#ifndef _XBOX	// No mods on Xbox
+typedef struct bitStorage_s bitStorage_t;
+
+struct bitStorage_s
+{
+	bitStorage_t	*next;
+	int				bits;
+};
+
+static bitStorage_t		*g_netfBitStorage = NULL;
+static bitStorage_t		*g_psfBitStorage = NULL;
+
+//rww - Check the overrides files to see if the mod wants anything changed
+void MSG_CheckNETFPSFOverrides(qboolean psfOverrides)
+{
+	char overrideFile[4096];
+	char entryName[4096];
+	char bits[4096];
+	char *fileName;
+	int ibits;
+	int i = 0;
+	int j;
+	int len;
+	int numFields;
+	fileHandle_t f;
+	bitStorage_t **bitStorage;
+
+	if (psfOverrides)
+	{ //do PSF overrides instead of NETF
+		fileName = "psf_overrides.txt";
+		bitStorage = &g_psfBitStorage;
+		numFields = sizeof(playerStateFields)/sizeof(playerStateFields[0]);
+	}
+	else
+	{
+		fileName = "netf_overrides.txt";
+		bitStorage = &g_netfBitStorage;
+		numFields = sizeof(entityStateFields)/sizeof(entityStateFields[0]);
+	}
+
+	if (*bitStorage)
+	{ //if we have saved off the defaults before we want to stuff them all back in now
+		bitStorage_t *restore = *bitStorage;
+
+		while (i < numFields)
+		{
+			assert(restore);
+
+			if (psfOverrides)
+			{
+				playerStateFields[i].bits = restore->bits;
+			}
+			else
+			{
+				entityStateFields[i].bits = restore->bits;
+			}
+
+			i++;
+			restore = restore->next;
+		}
+	}
+
+	len = FS_FOpenFileRead(va("ext_data/MP/%s", fileName), &f, qfalse);
+
+	if (!f)
+	{ //silently exit since this file is not needed to proceed.
+		return;
+	}
+
+	if (len >= 4096)
+	{
+		Com_Printf("WARNING: %s is >= 4096 bytes and is being ignored\n", fileName);
+		FS_FCloseFile(f);
+		return;
+	}
+
+	//Get contents of the file
+	FS_Read(overrideFile, len, f);
+	FS_FCloseFile(f);
+
+	//because FS_Read does not do this for us.
+	overrideFile[len] = 0;
+
+	//If we haven't saved off the initial stuff yet then stuff it all into
+	//a list.
+	if (!*bitStorage)
+	{
+		i = 0;
+
+		while (i < numFields)
+		{
+			//Alloc memory for this new ptr
+			*bitStorage = (bitStorage_t *)Z_Malloc(sizeof(bitStorage_t), TAG_GENERAL, qtrue);
+
+			if (psfOverrides)
+			{
+				(*bitStorage)->bits = playerStateFields[i].bits;
+			}
+			else
+			{
+				(*bitStorage)->bits = entityStateFields[i].bits;
+			}
+
+			//Point to the ->next of the existing current ptr
+			bitStorage = &(*bitStorage)->next;
+			i++;
+		}
+	}
+
+	i = 0;
+	//Now parse through. Lines beginning with ; are disabled.
+	while (overrideFile[i])
+	{
+		if (overrideFile[i] == ';')
+		{ //parse to end of the line
+			while (overrideFile[i] != '\n')
+			{
+				i++;
+			}
+		}
+
+		if (overrideFile[i] != ';' &&
+			overrideFile[i] != '\n' &&
+			overrideFile[i] != '\r')
+		{ //on a valid char I guess, parse it
+			j = 0;
+
+			while (overrideFile[i] && overrideFile[i] != ',')
+			{
+				entryName[j] = overrideFile[i];
+				j++;
+				i++;
+			}
+			entryName[j] = 0;
+
+			if (!overrideFile[i])
+			{ //just give up, this shouldn't happen
+				Com_Printf("WARNING: Parsing error for %s\n", fileName);
+				return;
+			}
+
+			while (overrideFile[i] == ',' || overrideFile[i] == ' ')
+			{ //parse to the start of the value
+				i++;
+			}
+
+			j = 0;
+			while (overrideFile[i] != '\n' && overrideFile[i] != '\r')
+			{ //now read the value in
+				bits[j] = overrideFile[i];
+				j++;
+				i++;
+			}
+			bits[j] = 0;
+
+			if (bits[0])
+			{
+				if (!strcmp(bits, "GENTITYNUM_BITS"))
+				{ //special case
+					ibits = GENTITYNUM_BITS;
+				}
+				else
+				{
+	                ibits = atoi(bits);
+				}
+
+				j = 0;
+
+				//Now go through all the fields and see if we can find a match
+				while (j < numFields)
+				{
+					if (psfOverrides)
+					{ //check psf fields
+						if (!strcmp(playerStateFields[j].name, entryName))
+						{ //found it, set the bits
+							playerStateFields[j].bits = ibits;
+							break;
+						}
+					}
+					else
+					{ //otherwise check netf fields
+						if (!strcmp(entityStateFields[j].name, entryName))
+						{ //found it, set the bits
+							entityStateFields[j].bits = ibits;
+							break;
+						}
+					}
+					j++;
+				}
+
+				if (j == numFields)
+				{ //failed to find the value
+					Com_Printf("WARNING: Value '%s' from %s is not valid\n", entryName, fileName);
+				}
+			}
+			else
+			{ //also should not happen
+				Com_Printf("WARNING: Parsing error for %s\n", fileName);
+				return;
+			}
+		}
+
+		i++;
+	}
+}
+#endif	// Xbox	- No mods on Xbox
+
+//MAKE SURE THIS MATCHES THE ENUM IN BG_PUBLIC.H!!!
+//This is in caps, because it is important.
+#define STAT_WEAPONS 4
+
+/*
+=============
+MSG_WriteDeltaPlayerstate
+
+=============
+*/
+#ifdef _ONEBIT_COMBO
+void MSG_WriteDeltaPlayerstate( msg_t *msg, struct playerState_s *from, struct playerState_s *to, int *bitComboDelta, int *bitNumDelta, qboolean isVehiclePS ) {
+#else
+void MSG_WriteDeltaPlayerstate( msg_t *msg, struct playerState_s *from, struct playerState_s *to, qboolean isVehiclePS ) {
+#endif
+	int				i;
+	playerState_t	dummy;
+	int				statsbits;
+	int				persistantbits;
+	int				ammobits;
+	int				powerupbits;
+	int				numFields;
+	int				c;
+	netField_t		*field;
+	netField_t		*PSFields = playerStateFields;
+	int				*fromF, *toF;
+	float			fullFloat;
+	int				trunc, lc;
+#ifdef _ONEBIT_COMBO
+	int				bitComboMask = 0;
+	int				numBitsInMask = 0;
+#endif
+
+	if (!from) {
+		from = &dummy;
+		Com_Memset (&dummy, 0, sizeof(dummy));
+	}
+
+	c = msg->cursize;
+
+//=====_OPTIMIZED_VEHICLE_NETWORKING=======================================================================
+#ifdef _OPTIMIZED_VEHICLE_NETWORKING
+	if ( isVehiclePS )
+	{//a vehicle playerstate
+		numFields = sizeof( vehPlayerStateFields ) / sizeof( vehPlayerStateFields[0] );
+		PSFields = vehPlayerStateFields;
+	}
+	else
+	{//regular client playerstate
+		if ( to->m_iVehicleNum
+			&& (to->eFlags&EF_NODRAW) )
+		{//pilot riding *inside* a vehicle!
+			MSG_WriteBits( msg, 1, 1 );	// Pilot player state
+			numFields = sizeof( pilotPlayerStateFields ) / sizeof( pilotPlayerStateFields[0] ) - 82;
+			PSFields = pilotPlayerStateFields;
+		}
+		else
+		{//normal client
+			MSG_WriteBits( msg, 0, 1 );	// Normal player state
+			numFields = sizeof( playerStateFields ) / sizeof( playerStateFields[0] );
+		}
+	}
+//=====_OPTIMIZED_VEHICLE_NETWORKING=======================================================================
+#else// _OPTIMIZED_VEHICLE_NETWORKING
+	numFields = sizeof( playerStateFields ) / sizeof( playerStateFields[0] );
+#endif// _OPTIMIZED_VEHICLE_NETWORKING
+
+	lc = 0;
+	for ( i = 0, field = PSFields ; i < numFields ; i++, field++ ) {
+		fromF = (int *)( (byte *)from + field->offset );
+		toF = (int *)( (byte *)to + field->offset );
+		if ( *fromF != *toF ) {
+			lc = i+1;
+#ifndef FINAL_BUILD
+			field->mCount++;
+#endif
+		}
+	}
+
+	MSG_WriteByte( msg, lc );	// # of changes
+
+#ifndef FINAL_BUILD
+	gLastBitIndex = lc;
+#endif
+
+	oldsize += numFields - lc;
+
+	for ( i = 0, field = PSFields ; i < lc ; i++, field++ ) {
+		fromF = (int *)( (byte *)from + field->offset );
+		toF = (int *)( (byte *)to + field->offset );
+
+#ifdef _ONEBIT_COMBO
+		if (numBitsInMask < 32 &&
+			field->bits == 1)
+		{
+			bitComboMask |= (*toF)<<numBitsInMask;
+			numBitsInMask++;
+			continue;
+		}
+#endif
+
+		if ( *fromF == *toF ) {
+			MSG_WriteBits( msg, 0, 1 );	// no change
+			continue;
+		}
+
+		MSG_WriteBits( msg, 1, 1 );	// changed
+
+		if ( field->bits == 0 ) {
+			// float
+			fullFloat = *(float *)toF;
+			trunc = (int)fullFloat;
+
+			if ( trunc == fullFloat && trunc + FLOAT_INT_BIAS >= 0 && 
+				trunc + FLOAT_INT_BIAS < ( 1 << FLOAT_INT_BITS ) ) {
+				// send as small integer
+				MSG_WriteBits( msg, 0, 1 );
+				MSG_WriteBits( msg, trunc + FLOAT_INT_BIAS, FLOAT_INT_BITS );
+			} else {
+				// send as full floating point value
+				MSG_WriteBits( msg, 1, 1 );
+				MSG_WriteBits( msg, *toF, 32 );
+			}
+		} else {
+			// integer
+			MSG_WriteBits( msg, *toF, field->bits );
+		}
+	}
+	c = msg->cursize - c;
+
+
+	//
+	// send the arrays
+	//
+	statsbits = 0;
+	for (i=0 ; i<16 ; i++) {
+		if (to->stats[i] != from->stats[i]) {
+			statsbits |= 1<<i;
+		}
+	}
+	persistantbits = 0;
+	for (i=0 ; i<16 ; i++) {
+		if (to->persistant[i] != from->persistant[i]) {
+			persistantbits |= 1<<i;
+		}
+	}
+	ammobits = 0;
+	for (i=0 ; i<16 ; i++) {
+		if (to->ammo[i] != from->ammo[i]) {
+			ammobits |= 1<<i;
+		}
+	}
+	powerupbits = 0;
+	for (i=0 ; i<16 ; i++) {
+		if (to->powerups[i] != from->powerups[i]) {
+			powerupbits |= 1<<i;
+		}
+	}
+
+	if (!statsbits && !persistantbits && !ammobits && !powerupbits) {
+		MSG_WriteBits( msg, 0, 1 );	// no change
+		oldsize += 4;
+#ifdef _ONEBIT_COMBO
+		goto sendBitMask;
+#else
+		return;
+#endif
+	}
+	MSG_WriteBits( msg, 1, 1 );	// changed
+
+	if ( statsbits ) {
+		MSG_WriteBits( msg, 1, 1 );	// changed
+		MSG_WriteShort( msg, statsbits );
+		for (i=0 ; i<16 ; i++)
+		{
+			if (statsbits & (1<<i) )
+			{
+				if (i == STAT_WEAPONS)
+				{ //ugly.. but we're gonna need it anyway -rww
+					//(just send this one in MAX_WEAPONS bits, so that we can add up to MAX_WEAPONS weaps without hassle)
+					MSG_WriteBits(msg, to->stats[i], MAX_WEAPONS);
+				}
+				else
+				{
+					MSG_WriteShort (msg, to->stats[i]);
+				}
+			}
+		}
+	} else {
+		MSG_WriteBits( msg, 0, 1 );	// no change
+	}
+
+
+	if ( persistantbits ) {
+		MSG_WriteBits( msg, 1, 1 );	// changed
+		MSG_WriteShort( msg, persistantbits );
+		for (i=0 ; i<16 ; i++)
+			if (persistantbits & (1<<i) )
+				MSG_WriteShort (msg, to->persistant[i]);
+	} else {
+		MSG_WriteBits( msg, 0, 1 );	// no change
+	}
+
+
+	if ( ammobits ) {
+		MSG_WriteBits( msg, 1, 1 );	// changed
+		MSG_WriteShort( msg, ammobits );
+		for (i=0 ; i<16 ; i++)
+			if (ammobits & (1<<i) )
+				MSG_WriteShort (msg, to->ammo[i]);
+	} else {
+		MSG_WriteBits( msg, 0, 1 );	// no change
+	}
+
+
+	if ( powerupbits ) {
+		MSG_WriteBits( msg, 1, 1 );	// changed
+		MSG_WriteShort( msg, powerupbits );
+		for (i=0 ; i<16 ; i++)
+			if (powerupbits & (1<<i) )
+				MSG_WriteLong( msg, to->powerups[i] );
+	} else {
+		MSG_WriteBits( msg, 0, 1 );	// no change
+	}
+
+#ifdef _ONEBIT_COMBO
+sendBitMask:
+	if (numBitsInMask)
+	{ //don't need to send at all if we didn't pass any 1bit values
+		if (!bitComboDelta ||
+			bitComboMask != *bitComboDelta ||
+			numBitsInMask != *bitNumDelta)
+		{ //send the mask, it changed
+			MSG_WriteBits(msg, 1, 1);
+			MSG_WriteBits(msg, bitComboMask, numBitsInMask);
+			if (bitComboDelta)
+			{
+				*bitComboDelta = bitComboMask;
+				*bitNumDelta = numBitsInMask;
+			}
+		}
+		else
+		{ //send 1 bit 0 to indicate no change
+			MSG_WriteBits(msg, 0, 1);
+		}
+	}
+#endif
+}
+
+
+/*
+===================
+MSG_ReadDeltaPlayerstate
+===================
+*/
+void MSG_ReadDeltaPlayerstate (msg_t *msg, playerState_t *from, playerState_t *to, qboolean isVehiclePS ) {
+	int			i, lc;
+	int			bits;
+	netField_t	*field;
+	netField_t  *PSFields = playerStateFields;
+	int			numFields;
+	int			startBit, endBit;
+	int			print;
+	int			*fromF, *toF;
+	int			trunc;
+#ifdef _ONEBIT_COMBO
+	int			numBitsInMask = 0;
+#endif
+	playerState_t	dummy;
+
+	if ( !from ) {
+		from = &dummy;
+		Com_Memset( &dummy, 0, sizeof( dummy ) );
+	}
+	*to = *from;
+
+	if ( msg->bit == 0 ) {
+		startBit = msg->readcount * 8 - GENTITYNUM_BITS;
+	} else {
+		startBit = ( msg->readcount - 1 ) * 8 + msg->bit - GENTITYNUM_BITS;
+	}
+
+	// shownet 2/3 will interleave with other printed info, -2 will
+	// just print the delta records
+	if ( cl_shownet->integer >= 2 || cl_shownet->integer == -2 ) {
+		print = 1;
+		Com_Printf( "%3i: playerstate ", msg->readcount );
+	} else {
+		print = 0;
+	}
+
+//=====_OPTIMIZED_VEHICLE_NETWORKING=======================================================================
+#ifdef _OPTIMIZED_VEHICLE_NETWORKING
+	if ( isVehiclePS )
+	{//a vehicle playerstate
+		numFields = sizeof( vehPlayerStateFields ) / sizeof( vehPlayerStateFields[0] );
+		PSFields = vehPlayerStateFields;
+	}
+	else
+	{
+		int isPilot = MSG_ReadBits( msg, 1 );
+		if ( isPilot )
+		{//pilot riding *inside* a vehicle!
+			numFields = sizeof( pilotPlayerStateFields ) / sizeof( pilotPlayerStateFields[0] ) - 82;
+			PSFields = pilotPlayerStateFields;
+		}
+		else
+		{//normal client
+			numFields = sizeof( playerStateFields ) / sizeof( playerStateFields[0] );
+		}
+	}
+//=====_OPTIMIZED_VEHICLE_NETWORKING=======================================================================
+#else//_OPTIMIZED_VEHICLE_NETWORKING
+	numFields = sizeof( playerStateFields ) / sizeof( playerStateFields[0] );
+#endif//_OPTIMIZED_VEHICLE_NETWORKING
+
+	lc = MSG_ReadByte(msg);
+
+#ifdef _DONETPROFILE_
+	int startBytes,endBytes;
+#endif
+
+	for ( i = 0, field = PSFields ; i < lc ; i++, field++ ) {
+		fromF = (int *)( (byte *)from + field->offset );
+		toF = (int *)( (byte *)to + field->offset );
+
+#ifdef _ONEBIT_COMBO
+		if (numBitsInMask < 32 &&
+			field->bits == 1)
+		{
+			*toF = *fromF;
+			numBitsInMask++;
+			continue;
+		}
+#endif
+
+#ifdef _DONETPROFILE_
+		startBytes=msg->readcount;
+#endif
+		if ( ! MSG_ReadBits( msg, 1 ) ) {
+			// no change
+			*toF = *fromF;
+		} else {
+			if ( field->bits == 0 ) {
+				// float
+				if ( MSG_ReadBits( msg, 1 ) == 0 ) {
+					// integral float
+					trunc = MSG_ReadBits( msg, FLOAT_INT_BITS );
+					// bias to allow equal parts positive and negative
+					trunc -= FLOAT_INT_BIAS;
+					*(float *)toF = trunc; 
+					if ( print ) {
+						Com_Printf( "%s:%i ", field->name, trunc );
+					}
+				} else {
+					// full floating point value
+					*toF = MSG_ReadBits( msg, 32 );
+					if ( print ) {
+						Com_Printf( "%s:%f ", field->name, *(float *)toF );
+					}
+				}
+			} else {
+				// integer
+				*toF = MSG_ReadBits( msg, field->bits );
+				if ( print ) {
+					Com_Printf( "%s:%i ", field->name, *toF );
+				}
+			}
+		}
+#ifdef _DONETPROFILE_
+		endBytes=msg->readcount;
+		ClReadProf().AddField(field->name,endBytes-startBytes);
+#endif
+	}
+	for ( i=lc,field = &PSFields[lc];i<numFields; i++, field++) {
+		fromF = (int *)( (byte *)from + field->offset );
+		toF = (int *)( (byte *)to + field->offset );
+		// no change
+		*toF = *fromF;
+	}
+
+	// read the arrays
+#ifdef _DONETPROFILE_
+		startBytes=msg->readcount;
+#endif
+	if (MSG_ReadBits( msg, 1 ) ) {
+		// parse stats
+		if ( MSG_ReadBits( msg, 1 ) ) {
+			LOG("PS_STATS");
+			bits = MSG_ReadShort (msg);
+			for (i=0 ; i<16 ; i++) {
+				if (bits & (1<<i) )
+				{
+					if (i == STAT_WEAPONS)
+					{ //ugly.. but we're gonna need it anyway -rww
+						to->stats[i] = MSG_ReadBits(msg, MAX_WEAPONS);
+					}
+					else
+					{
+						to->stats[i] = MSG_ReadShort(msg);
+					}
+				}
+			}
+		}
+#ifdef _DONETPROFILE_
+		endBytes=msg->readcount;
+		ClReadProf().AddField("PS_STATS",endBytes-startBytes);
+#endif
+
+		// parse persistant stats
+#ifdef _DONETPROFILE_
+		startBytes=msg->readcount;
+#endif
+		if ( MSG_ReadBits( msg, 1 ) ) {
+			LOG("PS_PERSISTANT");
+			bits = MSG_ReadShort (msg);
+			for (i=0 ; i<16 ; i++) {
+				if (bits & (1<<i) ) {
+					to->persistant[i] = MSG_ReadShort(msg);
+				}
+			}
+		}
+#ifdef _DONETPROFILE_
+		endBytes=msg->readcount;
+		ClReadProf().AddField("PS_PERSISTANT",endBytes-startBytes);
+#endif
+
+		// parse ammo
+#ifdef _DONETPROFILE_
+		startBytes=msg->readcount;
+#endif
+		if ( MSG_ReadBits( msg, 1 ) ) {
+			LOG("PS_AMMO");
+			bits = MSG_ReadShort (msg);
+			for (i=0 ; i<16 ; i++) {
+				if (bits & (1<<i) ) {
+					to->ammo[i] = MSG_ReadShort(msg);
+				}
+			}
+		}
+#ifdef _DONETPROFILE_
+		endBytes=msg->readcount;
+		ClReadProf().AddField("PS_AMMO",endBytes-startBytes);
+#endif
+
+		// parse powerups
+#ifdef _DONETPROFILE_
+		startBytes=msg->readcount;
+#endif
+		if ( MSG_ReadBits( msg, 1 ) ) {
+			LOG("PS_POWERUPS");
+			bits = MSG_ReadShort (msg);
+			for (i=0 ; i<16 ; i++) {
+				if (bits & (1<<i) ) {
+					to->powerups[i] = MSG_ReadLong(msg);
+				}
+			}
+		}
+	}
+#ifdef _DONETPROFILE_
+		endBytes=msg->readcount;
+		ClReadProf().AddField("PS_POWERUPS",endBytes-startBytes);
+#endif
+
+	if ( print ) {
+		if ( msg->bit == 0 ) {
+			endBit = msg->readcount * 8 - GENTITYNUM_BITS;
+		} else {
+			endBit = ( msg->readcount - 1 ) * 8 + msg->bit - GENTITYNUM_BITS;
+		}
+		Com_Printf( " (%i bits)\n", endBit - startBit  );
+	}
+
+#ifdef _ONEBIT_COMBO
+	if (numBitsInMask &&
+		MSG_ReadBits( msg, 1 ))
+	{ //mask changed...
+		int newBitMask = MSG_ReadBits(msg, numBitsInMask);
+		int nOneBit = 0;
+
+		//we have to go through all the fields again now to match the values
+		for ( i = 0, field = PSFields ; i < lc ; i++, field++ )
+		{
+			if (field->bits == 1)
+			{ //a 1 bit value, get the sent value from the mask
+				toF = (int *)( (byte *)to + field->offset );
+                *toF = (newBitMask>>nOneBit)&1;
+				nOneBit++;
+			}
+		}
+	}
+#endif
+}
+
+/*
+// New data gathered to tune Q3 to JK2MP. Takes longer to crunch and gain was minimal.
+int msg_hData[256] = 
+{
+	3163878,		// 0
+	473992,			// 1
+	564019,			// 2
+	136497,			// 3
+	129559,			// 4
+	283019,			// 5
+	75812,			// 6
+	179836,			// 7
+	85958,			// 8
+	168542,			// 9
+	78898,			// 10
+	82007,			// 11
+	48613,			// 12
+	138741,			// 13
+	35482,			// 14
+	47433,			// 15
+	65214,			// 16
+	51636,			// 17
+	63741,			// 18
+	52823,			// 19
+	42464,			// 20
+	44495,			// 21
+	45347,			// 22
+	40260,			// 23
+	59168,			// 24
+	44990,			// 25
+	52957,			// 26
+	42700,			// 27
+	42414,			// 28
+	36451,			// 29
+	45653,			// 30
+	44667,			// 31
+	125336,			// 32
+	38435,			// 33
+	53658,			// 34
+	42621,			// 35
+	40932,			// 36
+	33409,			// 37
+	35470,			// 38
+	40769,			// 39
+	33813,			// 40
+	32480,			// 41
+	33664,			// 42
+	32303,			// 43
+	32394,			// 44
+	34822,			// 45
+	37724,			// 46
+	48016,			// 47
+	94212,			// 48
+	53774,			// 49
+	54522,			// 50
+	44044,			// 51
+	42800,			// 52
+	47597,			// 53
+	29742,			// 54
+	30237,			// 55
+	34291,			// 56
+	106496,			// 57
+	20963,			// 58
+	19342,			// 59
+	20603,			// 60
+	19568,			// 61
+	23013,			// 62
+	23939,			// 63
+	44995,			// 64
+	37128,			// 65
+	44264,			// 66
+	46636,			// 67
+	56400,			// 68
+	32746,			// 69
+	23458,			// 70
+	29702,			// 71
+	25305,			// 72
+	20159,			// 73
+	19645,			// 74
+	20593,			// 75
+	21729,			// 76
+	19362,			// 77
+	24760,			// 78
+	22788,			// 79
+	25085,			// 80
+	21074,			// 81
+	97271,			// 82
+	22048,			// 83
+	24131,			// 84
+	19287,			// 85
+	20296,			// 86
+	20131,			// 87
+	86477,			// 88
+	25352,			// 89
+	20872,			// 90
+	21382,			// 91
+	38744,			// 92
+	137256,			// 93
+	26025,			// 94
+	22243,			// 95
+	23974,			// 96
+	43305,			// 97
+	28191,			// 98
+	34638,			// 99
+	37613,			// 100
+	46003,			// 101
+	31415,			// 102
+	25746,			// 103
+	28338,			// 104
+	34689,			// 105
+	24948,			// 106
+	27110,			// 107
+	39950,			// 108
+	32793,			// 109
+	42639,			// 110
+	47883,			// 111
+	37439,			// 112
+	23875,			// 113
+	36092,			// 114
+	46471,			// 115
+	37392,			// 116
+	33063,			// 117
+	29604,			// 118
+	42140,			// 119
+	61745,			// 120
+	45618,			// 121
+	51779,			// 122
+	49684,			// 123
+	57644,			// 124
+	65021,			// 125
+	67318,			// 126
+	88197,			// 127
+	258378,			// 128
+	76806,			// 129
+	72430,			// 130
+	64936,			// 131
+	62196,			// 132
+	56461,			// 133
+	166474,			// 134
+	70036,			// 135
+	40735,			// 136
+	29598,			// 137
+	26966,			// 138
+	26093,			// 139
+	25853,			// 140
+	26065,			// 141
+	26176,			// 142
+	26777,			// 143
+	26684,			// 144
+	23880,			// 145
+	22932,			// 146
+	24566,			// 147
+	24305,			// 148
+	26399,			// 149
+	23487,			// 150
+	24485,			// 151
+	25956,			// 152
+	26065,			// 153
+	26151,			// 154
+	23111,			// 155
+	23900,			// 156
+	22128,			// 157
+	24096,			// 158
+	20863,			// 159
+	24298,			// 160
+	22572,			// 161
+	22364,			// 162
+	20813,			// 163
+	21414,			// 164
+	21570,			// 165
+	20799,			// 166
+	20971,			// 167
+	22485,			// 168
+	20397,			// 169
+	88096,			// 170
+	17802,			// 171
+	20091,			// 172
+	84250,			// 173
+	21953,			// 174
+	21406,			// 175
+	23401,			// 176
+	19546,			// 177
+	19180,			// 178
+	18843,			// 179
+	20673,			// 180
+	19918,			// 181
+	20640,			// 182
+	20326,			// 183
+	21174,			// 184
+	21736,			// 185
+	22511,			// 186
+	20290,			// 187
+	23303,			// 188
+	19800,			// 189
+	25465,			// 190
+	22801,			// 191
+	28831,			// 192
+	26663,			// 193
+	36485,			// 194
+	45768,			// 195
+	49795,			// 196
+	36026,			// 197
+	24119,			// 198
+	18543,			// 199
+	19261,			// 200
+	17137,			// 201
+	19435,			// 202
+	23672,			// 203
+	22988,			// 204
+	18107,			// 205
+	18734,			// 206
+	19847,			// 207
+	101897,			// 208
+	18405,			// 209
+	21260,			// 210
+	17818,			// 211
+	18971,			// 212
+	19317,			// 213
+	19112,			// 214
+	19395,			// 215
+	20688,			// 216
+	18438,			// 217
+	18945,			// 218
+	29309,			// 219
+	19666,			// 220
+	18735,			// 221
+	87691,			// 222
+	18478,			// 223
+	22634,			// 224
+	20984,			// 225
+	20079,			// 226
+	18624,			// 227
+	20045,			// 228
+	18369,			// 229
+	19014,			// 230
+	83179,			// 231
+	20899,			// 232
+	17854,			// 233
+	19332,			// 234
+	17875,			// 235
+	28647,			// 236
+	17465,			// 237
+	20277,			// 238
+	18994,			// 239
+	22192,			// 240
+	17443,			// 241
+	20243,			// 242
+	28174,			// 243
+	134871,			// 244
+	17753,			// 245
+	18924,			// 246
+	18281,			// 247
+	18937,			// 248
+	17419,			// 249
+	20679,			// 250
+	17865,			// 251
+	17984,			// 252
+	58615,			// 253
+	35506,			// 254
+	123499,			// 255
+};
+*/
+
+// Q3 TA freq. table.
+int msg_hData[256] = {
+250315,			// 0
+41193,			// 1
+6292,			// 2
+7106,			// 3
+3730,			// 4
+3750,			// 5
+6110,			// 6
+23283,			// 7
+33317,			// 8
+6950,			// 9
+7838,			// 10
+9714,			// 11
+9257,			// 12
+17259,			// 13
+3949,			// 14
+1778,			// 15
+8288,			// 16
+1604,			// 17
+1590,			// 18
+1663,			// 19
+1100,			// 20
+1213,			// 21
+1238,			// 22
+1134,			// 23
+1749,			// 24
+1059,			// 25
+1246,			// 26
+1149,			// 27
+1273,			// 28
+4486,			// 29
+2805,			// 30
+3472,			// 31
+21819,			// 32
+1159,			// 33
+1670,			// 34
+1066,			// 35
+1043,			// 36
+1012,			// 37
+1053,			// 38
+1070,			// 39
+1726,			// 40
+888,			// 41
+1180,			// 42
+850,			// 43
+960,			// 44
+780,			// 45
+1752,			// 46
+3296,			// 47
+10630,			// 48
+4514,			// 49
+5881,			// 50
+2685,			// 51
+4650,			// 52
+3837,			// 53
+2093,			// 54
+1867,			// 55
+2584,			// 56
+1949,			// 57
+1972,			// 58
+940,			// 59
+1134,			// 60
+1788,			// 61
+1670,			// 62
+1206,			// 63
+5719,			// 64
+6128,			// 65
+7222,			// 66
+6654,			// 67
+3710,			// 68
+3795,			// 69
+1492,			// 70
+1524,			// 71
+2215,			// 72
+1140,			// 73
+1355,			// 74
+971,			// 75
+2180,			// 76
+1248,			// 77
+1328,			// 78
+1195,			// 79
+1770,			// 80
+1078,			// 81
+1264,			// 82
+1266,			// 83
+1168,			// 84
+965,			// 85
+1155,			// 86
+1186,			// 87
+1347,			// 88
+1228,			// 89
+1529,			// 90
+1600,			// 91
+2617,			// 92
+2048,			// 93
+2546,			// 94
+3275,			// 95
+2410,			// 96
+3585,			// 97
+2504,			// 98
+2800,			// 99
+2675,			// 100
+6146,			// 101
+3663,			// 102
+2840,			// 103
+14253,			// 104
+3164,			// 105
+2221,			// 106
+1687,			// 107
+3208,			// 108
+2739,			// 109
+3512,			// 110
+4796,			// 111
+4091,			// 112
+3515,			// 113
+5288,			// 114
+4016,			// 115
+7937,			// 116
+6031,			// 117
+5360,			// 118
+3924,			// 119
+4892,			// 120
+3743,			// 121
+4566,			// 122
+4807,			// 123
+5852,			// 124
+6400,			// 125
+6225,			// 126
+8291,			// 127
+23243,			// 128
+7838,			// 129
+7073,			// 130
+8935,			// 131
+5437,			// 132
+4483,			// 133
+3641,			// 134
+5256,			// 135
+5312,			// 136
+5328,			// 137
+5370,			// 138
+3492,			// 139
+2458,			// 140
+1694,			// 141
+1821,			// 142
+2121,			// 143
+1916,			// 144
+1149,			// 145
+1516,			// 146
+1367,			// 147
+1236,			// 148
+1029,			// 149
+1258,			// 150
+1104,			// 151
+1245,			// 152
+1006,			// 153
+1149,			// 154
+1025,			// 155
+1241,			// 156
+952,			// 157
+1287,			// 158
+997,			// 159
+1713,			// 160
+1009,			// 161
+1187,			// 162
+879,			// 163
+1099,			// 164
+929,			// 165
+1078,			// 166
+951,			// 167
+1656,			// 168
+930,			// 169
+1153,			// 170
+1030,			// 171
+1262,			// 172
+1062,			// 173
+1214,			// 174
+1060,			// 175
+1621,			// 176
+930,			// 177
+1106,			// 178
+912,			// 179
+1034,			// 180
+892,			// 181
+1158,			// 182
+990,			// 183
+1175,			// 184
+850,			// 185
+1121,			// 186
+903,			// 187
+1087,			// 188
+920,			// 189
+1144,			// 190
+1056,			// 191
+3462,			// 192
+2240,			// 193
+4397,			// 194
+12136,			// 195
+7758,			// 196
+1345,			// 197
+1307,			// 198
+3278,			// 199
+1950,			// 200
+886,			// 201
+1023,			// 202
+1112,			// 203
+1077,			// 204
+1042,			// 205
+1061,			// 206
+1071,			// 207
+1484,			// 208
+1001,			// 209
+1096,			// 210
+915,			// 211
+1052,			// 212
+995,			// 213
+1070,			// 214
+876,			// 215
+1111,			// 216
+851,			// 217
+1059,			// 218
+805,			// 219
+1112,			// 220
+923,			// 221
+1103,			// 222
+817,			// 223
+1899,			// 224
+1872,			// 225
+976,			// 226
+841,			// 227
+1127,			// 228
+956,			// 229
+1159,			// 230
+950,			// 231
+7791,			// 232
+954,			// 233
+1289,			// 234
+933,			// 235
+1127,			// 236
+3207,			// 237
+1020,			// 238
+927,			// 239
+1355,			// 240
+768,			// 241
+1040,			// 242
+745,			// 243
+952,			// 244
+805,			// 245
+1073,			// 246
+740,			// 247
+1013,			// 248
+805,			// 249
+1008,			// 250
+796,			// 251
+996,			// 252
+1057,			// 253
+11457,			// 254
+13504,			// 255
+};
+
+#ifndef _USINGNEWHUFFTABLE_
+
+void MSG_initHuffman() {
+	int i,j;
+
+#ifdef _NEWHUFFTABLE_
+	fp=fopen("c:\\netchan.bin", "a");
+#endif // _NEWHUFFTABLE_
+	
+	msgInit = qtrue;
+	Huff_Init(&msgHuff);
+	for(i=0;i<256;i++) {
+		for (j=0;j<msg_hData[i];j++) {
+			Huff_addRef(&msgHuff.compressor,	(byte)i);			// Do update
+			Huff_addRef(&msgHuff.decompressor,	(byte)i);			// Do update
+		}
+	}
+}
+
+#else
+
+void MSG_initHuffman() {
+
+	byte	*data;
+	int		size, i, ch;
+	int		array[256];
+
+	msgInit = qtrue;
+
+	Huff_Init(&msgHuff);
+	// load it in
+	size = FS_ReadFile( "netchan\\netchan.bin", (void **)&data );
+
+	for(i=0;i<256;i++) {
+		array[i] = 0;
+	}
+	for(i=0;i<size;i++) {
+		ch = data[i];
+		Huff_addRef(&msgHuff.compressor,	ch);			// Do update
+		Huff_addRef(&msgHuff.decompressor,	ch);			// Do update
+		array[ch]++;
+	}
+	Com_Printf("msg_hData {\n");
+	for(i=0;i<256;i++) {
+		if (array[i] == 0) {
+			Huff_addRef(&msgHuff.compressor,	i);			// Do update
+			Huff_addRef(&msgHuff.decompressor,	i);			// Do update
+		}
+		Com_Printf("%d,			// %d\n", array[i], i);
+	}
+	Com_Printf("};\n");
+	FS_FreeFile( data );
+	Cbuf_AddText( "condump dump.txt\n" );
+}
+
+#endif _USINGNEWHUFFTABLE_
+
+void MSG_shutdownHuffman()
+{
+#ifdef _NEWHUFFTABLE_
+	if(fp)
+	{
+		fclose(fp);
+	}
+#endif // _NEWHUFFTABLE_
+}
+
+/*
+=================
+MSG_ReportChangeVectors_f
+
+Prints out a table from the current statistics for copying to code
+=================
+*/
+void MSG_ReportChangeVectors_f( void ) {
+#ifndef _XBOX
+#ifndef FINAL_BUILD
+	int			numFields, i;
+	netField_t	*field;
+
+	numFields = sizeof(entityStateFields)/sizeof(entityStateFields[0]);
+
+	Com_Printf("Entity State Fields:\n");
+	for ( i = 0, field = entityStateFields ; i < numFields ; i++, field++ ) 
+	{
+		Com_Printf("%s\t\t%d\n", field->name, field->mCount);
+		field->mCount = 0;
+	}
+
+	Com_Printf("\nPlayer State Fields:\n");
+	numFields = sizeof( playerStateFields ) / sizeof( playerStateFields[0] );
+	for ( i = 0, field = playerStateFields ; i < numFields ; i++, field++ )
+	{
+		Com_Printf("%s\t\t%d\n", field->name, field->mCount);
+		field->mCount = 0;
+	}
+
+#endif	// FINAL_BUILD
+#endif
+}
+
+//===========================================================================
diff --git a/codemp/qcommon/net_chan.cpp b/codemp/qcommon/net_chan.cpp
new file mode 100644
index 0000000..9d6933a
--- /dev/null
+++ b/codemp/qcommon/net_chan.cpp
@@ -0,0 +1,657 @@
+
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+
+/*
+
+packet header
+-------------
+4	outgoing sequence.  high bit will be set if this is a fragmented message
+[2	qport (only for client to server)]
+[2	fragment start byte]
+[2	fragment length. if < FRAGMENT_SIZE, this is the last fragment]
+
+if the sequence number is -1, the packet should be handled as an out-of-band
+message instead of as part of a netcon.
+
+All fragments will have the same sequence numbers.
+
+The qport field is a workaround for bad address translating routers that
+sometimes remap the client's source port on a packet during gameplay.
+
+If the base part of the net address matches and the qport matches, then the
+channel matches even if the IP port differs.  The IP port should be updated
+to the new value before sending out any replies.
+
+*/
+
+#ifdef _XBOX
+#define	MAX_PACKETLEN			1359 // UDP total packet size
+#define	FRAGMENT_SIZE			(MAX_PACKETLEN - 55 - 10) // 55 is packet overhead  |||  10 is fudge factor - needed due to huffman?
+#else
+#define	MAX_PACKETLEN			1400		// max size of a network packet
+#define	FRAGMENT_SIZE			(MAX_PACKETLEN - 100)
+#define	PACKET_HEADER			10			// two ints and a short
+#endif
+
+#define	FRAGMENT_BIT	(1<<31)
+
+cvar_t		*showpackets;
+cvar_t		*showdrop;
+cvar_t		*qport;
+cvar_t		*net_killdroppedfragments;
+
+static char *netsrcString[2] = {
+	"client",
+	"server"
+};
+
+/*
+===============
+Netchan_Init
+
+===============
+*/
+void Netchan_Init( int port ) {
+	port &= 0xffff;
+	showpackets = Cvar_Get ("showpackets", "0", CVAR_TEMP );
+	showdrop = Cvar_Get ("showdrop", "0", CVAR_TEMP );
+	qport = Cvar_Get ("net_qport", va("%i", port), CVAR_INIT );
+	net_killdroppedfragments = Cvar_Get ("net_killdroppedfragments", "0", CVAR_TEMP);
+}
+
+/*
+==============
+Netchan_Setup
+
+called to open a channel to a remote system
+==============
+*/
+void Netchan_Setup( netsrc_t sock, netchan_t *chan, netadr_t adr, int qport ) {
+	Com_Memset (chan, 0, sizeof(*chan));
+	
+	chan->sock = sock;
+	chan->remoteAddress = adr;
+	chan->qport = qport;
+	chan->incomingSequence = 0;
+	chan->outgoingSequence = 1;
+}
+
+/*
+=================
+Netchan_TransmitNextFragment
+
+Send one fragment of the current message
+=================
+*/
+void Netchan_TransmitNextFragment( netchan_t *chan ) {
+	msg_t		send;
+	byte		send_buf[MAX_PACKETLEN];
+	int			fragmentLength;
+
+	// write the packet header
+	MSG_InitOOB (&send, send_buf, sizeof(send_buf));				// <-- only do the oob here
+
+	MSG_WriteLong( &send, chan->outgoingSequence | FRAGMENT_BIT );
+
+	// send the qport if we are a client
+	if ( chan->sock == NS_CLIENT ) {
+		MSG_WriteShort( &send, qport->integer );
+	}
+
+	// copy the reliable message to the packet first
+	fragmentLength = FRAGMENT_SIZE;
+	if ( chan->unsentFragmentStart  + fragmentLength > chan->unsentLength ) {
+		fragmentLength = chan->unsentLength - chan->unsentFragmentStart;
+	}
+
+	MSG_WriteShort( &send, chan->unsentFragmentStart );
+	MSG_WriteShort( &send, fragmentLength );
+	MSG_WriteData( &send, chan->unsentBuffer + chan->unsentFragmentStart, fragmentLength );
+
+	// send the datagram
+	NET_SendPacket( chan->sock, send.cursize, send.data, chan->remoteAddress );
+
+	if ( showpackets->integer ) {
+		Com_Printf ("%s send %4i : s=%i fragment=%i,%i\n"
+			, netsrcString[ chan->sock ]
+			, send.cursize
+			, chan->outgoingSequence - 1
+			, chan->unsentFragmentStart, fragmentLength);
+	}
+
+	chan->unsentFragmentStart += fragmentLength;
+
+	// this exit condition is a little tricky, because a packet
+	// that is exactly the fragment length still needs to send
+	// a second packet of zero length so that the other side
+	// can tell there aren't more to follow
+	if ( chan->unsentFragmentStart == chan->unsentLength && fragmentLength != FRAGMENT_SIZE ) {
+		chan->outgoingSequence++;
+		chan->unsentFragments = qfalse;
+	}
+}
+
+
+/*
+===============
+Netchan_Transmit
+
+Sends a message to a connection, fragmenting if necessary
+A 0 length will still generate a packet.
+================
+*/
+void Netchan_Transmit( netchan_t *chan, int length, const byte *data ) {
+	msg_t		send;
+	byte		send_buf[MAX_PACKETLEN];
+
+	if ( length > MAX_MSGLEN ) {
+		Com_Error( ERR_DROP, "Netchan_Transmit: length = %i", length );
+	}
+	chan->unsentFragmentStart = 0;
+
+	if (chan->unsentFragments)
+	{
+		Com_Printf("[ISM] Stomping Unsent Fragments %s\n",netsrcString[ chan->sock ]);
+	}
+	// fragment large reliable messages
+	if ( length >= FRAGMENT_SIZE ) 
+	{
+		chan->unsentFragments = qtrue;
+		chan->unsentLength = length;
+		Com_Memcpy( chan->unsentBuffer, data, length );
+
+		// only send the first fragment now
+		Netchan_TransmitNextFragment( chan );
+
+		return;
+	}
+
+	// write the packet header
+	MSG_InitOOB (&send, send_buf, sizeof(send_buf));
+
+	MSG_WriteLong( &send, chan->outgoingSequence );
+	chan->outgoingSequence++;
+
+	// send the qport if we are a client
+	if ( chan->sock == NS_CLIENT ) {
+		MSG_WriteShort( &send, qport->integer );
+	}
+
+	MSG_WriteData( &send, data, length );
+
+	// send the datagram
+	NET_SendPacket( chan->sock, send.cursize, send.data, chan->remoteAddress );
+
+	if ( showpackets->integer ) {
+		Com_Printf( "%s send %4i : s=%i ack=%i\n"
+			, netsrcString[ chan->sock ]
+			, send.cursize
+			, chan->outgoingSequence - 1
+			, chan->incomingSequence );
+	}
+}
+
+/*
+=================
+Netchan_Process
+
+Returns qfalse if the message should not be processed due to being
+out of order or a fragment.
+
+Msg must be large enough to hold MAX_MSGLEN, because if this is the
+final fragment of a multi-part message, the entire thing will be
+copied out.
+=================
+*/
+qboolean Netchan_Process( netchan_t *chan, msg_t *msg ) {
+	int			sequence;
+	int			qport;
+	int			fragmentStart, fragmentLength;
+	qboolean	fragmented;
+
+	// get sequence numbers		
+	MSG_BeginReadingOOB( msg );
+	sequence = MSG_ReadLong( msg );
+
+	// check for fragment information
+	if ( sequence & FRAGMENT_BIT ) {
+		sequence &= ~FRAGMENT_BIT;
+		fragmented = qtrue;
+	} else {
+		fragmented = qfalse;
+	}
+
+	// read the qport if we are a server
+	if ( chan->sock == NS_SERVER ) {
+		qport = MSG_ReadShort( msg );
+	}
+
+	// read the fragment information
+	if ( fragmented ) {
+		fragmentStart  = (unsigned short)MSG_ReadShort( msg );
+		fragmentLength = (unsigned short)MSG_ReadShort( msg );
+	} else {
+		fragmentStart = 0;		// stop warning message
+		fragmentLength = 0;
+	}
+
+	if ( showpackets->integer ) {
+		if ( fragmented ) {
+			Com_Printf( "%s recv %4i : s=%i fragment=%i,%i\n"
+				, netsrcString[ chan->sock ]
+				, msg->cursize
+				, sequence
+				, fragmentStart, fragmentLength );
+		} else {
+			Com_Printf( "%s recv %4i : s=%i\n"
+				, netsrcString[ chan->sock ]
+				, msg->cursize
+				, sequence );
+		}
+	}
+
+	//
+	// discard out of order or duplicated packets
+	//
+	if ( sequence <= chan->incomingSequence ) {
+		if ( showdrop->integer || showpackets->integer ) {
+			Com_Printf( "%s:Out of order packet %i at %i\n"
+				, NET_AdrToString( chan->remoteAddress )
+				,  sequence
+				, chan->incomingSequence );
+		}
+		return qfalse;
+	}
+
+	//
+	// dropped packets don't keep the message from being used
+	//
+	chan->dropped = sequence - (chan->incomingSequence+1);
+	if ( chan->dropped > 0 ) {
+		if ( showdrop->integer || showpackets->integer ) {
+			Com_Printf( "%s:Dropped %i packets at %i\n"
+			, NET_AdrToString( chan->remoteAddress )
+			, chan->dropped
+			, sequence );
+		}
+	}
+	
+
+	//
+	// if this is the final framgent of a reliable message,
+	// bump incoming_reliable_sequence 
+	//
+	if ( fragmented ) {
+		// make sure we 
+		if ( sequence != chan->fragmentSequence ) {
+			chan->fragmentSequence = sequence;
+			chan->fragmentLength = 0;
+		}
+
+		// if we missed a fragment, dump the message
+		if ( fragmentStart != chan->fragmentLength ) {
+			if ( showdrop->integer || showpackets->integer ) {
+				Com_Printf( "%s:Dropped a message fragment\n"
+				, NET_AdrToString( chan->remoteAddress )
+				, sequence);
+			}
+			// we can still keep the part that we have so far,
+			// so we don't need to clear chan->fragmentLength
+
+			//rww - not clearing this will allow us to piece together fragments belonging to other packets
+			//that happen to have the same sequence (or so it seems). I am just going to clear it and force
+			//the packet to be dropped.
+
+			// hell yeah we have to dump the whole thing -gil
+			// but I am scared - mw
+			/*
+			chan->fragmentLength = 0;
+			chan->incomingSequence = sequence;
+			chan->fragmentSequence = 0;
+			*/
+			return qfalse;
+		}
+
+		// copy the fragment to the fragment buffer
+		if ( fragmentLength < 0 || msg->readcount + fragmentLength > msg->cursize ||
+			chan->fragmentLength + fragmentLength > sizeof( chan->fragmentBuffer ) ) {
+			if ( showdrop->integer || showpackets->integer ) {
+				Com_Printf ("%s:illegal fragment length\n"
+				, NET_AdrToString (chan->remoteAddress ) );
+			}
+			return qfalse;
+		}
+
+		Com_Memcpy( chan->fragmentBuffer + chan->fragmentLength, 
+			msg->data + msg->readcount, fragmentLength );
+
+		chan->fragmentLength += fragmentLength;
+
+		// if this wasn't the last fragment, don't process anything
+		if ( fragmentLength == FRAGMENT_SIZE ) {
+			return qfalse;
+		}
+
+		if ( chan->fragmentLength+4 > msg->maxsize ) {
+			Com_Printf( "%s:fragmentLength %i > msg->maxsize\n"
+				, NET_AdrToString (chan->remoteAddress ),
+				chan->fragmentLength+4 );
+			return qfalse;
+		}
+
+		// copy the full message over the partial fragment
+
+		// make sure the sequence number is still there
+		*(int *)msg->data = LittleLong( sequence );
+
+		Com_Memcpy( msg->data + 4, chan->fragmentBuffer, chan->fragmentLength );
+		msg->cursize = chan->fragmentLength + 4;
+		chan->fragmentLength = 0;
+		msg->readcount = 4;	// past the sequence number
+		msg->bit = 32;	// past the sequence number
+
+		// but I am a wuss -mw 
+		// chan->incomingSequence = sequence;   // lets not accept any more with this sequence number -gil
+		return qtrue;
+	}
+
+	//
+	// the message can now be read from the current message pointer
+	//
+	chan->incomingSequence = sequence;
+
+	return qtrue;
+}
+
+
+//==============================================================================
+
+/*
+===================
+NET_CompareBaseAdr
+
+Compares without the port
+===================
+*/
+qboolean	NET_CompareBaseAdr (netadr_t a, netadr_t b)
+{
+	if (a.type != b.type)
+		return qfalse;
+
+	if (a.type == NA_LOOPBACK)
+		return qtrue;
+
+	if (a.type == NA_IP)
+	{
+		if (a.ip[0] == b.ip[0] && a.ip[1] == b.ip[1] && a.ip[2] == b.ip[2] && a.ip[3] == b.ip[3])
+			return qtrue;
+		return qfalse;
+	}
+
+#ifndef _XBOX	// No IPX
+	if (a.type == NA_IPX)
+	{
+		if ((memcmp(a.ipx, b.ipx, 10) == 0))
+			return qtrue;
+		return qfalse;
+	}
+#endif
+
+	Com_Printf ("NET_CompareBaseAdr: bad address type\n");
+	return qfalse;
+}
+
+const char	*NET_AdrToString (netadr_t a)
+{
+	static	char	s[64];
+
+	if (a.type == NA_LOOPBACK) {
+		Com_sprintf (s, sizeof(s), "loopback");
+	} else if (a.type == NA_BOT) {
+		Com_sprintf (s, sizeof(s), "bot");
+	} else if (a.type == NA_IP) {
+		Com_sprintf (s, sizeof(s), "%i.%i.%i.%i:%i",
+			a.ip[0], a.ip[1], a.ip[2], a.ip[3], BigShort(a.port));
+	} else if (a.type == NA_BAD) {
+		Com_sprintf (s, sizeof(s), "BAD");
+	} else {
+		Com_sprintf (s, sizeof(s), "%02x%02x%02x%02x.%02x%02x%02x%02x%02x%02x:%i",
+		a.ipx[0], a.ipx[1], a.ipx[2], a.ipx[3], a.ipx[4], a.ipx[5], a.ipx[6], a.ipx[7], a.ipx[8], a.ipx[9], 
+		BigShort(a.port));
+	}
+
+	return s;
+}
+
+
+qboolean	NET_CompareAdr (netadr_t a, netadr_t b)
+{
+	if (a.type != b.type)
+		return qfalse;
+
+	if (a.type == NA_LOOPBACK)
+		return qtrue;
+
+	if (a.type == NA_IP)
+	{
+		if (a.ip[0] == b.ip[0] && a.ip[1] == b.ip[1] && a.ip[2] == b.ip[2] && a.ip[3] == b.ip[3] && a.port == b.port)
+			return qtrue;
+		return qfalse;
+	}
+
+#ifndef _XBOX	// No IPX
+	if (a.type == NA_IPX)
+	{
+		if ((memcmp(a.ipx, b.ipx, 10) == 0) && a.port == b.port)
+			return qtrue;
+		return qfalse;
+	}
+#endif
+
+	Com_Printf ("NET_CompareAdr: bad address type\n");
+	return qfalse;
+}
+
+
+qboolean	NET_IsLocalAddress( netadr_t adr ) {
+	return (qboolean)(adr.type == NA_LOOPBACK);
+}
+
+
+
+/*
+=============================================================================
+
+LOOPBACK BUFFERS FOR LOCAL PLAYER
+
+=============================================================================
+*/
+
+// there needs to be enough loopback messages to hold a complete
+// gamestate of maximum size
+#define	MAX_LOOPBACK	16
+
+typedef struct {
+	byte	data[MAX_PACKETLEN];
+	int		datalen;
+} loopmsg_t;
+
+typedef struct {
+	loopmsg_t	msgs[MAX_LOOPBACK];
+	int			get, send;
+} loopback_t;
+
+loopback_t	loopbacks[2];
+
+
+qboolean	NET_GetLoopPacket (netsrc_t sock, netadr_t *net_from, msg_t *net_message)
+{
+	int		i;
+	loopback_t	*loop;
+
+	loop = &loopbacks[sock];
+
+	if (loop->send - loop->get > MAX_LOOPBACK)
+		loop->get = loop->send - MAX_LOOPBACK;
+
+	if (loop->get >= loop->send)
+		return qfalse;
+
+	i = loop->get & (MAX_LOOPBACK-1);
+	loop->get++;
+
+	Com_Memcpy (net_message->data, loop->msgs[i].data, loop->msgs[i].datalen);
+	net_message->cursize = loop->msgs[i].datalen;
+	Com_Memset (net_from, 0, sizeof(*net_from));
+	net_from->type = NA_LOOPBACK;
+	return qtrue;
+
+}
+
+
+void NET_SendLoopPacket (netsrc_t sock, int length, const void *data, netadr_t to)
+{
+	int		i;
+	loopback_t	*loop;
+
+	loop = &loopbacks[sock^1];
+
+	i = loop->send & (MAX_LOOPBACK-1);
+	loop->send++;
+
+	Com_Memcpy (loop->msgs[i].data, data, length);
+	loop->msgs[i].datalen = length;
+}
+
+//=============================================================================
+
+
+void NET_SendPacket( netsrc_t sock, int length, const void *data, netadr_t to ) {
+
+	// sequenced packets are shown in netchan, so just show oob
+	if ( showpackets->integer && *(int *)data == -1 )	{
+		Com_Printf ("send packet %4i\n", length);
+	}
+
+	if ( to.type == NA_LOOPBACK ) {
+		NET_SendLoopPacket (sock, length, data, to);
+		return;
+	}
+	if ( to.type == NA_BOT ) {
+		return;
+	}
+	if ( to.type == NA_BAD ) {
+		return;
+	}
+
+	Sys_SendPacket( length, data, to );
+}
+
+/*
+===============
+NET_OutOfBandPrint
+
+Sends a text message in an out-of-band datagram
+================
+*/
+void QDECL NET_OutOfBandPrint( netsrc_t sock, netadr_t adr, const char *format, ... ) {
+	va_list		argptr;
+	char		string[MAX_MSGLEN];
+
+
+	// set the header
+	string[0] = -1;
+	string[1] = -1;
+	string[2] = -1;
+	string[3] = -1;
+
+	va_start( argptr, format );
+	vsprintf( string+4, format, argptr );
+	va_end( argptr );
+
+	// send the datagram
+	NET_SendPacket( sock, strlen( string ), string, adr );
+}
+
+/*
+===============
+NET_OutOfBandPrint
+
+Sends a data message in an out-of-band datagram (only used for "connect")
+================
+*/
+void QDECL NET_OutOfBandData( netsrc_t sock, netadr_t adr, byte *format, int len ) {
+	byte		string[MAX_MSGLEN*2];
+	int			i;
+	msg_t		mbuf;
+
+	// set the header
+	string[0] = 0xff;
+	string[1] = 0xff;
+	string[2] = 0xff;
+	string[3] = 0xff;
+
+	for(i=0;i<len;i++) {
+		string[i+4] = format[i];
+	}
+
+	mbuf.data = string;
+	mbuf.cursize = len+4;
+	Huff_Compress( &mbuf, 12);
+	// send the datagram
+	NET_SendPacket( sock, mbuf.cursize, mbuf.data, adr );
+}
+
+
+
+
+/*
+=============
+NET_StringToAdr
+
+Traps "localhost" for loopback, passes everything else to system
+=============
+*/
+qboolean	NET_StringToAdr( const char *s, netadr_t *a ) {
+	qboolean	r;
+	char	base[MAX_STRING_CHARS];
+	char	*port;
+
+	if (!strcmp (s, "localhost")) {
+		Com_Memset (a, 0, sizeof(*a));
+		a->type = NA_LOOPBACK;
+		return qtrue;
+	}
+
+	// look for a port number
+	Q_strncpyz( base, s, sizeof( base ) );
+	port = strstr( base, ":" );
+	if ( port ) {
+		*port = 0;
+		port++;
+	}
+
+	r = Sys_StringToAdr( base, a );
+
+	if ( !r ) {
+		a->type = NA_BAD;
+		return qfalse;
+	}
+
+	// inet_addr returns this if out of range
+	if ( a->ip[0] == 255 && a->ip[1] == 255 && a->ip[2] == 255 && a->ip[3] == 255 ) {
+		a->type = NA_BAD;
+		return qfalse;
+	}
+
+	if ( port ) {
+		a->port = BigShort( (short)atoi( port ) );
+	} else {
+		a->port = BigShort( PORT_SERVER );
+	}
+
+	return qtrue;
+}
+
diff --git a/codemp/qcommon/platform.h b/codemp/qcommon/platform.h
new file mode 100644
index 0000000..bb71f02
--- /dev/null
+++ b/codemp/qcommon/platform.h
@@ -0,0 +1,22 @@
+// Simple header file to dispatch to the relevant platform API headers
+#ifndef _PLATFORM_H
+#define _PLATFORM_H
+
+#if defined(_XBOX)
+#include <xtl.h>
+#endif
+
+#if defined(_WINDOWS)
+#include <windows.h>
+#endif
+
+#if defined (__linux__)
+typedef const char *LPCTSTR;
+typedef const char *LPCSTR;
+typedef unsigned long DWORD;
+typedef unsigned int UINT;
+typedef void* HANDLE;
+typedef DWORD COLORREF;
+typedef unsigned char BYTE;
+#endif 
+#endif
diff --git a/codemp/qcommon/q_math.cpp b/codemp/qcommon/q_math.cpp
new file mode 100644
index 0000000..76f7306
--- /dev/null
+++ b/codemp/qcommon/q_math.cpp
@@ -0,0 +1,4 @@
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+#include "../game/q_math.c"
diff --git a/codemp/qcommon/q_shared.cpp b/codemp/qcommon/q_shared.cpp
new file mode 100644
index 0000000..7e0cb1f
--- /dev/null
+++ b/codemp/qcommon/q_shared.cpp
@@ -0,0 +1,4 @@
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+#include "../game/q_shared.c"
diff --git a/codemp/qcommon/qcommon.h b/codemp/qcommon/qcommon.h
new file mode 100644
index 0000000..d53b858
--- /dev/null
+++ b/codemp/qcommon/qcommon.h
@@ -0,0 +1,1132 @@
+// qcommon.h -- definitions common between client and server, but not game.or ref modules
+#ifndef _QCOMMON_H_
+#define _QCOMMON_H_
+
+#include "../qcommon/cm_public.h"
+#include "../game/q_shared.h"
+
+//#define	PRE_RELEASE_DEMO
+
+//#define		USE_CD_KEY
+
+//============================================================================
+
+//
+// msg.c
+//
+typedef struct {
+	qboolean	allowoverflow;	// if false, do a Com_Error
+	qboolean	overflowed;		// set to true if the buffer size failed (with allowoverflow set)
+	qboolean	oob;			// set to true if the buffer size failed (with allowoverflow set)
+	byte	*data;
+	int		maxsize;
+	int		cursize;
+	int		readcount;
+	int		bit;				// for bitwise reads and writes
+} msg_t;
+
+void MSG_Init (msg_t *buf, byte *data, int length);
+void MSG_InitOOB( msg_t *buf, byte *data, int length );
+void MSG_Clear (msg_t *buf);
+void MSG_WriteData (msg_t *buf, const void *data, int length);
+void MSG_Bitstream( msg_t *buf );
+
+
+struct usercmd_s;
+struct entityState_s;
+struct playerState_s;
+
+void MSG_WriteBits( msg_t *msg, int value, int bits );
+
+void MSG_WriteChar (msg_t *sb, int c);
+void MSG_WriteByte (msg_t *sb, int c);
+void MSG_WriteShort (msg_t *sb, int c);
+void MSG_WriteLong (msg_t *sb, int c);
+void MSG_WriteFloat (msg_t *sb, float f);
+void MSG_WriteString (msg_t *sb, const char *s);
+void MSG_WriteBigString (msg_t *sb, const char *s);
+void MSG_WriteAngle16 (msg_t *sb, float f);
+
+void	MSG_BeginReading (msg_t *sb);
+void	MSG_BeginReadingOOB(msg_t *sb);
+
+int		MSG_ReadBits( msg_t *msg, int bits );
+
+int		MSG_ReadChar (msg_t *sb);
+int		MSG_ReadByte (msg_t *sb);
+int		MSG_ReadShort (msg_t *sb);
+int		MSG_ReadLong (msg_t *sb);
+float	MSG_ReadFloat (msg_t *sb);
+char	*MSG_ReadString (msg_t *sb);
+char	*MSG_ReadBigString (msg_t *sb);
+char	*MSG_ReadStringLine (msg_t *sb);
+float	MSG_ReadAngle16 (msg_t *sb);
+void	MSG_ReadData (msg_t *sb, void *buffer, int size);
+
+
+void MSG_WriteDeltaUsercmd( msg_t *msg, struct usercmd_s *from, struct usercmd_s *to );
+void MSG_ReadDeltaUsercmd( msg_t *msg, struct usercmd_s *from, struct usercmd_s *to );
+
+void MSG_WriteDeltaUsercmdKey( msg_t *msg, int key, usercmd_t *from, usercmd_t *to );
+void MSG_ReadDeltaUsercmdKey( msg_t *msg, int key, usercmd_t *from, usercmd_t *to );
+
+void MSG_WriteDeltaEntity( msg_t *msg, struct entityState_s *from, struct entityState_s *to
+						   , qboolean force );
+void MSG_ReadDeltaEntity( msg_t *msg, entityState_t *from, entityState_t *to, 
+						 int number );
+
+#ifdef _ONEBIT_COMBO
+void MSG_WriteDeltaPlayerstate( msg_t *msg, struct playerState_s *from, struct playerState_s *to, int *bitComboDelta, int *bitNumDelta, qboolean isVehiclePS = qfalse );
+#else
+void MSG_WriteDeltaPlayerstate( msg_t *msg, struct playerState_s *from, struct playerState_s *to, qboolean isVehiclePS = qfalse );
+#endif
+void MSG_ReadDeltaPlayerstate( msg_t *msg, struct playerState_s *from, struct playerState_s *to, qboolean isVehiclePS = qfalse );
+
+
+void MSG_ReportChangeVectors_f( void );
+
+//============================================================================
+
+/*
+==============================================================
+
+NET
+
+==============================================================
+*/
+
+#define	PACKET_BACKUP	32	// number of old messages that must be kept on client and
+							// server for delta comrpession and ping estimation
+#define	PACKET_MASK		(PACKET_BACKUP-1)
+
+#define	MAX_PACKET_USERCMDS		32		// max number of usercmd_t in a packet
+
+#define	PORT_ANY			-1
+
+#define	MAX_RELIABLE_COMMANDS	128			// max string commands buffered for restransmit
+
+typedef enum {
+	NA_BOT,
+	NA_BAD,					// an address lookup failed
+	NA_LOOPBACK,
+	NA_BROADCAST,
+	NA_IP,
+	NA_IPX,
+	NA_BROADCAST_IPX
+} netadrtype_t;
+
+typedef enum {
+	NS_CLIENT,
+	NS_SERVER
+} netsrc_t;
+
+typedef struct {
+	netadrtype_t	type;
+
+	byte	ip[4];
+	byte	ipx[10];
+
+	unsigned short	port;
+} netadr_t;
+
+void		NET_Init( void );
+void		NET_Shutdown( void );
+void		NET_Restart( void );
+void		NET_Config( qboolean enableNetworking );
+
+void		NET_SendPacket (netsrc_t sock, int length, const void *data, netadr_t to);
+void		QDECL NET_OutOfBandPrint( netsrc_t net_socket, netadr_t adr, const char *format, ...);
+void		QDECL NET_OutOfBandData( netsrc_t sock, netadr_t adr, byte *format, int len );
+
+qboolean	NET_CompareAdr (netadr_t a, netadr_t b);
+qboolean	NET_CompareBaseAdr (netadr_t a, netadr_t b);
+qboolean	NET_IsLocalAddress (netadr_t adr);
+const char	*NET_AdrToString (netadr_t a);
+qboolean	NET_StringToAdr ( const char *s, netadr_t *a);
+qboolean	NET_GetLoopPacket (netsrc_t sock, netadr_t *net_from, msg_t *net_message);
+void		NET_Sleep(int msec);
+
+
+#define	MAX_MSGLEN				49152		// max length of a message, which may
+											// be fragmented into multiple packets
+
+//rww - 6/28/02 - Changed from 16384 to match sof2's. This does seem rather huge, but I guess it doesn't really hurt anything.
+
+#define MAX_DOWNLOAD_WINDOW			8		// max of eight download frames
+#define MAX_DOWNLOAD_BLKSIZE		2048	// 2048 byte block chunks
+ 
+
+/*
+Netchan handles packet fragmentation and out of order / duplicate suppression
+*/
+
+typedef struct {
+	netsrc_t	sock;
+
+	int			dropped;			// between last packet and previous
+
+	netadr_t	remoteAddress;
+	int			qport;				// qport value to write when transmitting
+
+	// sequencing variables
+	int			incomingSequence;
+	int			outgoingSequence;
+
+	// incoming fragment assembly buffer
+	int			fragmentSequence;
+	int			fragmentLength;	
+	byte		fragmentBuffer[MAX_MSGLEN];
+
+	// outgoing fragment buffer
+	// we need to space out the sending of large fragmented messages
+	qboolean	unsentFragments;
+	int			unsentFragmentStart;
+	int			unsentLength;
+	byte		unsentBuffer[MAX_MSGLEN];
+} netchan_t;
+
+void Netchan_Init( int qport );
+void Netchan_Setup( netsrc_t sock, netchan_t *chan, netadr_t adr, int qport );
+
+void Netchan_Transmit( netchan_t *chan, int length, const byte *data );
+void Netchan_TransmitNextFragment( netchan_t *chan );
+
+qboolean Netchan_Process( netchan_t *chan, msg_t *msg );
+
+
+/*
+==============================================================
+
+PROTOCOL
+
+==============================================================
+*/
+
+#define	PROTOCOL_VERSION	25
+
+#ifndef _XBOX	// No gethostbyname(), and can't really use this stuff
+#define	UPDATE_SERVER_NAME		"updatejk3.ravensoft.com"
+#define MASTER_SERVER_NAME		"masterjk3.ravensoft.com"
+
+#ifdef USE_CD_KEY
+#define	AUTHORIZE_SERVER_NAME	"authorizejk3.ravensoft.com"
+#endif
+#endif	// _XBOX
+
+#ifdef _XBOX	// Use port number 1000 for less bandwidth!
+#define	PORT_SERVER			1000
+#define NUM_SERVER_PORTS	1
+#else
+#define	PORT_MASTER			29060
+#define	PORT_UPDATE			29061
+//#define	PORT_AUTHORIZE		29062
+#define	PORT_SERVER			29070	//...+9 more for multiple servers
+#define	NUM_SERVER_PORTS	4		// broadcast scan this many ports after
+									// PORT_SERVER so a single machine can
+									// run multiple servers
+#endif
+
+// the svc_strings[] array in cl_parse.c should mirror this
+//
+// server to client
+//
+enum svc_ops_e {
+	svc_bad,
+	svc_nop,
+	svc_gamestate,
+	svc_configstring,			// [short] [string] only in gamestate messages
+	svc_baseline,				// only in gamestate messages
+	svc_serverCommand,			// [string] to be executed by client game module
+	svc_download,				// [short] size [size bytes]
+	svc_snapshot,
+	svc_setgame,
+	svc_mapchange,
+#ifdef _XBOX
+	svc_newpeer,				//jsw//inform current clients about new player
+	svc_removepeer,				//jsw//inform current clients about dying player
+	svc_xbInfo,					//jsw//update client with current server xbOnlineInfo
+#endif
+	svc_EOF
+};
+
+
+//
+// client to server
+//
+enum clc_ops_e {
+	clc_bad,
+	clc_nop, 		
+	clc_move,				// [[usercmd_t]
+	clc_moveNoDelta,		// [[usercmd_t]
+	clc_clientCommand,		// [string] message
+	clc_EOF
+};
+
+/*
+==============================================================
+
+VIRTUAL MACHINE
+
+==============================================================
+*/
+
+typedef struct vm_s vm_t;
+
+typedef enum {
+	VMI_NATIVE,
+	VMI_BYTECODE,
+	VMI_COMPILED
+} vmInterpret_t;
+
+typedef enum {
+	TRAP_MEMSET = 100,
+	TRAP_MEMCPY,
+	TRAP_STRNCPY,
+	TRAP_SIN,
+	TRAP_COS,
+	TRAP_ATAN2,
+	TRAP_SQRT,
+	TRAP_MATRIXMULTIPLY,
+	TRAP_ANGLEVECTORS,
+	TRAP_PERPENDICULARVECTOR,
+	TRAP_FLOOR,
+	TRAP_CEIL,
+
+	TRAP_TESTPRINTINT,
+	TRAP_TESTPRINTFLOAT,
+
+	TRAP_ACOS,
+	TRAP_ASIN
+} sharedTraps_t;
+
+void	VM_Init( void );
+vm_t	*VM_Create( const char *module, int (*systemCalls)(int *), 
+				   vmInterpret_t interpret );
+// module should be bare: "cgame", not "cgame.dll" or "vm/cgame.qvm"
+
+void	VM_Free( vm_t *vm );
+void	VM_Clear(void);
+vm_t	*VM_Restart( vm_t *vm );
+
+int		QDECL VM_Call( vm_t *vm, int callNum, ... );
+
+void	VM_Debug( int level );
+
+void	VM_Shifted_Alloc(void **ptr, int size);
+void	VM_Shifted_Free(void **ptr);
+
+void	*VM_ArgPtr( int intValue );
+void	*VM_ExplicitArgPtr( vm_t *vm, int intValue );
+
+/*
+==============================================================
+
+CMD
+
+Command text buffering and command execution
+
+==============================================================
+*/
+
+/*
+
+Any number of commands can be added in a frame, from several different sources.
+Most commands come from either keybindings or console line input, but entire text
+files can be execed.
+
+*/
+
+void Cbuf_Init (void);
+// allocates an initial text buffer that will grow as needed
+
+void Cbuf_AddText( const char *text );
+// Adds command text at the end of the buffer, does NOT add a final \n
+
+void Cbuf_ExecuteText( int exec_when, const char *text );
+// this can be used in place of either Cbuf_AddText or Cbuf_InsertText
+
+void Cbuf_Execute (void);
+// Pulls off \n terminated lines of text from the command buffer and sends
+// them through Cmd_ExecuteString.  Stops when the buffer is empty.
+// Normally called once per frame, but may be explicitly invoked.
+// Do not call inside a command function, or current args will be destroyed.
+
+//===========================================================================
+
+/*
+
+Command execution takes a null terminated string, breaks it into tokens,
+then searches for a command or variable that matches the first token.
+
+*/
+
+typedef void (*xcommand_t) (void);
+
+void	Cmd_Init (void);
+
+void	Cmd_AddCommand( const char *cmd_name, xcommand_t function );
+// called by the init functions of other parts of the program to
+// register commands and functions to call for them.
+// The cmd_name is referenced later, so it should not be in temp memory
+// if function is NULL, the command will be forwarded to the server
+// as a clc_clientCommand instead of executed locally
+
+void	Cmd_RemoveCommand( const char *cmd_name );
+
+void	Cmd_CommandCompletion( void(*callback)(const char *s) );
+// callback with each valid string
+
+int		Cmd_Argc (void);
+char	*Cmd_Argv (int arg);
+void	Cmd_ArgvBuffer( int arg, char *buffer, int bufferLength );
+char	*Cmd_Args (void);
+char	*Cmd_ArgsFrom( int arg );
+void	Cmd_ArgsBuffer( char *buffer, int bufferLength );
+// The functions that execute commands get their parameters with these
+// functions. Cmd_Argv () will return an empty string, not a NULL
+// if arg > argc, so string operations are allways safe.
+
+void	Cmd_TokenizeString( const char *text );
+// Takes a null terminated string.  Does not need to be /n terminated.
+// breaks the string up into arg tokens.
+
+void	Cmd_ExecuteString( const char *text );
+// Parses a single line of text into arguments and tries to execute it
+// as if it was typed at the console
+
+
+/*
+==============================================================
+
+CVAR
+
+==============================================================
+*/
+
+/*
+
+cvar_t variables are used to hold scalar or string variables that can be changed
+or displayed at the console or prog code as well as accessed directly
+in C code.
+
+The user can access cvars from the console in three ways:
+r_draworder			prints the current value
+r_draworder 0		sets the current value to 0
+set r_draworder 0	as above, but creates the cvar if not present
+
+Cvars are restricted from having the same names as commands to keep this
+interface from being ambiguous.
+
+The are also occasionally used to communicated information between different
+modules of the program.
+
+*/
+
+cvar_t *Cvar_Get( const char *var_name, const char *value, int flags );
+// creates the variable if it doesn't exist, or returns the existing one
+// if it exists, the value will not be changed, but flags will be ORed in
+// that allows variables to be unarchived without needing bitflags
+// if value is "", the value will not override a previously set value.
+
+void	Cvar_Register( vmCvar_t *vmCvar, const char *varName, const char *defaultValue, int flags );
+// basically a slightly modified Cvar_Get for the interpreted modules
+
+void	Cvar_Update( vmCvar_t *vmCvar );
+// updates an interpreted modules' version of a cvar
+
+void 	Cvar_Set( const char *var_name, const char *value );
+// will create the variable with no flags if it doesn't exist
+
+void Cvar_SetLatched( const char *var_name, const char *value);
+// don't set the cvar immediately
+
+void	Cvar_SetValue( const char *var_name, float value );
+// expands value to a string and calls Cvar_Set
+
+float	Cvar_VariableValue( const char *var_name );
+int		Cvar_VariableIntegerValue( const char *var_name );
+// returns 0 if not defined or non numeric
+
+char	*Cvar_VariableString( const char *var_name );
+void	Cvar_VariableStringBuffer( const char *var_name, char *buffer, int bufsize );
+// returns an empty string if not defined
+
+void	Cvar_CommandCompletion( void(*callback)(const char *s) );
+// callback with each valid string
+
+void 	Cvar_Reset( const char *var_name );
+
+void	Cvar_SetCheatState( void );
+// reset all testing vars to a safe value
+
+qboolean Cvar_Command( void );
+// called by Cmd_ExecuteString when Cmd_Argv(0) doesn't match a known
+// command.  Returns true if the command was a variable reference that
+// was handled. (print or change)
+
+void 	Cvar_WriteVariables( fileHandle_t f );
+// writes lines containing "set variable value" for all variables
+// with the archive flag set to true.
+
+void	Cvar_Init( void );
+
+char	*Cvar_InfoString( int bit );
+char	*Cvar_InfoString_Big( int bit );
+// returns an info string containing all the cvars that have the given bit set
+// in their flags ( CVAR_USERINFO, CVAR_SERVERINFO, CVAR_SYSTEMINFO, etc )
+void	Cvar_InfoStringBuffer( int bit, char *buff, int buffsize );
+
+void	Cvar_Restart_f( void );
+
+extern	int			cvar_modifiedFlags;
+// whenever a cvar is modifed, its flags will be OR'd into this, so
+// a single check can determine if any CVAR_USERINFO, CVAR_SERVERINFO,
+// etc, variables have been modified since the last check.  The bit
+// can then be cleared to allow another change detection.
+
+/*
+==============================================================
+
+FILESYSTEM
+
+No stdio calls should be used by any part of the game, because
+we need to deal with all sorts of directory and seperator char
+issues.
+==============================================================
+*/
+
+// referenced flags
+// these are in loop specific order so don't change the order
+#define FS_GENERAL_REF	0x01
+#define FS_UI_REF		0x02
+#define FS_CGAME_REF	0x04
+#define FS_QAGAME_REF	0x08
+// number of id paks that will never be autodownloaded from base
+#define NUM_ID_PAKS		9
+
+#ifdef _XBOX
+#define MAX_FILE_HANDLES	16
+#else
+#define	MAX_FILE_HANDLES	64
+#endif
+
+qboolean FS_Initialized();
+
+void	FS_InitFilesystem (void);
+void	FS_Shutdown( qboolean closemfp );
+
+qboolean	FS_ConditionalRestart( int checksumFeed );
+void	FS_Restart( int checksumFeed );
+// shutdown and restart the filesystem so changes to fs_gamedir can take effect
+
+char	**FS_ListFiles( const char *directory, const char *extension, int *numfiles );
+// directory should not have either a leading or trailing /
+// if extension is "/", only subdirectories will be returned
+// the returned files will not include any directories or /
+
+void	FS_FreeFileList( char **fileList );
+//rwwRMG - changed to fileList to not conflict with list type
+
+qboolean FS_FileExists( const char *file );
+
+int		FS_LoadStack();
+
+int		FS_GetFileList(  const char *path, const char *extension, char *listbuf, int bufsize );
+int		FS_GetModList(  char *listbuf, int bufsize );
+
+fileHandle_t	FS_FOpenFileWrite( const char *qpath );
+// will properly create any needed paths and deal with seperater character issues
+
+int		FS_filelength( fileHandle_t f );
+fileHandle_t FS_SV_FOpenFileWrite( const char *filename );
+int		FS_SV_FOpenFileRead( const char *filename, fileHandle_t *fp );
+void	FS_SV_Rename( const char *from, const char *to );
+int		FS_FOpenFileRead( const char *qpath, fileHandle_t *file, qboolean uniqueFILE );
+// if uniqueFILE is true, then a new FILE will be fopened even if the file
+// is found in an already open pak file.  If uniqueFILE is false, you must call
+// FS_FCloseFile instead of fclose, otherwise the pak FILE would be improperly closed
+// It is generally safe to always set uniqueFILE to true, because the majority of
+// file IO goes through FS_ReadFile, which Does The Right Thing already.
+
+int		FS_FileIsInPAK(const char *filename, int *pChecksum );
+// returns 1 if a file is in the PAK file, otherwise -1
+
+int		FS_Write( const void *buffer, int len, fileHandle_t f );
+
+int		FS_Read2( void *buffer, int len, fileHandle_t f );
+int		FS_Read( void *buffer, int len, fileHandle_t f );
+// properly handles partial reads and reads from other dlls
+
+void	FS_FCloseFile( fileHandle_t f );
+// note: you can't just fclose from another DLL, due to MS libc issues
+
+int		FS_ReadFile( const char *qpath, void **buffer );
+// returns the length of the file
+// a null buffer will just return the file length without loading
+// as a quick check for existance. -1 length == not present
+// A 0 byte will always be appended at the end, so string ops are safe.
+// the buffer should be considered read-only, because it may be cached
+// for other uses.
+
+void	FS_ForceFlush( fileHandle_t f );
+// forces flush on files we're writing to.
+
+void	FS_FreeFile( void *buffer );
+// frees the memory returned by FS_ReadFile
+
+void	FS_WriteFile( const char *qpath, const void *buffer, int size );
+// writes a complete file, creating any subdirectories needed
+
+int		FS_filelength( fileHandle_t f );
+// doesn't work for files that are opened from a pack file
+
+int		FS_FTell( fileHandle_t f );
+// where are we?
+
+void	FS_Flush( fileHandle_t f );
+
+void 	QDECL FS_Printf( fileHandle_t f, const char *fmt, ... );
+// like fprintf
+
+int		FS_FOpenFileByMode( const char *qpath, fileHandle_t *f, fsMode_t mode );
+// opens a file for reading, writing, or appending depending on the value of mode
+
+int		FS_Seek( fileHandle_t f, long offset, int origin );
+// seek on a file (doesn't work for zip files!!!!!!!!)
+
+qboolean FS_FilenameCompare( const char *s1, const char *s2 );
+
+const char *FS_GamePureChecksum( void );
+// Returns the checksum of the pk3 from which the server loaded the qagame.qvm
+
+const char *FS_LoadedPakNames( void );
+const char *FS_LoadedPakChecksums( void );
+const char *FS_LoadedPakPureChecksums( void );
+// Returns a space separated string containing the checksums of all loaded pk3 files.
+// Servers with sv_pure set will get this string and pass it to clients.
+
+const char *FS_ReferencedPakNames( void );
+const char *FS_ReferencedPakChecksums( void );
+const char *FS_ReferencedPakPureChecksums( void );
+// Returns a space separated string containing the checksums of all loaded 
+// AND referenced pk3 files. Servers with sv_pure set will get this string 
+// back from clients for pure validation 
+
+void FS_ClearPakReferences( int flags );
+// clears referenced booleans on loaded pk3s
+
+void FS_PureServerSetReferencedPaks( const char *pakSums, const char *pakNames );
+void FS_PureServerSetLoadedPaks( const char *pakSums, const char *pakNames );
+// If the string is empty, all data sources will be allowed.
+// If not empty, only pk3 files that match one of the space
+// separated checksums will be checked for files, with the
+// sole exception of .cfg files.
+
+qboolean FS_idPak( char *pak, char *base );
+qboolean FS_ComparePaks( char *neededpaks, int len, qboolean dlstring );
+void FS_Rename( const char *from, const char *to );
+
+/*
+==============================================================
+
+MISC
+
+==============================================================
+*/
+
+// NOTE NOTE NOTE!!!!!!!!!!!!!
+//
+// Any CPUID_XXXX defined as higher than CPUID_INTEL_MMX *must* have MMX support (eg like CPUID_AMD_3DNOW (0x30) has),
+//	this allows convenient MMX capability checking. If you for some reason want to support some new processor that does
+//	*NOT* have MMX (yeah, right), then define it as a lower number. -slc
+//
+// ( These values are returned by Sys_GetProcessorId )
+//
+#define CPUID_GENERIC			0			// any unrecognized processor
+
+#define CPUID_AXP				0x10
+
+#define CPUID_INTEL_UNSUPPORTED	0x20			// Intel 386/486
+#define CPUID_INTEL_PENTIUM		0x21			// Intel Pentium or PPro
+#define CPUID_INTEL_MMX			0x22			// Intel Pentium/MMX or P2/MMX
+#define CPUID_INTEL_KATMAI		0x23			// Intel Katmai
+#define CPUID_INTEL_WILLIAMETTE	0x24			// Intel Williamette
+
+#define CPUID_AMD_3DNOW			0x30			// AMD K6 3DNOW!
+//
+//==========================================================
+
+#define RoundUp(N, M) ((N) + ((unsigned int)(M)) - (((unsigned int)(N)) % ((unsigned int)(M))))
+#define RoundDown(N, M) ((N) - (((unsigned int)(N)) % ((unsigned int)(M))))
+
+char		*CopyString( const char *in );
+void		Info_Print( const char *s );
+
+void		Com_BeginRedirect (char *buffer, int buffersize, void (*flush)(char *));
+void		Com_EndRedirect( void );
+void 		QDECL Com_Printf( const char *fmt, ... );
+void 		QDECL Com_DPrintf( const char *fmt, ... );
+void		QDECL Com_OPrintf( const char *fmt, ...); // Outputs to the VC / Windows Debug window (only in debug compile)
+void 		QDECL Com_Error( int code, const char *fmt, ... );
+void 		Com_Quit_f( void );
+int			Com_EventLoop( void );
+int			Com_Milliseconds( void );	// will be journaled properly
+unsigned	Com_BlockChecksum( const void *buffer, int length );
+unsigned	Com_BlockChecksumKey (void *buffer, int length, int key);
+int			Com_HashKey(char *string, int maxlen);
+int			Com_Filter(char *filter, char *name, int casesensitive);
+int			Com_FilterPath(char *filter, char *name, int casesensitive);
+int			Com_RealTime(qtime_t *qtime);
+qboolean	Com_SafeMode( void );
+
+void		Com_StartupVariable( const char *match );
+// checks for and removes command line "+set var arg" constructs
+// if match is NULL, all set commands will be executed, otherwise
+// only a set with the exact name.  Only used during startup.
+
+
+extern	cvar_t	*com_developer;
+extern	cvar_t	*com_vmdebug;
+extern	cvar_t	*com_dedicated;
+extern	cvar_t	*com_speeds;
+extern	cvar_t	*com_timescale;
+extern	cvar_t	*com_sv_running;
+extern	cvar_t	*com_cl_running;
+extern	cvar_t	*com_viewlog;			// 0 = hidden, 1 = visible, 2 = minimized
+extern	cvar_t	*com_version;
+extern	cvar_t	*com_blood;
+extern	cvar_t	*com_buildScript;		// for building release pak files
+extern	cvar_t	*com_journal;
+extern	cvar_t	*com_cameraMode;
+
+#ifdef G2_PERFORMANCE_ANALYSIS
+extern	cvar_t	*com_G2Report;
+#endif
+
+extern	cvar_t	*com_RMG;
+
+// both client and server must agree to pause
+extern	cvar_t	*cl_paused;
+extern	cvar_t	*sv_paused;
+
+// com_speeds times
+extern	int		time_game;
+extern	int		time_frontend;
+extern	int		time_backend;		// renderer backend time
+
+extern	int		com_frameTime;
+extern	int		com_frameMsec;
+
+extern	qboolean	com_errorEntered;
+
+
+#ifndef _XBOX
+extern	fileHandle_t	logfile;
+extern	fileHandle_t	com_journalFile;
+extern	fileHandle_t	com_journalDataFile;
+#endif
+
+/*
+typedef enum {
+	TAG_FREE,
+	TAG_GENERAL,
+	TAG_BOTLIB,
+	TAG_RENDERER,
+	TAG_SMALL,
+	TAG_STATIC
+} memtag_t;
+*/
+
+/*
+
+--- low memory ----
+server vm
+server clipmap
+---mark---
+renderer initialization (shaders, etc)
+UI vm
+cgame vm
+renderer map
+renderer models
+
+---free---
+
+temp file loading
+--- high memory ---
+
+*/
+
+#if defined(_DEBUG) && !defined(BSPC)
+	#define DEBUG_ZONE_ALLOCS
+#endif
+
+/*
+#ifdef DEBUG_ZONE_ALLOCS
+	#define Z_TagMalloc(size, tag)			Z_TagMallocDebug(size, tag, #size, __FILE__, __LINE__)
+	#define Z_Malloc(size)					Z_MallocDebug(size, #size, __FILE__, __LINE__)
+	#define S_Malloc(size)					S_MallocDebug(size, #size, __FILE__, __LINE__)
+	void *Z_TagMallocDebug( int size, int tag, char *label, char *file, int line );	// NOT 0 filled memory
+	void *Z_MallocDebug( int size, char *label, char *file, int line );			// returns 0 filled memory
+	void *S_MallocDebug( int size, char *label, char *file, int line );			// returns 0 filled memory
+#else
+	void *Z_TagMalloc( int size, int tag );	// NOT 0 filled memory
+	void *Z_Malloc( int size );			// returns 0 filled memory
+	void *S_Malloc( int size );			// NOT 0 filled memory only for small allocations
+#endif
+void Z_Free( void *ptr );
+void Z_FreeTags( int tag );
+int Z_AvailableMemory( void );
+void Z_LogHeap( void );
+*/
+
+// later on I'll re-implement __FILE__, __LINE__ etc, but for now...
+//
+#ifdef DEBUG_ZONE_ALLOCS
+void *Z_Malloc  ( int iSize, memtag_t eTag, qboolean bZeroit = qfalse, int iAlign = 4);	// return memory NOT zero-filled by default
+void *S_Malloc	( int iSize );					// NOT 0 filled memory only for small allocations
+#else
+void *Z_Malloc  ( int iSize, memtag_t eTag, qboolean bZeroit = qfalse, int iAlign = 4);	// return memory NOT zero-filled by default
+void *S_Malloc	( int iSize );					// NOT 0 filled memory only for small allocations
+#endif
+void  Z_MorphMallocTag( void *pvBuffer, memtag_t eDesiredTag );
+void  Z_Validate( void );
+int   Z_MemSize	( memtag_t eTag );
+void  Z_TagFree	( memtag_t eTag );
+void  Z_Free	( void *ptr );
+int	  Z_Size	( void *pvAddress);
+void Com_InitZoneMemory(void);
+void Com_InitHunkMemory(void);
+void Com_ShutdownZoneMemory(void);
+void Com_ShutdownHunkMemory(void);
+
+void Hunk_Clear( void );
+void Hunk_ClearToMark( void );
+void Hunk_SetMark( void );
+qboolean Hunk_CheckMark( void );
+void Hunk_ClearTempMemory( void );
+void *Hunk_AllocateTempMemory( int size );
+void Hunk_FreeTempMemory( void *buf );
+int	Hunk_MemoryRemaining( void );
+void Hunk_Log( void);
+void Hunk_Trash( void );
+
+void Com_TouchMemory( void );
+
+// commandLine should not include the executable name (argv[0])
+void Com_Init( char *commandLine );
+void Com_Frame( void );
+void Com_Shutdown( void );
+//rwwRMG: Inserted:
+bool Com_ParseTextFile(const char *file, class CGenericParser2 &parser, bool cleanFirst = true);
+CGenericParser2 *Com_ParseTextFile(const char *file, bool cleanFirst, bool writeable);
+void Com_ParseTextFileDestroy(class CGenericParser2 &parser);
+
+
+/*
+==============================================================
+
+CLIENT / SERVER SYSTEMS
+
+==============================================================
+*/
+
+//
+// client interface
+//
+void CL_InitKeyCommands( void );
+// the keyboard binding interface must be setup before execing
+// config files, but the rest of client startup will happen later
+
+void CL_Init( void );
+void CL_Disconnect( qboolean showMainMenu );
+void CL_Shutdown( void );
+void CL_Frame( int msec );
+qboolean CL_GameCommand( void );
+void CL_KeyEvent (int key, qboolean down, unsigned time);
+
+void CL_CharEvent( int key );
+// char events are for field typing, not game control
+
+void CL_MouseEvent( int dx, int dy, int time );
+
+void CL_JoystickEvent( int axis, int value, int time );
+
+void CL_PacketEvent( netadr_t from, msg_t *msg );
+
+void CL_ConsolePrint( const char *text, qboolean silent );
+
+void CL_MapLoading( void );
+// do a screen update before starting to load a map
+// when the server is going to load a new map, the entire hunk
+// will be cleared, so the client must shutdown cgame, ui, and
+// the renderer
+
+void	CL_ForwardCommandToServer( const char *string );
+// adds the current command line as a clc_clientCommand to the client message.
+// things like godmode, noclip, etc, are commands directed to the server,
+// so when they are typed in at the console, they will need to be forwarded.
+
+void CL_ShutdownAll( void );
+// shutdown all the client stuff
+
+void CL_FlushMemory( void );
+// dump all memory on an error
+
+void CL_StartHunkUsers( void );
+// start all the client stuff using the hunk
+
+void Key_WriteBindings( fileHandle_t f );
+// for writing the config files
+
+void S_ClearSoundBuffer( void );
+// call before filesystem access
+
+void SCR_DebugGraph (float value, int color);	// FIXME: move logging to common?
+
+
+//
+// server interface
+//
+void SV_Init( void );
+void SV_Shutdown( char *finalmsg );
+void SV_Frame( int msec );
+void SV_PacketEvent( netadr_t from, msg_t *msg );
+qboolean SV_GameCommand( void );
+
+
+//
+// UI interface
+//
+qboolean UI_GameCommand( void );
+qboolean UI_usesUniqueCDKey();
+
+/*
+==============================================================
+
+NON-PORTABLE SYSTEM SERVICES
+
+==============================================================
+*/
+
+typedef enum {
+	AXIS_SIDE,
+	AXIS_FORWARD,
+	AXIS_UP,
+	AXIS_ROLL,
+	AXIS_YAW,
+	AXIS_PITCH,
+	MAX_JOYSTICK_AXIS
+} joystickAxis_t;
+
+typedef enum {
+  // bk001129 - make sure SE_NONE is zero
+	SE_NONE = 0,	// evTime is still valid
+	SE_KEY,		// evValue is a key code, evValue2 is the down flag
+	SE_CHAR,	// evValue is an ascii char
+	SE_MOUSE,	// evValue and evValue2 are reletive signed x / y moves
+	SE_JOYSTICK_AXIS,	// evValue is an axis number and evValue2 is the current state (-127 to 127)
+	SE_CONSOLE,	// evPtr is a char*
+	SE_PACKET	// evPtr is a netadr_t followed by data bytes to evPtrLength
+} sysEventType_t;
+
+typedef struct {
+	int				evTime;
+	sysEventType_t	evType;
+	int				evValue, evValue2;
+	int				evPtrLength;	// bytes of data pointed to by evPtr, for journaling
+	void			*evPtr;			// this must be manually freed if not NULL
+} sysEvent_t;
+
+sysEvent_t	Sys_GetEvent( void );
+
+void	Sys_Init (void);
+
+// general development dll loading for virtual machine testing
+void	* QDECL Sys_LoadDll( const char *name, int (QDECL **entryPoint)(int, ...),
+				  int (QDECL *systemcalls)(int, ...) );
+void	Sys_UnloadDll( void *dllHandle );
+
+void	Sys_UnloadGame( void );
+void	*Sys_GetGameAPI( void *parms );
+
+void	Sys_UnloadCGame( void );
+void	*Sys_GetCGameAPI( void );
+
+void	Sys_UnloadUI( void );
+void	*Sys_GetUIAPI( void );
+
+//bot libraries
+void	Sys_UnloadBotLib( void );
+void	*Sys_GetBotLibAPI( void *parms );
+
+char	*Sys_GetCurrentUser( void );
+
+void	QDECL Sys_Error( const char *error, ...);
+void	Sys_Quit (void);
+char	*Sys_GetClipboardData( void );	// note that this isn't journaled...
+
+void	Sys_Print( const char *msg );
+#ifdef _XBOX
+void	Sys_Log( const char *file, const char *msg );
+void	Sys_Log( const char *file, const void *buffer, int size, bool flush );
+#endif
+
+// Sys_Milliseconds should only be used for profiling purposes,
+// any game related timing information should come from event timestamps
+int		Sys_Milliseconds (bool baseTime = false);
+
+#if __linux__
+extern "C" void	Sys_SnapVector( float *v );
+
+#else
+void	Sys_SnapVector( float *v );
+#endif
+
+// the system console is shown when a dedicated server is running
+void	Sys_DisplaySystemConsole( qboolean show );
+
+int		Sys_GetProcessorId( void );
+int		Sys_GetCPUSpeed( void );
+int		Sys_GetPhysicalMemory(void);
+
+void	Sys_BeginStreamedFile( fileHandle_t f, int readahead );
+void	Sys_EndStreamedFile( fileHandle_t f );
+int		Sys_StreamedRead( void *buffer, int size, int count, fileHandle_t f );
+void	Sys_StreamSeek( fileHandle_t f, int offset, int origin );
+
+void	Sys_ShowConsole( int level, qboolean quitOnClose );
+void	Sys_SetErrorText( const char *text );
+
+void	Sys_SendPacket( int length, const void *data, netadr_t to );
+#ifdef _XBOX
+void	Sys_SendVoicePacket( int length, const void *data, netadr_t to );
+#endif
+
+qboolean	Sys_StringToAdr( const char *s, netadr_t *a );
+//Does NOT parse port numbers, only base addresses.
+
+qboolean	Sys_IsLANAddress (netadr_t adr);
+void		Sys_ShowIP(void);
+
+qboolean	Sys_CheckCD( void );
+
+void	Sys_Mkdir( const char *path );
+char	*Sys_Cwd( void );
+void	Sys_SetDefaultCDPath(const char *path);
+char	*Sys_DefaultCDPath(void);
+void	Sys_SetDefaultInstallPath(const char *path);
+char	*Sys_DefaultInstallPath(void);
+void     Sys_SetDefaultHomePath(const char *path);
+char	*Sys_DefaultHomePath(void);
+char	*Sys_DefaultBasePath(void);
+
+char **Sys_ListFiles( const char *directory, const char *extension, char *filter, int *numfiles, qboolean wantsubs );
+void	Sys_FreeFileList( char **fileList );
+//rwwRMG - changed to fileList to not conflict with list type
+
+void	Sys_BeginProfiling( void );
+void	Sys_EndProfiling( void );
+
+int Sys_FunctionCmp(void *f1, void *f2);
+int Sys_FunctionCheckSum(void *f1);
+
+qboolean Sys_LowPhysicalMemory();
+unsigned int Sys_ProcessorCount();
+
+int Sys_MonkeyShouldBeSpanked( void );
+
+/* This is based on the Adaptive Huffman algorithm described in Sayood's Data
+ * Compression book.  The ranks are not actually stored, but implicitly defined
+ * by the location of a node within a doubly-linked list */
+
+#define NYT HMAX					/* NYT = Not Yet Transmitted */
+#define INTERNAL_NODE (HMAX+1)
+
+typedef struct nodetype {
+	struct	nodetype *left, *right, *parent; /* tree structure */ 
+	struct	nodetype *next, *prev; /* doubly-linked list */
+	struct	nodetype **head; /* highest ranked node in block */
+	int		weight;
+	int		symbol;
+} node_t;
+
+#define HMAX 256 /* Maximum symbol */
+
+typedef struct {
+	int			blocNode;
+	int			blocPtrs;
+
+	node_t*		tree;
+	node_t*		lhead;
+	node_t*		ltail;
+	node_t*		loc[HMAX+1];
+	node_t**	freelist;
+
+	node_t		nodeList[768];
+	node_t*		nodePtrs[768];
+} huff_t;
+
+typedef struct {
+	huff_t		compressor;
+	huff_t		decompressor;
+} huffman_t;
+
+void	Huff_Compress(msg_t *buf, int offset);
+void	Huff_Decompress(msg_t *buf, int offset);
+void	Huff_Init(huffman_t *huff);
+void	Huff_addRef(huff_t* huff, byte ch);
+int		Huff_Receive (node_t *node, int *ch, byte *fin);
+void	Huff_transmit (huff_t *huff, int ch, byte *fout);
+void	Huff_offsetReceive (node_t *node, int *ch, byte *fin, int *offset);
+void	Huff_offsetTransmit (huff_t *huff, int ch, byte *fout, int *offset);
+void	Huff_putBit( int bit, byte *fout, int *offset);
+int		Huff_getBit( byte *fout, int *offset);
+
+extern huffman_t clientHuffTables;
+
+#define	SV_ENCODE_START		4
+#define SV_DECODE_START		12
+#define	CL_ENCODE_START		12
+#define CL_DECODE_START		4
+
+inline int Round(float value)
+{
+	return((int)floorf(value + 0.5f));
+}
+
+#ifdef _XBOX
+//////////////////////////////
+//
+// Map Lump Loader
+//
+struct Lump
+{
+	void* data;
+	int len;
+	
+	Lump() : data(NULL), len(0) {}
+	~Lump() { clear(); }
+
+	void load(const char* map, const char* lump)
+	{
+		clear();
+
+		char path[MAX_QPATH];
+		Com_sprintf(path, MAX_QPATH, "%s/%s.mle", map, lump);
+
+		len = FS_ReadFile(path, &data);
+		if (len < 0) len = 0;
+	}
+
+	void clear(void)
+	{
+		if (data)
+		{
+			FS_FreeFile(data);
+			data = NULL;
+		}
+	}
+};
+#endif _XBOX
+
+#endif // _QCOMMON_H_
diff --git a/codemp/qcommon/qfiles.h b/codemp/qcommon/qfiles.h
new file mode 100644
index 0000000..4d962f8
--- /dev/null
+++ b/codemp/qcommon/qfiles.h
@@ -0,0 +1,606 @@
+#ifndef __QFILES_H__
+#define __QFILES_H__
+
+//
+// qfiles.h: quake file formats
+// This file must be identical in the quake and utils directories
+//
+
+// surface geometry should not exceed these limits
+#define	SHADER_MAX_VERTEXES	1000
+#define	SHADER_MAX_INDEXES	(6*SHADER_MAX_VERTEXES)
+
+
+// the maximum size of game relative pathnames
+#define	MAX_QPATH		64
+
+/*
+========================================================================
+
+QVM files
+
+========================================================================
+*/
+
+#define	VM_MAGIC	0x12721444
+typedef struct {
+	int		vmMagic;
+
+	int		instructionCount;
+
+	int		codeOffset;
+	int		codeLength;
+
+	int		dataOffset;
+	int		dataLength;
+	int		litLength;			// ( dataLength - litLength ) should be byteswapped on load
+	int		bssLength;			// zero filled memory appended to datalength
+} vmHeader_t;
+
+
+/*
+========================================================================
+
+PCX files are used for 8 bit images
+
+========================================================================
+*/
+
+typedef struct {
+    char	manufacturer;
+    char	version;
+    char	encoding;
+    char	bits_per_pixel;
+    unsigned short	xmin,ymin,xmax,ymax;
+    unsigned short	hres,vres;
+    unsigned char	palette[48];
+    char	reserved;
+    char	color_planes;
+    unsigned short	bytes_per_line;
+    unsigned short	palette_type;
+    char	filler[58];
+    unsigned char	data;			// unbounded
+} pcx_t;
+
+
+/*
+========================================================================
+
+TGA files are used for 24/32 bit images
+
+========================================================================
+*/
+
+typedef struct _TargaHeader {
+	unsigned char 	id_length, colormap_type, image_type;
+	unsigned short	colormap_index, colormap_length;
+	unsigned char	colormap_size;
+	unsigned short	x_origin, y_origin, width, height;
+	unsigned char	pixel_size, attributes;
+} TargaHeader;
+
+
+
+/*
+========================================================================
+
+.MD3 triangle model file format
+
+========================================================================
+*/
+
+#define MD3_IDENT			(('3'<<24)+('P'<<16)+('D'<<8)+'I')
+#define MD3_VERSION			15
+
+// limits
+#define MD3_MAX_LODS		3
+#define	MD3_MAX_TRIANGLES	8192	// per surface
+#define MD3_MAX_VERTS		4096	// per surface
+#define MD3_MAX_SHADERS		256		// per surface
+#define MD3_MAX_FRAMES		1024	// per model
+#define	MD3_MAX_SURFACES	32 + 32	// per model
+#define MD3_MAX_TAGS		16		// per frame
+
+// vertex scales
+#define	MD3_XYZ_SCALE		(1.0/64)
+
+typedef struct md3Frame_s {
+	vec3_t		bounds[2];
+	vec3_t		localOrigin;
+	float		radius;
+	char		name[16];
+} md3Frame_t;
+
+typedef struct md3Tag_s {
+	char		name[MAX_QPATH];	// tag name
+	vec3_t		origin;
+	vec3_t		axis[3];
+} md3Tag_t;
+
+/*
+** md3Surface_t
+**
+** CHUNK			SIZE
+** header			sizeof( md3Surface_t )
+** shaders			sizeof( md3Shader_t ) * numShaders
+** triangles[0]		sizeof( md3Triangle_t ) * numTriangles
+** st				sizeof( md3St_t ) * numVerts
+** XyzNormals		sizeof( md3XyzNormal_t ) * numVerts * numFrames
+*/
+typedef struct {
+	int		ident;				// 
+
+	char	name[MAX_QPATH];	// polyset name
+
+	int		flags;
+	int		numFrames;			// all surfaces in a model should have the same
+
+	int		numShaders;			// all surfaces in a model should have the same
+	int		numVerts;
+
+	int		numTriangles;
+	int		ofsTriangles;
+
+	int		ofsShaders;			// offset from start of md3Surface_t
+	int		ofsSt;				// texture coords are common for all frames
+	int		ofsXyzNormals;		// numVerts * numFrames
+
+	int		ofsEnd;				// next surface follows
+} md3Surface_t;
+
+typedef struct {
+	char			name[MAX_QPATH];
+	int				shaderIndex;	// for in-game use
+} md3Shader_t;
+
+typedef struct {
+	int			indexes[3];
+} md3Triangle_t;
+
+typedef struct {
+	float		st[2];
+} md3St_t;
+
+typedef struct {
+	short		xyz[3];
+	short		normal;
+} md3XyzNormal_t;
+
+typedef struct {
+	int			ident;
+	int			version;
+
+	char		name[MAX_QPATH];	// model name
+
+	int			flags;
+
+	int			numFrames;
+	int			numTags;			
+	int			numSurfaces;
+
+	int			numSkins;
+
+	int			ofsFrames;			// offset for first frame
+	int			ofsTags;			// numFrames * numTags
+	int			ofsSurfaces;		// first surface, others follow
+
+	int			ofsEnd;				// end of file
+} md3Header_t;
+
+
+/*
+==============================================================================
+
+  .BSP file format
+
+==============================================================================
+*/
+
+
+// little-endian "RBSP"
+#define BSP_IDENT				(('P'<<24)+('S'<<16)+('B'<<8)+'R')
+
+#define BSP_VERSION				1
+
+
+// there shouldn't be any problem with increasing these values at the
+// expense of more memory allocation in the utilities
+#define	MAX_MAP_MODELS			0x400
+#define	MAX_MAP_BRUSHES			0x8000
+#define	MAX_MAP_ENTITIES		0x800
+#define	MAX_MAP_ENTSTRING		0x40000
+#define	MAX_MAP_SHADERS			0x400
+
+#define	MAX_MAP_AREAS			0x100	// MAX_MAP_AREA_BYTES in q_shared must match!
+#define	MAX_MAP_FOGS			0x100
+#define	MAX_MAP_PLANES			0x20000
+#define	MAX_MAP_NODES			0x20000
+#define	MAX_MAP_BRUSHSIDES		0x20000
+#define	MAX_MAP_LEAFS			0x20000
+#define	MAX_MAP_LEAFFACES		0x20000
+#define	MAX_MAP_LEAFBRUSHES		0x40000
+#define	MAX_MAP_PORTALS			0x20000
+#define	MAX_MAP_LIGHTING		0x800000
+#define	MAX_MAP_LIGHTGRID		65535
+#define	MAX_MAP_LIGHTGRID_ARRAY	0x100000
+#define	MAX_MAP_VISIBILITY		0x600000
+
+#define	MAX_MAP_DRAW_SURFS	0x20000
+#define	MAX_MAP_DRAW_VERTS	0x80000
+#define	MAX_MAP_DRAW_INDEXES	0x80000
+
+
+// key / value pair sizes in the entities lump
+#define	MAX_KEY				32
+#define	MAX_VALUE			1024
+
+// the editor uses these predefined yaw angles to orient entities up or down
+#define	ANGLE_UP			-1
+#define	ANGLE_DOWN			-2
+
+#define	LIGHTMAP_WIDTH		128
+#define	LIGHTMAP_HEIGHT		128
+
+//=============================================================================
+
+#ifdef _XBOX
+
+#pragma pack(push, 1)
+
+typedef struct {
+	float			mins[3], maxs[3];
+	int				firstSurface;
+	unsigned short	numSurfaces;
+	int				firstBrush;
+	unsigned short	numBrushes;
+} dmodel_t;
+
+typedef struct {
+	char		shader[MAX_QPATH];
+	int			surfaceFlags;
+	int			contentFlags;
+} dshader_t;
+
+// planes x^1 is allways the opposite of plane x
+
+typedef struct {
+	float		normal[3];
+	float		dist;
+} dplane_t;
+
+typedef struct {
+	int				planeNum;
+	short			children[2];	// negative numbers are -(leafs+1), not nodes
+	short			mins[3];		// for frustom culling
+	short			maxs[3];
+} dnode_t;
+
+typedef struct {
+	short			cluster;			// -1 = opaque cluster (do I still store these?)
+	signed char		area;
+
+	short			mins[3];			// for frustum culling
+	short			maxs[3];
+
+	unsigned short	firstLeafSurface;
+	unsigned short	numLeafSurfaces;
+
+	unsigned short	firstLeafBrush;
+	unsigned short	numLeafBrushes;
+} dleaf_t;
+
+typedef struct {
+	int				planeNum;		// positive plane side faces out of the leaf
+	byte			shaderNum;
+} dbrushside_t;
+
+typedef struct {
+	int				firstSide;
+	byte			numSides;
+	unsigned short	shaderNum;		// the shader that determines the contents flags
+} dbrush_t;
+
+typedef struct {
+	char		shader[MAX_QPATH];
+	int			brushNum;
+	int			visibleSide;	// the brush side that ray tests need to clip against (-1 == none)
+} dfog_t;
+
+// Light Style Constants
+#define	MAXLIGHTMAPS	4
+#define LS_NORMAL		0x00
+#define LS_UNUSED		0xfe
+#define	LS_LSNONE		0xff
+#define MAX_LIGHT_STYLES		64
+
+typedef struct {
+	float			lightmap[MAXLIGHTMAPS][2];
+	float			st[2];
+	short			xyz[3];
+	short			normal[3];
+	byte			color[MAXLIGHTMAPS][4];
+} mapVert_t;
+
+#define DRAWVERT_LIGHTMAP_SCALE 32768.0f
+// Change texture coordinates for TriSurfs to be even more fine grain.
+// See below for note about keeping MIN_ST and MAX_ST up to date with
+// ST_SCALE. These are in 4.12. OK, how about 5.11?
+//#define DRAWVERT_ST_SCALE 4096.0f
+#define DRAWVERT_ST_SCALE 2048.0f
+
+// We use a slightly different format for the fixed point texture
+// coords in Grid/Mesh drawverts: 10.6 rather than 12.4
+// To be sure that this is ok, keep the max and min values equal to
+// the largest and smallest whole numbers that can be stored using the
+// format. (ie: Don't change GRID_DRAWVERT_ST_SCALE without changing
+// the other two!) (And don't forget that we're using a bit for sign.)
+#define GRID_DRAWVERT_ST_SCALE 64.0f
+
+typedef struct {
+	vec3_t		xyz;
+	short		dvst[2];
+	short		dvlightmap[MAXLIGHTMAPS][2];
+	vec3_t		normal;
+#ifdef _XBOX
+	vec3_t		tangent;
+#endif
+	byte		dvcolor[MAXLIGHTMAPS][2];
+} drawVert_t;
+
+typedef struct {
+	byte	flags;
+	byte	latLong[2];
+} dgrid_t;
+
+typedef struct {
+	int			code;
+	byte		shaderNum;
+	signed char	fogNum;
+
+	unsigned int	verts;				// high 20 bits are first vert, low 12 are num verts
+	unsigned int	indexes;			// high 20 bits are first index, low 12 are num indices
+
+	byte		lightmapStyles[MAXLIGHTMAPS];
+	byte		lightmapNum[MAXLIGHTMAPS];
+
+	short		lightmapVecs[3];
+} dface_t;
+
+typedef struct {
+	int			code;
+	byte		shaderNum;
+	signed char	fogNum;
+
+	unsigned int	verts;				// high 20 bits are first vert, low 12 are num verts
+
+	byte		lightmapStyles[MAXLIGHTMAPS];
+	byte		lightmapNum[MAXLIGHTMAPS];
+
+	short		lightmapVecs[2][3];		// for patches, [0] and [1] are lodbounds
+
+	byte		patchWidth;
+	byte		patchHeight;
+} dpatch_t;
+
+typedef struct {
+	int			code;
+	byte		shaderNum;
+	signed char	fogNum;
+
+	unsigned int	verts;				// high 20 bits are first vert, low 12 are num verts
+	unsigned int	indexes;			// high 20 bits are first index, low 12 are num indices
+
+	byte		lightmapStyles[MAXLIGHTMAPS];
+} dtrisurf_t;
+
+typedef struct {
+	int				code;
+	byte			shaderNum;
+	signed char     fogNum;
+
+	short			origin[3];
+	short			normal[3];
+	byte			color[3];
+} dflare_t;
+
+#pragma pack(pop)
+
+#else // _XBOX
+
+typedef struct {
+	int		fileofs, filelen;
+} lump_t;
+
+#define	LUMP_ENTITIES		0
+#define	LUMP_SHADERS		1
+#define	LUMP_PLANES			2
+#define	LUMP_NODES			3
+#define	LUMP_LEAFS			4
+#define	LUMP_LEAFSURFACES	5
+#define	LUMP_LEAFBRUSHES	6
+#define	LUMP_MODELS			7
+#define	LUMP_BRUSHES		8
+#define	LUMP_BRUSHSIDES		9
+#define	LUMP_DRAWVERTS		10
+#define	LUMP_DRAWINDEXES	11
+#define	LUMP_FOGS			12
+#define	LUMP_SURFACES		13
+#define	LUMP_LIGHTMAPS		14
+#define	LUMP_LIGHTGRID		15
+#define	LUMP_VISIBILITY		16
+#define LUMP_LIGHTARRAY		17
+#define	HEADER_LUMPS		18
+
+typedef struct {
+	int			ident;
+	int			version;
+
+	lump_t		lumps[HEADER_LUMPS];
+} dheader_t;
+
+typedef struct {
+	float		mins[3], maxs[3];
+	int			firstSurface, numSurfaces;
+	int			firstBrush, numBrushes;
+} dmodel_t;
+
+typedef struct {
+	char		shader[MAX_QPATH];
+	int			surfaceFlags;
+	int			contentFlags;
+} dshader_t;
+
+// planes x^1 is allways the opposite of plane x
+
+typedef struct {
+	float		normal[3];
+	float		dist;
+} dplane_t;
+
+typedef struct {
+	int			planeNum;
+	int			children[2];	// negative numbers are -(leafs+1), not nodes
+	int			mins[3];		// for frustom culling
+	int			maxs[3];
+} dnode_t;
+
+typedef struct {
+	int			cluster;			// -1 = opaque cluster (do I still store these?)
+	int			area;
+
+	int			mins[3];			// for frustum culling
+	int			maxs[3];
+
+	int			firstLeafSurface;
+	int			numLeafSurfaces;
+
+	int			firstLeafBrush;
+	int			numLeafBrushes;
+} dleaf_t;
+
+typedef struct {
+	int			planeNum;			// positive plane side faces out of the leaf
+	int			shaderNum;
+	int			drawSurfNum;
+} dbrushside_t;
+
+typedef struct {
+	int			firstSide;
+	int			numSides;
+	int			shaderNum;		// the shader that determines the contents flags
+} dbrush_t;
+
+typedef struct {
+	char		shader[MAX_QPATH];
+	int			brushNum;
+	int			visibleSide;	// the brush side that ray tests need to clip against (-1 == none)
+} dfog_t;
+
+// Light Style Constants
+#define	MAXLIGHTMAPS	4
+#define LS_NORMAL		0x00
+#define LS_UNUSED		0xfe
+#define	LS_LSNONE		0xff //rww - changed name because it unhappily conflicts with a lightsaber state name and changing this is just easier
+#define MAX_LIGHT_STYLES		64
+
+typedef struct {
+	vec3_t		xyz;
+	float		st[2];
+	float		lightmap[MAXLIGHTMAPS][2];
+	vec3_t		normal;
+	byte		color[MAXLIGHTMAPS][4];
+} mapVert_t;
+
+typedef struct {
+	vec3_t		xyz;
+	float		st[2];
+	float		lightmap[MAXLIGHTMAPS][2];
+	vec3_t		normal;
+	byte		color[MAXLIGHTMAPS][4];
+} drawVert_t;
+
+typedef struct
+{
+	byte		ambientLight[MAXLIGHTMAPS][3];
+	byte		directLight[MAXLIGHTMAPS][3];
+	byte		styles[MAXLIGHTMAPS];
+	byte		latLong[2];
+}  dgrid_t;
+
+typedef enum {
+	MST_BAD,
+	MST_PLANAR,
+	MST_PATCH,
+	MST_TRIANGLE_SOUP,
+	MST_FLARE
+} mapSurfaceType_t;
+
+typedef struct {
+	int			shaderNum;
+	int			fogNum;
+	int			surfaceType;
+
+	int			firstVert;
+	int			numVerts;
+
+	int			firstIndex;
+	int			numIndexes;
+
+	byte		lightmapStyles[MAXLIGHTMAPS], vertexStyles[MAXLIGHTMAPS];
+	int			lightmapNum[MAXLIGHTMAPS];
+	int			lightmapX[MAXLIGHTMAPS], lightmapY[MAXLIGHTMAPS];
+	int			lightmapWidth, lightmapHeight;
+
+	vec3_t		lightmapOrigin;
+	vec3_t		lightmapVecs[3];	// for patches, [0] and [1] are lodbounds
+
+	int			patchWidth;
+	int			patchHeight;
+} dsurface_t;
+
+#endif // _XBOX
+
+/////////////////////////////////////////////////////////////
+//
+// Defines and structures required for fonts
+
+#define GLYPH_COUNT			256
+
+// Must match define in stmparse.h
+#define STYLE_DROPSHADOW	0x80000000
+#define STYLE_BLINK			0x40000000
+#define	SET_MASK			0x00ffffff
+
+typedef struct 
+{
+	short		width;					// number of pixels wide
+	short		height;					// number of scan lines
+	short		horizAdvance;			// number of pixels to advance to the next char
+	short		horizOffset;			// x offset into space to render glyph
+	int			baseline;				// y offset 
+	float		s;						// x start tex coord
+	float		t;						// y start tex coord
+	float		s2;						// x end tex coord
+	float		t2;						// y end tex coord
+} glyphInfo_t;
+
+
+// this file corresponds 1:1 with the "*.fontdat" files, so don't change it unless you're going to
+//	recompile the fontgen util and regenerate all the fonts!
+//
+typedef struct dfontdat_s
+{
+	glyphInfo_t		mGlyphs[GLYPH_COUNT];
+
+	short			mPointSize;
+	short			mHeight;				// max height of font
+	short			mAscender;
+	short			mDescender;
+
+	short			mKoreanHack;
+} dfontdat_t;
+
+/////////////////// fonts end ////////////////////////////////////
+
+
+#endif
diff --git a/codemp/qcommon/sparc.h b/codemp/qcommon/sparc.h
new file mode 100644
index 0000000..19ebeb6
--- /dev/null
+++ b/codemp/qcommon/sparc.h
@@ -0,0 +1,725 @@
+
+/*
+ * UNPUBLISHED -- Rights  reserved  under  the  copyright  laws  of the 
+ * United States.  Use  of a copyright notice is precautionary only and 
+ * does not imply publication or disclosure.                            
+ *                                                                      
+ * THIS DOCUMENTATION CONTAINS CONFIDENTIAL AND PROPRIETARY INFORMATION 
+ * OF    VICARIOUS   VISIONS,  INC.    ANY  DUPLICATION,  MODIFICATION, 
+ * DISTRIBUTION, OR DISCLOSURE IS STRICTLY PROHIBITED WITHOUT THE PRIOR 
+ * EXPRESS WRITTEN PERMISSION OF VICARIOUS VISIONS, INC.
+ */
+
+/*
+
+AUTHOR: Dave Calvin
+CREATED: 2002-05-07
+
+SParse ARray Compressor.  Given an array, this class reduces the memory
+needed to store the array by eliminating the most-frequently used element.
+The remaining elements are increased in size by one integer.
+
+If the compressed data would be larger than the original data, the
+original data is stored as is.
+
+Compression is O(2N) where N is the number of elements to compress.
+
+Decompression is O(log M + N) where M is the number of elements after
+compression (CompressedLength()) and N is the number of elements to decompress.
+Decompression is O(1) when the same or smaller amount of data is requested as
+the last decompression.
+
+The pointer returned by Decompress() is valid until the class is destroyed
+or a new call is made to Compress() or Decompress().
+
+Elements must define operator==, operator!=, and sizeof.
+
+*/
+
+#ifndef __SPARC_H
+#define __SPARC_H
+
+#ifdef _GAMECUBE
+#define SPARC_BIG_ENDIAN
+#endif
+
+//Bigger than a short, smaller than an int.
+#pragma pack(push, 1)
+struct NotSoShort
+{
+	unsigned char bytes[3];
+
+	NotSoShort(void) {}
+
+	NotSoShort(unsigned int source) {
+#ifdef SPARC_BIG_ENDIAN
+		bytes[2] = source & 0xFF;
+		bytes[1] = (source >> 8) & 0xFF;
+		bytes[0] = (source >> 16) & 0xFF;
+#else
+		bytes[0] = source & 0xFF;
+		bytes[1] = (source >> 8) & 0xFF;
+		bytes[2] = (source >> 16) & 0xFF;
+#endif
+	}
+
+	inline unsigned int GetValue(void) {
+#ifdef SPARC_BIG_ENDIAN
+		return (bytes[0] << 16) | (bytes[1] << 8) | bytes[2];
+#else
+		return (bytes[2] << 16) | (bytes[1] << 8) | bytes[0];
+#endif
+	}
+
+	inline bool operator==(unsigned int cmp) {
+#ifdef SPARC_BIG_ENDIAN
+		return cmp == ((*(unsigned int*)bytes) >> 8);
+#else
+		return cmp == ((*(unsigned int*)bytes) & 0x00FFFFFF);
+#endif
+	}
+
+	bool operator<(unsigned int cmp) {
+		unsigned int tmp = *(unsigned int*)bytes;
+#ifdef SPARC_BIG_ENDIAN
+		tmp >>= 8;
+#else
+		tmp &= 0x00FFFFFF;
+#endif
+		return tmp < cmp;
+	}
+
+	bool operator<=(unsigned int cmp) {
+		unsigned int tmp = *(unsigned int*)bytes;
+#ifdef SPARC_BIG_ENDIAN
+		tmp >>= 8;
+#else
+		tmp &= 0x00FFFFFF;
+#endif
+		return tmp <= cmp;
+	}
+
+	bool operator>(unsigned int cmp) {
+		unsigned int tmp = *(unsigned int*)bytes;
+#ifdef SPARC_BIG_ENDIAN
+		tmp >>= 8;
+#else
+		tmp &= 0x00FFFFFF;
+#endif
+		return tmp > cmp;
+	}
+};
+
+//Compressed data is made up of these elements.
+template <class T, class U>
+struct SPARCElement
+{
+	T data;
+	U offset;
+};
+#pragma pack(pop)
+
+
+inline unsigned int SPARC_SWAP32(unsigned int x, bool doSwap) {
+	if (doSwap) {
+		return ((unsigned int)( ( (x & 0xff000000) >> 24)
+			+ ( (x & 0x00ff0000) >> 8 )
+			+ ( (x & 0x0000ff00) << 8 )
+			+ ( (x & 0x000000ff) << 24 ) ));
+	}
+	return x;
+}
+
+inline NotSoShort SPARC_SWAP24(NotSoShort x, bool doSwap) {
+	if (doSwap) {
+		x.bytes[0] ^= x.bytes[2];
+		x.bytes[2] ^= x.bytes[0];
+		x.bytes[0] ^= x.bytes[2];
+	}
+	return x;
+}
+
+inline unsigned short SPARC_SWAP16(unsigned short x, bool doSwap) {
+	if (doSwap) {
+		return ((unsigned short)( ( (x & 0xff00) >> 8)
+			+ ( (x & 0x00ff) << 8 ) ));
+	}
+	return x;
+}
+
+
+//The core of the SPARC system.  T is the data type to be compressed.
+//U is the data type needed to store offsets information in the compressed
+//data.  Smaller U makes for better compression but bigger data requires
+//larger U.
+template <class T, class U>
+class SPARCCore
+{
+private:
+	//Using compression or just storing clear data?
+	bool compressionUsed;
+
+	//Compressed data and its length.
+	SPARCElement<T, U> *compressedData;
+	unsigned int compressedLength;
+
+	//Decompression cache.
+	T *decompressedData;
+	unsigned int decompressedOffset;
+	unsigned int decompressedLength;
+
+	//Element which was removed to compress.
+	T removedElement;
+	
+	//Length of original data before compression.
+	unsigned int originalLength;
+
+	//Memory allocators.
+	void* (*Allocator)(unsigned int size);
+	void (*Deallocator)(void *ptr);
+
+	//Destroy all allocated memory.
+	void Cleanup(void) {
+		if(compressedData) {
+			if(Deallocator) {
+				Deallocator(compressedData);
+			} else {
+				delete [] compressedData;
+			}
+			compressedData = NULL;
+		}
+
+		if(decompressedData) {
+			if(Deallocator) {
+				Deallocator(decompressedData);
+			} else {
+				delete [] decompressedData;
+			}
+			decompressedData = NULL;
+		}
+	}
+
+	void Init(void) {
+		compressionUsed = false;
+		compressedData = NULL;
+		originalLength = 0;
+		compressedLength = 0;
+		decompressedData = NULL;
+		decompressedOffset = 0;
+		decompressedLength = 0;
+	}
+
+
+	//Binary search for the compressed element most closely matching 'offset'.
+	SPARCElement<T, U> *FindDecompStart(unsigned int offset)
+	{
+		unsigned int startPoint = compressedLength / 2;
+		unsigned int divisor = 4;
+		unsigned int leap;
+		while(1) {
+			if(compressedData[startPoint].offset <= offset &&
+					compressedData[startPoint+1].offset > offset) {
+				if(compressedData[startPoint].offset == offset) {
+					return &compressedData[startPoint];
+				} else {
+					return &compressedData[startPoint+1];
+				}
+			}
+
+			leap = compressedLength / divisor;
+			if(leap < 1) {
+				leap = 1;
+			} else {
+				divisor *= 2;
+			}
+			if(compressedData[startPoint].offset > offset) {
+				startPoint -= leap;
+			} else {
+				startPoint += leap;
+			}
+		}
+	}
+
+public:
+	SPARCCore(void) {
+		Init();
+		Allocator = NULL;
+		Deallocator = NULL;
+	}
+
+	~SPARCCore(void) {
+		Cleanup();
+	}
+
+	void SetAllocator(void* (*alloc)(unsigned int size),
+			void (*dealloc)(void *ptr)) {
+		Allocator = alloc;
+		Deallocator = dealloc;
+	}
+
+	//Just store the array without compression.
+	unsigned int Store(const T *array, unsigned int length) {
+		//Destroy old data.
+		Cleanup();
+		Init();
+
+		//Allocate memory and copy array.
+		if(Allocator) {
+			decompressedData = (T*)Allocator(length * sizeof(T));
+		} else {
+			decompressedData = new T[length];
+		}
+		compressedLength = length;
+		memcpy(decompressedData, array, sizeof(T) * length);
+
+		//Set length.
+		originalLength = length;
+
+		return CompressedSize();
+	}
+
+	//Load compressed data directly.
+	unsigned int Load(const char *array, unsigned int length) {
+		//Destroy old data.
+		Cleanup();
+		Init();
+
+		//Restore some attributes.
+		compressionUsed = (bool)*array++;
+
+		assert(sizeof(T) == 1); //For now only support characters.
+		removedElement = *(T*)array;
+		array += sizeof(T);
+
+		originalLength = *(unsigned int*)array;
+		array += sizeof(unsigned int);
+
+		compressedLength = *(unsigned int*)array;
+		array += sizeof(unsigned int);
+
+		//Allocate memory and copy array.
+		if (compressionUsed) {
+			if(Allocator) {
+				compressedData = (SPARCElement<T, U>*)
+					Allocator(compressedLength * sizeof(SPARCElement<T, U>));
+			} else {
+				compressedData = new SPARCElement<T, U>[compressedLength];
+			}
+			memcpy(compressedData, array, 
+				compressedLength * sizeof(SPARCElement<T, U>));
+		}
+		else {
+			if(Allocator) {
+				decompressedData = (T*)Allocator(
+					compressedLength * sizeof(T));
+			} else {
+				decompressedData = new T[compressedLength];
+			}
+			memcpy(decompressedData, array, compressedLength * sizeof(T));
+		}
+
+		return CompressedSize();
+	}
+
+	//Save state for later restoration.
+	unsigned int Save(char *array, unsigned int length, bool doSwap) {
+		//Figure out how much space is needed.
+		unsigned int size = sizeof(char) + sizeof(T) + 
+			sizeof(unsigned int) + sizeof(unsigned int);
+
+		if (compressionUsed) {
+			size += compressedLength * sizeof(SPARCElement<T, U>);
+		}
+		else {
+			size += compressedLength * sizeof(T);
+		}
+		
+		assert(length >= size);
+		
+		//Save some attributes.
+		*array++ = (char)compressionUsed;
+
+		assert(sizeof(T) == 1); //For now only support characters.
+		*(T*)array = removedElement;
+		array += sizeof(T);
+
+		*(unsigned int*)array = SPARC_SWAP32(originalLength, doSwap);
+		array += sizeof(unsigned int);
+
+		*(unsigned int*)array = SPARC_SWAP32(compressedLength, doSwap);
+		array += sizeof(unsigned int);
+
+		//Store compressed data (or uncompressed data if none exists)
+		if (compressionUsed) {
+			for (unsigned int i = 0; i < compressedLength; ++i) {
+				//Copy the data element.  For now only support characters.
+				((SPARCElement<T, U> *)array)[i].data = compressedData[i].data;
+				
+				//Copy the offset to the next unique element.
+				if (sizeof(U) == 1) {
+					((SPARCElement<T, U> *)array)[i].offset = 
+						compressedData[i].offset;
+				}
+				else if (sizeof(U) == 2) {
+					((SPARCElement<T, unsigned short> *)array)[i].offset = 
+						SPARC_SWAP16(*(unsigned short*)&compressedData[i].offset, 
+						doSwap);
+				}
+				else if (sizeof(U) == 3) {
+					((SPARCElement<T, NotSoShort> *)array)[i].offset = 
+						SPARC_SWAP24(*(NotSoShort*)&compressedData[i].offset, 
+						doSwap);
+				}
+				else if (sizeof(U) == 4) {
+					((SPARCElement<T, unsigned int> *)array)[i].offset = 
+						SPARC_SWAP32(*(unsigned int*)&compressedData[i].offset, 
+						doSwap);
+				}
+			}
+		}
+		else {
+			memcpy(array, decompressedData, compressedLength * sizeof(T));
+		}
+
+		return size;
+	}
+
+	//Compresses this array, returns the compressed size.  Compresses
+	//by eliminating the given element.
+	unsigned int Compress(const T *array, unsigned int length, T removal) {
+
+		unsigned int i;
+		unsigned int numRemove = 0;
+		SPARCElement<T, U> *compress;
+
+		//Destroy old data.
+		Cleanup();
+		Init();
+
+		//Count number of elements to remove.  Can't remove first or
+		//last element (prevents boundary conditions).
+		for(i=1; i<length-1; i++) {
+			if(array[i] == removal) {
+				numRemove++;
+			}
+		}
+
+		compressedLength = length - numRemove;
+		originalLength = length;
+
+		//If we're going to allocate more memory than was originally used,
+		//just store the data.
+		if(sizeof(SPARCElement<T, U>) * compressedLength >= 
+				sizeof(T) * length) {
+			Store(array, length);
+			return CompressedSize();
+		}
+
+		//Allocate memory for compressed elements.
+		if(Allocator) {
+			compressedData = (SPARCElement<T, U>*)
+				Allocator(compressedLength * sizeof(SPARCElement<T, U>));
+		} else {
+			compressedData = new SPARCElement<T, U>[compressedLength];
+		}
+		compressionUsed = true;
+
+		//Fill compressed array.  First and last elements go in no matter
+		//what.
+		compressedData[0].data = array[0];
+		compressedData[0].offset = 0;
+		compress = &compressedData[1];
+		for(i=1; i<length-1; i++) {
+			if(array[i] != removal) {
+				compress->data = array[i];
+				compress->offset = i;
+				compress++;
+			}
+		}
+		compress->data = array[i];
+		compress->offset = i;
+
+		//Store removal value for decompression purposes.
+		removedElement = removal;
+
+		//Store original length for bounds checking.
+		originalLength = length;
+
+		//Return the compressed size.
+		return CompressedSize();
+	}
+
+
+	//Get the compressed data size in bytes, or 0 if nothing stored.
+	unsigned int CompressedSize(void) {
+		return compressedLength * sizeof(SPARCElement<T, U>);
+	}
+
+	//Get the decompressed data starting at offset and ending at
+	//offset + length.  Returns NULL on error.
+	const T *Decompress(unsigned int offset, unsigned int length) {
+
+		SPARCElement<T, U> *decomp = NULL;
+		unsigned int i;
+
+		//If data isn't compressed, just return a pointers.
+		if(!compressionUsed) {
+			return decompressedData + offset;
+		}
+		
+		//If last decompression falls within offset and length, just return
+		//a pointer.
+		if(decompressedData && decompressedOffset <= offset &&
+				decompressedOffset + decompressedLength >= offset + length) {
+			return decompressedData + offset - decompressedOffset;
+		}
+
+
+
+		//Allocate new space for decompression if length has changed.
+		if(length != decompressedLength) {
+			//Destroy old data first.
+			if(decompressedData) {
+				if(Deallocator) {
+					Deallocator(decompressedData);
+				} else {
+					delete [] decompressedData;
+				}
+			}
+
+			if(Allocator) {
+				decompressedData = (T*)Allocator(length * sizeof(T));
+			} else {
+				decompressedData = new T[length];
+			}
+		}
+		decompressedOffset = offset;
+		decompressedLength = length;
+
+		//Find position to start decompressing from.
+		decomp = FindDecompStart(offset);
+
+		if(!decomp) { //should never happen
+			assert(0);
+			return NULL;
+		}
+
+		//Decompress the data.
+		for(i=0; i < length; i++) {
+			if(decomp->offset == i + offset) {
+				decompressedData[i] = decomp->data;
+				decomp++;
+			} else {
+				decompressedData[i] = removedElement;
+			}
+		}
+
+		return decompressedData;
+	}
+};
+
+
+//The user-interface to SPARC.  Automatically selects the best core based
+//on data size.
+template <class T>
+class SPARC
+{
+private:
+	void *core;
+	unsigned char offsetBytes;
+
+	//Memory allocators.
+	void* (*Allocator)(unsigned int size);
+	void (*Deallocator)(void *ptr);
+
+public:
+	SPARC(void) {
+		core = NULL;
+		offsetBytes = 0;
+		Allocator = NULL;
+		Deallocator = NULL;
+	}
+
+	~SPARC(void) {
+		Release();
+	};
+
+	void SetAllocator(void* (*alloc)(unsigned int size),
+			void (*dealloc)(void *ptr)) {
+		Allocator = alloc;
+		Deallocator = dealloc;
+	}
+
+	//Select a core, cast it to the right type and return the size.
+	unsigned int CompressedSize(void) {
+		if(!core) {
+			return 0;
+		}
+
+		switch(offsetBytes) {
+		case 1:
+			return ((SPARCCore<T, unsigned char>*)core)->CompressedSize();
+		case 2:
+			return ((SPARCCore<T, unsigned short>*)core)->CompressedSize();
+		case 3:
+			return ((SPARCCore<T, NotSoShort>*)core)->CompressedSize();
+		case 4:
+			return ((SPARCCore<T, unsigned int>*)core)->CompressedSize();
+		}
+
+		return 0;
+	}
+
+	//Always use the same core type since we won't be compressing.
+	unsigned int Store(const T *array, unsigned int length)
+	{
+		Release();
+		offsetBytes = 1;
+		core = new SPARCCore<T, unsigned char>;
+		((SPARCCore<T, unsigned char>*)core)->
+			SetAllocator(Allocator, Deallocator);
+		return ((SPARCCore<T, unsigned char>*)core)-> Store(array, length);
+	}
+
+	//Load compressed data directly.
+	unsigned int Load(const char *array, unsigned int length) {
+		Release();
+
+		offsetBytes = *array++;
+
+		switch (offsetBytes) {
+		case 1:
+			core = new SPARCCore<T, unsigned char>;
+			((SPARCCore<T, unsigned char>*)core)->
+				SetAllocator(Allocator, Deallocator);
+			return ((SPARCCore<T, unsigned char>*)core)->
+				Load(array, length-1);
+		case 2:
+			core = new SPARCCore<T, unsigned short>;
+			((SPARCCore<T, unsigned short>*)core)->
+				SetAllocator(Allocator, Deallocator);
+			return ((SPARCCore<T, unsigned short>*)core)->
+				Load(array, length-1);
+		case 3:
+			core = new SPARCCore<T, NotSoShort>;
+			((SPARCCore<T, NotSoShort>*)core)->
+				SetAllocator(Allocator, Deallocator);
+			return ((SPARCCore<T, NotSoShort>*)core)->
+				Load(array, length-1);
+		case 4:
+			core = new SPARCCore<T, unsigned int>;
+			((SPARCCore<T, unsigned int>*)core)->
+				SetAllocator(Allocator, Deallocator);
+			return ((SPARCCore<T, unsigned int>*)core)->
+				Load(array, length-1);
+		default:
+			assert(false);
+			return 0;
+		}
+	}
+
+	//Save compressed data into array.
+	unsigned int Save(char *array, unsigned int length, bool doSwap) {
+		*array++ = offsetBytes;
+
+		switch (offsetBytes) {
+		case 1:
+			return ((SPARCCore<T, unsigned char>*)core)->
+				Save(array, length-1, doSwap);
+		case 2:
+			return ((SPARCCore<T, unsigned short>*)core)->
+				Save(array, length-1, doSwap);
+		case 3:
+			return ((SPARCCore<T, NotSoShort>*)core)->
+				Save(array, length-1, doSwap);
+		case 4:
+			return ((SPARCCore<T, unsigned int>*)core)->
+				Save(array, length-1, doSwap);
+		default:
+			assert(false);
+			return 0;
+		}
+	}
+
+	//Create the smallest core possible for the given data.
+	unsigned int Compress(const T *array, unsigned int length, T removal) {
+		Release();
+
+		if(length < 256) {
+			offsetBytes = 1;
+			core = new SPARCCore<T, unsigned char>;
+			((SPARCCore<T, unsigned char>*)core)->
+				SetAllocator(Allocator, Deallocator);
+			return ((SPARCCore<T, unsigned char>*)core)->
+				Compress(array, length, removal);
+		} else if(length < 65536) {
+			offsetBytes = 2;
+			core = new SPARCCore<T, unsigned short>;
+			((SPARCCore<T, unsigned short>*)core)->
+				SetAllocator(Allocator, Deallocator);
+			return ((SPARCCore<T, unsigned short>*)core)->
+				Compress(array, length, removal);
+		} else if(length < 16777216) {
+			offsetBytes = 3;
+			core = new SPARCCore<T, NotSoShort>;
+			((SPARCCore<T, NotSoShort>*)core)->
+				SetAllocator(Allocator, Deallocator);
+			return ((SPARCCore<T, NotSoShort>*)core)->
+				Compress(array, length, removal);
+		} else {
+			offsetBytes = 4;
+			core = new SPARCCore<T, unsigned int>;
+			((SPARCCore<T, unsigned int>*)core)->
+				SetAllocator(Allocator, Deallocator);
+			return ((SPARCCore<T, unsigned int>*)core)->
+				Compress(array, length, removal);
+		}
+	}
+
+	//Cast to the correct core type and decompress.
+	const T *Decompress(unsigned int offset, unsigned int length) {
+		if(!core) {
+			return NULL;
+		}
+
+		switch(offsetBytes) {
+		case 1:
+			return ((SPARCCore<T, unsigned char>*)core)->
+				Decompress(offset, length);
+		case 2:
+			return ((SPARCCore<T, unsigned short>*)core)->
+				Decompress(offset, length);
+		case 3:
+			return ((SPARCCore<T, NotSoShort>*)core)->
+				Decompress(offset, length);
+		case 4:
+			return ((SPARCCore<T, unsigned int>*)core)->
+				Decompress(offset, length);
+		}
+
+		return NULL;
+	}
+
+	//Destroy all compressed data and the current decompressed buffer.
+	void Release(void) {
+		if(core) {
+			switch(offsetBytes) {
+			case 1:
+				delete (SPARCCore<T, unsigned char>*)core;
+				break;
+			case 2:
+				delete (SPARCCore<T, unsigned short>*)core;
+				break;
+			case 3:
+				delete (SPARCCore<T, NotSoShort>*)core;
+				break;
+			case 4:
+				delete (SPARCCore<T, unsigned int>*)core;
+				break;
+			}
+			core = NULL;
+		}
+	}
+};
+
+#endif
diff --git a/codemp/qcommon/sstring.h b/codemp/qcommon/sstring.h
new file mode 100644
index 0000000..1b01eca
--- /dev/null
+++ b/codemp/qcommon/sstring.h
@@ -0,0 +1,120 @@
+// Filename:-	sstring.h
+//
+// Gil's string template, used to replace Microsoft's <string> vrsion which doesn't compile under certain stl map<>
+//	conditions...
+
+
+#ifndef SSTRING_H
+#define SSTRING_H
+
+
+template<int MaxSize>
+class sstring
+{
+	struct SStorage
+	{
+		char data[MaxSize];
+	};
+	SStorage mStorage;
+public:
+/* don't figure we need this
+	template<int oMaxSize>
+	sstring(const sstring<oMaxSize> &o)
+	{
+		assert(strlen(o.mStorage.data)<MaxSize);
+		strcpy(mStorage.data,o.mStorage.data);
+	}
+*/	
+	sstring(const sstring<MaxSize> &o)
+	{
+		//strcpy(mStorage.data,o.mStorage.data);
+		Q_strncpyz(mStorage.data,o.mStorage.data,sizeof(mStorage.data));
+	}
+	sstring(const char *s)
+	{
+		//assert(strlen(s)<MaxSize);
+		//strcpy(mStorage.data,s);
+		Q_strncpyz(mStorage.data,s,sizeof(mStorage.data));
+	}
+	sstring()
+	{
+		mStorage.data[0]=0;
+	}
+/* don't figure we need this
+	template<int oMaxSize>
+	sstring<oMaxSize> & operator =(const sstring<oMaxSize> &o)
+	{
+		assert(strlen(o.mStorage.data)<MaxSize);
+		strcpy(mStorage.data,o.mStorage.data);
+		return *this;
+	}
+*/	
+	sstring<MaxSize> & operator=(const sstring<MaxSize> &o)
+	{
+		//strcpy(mStorage.data,o.mStorage.data);
+		Q_strncpyz(mStorage.data,o.mStorage.data,sizeof(mStorage.data));
+		return *this;
+	}
+	sstring<MaxSize> & operator=(const char *s)
+	{
+		assert(strlen(s)<MaxSize);
+		//strcpy(mStorage.data,s);
+		Q_strncpyz(mStorage.data,s,sizeof(mStorage.data));
+		return *this;
+	}
+	char *c_str()
+	{
+		return mStorage.data;
+	}	
+	const char *c_str() const
+	{
+		return mStorage.data;
+	}	
+	int capacity() const
+	{
+		return MaxSize;
+	}
+	int length() const
+	{
+		return strlen(mStorage.data);
+	}
+	bool operator==(const sstring<MaxSize> &o) const
+	{
+		if (!Q_stricmp(mStorage.data,o.mStorage.data))
+		{
+			return true;
+		}
+		return false;
+	}
+	bool operator!=(const sstring<MaxSize> &o) const
+	{
+		if (Q_stricmp(mStorage.data,o.mStorage.data)!=0)
+		{
+			return true;
+		}
+		return false;
+	}
+	bool operator<(const sstring<MaxSize> &o) const
+	{
+		if (Q_stricmp(mStorage.data,o.mStorage.data)<0)
+		{
+			return true;
+		}
+		return false;
+	}
+	bool operator>(const sstring<MaxSize> &o) const
+	{
+		if (Q_stricmp(mStorage.data,o.mStorage.data)>0)
+		{
+			return true;
+		}
+		return false;
+	}
+};
+
+typedef sstring<MAX_QPATH> sstring_t;
+
+#endif	// #ifndef SSTRING_H
+
+/////////////////// eof ////////////////////
+
diff --git a/codemp/qcommon/stringed_ingame.cpp b/codemp/qcommon/stringed_ingame.cpp
new file mode 100644
index 0000000..5e77588
--- /dev/null
+++ b/codemp/qcommon/stringed_ingame.cpp
@@ -0,0 +1,1264 @@
+// Filename:-	stringed_ingame.cpp
+//
+// This file is designed to be pasted into each game project that uses the StringEd package's files.
+//  You can alter the way it does things by (eg) replacing STL with RATL, BUT LEAVE THE OVERALL
+//	FUNCTIONALITY THE SAME, or if I ever make any funadamental changes to the way the package works
+//	then you're going to be SOOL (shit out of luck ;-)...
+//
+
+//////////////////////////////////////////////////
+//
+// stuff common to all qcommon files...
+#include "../server/server.h"
+#include "../game/q_shared.h"
+#include "qcommon.h"
+//
+//////////////////////////////////////////////////
+
+
+#pragma warning ( disable : 4511 )			// copy constructor could not be generated
+#pragma warning ( disable : 4512 )			// assignment operator could not be generated
+#pragma warning ( disable : 4663 )			// C++ language change: blah blah template crap blah blah
+#include "stringed_ingame.h"
+#include "stringed_interface.h"
+
+///////////////////////////////////////////////
+//
+// some STL stuff...
+#pragma warning ( disable : 4786 )			// disable the usual stupid and pointless STL warning
+#include <list>
+#include <map>
+#include <set>
+#include <string>
+#include <vector>
+using namespace std;
+
+typedef vector<string>	vStrings_t;
+typedef vector<int>		vInts_t;
+//
+///////////////////////////////////////////////
+
+cvar_t	*se_language = NULL;
+cvar_t	*se_debug = NULL;
+cvar_t  *sp_leet = NULL;	// kept as 'sp_' for JK2 compat.
+
+#define __DEBUGOUT(_string)	OutputDebugString(_string)
+#define __ASSERT(_blah)		assert(_blah)
+
+typedef struct SE_Entry_s
+{
+	string		m_strString;
+	string		m_strDebug;	// english and/or "#same", used for debugging only. Also prefixed by "SE:" to show which strings go through StringEd (ie aren't hardwired)
+	int			m_iFlags;
+
+	SE_Entry_s()
+	{
+		m_iFlags = 0;
+	}
+
+} SE_Entry_t;
+
+
+typedef map <string, SE_Entry_t> mapStringEntries_t;
+
+class CStringEdPackage
+{
+private:
+
+	SE_BOOL				m_bEndMarkerFound_ParseOnly;
+	string				m_strCurrentEntryRef_ParseOnly;
+	string				m_strCurrentEntryEnglish_ParseOnly;
+	string				m_strCurrentFileRef_ParseOnly;
+	string				m_strLoadingLanguage_ParseOnly;	// eg "german"
+	SE_BOOL				m_bLoadingEnglish_ParseOnly;
+
+public:
+
+	CStringEdPackage()
+	{
+		Clear( SE_FALSE );
+	}
+
+	~CStringEdPackage()
+	{
+		Clear( SE_FALSE );
+	}
+
+	mapStringEntries_t	m_StringEntries;	// needs to be in public space now
+	SE_BOOL				m_bLoadDebug;		// ""
+	//
+	// flag stuff...
+	//
+	vector <string>		m_vstrFlagNames;
+	map	<string,int>	m_mapFlagMasks;
+
+	void	Clear( SE_BOOL bChangingLanguages );
+	void	SetupNewFileParse( LPCSTR psFileName, SE_BOOL bLoadDebug );
+	SE_BOOL	ReadLine( LPCSTR &psParsePos, char *psDest );
+	LPCSTR	ParseLine( LPCSTR psLine );
+	int		GetFlagMask( LPCSTR psFlagName );
+	LPCSTR	ExtractLanguageFromPath( LPCSTR psFileName );
+	SE_BOOL	EndMarkerFoundDuringParse( void )
+	{
+		return m_bEndMarkerFound_ParseOnly;
+	}
+
+private:
+
+	void	AddEntry( LPCSTR psLocalReference );
+	int		GetNumStrings(void);
+	void	SetString( LPCSTR psLocalReference, LPCSTR psNewString, SE_BOOL bEnglishDebug );
+	SE_BOOL	SetReference( int iIndex, LPCSTR psNewString );
+	void	AddFlagReference( LPCSTR psLocalReference, LPCSTR psFlagName );
+	LPCSTR	GetCurrentFileName(void);
+	LPCSTR	GetCurrentReference_ParseOnly( void );
+	SE_BOOL	CheckLineForKeyword( LPCSTR psKeyword, LPCSTR &psLine);
+	LPCSTR	InsideQuotes( LPCSTR psLine );
+	LPCSTR	ConvertCRLiterals_Read( LPCSTR psString );
+	void	REMKill( char *psBuffer );
+	char	*Filename_PathOnly( LPCSTR psFilename );
+	char	*Filename_WithoutPath(LPCSTR psFilename);
+	char	*Filename_WithoutExt(LPCSTR psFilename);
+};
+
+CStringEdPackage TheStringPackage;
+
+
+void CStringEdPackage::Clear( SE_BOOL bChangingLanguages )
+{
+	m_StringEntries.clear();
+
+	if ( !bChangingLanguages )
+	{
+		// if we're changing languages, then I'm going to leave these alone. This is to do with any (potentially) cached
+		//	flag bitmasks on the game side. It shouldn't matter since all files are written out at once using the build
+		//	command in StringEd. But if ever someone changed a file by hand, or added one, or whatever, and it had a 
+		//	different set of flags declared, or the strings were in a different order, then the flags might also change
+		//	the order I see them in, and hence their indexes and masks. This should never happen unless people mess with
+		//	the .STR files by hand and delete some, but this way makes sure it'll all work just in case...
+		//
+		// ie. flags stay defined once they're defined, and only the destructor (at app-end) kills them.
+		//
+		m_vstrFlagNames.clear();
+		m_mapFlagMasks.clear();
+	}
+
+	m_bEndMarkerFound_ParseOnly = SE_FALSE;
+	m_strCurrentEntryRef_ParseOnly = "";
+	m_strCurrentEntryEnglish_ParseOnly = "";
+	//
+	// the other vars are cleared in SetupNewFileParse(), and are ok to not do here.
+	//
+}
+
+
+
+// loses anything after the path (if any), (eg) "dir/name.bmp" becomes "dir"
+// (copes with either slash-scheme for names)
+//
+// (normally I'd call another function for this, but this is supposed to be engine-independant,
+//	 so a certain amount of re-invention of the wheel is to be expected...)
+//
+char *CStringEdPackage::Filename_PathOnly(LPCSTR psFilename)
+{
+	static char sString[ iSE_MAX_FILENAME_LENGTH ];
+
+	strcpy(sString,psFilename);	
+		
+	char *p1= strrchr(sString,'\\');
+	char *p2= strrchr(sString,'/');
+	char *p = (p1>p2)?p1:p2;
+	if (p)
+		*p=0;
+
+	return sString;
+}
+
+
+// returns (eg) "dir/name" for "dir/name.bmp"
+// (copes with either slash-scheme for names)
+//
+// (normally I'd call another function for this, but this is supposed to be engine-independant,
+//	 so a certain amount of re-invention of the wheel is to be expected...)
+//
+char *CStringEdPackage::Filename_WithoutExt(LPCSTR psFilename)
+{
+	static char sString[ iSE_MAX_FILENAME_LENGTH ];
+
+	strcpy(sString,psFilename);
+
+	char *p = strrchr(sString,'.');		
+	char *p2= strrchr(sString,'\\');
+	char *p3= strrchr(sString,'/');
+
+	// special check, make sure the first suffix we found from the end wasn't just a directory suffix (eg on a path'd filename with no extension anyway)
+	//
+	if (p && 
+		(p2==0 || (p2 && p>p2)) &&
+		(p3==0 || (p3 && p>p3))
+		)
+		*p=0;	
+
+	return sString;
+}
+
+// returns actual filename only, no path
+// (copes with either slash-scheme for names)
+//
+// (normally I'd call another function for this, but this is supposed to be engine-independant,
+//	 so a certain amount of re-invention of the wheel is to be expected...)
+//
+char *CStringEdPackage::Filename_WithoutPath(LPCSTR psFilename)
+{
+	static char sString[ iSE_MAX_FILENAME_LENGTH ];
+
+	LPCSTR psCopyPos = psFilename;
+	
+	while (*psFilename)
+	{
+		if (*psFilename == '/' || *psFilename == '\\')
+			psCopyPos = psFilename+1;
+		psFilename++;
+	}
+
+	strcpy(sString,psCopyPos);
+
+	return sString;
+}
+
+
+LPCSTR CStringEdPackage::ExtractLanguageFromPath( LPCSTR psFileName )
+{
+	return Filename_WithoutPath( Filename_PathOnly( psFileName ) );
+}
+
+
+void CStringEdPackage::SetupNewFileParse( LPCSTR psFileName, SE_BOOL bLoadDebug )
+{
+	char sString[ iSE_MAX_FILENAME_LENGTH ];
+
+	strcpy(sString, Filename_WithoutPath( Filename_WithoutExt( psFileName ) ));
+	Q_strupr(sString);
+
+	m_strCurrentFileRef_ParseOnly = sString;	// eg "OBJECTIVES"
+	m_strLoadingLanguage_ParseOnly = ExtractLanguageFromPath( psFileName );
+	m_bLoadingEnglish_ParseOnly = (!stricmp( m_strLoadingLanguage_ParseOnly.c_str(), "english" )) ? SE_TRUE : SE_FALSE;
+	m_bLoadDebug = bLoadDebug;
+}
+
+
+// returns SE_TRUE if supplied keyword found at line start (and advances supplied ptr past any whitespace to next arg (or line end if none),
+//
+//	else returns SE_FALSE...
+//
+SE_BOOL CStringEdPackage::CheckLineForKeyword( LPCSTR psKeyword, LPCSTR &psLine)
+{
+	if (!Q_stricmpn(psKeyword, psLine, strlen(psKeyword)) )
+	{
+		psLine += strlen(psKeyword);
+
+		// skip whitespace to arrive at next item...
+		//
+		while ( *psLine == '\t' || *psLine == ' ' )
+		{
+			psLine++;
+		}
+		return SE_TRUE;
+	}
+
+	return SE_FALSE;
+}
+
+// change "\n" to '\n' (i.e. 2-byte char-string to 1-byte ctrl-code)...
+//  (or "\r\n" in editor)
+//
+LPCSTR CStringEdPackage::ConvertCRLiterals_Read( LPCSTR psString )
+{
+	static string str;
+	str = psString;
+	int iLoc;
+	while ( (iLoc = str.find("\\n")) != -1 )
+	{
+		str[iLoc  ] = '\n';
+		str.erase( iLoc+1,1 );
+	}
+
+	return str.c_str();
+}
+
+
+// kill off any "//" onwards part in the line, but NOT if it's inside a quoted string...
+//
+void CStringEdPackage::REMKill( char *psBuffer )
+{
+	char *psScanPos = psBuffer;
+	char *p;
+	int iDoubleQuotesSoFar = 0;
+
+	// scan forwards in case there are more than one (and the first is inside quotes)...
+	//
+	while ( (p=strstr(psScanPos,"//")) != NULL)
+	{
+		// count the number of double quotes before this point, if odd number, then we're inside quotes...
+		//
+		int iDoubleQuoteCount = iDoubleQuotesSoFar;
+
+		for (int i=0; i<p-psScanPos; i++)
+		{
+			if (psScanPos[i] == '"')
+			{
+				iDoubleQuoteCount++;
+			}
+		}
+		if (!(iDoubleQuoteCount&1))
+		{
+			// not inside quotes, so kill line here...
+			//			
+			*p='\0';
+			//
+			// and remove any trailing whitespace...
+			//
+			if (psScanPos[0])	// any strlen? (else access violation with -1 below)
+			{
+				int iWhiteSpaceScanPos = strlen(psScanPos)-1;
+				while (iWhiteSpaceScanPos>=0 && isspace(psScanPos[iWhiteSpaceScanPos]))
+				{
+					psScanPos[iWhiteSpaceScanPos--] = '\0';
+				}
+			}
+
+			return;
+		}
+		else
+		{
+			// inside quotes (blast), oh well, skip past and keep scanning...
+			//
+			psScanPos = p+1;
+			iDoubleQuotesSoFar = iDoubleQuoteCount;
+		}
+	}
+}
+
+// returns true while new lines available to be read...
+//
+SE_BOOL CStringEdPackage::ReadLine( LPCSTR &psParsePos, char *psDest )
+{
+	if (psParsePos[0])
+	{	
+		LPCSTR psLineEnd = strchr(psParsePos, '\n');
+		if (psLineEnd)
+		{
+			int iCharsToCopy = (psLineEnd - psParsePos);
+			strncpy(psDest, psParsePos, iCharsToCopy);
+					psDest[iCharsToCopy] = '\0';
+			psParsePos += iCharsToCopy;
+			while (*psParsePos && strchr("\r\n",*psParsePos))
+			{
+				psParsePos++;	// skip over CR or CR/LF pairs
+			}
+		}
+		else
+		{
+			// last line...
+			//
+			strcpy(psDest, psParsePos);
+			psParsePos += strlen(psParsePos);
+		}
+
+		// clean up the line...
+		//
+		if (psDest[0])
+		{
+			int iWhiteSpaceScanPos = strlen(psDest)-1;
+			while (iWhiteSpaceScanPos>=0 && isspace(psDest[iWhiteSpaceScanPos]))
+			{
+				psDest[iWhiteSpaceScanPos--] = '\0';
+			}
+
+			REMKill( psDest );
+		}
+		return SE_TRUE;
+	}
+
+	return SE_FALSE;
+}
+
+// remove any outside quotes from this supplied line, plus any leading or trailing whitespace...
+//
+LPCSTR CStringEdPackage::InsideQuotes( LPCSTR psLine )
+{
+	// I *could* replace this string object with a declared array, but wasn't sure how big to leave it, and it'd have to
+	//	be static as well, hence permanent. (problem on consoles?)
+	//
+	static	string	str;
+					str = "";	// do NOT join to above line
+
+	// skip any leading whitespace...
+	//
+	while (*psLine == ' ' || *psLine == '\t')
+	{
+		psLine++;
+	}
+
+	// skip any leading quote...
+	//
+	if (*psLine == '"')
+	{
+		psLine++;
+	}
+
+	// assign it...
+	//
+	str = psLine;
+
+	if (psLine[0])
+	{
+		// lose any trailing whitespace...
+		//
+		while (	str.c_str()[ strlen(str.c_str()) -1 ] == ' ' ||
+				str.c_str()[ strlen(str.c_str()) -1 ] == '\t'
+				)
+		{
+			str.erase( strlen(str.c_str()) -1, 1);
+		}
+
+		// lose any trailing quote...
+		//
+		if (str.c_str()[ strlen(str.c_str()) -1 ] == '"')
+		{
+			str.erase( strlen(str.c_str()) -1, 1);
+		}
+	}
+
+	// and return it...
+	//
+	return str.c_str();
+}
+
+
+// returns flag bitmask (eg 00000010b), else 0 for not found
+//
+int CStringEdPackage::GetFlagMask( LPCSTR psFlagName )
+{
+	map <string, int>::iterator itFlag = m_mapFlagMasks.find( psFlagName );
+	if ( itFlag != m_mapFlagMasks.end() )
+	{
+		int &iMask = (*itFlag).second;
+		return iMask;
+	}
+
+	return 0;
+}
+
+
+void CStringEdPackage::AddFlagReference( LPCSTR psLocalReference, LPCSTR psFlagName )
+{
+	// add the flag to the list of known ones...
+	//
+	int iMask = GetFlagMask( psFlagName );
+	if (iMask == 0)
+	{
+		m_vstrFlagNames.push_back( psFlagName );
+		iMask = 1 << (m_vstrFlagNames.size()-1);
+		m_mapFlagMasks[ psFlagName ] = iMask;
+	}
+	//
+	// then add the reference to this flag to the currently-parsed reference...
+	//
+	mapStringEntries_t::iterator itEntry = m_StringEntries.find( va("%s_%s",m_strCurrentFileRef_ParseOnly.c_str(), psLocalReference) );
+	if (itEntry != m_StringEntries.end())
+	{
+		SE_Entry_t &Entry = (*itEntry).second;
+		Entry.m_iFlags |= iMask;
+	}
+}
+
+// this copes with both foreigners using hi-char values (eg the french using 0x92 instead of 0x27
+//  for a "'" char), as well as the fact that our buggy fontgen program writes out zeroed glyph info for
+//	some fonts anyway (though not all, just as a gotcha).
+//
+// New bit, instead of static buffer (since XBox guys are desperately short of mem) I return a malloc'd buffer now,
+//	so remember to free it!
+//
+static char *CopeWithDumbStringData( LPCSTR psSentence, LPCSTR psThisLanguage )
+{
+	const int iBufferSize = strlen(psSentence)*3;	// *3 to allow for expansion of anything even stupid string consisting entirely of elipsis chars
+	char *psNewString = (char *) Z_Malloc(iBufferSize, TAG_TEMP_WORKSPACE, qfalse);	
+	Q_strncpyz(psNewString, psSentence, iBufferSize);
+
+	// this is annoying, I have to just guess at which languages to do it for (ie NOT ASIAN/MBCS!!!) since the 
+	//	string system was deliberately (and correctly) designed to not know or care whether it was doing SBCS 
+	//	or MBCS languages, because it was never envisioned that I'd have to clean up other people's mess.
+	//
+	// Ok, bollocks to it, this will have to do. Any other languages that come later and have bugs in their text can
+	//	get fixed by them typing it in properly in the first place...
+	//
+	if (!stricmp(psThisLanguage,"ENGLISH") ||
+		!stricmp(psThisLanguage,"FRENCH") ||
+		!stricmp(psThisLanguage,"GERMAN") ||
+		!stricmp(psThisLanguage,"ITALIAN") ||
+		!stricmp(psThisLanguage,"SPANISH") ||
+		!stricmp(psThisLanguage,"POLISH") ||
+		!stricmp(psThisLanguage,"RUSSIAN")
+		)
+	{
+		char *p;
+
+	//	strXLS_Speech.Replace(va("%c",0x92),va("%c",0x27));	// "'"
+		while ((p=strchr(psNewString,0x92))!=NULL)  // "rich" (and illegal) apostrophe
+		{
+			*p = 0x27;
+		}
+
+	//	strXLS_Speech.Replace(va("%c",0x93),"\"");			// smart quotes -> '"'
+		while ((p=strchr(psNewString,0x93))!=NULL)
+		{
+			*p = '"';
+		}
+
+	//	strXLS_Speech.Replace(va("%c",0x94),"\"");			// smart quotes -> '"'
+		while ((p=strchr(psNewString,0x94))!=NULL)
+		{
+			*p = '"';
+		}
+
+	//	strXLS_Speech.Replace(va("%c",0x0B),".");			// full stop
+		while ((p=strchr(psNewString,0x0B))!=NULL)
+		{
+			*p = '.';
+		}
+
+	//	strXLS_Speech.Replace(va("%c",0x85),"...");			// "..."-char ->  3-char "..."
+		while ((p=strchr(psNewString,0x85))!=NULL)  // "rich" (and illegal) apostrophe
+		{			
+			memmove(p+2,p,strlen(p));
+			*p++ = '.';
+			*p++ = '.';
+			*p   = '.';
+		}
+
+	//	strXLS_Speech.Replace(va("%c",0x91),va("%c",0x27));	// "'"
+		while ((p=strchr(psNewString,0x91))!=NULL)
+		{
+			*p = 0x27;
+		}
+
+	//	strXLS_Speech.Replace(va("%c",0x96),va("%c",0x2D));	// "-"
+		while ((p=strchr(psNewString,0x96))!=NULL)
+		{
+			*p = 0x2D;
+		}
+
+	//	strXLS_Speech.Replace(va("%c",0x97),va("%c",0x2D));	// "-"
+		while ((p=strchr(psNewString,0x97))!=NULL)
+		{
+			*p = 0x2D;
+		}
+
+		// bug fix for picky grammatical errors, replace "?." with "? "
+		//
+		while ((p=strstr(psNewString,"?."))!=NULL)
+		{
+			p[1] = ' ';
+		}
+
+		// StripEd and our print code don't support tabs...
+		//
+		while ((p=strchr(psNewString,0x09))!=NULL)
+		{
+			*p = ' ';
+		}
+	}
+
+	return psNewString;
+}
+
+// return is either NULL for good else error message to display...
+//
+LPCSTR CStringEdPackage::ParseLine( LPCSTR psLine )
+{
+	LPCSTR psErrorMessage = NULL;
+
+	if (psLine)
+	{
+		if (CheckLineForKeyword( sSE_KEYWORD_VERSION, psLine ))
+		{
+			// VERSION 	"1"
+			//
+			LPCSTR psVersionNumber = InsideQuotes( psLine );
+			int		iVersionNumber = atoi( psVersionNumber );
+			
+			if (iVersionNumber != iSE_VERSION)
+			{
+				psErrorMessage = va("Unexpected version number %d, expecting %d!\n", iVersionNumber, iSE_VERSION);
+			}
+		}
+		else
+		if (	CheckLineForKeyword(sSE_KEYWORD_CONFIG, psLine)
+			||	CheckLineForKeyword(sSE_KEYWORD_FILENOTES, psLine)
+			||	CheckLineForKeyword(sSE_KEYWORD_NOTES, psLine)
+			)
+		{
+			// not used ingame, but need to absorb the token
+		}
+		else
+		if (CheckLineForKeyword(sSE_KEYWORD_REFERENCE, psLine))
+		{
+			// REFERENCE	GUARD_GOOD_TO_SEE_YOU
+			//
+			LPCSTR psLocalReference = InsideQuotes( psLine );
+			AddEntry( psLocalReference );
+		}
+		else
+		if (CheckLineForKeyword(sSE_KEYWORD_FLAGS, psLine))
+		{
+			// FLAGS 	FLAG_CAPTION FLAG_TYPEMATIC
+			//
+			LPCSTR psReference = GetCurrentReference_ParseOnly();
+			if (psReference[0])
+			{
+				static const char sSeperators[] = " \t";
+				char sFlags[1024]={0};	// 1024 chars should be enough to store 8 flag names
+				strncpy(sFlags, psLine, sizeof(sFlags)-1);
+				char *psToken = strtok( sFlags, sSeperators );
+				while( psToken != NULL )
+				{
+					// psToken = flag name (in caps)
+					//
+					Q_strupr(psToken);	// jic
+					AddFlagReference( psReference, psToken );
+
+					// read next flag for this string...
+					//
+					psToken = strtok( NULL, sSeperators );
+				}
+			}
+			else
+			{
+				psErrorMessage = "Error parsing file: Unexpected \"" sSE_KEYWORD_FLAGS "\"\n";
+			}
+		}
+		else
+		if (CheckLineForKeyword(sSE_KEYWORD_ENDMARKER, psLine))
+		{
+			// ENDMARKER
+			//
+			m_bEndMarkerFound_ParseOnly = SE_TRUE;	// the only major error checking I bother to do (for file truncation)
+		}
+		else
+		if (!Q_stricmpn(sSE_KEYWORD_LANG, psLine, strlen(sSE_KEYWORD_LANG)))
+		{
+			// LANG_ENGLISH 	"GUARD:  Good to see you, sir.  Taylor is waiting for you in the clean tent.  We need to get you suited up.  "
+			//
+			LPCSTR psReference = GetCurrentReference_ParseOnly();
+			if ( psReference[0] )
+			{
+				psLine += strlen(sSE_KEYWORD_LANG);
+
+				// what language is this?...
+				//
+				LPCSTR psWordEnd = psLine;
+				while (*psWordEnd && *psWordEnd != ' ' && *psWordEnd != '\t')
+				{
+					psWordEnd++;
+				}
+				char sThisLanguage[1024]={0};
+				int iCharsToCopy = psWordEnd - psLine;
+				if (iCharsToCopy > sizeof(sThisLanguage)-1)
+				{
+					iCharsToCopy = sizeof(sThisLanguage)-1;
+				}
+				strncpy(sThisLanguage, psLine, iCharsToCopy);	// already declared as {0} so no need to zero-cap dest buffer
+
+				psLine += strlen(sThisLanguage);
+				LPCSTR _psSentence = ConvertCRLiterals_Read( InsideQuotes( psLine ) );
+
+				// Dammit, I hate having to do crap like this just because other people mess up and put
+				//	stupid data in their text, so I have to cope with it. 
+				//
+				// note hackery with _psSentence and psSentence because of const-ness. bleurgh. Just don't ask.
+				//
+				char *psSentence = CopeWithDumbStringData( _psSentence, sThisLanguage );
+
+				if ( m_bLoadingEnglish_ParseOnly )
+				{
+					// if loading just "english", then go ahead and store it...
+					//
+					SetString( psReference, psSentence, SE_FALSE );
+				}
+				else
+				{
+					// if loading a foreign language...
+					//
+					SE_BOOL bSentenceIsEnglish = (!stricmp(sThisLanguage,"english")) ? SE_TRUE: SE_FALSE;	// see whether this is the english master or not
+
+					// this check can be omitted, I'm just being extra careful here...
+					//
+					if ( !bSentenceIsEnglish )
+					{
+						// basically this is just checking that an .STE file override is the same language as the .STR...
+						//
+						if (stricmp( m_strLoadingLanguage_ParseOnly.c_str(), sThisLanguage ))
+						{
+							psErrorMessage = va("Language \"%s\" found when expecting \"%s\"!\n", sThisLanguage, m_strLoadingLanguage_ParseOnly.c_str());
+						}
+					}
+
+					if (!psErrorMessage)
+					{
+						SetString( psReference, psSentence, bSentenceIsEnglish );
+					}
+				}
+
+				Z_Free( psSentence );
+			}
+			else
+			{
+				psErrorMessage = "Error parsing file: Unexpected \"" sSE_KEYWORD_LANG "\"\n";
+			}
+		}
+		else
+		{
+			psErrorMessage = va("Unknown keyword at linestart: \"%s\"\n", psLine);
+		}
+	}
+
+	return psErrorMessage;
+}
+	
+// returns reference of string being parsed, else "" for none.
+//
+LPCSTR CStringEdPackage::GetCurrentReference_ParseOnly( void )
+{
+	return m_strCurrentEntryRef_ParseOnly.c_str();
+}
+	
+// add new string entry (during parse)
+//
+void CStringEdPackage::AddEntry( LPCSTR psLocalReference )
+{
+	// the reason I don't just assign it anyway is because the optional .STE override files don't contain flags, 
+	//	and therefore would wipe out the parsed flags of the .STR file...
+	//
+	mapStringEntries_t::iterator itEntry = m_StringEntries.find( va("%s_%s",m_strCurrentFileRef_ParseOnly.c_str(), psLocalReference) );
+	if (itEntry == m_StringEntries.end())
+	{
+		SE_Entry_t SE_Entry;
+		m_StringEntries[ va("%s_%s", m_strCurrentFileRef_ParseOnly.c_str(), psLocalReference) ] = SE_Entry;
+	}
+	m_strCurrentEntryRef_ParseOnly = psLocalReference;
+}
+
+LPCSTR Leetify( LPCSTR psString )
+{
+	static string str;
+	str = psString;
+	if (sp_leet->integer == 42)	// very specific test, so you won't hit it accidentally
+	{
+		static const
+		char cReplace[]={	'o','0','l','1','e','3','a','4','s','5','t','7','i','!','h','#',
+							'O','0','L','1','E','3','A','4','S','5','T','7','I','!','H','#'	// laziness because of strchr()
+						};
+
+		char *p;
+		for (int i=0; i<sizeof(cReplace); i+=2)
+		{
+			while ((p=strchr(str.c_str(),cReplace[i]))!=NULL)
+				*p = cReplace[i+1];
+		}
+	}
+
+	return str.c_str();
+}
+
+
+void CStringEdPackage::SetString( LPCSTR psLocalReference, LPCSTR psNewString, SE_BOOL bEnglishDebug )
+{
+	mapStringEntries_t::iterator itEntry = m_StringEntries.find( va("%s_%s",m_strCurrentFileRef_ParseOnly.c_str(), psLocalReference) );
+	if (itEntry != m_StringEntries.end())
+	{
+		SE_Entry_t &Entry = (*itEntry).second;
+	
+		if ( bEnglishDebug || m_bLoadingEnglish_ParseOnly)
+		{	
+			// then this is the leading english text of a foreign sentence pair (so it's the debug-key text),
+			//	or it's the only text when it's english being loaded...
+			//
+			Entry.m_strString = Leetify( psNewString );
+			if ( m_bLoadDebug )
+			{
+				Entry.m_strDebug = sSE_DEBUGSTR_PREFIX;
+				Entry.m_strDebug+= /* m_bLoadingEnglish_ParseOnly ? "" : */ psNewString;
+				Entry.m_strDebug+= sSE_DEBUGSTR_SUFFIX;
+			}
+			m_strCurrentEntryEnglish_ParseOnly = psNewString;	// for possible "#same" resolving in foreign later
+		}
+		else
+		{				
+			// then this is foreign text (so check for "#same" resolving)...
+			//
+			if (!stricmp(psNewString, sSE_EXPORT_SAME))
+			{
+				Entry.m_strString = m_strCurrentEntryEnglish_ParseOnly;	// foreign "#same" is now english
+				if (m_bLoadDebug)
+				{
+					Entry.m_strDebug = sSE_DEBUGSTR_PREFIX;
+					Entry.m_strDebug+= sSE_EXPORT_SAME;				// english (debug) is now "#same"
+					Entry.m_strDebug+= sSE_DEBUGSTR_SUFFIX;
+				}
+			}
+			else
+			{
+				Entry.m_strString	= psNewString;							// foreign is just foreign
+			}
+		}
+	}
+	else
+	{
+		__ASSERT(0);	// should never happen
+	}
+}
+
+
+
+// filename is local here, eg:	"strings/german/obj.str"
+//
+// return is either NULL for good else error message to display...
+//
+static LPCSTR SE_Load_Actual( LPCSTR psFileName, SE_BOOL bLoadDebug, SE_BOOL bSpeculativeLoad )
+{
+	LPCSTR psErrorMessage = NULL;
+	
+	unsigned char *psLoadedData = SE_LoadFileData( psFileName );
+	if ( psLoadedData )
+	{
+		// now parse the data...
+		//
+		char *psParsePos = (char *) psLoadedData;
+
+		TheStringPackage.SetupNewFileParse( psFileName, bLoadDebug );
+
+		char sLineBuffer[16384];	// should be enough for one line of text (some of them can be BIG though)
+		while ( !psErrorMessage && TheStringPackage.ReadLine((LPCSTR &) psParsePos, sLineBuffer ) )
+		{
+			if (strlen(sLineBuffer))
+			{
+//				__DEBUGOUT( sLineBuffer );
+//				__DEBUGOUT( "\n" );
+
+				psErrorMessage = TheStringPackage.ParseLine( sLineBuffer );
+			}
+		}
+
+		SE_FreeFileDataAfterLoad( psLoadedData);
+		
+		if (!psErrorMessage && !TheStringPackage.EndMarkerFoundDuringParse())
+		{
+			psErrorMessage = va("Truncated file, failed to find \"%s\" at file end!", sSE_KEYWORD_ENDMARKER);
+		}
+	}
+	else
+	{
+		if ( bSpeculativeLoad )
+		{
+			// then it's ok to not find the file, so do nothing...
+		}
+		else
+		{
+			psErrorMessage = va("Unable to load \"%s\"!", psFileName);
+		}
+	}
+
+	return psErrorMessage;
+}
+
+static LPCSTR SE_GetFoundFile( string &strResult )
+{
+	static char sTemp[1024/*MAX_PATH*/];
+
+	if (!strlen(strResult.c_str()))
+		return NULL;
+	
+	strncpy(sTemp,strResult.c_str(),sizeof(sTemp)-1);
+	sTemp[sizeof(sTemp)-1]='\0';
+
+	char *psSemiColon = strchr(sTemp,';');
+	if (  psSemiColon)
+	{
+		 *psSemiColon = '\0';
+
+		 strResult.erase(0,(psSemiColon-sTemp)+1);
+	}
+	else
+	{
+		// no semicolon found, probably last entry? (though i think even those have them on, oh well)
+		//
+		strResult.erase();
+	}
+
+//	strlwr(sTemp);	// just for consistancy and set<> -> set<> erasure checking etc
+
+	return sTemp;
+}
+
+//////////// API entry points from rest of game.... //////////////////////////////
+
+// filename is local here, eg:	"strings/german/obj.str"
+//
+// return is either NULL for good else error message to display...
+//
+LPCSTR SE_Load( LPCSTR psFileName, SE_BOOL bLoadDebug = SE_TRUE, SE_BOOL bFailIsCritical = SE_TRUE  )
+{
+	////////////////////////////////////////////////////
+	//
+	// ingame here tends to pass in names without paths, but I expect them when doing a language load, so...
+	//
+	char sTemp[1000]={0};
+	if (!strchr(psFileName,'/'))
+	{
+		strcpy(sTemp,sSE_STRINGS_DIR);
+		strcat(sTemp,"/");
+		if (se_language)
+		{
+			strcat(sTemp,se_language->string);
+			strcat(sTemp,"/");
+		}
+	}
+	strcat(sTemp,psFileName);
+	COM_DefaultExtension( sTemp, sizeof(sTemp), sSE_INGAME_FILE_EXTENSION);
+	psFileName = &sTemp[0];
+	//
+	////////////////////////////////////////////////////
+
+
+	LPCSTR psErrorMessage = SE_Load_Actual( psFileName, bLoadDebug, SE_FALSE );
+
+	// check for any corresponding / overriding .STE files and load them afterwards...
+	//
+	if ( !psErrorMessage )
+	{
+		char sFileName[ iSE_MAX_FILENAME_LENGTH ];
+		strncpy( sFileName, psFileName, sizeof(sFileName)-1 );
+				 sFileName[ sizeof(sFileName)-1 ] = '\0';
+		char *p = strrchr( sFileName, '.' );
+		if (p && strlen(p) == strlen(sSE_EXPORT_FILE_EXTENSION))
+		{
+			strcpy( p, sSE_EXPORT_FILE_EXTENSION );
+		
+			psErrorMessage = SE_Load_Actual( sFileName, bLoadDebug, SE_TRUE );
+		}
+	}
+
+	if (psErrorMessage)
+	{
+		if (bFailIsCritical)
+		{
+	//		TheStringPackage.Clear(TRUE);	// Will we want to do this?  Any errors that arise should be fixed immediately
+			Com_Error( ERR_DROP, "SE_Load(): Couldn't load \"%s\"!\n\nError: \"%s\"\n", psFileName, psErrorMessage );
+		}
+		else
+		{
+			Com_DPrintf(S_COLOR_YELLOW "SE_Load(): Couldn't load \"%s\"!\n", psFileName );
+		}
+	}
+
+	return psErrorMessage;
+}
+
+
+// convenience-function for the main GetString call...
+//
+LPCSTR SE_GetString( LPCSTR psPackageReference, LPCSTR psStringReference)
+{
+	char sReference[256];	// will always be enough, I've never seen one more than about 30 chars long
+
+	sprintf(sReference,"%s_%s", psPackageReference, psStringReference);
+
+	return SE_GetString( Q_strupr(sReference) );
+}
+
+
+LPCSTR SE_GetString( LPCSTR psPackageAndStringReference )
+{
+	char sReference[256];	// will always be enough, I've never seen one more than about 30 chars long
+	assert(strlen(psPackageAndStringReference) < sizeof(sReference) );
+	Q_strncpyz(sReference, psPackageAndStringReference, sizeof(sReference) );
+	Q_strupr(sReference);
+
+	mapStringEntries_t::iterator itEntry = TheStringPackage.m_StringEntries.find( sReference );
+	if (itEntry != TheStringPackage.m_StringEntries.end())
+	{
+		SE_Entry_t &Entry = (*itEntry).second;
+
+		if ( se_debug->integer && TheStringPackage.m_bLoadDebug )
+		{
+			return Entry.m_strDebug.c_str();
+		}
+		else
+		{
+			return Entry.m_strString.c_str();
+		}
+	}
+
+	// should never get here, but fall back anyway... (except we DO use this to see if there's a debug-friendly key bind, which may not exist)
+	//
+//	__ASSERT(0);
+	return "";	// you may want to replace this with something based on _DEBUG or not?
+}
+
+
+// convenience-function for the main GetFlags call...
+//
+int	SE_GetFlags ( LPCSTR psPackageReference, LPCSTR psStringReference )
+{
+	char sReference[256];	// will always be enough, I've never seen one more than about 30 chars long
+
+	sprintf(sReference,"%s_%s", psPackageReference, psStringReference);
+
+	return SE_GetFlags( sReference );
+}
+
+int	SE_GetFlags ( LPCSTR psPackageAndStringReference )
+{
+	mapStringEntries_t::iterator itEntry = TheStringPackage.m_StringEntries.find( psPackageAndStringReference );
+	if (itEntry != TheStringPackage.m_StringEntries.end())
+	{
+		SE_Entry_t &Entry = (*itEntry).second;
+
+		return Entry.m_iFlags;
+	}
+
+	// should never get here, but fall back anyway...
+	//
+	__ASSERT(0);
+
+	return 0;
+}
+
+
+int SE_GetNumFlags( void )
+{
+	return TheStringPackage.m_vstrFlagNames.size();
+}
+
+LPCSTR SE_GetFlagName( int iFlagIndex )
+{
+	if ( iFlagIndex < TheStringPackage.m_vstrFlagNames.size())
+	{
+		return TheStringPackage.m_vstrFlagNames[ iFlagIndex ].c_str();
+	}
+
+	__ASSERT(0);
+	return "";
+}
+
+// returns flag bitmask (eg 00000010b), else 0 for not found
+//
+int SE_GetFlagMask( LPCSTR psFlagName )
+{
+	return TheStringPackage.GetFlagMask( psFlagName );
+}
+
+// I could cache the result of this since it won't change during app lifetime unless someone does a build-publish
+//	while you're still ingame. Cacheing would make sense since it can take a while to scan, but I'll leave it and
+//	let whoever calls it cache the results instead. I'll make it known that it's a slow process to call this, but 
+//	whenever anyone calls someone else's code they should assign it to an int anyway, since you've no idea what's
+//	going on. Basically, don't  use this in a FOR loop as the end-condition. Duh.
+//
+// Groan, except for Bob. I mentioned that this was slow and only call it once, but he's calling it from 
+//	every level-load...  Ok, cacheing it is...
+//
+vector <string> gvLanguagesAvailable;
+int SE_GetNumLanguages(void)
+{
+	if ( gvLanguagesAvailable.empty() )
+	{
+		string strResults;
+		/*int iFilesFound = */SE_BuildFileList( 
+												#ifdef _STRINGED
+													va("C:\\Source\\Tools\\StringEd\\test_data\\%s",sSE_STRINGS_DIR)
+												#else
+													sSE_STRINGS_DIR
+												#endif
+												, strResults 
+											);
+
+		set<string> strUniqueStrings;	// laziness <g>
+		LPCSTR p;
+		while ((p=SE_GetFoundFile (strResults)) != NULL)
+		{
+			LPCSTR psLanguage = TheStringPackage.ExtractLanguageFromPath( p );
+
+	//		__DEBUGOUT( p );
+	//		__DEBUGOUT( "\n" );
+	//		__DEBUGOUT( psLanguage );
+	//		__DEBUGOUT( "\n" );
+
+			if (!strUniqueStrings.count( psLanguage ))
+			{
+				strUniqueStrings.insert( psLanguage );
+
+				// if english is available, it should always be first... ( I suppose )
+				//
+				if (!stricmp(psLanguage,"english"))
+				{
+					gvLanguagesAvailable.insert( gvLanguagesAvailable.begin(), psLanguage );
+				}
+				else
+				{
+					gvLanguagesAvailable.push_back( psLanguage );
+				}
+			}
+		}
+	}
+
+	return gvLanguagesAvailable.size();
+}
+
+// SE_GetNumLanguages() must have been called before this...
+//
+LPCSTR SE_GetLanguageName( int iLangIndex )
+{
+	if ( iLangIndex < gvLanguagesAvailable.size() )
+	{
+		return gvLanguagesAvailable[ iLangIndex ].c_str();
+	}
+
+	__ASSERT(0);
+	return "";
+}
+
+// SE_GetNumLanguages() must have been called before this...
+//
+LPCSTR SE_GetLanguageDir( int iLangIndex )
+{
+	if ( iLangIndex < gvLanguagesAvailable.size() )
+	{
+		return va("%s/%s", sSE_STRINGS_DIR, gvLanguagesAvailable[ iLangIndex ].c_str() );
+	}
+
+	__ASSERT(0);
+	return "";
+}
+
+void SE_NewLanguage(void)
+{
+	TheStringPackage.Clear( SE_TRUE );
+}
+
+
+
+// these two functions aren't needed other than to make Quake-type games happy and/or stop memory managers
+//	complaining about leaks if they report them before the global StringEd package object calls it's own dtor.
+//
+// but here they are for completeness's sake I guess...
+//
+void SE_Init(void)
+{
+#ifdef _XBOX	// VVFIXME?
+//	extern void Z_SetNewDeleteTemporary(bool);
+//	Z_SetNewDeleteTemporary(true);
+#endif
+
+	TheStringPackage.Clear( SE_FALSE );
+
+#ifdef _DEBUG
+//	int iNumLanguages = SE_GetNumLanguages();
+#endif
+
+	se_language = Cvar_Get("se_language", "english", CVAR_ARCHIVE | CVAR_NORESTART);
+	se_debug = Cvar_Get("se_debug", "0", 0);
+	sp_leet = Cvar_Get("sp_leet", "0", CVAR_ROM );
+
+	// if doing a buildscript, load all languages...
+	//
+	extern cvar_t *com_buildScript;
+	if (com_buildScript->integer == 2)
+	{
+		int iLanguages = SE_GetNumLanguages();
+		for (int iLang = 0; iLang < iLanguages; iLang++)
+		{
+            LPCSTR psLanguage = SE_GetLanguageName( iLang );	// eg "german"			
+			Com_Printf( "com_buildScript(2): Loading language \"%s\"...\n", psLanguage );
+			SE_LoadLanguage( psLanguage );
+		}
+	}
+
+	LPCSTR psErrorMessage = SE_LoadLanguage( se_language->string );
+	if (psErrorMessage)
+	{
+		Com_Error( ERR_DROP, "SE_Init() Unable to load language: \"%s\"!\nError: \"%s\"\n", se_language->string,psErrorMessage );
+	}
+
+#ifdef _XBOX
+//	Z_SetNewDeleteTemporary(false);
+#endif
+}
+
+void SE_ShutDown(void)
+{
+	TheStringPackage.Clear( SE_FALSE );
+}
+
+
+// returns error message else NULL for ok.
+//
+// Any errors that result from this should probably be treated as game-fatal, since an asset file is fuxored.
+//
+LPCSTR SE_LoadLanguage( LPCSTR psLanguage, SE_BOOL bLoadDebug /* = SE_TRUE */ )
+{
+	LPCSTR psErrorMessage = NULL;
+
+	if (psLanguage && psLanguage[0])
+	{
+		SE_NewLanguage();
+
+		string strResults;
+		/*int iFilesFound = */SE_BuildFileList( 
+												#ifdef _STRINGED
+													va("C:\\Source\\Tools\\StringEd\\test_data\\%s",sSE_STRINGS_DIR)
+												#else
+													sSE_STRINGS_DIR
+												#endif
+												, strResults 
+											);
+
+		LPCSTR p;
+		while ( (p=SE_GetFoundFile (strResults)) != NULL && !psErrorMessage )
+		{
+			LPCSTR psThisLang = TheStringPackage.ExtractLanguageFromPath( p );
+
+			if ( !stricmp( psLanguage, psThisLang ) )
+			{
+				psErrorMessage = SE_Load( p, bLoadDebug );
+			}
+		}
+	}
+	else
+	{
+		__ASSERT( 0 && "SE_LoadLanguage(): Bad language name!" );
+	}
+
+	return psErrorMessage;
+}
+
+
+// called in Com_Frame, so don't take up any time! (can also be called during dedicated)
+//
+// instead of re-loading just the files we've already loaded I'm going to load the whole language (simpler)
+//
+void SE_CheckForLanguageUpdates(void)
+{
+	if (se_language && se_language->modified)
+	{
+		LPCSTR psErrorMessage = SE_LoadLanguage( se_language->string, SE_TRUE );
+		if ( psErrorMessage )
+		{
+			Com_Error( ERR_DROP, psErrorMessage );
+		}
+		se_language->modified = SE_FALSE;
+	}
+}
+
+
+///////////////////////// eof //////////////////////////
diff --git a/codemp/qcommon/stringed_ingame.h b/codemp/qcommon/stringed_ingame.h
new file mode 100644
index 0000000..107951c
--- /dev/null
+++ b/codemp/qcommon/stringed_ingame.h
@@ -0,0 +1,110 @@
+// Filename:-	stringed_ingame.h
+//
+
+#ifndef STRINGED_INGAME_H
+#define	STRINGED_INGAME_H
+
+
+// alter these to suit your own game...
+//
+#define SE_BOOL					qboolean
+#define SE_TRUE					qtrue
+#define SE_FALSE				qfalse
+#define	iSE_MAX_FILENAME_LENGTH	MAX_QPATH
+#define sSE_STRINGS_DIR			"strings"
+#define sSE_DEBUGSTR_PREFIX		"["		// any string you want prefixing onto the debug versions of strings (to spot hardwired english etc)
+#define sSE_DEBUGSTR_SUFFIX		"]"		// ""
+
+extern cvar_t	*se_language;
+
+// some needed text-equates, do not alter these under any circumstances !!!! (unless you're me. Which you're not)
+//
+#define iSE_VERSION					1
+#define sSE_KEYWORD_VERSION			"VERSION"
+#define sSE_KEYWORD_CONFIG			"CONFIG"
+#define sSE_KEYWORD_FILENOTES		"FILENOTES"
+#define sSE_KEYWORD_REFERENCE		"REFERENCE"
+#define sSE_KEYWORD_FLAGS 			"FLAGS"
+#define sSE_KEYWORD_NOTES			"NOTES"
+#define sSE_KEYWORD_LANG			"LANG_"
+#define sSE_KEYWORD_ENDMARKER		"ENDMARKER"
+#define sSE_FILE_EXTENSION			".st"	// editor-only NEVER used ingame, but I wanted all extensions together
+#define sSE_EXPORT_FILE_EXTENSION	".ste"
+#define sSE_INGAME_FILE_EXTENSION	".str"
+#define sSE_EXPORT_SAME				"#same"
+
+
+
+// available API calls...
+//
+typedef const char *LPCSTR;
+
+void	SE_Init				( void );
+void	SE_ShutDown			( void );
+void	SE_CheckForLanguageUpdates(void);
+int		SE_GetNumLanguages	( void );
+LPCSTR	SE_GetLanguageName	( int iLangIndex );	// eg "german"
+LPCSTR	SE_GetLanguageDir	( int iLangIndex );	// eg "strings/german"
+LPCSTR	SE_LoadLanguage		( LPCSTR psLanguage, SE_BOOL bLoadDebug = SE_TRUE );
+void	SE_NewLanguage		( void );
+//
+// for convenience, two ways of getting at the same data...
+//
+LPCSTR	SE_GetString		( LPCSTR psPackageReference, LPCSTR psStringReference);
+LPCSTR	SE_GetString		( LPCSTR psPackageAndStringReference);
+//
+// ditto...
+//
+int		SE_GetFlags			( LPCSTR psPackageReference, LPCSTR psStringReference );
+int		SE_GetFlags			( LPCSTR psPackageAndStringReference );
+//
+// general flag functions... (SEP_GetFlagMask() return should be used with SEP_GetFlags() return)
+//
+int		SE_GetNumFlags		( void );
+LPCSTR	SE_GetFlagName		( int iFlagIndex );
+int		SE_GetFlagMask		( LPCSTR psFlagName );
+
+
+// note that so far the only place in the game that needs to know these is the font system so it can know how to
+//	interpret char codes, for this reason I'm only exposing these simple bool queries...
+//
+inline SE_BOOL Language_IsRussian(void)
+{
+	return (se_language && !Q_stricmp(se_language->string, "russian")) ? SE_TRUE : SE_FALSE;	
+}
+
+inline SE_BOOL Language_IsPolish(void)
+{
+	return (se_language && !Q_stricmp(se_language->string, "polish")) ? SE_TRUE : SE_FALSE;	
+}
+
+inline SE_BOOL Language_IsKorean(void)
+{
+	return (se_language && !Q_stricmp(se_language->string, "korean")) ? SE_TRUE : SE_FALSE;
+}
+
+inline SE_BOOL Language_IsTaiwanese(void)
+{
+	return (se_language && !Q_stricmp(se_language->string, "taiwanese")) ? SE_TRUE : SE_FALSE;
+}
+
+inline SE_BOOL Language_IsJapanese(void)
+{
+	return (se_language && !Q_stricmp(se_language->string, "japanese")) ? SE_TRUE : SE_FALSE;
+}
+
+inline SE_BOOL Language_IsChinese(void)
+{
+	return (se_language && !Q_stricmp(se_language->string, "chinese")) ? SE_TRUE : SE_FALSE;
+}
+
+inline SE_BOOL Language_IsThai(void)
+{
+	return (se_language && !Q_stricmp(se_language->string, "thai")) ? SE_TRUE : SE_FALSE;
+}
+
+
+#endif	// #ifndef STRINGED_INGAME_H
+
+/////////////////// eof ////////////////
+
diff --git a/codemp/qcommon/stringed_interface.cpp b/codemp/qcommon/stringed_interface.cpp
new file mode 100644
index 0000000..b23b9fa
--- /dev/null
+++ b/codemp/qcommon/stringed_interface.cpp
@@ -0,0 +1,215 @@
+// Filename:-	stringed_interface.cpp
+//
+// This file contains functions that StringEd wants to call to do things like load/save, they can be modified
+//	for use ingame, but must remain functionally the same...
+//
+//  Please try and put modifications for whichever games this is used for inside #defines, so I can copy the same file
+//		into each project.
+//
+
+
+//////////////////////////////////////////////////
+//
+// stuff common to all qcommon files...
+#include "../server/server.h"
+#include "../game/q_shared.h"
+#include "qcommon.h"
+//
+//////////////////////////////////////////////////
+
+
+#pragma warning ( disable : 4511 )			// copy constructor could not be generated
+#pragma warning ( disable : 4512 )			// assignment operator could not be generated
+#pragma warning ( disable : 4663 )			// C++ language change: blah blah template crap blah blah
+#include "stringed_interface.h"
+#include "stringed_ingame.h"
+
+#include <string>
+using namespace std;
+
+#ifdef _STRINGED
+#include <stdlib.h>
+#include <memory.h>
+#include "generic.h"
+#endif
+
+
+// this just gets the binary of the file into memory, so I can parse it. Called by main SGE loader
+//
+//  returns either char * of loaded file, else NULL for failed-to-open...
+//
+unsigned char *SE_LoadFileData( const char *psFileName, int *piLoadedLength /* = 0 */)
+{
+	unsigned char *psReturn = NULL;
+	if ( piLoadedLength )
+	{
+		*piLoadedLength = 0;
+	}
+
+#ifdef _STRINGED
+	if (psFileName[1] == ':')
+	{
+		// full-path filename...
+		//
+		FILE *fh = fopen( psFileName, "rb" );
+		if (fh)
+		{
+			long lLength = filesize(fh);
+
+			if (lLength > 0)
+			{
+				psReturn = (unsigned char *) malloc( lLength + 1);
+				if (psReturn)
+				{
+					int iBytesRead = fread( psReturn, 1, lLength, fh );
+					if (iBytesRead != lLength)
+					{
+						// error reading file!!!...
+						//
+						free(psReturn);
+							 psReturn = NULL;
+					}
+					else
+					{
+						psReturn[ lLength ] = '\0';
+						if ( piLoadedLength )
+						{
+							*piLoadedLength = iBytesRead;
+						}
+					}
+					fclose(fh);
+				}
+			}
+		}
+	}
+	else
+#endif
+	{
+		// local filename, so prepend the base dir etc according to game and load it however (from PAK?)
+		//		
+		unsigned char *pvLoadedData;		
+		int iLen = FS_ReadFile( psFileName, (void **)&pvLoadedData );
+
+		if (iLen>0)
+		{
+			psReturn = pvLoadedData;
+			if ( piLoadedLength )
+			{
+				*piLoadedLength = iLen;
+			}
+		}
+	}
+
+	return psReturn;
+}
+
+
+// called by main SGE code after loaded data has been parsedinto internal structures...
+//
+void SE_FreeFileDataAfterLoad( unsigned char *psLoadedFile )
+{
+#ifdef _STRINGED
+	if ( psLoadedFile )
+	{
+		free( psLoadedFile );
+	}
+#else
+	if ( psLoadedFile )
+	{
+		FS_FreeFile( psLoadedFile );
+	}	
+#endif
+}
+
+
+
+
+
+#ifndef _STRINGED
+// quake-style method of doing things since their file-list code doesn't have a 'recursive' flag...
+//
+int giFilesFound;
+static void SE_R_ListFiles( const char *psExtension, const char *psDir, string &strResults )
+{
+//	Com_Printf(va("Scanning Dir: %s\n",psDir));
+
+	char	**sysFiles, **dirFiles;
+	int		numSysFiles, i, numdirs;
+
+	dirFiles = FS_ListFiles( psDir, "/", &numdirs);
+	for (i=0;i<numdirs;i++)
+	{
+		if (dirFiles[i][0] && dirFiles[i][0] != '.')	// skip blanks, plus ".", ".." etc
+		{
+			char	sDirName[MAX_QPATH];
+			sprintf(sDirName, "%s/%s", psDir, dirFiles[i]);
+			//
+			// for some reason the quake filesystem in this game now returns an extra slash on the end,
+			//	didn't used to. Sigh...
+			//
+			if (sDirName[strlen(sDirName)-1] == '/')
+			{
+				sDirName[strlen(sDirName)-1] = '\0';
+			}
+			SE_R_ListFiles( psExtension, sDirName, strResults );
+		}
+	}
+
+	sysFiles = FS_ListFiles( psDir, psExtension, &numSysFiles );
+	for(i=0; i<numSysFiles; i++)
+	{
+		char	sFilename[MAX_QPATH];
+		sprintf(sFilename,"%s/%s", psDir, sysFiles[i]);		
+			
+//		Com_Printf("%sFound file: %s",!i?"\n":"",sFilename);
+
+		strResults += sFilename;
+		strResults += ';';
+		giFilesFound++;
+
+		// read it in...
+		//
+/*		byte *pbData = NULL;
+		int iSize = FS_ReadFile( sFilename, (void **)&pbData);
+
+		if (pbData)
+		{
+
+			FS_FreeFile( pbData );
+		}
+*/
+	}
+	FS_FreeFileList( sysFiles );
+	FS_FreeFileList( dirFiles );
+}
+#endif
+
+
+// replace this with a call to whatever your own code equivalent is.
+//
+// expected result is a ';'-delineated string (including last one) containing file-list search results
+//
+int SE_BuildFileList( const char *psStartDir, string &strResults )
+{
+#ifndef _STRINGED
+	giFilesFound = 0;
+	strResults = "";
+
+	SE_R_ListFiles( sSE_INGAME_FILE_EXTENSION, psStartDir, strResults );
+
+	return giFilesFound;
+#else
+	// .ST files...
+	//
+	int iFilesFound = BuildFileList(	va("%s\\*%s",psStartDir, sSE_INGAME_FILE_EXTENSION),	// LPCSTR psPathAndFilter, 
+										true					// bool bRecurseSubDirs
+										);
+
+	extern string strResult;
+	strResults = strResult;
+	return iFilesFound;
+#endif
+}
+
+/////////////////////// eof ///////////////////////
+
diff --git a/codemp/qcommon/stringed_interface.h b/codemp/qcommon/stringed_interface.h
new file mode 100644
index 0000000..a708c24
--- /dev/null
+++ b/codemp/qcommon/stringed_interface.h
@@ -0,0 +1,21 @@
+// Filename:-	stringed_interface.h
+//
+// These are the functions that get replaced by game-specific ones (or StringEd code) so SGE can access files etc
+//
+
+#ifndef STRINGED_INTERFACE_H
+#define STRINGED_INTERFACE_H
+
+#pragma warning ( disable : 4786 )			// disable the usual stupid and pointless STL warning
+#include <string>
+using namespace std;
+
+unsigned char *	SE_LoadFileData			( const char *psFileName, int *piLoadedLength = 0);
+void			SE_FreeFileDataAfterLoad( unsigned char *psLoadedFile );
+int				SE_BuildFileList		( const char *psStartDir, string &strResults );
+
+#endif	// #ifndef STRINGED_INTERFACE_H
+
+
+////////////////// eof ///////////////////
+
diff --git a/codemp/qcommon/tags.h b/codemp/qcommon/tags.h
new file mode 100644
index 0000000..c8a4635
--- /dev/null
+++ b/codemp/qcommon/tags.h
@@ -0,0 +1,75 @@
+// Filename:-	tags.h
+
+// do NOT include-protect this file, or add any fields or labels, because it's included within enums and tables
+//
+// these macro args get "TAG_" prepended on them for enum purposes, and appear as literal strings for "meminfo" command
+
+	TAGDEF(ALL),
+	TAGDEF(BOTLIB),
+	TAGDEF(CLIENTS),					// Memory used for client info
+#ifndef _XBOX
+	TAGDEF(BOTGAME),
+	TAGDEF(DOWNLOAD),					// used by the downloading system
+	TAGDEF(GENERAL),
+	TAGDEF(CLIPBOARD),					
+	TAGDEF(SND_MP3STREAMHDR),			// specific MP3 struct for decoding (about 18..22K each?), not the actual MP3 binary
+	TAGDEF(SND_DYNAMICMUSIC),			// in-mem MP3 files
+	TAGDEF(BSP_DISKIMAGE),				// temp during loading, to save both server and renderer fread()ing the same file. Only used if not low physical memory (currently 96MB)
+	TAGDEF(VM),							// stuff for VM, may be zapped later?
+	TAGDEF(SPECIAL_MEM_TEST),			// special usage for testing z_malloc recover only
+#endif
+	TAGDEF(HUNK_MARK1),					//hunk allocations before the mark is set
+	TAGDEF(HUNK_MARK2),					//hunk allocations after the mark is set
+	TAGDEF(EVENT),
+	TAGDEF(FILESYS),					// general filesystem usage
+	TAGDEF(GHOUL2),						// Ghoul2 stuff
+	TAGDEF(GHOUL2_GORE),				// Ghoul2 gore stuff
+	TAGDEF(LISTFILES),					// for "*.blah" lists
+	TAGDEF(AMBIENTSET),
+	TAGDEF(STATIC),						// special usage for 1-byte allocations from 0..9 to avoid CopyString() slowdowns during cvar value copies
+	TAGDEF(SMALL),						// used by S_Malloc, but probably more of a hint now. Will be dumped later
+	TAGDEF(MODEL_MD3),					// specific model types' disk images
+	TAGDEF(MODEL_GLM),					//	   "
+	TAGDEF(MODEL_GLA),					//	   "
+	TAGDEF(ICARUS),						// Memory used internally by the Icarus scripting system
+	//sorry, I don't want to have to keep adding these and recompiling, so there may be more than I need
+	TAGDEF(ICARUS2),					//for debugging mem leaks in icarus -rww
+	TAGDEF(ICARUS3),					//for debugging mem leaks in icarus -rww
+	TAGDEF(ICARUS4),					//for debugging mem leaks in icarus -rww
+	TAGDEF(ICARUS5),					//for debugging mem leaks in icarus -rww
+	TAGDEF(SHADERTEXT),
+	TAGDEF(SND_RAWDATA),				// raw sound data, either MP3 or WAV
+	TAGDEF(TEMP_WORKSPACE),				// anything like file loading or image workspace that's only temporary
+	TAGDEF(TEMP_PNG),					// image workspace that's only temporary
+	TAGDEF(TEXTPOOL),					// for some special text-pool class thingy
+	TAGDEF(IMAGE_T),					// an image_t struct (no longer on the hunk because of cached texture stuff)
+    TAGDEF(INFLATE),                                // Temp memory used by zlib32
+    TAGDEF(DEFLATE),                                // Temp memory used by zlib32//	TAGDEF(SOUNDPOOL),					// pool of mem for the sound system
+	TAGDEF(BSP),						// guess.
+	TAGDEF(GRIDMESH),					// some specific temp workspace that only seems to be in the MP codebase
+
+	//rwwRMG - following:
+	TAGDEF(POINTCACHE),					// weather system
+	TAGDEF(TERRAIN),					// RMG terrain management
+	TAGDEF(R_TERRAIN),					// terrain renderer
+	TAGDEF(RESAMPLE),					// terrain heightmap resampling (I think)
+	TAGDEF(CM_TERRAIN),					// common terrain data management
+	TAGDEF(CM_TERRAIN_TEMP),			// temporary terrain allocations
+	TAGDEF(TEMP_IMAGE),					// temporary allocations for image manipulation
+
+	TAGDEF(VM_ALLOCATED),				// allocated by game or cgame via memory shifting
+
+	TAGDEF(TEMP_HUNKALLOC),
+#ifdef _XBOX
+	TAGDEF(NEWDEL),						// new / delete -> Z_Malloc on Xbox
+	TAGDEF(UI_ALLOC),					// UI DLL calls to UI_Alloc
+	TAGDEF(CG_UI_ALLOC),				// Cgame DLL calls to UI_Alloc
+	TAGDEF(BG_ALLOC),
+	TAGDEF(BINK),
+	TAGDEF(XBL_FRIENDS),				// friends list
+#endif
+	TAGDEF(COUNT)
+
+
+//////////////// eof //////////////
+
diff --git a/codemp/qcommon/timing.h b/codemp/qcommon/timing.h
new file mode 100644
index 0000000..c825fad
--- /dev/null
+++ b/codemp/qcommon/timing.h
@@ -0,0 +1,61 @@
+
+class timing_c
+{
+private:
+	__int64	start;
+	__int64	end;
+
+	int		reset;
+public:
+	timing_c(void)
+	{
+	}
+	void Start()
+	{
+		const __int64 *s = &start;
+		__asm
+		{
+			push eax
+			push ebx
+			push edx
+
+			rdtsc
+			mov ebx, s
+			mov	[ebx], eax
+			mov [ebx + 4], edx
+
+			pop edx
+			pop ebx
+			pop eax
+		}
+	}
+	int End()
+	{
+		const __int64 *e = &end;
+		__int64	time;
+#ifndef __linux__
+		__asm
+		{
+			push eax
+			push ebx
+			push edx
+
+			rdtsc
+			mov ebx, e
+			mov	[ebx], eax
+			mov [ebx + 4], edx
+
+			pop edx
+			pop ebx
+			pop eax
+		}
+#endif 
+		time = end - start;
+		if (time < 0)
+		{
+			time = 0;
+		}
+		return((int)time);
+	}
+};
+// end
\ No newline at end of file
diff --git a/codemp/qcommon/unzip.cpp b/codemp/qcommon/unzip.cpp
new file mode 100644
index 0000000..02e8edd
--- /dev/null
+++ b/codemp/qcommon/unzip.cpp
@@ -0,0 +1,1337 @@
+/*****************************************************************************
+ * name:		unzip.c
+ *
+ * desc:		IO on .zip files using portions of zlib 
+ *
+ *****************************************************************************/
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+#include "../client/client.h"
+
+#define ZIP_fopen	fopen
+#define ZIP_fclose	fclose
+#define ZIP_fseek	fseek
+#define ZIP_fread	fread
+#define ZIP_ftell	ftell
+
+#include "../zlib32/zip.h"
+#include "unzip.h"
+
+/* unzip.h -- IO for uncompress .zip files using zlib 
+   Version 0.15 beta, Mar 19th, 1998,
+
+   Copyright (C) 1998 Gilles Vollant
+
+   This unzip package allow extract file from .ZIP file, compatible with PKZip 2.04g
+     WinZip, InfoZip tools and compatible.
+   Encryption and multi volume ZipFile (span) are not supported.
+   Old compressions used by old PKZip 1.x are not supported
+
+   THIS IS AN ALPHA VERSION. AT THIS STAGE OF DEVELOPPEMENT, SOMES API OR STRUCTURE
+   CAN CHANGE IN FUTURE VERSION !!
+   I WAIT FEEDBACK at mail info@winimage.com
+   Visit also http://www.winimage.com/zLibDll/unzip.htm for evolution
+
+   Condition of use and distribution are the same than zlib :
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+
+                        /* Type declarations */
+
+#ifndef OF /* function prototypes */
+#define OF(args)  args
+#endif
+
+typedef unsigned char  Byte;  /* 8 bits */
+typedef unsigned int   uInt;  /* 16 bits or more */
+typedef unsigned long  uLong; /* 32 bits or more */
+typedef Byte    *voidp;
+
+#ifndef SEEK_SET
+#  define SEEK_SET        0       /* Seek from beginning of file.  */
+#  define SEEK_CUR        1       /* Seek from current position.  */
+#  define SEEK_END        2       /* Set file pointer to EOF plus "offset" */
+#endif
+
+typedef voidp gzFile;
+
+gzFile gzopen  OF((const char *path, const char *mode));
+/*
+     Opens a gzip (.gz) file for reading or writing. The mode parameter
+   is as in fopen ("rb" or "wb") but can also include a compression level
+   ("wb9") or a strategy: 'f' for filtered data as in "wb6f", 'h' for
+   Huffman only compression as in "wb1h". (See the description
+   of deflateInit2 for more information about the strategy parameter.)
+
+     gzopen can be used to read a file which is not in gzip format; in this
+   case gzread will directly read from the file without decompression.
+
+     gzopen returns NULL if the file could not be opened or if there was
+   insufficient memory to allocate the (de)compression state; errno
+   can be checked to distinguish the two cases (if errno is zero, the
+   zlib error is Z_MEM_ERROR).  */
+
+gzFile gzdopen  OF((int fd, const char *mode));
+/*
+     gzdopen() associates a gzFile with the file descriptor fd.  File
+   descriptors are obtained from calls like open, dup, creat, pipe or
+   fileno (in the file has been previously opened with fopen).
+   The mode parameter is as in gzopen.
+     The next call of gzclose on the returned gzFile will also close the
+   file descriptor fd, just like fclose(fdopen(fd), mode) closes the file
+   descriptor fd. If you want to keep fd open, use gzdopen(dup(fd), mode).
+     gzdopen returns NULL if there was insufficient memory to allocate
+   the (de)compression state.
+*/
+
+int gzsetparams OF((gzFile file, int level, int strategy));
+/*
+     Dynamically update the compression level or strategy. See the description
+   of deflateInit2 for the meaning of these parameters.
+     gzsetparams returns Z_OK if success, or Z_STREAM_ERROR if the file was not
+   opened for writing.
+*/
+
+int    gzread  OF((gzFile file, voidp buf, unsigned len));
+/*
+     Reads the given number of uncompressed bytes from the compressed file.
+   If the input file was not in gzip format, gzread copies the given number
+   of bytes into the buffer.
+     gzread returns the number of uncompressed bytes actually read (0 for
+   end of file, -1 for error). */
+
+int    gzwrite OF((gzFile file, 
+				   const voidp buf, unsigned len));
+/*
+     Writes the given number of uncompressed bytes into the compressed file.
+   gzwrite returns the number of uncompressed bytes actually written
+   (0 in case of error).
+*/
+
+int    QDECL gzprintf OF((gzFile file, const char *format, ...));
+/*
+     Converts, formats, and writes the args to the compressed file under
+   control of the format string, as in fprintf. gzprintf returns the number of
+   uncompressed bytes actually written (0 in case of error).
+*/
+
+int gzputs OF((gzFile file, const char *s));
+/*
+      Writes the given null-terminated string to the compressed file, excluding
+   the terminating null character.
+      gzputs returns the number of characters written, or -1 in case of error.
+*/
+
+char * gzgets OF((gzFile file, char *buf, int len));
+/*
+      Reads bytes from the compressed file until len-1 characters are read, or
+   a newline character is read and transferred to buf, or an end-of-file
+   condition is encountered.  The string is then terminated with a null
+   character.
+      gzgets returns buf, or Z_NULL in case of error.
+*/
+
+int    gzputc OF((gzFile file, int c));
+/*
+      Writes c, converted to an unsigned char, into the compressed file.
+   gzputc returns the value that was written, or -1 in case of error.
+*/
+
+int    gzgetc OF((gzFile file));
+/*
+      Reads one byte from the compressed file. gzgetc returns this byte
+   or -1 in case of end of file or error.
+*/
+
+int    gzflush OF((gzFile file, int flush));
+/*
+     Flushes all pending output into the compressed file. The parameter
+   flush is as in the deflate() function. The return value is the zlib
+   error number (see function gzerror below). gzflush returns Z_OK if
+   the flush parameter is Z_FINISH and all output could be flushed.
+     gzflush should be called only when strictly necessary because it can
+   degrade compression.
+*/
+
+long gzseek OF((gzFile file,
+				      long offset, int whence));
+/* 
+      Sets the starting position for the next gzread or gzwrite on the
+   given compressed file. The offset represents a number of bytes in the
+   uncompressed data stream. The whence parameter is defined as in lseek(2);
+   the value SEEK_END is not supported.
+     If the file is opened for reading, this function is emulated but can be
+   extremely slow. If the file is opened for writing, only forward seeks are
+   supported; gzseek then compresses a sequence of zeroes up to the new
+   starting position.
+
+      gzseek returns the resulting offset location as measured in bytes from
+   the beginning of the uncompressed stream, or -1 in case of error, in
+   particular if the file is opened for writing and the new starting position
+   would be before the current position.
+*/
+
+int    gzrewind OF((gzFile file));
+/*
+     Rewinds the given file. This function is supported only for reading.
+
+   gzrewind(file) is equivalent to (int)gzseek(file, 0L, SEEK_SET)
+*/
+
+long    gztell OF((gzFile file));
+/*
+     Returns the starting position for the next gzread or gzwrite on the
+   given compressed file. This position represents a number of bytes in the
+   uncompressed data stream.
+
+   gztell(file) is equivalent to gzseek(file, 0L, SEEK_CUR)
+*/
+
+int gzeof OF((gzFile file));
+/*
+     Returns 1 when EOF has previously been detected reading the given
+   input stream, otherwise zero.
+*/
+
+int    gzclose OF((gzFile file));
+/*
+     Flushes all pending output if necessary, closes the compressed file
+   and deallocates all the (de)compression state. The return value is the zlib
+   error number (see function gzerror below).
+*/
+
+const char * gzerror OF((gzFile file, int *errnum));
+/*
+     Returns the error message for the last error which occurred on the
+   given compressed file. errnum is set to zlib error number. If an
+   error occurred in the file system and not in the compression library,
+   errnum is set to Z_ERRNO and the application may consult errno
+   to get the exact error code.
+*/
+
+#if !defined(unix) && !defined(CASESENSITIVITYDEFAULT_YES) && \
+                      !defined(CASESENSITIVITYDEFAULT_NO)
+#define CASESENSITIVITYDEFAULT_NO
+#endif
+
+
+#ifndef UNZ_BUFSIZE
+#define UNZ_BUFSIZE (65536)
+#endif
+
+#ifndef UNZ_MAXFILENAMEINZIP
+#define UNZ_MAXFILENAMEINZIP (256)
+#endif
+
+#ifndef ALLOC
+# define ALLOC(size) (Z_Malloc(size, TAG_FILESYS, qfalse))
+#endif
+#ifndef TRYFREE
+# define TRYFREE(p) {if (p) Z_Free(p);}
+#endif
+
+#define SIZECENTRALDIRITEM (0x2e)
+#define SIZEZIPLOCALHEADER (0x1e)
+
+/* ===========================================================================
+   Reads a long in LSB order from the given gz_stream. Sets 
+*/
+static int unzlocal_getShort (ZIP_FILE* fin, uLong *pX)
+{
+	short	v;
+
+	ZIP_fread( &v, sizeof(v), 1, fin );
+
+	*pX = LittleShort( v);
+	return UNZ_OK;
+}
+
+static int unzlocal_getLong (ZIP_FILE *fin, uLong *pX)
+{
+	int		v;
+
+	ZIP_fread( &v, sizeof(v), 1, fin );
+
+	*pX = LittleLong( v);
+	return UNZ_OK;
+}
+
+
+/* My own strcmpi / strcasecmp */
+static int strcmpcasenosensitive_internal (const char* fileName1,const char* fileName2)
+{
+	for (;;)
+	{
+		char c1=*(fileName1++);
+		char c2=*(fileName2++);
+		if ((c1>='a') && (c1<='z'))
+			c1 -= 0x20;
+		if ((c2>='a') && (c2<='z'))
+			c2 -= 0x20;
+		if (c1=='\0')
+			return ((c2=='\0') ? 0 : -1);
+		if (c2=='\0')
+			return 1;
+		if (c1<c2)
+			return -1;
+		if (c1>c2)
+			return 1;
+	}
+}
+
+
+#ifdef  CASESENSITIVITYDEFAULT_NO
+#define CASESENSITIVITYDEFAULTVALUE 2
+#else
+#define CASESENSITIVITYDEFAULTVALUE 1
+#endif
+
+#ifndef STRCMPCASENOSENTIVEFUNCTION
+#define STRCMPCASENOSENTIVEFUNCTION strcmpcasenosensitive_internal
+#endif
+
+/* 
+   Compare two filename (fileName1,fileName2).
+   If iCaseSenisivity = 1, comparision is case sensitivity (like strcmp)
+   If iCaseSenisivity = 2, comparision is not case sensitivity (like strcmpi
+                                                                or strcasecmp)
+   If iCaseSenisivity = 0, case sensitivity is defaut of your operating system
+        (like 1 on Unix, 2 on Windows)
+
+*/
+extern int unzStringFileNameCompare (const char* fileName1,const char* fileName2,int iCaseSensitivity)
+{
+	if (iCaseSensitivity==0)
+		iCaseSensitivity=CASESENSITIVITYDEFAULTVALUE;
+
+	if (iCaseSensitivity==1)
+		return strcmp(fileName1,fileName2);
+
+	return STRCMPCASENOSENTIVEFUNCTION(fileName1,fileName2);
+} 
+
+#define BUFREADCOMMENT (0x400)
+
+/*
+  Locate the Central directory of a zipfile (at the end, just before
+    the global comment)
+*/
+static uLong unzlocal_SearchCentralDir(ZIP_FILE *fin)
+{
+	unsigned char* buf;
+	uLong uSizeFile;
+	uLong uBackRead;
+	uLong uMaxBack=0xffff; /* maximum size of global comment */
+	uLong uPosFound=0;
+	
+	if (ZIP_fseek(fin,0,SEEK_END) != 0)
+		return 0;
+
+
+	uSizeFile = ZIP_ftell( fin );
+	
+	if (uMaxBack>uSizeFile)
+		uMaxBack = uSizeFile;
+
+	buf = (unsigned char*)ALLOC(BUFREADCOMMENT+4);
+
+	uBackRead = 4;
+	while (uBackRead<uMaxBack)
+	{
+		uLong uReadSize,uReadPos ;
+		int i;
+		if (uBackRead+BUFREADCOMMENT>uMaxBack) 
+			uBackRead = uMaxBack;
+		else
+			uBackRead+=BUFREADCOMMENT;
+		uReadPos = uSizeFile-uBackRead ;
+		
+		uReadSize = ((BUFREADCOMMENT+4) < (uSizeFile-uReadPos)) ? 
+                     (BUFREADCOMMENT+4) : (uSizeFile-uReadPos);
+		if (ZIP_fseek(fin,uReadPos,SEEK_SET)!=0)
+			break;
+
+		if (ZIP_fread(buf,(uInt)uReadSize,1,fin)!=1)
+			break;
+
+                for (i=(int)uReadSize-3; (i--)>0;)
+			if (((*(buf+i))==0x50) && ((*(buf+i+1))==0x4b) && 
+				((*(buf+i+2))==0x05) && ((*(buf+i+3))==0x06))
+			{
+				uPosFound = uReadPos+i;
+				break;
+			}
+
+		if (uPosFound!=0)
+			break;
+	}
+	TRYFREE(buf);
+	return uPosFound;
+}
+
+extern unzFile unzReOpen (const char* path, unzFile file)
+{
+	unz_s *s;
+	ZIP_FILE * fin;
+
+    fin=ZIP_fopen(path,"rb");
+	if (fin==NULL)
+		return NULL;
+
+	s=(unz_s*)ALLOC(sizeof(unz_s));
+	Com_Memcpy(s, (unz_s*)file, sizeof(unz_s));
+
+	s->file = fin;
+	return (unzFile)s;	
+}
+
+/*
+  Open a Zip file. path contain the full pathname (by example,
+     on a Windows NT computer "c:\\test\\zlib109.zip" or on an Unix computer
+	 "zlib/zlib109.zip".
+	 If the zipfile cannot be opened (file don't exist or in not valid), the
+	   return value is NULL.
+     Else, the return value is a unzFile Handle, usable with other function
+	   of this unzip package.
+*/
+extern unzFile unzOpen (const char* path)
+{
+	unz_s us;
+	unz_s *s;
+	uLong central_pos,uL;
+	ZIP_FILE * fin ;
+
+	uLong number_disk;          /* number of the current dist, used for 
+								   spaning ZIP, unsupported, always 0*/
+	uLong number_disk_with_CD;  /* number the the disk with central dir, used
+								   for spaning ZIP, unsupported, always 0*/
+	uLong number_entry_CD;      /* total number of entries in
+	                               the central dir 
+	                               (same than number_entry on nospan) */
+
+	int err=UNZ_OK;
+
+    fin=ZIP_fopen(path,"rb");
+	if (fin==NULL)
+		return NULL;
+
+	central_pos = unzlocal_SearchCentralDir(fin);
+	if (central_pos==0)
+		err=UNZ_ERRNO;
+
+	if (ZIP_fseek(fin,central_pos,SEEK_SET)!=0)
+		err=UNZ_ERRNO;
+
+	/* the signature, already checked */
+	if (unzlocal_getLong(fin,&uL)!=UNZ_OK)
+		err=UNZ_ERRNO;
+
+	/* number of this disk */
+	if (unzlocal_getShort(fin,&number_disk)!=UNZ_OK)
+		err=UNZ_ERRNO;
+
+	/* number of the disk with the start of the central directory */
+	if (unzlocal_getShort(fin,&number_disk_with_CD)!=UNZ_OK)
+		err=UNZ_ERRNO;
+
+	/* total number of entries in the central dir on this disk */
+	if (unzlocal_getShort(fin,&us.gi.number_entry)!=UNZ_OK)
+		err=UNZ_ERRNO;
+
+	/* total number of entries in the central dir */
+	if (unzlocal_getShort(fin,&number_entry_CD)!=UNZ_OK)
+		err=UNZ_ERRNO;
+
+	if ((number_entry_CD!=us.gi.number_entry) ||
+		(number_disk_with_CD!=0) ||
+		(number_disk!=0))
+		err=UNZ_BADZIPFILE;
+
+	/* size of the central directory */
+	if (unzlocal_getLong(fin,&us.size_central_dir)!=UNZ_OK)
+		err=UNZ_ERRNO;
+
+	/* offset of start of central directory with respect to the 
+	      starting disk number */
+	if (unzlocal_getLong(fin,&us.offset_central_dir)!=UNZ_OK)
+		err=UNZ_ERRNO;
+
+	/* zipfile comment length */
+	if (unzlocal_getShort(fin,&us.gi.size_comment)!=UNZ_OK)
+		err=UNZ_ERRNO;
+
+	if ((central_pos<us.offset_central_dir+us.size_central_dir) && 
+		(err==UNZ_OK))
+		err=UNZ_BADZIPFILE;
+
+	if (err!=UNZ_OK)
+	{
+		ZIP_fclose(fin);
+		return NULL;
+	}
+
+	us.file=fin;
+	us.byte_before_the_zipfile = central_pos -
+		                    (us.offset_central_dir+us.size_central_dir);
+	us.central_pos = central_pos;
+    us.pfile_in_zip_read = NULL;
+	
+
+	s=(unz_s*)ALLOC(sizeof(unz_s));
+	*s=us;
+//	unzGoToFirstFile((unzFile)s);	
+	return (unzFile)s;	
+}
+
+
+/*
+  Close a ZipFile opened with unzipOpen.
+  If there is files inside the .Zip opened with unzipOpenCurrentFile (see later),
+    these files MUST be closed with unzipCloseCurrentFile before call unzipClose.
+  return UNZ_OK if there is no problem. */
+extern int unzClose (unzFile file)
+{
+	unz_s* s;
+	if (file==NULL)
+		return UNZ_PARAMERROR;
+	s=(unz_s*)file;
+
+    if (s->pfile_in_zip_read!=NULL)
+        unzCloseCurrentFile(file);
+
+	ZIP_fclose(s->file);
+	TRYFREE(s);
+	return UNZ_OK;
+}
+
+
+/*
+  Write info about the ZipFile in the *pglobal_info structure.
+  No preparation of the structure is needed
+  return UNZ_OK if there is no problem. */
+extern int unzGetGlobalInfo (unzFile file,unz_global_info *pglobal_info)
+{
+	unz_s* s;
+	if (file==NULL)
+		return UNZ_PARAMERROR;
+	s=(unz_s*)file;
+	*pglobal_info=s->gi;
+	return UNZ_OK;
+}
+
+
+/*
+   Translate date/time from Dos format to tm_unz (readable more easilty)
+*/
+static void unzlocal_DosDateToTmuDate (uLong ulDosDate, tm_unz* ptm)
+{
+    uLong uDate;
+    uDate = (uLong)(ulDosDate>>16);
+    ptm->tm_mday = (uInt)(uDate&0x1f) ;
+    ptm->tm_mon =  (uInt)((((uDate)&0x1E0)/0x20)-1) ;
+    ptm->tm_year = (uInt)(((uDate&0x0FE00)/0x0200)+1980) ;
+
+    ptm->tm_hour = (uInt) ((ulDosDate &0xF800)/0x800);
+    ptm->tm_min =  (uInt) ((ulDosDate&0x7E0)/0x20) ;
+    ptm->tm_sec =  (uInt) (2*(ulDosDate&0x1f)) ;
+}
+
+/*
+  Get Info about the current file in the zipfile, with internal only info
+*/
+static int unzlocal_GetCurrentFileInfoInternal (unzFile file,
+                                                  unz_file_info *pfile_info,
+                                                  unz_file_info_internal 
+                                                  *pfile_info_internal,
+                                                  char *szFileName,
+												  uLong fileNameBufferSize,
+                                                  void *extraField,
+												  uLong extraFieldBufferSize,
+                                                  char *szComment,
+												  uLong commentBufferSize)
+{
+	unz_s* s;
+	unz_file_info file_info;
+	unz_file_info_internal file_info_internal;
+	int err=UNZ_OK;
+	uLong uMagic;
+	long lSeek=0;
+
+	if (file==NULL)
+		return UNZ_PARAMERROR;
+	s=(unz_s*)file;
+	if (ZIP_fseek(s->file,s->pos_in_central_dir+s->byte_before_the_zipfile,SEEK_SET)!=0)
+		err=UNZ_ERRNO;
+
+
+	/* we check the magic */
+	if (err==UNZ_OK) {
+		if (unzlocal_getLong(s->file,&uMagic) != UNZ_OK)
+			err=UNZ_ERRNO;
+		else if (uMagic!=0x02014b50)
+			err=UNZ_BADZIPFILE;
+	}
+	if (unzlocal_getShort(s->file,&file_info.version) != UNZ_OK)
+		err=UNZ_ERRNO;
+
+	if (unzlocal_getShort(s->file,&file_info.version_needed) != UNZ_OK)
+		err=UNZ_ERRNO;
+
+	if (unzlocal_getShort(s->file,&file_info.flag) != UNZ_OK)
+		err=UNZ_ERRNO;
+
+	if (unzlocal_getShort(s->file,&file_info.compression_method) != UNZ_OK)
+		err=UNZ_ERRNO;
+
+	if (unzlocal_getLong(s->file,&file_info.dosDate) != UNZ_OK)
+		err=UNZ_ERRNO;
+
+    unzlocal_DosDateToTmuDate(file_info.dosDate,&file_info.tmu_date);
+
+	if (unzlocal_getLong(s->file,&file_info.crc) != UNZ_OK)
+		err=UNZ_ERRNO;
+
+	if (unzlocal_getLong(s->file,&file_info.compressed_size) != UNZ_OK)
+		err=UNZ_ERRNO;
+
+	if (unzlocal_getLong(s->file,&file_info.uncompressed_size) != UNZ_OK)
+		err=UNZ_ERRNO;
+
+	if (unzlocal_getShort(s->file,&file_info.size_filename) != UNZ_OK)
+		err=UNZ_ERRNO;
+
+	if (unzlocal_getShort(s->file,&file_info.size_file_extra) != UNZ_OK)
+		err=UNZ_ERRNO;
+
+	if (unzlocal_getShort(s->file,&file_info.size_file_comment) != UNZ_OK)
+		err=UNZ_ERRNO;
+
+	if (unzlocal_getShort(s->file,&file_info.disk_num_start) != UNZ_OK)
+		err=UNZ_ERRNO;
+
+	if (unzlocal_getShort(s->file,&file_info.internal_fa) != UNZ_OK)
+		err=UNZ_ERRNO;
+
+	if (unzlocal_getLong(s->file,&file_info.external_fa) != UNZ_OK)
+		err=UNZ_ERRNO;
+
+	if (unzlocal_getLong(s->file,&file_info_internal.offset_curfile) != UNZ_OK)
+		err=UNZ_ERRNO;
+
+	lSeek+=file_info.size_filename;
+	if ((err==UNZ_OK) && (szFileName!=NULL))
+	{
+		uLong uSizeRead ;
+		if (file_info.size_filename<fileNameBufferSize)
+		{
+			*(szFileName+file_info.size_filename)='\0';
+			uSizeRead = file_info.size_filename;
+		}
+		else
+			uSizeRead = fileNameBufferSize;
+
+		if ((file_info.size_filename>0) && (fileNameBufferSize>0))
+			if (ZIP_fread(szFileName,(uInt)uSizeRead,1,s->file)!=1)
+				err=UNZ_ERRNO;
+		lSeek -= uSizeRead;
+	}
+
+	
+	if ((err==UNZ_OK) && (extraField!=NULL))
+	{
+		uLong uSizeRead ;
+		if (file_info.size_file_extra<extraFieldBufferSize)
+			uSizeRead = file_info.size_file_extra;
+		else
+			uSizeRead = extraFieldBufferSize;
+
+		if (lSeek!=0) {
+			if (ZIP_fseek(s->file,lSeek,SEEK_CUR)==0)
+				lSeek=0;
+			else
+				err=UNZ_ERRNO;
+		}
+		if ((file_info.size_file_extra>0) && (extraFieldBufferSize>0)) {
+			if (ZIP_fread(extraField,(uInt)uSizeRead,1,s->file)!=1)
+				err=UNZ_ERRNO;
+		}
+		lSeek += file_info.size_file_extra - uSizeRead;
+	}
+	else
+		lSeek+=file_info.size_file_extra; 
+
+	
+	if ((err==UNZ_OK) && (szComment!=NULL))
+	{
+		uLong uSizeRead ;
+		if (file_info.size_file_comment<commentBufferSize)
+		{
+			*(szComment+file_info.size_file_comment)='\0';
+			uSizeRead = file_info.size_file_comment;
+		}
+		else
+			uSizeRead = commentBufferSize;
+
+		if (lSeek!=0) {
+			if (ZIP_fseek(s->file,lSeek,SEEK_CUR)==0)
+				lSeek=0;
+			else
+				err=UNZ_ERRNO;
+		}
+		if ((file_info.size_file_comment>0) && (commentBufferSize>0)) {
+			if (ZIP_fread(szComment,(uInt)uSizeRead,1,s->file)!=1)
+				err=UNZ_ERRNO;
+		}
+		lSeek+=file_info.size_file_comment - uSizeRead;
+	}
+	else
+		lSeek+=file_info.size_file_comment;
+
+	if ((err==UNZ_OK) && (pfile_info!=NULL))
+		*pfile_info=file_info;
+
+	if ((err==UNZ_OK) && (pfile_info_internal!=NULL))
+		*pfile_info_internal=file_info_internal;
+
+	return err;
+}
+
+
+
+/*
+  Write info about the ZipFile in the *pglobal_info structure.
+  No preparation of the structure is needed
+  return UNZ_OK if there is no problem.
+*/
+extern int unzGetCurrentFileInfo (	unzFile file, unz_file_info *pfile_info,
+									char *szFileName, uLong fileNameBufferSize,
+									void *extraField, uLong extraFieldBufferSize,
+									char *szComment, uLong commentBufferSize)
+{
+	return unzlocal_GetCurrentFileInfoInternal(file,pfile_info,NULL,
+												szFileName,fileNameBufferSize,
+												extraField,extraFieldBufferSize,
+												szComment,commentBufferSize);
+}
+
+/*
+  Set the current file of the zipfile to the first file.
+  return UNZ_OK if there is no problem
+*/
+extern int unzGoToFirstFile (unzFile file)
+{
+	int err=UNZ_OK;
+	unz_s* s;
+	if (file==NULL)
+		return UNZ_PARAMERROR;
+	s=(unz_s*)file;
+	s->pos_in_central_dir=s->offset_central_dir;
+	s->num_file=0;
+	err=unzlocal_GetCurrentFileInfoInternal(file,&s->cur_file_info,
+											 &s->cur_file_info_internal,
+											 NULL,0,NULL,0,NULL,0);
+	s->current_file_ok = (err == UNZ_OK);
+	return err;
+}
+
+
+/*
+  Set the current file of the zipfile to the next file.
+  return UNZ_OK if there is no problem
+  return UNZ_END_OF_LIST_OF_FILE if the actual file was the latest.
+*/
+extern int unzGoToNextFile (unzFile file)
+{
+	unz_s* s;	
+	int err;
+
+	if (file==NULL)
+		return UNZ_PARAMERROR;
+	s=(unz_s*)file;
+	if (!s->current_file_ok)
+		return UNZ_END_OF_LIST_OF_FILE;
+	if (s->num_file+1==s->gi.number_entry)
+		return UNZ_END_OF_LIST_OF_FILE;
+
+	s->pos_in_central_dir += SIZECENTRALDIRITEM + s->cur_file_info.size_filename +
+			s->cur_file_info.size_file_extra + s->cur_file_info.size_file_comment ;
+	s->num_file++;
+	err = unzlocal_GetCurrentFileInfoInternal(file,&s->cur_file_info,
+											   &s->cur_file_info_internal,
+											   NULL,0,NULL,0,NULL,0);
+	s->current_file_ok = (err == UNZ_OK);
+	return err;
+}
+
+/*
+  Get the position of the info of the current file in the zip.
+  return UNZ_OK if there is no problem
+*/
+extern int unzGetCurrentFileInfoPosition (unzFile file, unsigned long *pos )
+{
+	unz_s* s;	
+
+	if (file==NULL)
+		return UNZ_PARAMERROR;
+	s=(unz_s*)file;
+
+	*pos = s->pos_in_central_dir;
+	return UNZ_OK;
+}
+
+/*
+  Set the position of the info of the current file in the zip.
+  return UNZ_OK if there is no problem
+*/
+extern int unzSetCurrentFileInfoPosition (unzFile file, unsigned long pos )
+{
+	unz_s* s;	
+	int err;
+
+	if (file==NULL)
+		return UNZ_PARAMERROR;
+	s=(unz_s*)file;
+
+	s->pos_in_central_dir = pos;
+	err = unzlocal_GetCurrentFileInfoInternal(file,&s->cur_file_info,
+											   &s->cur_file_info_internal,
+											   NULL,0,NULL,0,NULL,0);
+	s->current_file_ok = (err == UNZ_OK);
+	return UNZ_OK;
+}
+
+/*
+  Try locate the file szFileName in the zipfile.
+  For the iCaseSensitivity signification, see unzipStringFileNameCompare
+
+  return value :
+  UNZ_OK if the file is found. It becomes the current file.
+  UNZ_END_OF_LIST_OF_FILE if the file is not found
+*/
+extern int unzLocateFile (unzFile file, const char *szFileName, int iCaseSensitivity)
+{
+	unz_s* s;	
+	int err;
+
+	
+	uLong num_fileSaved;
+	uLong pos_in_central_dirSaved;
+
+
+	if (file==NULL)
+		return UNZ_PARAMERROR;
+
+    if (strlen(szFileName)>=UNZ_MAXFILENAMEINZIP)
+        return UNZ_PARAMERROR;
+
+	s=(unz_s*)file;
+	if (!s->current_file_ok)
+		return UNZ_END_OF_LIST_OF_FILE;
+
+	num_fileSaved = s->num_file;
+	pos_in_central_dirSaved = s->pos_in_central_dir;
+
+	err = unzGoToFirstFile(file);
+
+	while (err == UNZ_OK)
+	{
+		char szCurrentFileName[UNZ_MAXFILENAMEINZIP+1];
+		unzGetCurrentFileInfo(file,NULL,
+								szCurrentFileName,sizeof(szCurrentFileName)-1,
+								NULL,0,NULL,0);
+		if (unzStringFileNameCompare(szCurrentFileName,
+										szFileName,iCaseSensitivity)==0)
+			return UNZ_OK;
+		err = unzGoToNextFile(file);
+	}
+
+	s->num_file = num_fileSaved ;
+	s->pos_in_central_dir = pos_in_central_dirSaved ;
+	return err;
+}
+
+
+/*
+  Read the static header of the current zipfile
+  Check the coherency of the static header and info in the end of central
+        directory about this file
+  store in *piSizeVar the size of extra info in static header
+        (filename and size of extra field data)
+*/
+static int unzlocal_CheckCurrentFileCoherencyHeader (unz_s* s, uInt* piSizeVar,
+													uLong *poffset_local_extrafield,
+													uInt *psize_local_extrafield)
+{
+	uLong uMagic,uData,uFlags;
+	uLong size_filename;
+	uLong size_extra_field;
+	int err=UNZ_OK;
+
+	*piSizeVar = 0;
+	*poffset_local_extrafield = 0;
+	*psize_local_extrafield = 0;
+
+	if (ZIP_fseek(s->file,s->cur_file_info_internal.offset_curfile +
+								s->byte_before_the_zipfile,SEEK_SET)!=0)
+		return UNZ_ERRNO;
+
+
+	if (err==UNZ_OK) {
+		if (unzlocal_getLong(s->file,&uMagic) != UNZ_OK)
+			err=UNZ_ERRNO;
+		else if (uMagic!=0x04034b50)
+			err=UNZ_BADZIPFILE;
+	}
+	if (unzlocal_getShort(s->file,&uData) != UNZ_OK)
+		err=UNZ_ERRNO;
+/*
+	else if ((err==UNZ_OK) && (uData!=s->cur_file_info.wVersion))
+		err=UNZ_BADZIPFILE;
+*/
+	if (unzlocal_getShort(s->file,&uFlags) != UNZ_OK)
+		err=UNZ_ERRNO;
+
+	if (unzlocal_getShort(s->file,&uData) != UNZ_OK)
+		err=UNZ_ERRNO;
+	else if ((err==UNZ_OK) && (uData!=s->cur_file_info.compression_method))
+		err=UNZ_BADZIPFILE;
+
+    if ((err==UNZ_OK) && (s->cur_file_info.compression_method!=0) &&
+                         (s->cur_file_info.compression_method!=ZF_DEFLATED))
+        err=UNZ_BADZIPFILE;
+
+	if (unzlocal_getLong(s->file,&uData) != UNZ_OK) /* date/time */
+		err=UNZ_ERRNO;
+
+	if (unzlocal_getLong(s->file,&uData) != UNZ_OK) /* crc */
+		err=UNZ_ERRNO;
+	else if ((err==UNZ_OK) && (uData!=s->cur_file_info.crc) &&
+		                      ((uFlags & 8)==0))
+		err=UNZ_BADZIPFILE;
+
+	if (unzlocal_getLong(s->file,&uData) != UNZ_OK) /* size compr */
+		err=UNZ_ERRNO;
+	else if ((err==UNZ_OK) && (uData!=s->cur_file_info.compressed_size) &&
+							  ((uFlags & 8)==0))
+		err=UNZ_BADZIPFILE;
+
+	if (unzlocal_getLong(s->file,&uData) != UNZ_OK) /* size uncompr */
+		err=UNZ_ERRNO;
+	else if ((err==UNZ_OK) && (uData!=s->cur_file_info.uncompressed_size) && 
+							  ((uFlags & 8)==0))
+		err=UNZ_BADZIPFILE;
+
+
+	if (unzlocal_getShort(s->file,&size_filename) != UNZ_OK)
+		err=UNZ_ERRNO;
+	else if ((err==UNZ_OK) && (size_filename!=s->cur_file_info.size_filename))
+		err=UNZ_BADZIPFILE;
+
+	*piSizeVar += (uInt)size_filename;
+
+	if (unzlocal_getShort(s->file,&size_extra_field) != UNZ_OK)
+		err=UNZ_ERRNO;
+	*poffset_local_extrafield= s->cur_file_info_internal.offset_curfile +
+									SIZEZIPLOCALHEADER + size_filename;
+	*psize_local_extrafield = (uInt)size_extra_field;
+
+	*piSizeVar += (uInt)size_extra_field;
+
+	return err;
+}
+												
+/*
+  Open for reading data the current file in the zipfile.
+  If there is no error and the file is opened, the return value is UNZ_OK.
+*/
+extern int unzOpenCurrentFile (unzFile file)
+{
+	int err=UNZ_OK;
+	int Store;
+	uInt iSizeVar;
+	unz_s* s;
+	file_in_zip_read_info_s* pfile_in_zip_read_info;
+	uLong offset_local_extrafield;  /* offset of the static extra field */
+	uInt  size_local_extrafield;    /* size of the static extra field */
+
+	if (file==NULL)
+		return UNZ_PARAMERROR;
+	s=(unz_s*)file;
+	if (!s->current_file_ok)
+		return UNZ_PARAMERROR;
+
+    if (s->pfile_in_zip_read != NULL)
+        unzCloseCurrentFile(file);
+
+	if (unzlocal_CheckCurrentFileCoherencyHeader(s,&iSizeVar,
+				&offset_local_extrafield,&size_local_extrafield)!=UNZ_OK)
+		return UNZ_BADZIPFILE;
+
+	pfile_in_zip_read_info = (file_in_zip_read_info_s*) ALLOC(sizeof(file_in_zip_read_info_s));
+
+	pfile_in_zip_read_info->read_buffer=(char*)ALLOC(UNZ_BUFSIZE);
+	pfile_in_zip_read_info->offset_local_extrafield = offset_local_extrafield;
+	pfile_in_zip_read_info->size_local_extrafield = size_local_extrafield;
+	pfile_in_zip_read_info->pos_local_extrafield=0;
+
+	pfile_in_zip_read_info->stream_initialised=0;
+	
+	if ((s->cur_file_info.compression_method!=0) &&
+        (s->cur_file_info.compression_method!=ZF_DEFLATED))
+		err=UNZ_BADZIPFILE;
+	Store = s->cur_file_info.compression_method==0;
+
+	pfile_in_zip_read_info->crc32_wait=s->cur_file_info.crc;
+	pfile_in_zip_read_info->crc32=0;
+	pfile_in_zip_read_info->compression_method =
+            s->cur_file_info.compression_method;
+	pfile_in_zip_read_info->file=s->file;
+	pfile_in_zip_read_info->byte_before_the_zipfile=s->byte_before_the_zipfile;
+
+    pfile_in_zip_read_info->stream.total_out = 0;
+
+	if (!Store)
+	{
+	  err=inflateInit(&pfile_in_zip_read_info->stream, Z_SYNC_FLUSH, 1);
+	  if (err == Z_OK)
+	    pfile_in_zip_read_info->stream_initialised=1;
+        /* windowBits is passed < 0 to tell that there is no zlib header.
+         * Note that in this case inflate *requires* an extra "dummy" byte
+         * after the compressed stream in order to complete decompression and
+         * return Z_STREAM_END. 
+         * In unzip, i don't wait absolutely Z_STREAM_END because I known the 
+         * size of both compressed and uncompressed data
+         */
+	}
+	pfile_in_zip_read_info->rest_read_compressed = 
+            s->cur_file_info.compressed_size ;
+	pfile_in_zip_read_info->rest_read_uncompressed = 
+            s->cur_file_info.uncompressed_size ;
+
+	
+	pfile_in_zip_read_info->pos_in_zipfile = 
+            s->cur_file_info_internal.offset_curfile + SIZEZIPLOCALHEADER + 
+			  iSizeVar;
+	
+	pfile_in_zip_read_info->stream.avail_in = (uInt)0;
+
+
+	s->pfile_in_zip_read = pfile_in_zip_read_info;
+    return UNZ_OK;
+}
+
+
+/*
+  Read bytes from the current file.
+  buf contain buffer where data must be copied
+  len the size of buf.
+
+  return the number of byte copied if somes bytes are copied
+  return 0 if the end of file was reached
+  return <0 with error code if there is an error
+    (UNZ_ERRNO for IO error, or zLib error for uncompress error)
+*/
+extern int unzReadCurrentFile  (unzFile file, void *buf, unsigned len)
+{
+	int err=UNZ_OK;
+	uInt iRead = 0;
+	unz_s* s;
+	file_in_zip_read_info_s* pfile_in_zip_read_info;
+	if (file==NULL)
+		return UNZ_PARAMERROR;
+	s=(unz_s*)file;
+    pfile_in_zip_read_info=s->pfile_in_zip_read;
+
+	if (pfile_in_zip_read_info==NULL)
+		return UNZ_PARAMERROR;
+
+
+	if ((pfile_in_zip_read_info->read_buffer == NULL))
+		return UNZ_END_OF_LIST_OF_FILE;
+	if (len==0)
+		return 0;
+
+	pfile_in_zip_read_info->stream.next_out = (Byte*)buf;
+
+	pfile_in_zip_read_info->stream.avail_out = (uInt)len;
+	
+	if (len>pfile_in_zip_read_info->rest_read_uncompressed)
+		pfile_in_zip_read_info->stream.avail_out = 
+		  (uInt)pfile_in_zip_read_info->rest_read_uncompressed;
+
+	while (pfile_in_zip_read_info->stream.avail_out>0)
+	{
+		if ((pfile_in_zip_read_info->stream.avail_in==0) &&
+            (pfile_in_zip_read_info->rest_read_compressed>0))
+		{
+			uInt uReadThis = UNZ_BUFSIZE;
+			if (pfile_in_zip_read_info->rest_read_compressed<uReadThis)
+				uReadThis = (uInt)pfile_in_zip_read_info->rest_read_compressed;
+			if (uReadThis == 0)
+				return UNZ_EOF;
+			if (s->cur_file_info.compressed_size == pfile_in_zip_read_info->rest_read_compressed)
+				if (ZIP_fseek(pfile_in_zip_read_info->file,
+						  pfile_in_zip_read_info->pos_in_zipfile + 
+							 pfile_in_zip_read_info->byte_before_the_zipfile,SEEK_SET)!=0)
+					return UNZ_ERRNO;
+			if (ZIP_fread(pfile_in_zip_read_info->read_buffer,uReadThis,1,
+                         pfile_in_zip_read_info->file)!=1)
+				return UNZ_ERRNO;
+			pfile_in_zip_read_info->pos_in_zipfile += uReadThis;
+
+			pfile_in_zip_read_info->rest_read_compressed-=uReadThis;
+			
+			pfile_in_zip_read_info->stream.next_in = 
+                (Byte*)pfile_in_zip_read_info->read_buffer;
+			pfile_in_zip_read_info->stream.avail_in = (uInt)uReadThis;
+		}
+
+		if (pfile_in_zip_read_info->compression_method==0)
+		{
+			uInt uDoCopy,i ;
+			if (pfile_in_zip_read_info->stream.avail_out < 
+                            pfile_in_zip_read_info->stream.avail_in)
+				uDoCopy = pfile_in_zip_read_info->stream.avail_out ;
+			else
+				uDoCopy = pfile_in_zip_read_info->stream.avail_in ;
+				
+			for (i=0;i<uDoCopy;i++)
+				*(pfile_in_zip_read_info->stream.next_out+i) =
+                        *(pfile_in_zip_read_info->stream.next_in+i);
+					
+//			pfile_in_zip_read_info->crc32 = crc32(pfile_in_zip_read_info->crc32,
+//								pfile_in_zip_read_info->stream.next_out,
+//								uDoCopy);
+			pfile_in_zip_read_info->rest_read_uncompressed-=uDoCopy;
+			pfile_in_zip_read_info->stream.avail_in -= uDoCopy;
+			pfile_in_zip_read_info->stream.avail_out -= uDoCopy;
+			pfile_in_zip_read_info->stream.next_out += uDoCopy;
+			pfile_in_zip_read_info->stream.next_in += uDoCopy;
+            pfile_in_zip_read_info->stream.total_out += uDoCopy;
+			iRead += uDoCopy;
+		}
+		else
+		{
+			uLong uTotalOutBefore,uTotalOutAfter;
+			const Byte *bufBefore;
+			uLong uOutThis;
+
+			uTotalOutBefore = pfile_in_zip_read_info->stream.total_out;
+			bufBefore = pfile_in_zip_read_info->stream.next_out;
+
+			/*
+			if ((pfile_in_zip_read_info->rest_read_uncompressed ==
+			         pfile_in_zip_read_info->stream.avail_out) &&
+				(pfile_in_zip_read_info->rest_read_compressed == 0))
+				flush = Z_FINISH;
+			*/
+			err=inflate(&pfile_in_zip_read_info->stream);
+
+			uTotalOutAfter = pfile_in_zip_read_info->stream.total_out;
+			uOutThis = uTotalOutAfter-uTotalOutBefore;
+			
+//			pfile_in_zip_read_info->crc32 = 
+//                crc32(pfile_in_zip_read_info->crc32,bufBefore,
+//                        (uInt)(uOutThis));
+
+			pfile_in_zip_read_info->rest_read_uncompressed -=
+                uOutThis;
+
+			iRead += (uInt)(uTotalOutAfter - uTotalOutBefore);
+            
+			if (err==Z_STREAM_END)
+				return (iRead==0) ? UNZ_EOF : iRead;
+			if (err!=Z_OK) 
+				break;
+		}
+	}
+
+	if (err==Z_OK)
+		return iRead;
+	return err;
+}
+
+
+/*
+  Give the current position in uncompressed data
+*/
+extern long unztell (unzFile file)
+{
+	unz_s* s;
+	file_in_zip_read_info_s* pfile_in_zip_read_info;
+	if (file==NULL)
+		return UNZ_PARAMERROR;
+	s=(unz_s*)file;
+    pfile_in_zip_read_info=s->pfile_in_zip_read;
+
+	if (pfile_in_zip_read_info==NULL)
+		return UNZ_PARAMERROR;
+
+	return (long)pfile_in_zip_read_info->stream.total_out;
+}
+
+
+/*
+  return 1 if the end of file was reached, 0 elsewhere 
+*/
+extern int unzeof (unzFile file)
+{
+	unz_s* s;
+	file_in_zip_read_info_s* pfile_in_zip_read_info;
+	if (file==NULL)
+		return UNZ_PARAMERROR;
+	s=(unz_s*)file;
+    pfile_in_zip_read_info=s->pfile_in_zip_read;
+
+	if (pfile_in_zip_read_info==NULL)
+		return UNZ_PARAMERROR;
+	
+	if (pfile_in_zip_read_info->rest_read_uncompressed == 0)
+		return 1;
+	else
+		return 0;
+}
+
+
+
+/*
+  Read extra field from the current file (opened by unzOpenCurrentFile)
+  This is the static-header version of the extra field (sometimes, there is
+    more info in the static-header version than in the central-header)
+
+  if buf==NULL, it return the size of the static extra field that can be read
+
+  if buf!=NULL, len is the size of the buffer, the extra header is copied in
+	buf.
+  the return value is the number of bytes copied in buf, or (if <0) 
+	the error code
+*/
+extern int unzGetLocalExtrafield (unzFile file,void *buf,unsigned len)
+{
+	unz_s* s;
+	file_in_zip_read_info_s* pfile_in_zip_read_info;
+	uInt read_now;
+	uLong size_to_read;
+
+	if (file==NULL)
+		return UNZ_PARAMERROR;
+	s=(unz_s*)file;
+    pfile_in_zip_read_info=s->pfile_in_zip_read;
+
+	if (pfile_in_zip_read_info==NULL)
+		return UNZ_PARAMERROR;
+
+	size_to_read = (pfile_in_zip_read_info->size_local_extrafield - 
+				pfile_in_zip_read_info->pos_local_extrafield);
+
+	if (buf==NULL)
+		return (int)size_to_read;
+	
+	if (len>size_to_read)
+		read_now = (uInt)size_to_read;
+	else
+		read_now = (uInt)len ;
+
+	if (read_now==0)
+		return 0;
+	
+	if (ZIP_fseek(pfile_in_zip_read_info->file,
+              pfile_in_zip_read_info->offset_local_extrafield + 
+			  pfile_in_zip_read_info->pos_local_extrafield,SEEK_SET)!=0)
+		return UNZ_ERRNO;
+
+	if (ZIP_fread(buf,(uInt)size_to_read,1,pfile_in_zip_read_info->file)!=1)
+		return UNZ_ERRNO;
+
+	return (int)read_now;
+}
+
+/*
+  Close the file in zip opened with unzipOpenCurrentFile
+  Return UNZ_CRCERROR if all the file was read but the CRC is not good
+*/
+extern int unzCloseCurrentFile (unzFile file)
+{
+	int err=UNZ_OK;
+
+	unz_s* s;
+	file_in_zip_read_info_s* pfile_in_zip_read_info;
+	if (file==NULL)
+		return UNZ_PARAMERROR;
+	s=(unz_s*)file;
+    pfile_in_zip_read_info=s->pfile_in_zip_read;
+
+	if (pfile_in_zip_read_info==NULL)
+		return UNZ_PARAMERROR;
+
+/*
+	if (pfile_in_zip_read_info->rest_read_uncompressed == 0)
+	{
+		if (pfile_in_zip_read_info->crc32 != pfile_in_zip_read_info->crc32_wait)
+			err=UNZ_CRCERROR;
+	}
+*/
+
+	TRYFREE(pfile_in_zip_read_info->read_buffer);
+	pfile_in_zip_read_info->read_buffer = NULL;
+	if (pfile_in_zip_read_info->stream_initialised)
+		inflateEnd(&pfile_in_zip_read_info->stream);
+
+	pfile_in_zip_read_info->stream_initialised = 0;
+	TRYFREE(pfile_in_zip_read_info);
+
+    s->pfile_in_zip_read=NULL;
+
+	return err;
+}
+
+
+/*
+  Get the global comment string of the ZipFile, in the szComment buffer.
+  uSizeBuf is the size of the szComment buffer.
+  return the number of byte copied or an error code <0
+*/
+extern int unzGetGlobalComment (unzFile file, char *szComment, uLong uSizeBuf)
+{
+	unz_s* s;
+	uLong uReadThis ;
+	if (file==NULL)
+		return UNZ_PARAMERROR;
+	s=(unz_s*)file;
+
+	uReadThis = uSizeBuf;
+	if (uReadThis>s->gi.size_comment)
+		uReadThis = s->gi.size_comment;
+
+	if (ZIP_fseek(s->file,s->central_pos+22,SEEK_SET)!=0)
+		return UNZ_ERRNO;
+
+	if (uReadThis>0)
+    {
+      *szComment='\0';
+	  if (ZIP_fread(szComment,(uInt)uReadThis,1,s->file)!=1)
+		return UNZ_ERRNO;
+    }
+
+	if ((szComment != NULL) && (uSizeBuf > s->gi.size_comment))
+		*(szComment+s->gi.size_comment)='\0';
+	return (int)uReadThis;
+}
+
+// end
diff --git a/codemp/qcommon/unzip.h b/codemp/qcommon/unzip.h
new file mode 100644
index 0000000..e7fc924
--- /dev/null
+++ b/codemp/qcommon/unzip.h
@@ -0,0 +1,289 @@
+//unzip.h
+
+#define ZIP_FILE	FILE
+
+#if defined(STRICTUNZIP) || defined(STRICTZIPUNZIP)
+/* like the STRICT of WIN32, we define a pointer that cannot be converted
+    from (void*) without cast */
+typedef struct TagunzFile__ { int unused; } unzFile__; 
+typedef unzFile__ *unzFile;
+#else
+typedef void* unzFile;
+#endif
+
+/* tm_unz contain date/time info */
+typedef struct tm_unz_s 
+{
+	unsigned int tm_sec;            /* seconds after the minute - [0,59] */
+	unsigned int tm_min;            /* minutes after the hour - [0,59] */
+	unsigned int tm_hour;           /* hours since midnight - [0,23] */
+	unsigned int tm_mday;           /* day of the month - [1,31] */
+	unsigned int tm_mon;            /* months since January - [0,11] */
+	unsigned int tm_year;           /* years - [1980..2044] */
+} tm_unz;
+
+/* unz_global_info structure contain global data about the ZIPfile
+   These data comes from the end of central dir */
+typedef struct unz_global_info_s
+{
+	unsigned long number_entry;         /* total number of entries in the central dir on this disk */
+	unsigned long size_comment;         /* size of the global comment of the zipfile */
+} unz_global_info;
+
+
+/* unz_file_info contain information about a file in the zipfile */
+typedef struct unz_file_info_s
+{
+    unsigned long version;              /* version made by                 2 unsigned chars */
+    unsigned long version_needed;       /* version needed to extract       2 unsigned chars */
+    unsigned long flag;                 /* general purpose bit flag        2 unsigned chars */
+    unsigned long compression_method;   /* compression method              2 unsigned chars */
+    unsigned long dosDate;              /* last mod file date in Dos fmt   4 unsigned chars */
+    unsigned long crc;                  /* crc-32                          4 unsigned chars */
+    unsigned long compressed_size;      /* compressed size                 4 unsigned chars */ 
+    unsigned long uncompressed_size;    /* uncompressed size               4 unsigned chars */ 
+    unsigned long size_filename;        /* filename length                 2 unsigned chars */
+    unsigned long size_file_extra;      /* extra field length              2 unsigned chars */
+    unsigned long size_file_comment;    /* file comment length             2 unsigned chars */
+
+    unsigned long disk_num_start;       /* disk number start               2 unsigned chars */
+    unsigned long internal_fa;          /* internal file attributes        2 unsigned chars */
+    unsigned long external_fa;          /* external file attributes        4 unsigned chars */
+
+    tm_unz tmu_date;
+} unz_file_info;
+
+/* unz_file_info_interntal contain internal info about a file in zipfile*/
+typedef struct unz_file_info_internal_s
+{
+    unsigned long offset_curfile;/* relative offset of static header 4 unsigned chars */
+} unz_file_info_internal;
+
+/* file_in_zip_read_info_s contain internal information about a file in zipfile,
+    when reading and decompress it */
+typedef struct
+{
+	char  *read_buffer;         /* internal buffer for compressed data */
+	z_stream stream;            /* zLib stream structure for inflate */
+
+	unsigned long pos_in_zipfile;       /* position in unsigned char on the zipfile, for fseek*/
+	unsigned long stream_initialised;   /* flag set if stream structure is initialised*/
+
+	unsigned long offset_local_extrafield;/* offset of the static extra field */
+	unsigned int  size_local_extrafield;/* size of the static extra field */
+	unsigned long pos_local_extrafield;   /* position in the static extra field in read*/
+
+	unsigned long crc32;                /* crc32 of all data uncompressed */
+	unsigned long crc32_wait;           /* crc32 we must obtain after decompress all */
+	unsigned long rest_read_compressed; /* number of unsigned char to be decompressed */
+	unsigned long rest_read_uncompressed;/*number of unsigned char to be obtained after decomp*/
+	ZIP_FILE *file;                 /* io structore of the zipfile */
+	unsigned long compression_method;   /* compression method (0==store) */
+	unsigned long byte_before_the_zipfile;/* unsigned char before the zipfile, (>0 for sfx)*/
+} file_in_zip_read_info_s;
+
+
+/* unz_s contain internal information about the zipfile
+*/
+typedef struct
+{
+	ZIP_FILE* file;                 /* io structore of the zipfile */
+	unz_global_info gi;       /* public global information */
+	unsigned long byte_before_the_zipfile;/* unsigned char before the zipfile, (>0 for sfx)*/
+	unsigned long num_file;             /* number of the current file in the zipfile*/
+	unsigned long pos_in_central_dir;   /* pos of the current file in the central dir*/
+	unsigned long current_file_ok;      /* flag about the usability of the current file*/
+	unsigned long central_pos;          /* position of the beginning of the central dir*/
+
+	unsigned long size_central_dir;     /* size of the central directory  */
+	unsigned long offset_central_dir;   /* offset of start of central directory with
+								   respect to the starting disk number */
+
+	unz_file_info cur_file_info; /* public info about the current file in zip*/
+	unz_file_info_internal cur_file_info_internal; /* private info about it*/
+    file_in_zip_read_info_s* pfile_in_zip_read; /* structure about the current
+	                                    file if we are decompressing it */
+	unsigned char*	tmpFile;
+	int	tmpPos,tmpSize;
+} unz_s;
+
+#define UNZ_OK                                  (0)
+#define UNZ_END_OF_LIST_OF_FILE (-100)
+#define UNZ_ERRNO               (Z_DATA_ERROR)
+#define UNZ_EOF                 (0)
+#define UNZ_PARAMERROR                  (-102)
+#define UNZ_BADZIPFILE                  (-103)
+#define UNZ_INTERNALERROR               (-104)
+#define UNZ_CRCERROR                    (-105)
+
+#define UNZ_CASESENSITIVE		1
+#define UNZ_NOTCASESENSITIVE	2
+#define UNZ_OSDEFAULTCASE		0
+
+extern int unzStringFileNameCompare (const char* fileName1, const char* fileName2, int iCaseSensitivity);
+
+/*
+   Compare two filename (fileName1,fileName2).
+   If iCaseSenisivity = 1, comparision is case sensitivity (like strcmp)
+   If iCaseSenisivity = 2, comparision is not case sensitivity (like strcmpi
+								or strcasecmp)
+   If iCaseSenisivity = 0, case sensitivity is defaut of your operating system
+	(like 1 on Unix, 2 on Windows)
+*/
+
+extern unzFile unzOpen (const char *path);
+extern unzFile unzReOpen (const char* path, unzFile file);
+
+/*
+  Open a Zip file. path contain the full pathname (by example,
+     on a Windows NT computer "c:\\zlib\\zlib111.zip" or on an Unix computer
+	 "zlib/zlib111.zip".
+	 If the zipfile cannot be opened (file don't exist or in not valid), the
+	   return value is NULL.
+     Else, the return value is a unzFile Handle, usable with other function
+	   of this unzip package.
+*/
+
+extern int unzClose (unzFile file);
+
+/*
+  Close a ZipFile opened with unzipOpen.
+  If there is files inside the .Zip opened with unzOpenCurrentFile (see later),
+    these files MUST be closed with unzipCloseCurrentFile before call unzipClose.
+  return UNZ_OK if there is no problem. */
+
+extern int unzGetGlobalInfo (unzFile file, unz_global_info *pglobal_info);
+
+/*
+  Write info about the ZipFile in the *pglobal_info structure.
+  No preparation of the structure is needed
+  return UNZ_OK if there is no problem. */
+
+
+extern int unzGetGlobalComment (unzFile file, char *szComment, unsigned long uSizeBuf);
+
+/*
+  Get the global comment string of the ZipFile, in the szComment buffer.
+  uSizeBuf is the size of the szComment buffer.
+  return the number of unsigned char copied or an error code <0
+*/
+
+
+/***************************************************************************/
+/* Unzip package allow you browse the directory of the zipfile */
+
+extern int unzGoToFirstFile (unzFile file);
+
+/*
+  Set the current file of the zipfile to the first file.
+  return UNZ_OK if there is no problem
+*/
+
+extern int unzGoToNextFile (unzFile file);
+
+/*
+  Set the current file of the zipfile to the next file.
+  return UNZ_OK if there is no problem
+  return UNZ_END_OF_LIST_OF_FILE if the actual file was the latest.
+*/
+
+extern int unzGetCurrentFileInfoPosition (unzFile file, unsigned long *pos );
+
+/*
+  Get the position of the info of the current file in the zip.
+  return UNZ_OK if there is no problem
+*/
+
+extern int unzSetCurrentFileInfoPosition (unzFile file, unsigned long pos );
+
+/*
+  Set the position of the info of the current file in the zip.
+  return UNZ_OK if there is no problem
+*/
+
+extern int unzLocateFile (unzFile file, const char *szFileName, int iCaseSensitivity);
+
+/*
+  Try locate the file szFileName in the zipfile.
+  For the iCaseSensitivity signification, see unzStringFileNameCompare
+
+  return value :
+  UNZ_OK if the file is found. It becomes the current file.
+  UNZ_END_OF_LIST_OF_FILE if the file is not found
+*/
+
+
+extern int unzGetCurrentFileInfo (unzFile file, unz_file_info *pfile_info, char *szFileName, unsigned long fileNameBufferSize, void *extraField, unsigned long extraFieldBufferSize, char *szComment, unsigned long commentBufferSize);
+
+/*
+  Get Info about the current file
+  if pfile_info!=NULL, the *pfile_info structure will contain somes info about
+	    the current file
+  if szFileName!=NULL, the filemane string will be copied in szFileName
+			(fileNameBufferSize is the size of the buffer)
+  if extraField!=NULL, the extra field information will be copied in extraField
+			(extraFieldBufferSize is the size of the buffer).
+			This is the Central-header version of the extra field
+  if szComment!=NULL, the comment string of the file will be copied in szComment
+			(commentBufferSize is the size of the buffer)
+*/
+
+/***************************************************************************/
+/* for reading the content of the current zipfile, you can open it, read data
+   from it, and close it (you can close it before reading all the file)
+   */
+
+extern int unzOpenCurrentFile (unzFile file);
+
+/*
+  Open for reading data the current file in the zipfile.
+  If there is no error, the return value is UNZ_OK.
+*/
+
+extern int unzCloseCurrentFile (unzFile file);
+
+/*
+  Close the file in zip opened with unzOpenCurrentFile
+  Return UNZ_CRCERROR if all the file was read but the CRC is not good
+*/
+
+												
+extern int unzReadCurrentFile (unzFile file, void* buf, unsigned len);
+
+/*
+  Read unsigned chars from the current file (opened by unzOpenCurrentFile)
+  buf contain buffer where data must be copied
+  len the size of buf.
+
+  return the number of unsigned char copied if somes unsigned chars are copied
+  return 0 if the end of file was reached
+  return <0 with error code if there is an error
+    (UNZ_ERRNO for IO error, or zLib error for uncompress error)
+*/
+
+extern long unztell(unzFile file);
+
+/*
+  Give the current position in uncompressed data
+*/
+
+extern int unzeof (unzFile file);
+
+/*
+  return 1 if the end of file was reached, 0 elsewhere 
+*/
+
+extern int unzGetLocalExtrafield (unzFile file, void* buf, unsigned len);
+
+/*
+  Read extra field from the current file (opened by unzOpenCurrentFile)
+  This is the local-header version of the extra field (sometimes, there is
+    more info in the local-header version than in the central-header)
+
+  if buf==NULL, it return the size of the local extra field
+
+  if buf!=NULL, len is the size of the buffer, the extra header is copied in
+	buf.
+  the return value is the number of unsigned chars copied in buf, or (if <0) 
+	the error code
+*/
diff --git a/codemp/qcommon/vm.cpp b/codemp/qcommon/vm.cpp
new file mode 100644
index 0000000..29a3277
--- /dev/null
+++ b/codemp/qcommon/vm.cpp
@@ -0,0 +1,954 @@
+// vm.c -- virtual machine
+
+/*
+
+
+intermix code and data
+symbol table
+
+a dll has one imported function: VM_SystemCall
+and one exported function: Perform
+
+
+*/
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+#include "vm_local.h"
+
+#ifdef CRAZY_SYMBOL_MAP
+symbolVMMap_t		g_vmMap;
+symbolMap_t			*g_symbolMap;
+#endif
+
+vm_t	*currentVM = NULL; // bk001212
+vm_t	*lastVM    = NULL; // bk001212
+int		vm_debugLevel;
+
+#define	MAX_VM		3
+vm_t	vmTable[MAX_VM];
+
+void VM_VmInfo_f( void );
+void VM_VmProfile_f( void );
+
+
+// converts a VM pointer to a C pointer and
+// checks to make sure that the range is acceptable
+void	*VM_VM2C( vmptr_t p, int length ) {
+	return (void *)p;
+}
+
+void VM_Debug( int level ) {
+	vm_debugLevel = level;
+}
+
+/*
+==============
+VM_Init
+==============
+*/
+void VM_Init( void ) {
+	Cvar_Get( "vm_cgame", "0", CVAR_SYSTEMINFO|CVAR_ARCHIVE );	// default to DLLs now instead. Our VMs are getting too HUGE.
+	Cvar_Get( "vm_game", "0", CVAR_SYSTEMINFO|CVAR_ARCHIVE );	// 
+	Cvar_Get( "vm_ui", "0", CVAR_SYSTEMINFO|CVAR_ARCHIVE );		// 
+	//client wants to know if the server is using vm's for certain modules,
+	//so if pure we can force the same method (be it vm or dll) -rww
+
+	Cmd_AddCommand ("vmprofile", VM_VmProfile_f );
+	Cmd_AddCommand ("vminfo", VM_VmInfo_f );
+
+	Com_Memset( vmTable, 0, sizeof( vmTable ) );
+}
+
+/*
+===============
+VM_ValueToSymbol
+
+Assumes a program counter value
+===============
+*/
+const char *VM_ValueToSymbol( vm_t *vm, int value ) {
+	vmSymbol_t	*sym;
+	static char		text[MAX_TOKEN_CHARS];
+
+#ifdef CRAZY_SYMBOL_MAP
+	sym = (*g_symbolMap)[value];
+
+	if (!sym)
+	{
+#endif
+		sym = vm->symbols;
+		if ( !sym ) {
+			return "NO SYMBOLS";
+		}
+
+		// find the symbol
+		while ( sym->next && sym->next->symValue <= value ) {
+			sym = sym->next;
+		}
+#ifdef CRAZY_SYMBOL_MAP
+		if (sym)
+		{ //for instant recollection next time
+			(*g_symbolMap)[value] = sym;
+		}
+	}
+#endif
+
+	if ( value == sym->symValue ) {
+		return sym->symName;
+	}
+
+	Com_sprintf( text, sizeof( text ), "%s+%i", sym->symName, value - sym->symValue );
+
+	return text;
+}
+
+/*
+===============
+VM_ValueToFunctionSymbol
+
+For profiling, find the symbol behind this value
+===============
+*/
+vmSymbol_t *VM_ValueToFunctionSymbol( vm_t *vm, int value ) {
+	vmSymbol_t	*sym;
+	static vmSymbol_t	nullSym;
+
+#ifdef CRAZY_SYMBOL_MAP
+	sym = (*g_symbolMap)[value];
+
+	if ( !sym )
+	{
+#endif
+		sym = vm->symbols;
+		if ( !sym ) {
+			return &nullSym;
+		}
+
+		while ( sym->next && sym->next->symValue <= value ) {
+			sym = sym->next;
+		}
+#ifdef CRAZY_SYMBOL_MAP
+		if (sym)
+		{ //for instant recollection next time
+			(*g_symbolMap)[value] = sym;
+		}
+	}
+#endif
+
+	return sym;
+}
+
+
+/*
+===============
+VM_SymbolToValue
+===============
+*/
+int VM_SymbolToValue( vm_t *vm, const char *symbol ) {
+	vmSymbol_t	*sym;
+
+	for ( sym = vm->symbols ; sym ; sym = sym->next ) {
+		if ( !strcmp( symbol, sym->symName ) ) {
+			return sym->symValue;
+		}
+	}
+	return 0;
+}
+
+
+/*
+=====================
+VM_SymbolForCompiledPointer
+=====================
+*/
+const char *VM_SymbolForCompiledPointer( vm_t *vm, void *code ) {
+	int			i;
+
+	if ( code < (void *)vm->codeBase ) {
+		return "Before code block";
+	}
+	if ( code >= (void *)(vm->codeBase + vm->codeLength) ) {
+		return "After code block";
+	}
+
+	// find which original instruction it is after
+	for ( i = 0 ; i < vm->codeLength ; i++ ) {
+		if ( (void *)vm->instructionPointers[i] > code ) {
+			break;
+		}
+	}
+	i--;
+
+	// now look up the bytecode instruction pointer
+#ifdef CRAZY_SYMBOL_MAP
+	VM_SetSymbolMap(vm);
+#endif
+	return VM_ValueToSymbol( vm, i );
+}
+
+
+
+/*
+===============
+ParseHex
+===============
+*/
+int	ParseHex( const char *text ) {
+	int		value;
+	int		c;
+
+	value = 0;
+	while ( ( c = *text++ ) != 0 ) {
+		if ( c >= '0' && c <= '9' ) {
+			value = value * 16 + c - '0';
+			continue;
+		}
+		if ( c >= 'a' && c <= 'f' ) {
+			value = value * 16 + 10 + c - 'a';
+			continue;
+		}
+		if ( c >= 'A' && c <= 'F' ) {
+			value = value * 16 + 10 + c - 'A';
+			continue;
+		}
+	}
+
+	return value;
+}
+
+/*
+===============
+VM_Alloc
+
+Convenience function for changing the way VMs are allocated.
+===============
+*/
+void *VM_Alloc( int size )
+{
+	return Hunk_Alloc(size, h_high);
+	//return Z_Malloc(size, TAG_ALL, qtrue);
+}
+
+/*
+===============
+VM_LoadSymbols
+===============
+*/
+void VM_LoadSymbols( vm_t *vm ) {
+	int		len;
+	char	*mapfile, *token;
+	const	char *text_p;
+	char	name[MAX_QPATH];
+	char	symbols[MAX_QPATH];
+	vmSymbol_t	**prev, *sym;
+	int		count;
+	int		value;
+	int		chars;
+	int		segment;
+	int		numInstructions;
+
+	// don't load symbols if not developer
+	if ( !com_developer->integer ) {
+		return;
+	}
+
+	COM_StripExtension( vm->name, name );
+	Com_sprintf( symbols, sizeof( symbols ), "vm/%s.map", name );
+	len = FS_ReadFile( symbols, (void **)&mapfile );
+	if ( !mapfile ) {
+		Com_Printf( "Couldn't load symbol file: %s\n", symbols );
+		return;
+	}
+
+	numInstructions = vm->instructionPointersLength >> 2;
+
+	// parse the symbols
+	text_p = mapfile;
+	prev = &vm->symbols;
+	count = 0;
+
+#ifdef CRAZY_SYMBOL_MAP
+	VM_SetSymbolMap(vm);
+#endif
+
+	while ( 1 ) {
+		token = COM_Parse( &text_p );
+		if ( !token[0] ) {
+			break;
+		}
+		segment = ParseHex( token );
+		if ( segment ) {
+			COM_Parse( &text_p );
+			COM_Parse( &text_p );
+			continue;		// only load code segment values
+		}
+
+		token = COM_Parse( &text_p );
+		if ( !token[0] ) {
+			Com_Printf( "WARNING: incomplete line at end of file\n" );
+			break;
+		}
+		value = ParseHex( token );
+
+		token = COM_Parse( &text_p );
+		if ( !token[0] ) {
+			Com_Printf( "WARNING: incomplete line at end of file\n" );
+			break;
+		}
+		chars = strlen( token );
+		sym = (struct vmSymbol_s *)VM_Alloc( sizeof( *sym ) + chars );
+		*prev = sym;
+		prev = &sym->next;
+		sym->next = NULL;
+
+		// convert value from an instruction number to a code offset
+		if ( value >= 0 && value < numInstructions ) {
+			value = vm->instructionPointers[value];
+		}
+
+		sym->symValue = value;
+		Q_strncpyz( sym->symName, token, chars + 1 );
+
+#ifdef CRAZY_SYMBOL_MAP
+		(*g_symbolMap)[value] = sym;
+#endif
+
+		count++;
+	}
+
+	vm->numSymbols = count;
+	Com_Printf( "%i symbols parsed from %s\n", count, symbols );
+	FS_FreeFile( mapfile );
+}
+
+/*
+============
+VM_DllSyscall
+
+Dlls will call this directly
+
+ rcg010206 The horror; the horror.
+
+  The syscall mechanism relies on stack manipulation to get it's args.
+   This is likely due to C's inability to pass "..." parameters to
+   a function in one clean chunk. On PowerPC Linux, these parameters
+   are not necessarily passed on the stack, so while (&arg[0] == arg)
+   is true, (&arg[1] == 2nd function parameter) is not necessarily
+   accurate, as arg's value might have been stored to the stack or
+   other piece of scratch memory to give it a valid address, but the
+   next parameter might still be sitting in a register.
+
+  Quake's syscall system also assumes that the stack grows downward,
+   and that any needed types can be squeezed, safely, into a signed int.
+
+  This hack below copies all needed values for an argument to a
+   array in memory, so that Quake can get the correct values. This can
+   also be used on systems where the stack grows upwards, as the
+   presumably standard and safe stdargs.h macros are used.
+
+  As for having enough space in a signed int for your datatypes, well,
+   it might be better to wait for DOOM 3 before you start porting.  :)
+
+  The original code, while probably still inherently dangerous, seems
+   to work well enough for the platforms it already works on. Rather
+   than add the performance hit for those platforms, the original code
+   is still in use there.
+
+  For speed, we just grab 15 arguments, and don't worry about exactly
+   how many the syscall actually needs; the extra is thrown away.
+ 
+============
+*/
+int QDECL VM_DllSyscall( int arg, ... ) {
+#if ((defined __linux__) && (defined __powerpc__))
+  // rcg010206 - see commentary above
+  int args[16];
+  int i;
+  va_list ap;
+  
+  args[0] = arg;
+  
+  va_start(ap, arg);
+  for (i = 1; i < sizeof (args) / sizeof (args[i]); i++)
+    args[i] = va_arg(ap, int);
+  va_end(ap);
+  
+  return currentVM->systemCall( args );
+#else // original id code
+	return currentVM->systemCall( &arg );
+#endif
+}
+
+/*
+=================
+VM_Restart
+
+Reload the data, but leave everything else in place
+This allows a server to do a map_restart without changing memory allocation
+=================
+*/
+vm_t *VM_Restart( vm_t *vm ) {
+	vmHeader_t	*header;
+	int			length;
+	int			dataLength;
+	int			i;
+	char		filename[MAX_QPATH];
+
+	// DLL's can't be restarted in place
+	if ( vm->dllHandle ) {
+		char	name[MAX_QPATH];
+	    int			(*systemCall)( int *parms );
+		
+		systemCall = vm->systemCall;	
+		Q_strncpyz( name, vm->name, sizeof( name ) );
+
+		VM_Free( vm );
+
+		vm = VM_Create( name, systemCall, VMI_NATIVE );
+		return vm;
+	}
+
+	// load the image
+	Com_Printf( "VM_Restart()\n", filename );
+	Com_sprintf( filename, sizeof(filename), "vm/%s.qvm", vm->name );
+	Com_Printf( "Loading vm file %s.\n", filename );
+	length = FS_ReadFile( filename, (void **)&header );
+	if ( !header ) {
+		Com_Error( ERR_DROP, "VM_Restart failed.\n" );
+	}
+
+	// byte swap the header
+	for ( i = 0 ; i < sizeof( *header ) / 4 ; i++ ) {
+		((int *)header)[i] = LittleLong( ((int *)header)[i] );
+	}
+
+	// validate
+	if ( header->vmMagic != VM_MAGIC
+		|| header->bssLength < 0 
+		|| header->dataLength < 0 
+		|| header->litLength < 0 
+		|| header->codeLength <= 0 ) {
+		VM_Free( vm );
+		Com_Error( ERR_FATAL, "%s has bad header", filename );
+	}
+
+	// round up to next power of 2 so all data operations can
+	// be mask protected
+	dataLength = header->dataLength + header->litLength + header->bssLength;
+	for ( i = 0 ; dataLength > ( 1 << i ) ; i++ ) {
+	}
+	dataLength = 1 << i;
+
+	// clear the data
+	Com_Memset( vm->dataBase, 0, dataLength );
+
+	// copy the intialized data
+	Com_Memcpy( vm->dataBase, (byte *)header + header->dataOffset, header->dataLength + header->litLength );
+
+	// byte swap the longs
+	for ( i = 0 ; i < header->dataLength ; i += 4 ) {
+		*(int *)(vm->dataBase + i) = LittleLong( *(int *)(vm->dataBase + i ) );
+	}
+
+	// free the original file
+	FS_FreeFile( header );
+
+	return vm;
+}
+
+/*
+================
+VM_Create
+
+If image ends in .qvm it will be interpreted, otherwise
+it will attempt to load as a system dll
+================
+*/
+
+#define	STACK_SIZE	0x20000
+
+vm_t *VM_Create( const char *module, int (*systemCalls)(int *), 
+				vmInterpret_t interpret ) {
+	vm_t		*vm;
+	vmHeader_t	*header;
+	int			length;
+	int			dataLength;
+	int			i;
+	char		filename[MAX_QPATH];
+
+	if ( !module || !module[0] || !systemCalls ) {
+		Com_Error( ERR_FATAL, "VM_Create: bad parms" );
+	}
+
+	// see if we already have the VM
+	for ( i = 0 ; i < MAX_VM ; i++ ) {
+		if (!Q_stricmp(vmTable[i].name, module)) {
+			vm = &vmTable[i];
+			return vm;
+		}
+	}
+
+	// find a free vm
+	for ( i = 0 ; i < MAX_VM ; i++ ) {
+		if ( !vmTable[i].name[0] ) {
+			break;
+		}
+	}
+
+	if ( i == MAX_VM ) {
+		Com_Error( ERR_FATAL, "VM_Create: no free vm_t" );
+	}
+
+	vm = &vmTable[i];
+
+	Q_strncpyz( vm->name, module, sizeof( vm->name ) );
+	vm->systemCall = systemCalls;
+
+	// never allow dll loading with a demo
+	if ( interpret == VMI_NATIVE ) {
+		if ( Cvar_VariableValue( "fs_restrict" ) ) {
+			interpret = VMI_COMPILED;
+		}
+	}
+
+	if ( interpret == VMI_NATIVE ) {
+		// try to load as a system dll
+		Com_Printf( "Loading dll file %s.\n", vm->name );
+		vm->dllHandle = Sys_LoadDll( module, &vm->entryPoint, VM_DllSyscall );
+		if ( vm->dllHandle ) {
+			return vm;
+		}
+
+		Com_Printf( "Failed to load dll, looking for qvm.\n" );
+		interpret = VMI_COMPILED;
+	}
+
+	// load the image
+	Com_sprintf( filename, sizeof(filename), "vm/%s.qvm", vm->name );
+	Com_Printf( "Loading vm file %s.\n", filename );
+	length = FS_ReadFile( filename, (void **)&header );
+	if ( !header ) {
+		Com_Printf( "Failed.\n" );
+		VM_Free( vm );
+		return NULL;
+	}
+
+	// byte swap the header
+	for ( i = 0 ; i < sizeof( *header ) / 4 ; i++ ) {
+		((int *)header)[i] = LittleLong( ((int *)header)[i] );
+	}
+
+	// validate
+	if ( header->vmMagic != VM_MAGIC
+		|| header->bssLength < 0 
+		|| header->dataLength < 0 
+		|| header->litLength < 0 
+		|| header->codeLength <= 0 ) {
+		VM_Free( vm );
+		Com_Error( ERR_FATAL, "%s has bad header", filename );
+	}
+
+	// round up to next power of 2 so all data operations can
+	// be mask protected
+	dataLength = header->dataLength + header->litLength + header->bssLength;
+	for ( i = 0 ; dataLength > ( 1 << i ) ; i++ ) {
+	}
+	dataLength = 1 << i;
+
+	// allocate zero filled space for initialized and uninitialized data
+	vm->dataBase = (unsigned char *)VM_Alloc( dataLength );
+	vm->dataMask = dataLength - 1;
+
+	// copy the intialized data
+	Com_Memcpy( vm->dataBase, (byte *)header + header->dataOffset, header->dataLength + header->litLength );
+
+	// byte swap the longs
+	for ( i = 0 ; i < header->dataLength ; i += 4 ) {
+		*(int *)(vm->dataBase + i) = LittleLong( *(int *)(vm->dataBase + i ) );
+	}
+
+	// allocate space for the jump targets, which will be filled in by the compile/prep functions
+	vm->instructionPointersLength = header->instructionCount * 4;
+	vm->instructionPointers = (int *)VM_Alloc( vm->instructionPointersLength );
+
+	// copy or compile the instructions
+	vm->codeLength = header->codeLength;
+
+	if ( interpret >= VMI_COMPILED ) {
+		vm->compiled = qtrue;
+		VM_Compile( vm, header );
+	} else {
+		vm->compiled = qfalse;
+		VM_PrepareInterpreter( vm, header );
+	}
+
+	// free the original file
+	FS_FreeFile( header );
+
+	// load the map file
+	VM_LoadSymbols( vm );
+
+	// the stack is implicitly at the end of the image
+	vm->programStack = vm->dataMask + 1;
+	vm->stackBottom = vm->programStack - STACK_SIZE;
+
+	return vm;
+}
+
+
+/*
+==============
+VM_Free
+==============
+*/
+void VM_Free( vm_t *vm ) {
+
+	if ( vm->dllHandle ) {
+		Sys_UnloadDll( vm->dllHandle );
+		Com_Memset( vm, 0, sizeof( *vm ) );
+	}
+#if 0	// now automatically freed by hunk
+	if ( vm->codeBase ) {
+		Z_Free( vm->codeBase );
+	}
+	if ( vm->dataBase ) {
+		Z_Free( vm->dataBase );
+	}
+	if ( vm->instructionPointers ) {
+		Z_Free( vm->instructionPointers );
+	}
+#endif
+	Com_Memset( vm, 0, sizeof( *vm ) );
+
+	currentVM = NULL;
+	lastVM = NULL;
+}
+
+void VM_Clear(void) {
+	int i;
+	for (i=0;i<MAX_VM; i++) {
+		if ( vmTable[i].dllHandle ) {
+			Sys_UnloadDll( vmTable[i].dllHandle );
+		}
+		Com_Memset( &vmTable[i], 0, sizeof( vm_t ) );
+	}
+	currentVM = NULL;
+	lastVM = NULL;
+}
+
+void *VM_ArgPtr( int intValue ) {
+	if ( !intValue ) {
+		return NULL;
+	}
+	// bk001220 - currentVM is missing on reconnect
+	if ( currentVM==NULL )
+	  return NULL;
+
+	if ( currentVM->entryPoint ) {
+		return (void *)(currentVM->dataBase + intValue);
+	}
+	else {
+		return (void *)(currentVM->dataBase + (intValue & currentVM->dataMask));
+	}
+}
+
+extern vm_t *gvm;
+void *BotVMShift( int ptr )
+{
+	if ( !ptr )
+	{
+		return NULL;
+	}
+
+	if (!gvm)
+	{ //always using the game vm here.
+		return NULL;
+	}
+
+	if ( gvm->entryPoint )
+	{
+		return (void *)(gvm->dataBase + ptr);
+	}
+	else
+	{
+		return (void *)(gvm->dataBase + (ptr & gvm->dataMask));
+	}
+}
+
+void VM_Shifted_Alloc(void **ptr, int size)
+{
+	void *mem;
+
+	if (!currentVM)
+	{
+		assert(0);
+		*ptr = NULL;
+		return;
+	}
+
+	//first allocate our desired memory, up front
+	mem = Z_Malloc(size+1, TAG_VM_ALLOCATED, qfalse);
+
+	if (!mem)
+	{
+		assert(0);
+		*ptr = NULL;
+		return;
+	}
+
+	memset(mem, 0, size+1);
+
+	//This can happen.. if a free chunk of memory is found before the vm alloc pointer, commonly happens
+	//when allocating like 4 bytes or whatever. However it seems to actually be handled which I didn't
+	//think it would be.. so hey.
+#if 0
+	if ((int)mem < (int)currentVM->dataBase)
+	{
+		assert(!"Unspeakably bad thing has occured (mem ptr < vm base ptr)");
+		*ptr = NULL;
+		return;
+	}
+#endif
+
+	//Alright, subtract the database from the memory pointer to get a memory address relative to the VM.
+	//When the VM modifies it it should be modifying the same chunk of memory we have allocated in the engine.
+	*ptr = (void *)((int)mem - (int)currentVM->dataBase);
+}
+
+void VM_Shifted_Free(void **ptr)
+{
+	void *mem;
+
+	if (!currentVM)
+	{
+		assert(0);
+		return;
+	}
+
+	//Shift the VM memory pointer back to get the same pointer we initially allocated in real memory space.
+	mem = (void *)((int)currentVM->dataBase + (int)*ptr);
+
+	if (!mem)
+	{
+		assert(0);
+		return;
+	}
+
+	Z_Free(mem);
+	*ptr = NULL; //go ahead and clear the pointer for the game.
+}
+
+void *VM_ExplicitArgPtr( vm_t *vm, int intValue ) {
+	if ( !intValue ) {
+		return NULL;
+	}
+
+	// bk010124 - currentVM is missing on reconnect here as well?
+	if ( currentVM==NULL )
+	  return NULL;
+
+	//
+	if ( vm->entryPoint ) {
+		return (void *)(vm->dataBase + intValue);
+	}
+	else {
+		return (void *)(vm->dataBase + (intValue & vm->dataMask));
+	}
+}
+
+
+/*
+==============
+VM_Call
+
+
+Upon a system call, the stack will look like:
+
+sp+32	parm1
+sp+28	parm0
+sp+24	return value
+sp+20	return address
+sp+16	local1
+sp+14	local0
+sp+12	arg1
+sp+8	arg0
+sp+4	return stack
+sp		return address
+
+An interpreted function will immediately execute
+an OP_ENTER instruction, which will subtract space for
+locals from sp
+==============
+*/
+#define	MAX_STACK	256
+#define	STACK_MASK	(MAX_STACK-1)
+
+int	QDECL VM_Call( vm_t *vm, int callnum, ... ) {
+	vm_t	*oldVM;
+	int		r;
+	int i;
+	int args[16];
+	va_list ap;
+
+
+	if ( !vm ) {
+		Com_Error( ERR_FATAL, "VM_Call with NULL vm" );
+	}
+
+	oldVM = currentVM;
+	currentVM = vm;
+	lastVM = vm;
+
+	if ( vm_debugLevel ) {
+	  Com_Printf( "VM_Call( %i )\n", callnum );
+	}
+
+	// if we have a dll loaded, call it directly
+	if ( vm->entryPoint ) {
+		//rcg010207 -  see dissertation at top of VM_DllSyscall() in this file.
+		va_start(ap, callnum);
+		for (i = 0; i < sizeof (args) / sizeof (args[i]); i++) {
+			args[i] = va_arg(ap, int);
+		}
+		va_end(ap);
+
+		r = vm->entryPoint( callnum,  args[0],  args[1],  args[2], args[3],
+                            args[4],  args[5],  args[6], args[7],
+                            args[8],  args[9], args[10], args[11],
+                            args[12], args[13], args[14], args[15]);
+	} else if ( vm->compiled ) {
+		r = VM_CallCompiled( vm, &callnum );
+	} else {
+		r = VM_CallInterpreted( vm, &callnum );
+	}
+
+	if ( oldVM != NULL ) // bk001220 - assert(currentVM!=NULL) for oldVM==NULL
+	  currentVM = oldVM;
+	return r;
+}
+
+//=================================================================
+
+static int QDECL VM_ProfileSort( const void *a, const void *b ) {
+	vmSymbol_t	*sa, *sb;
+
+	sa = *(vmSymbol_t **)a;
+	sb = *(vmSymbol_t **)b;
+
+	if ( sa->profileCount < sb->profileCount ) {
+		return -1;
+	}
+	if ( sa->profileCount > sb->profileCount ) {
+		return 1;
+	}
+	return 0;
+}
+
+/*
+==============
+VM_VmProfile_f
+
+==============
+*/
+void VM_VmProfile_f( void ) {
+	vm_t		*vm;
+	vmSymbol_t	**sorted, *sym;
+	int			i;
+	double		total;
+
+	if ( !lastVM ) {
+		return;
+	}
+
+	vm = lastVM;
+
+	if ( !vm->numSymbols ) {
+		return;
+	}
+
+	sorted = (struct vmSymbol_s **)Z_Malloc( vm->numSymbols * sizeof( *sorted ), TAG_VM, qtrue );
+	sorted[0] = vm->symbols;
+	total = sorted[0]->profileCount;
+	for ( i = 1 ; i < vm->numSymbols ; i++ ) {
+		sorted[i] = sorted[i-1]->next;
+		total += sorted[i]->profileCount;
+	}
+
+	qsort( sorted, vm->numSymbols, sizeof( *sorted ), VM_ProfileSort );
+
+	for ( i = 0 ; i < vm->numSymbols ; i++ ) {
+		int		perc;
+
+		sym = sorted[i];
+
+		perc = 100 * (float) sym->profileCount / total;
+		Com_Printf( "%2i%% %9i %s\n", perc, sym->profileCount, sym->symName );
+		sym->profileCount = 0;
+	}
+
+	Com_Printf("    %9.0f total\n", total );
+
+	Z_Free( sorted );
+}
+
+/*
+==============
+VM_VmInfo_f
+
+==============
+*/
+void VM_VmInfo_f( void ) {
+	vm_t	*vm;
+	int		i;
+
+	Com_Printf( "Registered virtual machines:\n" );
+	for ( i = 0 ; i < MAX_VM ; i++ ) {
+		vm = &vmTable[i];
+		if ( !vm->name[0] ) {
+			break;
+		}
+		Com_Printf( "%s : ", vm->name );
+		if ( vm->dllHandle ) {
+			Com_Printf( "native\n" );
+			continue;
+		}
+		if ( vm->compiled ) {
+			Com_Printf( "compiled on load\n" );
+		} else {
+			Com_Printf( "interpreted\n" );
+		}
+		Com_Printf( "    code length : %7i\n", vm->codeLength );
+		Com_Printf( "    table length: %7i\n", vm->instructionPointersLength );
+		Com_Printf( "    data length : %7i\n", vm->dataMask + 1 );
+	}
+}
+
+/*
+===============
+VM_LogSyscalls
+
+Insert calls to this while debugging the vm compiler
+===============
+*/
+void VM_LogSyscalls( int *args ) {
+	static	int		callnum;
+	static	FILE	*f;
+
+	if ( !f ) {
+		f = fopen("syscalls.log", "w" );
+	}
+	callnum++;
+	fprintf(f, "%i: %i (%i) = %i %i %i %i\n", callnum, args - (int *)currentVM->dataBase,
+		args[0], args[1], args[2], args[3], args[4] );
+}
+
+
+
+#ifdef oDLL_ONLY // bk010215 - for DLL_ONLY dedicated servers/builds w/o VM
+int	VM_CallCompiled( vm_t *vm, int *args ) {
+  return(0); 
+}
+
+void VM_Compile( vm_t *vm, vmHeader_t *header ) {}
+#endif // DLL_ONLY
diff --git a/codemp/qcommon/vm_console.cpp b/codemp/qcommon/vm_console.cpp
new file mode 100644
index 0000000..4ad0129
--- /dev/null
+++ b/codemp/qcommon/vm_console.cpp
@@ -0,0 +1,229 @@
+#include "../qcommon/exe_headers.h"
+#include "vm_local.h"
+
+vm_t *currentVM	= NULL;
+vm_t *lastVM	= NULL;
+
+
+#define	MAX_VM		3
+vm_t	vmTable[MAX_VM];
+
+
+/*
+============
+VM_DllSyscall
+
+Dlls will call this directly
+
+ rcg010206 The horror; the horror.
+
+  The syscall mechanism relies on stack manipulation to get it's args.
+   This is likely due to C's inability to pass "..." parameters to
+   a function in one clean chunk. On PowerPC Linux, these parameters
+   are not necessarily passed on the stack, so while (&arg[0] == arg)
+   is true, (&arg[1] == 2nd function parameter) is not necessarily
+   accurate, as arg's value might have been stored to the stack or
+   other piece of scratch memory to give it a valid address, but the
+   next parameter might still be sitting in a register.
+
+  Quake's syscall system also assumes that the stack grows downward,
+   and that any needed types can be squeezed, safely, into a signed int.
+
+  This hack below copies all needed values for an argument to a
+   array in memory, so that Quake can get the correct values. This can
+   also be used on systems where the stack grows upwards, as the
+   presumably standard and safe stdargs.h macros are used.
+
+  As for having enough space in a signed int for your datatypes, well,
+   it might be better to wait for DOOM 3 before you start porting.  :)
+
+  The original code, while probably still inherently dangerous, seems
+   to work well enough for the platforms it already works on. Rather
+   than add the performance hit for those platforms, the original code
+   is still in use there.
+
+  For speed, we just grab 15 arguments, and don't worry about exactly
+   how many the syscall actually needs; the extra is thrown away.
+ 
+============
+*/
+int QDECL VM_DllSyscall( int arg, ... )
+{
+	return currentVM->systemCall( &arg );
+}
+
+/*
+================
+VM_Create
+
+If image ends in .qvm it will be interpreted, otherwise
+it will attempt to load as a system dll
+================
+*/
+
+//#define	STACK_SIZE	0x20000
+
+#define UI_VM_INDEX 0
+#define CG_VM_INDEX 1
+#define G_VM_INDEX 2
+
+namespace cgame
+{
+	extern int vmMain( int command, int arg0, int arg1, int arg2, int arg3, int arg4, int arg5, int arg6, int arg7, int arg8, int arg9, int arg10, int arg11  );
+	void dllEntry( int (QDECL *syscallptr)( int arg,... ) );
+};
+
+namespace game
+{
+	extern int vmMain( int command, int arg0, int arg1, int arg2, int arg3, int arg4, int arg5, int arg6, int arg7, int arg8, int arg9, int arg10, int arg11  );
+	void dllEntry( int (QDECL *syscallptr)( int arg,... ) );
+};
+
+namespace ui
+{
+	extern int vmMain( int command, int arg0, int arg1, int arg2, int arg3, int arg4, int arg5, int arg6, int arg7, int arg8, int arg9, int arg10, int arg11  );
+	void dllEntry( int (QDECL *syscallptr)( int arg,... ) );
+};
+
+vm_t *VM_Create( const char *module, int (*systemCalls)(int *), 
+				vmInterpret_t interpret ) {
+	if (!Q_stricmp("ui", module))
+	{
+		// UI VM
+		vmTable[UI_VM_INDEX].entryPoint = (int (*)(int,...)) ui::vmMain;
+		vmTable[UI_VM_INDEX].systemCall = systemCalls;
+		ui::dllEntry(VM_DllSyscall);
+		return &vmTable[UI_VM_INDEX];
+	}
+	else if (!Q_stricmp("cgame", module))
+	{
+		// CG VM
+		vmTable[CG_VM_INDEX].entryPoint = (int (*)(int,...)) cgame::vmMain;
+		vmTable[CG_VM_INDEX].systemCall = systemCalls;
+		cgame::dllEntry(VM_DllSyscall);
+		return &vmTable[CG_VM_INDEX];
+	}
+	else if (!Q_stricmp("jampgame", module))
+	{
+		// G VM
+		vmTable[G_VM_INDEX].entryPoint = (int (*)(int,...)) game::vmMain;
+		vmTable[G_VM_INDEX].systemCall = systemCalls;
+		game::dllEntry(VM_DllSyscall);
+		return &vmTable[G_VM_INDEX];
+	}
+	else
+		return NULL;
+}
+
+
+/*
+==============
+VM_Call
+
+
+Upon a system call, the stack will look like:
+
+sp+32	parm1
+sp+28	parm0
+sp+24	return value
+sp+20	return address
+sp+16	local1
+sp+14	local0
+sp+12	arg1
+sp+8	arg0
+sp+4	return stack
+sp		return address
+
+An interpreted function will immediately execute
+an OP_ENTER instruction, which will subtract space for
+locals from sp
+==============
+*/
+#define	MAX_STACK	256
+#define	STACK_MASK	(MAX_STACK-1)
+
+int	QDECL VM_Call( vm_t *vm, int callnum, ... )
+{
+	// Remember what the current VM was when we started.
+	vm_t *oldVM = currentVM;
+	// Change current VM so that VMA() crap works
+	currentVM = vm;
+
+	// Forward the call to the vm's vmMain function, passing through more data than
+	// we should. I'm going to be sick.
+#if defined(_GAMECUBE)
+	int i;
+	int args[16];
+	va_list ap;
+	va_start(ap, callnum);
+	for (i = 0; i < sizeof (args) / sizeof (args[i]); i++)
+	  args[i] = va_arg(ap, int);
+	va_end(ap);
+
+	int r = vm->entryPoint( callnum,  args[0],  args[1],  args[2], args[3],
+                                    args[4],  args[5],  args[6], args[7],
+                                    args[8],  args[9], args[10], args[11],
+                                    args[12], args[13], args[14], args[15]);
+#else
+	int r = vm->entryPoint( (&callnum)[0], (&callnum)[1], (&callnum)[2], (&callnum)[3],
+			(&callnum)[4], (&callnum)[5], (&callnum)[6], (&callnum)[7],
+			(&callnum)[8],  (&callnum)[9],  (&callnum)[10],  (&callnum)[11],  (&callnum)[12] );
+#endif
+
+
+	// Restore VM pointer XXX: Why does the below code check for non-NULL?
+	currentVM = oldVM;
+	return r;
+}
+
+// This function seems really suspect. Let's cross our fingers...
+void *BotVMShift( int ptr )
+{
+	return (void *)ptr;
+}
+
+// Functions to support dynamic memory allocation by VMs.
+// I don't really trust these. Oh well.
+void VM_Shifted_Alloc(void **ptr, int size)
+{
+	if (!currentVM)
+	{
+		assert(0);
+		*ptr = NULL;
+		return;
+	}
+
+	//first allocate our desired memory, up front
+	*ptr = Z_Malloc(size, TAG_VM_ALLOCATED, qtrue);
+}
+
+void VM_Shifted_Free(void **ptr)
+{
+	if (!currentVM)
+	{
+		assert(0);
+		return;
+	}
+
+	Z_Free(*ptr);
+	*ptr = NULL; //go ahead and clear the pointer for the game.
+}
+
+// Stupid casting function. We can't do this in the macros, because sv_game calls this
+// directly now.
+void *VM_ArgPtr( int intValue )
+{
+	return (void *)intValue;
+}
+
+void VM_Free(vm_t *) {}
+
+void VM_Debug(int) {}
+
+void VM_Clear(void) {}
+
+void VM_Init(void) {}
+
+void *VM_ExplicitArgPtr(vm_t *, int) { return NULL; }
+
+vm_t *VM_Restart(vm_t *vm) { return vm; }
diff --git a/codemp/qcommon/vm_interpreted.cpp b/codemp/qcommon/vm_interpreted.cpp
new file mode 100644
index 0000000..cfefb16
--- /dev/null
+++ b/codemp/qcommon/vm_interpreted.cpp
@@ -0,0 +1,905 @@
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+#include "vm_local.h"
+
+#define	DEBUG_VM
+
+#ifdef DEBUG_VM // bk001204
+static char	*opnames[256] = {
+	"OP_UNDEF", 
+
+	"OP_IGNORE", 
+
+	"OP_BREAK",
+
+	"OP_ENTER",
+	"OP_LEAVE",
+	"OP_CALL",
+	"OP_PUSH",
+	"OP_POP",
+
+	"OP_CONST",
+
+	"OP_LOCAL",
+
+	"OP_JUMP",
+
+	//-------------------
+
+	"OP_EQ",
+	"OP_NE",
+
+	"OP_LTI",
+	"OP_LEI",
+	"OP_GTI",
+	"OP_GEI",
+
+	"OP_LTU",
+	"OP_LEU",
+	"OP_GTU",
+	"OP_GEU",
+
+	"OP_EQF",
+	"OP_NEF",
+
+	"OP_LTF",
+	"OP_LEF",
+	"OP_GTF",
+	"OP_GEF",
+
+	//-------------------
+
+	"OP_LOAD1",
+	"OP_LOAD2",
+	"OP_LOAD4",
+	"OP_STORE1",
+	"OP_STORE2",
+	"OP_STORE4",
+	"OP_ARG",
+
+	"OP_BLOCK_COPY",
+
+	//-------------------
+
+	"OP_SEX8",
+	"OP_SEX16",
+
+	"OP_NEGI",
+	"OP_ADD",
+	"OP_SUB",
+	"OP_DIVI",
+	"OP_DIVU",
+	"OP_MODI",
+	"OP_MODU",
+	"OP_MULI",
+	"OP_MULU",
+
+	"OP_BAND",
+	"OP_BOR",
+	"OP_BXOR",
+	"OP_BCOM",
+
+	"OP_LSH",
+	"OP_RSHI",
+	"OP_RSHU",
+
+	"OP_NEGF",
+	"OP_ADDF",
+	"OP_SUBF",
+	"OP_DIVF",
+	"OP_MULF",
+
+	"OP_CVIF",
+	"OP_CVFI"
+};
+#endif
+
+#if idppc
+    #if defined(__GNUC__)
+        static inline unsigned int loadWord(void *addr) {
+            unsigned int word;
+            
+            asm("lwbrx %0,0,%1" : "=r" (word) : "r" (addr));
+            return word;
+        }
+    #else
+	#define loadWord(addr) __lwbrx(addr,0)
+    #endif
+#else
+	#define	loadWord(addr) *((int *)addr)
+#endif
+
+char *VM_Indent( vm_t *vm ) {
+	static char	*string = "                                        ";
+	if ( vm->callLevel > 20 ) {
+		return string;
+	}
+	return string + 2 * ( 20 - vm->callLevel );
+}
+
+void VM_StackTrace( vm_t *vm, int programCounter, int programStack ) {
+	int		count;
+
+	count = 0;
+	do {
+		Com_Printf( "%s\n", VM_ValueToSymbol( vm, programCounter ) );
+		programStack =  *(int *)&vm->dataBase[programStack+4];
+		programCounter = *(int *)&vm->dataBase[programStack];
+	} while ( programCounter != -1 && ++count < 32 );
+
+}
+
+
+/*
+====================
+VM_PrepareInterpreter
+====================
+*/
+void VM_PrepareInterpreter( vm_t *vm, vmHeader_t *header ) {
+	int		op;
+	int		pc;
+	byte	*code;
+	int		instruction;
+	int		*codeBase;
+
+	vm->codeBase = (unsigned char *)Hunk_Alloc( vm->codeLength*4, h_high );			// we're now int aligned
+//	memcpy( vm->codeBase, (byte *)header + header->codeOffset, vm->codeLength );
+
+	// we don't need to translate the instructions, but we still need
+	// to find each instructions starting point for jumps
+	pc = 0;
+	instruction = 0;
+	code = (byte *)header + header->codeOffset;
+	codeBase = (int *)vm->codeBase;
+
+	while ( instruction < header->instructionCount ) {
+		vm->instructionPointers[ instruction ] = pc;
+		instruction++;
+
+		op = code[ pc ];
+		codeBase[pc] = op;
+		if ( pc > header->codeLength ) {
+			Com_Error( ERR_FATAL, "VM_PrepareInterpreter: pc > header->codeLength" );
+		}
+
+		pc++;
+
+		// these are the only opcodes that aren't a single byte
+		switch ( op ) {
+		case OP_ENTER:
+		case OP_CONST:
+		case OP_LOCAL:
+		case OP_LEAVE:
+		case OP_EQ:
+		case OP_NE:
+		case OP_LTI:
+		case OP_LEI:
+		case OP_GTI:
+		case OP_GEI:
+		case OP_LTU:
+		case OP_LEU:
+		case OP_GTU:
+		case OP_GEU:
+		case OP_EQF:
+		case OP_NEF:
+		case OP_LTF:
+		case OP_LEF:
+		case OP_GTF:
+		case OP_GEF:
+		case OP_BLOCK_COPY:
+			codeBase[pc+0] = loadWord(&code[pc]);
+			pc += 4;
+			break;
+		case OP_ARG:
+			codeBase[pc+0] = code[pc];
+			pc += 1;
+			break;
+		default:
+			break;
+		}
+
+	}
+	pc = 0;
+	instruction = 0;
+	code = (byte *)header + header->codeOffset;
+	codeBase = (int *)vm->codeBase;
+
+	while ( instruction < header->instructionCount ) {
+		op = code[ pc ];
+		instruction++;
+		pc++;
+		switch ( op ) {
+		case OP_ENTER:
+		case OP_CONST:
+		case OP_LOCAL:
+		case OP_LEAVE:
+		case OP_EQ:
+		case OP_NE:
+		case OP_LTI:
+		case OP_LEI:
+		case OP_GTI:
+		case OP_GEI:
+		case OP_LTU:
+		case OP_LEU:
+		case OP_GTU:
+		case OP_GEU:
+		case OP_EQF:
+		case OP_NEF:
+		case OP_LTF:
+		case OP_LEF:
+		case OP_GTF:
+		case OP_GEF:
+		case OP_BLOCK_COPY:
+			switch(op) {
+				case OP_EQ:
+				case OP_NE:
+				case OP_LTI:
+				case OP_LEI:
+				case OP_GTI:
+				case OP_GEI:
+				case OP_LTU:
+				case OP_LEU:
+				case OP_GTU:
+				case OP_GEU:
+				case OP_EQF:
+				case OP_NEF:
+				case OP_LTF:
+				case OP_LEF:
+				case OP_GTF:
+				case OP_GEF:
+				codeBase[pc] = vm->instructionPointers[codeBase[pc]];
+				break;
+			default:
+				break;
+			}
+			pc += 4;
+			break;
+		case OP_ARG:
+			pc += 1;
+			break;
+		default:
+			break;
+		}
+
+	}
+}
+
+/*
+==============
+VM_Call
+
+
+Upon a system call, the stack will look like:
+
+sp+32	parm1
+sp+28	parm0
+sp+24	return stack
+sp+20	return address
+sp+16	local1
+sp+14	local0
+sp+12	arg1
+sp+8	arg0
+sp+4	return stack
+sp		return address
+
+An interpreted function will immediately execute
+an OP_ENTER instruction, which will subtract space for
+locals from sp
+==============
+*/
+#define	MAX_STACK	256
+#define	STACK_MASK	(MAX_STACK-1)
+
+#define	DEBUGSTR va("%s%i", VM_Indent(vm), opStack-stack )
+
+int	VM_CallInterpreted( vm_t *vm, int *args ) {
+	int		stack[MAX_STACK];
+	int		*opStack;
+	int		programCounter;
+	int		programStack;
+	int		stackOnEntry;
+	byte	*image;
+	int		*codeImage;
+	int		v1;
+	int		dataMask;
+#ifdef DEBUG_VM
+	vmSymbol_t	*profileSymbol = NULL;
+#endif
+
+	// interpret the code
+	vm->currentlyInterpreting = qtrue;
+#ifdef CRAZY_SYMBOL_MAP
+	VM_SetSymbolMap(vm);
+#endif
+
+	// we might be called recursively, so this might not be the very top
+	programStack = stackOnEntry = vm->programStack;
+
+#ifdef DEBUG_VM
+	if (com_vmdebug->integer)
+	{
+		profileSymbol = VM_ValueToFunctionSymbol( vm, 0 );
+	}
+	// uncomment this for debugging breakpoints
+	vm->breakFunction = 0;
+#endif
+	// set up the stack frame 
+
+	image = vm->dataBase;
+	codeImage = (int *)vm->codeBase;
+	dataMask = vm->dataMask;
+	
+	// leave a free spot at start of stack so
+	// that as long as opStack is valid, opStack-1 will
+	// not corrupt anything
+	opStack = stack;
+	programCounter = 0;
+
+	programStack -= 48;
+
+	*(int *)&image[ programStack + 44] = args[9];
+	*(int *)&image[ programStack + 40] = args[8];
+	*(int *)&image[ programStack + 36] = args[7];
+	*(int *)&image[ programStack + 32] = args[6];
+	*(int *)&image[ programStack + 28] = args[5];
+	*(int *)&image[ programStack + 24] = args[4];
+	*(int *)&image[ programStack + 20] = args[3];
+	*(int *)&image[ programStack + 16] = args[2];
+	*(int *)&image[ programStack + 12] = args[1];
+	*(int *)&image[ programStack + 8 ] = args[0];
+	*(int *)&image[ programStack + 4 ] = 0;	// return stack
+	*(int *)&image[ programStack ] = -1;	// will terminate the loop on return
+
+	vm->callLevel = 0;
+	
+	VM_Debug(0);
+
+//	vm_debugLevel=2;
+	// main interpreter loop, will exit when a LEAVE instruction
+	// grabs the -1 program counter
+
+#define r2 codeImage[programCounter]
+
+	while ( 1 ) {
+		int		opcode,	r0, r1;
+//		unsigned int	r2;
+
+nextInstruction:
+		r0 = ((int *)opStack)[0];
+		r1 = ((int *)opStack)[-1];
+nextInstruction2:
+		opcode = codeImage[ programCounter++ ];
+#ifdef DEBUG_VM
+		if (com_vmdebug->integer > 1)
+		{
+			if ( (unsigned)programCounter > vm->codeLength ) {
+				Com_Error( ERR_DROP, "VM pc out of range" );
+			}
+
+			if ( opStack < stack ) {
+				Com_Error( ERR_DROP, "VM opStack underflow" );
+			}
+			if ( opStack >= stack+MAX_STACK ) {
+				Com_Error( ERR_DROP, "VM opStack overflow" );
+			}
+
+			if ( programStack <= vm->stackBottom ) {
+				Com_Error( ERR_DROP, "VM stack overflow" );
+			}
+
+			if ( programStack & 3 ) {
+				Com_Error( ERR_DROP, "VM program stack misaligned" );
+			}
+
+			if ( vm_debugLevel > 1 ) {
+				Com_Printf( "%s %s\n", DEBUGSTR, opnames[opcode] );
+			}
+			profileSymbol->profileCount++;
+		}
+#endif
+
+		switch ( opcode ) {
+#ifdef DEBUG_VM
+		default:
+			Com_Error( ERR_DROP, "Bad VM instruction" );  // this should be scanned on load!
+#endif
+		case OP_BREAK:
+			vm->breakCount++;
+			goto nextInstruction2;
+		case OP_CONST:
+			opStack++;
+			r1 = r0;
+			r0 = *opStack = r2;
+			
+			programCounter += 4;
+			goto nextInstruction2;
+		case OP_LOCAL:
+			opStack++;
+			r1 = r0;
+			r0 = *opStack = r2+programStack;
+
+			programCounter += 4;
+			goto nextInstruction2;
+
+		case OP_LOAD4:
+#ifdef DEBUG_VM
+			if (com_vmdebug->integer > 1)
+			{
+				if ( *opStack & 3 ) {
+					Com_Error( ERR_DROP, "OP_LOAD4 misaligned" );
+				}
+			}
+#endif
+			r0 = *opStack = *(int *)&image[ r0&dataMask ];
+			goto nextInstruction2;
+		case OP_LOAD2:
+			r0 = *opStack = *(unsigned short *)&image[ r0&dataMask ];
+			goto nextInstruction2;
+		case OP_LOAD1:
+			r0 = *opStack = image[ r0&dataMask ];
+			goto nextInstruction2;
+
+		case OP_STORE4:
+			*(int *)&image[ r1&(dataMask & ~3) ] = r0;
+			opStack -= 2;
+			goto nextInstruction;
+		case OP_STORE2:
+			*(short *)&image[ r1&(dataMask & ~1) ] = r0;
+			opStack -= 2;
+			goto nextInstruction;
+		case OP_STORE1:
+			image[ r1&dataMask ] = r0;
+			opStack -= 2;
+			goto nextInstruction;
+
+		case OP_ARG:
+			// single byte offset from programStack
+			*(int *)&image[ codeImage[programCounter] + programStack ] = r0;
+			opStack--;
+			programCounter += 1;
+			goto nextInstruction;
+
+		case OP_BLOCK_COPY:
+			{
+				int		*src, *dest;
+				int		i, count, srci, desti;
+
+				count = r2;
+				// MrE: copy range check
+				srci = r0 & dataMask;
+				desti = r1 & dataMask;
+				count = ((srci + count) & dataMask) - srci;
+				count = ((desti + count) & dataMask) - desti;
+
+				src = (int *)&image[ r0&dataMask ];
+				dest = (int *)&image[ r1&dataMask ];
+				if ( ( (int)src | (int)dest | count ) & 3 ) {
+					Com_Error( ERR_DROP, "OP_BLOCK_COPY not dword aligned" );
+				}
+				count >>= 2;
+				for ( i = count-1 ; i>= 0 ; i-- ) {
+					dest[i] = src[i];
+				}
+				programCounter += 4;
+				opStack -= 2;
+			}
+			goto nextInstruction;
+
+		case OP_CALL:
+			// save current program counter
+			*(int *)&image[ programStack ] = programCounter;
+			
+			// jump to the location on the stack
+			programCounter = r0;
+			opStack--;
+			if ( programCounter < 0 ) {
+				// system call
+				int		r;
+				int		temp;
+#ifdef DEBUG_VM
+				int		stomped = 0;
+
+				if (com_vmdebug->integer > 1)
+				{
+					if ( vm_debugLevel ) {
+						Com_Printf( "%s---> systemcall(%i)\n", DEBUGSTR, -1 - programCounter );
+					}
+				}
+#endif
+				// save the stack to allow recursive VM entry
+				temp = vm->callLevel;
+				vm->programStack = programStack - 4;
+#ifdef DEBUG_VM
+				if (com_vmdebug->integer > 1)
+				{
+					stomped = *(int *)&image[ programStack + 4 ];
+				}
+#endif
+				*(int *)&image[ programStack + 4 ] = -1 - programCounter;
+
+//VM_LogSyscalls( (int *)&image[ programStack + 4 ] );
+				r = vm->systemCall( (int *)&image[ programStack + 4 ] );
+
+#ifdef DEBUG_VM
+				if (com_vmdebug->integer > 1)
+				{
+					// this is just our stack frame pointer, only needed
+					// for debugging
+					*(int *)&image[ programStack + 4 ] = stomped;
+				}
+#endif
+
+				// save return value
+				opStack++;
+				*opStack = r;
+				programCounter = *(int *)&image[ programStack ];
+				vm->callLevel = temp;
+#ifdef DEBUG_VM
+				if (com_vmdebug->integer > 1)
+				{
+					if ( vm_debugLevel ) {
+						Com_Printf( "%s<--- %s\n", DEBUGSTR, VM_ValueToSymbol( vm, programCounter ) );
+					}
+				}
+#endif
+			} else {
+				programCounter = vm->instructionPointers[ programCounter ];
+			}
+			goto nextInstruction;
+
+		// push and pop are only needed for discarded or bad function return values
+		case OP_PUSH:
+			opStack++;
+			goto nextInstruction;
+		case OP_POP:
+			opStack--;
+			goto nextInstruction;
+
+		case OP_ENTER:
+#ifdef DEBUG_VM
+			if (com_vmdebug->integer)
+			{
+				profileSymbol = VM_ValueToFunctionSymbol( vm, programCounter );
+			}
+#endif
+			// get size of stack frame
+			v1 = r2;
+
+			programCounter += 4;
+			programStack -= v1;
+#ifdef DEBUG_VM
+			if (com_vmdebug->integer > 1)
+			{
+				// save old stack frame for debugging traces
+				*(int *)&image[programStack+4] = programStack + v1;
+				if ( vm_debugLevel ) {
+					Com_Printf( "%s---> %s\n", DEBUGSTR, VM_ValueToSymbol( vm, programCounter - 5 ) );
+					if ( vm->breakFunction && programCounter - 5 == vm->breakFunction ) {
+						// this is to allow setting breakpoints here in the debugger
+						vm->breakCount++;
+	//					vm_debugLevel = 2;
+	//					VM_StackTrace( vm, programCounter, programStack );
+					}
+					vm->callLevel++;
+				}
+			}
+#endif
+			goto nextInstruction;
+		case OP_LEAVE:
+			// remove our stack frame
+			v1 = r2;
+
+			programStack += v1;
+
+			// grab the saved program counter
+			programCounter = *(int *)&image[ programStack ];
+#ifdef DEBUG_VM
+			if (com_vmdebug->integer)
+			{
+				profileSymbol = VM_ValueToFunctionSymbol( vm, programCounter );
+				if ( vm_debugLevel ) {
+					vm->callLevel--;
+					Com_Printf( "%s<--- %s\n", DEBUGSTR, VM_ValueToSymbol( vm, programCounter ) );
+				}
+			}
+#endif
+			// check for leaving the VM
+			if ( programCounter == -1 ) {
+				goto done;
+			}
+			goto nextInstruction;
+
+		/*
+		===================================================================
+		BRANCHES
+		===================================================================
+		*/
+
+		case OP_JUMP:
+			programCounter = r0;
+			programCounter = vm->instructionPointers[ programCounter ];
+			opStack--;
+			goto nextInstruction;
+
+		case OP_EQ:
+			opStack -= 2;
+			if ( r1 == r0 ) {
+				programCounter = r2;	//vm->instructionPointers[r2];
+				goto nextInstruction;
+			} else {
+				programCounter += 4;
+				goto nextInstruction;
+			}
+
+		case OP_NE:
+			opStack -= 2;
+			if ( r1 != r0 ) {
+				programCounter = r2;	//vm->instructionPointers[r2];
+				goto nextInstruction;
+			} else {
+				programCounter += 4;
+				goto nextInstruction;
+			}
+
+		case OP_LTI:
+			opStack -= 2;
+			if ( r1 < r0 ) {
+				programCounter = r2;	//vm->instructionPointers[r2];
+				goto nextInstruction;
+			} else {
+				programCounter += 4;
+				goto nextInstruction;
+			}
+
+		case OP_LEI:
+			opStack -= 2;
+			if ( r1 <= r0 ) {
+				programCounter = r2;	//vm->instructionPointers[r2];
+				goto nextInstruction;
+			} else {
+				programCounter += 4;
+				goto nextInstruction;
+			}
+
+		case OP_GTI:
+			opStack -= 2;
+			if ( r1 > r0 ) {
+				programCounter = r2;	//vm->instructionPointers[r2];
+				goto nextInstruction;
+			} else {
+				programCounter += 4;
+				goto nextInstruction;
+			}
+
+		case OP_GEI:
+			opStack -= 2;
+			if ( r1 >= r0 ) {
+				programCounter = r2;	//vm->instructionPointers[r2];
+				goto nextInstruction;
+			} else {
+				programCounter += 4;
+				goto nextInstruction;
+			}
+
+		case OP_LTU:
+			opStack -= 2;
+			if ( ((unsigned)r1) < ((unsigned)r0) ) {
+				programCounter = r2;	//vm->instructionPointers[r2];
+				goto nextInstruction;
+			} else {
+				programCounter += 4;
+				goto nextInstruction;
+			}
+
+		case OP_LEU:
+			opStack -= 2;
+			if ( ((unsigned)r1) <= ((unsigned)r0) ) {
+				programCounter = r2;	//vm->instructionPointers[r2];
+				goto nextInstruction;
+			} else {
+				programCounter += 4;
+				goto nextInstruction;
+			}
+
+		case OP_GTU:
+			opStack -= 2;
+			if ( ((unsigned)r1) > ((unsigned)r0) ) {
+				programCounter = r2;	//vm->instructionPointers[r2];
+				goto nextInstruction;
+			} else {
+				programCounter += 4;
+				goto nextInstruction;
+			}
+
+		case OP_GEU:
+			opStack -= 2;
+			if ( ((unsigned)r1) >= ((unsigned)r0) ) {
+				programCounter = r2;	//vm->instructionPointers[r2];
+				goto nextInstruction;
+			} else {
+				programCounter += 4;
+				goto nextInstruction;
+			}
+
+		case OP_EQF:
+			if ( ((float *)opStack)[-1] == *(float *)opStack ) {
+				programCounter = r2;	//vm->instructionPointers[r2];
+				opStack -= 2;
+				goto nextInstruction;
+			} else {
+				programCounter += 4;
+				opStack -= 2;
+				goto nextInstruction;
+			}
+
+		case OP_NEF:
+			if ( ((float *)opStack)[-1] != *(float *)opStack ) {
+				programCounter = r2;	//vm->instructionPointers[r2];
+				opStack -= 2;
+				goto nextInstruction;
+			} else {
+				programCounter += 4;
+				opStack -= 2;
+				goto nextInstruction;
+			}
+
+		case OP_LTF:
+			if ( ((float *)opStack)[-1] < *(float *)opStack ) {
+				programCounter = r2;	//vm->instructionPointers[r2];
+				opStack -= 2;
+				goto nextInstruction;
+			} else {
+				programCounter += 4;
+				opStack -= 2;
+				goto nextInstruction;
+			}
+
+		case OP_LEF:
+			if ( ((float *)opStack)[-1] <= *(float *)opStack ) {
+				programCounter = r2;	//vm->instructionPointers[r2];
+				opStack -= 2;
+				goto nextInstruction;
+			} else {
+				programCounter += 4;
+				opStack -= 2;
+				goto nextInstruction;
+			}
+
+		case OP_GTF:
+			if ( ((float *)opStack)[-1] > *(float *)opStack ) {
+				programCounter = r2;	//vm->instructionPointers[r2];
+				opStack -= 2;
+				goto nextInstruction;
+			} else {
+				programCounter += 4;
+				opStack -= 2;
+				goto nextInstruction;
+			}
+
+		case OP_GEF:
+			if ( ((float *)opStack)[-1] >= *(float *)opStack ) {
+				programCounter = r2;	//vm->instructionPointers[r2];
+				opStack -= 2;
+				goto nextInstruction;
+			} else {
+				programCounter += 4;
+				opStack -= 2;
+				goto nextInstruction;
+			}
+
+
+		//===================================================================
+
+		case OP_NEGI:
+			*opStack = -r0;
+			goto nextInstruction;
+		case OP_ADD:
+			opStack[-1] = r1 + r0;
+			opStack--;
+			goto nextInstruction;
+		case OP_SUB:
+			opStack[-1] = r1 - r0;
+			opStack--;
+			goto nextInstruction;
+		case OP_DIVI:
+			opStack[-1] = r1 / r0;
+			opStack--;
+			goto nextInstruction;
+		case OP_DIVU:
+			opStack[-1] = ((unsigned)r1) / ((unsigned)r0);
+			opStack--;
+			goto nextInstruction;
+		case OP_MODI:
+			opStack[-1] = r1 % r0;
+			opStack--;
+			goto nextInstruction;
+		case OP_MODU:
+			opStack[-1] = ((unsigned)r1) % (unsigned)r0;
+			opStack--;
+			goto nextInstruction;
+		case OP_MULI:
+			opStack[-1] = r1 * r0;
+			opStack--;
+			goto nextInstruction;
+		case OP_MULU:
+			opStack[-1] = ((unsigned)r1) * ((unsigned)r0);
+			opStack--;
+			goto nextInstruction;
+
+		case OP_BAND:
+			opStack[-1] = ((unsigned)r1) & ((unsigned)r0);
+			opStack--;
+			goto nextInstruction;
+		case OP_BOR:
+			opStack[-1] = ((unsigned)r1) | ((unsigned)r0);
+			opStack--;
+			goto nextInstruction;
+		case OP_BXOR:
+			opStack[-1] = ((unsigned)r1) ^ ((unsigned)r0);
+			opStack--;
+			goto nextInstruction;
+		case OP_BCOM:
+			opStack[-1] = ~ ((unsigned)r0);
+			goto nextInstruction;
+
+		case OP_LSH:
+			opStack[-1] = r1 << r0;
+			opStack--;
+			goto nextInstruction;
+		case OP_RSHI:
+			opStack[-1] = r1 >> r0;
+			opStack--;
+			goto nextInstruction;
+		case OP_RSHU:
+			opStack[-1] = ((unsigned)r1) >> r0;
+			opStack--;
+			goto nextInstruction;
+
+		case OP_NEGF:
+			*(float *)opStack =  -*(float *)opStack;
+			goto nextInstruction;
+		case OP_ADDF:
+			*(float *)(opStack-1) = *(float *)(opStack-1) + *(float *)opStack;
+			opStack--;
+			goto nextInstruction;
+		case OP_SUBF:
+			*(float *)(opStack-1) = *(float *)(opStack-1) - *(float *)opStack;
+			opStack--;
+			goto nextInstruction;
+		case OP_DIVF:
+			*(float *)(opStack-1) = *(float *)(opStack-1) / *(float *)opStack;
+			opStack--;
+			goto nextInstruction;
+		case OP_MULF:
+			*(float *)(opStack-1) = *(float *)(opStack-1) * *(float *)opStack;
+			opStack--;
+			goto nextInstruction;
+
+		case OP_CVIF:
+			*(float *)opStack =  (float)*opStack;
+			goto nextInstruction;
+		case OP_CVFI:
+			*opStack = (int) *(float *)opStack;
+			goto nextInstruction;
+		case OP_SEX8:
+			*opStack = (signed char)*opStack;
+			goto nextInstruction;
+		case OP_SEX16:
+			*opStack = (short)*opStack;
+			goto nextInstruction;
+		}
+	}
+
+done:
+	vm->currentlyInterpreting = qfalse;
+
+	if ( opStack != &stack[1] ) {
+		Com_Error( ERR_DROP, "Interpreter error: opStack = %i", opStack - stack );
+	}
+
+	vm->programStack = stackOnEntry;
+
+	// return the result
+	return *opStack;
+}
diff --git a/codemp/qcommon/vm_local.h b/codemp/qcommon/vm_local.h
new file mode 100644
index 0000000..dc1e545
--- /dev/null
+++ b/codemp/qcommon/vm_local.h
@@ -0,0 +1,182 @@
+//rww - so that I may utilize vm debugging features WITHOUT DROPPING TO 0.1FPS
+#ifndef _XBOX
+#define CRAZY_SYMBOL_MAP
+#endif
+
+#ifdef CRAZY_SYMBOL_MAP
+#include <map>
+#endif
+
+typedef enum {
+	OP_UNDEF, 
+
+	OP_IGNORE, 
+
+	OP_BREAK,
+
+	OP_ENTER,
+	OP_LEAVE,
+	OP_CALL,
+	OP_PUSH,
+	OP_POP,
+
+	OP_CONST,
+	OP_LOCAL,
+
+	OP_JUMP,
+
+	//-------------------
+
+	OP_EQ,
+	OP_NE,
+
+	OP_LTI,
+	OP_LEI,
+	OP_GTI,
+	OP_GEI,
+
+	OP_LTU,
+	OP_LEU,
+	OP_GTU,
+	OP_GEU,
+
+	OP_EQF,
+	OP_NEF,
+
+	OP_LTF,
+	OP_LEF,
+	OP_GTF,
+	OP_GEF,
+
+	//-------------------
+
+	OP_LOAD1,
+	OP_LOAD2,
+	OP_LOAD4,
+	OP_STORE1,
+	OP_STORE2,
+	OP_STORE4,				// *(stack[top-1]) = stack[top]
+	OP_ARG,
+
+	OP_BLOCK_COPY,
+
+	//-------------------
+
+	OP_SEX8,
+	OP_SEX16,
+
+	OP_NEGI,
+	OP_ADD,
+	OP_SUB,
+	OP_DIVI,
+	OP_DIVU,
+	OP_MODI,
+	OP_MODU,
+	OP_MULI,
+	OP_MULU,
+
+	OP_BAND,
+	OP_BOR,
+	OP_BXOR,
+	OP_BCOM,
+
+	OP_LSH,
+	OP_RSHI,
+	OP_RSHU,
+
+	OP_NEGF,
+	OP_ADDF,
+	OP_SUBF,
+	OP_DIVF,
+	OP_MULF,
+
+	OP_CVIF,
+	OP_CVFI
+} opcode_t;
+
+
+
+typedef int	vmptr_t;
+
+typedef struct vmSymbol_s {
+	struct vmSymbol_s	*next;
+	int		symValue;
+	int		profileCount;
+	char	symName[1];		// variable sized
+} vmSymbol_t;
+
+#define	VM_OFFSET_PROGRAM_STACK		0
+#define	VM_OFFSET_SYSTEM_CALL		4
+
+struct vm_s {
+    // DO NOT MOVE OR CHANGE THESE WITHOUT CHANGING THE VM_OFFSET_* DEFINES
+    // USED BY THE ASM CODE
+    int			programStack;		// the vm may be recursively entered
+    int			(*systemCall)( int *parms );
+
+	//------------------------------------
+   
+    char		name[MAX_QPATH];
+
+	// for dynamic linked modules
+	void		*dllHandle;
+	int			(QDECL *entryPoint)( int callNum, ... );
+
+	// for interpreted modules
+	qboolean	currentlyInterpreting;
+
+	qboolean	compiled;
+	byte		*codeBase;
+	int			codeLength;
+
+	int			*instructionPointers;
+	int			instructionPointersLength;
+
+	byte		*dataBase;
+	int			dataMask;
+
+	int			stackBottom;		// if programStack < stackBottom, error
+
+	int			numSymbols;
+	struct vmSymbol_s	*symbols;
+
+	int			callLevel;			// for debug indenting
+	int			breakFunction;		// increment breakCount on function entry to this
+	int			breakCount;
+};
+
+#ifdef CRAZY_SYMBOL_MAP
+typedef std::map<int, vmSymbol_s*> symbolMap_t;
+typedef std::map<vm_t*, symbolMap_t> symbolVMMap_t;
+
+extern symbolVMMap_t		g_vmMap;
+extern symbolMap_t			*g_symbolMap;
+
+/*
+Set the symbol map based on the VM currently
+being in interpreted. This is done so that we
+do not have to do a map lookup for the VM with
+each symbol request.
+-rww
+*/
+inline void VM_SetSymbolMap(vm_t *vm)
+{
+	g_symbolMap = &g_vmMap[vm];
+}
+#endif
+
+
+extern	vm_t	*currentVM;
+extern	int		vm_debugLevel;
+
+void VM_Compile( vm_t *vm, vmHeader_t *header );
+int	VM_CallCompiled( vm_t *vm, int *args );
+
+void VM_PrepareInterpreter( vm_t *vm, vmHeader_t *header );
+int	VM_CallInterpreted( vm_t *vm, int *args );
+
+vmSymbol_t *VM_ValueToFunctionSymbol( vm_t *vm, int value );
+int VM_SymbolToValue( vm_t *vm, const char *symbol );
+const char *VM_ValueToSymbol( vm_t *vm, int value );
+void VM_LogSyscalls( int *args );
+
diff --git a/codemp/qcommon/vm_ppc.cpp b/codemp/qcommon/vm_ppc.cpp
new file mode 100644
index 0000000..7fff987
--- /dev/null
+++ b/codemp/qcommon/vm_ppc.cpp
@@ -0,0 +1,1274 @@
+// vm_ppc.c
+// ppc dynamic compiler
+
+#include "vm_local.h"
+
+#pragma opt_pointer_analysis off
+
+
+typedef enum {
+    R_REAL_STACK = 1,
+	// registers 3-11 are the parameter passing registers
+	
+	// state
+	R_STACK = 3,			// local
+	R_OPSTACK,				// global
+
+	// constants	
+	R_MEMBASE,			// global
+	R_MEMMASK,
+	R_ASMCALL,			// global
+    R_INSTRUCTIONS,		// global
+    R_NUM_INSTRUCTIONS,	// global
+    R_CVM,				// currentVM
+    
+	// temps
+	R_TOP = 12,
+	R_SECOND = 13,
+	R_EA = 14				// effective address calculation
+	 
+} regNums_t;
+
+#define	RG_REAL_STACK		r1
+#define	RG_STACK			r3
+#define	RG_OPSTACK			r4
+#define	RG_MEMBASE			r5
+#define	RG_MEMMASK			r6
+#define	RG_ASMCALL			r7
+#define	RG_INSTRUCTIONS		r8
+#define	RG_NUM_INSTRUCTIONS	r9
+#define	RG_CVM				r10
+#define	RG_TOP				r12
+#define	RG_SECOND			r13
+#define	RG_EA 				r14
+
+// this doesn't have the low order bits set for instructions i'm not using...
+typedef enum {
+	PPC_TDI		= 0x08000000,
+	PPC_TWI		= 0x0c000000,
+	PPC_MULLI	= 0x1c000000,
+	PPC_SUBFIC	= 0x20000000,
+	PPC_CMPI	= 0x28000000,
+	PPC_CMPLI	= 0x2c000000,
+	PPC_ADDIC	= 0x30000000,
+	PPC_ADDIC_	= 0x34000000,
+	PPC_ADDI	= 0x38000000,
+	PPC_ADDIS	= 0x3c000000,
+	PPC_BC		= 0x40000000,
+	PPC_SC		= 0x44000000,
+	PPC_B		= 0x48000000,
+
+	PPC_MCRF	= 0x4c000000,
+	PPC_BCLR	= 0x4c000020,
+	PPC_RFID	= 0x4c000000,
+	PPC_CRNOR	= 0x4c000000,
+	PPC_RFI		= 0x4c000000,
+	PPC_CRANDC	= 0x4c000000,
+	PPC_ISYNC	= 0x4c000000,
+	PPC_CRXOR	= 0x4c000000,
+	PPC_CRNAND	= 0x4c000000,
+	PPC_CREQV	= 0x4c000000,
+	PPC_CRORC	= 0x4c000000,
+	PPC_CROR	= 0x4c000000,
+//------------
+	PPC_BCCTR	= 0x4c000420,
+	PPC_RLWIMI	= 0x50000000,
+	PPC_RLWINM	= 0x54000000,
+	PPC_RLWNM	= 0x5c000000,
+	PPC_ORI		= 0x60000000,
+	PPC_ORIS	= 0x64000000,
+	PPC_XORI	= 0x68000000,
+	PPC_XORIS	= 0x6c000000,
+	PPC_ANDI_	= 0x70000000,
+	PPC_ANDIS_	= 0x74000000,
+	PPC_RLDICL	= 0x78000000,
+	PPC_RLDICR	= 0x78000000,
+	PPC_RLDIC	= 0x78000000,
+	PPC_RLDIMI	= 0x78000000,
+	PPC_RLDCL	= 0x78000000,
+	PPC_RLDCR	= 0x78000000,
+	PPC_CMP		= 0x7c000000,
+	PPC_TW		= 0x7c000000,
+	PPC_SUBFC	= 0x7c000010,
+	PPC_MULHDU	= 0x7c000000,
+	PPC_ADDC	= 0x7c000014,
+	PPC_MULHWU	= 0x7c000000,
+	PPC_MFCR	= 0x7c000000,
+	PPC_LWAR	= 0x7c000000,
+	PPC_LDX		= 0x7c000000,
+	PPC_LWZX	= 0x7c00002e,
+	PPC_SLW		= 0x7c000030,
+	PPC_CNTLZW	= 0x7c000000,
+	PPC_SLD		= 0x7c000000,
+	PPC_AND		= 0x7c000038,
+	PPC_CMPL	= 0x7c000040,
+	PPC_SUBF	= 0x7c000050,
+	PPC_LDUX	= 0x7c000000,
+//------------
+	PPC_DCBST	= 0x7c000000,
+	PPC_LWZUX	= 0x7c00006c,
+	PPC_CNTLZD	= 0x7c000000,
+	PPC_ANDC	= 0x7c000000,
+	PPC_TD		= 0x7c000000,
+	PPC_MULHD	= 0x7c000000,
+	PPC_MULHW	= 0x7c000000,
+	PPC_MTSRD	= 0x7c000000,
+	PPC_MFMSR	= 0x7c000000,
+	PPC_LDARX	= 0x7c000000,
+	PPC_DCBF	= 0x7c000000,
+	PPC_LBZX	= 0x7c0000ae,
+	PPC_NEG		= 0x7c000000,
+	PPC_MTSRDIN	= 0x7c000000,
+	PPC_LBZUX	= 0x7c000000,
+	PPC_NOR		= 0x7c0000f8,
+	PPC_SUBFE	= 0x7c000000,
+	PPC_ADDE	= 0x7c000000,
+	PPC_MTCRF	= 0x7c000000,
+	PPC_MTMSR	= 0x7c000000,
+	PPC_STDX	= 0x7c000000,
+	PPC_STWCX_	= 0x7c000000,
+	PPC_STWX	= 0x7c00012e,
+	PPC_MTMSRD	= 0x7c000000,
+	PPC_STDUX	= 0x7c000000,
+	PPC_STWUX	= 0x7c00016e,
+	PPC_SUBFZE	= 0x7c000000,
+	PPC_ADDZE	= 0x7c000000,
+	PPC_MTSR	= 0x7c000000,
+	PPC_STDCX_	= 0x7c000000,
+	PPC_STBX	= 0x7c0001ae,
+	PPC_SUBFME	= 0x7c000000,
+	PPC_MULLD	= 0x7c000000,
+//------------
+	PPC_ADDME	= 0x7c000000,
+	PPC_MULLW	= 0x7c0001d6,
+	PPC_MTSRIN	= 0x7c000000,
+	PPC_DCBTST	= 0x7c000000,
+	PPC_STBUX	= 0x7c000000,
+	PPC_ADD		= 0x7c000214,
+	PPC_DCBT	= 0x7c000000,
+	PPC_LHZX	= 0x7c00022e,
+	PPC_EQV		= 0x7c000000,
+	PPC_TLBIE	= 0x7c000000,
+	PPC_ECIWX	= 0x7c000000,
+	PPC_LHZUX	= 0x7c000000,
+	PPC_XOR		= 0x7c000278,
+	PPC_MFSPR	= 0x7c0002a6,
+	PPC_LWAX	= 0x7c000000,
+	PPC_LHAX	= 0x7c000000,
+	PPC_TLBIA	= 0x7c000000,
+	PPC_MFTB	= 0x7c000000,
+	PPC_LWAUX	= 0x7c000000,
+	PPC_LHAUX	= 0x7c000000,
+	PPC_STHX	= 0x7c00032e,
+	PPC_ORC		= 0x7c000338,
+	PPC_SRADI	= 0x7c000000,
+	PPC_SLBIE	= 0x7c000000,
+	PPC_ECOWX	= 0x7c000000,
+	PPC_STHUX	= 0x7c000000,
+	PPC_OR		= 0x7c000378,
+	PPC_DIVDU	= 0x7c000000,
+	PPC_DIVWU	= 0x7c000396,
+	PPC_MTSPR	= 0x7c0003a6,
+	PPC_DCBI	= 0x7c000000,
+	PPC_NAND	= 0x7c000000,
+	PPC_DIVD	= 0x7c000000,
+//------------
+	PPC_DIVW	= 0x7c0003d6,
+	PPC_SLBIA	= 0x7c000000,
+	PPC_MCRXR	= 0x7c000000,
+	PPC_LSWX	= 0x7c000000,
+	PPC_LWBRX	= 0x7c000000,
+	PPC_LFSX	= 0x7c000000,
+	PPC_SRW		= 0x7c000430,
+	PPC_SRD		= 0x7c000000,
+	PPC_TLBSYNC	= 0x7c000000,
+	PPC_LFSUX	= 0x7c000000,
+	PPC_MFSR	= 0x7c000000,
+	PPC_LSWI	= 0x7c000000,
+	PPC_SYNC	= 0x7c000000,
+	PPC_LFDX	= 0x7c000000,
+	PPC_LFDUX	= 0x7c000000,
+	PPC_MFSRIN	= 0x7c000000,
+	PPC_STSWX	= 0x7c000000,
+	PPC_STWBRX	= 0x7c000000,
+	PPC_STFSX	= 0x7c000000,
+	PPC_STFSUX	= 0x7c000000,
+	PPC_STSWI	= 0x7c000000,
+	PPC_STFDX	= 0x7c000000,
+	PPC_DCBA	= 0x7c000000,
+	PPC_STFDUX	= 0x7c000000,
+	PPC_LHBRX	= 0x7c000000,
+	PPC_SRAW	= 0x7c000630,
+	PPC_SRAD	= 0x7c000000,
+	PPC_SRAWI	= 0x7c000000,
+	PPC_EIEIO	= 0x7c000000,
+	PPC_STHBRX	= 0x7c000000,
+	PPC_EXTSH	= 0x7c000734,
+	PPC_EXTSB	= 0x7c000774,
+	PPC_ICBI	= 0x7c000000,
+//------------
+	PPC_STFIWX	= 0x7c0007ae,
+	PPC_EXTSW	= 0x7c000000,
+	PPC_DCBZ	= 0x7c000000,
+	PPC_LWZ		= 0x80000000,
+	PPC_LWZU	= 0x84000000,
+	PPC_LBZ		= 0x88000000,
+	PPC_LBZU	= 0x8c000000,
+	PPC_STW		= 0x90000000,
+	PPC_STWU	= 0x94000000,
+	PPC_STB		= 0x98000000,
+	PPC_STBU	= 0x9c000000,
+	PPC_LHZ		= 0xa0000000,
+	PPC_LHZU	= 0xa4000000,
+	PPC_LHA		= 0xa8000000,
+	PPC_LHAU	= 0xac000000,
+	PPC_STH		= 0xb0000000,
+	PPC_STHU	= 0xb4000000,
+	PPC_LMW		= 0xb8000000,
+	PPC_STMW	= 0xbc000000,
+	PPC_LFS		= 0xc0000000,
+	PPC_LFSU	= 0xc4000000,
+	PPC_LFD		= 0xc8000000,
+	PPC_LFDU	= 0xcc000000,
+	PPC_STFS	= 0xd0000000,
+	PPC_STFSU	= 0xd4000000,
+	PPC_STFD	= 0xd8000000,
+	PPC_STFDU	= 0xdc000000,
+	PPC_LD		= 0xe8000000,
+	PPC_LDU		= 0xe8000001,
+	PPC_LWA		= 0xe8000002,
+	PPC_FDIVS	= 0xec000024,
+	PPC_FSUBS	= 0xec000028,
+	PPC_FADDS	= 0xec00002a,
+//------------
+	PPC_FSQRTS	= 0xec000000,
+	PPC_FRES	= 0xec000000,
+	PPC_FMULS	= 0xec000032,
+	PPC_FMSUBS	= 0xec000000,
+	PPC_FMADDS	= 0xec000000,
+	PPC_FNMSUBS	= 0xec000000,
+	PPC_FNMADDS	= 0xec000000,
+	PPC_STD		= 0xf8000000,
+	PPC_STDU	= 0xf8000001,
+	PPC_FCMPU	= 0xfc000000,
+	PPC_FRSP	= 0xfc000018,
+	PPC_FCTIW	= 0xfc000000,
+	PPC_FCTIWZ	= 0xfc00001e,
+	PPC_FDIV	= 0xfc000000,
+	PPC_FSUB	= 0xfc000028,
+	PPC_FADD	= 0xfc000000,
+	PPC_FSQRT	= 0xfc000000,
+	PPC_FSEL	= 0xfc000000,
+	PPC_FMUL	= 0xfc000000,
+	PPC_FRSQRTE	= 0xfc000000,
+	PPC_FMSUB	= 0xfc000000,
+	PPC_FMADD	= 0xfc000000,
+	PPC_FNMSUB	= 0xfc000000,
+	PPC_FNMADD	= 0xfc000000,
+	PPC_FCMPO	= 0xfc000000,
+	PPC_MTFSB1	= 0xfc000000,
+	PPC_FNEG	= 0xfc000050,
+	PPC_MCRFS	= 0xfc000000,
+	PPC_MTFSB0	= 0xfc000000,
+	PPC_FMR		= 0xfc000000,
+	PPC_MTFSFI	= 0xfc000000,
+	PPC_FNABS	= 0xfc000000,
+	PPC_FABS	= 0xfc000000,
+//------------
+	PPC_MFFS	= 0xfc000000,
+	PPC_MTFSF	= 0xfc000000,
+	PPC_FCTID	= 0xfc000000,
+	PPC_FCTIDZ	= 0xfc000000,
+	PPC_FCFID	= 0xfc000000
+	
+} ppcOpcodes_t;
+
+
+// the newly generated code
+static	unsigned	*buf;
+static	int		compiledOfs;	// in dwords
+
+// fromt the original bytecode
+static	byte	*code;
+static	int		pc;
+
+void AsmCall( void );
+
+double	itofConvert[2];
+
+static int	Constant4( void ) {
+	int		v;
+
+	v = code[pc] | (code[pc+1]<<8) | (code[pc+2]<<16) | (code[pc+3]<<24);
+	pc += 4;
+	return v;
+}
+
+static int	Constant1( void ) {
+	int		v;
+
+	v = code[pc];
+	pc += 1;
+	return v;
+}
+
+static void Emit4( int i ) {
+	buf[ compiledOfs ] = i;
+	compiledOfs++;
+}
+
+static void Inst( int opcode, int destReg, int aReg, int bReg ) {
+    unsigned		r;
+
+    r = opcode | ( destReg << 21 ) | ( aReg << 16 ) | ( bReg << 11 ) ;
+    buf[ compiledOfs ] = r;
+    compiledOfs++;
+}
+
+static void Inst4( int opcode, int destReg, int aReg, int bReg, int cReg ) {
+    unsigned		r;
+
+    r = opcode | ( destReg << 21 ) | ( aReg << 16 ) | ( bReg << 11 ) | ( cReg << 6 );
+    buf[ compiledOfs ] = r;
+    compiledOfs++;
+}
+
+static void InstImm( int opcode, int destReg, int aReg, int immediate ) {
+	unsigned		r;
+	
+	if ( immediate > 32767 || immediate < -32768 ) {
+	    Com_Error( ERR_FATAL, "VM_Compile: immediate value %i out of range, opcode %x,%d,%d", immediate, opcode, destReg, aReg );
+	}
+	r = opcode | ( destReg << 21 ) | ( aReg << 16 ) | ( immediate & 0xffff );
+	buf[ compiledOfs ] = r;
+	compiledOfs++;
+}
+
+static void InstImmU( int opcode, int destReg, int aReg, int immediate ) {
+	unsigned		r;
+	
+	if ( immediate > 0xffff || immediate < 0 ) {
+		Com_Error( ERR_FATAL, "VM_Compile: immediate value %i out of range", immediate );
+	}
+    r = opcode | ( destReg << 21 ) | ( aReg << 16 ) | ( immediate & 0xffff );
+	buf[ compiledOfs ] = r;
+	compiledOfs++;
+}
+
+static qboolean	rtopped;
+static int pop0, pop1, oc0, oc1;
+static vm_t *tvm;
+static int instruction;
+static byte *jused;
+static int pass;
+
+static void ltop() {
+    if (rtopped == qfalse) {
+	InstImm( PPC_LWZ, R_TOP, R_OPSTACK, 0 );		// get value from opstack
+    }
+}
+
+static void ltopandsecond() {
+    if (pass>=0 && buf[compiledOfs-1] == (PPC_STWU |  R_TOP<<21 | R_OPSTACK<<16 | 4 ) && jused[instruction]==0 ) {
+	compiledOfs--;
+	if (!pass) {
+	    tvm->instructionPointers[instruction] = compiledOfs * 4;
+	}
+	InstImm( PPC_LWZ, R_SECOND, R_OPSTACK, 0 );	// get value from opstack
+	InstImm( PPC_ADDI, R_OPSTACK, R_OPSTACK, -4 );
+    } else if (pass>=0 && buf[compiledOfs-1] == (PPC_STW |  R_TOP<<21 | R_OPSTACK<<16 | 0 )  && jused[instruction]==0 ) {
+	compiledOfs--;
+	if (!pass) {
+	    tvm->instructionPointers[instruction] = compiledOfs * 4;
+	}
+	InstImm( PPC_LWZ, R_SECOND, R_OPSTACK, -4 );	// get value from opstack
+	InstImm( PPC_ADDI, R_OPSTACK, R_OPSTACK, -8 );
+    } else {
+	ltop();		// get value from opstack
+	InstImm( PPC_LWZ, R_SECOND, R_OPSTACK, -4 );	// get value from opstack
+	InstImm( PPC_ADDI, R_OPSTACK, R_OPSTACK, -8 );
+    }
+    rtopped = qfalse;
+}
+
+// TJW: Unused
+#if 0
+static void fltop() {
+    if (rtopped == qfalse) {
+	InstImm( PPC_LFS, R_TOP, R_OPSTACK, 0 );		// get value from opstack
+    }
+}
+#endif
+
+static void fltopandsecond() {
+	InstImm( PPC_LFS, R_TOP, R_OPSTACK, 0 );		// get value from opstack
+	InstImm( PPC_LFS, R_SECOND, R_OPSTACK, -4 );	// get value from opstack
+	InstImm( PPC_ADDI, R_OPSTACK, R_OPSTACK, -8 );
+    rtopped = qfalse;
+	return;
+}
+
+/*
+=================
+VM_Compile
+=================
+*/
+void VM_Compile( vm_t *vm, vmHeader_t *header ) {
+	int		op;
+	int		maxLength;
+	int		v;
+	int		i;
+	
+	// set up the into-to-float variables
+   	((int *)itofConvert)[0] = 0x43300000;
+   	((int *)itofConvert)[1] = 0x80000000;
+   	((int *)itofConvert)[2] = 0x43300000;
+
+	// allocate a very large temp buffer, we will shrink it later
+	maxLength = header->codeLength * 8;
+	buf = Z_Malloc( maxLength,qfalse );
+	jused = Z_Malloc(header->instructionCount + 2,qfalse);
+	Com_Memset(jused, 0, header->instructionCount+2);
+	
+    // compile everything twice, so the second pass will have valid instruction
+    // pointers for branches
+    for ( pass = -1 ; pass < 2 ; pass++ ) {
+
+	rtopped = qfalse;
+        // translate all instructions
+        pc = 0;
+	
+	pop0 = 343545;
+	pop1 = 2443545;
+	oc0 = -2343535;
+	oc1 = 24353454;
+	tvm = vm;
+	
+        code = (byte *)header + header->codeOffset;
+        compiledOfs = 0;
+#ifndef __GNUC__
+		// metrowerks seems to require this header in front of functions
+		Emit4( (int)(buf+2) );
+		Emit4( 0 );
+#endif
+
+		for ( instruction = 0 ; instruction < header->instructionCount ; instruction++ ) {
+            if ( compiledOfs*4 > maxLength - 16 ) {
+                Com_Error( ERR_DROP, "VM_Compile: maxLength exceeded" );
+            }
+
+            op = code[ pc ];
+            if ( !pass ) {
+                vm->instructionPointers[ instruction ] = compiledOfs * 4;
+            }
+            pc++;
+            switch ( op ) {
+            case 0:
+                break;
+            case OP_BREAK:
+                InstImmU( PPC_ADDI, R_TOP, 0, 0 );
+                InstImm( PPC_LWZ, R_TOP, R_TOP, 0 );			// *(int *)0 to crash to debugger
+		rtopped = qfalse;
+                break;
+            case OP_ENTER:
+                InstImm( PPC_ADDI, R_STACK, R_STACK, -Constant4() );	// sub R_STACK, R_STACK, imm
+		rtopped = qfalse;
+                break;
+            case OP_CONST:
+                v = Constant4();
+		if (code[pc] == OP_LOAD4 || code[pc] == OP_LOAD2 || code[pc] == OP_LOAD1) {
+		    v &= vm->dataMask;
+		}
+                if ( v < 32768 && v >= -32768 ) {
+                    InstImmU( PPC_ADDI, R_TOP, 0, v & 0xffff );
+                } else {
+                    InstImmU( PPC_ADDIS, R_TOP, 0, (v >> 16)&0xffff );
+                    if ( v & 0xffff ) {
+                        InstImmU( PPC_ORI, R_TOP, R_TOP, v & 0xffff );
+                    }
+                }
+		if (code[pc] == OP_LOAD4) {
+		    Inst( PPC_LWZX, R_TOP, R_TOP, R_MEMBASE );		// load from memory base
+		    pc++;
+		    instruction++;
+		} else if (code[pc] == OP_LOAD2) {
+		    Inst( PPC_LHZX, R_TOP, R_TOP, R_MEMBASE );		// load from memory base
+		    pc++;
+		    instruction++;
+		} else if (code[pc] == OP_LOAD1) {
+		    Inst( PPC_LBZX, R_TOP, R_TOP, R_MEMBASE );		// load from memory base
+		    pc++;
+		    instruction++;
+		}
+		if (code[pc] == OP_STORE4) {
+		    InstImm( PPC_LWZ, R_SECOND, R_OPSTACK, 0 );	// get value from opstack
+		    InstImm( PPC_ADDI, R_OPSTACK, R_OPSTACK, -4 );
+		    //Inst( PPC_AND, R_MEMMASK, R_SECOND, R_SECOND );	// mask it
+		    Inst( PPC_STWX, R_TOP, R_SECOND, R_MEMBASE );	// store from memory base
+		    pc++;
+		    instruction++;
+		    rtopped = qfalse;
+		    break;
+		} else if (code[pc] == OP_STORE2) {
+		    InstImm( PPC_LWZ, R_SECOND, R_OPSTACK, 0 );	// get value from opstack
+		    InstImm( PPC_ADDI, R_OPSTACK, R_OPSTACK, -4 );
+		    //Inst( PPC_AND, R_MEMMASK, R_SECOND, R_SECOND );	// mask it
+		    Inst( PPC_STHX, R_TOP, R_SECOND, R_MEMBASE );	// store from memory base
+		    pc++;
+		    instruction++;
+		    rtopped = qfalse;
+		    break;
+		} else if (code[pc] == OP_STORE1) {
+		    InstImm( PPC_LWZ, R_SECOND, R_OPSTACK, 0 );	// get value from opstack
+		    InstImm( PPC_ADDI, R_OPSTACK, R_OPSTACK, -4 );
+		    //Inst( PPC_AND, R_MEMMASK, R_SECOND, R_SECOND );	// mask it
+		    Inst( PPC_STBX, R_TOP, R_SECOND, R_MEMBASE );	// store from memory base
+		    pc++;
+		    instruction++;
+		    rtopped = qfalse;
+		    break;
+		}
+		if (code[pc] == OP_JUMP) {
+		    jused[v] = 1;
+		}
+		InstImm( PPC_STWU, R_TOP, R_OPSTACK, 4 );
+		rtopped = qtrue;
+		break;
+            case OP_LOCAL:
+		oc0 = oc1;
+		oc1 = Constant4();
+		if (code[pc] == OP_LOAD4 || code[pc] == OP_LOAD2 || code[pc] == OP_LOAD1) {
+		    oc1 &= vm->dataMask;
+		}
+                InstImm( PPC_ADDI, R_TOP, R_STACK, oc1 );
+		if (code[pc] == OP_LOAD4) {
+		    Inst( PPC_LWZX, R_TOP, R_TOP, R_MEMBASE );		// load from memory base
+		    pc++;
+		    instruction++;
+		} else if (code[pc] == OP_LOAD2) {
+		    Inst( PPC_LHZX, R_TOP, R_TOP, R_MEMBASE );		// load from memory base
+		    pc++;
+		    instruction++;
+		} else if (code[pc] == OP_LOAD1) {
+		    Inst( PPC_LBZX, R_TOP, R_TOP, R_MEMBASE );		// load from memory base
+		    pc++;
+		    instruction++;
+		}
+		if (code[pc] == OP_STORE4) {
+		    InstImm( PPC_LWZ, R_SECOND, R_OPSTACK, 0 );		// get value from opstack
+		    InstImm( PPC_ADDI, R_OPSTACK, R_OPSTACK, -4 );
+		    //Inst( PPC_AND, R_MEMMASK, R_SECOND, R_SECOND );	// mask it
+		    Inst( PPC_STWX, R_TOP, R_SECOND, R_MEMBASE );	// store from memory base
+		    pc++;
+		    instruction++;
+		    rtopped = qfalse;
+		    break;
+		} else if (code[pc] == OP_STORE2) {
+		    InstImm( PPC_LWZ, R_SECOND, R_OPSTACK, 0 );		// get value from opstack
+		    InstImm( PPC_ADDI, R_OPSTACK, R_OPSTACK, -4 );
+		    //Inst( PPC_AND, R_MEMMASK, R_SECOND, R_SECOND );	// mask it
+		    Inst( PPC_STHX, R_TOP, R_SECOND, R_MEMBASE );	// store from memory base
+		    pc++;
+		    instruction++;
+		    rtopped = qfalse;
+		    break;
+		} else if (code[pc] == OP_STORE1) {
+		    InstImm( PPC_LWZ, R_SECOND, R_OPSTACK, 0 );		// get value from opstack
+		    InstImm( PPC_ADDI, R_OPSTACK, R_OPSTACK, -4 );
+		    //Inst( PPC_AND, R_MEMMASK, R_SECOND, R_SECOND );	// mask it
+		    Inst( PPC_STBX, R_TOP, R_SECOND, R_MEMBASE );	// store from memory base
+		    pc++;
+		    instruction++;
+		    rtopped = qfalse;
+		    break;
+		}
+                InstImm( PPC_STWU, R_TOP, R_OPSTACK, 4 );
+		rtopped = qtrue;
+                break;
+            case OP_ARG:
+                ltop();							// get value from opstack
+                InstImm( PPC_ADDI, R_OPSTACK, R_OPSTACK, -4 );
+                InstImm( PPC_ADDI, R_EA, R_STACK, Constant1() );	// location to put it
+                Inst( PPC_STWX, R_TOP, R_EA, R_MEMBASE );
+		rtopped = qfalse;
+                break;
+            case OP_CALL:
+                Inst( PPC_MFSPR, R_SECOND, 8, 0 );			// move from link register
+                InstImm( PPC_STWU, R_SECOND, R_REAL_STACK, -16 );	// save off the old return address
+
+                Inst( PPC_MTSPR, R_ASMCALL, 9, 0 );			// move to count register
+                Inst( PPC_BCCTR | 1, 20, 0, 0 );			// jump and link to the count register
+
+                InstImm( PPC_LWZ, R_SECOND, R_REAL_STACK, 0 );		// fetch the old return address
+                InstImm( PPC_ADDI, R_REAL_STACK, R_REAL_STACK, 16 );
+                Inst( PPC_MTSPR, R_SECOND, 8, 0 );			// move to link register
+		rtopped = qfalse;
+                break;
+            case OP_PUSH:
+                InstImm( PPC_ADDI, R_OPSTACK, R_OPSTACK, 4 );
+		rtopped = qfalse;
+                break;
+            case OP_POP:
+                InstImm( PPC_ADDI, R_OPSTACK, R_OPSTACK, -4 );
+		rtopped = qfalse;
+                break;
+            case OP_LEAVE:
+                InstImm( PPC_ADDI, R_STACK, R_STACK, Constant4() );	// add R_STACK, R_STACK, imm
+                Inst( PPC_BCLR, 20, 0, 0 );							// branch unconditionally to link register
+		rtopped = qfalse;
+                break;
+            case OP_LOAD4:
+                ltop();							// get value from opstack
+		//Inst( PPC_AND, R_MEMMASK, R_TOP, R_TOP );		// mask it
+                Inst( PPC_LWZX, R_TOP, R_TOP, R_MEMBASE );		// load from memory base
+                InstImm( PPC_STW, R_TOP, R_OPSTACK, 0 );
+		rtopped = qtrue;
+                break;
+            case OP_LOAD2:
+                ltop();							// get value from opstack
+		//Inst( PPC_AND, R_MEMMASK, R_TOP, R_TOP );		// mask it
+                Inst( PPC_LHZX, R_TOP, R_TOP, R_MEMBASE );		// load from memory base
+                InstImm( PPC_STW, R_TOP, R_OPSTACK, 0 );
+		rtopped = qtrue;
+                break;
+            case OP_LOAD1:
+                ltop();							// get value from opstack
+		//Inst( PPC_AND, R_MEMMASK, R_TOP, R_TOP );		// mask it
+                Inst( PPC_LBZX, R_TOP, R_TOP, R_MEMBASE );		// load from memory base
+                InstImm( PPC_STW, R_TOP, R_OPSTACK, 0 );
+		rtopped = qtrue;
+                break;
+            case OP_STORE4:
+                ltopandsecond();					// get value from opstack
+		//Inst( PPC_AND, R_MEMMASK, R_SECOND, R_SECOND );		// mask it
+                Inst( PPC_STWX, R_TOP, R_SECOND, R_MEMBASE );		// store from memory base
+		rtopped = qfalse;
+                break;
+            case OP_STORE2:
+                ltopandsecond();					// get value from opstack
+		//Inst( PPC_AND, R_MEMMASK, R_SECOND, R_SECOND );		// mask it
+                Inst( PPC_STHX, R_TOP, R_SECOND, R_MEMBASE );		// store from memory base
+		rtopped = qfalse;
+                break;
+            case OP_STORE1:
+                ltopandsecond();					// get value from opstack
+		//Inst( PPC_AND, R_MEMMASK, R_SECOND, R_SECOND );		// mask it
+                Inst( PPC_STBX, R_TOP, R_SECOND, R_MEMBASE );		// store from memory base
+		rtopped = qfalse;
+                break;
+
+            case OP_EQ:
+                ltopandsecond();					// get value from opstack
+                Inst( PPC_CMP, 0, R_SECOND, R_TOP );
+                i = Constant4();
+				jused[i] = 1;
+                InstImm( PPC_BC, 4, 2, 8 );
+                if ( pass==1 ) {
+                    v = vm->instructionPointers[ i ] - (int)&buf[compiledOfs];                    
+                } else {
+                    v = 0;             
+                }
+                Emit4(PPC_B | (v&0x3ffffff) );
+				rtopped = qfalse;
+                break;
+            case OP_NE:
+                ltopandsecond();					// get value from opstack
+                Inst( PPC_CMP, 0, R_SECOND, R_TOP );
+                i = Constant4();
+				jused[i] = 1;
+                InstImm( PPC_BC, 12, 2, 8 );
+                if ( pass==1 ) {
+                    v = vm->instructionPointers[ i ] - (int)&buf[compiledOfs];                    
+                } else {
+                    v = 0;
+                }
+                Emit4(PPC_B | (unsigned int)(v&0x3ffffff) );
+//                InstImm( PPC_BC, 4, 2, v );
+
+				rtopped = qfalse;
+                break;
+            case OP_LTI:
+                ltopandsecond();					// get value from opstack
+                Inst( PPC_CMP, 0, R_SECOND, R_TOP );
+                i = Constant4();
+				jused[i] = 1;
+                InstImm( PPC_BC, 4, 0, 8 );
+                if ( pass==1 ) {
+                    v = vm->instructionPointers[ i ] - (int)&buf[compiledOfs];
+                } else {
+                    v = 0;
+                }
+                Emit4(PPC_B | (unsigned int)(v&0x3ffffff) );
+//                InstImm( PPC_BC, 12, 0, v );
+				rtopped = qfalse;
+                break;
+            case OP_LEI:
+                ltopandsecond();					// get value from opstack
+                Inst( PPC_CMP, 0, R_SECOND, R_TOP );
+                i = Constant4();
+				jused[i] = 1;
+                InstImm( PPC_BC, 12, 1, 8 );
+                if ( pass==1 ) {
+                    v = vm->instructionPointers[ i ] - (int)&buf[compiledOfs];
+                } else {
+                    v = 0;
+                }
+                Emit4(PPC_B | (unsigned int)(v&0x3ffffff) );
+//                InstImm( PPC_BC, 4, 1, v );
+				rtopped = qfalse;
+                break;
+            case OP_GTI:
+                ltopandsecond();		// get value from opstack
+                Inst( PPC_CMP, 0, R_SECOND, R_TOP );
+                i = Constant4();
+				jused[i] = 1;
+                InstImm( PPC_BC, 4, 1, 8 );
+                if ( pass==1 ) {
+                    v = vm->instructionPointers[ i ] - (int)&buf[compiledOfs];
+                } else {
+                    v = 0;
+                }
+                Emit4(PPC_B | (unsigned int)(v&0x3ffffff) );
+//                InstImm( PPC_BC, 12, 1, v );
+				rtopped = qfalse;
+                break;
+            case OP_GEI:
+                ltopandsecond();		// get value from opstack
+                Inst( PPC_CMP, 0, R_SECOND, R_TOP );
+                i = Constant4();
+				jused[i] = 1;
+                if ( pass==1 ) {
+                    v = vm->instructionPointers[ i ] - (int)&buf[compiledOfs];
+                } else {
+                    v = 0;
+                }
+                InstImm( PPC_BC, 4, 0, v );
+				rtopped = qfalse;
+                break;
+            case OP_LTU:
+                ltopandsecond();		// get value from opstack
+                Inst( PPC_CMPL, 0, R_SECOND, R_TOP );
+                i = Constant4();
+		jused[i] = 1;
+                if ( pass==1 ) {
+                    v = vm->instructionPointers[ i ] - (int)&buf[compiledOfs];
+                } else {
+                    v = 0;
+                }
+                InstImm( PPC_BC, 12, 0, v );
+		rtopped = qfalse;
+                break;
+            case OP_LEU:
+                ltopandsecond();		// get value from opstack
+                Inst( PPC_CMPL, 0, R_SECOND, R_TOP );
+                i = Constant4();
+		jused[i] = 1;
+                if ( pass==1 ) {
+                    v = vm->instructionPointers[ i ] - (int)&buf[compiledOfs];
+                } else {
+                    v = 0;
+                }
+                InstImm( PPC_BC, 4, 1, v );
+		rtopped = qfalse;
+                break;
+            case OP_GTU:
+                ltopandsecond();		// get value from opstack
+                Inst( PPC_CMPL, 0, R_SECOND, R_TOP );
+                i = Constant4();
+		jused[i] = 1;
+                if ( pass==1 ) {
+                    v = vm->instructionPointers[ i ] - (int)&buf[compiledOfs];
+                } else {
+                    v = 0;
+                }
+                InstImm( PPC_BC, 12, 1, v );
+		rtopped = qfalse;
+                break;
+            case OP_GEU:
+                ltopandsecond();		// get value from opstack
+                Inst( PPC_CMPL, 0, R_SECOND, R_TOP );
+                i = Constant4();
+		jused[i] = 1;
+                if ( pass==1 ) {
+                    v = vm->instructionPointers[ i ] - (int)&buf[compiledOfs];
+                } else {
+                    v = 0;
+                }
+                InstImm( PPC_BC, 4, 0, v );
+		rtopped = qfalse;
+                break;
+                
+            case OP_EQF:
+                fltopandsecond();		// get value from opstack
+                Inst( PPC_FCMPU, 0, R_TOP, R_SECOND );
+                i = Constant4();
+		jused[i] = 1;
+                if ( pass==1 ) {
+                    v = vm->instructionPointers[ i ] - (int)&buf[compiledOfs];
+                } else {
+                    v = 0;
+                }
+                InstImm( PPC_BC, 12, 2, v );
+		rtopped = qfalse;
+                break;			
+            case OP_NEF:
+                fltopandsecond();		// get value from opstack
+                Inst( PPC_FCMPU, 0, R_TOP, R_SECOND );
+                i = Constant4();
+		jused[i] = 1;
+                if ( pass==1 ) {
+                    v = vm->instructionPointers[ i ] - (int)&buf[compiledOfs];
+                } else {
+                    v = 0;
+                }
+                InstImm( PPC_BC, 4, 2, v );
+		rtopped = qfalse;
+                break;			
+            case OP_LTF:
+                fltopandsecond();		// get value from opstack
+                Inst( PPC_FCMPU, 0, R_SECOND, R_TOP );
+                i = Constant4();
+		jused[i] = 1;
+                if ( pass==1 ) {
+                    v = vm->instructionPointers[ i ] - (int)&buf[compiledOfs];
+                } else {
+                    v = 0;
+                }
+                InstImm( PPC_BC, 12, 0, v );
+		rtopped = qfalse;
+                break;			
+            case OP_LEF:
+                fltopandsecond();		// get value from opstack
+                Inst( PPC_FCMPU, 0, R_SECOND, R_TOP );
+                i = Constant4();
+		jused[i] = 1;
+                if ( pass==1 ) {
+                    v = vm->instructionPointers[ i ] - (int)&buf[compiledOfs];
+                } else {
+                    v = 0;
+                }
+                InstImm( PPC_BC, 4, 1, v );
+		rtopped = qfalse;
+                break;			
+            case OP_GTF:
+                fltopandsecond();		// get value from opstack
+                Inst( PPC_FCMPU, 0, R_SECOND, R_TOP );
+                i = Constant4();
+		jused[i] = 1;
+                if ( pass==1 ) {
+                    v = vm->instructionPointers[ i ] - (int)&buf[compiledOfs];
+                } else {
+                    v = 0;
+                }
+                InstImm( PPC_BC, 12, 1, v );
+		rtopped = qfalse;
+                break;			
+            case OP_GEF:
+                fltopandsecond();		// get value from opstack
+                Inst( PPC_FCMPU, 0, R_SECOND, R_TOP );
+                i = Constant4();
+		jused[i] = 1;
+                if ( pass==1 ) {
+                    v = vm->instructionPointers[ i ] - (int)&buf[compiledOfs];
+                } else {
+                    v = 0;
+                }
+                InstImm( PPC_BC, 4, 0, v );
+		rtopped = qfalse;
+                break;
+
+            case OP_NEGI:
+                ltop();		// get value from opstack
+                InstImm( PPC_SUBFIC, R_TOP, R_TOP, 0 );
+                InstImm( PPC_STW, R_TOP, R_OPSTACK, 0 );		// save value to opstack
+		rtopped = qtrue;
+                break;
+            case OP_ADD:
+                ltop();		// get value from opstack
+                InstImm( PPC_LWZU, R_SECOND, R_OPSTACK, -4 );		// get value from opstack
+                Inst( PPC_ADD, R_TOP, R_TOP, R_SECOND );
+                InstImm( PPC_STW, R_TOP, R_OPSTACK, 0 );		// save value to opstack
+		rtopped = qtrue;
+                break;
+            case OP_SUB:
+                ltop();		// get value from opstack
+                InstImm( PPC_LWZU, R_SECOND, R_OPSTACK, -4 );		// get value from opstack
+                Inst( PPC_SUBF, R_TOP, R_TOP, R_SECOND );
+                InstImm( PPC_STW, R_TOP, R_OPSTACK, 0 );		// save value to opstack
+		rtopped = qtrue;
+                break;
+            case OP_DIVI:
+                ltop();		// get value from opstack
+                InstImm( PPC_LWZU, R_SECOND, R_OPSTACK, -4 );		// get value from opstack
+                Inst( PPC_DIVW, R_TOP, R_SECOND, R_TOP );
+                InstImm( PPC_STW, R_TOP, R_OPSTACK, 0 );		// save value to opstack
+		rtopped = qtrue;
+                break;
+            case OP_DIVU:
+                ltop();		// get value from opstack
+                InstImm( PPC_LWZU, R_SECOND, R_OPSTACK, -4 );		// get value from opstack
+                Inst( PPC_DIVWU, R_TOP, R_SECOND, R_TOP );
+                InstImm( PPC_STW, R_TOP, R_OPSTACK, 0 );		// save value to opstack
+		rtopped = qtrue;
+                break;
+            case OP_MODI:
+                ltop();		// get value from opstack
+                InstImm( PPC_LWZU, R_SECOND, R_OPSTACK, -4 );		// get value from opstack
+                Inst( PPC_DIVW, R_EA, R_SECOND, R_TOP );
+                Inst( PPC_MULLW, R_EA, R_TOP, R_EA );
+                Inst( PPC_SUBF, R_TOP, R_EA, R_SECOND );
+                InstImm( PPC_STW, R_TOP, R_OPSTACK, 0 );		// save value to opstack
+		rtopped = qtrue;
+                break;
+            case OP_MODU:
+                ltop();		// get value from opstack
+                InstImm( PPC_LWZU, R_SECOND, R_OPSTACK, -4 );		// get value from opstack
+                Inst( PPC_DIVWU, R_EA, R_SECOND, R_TOP );
+                Inst( PPC_MULLW, R_EA, R_TOP, R_EA );
+                Inst( PPC_SUBF, R_TOP, R_EA, R_SECOND );
+                InstImm( PPC_STW, R_TOP, R_OPSTACK, 0 );		// save value to opstack
+		rtopped = qtrue;
+                break;
+            case OP_MULI:
+            case OP_MULU:
+                ltop();		// get value from opstack
+                InstImm( PPC_LWZU, R_SECOND, R_OPSTACK, -4 );		// get value from opstack
+                Inst( PPC_MULLW, R_TOP, R_SECOND, R_TOP );
+                InstImm( PPC_STW, R_TOP, R_OPSTACK, 0 );		// save value to opstack
+		rtopped = qtrue;
+                break;
+            case OP_BAND:
+                ltop();		// get value from opstack
+                InstImm( PPC_LWZU, R_SECOND, R_OPSTACK, -4 );		// get value from opstack
+                Inst( PPC_AND, R_SECOND, R_TOP, R_TOP );
+                InstImm( PPC_STW, R_TOP, R_OPSTACK, 0 );		// save value to opstack
+		rtopped = qtrue;
+                break;
+            case OP_BOR:
+                ltop();		// get value from opstack
+                InstImm( PPC_LWZU, R_SECOND, R_OPSTACK, -4 );		// get value from opstack
+                Inst( PPC_OR, R_SECOND, R_TOP, R_TOP );
+                InstImm( PPC_STW, R_TOP, R_OPSTACK, 0 );		// save value to opstack
+		rtopped = qtrue;
+                break;
+            case OP_BXOR:
+                ltop();		// get value from opstack
+                InstImm( PPC_LWZU, R_SECOND, R_OPSTACK, -4 );		// get value from opstack
+                Inst( PPC_XOR, R_SECOND, R_TOP, R_TOP );
+                InstImm( PPC_STW, R_TOP, R_OPSTACK, 0 );		// save value to opstack
+		rtopped = qtrue;
+                break;
+            case OP_BCOM:
+                ltop();		// get value from opstack
+                Inst( PPC_NOR, R_TOP, R_TOP, R_TOP );
+                InstImm( PPC_STW, R_TOP, R_OPSTACK, 0 );		// save value to opstack
+		rtopped = qtrue;
+                break;
+            case OP_LSH:
+                ltop();		// get value from opstack
+                InstImm( PPC_LWZU, R_SECOND, R_OPSTACK, -4 );		// get value from opstack
+                Inst( PPC_SLW, R_SECOND, R_TOP, R_TOP );
+                InstImm( PPC_STW, R_TOP, R_OPSTACK, 0 );		// save value to opstack
+		rtopped = qtrue;
+                break;
+            case OP_RSHI:
+                ltop();		// get value from opstack
+                InstImm( PPC_LWZU, R_SECOND, R_OPSTACK, -4 );		// get value from opstack
+                Inst( PPC_SRAW, R_SECOND, R_TOP, R_TOP );
+                InstImm( PPC_STW, R_TOP, R_OPSTACK, 0 );		// save value to opstack
+		rtopped = qtrue;
+                break;
+            case OP_RSHU:
+                ltop();		// get value from opstack
+                InstImm( PPC_LWZU, R_SECOND, R_OPSTACK, -4 );		// get value from opstack
+                Inst( PPC_SRW, R_SECOND, R_TOP, R_TOP );
+                InstImm( PPC_STW, R_TOP, R_OPSTACK, 0 );		// save value to opstack
+		rtopped = qtrue;
+                break;
+
+            case OP_NEGF:
+                InstImm( PPC_LFS, R_TOP, R_OPSTACK, 0 );		// get value from opstack
+                Inst( PPC_FNEG, R_TOP, 0, R_TOP );
+                InstImm( PPC_STFS, R_TOP, R_OPSTACK, 0 );		// save value to opstack
+		rtopped = qfalse;
+                break;
+            case OP_ADDF:
+                InstImm( PPC_LFS, R_TOP, R_OPSTACK, 0 );		// get value from opstack
+                InstImm( PPC_LFSU, R_SECOND, R_OPSTACK, -4 );		// get value from opstack
+                Inst( PPC_FADDS, R_TOP, R_SECOND, R_TOP );
+                InstImm( PPC_STFS, R_TOP, R_OPSTACK, 0 );		// save value to opstack
+		rtopped = qfalse;
+                break;
+            case OP_SUBF:
+                InstImm( PPC_LFS, R_TOP, R_OPSTACK, 0 );		// get value from opstack
+                InstImm( PPC_LFSU, R_SECOND, R_OPSTACK, -4 );		// get value from opstack
+                Inst( PPC_FSUBS, R_TOP, R_SECOND, R_TOP );
+                InstImm( PPC_STFS, R_TOP, R_OPSTACK, 0 );		// save value to opstack
+		rtopped = qfalse;
+                break;
+            case OP_DIVF:
+                InstImm( PPC_LFS, R_TOP, R_OPSTACK, 0 );		// get value from opstack
+                InstImm( PPC_LFSU, R_SECOND, R_OPSTACK, -4 );		// get value from opstack
+                Inst( PPC_FDIVS, R_TOP, R_SECOND, R_TOP );
+                InstImm( PPC_STFS, R_TOP, R_OPSTACK, 0 );		// save value to opstack
+		rtopped = qfalse;
+                break;
+            case OP_MULF:
+                InstImm( PPC_LFS, R_TOP, R_OPSTACK, 0 );		// get value from opstack
+                InstImm( PPC_LFSU, R_SECOND, R_OPSTACK, -4 );		// get value from opstack
+                Inst4( PPC_FMULS, R_TOP, R_SECOND, 0, R_TOP );
+                InstImm( PPC_STFS, R_TOP, R_OPSTACK, 0 );		// save value to opstack
+		rtopped = qfalse;
+                break;
+
+            case OP_CVIF:
+                v = (int)&itofConvert;
+                InstImmU( PPC_ADDIS, R_EA, 0, (v >> 16)&0xffff );
+                InstImmU( PPC_ORI, R_EA, R_EA, v & 0xffff );
+		InstImm( PPC_LWZ, R_TOP, R_OPSTACK, 0 );		// get value from opstack
+                InstImmU( PPC_XORIS, R_TOP, R_TOP, 0x8000 );
+                InstImm( PPC_STW, R_TOP, R_EA, 12 );
+                InstImm( PPC_LFD, R_TOP, R_EA, 0 );
+                InstImm( PPC_LFD, R_SECOND, R_EA, 8 );
+                Inst( PPC_FSUB, R_TOP, R_SECOND, R_TOP );
+    //            Inst( PPC_FRSP, R_TOP, 0, R_TOP );
+                InstImm( PPC_STFS, R_TOP, R_OPSTACK, 0 );		// save value to opstack
+		rtopped = qfalse;
+                break;
+            case OP_CVFI:
+                InstImm( PPC_LFS, R_TOP, R_OPSTACK, 0 );		// get value from opstack
+                Inst( PPC_FCTIWZ, R_TOP, 0, R_TOP );
+                Inst( PPC_STFIWX, R_TOP, 0, R_OPSTACK );		// save value to opstack
+		rtopped = qfalse;
+                break;
+            case OP_SEX8:
+                ltop();	// get value from opstack
+                Inst( PPC_EXTSB, R_TOP, R_TOP, 0 );
+                InstImm( PPC_STW, R_TOP, R_OPSTACK, 0 );
+		rtopped = qtrue;
+                break;
+            case OP_SEX16:
+                ltop();	// get value from opstack
+                Inst( PPC_EXTSH, R_TOP, R_TOP, 0 );
+                InstImm( PPC_STW, R_TOP, R_OPSTACK, 0 );
+		rtopped = qtrue;
+                break;
+
+            case OP_BLOCK_COPY:
+                v = Constant4() >> 2;
+                ltop();		// source
+                InstImm( PPC_LWZ, R_SECOND, R_OPSTACK, -4 );	// dest
+                InstImm( PPC_ADDI, R_OPSTACK, R_OPSTACK, -8 );
+                InstImmU( PPC_ADDI, R_EA, 0, v );				// count
+				// FIXME: range check
+              	Inst( PPC_MTSPR, R_EA, 9, 0 );					// move to count register
+
+                Inst( PPC_ADD, R_TOP, R_TOP, R_MEMBASE );
+                InstImm( PPC_ADDI, R_TOP, R_TOP, -4 );
+                Inst( PPC_ADD, R_SECOND, R_SECOND, R_MEMBASE );
+                InstImm( PPC_ADDI, R_SECOND, R_SECOND, -4 );
+
+                InstImm( PPC_LWZU, R_EA, R_TOP, 4 );		// source
+                InstImm( PPC_STWU, R_EA, R_SECOND, 4 );	// dest
+                Inst( PPC_BC | 0xfff8 , 16, 0, 0 );					// loop
+		rtopped = qfalse;
+                break;
+
+            case OP_JUMP:
+                ltop();	// get value from opstack
+                InstImm( PPC_ADDI, R_OPSTACK, R_OPSTACK, -4 );
+                Inst( PPC_RLWINM | ( 29 << 1 ), R_TOP, R_TOP, 2 );
+		// FIXME: range check
+		Inst( PPC_LWZX, R_TOP, R_TOP, R_INSTRUCTIONS );
+                Inst( PPC_MTSPR, R_TOP, 9, 0 );		// move to count register
+                Inst( PPC_BCCTR, 20, 0, 0 );		// jump to the count register
+		rtopped = qfalse;
+                break;
+            default:
+                Com_Error( ERR_DROP, "VM_CompilePPC: bad opcode %i at instruction %i, offset %i", op, instruction, pc );
+            }
+	    pop0 = pop1;
+	    pop1 = op;
+        }
+
+	Com_Printf( "VM file %s pass %d compiled to %i bytes of code\n", vm->name, (pass+1), compiledOfs*4 );
+
+    	if ( pass == 0 ) {
+	    // copy to an exact size buffer on the hunk
+	    vm->codeLength = compiledOfs * 4;
+	    vm->codeBase = Hunk_Alloc( vm->codeLength, h_low );
+	    Com_Memcpy( vm->codeBase, buf, vm->codeLength );
+	    Z_Free( buf );
+	
+	    // offset all the instruction pointers for the new location
+	    for ( i = 0 ; i < header->instructionCount ; i++ ) {
+		vm->instructionPointers[i] += (int)vm->codeBase;
+	    }
+
+	    // go back over it in place now to fixup reletive jump targets
+	    buf = (unsigned *)vm->codeBase;
+	}
+    }
+    Z_Free( jused );
+}
+
+/*
+==============
+VM_CallCompiled
+
+This function is called directly by the generated code
+==============
+*/
+int	VM_CallCompiled( vm_t *vm, int *args ) {
+	int		stack[1024];
+	int		programStack;
+	int		stackOnEntry;
+	byte	*image;
+
+	currentVM = vm;
+
+	// interpret the code
+	vm->currentlyInterpreting = qtrue;
+
+	// we might be called recursively, so this might not be the very top
+	programStack = vm->programStack;
+	stackOnEntry = programStack;
+	image = vm->dataBase;
+	
+	// set up the stack frame 
+	programStack -= 48;
+
+	*(int *)&image[ programStack + 44] = args[9];
+	*(int *)&image[ programStack + 40] = args[8];
+	*(int *)&image[ programStack + 36] = args[7];
+	*(int *)&image[ programStack + 32] = args[6];
+	*(int *)&image[ programStack + 28] = args[5];
+	*(int *)&image[ programStack + 24] = args[4];
+	*(int *)&image[ programStack + 20] = args[3];
+	*(int *)&image[ programStack + 16] = args[2];
+	*(int *)&image[ programStack + 12] = args[1];
+	*(int *)&image[ programStack + 8 ] = args[0];
+	*(int *)&image[ programStack + 4 ] = 0;	// return stack
+	*(int *)&image[ programStack ] = -1;	// will terminate the loop on return
+
+	// off we go into generated code...
+	// the PPC calling standard says the parms will all go into R3 - R11, so 
+	// no special asm code is needed here
+#ifdef __GNUC__
+	((void(*)(int, int, int, int, int, int, int, int))(vm->codeBase))( 
+		programStack, (int)&stack, 
+		(int)image, vm->dataMask, (int)&AsmCall, 
+		(int)vm->instructionPointers, vm->instructionPointersLength,
+        (int)vm );
+#else
+	((void(*)(int, int, int, int, int, int, int, int))(vm->codeBase))( 
+		programStack, (int)&stack, 
+		(int)image, vm->dataMask, *(int *)&AsmCall /* skip function pointer header */, 
+		(int)vm->instructionPointers, vm->instructionPointersLength,
+        (int)vm );
+#endif
+	vm->programStack = stackOnEntry;
+
+    vm->currentlyInterpreting = qfalse;
+
+	return stack[1];
+}
+
+
+/*
+==================
+AsmCall
+
+Put this at end of file because gcc messes up debug line numbers 
+==================
+*/
+#ifdef __GNUC__
+
+void AsmCall( void ) {
+asm ("
+    // pop off the destination instruction
+    lwz		r12,0(r4)	// RG_TOP, 0(RG_OPSTACK)
+    addi	r4,r4,-4	// RG_OPSTACK, RG_OPSTACK, -4
+
+    // see if it is a system trap
+    cmpwi	r12,0		// RG_TOP, 0
+    bc		12,0, systemTrap
+
+    // calling another VM function, so lookup in instructionPointers
+    slwi	r12,r12,2		// RG_TOP,RG_TOP,2
+                        // FIXME: range check
+    lwzx	r12, r8, r12	// RG_TOP, RG_INSTRUCTIONS(RG_TOP)	
+    mtctr	r12			// RG_TOP
+");
+
+
+#if defined(MACOS_X) && defined(__OPTIMIZE__)
+    // On Mac OS X, gcc doesn't push a frame when we are optimized, so trying to tear it down results in grave disorder.
+#warning Mac OS X optimization on, not popping GCC AsmCall frame
+#else
+    // Mac OS X Server and unoptimized compiles include a GCC AsmCall frame
+    asm ("
+	lwz		r1,0(r1)		// pop off the GCC AsmCall frame
+	lmw		r30,-8(r1)
+");
+#endif
+
+asm ("
+    bcctr	20,0		// when it hits a leave, it will branch to the current link register
+
+    // calling a system trap
+systemTrap:
+	// convert to positive system call number
+	subfic	r12,r12,-1
+
+    // save all our registers, including the current link register
+    mflr	r13			// RG_SECOND		// copy off our link register
+	addi	r1,r1,-92	// required 24 byets of linkage, 32 bytes of parameter, plus our saves
+    stw		r3,56(r1)	// RG_STACK, -36(REAL_STACK)
+    stw		r4,60(r1)	// RG_OPSTACK, 4(RG_REAL_STACK)
+    stw		r5,64(r1)	// RG_MEMBASE, 8(RG_REAL_STACK)
+    stw		r6,68(r1)	// RG_MEMMASK, 12(RG_REAL_STACK)
+    stw		r7,72(r1)	// RG_ASMCALL, 16(RG_REAL_STACK)
+    stw		r8,76(r1)	// RG_INSTRUCTIONS, 20(RG_REAL_STACK)
+    stw		r9,80(r1)	// RG_NUM_INSTRUCTIONS, 24(RG_REAL_STACK)
+    stw		r10,84(r1)	// RG_VM, 28(RG_REAL_STACK)
+    stw		r13,88(r1)	// RG_SECOND, 32(RG_REAL_STACK)	// link register
+
+    // save the vm stack position to allow recursive VM entry
+    addi	r13,r3,-4	// RG_TOP, RG_STACK, -4
+    stw		r13,0(r10)	//RG_TOP, VM_OFFSET_PROGRAM_STACK(RG_VM)
+
+    // save the system call number as the 0th parameter
+    add		r3,r3,r5	// r3,  RG_STACK, RG_MEMBASE		// r3 is the first parameter to vm->systemCalls
+    stwu	r12,4(r3)	// RG_TOP, 4(r3)
+
+    // make the system call with the address of all the VM parms as a parameter
+    // vm->systemCalls( &parms )
+    lwz		r12,4(r10)	// RG_TOP, VM_OFFSET_SYSTEM_CALL(RG_VM)
+    mtctr	r12			// RG_TOP
+    bcctrl	20,0
+    mr		r12,r3		// RG_TOP, r3
+
+    // pop our saved registers
+   	lwz		r3,56(r1)	// RG_STACK, 0(RG_REAL_STACK)
+   	lwz		r4,60(r1)	// RG_OPSTACK, 4(RG_REAL_STACK)
+   	lwz		r5,64(r1)	// RG_MEMBASE, 8(RG_REAL_STACK)
+   	lwz		r6,68(r1)	// RG_MEMMASK, 12(RG_REAL_STACK)
+   	lwz		r7,72(r1)	// RG_ASMCALL, 16(RG_REAL_STACK)
+   	lwz		r8,76(r1)	// RG_INSTRUCTIONS, 20(RG_REAL_STACK)
+   	lwz		r9,80(r1)	// RG_NUM_INSTRUCTIONS, 24(RG_REAL_STACK)
+   	lwz		r10,84(r1)	// RG_VM, 28(RG_REAL_STACK)
+   	lwz		r13,88(r1)	// RG_SECOND, 32(RG_REAL_STACK)
+    addi	r1,r1,92	// RG_REAL_STACK, RG_REAL_STACK, 36
+
+    // restore the old link register
+    mtlr	r13			// RG_SECOND
+
+    // save off the return value
+    stwu	r12,4(r4)	// RG_TOP, 0(RG_OPSTACK)
+
+	// GCC adds its own prolog / epliog code
+" );
+}
+
+#endif
diff --git a/codemp/qcommon/vm_x86.cpp b/codemp/qcommon/vm_x86.cpp
new file mode 100644
index 0000000..ca88d40
--- /dev/null
+++ b/codemp/qcommon/vm_x86.cpp
@@ -0,0 +1,1166 @@
+// vm_x86.c -- load time compiler and execution environment for x86
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+#include "vm_local.h"
+
+#ifdef __FreeBSD__ // rb0101023
+#include <sys/types.h>
+#endif
+
+#ifndef _WIN32
+#include <sys/mman.h> // for PROT_ stuff
+#endif
+
+/*
+
+  eax	scratch
+  ebx	scratch
+  ecx	scratch (required for shifts)
+  edx	scratch (required for divisions)
+  esi	program stack
+  edi	opstack
+
+*/
+
+// TTimo: initialised the statics, this fixes a crash when entering a compiled VM 
+static	byte	*buf = NULL;
+static	byte	*jused = NULL;
+static	int		compiledOfs = 0;
+static	byte	*code = NULL;
+static	int		pc = 0;
+
+static	int		*instructionPointers = NULL;
+
+//#undef FTOL_PTR  // bk001213
+#define FTOL_PTR
+
+#ifdef _WIN32
+
+#if defined( FTOL_PTR )
+extern "C" int _ftol(float);
+static	int		ftolPtr = (int)_ftol;
+#endif
+
+void AsmCall( void );
+static	int		asmCallPtr = (int)AsmCall;
+
+#else // _WIN32
+
+#if defined( FTOL_PTR )
+// bk001213 - BEWARE: does not work! UI menu etc. broken - stack!
+// bk001119 - added: int gftol( float x ) { return (int)x; }
+
+extern "C" {
+int qftol( void );     // bk001213 - label, see unix/ftol.nasm
+int qftol027F( void ); // bk001215 - fixed FPU control variants
+int qftol037F( void );
+int qftol0E7F( void ); // bk010102 - fixed bogus bits (duh)
+int qftol0F7F( void );
+}
+
+static	int		ftolPtr = (int)qftol0F7F;
+#endif // FTOL_PTR
+
+extern "C" void doAsmCall( void );
+static	int		asmCallPtr = (int)doAsmCall;
+#endif // !_WIN32
+
+
+static	int		callMask = 0; // bk001213 - init
+
+static	int		instruction, pass, lastConst;
+static	int		oc0, oc1, pop0, pop1;
+
+typedef enum 
+{
+	LAST_COMMAND_NONE	= 0,
+	LAST_COMMAND_MOV_EDI_EAX,
+	LAST_COMMAND_SUB_DI_4,
+	LAST_COMMAND_SUB_DI_8,
+} ELastCommand;
+
+static	ELastCommand	LastCommand;
+
+ /*
+=================
+AsmCall
+=================
+*/
+#ifdef _WIN32
+__declspec( naked ) void AsmCall( void ) {
+int		programStack;
+int		*opStack;
+int		syscallNum;
+vm_t*	savedVM;
+
+__asm {
+	mov		eax, dword ptr [edi]
+	sub		edi, 4
+	or		eax,eax
+	jl		systemCall
+	// calling another vm function
+	shl		eax,2
+	add		eax, dword ptr [instructionPointers]
+	call	dword ptr [eax]
+	mov		eax, dword ptr [edi]
+	and		eax, [callMask]
+	ret
+systemCall:
+
+	// convert negative num to system call number
+	// and store right before the first arg
+	neg		eax
+	dec		eax
+
+	push    ebp
+	mov     ebp, esp
+	sub     esp, __LOCAL_SIZE
+
+	mov		dword ptr syscallNum, eax	// so C code can get at it
+	mov		dword ptr programStack, esi	// so C code can get at it
+	mov		dword ptr opStack, edi
+
+	push	ecx
+	push	esi							// we may call recursively, so the
+	push	edi							// statics aren't guaranteed to be around
+}
+
+	savedVM = currentVM;
+
+	// save the stack to allow recursive VM entry
+	currentVM->programStack = programStack - 4;
+	*(int *)((byte *)currentVM->dataBase + programStack + 4) = syscallNum;
+//VM_LogSyscalls(  (int *)((byte *)currentVM->dataBase + programStack + 4) );
+	*(opStack+1) = currentVM->systemCall( (int *)((byte *)currentVM->dataBase + programStack + 4) );
+
+	currentVM = savedVM;
+
+_asm {
+	pop		edi
+	pop		esi
+	pop		ecx
+	add		edi, 4		// we added the return value
+
+	mov     esp, ebp
+	pop     ebp
+
+	ret
+}
+
+}
+
+#else //!_WIN32
+
+static	int		callProgramStack;
+static	int		*callOpStack;
+static	int		callSyscallNum;
+
+extern "C" void callAsmCall(void) {
+	// save the stack to allow recursive VM entry
+	currentVM->programStack = callProgramStack - 4;
+	*(int *)((byte *)currentVM->dataBase + callProgramStack + 4) = callSyscallNum;
+//VM_LogSyscalls(  (int *)((byte *)currentVM->dataBase + programStack + 4) );
+	*(callOpStack+1) = currentVM->systemCall( (int *)((byte *)currentVM->dataBase + callProgramStack + 4) );
+}
+
+void AsmCall( void ) {
+	__asm__("doAsmCall:      			\n\t" \
+			"	movl (%%edi),%%eax			\n\t" \
+			"	subl $4,%%edi				\n\t" \
+			"   orl %%eax,%%eax				\n\t" \
+			"	jl systemCall				\n\t" \
+			"	shll $2,%%eax				\n\t" \
+			"	addl %3,%%eax				\n\t" \
+			"	call *(%%eax)				\n\t" \
+		  " movl (%%edi),%%eax   \n\t" \
+	    " andl callMask, %%eax \n\t" \
+			"	jmp doret					   \n\t" \
+			"systemCall:					\n\t" \
+			"	negl %%eax					\n\t" \
+			"	decl %%eax					\n\t" \
+			"	movl %%eax,%0				\n\t" \
+			"	movl %%esi,%1				\n\t" \
+			"	movl %%edi,%2				\n\t" \
+			"	pushl %%ecx					\n\t" \
+			"	pushl %%esi					\n\t" \
+			"	pushl %%edi					\n\t" \
+			"	call callAsmCall			\n\t" \
+			"	popl %%edi					\n\t" \
+			"	popl %%esi					\n\t" \
+			"	popl %%ecx					\n\t" \
+			"	addl $4,%%edi				\n\t" \
+			"doret:							\n\t" \
+			"	ret							\n\t" \
+			: "=rm" (callSyscallNum), "=rm" (callProgramStack), "=rm" (callOpStack) \
+			: "rm" (instructionPointers) \
+			: "ax", "di", "si", "cx" \
+	);
+}
+#endif
+
+static int	Constant4( void ) {
+	int		v;
+
+	v = code[pc] | (code[pc+1]<<8) | (code[pc+2]<<16) | (code[pc+3]<<24);
+	pc += 4;
+	return v;
+}
+
+static int	Constant1( void ) {
+	int		v;
+
+	v = code[pc];
+	pc += 1;
+	return v;
+}
+
+static void Emit1( int v ) 
+{
+	buf[ compiledOfs ] = v;
+	compiledOfs++;
+
+	LastCommand = LAST_COMMAND_NONE;
+}
+
+#if 0
+static void Emit2( int v ) {
+	Emit1( v & 255 );
+	Emit1( ( v >> 8 ) & 255 );
+}
+#endif
+
+static void Emit4( int v ) {
+	Emit1( v & 255 );
+	Emit1( ( v >> 8 ) & 255 );
+	Emit1( ( v >> 16 ) & 255 );
+	Emit1( ( v >> 24 ) & 255 );
+}
+
+static int Hex( int c ) {
+	if ( c >= 'a' && c <= 'f' ) {
+		return 10 + c - 'a';
+	}
+	if ( c >= 'A' && c <= 'F' ) {
+		return 10 + c - 'A';
+	}
+	if ( c >= '0' && c <= '9' ) {
+		return c - '0';
+	}
+
+	Com_Error( ERR_DROP, "Hex: bad char '%c'", c );
+
+	return 0;
+}
+static void EmitString( const char *string ) {
+	int		c1, c2;
+	int		v;
+
+	while ( 1 ) {
+		c1 = string[0];
+		c2 = string[1];
+
+		v = ( Hex( c1 ) << 4 ) | Hex( c2 );
+		Emit1( v );
+
+		if ( !string[2] ) {
+			break;
+		}
+		string += 3;
+	}
+}
+
+
+
+static void EmitCommand(ELastCommand command)
+{
+	switch(command)
+	{
+		case LAST_COMMAND_MOV_EDI_EAX:
+			EmitString( "89 07" );		// mov dword ptr [edi], eax
+			break;
+
+		case LAST_COMMAND_SUB_DI_4:
+			EmitString( "83 EF 04" );	// sub edi, 4
+			break;
+
+		case LAST_COMMAND_SUB_DI_8:
+			EmitString( "83 EF 08" );	// sub edi, 8
+			break;
+	}
+	LastCommand = command;
+}
+
+static void EmitAddEDI4(vm_t *vm) {
+	if (LastCommand == LAST_COMMAND_SUB_DI_4 && jused[instruction-1] == 0) 
+	{		// sub di,4
+		compiledOfs -= 3;
+		vm->instructionPointers[ instruction-1 ] = compiledOfs;
+		return;
+	}
+	if (LastCommand == LAST_COMMAND_SUB_DI_8 && jused[instruction-1] == 0) 
+	{		// sub di,8
+		compiledOfs -= 3;
+		vm->instructionPointers[ instruction-1 ] = compiledOfs;
+		EmitString( "83 EF 04" );	//	sub edi,4
+		return;
+	}
+	EmitString( "83 C7 04" );	//	add edi,4
+}
+
+static void EmitMovEAXEDI(vm_t *vm) {
+	if (LastCommand == LAST_COMMAND_MOV_EDI_EAX) 
+	{	// mov [edi], eax
+		compiledOfs -= 2;
+		vm->instructionPointers[ instruction-1 ] = compiledOfs;
+		return;
+	}
+	if (pop1 == OP_DIVI || pop1 == OP_DIVU || pop1 == OP_MULI || pop1 == OP_MULU ||
+		pop1 == OP_STORE4 || pop1 == OP_STORE2 || pop1 == OP_STORE1 ) 
+	{	
+		return;
+	}
+	if (pop1 == OP_CONST && buf[compiledOfs-6] == 0xC7 && buf[compiledOfs-5] == 0x07 ) 
+	{	// mov edi, 0x123456
+		compiledOfs -= 6;
+		vm->instructionPointers[ instruction-1 ] = compiledOfs;
+		EmitString( "B8" );			// mov	eax, 0x12345678
+		Emit4( lastConst );
+		return;
+	}
+	EmitString( "8B 07" );		// mov eax, dword ptr [edi]
+}
+
+qboolean EmitMovEBXEDI(vm_t *vm, int andit) {
+	if (LastCommand == LAST_COMMAND_MOV_EDI_EAX) 
+	{	// mov [edi], eax
+		compiledOfs -= 2;
+		vm->instructionPointers[ instruction-1 ] = compiledOfs;
+		EmitString( "8B D8");		// mov bx, eax
+		return qfalse;
+	}
+	if (pop1 == OP_DIVI || pop1 == OP_DIVU || pop1 == OP_MULI || pop1 == OP_MULU ||
+		pop1 == OP_STORE4 || pop1 == OP_STORE2 || pop1 == OP_STORE1 ) 
+	{	
+		EmitString( "8B D8");		// mov bx, eax
+		return qfalse;
+	}
+	if (pop1 == OP_CONST && buf[compiledOfs-6] == 0xC7 && buf[compiledOfs-5] == 0x07 ) 
+	{		// mov edi, 0x123456
+		compiledOfs -= 6;
+		vm->instructionPointers[ instruction-1 ] = compiledOfs;
+		EmitString( "BB" );			// mov	ebx, 0x12345678
+		if (andit) {
+			Emit4( lastConst & andit );
+		} else {
+			Emit4( lastConst );
+		}
+		return qtrue;
+	}
+
+	EmitString( "8B 1F" );		// mov ebx, dword ptr [edi]
+	return qfalse;
+}
+
+/*
+=================
+VM_Compile
+=================
+*/
+void VM_Compile( vm_t *vm, vmHeader_t *header ) {
+	int		op;
+	int		maxLength;
+	int		v;
+	int		i;
+	qboolean opt;
+
+	// allocate a very large temp buffer, we will shrink it later
+	maxLength = header->codeLength * 8;
+	buf = (unsigned char *)Z_Malloc( maxLength, TAG_VM, qtrue  );
+	jused = (unsigned char *)Z_Malloc(header->instructionCount + 2, TAG_VM, qtrue  );
+	
+	Com_Memset(jused, 0, header->instructionCount+2);
+
+	for(pass=0;pass<2;pass++) {
+	oc0 = -23423;
+	oc1 = -234354;
+	pop0 = -43435;
+	pop1 = -545455;
+
+	// translate all instructions
+	pc = 0;
+	instruction = 0;
+	code = (byte *)header + header->codeOffset;
+	compiledOfs = 0;
+
+	LastCommand = LAST_COMMAND_NONE;
+
+	while ( instruction < header->instructionCount ) {
+		if ( compiledOfs > maxLength - 16 ) {
+			Com_Error( ERR_FATAL, "VM_CompileX86: maxLength exceeded" );
+		}
+
+		vm->instructionPointers[ instruction ] = compiledOfs;
+		instruction++;
+
+		if ( pc > header->codeLength ) {
+			Com_Error( ERR_FATAL, "VM_CompileX86: pc > header->codeLength" );
+		}
+
+		op = code[ pc ];
+		pc++;
+		switch ( op ) {
+		case 0:
+			break;
+		case OP_BREAK:
+			EmitString( "CC" );			// int 3
+			break;
+		case OP_ENTER:
+			EmitString( "81 EE" );		// sub	esi, 0x12345678
+			Emit4( Constant4() );
+			break;
+		case OP_CONST:
+			if (code[pc+4] == OP_LOAD4) {
+				EmitAddEDI4(vm);
+				EmitString( "BB" );		// mov	ebx, 0x12345678
+				Emit4( (Constant4()&vm->dataMask) + (int)vm->dataBase);
+				EmitString( "8B 03" );		// mov	eax, dword ptr [ebx]
+				EmitCommand(LAST_COMMAND_MOV_EDI_EAX);		// mov dword ptr [edi], eax
+				pc++;						// OP_LOAD4
+				instruction += 1;
+				break;
+			}
+			if (code[pc+4] == OP_LOAD2) {
+				EmitAddEDI4(vm);
+				EmitString( "BB" );		// mov	ebx, 0x12345678
+				Emit4( (Constant4()&vm->dataMask) + (int)vm->dataBase);
+				EmitString( "0F B7 03" );	// movzx	eax, word ptr [ebx]
+				EmitCommand(LAST_COMMAND_MOV_EDI_EAX);		// mov dword ptr [edi], eax
+				pc++;						// OP_LOAD4
+				instruction += 1;
+				break;
+			}
+			if (code[pc+4] == OP_LOAD1) {
+				EmitAddEDI4(vm);
+				EmitString( "BB" );		// mov	ebx, 0x12345678
+				Emit4( (Constant4()&vm->dataMask) + (int)vm->dataBase);
+				EmitString( "0F B6 03" );	// movzx	eax, byte ptr [ebx]
+				EmitCommand(LAST_COMMAND_MOV_EDI_EAX);		// mov dword ptr [edi], eax
+				pc++;						// OP_LOAD4
+				instruction += 1;
+				break;
+			}
+			if (code[pc+4] == OP_STORE4) {
+				opt = EmitMovEBXEDI(vm, (vm->dataMask & ~3));
+				EmitString( "B8" );			// mov	eax, 0x12345678
+				Emit4( Constant4() );
+//				if (!opt) {
+//					EmitString( "81 E3" );		// and ebx, 0x12345678
+//					Emit4( vm->dataMask & ~3 );
+//				}
+				EmitString( "89 83" );		// mov dword ptr [ebx+0x12345678], eax
+				Emit4( (int)vm->dataBase );
+				EmitCommand(LAST_COMMAND_SUB_DI_4);		// sub edi, 4
+				pc++;						// OP_STORE4
+				instruction += 1;
+				break;
+			}
+			if (code[pc+4] == OP_STORE2) {
+				opt = EmitMovEBXEDI(vm, (vm->dataMask & ~1));
+				EmitString( "B8" );			// mov	eax, 0x12345678
+				Emit4( Constant4() );
+//				if (!opt) {
+//					EmitString( "81 E3" );		// and ebx, 0x12345678
+//					Emit4( vm->dataMask & ~1 );
+//				}
+				EmitString( "66 89 83" );	// mov word ptr [ebx+0x12345678], eax
+				Emit4( (int)vm->dataBase );
+				EmitCommand(LAST_COMMAND_SUB_DI_4);		// sub edi, 4
+				pc++;						// OP_STORE4
+				instruction += 1;
+				break;
+			}
+			if (code[pc+4] == OP_STORE1) {
+				opt = EmitMovEBXEDI(vm, vm->dataMask);
+				EmitString( "B8" );			// mov	eax, 0x12345678
+				Emit4( Constant4() );
+//				if (!opt) {
+//					EmitString( "81 E3" );	// and ebx, 0x12345678
+//					Emit4( vm->dataMask );
+//				}
+				EmitString( "88 83" );		// mov byte ptr [ebx+0x12345678], eax
+				Emit4( (int)vm->dataBase );
+				EmitCommand(LAST_COMMAND_SUB_DI_4);		// sub edi, 4
+				pc++;						// OP_STORE4
+				instruction += 1;
+				break;
+			}
+			if (code[pc+4] == OP_ADD) {
+				EmitString( "81 07" );		// add dword ptr [edi], 0x1234567
+				Emit4( Constant4() );
+				pc++;						// OP_ADD
+				instruction += 1;
+				break;
+			}
+			if (code[pc+4] == OP_SUB) {
+				EmitString( "81 2F" );		// sub dword ptr [edi], 0x1234567
+				Emit4( Constant4() );
+				pc++;						// OP_ADD
+				instruction += 1;
+				break;
+			}
+			EmitAddEDI4(vm);
+			EmitString( "C7 07" );		// mov	dword ptr [edi], 0x12345678
+			lastConst = Constant4();
+			Emit4( lastConst );
+			if (code[pc] == OP_JUMP) {
+				jused[lastConst] = 1;
+			}
+			break;
+		case OP_LOCAL:
+			EmitAddEDI4(vm);
+			EmitString( "8D 86" );		// lea eax, [0x12345678 + esi]
+			oc0 = oc1;
+			oc1 = Constant4();
+			Emit4( oc1 );
+			EmitCommand(LAST_COMMAND_MOV_EDI_EAX);		// mov dword ptr [edi], eax
+			break;
+		case OP_ARG:
+			EmitMovEAXEDI(vm);			// mov	eax,dword ptr [edi]
+			EmitString( "89 86" );		// mov	dword ptr [esi+database],eax
+			// FIXME: range check
+			Emit4( Constant1() + (int)vm->dataBase );
+			EmitCommand(LAST_COMMAND_SUB_DI_4);		// sub edi, 4
+			break;
+		case OP_CALL:
+			EmitString( "C7 86" );		// mov dword ptr [esi+database],0x12345678
+			Emit4( (int)vm->dataBase );
+			Emit4( pc );
+			EmitString( "FF 15" );		// call asmCallPtr
+			Emit4( (int)&asmCallPtr );
+			break;
+		case OP_PUSH:
+			EmitAddEDI4(vm);
+			break;
+		case OP_POP:
+			EmitCommand(LAST_COMMAND_SUB_DI_4);		// sub edi, 4
+			break;
+		case OP_LEAVE:
+			v = Constant4();
+			EmitString( "81 C6" );		// add	esi, 0x12345678
+			Emit4( v );
+			EmitString( "C3" );			// ret
+			break;
+		case OP_LOAD4:
+			if (code[pc] == OP_CONST && code[pc+5] == OP_ADD && code[pc+6] == OP_STORE4) {
+				if (oc0 == oc1 && pop0 == OP_LOCAL && pop1 == OP_LOCAL) {
+					compiledOfs -= 11;
+					vm->instructionPointers[ instruction-1 ] = compiledOfs;
+				}
+				pc++;						// OP_CONST
+				v = Constant4();
+				EmitMovEBXEDI(vm, vm->dataMask);
+				if (v == 1 && oc0 == oc1 && pop0 == OP_LOCAL && pop1 == OP_LOCAL) {
+					EmitString( "FF 83");		// inc dword ptr [ebx + 0x12345678]
+					Emit4( (int)vm->dataBase );
+				} else {
+					EmitString( "8B 83" );		// mov	eax, dword ptr [ebx + 0x12345678]
+					Emit4( (int)vm->dataBase );
+					EmitString( "05"  );		// add eax, const
+					Emit4( v );
+					if (oc0 == oc1 && pop0 == OP_LOCAL && pop1 == OP_LOCAL) {
+						EmitString( "89 83" );		// mov dword ptr [ebx+0x12345678], eax
+						Emit4( (int)vm->dataBase );
+					} else {
+						EmitCommand(LAST_COMMAND_SUB_DI_4);		// sub edi, 4
+						EmitString( "8B 1F" );		// mov	ebx, dword ptr [edi]
+						EmitString( "89 83" );		// mov dword ptr [ebx+0x12345678], eax
+						Emit4( (int)vm->dataBase );
+					}
+				}
+				EmitCommand(LAST_COMMAND_SUB_DI_4);		// sub edi, 4
+				pc++;						// OP_ADD
+				pc++;						// OP_STORE
+				instruction += 3;
+				break;
+			}
+
+			if (code[pc] == OP_CONST && code[pc+5] == OP_SUB && code[pc+6] == OP_STORE4) {
+				if (oc0 == oc1 && pop0 == OP_LOCAL && pop1 == OP_LOCAL) {
+					compiledOfs -= 11;
+					vm->instructionPointers[ instruction-1 ] = compiledOfs;
+				}
+				EmitMovEBXEDI(vm, vm->dataMask);
+				EmitString( "8B 83" );		// mov	eax, dword ptr [ebx + 0x12345678]
+				Emit4( (int)vm->dataBase );
+				pc++;						// OP_CONST
+				v = Constant4();
+				if (v == 1 && oc0 == oc1 && pop0 == OP_LOCAL && pop1 == OP_LOCAL) {
+					EmitString( "FF 8B");		// dec dword ptr [ebx + 0x12345678]
+					Emit4( (int)vm->dataBase );
+				} else {
+					EmitString( "2D"  );		// sub eax, const
+					Emit4( v );
+					if (oc0 == oc1 && pop0 == OP_LOCAL && pop1 == OP_LOCAL) {
+						EmitString( "89 83" );		// mov dword ptr [ebx+0x12345678], eax
+						Emit4( (int)vm->dataBase );
+					} else {
+						EmitCommand(LAST_COMMAND_SUB_DI_4);		// sub edi, 4
+						EmitString( "8B 1F" );		// mov	ebx, dword ptr [edi]
+						EmitString( "89 83" );		// mov dword ptr [ebx+0x12345678], eax
+						Emit4( (int)vm->dataBase );
+					}
+				}
+				EmitCommand(LAST_COMMAND_SUB_DI_4);		// sub edi, 4
+				pc++;						// OP_SUB
+				pc++;						// OP_STORE
+				instruction += 3;
+				break;
+			}
+
+			if (buf[compiledOfs-2] == 0x89 && buf[compiledOfs-1] == 0x07) {
+				compiledOfs -= 2;
+				vm->instructionPointers[ instruction-1 ] = compiledOfs;
+				EmitString( "8B 80");	// mov eax, dword ptr [eax + 0x1234567]
+				Emit4( (int)vm->dataBase );
+				EmitCommand(LAST_COMMAND_MOV_EDI_EAX);		// mov dword ptr [edi], eax
+				break;
+			}
+			EmitMovEBXEDI(vm, vm->dataMask);
+			EmitString( "8B 83" );		// mov	eax, dword ptr [ebx + 0x12345678]
+			Emit4( (int)vm->dataBase );
+			EmitCommand(LAST_COMMAND_MOV_EDI_EAX);		// mov dword ptr [edi], eax
+			break;
+		case OP_LOAD2:
+			EmitMovEBXEDI(vm, vm->dataMask);
+			EmitString( "0F B7 83" );	// movzx	eax, word ptr [ebx + 0x12345678]
+			Emit4( (int)vm->dataBase );
+			EmitCommand(LAST_COMMAND_MOV_EDI_EAX);		// mov dword ptr [edi], eax
+			break;
+		case OP_LOAD1:
+			EmitMovEBXEDI(vm, vm->dataMask);
+			EmitString( "0F B6 83" );	// movzx eax, byte ptr [ebx + 0x12345678]
+			Emit4( (int)vm->dataBase );
+			EmitCommand(LAST_COMMAND_MOV_EDI_EAX);		// mov dword ptr [edi], eax
+			break;
+		case OP_STORE4:
+			EmitMovEAXEDI(vm);	
+			EmitString( "8B 5F FC" );	// mov	ebx, dword ptr [edi-4]
+//			if (pop1 != OP_CALL) {
+//				EmitString( "81 E3" );		// and ebx, 0x12345678
+//				Emit4( vm->dataMask & ~3 );
+//			}
+			EmitString( "89 83" );		// mov dword ptr [ebx+0x12345678], eax
+			Emit4( (int)vm->dataBase );
+			EmitCommand(LAST_COMMAND_SUB_DI_8);		// sub edi, 8
+			break;
+		case OP_STORE2:
+			EmitMovEAXEDI(vm);	
+			EmitString( "8B 5F FC" );	// mov	ebx, dword ptr [edi-4]
+//			EmitString( "81 E3" );		// and ebx, 0x12345678
+//			Emit4( vm->dataMask & ~1 );
+			EmitString( "66 89 83" );	// mov word ptr [ebx+0x12345678], eax
+			Emit4( (int)vm->dataBase );
+			EmitCommand(LAST_COMMAND_SUB_DI_8);		// sub edi, 8
+			break;
+		case OP_STORE1:
+			EmitMovEAXEDI(vm);	
+			EmitString( "8B 5F FC" );	// mov	ebx, dword ptr [edi-4]
+//			EmitString( "81 E3" );		// and ebx, 0x12345678
+//			Emit4( vm->dataMask );
+			EmitString( "88 83" );		// mov byte ptr [ebx+0x12345678], eax
+			Emit4( (int)vm->dataBase );
+			EmitCommand(LAST_COMMAND_SUB_DI_8);		// sub edi, 8
+			break;
+
+		case OP_EQ:
+			EmitCommand(LAST_COMMAND_SUB_DI_8);		// sub edi, 8
+			EmitString( "8B 47 04" );	// mov	eax, dword ptr [edi+4]
+			EmitString( "3B 47 08" );	// cmp	eax, dword ptr [edi+8]
+			EmitString( "75 06" );		// jne +6
+			EmitString( "FF 25" );		// jmp	[0x12345678]
+			v = Constant4();
+			jused[v] = 1;
+			Emit4( (int)vm->instructionPointers + v*4 );
+			break;
+		case OP_NE:
+			EmitCommand(LAST_COMMAND_SUB_DI_8);		// sub edi, 8
+			EmitString( "8B 47 04" );	// mov	eax, dword ptr [edi+4]
+			EmitString( "3B 47 08" );	// cmp	eax, dword ptr [edi+8]
+			EmitString( "74 06" );		// je +6
+			EmitString( "FF 25" );		// jmp	[0x12345678]
+			v = Constant4();
+			jused[v] = 1;
+			Emit4( (int)vm->instructionPointers + v*4 );
+			break;
+		case OP_LTI:
+			EmitCommand(LAST_COMMAND_SUB_DI_8);		// sub edi, 8
+			EmitString( "8B 47 04" );	// mov	eax, dword ptr [edi+4]
+			EmitString( "3B 47 08" );	// cmp	eax, dword ptr [edi+8]
+			EmitString( "7D 06" );		// jnl +6
+			EmitString( "FF 25" );		// jmp	[0x12345678]
+			v = Constant4();
+			jused[v] = 1;
+			Emit4( (int)vm->instructionPointers + v*4 );
+			break;
+		case OP_LEI:
+			EmitCommand(LAST_COMMAND_SUB_DI_8);		// sub edi, 8
+			EmitString( "8B 47 04" );	// mov	eax, dword ptr [edi+4]
+			EmitString( "3B 47 08" );	// cmp	eax, dword ptr [edi+8]
+			EmitString( "7F 06" );		// jnle +6
+			EmitString( "FF 25" );		// jmp	[0x12345678]
+			v = Constant4();
+			jused[v] = 1;
+			Emit4( (int)vm->instructionPointers + v*4 );
+			break;
+		case OP_GTI:
+			EmitCommand(LAST_COMMAND_SUB_DI_8);		// sub edi, 8
+			EmitString( "8B 47 04" );	// mov	eax, dword ptr [edi+4]
+			EmitString( "3B 47 08" );	// cmp	eax, dword ptr [edi+8]
+			EmitString( "7E 06" );		// jng +6
+			EmitString( "FF 25" );		// jmp	[0x12345678]
+			v = Constant4();
+			jused[v] = 1;
+			Emit4( (int)vm->instructionPointers + v*4 );
+			break;
+		case OP_GEI:
+			EmitCommand(LAST_COMMAND_SUB_DI_8);		// sub edi, 8
+			EmitString( "8B 47 04" );	// mov	eax, dword ptr [edi+4]
+			EmitString( "3B 47 08" );	// cmp	eax, dword ptr [edi+8]
+			EmitString( "7C 06" );		// jnge +6
+			EmitString( "FF 25" );		// jmp	[0x12345678]
+			v = Constant4();
+			jused[v] = 1;
+			Emit4( (int)vm->instructionPointers + v*4 );
+			break;
+		case OP_LTU:
+			EmitCommand(LAST_COMMAND_SUB_DI_8);		// sub edi, 8
+			EmitString( "8B 47 04" );	// mov	eax, dword ptr [edi+4]
+			EmitString( "3B 47 08" );	// cmp	eax, dword ptr [edi+8]
+			EmitString( "73 06" );		// jnb +6
+			EmitString( "FF 25" );		// jmp	[0x12345678]
+			v = Constant4();
+			jused[v] = 1;
+			Emit4( (int)vm->instructionPointers + v*4 );
+			break;
+		case OP_LEU:
+			EmitCommand(LAST_COMMAND_SUB_DI_8);		// sub edi, 8
+			EmitString( "8B 47 04" );	// mov	eax, dword ptr [edi+4]
+			EmitString( "3B 47 08" );	// cmp	eax, dword ptr [edi+8]
+			EmitString( "77 06" );		// jnbe +6
+			EmitString( "FF 25" );		// jmp	[0x12345678]
+			v = Constant4();
+			jused[v] = 1;
+			Emit4( (int)vm->instructionPointers + v*4 );
+			break;
+		case OP_GTU:
+			EmitCommand(LAST_COMMAND_SUB_DI_8);		// sub edi, 8
+			EmitString( "8B 47 04" );	// mov	eax, dword ptr [edi+4]
+			EmitString( "3B 47 08" );	// cmp	eax, dword ptr [edi+8]
+			EmitString( "76 06" );		// jna +6
+			EmitString( "FF 25" );		// jmp	[0x12345678]
+			v = Constant4();
+			jused[v] = 1;
+			Emit4( (int)vm->instructionPointers + v*4 );
+			break;
+		case OP_GEU:
+			EmitCommand(LAST_COMMAND_SUB_DI_8);		// sub edi, 8
+			EmitString( "8B 47 04" );	// mov	eax, dword ptr [edi+4]
+			EmitString( "3B 47 08" );	// cmp	eax, dword ptr [edi+8]
+			EmitString( "72 06" );		// jnae +6
+			EmitString( "FF 25" );		// jmp	[0x12345678]
+			v = Constant4();
+			jused[v] = 1;
+			Emit4( (int)vm->instructionPointers + v*4 );
+			break;
+		case OP_EQF:
+			EmitCommand(LAST_COMMAND_SUB_DI_8);		// sub edi, 8
+			EmitString( "D9 47 04" );	// fld dword ptr [edi+4]
+			EmitString( "D8 5F 08" );	// fcomp dword ptr [edi+8]
+			EmitString( "DF E0" );		// fnstsw ax
+			EmitString( "F6 C4 40" );	// test	ah,0x40
+			EmitString( "74 06" );		// je +6
+			EmitString( "FF 25" );		// jmp	[0x12345678]
+			v = Constant4();
+			jused[v] = 1;
+			Emit4( (int)vm->instructionPointers + v*4 );
+			break;			
+		case OP_NEF:
+			EmitCommand(LAST_COMMAND_SUB_DI_8);		// sub edi, 8
+			EmitString( "D9 47 04" );	// fld dword ptr [edi+4]
+			EmitString( "D8 5F 08" );	// fcomp dword ptr [edi+8]
+			EmitString( "DF E0" );		// fnstsw ax
+			EmitString( "F6 C4 40" );	// test	ah,0x40
+			EmitString( "75 06" );		// jne +6
+			EmitString( "FF 25" );		// jmp	[0x12345678]
+			v = Constant4();
+			jused[v] = 1;
+			Emit4( (int)vm->instructionPointers + v*4 );
+			break;			
+		case OP_LTF:
+			EmitCommand(LAST_COMMAND_SUB_DI_8);		// sub edi, 8
+			EmitString( "D9 47 04" );	// fld dword ptr [edi+4]
+			EmitString( "D8 5F 08" );	// fcomp dword ptr [edi+8]
+			EmitString( "DF E0" );		// fnstsw ax
+			EmitString( "F6 C4 01" );	// test	ah,0x01
+			EmitString( "74 06" );		// je +6
+			EmitString( "FF 25" );		// jmp	[0x12345678]
+			v = Constant4();
+			jused[v] = 1;
+			Emit4( (int)vm->instructionPointers + v*4 );
+			break;			
+		case OP_LEF:
+			EmitCommand(LAST_COMMAND_SUB_DI_8);		// sub edi, 8
+			EmitString( "D9 47 04" );	// fld dword ptr [edi+4]
+			EmitString( "D8 5F 08" );	// fcomp dword ptr [edi+8]
+			EmitString( "DF E0" );		// fnstsw ax
+			EmitString( "F6 C4 41" );	// test	ah,0x41
+			EmitString( "74 06" );		// je +6
+			EmitString( "FF 25" );		// jmp	[0x12345678]
+			v = Constant4();
+			jused[v] = 1;
+			Emit4( (int)vm->instructionPointers + v*4 );
+			break;			
+		case OP_GTF:
+			EmitCommand(LAST_COMMAND_SUB_DI_8);		// sub edi, 8
+			EmitString( "D9 47 04" );	// fld dword ptr [edi+4]
+			EmitString( "D8 5F 08" );	// fcomp dword ptr [edi+8]
+			EmitString( "DF E0" );		// fnstsw ax
+			EmitString( "F6 C4 41" );	// test	ah,0x41
+			EmitString( "75 06" );		// jne +6
+			EmitString( "FF 25" );		// jmp	[0x12345678]
+			v = Constant4();
+			jused[v] = 1;
+			Emit4( (int)vm->instructionPointers + v*4 );
+			break;			
+		case OP_GEF:
+			EmitCommand(LAST_COMMAND_SUB_DI_8);		// sub edi, 8
+			EmitString( "D9 47 04" );	// fld dword ptr [edi+4]
+			EmitString( "D8 5F 08" );	// fcomp dword ptr [edi+8]
+			EmitString( "DF E0" );		// fnstsw ax
+			EmitString( "F6 C4 01" );	// test	ah,0x01
+			EmitString( "75 06" );		// jne +6
+			EmitString( "FF 25" );		// jmp	[0x12345678]
+			v = Constant4();
+			jused[v] = 1;
+			Emit4( (int)vm->instructionPointers + v*4 );
+			break;			
+		case OP_NEGI:
+			EmitString( "F7 1F" );		// neg dword ptr [edi]
+			break;
+		case OP_ADD:
+			EmitMovEAXEDI(vm);			// mov eax, dword ptr [edi]
+			EmitString( "01 47 FC" );	// add dword ptr [edi-4],eax
+			EmitCommand(LAST_COMMAND_SUB_DI_4);		// sub edi, 4
+			break;
+		case OP_SUB:
+			EmitMovEAXEDI(vm);			// mov eax, dword ptr [edi]
+			EmitString( "29 47 FC" );	// sub dword ptr [edi-4],eax
+			EmitCommand(LAST_COMMAND_SUB_DI_4);		// sub edi, 4
+			break;
+		case OP_DIVI:
+			EmitString( "8B 47 FC" );	// mov eax,dword ptr [edi-4]
+			EmitString( "99" );			// cdq
+			EmitString( "F7 3F" );		// idiv dword ptr [edi]
+			EmitString( "89 47 FC" );	// mov dword ptr [edi-4],eax
+			EmitCommand(LAST_COMMAND_SUB_DI_4);		// sub edi, 4
+			break;
+		case OP_DIVU:
+			EmitString( "8B 47 FC" );	// mov eax,dword ptr [edi-4]
+			EmitString( "33 D2" );		// xor edx, edx
+			EmitString( "F7 37" );		// div dword ptr [edi]
+			EmitString( "89 47 FC" );	// mov dword ptr [edi-4],eax
+			EmitCommand(LAST_COMMAND_SUB_DI_4);		// sub edi, 4
+			break;
+		case OP_MODI:
+			EmitString( "8B 47 FC" );	// mov eax,dword ptr [edi-4]
+			EmitString( "99" );			// cdq
+			EmitString( "F7 3F" );		// idiv dword ptr [edi]
+			EmitString( "89 57 FC" );	// mov dword ptr [edi-4],edx
+			EmitCommand(LAST_COMMAND_SUB_DI_4);		// sub edi, 4
+			break;
+		case OP_MODU:
+			EmitString( "8B 47 FC" );	// mov eax,dword ptr [edi-4]
+			EmitString( "33 D2" );		// xor edx, edx
+			EmitString( "F7 37" );		// div dword ptr [edi]
+			EmitString( "89 57 FC" );	// mov dword ptr [edi-4],edx
+			EmitCommand(LAST_COMMAND_SUB_DI_4);		// sub edi, 4
+			break;
+		case OP_MULI:
+			EmitString( "8B 47 FC" );	// mov eax,dword ptr [edi-4]
+			EmitString( "F7 2F" );		// imul dword ptr [edi]
+			EmitString( "89 47 FC" );	// mov dword ptr [edi-4],eax
+			EmitCommand(LAST_COMMAND_SUB_DI_4);		// sub edi, 4
+			break;
+		case OP_MULU:
+			EmitString( "8B 47 FC" );	// mov eax,dword ptr [edi-4]
+			EmitString( "F7 27" );		// mul dword ptr [edi]
+			EmitString( "89 47 FC" );	// mov dword ptr [edi-4],eax
+			EmitCommand(LAST_COMMAND_SUB_DI_4);		// sub edi, 4
+			break;
+		case OP_BAND:
+			EmitMovEAXEDI(vm);			// mov eax, dword ptr [edi]
+			EmitString( "21 47 FC" );	// and dword ptr [edi-4],eax
+			EmitCommand(LAST_COMMAND_SUB_DI_4);		// sub edi, 4
+			break;
+		case OP_BOR:
+			EmitMovEAXEDI(vm);			// mov eax, dword ptr [edi]
+			EmitString( "09 47 FC" );	// or dword ptr [edi-4],eax
+			EmitCommand(LAST_COMMAND_SUB_DI_4);		// sub edi, 4
+			break;
+		case OP_BXOR:
+			EmitMovEAXEDI(vm);			// mov eax, dword ptr [edi]
+			EmitString( "31 47 FC" );	// xor dword ptr [edi-4],eax
+			EmitCommand(LAST_COMMAND_SUB_DI_4);		// sub edi, 4
+			break;
+		case OP_BCOM:
+			EmitString( "F7 17" );		// not dword ptr [edi]
+			break;
+		case OP_LSH:
+			EmitString( "8B 0F" );		// mov ecx, dword ptr [edi]
+			EmitString( "D3 67 FC" );	// shl dword ptr [edi-4], cl
+			EmitCommand(LAST_COMMAND_SUB_DI_4);		// sub edi, 4
+			break;
+		case OP_RSHI:
+			EmitString( "8B 0F" );		// mov ecx, dword ptr [edi]
+			EmitString( "D3 7F FC" );	// sar dword ptr [edi-4], cl
+			EmitCommand(LAST_COMMAND_SUB_DI_4);		// sub edi, 4
+			break;
+		case OP_RSHU:
+			EmitString( "8B 0F" );		// mov ecx, dword ptr [edi]
+			EmitString( "D3 6F FC" );	// shr dword ptr [edi-4], cl
+			EmitCommand(LAST_COMMAND_SUB_DI_4);		// sub edi, 4
+			break;
+		case OP_NEGF:
+			EmitString( "D9 07" );		// fld dword ptr [edi]
+			EmitString( "D9 E0" );		// fchs
+			EmitString( "D9 1F" );		// fstp dword ptr [edi]
+			break;
+		case OP_ADDF:
+			EmitString( "D9 47 FC" );	// fld dword ptr [edi-4]
+			EmitString( "D8 07" );		// fadd dword ptr [edi]
+			EmitString( "D9 5F FC" );	// fstp dword ptr [edi-4]
+			EmitCommand(LAST_COMMAND_SUB_DI_4);		// sub edi, 4
+			break;
+		case OP_SUBF:
+			EmitCommand(LAST_COMMAND_SUB_DI_4);		// sub edi, 4
+			EmitString( "D9 07" );		// fld dword ptr [edi]
+			EmitString( "D8 67 04" );	// fsub dword ptr [edi+4]
+			EmitString( "D9 1F" );		// fstp dword ptr [edi]
+			break;
+		case OP_DIVF:
+			EmitCommand(LAST_COMMAND_SUB_DI_4);		// sub edi, 4
+			EmitString( "D9 07" );		// fld dword ptr [edi]
+			EmitString( "D8 77 04" );	// fdiv dword ptr [edi+4]
+			EmitString( "D9 1F" );		// fstp dword ptr [edi]
+			break;
+		case OP_MULF:
+			EmitCommand(LAST_COMMAND_SUB_DI_4);		// sub edi, 4
+			EmitString( "D9 07" );		// fld dword ptr [edi]
+			EmitString( "D8 4f 04" );	// fmul dword ptr [edi+4]
+			EmitString( "D9 1F" );		// fstp dword ptr [edi]
+			break;
+		case OP_CVIF:
+			EmitString( "DB 07" );		// fild dword ptr [edi]
+			EmitString( "D9 1F" );		// fstp dword ptr [edi]
+			break;
+		case OP_CVFI:
+#ifndef FTOL_PTR // WHENHELLISFROZENOVER  // bk001213 - was used in 1.17
+			// not IEEE complient, but simple and fast
+		  EmitString( "D9 07" );		// fld dword ptr [edi]
+			EmitString( "DB 1F" );		// fistp dword ptr [edi]
+#else // FTOL_PTR
+			// call the library conversion function
+			EmitString( "D9 07" );		// fld dword ptr [edi]
+			EmitString( "FF 15" );		// call ftolPtr
+			Emit4( (int)&ftolPtr );
+			EmitCommand(LAST_COMMAND_MOV_EDI_EAX);		// mov dword ptr [edi], eax
+#endif
+			break;
+		case OP_SEX8:
+			EmitString( "0F BE 07" );	// movsx eax, byte ptr [edi]
+			EmitCommand(LAST_COMMAND_MOV_EDI_EAX);		// mov dword ptr [edi], eax
+			break;
+		case OP_SEX16:
+			EmitString( "0F BF 07" );	// movsx eax, word ptr [edi]
+			EmitCommand(LAST_COMMAND_MOV_EDI_EAX);		// mov dword ptr [edi], eax
+			break;
+
+		case OP_BLOCK_COPY:
+			// FIXME: range check
+			EmitString( "56" );			// push esi
+			EmitString( "57" );			// push edi
+			EmitString( "8B 37" );		// mov esi,[edi] 
+			EmitString( "8B 7F FC" );	// mov edi,[edi-4] 
+			EmitString( "B9" );			// mov ecx,0x12345678
+			Emit4( Constant4() >> 2 );
+			EmitString( "B8" );			// mov eax, datamask
+			Emit4( vm->dataMask );
+			EmitString( "BB" );			// mov ebx, database
+			Emit4( (int)vm->dataBase );
+			EmitString( "23 F0" );		// and esi, eax
+			EmitString( "03 F3" );		// add esi, ebx
+			EmitString( "23 F8" );		// and edi, eax
+			EmitString( "03 FB" );		// add edi, ebx
+			EmitString( "F3 A5" );		// rep movsd
+			EmitString( "5F" );			// pop edi
+			EmitString( "5E" );			// pop esi
+			EmitCommand(LAST_COMMAND_SUB_DI_8);		// sub edi, 8
+			break;
+
+		case OP_JUMP:
+			EmitCommand(LAST_COMMAND_SUB_DI_4);		// sub edi, 4
+			EmitString( "8B 47 04" );	// mov eax,dword ptr [edi+4]
+			// FIXME: range check
+			EmitString( "FF 24 85" );	// jmp dword ptr [instructionPointers + eax * 4]
+			Emit4( (int)vm->instructionPointers );
+			break;
+		default:
+			Com_Error( ERR_DROP, "VM_CompileX86: bad opcode %i at offset %i", op, pc );
+		}
+		pop0 = pop1;
+		pop1 = op;
+	}
+	}
+
+	// copy to an exact size buffer on the hunk
+	vm->codeLength = compiledOfs;
+	vm->codeBase = (unsigned char *)Hunk_Alloc( compiledOfs, h_low );
+	Com_Memcpy( vm->codeBase, buf, compiledOfs );
+	Z_Free( buf );
+	Z_Free( jused );
+	Com_Printf( "VM file %s compiled to %i bytes of code\n", vm->name, compiledOfs);
+
+	// offset all the instruction pointers for the new location
+	for ( i = 0 ; i < header->instructionCount ; i++ ) {
+		vm->instructionPointers[i] += (int)vm->codeBase;
+	}
+
+#if 0 // ndef _WIN32
+	// Must make the newly generated code executable
+	{
+		int r;
+		unsigned long addr;
+		int psize = getpagesize();
+
+		addr = ((int)vm->codeBase & ~(psize-1)) - psize;
+
+		r = mprotect((char*)addr, vm->codeLength + (int)vm->codeBase - addr + psize, 
+			PROT_READ | PROT_WRITE | PROT_EXEC );
+
+		if (r < 0)
+			Com_Error( ERR_FATAL, "mprotect failed to change PROT_EXEC" );
+	}
+#endif
+
+}
+
+/*
+==============
+VM_CallCompiled
+
+This function is called directly by the generated code
+==============
+*/
+#ifndef DLL_ONLY // bk010215 - for DLL_ONLY dedicated servers/builds w/o VM
+int	VM_CallCompiled( vm_t *vm, int *args ) {
+	int		stack[1024];
+	int		programCounter;
+	int		programStack;
+	int		stackOnEntry;
+	byte	*image;
+	void	*entryPoint;
+	void	*opStack;
+	int		*oldInstructionPointers;
+
+	oldInstructionPointers = instructionPointers;
+
+	currentVM = vm;
+	instructionPointers = vm->instructionPointers;
+
+	// interpret the code
+	vm->currentlyInterpreting = qtrue;
+
+	callMask = vm->dataMask;
+
+	// we might be called recursively, so this might not be the very top
+	programStack = vm->programStack;
+	stackOnEntry = programStack;
+
+	// set up the stack frame 
+	image = vm->dataBase;
+
+	programCounter = 0;
+
+	programStack -= 48;
+
+	*(int *)&image[ programStack + 44] = args[9];
+	*(int *)&image[ programStack + 40] = args[8];
+	*(int *)&image[ programStack + 36] = args[7];
+	*(int *)&image[ programStack + 32] = args[6];
+	*(int *)&image[ programStack + 28] = args[5];
+	*(int *)&image[ programStack + 24] = args[4];
+	*(int *)&image[ programStack + 20] = args[3];
+	*(int *)&image[ programStack + 16] = args[2];
+	*(int *)&image[ programStack + 12] = args[1];
+	*(int *)&image[ programStack + 8 ] = args[0];
+	*(int *)&image[ programStack + 4 ] = 0;	// return stack
+	*(int *)&image[ programStack ] = -1;	// will terminate the loop on return
+
+	// off we go into generated code...
+	entryPoint = vm->codeBase;
+	opStack = &stack;
+
+#ifdef _WIN32
+	__asm  {
+		pushad
+		mov		esi, programStack;
+		mov		edi, opStack
+		call	entryPoint
+		mov		programStack, esi
+		mov		opStack, edi
+		popad
+	}
+#else
+	{
+		static int memProgramStack;
+		static void *memOpStack;
+		static void *memEntryPoint;
+
+		memProgramStack	= programStack;
+		memOpStack      = opStack;     
+		memEntryPoint   = entryPoint;  
+		
+		__asm__("	pushal				\r\n" \
+				"	movl %0,%%esi		\r\n" \
+				"	movl %1,%%edi		\r\n" \
+				"	call *%2			\r\n" \
+				"	movl %%esi,%0		\r\n" \
+				"	movl %%edi,%1		\r\n" \
+				"	popal				\r\n" \
+				: "=m" (memProgramStack), "=m" (memOpStack) \
+				: "m" (memEntryPoint), "0" (memProgramStack), "1" (memOpStack) \
+				: "si", "di" \
+		);
+
+		programStack = memProgramStack;
+		opStack      = memOpStack;
+	}
+#endif
+
+	if ( opStack != &stack[1] ) {
+		Com_Error( ERR_DROP, "opStack corrupted in compiled code" );
+	}
+	if ( programStack != stackOnEntry - 48 ) {
+		Com_Error( ERR_DROP, "programStack corrupted in compiled code" );
+	}
+
+	vm->programStack = stackOnEntry;
+
+	// in case we were recursively called by another vm
+	instructionPointers = oldInstructionPointers;
+
+	return *(int *)opStack;
+}
+#endif // !DLL_ONLY
+
diff --git a/codemp/qcommon/vssver.scc b/codemp/qcommon/vssver.scc
new file mode 100644
index 0000000..3f48578
Binary files /dev/null and b/codemp/qcommon/vssver.scc differ
diff --git a/codemp/qcommon/z_memman_console.cpp b/codemp/qcommon/z_memman_console.cpp
new file mode 100644
index 0000000..e45b28e
--- /dev/null
+++ b/codemp/qcommon/z_memman_console.cpp
@@ -0,0 +1,1825 @@
+
+/*
+ * UNPUBLISHED -- Rights  reserved  under  the  copyright  laws  of the 
+ * United States.  Use  of a copyright notice is precautionary only and 
+ * does not imply publication or disclosure.                            
+ *                                                                      
+ * THIS DOCUMENTATION CONTAINS CONFIDENTIAL AND PROPRIETARY INFORMATION 
+ * OF    VICARIOUS   VISIONS,  INC.    ANY  DUPLICATION,  MODIFICATION, 
+ * DISTRIBUTION, OR DISCLOSURE IS STRICTLY PROHIBITED WITHOUT THE PRIOR 
+ * EXPRESS WRITTEN PERMISSION OF VICARIOUS VISIONS, INC.
+ */
+
+/*
+ *	ZONE MEMORY MANAGER
+ *
+ *	Goals:
+ *		1. Minimize overhead
+ *		2. Minimize fragmentation
+ *
+ *	Constraints:
+ *		1. Maximum allocated block size is 32MB
+ *		2. Maximum 64 different memory tags supported
+ *		3. Maximum 256 byte alignment
+ *
+ *	All memory required by the manager is allocated at startup in
+ *	the form of one large pool.
+ *
+ *	Allocated blocks require a 4 byte header to store size, tag, and
+ *	alignment information.  Blocks that need to support the Z_TagFree()
+ *	feature require an additional 8 byte link list structure.
+ *
+ *	Free blocks require a 16 bytes of tracking information.  If possible
+ *	this information is stored directly in the block (which is in the
+ *	pool.)  If the free block is not large enough, its information is
+ *	stored in an overflow buffer.
+ *
+ *	In an effort to reduce fragmentation, blocks allocated for a short
+ *	period of time at the end of the pool.  All other blocks are allocated
+ *	at the start.  Allocation is first fit.
+ *
+ */
+
+#include "../game/q_shared.h"
+#include "qcommon.h"
+#include "../renderer/qgl_console.h"
+
+#ifdef _GAMECUBE
+#include <dolphin/os.h>
+#endif
+
+#ifdef _WINDOWS
+#include <windows.h>
+#endif
+
+#ifdef _XBOX
+#include <Xtl.h>
+#endif
+
+// Where do hunk allocations go?
+static memtag_t hunk_tag;
+
+// Used to mark the start and end of blocks in debug mode
+#define ZONE_MAGIC 0xfe
+
+// Size of the free block overflow buffer
+#define ZONE_FREE_OVERFLOW 4096
+
+// Indicates whether or not special (slow) debug code should be enabled
+#define ZONE_DEBUG 0
+
+// Allocate all available memory minus this amount
+#ifdef _GAMECUBE
+#define ZONE_HEAP_FREE_DEBUG (64*1024*4)
+#define ZONE_HEAP_FREE_RELEASE (0)
+
+#ifdef _DEBUG
+#	define ZONE_HEAP_FREE ZONE_HEAP_FREE_DEBUG
+#else
+#	define ZONE_HEAP_FREE ZONE_HEAP_FREE_RELEASE
+#endif
+#else
+//Game needs about 8 MB for framebuffers audio, bink, etc., plus 24 MB
+//for textures.
+//#	define ZONE_HEAP_FREE (1024*1024*8 + 24*1024*1024)
+#	define ZONE_HEAP_FREE (1024*1024*8 + 24*1024*1024 + 4*1024*1024)
+#endif
+
+// Should we emulate the smaller memory footprint of actual release systems?
+#define ZONE_EMULATE_SPACE 0
+
+// All standard header data is crammed into 4 bytes
+typedef unsigned int ZoneHeader;
+
+// Debug markers to check for overflow/underflow
+typedef unsigned int ZoneDebugHeader;
+typedef unsigned char ZoneDebugFooter;
+
+// Extended header information for memory freed with TagFree()
+struct ZoneLinkHeader
+{
+	ZoneLinkHeader* m_Next;
+	ZoneLinkHeader* m_Prev;
+};
+
+static ZoneLinkHeader* s_LinkBase;
+
+// Free memory block tracking information
+struct ZoneFreeBlock
+{
+	unsigned int m_Address;
+	unsigned int m_Size;
+	ZoneFreeBlock* m_Next;
+	ZoneFreeBlock* m_Prev;
+};
+
+// Buffer to hold free memory information that we can't
+// fit directly in the pool
+static ZoneFreeBlock s_FreeOverflow[ZONE_FREE_OVERFLOW];
+static int s_LastOverflowIndex;
+
+static ZoneFreeBlock s_FreeStart;
+static ZoneFreeBlock s_FreeEnd;
+
+// Various stats collected at runtime
+struct ZoneStats
+{
+	int	m_CountAlloc;
+	int m_SizeAlloc;
+	int m_OverheadAlloc;
+	int	m_PeakAlloc;
+	int	m_CountFree;
+	int m_SizeFree;
+	int	m_SizesPerTag[TAG_COUNT];
+	int	m_CountsPerTag[TAG_COUNT];	
+};
+
+static ZoneStats s_Stats;
+
+// Special empty block for zero size allocations
+struct ZoneEmptyBlock
+{
+	ZoneHeader header;
+#ifdef _DEBUG
+	ZoneDebugHeader start;
+	ZoneDebugFooter end;
+#endif
+};
+
+#ifdef _DEBUG
+static ZoneEmptyBlock s_EmptyBlock = {TAG_STATIC << 25, ZONE_MAGIC, ZONE_MAGIC};
+#else
+static ZoneEmptyBlock s_EmptyBlock = {TAG_STATIC << 25};
+#endif
+
+// Free block jump table for fast memory deallocation
+#define Z_JUMP_TABLE_SIZE 64
+static ZoneFreeBlock* s_FreeJumpTable[Z_JUMP_TABLE_SIZE];
+static unsigned int s_FreeJumpResolution;
+
+static void* s_PoolBase;
+static bool s_Initialized = false;
+static bool s_IsNewDeleteTemp = false;
+
+#ifndef _GAMECUBE
+static HANDLE s_Mutex = INVALID_HANDLE_VALUE;
+#endif
+
+static void Z_Stats_f(void);
+void Z_Details_f(void);
+void Z_DumpMemMap_f(void);
+
+
+#ifdef _XBOX
+void ShowOSMemory(void)
+{
+	MEMORYSTATUS stat;
+	GlobalMemoryStatus(&stat);
+	Com_Printf("     total mem: %d, free mem: %d\n", stat.dwTotalPhys / 1024,
+			stat.dwAvailPhys / 1024);
+	FILE *out = fopen("d:\\osmem.txt", "a");
+	if(out) {
+		fprintf(out, "total mem: %d, free mem: %d\n", stat.dwTotalPhys / 1024,
+				stat.dwAvailPhys / 1024);
+		fclose(out);
+	}
+}
+#endif
+
+
+int Z_MemFree(void)
+{
+	return s_Stats.m_SizeFree;
+}
+
+
+void Com_InitZoneMemory(void)
+{
+//	assert(!s_Initialized);
+	// Zone now initializes on first use, can't reliably assume anything here
+	if (s_Initialized)
+		return;
+
+	Com_Printf("Initialising zone memory .....\n");
+
+	// Clear some globals
+	memset(&s_Stats, 0, sizeof(s_Stats));
+	memset(s_FreeOverflow, 0, sizeof(s_FreeOverflow));
+	s_LastOverflowIndex = 0;
+	s_LinkBase = NULL;
+	s_IsNewDeleteTemp = false;
+
+	// Alloc the pool
+#if defined(_XBOX)
+	MEMORYSTATUS status;
+	GlobalMemoryStatus(&status);
+
+	// BTO : VVFIXME - Extra little note to see how much memory
+	// is being used by globals/statics
+	Com_Printf("*** PhysRAM: %d used, %d free\n",
+				status.dwTotalPhys-status.dwAvailPhys,
+				status.dwAvailPhys);
+	SIZE_T size;
+#	if ZONE_EMULATE_SPACE
+#ifdef _DEBUG
+	//Emulated space is always about 6 megs off from release build.  Try
+	//to compensate.  This number may need tweaking in the future.
+	SIZE_T exe = 6500 * 1024;
+#else
+	SIZE_T exe = 0; //Exe size is already reflected in GlobalMemoryStatus().
+#endif
+	size = 0x4000000 - (exe + ZONE_HEAP_FREE);
+#	else
+	size = status.dwAvailPhys - ZONE_HEAP_FREE;
+#	endif
+	s_PoolBase = GlobalAlloc(0, size);
+#elif defined(_WINDOWS)
+	SIZE_T size = 50*1024*1024;
+	s_PoolBase = GlobalAlloc(0, size);
+#endif
+
+	// Setup the initial free block
+	ZoneFreeBlock* base = (ZoneFreeBlock*)s_PoolBase;
+	base->m_Address = (unsigned int)s_PoolBase;
+	base->m_Size = size;
+	base->m_Next = &s_FreeEnd;
+	base->m_Prev = &s_FreeStart;
+
+	// Init the free block jump table
+	memset(s_FreeJumpTable, 0, Z_JUMP_TABLE_SIZE * sizeof(ZoneFreeBlock*));
+	s_FreeJumpResolution = (size / Z_JUMP_TABLE_SIZE) + 1;
+	s_FreeJumpTable[0] = base;
+
+	// Setup free block dummies
+	s_FreeStart.m_Address = 0;
+	s_FreeStart.m_Size = 0;
+	s_FreeStart.m_Next = base;
+	s_FreeStart.m_Prev = NULL;
+
+	s_FreeEnd.m_Address = 0xFFFFFFFF;
+	s_FreeEnd.m_Size = 0;
+	s_FreeEnd.m_Next = NULL;
+	s_FreeEnd.m_Prev = base;
+
+	s_Stats.m_CountFree = 1;
+	s_Stats.m_SizeFree = size;
+
+	s_Initialized = true;
+
+	// Add some commands
+	Cmd_AddCommand("zone_stats",	Z_Stats_f);
+	Cmd_AddCommand("zone_details",	Z_Details_f);
+	Cmd_AddCommand("zone_memmap",	Z_DumpMemMap_f);
+
+#ifndef _GAMECUBE
+	s_Mutex = CreateMutex(NULL, FALSE, NULL);
+#endif
+}
+
+void Com_ShutdownZoneMemory(void)
+{
+	assert(s_Initialized);
+
+	// Remove commands
+	Cmd_RemoveCommand("zone_stats");
+	Cmd_RemoveCommand("zone_details");
+	Cmd_RemoveCommand("zone_memmap");
+
+	if (s_Stats.m_CountAlloc)
+	{
+		// Free all memory
+//		CM_ReleaseVisData();
+		Z_TagFree(TAG_ALL);
+	}
+	
+	// Clear some globals
+	memset(&s_Stats, 0, sizeof(s_Stats));
+	memset(s_FreeOverflow, 0, sizeof(s_FreeOverflow));
+	s_LastOverflowIndex = 0;
+	s_LinkBase = NULL;
+
+	// Free the pool
+#ifndef _GAMECUBE
+	GlobalFree(s_PoolBase);
+	CloseHandle(s_Mutex);
+#endif
+
+	s_PoolBase = NULL;
+	s_Initialized = false;
+}
+
+
+// Determine if a tag should only be allocated for a very
+// short period of time.
+static bool Z_IsTagTemp(memtag_t eTag)
+{
+	return 
+		eTag == TAG_TEMP_WORKSPACE || 
+#ifndef _JK2MP
+		eTag == TAG_TEMP_SAVEGAME_WORKSPACE ||
+		eTag == TAG_STRING ||
+		eTag == TAG_GP2 ||
+#endif
+		eTag == TAG_SND_RAWDATA ||
+		eTag == TAG_ICARUS ||
+#ifdef _JK2MP
+		eTag == TAG_TEXTPOOL ||
+		eTag == TAG_TEMP_HUNKALLOC ||
+#endif
+		eTag == TAG_LISTFILES;
+}
+
+// Determine if a tag needs TagFree() support.
+static bool Z_IsTagLinked(memtag_t eTag)
+{
+	return
+		eTag == TAG_BSP ||
+#ifndef _JK2MP
+		eTag == TAG_HUNKALLOC ||
+		eTag == TAG_HUNKMISCMODELS ||
+		eTag == TAG_G_ALLOC ||
+#endif
+#ifdef _JK2MP
+		eTag == TAG_CG_UI_ALLOC ||
+		eTag == TAG_BG_ALLOC ||
+		eTag == TAG_HUNK_MARK1 ||
+		eTag == TAG_HUNK_MARK2 ||
+		eTag == TAG_TEMP_HUNKALLOC ||
+#endif
+		eTag == TAG_UI_ALLOC;
+}
+
+static int Z_CalcAlignmentPad(int iAlign, unsigned int iAddress, unsigned int iOffset, 
+	unsigned int iSize, unsigned int iHeaderSize, unsigned int iFooterSize)
+{
+	int align_size;
+
+	if (iAlign == 0) return 0;
+	
+	if (iOffset == 0)
+	{
+		// Align data at low end of block
+		align_size = iAlign - 
+			((iAddress + iHeaderSize) % iAlign);
+	}
+	else
+	{
+		// Align data at high end of block
+		unsigned int block_start = iAddress + iOffset - 
+			iSize + iHeaderSize;
+		align_size = block_start % iAlign;
+	}
+	
+	if (align_size == iAlign)
+	{
+		return 0;
+	}
+
+	return align_size;
+}
+
+static ZoneFreeBlock* Z_GetOverflowBlock(void)
+{
+	for (int i = s_LastOverflowIndex; i < ZONE_FREE_OVERFLOW; ++i)
+	{
+		if (s_FreeOverflow[i].m_Address == 0)
+		{
+			s_LastOverflowIndex = i;
+			return &s_FreeOverflow[i];
+		}
+	}
+
+	for (int j = 0; j < s_LastOverflowIndex; ++j)
+	{
+		if (s_FreeOverflow[j].m_Address == 0)
+		{
+			s_LastOverflowIndex = j;
+			return &s_FreeOverflow[j];
+		}
+	}
+
+	return NULL;
+}
+
+static inline bool Z_IsFreeBlockLargeEnough(ZoneFreeBlock* pBlock, int iSize, 
+	int iHeaderSize, int iFooterSize, int iAlign, bool bLow, int& iAlignPad)
+{
+	// Is the block large enough?
+	if (pBlock->m_Size >= iSize)
+	{
+		if (iAlign > 0)
+		{
+			// If we need some aligment, we need to check size
+			// against that as well.
+			iAlignPad = Z_CalcAlignmentPad(iAlign,
+				pBlock->m_Address, !bLow ? pBlock->m_Size : 0,
+				iSize, iHeaderSize, iFooterSize);
+
+			if (pBlock->m_Size < iAlignPad + iSize)
+			{
+				return false;
+			}
+		}
+		return true;
+	}
+	return false;
+}
+
+static ZoneFreeBlock* Z_FindFirstFree(int iSize, int iHeaderSize, 
+	int iFooterSize, int iAlign, int& iAlignPad)
+{
+	for (ZoneFreeBlock* block = s_FreeStart.m_Next; block; block = block->m_Next)
+	{
+		if (Z_IsFreeBlockLargeEnough(block, iSize, iHeaderSize, iFooterSize,
+			iAlign, true, iAlignPad))
+		{
+			return block;
+		}
+	}
+	return NULL;
+}
+
+static ZoneFreeBlock* Z_FindLastFree(int iSize, int iHeaderSize, 
+	int iFooterSize, int iAlign, int& iAlignPad)
+{
+	for (ZoneFreeBlock* block = s_FreeEnd.m_Prev; block; block = block->m_Prev)
+	{
+		if (Z_IsFreeBlockLargeEnough(block, iSize, iHeaderSize, iFooterSize,
+			iAlign, false, iAlignPad))
+		{
+			return block;
+		}
+	}
+	return NULL;
+}
+
+static bool Z_ValidateFree(void)
+{
+#if ZONE_DEBUG
+	// Make sure no free blocks are overlapping
+	for (ZoneFreeBlock* a = &s_FreeStart; a; a = a->m_Next)
+	{
+		if (a->m_Address == 0 && a->m_Size != 0)
+		{
+			return false;
+		}
+
+		for (ZoneFreeBlock* b = &s_FreeStart; b; b = b->m_Next)
+		{
+			if (a != b && 
+				a->m_Address >= b->m_Address && 
+				a->m_Address < b->m_Address + b->m_Size)
+			{
+				return false;
+			}
+		}
+	}
+#endif
+
+	return true;
+}
+
+static bool Z_ValidateLinks(void)
+{
+#if ZONE_DEBUG
+	// Make sure links are sane
+	for (ZoneLinkHeader* a = s_LinkBase; a; a = a->m_Next)
+	{
+		if ((a->m_Next && a != a->m_Next->m_Prev) ||
+			(a->m_Prev && a != a->m_Prev->m_Next))
+		{
+			return false;
+		}
+	}
+#endif
+
+	return true;
+}
+
+static int Z_GetJumpTableIndex(unsigned int iAddress)
+{
+	int index = (iAddress - (unsigned int)s_PoolBase) / s_FreeJumpResolution;
+	if (index < 0) return 0;
+	if (index >= Z_JUMP_TABLE_SIZE) return Z_JUMP_TABLE_SIZE - 1;
+	return index;
+}
+
+static ZoneFreeBlock* Z_GetFreeBlockBefore(unsigned int iAddress)
+{
+	// Find this block's position in the jump table
+	int index = Z_GetJumpTableIndex(iAddress) - 1;
+
+	// Find a valid jump table entry
+	while (index >= 0 && !s_FreeJumpTable[index]) --index;
+
+	if (index < 0) return &s_FreeStart;
+	return s_FreeJumpTable[index];
+}
+
+static void Z_RemoveFromJumpTable(ZoneFreeBlock* pBlock)
+{
+	// Is this block in the jump table?
+	int index = Z_GetJumpTableIndex(pBlock->m_Address);
+	if (s_FreeJumpTable[index] == pBlock)
+	{
+		// See if the next block will fit in our slot
+		if (pBlock->m_Next != &s_FreeEnd)
+		{
+			int nindex = Z_GetJumpTableIndex(pBlock->m_Next->m_Address);
+			if (nindex == index)
+			{
+				s_FreeJumpTable[index] = pBlock->m_Next;
+				return;
+			}
+		}
+
+		// See if the previous block will fit in our slot
+		if (pBlock->m_Prev != &s_FreeStart)
+		{
+			int pindex = Z_GetJumpTableIndex(pBlock->m_Prev->m_Address);
+			if (pindex == index)
+			{
+				s_FreeJumpTable[index] = pBlock->m_Prev;
+				return;
+			}
+		}
+
+		// No other free blocks fit here, give up
+		s_FreeJumpTable[index] = NULL;
+	}
+}
+
+static void Z_LinkFreeBlock(ZoneFreeBlock* pBlock)
+{
+	ZoneFreeBlock* cur = Z_GetFreeBlockBefore(pBlock->m_Address);
+	for (; cur; cur = cur->m_Next)
+	{
+		// Find the correct position, ordered by address
+		if (cur->m_Address > pBlock->m_Address)
+		{
+			// Link up the block
+			pBlock->m_Next = cur;
+			pBlock->m_Prev = cur->m_Prev;
+			cur->m_Prev->m_Next = pBlock;
+			cur->m_Prev = pBlock;
+
+			// Update the jump table if necessary
+			int index = Z_GetJumpTableIndex(pBlock->m_Address);
+			if (!s_FreeJumpTable[index])
+			{
+				s_FreeJumpTable[index] = pBlock;
+			}
+
+			s_Stats.m_CountFree++;
+			s_Stats.m_SizeFree += pBlock->m_Size;
+			
+			assert(Z_ValidateFree());
+			break;
+		}
+	}	
+}
+
+static void* Z_SplitFree(ZoneFreeBlock* pBlock, int iSize, bool bLow)
+{
+	assert(pBlock->m_Size >= iSize);
+	
+	Z_RemoveFromJumpTable(pBlock);
+
+	// Delink the free block
+	ZoneFreeBlock fblock = *pBlock;
+	pBlock->m_Prev->m_Next = pBlock->m_Next;
+	pBlock->m_Next->m_Prev = pBlock->m_Prev;
+	pBlock->m_Address = 0;
+
+	s_Stats.m_CountFree--;
+	s_Stats.m_SizeFree -= pBlock->m_Size;
+	assert(Z_ValidateFree());
+
+	if (fblock.m_Size > iSize)
+	{
+		// Split the block into an allocated and free portion
+		int remainder = fblock.m_Size - iSize;
+
+		if (remainder < sizeof(ZoneFreeBlock))
+		{
+			// Free portion is not large to hold free info --
+			// we're going to have to use the overflow buffer.
+			ZoneFreeBlock* nblock = Z_GetOverflowBlock();
+
+			if (nblock == NULL)
+			{
+				Z_Details_f();
+				Com_Error(ERR_FATAL, "Zone free overflow buffer overflowed!");
+			}
+
+			// Split the block
+			void* ret;
+			if (bLow)
+			{
+				ret = (void*)fblock.m_Address;
+				nblock->m_Address = fblock.m_Address + iSize;
+			}
+			else
+			{
+				ret = (void*)(fblock.m_Address + remainder);
+				nblock->m_Address = fblock.m_Address;
+			}
+	
+			nblock->m_Size = remainder;
+			Z_LinkFreeBlock(nblock);
+
+			return ret;
+		}
+		else
+		{
+			// Free portion is large enough -- split it
+			void* ret;
+			ZoneFreeBlock* nblock;
+			if (bLow)
+			{
+				ret = (void*)fblock.m_Address;
+				nblock = (ZoneFreeBlock*)(fblock.m_Address + iSize);
+			}
+			else
+			{
+				ret = (void*)(fblock.m_Address + remainder);
+				nblock = (ZoneFreeBlock*)fblock.m_Address;
+			}
+
+			nblock->m_Address = (unsigned int)nblock;
+			nblock->m_Size = remainder;
+			
+			Z_LinkFreeBlock(nblock);
+
+			return ret;
+		}
+	}
+	else
+	{
+		// No need to split, just return block.
+		return (void*)fblock.m_Address;
+	}
+}
+
+static void Z_SetupAlignmentPad(void* pBlock, int iAlignPad, bool bLow)
+{
+	// Clear alignment bytes
+	memset(pBlock, 0, iAlignPad);
+	
+	// If we have more than 1 alignment byte, the first align byte
+	// tells us how many additional bytes we have.
+	if (iAlignPad > 1)
+	{
+		assert(iAlignPad < 256);
+		unsigned char* ptr;
+		if (bLow)
+		{
+			ptr = (unsigned char*)pBlock + (iAlignPad - 1);
+		}
+		else
+		{
+			ptr = (unsigned char*)pBlock;
+		}
+		*ptr = iAlignPad - 1;
+	}
+}
+
+void Z_MallocFail(const char* pMessage, int iSize, memtag_t eTag)
+{
+	// Report the error
+//	Com_Printf("Z_Malloc(): %s : %d bytes and tag %d !!!!\n", pMessage, iSize, eTag);
+	Com_Printf("Z_Malloc(): %s : %d bytes and tag %d !!!!\n", pMessage, iSize, eTag);
+	Z_Details_f();
+	Z_DumpMemMap_f();
+//	Com_Printf("(Repeat): Z_Malloc(): %s : %d bytes and tag %d !!!!\n", pMessage, iSize, eTag);
+	Com_Printf("(Repeat): Z_Malloc(): %s : %d bytes and tag %d !!!!\n", pMessage, iSize, eTag);
+
+	// Clear the screen blue to indicate out of memory
+	for (;;)
+	{
+		qglBeginFrame();
+		qglClearColor(0, 0, 1, 1);
+		qglClear(GL_COLOR_BUFFER_BIT);
+		qglEndFrame();
+	}
+}
+
+void *Z_Malloc(int iSize, memtag_t eTag, qboolean bZeroit, int iAlign)
+{
+//	assert(s_Initialized);
+	// Zone now initializes on first use. (During static constructors)
+	if (!s_Initialized)
+		Com_InitZoneMemory();
+	
+	if (iSize == 0)
+	{
+#ifdef _DEBUG
+		return (void*)(&s_EmptyBlock.start + 1);
+#else
+		return (void*)(&s_EmptyBlock.header + 1);
+#endif
+	}
+
+	if (iSize < 0)
+	{
+		Z_MallocFail("Negative size", iSize, eTag);
+		return NULL;
+	}
+
+#ifndef _GAMECUBE
+	WaitForSingleObject(s_Mutex, INFINITE);
+#endif
+	
+	// Make new/delete memory temporary if requested
+	if (eTag == TAG_NEWDEL && s_IsNewDeleteTemp)
+	{
+		eTag = TAG_TEMP_WORKSPACE;
+	}
+
+	// Determine how much space we need with headers and footers
+	int header_size = sizeof(ZoneHeader);
+	int footer_size = 0;
+	if (Z_IsTagLinked(eTag))
+	{
+		header_size += sizeof(ZoneLinkHeader);
+	}
+#ifdef _DEBUG
+	header_size += sizeof(ZoneDebugHeader);
+	footer_size += sizeof(ZoneDebugFooter);
+#endif
+	int real_size = iSize + header_size + footer_size;
+	int align_pad = 0;
+
+	// Get a bit of free memory.  Temporary memory is allocated
+	// from the end.  More permanent allocations are done at the
+	// begining of the pool.
+	ZoneFreeBlock* fblock;
+	if (Z_IsTagTemp(eTag))
+	{
+		fblock = Z_FindLastFree(real_size, header_size, footer_size, 
+			iAlign, align_pad);
+	}
+	else
+	{
+		fblock = Z_FindFirstFree(real_size, header_size, footer_size, 
+			iAlign, align_pad);
+	}
+
+	// Did we actually find some memory?
+	if (!fblock)
+	{
+#ifndef _GAMECUBE
+		ReleaseMutex(s_Mutex);
+#endif
+//		if(eTag == TAG_TEMP_SND_RAWDATA) {
+		if(eTag == TAG_SND_RAWDATA) {
+			return NULL;
+		}
+
+		Z_MallocFail("Out of memory", iSize, eTag);
+		return NULL;
+	}
+
+	// Add any alignment bytes
+	real_size += align_pad;
+
+	// Split the free block and get a pointer to the start
+	// allocated space.
+	void* ablock;
+	if (Z_IsTagTemp(eTag))
+	{
+		ablock = Z_SplitFree(fblock, real_size, false);
+		
+		// Append align pad to end of block
+		Z_SetupAlignmentPad(
+			(void*)((char*)ablock + real_size - align_pad), 
+			align_pad, false);
+	}
+	else
+	{
+		ablock = Z_SplitFree(fblock, real_size, true);
+
+		// Insert align pad at block start
+		Z_SetupAlignmentPad(ablock, align_pad, true);
+		ablock = (void*)((char*)ablock + align_pad);
+	}
+
+	if (!ablock)
+	{
+		Z_MallocFail("Failed to split", iSize, eTag);
+	}
+
+	// Add linking header if necessary
+	if (Z_IsTagLinked(eTag))
+	{
+		ZoneLinkHeader* linked = (ZoneLinkHeader*)ablock;
+		linked->m_Next = s_LinkBase;
+		linked->m_Prev = NULL;
+		if (s_LinkBase)
+		{
+			s_LinkBase->m_Prev = linked;
+		}
+		s_LinkBase = linked;
+
+		assert(Z_ValidateLinks());
+
+		// Next...
+		ablock = (void*)((char*)ablock + sizeof(ZoneLinkHeader));
+	}
+
+	// Setup the header:
+	//		31		- alignment flag
+	//		25-30	- tag
+	//		0-24	- size without headers/footers
+	assert(iSize >= 0 && iSize < (1 << 25));
+	assert(eTag >= 0 && eTag < 64);
+	ZoneHeader* header = (ZoneHeader*)ablock;
+	*header = 
+		(((unsigned int)eTag) << 25) |
+		((unsigned int)iSize);
+
+	if (align_pad)
+	{
+		*header |= (1 << 31);
+	}
+
+	// Next...
+	ablock = (void*)((char*)ablock + sizeof(ZoneHeader));
+
+#ifdef _DEBUG
+	{
+		// Setup the debug markers
+		ZoneDebugHeader* debug_header = (ZoneDebugHeader*)ablock;
+
+		ZoneDebugFooter* debug_footer = (ZoneDebugFooter*)((char*)debug_header + 
+			(sizeof(ZoneDebugHeader) + iSize));
+
+		*debug_header = ZONE_MAGIC;
+		*debug_footer = ZONE_MAGIC;
+
+		// Next...
+		ablock = (void*)((char*)ablock + sizeof(ZoneDebugHeader));
+	}
+#endif
+
+	// Update the stats
+	s_Stats.m_SizeAlloc += iSize;
+	s_Stats.m_OverheadAlloc += header_size + footer_size + align_pad;
+	s_Stats.m_SizesPerTag[eTag] += iSize;
+	s_Stats.m_CountAlloc++;
+	s_Stats.m_CountsPerTag[eTag]++;
+
+	if (s_Stats.m_SizeAlloc + s_Stats.m_OverheadAlloc > s_Stats.m_PeakAlloc)
+	{
+		s_Stats.m_PeakAlloc = s_Stats.m_SizeAlloc + s_Stats.m_OverheadAlloc;
+	}
+
+	// Return a pointer to data memory
+	if (bZeroit)
+	{
+		memset(ablock, 0, iSize);
+	}
+
+	assert(iAlign == 0 || (unsigned int)ablock % iAlign == 0);
+
+	/*
+	   This is useful for figuring out who's allocating a certain block of
+	   memory.  Please don't remove it.
+	if(eTag == TAG_NEWDEL && (unsigned int)ablock >= 0x806c0000 && 
+			(unsigned int)ablock <= 0x806c1000 && iSize == 24) {
+		int suck = 0;
+	}
+	if(eTag == TAG_SMALL && (iSize == 7 || iSize == 96)) {
+		int suck = 0;
+	}
+	if(eTag == TAG_CLIENTS) {
+		int suck = 0;
+	}
+	*/
+
+#ifndef _GAMECUBE
+	ReleaseMutex(s_Mutex);
+#endif
+
+	return ablock;
+}
+
+static memtag_t Z_GetTag(const ZoneHeader* header)
+{
+	return (*header & 0x7E000000) >> 25;
+}
+
+static unsigned int Z_GetSize(const ZoneHeader* header)
+{
+	return *header & 0x1FFFFFF;
+}
+
+static int Z_GetAlign(const ZoneHeader* header)
+{
+	if (*header & (1 << 31))
+	{
+		unsigned char* ptr = (unsigned char*)header;
+		memtag_t tag = Z_GetTag(header);
+
+		// point to the first alignment block
+		if (Z_IsTagTemp(tag))
+		{
+			ptr += sizeof(ZoneHeader) + Z_GetSize(header);
+#ifdef _DEBUG
+			ptr += sizeof(ZoneDebugHeader) + sizeof(ZoneDebugFooter);
+#endif
+		}
+		else
+		{
+			if (Z_IsTagLinked(tag))
+			{
+				// skip the link header
+				ptr -= sizeof(ZoneLinkHeader);
+			}
+			ptr -= 1;
+		}
+
+		return *ptr + 1;
+	}
+	return 0;
+}
+
+int Z_Size(void *pvAddress)
+{
+	assert(s_Initialized);
+
+#ifdef _DEBUG
+	ZoneDebugHeader* debug = (ZoneDebugHeader*)pvAddress - 1;
+
+	if (*debug != ZONE_MAGIC)
+	{
+		Com_Error(ERR_FATAL, "Z_Size(): Not a valid zone header!");
+		return 0;	// won't get here
+	}
+
+	pvAddress = (void*)debug;
+#endif
+
+	ZoneHeader* header = (ZoneHeader*)pvAddress - 1;
+
+	if (Z_GetTag(header) == TAG_STATIC)
+	{
+		return 0;	// kind of
+	}
+	
+	return Z_GetSize(header);
+}
+
+static void Z_Coalasce(ZoneFreeBlock* pBlock)
+{
+	unsigned int size = 0;
+	
+	// Find later free blocks adjacent to us
+	ZoneFreeBlock* end;
+	for (end = pBlock->m_Next; 
+	end->m_Next; 
+	end = end->m_Next)
+	{
+		if (end->m_Address !=
+			end->m_Prev->m_Address + end->m_Prev->m_Size)
+		{
+			break;
+		}
+
+		size += end->m_Size;
+
+		Z_RemoveFromJumpTable(end);
+
+		end->m_Address = 0; // invalidate block
+		s_Stats.m_CountFree--;
+	}
+
+	// Find previous free blocks adjacent to us
+	ZoneFreeBlock* start;
+	for (start = pBlock; 
+	start->m_Prev; 
+	start = start->m_Prev)
+	{
+		if (start->m_Prev->m_Address + start->m_Prev->m_Size !=
+			start->m_Address)
+		{
+			break;
+		}
+
+		size += start->m_Size;
+
+		Z_RemoveFromJumpTable(start);
+
+		start->m_Address = 0; // invalidate block
+		s_Stats.m_CountFree--;
+	}
+
+	// Do we need to coalesce some blocks?
+	if (start->m_Next != end)
+	{
+		start->m_Next = end;
+		end->m_Prev = start;
+		start->m_Size += size;
+	}
+}
+
+// Return type of Z_Free differs in SP/MP. Macro hack to wrap it up
+#ifdef _JK2MP
+	void Z_Free(void *pvAddress)
+	#define Z_FREE_RETURN(x) return
+#else
+	int Z_Free(void *pvAddress)
+	#define Z_FREE_RETURN(x) return (x)
+#endif
+{
+#ifdef _WINDOWS
+	if (!s_Initialized) return;
+#endif
+
+	assert(s_Initialized);
+
+#ifdef _DEBUG
+	// check the header magic
+	ZoneDebugHeader* debug_header = (ZoneDebugHeader*)pvAddress - 1;
+
+	if (*debug_header != ZONE_MAGIC)
+	{
+		Com_Error(ERR_FATAL, "Z_Free(): Corrupt zone header!");
+		Z_FREE_RETURN( 0 );
+	}
+
+	ZoneHeader* header = (ZoneHeader*)debug_header - 1;
+
+	// check the footer magic
+	ZoneDebugFooter* debug_footer = (ZoneDebugFooter*)((char*)pvAddress + 
+		Z_GetSize(header));
+
+	if (*debug_footer != ZONE_MAGIC)
+	{
+		Com_Error(ERR_FATAL, "Z_Free(): Corrupt zone footer!");
+		Z_FREE_RETURN( 0 );
+	}
+#else
+	ZoneHeader* header = (ZoneHeader*)pvAddress - 1;
+#endif
+
+	memtag_t tag = Z_GetTag(header);
+
+	if (tag != TAG_STATIC)
+	{
+#ifndef _GAMECUBE
+		WaitForSingleObject(s_Mutex, INFINITE);
+#endif
+
+		// Determine size of header and footer
+		int header_size = sizeof(ZoneHeader);
+		int align_size = Z_GetAlign(header);
+		int footer_size = 0;
+		int data_size = Z_GetSize(header);
+		if (Z_IsTagLinked(tag))
+		{
+			header_size += sizeof(ZoneLinkHeader);
+		}
+		if (Z_IsTagTemp(tag))
+		{
+			footer_size += align_size;
+		}
+		else
+		{
+			header_size += align_size;
+		}
+#ifdef _DEBUG
+		header_size += sizeof(ZoneDebugHeader);
+		footer_size += sizeof(ZoneDebugFooter);
+#endif
+		int real_size = data_size + header_size + footer_size;
+		
+		// Update the stats
+		s_Stats.m_SizeAlloc -= data_size;
+		s_Stats.m_OverheadAlloc -= header_size + footer_size;
+		s_Stats.m_SizesPerTag[tag] -= data_size;
+		s_Stats.m_CountAlloc--;
+		s_Stats.m_CountsPerTag[tag]--;
+	
+		// Delink block
+		if (Z_IsTagLinked(tag))
+		{
+			ZoneLinkHeader* linked = (ZoneLinkHeader*)header - 1;
+			
+			if (linked == s_LinkBase)
+			{
+				s_LinkBase = linked->m_Next;
+				if (s_LinkBase)
+				{
+					s_LinkBase->m_Prev = NULL;
+				}
+			}
+			else
+			{
+				if (linked->m_Next)
+				{
+					linked->m_Next->m_Prev = linked->m_Prev;
+				}
+				linked->m_Prev->m_Next = linked->m_Next;
+			}
+
+			assert(Z_ValidateLinks());
+		}
+
+		// Clear the block header for safety
+		*header = 0;
+
+		// Add block to free list
+		ZoneFreeBlock* nblock = NULL;
+		if (real_size < sizeof(ZoneFreeBlock))
+		{
+			// Not enough space in block to put free information --
+			// use overflow buffer.
+			nblock = Z_GetOverflowBlock();
+
+			if (nblock == NULL)
+			{
+				Z_Details_f();
+				Com_Error(ERR_FATAL, "Zone free overflow buffer overflowed!");
+			}
+		}
+		else
+		{
+			// Place free information in block
+			nblock = (ZoneFreeBlock*)((char*)pvAddress - header_size);
+		}
+
+		nblock->m_Address = (unsigned int)pvAddress - header_size;
+		nblock->m_Size = real_size;
+		Z_LinkFreeBlock(nblock);
+
+		// Coalesce any adjacent free blocks
+		Z_Coalasce(nblock);
+#ifndef _GAMECUBE
+		ReleaseMutex(s_Mutex);
+#endif
+	}
+
+	Z_FREE_RETURN( 0 );
+}
+
+
+int Z_MemSize(memtag_t eTag)
+{
+	return s_Stats.m_SizesPerTag[eTag];
+}
+
+#if ZONE_DEBUG
+void Z_FindLeak(void)
+{
+	assert(s_Initialized);
+
+	static int cycle_count = 0;
+	const memtag_t tag = TAG_NEWDEL;
+
+	struct PointerInfo
+	{
+		void* data;
+		int counter;
+		bool mark;
+	};
+	
+	const int max_pointers = 32768;
+	static PointerInfo pointers[max_pointers];
+	static int num_pointers = 0;
+
+	// Clear pointer existance
+	for (int i = 0; i < num_pointers; ++i)
+	{
+		pointers[i].mark = false;
+	}
+	
+	// Add all known pointers
+	int start_num = num_pointers;
+	for (ZoneLinkHeader* link = s_LinkBase; link;)
+	{
+		ZoneHeader* header = (ZoneHeader*)(link + 1);
+		link = link->m_Next;
+		
+		if (Z_GetTag(header) == tag)
+		{
+			// See if the pointer already is in the array
+			bool found = false;
+			for (int k = start_num; k < num_pointers; ++k)
+			{
+				if (pointers[k].data == header)
+				{
+					++pointers[k].counter;
+					pointers[k].mark = true;
+					found = true;
+					break;
+				}
+			}
+
+			// If the pointer is not in the array, add it
+			if (!found)
+			{
+				assert(num_pointers < max_pointers);
+				pointers[num_pointers].data = header;
+				pointers[num_pointers].counter = 0;
+				pointers[num_pointers].mark = true;
+				++num_pointers;
+			}
+		}
+	}
+
+	// Remove pointers that are no longer used
+	for (int j = 0; j < num_pointers; ++j)
+	{
+		if (pointers[j].mark)
+		{
+			if (pointers[j].counter != cycle_count && 
+				pointers[j].counter != cycle_count - 1 && 
+				pointers[j].counter != 0)
+			{
+				Com_Printf("Memory leak: %p\n", pointers[j].data);
+			}
+		}
+		else
+		{
+			int k;
+			for (k = j; k < num_pointers; ++k)
+			{
+				if (pointers[k].mark) break;
+			}
+
+			if (k == num_pointers) break;
+
+			memmove(pointers + j, pointers + k, (num_pointers - k) * sizeof(PointerInfo));
+			num_pointers -= k - j;
+		}
+	}
+
+	++cycle_count;
+}
+#endif
+
+void Z_TagPointers(memtag_t eTag)
+{
+	assert(s_Initialized);
+
+#ifndef _GAMECUBE
+	WaitForSingleObject(s_Mutex, INFINITE);
+#endif
+
+	Com_Printf("Pointers for tag %d:\n", eTag);
+
+	for (ZoneLinkHeader* link = s_LinkBase; link;)
+	{
+		ZoneHeader* header = (ZoneHeader*)(link + 1);
+		link = link->m_Next;
+
+		if (eTag == TAG_ALL || Z_GetTag(header) == eTag)
+		{
+#ifdef _DEBUG
+			Com_Printf("%x - %d\n", ((void*)((char*)header + 
+							sizeof(ZoneHeader) + sizeof(ZoneDebugHeader))),
+					Z_Size(((void*)((char*)header + 
+							sizeof(ZoneHeader) + sizeof(ZoneDebugHeader)))));
+#else
+			Com_Printf("%x - %d\n", (void*)(header + 1),
+					Z_Size((void*)(header + 1)));
+#endif
+		}
+	}
+
+#ifndef _GAMECUBE
+	ReleaseMutex(s_Mutex);
+#endif
+}
+
+void Z_TagFree(memtag_t eTag)
+{
+	assert(s_Initialized);
+
+	for (ZoneLinkHeader* link = s_LinkBase; link;)
+	{
+		ZoneHeader* header = (ZoneHeader*)(link + 1);
+		link = link->m_Next;
+
+		if (eTag == TAG_ALL || Z_GetTag(header) == eTag)
+		{
+#ifdef _DEBUG
+			Z_Free((void*)((char*)header + sizeof(ZoneHeader) + 
+				sizeof(ZoneDebugHeader)));
+#else
+			Z_Free((void*)(header + 1));
+#endif
+		}
+	}
+}
+
+void Z_SetNewDeleteTemporary(bool bTemp)
+{
+	// Catch nested uses that break when unwinding the stack
+	assert(bTemp != s_IsNewDeleteTemp);
+	s_IsNewDeleteTemp = bTemp;
+}
+
+void *S_Malloc( int iSize ) 
+{
+	return Z_Malloc(iSize, TAG_SMALL, qfalse, 0);
+}
+
+int Z_GetLevelMemory(void)
+{
+#ifdef _JK2MP
+	return s_Stats.m_SizesPerTag[TAG_BSP];
+#else
+	return s_Stats.m_SizesPerTag[TAG_HUNKALLOC] +
+		s_Stats.m_SizesPerTag[TAG_HUNKMISCMODELS] +
+		s_Stats.m_SizesPerTag[TAG_BSP];
+#endif
+}
+
+#ifdef _JK2MP
+int Z_GetHunkMemory(void)
+{
+	return s_Stats.m_SizesPerTag[TAG_HUNK_MARK1] +
+		s_Stats.m_SizesPerTag[TAG_HUNK_MARK2] +
+		s_Stats.m_SizesPerTag[TAG_TEMP_HUNKALLOC];
+}
+#endif
+
+int Z_GetTerrainMemory(void)
+{
+	return s_Stats.m_SizesPerTag[TAG_CM_TERRAIN] +
+		s_Stats.m_SizesPerTag[TAG_CM_TERRAIN_TEMP] +
+#ifdef _JK2MP
+		s_Stats.m_SizesPerTag[TAG_TERRAIN] +
+#endif
+		s_Stats.m_SizesPerTag[TAG_R_TERRAIN];
+}
+
+int Z_GetMiscMemory(void)
+{
+	return s_Stats.m_SizeAlloc -
+		(Z_GetLevelMemory() +
+#ifdef _JK2MP
+		Z_GetHunkMemory() +
+#endif
+		Z_GetTerrainMemory() +
+		s_Stats.m_SizesPerTag[TAG_MODEL_GLM] +
+		s_Stats.m_SizesPerTag[TAG_MODEL_GLA] +
+		s_Stats.m_SizesPerTag[TAG_MODEL_MD3] +
+		s_Stats.m_SizesPerTag[TAG_BINK] +
+		s_Stats.m_SizesPerTag[TAG_SND_RAWDATA]);
+}
+
+#ifdef _GAMECUBE
+static int texMemSize = 0;
+#else
+extern int texMemSize;
+#endif
+void Z_CompactStats(void)
+{
+	assert(s_Initialized);
+
+	//This report is conservative.  Divides by 1000 instead of 1024 and
+	//then rounds up.
+	Sys_Log("memory-map.txt", va("**Z_CompactStats Start**\n"));
+	Sys_Log("memory-map.txt", va("map: %s\n", Cvar_VariableString( "mapname" )) );
+
+	Sys_Log("memory-map.txt", va("OV: %d, LVL: %d, GLM: %d, GLA: %d, MD3: %d\n",
+			(s_Stats.m_OverheadAlloc / 1000) + 1,
+			(Z_GetLevelMemory() / 1000) + 1,
+			(s_Stats.m_SizesPerTag[TAG_MODEL_GLM] / 1000) + 1,
+			(s_Stats.m_SizesPerTag[TAG_MODEL_GLA] / 1000) + 1,
+			(s_Stats.m_SizesPerTag[TAG_MODEL_MD3] / 1000) + 1));
+
+	Sys_Log("memory-map.txt", va("TER: %d, SND: %d, TEX: %d, FMV: %d, MSC: %d\n",
+			(Z_GetTerrainMemory() / 1000) + 1,
+			(s_Stats.m_SizesPerTag[TAG_SND_RAWDATA] / 1000) + 1,
+			(texMemSize / 1000) + 1,
+			(s_Stats.m_SizesPerTag[TAG_BINK] / 1000) + 1,
+			(Z_GetMiscMemory() / 1000) + 1));
+
+#ifdef _JK2MP
+	Sys_Log("memory-map.txt", va("HUNK: %d, THUNK: %d\n",
+			((s_Stats.m_SizesPerTag[TAG_HUNK_MARK1] + s_Stats.m_SizesPerTag[TAG_HUNK_MARK2]) / 1000) + 1,
+			(s_Stats.m_SizesPerTag[TAG_TEMP_HUNKALLOC] / 1000) + 1));
+#endif
+
+	Sys_Log("memory-map.txt", va("Free Zone: %d\n", s_Stats.m_SizeFree));
+
+}
+
+
+static void Z_Stats_f(void)
+{
+	assert(s_Initialized);
+	// Display some memory usage summary information...
+
+	Com_Printf("\nThe zone is using %d bytes (%.2fMB) in %d memory blocks\n", 
+		s_Stats.m_SizeAlloc,
+		(float)s_Stats.m_SizeAlloc / 1024.0f / 1024.0f, 
+		s_Stats.m_CountAlloc);
+
+	Com_Printf("Free memory is %d bytes (%.2fMB) in %d memory blocks\n", 
+		s_Stats.m_SizeFree,
+		(float)s_Stats.m_SizeFree / 1024.0f / 1024.0f, 
+		s_Stats.m_CountFree);
+
+	Com_Printf("The zone peaked at %d bytes (%.2fMB)\n", 
+		s_Stats.m_PeakAlloc,
+		(float)s_Stats.m_PeakAlloc / 1024.0f / 1024.0f);
+
+	Com_Printf("The zone overhead is %d bytes (%.2fMB)\n", 
+		s_Stats.m_OverheadAlloc,
+		(float)s_Stats.m_OverheadAlloc / 1024.0f / 1024.0f);
+}
+
+void Z_Details_f(void)
+{
+	assert(s_Initialized);
+	// Display some tag specific information...
+
+	Com_Printf("---------------------------------------------------------------------------\n");
+	Com_Printf("%20s %9s\n","Zone Tag","Bytes");
+	Com_Printf("%20s %9s\n","--------","-----");
+	for (int i=0; i<TAG_COUNT; i++)
+	{
+		int iThisCount = s_Stats.m_CountsPerTag[i];
+		int iThisSize = s_Stats.m_SizesPerTag[i];
+
+		if (iThisCount)
+		{
+			float	fSize		= (float)(iThisSize) / 1024.0f / 1024.0f;
+			int		iSize		= fSize;
+			int		iRemainder 	= 100.0f * (fSize - floor(fSize));
+			Com_Printf("%d %9d (%2d.%02dMB) in %6d blocks (%9d average)\n", 
+				i, iThisSize, iSize, iRemainder, iThisCount, iThisSize / iThisCount);
+		}
+	}
+	Com_Printf("---------------------------------------------------------------------------\n");
+
+	Z_Stats_f();
+}
+
+void Z_DumpMemMap_f(void)
+{
+#	define WRITECHAR(C) \
+		Sys_Log("memmap.txt", C, 1, false);	\
+		cur += 1024;	\
+		if ((++counter) % 81 == 0) Sys_Log("memmap.txt", "\n", 1, false);
+	
+	unsigned int cur = (unsigned int)s_PoolBase;
+	unsigned int counter = 0;
+	for (ZoneFreeBlock* fblock = &s_FreeStart; fblock != &s_FreeEnd; fblock = fblock->m_Next)
+	{
+		while (fblock->m_Address > cur + 1024)
+		{
+			WRITECHAR("*");
+		}
+
+		if (fblock->m_Address > cur && fblock->m_Address < cur + 1024)
+		{
+			WRITECHAR("+");
+		}
+
+		while (fblock->m_Address + fblock->m_Size > cur + 1024)
+		{
+			WRITECHAR("-");
+		}
+
+		if (fblock->m_Address + fblock->m_Size > cur && 
+			fblock->m_Address + fblock->m_Size < cur + 1024)
+		{
+			WRITECHAR("+");
+		}
+	}
+
+	Sys_Log("memmap.txt", "\n");
+}
+
+void Z_DisplayLevelMemory(int size, int surf, int block)
+{
+	Z_DumpMemMap_f();
+
+	//Yes, it should be divided by 1024, but I'm going for a safety margin
+	//by rounding down.
+	//Com_Printf("level memory used: %d KB\n", size / 1000);
+	//Z_CompactStats(size, surf, block);
+	Z_CompactStats();
+}
+
+void Z_DisplayLevelMemory(void)
+{
+#ifdef _GAMECUBE
+	extern void R_SurfMramUsed(int &surface, int &block);
+	int surface, block;
+	R_SurfMramUsed(surface, block);
+	Z_DisplayLevelMemory(Z_GetLevelMemory(), surface, block);
+#else
+	Z_DisplayLevelMemory(Z_GetLevelMemory(), 0, 0);
+#endif
+}
+
+
+/*
+========================
+CopyString
+
+ NOTE:	never write over the memory CopyString returns because
+		memory from a memstatic_t might be returned
+========================
+*/
+char *CopyString( const char *in )
+{
+	struct ZoneSingleChar
+	{
+		ZoneHeader header;
+#ifdef _DEBUG
+		ZoneDebugHeader start;
+#endif
+		char data[2];
+#ifdef _DEBUG
+		ZoneDebugFooter end;
+#endif
+	};
+
+#ifdef _DEBUG
+	static ZoneSingleChar empty = {(TAG_STATIC << 25) | 2, ZONE_MAGIC, "\0", ZONE_MAGIC};
+	static ZoneSingleChar numbers[10] =
+	{
+		{(TAG_STATIC << 25) | 2, ZONE_MAGIC, "0", ZONE_MAGIC},
+		{(TAG_STATIC << 25) | 2, ZONE_MAGIC, "1", ZONE_MAGIC},
+		{(TAG_STATIC << 25) | 2, ZONE_MAGIC, "2", ZONE_MAGIC},
+		{(TAG_STATIC << 25) | 2, ZONE_MAGIC, "3", ZONE_MAGIC},
+		{(TAG_STATIC << 25) | 2, ZONE_MAGIC, "4", ZONE_MAGIC},
+		{(TAG_STATIC << 25) | 2, ZONE_MAGIC, "5", ZONE_MAGIC},
+		{(TAG_STATIC << 25) | 2, ZONE_MAGIC, "6", ZONE_MAGIC},
+		{(TAG_STATIC << 25) | 2, ZONE_MAGIC, "7", ZONE_MAGIC},
+		{(TAG_STATIC << 25) | 2, ZONE_MAGIC, "8", ZONE_MAGIC},
+		{(TAG_STATIC << 25) | 2, ZONE_MAGIC, "9", ZONE_MAGIC},
+	};
+#else
+	static ZoneSingleChar empty = {(TAG_STATIC << 25) | 2, "\0"};
+	static ZoneSingleChar numbers[10] =
+	{
+		{(TAG_STATIC << 25) | 2, "0"},
+		{(TAG_STATIC << 25) | 2, "1"},
+		{(TAG_STATIC << 25) | 2, "2"},
+		{(TAG_STATIC << 25) | 2, "3"},
+		{(TAG_STATIC << 25) | 2, "4"},
+		{(TAG_STATIC << 25) | 2, "5"},
+		{(TAG_STATIC << 25) | 2, "6"},
+		{(TAG_STATIC << 25) | 2, "7"},
+		{(TAG_STATIC << 25) | 2, "8"},
+		{(TAG_STATIC << 25) | 2, "9"},
+	};
+#endif
+
+	char	*out;
+
+	if (!in[0])
+	{
+		return empty.data;
+	}
+	else if (!in[1])
+	{
+		if (in[0] >= '0' && in[0] <= '9')
+		{
+			return numbers[in[0]-'0'].data;
+		}
+	}
+
+	out = (char *) S_Malloc (strlen(in)+1);
+	strcpy (out, in);
+
+//	Z_Label(out,in);
+
+	return out;
+}
+
+void Com_TouchMemory(void)
+{
+	// Stub function. Do nothing.
+	return;
+}
+
+qboolean Z_IsFromZone(void *pvAddress, memtag_t eTag)
+{
+	assert(s_Initialized);
+
+#ifdef _DEBUG
+	ZoneDebugHeader* debug = (ZoneDebugHeader*)pvAddress - 1;
+
+	if (*debug != ZONE_MAGIC)
+	{
+		return qfalse;
+	}
+
+	pvAddress = (void*)debug;
+#endif
+
+	ZoneHeader* header = (ZoneHeader*)pvAddress - 1;
+
+	if (Z_GetTag(header) != eTag)
+	{
+		return qfalse;
+	}
+	
+	return Z_GetSize(header);
+}
+
+
+/*
+   Hunk emulation - PC switched to system similar to ours. I made the remaining
+   changes so that the two are identical.
+*/
+#ifdef _JK2MP
+
+qboolean Com_TheHunkMarkHasBeenMade(void)
+{
+	if (hunk_tag == TAG_HUNK_MARK2)
+	{
+		return qtrue;
+	}
+	return qfalse;
+}
+
+/*
+=================
+Com_InitHunkMemory
+=================
+*/
+void Com_InitHunkMemory(void)
+{
+	hunk_tag = TAG_HUNK_MARK1;
+	Hunk_Clear();
+}
+
+/*
+====================
+Hunk_MemoryRemaining
+====================
+*/
+int Hunk_MemoryRemaining(void)
+{
+	return 0;
+}
+
+/*
+===================
+Hunk_SetMark
+
+The server calls this after the level and game VM have been loaded
+===================
+*/
+void Hunk_SetMark(void)
+{
+	hunk_tag = TAG_HUNK_MARK2;
+}
+
+/*
+=================
+Hunk_ClearToMark
+
+The client calls this before starting a vid_restart or snd_restart
+=================
+*/
+void Hunk_ClearToMark(void)
+{
+	assert(hunk_tag == TAG_HUNK_MARK2); //if this is not true then no mark has been made
+	Z_TagFree(TAG_HUNK_MARK2);
+}
+
+/*
+=================
+Hunk_CheckMark
+=================
+*/
+qboolean Hunk_CheckMark( void )
+{
+	if (hunk_tag != TAG_HUNK_MARK1)
+	{
+		return qtrue;
+	}
+	return qfalse;
+}
+
+/*
+=================
+Hunk_Clear
+
+The server calls this before shutting down or loading a new map
+VVFIXME - PC version does lots of other things in here.
+=================
+*/
+void R_HunkClearCrap(void);
+void Hunk_Clear(void)
+{
+	hunk_tag = TAG_HUNK_MARK1;
+	Z_TagFree(TAG_HUNK_MARK1);
+	Z_TagFree(TAG_HUNK_MARK2);
+
+	R_HunkClearCrap();
+/*
+	Z_TagFree(TAG_HUNKALLOC);
+	Z_TagFree(TAG_BSP_HUNK);
+	Z_TagFree(TAG_BOT_HUNK);
+	Z_TagFree(TAG_RENDERER_HUNK);
+	Z_TagFree(TAG_SKELETON);
+	Z_TagFree(TAG_MODEL_OTHER);
+	Z_TagFree(TAG_MODEL_CHAR);
+	VM_Clear();
+*/
+}
+
+/*
+=================
+Hunk_Alloc
+
+Allocate permanent (until the hunk is cleared) memory
+=================
+*/
+void *Hunk_Alloc(int size, ha_pref preference)
+{
+	return Z_Malloc(size, hunk_tag, qtrue);
+}
+
+/*
+=================
+Hunk_AllocateTempMemory
+
+This is used by the file loading system.
+Multiple files can be loaded in temporary memory.
+When the files-in-use count reaches zero, all temp memory will be deleted
+=================
+*/
+void *Hunk_AllocateTempMemory(int size)
+{
+	// don't bother clearing, because we are going to load a file over it
+	return Z_Malloc(size, TAG_TEMP_HUNKALLOC, qfalse);
+}
+
+/*
+==================
+Hunk_FreeTempMemory
+==================
+*/
+void Hunk_FreeTempMemory(void *buf)
+{
+	Z_Free(buf);
+}
+
+/*
+=================
+Hunk_ClearTempMemory
+
+The temp space is no longer needed.  If we have left more
+touched but unused memory on this side, have future
+permanent allocs use this side.
+=================
+*/
+void Hunk_ClearTempMemory(void)
+{
+	Z_TagFree(TAG_TEMP_HUNKALLOC);
+}
+
+#endif // _JK2MP
+
+/*
+	XTL Replacement functions
+	XMemAlloc
+	XMemFree
+	XMemSize
+
+	Replacing these lets us intercept ALL memory allocation done by the XTL, and lets the
+	Zone take pretty much all available memory at startup
+*/
+/* This still doesn't work. Numrous allocations still use internal functions, so there's
+   little benefit right now.
+
+XBOXAPI
+LPVOID
+WINAPI
+XMemAlloc(SIZE_T dwSize, DWORD dwAllocAttributes)
+{
+	// We always give XTL 16 byte aligned memory
+	return Z_Malloc(dwSize, TAG_XTL, ((PXALLOC_ATTRIBUTES)&dwAllocAttributes)->dwZeroInitialize, 16);
+}
+
+XBOXAPI
+VOID
+WINAPI
+XMemFree(PVOID pAddress, DWORD dwAllocAttributes)
+{
+	Z_Free(pAddress);
+}
+
+XBOXAPI
+SIZE_T
+WINAPI
+XMemSize(PVOID pAddress, DWORD dwAllocAttributes)
+{
+	return Z_Size(pAddress);
+}
+
+*/
diff --git a/codemp/qcommon/z_memman_pc.cpp b/codemp/qcommon/z_memman_pc.cpp
new file mode 100644
index 0000000..d15e5da
--- /dev/null
+++ b/codemp/qcommon/z_memman_pc.cpp
@@ -0,0 +1,832 @@
+// Created 3/13/03 by Brian Osman (VV) - Split Zone/Hunk from common
+
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+#include "platform.h"
+
+////////////////////////////////////////////////
+//
+#ifdef TAGDEF	// itu?
+#undef TAGDEF
+#endif
+#define TAGDEF(blah) #blah
+const static char *psTagStrings[TAG_COUNT+1]=	// +1 because TAG_COUNT will itself become a string here. Oh well.
+{
+	#include "../qcommon/tags.h"
+};
+//
+////////////////////////////////////////////////
+
+static void Z_Details_f(void);
+void CIN_CloseAllVideos();
+
+
+// This handles zone memory allocation.
+// It is a wrapper around malloc with a tag id and a magic number at the start
+
+#define ZONE_MAGIC			0x21436587
+
+typedef struct zoneHeader_s
+{
+		int					iMagic;
+		memtag_t			eTag;
+		int					iSize;
+struct	zoneHeader_s		*pNext;
+struct	zoneHeader_s		*pPrev;
+} zoneHeader_t;
+
+typedef struct 
+{
+	int iMagic;
+
+} zoneTail_t;
+
+static inline zoneTail_t *ZoneTailFromHeader(zoneHeader_t *pHeader)
+{
+	return (zoneTail_t*) ( (char*)pHeader + sizeof(*pHeader) + pHeader->iSize );
+}
+
+#ifdef DETAILED_ZONE_DEBUG_CODE
+map <void*,int> mapAllocatedZones;
+#endif
+
+
+typedef struct zoneStats_s
+{
+	int		iCount;
+	int		iCurrent;
+	int		iPeak;
+
+	// I'm keeping these updated on the fly, since it's quicker for cache-pool
+	//	purposes rather than recalculating each time...
+	//
+	int		iSizesPerTag [TAG_COUNT];	
+	int		iCountsPerTag[TAG_COUNT];	
+
+} zoneStats_t;
+
+typedef struct zone_s
+{
+	zoneStats_t				Stats;
+	zoneHeader_t			Header;
+} zone_t;
+
+cvar_t	*com_validateZone;
+
+zone_t	TheZone = {0};
+
+
+// Scans through the linked list of mallocs and makes sure no data has been overwritten
+
+void Z_Validate(void)
+{	
+	if(!com_validateZone || !com_validateZone->integer)
+	{
+		return;
+	}
+
+	zoneHeader_t *pMemory = TheZone.Header.pNext;
+	while (pMemory)
+	{
+		#ifdef DETAILED_ZONE_DEBUG_CODE
+		// this won't happen here, but wtf?
+		int& iAllocCount = mapAllocatedZones[pMemory];
+		if (iAllocCount <= 0)
+		{
+			Com_Error(ERR_FATAL, "Z_Validate(): Bad block allocation count!");
+			return;
+		}		   
+		#endif
+
+		if(pMemory->iMagic != ZONE_MAGIC)
+		{
+			Com_Error(ERR_FATAL, "Z_Validate(): Corrupt zone header!");
+			return;
+		}
+
+		if (ZoneTailFromHeader(pMemory)->iMagic != ZONE_MAGIC)
+		{
+			Com_Error(ERR_FATAL, "Z_Validate(): Corrupt zone tail!");
+			return;
+		}
+		
+		pMemory = pMemory->pNext;
+	}
+}
+				
+
+
+// static mem blocks to reduce a lot of small zone overhead
+//
+#pragma pack(push)
+#pragma pack(1)
+typedef struct
+{
+	zoneHeader_t	Header;	
+//	byte mem[0];
+	zoneTail_t		Tail;
+} StaticZeroMem_t;
+
+typedef struct
+{
+	zoneHeader_t	Header;	
+	byte mem[2];
+	zoneTail_t		Tail;
+} StaticMem_t;
+#pragma pack(pop)
+
+StaticZeroMem_t gZeroMalloc  =
+	{ {ZONE_MAGIC, TAG_STATIC,0,NULL,NULL},{ZONE_MAGIC}};
+StaticMem_t gEmptyString =
+	{ {ZONE_MAGIC, TAG_STATIC,2,NULL,NULL},'\0','\0',{ZONE_MAGIC}};
+StaticMem_t gNumberString[] = {
+	{ {ZONE_MAGIC, TAG_STATIC,2,NULL,NULL},'0','\0',{ZONE_MAGIC}},
+	{ {ZONE_MAGIC, TAG_STATIC,2,NULL,NULL},'1','\0',{ZONE_MAGIC}},
+	{ {ZONE_MAGIC, TAG_STATIC,2,NULL,NULL},'2','\0',{ZONE_MAGIC}},
+	{ {ZONE_MAGIC, TAG_STATIC,2,NULL,NULL},'3','\0',{ZONE_MAGIC}},
+	{ {ZONE_MAGIC, TAG_STATIC,2,NULL,NULL},'4','\0',{ZONE_MAGIC}},
+	{ {ZONE_MAGIC, TAG_STATIC,2,NULL,NULL},'5','\0',{ZONE_MAGIC}},
+	{ {ZONE_MAGIC, TAG_STATIC,2,NULL,NULL},'6','\0',{ZONE_MAGIC}},
+	{ {ZONE_MAGIC, TAG_STATIC,2,NULL,NULL},'7','\0',{ZONE_MAGIC}},
+	{ {ZONE_MAGIC, TAG_STATIC,2,NULL,NULL},'8','\0',{ZONE_MAGIC}},
+	{ {ZONE_MAGIC, TAG_STATIC,2,NULL,NULL},'9','\0',{ZONE_MAGIC}},
+};
+
+qboolean gbMemFreeupOccured = qfalse;
+void *Z_Malloc(int iSize, memtag_t eTag, qboolean bZeroit /* = qfalse */, int iUnusedAlign /* = 4 */)
+{	
+	gbMemFreeupOccured = qfalse;
+
+	if (iSize == 0)
+	{
+		zoneHeader_t *pMemory = (zoneHeader_t *) &gZeroMalloc;
+		return &pMemory[1];
+	}
+
+	// Add in tracking info
+	//
+	int iRealSize = (iSize + sizeof(zoneHeader_t) + sizeof(zoneTail_t));
+
+	// Allocate a chunk...
+	//
+	zoneHeader_t *pMemory = NULL;
+	while (pMemory == NULL)
+	{
+		#ifdef _WIN32
+		if (gbMemFreeupOccured)
+		{
+			Sleep(1000);	// sleep for a second, so Windows has a chance to shuffle mem to de-swiss-cheese it
+		}
+		#endif
+
+		if (bZeroit) {
+			pMemory = (zoneHeader_t *) calloc ( iRealSize, 1 );
+		} else {
+			pMemory = (zoneHeader_t *) malloc ( iRealSize );
+		}
+		if (!pMemory)
+		{
+			// new bit, if we fail to malloc memory, try dumping some of the cached stuff that's non-vital and try again...
+			//
+
+			// ditch the BSP cache...
+			//
+			extern qboolean CM_DeleteCachedMap(qboolean bGuaranteedOkToDelete);
+			if (CM_DeleteCachedMap(qfalse))
+			{
+				gbMemFreeupOccured = qtrue;
+				continue;		// we've just ditched a whole load of memory, so try again with the malloc
+			}
+
+
+			// ditch any sounds not used on this level...
+			//
+			extern qboolean SND_RegisterAudio_LevelLoadEnd(qboolean bDeleteEverythingNotUsedThisLevel);
+			if (SND_RegisterAudio_LevelLoadEnd(qtrue))
+			{
+				gbMemFreeupOccured = qtrue;
+				continue;		// we've dropped at least one sound, so try again with the malloc
+			}
+
+#ifndef DEDICATED
+			// ditch any image_t's (and associated GL memory) not used on this level...
+			//
+			extern qboolean RE_RegisterImages_LevelLoadEnd(void);
+			if (RE_RegisterImages_LevelLoadEnd())
+			{
+				gbMemFreeupOccured = qtrue;
+				continue;		// we've dropped at least one image, so try again with the malloc
+			}
+#endif
+
+			// ditch the model-binaries cache...  (must be getting desperate here!)
+			//
+			extern qboolean RE_RegisterModels_LevelLoadEnd(qboolean bDeleteEverythingNotUsedThisLevel);
+			if (RE_RegisterModels_LevelLoadEnd(qtrue))
+			{
+				gbMemFreeupOccured = qtrue;
+				continue;
+			}
+
+			// as a last panic measure, dump all the audio memory, but not if we're in the audio loader 
+			//	(which is annoying, but I'm not sure how to ensure we're not dumping any memory needed by the sound
+			//	currently being loaded if that was the case)...
+			//
+			// note that this keeps querying until it's freed up as many bytes as the requested size, but freeing
+			//	several small blocks might not mean that one larger one is satisfiable after freeup, however that'll
+			//	just make it go round again and try for freeing up another bunch of blocks until the total is satisfied 
+			//	again (though this will have freed twice the requested amount in that case), so it'll either work 
+			//	eventually or not free up enough and drop through to the final ERR_DROP. No worries...
+			//
+			extern qboolean gbInsideLoadSound;
+			extern int SND_FreeOldestSound();
+			if (!gbInsideLoadSound)
+			{
+				int iBytesFreed = SND_FreeOldestSound();
+				if (iBytesFreed)
+				{
+					int iTheseBytesFreed = 0;
+					while ( (iTheseBytesFreed = SND_FreeOldestSound()) != 0)
+					{
+						iBytesFreed += iTheseBytesFreed;
+						if (iBytesFreed >= iRealSize)
+							break;	// early opt-out since we've managed to recover enough (mem-contiguity issues aside)
+					}
+					gbMemFreeupOccured = qtrue;
+					continue;
+				}
+			}
+
+			// sigh, dunno what else to try, I guess we'll have to give up and report this as an out-of-mem error...
+			//
+			// findlabel:  "recovermem"
+
+			Com_Printf(S_COLOR_RED"Z_Malloc(): Failed to alloc %d bytes (TAG_%s) !!!!!\n", iSize, psTagStrings[eTag]);
+			Z_Details_f();
+			Com_Error(ERR_FATAL,"(Repeat): Z_Malloc(): Failed to alloc %d bytes (TAG_%s) !!!!!\n", iSize, psTagStrings[eTag]);
+			return NULL;
+		}
+	}
+
+	// Link in
+	pMemory->iMagic	= ZONE_MAGIC;
+	pMemory->eTag	= eTag;
+	pMemory->iSize	= iSize;	
+	pMemory->pNext  = TheZone.Header.pNext;
+	TheZone.Header.pNext = pMemory;
+	if (pMemory->pNext)
+	{
+		pMemory->pNext->pPrev = pMemory;
+	}
+	pMemory->pPrev = &TheZone.Header;
+	//
+	// add tail...
+	//
+	ZoneTailFromHeader(pMemory)->iMagic = ZONE_MAGIC;
+
+	// Update stats...
+	//
+	TheZone.Stats.iCurrent += iSize;
+	TheZone.Stats.iCount++;
+	TheZone.Stats.iSizesPerTag	[eTag] += iSize;
+	TheZone.Stats.iCountsPerTag	[eTag]++;	
+
+	if (TheZone.Stats.iCurrent > TheZone.Stats.iPeak)
+	{
+		TheZone.Stats.iPeak	= TheZone.Stats.iCurrent;
+	}
+
+#ifdef DETAILED_ZONE_DEBUG_CODE
+	mapAllocatedZones[pMemory]++;
+#endif
+	
+	Z_Validate();	// check for corruption
+
+	void *pvReturnMem = &pMemory[1];
+	return pvReturnMem;
+}
+
+// used during model cacheing to save an extra malloc, lets us morph the disk-load buffer then
+//	just not fs_freefile() it afterwards.
+//
+void Z_MorphMallocTag( void *pvAddress, memtag_t eDesiredTag )
+{
+	zoneHeader_t *pMemory = ((zoneHeader_t *)pvAddress) - 1;
+
+	if (pMemory->iMagic != ZONE_MAGIC)
+	{
+		Com_Error(ERR_FATAL, "Z_MorphMallocTag(): Not a valid zone header!");
+		return;	// won't get here
+	}
+
+	// DEC existing tag stats...
+	//
+//	TheZone.Stats.iCurrent	- unchanged
+//	TheZone.Stats.iCount	- unchanged
+	TheZone.Stats.iSizesPerTag	[pMemory->eTag] -= pMemory->iSize;
+	TheZone.Stats.iCountsPerTag	[pMemory->eTag]--;
+
+	// morph...
+	//
+	pMemory->eTag = eDesiredTag;
+
+	// INC new tag stats...
+	//
+//	TheZone.Stats.iCurrent	- unchanged
+//	TheZone.Stats.iCount	- unchanged
+	TheZone.Stats.iSizesPerTag	[pMemory->eTag] += pMemory->iSize;
+	TheZone.Stats.iCountsPerTag	[pMemory->eTag]++;
+}
+
+static void Zone_FreeBlock(zoneHeader_t *pMemory)
+{
+	if (pMemory->eTag != TAG_STATIC)	// belt and braces, should never hit this though
+	{
+		// Update stats...
+		//
+		TheZone.Stats.iCount--;
+		TheZone.Stats.iCurrent -= pMemory->iSize;
+		TheZone.Stats.iSizesPerTag	[pMemory->eTag] -= pMemory->iSize;
+		TheZone.Stats.iCountsPerTag	[pMemory->eTag]--;
+
+		// Sanity checks...
+		//
+		assert(pMemory->pPrev->pNext == pMemory);
+		assert(!pMemory->pNext || (pMemory->pNext->pPrev == pMemory));
+
+		// Unlink and free...
+		//
+		pMemory->pPrev->pNext = pMemory->pNext;
+		if(pMemory->pNext)
+		{
+			pMemory->pNext->pPrev = pMemory->pPrev;
+		}
+		free (pMemory);
+
+		
+		#ifdef DETAILED_ZONE_DEBUG_CODE
+		// this has already been checked for in execution order, but wtf?
+		int& iAllocCount = mapAllocatedZones[pMemory];
+		if (iAllocCount == 0)
+		{
+			Com_Error(ERR_FATAL, "Zone_FreeBlock(): Double-freeing block!");
+			return;
+		}
+		iAllocCount--;	
+		#endif
+	}
+}
+
+// stats-query function to ask how big a malloc is...
+//
+int Z_Size(void *pvAddress)
+{
+	zoneHeader_t *pMemory = ((zoneHeader_t *)pvAddress) - 1;
+
+	if (pMemory->eTag == TAG_STATIC)
+	{
+		return 0;	// kind of
+	}
+
+	if (pMemory->iMagic != ZONE_MAGIC)
+	{
+		Com_Error(ERR_FATAL, "Z_Size(): Not a valid zone header!");
+		return 0;	// won't get here
+	}
+
+	return pMemory->iSize;
+}
+
+
+// Frees a block of memory...
+//
+void Z_Free(void *pvAddress)
+{
+	if (pvAddress == NULL)	// I've put this in as a safety measure because of some bits of #ifdef BSPC stuff	-Ste.
+	{
+		//Com_Error(ERR_FATAL, "Z_Free(): NULL arg");
+		return;		
+	}
+
+	zoneHeader_t *pMemory = ((zoneHeader_t *)pvAddress) - 1;
+
+	if (pMemory->eTag == TAG_STATIC)
+	{
+		return;
+	}
+
+	#ifdef DETAILED_ZONE_DEBUG_CODE
+	//
+	// check this error *before* barfing on bad magics...
+	//
+	int& iAllocCount = mapAllocatedZones[pMemory];
+	if (iAllocCount <= 0)
+	{			
+		Com_Error(ERR_FATAL, "Z_Free(): Block already-freed, or not allocated through Z_Malloc!");
+		return;
+	}		   
+	#endif
+
+	if (pMemory->iMagic != ZONE_MAGIC)
+	{
+		Com_Error(ERR_FATAL, "Z_Free(): Corrupt zone header!");
+		return;
+	}
+	if (ZoneTailFromHeader(pMemory)->iMagic != ZONE_MAGIC)
+	{
+		Com_Error(ERR_FATAL, "Z_Free(): Corrupt zone tail!");
+		return;
+	}
+
+	Zone_FreeBlock(pMemory);
+}
+
+
+int Z_MemSize(memtag_t eTag)
+{
+	return TheZone.Stats.iSizesPerTag[eTag];
+}
+
+// Frees all blocks with the specified tag...
+//
+void Z_TagFree(memtag_t eTag)
+{
+//#ifdef _DEBUG
+//	int iZoneBlocks = TheZone.Stats.iCount;
+//#endif
+
+	zoneHeader_t *pMemory = TheZone.Header.pNext;
+	while (pMemory)
+	{
+		zoneHeader_t *pNext = pMemory->pNext;
+		if ( (eTag == TAG_ALL) || (pMemory->eTag == eTag))
+		{
+			Zone_FreeBlock(pMemory);
+		}
+		pMemory = pNext;
+	}
+
+// these stupid pragmas don't work here???!?!?!
+//
+//#ifdef _DEBUG
+//#pragma warning( disable : 4189)
+//	int iBlocksFreed = iZoneBlocks - TheZone.Stats.iCount;
+//#pragma warning( default : 4189)
+//#endif
+}
+
+
+void *S_Malloc( int iSize ) {
+	return Z_Malloc( iSize, TAG_SMALL );
+}
+
+
+#ifdef _DEBUG
+static void Z_MemRecoverTest_f(void)
+{
+	// needs to be in _DEBUG only, not good for final game! 
+	// fixme: findmeste: Remove this sometime
+	//
+	int iTotalMalloc = 0;
+	while (1)
+	{
+		int iThisMalloc = 5* (1024 * 1024);
+		Z_Malloc(iThisMalloc, TAG_SPECIAL_MEM_TEST, qfalse);	// and lose, just to consume memory
+		iTotalMalloc += iThisMalloc;
+
+		if (gbMemFreeupOccured)
+			break;
+	}
+
+	Z_TagFree(TAG_SPECIAL_MEM_TEST);
+}
+#endif
+
+
+
+// Gives a summary of the zone memory usage
+
+static void Z_Stats_f(void)
+{
+	Com_Printf("\nThe zone is using %d bytes (%.2fMB) in %d memory blocks\n", 
+								  TheZone.Stats.iCurrent, 
+									        (float)TheZone.Stats.iCurrent / 1024.0f / 1024.0f, 
+													  TheZone.Stats.iCount
+				);
+
+	Com_Printf("The zone peaked at %d bytes (%.2fMB)\n", 
+									TheZone.Stats.iPeak, 
+									         (float)TheZone.Stats.iPeak / 1024.0f / 1024.0f
+				);
+}
+
+// Gives a detailed breakdown of the memory blocks in the zone
+
+static void Z_Details_f(void)
+{	
+	Com_Printf("---------------------------------------------------------------------------\n");
+	Com_Printf("%20s %9s\n","Zone Tag","Bytes");
+	Com_Printf("%20s %9s\n","--------","-----");
+	for (int i=0; i<TAG_COUNT; i++)
+	{
+		int iThisCount = TheZone.Stats.iCountsPerTag[i];
+		int iThisSize  = TheZone.Stats.iSizesPerTag	[i];
+
+		if (iThisCount)
+		{
+			// can you believe that using %2.2f as a format specifier doesn't bloody work? 
+			//	It ignores the left-hand specifier. Sigh, now I've got to do shit like this...
+			//
+			float	fSize		= (float)(iThisSize) / 1024.0f / 1024.0f;
+			int		iSize		= fSize;
+			int		iRemainder 	= 100.0f * (fSize - floor(fSize));
+			Com_Printf("%20s %9d (%2d.%02dMB) in %6d blocks (%9d average)\n", 
+					    psTagStrings[i], 
+							  iThisSize, 
+								iSize,iRemainder,
+								           iThisCount, iThisSize / iThisCount
+					   );
+		}
+	}
+	Com_Printf("---------------------------------------------------------------------------\n");
+
+	Z_Stats_f();
+}
+
+// Shuts down the zone memory system and frees up all memory
+void Com_ShutdownZoneMemory(void)
+{
+//	Com_Printf("Shutting down zone memory .....\n");
+
+	Cmd_RemoveCommand("zone_stats");
+	Cmd_RemoveCommand("zone_details");
+
+	if(TheZone.Stats.iCount)
+	{
+		Com_Printf("Automatically freeing %d blocks making up %d bytes\n", TheZone.Stats.iCount, TheZone.Stats.iCurrent);
+		Z_TagFree(TAG_ALL);
+
+		assert(!TheZone.Stats.iCount);
+		assert(!TheZone.Stats.iCurrent);
+	}
+}
+
+// Initialises the zone memory system
+
+void Com_InitZoneMemory( void ) 
+{
+	memset(&TheZone, 0, sizeof(TheZone)); 
+	TheZone.Header.iMagic = ZONE_MAGIC;
+
+//#ifdef _DEBUG
+//	com_validateZone = Cvar_Get("com_validateZone", "1", 0);
+//#else
+	com_validateZone = Cvar_Get("com_validateZone", "0", 0);
+//#endif
+
+	Cmd_AddCommand("zone_stats", Z_Stats_f);
+	Cmd_AddCommand("zone_details", Z_Details_f);
+
+#ifdef _DEBUG
+	Cmd_AddCommand("zone_memrecovertest", Z_MemRecoverTest_f);
+#endif
+}
+
+
+
+
+/*
+========================
+CopyString
+
+ NOTE:	never write over the memory CopyString returns because
+		memory from a memstatic_t might be returned
+========================
+*/
+char *CopyString( const char *in ) {
+	char	*out;
+
+	if (!in[0]) {
+		return ((char *)&gEmptyString) + sizeof(zoneHeader_t);
+	}
+	else if (!in[1]) {
+		if (in[0] >= '0' && in[0] <= '9') {
+			return ((char *)&gNumberString[in[0]-'0']) + sizeof(zoneHeader_t);
+		}
+	}
+
+	out = (char *) S_Malloc (strlen(in)+1);
+	strcpy (out, in);
+	return out;
+}
+
+
+
+static memtag_t hunk_tag;
+
+
+/*
+===============
+Com_TouchMemory
+
+Touch all known used data to make sure it is paged in
+===============
+*/
+void Com_TouchMemory( void ) {
+//	int		start, end;
+	int		i, j;
+	int		sum;
+
+//	start = Sys_Milliseconds();
+	Z_Validate();
+
+	sum = 0;
+
+	zoneHeader_t *pMemory = TheZone.Header.pNext;
+	while (pMemory)
+	{
+		byte *pMem = (byte *) &pMemory[1];
+		j = pMemory->iSize >> 2;
+		for (i=0; i<j; i+=64){
+			sum += ((int*)pMem)[i];
+		}
+		
+		pMemory = pMemory->pNext;
+	}
+
+//	end = Sys_Milliseconds();
+//	Com_Printf( "Com_TouchMemory: %i msec\n", end - start );
+}
+
+
+
+qboolean Com_TheHunkMarkHasBeenMade(void)
+{
+	if (hunk_tag == TAG_HUNK_MARK2)
+	{
+		return qtrue;
+	}
+	return qfalse;
+}
+
+/*
+=================
+Com_InitHunkMemory
+=================
+*/
+void Com_InitHunkMemory( void ) {
+	hunk_tag = TAG_HUNK_MARK1;
+	Hunk_Clear();
+}
+
+void Com_ShutdownHunkMemory(void)
+{
+	//Er, ok. Clear it then I guess.
+	Z_TagFree(TAG_HUNK_MARK1);
+	Z_TagFree(TAG_HUNK_MARK2);
+}
+
+/*
+====================
+Hunk_MemoryRemaining
+====================
+*/
+int	Hunk_MemoryRemaining( void ) {
+	return (64*1024*1024) - (Z_MemSize(TAG_HUNK_MARK1)+Z_MemSize(TAG_HUNK_MARK2));	//Yeah. Whatever. We've got no size now.
+}
+
+/*
+===================
+Hunk_SetMark
+
+The server calls this after the level and game VM have been loaded
+===================
+*/
+void Hunk_SetMark( void ) {
+	hunk_tag = TAG_HUNK_MARK2;
+}
+
+/*
+=================
+Hunk_ClearToMark
+
+The client calls this before starting a vid_restart or snd_restart
+=================
+*/
+void Hunk_ClearToMark( void ) {
+	assert(hunk_tag == TAG_HUNK_MARK2); //if this is not true then no mark has been made
+	Z_TagFree(TAG_HUNK_MARK2);
+}
+
+/*
+=================
+Hunk_CheckMark
+=================
+*/
+qboolean Hunk_CheckMark( void ) {
+	//if( hunk_low.mark || hunk_high.mark ) {
+	if (hunk_tag != TAG_HUNK_MARK1)
+	{
+		return qtrue;
+	}
+	return qfalse;
+}
+
+void CL_ShutdownCGame( void );
+void CL_ShutdownUI( void );
+void SV_ShutdownGameProgs( void );
+
+/*
+=================
+Hunk_Clear
+
+The server calls this before shutting down or loading a new map
+=================
+*/
+void R_HunkClearCrap(void);
+#ifdef _FULL_G2_LEAK_CHECKING
+void G2_DEBUG_ReportLeaks(void);
+#endif
+
+void Hunk_Clear( void ) {
+
+#ifndef DEDICATED
+	CL_ShutdownCGame();
+	CL_ShutdownUI();
+#endif
+	SV_ShutdownGameProgs();
+
+#ifndef DEDICATED
+	CIN_CloseAllVideos();
+#endif
+
+	hunk_tag = TAG_HUNK_MARK1;
+	Z_TagFree(TAG_HUNK_MARK1);
+	Z_TagFree(TAG_HUNK_MARK2);
+
+	R_HunkClearCrap();
+
+//	Com_Printf( "Hunk_Clear: reset the hunk ok\n" );
+	VM_Clear();
+
+//See if any ghoul2 stuff was leaked, at this point it should be all cleaned up.
+#ifdef _FULL_G2_LEAK_CHECKING
+	assert(g_Ghoul2Allocations == 0 && g_G2ClientAlloc == 0 && g_G2ServerAlloc == 0);
+	if (g_Ghoul2Allocations)
+	{
+		Com_Printf("%i bytes leaked by ghoul2 routines (%i client, %i server)\n", g_Ghoul2Allocations, g_G2ClientAlloc, g_G2ServerAlloc);
+		G2_DEBUG_ReportLeaks();
+	}
+#endif
+}
+
+/*
+=================
+Hunk_Alloc
+
+Allocate permanent (until the hunk is cleared) memory
+=================
+*/
+void *Hunk_Alloc( int size, ha_pref preference ) {
+	return Z_Malloc(size, hunk_tag, qtrue);
+}
+
+/*
+=================
+Hunk_AllocateTempMemory
+
+This is used by the file loading system.
+Multiple files can be loaded in temporary memory.
+When the files-in-use count reaches zero, all temp memory will be deleted
+=================
+*/
+void *Hunk_AllocateTempMemory( int size ) {
+	// don't bother clearing, because we are going to load a file over it
+	return Z_Malloc(size, TAG_TEMP_HUNKALLOC, qfalse);
+}
+
+
+/*
+==================
+Hunk_FreeTempMemory
+==================
+*/
+void Hunk_FreeTempMemory( void *buf )
+{
+	Z_Free(buf);
+}
+
+
+/*
+=================
+Hunk_ClearTempMemory
+
+The temp space is no longer needed.  If we have left more
+touched but unused memory on this side, have future
+permanent allocs use this side.
+=================
+*/
+void Hunk_ClearTempMemory( void ) {
+	Z_TagFree(TAG_TEMP_HUNKALLOC);
+}
diff --git a/codemp/renderer/glext.h b/codemp/renderer/glext.h
new file mode 100644
index 0000000..63dbe82
--- /dev/null
+++ b/codemp/renderer/glext.h
@@ -0,0 +1,3037 @@
+#ifndef __glext_h_
+#define __glext_h_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+** License Applicability. Except to the extent portions of this file are
+** made subject to an alternative license as permitted in the SGI Free
+** Software License B, Version 1.1 (the "License"), the contents of this
+** file are subject only to the provisions of the License. You may not use
+** this file except in compliance with the License. You may obtain a copy
+** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+** 
+** http://oss.sgi.com/projects/FreeB
+** 
+** Note that, as provided in the License, the Software is distributed on an
+** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+** 
+** Original Code. The Original Code is: OpenGL Sample Implementation,
+** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+** Copyright in any portions created by third parties is as indicated
+** elsewhere herein. All Rights Reserved.
+** 
+** Additional Notice Provisions: This software was created using the
+** OpenGL(R) version 1.2.1 Sample Implementation published by SGI, but has
+** not been independently verified as being compliant with the OpenGL(R)
+** version 1.2.1 Specification.
+*/
+
+#if defined(_WIN32) && !defined(APIENTRY) && !defined(__CYGWIN__)
+#define WIN32_LEAN_AND_MEAN 1
+#include <windows.h>
+#endif
+
+#ifndef APIENTRY
+#define APIENTRY
+#endif
+
+/*************************************************************/
+
+/* Header file version number, required by OpenGL ABI for Linux */
+#define GL_GLEXT_VERSION 7
+
+#ifndef GL_VERSION_1_2
+#define GL_CONSTANT_COLOR                 0x8001
+#define GL_ONE_MINUS_CONSTANT_COLOR       0x8002
+#define GL_CONSTANT_ALPHA                 0x8003
+#define GL_ONE_MINUS_CONSTANT_ALPHA       0x8004
+#define GL_BLEND_COLOR                    0x8005
+#define GL_FUNC_ADD                       0x8006
+#define GL_MIN                            0x8007
+#define GL_MAX                            0x8008
+#define GL_BLEND_EQUATION                 0x8009
+#define GL_FUNC_SUBTRACT                  0x800A
+#define GL_FUNC_REVERSE_SUBTRACT          0x800B
+#define GL_CONVOLUTION_1D                 0x8010
+#define GL_CONVOLUTION_2D                 0x8011
+#define GL_SEPARABLE_2D                   0x8012
+#define GL_CONVOLUTION_BORDER_MODE        0x8013
+#define GL_CONVOLUTION_FILTER_SCALE       0x8014
+#define GL_CONVOLUTION_FILTER_BIAS        0x8015
+#define GL_REDUCE                         0x8016
+#define GL_CONVOLUTION_FORMAT             0x8017
+#define GL_CONVOLUTION_WIDTH              0x8018
+#define GL_CONVOLUTION_HEIGHT             0x8019
+#define GL_MAX_CONVOLUTION_WIDTH          0x801A
+#define GL_MAX_CONVOLUTION_HEIGHT         0x801B
+#define GL_POST_CONVOLUTION_RED_SCALE     0x801C
+#define GL_POST_CONVOLUTION_GREEN_SCALE   0x801D
+#define GL_POST_CONVOLUTION_BLUE_SCALE    0x801E
+#define GL_POST_CONVOLUTION_ALPHA_SCALE   0x801F
+#define GL_POST_CONVOLUTION_RED_BIAS      0x8020
+#define GL_POST_CONVOLUTION_GREEN_BIAS    0x8021
+#define GL_POST_CONVOLUTION_BLUE_BIAS     0x8022
+#define GL_POST_CONVOLUTION_ALPHA_BIAS    0x8023
+#define GL_HISTOGRAM                      0x8024
+#define GL_PROXY_HISTOGRAM                0x8025
+#define GL_HISTOGRAM_WIDTH                0x8026
+#define GL_HISTOGRAM_FORMAT               0x8027
+#define GL_HISTOGRAM_RED_SIZE             0x8028
+#define GL_HISTOGRAM_GREEN_SIZE           0x8029
+#define GL_HISTOGRAM_BLUE_SIZE            0x802A
+#define GL_HISTOGRAM_ALPHA_SIZE           0x802B
+#define GL_HISTOGRAM_LUMINANCE_SIZE       0x802C
+#define GL_HISTOGRAM_SINK                 0x802D
+#define GL_MINMAX                         0x802E
+#define GL_MINMAX_FORMAT                  0x802F
+#define GL_MINMAX_SINK                    0x8030
+#define GL_TABLE_TOO_LARGE                0x8031
+#define GL_UNSIGNED_BYTE_3_3_2            0x8032
+#define GL_UNSIGNED_SHORT_4_4_4_4         0x8033
+#define GL_UNSIGNED_SHORT_5_5_5_1         0x8034
+#define GL_UNSIGNED_INT_8_8_8_8           0x8035
+#define GL_UNSIGNED_INT_10_10_10_2        0x8036
+#define GL_RESCALE_NORMAL                 0x803A
+#define GL_UNSIGNED_BYTE_2_3_3_REV        0x8362
+#define GL_UNSIGNED_SHORT_5_6_5           0x8363
+#define GL_UNSIGNED_SHORT_5_6_5_REV       0x8364
+#define GL_UNSIGNED_SHORT_4_4_4_4_REV     0x8365
+#define GL_UNSIGNED_SHORT_1_5_5_5_REV     0x8366
+#define GL_UNSIGNED_INT_8_8_8_8_REV       0x8367
+#define GL_UNSIGNED_INT_2_10_10_10_REV    0x8368
+#define GL_COLOR_MATRIX                   0x80B1
+#define GL_COLOR_MATRIX_STACK_DEPTH       0x80B2
+#define GL_MAX_COLOR_MATRIX_STACK_DEPTH   0x80B3
+#define GL_POST_COLOR_MATRIX_RED_SCALE    0x80B4
+#define GL_POST_COLOR_MATRIX_GREEN_SCALE  0x80B5
+#define GL_POST_COLOR_MATRIX_BLUE_SCALE   0x80B6
+#define GL_POST_COLOR_MATRIX_ALPHA_SCALE  0x80B7
+#define GL_POST_COLOR_MATRIX_RED_BIAS     0x80B8
+#define GL_POST_COLOR_MATRIX_GREEN_BIAS   0x80B9
+#define GL_POST_COLOR_MATRIX_BLUE_BIAS    0x80BA
+#define GL_COLOR_TABLE                    0x80D0
+#define GL_POST_CONVOLUTION_COLOR_TABLE   0x80D1
+#define GL_POST_COLOR_MATRIX_COLOR_TABLE  0x80D2
+#define GL_PROXY_COLOR_TABLE              0x80D3
+#define GL_PROXY_POST_CONVOLUTION_COLOR_TABLE 0x80D4
+#define GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE 0x80D5
+#define GL_COLOR_TABLE_SCALE              0x80D6
+#define GL_COLOR_TABLE_BIAS               0x80D7
+#define GL_COLOR_TABLE_FORMAT             0x80D8
+#define GL_COLOR_TABLE_WIDTH              0x80D9
+#define GL_COLOR_TABLE_RED_SIZE           0x80DA
+#define GL_COLOR_TABLE_GREEN_SIZE         0x80DB
+#define GL_COLOR_TABLE_BLUE_SIZE          0x80DC
+#define GL_COLOR_TABLE_ALPHA_SIZE         0x80DD
+#define GL_COLOR_TABLE_LUMINANCE_SIZE     0x80DE
+#define GL_COLOR_TABLE_INTENSITY_SIZE     0x80DF
+#define GL_CLAMP_TO_EDGE                  0x812F
+#define GL_TEXTURE_MIN_LOD                0x813A
+#define GL_TEXTURE_MAX_LOD                0x813B
+#define GL_TEXTURE_BASE_LEVEL             0x813C
+#define GL_TEXTURE_MAX_LEVEL              0x813D
+#endif
+
+#ifndef GL_ARB_multitexture
+#define GL_TEXTURE0_ARB                   0x84C0
+#define GL_TEXTURE1_ARB                   0x84C1
+#define GL_TEXTURE2_ARB                   0x84C2
+#define GL_TEXTURE3_ARB                   0x84C3
+#define GL_TEXTURE4_ARB                   0x84C4
+#define GL_TEXTURE5_ARB                   0x84C5
+#define GL_TEXTURE6_ARB                   0x84C6
+#define GL_TEXTURE7_ARB                   0x84C7
+#define GL_TEXTURE8_ARB                   0x84C8
+#define GL_TEXTURE9_ARB                   0x84C9
+#define GL_TEXTURE10_ARB                  0x84CA
+#define GL_TEXTURE11_ARB                  0x84CB
+#define GL_TEXTURE12_ARB                  0x84CC
+#define GL_TEXTURE13_ARB                  0x84CD
+#define GL_TEXTURE14_ARB                  0x84CE
+#define GL_TEXTURE15_ARB                  0x84CF
+#define GL_TEXTURE16_ARB                  0x84D0
+#define GL_TEXTURE17_ARB                  0x84D1
+#define GL_TEXTURE18_ARB                  0x84D2
+#define GL_TEXTURE19_ARB                  0x84D3
+#define GL_TEXTURE20_ARB                  0x84D4
+#define GL_TEXTURE21_ARB                  0x84D5
+#define GL_TEXTURE22_ARB                  0x84D6
+#define GL_TEXTURE23_ARB                  0x84D7
+#define GL_TEXTURE24_ARB                  0x84D8
+#define GL_TEXTURE25_ARB                  0x84D9
+#define GL_TEXTURE26_ARB                  0x84DA
+#define GL_TEXTURE27_ARB                  0x84DB
+#define GL_TEXTURE28_ARB                  0x84DC
+#define GL_TEXTURE29_ARB                  0x84DD
+#define GL_TEXTURE30_ARB                  0x84DE
+#define GL_TEXTURE31_ARB                  0x84DF
+#define GL_ACTIVE_TEXTURE_ARB             0x84E0
+#define GL_CLIENT_ACTIVE_TEXTURE_ARB      0x84E1
+#define GL_MAX_TEXTURE_UNITS_ARB          0x84E2
+#endif
+
+#ifndef GL_ARB_transpose_matrix
+#define GL_TRANSPOSE_MODELVIEW_MATRIX_ARB 0x84E3
+#define GL_TRANSPOSE_PROJECTION_MATRIX_ARB 0x84E4
+#define GL_TRANSPOSE_TEXTURE_MATRIX_ARB   0x84E5
+#define GL_TRANSPOSE_COLOR_MATRIX_ARB     0x84E6
+#endif
+
+#ifndef GL_ARB_multisample
+#define GL_MULTISAMPLE_ARB                0x809D
+#define GL_SAMPLE_ALPHA_TO_COVERAGE_ARB   0x809E
+#define GL_SAMPLE_ALPHA_TO_ONE_ARB        0x809F
+#define GL_SAMPLE_COVERAGE_ARB            0x80A0
+#define GL_SAMPLE_BUFFERS_ARB             0x80A8
+#define GL_SAMPLES_ARB                    0x80A9
+#define GL_SAMPLE_COVERAGE_VALUE_ARB      0x80AA
+#define GL_SAMPLE_COVERAGE_INVERT_ARB     0x80AB
+#define GL_MULTISAMPLE_BIT_ARB            0x20000000
+#endif
+
+#ifndef GL_ARB_texture_cube_map
+#define GL_NORMAL_MAP_ARB                 0x8511
+#define GL_REFLECTION_MAP_ARB             0x8512
+#define GL_TEXTURE_CUBE_MAP_ARB           0x8513
+#define GL_TEXTURE_BINDING_CUBE_MAP_ARB   0x8514
+#define GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB 0x8515
+#define GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB 0x8516
+#define GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB 0x8517
+#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB 0x8518
+#define GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB 0x8519
+#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB 0x851A
+#define GL_PROXY_TEXTURE_CUBE_MAP_ARB     0x851B
+#define GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB  0x851C
+#endif
+
+#ifndef GL_ARB_texture_compression
+#define GL_COMPRESSED_ALPHA_ARB           0x84E9
+#define GL_COMPRESSED_LUMINANCE_ARB       0x84EA
+#define GL_COMPRESSED_LUMINANCE_ALPHA_ARB 0x84EB
+#define GL_COMPRESSED_INTENSITY_ARB       0x84EC
+#define GL_COMPRESSED_RGB_ARB             0x84ED
+#define GL_COMPRESSED_RGBA_ARB            0x84EE
+#define GL_TEXTURE_COMPRESSION_HINT_ARB   0x84EF
+#define GL_TEXTURE_IMAGE_SIZE_ARB         0x86A0
+#define GL_TEXTURE_COMPRESSED_ARB         0x86A1
+#define GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB 0x86A2
+#define GL_COMPRESSED_TEXTURE_FORMATS_ARB 0x86A3
+#endif
+
+#ifndef GL_ARB_vertex_blend
+#define GL_MAX_VERTEX_UNITS_ARB           0x86A4
+#define GL_ACTIVE_VERTEX_UNITS_ARB        0x86A5
+#define GL_WEIGHT_SUM_UNITY_ARB           0x86A6
+#define GL_VERTEX_BLEND_ARB               0x86A7
+#define GL_CURRENT_WEIGHT_ARB             0x86A8
+#define GL_WEIGHT_ARRAY_TYPE_ARB          0x86A9
+#define GL_WEIGHT_ARRAY_STRIDE_ARB        0x86AA
+#define GL_WEIGHT_ARRAY_SIZE_ARB          0x86AB
+#define GL_WEIGHT_ARRAY_POINTER_ARB       0x86AC
+#define GL_WEIGHT_ARRAY_ARB               0x86AD
+#define GL_MODELVIEW0_ARB                 0x1700
+#define GL_MODELVIEW1_ARB                 0x850A
+#define GL_MODELVIEW2_ARB                 0x8722
+#define GL_MODELVIEW3_ARB                 0x8723
+#define GL_MODELVIEW4_ARB                 0x8724
+#define GL_MODELVIEW5_ARB                 0x8725
+#define GL_MODELVIEW6_ARB                 0x8726
+#define GL_MODELVIEW7_ARB                 0x8727
+#define GL_MODELVIEW8_ARB                 0x8728
+#define GL_MODELVIEW9_ARB                 0x8729
+#define GL_MODELVIEW10_ARB                0x872A
+#define GL_MODELVIEW11_ARB                0x872B
+#define GL_MODELVIEW12_ARB                0x872C
+#define GL_MODELVIEW13_ARB                0x872D
+#define GL_MODELVIEW14_ARB                0x872E
+#define GL_MODELVIEW15_ARB                0x872F
+#define GL_MODELVIEW16_ARB                0x8730
+#define GL_MODELVIEW17_ARB                0x8731
+#define GL_MODELVIEW18_ARB                0x8732
+#define GL_MODELVIEW19_ARB                0x8733
+#define GL_MODELVIEW20_ARB                0x8734
+#define GL_MODELVIEW21_ARB                0x8735
+#define GL_MODELVIEW22_ARB                0x8736
+#define GL_MODELVIEW23_ARB                0x8737
+#define GL_MODELVIEW24_ARB                0x8738
+#define GL_MODELVIEW25_ARB                0x8739
+#define GL_MODELVIEW26_ARB                0x873A
+#define GL_MODELVIEW27_ARB                0x873B
+#define GL_MODELVIEW28_ARB                0x873C
+#define GL_MODELVIEW29_ARB                0x873D
+#define GL_MODELVIEW30_ARB                0x873E
+#define GL_MODELVIEW31_ARB                0x873F
+#endif
+
+#ifndef GL_EXT_abgr
+#define GL_ABGR_EXT                       0x8000
+#endif
+
+#ifndef GL_EXT_blend_color
+#define GL_CONSTANT_COLOR_EXT             0x8001
+#define GL_ONE_MINUS_CONSTANT_COLOR_EXT   0x8002
+#define GL_CONSTANT_ALPHA_EXT             0x8003
+#define GL_ONE_MINUS_CONSTANT_ALPHA_EXT   0x8004
+#define GL_BLEND_COLOR_EXT                0x8005
+#endif
+
+#ifndef GL_EXT_polygon_offset
+#define GL_POLYGON_OFFSET_EXT             0x8037
+#define GL_POLYGON_OFFSET_FACTOR_EXT      0x8038
+#define GL_POLYGON_OFFSET_BIAS_EXT        0x8039
+#endif
+
+#ifndef GL_EXT_texture
+#define GL_ALPHA4_EXT                     0x803B
+#define GL_ALPHA8_EXT                     0x803C
+#define GL_ALPHA12_EXT                    0x803D
+#define GL_ALPHA16_EXT                    0x803E
+#define GL_LUMINANCE4_EXT                 0x803F
+#define GL_LUMINANCE8_EXT                 0x8040
+#define GL_LUMINANCE12_EXT                0x8041
+#define GL_LUMINANCE16_EXT                0x8042
+#define GL_LUMINANCE4_ALPHA4_EXT          0x8043
+#define GL_LUMINANCE6_ALPHA2_EXT          0x8044
+#define GL_LUMINANCE8_ALPHA8_EXT          0x8045
+#define GL_LUMINANCE12_ALPHA4_EXT         0x8046
+#define GL_LUMINANCE12_ALPHA12_EXT        0x8047
+#define GL_LUMINANCE16_ALPHA16_EXT        0x8048
+#define GL_INTENSITY_EXT                  0x8049
+#define GL_INTENSITY4_EXT                 0x804A
+#define GL_INTENSITY8_EXT                 0x804B
+#define GL_INTENSITY12_EXT                0x804C
+#define GL_INTENSITY16_EXT                0x804D
+#define GL_RGB2_EXT                       0x804E
+#define GL_RGB4_EXT                       0x804F
+#define GL_RGB5_EXT                       0x8050
+#define GL_RGB8_EXT                       0x8051
+#define GL_RGB10_EXT                      0x8052
+#define GL_RGB12_EXT                      0x8053
+#define GL_RGB16_EXT                      0x8054
+#define GL_RGBA2_EXT                      0x8055
+#define GL_RGBA4_EXT                      0x8056
+#define GL_RGB5_A1_EXT                    0x8057
+#define GL_RGBA8_EXT                      0x8058
+#define GL_RGB10_A2_EXT                   0x8059
+#define GL_RGBA12_EXT                     0x805A
+#define GL_RGBA16_EXT                     0x805B
+#define GL_TEXTURE_RED_SIZE_EXT           0x805C
+#define GL_TEXTURE_GREEN_SIZE_EXT         0x805D
+#define GL_TEXTURE_BLUE_SIZE_EXT          0x805E
+#define GL_TEXTURE_ALPHA_SIZE_EXT         0x805F
+#define GL_TEXTURE_LUMINANCE_SIZE_EXT     0x8060
+#define GL_TEXTURE_INTENSITY_SIZE_EXT     0x8061
+#define GL_REPLACE_EXT                    0x8062
+#define GL_PROXY_TEXTURE_1D_EXT           0x8063
+#define GL_PROXY_TEXTURE_2D_EXT           0x8064
+#define GL_TEXTURE_TOO_LARGE_EXT          0x8065
+#endif
+
+#ifndef GL_EXT_texture3D
+#define GL_PACK_SKIP_IMAGES               0x806B
+#define GL_PACK_SKIP_IMAGES_EXT           0x806B
+#define GL_PACK_IMAGE_HEIGHT              0x806C
+#define GL_PACK_IMAGE_HEIGHT_EXT          0x806C
+#define GL_UNPACK_SKIP_IMAGES             0x806D
+#define GL_UNPACK_SKIP_IMAGES_EXT         0x806D
+#define GL_UNPACK_IMAGE_HEIGHT            0x806E
+#define GL_UNPACK_IMAGE_HEIGHT_EXT        0x806E
+#define GL_TEXTURE_3D                     0x806F
+#define GL_TEXTURE_3D_EXT                 0x806F
+#define GL_PROXY_TEXTURE_3D               0x8070
+#define GL_PROXY_TEXTURE_3D_EXT           0x8070
+#define GL_TEXTURE_DEPTH                  0x8071
+#define GL_TEXTURE_DEPTH_EXT              0x8071
+#define GL_TEXTURE_WRAP_R                 0x8072
+#define GL_TEXTURE_WRAP_R_EXT             0x8072
+#define GL_MAX_3D_TEXTURE_SIZE            0x8073
+#define GL_MAX_3D_TEXTURE_SIZE_EXT        0x8073
+#endif
+
+#ifndef GL_SGIS_texture_filter4
+#define GL_FILTER4_SGIS                   0x8146
+#define GL_TEXTURE_FILTER4_SIZE_SGIS      0x8147
+#endif
+
+#ifndef GL_EXT_subtexture
+#endif
+
+#ifndef GL_EXT_copy_texture
+#endif
+
+#ifndef GL_EXT_histogram
+#define GL_HISTOGRAM_EXT                  0x8024
+#define GL_PROXY_HISTOGRAM_EXT            0x8025
+#define GL_HISTOGRAM_WIDTH_EXT            0x8026
+#define GL_HISTOGRAM_FORMAT_EXT           0x8027
+#define GL_HISTOGRAM_RED_SIZE_EXT         0x8028
+#define GL_HISTOGRAM_GREEN_SIZE_EXT       0x8029
+#define GL_HISTOGRAM_BLUE_SIZE_EXT        0x802A
+#define GL_HISTOGRAM_ALPHA_SIZE_EXT       0x802B
+#define GL_HISTOGRAM_LUMINANCE_SIZE_EXT   0x802C
+#define GL_HISTOGRAM_SINK_EXT             0x802D
+#define GL_MINMAX_EXT                     0x802E
+#define GL_MINMAX_FORMAT_EXT              0x802F
+#define GL_MINMAX_SINK_EXT                0x8030
+#define GL_TABLE_TOO_LARGE_EXT            0x8031
+#endif
+
+#ifndef GL_EXT_convolution
+#define GL_CONVOLUTION_1D_EXT             0x8010
+#define GL_CONVOLUTION_2D_EXT             0x8011
+#define GL_SEPARABLE_2D_EXT               0x8012
+#define GL_CONVOLUTION_BORDER_MODE_EXT    0x8013
+#define GL_CONVOLUTION_FILTER_SCALE_EXT   0x8014
+#define GL_CONVOLUTION_FILTER_BIAS_EXT    0x8015
+#define GL_REDUCE_EXT                     0x8016
+#define GL_CONVOLUTION_FORMAT_EXT         0x8017
+#define GL_CONVOLUTION_WIDTH_EXT          0x8018
+#define GL_CONVOLUTION_HEIGHT_EXT         0x8019
+#define GL_MAX_CONVOLUTION_WIDTH_EXT      0x801A
+#define GL_MAX_CONVOLUTION_HEIGHT_EXT     0x801B
+#define GL_POST_CONVOLUTION_RED_SCALE_EXT 0x801C
+#define GL_POST_CONVOLUTION_GREEN_SCALE_EXT 0x801D
+#define GL_POST_CONVOLUTION_BLUE_SCALE_EXT 0x801E
+#define GL_POST_CONVOLUTION_ALPHA_SCALE_EXT 0x801F
+#define GL_POST_CONVOLUTION_RED_BIAS_EXT  0x8020
+#define GL_POST_CONVOLUTION_GREEN_BIAS_EXT 0x8021
+#define GL_POST_CONVOLUTION_BLUE_BIAS_EXT 0x8022
+#define GL_POST_CONVOLUTION_ALPHA_BIAS_EXT 0x8023
+#endif
+
+#ifndef GL_SGI_color_matrix
+#define GL_COLOR_MATRIX_SGI               0x80B1
+#define GL_COLOR_MATRIX_STACK_DEPTH_SGI   0x80B2
+#define GL_MAX_COLOR_MATRIX_STACK_DEPTH_SGI 0x80B3
+#define GL_POST_COLOR_MATRIX_RED_SCALE_SGI 0x80B4
+#define GL_POST_COLOR_MATRIX_GREEN_SCALE_SGI 0x80B5
+#define GL_POST_COLOR_MATRIX_BLUE_SCALE_SGI 0x80B6
+#define GL_POST_COLOR_MATRIX_ALPHA_SCALE_SGI 0x80B7
+#define GL_POST_COLOR_MATRIX_RED_BIAS_SGI 0x80B8
+#define GL_POST_COLOR_MATRIX_GREEN_BIAS_SGI 0x80B9
+#define GL_POST_COLOR_MATRIX_BLUE_BIAS_SGI 0x80BA
+#define GL_POST_COLOR_MATRIX_ALPHA_BIAS_SGI 0x80BB
+#endif
+
+#ifndef GL_SGI_color_table
+#define GL_COLOR_TABLE_SGI                0x80D0
+#define GL_POST_CONVOLUTION_COLOR_TABLE_SGI 0x80D1
+#define GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI 0x80D2
+#define GL_PROXY_COLOR_TABLE_SGI          0x80D3
+#define GL_PROXY_POST_CONVOLUTION_COLOR_TABLE_SGI 0x80D4
+#define GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE_SGI 0x80D5
+#define GL_COLOR_TABLE_SCALE_SGI          0x80D6
+#define GL_COLOR_TABLE_BIAS_SGI           0x80D7
+#define GL_COLOR_TABLE_FORMAT_SGI         0x80D8
+#define GL_COLOR_TABLE_WIDTH_SGI          0x80D9
+#define GL_COLOR_TABLE_RED_SIZE_SGI       0x80DA
+#define GL_COLOR_TABLE_GREEN_SIZE_SGI     0x80DB
+#define GL_COLOR_TABLE_BLUE_SIZE_SGI      0x80DC
+#define GL_COLOR_TABLE_ALPHA_SIZE_SGI     0x80DD
+#define GL_COLOR_TABLE_LUMINANCE_SIZE_SGI 0x80DE
+#define GL_COLOR_TABLE_INTENSITY_SIZE_SGI 0x80DF
+#endif
+
+#ifndef GL_SGIS_pixel_texture
+#define GL_PIXEL_TEXTURE_SGIS             0x8353
+#define GL_PIXEL_FRAGMENT_RGB_SOURCE_SGIS 0x8354
+#define GL_PIXEL_FRAGMENT_ALPHA_SOURCE_SGIS 0x8355
+#define GL_PIXEL_GROUP_COLOR_SGIS         0x8356
+#endif
+
+#ifndef GL_SGIX_pixel_texture
+#define GL_PIXEL_TEX_GEN_SGIX             0x8139
+#define GL_PIXEL_TEX_GEN_MODE_SGIX        0x832B
+#endif
+
+#ifndef GL_SGIS_texture4D
+#define GL_PACK_SKIP_VOLUMES_SGIS         0x8130
+#define GL_PACK_IMAGE_DEPTH_SGIS          0x8131
+#define GL_UNPACK_SKIP_VOLUMES_SGIS       0x8132
+#define GL_UNPACK_IMAGE_DEPTH_SGIS        0x8133
+#define GL_TEXTURE_4D_SGIS                0x8134
+#define GL_PROXY_TEXTURE_4D_SGIS          0x8135
+#define GL_TEXTURE_4DSIZE_SGIS            0x8136
+#define GL_TEXTURE_WRAP_Q_SGIS            0x8137
+#define GL_MAX_4D_TEXTURE_SIZE_SGIS       0x8138
+#define GL_TEXTURE_4D_BINDING_SGIS        0x814F
+#endif
+
+#ifndef GL_SGI_texture_color_table
+#define GL_TEXTURE_COLOR_TABLE_SGI        0x80BC
+#define GL_PROXY_TEXTURE_COLOR_TABLE_SGI  0x80BD
+#endif
+
+#ifndef GL_EXT_cmyka
+#define GL_CMYK_EXT                       0x800C
+#define GL_CMYKA_EXT                      0x800D
+#define GL_PACK_CMYK_HINT_EXT             0x800E
+#define GL_UNPACK_CMYK_HINT_EXT           0x800F
+#endif
+
+#ifndef GL_EXT_texture_object
+#define GL_TEXTURE_PRIORITY_EXT           0x8066
+#define GL_TEXTURE_RESIDENT_EXT           0x8067
+#define GL_TEXTURE_1D_BINDING_EXT         0x8068
+#define GL_TEXTURE_2D_BINDING_EXT         0x8069
+#define GL_TEXTURE_3D_BINDING_EXT         0x806A
+#endif
+
+#ifndef GL_SGIS_detail_texture
+#define GL_DETAIL_TEXTURE_2D_SGIS         0x8095
+#define GL_DETAIL_TEXTURE_2D_BINDING_SGIS 0x8096
+#define GL_LINEAR_DETAIL_SGIS             0x8097
+#define GL_LINEAR_DETAIL_ALPHA_SGIS       0x8098
+#define GL_LINEAR_DETAIL_COLOR_SGIS       0x8099
+#define GL_DETAIL_TEXTURE_LEVEL_SGIS      0x809A
+#define GL_DETAIL_TEXTURE_MODE_SGIS       0x809B
+#define GL_DETAIL_TEXTURE_FUNC_POINTS_SGIS 0x809C
+#endif
+
+#ifndef GL_SGIS_sharpen_texture
+#define GL_LINEAR_SHARPEN_SGIS            0x80AD
+#define GL_LINEAR_SHARPEN_ALPHA_SGIS      0x80AE
+#define GL_LINEAR_SHARPEN_COLOR_SGIS      0x80AF
+#define GL_SHARPEN_TEXTURE_FUNC_POINTS_SGIS 0x80B0
+#endif
+
+#ifndef GL_EXT_packed_pixels
+#define GL_UNSIGNED_BYTE_3_3_2_EXT        0x8032
+#define GL_UNSIGNED_SHORT_4_4_4_4_EXT     0x8033
+#define GL_UNSIGNED_SHORT_5_5_5_1_EXT     0x8034
+#define GL_UNSIGNED_INT_8_8_8_8_EXT       0x8035
+#define GL_UNSIGNED_INT_10_10_10_2_EXT    0x8036
+#endif
+
+#ifndef GL_SGIS_texture_lod
+#define GL_TEXTURE_MIN_LOD_SGIS           0x813A
+#define GL_TEXTURE_MAX_LOD_SGIS           0x813B
+#define GL_TEXTURE_BASE_LEVEL_SGIS        0x813C
+#define GL_TEXTURE_MAX_LEVEL_SGIS         0x813D
+#endif
+
+#ifndef GL_SGIS_multisample
+#define GL_MULTISAMPLE_SGIS               0x809D
+#define GL_SAMPLE_ALPHA_TO_MASK_SGIS      0x809E
+#define GL_SAMPLE_ALPHA_TO_ONE_SGIS       0x809F
+#define GL_SAMPLE_MASK_SGIS               0x80A0
+#define GL_1PASS_SGIS                     0x80A1
+#define GL_2PASS_0_SGIS                   0x80A2
+#define GL_2PASS_1_SGIS                   0x80A3
+#define GL_4PASS_0_SGIS                   0x80A4
+#define GL_4PASS_1_SGIS                   0x80A5
+#define GL_4PASS_2_SGIS                   0x80A6
+#define GL_4PASS_3_SGIS                   0x80A7
+#define GL_SAMPLE_BUFFERS_SGIS            0x80A8
+#define GL_SAMPLES_SGIS                   0x80A9
+#define GL_SAMPLE_MASK_VALUE_SGIS         0x80AA
+#define GL_SAMPLE_MASK_INVERT_SGIS        0x80AB
+#define GL_SAMPLE_PATTERN_SGIS            0x80AC
+#endif
+
+#ifndef GL_EXT_rescale_normal
+#define GL_RESCALE_NORMAL_EXT             0x803A
+#endif
+
+#ifndef GL_EXT_vertex_array
+#define GL_VERTEX_ARRAY_EXT               0x8074
+#define GL_NORMAL_ARRAY_EXT               0x8075
+#define GL_COLOR_ARRAY_EXT                0x8076
+#define GL_INDEX_ARRAY_EXT                0x8077
+#define GL_TEXTURE_COORD_ARRAY_EXT        0x8078
+#define GL_EDGE_FLAG_ARRAY_EXT            0x8079
+#define GL_VERTEX_ARRAY_SIZE_EXT          0x807A
+#define GL_VERTEX_ARRAY_TYPE_EXT          0x807B
+#define GL_VERTEX_ARRAY_STRIDE_EXT        0x807C
+#define GL_VERTEX_ARRAY_COUNT_EXT         0x807D
+#define GL_NORMAL_ARRAY_TYPE_EXT          0x807E
+#define GL_NORMAL_ARRAY_STRIDE_EXT        0x807F
+#define GL_NORMAL_ARRAY_COUNT_EXT         0x8080
+#define GL_COLOR_ARRAY_SIZE_EXT           0x8081
+#define GL_COLOR_ARRAY_TYPE_EXT           0x8082
+#define GL_COLOR_ARRAY_STRIDE_EXT         0x8083
+#define GL_COLOR_ARRAY_COUNT_EXT          0x8084
+#define GL_INDEX_ARRAY_TYPE_EXT           0x8085
+#define GL_INDEX_ARRAY_STRIDE_EXT         0x8086
+#define GL_INDEX_ARRAY_COUNT_EXT          0x8087
+#define GL_TEXTURE_COORD_ARRAY_SIZE_EXT   0x8088
+#define GL_TEXTURE_COORD_ARRAY_TYPE_EXT   0x8089
+#define GL_TEXTURE_COORD_ARRAY_STRIDE_EXT 0x808A
+#define GL_TEXTURE_COORD_ARRAY_COUNT_EXT  0x808B
+#define GL_EDGE_FLAG_ARRAY_STRIDE_EXT     0x808C
+#define GL_EDGE_FLAG_ARRAY_COUNT_EXT      0x808D
+#define GL_VERTEX_ARRAY_POINTER_EXT       0x808E
+#define GL_NORMAL_ARRAY_POINTER_EXT       0x808F
+#define GL_COLOR_ARRAY_POINTER_EXT        0x8090
+#define GL_INDEX_ARRAY_POINTER_EXT        0x8091
+#define GL_TEXTURE_COORD_ARRAY_POINTER_EXT 0x8092
+#define GL_EDGE_FLAG_ARRAY_POINTER_EXT    0x8093
+#endif
+
+#ifndef GL_EXT_misc_attribute
+#endif
+
+#ifndef GL_SGIS_generate_mipmap
+#define GL_GENERATE_MIPMAP_SGIS           0x8191
+#define GL_GENERATE_MIPMAP_HINT_SGIS      0x8192
+#endif
+
+#ifndef GL_SGIX_clipmap
+#define GL_LINEAR_CLIPMAP_LINEAR_SGIX     0x8170
+#define GL_TEXTURE_CLIPMAP_CENTER_SGIX    0x8171
+#define GL_TEXTURE_CLIPMAP_FRAME_SGIX     0x8172
+#define GL_TEXTURE_CLIPMAP_OFFSET_SGIX    0x8173
+#define GL_TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX 0x8174
+#define GL_TEXTURE_CLIPMAP_LOD_OFFSET_SGIX 0x8175
+#define GL_TEXTURE_CLIPMAP_DEPTH_SGIX     0x8176
+#define GL_MAX_CLIPMAP_DEPTH_SGIX         0x8177
+#define GL_MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX 0x8178
+#define GL_NEAREST_CLIPMAP_NEAREST_SGIX   0x844D
+#define GL_NEAREST_CLIPMAP_LINEAR_SGIX    0x844E
+#define GL_LINEAR_CLIPMAP_NEAREST_SGIX    0x844F
+#endif
+
+#ifndef GL_SGIX_shadow
+#define GL_TEXTURE_COMPARE_SGIX           0x819A
+#define GL_TEXTURE_COMPARE_OPERATOR_SGIX  0x819B
+#define GL_TEXTURE_LEQUAL_R_SGIX          0x819C
+#define GL_TEXTURE_GEQUAL_R_SGIX          0x819D
+#endif
+
+#ifndef GL_SGIS_texture_edge_clamp
+#define GL_CLAMP_TO_EDGE_SGIS             0x812F
+#endif
+
+#ifndef GL_SGIS_texture_border_clamp
+#define GL_CLAMP_TO_BORDER_SGIS           0x812D
+#endif
+
+#ifndef GL_EXT_blend_minmax
+#define GL_FUNC_ADD_EXT                   0x8006
+#define GL_MIN_EXT                        0x8007
+#define GL_MAX_EXT                        0x8008
+#define GL_BLEND_EQUATION_EXT             0x8009
+#endif
+
+#ifndef GL_EXT_blend_subtract
+#define GL_FUNC_SUBTRACT_EXT              0x800A
+#define GL_FUNC_REVERSE_SUBTRACT_EXT      0x800B
+#endif
+
+#ifndef GL_EXT_blend_logic_op
+#endif
+
+#ifndef GL_SGIX_interlace
+#define GL_INTERLACE_SGIX                 0x8094
+#endif
+
+#ifndef GL_SGIX_pixel_tiles
+#define GL_PIXEL_TILE_BEST_ALIGNMENT_SGIX 0x813E
+#define GL_PIXEL_TILE_CACHE_INCREMENT_SGIX 0x813F
+#define GL_PIXEL_TILE_WIDTH_SGIX          0x8140
+#define GL_PIXEL_TILE_HEIGHT_SGIX         0x8141
+#define GL_PIXEL_TILE_GRID_WIDTH_SGIX     0x8142
+#define GL_PIXEL_TILE_GRID_HEIGHT_SGIX    0x8143
+#define GL_PIXEL_TILE_GRID_DEPTH_SGIX     0x8144
+#define GL_PIXEL_TILE_CACHE_SIZE_SGIX     0x8145
+#endif
+
+#ifndef GL_SGIS_texture_select
+#define GL_DUAL_ALPHA4_SGIS               0x8110
+#define GL_DUAL_ALPHA8_SGIS               0x8111
+#define GL_DUAL_ALPHA12_SGIS              0x8112
+#define GL_DUAL_ALPHA16_SGIS              0x8113
+#define GL_DUAL_LUMINANCE4_SGIS           0x8114
+#define GL_DUAL_LUMINANCE8_SGIS           0x8115
+#define GL_DUAL_LUMINANCE12_SGIS          0x8116
+#define GL_DUAL_LUMINANCE16_SGIS          0x8117
+#define GL_DUAL_INTENSITY4_SGIS           0x8118
+#define GL_DUAL_INTENSITY8_SGIS           0x8119
+#define GL_DUAL_INTENSITY12_SGIS          0x811A
+#define GL_DUAL_INTENSITY16_SGIS          0x811B
+#define GL_DUAL_LUMINANCE_ALPHA4_SGIS     0x811C
+#define GL_DUAL_LUMINANCE_ALPHA8_SGIS     0x811D
+#define GL_QUAD_ALPHA4_SGIS               0x811E
+#define GL_QUAD_ALPHA8_SGIS               0x811F
+#define GL_QUAD_LUMINANCE4_SGIS           0x8120
+#define GL_QUAD_LUMINANCE8_SGIS           0x8121
+#define GL_QUAD_INTENSITY4_SGIS           0x8122
+#define GL_QUAD_INTENSITY8_SGIS           0x8123
+#define GL_DUAL_TEXTURE_SELECT_SGIS       0x8124
+#define GL_QUAD_TEXTURE_SELECT_SGIS       0x8125
+#endif
+
+#ifndef GL_SGIX_sprite
+#define GL_SPRITE_SGIX                    0x8148
+#define GL_SPRITE_MODE_SGIX               0x8149
+#define GL_SPRITE_AXIS_SGIX               0x814A
+#define GL_SPRITE_TRANSLATION_SGIX        0x814B
+#define GL_SPRITE_AXIAL_SGIX              0x814C
+#define GL_SPRITE_OBJECT_ALIGNED_SGIX     0x814D
+#define GL_SPRITE_EYE_ALIGNED_SGIX        0x814E
+#endif
+
+#ifndef GL_SGIX_texture_multi_buffer
+#define GL_TEXTURE_MULTI_BUFFER_HINT_SGIX 0x812E
+#endif
+
+#ifndef GL_SGIS_point_parameters
+#define GL_POINT_SIZE_MIN_EXT             0x8126
+#define GL_POINT_SIZE_MIN_SGIS            0x8126
+#define GL_POINT_SIZE_MAX_EXT             0x8127
+#define GL_POINT_SIZE_MAX_SGIS            0x8127
+#define GL_POINT_FADE_THRESHOLD_SIZE_EXT  0x8128
+#define GL_POINT_FADE_THRESHOLD_SIZE_SGIS 0x8128
+#define GL_DISTANCE_ATTENUATION_EXT       0x8129
+#define GL_DISTANCE_ATTENUATION_SGIS      0x8129
+#endif
+
+#ifndef GL_SGIX_instruments
+#define GL_INSTRUMENT_BUFFER_POINTER_SGIX 0x8180
+#define GL_INSTRUMENT_MEASUREMENTS_SGIX   0x8181
+#endif
+
+#ifndef GL_SGIX_texture_scale_bias
+#define GL_POST_TEXTURE_FILTER_BIAS_SGIX  0x8179
+#define GL_POST_TEXTURE_FILTER_SCALE_SGIX 0x817A
+#define GL_POST_TEXTURE_FILTER_BIAS_RANGE_SGIX 0x817B
+#define GL_POST_TEXTURE_FILTER_SCALE_RANGE_SGIX 0x817C
+#endif
+
+#ifndef GL_SGIX_framezoom
+#define GL_FRAMEZOOM_SGIX                 0x818B
+#define GL_FRAMEZOOM_FACTOR_SGIX          0x818C
+#define GL_MAX_FRAMEZOOM_FACTOR_SGIX      0x818D
+#endif
+
+#ifndef GL_SGIX_tag_sample_buffer
+#endif
+
+#ifndef GL_FfdMaskSGIX
+#define GL_TEXTURE_DEFORMATION_BIT_SGIX   0x00000001
+#define GL_GEOMETRY_DEFORMATION_BIT_SGIX  0x00000002
+#endif
+
+#ifndef GL_SGIX_polynomial_ffd
+#define GL_GEOMETRY_DEFORMATION_SGIX      0x8194
+#define GL_TEXTURE_DEFORMATION_SGIX       0x8195
+#define GL_DEFORMATIONS_MASK_SGIX         0x8196
+#define GL_MAX_DEFORMATION_ORDER_SGIX     0x8197
+#endif
+
+#ifndef GL_SGIX_reference_plane
+#define GL_REFERENCE_PLANE_SGIX           0x817D
+#define GL_REFERENCE_PLANE_EQUATION_SGIX  0x817E
+#endif
+
+#ifndef GL_SGIX_flush_raster
+#endif
+
+#ifndef GL_SGIX_depth_texture
+#define GL_DEPTH_COMPONENT16_SGIX         0x81A5
+#define GL_DEPTH_COMPONENT24_SGIX         0x81A6
+#define GL_DEPTH_COMPONENT32_SGIX         0x81A7
+#endif
+
+#ifndef GL_SGIS_fog_function
+#define GL_FOG_FUNC_SGIS                  0x812A
+#define GL_FOG_FUNC_POINTS_SGIS           0x812B
+#define GL_MAX_FOG_FUNC_POINTS_SGIS       0x812C
+#endif
+
+#ifndef GL_SGIX_fog_offset
+#define GL_FOG_OFFSET_SGIX                0x8198
+#define GL_FOG_OFFSET_VALUE_SGIX          0x8199
+#endif
+
+#ifndef GL_HP_image_transform
+#define GL_IMAGE_SCALE_X_HP               0x8155
+#define GL_IMAGE_SCALE_Y_HP               0x8156
+#define GL_IMAGE_TRANSLATE_X_HP           0x8157
+#define GL_IMAGE_TRANSLATE_Y_HP           0x8158
+#define GL_IMAGE_ROTATE_ANGLE_HP          0x8159
+#define GL_IMAGE_ROTATE_ORIGIN_X_HP       0x815A
+#define GL_IMAGE_ROTATE_ORIGIN_Y_HP       0x815B
+#define GL_IMAGE_MAG_FILTER_HP            0x815C
+#define GL_IMAGE_MIN_FILTER_HP            0x815D
+#define GL_IMAGE_CUBIC_WEIGHT_HP          0x815E
+#define GL_CUBIC_HP                       0x815F
+#define GL_AVERAGE_HP                     0x8160
+#define GL_IMAGE_TRANSFORM_2D_HP          0x8161
+#define GL_POST_IMAGE_TRANSFORM_COLOR_TABLE_HP 0x8162
+#define GL_PROXY_POST_IMAGE_TRANSFORM_COLOR_TABLE_HP 0x8163
+#endif
+
+#ifndef GL_HP_convolution_border_modes
+#define GL_IGNORE_BORDER_HP               0x8150
+#define GL_CONSTANT_BORDER_HP             0x8151
+#define GL_REPLICATE_BORDER_HP            0x8153
+#define GL_CONVOLUTION_BORDER_COLOR_HP    0x8154
+#endif
+
+#ifndef GL_INGR_palette_buffer
+#endif
+
+#ifndef GL_SGIX_texture_add_env
+#define GL_TEXTURE_ENV_BIAS_SGIX          0x80BE
+#endif
+
+#ifndef GL_EXT_color_subtable
+#endif
+
+#ifndef GL_PGI_vertex_hints
+#define GL_VERTEX_DATA_HINT_PGI           0x1A22A
+#define GL_VERTEX_CONSISTENT_HINT_PGI     0x1A22B
+#define GL_MATERIAL_SIDE_HINT_PGI         0x1A22C
+#define GL_MAX_VERTEX_HINT_PGI            0x1A22D
+#define GL_COLOR3_BIT_PGI                 0x00010000
+#define GL_COLOR4_BIT_PGI                 0x00020000
+#define GL_EDGEFLAG_BIT_PGI               0x00040000
+#define GL_INDEX_BIT_PGI                  0x00080000
+#define GL_MAT_AMBIENT_BIT_PGI            0x00100000
+#define GL_MAT_AMBIENT_AND_DIFFUSE_BIT_PGI 0x00200000
+#define GL_MAT_DIFFUSE_BIT_PGI            0x00400000
+#define GL_MAT_EMISSION_BIT_PGI           0x00800000
+#define GL_MAT_COLOR_INDEXES_BIT_PGI      0x01000000
+#define GL_MAT_SHININESS_BIT_PGI          0x02000000
+#define GL_MAT_SPECULAR_BIT_PGI           0x04000000
+#define GL_NORMAL_BIT_PGI                 0x08000000
+#define GL_TEXCOORD1_BIT_PGI              0x10000000
+#define GL_TEXCOORD2_BIT_PGI              0x20000000
+#define GL_TEXCOORD3_BIT_PGI              0x40000000
+#define GL_TEXCOORD4_BIT_PGI              0x80000000
+#define GL_VERTEX23_BIT_PGI               0x00000004
+#define GL_VERTEX4_BIT_PGI                0x00000008
+#endif
+
+#ifndef GL_PGI_misc_hints
+#define GL_PREFER_DOUBLEBUFFER_HINT_PGI   0x1A1F8
+#define GL_CONSERVE_MEMORY_HINT_PGI       0x1A1FD
+#define GL_RECLAIM_MEMORY_HINT_PGI        0x1A1FE
+#define GL_NATIVE_GRAPHICS_HANDLE_PGI     0x1A202
+#define GL_NATIVE_GRAPHICS_BEGIN_HINT_PGI 0x1A203
+#define GL_NATIVE_GRAPHICS_END_HINT_PGI   0x1A204
+#define GL_ALWAYS_FAST_HINT_PGI           0x1A20C
+#define GL_ALWAYS_SOFT_HINT_PGI           0x1A20D
+#define GL_ALLOW_DRAW_OBJ_HINT_PGI        0x1A20E
+#define GL_ALLOW_DRAW_WIN_HINT_PGI        0x1A20F
+#define GL_ALLOW_DRAW_FRG_HINT_PGI        0x1A210
+#define GL_ALLOW_DRAW_MEM_HINT_PGI        0x1A211
+#define GL_STRICT_DEPTHFUNC_HINT_PGI      0x1A216
+#define GL_STRICT_LIGHTING_HINT_PGI       0x1A217
+#define GL_STRICT_SCISSOR_HINT_PGI        0x1A218
+#define GL_FULL_STIPPLE_HINT_PGI          0x1A219
+#define GL_CLIP_NEAR_HINT_PGI             0x1A220
+#define GL_CLIP_FAR_HINT_PGI              0x1A221
+#define GL_WIDE_LINE_HINT_PGI             0x1A222
+#define GL_BACK_NORMALS_HINT_PGI          0x1A223
+#endif
+
+#ifndef GL_EXT_paletted_texture
+#define GL_COLOR_INDEX1_EXT               0x80E2
+#define GL_COLOR_INDEX2_EXT               0x80E3
+#define GL_COLOR_INDEX4_EXT               0x80E4
+#define GL_COLOR_INDEX8_EXT               0x80E5
+#define GL_COLOR_INDEX12_EXT              0x80E6
+#define GL_COLOR_INDEX16_EXT              0x80E7
+#define GL_TEXTURE_INDEX_SIZE_EXT         0x80ED
+#endif
+
+#ifndef GL_EXT_clip_volume_hint
+#define GL_CLIP_VOLUME_CLIPPING_HINT_EXT  0x80F0
+#endif
+
+#ifndef GL_SGIX_list_priority
+#define GL_LIST_PRIORITY_SGIX             0x8182
+#endif
+
+#ifndef GL_SGIX_ir_instrument1
+#define GL_IR_INSTRUMENT1_SGIX            0x817F
+#endif
+
+#ifndef GL_SGIX_calligraphic_fragment
+#define GL_CALLIGRAPHIC_FRAGMENT_SGIX     0x8183
+#endif
+
+#ifndef GL_SGIX_texture_lod_bias
+#define GL_TEXTURE_LOD_BIAS_S_SGIX        0x818E
+#define GL_TEXTURE_LOD_BIAS_T_SGIX        0x818F
+#define GL_TEXTURE_LOD_BIAS_R_SGIX        0x8190
+#endif
+
+#ifndef GL_SGIX_shadow_ambient
+#define GL_SHADOW_AMBIENT_SGIX            0x80BF
+#endif
+
+#ifndef GL_EXT_index_texture
+#endif
+
+#ifndef GL_EXT_index_material
+#define GL_INDEX_MATERIAL_EXT             0x81B8
+#define GL_INDEX_MATERIAL_PARAMETER_EXT   0x81B9
+#define GL_INDEX_MATERIAL_FACE_EXT        0x81BA
+#endif
+
+#ifndef GL_EXT_index_func
+#define GL_INDEX_TEST_EXT                 0x81B5
+#define GL_INDEX_TEST_FUNC_EXT            0x81B6
+#define GL_INDEX_TEST_REF_EXT             0x81B7
+#endif
+
+#ifndef GL_EXT_index_array_formats
+#define GL_IUI_V2F_EXT                    0x81AD
+#define GL_IUI_V3F_EXT                    0x81AE
+#define GL_IUI_N3F_V2F_EXT                0x81AF
+#define GL_IUI_N3F_V3F_EXT                0x81B0
+#define GL_T2F_IUI_V2F_EXT                0x81B1
+#define GL_T2F_IUI_V3F_EXT                0x81B2
+#define GL_T2F_IUI_N3F_V2F_EXT            0x81B3
+#define GL_T2F_IUI_N3F_V3F_EXT            0x81B4
+#endif
+
+#ifndef GL_EXT_compiled_vertex_array
+#define GL_ARRAY_ELEMENT_LOCK_FIRST_EXT   0x81A8
+#define GL_ARRAY_ELEMENT_LOCK_COUNT_EXT   0x81A9
+#endif
+
+#ifndef GL_EXT_cull_vertex
+#define GL_CULL_VERTEX_EXT                0x81AA
+#define GL_CULL_VERTEX_EYE_POSITION_EXT   0x81AB
+#define GL_CULL_VERTEX_OBJECT_POSITION_EXT 0x81AC
+#endif
+
+#ifndef GL_SGIX_ycrcb
+#define GL_YCRCB_422_SGIX                 0x81BB
+#define GL_YCRCB_444_SGIX                 0x81BC
+#endif
+
+#ifndef GL_SGIX_fragment_lighting
+#define GL_FRAGMENT_LIGHTING_SGIX         0x8400
+#define GL_FRAGMENT_COLOR_MATERIAL_SGIX   0x8401
+#define GL_FRAGMENT_COLOR_MATERIAL_FACE_SGIX 0x8402
+#define GL_FRAGMENT_COLOR_MATERIAL_PARAMETER_SGIX 0x8403
+#define GL_MAX_FRAGMENT_LIGHTS_SGIX       0x8404
+#define GL_MAX_ACTIVE_LIGHTS_SGIX         0x8405
+#define GL_CURRENT_RASTER_NORMAL_SGIX     0x8406
+#define GL_LIGHT_ENV_MODE_SGIX            0x8407
+#define GL_FRAGMENT_LIGHT_MODEL_LOCAL_VIEWER_SGIX 0x8408
+#define GL_FRAGMENT_LIGHT_MODEL_TWO_SIDE_SGIX 0x8409
+#define GL_FRAGMENT_LIGHT_MODEL_AMBIENT_SGIX 0x840A
+#define GL_FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION_SGIX 0x840B
+#define GL_FRAGMENT_LIGHT0_SGIX           0x840C
+#define GL_FRAGMENT_LIGHT1_SGIX           0x840D
+#define GL_FRAGMENT_LIGHT2_SGIX           0x840E
+#define GL_FRAGMENT_LIGHT3_SGIX           0x840F
+#define GL_FRAGMENT_LIGHT4_SGIX           0x8410
+#define GL_FRAGMENT_LIGHT5_SGIX           0x8411
+#define GL_FRAGMENT_LIGHT6_SGIX           0x8412
+#define GL_FRAGMENT_LIGHT7_SGIX           0x8413
+#endif
+
+#ifndef GL_IBM_rasterpos_clip
+#define GL_RASTER_POSITION_UNCLIPPED_IBM  0x19262
+#endif
+
+#ifndef GL_HP_texture_lighting
+#define GL_TEXTURE_LIGHTING_MODE_HP       0x8167
+#define GL_TEXTURE_POST_SPECULAR_HP       0x8168
+#define GL_TEXTURE_PRE_SPECULAR_HP        0x8169
+#endif
+
+#ifndef GL_EXT_draw_range_elements
+#define GL_MAX_ELEMENTS_VERTICES_EXT      0x80E8
+#define GL_MAX_ELEMENTS_INDICES_EXT       0x80E9
+#endif
+
+#ifndef GL_WIN_phong_shading
+#define GL_PHONG_WIN                      0x80EA
+#define GL_PHONG_HINT_WIN                 0x80EB
+#endif
+
+#ifndef GL_WIN_specular_fog
+#define GL_FOG_SPECULAR_TEXTURE_WIN       0x80EC
+#endif
+
+#ifndef GL_EXT_light_texture
+#define GL_FRAGMENT_MATERIAL_EXT          0x8349
+#define GL_FRAGMENT_NORMAL_EXT            0x834A
+#define GL_FRAGMENT_COLOR_EXT             0x834C
+#define GL_ATTENUATION_EXT                0x834D
+#define GL_SHADOW_ATTENUATION_EXT         0x834E
+#define GL_TEXTURE_APPLICATION_MODE_EXT   0x834F
+#define GL_TEXTURE_LIGHT_EXT              0x8350
+#define GL_TEXTURE_MATERIAL_FACE_EXT      0x8351
+#define GL_TEXTURE_MATERIAL_PARAMETER_EXT 0x8352
+/* reuse GL_FRAGMENT_DEPTH_EXT */
+#endif
+
+#ifndef GL_SGIX_blend_alpha_minmax
+#define GL_ALPHA_MIN_SGIX                 0x8320
+#define GL_ALPHA_MAX_SGIX                 0x8321
+#endif
+
+#ifndef GL_EXT_bgra
+#define GL_BGR_EXT                        0x80E0
+#define GL_BGRA_EXT                       0x80E1
+#endif
+
+#ifndef GL_SGIX_async
+#define GL_ASYNC_MARKER_SGIX              0x8329
+#endif
+
+#ifndef GL_SGIX_async_pixel
+#define GL_ASYNC_TEX_IMAGE_SGIX           0x835C
+#define GL_ASYNC_DRAW_PIXELS_SGIX         0x835D
+#define GL_ASYNC_READ_PIXELS_SGIX         0x835E
+#define GL_MAX_ASYNC_TEX_IMAGE_SGIX       0x835F
+#define GL_MAX_ASYNC_DRAW_PIXELS_SGIX     0x8360
+#define GL_MAX_ASYNC_READ_PIXELS_SGIX     0x8361
+#endif
+
+#ifndef GL_SGIX_async_histogram
+#define GL_ASYNC_HISTOGRAM_SGIX           0x832C
+#define GL_MAX_ASYNC_HISTOGRAM_SGIX       0x832D
+#endif
+
+#ifndef GL_INTEL_texture_scissor
+#endif
+
+#ifndef GL_INTEL_parallel_arrays
+#define GL_PARALLEL_ARRAYS_INTEL          0x83F4
+#define GL_VERTEX_ARRAY_PARALLEL_POINTERS_INTEL 0x83F5
+#define GL_NORMAL_ARRAY_PARALLEL_POINTERS_INTEL 0x83F6
+#define GL_COLOR_ARRAY_PARALLEL_POINTERS_INTEL 0x83F7
+#define GL_TEXTURE_COORD_ARRAY_PARALLEL_POINTERS_INTEL 0x83F8
+#endif
+
+#ifndef GL_HP_occlusion_test
+#define GL_OCCLUSION_TEST_HP              0x8165
+#define GL_OCCLUSION_TEST_RESULT_HP       0x8166
+#endif
+
+#ifndef GL_EXT_pixel_transform
+#define GL_PIXEL_TRANSFORM_2D_EXT         0x8330
+#define GL_PIXEL_MAG_FILTER_EXT           0x8331
+#define GL_PIXEL_MIN_FILTER_EXT           0x8332
+#define GL_PIXEL_CUBIC_WEIGHT_EXT         0x8333
+#define GL_CUBIC_EXT                      0x8334
+#define GL_AVERAGE_EXT                    0x8335
+#define GL_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT 0x8336
+#define GL_MAX_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT 0x8337
+#define GL_PIXEL_TRANSFORM_2D_MATRIX_EXT  0x8338
+#endif
+
+#ifndef GL_EXT_pixel_transform_color_table
+#endif
+
+#ifndef GL_EXT_shared_texture_palette
+#define GL_SHARED_TEXTURE_PALETTE_EXT     0x81FB
+#endif
+
+#ifndef GL_EXT_separate_specular_color
+#define GL_LIGHT_MODEL_COLOR_CONTROL_EXT  0x81F8
+#define GL_SINGLE_COLOR_EXT               0x81F9
+#define GL_SEPARATE_SPECULAR_COLOR_EXT    0x81FA
+#endif
+
+#ifndef GL_EXT_secondary_color
+#define GL_COLOR_SUM_EXT                  0x8458
+#define GL_CURRENT_SECONDARY_COLOR_EXT    0x8459
+#define GL_SECONDARY_COLOR_ARRAY_SIZE_EXT 0x845A
+#define GL_SECONDARY_COLOR_ARRAY_TYPE_EXT 0x845B
+#define GL_SECONDARY_COLOR_ARRAY_STRIDE_EXT 0x845C
+#define GL_SECONDARY_COLOR_ARRAY_POINTER_EXT 0x845D
+#define GL_SECONDARY_COLOR_ARRAY_EXT      0x845E
+#endif
+
+#ifndef GL_EXT_texture_perturb_normal
+#define GL_PERTURB_EXT                    0x85AE
+#define GL_TEXTURE_NORMAL_EXT             0x85AF
+#endif
+
+#ifndef GL_EXT_multi_draw_arrays
+#endif
+
+#ifndef GL_EXT_fog_coord
+#define GL_FOG_COORDINATE_SOURCE_EXT      0x8450
+#define GL_FOG_COORDINATE_EXT             0x8451
+#define GL_FRAGMENT_DEPTH_EXT             0x8452
+#define GL_CURRENT_FOG_COORDINATE_EXT     0x8453
+#define GL_FOG_COORDINATE_ARRAY_TYPE_EXT  0x8454
+#define GL_FOG_COORDINATE_ARRAY_STRIDE_EXT 0x8455
+#define GL_FOG_COORDINATE_ARRAY_POINTER_EXT 0x8456
+#define GL_FOG_COORDINATE_ARRAY_EXT       0x8457
+#endif
+
+#ifndef GL_REND_screen_coordinates
+#define GL_SCREEN_COORDINATES_REND        0x8490
+#define GL_INVERTED_SCREEN_W_REND         0x8491
+#endif
+
+#ifndef GL_EXT_coordinate_frame
+#define GL_TANGENT_ARRAY_EXT              0x8439
+#define GL_BINORMAL_ARRAY_EXT             0x843A
+#define GL_CURRENT_TANGENT_EXT            0x843B
+#define GL_CURRENT_BINORMAL_EXT           0x843C
+#define GL_TANGENT_ARRAY_TYPE_EXT         0x843E
+#define GL_TANGENT_ARRAY_STRIDE_EXT       0x843F
+#define GL_BINORMAL_ARRAY_TYPE_EXT        0x8440
+#define GL_BINORMAL_ARRAY_STRIDE_EXT      0x8441
+#define GL_TANGENT_ARRAY_POINTER_EXT      0x8442
+#define GL_BINORMAL_ARRAY_POINTER_EXT     0x8443
+#define GL_MAP1_TANGENT_EXT               0x8444
+#define GL_MAP2_TANGENT_EXT               0x8445
+#define GL_MAP1_BINORMAL_EXT              0x8446
+#define GL_MAP2_BINORMAL_EXT              0x8447
+#endif
+
+#ifndef GL_EXT_texture_env_combine
+#define GL_COMBINE_EXT                    0x8570
+#define GL_COMBINE_RGB_EXT                0x8571
+#define GL_COMBINE_ALPHA_EXT              0x8572
+#define GL_RGB_SCALE_EXT                  0x8573
+#define GL_ADD_SIGNED_EXT                 0x8574
+#define GL_INTERPOLATE_EXT                0x8575
+#define GL_CONSTANT_EXT                   0x8576
+#define GL_PRIMARY_COLOR_EXT              0x8577
+#define GL_PREVIOUS_EXT                   0x8578
+#define GL_SOURCE0_RGB_EXT                0x8580
+#define GL_SOURCE1_RGB_EXT                0x8581
+#define GL_SOURCE2_RGB_EXT                0x8582
+#define GL_SOURCE3_RGB_EXT                0x8583
+#define GL_SOURCE4_RGB_EXT                0x8584
+#define GL_SOURCE5_RGB_EXT                0x8585
+#define GL_SOURCE6_RGB_EXT                0x8586
+#define GL_SOURCE7_RGB_EXT                0x8587
+#define GL_SOURCE0_ALPHA_EXT              0x8588
+#define GL_SOURCE1_ALPHA_EXT              0x8589
+#define GL_SOURCE2_ALPHA_EXT              0x858A
+#define GL_SOURCE3_ALPHA_EXT              0x858B
+#define GL_SOURCE4_ALPHA_EXT              0x858C
+#define GL_SOURCE5_ALPHA_EXT              0x858D
+#define GL_SOURCE6_ALPHA_EXT              0x858E
+#define GL_SOURCE7_ALPHA_EXT              0x858F
+#define GL_OPERAND0_RGB_EXT               0x8590
+#define GL_OPERAND1_RGB_EXT               0x8591
+#define GL_OPERAND2_RGB_EXT               0x8592
+#define GL_OPERAND3_RGB_EXT               0x8593
+#define GL_OPERAND4_RGB_EXT               0x8594
+#define GL_OPERAND5_RGB_EXT               0x8595
+#define GL_OPERAND6_RGB_EXT               0x8596
+#define GL_OPERAND7_RGB_EXT               0x8597
+#define GL_OPERAND0_ALPHA_EXT             0x8598
+#define GL_OPERAND1_ALPHA_EXT             0x8599
+#define GL_OPERAND2_ALPHA_EXT             0x859A
+#define GL_OPERAND3_ALPHA_EXT             0x859B
+#define GL_OPERAND4_ALPHA_EXT             0x859C
+#define GL_OPERAND5_ALPHA_EXT             0x859D
+#define GL_OPERAND6_ALPHA_EXT             0x859E
+#define GL_OPERAND7_ALPHA_EXT             0x859F
+#endif
+
+#ifndef GL_APPLE_specular_vector
+#define GL_LIGHT_MODEL_SPECULAR_VECTOR_APPLE 0x85B0
+#endif
+
+#ifndef GL_APPLE_transform_hint
+#define GL_TRANSFORM_HINT_APPLE           0x85B1
+#endif
+
+#ifndef GL_SGIX_fog_scale
+#define GL_FOG_SCALE_SGIX                 0x81FC
+#define GL_FOG_SCALE_VALUE_SGIX           0x81FD
+#endif
+
+#ifndef GL_SUNX_constant_data
+#define GL_UNPACK_CONSTANT_DATA_SUNX      0x81D5
+#define GL_TEXTURE_CONSTANT_DATA_SUNX     0x81D6
+#endif
+
+#ifndef GL_SUN_global_alpha
+#define GL_GLOBAL_ALPHA_SUN               0x81D9
+#define GL_GLOBAL_ALPHA_FACTOR_SUN        0x81DA
+#endif
+
+#ifndef GL_SUN_triangle_list
+#define GL_RESTART_SUN                    0x01
+#define GL_REPLACE_MIDDLE_SUN             0x02
+#define GL_REPLACE_OLDEST_SUN             0x03
+#define GL_TRIANGLE_LIST_SUN              0x81D7
+#define GL_REPLACEMENT_CODE_SUN           0x81D8
+#define GL_REPLACEMENT_CODE_ARRAY_SUN     0x85C0
+#define GL_REPLACEMENT_CODE_ARRAY_TYPE_SUN 0x85C1
+#define GL_REPLACEMENT_CODE_ARRAY_STRIDE_SUN 0x85C2
+#define GL_REPLACEMENT_CODE_ARRAY_POINTER_SUN 0x85C3
+#define GL_R1UI_V3F_SUN                   0x85C4
+#define GL_R1UI_C4UB_V3F_SUN              0x85C5
+#define GL_R1UI_C3F_V3F_SUN               0x85C6
+#define GL_R1UI_N3F_V3F_SUN               0x85C7
+#define GL_R1UI_C4F_N3F_V3F_SUN           0x85C8
+#define GL_R1UI_T2F_V3F_SUN               0x85C9
+#define GL_R1UI_T2F_N3F_V3F_SUN           0x85CA
+#define GL_R1UI_T2F_C4F_N3F_V3F_SUN       0x85CB
+#endif
+
+#ifndef GL_SUN_vertex
+#endif
+
+#ifndef GL_EXT_blend_func_separate
+#define GL_BLEND_DST_RGB_EXT              0x80C8
+#define GL_BLEND_SRC_RGB_EXT              0x80C9
+#define GL_BLEND_DST_ALPHA_EXT            0x80CA
+#define GL_BLEND_SRC_ALPHA_EXT            0x80CB
+#endif
+
+#ifndef GL_INGR_color_clamp
+#define GL_RED_MIN_CLAMP_INGR             0x8560
+#define GL_GREEN_MIN_CLAMP_INGR           0x8561
+#define GL_BLUE_MIN_CLAMP_INGR            0x8562
+#define GL_ALPHA_MIN_CLAMP_INGR           0x8563
+#define GL_RED_MAX_CLAMP_INGR             0x8564
+#define GL_GREEN_MAX_CLAMP_INGR           0x8565
+#define GL_BLUE_MAX_CLAMP_INGR            0x8566
+#define GL_ALPHA_MAX_CLAMP_INGR           0x8567
+#endif
+
+#ifndef GL_INGR_interlace_read
+#define GL_INTERLACE_READ_INGR            0x8568
+#endif
+
+#ifndef GL_EXT_stencil_wrap
+#define GL_INCR_WRAP_EXT                  0x8507
+#define GL_DECR_WRAP_EXT                  0x8508
+#endif
+
+#ifndef GL_EXT_422_pixels
+#define GL_422_EXT                        0x80CC
+#define GL_422_REV_EXT                    0x80CD
+#define GL_422_AVERAGE_EXT                0x80CE
+#define GL_422_REV_AVERAGE_EXT            0x80CF
+#endif
+
+#ifndef GL_NV_texgen_reflection
+#define GL_NORMAL_MAP_NV                  0x8511
+#define GL_REFLECTION_MAP_NV              0x8512
+#endif
+
+#ifndef GL_EXT_texture_cube_map
+#define GL_NORMAL_MAP_EXT                 0x8511
+#define GL_REFLECTION_MAP_EXT             0x8512
+#define GL_TEXTURE_CUBE_MAP_EXT           0x8513
+#define GL_TEXTURE_BINDING_CUBE_MAP_EXT   0x8514
+#define GL_TEXTURE_CUBE_MAP_POSITIVE_X_EXT 0x8515
+#define GL_TEXTURE_CUBE_MAP_NEGATIVE_X_EXT 0x8516
+#define GL_TEXTURE_CUBE_MAP_POSITIVE_Y_EXT 0x8517
+#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_EXT 0x8518
+#define GL_TEXTURE_CUBE_MAP_POSITIVE_Z_EXT 0x8519
+#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_EXT 0x851A
+#define GL_PROXY_TEXTURE_CUBE_MAP_EXT     0x851B
+#define GL_MAX_CUBE_MAP_TEXTURE_SIZE_EXT  0x851C
+#endif
+
+#ifndef GL_SUN_convolution_border_modes
+#define GL_WRAP_BORDER_SUN                0x81D4
+#endif
+
+#ifndef GL_EXT_texture_env_add
+#endif
+
+#ifndef GL_EXT_texture_lod_bias
+#define GL_MAX_TEXTURE_LOD_BIAS_EXT       0x84FD
+#define GL_TEXTURE_FILTER_CONTROL_EXT     0x8500
+#define GL_TEXTURE_LOD_BIAS_EXT           0x8501
+#endif
+
+#ifndef GL_EXT_texture_filter_anisotropic
+#define GL_TEXTURE_MAX_ANISOTROPY_EXT     0x84FE
+#define GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT 0x84FF
+#endif
+
+#ifndef GL_EXT_vertex_weighting
+#define GL_MODELVIEW0_STACK_DEPTH_EXT     GL_MODELVIEW_STACK_DEPTH
+#define GL_MODELVIEW1_STACK_DEPTH_EXT     0x8502
+#define GL_MODELVIEW0_MATRIX_EXT          GL_MODELVIEW_MATRIX
+#define GL_MODELVIEW_MATRIX1_EXT          0x8506
+#define GL_VERTEX_WEIGHTING_EXT           0x8509
+#define GL_MODELVIEW0_EXT                 GL_MODELVIEW
+#define GL_MODELVIEW1_EXT                 0x850A
+#define GL_CURRENT_VERTEX_WEIGHT_EXT      0x850B
+#define GL_VERTEX_WEIGHT_ARRAY_EXT        0x850C
+#define GL_VERTEX_WEIGHT_ARRAY_SIZE_EXT   0x850D
+#define GL_VERTEX_WEIGHT_ARRAY_TYPE_EXT   0x850E
+#define GL_VERTEX_WEIGHT_ARRAY_STRIDE_EXT 0x850F
+#define GL_VERTEX_WEIGHT_ARRAY_POINTER_EXT 0x8510
+#endif
+
+#ifndef GL_NV_light_max_exponent
+#define GL_MAX_SHININESS_NV               0x8504
+#define GL_MAX_SPOT_EXPONENT_NV           0x8505
+#endif
+
+#ifndef GL_NV_vertex_array_range
+#define GL_VERTEX_ARRAY_RANGE_NV          0x851D
+#define GL_VERTEX_ARRAY_RANGE_LENGTH_NV   0x851E
+#define GL_VERTEX_ARRAY_RANGE_VALID_NV    0x851F
+#define GL_MAX_VERTEX_ARRAY_RANGE_ELEMENT_NV 0x8520
+#define GL_VERTEX_ARRAY_RANGE_POINTER_NV  0x8521
+#endif
+
+#ifndef GL_NV_register_combiners
+#define GL_REGISTER_COMBINERS_NV          0x8522
+#define GL_VARIABLE_A_NV                  0x8523
+#define GL_VARIABLE_B_NV                  0x8524
+#define GL_VARIABLE_C_NV                  0x8525
+#define GL_VARIABLE_D_NV                  0x8526
+#define GL_VARIABLE_E_NV                  0x8527
+#define GL_VARIABLE_F_NV                  0x8528
+#define GL_VARIABLE_G_NV                  0x8529
+#define GL_CONSTANT_COLOR0_NV             0x852A
+#define GL_CONSTANT_COLOR1_NV             0x852B
+#define GL_PRIMARY_COLOR_NV               0x852C
+#define GL_SECONDARY_COLOR_NV             0x852D
+#define GL_SPARE0_NV                      0x852E
+#define GL_SPARE1_NV                      0x852F
+#define GL_DISCARD_NV                     0x8530
+#define GL_E_TIMES_F_NV                   0x8531
+#define GL_SPARE0_PLUS_SECONDARY_COLOR_NV 0x8532
+#define GL_UNSIGNED_IDENTITY_NV           0x8536
+#define GL_UNSIGNED_INVERT_NV             0x8537
+#define GL_EXPAND_NORMAL_NV               0x8538
+#define GL_EXPAND_NEGATE_NV               0x8539
+#define GL_HALF_BIAS_NORMAL_NV            0x853A
+#define GL_HALF_BIAS_NEGATE_NV            0x853B
+#define GL_SIGNED_IDENTITY_NV             0x853C
+#define GL_SIGNED_NEGATE_NV               0x853D
+#define GL_SCALE_BY_TWO_NV                0x853E
+#define GL_SCALE_BY_FOUR_NV               0x853F
+#define GL_SCALE_BY_ONE_HALF_NV           0x8540
+#define GL_BIAS_BY_NEGATIVE_ONE_HALF_NV   0x8541
+#define GL_COMBINER_INPUT_NV              0x8542
+#define GL_COMBINER_MAPPING_NV            0x8543
+#define GL_COMBINER_COMPONENT_USAGE_NV    0x8544
+#define GL_COMBINER_AB_DOT_PRODUCT_NV     0x8545
+#define GL_COMBINER_CD_DOT_PRODUCT_NV     0x8546
+#define GL_COMBINER_MUX_SUM_NV            0x8547
+#define GL_COMBINER_SCALE_NV              0x8548
+#define GL_COMBINER_BIAS_NV               0x8549
+#define GL_COMBINER_AB_OUTPUT_NV          0x854A
+#define GL_COMBINER_CD_OUTPUT_NV          0x854B
+#define GL_COMBINER_SUM_OUTPUT_NV         0x854C
+#define GL_MAX_GENERAL_COMBINERS_NV       0x854D
+#define GL_NUM_GENERAL_COMBINERS_NV       0x854E
+#define GL_COLOR_SUM_CLAMP_NV             0x854F
+#define GL_COMBINER0_NV                   0x8550
+#define GL_COMBINER1_NV                   0x8551
+#define GL_COMBINER2_NV                   0x8552
+#define GL_COMBINER3_NV                   0x8553
+#define GL_COMBINER4_NV                   0x8554
+#define GL_COMBINER5_NV                   0x8555
+#define GL_COMBINER6_NV                   0x8556
+#define GL_COMBINER7_NV                   0x8557
+/* reuse GL_TEXTURE0_ARB */
+/* reuse GL_TEXTURE1_ARB */
+/* reuse GL_ZERO */
+/* reuse GL_NONE */
+/* reuse GL_FOG */
+#endif
+
+#ifndef GL_NV_fog_distance
+#define GL_FOG_DISTANCE_MODE_NV           0x855A
+#define GL_EYE_RADIAL_NV                  0x855B
+#define GL_EYE_PLANE_ABSOLUTE_NV          0x855C
+/* reuse GL_EYE_PLANE */
+#endif
+
+#ifndef GL_NV_texgen_emboss
+#define GL_EMBOSS_LIGHT_NV                0x855D
+#define GL_EMBOSS_CONSTANT_NV             0x855E
+#define GL_EMBOSS_MAP_NV                  0x855F
+#endif
+
+#ifndef GL_NV_blend_square
+#endif
+
+#ifndef GL_NV_texture_env_combine4
+#define GL_COMBINE4_NV                    0x8503
+#define GL_SOURCE3_RGB_NV                 0x8583
+#define GL_SOURCE3_ALPHA_NV               0x858B
+#define GL_OPERAND3_RGB_NV                0x8593
+#define GL_OPERAND3_ALPHA_NV              0x859B
+#endif
+
+#ifndef GL_MESA_resize_buffers
+#endif
+
+#ifndef GL_MESA_window_pos
+#endif
+
+#ifndef GL_EXT_texture_compression_s3tc
+#define GL_COMPRESSED_RGB_S3TC_DXT1_EXT   0x83F0
+#define GL_COMPRESSED_RGBA_S3TC_DXT1_EXT  0x83F1
+#define GL_COMPRESSED_RGBA_S3TC_DXT3_EXT  0x83F2
+#define GL_COMPRESSED_RGBA_S3TC_DXT5_EXT  0x83F3
+#endif
+
+#ifndef GL_IBM_cull_vertex
+#define GL_CULL_VERTEX_IBM                103050
+#endif
+
+#ifndef GL_IBM_multimode_draw_arrays
+#endif
+
+#ifndef GL_IBM_vertex_array_lists
+#define GL_VERTEX_ARRAY_LIST_IBM          103070
+#define GL_NORMAL_ARRAY_LIST_IBM          103071
+#define GL_COLOR_ARRAY_LIST_IBM           103072
+#define GL_INDEX_ARRAY_LIST_IBM           103073
+#define GL_TEXTURE_COORD_ARRAY_LIST_IBM   103074
+#define GL_EDGE_FLAG_ARRAY_LIST_IBM       103075
+#define GL_FOG_COORDINATE_ARRAY_LIST_IBM  103076
+#define GL_SECONDARY_COLOR_ARRAY_LIST_IBM 103077
+#define GL_VERTEX_ARRAY_LIST_STRIDE_IBM   103080
+#define GL_NORMAL_ARRAY_LIST_STRIDE_IBM   103081
+#define GL_COLOR_ARRAY_LIST_STRIDE_IBM    103082
+#define GL_INDEX_ARRAY_LIST_STRIDE_IBM    103083
+#define GL_TEXTURE_COORD_ARRAY_LIST_STRIDE_IBM 103084
+#define GL_EDGE_FLAG_ARRAY_LIST_STRIDE_IBM 103085
+#define GL_FOG_COORDINATE_ARRAY_LIST_STRIDE_IBM 103086
+#define GL_SECONDARY_COLOR_ARRAY_LIST_STRIDE_IBM 103087
+#endif
+
+#ifndef GL_SGIX_subsample
+#define GL_PACK_SUBSAMPLE_RATE_SGIX       0x85A0
+#define GL_UNPACK_SUBSAMPLE_RATE_SGIX     0x85A1
+#define GL_PIXEL_SUBSAMPLE_4444_SGIX      0x85A2
+#define GL_PIXEL_SUBSAMPLE_2424_SGIX      0x85A3
+#define GL_PIXEL_SUBSAMPLE_4242_SGIX      0x85A4
+#endif
+
+#ifndef GL_SGIX_ycrcb_subsample
+#endif
+
+#ifndef GL_SGIX_ycrcba
+#define GL_YCRCB_SGIX                     0x8318
+#define GL_YCRCBA_SGIX                    0x8319
+#endif
+
+#ifndef GL_SGI_depth_pass_instrument
+#define GL_DEPTH_PASS_INSTRUMENT_SGIX     0x8310
+#define GL_DEPTH_PASS_INSTRUMENT_COUNTERS_SGIX 0x8311
+#define GL_DEPTH_PASS_INSTRUMENT_MAX_SGIX 0x8312
+#endif
+
+#ifndef GL_3DFX_texture_compression_FXT1
+#define GL_COMPRESSED_RGB_FXT1_3DFX       0x86B0
+#define GL_COMPRESSED_RGBA_FXT1_3DFX      0x86B1
+#endif
+
+#ifndef GL_3DFX_multisample
+#define GL_MULTISAMPLE_3DFX               0x86B2
+#define GL_SAMPLE_BUFFERS_3DFX            0x86B3
+#define GL_SAMPLES_3DFX                   0x86B4
+#define GL_MULTISAMPLE_BIT_3DFX           0x20000000
+#endif
+
+#ifndef GL_3DFX_tbuffer
+#endif
+
+#ifndef GL_EXT_multisample
+#define GL_MULTISAMPLE_EXT                0x809D
+#define GL_SAMPLE_ALPHA_TO_MASK_EXT       0x809E
+#define GL_SAMPLE_ALPHA_TO_ONE_EXT        0x809F
+#define GL_SAMPLE_MASK_EXT                0x80A0
+#define GL_1PASS_EXT                      0x80A1
+#define GL_2PASS_0_EXT                    0x80A2
+#define GL_2PASS_1_EXT                    0x80A3
+#define GL_4PASS_0_EXT                    0x80A4
+#define GL_4PASS_1_EXT                    0x80A5
+#define GL_4PASS_2_EXT                    0x80A6
+#define GL_4PASS_3_EXT                    0x80A7
+#define GL_SAMPLE_BUFFERS_EXT             0x80A8
+#define GL_SAMPLES_EXT                    0x80A9
+#define GL_SAMPLE_MASK_VALUE_EXT          0x80AA
+#define GL_SAMPLE_MASK_INVERT_EXT         0x80AB
+#define GL_SAMPLE_PATTERN_EXT             0x80AC
+#endif
+
+#ifndef GL_SGIX_vertex_preclip
+#define GL_VERTEX_PRECLIP_SGIX            0x83EE
+#define GL_VERTEX_PRECLIP_HINT_SGIX       0x83EF
+#endif
+
+#ifndef GL_SGIX_convolution_accuracy
+#define GL_CONVOLUTION_HINT_SGIX          0x8316
+#endif
+
+#ifndef GL_SGIX_resample
+#define GL_PACK_RESAMPLE_SGIX             0x842C
+#define GL_UNPACK_RESAMPLE_SGIX           0x842D
+#define GL_RESAMPLE_REPLICATE_SGIX        0x842E
+#define GL_RESAMPLE_ZERO_FILL_SGIX        0x842F
+#define GL_RESAMPLE_DECIMATE_SGIX         0x8430
+#endif
+
+#ifndef GL_SGIS_point_line_texgen
+#define GL_EYE_DISTANCE_TO_POINT_SGIS     0x81F0
+#define GL_OBJECT_DISTANCE_TO_POINT_SGIS  0x81F1
+#define GL_EYE_DISTANCE_TO_LINE_SGIS      0x81F2
+#define GL_OBJECT_DISTANCE_TO_LINE_SGIS   0x81F3
+#define GL_EYE_POINT_SGIS                 0x81F4
+#define GL_OBJECT_POINT_SGIS              0x81F5
+#define GL_EYE_LINE_SGIS                  0x81F6
+#define GL_OBJECT_LINE_SGIS               0x81F7
+#endif
+
+#ifndef GL_SGIS_texture_color_mask
+#define GL_TEXTURE_COLOR_WRITEMASK_SGIS   0x81EF
+#endif
+
+
+/*************************************************************/
+
+#ifndef GL_VERSION_1_2
+#define GL_VERSION_1_2 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glBlendColor (GLclampf, GLclampf, GLclampf, GLclampf);
+extern void APIENTRY glBlendEquation (GLenum);
+extern void APIENTRY glDrawRangeElements (GLenum, GLuint, GLuint, GLsizei, GLenum, const GLvoid *);
+extern void APIENTRY glColorTable (GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *);
+extern void APIENTRY glColorTableParameterfv (GLenum, GLenum, const GLfloat *);
+extern void APIENTRY glColorTableParameteriv (GLenum, GLenum, const GLint *);
+extern void APIENTRY glCopyColorTable (GLenum, GLenum, GLint, GLint, GLsizei);
+extern void APIENTRY glGetColorTable (GLenum, GLenum, GLenum, GLvoid *);
+extern void APIENTRY glGetColorTableParameterfv (GLenum, GLenum, GLfloat *);
+extern void APIENTRY glGetColorTableParameteriv (GLenum, GLenum, GLint *);
+extern void APIENTRY glColorSubTable (GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *);
+extern void APIENTRY glCopyColorSubTable (GLenum, GLsizei, GLint, GLint, GLsizei);
+extern void APIENTRY glConvolutionFilter1D (GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *);
+extern void APIENTRY glConvolutionFilter2D (GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *);
+extern void APIENTRY glConvolutionParameterf (GLenum, GLenum, GLfloat);
+extern void APIENTRY glConvolutionParameterfv (GLenum, GLenum, const GLfloat *);
+extern void APIENTRY glConvolutionParameteri (GLenum, GLenum, GLint);
+extern void APIENTRY glConvolutionParameteriv (GLenum, GLenum, const GLint *);
+extern void APIENTRY glCopyConvolutionFilter1D (GLenum, GLenum, GLint, GLint, GLsizei);
+extern void APIENTRY glCopyConvolutionFilter2D (GLenum, GLenum, GLint, GLint, GLsizei, GLsizei);
+extern void APIENTRY glGetConvolutionFilter (GLenum, GLenum, GLenum, GLvoid *);
+extern void APIENTRY glGetConvolutionParameterfv (GLenum, GLenum, GLfloat *);
+extern void APIENTRY glGetConvolutionParameteriv (GLenum, GLenum, GLint *);
+extern void APIENTRY glGetSeparableFilter (GLenum, GLenum, GLenum, GLvoid *, GLvoid *, GLvoid *);
+extern void APIENTRY glSeparableFilter2D (GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *, const GLvoid *);
+extern void APIENTRY glGetHistogram (GLenum, GLboolean, GLenum, GLenum, GLvoid *);
+extern void APIENTRY glGetHistogramParameterfv (GLenum, GLenum, GLfloat *);
+extern void APIENTRY glGetHistogramParameteriv (GLenum, GLenum, GLint *);
+extern void APIENTRY glGetMinmax (GLenum, GLboolean, GLenum, GLenum, GLvoid *);
+extern void APIENTRY glGetMinmaxParameterfv (GLenum, GLenum, GLfloat *);
+extern void APIENTRY glGetMinmaxParameteriv (GLenum, GLenum, GLint *);
+extern void APIENTRY glHistogram (GLenum, GLsizei, GLenum, GLboolean);
+extern void APIENTRY glMinmax (GLenum, GLenum, GLboolean);
+extern void APIENTRY glResetHistogram (GLenum);
+extern void APIENTRY glResetMinmax (GLenum);
+extern void APIENTRY glTexImage3D (GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *);
+extern void APIENTRY glTexSubImage3D (GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *);
+extern void APIENTRY glCopyTexSubImage3D (GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLBLENDCOLORPROC) (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
+typedef void (APIENTRY * PFNGLBLENDEQUATIONPROC) (GLenum mode);
+typedef void (APIENTRY * PFNGLDRAWRANGEELEMENTSPROC) (GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices);
+typedef void (APIENTRY * PFNGLCOLORTABLEPROC) (GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table);
+typedef void (APIENTRY * PFNGLCOLORTABLEPARAMETERFVPROC) (GLenum target, GLenum pname, const GLfloat *params);
+typedef void (APIENTRY * PFNGLCOLORTABLEPARAMETERIVPROC) (GLenum target, GLenum pname, const GLint *params);
+typedef void (APIENTRY * PFNGLCOPYCOLORTABLEPROC) (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width);
+typedef void (APIENTRY * PFNGLGETCOLORTABLEPROC) (GLenum target, GLenum format, GLenum type, GLvoid *table);
+typedef void (APIENTRY * PFNGLGETCOLORTABLEPARAMETERFVPROC) (GLenum target, GLenum pname, GLfloat *params);
+typedef void (APIENTRY * PFNGLGETCOLORTABLEPARAMETERIVPROC) (GLenum target, GLenum pname, GLint *params);
+typedef void (APIENTRY * PFNGLCOLORSUBTABLEPROC) (GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data);
+typedef void (APIENTRY * PFNGLCOPYCOLORSUBTABLEPROC) (GLenum target, GLsizei start, GLint x, GLint y, GLsizei width);
+typedef void (APIENTRY * PFNGLCONVOLUTIONFILTER1DPROC) (GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *image);
+typedef void (APIENTRY * PFNGLCONVOLUTIONFILTER2DPROC) (GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image);
+typedef void (APIENTRY * PFNGLCONVOLUTIONPARAMETERFPROC) (GLenum target, GLenum pname, GLfloat params);
+typedef void (APIENTRY * PFNGLCONVOLUTIONPARAMETERFVPROC) (GLenum target, GLenum pname, const GLfloat *params);
+typedef void (APIENTRY * PFNGLCONVOLUTIONPARAMETERIPROC) (GLenum target, GLenum pname, GLint params);
+typedef void (APIENTRY * PFNGLCONVOLUTIONPARAMETERIVPROC) (GLenum target, GLenum pname, const GLint *params);
+typedef void (APIENTRY * PFNGLCOPYCONVOLUTIONFILTER1DPROC) (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width);
+typedef void (APIENTRY * PFNGLCOPYCONVOLUTIONFILTER2DPROC) (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height);
+typedef void (APIENTRY * PFNGLGETCONVOLUTIONFILTERPROC) (GLenum target, GLenum format, GLenum type, GLvoid *image);
+typedef void (APIENTRY * PFNGLGETCONVOLUTIONPARAMETERFVPROC) (GLenum target, GLenum pname, GLfloat *params);
+typedef void (APIENTRY * PFNGLGETCONVOLUTIONPARAMETERIVPROC) (GLenum target, GLenum pname, GLint *params);
+typedef void (APIENTRY * PFNGLGETSEPARABLEFILTERPROC) (GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span);
+typedef void (APIENTRY * PFNGLSEPARABLEFILTER2DPROC) (GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column);
+typedef void (APIENTRY * PFNGLGETHISTOGRAMPROC) (GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values);
+typedef void (APIENTRY * PFNGLGETHISTOGRAMPARAMETERFVPROC) (GLenum target, GLenum pname, GLfloat *params);
+typedef void (APIENTRY * PFNGLGETHISTOGRAMPARAMETERIVPROC) (GLenum target, GLenum pname, GLint *params);
+typedef void (APIENTRY * PFNGLGETMINMAXPROC) (GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values);
+typedef void (APIENTRY * PFNGLGETMINMAXPARAMETERFVPROC) (GLenum target, GLenum pname, GLfloat *params);
+typedef void (APIENTRY * PFNGLGETMINMAXPARAMETERIVPROC) (GLenum target, GLenum pname, GLint *params);
+typedef void (APIENTRY * PFNGLHISTOGRAMPROC) (GLenum target, GLsizei width, GLenum internalformat, GLboolean sink);
+typedef void (APIENTRY * PFNGLMINMAXPROC) (GLenum target, GLenum internalformat, GLboolean sink);
+typedef void (APIENTRY * PFNGLRESETHISTOGRAMPROC) (GLenum target);
+typedef void (APIENTRY * PFNGLRESETMINMAXPROC) (GLenum target);
+typedef void (APIENTRY * PFNGLTEXIMAGE3DPROC) (GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
+typedef void (APIENTRY * PFNGLTEXSUBIMAGE3DPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels);
+typedef void (APIENTRY * PFNGLCOPYTEXSUBIMAGE3DPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height);
+#endif
+
+#ifndef GL_ARB_multitexture
+#define GL_ARB_multitexture 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glActiveTextureARB (GLenum);
+extern void APIENTRY glClientActiveTextureARB (GLenum);
+extern void APIENTRY glMultiTexCoord1dARB (GLenum, GLdouble);
+extern void APIENTRY glMultiTexCoord1dvARB (GLenum, const GLdouble *);
+extern void APIENTRY glMultiTexCoord1fARB (GLenum, GLfloat);
+extern void APIENTRY glMultiTexCoord1fvARB (GLenum, const GLfloat *);
+extern void APIENTRY glMultiTexCoord1iARB (GLenum, GLint);
+extern void APIENTRY glMultiTexCoord1ivARB (GLenum, const GLint *);
+extern void APIENTRY glMultiTexCoord1sARB (GLenum, GLshort);
+extern void APIENTRY glMultiTexCoord1svARB (GLenum, const GLshort *);
+extern void APIENTRY glMultiTexCoord2dARB (GLenum, GLdouble, GLdouble);
+extern void APIENTRY glMultiTexCoord2dvARB (GLenum, const GLdouble *);
+extern void APIENTRY glMultiTexCoord2fARB (GLenum, GLfloat, GLfloat);
+extern void APIENTRY glMultiTexCoord2fvARB (GLenum, const GLfloat *);
+extern void APIENTRY glMultiTexCoord2iARB (GLenum, GLint, GLint);
+extern void APIENTRY glMultiTexCoord2ivARB (GLenum, const GLint *);
+extern void APIENTRY glMultiTexCoord2sARB (GLenum, GLshort, GLshort);
+extern void APIENTRY glMultiTexCoord2svARB (GLenum, const GLshort *);
+extern void APIENTRY glMultiTexCoord3dARB (GLenum, GLdouble, GLdouble, GLdouble);
+extern void APIENTRY glMultiTexCoord3dvARB (GLenum, const GLdouble *);
+extern void APIENTRY glMultiTexCoord3fARB (GLenum, GLfloat, GLfloat, GLfloat);
+extern void APIENTRY glMultiTexCoord3fvARB (GLenum, const GLfloat *);
+extern void APIENTRY glMultiTexCoord3iARB (GLenum, GLint, GLint, GLint);
+extern void APIENTRY glMultiTexCoord3ivARB (GLenum, const GLint *);
+extern void APIENTRY glMultiTexCoord3sARB (GLenum, GLshort, GLshort, GLshort);
+extern void APIENTRY glMultiTexCoord3svARB (GLenum, const GLshort *);
+extern void APIENTRY glMultiTexCoord4dARB (GLenum, GLdouble, GLdouble, GLdouble, GLdouble);
+extern void APIENTRY glMultiTexCoord4dvARB (GLenum, const GLdouble *);
+extern void APIENTRY glMultiTexCoord4fARB (GLenum, GLfloat, GLfloat, GLfloat, GLfloat);
+extern void APIENTRY glMultiTexCoord4fvARB (GLenum, const GLfloat *);
+extern void APIENTRY glMultiTexCoord4iARB (GLenum, GLint, GLint, GLint, GLint);
+extern void APIENTRY glMultiTexCoord4ivARB (GLenum, const GLint *);
+extern void APIENTRY glMultiTexCoord4sARB (GLenum, GLshort, GLshort, GLshort, GLshort);
+extern void APIENTRY glMultiTexCoord4svARB (GLenum, const GLshort *);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLACTIVETEXTUREARBPROC) (GLenum texture);
+typedef void (APIENTRY * PFNGLCLIENTACTIVETEXTUREARBPROC) (GLenum texture);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD1DARBPROC) (GLenum target, GLdouble s);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD1DVARBPROC) (GLenum target, const GLdouble *v);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD1FARBPROC) (GLenum target, GLfloat s);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD1FVARBPROC) (GLenum target, const GLfloat *v);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD1IARBPROC) (GLenum target, GLint s);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD1IVARBPROC) (GLenum target, const GLint *v);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD1SARBPROC) (GLenum target, GLshort s);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD1SVARBPROC) (GLenum target, const GLshort *v);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD2DARBPROC) (GLenum target, GLdouble s, GLdouble t);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD2DVARBPROC) (GLenum target, const GLdouble *v);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD2FARBPROC) (GLenum target, GLfloat s, GLfloat t);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD2FVARBPROC) (GLenum target, const GLfloat *v);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD2IARBPROC) (GLenum target, GLint s, GLint t);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD2IVARBPROC) (GLenum target, const GLint *v);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD2SARBPROC) (GLenum target, GLshort s, GLshort t);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD2SVARBPROC) (GLenum target, const GLshort *v);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD3DARBPROC) (GLenum target, GLdouble s, GLdouble t, GLdouble r);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD3DVARBPROC) (GLenum target, const GLdouble *v);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD3FARBPROC) (GLenum target, GLfloat s, GLfloat t, GLfloat r);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD3FVARBPROC) (GLenum target, const GLfloat *v);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD3IARBPROC) (GLenum target, GLint s, GLint t, GLint r);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD3IVARBPROC) (GLenum target, const GLint *v);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD3SARBPROC) (GLenum target, GLshort s, GLshort t, GLshort r);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD3SVARBPROC) (GLenum target, const GLshort *v);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD4DARBPROC) (GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD4DVARBPROC) (GLenum target, const GLdouble *v);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD4FARBPROC) (GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD4FVARBPROC) (GLenum target, const GLfloat *v);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD4IARBPROC) (GLenum target, GLint s, GLint t, GLint r, GLint q);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD4IVARBPROC) (GLenum target, const GLint *v);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD4SARBPROC) (GLenum target, GLshort s, GLshort t, GLshort r, GLshort q);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD4SVARBPROC) (GLenum target, const GLshort *v);
+#endif
+
+#ifndef GL_ARB_transpose_matrix
+#define GL_ARB_transpose_matrix 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glLoadTransposeMatrixfARB (const GLfloat *);
+extern void APIENTRY glLoadTransposeMatrixdARB (const GLdouble *);
+extern void APIENTRY glMultTransposeMatrixfARB (const GLfloat *);
+extern void APIENTRY glMultTransposeMatrixdARB (const GLdouble *);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLLOADTRANSPOSEMATRIXFARBPROC) (const GLfloat *m);
+typedef void (APIENTRY * PFNGLLOADTRANSPOSEMATRIXDARBPROC) (const GLdouble *m);
+typedef void (APIENTRY * PFNGLMULTTRANSPOSEMATRIXFARBPROC) (const GLfloat *m);
+typedef void (APIENTRY * PFNGLMULTTRANSPOSEMATRIXDARBPROC) (const GLdouble *m);
+#endif
+
+#ifndef GL_ARB_multisample
+#define GL_ARB_multisample 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glSampleCoverageARB (GLclampf, GLboolean);
+extern void APIENTRY glSamplePassARB (GLenum);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLSAMPLECOVERAGEARBPROC) (GLclampf value, GLboolean invert);
+typedef void (APIENTRY * PFNGLSAMPLEPASSARBPROC) (GLenum pass);
+#endif
+
+#ifndef GL_ARB_texture_env_add
+#define GL_ARB_texture_env_add 1
+#endif
+
+#ifndef GL_ARB_texture_cube_map
+#define GL_ARB_texture_cube_map 1
+#endif
+
+#ifndef GL_ARB_texture_compression
+#define GL_ARB_texture_compression 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glCompressedTexImage3DARB (GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLsizei, const GLvoid *);
+extern void APIENTRY glCompressedTexImage2DARB (GLenum, GLint, GLenum, GLsizei, GLsizei, GLint, GLsizei, const GLvoid *);
+extern void APIENTRY glCompressedTexImage1DARB (GLenum, GLint, GLenum, GLsizei, GLint, GLsizei, const GLvoid *);
+extern void APIENTRY glCompressedTexSubImage3DARB (GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLsizei, const GLvoid *);
+extern void APIENTRY glCompressedTexSubImage2DARB (GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLsizei, const GLvoid *);
+extern void APIENTRY glCompressedTexSubImage1DARB (GLenum, GLint, GLint, GLsizei, GLenum, GLsizei, const GLvoid *);
+extern void APIENTRY glGetCompressedTexImageARB (GLenum, GLint, void *);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLCOMPRESSEDTEXIMAGE3DARBPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data);
+typedef void (APIENTRY * PFNGLCOMPRESSEDTEXIMAGE2DARBPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data);
+typedef void (APIENTRY * PFNGLCOMPRESSEDTEXIMAGE1DARBPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data);
+typedef void (APIENTRY * PFNGLCOMPRESSEDTEXSUBIMAGE3DARBPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data);
+typedef void (APIENTRY * PFNGLCOMPRESSEDTEXSUBIMAGE2DARBPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data);
+typedef void (APIENTRY * PFNGLCOMPRESSEDTEXSUBIMAGE1DARBPROC) (GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data);
+typedef void (APIENTRY * PFNGLGETCOMPRESSEDTEXIMAGEARBPROC) (GLenum target, GLint level, void *img);
+#endif
+
+#ifndef GL_EXT_abgr
+#define GL_EXT_abgr 1
+#endif
+
+#ifndef GL_EXT_blend_color
+#define GL_EXT_blend_color 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glBlendColorEXT (GLclampf, GLclampf, GLclampf, GLclampf);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLBLENDCOLOREXTPROC) (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
+#endif
+
+#ifndef GL_EXT_polygon_offset
+#define GL_EXT_polygon_offset 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glPolygonOffsetEXT (GLfloat, GLfloat);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLPOLYGONOFFSETEXTPROC) (GLfloat factor, GLfloat bias);
+#endif
+
+#ifndef GL_EXT_texture
+#define GL_EXT_texture 1
+#endif
+
+#ifndef GL_EXT_texture3D
+#define GL_EXT_texture3D 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glTexImage3DEXT (GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *);
+extern void APIENTRY glTexSubImage3DEXT (GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLTEXIMAGE3DEXTPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
+typedef void (APIENTRY * PFNGLTEXSUBIMAGE3DEXTPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels);
+#endif
+
+#ifndef GL_SGIS_texture_filter4
+#define GL_SGIS_texture_filter4 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glGetTexFilterFuncSGIS (GLenum, GLenum, GLfloat *);
+extern void APIENTRY glTexFilterFuncSGIS (GLenum, GLenum, GLsizei, const GLfloat *);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLGETTEXFILTERFUNCSGISPROC) (GLenum target, GLenum filter, GLfloat *weights);
+typedef void (APIENTRY * PFNGLTEXFILTERFUNCSGISPROC) (GLenum target, GLenum filter, GLsizei n, const GLfloat *weights);
+#endif
+
+#ifndef GL_EXT_subtexture
+#define GL_EXT_subtexture 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glTexSubImage1DEXT (GLenum, GLint, GLint, GLsizei, GLenum, GLenum, const GLvoid *);
+extern void APIENTRY glTexSubImage2DEXT (GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLTEXSUBIMAGE1DEXTPROC) (GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels);
+typedef void (APIENTRY * PFNGLTEXSUBIMAGE2DEXTPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
+#endif
+
+#ifndef GL_EXT_copy_texture
+#define GL_EXT_copy_texture 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glCopyTexImage1DEXT (GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLint);
+extern void APIENTRY glCopyTexImage2DEXT (GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLsizei, GLint);
+extern void APIENTRY glCopyTexSubImage1DEXT (GLenum, GLint, GLint, GLint, GLint, GLsizei);
+extern void APIENTRY glCopyTexSubImage2DEXT (GLenum, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei);
+extern void APIENTRY glCopyTexSubImage3DEXT (GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLCOPYTEXIMAGE1DEXTPROC) (GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border);
+typedef void (APIENTRY * PFNGLCOPYTEXIMAGE2DEXTPROC) (GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
+typedef void (APIENTRY * PFNGLCOPYTEXSUBIMAGE1DEXTPROC) (GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);
+typedef void (APIENTRY * PFNGLCOPYTEXSUBIMAGE2DEXTPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
+typedef void (APIENTRY * PFNGLCOPYTEXSUBIMAGE3DEXTPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height);
+#endif
+
+#ifndef GL_EXT_histogram
+#define GL_EXT_histogram 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glGetHistogramEXT (GLenum, GLboolean, GLenum, GLenum, GLvoid *);
+extern void APIENTRY glGetHistogramParameterfvEXT (GLenum, GLenum, GLfloat *);
+extern void APIENTRY glGetHistogramParameterivEXT (GLenum, GLenum, GLint *);
+extern void APIENTRY glGetMinmaxEXT (GLenum, GLboolean, GLenum, GLenum, GLvoid *);
+extern void APIENTRY glGetMinmaxParameterfvEXT (GLenum, GLenum, GLfloat *);
+extern void APIENTRY glGetMinmaxParameterivEXT (GLenum, GLenum, GLint *);
+extern void APIENTRY glHistogramEXT (GLenum, GLsizei, GLenum, GLboolean);
+extern void APIENTRY glMinmaxEXT (GLenum, GLenum, GLboolean);
+extern void APIENTRY glResetHistogramEXT (GLenum);
+extern void APIENTRY glResetMinmaxEXT (GLenum);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLGETHISTOGRAMEXTPROC) (GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values);
+typedef void (APIENTRY * PFNGLGETHISTOGRAMPARAMETERFVEXTPROC) (GLenum target, GLenum pname, GLfloat *params);
+typedef void (APIENTRY * PFNGLGETHISTOGRAMPARAMETERIVEXTPROC) (GLenum target, GLenum pname, GLint *params);
+typedef void (APIENTRY * PFNGLGETMINMAXEXTPROC) (GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values);
+typedef void (APIENTRY * PFNGLGETMINMAXPARAMETERFVEXTPROC) (GLenum target, GLenum pname, GLfloat *params);
+typedef void (APIENTRY * PFNGLGETMINMAXPARAMETERIVEXTPROC) (GLenum target, GLenum pname, GLint *params);
+typedef void (APIENTRY * PFNGLHISTOGRAMEXTPROC) (GLenum target, GLsizei width, GLenum internalformat, GLboolean sink);
+typedef void (APIENTRY * PFNGLMINMAXEXTPROC) (GLenum target, GLenum internalformat, GLboolean sink);
+typedef void (APIENTRY * PFNGLRESETHISTOGRAMEXTPROC) (GLenum target);
+typedef void (APIENTRY * PFNGLRESETMINMAXEXTPROC) (GLenum target);
+#endif
+
+#ifndef GL_EXT_convolution
+#define GL_EXT_convolution 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glConvolutionFilter1DEXT (GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *);
+extern void APIENTRY glConvolutionFilter2DEXT (GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *);
+extern void APIENTRY glConvolutionParameterfEXT (GLenum, GLenum, GLfloat);
+extern void APIENTRY glConvolutionParameterfvEXT (GLenum, GLenum, const GLfloat *);
+extern void APIENTRY glConvolutionParameteriEXT (GLenum, GLenum, GLint);
+extern void APIENTRY glConvolutionParameterivEXT (GLenum, GLenum, const GLint *);
+extern void APIENTRY glCopyConvolutionFilter1DEXT (GLenum, GLenum, GLint, GLint, GLsizei);
+extern void APIENTRY glCopyConvolutionFilter2DEXT (GLenum, GLenum, GLint, GLint, GLsizei, GLsizei);
+extern void APIENTRY glGetConvolutionFilterEXT (GLenum, GLenum, GLenum, GLvoid *);
+extern void APIENTRY glGetConvolutionParameterfvEXT (GLenum, GLenum, GLfloat *);
+extern void APIENTRY glGetConvolutionParameterivEXT (GLenum, GLenum, GLint *);
+extern void APIENTRY glGetSeparableFilterEXT (GLenum, GLenum, GLenum, GLvoid *, GLvoid *, GLvoid *);
+extern void APIENTRY glSeparableFilter2DEXT (GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *, const GLvoid *);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLCONVOLUTIONFILTER1DEXTPROC) (GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *image);
+typedef void (APIENTRY * PFNGLCONVOLUTIONFILTER2DEXTPROC) (GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image);
+typedef void (APIENTRY * PFNGLCONVOLUTIONPARAMETERFEXTPROC) (GLenum target, GLenum pname, GLfloat params);
+typedef void (APIENTRY * PFNGLCONVOLUTIONPARAMETERFVEXTPROC) (GLenum target, GLenum pname, const GLfloat *params);
+typedef void (APIENTRY * PFNGLCONVOLUTIONPARAMETERIEXTPROC) (GLenum target, GLenum pname, GLint params);
+typedef void (APIENTRY * PFNGLCONVOLUTIONPARAMETERIVEXTPROC) (GLenum target, GLenum pname, const GLint *params);
+typedef void (APIENTRY * PFNGLCOPYCONVOLUTIONFILTER1DEXTPROC) (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width);
+typedef void (APIENTRY * PFNGLCOPYCONVOLUTIONFILTER2DEXTPROC) (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height);
+typedef void (APIENTRY * PFNGLGETCONVOLUTIONFILTEREXTPROC) (GLenum target, GLenum format, GLenum type, GLvoid *image);
+typedef void (APIENTRY * PFNGLGETCONVOLUTIONPARAMETERFVEXTPROC) (GLenum target, GLenum pname, GLfloat *params);
+typedef void (APIENTRY * PFNGLGETCONVOLUTIONPARAMETERIVEXTPROC) (GLenum target, GLenum pname, GLint *params);
+typedef void (APIENTRY * PFNGLGETSEPARABLEFILTEREXTPROC) (GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span);
+typedef void (APIENTRY * PFNGLSEPARABLEFILTER2DEXTPROC) (GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column);
+#endif
+
+#ifndef GL_EXT_color_matrix
+#define GL_EXT_color_matrix 1
+#endif
+
+#ifndef GL_SGI_color_table
+#define GL_SGI_color_table 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glColorTableSGI (GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *);
+extern void APIENTRY glColorTableParameterfvSGI (GLenum, GLenum, const GLfloat *);
+extern void APIENTRY glColorTableParameterivSGI (GLenum, GLenum, const GLint *);
+extern void APIENTRY glCopyColorTableSGI (GLenum, GLenum, GLint, GLint, GLsizei);
+extern void APIENTRY glGetColorTableSGI (GLenum, GLenum, GLenum, GLvoid *);
+extern void APIENTRY glGetColorTableParameterfvSGI (GLenum, GLenum, GLfloat *);
+extern void APIENTRY glGetColorTableParameterivSGI (GLenum, GLenum, GLint *);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLCOLORTABLESGIPROC) (GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table);
+typedef void (APIENTRY * PFNGLCOLORTABLEPARAMETERFVSGIPROC) (GLenum target, GLenum pname, const GLfloat *params);
+typedef void (APIENTRY * PFNGLCOLORTABLEPARAMETERIVSGIPROC) (GLenum target, GLenum pname, const GLint *params);
+typedef void (APIENTRY * PFNGLCOPYCOLORTABLESGIPROC) (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width);
+typedef void (APIENTRY * PFNGLGETCOLORTABLESGIPROC) (GLenum target, GLenum format, GLenum type, GLvoid *table);
+typedef void (APIENTRY * PFNGLGETCOLORTABLEPARAMETERFVSGIPROC) (GLenum target, GLenum pname, GLfloat *params);
+typedef void (APIENTRY * PFNGLGETCOLORTABLEPARAMETERIVSGIPROC) (GLenum target, GLenum pname, GLint *params);
+#endif
+
+#ifndef GL_SGIX_pixel_texture
+#define GL_SGIX_pixel_texture 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glPixelTexGenSGIX (GLenum);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLPIXELTEXGENSGIXPROC) (GLenum mode);
+#endif
+
+#ifndef GL_SGIS_pixel_texture
+#define GL_SGIS_pixel_texture 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glPixelTexGenParameteriSGIS (GLenum, GLint);
+extern void APIENTRY glPixelTexGenParameterivSGIS (GLenum, const GLint *);
+extern void APIENTRY glPixelTexGenParameterfSGIS (GLenum, GLfloat);
+extern void APIENTRY glPixelTexGenParameterfvSGIS (GLenum, const GLfloat *);
+extern void APIENTRY glGetPixelTexGenParameterivSGIS (GLenum, GLint *);
+extern void APIENTRY glGetPixelTexGenParameterfvSGIS (GLenum, GLfloat *);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLPIXELTEXGENPARAMETERISGISPROC) (GLenum pname, GLint param);
+typedef void (APIENTRY * PFNGLPIXELTEXGENPARAMETERIVSGISPROC) (GLenum pname, const GLint *params);
+typedef void (APIENTRY * PFNGLPIXELTEXGENPARAMETERFSGISPROC) (GLenum pname, GLfloat param);
+typedef void (APIENTRY * PFNGLPIXELTEXGENPARAMETERFVSGISPROC) (GLenum pname, const GLfloat *params);
+typedef void (APIENTRY * PFNGLGETPIXELTEXGENPARAMETERIVSGISPROC) (GLenum pname, GLint *params);
+typedef void (APIENTRY * PFNGLGETPIXELTEXGENPARAMETERFVSGISPROC) (GLenum pname, GLfloat *params);
+#endif
+
+#ifndef GL_SGIS_texture4D
+#define GL_SGIS_texture4D 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glTexImage4DSGIS (GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *);
+extern void APIENTRY glTexSubImage4DSGIS (GLenum, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLTEXIMAGE4DSGISPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLsizei size4d, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
+typedef void (APIENTRY * PFNGLTEXSUBIMAGE4DSGISPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint woffset, GLsizei width, GLsizei height, GLsizei depth, GLsizei size4d, GLenum format, GLenum type, const GLvoid *pixels);
+#endif
+
+#ifndef GL_SGI_texture_color_table
+#define GL_SGI_texture_color_table 1
+#endif
+
+#ifndef GL_EXT_cmyka
+#define GL_EXT_cmyka 1
+#endif
+
+#ifndef GL_EXT_texture_object
+#define GL_EXT_texture_object 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern GLboolean APIENTRY glAreTexturesResidentEXT (GLsizei, const GLuint *, GLboolean *);
+extern void APIENTRY glBindTextureEXT (GLenum, GLuint);
+extern void APIENTRY glDeleteTexturesEXT (GLsizei, const GLuint *);
+extern void APIENTRY glGenTexturesEXT (GLsizei, GLuint *);
+extern GLboolean APIENTRY glIsTextureEXT (GLuint);
+extern void APIENTRY glPrioritizeTexturesEXT (GLsizei, const GLuint *, const GLclampf *);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef GLboolean (APIENTRY * PFNGLARETEXTURESRESIDENTEXTPROC) (GLsizei n, const GLuint *textures, GLboolean *residences);
+typedef void (APIENTRY * PFNGLBINDTEXTUREEXTPROC) (GLenum target, GLuint texture);
+typedef void (APIENTRY * PFNGLDELETETEXTURESEXTPROC) (GLsizei n, const GLuint *textures);
+typedef void (APIENTRY * PFNGLGENTEXTURESEXTPROC) (GLsizei n, GLuint *textures);
+typedef GLboolean (APIENTRY * PFNGLISTEXTUREEXTPROC) (GLuint texture);
+typedef void (APIENTRY * PFNGLPRIORITIZETEXTURESEXTPROC) (GLsizei n, const GLuint *textures, const GLclampf *priorities);
+#endif
+
+#ifndef GL_SGIS_detail_texture
+#define GL_SGIS_detail_texture 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glDetailTexFuncSGIS (GLenum, GLsizei, const GLfloat *);
+extern void APIENTRY glGetDetailTexFuncSGIS (GLenum, GLfloat *);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLDETAILTEXFUNCSGISPROC) (GLenum target, GLsizei n, const GLfloat *points);
+typedef void (APIENTRY * PFNGLGETDETAILTEXFUNCSGISPROC) (GLenum target, GLfloat *points);
+#endif
+
+#ifndef GL_SGIS_sharpen_texture
+#define GL_SGIS_sharpen_texture 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glSharpenTexFuncSGIS (GLenum, GLsizei, const GLfloat *);
+extern void APIENTRY glGetSharpenTexFuncSGIS (GLenum, GLfloat *);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLSHARPENTEXFUNCSGISPROC) (GLenum target, GLsizei n, const GLfloat *points);
+typedef void (APIENTRY * PFNGLGETSHARPENTEXFUNCSGISPROC) (GLenum target, GLfloat *points);
+#endif
+
+#ifndef GL_EXT_packed_pixels
+#define GL_EXT_packed_pixels 1
+#endif
+
+#ifndef GL_SGIS_texture_lod
+#define GL_SGIS_texture_lod 1
+#endif
+
+#ifndef GL_SGIS_multisample
+#define GL_SGIS_multisample 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glSampleMaskSGIS (GLclampf, GLboolean);
+extern void APIENTRY glSamplePatternSGIS (GLenum);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLSAMPLEMASKSGISPROC) (GLclampf value, GLboolean invert);
+typedef void (APIENTRY * PFNGLSAMPLEPATTERNSGISPROC) (GLenum pattern);
+#endif
+
+#ifndef GL_EXT_rescale_normal
+#define GL_EXT_rescale_normal 1
+#endif
+
+#ifndef GL_EXT_vertex_array
+#define GL_EXT_vertex_array 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glArrayElementEXT (GLint);
+extern void APIENTRY glColorPointerEXT (GLint, GLenum, GLsizei, GLsizei, const GLvoid *);
+extern void APIENTRY glDrawArraysEXT (GLenum, GLint, GLsizei);
+extern void APIENTRY glEdgeFlagPointerEXT (GLsizei, GLsizei, const GLboolean *);
+extern void APIENTRY glGetPointervEXT (GLenum, GLvoid* *);
+extern void APIENTRY glIndexPointerEXT (GLenum, GLsizei, GLsizei, const GLvoid *);
+extern void APIENTRY glNormalPointerEXT (GLenum, GLsizei, GLsizei, const GLvoid *);
+extern void APIENTRY glTexCoordPointerEXT (GLint, GLenum, GLsizei, GLsizei, const GLvoid *);
+extern void APIENTRY glVertexPointerEXT (GLint, GLenum, GLsizei, GLsizei, const GLvoid *);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLARRAYELEMENTEXTPROC) (GLint i);
+typedef void (APIENTRY * PFNGLCOLORPOINTEREXTPROC) (GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer);
+typedef void (APIENTRY * PFNGLDRAWARRAYSEXTPROC) (GLenum mode, GLint first, GLsizei count);
+typedef void (APIENTRY * PFNGLEDGEFLAGPOINTEREXTPROC) (GLsizei stride, GLsizei count, const GLboolean *pointer);
+typedef void (APIENTRY * PFNGLGETPOINTERVEXTPROC) (GLenum pname, GLvoid* *params);
+typedef void (APIENTRY * PFNGLINDEXPOINTEREXTPROC) (GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer);
+typedef void (APIENTRY * PFNGLNORMALPOINTEREXTPROC) (GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer);
+typedef void (APIENTRY * PFNGLTEXCOORDPOINTEREXTPROC) (GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer);
+typedef void (APIENTRY * PFNGLVERTEXPOINTEREXTPROC) (GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer);
+#endif
+
+#ifndef GL_EXT_misc_attribute
+#define GL_EXT_misc_attribute 1
+#endif
+
+#ifndef GL_SGIS_generate_mipmap
+#define GL_SGIS_generate_mipmap 1
+#endif
+
+#ifndef GL_SGIX_clipmap
+#define GL_SGIX_clipmap 1
+#endif
+
+#ifndef GL_SGIX_shadow
+#define GL_SGIX_shadow 1
+#endif
+
+#ifndef GL_SGIS_texture_edge_clamp
+#define GL_SGIS_texture_edge_clamp 1
+#endif
+
+#ifndef GL_SGIS_texture_border_clamp
+#define GL_SGIS_texture_border_clamp 1
+#endif
+
+#ifndef GL_EXT_blend_minmax
+#define GL_EXT_blend_minmax 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glBlendEquationEXT (GLenum);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLBLENDEQUATIONEXTPROC) (GLenum mode);
+#endif
+
+#ifndef GL_EXT_blend_subtract
+#define GL_EXT_blend_subtract 1
+#endif
+
+#ifndef GL_EXT_blend_logic_op
+#define GL_EXT_blend_logic_op 1
+#endif
+
+#ifndef GL_SGIX_interlace
+#define GL_SGIX_interlace 1
+#endif
+
+#ifndef GL_SGIX_pixel_tiles
+#define GL_SGIX_pixel_tiles 1
+#endif
+
+#ifndef GL_SGIX_texture_select
+#define GL_SGIX_texture_select 1
+#endif
+
+#ifndef GL_SGIX_sprite
+#define GL_SGIX_sprite 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glSpriteParameterfSGIX (GLenum, GLfloat);
+extern void APIENTRY glSpriteParameterfvSGIX (GLenum, const GLfloat *);
+extern void APIENTRY glSpriteParameteriSGIX (GLenum, GLint);
+extern void APIENTRY glSpriteParameterivSGIX (GLenum, const GLint *);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLSPRITEPARAMETERFSGIXPROC) (GLenum pname, GLfloat param);
+typedef void (APIENTRY * PFNGLSPRITEPARAMETERFVSGIXPROC) (GLenum pname, const GLfloat *params);
+typedef void (APIENTRY * PFNGLSPRITEPARAMETERISGIXPROC) (GLenum pname, GLint param);
+typedef void (APIENTRY * PFNGLSPRITEPARAMETERIVSGIXPROC) (GLenum pname, const GLint *params);
+#endif
+
+#ifndef GL_SGIX_texture_multi_buffer
+#define GL_SGIX_texture_multi_buffer 1
+#endif
+
+#ifndef GL_EXT_point_parameters
+#define GL_EXT_point_parameters 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glPointParameterfEXT (GLenum, GLfloat);
+extern void APIENTRY glPointParameterfvEXT (GLenum, const GLfloat *);
+extern void APIENTRY glPointParameterfSGIS (GLenum, GLfloat);
+extern void APIENTRY glPointParameterfvSGIS (GLenum, const GLfloat *);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLPOINTPARAMETERFEXTPROC) (GLenum pname, GLfloat param);
+typedef void (APIENTRY * PFNGLPOINTPARAMETERFVEXTPROC) (GLenum pname, const GLfloat *params);
+typedef void (APIENTRY * PFNGLPOINTPARAMETERFSGISPROC) (GLenum pname, GLfloat param);
+typedef void (APIENTRY * PFNGLPOINTPARAMETERFVSGISPROC) (GLenum pname, const GLfloat *params);
+#endif
+
+#ifndef GL_SGIX_instruments
+#define GL_SGIX_instruments 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern GLint APIENTRY glGetInstrumentsSGIX (void);
+extern void APIENTRY glInstrumentsBufferSGIX (GLsizei, GLint *);
+extern GLint APIENTRY glPollInstrumentsSGIX (GLint *);
+extern void APIENTRY glReadInstrumentsSGIX (GLint);
+extern void APIENTRY glStartInstrumentsSGIX (void);
+extern void APIENTRY glStopInstrumentsSGIX (GLint);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef GLint (APIENTRY * PFNGLGETINSTRUMENTSSGIXPROC) (void);
+typedef void (APIENTRY * PFNGLINSTRUMENTSBUFFERSGIXPROC) (GLsizei size, GLint *buffer);
+typedef GLint (APIENTRY * PFNGLPOLLINSTRUMENTSSGIXPROC) (GLint *marker_p);
+typedef void (APIENTRY * PFNGLREADINSTRUMENTSSGIXPROC) (GLint marker);
+typedef void (APIENTRY * PFNGLSTARTINSTRUMENTSSGIXPROC) (void);
+typedef void (APIENTRY * PFNGLSTOPINSTRUMENTSSGIXPROC) (GLint marker);
+#endif
+
+#ifndef GL_SGIX_texture_scale_bias
+#define GL_SGIX_texture_scale_bias 1
+#endif
+
+#ifndef GL_SGIX_framezoom
+#define GL_SGIX_framezoom 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glFrameZoomSGIX (GLint);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLFRAMEZOOMSGIXPROC) (GLint factor);
+#endif
+
+#ifndef GL_SGIX_tag_sample_buffer
+#define GL_SGIX_tag_sample_buffer 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glTagSampleBufferSGIX (void);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLTAGSAMPLEBUFFERSGIXPROC) (void);
+#endif
+
+#ifndef GL_SGIX_polynomial_ffd
+#define GL_SGIX_polynomial_ffd 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glDeformationMap3dSGIX (GLenum, GLdouble, GLdouble, GLint, GLint, GLdouble, GLdouble, GLint, GLint, GLdouble, GLdouble, GLint, GLint, const GLdouble *);
+extern void APIENTRY glDeformationMap3fSGIX (GLenum, GLfloat, GLfloat, GLint, GLint, GLfloat, GLfloat, GLint, GLint, GLfloat, GLfloat, GLint, GLint, const GLfloat *);
+extern void APIENTRY glDeformSGIX (GLbitfield);
+extern void APIENTRY glLoadIdentityDeformationMapSGIX (GLbitfield);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLDEFORMATIONMAP3DSGIXPROC) (GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, GLdouble w1, GLdouble w2, GLint wstride, GLint worder, const GLdouble *points);
+typedef void (APIENTRY * PFNGLDEFORMATIONMAP3FSGIXPROC) (GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, GLfloat w1, GLfloat w2, GLint wstride, GLint worder, const GLfloat *points);
+typedef void (APIENTRY * PFNGLDEFORMSGIXPROC) (GLbitfield mask);
+typedef void (APIENTRY * PFNGLLOADIDENTITYDEFORMATIONMAPSGIXPROC) (GLbitfield mask);
+#endif
+
+#ifndef GL_SGIX_reference_plane
+#define GL_SGIX_reference_plane 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glReferencePlaneSGIX (const GLdouble *);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLREFERENCEPLANESGIXPROC) (const GLdouble *equation);
+#endif
+
+#ifndef GL_SGIX_flush_raster
+#define GL_SGIX_flush_raster 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glFlushRasterSGIX (void);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLFLUSHRASTERSGIXPROC) (void);
+#endif
+
+#ifndef GL_SGIX_depth_texture
+#define GL_SGIX_depth_texture 1
+#endif
+
+#ifndef GL_SGIS_fog_function
+#define GL_SGIS_fog_function 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glFogFuncSGIS (GLsizei, const GLfloat *);
+extern void APIENTRY glGetFogFuncSGIS (const GLfloat *);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLFOGFUNCSGISPROC) (GLsizei n, const GLfloat *points);
+typedef void (APIENTRY * PFNGLGETFOGFUNCSGISPROC) (const GLfloat *points);
+#endif
+
+#ifndef GL_SGIX_fog_offset
+#define GL_SGIX_fog_offset 1
+#endif
+
+#ifndef GL_HP_image_transform
+#define GL_HP_image_transform 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glImageTransformParameteriHP (GLenum, GLenum, GLint);
+extern void APIENTRY glImageTransformParameterfHP (GLenum, GLenum, GLfloat);
+extern void APIENTRY glImageTransformParameterivHP (GLenum, GLenum, const GLint *);
+extern void APIENTRY glImageTransformParameterfvHP (GLenum, GLenum, const GLfloat *);
+extern void APIENTRY glGetImageTransformParameterivHP (GLenum, GLenum, GLint *);
+extern void APIENTRY glGetImageTransformParameterfvHP (GLenum, GLenum, GLfloat *);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLIMAGETRANSFORMPARAMETERIHPPROC) (GLenum target, GLenum pname, GLint param);
+typedef void (APIENTRY * PFNGLIMAGETRANSFORMPARAMETERFHPPROC) (GLenum target, GLenum pname, GLfloat param);
+typedef void (APIENTRY * PFNGLIMAGETRANSFORMPARAMETERIVHPPROC) (GLenum target, GLenum pname, const GLint *params);
+typedef void (APIENTRY * PFNGLIMAGETRANSFORMPARAMETERFVHPPROC) (GLenum target, GLenum pname, const GLfloat *params);
+typedef void (APIENTRY * PFNGLGETIMAGETRANSFORMPARAMETERIVHPPROC) (GLenum target, GLenum pname, GLint *params);
+typedef void (APIENTRY * PFNGLGETIMAGETRANSFORMPARAMETERFVHPPROC) (GLenum target, GLenum pname, GLfloat *params);
+#endif
+
+#ifndef GL_HP_convolution_border_modes
+#define GL_HP_convolution_border_modes 1
+#endif
+
+#ifndef GL_SGIX_texture_add_env
+#define GL_SGIX_texture_add_env 1
+#endif
+
+#ifndef GL_EXT_color_subtable
+#define GL_EXT_color_subtable 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glColorSubTableEXT (GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *);
+extern void APIENTRY glCopyColorSubTableEXT (GLenum, GLsizei, GLint, GLint, GLsizei);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLCOLORSUBTABLEEXTPROC) (GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data);
+typedef void (APIENTRY * PFNGLCOPYCOLORSUBTABLEEXTPROC) (GLenum target, GLsizei start, GLint x, GLint y, GLsizei width);
+#endif
+
+#ifndef GL_PGI_vertex_hints
+#define GL_PGI_vertex_hints 1
+#endif
+
+#ifndef GL_PGI_misc_hints
+#define GL_PGI_misc_hints 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glHintPGI (GLenum, GLint);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLHINTPGIPROC) (GLenum target, GLint mode);
+#endif
+
+#ifndef GL_EXT_paletted_texture
+#define GL_EXT_paletted_texture 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glColorTableEXT (GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *);
+extern void APIENTRY glGetColorTableEXT (GLenum, GLenum, GLenum, GLvoid *);
+extern void APIENTRY glGetColorTableParameterivEXT (GLenum, GLenum, GLint *);
+extern void APIENTRY glGetColorTableParameterfvEXT (GLenum, GLenum, GLfloat *);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLCOLORTABLEEXTPROC) (GLenum target, GLenum internalFormat, GLsizei width, GLenum format, GLenum type, const GLvoid *table);
+typedef void (APIENTRY * PFNGLGETCOLORTABLEEXTPROC) (GLenum target, GLenum format, GLenum type, GLvoid *data);
+typedef void (APIENTRY * PFNGLGETCOLORTABLEPARAMETERIVEXTPROC) (GLenum target, GLenum pname, GLint *params);
+typedef void (APIENTRY * PFNGLGETCOLORTABLEPARAMETERFVEXTPROC) (GLenum target, GLenum pname, GLfloat *params);
+#endif
+
+#ifndef GL_EXT_clip_volume_hint
+#define GL_EXT_clip_volume_hint 1
+#endif
+
+#ifndef GL_SGIX_list_priority
+#define GL_SGIX_list_priority 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glGetListParameterfvSGIX (GLuint, GLenum, GLfloat *);
+extern void APIENTRY glGetListParameterivSGIX (GLuint, GLenum, GLint *);
+extern void APIENTRY glListParameterfSGIX (GLuint, GLenum, GLfloat);
+extern void APIENTRY glListParameterfvSGIX (GLuint, GLenum, const GLfloat *);
+extern void APIENTRY glListParameteriSGIX (GLuint, GLenum, GLint);
+extern void APIENTRY glListParameterivSGIX (GLuint, GLenum, const GLint *);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLGETLISTPARAMETERFVSGIXPROC) (GLuint list, GLenum pname, GLfloat *params);
+typedef void (APIENTRY * PFNGLGETLISTPARAMETERIVSGIXPROC) (GLuint list, GLenum pname, GLint *params);
+typedef void (APIENTRY * PFNGLLISTPARAMETERFSGIXPROC) (GLuint list, GLenum pname, GLfloat param);
+typedef void (APIENTRY * PFNGLLISTPARAMETERFVSGIXPROC) (GLuint list, GLenum pname, const GLfloat *params);
+typedef void (APIENTRY * PFNGLLISTPARAMETERISGIXPROC) (GLuint list, GLenum pname, GLint param);
+typedef void (APIENTRY * PFNGLLISTPARAMETERIVSGIXPROC) (GLuint list, GLenum pname, const GLint *params);
+#endif
+
+#ifndef GL_SGIX_ir_instrument1
+#define GL_SGIX_ir_instrument1 1
+#endif
+
+#ifndef GL_SGIX_calligraphic_fragment
+#define GL_SGIX_calligraphic_fragment 1
+#endif
+
+#ifndef GL_SGIX_texture_lod_bias
+#define GL_SGIX_texture_lod_bias 1
+#endif
+
+#ifndef GL_SGIX_shadow_ambient
+#define GL_SGIX_shadow_ambient 1
+#endif
+
+#ifndef GL_EXT_index_texture
+#define GL_EXT_index_texture 1
+#endif
+
+#ifndef GL_EXT_index_material
+#define GL_EXT_index_material 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glIndexMaterialEXT (GLenum, GLenum);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLINDEXMATERIALEXTPROC) (GLenum face, GLenum mode);
+#endif
+
+#ifndef GL_EXT_index_func
+#define GL_EXT_index_func 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glIndexFuncEXT (GLenum, GLclampf);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLINDEXFUNCEXTPROC) (GLenum func, GLclampf ref);
+#endif
+
+#ifndef GL_EXT_index_array_formats
+#define GL_EXT_index_array_formats 1
+#endif
+
+#ifndef GL_EXT_compiled_vertex_array
+#define GL_EXT_compiled_vertex_array 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glLockArraysEXT (GLint, GLsizei);
+extern void APIENTRY glUnlockArraysEXT (void);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLLOCKARRAYSEXTPROC) (GLint first, GLsizei count);
+typedef void (APIENTRY * PFNGLUNLOCKARRAYSEXTPROC) (void);
+#endif
+
+#ifndef GL_EXT_cull_vertex
+#define GL_EXT_cull_vertex 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glCullParameterdvEXT (GLenum, GLdouble *);
+extern void APIENTRY glCullParameterfvEXT (GLenum, GLfloat *);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLCULLPARAMETERDVEXTPROC) (GLenum pname, GLdouble *params);
+typedef void (APIENTRY * PFNGLCULLPARAMETERFVEXTPROC) (GLenum pname, GLfloat *params);
+#endif
+
+#ifndef GL_SGIX_ycrcb
+#define GL_SGIX_ycrcb 1
+#endif
+
+#ifndef GL_SGIX_fragment_lighting
+#define GL_SGIX_fragment_lighting 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glFragmentColorMaterialSGIX (GLenum, GLenum);
+extern void APIENTRY glFragmentLightfSGIX (GLenum, GLenum, GLfloat);
+extern void APIENTRY glFragmentLightfvSGIX (GLenum, GLenum, const GLfloat *);
+extern void APIENTRY glFragmentLightiSGIX (GLenum, GLenum, GLint);
+extern void APIENTRY glFragmentLightivSGIX (GLenum, GLenum, const GLint *);
+extern void APIENTRY glFragmentLightModelfSGIX (GLenum, GLfloat);
+extern void APIENTRY glFragmentLightModelfvSGIX (GLenum, const GLfloat *);
+extern void APIENTRY glFragmentLightModeliSGIX (GLenum, GLint);
+extern void APIENTRY glFragmentLightModelivSGIX (GLenum, const GLint *);
+extern void APIENTRY glFragmentMaterialfSGIX (GLenum, GLenum, GLfloat);
+extern void APIENTRY glFragmentMaterialfvSGIX (GLenum, GLenum, const GLfloat *);
+extern void APIENTRY glFragmentMaterialiSGIX (GLenum, GLenum, GLint);
+extern void APIENTRY glFragmentMaterialivSGIX (GLenum, GLenum, const GLint *);
+extern void APIENTRY glGetFragmentLightfvSGIX (GLenum, GLenum, GLfloat *);
+extern void APIENTRY glGetFragmentLightivSGIX (GLenum, GLenum, GLint *);
+extern void APIENTRY glGetFragmentMaterialfvSGIX (GLenum, GLenum, GLfloat *);
+extern void APIENTRY glGetFragmentMaterialivSGIX (GLenum, GLenum, GLint *);
+extern void APIENTRY glLightEnviSGIX (GLenum, GLint);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLFRAGMENTCOLORMATERIALSGIXPROC) (GLenum face, GLenum mode);
+typedef void (APIENTRY * PFNGLFRAGMENTLIGHTFSGIXPROC) (GLenum light, GLenum pname, GLfloat param);
+typedef void (APIENTRY * PFNGLFRAGMENTLIGHTFVSGIXPROC) (GLenum light, GLenum pname, const GLfloat *params);
+typedef void (APIENTRY * PFNGLFRAGMENTLIGHTISGIXPROC) (GLenum light, GLenum pname, GLint param);
+typedef void (APIENTRY * PFNGLFRAGMENTLIGHTIVSGIXPROC) (GLenum light, GLenum pname, const GLint *params);
+typedef void (APIENTRY * PFNGLFRAGMENTLIGHTMODELFSGIXPROC) (GLenum pname, GLfloat param);
+typedef void (APIENTRY * PFNGLFRAGMENTLIGHTMODELFVSGIXPROC) (GLenum pname, const GLfloat *params);
+typedef void (APIENTRY * PFNGLFRAGMENTLIGHTMODELISGIXPROC) (GLenum pname, GLint param);
+typedef void (APIENTRY * PFNGLFRAGMENTLIGHTMODELIVSGIXPROC) (GLenum pname, const GLint *params);
+typedef void (APIENTRY * PFNGLFRAGMENTMATERIALFSGIXPROC) (GLenum face, GLenum pname, GLfloat param);
+typedef void (APIENTRY * PFNGLFRAGMENTMATERIALFVSGIXPROC) (GLenum face, GLenum pname, const GLfloat *params);
+typedef void (APIENTRY * PFNGLFRAGMENTMATERIALISGIXPROC) (GLenum face, GLenum pname, GLint param);
+typedef void (APIENTRY * PFNGLFRAGMENTMATERIALIVSGIXPROC) (GLenum face, GLenum pname, const GLint *params);
+typedef void (APIENTRY * PFNGLGETFRAGMENTLIGHTFVSGIXPROC) (GLenum light, GLenum pname, GLfloat *params);
+typedef void (APIENTRY * PFNGLGETFRAGMENTLIGHTIVSGIXPROC) (GLenum light, GLenum pname, GLint *params);
+typedef void (APIENTRY * PFNGLGETFRAGMENTMATERIALFVSGIXPROC) (GLenum face, GLenum pname, GLfloat *params);
+typedef void (APIENTRY * PFNGLGETFRAGMENTMATERIALIVSGIXPROC) (GLenum face, GLenum pname, GLint *params);
+typedef void (APIENTRY * PFNGLLIGHTENVISGIXPROC) (GLenum pname, GLint param);
+#endif
+
+#ifndef GL_IBM_rasterpos_clip
+#define GL_IBM_rasterpos_clip 1
+#endif
+
+#ifndef GL_HP_texture_lighting
+#define GL_HP_texture_lighting 1
+#endif
+
+#ifndef GL_EXT_draw_range_elements
+#define GL_EXT_draw_range_elements 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glDrawRangeElementsEXT (GLenum, GLuint, GLuint, GLsizei, GLenum, const GLvoid *);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLDRAWRANGEELEMENTSEXTPROC) (GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices);
+#endif
+
+#ifndef GL_WIN_phong_shading
+#define GL_WIN_phong_shading 1
+#endif
+
+#ifndef GL_WIN_specular_fog
+#define GL_WIN_specular_fog 1
+#endif
+
+#ifndef GL_EXT_light_texture
+#define GL_EXT_light_texture 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glApplyTextureEXT (GLenum);
+extern void APIENTRY glTextureLightEXT (GLenum);
+extern void APIENTRY glTextureMaterialEXT (GLenum, GLenum);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLAPPLYTEXTUREEXTPROC) (GLenum mode);
+typedef void (APIENTRY * PFNGLTEXTURELIGHTEXTPROC) (GLenum pname);
+typedef void (APIENTRY * PFNGLTEXTUREMATERIALEXTPROC) (GLenum face, GLenum mode);
+#endif
+
+#ifndef GL_SGIX_blend_alpha_minmax
+#define GL_SGIX_blend_alpha_minmax 1
+#endif
+
+#ifndef GL_EXT_bgra
+#define GL_EXT_bgra 1
+#endif
+
+#ifndef GL_SGIX_async
+#define GL_SGIX_async 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glAsyncMarkerSGIX (GLuint);
+extern GLint APIENTRY glFinishAsyncSGIX (GLuint *);
+extern GLint APIENTRY glPollAsyncSGIX (GLuint *);
+extern GLuint APIENTRY glGenAsyncMarkersSGIX (GLsizei);
+extern void APIENTRY glDeleteAsyncMarkersSGIX (GLuint, GLsizei);
+extern GLboolean APIENTRY glIsAsyncMarkerSGIX (GLuint);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLASYNCMARKERSGIXPROC) (GLuint marker);
+typedef GLint (APIENTRY * PFNGLFINISHASYNCSGIXPROC) (GLuint *markerp);
+typedef GLint (APIENTRY * PFNGLPOLLASYNCSGIXPROC) (GLuint *markerp);
+typedef GLuint (APIENTRY * PFNGLGENASYNCMARKERSSGIXPROC) (GLsizei range);
+typedef void (APIENTRY * PFNGLDELETEASYNCMARKERSSGIXPROC) (GLuint marker, GLsizei range);
+typedef GLboolean (APIENTRY * PFNGLISASYNCMARKERSGIXPROC) (GLuint marker);
+#endif
+
+#ifndef GL_SGIX_async_pixel
+#define GL_SGIX_async_pixel 1
+#endif
+
+#ifndef GL_SGIX_async_histogram
+#define GL_SGIX_async_histogram 1
+#endif
+
+#ifndef GL_INTEL_parallel_arrays
+#define GL_INTEL_parallel_arrays 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glVertexPointervINTEL (GLint, GLenum, const GLvoid* *);
+extern void APIENTRY glNormalPointervINTEL (GLenum, const GLvoid* *);
+extern void APIENTRY glColorPointervINTEL (GLint, GLenum, const GLvoid* *);
+extern void APIENTRY glTexCoordPointervINTEL (GLint, GLenum, const GLvoid* *);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLVERTEXPOINTERVINTELPROC) (GLint size, GLenum type, const GLvoid* *pointer);
+typedef void (APIENTRY * PFNGLNORMALPOINTERVINTELPROC) (GLenum type, const GLvoid* *pointer);
+typedef void (APIENTRY * PFNGLCOLORPOINTERVINTELPROC) (GLint size, GLenum type, const GLvoid* *pointer);
+typedef void (APIENTRY * PFNGLTEXCOORDPOINTERVINTELPROC) (GLint size, GLenum type, const GLvoid* *pointer);
+#endif
+
+#ifndef GL_HP_occlusion_test
+#define GL_HP_occlusion_test 1
+#endif
+
+#ifndef GL_EXT_pixel_transform
+#define GL_EXT_pixel_transform 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glPixelTransformParameteriEXT (GLenum, GLenum, GLint);
+extern void APIENTRY glPixelTransformParameterfEXT (GLenum, GLenum, GLfloat);
+extern void APIENTRY glPixelTransformParameterivEXT (GLenum, GLenum, const GLint *);
+extern void APIENTRY glPixelTransformParameterfvEXT (GLenum, GLenum, const GLfloat *);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLPIXELTRANSFORMPARAMETERIEXTPROC) (GLenum target, GLenum pname, GLint param);
+typedef void (APIENTRY * PFNGLPIXELTRANSFORMPARAMETERFEXTPROC) (GLenum target, GLenum pname, GLfloat param);
+typedef void (APIENTRY * PFNGLPIXELTRANSFORMPARAMETERIVEXTPROC) (GLenum target, GLenum pname, const GLint *params);
+typedef void (APIENTRY * PFNGLPIXELTRANSFORMPARAMETERFVEXTPROC) (GLenum target, GLenum pname, const GLfloat *params);
+#endif
+
+#ifndef GL_EXT_pixel_transform_color_table
+#define GL_EXT_pixel_transform_color_table 1
+#endif
+
+#ifndef GL_EXT_shared_texture_palette
+#define GL_EXT_shared_texture_palette 1
+#endif
+
+#ifndef GL_EXT_separate_specular_color
+#define GL_EXT_separate_specular_color 1
+#endif
+
+#ifndef GL_EXT_secondary_color
+#define GL_EXT_secondary_color 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glSecondaryColor3bEXT (GLbyte, GLbyte, GLbyte);
+extern void APIENTRY glSecondaryColor3bvEXT (const GLbyte *);
+extern void APIENTRY glSecondaryColor3dEXT (GLdouble, GLdouble, GLdouble);
+extern void APIENTRY glSecondaryColor3dvEXT (const GLdouble *);
+extern void APIENTRY glSecondaryColor3fEXT (GLfloat, GLfloat, GLfloat);
+extern void APIENTRY glSecondaryColor3fvEXT (const GLfloat *);
+extern void APIENTRY glSecondaryColor3iEXT (GLint, GLint, GLint);
+extern void APIENTRY glSecondaryColor3ivEXT (const GLint *);
+extern void APIENTRY glSecondaryColor3sEXT (GLshort, GLshort, GLshort);
+extern void APIENTRY glSecondaryColor3svEXT (const GLshort *);
+extern void APIENTRY glSecondaryColor3ubEXT (GLubyte, GLubyte, GLubyte);
+extern void APIENTRY glSecondaryColor3ubvEXT (const GLubyte *);
+extern void APIENTRY glSecondaryColor3uiEXT (GLuint, GLuint, GLuint);
+extern void APIENTRY glSecondaryColor3uivEXT (const GLuint *);
+extern void APIENTRY glSecondaryColor3usEXT (GLushort, GLushort, GLushort);
+extern void APIENTRY glSecondaryColor3usvEXT (const GLushort *);
+extern void APIENTRY glSecondaryColorPointerEXT (GLint, GLenum, GLsizei, GLvoid *);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLSECONDARYCOLOR3BEXTPROC) (GLbyte red, GLbyte green, GLbyte blue);
+typedef void (APIENTRY * PFNGLSECONDARYCOLOR3BVEXTPROC) (const GLbyte *v);
+typedef void (APIENTRY * PFNGLSECONDARYCOLOR3DEXTPROC) (GLdouble red, GLdouble green, GLdouble blue);
+typedef void (APIENTRY * PFNGLSECONDARYCOLOR3DVEXTPROC) (const GLdouble *v);
+typedef void (APIENTRY * PFNGLSECONDARYCOLOR3FEXTPROC) (GLfloat red, GLfloat green, GLfloat blue);
+typedef void (APIENTRY * PFNGLSECONDARYCOLOR3FVEXTPROC) (const GLfloat *v);
+typedef void (APIENTRY * PFNGLSECONDARYCOLOR3IEXTPROC) (GLint red, GLint green, GLint blue);
+typedef void (APIENTRY * PFNGLSECONDARYCOLOR3IVEXTPROC) (const GLint *v);
+typedef void (APIENTRY * PFNGLSECONDARYCOLOR3SEXTPROC) (GLshort red, GLshort green, GLshort blue);
+typedef void (APIENTRY * PFNGLSECONDARYCOLOR3SVEXTPROC) (const GLshort *v);
+typedef void (APIENTRY * PFNGLSECONDARYCOLOR3UBEXTPROC) (GLubyte red, GLubyte green, GLubyte blue);
+typedef void (APIENTRY * PFNGLSECONDARYCOLOR3UBVEXTPROC) (const GLubyte *v);
+typedef void (APIENTRY * PFNGLSECONDARYCOLOR3UIEXTPROC) (GLuint red, GLuint green, GLuint blue);
+typedef void (APIENTRY * PFNGLSECONDARYCOLOR3UIVEXTPROC) (const GLuint *v);
+typedef void (APIENTRY * PFNGLSECONDARYCOLOR3USEXTPROC) (GLushort red, GLushort green, GLushort blue);
+typedef void (APIENTRY * PFNGLSECONDARYCOLOR3USVEXTPROC) (const GLushort *v);
+typedef void (APIENTRY * PFNGLSECONDARYCOLORPOINTEREXTPROC) (GLint size, GLenum type, GLsizei stride, GLvoid *pointer);
+#endif
+
+#ifndef GL_EXT_texture_perturb_normal
+#define GL_EXT_texture_perturb_normal 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glTextureNormalEXT (GLenum);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLTEXTURENORMALEXTPROC) (GLenum mode);
+#endif
+
+#ifndef GL_EXT_multi_draw_arrays
+#define GL_EXT_multi_draw_arrays 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glMultiDrawArraysEXT (GLenum, GLint *, GLsizei *, GLsizei);
+extern void APIENTRY glMultiDrawElementsEXT (GLenum, const GLsizei *, GLenum, const GLvoid* *, GLsizei);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLMULTIDRAWARRAYSEXTPROC) (GLenum mode, GLint *first, GLsizei *count, GLsizei primcount);
+typedef void (APIENTRY * PFNGLMULTIDRAWELEMENTSEXTPROC) (GLenum mode, const GLsizei *count, GLenum type, const GLvoid* *indices, GLsizei primcount);
+#endif
+
+#ifndef GL_EXT_fog_coord
+#define GL_EXT_fog_coord 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glFogCoordfEXT (GLfloat);
+extern void APIENTRY glFogCoordfvEXT (const GLfloat *);
+extern void APIENTRY glFogCoorddEXT (GLdouble);
+extern void APIENTRY glFogCoorddvEXT (const GLdouble *);
+extern void APIENTRY glFogCoordPointerEXT (GLenum, GLsizei, const GLvoid *);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLFOGCOORDFEXTPROC) (GLfloat coord);
+typedef void (APIENTRY * PFNGLFOGCOORDFVEXTPROC) (const GLfloat *coord);
+typedef void (APIENTRY * PFNGLFOGCOORDDEXTPROC) (GLdouble coord);
+typedef void (APIENTRY * PFNGLFOGCOORDDVEXTPROC) (const GLdouble *coord);
+typedef void (APIENTRY * PFNGLFOGCOORDPOINTEREXTPROC) (GLenum type, GLsizei stride, const GLvoid *pointer);
+#endif
+
+#ifndef GL_REND_screen_coordinates
+#define GL_REND_screen_coordinates 1
+#endif
+
+#ifndef GL_EXT_coordinate_frame
+#define GL_EXT_coordinate_frame 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glTangent3bEXT (GLbyte, GLbyte, GLbyte);
+extern void APIENTRY glTangent3bvEXT (const GLbyte *);
+extern void APIENTRY glTangent3dEXT (GLdouble, GLdouble, GLdouble);
+extern void APIENTRY glTangent3dvEXT (const GLdouble *);
+extern void APIENTRY glTangent3fEXT (GLfloat, GLfloat, GLfloat);
+extern void APIENTRY glTangent3fvEXT (const GLfloat *);
+extern void APIENTRY glTangent3iEXT (GLint, GLint, GLint);
+extern void APIENTRY glTangent3ivEXT (const GLint *);
+extern void APIENTRY glTangent3sEXT (GLshort, GLshort, GLshort);
+extern void APIENTRY glTangent3svEXT (const GLshort *);
+extern void APIENTRY glBinormal3bEXT (GLbyte, GLbyte, GLbyte);
+extern void APIENTRY glBinormal3bvEXT (const GLbyte *);
+extern void APIENTRY glBinormal3dEXT (GLdouble, GLdouble, GLdouble);
+extern void APIENTRY glBinormal3dvEXT (const GLdouble *);
+extern void APIENTRY glBinormal3fEXT (GLfloat, GLfloat, GLfloat);
+extern void APIENTRY glBinormal3fvEXT (const GLfloat *);
+extern void APIENTRY glBinormal3iEXT (GLint, GLint, GLint);
+extern void APIENTRY glBinormal3ivEXT (const GLint *);
+extern void APIENTRY glBinormal3sEXT (GLshort, GLshort, GLshort);
+extern void APIENTRY glBinormal3svEXT (const GLshort *);
+extern void APIENTRY glTangentPointerEXT (GLenum, GLsizei, const GLvoid *);
+extern void APIENTRY glBinormalPointerEXT (GLenum, GLsizei, const GLvoid *);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLTANGENT3BEXTPROC) (GLbyte tx, GLbyte ty, GLbyte tz);
+typedef void (APIENTRY * PFNGLTANGENT3BVEXTPROC) (const GLbyte *v);
+typedef void (APIENTRY * PFNGLTANGENT3DEXTPROC) (GLdouble tx, GLdouble ty, GLdouble tz);
+typedef void (APIENTRY * PFNGLTANGENT3DVEXTPROC) (const GLdouble *v);
+typedef void (APIENTRY * PFNGLTANGENT3FEXTPROC) (GLfloat tx, GLfloat ty, GLfloat tz);
+typedef void (APIENTRY * PFNGLTANGENT3FVEXTPROC) (const GLfloat *v);
+typedef void (APIENTRY * PFNGLTANGENT3IEXTPROC) (GLint tx, GLint ty, GLint tz);
+typedef void (APIENTRY * PFNGLTANGENT3IVEXTPROC) (const GLint *v);
+typedef void (APIENTRY * PFNGLTANGENT3SEXTPROC) (GLshort tx, GLshort ty, GLshort tz);
+typedef void (APIENTRY * PFNGLTANGENT3SVEXTPROC) (const GLshort *v);
+typedef void (APIENTRY * PFNGLBINORMAL3BEXTPROC) (GLbyte bx, GLbyte by, GLbyte bz);
+typedef void (APIENTRY * PFNGLBINORMAL3BVEXTPROC) (const GLbyte *v);
+typedef void (APIENTRY * PFNGLBINORMAL3DEXTPROC) (GLdouble bx, GLdouble by, GLdouble bz);
+typedef void (APIENTRY * PFNGLBINORMAL3DVEXTPROC) (const GLdouble *v);
+typedef void (APIENTRY * PFNGLBINORMAL3FEXTPROC) (GLfloat bx, GLfloat by, GLfloat bz);
+typedef void (APIENTRY * PFNGLBINORMAL3FVEXTPROC) (const GLfloat *v);
+typedef void (APIENTRY * PFNGLBINORMAL3IEXTPROC) (GLint bx, GLint by, GLint bz);
+typedef void (APIENTRY * PFNGLBINORMAL3IVEXTPROC) (const GLint *v);
+typedef void (APIENTRY * PFNGLBINORMAL3SEXTPROC) (GLshort bx, GLshort by, GLshort bz);
+typedef void (APIENTRY * PFNGLBINORMAL3SVEXTPROC) (const GLshort *v);
+typedef void (APIENTRY * PFNGLTANGENTPOINTEREXTPROC) (GLenum type, GLsizei stride, const GLvoid *pointer);
+typedef void (APIENTRY * PFNGLBINORMALPOINTEREXTPROC) (GLenum type, GLsizei stride, const GLvoid *pointer);
+#endif
+
+#ifndef GL_EXT_texture_env_combine
+#define GL_EXT_texture_env_combine 1
+#endif
+
+#ifndef GL_APPLE_specular_vector
+#define GL_APPLE_specular_vector 1
+#endif
+
+#ifndef GL_APPLE_transform_hint
+#define GL_APPLE_transform_hint 1
+#endif
+
+#ifndef GL_SGIX_fog_scale
+#define GL_SGIX_fog_scale 1
+#endif
+
+#ifndef GL_SUNX_constant_data
+#define GL_SUNX_constant_data 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glFinishTextureSUNX (void);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLFINISHTEXTURESUNXPROC) (void);
+#endif
+
+#ifndef GL_SUN_global_alpha
+#define GL_SUN_global_alpha 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glGlobalAlphaFactorbSUN (GLbyte);
+extern void APIENTRY glGlobalAlphaFactorsSUN (GLshort);
+extern void APIENTRY glGlobalAlphaFactoriSUN (GLint);
+extern void APIENTRY glGlobalAlphaFactorfSUN (GLfloat);
+extern void APIENTRY glGlobalAlphaFactordSUN (GLdouble);
+extern void APIENTRY glGlobalAlphaFactorubSUN (GLubyte);
+extern void APIENTRY glGlobalAlphaFactorusSUN (GLushort);
+extern void APIENTRY glGlobalAlphaFactoruiSUN (GLuint);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLGLOBALALPHAFACTORBSUNPROC) (GLbyte factor);
+typedef void (APIENTRY * PFNGLGLOBALALPHAFACTORSSUNPROC) (GLshort factor);
+typedef void (APIENTRY * PFNGLGLOBALALPHAFACTORISUNPROC) (GLint factor);
+typedef void (APIENTRY * PFNGLGLOBALALPHAFACTORFSUNPROC) (GLfloat factor);
+typedef void (APIENTRY * PFNGLGLOBALALPHAFACTORDSUNPROC) (GLdouble factor);
+typedef void (APIENTRY * PFNGLGLOBALALPHAFACTORUBSUNPROC) (GLubyte factor);
+typedef void (APIENTRY * PFNGLGLOBALALPHAFACTORUSSUNPROC) (GLushort factor);
+typedef void (APIENTRY * PFNGLGLOBALALPHAFACTORUISUNPROC) (GLuint factor);
+#endif
+
+#ifndef GL_SUN_triangle_list
+#define GL_SUN_triangle_list 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glReplacementCodeuiSUN (GLuint);
+extern void APIENTRY glReplacementCodeusSUN (GLushort);
+extern void APIENTRY glReplacementCodeubSUN (GLubyte);
+extern void APIENTRY glReplacementCodeuivSUN (const GLuint *);
+extern void APIENTRY glReplacementCodeusvSUN (const GLushort *);
+extern void APIENTRY glReplacementCodeubvSUN (const GLubyte *);
+extern void APIENTRY glReplacementCodePointerSUN (GLenum, GLsizei, const GLvoid* *);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLREPLACEMENTCODEUISUNPROC) (GLuint code);
+typedef void (APIENTRY * PFNGLREPLACEMENTCODEUSSUNPROC) (GLushort code);
+typedef void (APIENTRY * PFNGLREPLACEMENTCODEUBSUNPROC) (GLubyte code);
+typedef void (APIENTRY * PFNGLREPLACEMENTCODEUIVSUNPROC) (const GLuint *code);
+typedef void (APIENTRY * PFNGLREPLACEMENTCODEUSVSUNPROC) (const GLushort *code);
+typedef void (APIENTRY * PFNGLREPLACEMENTCODEUBVSUNPROC) (const GLubyte *code);
+typedef void (APIENTRY * PFNGLREPLACEMENTCODEPOINTERSUNPROC) (GLenum type, GLsizei stride, const GLvoid* *pointer);
+#endif
+
+#ifndef GL_SUN_vertex
+#define GL_SUN_vertex 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glColor4ubVertex2fSUN (GLubyte, GLubyte, GLubyte, GLubyte, GLfloat, GLfloat);
+extern void APIENTRY glColor4ubVertex2fvSUN (const GLubyte *, const GLfloat *);
+extern void APIENTRY glColor4ubVertex3fSUN (GLubyte, GLubyte, GLubyte, GLubyte, GLfloat, GLfloat, GLfloat);
+extern void APIENTRY glColor4ubVertex3fvSUN (const GLubyte *, const GLfloat *);
+extern void APIENTRY glColor3fVertex3fSUN (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
+extern void APIENTRY glColor3fVertex3fvSUN (const GLfloat *, const GLfloat *);
+extern void APIENTRY glNormal3fVertex3fSUN (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
+extern void APIENTRY glNormal3fVertex3fvSUN (const GLfloat *, const GLfloat *);
+extern void APIENTRY glColor4fNormal3fVertex3fSUN (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
+extern void APIENTRY glColor4fNormal3fVertex3fvSUN (const GLfloat *, const GLfloat *, const GLfloat *);
+extern void APIENTRY glTexCoord2fVertex3fSUN (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
+extern void APIENTRY glTexCoord2fVertex3fvSUN (const GLfloat *, const GLfloat *);
+extern void APIENTRY glTexCoord4fVertex4fSUN (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
+extern void APIENTRY glTexCoord4fVertex4fvSUN (const GLfloat *, const GLfloat *);
+extern void APIENTRY glTexCoord2fColor4ubVertex3fSUN (GLfloat, GLfloat, GLubyte, GLubyte, GLubyte, GLubyte, GLfloat, GLfloat, GLfloat);
+extern void APIENTRY glTexCoord2fColor4ubVertex3fvSUN (const GLfloat *, const GLubyte *, const GLfloat *);
+extern void APIENTRY glTexCoord2fColor3fVertex3fSUN (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
+extern void APIENTRY glTexCoord2fColor3fVertex3fvSUN (const GLfloat *, const GLfloat *, const GLfloat *);
+extern void APIENTRY glTexCoord2fNormal3fVertex3fSUN (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
+extern void APIENTRY glTexCoord2fNormal3fVertex3fvSUN (const GLfloat *, const GLfloat *, const GLfloat *);
+extern void APIENTRY glTexCoord2fColor4fNormal3fVertex3fSUN (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
+extern void APIENTRY glTexCoord2fColor4fNormal3fVertex3fvSUN (const GLfloat *, const GLfloat *, const GLfloat *, const GLfloat *);
+extern void APIENTRY glTexCoord4fColor4fNormal3fVertex4fSUN (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
+extern void APIENTRY glTexCoord4fColor4fNormal3fVertex4fvSUN (const GLfloat *, const GLfloat *, const GLfloat *, const GLfloat *);
+extern void APIENTRY glReplacementCodeuiVertex3fSUN (GLenum, GLfloat, GLfloat, GLfloat);
+extern void APIENTRY glReplacementCodeuiVertex3fvSUN (const GLenum *, const GLfloat *);
+extern void APIENTRY glReplacementCodeuiColor4ubVertex3fSUN (GLenum, GLubyte, GLubyte, GLubyte, GLubyte, GLfloat, GLfloat, GLfloat);
+extern void APIENTRY glReplacementCodeuiColor4ubVertex3fvSUN (const GLenum *, const GLubyte *, const GLfloat *);
+extern void APIENTRY glReplacementCodeuiColor3fVertex3fSUN (GLenum, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
+extern void APIENTRY glReplacementCodeuiColor3fVertex3fvSUN (const GLenum *, const GLfloat *, const GLfloat *);
+extern void APIENTRY glReplacementCodeuiNormal3fVertex3fSUN (GLenum, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
+extern void APIENTRY glReplacementCodeuiNormal3fVertex3fvSUN (const GLenum *, const GLfloat *, const GLfloat *);
+extern void APIENTRY glReplacementCodeuiColor4fNormal3fVertex3fSUN (GLenum, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
+extern void APIENTRY glReplacementCodeuiColor4fNormal3fVertex3fvSUN (const GLenum *, const GLfloat *, const GLfloat *, const GLfloat *);
+extern void APIENTRY glReplacementCodeuiTexCoord2fVertex3fSUN (GLenum, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
+extern void APIENTRY glReplacementCodeuiTexCoord2fVertex3fvSUN (const GLenum *, const GLfloat *, const GLfloat *);
+extern void APIENTRY glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN (GLenum, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
+extern void APIENTRY glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN (const GLenum *, const GLfloat *, const GLfloat *, const GLfloat *);
+extern void APIENTRY glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN (GLenum, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
+extern void APIENTRY glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN (const GLenum *, const GLfloat *, const GLfloat *, const GLfloat *, const GLfloat *);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLCOLOR4UBVERTEX2FSUNPROC) (GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y);
+typedef void (APIENTRY * PFNGLCOLOR4UBVERTEX2FVSUNPROC) (const GLubyte *c, const GLfloat *v);
+typedef void (APIENTRY * PFNGLCOLOR4UBVERTEX3FSUNPROC) (GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y, GLfloat z);
+typedef void (APIENTRY * PFNGLCOLOR4UBVERTEX3FVSUNPROC) (const GLubyte *c, const GLfloat *v);
+typedef void (APIENTRY * PFNGLCOLOR3FVERTEX3FSUNPROC) (GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat z);
+typedef void (APIENTRY * PFNGLCOLOR3FVERTEX3FVSUNPROC) (const GLfloat *c, const GLfloat *v);
+typedef void (APIENTRY * PFNGLNORMAL3FVERTEX3FSUNPROC) (GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z);
+typedef void (APIENTRY * PFNGLNORMAL3FVERTEX3FVSUNPROC) (const GLfloat *n, const GLfloat *v);
+typedef void (APIENTRY * PFNGLCOLOR4FNORMAL3FVERTEX3FSUNPROC) (GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z);
+typedef void (APIENTRY * PFNGLCOLOR4FNORMAL3FVERTEX3FVSUNPROC) (const GLfloat *c, const GLfloat *n, const GLfloat *v);
+typedef void (APIENTRY * PFNGLTEXCOORD2FVERTEX3FSUNPROC) (GLfloat s, GLfloat t, GLfloat x, GLfloat y, GLfloat z);
+typedef void (APIENTRY * PFNGLTEXCOORD2FVERTEX3FVSUNPROC) (const GLfloat *tc, const GLfloat *v);
+typedef void (APIENTRY * PFNGLTEXCOORD4FVERTEX4FSUNPROC) (GLfloat s, GLfloat t, GLfloat p, GLfloat q, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+typedef void (APIENTRY * PFNGLTEXCOORD4FVERTEX4FVSUNPROC) (const GLfloat *tc, const GLfloat *v);
+typedef void (APIENTRY * PFNGLTEXCOORD2FCOLOR4UBVERTEX3FSUNPROC) (GLfloat s, GLfloat t, GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y, GLfloat z);
+typedef void (APIENTRY * PFNGLTEXCOORD2FCOLOR4UBVERTEX3FVSUNPROC) (const GLfloat *tc, const GLubyte *c, const GLfloat *v);
+typedef void (APIENTRY * PFNGLTEXCOORD2FCOLOR3FVERTEX3FSUNPROC) (GLfloat s, GLfloat t, GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat z);
+typedef void (APIENTRY * PFNGLTEXCOORD2FCOLOR3FVERTEX3FVSUNPROC) (const GLfloat *tc, const GLfloat *c, const GLfloat *v);
+typedef void (APIENTRY * PFNGLTEXCOORD2FNORMAL3FVERTEX3FSUNPROC) (GLfloat s, GLfloat t, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z);
+typedef void (APIENTRY * PFNGLTEXCOORD2FNORMAL3FVERTEX3FVSUNPROC) (const GLfloat *tc, const GLfloat *n, const GLfloat *v);
+typedef void (APIENTRY * PFNGLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC) (GLfloat s, GLfloat t, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z);
+typedef void (APIENTRY * PFNGLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC) (const GLfloat *tc, const GLfloat *c, const GLfloat *n, const GLfloat *v);
+typedef void (APIENTRY * PFNGLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FSUNPROC) (GLfloat s, GLfloat t, GLfloat p, GLfloat q, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+typedef void (APIENTRY * PFNGLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FVSUNPROC) (const GLfloat *tc, const GLfloat *c, const GLfloat *n, const GLfloat *v);
+typedef void (APIENTRY * PFNGLREPLACEMENTCODEUIVERTEX3FSUNPROC) (GLenum rc, GLfloat x, GLfloat y, GLfloat z);
+typedef void (APIENTRY * PFNGLREPLACEMENTCODEUIVERTEX3FVSUNPROC) (const GLenum *rc, const GLfloat *v);
+typedef void (APIENTRY * PFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FSUNPROC) (GLenum rc, GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y, GLfloat z);
+typedef void (APIENTRY * PFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FVSUNPROC) (const GLenum *rc, const GLubyte *c, const GLfloat *v);
+typedef void (APIENTRY * PFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FSUNPROC) (GLenum rc, GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat z);
+typedef void (APIENTRY * PFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FVSUNPROC) (const GLenum *rc, const GLfloat *c, const GLfloat *v);
+typedef void (APIENTRY * PFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FSUNPROC) (GLenum rc, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z);
+typedef void (APIENTRY * PFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FVSUNPROC) (const GLenum *rc, const GLfloat *n, const GLfloat *v);
+typedef void (APIENTRY * PFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FSUNPROC) (GLenum rc, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z);
+typedef void (APIENTRY * PFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FVSUNPROC) (const GLenum *rc, const GLfloat *c, const GLfloat *n, const GLfloat *v);
+typedef void (APIENTRY * PFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FSUNPROC) (GLenum rc, GLfloat s, GLfloat t, GLfloat x, GLfloat y, GLfloat z);
+typedef void (APIENTRY * PFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FVSUNPROC) (const GLenum *rc, const GLfloat *tc, const GLfloat *v);
+typedef void (APIENTRY * PFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FSUNPROC) (GLenum rc, GLfloat s, GLfloat t, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z);
+typedef void (APIENTRY * PFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FVSUNPROC) (const GLenum *rc, const GLfloat *tc, const GLfloat *n, const GLfloat *v);
+typedef void (APIENTRY * PFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC) (GLenum rc, GLfloat s, GLfloat t, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z);
+typedef void (APIENTRY * PFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC) (const GLenum *rc, const GLfloat *tc, const GLfloat *c, const GLfloat *n, const GLfloat *v);
+#endif
+
+#ifndef GL_EXT_blend_func_separate
+#define GL_EXT_blend_func_separate 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glBlendFuncSeparateEXT (GLenum, GLenum, GLenum, GLenum);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLBLENDFUNCSEPARATEEXTPROC) (GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);
+#endif
+
+#ifndef GL_INGR_color_clamp
+#define GL_INGR_color_clamp 1
+#endif
+
+#ifndef GL_INGR_interlace_read
+#define GL_INGR_interlace_read 1
+#endif
+
+#ifndef GL_EXT_stencil_wrap
+#define GL_EXT_stencil_wrap 1
+#endif
+
+#ifndef GL_EXT_422_pixels
+#define GL_EXT_422_pixels 1
+#endif
+
+#ifndef GL_NV_texgen_reflection
+#define GL_NV_texgen_reflection 1
+#endif
+
+#ifndef GL_SUN_convolution_border_modes
+#define GL_SUN_convolution_border_modes 1
+#endif
+
+#ifndef GL_EXT_texture_env_add
+#define GL_EXT_texture_env_add 1
+#endif
+
+#ifndef GL_EXT_texture_lod_bias
+#define GL_EXT_texture_lod_bias 1
+#endif
+
+#ifndef GL_EXT_texture_filter_anisotropic
+#define GL_EXT_texture_filter_anisotropic 1
+#endif
+
+#ifndef GL_EXT_vertex_weighting
+#define GL_EXT_vertex_weighting 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glVertexWeightfEXT (GLfloat);
+extern void APIENTRY glVertexWeightfvEXT (const GLfloat *);
+extern void APIENTRY glVertexWeightPointerEXT (GLsizei, GLenum, GLsizei, const GLvoid *);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLVERTEXWEIGHTFEXTPROC) (GLfloat weight);
+typedef void (APIENTRY * PFNGLVERTEXWEIGHTFVEXTPROC) (const GLfloat *weight);
+typedef void (APIENTRY * PFNGLVERTEXWEIGHTPOINTEREXTPROC) (GLsizei size, GLenum type, GLsizei stride, const GLvoid *pointer);
+#endif
+
+#ifndef GL_NV_light_max_exponent
+#define GL_NV_light_max_exponent 1
+#endif
+
+#ifndef GL_NV_vertex_array_range
+#define GL_NV_vertex_array_range 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glFlushVertexArrayRangeNV (void);
+extern void APIENTRY glVertexArrayRangeNV (GLsizei, const GLvoid *);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLFLUSHVERTEXARRAYRANGENVPROC) (void);
+typedef void (APIENTRY * PFNGLVERTEXARRAYRANGENVPROC) (GLsizei size, const GLvoid *pointer);
+#endif
+
+#ifndef GL_NV_register_combiners
+#define GL_NV_register_combiners 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glCombinerParameterfvNV (GLenum, const GLfloat *);
+extern void APIENTRY glCombinerParameterfNV (GLenum, GLfloat);
+extern void APIENTRY glCombinerParameterivNV (GLenum, const GLint *);
+extern void APIENTRY glCombinerParameteriNV (GLenum, GLint);
+extern void APIENTRY glCombinerInputNV (GLenum, GLenum, GLenum, GLenum, GLenum, GLenum);
+extern void APIENTRY glCombinerOutputNV (GLenum, GLenum, GLenum, GLenum, GLenum, GLenum, GLenum, GLboolean, GLboolean, GLboolean);
+extern void APIENTRY glFinalCombinerInputNV (GLenum, GLenum, GLenum, GLenum);
+extern void APIENTRY glGetCombinerInputParameterfvNV (GLenum, GLenum, GLenum, GLenum, GLfloat *);
+extern void APIENTRY glGetCombinerInputParameterivNV (GLenum, GLenum, GLenum, GLenum, GLint *);
+extern void APIENTRY glGetCombinerOutputParameterfvNV (GLenum, GLenum, GLenum, GLfloat *);
+extern void APIENTRY glGetCombinerOutputParameterivNV (GLenum, GLenum, GLenum, GLint *);
+extern void APIENTRY glGetFinalCombinerInputParameterfvNV (GLenum, GLenum, GLfloat *);
+extern void APIENTRY glGetFinalCombinerInputParameterivNV (GLenum, GLenum, GLint *);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLCOMBINERPARAMETERFVNVPROC) (GLenum pname, const GLfloat *params);
+typedef void (APIENTRY * PFNGLCOMBINERPARAMETERFNVPROC) (GLenum pname, GLfloat param);
+typedef void (APIENTRY * PFNGLCOMBINERPARAMETERIVNVPROC) (GLenum pname, const GLint *params);
+typedef void (APIENTRY * PFNGLCOMBINERPARAMETERINVPROC) (GLenum pname, GLint param);
+typedef void (APIENTRY * PFNGLCOMBINERINPUTNVPROC) (GLenum stage, GLenum portion, GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage);
+typedef void (APIENTRY * PFNGLCOMBINEROUTPUTNVPROC) (GLenum stage, GLenum portion, GLenum abOutput, GLenum cdOutput, GLenum sumOutput, GLenum scale, GLenum bias, GLboolean abDotProduct, GLboolean cdDotProduct, GLboolean muxSum);
+typedef void (APIENTRY * PFNGLFINALCOMBINERINPUTNVPROC) (GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage);
+typedef void (APIENTRY * PFNGLGETCOMBINERINPUTPARAMETERFVNVPROC) (GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLfloat *params);
+typedef void (APIENTRY * PFNGLGETCOMBINERINPUTPARAMETERIVNVPROC) (GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLint *params);
+typedef void (APIENTRY * PFNGLGETCOMBINEROUTPUTPARAMETERFVNVPROC) (GLenum stage, GLenum portion, GLenum pname, GLfloat *params);
+typedef void (APIENTRY * PFNGLGETCOMBINEROUTPUTPARAMETERIVNVPROC) (GLenum stage, GLenum portion, GLenum pname, GLint *params);
+typedef void (APIENTRY * PFNGLGETFINALCOMBINERINPUTPARAMETERFVNVPROC) (GLenum variable, GLenum pname, GLfloat *params);
+typedef void (APIENTRY * PFNGLGETFINALCOMBINERINPUTPARAMETERIVNVPROC) (GLenum variable, GLenum pname, GLint *params);
+#endif
+
+#ifndef GL_NV_fog_distance
+#define GL_NV_fog_distance 1
+#endif
+
+#ifndef GL_NV_texgen_emboss
+#define GL_NV_texgen_emboss 1
+#endif
+
+#ifndef GL_NV_blend_square
+#define GL_NV_blend_square 1
+#endif
+
+#ifndef GL_NV_texture_env_combine4
+#define GL_NV_texture_env_combine4 1
+#endif
+
+#ifndef GL_MESA_resize_buffers
+#define GL_MESA_resize_buffers 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glResizeBuffersMESA (void);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLRESIZEBUFFERSMESAPROC) (void);
+#endif
+
+#ifndef GL_MESA_window_pos
+#define GL_MESA_window_pos 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glWindowPos2dMESA (GLdouble, GLdouble);
+extern void APIENTRY glWindowPos2dvMESA (const GLdouble *);
+extern void APIENTRY glWindowPos2fMESA (GLfloat, GLfloat);
+extern void APIENTRY glWindowPos2fvMESA (const GLfloat *);
+extern void APIENTRY glWindowPos2iMESA (GLint, GLint);
+extern void APIENTRY glWindowPos2ivMESA (const GLint *);
+extern void APIENTRY glWindowPos2sMESA (GLshort, GLshort);
+extern void APIENTRY glWindowPos2svMESA (const GLshort *);
+extern void APIENTRY glWindowPos3dMESA (GLdouble, GLdouble, GLdouble);
+extern void APIENTRY glWindowPos3dvMESA (const GLdouble *);
+extern void APIENTRY glWindowPos3fMESA (GLfloat, GLfloat, GLfloat);
+extern void APIENTRY glWindowPos3fvMESA (const GLfloat *);
+extern void APIENTRY glWindowPos3iMESA (GLint, GLint, GLint);
+extern void APIENTRY glWindowPos3ivMESA (const GLint *);
+extern void APIENTRY glWindowPos3sMESA (GLshort, GLshort, GLshort);
+extern void APIENTRY glWindowPos3svMESA (const GLshort *);
+extern void APIENTRY glWindowPos4dMESA (GLdouble, GLdouble, GLdouble, GLdouble);
+extern void APIENTRY glWindowPos4dvMESA (const GLdouble *);
+extern void APIENTRY glWindowPos4fMESA (GLfloat, GLfloat, GLfloat, GLfloat);
+extern void APIENTRY glWindowPos4fvMESA (const GLfloat *);
+extern void APIENTRY glWindowPos4iMESA (GLint, GLint, GLint, GLint);
+extern void APIENTRY glWindowPos4ivMESA (const GLint *);
+extern void APIENTRY glWindowPos4sMESA (GLshort, GLshort, GLshort, GLshort);
+extern void APIENTRY glWindowPos4svMESA (const GLshort *);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLWINDOWPOS2DMESAPROC) (GLdouble x, GLdouble y);
+typedef void (APIENTRY * PFNGLWINDOWPOS2DVMESAPROC) (const GLdouble *v);
+typedef void (APIENTRY * PFNGLWINDOWPOS2FMESAPROC) (GLfloat x, GLfloat y);
+typedef void (APIENTRY * PFNGLWINDOWPOS2FVMESAPROC) (const GLfloat *v);
+typedef void (APIENTRY * PFNGLWINDOWPOS2IMESAPROC) (GLint x, GLint y);
+typedef void (APIENTRY * PFNGLWINDOWPOS2IVMESAPROC) (const GLint *v);
+typedef void (APIENTRY * PFNGLWINDOWPOS2SMESAPROC) (GLshort x, GLshort y);
+typedef void (APIENTRY * PFNGLWINDOWPOS2SVMESAPROC) (const GLshort *v);
+typedef void (APIENTRY * PFNGLWINDOWPOS3DMESAPROC) (GLdouble x, GLdouble y, GLdouble z);
+typedef void (APIENTRY * PFNGLWINDOWPOS3DVMESAPROC) (const GLdouble *v);
+typedef void (APIENTRY * PFNGLWINDOWPOS3FMESAPROC) (GLfloat x, GLfloat y, GLfloat z);
+typedef void (APIENTRY * PFNGLWINDOWPOS3FVMESAPROC) (const GLfloat *v);
+typedef void (APIENTRY * PFNGLWINDOWPOS3IMESAPROC) (GLint x, GLint y, GLint z);
+typedef void (APIENTRY * PFNGLWINDOWPOS3IVMESAPROC) (const GLint *v);
+typedef void (APIENTRY * PFNGLWINDOWPOS3SMESAPROC) (GLshort x, GLshort y, GLshort z);
+typedef void (APIENTRY * PFNGLWINDOWPOS3SVMESAPROC) (const GLshort *v);
+typedef void (APIENTRY * PFNGLWINDOWPOS4DMESAPROC) (GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+typedef void (APIENTRY * PFNGLWINDOWPOS4DVMESAPROC) (const GLdouble *v);
+typedef void (APIENTRY * PFNGLWINDOWPOS4FMESAPROC) (GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+typedef void (APIENTRY * PFNGLWINDOWPOS4FVMESAPROC) (const GLfloat *v);
+typedef void (APIENTRY * PFNGLWINDOWPOS4IMESAPROC) (GLint x, GLint y, GLint z, GLint w);
+typedef void (APIENTRY * PFNGLWINDOWPOS4IVMESAPROC) (const GLint *v);
+typedef void (APIENTRY * PFNGLWINDOWPOS4SMESAPROC) (GLshort x, GLshort y, GLshort z, GLshort w);
+typedef void (APIENTRY * PFNGLWINDOWPOS4SVMESAPROC) (const GLshort *v);
+#endif
+
+#ifndef GL_IBM_cull_vertex
+#define GL_IBM_cull_vertex 1
+#endif
+
+#ifndef GL_IBM_multimode_draw_arrays
+#define GL_IBM_multimode_draw_arrays 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glMultiModeDrawArraysIBM (GLenum, const GLint *, const GLsizei *, GLsizei, GLint);
+extern void APIENTRY glMultiModeDrawElementsIBM (const GLenum *, const GLsizei *, GLenum, const GLvoid* *, GLsizei, GLint);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLMULTIMODEDRAWARRAYSIBMPROC) (GLenum mode, const GLint *first, const GLsizei *count, GLsizei primcount, GLint modestride);
+typedef void (APIENTRY * PFNGLMULTIMODEDRAWELEMENTSIBMPROC) (const GLenum *mode, const GLsizei *count, GLenum type, const GLvoid* *indices, GLsizei primcount, GLint modestride);
+#endif
+
+#ifndef GL_IBM_vertex_array_lists
+#define GL_IBM_vertex_array_lists 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glColorPointerListIBM (GLint, GLenum, GLint, const GLvoid* *, GLint);
+extern void APIENTRY glSecondaryColorPointerListIBM (GLint, GLenum, GLint, const GLvoid* *, GLint);
+extern void APIENTRY glEdgeFlagPointerListIBM (GLint, const GLboolean* *, GLint);
+extern void APIENTRY glFogCoordPointerListIBM (GLenum, GLint, const GLvoid* *, GLint);
+extern void APIENTRY glIndexPointerListIBM (GLenum, GLint, const GLvoid* *, GLint);
+extern void APIENTRY glNormalPointerListIBM (GLenum, GLint, const GLvoid* *, GLint);
+extern void APIENTRY glTexCoordPointerListIBM (GLint, GLenum, GLint, const GLvoid* *, GLint);
+extern void APIENTRY glVertexPointerListIBM (GLint, GLenum, GLint, const GLvoid* *, GLint);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLCOLORPOINTERLISTIBMPROC) (GLint size, GLenum type, GLint stride, const GLvoid* *pointer, GLint ptrstride);
+typedef void (APIENTRY * PFNGLSECONDARYCOLORPOINTERLISTIBMPROC) (GLint size, GLenum type, GLint stride, const GLvoid* *pointer, GLint ptrstride);
+typedef void (APIENTRY * PFNGLEDGEFLAGPOINTERLISTIBMPROC) (GLint stride, const GLboolean* *pointer, GLint ptrstride);
+typedef void (APIENTRY * PFNGLFOGCOORDPOINTERLISTIBMPROC) (GLenum type, GLint stride, const GLvoid* *pointer, GLint ptrstride);
+typedef void (APIENTRY * PFNGLINDEXPOINTERLISTIBMPROC) (GLenum type, GLint stride, const GLvoid* *pointer, GLint ptrstride);
+typedef void (APIENTRY * PFNGLNORMALPOINTERLISTIBMPROC) (GLenum type, GLint stride, const GLvoid* *pointer, GLint ptrstride);
+typedef void (APIENTRY * PFNGLTEXCOORDPOINTERLISTIBMPROC) (GLint size, GLenum type, GLint stride, const GLvoid* *pointer, GLint ptrstride);
+typedef void (APIENTRY * PFNGLVERTEXPOINTERLISTIBMPROC) (GLint size, GLenum type, GLint stride, const GLvoid* *pointer, GLint ptrstride);
+#endif
+
+#ifndef GL_SGIX_subsample
+#define GL_SGIX_subsample 1
+#endif
+
+#ifndef GL_SGIX_ycrcba
+#define GL_SGIX_ycrcba 1
+#endif
+
+#ifndef GL_SGIX_ycrcb_subsample
+#define GL_SGIX_ycrcb_subsample 1
+#endif
+
+#ifndef GL_SGIX_depth_pass_instrument
+#define GL_SGIX_depth_pass_instrument 1
+#endif
+
+#ifndef GL_3DFX_texture_compression_FXT1
+#define GL_3DFX_texture_compression_FXT1 1
+#endif
+
+#ifndef GL_3DFX_multisample
+#define GL_3DFX_multisample 1
+#endif
+
+#ifndef GL_3DFX_tbuffer
+#define GL_3DFX_tbuffer 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glTbufferMask3DFX (GLuint);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLTBUFFERMASK3DFXPROC) (GLuint mask);
+#endif
+
+#ifndef GL_EXT_multisample
+#define GL_EXT_multisample 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glSampleMaskEXT (GLclampf, GLboolean);
+extern void APIENTRY glSamplePatternEXT (GLenum);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLSAMPLEMASKEXTPROC) (GLclampf value, GLboolean invert);
+typedef void (APIENTRY * PFNGLSAMPLEPATTERNEXTPROC) (GLenum pattern);
+#endif
+
+#ifndef GL_SGI_vertex_preclip
+#define GL_SGI_vertex_preclip 1
+#endif
+
+#ifndef GL_SGIX_convolution_accuracy
+#define GL_SGIX_convolution_accuracy 1
+#endif
+
+#ifndef GL_SGIX_resample
+#define GL_SGIX_resample 1
+#endif
+
+#ifndef GL_SGIS_point_line_texgen
+#define GL_SGIS_point_line_texgen 1
+#endif
+
+#ifndef GL_SGIS_texture_color_mask
+#define GL_SGIS_texture_color_mask 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glTextureColorMaskSGIS (GLboolean, GLboolean, GLboolean, GLboolean);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLTEXTURECOLORMASKSGISPROC) (GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
+#endif
+
+#ifndef GL_SGIX_igloo_interface
+#define GL_SGIX_igloo_interface 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void APIENTRY glIglooInterfaceSGIX (GLenum, const GLvoid *);
+#endif /* GL_GLEXT_PROTOTYPES */
+typedef void (APIENTRY * PFNGLIGLOOINTERFACESGIXPROC) (GLenum pname, const GLvoid *params);
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/codemp/renderer/glext_console.h b/codemp/renderer/glext_console.h
new file mode 100644
index 0000000..0220e94
--- /dev/null
+++ b/codemp/renderer/glext_console.h
@@ -0,0 +1,2521 @@
+#ifndef __glext_h_
+#define __glext_h_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+** License Applicability. Except to the extent portions of this file are
+** made subject to an alternative license as permitted in the SGI Free
+** Software License B, Version 1.1 (the "License"), the contents of this
+** file are subject only to the provisions of the License. You may not use
+** this file except in compliance with the License. You may obtain a copy
+** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+** 
+** http://oss.sgi.com/projects/FreeB
+** 
+** Note that, as provided in the License, the Software is distributed on an
+** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+** 
+** Original Code. The Original Code is: OpenGL Sample Implementation,
+** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+** Copyright in any portions created by third parties is as indicated
+** elsewhere herein. All Rights Reserved.
+** 
+** Additional Notice Provisions: This software was created using the
+** OpenGL(R) version 1.2.1 Sample Implementation published by SGI, but has
+** not been independently verified as being compliant with the OpenGL(R)
+** version 1.2.1 Specification.
+*/
+
+/*************************************************************/
+
+/* Header file version number, required by OpenGL ABI for Linux */
+#define GL_GLEXT_VERSION 6
+
+#ifndef GL_VERSION_1_2
+#define GL_CONSTANT_COLOR                 0x8001
+#define GL_ONE_MINUS_CONSTANT_COLOR       0x8002
+#define GL_CONSTANT_ALPHA                 0x8003
+#define GL_ONE_MINUS_CONSTANT_ALPHA       0x8004
+#define GL_BLEND_COLOR                    0x8005
+#define GL_FUNC_ADD                       0x8006
+#define GL_MIN                            0x8007
+#define GL_MAX                            0x8008
+#define GL_BLEND_EQUATION                 0x8009
+#define GL_FUNC_SUBTRACT                  0x800A
+#define GL_FUNC_REVERSE_SUBTRACT          0x800B
+#define GL_CONVOLUTION_1D                 0x8010
+#define GL_CONVOLUTION_2D                 0x8011
+#define GL_SEPARABLE_2D                   0x8012
+#define GL_CONVOLUTION_BORDER_MODE        0x8013
+#define GL_CONVOLUTION_FILTER_SCALE       0x8014
+#define GL_CONVOLUTION_FILTER_BIAS        0x8015
+#define GL_REDUCE                         0x8016
+#define GL_CONVOLUTION_FORMAT             0x8017
+#define GL_CONVOLUTION_WIDTH              0x8018
+#define GL_CONVOLUTION_HEIGHT             0x8019
+#define GL_MAX_CONVOLUTION_WIDTH          0x801A
+#define GL_MAX_CONVOLUTION_HEIGHT         0x801B
+#define GL_POST_CONVOLUTION_RED_SCALE     0x801C
+#define GL_POST_CONVOLUTION_GREEN_SCALE   0x801D
+#define GL_POST_CONVOLUTION_BLUE_SCALE    0x801E
+#define GL_POST_CONVOLUTION_ALPHA_SCALE   0x801F
+#define GL_POST_CONVOLUTION_RED_BIAS      0x8020
+#define GL_POST_CONVOLUTION_GREEN_BIAS    0x8021
+#define GL_POST_CONVOLUTION_BLUE_BIAS     0x8022
+#define GL_POST_CONVOLUTION_ALPHA_BIAS    0x8023
+#define GL_HISTOGRAM                      0x8024
+#define GL_PROXY_HISTOGRAM                0x8025
+#define GL_HISTOGRAM_WIDTH                0x8026
+#define GL_HISTOGRAM_FORMAT               0x8027
+#define GL_HISTOGRAM_RED_SIZE             0x8028
+#define GL_HISTOGRAM_GREEN_SIZE           0x8029
+#define GL_HISTOGRAM_BLUE_SIZE            0x802A
+#define GL_HISTOGRAM_ALPHA_SIZE           0x802B
+#define GL_HISTOGRAM_LUMINANCE_SIZE       0x802C
+#define GL_HISTOGRAM_SINK                 0x802D
+#define GL_MINMAX                         0x802E
+#define GL_MINMAX_FORMAT                  0x802F
+#define GL_MINMAX_SINK                    0x8030
+#define GL_TABLE_TOO_LARGE                0x8031
+#define GL_UNSIGNED_BYTE_3_3_2            0x8032
+#define GL_UNSIGNED_SHORT_4_4_4_4         0x8033
+#define GL_UNSIGNED_SHORT_5_5_5_1         0x8034
+#define GL_UNSIGNED_INT_8_8_8_8           0x8035
+#define GL_UNSIGNED_INT_10_10_10_2        0x8036
+#define GL_RESCALE_NORMAL                 0x803A
+#define GL_UNSIGNED_BYTE_2_3_3_REV        0x8362
+#define GL_UNSIGNED_SHORT_5_6_5           0x8363
+#define GL_UNSIGNED_SHORT_5_6_5_REV       0x8364
+#define GL_UNSIGNED_SHORT_4_4_4_4_REV     0x8365
+#define GL_UNSIGNED_SHORT_1_5_5_5_REV     0x8366
+#define GL_UNSIGNED_INT_8_8_8_8_REV       0x8367
+#define GL_UNSIGNED_INT_2_10_10_10_REV    0x8368
+#define GL_COLOR_MATRIX                   0x80B1
+#define GL_COLOR_MATRIX_STACK_DEPTH       0x80B2
+#define GL_MAX_COLOR_MATRIX_STACK_DEPTH   0x80B3
+#define GL_POST_COLOR_MATRIX_RED_SCALE    0x80B4
+#define GL_POST_COLOR_MATRIX_GREEN_SCALE  0x80B5
+#define GL_POST_COLOR_MATRIX_BLUE_SCALE   0x80B6
+#define GL_POST_COLOR_MATRIX_ALPHA_SCALE  0x80B7
+#define GL_POST_COLOR_MATRIX_RED_BIAS     0x80B8
+#define GL_POST_COLOR_MATRIX_GREEN_BIAS   0x80B9
+#define GL_POST_COLOR_MATRIX_BLUE_BIAS    0x80BA
+#define GL_COLOR_TABLE                    0x80D0
+#define GL_POST_CONVOLUTION_COLOR_TABLE   0x80D1
+#define GL_POST_COLOR_MATRIX_COLOR_TABLE  0x80D2
+#define GL_PROXY_COLOR_TABLE              0x80D3
+#define GL_PROXY_POST_CONVOLUTION_COLOR_TABLE 0x80D4
+#define GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE 0x80D5
+#define GL_COLOR_TABLE_SCALE              0x80D6
+#define GL_COLOR_TABLE_BIAS               0x80D7
+#define GL_COLOR_TABLE_FORMAT             0x80D8
+#define GL_COLOR_TABLE_WIDTH              0x80D9
+#define GL_COLOR_TABLE_RED_SIZE           0x80DA
+#define GL_COLOR_TABLE_GREEN_SIZE         0x80DB
+#define GL_COLOR_TABLE_BLUE_SIZE          0x80DC
+#define GL_COLOR_TABLE_ALPHA_SIZE         0x80DD
+#define GL_COLOR_TABLE_LUMINANCE_SIZE     0x80DE
+#define GL_COLOR_TABLE_INTENSITY_SIZE     0x80DF
+#define GL_CLAMP_TO_EDGE                  0x812F
+#define GL_TEXTURE_MIN_LOD                0x813A
+#define GL_TEXTURE_MAX_LOD                0x813B
+#define GL_TEXTURE_BASE_LEVEL             0x813C
+#define GL_TEXTURE_MAX_LEVEL              0x813D
+#define GL_VSYNC                          0x813F
+#endif
+
+#ifndef GL_ARB_multitexture
+#define GL_TEXTURE0_ARB                   0x84C0
+#define GL_TEXTURE1_ARB                   0x84C1
+#define GL_TEXTURE2_ARB                   0x84C2
+#define GL_TEXTURE3_ARB                   0x84C3
+#define GL_TEXTURE4_ARB                   0x84C4
+#define GL_TEXTURE5_ARB                   0x84C5
+#define GL_TEXTURE6_ARB                   0x84C6
+#define GL_TEXTURE7_ARB                   0x84C7
+#define GL_TEXTURE8_ARB                   0x84C8
+#define GL_TEXTURE9_ARB                   0x84C9
+#define GL_TEXTURE10_ARB                  0x84CA
+#define GL_TEXTURE11_ARB                  0x84CB
+#define GL_TEXTURE12_ARB                  0x84CC
+#define GL_TEXTURE13_ARB                  0x84CD
+#define GL_TEXTURE14_ARB                  0x84CE
+#define GL_TEXTURE15_ARB                  0x84CF
+#define GL_TEXTURE16_ARB                  0x84D0
+#define GL_TEXTURE17_ARB                  0x84D1
+#define GL_TEXTURE18_ARB                  0x84D2
+#define GL_TEXTURE19_ARB                  0x84D3
+#define GL_TEXTURE20_ARB                  0x84D4
+#define GL_TEXTURE21_ARB                  0x84D5
+#define GL_TEXTURE22_ARB                  0x84D6
+#define GL_TEXTURE23_ARB                  0x84D7
+#define GL_TEXTURE24_ARB                  0x84D8
+#define GL_TEXTURE25_ARB                  0x84D9
+#define GL_TEXTURE26_ARB                  0x84DA
+#define GL_TEXTURE27_ARB                  0x84DB
+#define GL_TEXTURE28_ARB                  0x84DC
+#define GL_TEXTURE29_ARB                  0x84DD
+#define GL_TEXTURE30_ARB                  0x84DE
+#define GL_TEXTURE31_ARB                  0x84DF
+#define GL_ACTIVE_TEXTURE_ARB             0x84E0
+#define GL_CLIENT_ACTIVE_TEXTURE_ARB      0x84E1
+#define GL_MAX_TEXTURE_UNITS_ARB          0x84E2
+#endif
+
+#ifndef GL_ARB_transpose_matrix
+#define GL_TRANSPOSE_MODELVIEW_MATRIX_ARB 0x84E3
+#define GL_TRANSPOSE_PROJECTION_MATRIX_ARB 0x84E4
+#define GL_TRANSPOSE_TEXTURE_MATRIX_ARB   0x84E5
+#define GL_TRANSPOSE_COLOR_MATRIX_ARB     0x84E6
+#endif
+
+#ifndef GL_ARB_multisample
+#define GL_MULTISAMPLE_ARB                0x809D
+#define GL_SAMPLE_ALPHA_TO_COVERAGE_ARB   0x809E
+#define GL_SAMPLE_ALPHA_TO_ONE_ARB        0x809F
+#define GL_SAMPLE_COVERAGE_ARB            0x80A0
+#define GL_SAMPLE_BUFFERS_ARB             0x80A8
+#define GL_SAMPLES_ARB                    0x80A9
+#define GL_SAMPLE_COVERAGE_VALUE_ARB      0x80AA
+#define GL_SAMPLE_COVERAGE_INVERT_ARB     0x80AB
+#define GL_MULTISAMPLE_BIT_ARB            0x20000000
+#endif
+
+#ifndef GL_ARB_texture_cube_map
+#define GL_NORMAL_MAP_ARB                 0x8511
+#define GL_REFLECTION_MAP_ARB             0x8512
+#define GL_TEXTURE_CUBE_MAP_ARB           0x8513
+#define GL_TEXTURE_BINDING_CUBE_MAP_ARB   0x8514
+#define GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB 0x8515
+#define GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB 0x8516
+#define GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB 0x8517
+#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB 0x8518
+#define GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB 0x8519
+#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB 0x851A
+#define GL_PROXY_TEXTURE_CUBE_MAP_ARB     0x851B
+#define GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB  0x851C
+#endif
+
+#ifndef GL_ARB_texture_compression
+#define GL_COMPRESSED_ALPHA_ARB           0x84E9
+#define GL_COMPRESSED_LUMINANCE_ARB       0x84EA
+#define GL_COMPRESSED_LUMINANCE_ALPHA_ARB 0x84EB
+#define GL_COMPRESSED_INTENSITY_ARB       0x84EC
+#define GL_COMPRESSED_RGB_ARB             0x84ED
+#define GL_COMPRESSED_RGBA_ARB            0x84EE
+#define GL_TEXTURE_COMPRESSION_HINT_ARB   0x84EF
+#define GL_TEXTURE_IMAGE_SIZE_ARB         0x86A0
+#define GL_TEXTURE_COMPRESSED_ARB         0x86A1
+#define GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB 0x86A2
+#define GL_COMPRESSED_TEXTURE_FORMATS_ARB 0x86A3
+#endif
+
+#ifndef GL_EXT_abgr
+#define GL_ABGR_EXT                       0x8000
+#endif
+
+#ifndef GL_EXT_blend_color
+#define GL_CONSTANT_COLOR_EXT             0x8001
+#define GL_ONE_MINUS_CONSTANT_COLOR_EXT   0x8002
+#define GL_CONSTANT_ALPHA_EXT             0x8003
+#define GL_ONE_MINUS_CONSTANT_ALPHA_EXT   0x8004
+#define GL_BLEND_COLOR_EXT                0x8005
+#endif
+
+#ifndef GL_EXT_polygon_offset
+#define GL_POLYGON_OFFSET_EXT             0x8037
+#define GL_POLYGON_OFFSET_FACTOR_EXT      0x8038
+#define GL_POLYGON_OFFSET_BIAS_EXT        0x8039
+#endif
+
+#ifndef GL_EXT_texture
+#define GL_ALPHA4_EXT                     0x803B
+#define GL_ALPHA8_EXT                     0x803C
+#define GL_ALPHA12_EXT                    0x803D
+#define GL_ALPHA16_EXT                    0x803E
+#define GL_LUMINANCE4_EXT                 0x803F
+#define GL_LUMINANCE8_EXT                 0x8040
+#define GL_LUMINANCE12_EXT                0x8041
+#define GL_LUMINANCE16_EXT                0x8042
+#define GL_LUMINANCE4_ALPHA4_EXT          0x8043
+#define GL_LUMINANCE6_ALPHA2_EXT          0x8044
+#define GL_LUMINANCE8_ALPHA8_EXT          0x8045
+#define GL_LUMINANCE12_ALPHA4_EXT         0x8046
+#define GL_LUMINANCE12_ALPHA12_EXT        0x8047
+#define GL_LUMINANCE16_ALPHA16_EXT        0x8048
+#define GL_INTENSITY_EXT                  0x8049
+#define GL_INTENSITY4_EXT                 0x804A
+#define GL_INTENSITY8_EXT                 0x804B
+#define GL_INTENSITY12_EXT                0x804C
+#define GL_INTENSITY16_EXT                0x804D
+#define GL_RGB2_EXT                       0x804E
+#define GL_RGB4_EXT                       0x804F
+#define GL_RGB5_EXT                       0x8050
+#define GL_RGB8_EXT                       0x8051
+#define GL_RGB10_EXT                      0x8052
+#define GL_RGB12_EXT                      0x8053
+#define GL_RGB16_EXT                      0x8054
+#define GL_RGBA2_EXT                      0x8055
+#define GL_RGBA4_EXT                      0x8056
+#define GL_RGB5_A1_EXT                    0x8057
+#define GL_RGBA8_EXT                      0x8058
+#define GL_RGB10_A2_EXT                   0x8059
+#define GL_RGBA12_EXT                     0x805A
+#define GL_RGBA16_EXT                     0x805B
+#define GL_TEXTURE_RED_SIZE_EXT           0x805C
+#define GL_TEXTURE_GREEN_SIZE_EXT         0x805D
+#define GL_TEXTURE_BLUE_SIZE_EXT          0x805E
+#define GL_TEXTURE_ALPHA_SIZE_EXT         0x805F
+#define GL_TEXTURE_LUMINANCE_SIZE_EXT     0x8060
+#define GL_TEXTURE_INTENSITY_SIZE_EXT     0x8061
+#define GL_REPLACE_EXT                    0x8062
+#define GL_PROXY_TEXTURE_1D_EXT           0x8063
+#define GL_PROXY_TEXTURE_2D_EXT           0x8064
+#define GL_TEXTURE_TOO_LARGE_EXT          0x8065
+#define GL_TPL4_EXT                       0x9991
+#define GL_TPL8_EXT                       0x9992
+#define GL_TPL16_EXT                      0x9993
+#define GL_TPL32_EXT                      0x9994
+#define GL_DDS1_EXT                       0x9995
+#define GL_DDS5_EXT                       0x9996
+#define GL_DDS_RGB16_EXT                  0x9997
+#define GL_DDS_RGBA32_EXT                 0x9998
+#define GL_RGB_SWIZZLE_EXT                0x9999
+#endif
+
+#ifndef GL_EXT_texture3D
+#define GL_PACK_SKIP_IMAGES               0x806B
+#define GL_PACK_SKIP_IMAGES_EXT           0x806B
+#define GL_PACK_IMAGE_HEIGHT              0x806C
+#define GL_PACK_IMAGE_HEIGHT_EXT          0x806C
+#define GL_UNPACK_SKIP_IMAGES             0x806D
+#define GL_UNPACK_SKIP_IMAGES_EXT         0x806D
+#define GL_UNPACK_IMAGE_HEIGHT            0x806E
+#define GL_UNPACK_IMAGE_HEIGHT_EXT        0x806E
+#define GL_TEXTURE_3D                     0x806F
+#define GL_TEXTURE_3D_EXT                 0x806F
+#define GL_PROXY_TEXTURE_3D               0x8070
+#define GL_PROXY_TEXTURE_3D_EXT           0x8070
+#define GL_TEXTURE_DEPTH                  0x8071
+#define GL_TEXTURE_DEPTH_EXT              0x8071
+#define GL_TEXTURE_WRAP_R                 0x8072
+#define GL_TEXTURE_WRAP_R_EXT             0x8072
+#define GL_MAX_3D_TEXTURE_SIZE            0x8073
+#define GL_MAX_3D_TEXTURE_SIZE_EXT        0x8073
+#endif
+
+#ifndef GL_SGIS_texture_filter4
+#define GL_FILTER4_SGIS                   0x8146
+#define GL_TEXTURE_FILTER4_SIZE_SGIS      0x8147
+#endif
+
+#ifndef GL_EXT_subtexture
+#endif
+
+#ifndef GL_EXT_copy_texture
+#endif
+
+#ifndef GL_EXT_histogram
+#define GL_HISTOGRAM_EXT                  0x8024
+#define GL_PROXY_HISTOGRAM_EXT            0x8025
+#define GL_HISTOGRAM_WIDTH_EXT            0x8026
+#define GL_HISTOGRAM_FORMAT_EXT           0x8027
+#define GL_HISTOGRAM_RED_SIZE_EXT         0x8028
+#define GL_HISTOGRAM_GREEN_SIZE_EXT       0x8029
+#define GL_HISTOGRAM_BLUE_SIZE_EXT        0x802A
+#define GL_HISTOGRAM_ALPHA_SIZE_EXT       0x802B
+#define GL_HISTOGRAM_LUMINANCE_SIZE_EXT   0x802C
+#define GL_HISTOGRAM_SINK_EXT             0x802D
+#define GL_MINMAX_EXT                     0x802E
+#define GL_MINMAX_FORMAT_EXT              0x802F
+#define GL_MINMAX_SINK_EXT                0x8030
+#define GL_TABLE_TOO_LARGE_EXT            0x8031
+#endif
+
+#ifndef GL_EXT_convolution
+#define GL_CONVOLUTION_1D_EXT             0x8010
+#define GL_CONVOLUTION_2D_EXT             0x8011
+#define GL_SEPARABLE_2D_EXT               0x8012
+#define GL_CONVOLUTION_BORDER_MODE_EXT    0x8013
+#define GL_CONVOLUTION_FILTER_SCALE_EXT   0x8014
+#define GL_CONVOLUTION_FILTER_BIAS_EXT    0x8015
+#define GL_REDUCE_EXT                     0x8016
+#define GL_CONVOLUTION_FORMAT_EXT         0x8017
+#define GL_CONVOLUTION_WIDTH_EXT          0x8018
+#define GL_CONVOLUTION_HEIGHT_EXT         0x8019
+#define GL_MAX_CONVOLUTION_WIDTH_EXT      0x801A
+#define GL_MAX_CONVOLUTION_HEIGHT_EXT     0x801B
+#define GL_POST_CONVOLUTION_RED_SCALE_EXT 0x801C
+#define GL_POST_CONVOLUTION_GREEN_SCALE_EXT 0x801D
+#define GL_POST_CONVOLUTION_BLUE_SCALE_EXT 0x801E
+#define GL_POST_CONVOLUTION_ALPHA_SCALE_EXT 0x801F
+#define GL_POST_CONVOLUTION_RED_BIAS_EXT  0x8020
+#define GL_POST_CONVOLUTION_GREEN_BIAS_EXT 0x8021
+#define GL_POST_CONVOLUTION_BLUE_BIAS_EXT 0x8022
+#define GL_POST_CONVOLUTION_ALPHA_BIAS_EXT 0x8023
+#endif
+
+#ifndef GL_SGI_color_matrix
+#define GL_COLOR_MATRIX_SGI               0x80B1
+#define GL_COLOR_MATRIX_STACK_DEPTH_SGI   0x80B2
+#define GL_MAX_COLOR_MATRIX_STACK_DEPTH_SGI 0x80B3
+#define GL_POST_COLOR_MATRIX_RED_SCALE_SGI 0x80B4
+#define GL_POST_COLOR_MATRIX_GREEN_SCALE_SGI 0x80B5
+#define GL_POST_COLOR_MATRIX_BLUE_SCALE_SGI 0x80B6
+#define GL_POST_COLOR_MATRIX_ALPHA_SCALE_SGI 0x80B7
+#define GL_POST_COLOR_MATRIX_RED_BIAS_SGI 0x80B8
+#define GL_POST_COLOR_MATRIX_GREEN_BIAS_SGI 0x80B9
+#define GL_POST_COLOR_MATRIX_BLUE_BIAS_SGI 0x80BA
+#define GL_POST_COLOR_MATRIX_ALPHA_BIAS_SGI 0x80BB
+#endif
+
+#ifndef GL_SGI_color_table
+#define GL_COLOR_TABLE_SGI                0x80D0
+#define GL_POST_CONVOLUTION_COLOR_TABLE_SGI 0x80D1
+#define GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI 0x80D2
+#define GL_PROXY_COLOR_TABLE_SGI          0x80D3
+#define GL_PROXY_POST_CONVOLUTION_COLOR_TABLE_SGI 0x80D4
+#define GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE_SGI 0x80D5
+#define GL_COLOR_TABLE_SCALE_SGI          0x80D6
+#define GL_COLOR_TABLE_BIAS_SGI           0x80D7
+#define GL_COLOR_TABLE_FORMAT_SGI         0x80D8
+#define GL_COLOR_TABLE_WIDTH_SGI          0x80D9
+#define GL_COLOR_TABLE_RED_SIZE_SGI       0x80DA
+#define GL_COLOR_TABLE_GREEN_SIZE_SGI     0x80DB
+#define GL_COLOR_TABLE_BLUE_SIZE_SGI      0x80DC
+#define GL_COLOR_TABLE_ALPHA_SIZE_SGI     0x80DD
+#define GL_COLOR_TABLE_LUMINANCE_SIZE_SGI 0x80DE
+#define GL_COLOR_TABLE_INTENSITY_SIZE_SGI 0x80DF
+#endif
+
+#ifndef GL_SGIS_pixel_texture
+#define GL_PIXEL_TEXTURE_SGIS             0x8353
+#define GL_PIXEL_FRAGMENT_RGB_SOURCE_SGIS 0x8354
+#define GL_PIXEL_FRAGMENT_ALPHA_SOURCE_SGIS 0x8355
+#define GL_PIXEL_GROUP_COLOR_SGIS         0x8356
+#endif
+
+#ifndef GL_SGIX_pixel_texture
+#define GL_PIXEL_TEX_GEN_SGIX             0x8139
+#define GL_PIXEL_TEX_GEN_MODE_SGIX        0x832B
+#endif
+
+#ifndef GL_SGIS_texture4D
+#define GL_PACK_SKIP_VOLUMES_SGIS         0x8130
+#define GL_PACK_IMAGE_DEPTH_SGIS          0x8131
+#define GL_UNPACK_SKIP_VOLUMES_SGIS       0x8132
+#define GL_UNPACK_IMAGE_DEPTH_SGIS        0x8133
+#define GL_TEXTURE_4D_SGIS                0x8134
+#define GL_PROXY_TEXTURE_4D_SGIS          0x8135
+#define GL_TEXTURE_4DSIZE_SGIS            0x8136
+#define GL_TEXTURE_WRAP_Q_SGIS            0x8137
+#define GL_MAX_4D_TEXTURE_SIZE_SGIS       0x8138
+#define GL_TEXTURE_4D_BINDING_SGIS        0x814F
+#endif
+
+#ifndef GL_SGI_texture_color_table
+#define GL_TEXTURE_COLOR_TABLE_SGI        0x80BC
+#define GL_PROXY_TEXTURE_COLOR_TABLE_SGI  0x80BD
+#endif
+
+#ifndef GL_EXT_cmyka
+#define GL_CMYK_EXT                       0x800C
+#define GL_CMYKA_EXT                      0x800D
+#define GL_PACK_CMYK_HINT_EXT             0x800E
+#define GL_UNPACK_CMYK_HINT_EXT           0x800F
+#endif
+
+#ifndef GL_EXT_texture_object
+#define GL_TEXTURE_PRIORITY_EXT           0x8066
+#define GL_TEXTURE_RESIDENT_EXT           0x8067
+#define GL_TEXTURE_1D_BINDING_EXT         0x8068
+#define GL_TEXTURE_2D_BINDING_EXT         0x8069
+#define GL_TEXTURE_3D_BINDING_EXT         0x806A
+#endif
+
+#ifndef GL_SGIS_detail_texture
+#define GL_DETAIL_TEXTURE_2D_SGIS         0x8095
+#define GL_DETAIL_TEXTURE_2D_BINDING_SGIS 0x8096
+#define GL_LINEAR_DETAIL_SGIS             0x8097
+#define GL_LINEAR_DETAIL_ALPHA_SGIS       0x8098
+#define GL_LINEAR_DETAIL_COLOR_SGIS       0x8099
+#define GL_DETAIL_TEXTURE_LEVEL_SGIS      0x809A
+#define GL_DETAIL_TEXTURE_MODE_SGIS       0x809B
+#define GL_DETAIL_TEXTURE_FUNC_POINTS_SGIS 0x809C
+#endif
+
+#ifndef GL_SGIS_sharpen_texture
+#define GL_LINEAR_SHARPEN_SGIS            0x80AD
+#define GL_LINEAR_SHARPEN_ALPHA_SGIS      0x80AE
+#define GL_LINEAR_SHARPEN_COLOR_SGIS      0x80AF
+#define GL_SHARPEN_TEXTURE_FUNC_POINTS_SGIS 0x80B0
+#endif
+
+#ifndef GL_EXT_packed_pixels
+#define GL_UNSIGNED_BYTE_3_3_2_EXT        0x8032
+#define GL_UNSIGNED_SHORT_4_4_4_4_EXT     0x8033
+#define GL_UNSIGNED_SHORT_5_5_5_1_EXT     0x8034
+#define GL_UNSIGNED_INT_8_8_8_8_EXT       0x8035
+#define GL_UNSIGNED_INT_10_10_10_2_EXT    0x8036
+#endif
+
+#ifndef GL_SGIS_texture_lod
+#define GL_TEXTURE_MIN_LOD_SGIS           0x813A
+#define GL_TEXTURE_MAX_LOD_SGIS           0x813B
+#define GL_TEXTURE_BASE_LEVEL_SGIS        0x813C
+#define GL_TEXTURE_MAX_LEVEL_SGIS         0x813D
+#endif
+
+#ifndef GL_SGIS_multisample
+#define GL_MULTISAMPLE_SGIS               0x809D
+#define GL_SAMPLE_ALPHA_TO_MASK_SGIS      0x809E
+#define GL_SAMPLE_ALPHA_TO_ONE_SGIS       0x809F
+#define GL_SAMPLE_MASK_SGIS               0x80A0
+#define GL_1PASS_SGIS                     0x80A1
+#define GL_2PASS_0_SGIS                   0x80A2
+#define GL_2PASS_1_SGIS                   0x80A3
+#define GL_4PASS_0_SGIS                   0x80A4
+#define GL_4PASS_1_SGIS                   0x80A5
+#define GL_4PASS_2_SGIS                   0x80A6
+#define GL_4PASS_3_SGIS                   0x80A7
+#define GL_SAMPLE_BUFFERS_SGIS            0x80A8
+#define GL_SAMPLES_SGIS                   0x80A9
+#define GL_SAMPLE_MASK_VALUE_SGIS         0x80AA
+#define GL_SAMPLE_MASK_INVERT_SGIS        0x80AB
+#define GL_SAMPLE_PATTERN_SGIS            0x80AC
+#endif
+
+#ifndef GL_EXT_rescale_normal
+#define GL_RESCALE_NORMAL_EXT             0x803A
+#endif
+
+#ifndef GL_EXT_vertex_array
+#define GL_VERTEX_ARRAY_EXT               0x8074
+#define GL_NORMAL_ARRAY_EXT               0x8075
+#define GL_COLOR_ARRAY_EXT                0x8076
+#define GL_INDEX_ARRAY_EXT                0x8077
+#define GL_TEXTURE_COORD_ARRAY_EXT        0x8078
+#define GL_EDGE_FLAG_ARRAY_EXT            0x8079
+#define GL_VERTEX_ARRAY_SIZE_EXT          0x807A
+#define GL_VERTEX_ARRAY_TYPE_EXT          0x807B
+#define GL_VERTEX_ARRAY_STRIDE_EXT        0x807C
+#define GL_VERTEX_ARRAY_COUNT_EXT         0x807D
+#define GL_NORMAL_ARRAY_TYPE_EXT          0x807E
+#define GL_NORMAL_ARRAY_STRIDE_EXT        0x807F
+#define GL_NORMAL_ARRAY_COUNT_EXT         0x8080
+#define GL_COLOR_ARRAY_SIZE_EXT           0x8081
+#define GL_COLOR_ARRAY_TYPE_EXT           0x8082
+#define GL_COLOR_ARRAY_STRIDE_EXT         0x8083
+#define GL_COLOR_ARRAY_COUNT_EXT          0x8084
+#define GL_INDEX_ARRAY_TYPE_EXT           0x8085
+#define GL_INDEX_ARRAY_STRIDE_EXT         0x8086
+#define GL_INDEX_ARRAY_COUNT_EXT          0x8087
+#define GL_TEXTURE_COORD_ARRAY_SIZE_EXT   0x8088
+#define GL_TEXTURE_COORD_ARRAY_TYPE_EXT   0x8089
+#define GL_TEXTURE_COORD_ARRAY_STRIDE_EXT 0x808A
+#define GL_TEXTURE_COORD_ARRAY_COUNT_EXT  0x808B
+#define GL_EDGE_FLAG_ARRAY_STRIDE_EXT     0x808C
+#define GL_EDGE_FLAG_ARRAY_COUNT_EXT      0x808D
+#define GL_VERTEX_ARRAY_POINTER_EXT       0x808E
+#define GL_NORMAL_ARRAY_POINTER_EXT       0x808F
+#define GL_COLOR_ARRAY_POINTER_EXT        0x8090
+#define GL_INDEX_ARRAY_POINTER_EXT        0x8091
+#define GL_TEXTURE_COORD_ARRAY_POINTER_EXT 0x8092
+#define GL_EDGE_FLAG_ARRAY_POINTER_EXT    0x8093
+#endif
+
+#ifndef GL_EXT_misc_attribute
+#endif
+
+#ifndef GL_SGIS_generate_mipmap
+#define GL_GENERATE_MIPMAP_SGIS           0x8191
+#define GL_GENERATE_MIPMAP_HINT_SGIS      0x8192
+#endif
+
+#ifndef GL_SGIX_clipmap
+#define GL_LINEAR_CLIPMAP_LINEAR_SGIX     0x8170
+#define GL_TEXTURE_CLIPMAP_CENTER_SGIX    0x8171
+#define GL_TEXTURE_CLIPMAP_FRAME_SGIX     0x8172
+#define GL_TEXTURE_CLIPMAP_OFFSET_SGIX    0x8173
+#define GL_TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX 0x8174
+#define GL_TEXTURE_CLIPMAP_LOD_OFFSET_SGIX 0x8175
+#define GL_TEXTURE_CLIPMAP_DEPTH_SGIX     0x8176
+#define GL_MAX_CLIPMAP_DEPTH_SGIX         0x8177
+#define GL_MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX 0x8178
+#define GL_NEAREST_CLIPMAP_NEAREST_SGIX   0x844D
+#define GL_NEAREST_CLIPMAP_LINEAR_SGIX    0x844E
+#define GL_LINEAR_CLIPMAP_NEAREST_SGIX    0x844F
+#endif
+
+#ifndef GL_SGIX_shadow
+#define GL_TEXTURE_COMPARE_SGIX           0x819A
+#define GL_TEXTURE_COMPARE_OPERATOR_SGIX  0x819B
+#define GL_TEXTURE_LEQUAL_R_SGIX          0x819C
+#define GL_TEXTURE_GEQUAL_R_SGIX          0x819D
+#endif
+
+#ifndef GL_SGIS_texture_edge_clamp
+#define GL_CLAMP_TO_EDGE_SGIS             0x812F
+#endif
+
+#ifndef GL_SGIS_texture_border_clamp
+#define GL_CLAMP_TO_BORDER_SGIS           0x812D
+#endif
+
+#ifndef GL_EXT_blend_minmax
+#define GL_FUNC_ADD_EXT                   0x8006
+#define GL_MIN_EXT                        0x8007
+#define GL_MAX_EXT                        0x8008
+#define GL_BLEND_EQUATION_EXT             0x8009
+#endif
+
+#ifndef GL_EXT_blend_subtract
+#define GL_FUNC_SUBTRACT_EXT              0x800A
+#define GL_FUNC_REVERSE_SUBTRACT_EXT      0x800B
+#endif
+
+#ifndef GL_EXT_blend_logic_op
+#endif
+
+#ifndef GL_SGIX_interlace
+#define GL_INTERLACE_SGIX                 0x8094
+#endif
+
+#ifndef GL_SGIX_pixel_tiles
+#define GL_PIXEL_TILE_BEST_ALIGNMENT_SGIX 0x813E
+#define GL_PIXEL_TILE_CACHE_INCREMENT_SGIX 0x813F
+#define GL_PIXEL_TILE_WIDTH_SGIX          0x8140
+#define GL_PIXEL_TILE_HEIGHT_SGIX         0x8141
+#define GL_PIXEL_TILE_GRID_WIDTH_SGIX     0x8142
+#define GL_PIXEL_TILE_GRID_HEIGHT_SGIX    0x8143
+#define GL_PIXEL_TILE_GRID_DEPTH_SGIX     0x8144
+#define GL_PIXEL_TILE_CACHE_SIZE_SGIX     0x8145
+#endif
+
+#ifndef GL_SGIS_texture_select
+#define GL_DUAL_ALPHA4_SGIS               0x8110
+#define GL_DUAL_ALPHA8_SGIS               0x8111
+#define GL_DUAL_ALPHA12_SGIS              0x8112
+#define GL_DUAL_ALPHA16_SGIS              0x8113
+#define GL_DUAL_LUMINANCE4_SGIS           0x8114
+#define GL_DUAL_LUMINANCE8_SGIS           0x8115
+#define GL_DUAL_LUMINANCE12_SGIS          0x8116
+#define GL_DUAL_LUMINANCE16_SGIS          0x8117
+#define GL_DUAL_INTENSITY4_SGIS           0x8118
+#define GL_DUAL_INTENSITY8_SGIS           0x8119
+#define GL_DUAL_INTENSITY12_SGIS          0x811A
+#define GL_DUAL_INTENSITY16_SGIS          0x811B
+#define GL_DUAL_LUMINANCE_ALPHA4_SGIS     0x811C
+#define GL_DUAL_LUMINANCE_ALPHA8_SGIS     0x811D
+#define GL_QUAD_ALPHA4_SGIS               0x811E
+#define GL_QUAD_ALPHA8_SGIS               0x811F
+#define GL_QUAD_LUMINANCE4_SGIS           0x8120
+#define GL_QUAD_LUMINANCE8_SGIS           0x8121
+#define GL_QUAD_INTENSITY4_SGIS           0x8122
+#define GL_QUAD_INTENSITY8_SGIS           0x8123
+#define GL_DUAL_TEXTURE_SELECT_SGIS       0x8124
+#define GL_QUAD_TEXTURE_SELECT_SGIS       0x8125
+#endif
+
+#ifndef GL_SGIX_sprite
+#define GL_SPRITE_SGIX                    0x8148
+#define GL_SPRITE_MODE_SGIX               0x8149
+#define GL_SPRITE_AXIS_SGIX               0x814A
+#define GL_SPRITE_TRANSLATION_SGIX        0x814B
+#define GL_SPRITE_AXIAL_SGIX              0x814C
+#define GL_SPRITE_OBJECT_ALIGNED_SGIX     0x814D
+#define GL_SPRITE_EYE_ALIGNED_SGIX        0x814E
+#endif
+
+#ifndef GL_SGIX_texture_multi_buffer
+#define GL_TEXTURE_MULTI_BUFFER_HINT_SGIX 0x812E
+#endif
+
+#ifndef GL_SGIS_point_parameters
+#define GL_POINT_SIZE_MIN_EXT             0x8126
+#define GL_POINT_SIZE_MIN_SGIS            0x8126
+#define GL_POINT_SIZE_MAX_EXT             0x8127
+#define GL_POINT_SIZE_MAX_SGIS            0x8127
+#define GL_POINT_FADE_THRESHOLD_SIZE_EXT  0x8128
+#define GL_POINT_FADE_THRESHOLD_SIZE_SGIS 0x8128
+#define GL_DISTANCE_ATTENUATION_EXT       0x8129
+#define GL_DISTANCE_ATTENUATION_SGIS      0x8129
+#endif
+
+#ifndef GL_SGIX_instruments
+#define GL_INSTRUMENT_BUFFER_POINTER_SGIX 0x8180
+#define GL_INSTRUMENT_MEASUREMENTS_SGIX   0x8181
+#endif
+
+#ifndef GL_SGIX_texture_scale_bias
+#define GL_POST_TEXTURE_FILTER_BIAS_SGIX  0x8179
+#define GL_POST_TEXTURE_FILTER_SCALE_SGIX 0x817A
+#define GL_POST_TEXTURE_FILTER_BIAS_RANGE_SGIX 0x817B
+#define GL_POST_TEXTURE_FILTER_SCALE_RANGE_SGIX 0x817C
+#endif
+
+#ifndef GL_SGIX_framezoom
+#define GL_FRAMEZOOM_SGIX                 0x818B
+#define GL_FRAMEZOOM_FACTOR_SGIX          0x818C
+#define GL_MAX_FRAMEZOOM_FACTOR_SGIX      0x818D
+#endif
+
+#ifndef GL_SGIX_tag_sample_buffer
+#endif
+
+#ifndef GL_SGIX_reference_plane
+#define GL_REFERENCE_PLANE_SGIX           0x817D
+#define GL_REFERENCE_PLANE_EQUATION_SGIX  0x817E
+#endif
+
+#ifndef GL_SGIX_flush_raster
+#endif
+
+#ifndef GL_SGIX_depth_texture
+#define GL_DEPTH_COMPONENT16_SGIX         0x81A5
+#define GL_DEPTH_COMPONENT24_SGIX         0x81A6
+#define GL_DEPTH_COMPONENT32_SGIX         0x81A7
+#endif
+
+#ifndef GL_SGIS_fog_function
+#define GL_FOG_FUNC_SGIS                  0x812A
+#define GL_FOG_FUNC_POINTS_SGIS           0x812B
+#define GL_MAX_FOG_FUNC_POINTS_SGIS       0x812C
+#endif
+
+#ifndef GL_SGIX_fog_offset
+#define GL_FOG_OFFSET_SGIX                0x8198
+#define GL_FOG_OFFSET_VALUE_SGIX          0x8199
+#endif
+
+#ifndef GL_HP_image_transform
+#define GL_IMAGE_SCALE_X_HP               0x8155
+#define GL_IMAGE_SCALE_Y_HP               0x8156
+#define GL_IMAGE_TRANSLATE_X_HP           0x8157
+#define GL_IMAGE_TRANSLATE_Y_HP           0x8158
+#define GL_IMAGE_ROTATE_ANGLE_HP          0x8159
+#define GL_IMAGE_ROTATE_ORIGIN_X_HP       0x815A
+#define GL_IMAGE_ROTATE_ORIGIN_Y_HP       0x815B
+#define GL_IMAGE_MAG_FILTER_HP            0x815C
+#define GL_IMAGE_MIN_FILTER_HP            0x815D
+#define GL_IMAGE_CUBIC_WEIGHT_HP          0x815E
+#define GL_CUBIC_HP                       0x815F
+#define GL_AVERAGE_HP                     0x8160
+#define GL_IMAGE_TRANSFORM_2D_HP          0x8161
+#define GL_POST_IMAGE_TRANSFORM_COLOR_TABLE_HP 0x8162
+#define GL_PROXY_POST_IMAGE_TRANSFORM_COLOR_TABLE_HP 0x8163
+#endif
+
+#ifndef GL_HP_convolution_border_modes
+#define GL_IGNORE_BORDER_HP               0x8150
+#define GL_CONSTANT_BORDER_HP             0x8151
+#define GL_REPLICATE_BORDER_HP            0x8153
+#define GL_CONVOLUTION_BORDER_COLOR_HP    0x8154
+#endif
+
+#ifndef GL_INGR_palette_buffer
+#endif
+
+#ifndef GL_SGIX_texture_add_env
+#define GL_TEXTURE_ENV_BIAS_SGIX          0x80BE
+#endif
+
+#ifndef GL_EXT_color_subtable
+#endif
+
+#ifndef GL_PGI_vertex_hints
+#define GL_VERTEX_DATA_HINT_PGI           0x1A22A
+#define GL_VERTEX_CONSISTENT_HINT_PGI     0x1A22B
+#define GL_MATERIAL_SIDE_HINT_PGI         0x1A22C
+#define GL_MAX_VERTEX_HINT_PGI            0x1A22D
+#define GL_COLOR3_BIT_PGI                 0x00010000
+#define GL_COLOR4_BIT_PGI                 0x00020000
+#define GL_EDGEFLAG_BIT_PGI               0x00040000
+#define GL_INDEX_BIT_PGI                  0x00080000
+#define GL_MAT_AMBIENT_BIT_PGI            0x00100000
+#define GL_MAT_AMBIENT_AND_DIFFUSE_BIT_PGI 0x00200000
+#define GL_MAT_DIFFUSE_BIT_PGI            0x00400000
+#define GL_MAT_EMISSION_BIT_PGI           0x00800000
+#define GL_MAT_COLOR_INDEXES_BIT_PGI      0x01000000
+#define GL_MAT_SHININESS_BIT_PGI          0x02000000
+#define GL_MAT_SPECULAR_BIT_PGI           0x04000000
+#define GL_NORMAL_BIT_PGI                 0x08000000
+#define GL_TEXCOORD1_BIT_PGI              0x10000000
+#define GL_TEXCOORD2_BIT_PGI              0x20000000
+#define GL_TEXCOORD3_BIT_PGI              0x40000000
+#define GL_TEXCOORD4_BIT_PGI              0x80000000
+#define GL_VERTEX23_BIT_PGI               0x00000004
+#define GL_VERTEX4_BIT_PGI                0x00000008
+#endif
+
+#ifndef GL_PGI_misc_hints
+#define GL_PREFER_DOUBLEBUFFER_HINT_PGI   0x1A1F8
+#define GL_CONSERVE_MEMORY_HINT_PGI       0x1A1FD
+#define GL_RECLAIM_MEMORY_HINT_PGI        0x1A1FE
+#define GL_NATIVE_GRAPHICS_HANDLE_PGI     0x1A202
+#define GL_NATIVE_GRAPHICS_BEGIN_HINT_PGI 0x1A203
+#define GL_NATIVE_GRAPHICS_END_HINT_PGI   0x1A204
+#define GL_ALWAYS_FAST_HINT_PGI           0x1A20C
+#define GL_ALWAYS_SOFT_HINT_PGI           0x1A20D
+#define GL_ALLOW_DRAW_OBJ_HINT_PGI        0x1A20E
+#define GL_ALLOW_DRAW_WIN_HINT_PGI        0x1A20F
+#define GL_ALLOW_DRAW_FRG_HINT_PGI        0x1A210
+#define GL_ALLOW_DRAW_MEM_HINT_PGI        0x1A211
+#define GL_STRICT_DEPTHFUNC_HINT_PGI      0x1A216
+#define GL_STRICT_LIGHTING_HINT_PGI       0x1A217
+#define GL_STRICT_SCISSOR_HINT_PGI        0x1A218
+#define GL_FULL_STIPPLE_HINT_PGI          0x1A219
+#define GL_CLIP_NEAR_HINT_PGI             0x1A220
+#define GL_CLIP_FAR_HINT_PGI              0x1A221
+#define GL_WIDE_LINE_HINT_PGI             0x1A222
+#define GL_BACK_NORMALS_HINT_PGI          0x1A223
+#endif
+
+#ifndef GL_EXT_paletted_texture
+#define GL_COLOR_INDEX1_EXT               0x80E2
+#define GL_COLOR_INDEX2_EXT               0x80E3
+#define GL_COLOR_INDEX4_EXT               0x80E4
+#define GL_COLOR_INDEX8_EXT               0x80E5
+#define GL_COLOR_INDEX12_EXT              0x80E6
+#define GL_COLOR_INDEX16_EXT              0x80E7
+#define GL_TEXTURE_INDEX_SIZE_EXT         0x80ED
+#endif
+
+#ifndef GL_EXT_clip_volume_hint
+#define GL_CLIP_VOLUME_CLIPPING_HINT_EXT  0x80F0
+#endif
+
+#ifndef GL_SGIX_list_priority
+#define GL_LIST_PRIORITY_SGIX             0x8182
+#endif
+
+#ifndef GL_SGIX_ir_instrument1
+#define GL_IR_INSTRUMENT1_SGIX            0x817F
+#endif
+
+#ifndef GL_SGIX_calligraphic_fragment
+#define GL_CALLIGRAPHIC_FRAGMENT_SGIX     0x8183
+#endif
+
+#ifndef GL_SGIX_texture_lod_bias
+#define GL_TEXTURE_LOD_BIAS_S_SGIX        0x818E
+#define GL_TEXTURE_LOD_BIAS_T_SGIX        0x818F
+#define GL_TEXTURE_LOD_BIAS_R_SGIX        0x8190
+#endif
+
+#ifndef GL_SGIX_shadow_ambient
+#define GL_SHADOW_AMBIENT_SGIX            0x80BF
+#endif
+
+#ifndef GL_EXT_index_texture
+#endif
+
+#ifndef GL_EXT_index_material
+#define GL_INDEX_MATERIAL_EXT             0x81B8
+#define GL_INDEX_MATERIAL_PARAMETER_EXT   0x81B9
+#define GL_INDEX_MATERIAL_FACE_EXT        0x81BA
+#endif
+
+#ifndef GL_EXT_index_func
+#define GL_INDEX_TEST_EXT                 0x81B5
+#define GL_INDEX_TEST_FUNC_EXT            0x81B6
+#define GL_INDEX_TEST_REF_EXT             0x81B7
+#endif
+
+#ifndef GL_EXT_index_array_formats
+#define GL_IUI_V2F_EXT                    0x81AD
+#define GL_IUI_V3F_EXT                    0x81AE
+#define GL_IUI_N3F_V2F_EXT                0x81AF
+#define GL_IUI_N3F_V3F_EXT                0x81B0
+#define GL_T2F_IUI_V2F_EXT                0x81B1
+#define GL_T2F_IUI_V3F_EXT                0x81B2
+#define GL_T2F_IUI_N3F_V2F_EXT            0x81B3
+#define GL_T2F_IUI_N3F_V3F_EXT            0x81B4
+#endif
+
+#ifndef GL_EXT_compiled_vertex_array
+#define GL_ARRAY_ELEMENT_LOCK_FIRST_EXT   0x81A8
+#define GL_ARRAY_ELEMENT_LOCK_COUNT_EXT   0x81A9
+#endif
+
+#ifndef GL_EXT_cull_vertex
+#define GL_CULL_VERTEX_EXT                0x81AA
+#define GL_CULL_VERTEX_EYE_POSITION_EXT   0x81AB
+#define GL_CULL_VERTEX_OBJECT_POSITION_EXT 0x81AC
+#endif
+
+#ifndef GL_SGIX_ycrcb
+#define GL_YCRCB_422_SGIX                 0x81BB
+#define GL_YCRCB_444_SGIX                 0x81BC
+#endif
+
+#ifndef GL_SGIX_fragment_lighting
+#define GL_FRAGMENT_LIGHTING_SGIX         0x8400
+#define GL_FRAGMENT_COLOR_MATERIAL_SGIX   0x8401
+#define GL_FRAGMENT_COLOR_MATERIAL_FACE_SGIX 0x8402
+#define GL_FRAGMENT_COLOR_MATERIAL_PARAMETER_SGIX 0x8403
+#define GL_MAX_FRAGMENT_LIGHTS_SGIX       0x8404
+#define GL_MAX_ACTIVE_LIGHTS_SGIX         0x8405
+#define GL_CURRENT_RASTER_NORMAL_SGIX     0x8406
+#define GL_LIGHT_ENV_MODE_SGIX            0x8407
+#define GL_FRAGMENT_LIGHT_MODEL_LOCAL_VIEWER_SGIX 0x8408
+#define GL_FRAGMENT_LIGHT_MODEL_TWO_SIDE_SGIX 0x8409
+#define GL_FRAGMENT_LIGHT_MODEL_AMBIENT_SGIX 0x840A
+#define GL_FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION_SGIX 0x840B
+#define GL_FRAGMENT_LIGHT0_SGIX           0x840C
+#define GL_FRAGMENT_LIGHT1_SGIX           0x840D
+#define GL_FRAGMENT_LIGHT2_SGIX           0x840E
+#define GL_FRAGMENT_LIGHT3_SGIX           0x840F
+#define GL_FRAGMENT_LIGHT4_SGIX           0x8410
+#define GL_FRAGMENT_LIGHT5_SGIX           0x8411
+#define GL_FRAGMENT_LIGHT6_SGIX           0x8412
+#define GL_FRAGMENT_LIGHT7_SGIX           0x8413
+#endif
+
+#ifndef GL_IBM_rasterpos_clip
+#define GL_RASTER_POSITION_UNCLIPPED_IBM  0x19262
+#endif
+
+#ifndef GL_HP_texture_lighting
+#define GL_TEXTURE_LIGHTING_MODE_HP       0x8167
+#define GL_TEXTURE_POST_SPECULAR_HP       0x8168
+#define GL_TEXTURE_PRE_SPECULAR_HP        0x8169
+#endif
+
+#ifndef GL_EXT_draw_range_elements
+#define GL_MAX_ELEMENTS_VERTICES_EXT      0x80E8
+#define GL_MAX_ELEMENTS_INDICES_EXT       0x80E9
+#endif
+
+#ifndef GL_WIN_phong_shading
+#define GL_PHONG_WIN                      0x80EA
+#define GL_PHONG_HINT_WIN                 0x80EB
+#endif
+
+#ifndef GL_WIN_specular_fog
+#define GL_FOG_SPECULAR_TEXTURE_WIN       0x80EC
+#endif
+
+#ifndef GL_EXT_light_texture
+#define GL_FRAGMENT_MATERIAL_EXT          0x8349
+#define GL_FRAGMENT_NORMAL_EXT            0x834A
+#define GL_FRAGMENT_COLOR_EXT             0x834C
+#define GL_ATTENUATION_EXT                0x834D
+#define GL_SHADOW_ATTENUATION_EXT         0x834E
+#define GL_TEXTURE_APPLICATION_MODE_EXT   0x834F
+#define GL_TEXTURE_LIGHT_EXT              0x8350
+#define GL_TEXTURE_MATERIAL_FACE_EXT      0x8351
+#define GL_TEXTURE_MATERIAL_PARAMETER_EXT 0x8352
+/* reuse GL_FRAGMENT_DEPTH_EXT */
+#endif
+
+#ifndef GL_SGIX_blend_alpha_minmax
+#define GL_ALPHA_MIN_SGIX                 0x8320
+#define GL_ALPHA_MAX_SGIX                 0x8321
+#endif
+
+#ifndef GL_EXT_bgra
+#define GL_BGR_EXT                        0x80E0
+#define GL_BGRA_EXT                       0x80E1
+#endif
+
+#ifndef GL_INTEL_texture_scissor
+#endif
+
+#ifndef GL_INTEL_parallel_arrays
+#define GL_PARALLEL_ARRAYS_INTEL          0x83F4
+#define GL_VERTEX_ARRAY_PARALLEL_POINTERS_INTEL 0x83F5
+#define GL_NORMAL_ARRAY_PARALLEL_POINTERS_INTEL 0x83F6
+#define GL_COLOR_ARRAY_PARALLEL_POINTERS_INTEL 0x83F7
+#define GL_TEXTURE_COORD_ARRAY_PARALLEL_POINTERS_INTEL 0x83F8
+#endif
+
+#ifndef GL_HP_occlusion_test
+#define GL_OCCLUSION_TEST_HP              0x8165
+#define GL_OCCLUSION_TEST_RESULT_HP       0x8166
+#endif
+
+#ifndef GL_EXT_pixel_transform
+#define GL_PIXEL_TRANSFORM_2D_EXT         0x8330
+#define GL_PIXEL_MAG_FILTER_EXT           0x8331
+#define GL_PIXEL_MIN_FILTER_EXT           0x8332
+#define GL_PIXEL_CUBIC_WEIGHT_EXT         0x8333
+#define GL_CUBIC_EXT                      0x8334
+#define GL_AVERAGE_EXT                    0x8335
+#define GL_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT 0x8336
+#define GL_MAX_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT 0x8337
+#define GL_PIXEL_TRANSFORM_2D_MATRIX_EXT  0x8338
+#endif
+
+#ifndef GL_EXT_pixel_transform_color_table
+#endif
+
+#ifndef GL_EXT_shared_texture_palette
+#define GL_SHARED_TEXTURE_PALETTE_EXT     0x81FB
+#endif
+
+#ifndef GL_EXT_separate_specular_color
+#define GL_LIGHT_MODEL_COLOR_CONTROL_EXT  0x81F8
+#define GL_SINGLE_COLOR_EXT               0x81F9
+#define GL_SEPARATE_SPECULAR_COLOR_EXT    0x81FA
+#endif
+
+#ifndef GL_EXT_secondary_color
+#define GL_COLOR_SUM_EXT                  0x8458
+#define GL_CURRENT_SECONDARY_COLOR_EXT    0x8459
+#define GL_SECONDARY_COLOR_ARRAY_SIZE_EXT 0x845A
+#define GL_SECONDARY_COLOR_ARRAY_TYPE_EXT 0x845B
+#define GL_SECONDARY_COLOR_ARRAY_STRIDE_EXT 0x845C
+#define GL_SECONDARY_COLOR_ARRAY_POINTER_EXT 0x845D
+#define GL_SECONDARY_COLOR_ARRAY_EXT      0x845E
+#endif
+
+#ifndef GL_EXT_texture_perturb_normal
+#define GL_PERTURB_EXT                    0x85AE
+#define GL_TEXTURE_NORMAL_EXT             0x85AF
+#endif
+
+#ifndef GL_EXT_multi_draw_arrays
+#endif
+
+#ifndef GL_EXT_fog_coord
+#define GL_FOG_COORDINATE_SOURCE_EXT      0x8450
+#define GL_FOG_COORDINATE_EXT             0x8451
+#define GL_FRAGMENT_DEPTH_EXT             0x8452
+#define GL_CURRENT_FOG_COORDINATE_EXT     0x8453
+#define GL_FOG_COORDINATE_ARRAY_TYPE_EXT  0x8454
+#define GL_FOG_COORDINATE_ARRAY_STRIDE_EXT 0x8455
+#define GL_FOG_COORDINATE_ARRAY_POINTER_EXT 0x8456
+#define GL_FOG_COORDINATE_ARRAY_EXT       0x8457
+#endif
+
+#ifndef GL_REND_screen_coordinates
+#define GL_SCREEN_COORDINATES_REND        0x8490
+#define GL_INVERTED_SCREEN_W_REND         0x8491
+#endif
+
+#ifndef GL_EXT_coordinate_frame
+#define GL_TANGENT_ARRAY_EXT              0x8439
+#define GL_BINORMAL_ARRAY_EXT             0x843A
+#define GL_CURRENT_TANGENT_EXT            0x843B
+#define GL_CURRENT_BINORMAL_EXT           0x843C
+#define GL_TANGENT_ARRAY_TYPE_EXT         0x843E
+#define GL_TANGENT_ARRAY_STRIDE_EXT       0x843F
+#define GL_BINORMAL_ARRAY_TYPE_EXT        0x8440
+#define GL_BINORMAL_ARRAY_STRIDE_EXT      0x8441
+#define GL_TANGENT_ARRAY_POINTER_EXT      0x8442
+#define GL_BINORMAL_ARRAY_POINTER_EXT     0x8443
+#define GL_MAP1_TANGENT_EXT               0x8444
+#define GL_MAP2_TANGENT_EXT               0x8445
+#define GL_MAP1_BINORMAL_EXT              0x8446
+#define GL_MAP2_BINORMAL_EXT              0x8447
+#endif
+
+#ifndef GL_EXT_texture_env_combine
+#define GL_COMBINE_EXT                    0x8570
+#define GL_COMBINE_RGB_EXT                0x8571
+#define GL_COMBINE_ALPHA_EXT              0x8572
+#define GL_RGB_SCALE_EXT                  0x8573
+#define GL_ADD_SIGNED_EXT                 0x8574
+#define GL_INTERPOLATE_EXT                0x8575
+#define GL_CONSTANT_EXT                   0x8576
+#define GL_PRIMARY_COLOR_EXT              0x8577
+#define GL_PREVIOUS_EXT                   0x8578
+#define GL_SOURCE0_RGB_EXT                0x8580
+#define GL_SOURCE1_RGB_EXT                0x8581
+#define GL_SOURCE2_RGB_EXT                0x8582
+#define GL_SOURCE3_RGB_EXT                0x8583
+#define GL_SOURCE4_RGB_EXT                0x8584
+#define GL_SOURCE5_RGB_EXT                0x8585
+#define GL_SOURCE6_RGB_EXT                0x8586
+#define GL_SOURCE7_RGB_EXT                0x8587
+#define GL_SOURCE0_ALPHA_EXT              0x8588
+#define GL_SOURCE1_ALPHA_EXT              0x8589
+#define GL_SOURCE2_ALPHA_EXT              0x858A
+#define GL_SOURCE3_ALPHA_EXT              0x858B
+#define GL_SOURCE4_ALPHA_EXT              0x858C
+#define GL_SOURCE5_ALPHA_EXT              0x858D
+#define GL_SOURCE6_ALPHA_EXT              0x858E
+#define GL_SOURCE7_ALPHA_EXT              0x858F
+#define GL_OPERAND0_RGB_EXT               0x8590
+#define GL_OPERAND1_RGB_EXT               0x8591
+#define GL_OPERAND2_RGB_EXT               0x8592
+#define GL_OPERAND3_RGB_EXT               0x8593
+#define GL_OPERAND4_RGB_EXT               0x8594
+#define GL_OPERAND5_RGB_EXT               0x8595
+#define GL_OPERAND6_RGB_EXT               0x8596
+#define GL_OPERAND7_RGB_EXT               0x8597
+#define GL_OPERAND0_ALPHA_EXT             0x8598
+#define GL_OPERAND1_ALPHA_EXT             0x8599
+#define GL_OPERAND2_ALPHA_EXT             0x859A
+#define GL_OPERAND3_ALPHA_EXT             0x859B
+#define GL_OPERAND4_ALPHA_EXT             0x859C
+#define GL_OPERAND5_ALPHA_EXT             0x859D
+#define GL_OPERAND6_ALPHA_EXT             0x859E
+#define GL_OPERAND7_ALPHA_EXT             0x859F
+#endif
+
+#ifndef GL_APPLE_specular_vector
+#define GL_LIGHT_MODEL_SPECULAR_VECTOR_APPLE 0x85B0
+#endif
+
+#ifndef GL_APPLE_transform_hint
+#define GL_TRANSFORM_HINT_APPLE           0x85B1
+#endif
+
+#ifndef GL_SGIX_fog_scale
+#define GL_FOG_SCALE_SGIX                 0x81FC
+#define GL_FOG_SCALE_VALUE_SGIX           0x81FD
+#endif
+
+#ifndef GL_SUNX_constant_data
+#define GL_UNPACK_CONSTANT_DATA_SUNX      0x81D5
+#define GL_TEXTURE_CONSTANT_DATA_SUNX     0x81D6
+#endif
+
+#ifndef GL_SUN_global_alpha
+#define GL_GLOBAL_ALPHA_SUN               0x81D9
+#define GL_GLOBAL_ALPHA_FACTOR_SUN        0x81DA
+#endif
+
+#ifndef GL_SUN_triangle_list
+#define GL_RESTART_SUN                    0x01
+#define GL_REPLACE_MIDDLE_SUN             0x02
+#define GL_REPLACE_OLDEST_SUN             0x03
+#define GL_TRIANGLE_LIST_SUN              0x81D7
+#define GL_REPLACEMENT_CODE_SUN           0x81D8
+#define GL_REPLACEMENT_CODE_ARRAY_SUN     0x85C0
+#define GL_REPLACEMENT_CODE_ARRAY_TYPE_SUN 0x85C1
+#define GL_REPLACEMENT_CODE_ARRAY_STRIDE_SUN 0x85C2
+#define GL_REPLACEMENT_CODE_ARRAY_POINTER_SUN 0x85C3
+#define GL_R1UI_V3F_SUN                   0x85C4
+#define GL_R1UI_C4UB_V3F_SUN              0x85C5
+#define GL_R1UI_C3F_V3F_SUN               0x85C6
+#define GL_R1UI_N3F_V3F_SUN               0x85C7
+#define GL_R1UI_C4F_N3F_V3F_SUN           0x85C8
+#define GL_R1UI_T2F_V3F_SUN               0x85C9
+#define GL_R1UI_T2F_N3F_V3F_SUN           0x85CA
+#define GL_R1UI_T2F_C4F_N3F_V3F_SUN       0x85CB
+#endif
+
+#ifndef GL_SUN_vertex
+#endif
+
+#ifndef GL_EXT_blend_func_separate
+#define GL_BLEND_DST_RGB_EXT              0x80C8
+#define GL_BLEND_SRC_RGB_EXT              0x80C9
+#define GL_BLEND_DST_ALPHA_EXT            0x80CA
+#define GL_BLEND_SRC_ALPHA_EXT            0x80CB
+#endif
+
+#ifndef GL_INGR_color_clamp
+#define GL_RED_MIN_CLAMP_INGR             0x8560
+#define GL_GREEN_MIN_CLAMP_INGR           0x8561
+#define GL_BLUE_MIN_CLAMP_INGR            0x8562
+#define GL_ALPHA_MIN_CLAMP_INGR           0x8563
+#define GL_RED_MAX_CLAMP_INGR             0x8564
+#define GL_GREEN_MAX_CLAMP_INGR           0x8565
+#define GL_BLUE_MAX_CLAMP_INGR            0x8566
+#define GL_ALPHA_MAX_CLAMP_INGR           0x8567
+#endif
+
+#ifndef GL_INGR_interlace_read
+#define GL_INTERLACE_READ_INGR            0x8568
+#endif
+
+#ifndef GL_EXT_stencil_wrap
+#define GL_INCR_WRAP_EXT                  0x8507
+#define GL_DECR_WRAP_EXT                  0x8508
+#endif
+
+#ifndef GL_EXT_422_pixels
+#define GL_422_EXT                        0x80CC
+#define GL_422_REV_EXT                    0x80CD
+#define GL_422_AVERAGE_EXT                0x80CE
+#define GL_422_REV_AVERAGE_EXT            0x80CF
+#endif
+
+#ifndef GL_NV_texgen_reflection
+#define GL_NORMAL_MAP_NV                  0x8511
+#define GL_REFLECTION_MAP_NV              0x8512
+#endif
+
+#ifndef GL_EXT_texture_cube_map
+#define GL_NORMAL_MAP_EXT                 0x8511
+#define GL_REFLECTION_MAP_EXT             0x8512
+#define GL_TEXTURE_CUBE_MAP_EXT           0x8513
+#define GL_TEXTURE_BINDING_CUBE_MAP_EXT   0x8514
+#define GL_TEXTURE_CUBE_MAP_POSITIVE_X_EXT 0x8515
+#define GL_TEXTURE_CUBE_MAP_NEGATIVE_X_EXT 0x8516
+#define GL_TEXTURE_CUBE_MAP_POSITIVE_Y_EXT 0x8517
+#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_EXT 0x8518
+#define GL_TEXTURE_CUBE_MAP_POSITIVE_Z_EXT 0x8519
+#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_EXT 0x851A
+#define GL_PROXY_TEXTURE_CUBE_MAP_EXT     0x851B
+#define GL_MAX_CUBE_MAP_TEXTURE_SIZE_EXT  0x851C
+#endif
+
+#ifndef GL_SUN_convolution_border_modes
+#define GL_WRAP_BORDER_SUN                0x81D4
+#endif
+
+#ifndef GL_EXT_texture_env_add
+#endif
+
+#ifndef GL_EXT_texture_lod_bias
+#define GL_MAX_TEXTURE_LOD_BIAS_EXT       0x84FD
+#define GL_TEXTURE_FILTER_CONTROL_EXT     0x8500
+#define GL_TEXTURE_LOD_BIAS_EXT           0x8501
+#endif
+
+#ifndef GL_EXT_texture_filter_anisotropic
+#define GL_TEXTURE_MAX_ANISOTROPY_EXT     0x84FE
+#define GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT 0x84FF
+#endif
+
+#ifndef GL_EXT_vertex_weighting
+#define GL_MODELVIEW0_STACK_DEPTH_EXT     GL_MODELVIEW_STACK_DEPTH
+#define GL_MODELVIEW1_STACK_DEPTH_EXT     0x8502
+#define GL_MODELVIEW0_MATRIX_EXT          GL_MODELVIEW_MATRIX
+#define GL_MODELVIEW_MATRIX1_EXT          0x8506
+#define GL_VERTEX_WEIGHTING_EXT           0x8509
+#define GL_MODELVIEW0_EXT                 GL_MODELVIEW
+#define GL_MODELVIEW1_EXT                 0x850A
+#define GL_CURRENT_VERTEX_WEIGHT_EXT      0x850B
+#define GL_VERTEX_WEIGHT_ARRAY_EXT        0x850C
+#define GL_VERTEX_WEIGHT_ARRAY_SIZE_EXT   0x850D
+#define GL_VERTEX_WEIGHT_ARRAY_TYPE_EXT   0x850E
+#define GL_VERTEX_WEIGHT_ARRAY_STRIDE_EXT 0x850F
+#define GL_VERTEX_WEIGHT_ARRAY_POINTER_EXT 0x8510
+#endif
+
+#ifndef GL_NV_light_max_exponent
+#define GL_MAX_SHININESS_NV               0x8504
+#define GL_MAX_SPOT_EXPONENT_NV           0x8505
+#endif
+
+#ifndef GL_NV_vertex_array_range
+#define GL_VERTEX_ARRAY_RANGE_NV          0x851D
+#define GL_VERTEX_ARRAY_RANGE_LENGTH_NV   0x851E
+#define GL_VERTEX_ARRAY_RANGE_VALID_NV    0x851F
+#define GL_MAX_VERTEX_ARRAY_RANGE_ELEMENT_NV 0x8520
+#define GL_VERTEX_ARRAY_RANGE_POINTER_NV  0x8521
+#endif
+
+#ifndef GL_NV_register_combiners
+#define GL_REGISTER_COMBINERS_NV          0x8522
+#define GL_VARIABLE_A_NV                  0x8523
+#define GL_VARIABLE_B_NV                  0x8524
+#define GL_VARIABLE_C_NV                  0x8525
+#define GL_VARIABLE_D_NV                  0x8526
+#define GL_VARIABLE_E_NV                  0x8527
+#define GL_VARIABLE_F_NV                  0x8528
+#define GL_VARIABLE_G_NV                  0x8529
+#define GL_CONSTANT_COLOR0_NV             0x852A
+#define GL_CONSTANT_COLOR1_NV             0x852B
+#define GL_PRIMARY_COLOR_NV               0x852C
+#define GL_SECONDARY_COLOR_NV             0x852D
+#define GL_SPARE0_NV                      0x852E
+#define GL_SPARE1_NV                      0x852F
+#define GL_DISCARD_NV                     0x8530
+#define GL_E_TIMES_F_NV                   0x8531
+#define GL_SPARE0_PLUS_SECONDARY_COLOR_NV 0x8532
+#define GL_UNSIGNED_IDENTITY_NV           0x8536
+#define GL_UNSIGNED_INVERT_NV             0x8537
+#define GL_EXPAND_NORMAL_NV               0x8538
+#define GL_EXPAND_NEGATE_NV               0x8539
+#define GL_HALF_BIAS_NORMAL_NV            0x853A
+#define GL_HALF_BIAS_NEGATE_NV            0x853B
+#define GL_SIGNED_IDENTITY_NV             0x853C
+#define GL_SIGNED_NEGATE_NV               0x853D
+#define GL_SCALE_BY_TWO_NV                0x853E
+#define GL_SCALE_BY_FOUR_NV               0x853F
+#define GL_SCALE_BY_ONE_HALF_NV           0x8540
+#define GL_BIAS_BY_NEGATIVE_ONE_HALF_NV   0x8541
+#define GL_COMBINER_INPUT_NV              0x8542
+#define GL_COMBINER_MAPPING_NV            0x8543
+#define GL_COMBINER_COMPONENT_USAGE_NV    0x8544
+#define GL_COMBINER_AB_DOT_PRODUCT_NV     0x8545
+#define GL_COMBINER_CD_DOT_PRODUCT_NV     0x8546
+#define GL_COMBINER_MUX_SUM_NV            0x8547
+#define GL_COMBINER_SCALE_NV              0x8548
+#define GL_COMBINER_BIAS_NV               0x8549
+#define GL_COMBINER_AB_OUTPUT_NV          0x854A
+#define GL_COMBINER_CD_OUTPUT_NV          0x854B
+#define GL_COMBINER_SUM_OUTPUT_NV         0x854C
+#define GL_MAX_GENERAL_COMBINERS_NV       0x854D
+#define GL_NUM_GENERAL_COMBINERS_NV       0x854E
+#define GL_COLOR_SUM_CLAMP_NV             0x854F
+#define GL_COMBINER0_NV                   0x8550
+#define GL_COMBINER1_NV                   0x8551
+#define GL_COMBINER2_NV                   0x8552
+#define GL_COMBINER3_NV                   0x8553
+#define GL_COMBINER4_NV                   0x8554
+#define GL_COMBINER5_NV                   0x8555
+#define GL_COMBINER6_NV                   0x8556
+#define GL_COMBINER7_NV                   0x8557
+/* reuse GL_TEXTURE0_ARB */
+/* reuse GL_TEXTURE1_ARB */
+/* reuse GL_ZERO */
+/* reuse GL_NONE */
+/* reuse GL_FOG */
+#endif
+
+#ifndef GL_NV_fog_distance
+#define GL_FOG_DISTANCE_MODE_NV           0x855A
+#define GL_EYE_RADIAL_NV                  0x855B
+#define GL_EYE_PLANE_ABSOLUTE_NV          0x855C
+/* reuse GL_EYE_PLANE */
+#endif
+
+#ifndef GL_NV_texgen_emboss
+#define GL_EMBOSS_LIGHT_NV                0x855D
+#define GL_EMBOSS_CONSTANT_NV             0x855E
+#define GL_EMBOSS_MAP_NV                  0x855F
+#endif
+
+#ifndef GL_NV_blend_square
+#endif
+
+#ifndef GL_NV_texture_env_combine4
+#define GL_COMBINE4_NV                    0x8503
+#define GL_SOURCE3_RGB_NV                 0x8583
+#define GL_SOURCE3_ALPHA_NV               0x858B
+#define GL_OPERAND3_RGB_NV                0x8593
+#define GL_OPERAND3_ALPHA_NV              0x859B
+#endif
+
+#ifndef GL_MESA_resize_buffers
+#endif
+
+#ifndef GL_MESA_window_pos
+#endif
+
+#ifndef GL_EXT_texture_compression_s3tc
+#define GL_COMPRESSED_RGB_S3TC_DXT1_EXT   0x83F0
+#define GL_COMPRESSED_RGBA_S3TC_DXT1_EXT  0x83F1
+#define GL_COMPRESSED_RGBA_S3TC_DXT3_EXT  0x83F2
+#define GL_COMPRESSED_RGBA_S3TC_DXT5_EXT  0x83F3
+#endif
+
+#ifndef GL_IBM_cull_vertex
+#define GL_CULL_VERTEX_IBM                103050
+#endif
+
+#ifndef GL_IBM_multimode_draw_arrays
+#endif
+
+#ifndef GL_IBM_vertex_array_lists
+#define GL_VERTEX_ARRAY_LIST_IBM          103070
+#define GL_NORMAL_ARRAY_LIST_IBM          103071
+#define GL_COLOR_ARRAY_LIST_IBM           103072
+#define GL_INDEX_ARRAY_LIST_IBM           103073
+#define GL_TEXTURE_COORD_ARRAY_LIST_IBM   103074
+#define GL_EDGE_FLAG_ARRAY_LIST_IBM       103075
+#define GL_FOG_COORDINATE_ARRAY_LIST_IBM  103076
+#define GL_SECONDARY_COLOR_ARRAY_LIST_IBM 103077
+#define GL_VERTEX_ARRAY_LIST_STRIDE_IBM   103080
+#define GL_NORMAL_ARRAY_LIST_STRIDE_IBM   103081
+#define GL_COLOR_ARRAY_LIST_STRIDE_IBM    103082
+#define GL_INDEX_ARRAY_LIST_STRIDE_IBM    103083
+#define GL_TEXTURE_COORD_ARRAY_LIST_STRIDE_IBM 103084
+#define GL_EDGE_FLAG_ARRAY_LIST_STRIDE_IBM 103085
+#define GL_FOG_COORDINATE_ARRAY_LIST_STRIDE_IBM 103086
+#define GL_SECONDARY_COLOR_ARRAY_LIST_STRIDE_IBM 103087
+#endif
+
+#ifndef GL_SGIX_subsample
+#define GL_PACK_SUBSAMPLE_RATE_SGIX       0x85A0
+#define GL_UNPACK_SUBSAMPLE_RATE_SGIX     0x85A1
+#define GL_PIXEL_SUBSAMPLE_4444_SGIX      0x85A2
+#define GL_PIXEL_SUBSAMPLE_2424_SGIX      0x85A3
+#define GL_PIXEL_SUBSAMPLE_4242_SGIX      0x85A4
+#endif
+
+#ifndef GL_SGIX_ycrcb_subsample
+#endif
+
+#ifndef GL_SGIX_ycrcba
+#define GL_YCRCB_SGIX                     0x8318
+#define GL_YCRCBA_SGIX                    0x8319
+#endif
+
+#ifndef GL_SGI_depth_pass_instrument
+#define GL_DEPTH_PASS_INSTRUMENT_SGIX     0x8310
+#define GL_DEPTH_PASS_INSTRUMENT_COUNTERS_SGIX 0x8311
+#define GL_DEPTH_PASS_INSTRUMENT_MAX_SGIX 0x8312
+#endif
+
+#ifndef GL_3DFX_texture_compression_FXT1
+#define GL_COMPRESSED_RGB_FXT1_3DFX       0x86B0
+#define GL_COMPRESSED_RGBA_FXT1_3DFX      0x86B1
+#endif
+
+#ifndef GL_3DFX_multisample
+#define GL_MULTISAMPLE_3DFX               0x86B2
+#define GL_SAMPLE_BUFFERS_3DFX            0x86B3
+#define GL_SAMPLES_3DFX                   0x86B4
+#define GL_MULTISAMPLE_BIT_3DFX           0x20000000
+#endif
+
+#ifndef GL_3DFX_tbuffer
+#endif
+
+#ifndef GL_EXT_multisample
+#define GL_MULTISAMPLE_EXT                0x809D
+#define GL_SAMPLE_ALPHA_TO_MASK_EXT       0x809E
+#define GL_SAMPLE_ALPHA_TO_ONE_EXT        0x809F
+#define GL_SAMPLE_MASK_EXT                0x80A0
+#define GL_1PASS_EXT                      0x80A1
+#define GL_2PASS_0_EXT                    0x80A2
+#define GL_2PASS_1_EXT                    0x80A3
+#define GL_4PASS_0_EXT                    0x80A4
+#define GL_4PASS_1_EXT                    0x80A5
+#define GL_4PASS_2_EXT                    0x80A6
+#define GL_4PASS_3_EXT                    0x80A7
+#define GL_SAMPLE_BUFFERS_EXT             0x80A8
+#define GL_SAMPLES_EXT                    0x80A9
+#define GL_SAMPLE_MASK_VALUE_EXT          0x80AA
+#define GL_SAMPLE_MASK_INVERT_EXT         0x80AB
+#define GL_SAMPLE_PATTERN_EXT             0x80AC
+#endif
+
+#ifndef GL_SGIX_vertex_preclip
+#define GL_VERTEX_PRECLIP_SGIX            0x83EE
+#define GL_VERTEX_PRECLIP_HINT_SGIX       0x83EF
+#endif
+
+#ifndef GL_SGIX_convolution_accuracy
+#define GL_CONVOLUTION_HINT_SGIX          0x8316
+#endif
+
+#ifndef GL_SGIX_resample
+#define GL_PACK_RESAMPLE_SGIX             0x842C
+#define GL_UNPACK_RESAMPLE_SGIX           0x842D
+#define GL_RESAMPLE_REPLICATE_SGIX        0x842E
+#define GL_RESAMPLE_ZERO_FILL_SGIX        0x842F
+#define GL_RESAMPLE_DECIMATE_SGIX         0x8430
+#endif
+
+#ifndef GL_SGIS_point_line_texgen
+#define GL_EYE_DISTANCE_TO_POINT_SGIS     0x81F0
+#define GL_OBJECT_DISTANCE_TO_POINT_SGIS  0x81F1
+#define GL_EYE_DISTANCE_TO_LINE_SGIS      0x81F2
+#define GL_OBJECT_DISTANCE_TO_LINE_SGIS   0x81F3
+#define GL_EYE_POINT_SGIS                 0x81F4
+#define GL_OBJECT_POINT_SGIS              0x81F5
+#define GL_EYE_LINE_SGIS                  0x81F6
+#define GL_OBJECT_LINE_SGIS               0x81F7
+#endif
+
+#ifndef GL_SGIS_texture_color_mask
+#define GL_TEXTURE_COLOR_WRITEMASK_SGIS   0x81EF
+#endif
+
+
+/*************************************************************/
+
+#ifndef GL_VERSION_1_2
+#define GL_VERSION_1_2 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glBlendColor (GLclampf, GLclampf, GLclampf, GLclampf);
+extern void glBlendEquation (GLenum);
+extern void glDrawRangeElements (GLenum, GLuint, GLuint, GLsizei, GLenum, const GLvoid *);
+extern void glColorTable (GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *);
+extern void glColorTableParameterfv (GLenum, GLenum, const GLfloat *);
+extern void glColorTableParameteriv (GLenum, GLenum, const GLint *);
+extern void glCopyColorTable (GLenum, GLenum, GLint, GLint, GLsizei);
+extern void glGetColorTable (GLenum, GLenum, GLenum, GLvoid *);
+extern void glGetColorTableParameterfv (GLenum, GLenum, GLfloat *);
+extern void glGetColorTableParameteriv (GLenum, GLenum, GLint *);
+extern void glColorSubTable (GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *);
+extern void glCopyColorSubTable (GLenum, GLsizei, GLint, GLint, GLsizei);
+extern void glConvolutionFilter1D (GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *);
+extern void glConvolutionFilter2D (GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *);
+extern void glConvolutionParameterf (GLenum, GLenum, GLfloat);
+extern void glConvolutionParameterfv (GLenum, GLenum, const GLfloat *);
+extern void glConvolutionParameteri (GLenum, GLenum, GLint);
+extern void glConvolutionParameteriv (GLenum, GLenum, const GLint *);
+extern void glCopyConvolutionFilter1D (GLenum, GLenum, GLint, GLint, GLsizei);
+extern void glCopyConvolutionFilter2D (GLenum, GLenum, GLint, GLint, GLsizei, GLsizei);
+extern void glGetConvolutionFilter (GLenum, GLenum, GLenum, GLvoid *);
+extern void glGetConvolutionParameterfv (GLenum, GLenum, GLfloat *);
+extern void glGetConvolutionParameteriv (GLenum, GLenum, GLint *);
+extern void glGetSeparableFilter (GLenum, GLenum, GLenum, GLvoid *, GLvoid *, GLvoid *);
+extern void glSeparableFilter2D (GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *, const GLvoid *);
+extern void glGetHistogram (GLenum, GLboolean, GLenum, GLenum, GLvoid *);
+extern void glGetHistogramParameterfv (GLenum, GLenum, GLfloat *);
+extern void glGetHistogramParameteriv (GLenum, GLenum, GLint *);
+extern void glGetMinmax (GLenum, GLboolean, GLenum, GLenum, GLvoid *);
+extern void glGetMinmaxParameterfv (GLenum, GLenum, GLfloat *);
+extern void glGetMinmaxParameteriv (GLenum, GLenum, GLint *);
+extern void glHistogram (GLenum, GLsizei, GLenum, GLboolean);
+extern void glMinmax (GLenum, GLenum, GLboolean);
+extern void glResetHistogram (GLenum);
+extern void glResetMinmax (GLenum);
+extern void glTexImage3D (GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *);
+extern void glTexSubImage3D (GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *);
+extern void glCopyTexSubImage3D (GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_ARB_multitexture
+#define GL_ARB_multitexture 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glActiveTextureARB (GLenum);
+extern void glClientActiveTextureARB (GLenum);
+extern void glMultiTexCoord1dARB (GLenum, GLdouble);
+extern void glMultiTexCoord1dvARB (GLenum, const GLdouble *);
+extern void glMultiTexCoord1fARB (GLenum, GLfloat);
+extern void glMultiTexCoord1fvARB (GLenum, const GLfloat *);
+extern void glMultiTexCoord1iARB (GLenum, GLint);
+extern void glMultiTexCoord1ivARB (GLenum, const GLint *);
+extern void glMultiTexCoord1sARB (GLenum, GLshort);
+extern void glMultiTexCoord1svARB (GLenum, const GLshort *);
+extern void glMultiTexCoord2dARB (GLenum, GLdouble, GLdouble);
+extern void glMultiTexCoord2dvARB (GLenum, const GLdouble *);
+extern void glMultiTexCoord2fARB (GLenum, GLfloat, GLfloat);
+extern void glMultiTexCoord2fvARB (GLenum, const GLfloat *);
+extern void glMultiTexCoord2iARB (GLenum, GLint, GLint);
+extern void glMultiTexCoord2ivARB (GLenum, const GLint *);
+extern void glMultiTexCoord2sARB (GLenum, GLshort, GLshort);
+extern void glMultiTexCoord2svARB (GLenum, const GLshort *);
+extern void glMultiTexCoord3dARB (GLenum, GLdouble, GLdouble, GLdouble);
+extern void glMultiTexCoord3dvARB (GLenum, const GLdouble *);
+extern void glMultiTexCoord3fARB (GLenum, GLfloat, GLfloat, GLfloat);
+extern void glMultiTexCoord3fvARB (GLenum, const GLfloat *);
+extern void glMultiTexCoord3iARB (GLenum, GLint, GLint, GLint);
+extern void glMultiTexCoord3ivARB (GLenum, const GLint *);
+extern void glMultiTexCoord3sARB (GLenum, GLshort, GLshort, GLshort);
+extern void glMultiTexCoord3svARB (GLenum, const GLshort *);
+extern void glMultiTexCoord4dARB (GLenum, GLdouble, GLdouble, GLdouble, GLdouble);
+extern void glMultiTexCoord4dvARB (GLenum, const GLdouble *);
+extern void glMultiTexCoord4fARB (GLenum, GLfloat, GLfloat, GLfloat, GLfloat);
+extern void glMultiTexCoord4fvARB (GLenum, const GLfloat *);
+extern void glMultiTexCoord4iARB (GLenum, GLint, GLint, GLint, GLint);
+extern void glMultiTexCoord4ivARB (GLenum, const GLint *);
+extern void glMultiTexCoord4sARB (GLenum, GLshort, GLshort, GLshort, GLshort);
+extern void glMultiTexCoord4svARB (GLenum, const GLshort *);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_ARB_transpose_matrix
+#define GL_ARB_transpose_matrix 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glLoadTransposeMatrixfARB (const GLfloat *);
+extern void glLoadTransposeMatrixdARB (const GLdouble *);
+extern void glMultTransposeMatrixfARB (const GLfloat *);
+extern void glMultTransposeMatrixdARB (const GLdouble *);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_ARB_multisample
+#define GL_ARB_multisample 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glSampleCoverageARB (GLclampf, GLboolean);
+extern void glSamplePassARB (GLenum);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_ARB_texture_env_add
+#define GL_ARB_texture_env_add 1
+#endif
+
+#ifndef GL_ARB_texture_cube_map
+#define GL_ARB_texture_cube_map 1
+#endif
+
+#ifndef GL_ARB_texture_compression
+#define GL_ARB_texture_compression 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glCompressedTexImage3DARB (GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLsizei, const GLvoid *);
+extern void glCompressedTexImage2DARB (GLenum, GLint, GLenum, GLsizei, GLsizei, GLint, GLsizei, const GLvoid *);
+extern void glCompressedTexImage1DARB (GLenum, GLint, GLenum, GLsizei, GLint, GLsizei, const GLvoid *);
+extern void glCompressedTexSubImage3DARB (GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLsizei, const GLvoid *);
+extern void glCompressedTexSubImage2DARB (GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLsizei, const GLvoid *);
+extern void glCompressedTexSubImage1DARB (GLenum, GLint, GLint, GLsizei, GLenum, GLsizei, const GLvoid *);
+extern void glGetCompressedTexImageARB (GLenum, GLint, void *);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_EXT_abgr
+#define GL_EXT_abgr 1
+#endif
+
+#ifndef GL_EXT_blend_color
+#define GL_EXT_blend_color 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glBlendColorEXT (GLclampf, GLclampf, GLclampf, GLclampf);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_EXT_polygon_offset
+#define GL_EXT_polygon_offset 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glPolygonOffsetEXT (GLfloat, GLfloat);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_EXT_texture
+#define GL_EXT_texture 1
+#endif
+
+#ifndef GL_EXT_texture3D
+#define GL_EXT_texture3D 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glTexImage3DEXT (GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *);
+extern void glTexSubImage3DEXT (GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_SGIS_texture_filter4
+#define GL_SGIS_texture_filter4 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glGetTexFilterFuncSGIS (GLenum, GLenum, GLfloat *);
+extern void glTexFilterFuncSGIS (GLenum, GLenum, GLsizei, const GLfloat *);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_EXT_subtexture
+#define GL_EXT_subtexture 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glTexSubImage1DEXT (GLenum, GLint, GLint, GLsizei, GLenum, GLenum, const GLvoid *);
+extern void glTexSubImage2DEXT (GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_EXT_copy_texture
+#define GL_EXT_copy_texture 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glCopyTexImage1DEXT (GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLint);
+extern void glCopyTexImage2DEXT (GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLsizei, GLint);
+extern void glCopyTexSubImage1DEXT (GLenum, GLint, GLint, GLint, GLint, GLsizei);
+extern void glCopyTexSubImage2DEXT (GLenum, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei);
+extern void glCopyTexSubImage3DEXT (GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_EXT_histogram
+#define GL_EXT_histogram 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glGetHistogramEXT (GLenum, GLboolean, GLenum, GLenum, GLvoid *);
+extern void glGetHistogramParameterfvEXT (GLenum, GLenum, GLfloat *);
+extern void glGetHistogramParameterivEXT (GLenum, GLenum, GLint *);
+extern void glGetMinmaxEXT (GLenum, GLboolean, GLenum, GLenum, GLvoid *);
+extern void glGetMinmaxParameterfvEXT (GLenum, GLenum, GLfloat *);
+extern void glGetMinmaxParameterivEXT (GLenum, GLenum, GLint *);
+extern void glHistogramEXT (GLenum, GLsizei, GLenum, GLboolean);
+extern void glMinmaxEXT (GLenum, GLenum, GLboolean);
+extern void glResetHistogramEXT (GLenum);
+extern void glResetMinmaxEXT (GLenum);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_EXT_convolution
+#define GL_EXT_convolution 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glConvolutionFilter1DEXT (GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *);
+extern void glConvolutionFilter2DEXT (GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *);
+extern void glConvolutionParameterfEXT (GLenum, GLenum, GLfloat);
+extern void glConvolutionParameterfvEXT (GLenum, GLenum, const GLfloat *);
+extern void glConvolutionParameteriEXT (GLenum, GLenum, GLint);
+extern void glConvolutionParameterivEXT (GLenum, GLenum, const GLint *);
+extern void glCopyConvolutionFilter1DEXT (GLenum, GLenum, GLint, GLint, GLsizei);
+extern void glCopyConvolutionFilter2DEXT (GLenum, GLenum, GLint, GLint, GLsizei, GLsizei);
+extern void glGetConvolutionFilterEXT (GLenum, GLenum, GLenum, GLvoid *);
+extern void glGetConvolutionParameterfvEXT (GLenum, GLenum, GLfloat *);
+extern void glGetConvolutionParameterivEXT (GLenum, GLenum, GLint *);
+extern void glGetSeparableFilterEXT (GLenum, GLenum, GLenum, GLvoid *, GLvoid *, GLvoid *);
+extern void glSeparableFilter2DEXT (GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *, const GLvoid *);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_EXT_color_matrix
+#define GL_EXT_color_matrix 1
+#endif
+
+#ifndef GL_SGI_color_table
+#define GL_SGI_color_table 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glColorTableSGI (GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *);
+extern void glColorTableParameterfvSGI (GLenum, GLenum, const GLfloat *);
+extern void glColorTableParameterivSGI (GLenum, GLenum, const GLint *);
+extern void glCopyColorTableSGI (GLenum, GLenum, GLint, GLint, GLsizei);
+extern void glGetColorTableSGI (GLenum, GLenum, GLenum, GLvoid *);
+extern void glGetColorTableParameterfvSGI (GLenum, GLenum, GLfloat *);
+extern void glGetColorTableParameterivSGI (GLenum, GLenum, GLint *);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_SGIX_pixel_texture
+#define GL_SGIX_pixel_texture 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glPixelTexGenSGIX (GLenum);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_SGIS_pixel_texture
+#define GL_SGIS_pixel_texture 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glPixelTexGenParameteriSGIS (GLenum, GLint);
+extern void glPixelTexGenParameterivSGIS (GLenum, const GLint *);
+extern void glPixelTexGenParameterfSGIS (GLenum, GLfloat);
+extern void glPixelTexGenParameterfvSGIS (GLenum, const GLfloat *);
+extern void glGetPixelTexGenParameterivSGIS (GLenum, GLint *);
+extern void glGetPixelTexGenParameterfvSGIS (GLenum, GLfloat *);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_SGIS_texture4D
+#define GL_SGIS_texture4D 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glTexImage4DSGIS (GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *);
+extern void glTexSubImage4DSGIS (GLenum, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_SGI_texture_color_table
+#define GL_SGI_texture_color_table 1
+#endif
+
+#ifndef GL_EXT_cmyka
+#define GL_EXT_cmyka 1
+#endif
+
+#ifndef GL_EXT_texture_object
+#define GL_EXT_texture_object 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern GLboolean glAreTexturesResidentEXT (GLsizei, const GLuint *, GLboolean *);
+extern void glBindTextureEXT (GLenum, GLuint);
+extern void glDeleteTexturesEXT (GLsizei, const GLuint *);
+extern void glGenTexturesEXT (GLsizei, GLuint *);
+extern GLboolean glIsTextureEXT (GLuint);
+extern void glPrioritizeTexturesEXT (GLsizei, const GLuint *, const GLclampf *);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_SGIS_detail_texture
+#define GL_SGIS_detail_texture 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glDetailTexFuncSGIS (GLenum, GLsizei, const GLfloat *);
+extern void glGetDetailTexFuncSGIS (GLenum, GLfloat *);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_SGIS_sharpen_texture
+#define GL_SGIS_sharpen_texture 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glSharpenTexFuncSGIS (GLenum, GLsizei, const GLfloat *);
+extern void glGetSharpenTexFuncSGIS (GLenum, GLfloat *);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_EXT_packed_pixels
+#define GL_EXT_packed_pixels 1
+#endif
+
+#ifndef GL_SGIS_texture_lod
+#define GL_SGIS_texture_lod 1
+#endif
+
+#ifndef GL_SGIS_multisample
+#define GL_SGIS_multisample 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glSampleMaskSGIS (GLclampf, GLboolean);
+extern void glSamplePatternSGIS (GLenum);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_EXT_rescale_normal
+#define GL_EXT_rescale_normal 1
+#endif
+
+#ifndef GL_EXT_vertex_array
+#define GL_EXT_vertex_array 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glArrayElementEXT (GLint);
+extern void glColorPointerEXT (GLint, GLenum, GLsizei, GLsizei, const GLvoid *);
+extern void glDrawArraysEXT (GLenum, GLint, GLsizei);
+extern void glEdgeFlagPointerEXT (GLsizei, GLsizei, const GLboolean *);
+extern void glGetPointervEXT (GLenum, GLvoid* *);
+extern void glIndexPointerEXT (GLenum, GLsizei, GLsizei, const GLvoid *);
+extern void glNormalPointerEXT (GLenum, GLsizei, GLsizei, const GLvoid *);
+extern void glTexCoordPointerEXT (GLint, GLenum, GLsizei, GLsizei, const GLvoid *);
+extern void glVertexPointerEXT (GLint, GLenum, GLsizei, GLsizei, const GLvoid *);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_EXT_misc_attribute
+#define GL_EXT_misc_attribute 1
+#endif
+
+#ifndef GL_SGIS_generate_mipmap
+#define GL_SGIS_generate_mipmap 1
+#endif
+
+#ifndef GL_SGIX_clipmap
+#define GL_SGIX_clipmap 1
+#endif
+
+#ifndef GL_SGIX_shadow
+#define GL_SGIX_shadow 1
+#endif
+
+#ifndef GL_SGIS_texture_edge_clamp
+#define GL_SGIS_texture_edge_clamp 1
+#endif
+
+#ifndef GL_SGIS_texture_border_clamp
+#define GL_SGIS_texture_border_clamp 1
+#endif
+
+#ifndef GL_EXT_blend_minmax
+#define GL_EXT_blend_minmax 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glBlendEquationEXT (GLenum);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_EXT_blend_subtract
+#define GL_EXT_blend_subtract 1
+#endif
+
+#ifndef GL_EXT_blend_logic_op
+#define GL_EXT_blend_logic_op 1
+#endif
+
+#ifndef GL_SGIX_interlace
+#define GL_SGIX_interlace 1
+#endif
+
+#ifndef GL_SGIX_pixel_tiles
+#define GL_SGIX_pixel_tiles 1
+#endif
+
+#ifndef GL_SGIX_texture_select
+#define GL_SGIX_texture_select 1
+#endif
+
+#ifndef GL_SGIX_sprite
+#define GL_SGIX_sprite 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glSpriteParameterfSGIX (GLenum, GLfloat);
+extern void glSpriteParameterfvSGIX (GLenum, const GLfloat *);
+extern void glSpriteParameteriSGIX (GLenum, GLint);
+extern void glSpriteParameterivSGIX (GLenum, const GLint *);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_SGIX_texture_multi_buffer
+#define GL_SGIX_texture_multi_buffer 1
+#endif
+
+#ifndef GL_EXT_point_parameters
+#define GL_EXT_point_parameters 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glPointParameterfEXT (GLenum, GLfloat);
+extern void glPointParameterfvEXT (GLenum, const GLfloat *);
+extern void glPointParameterfSGIS (GLenum, GLfloat);
+extern void glPointParameterfvSGIS (GLenum, const GLfloat *);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_SGIX_instruments
+#define GL_SGIX_instruments 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern GLint glGetInstrumentsSGIX (void);
+extern void glInstrumentsBufferSGIX (GLsizei, GLint *);
+extern GLint glPollInstrumentsSGIX (GLint *);
+extern void glReadInstrumentsSGIX (GLint);
+extern void glStartInstrumentsSGIX (void);
+extern void glStopInstrumentsSGIX (GLint);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_SGIX_texture_scale_bias
+#define GL_SGIX_texture_scale_bias 1
+#endif
+
+#ifndef GL_SGIX_framezoom
+#define GL_SGIX_framezoom 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glFrameZoomSGIX (GLint);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_SGIX_tag_sample_buffer
+#define GL_SGIX_tag_sample_buffer 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glTagSampleBufferSGIX (void);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_SGIX_reference_plane
+#define GL_SGIX_reference_plane 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glReferencePlaneSGIX (const GLdouble *);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_SGIX_flush_raster
+#define GL_SGIX_flush_raster 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glFlushRasterSGIX (void);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_SGIX_depth_texture
+#define GL_SGIX_depth_texture 1
+#endif
+
+#ifndef GL_SGIS_fog_function
+#define GL_SGIS_fog_function 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glFogFuncSGIS (GLsizei, const GLfloat *);
+extern void glGetFogFuncSGIS (const GLfloat *);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_SGIX_fog_offset
+#define GL_SGIX_fog_offset 1
+#endif
+
+#ifndef GL_HP_image_transform
+#define GL_HP_image_transform 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glImageTransformParameteriHP (GLenum, GLenum, GLint);
+extern void glImageTransformParameterfHP (GLenum, GLenum, GLfloat);
+extern void glImageTransformParameterivHP (GLenum, GLenum, const GLint *);
+extern void glImageTransformParameterfvHP (GLenum, GLenum, const GLfloat *);
+extern void glGetImageTransformParameterivHP (GLenum, GLenum, GLint *);
+extern void glGetImageTransformParameterfvHP (GLenum, GLenum, GLfloat *);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_HP_convolution_border_modes
+#define GL_HP_convolution_border_modes 1
+#endif
+
+#ifndef GL_SGIX_texture_add_env
+#define GL_SGIX_texture_add_env 1
+#endif
+
+#ifndef GL_EXT_color_subtable
+#define GL_EXT_color_subtable 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glColorSubTableEXT (GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *);
+extern void glCopyColorSubTableEXT (GLenum, GLsizei, GLint, GLint, GLsizei);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_PGI_vertex_hints
+#define GL_PGI_vertex_hints 1
+#endif
+
+#ifndef GL_PGI_misc_hints
+#define GL_PGI_misc_hints 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glHintPGI (GLenum, GLint);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_EXT_paletted_texture
+#define GL_EXT_paletted_texture 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glColorTableEXT (GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *);
+extern void glGetColorTableEXT (GLenum, GLenum, GLenum, GLvoid *);
+extern void glGetColorTableParameterivEXT (GLenum, GLenum, GLint *);
+extern void glGetColorTableParameterfvEXT (GLenum, GLenum, GLfloat *);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_EXT_clip_volume_hint
+#define GL_EXT_clip_volume_hint 1
+#endif
+
+#ifndef GL_SGIX_list_priority
+#define GL_SGIX_list_priority 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glGetListParameterfvSGIX (GLuint, GLenum, GLfloat *);
+extern void glGetListParameterivSGIX (GLuint, GLenum, GLint *);
+extern void glListParameterfSGIX (GLuint, GLenum, GLfloat);
+extern void glListParameterfvSGIX (GLuint, GLenum, const GLfloat *);
+extern void glListParameteriSGIX (GLuint, GLenum, GLint);
+extern void glListParameterivSGIX (GLuint, GLenum, const GLint *);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_SGIX_ir_instrument1
+#define GL_SGIX_ir_instrument1 1
+#endif
+
+#ifndef GL_SGIX_calligraphic_fragment
+#define GL_SGIX_calligraphic_fragment 1
+#endif
+
+#ifndef GL_SGIX_texture_lod_bias
+#define GL_SGIX_texture_lod_bias 1
+#endif
+
+#ifndef GL_SGIX_shadow_ambient
+#define GL_SGIX_shadow_ambient 1
+#endif
+
+#ifndef GL_EXT_index_texture
+#define GL_EXT_index_texture 1
+#endif
+
+#ifndef GL_EXT_index_material
+#define GL_EXT_index_material 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glIndexMaterialEXT (GLenum, GLenum);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_EXT_index_func
+#define GL_EXT_index_func 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glIndexFuncEXT (GLenum, GLclampf);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_EXT_index_array_formats
+#define GL_EXT_index_array_formats 1
+#endif
+
+#ifndef GL_EXT_compiled_vertex_array
+#define GL_EXT_compiled_vertex_array 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glLockArraysEXT (GLint, GLsizei);
+extern void glUnlockArraysEXT (void);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_EXT_cull_vertex
+#define GL_EXT_cull_vertex 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glCullParameterdvEXT (GLenum, GLdouble *);
+extern void glCullParameterfvEXT (GLenum, GLfloat *);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_SGIX_ycrcb
+#define GL_SGIX_ycrcb 1
+#endif
+
+#ifndef GL_SGIX_fragment_lighting
+#define GL_SGIX_fragment_lighting 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glFragmentColorMaterialSGIX (GLenum, GLenum);
+extern void glFragmentLightfSGIX (GLenum, GLenum, GLfloat);
+extern void glFragmentLightfvSGIX (GLenum, GLenum, const GLfloat *);
+extern void glFragmentLightiSGIX (GLenum, GLenum, GLint);
+extern void glFragmentLightivSGIX (GLenum, GLenum, const GLint *);
+extern void glFragmentLightModelfSGIX (GLenum, GLfloat);
+extern void glFragmentLightModelfvSGIX (GLenum, const GLfloat *);
+extern void glFragmentLightModeliSGIX (GLenum, GLint);
+extern void glFragmentLightModelivSGIX (GLenum, const GLint *);
+extern void glFragmentMaterialfSGIX (GLenum, GLenum, GLfloat);
+extern void glFragmentMaterialfvSGIX (GLenum, GLenum, const GLfloat *);
+extern void glFragmentMaterialiSGIX (GLenum, GLenum, GLint);
+extern void glFragmentMaterialivSGIX (GLenum, GLenum, const GLint *);
+extern void glGetFragmentLightfvSGIX (GLenum, GLenum, GLfloat *);
+extern void glGetFragmentLightivSGIX (GLenum, GLenum, GLint *);
+extern void glGetFragmentMaterialfvSGIX (GLenum, GLenum, GLfloat *);
+extern void glGetFragmentMaterialivSGIX (GLenum, GLenum, GLint *);
+extern void glLightEnviSGIX (GLenum, GLint);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_IBM_rasterpos_clip
+#define GL_IBM_rasterpos_clip 1
+#endif
+
+#ifndef GL_HP_texture_lighting
+#define GL_HP_texture_lighting 1
+#endif
+
+#ifndef GL_EXT_draw_range_elements
+#define GL_EXT_draw_range_elements 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glDrawRangeElementsEXT (GLenum, GLuint, GLuint, GLsizei, GLenum, const GLvoid *);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_WIN_phong_shading
+#define GL_WIN_phong_shading 1
+#endif
+
+#ifndef GL_WIN_specular_fog
+#define GL_WIN_specular_fog 1
+#endif
+
+#ifndef GL_EXT_light_texture
+#define GL_EXT_light_texture 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glApplyTextureEXT (GLenum);
+extern void glTextureLightEXT (GLenum);
+extern void glTextureMaterialEXT (GLenum, GLenum);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_SGIX_blend_alpha_minmax
+#define GL_SGIX_blend_alpha_minmax 1
+#endif
+
+#ifndef GL_EXT_bgra
+#define GL_EXT_bgra 1
+#endif
+
+#ifndef GL_INTEL_parallel_arrays
+#define GL_INTEL_parallel_arrays 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glVertexPointervINTEL (GLint, GLenum, const GLvoid* *);
+extern void glNormalPointervINTEL (GLenum, const GLvoid* *);
+extern void glColorPointervINTEL (GLint, GLenum, const GLvoid* *);
+extern void glTexCoordPointervINTEL (GLint, GLenum, const GLvoid* *);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_HP_occlusion_test
+#define GL_HP_occlusion_test 1
+#endif
+
+#ifndef GL_EXT_pixel_transform
+#define GL_EXT_pixel_transform 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glPixelTransformParameteriEXT (GLenum, GLenum, GLint);
+extern void glPixelTransformParameterfEXT (GLenum, GLenum, GLfloat);
+extern void glPixelTransformParameterivEXT (GLenum, GLenum, const GLint *);
+extern void glPixelTransformParameterfvEXT (GLenum, GLenum, const GLfloat *);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_EXT_pixel_transform_color_table
+#define GL_EXT_pixel_transform_color_table 1
+#endif
+
+#ifndef GL_EXT_shared_texture_palette
+#define GL_EXT_shared_texture_palette 1
+#endif
+
+#ifndef GL_EXT_separate_specular_color
+#define GL_EXT_separate_specular_color 1
+#endif
+
+#ifndef GL_EXT_secondary_color
+#define GL_EXT_secondary_color 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glSecondaryColor3bEXT (GLbyte, GLbyte, GLbyte);
+extern void glSecondaryColor3bvEXT (const GLbyte *);
+extern void glSecondaryColor3dEXT (GLdouble, GLdouble, GLdouble);
+extern void glSecondaryColor3dvEXT (const GLdouble *);
+extern void glSecondaryColor3fEXT (GLfloat, GLfloat, GLfloat);
+extern void glSecondaryColor3fvEXT (const GLfloat *);
+extern void glSecondaryColor3iEXT (GLint, GLint, GLint);
+extern void glSecondaryColor3ivEXT (const GLint *);
+extern void glSecondaryColor3sEXT (GLshort, GLshort, GLshort);
+extern void glSecondaryColor3svEXT (const GLshort *);
+extern void glSecondaryColor3ubEXT (GLubyte, GLubyte, GLubyte);
+extern void glSecondaryColor3ubvEXT (const GLubyte *);
+extern void glSecondaryColor3uiEXT (GLuint, GLuint, GLuint);
+extern void glSecondaryColor3uivEXT (const GLuint *);
+extern void glSecondaryColor3usEXT (GLushort, GLushort, GLushort);
+extern void glSecondaryColor3usvEXT (const GLushort *);
+extern void glSecondaryColorPointerEXT (GLint, GLenum, GLsizei, GLvoid *);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_EXT_texture_perturb_normal
+#define GL_EXT_texture_perturb_normal 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glTextureNormalEXT (GLenum);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_EXT_multi_draw_arrays
+#define GL_EXT_multi_draw_arrays 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glMultiDrawArraysEXT (GLenum, GLint *, GLsizei *, GLsizei);
+extern void glMultiDrawElementsEXT (GLenum, const GLsizei *, GLenum, const GLvoid* *, GLsizei);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_EXT_fog_coord
+#define GL_EXT_fog_coord 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glFogCoordfEXT (GLfloat);
+extern void glFogCoordfvEXT (const GLfloat *);
+extern void glFogCoorddEXT (GLdouble);
+extern void glFogCoorddvEXT (const GLdouble *);
+extern void glFogCoordPointerEXT (GLenum, GLsizei, const GLvoid *);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_REND_screen_coordinates
+#define GL_REND_screen_coordinates 1
+#endif
+
+#ifndef GL_EXT_coordinate_frame
+#define GL_EXT_coordinate_frame 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glTangent3bEXT (GLbyte, GLbyte, GLbyte);
+extern void glTangent3bvEXT (const GLbyte *);
+extern void glTangent3dEXT (GLdouble, GLdouble, GLdouble);
+extern void glTangent3dvEXT (const GLdouble *);
+extern void glTangent3fEXT (GLfloat, GLfloat, GLfloat);
+extern void glTangent3fvEXT (const GLfloat *);
+extern void glTangent3iEXT (GLint, GLint, GLint);
+extern void glTangent3ivEXT (const GLint *);
+extern void glTangent3sEXT (GLshort, GLshort, GLshort);
+extern void glTangent3svEXT (const GLshort *);
+extern void glBinormal3bEXT (GLbyte, GLbyte, GLbyte);
+extern void glBinormal3bvEXT (const GLbyte *);
+extern void glBinormal3dEXT (GLdouble, GLdouble, GLdouble);
+extern void glBinormal3dvEXT (const GLdouble *);
+extern void glBinormal3fEXT (GLfloat, GLfloat, GLfloat);
+extern void glBinormal3fvEXT (const GLfloat *);
+extern void glBinormal3iEXT (GLint, GLint, GLint);
+extern void glBinormal3ivEXT (const GLint *);
+extern void glBinormal3sEXT (GLshort, GLshort, GLshort);
+extern void glBinormal3svEXT (const GLshort *);
+extern void glTangentPointerEXT (GLenum, GLsizei, const GLvoid *);
+extern void glBinormalPointerEXT (GLenum, GLsizei, const GLvoid *);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_EXT_texture_env_combine
+#define GL_EXT_texture_env_combine 1
+#endif
+
+#ifndef GL_APPLE_specular_vector
+#define GL_APPLE_specular_vector 1
+#endif
+
+#ifndef GL_APPLE_transform_hint
+#define GL_APPLE_transform_hint 1
+#endif
+
+#ifndef GL_SGIX_fog_scale
+#define GL_SGIX_fog_scale 1
+#endif
+
+#ifndef GL_SUNX_constant_data
+#define GL_SUNX_constant_data 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glFinishTextureSUNX (void);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_SUN_global_alpha
+#define GL_SUN_global_alpha 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glGlobalAlphaFactorbSUN (GLbyte);
+extern void glGlobalAlphaFactorsSUN (GLshort);
+extern void glGlobalAlphaFactoriSUN (GLint);
+extern void glGlobalAlphaFactorfSUN (GLfloat);
+extern void glGlobalAlphaFactordSUN (GLdouble);
+extern void glGlobalAlphaFactorubSUN (GLubyte);
+extern void glGlobalAlphaFactorusSUN (GLushort);
+extern void glGlobalAlphaFactoruiSUN (GLuint);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_SUN_triangle_list
+#define GL_SUN_triangle_list 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glReplacementCodeuiSUN (GLuint);
+extern void glReplacementCodeusSUN (GLushort);
+extern void glReplacementCodeubSUN (GLubyte);
+extern void glReplacementCodeuivSUN (const GLuint *);
+extern void glReplacementCodeusvSUN (const GLushort *);
+extern void glReplacementCodeubvSUN (const GLubyte *);
+extern void glReplacementCodePointerSUN (GLenum, GLsizei, const GLvoid* *);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_SUN_vertex
+#define GL_SUN_vertex 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glColor4ubVertex2fSUN (GLubyte, GLubyte, GLubyte, GLubyte, GLfloat, GLfloat);
+extern void glColor4ubVertex2fvSUN (const GLubyte *, const GLfloat *);
+extern void glColor4ubVertex3fSUN (GLubyte, GLubyte, GLubyte, GLubyte, GLfloat, GLfloat, GLfloat);
+extern void glColor4ubVertex3fvSUN (const GLubyte *, const GLfloat *);
+extern void glColor3fVertex3fSUN (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
+extern void glColor3fVertex3fvSUN (const GLfloat *, const GLfloat *);
+extern void glNormal3fVertex3fSUN (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
+extern void glNormal3fVertex3fvSUN (const GLfloat *, const GLfloat *);
+extern void glColor4fNormal3fVertex3fSUN (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
+extern void glColor4fNormal3fVertex3fvSUN (const GLfloat *, const GLfloat *, const GLfloat *);
+extern void glTexCoord2fVertex3fSUN (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
+extern void glTexCoord2fVertex3fvSUN (const GLfloat *, const GLfloat *);
+extern void glTexCoord4fVertex4fSUN (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
+extern void glTexCoord4fVertex4fvSUN (const GLfloat *, const GLfloat *);
+extern void glTexCoord2fColor4ubVertex3fSUN (GLfloat, GLfloat, GLubyte, GLubyte, GLubyte, GLubyte, GLfloat, GLfloat, GLfloat);
+extern void glTexCoord2fColor4ubVertex3fvSUN (const GLfloat *, const GLubyte *, const GLfloat *);
+extern void glTexCoord2fColor3fVertex3fSUN (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
+extern void glTexCoord2fColor3fVertex3fvSUN (const GLfloat *, const GLfloat *, const GLfloat *);
+extern void glTexCoord2fNormal3fVertex3fSUN (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
+extern void glTexCoord2fNormal3fVertex3fvSUN (const GLfloat *, const GLfloat *, const GLfloat *);
+extern void glTexCoord2fColor4fNormal3fVertex3fSUN (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
+extern void glTexCoord2fColor4fNormal3fVertex3fvSUN (const GLfloat *, const GLfloat *, const GLfloat *, const GLfloat *);
+extern void glTexCoord4fColor4fNormal3fVertex4fSUN (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
+extern void glTexCoord4fColor4fNormal3fVertex4fvSUN (const GLfloat *, const GLfloat *, const GLfloat *, const GLfloat *);
+extern void glReplacementCodeuiVertex3fSUN (GLenum, GLfloat, GLfloat, GLfloat);
+extern void glReplacementCodeuiVertex3fvSUN (const GLenum *, const GLfloat *);
+extern void glReplacementCodeuiColor4ubVertex3fSUN (GLenum, GLubyte, GLubyte, GLubyte, GLubyte, GLfloat, GLfloat, GLfloat);
+extern void glReplacementCodeuiColor4ubVertex3fvSUN (const GLenum *, const GLubyte *, const GLfloat *);
+extern void glReplacementCodeuiColor3fVertex3fSUN (GLenum, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
+extern void glReplacementCodeuiColor3fVertex3fvSUN (const GLenum *, const GLfloat *, const GLfloat *);
+extern void glReplacementCodeuiNormal3fVertex3fSUN (GLenum, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
+extern void glReplacementCodeuiNormal3fVertex3fvSUN (const GLenum *, const GLfloat *, const GLfloat *);
+extern void glReplacementCodeuiColor4fNormal3fVertex3fSUN (GLenum, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
+extern void glReplacementCodeuiColor4fNormal3fVertex3fvSUN (const GLenum *, const GLfloat *, const GLfloat *, const GLfloat *);
+extern void glReplacementCodeuiTexCoord2fVertex3fSUN (GLenum, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
+extern void glReplacementCodeuiTexCoord2fVertex3fvSUN (const GLenum *, const GLfloat *, const GLfloat *);
+extern void glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN (GLenum, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
+extern void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN (const GLenum *, const GLfloat *, const GLfloat *, const GLfloat *);
+extern void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN (GLenum, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
+extern void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN (const GLenum *, const GLfloat *, const GLfloat *, const GLfloat *, const GLfloat *);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_EXT_blend_func_separate
+#define GL_EXT_blend_func_separate 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glBlendFuncSeparateEXT (GLenum, GLenum, GLenum, GLenum);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_INGR_color_clamp
+#define GL_INGR_color_clamp 1
+#endif
+
+#ifndef GL_INGR_interlace_read
+#define GL_INGR_interlace_read 1
+#endif
+
+#ifndef GL_EXT_stencil_wrap
+#define GL_EXT_stencil_wrap 1
+#endif
+
+#ifndef GL_EXT_422_pixels
+#define GL_EXT_422_pixels 1
+#endif
+
+#ifndef GL_NV_texgen_reflection
+#define GL_NV_texgen_reflection 1
+#endif
+
+#ifndef GL_SUN_convolution_border_modes
+#define GL_SUN_convolution_border_modes 1
+#endif
+
+#ifndef GL_EXT_texture_env_add
+#define GL_EXT_texture_env_add 1
+#endif
+
+#ifndef GL_EXT_texture_lod_bias
+#define GL_EXT_texture_lod_bias 1
+#endif
+
+#ifndef GL_EXT_texture_filter_anisotropic
+#define GL_EXT_texture_filter_anisotropic 1
+#endif
+
+#ifndef GL_EXT_vertex_weighting
+#define GL_EXT_vertex_weighting 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glVertexWeightfEXT (GLfloat);
+extern void glVertexWeightfvEXT (const GLfloat *);
+extern void glVertexWeightPointerEXT (GLsizei, GLenum, GLsizei, const GLvoid *);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_NV_light_max_exponent
+#define GL_NV_light_max_exponent 1
+#endif
+
+#ifndef GL_NV_vertex_array_range
+#define GL_NV_vertex_array_range 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glFlushVertexArrayRangeNV (void);
+extern void glVertexArrayRangeNV (GLsizei, const GLvoid *);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_NV_register_combiners
+#define GL_NV_register_combiners 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glCombinerParameterfvNV (GLenum, const GLfloat *);
+extern void glCombinerParameterfNV (GLenum, GLfloat);
+extern void glCombinerParameterivNV (GLenum, const GLint *);
+extern void glCombinerParameteriNV (GLenum, GLint);
+extern void glCombinerInputNV (GLenum, GLenum, GLenum, GLenum, GLenum, GLenum);
+extern void glCombinerOutputNV (GLenum, GLenum, GLenum, GLenum, GLenum, GLenum, GLenum, GLboolean, GLboolean, GLboolean);
+extern void glFinalCombinerInputNV (GLenum, GLenum, GLenum, GLenum);
+extern void glGetCombinerInputParameterfvNV (GLenum, GLenum, GLenum, GLenum, GLfloat *);
+extern void glGetCombinerInputParameterivNV (GLenum, GLenum, GLenum, GLenum, GLint *);
+extern void glGetCombinerOutputParameterfvNV (GLenum, GLenum, GLenum, GLfloat *);
+extern void glGetCombinerOutputParameterivNV (GLenum, GLenum, GLenum, GLint *);
+extern void glGetFinalCombinerInputParameterfvNV (GLenum, GLenum, GLfloat *);
+extern void glGetFinalCombinerInputParameterivNV (GLenum, GLenum, GLint *);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_NV_fog_distance
+#define GL_NV_fog_distance 1
+#endif
+
+#ifndef GL_NV_texgen_emboss
+#define GL_NV_texgen_emboss 1
+#endif
+
+#ifndef GL_NV_blend_square
+#define GL_NV_blend_square 1
+#endif
+
+#ifndef GL_NV_texture_env_combine4
+#define GL_NV_texture_env_combine4 1
+#endif
+
+#ifndef GL_MESA_resize_buffers
+#define GL_MESA_resize_buffers 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glResizeBuffersMESA (void);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_MESA_window_pos
+#define GL_MESA_window_pos 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glWindowPos2dMESA (GLdouble, GLdouble);
+extern void glWindowPos2dvMESA (const GLdouble *);
+extern void glWindowPos2fMESA (GLfloat, GLfloat);
+extern void glWindowPos2fvMESA (const GLfloat *);
+extern void glWindowPos2iMESA (GLint, GLint);
+extern void glWindowPos2ivMESA (const GLint *);
+extern void glWindowPos2sMESA (GLshort, GLshort);
+extern void glWindowPos2svMESA (const GLshort *);
+extern void glWindowPos3dMESA (GLdouble, GLdouble, GLdouble);
+extern void glWindowPos3dvMESA (const GLdouble *);
+extern void glWindowPos3fMESA (GLfloat, GLfloat, GLfloat);
+extern void glWindowPos3fvMESA (const GLfloat *);
+extern void glWindowPos3iMESA (GLint, GLint, GLint);
+extern void glWindowPos3ivMESA (const GLint *);
+extern void glWindowPos3sMESA (GLshort, GLshort, GLshort);
+extern void glWindowPos3svMESA (const GLshort *);
+extern void glWindowPos4dMESA (GLdouble, GLdouble, GLdouble, GLdouble);
+extern void glWindowPos4dvMESA (const GLdouble *);
+extern void glWindowPos4fMESA (GLfloat, GLfloat, GLfloat, GLfloat);
+extern void glWindowPos4fvMESA (const GLfloat *);
+extern void glWindowPos4iMESA (GLint, GLint, GLint, GLint);
+extern void glWindowPos4ivMESA (const GLint *);
+extern void glWindowPos4sMESA (GLshort, GLshort, GLshort, GLshort);
+extern void glWindowPos4svMESA (const GLshort *);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_IBM_cull_vertex
+#define GL_IBM_cull_vertex 1
+#endif
+
+#ifndef GL_IBM_multimode_draw_arrays
+#define GL_IBM_multimode_draw_arrays 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glMultiModeDrawArraysIBM (GLenum, const GLint *, const GLsizei *, GLsizei, GLint);
+extern void glMultiModeDrawElementsIBM (const GLenum *, const GLsizei *, GLenum, const GLvoid* *, GLsizei, GLint);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_IBM_vertex_array_lists
+#define GL_IBM_vertex_array_lists 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glColorPointerListIBM (GLint, GLenum, GLint, const GLvoid* *, GLint);
+extern void glSecondaryColorPointerListIBM (GLint, GLenum, GLint, const GLvoid* *, GLint);
+extern void glEdgeFlagPointerListIBM (GLint, const GLboolean* *, GLint);
+extern void glFogCoordPointerListIBM (GLenum, GLint, const GLvoid* *, GLint);
+extern void glIndexPointerListIBM (GLenum, GLint, const GLvoid* *, GLint);
+extern void glNormalPointerListIBM (GLenum, GLint, const GLvoid* *, GLint);
+extern void glTexCoordPointerListIBM (GLint, GLenum, GLint, const GLvoid* *, GLint);
+extern void glVertexPointerListIBM (GLint, GLenum, GLint, const GLvoid* *, GLint);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_SGIX_subsample
+#define GL_SGIX_subsample 1
+#endif
+
+#ifndef GL_SGIX_ycrcba
+#define GL_SGIX_ycrcba 1
+#endif
+
+#ifndef GL_SGIX_ycrcb_subsample
+#define GL_SGIX_ycrcb_subsample 1
+#endif
+
+#ifndef GL_SGIX_depth_pass_instrument
+#define GL_SGIX_depth_pass_instrument 1
+#endif
+
+#ifndef GL_3DFX_texture_compression_FXT1
+#define GL_3DFX_texture_compression_FXT1 1
+#endif
+
+#ifndef GL_3DFX_multisample
+#define GL_3DFX_multisample 1
+#endif
+
+#ifndef GL_3DFX_tbuffer
+#define GL_3DFX_tbuffer 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glTbufferMask3DFX (GLuint);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_EXT_multisample
+#define GL_EXT_multisample 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glSampleMaskEXT (GLclampf, GLboolean);
+extern void glSamplePatternEXT (GLenum);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+#ifndef GL_SGI_vertex_preclip
+#define GL_SGI_vertex_preclip 1
+#endif
+
+#ifndef GL_SGIX_convolution_accuracy
+#define GL_SGIX_convolution_accuracy 1
+#endif
+
+#ifndef GL_SGIX_resample
+#define GL_SGIX_resample 1
+#endif
+
+#ifndef GL_SGIS_point_line_texgen
+#define GL_SGIS_point_line_texgen 1
+#endif
+
+#ifndef GL_SGIS_texture_color_mask
+#define GL_SGIS_texture_color_mask 1
+#ifdef GL_GLEXT_PROTOTYPES
+extern void glTextureColorMaskSGIS (GLboolean, GLboolean, GLboolean, GLboolean);
+#endif /* GL_GLEXT_PROTOTYPES */
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
diff --git a/codemp/renderer/matcomp.c b/codemp/renderer/matcomp.c
new file mode 100644
index 0000000..faa1efb
--- /dev/null
+++ b/codemp/renderer/matcomp.c
@@ -0,0 +1,293 @@
+#include "matcomp.h"
+#include <assert.h>
+#include <math.h>
+#include <stdio.h>
+#include <memory.h>	// for memcpy
+
+#define MC_MASK_X ((1<<(MC_BITS_X))-1)
+#define MC_MASK_Y ((1<<(MC_BITS_Y))-1)
+#define MC_MASK_Z ((1<<(MC_BITS_Z))-1)
+#define MC_MASK_VECT ((1<<(MC_BITS_VECT))-1)
+
+#define MC_SCALE_VECT (1.0f/(float)((1<<(MC_BITS_VECT-1))-2))
+
+#define MC_POS_X (0)
+#define MC_SHIFT_X (0)
+
+#define MC_POS_Y ((((MC_BITS_X))/8))
+#define MC_SHIFT_Y ((((MC_BITS_X)%8)))
+
+#define MC_POS_Z ((((MC_BITS_X+MC_BITS_Y))/8))
+#define MC_SHIFT_Z ((((MC_BITS_X+MC_BITS_Y)%8)))
+
+#define MC_POS_V11 ((((MC_BITS_X+MC_BITS_Y+MC_BITS_Z))/8))
+#define MC_SHIFT_V11 ((((MC_BITS_X+MC_BITS_Y+MC_BITS_Z)%8)))
+
+#define MC_POS_V12 ((((MC_BITS_X+MC_BITS_Y+MC_BITS_Z+MC_BITS_VECT))/8))
+#define MC_SHIFT_V12 ((((MC_BITS_X+MC_BITS_Y+MC_BITS_Z+MC_BITS_VECT)%8)))
+
+#define MC_POS_V13 ((((MC_BITS_X+MC_BITS_Y+MC_BITS_Z+MC_BITS_VECT*2))/8))
+#define MC_SHIFT_V13 ((((MC_BITS_X+MC_BITS_Y+MC_BITS_Z+MC_BITS_VECT*2)%8)))
+
+#define MC_POS_V21 ((((MC_BITS_X+MC_BITS_Y+MC_BITS_Z+MC_BITS_VECT*3))/8))
+#define MC_SHIFT_V21 ((((MC_BITS_X+MC_BITS_Y+MC_BITS_Z+MC_BITS_VECT*3)%8)))
+
+#define MC_POS_V22 ((((MC_BITS_X+MC_BITS_Y+MC_BITS_Z+MC_BITS_VECT*4))/8))
+#define MC_SHIFT_V22 ((((MC_BITS_X+MC_BITS_Y+MC_BITS_Z+MC_BITS_VECT*4)%8)))
+
+#define MC_POS_V23 ((((MC_BITS_X+MC_BITS_Y+MC_BITS_Z+MC_BITS_VECT*5))/8))
+#define MC_SHIFT_V23 ((((MC_BITS_X+MC_BITS_Y+MC_BITS_Z+MC_BITS_VECT*5)%8)))
+
+#define MC_POS_V31 ((((MC_BITS_X+MC_BITS_Y+MC_BITS_Z+MC_BITS_VECT*6))/8))
+#define MC_SHIFT_V31 ((((MC_BITS_X+MC_BITS_Y+MC_BITS_Z+MC_BITS_VECT*6)%8)))
+
+#define MC_POS_V32 ((((MC_BITS_X+MC_BITS_Y+MC_BITS_Z+MC_BITS_VECT*7))/8))
+#define MC_SHIFT_V32 ((((MC_BITS_X+MC_BITS_Y+MC_BITS_Z+MC_BITS_VECT*7)%8)))
+
+#define MC_POS_V33 ((((MC_BITS_X+MC_BITS_Y+MC_BITS_Z+MC_BITS_VECT*8))/8))
+#define MC_SHIFT_V33 ((((MC_BITS_X+MC_BITS_Y+MC_BITS_Z+MC_BITS_VECT*8)%8)))
+
+void MC_Compress(const float mat[3][4],unsigned char * _comp)
+{
+	char comp[MC_COMP_BYTES*2];
+
+	int i,val;
+	for (i=0;i<MC_COMP_BYTES;i++)
+		comp[i]=0;
+
+	val=(int)(mat[0][3]/MC_SCALE_X);
+	val+=1<<(MC_BITS_X-1);
+	if (val>=(1<<MC_BITS_X))
+		val=(1<<MC_BITS_X)-1;
+	if (val<0)
+		val=0;
+	*(unsigned int *)(comp+MC_POS_X)|=((unsigned int)(val))<<MC_SHIFT_X;
+
+	val=(int)(mat[1][3]/MC_SCALE_Y);
+	val+=1<<(MC_BITS_Y-1);
+	if (val>=(1<<MC_BITS_Y))
+		val=(1<<MC_BITS_Y)-1;
+	if (val<0)
+		val=0;
+	*(unsigned int *)(comp+MC_POS_Y)|=((unsigned int)(val))<<MC_SHIFT_Y;
+
+	val=(int)(mat[2][3]/MC_SCALE_Z);
+	val+=1<<(MC_BITS_Z-1);
+	if (val>=(1<<MC_BITS_Z))
+		val=(1<<MC_BITS_Z)-1;
+	if (val<0)
+		val=0;
+	*(unsigned int *)(comp+MC_POS_Z)|=((unsigned int)(val))<<MC_SHIFT_Z;
+
+
+	val=(int)(mat[0][0]/MC_SCALE_VECT);
+	val+=1<<(MC_BITS_VECT-1);
+	if (val>=(1<<MC_BITS_VECT))
+		val=(1<<MC_BITS_VECT)-1;
+	if (val<0)
+		val=0;
+	*(unsigned int *)(comp+MC_POS_V11)|=((unsigned int)(val))<<MC_SHIFT_V11;
+
+	val=(int)(mat[0][1]/MC_SCALE_VECT);
+	val+=1<<(MC_BITS_VECT-1);
+	if (val>=(1<<MC_BITS_VECT))
+		val=(1<<MC_BITS_VECT)-1;
+	if (val<0)
+		val=0;
+	*(unsigned int *)(comp+MC_POS_V12)|=((unsigned int)(val))<<MC_SHIFT_V12;
+
+	val=(int)(mat[0][2]/MC_SCALE_VECT);
+	val+=1<<(MC_BITS_VECT-1);
+	if (val>=(1<<MC_BITS_VECT))
+		val=(1<<MC_BITS_VECT)-1;
+	if (val<0)
+		val=0;
+	*(unsigned int *)(comp+MC_POS_V13)|=((unsigned int)(val))<<MC_SHIFT_V13;
+
+
+	val=(int)(mat[1][0]/MC_SCALE_VECT);
+	val+=1<<(MC_BITS_VECT-1);
+	if (val>=(1<<MC_BITS_VECT))
+		val=(1<<MC_BITS_VECT)-1;
+	if (val<0)
+		val=0;
+	*(unsigned int *)(comp+MC_POS_V21)|=((unsigned int)(val))<<MC_SHIFT_V21;
+
+	val=(int)(mat[1][1]/MC_SCALE_VECT);
+	val+=1<<(MC_BITS_VECT-1);
+	if (val>=(1<<MC_BITS_VECT))
+		val=(1<<MC_BITS_VECT)-1;
+	if (val<0)
+		val=0;
+	*(unsigned int *)(comp+MC_POS_V22)|=((unsigned int)(val))<<MC_SHIFT_V22;
+
+	val=(int)(mat[1][2]/MC_SCALE_VECT);
+	val+=1<<(MC_BITS_VECT-1);
+	if (val>=(1<<MC_BITS_VECT))
+		val=(1<<MC_BITS_VECT)-1;
+	if (val<0)
+		val=0;
+	*(unsigned int *)(comp+MC_POS_V23)|=((unsigned int)(val))<<MC_SHIFT_V23;
+
+	val=(int)(mat[2][0]/MC_SCALE_VECT);
+	val+=1<<(MC_BITS_VECT-1);
+	if (val>=(1<<MC_BITS_VECT))
+		val=(1<<MC_BITS_VECT)-1;
+	if (val<0)
+		val=0;
+	*(unsigned int *)(comp+MC_POS_V31)|=((unsigned int)(val))<<MC_SHIFT_V31;
+
+	val=(int)(mat[2][1]/MC_SCALE_VECT);
+	val+=1<<(MC_BITS_VECT-1);
+	if (val>=(1<<MC_BITS_VECT))
+		val=(1<<MC_BITS_VECT)-1;
+	if (val<0)
+		val=0;
+	*(unsigned int *)(comp+MC_POS_V32)|=((unsigned int)(val))<<MC_SHIFT_V32;
+
+	val=(int)(mat[2][2]/MC_SCALE_VECT);
+	val+=1<<(MC_BITS_VECT-1);
+	if (val>=(1<<MC_BITS_VECT))
+		val=(1<<MC_BITS_VECT)-1;
+	if (val<0)
+		val=0;
+	*(unsigned int *)(comp+MC_POS_V33)|=((unsigned int)(val))<<MC_SHIFT_V33;
+
+	// I added this because the line above actually ORs data into an int at the 22 byte (from 0), and therefore technically
+	//	is writing beyond the 24th byte of the output array. This *should** be harmless if the OR'd-in value doesn't change 
+	//	those bytes, but BoundsChecker says that it's accessing undefined memory (which it does, sometimes). This is probably
+	//	bad, so... 
+	memcpy(_comp,comp,MC_COMP_BYTES);
+}
+
+void MC_UnCompress(float mat[3][4],const unsigned char * comp)
+{
+	int val;
+
+	val=(int)((unsigned short *)(comp))[0];
+	val-=1<<(MC_BITS_X-1);
+	mat[0][3]=((float)(val))*MC_SCALE_X;
+
+	val=(int)((unsigned short *)(comp))[1];
+	val-=1<<(MC_BITS_Y-1);
+	mat[1][3]=((float)(val))*MC_SCALE_Y;
+
+	val=(int)((unsigned short *)(comp))[2];
+	val-=1<<(MC_BITS_Z-1);
+	mat[2][3]=((float)(val))*MC_SCALE_Z;
+
+	val=(int)((unsigned short *)(comp))[3];
+	val-=1<<(MC_BITS_VECT-1);
+	mat[0][0]=((float)(val))*MC_SCALE_VECT;
+
+	val=(int)((unsigned short *)(comp))[4];
+	val-=1<<(MC_BITS_VECT-1);
+	mat[0][1]=((float)(val))*MC_SCALE_VECT;
+
+	val=(int)((unsigned short *)(comp))[5];
+	val-=1<<(MC_BITS_VECT-1);
+	mat[0][2]=((float)(val))*MC_SCALE_VECT;
+
+
+	val=(int)((unsigned short *)(comp))[6];
+	val-=1<<(MC_BITS_VECT-1);
+	mat[1][0]=((float)(val))*MC_SCALE_VECT;
+
+	val=(int)((unsigned short *)(comp))[7];
+	val-=1<<(MC_BITS_VECT-1);
+	mat[1][1]=((float)(val))*MC_SCALE_VECT;
+
+	val=(int)((unsigned short *)(comp))[8];
+	val-=1<<(MC_BITS_VECT-1);
+	mat[1][2]=((float)(val))*MC_SCALE_VECT;
+
+
+	val=(int)((unsigned short *)(comp))[9];
+	val-=1<<(MC_BITS_VECT-1);
+	mat[2][0]=((float)(val))*MC_SCALE_VECT;
+
+	val=(int)((unsigned short *)(comp))[10];
+	val-=1<<(MC_BITS_VECT-1);
+	mat[2][1]=((float)(val))*MC_SCALE_VECT;
+
+	val=(int)((unsigned short *)(comp))[11];
+	val-=1<<(MC_BITS_VECT-1);
+	mat[2][2]=((float)(val))*MC_SCALE_VECT;
+
+}
+
+void MC_UnCompressQuat(float mat[3][4],const unsigned char * comp)
+{
+	float w,x,y,z,f;
+    float fTx;
+    float fTy;
+    float fTz;
+    float fTwx;
+    float fTwy;
+    float fTwz;
+    float fTxx;
+    float fTxy;
+    float fTxz;
+    float fTyy;
+    float fTyz;
+    float fTzz;
+	
+	const unsigned short *pwIn = (unsigned short *) comp;
+
+	w = *pwIn++;
+	w/=16383.0f;
+	w-=2.0f;
+	x = *pwIn++;
+	x/=16383.0f;
+	x-=2.0f;
+	y = *pwIn++;
+	y/=16383.0f;
+	y-=2.0f;
+	z = *pwIn++;
+	z/=16383.0f;
+	z-=2.0f;
+
+    fTx  = 2.0f*x;
+    fTy  = 2.0f*y;
+    fTz  = 2.0f*z;
+    fTwx = fTx*w;
+    fTwy = fTy*w;
+    fTwz = fTz*w;
+    fTxx = fTx*x;
+    fTxy = fTy*x;
+    fTxz = fTz*x;
+    fTyy = fTy*y;
+    fTyz = fTz*y;
+    fTzz = fTz*z;
+
+	// rot...
+	//
+    mat[0][0] = 1.0f-(fTyy+fTzz);
+    mat[0][1] = fTxy-fTwz;
+    mat[0][2] = fTxz+fTwy;
+    mat[1][0] = fTxy+fTwz;
+    mat[1][1] = 1.0f-(fTxx+fTzz);
+    mat[1][2] = fTyz-fTwx;
+    mat[2][0] = fTxz-fTwy;
+    mat[2][1] = fTyz+fTwx;
+    mat[2][2] = 1.0f-(fTxx+fTyy);
+
+	// xlat...
+	//
+	f = *pwIn++;
+	f/=64;
+	f-=512;
+	mat[0][3] = f;
+
+	f = *pwIn++;
+	f/=64;
+	f-=512;
+	mat[1][3] = f;
+
+	f = *pwIn++;
+	f/=64;
+	f-=512;
+	mat[2][3] = f;
+}
+
+
diff --git a/codemp/renderer/matcomp.h b/codemp/renderer/matcomp.h
new file mode 100644
index 0000000..9420c5d
--- /dev/null
+++ b/codemp/renderer/matcomp.h
@@ -0,0 +1,31 @@
+#ifndef __MATCOMP__
+#define __MATCOMP__
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#define MC_BITS_X (16)
+#define MC_BITS_Y (16)
+#define MC_BITS_Z (16)
+#define MC_BITS_VECT (16)
+
+#define MC_SCALE_X (1.0f/64)
+#define MC_SCALE_Y (1.0f/64)
+#define MC_SCALE_Z (1.0f/64)
+
+
+// currently 24 (.875)
+#define MC_COMP_BYTES (((MC_BITS_X+MC_BITS_Y+MC_BITS_Z+MC_BITS_VECT*9)+7)/8)
+
+void MC_Compress(const float mat[3][4],unsigned char * comp);
+void MC_UnCompress(float mat[3][4],const unsigned char * comp);
+void MC_UnCompressQuat(float mat[3][4],const unsigned char * comp);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/codemp/renderer/mdx_format.h b/codemp/renderer/mdx_format.h
new file mode 100644
index 0000000..e9f8e06
--- /dev/null
+++ b/codemp/renderer/mdx_format.h
@@ -0,0 +1,434 @@
+// Filename:-	mdx_format.h
+//
+// DO NOT UPDATE THIS FILE IN ANY WAY WHATSOEVER WITHOUT TELLING ME (-Ste),
+//	BECAUSE THE MASTER COPY IS IN A DIFFERENT SOURCESAFE DATABASE AND WILL 
+//	JUST GET PASTED OVER THIS ONE WHENEVER I CHANGE IT.
+//
+//
+//
+// MDX file format (typically uses file extension GLX for mesh, and GLA for anim/skeleton file)
+//
+// Notes:
+//	
+//	- All offset fields are relative to the address of the structure they occur in
+//	- So far, the only external symbol needed is MAX_QPATH, plus the typedefs for vec3_t, vec2_t etc
+
+#ifndef MDX_FORMAT_H
+#define MDX_FORMAT_H
+
+
+#define MDXM_IDENT			(('M'<<24)+('G'<<16)+('L'<<8)+'2')
+#define MDXA_IDENT			(('A'<<24)+('G'<<16)+('L'<<8)+'2')
+
+#define MAX_TAGNAME_BYTES	32	// matches MDR, can be changed if nec.
+
+//
+// normal version numbers...
+//
+#define MDXM_VERSION 6
+#define MDXA_VERSION 6
+
+// (Note that since there is now a "<modelname>_info.txt" file written out by carcass any changes made in here that
+//		introduce new data should also be reflected in the info-output)
+
+// 32 bit-flags for ghoul2 bone properties...  (all undefined fields will be blank)
+//
+#define G2BONEFLAG_ALWAYSXFORM	0x00000001
+
+// same thing but for surfaces...  (Carcass will only generate 1st 2 flags, others are ingame
+//
+#define G2SURFACEFLAG_ISBOLT		0x00000001
+#define G2SURFACEFLAG_OFF			0x00000002	// saves strcmp()ing for "_off" in surface names
+#define G2SURFACEFLAG_SPARE0		0x00000004	// future-expansion fields, saves invalidating models if we add more
+#define G2SURFACEFLAG_SPARE1		0x00000008	//   
+#define G2SURFACEFLAG_SPARE2		0x00000010	// 
+#define G2SURFACEFLAG_SPARE3		0x00000020	// 
+#define G2SURFACEFLAG_SPARE4		0x00000040	// 
+#define G2SURFACEFLAG_SPARE5		0x00000080	// 
+//
+#define G2SURFACEFLAG_NODESCENDANTS 0x00000100	// ingame-stuff, never generated by Carcass....
+#define G2SURFACEFLAG_GENERATED		0x00000200	//
+
+
+
+// triangle side-ordering stuff for tags...
+//
+#define iG2_TRISIDE_MIDDLE				1
+#define iG2_TRISIDE_LONGEST				0
+#define iG2_TRISIDE_SHORTEST			2
+
+#define fG2_BONEWEIGHT_RECIPROCAL_MULT	((float)(1.0f/1023.0f))
+#define iG2_BITS_PER_BONEREF			5
+#define iMAX_G2_BONEREFS_PER_SURFACE	(1<<iG2_BITS_PER_BONEREF)	// (32)
+#define iMAX_G2_BONEWEIGHTS_PER_VERT	4	// can't just be blindly increased, affects cache size etc
+
+#define iG2_BONEWEIGHT_TOPBITS_SHIFT	((iG2_BITS_PER_BONEREF * iMAX_G2_BONEWEIGHTS_PER_VERT) - 8)	// 8 bits because of 8 in the BoneWeight[] array entry
+#define iG2_BONEWEIGHT_TOPBITS_AND		0x300	// 2 bits, giving 10 total, or 10 bits, for 1023/1024 above
+
+
+#define sDEFAULT_GLA_NAME "*default"	// used when making special simple ghoul2 models, usually from MD3 files
+
+
+////////////////////////////////////
+//
+// these structs are defined here purely because of structure dependancy order...
+//
+/*
+#ifdef __cplusplus
+struct mdxmWeight_t
+#else
+typedef struct 
+#endif
+{
+	int			boneIndex;		// these are indexes into the surface boneReferences, not the global bone index
+	float		boneWeight;		// not the global per-frame bone list
+
+	// I'm defining this '<' operator so this struct can be used with an STL <set>...
+	// (note that I've defined it using '>' internally, so it sorts with higher weights being "less", for distance weight-culling
+	//
+	#ifdef __cplusplus
+	bool operator < (const mdxmWeight_t& _X) const {return (boneWeight>_X.boneWeight);}
+	#endif
+} 
+#ifndef __cplusplus
+mdxmWeight_t
+#endif
+;
+*/
+/*
+#ifdef __cplusplus
+struct mdxaCompBone_t
+#else
+typedef struct
+#endif
+{
+	unsigned char Comp[24];		// MC_COMP_BYTES is in MatComp.h, but don't want to couple	
+
+	// I'm defining this '<' operator so this struct can be used as an STL <map> key...
+	//
+	#ifdef __cplusplus
+	bool operator < (const mdxaCompBone_t& _X) const {return (memcmp(Comp,_X.Comp,sizeof(Comp))<0);}
+	#endif
+}
+#ifndef __cplusplus
+mdxaCompBone_t
+#endif
+;
+*/
+#ifdef __cplusplus
+struct mdxaCompQuatBone_t
+#else
+typedef struct
+#endif
+{
+	unsigned char Comp[14];
+
+	// I'm defining this '<' operator so this struct can be used as an STL <map> key...
+	//
+	#ifdef __cplusplus
+	bool operator < (const mdxaCompQuatBone_t& _X) const {return (memcmp(Comp,_X.Comp,sizeof(Comp))<0);}
+	#endif
+}
+#ifndef __cplusplus
+mdxaCompQuatBone_t
+#endif
+;
+
+
+#ifndef MDXABONEDEF
+typedef struct {
+	float matrix[3][4];			
+} mdxaBone_t;
+#endif
+
+////////////////////////////////////
+
+
+
+
+
+
+// mdxHeader_t  - this contains the header for the file, with sanity checking and version checking, plus number of lod's to be expected
+//
+typedef struct {
+	// 
+	// ( first 3 fields are same format as MD3/MDR so we can apply easy model-format-type checks )
+	//
+	int			ident;				// "IDP3" = MD3, "RDM5" = MDR, "2LGM"(GL2 Mesh) = MDX   (cruddy char order I know, but I'm following what was there in other versions)
+	int			version;			// 1,2,3 etc as per format revision
+	char		name[MAX_QPATH];	// model name (eg "models/players/marine.glm")	// note: extension supplied
+	char		animName[MAX_QPATH];// name of animation file this mesh requires	// note: extension missing
+	int			animIndex;			// filled in by game (carcass defaults it to 0)
+
+	int			numBones;			// (for ingame version-checks only, ensure we don't ref more bones than skel file has)
+
+	int			numLODs;
+	int			ofsLODs;
+
+	int			numSurfaces;		// now that surfaces are drawn hierarchically, we have same # per LOD
+	int			ofsSurfHierarchy;
+
+	int			ofsEnd;				// EOF, which of course gives overall file size
+} mdxmHeader_t;
+
+
+// for each surface (doesn't actually need a struct for this, just makes source clearer)
+// {
+		typedef struct
+		{
+			int offsets[1];		// variable sized (mdxmHeader_t->numSurfaces), each offset points to a mdxmSurfHierarchy_t below
+		} mdxmHierarchyOffsets_t;
+// }
+
+// for each surface...	(mdxmHeader_t->numSurfaces)
+// {
+		// mdxmSurfHierarchy_t - contains hierarchical info for surfaces...
+
+		typedef struct {
+			char		name[MAX_QPATH];
+			unsigned int flags;
+			char		shader[MAX_QPATH];
+			int			shaderIndex;		// for in-game use (carcass defaults to 0)
+			int			parentIndex;		// this points to the index in the file of the parent surface. -1 if null/root
+			int			numChildren;		// number of surfaces which are children of this one
+			int			childIndexes[1];	// [mdxmSurfHierarch_t->numChildren] (variable sized)
+		} mdxmSurfHierarchy_t;	// struct size = (int)( &((mdxmSurfHierarch_t *)0)->childIndexes[ mdxmSurfHierarch_t->numChildren ] );
+// }
+
+
+// for each LOD...  (mdxmHeader_t->numLODs)
+// {
+		// mdxLOD_t - this contains the header for this LOD. Contains num of surfaces, offset to surfaces and offset to next LOD. Surfaces are shader sorted, so each surface = 1 shader
+
+		typedef struct {
+			// (used to contain numSurface/ofsSurfaces fields, but these are same per LOD level now)
+			//
+			int			ofsEnd;				// offset to next LOD
+		} mdxmLOD_t;
+
+
+		typedef struct {	// added in GLM version 3 for ingame use at Jake's request
+			int offsets[1];		// variable sized (mdxmHeader_t->numSurfaces), each offset points to surfaces below
+		} mdxmLODSurfOffset_t;
+
+
+		// for each surface... (mdxmHeader_t->numSurfaces)
+		// {
+				// mdxSurface_t - reuse of header format containing surface name, number of bones, offset to poly data and number of polys, offset to vertex information, and number of verts. NOTE offsets are relative to this header.
+
+				typedef struct {
+					int			ident;				// this one field at least should be kept, since the game-engine may switch-case (but currently=0 in carcass)
+
+					int			thisSurfaceIndex;	// 0...mdxmHeader_t->numSurfaces-1 (because of how ingame renderer works)
+
+					int			ofsHeader;			// this will be a negative number, pointing back to main header
+
+					int			numVerts;
+					int			ofsVerts;
+
+					int			numTriangles;
+					int			ofsTriangles;
+
+					// Bone references are a set of ints representing all the bones
+					// present in any vertex weights for this surface.  This is
+					// needed because a model may have surfaces that need to be
+					// drawn at different sort times, and we don't want to have
+					// to re-interpolate all the bones for each surface.
+					//
+					int			numBoneReferences;
+					int			ofsBoneReferences;
+
+					int			ofsEnd;				// next surface follows
+
+				} mdxmSurface_t;
+
+
+				// for each triangle...	(mdxmSurface_t->numTriangles)
+				// {
+						// mdxTriangle_t - contains indexes into verts. One struct entry per poly.
+
+						typedef struct {
+							int			indexes[3];
+						} mdxmTriangle_t;
+				// }
+				
+
+				// for each vert... (mdxmSurface_t->numVerts)
+				// {
+						// mdxVertex_t - this is an array with number of verts from the surface definition as its bounds. It contains normal info, texture coors and number of weightings for this bone
+						// (this is now kept at 32 bytes for cache-aligning)
+						typedef struct {
+#ifdef _XBOX
+							//short			normal[3];
+							unsigned int	normal;
+							short			vertCoords[3];
+							unsigned int	tangent;
+#else
+							vec3_t			normal;
+							vec3_t			vertCoords;
+#endif
+
+							// packed int...
+							unsigned int	uiNmWeightsAndBoneIndexes;	// 32 bits.  format: 
+																		// 31 & 30:  0..3 (= 1..4) weight count
+																		// 29 & 28 (spare)
+																		//	2 bit pairs at 20,22,24,26 are 2-bit overflows from 4 BonWeights below (20=[0], 22=[1]) etc)
+																		//  5-bits each (iG2_BITS_PER_BONEREF) for boneweights
+							// effectively a packed int, each bone weight converted from 0..1 float to 0..255 int...
+							//  promote each entry to float and multiply by fG2_BONEWEIGHT_RECIPROCAL_MULT to convert.
+							byte			BoneWeightings[iMAX_G2_BONEWEIGHTS_PER_VERT];	// 4
+
+						} mdxmVertex_t;
+
+				// } vert
+
+#ifdef __cplusplus
+
+// these are convenience functions that I can invoked in code. Do NOT change them (because this is a shared file), 
+//	but if you want to copy the logic out and use your own versions then fine...
+//
+static inline int G2_GetVertWeights( const mdxmVertex_t *pVert )
+{
+	int iNumWeights = (pVert->uiNmWeightsAndBoneIndexes >> 30)+1;	// 1..4 count 
+
+	return iNumWeights;
+}
+
+static inline int G2_GetVertBoneIndex( const mdxmVertex_t *pVert, const int iWeightNum)
+{ 
+	int iBoneIndex = (pVert->uiNmWeightsAndBoneIndexes>>(iG2_BITS_PER_BONEREF*iWeightNum))&((1<<iG2_BITS_PER_BONEREF)-1);
+
+	return iBoneIndex;
+}
+
+static inline float G2_GetVertBoneWeight( const mdxmVertex_t *pVert, const int iWeightNum, float &fTotalWeight, int iNumWeights )
+{
+	float fBoneWeight;
+
+	if (iWeightNum == iNumWeights-1)
+	{
+		fBoneWeight = 1.0f-fTotalWeight;
+	}
+	else
+	{
+		int iTemp = pVert->BoneWeightings[iWeightNum];
+			iTemp|= (pVert->uiNmWeightsAndBoneIndexes >> (iG2_BONEWEIGHT_TOPBITS_SHIFT+(iWeightNum*2)) ) & iG2_BONEWEIGHT_TOPBITS_AND;
+
+		fBoneWeight = fG2_BONEWEIGHT_RECIPROCAL_MULT * iTemp;
+		fTotalWeight += fBoneWeight;
+	}
+
+	return fBoneWeight;
+}
+#endif															 
+				// for each vert... (mdxmSurface_t->numVerts)  (seperated from mdxmVertex_t struct for cache reasons)
+				// {
+						// mdxVertex_t - this is an array with number of verts from the surface definition as its bounds. It contains normal info, texture coors and number of weightings for this bone
+
+						typedef struct {
+#ifdef _XBOX
+							short			texCoords[2];
+#else
+							vec2_t			texCoords;
+#endif
+						} mdxmVertexTexCoord_t;
+
+				// } vert
+
+
+		// } surface
+// } LOD
+
+
+
+//----------------------------------------------------------------------------
+// seperate file here for animation data...
+//
+
+
+// mdxaHeader_t  - this contains the header for the file, with sanity checking and version checking, plus number of lod's to be expected
+//
+typedef struct {
+	// 
+	// ( first 3 fields are same format as MD3/MDR so we can apply easy model-format-type checks )
+	//
+	int			ident;				// 	"IDP3" = MD3, "RDM5" = MDR, "2LGA"(GL2 Anim) = MDXA
+	int			version;			// 1,2,3 etc as per format revision
+	//
+	char		name[MAX_QPATH];	// GLA name (eg "skeletons/marine")	// note: extension missing
+	float		fScale;				// will be zero if build before this field was defined, else scale it was built with
+
+	// frames and bones are shared by all levels of detail
+	//
+	int			numFrames;
+	int			ofsFrames;			// points at mdxaFrame_t array
+	int			numBones;			// (no offset to these since they're inside the frames array)
+	int			ofsCompBonePool;	// offset to global compressed-bone pool that all frames use
+	int			ofsSkel;			// offset to mdxaSkel_t info
+	
+	int			ofsEnd;				// EOF, which of course gives overall file size
+
+} mdxaHeader_t;
+
+
+// for each bone... (doesn't actually need a struct for this, just makes source clearer)
+// {
+		typedef struct
+		{
+			int offsets[1];		// variable sized (mdxaHeader_t->numBones), each offset points to an mdxaSkel_t below
+		} mdxaSkelOffsets_t;
+// }
+
+
+
+// for each bone...	 (mdxaHeader_t->numBones)       
+// {
+		// mdxaSkel_t - contains hierarchical info only...
+
+		typedef struct {
+			char		name[MAX_QPATH];	// name of bone
+			unsigned int flags;
+			int			parent;				// index of bone that is parent to this one, -1 = NULL/root
+			mdxaBone_t	BasePoseMat;		// base pose
+			mdxaBone_t	BasePoseMatInv;		// inverse, to save run-time calc
+			int			numChildren;		// number of children bones
+			int			children[1];		// [mdxaSkel_t->numChildren] (variable sized)
+		} mdxaSkel_t;	// struct size = (int)( &((mdxaSkel_t *)0)->children[ mdxaSkel_t->numChildren ] );
+// }
+
+
+	// (offset @ mdxaHeader_t->ofsFrames)
+	//
+	//  array of 3 byte indices here (hey, 25% saving over 4-byte really adds up)...
+	//
+	//
+	// access as follows to get the index for a given <iFrameNum, iBoneNum>
+	//
+	// (iFrameNum * mdxaHeader_t->numBones * 3) + (iBoneNum * 3)
+	//
+	//  then read the int at that location and AND it with 0x00FFFFFF. I use the struct below simply for easy searches
+	typedef struct
+	{
+		int iIndex;	// this struct for pointing purposes, need to and with 0x00FFFFFF to be meaningful
+	} mdxaIndex_t;
+	//
+	// (note that there's then an alignement-pad here to get the next struct back onto 32-bit alignement)
+	//
+	// this index then points into the following...
+
+
+// Compressed-bone pool that all frames use  (mdxaHeader_t->ofsCompBonePool)  (defined at end because size unknown until end)
+// for each bone in pool (unknown number, no actual total stored at the moment)... 
+// {
+		// mdxaCompBone_t  (defined at file top because of struct dependancy)
+// }
+
+//---------------------------------------------------------------------------
+
+
+#endif	// #ifndef MDX_FORMAT_H
+
+//////////////////////// eof ///////////////////////
+
+
+
diff --git a/codemp/renderer/qgl.h b/codemp/renderer/qgl.h
new file mode 100644
index 0000000..8214b73
--- /dev/null
+++ b/codemp/renderer/qgl.h
@@ -0,0 +1,757 @@
+/*
+** QGL.H
+*/
+
+#ifndef __QGL_H__
+#define __QGL_H__
+
+#if defined( __LINT__ )
+
+#include <GL/gl.h>
+
+#elif defined( _WIN32 )
+
+#pragma warning (disable: 4201)
+#pragma warning (disable: 4214)
+#pragma warning (disable: 4514)
+#pragma warning (disable: 4032)
+#pragma warning (disable: 4201)
+#pragma warning (disable: 4214)
+#include <windows.h>
+#include <gl/gl.h>
+
+#elif defined(MACOS_X)
+
+#include "macosx_glimp.h"
+
+#elif defined( __linux__ )
+
+#include <GL/gl.h>
+#include <GL/glx.h>
+// bk001129 - from cvs1.17 (mkv)
+#if defined(__FX__)
+#include <GL/fxmesa.h>
+#endif
+
+#elif defined( __FreeBSD__ ) // rb010123
+
+#include <GL/gl.h>
+#include <GL/glx.h>
+#if defined(__FX__)
+#include <GL/fxmesa.h>
+#endif
+
+#else
+
+#include <gl.h>
+
+#endif
+
+#ifndef APIENTRY
+#define APIENTRY
+#endif
+#ifndef WINAPI
+#define WINAPI
+#endif
+
+
+//===========================================================================
+
+/*
+** multitexture extension definitions
+*/
+#define GL_ACTIVE_TEXTURE_ARB               0x84E0
+#define GL_CLIENT_ACTIVE_TEXTURE_ARB        0x84E1
+#define GL_MAX_ACTIVE_TEXTURES_ARB          0x84E2
+
+#define GL_TEXTURE0_ARB                     0x84C0
+#define GL_TEXTURE1_ARB                     0x84C1
+#define GL_TEXTURE2_ARB                     0x84C2
+#define GL_TEXTURE3_ARB                     0x84C3
+
+#define GL_TEXTURE_RECTANGLE_EXT						0x84F5
+
+// TTimo: FIXME
+// linux needs those prototypes
+// GL_VERSION_1_2 is defined after #include <gl.h>
+#if !defined(GL_VERSION_1_2) || defined(__linux__)
+typedef void (APIENTRY * PFNGLMULTITEXCOORD1DARBPROC) (GLenum target, GLdouble s);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD1DVARBPROC) (GLenum target, const GLdouble *v);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD1FARBPROC) (GLenum target, GLfloat s);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD1FVARBPROC) (GLenum target, const GLfloat *v);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD1IARBPROC) (GLenum target, GLint s);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD1IVARBPROC) (GLenum target, const GLint *v);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD1SARBPROC) (GLenum target, GLshort s);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD1SVARBPROC) (GLenum target, const GLshort *v);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD2DARBPROC) (GLenum target, GLdouble s, GLdouble t);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD2DVARBPROC) (GLenum target, const GLdouble *v);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD2FARBPROC) (GLenum target, GLfloat s, GLfloat t);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD2FVARBPROC) (GLenum target, const GLfloat *v);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD2IARBPROC) (GLenum target, GLint s, GLint t);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD2IVARBPROC) (GLenum target, const GLint *v);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD2SARBPROC) (GLenum target, GLshort s, GLshort t);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD2SVARBPROC) (GLenum target, const GLshort *v);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD3DARBPROC) (GLenum target, GLdouble s, GLdouble t, GLdouble r);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD3DVARBPROC) (GLenum target, const GLdouble *v);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD3FARBPROC) (GLenum target, GLfloat s, GLfloat t, GLfloat r);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD3FVARBPROC) (GLenum target, const GLfloat *v);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD3IARBPROC) (GLenum target, GLint s, GLint t, GLint r);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD3IVARBPROC) (GLenum target, const GLint *v);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD3SARBPROC) (GLenum target, GLshort s, GLshort t, GLshort r);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD3SVARBPROC) (GLenum target, const GLshort *v);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD4DARBPROC) (GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD4DVARBPROC) (GLenum target, const GLdouble *v);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD4FARBPROC) (GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD4FVARBPROC) (GLenum target, const GLfloat *v);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD4IARBPROC) (GLenum target, GLint s, GLint t, GLint r, GLint q);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD4IVARBPROC) (GLenum target, const GLint *v);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD4SARBPROC) (GLenum target, GLshort s, GLshort t, GLshort r, GLshort q);
+typedef void (APIENTRY * PFNGLMULTITEXCOORD4SVARBPROC) (GLenum target, const GLshort *v);
+typedef void (APIENTRY * PFNGLACTIVETEXTUREARBPROC) (GLenum target);
+typedef void (APIENTRY * PFNGLCLIENTACTIVETEXTUREARBPROC) (GLenum target);
+#endif
+
+
+// Steps to adding a new extension:
+//	- Add the typedef and function pointer externs here.
+//	- Define the function pointer in tr_init.cpp and possibly add a cvar to track your ext status.
+//	- Load the extension in win_glimp.cpp.
+
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// Register Combiner extension definitions. - AReis
+/***********************************************************************************************************/
+// NOTE: These are obviously not all the regcom flags. I'm only including the ones I use (to reduce code clutter), so
+// if you need any of the other flags, just add them.
+#define GL_REGISTER_COMBINERS_NV			0x8522
+#define GL_COMBINER0_NV						0x8550
+#define GL_COMBINER1_NV						0x8551
+#define GL_COMBINER2_NV						0x8552
+#define GL_COMBINER3_NV						0x8553
+#define GL_COMBINER4_NV						0x8554
+#define GL_COMBINER5_NV						0x8555
+#define GL_COMBINER6_NV						0x8556
+#define GL_COMBINER7_NV						0x8557
+#define GL_NUM_GENERAL_COMBINERS_NV			0x854E
+#define GL_VARIABLE_A_NV					0x8523
+#define GL_VARIABLE_B_NV					0x8524
+#define GL_VARIABLE_C_NV					0x8525
+#define GL_VARIABLE_D_NV					0x8526
+#define GL_VARIABLE_E_NV					0x8527
+#define GL_VARIABLE_F_NV					0x8528
+#define GL_VARIABLE_G_NV					0x8529
+#define GL_DISCARD_NV						0x8530
+#define GL_CONSTANT_COLOR0_NV				0x852A
+#define GL_CONSTANT_COLOR1_NV				0x852B
+#define GL_SPARE0_NV						0x852E
+#define GL_SPARE1_NV						0x852F
+#define GL_UNSIGNED_IDENTITY_NV				0x8536
+#define GL_UNSIGNED_INVERT_NV				0x8537
+
+typedef void (APIENTRY *PFNGLCOMBINERPARAMETERFVNV) (GLenum pname,const GLfloat *params);
+typedef void (APIENTRY *PFNGLCOMBINERPARAMETERIVNV) (GLenum pname,const GLint *params);
+typedef void (APIENTRY *PFNGLCOMBINERPARAMETERFNV) (GLenum pname,GLfloat param);
+typedef void (APIENTRY *PFNGLCOMBINERPARAMETERINV) (GLenum pname,GLint param);
+typedef void (APIENTRY *PFNGLCOMBINERINPUTNV) (GLenum stage,GLenum portion,GLenum variable,GLenum input,GLenum mapping,
+											   GLenum componentUsage);
+typedef void (APIENTRY *PFNGLCOMBINEROUTPUTNV) (GLenum stage,GLenum portion,GLenum abOutput,GLenum cdOutput,GLenum sumOutput,
+												GLenum scale, GLenum bias,GLboolean abDotProduct,GLboolean cdDotProduct,
+												GLboolean muxSum);
+typedef void (APIENTRY *PFNGLFINALCOMBINERINPUTNV) (GLenum variable,GLenum input,GLenum mapping,GLenum componentUsage);
+
+typedef void (APIENTRY *PFNGLGETCOMBINERINPUTPARAMETERFVNV) (GLenum stage,GLenum portion,GLenum variable,GLenum pname,GLfloat *params);
+typedef void (APIENTRY *PFNGLGETCOMBINERINPUTPARAMETERIVNV) (GLenum stage,GLenum portion,GLenum variable,GLenum pname,GLint *params);
+typedef void (APIENTRY *PFNGLGETCOMBINEROUTPUTPARAMETERFVNV) (GLenum stage,GLenum portion,GLenum pname,GLfloat *params);
+typedef void (APIENTRY *PFNGLGETCOMBINEROUTPUTPARAMETERIVNV) (GLenum stage,GLenum portion,GLenum pname,GLint *params);
+typedef void (APIENTRY *PFNGLGETFINALCOMBINERINPUTPARAMETERFVNV) (GLenum variable,GLenum pname,GLfloat *params);
+typedef void (APIENTRY *PFNGLGETFINALCOMBINERINPUTPARAMETERIVNV) (GLenum variable,GLenum pname,GLfloat *params);
+/***********************************************************************************************************/
+
+// Declare Register Combiners function pointers.
+extern PFNGLCOMBINERPARAMETERFVNV				qglCombinerParameterfvNV;
+extern PFNGLCOMBINERPARAMETERIVNV				qglCombinerParameterivNV;
+extern PFNGLCOMBINERPARAMETERFNV				qglCombinerParameterfNV;
+extern PFNGLCOMBINERPARAMETERINV				qglCombinerParameteriNV;
+extern PFNGLCOMBINERINPUTNV						qglCombinerInputNV;
+extern PFNGLCOMBINEROUTPUTNV					qglCombinerOutputNV;
+extern PFNGLFINALCOMBINERINPUTNV				qglFinalCombinerInputNV;
+extern PFNGLGETCOMBINERINPUTPARAMETERFVNV		qglGetCombinerInputParameterfvNV;
+extern PFNGLGETCOMBINERINPUTPARAMETERIVNV		qglGetCombinerInputParameterivNV;
+extern PFNGLGETCOMBINEROUTPUTPARAMETERFVNV		qglGetCombinerOutputParameterfvNV;
+extern PFNGLGETCOMBINEROUTPUTPARAMETERIVNV		qglGetCombinerOutputParameterivNV;
+extern PFNGLGETFINALCOMBINERINPUTPARAMETERFVNV	qglGetFinalCombinerInputParameterfvNV;
+extern PFNGLGETFINALCOMBINERINPUTPARAMETERIVNV	qglGetFinalCombinerInputParameterivNV;
+
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// Pixel Format extension definitions. - AReis
+/***********************************************************************************************************/
+#define WGL_COLOR_BITS_ARB             0x2014
+#define WGL_ALPHA_BITS_ARB             0x201B
+#define WGL_DEPTH_BITS_ARB             0x2022
+#define WGL_STENCIL_BITS_ARB           0x2023
+
+typedef BOOL (WINAPI * PFNWGLGETPIXELFORMATATTRIBIVARBPROC) (HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, const int *piAttributes, int *piValues);
+typedef BOOL (WINAPI * PFNWGLGETPIXELFORMATATTRIBFVARBPROC) (HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, const int *piAttributes, FLOAT *pfValues);
+typedef BOOL (WINAPI * PFNWGLCHOOSEPIXELFORMATARBPROC) (HDC hdc, const int *piAttribIList, const FLOAT *pfAttribFList, UINT nMaxFormats, int *piFormats, UINT *nNumFormats);
+/***********************************************************************************************************/
+
+// Declare Pixel Format function pointers.
+extern PFNWGLGETPIXELFORMATATTRIBIVARBPROC		qwglGetPixelFormatAttribivARB;
+extern PFNWGLGETPIXELFORMATATTRIBFVARBPROC		qwglGetPixelFormatAttribfvARB;
+extern PFNWGLCHOOSEPIXELFORMATARBPROC			qwglChoosePixelFormatARB;
+
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// Pixel Buffer extension definitions. - AReis
+/***********************************************************************************************************/
+DECLARE_HANDLE(HPBUFFERARB);
+
+#define WGL_SUPPORT_OPENGL_ARB         0x2010
+#define WGL_DOUBLE_BUFFER_ARB          0x2011
+#define WGL_DRAW_TO_PBUFFER_ARB        0x202D
+#define WGL_PBUFFER_WIDTH_ARB          0x2034
+#define WGL_PBUFFER_HEIGHT_ARB         0x2035
+#define WGL_RED_BITS_ARB               0x2015
+#define WGL_GREEN_BITS_ARB             0x2017
+#define WGL_BLUE_BITS_ARB              0x2019
+
+typedef HPBUFFERARB (WINAPI * PFNWGLCREATEPBUFFERARBPROC) (HDC hDC, int iPixelFormat, int iWidth, int iHeight, const int *piAttribList);
+typedef HDC (WINAPI * PFNWGLGETPBUFFERDCARBPROC) (HPBUFFERARB hPbuffer);
+typedef int (WINAPI * PFNWGLRELEASEPBUFFERDCARBPROC) (HPBUFFERARB hPbuffer, HDC hDC);
+typedef BOOL (WINAPI * PFNWGLDESTROYPBUFFERARBPROC) (HPBUFFERARB hPbuffer);
+typedef BOOL (WINAPI * PFNWGLQUERYPBUFFERARBPROC) (HPBUFFERARB hPbuffer, int iAttribute, int *piValue);
+/***********************************************************************************************************/
+
+// Declare Pixel Buffer function pointers.
+extern PFNWGLCREATEPBUFFERARBPROC				qwglCreatePbufferARB;
+extern PFNWGLGETPBUFFERDCARBPROC				qwglGetPbufferDCARB;
+extern PFNWGLRELEASEPBUFFERDCARBPROC			qwglReleasePbufferDCARB;
+extern PFNWGLDESTROYPBUFFERARBPROC				qwglDestroyPbufferARB;
+extern PFNWGLQUERYPBUFFERARBPROC				qwglQueryPbufferARB;
+
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// Render-Texture extension definitions. - AReis
+/***********************************************************************************************************/
+#define WGL_BIND_TO_TEXTURE_RGBA_ARB       0x2071
+#define WGL_TEXTURE_FORMAT_ARB             0x2072
+#define WGL_TEXTURE_TARGET_ARB             0x2073
+#define WGL_TEXTURE_RGB_ARB                0x2075
+#define WGL_TEXTURE_RGBA_ARB               0x2076
+#define WGL_TEXTURE_2D_ARB                 0x207A
+#define WGL_FRONT_LEFT_ARB                 0x2083
+
+typedef BOOL (WINAPI * PFNWGLBINDTEXIMAGEARBPROC) (HPBUFFERARB hPbuffer, int iBuffer);
+typedef BOOL (WINAPI * PFNWGLRELEASETEXIMAGEARBPROC) (HPBUFFERARB hPbuffer, int iBuffer);
+typedef BOOL (WINAPI * PFNWGLSETPBUFFERATTRIBARBPROC) (HPBUFFERARB hPbuffer, const int * piAttribList);
+/***********************************************************************************************************/
+
+// Declare Render-Texture function pointers.
+extern PFNWGLBINDTEXIMAGEARBPROC			qwglBindTexImageARB;
+extern PFNWGLRELEASETEXIMAGEARBPROC			qwglReleaseTexImageARB;
+extern PFNWGLSETPBUFFERATTRIBARBPROC		qwglSetPbufferAttribARB;
+
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// Vertex and Fragment Program extension definitions. - AReis
+/***********************************************************************************************************/
+#ifndef GL_ARB_fragment_program
+#define GL_FRAGMENT_PROGRAM_ARB           0x8804
+#define GL_PROGRAM_ALU_INSTRUCTIONS_ARB   0x8805
+#define GL_PROGRAM_TEX_INSTRUCTIONS_ARB   0x8806
+#define GL_PROGRAM_TEX_INDIRECTIONS_ARB   0x8807
+#define GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB 0x8808
+#define GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB 0x8809
+#define GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB 0x880A
+#define GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB 0x880B
+#define GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB 0x880C
+#define GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB 0x880D
+#define GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB 0x880E
+#define GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB 0x880F
+#define GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB 0x8810
+#define GL_MAX_TEXTURE_COORDS_ARB         0x8871
+#define GL_MAX_TEXTURE_IMAGE_UNITS_ARB    0x8872
+#endif
+
+// NOTE: These are obviously not all the vertex program flags (have you seen how many there actually are!). I'm
+// only including the ones I use (to reduce code clutter), so if you need any of the other flags, just add them.
+#define GL_VERTEX_PROGRAM_ARB                       0x8620
+#define GL_PROGRAM_FORMAT_ASCII_ARB                 0x8875
+
+typedef void (APIENTRY * PFNGLPROGRAMSTRINGARBPROC) (GLenum target, GLenum format, GLsizei len, const GLvoid *string); 
+typedef void (APIENTRY * PFNGLBINDPROGRAMARBPROC) (GLenum target, GLuint program);
+typedef void (APIENTRY * PFNGLDELETEPROGRAMSARBPROC) (GLsizei n, const GLuint *programs);
+typedef void (APIENTRY * PFNGLGENPROGRAMSARBPROC) (GLsizei n, GLuint *programs);
+typedef void (APIENTRY * PFNGLPROGRAMENVPARAMETER4DARBPROC) (GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+typedef void (APIENTRY * PFNGLPROGRAMENVPARAMETER4DVARBPROC) (GLenum target, GLuint index, const GLdouble *params);
+typedef void (APIENTRY * PFNGLPROGRAMENVPARAMETER4FARBPROC) (GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+typedef void (APIENTRY * PFNGLPROGRAMENVPARAMETER4FVARBPROC) (GLenum target, GLuint index, const GLfloat *params);
+typedef void (APIENTRY * PFNGLPROGRAMLOCALPARAMETER4DARBPROC) (GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+typedef void (APIENTRY * PFNGLPROGRAMLOCALPARAMETER4DVARBPROC) (GLenum target, GLuint index, const GLdouble *params);
+typedef void (APIENTRY * PFNGLPROGRAMLOCALPARAMETER4FARBPROC) (GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+typedef void (APIENTRY * PFNGLPROGRAMLOCALPARAMETER4FVARBPROC) (GLenum target, GLuint index, const GLfloat *params);
+typedef void (APIENTRY * PFNGLGETPROGRAMENVPARAMETERDVARBPROC) (GLenum target, GLuint index, GLdouble *params);
+typedef void (APIENTRY * PFNGLGETPROGRAMENVPARAMETERFVARBPROC) (GLenum target, GLuint index, GLfloat *params);
+typedef void (APIENTRY * PFNGLGETPROGRAMLOCALPARAMETERDVARBPROC) (GLenum target, GLuint index, GLdouble *params);
+typedef void (APIENTRY * PFNGLGETPROGRAMLOCALPARAMETERFVARBPROC) (GLenum target, GLuint index, GLfloat *params);
+typedef void (APIENTRY * PFNGLGETPROGRAMIVARBPROC) (GLenum target, GLenum pname, GLint *params);
+typedef void (APIENTRY * PFNGLGETPROGRAMSTRINGARBPROC) (GLenum target, GLenum pname, GLvoid *string);
+typedef GLboolean (APIENTRY * PFNGLISPROGRAMARBPROC) (GLuint program);
+/***********************************************************************************************************/
+
+// Declare Vertex and Fragment Program function pointers.
+extern PFNGLPROGRAMSTRINGARBPROC qglProgramStringARB;
+extern PFNGLBINDPROGRAMARBPROC qglBindProgramARB;
+extern PFNGLDELETEPROGRAMSARBPROC qglDeleteProgramsARB;
+extern PFNGLGENPROGRAMSARBPROC qglGenProgramsARB;
+extern PFNGLPROGRAMENVPARAMETER4DARBPROC qglProgramEnvParameter4dARB;
+extern PFNGLPROGRAMENVPARAMETER4DVARBPROC qglProgramEnvParameter4dvARB;
+extern PFNGLPROGRAMENVPARAMETER4FARBPROC qglProgramEnvParameter4fARB;
+extern PFNGLPROGRAMENVPARAMETER4FVARBPROC qglProgramEnvParameter4fvARB;
+extern PFNGLPROGRAMLOCALPARAMETER4DARBPROC qglProgramLocalParameter4dARB;
+extern PFNGLPROGRAMLOCALPARAMETER4DVARBPROC qglProgramLocalParameter4dvARB;
+extern PFNGLPROGRAMLOCALPARAMETER4FARBPROC qglProgramLocalParameter4fARB;
+extern PFNGLPROGRAMLOCALPARAMETER4FVARBPROC qglProgramLocalParameter4fvARB;
+extern PFNGLGETPROGRAMENVPARAMETERDVARBPROC qglGetProgramEnvParameterdvARB;
+extern PFNGLGETPROGRAMENVPARAMETERFVARBPROC qglGetProgramEnvParameterfvARB;
+extern PFNGLGETPROGRAMLOCALPARAMETERDVARBPROC qglGetProgramLocalParameterdvARB;
+extern PFNGLGETPROGRAMLOCALPARAMETERFVARBPROC qglGetProgramLocalParameterfvARB;
+extern PFNGLGETPROGRAMIVARBPROC qglGetProgramivARB;
+extern PFNGLGETPROGRAMSTRINGARBPROC qglGetProgramStringARB;
+extern PFNGLISPROGRAMARBPROC qglIsProgramARB;
+
+
+/*
+** extension constants
+*/
+
+
+// S3TC compression constants
+#define GL_RGB_S3TC							0x83A0
+#define GL_RGB4_S3TC						0x83A1
+
+
+// extensions will be function pointers on all platforms
+
+extern	void ( APIENTRY * qglMultiTexCoord2fARB )( GLenum texture, GLfloat s, GLfloat t );
+extern	void ( APIENTRY * qglActiveTextureARB )( GLenum texture );
+extern	void ( APIENTRY * qglClientActiveTextureARB )( GLenum texture );
+
+extern	void ( APIENTRY * qglLockArraysEXT) (GLint, GLint);
+extern	void ( APIENTRY * qglUnlockArraysEXT) (void);
+
+extern	void ( APIENTRY * qglPointParameterfEXT)( GLenum, GLfloat);
+extern	void ( APIENTRY * qglPointParameterfvEXT)( GLenum, GLfloat *);
+
+//3d textures -rww
+extern	void ( APIENTRY * qglTexImage3DEXT) (GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *);
+extern	void ( APIENTRY * qglTexSubImage3DEXT) (GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *);
+
+//===========================================================================
+
+// non-windows systems will just redefine qgl* to gl*
+#if !defined( _WIN32 ) && !defined(MACOS_X) && !defined( __linux__ ) && !defined( __FreeBSD__ ) // rb010123
+
+#include "qgl_linked.h"
+
+#elif defined(MACOS_X)
+// This includes #ifdefs for optional logging and GL error checking after every GL call as well as #defines to prevent incorrect usage of the non-'qgl' versions of the GL API.
+#include "macosx_qgl.h"
+
+#else
+
+// windows systems use a function pointer for each call so we can load minidrivers
+
+extern  void ( APIENTRY * qglAccum )(GLenum op, GLfloat value);
+extern  void ( APIENTRY * qglAlphaFunc )(GLenum func, GLclampf ref);
+extern  GLboolean ( APIENTRY * qglAreTexturesResident )(GLsizei n, const GLuint *textures, GLboolean *residences);
+extern  void ( APIENTRY * qglArrayElement )(GLint i);
+extern  void ( APIENTRY * qglBegin )(GLenum mode);
+extern  void ( APIENTRY * qglBindTexture )(GLenum target, GLuint texture);
+extern  void ( APIENTRY * qglBitmap )(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap);
+extern  void ( APIENTRY * qglBlendFunc )(GLenum sfactor, GLenum dfactor);
+extern  void ( APIENTRY * qglCallList )(GLuint list);
+extern  void ( APIENTRY * qglCallLists )(GLsizei n, GLenum type, const GLvoid *lists);
+extern  void ( APIENTRY * qglClear )(GLbitfield mask);
+extern  void ( APIENTRY * qglClearAccum )(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
+extern  void ( APIENTRY * qglClearColor )(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
+extern  void ( APIENTRY * qglClearDepth )(GLclampd depth);
+extern  void ( APIENTRY * qglClearIndex )(GLfloat c);
+extern  void ( APIENTRY * qglClearStencil )(GLint s);
+extern  void ( APIENTRY * qglClipPlane )(GLenum plane, const GLdouble *equation);
+extern  void ( APIENTRY * qglColor3b )(GLbyte red, GLbyte green, GLbyte blue);
+extern  void ( APIENTRY * qglColor3bv )(const GLbyte *v);
+extern  void ( APIENTRY * qglColor3d )(GLdouble red, GLdouble green, GLdouble blue);
+extern  void ( APIENTRY * qglColor3dv )(const GLdouble *v);
+extern  void ( APIENTRY * qglColor3f )(GLfloat red, GLfloat green, GLfloat blue);
+extern  void ( APIENTRY * qglColor3fv )(const GLfloat *v);
+extern  void ( APIENTRY * qglColor3i )(GLint red, GLint green, GLint blue);
+extern  void ( APIENTRY * qglColor3iv )(const GLint *v);
+extern  void ( APIENTRY * qglColor3s )(GLshort red, GLshort green, GLshort blue);
+extern  void ( APIENTRY * qglColor3sv )(const GLshort *v);
+extern  void ( APIENTRY * qglColor3ub )(GLubyte red, GLubyte green, GLubyte blue);
+extern  void ( APIENTRY * qglColor3ubv )(const GLubyte *v);
+extern  void ( APIENTRY * qglColor3ui )(GLuint red, GLuint green, GLuint blue);
+extern  void ( APIENTRY * qglColor3uiv )(const GLuint *v);
+extern  void ( APIENTRY * qglColor3us )(GLushort red, GLushort green, GLushort blue);
+extern  void ( APIENTRY * qglColor3usv )(const GLushort *v);
+extern  void ( APIENTRY * qglColor4b )(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha);
+extern  void ( APIENTRY * qglColor4bv )(const GLbyte *v);
+extern  void ( APIENTRY * qglColor4d )(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha);
+extern  void ( APIENTRY * qglColor4dv )(const GLdouble *v);
+extern  void ( APIENTRY * qglColor4f )(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
+extern  void ( APIENTRY * qglColor4fv )(const GLfloat *v);
+extern  void ( APIENTRY * qglColor4i )(GLint red, GLint green, GLint blue, GLint alpha);
+extern  void ( APIENTRY * qglColor4iv )(const GLint *v);
+extern  void ( APIENTRY * qglColor4s )(GLshort red, GLshort green, GLshort blue, GLshort alpha);
+extern  void ( APIENTRY * qglColor4sv )(const GLshort *v);
+extern  void ( APIENTRY * qglColor4ub )(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha);
+extern  void ( APIENTRY * qglColor4ubv )(const GLubyte *v);
+extern  void ( APIENTRY * qglColor4ui )(GLuint red, GLuint green, GLuint blue, GLuint alpha);
+extern  void ( APIENTRY * qglColor4uiv )(const GLuint *v);
+extern  void ( APIENTRY * qglColor4us )(GLushort red, GLushort green, GLushort blue, GLushort alpha);
+extern  void ( APIENTRY * qglColor4usv )(const GLushort *v);
+extern  void ( APIENTRY * qglColorMask )(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
+extern  void ( APIENTRY * qglColorMaterial )(GLenum face, GLenum mode);
+extern  void ( APIENTRY * qglColorPointer )(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
+extern  void ( APIENTRY * qglCopyPixels )(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type);
+extern  void ( APIENTRY * qglCopyTexImage1D )(GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border);
+extern  void ( APIENTRY * qglCopyTexImage2D )(GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
+extern  void ( APIENTRY * qglCopyTexSubImage1D )(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);
+extern  void ( APIENTRY * qglCopyTexSubImage2D )(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
+extern  void ( APIENTRY * qglCullFace )(GLenum mode);
+extern  void ( APIENTRY * qglDeleteLists )(GLuint list, GLsizei range);
+extern  void ( APIENTRY * qglDeleteTextures )(GLsizei n, const GLuint *textures);
+extern  void ( APIENTRY * qglDepthFunc )(GLenum func);
+extern  void ( APIENTRY * qglDepthMask )(GLboolean flag);
+extern  void ( APIENTRY * qglDepthRange )(GLclampd zNear, GLclampd zFar);
+extern  void ( APIENTRY * qglDisable )(GLenum cap);
+extern  void ( APIENTRY * qglDisableClientState )(GLenum array);
+extern  void ( APIENTRY * qglDrawArrays )(GLenum mode, GLint first, GLsizei count);
+extern  void ( APIENTRY * qglDrawBuffer )(GLenum mode);
+extern  void ( APIENTRY * qglDrawElements )(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices);
+extern  void ( APIENTRY * qglDrawPixels )(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
+extern  void ( APIENTRY * qglEdgeFlag )(GLboolean flag);
+extern  void ( APIENTRY * qglEdgeFlagPointer )(GLsizei stride, const GLvoid *pointer);
+extern  void ( APIENTRY * qglEdgeFlagv )(const GLboolean *flag);
+extern  void ( APIENTRY * qglEnable )(GLenum cap);
+extern  void ( APIENTRY * qglEnableClientState )(GLenum array);
+extern  void ( APIENTRY * qglEnd )(void);
+extern  void ( APIENTRY * qglEndList )(void);
+extern  void ( APIENTRY * qglEvalCoord1d )(GLdouble u);
+extern  void ( APIENTRY * qglEvalCoord1dv )(const GLdouble *u);
+extern  void ( APIENTRY * qglEvalCoord1f )(GLfloat u);
+extern  void ( APIENTRY * qglEvalCoord1fv )(const GLfloat *u);
+extern  void ( APIENTRY * qglEvalCoord2d )(GLdouble u, GLdouble v);
+extern  void ( APIENTRY * qglEvalCoord2dv )(const GLdouble *u);
+extern  void ( APIENTRY * qglEvalCoord2f )(GLfloat u, GLfloat v);
+extern  void ( APIENTRY * qglEvalCoord2fv )(const GLfloat *u);
+extern  void ( APIENTRY * qglEvalMesh1 )(GLenum mode, GLint i1, GLint i2);
+extern  void ( APIENTRY * qglEvalMesh2 )(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2);
+extern  void ( APIENTRY * qglEvalPoint1 )(GLint i);
+extern  void ( APIENTRY * qglEvalPoint2 )(GLint i, GLint j);
+extern  void ( APIENTRY * qglFeedbackBuffer )(GLsizei size, GLenum type, GLfloat *buffer);
+extern  void ( APIENTRY * qglFinish )(void);
+extern  void ( APIENTRY * qglFlush )(void);
+extern  void ( APIENTRY * qglFogf )(GLenum pname, GLfloat param);
+extern  void ( APIENTRY * qglFogfv )(GLenum pname, const GLfloat *params);
+extern  void ( APIENTRY * qglFogi )(GLenum pname, GLint param);
+extern  void ( APIENTRY * qglFogiv )(GLenum pname, const GLint *params);
+extern  void ( APIENTRY * qglFrontFace )(GLenum mode);
+extern  void ( APIENTRY * qglFrustum )(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
+extern  GLuint ( APIENTRY * qglGenLists )(GLsizei range);
+extern  void ( APIENTRY * qglGenTextures )(GLsizei n, GLuint *textures);
+extern  void ( APIENTRY * qglGetBooleanv )(GLenum pname, GLboolean *params);
+extern  void ( APIENTRY * qglGetClipPlane )(GLenum plane, GLdouble *equation);
+extern  void ( APIENTRY * qglGetDoublev )(GLenum pname, GLdouble *params);
+extern  GLenum ( APIENTRY * qglGetError )(void);
+extern  void ( APIENTRY * qglGetFloatv )(GLenum pname, GLfloat *params);
+extern  void ( APIENTRY * qglGetIntegerv )(GLenum pname, GLint *params);
+extern  void ( APIENTRY * qglGetLightfv )(GLenum light, GLenum pname, GLfloat *params);
+extern  void ( APIENTRY * qglGetLightiv )(GLenum light, GLenum pname, GLint *params);
+extern  void ( APIENTRY * qglGetMapdv )(GLenum target, GLenum query, GLdouble *v);
+extern  void ( APIENTRY * qglGetMapfv )(GLenum target, GLenum query, GLfloat *v);
+extern  void ( APIENTRY * qglGetMapiv )(GLenum target, GLenum query, GLint *v);
+extern  void ( APIENTRY * qglGetMaterialfv )(GLenum face, GLenum pname, GLfloat *params);
+extern  void ( APIENTRY * qglGetMaterialiv )(GLenum face, GLenum pname, GLint *params);
+extern  void ( APIENTRY * qglGetPixelMapfv )(GLenum map, GLfloat *values);
+extern  void ( APIENTRY * qglGetPixelMapuiv )(GLenum map, GLuint *values);
+extern  void ( APIENTRY * qglGetPixelMapusv )(GLenum map, GLushort *values);
+extern  void ( APIENTRY * qglGetPointerv )(GLenum pname, GLvoid* *params);
+extern  void ( APIENTRY * qglGetPolygonStipple )(GLubyte *mask);
+extern  const GLubyte * ( APIENTRY * qglGetString )(GLenum name);
+extern  void ( APIENTRY * qglGetTexEnvfv )(GLenum target, GLenum pname, GLfloat *params);
+extern  void ( APIENTRY * qglGetTexEnviv )(GLenum target, GLenum pname, GLint *params);
+extern  void ( APIENTRY * qglGetTexGendv )(GLenum coord, GLenum pname, GLdouble *params);
+extern  void ( APIENTRY * qglGetTexGenfv )(GLenum coord, GLenum pname, GLfloat *params);
+extern  void ( APIENTRY * qglGetTexGeniv )(GLenum coord, GLenum pname, GLint *params);
+extern  void ( APIENTRY * qglGetTexImage )(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels);
+extern  void ( APIENTRY * qglGetTexLevelParameterfv )(GLenum target, GLint level, GLenum pname, GLfloat *params);
+extern  void ( APIENTRY * qglGetTexLevelParameteriv )(GLenum target, GLint level, GLenum pname, GLint *params);
+extern  void ( APIENTRY * qglGetTexParameterfv )(GLenum target, GLenum pname, GLfloat *params);
+extern  void ( APIENTRY * qglGetTexParameteriv )(GLenum target, GLenum pname, GLint *params);
+extern  void ( APIENTRY * qglHint )(GLenum target, GLenum mode);
+extern  void ( APIENTRY * qglIndexMask )(GLuint mask);
+extern  void ( APIENTRY * qglIndexPointer )(GLenum type, GLsizei stride, const GLvoid *pointer);
+extern  void ( APIENTRY * qglIndexd )(GLdouble c);
+extern  void ( APIENTRY * qglIndexdv )(const GLdouble *c);
+extern  void ( APIENTRY * qglIndexf )(GLfloat c);
+extern  void ( APIENTRY * qglIndexfv )(const GLfloat *c);
+extern  void ( APIENTRY * qglIndexi )(GLint c);
+extern  void ( APIENTRY * qglIndexiv )(const GLint *c);
+extern  void ( APIENTRY * qglIndexs )(GLshort c);
+extern  void ( APIENTRY * qglIndexsv )(const GLshort *c);
+extern  void ( APIENTRY * qglIndexub )(GLubyte c);
+extern  void ( APIENTRY * qglIndexubv )(const GLubyte *c);
+extern  void ( APIENTRY * qglInitNames )(void);
+extern  void ( APIENTRY * qglInterleavedArrays )(GLenum format, GLsizei stride, const GLvoid *pointer);
+extern  GLboolean ( APIENTRY * qglIsEnabled )(GLenum cap);
+extern  GLboolean ( APIENTRY * qglIsList )(GLuint ilist);
+extern  GLboolean ( APIENTRY * qglIsTexture )(GLuint texture);
+extern  void ( APIENTRY * qglLightModelf )(GLenum pname, GLfloat param);
+extern  void ( APIENTRY * qglLightModelfv )(GLenum pname, const GLfloat *params);
+extern  void ( APIENTRY * qglLightModeli )(GLenum pname, GLint param);
+extern  void ( APIENTRY * qglLightModeliv )(GLenum pname, const GLint *params);
+extern  void ( APIENTRY * qglLightf )(GLenum light, GLenum pname, GLfloat param);
+extern  void ( APIENTRY * qglLightfv )(GLenum light, GLenum pname, const GLfloat *params);
+extern  void ( APIENTRY * qglLighti )(GLenum light, GLenum pname, GLint param);
+extern  void ( APIENTRY * qglLightiv )(GLenum light, GLenum pname, const GLint *params);
+extern  void ( APIENTRY * qglLineStipple )(GLint factor, GLushort pattern);
+extern  void ( APIENTRY * qglLineWidth )(GLfloat width);
+extern  void ( APIENTRY * qglListBase )(GLuint base);
+extern  void ( APIENTRY * qglLoadIdentity )(void);
+extern  void ( APIENTRY * qglLoadMatrixd )(const GLdouble *m);
+extern  void ( APIENTRY * qglLoadMatrixf )(const GLfloat *m);
+extern  void ( APIENTRY * qglLoadName )(GLuint name);
+extern  void ( APIENTRY * qglLogicOp )(GLenum opcode);
+extern  void ( APIENTRY * qglMap1d )(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points);
+extern  void ( APIENTRY * qglMap1f )(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points);
+extern  void ( APIENTRY * qglMap2d )(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points);
+extern  void ( APIENTRY * qglMap2f )(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points);
+extern  void ( APIENTRY * qglMapGrid1d )(GLint un, GLdouble u1, GLdouble u2);
+extern  void ( APIENTRY * qglMapGrid1f )(GLint un, GLfloat u1, GLfloat u2);
+extern  void ( APIENTRY * qglMapGrid2d )(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2);
+extern  void ( APIENTRY * qglMapGrid2f )(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2);
+extern  void ( APIENTRY * qglMaterialf )(GLenum face, GLenum pname, GLfloat param);
+extern  void ( APIENTRY * qglMaterialfv )(GLenum face, GLenum pname, const GLfloat *params);
+extern  void ( APIENTRY * qglMateriali )(GLenum face, GLenum pname, GLint param);
+extern  void ( APIENTRY * qglMaterialiv )(GLenum face, GLenum pname, const GLint *params);
+extern  void ( APIENTRY * qglMatrixMode )(GLenum mode);
+extern  void ( APIENTRY * qglMultMatrixd )(const GLdouble *m);
+extern  void ( APIENTRY * qglMultMatrixf )(const GLfloat *m);
+extern  void ( APIENTRY * qglNewList )(GLuint list, GLenum mode);
+extern  void ( APIENTRY * qglNormal3b )(GLbyte nx, GLbyte ny, GLbyte nz);
+extern  void ( APIENTRY * qglNormal3bv )(const GLbyte *v);
+extern  void ( APIENTRY * qglNormal3d )(GLdouble nx, GLdouble ny, GLdouble nz);
+extern  void ( APIENTRY * qglNormal3dv )(const GLdouble *v);
+extern  void ( APIENTRY * qglNormal3f )(GLfloat nx, GLfloat ny, GLfloat nz);
+extern  void ( APIENTRY * qglNormal3fv )(const GLfloat *v);
+extern  void ( APIENTRY * qglNormal3i )(GLint nx, GLint ny, GLint nz);
+extern  void ( APIENTRY * qglNormal3iv )(const GLint *v);
+extern  void ( APIENTRY * qglNormal3s )(GLshort nx, GLshort ny, GLshort nz);
+extern  void ( APIENTRY * qglNormal3sv )(const GLshort *v);
+extern  void ( APIENTRY * qglNormalPointer )(GLenum type, GLsizei stride, const GLvoid *pointer);
+extern  void ( APIENTRY * qglOrtho )(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
+extern  void ( APIENTRY * qglPassThrough )(GLfloat token);
+extern  void ( APIENTRY * qglPixelMapfv )(GLenum map, GLsizei mapsize, const GLfloat *values);
+extern  void ( APIENTRY * qglPixelMapuiv )(GLenum map, GLsizei mapsize, const GLuint *values);
+extern  void ( APIENTRY * qglPixelMapusv )(GLenum map, GLsizei mapsize, const GLushort *values);
+extern  void ( APIENTRY * qglPixelStoref )(GLenum pname, GLfloat param);
+extern  void ( APIENTRY * qglPixelStorei )(GLenum pname, GLint param);
+extern  void ( APIENTRY * qglPixelTransferf )(GLenum pname, GLfloat param);
+extern  void ( APIENTRY * qglPixelTransferi )(GLenum pname, GLint param);
+extern  void ( APIENTRY * qglPixelZoom )(GLfloat xfactor, GLfloat yfactor);
+extern  void ( APIENTRY * qglPointSize )(GLfloat size);
+extern  void ( APIENTRY * qglPolygonMode )(GLenum face, GLenum mode);
+extern  void ( APIENTRY * qglPolygonOffset )(GLfloat factor, GLfloat units);
+extern  void ( APIENTRY * qglPolygonStipple )(const GLubyte *mask);
+extern  void ( APIENTRY * qglPopAttrib )(void);
+extern  void ( APIENTRY * qglPopClientAttrib )(void);
+extern  void ( APIENTRY * qglPopMatrix )(void);
+extern  void ( APIENTRY * qglPopName )(void);
+extern  void ( APIENTRY * qglPrioritizeTextures )(GLsizei n, const GLuint *textures, const GLclampf *priorities);
+extern  void ( APIENTRY * qglPushAttrib )(GLbitfield mask);
+extern  void ( APIENTRY * qglPushClientAttrib )(GLbitfield mask);
+extern  void ( APIENTRY * qglPushMatrix )(void);
+extern  void ( APIENTRY * qglPushName )(GLuint name);
+extern  void ( APIENTRY * qglRasterPos2d )(GLdouble x, GLdouble y);
+extern  void ( APIENTRY * qglRasterPos2dv )(const GLdouble *v);
+extern  void ( APIENTRY * qglRasterPos2f )(GLfloat x, GLfloat y);
+extern  void ( APIENTRY * qglRasterPos2fv )(const GLfloat *v);
+extern  void ( APIENTRY * qglRasterPos2i )(GLint x, GLint y);
+extern  void ( APIENTRY * qglRasterPos2iv )(const GLint *v);
+extern  void ( APIENTRY * qglRasterPos2s )(GLshort x, GLshort y);
+extern  void ( APIENTRY * qglRasterPos2sv )(const GLshort *v);
+extern  void ( APIENTRY * qglRasterPos3d )(GLdouble x, GLdouble y, GLdouble z);
+extern  void ( APIENTRY * qglRasterPos3dv )(const GLdouble *v);
+extern  void ( APIENTRY * qglRasterPos3f )(GLfloat x, GLfloat y, GLfloat z);
+extern  void ( APIENTRY * qglRasterPos3fv )(const GLfloat *v);
+extern  void ( APIENTRY * qglRasterPos3i )(GLint x, GLint y, GLint z);
+extern  void ( APIENTRY * qglRasterPos3iv )(const GLint *v);
+extern  void ( APIENTRY * qglRasterPos3s )(GLshort x, GLshort y, GLshort z);
+extern  void ( APIENTRY * qglRasterPos3sv )(const GLshort *v);
+extern  void ( APIENTRY * qglRasterPos4d )(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+extern  void ( APIENTRY * qglRasterPos4dv )(const GLdouble *v);
+extern  void ( APIENTRY * qglRasterPos4f )(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+extern  void ( APIENTRY * qglRasterPos4fv )(const GLfloat *v);
+extern  void ( APIENTRY * qglRasterPos4i )(GLint x, GLint y, GLint z, GLint w);
+extern  void ( APIENTRY * qglRasterPos4iv )(const GLint *v);
+extern  void ( APIENTRY * qglRasterPos4s )(GLshort x, GLshort y, GLshort z, GLshort w);
+extern  void ( APIENTRY * qglRasterPos4sv )(const GLshort *v);
+extern  void ( APIENTRY * qglReadBuffer )(GLenum mode);
+extern  void ( APIENTRY * qglReadPixels )(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels);
+extern  void ( APIENTRY * qglRectd )(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2);
+extern  void ( APIENTRY * qglRectdv )(const GLdouble *v1, const GLdouble *v2);
+extern  void ( APIENTRY * qglRectf )(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2);
+extern  void ( APIENTRY * qglRectfv )(const GLfloat *v1, const GLfloat *v2);
+extern  void ( APIENTRY * qglRecti )(GLint x1, GLint y1, GLint x2, GLint y2);
+extern  void ( APIENTRY * qglRectiv )(const GLint *v1, const GLint *v2);
+extern  void ( APIENTRY * qglRects )(GLshort x1, GLshort y1, GLshort x2, GLshort y2);
+extern  void ( APIENTRY * qglRectsv )(const GLshort *v1, const GLshort *v2);
+extern  GLint ( APIENTRY * qglRenderMode )(GLenum mode);
+extern  void ( APIENTRY * qglRotated )(GLdouble angle, GLdouble x, GLdouble y, GLdouble z);
+extern  void ( APIENTRY * qglRotatef )(GLfloat angle, GLfloat x, GLfloat y, GLfloat z);
+extern  void ( APIENTRY * qglScaled )(GLdouble x, GLdouble y, GLdouble z);
+extern  void ( APIENTRY * qglScalef )(GLfloat x, GLfloat y, GLfloat z);
+extern  void ( APIENTRY * qglScissor )(GLint x, GLint y, GLsizei width, GLsizei height);
+extern  void ( APIENTRY * qglSelectBuffer )(GLsizei size, GLuint *buffer);
+extern  void ( APIENTRY * qglShadeModel )(GLenum mode);
+extern  void ( APIENTRY * qglStencilFunc )(GLenum func, GLint ref, GLuint mask);
+extern  void ( APIENTRY * qglStencilMask )(GLuint mask);
+extern  void ( APIENTRY * qglStencilOp )(GLenum fail, GLenum zfail, GLenum zpass);
+extern  void ( APIENTRY * qglTexCoord1d )(GLdouble s);
+extern  void ( APIENTRY * qglTexCoord1dv )(const GLdouble *v);
+extern  void ( APIENTRY * qglTexCoord1f )(GLfloat s);
+extern  void ( APIENTRY * qglTexCoord1fv )(const GLfloat *v);
+extern  void ( APIENTRY * qglTexCoord1i )(GLint s);
+extern  void ( APIENTRY * qglTexCoord1iv )(const GLint *v);
+extern  void ( APIENTRY * qglTexCoord1s )(GLshort s);
+extern  void ( APIENTRY * qglTexCoord1sv )(const GLshort *v);
+extern  void ( APIENTRY * qglTexCoord2d )(GLdouble s, GLdouble t);
+extern  void ( APIENTRY * qglTexCoord2dv )(const GLdouble *v);
+extern  void ( APIENTRY * qglTexCoord2f )(GLfloat s, GLfloat t);
+extern  void ( APIENTRY * qglTexCoord2fv )(const GLfloat *v);
+extern  void ( APIENTRY * qglTexCoord2i )(GLint s, GLint t);
+extern  void ( APIENTRY * qglTexCoord2iv )(const GLint *v);
+extern  void ( APIENTRY * qglTexCoord2s )(GLshort s, GLshort t);
+extern  void ( APIENTRY * qglTexCoord2sv )(const GLshort *v);
+extern  void ( APIENTRY * qglTexCoord3d )(GLdouble s, GLdouble t, GLdouble r);
+extern  void ( APIENTRY * qglTexCoord3dv )(const GLdouble *v);
+extern  void ( APIENTRY * qglTexCoord3f )(GLfloat s, GLfloat t, GLfloat r);
+extern  void ( APIENTRY * qglTexCoord3fv )(const GLfloat *v);
+extern  void ( APIENTRY * qglTexCoord3i )(GLint s, GLint t, GLint r);
+extern  void ( APIENTRY * qglTexCoord3iv )(const GLint *v);
+extern  void ( APIENTRY * qglTexCoord3s )(GLshort s, GLshort t, GLshort r);
+extern  void ( APIENTRY * qglTexCoord3sv )(const GLshort *v);
+extern  void ( APIENTRY * qglTexCoord4d )(GLdouble s, GLdouble t, GLdouble r, GLdouble q);
+extern  void ( APIENTRY * qglTexCoord4dv )(const GLdouble *v);
+extern  void ( APIENTRY * qglTexCoord4f )(GLfloat s, GLfloat t, GLfloat r, GLfloat q);
+extern  void ( APIENTRY * qglTexCoord4fv )(const GLfloat *v);
+extern  void ( APIENTRY * qglTexCoord4i )(GLint s, GLint t, GLint r, GLint q);
+extern  void ( APIENTRY * qglTexCoord4iv )(const GLint *v);
+extern  void ( APIENTRY * qglTexCoord4s )(GLshort s, GLshort t, GLshort r, GLshort q);
+extern  void ( APIENTRY * qglTexCoord4sv )(const GLshort *v);
+extern  void ( APIENTRY * qglTexCoordPointer )(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
+extern  void ( APIENTRY * qglTexEnvf )(GLenum target, GLenum pname, GLfloat param);
+extern  void ( APIENTRY * qglTexEnvfv )(GLenum target, GLenum pname, const GLfloat *params);
+extern  void ( APIENTRY * qglTexEnvi )(GLenum target, GLenum pname, GLint param);
+extern  void ( APIENTRY * qglTexEnviv )(GLenum target, GLenum pname, const GLint *params);
+extern  void ( APIENTRY * qglTexGend )(GLenum coord, GLenum pname, GLdouble param);
+extern  void ( APIENTRY * qglTexGendv )(GLenum coord, GLenum pname, const GLdouble *params);
+extern  void ( APIENTRY * qglTexGenf )(GLenum coord, GLenum pname, GLfloat param);
+extern  void ( APIENTRY * qglTexGenfv )(GLenum coord, GLenum pname, const GLfloat *params);
+extern  void ( APIENTRY * qglTexGeni )(GLenum coord, GLenum pname, GLint param);
+extern  void ( APIENTRY * qglTexGeniv )(GLenum coord, GLenum pname, const GLint *params);
+extern  void ( APIENTRY * qglTexImage1D )(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
+extern  void ( APIENTRY * qglTexImage2D )(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
+extern  void ( APIENTRY * qglTexParameterf )(GLenum target, GLenum pname, GLfloat param);
+extern  void ( APIENTRY * qglTexParameterfv )(GLenum target, GLenum pname, const GLfloat *params);
+extern  void ( APIENTRY * qglTexParameteri )(GLenum target, GLenum pname, GLint param);
+extern  void ( APIENTRY * qglTexParameteriv )(GLenum target, GLenum pname, const GLint *params);
+extern  void ( APIENTRY * qglTexSubImage1D )(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels);
+extern  void ( APIENTRY * qglTexSubImage2D )(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
+extern  void ( APIENTRY * qglTranslated )(GLdouble x, GLdouble y, GLdouble z);
+extern  void ( APIENTRY * qglTranslatef )(GLfloat x, GLfloat y, GLfloat z);
+extern  void ( APIENTRY * qglVertex2d )(GLdouble x, GLdouble y);
+extern  void ( APIENTRY * qglVertex2dv )(const GLdouble *v);
+extern  void ( APIENTRY * qglVertex2f )(GLfloat x, GLfloat y);
+extern  void ( APIENTRY * qglVertex2fv )(const GLfloat *v);
+extern  void ( APIENTRY * qglVertex2i )(GLint x, GLint y);
+extern  void ( APIENTRY * qglVertex2iv )(const GLint *v);
+extern  void ( APIENTRY * qglVertex2s )(GLshort x, GLshort y);
+extern  void ( APIENTRY * qglVertex2sv )(const GLshort *v);
+extern  void ( APIENTRY * qglVertex3d )(GLdouble x, GLdouble y, GLdouble z);
+extern  void ( APIENTRY * qglVertex3dv )(const GLdouble *v);
+extern  void ( APIENTRY * qglVertex3f )(GLfloat x, GLfloat y, GLfloat z);
+extern  void ( APIENTRY * qglVertex3fv )(const GLfloat *v);
+extern  void ( APIENTRY * qglVertex3i )(GLint x, GLint y, GLint z);
+extern  void ( APIENTRY * qglVertex3iv )(const GLint *v);
+extern  void ( APIENTRY * qglVertex3s )(GLshort x, GLshort y, GLshort z);
+extern  void ( APIENTRY * qglVertex3sv )(const GLshort *v);
+extern  void ( APIENTRY * qglVertex4d )(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+extern  void ( APIENTRY * qglVertex4dv )(const GLdouble *v);
+extern  void ( APIENTRY * qglVertex4f )(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+extern  void ( APIENTRY * qglVertex4fv )(const GLfloat *v);
+extern  void ( APIENTRY * qglVertex4i )(GLint x, GLint y, GLint z, GLint w);
+extern  void ( APIENTRY * qglVertex4iv )(const GLint *v);
+extern  void ( APIENTRY * qglVertex4s )(GLshort x, GLshort y, GLshort z, GLshort w);
+extern  void ( APIENTRY * qglVertex4sv )(const GLshort *v);
+extern  void ( APIENTRY * qglVertexPointer )(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
+extern  void ( APIENTRY * qglViewport )(GLint x, GLint y, GLsizei width, GLsizei height);
+
+#if defined( _WIN32 )
+
+extern BOOL  ( WINAPI * qwglCopyContext)(HGLRC, HGLRC, UINT);
+extern HGLRC ( WINAPI * qwglCreateContext)(HDC);
+extern HGLRC ( WINAPI * qwglCreateLayerContext)(HDC, int);
+extern BOOL  ( WINAPI * qwglDeleteContext)(HGLRC);
+extern HGLRC ( WINAPI * qwglGetCurrentContext)(VOID);
+extern HDC   ( WINAPI * qwglGetCurrentDC)(VOID);
+extern PROC  ( WINAPI * qwglGetProcAddress)(LPCSTR);
+extern BOOL  ( WINAPI * qwglMakeCurrent)(HDC, HGLRC);
+extern BOOL  ( WINAPI * qwglShareLists)(HGLRC, HGLRC);
+extern BOOL  ( WINAPI * qwglUseFontBitmaps)(HDC, DWORD, DWORD, DWORD);
+
+extern BOOL  ( WINAPI * qwglUseFontOutlines)(HDC, DWORD, DWORD, DWORD, FLOAT,
+                                           FLOAT, int, LPGLYPHMETRICSFLOAT);
+
+extern BOOL ( WINAPI * qwglDescribeLayerPlane)(HDC, int, int, UINT,
+                                            LPLAYERPLANEDESCRIPTOR);
+extern int  ( WINAPI * qwglSetLayerPaletteEntries)(HDC, int, int, int,
+                                                CONST COLORREF *);
+extern int  ( WINAPI * qwglGetLayerPaletteEntries)(HDC, int, int, int,
+                                                COLORREF *);
+extern BOOL ( WINAPI * qwglRealizeLayerPalette)(HDC, int, BOOL);
+extern BOOL ( WINAPI * qwglSwapLayerBuffers)(HDC, UINT);
+
+extern BOOL ( WINAPI * qwglSwapIntervalEXT)( int interval );
+
+#endif	// _WIN32
+
+#if ( (defined __linux__ )  || (defined __FreeBSD__ ) ) // rb010123
+
+//FX Mesa Functions
+// bk001129 - from cvs1.17 (mkv)
+#if defined (__FX__)
+extern fxMesaContext (*qfxMesaCreateContext)(GLuint win, GrScreenResolution_t, GrScreenRefresh_t, const GLint attribList[]);
+extern fxMesaContext (*qfxMesaCreateBestContext)(GLuint win, GLint width, GLint height, const GLint attribList[]);
+extern void (*qfxMesaDestroyContext)(fxMesaContext ctx);
+extern void (*qfxMesaMakeCurrent)(fxMesaContext ctx);
+extern fxMesaContext (*qfxMesaGetCurrentContext)(void);
+extern void (*qfxMesaSwapBuffers)(void);
+#endif
+
+//GLX Functions
+extern XVisualInfo * (*qglXChooseVisual)( Display *dpy, int screen, int *attribList );
+extern GLXContext (*qglXCreateContext)( Display *dpy, XVisualInfo *vis, GLXContext shareList, Bool direct );
+extern void (*qglXDestroyContext)( Display *dpy, GLXContext ctx );
+extern Bool (*qglXMakeCurrent)( Display *dpy, GLXDrawable drawable, GLXContext ctx);
+extern void (*qglXCopyContext)( Display *dpy, GLXContext src, GLXContext dst, GLuint mask );
+extern void (*qglXSwapBuffers)( Display *dpy, GLXDrawable drawable );
+
+#endif // __linux__ || __FreeBSD__ // rb010123
+
+#endif	// _WIN32 && __linux__
+
+#endif
\ No newline at end of file
diff --git a/codemp/renderer/qgl_console.h b/codemp/renderer/qgl_console.h
new file mode 100644
index 0000000..0e35b09
--- /dev/null
+++ b/codemp/renderer/qgl_console.h
@@ -0,0 +1,1205 @@
+/*
+** QGL.H
+*/
+
+#ifndef __QGL_H__
+#define __QGL_H__
+
+#ifdef _WINDOWS
+#include <windows.h>
+#include <gl/gl.h>
+#endif
+
+#ifdef _XBOX
+
+#include <Xtl.h>
+#endif
+
+#ifdef _GAMECUBE
+#include <dolphin/gx.h>
+#include <dolphin/mtx.h>
+#endif
+
+typedef unsigned int GLenum;
+typedef unsigned char GLboolean;
+typedef unsigned int GLbitfield;
+typedef signed char GLbyte;
+typedef short GLshort;
+typedef int GLint;
+typedef int GLsizei;
+typedef unsigned char GLubyte;
+typedef unsigned short GLushort;
+typedef unsigned int GLuint;
+typedef float GLfloat;
+typedef float GLclampf;
+typedef double GLdouble;
+typedef double GLclampd;
+typedef void GLvoid;
+
+#undef APIENTRY
+#define APIENTRY
+
+#define GL_ACCUM                          0x0100
+#define GL_LOAD                           0x0101
+#define GL_RETURN                         0x0102
+#define GL_MULT                           0x0103
+#define GL_ADD                            0x0104
+
+/* AlphaFunction */
+#define GL_NEVER                          0x0200
+#define GL_LESS                           0x0201
+#define GL_EQUAL                          0x0202
+#define GL_LEQUAL                         0x0203
+#define GL_GREATER                        0x0204
+#define GL_NOTEQUAL                       0x0205
+#define GL_GEQUAL                         0x0206
+#define GL_ALWAYS                         0x0207
+
+/* AttribMask */
+#define GL_CURRENT_BIT                    0x00000001
+#define GL_POINT_BIT                      0x00000002
+#define GL_LINE_BIT                       0x00000004
+#define GL_POLYGON_BIT                    0x00000008
+#define GL_POLYGON_STIPPLE_BIT            0x00000010
+#define GL_PIXEL_MODE_BIT                 0x00000020
+#define GL_LIGHTING_BIT                   0x00000040
+#define GL_FOG_BIT                        0x00000080
+#define GL_DEPTH_BUFFER_BIT               0x00000100
+#define GL_ACCUM_BUFFER_BIT               0x00000200
+#define GL_STENCIL_BUFFER_BIT             0x00000400
+#define GL_VIEWPORT_BIT                   0x00000800
+#define GL_TRANSFORM_BIT                  0x00001000
+#define GL_ENABLE_BIT                     0x00002000
+#define GL_COLOR_BUFFER_BIT               0x00004000
+#define GL_HINT_BIT                       0x00008000
+#define GL_EVAL_BIT                       0x00010000
+#define GL_LIST_BIT                       0x00020000
+#define GL_TEXTURE_BIT                    0x00040000
+#define GL_SCISSOR_BIT                    0x00080000
+#define GL_ALL_ATTRIB_BITS                0x000fffff
+
+/* BeginMode */
+#define GL_POINTS                         0x0000
+#define GL_LINES                          0x0001
+#define GL_LINE_LOOP                      0x0002
+#define GL_LINE_STRIP                     0x0003
+#define GL_TRIANGLES                      0x0004
+#define GL_TRIANGLE_STRIP                 0x0005
+#define GL_TRIANGLE_FAN                   0x0006
+#define GL_QUADS                          0x0007
+#define GL_QUAD_STRIP                     0x0008
+#define GL_POLYGON                        0x0009
+
+/* BlendingFactorDest */
+#define GL_ZERO                           0
+#define GL_ONE                            1
+#define GL_SRC_COLOR                      0x0300
+#define GL_ONE_MINUS_SRC_COLOR            0x0301
+#define GL_SRC_ALPHA                      0x0302
+#define GL_ONE_MINUS_SRC_ALPHA            0x0303
+#define GL_DST_ALPHA                      0x0304
+#define GL_ONE_MINUS_DST_ALPHA            0x0305
+
+/* BlendingFactorSrc */
+/*      GL_ZERO */
+/*      GL_ONE */
+#define GL_DST_COLOR                      0x0306
+#define GL_ONE_MINUS_DST_COLOR            0x0307
+#define GL_SRC_ALPHA_SATURATE             0x0308
+
+/* Boolean */
+#define GL_TRUE                           1
+#define GL_FALSE                          0
+
+/* ClipPlaneName */
+#define GL_CLIP_PLANE0                    0x3000
+#define GL_CLIP_PLANE1                    0x3001
+#define GL_CLIP_PLANE2                    0x3002
+#define GL_CLIP_PLANE3                    0x3003
+#define GL_CLIP_PLANE4                    0x3004
+#define GL_CLIP_PLANE5                    0x3005
+
+/* DataType */
+#define GL_BYTE                           0x1400
+#define GL_UNSIGNED_BYTE                  0x1401
+#define GL_SHORT                          0x1402
+#define GL_UNSIGNED_SHORT                 0x1403
+#define GL_INT                            0x1404
+#define GL_UNSIGNED_INT                   0x1405
+#define GL_FLOAT                          0x1406
+#define GL_2_BYTES                        0x1407
+#define GL_3_BYTES                        0x1408
+#define GL_4_BYTES                        0x1409
+#define GL_DOUBLE                         0x140A
+
+/* DrawBufferMode */
+#define GL_NONE                           0
+#define GL_FRONT_LEFT                     0x0400
+#define GL_FRONT_RIGHT                    0x0401
+#define GL_BACK_LEFT                      0x0402
+#define GL_BACK_RIGHT                     0x0403
+#define GL_FRONT                          0x0404
+#define GL_BACK                           0x0405
+#define GL_LEFT                           0x0406
+#define GL_RIGHT                          0x0407
+#define GL_FRONT_AND_BACK                 0x0408
+#define GL_AUX0                           0x0409
+#define GL_AUX1                           0x040A
+#define GL_AUX2                           0x040B
+#define GL_AUX3                           0x040C
+
+/* ErrorCode */
+#define GL_NO_ERROR                       0
+#define GL_INVALID_ENUM                   0x0500
+#define GL_INVALID_VALUE                  0x0501
+#define GL_INVALID_OPERATION              0x0502
+#define GL_STACK_OVERFLOW                 0x0503
+#define GL_STACK_UNDERFLOW                0x0504
+#define GL_OUT_OF_MEMORY                  0x0505
+
+/* FeedBackMode */
+#define GL_2D                             0x0600
+#define GL_3D                             0x0601
+#define GL_3D_COLOR                       0x0602
+#define GL_3D_COLOR_TEXTURE               0x0603
+#define GL_4D_COLOR_TEXTURE               0x0604
+
+/* FeedBackToken */
+#define GL_PASS_THROUGH_TOKEN             0x0700
+#define GL_POINT_TOKEN                    0x0701
+#define GL_LINE_TOKEN                     0x0702
+#define GL_POLYGON_TOKEN                  0x0703
+#define GL_BITMAP_TOKEN                   0x0704
+#define GL_DRAW_PIXEL_TOKEN               0x0705
+#define GL_COPY_PIXEL_TOKEN               0x0706
+#define GL_LINE_RESET_TOKEN               0x0707
+
+/* FogMode */
+/*      GL_LINEAR */
+#define GL_EXP                            0x0800
+#define GL_EXP2                           0x0801
+
+/* FrontFaceDirection */
+#define GL_CW                             0x0900
+#define GL_CCW                            0x0901
+
+/* GetMapTarget */
+#define GL_COEFF                          0x0A00
+#define GL_ORDER                          0x0A01
+#define GL_DOMAIN                         0x0A02
+
+/* GetTarget */
+#define GL_CURRENT_COLOR                  0x0B00
+#define GL_CURRENT_INDEX                  0x0B01
+#define GL_CURRENT_NORMAL                 0x0B02
+#define GL_CURRENT_TEXTURE_COORDS         0x0B03
+#define GL_CURRENT_RASTER_COLOR           0x0B04
+#define GL_CURRENT_RASTER_INDEX           0x0B05
+#define GL_CURRENT_RASTER_TEXTURE_COORDS  0x0B06
+#define GL_CURRENT_RASTER_POSITION        0x0B07
+#define GL_CURRENT_RASTER_POSITION_VALID  0x0B08
+#define GL_CURRENT_RASTER_DISTANCE        0x0B09
+#define GL_POINT_SMOOTH                   0x0B10
+#define GL_POINT_SIZE                     0x0B11
+#define GL_POINT_SIZE_RANGE               0x0B12
+#define GL_POINT_SIZE_GRANULARITY         0x0B13
+#define GL_LINE_SMOOTH                    0x0B20
+#define GL_LINE_WIDTH                     0x0B21
+#define GL_LINE_WIDTH_RANGE               0x0B22
+#define GL_LINE_WIDTH_GRANULARITY         0x0B23
+#define GL_LINE_STIPPLE                   0x0B24
+#define GL_LINE_STIPPLE_PATTERN           0x0B25
+#define GL_LINE_STIPPLE_REPEAT            0x0B26
+#define GL_LIST_MODE                      0x0B30
+#define GL_MAX_LIST_NESTING               0x0B31
+#define GL_LIST_BASE                      0x0B32
+#define GL_LIST_INDEX                     0x0B33
+#define GL_POLYGON_MODE                   0x0B40
+#define GL_POLYGON_SMOOTH                 0x0B41
+#define GL_POLYGON_STIPPLE                0x0B42
+#define GL_EDGE_FLAG                      0x0B43
+#define GL_CULL_FACE                      0x0B44
+#define GL_CULL_FACE_MODE                 0x0B45
+#define GL_FRONT_FACE                     0x0B46
+#define GL_LIGHTING                       0x0B50
+#define GL_LIGHT_MODEL_LOCAL_VIEWER       0x0B51
+#define GL_LIGHT_MODEL_TWO_SIDE           0x0B52
+#define GL_LIGHT_MODEL_AMBIENT            0x0B53
+#define GL_SHADE_MODEL                    0x0B54
+#define GL_COLOR_MATERIAL_FACE            0x0B55
+#define GL_COLOR_MATERIAL_PARAMETER       0x0B56
+#define GL_COLOR_MATERIAL                 0x0B57
+#define GL_FOG                            0x0B60
+#define GL_FOG_INDEX                      0x0B61
+#define GL_FOG_DENSITY                    0x0B62
+#define GL_FOG_START                      0x0B63
+#define GL_FOG_END                        0x0B64
+#define GL_FOG_MODE                       0x0B65
+#define GL_FOG_COLOR                      0x0B66
+#define GL_DEPTH_RANGE                    0x0B70
+#define GL_DEPTH_TEST                     0x0B71
+#define GL_DEPTH_WRITEMASK                0x0B72
+#define GL_DEPTH_CLEAR_VALUE              0x0B73
+#define GL_DEPTH_FUNC                     0x0B74
+#define GL_ACCUM_CLEAR_VALUE              0x0B80
+#define GL_STENCIL_TEST                   0x0B90
+#define GL_STENCIL_CLEAR_VALUE            0x0B91
+#define GL_STENCIL_FUNC                   0x0B92
+#define GL_STENCIL_VALUE_MASK             0x0B93
+#define GL_STENCIL_FAIL                   0x0B94
+#define GL_STENCIL_PASS_DEPTH_FAIL        0x0B95
+#define GL_STENCIL_PASS_DEPTH_PASS        0x0B96
+#define GL_STENCIL_REF                    0x0B97
+#define GL_STENCIL_WRITEMASK              0x0B98
+#define GL_MATRIX_MODE                    0x0BA0
+#define GL_NORMALIZE                      0x0BA1
+#define GL_VIEWPORT                       0x0BA2
+#define GL_MODELVIEW_STACK_DEPTH          0x0BA3
+#define GL_PROJECTION_STACK_DEPTH         0x0BA4
+#define GL_TEXTURE_STACK_DEPTH            0x0BA5
+#define GL_MODELVIEW_MATRIX               0x0BA6
+#define GL_PROJECTION_MATRIX              0x0BA7
+#define GL_TEXTURE_MATRIX                 0x0BA8
+#define GL_ATTRIB_STACK_DEPTH             0x0BB0
+#define GL_CLIENT_ATTRIB_STACK_DEPTH      0x0BB1
+#define GL_ALPHA_TEST                     0x0BC0
+#define GL_ALPHA_TEST_FUNC                0x0BC1
+#define GL_ALPHA_TEST_REF                 0x0BC2
+#define GL_DITHER                         0x0BD0
+#define GL_BLEND_DST                      0x0BE0
+#define GL_BLEND_SRC                      0x0BE1
+#define GL_BLEND                          0x0BE2
+#define GL_LOGIC_OP_MODE                  0x0BF0
+#define GL_INDEX_LOGIC_OP                 0x0BF1
+#define GL_COLOR_LOGIC_OP                 0x0BF2
+#define GL_AUX_BUFFERS                    0x0C00
+#define GL_DRAW_BUFFER                    0x0C01
+#define GL_READ_BUFFER                    0x0C02
+#define GL_SCISSOR_BOX                    0x0C10
+#define GL_SCISSOR_TEST                   0x0C11
+#define GL_INDEX_CLEAR_VALUE              0x0C20
+#define GL_INDEX_WRITEMASK                0x0C21
+#define GL_COLOR_CLEAR_VALUE              0x0C22
+#define GL_COLOR_WRITEMASK                0x0C23
+#define GL_INDEX_MODE                     0x0C30
+#define GL_RGBA_MODE                      0x0C31
+#define GL_DOUBLEBUFFER                   0x0C32
+#define GL_STEREO                         0x0C33
+#define GL_RENDER_MODE                    0x0C40
+#define GL_PERSPECTIVE_CORRECTION_HINT    0x0C50
+#define GL_POINT_SMOOTH_HINT              0x0C51
+#define GL_LINE_SMOOTH_HINT               0x0C52
+#define GL_POLYGON_SMOOTH_HINT            0x0C53
+#define GL_FOG_HINT                       0x0C54
+#define GL_TEXTURE_GEN_S                  0x0C60
+#define GL_TEXTURE_GEN_T                  0x0C61
+#define GL_TEXTURE_GEN_R                  0x0C62
+#define GL_TEXTURE_GEN_Q                  0x0C63
+#define GL_PIXEL_MAP_I_TO_I               0x0C70
+#define GL_PIXEL_MAP_S_TO_S               0x0C71
+#define GL_PIXEL_MAP_I_TO_R               0x0C72
+#define GL_PIXEL_MAP_I_TO_G               0x0C73
+#define GL_PIXEL_MAP_I_TO_B               0x0C74
+#define GL_PIXEL_MAP_I_TO_A               0x0C75
+#define GL_PIXEL_MAP_R_TO_R               0x0C76
+#define GL_PIXEL_MAP_G_TO_G               0x0C77
+#define GL_PIXEL_MAP_B_TO_B               0x0C78
+#define GL_PIXEL_MAP_A_TO_A               0x0C79
+#define GL_PIXEL_MAP_I_TO_I_SIZE          0x0CB0
+#define GL_PIXEL_MAP_S_TO_S_SIZE          0x0CB1
+#define GL_PIXEL_MAP_I_TO_R_SIZE          0x0CB2
+#define GL_PIXEL_MAP_I_TO_G_SIZE          0x0CB3
+#define GL_PIXEL_MAP_I_TO_B_SIZE          0x0CB4
+#define GL_PIXEL_MAP_I_TO_A_SIZE          0x0CB5
+#define GL_PIXEL_MAP_R_TO_R_SIZE          0x0CB6
+#define GL_PIXEL_MAP_G_TO_G_SIZE          0x0CB7
+#define GL_PIXEL_MAP_B_TO_B_SIZE          0x0CB8
+#define GL_PIXEL_MAP_A_TO_A_SIZE          0x0CB9
+#define GL_UNPACK_SWAP_BYTES              0x0CF0
+#define GL_UNPACK_LSB_FIRST               0x0CF1
+#define GL_UNPACK_ROW_LENGTH              0x0CF2
+#define GL_UNPACK_SKIP_ROWS               0x0CF3
+#define GL_UNPACK_SKIP_PIXELS             0x0CF4
+#define GL_UNPACK_ALIGNMENT               0x0CF5
+#define GL_PACK_SWAP_BYTES                0x0D00
+#define GL_PACK_LSB_FIRST                 0x0D01
+#define GL_PACK_ROW_LENGTH                0x0D02
+#define GL_PACK_SKIP_ROWS                 0x0D03
+#define GL_PACK_SKIP_PIXELS               0x0D04
+#define GL_PACK_ALIGNMENT                 0x0D05
+#define GL_MAP_COLOR                      0x0D10
+#define GL_MAP_STENCIL                    0x0D11
+#define GL_INDEX_SHIFT                    0x0D12
+#define GL_INDEX_OFFSET                   0x0D13
+#define GL_RED_SCALE                      0x0D14
+#define GL_RED_BIAS                       0x0D15
+#define GL_ZOOM_X                         0x0D16
+#define GL_ZOOM_Y                         0x0D17
+#define GL_GREEN_SCALE                    0x0D18
+#define GL_GREEN_BIAS                     0x0D19
+#define GL_BLUE_SCALE                     0x0D1A
+#define GL_BLUE_BIAS                      0x0D1B
+#define GL_ALPHA_SCALE                    0x0D1C
+#define GL_ALPHA_BIAS                     0x0D1D
+#define GL_DEPTH_SCALE                    0x0D1E
+#define GL_DEPTH_BIAS                     0x0D1F
+#define GL_MAX_EVAL_ORDER                 0x0D30
+#define GL_MAX_LIGHTS                     0x0D31
+#define GL_MAX_CLIP_PLANES                0x0D32
+#define GL_MAX_TEXTURE_SIZE               0x0D33
+#define GL_MAX_PIXEL_MAP_TABLE            0x0D34
+#define GL_MAX_ATTRIB_STACK_DEPTH         0x0D35
+#define GL_MAX_MODELVIEW_STACK_DEPTH      0x0D36
+#define GL_MAX_NAME_STACK_DEPTH           0x0D37
+#define GL_MAX_PROJECTION_STACK_DEPTH     0x0D38
+#define GL_MAX_TEXTURE_STACK_DEPTH        0x0D39
+#define GL_MAX_VIEWPORT_DIMS              0x0D3A
+#define GL_MAX_CLIENT_ATTRIB_STACK_DEPTH  0x0D3B
+#define GL_SUBPIXEL_BITS                  0x0D50
+#define GL_INDEX_BITS                     0x0D51
+#define GL_RED_BITS                       0x0D52
+#define GL_GREEN_BITS                     0x0D53
+#define GL_BLUE_BITS                      0x0D54
+#define GL_ALPHA_BITS                     0x0D55
+#define GL_DEPTH_BITS                     0x0D56
+#define GL_STENCIL_BITS                   0x0D57
+#define GL_ACCUM_RED_BITS                 0x0D58
+#define GL_ACCUM_GREEN_BITS               0x0D59
+#define GL_ACCUM_BLUE_BITS                0x0D5A
+#define GL_ACCUM_ALPHA_BITS               0x0D5B
+#define GL_NAME_STACK_DEPTH               0x0D70
+#define GL_AUTO_NORMAL                    0x0D80
+#define GL_MAP1_COLOR_4                   0x0D90
+#define GL_MAP1_INDEX                     0x0D91
+#define GL_MAP1_NORMAL                    0x0D92
+#define GL_MAP1_TEXTURE_COORD_1           0x0D93
+#define GL_MAP1_TEXTURE_COORD_2           0x0D94
+#define GL_MAP1_TEXTURE_COORD_3           0x0D95
+#define GL_MAP1_TEXTURE_COORD_4           0x0D96
+#define GL_MAP1_VERTEX_3                  0x0D97
+#define GL_MAP1_VERTEX_4                  0x0D98
+#define GL_MAP2_COLOR_4                   0x0DB0
+#define GL_MAP2_INDEX                     0x0DB1
+#define GL_MAP2_NORMAL                    0x0DB2
+#define GL_MAP2_TEXTURE_COORD_1           0x0DB3
+#define GL_MAP2_TEXTURE_COORD_2           0x0DB4
+#define GL_MAP2_TEXTURE_COORD_3           0x0DB5
+#define GL_MAP2_TEXTURE_COORD_4           0x0DB6
+#define GL_MAP2_VERTEX_3                  0x0DB7
+#define GL_MAP2_VERTEX_4                  0x0DB8
+#define GL_MAP1_GRID_DOMAIN               0x0DD0
+#define GL_MAP1_GRID_SEGMENTS             0x0DD1
+#define GL_MAP2_GRID_DOMAIN               0x0DD2
+#define GL_MAP2_GRID_SEGMENTS             0x0DD3
+#define GL_TEXTURE_1D                     0x0DE0
+#define GL_TEXTURE_2D                     0x0DE1
+#define GL_FEEDBACK_BUFFER_POINTER        0x0DF0
+#define GL_FEEDBACK_BUFFER_SIZE           0x0DF1
+#define GL_FEEDBACK_BUFFER_TYPE           0x0DF2
+#define GL_SELECTION_BUFFER_POINTER       0x0DF3
+#define GL_SELECTION_BUFFER_SIZE          0x0DF4
+
+/* GetTextureParameter */
+#define GL_TEXTURE_WIDTH                  0x1000
+#define GL_TEXTURE_HEIGHT                 0x1001
+#define GL_TEXTURE_INTERNAL_FORMAT        0x1003
+#define GL_TEXTURE_BORDER_COLOR           0x1004
+#define GL_TEXTURE_BORDER                 0x1005
+
+/* HintMode */
+#define GL_DONT_CARE                      0x1100
+#define GL_FASTEST                        0x1101
+#define GL_NICEST                         0x1102
+
+/* LightName */
+#define GL_LIGHT0                         0x4000
+#define GL_LIGHT1                         0x4001
+#define GL_LIGHT2                         0x4002
+#define GL_LIGHT3                         0x4003
+#define GL_LIGHT4                         0x4004
+#define GL_LIGHT5                         0x4005
+#define GL_LIGHT6                         0x4006
+#define GL_LIGHT7                         0x4007
+
+/* LightParameter */
+#define GL_AMBIENT                        0x1200
+#define GL_DIFFUSE                        0x1201
+#define GL_SPECULAR                       0x1202
+#define GL_POSITION                       0x1203
+#define GL_SPOT_DIRECTION                 0x1204
+#define GL_SPOT_EXPONENT                  0x1205
+#define GL_SPOT_CUTOFF                    0x1206
+#define GL_CONSTANT_ATTENUATION           0x1207
+#define GL_LINEAR_ATTENUATION             0x1208
+#define GL_QUADRATIC_ATTENUATION          0x1209
+
+/* ListMode */
+#define GL_COMPILE                        0x1300
+#define GL_COMPILE_AND_EXECUTE            0x1301
+
+/* LogicOp */
+#define GL_CLEAR                          0x1500
+#define GL_AND                            0x1501
+#define GL_AND_REVERSE                    0x1502
+#define GL_COPY                           0x1503
+#define GL_AND_INVERTED                   0x1504
+#define GL_NOOP                           0x1505
+#define GL_XOR                            0x1506
+#define GL_OR                             0x1507
+#define GL_NOR                            0x1508
+#define GL_EQUIV                          0x1509
+#define GL_INVERT                         0x150A
+#define GL_OR_REVERSE                     0x150B
+#define GL_COPY_INVERTED                  0x150C
+#define GL_OR_INVERTED                    0x150D
+#define GL_NAND                           0x150E
+#define GL_SET                            0x150F
+
+/* MaterialParameter */
+#define GL_EMISSION                       0x1600
+#define GL_SHININESS                      0x1601
+#define GL_AMBIENT_AND_DIFFUSE            0x1602
+#define GL_COLOR_INDEXES                  0x1603
+
+/* MatrixMode */
+#define GL_MODELVIEW                      0x1700
+#define GL_PROJECTION                     0x1701
+#define GL_TEXTURE0						  0x1702
+#define GL_TEXTURE1                       0x1703
+#define GL_TEXTURE2                       0x1704
+#define GL_TEXTURE3                       0x1705
+
+/* PixelCopyType */
+#define GL_COLOR                          0x1800
+#define GL_DEPTH                          0x1801
+#define GL_STENCIL                        0x1802
+
+/* PixelFormat */
+#define GL_COLOR_INDEX                    0x1900
+#define GL_STENCIL_INDEX                  0x1901
+#define GL_DEPTH_COMPONENT                0x1902
+#define GL_RED                            0x1903
+#define GL_GREEN                          0x1904
+#define GL_BLUE                           0x1905
+#define GL_ALPHA                          0x1906
+#define GL_RGB                            0x1907
+#define GL_RGBA                           0x1908
+#define GL_LUMINANCE                      0x1909
+#define GL_LUMINANCE_ALPHA                0x190A
+
+/* PixelType */
+#define GL_BITMAP                         0x1A00
+
+/* PolygonMode */
+#define GL_POINT                          0x1B00
+#define GL_LINE                           0x1B01
+#define GL_FILL                           0x1B02
+
+/* RenderingMode */
+#define GL_RENDER                         0x1C00
+#define GL_FEEDBACK                       0x1C01
+#define GL_SELECT                         0x1C02
+
+/* ShadingModel */
+#define GL_FLAT                           0x1D00
+#define GL_SMOOTH                         0x1D01
+
+/* StencilOp */
+/*      GL_ZERO */
+#define GL_KEEP                           0x1E00
+#define GL_REPLACE                        0x1E01
+#define GL_INCR                           0x1E02
+#define GL_DECR                           0x1E03
+/*      GL_INVERT */
+
+/* StringName */
+#define GL_VENDOR                         0x1F00
+#define GL_RENDERER                       0x1F01
+#define GL_VERSION                        0x1F02
+#define GL_EXTENSIONS                     0x1F03
+
+/* TextureCoordName */
+#define GL_S                              0x2000
+#define GL_T                              0x2001
+#define GL_R                              0x2002
+#define GL_Q                              0x2003
+
+/* TextureEnvMode */
+#define GL_MODULATE                       0x2100
+#define GL_DECAL                          0x2101
+
+/* TextureEnvParameter */
+#define GL_TEXTURE_ENV_MODE               0x2200
+#define GL_TEXTURE_ENV_COLOR              0x2201
+
+/* TextureEnvTarget */
+#define GL_TEXTURE_ENV                    0x2300
+
+/* TextureGenMode */
+#define GL_EYE_LINEAR                     0x2400
+#define GL_OBJECT_LINEAR                  0x2401
+#define GL_SPHERE_MAP                     0x2402
+
+/* TextureGenParameter */
+#define GL_TEXTURE_GEN_MODE               0x2500
+#define GL_OBJECT_PLANE                   0x2501
+#define GL_EYE_PLANE                      0x2502
+
+/* TextureMagFilter */
+#define GL_NEAREST                        0x2600
+#define GL_LINEAR                         0x2601
+
+/* TextureMinFilter */
+#define GL_NEAREST_MIPMAP_NEAREST         0x2700
+#define GL_LINEAR_MIPMAP_NEAREST          0x2701
+#define GL_NEAREST_MIPMAP_LINEAR          0x2702
+#define GL_LINEAR_MIPMAP_LINEAR           0x2703
+
+/* TextureParameterName */
+#define GL_TEXTURE_MAG_FILTER             0x2800
+#define GL_TEXTURE_MIN_FILTER             0x2801
+#define GL_TEXTURE_WRAP_S                 0x2802
+#define GL_TEXTURE_WRAP_T                 0x2803
+
+// PORT: Anisotropy stuff
+#define GL_TEXTURE_MAX_ANISOTROPY_EXT     0x84FE
+#define GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT 0x84FF
+
+//PORT - TPL stuff
+#define GL_TPL4_EXT                       0x9991
+#define GL_TPL8_EXT                       0x9992
+#define GL_TPL16_EXT                      0x9993
+#define GL_TPL32_EXT                      0x9994
+
+// PORT: DDS Stuff
+#define GL_DDS_RGBA_EXT                   0x9998
+#define GL_RGB_SWIZZLE_EXT				  0x9999
+
+/* TextureWrapMode */
+#define GL_CLAMP                          0x2900
+#define GL_REPEAT                         0x2901
+
+/* ClientAttribMask */
+#define GL_CLIENT_PIXEL_STORE_BIT         0x00000001
+#define GL_CLIENT_VERTEX_ARRAY_BIT        0x00000002
+#define GL_CLIENT_ALL_ATTRIB_BITS         0xffffffff
+
+/* polygon_offset */
+#define GL_POLYGON_OFFSET_FACTOR          0x8038
+#define GL_POLYGON_OFFSET_UNITS           0x2A00
+#define GL_POLYGON_OFFSET_POINT           0x2A01
+#define GL_POLYGON_OFFSET_LINE            0x2A02
+#define GL_POLYGON_OFFSET_FILL            0x8037
+
+/* texture */
+#define GL_ALPHA4                         0x803B
+#define GL_ALPHA8                         0x803C
+#define GL_ALPHA12                        0x803D
+#define GL_ALPHA16                        0x803E
+#define GL_LUMINANCE4                     0x803F
+#define GL_LUMINANCE8                     0x8040
+#define GL_LUMINANCE12                    0x8041
+#define GL_LUMINANCE16                    0x8042
+#define GL_LUMINANCE4_ALPHA4              0x8043
+#define GL_LUMINANCE6_ALPHA2              0x8044
+#define GL_LUMINANCE8_ALPHA8              0x8045
+#define GL_LUMINANCE12_ALPHA4             0x8046
+#define GL_LUMINANCE12_ALPHA12            0x8047
+#define GL_LUMINANCE16_ALPHA16            0x8048
+#define GL_INTENSITY                      0x8049
+#define GL_INTENSITY4                     0x804A
+#define GL_INTENSITY8                     0x804B
+#define GL_INTENSITY12                    0x804C
+#define GL_INTENSITY16                    0x804D
+#define GL_R3_G3_B2                       0x2A10
+#define GL_RGB4                           0x804F
+#define GL_RGB5                           0x8050
+#define GL_RGB8                           0x8051
+#define GL_RGB10                          0x8052
+#define GL_RGB12                          0x8053
+#define GL_RGB16                          0x8054
+#define GL_RGBA2                          0x8055
+#define GL_RGBA4                          0x8056
+#define GL_RGB5_A1                        0x8057
+#define GL_RGBA8                          0x8058
+#define GL_RGB10_A2                       0x8059
+#define GL_RGBA12                         0x805A
+#define GL_RGBA16                         0x805B
+#define GL_TEXTURE_RED_SIZE               0x805C
+#define GL_TEXTURE_GREEN_SIZE             0x805D
+#define GL_TEXTURE_BLUE_SIZE              0x805E
+#define GL_TEXTURE_ALPHA_SIZE             0x805F
+#define GL_TEXTURE_LUMINANCE_SIZE         0x8060
+#define GL_TEXTURE_INTENSITY_SIZE         0x8061
+#define GL_PROXY_TEXTURE_1D               0x8063
+#define GL_PROXY_TEXTURE_2D               0x8064
+
+/* texture_object */
+#define GL_TEXTURE_PRIORITY               0x8066
+#define GL_TEXTURE_RESIDENT               0x8067
+#define GL_TEXTURE_BINDING_1D             0x8068
+#define GL_TEXTURE_BINDING_2D             0x8069
+
+/* vertex_array */
+#define GL_VERTEX_ARRAY                   0x8074
+#define GL_NORMAL_ARRAY                   0x8075
+#define GL_COLOR_ARRAY                    0x8076
+#define GL_INDEX_ARRAY                    0x8077
+#define GL_TEXTURE_COORD_ARRAY            0x8078
+#define GL_EDGE_FLAG_ARRAY                0x8079
+#define GL_VERTEX_ARRAY_SIZE              0x807A
+#define GL_VERTEX_ARRAY_TYPE              0x807B
+#define GL_VERTEX_ARRAY_STRIDE            0x807C
+#define GL_NORMAL_ARRAY_TYPE              0x807E
+#define GL_NORMAL_ARRAY_STRIDE            0x807F
+#define GL_COLOR_ARRAY_SIZE               0x8081
+#define GL_COLOR_ARRAY_TYPE               0x8082
+#define GL_COLOR_ARRAY_STRIDE             0x8083
+#define GL_INDEX_ARRAY_TYPE               0x8085
+#define GL_INDEX_ARRAY_STRIDE             0x8086
+#define GL_TEXTURE_COORD_ARRAY_SIZE       0x8088
+#define GL_TEXTURE_COORD_ARRAY_TYPE       0x8089
+#define GL_TEXTURE_COORD_ARRAY_STRIDE     0x808A
+#define GL_EDGE_FLAG_ARRAY_STRIDE         0x808C
+#define GL_VERTEX_ARRAY_POINTER           0x808E
+#define GL_NORMAL_ARRAY_POINTER           0x808F
+#define GL_COLOR_ARRAY_POINTER            0x8090
+#define GL_INDEX_ARRAY_POINTER            0x8091
+#define GL_TEXTURE_COORD_ARRAY_POINTER    0x8092
+#define GL_EDGE_FLAG_ARRAY_POINTER        0x8093
+#define GL_V2F                            0x2A20
+#define GL_V3F                            0x2A21
+#define GL_C4UB_V2F                       0x2A22
+#define GL_C4UB_V3F                       0x2A23
+#define GL_C3F_V3F                        0x2A24
+#define GL_N3F_V3F                        0x2A25
+#define GL_C4F_N3F_V3F                    0x2A26
+#define GL_T2F_V3F                        0x2A27
+#define GL_T4F_V4F                        0x2A28
+#define GL_T2F_C4UB_V3F                   0x2A29
+#define GL_T2F_C3F_V3F                    0x2A2A
+#define GL_T2F_N3F_V3F                    0x2A2B
+#define GL_T2F_C4F_N3F_V3F                0x2A2C
+#define GL_T4F_C4F_N3F_V4F                0x2A2D
+
+/* Extensions */
+#define GL_EXT_vertex_array               1
+#define GL_EXT_bgra                       1
+#define GL_EXT_paletted_texture           1
+
+/* EXT_vertex_array */
+#define GL_VERTEX_ARRAY_EXT               0x8074
+#define GL_NORMAL_ARRAY_EXT               0x8075
+#define GL_COLOR_ARRAY_EXT                0x8076
+#define GL_INDEX_ARRAY_EXT                0x8077
+#define GL_TEXTURE_COORD_ARRAY_EXT        0x8078
+#define GL_EDGE_FLAG_ARRAY_EXT            0x8079
+#define GL_VERTEX_ARRAY_SIZE_EXT          0x807A
+#define GL_VERTEX_ARRAY_TYPE_EXT          0x807B
+#define GL_VERTEX_ARRAY_STRIDE_EXT        0x807C
+#define GL_VERTEX_ARRAY_COUNT_EXT         0x807D
+#define GL_NORMAL_ARRAY_TYPE_EXT          0x807E
+#define GL_NORMAL_ARRAY_STRIDE_EXT        0x807F
+#define GL_NORMAL_ARRAY_COUNT_EXT         0x8080
+#define GL_COLOR_ARRAY_SIZE_EXT           0x8081
+#define GL_COLOR_ARRAY_TYPE_EXT           0x8082
+#define GL_COLOR_ARRAY_STRIDE_EXT         0x8083
+#define GL_COLOR_ARRAY_COUNT_EXT          0x8084
+#define GL_INDEX_ARRAY_TYPE_EXT           0x8085
+#define GL_INDEX_ARRAY_STRIDE_EXT         0x8086
+#define GL_INDEX_ARRAY_COUNT_EXT          0x8087
+#define GL_TEXTURE_COORD_ARRAY_SIZE_EXT   0x8088
+#define GL_TEXTURE_COORD_ARRAY_TYPE_EXT   0x8089
+#define GL_TEXTURE_COORD_ARRAY_STRIDE_EXT 0x808A
+#define GL_TEXTURE_COORD_ARRAY_COUNT_EXT  0x808B
+#define GL_EDGE_FLAG_ARRAY_STRIDE_EXT     0x808C
+#define GL_EDGE_FLAG_ARRAY_COUNT_EXT      0x808D
+#define GL_VERTEX_ARRAY_POINTER_EXT       0x808E
+#define GL_NORMAL_ARRAY_POINTER_EXT       0x808F
+#define GL_COLOR_ARRAY_POINTER_EXT        0x8090
+#define GL_INDEX_ARRAY_POINTER_EXT        0x8091
+#define GL_TEXTURE_COORD_ARRAY_POINTER_EXT 0x8092
+#define GL_EDGE_FLAG_ARRAY_POINTER_EXT    0x8093
+#define GL_DOUBLE_EXT                     GL_DOUBLE
+
+/* EXT_bgra */
+#define GL_BGR_EXT                        0x80E0
+#define GL_BGRA_EXT                       0x80E1
+
+/* EXT_paletted_texture */
+
+/* These must match the GL_COLOR_TABLE_*_SGI enumerants */
+#define GL_COLOR_TABLE_FORMAT_EXT         0x80D8
+#define GL_COLOR_TABLE_WIDTH_EXT          0x80D9
+#define GL_COLOR_TABLE_RED_SIZE_EXT       0x80DA
+#define GL_COLOR_TABLE_GREEN_SIZE_EXT     0x80DB
+#define GL_COLOR_TABLE_BLUE_SIZE_EXT      0x80DC
+#define GL_COLOR_TABLE_ALPHA_SIZE_EXT     0x80DD
+#define GL_COLOR_TABLE_LUMINANCE_SIZE_EXT 0x80DE
+#define GL_COLOR_TABLE_INTENSITY_SIZE_EXT 0x80DF
+
+#define GL_COLOR_INDEX1_EXT               0x80E2
+#define GL_COLOR_INDEX2_EXT               0x80E3
+#define GL_COLOR_INDEX4_EXT               0x80E4
+#define GL_COLOR_INDEX8_EXT               0x80E5
+#define GL_COLOR_INDEX12_EXT              0x80E6
+#define GL_COLOR_INDEX16_EXT              0x80E7
+
+// VVFIXME New Constants from Jedi
+#define GL_VSYNC                          0x813F
+#define GL_DDS_RGB16_EXT                  0x9997
+#define GL_DDS_RGBA32_EXT                 0x9998
+#define GL_RGB_SWIZZLE_EXT                0x9999
+
+//	VVFIXME - New constants for linear format textures.
+// These numbers are just made up. This is awful.
+#define GL_LIN_RGBA8	0x8E01
+#define GL_LIN_RGBA		0x8E02
+#define GL_LIN_RGB8		0x8E03
+#define GL_LIN_RGB		0x8E04
+
+//===========================================================================
+
+/*
+** multitexture extension definitions
+*/
+#define GL_ACTIVE_TEXTURE_ARB               0x84E0
+#define GL_CLIENT_ACTIVE_TEXTURE_ARB        0x84E1
+#define GL_MAX_ACTIVE_TEXTURES_ARB          0x84E2
+
+#define GL_TEXTURE0_ARB                     0x84C0
+#define GL_TEXTURE1_ARB                     0x84C1
+#define GL_TEXTURE2_ARB                     0x84C2
+#define GL_TEXTURE3_ARB                     0x84C3
+
+typedef void ( * PFNGLMULTITEXCOORD1DARBPROC) (GLenum target, GLdouble s);
+typedef void ( * PFNGLMULTITEXCOORD1DVARBPROC) (GLenum target, const GLdouble *v);
+typedef void ( * PFNGLMULTITEXCOORD1FARBPROC) (GLenum target, GLfloat s);
+typedef void ( * PFNGLMULTITEXCOORD1FVARBPROC) (GLenum target, const GLfloat *v);
+typedef void ( * PFNGLMULTITEXCOORD1IARBPROC) (GLenum target, GLint s);
+typedef void ( * PFNGLMULTITEXCOORD1IVARBPROC) (GLenum target, const GLint *v);
+typedef void ( * PFNGLMULTITEXCOORD1SARBPROC) (GLenum target, GLshort s);
+typedef void ( * PFNGLMULTITEXCOORD1SVARBPROC) (GLenum target, const GLshort *v);
+typedef void ( * PFNGLMULTITEXCOORD2DARBPROC) (GLenum target, GLdouble s, GLdouble t);
+typedef void ( * PFNGLMULTITEXCOORD2DVARBPROC) (GLenum target, const GLdouble *v);
+typedef void ( * PFNGLMULTITEXCOORD2FARBPROC) (GLenum target, GLfloat s, GLfloat t);
+typedef void ( * PFNGLMULTITEXCOORD2FVARBPROC) (GLenum target, const GLfloat *v);
+typedef void ( * PFNGLMULTITEXCOORD2IARBPROC) (GLenum target, GLint s, GLint t);
+typedef void ( * PFNGLMULTITEXCOORD2IVARBPROC) (GLenum target, const GLint *v);
+typedef void ( * PFNGLMULTITEXCOORD2SARBPROC) (GLenum target, GLshort s, GLshort t);
+typedef void ( * PFNGLMULTITEXCOORD2SVARBPROC) (GLenum target, const GLshort *v);
+typedef void ( * PFNGLMULTITEXCOORD3DARBPROC) (GLenum target, GLdouble s, GLdouble t, GLdouble r);
+typedef void ( * PFNGLMULTITEXCOORD3DVARBPROC) (GLenum target, const GLdouble *v);
+typedef void ( * PFNGLMULTITEXCOORD3FARBPROC) (GLenum target, GLfloat s, GLfloat t, GLfloat r);
+typedef void ( * PFNGLMULTITEXCOORD3FVARBPROC) (GLenum target, const GLfloat *v);
+typedef void ( * PFNGLMULTITEXCOORD3IARBPROC) (GLenum target, GLint s, GLint t, GLint r);
+typedef void ( * PFNGLMULTITEXCOORD3IVARBPROC) (GLenum target, const GLint *v);
+typedef void ( * PFNGLMULTITEXCOORD3SARBPROC) (GLenum target, GLshort s, GLshort t, GLshort r);
+typedef void ( * PFNGLMULTITEXCOORD3SVARBPROC) (GLenum target, const GLshort *v);
+typedef void ( * PFNGLMULTITEXCOORD4DARBPROC) (GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q);
+typedef void ( * PFNGLMULTITEXCOORD4DVARBPROC) (GLenum target, const GLdouble *v);
+typedef void ( * PFNGLMULTITEXCOORD4FARBPROC) (GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q);
+typedef void ( * PFNGLMULTITEXCOORD4FVARBPROC) (GLenum target, const GLfloat *v);
+typedef void ( * PFNGLMULTITEXCOORD4IARBPROC) (GLenum target, GLint s, GLint t, GLint r, GLint q);
+typedef void ( * PFNGLMULTITEXCOORD4IVARBPROC) (GLenum target, const GLint *v);
+typedef void ( * PFNGLMULTITEXCOORD4SARBPROC) (GLenum target, GLshort s, GLshort t, GLshort r, GLshort q);
+typedef void ( * PFNGLMULTITEXCOORD4SVARBPROC) (GLenum target, const GLshort *v);
+typedef void ( * PFNGLACTIVETEXTUREARBPROC) (GLenum target);
+typedef void ( * PFNGLCLIENTACTIVETEXTUREARBPROC) (GLenum target);
+
+/*
+** extension constants
+*/
+extern	void ( * qglMultiTexCoord2fARB )( GLenum texture, GLfloat s, GLfloat t );
+extern	void ( * qglActiveTextureARB )( GLenum texture );
+extern	void ( * qglClientActiveTextureARB )( GLenum texture );
+
+extern	void ( * qglLockArraysEXT) (GLint, GLint);
+extern	void ( * qglUnlockArraysEXT) (void);
+
+//----(SA)	from Raven
+extern	void ( * qglPointParameterfEXT)( GLenum, GLfloat);
+extern	void ( * qglPointParameterfvEXT)( GLenum, GLfloat *);
+//----(SA)	end
+
+
+
+// S3TC compression constants
+#define GL_RGB_S3TC							0x83A0
+#define GL_RGB4_S3TC						0x83A1
+// More, grabbed from wolf code PORT
+#define	GL_COMPRESSED_RGB_S3TC_DXT1_EXT                   0x83F0
+#define	GL_COMPRESSED_RGBA_S3TC_DXT1_EXT                  0x83F1
+#define	GL_COMPRESSED_RGBA_S3TC_DXT3_EXT                  0x83F2
+#define	GL_COMPRESSED_RGBA_S3TC_DXT5_EXT                  0x83F3
+
+// And more, also from old wolf code:
+// GR - update enumerants
+#define GL_PN_TRIANGLES_ATI							0x87F0
+#define GL_MAX_PN_TRIANGLES_TESSELATION_LEVEL_ATI	0x87F1
+#define GL_PN_TRIANGLES_POINT_MODE_ATI				0x87F2
+#define GL_PN_TRIANGLES_NORMAL_MODE_ATI				0x87F3
+#define GL_PN_TRIANGLES_TESSELATION_LEVEL_ATI		0x87F4
+#define GL_PN_TRIANGLES_POINT_MODE_LINEAR_ATI		0x87F5
+#define GL_PN_TRIANGLES_POINT_MODE_CUBIC_ATI		0x87F6
+#define GL_PN_TRIANGLES_NORMAL_MODE_LINEAR_ATI		0x87F7
+#define GL_PN_TRIANGLES_NORMAL_MODE_QUADRATIC_ATI	0x87F8
+
+extern	void ( * qglPNTrianglesiATI)(GLenum pname, GLint param);
+extern	void ( * qglPNTrianglesfATI)(GLenum pname, GLfloat param);
+
+#define GL_FOG_DISTANCE_MODE_NV           0x855A
+#define GL_EYE_RADIAL_NV                  0x855B
+#define GL_EYE_PLANE_ABSOLUTE_NV          0x855C
+
+//===========================================================================
+
+
+extern  void ( * qglAccum )(GLenum op, GLfloat value);
+extern  void ( * qglAlphaFunc )(GLenum func, GLclampf ref);
+extern  GLboolean ( * qglAreTexturesResident )(GLsizei n, const GLuint *textures, GLboolean *residences);
+extern  void ( * qglArrayElement )(GLint i);
+extern  void ( * qglBegin )(GLenum mode);
+extern  void ( * qglBeginEXT )(GLenum mode, GLint verts, GLint colors, GLint normals, GLint tex0, GLint tex1);//, GLint tex2, GLint tex3);
+extern  GLboolean ( * qglBeginFrame )(void);
+extern  void ( * qglBeginShadow )(void);
+extern  void ( * qglBindTexture )(GLenum target, GLuint texture);
+extern  void ( * qglBitmap )(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap);
+extern  void ( * qglBlendFunc )(GLenum sfactor, GLenum dfactor);
+extern  void ( * qglCallList )(GLuint list);
+extern  void ( * qglCallLists )(GLsizei n, GLenum type, const GLvoid *lists);
+extern  void ( * qglClear )(GLbitfield mask);
+extern  void ( * qglClearAccum )(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
+extern  void ( * qglClearColor )(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
+extern  void ( * qglClearDepth )(GLclampd depth);
+extern  void ( * qglClearIndex )(GLfloat c);
+extern  void ( * qglClearStencil )(GLint s);
+extern  void ( * qglClipPlane )(GLenum plane, const GLdouble *equation);
+extern  void ( * qglColor3b )(GLbyte red, GLbyte green, GLbyte blue);
+extern  void ( * qglColor3bv )(const GLbyte *v);
+extern  void ( * qglColor3d )(GLdouble red, GLdouble green, GLdouble blue);
+extern  void ( * qglColor3dv )(const GLdouble *v);
+extern  void ( * qglColor3f )(GLfloat red, GLfloat green, GLfloat blue);
+extern  void ( * qglColor3fv )(const GLfloat *v);
+extern  void ( * qglColor3i )(GLint red, GLint green, GLint blue);
+extern  void ( * qglColor3iv )(const GLint *v);
+extern  void ( * qglColor3s )(GLshort red, GLshort green, GLshort blue);
+extern  void ( * qglColor3sv )(const GLshort *v);
+extern  void ( * qglColor3ub )(GLubyte red, GLubyte green, GLubyte blue);
+extern  void ( * qglColor3ubv )(const GLubyte *v);
+extern  void ( * qglColor3ui )(GLuint red, GLuint green, GLuint blue);
+extern  void ( * qglColor3uiv )(const GLuint *v);
+extern  void ( * qglColor3us )(GLushort red, GLushort green, GLushort blue);
+extern  void ( * qglColor3usv )(const GLushort *v);
+extern  void ( * qglColor4b )(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha);
+extern  void ( * qglColor4bv )(const GLbyte *v);
+extern  void ( * qglColor4d )(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha);
+extern  void ( * qglColor4dv )(const GLdouble *v);
+extern  void ( * qglColor4f )(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
+extern  void ( * qglColor4fv )(const GLfloat *v);
+extern  void ( * qglColor4i )(GLint red, GLint green, GLint blue, GLint alpha);
+extern  void ( * qglColor4iv )(const GLint *v);
+extern  void ( * qglColor4s )(GLshort red, GLshort green, GLshort blue, GLshort alpha);
+extern  void ( * qglColor4sv )(const GLshort *v);
+extern  void ( * qglColor4ub )(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha);
+extern  void ( * qglColor4ubv )(const GLubyte *v);
+extern  void ( * qglColor4ui )(GLuint red, GLuint green, GLuint blue, GLuint alpha);
+extern  void ( * qglColor4uiv )(const GLuint *v);
+extern  void ( * qglColor4us )(GLushort red, GLushort green, GLushort blue, GLushort alpha);
+extern  void ( * qglColor4usv )(const GLushort *v);
+extern  void ( * qglColorMask )(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
+extern  void ( * qglColorMaterial )(GLenum face, GLenum mode);
+extern  void ( * qglColorPointer )(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
+extern  void ( * qglCopyPixels )(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type);
+extern  void ( * qglCopyTexImage1D )(GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border);
+extern  void ( * qglCopyTexImage2D )(GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
+extern  void ( * qglCopyTexSubImage1D )(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);
+extern  void ( * qglCopyTexSubImage2D )(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
+extern  void ( * qglCullFace )(GLenum mode);
+extern  void ( * qglDeleteLists )(GLuint list, GLsizei range);
+extern  void ( * qglDeleteTextures )(GLsizei n, const GLuint *textures);
+extern  void ( * qglDepthFunc )(GLenum func);
+extern  void ( * qglDepthMask )(GLboolean flag);
+extern  void ( * qglDepthRange )(GLclampd zNear, GLclampd zFar);
+extern  void ( * qglDisable )(GLenum cap);
+extern  void ( * qglDisableClientState )(GLenum array);
+extern  void ( * qglDrawArrays )(GLenum mode, GLint first, GLsizei count);
+extern  void ( * qglDrawBuffer )(GLenum mode);
+extern  void ( * qglDrawElements )(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices);
+extern  void ( * qglDrawPixels )(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
+extern  void ( * qglEdgeFlag )(GLboolean flag);
+extern  void ( * qglEdgeFlagPointer )(GLsizei stride, const GLvoid *pointer);
+extern  void ( * qglEdgeFlagv )(const GLboolean *flag);
+extern  void ( * qglEnable )(GLenum cap);
+extern  void ( * qglEnableClientState )(GLenum array);
+extern  void ( * qglEnd )(void);
+extern  void ( * qglEndFrame )(void);
+extern  void ( * qglEndShadow )(void);
+extern  void ( * qglEndList )(void);
+extern  void ( * qglEvalCoord1d )(GLdouble u);
+extern  void ( * qglEvalCoord1dv )(const GLdouble *u);
+extern  void ( * qglEvalCoord1f )(GLfloat u);
+extern  void ( * qglEvalCoord1fv )(const GLfloat *u);
+extern  void ( * qglEvalCoord2d )(GLdouble u, GLdouble v);
+extern  void ( * qglEvalCoord2dv )(const GLdouble *u);
+extern  void ( * qglEvalCoord2f )(GLfloat u, GLfloat v);
+extern  void ( * qglEvalCoord2fv )(const GLfloat *u);
+extern  void ( * qglEvalMesh1 )(GLenum mode, GLint i1, GLint i2);
+extern  void ( * qglEvalMesh2 )(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2);
+extern  void ( * qglEvalPoint1 )(GLint i);
+extern  void ( * qglEvalPoint2 )(GLint i, GLint j);
+extern  void ( * qglFeedbackBuffer )(GLsizei size, GLenum type, GLfloat *buffer);
+extern  void ( * qglFinish )(void);
+extern  void ( * qglFlush )(void);
+extern  void ( * qglFlushShadow )(void);
+extern  void ( * qglFogf )(GLenum pname, GLfloat param);
+extern  void ( * qglFogfv )(GLenum pname, const GLfloat *params);
+extern  void ( * qglFogi )(GLenum pname, GLint param);
+extern  void ( * qglFogiv )(GLenum pname, const GLint *params);
+extern  void ( * qglFrontFace )(GLenum mode);
+extern  void ( * qglFrustum )(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
+extern  GLuint ( * qglGenLists )(GLsizei range);
+extern  void ( * qglGenTextures )(GLsizei n, GLuint *textures);
+extern  void ( * qglGetBooleanv )(GLenum pname, GLboolean *params);
+extern  void ( * qglGetClipPlane )(GLenum plane, GLdouble *equation);
+extern  void ( * qglGetDoublev )(GLenum pname, GLdouble *params);
+extern  GLenum ( * qglGetError )(void);
+extern  void ( * qglGetFloatv )(GLenum pname, GLfloat *params);
+extern  void ( * qglGetIntegerv )(GLenum pname, GLint *params);
+extern  void ( * qglGetLightfv )(GLenum light, GLenum pname, GLfloat *params);
+extern  void ( * qglGetLightiv )(GLenum light, GLenum pname, GLint *params);
+extern  void ( * qglGetMapdv )(GLenum target, GLenum query, GLdouble *v);
+extern  void ( * qglGetMapfv )(GLenum target, GLenum query, GLfloat *v);
+extern  void ( * qglGetMapiv )(GLenum target, GLenum query, GLint *v);
+extern  void ( * qglGetMaterialfv )(GLenum face, GLenum pname, GLfloat *params);
+extern  void ( * qglGetMaterialiv )(GLenum face, GLenum pname, GLint *params);
+extern  void ( * qglGetPixelMapfv )(GLenum map, GLfloat *values);
+extern  void ( * qglGetPixelMapuiv )(GLenum map, GLuint *values);
+extern  void ( * qglGetPixelMapusv )(GLenum map, GLushort *values);
+extern  void ( * qglGetPointerv )(GLenum pname, GLvoid* *params);
+extern  void ( * qglGetPolygonStipple )(GLubyte *mask);
+extern  const GLubyte * ( * qglGetString )(GLenum name);
+extern  void ( * qglGetTexEnvfv )(GLenum target, GLenum pname, GLfloat *params);
+extern  void ( * qglGetTexEnviv )(GLenum target, GLenum pname, GLint *params);
+extern  void ( * qglGetTexGendv )(GLenum coord, GLenum pname, GLdouble *params);
+extern  void ( * qglGetTexGenfv )(GLenum coord, GLenum pname, GLfloat *params);
+extern  void ( * qglGetTexGeniv )(GLenum coord, GLenum pname, GLint *params);
+extern  void ( * qglGetTexImage )(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels);
+extern  void ( * qglGetTexLevelParameterfv )(GLenum target, GLint level, GLenum pname, GLfloat *params);
+extern  void ( * qglGetTexLevelParameteriv )(GLenum target, GLint level, GLenum pname, GLint *params);
+extern  void ( * qglGetTexParameterfv )(GLenum target, GLenum pname, GLfloat *params);
+extern  void ( * qglGetTexParameteriv )(GLenum target, GLenum pname, GLint *params);
+extern  void ( * qglHint )(GLenum target, GLenum mode);
+extern  void ( * qglIndexedTriToStrip )(GLsizei count, const GLushort *indices);
+extern  void ( * qglIndexMask )(GLuint mask);
+extern  void ( * qglIndexPointer )(GLenum type, GLsizei stride, const GLvoid *pointer);
+extern  void ( * qglIndexd )(GLdouble c);
+extern  void ( * qglIndexdv )(const GLdouble *c);
+extern  void ( * qglIndexf )(GLfloat c);
+extern  void ( * qglIndexfv )(const GLfloat *c);
+extern  void ( * qglIndexi )(GLint c);
+extern  void ( * qglIndexiv )(const GLint *c);
+extern  void ( * qglIndexs )(GLshort c);
+extern  void ( * qglIndexsv )(const GLshort *c);
+extern  void ( * qglIndexub )(GLubyte c);
+extern  void ( * qglIndexubv )(const GLubyte *c);
+extern  void ( * qglInitNames )(void);
+extern  void ( * qglInterleavedArrays )(GLenum format, GLsizei stride, const GLvoid *pointer);
+extern  GLboolean ( * qglIsEnabled )(GLenum cap);
+extern  GLboolean ( * qglIsList )(GLuint listArg);
+extern  GLboolean ( * qglIsTexture )(GLuint texture);
+extern  void ( * qglLightModelf )(GLenum pname, GLfloat param);
+extern  void ( * qglLightModelfv )(GLenum pname, const GLfloat *params);
+extern  void ( * qglLightModeli )(GLenum pname, GLint param);
+extern  void ( * qglLightModeliv )(GLenum pname, const GLint *params);
+extern  void ( * qglLightf )(GLenum light, GLenum pname, GLfloat param);
+extern  void ( * qglLightfv )(GLenum light, GLenum pname, const GLfloat *params);
+extern  void ( * qglLighti )(GLenum light, GLenum pname, GLint param);
+extern  void ( * qglLightiv )(GLenum light, GLenum pname, const GLint *params);
+extern  void ( * qglLineStipple )(GLint factor, GLushort pattern);
+extern  void ( * qglLineWidth )(GLfloat width);
+extern  void ( * qglListBase )(GLuint base);
+extern  void ( * qglLoadIdentity )(void);
+extern  void ( * qglLoadMatrixd )(const GLdouble *m);
+extern  void ( * qglLoadMatrixf )(const GLfloat *m);
+extern  void ( * qglLoadName )(GLuint name);
+extern  void ( * qglLogicOp )(GLenum opcode);
+extern  void ( * qglMap1d )(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points);
+extern  void ( * qglMap1f )(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points);
+extern  void ( * qglMap2d )(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points);
+extern  void ( * qglMap2f )(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points);
+extern  void ( * qglMapGrid1d )(GLint un, GLdouble u1, GLdouble u2);
+extern  void ( * qglMapGrid1f )(GLint un, GLfloat u1, GLfloat u2);
+extern  void ( * qglMapGrid2d )(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2);
+extern  void ( * qglMapGrid2f )(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2);
+extern  void ( * qglMaterialf )(GLenum face, GLenum pname, GLfloat param);
+extern  void ( * qglMaterialfv )(GLenum face, GLenum pname, const GLfloat *params);
+extern  void ( * qglMateriali )(GLenum face, GLenum pname, GLint param);
+extern  void ( * qglMaterialiv )(GLenum face, GLenum pname, const GLint *params);
+extern  void ( * qglMatrixMode )(GLenum mode);
+extern  void ( * qglMultMatrixd )(const GLdouble *m);
+extern  void ( * qglMultMatrixf )(const GLfloat *m);
+extern  void ( * qglNewList )(GLuint list, GLenum mode);
+extern  void ( * qglNormal3b )(GLbyte nx, GLbyte ny, GLbyte nz);
+extern  void ( * qglNormal3bv )(const GLbyte *v);
+extern  void ( * qglNormal3d )(GLdouble nx, GLdouble ny, GLdouble nz);
+extern  void ( * qglNormal3dv )(const GLdouble *v);
+extern  void ( * qglNormal3f )(GLfloat nx, GLfloat ny, GLfloat nz);
+extern  void ( * qglNormal3fv )(const GLfloat *v);
+extern  void ( * qglNormal3i )(GLint nx, GLint ny, GLint nz);
+extern  void ( * qglNormal3iv )(const GLint *v);
+extern  void ( * qglNormal3s )(GLshort nx, GLshort ny, GLshort nz);
+extern  void ( * qglNormal3sv )(const GLshort *v);
+extern  void ( * qglNormalPointer )(GLenum type, GLsizei stride, const GLvoid *pointer);
+extern  void ( * qglOrtho )(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
+extern  void ( * qglPassThrough )(GLfloat token);
+extern  void ( * qglPixelMapfv )(GLenum map, GLsizei mapsize, const GLfloat *values);
+extern  void ( * qglPixelMapuiv )(GLenum map, GLsizei mapsize, const GLuint *values);
+extern  void ( * qglPixelMapusv )(GLenum map, GLsizei mapsize, const GLushort *values);
+extern  void ( * qglPixelStoref )(GLenum pname, GLfloat param);
+extern  void ( * qglPixelStorei )(GLenum pname, GLint param);
+extern  void ( * qglPixelTransferf )(GLenum pname, GLfloat param);
+extern  void ( * qglPixelTransferi )(GLenum pname, GLint param);
+extern  void ( * qglPixelZoom )(GLfloat xfactor, GLfloat yfactor);
+extern  void ( * qglPointSize )(GLfloat size);
+extern  void ( * qglPolygonMode )(GLenum face, GLenum mode);
+extern  void ( * qglPolygonOffset )(GLfloat factor, GLfloat units);
+extern  void ( * qglPolygonStipple )(const GLubyte *mask);
+extern  void ( * qglPopAttrib )(void);
+extern  void ( * qglPopClientAttrib )(void);
+extern  void ( * qglPopMatrix )(void);
+extern  void ( * qglPopName )(void);
+extern  void ( * qglPrioritizeTextures )(GLsizei n, const GLuint *textures, const GLclampf *priorities);
+extern  void ( * qglPushAttrib )(GLbitfield mask);
+extern  void ( * qglPushClientAttrib )(GLbitfield mask);
+extern  void ( * qglPushMatrix )(void);
+extern  void ( * qglPushName )(GLuint name);
+extern  void ( * qglRasterPos2d )(GLdouble x, GLdouble y);
+extern  void ( * qglRasterPos2dv )(const GLdouble *v);
+extern  void ( * qglRasterPos2f )(GLfloat x, GLfloat y);
+extern  void ( * qglRasterPos2fv )(const GLfloat *v);
+extern  void ( * qglRasterPos2i )(GLint x, GLint y);
+extern  void ( * qglRasterPos2iv )(const GLint *v);
+extern  void ( * qglRasterPos2s )(GLshort x, GLshort y);
+extern  void ( * qglRasterPos2sv )(const GLshort *v);
+extern  void ( * qglRasterPos3d )(GLdouble x, GLdouble y, GLdouble z);
+extern  void ( * qglRasterPos3dv )(const GLdouble *v);
+extern  void ( * qglRasterPos3f )(GLfloat x, GLfloat y, GLfloat z);
+extern  void ( * qglRasterPos3fv )(const GLfloat *v);
+extern  void ( * qglRasterPos3i )(GLint x, GLint y, GLint z);
+extern  void ( * qglRasterPos3iv )(const GLint *v);
+extern  void ( * qglRasterPos3s )(GLshort x, GLshort y, GLshort z);
+extern  void ( * qglRasterPos3sv )(const GLshort *v);
+extern  void ( * qglRasterPos4d )(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+extern  void ( * qglRasterPos4dv )(const GLdouble *v);
+extern  void ( * qglRasterPos4f )(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+extern  void ( * qglRasterPos4fv )(const GLfloat *v);
+extern  void ( * qglRasterPos4i )(GLint x, GLint y, GLint z, GLint w);
+extern  void ( * qglRasterPos4iv )(const GLint *v);
+extern  void ( * qglRasterPos4s )(GLshort x, GLshort y, GLshort z, GLshort w);
+extern  void ( * qglRasterPos4sv )(const GLshort *v);
+extern  void ( * qglReadBuffer )(GLenum mode);
+extern  void ( * qglReadPixels )(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei twidth, GLsizei theight, GLvoid *pixels);
+extern  void ( * qglCopyBackBufferToTexEXT )(float width, float height, float u1, float v1, float u2, float v2);
+extern	void ( * qglCopyBackBufferToTex )(void);
+extern  void ( * qglRectd )(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2);
+extern  void ( * qglRectdv )(const GLdouble *v1, const GLdouble *v2);
+extern  void ( * qglRectf )(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2);
+extern  void ( * qglRectfv )(const GLfloat *v1, const GLfloat *v2);
+extern  void ( * qglRecti )(GLint x1, GLint y1, GLint x2, GLint y2);
+extern  void ( * qglRectiv )(const GLint *v1, const GLint *v2);
+extern  void ( * qglRects )(GLshort x1, GLshort y1, GLshort x2, GLshort y2);
+extern  void ( * qglRectsv )(const GLshort *v1, const GLshort *v2);
+extern  GLint ( * qglRenderMode )(GLenum mode);
+extern  void ( * qglRotated )(GLdouble angle, GLdouble x, GLdouble y, GLdouble z);
+extern  void ( * qglRotatef )(GLfloat angle, GLfloat x, GLfloat y, GLfloat z);
+extern  void ( * qglScaled )(GLdouble x, GLdouble y, GLdouble z);
+extern  void ( * qglScalef )(GLfloat x, GLfloat y, GLfloat z);
+extern  void ( * qglScissor )(GLint x, GLint y, GLsizei width, GLsizei height);
+extern  void ( * qglSelectBuffer )(GLsizei size, GLuint *buffer);
+extern  void ( * qglShadeModel )(GLenum mode);
+extern  void ( * qglStencilFunc )(GLenum func, GLint ref, GLuint mask);
+extern  void ( * qglStencilMask )(GLuint mask);
+extern  void ( * qglStencilOp )(GLenum fail, GLenum zfail, GLenum zpass);
+extern  void ( * qglTexCoord1d )(GLdouble s);
+extern  void ( * qglTexCoord1dv )(const GLdouble *v);
+extern  void ( * qglTexCoord1f )(GLfloat s);
+extern  void ( * qglTexCoord1fv )(const GLfloat *v);
+extern  void ( * qglTexCoord1i )(GLint s);
+extern  void ( * qglTexCoord1iv )(const GLint *v);
+extern  void ( * qglTexCoord1s )(GLshort s);
+extern  void ( * qglTexCoord1sv )(const GLshort *v);
+extern  void ( * qglTexCoord2d )(GLdouble s, GLdouble t);
+extern  void ( * qglTexCoord2dv )(const GLdouble *v);
+extern  void ( * qglTexCoord2f )(GLfloat s, GLfloat t);
+extern  void ( * qglTexCoord2fv )(const GLfloat *v);
+extern  void ( * qglTexCoord2i )(GLint s, GLint t);
+extern  void ( * qglTexCoord2iv )(const GLint *v);
+extern  void ( * qglTexCoord2s )(GLshort s, GLshort t);
+extern  void ( * qglTexCoord2sv )(const GLshort *v);
+extern  void ( * qglTexCoord3d )(GLdouble s, GLdouble t, GLdouble r);
+extern  void ( * qglTexCoord3dv )(const GLdouble *v);
+extern  void ( * qglTexCoord3f )(GLfloat s, GLfloat t, GLfloat r);
+extern  void ( * qglTexCoord3fv )(const GLfloat *v);
+extern  void ( * qglTexCoord3i )(GLint s, GLint t, GLint r);
+extern  void ( * qglTexCoord3iv )(const GLint *v);
+extern  void ( * qglTexCoord3s )(GLshort s, GLshort t, GLshort r);
+extern  void ( * qglTexCoord3sv )(const GLshort *v);
+extern  void ( * qglTexCoord4d )(GLdouble s, GLdouble t, GLdouble r, GLdouble q);
+extern  void ( * qglTexCoord4dv )(const GLdouble *v);
+extern  void ( * qglTexCoord4f )(GLfloat s, GLfloat t, GLfloat r, GLfloat q);
+extern  void ( * qglTexCoord4fv )(const GLfloat *v);
+extern  void ( * qglTexCoord4i )(GLint s, GLint t, GLint r, GLint q);
+extern  void ( * qglTexCoord4iv )(const GLint *v);
+extern  void ( * qglTexCoord4s )(GLshort s, GLshort t, GLshort r, GLshort q);
+extern  void ( * qglTexCoord4sv )(const GLshort *v);
+extern  void ( * qglTexCoordPointer )(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
+extern  void ( * qglTexEnvf )(GLenum target, GLenum pname, GLfloat param);
+extern  void ( * qglTexEnvfv )(GLenum target, GLenum pname, const GLfloat *params);
+extern  void ( * qglTexEnvi )(GLenum target, GLenum pname, GLint param);
+extern  void ( * qglTexEnviv )(GLenum target, GLenum pname, const GLint *params);
+extern  void ( * qglTexGend )(GLenum coord, GLenum pname, GLdouble param);
+extern  void ( * qglTexGendv )(GLenum coord, GLenum pname, const GLdouble *params);
+extern  void ( * qglTexGenf )(GLenum coord, GLenum pname, GLfloat param);
+extern  void ( * qglTexGenfv )(GLenum coord, GLenum pname, const GLfloat *params);
+extern  void ( * qglTexGeni )(GLenum coord, GLenum pname, GLint param);
+extern  void ( * qglTexGeniv )(GLenum coord, GLenum pname, const GLint *params);
+extern  void ( * qglTexImage1D )(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
+extern  void ( * qglTexImage2D )(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
+extern  void ( * qglTexImage2DEXT )(GLenum target, GLint level, GLint numlevels, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
+extern  void ( * qglTexParameterf )(GLenum target, GLenum pname, GLfloat param);
+extern  void ( * qglTexParameterfv )(GLenum target, GLenum pname, const GLfloat *params);
+extern  void ( * qglTexParameteri )(GLenum target, GLenum pname, GLint param);
+extern  void ( * qglTexParameteriv )(GLenum target, GLenum pname, const GLint *params);
+extern  void ( * qglTexSubImage1D )(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels);
+extern  void ( * qglTexSubImage2D )(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
+extern  void ( * qglTranslated )(GLdouble x, GLdouble y, GLdouble z);
+extern  void ( * qglTranslatef )(GLfloat x, GLfloat y, GLfloat z);
+extern  void ( * qglVertex2d )(GLdouble x, GLdouble y);
+extern  void ( * qglVertex2dv )(const GLdouble *v);
+extern  void ( * qglVertex2f )(GLfloat x, GLfloat y);
+extern  void ( * qglVertex2fv )(const GLfloat *v);
+extern  void ( * qglVertex2i )(GLint x, GLint y);
+extern  void ( * qglVertex2iv )(const GLint *v);
+extern  void ( * qglVertex2s )(GLshort x, GLshort y);
+extern  void ( * qglVertex2sv )(const GLshort *v);
+extern  void ( * qglVertex3d )(GLdouble x, GLdouble y, GLdouble z);
+extern  void ( * qglVertex3dv )(const GLdouble *v);
+extern  void ( * qglVertex3f )(GLfloat x, GLfloat y, GLfloat z);
+extern  void ( * qglVertex3fv )(const GLfloat *v);
+extern  void ( * qglVertex3i )(GLint x, GLint y, GLint z);
+extern  void ( * qglVertex3iv )(const GLint *v);
+extern  void ( * qglVertex3s )(GLshort x, GLshort y, GLshort z);
+extern  void ( * qglVertex3sv )(const GLshort *v);
+extern  void ( * qglVertex4d )(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+extern  void ( * qglVertex4dv )(const GLdouble *v);
+extern  void ( * qglVertex4f )(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+extern  void ( * qglVertex4fv )(const GLfloat *v);
+extern  void ( * qglVertex4i )(GLint x, GLint y, GLint z, GLint w);
+extern  void ( * qglVertex4iv )(const GLint *v);
+extern  void ( * qglVertex4s )(GLshort x, GLshort y, GLshort z, GLshort w);
+extern  void ( * qglVertex4sv )(const GLshort *v);
+extern  void ( * qglVertexPointer )(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
+extern  void ( * qglViewport )(GLint x, GLint y, GLsizei width, GLsizei height);
+
+#endif
diff --git a/codemp/renderer/tr_WorldEffects.cpp b/codemp/renderer/tr_WorldEffects.cpp
new file mode 100644
index 0000000..637a42c
--- /dev/null
+++ b/codemp/renderer/tr_WorldEffects.cpp
@@ -0,0 +1,2025 @@
+////////////////////////////////////////////////////////////////////////////////////////
+// RAVEN SOFTWARE - STAR WARS: JK II
+//  (c) 2002 Activision
+//
+// World Effects
+//
+//
+////////////////////////////////////////////////////////////////////////////////////////
+#include "../qcommon/exe_headers.h"
+#pragma warning( disable : 4512 )
+
+inline float WE_flrand(float min, float max) {
+	return ((rand() * (max - min)) / 32768.0F) + min;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Externs & Fwd Decl.
+////////////////////////////////////////////////////////////////////////////////////////
+extern qboolean		ParseVector( const char **text, int count, float *v );
+extern void			SetViewportAndScissor( void );
+
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Includes
+////////////////////////////////////////////////////////////////////////////////////////
+#include "tr_local.h"
+#include "tr_WorldEffects.h"
+
+#include "../Ravl/CVec.h"
+#include "../Ratl/vector_vs.h"
+#include "../Ratl/bits_vs.h"
+
+#ifdef _XBOX
+#include "../win32/glw_win_dx8.h"
+#else
+#include "glext.h"
+#endif
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Defines
+////////////////////////////////////////////////////////////////////////////////////////
+#define GLS_ALPHA				(GLS_SRCBLEND_SRC_ALPHA | GLS_DSTBLEND_ONE_MINUS_SRC_ALPHA)
+#define	MAX_WIND_ZONES			10
+#define MAX_WEATHER_ZONES		10
+#define	MAX_PUFF_SYSTEMS		2
+#define	MAX_PARTICLE_CLOUDS		5
+
+#ifdef _XBOX
+#define POINTCACHE_CELL_SIZE	96.0f		
+
+// Note to Vv:
+// you guys may want to look into lowering that number.  I've optimized the storage
+// space by breaking it up into small boxes (weather zones) around the areas we care about
+// in order to speed up load time and reduce memory.  A very high number here will mean
+// that weather related effects like rain, fog, snow, etc will bleed through to where
+// they shouldn't...
+
+#else
+#define POINTCACHE_CELL_SIZE	96.0f
+#endif
+
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Globals
+////////////////////////////////////////////////////////////////////////////////////////
+float		mMillisecondsElapsed = 0;
+float		mSecondsElapsed = 0;
+bool		mFrozen = false;
+
+CVec3		mGlobalWindVelocity;
+CVec3		mGlobalWindDirection;
+float		mGlobalWindSpeed;
+int			mParticlesRendered;
+
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Handy Functions
+////////////////////////////////////////////////////////////////////////////////////////
+inline void VectorFloor(vec3_t in)
+{
+	in[0] = floorf(in[0]);
+	in[1] = floorf(in[1]);
+	in[2] = floorf(in[2]);
+}
+
+inline void VectorCeil(vec3_t in)
+{
+	in[0] = ceilf(in[0]);
+	in[1] = ceilf(in[1]);
+	in[2] = ceilf(in[2]);
+}
+
+inline float	FloatRand(void) 
+{ 
+	return ((float)rand() / (float)RAND_MAX);
+}
+
+inline float	fast_flrand(float min, float max)
+{
+	//return min + (max - min) * flrand;
+	return WE_flrand(min, max); //fixme?
+}
+
+inline	void	SnapFloatToGrid(float& f, int GridSize)
+{
+	f = (int)(f);
+
+	bool	fNeg		= (f<0);
+	if (fNeg)
+	{
+		f *= -1;		// Temporarly make it positive
+	}
+
+	int		Offset		= ((int)(f) % (int)(GridSize));
+	int		OffsetAbs	= abs(Offset);
+	if (OffsetAbs>(GridSize/2))
+	{
+		Offset = (GridSize - OffsetAbs) * -1;
+	}
+
+	f -= Offset;
+
+	if (fNeg)
+	{
+		f *= -1;		// Put It Back To Negative
+	}
+
+	f = (int)(f);
+
+	assert(((int)(f)%(int)(GridSize)) == 0);
+}
+
+inline	void	SnapVectorToGrid(CVec3& Vec, int GridSize)
+{
+	SnapFloatToGrid(Vec[0], GridSize);
+	SnapFloatToGrid(Vec[1], GridSize);
+	SnapFloatToGrid(Vec[2], GridSize);
+}
+
+
+
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Range Structures
+////////////////////////////////////////////////////////////////////////////////////////
+struct	SVecRange
+{
+	CVec3	mMins;
+	CVec3	mMaxs;
+
+	inline void	Clear()
+	{
+		mMins.Clear();
+		mMaxs.Clear();
+	}
+
+	inline void Pick(CVec3& V)
+	{
+		V[0] = WE_flrand(mMins[0], mMaxs[0]); 
+		V[1] = WE_flrand(mMins[1], mMaxs[1]); 
+		V[2] = WE_flrand(mMins[2], mMaxs[2]); 
+	}
+	inline void Wrap(CVec3& V, SVecRange &spawnRange)
+	{
+		if (V[0]<mMins[0])
+		{
+			const float d = mMins[0]-V[0];
+			V[0] = mMaxs[0]-fmod(d, mMaxs[0]-mMins[0]);
+		}
+		if (V[0]>mMaxs[0])
+		{
+			const float d = V[0]-mMaxs[0];
+			V[0] = mMins[0]+fmod(d, mMaxs[0]-mMins[0]);
+		}
+
+		if (V[1]<mMins[1])
+		{
+			const float d = mMins[1]-V[1];
+			V[1] = mMaxs[1]-fmod(d, mMaxs[1]-mMins[1]);
+		}
+		if (V[1]>mMaxs[1])
+		{
+			const float d = V[1]-mMaxs[1];
+			V[1] = mMins[1]+fmod(d, mMaxs[1]-mMins[1]);
+		}
+
+		if (V[2]<mMins[2])
+		{
+			const float d = mMins[2]-V[2];
+			V[2] = mMaxs[2]-fmod(d, mMaxs[2]-mMins[2]);
+		}
+		if (V[2]>mMaxs[2])
+		{
+			const float d = V[2]-mMaxs[2];
+			V[2] = mMins[2]+fmod(d, mMaxs[2]-mMins[2]);
+		}
+	}
+
+	inline bool In(const CVec3& V)
+	{
+		return (V>mMins && V<mMaxs);
+	}
+};
+
+struct	SFloatRange
+{
+	float	mMin;
+	float	mMax;
+
+	inline void	Clear()
+	{
+		mMin = 0;
+		mMin = 0;
+	}
+	inline void Pick(float& V)
+	{
+		V = WE_flrand(mMin, mMax);
+	}
+	inline bool In(const float& V)
+	{
+		return (V>mMin && V<mMax);
+	}
+};
+
+struct	SIntRange
+{
+	int	mMin;
+	int	mMax;
+
+	inline void	Clear()
+	{
+		mMin = 0;
+		mMin = 0;
+	}
+	inline void Pick(int& V)
+	{
+		V = Q_irand(mMin, mMax);
+	}
+	inline bool In(const int& V)
+	{
+		return (V>mMin && V<mMax);
+	}
+};
+
+
+
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// The Particle Class
+////////////////////////////////////////////////////////////////////////////////////////
+class	CWeatherParticle
+{
+public:
+	enum
+	{
+		FLAG_RENDER = 0,
+
+		FLAG_FADEIN,
+		FLAG_FADEOUT,
+		FLAG_RESPAWN,
+
+		FLAG_MAX
+	};
+	typedef		ratl::bits_vs<FLAG_MAX>		TFlags;
+
+	float	mAlpha;
+	TFlags	mFlags;
+	CVec3	mPosition;
+	CVec3	mVelocity;
+	float	mMass;			// A higher number will more greatly resist force and result in greater gravity
+};
+
+
+
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// The Wind
+////////////////////////////////////////////////////////////////////////////////////////
+class	CWindZone
+{
+public:
+	bool		mGlobal;
+	SVecRange	mRBounds;
+	SVecRange	mRVelocity;
+	SIntRange	mRDuration;
+	SIntRange	mRDeadTime;
+	float		mMaxDeltaVelocityPerUpdate;
+	float		mChanceOfDeadTime;
+
+	CVec3		mCurrentVelocity;
+	CVec3		mTargetVelocity;
+	int			mTargetVelocityTimeRemaining;
+
+
+public:
+	////////////////////////////////////////////////////////////////////////////////////
+	// Initialize - Will setup default values for all data
+	////////////////////////////////////////////////////////////////////////////////////
+	void		Initialize()
+	{
+		mRBounds.Clear();
+		mGlobal						= true;
+
+		mRVelocity.mMins			= -1500.0f;
+		mRVelocity.mMins[2]			= -10.0f;
+		mRVelocity.mMaxs			= 1500.0f;
+		mRVelocity.mMaxs[2]			= 10.0f;
+
+		mMaxDeltaVelocityPerUpdate	= 10.0f;
+
+		mRDuration.mMin				= 1000;
+		mRDuration.mMax				= 2000;
+
+		mChanceOfDeadTime			= 0.3f;
+		mRDeadTime.mMin				= 1000;
+		mRDeadTime.mMax				= 3000;
+
+		mCurrentVelocity.Clear();
+		mTargetVelocity.Clear();
+		mTargetVelocityTimeRemaining = 0;
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Update - Changes wind when current target velocity expires
+	////////////////////////////////////////////////////////////////////////////////////
+	void		Update()
+	{
+		if (mTargetVelocityTimeRemaining==0)
+		{
+			if (FloatRand()<mChanceOfDeadTime)
+			{
+				mRDeadTime.Pick(mTargetVelocityTimeRemaining);
+				mTargetVelocity.Clear();
+			}
+			else
+			{
+				mRDuration.Pick(mTargetVelocityTimeRemaining);
+				mRVelocity.Pick(mTargetVelocity);
+			}
+		}
+		else if (mTargetVelocityTimeRemaining!=-1)
+		{
+			mTargetVelocityTimeRemaining--;
+
+			CVec3	DeltaVelocity(mTargetVelocity - mCurrentVelocity);
+			float	DeltaVelocityLen = VectorNormalize(DeltaVelocity.v);
+			if (DeltaVelocityLen > mMaxDeltaVelocityPerUpdate)
+			{
+				DeltaVelocityLen = mMaxDeltaVelocityPerUpdate;
+			}
+			DeltaVelocity *= (DeltaVelocityLen);
+			mCurrentVelocity += DeltaVelocity;
+		}
+	}
+};
+ratl::vector_vs<CWindZone, MAX_WIND_ZONES>		mWindZones;
+
+bool R_GetWindVector(vec3_t windVector)
+{
+	VectorCopy(mGlobalWindDirection.v, windVector);
+	return true;
+}
+
+bool R_GetWindSpeed(float &windSpeed)
+{
+	windSpeed = mGlobalWindSpeed;
+	return true;
+}
+
+bool R_GetWindGusting()
+{
+	return (mGlobalWindSpeed>1000.0f);
+}
+
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Outside Point Cache
+////////////////////////////////////////////////////////////////////////////////////////
+class COutside
+{
+public:
+	////////////////////////////////////////////////////////////////////////////////////
+	//Global Public Outside Variables
+	////////////////////////////////////////////////////////////////////////////////////
+	bool			mOutsideShake;
+	float			mOutsidePain;
+
+private:
+	////////////////////////////////////////////////////////////////////////////////////
+	// The Outside Cache
+	////////////////////////////////////////////////////////////////////////////////////
+	bool			mCacheInit;			// Has It Been Cached?
+
+	struct SWeatherZone
+	{
+		static bool	mMarkedOutside;
+		ulong*		mPointCache;
+		SVecRange	mExtents;
+		SVecRange	mSize;
+		int			mWidth;
+		int			mHeight;
+		int			mDepth;
+
+		////////////////////////////////////////////////////////////////////////////////////
+		// Convert To Cell
+		////////////////////////////////////////////////////////////////////////////////////
+		inline	void	ConvertToCell(const CVec3& pos, int& x, int& y, int& z, int& bit)
+		{
+			x = (int)((pos[0] / POINTCACHE_CELL_SIZE) - mSize.mMins[0]);
+			y = (int)((pos[1] / POINTCACHE_CELL_SIZE) - mSize.mMins[1]);
+			z = (int)((pos[2] / POINTCACHE_CELL_SIZE) - mSize.mMins[2]);
+
+			bit = (z & 31);
+			z >>= 5;
+		}
+
+		////////////////////////////////////////////////////////////////////////////////////
+		// CellOutside - Test to see if a given cell is outside
+		////////////////////////////////////////////////////////////////////////////////////
+		inline	bool	CellOutside(int x, int y, int z, int bit)
+		{
+			if ((x < 0 || x >= mWidth) || (y < 0 || y >= mHeight) || (z < 0 || z >= mDepth) || (bit < 0 || bit >= 32))
+			{
+				return !(mMarkedOutside);
+			}
+			return (mMarkedOutside==(!!(mPointCache[((z * mWidth * mHeight) + (y * mWidth) + x)]&(1 << bit))));
+		}
+	};
+	ratl::vector_vs<SWeatherZone, MAX_WEATHER_ZONES>	mWeatherZones;
+
+
+private:
+	////////////////////////////////////////////////////////////////////////////////////
+	// Iteration Variables
+	////////////////////////////////////////////////////////////////////////////////////
+	int				mWCells;
+	int				mHCells;
+
+	int				mXCell;
+	int				mYCell;
+	int				mZBit;
+
+	int				mXMax;
+	int				mYMax;
+	int				mZMax;
+
+
+private:
+
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Contents Outside
+	////////////////////////////////////////////////////////////////////////////////////
+	inline	bool	ContentsOutside(int contents)
+	{
+		if (contents&CONTENTS_WATER || contents&CONTENTS_SOLID)
+		{
+			return false;
+		}
+		if (mCacheInit)
+		{
+			if (SWeatherZone::mMarkedOutside)
+			{
+				return (!!(contents&CONTENTS_OUTSIDE));
+			}
+			return (!(contents&CONTENTS_INSIDE));
+		}
+		return !!(contents&CONTENTS_OUTSIDE);
+	}
+
+
+
+
+public:
+	////////////////////////////////////////////////////////////////////////////////////
+	// Constructor - Will setup default values for all data
+	////////////////////////////////////////////////////////////////////////////////////
+	void Reset()
+	{
+		mOutsideShake = false;
+		mOutsidePain = 0.0;
+		mCacheInit = false;
+		SWeatherZone::mMarkedOutside = false;
+		for (int wz=0; wz<mWeatherZones.size(); wz++)
+		{
+			Z_Free(mWeatherZones[wz].mPointCache);
+			mWeatherZones[wz].mPointCache = 0;
+		}
+		mWeatherZones.clear();
+	}
+
+	COutside()
+	{
+		Reset();
+	}
+	~COutside()
+	{
+		Reset();
+	}
+
+	bool			Initialized()
+	{
+		return mCacheInit;
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// AddWeatherZone - Will add a zone of mins and maxes
+	////////////////////////////////////////////////////////////////////////////////////
+	void			AddWeatherZone(vec3_t mins, vec3_t maxs)
+	{
+		if (!mWeatherZones.full())
+		{
+			SWeatherZone&	Wz = mWeatherZones.push_back();
+			Wz.mExtents.mMins = mins;
+			Wz.mExtents.mMaxs = maxs;
+
+			SnapVectorToGrid(Wz.mExtents.mMins, POINTCACHE_CELL_SIZE); 
+			SnapVectorToGrid(Wz.mExtents.mMaxs, POINTCACHE_CELL_SIZE); 
+
+			Wz.mSize.mMins = Wz.mExtents.mMins;
+			Wz.mSize.mMaxs = Wz.mExtents.mMaxs;
+
+			Wz.mSize.mMins /= POINTCACHE_CELL_SIZE;
+			Wz.mSize.mMaxs /= POINTCACHE_CELL_SIZE;
+			Wz.mWidth		=  (int)(Wz.mSize.mMaxs[0] - Wz.mSize.mMins[0]);
+			Wz.mHeight		=  (int)(Wz.mSize.mMaxs[1] - Wz.mSize.mMins[1]);
+			Wz.mDepth		= ((int)(Wz.mSize.mMaxs[2] - Wz.mSize.mMins[2]) + 31) >> 5;
+			
+			int arraySize	= (Wz.mWidth * Wz.mHeight * Wz.mDepth);
+			Wz.mPointCache  = (ulong *)Z_Malloc(arraySize*sizeof(ulong), TAG_POINTCACHE, qtrue);
+		}
+	}
+
+
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Cache - Will Scan the World, Creating The Cache
+	////////////////////////////////////////////////////////////////////////////////////
+	void			Cache()
+	{
+		if (!tr.world || mCacheInit)
+		{
+			return;
+		}
+
+		CVec3		CurPos;
+		CVec3		Size;
+		CVec3		Mins;
+		int			x, y, z, q, zbase;
+		bool		curPosOutside;
+		ulong		contents;
+		ulong		bit;
+
+
+		// Record The Extents Of The World Incase No Other Weather Zones Exist
+		//---------------------------------------------------------------------
+		if (!mWeatherZones.size())
+		{
+			Com_Printf("WARNING: No Weather Zones Encountered");
+			AddWeatherZone(tr.world->bmodels[0].bounds[0], tr.world->bmodels[0].bounds[1]);
+		}
+
+		// Iterate Over All Weather Zones
+		//--------------------------------
+		for (int zone=0; zone<mWeatherZones.size(); zone++)
+		{
+			SWeatherZone	wz = mWeatherZones[zone];
+
+			// Make Sure Point Contents Checks Occur At The CENTER Of The Cell
+			//-----------------------------------------------------------------
+			Mins = wz.mExtents.mMins;
+			for (x=0; x<3; x++)
+			{
+				Mins[x] += (POINTCACHE_CELL_SIZE/2);
+			}
+
+
+			// Start Scanning
+			//----------------
+			for(z = 0; z < wz.mDepth; z++)
+			{
+				for(q = 0; q < 32; q++)
+				{
+					bit = (1 << q);
+					zbase = (z << 5);
+
+					for(x = 0; x < wz.mWidth; x++)
+					{
+						for(y = 0; y < wz.mHeight; y++)
+						{
+							CurPos[0] = x			* POINTCACHE_CELL_SIZE;
+							CurPos[1] = y			* POINTCACHE_CELL_SIZE;
+							CurPos[2] = (zbase + q)	* POINTCACHE_CELL_SIZE;
+							CurPos	  += Mins;
+
+							contents = CM_PointContents(CurPos.v, 0);
+							if (contents&CONTENTS_INSIDE || contents&CONTENTS_OUTSIDE)
+							{
+								curPosOutside = ((contents&CONTENTS_OUTSIDE)!=0);
+								if (!mCacheInit)
+								{
+									mCacheInit = true;
+									SWeatherZone::mMarkedOutside = curPosOutside;
+								}
+								else if (SWeatherZone::mMarkedOutside!=curPosOutside)
+								{
+									assert(0);
+									Com_Error (ERR_DROP, "Weather Effect: Both Indoor and Outdoor brushs encountered in map.\n" );
+									return;
+								}
+
+								// Mark The Point
+								//----------------
+								wz.mPointCache[((z * wz.mWidth * wz.mHeight) + (y * wz.mWidth) + x)] |= bit;
+							}
+						}// for (y)
+					}// for (x)
+				}// for (q)
+			}// for (z)
+		}
+
+
+		// If no indoor or outdoor brushes were found
+		//--------------------------------------------
+		if (!mCacheInit)
+		{
+			mCacheInit = true;
+			SWeatherZone::mMarkedOutside = false;		// Assume All Is Outside, Except Solid
+		}
+	}
+
+
+
+
+public:
+	////////////////////////////////////////////////////////////////////////////////////
+	// PointOutside - Test to see if a given point is outside
+	////////////////////////////////////////////////////////////////////////////////////
+	inline	bool	PointOutside(const CVec3& pos)
+	{
+		if (!mCacheInit)
+		{
+			return ContentsOutside(CM_PointContents(pos.v, 0));
+		}
+		for (int zone=0; zone<mWeatherZones.size(); zone++)
+		{
+			SWeatherZone	wz = mWeatherZones[zone];
+			if (wz.mExtents.In(pos))
+			{
+				int		bit, x, y, z;
+				wz.ConvertToCell(pos, x, y, z, bit);
+				return wz.CellOutside(x, y, z, bit);
+			}
+		}
+		return !(SWeatherZone::mMarkedOutside);
+
+	}
+
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// PointOutside - Test to see if a given bounded plane is outside
+	////////////////////////////////////////////////////////////////////////////////////
+	inline	bool	PointOutside(const CVec3& pos, float width, float height)
+	{
+		for (int zone=0; zone<mWeatherZones.size(); zone++)
+		{
+			SWeatherZone	wz = mWeatherZones[zone];
+			if (wz.mExtents.In(pos))
+			{
+				int		bit, x, y, z;
+				wz.ConvertToCell(pos, x, y, z, bit);
+				if (width<POINTCACHE_CELL_SIZE || height<POINTCACHE_CELL_SIZE)
+				{
+ 					return (wz.CellOutside(x, y, z, bit));
+				}
+
+				mWCells = ((int)width  / POINTCACHE_CELL_SIZE);
+				mHCells = ((int)height / POINTCACHE_CELL_SIZE);
+
+				mXMax = x + mWCells;
+				mYMax = y + mWCells;
+				mZMax = bit + mHCells;
+
+				for (mXCell=x-mWCells; mXCell<=mXMax; mXCell++)
+				{
+					for (mYCell=y-mWCells; mYCell<=mYMax; mYCell++)
+					{
+						for (mZBit=bit-mHCells; mZBit<=mZMax; mZBit++)
+						{
+							if (!wz.CellOutside(mXCell, mYCell, z, mZBit))
+							{
+								return false;
+							}
+						}
+					}
+				}
+				return true;
+			}
+		}
+		return !(SWeatherZone::mMarkedOutside);
+	}
+};
+COutside			mOutside;
+bool				COutside::SWeatherZone::mMarkedOutside = false;
+
+
+void R_AddWeatherZone(vec3_t mins, vec3_t maxs)
+{
+	mOutside.AddWeatherZone(mins, maxs);
+}
+
+bool R_IsOutside(vec3_t pos)
+{
+	return mOutside.PointOutside(pos);
+}
+
+bool R_IsShaking()
+{
+	return (mOutside.mOutsideShake && mOutside.PointOutside(backEnd.viewParms.ori.origin));
+}
+
+float R_IsOutsideCausingPain(vec3_t pos)
+{
+	return (mOutside.mOutsidePain && mOutside.PointOutside(pos));
+}
+
+#ifdef _XBOX
+static void pointBegin(GLint verts, float size)
+{
+	assert(!glw_state->inDrawBlock);
+
+	// start the draw block
+	glw_state->inDrawBlock = true;
+	glw_state->primitiveMode = D3DPT_POINTLIST;
+
+	// update DX with any pending state changes
+	glw_state->drawStride = 4;
+	DWORD mask = D3DFVF_XYZ | D3DFVF_DIFFUSE;
+	glw_state->device->SetVertexShader(mask);
+	glw_state->shaderMask = mask;
+
+	if(glw_state->matricesDirty[glwstate_t::MatrixMode_Model])
+	{
+		glw_state->device->SetTransform(D3DTS_VIEW, 
+			glw_state->matrixStack[glwstate_t::MatrixMode_Model]->GetTop());
+
+		glw_state->matricesDirty[glwstate_t::MatrixMode_Model] = false;
+	}
+
+	// Update the texture and states
+	// NOTE: Point sprites ALWAYS go on texture stage 3
+	glwstate_t::texturexlat_t::iterator it = glw_state->textureXlat.find(glw_state->currentTexture[0]);
+	glw_state->device->SetTexture( 3, it->second.mipmap );
+	glw_state->device->SetTextureStageState(3, D3DTSS_COLOROP,   glw_state->textureEnv[0]);
+	glw_state->device->SetTextureStageState(3, D3DTSS_COLORARG1, D3DTA_TEXTURE);
+	glw_state->device->SetTextureStageState(3, D3DTSS_COLORARG2, D3DTA_CURRENT);
+	glw_state->device->SetTextureStageState(3, D3DTSS_ALPHAOP,   glw_state->textureEnv[0]);
+	glw_state->device->SetTextureStageState(3, D3DTSS_ALPHAARG1, D3DTA_TEXTURE);
+	glw_state->device->SetTextureStageState(3, D3DTSS_ALPHAARG2, D3DTA_CURRENT);
+	glw_state->device->SetTextureStageState(3, D3DTSS_MAXANISOTROPY, it->second.anisotropy);
+	glw_state->device->SetTextureStageState(3, D3DTSS_MINFILTER, it->second.minFilter);
+	glw_state->device->SetTextureStageState(3, D3DTSS_MIPFILTER, it->second.mipFilter);
+	glw_state->device->SetTextureStageState(3, D3DTSS_MAGFILTER, it->second.magFilter);
+	glw_state->device->SetTextureStageState(3, D3DTSS_ADDRESSU,  it->second.wrapU);
+	glw_state->device->SetTextureStageState(3, D3DTSS_ADDRESSV,  it->second.wrapV);
+
+	glw_state->device->SetTexture( 0, NULL );
+	glw_state->device->SetTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_DISABLE );
+
+	float attena = 1.0f, attenb = 0.0f, attenc = 0.0004f;
+	glw_state->device->SetRenderState( D3DRS_POINTSPRITEENABLE, TRUE );
+	glw_state->device->SetRenderState( D3DRS_POINTSCALEENABLE,  TRUE );
+	glw_state->device->SetRenderState( D3DRS_POINTSIZE,         *((DWORD*)&size) );
+	glw_state->device->SetRenderState( D3DRS_POINTSIZE_MIN,     *((DWORD*)&attenb));
+	glw_state->device->SetRenderState( D3DRS_POINTSCALE_A,      *((DWORD*)&attena) );
+	glw_state->device->SetRenderState( D3DRS_POINTSCALE_B,      *((DWORD*)&attenb) );
+	glw_state->device->SetRenderState( D3DRS_POINTSCALE_C,      *((DWORD*)&attenc) );
+
+	// set vertex counters
+	glw_state->numVertices = 0;
+	glw_state->totalVertices = verts;
+	int max = glw_state->totalVertices;
+	if (max > 2040 / glw_state->drawStride)
+	{
+		max = 2040 / glw_state->drawStride;
+	}
+	glw_state->maxVertices = max;	
+
+	// open a draw packet
+	int num_packets;
+	if(verts == 0) {
+		num_packets = 1;
+	} else {
+		num_packets = (verts / glw_state->maxVertices) + (!!(verts % glw_state->maxVertices));
+	}
+	int cmd_size = num_packets * 3;
+	int vert_size = glw_state->drawStride * verts;
+
+	glw_state->device->BeginPush(vert_size + cmd_size + 2, 
+		&glw_state->drawArray);
+
+	glw_state->drawArray[0] = D3DPUSH_ENCODE(D3DPUSH_SET_BEGIN_END, 1);
+	glw_state->drawArray[1] = glw_state->primitiveMode;
+	glw_state->drawArray[2] = D3DPUSH_ENCODE(
+		D3DPUSH_NOINCREMENT_FLAG|D3DPUSH_INLINE_ARRAY, 
+		glw_state->drawStride * glw_state->maxVertices);
+	glw_state->drawArray += 3;
+}
+
+
+static void pointEnd()
+{
+	glw_state->device->SetRenderState( D3DRS_POINTSPRITEENABLE, FALSE );
+	glw_state->device->SetRenderState( D3DRS_POINTSCALEENABLE, FALSE );
+	glw_state->device->SetTexture( 3, NULL );
+	glw_state->device->SetTextureStageState( 3, D3DTSS_COLOROP, D3DTOP_DISABLE );
+}
+#endif // _XBOX
+
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Particle Cloud
+////////////////////////////////////////////////////////////////////////////////////////
+class	CWeatherParticleCloud
+{
+private:
+	////////////////////////////////////////////////////////////////////////////////////
+	// DYNAMIC MEMORY
+	////////////////////////////////////////////////////////////////////////////////////
+	image_t*	mImage;
+	CWeatherParticle*	mParticles;
+
+private:
+	////////////////////////////////////////////////////////////////////////////////////
+	// RUN TIME VARIANTS
+	////////////////////////////////////////////////////////////////////////////////////
+	float		mSpawnSpeed;
+	CVec3		mSpawnPlaneNorm;
+	CVec3		mSpawnPlaneRight;
+	CVec3		mSpawnPlaneUp;
+	SVecRange	mRange;
+
+	CVec3		mCameraPosition;
+	CVec3		mCameraForward;
+	CVec3		mCameraLeft;
+	CVec3		mCameraDown;
+	CVec3		mCameraLeftPlusUp;
+	CVec3		mCameraLeftMinusUp;
+
+
+	int			mParticleCountRender;
+	int			mGLModeEnum;
+
+	bool		mPopulated;
+
+
+public:
+	////////////////////////////////////////////////////////////////////////////////////
+	// CONSTANTS
+	////////////////////////////////////////////////////////////////////////////////////
+	bool		mOrientWithVelocity;
+	float		mSpawnPlaneSize;
+	float		mSpawnPlaneDistance;
+	SVecRange	mSpawnRange;
+
+	float		mGravity;			// How much gravity affects the velocity of a particle
+	CVec4		mColor;				// RGBA color
+	int			mVertexCount;		// 3 for triangle, 4 for quad, other numbers not supported
+
+	float		mWidth;
+	float		mHeight;
+
+	int			mBlendMode;			// 0 = ALPHA, 1 = SRC->SRC
+	int			mFilterMode;		// 0 = LINEAR, 1 = NEAREST
+
+	float		mFade;				// How much to fade in and out 1.0 = instant, 0.01 = very slow
+
+	SFloatRange	mRotation;
+	float		mRotationDelta;
+	float		mRotationDeltaTarget;
+	float		mRotationCurrent;
+	SIntRange	mRotationChangeTimer;
+	int			mRotationChangeNext;
+
+	SFloatRange	mMass;				// Determines how slowness to accelerate, higher number = slower
+	float		mFrictionInverse;	// How much air friction does this particle have 1.0=none, 0.0=nomove
+	
+	int			mParticleCount;
+
+	bool		mWaterParticles;
+
+
+
+
+public:
+	////////////////////////////////////////////////////////////////////////////////////
+	// Initialize - Create Image, Particles, And Setup All Values
+	////////////////////////////////////////////////////////////////////////////////////
+	void	Initialize(int count, const char* texturePath, int VertexCount=4)
+	{
+		Reset();
+		assert(mParticleCount==0 && mParticles==0);
+		assert(mImage==0);
+
+		// Create The Image
+		//------------------
+		mImage = R_FindImageFile(texturePath, qfalse, qfalse, qfalse, GL_CLAMP);
+		if (!mImage)
+		{
+			Com_Error(ERR_DROP, "CWeatherParticleCloud: Could not texture %s", texturePath);
+		}
+
+		GL_Bind(mImage);
+
+
+
+		// Create The Particles
+		//----------------------
+		mParticleCount	= count;
+		mParticles		= new CWeatherParticle[mParticleCount];
+
+
+
+		CWeatherParticle*	part=0;
+		for (int particleNum=0; particleNum<mParticleCount; particleNum++)
+		{
+			part = &(mParticles[particleNum]);
+			part->mPosition.Clear();
+			part->mVelocity.Clear();
+			part->mAlpha	= 0.0f;
+			mMass.Pick(part->mMass);
+		}
+
+		mVertexCount = VertexCount;
+
+#ifdef _XBOX
+		if(mVertexCount == 1)
+			mGLModeEnum = GL_POINTS;
+		else
+#endif
+		mGLModeEnum = (mVertexCount==3)?(GL_TRIANGLES):(GL_QUADS);
+	}
+
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Reset - Initializes all data to default values
+	////////////////////////////////////////////////////////////////////////////////////
+	void		Reset()
+	{
+		if (mImage)
+		{
+			// TODO: Free Image?
+		}
+		mImage				= 0;
+		if (mParticleCount)
+		{
+			delete [] mParticles;
+		}
+		mParticleCount		= 0;
+		mParticles			= 0;
+
+		mPopulated			= 0;
+
+
+
+		// These Are The Default Startup Values For Constant Data
+		//========================================================
+		mOrientWithVelocity = false;
+		mWaterParticles		= false;
+
+		mSpawnPlaneDistance	= 500;
+		mSpawnPlaneSize		= 500;
+		mSpawnRange.mMins	= -(mSpawnPlaneDistance*1.25f);
+		mSpawnRange.mMaxs	=  (mSpawnPlaneDistance*1.25f);
+
+		mGravity			= 300.0f;	// Units Per Second
+
+		mColor				= 1.0f;
+
+		mVertexCount		= 4;
+		mWidth				= 1.0f;
+		mHeight				= 1.0f;
+
+		mBlendMode			= 0;
+		mFilterMode			= 0;
+
+		mFade				= 10.0f;
+
+		mRotation.Clear();
+		mRotationDelta		= 0.0f;
+		mRotationDeltaTarget= 0.0f;
+		mRotationCurrent	= 0.0f;
+		mRotationChangeNext	= -1;
+		mRotation.mMin		= -0.7f;
+		mRotation.mMax		=  0.7f;
+		mRotationChangeTimer.mMin = 500;
+		mRotationChangeTimer.mMin = 2000;
+
+		mMass.mMin			= 5.0f;
+		mMass.mMax			= 10.0f;
+
+		mFrictionInverse	= 0.7f;		// No Friction?
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Constructor - Will setup default values for all data
+	////////////////////////////////////////////////////////////////////////////////////
+	CWeatherParticleCloud()
+	{
+		mImage = 0;
+		mParticleCount = 0;
+		Reset();
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Initialize - Will setup default values for all data
+	////////////////////////////////////////////////////////////////////////////////////
+	~CWeatherParticleCloud()
+	{
+		Reset();
+	}
+
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// UseSpawnPlane - Check To See If We Should Spawn On A Plane, Or Just Wrap The Box
+	////////////////////////////////////////////////////////////////////////////////////
+	inline bool	UseSpawnPlane()
+	{
+		return (mGravity!=0.0f);
+	}
+
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Update - Applies All Physics Forces To All Contained Particles
+	////////////////////////////////////////////////////////////////////////////////////
+	void		Update()
+	{
+		CWeatherParticle*	part=0;
+		CVec3		partForce;
+		CVec3		partMoved;
+		CVec3		partToCamera;
+		bool		partRendering;
+		bool		partOutside;
+		bool		partInRange;
+		bool		partInView;
+		int			particleNum;
+		float		particleFade = (mFade * mSecondsElapsed);
+
+/* TODO: Non Global Wind Zones
+		CWindZone*	wind=0;
+		int			windNum;
+		int			windCount = mWindZones.size();
+*/
+
+		// Compute Camera
+		//----------------
+		{
+			mCameraPosition	= backEnd.viewParms.ori.origin;
+			mCameraForward	= backEnd.viewParms.ori.axis[0];
+			mCameraLeft		= backEnd.viewParms.ori.axis[1];
+			mCameraDown		= backEnd.viewParms.ori.axis[2];
+
+			if (mRotationChangeNext!=-1)
+			{
+				if (mRotationChangeNext==0)
+				{
+					mRotation.Pick(mRotationDeltaTarget);
+					mRotationChangeTimer.Pick(mRotationChangeNext);
+					if (mRotationChangeNext<=0)
+					{
+						mRotationChangeNext = 1;
+					}
+				}
+				mRotationChangeNext--;
+
+				float	RotationDeltaDifference = (mRotationDeltaTarget - mRotationDelta);
+				if (fabsf(RotationDeltaDifference)>0.01)
+				{
+					mRotationDelta += RotationDeltaDifference;		// Blend To New Delta
+				}
+                mRotationCurrent += (mRotationDelta * mSecondsElapsed);
+				float s = sinf(mRotationCurrent);
+				float c = cosf(mRotationCurrent);
+
+				CVec3	TempCamLeft(mCameraLeft);
+
+				mCameraLeft *= (c * mWidth);
+				mCameraLeft.ScaleAdd(mCameraDown, (s * mWidth * -1.0f));
+
+				mCameraDown *= (c * mHeight);
+				mCameraDown.ScaleAdd(TempCamLeft, (s * mHeight));
+			}
+			else
+			{
+				mCameraLeft		*= mWidth;
+ 				mCameraDown		*= mHeight;
+			}
+		}
+
+
+		// Compute Global Force
+		//----------------------
+		CVec3		force;
+		{
+			force.Clear();
+
+			// Apply Gravity
+			//---------------
+			force[2] = -1.0f * mGravity;
+
+			// Apply Wind Velocity
+			//---------------------
+			force    += mGlobalWindVelocity;
+		}
+
+
+		// Update Range
+		//--------------
+		{
+			mRange.mMins = mCameraPosition + mSpawnRange.mMins;
+			mRange.mMaxs = mCameraPosition + mSpawnRange.mMaxs;
+
+			// If Using A Spawn Plane, Increase The Range Box A Bit To Account For Rotation On The Spawn Plane
+			//-------------------------------------------------------------------------------------------------
+			if (UseSpawnPlane())
+			{
+				for (int dim=0; dim<3; dim++)
+				{
+					if (force[dim]>0.01)
+					{
+						mRange.mMins[dim] -= (mSpawnPlaneDistance/2.0f);
+					}
+					else if (force[dim]<-0.01)
+					{
+						mRange.mMaxs[dim] += (mSpawnPlaneDistance/2.0f);
+					}
+				}
+				mSpawnPlaneNorm	= force;
+				mSpawnSpeed		= VectorNormalize(mSpawnPlaneNorm.v);
+				MakeNormalVectors(mSpawnPlaneNorm.v, mSpawnPlaneRight.v, mSpawnPlaneUp.v);
+				if (mOrientWithVelocity)
+				{
+					mCameraDown = mSpawnPlaneNorm;
+					mCameraDown *= (mHeight * -1);
+				}
+			}
+
+			// Optimization For Quad Position Calculation
+			//--------------------------------------------
+			if (mVertexCount==4)
+			{
+		 		mCameraLeftPlusUp  = (mCameraLeft - mCameraDown);
+				mCameraLeftMinusUp = (mCameraLeft + mCameraDown);
+			}
+			else
+			{
+				mCameraLeftPlusUp  = (mCameraDown + mCameraLeft);		// should really be called mCamera Left + Down
+			}
+		}
+
+		// Stop All Additional Processing
+		//--------------------------------
+		if (mFrozen)
+		{
+			return;
+		}
+
+
+
+		// Now Update All Particles
+		//--------------------------
+		mParticleCountRender = 0;
+		for (particleNum=0; particleNum<mParticleCount; particleNum++)
+		{
+			part			= &mParticles[particleNum];
+
+			if (!mPopulated)
+			{
+				mRange.Pick(part->mPosition);		// First Time Spawn Location
+			}
+
+			// Grab The Force And Apply Non Global Wind
+			//------------------------------------------
+			partForce = force;
+			partForce /= part->mMass;
+
+
+			// Apply The Force
+			//-----------------
+			part->mVelocity		+= partForce;
+			part->mVelocity		*= mFrictionInverse;
+
+			part->mPosition.ScaleAdd(part->mVelocity, mSecondsElapsed);
+
+			partToCamera	= (part->mPosition - mCameraPosition);
+			partRendering	= part->mFlags.get_bit(CWeatherParticle::FLAG_RENDER);
+			partOutside		= mOutside.PointOutside(part->mPosition, mWidth, mHeight);
+			partInRange		= mRange.In(part->mPosition);
+			partInView		= (partOutside && partInRange && (partToCamera.Dot(mCameraForward)>0.0f));
+
+			// Process Respawn
+			//-----------------
+			if (!partInRange && !partRendering)
+			{
+				part->mVelocity.Clear();
+
+				// Reselect A Position On The Spawn Plane
+				//----------------------------------------
+				if (UseSpawnPlane())
+				{
+					part->mPosition		= mCameraPosition;
+					part->mPosition		-= (mSpawnPlaneNorm* mSpawnPlaneDistance); 
+					part->mPosition		+= (mSpawnPlaneRight*WE_flrand(-mSpawnPlaneSize, mSpawnPlaneSize)); 
+					part->mPosition		+= (mSpawnPlaneUp*   WE_flrand(-mSpawnPlaneSize, mSpawnPlaneSize)); 
+				}
+
+				// Otherwise, Just Wrap Around To The Other End Of The Range
+				//-----------------------------------------------------------
+				else
+				{
+					mRange.Wrap(part->mPosition, mSpawnRange);
+				}
+				partInRange = true;
+			}
+
+			// Process Fade
+			//--------------
+			{
+				// Start A Fade Out
+				//------------------
+				if		(partRendering && !partInView)
+				{
+					part->mFlags.clear_bit(CWeatherParticle::FLAG_FADEIN);
+					part->mFlags.set_bit(CWeatherParticle::FLAG_FADEOUT);
+				}
+
+				// Switch From Fade Out To Fade In
+				//---------------------------------
+				else if (partRendering && partInView && part->mFlags.get_bit(CWeatherParticle::FLAG_FADEOUT))
+				{
+					part->mFlags.set_bit(CWeatherParticle::FLAG_FADEIN);
+					part->mFlags.clear_bit(CWeatherParticle::FLAG_FADEOUT);
+				}			
+
+				// Start A Fade In
+				//-----------------
+				else if (!partRendering && partInView)
+				{
+					partRendering = true;
+					part->mAlpha = 0.0f;
+					part->mFlags.set_bit(CWeatherParticle::FLAG_RENDER);
+					part->mFlags.set_bit(CWeatherParticle::FLAG_FADEIN);
+					part->mFlags.clear_bit(CWeatherParticle::FLAG_FADEOUT);
+				}
+
+				// Update Fade
+				//-------------
+				if (partRendering)
+				{
+
+					// Update Fade Out
+					//-----------------
+					if (part->mFlags.get_bit(CWeatherParticle::FLAG_FADEOUT))
+					{
+						part->mAlpha -= particleFade;
+						if (part->mAlpha<=0.0f)
+						{
+							part->mAlpha = 0.0f;
+							part->mFlags.clear_bit(CWeatherParticle::FLAG_FADEOUT);
+							part->mFlags.clear_bit(CWeatherParticle::FLAG_FADEIN);
+							part->mFlags.clear_bit(CWeatherParticle::FLAG_RENDER);
+							partRendering = false;
+						}
+					}
+
+					// Update Fade In
+					//----------------
+					else if (part->mFlags.get_bit(CWeatherParticle::FLAG_FADEIN))
+					{
+						part->mAlpha += particleFade;
+						if (part->mAlpha>=mColor[3])
+						{
+							part->mFlags.clear_bit(CWeatherParticle::FLAG_FADEIN);
+							part->mAlpha = mColor[3];
+						}
+					}
+				}
+			}
+
+			// Keep Track Of The Number Of Particles To Render
+			//-------------------------------------------------
+			if (part->mFlags.get_bit(CWeatherParticle::FLAG_RENDER))
+			{
+				mParticleCountRender ++;
+			}
+
+
+
+
+
+		}
+		mPopulated = true;
+	}
+
+	////////////////////////////////////////////////////////////////////////////////////
+	// Render - 
+	////////////////////////////////////////////////////////////////////////////////////
+	void		Render()
+	{
+		CWeatherParticle*	part=0;
+		int			particleNum;
+
+
+		// Set The GL State And Image Binding
+		//------------------------------------
+		GL_State((mBlendMode==0)?(GLS_ALPHA):(GLS_SRCBLEND_ONE | GLS_DSTBLEND_ONE));
+		GL_Bind(mImage);
+
+
+		// Enable And Disable Things
+		//---------------------------
+		/*
+		if (mGLModeEnum==GL_POINTS && qglPointParameteriNV)
+		{
+			qglEnable(GL_POINT_SPRITE_NV);
+
+			qglPointSize(mWidth);
+			qglPointParameterfEXT( GL_POINT_SIZE_MIN_EXT, 4.0f );
+			qglPointParameterfEXT( GL_POINT_SIZE_MAX_EXT, 2047.0f );
+
+			qglTexEnvi(GL_POINT_SPRITE_NV, GL_COORD_REPLACE_NV, GL_TRUE);
+		}
+		else
+		*/
+		//FIXME use this extension?
+		const float	attenuation[3] =
+		{
+			1, 0.0, 0.0004
+		};
+#ifdef _XBOX
+		if (mGLModeEnum==GL_POINTS)
+		{
+			pointBegin(mParticleCountRender, mWidth);
+		}
+#else
+		if (mGLModeEnum == GL_POINTS && qglPointParameterfEXT)
+		{ //fixme use custom parameters but gotta make sure it expects them on same scale first
+			qglPointSize(10.0);
+			qglPointParameterfEXT(GL_POINT_SIZE_MIN_EXT, 1.0);
+			qglPointParameterfEXT(GL_POINT_SIZE_MAX_EXT, 4.0);
+			qglPointParameterfvEXT(GL_DISTANCE_ATTENUATION_EXT, (float *)attenuation);
+		}
+#endif
+		else
+		{
+			qglEnable(GL_TEXTURE_2D);
+			//qglDisable(GL_CULL_FACE);
+			//naughty, you are making the assumption that culling is on when you get here. -rww
+			GL_Cull(CT_TWO_SIDED);
+
+			qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, (mFilterMode==0)?(GL_LINEAR):(GL_NEAREST));
+			qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, (mFilterMode==0)?(GL_LINEAR):(GL_NEAREST));
+
+
+			// Setup Matrix Mode And Translation
+			//-----------------------------------
+			qglMatrixMode(GL_MODELVIEW);
+			qglPushMatrix();
+
+#ifdef _XBOX
+			qglBeginEXT(mGLModeEnum, mParticleCountRender*mVertexCount, mParticleCountRender, 0, mParticleCountRender*mVertexCount, 0);
+#endif
+		}
+
+		// Begin
+		//-------
+#ifndef _XBOX
+		qglBegin(mGLModeEnum);
+#endif
+		for (particleNum=0; particleNum<mParticleCount; particleNum++)
+		{
+			part = &(mParticles[particleNum]);
+			if (!part->mFlags.get_bit(CWeatherParticle::FLAG_RENDER))
+			{
+				continue;
+			}
+
+			// Blend Mode Zero -> Apply Alpha Just To Alpha Channel
+			//------------------------------------------------------
+			if (mBlendMode==0)
+			{
+				qglColor4f(mColor[0], mColor[1], mColor[2], part->mAlpha);
+			}
+
+			// Otherwise Apply Alpha To All Channels
+			//---------------------------------------
+			else
+			{
+				qglColor4f(mColor[0]*part->mAlpha, mColor[1]*part->mAlpha, mColor[2]*part->mAlpha, mColor[3]*part->mAlpha);
+			}
+
+			// Render A Point
+			//----------------
+			if (mGLModeEnum==GL_POINTS)
+			{
+				qglVertex3fv(part->mPosition.v);
+			}
+
+			// Render A Triangle
+			//-------------------
+			else if (mVertexCount==3)
+			{
+ 				qglTexCoord2f(1.0, 0.0);
+				qglVertex3f(part->mPosition[0],
+							part->mPosition[1],
+							part->mPosition[2]);
+
+				qglTexCoord2f(0.0, 1.0);
+				qglVertex3f(part->mPosition[0] + mCameraLeft[0],
+							part->mPosition[1] + mCameraLeft[1],
+							part->mPosition[2] + mCameraLeft[2]);
+				
+				qglTexCoord2f(0.0, 0.0);
+				qglVertex3f(part->mPosition[0] + mCameraLeftPlusUp[0],
+							part->mPosition[1] + mCameraLeftPlusUp[1],
+							part->mPosition[2] + mCameraLeftPlusUp[2]);
+			}
+
+			// Render A Quad
+			//---------------
+			else
+			{
+				// Left bottom.
+				qglTexCoord2f( 0.0, 0.0 );
+				qglVertex3f(part->mPosition[0] - mCameraLeftMinusUp[0],
+							part->mPosition[1] - mCameraLeftMinusUp[1],
+							part->mPosition[2] - mCameraLeftMinusUp[2] );
+
+				// Right bottom.
+				qglTexCoord2f( 1.0, 0.0 );
+				qglVertex3f(part->mPosition[0] - mCameraLeftPlusUp[0],
+							part->mPosition[1] - mCameraLeftPlusUp[1],
+							part->mPosition[2] - mCameraLeftPlusUp[2] );
+
+				// Right top.
+				qglTexCoord2f( 1.0, 1.0 );
+				qglVertex3f(part->mPosition[0] + mCameraLeftMinusUp[0],
+							part->mPosition[1] + mCameraLeftMinusUp[1],
+							part->mPosition[2] + mCameraLeftMinusUp[2] );
+
+				// Left top.
+				qglTexCoord2f( 0.0, 1.0 );
+				qglVertex3f(part->mPosition[0] + mCameraLeftPlusUp[0],
+							part->mPosition[1] + mCameraLeftPlusUp[1], 
+							part->mPosition[2] + mCameraLeftPlusUp[2] );
+			}
+		}
+		qglEnd();
+
+		if (mGLModeEnum==GL_POINTS)
+		{
+#ifdef _XBOX
+			pointEnd();
+#else
+			//qglDisable(GL_POINT_SPRITE_NV);
+			//qglTexEnvi(GL_POINT_SPRITE_NV, GL_COORD_REPLACE_NV, GL_FALSE);
+#endif
+		}
+		else
+		{
+			//qglEnable(GL_CULL_FACE);
+			//you don't need to do this when you are properly setting cull state.
+			qglPopMatrix();
+		}
+
+		mParticlesRendered += mParticleCountRender;
+	}
+};
+ratl::vector_vs<CWeatherParticleCloud, MAX_PARTICLE_CLOUDS>	mParticleClouds;
+
+
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Init World Effects - Will Iterate Over All Particle Clouds, Clear Them Out, And Erase
+////////////////////////////////////////////////////////////////////////////////////////
+void R_InitWorldEffects(void)
+{
+	srand(Com_Milliseconds());
+
+	for (int i=0; i<mParticleClouds.size(); i++)
+	{
+		mParticleClouds[i].Reset();
+	}
+	mParticleClouds.clear();
+	mWindZones.clear();
+	mOutside.Reset();
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// Init World Effects - Will Iterate Over All Particle Clouds, Clear Them Out, And Erase
+////////////////////////////////////////////////////////////////////////////////////////
+void R_ShutdownWorldEffects(void)
+{
+	R_InitWorldEffects();
+}
+
+////////////////////////////////////////////////////////////////////////////////////////
+// RB_RenderWorldEffects - If any particle clouds exist, this will update and render them
+////////////////////////////////////////////////////////////////////////////////////////
+void RB_RenderWorldEffects(void)
+{
+	if (!tr.world || 
+		(tr.refdef.rdflags & RDF_NOWORLDMODEL) || 
+		(backEnd.refdef.rdflags & RDF_SKYBOXPORTAL) || 
+		!mParticleClouds.size()) 
+	{	//  no world rendering or no world or no particle clouds
+		return;
+	}
+
+	SetViewportAndScissor();
+	qglMatrixMode(GL_MODELVIEW);
+	qglLoadMatrixf(backEnd.viewParms.world.modelMatrix);
+
+
+	// Calculate Elapsed Time For Scale Purposes
+	//-------------------------------------------
+	mMillisecondsElapsed = backEnd.refdef.frametime;
+	if (mMillisecondsElapsed<1)
+	{
+		mMillisecondsElapsed = 1.0f;
+	}
+	if (mMillisecondsElapsed>1000.0f)
+	{
+		mMillisecondsElapsed = 1000.0f;
+	}
+	mSecondsElapsed = (mMillisecondsElapsed / 1000.0f);
+
+
+	// Make Sure We Are Always Outside Cached
+	//----------------------------------------
+	if (!mOutside.Initialized())
+	{
+		mOutside.Cache();
+	}
+	else
+	{
+		// Update All Wind Zones
+		//-----------------------
+		if (!mFrozen)
+		{
+			mGlobalWindVelocity.Clear();
+			for (int wz=0; wz<mWindZones.size(); wz++)
+			{
+				mWindZones[wz].Update();
+				if (mWindZones[wz].mGlobal)
+				{
+					mGlobalWindVelocity += mWindZones[wz].mCurrentVelocity;
+				}
+			}
+			mGlobalWindDirection	= mGlobalWindVelocity;
+			mGlobalWindSpeed		= VectorNormalize(mGlobalWindDirection.v);
+		}
+
+		// Update All Particle Clouds
+		//----------------------------
+		mParticlesRendered = 0;
+		for (int i=0; i<mParticleClouds.size(); i++)
+		{
+			mParticleClouds[i].Update();
+			mParticleClouds[i].Render();
+		}
+		if (false)
+		{
+			Com_Printf( "Weather: %d Particles Rendered\n", mParticlesRendered);
+		}
+	}
+}
+
+
+void R_WorldEffect_f(void)
+{
+	if (Cvar_VariableIntegerValue("sv_cheats"))
+	{
+		char	temp[2048];
+		Cmd_ArgsBuffer(temp, sizeof(temp));
+		R_WorldEffectCommand(temp);
+	}
+}
+
+void R_WorldEffectCommand(const char *command)
+{
+	if ( !command )
+	{
+		return;
+	}
+
+	const char	*token;//, *origCommand;
+
+	token = COM_ParseExt(&command, qfalse);
+
+	if ( !token )
+	{
+		return;
+	}
+
+
+	//Die - clean up the whole weather system -rww
+	if (strcmpi(token, "die") == 0)
+	{
+		R_ShutdownWorldEffects();
+		return;
+	}
+
+	// Clear - Removes All Particle Clouds And Wind Zones
+	//----------------------------------------------------
+	else if (strcmpi(token, "clear") == 0)
+	{
+		for (int p=0; p<mParticleClouds.size(); p++)
+		{
+			mParticleClouds[p].Reset();
+		}
+		mParticleClouds.clear();
+		mWindZones.clear();
+	}
+
+	// Freeze / UnFreeze - Stops All Particle Motion Updates
+	//--------------------------------------------------------
+	else if (strcmpi(token, "freeze") == 0)
+	{
+		mFrozen = !mFrozen;
+	}
+
+	// Add a zone
+	//---------------
+	else if (strcmpi(token, "zone") == 0)
+	{
+		vec3_t	mins;
+		vec3_t	maxs;
+		if (ParseVector(&command, 3, mins) && ParseVector(&command, 3, maxs))
+		{
+			mOutside.AddWeatherZone(mins, maxs);
+		}
+	}
+
+	// Basic Wind
+	//------------
+	else if (strcmpi(token, "wind") == 0)
+	{
+		if (mWindZones.full())
+		{
+			return;
+		}
+		CWindZone& nWind = mWindZones.push_back();
+		nWind.Initialize();
+	}
+
+	// Constant Wind
+	//---------------
+	else if (strcmpi(token, "constantwind") == 0)
+	{
+		if (mWindZones.full())
+		{
+			return;
+		}
+		CWindZone& nWind = mWindZones.push_back();
+		nWind.Initialize();
+		if (!ParseVector(&command, 3, nWind.mCurrentVelocity.v))
+		{
+			nWind.mCurrentVelocity.Clear();
+			nWind.mCurrentVelocity[1] = 800.0f;
+		}
+		nWind.mTargetVelocityTimeRemaining = -1;
+	}
+
+	// Gusting Wind
+	//--------------
+	else if (strcmpi(token, "gustingwind") == 0)
+	{
+		if (mWindZones.full())
+		{
+			return;
+		}
+		CWindZone& nWind = mWindZones.push_back();
+		nWind.Initialize();
+		nWind.mRVelocity.mMins				= -3000.0f;
+		nWind.mRVelocity.mMins[2]			= -100.0f;
+		nWind.mRVelocity.mMaxs				=  3000.0f;
+		nWind.mRVelocity.mMaxs[2]			=  100.0f;
+
+		nWind.mMaxDeltaVelocityPerUpdate	=  10.0f;
+
+		nWind.mRDuration.mMin				=  1000;
+		nWind.mRDuration.mMax				=  3000;
+
+		nWind.mChanceOfDeadTime				=  0.5f;
+		nWind.mRDeadTime.mMin				=  2000;
+		nWind.mRDeadTime.mMax				=  4000;
+	}
+
+
+
+	// Create A Rain Storm
+	//---------------------
+	else if (strcmpi(token, "lightrain") == 0)
+	{
+		if (mParticleClouds.full())
+		{
+			return;
+		}
+		CWeatherParticleCloud& nCloud = mParticleClouds.push_back();
+		nCloud.Initialize(500, "gfx/world/rain.jpg", 3);
+		nCloud.mHeight		= 80.0f;
+		nCloud.mWidth		= 1.2f;
+		nCloud.mGravity		= 2000.0f;
+		nCloud.mFilterMode	= 1;
+		nCloud.mBlendMode	= 1;
+		nCloud.mFade		= 100.0f;
+		nCloud.mColor		= 0.5f;
+		nCloud.mOrientWithVelocity = true;
+		nCloud.mWaterParticles = true;
+	}
+
+	// Create A Rain Storm
+	//---------------------
+	else if (strcmpi(token, "rain") == 0)
+	{
+		if (mParticleClouds.full())
+		{
+			return;
+		}
+		CWeatherParticleCloud& nCloud = mParticleClouds.push_back();
+		nCloud.Initialize(1000, "gfx/world/rain.jpg", 3);
+		nCloud.mHeight		= 80.0f;
+		nCloud.mWidth		= 1.2f;
+		nCloud.mGravity		= 2000.0f;
+		nCloud.mFilterMode	= 1;
+		nCloud.mBlendMode	= 1;
+		nCloud.mFade		= 100.0f;
+		nCloud.mColor		= 0.5f;
+		nCloud.mOrientWithVelocity = true;
+		nCloud.mWaterParticles = true;
+	}
+
+	// Create A Rain Storm
+	//---------------------
+	else if (strcmpi(token, "acidrain") == 0)
+	{
+		if (mParticleClouds.full())
+		{
+			return;
+		}
+		CWeatherParticleCloud& nCloud = mParticleClouds.push_back();
+		nCloud.Initialize(1000, "gfx/world/rain.jpg", 3);
+		nCloud.mHeight		= 80.0f;
+		nCloud.mWidth		= 2.0f;
+		nCloud.mGravity		= 2000.0f;
+		nCloud.mFilterMode	= 1;
+		nCloud.mBlendMode	= 1;
+		nCloud.mFade		= 100.0f;
+		
+		nCloud.mColor[0]	= 0.34f;
+		nCloud.mColor[1]	= 0.70f;
+		nCloud.mColor[2]	= 0.34f;
+		nCloud.mColor[3]	= 0.70f;
+
+		nCloud.mOrientWithVelocity = true;
+		nCloud.mWaterParticles = true;
+
+		mOutside.mOutsidePain = 0.1f;
+	}
+
+	// Create A Rain Storm
+	//---------------------
+	else if (strcmpi(token, "heavyrain") == 0)
+	{
+		if (mParticleClouds.full())
+		{
+			return;
+		}
+		CWeatherParticleCloud& nCloud = mParticleClouds.push_back();
+		nCloud.Initialize(1000, "gfx/world/rain.jpg", 3);
+		nCloud.mHeight		= 80.0f;
+		nCloud.mWidth		= 1.2f;
+		nCloud.mGravity		= 2800.0f;
+		nCloud.mFilterMode	= 1;
+		nCloud.mBlendMode	= 1;
+		nCloud.mFade		= 15.0f;
+		nCloud.mColor		= 0.5f;
+		nCloud.mOrientWithVelocity = true;
+		nCloud.mWaterParticles = true;
+	}
+
+	// Create A Snow Storm
+	//---------------------
+	else if (strcmpi(token, "snow") == 0)
+	{
+		if (mParticleClouds.full())
+		{
+			return;
+		}
+		CWeatherParticleCloud& nCloud = mParticleClouds.push_back();
+#ifdef _XBOX
+		nCloud.Initialize(1000, "gfx/effects/snowflake1.bmp", 1);
+#else
+		nCloud.Initialize(1000, "gfx/effects/snowflake1.bmp");
+#endif
+		nCloud.mBlendMode			= 1;
+		nCloud.mRotationChangeNext	= 0;
+		nCloud.mColor		= 0.75f;
+		nCloud.mWaterParticles = true;
+#ifdef _XBOX
+		nCloud.mWidth = 0.05f;
+#endif
+	}
+
+	// Create A Some stuff
+	//---------------------
+	else if (strcmpi(token, "spacedust") == 0)
+	{
+		int count;
+		if (mParticleClouds.full())
+		{
+			return;
+		}
+		token = COM_ParseExt(&command, qfalse);
+		count = atoi(token);
+
+		CWeatherParticleCloud& nCloud = mParticleClouds.push_back();
+		nCloud.Initialize(count, "gfx/effects/snowpuff1.tga");
+		nCloud.mHeight		= 1.2f;
+		nCloud.mWidth		= 1.2f;
+		nCloud.mGravity		= 0.0f;
+		nCloud.mBlendMode			= 1;
+		nCloud.mRotationChangeNext	= 0;
+		nCloud.mColor		= 0.75f;
+		nCloud.mWaterParticles = true;
+		nCloud.mMass.mMax	= 30.0f;
+		nCloud.mMass.mMin	= 10.0f;
+		nCloud.mSpawnRange.mMins[0]	= -1500.0f;
+		nCloud.mSpawnRange.mMins[1]	= -1500.0f;
+		nCloud.mSpawnRange.mMins[2]	= -1500.0f;
+		nCloud.mSpawnRange.mMaxs[0]	= 1500.0f;
+		nCloud.mSpawnRange.mMaxs[1]	= 1500.0f;
+		nCloud.mSpawnRange.mMaxs[2]	= 1500.0f;
+	}
+
+	// Create A Sand Storm
+	//---------------------
+	else if (strcmpi(token, "sand") == 0)
+	{
+		if (mParticleClouds.full())
+		{
+			return;
+		}
+		CWeatherParticleCloud& nCloud = mParticleClouds.push_back();
+		nCloud.Initialize(400, "gfx/effects/alpha_smoke2b.tga");
+
+		nCloud.mGravity		= 0;
+ 		nCloud.mWidth		= 70;
+		nCloud.mHeight		= 70;
+		nCloud.mColor[0]	= 0.9f;
+		nCloud.mColor[1]	= 0.6f;
+		nCloud.mColor[2]	= 0.0f;
+		nCloud.mColor[3]	= 0.5f;
+		nCloud.mFade		= 5.0f;
+		nCloud.mMass.mMax	= 30.0f;
+		nCloud.mMass.mMin	= 10.0f;
+		nCloud.mSpawnRange.mMins[2]	= -150;
+		nCloud.mSpawnRange.mMaxs[2]	= 150;
+
+		nCloud.mRotationChangeNext	= 0;
+	}
+
+	// Create Blowing Clouds Of Fog
+	//------------------------------
+	else if (strcmpi(token, "fog") == 0)
+	{
+		if (mParticleClouds.full())
+		{
+			return;
+		}
+		CWeatherParticleCloud& nCloud = mParticleClouds.push_back();
+		nCloud.Initialize(60, "gfx/effects/alpha_smoke2b.tga");
+		nCloud.mBlendMode	= 1;
+		nCloud.mGravity		= 0;
+ 		nCloud.mWidth		= 70;
+		nCloud.mHeight		= 70;
+		nCloud.mColor		= 0.2f;
+		nCloud.mFade		= 5.0f;
+		nCloud.mMass.mMax	= 30.0f;
+		nCloud.mMass.mMin	= 10.0f;
+		nCloud.mSpawnRange.mMins[2]	= -150;
+		nCloud.mSpawnRange.mMaxs[2]	= 150;
+
+		nCloud.mRotationChangeNext	= 0;
+	}
+
+	// Create Heavy Rain Particle Cloud
+	//-----------------------------------
+	else if (strcmpi(token, "heavyrainfog") == 0)
+	{
+		if (mParticleClouds.full())
+		{
+			return;
+		}
+		CWeatherParticleCloud& nCloud = mParticleClouds.push_back();
+ 		nCloud.Initialize(70, "gfx/effects/alpha_smoke2b.tga");
+		nCloud.mBlendMode	= 1;
+		nCloud.mGravity		= 0;
+ 		nCloud.mWidth		= 100;
+		nCloud.mHeight		= 100;
+		nCloud.mColor		= 0.3f;
+		nCloud.mFade		= 1.0f;
+		nCloud.mMass.mMax	= 10.0f;
+		nCloud.mMass.mMin	= 5.0f;
+
+		nCloud.mSpawnRange.mMins	= -(nCloud.mSpawnPlaneDistance*1.25f);
+		nCloud.mSpawnRange.mMaxs	=  (nCloud.mSpawnPlaneDistance*1.25f);
+		nCloud.mSpawnRange.mMins[2]	= -150;
+		nCloud.mSpawnRange.mMaxs[2]	=  150;
+
+		nCloud.mRotationChangeNext	= 0;
+	}
+
+	// Create Blowing Clouds Of Fog
+	//------------------------------
+	else if (strcmpi(token, "light_fog") == 0)
+	{
+		if (mParticleClouds.full())
+		{
+			return;
+		}
+		CWeatherParticleCloud& nCloud = mParticleClouds.push_back();
+		nCloud.Initialize(40, "gfx/effects/alpha_smoke2b.tga");
+		nCloud.mBlendMode	= 1;
+		nCloud.mGravity		= 0;
+ 		nCloud.mWidth		= 100;
+		nCloud.mHeight		= 100;
+		nCloud.mColor[0]	= 0.19f;
+		nCloud.mColor[1]	= 0.6f;
+		nCloud.mColor[2]	= 0.7f;
+		nCloud.mColor[3]	= 0.12f;
+		nCloud.mFade		= 0.10f;
+		nCloud.mMass.mMax	= 30.0f;
+		nCloud.mMass.mMin	= 10.0f;
+		nCloud.mSpawnRange.mMins[2]	= -150;
+		nCloud.mSpawnRange.mMaxs[2]	= 150;
+
+		nCloud.mRotationChangeNext	= 0;
+	}
+
+	else if (strcmpi(token, "outsideshake") == 0)
+	{
+		mOutside.mOutsideShake = !mOutside.mOutsideShake;
+	}
+	else if (strcmpi(token, "outsidepain") == 0)
+	{
+		mOutside.mOutsidePain = !mOutside.mOutsidePain;
+	}
+	else
+	{
+		Com_Printf( "Weather Effect: Please enter a valid command.\n" );
+		Com_Printf( "	clear\n" );
+		Com_Printf( "	freeze\n" );
+		Com_Printf( "	zone (mins) (maxs)\n" );
+		Com_Printf( "	wind\n" );
+		Com_Printf( "	constantwind (velocity)\n" );
+		Com_Printf( "	gustingwind\n" );
+		Com_Printf( "	windzone (mins) (maxs) (velocity)\n" );
+		Com_Printf( "	lightrain\n" );
+		Com_Printf( "	rain\n" );
+		Com_Printf( "	acidrain\n" );
+		Com_Printf( "	heavyrain\n" );
+		Com_Printf( "	snow\n" );
+		Com_Printf( "	spacedust\n" );
+		Com_Printf( "	sand\n" );
+		Com_Printf( "	fog\n" );
+		Com_Printf( "	heavyrainfog\n" );
+		Com_Printf( "	light_fog\n" );
+		Com_Printf( "	outsideshake\n" );
+		Com_Printf( "	outsidepain\n" );
+	}
+}
+
+
+
+float R_GetChanceOfSaberFizz()
+{
+ 	float	chance = 0.0f;
+	int		numWater = 0;
+	for (int i=0; i<mParticleClouds.size(); i++)
+	{
+		if (mParticleClouds[i].mWaterParticles)
+		{
+			chance += (mParticleClouds[i].mGravity/20000.0f);
+			numWater ++;
+		}
+	}
+	if (numWater)
+	{
+		return (chance / numWater);
+	}
+	return 0.0f;
+}
+
+bool R_IsRaining()
+{
+	return !mParticleClouds.empty();
+}
+
+bool R_IsPuffing()
+{ //Eh? Don't want surfacesprites to know this?
+	return false;
+}
+
+
+
diff --git a/codemp/renderer/tr_WorldEffects.h b/codemp/renderer/tr_WorldEffects.h
new file mode 100644
index 0000000..7dc9152
--- /dev/null
+++ b/codemp/renderer/tr_WorldEffects.h
@@ -0,0 +1,108 @@
+#if defined (_MSC_VER) && (_MSC_VER >= 1020)
+#pragma once
+#endif
+#if !defined __TR_WORLDEFFECTS_H
+#define __TR_WORLDEFFECTS_H
+
+class CWorldEffectsSystem;
+
+
+
+#define PARTICLE_FLAG_RENDER			0x00000001
+
+struct	SParticle
+{
+	vec3_t		pos;
+	vec3_t		velocity;
+	unsigned	flags;
+};
+
+
+
+class CWorldEffect
+{
+protected:
+	CWorldEffect	*mNext, *mSlave, *mOwner;
+	bool			mEnabled, mIsSlave;
+
+public:
+	enum
+	{
+		WORLDEFFECT_ENABLED = 0,
+		WORLDEFFECT_PARTICLES,
+		WORLDEFFECT_PARTICLE_COUNT,
+
+		WORLDEFFECT_END
+	};
+
+public:
+			CWorldEffect(CWorldEffect *owner = 0);
+	virtual ~CWorldEffect(void);
+	
+	void			SetNext(CWorldEffect *next) { mNext = next; }
+	CWorldEffect	*GetNext(void) { return mNext; }
+	void			SetSlave(CWorldEffect *slave) { mSlave = slave; }
+	CWorldEffect	*GetSlave(void) { return mSlave; }
+	void			AddSlave(CWorldEffect *slave);
+
+	void			SetIsSlave(bool isSlave) { mIsSlave = isSlave; }
+	void			SetOwner(CWorldEffect *owner) { mOwner = owner; }
+
+	virtual	bool	Command(const char *command);
+
+	virtual	void	ParmUpdate(CWorldEffectsSystem *system, int which);
+	virtual	void	ParmUpdate(CWorldEffect *effect, int which);
+	virtual	void	SetVariable(int which, bool newValue, bool doSlave = false);
+	virtual	void	SetVariable(int which, float newValue, bool doSlave = false);
+	virtual	void	SetVariable(int which, int newValue, bool doSlave = false);
+	virtual	void	SetVariable(int which, vec3_t newValue, bool doSlave = false);
+
+	virtual	int			GetIntVariable(int which) { return 0; }
+	virtual	SParticle	*GetParticleVariable(int which) { return 0; }
+
+	virtual	void	Update(CWorldEffectsSystem *system, float elapseTime);
+	virtual	void	Render(CWorldEffectsSystem *system);
+};
+
+
+
+class CWorldEffectsSystem
+{
+protected:
+	CWorldEffect	*mList, *mLast;
+
+public:
+			CWorldEffectsSystem(void);
+	virtual	~CWorldEffectsSystem(void);
+
+			void	AddWorldEffect(CWorldEffect *effect);
+
+	virtual	int			GetIntVariable(int which) { return 0; }
+	virtual	SParticle	*GetParticleVariable(int which) { return 0; }
+	virtual float		GetFloatVariable(int which) { return 0.0; }
+	virtual	float		*GetVecVariable(int which) { return 0; }
+
+	virtual	bool	Command(const char *command);
+
+	virtual	void	Update(float elapseTime);
+	virtual	void	ParmUpdate(int which);
+	virtual	void	Render(void);
+};
+
+
+void R_InitWorldEffects(void);
+void R_ShutdownWorldEffects(void);
+void RB_RenderWorldEffects(void);
+
+void R_WorldEffectCommand(const char *command);
+void R_WorldEffect_f(void);
+
+bool R_GetWindVector(vec3_t windVector);
+bool R_GetWindSpeed(float &windSpeed);
+
+bool R_IsRaining();
+//bool R_IsSnowing();
+bool R_IsPuffing();
+void R_AddWeatherZone(vec3_t mins, vec3_t maxs);
+
+#endif // __TR_WORLDEFFECTS_H
diff --git a/codemp/renderer/tr_animation.cpp b/codemp/renderer/tr_animation.cpp
new file mode 100644
index 0000000..1e65c46
--- /dev/null
+++ b/codemp/renderer/tr_animation.cpp
@@ -0,0 +1,16 @@
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+#include "tr_local.h"
+
+/*
+
+All bones should be an identity orientation to display the mesh exactly
+as it is specified.
+
+For all other frames, the bones represent the transformation from the 
+orientation of the bone in the base frame to the orientation in this
+frame.
+
+*/
+
diff --git a/codemp/renderer/tr_arioche.cpp b/codemp/renderer/tr_arioche.cpp
new file mode 100644
index 0000000..d5eb347
--- /dev/null
+++ b/codemp/renderer/tr_arioche.cpp
@@ -0,0 +1,117 @@
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+#include "tr_local.h"
+#include "tr_worldeffects.h"
+
+// Patches up the loaded map to handle the parameters passed from the UI
+
+// Remap sky to contents of the cvar ar_sky
+// Grab sunlight properties from the indirected sky
+
+void R_RMGInit(void)
+{
+	char			newSky[MAX_QPATH];
+	char			newFog[MAX_QPATH];
+	shader_t		*sky;
+	shader_t		*fog;
+	fog_t			*gfog;
+	mgrid_t			*grid;
+	char			temp[MAX_QPATH];
+	int				i;
+	unsigned short	*pos;
+
+	Cvar_VariableStringBuffer("RMG_sky", newSky, MAX_QPATH);
+	// Get sunlight - this should set up all the sunlight data
+	sky = R_FindShader( newSky, lightmapsNone, stylesDefault, qfalse );
+
+	// Remap sky
+	R_RemapShader("textures/tools/_sky", newSky, NULL);
+
+	// Fill in the lightgrid with sunlight
+	if(tr.world->lightGridData)
+	{
+#ifdef _XBOX
+		byte *memory = (byte *)tr.world->lightGridData;
+
+		byte *array;
+		array = memory;
+		memory += 3;
+
+		array[0] = (byte)Com_Clamp(0, 255, tr.sunAmbient[0] * 255.0f);
+		array[1] = (byte)Com_Clamp(0, 255, tr.sunAmbient[1] * 255.0f);
+		array[2] = (byte)Com_Clamp(0, 255, tr.sunAmbient[2] * 255.0f);
+		
+		array[3] = (byte)Com_Clamp(0, 255, tr.sunLight[0]);
+		array[4] = (byte)Com_Clamp(0, 255, tr.sunLight[1]);
+		array[5] = (byte)Com_Clamp(0, 255, tr.sunLight[2]);
+		
+		NormalToLatLong(tr.sunDirection, grid->latLong);
+#else // _XBOX
+		grid = tr.world->lightGridData;
+		grid->ambientLight[0][0] = (byte)Com_Clampi(0, 255, tr.sunAmbient[0] * 255.0f);
+		grid->ambientLight[0][1] = (byte)Com_Clampi(0, 255, tr.sunAmbient[1] * 255.0f);
+		grid->ambientLight[0][2] = (byte)Com_Clampi(0, 255, tr.sunAmbient[2] * 255.0f);
+		R_ColorShiftLightingBytes(grid->ambientLight[0], grid->ambientLight[0]);
+
+		grid->directLight[0][0] = (byte)Com_Clampi(0, 255, tr.sunLight[0]);
+		grid->directLight[0][1] = (byte)Com_Clampi(0, 255, tr.sunLight[1]);
+		grid->directLight[0][2] = (byte)Com_Clampi(0, 255, tr.sunLight[2]);
+		R_ColorShiftLightingBytes(grid->directLight[0], grid->directLight[0]);
+
+		NormalToLatLong(tr.sunDirection, grid->latLong);
+#endif // _XBOX
+
+		pos = tr.world->lightGridArray;
+		for(i=0;i<tr.world->numGridArrayElements;i++)
+		{
+			*pos = 0;
+			pos++;
+		}
+	}
+
+	// Override the global fog with the defined one
+	if(tr.world->globalFog != -1)
+	{
+		Cvar_VariableStringBuffer("RMG_fog", newFog, MAX_QPATH);
+		fog = R_FindShader( newFog, lightmapsNone, stylesDefault, qfalse);
+		if (fog != tr.defaultShader)
+		{
+			gfog = tr.world->fogs + tr.world->globalFog;
+			gfog->parms = *fog->fogParms;
+			if (gfog->parms.depthForOpaque)
+			{
+				gfog->tcScale = 1.0f / ( gfog->parms.depthForOpaque * 8.0f );
+				tr.distanceCull = gfog->parms.depthForOpaque;
+				tr.distanceCullSquared = tr.distanceCull * tr.distanceCull;
+				Cvar_Set("RMG_distancecull", va("%f", tr.distanceCull));
+			}
+			else
+			{
+				gfog->tcScale = 1.0f;
+			}
+			gfog->colorInt = ColorBytes4 ( gfog->parms.color[0], 
+										  gfog->parms.color[1], 
+										  gfog->parms.color[2], 1.0f );
+		}
+	}
+
+	Cvar_VariableStringBuffer("RMG_weather", temp, MAX_QPATH);
+
+	// Set up any weather effects
+	switch(atol(temp))
+	{
+	case 0:
+		break;
+	case 1:
+		R_WorldEffectCommand("rain init 1000");
+		R_WorldEffectCommand("rain outside");
+		break;
+	case 2:
+		R_WorldEffectCommand("snow init 1000 outside");
+		R_WorldEffectCommand("snow outside");
+		break;
+	}
+}
+
+// end
diff --git a/codemp/renderer/tr_backend.cpp b/codemp/renderer/tr_backend.cpp
new file mode 100644
index 0000000..cfa7010
--- /dev/null
+++ b/codemp/renderer/tr_backend.cpp
@@ -0,0 +1,2328 @@
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+#include "tr_local.h"
+
+#ifndef DEDICATED
+#if !defined __TR_WORLDEFFECTS_H
+	#include "tr_WorldEffects.h"
+#endif
+#endif
+
+#ifdef VV_LIGHTING
+#include "tr_lightmanager.h"
+#endif
+
+#ifdef _XBOX
+#include "../win32/win_highdynamicrange.h"
+#endif
+
+backEndData_t	*backEndData;
+backEndState_t	backEnd;
+
+bool tr_stencilled = false;
+extern qboolean tr_distortionPrePost; //tr_shadows.cpp
+extern qboolean tr_distortionNegate; //tr_shadows.cpp
+extern void RB_CaptureScreenImage(void); //tr_shadows.cpp
+extern void RB_DistortionFill(void); //tr_shadows.cpp
+static void RB_DrawGlowOverlay();
+static void RB_BlurGlowTexture();
+
+// Whether we are currently rendering only glowing objects or not.
+bool g_bRenderGlowingObjects = false;
+
+// Whether the current hardware supports dynamic glows/flares.
+bool g_bDynamicGlowSupported = false;
+
+extern void R_RotateForViewer(void);
+extern void R_SetupFrustum(void);
+
+static const float s_flipMatrix[16] = {
+	// convert from our coordinate system (looking down X)
+	// to OpenGL's coordinate system (looking down -Z)
+#if defined (_XBOX)
+	0, 0, 1, 0,
+	-1, 0, 0, 0,
+	0, 1, 0, 0,
+	0, 0, 0, 1
+#else
+	0, 0, -1, 0,
+	-1, 0, 0, 0,
+	0, 1, 0, 0,
+	0, 0, 0, 1
+#endif
+};
+
+#ifndef DEDICATED
+
+/*
+** GL_Bind
+*/
+void GL_Bind( image_t *image ) {
+	int texnum;
+
+	if ( !image ) {
+		Com_Printf (S_COLOR_YELLOW  "GL_Bind: NULL image\n" );
+		texnum = tr.defaultImage->texnum;
+	} else {
+		texnum = image->texnum;
+	}
+
+	if ( r_nobind->integer && tr.dlightImage ) {		// performance evaluation option
+		texnum = tr.dlightImage->texnum;
+	}
+
+	if ( glState.currenttextures[glState.currenttmu] != texnum ) {
+#ifndef _XBOX
+		image->frameUsed = tr.frameCount;
+#endif
+		glState.currenttextures[glState.currenttmu] = texnum;
+		qglBindTexture (GL_TEXTURE_2D, texnum);
+	}
+}
+
+//bind 3D texture -rww
+void GL_Bind3D( image_t *image )
+{
+	int texnum;
+
+	if ( !image ) {
+		Com_Printf (S_COLOR_YELLOW  "GL_Bind: NULL image\n" );
+		texnum = tr.defaultImage->texnum;
+	} else {
+		texnum = image->texnum;
+	}
+
+	if ( r_nobind->integer && tr.dlightImage ) {		// performance evaluation option
+		texnum = tr.dlightImage->texnum;
+	}
+
+	if ( glState.currenttextures[glState.currenttmu] != texnum ) {
+#ifndef _XBOX
+		image->frameUsed = tr.frameCount;
+#endif
+		glState.currenttextures[glState.currenttmu] = texnum;
+		qglBindTexture (GL_TEXTURE_3D, texnum);
+	}
+}
+
+/*
+** GL_SelectTexture
+*/
+void GL_SelectTexture( int unit )
+{
+	if ( glState.currenttmu == unit )
+	{
+		return;
+	}
+
+	if ( unit == 0 )
+	{
+		qglActiveTextureARB( GL_TEXTURE0_ARB );
+		GLimp_LogComment( "glActiveTextureARB( GL_TEXTURE0_ARB )\n" );
+		qglClientActiveTextureARB( GL_TEXTURE0_ARB );
+		GLimp_LogComment( "glClientActiveTextureARB( GL_TEXTURE0_ARB )\n" );
+	}
+	else if ( unit == 1 )
+	{
+		qglActiveTextureARB( GL_TEXTURE1_ARB );
+		GLimp_LogComment( "glActiveTextureARB( GL_TEXTURE1_ARB )\n" );
+		qglClientActiveTextureARB( GL_TEXTURE1_ARB );
+		GLimp_LogComment( "glClientActiveTextureARB( GL_TEXTURE1_ARB )\n" );
+	}
+	else if ( unit == 2 )
+	{
+		qglActiveTextureARB( GL_TEXTURE2_ARB );
+		GLimp_LogComment( "glActiveTextureARB( GL_TEXTURE2_ARB )\n" );
+		qglClientActiveTextureARB( GL_TEXTURE2_ARB );
+		GLimp_LogComment( "glClientActiveTextureARB( GL_TEXTURE2_ARB )\n" );
+	}
+	else if ( unit == 3 )
+	{
+		qglActiveTextureARB( GL_TEXTURE3_ARB );
+		GLimp_LogComment( "glActiveTextureARB( GL_TEXTURE3_ARB )\n" );
+		qglClientActiveTextureARB( GL_TEXTURE3_ARB );
+		GLimp_LogComment( "glClientActiveTextureARB( GL_TEXTURE3_ARB )\n" );
+	}
+	else {
+		Com_Error( ERR_DROP, "GL_SelectTexture: unit = %i", unit );
+	}
+
+	glState.currenttmu = unit;
+}
+
+
+/*
+** GL_Cull
+*/
+void GL_Cull( int cullType ) {
+	if ( glState.faceCulling == cullType ) {
+		return;
+	}
+	glState.faceCulling = cullType;
+	if (backEnd.projection2D){	//don't care, we're in 2d when it's always disabled
+		return;	
+	}
+
+	if ( cullType == CT_TWO_SIDED ) 
+	{
+		qglDisable( GL_CULL_FACE );
+	} 
+	else 
+	{
+		qglEnable( GL_CULL_FACE );
+
+		if ( cullType == CT_BACK_SIDED )
+		{
+			if ( backEnd.viewParms.isMirror )
+			{
+				qglCullFace( GL_FRONT );
+			}
+			else
+			{
+				qglCullFace( GL_BACK );
+			}
+		}
+		else
+		{
+			if ( backEnd.viewParms.isMirror )
+			{
+				qglCullFace( GL_BACK );
+			}
+			else
+			{
+				qglCullFace( GL_FRONT );
+			}
+		}
+	}
+}
+
+/*
+** GL_TexEnv
+*/
+void GL_TexEnv( int env )
+{
+	if ( env == glState.texEnv[glState.currenttmu] )
+	{
+		return;
+	}
+
+	glState.texEnv[glState.currenttmu] = env;
+
+
+	switch ( env )
+	{
+	case GL_MODULATE:
+		qglTexEnvf( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE );
+		break;
+	case GL_REPLACE:
+		qglTexEnvf( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE );
+		break;
+	case GL_DECAL:
+		qglTexEnvf( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL );
+		break;
+	case GL_ADD:
+		qglTexEnvf( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_ADD );
+		break;
+#ifdef _XBOX
+	case GL_NONE:
+		qglTexEnvf( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_NONE );
+		break;
+#endif
+	default:
+		Com_Error( ERR_DROP, "GL_TexEnv: invalid env '%d' passed\n", env );
+		break;
+	}
+}
+
+/*
+** GL_State
+**
+** This routine is responsible for setting the most commonly changed state
+** in Q3.
+*/
+void GL_State( unsigned long stateBits )
+{
+	unsigned long diff = stateBits ^ glState.glStateBits;
+
+	if ( !diff )
+	{
+		return;
+	}
+
+	//
+	// check depthFunc bits
+	//
+	if ( diff & GLS_DEPTHFUNC_EQUAL )
+	{
+		if ( stateBits & GLS_DEPTHFUNC_EQUAL )
+		{
+			qglDepthFunc( GL_EQUAL );
+		}
+		else
+		{
+			qglDepthFunc( GL_LEQUAL );
+		}
+	}
+
+	//
+	// check blend bits
+	//
+	if ( diff & ( GLS_SRCBLEND_BITS | GLS_DSTBLEND_BITS ) )
+	{
+		GLenum srcFactor, dstFactor;
+
+		if ( stateBits & ( GLS_SRCBLEND_BITS | GLS_DSTBLEND_BITS ) )
+		{
+			switch ( stateBits & GLS_SRCBLEND_BITS )
+			{
+			case GLS_SRCBLEND_ZERO:
+				srcFactor = GL_ZERO;
+				break;
+			case GLS_SRCBLEND_ONE:
+				srcFactor = GL_ONE;
+				break;
+			case GLS_SRCBLEND_DST_COLOR:
+				srcFactor = GL_DST_COLOR;
+				break;
+			case GLS_SRCBLEND_ONE_MINUS_DST_COLOR:
+				srcFactor = GL_ONE_MINUS_DST_COLOR;
+				break;
+			case GLS_SRCBLEND_SRC_ALPHA:
+				srcFactor = GL_SRC_ALPHA;
+				break;
+			case GLS_SRCBLEND_ONE_MINUS_SRC_ALPHA:
+				srcFactor = GL_ONE_MINUS_SRC_ALPHA;
+				break;
+			case GLS_SRCBLEND_DST_ALPHA:
+				srcFactor = GL_DST_ALPHA;
+				break;
+			case GLS_SRCBLEND_ONE_MINUS_DST_ALPHA:
+				srcFactor = GL_ONE_MINUS_DST_ALPHA;
+				break;
+			case GLS_SRCBLEND_ALPHA_SATURATE:
+				srcFactor = GL_SRC_ALPHA_SATURATE;
+				break;
+			default:
+				srcFactor = GL_ONE;		// to get warning to shut up
+				Com_Error( ERR_DROP, "GL_State: invalid src blend state bits\n" );
+				break;
+			}
+
+			switch ( stateBits & GLS_DSTBLEND_BITS )
+			{
+			case GLS_DSTBLEND_ZERO:
+				dstFactor = GL_ZERO;
+				break;
+			case GLS_DSTBLEND_ONE:
+				dstFactor = GL_ONE;
+				break;
+			case GLS_DSTBLEND_SRC_COLOR:
+				dstFactor = GL_SRC_COLOR;
+				break;
+			case GLS_DSTBLEND_ONE_MINUS_SRC_COLOR:
+				dstFactor = GL_ONE_MINUS_SRC_COLOR;
+				break;
+			case GLS_DSTBLEND_SRC_ALPHA:
+				dstFactor = GL_SRC_ALPHA;
+				break;
+			case GLS_DSTBLEND_ONE_MINUS_SRC_ALPHA:
+				dstFactor = GL_ONE_MINUS_SRC_ALPHA;
+				break;
+			case GLS_DSTBLEND_DST_ALPHA:
+				dstFactor = GL_DST_ALPHA;
+				break;
+			case GLS_DSTBLEND_ONE_MINUS_DST_ALPHA:
+				dstFactor = GL_ONE_MINUS_DST_ALPHA;
+				break;
+			default:
+				dstFactor = GL_ONE;		// to get warning to shut up
+				Com_Error( ERR_DROP, "GL_State: invalid dst blend state bits\n" );
+				break;
+			}
+
+			qglEnable( GL_BLEND );
+			qglBlendFunc( srcFactor, dstFactor );
+		}
+		else
+		{
+			qglDisable( GL_BLEND );
+		}
+	}
+
+	//
+	// check depthmask
+	//
+	if ( diff & GLS_DEPTHMASK_TRUE )
+	{
+		if ( stateBits & GLS_DEPTHMASK_TRUE )
+		{
+			qglDepthMask( GL_TRUE );
+		}
+		else
+		{
+			qglDepthMask( GL_FALSE );
+		}
+	}
+
+	//
+	// fill/line mode
+	//
+	if ( diff & GLS_POLYMODE_LINE )
+	{
+		if ( stateBits & GLS_POLYMODE_LINE )
+		{
+			qglPolygonMode( GL_FRONT_AND_BACK, GL_LINE );
+		}
+		else
+		{
+			qglPolygonMode( GL_FRONT_AND_BACK, GL_FILL );
+		}
+	}
+
+	//
+	// depthtest
+	//
+	if ( diff & GLS_DEPTHTEST_DISABLE )
+	{
+		if ( stateBits & GLS_DEPTHTEST_DISABLE )
+		{
+			qglDisable( GL_DEPTH_TEST );
+		}
+		else
+		{
+			qglEnable( GL_DEPTH_TEST );
+		}
+	}
+
+	//
+	// alpha test
+	//
+	if ( diff & GLS_ATEST_BITS )
+	{
+		switch ( stateBits & GLS_ATEST_BITS )
+		{
+		case 0:
+			qglDisable( GL_ALPHA_TEST );
+			break;
+		case GLS_ATEST_GT_0:
+			qglEnable( GL_ALPHA_TEST );
+			qglAlphaFunc( GL_GREATER, 0.0f );
+			break;
+		case GLS_ATEST_LT_80:
+			qglEnable( GL_ALPHA_TEST );
+			qglAlphaFunc( GL_LESS, 0.5f );
+			break;
+		case GLS_ATEST_GE_80:
+			qglEnable( GL_ALPHA_TEST );
+			qglAlphaFunc( GL_GEQUAL, 0.5f );
+			break;
+		case GLS_ATEST_GE_C0:
+			qglEnable( GL_ALPHA_TEST );
+			qglAlphaFunc( GL_GEQUAL, 0.75f );
+			break;
+		default:
+			assert( 0 );
+			break;
+		}
+	}
+
+	glState.glStateBits = stateBits;
+}
+
+
+
+/*
+================
+RB_Hyperspace
+
+A player has predicted a teleport, but hasn't arrived yet
+================
+*/
+static void RB_Hyperspace( void ) {
+	float		c;
+
+	if ( !backEnd.isHyperspace ) {
+		// do initialization shit
+	}
+
+	c = ( backEnd.refdef.time & 255 ) / 255.0f;
+	qglClearColor( c, c, c, 1 );
+	qglClear( GL_COLOR_BUFFER_BIT );
+
+	backEnd.isHyperspace = qtrue;
+}
+
+
+void SetViewportAndScissor( void ) {
+	qglMatrixMode(GL_PROJECTION);
+	qglLoadMatrixf( backEnd.viewParms.projectionMatrix );
+	qglMatrixMode(GL_MODELVIEW);
+
+	// set the window clipping
+	qglViewport( backEnd.viewParms.viewportX, backEnd.viewParms.viewportY, 
+		backEnd.viewParms.viewportWidth, backEnd.viewParms.viewportHeight );
+	qglScissor( backEnd.viewParms.viewportX, backEnd.viewParms.viewportY, 
+		backEnd.viewParms.viewportWidth, backEnd.viewParms.viewportHeight );
+}
+
+/*
+=================
+RB_BeginDrawingView
+
+Any mirrored or portaled views have already been drawn, so prepare
+to actually render the visible surfaces for this view
+=================
+*/
+void RB_BeginDrawingView (void) {
+	int clearBits = GL_DEPTH_BUFFER_BIT;
+
+	// sync with gl if needed
+	if ( r_finish->integer == 1 && !glState.finishCalled ) {
+		qglFinish ();
+		glState.finishCalled = qtrue;
+	}
+	if ( r_finish->integer == 0 ) {
+		glState.finishCalled = qtrue;
+	}
+
+	// we will need to change the projection matrix before drawing
+	// 2D images again
+	backEnd.projection2D = qfalse;
+
+	//
+	// set the modelview matrix for the viewer
+	//
+	SetViewportAndScissor();
+
+	// ensures that depth writes are enabled for the depth clear
+	GL_State( GLS_DEFAULT );
+
+	// clear relevant buffers
+	if ( r_measureOverdraw->integer || r_shadows->integer == 2 || tr_stencilled )
+	{
+		clearBits |= GL_STENCIL_BUFFER_BIT;
+		tr_stencilled = false;
+	}
+
+	if (skyboxportal)
+	{
+		if ( backEnd.refdef.rdflags & RDF_SKYBOXPORTAL )
+		{	// portal scene, clear whatever is necessary
+			if (r_fastsky->integer || (backEnd.refdef.rdflags & RDF_NOWORLDMODEL) )
+			{	// fastsky: clear color
+				// try clearing first with the portal sky fog color, then the world fog color, then finally a default
+				clearBits |= GL_COLOR_BUFFER_BIT;
+				//rwwFIXMEFIXME: Clear with fog color if there is one
+				qglClearColor ( 0.5, 0.5, 0.5, 1.0 );
+			} 
+		}
+	}
+	else
+	{
+		if ( r_fastsky->integer && !( backEnd.refdef.rdflags & RDF_NOWORLDMODEL ) && !g_bRenderGlowingObjects )
+		{
+			clearBits |= GL_COLOR_BUFFER_BIT;	// FIXME: only if sky shaders have been used
+#ifdef _DEBUG
+			qglClearColor( 0.8f, 0.7f, 0.4f, 1.0f );	// FIXME: get color of sky
+#else
+			qglClearColor( 0.0f, 0.0f, 0.0f, 1.0f );	// FIXME: get color of sky
+#endif
+		}
+	}
+
+	if ( tr.refdef.rdflags & RDF_AUTOMAP || (!( backEnd.refdef.rdflags & RDF_NOWORLDMODEL ) && r_DynamicGlow->integer && !g_bRenderGlowingObjects ) )
+	{
+		if (tr.world && tr.world->globalFog != -1)
+		{ //this is because of a bug in multiple scenes I think, it needs to clear for the second scene but it doesn't normally.
+			const fog_t		*fog = &tr.world->fogs[tr.world->globalFog];
+
+			clearBits |= GL_COLOR_BUFFER_BIT;
+			qglClearColor(fog->parms.color[0],  fog->parms.color[1], fog->parms.color[2], 1.0f );
+		}
+	}
+
+	// If this pass is to just render the glowing objects, don't clear the depth buffer since
+	// we're sharing it with the main scene (since the main scene has already been rendered). -AReis
+	if ( g_bRenderGlowingObjects )
+	{
+		clearBits &= ~GL_DEPTH_BUFFER_BIT;
+	}
+
+	if (clearBits)
+	{
+		qglClear( clearBits );
+	}
+
+	if ( ( backEnd.refdef.rdflags & RDF_HYPERSPACE ) )
+	{
+		RB_Hyperspace();
+		return;
+	}
+	else
+	{
+		backEnd.isHyperspace = qfalse;
+	}
+
+	glState.faceCulling = -1;		// force face culling to set next time
+
+	// we will only draw a sun if there was sky rendered in this view
+	backEnd.skyRenderedThisView = qfalse;
+
+	// clip to the plane of the portal
+	if ( backEnd.viewParms.isPortal ) {
+		float	plane[4];
+		double	plane2[4];
+
+		plane[0] = backEnd.viewParms.portalPlane.normal[0];
+		plane[1] = backEnd.viewParms.portalPlane.normal[1];
+		plane[2] = backEnd.viewParms.portalPlane.normal[2];
+		plane[3] = backEnd.viewParms.portalPlane.dist;
+
+		plane2[0] = DotProduct (backEnd.viewParms.ori.axis[0], plane);
+		plane2[1] = DotProduct (backEnd.viewParms.ori.axis[1], plane);
+		plane2[2] = DotProduct (backEnd.viewParms.ori.axis[2], plane);
+		plane2[3] = DotProduct (plane, backEnd.viewParms.ori.origin) - plane[3];
+
+		qglLoadMatrixf( s_flipMatrix );
+		qglClipPlane (GL_CLIP_PLANE0, plane2);
+		qglEnable (GL_CLIP_PLANE0);
+	} else {
+		qglDisable (GL_CLIP_PLANE0);
+	}
+}
+
+#define	MAC_EVENT_PUMP_MSEC		5
+
+//used by RF_DISTORTION
+static inline bool R_WorldCoordToScreenCoordFloat(vec3_t worldCoord, float *x, float *y)
+{
+	int	xcenter, ycenter;
+	vec3_t	local, transformed;
+	vec3_t	vfwd;
+	vec3_t	vright;
+	vec3_t	vup;
+	float xzi;
+	float yzi;
+
+	xcenter = glConfig.vidWidth / 2;
+	ycenter = glConfig.vidHeight / 2;
+
+	//AngleVectors (tr.refdef.viewangles, vfwd, vright, vup);
+	VectorCopy(tr.refdef.viewaxis[0], vfwd);
+	VectorCopy(tr.refdef.viewaxis[1], vright);
+	VectorCopy(tr.refdef.viewaxis[2], vup);
+
+	VectorSubtract (worldCoord, tr.refdef.vieworg, local);
+
+	transformed[0] = DotProduct(local,vright);
+	transformed[1] = DotProduct(local,vup);
+	transformed[2] = DotProduct(local,vfwd);		
+
+	// Make sure Z is not negative.
+	if(transformed[2] < 0.01)
+	{
+		return false;
+	}
+
+	xzi = xcenter / transformed[2] * (90.0/tr.refdef.fov_x);
+	yzi = ycenter / transformed[2] * (90.0/tr.refdef.fov_y);
+
+	*x = xcenter + xzi * transformed[0];
+	*y = ycenter - yzi * transformed[1];
+
+	return true;
+}
+
+//used by RF_DISTORTION
+static inline bool R_WorldCoordToScreenCoord( vec3_t worldCoord, int *x, int *y )
+{
+	float	xF, yF;
+	bool retVal = R_WorldCoordToScreenCoordFloat( worldCoord, &xF, &yF );
+	*x = (int)xF;
+	*y = (int)yF;
+	return retVal;
+}
+
+/*
+==================
+RB_RenderDrawSurfList
+==================
+*/
+//number of possible surfs we can postrender.
+//note that postrenders lack much of the optimization that the standard sort-render crap does,
+//so it's slower.
+#define MAX_POST_RENDERS	128
+
+typedef struct
+{
+	int			fogNum;
+	int			entNum;
+	int			dlighted;
+	int			depthRange;
+	drawSurf_t	*drawSurf;
+	shader_t	*shader;
+	qboolean	eValid;
+} postRender_t;
+
+static postRender_t g_postRenders[MAX_POST_RENDERS];
+static int g_numPostRenders = 0;
+
+//get the "average" (ideally center) position of a surface on the tess.
+//this is a kind of lame method because I can't think correctly right now.
+static inline bool R_AverageTessXYZ(vec3_t dest)
+{
+	int i = 1;
+	float bd = 0.0f;
+	float d = 0.0f;
+	int b = -1;
+	vec3_t v;
+
+	while (i < tess.numVertexes)
+	{
+		VectorSubtract(tess.xyz[i], tess.xyz[i], v);
+		d = VectorLength(v);
+		if (b == -1 || d < bd)
+		{
+			b = i;
+			bd = d;
+		}
+		i++;
+	}
+	if (b != -1)
+	{
+		VectorSubtract(tess.xyz[0], tess.xyz[b], v);
+
+		VectorScale(v, 0.5f, dest);
+		VectorAdd(dest, tess.xyz[0], dest);
+
+		return true;
+	}
+
+	return false;
+}
+
+void RB_RenderDrawSurfList( drawSurf_t *drawSurfs, int numDrawSurfs ) {
+	shader_t		*shader, *oldShader;
+	int				fogNum, oldFogNum;
+	int				entityNum, oldEntityNum;
+	int				dlighted, oldDlighted;
+	int				depthRange, oldDepthRange;
+	int				i;
+	drawSurf_t		*drawSurf;
+	unsigned int	oldSort;
+	float			originalTime;
+	trRefEntity_t	*curEnt;
+	postRender_t	*pRender;
+	bool			didShadowPass = false;
+#ifdef __MACOS__
+	int				macEventTime;
+
+	Sys_PumpEvents();		// crutch up the mac's limited buffer queue size
+
+	// we don't want to pump the event loop too often and waste time, so
+	// we are going to check every shader change
+	macEventTime = Sys_Milliseconds()*com_timescale->value + MAC_EVENT_PUMP_MSEC;
+#endif
+
+	if (g_bRenderGlowingObjects)
+	{ //only shadow on initial passes
+		didShadowPass = true;
+	}
+
+	// save original time for entity shader offsets
+	originalTime = backEnd.refdef.floatTime;
+
+	// clear the z buffer, set the modelview, etc
+	RB_BeginDrawingView ();
+
+	// draw everything
+	oldEntityNum = -1;
+	backEnd.currentEntity = &tr.worldEntity;
+	oldShader = NULL;
+	oldFogNum = -1;
+	oldDepthRange = qfalse;
+	oldDlighted = qfalse;
+	oldSort = (unsigned int) -1;
+	depthRange = qfalse;
+
+	backEnd.pc.c_surfaces += numDrawSurfs;
+
+	for (i = 0, drawSurf = drawSurfs ; i < numDrawSurfs ; i++, drawSurf++)
+	{
+		if ( drawSurf->sort == oldSort )
+		{
+			// fast path, same as previous sort
+			rb_surfaceTable[ *drawSurf->surface ]( drawSurf->surface );
+			continue;
+		}
+		R_DecomposeSort( drawSurf->sort, &entityNum, &shader, &fogNum, &dlighted );
+
+#ifndef _XBOX	// GLOWXXX
+		// If we're rendering glowing objects, but this shader has no stages with glow, skip it!
+		if ( g_bRenderGlowingObjects && !shader->hasGlow )
+		{
+			shader = oldShader;
+			entityNum = oldEntityNum;
+			fogNum = oldFogNum;
+			dlighted = oldDlighted;
+			continue;
+		}
+#endif
+		oldSort = drawSurf->sort;
+
+		//
+		// change the tess parameters if needed
+		// a "entityMergable" shader is a shader that can have surfaces from seperate
+		// entities merged into a single batch, like smoke and blood puff sprites
+		if (entityNum != TR_WORLDENT &&
+			g_numPostRenders < MAX_POST_RENDERS)
+		{
+			if ( (backEnd.refdef.entities[entityNum].e.renderfx & RF_DISTORTION) ||
+				 (backEnd.refdef.entities[entityNum].e.renderfx & RF_FORCEPOST) ||
+				 (backEnd.refdef.entities[entityNum].e.renderfx & RF_FORCE_ENT_ALPHA) )
+			{ //must render last
+				curEnt = &backEnd.refdef.entities[entityNum];
+				pRender = &g_postRenders[g_numPostRenders];
+
+				g_numPostRenders++;
+
+				depthRange = 0;
+				//figure this stuff out now and store it
+				if ( curEnt->e.renderfx & RF_NODEPTH )
+				{
+					depthRange = 2;
+				}
+				else if ( curEnt->e.renderfx & RF_DEPTHHACK )
+				{
+					depthRange = 1;
+				}
+				pRender->depthRange = depthRange;
+
+				//It is not necessary to update the old* values because
+				//we are not updating now with the current values.
+				depthRange = oldDepthRange;
+
+				//store off the ent num
+				pRender->entNum = entityNum;
+
+				//remember the other values necessary for rendering this surf
+				pRender->drawSurf = drawSurf;
+				pRender->dlighted = dlighted;
+				pRender->fogNum = fogNum;
+				pRender->shader = shader;
+
+				/*
+				if (shader == tr.distortionShader)
+				{
+					pRender->eValid = qfalse;
+				}
+				else
+				*/
+				{
+					pRender->eValid = qtrue;
+				}
+
+				//assure the info is back to the last set state
+				shader = oldShader;
+				entityNum = oldEntityNum;
+				fogNum = oldFogNum;
+				dlighted = oldDlighted;
+
+				oldSort = -20; //invalidate this thing, cause we may want to postrender more surfs of the same sort
+
+				//continue without bothering to begin a draw surf
+				continue;
+			}
+		}
+		/*
+		else if (shader == tr.distortionShader &&
+			g_numPostRenders < MAX_POST_RENDERS)
+		{ //not an ent, just a surface that needs this effect
+			pRender = &g_postRenders[g_numPostRenders];
+
+			g_numPostRenders++;
+
+			depthRange = 0;
+			pRender->depthRange = depthRange;
+
+			//It is not necessary to update the old* values because
+			//we are not updating now with the current values.
+			depthRange = oldDepthRange;
+
+			//store off the ent num
+			pRender->entNum = entityNum;
+
+			//remember the other values necessary for rendering this surf
+			pRender->drawSurf = drawSurf;
+			pRender->dlighted = dlighted;
+			pRender->fogNum = fogNum;
+			pRender->shader = shader;
+
+			pRender->eValid = qfalse;
+
+			//assure the info is back to the last set state
+			shader = oldShader;
+			entityNum = oldEntityNum;
+			fogNum = oldFogNum;
+			dlighted = oldDlighted;
+
+			oldSort = -20; //invalidate this thing, cause we may want to postrender more surfs of the same sort
+
+			//continue without bothering to begin a draw surf
+			continue;
+		}
+		*/
+
+		if (shader != oldShader || fogNum != oldFogNum || dlighted != oldDlighted 
+			|| ( entityNum != oldEntityNum && !shader->entityMergable ) )
+		{
+			if (oldShader != NULL) {
+#ifdef __MACOS__	// crutch up the mac's limited buffer queue size
+				int		t;
+
+				t = Sys_Milliseconds()*com_timescale->value;
+				if ( t > macEventTime ) {
+					macEventTime = t + MAC_EVENT_PUMP_MSEC;
+					Sys_PumpEvents();
+				}
+#endif
+				RB_EndSurface();
+
+				if (!didShadowPass && shader && shader->sort > SS_BANNER)
+				{
+					RB_ShadowFinish();
+					didShadowPass = true;
+				}
+			}
+			RB_BeginSurface( shader, fogNum );
+			oldShader = shader;
+			oldFogNum = fogNum;
+			oldDlighted = dlighted;
+		}
+
+		//
+		// change the modelview matrix if needed
+		//
+		if ( entityNum != oldEntityNum ) {
+			depthRange = 0;
+
+			if ( entityNum != TR_WORLDENT ) {
+				backEnd.currentEntity = &backEnd.refdef.entities[entityNum];
+
+				backEnd.refdef.floatTime = originalTime - backEnd.currentEntity->e.shaderTime;
+				// we have to reset the shaderTime as well otherwise image animations start
+				// from the wrong frame
+				tess.shaderTime = backEnd.refdef.floatTime - tess.shader->timeOffset;
+
+				// set up the transformation matrix
+				R_RotateForEntity( backEnd.currentEntity, &backEnd.viewParms, &backEnd.ori );
+
+				// set up the dynamic lighting if needed
+				if ( backEnd.currentEntity->needDlights ) {
+#ifdef VV_LIGHTING
+					VVLightMan.R_TransformDlights( &backEnd.ori );
+#else
+					R_TransformDlights( backEnd.refdef.num_dlights, backEnd.refdef.dlights, &backEnd.ori );
+#endif
+				}
+
+				if ( backEnd.currentEntity->e.renderfx & RF_NODEPTH ) {
+					// No depth at all, very rare but some things for seeing through walls
+					depthRange = 2;
+				}
+				else if ( backEnd.currentEntity->e.renderfx & RF_DEPTHHACK ) {
+					// hack the depth range to prevent view model from poking into walls
+					depthRange = 1;
+				}
+			} else {
+				backEnd.currentEntity = &tr.worldEntity;
+				backEnd.refdef.floatTime = originalTime;
+				backEnd.ori = backEnd.viewParms.world;
+				// we have to reset the shaderTime as well otherwise image animations on
+				// the world (like water) continue with the wrong frame
+				tess.shaderTime = backEnd.refdef.floatTime - tess.shader->timeOffset;
+#ifdef VV_LIGHTING
+				VVLightMan.R_TransformDlights( &backEnd.ori );
+#else
+				R_TransformDlights( backEnd.refdef.num_dlights, backEnd.refdef.dlights, &backEnd.ori );
+#endif
+			}
+
+			qglLoadMatrixf( backEnd.ori.modelMatrix );
+
+			//
+			// change depthrange if needed
+			//
+			if ( oldDepthRange != depthRange ) {
+				switch ( depthRange ) {
+					default:
+					case 0:
+						qglDepthRange (0, 1);	
+						break;
+
+					case 1:
+						qglDepthRange (0, .3);	
+						break;
+
+					case 2:
+						qglDepthRange (0, 0);
+						break;
+				}
+
+				oldDepthRange = depthRange;
+			}
+
+			oldEntityNum = entityNum;
+		}
+
+		// add the triangles for this surface
+		rb_surfaceTable[ *drawSurf->surface ]( drawSurf->surface );
+	}
+
+	backEnd.refdef.floatTime = originalTime;
+
+	// draw the contents of the last shader batch
+	//assert(entityNum < MAX_GENTITIES);
+
+	if (oldShader != NULL) {
+		RB_EndSurface();
+	}
+
+#ifdef _CRAZY_ATTRIB_DEBUG
+	qglPopAttrib();
+	glState.glStateBits = -1;
+#endif
+
+	if (tr_stencilled && tr_distortionPrePost)
+	{ //ok, cap it now
+		RB_CaptureScreenImage();
+		RB_DistortionFill();
+	}
+
+	//render distortion surfs (or anything else that needs to be post-rendered)
+	if (g_numPostRenders > 0)
+	{
+		int lastPostEnt = -1;
+
+		while (g_numPostRenders > 0)
+		{
+			g_numPostRenders--;
+			pRender = &g_postRenders[g_numPostRenders];
+
+			RB_BeginSurface( pRender->shader, pRender->fogNum );
+
+			/*
+			if (!pRender->eValid && pRender->entNum == TR_WORLDENT)
+			{ //world/other surface
+				backEnd.currentEntity = &tr.worldEntity;
+				backEnd.refdef.floatTime = originalTime;
+				backEnd.ori = backEnd.viewParms.world;
+				// we have to reset the shaderTime as well otherwise image animations on
+				// the world (like water) continue with the wrong frame
+				tess.shaderTime = backEnd.refdef.floatTime - tess.shader->timeOffset;
+
+#ifdef VV_LIGHTING
+				VVLightMan.R_TransformDlights( &backEnd.ori );
+#else
+				R_TransformDlights( backEnd.refdef.num_dlights, backEnd.refdef.dlights, &backEnd.ori );
+#endif
+			}
+			else
+			*/
+			{ //ent
+				backEnd.currentEntity = &backEnd.refdef.entities[pRender->entNum];
+
+				backEnd.refdef.floatTime = originalTime - backEnd.currentEntity->e.shaderTime;
+				// we have to reset the shaderTime as well otherwise image animations start
+				// from the wrong frame
+				tess.shaderTime = backEnd.refdef.floatTime - tess.shader->timeOffset;
+
+				// set up the transformation matrix
+				R_RotateForEntity( backEnd.currentEntity, &backEnd.viewParms, &backEnd.ori );
+
+				// set up the dynamic lighting if needed
+				if ( backEnd.currentEntity->needDlights ) {
+#ifdef VV_LIGHTING
+					VVLightMan.R_TransformDlights( &backEnd.ori );
+#else
+					R_TransformDlights( backEnd.refdef.num_dlights, backEnd.refdef.dlights, &backEnd.ori );
+#endif
+				}
+			}
+
+			qglLoadMatrixf( backEnd.ori.modelMatrix );
+
+			depthRange = pRender->depthRange;
+			switch ( depthRange )
+			{
+				default:
+				case 0:
+					qglDepthRange (0, 1);	
+					break;
+
+				case 1:
+					qglDepthRange (0, .3);	
+					break;
+
+				case 2:
+					qglDepthRange (0, 0);
+					break;
+			}
+
+			/*
+			if (!pRender->eValid)
+			{ //special full-screen "distortion" (or refraction or whatever the heck you want to call it)
+				if (!tr_stencilled)
+				{ //only need to do this once every frame (that a surface using it is around)
+					int radX = 2048;
+					int radY = 2048;
+					int x = glConfig.vidWidth/2;
+					int y = glConfig.vidHeight/2;
+					int cX, cY;
+
+					GL_Bind( tr.screenImage );
+					//using this method, we could pixel-filter the texture and all sorts of crazy stuff.
+					//but, it is slow as hell.
+#if 0
+					static byte *tmp = NULL;
+					if (!tmp)
+					{
+						tmp = (byte *)Z_Malloc((sizeof(byte)*4)*(glConfig.vidWidth*glConfig.vidHeight), TAG_ICARUS, qtrue);
+					}
+					qglReadPixels(0, 0, glConfig.vidWidth, glConfig.vidHeight, GL_RGBA, GL_UNSIGNED_BYTE, tmp);
+					qglTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 512, 512, 0, GL_RGBA, GL_UNSIGNED_BYTE, tmp);
+#endif
+
+					if (radX > glConfig.maxTextureSize)
+					{
+						radX = glConfig.maxTextureSize;
+					}
+					if (radY > glConfig.maxTextureSize)
+					{
+						radY = glConfig.maxTextureSize;
+					}
+
+					while (glConfig.vidWidth < radX)
+					{
+						radX /= 2;
+					}
+					while (glConfig.vidHeight < radY)
+					{
+						radY /= 2;
+					}
+
+					cX = x-(radX/2);
+					cY = y-(radY/2);
+
+					if (cX+radX > glConfig.vidWidth)
+					{ //would it go off screen?
+						cX = glConfig.vidWidth-radX;
+					}
+					else if (cX < 0)
+					{ //cap it off at 0
+						cX = 0;
+					}
+
+					if (cY+radY > glConfig.vidHeight)
+					{ //would it go off screen?
+						cY = glConfig.vidHeight-radY;
+					}
+					else if (cY < 0)
+					{ //cap it off at 0
+						cY = 0;
+					}
+
+					qglCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA16, cX, cY, radX, radY, 0);
+				}
+				lastPostEnt = ENTITYNUM_NONE;
+			}
+			*/
+			if (!pRender->eValid)
+			{
+			}
+			else if ((backEnd.refdef.entities[pRender->entNum].e.renderfx & RF_DISTORTION) &&
+				lastPostEnt != pRender->entNum)
+			{ //do the capture now, we only need to do it once per ent
+				int x, y;
+				int rad;
+				bool r;
+				//We are going to just bind this, and then the CopyTexImage is going to
+				//stomp over this texture num in texture memory.
+				GL_Bind( tr.screenImage );
+
+#if 0 //yeah.. this kinda worked but it was stupid
+				if (pRender->eValid)
+				{
+					r = R_WorldCoordToScreenCoord( backEnd.currentEntity->e.origin, &x, &y );
+					rad = backEnd.currentEntity->e.radius;
+				}
+				else
+				{
+					vec3_t v;
+					//probably a little bit expensive.. but we're doing this for looks, not speed!
+					if (!R_AverageTessXYZ(v))
+					{ //failed, just use first vert I guess
+						VectorCopy(tess.xyz[0], v);
+					}
+					r = R_WorldCoordToScreenCoord( v, &x, &y );
+					rad = 256;
+				}
+#else
+				r = R_WorldCoordToScreenCoord( backEnd.currentEntity->e.origin, &x, &y );
+				rad = backEnd.currentEntity->e.radius;
+#endif
+
+				if (r)
+				{
+					int cX, cY;
+					cX = glConfig.vidWidth-x-(rad/2);
+					cY = glConfig.vidHeight-y-(rad/2);
+
+					if (cX+rad > glConfig.vidWidth)
+					{ //would it go off screen?
+						cX = glConfig.vidWidth-rad;
+					}
+					else if (cX < 0)
+					{ //cap it off at 0
+						cX = 0;
+					}
+
+					if (cY+rad > glConfig.vidHeight)
+					{ //would it go off screen?
+						cY = glConfig.vidHeight-rad;
+					}
+					else if (cY < 0)
+					{ //cap it off at 0
+						cY = 0;
+					}
+
+					//now copy a portion of the screen to this texture
+#ifdef _XBOX
+					qglCopyBackBufferToTexEXT(rad, rad, cX, (480 - cY), (cX + rad), (480 - (cY + rad)));
+#else
+					qglCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA16, cX, cY, rad, rad, 0);
+#endif
+
+					lastPostEnt = pRender->entNum;
+				}
+			}
+
+			rb_surfaceTable[ *pRender->drawSurf->surface ]( pRender->drawSurf->surface );
+			RB_EndSurface();
+		}
+	}
+
+	// go back to the world modelview matrix
+	qglLoadMatrixf( backEnd.viewParms.world.modelMatrix );
+	if ( depthRange ) {
+		qglDepthRange (0, 1);
+	}
+
+#if 0
+	RB_DrawSun();
+#endif
+	if (tr_stencilled && !tr_distortionPrePost)
+	{ //draw in the stencil buffer's cutout
+		RB_DistortionFill();
+	}
+	if (!didShadowPass)
+	{
+		// darken down any stencil shadows
+		RB_ShadowFinish();
+		didShadowPass = true;
+	}
+
+#ifdef _XBOX
+	if (Cvar_VariableIntegerValue("r_hdreffect"))
+		HDREffect.Render();
+#endif
+
+	// add light flares on lights that aren't obscured
+
+	// rww - 9-13-01 [1-26-01-sof2]
+//	RB_RenderFlares();
+
+#ifdef __MACOS__
+	Sys_PumpEvents();		// crutch up the mac's limited buffer queue size
+#endif
+}
+
+
+/*
+============================================================================
+
+RENDER BACK END THREAD FUNCTIONS
+
+============================================================================
+*/
+
+/*
+================
+RB_SetGL2D
+
+================
+*/
+void	RB_SetGL2D (void) {
+	backEnd.projection2D = qtrue;
+
+	// set 2D virtual screen size
+	qglViewport( 0, 0, glConfig.vidWidth, glConfig.vidHeight );
+	qglScissor( 0, 0, glConfig.vidWidth, glConfig.vidHeight );
+	qglMatrixMode(GL_PROJECTION);
+    qglLoadIdentity ();
+#ifdef _XBOX
+	qglOrtho (0, 640, 0, 480, 0, 1);
+#else
+	qglOrtho (0, 640, 480, 0, 0, 1);
+#endif
+	qglMatrixMode(GL_MODELVIEW);
+    qglLoadIdentity ();
+
+	GL_State( GLS_DEPTHTEST_DISABLE |
+			  GLS_SRCBLEND_SRC_ALPHA |
+			  GLS_DSTBLEND_ONE_MINUS_SRC_ALPHA );
+
+	qglDisable( GL_CULL_FACE );
+	qglDisable( GL_CLIP_PLANE0 );
+
+	// set time for 2D shaders
+	backEnd.refdef.time = Sys_Milliseconds()*com_timescale->value;
+	backEnd.refdef.floatTime = backEnd.refdef.time * 0.001f;
+}
+
+
+/*
+=============
+RE_StretchRaw
+
+FIXME: not exactly backend
+Stretches a raw 32 bit power of 2 bitmap image over the given screen rectangle.
+Used for cinematics.
+=============
+*/
+void RE_StretchRaw (int x, int y, int w, int h, int cols, int rows, const byte *data, int client, qboolean dirty) 
+{
+	int			start, end;
+
+	if ( !tr.registered ) {
+		return;
+	}
+	R_SyncRenderThread();
+
+	// we definately want to sync every frame for the cinematics
+	qglFinish();
+
+	start = end = 0;
+	if ( r_speeds->integer ) {
+		start = Sys_Milliseconds()*com_timescale->value;
+	}
+
+	// make sure rows and cols are powers of 2
+	if ( (cols&(cols-1)) || (rows&(rows-1)) )
+	{
+		Com_Error (ERR_DROP, "Draw_StretchRaw: size not a power of 2: %i by %i", cols, rows);
+	}
+
+	GL_Bind( tr.scratchImage[client] );
+
+	// if the scratchImage isn't in the format we want, specify it as a new texture
+	if ( cols != tr.scratchImage[client]->width || rows != tr.scratchImage[client]->height ) {
+		tr.scratchImage[client]->width = cols;
+		tr.scratchImage[client]->height = rows;
+		qglTexImage2D( GL_TEXTURE_2D, 0, GL_RGB8, cols, rows, 0, GL_RGBA, GL_UNSIGNED_BYTE, data );
+		qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
+		qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
+		qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP );
+		qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP );	
+	} else {
+		if (dirty) {
+			// otherwise, just subimage upload it so that drivers can tell we are going to be changing
+			// it and don't try and do a texture compression
+			qglTexSubImage2D( GL_TEXTURE_2D, 0, 0, 0, cols, rows, GL_RGBA, GL_UNSIGNED_BYTE, data );
+		}
+	}
+
+	if ( r_speeds->integer ) {
+		end = Sys_Milliseconds()*com_timescale->value;
+		Com_Printf ("qglTexSubImage2D %i, %i: %i msec\n", cols, rows, end - start );
+	}
+
+	RB_SetGL2D();
+
+	qglColor3f( tr.identityLight, tr.identityLight, tr.identityLight );
+
+	qglBegin (GL_QUADS);
+	qglTexCoord2f ( 0.5f / cols,  0.5f / rows );
+	qglVertex2f (x, y);
+	qglTexCoord2f ( ( cols - 0.5f ) / cols ,  0.5f / rows );
+	qglVertex2f (x+w, y);
+	qglTexCoord2f ( ( cols - 0.5f ) / cols, ( rows - 0.5f ) / rows );
+	qglVertex2f (x+w, y+h);
+	qglTexCoord2f ( 0.5f / cols, ( rows - 0.5f ) / rows );
+	qglVertex2f (x, y+h);
+	qglEnd ();
+}
+
+void RE_UploadCinematic (int cols, int rows, const byte *data, int client, qboolean dirty) {
+
+	GL_Bind( tr.scratchImage[client] );
+
+	// if the scratchImage isn't in the format we want, specify it as a new texture
+	if ( cols != tr.scratchImage[client]->width || rows != tr.scratchImage[client]->height ) {
+		tr.scratchImage[client]->width = tr.scratchImage[client]->width = cols;
+		tr.scratchImage[client]->height = tr.scratchImage[client]->height = rows;
+#ifdef _XBOX
+		qglTexImage2D( GL_TEXTURE_2D, 0, GL_RGB5, cols, rows, 0, GL_RGB_SWIZZLE_EXT, GL_UNSIGNED_BYTE, data );
+#else
+		qglTexImage2D( GL_TEXTURE_2D, 0, GL_RGB8, cols, rows, 0, GL_RGBA, GL_UNSIGNED_BYTE, data );
+#endif
+		qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
+		qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
+		qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP );
+		qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP );	
+	} else {
+		if (dirty) {
+			// otherwise, just subimage upload it so that drivers can tell we are going to be changing
+			// it and don't try and do a texture compression
+#ifdef _XBOX
+			qglTexSubImage2D( GL_TEXTURE_2D, 0, 0, 0, cols, rows, GL_RGB_SWIZZLE_EXT, GL_UNSIGNED_BYTE, data );
+#else
+			qglTexSubImage2D( GL_TEXTURE_2D, 0, 0, 0, cols, rows, GL_RGBA, GL_UNSIGNED_BYTE, data );
+#endif
+		}
+	}
+}
+
+
+/*
+=============
+RB_SetColor
+
+=============
+*/
+const void	*RB_SetColor( const void *data ) {
+	const setColorCommand_t	*cmd;
+
+	cmd = (const setColorCommand_t *)data;
+
+	backEnd.color2D[0] = cmd->color[0] * 255;
+	backEnd.color2D[1] = cmd->color[1] * 255;
+	backEnd.color2D[2] = cmd->color[2] * 255;
+	backEnd.color2D[3] = cmd->color[3] * 255;
+
+	return (const void *)(cmd + 1);
+}
+
+/*
+=============
+RB_StretchPic
+=============
+*/
+const void *RB_StretchPic ( const void *data ) {
+	const stretchPicCommand_t	*cmd;
+	shader_t *shader;
+	int		numVerts, numIndexes;
+
+	cmd = (const stretchPicCommand_t *)data;
+
+	if ( !backEnd.projection2D ) {
+		RB_SetGL2D();
+	}
+
+	shader = cmd->shader;
+	if ( shader != tess.shader ) {
+		if ( tess.numIndexes ) {
+			RB_EndSurface();
+		}
+		backEnd.currentEntity = &backEnd.entity2D;
+		RB_BeginSurface( shader, 0 );
+	}
+
+	RB_CHECKOVERFLOW( 4, 6 );
+	numVerts = tess.numVertexes;
+	numIndexes = tess.numIndexes;
+
+	tess.numVertexes += 4;
+	tess.numIndexes += 6;
+
+	tess.indexes[ numIndexes ] = numVerts + 3;
+	tess.indexes[ numIndexes + 1 ] = numVerts + 0;
+	tess.indexes[ numIndexes + 2 ] = numVerts + 2;
+	tess.indexes[ numIndexes + 3 ] = numVerts + 2;
+	tess.indexes[ numIndexes + 4 ] = numVerts + 0;
+	tess.indexes[ numIndexes + 5 ] = numVerts + 1;
+
+	*(int *)tess.vertexColors[ numVerts ] =
+		*(int *)tess.vertexColors[ numVerts + 1 ] =
+		*(int *)tess.vertexColors[ numVerts + 2 ] =
+		*(int *)tess.vertexColors[ numVerts + 3 ] = *(int *)backEnd.color2D;
+
+	tess.xyz[ numVerts ][0] = cmd->x;
+	tess.xyz[ numVerts ][1] = cmd->y;
+	tess.xyz[ numVerts ][2] = 0;
+
+	tess.texCoords[ numVerts ][0][0] = cmd->s1;
+	tess.texCoords[ numVerts ][0][1] = cmd->t1;
+
+	tess.xyz[ numVerts + 1 ][0] = cmd->x + cmd->w;
+	tess.xyz[ numVerts + 1 ][1] = cmd->y;
+	tess.xyz[ numVerts + 1 ][2] = 0;
+
+	tess.texCoords[ numVerts + 1 ][0][0] = cmd->s2;
+	tess.texCoords[ numVerts + 1 ][0][1] = cmd->t1;
+
+	tess.xyz[ numVerts + 2 ][0] = cmd->x + cmd->w;
+	tess.xyz[ numVerts + 2 ][1] = cmd->y + cmd->h;
+	tess.xyz[ numVerts + 2 ][2] = 0;
+
+	tess.texCoords[ numVerts + 2 ][0][0] = cmd->s2;
+	tess.texCoords[ numVerts + 2 ][0][1] = cmd->t2;
+
+	tess.xyz[ numVerts + 3 ][0] = cmd->x;
+	tess.xyz[ numVerts + 3 ][1] = cmd->y + cmd->h;
+	tess.xyz[ numVerts + 3 ][2] = 0;
+
+	tess.texCoords[ numVerts + 3 ][0][0] = cmd->s1;
+	tess.texCoords[ numVerts + 3 ][0][1] = cmd->t2;
+
+	return (const void *)(cmd + 1);
+}
+
+
+/*
+=============
+RB_DrawRotatePic
+=============
+*/
+const void *RB_RotatePic ( const void *data ) 
+{
+	const rotatePicCommand_t	*cmd;
+	image_t *image;
+	shader_t *shader;
+
+	cmd = (const rotatePicCommand_t *)data;
+
+	shader = cmd->shader;
+	image = &shader->stages[0].bundle[0].image[0];
+
+	if ( image ) {
+		if ( !backEnd.projection2D ) {
+			RB_SetGL2D();
+		}
+
+		qglColor4ubv( backEnd.color2D );
+		qglPushMatrix();
+
+		qglTranslatef(cmd->x+cmd->w,cmd->y,0);
+		qglRotatef(cmd->a, 0.0, 0.0, 1.0);
+		
+		GL_Bind( image );
+#ifdef _XBOX
+		qglBeginEXT (GL_QUADS, 4, 0, 0, 4, 0);
+#else
+		qglBegin (GL_QUADS);
+#endif
+		qglTexCoord2f( cmd->s1, cmd->t1);
+		qglVertex2f( -cmd->w, 0 );
+		qglTexCoord2f( cmd->s2, cmd->t1 );
+		qglVertex2f( 0, 0 );
+		qglTexCoord2f( cmd->s2, cmd->t2 );
+		qglVertex2f( 0, cmd->h );
+		qglTexCoord2f( cmd->s1, cmd->t2 );
+		qglVertex2f( -cmd->w, cmd->h );
+		qglEnd();
+		
+		qglPopMatrix();
+	}
+
+	return (const void *)(cmd + 1);
+}
+
+/*
+=============
+RB_DrawRotatePic2
+=============
+*/
+const void *RB_RotatePic2 ( const void *data ) 
+{
+	const rotatePicCommand_t	*cmd;
+	image_t *image;
+	shader_t *shader;
+
+	cmd = (const rotatePicCommand_t *)data;
+
+	shader = cmd->shader;
+
+	if ( shader->numUnfoggedPasses )
+	{
+		image = &shader->stages[0].bundle[0].image[0];
+
+		if ( image )
+	{
+			if ( !backEnd.projection2D )
+			{
+				RB_SetGL2D();
+			}
+
+			// Get our current blend mode, etc.
+			GL_State( shader->stages[0].stateBits );
+
+			qglColor4ubv( backEnd.color2D );
+			qglPushMatrix();
+
+			// rotation point is going to be around the center of the passed in coordinates
+			qglTranslatef( cmd->x, cmd->y, 0 );
+			qglRotatef( cmd->a, 0.0, 0.0, 1.0 );
+		
+			GL_Bind( image );
+#ifdef _XBOX
+			qglBeginEXT( GL_QUADS, 4, 0, 0, 4, 0);
+#else
+			qglBegin( GL_QUADS );
+#endif
+				qglTexCoord2f( cmd->s1, cmd->t1);
+				qglVertex2f( -cmd->w * 0.5f, -cmd->h * 0.5f );
+
+				qglTexCoord2f( cmd->s2, cmd->t1 );
+				qglVertex2f( cmd->w * 0.5f, -cmd->h * 0.5f );
+
+				qglTexCoord2f( cmd->s2, cmd->t2 );
+				qglVertex2f( cmd->w * 0.5f, cmd->h * 0.5f );
+
+				qglTexCoord2f( cmd->s1, cmd->t2 );
+				qglVertex2f( -cmd->w * 0.5f, cmd->h * 0.5f );
+			qglEnd();
+		
+			qglPopMatrix();
+
+			// Hmmm, this is not too cool
+			GL_State( GLS_DEPTHTEST_DISABLE |
+				  GLS_SRCBLEND_SRC_ALPHA |
+				  GLS_DSTBLEND_ONE_MINUS_SRC_ALPHA );
+		}
+	}
+
+	return (const void *)(cmd + 1);
+}
+
+
+/*
+=============
+RB_DrawSurfs
+
+=============
+*/
+const void	*RB_DrawSurfs( const void *data ) {
+	const drawSurfsCommand_t	*cmd;
+
+	// finish any 2D drawing if needed
+	if ( tess.numIndexes ) {
+		RB_EndSurface();
+	}
+
+	cmd = (const drawSurfsCommand_t *)data;
+
+	backEnd.refdef = cmd->refdef;
+	backEnd.viewParms = cmd->viewParms;
+
+	RB_RenderDrawSurfList( cmd->drawSurfs, cmd->numDrawSurfs );
+
+	// Dynamic Glow/Flares:
+	/*
+		The basic idea is to render the glowing parts of the scene to an offscreen buffer, then take
+		that buffer and blur it. After it is sufficiently blurred, re-apply that image back to
+		the normal screen using a additive blending. To blur the scene I use a vertex program to supply
+		four texture coordinate offsets that allow 'peeking' into adjacent pixels. In the register
+		combiner (pixel shader), I combine the adjacent pixels using a weighting factor. - Aurelio
+	*/
+
+	// Render dynamic glowing/flaring objects.
+#ifndef _XBOX	// GLOWXXX
+	if ( !(backEnd.refdef.rdflags & RDF_NOWORLDMODEL) && g_bDynamicGlowSupported && r_DynamicGlow->integer )
+	{
+		// Copy the normal scene to texture.
+		qglDisable( GL_TEXTURE_2D );
+		qglEnable( GL_TEXTURE_RECTANGLE_EXT ); 
+		qglBindTexture( GL_TEXTURE_RECTANGLE_EXT, tr.sceneImage ); 
+		qglCopyTexSubImage2D( GL_TEXTURE_RECTANGLE_EXT, 0, 0, 0, 0, 0, glConfig.vidWidth, glConfig.vidHeight ); 
+		qglDisable( GL_TEXTURE_RECTANGLE_EXT );
+		qglEnable( GL_TEXTURE_2D );    
+
+		// Just clear colors, but leave the depth buffer intact so we can 'share' it.
+		qglClearColor( 0.0f, 0.0f, 0.0f, 0.0f );
+		qglClear( GL_COLOR_BUFFER_BIT ); 
+
+		// Render the glowing objects.
+		g_bRenderGlowingObjects = true;
+		RB_RenderDrawSurfList( cmd->drawSurfs, cmd->numDrawSurfs );  
+		g_bRenderGlowingObjects = false;
+
+		qglFinish();
+
+		// Copy the glow scene to texture.
+		qglDisable( GL_TEXTURE_2D );
+		qglEnable( GL_TEXTURE_RECTANGLE_EXT ); 
+		qglBindTexture( GL_TEXTURE_RECTANGLE_EXT, tr.screenGlow ); 
+		qglCopyTexSubImage2D( GL_TEXTURE_RECTANGLE_EXT, 0, 0, 0, 0, 0, glConfig.vidWidth, glConfig.vidHeight ); 
+		qglDisable( GL_TEXTURE_RECTANGLE_EXT );
+		qglEnable( GL_TEXTURE_2D );
+		
+		// Resize the viewport to the blur texture size.
+		const int oldViewWidth = backEnd.viewParms.viewportWidth;
+		const int oldViewHeight = backEnd.viewParms.viewportHeight;
+		backEnd.viewParms.viewportWidth = r_DynamicGlowWidth->integer;
+		backEnd.viewParms.viewportHeight = r_DynamicGlowHeight->integer;
+		SetViewportAndScissor();
+
+		// Blur the scene.
+		RB_BlurGlowTexture();
+
+		// Copy the finished glow scene back to texture.
+		qglDisable( GL_TEXTURE_2D );
+		qglEnable( GL_TEXTURE_RECTANGLE_EXT );
+		qglBindTexture( GL_TEXTURE_RECTANGLE_EXT, tr.blurImage );
+		qglCopyTexSubImage2D( GL_TEXTURE_RECTANGLE_EXT, 0, 0, 0, 0, 0, backEnd.viewParms.viewportWidth, backEnd.viewParms.viewportHeight ); 
+		qglDisable( GL_TEXTURE_RECTANGLE_EXT );
+		qglEnable( GL_TEXTURE_2D );
+		
+		// Set the viewport back to normal.
+		backEnd.viewParms.viewportWidth = oldViewWidth;
+		backEnd.viewParms.viewportHeight = oldViewHeight;
+		SetViewportAndScissor();
+		qglClear( GL_COLOR_BUFFER_BIT ); 
+
+		// Draw the glow additively over the screen.
+		RB_DrawGlowOverlay(); 
+	}
+#endif	// _XBOX
+
+	return (const void *)(cmd + 1);
+}
+
+
+/*
+=============
+RB_DrawBuffer
+
+=============
+*/
+const void	*RB_DrawBuffer( const void *data ) {
+	const drawBufferCommand_t	*cmd;
+
+	cmd = (const drawBufferCommand_t *)data;
+
+	qglDrawBuffer( cmd->buffer );
+
+	// clear screen for debugging
+	if (tr.world && tr.world->globalFog != -1)
+	{
+		const fog_t		*fog = &tr.world->fogs[tr.world->globalFog];
+
+		qglClearColor(fog->parms.color[0],  fog->parms.color[1], fog->parms.color[2], 1.0f );
+		qglClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
+	}
+	else if ( r_clear->integer ) {
+		int i = r_clear->integer;
+		if (i == 42) {
+			i = Q_irand(0,8);
+		}
+		switch (i)
+		{
+		default:
+			qglClearColor( 1, 0, 0.5, 1 );
+			break;
+		case 1:
+			qglClearColor( 1.0, 0.0, 0.0, 1.0); //red
+			break;
+		case 2:
+			qglClearColor( 0.0, 1.0, 0.0, 1.0); //green
+			break;
+		case 3:
+			qglClearColor( 1.0, 1.0, 0.0, 1.0); //yellow
+			break;
+		case 4:
+			qglClearColor( 0.0, 0.0, 1.0, 1.0); //blue
+			break;
+		case 5:
+			qglClearColor( 0.0, 1.0, 1.0, 1.0); //cyan
+			break;
+		case 6:
+			qglClearColor( 1.0, 0.0, 1.0, 1.0); //magenta
+			break;
+		case 7:
+			qglClearColor( 1.0, 1.0, 1.0, 1.0); //white
+			break;
+		case 8:
+			qglClearColor( 0.0, 0.0, 0.0, 1.0); //black
+			break;
+		}		
+		qglClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
+	}
+
+	return (const void *)(cmd + 1);
+}
+
+/*
+===============
+RB_ShowImages
+
+Draw all the images to the screen, on top of whatever
+was there.  This is used to test for texture thrashing.
+
+Also called by RE_EndRegistration
+===============
+*/
+void RB_ShowImages( void ) {
+	image_t	*image;
+	float	x, y, w, h;
+//	int		start, end;
+
+	if ( !backEnd.projection2D ) {
+		RB_SetGL2D();
+	}
+
+	qglClear( GL_COLOR_BUFFER_BIT );
+
+	qglFinish();
+
+//	start = Sys_Milliseconds()*com_timescale->value;
+
+
+	int i=0;
+	   				 R_Images_StartIteration();
+	while ( (image = R_Images_GetNextIteration()) != NULL)
+	{
+		w = glConfig.vidWidth / 20;
+		h = glConfig.vidHeight / 15;
+		x = i % 20 * w;
+		y = i / 20 * h;
+
+		// show in proportional size in mode 2
+		if ( r_showImages->integer == 2 ) {
+			w *= image->width / 512.0;
+			h *= image->height / 512.0;
+		}
+
+		GL_Bind( image );
+#ifdef _XBOX
+		qglBeginEXT (GL_QUADS, 4, 0, 0, 4, 0);
+#else
+		qglBegin (GL_QUADS);
+#endif
+		qglTexCoord2f( 0, 0 );
+		qglVertex2f( x, y );
+		qglTexCoord2f( 1, 0 );
+		qglVertex2f( x + w, y );
+		qglTexCoord2f( 1, 1 );
+		qglVertex2f( x + w, y + h );
+		qglTexCoord2f( 0, 1 );
+		qglVertex2f( x, y + h );
+		qglEnd();
+		i++;
+	}
+
+	qglFinish();
+
+//	end = Sys_Milliseconds()*com_timescale->value;
+//	Com_Printf ("%i msec to draw all images\n", end - start );
+}
+
+
+/*
+=============
+RB_SwapBuffers
+
+=============
+*/
+const void	*RB_SwapBuffers( const void *data ) {
+	const swapBuffersCommand_t	*cmd;
+
+	// finish any 2D drawing if needed
+	if ( tess.numIndexes ) {
+		RB_EndSurface();
+	}
+
+	// texture swapping test
+	if ( r_showImages->integer ) {
+		RB_ShowImages();
+	}
+
+	cmd = (const swapBuffersCommand_t *)data;
+
+	// we measure overdraw by reading back the stencil buffer and
+	// counting up the number of increments that have happened
+#ifndef _XBOX
+	if ( r_measureOverdraw->integer ) {
+		int i;
+		long sum = 0;
+		unsigned char *stencilReadback;
+
+		stencilReadback = (unsigned char *)Hunk_AllocateTempMemory( glConfig.vidWidth * glConfig.vidHeight );
+		qglReadPixels( 0, 0, glConfig.vidWidth, glConfig.vidHeight, GL_STENCIL_INDEX, GL_UNSIGNED_BYTE, stencilReadback );
+
+		for ( i = 0; i < glConfig.vidWidth * glConfig.vidHeight; i++ ) {
+			sum += stencilReadback[i];
+		}
+
+		backEnd.pc.c_overDraw += sum;
+		Hunk_FreeTempMemory( stencilReadback );
+	}
+#endif
+
+    if ( !glState.finishCalled ) {
+        qglFinish();
+	}
+
+    GLimp_LogComment( "***************** RB_SwapBuffers *****************\n\n\n" );
+
+    GLimp_EndFrame();
+
+	backEnd.projection2D = qfalse;
+
+	return (const void *)(cmd + 1);
+}
+
+const void	*RB_WorldEffects( const void *data ) 
+{
+	const drawBufferCommand_t	*cmd;
+
+	cmd = (const drawBufferCommand_t *)data;
+
+	// Always flush the tess buffer
+	if ( tess.shader && tess.numIndexes ) 
+	{
+		RB_EndSurface();
+	}
+	RB_RenderWorldEffects();
+
+	if(tess.shader)
+	{
+		RB_BeginSurface( tess.shader, tess.fogNum );
+	}
+
+	return (const void *)(cmd + 1);
+}
+
+/*
+====================
+RB_ExecuteRenderCommands
+
+This function will be called syncronously if running without
+smp extensions, or asyncronously by another thread.
+====================
+*/
+extern const void *R_DrawWireframeAutomap(const void *data); //tr_world.cpp
+void RB_ExecuteRenderCommands( const void *data ) {
+	int		t1, t2;
+
+	t1 = Sys_Milliseconds()*com_timescale->value;
+
+	while ( 1 ) {
+		switch ( *(const int *)data ) {
+		case RC_SET_COLOR:
+			data = RB_SetColor( data );
+			break;
+		case RC_STRETCH_PIC:
+			data = RB_StretchPic( data );
+			break;
+		case RC_ROTATE_PIC:
+			data = RB_RotatePic( data );
+			break;
+		case RC_ROTATE_PIC2:
+			data = RB_RotatePic2( data );
+			break;
+		case RC_DRAW_SURFS:
+			data = RB_DrawSurfs( data );
+			break;
+		case RC_DRAW_BUFFER:
+			data = RB_DrawBuffer( data );
+			break;
+		case RC_SWAP_BUFFERS:
+			data = RB_SwapBuffers( data );
+			break;
+		case RC_WORLD_EFFECTS:
+			data = RB_WorldEffects( data );
+			break;
+		case RC_AUTO_MAP:
+			data = R_DrawWireframeAutomap(data);
+			break;
+		case RC_END_OF_LIST:
+		default:
+			// stop rendering on this thread
+			t2 = Sys_Milliseconds()*com_timescale->value;
+			backEnd.pc.msec = t2 - t1;
+			return;
+		}
+	}
+
+}
+
+#ifndef _XBOX	// GLOWXXX
+
+// What Pixel Shader type is currently active (regcoms or fragment programs).
+GLuint g_uiCurrentPixelShaderType = 0x0;
+
+// Begin using a Pixel Shader.
+void BeginPixelShader( GLuint uiType, GLuint uiID )
+{
+	switch ( uiType )
+	{
+		// Using Register Combiners, so call the Display List that stores it.
+		case GL_REGISTER_COMBINERS_NV:
+		{
+			// Just in case...
+			if ( !qglCombinerParameterfvNV )
+				return;
+
+			// Call the list with the regcom in it.
+			qglEnable( GL_REGISTER_COMBINERS_NV );
+			qglCallList( uiID );
+
+			g_uiCurrentPixelShaderType = GL_REGISTER_COMBINERS_NV;
+		}
+		return;
+
+		// Using Fragment Programs, so call the program.
+		case GL_FRAGMENT_PROGRAM_ARB:
+		{
+			// Just in case...
+			if ( !qglGenProgramsARB )
+				return;
+
+			qglEnable( GL_FRAGMENT_PROGRAM_ARB );
+			qglBindProgramARB( GL_FRAGMENT_PROGRAM_ARB, uiID );
+
+			g_uiCurrentPixelShaderType = GL_FRAGMENT_PROGRAM_ARB;
+		}
+		return;
+	}
+}
+
+// Stop using a Pixel Shader and return states to normal.
+void EndPixelShader()
+{
+	if ( g_uiCurrentPixelShaderType == 0x0 )
+		return;
+
+	qglDisable( g_uiCurrentPixelShaderType );
+}
+
+// Hack variable for deciding which kind of texture rectangle thing to do (for some
+// reason it acts different on radeon! It's against the spec!).
+extern bool g_bTextureRectangleHack;
+
+static inline void RB_BlurGlowTexture()
+{
+	qglDisable (GL_CLIP_PLANE0);
+	GL_Cull( CT_TWO_SIDED );
+	qglDisable( GL_DEPTH_TEST );
+
+	// Go into orthographic 2d mode.
+	qglMatrixMode(GL_PROJECTION);
+	qglPushMatrix();
+	qglLoadIdentity();
+	qglOrtho(0, backEnd.viewParms.viewportWidth, backEnd.viewParms.viewportHeight, 0, -1, 1);
+	qglMatrixMode(GL_MODELVIEW);
+	qglPushMatrix();
+	qglLoadIdentity();
+
+	GL_State(0);
+
+	/////////////////////////////////////////////////////////
+	// Setup vertex and pixel programs.
+	/////////////////////////////////////////////////////////
+
+	// NOTE: The 0.25 is because we're blending 4 textures (so = 1.0) and we want a relatively normalized pixel
+	// intensity distribution, but this won't happen anyways if intensity is higher than 1.0.
+	float fBlurDistribution = r_DynamicGlowIntensity->value * 0.25f;
+	float fBlurWeight[4] = { fBlurDistribution, fBlurDistribution, fBlurDistribution, 1.0f };
+
+	// Enable and set the Vertex Program.
+	qglEnable( GL_VERTEX_PROGRAM_ARB );
+	qglBindProgramARB( GL_VERTEX_PROGRAM_ARB, tr.glowVShader );
+
+	// Apply Pixel Shaders.
+	if ( qglCombinerParameterfvNV )
+	{
+		BeginPixelShader( GL_REGISTER_COMBINERS_NV, tr.glowPShader );
+
+		// Pass the blur weight to the regcom.
+		qglCombinerParameterfvNV( GL_CONSTANT_COLOR0_NV, (float*)&fBlurWeight );
+	}
+	else if ( qglProgramEnvParameter4fARB )
+	{
+		BeginPixelShader( GL_FRAGMENT_PROGRAM_ARB, tr.glowPShader );
+
+		// Pass the blur weight to the Fragment Program.
+		qglProgramEnvParameter4fARB( GL_FRAGMENT_PROGRAM_ARB, 0, fBlurWeight[0], fBlurWeight[1], fBlurWeight[2], fBlurWeight[3] );
+	}
+
+	/////////////////////////////////////////////////////////
+	// Set the blur texture to the 4 texture stages.
+	/////////////////////////////////////////////////////////
+
+	// How much to offset each texel by.
+	float fTexelWidthOffset = 0.1f, fTexelHeightOffset = 0.1f;
+
+	GLuint uiTex = tr.screenGlow;  
+
+	qglActiveTextureARB( GL_TEXTURE3_ARB );  
+	qglEnable( GL_TEXTURE_RECTANGLE_EXT ); 
+	qglBindTexture( GL_TEXTURE_RECTANGLE_EXT, uiTex );
+	
+	qglActiveTextureARB( GL_TEXTURE2_ARB ); 
+	qglEnable( GL_TEXTURE_RECTANGLE_EXT );
+	qglBindTexture( GL_TEXTURE_RECTANGLE_EXT, uiTex );
+
+	qglActiveTextureARB( GL_TEXTURE1_ARB );
+	qglEnable( GL_TEXTURE_RECTANGLE_EXT );
+	qglBindTexture( GL_TEXTURE_RECTANGLE_EXT, uiTex );
+
+	qglActiveTextureARB(GL_TEXTURE0_ARB );
+	qglDisable( GL_TEXTURE_2D );  
+	qglEnable( GL_TEXTURE_RECTANGLE_EXT );
+	qglBindTexture( GL_TEXTURE_RECTANGLE_EXT, uiTex ); 
+	
+	/////////////////////////////////////////////////////////
+	// Draw the blur passes (each pass blurs it more, increasing the blur radius ).
+	/////////////////////////////////////////////////////////
+	
+	//int iTexWidth = backEnd.viewParms.viewportWidth, iTexHeight = backEnd.viewParms.viewportHeight;
+	int iTexWidth = glConfig.vidWidth, iTexHeight = glConfig.vidHeight; 
+	
+	for ( int iNumBlurPasses = 0; iNumBlurPasses < r_DynamicGlowPasses->integer; iNumBlurPasses++ )       
+	{
+		// Load the Texel Offsets into the Vertex Program.
+		qglProgramEnvParameter4fARB( GL_VERTEX_PROGRAM_ARB, 0, -fTexelWidthOffset, -fTexelWidthOffset, 0.0f, 0.0f );
+		qglProgramEnvParameter4fARB( GL_VERTEX_PROGRAM_ARB, 1, -fTexelWidthOffset, fTexelWidthOffset, 0.0f, 0.0f );
+		qglProgramEnvParameter4fARB( GL_VERTEX_PROGRAM_ARB, 2, fTexelWidthOffset, -fTexelWidthOffset, 0.0f, 0.0f );
+		qglProgramEnvParameter4fARB( GL_VERTEX_PROGRAM_ARB, 3, fTexelWidthOffset, fTexelWidthOffset, 0.0f, 0.0f );
+
+		// After first pass put the tex coords to the viewport size.
+		if ( iNumBlurPasses == 1 )
+		{
+			// OK, very weird, but dependent on which texture rectangle extension we're using, the
+			// texture either needs to be always texure correct or view correct...
+			if ( !g_bTextureRectangleHack ) 
+			{
+				iTexWidth = backEnd.viewParms.viewportWidth;
+				iTexHeight = backEnd.viewParms.viewportHeight;
+			}
+
+			uiTex = tr.blurImage;
+			qglActiveTextureARB( GL_TEXTURE3_ARB );  
+			qglDisable( GL_TEXTURE_2D );
+			qglEnable( GL_TEXTURE_RECTANGLE_EXT ); 
+			qglBindTexture( GL_TEXTURE_RECTANGLE_EXT, uiTex );
+			qglActiveTextureARB( GL_TEXTURE2_ARB ); 
+			qglDisable( GL_TEXTURE_2D );
+			qglEnable( GL_TEXTURE_RECTANGLE_EXT );
+			qglBindTexture( GL_TEXTURE_RECTANGLE_EXT, uiTex );			
+			qglActiveTextureARB( GL_TEXTURE1_ARB );
+			qglDisable( GL_TEXTURE_2D );
+			qglEnable( GL_TEXTURE_RECTANGLE_EXT );
+			qglBindTexture( GL_TEXTURE_RECTANGLE_EXT, uiTex );
+			qglActiveTextureARB(GL_TEXTURE0_ARB );
+			qglDisable( GL_TEXTURE_2D );
+			qglEnable( GL_TEXTURE_RECTANGLE_EXT );
+			qglBindTexture( GL_TEXTURE_RECTANGLE_EXT, uiTex ); 
+
+			// Copy the current image over.
+			qglBindTexture( GL_TEXTURE_RECTANGLE_EXT, uiTex );     
+			qglCopyTexSubImage2D( GL_TEXTURE_RECTANGLE_EXT, 0, 0, 0, 0, 0, backEnd.viewParms.viewportWidth, backEnd.viewParms.viewportHeight );
+		}
+
+		// Draw the fullscreen quad.
+		qglBegin( GL_QUADS ); 
+			qglMultiTexCoord2fARB( GL_TEXTURE0_ARB, 0, iTexHeight );  
+			qglVertex2f( 0, 0 );
+
+			qglMultiTexCoord2fARB( GL_TEXTURE0_ARB, 0, 0 );
+			qglVertex2f( 0, backEnd.viewParms.viewportHeight );
+
+			qglMultiTexCoord2fARB( GL_TEXTURE0_ARB, iTexWidth, 0 ); 
+			qglVertex2f( backEnd.viewParms.viewportWidth, backEnd.viewParms.viewportHeight );
+
+			qglMultiTexCoord2fARB( GL_TEXTURE0_ARB, iTexWidth, iTexHeight );
+			qglVertex2f( backEnd.viewParms.viewportWidth, 0 ); 
+		qglEnd();
+
+		qglBindTexture( GL_TEXTURE_RECTANGLE_EXT, tr.blurImage );       
+		qglCopyTexSubImage2D( GL_TEXTURE_RECTANGLE_EXT, 0, 0, 0, 0, 0, backEnd.viewParms.viewportWidth, backEnd.viewParms.viewportHeight );    
+
+		// Increase the texel offsets.
+		// NOTE: This is possibly the most important input to the effect. Even by using an exponential function I've been able to
+		// make it look better (at a much higher cost of course). This is cheap though and still looks pretty great. In the future 
+		// I might want to use an actual gaussian equation to correctly calculate the pixel coefficients and attenuates, texel
+		// offsets, gaussian amplitude and radius...
+		fTexelWidthOffset += r_DynamicGlowDelta->value;
+		fTexelHeightOffset += r_DynamicGlowDelta->value;
+	}
+
+	// Disable multi-texturing.
+	qglActiveTextureARB( GL_TEXTURE3_ARB );   
+	qglDisable( GL_TEXTURE_RECTANGLE_EXT );
+
+	qglActiveTextureARB( GL_TEXTURE2_ARB );
+	qglDisable( GL_TEXTURE_RECTANGLE_EXT );
+
+	qglActiveTextureARB( GL_TEXTURE1_ARB );
+	qglDisable( GL_TEXTURE_RECTANGLE_EXT );
+
+	qglActiveTextureARB(GL_TEXTURE0_ARB );
+	qglDisable( GL_TEXTURE_RECTANGLE_EXT );
+	qglEnable( GL_TEXTURE_2D );
+
+	qglDisable( GL_VERTEX_PROGRAM_ARB );
+	EndPixelShader();
+	
+	qglMatrixMode(GL_PROJECTION);
+	qglPopMatrix();
+	qglMatrixMode(GL_MODELVIEW);
+	qglPopMatrix();
+
+	qglDisable( GL_BLEND );
+	qglEnable( GL_DEPTH_TEST );
+
+	glState.currenttmu = 0;	//this matches the last one we activated
+}
+
+// Draw the glow blur over the screen additively.
+static inline void RB_DrawGlowOverlay()
+{
+	qglDisable (GL_CLIP_PLANE0);
+	GL_Cull( CT_TWO_SIDED );
+	qglDisable( GL_DEPTH_TEST ); 
+
+	// Go into orthographic 2d mode.
+	qglMatrixMode(GL_PROJECTION);
+	qglPushMatrix();
+	qglLoadIdentity();
+	qglOrtho(0, glConfig.vidWidth, glConfig.vidHeight, 0, -1, 1);
+	qglMatrixMode(GL_MODELVIEW);
+	qglPushMatrix();
+	qglLoadIdentity();
+
+	GL_State(0);
+
+	qglDisable( GL_TEXTURE_2D );
+	qglEnable( GL_TEXTURE_RECTANGLE_EXT );
+
+	// For debug purposes.
+	if ( r_DynamicGlow->integer != 2 )
+	{
+		// Render the normal scene texture.
+		qglBindTexture( GL_TEXTURE_RECTANGLE_EXT, tr.sceneImage ); 
+		qglBegin(GL_QUADS);    
+			qglColor4f( 1.0f, 1.0f, 1.0f, 1.0f );
+			qglTexCoord2f( 0, glConfig.vidHeight ); 
+			qglVertex2f( 0, 0 );
+
+			qglTexCoord2f( 0, 0 );
+			qglVertex2f( 0, glConfig.vidHeight );
+
+			qglTexCoord2f( glConfig.vidWidth, 0 );
+			qglVertex2f( glConfig.vidWidth, glConfig.vidHeight );
+
+			qglTexCoord2f( glConfig.vidWidth, glConfig.vidHeight );
+			qglVertex2f( glConfig.vidWidth, 0 );
+		qglEnd();
+	}
+
+	// One and Inverse Src Color give a very soft addition, while one one is a bit stronger. With one one we can
+	// use additive blending through multitexture though.
+	if ( r_DynamicGlowSoft->integer )
+	{
+		qglBlendFunc( GL_ONE, GL_ONE_MINUS_SRC_COLOR );
+	}
+	else
+	{
+		qglBlendFunc( GL_ONE, GL_ONE );
+	}
+	qglEnable( GL_BLEND );  
+
+	// Now additively render the glow texture.
+	qglBindTexture( GL_TEXTURE_RECTANGLE_EXT, tr.blurImage );     
+	qglBegin(GL_QUADS);    
+		qglColor4f( 1.0f, 1.0f, 1.0f, 1.0f );  
+		qglTexCoord2f( 0, r_DynamicGlowHeight->integer ); 
+		qglVertex2f( 0, 0 );
+
+		qglTexCoord2f( 0, 0 );
+		qglVertex2f( 0, glConfig.vidHeight );
+
+		qglTexCoord2f( r_DynamicGlowWidth->integer, 0 );
+		qglVertex2f( glConfig.vidWidth, glConfig.vidHeight );
+
+		qglTexCoord2f( r_DynamicGlowWidth->integer, r_DynamicGlowHeight->integer );
+		qglVertex2f( glConfig.vidWidth, 0 );
+	qglEnd();
+
+	qglDisable( GL_TEXTURE_RECTANGLE_EXT );
+	qglEnable( GL_TEXTURE_2D );
+	qglBlendFunc( GL_SRC_COLOR, GL_ONE_MINUS_SRC_COLOR );
+	qglDisable( GL_BLEND );
+
+	// NOTE: Multi-texture wasn't that much faster (we're obviously not bottlenecked by transform pipeline),
+	// and besides, soft glow looks better anyways.
+/*	else
+	{
+		int iTexWidth = glConfig.vidWidth, iTexHeight = glConfig.vidHeight;
+		if ( GL_TEXTURE_RECTANGLE_EXT == GL_TEXTURE_RECTANGLE_NV ) 
+		{
+			iTexWidth = r_DynamicGlowWidth->integer;
+			iTexHeight = r_DynamicGlowHeight->integer;
+		}
+
+		qglActiveTextureARB( GL_TEXTURE1_ARB ); 
+		qglDisable( GL_TEXTURE_2D ); 
+		qglEnable( GL_TEXTURE_RECTANGLE_EXT );
+		qglBindTexture( GL_TEXTURE_RECTANGLE_EXT, tr.screenGlow ); 
+		qglTexEnvf( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_ADD );  
+
+		qglActiveTextureARB(GL_TEXTURE0_ARB );
+		qglDisable( GL_TEXTURE_2D );
+		qglEnable( GL_TEXTURE_RECTANGLE_EXT );
+		qglBindTexture( GL_TEXTURE_RECTANGLE_EXT, tr.sceneImage );
+		qglTexEnvf( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL );
+
+		qglBegin(GL_QUADS);    
+			qglColor4f( 1.0f, 1.0f, 1.0f, 1.0f );
+			qglMultiTexCoord2fARB( GL_TEXTURE1_ARB, 0, iTexHeight );  
+			qglMultiTexCoord2fARB( GL_TEXTURE0_ARB, 0, glConfig.vidHeight );  
+			qglVertex2f( 0, 0 );
+
+			qglMultiTexCoord2fARB( GL_TEXTURE1_ARB, 0, 0 );
+			qglMultiTexCoord2fARB( GL_TEXTURE0_ARB, 0, 0 );
+			qglVertex2f( 0, glConfig.vidHeight );
+
+			qglMultiTexCoord2fARB( GL_TEXTURE1_ARB, iTexWidth, 0 ); 
+			qglMultiTexCoord2fARB( GL_TEXTURE0_ARB, glConfig.vidWidth, 0 ); 
+			qglVertex2f( glConfig.vidWidth, glConfig.vidHeight );
+
+			qglMultiTexCoord2fARB( GL_TEXTURE1_ARB, iTexWidth, iTexHeight );
+			qglMultiTexCoord2fARB( GL_TEXTURE0_ARB, glConfig.vidWidth, glConfig.vidHeight );
+			qglVertex2f( glConfig.vidWidth, 0 ); 
+		qglEnd();
+
+		qglActiveTextureARB( GL_TEXTURE1_ARB );
+		qglTexEnvf( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE ); 
+		qglDisable( GL_TEXTURE_RECTANGLE_EXT );
+
+		qglActiveTextureARB(GL_TEXTURE0_ARB );
+		qglTexEnvf( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE ); 
+		qglDisable( GL_TEXTURE_RECTANGLE_EXT );
+		qglEnable( GL_TEXTURE_2D );
+	}*/
+
+	qglMatrixMode(GL_PROJECTION);
+	qglPopMatrix();
+	qglMatrixMode(GL_MODELVIEW);
+	qglPopMatrix();
+
+	qglEnable( GL_DEPTH_TEST );
+}
+#endif	//XBOX
+
+#endif //!DEDICATED
diff --git a/codemp/renderer/tr_bsp.cpp b/codemp/renderer/tr_bsp.cpp
new file mode 100644
index 0000000..128aa3f
--- /dev/null
+++ b/codemp/renderer/tr_bsp.cpp
@@ -0,0 +1,2123 @@
+// tr_map.c
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+#include "tr_local.h"
+
+/*
+
+Loads and prepares a map file for scene rendering.
+
+A single entry point:
+
+void RE_LoadWorldMap( const char *name );
+
+*/
+
+static	world_t		s_worldData;
+static	byte		*fileBase;
+
+int			c_subdivisions;
+int			c_gridVerts;
+
+void R_RMGInit(void);
+
+//===============================================================================
+
+static void HSVtoRGB( float h, float s, float v, float rgb[3] )
+{
+	int i;
+	float f;
+	float p, q, t;
+
+	h *= 5;
+
+	i = floor( h );
+	f = h - i;
+
+	p = v * ( 1 - s );
+	q = v * ( 1 - s * f );
+	t = v * ( 1 - s * ( 1 - f ) );
+
+	switch ( i )
+	{
+	case 0:
+		rgb[0] = v;
+		rgb[1] = t;
+		rgb[2] = p;
+		break;
+	case 1:
+		rgb[0] = q;
+		rgb[1] = v;
+		rgb[2] = p;
+		break;
+	case 2:
+		rgb[0] = p;
+		rgb[1] = v;
+		rgb[2] = t;
+		break;
+	case 3:
+		rgb[0] = p;
+		rgb[1] = q;
+		rgb[2] = v;
+		break;
+	case 4:
+		rgb[0] = t;
+		rgb[1] = p;
+		rgb[2] = v;
+		break;
+	case 5:
+		rgb[0] = v;
+		rgb[1] = p;
+		rgb[2] = q;
+		break;
+	}
+}
+
+/*
+===============
+R_ColorShiftLightingBytes
+
+===============
+*/
+void R_ColorShiftLightingBytes( byte in[4], byte out[4] ) { //rwwRMG - modified
+	int		shift=0, r, g, b;
+
+	// should NOT do it if overbrightBits is 0
+	if (tr.overbrightBits)
+		shift = 1 - tr.overbrightBits;
+
+	if (!shift)
+	{
+		out[0] = in[0];
+		out[1] = in[1];
+		out[2] = in[2];
+		out[3] = in[3];
+		return;
+	}
+
+	// shift the data based on overbright range
+	r = in[0] << shift;
+	g = in[1] << shift;
+	b = in[2] << shift;
+	
+	// normalize by color instead of saturating to white
+	if ( ( r | g | b ) > 255 ) {
+		int		max;
+
+		max = r > g ? r : g;
+		max = max > b ? max : b;
+		r = r * 255 / max;
+		g = g * 255 / max;
+		b = b * 255 / max;
+	}
+
+	out[0] = r;
+	out[1] = g;
+	out[2] = b;
+	out[3] = in[3];
+}
+
+/*
+===============
+R_ColorShiftLightingBytes
+
+===============
+*/
+static	void R_ColorShiftLightingBytes( byte in[3]) 
+{
+	int		shift=0, r, g, b;
+
+	// should NOT do it if overbrightBits is 0
+	if (tr.overbrightBits)
+		shift = 1 - tr.overbrightBits;
+
+	if (!shift)
+	{
+		return;
+	}
+
+	// shift the data based on overbright range
+	r = in[0] << shift;
+	g = in[1] << shift;
+	b = in[2] << shift;
+	
+	// normalize by color instead of saturating to white
+	if ( ( r | g | b ) > 255 ) {
+		int		max;
+
+		max = r > g ? r : g;
+		max = max > b ? max : b;
+		r = r * 255 / max;
+		g = g * 255 / max;
+		b = b * 255 / max;
+	}
+
+	in[0] = r;
+	in[1] = g;
+	in[2] = b;
+}
+
+/*
+===============
+R_LoadLightmaps
+
+===============
+*/
+#define	LIGHTMAP_SIZE	128
+static	void R_LoadLightmaps( lump_t *l, const char *psMapName, world_t &worldData ) {
+	byte		*buf, *buf_p;
+	int			len;
+	MAC_STATIC byte		image[LIGHTMAP_SIZE*LIGHTMAP_SIZE*4];
+	int			i, j;
+	float maxIntensity = 0;
+	double sumIntensity = 0;
+
+	if (&worldData == &s_worldData)
+	{
+		tr.numLightmaps = 0;
+	}
+
+    len = l->filelen;
+	if ( !len ) {
+		return;
+	}
+	buf = fileBase + l->fileofs;
+
+	// we are about to upload textures
+	R_SyncRenderThread();
+
+	// create all the lightmaps
+	tr.numLightmaps = len / (LIGHTMAP_SIZE * LIGHTMAP_SIZE * 3);
+
+	// if we are in r_vertexLight mode, we don't need the lightmaps at all
+	if ( r_vertexLight->integer ) {
+		return;
+	}
+
+	char sMapName[MAX_QPATH];
+	COM_StripExtension(psMapName,sMapName);	// will already by MAX_QPATH legal, so no length check
+
+	for ( i = 0 ; i < tr.numLightmaps ; i++ ) {
+		// expand the 24 bit on-disk to 32 bit
+		buf_p = buf + i * LIGHTMAP_SIZE*LIGHTMAP_SIZE * 3;
+
+		if ( r_lightmap->integer == 2 )
+		{	// color code by intensity as development tool	(FIXME: check range)
+			for ( j = 0; j < LIGHTMAP_SIZE * LIGHTMAP_SIZE; j++ )
+			{
+				float r = buf_p[j*3+0];
+				float g = buf_p[j*3+1];
+				float b = buf_p[j*3+2];
+				float intensity;
+				float out[3];
+
+				intensity = 0.33f * r + 0.685f * g + 0.063f * b;
+
+				if ( intensity > 255 )
+					intensity = 1.0f;
+				else
+					intensity /= 255.0f;
+
+				if ( intensity > maxIntensity )
+					maxIntensity = intensity;
+
+				HSVtoRGB( intensity, 1.00, 0.50, out );
+
+				image[j*4+0] = out[0] * 255;
+				image[j*4+1] = out[1] * 255;
+				image[j*4+2] = out[2] * 255;
+				image[j*4+3] = 255;
+
+				sumIntensity += intensity;
+			}
+		} else {
+			for ( j = 0 ; j < LIGHTMAP_SIZE * LIGHTMAP_SIZE; j++ ) {
+				R_ColorShiftLightingBytes( &buf_p[j*3], &image[j*4] );
+				image[j*4+3] = 255;
+			}
+		}
+		tr.lightmaps[i] = R_CreateImage( va("*%s/lightmap%d",sMapName,i), image, 
+			LIGHTMAP_SIZE, LIGHTMAP_SIZE, GL_RGBA, qfalse, qfalse, (qboolean)r_ext_compressed_lightmaps->integer, GL_CLAMP );
+	}
+
+	if ( r_lightmap->integer == 2 )	{
+		Com_Printf ("Brightest lightmap value: %d\n", ( int ) ( maxIntensity * 255 ) );
+	}
+}
+
+
+/*
+=================
+RE_SetWorldVisData
+
+This is called by the clipmodel subsystem so we can share the 1.8 megs of
+space in big maps...
+=================
+*/
+void		RE_SetWorldVisData( const byte *vis ) {
+	tr.externalVisData = vis;
+}
+
+
+/*
+=================
+R_LoadVisibility
+=================
+*/
+static	void R_LoadVisibility( lump_t *l, world_t &worldData ) {
+	int		len;
+	byte	*buf;
+
+	len = ( worldData.numClusters + 63 ) & ~63;
+	worldData.novis = (unsigned char *)Hunk_Alloc( len, h_low );
+	Com_Memset( worldData.novis, 0xff, len );
+
+    len = l->filelen;
+	if ( !len ) {
+		return;
+	}
+	buf = fileBase + l->fileofs;
+
+	worldData.numClusters = LittleLong( ((int *)buf)[0] );
+	worldData.clusterBytes = LittleLong( ((int *)buf)[1] );
+
+	// CM_Load should have given us the vis data to share, so
+	// we don't need to allocate another copy
+	if ( tr.externalVisData ) {
+		worldData.vis = tr.externalVisData;
+	} else {
+		byte	*dest;
+
+		dest = (unsigned char *)Hunk_Alloc( len - 8, h_low );
+		Com_Memcpy( dest, buf + 8, len - 8 );
+		worldData.vis = dest;
+	}
+}
+
+//===============================================================================
+
+qhandle_t R_GetShaderByNum(int shaderNum, world_t &worldData)
+{
+	qhandle_t	shader;
+
+	if ( (shaderNum < 0) || (shaderNum >= worldData.numShaders) ) 
+	{
+		Com_Printf( "Warning: Bad index for R_GetShaderByNum - %i", shaderNum );
+		return(0);
+	}
+	shader = RE_RegisterShader(worldData.shaders[ shaderNum ].shader);
+	return(shader);
+}
+
+/*
+===============
+ShaderForShaderNum
+===============
+*/
+static shader_t *ShaderForShaderNum( int shaderNum, const int *lightmapNum, const byte *lightmapStyles, const byte *vertexStyles, world_t &worldData ) 
+{
+	shader_t	*shader;
+	dshader_t	*dsh;
+	const byte	*styles;
+
+	styles = lightmapStyles;
+
+	shaderNum = LittleLong( shaderNum );
+	if ( shaderNum < 0 || shaderNum >= worldData.numShaders ) {
+		Com_Error( ERR_DROP, "ShaderForShaderNum: bad num %i", shaderNum );
+	}
+	dsh = &worldData.shaders[ shaderNum ];
+
+	if (lightmapNum[0] == LIGHTMAP_BY_VERTEX)
+	{
+		styles = vertexStyles;
+	}
+
+	if ( r_vertexLight->integer ) 
+	{
+		lightmapNum = lightmapsVertex;
+		styles = vertexStyles;
+	}
+
+	shader = R_FindShader( dsh->shader, lightmapNum, styles, qtrue );
+
+	// if the shader had errors, just use default shader
+	if ( shader->defaultShader ) {
+		return tr.defaultShader;
+	}
+
+	return shader;
+}
+
+/*
+===============
+ParseFace
+===============
+*/
+static void ParseFace( dsurface_t *ds, mapVert_t *verts, msurface_t *surf, int *indexes, world_t &worldData, int index ) {
+	int					i, j, k;
+	srfSurfaceFace_t	*cv;
+	int					numPoints, numIndexes;
+	int					lightmapNum[MAXLIGHTMAPS];
+	int					sfaceSize, ofsIndexes;
+
+	for(i = 0; i < MAXLIGHTMAPS; i++)
+	{
+		lightmapNum[i] = LittleLong( ds->lightmapNum[i] );
+	}
+
+	// get fog volume
+	surf->fogIndex = LittleLong( ds->fogNum ) + 1;
+	if (index && !surf->fogIndex && tr.world->globalFog != -1)
+	{
+		surf->fogIndex = worldData.globalFog;
+	}
+
+	// get shader value
+	surf->shader = ShaderForShaderNum( ds->shaderNum, lightmapNum, ds->lightmapStyles, ds->vertexStyles, worldData );
+	if ( r_singleShader->integer && !surf->shader->sky ) {
+		surf->shader = tr.defaultShader;
+	}
+
+	numPoints = LittleLong( ds->numVerts );
+	if (numPoints > MAX_FACE_POINTS) {
+		Com_Printf (S_COLOR_YELLOW  "WARNING: MAX_FACE_POINTS exceeded: %i\n", numPoints);
+    numPoints = MAX_FACE_POINTS;
+    surf->shader = tr.defaultShader;
+	}
+
+	numIndexes = LittleLong( ds->numIndexes );
+
+	// create the srfSurfaceFace_t
+	sfaceSize = ( int ) &((srfSurfaceFace_t *)0)->points[numPoints];
+	ofsIndexes = sfaceSize;
+	sfaceSize += sizeof( int ) * numIndexes;
+
+	cv = (srfSurfaceFace_t *)Hunk_Alloc( sfaceSize, h_low );
+	cv->surfaceType = SF_FACE;
+	cv->numPoints = numPoints;
+	cv->numIndices = numIndexes;
+	cv->ofsIndices = ofsIndexes;
+
+	verts += LittleLong( ds->firstVert );
+	for ( i = 0 ; i < numPoints ; i++ ) {
+		for ( j = 0 ; j < 3 ; j++ ) {
+			cv->points[i][j] = LittleFloat( verts[i].xyz[j] );
+		}
+		for ( j = 0 ; j < 2 ; j++ ) {
+			cv->points[i][3+j] = LittleFloat( verts[i].st[j] );
+			for(k=0;k<MAXLIGHTMAPS;k++)
+			{
+				cv->points[i][VERTEX_LM+j+(k*2)] = LittleFloat( verts[i].lightmap[k][j] );
+			}
+		}
+		for(k=0;k<MAXLIGHTMAPS;k++)
+		{
+			R_ColorShiftLightingBytes( verts[i].color[k], (byte *)&cv->points[i][VERTEX_COLOR+k] );
+		}
+	}
+
+	indexes += LittleLong( ds->firstIndex );
+	for ( i = 0 ; i < numIndexes ; i++ ) {
+		((int *)((byte *)cv + cv->ofsIndices ))[i] = LittleLong( indexes[ i ] );
+	}
+
+	// take the plane information from the lightmap vector
+	for ( i = 0 ; i < 3 ; i++ ) {
+		cv->plane.normal[i] = LittleFloat( ds->lightmapVecs[2][i] );
+	}
+	cv->plane.dist = DotProduct( cv->points[0], cv->plane.normal );
+	SetPlaneSignbits( &cv->plane );
+	cv->plane.type = PlaneTypeForNormal( cv->plane.normal );
+
+	surf->data = (surfaceType_t *)cv;
+}
+
+
+/*
+===============
+ParseMesh
+===============
+*/
+static void ParseMesh ( dsurface_t *ds, mapVert_t *verts, msurface_t *surf, world_t &worldData, int index ) {
+	srfGridMesh_t			*grid;
+	int						i, j, k;
+	int						width, height, numPoints;
+	MAC_STATIC drawVert_t	points[MAX_PATCH_SIZE*MAX_PATCH_SIZE];
+	int						lightmapNum[MAXLIGHTMAPS];
+	vec3_t					bounds[2];
+	vec3_t					tmpVec;
+	static surfaceType_t	skipData = SF_SKIP;
+
+	for(i=0;i<MAXLIGHTMAPS;i++)
+	{
+		lightmapNum[i] = LittleLong( ds->lightmapNum[i] );
+	}
+
+	// get fog volume
+	surf->fogIndex = LittleLong( ds->fogNum ) + 1;
+	if (index && !surf->fogIndex && tr.world->globalFog != -1)
+	{
+		surf->fogIndex = worldData.globalFog;
+	}
+
+	// get shader value
+	surf->shader = ShaderForShaderNum( ds->shaderNum, lightmapNum, ds->lightmapStyles, ds->vertexStyles, worldData );
+	if ( r_singleShader->integer && !surf->shader->sky ) {
+		surf->shader = tr.defaultShader;
+	}
+
+	// we may have a nodraw surface, because they might still need to
+	// be around for movement clipping
+	if ( worldData.shaders[ LittleLong( ds->shaderNum ) ].surfaceFlags & SURF_NODRAW ) {
+		surf->data = &skipData;
+		return;
+	}
+
+	width = LittleLong( ds->patchWidth );
+	height = LittleLong( ds->patchHeight );
+
+	verts += LittleLong( ds->firstVert );
+	numPoints = width * height;
+	for ( i = 0 ; i < numPoints ; i++ ) {
+		for ( j = 0 ; j < 3 ; j++ ) {
+			points[i].xyz[j] = LittleFloat( verts[i].xyz[j] );
+			points[i].normal[j] = LittleFloat( verts[i].normal[j] );
+		}
+		for ( j = 0 ; j < 2 ; j++ ) {
+			points[i].st[j] = LittleFloat( verts[i].st[j] );
+			for(k=0;k<MAXLIGHTMAPS;k++)
+			{
+				points[i].lightmap[k][j] = LittleFloat( verts[i].lightmap[k][j] );
+			}
+		}
+		for(k=0;k<MAXLIGHTMAPS;k++)
+		{
+			R_ColorShiftLightingBytes( verts[i].color[k], points[i].color[k] );
+		}
+	}
+
+	// pre-tesseleate
+	grid = R_SubdividePatchToGrid( width, height, points );
+	surf->data = (surfaceType_t *)grid;
+
+	// copy the level of detail origin, which is the center
+	// of the group of all curves that must subdivide the same
+	// to avoid cracking
+	for ( i = 0 ; i < 3 ; i++ ) {
+		bounds[0][i] = LittleFloat( ds->lightmapVecs[0][i] );
+		bounds[1][i] = LittleFloat( ds->lightmapVecs[1][i] );
+	}
+	VectorAdd( bounds[0], bounds[1], bounds[1] );
+	VectorScale( bounds[1], 0.5f, grid->lodOrigin );
+	VectorSubtract( bounds[0], grid->lodOrigin, tmpVec );
+	grid->lodRadius = VectorLength( tmpVec );
+}
+
+/*
+===============
+ParseTriSurf
+===============
+*/
+static void ParseTriSurf( dsurface_t *ds, mapVert_t *verts, msurface_t *surf, int *indexes, world_t &worldData, int index ) {
+	srfTriangles_t	*tri;
+	int				i, j, k;
+	int				numVerts, numIndexes;
+
+	// get fog volume
+	surf->fogIndex = LittleLong( ds->fogNum ) + 1;
+	if (index && !surf->fogIndex && tr.world->globalFog != -1)
+	{
+		surf->fogIndex = worldData.globalFog;
+	}
+
+	// get shader
+	surf->shader = ShaderForShaderNum( ds->shaderNum, lightmapsVertex, ds->lightmapStyles, ds->vertexStyles, worldData );
+	if ( r_singleShader->integer && !surf->shader->sky ) {
+		surf->shader = tr.defaultShader;
+	}
+
+	numVerts = LittleLong( ds->numVerts );
+	numIndexes = LittleLong( ds->numIndexes );
+
+	if ( numVerts >= SHADER_MAX_VERTEXES ) {
+		Com_Error(ERR_DROP, "ParseTriSurf: verts > MAX (%d > %d) on misc_model %s", numVerts, SHADER_MAX_VERTEXES, surf->shader->name );
+	}
+	if ( numIndexes >= SHADER_MAX_INDEXES ) {
+		Com_Error(ERR_DROP, "ParseTriSurf: indices > MAX (%d > %d) on misc_model %s", numIndexes, SHADER_MAX_INDEXES, surf->shader->name );
+	}
+
+	tri = (srfTriangles_t *)Hunk_Alloc( sizeof( *tri ) + numVerts * sizeof( tri->verts[0] ) 
+		+ numIndexes * sizeof( tri->indexes[0] ), h_low );
+	tri->surfaceType = SF_TRIANGLES;
+	tri->numVerts = numVerts;
+	tri->numIndexes = numIndexes;
+	tri->verts = (drawVert_t *)(tri + 1);
+	tri->indexes = (int *)(tri->verts + tri->numVerts );
+
+	surf->data = (surfaceType_t *)tri;
+
+	// copy vertexes
+	ClearBounds( tri->bounds[0], tri->bounds[1] );
+	verts += LittleLong( ds->firstVert );
+	for ( i = 0 ; i < numVerts ; i++ ) {
+		for ( j = 0 ; j < 3 ; j++ ) {
+			tri->verts[i].xyz[j] = LittleFloat( verts[i].xyz[j] );
+			tri->verts[i].normal[j] = LittleFloat( verts[i].normal[j] );
+		}
+		AddPointToBounds( tri->verts[i].xyz, tri->bounds[0], tri->bounds[1] );
+		for ( j = 0 ; j < 2 ; j++ ) {
+			tri->verts[i].st[j] = LittleFloat( verts[i].st[j] );
+			for(k=0;k<MAXLIGHTMAPS;k++)
+			{
+				tri->verts[i].lightmap[k][j] = LittleFloat( verts[i].lightmap[k][j] );
+			}
+		}
+
+		for(k=0;k<MAXLIGHTMAPS;k++)
+		{
+			R_ColorShiftLightingBytes( verts[i].color[k], tri->verts[i].color[k] );
+		}
+	}
+
+	// copy indexes
+	indexes += LittleLong( ds->firstIndex );
+	for ( i = 0 ; i < numIndexes ; i++ ) {
+		tri->indexes[i] = LittleLong( indexes[i] );
+		if ( tri->indexes[i] < 0 || tri->indexes[i] >= numVerts ) {
+			Com_Error( ERR_DROP, "Bad index in triangle surface" );
+		}
+	}
+}
+
+/*
+===============
+ParseFlare
+===============
+*/
+static void ParseFlare( dsurface_t *ds, mapVert_t *verts, msurface_t *surf, int *indexes, world_t &worldData, int index ) {
+	srfFlare_t		*flare;
+	int				i;
+	int				lightmaps[MAXLIGHTMAPS] = { LIGHTMAP_BY_VERTEX };
+
+	// get fog volume
+	surf->fogIndex = LittleLong( ds->fogNum ) + 1;
+	if (index && !surf->fogIndex && tr.world->globalFog != -1)
+	{
+		surf->fogIndex = worldData.globalFog;
+	}
+
+	// get shader
+	surf->shader = ShaderForShaderNum( ds->shaderNum, lightmaps, ds->lightmapStyles, ds->vertexStyles, worldData );
+	if ( r_singleShader->integer && !surf->shader->sky ) {
+		surf->shader = tr.defaultShader;
+	}
+
+	flare = (struct srfFlare_s *)Hunk_Alloc( sizeof( *flare ), h_low );
+	flare->surfaceType = SF_FLARE;
+
+	surf->data = (surfaceType_t *)flare;
+
+	for ( i = 0 ; i < 3 ; i++ ) {
+		flare->origin[i] = LittleFloat( ds->lightmapOrigin[i] );
+		flare->color[i] = LittleFloat( ds->lightmapVecs[0][i] );
+		flare->normal[i] = LittleFloat( ds->lightmapVecs[2][i] );
+	}
+}
+
+
+/*
+=================
+R_MergedWidthPoints
+
+returns true if there are grid points merged on a width edge
+=================
+*/
+int R_MergedWidthPoints(srfGridMesh_t *grid, int offset) {
+	int i, j;
+
+	for (i = 1; i < grid->width-1; i++) {
+		for (j = i + 1; j < grid->width-1; j++) {
+			if ( fabs(grid->verts[i + offset].xyz[0] - grid->verts[j + offset].xyz[0]) > .1) continue;
+			if ( fabs(grid->verts[i + offset].xyz[1] - grid->verts[j + offset].xyz[1]) > .1) continue;
+			if ( fabs(grid->verts[i + offset].xyz[2] - grid->verts[j + offset].xyz[2]) > .1) continue;
+			return qtrue;
+		}
+	}
+	return qfalse;
+}
+
+/*
+=================
+R_MergedHeightPoints
+
+returns true if there are grid points merged on a height edge
+=================
+*/
+int R_MergedHeightPoints(srfGridMesh_t *grid, int offset) {
+	int i, j;
+
+	for (i = 1; i < grid->height-1; i++) {
+		for (j = i + 1; j < grid->height-1; j++) {
+			if ( fabs(grid->verts[grid->width * i + offset].xyz[0] - grid->verts[grid->width * j + offset].xyz[0]) > .1) continue;
+			if ( fabs(grid->verts[grid->width * i + offset].xyz[1] - grid->verts[grid->width * j + offset].xyz[1]) > .1) continue;
+			if ( fabs(grid->verts[grid->width * i + offset].xyz[2] - grid->verts[grid->width * j + offset].xyz[2]) > .1) continue;
+			return qtrue;
+		}
+	}
+	return qfalse;
+}
+
+/*
+=================
+R_FixSharedVertexLodError_r
+
+NOTE: never sync LoD through grid edges with merged points!
+
+FIXME: write generalized version that also avoids cracks between a patch and one that meets half way?
+=================
+*/
+void R_FixSharedVertexLodError_r( int start, srfGridMesh_t *grid1, world_t &worldData ) {
+	int j, k, l, m, n, offset1, offset2, touch;
+	srfGridMesh_t *grid2;
+
+	for ( j = start; j < worldData.numsurfaces; j++ ) {
+		//
+		grid2 = (srfGridMesh_t *) worldData.surfaces[j].data;
+		// if this surface is not a grid
+		if ( grid2->surfaceType != SF_GRID ) continue;
+		// if the LOD errors are already fixed for this patch
+		if ( grid2->lodFixed == 2 ) continue;
+		// grids in the same LOD group should have the exact same lod radius
+		if ( grid1->lodRadius != grid2->lodRadius ) continue;
+		// grids in the same LOD group should have the exact same lod origin
+		if ( grid1->lodOrigin[0] != grid2->lodOrigin[0] ) continue;
+		if ( grid1->lodOrigin[1] != grid2->lodOrigin[1] ) continue;
+		if ( grid1->lodOrigin[2] != grid2->lodOrigin[2] ) continue;
+		//
+		touch = qfalse;
+		for (n = 0; n < 2; n++) {
+			//
+			if (n) offset1 = (grid1->height-1) * grid1->width;
+			else offset1 = 0;
+			if (R_MergedWidthPoints(grid1, offset1)) continue;
+			for (k = 1; k < grid1->width-1; k++) {
+				for (m = 0; m < 2; m++) {
+
+					if (m) offset2 = (grid2->height-1) * grid2->width;
+					else offset2 = 0;
+					if (R_MergedWidthPoints(grid2, offset2)) continue;
+					for ( l = 1; l < grid2->width-1; l++) {
+					//
+						if ( fabs(grid1->verts[k + offset1].xyz[0] - grid2->verts[l + offset2].xyz[0]) > .1) continue;
+						if ( fabs(grid1->verts[k + offset1].xyz[1] - grid2->verts[l + offset2].xyz[1]) > .1) continue;
+						if ( fabs(grid1->verts[k + offset1].xyz[2] - grid2->verts[l + offset2].xyz[2]) > .1) continue;
+						// ok the points are equal and should have the same lod error
+						grid2->widthLodError[l] = grid1->widthLodError[k];
+						touch = qtrue;
+					}
+				}
+				for (m = 0; m < 2; m++) {
+
+					if (m) offset2 = grid2->width-1;
+					else offset2 = 0;
+					if (R_MergedHeightPoints(grid2, offset2)) continue;
+					for ( l = 1; l < grid2->height-1; l++) {
+					//
+						if ( fabs(grid1->verts[k + offset1].xyz[0] - grid2->verts[grid2->width * l + offset2].xyz[0]) > .1) continue;
+						if ( fabs(grid1->verts[k + offset1].xyz[1] - grid2->verts[grid2->width * l + offset2].xyz[1]) > .1) continue;
+						if ( fabs(grid1->verts[k + offset1].xyz[2] - grid2->verts[grid2->width * l + offset2].xyz[2]) > .1) continue;
+						// ok the points are equal and should have the same lod error
+						grid2->heightLodError[l] = grid1->widthLodError[k];
+						touch = qtrue;
+					}
+				}
+			}
+		}
+		for (n = 0; n < 2; n++) {
+			//
+			if (n) offset1 = grid1->width-1;
+			else offset1 = 0;
+			if (R_MergedHeightPoints(grid1, offset1)) continue;
+			for (k = 1; k < grid1->height-1; k++) {
+				for (m = 0; m < 2; m++) {
+
+					if (m) offset2 = (grid2->height-1) * grid2->width;
+					else offset2 = 0;
+					if (R_MergedWidthPoints(grid2, offset2)) continue;
+					for ( l = 1; l < grid2->width-1; l++) {
+					//
+						if ( fabs(grid1->verts[grid1->width * k + offset1].xyz[0] - grid2->verts[l + offset2].xyz[0]) > .1) continue;
+						if ( fabs(grid1->verts[grid1->width * k + offset1].xyz[1] - grid2->verts[l + offset2].xyz[1]) > .1) continue;
+						if ( fabs(grid1->verts[grid1->width * k + offset1].xyz[2] - grid2->verts[l + offset2].xyz[2]) > .1) continue;
+						// ok the points are equal and should have the same lod error
+						grid2->widthLodError[l] = grid1->heightLodError[k];
+						touch = qtrue;
+					}
+				}
+				for (m = 0; m < 2; m++) {
+
+					if (m) offset2 = grid2->width-1;
+					else offset2 = 0;
+					if (R_MergedHeightPoints(grid2, offset2)) continue;
+					for ( l = 1; l < grid2->height-1; l++) {
+					//
+						if ( fabs(grid1->verts[grid1->width * k + offset1].xyz[0] - grid2->verts[grid2->width * l + offset2].xyz[0]) > .1) continue;
+						if ( fabs(grid1->verts[grid1->width * k + offset1].xyz[1] - grid2->verts[grid2->width * l + offset2].xyz[1]) > .1) continue;
+						if ( fabs(grid1->verts[grid1->width * k + offset1].xyz[2] - grid2->verts[grid2->width * l + offset2].xyz[2]) > .1) continue;
+						// ok the points are equal and should have the same lod error
+						grid2->heightLodError[l] = grid1->heightLodError[k];
+						touch = qtrue;
+					}
+				}
+			}
+		}
+		if (touch) {
+			grid2->lodFixed = 2;
+			R_FixSharedVertexLodError_r ( start, grid2, worldData );
+			//NOTE: this would be correct but makes things really slow
+			//grid2->lodFixed = 1;
+		}
+	}
+}
+
+/*
+=================
+R_FixSharedVertexLodError
+
+This function assumes that all patches in one group are nicely stitched together for the highest LoD.
+If this is not the case this function will still do its job but won't fix the highest LoD cracks.
+=================
+*/
+void R_FixSharedVertexLodError( world_t &worldData ) {
+	int i;
+	srfGridMesh_t *grid1;
+
+	for ( i = 0; i < worldData.numsurfaces; i++ ) {
+		//
+		grid1 = (srfGridMesh_t *) worldData.surfaces[i].data;
+		// if this surface is not a grid
+		if ( grid1->surfaceType != SF_GRID )
+			continue;
+		//
+		if ( grid1->lodFixed )
+			continue;
+		//
+		grid1->lodFixed = 2;
+		// recursively fix other patches in the same LOD group
+		R_FixSharedVertexLodError_r( i + 1, grid1, worldData);
+	}
+}
+
+
+/*
+===============
+R_StitchPatches
+===============
+*/
+int R_StitchPatches( int grid1num, int grid2num, world_t &worldData ) {
+	int k, l, m, n, offset1, offset2, row, column;
+	srfGridMesh_t *grid1, *grid2;
+	float *v1, *v2;
+
+	grid1 = (srfGridMesh_t *) worldData.surfaces[grid1num].data;
+	grid2 = (srfGridMesh_t *) worldData.surfaces[grid2num].data;
+	for (n = 0; n < 2; n++) {
+		//
+		if (n) offset1 = (grid1->height-1) * grid1->width;
+		else offset1 = 0;
+		if (R_MergedWidthPoints(grid1, offset1))
+			continue;
+		for (k = 0; k < grid1->width-2; k += 2) {
+
+			for (m = 0; m < 2; m++) {
+
+				if ( grid2->width >= MAX_GRID_SIZE )
+					break;
+				if (m) offset2 = (grid2->height-1) * grid2->width;
+				else offset2 = 0;
+				//if (R_MergedWidthPoints(grid2, offset2))
+				//	continue;
+				for ( l = 0; l < grid2->width-1; l++) {
+				//
+					v1 = grid1->verts[k + offset1].xyz;
+					v2 = grid2->verts[l + offset2].xyz;
+					if ( fabs(v1[0] - v2[0]) > .1)
+						continue;
+					if ( fabs(v1[1] - v2[1]) > .1)
+						continue;
+					if ( fabs(v1[2] - v2[2]) > .1)
+						continue;
+
+					v1 = grid1->verts[k + 2 + offset1].xyz;
+					v2 = grid2->verts[l + 1 + offset2].xyz;
+					if ( fabs(v1[0] - v2[0]) > .1)
+						continue;
+					if ( fabs(v1[1] - v2[1]) > .1)
+						continue;
+					if ( fabs(v1[2] - v2[2]) > .1)
+						continue;
+					//
+					v1 = grid2->verts[l + offset2].xyz;
+					v2 = grid2->verts[l + 1 + offset2].xyz;
+					if ( fabs(v1[0] - v2[0]) < .01 &&
+							fabs(v1[1] - v2[1]) < .01 &&
+							fabs(v1[2] - v2[2]) < .01)
+						continue;
+					//
+					//Com_Printf ("found highest LoD crack between two patches\n" );
+					// insert column into grid2 right after after column l
+					if (m) row = grid2->height-1;
+					else row = 0;
+					grid2 = R_GridInsertColumn( grid2, l+1, row,
+									grid1->verts[k + 1 + offset1].xyz, grid1->widthLodError[k+1]);
+					grid2->lodStitched = qfalse;
+					worldData.surfaces[grid2num].data = (surfaceType_t *) grid2;
+					return qtrue;
+				}
+			}
+			for (m = 0; m < 2; m++) {
+
+				if (grid2->height >= MAX_GRID_SIZE)
+					break;
+				if (m) offset2 = grid2->width-1;
+				else offset2 = 0;
+				//if (R_MergedHeightPoints(grid2, offset2))
+				//	continue;
+				for ( l = 0; l < grid2->height-1; l++) {
+					//
+					v1 = grid1->verts[k + offset1].xyz;
+					v2 = grid2->verts[grid2->width * l + offset2].xyz;
+					if ( fabs(v1[0] - v2[0]) > .1)
+						continue;
+					if ( fabs(v1[1] - v2[1]) > .1)
+						continue;
+					if ( fabs(v1[2] - v2[2]) > .1)
+						continue;
+
+					v1 = grid1->verts[k + 2 + offset1].xyz;
+					v2 = grid2->verts[grid2->width * (l + 1) + offset2].xyz;
+					if ( fabs(v1[0] - v2[0]) > .1)
+						continue;
+					if ( fabs(v1[1] - v2[1]) > .1)
+						continue;
+					if ( fabs(v1[2] - v2[2]) > .1)
+						continue;
+					//
+					v1 = grid2->verts[grid2->width * l + offset2].xyz;
+					v2 = grid2->verts[grid2->width * (l + 1) + offset2].xyz;
+					if ( fabs(v1[0] - v2[0]) < .01 &&
+							fabs(v1[1] - v2[1]) < .01 &&
+							fabs(v1[2] - v2[2]) < .01)
+						continue;
+					//
+					//Com_Printf ("found highest LoD crack between two patches\n" );
+					// insert row into grid2 right after after row l
+					if (m) column = grid2->width-1;
+					else column = 0;
+					grid2 = R_GridInsertRow( grid2, l+1, column,
+										grid1->verts[k + 1 + offset1].xyz, grid1->widthLodError[k+1]);
+					grid2->lodStitched = qfalse;
+					worldData.surfaces[grid2num].data = (surfaceType_t *) grid2;
+					return qtrue;
+				}
+			}
+		}
+	}
+	for (n = 0; n < 2; n++) {
+		//
+		if (n) offset1 = grid1->width-1;
+		else offset1 = 0;
+		if (R_MergedHeightPoints(grid1, offset1))
+			continue;
+		for (k = 0; k < grid1->height-2; k += 2) {
+			for (m = 0; m < 2; m++) {
+
+				if ( grid2->width >= MAX_GRID_SIZE )
+					break;
+				if (m) offset2 = (grid2->height-1) * grid2->width;
+				else offset2 = 0;
+				//if (R_MergedWidthPoints(grid2, offset2))
+				//	continue;
+				for ( l = 0; l < grid2->width-1; l++) {
+				//
+					v1 = grid1->verts[grid1->width * k + offset1].xyz;
+					v2 = grid2->verts[l + offset2].xyz;
+					if ( fabs(v1[0] - v2[0]) > .1)
+						continue;
+					if ( fabs(v1[1] - v2[1]) > .1)
+						continue;
+					if ( fabs(v1[2] - v2[2]) > .1)
+						continue;
+
+					v1 = grid1->verts[grid1->width * (k + 2) + offset1].xyz;
+					v2 = grid2->verts[l + 1 + offset2].xyz;
+					if ( fabs(v1[0] - v2[0]) > .1)
+						continue;
+					if ( fabs(v1[1] - v2[1]) > .1)
+						continue;
+					if ( fabs(v1[2] - v2[2]) > .1)
+						continue;
+					//
+					v1 = grid2->verts[l + offset2].xyz;
+					v2 = grid2->verts[(l + 1) + offset2].xyz;
+					if ( fabs(v1[0] - v2[0]) < .01 &&
+							fabs(v1[1] - v2[1]) < .01 &&
+							fabs(v1[2] - v2[2]) < .01)
+						continue;
+					//
+					//Com_Printf ("found highest LoD crack between two patches\n" );
+					// insert column into grid2 right after after column l
+					if (m) row = grid2->height-1;
+					else row = 0;
+					grid2 = R_GridInsertColumn( grid2, l+1, row,
+									grid1->verts[grid1->width * (k + 1) + offset1].xyz, grid1->heightLodError[k+1]);
+					grid2->lodStitched = qfalse;
+					worldData.surfaces[grid2num].data = (surfaceType_t *) grid2;
+					return qtrue;
+				}
+			}
+			for (m = 0; m < 2; m++) {
+
+				if (grid2->height >= MAX_GRID_SIZE)
+					break;
+				if (m) offset2 = grid2->width-1;
+				else offset2 = 0;
+				//if (R_MergedHeightPoints(grid2, offset2))
+				//	continue;
+				for ( l = 0; l < grid2->height-1; l++) {
+				//
+					v1 = grid1->verts[grid1->width * k + offset1].xyz;
+					v2 = grid2->verts[grid2->width * l + offset2].xyz;
+					if ( fabs(v1[0] - v2[0]) > .1)
+						continue;
+					if ( fabs(v1[1] - v2[1]) > .1)
+						continue;
+					if ( fabs(v1[2] - v2[2]) > .1)
+						continue;
+
+					v1 = grid1->verts[grid1->width * (k + 2) + offset1].xyz;
+					v2 = grid2->verts[grid2->width * (l + 1) + offset2].xyz;
+					if ( fabs(v1[0] - v2[0]) > .1)
+						continue;
+					if ( fabs(v1[1] - v2[1]) > .1)
+						continue;
+					if ( fabs(v1[2] - v2[2]) > .1)
+						continue;
+					//
+					v1 = grid2->verts[grid2->width * l + offset2].xyz;
+					v2 = grid2->verts[grid2->width * (l + 1) + offset2].xyz;
+					if ( fabs(v1[0] - v2[0]) < .01 &&
+							fabs(v1[1] - v2[1]) < .01 &&
+							fabs(v1[2] - v2[2]) < .01)
+						continue;
+					//
+					//Com_Printf ("found highest LoD crack between two patches\n" );
+					// insert row into grid2 right after after row l
+					if (m) column = grid2->width-1;
+					else column = 0;
+					grid2 = R_GridInsertRow( grid2, l+1, column,
+									grid1->verts[grid1->width * (k + 1) + offset1].xyz, grid1->heightLodError[k+1]);
+					grid2->lodStitched = qfalse;
+					worldData.surfaces[grid2num].data = (surfaceType_t *) grid2;
+					return qtrue;
+				}
+			}
+		}
+	}
+	for (n = 0; n < 2; n++) {
+		//
+		if (n) offset1 = (grid1->height-1) * grid1->width;
+		else offset1 = 0;
+		if (R_MergedWidthPoints(grid1, offset1))
+			continue;
+		for (k = grid1->width-1; k > 1; k -= 2) {
+
+			for (m = 0; m < 2; m++) {
+
+				if ( grid2->width >= MAX_GRID_SIZE )
+					break;
+				if (m) offset2 = (grid2->height-1) * grid2->width;
+				else offset2 = 0;
+				//if (R_MergedWidthPoints(grid2, offset2))
+				//	continue;
+				for ( l = 0; l < grid2->width-1; l++) {
+				//
+					v1 = grid1->verts[k + offset1].xyz;
+					v2 = grid2->verts[l + offset2].xyz;
+					if ( fabs(v1[0] - v2[0]) > .1)
+						continue;
+					if ( fabs(v1[1] - v2[1]) > .1)
+						continue;
+					if ( fabs(v1[2] - v2[2]) > .1)
+						continue;
+
+					v1 = grid1->verts[k - 2 + offset1].xyz;
+					v2 = grid2->verts[l + 1 + offset2].xyz;
+					if ( fabs(v1[0] - v2[0]) > .1)
+						continue;
+					if ( fabs(v1[1] - v2[1]) > .1)
+						continue;
+					if ( fabs(v1[2] - v2[2]) > .1)
+						continue;
+					//
+					v1 = grid2->verts[l + offset2].xyz;
+					v2 = grid2->verts[(l + 1) + offset2].xyz;
+					if ( fabs(v1[0] - v2[0]) < .01 &&
+							fabs(v1[1] - v2[1]) < .01 &&
+							fabs(v1[2] - v2[2]) < .01)
+						continue;
+					//
+					//Com_Printf ("found highest LoD crack between two patches\n" );
+					// insert column into grid2 right after after column l
+					if (m) row = grid2->height-1;
+					else row = 0;
+					grid2 = R_GridInsertColumn( grid2, l+1, row,
+										grid1->verts[k - 1 + offset1].xyz, grid1->widthLodError[k+1]);
+					grid2->lodStitched = qfalse;
+					worldData.surfaces[grid2num].data = (surfaceType_t *) grid2;
+					return qtrue;
+				}
+			}
+			for (m = 0; m < 2; m++) {
+
+				if (grid2->height >= MAX_GRID_SIZE)
+					break;
+				if (m) offset2 = grid2->width-1;
+				else offset2 = 0;
+				//if (R_MergedHeightPoints(grid2, offset2))
+				//	continue;
+				for ( l = 0; l < grid2->height-1; l++) {
+				//
+					v1 = grid1->verts[k + offset1].xyz;
+					v2 = grid2->verts[grid2->width * l + offset2].xyz;
+					if ( fabs(v1[0] - v2[0]) > .1)
+						continue;
+					if ( fabs(v1[1] - v2[1]) > .1)
+						continue;
+					if ( fabs(v1[2] - v2[2]) > .1)
+						continue;
+
+					v1 = grid1->verts[k - 2 + offset1].xyz;
+					v2 = grid2->verts[grid2->width * (l + 1) + offset2].xyz;
+					if ( fabs(v1[0] - v2[0]) > .1)
+						continue;
+					if ( fabs(v1[1] - v2[1]) > .1)
+						continue;
+					if ( fabs(v1[2] - v2[2]) > .1)
+						continue;
+					//
+					v1 = grid2->verts[grid2->width * l + offset2].xyz;
+					v2 = grid2->verts[grid2->width * (l + 1) + offset2].xyz;
+					if ( fabs(v1[0] - v2[0]) < .01 &&
+							fabs(v1[1] - v2[1]) < .01 &&
+							fabs(v1[2] - v2[2]) < .01)
+						continue;
+					//
+					//Com_Printf ("found highest LoD crack between two patches\n" );
+					// insert row into grid2 right after after row l
+					if (m) column = grid2->width-1;
+					else column = 0;
+					grid2 = R_GridInsertRow( grid2, l+1, column,
+										grid1->verts[k - 1 + offset1].xyz, grid1->widthLodError[k+1]);
+					if (!grid2)
+						break;
+					grid2->lodStitched = qfalse;
+					worldData.surfaces[grid2num].data = (surfaceType_t *) grid2;
+					return qtrue;
+				}
+			}
+		}
+	}
+	for (n = 0; n < 2; n++) {
+		//
+		if (n) offset1 = grid1->width-1;
+		else offset1 = 0;
+		if (R_MergedHeightPoints(grid1, offset1))
+			continue;
+		for (k = grid1->height-1; k > 1; k -= 2) {
+			for (m = 0; m < 2; m++) {
+
+				if ( grid2->width >= MAX_GRID_SIZE )
+					break;
+				if (m) offset2 = (grid2->height-1) * grid2->width;
+				else offset2 = 0;
+				//if (R_MergedWidthPoints(grid2, offset2))
+				//	continue;
+				for ( l = 0; l < grid2->width-1; l++) {
+				//
+					v1 = grid1->verts[grid1->width * k + offset1].xyz;
+					v2 = grid2->verts[l + offset2].xyz;
+					if ( fabs(v1[0] - v2[0]) > .1)
+						continue;
+					if ( fabs(v1[1] - v2[1]) > .1)
+						continue;
+					if ( fabs(v1[2] - v2[2]) > .1)
+						continue;
+
+					v1 = grid1->verts[grid1->width * (k - 2) + offset1].xyz;
+					v2 = grid2->verts[l + 1 + offset2].xyz;
+					if ( fabs(v1[0] - v2[0]) > .1)
+						continue;
+					if ( fabs(v1[1] - v2[1]) > .1)
+						continue;
+					if ( fabs(v1[2] - v2[2]) > .1)
+						continue;
+					//
+					v1 = grid2->verts[l + offset2].xyz;
+					v2 = grid2->verts[(l + 1) + offset2].xyz;
+					if ( fabs(v1[0] - v2[0]) < .01 &&
+							fabs(v1[1] - v2[1]) < .01 &&
+							fabs(v1[2] - v2[2]) < .01)
+						continue;
+					//
+					//Com_Printf ("found highest LoD crack between two patches\n" );
+					// insert column into grid2 right after after column l
+					if (m) row = grid2->height-1;
+					else row = 0;
+					grid2 = R_GridInsertColumn( grid2, l+1, row,
+										grid1->verts[grid1->width * (k - 1) + offset1].xyz, grid1->heightLodError[k+1]);
+					grid2->lodStitched = qfalse;
+					worldData.surfaces[grid2num].data = (surfaceType_t *) grid2;
+					return qtrue;
+				}
+			}
+			for (m = 0; m < 2; m++) {
+
+				if (grid2->height >= MAX_GRID_SIZE)
+					break;
+				if (m) offset2 = grid2->width-1;
+				else offset2 = 0;
+				//if (R_MergedHeightPoints(grid2, offset2))
+				//	continue;
+				for ( l = 0; l < grid2->height-1; l++) {
+				//
+					v1 = grid1->verts[grid1->width * k + offset1].xyz;
+					v2 = grid2->verts[grid2->width * l + offset2].xyz;
+					if ( fabs(v1[0] - v2[0]) > .1)
+						continue;
+					if ( fabs(v1[1] - v2[1]) > .1)
+						continue;
+					if ( fabs(v1[2] - v2[2]) > .1)
+						continue;
+
+					v1 = grid1->verts[grid1->width * (k - 2) + offset1].xyz;
+					v2 = grid2->verts[grid2->width * (l + 1) + offset2].xyz;
+					if ( fabs(v1[0] - v2[0]) > .1)
+						continue;
+					if ( fabs(v1[1] - v2[1]) > .1)
+						continue;
+					if ( fabs(v1[2] - v2[2]) > .1)
+						continue;
+					//
+					v1 = grid2->verts[grid2->width * l + offset2].xyz;
+					v2 = grid2->verts[grid2->width * (l + 1) + offset2].xyz;
+					if ( fabs(v1[0] - v2[0]) < .01 &&
+							fabs(v1[1] - v2[1]) < .01 &&
+							fabs(v1[2] - v2[2]) < .01)
+						continue;
+					//
+					//Com_Printf ("found highest LoD crack between two patches\n" );
+					// insert row into grid2 right after after row l
+					if (m) column = grid2->width-1;
+					else column = 0;
+					grid2 = R_GridInsertRow( grid2, l+1, column,
+										grid1->verts[grid1->width * (k - 1) + offset1].xyz, grid1->heightLodError[k+1]);
+					grid2->lodStitched = qfalse;
+					worldData.surfaces[grid2num].data = (surfaceType_t *) grid2;
+					return qtrue;
+				}
+			}
+		}
+	}
+	return qfalse;
+}
+
+/*
+===============
+R_TryStitchPatch
+
+This function will try to stitch patches in the same LoD group together for the highest LoD.
+
+Only single missing vertice cracks will be fixed.
+
+Vertices will be joined at the patch side a crack is first found, at the other side
+of the patch (on the same row or column) the vertices will not be joined and cracks
+might still appear at that side.
+===============
+*/
+int R_TryStitchingPatch( int grid1num, world_t &worldData ) {
+	int j, numstitches;
+	srfGridMesh_t *grid1, *grid2;
+
+	numstitches = 0;
+	grid1 = (srfGridMesh_t *) worldData.surfaces[grid1num].data;
+	for ( j = 0; j < worldData.numsurfaces; j++ ) {
+		//
+		grid2 = (srfGridMesh_t *) worldData.surfaces[j].data;
+		// if this surface is not a grid
+		if ( grid2->surfaceType != SF_GRID ) continue;
+		// grids in the same LOD group should have the exact same lod radius
+		if ( grid1->lodRadius != grid2->lodRadius ) continue;
+		// grids in the same LOD group should have the exact same lod origin
+		if ( grid1->lodOrigin[0] != grid2->lodOrigin[0] ) continue;
+		if ( grid1->lodOrigin[1] != grid2->lodOrigin[1] ) continue;
+		if ( grid1->lodOrigin[2] != grid2->lodOrigin[2] ) continue;
+		//
+		while (R_StitchPatches(grid1num, j, worldData))
+		{
+			numstitches++;
+		}
+	}
+	return numstitches;
+}
+
+/*
+===============
+R_StitchAllPatches
+===============
+*/
+void R_StitchAllPatches( world_t &worldData ) {
+	int i, stitched, numstitches;
+	srfGridMesh_t *grid1;
+
+	numstitches = 0;
+	do
+	{
+		stitched = qfalse;
+		for ( i = 0; i < worldData.numsurfaces; i++ ) {
+			//
+			grid1 = (srfGridMesh_t *) worldData.surfaces[i].data;
+			// if this surface is not a grid
+			if ( grid1->surfaceType != SF_GRID )
+				continue;
+			//
+			if ( grid1->lodStitched )
+				continue;
+			//
+			grid1->lodStitched = qtrue;
+			stitched = qtrue;
+			//
+			numstitches += R_TryStitchingPatch( i, worldData );
+		}
+	}
+	while (stitched);
+//	Com_Printf ("stitched %d LoD cracks\n", numstitches );
+}
+
+/*
+===============
+R_MovePatchSurfacesToHunk
+===============
+*/
+void R_MovePatchSurfacesToHunk(world_t &worldData) {
+	int i, size;
+	srfGridMesh_t *grid, *hunkgrid;
+
+	for ( i = 0; i < worldData.numsurfaces; i++ ) {
+		//
+		grid = (srfGridMesh_t *) worldData.surfaces[i].data;
+		// if this surface is not a grid
+		if ( grid->surfaceType != SF_GRID )
+			continue;
+		//
+		size = (grid->width * grid->height - 1) * sizeof( drawVert_t ) + sizeof( *grid );
+		hunkgrid = (struct srfGridMesh_s *)Hunk_Alloc( size, h_low );
+		Com_Memcpy(hunkgrid, grid, size);
+
+		hunkgrid->widthLodError = (float *)Hunk_Alloc( grid->width * 4, h_low );
+		Com_Memcpy( hunkgrid->widthLodError, grid->widthLodError, grid->width * 4 );
+
+		hunkgrid->heightLodError = (float *)Hunk_Alloc( grid->height * 4, h_low );
+		Com_Memcpy( grid->heightLodError, grid->heightLodError, grid->height * 4 );
+
+		R_FreeSurfaceGridMesh( grid );
+
+		worldData.surfaces[i].data = (surfaceType_t *) hunkgrid;
+	}
+}
+
+/*
+===============
+R_LoadSurfaces
+===============
+*/
+static	void R_LoadSurfaces( lump_t *surfs, lump_t *verts, lump_t *indexLump, world_t &worldData, int index ) {
+	dsurface_t	*in;
+	msurface_t	*out;
+	mapVert_t	*dv;
+	int			*indexes;
+	int			count;
+	int			numFaces, numMeshes, numTriSurfs, numFlares;
+	int			i;
+
+	numFaces = 0;
+	numMeshes = 0;
+	numTriSurfs = 0;
+	numFlares = 0;
+
+	in = (dsurface_t *)(fileBase + surfs->fileofs);
+	if (surfs->filelen % sizeof(*in))
+		Com_Error (ERR_DROP, "LoadMap: funny lump size in %s",worldData.name);
+	count = surfs->filelen / sizeof(*in);
+
+	dv = (mapVert_t *)(fileBase + verts->fileofs);
+	if (verts->filelen % sizeof(*dv))
+		Com_Error (ERR_DROP, "LoadMap: funny lump size in %s",worldData.name);
+
+	indexes = (int *)(fileBase + indexLump->fileofs);
+	if ( indexLump->filelen % sizeof(*indexes))
+		Com_Error (ERR_DROP, "LoadMap: funny lump size in %s",worldData.name);
+
+	out = (struct msurface_s *)Hunk_Alloc ( count * sizeof(*out), h_low );	
+
+	worldData.surfaces = out;
+	worldData.numsurfaces = count;
+
+	for ( i = 0 ; i < count ; i++, in++, out++ ) {
+		switch ( LittleLong( in->surfaceType ) ) {
+		case MST_PATCH:
+			ParseMesh ( in, dv, out, worldData, index );
+			numMeshes++;
+			break;
+		case MST_TRIANGLE_SOUP:
+			ParseTriSurf( in, dv, out, indexes, worldData, index );
+			numTriSurfs++;
+			break;
+		case MST_PLANAR:
+			ParseFace( in, dv, out, indexes, worldData, index );
+			numFaces++;
+			break;
+		case MST_FLARE:
+			ParseFlare( in, dv, out, indexes, worldData, index );
+			numFlares++;
+			break;
+		default:
+			Com_Error( ERR_DROP, "Bad surfaceType" );
+		}
+	}
+
+#ifdef PATCH_STITCHING
+	R_StitchAllPatches(worldData);
+#endif
+
+	R_FixSharedVertexLodError(worldData);
+
+#ifdef PATCH_STITCHING
+	R_MovePatchSurfacesToHunk(worldData);
+#endif
+
+//	Com_Printf ("...loaded %d faces, %i meshes, %i trisurfs, %i flares\n", numFaces, numMeshes, numTriSurfs, numFlares );
+}
+
+
+
+/*
+=================
+R_LoadSubmodels
+=================
+*/
+static	void R_LoadSubmodels( lump_t *l, world_t &worldData, int index ) {
+	dmodel_t	*in;
+	bmodel_t	*out;
+	int			i, j, count;
+
+	in = (dmodel_t *)(fileBase + l->fileofs);
+	if (l->filelen % sizeof(*in))
+		Com_Error (ERR_DROP, "LoadMap: funny lump size in %s",worldData.name);
+	count = l->filelen / sizeof(*in);
+
+	worldData.bmodels = out = (bmodel_t *)Hunk_Alloc( count * sizeof(*out), h_low );
+
+	for ( i=0 ; i<count ; i++, in++, out++ ) {
+		model_t *model;
+
+		model = R_AllocModel();
+
+		assert( model != NULL );			// this should never happen
+
+		model->type = MOD_BRUSH;
+		model->bmodel = out;
+		if (index)
+		{
+			Com_sprintf( model->name, sizeof( model->name ), "*%d-%d", index, i );
+			model->bspInstance = qtrue;
+		}
+		else
+		{
+			Com_sprintf( model->name, sizeof( model->name ), "*%d", i);
+		}
+
+		for (j=0 ; j<3 ; j++) {
+			out->bounds[0][j] = LittleFloat (in->mins[j]);
+			out->bounds[1][j] = LittleFloat (in->maxs[j]);
+		}
+/*
+Ghoul2 Insert Start
+*/
+
+		RE_InsertModelIntoHash(model->name, model);
+/*
+Ghoul2 Insert End
+*/
+		out->firstSurface = worldData.surfaces + LittleLong( in->firstSurface );
+		out->numSurfaces = LittleLong( in->numSurfaces );
+	}
+}
+
+
+
+//==================================================================
+
+/*
+=================
+R_SetParent
+=================
+*/
+static	void R_SetParent (mnode_t *node, mnode_t *parent)
+{
+	node->parent = parent;
+	if (node->contents != -1)
+		return;
+	R_SetParent (node->children[0], node);
+	R_SetParent (node->children[1], node);
+}
+
+/*
+=================
+R_LoadNodesAndLeafs
+=================
+*/
+static	void R_LoadNodesAndLeafs (lump_t *nodeLump, lump_t *leafLump, world_t &worldData) {
+	int			i, j, p;
+	dnode_t		*in;
+	dleaf_t		*inLeaf;
+	mnode_t 	*out;
+	int			numNodes, numLeafs;
+
+	in = (dnode_t *)(fileBase + nodeLump->fileofs);
+	if (nodeLump->filelen % sizeof(dnode_t) ||
+		leafLump->filelen % sizeof(dleaf_t) ) {
+		Com_Error (ERR_DROP, "LoadMap: funny lump size in %s",worldData.name);
+	}
+	numNodes = nodeLump->filelen / sizeof(dnode_t);
+	numLeafs = leafLump->filelen / sizeof(dleaf_t);
+
+	out = (struct mnode_s *)Hunk_Alloc ( (numNodes + numLeafs) * sizeof(*out), h_low);	
+
+	worldData.nodes = out;
+	worldData.numnodes = numNodes + numLeafs;
+	worldData.numDecisionNodes = numNodes;
+
+	// load nodes
+	for ( i=0 ; i<numNodes; i++, in++, out++)
+	{
+		for (j=0 ; j<3 ; j++)
+		{
+			out->mins[j] = LittleLong (in->mins[j]);
+			out->maxs[j] = LittleLong (in->maxs[j]);
+		}
+	
+		p = LittleLong(in->planeNum);
+		out->plane = worldData.planes + p;
+
+		out->contents = CONTENTS_NODE;	// differentiate from leafs
+
+		for (j=0 ; j<2 ; j++)
+		{
+			p = LittleLong (in->children[j]);
+			if (p >= 0)
+				out->children[j] = worldData.nodes + p;
+			else
+				out->children[j] = worldData.nodes + numNodes + (-1 - p);
+		}
+	}
+	
+	// load leafs
+	inLeaf = (dleaf_t *)(fileBase + leafLump->fileofs);
+	for ( i=0 ; i<numLeafs ; i++, inLeaf++, out++)
+	{
+		for (j=0 ; j<3 ; j++)
+		{
+			out->mins[j] = LittleLong (inLeaf->mins[j]);
+			out->maxs[j] = LittleLong (inLeaf->maxs[j]);
+		}
+
+		out->cluster = LittleLong(inLeaf->cluster);
+		out->area = LittleLong(inLeaf->area);
+
+		if ( out->cluster >= worldData.numClusters ) {
+			worldData.numClusters = out->cluster + 1;
+		}
+
+		out->firstmarksurface = worldData.marksurfaces +
+			LittleLong(inLeaf->firstLeafSurface);
+		out->nummarksurfaces = LittleLong(inLeaf->numLeafSurfaces);
+	}	
+
+	// chain decendants
+	R_SetParent (worldData.nodes, NULL);
+}
+
+//=============================================================================
+
+/*
+=================
+R_LoadShaders
+=================
+*/
+static	void R_LoadShaders( lump_t *l, world_t &worldData ) {	
+	int		i, count;
+	dshader_t	*in, *out;
+	
+	in = (dshader_t *)(fileBase + l->fileofs);
+	if (l->filelen % sizeof(*in))
+		Com_Error (ERR_DROP, "LoadMap: funny lump size in %s",worldData.name);
+	count = l->filelen / sizeof(*in);
+	out = (dshader_t *)Hunk_Alloc ( count*sizeof(*out), h_low );
+
+	worldData.shaders = out;
+	worldData.numShaders = count;
+
+	Com_Memcpy( out, in, count*sizeof(*out) );
+
+	for ( i=0 ; i<count ; i++ ) {
+		out[i].surfaceFlags = LittleLong( out[i].surfaceFlags );
+		out[i].contentFlags = LittleLong( out[i].contentFlags );
+	}
+}
+
+
+/*
+=================
+R_LoadMarksurfaces
+=================
+*/
+static	void R_LoadMarksurfaces (lump_t *l, world_t &worldData)
+{	
+	int		i, j, count;
+	int		*in;
+	msurface_t **out;
+	
+	in = (int *)(fileBase + l->fileofs);
+	if (l->filelen % sizeof(*in))
+		Com_Error (ERR_DROP, "LoadMap: funny lump size in %s",worldData.name);
+	count = l->filelen / sizeof(*in);
+	out = (struct msurface_s **)Hunk_Alloc ( count*sizeof(*out), h_low);	
+
+	worldData.marksurfaces = out;
+	worldData.nummarksurfaces = count;
+
+	for ( i=0 ; i<count ; i++)
+	{
+		j = LittleLong(in[i]);
+		out[i] = worldData.surfaces + j;
+	}
+}
+
+
+/*
+=================
+R_LoadPlanes
+=================
+*/
+static	void R_LoadPlanes( lump_t *l, world_t &worldData ) {
+	int			i, j;
+	cplane_t	*out;
+	dplane_t 	*in;
+	int			count;
+	int			bits;
+	
+	in = (dplane_t *)(fileBase + l->fileofs);
+	if (l->filelen % sizeof(*in))
+		Com_Error (ERR_DROP, "LoadMap: funny lump size in %s",worldData.name);
+	count = l->filelen / sizeof(*in);
+	out = (struct cplane_s *)Hunk_Alloc ( count*2*sizeof(*out), h_low);	
+	
+	worldData.planes = out;
+	worldData.numplanes = count;
+
+	for ( i=0 ; i<count ; i++, in++, out++) {
+		bits = 0;
+		for (j=0 ; j<3 ; j++) {
+			out->normal[j] = LittleFloat (in->normal[j]);
+			if (out->normal[j] < 0) {
+				bits |= 1<<j;
+			}
+		}
+
+		out->dist = LittleFloat (in->dist);
+		out->type = PlaneTypeForNormal( out->normal );
+		out->signbits = bits;
+	}
+}
+
+/*
+=================
+R_LoadFogs
+
+=================
+*/
+static	void R_LoadFogs( lump_t *l, lump_t *brushesLump, lump_t *sidesLump, world_t &worldData, int index ) {
+	int			i;
+	fog_t		*out;
+	dfog_t		*fogs;
+	dbrush_t 	*brushes, *brush;
+	dbrushside_t	*sides;
+	int			count, brushesCount, sidesCount;
+	int			sideNum;
+	int			planeNum;
+	shader_t	*shader;
+	float		d;
+	int			firstSide=0;
+	int			lightmaps[MAXLIGHTMAPS] = { LIGHTMAP_NONE } ;
+
+	fogs = (dfog_t *)(fileBase + l->fileofs);
+	if (l->filelen % sizeof(*fogs)) {
+		Com_Error (ERR_DROP, "LoadMap: funny lump size in %s",worldData.name);
+	}
+	count = l->filelen / sizeof(*fogs);
+
+	// create fog strucutres for them
+	worldData.numfogs = count + 1;
+	worldData.fogs = (fog_t *)Hunk_Alloc ( worldData.numfogs*sizeof(*out), h_low);
+	worldData.globalFog = -1;
+	out = worldData.fogs + 1;
+
+	// Copy the global fog from the main world into the bsp instance
+	if(index)
+	{
+		if(tr.world && (tr.world->globalFog != -1))
+		{
+			// Use the nightvision fog slot
+			worldData.fogs[worldData.numfogs] = tr.world->fogs[tr.world->globalFog];
+			worldData.globalFog = worldData.numfogs;
+			worldData.numfogs++;
+		}
+	}
+
+	if ( !count ) {
+		return;
+	}
+
+	brushes = (dbrush_t *)(fileBase + brushesLump->fileofs);
+	if (brushesLump->filelen % sizeof(*brushes)) {
+		Com_Error (ERR_DROP, "LoadMap: funny lump size in %s",worldData.name);
+	}
+	brushesCount = brushesLump->filelen / sizeof(*brushes);
+
+	sides = (dbrushside_t *)(fileBase + sidesLump->fileofs);
+	if (sidesLump->filelen % sizeof(*sides)) {
+		Com_Error (ERR_DROP, "LoadMap: funny lump size in %s",worldData.name);
+	}
+	sidesCount = sidesLump->filelen / sizeof(*sides);
+
+	for ( i=0 ; i<count ; i++, fogs++) {
+		out->originalBrushNumber = LittleLong( fogs->brushNum );
+
+		if (out->originalBrushNumber == -1)
+		{
+			out->bounds[0][0] = out->bounds[0][1] = out->bounds[0][2] = MIN_WORLD_COORD;
+			out->bounds[1][0] = out->bounds[1][1] = out->bounds[1][2] = MAX_WORLD_COORD;
+			firstSide = -1;
+			worldData.globalFog = i+1;
+		}
+		else
+		{
+			if ( (unsigned)out->originalBrushNumber >= brushesCount ) {
+				Com_Error( ERR_DROP, "fog brushNumber out of range" );
+			}
+			brush = brushes + out->originalBrushNumber;
+
+			firstSide = LittleLong( brush->firstSide );
+
+				if ( (unsigned)firstSide > sidesCount - 6 ) {
+				Com_Error( ERR_DROP, "fog brush sideNumber out of range" );
+			}
+
+			// brushes are always sorted with the axial sides first
+			sideNum = firstSide + 0;
+			planeNum = LittleLong( sides[ sideNum ].planeNum );
+			out->bounds[0][0] = -worldData.planes[ planeNum ].dist;
+
+			sideNum = firstSide + 1;
+			planeNum = LittleLong( sides[ sideNum ].planeNum );
+			out->bounds[1][0] = worldData.planes[ planeNum ].dist;
+
+			sideNum = firstSide + 2;
+			planeNum = LittleLong( sides[ sideNum ].planeNum );
+			out->bounds[0][1] = -worldData.planes[ planeNum ].dist;
+
+			sideNum = firstSide + 3;
+			planeNum = LittleLong( sides[ sideNum ].planeNum );
+			out->bounds[1][1] = worldData.planes[ planeNum ].dist;
+
+			sideNum = firstSide + 4;
+			planeNum = LittleLong( sides[ sideNum ].planeNum );
+			out->bounds[0][2] = -worldData.planes[ planeNum ].dist;
+
+			sideNum = firstSide + 5;
+			planeNum = LittleLong( sides[ sideNum ].planeNum );
+			out->bounds[1][2] = worldData.planes[ planeNum ].dist;
+		}
+
+		// get information from the shader for fog parameters
+		shader = R_FindShader( fogs->shader, lightmaps, stylesDefault, qtrue );
+
+		if (!shader->fogParms)
+		{//bad shader!!
+			assert(shader->fogParms);
+			out->parms.color[0] = 1.0f;
+			out->parms.color[1] = 0.0f;
+			out->parms.color[2] = 0.0f;
+			out->parms.color[3] = 0.0f;
+			out->parms.depthForOpaque = 250.0f;
+		}
+		else
+		{
+			out->parms = *shader->fogParms;
+		}
+
+		out->colorInt = ColorBytes4 (	out->parms.color[0] * tr.identityLight, 
+										out->parms.color[1] * tr.identityLight, 
+										out->parms.color[2] * tr.identityLight, 1.0 );
+		d = out->parms.depthForOpaque < 1 ? 1 : out->parms.depthForOpaque;
+		out->tcScale = 1.0f / ( d * 8 );
+
+		// set the gradient vector
+		sideNum = LittleLong( fogs->visibleSide );
+
+		if ( sideNum == -1 ) {
+			//rww - we need to set this to qtrue for global fog as well
+			out->hasSurface = qtrue;
+		} else {
+			out->hasSurface = qtrue;
+			planeNum = LittleLong( sides[ firstSide + sideNum ].planeNum );
+			VectorSubtract( vec3_origin, worldData.planes[ planeNum ].normal, out->surface );
+			out->surface[3] = -worldData.planes[ planeNum ].dist;
+		}
+
+		out++;
+	}
+
+}
+
+
+/*
+================
+R_LoadLightGrid
+
+================
+*/
+void R_LoadLightGrid( lump_t *l, world_t &worldData ) {
+	int		i, j;
+	vec3_t	maxs;
+	world_t	*w;
+	float	*wMins, *wMaxs;
+
+	w = &worldData;
+
+	w->lightGridInverseSize[0] = 1.0 / w->lightGridSize[0];
+	w->lightGridInverseSize[1] = 1.0 / w->lightGridSize[1];
+	w->lightGridInverseSize[2] = 1.0 / w->lightGridSize[2];
+
+	wMins = w->bmodels[0].bounds[0];
+	wMaxs = w->bmodels[0].bounds[1];
+
+	for ( i = 0 ; i < 3 ; i++ ) {
+		w->lightGridOrigin[i] = w->lightGridSize[i] * ceil( wMins[i] / w->lightGridSize[i] );
+		maxs[i] = w->lightGridSize[i] * floor( wMaxs[i] / w->lightGridSize[i] );
+		w->lightGridBounds[i] = (maxs[i] - w->lightGridOrigin[i])/w->lightGridSize[i] + 1;
+	}
+
+	int numGridDataElements = l->filelen / sizeof(*w->lightGridData);
+
+	w->lightGridData = (mgrid_t *)Hunk_Alloc( l->filelen, h_low );
+	memcpy( w->lightGridData, (void *)(fileBase + l->fileofs), l->filelen );
+
+	// deal with overbright bits
+	for ( i = 0 ; i < numGridDataElements ; i++ ) 
+	{
+		for(j=0;j<MAXLIGHTMAPS;j++)
+		{
+			R_ColorShiftLightingBytes(w->lightGridData[i].ambientLight[j]);
+			R_ColorShiftLightingBytes(w->lightGridData[i].directLight[j]);
+		}
+	}
+}
+
+/*
+================
+R_LoadLightGridArray
+
+================
+*/
+void R_LoadLightGridArray( lump_t *l, world_t &worldData ) {
+	world_t	*w;
+
+	w = &worldData;
+
+	w->numGridArrayElements = w->lightGridBounds[0] * w->lightGridBounds[1] * w->lightGridBounds[2];
+
+	if ( l->filelen != w->numGridArrayElements * sizeof(*w->lightGridArray) ) {
+		Com_Printf (S_COLOR_YELLOW  "WARNING: light grid array mismatch\n" );
+		w->lightGridData = NULL;
+		return;
+	}
+
+	w->lightGridArray = (unsigned short *)Hunk_Alloc( l->filelen, h_low );
+	memcpy( w->lightGridArray, (void *)(fileBase + l->fileofs), l->filelen );
+}
+
+/*
+================
+R_LoadEntities
+================
+*/
+void R_LoadEntities( lump_t *l, world_t &worldData ) {
+	const char *p;
+	char *token, *s;
+	char keyname[MAX_TOKEN_CHARS];
+	char value[MAX_TOKEN_CHARS];
+	world_t	*w;
+	float ambient = 1;
+
+	w = &worldData;
+	w->lightGridSize[0] = 64;
+	w->lightGridSize[1] = 64;
+	w->lightGridSize[2] = 128;
+
+	VectorSet(tr.sunAmbient, 1, 1, 1);
+	tr.distanceCull = 6000;//DEFAULT_DISTANCE_CULL;
+
+	p = (char *)(fileBase + l->fileofs);
+
+	// store for reference by the cgame
+	w->entityString = (char *)Hunk_Alloc( l->filelen + 1, h_low );
+	strcpy( w->entityString, p );
+	w->entityParsePoint = w->entityString;
+
+	token = COM_ParseExt( &p, qtrue );
+	if (!*token || *token != '{') {
+		return;
+	}
+
+	// only parse the world spawn
+	while ( 1 ) {	
+		// parse key
+		token = COM_ParseExt( &p, qtrue );
+
+		if ( !*token || *token == '}' ) {
+			break;
+		}
+		Q_strncpyz(keyname, token, sizeof(keyname));
+
+		// parse value
+		token = COM_ParseExt( &p, qtrue );
+
+		if ( !*token || *token == '}' ) {
+			break;
+		}
+		Q_strncpyz(value, token, sizeof(value));
+
+		// check for remapping of shaders for vertex lighting
+		s = "vertexremapshader";
+		if (!Q_strncmp(keyname, s, strlen(s)) ) {
+			s = strchr(value, ';');
+			if (!s) {
+				Com_Printf (S_COLOR_YELLOW  "WARNING: no semi colon in vertexshaderremap '%s'\n", value );
+				break;
+			}
+			*s++ = 0;
+			if (r_vertexLight->integer) {
+				R_RemapShader(value, s, "0");
+			}
+			continue;
+		}
+		// check for remapping of shaders
+		s = "remapshader";
+		if (!Q_strncmp(keyname, s, strlen(s)) ) {
+			s = strchr(value, ';');
+			if (!s) {
+				Com_Printf (S_COLOR_YELLOW  "WARNING: no semi colon in shaderremap '%s'\n", value );
+				break;
+			}
+			*s++ = 0;
+			R_RemapShader(value, s, "0");
+			continue;
+		}
+ 		if (!Q_stricmp(keyname, "distanceCull")) {
+			sscanf(value, "%f", &tr.distanceCull );
+			continue;
+		}
+		// check for a different grid size
+		if (!Q_stricmp(keyname, "gridsize")) {
+			sscanf(value, "%f %f %f", &w->lightGridSize[0], &w->lightGridSize[1], &w->lightGridSize[2] );
+			continue;
+		}
+	// find the optional world ambient for arioche
+		if (!Q_stricmp(keyname, "_color")) {
+			sscanf(value, "%f %f %f", &tr.sunAmbient[0], &tr.sunAmbient[1], &tr.sunAmbient[2] );
+			continue;
+		}
+		if (!Q_stricmp(keyname, "ambient")) {
+			sscanf(value, "%f", &ambient);
+			continue;
+		}
+	}
+	//both default to 1 so no harm if not present.
+	VectorScale( tr.sunAmbient, ambient, tr.sunAmbient);
+}
+
+/*
+=================
+R_GetEntityToken
+=================
+*/
+qboolean R_GetEntityToken( char *buffer, int size ) {
+	const char	*s;
+
+	if (size == -1)
+	{ //force reset
+		s_worldData.entityParsePoint = s_worldData.entityString;
+		return qtrue;
+	}
+
+	s = COM_Parse( (const char **) &s_worldData.entityParsePoint );
+	Q_strncpyz( buffer, s, size );
+	if ( !s_worldData.entityParsePoint || !s[0] ) {
+		return qfalse;
+	} else {
+		return qtrue;
+	}
+}
+
+/*
+=================
+RE_LoadWorldMap
+
+Called directly from cgame
+=================
+*/
+void RE_LoadWorldMap_Actual( const char *name, world_t &worldData, int index )
+{
+	int			i;
+	dheader_t	*header;
+	byte		*buffer;
+	byte		*startMarker;
+
+	if ( tr.worldMapLoaded && !index ) {
+		Com_Error( ERR_DROP, "ERROR: attempted to redundantly load world map\n" );
+	}
+
+	if (!index)
+	{
+		skyboxportal = 0;
+
+		// set default sun direction to be used if it isn't
+		// overridden by a shader
+		tr.sunDirection[0] = 0.45f;
+		tr.sunDirection[1] = 0.3f;
+		tr.sunDirection[2] = 0.9f;
+
+		VectorNormalize( tr.sunDirection );
+
+		tr.worldMapLoaded = qtrue;
+
+		// clear tr.world so if the level fails to load, the next
+		// try will not look at the partially loaded version
+		tr.world = NULL;
+	}
+
+	// check for cached disk file from the server first...
+	//
+	extern void *gpvCachedMapDiskImage;
+	if (gpvCachedMapDiskImage)
+	{
+		buffer = (byte *)gpvCachedMapDiskImage;
+	}
+	else		
+	{
+		// still needs loading...
+		//
+		FS_ReadFile( name, (void **)&buffer );
+		if ( !buffer ) {
+			Com_Error (ERR_DROP, "RE_LoadWorldMap: %s not found", name);
+		}
+	}
+
+	Com_Memset( &worldData, 0, sizeof( worldData ) );
+	Q_strncpyz( worldData.name, name, sizeof( worldData.name ) );
+
+	Q_strncpyz( worldData.baseName, COM_SkipPath( worldData.name ), sizeof( worldData.name ) );
+	COM_StripExtension( worldData.baseName, worldData.baseName );
+
+	startMarker = (unsigned char *)Hunk_Alloc(0, h_low);
+	c_gridVerts = 0;
+
+	header = (dheader_t *)buffer;
+	fileBase = (byte *)header;
+
+	i = LittleLong (header->version);
+	if ( i != BSP_VERSION ) {
+		Com_Error (ERR_DROP, "RE_LoadWorldMap: %s has wrong version number (%i should be %i)", 
+			name, i, BSP_VERSION);
+	}
+
+	// swap all the lumps
+	for (i=0 ; i<sizeof(dheader_t)/4 ; i++) {
+		((int *)header)[i] = LittleLong ( ((int *)header)[i]);
+	}
+
+	// load into heap
+	R_LoadShaders( &header->lumps[LUMP_SHADERS], worldData );
+	R_LoadLightmaps( &header->lumps[LUMP_LIGHTMAPS], name, worldData );
+	R_LoadPlanes (&header->lumps[LUMP_PLANES], worldData);
+	R_LoadFogs( &header->lumps[LUMP_FOGS], &header->lumps[LUMP_BRUSHES], &header->lumps[LUMP_BRUSHSIDES], worldData, index );
+	R_LoadSurfaces( &header->lumps[LUMP_SURFACES], &header->lumps[LUMP_DRAWVERTS], &header->lumps[LUMP_DRAWINDEXES], worldData, index );
+	R_LoadMarksurfaces (&header->lumps[LUMP_LEAFSURFACES], worldData);
+	R_LoadNodesAndLeafs (&header->lumps[LUMP_NODES], &header->lumps[LUMP_LEAFS], worldData);
+	R_LoadSubmodels (&header->lumps[LUMP_MODELS], worldData, index);
+	R_LoadVisibility( &header->lumps[LUMP_VISIBILITY], worldData );
+
+	worldData.dataSize = (byte *)Hunk_Alloc(0, h_low) - startMarker;
+
+	if (!index)
+	{
+		R_LoadEntities( &header->lumps[LUMP_ENTITIES], worldData );
+		R_LoadLightGrid( &header->lumps[LUMP_LIGHTGRID], worldData );
+		R_LoadLightGridArray( &header->lumps[LUMP_LIGHTARRAY], worldData );
+
+		// only set tr.world now that we know the entire level has loaded properly
+		tr.world = &worldData;
+
+		if (com_RMG && com_RMG->integer)
+		{
+			R_RMGInit();
+		}
+	}
+
+	if (gpvCachedMapDiskImage)
+	{
+		Z_Free( gpvCachedMapDiskImage );
+				gpvCachedMapDiskImage = NULL;
+	}
+	else
+	{
+		FS_FreeFile( buffer );
+	}
+}
+
+
+// new wrapper used for convenience to tell z_malloc()-fail recovery code whether it's safe to dump the cached-bsp or not.
+//
+extern qboolean gbUsingCachedMapDataRightNow;
+void RE_LoadWorldMap( const char *name )
+{
+	gbUsingCachedMapDataRightNow = qtrue;	// !!!!!!!!!!!!
+
+		RE_LoadWorldMap_Actual( name, s_worldData, 0 );
+
+	gbUsingCachedMapDataRightNow = qfalse;	// !!!!!!!!!!!!
+}
diff --git a/codemp/renderer/tr_bsp_xbox.cpp b/codemp/renderer/tr_bsp_xbox.cpp
new file mode 100644
index 0000000..b51af9d
--- /dev/null
+++ b/codemp/renderer/tr_bsp_xbox.cpp
@@ -0,0 +1,1765 @@
+// tr_map.c
+
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+#include "tr_local.h"
+
+#include "../qcommon/cm_local.h"
+
+/*
+
+Loads and prepares a map file for scene rendering.
+
+A single entry point:
+
+void RE_LoadWorldMap( const char *name );
+
+*/
+
+static world_t		s_worldData;
+byte		*fileBase;
+int			c_subdivisions;
+int			c_gridVerts;
+
+void R_RMGInit(void);
+//===============================================================================
+
+// We use a special hack to prevent slight differences in channels
+// from exploding into big differences, as it causes lighting problems
+// later on. This is the maximum channel separation for which we
+// enable the hack.
+#define MAX_GREYSCALE_CHANNEL_DIFF 15
+
+static void R_ColorShiftLightingBytes16( const byte in[4], byte out[2] ) {
+	// What's the largest separation between the red, green, and blue
+	// channels?
+	int chanDiff = max(in[0],max(in[1],in[2])) -
+		min(in[0],min(in[1],in[2]));
+	if (chanDiff <= MAX_GREYSCALE_CHANNEL_DIFF)
+	{
+		// Ensure that all color channels compress to the same value
+		byte channelAvg = (in[0] + in[1] + in[2] + 1) / 3;
+		out[0] = channelAvg & 0xF0;
+		out[0] |= (channelAvg & 0xF0) >> 4;
+		out[1] = channelAvg & 0xF0;
+		out[1] |= (in[3] & 0xF0) >> 4;
+
+		if (channelAvg % 16 >= 8)
+		{
+			out[0] |= 0x10;
+			out[0] |= 0x01;
+			out[1] |= 0x10;
+		}
+		if (in[4] % 16 >= 8)
+		{
+			out[1] |= 0x01;
+		}
+		return;
+	}
+
+	// Normal case for vertex colors that are not "near" greyscale
+	out[0] = in[0] & 0xF0;
+	out[0] |= (in[1] & 0xF0) >> 4;
+	out[1] = in[2] & 0xF0;
+	out[1] |= (in[3] & 0xF0) >> 4;
+	
+	if(in[0] % 16 >= 8) {
+		out[0] |= 0x10;
+	}
+	if(in[1] % 16 >= 8) {
+		out[0] |= 0x1;
+	}
+	if(in[2] % 16 >= 8) {
+		out[1] |= 0x10;
+	}
+	if(in[3] % 16 >= 8) {
+		out[1] |= 0x1;
+	}
+}
+
+
+static void HSVtoRGB( float h, float s, float v, float rgb[3] )
+{
+	int i;
+	float f;
+	float p, q, t;
+
+	h *= 5;
+
+	i = floor( h );
+	f = h - i;
+
+	p = v * ( 1 - s );
+	q = v * ( 1 - s * f );
+	t = v * ( 1 - s * ( 1 - f ) );
+
+	switch ( i )
+	{
+	case 0:
+		rgb[0] = v;
+		rgb[1] = t;
+		rgb[2] = p;
+		break;
+	case 1:
+		rgb[0] = q;
+		rgb[1] = v;
+		rgb[2] = p;
+		break;
+	case 2:
+		rgb[0] = p;
+		rgb[1] = v;
+		rgb[2] = t;
+		break;
+	case 3:
+		rgb[0] = p;
+		rgb[1] = q;
+		rgb[2] = v;
+		break;
+	case 4:
+		rgb[0] = t;
+		rgb[1] = p;
+		rgb[2] = v;
+		break;
+	case 5:
+		rgb[0] = v;
+		rgb[1] = p;
+		rgb[2] = q;
+		break;
+	}
+}
+
+/*
+===============
+R_ColorShiftLightingBytes
+
+===============
+*/
+void R_ColorShiftLightingBytes( byte in[4], byte out[4] ) {
+	int		shift=0, r, g, b;
+
+	// should NOT do it if overbrightBits is 0
+	if (tr.overbrightBits)
+		shift = 1 - tr.overbrightBits;
+
+	if (!shift)
+	{
+		out[0] = in[0];
+		out[1] = in[1];
+		out[2] = in[2];
+		out[3] = in[3];
+		return;
+	}
+
+	// shift the data based on overbright range
+	r = in[0] << shift;
+	g = in[1] << shift;
+	b = in[2] << shift;
+	
+	// normalize by color instead of saturating to white
+	if ( ( r | g | b ) > 255 ) {
+		int		max;
+
+		max = r > g ? r : g;
+		max = max > b ? max : b;
+		r = r * 255 / max;
+		g = g * 255 / max;
+		b = b * 255 / max;
+	}
+
+	out[0] = r;
+	out[1] = g;
+	out[2] = b;
+	out[3] = in[3];
+}
+
+/*
+===============
+R_ColorShiftLightingBytes
+
+===============
+*/
+static	void R_ColorShiftLightingBytes( byte in[3]) 
+{
+	int		shift=0, r, g, b;
+
+	// should NOT do it if overbrightBits is 0
+	if (tr.overbrightBits)
+		shift = 1 - tr.overbrightBits;
+
+	if (!shift) {
+		return;	//no need if not overbright
+	}
+	// shift the data based on overbright range
+	r = in[0] << shift;
+	g = in[1] << shift;
+	b = in[2] << shift;
+	
+	// normalize by color instead of saturating to white
+	if ( ( r | g | b ) > 255 ) {
+		int		max;
+
+		max = r > g ? r : g;
+		max = max > b ? max : b;
+		r = r * 255 / max;
+		g = g * 255 / max;
+		b = b * 255 / max;
+	}
+
+	in[0] = r;
+	in[1] = g;
+	in[2] = b;
+}
+
+
+/*
+===============
+R_LoadLightmaps
+
+===============
+*/
+#define	LIGHTMAP_SIZE	128
+void R_LoadLightmaps( void *data, int len, const char *psMapName ) {
+	byte		*buf, *buf_p;
+	int			i;
+
+	if ( !len ) {
+		return;
+	}
+	buf = (byte *)data + sizeof(int);
+
+	tr.numLightmaps = 0;
+
+	// we are about to upload textures
+	R_SyncRenderThread();
+
+	// create all the lightmaps
+	int size = *(int*)data;
+	tr.numLightmaps = len / size;
+
+	byte* image = (byte*)Z_Malloc(size, TAG_BSP, qfalse, 32);
+
+	char sMapName[MAX_QPATH];
+	COM_StripExtension(psMapName,sMapName);	// will already by MAX_QPATH legal, so no length check
+
+	for ( i = 0 ; i < tr.numLightmaps ; i++ ) {
+		buf_p = buf + i * size;
+		memcpy(image, buf_p, size);
+
+		char lmapName[MAX_QPATH + 32];
+		Com_sprintf(lmapName, MAX_QPATH + 32, "*%s/lightmap%d",sMapName,i);
+		tr.lightmaps[i] = R_CreateImage( lmapName, image, 
+			LIGHTMAP_SIZE, LIGHTMAP_SIZE,
+			GL_DDS_RGB16_EXT,
+			qfalse, 0, GL_CLAMP);
+	}
+
+	Z_Free(image);
+}
+
+
+/*
+=================
+RE_SetWorldVisData
+
+This is called by the clipmodel subsystem so we can share the 1.8 megs of
+space in big maps...
+=================
+*/
+void RE_SetWorldVisData( SPARC<byte> *vis ) {
+	tr.externalVisData = vis;
+}
+
+
+/*
+=================
+R_LoadVisibility
+=================
+*/
+static	void R_LoadVisibility( void *data, int len ) {
+	int		length;
+	char    *buf;
+
+	length = ( s_worldData.numClusters + 63 ) & ~63;
+	s_worldData.novis = ( unsigned char *) Hunk_Alloc( length, h_low );
+	memset( s_worldData.novis, 0xff, length );
+
+	if ( !len ) {
+		s_worldData.vis = NULL;
+		return;
+	}
+	buf = (char*)data;
+
+	s_worldData.numClusters = ((int *)buf)[0];
+	s_worldData.clusterBytes = ((int *)buf)[1];
+
+	// CM_Load should have given us the vis data to share, so
+	// we don't need to allocate another copy
+	if ( tr.externalVisData ) {
+		s_worldData.vis = tr.externalVisData;
+	} else {
+		assert(0);
+	}
+}
+
+//===============================================================================
+
+qhandle_t R_GetShaderByNum(int shaderNum, world_t &worldData)
+{
+	qhandle_t	shader;
+
+	if ( (shaderNum < 0) || (shaderNum >= worldData.numShaders) ) 
+	{
+		Com_Printf( "Warning: Bad index for R_GetShaderByNum - %i", shaderNum );
+		return(0);
+	}
+	shader = RE_RegisterShader(worldData.shaders[ shaderNum ].shader);
+	return(shader);
+}
+
+/*
+===============
+ShaderForShaderNum
+===============
+*/
+static shader_t *ShaderForShaderNum( int shaderNum, const int *lightmapNum, const byte *lightmapStyles ) {
+	shader_t	*shader;
+	dshader_t	*dsh;
+
+	shaderNum = shaderNum;
+	if ( shaderNum < 0 || shaderNum >= s_worldData.numShaders ) {
+		Com_Error( ERR_DROP, "ShaderForShaderNum: bad num %i", shaderNum );
+	}
+	dsh = &s_worldData.shaders[ shaderNum ];
+
+	shader = R_FindShader( dsh->shader, lightmapNum, lightmapStyles, qtrue );
+
+	// if the shader had errors, just use default shader
+	if ( shader->defaultShader ) {
+		return tr.defaultShader;
+	}
+
+	return shader;
+}
+
+bool NeedVertexColors(shader_t *shader)
+{
+	int i;
+	shaderStage_t *stage;
+
+	for(i=0; i<shader->numUnfoggedPasses; i++) {
+		stage = &shader->stages[i];
+		switch(stage->rgbGen) {
+		case CGEN_EXACT_VERTEX:
+		case CGEN_VERTEX:
+		case CGEN_ONE_MINUS_VERTEX:
+			return true;
+		}
+		switch(stage->alphaGen) {
+		case AGEN_VERTEX:
+		case AGEN_ONE_MINUS_VERTEX:
+			return true;
+		}
+	}
+
+	return false;
+}
+
+int NumLightMaps(shader_t *shader)
+{
+	int count = 0;
+	int i;
+
+	for(i=0; i<MAXLIGHTMAPS; i++) {
+		if(shader->lightmapIndex[i] >= 0) {
+			count++;
+		} else {
+			return count;
+		}
+	}
+
+	return count;
+}
+
+int SurfaceFaceSize(int numVerts, int numLightMaps, bool needVertexColors,
+		int numIndexes)
+{
+	int sfaceSize = ( int ) &((srfSurfaceFace_t *)0)->srfPoints + 
+		4 /*sizeof srfPoints*/ + 
+		(numVerts * sizeof(unsigned short) *
+			(VERTEX_LM + numLightMaps * 2 + 
+			(int)needVertexColors * 4));	
+
+	// Add in tangent size
+	sfaceSize += sizeof(vec3_t) * numVerts;
+
+	//Indices stored in 8 bits now.
+	sfaceSize += numIndexes;
+
+	return sfaceSize;
+}
+
+
+void BuildDrawVertTangents( drawVert_t *verts, int *indexes, int numIndexes, int numVertexes ) 
+{
+	int i = 0;
+
+	for(i = 0; i < numVertexes; i++)
+	{
+		verts[i].tangent[0] = 0.0f;
+		verts[i].tangent[1] = 0.0f;
+		verts[i].tangent[2] = 0.0f;
+	}
+
+	for(i = 0; i < numIndexes; i += 3)
+	{
+		vec3_t vec1, vec2, du, dv, cp;
+		float st0[2], st1[2], st2[2];
+
+		Q_CastShort2FloatScale(&st0[0], &verts[indexes[i]].dvst[0], 1.f / DRAWVERT_ST_SCALE);
+		Q_CastShort2FloatScale(&st0[1], &verts[indexes[i]].dvst[1], 1.f / DRAWVERT_ST_SCALE);
+
+		Q_CastShort2FloatScale(&st1[0], &verts[indexes[i+1]].dvst[0], 1.f / DRAWVERT_ST_SCALE);
+		Q_CastShort2FloatScale(&st1[1], &verts[indexes[i+1]].dvst[1], 1.f / DRAWVERT_ST_SCALE);
+
+		Q_CastShort2FloatScale(&st2[0], &verts[indexes[i+2]].dvst[0], 1.f / DRAWVERT_ST_SCALE);
+		Q_CastShort2FloatScale(&st2[1], &verts[indexes[i+2]].dvst[1], 1.f / DRAWVERT_ST_SCALE);
+
+		vec1[0] = verts[indexes[i+1]].xyz[0] - verts[indexes[i]].xyz[0];
+		vec1[1] = st1[0] - st0[0];
+		vec1[2] = st1[1] - st0[1];
+
+		vec2[0] = verts[indexes[i+2]].xyz[0] - verts[indexes[i]].xyz[0];
+		vec2[1] = st2[0] - st0[0];
+		vec2[2] = st2[1] - st0[1];
+
+		CrossProduct(vec1, vec2, cp);
+
+		if(cp[0] == 0.0f)
+			cp[0] = 0.001f;
+
+		du[0] = -cp[1] / cp[0];
+		dv[0] = -cp[2] / cp[0];
+
+		vec1[0] = verts[indexes[i+1]].xyz[1] - verts[indexes[i]].xyz[1];
+
+		vec2[0] = verts[indexes[i+2]].xyz[1] - verts[indexes[i]].xyz[1];
+
+		CrossProduct(vec1, vec2, cp);
+
+		if(cp[0] == 0.0f)
+			cp[0] = 0.001f;
+
+		du[1] = -cp[1] / cp[0];
+		dv[1] = -cp[2] / cp[0];
+
+		vec1[0] = verts[indexes[i+1]].xyz[2] - verts[indexes[i]].xyz[2];
+
+		vec2[0] = verts[indexes[i+2]].xyz[2] - verts[indexes[i]].xyz[2];
+
+		CrossProduct(vec1, vec2, cp);
+
+		if(cp[0] == 0.0f)
+			cp[0] = 0.001f;
+
+		du[2] = -cp[1] / cp[0];
+		dv[2] = -cp[2] / cp[0];
+
+		verts[indexes[i]].tangent[0] += du[0];
+		verts[indexes[i]].tangent[1] += du[1];
+		verts[indexes[i]].tangent[2] += du[2];
+
+		verts[indexes[i+1]].tangent[0] += du[0];
+		verts[indexes[i+1]].tangent[1] += du[1];
+		verts[indexes[i+1]].tangent[2] += du[2];
+
+		verts[indexes[i+2]].tangent[0] += du[0];
+		verts[indexes[i+2]].tangent[1] += du[1];
+		verts[indexes[i+2]].tangent[2] += du[2];
+	}
+
+	for(i = 0; i < numVertexes; i++)
+	{
+		VectorNormalizeFast(verts[i].tangent);
+	}
+}
+
+
+void BuildMapVertTangents( mapVert_t *verts, vec3_t *tangents, short *indexes, int numIndexes, int numVertexes ) 
+{
+	int i = 0;
+
+	for(i = 0; i < numVertexes; i++)
+	{
+		tangents[i][0] = 0.0f;
+		tangents[i][1] = 0.0f;
+		tangents[i][2] = 0.0f;
+	}
+
+	for(i = 0; i < numIndexes; i += 3)
+	{
+		vec3_t vec1, vec2, du, dv, cp;
+
+		vec1[0] = verts[indexes[i+1]].xyz[0] - verts[indexes[i]].xyz[0];
+		vec1[1] = (verts[indexes[i+1]].st[0] * POINTS_ST_SCALE) - 
+			(verts[indexes[i]].st[0] * POINTS_ST_SCALE);
+		vec1[2] = (verts[indexes[i+1]].st[1] * POINTS_ST_SCALE) - 
+			(verts[indexes[i]].st[1] * POINTS_ST_SCALE);
+
+		vec2[0] = verts[indexes[i+2]].xyz[0] - verts[indexes[i]].xyz[0];
+		vec2[1] = (verts[indexes[i+2]].st[0] * POINTS_ST_SCALE) - 
+			(verts[indexes[i]].st[0] * POINTS_ST_SCALE);
+		vec2[2] = (verts[indexes[i+2]].st[1]* POINTS_ST_SCALE) - 
+			(verts[indexes[i]].st[1] * POINTS_ST_SCALE);
+
+		CrossProduct(vec1, vec2, cp);
+
+		if(cp[0] == 0.0f)
+			cp[0] = 0.001f;
+
+		du[0] = -cp[1] / cp[0];
+		dv[0] = -cp[2] / cp[0];
+
+		vec1[0] = verts[indexes[i+1]].xyz[1] - verts[indexes[i]].xyz[1];
+
+		vec2[0] = verts[indexes[i+2]].xyz[1] - verts[indexes[i]].xyz[1];
+
+		CrossProduct(vec1, vec2, cp);
+
+		if(cp[0] == 0.0f)
+			cp[0] = 0.001f;
+
+		du[1] = -cp[1] / cp[0];
+		dv[1] = -cp[2] / cp[0];
+
+		vec1[0] = verts[indexes[i+1]].xyz[2] - verts[indexes[i]].xyz[2];
+
+		vec2[0] = verts[indexes[i+2]].xyz[2] - verts[indexes[i]].xyz[2];
+
+		CrossProduct(vec1, vec2, cp);
+
+		if(cp[0] == 0.0f)
+			cp[0] = 0.001f;
+
+		du[2] = -cp[1] / cp[0];
+		dv[2] = -cp[2] / cp[0];
+
+		tangents[indexes[i]][0] += du[0];
+		tangents[indexes[i]][1] += du[1];
+		tangents[indexes[i]][2] += du[2];
+
+		tangents[indexes[i+1]][0] += du[0];
+		tangents[indexes[i+1]][1] += du[1];
+		tangents[indexes[i+1]][2] += du[2];
+
+		tangents[indexes[i+2]][0] += du[0];
+		tangents[indexes[i+2]][1] += du[1];
+		tangents[indexes[i+2]][2] += du[2];
+	}
+
+	for(i = 0; i < numVertexes; i++)
+	{
+		VectorNormalizeFast(tangents[i]);
+	}
+}
+
+/*
+===============
+ParseFace
+===============
+*/
+static void ParseFace( dface_t *ds, mapVert_t *verts, msurface_t *surf, short *indexes, byte *&pFaceDataBuffer) 
+{
+	int			i, j, k;
+	srfSurfaceFace_t	*cv;
+	int			numPoints, numIndexes;
+	int			lightmapNum[MAXLIGHTMAPS];
+	int			sfaceSize, ofsIndexes;
+	vec3_t		tangents[1000];
+
+	for(i=0;i<MAXLIGHTMAPS;i++)
+	{
+		lightmapNum[i] = (int)ds->lightmapNum[i] - 4;
+	}
+
+	// get fog volume
+	surf->fogIndex = ds->fogNum + 1;
+
+	// get shader value
+	surf->shader = ShaderForShaderNum( ds->shaderNum, lightmapNum, ds->lightmapStyles );
+	if ( r_singleShader->integer && !surf->shader->sky ) {
+		surf->shader = tr.defaultShader;
+	}
+
+	bool needVertexColors = NeedVertexColors(surf->shader); 
+	int numLightMaps = NumLightMaps(surf->shader);
+	assert(numLightMaps <= 0x7F);
+
+	numPoints = ds->verts & 0xFFF;
+	if (numPoints > MAX_FACE_POINTS) {
+		Com_Printf (S_COLOR_YELLOW  "WARNING: MAX_FACE_POINTS exceeded: %i\n", numPoints);
+	}
+
+	numIndexes = ds->indexes & 0xFFF;
+
+	// create the srfSurfaceFace_t
+	sfaceSize = SurfaceFaceSize(numPoints,
+			numLightMaps, needVertexColors, numIndexes);
+	ofsIndexes = sfaceSize - numIndexes;
+
+	cv = (srfSurfaceFace_t *) pFaceDataBuffer;//ri.Hunk_Alloc( sfaceSize );
+	pFaceDataBuffer += sfaceSize;	// :-)
+
+	cv->surfaceType = SF_FACE;
+	cv->numPoints = numPoints;
+	cv->numIndices = numIndexes;
+	cv->ofsIndices = ofsIndexes;
+	cv->srfPoints = (unsigned short *)(((byte*)cv) + ( int ) &((srfSurfaceFace_t *)0)->srfPoints + 4);
+	if(needVertexColors) {
+		cv->flags = 1 << 7;
+	} else {
+		cv->flags = 0;
+	}
+	cv->flags |= (numLightMaps & 0x7F);
+
+	//Make sure we don't overflow storage.
+	assert(numPoints < 256);
+	assert(numIndexes < 65536);
+	assert(ofsIndexes < 65536);
+
+	int nextSurfPoint = NEXT_SURFPOINT(cv->flags);
+	verts += ds->verts >> 12;
+	indexes += ds->indexes >> 12;
+
+	BuildMapVertTangents(verts, tangents, indexes, numIndexes, numPoints);
+
+	for ( i = 0 ; i < numPoints ; i++ ) {
+		for ( j = 0 ; j < 3 ; j++ ) {
+			*(cv->srfPoints + i * nextSurfPoint + j) = verts[i].xyz[j];
+		}
+		for ( j = 0; j < 3 ; j++ ) {
+			assert(tangents[i][j] >= -1 && tangents[i][j] <= 1);
+			*(cv->srfPoints + i * nextSurfPoint + 3 + j) = (short)(tangents[i][j] * 32767.0f);
+		}
+		for ( j = 0 ; j < 2 ; j++ ) {
+			*(cv->srfPoints + i * nextSurfPoint + 6 + j) = 
+				(short)(verts[i].st[j] * POINTS_ST_SCALE);
+
+			for(k=0;k<numLightMaps;k++)
+			{
+				*(cv->srfPoints + i * nextSurfPoint + VERTEX_LM+j+(k*2)) = 
+					verts[i].lightmap[k][j];
+			}
+		}
+		if(needVertexColors) {
+			for(k=0;k<MAXLIGHTMAPS;k++)
+			{
+				R_ColorShiftLightingBytes16(
+					verts[i].color[k],
+					(byte*)(cv->srfPoints + i * nextSurfPoint + 
+					VERTEX_COLOR(cv->flags) + k));
+			}
+		}
+	}
+
+	unsigned char *indexStorage = ((unsigned char*)cv) + cv->ofsIndices;
+	for ( i = 0 ; i < numIndexes ; i++ ) {
+		indexStorage[i] = indexes[ i ];
+	}
+
+	// take the plane information from the lightmap vector
+	for ( i = 0 ; i < 3 ; i++ ) {
+		cv->plane.normal[i] = (float)ds->lightmapVecs[i] / 32767.f;
+	}
+	vec3_t fVec;
+	fVec[0] = (float)((short)cv->srfPoints[0]);
+	fVec[1] = (float)((short)cv->srfPoints[1]);
+	fVec[2] = (float)((short)cv->srfPoints[2]);
+	cv->plane.dist = DotProduct( fVec, cv->plane.normal );
+	SetPlaneSignbits( &cv->plane );
+	cv->plane.type = PlaneTypeForNormal( cv->plane.normal );
+
+	surf->data = (surfaceType_t *)cv;
+}
+
+
+/*
+===============
+ParseMesh
+===============
+*/
+static void ParseMesh ( dpatch_t *ds, mapVert_t *verts, msurface_t *surf,
+					   drawVert_t* points, drawVert_t* ctrl, float* errorTable ) {
+	srfGridMesh_t	*grid;
+	int				i, j, k;
+	int				width, height, numPoints;
+	int				lightmapNum[MAXLIGHTMAPS];
+	vec3_t			bounds[2];
+	vec3_t			tmpVec;
+	static surfaceType_t	skipData = SF_SKIP;
+
+	for(i=0;i<MAXLIGHTMAPS;i++)
+	{
+		lightmapNum[i] = (int)ds->lightmapNum[i] - 4;
+	}
+
+	// get fog volume
+	surf->fogIndex = ds->fogNum + 1;
+
+	// get shader value
+	surf->shader = ShaderForShaderNum( ds->shaderNum, lightmapNum, ds->lightmapStyles );
+	if ( r_singleShader->integer && !surf->shader->sky ) {
+		surf->shader = tr.defaultShader;
+	}
+
+	// we may have a nodraw surface, because they might still need to
+	// be around for movement clipping
+	if ( s_worldData.shaders[ ds->shaderNum ].surfaceFlags & SURF_NODRAW ) {
+		surf->data = &skipData;
+		return;
+	}
+
+	width = ds->patchWidth;
+	height = ds->patchHeight;
+
+	verts += ds->verts >> 12;
+	numPoints = width * height;
+	for ( i = 0 ; i < numPoints ; i++ ) {
+		for ( j = 0 ; j < 3 ; j++ ) {
+			points[i].xyz[j] = (float)verts[i].xyz[j];
+			points[i].normal[j] = (float)verts[i].normal[j] / 32767.f;
+		}
+		for ( j = 0 ; j < 2 ; j++ ) {
+			// Sanity check that alternate fixed point representation
+			// is good enough
+			assert( verts[i].st[j] * GRID_DRAWVERT_ST_SCALE < 32767 &&
+					verts[i].st[j] * GRID_DRAWVERT_ST_SCALE >= -32768 );
+			points[i].dvst[j] = verts[i].st[j] * GRID_DRAWVERT_ST_SCALE;
+			for(k=0;k<MAXLIGHTMAPS;k++)
+			{
+				points[i].dvlightmap[k][j] = 
+					((float)verts[i].lightmap[k][j] / POINTS_LIGHT_SCALE) *
+					DRAWVERT_LIGHTMAP_SCALE;
+			}
+		}
+		for(k=0;k<MAXLIGHTMAPS;k++)
+		{
+			R_ColorShiftLightingBytes16(verts[i].color[k], 
+				points[i].dvcolor[k]);
+		}
+	}
+
+	// pre-tesseleate
+	grid = R_SubdividePatchToGrid( width, height, points, ctrl, errorTable );
+	surf->data = (surfaceType_t *)grid;
+
+	// copy the level of detail origin, which is the center
+	// of the group of all curves that must subdivide the same
+	// to avoid cracking
+	for ( i = 0 ; i < 3 ; i++ ) {
+		bounds[0][i] = ds->lightmapVecs[0][i];
+		bounds[1][i] = ds->lightmapVecs[1][i];
+	}
+	VectorAdd( bounds[0], bounds[1], bounds[1] );
+	VectorScale( bounds[1], 0.5f, grid->lodOrigin );
+	VectorSubtract( bounds[0], grid->lodOrigin, tmpVec );
+	grid->lodRadius = VectorLength( tmpVec );
+}
+
+/*
+===============
+ParseTriSurf
+===============
+*/
+static void ParseTriSurf( dtrisurf_t *ds, mapVert_t *verts, msurface_t *surf, short *indexes ) {
+	srfTriangles_t	*tri;
+	int				i, j, k;
+	int				numVerts, numIndexes;
+
+	// get fog volume
+	surf->fogIndex = ds->fogNum + 1;
+
+	// get shader
+	surf->shader = ShaderForShaderNum( ds->shaderNum, lightmapsVertex, ds->lightmapStyles );
+	if ( r_singleShader->integer && !surf->shader->sky ) {
+		surf->shader = tr.defaultShader;
+	}
+
+	numVerts = ds->verts & 0xFFF;
+	numIndexes = ds->indexes & 0xFFF;
+
+	tri = (srfTriangles_t *) Hunk_Alloc( sizeof( *tri ) + numVerts * sizeof( tri->verts[0] ) 
+		+ numIndexes * sizeof( tri->indexes[0] ), h_low );
+	tri->surfaceType = SF_TRIANGLES;
+	tri->numVerts = numVerts;
+	tri->numIndexes = numIndexes;
+	tri->verts = (drawVert_t *)(tri + 1);
+	tri->indexes = (int *)(tri->verts + tri->numVerts );
+
+	surf->data = (surfaceType_t *)tri;
+
+	// copy vertexes
+	verts += ds->verts >> 12;
+	ClearBounds( tri->bounds[0], tri->bounds[1] );
+	for ( i = 0 ; i < numVerts ; i++ ) {
+		for ( j = 0 ; j < 3 ; j++ ) {
+			tri->verts[i].xyz[j] = (float)verts[i].xyz[j];
+			tri->verts[i].normal[j] = (float)verts[i].normal[j] / 32767.f;
+		}
+		AddPointToBounds( tri->verts[i].xyz, tri->bounds[0], tri->bounds[1] );
+		for ( j = 0 ; j < 2 ; j++ ) {
+			// Sanity check that alternate fixed point representation
+			// is good enough
+			// MATT! - double check this!
+			assert( verts[i].st[j] * DRAWVERT_ST_SCALE <= 32767 &&
+					verts[i].st[j] * DRAWVERT_ST_SCALE >= -32768 );
+			tri->verts[i].dvst[j] = verts[i].st[j] * DRAWVERT_ST_SCALE;
+			for(k=0;k<MAXLIGHTMAPS;k++)
+			{
+				tri->verts[i].dvlightmap[k][j] = 
+					((float)verts[i].lightmap[k][j] / POINTS_LIGHT_SCALE) *
+					DRAWVERT_LIGHTMAP_SCALE;
+			}
+		}
+		for(k=0;k<MAXLIGHTMAPS;k++)
+		{
+			R_ColorShiftLightingBytes16(verts[i].color[k], 
+				tri->verts[i].dvcolor[k]);
+		}
+	}
+
+	// copy indexes
+	indexes += ds->indexes >> 12;
+	for ( i = 0 ; i < numIndexes ; i++ ) {
+		tri->indexes[i] = indexes[i];
+		if ( tri->indexes[i] < 0 || tri->indexes[i] >= numVerts ) {
+			Com_Error( ERR_DROP, "Bad index in triangle surface" );
+		}
+	}
+
+	// Build the tangent vectors
+	BuildDrawVertTangents(tri->verts, tri->indexes, numIndexes, numVerts);
+}
+
+
+/*
+===============
+ParseFlare
+===============
+*/
+static void ParseFlare( dflare_t *df, msurface_t *surf )
+{
+	srfFlare_t		*flare;
+	int i;
+
+	surf->fogIndex = df->fogNum + 1;
+
+	// get shader
+	surf->shader = ShaderForShaderNum( df->shaderNum, lightmapsVertex, stylesDefault );
+
+	flare = (srfFlare_t *) Hunk_Alloc( sizeof( *flare ), h_low );
+	flare->surfaceType = SF_FLARE;
+
+	for ( i = 0 ; i < 3 ; i++ ) {
+		flare->origin[i] = df->origin[i];
+		flare->color[i] = df->color[i];
+		flare->normal[i] = df->normal[i];
+	}
+
+	surf->data = (surfaceType_t *)flare;
+}
+
+
+void R_LoadFlares( void *surfaces, int surfacelen ) {
+	int count, i;
+	dflare_t	*in = NULL;
+	msurface_t  *out;
+
+	count = surfacelen / sizeof(*in);
+
+	for ( i = 0 ; i < count ; i++ ) {
+		in = (dflare_t *)surfaces + i;
+		out = s_worldData.surfaces + in->code;
+		ParseFlare( in, out );
+	}
+}
+
+
+/*
+===============
+R_LoadSurfaces
+===============
+*/
+void R_LoadSurfaces( int count ) {
+	s_worldData.surfaces = (struct msurface_s *) 
+		Hunk_Alloc ( count * sizeof(msurface_s), h_low );
+	s_worldData.numsurfaces = count;
+}
+
+
+/*
+===============
+R_LoadPatches
+===============
+*/
+void R_LoadPatches( void *verts, int vertlen, 
+					void *surfaces, int surfacelen ) {
+	dpatch_t	*in = NULL;
+	msurface_t	*out;
+	mapVert_t	*dv;
+	int			count;
+	int			i;
+
+	if (surfacelen == 0) {
+		return;
+	}
+
+	count = surfacelen / sizeof(*in);
+
+	dv = (mapVert_t *)(verts);
+	if (vertlen % sizeof(*dv))
+		Com_Error (ERR_DROP, "LoadMap: funny lump size in %s",s_worldData.name);
+
+	drawVert_t* points = (drawVert_t*)Z_Malloc(
+		MAX_PATCH_SIZE*MAX_PATCH_SIZE*sizeof(drawVert_t), 
+		TAG_TEMP_WORKSPACE, qfalse);
+	
+	drawVert_t*	ctrl = (drawVert_t*)Z_Malloc(
+		MAX_GRID_SIZE*MAX_GRID_SIZE*sizeof(drawVert_t), 
+		TAG_TEMP_WORKSPACE, qfalse);
+	
+	float* errorTable = (float*)Z_Malloc(
+		2*MAX_GRID_SIZE*sizeof(float), 
+		TAG_TEMP_WORKSPACE, qfalse);
+
+	for ( i = 0 ; i < count ; i++ ) {
+		in = (dpatch_t *)surfaces + i;
+		out = s_worldData.surfaces + in->code;
+		ParseMesh ( in, dv, out, points, ctrl, errorTable );
+	}
+
+	Z_Free(errorTable);
+	Z_Free(ctrl);
+	Z_Free(points);
+
+	Com_Printf( "...loaded %i meshes\n", count );
+}
+
+
+					/*
+===============
+R_LoadTriSurfs
+===============
+*/
+void R_LoadTriSurfs( void *indexdata, int indexlen, 
+					void *verts, int vertlen, 
+					void *surfaces, int surfacelen ) {
+	dtrisurf_t	*in = NULL;
+	msurface_t	*out;
+	mapVert_t	*dv;
+	short		*indexes;
+	int			count;
+	int			i;
+
+	if (surfacelen == 0) {
+		return;
+	}
+	
+	count = surfacelen / sizeof(*in);
+
+	dv = (mapVert_t *)(verts);
+	if (vertlen % sizeof(*dv))
+		Com_Error (ERR_DROP, "LoadMap: funny lump size in %s",s_worldData.name);
+
+	indexes = (short *)(indexdata);
+	if ( indexlen % sizeof(*indexes))
+		Com_Error (ERR_DROP, "LoadMap: funny lump size in %s",s_worldData.name);
+
+	for ( i = 0 ; i < count ; i++ ) {
+		in = (dtrisurf_t *)surfaces + i;
+		out = s_worldData.surfaces + in->code;
+		ParseTriSurf( in, dv, out, indexes );
+	}
+
+	Com_Printf( "...loaded %i trisurfs\n", count );
+}
+
+
+/*
+===============
+R_LoadFaces
+===============
+*/
+void R_LoadFaces( void *indexdata, int indexlen, 
+					void *verts, int vertlen, 
+					void *surfaces, int surfacelen ) {
+	dface_t		*in = NULL;
+	msurface_t	*out;
+	mapVert_t	*dv;
+	short		*indexes;
+	int			count;
+	int			i;
+
+	if (surfacelen == 0) {
+		return;
+	}
+	
+	count = surfacelen / sizeof(*in);
+
+	dv = (mapVert_t *)(verts);
+	if (vertlen % sizeof(*dv))
+		Com_Error (ERR_DROP, "LoadMap: funny lump size in %s",s_worldData.name);
+
+	indexes = (short *)(indexdata);
+	if ( indexlen % sizeof(*indexes))
+		Com_Error (ERR_DROP, "LoadMap: funny lump size in %s",s_worldData.name);
+
+	// new bit, the face code on our biggest map requires over 15,000 mallocs, which was no problem on the hunk,
+	//	bit hits the zone pretty bad (even the tagFree takes about 9 seconds for that many memblocks), 
+	//	so special-case pre-alloc enough space for this data (the patches etc can stay as they are)...
+	//
+	int nTimes = count / 100;
+	int nToGo = nTimes;
+	int iFaceDataSizeRequired = 0;
+	for ( i = 0 ; i < count ; i++) 
+	{ 
+		in = (dface_t *)surfaces + i;
+
+		int lightmapNum[MAXLIGHTMAPS];
+		for(int j=0; j<4; j++) {
+			lightmapNum[j] = (int)in->lightmapNum[j] - 4;
+		}
+		shader_t *shader = ShaderForShaderNum( in->shaderNum, lightmapNum, in->lightmapStyles );
+		bool needVertexColors = NeedVertexColors(shader); 
+		int numLightMaps = NumLightMaps(shader);
+		
+		int sfaceSize = SurfaceFaceSize(in->verts & 0xFFF,
+			numLightMaps, needVertexColors,
+			in->indexes & 0xFFF);
+		
+		iFaceDataSizeRequired += sfaceSize;
+		assert(sfaceSize < 100 * 1024);
+		if (--nToGo <= 0)
+		{
+			nToGo = nTimes;
+		}
+	}
+	in -= count;	// back it up, ready for loop-proper
+
+	// since this ptr is to hunk data, I can pass it in and have it advanced without worrying about losing
+	//	the original alloc ptr...
+	//
+	byte *orgFaceData;
+	byte *pFaceDataBuffer	= (byte *)Hunk_Alloc( iFaceDataSizeRequired, h_low );
+	orgFaceData = pFaceDataBuffer;
+
+	// now do regular loop...
+	//
+	for ( i = 0 ; i < count ; i++ ) {
+		in = (dface_t *)surfaces + i;
+		out = s_worldData.surfaces + in->code;
+		ParseFace( in, dv, out, indexes, pFaceDataBuffer );
+		if (--nToGo <= 0)
+		{
+			nToGo = nTimes;
+		}
+	}
+
+	Com_Printf( "...loaded %d faces\n", count );
+}
+
+
+/*
+=================
+R_LoadSubmodels
+=================
+*/
+static	void R_LoadSubmodels( void *data, int len ) {
+	dmodel_t	*in;
+	bmodel_t	*out;
+	int			i, j, count;
+
+	in = (dmodel_t *)(data);
+	if (len % sizeof(*in))
+		Com_Error (ERR_DROP, "LoadMap: funny lump size in %s",s_worldData.name);
+	count = len / sizeof(*in);
+
+	s_worldData.bmodels = out = (bmodel_t *) Hunk_Alloc( count * sizeof(*out), h_low );
+
+	for ( i=0 ; i<count ; i++, in++, out++ ) {
+		model_t *model;
+
+		model = R_AllocModel();
+
+		assert( model != NULL );			// this should never happen
+
+		model->type = MOD_BRUSH;
+		model->bmodel = out;
+		Com_sprintf( model->name, sizeof( model->name ), "*%d", i );
+
+		for (j=0 ; j<3 ; j++) {
+			out->bounds[0][j] = in->mins[j];
+			out->bounds[1][j] = in->maxs[j];
+		}
+
+		RE_InsertModelIntoHash(model->name, model);
+
+		out->firstSurface = s_worldData.surfaces + in->firstSurface;
+		out->numSurfaces = in->numSurfaces;
+	}
+}
+
+//==================================================================
+
+/*
+=================
+R_SetParent
+=================
+*/
+static	void R_SetParent (mnode_t *node, mnode_t *parent)
+{
+	node->parent = parent;
+	if (node->contents != -1)
+		return;
+	R_SetParent (node->children[0], node);
+	R_SetParent (node->children[1], node);
+}
+
+/*
+=================
+R_LoadNodesAndLeafs
+=================
+*/
+static void R_LoadNodesAndLeafs (void *nodes, int nodelen, void *leafs, int leaflen) {
+	int			i, j, p;
+	dnode_t		*in;
+	dleaf_t		*inLeaf;
+	mnode_t 	*outNode;
+	mleaf_s 	*outLeaf;
+	int			numNodes, numLeafs;
+
+	in = (dnode_t *)(nodes);
+	if (nodelen % sizeof(dnode_t) ||
+		leaflen % sizeof(dleaf_t) ) {
+		Com_Error (ERR_DROP, "LoadMap: funny lump size in %s",s_worldData.name);
+	}
+	numNodes = nodelen / sizeof(dnode_t);
+	numLeafs = leaflen / sizeof(dleaf_t);
+
+	outNode = (struct mnode_s *) Hunk_Alloc ( (numNodes) * sizeof(*outNode), h_low );	
+	outLeaf = (struct mleaf_s *) Hunk_Alloc ( (numLeafs) * sizeof(*outLeaf), h_low );	
+
+	s_worldData.nodes = outNode;
+	s_worldData.leafs = outLeaf;
+	s_worldData.numnodes = numNodes;
+	s_worldData.numleafs = numLeafs;
+
+	// load nodes
+	for ( i=0 ; i<numNodes; i++, in++, outNode++)
+	{
+		for (j=0 ; j<3 ; j++)
+		{
+			outNode->mins[j] = in->mins[j];
+			outNode->maxs[j] = in->maxs[j];
+		}
+	
+		outNode->planeNum = in->planeNum;
+		outNode->contents = CONTENTS_NODE;	// differentiate from leafs
+
+		for (j=0 ; j<2 ; j++)
+		{
+			p = in->children[j];
+			if (p >= 0) {
+				if(p < numNodes) {
+					outNode->children[j] = s_worldData.nodes + p;
+				} else {
+					outNode->children[j] = (mnode_s*)
+						(s_worldData.leafs + (p - numNodes));
+				}
+			} else {
+				if(numNodes + (-1 - p) < numNodes) {
+					outNode->children[j] = s_worldData.nodes + numNodes + (-1 - p);
+				} else {
+					outNode->children[j] = (mnode_s*)
+						(s_worldData.leafs + (-1 - p));
+				}
+			}
+		}
+	}
+	
+	// load leafs
+	inLeaf = (dleaf_t *)(leafs);
+	for ( i=0 ; i<numLeafs ; i++, inLeaf++, outLeaf++)
+	{
+		for (j=0 ; j<3 ; j++)
+		{
+			outLeaf->mins[j] = inLeaf->mins[j];
+			outLeaf->maxs[j] = inLeaf->maxs[j];
+		}
+
+		outLeaf->cluster = inLeaf->cluster;
+		outLeaf->area = inLeaf->area;
+
+		if ( outLeaf->cluster >= s_worldData.numClusters ) {
+			s_worldData.numClusters = outLeaf->cluster + 1;
+		}
+
+		outLeaf->firstMarkSurfNum = inLeaf->firstLeafSurface;
+		outLeaf->nummarksurfaces = inLeaf->numLeafSurfaces;
+	}	
+
+	// chain decendants
+	R_SetParent (s_worldData.nodes, NULL);
+}
+
+//=============================================================================
+
+/*
+=================
+R_LoadShaders
+=================
+*/
+void R_LoadShaders( void *data, int len) {	
+	dshader_t	*in, *out;
+	int			i, count;
+
+	in = (dshader_t *)(data);
+	if (len % sizeof(*in)) {
+		Com_Error (ERR_DROP, "CMod_LoadShaders: funny lump size");
+	}
+	count = len / sizeof(*in);
+
+	if (count < 1) {
+		Com_Error (ERR_DROP, "Map with no shaders");
+	}
+	out = (dshader_t *)Hunk_Alloc( count*sizeof(*out), h_low);
+
+	s_worldData.shaders = out;
+	s_worldData.numShaders = count;
+
+	Com_Memcpy( out, in, count*sizeof(*out) );
+
+	for ( i = 0; i < count; i++, in++, out++ ) 
+	{
+//		Q_strncpyz(out->shader, in->shader, MAX_QPATH);
+		out->contentFlags = in->contentFlags;
+		out->surfaceFlags = in->surfaceFlags;
+	}
+}
+
+/*
+=================
+R_LoadMarksurfaces
+=================
+*/
+static	void R_LoadMarksurfaces (void *data, int len)
+{	
+	int		i, count;
+	int		*in;
+	msurface_t **out;
+	
+	in = (int *)(data);
+	if (len % sizeof(*in))
+		Com_Error (ERR_DROP, "LoadMap: funny lump size in %s",s_worldData.name);
+	count = len / sizeof(*in);
+	out = (struct msurface_s **) Hunk_Alloc ( count*sizeof(*out), h_low );	
+
+	s_worldData.marksurfaces = out;
+	s_worldData.nummarksurfaces = count;
+
+	for ( i=0 ; i<count ; i++)
+	{
+		if(in[i] > s_worldData.numsurfaces)
+			assert(0);
+
+		out[i] = s_worldData.surfaces + in[i];
+
+		if (out[i]->shader && out[i]->shader->sort == SS_PORTAL)
+		{
+			s_worldData.portalPresent = qtrue;
+		}
+	}
+}
+
+/*
+=================
+R_LoadPlanes
+=================
+*/
+static void R_LoadPlanes( void *data, int len ) {
+	int			i, j;
+	cplane_t	*out;
+	dplane_t 	*in;
+	int			count;
+	int			bits;
+
+	in = (dplane_t *)(data);
+	if (len % sizeof(*in))
+		Com_Error (ERR_DROP, "LoadMap: funny lump size");
+	count = len / sizeof(*in);
+
+	if (count < 1)
+		Com_Error (ERR_DROP, "Map with no planes");
+
+	out = (struct cplane_s *) Hunk_Alloc( count * 2 * sizeof( *out ), h_low);
+
+	s_worldData.planes = out;
+	s_worldData.numplanes = count;
+
+	for ( i=0 ; i<count ; i++, in++, out++)
+	{
+		bits = 0;
+		for (j=0 ; j<3 ; j++)
+		{
+			out->normal[j] = in->normal[j];
+			if (out->normal[j] < 0)
+				bits |= 1<<j;
+		}
+
+		out->dist = in->dist;
+		out->type = PlaneTypeForNormal( out->normal );
+		out->signbits = bits;
+	}
+}
+
+/*
+=================
+R_LoadFogs
+
+=================
+*/
+static void R_LoadFogs( void *fogdata, int foglen,
+					   void *brushdata, int brushlen,
+					   void *sidedata, int sidelen ) {
+	int			i;
+	fog_t		*out;
+	dfog_t		*fogs;
+	dbrush_t 	*brushes, *brush;
+	dbrushside_t	*sides;
+	int			count, brushesCount, sidesCount;
+	int			sideNum;
+	int			planeNum;
+	shader_t	*shader;
+	float		d;
+	int			firstSide=0;
+	int			lightmaps[MAXLIGHTMAPS] = { LIGHTMAP_NONE } ;
+
+	fogs = (dfog_t *)(fogdata);
+	if (foglen % sizeof(*fogs)) {
+		Com_Error (ERR_DROP, "LoadMap: funny lump size in %s",s_worldData.name);
+	}
+	count = foglen / sizeof(*fogs);
+
+	// create fog structres for them
+	// NOTE: we allocate memory for an extra one so that the LA goggles can turn on their own fog
+	s_worldData.numfogs = count + 1;
+	s_worldData.fogs = (fog_t *)Hunk_Alloc (( s_worldData.numfogs + 1)*sizeof(*out), h_low );
+	s_worldData.globalFog = -1;
+	out = s_worldData.fogs + 1;
+
+	if ( !count ) {
+		return;
+	}
+
+	brushes = (dbrush_t *)(brushdata);
+	if (brushlen % sizeof(*brushes)) {
+		Com_Error (ERR_DROP, "LoadMap: funny lump size in %s",s_worldData.name);
+	}
+	brushesCount = brushlen / sizeof(*brushes);
+
+	sides = (dbrushside_t *)(sidedata);
+	if (sidelen % sizeof(*sides)) {
+		Com_Error (ERR_DROP, "LoadMap: funny lump size in %s",s_worldData.name);
+	}
+	sidesCount = sidelen / sizeof(*sides);
+
+	for ( i=0 ; i<count ; i++, fogs++) {
+		out->originalBrushNumber = fogs->brushNum;
+		if (out->originalBrushNumber == -1)
+		{
+			out->bounds[0][0] = out->bounds[0][1] = out->bounds[0][2] = MIN_WORLD_COORD;
+			out->bounds[1][0] = out->bounds[1][1] = out->bounds[1][2] = MAX_WORLD_COORD;
+			s_worldData.globalFog = i+1;
+		}
+		else
+		{
+			if ( (unsigned)out->originalBrushNumber >= brushesCount ) {
+				Com_Error( ERR_DROP, "fog brushNumber out of range" );
+			}
+			brush = brushes + out->originalBrushNumber;
+			
+			firstSide = brush->firstSide;
+			
+			if ( (unsigned)firstSide > sidesCount - 6 ) {
+				Com_Error( ERR_DROP, "fog brush sideNumber out of range" );
+			}
+			
+			// brushes are always sorted with the axial sides first
+			sideNum = firstSide + 0;
+			planeNum = sides[ sideNum ].planeNum;
+			out->bounds[0][0] = -s_worldData.planes[ planeNum ].dist;
+			
+			sideNum = firstSide + 1;
+			planeNum = sides[ sideNum ].planeNum;
+			out->bounds[1][0] = s_worldData.planes[ planeNum ].dist;
+			
+			sideNum = firstSide + 2;
+			planeNum = sides[ sideNum ].planeNum;
+			out->bounds[0][1] = -s_worldData.planes[ planeNum ].dist;
+			
+			sideNum = firstSide + 3;
+			planeNum = sides[ sideNum ].planeNum;
+			out->bounds[1][1] = s_worldData.planes[ planeNum ].dist;
+			
+			sideNum = firstSide + 4;
+			planeNum = sides[ sideNum ].planeNum;
+			out->bounds[0][2] = -s_worldData.planes[ planeNum ].dist;
+			
+			sideNum = firstSide + 5;
+			planeNum = sides[ sideNum ].planeNum;
+			out->bounds[1][2] = s_worldData.planes[ planeNum ].dist;
+		}
+		
+		// get information from the shader for fog parameters
+		shader = R_FindShader( fogs->shader, lightmaps, stylesDefault, qtrue );
+		
+		if (!shader->fogParms)
+		{//bad shader!!
+			assert(shader->fogParms);
+			out->parms.color[0] = 1.0f;
+			out->parms.color[1] = 0.0f;
+			out->parms.color[2] = 0.0f;
+			out->parms.color[3] = 0.0f;
+			out->parms.depthForOpaque = 250.0f;
+		}
+		else
+		{
+			out->parms = *shader->fogParms;
+		}
+
+		out->colorInt = ColorBytes4 ( out->parms.color[0] * tr.identityLight, 
+									  out->parms.color[1] * tr.identityLight, 
+									  out->parms.color[2] * tr.identityLight, 1.0 );
+		
+		d = out->parms.depthForOpaque < 1 ? 1 : out->parms.depthForOpaque;
+		out->tcScale = 1.0 / ( d * 8 );
+		
+		// set the gradient vector
+		sideNum = fogs->visibleSide;
+		
+		if ( sideNum == -1 ) {
+			out->hasSurface = qfalse;
+		} else {
+			out->hasSurface = qtrue;
+			planeNum = sides[ firstSide + sideNum ].planeNum;
+			VectorSubtract( vec3_origin, s_worldData.planes[ planeNum ].normal, out->surface );
+			out->surface[3] = -s_worldData.planes[ planeNum ].dist;
+		}
+		
+		out++;
+	}
+
+	// Initialise the last fog so we can use it with the LA Goggles
+	// NOTE: We are might appear to be off the end of the array, but we allocated an extra memory slot above but [purposely] didn't 
+	//	increment the total world numFogs to match our array size
+	VectorSet(out->bounds[0], MIN_WORLD_COORD, MIN_WORLD_COORD, MIN_WORLD_COORD);
+	VectorSet(out->bounds[1], MAX_WORLD_COORD, MAX_WORLD_COORD, MAX_WORLD_COORD);
+	out->originalBrushNumber = -1;
+	out->parms.color[0] = 0.0f;
+	out->parms.color[1] = 0.0f;
+	out->parms.color[2] = 0.0f;
+	out->parms.color[3] = 0.0f;
+	out->parms.depthForOpaque = 0.0f;
+	out->colorInt = 0x00000000;
+	out->tcScale = 0.0f;
+	out->hasSurface = false;
+}
+
+/*
+================
+R_LoadLightGrid
+
+================
+*/
+void R_LoadLightGrid( void *data, int len ) {
+	vec3_t	maxs;
+	world_t	*w;
+	int		i;
+	float	*wMins, *wMaxs;
+
+	w = &s_worldData;
+
+	w->lightGridInverseSize[0] = 1.0 / w->lightGridSize[0];
+	w->lightGridInverseSize[1] = 1.0 / w->lightGridSize[1];
+	w->lightGridInverseSize[2] = 1.0 / w->lightGridSize[2];
+
+	wMins = w->bmodels[0].bounds[0];
+	wMaxs = w->bmodels[0].bounds[1];
+
+	for ( i = 0 ; i < 3 ; i++ ) {
+		w->lightGridOrigin[i] = w->lightGridSize[i] * ceil( wMins[i] / w->lightGridSize[i] );
+		maxs[i] = w->lightGridSize[i] * floor( wMaxs[i] / w->lightGridSize[i] );
+		w->lightGridBounds[i] = (maxs[i] - w->lightGridOrigin[i])/w->lightGridSize[i] + 1;
+	}
+
+	w->lightGridData = (mgrid_t *)Hunk_Alloc( len, h_low );
+	memcpy( w->lightGridData, data, len );
+}
+
+/*
+================
+R_LoadLightGridArray
+
+================
+*/
+void R_LoadLightGridArray( void *data, int len ) {
+	world_t	*w;
+
+	w = &s_worldData;
+
+	w->numGridArrayElements = w->lightGridBounds[0] * w->lightGridBounds[1] * w->lightGridBounds[2];
+
+	if ( len != w->numGridArrayElements * sizeof(*w->lightGridArray) ) {
+		if (len>0)//don't warn if not even lit
+			Com_Printf( "WARNING: light grid array mismatch\n" );
+		w->lightGridData = NULL;
+		return;
+	}
+
+	w->lightGridArray = (unsigned short *)Hunk_Alloc( len, h_low );
+	memcpy( w->lightGridArray, data, len );
+}
+
+/*
+================
+R_LoadEntities
+================
+*/
+void R_LoadEntities( void *data, int len ) {
+	const char *p, *token;
+	char keyname[MAX_TOKEN_CHARS];
+	char value[MAX_TOKEN_CHARS];
+	world_t	*w;
+
+	w = &s_worldData;
+	w->lightGridSize[0] = 64;
+	w->lightGridSize[1] = 64;
+	w->lightGridSize[2] = 128;
+
+	VectorSet(tr.sunAmbient, 1, 1, 1);
+	tr.distanceCull = 6000;//DEFAULT_DISTANCE_CULL;
+
+	p = (char *)(data);
+
+	// store for reference by the cgame
+	w->entityString = (char *)Hunk_Alloc( len + 1, h_low );
+	strcpy( w->entityString, p );
+	w->entityParsePoint = w->entityString;
+
+	token = COM_ParseExt( &p, qtrue );
+	if (!*token || *token != '{') {
+		return;
+	}
+
+	// only parse the world spawn
+	while ( 1 ) {	
+		// parse key
+		token = COM_ParseExt( &p, qtrue );
+
+		if ( !*token || *token == '}' ) {
+			break;
+		}
+		Q_strncpyz(keyname, token, sizeof(keyname));
+
+		// parse value
+		token = COM_ParseExt( &p, qtrue );
+
+		if ( !*token || *token == '}' ) {
+			break;
+		}
+		Q_strncpyz(value, token, sizeof(value));
+
+		if (!Q_stricmp(keyname, "distanceCull")) {
+			sscanf(value, "%f", &tr.distanceCull );
+			continue;
+		}
+
+		// check for a different grid size
+		if (!Q_stricmp(keyname, "gridsize")) {
+			sscanf(value, "%f %f %f", &w->lightGridSize[0], &w->lightGridSize[1], &w->lightGridSize[2] );
+			continue;
+		}
+
+		// find the optional world ambient for arioche
+		if (!Q_stricmp(keyname, "_color")) {
+			sscanf(value, "%f %f %f", &tr.sunAmbient[0], &tr.sunAmbient[1], &tr.sunAmbient[2] );
+			continue;
+		}
+	}
+}
+
+/*
+=================
+R_GetEntityToken
+=================
+*/
+qboolean R_GetEntityToken( char *buffer, int size ) {
+	const char	*s;
+
+	if (size == -1)
+	{ //force reset
+		s_worldData.entityParsePoint = s_worldData.entityString;
+		return qtrue;
+	}
+
+	s = COM_Parse( (const char **) &s_worldData.entityParsePoint );
+	Q_strncpyz( buffer, s, size );
+	if ( !s_worldData.entityParsePoint || !s[0] ) {
+		return qfalse;
+	} else {
+		return qtrue;
+	}
+}
+
+
+/*
+=================
+RE_LoadWorldMap
+
+Called directly from cgame
+=================
+*/
+void RE_LoadWorldMap_Actual( const char *name, world_t &worldData, int index ) {
+	char		stripName[MAX_QPATH];
+	Lump outputLumps[3];
+
+	if ( tr.worldMapLoaded ) {
+		Com_Error( ERR_DROP, "ERROR: attempted to redundantly load world map\n" );
+	}
+
+	skyboxportal = 0;
+
+	// set default sun direction to be used if it isn't
+	// overridden by a shader
+	tr.sunDirection[0] = 0.45f;
+	tr.sunDirection[1] = 0.3f;
+	tr.sunDirection[2] = 0.9f;
+
+	Cvar_SetValue( "r_sundir_x", tr.sunDirection[0] );
+	Cvar_SetValue( "r_sundir_y", tr.sunDirection[1] );
+	Cvar_SetValue( "r_sundir_z", tr.sunDirection[2] );
+
+	VectorNormalize( tr.sunDirection );
+
+	tr.worldMapLoaded = qtrue;
+
+	// clear tr.world so if the level fails to load, the next
+	// try will not look at the partially loaded version
+	tr.world = NULL;
+
+	memset( &s_worldData, 0, sizeof( s_worldData ) );
+	Q_strncpyz( s_worldData.name, name, sizeof( s_worldData.name ) );
+
+	Q_strncpyz( s_worldData.baseName, COM_SkipPath( s_worldData.name ), sizeof( s_worldData.name ) );
+	COM_StripExtension( s_worldData.baseName, s_worldData.baseName );
+
+	COM_StripExtension(name, stripName);
+	
+	c_gridVerts = 0;
+
+	// load into heap
+	outputLumps[0].load(stripName, "shaders");
+	R_LoadShaders(outputLumps[0].data, outputLumps[0].len);
+
+	outputLumps[0].load(stripName, "lightmaps");
+	R_LoadLightmaps(outputLumps[0].data, outputLumps[0].len, name);
+
+	outputLumps[0].load(stripName, "planes");
+	R_LoadPlanes(outputLumps[0].data, outputLumps[0].len);
+
+	outputLumps[0].load(stripName, "fogs");
+	outputLumps[1].load(stripName, "brushes");
+	outputLumps[2].load(stripName, "brushsides");
+	R_LoadFogs( outputLumps[0].data, outputLumps[0].len,
+		outputLumps[1].data, outputLumps[1].len,
+		outputLumps[2].data, outputLumps[2].len );
+	outputLumps[2].clear();
+	outputLumps[1].clear();
+
+	Lump misc;
+	misc.load(stripName, "misc");
+		
+	int num_surfs = *(int*)misc.data;
+	misc.clear();
+
+	R_LoadSurfaces(num_surfs);
+		
+	Lump verts;
+	verts.load(stripName, "verts");
+
+	Lump patches;
+	patches.load(stripName, "patches");
+	R_LoadPatches(verts.data, verts.len, patches.data, patches.len);
+	patches.clear();
+
+	Lump indexes;
+	indexes.load(stripName, "indexes");
+
+	Lump trisurfs;
+	trisurfs.load(stripName, "trisurfs");
+	R_LoadTriSurfs(indexes.data, indexes.len, verts.data, verts.len, trisurfs.data, trisurfs.len);
+	trisurfs.clear();
+	
+	Lump faces;
+	faces.load(stripName, "faces");
+	R_LoadFaces(indexes.data, indexes.len, verts.data, verts.len, faces.data, faces.len);
+
+	Lump flares;
+	flares.load(stripName, "flares");
+	R_LoadFlares(flares.data, flares.len);
+
+	outputLumps[0].load(stripName, "leafsurfaces");
+	R_LoadMarksurfaces (outputLumps[0].data, outputLumps[0].len);
+
+	outputLumps[0].load(stripName, "nodes");
+	outputLumps[1].load(stripName, "leafs");
+	R_LoadNodesAndLeafs (outputLumps[0].data, outputLumps[0].len,
+		outputLumps[1].data, outputLumps[1].len);
+	outputLumps[1].clear();
+	
+	outputLumps[0].load(stripName, "models");
+	R_LoadSubmodels (outputLumps[0].data, outputLumps[0].len);
+
+	outputLumps[0].load(stripName, "visibility");
+	R_LoadVisibility(outputLumps[0].data, outputLumps[0].len);
+
+	outputLumps[0].load(stripName, "entities");
+	R_LoadEntities( outputLumps[0].data, outputLumps[0].len );
+
+	outputLumps[0].load(stripName, "lightgrid");
+	R_LoadLightGrid( outputLumps[0].data, outputLumps[0].len );
+
+	outputLumps[0].load(stripName, "lightarray");
+	R_LoadLightGridArray( outputLumps[0].data, outputLumps[0].len );
+
+	// only set tr.world now that we know the entire level has loaded properly
+	tr.world = &s_worldData;
+
+	// Load the light parms for this level
+	R_LoadLevelLightParms();
+	R_GetLightParmsForLevel();
+}
+
+
+// new wrapper used for convenience to tell z_malloc()-fail recovery code whether it's safe to dump the cached-bsp or not.
+//
+extern qboolean gbUsingCachedMapDataRightNow;
+void RE_LoadWorldMap( const char *name )
+{
+	gbUsingCachedMapDataRightNow = qtrue;	// !!!!!!!!!!!!
+
+		RE_LoadWorldMap_Actual( name, s_worldData, 0 );
+
+	gbUsingCachedMapDataRightNow = qfalse;	// !!!!!!!!!!!!
+}
diff --git a/codemp/renderer/tr_cmds.cpp b/codemp/renderer/tr_cmds.cpp
new file mode 100644
index 0000000..16098d3
--- /dev/null
+++ b/codemp/renderer/tr_cmds.cpp
@@ -0,0 +1,476 @@
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+#include "tr_local.h"
+
+
+/*
+=====================
+R_PerformanceCounters
+=====================
+*/
+void R_PerformanceCounters( void ) {
+#ifndef _XBOX
+	if ( !r_speeds->integer ) {
+		// clear the counters even if we aren't printing
+		Com_Memset( &tr.pc, 0, sizeof( tr.pc ) );
+		Com_Memset( &backEnd.pc, 0, sizeof( backEnd.pc ) );
+		return;
+	}
+
+	if (r_speeds->integer == 1) {
+		const float texSize = R_SumOfUsedImages( qfalse )/(8*1048576.0f)*(r_texturebits->integer?r_texturebits->integer:glConfig.colorBits);
+		Com_Printf ( "%i/%i shdrs/srfs %i leafs %i vrts %i/%i tris %.2fMB tex %.2f dc\n",
+			backEnd.pc.c_shaders, backEnd.pc.c_surfaces, tr.pc.c_leafs, backEnd.pc.c_vertexes, 
+			backEnd.pc.c_indexes/3, backEnd.pc.c_totalIndexes/3, 
+			texSize, backEnd.pc.c_overDraw / (float)(glConfig.vidWidth * glConfig.vidHeight) ); 
+	} else if (r_speeds->integer == 2) {
+		Com_Printf ( "(patch) %i sin %i sclip  %i sout %i bin %i bclip %i bout\n",
+			tr.pc.c_sphere_cull_patch_in, tr.pc.c_sphere_cull_patch_clip, tr.pc.c_sphere_cull_patch_out, 
+			tr.pc.c_box_cull_patch_in, tr.pc.c_box_cull_patch_clip, tr.pc.c_box_cull_patch_out );
+		Com_Printf ( "(md3) %i sin %i sclip  %i sout %i bin %i bclip %i bout\n",
+			tr.pc.c_sphere_cull_md3_in, tr.pc.c_sphere_cull_md3_clip, tr.pc.c_sphere_cull_md3_out, 
+			tr.pc.c_box_cull_md3_in, tr.pc.c_box_cull_md3_clip, tr.pc.c_box_cull_md3_out );
+	} else if (r_speeds->integer == 3) {
+		Com_Printf ( "viewcluster: %i\n", tr.viewCluster );
+	} else if (r_speeds->integer == 4) {
+		if ( backEnd.pc.c_dlightVertexes ) {
+			Com_Printf ( "dlight srf:%i  culled:%i  verts:%i  tris:%i\n", 
+				tr.pc.c_dlightSurfaces, tr.pc.c_dlightSurfacesCulled,
+				backEnd.pc.c_dlightVertexes, backEnd.pc.c_dlightIndexes / 3 );
+		}
+	} 
+	else if (r_speeds->integer == 5 )
+	{
+		Com_Printf ("zFar: %.0f\n", tr.viewParms.zFar );
+	}
+	else if (r_speeds->integer == 6 )
+	{
+		Com_Printf ("flare adds:%i tests:%i renders:%i\n", 
+			backEnd.pc.c_flareAdds, backEnd.pc.c_flareTests, backEnd.pc.c_flareRenders );
+	}
+	else if (r_speeds->integer == 7) {
+		const float texSize = R_SumOfUsedImages(qtrue) / (1048576.0f);
+		const float backBuff= glConfig.vidWidth * glConfig.vidHeight * glConfig.colorBits / (8.0f * 1024*1024);
+		const float depthBuff= glConfig.vidWidth * glConfig.vidHeight * glConfig.depthBits / (8.0f * 1024*1024);
+		const float stencilBuff= glConfig.vidWidth * glConfig.vidHeight * glConfig.stencilBits / (8.0f * 1024*1024);
+		Com_Printf ( "Tex MB %.2f + buffers %.2f MB = Total %.2fMB\n",
+			texSize, backBuff*2+depthBuff+stencilBuff, texSize+backBuff*2+depthBuff+stencilBuff); 
+	}
+#endif
+
+	Com_Memset( &tr.pc, 0, sizeof( tr.pc ) );
+	Com_Memset( &backEnd.pc, 0, sizeof( backEnd.pc ) );
+}
+
+
+/*
+====================
+R_InitCommandBuffers
+====================
+*/
+void R_InitCommandBuffers( void ) {
+}
+
+/*
+====================
+R_ShutdownCommandBuffers
+====================
+*/
+void R_ShutdownCommandBuffers( void ) {
+}
+
+/*
+====================
+R_IssueRenderCommands
+====================
+*/
+void R_IssueRenderCommands( qboolean runPerformanceCounters ) {
+	renderCommandList_t	*cmdList;
+
+	cmdList = &backEndData->commands;
+	assert(cmdList); // bk001205
+	// add an end-of-list command
+	*(int *)(cmdList->cmds + cmdList->used) = RC_END_OF_LIST;
+
+	// clear it out, in case this is a sync and not a buffer flip
+	cmdList->used = 0;
+
+	// at this point, the back end thread is idle, so it is ok
+	// to look at it's performance counters
+	if ( runPerformanceCounters ) {
+		R_PerformanceCounters();
+	}
+
+	// actually start the commands going
+	if ( !r_skipBackEnd->integer ) {
+		// let it start on the new batch
+		RB_ExecuteRenderCommands( cmdList->cmds );
+	}
+}
+
+
+/*
+====================
+R_SyncRenderThread
+
+Issue any pending commands and wait for them to complete.
+After exiting, the render thread will have completed its work
+and will remain idle and the main thread is free to issue
+OpenGL calls until R_IssueRenderCommands is called.
+====================
+*/
+void R_SyncRenderThread( void ) {
+#ifndef _XBOX
+	if ( !tr.registered ) {
+		return;
+	}
+	R_IssueRenderCommands( qfalse );
+#endif
+}
+
+/*
+============
+R_GetCommandBuffer
+
+make sure there is enough command space, waiting on the
+render thread if needed.
+============
+*/
+void *R_GetCommandBuffer( int bytes ) {
+	renderCommandList_t	*cmdList;
+
+	cmdList = &backEndData->commands;
+
+	// always leave room for the end of list command
+	if ( cmdList->used + bytes + 4 > MAX_RENDER_COMMANDS ) {
+#if defined(_DEBUG) && defined(_XBOX)
+		Com_Printf(S_COLOR_RED"Command buffer overflow!  Tell Brian.\n");
+#endif
+		if ( bytes > MAX_RENDER_COMMANDS - 4 ) {
+			Com_Error( ERR_FATAL, "R_GetCommandBuffer: bad size %i", bytes );
+		}
+		// if we run out of room, just start dropping commands
+		return NULL;
+	}
+
+	cmdList->used += bytes;
+
+	return cmdList->cmds + cmdList->used - bytes;
+}
+
+
+/*
+=============
+R_AddDrawSurfCmd
+
+=============
+*/
+void	R_AddDrawSurfCmd( drawSurf_t *drawSurfs, int numDrawSurfs ) {
+	drawSurfsCommand_t	*cmd;
+
+	cmd = (drawSurfsCommand_t *) R_GetCommandBuffer( sizeof( *cmd ) );
+	if ( !cmd ) {
+		return;
+	}
+	cmd->commandId = RC_DRAW_SURFS;
+
+	cmd->drawSurfs = drawSurfs;
+	cmd->numDrawSurfs = numDrawSurfs;
+
+	cmd->refdef = tr.refdef;
+	cmd->viewParms = tr.viewParms;
+}
+
+
+/*
+=============
+RE_SetColor
+
+Passing NULL will set the color to white
+=============
+*/
+void	RE_SetColor( const float *rgba ) {
+	setColorCommand_t	*cmd;
+
+	cmd = (setColorCommand_t *) R_GetCommandBuffer( sizeof( *cmd ) );
+	if ( !cmd ) {
+		return;
+	}
+	cmd->commandId = RC_SET_COLOR;
+	if ( !rgba ) {
+		static float colorWhite[4] = { 1, 1, 1, 1 };
+
+		rgba = colorWhite;
+	}
+
+	cmd->color[0] = rgba[0];
+	cmd->color[1] = rgba[1];
+	cmd->color[2] = rgba[2];
+	cmd->color[3] = rgba[3];
+}
+
+
+/*
+=============
+RE_StretchPic
+=============
+*/
+void RE_StretchPic ( float x, float y, float w, float h, 
+					  float s1, float t1, float s2, float t2, qhandle_t hShader ) {
+	stretchPicCommand_t	*cmd;
+
+	cmd = (stretchPicCommand_t *) R_GetCommandBuffer( sizeof( *cmd ) );
+	if ( !cmd ) {
+		return;
+	}
+	cmd->commandId = RC_STRETCH_PIC;
+	cmd->shader = R_GetShaderByHandle( hShader );
+	cmd->x = x;
+	cmd->y = y;
+	cmd->w = w;
+	cmd->h = h;
+	cmd->s1 = s1;
+	cmd->t1 = t1;
+	cmd->s2 = s2;
+	cmd->t2 = t2;
+}
+
+/*
+=============
+RE_RotatePic
+=============
+*/
+void RE_RotatePic ( float x, float y, float w, float h, 
+					  float s1, float t1, float s2, float t2,float a, qhandle_t hShader ) {
+	rotatePicCommand_t	*cmd;
+
+	cmd = (rotatePicCommand_t *) R_GetCommandBuffer( sizeof( *cmd ) );
+	if ( !cmd ) {
+		return;
+	}
+	cmd->commandId = RC_ROTATE_PIC;
+	cmd->shader = R_GetShaderByHandle( hShader );
+	cmd->x = x;
+	cmd->y = y;
+	cmd->w = w;
+	cmd->h = h;
+	cmd->s1 = s1;
+	cmd->t1 = t1;
+	cmd->s2 = s2;
+	cmd->t2 = t2;
+	cmd->a = a;
+}
+
+/*
+=============
+RE_RotatePic2
+=============
+*/
+void RE_RotatePic2 ( float x, float y, float w, float h, 
+					  float s1, float t1, float s2, float t2,float a, qhandle_t hShader ) {
+	rotatePicCommand_t	*cmd;
+
+	cmd = (rotatePicCommand_t *) R_GetCommandBuffer( sizeof( *cmd ) );
+	if ( !cmd ) {
+		return;
+	}
+	cmd->commandId = RC_ROTATE_PIC2;
+	cmd->shader = R_GetShaderByHandle( hShader );
+	cmd->x = x;
+	cmd->y = y;
+	cmd->w = w;
+	cmd->h = h;
+	cmd->s1 = s1;
+	cmd->t1 = t1;
+	cmd->s2 = s2;
+	cmd->t2 = t2;
+	cmd->a = a;
+}
+
+void RE_RenderWorldEffects(void)
+{
+	drawBufferCommand_t	*cmd;
+
+	cmd = (drawBufferCommand_t *)R_GetCommandBuffer( sizeof( *cmd ) );
+	if ( !cmd ) {
+		return;
+	}
+	cmd->commandId = RC_WORLD_EFFECTS;
+}
+
+void RE_RenderAutoMap(void)
+{
+	drawBufferCommand_t	*cmd;
+
+	cmd = (drawBufferCommand_t *)R_GetCommandBuffer( sizeof( *cmd ) );
+	if ( !cmd )
+	{
+		return;
+	}
+	cmd->commandId = RC_AUTO_MAP;
+}
+
+/*
+====================
+RE_BeginFrame
+
+If running in stereo, RE_BeginFrame will be called twice
+for each RE_EndFrame
+====================
+*/
+void RE_BeginFrame( stereoFrame_t stereoFrame ) {
+	drawBufferCommand_t	*cmd;
+
+	if ( !tr.registered ) {
+		return;
+	}
+	glState.finishCalled = qfalse;
+
+	tr.frameCount++;
+	tr.frameSceneNum = 0;
+
+	//
+	// do overdraw measurement
+	//
+#ifndef _XBOX
+	if ( r_measureOverdraw->integer )
+	{
+		if ( glConfig.stencilBits < 4 )
+		{
+			Com_Printf ("Warning: not enough stencil bits to measure overdraw: %d\n", glConfig.stencilBits );
+			Cvar_Set( "r_measureOverdraw", "0" );
+			r_measureOverdraw->modified = qfalse;
+		}
+		else if ( r_shadows->integer == 2 )
+		{
+			Com_Printf ("Warning: stencil shadows and overdraw measurement are mutually exclusive\n" );
+			Cvar_Set( "r_measureOverdraw", "0" );
+			r_measureOverdraw->modified = qfalse;
+		}
+		else
+		{
+			R_SyncRenderThread();
+			qglEnable( GL_STENCIL_TEST );
+			qglStencilMask( ~0U );
+			qglClearStencil( 0U );
+			qglStencilFunc( GL_ALWAYS, 0U, ~0U );
+			qglStencilOp( GL_KEEP, GL_INCR, GL_INCR );
+		}
+		r_measureOverdraw->modified = qfalse;
+	}
+	else
+	{
+		// this is only reached if it was on and is now off
+		if ( r_measureOverdraw->modified ) {
+			R_SyncRenderThread();
+			qglDisable( GL_STENCIL_TEST );
+		}
+		r_measureOverdraw->modified = qfalse;
+	}
+#endif
+
+	//
+	// texturemode stuff
+	//
+	if ( r_textureMode->modified || r_ext_texture_filter_anisotropic->modified) {
+		R_SyncRenderThread();
+		GL_TextureMode( r_textureMode->string );
+		r_textureMode->modified = qfalse;
+		r_ext_texture_filter_anisotropic->modified = qfalse;
+	}
+
+	//
+	// gamma stuff
+	//
+	if ( r_gamma->modified ) {
+		r_gamma->modified = qfalse;
+
+		R_SyncRenderThread();
+		R_SetColorMappings();
+	}
+
+    // check for errors
+    if ( !r_ignoreGLErrors->integer ) {
+        int	err;
+
+		R_SyncRenderThread();
+        if ( ( err = qglGetError() ) != GL_NO_ERROR ) {
+            Com_Error( ERR_FATAL, "RE_BeginFrame() - glGetError() failed (0x%x)!\n", err );
+        }
+    }
+
+	//
+	// draw buffer stuff
+	//
+	cmd = (drawBufferCommand_t *) R_GetCommandBuffer( sizeof( *cmd ) );
+	if ( !cmd ) {
+		return;
+	}
+	cmd->commandId = RC_DRAW_BUFFER;
+
+	if ( glConfig.stereoEnabled ) {
+		if ( stereoFrame == STEREO_LEFT ) {
+			cmd->buffer = (int)GL_BACK_LEFT;
+		} else if ( stereoFrame == STEREO_RIGHT ) {
+			cmd->buffer = (int)GL_BACK_RIGHT;
+		} else {
+			Com_Error( ERR_FATAL, "RE_BeginFrame: Stereo is enabled, but stereoFrame was %i", stereoFrame );
+		}
+	} else {
+		if ( stereoFrame != STEREO_CENTER ) {
+			Com_Error( ERR_FATAL, "RE_BeginFrame: Stereo is disabled, but stereoFrame was %i", stereoFrame );
+		}
+//		if ( !Q_stricmp( r_drawBuffer->string, "GL_FRONT" ) ) {
+//			cmd->buffer = (int)GL_FRONT;
+//		} else 
+		{
+			cmd->buffer = (int)GL_BACK;
+		}
+	}
+}
+
+
+/*
+=============
+RE_EndFrame
+
+Returns the number of msec spent in the back end
+=============
+*/
+void RE_EndFrame( int *frontEndMsec, int *backEndMsec ) {
+	swapBuffersCommand_t	*cmd;
+
+	if ( !tr.registered ) {
+		return;
+	}
+	cmd = (swapBuffersCommand_t *) R_GetCommandBuffer( sizeof( *cmd ) );
+	if ( !cmd ) {
+		return;
+	}
+	cmd->commandId = RC_SWAP_BUFFERS;
+
+#ifdef _XBOX
+	if (!qglBeginFrame()) return;
+#endif
+
+	R_IssueRenderCommands( qtrue );
+
+#ifdef _XBOX
+	qglEndFrame();
+#endif
+
+	// use the other buffers next frame, because another CPU
+	// may still be rendering into the current ones
+	R_ToggleSmpFrame();
+
+	if ( frontEndMsec ) {
+		*frontEndMsec = tr.frontEndMsec;
+	}
+	tr.frontEndMsec = 0;
+	if ( backEndMsec ) {
+		*backEndMsec = backEnd.pc.msec;
+	}
+	backEnd.pc.msec = 0;
+}
+
diff --git a/codemp/renderer/tr_curve.cpp b/codemp/renderer/tr_curve.cpp
new file mode 100644
index 0000000..503edad
--- /dev/null
+++ b/codemp/renderer/tr_curve.cpp
@@ -0,0 +1,612 @@
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+#include "tr_local.h"
+
+/*
+
+This file does all of the processing necessary to turn a raw grid of points
+read from the map file into a srfGridMesh_t ready for rendering.
+
+The level of detail solution is direction independent, based only on subdivided
+distance from the true curve.
+
+Only a single entry point:
+
+srfGridMesh_t *R_SubdividePatchToGrid( int width, int height,
+								drawVert_t points[MAX_PATCH_SIZE*MAX_PATCH_SIZE] ) {
+
+*/
+
+
+/*
+============
+LerpDrawVert
+============
+*/
+static void LerpDrawVert( drawVert_t *a, drawVert_t *b, drawVert_t *out ) 
+{
+	int	k;
+
+	out->xyz[0] = 0.5 * (a->xyz[0] + b->xyz[0]);
+	out->xyz[1] = 0.5 * (a->xyz[1] + b->xyz[1]);
+	out->xyz[2] = 0.5 * (a->xyz[2] + b->xyz[2]);
+
+	out->st[0] = 0.5 * (a->st[0] + b->st[0]);
+	out->st[1] = 0.5 * (a->st[1] + b->st[1]);
+
+	out->normal[0] = 0.5 * (a->normal[0] + b->normal[0]);
+	out->normal[1] = 0.5 * (a->normal[1] + b->normal[1]);
+	out->normal[2] = 0.5 * (a->normal[2] + b->normal[2]);
+
+	for(k=0;k<MAXLIGHTMAPS;k++)
+	{
+		out->lightmap[k][0] = 0.5 * (a->lightmap[k][0] + b->lightmap[k][0]);
+		out->lightmap[k][1] = 0.5 * (a->lightmap[k][1] + b->lightmap[k][1]);
+
+		out->color[k][0] = (a->color[k][0] + b->color[k][0]) >> 1;
+		out->color[k][1] = (a->color[k][1] + b->color[k][1]) >> 1;
+		out->color[k][2] = (a->color[k][2] + b->color[k][2]) >> 1;
+		out->color[k][3] = (a->color[k][3] + b->color[k][3]) >> 1;
+	}
+}
+
+/*
+============
+Transpose
+============
+*/
+static void Transpose( int width, int height, drawVert_t ctrl[MAX_GRID_SIZE][MAX_GRID_SIZE] ) {
+	int		i, j;
+	drawVert_t	temp;
+
+	if ( width > height ) {
+		for ( i = 0 ; i < height ; i++ ) {
+			for ( j = i + 1 ; j < width ; j++ ) {
+				if ( j < height ) {
+					// swap the value
+					temp = ctrl[j][i];
+					ctrl[j][i] = ctrl[i][j];
+					ctrl[i][j] = temp;
+				} else {
+					// just copy
+					ctrl[j][i] = ctrl[i][j];
+				}
+			}
+		}
+	} else {
+		for ( i = 0 ; i < width ; i++ ) {
+			for ( j = i + 1 ; j < height ; j++ ) {
+				if ( j < width ) {
+					// swap the value
+					temp = ctrl[i][j];
+					ctrl[i][j] = ctrl[j][i];
+					ctrl[j][i] = temp;
+				} else {
+					// just copy
+					ctrl[i][j] = ctrl[j][i];
+				}
+			}
+		}
+	}
+
+}
+
+
+/*
+=================
+MakeMeshNormals
+
+Handles all the complicated wrapping and degenerate cases
+=================
+*/
+static void MakeMeshNormals( int width, int height, drawVert_t ctrl[MAX_GRID_SIZE][MAX_GRID_SIZE] ) {
+	int		i, j, k, dist;
+	vec3_t	normal;
+	vec3_t	sum;
+	int		count;
+	vec3_t	base;
+	vec3_t	delta;
+	int		x, y;
+	drawVert_t	*dv;
+	vec3_t		around[8], temp;
+	qboolean	good[8];
+	qboolean	wrapWidth, wrapHeight;
+	float		len;
+static	int	neighbors[8][2] = {
+	{0,1}, {1,1}, {1,0}, {1,-1}, {0,-1}, {-1,-1}, {-1,0}, {-1,1}
+	};
+
+	wrapWidth = qfalse;
+	for ( i = 0 ; i < height ; i++ ) {
+		VectorSubtract( ctrl[i][0].xyz, ctrl[i][width-1].xyz, delta );
+		len = VectorLengthSquared( delta );
+		if ( len > 1.0 ) {
+			break;
+		}
+	}
+	if ( i == height ) {
+		wrapWidth = qtrue;
+	}
+
+	wrapHeight = qfalse;
+	for ( i = 0 ; i < width ; i++ ) {
+		VectorSubtract( ctrl[0][i].xyz, ctrl[height-1][i].xyz, delta );
+		len = VectorLengthSquared( delta );
+		if ( len > 1.0 ) {
+			break;
+		}
+	}
+	if ( i == width) {
+		wrapHeight = qtrue;
+	}
+
+
+	for ( i = 0 ; i < width ; i++ ) {
+		for ( j = 0 ; j < height ; j++ ) {
+			count = 0;
+			dv = &ctrl[j][i];
+			VectorCopy( dv->xyz, base );
+			for ( k = 0 ; k < 8 ; k++ ) {
+				VectorClear( around[k] );
+				good[k] = qfalse;
+
+				for ( dist = 1 ; dist <= 3 ; dist++ ) {
+					x = i + neighbors[k][0] * dist;
+					y = j + neighbors[k][1] * dist;
+					if ( wrapWidth ) {
+						if ( x < 0 ) {
+							x = width - 1 + x;
+						} else if ( x >= width ) {
+							x = 1 + x - width;
+						}
+					}
+					if ( wrapHeight ) {
+						if ( y < 0 ) {
+							y = height - 1 + y;
+						} else if ( y >= height ) {
+							y = 1 + y - height;
+						}
+					}
+
+					if ( x < 0 || x >= width || y < 0 || y >= height ) {
+						break;					// edge of patch
+					}
+					VectorSubtract( ctrl[y][x].xyz, base, temp );
+					if ( VectorNormalize2( temp, temp ) == 0 ) {
+						continue;				// degenerate edge, get more dist
+					} else {
+						good[k] = qtrue;
+						VectorCopy( temp, around[k] );
+						break;					// good edge
+					}
+				}
+			}
+
+			VectorClear( sum );
+			for ( k = 0 ; k < 8 ; k++ ) {
+				if ( !good[k] || !good[(k+1)&7] ) {
+					continue;	// didn't get two points
+				}
+				CrossProduct( around[(k+1)&7], around[k], normal );
+				if ( VectorNormalize2( normal, normal ) == 0 ) {
+					continue;
+				}
+				VectorAdd( normal, sum, sum );
+				count++;
+			}
+			if ( count == 0 ) {
+//printf("bad normal\n");
+				count = 1;
+			}
+			VectorNormalize2( sum, dv->normal );
+		}
+	}
+}
+
+/*
+============
+InvertCtrl
+============
+*/
+static void InvertCtrl( int width, int height, drawVert_t ctrl[MAX_GRID_SIZE][MAX_GRID_SIZE] ) {
+	int		i, j;
+	drawVert_t	temp;
+
+	for ( i = 0 ; i < height ; i++ ) {
+		for ( j = 0 ; j < width/2 ; j++ ) {
+			temp = ctrl[i][j];
+			ctrl[i][j] = ctrl[i][width-1-j];
+			ctrl[i][width-1-j] = temp;
+		}
+	}
+}
+
+/*
+=================
+InvertErrorTable
+=================
+*/
+static void InvertErrorTable( float errorTable[2][MAX_GRID_SIZE], int width, int height ) {
+	int		i;
+	float	copy[2][MAX_GRID_SIZE];
+
+	Com_Memcpy( copy, errorTable, sizeof( copy ) );
+
+	for ( i = 0 ; i < width ; i++ ) {
+		errorTable[1][i] = copy[0][i];	//[width-1-i];
+	}
+
+	for ( i = 0 ; i < height ; i++ ) {
+		errorTable[0][i] = copy[1][height-1-i];
+	}
+
+}
+
+/*
+==================
+PutPointsOnCurve
+==================
+*/
+static void PutPointsOnCurve( drawVert_t	ctrl[MAX_GRID_SIZE][MAX_GRID_SIZE], 
+							 int width, int height ) {
+	int			i, j;
+	drawVert_t	prev, next;
+
+	for ( i = 0 ; i < width ; i++ ) {
+		for ( j = 1 ; j < height ; j += 2 ) {
+			LerpDrawVert( &ctrl[j][i], &ctrl[j+1][i], &prev );
+			LerpDrawVert( &ctrl[j][i], &ctrl[j-1][i], &next );
+			LerpDrawVert( &prev, &next, &ctrl[j][i] );
+		}
+	}
+
+
+	for ( j = 0 ; j < height ; j++ ) {
+		for ( i = 1 ; i < width ; i += 2 ) {
+			LerpDrawVert( &ctrl[j][i], &ctrl[j][i+1], &prev );
+			LerpDrawVert( &ctrl[j][i], &ctrl[j][i-1], &next );
+			LerpDrawVert( &prev, &next, &ctrl[j][i] );
+		}
+	}
+}
+
+/*
+=================
+R_CreateSurfaceGridMesh
+=================
+*/
+srfGridMesh_t *R_CreateSurfaceGridMesh(int width, int height,
+								drawVert_t ctrl[MAX_GRID_SIZE][MAX_GRID_SIZE], float errorTable[2][MAX_GRID_SIZE] ) {
+	int i, j, size;
+	drawVert_t	*vert;
+	vec3_t		tmpVec;
+	srfGridMesh_t *grid;
+
+	// copy the results out to a grid
+	size = (width * height - 1) * sizeof( drawVert_t ) + sizeof( *grid );
+
+#ifdef PATCH_STITCHING
+	grid = (struct srfGridMesh_s *)/*Hunk_Alloc*/ Z_Malloc( size, TAG_GRIDMESH, qfalse );
+	Com_Memset(grid, 0, size);
+
+	grid->widthLodError = (float *)/*Hunk_Alloc*/ Z_Malloc( width * 4, TAG_GRIDMESH, qfalse );
+	Com_Memcpy( grid->widthLodError, errorTable[0], width * 4 );
+
+	grid->heightLodError = (float *)/*Hunk_Alloc*/ Z_Malloc( height * 4, TAG_GRIDMESH, qfalse );
+	Com_Memcpy( grid->heightLodError, errorTable[1], height * 4 );
+#else
+	grid = Hunk_Alloc( size );
+	Com_Memset(grid, 0, size);
+
+	grid->widthLodError = Hunk_Alloc( width * 4 );
+	Com_Memcpy( grid->widthLodError, errorTable[0], width * 4 );
+
+	grid->heightLodError = Hunk_Alloc( height * 4 );
+	Com_Memcpy( grid->heightLodError, errorTable[1], height * 4 );
+#endif
+
+	grid->width = width;
+	grid->height = height;
+	grid->surfaceType = SF_GRID;
+	ClearBounds( grid->meshBounds[0], grid->meshBounds[1] );
+	for ( i = 0 ; i < width ; i++ ) {
+		for ( j = 0 ; j < height ; j++ ) {
+			vert = &grid->verts[j*width+i];
+			*vert = ctrl[j][i];
+			AddPointToBounds( vert->xyz, grid->meshBounds[0], grid->meshBounds[1] );
+		}
+	}
+
+	// compute local origin and bounds
+	VectorAdd( grid->meshBounds[0], grid->meshBounds[1], grid->localOrigin );
+	VectorScale( grid->localOrigin, 0.5f, grid->localOrigin );
+	VectorSubtract( grid->meshBounds[0], grid->localOrigin, tmpVec );
+	grid->meshRadius = VectorLength( tmpVec );
+
+	VectorCopy( grid->localOrigin, grid->lodOrigin );
+	grid->lodRadius = grid->meshRadius;
+	//
+	return grid;
+}
+
+/*
+=================
+R_FreeSurfaceGridMesh
+=================
+*/
+void R_FreeSurfaceGridMesh( srfGridMesh_t *grid ) {
+	Z_Free(grid->widthLodError);
+	Z_Free(grid->heightLodError);
+	Z_Free(grid);
+}
+
+/*
+=================
+R_SubdividePatchToGrid
+=================
+*/
+srfGridMesh_t *R_SubdividePatchToGrid( int width, int height,
+								drawVert_t points[MAX_PATCH_SIZE*MAX_PATCH_SIZE] ) {
+	int			i, j, k, l;
+	drawVert_t	prev, next, mid;
+	float		len, maxLen;
+	int			dir;
+	int			t;
+	MAC_STATIC drawVert_t	ctrl[MAX_GRID_SIZE][MAX_GRID_SIZE];
+	float		errorTable[2][MAX_GRID_SIZE];
+
+	for ( i = 0 ; i < width ; i++ ) {
+		for ( j = 0 ; j < height ; j++ ) {
+			ctrl[j][i] = points[j*width+i];
+		}
+	}
+
+	for ( dir = 0 ; dir < 2 ; dir++ ) {
+
+		for ( j = 0 ; j < MAX_GRID_SIZE ; j++ ) {
+			errorTable[dir][j] = 0;
+		}
+
+		// horizontal subdivisions
+		for ( j = 0 ; j + 2 < width ; j += 2 ) {
+			// check subdivided midpoints against control points
+
+			// FIXME: also check midpoints of adjacent patches against the control points
+			// this would basically stitch all patches in the same LOD group together.
+
+			maxLen = 0;
+			for ( i = 0 ; i < height ; i++ ) {
+				vec3_t		midxyz;
+				vec3_t		dir;
+				vec3_t		projected;
+				float		d;
+
+				// calculate the point on the curve
+				for ( l = 0 ; l < 3 ; l++ ) {
+					midxyz[l] = (ctrl[i][j].xyz[l] + ctrl[i][j+1].xyz[l] * 2
+							+ ctrl[i][j+2].xyz[l] ) * 0.25f;
+				}
+
+				// see how far off the line it is
+				// using dist-from-line will not account for internal
+				// texture warping, but it gives a lot less polygons than
+				// dist-from-midpoint
+				VectorSubtract( midxyz, ctrl[i][j].xyz, midxyz );
+				VectorSubtract( ctrl[i][j+2].xyz, ctrl[i][j].xyz, dir );
+				VectorNormalize( dir );
+
+				d = DotProduct( midxyz, dir );
+				VectorScale( dir, d, projected );
+				VectorSubtract( midxyz, projected, midxyz);
+				len = VectorLengthSquared( midxyz );			// we will do the sqrt later
+
+				if ( len > maxLen ) {
+					maxLen = len;
+				}
+			}
+
+			maxLen = sqrt(maxLen);
+			// if all the points are on the lines, remove the entire columns
+			if ( maxLen < 0.1f ) {
+				errorTable[dir][j+1] = 999;
+				continue;
+			}
+
+			// see if we want to insert subdivided columns
+			if ( width + 2 > MAX_GRID_SIZE ) {
+				errorTable[dir][j+1] = 1.0f/maxLen;
+				continue;	// can't subdivide any more
+			}
+
+			if ( maxLen <= r_subdivisions->value ) {
+				errorTable[dir][j+1] = 1.0f/maxLen;
+				continue;	// didn't need subdivision
+			}
+
+			errorTable[dir][j+2] = 1.0f/maxLen;
+
+			// insert two columns and replace the peak
+			width += 2;
+			for ( i = 0 ; i < height ; i++ ) {
+				LerpDrawVert( &ctrl[i][j], &ctrl[i][j+1], &prev );
+				LerpDrawVert( &ctrl[i][j+1], &ctrl[i][j+2], &next );
+				LerpDrawVert( &prev, &next, &mid );
+
+				for ( k = width - 1 ; k > j + 3 ; k-- ) {
+					ctrl[i][k] = ctrl[i][k-2];
+				}
+				ctrl[i][j + 1] = prev;
+				ctrl[i][j + 2] = mid;
+				ctrl[i][j + 3] = next;
+			}
+
+			// back up and recheck this set again, it may need more subdivision
+			j -= 2;
+
+		}
+
+		Transpose( width, height, ctrl );
+		t = width;
+		width = height;
+		height = t;
+	}
+
+
+	// put all the aproximating points on the curve
+	PutPointsOnCurve( ctrl, width, height );
+
+	// cull out any rows or columns that are colinear
+	for ( i = 1 ; i < width-1 ; i++ ) {
+		if ( errorTable[0][i] != 999 ) {
+			continue;
+		}
+		for ( j = i+1 ; j < width ; j++ ) {
+			for ( k = 0 ; k < height ; k++ ) {
+				ctrl[k][j-1] = ctrl[k][j];
+			}
+			errorTable[0][j-1] = errorTable[0][j];
+		}
+		width--;
+	}
+
+	for ( i = 1 ; i < height-1 ; i++ ) {
+		if ( errorTable[1][i] != 999 ) {
+			continue;
+		}
+		for ( j = i+1 ; j < height ; j++ ) {
+			for ( k = 0 ; k < width ; k++ ) {
+				ctrl[j-1][k] = ctrl[j][k];
+			}
+			errorTable[1][j-1] = errorTable[1][j];
+		}
+		height--;
+	}
+
+#if 1
+	// flip for longest tristrips as an optimization
+	// the results should be visually identical with or
+	// without this step
+	if ( height > width ) {
+		Transpose( width, height, ctrl );
+		InvertErrorTable( errorTable, width, height );
+		t = width;
+		width = height;
+		height = t;
+		InvertCtrl( width, height, ctrl );
+	}
+#endif
+
+	// calculate normals
+	MakeMeshNormals( width, height, ctrl );
+
+	return R_CreateSurfaceGridMesh( width, height, ctrl, errorTable );
+}
+
+/*
+===============
+R_GridInsertColumn
+===============
+*/
+srfGridMesh_t *R_GridInsertColumn( srfGridMesh_t *grid, int column, int row, vec3_t point, float loderror ) {
+	int i, j;
+	int width, height, oldwidth;
+	MAC_STATIC drawVert_t ctrl[MAX_GRID_SIZE][MAX_GRID_SIZE];
+	float errorTable[2][MAX_GRID_SIZE];
+	float lodRadius;
+	vec3_t lodOrigin;
+
+	oldwidth = 0;
+	width = grid->width + 1;
+	if (width > MAX_GRID_SIZE)
+		return NULL;
+	height = grid->height;
+	for (i = 0; i < width; i++) {
+		if (i == column) {
+			//insert new column
+			for (j = 0; j < grid->height; j++) {
+				LerpDrawVert( &grid->verts[j * grid->width + i-1], &grid->verts[j * grid->width + i], &ctrl[j][i] );
+				if (j == row)
+					VectorCopy(point, ctrl[j][i].xyz);
+			}
+			errorTable[0][i] = loderror;
+			continue;
+		}
+		errorTable[0][i] = grid->widthLodError[oldwidth];
+		for (j = 0; j < grid->height; j++) {
+			ctrl[j][i] = grid->verts[j * grid->width + oldwidth];
+		}
+		oldwidth++;
+	}
+	for (j = 0; j < grid->height; j++) {
+		errorTable[1][j] = grid->heightLodError[j];
+	}
+	// put all the aproximating points on the curve
+	//PutPointsOnCurve( ctrl, width, height );
+	// calculate normals
+	MakeMeshNormals( width, height, ctrl );
+
+	VectorCopy(grid->lodOrigin, lodOrigin);
+	lodRadius = grid->lodRadius;
+	// free the old grid
+	R_FreeSurfaceGridMesh(grid);
+	// create a new grid
+	grid = R_CreateSurfaceGridMesh( width, height, ctrl, errorTable );
+	grid->lodRadius = lodRadius;
+	VectorCopy(lodOrigin, grid->lodOrigin);
+	return grid;
+}
+
+/*
+===============
+R_GridInsertRow
+===============
+*/
+srfGridMesh_t *R_GridInsertRow( srfGridMesh_t *grid, int row, int column, vec3_t point, float loderror ) {
+	int i, j;
+	int width, height, oldheight;
+	MAC_STATIC drawVert_t ctrl[MAX_GRID_SIZE][MAX_GRID_SIZE];
+	float errorTable[2][MAX_GRID_SIZE];
+	float lodRadius;
+	vec3_t lodOrigin;
+
+	oldheight = 0;
+	width = grid->width;
+	height = grid->height + 1;
+	if (height > MAX_GRID_SIZE)
+		return NULL;
+	for (i = 0; i < height; i++) {
+		if (i == row) {
+			//insert new row
+			for (j = 0; j < grid->width; j++) {
+				LerpDrawVert( &grid->verts[(i-1) * grid->width + j], &grid->verts[i * grid->width + j], &ctrl[i][j] );
+				if (j == column)
+					VectorCopy(point, ctrl[i][j].xyz);
+			}
+			errorTable[1][i] = loderror;
+			continue;
+		}
+		errorTable[1][i] = grid->heightLodError[oldheight];
+		for (j = 0; j < grid->width; j++) {
+			ctrl[i][j] = grid->verts[oldheight * grid->width + j];
+		}
+		oldheight++;
+	}
+	for (j = 0; j < grid->width; j++) {
+		errorTable[0][j] = grid->widthLodError[j];
+	}
+	// put all the aproximating points on the curve
+	//PutPointsOnCurve( ctrl, width, height );
+	// calculate normals
+	MakeMeshNormals( width, height, ctrl );
+
+	VectorCopy(grid->lodOrigin, lodOrigin);
+	lodRadius = grid->lodRadius;
+	// free the old grid
+	R_FreeSurfaceGridMesh(grid);
+	// create a new grid
+	grid = R_CreateSurfaceGridMesh( width, height, ctrl, errorTable );
+	grid->lodRadius = lodRadius;
+	VectorCopy(lodOrigin, grid->lodOrigin);
+	return grid;
+}
diff --git a/codemp/renderer/tr_curve_xbox.cpp b/codemp/renderer/tr_curve_xbox.cpp
new file mode 100644
index 0000000..f89726a
--- /dev/null
+++ b/codemp/renderer/tr_curve_xbox.cpp
@@ -0,0 +1,536 @@
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+#include "tr_local.h"
+
+/*
+
+This file does all of the processing necessary to turn a raw grid of points
+read from the map file into a srfGridMesh_t ready for rendering.
+
+The level of detail solution is direction independent, based only on subdivided
+distance from the true curve.
+
+Only a single entry point:
+
+srfGridMesh_t *R_SubdividePatchToGrid( int width, int height,
+								drawVert_t points[MAX_PATCH_SIZE*MAX_PATCH_SIZE] ) {
+
+*/
+
+
+/*
+============
+LerpDrawVert
+============
+*/
+static void LerpDrawVert( drawVert_t *a, drawVert_t *b, drawVert_t *out ) {
+	int	k;
+	out->xyz[0] = 0.5 * (a->xyz[0] + b->xyz[0]);
+	out->xyz[1] = 0.5 * (a->xyz[1] + b->xyz[1]);
+	out->xyz[2] = 0.5 * (a->xyz[2] + b->xyz[2]);
+
+	out->dvst[0] = (short)(0.5 * (float)(a->dvst[0] + b->dvst[0]));
+	out->dvst[1] = (short)(0.5 * (float)(a->dvst[1] + b->dvst[1]));
+
+	out->normal[0] = 0.5 * (a->normal[0] + b->normal[0]);
+	out->normal[1] = 0.5 * (a->normal[1] + b->normal[1]);
+	out->normal[2] = 0.5 * (a->normal[2] + b->normal[2]);
+
+	for(k=0;k<MAXLIGHTMAPS;k++)
+	{
+		out->dvlightmap[k][0] = (short)(0.5 * (float)(a->dvlightmap[k][0] + b->dvlightmap[k][0]));
+		out->dvlightmap[k][1] = (short)(0.5 * (float)(a->dvlightmap[k][1] + b->dvlightmap[k][1]));
+
+		// Need to do averaging per every four bits
+		for (int j = 0; j < 2; ++j)
+		{
+			byte ah, al, bh, bl;
+			ah = a->dvcolor[k][j] >> 4;
+			al = a->dvcolor[k][j] & 0x0F;
+			bh = b->dvcolor[k][j] >> 4;
+			bl = b->dvcolor[k][j] & 0x0F;
+			out->dvcolor[k][j] = (((ah+bh) / 2) << 4) | ((al+bl) / 2);
+		}
+	}
+}
+
+/*
+============
+Transpose
+============
+*/
+static void Transpose( int width, int height, drawVert_t* ctrl/*[MAX_GRID_SIZE][MAX_GRID_SIZE]*/ ) {
+	int		i, j;
+	drawVert_t	temp;
+
+	if ( width > height ) {
+		for ( i = 0 ; i < height ; i++ ) {
+			for ( j = i + 1 ; j < width ; j++ ) {
+				if ( j < height ) {
+					// swap the value
+					temp = ctrl[j*MAX_GRID_SIZE+i];
+					ctrl[j*MAX_GRID_SIZE+i] = ctrl[i*MAX_GRID_SIZE+j];
+					ctrl[i*MAX_GRID_SIZE+j] = temp;
+				} else {
+					// just copy
+					ctrl[j*MAX_GRID_SIZE+i] = ctrl[i*MAX_GRID_SIZE+j];
+				}
+			}
+		}
+	} else {
+		for ( i = 0 ; i < width ; i++ ) {
+			for ( j = i + 1 ; j < height ; j++ ) {
+				if ( j < width ) {
+					// swap the value
+					temp = ctrl[i*MAX_GRID_SIZE+j];
+					ctrl[i*MAX_GRID_SIZE+j] = ctrl[j*MAX_GRID_SIZE+i];
+					ctrl[j*MAX_GRID_SIZE+i] = temp;
+				} else {
+					// just copy
+					ctrl[i*MAX_GRID_SIZE+j] = ctrl[j*MAX_GRID_SIZE+i];
+				}
+			}
+		}
+	}
+
+}
+
+/*
+=================
+MakeMeshNormals
+
+Handles all the complicated wrapping and degenerate cases
+=================
+*/
+static void MakeMeshNormals( int width, int height, drawVert_t* ctrl/*[MAX_GRID_SIZE][MAX_GRID_SIZE]*/ ) {
+	int		i, j, k, dist;
+	vec3_t	normal;
+	vec3_t	sum;
+	int		count;
+	vec3_t	base;
+	vec3_t	delta;
+	int		x, y;
+	drawVert_t	*dv;
+	vec3_t		around[8], temp;
+	qboolean	good[8];
+	qboolean	wrapWidth, wrapHeight;
+	float		len;
+	static	int	neighbors[8][2] = {
+		{0,1}, {1,1}, {1,0}, {1,-1}, {0,-1}, {-1,-1}, {-1,0}, {-1,1}
+	};
+
+	wrapWidth = qfalse;
+	for ( i = 0 ; i < height ; i++ ) {
+		VectorSubtract( ctrl[i*MAX_GRID_SIZE+0].xyz, ctrl[i*MAX_GRID_SIZE+width-1].xyz, delta );
+		len = VectorLengthSquared( delta );
+		if ( len > 1.0 ) {
+			break;
+		}
+	}
+	if ( i == height ) {
+		wrapWidth = qtrue;
+	}
+
+	wrapHeight = qfalse;
+	for ( i = 0 ; i < width ; i++ ) {
+		VectorSubtract( ctrl[0*MAX_GRID_SIZE+i].xyz, ctrl[(height-1)*MAX_GRID_SIZE+i].xyz, delta );
+		len = VectorLengthSquared( delta );
+		if ( len > 1.0 ) {
+			break;
+		}
+	}
+	if ( i == width) {
+		wrapHeight = qtrue;
+	}
+
+
+	for ( i = 0 ; i < width ; i++ ) {
+		for ( j = 0 ; j < height ; j++ ) {
+			count = 0;
+			dv = &ctrl[j*MAX_GRID_SIZE+i];
+			VectorCopy( dv->xyz, base );
+			for ( k = 0 ; k < 8 ; k++ ) {
+				VectorClear( around[k] );
+				good[k] = qfalse;
+
+				for ( dist = 1 ; dist <= 3 ; dist++ ) {
+					x = i + neighbors[k][0] * dist;
+					y = j + neighbors[k][1] * dist;
+					if ( wrapWidth ) {
+						if ( x < 0 ) {
+							x = width - 1 + x;
+						} else if ( x >= width ) {
+							x = 1 + x - width;
+						}
+					}
+					if ( wrapHeight ) {
+						if ( y < 0 ) {
+							y = height - 1 + y;
+						} else if ( y >= height ) {
+							y = 1 + y - height;
+						}
+					}
+
+					if ( x < 0 || x >= width || y < 0 || y >= height ) {
+						break;					// edge of patch
+					}
+					VectorSubtract( ctrl[y*MAX_GRID_SIZE+x].xyz, base, temp );
+					if ( VectorNormalize2( temp, temp ) == 0 ) {
+						continue;				// degenerate edge, get more dist
+					} else {
+						good[k] = qtrue;
+						VectorCopy( temp, around[k] );
+						break;					// good edge
+					}
+				}
+			}
+
+			VectorClear( sum );
+			for ( k = 0 ; k < 8 ; k++ ) {
+				if ( !good[k] || !good[(k+1)&7] ) {
+					continue;	// didn't get two points
+				}
+				CrossProduct( around[(k+1)&7], around[k], normal );
+				if ( VectorNormalize2( normal, normal ) == 0 ) {
+					continue;
+				}
+				VectorAdd( normal, sum, sum );
+				count++;
+			}
+			if ( count == 0 ) {
+//printf("bad normal\n");
+				count = 1;
+			}
+			VectorNormalize2( sum, dv->normal );
+		}
+	}
+}
+
+/*
+============
+InvertCtrl
+============
+*/
+static void InvertCtrl( int width, int height, drawVert_t* ctrl/*[MAX_GRID_SIZE][MAX_GRID_SIZE]*/ ) {
+	int		i, j;
+	drawVert_t	temp;
+
+	for ( i = 0 ; i < height ; i++ ) {
+		for ( j = 0 ; j < width/2 ; j++ ) {
+			temp = ctrl[i*MAX_GRID_SIZE+j];
+			ctrl[i*MAX_GRID_SIZE+j] = ctrl[i*MAX_GRID_SIZE+width-1-j];
+			ctrl[i*MAX_GRID_SIZE+width-1-j] = temp;
+		}
+	}
+}
+
+/*
+=================
+InvertErrorTable
+=================
+*/
+static void InvertErrorTable( float* errorTable/*[2][MAX_GRID_SIZE]*/, int width, int height ) {
+	int		i;
+	float	copy[2][MAX_GRID_SIZE];
+
+	memcpy( copy, errorTable, sizeof( copy ) );
+
+	for ( i = 0 ; i < width ; i++ ) {
+		errorTable[1*MAX_GRID_SIZE+i] = copy[0][i];	//[width-1-i];
+	}
+
+	for ( i = 0 ; i < height ; i++ ) {
+		errorTable[0*MAX_GRID_SIZE+i] = copy[1][height-1-i];
+	}
+
+}
+
+/*
+==================
+PutPointsOnCurve
+==================
+*/
+static void PutPointsOnCurve( drawVert_t* ctrl/*[MAX_GRID_SIZE][MAX_GRID_SIZE]*/, 
+							 int width, int height ) {
+	int			i, j;
+	drawVert_t	prev, next;
+
+	for ( i = 0 ; i < width ; i++ ) {
+		for ( j = 1 ; j < height ; j += 2 ) {
+			LerpDrawVert( &ctrl[j*MAX_GRID_SIZE+i], &ctrl[(j+1)*MAX_GRID_SIZE+i], &prev );
+			LerpDrawVert( &ctrl[j*MAX_GRID_SIZE+i], &ctrl[(j-1)*MAX_GRID_SIZE+i], &next );
+			LerpDrawVert( &prev, &next, &ctrl[j*MAX_GRID_SIZE+i] );
+		}
+	}
+
+
+	for ( j = 0 ; j < height ; j++ ) {
+		for ( i = 1 ; i < width ; i += 2 ) {
+			LerpDrawVert( &ctrl[j*MAX_GRID_SIZE+i], &ctrl[j*MAX_GRID_SIZE+i+1], &prev );
+			LerpDrawVert( &ctrl[j*MAX_GRID_SIZE+i], &ctrl[j*MAX_GRID_SIZE+i-1], &next );
+			LerpDrawVert( &prev, &next, &ctrl[j*MAX_GRID_SIZE+i] );
+		}
+	}
+}
+
+/*
+=================
+R_CreateSurfaceGridMesh
+=================
+*/
+srfGridMesh_t *R_CreateSurfaceGridMesh(int width, int height,
+								drawVert_t ctrl[MAX_GRID_SIZE][MAX_GRID_SIZE], float errorTable[2][MAX_GRID_SIZE] ) {
+	int i, j, size;
+	drawVert_t	*vert;
+	vec3_t		tmpVec;
+	srfGridMesh_t *grid;
+
+	// copy the results out to a grid
+	size = (width * height - 1) * sizeof( drawVert_t ) + sizeof( *grid );
+
+#ifdef PATCH_STITCHING
+	grid = (struct srfGridMesh_s *)/*Hunk_Alloc*/ Z_Malloc( size, TAG_GRIDMESH, qfalse );
+	Com_Memset(grid, 0, size);
+
+	grid->widthLodError = (float *)/*Hunk_Alloc*/ Z_Malloc( width * 4, TAG_GRIDMESH, qfalse );
+	Com_Memcpy( grid->widthLodError, errorTable[0], width * 4 );
+
+	grid->heightLodError = (float *)/*Hunk_Alloc*/ Z_Malloc( height * 4, TAG_GRIDMESH, qfalse );
+	Com_Memcpy( grid->heightLodError, errorTable[1], height * 4 );
+#else
+	grid = Hunk_Alloc( size );
+	Com_Memset(grid, 0, size);
+
+	grid->widthLodError = Hunk_Alloc( width * 4 );
+	Com_Memcpy( grid->widthLodError, errorTable[0], width * 4 );
+
+	grid->heightLodError = Hunk_Alloc( height * 4 );
+	Com_Memcpy( grid->heightLodError, errorTable[1], height * 4 );
+#endif
+
+	grid->width = width;
+	grid->height = height;
+	grid->surfaceType = SF_GRID;
+	ClearBounds( grid->meshBounds[0], grid->meshBounds[1] );
+	for ( i = 0 ; i < width ; i++ ) {
+		for ( j = 0 ; j < height ; j++ ) {
+			vert = &grid->verts[j*width+i];
+			*vert = ctrl[j][i];
+			AddPointToBounds( vert->xyz, grid->meshBounds[0], grid->meshBounds[1] );
+		}
+	}
+
+	// compute local origin and bounds
+	VectorAdd( grid->meshBounds[0], grid->meshBounds[1], grid->localOrigin );
+	VectorScale( grid->localOrigin, 0.5f, grid->localOrigin );
+	VectorSubtract( grid->meshBounds[0], grid->localOrigin, tmpVec );
+	grid->meshRadius = VectorLength( tmpVec );
+
+	VectorCopy( grid->localOrigin, grid->lodOrigin );
+	grid->lodRadius = grid->meshRadius;
+	//
+	return grid;
+}
+
+/*
+=================
+R_FreeSurfaceGridMesh
+=================
+*/
+void R_FreeSurfaceGridMesh( srfGridMesh_t *grid ) {
+	Z_Free(grid->widthLodError);
+	Z_Free(grid->heightLodError);
+	Z_Free(grid);
+}
+
+/*
+=================
+R_SubdividePatchToGrid
+=================
+*/
+srfGridMesh_t *R_SubdividePatchToGrid( int width, int height, drawVert_t* points,
+									   drawVert_t*	ctrl, float* errorTable ) {
+	int			i, j, k, l;
+	drawVert_t	prev, next, mid;
+	float		len, maxLen;
+	int			dir;
+	int			t;
+	srfGridMesh_t	*grid;
+	drawVert_t	*vert;
+	vec3_t		tmpVec;
+
+	for ( i = 0 ; i < width ; i++ ) {
+		for ( j = 0 ; j < height ; j++ ) {
+			ctrl[j*MAX_GRID_SIZE+i] = points[j*width+i];
+		}
+	}
+
+	for ( dir = 0 ; dir < 2 ; dir++ ) {
+
+		for ( j = 0 ; j < MAX_GRID_SIZE ; j++ ) {
+			errorTable[dir*MAX_GRID_SIZE+j] = 0;
+		}
+
+		// horizontal subdivisions
+		for ( j = 0 ; j + 2 < width ; j += 2 ) {
+			// check subdivided midpoints against control points
+			maxLen = 0;
+			for ( i = 0 ; i < height ; i++ ) {
+				vec3_t		midxyz;
+				vec3_t		dir;
+				vec3_t		projected;
+				float		d;
+
+				// calculate the point on the curve
+				for ( l = 0 ; l < 3 ; l++ ) {
+					midxyz[l] = (ctrl[i*MAX_GRID_SIZE+j].xyz[l] 
+							+ ctrl[i*MAX_GRID_SIZE+j+1].xyz[l] * 2
+							+ ctrl[i*MAX_GRID_SIZE+j+2].xyz[l] ) * 0.25;
+				}
+
+				// see how far off the line it is
+				// using dist-from-line will not account for internal
+				// texture warping, but it gives a lot less polygons than
+				// dist-from-midpoint
+				VectorSubtract( midxyz, ctrl[i*MAX_GRID_SIZE+j].xyz, midxyz );
+				VectorSubtract( ctrl[i*MAX_GRID_SIZE+j+2].xyz, ctrl[i*MAX_GRID_SIZE+j].xyz, dir );
+				VectorNormalize( dir );
+
+				d = DotProduct( midxyz, dir );
+				VectorScale( dir, d, projected );
+				VectorSubtract( midxyz, projected, midxyz);
+				len = VectorLengthSquared( midxyz );
+
+				if ( len > maxLen ) {
+					maxLen = len;
+				}
+			}
+			maxLen = sqrt(maxLen);
+
+			// if all the points are on the lines, remove the entire columns
+			if ( maxLen < 0.1 ) {
+				errorTable[dir*MAX_GRID_SIZE+j+1] = 999;
+				continue;
+			}
+
+			// see if we want to insert subdivided columns
+			if ( width + 2 > MAX_GRID_SIZE ) {
+				errorTable[dir*MAX_GRID_SIZE+j+1] = 1.0/maxLen;
+				continue;	// can't subdivide any more
+			}
+
+			if ( maxLen <= r_subdivisions->value ) {
+				errorTable[dir*MAX_GRID_SIZE+j+1] = 1.0/maxLen;
+				continue;	// didn't need subdivision
+			}
+
+			errorTable[dir*MAX_GRID_SIZE+j+2] = 1.0/maxLen;
+
+			// insert two columns and replace the peak
+			width += 2;
+			for ( i = 0 ; i < height ; i++ ) {
+				LerpDrawVert( &ctrl[i*MAX_GRID_SIZE+j], &ctrl[i*MAX_GRID_SIZE+j+1], &prev );
+				LerpDrawVert( &ctrl[i*MAX_GRID_SIZE+j+1], &ctrl[i*MAX_GRID_SIZE+j+2], &next );
+				LerpDrawVert( &prev, &next, &mid );
+
+				for ( k = width - 1 ; k > j + 3 ; k-- ) {
+					ctrl[i*MAX_GRID_SIZE+k] = ctrl[i*MAX_GRID_SIZE+k-2];
+				}
+				ctrl[i*MAX_GRID_SIZE+j + 1] = prev;
+				ctrl[i*MAX_GRID_SIZE+j + 2] = mid;
+				ctrl[i*MAX_GRID_SIZE+j + 3] = next;
+			}
+
+			// back up and recheck this set again, it may need more subdivision
+			j -= 2;
+
+		}
+
+		Transpose( width, height, ctrl );
+		t = width;
+		width = height;
+		height = t;
+	}
+
+
+	// put all the aproximating points on the curve
+	PutPointsOnCurve( ctrl, width, height );
+
+	// cull out any rows or columns that are colinear
+	for ( i = 1 ; i < width-1 ; i++ ) {
+		if ( errorTable[0*MAX_GRID_SIZE+i] != 999 ) {
+			continue;
+		}
+		for ( j = i+1 ; j < width ; j++ ) {
+			for ( k = 0 ; k < height ; k++ ) {
+				ctrl[k*MAX_GRID_SIZE+j-1] = ctrl[k*MAX_GRID_SIZE+j];
+			}
+			errorTable[0*MAX_GRID_SIZE+j-1] = errorTable[0*MAX_GRID_SIZE+j];
+		}
+		width--;
+	}
+
+	for ( i = 1 ; i < height-1 ; i++ ) {
+		if ( errorTable[1*MAX_GRID_SIZE+i] != 999 ) {
+			continue;
+		}
+		for ( j = i+1 ; j < height ; j++ ) {
+			for ( k = 0 ; k < width ; k++ ) {
+				ctrl[(j-1)*MAX_GRID_SIZE+k] = ctrl[j*MAX_GRID_SIZE+k];
+			}
+			errorTable[1*MAX_GRID_SIZE+j-1] = errorTable[1*MAX_GRID_SIZE+j];
+		}
+		height--;
+	}
+
+#if 1
+	// flip for longest tristrips as an optimization
+	// the results should be visually identical with or
+	// without this step
+	if ( height > width ) {
+		Transpose( width, height, ctrl );
+		InvertErrorTable( errorTable, width, height );
+		t = width;
+		width = height;
+		height = t;
+		InvertCtrl( width, height, ctrl );
+	}
+#endif
+
+	// calculate normals
+	MakeMeshNormals( width, height, ctrl );
+
+	// copy the results out to a grid
+	grid = (struct srfGridMesh_s *) Hunk_Alloc( (width * height - 1) * sizeof( drawVert_t ) + sizeof( *grid ) + width * 4 + height * 4, h_low );
+
+	grid->widthLodError = (float*)(((char*)grid) + (width * height - 1) *
+		sizeof(drawVert_t) + sizeof(*grid));
+	memcpy( grid->widthLodError, &errorTable[0*MAX_GRID_SIZE], width * 4 );
+
+	grid->heightLodError = (float*)(((char*)grid->widthLodError) + width * 4);
+	memcpy( grid->heightLodError, &errorTable[1*MAX_GRID_SIZE], height * 4 );
+
+	grid->width = width;
+	grid->height = height;
+	grid->surfaceType = SF_GRID;
+	ClearBounds( grid->meshBounds[0], grid->meshBounds[1] );
+	for ( i = 0 ; i < width ; i++ ) {
+		for ( j = 0 ; j < height ; j++ ) {
+			vert = &grid->verts[j*width+i];
+			*vert = ctrl[j*MAX_GRID_SIZE+i];
+			AddPointToBounds( vert->xyz, grid->meshBounds[0], grid->meshBounds[1] );
+		}
+	}
+
+	// compute local origin and bounds
+	VectorAdd( grid->meshBounds[0], grid->meshBounds[1], grid->localOrigin );
+	VectorScale( grid->localOrigin, 0.5f, grid->localOrigin );
+	VectorSubtract( grid->meshBounds[0], grid->localOrigin, tmpVec );
+	grid->meshRadius = VectorLength( tmpVec );
+
+	VectorCopy( grid->localOrigin, grid->lodOrigin );
+	grid->lodRadius = grid->meshRadius;
+
+	return grid;
+}
diff --git a/codemp/renderer/tr_flares.cpp b/codemp/renderer/tr_flares.cpp
new file mode 100644
index 0000000..38eb89d
--- /dev/null
+++ b/codemp/renderer/tr_flares.cpp
@@ -0,0 +1,428 @@
+// tr_flares.c
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+#include "tr_local.h"
+
+/*
+=============================================================================
+
+LIGHT FLARES
+
+A light flare is an effect that takes place inside the eye when bright light
+sources are visible.  The size of the flare reletive to the screen is nearly
+constant, irrespective of distance, but the intensity should be proportional to the
+projected area of the light source.
+
+A surface that has been flagged as having a light flare will calculate the depth
+buffer value that it's midpoint should have when the surface is added.
+
+After all opaque surfaces have been rendered, the depth buffer is read back for
+each flare in view.  If the point has not been obscured by a closer surface, the
+flare should be drawn.
+
+Surfaces that have a repeated texture should never be flagged as flaring, because
+there will only be a single flare added at the midpoint of the polygon.
+
+To prevent abrupt popping, the intensity of the flare is interpolated up and
+down as it changes visibility.  This involves scene to scene state, unlike almost
+all other aspects of the renderer, and is complicated by the fact that a single
+frame may have multiple scenes.
+
+RB_RenderFlares() will be called once per view (twice in a mirrored scene, potentially
+up to five or more times in a frame with 3D status bar icons).
+
+=============================================================================
+*/
+
+
+// flare states maintain visibility over multiple frames for fading
+// layers: view, mirror, menu
+typedef struct flare_s {
+	struct		flare_s	*next;		// for active chain
+
+	int			addedFrame;
+
+	qboolean	inPortal;				// true if in a portal view of the scene
+	int			frameSceneNum;
+	void		*surface;
+	int			fogNum;
+
+	int			fadeTime;
+
+	qboolean	visible;			// state of last test
+	float		drawIntensity;		// may be non 0 even if !visible due to fading
+
+	int			windowX, windowY;
+	float		eyeZ;
+
+	vec3_t		color;
+} flare_t;
+
+#define		MAX_FLARES		128
+
+flare_t		r_flareStructs[MAX_FLARES];
+flare_t		*r_activeFlares, *r_inactiveFlares;
+
+/*
+==================
+R_ClearFlares
+==================
+*/
+void R_ClearFlares( void ) {
+	int		i;
+
+	Com_Memset( r_flareStructs, 0, sizeof( r_flareStructs ) );
+	r_activeFlares = NULL;
+	r_inactiveFlares = NULL;
+
+	for ( i = 0 ; i < MAX_FLARES ; i++ ) {
+		r_flareStructs[i].next = r_inactiveFlares;
+		r_inactiveFlares = &r_flareStructs[i];
+	}
+}
+
+
+/*
+==================
+RB_AddFlare
+
+This is called at surface tesselation time
+==================
+*/
+void RB_AddFlare( void *surface, int fogNum, vec3_t point, vec3_t color, vec3_t normal ) {
+	int				i;
+	flare_t			*f, *oldest;
+	vec3_t			local;
+	float			d;
+	vec4_t			eye, clip, normalized, window;
+
+	backEnd.pc.c_flareAdds++;
+
+	// if the point is off the screen, don't bother adding it
+	// calculate screen coordinates and depth
+	R_TransformModelToClip( point, backEnd.ori.modelMatrix, 
+		backEnd.viewParms.projectionMatrix, eye, clip );
+
+	// check to see if the point is completely off screen
+	for ( i = 0 ; i < 3 ; i++ ) {
+		if ( clip[i] >= clip[3] || clip[i] <= -clip[3] ) {
+			return;
+		}
+	}
+
+	R_TransformClipToWindow( clip, &backEnd.viewParms, normalized, window );
+
+	if ( window[0] < 0 || window[0] >= backEnd.viewParms.viewportWidth
+		|| window[1] < 0 || window[1] >= backEnd.viewParms.viewportHeight ) {
+		return;	// shouldn't happen, since we check the clip[] above, except for FP rounding
+	}
+
+	// see if a flare with a matching surface, scene, and view exists
+	oldest = r_flareStructs;
+	for ( f = r_activeFlares ; f ; f = f->next ) {
+		if ( f->surface == surface && f->frameSceneNum == backEnd.viewParms.frameSceneNum
+			&& f->inPortal == backEnd.viewParms.isPortal ) {
+			break;
+		}
+	}
+
+	// allocate a new one
+	if (!f ) {
+		if ( !r_inactiveFlares ) {
+			// the list is completely full
+			return;
+		}
+		f = r_inactiveFlares;
+		r_inactiveFlares = r_inactiveFlares->next;
+		f->next = r_activeFlares;
+		r_activeFlares = f;
+
+		f->surface = surface;
+		f->frameSceneNum = backEnd.viewParms.frameSceneNum;
+		f->inPortal = backEnd.viewParms.isPortal;
+		f->addedFrame = -1;
+	}
+
+	if ( f->addedFrame != backEnd.viewParms.frameCount - 1 ) {
+		f->visible = qfalse;
+		f->fadeTime = backEnd.refdef.time - 2000;
+	}
+
+	f->addedFrame = backEnd.viewParms.frameCount;
+	f->fogNum = fogNum;
+
+	VectorCopy( color, f->color );
+
+	// fade the intensity of the flare down as the
+	// light surface turns away from the viewer
+	if ( normal ) {
+		VectorSubtract( backEnd.viewParms.ori.origin, point, local );
+		VectorNormalizeFast( local );
+		d = DotProduct( local, normal );
+		VectorScale( f->color, d, f->color ); 
+	}
+
+	// save info needed to test
+	f->windowX = backEnd.viewParms.viewportX + window[0];
+	f->windowY = backEnd.viewParms.viewportY + window[1];
+
+	f->eyeZ = eye[2];
+}
+
+/*
+==================
+RB_AddDlightFlares
+==================
+*/
+void RB_AddDlightFlares( void ) {
+	dlight_t		*l;
+	int				i, j, k;
+	fog_t			*fog;
+
+	if ( !r_flares->integer ) {
+		return;
+	}
+
+	l = backEnd.refdef.dlights;
+	fog = tr.world->fogs;
+	for (i=0 ; i<backEnd.refdef.num_dlights ; i++, l++) {
+
+		// find which fog volume the light is in 
+		for ( j = 1 ; j < tr.world->numfogs ; j++ ) {
+			fog = &tr.world->fogs[j];
+			for ( k = 0 ; k < 3 ; k++ ) {
+				if ( l->origin[k] < fog->bounds[0][k] || l->origin[k] > fog->bounds[1][k] ) {
+					break;
+				}
+			}
+			if ( k == 3 ) {
+				break;
+			}
+		}
+		if ( j == tr.world->numfogs ) {
+			j = 0;
+		}
+
+		RB_AddFlare( (void *)l, j, l->origin, l->color, NULL );
+	}
+}
+
+/*
+===============================================================================
+
+FLARE BACK END
+
+===============================================================================
+*/
+
+/*
+==================
+RB_TestFlare
+==================
+*/
+void RB_TestFlare( flare_t *f ) {
+	float			depth;
+	qboolean		visible;
+	float			fade;
+	float			screenZ;
+
+	backEnd.pc.c_flareTests++;
+
+	// doing a readpixels is as good as doing a glFinish(), so
+	// don't bother with another sync
+	glState.finishCalled = qfalse;
+
+	// read back the z buffer contents
+	qglReadPixels( f->windowX, f->windowY, 1, 1, GL_DEPTH_COMPONENT, GL_FLOAT, &depth );
+
+	screenZ = backEnd.viewParms.projectionMatrix[14] / 
+		( ( 2*depth - 1 ) * backEnd.viewParms.projectionMatrix[11] - backEnd.viewParms.projectionMatrix[10] );
+
+	visible = (qboolean)(( -f->eyeZ - -screenZ ) < 24);
+
+	if ( visible ) {
+		if ( !f->visible ) {
+			f->visible = qtrue;
+			f->fadeTime = backEnd.refdef.time - 1;
+		}
+		fade = ( ( backEnd.refdef.time - f->fadeTime ) /1000.0f ) * r_flareFade->value;
+	} else {
+		if ( f->visible ) {
+			f->visible = qfalse;
+			f->fadeTime = backEnd.refdef.time - 1;
+		}
+		fade = 1.0f - ( ( backEnd.refdef.time - f->fadeTime ) / 1000.0f ) * r_flareFade->value;
+	}
+
+	if ( fade < 0 ) {
+		fade = 0;
+	}
+	if ( fade > 1 ) {
+		fade = 1;
+	}
+
+	f->drawIntensity = fade;
+}
+
+
+/*
+==================
+RB_RenderFlare
+==================
+*/
+void RB_RenderFlare( flare_t *f ) {
+	float			size;
+	vec3_t			color;
+	int				iColor[3];
+
+	backEnd.pc.c_flareRenders++;
+
+	VectorScale( f->color, f->drawIntensity*tr.identityLight, color );
+	iColor[0] = color[0] * 255;
+	iColor[1] = color[1] * 255;
+	iColor[2] = color[2] * 255;
+
+	size = backEnd.viewParms.viewportWidth * ( r_flareSize->value/640.0f + 8 / -f->eyeZ );
+
+	RB_BeginSurface( tr.flareShader, f->fogNum );
+
+	// FIXME: use quadstamp?
+	tess.xyz[tess.numVertexes][0] = f->windowX - size;
+	tess.xyz[tess.numVertexes][1] = f->windowY - size;
+	tess.texCoords[tess.numVertexes][0][0] = 0;
+	tess.texCoords[tess.numVertexes][0][1] = 0;
+	tess.vertexColors[tess.numVertexes][0] = iColor[0];
+	tess.vertexColors[tess.numVertexes][1] = iColor[1];
+	tess.vertexColors[tess.numVertexes][2] = iColor[2];
+	tess.vertexColors[tess.numVertexes][3] = 255;
+	tess.numVertexes++;
+
+	tess.xyz[tess.numVertexes][0] = f->windowX - size;
+	tess.xyz[tess.numVertexes][1] = f->windowY + size;
+	tess.texCoords[tess.numVertexes][0][0] = 0;
+	tess.texCoords[tess.numVertexes][0][1] = 1;
+	tess.vertexColors[tess.numVertexes][0] = iColor[0];
+	tess.vertexColors[tess.numVertexes][1] = iColor[1];
+	tess.vertexColors[tess.numVertexes][2] = iColor[2];
+	tess.vertexColors[tess.numVertexes][3] = 255;
+	tess.numVertexes++;
+
+	tess.xyz[tess.numVertexes][0] = f->windowX + size;
+	tess.xyz[tess.numVertexes][1] = f->windowY + size;
+	tess.texCoords[tess.numVertexes][0][0] = 1;
+	tess.texCoords[tess.numVertexes][0][1] = 1;
+	tess.vertexColors[tess.numVertexes][0] = iColor[0];
+	tess.vertexColors[tess.numVertexes][1] = iColor[1];
+	tess.vertexColors[tess.numVertexes][2] = iColor[2];
+	tess.vertexColors[tess.numVertexes][3] = 255;
+	tess.numVertexes++;
+
+	tess.xyz[tess.numVertexes][0] = f->windowX + size;
+	tess.xyz[tess.numVertexes][1] = f->windowY - size;
+	tess.texCoords[tess.numVertexes][0][0] = 1;
+	tess.texCoords[tess.numVertexes][0][1] = 0;
+	tess.vertexColors[tess.numVertexes][0] = iColor[0];
+	tess.vertexColors[tess.numVertexes][1] = iColor[1];
+	tess.vertexColors[tess.numVertexes][2] = iColor[2];
+	tess.vertexColors[tess.numVertexes][3] = 255;
+	tess.numVertexes++;
+
+	tess.indexes[tess.numIndexes++] = 0;
+	tess.indexes[tess.numIndexes++] = 1;
+	tess.indexes[tess.numIndexes++] = 2;
+	tess.indexes[tess.numIndexes++] = 0;
+	tess.indexes[tess.numIndexes++] = 2;
+	tess.indexes[tess.numIndexes++] = 3;
+
+	RB_EndSurface();
+}
+
+/*
+==================
+RB_RenderFlares
+
+Because flares are simulating an occular effect, they should be drawn after
+everything (all views) in the entire frame has been drawn.
+
+Because of the way portals use the depth buffer to mark off areas, the
+needed information would be lost after each view, so we are forced to draw
+flares after each view.
+
+The resulting artifact is that flares in mirrors or portals don't dim properly
+when occluded by something in the main view, and portal flares that should
+extend past the portal edge will be overwritten.
+==================
+*/
+void RB_RenderFlares (void) {
+	flare_t		*f;
+	flare_t		**prev;
+	qboolean	draw;
+
+	if ( !r_flares->integer ) {
+		return;
+	}
+
+//	RB_AddDlightFlares();
+
+	// perform z buffer readback on each flare in this view
+	draw = qfalse;
+	prev = &r_activeFlares;
+	while ( ( f = *prev ) != NULL ) {
+		// throw out any flares that weren't added last frame
+		if ( f->addedFrame < backEnd.viewParms.frameCount - 1 ) {
+			*prev = f->next;
+			f->next = r_inactiveFlares;
+			r_inactiveFlares = f;
+			continue;
+		}
+
+		// don't draw any here that aren't from this scene / portal
+		f->drawIntensity = 0;
+		if ( f->frameSceneNum == backEnd.viewParms.frameSceneNum
+			&& f->inPortal == backEnd.viewParms.isPortal ) {
+			RB_TestFlare( f );
+			if ( f->drawIntensity ) {
+				draw = qtrue;
+			} else {
+				// this flare has completely faded out, so remove it from the chain
+				*prev = f->next;
+				f->next = r_inactiveFlares;
+				r_inactiveFlares = f;
+				continue;
+			}
+		}
+
+		prev = &f->next;
+	}
+
+	if ( !draw ) {
+		return;		// none visible
+	}
+
+	if ( backEnd.viewParms.isPortal ) {
+		qglDisable (GL_CLIP_PLANE0);
+	}
+
+	qglPushMatrix();
+    qglLoadIdentity();
+	qglMatrixMode( GL_PROJECTION );
+	qglPushMatrix();
+    qglLoadIdentity();
+	qglOrtho( backEnd.viewParms.viewportX, backEnd.viewParms.viewportX + backEnd.viewParms.viewportWidth,
+			  backEnd.viewParms.viewportY, backEnd.viewParms.viewportY + backEnd.viewParms.viewportHeight,
+			  -99999, 99999 );
+
+	for ( f = r_activeFlares ; f ; f = f->next ) {
+		if ( f->frameSceneNum == backEnd.viewParms.frameSceneNum
+			&& f->inPortal == backEnd.viewParms.isPortal
+			&& f->drawIntensity ) {
+			RB_RenderFlare( f );
+		}
+	}
+
+	qglPopMatrix();
+	qglMatrixMode( GL_MODELVIEW );
+	qglPopMatrix();
+}
+
diff --git a/codemp/renderer/tr_font.cpp b/codemp/renderer/tr_font.cpp
new file mode 100644
index 0000000..72f2952
--- /dev/null
+++ b/codemp/renderer/tr_font.cpp
@@ -0,0 +1,1714 @@
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+#include "../qcommon/sstring.h"	// stl string class won't compile in here (MS shite), so use Gil's.
+#include "tr_local.h"
+#include "tr_font.h"
+
+#include "../qcommon/stringed_ingame.h"
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////
+//
+// This file is shared in the single and multiplayer codebases, so be CAREFUL WHAT YOU ADD/CHANGE!!!!!
+//
+/////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+typedef enum
+{
+	eWestern,	// ( I only care about asian languages in here at the moment )
+	eRussian,	//  .. but now I need to care about this, since it uses a different TP
+	ePolish,	// ditto
+	eKorean,
+	eTaiwanese,	// 15x15 glyphs tucked against BR of 16x16 space
+	eJapanese,	// 15x15 glyphs tucked against TL of 16x16 space
+	eChinese,	// 15x15 glyphs tucked against TL of 16x16 space
+	eThai,		// 16x16 cells with glyphs against left edge, special file (tha_widths.dat) for variable widths
+} Language_e;
+
+// this is to cut down on all the stupid string compares I've been doing, and convert asian stuff to switch-case
+//
+Language_e GetLanguageEnum()
+{
+	static int			iSE_Language_ModificationCount = -1234;	// any old silly value that won't match the cvar mod count
+	static Language_e	eLanguage = eWestern;
+
+	// only re-strcmp() when language string has changed from what we knew it as...
+	//
+	if (iSE_Language_ModificationCount != se_language->modificationCount )
+	{
+		iSE_Language_ModificationCount  = se_language->modificationCount;
+
+				if ( Language_IsRussian()	)	eLanguage = eRussian;
+		else	if ( Language_IsPolish()	)	eLanguage = ePolish;
+		else	if ( Language_IsKorean()	)	eLanguage = eKorean;
+		else	if ( Language_IsTaiwanese()	)	eLanguage = eTaiwanese;
+		else	if ( Language_IsJapanese()	)	eLanguage = eJapanese;
+		else	if ( Language_IsChinese()	)	eLanguage = eChinese;
+		else	if ( Language_IsThai()		)	eLanguage = eThai;
+		else	eLanguage = eWestern;
+	}
+
+	return eLanguage;
+}
+
+struct SBCSOverrideLanguages_t
+{
+	LPCSTR		m_psName;
+	Language_e	m_eLanguage;
+};
+
+// so I can do some stuff with for-next loops when I add polish etc...
+//
+SBCSOverrideLanguages_t g_SBCSOverrideLanguages[]=
+{
+	{"russian",	eRussian},
+	{"polish",	ePolish},
+	{NULL,		eWestern}
+};
+
+
+
+//================================================
+//
+
+#define sFILENAME_THAI_WIDTHS	"fonts/tha_widths.dat"
+#define sFILENAME_THAI_CODES	"fonts/tha_codes.dat"
+
+struct ThaiCodes_t
+{
+	map <int, int>	m_mapValidCodes;
+	vector<int>		m_viGlyphWidths;	
+	string			m_strInitFailureReason;	// so we don't have to keep retrying to work this out
+
+	void Clear( void )
+	{
+		m_mapValidCodes.clear();
+		m_viGlyphWidths.clear();		
+		m_strInitFailureReason = "";	// if blank, never failed, else says don't bother re-trying
+	}
+
+	ThaiCodes_t()
+	{
+		Clear();
+	}
+
+	// convert a supplied 1,2 or 3-byte multiplied-up integer into a valid 0..n index, else -1...
+	//
+	int GetValidIndex( int iCode )
+	{
+		map <int,int>::iterator it = m_mapValidCodes.find( iCode );
+		if (it != m_mapValidCodes.end())
+		{
+            return (*it).second;
+		}
+
+		return -1;
+	}
+
+	int GetWidth( int iGlyphIndex )
+	{
+		if (iGlyphIndex < m_viGlyphWidths.size())
+		{
+			return m_viGlyphWidths[ iGlyphIndex ];
+		}
+
+		assert(0);
+		return 0;
+	}
+
+	// return is error message to display, or NULL for success
+	const char *Init(void)
+	{
+		if (m_mapValidCodes.empty() && m_viGlyphWidths.empty())
+		{
+			if (m_strInitFailureReason.empty())	// never tried and failed already?
+			{
+				int *piData = NULL;	// note <int>, not <byte>, for []-access
+				//
+				// read the valid-codes table in...
+				//
+				int iBytesRead = FS_ReadFile( sFILENAME_THAI_CODES, (void **) &piData );
+				if (iBytesRead > 0 && !(iBytesRead&3))	// valid length and multiple of 4 bytes long
+				{
+					int iTableEntries = iBytesRead / sizeof(int);
+					
+					for (int i=0; i < iTableEntries; i++)
+					{
+						m_mapValidCodes[ piData[i] ] = i;	// convert MBCS code to sequential index...
+					}
+					FS_FreeFile( piData );	// dispose of original
+
+					// now read in the widths... (I'll keep these in a simple STL vector, so they'all disappear when the <map> entries do...
+					//		
+					iBytesRead = FS_ReadFile( sFILENAME_THAI_WIDTHS, (void **) &piData );
+					if (iBytesRead > 0 && !(iBytesRead&3) && iBytesRead>>2/*sizeof(int)*/ == iTableEntries)
+					{
+						for (int i=0; i<iTableEntries; i++)
+						{
+							m_viGlyphWidths.push_back( piData[i] );
+						}
+						FS_FreeFile( piData );	// dispose of original
+					}
+					else
+					{
+						m_strInitFailureReason = va("Error with file \"%s\", size = %d!\n", sFILENAME_THAI_WIDTHS, iBytesRead);
+					}
+				}
+				else
+				{
+					m_strInitFailureReason = va("Error with file \"%s\", size = %d!\n", sFILENAME_THAI_CODES, iBytesRead);
+				}
+			}
+		}
+
+		return m_strInitFailureReason.c_str();
+	}
+};
+
+
+#define GLYPH_MAX_KOREAN_SHADERS	3
+#define GLYPH_MAX_TAIWANESE_SHADERS 4
+#define GLYPH_MAX_JAPANESE_SHADERS	3
+#define GLYPH_MAX_CHINESE_SHADERS	3
+#define GLYPH_MAX_THAI_SHADERS		3
+#define GLYPH_MAX_ASIAN_SHADERS		4	// this MUST equal the larger of the above defines
+
+class CFontInfo
+{
+private:
+	// From the fontdat file
+	glyphInfo_t		mGlyphs[GLYPH_COUNT];
+
+//	int				mAsianHack;				// unused junk from John's fontdat file format.
+	// end of fontdat data
+
+	int				mShader;   				// handle to the shader with the glyph
+	
+	int				m_hAsianShaders[GLYPH_MAX_ASIAN_SHADERS];	// shaders for Korean glyphs where applicable		
+	glyphInfo_t		m_AsianGlyph;			// special glyph containing asian->western scaling info for all glyphs
+	int				m_iAsianGlyphsAcross;	// needed to dynamically calculate S,T coords
+	int				m_iAsianPagesLoaded;
+	bool			m_bAsianLastPageHalfHeight;
+	int				m_iLanguageModificationCount;	// doesn't matter what this is, so long as it's comparable as being changed
+
+	ThaiCodes_t		*m_pThaiData;
+
+public:
+	char			m_sFontName[MAX_QPATH];	// eg "fonts/lcd"	// needed for korean font-hint if we need >1 hangul set
+	int				mPointSize;
+	int				mHeight;
+	int				mAscender;
+	int				mDescender;
+
+	bool			mbRoundCalcs;	// trying to make this !@#$%^ thing work with scaling
+	int				m_iThisFont;	// handle to itself
+	int				m_iAltSBCSFont;	// -1 == NULL // alternative single-byte font for languages like russian/polish etc that need to override high characters ?
+	int				m_iOriginalFontWhenSBCSOverriden;
+	float			m_fAltSBCSFontScaleFactor;	// -1, else amount to adjust returned values by to make them fit the master western font they're substituting for
+	bool			m_bIsFakeAlienLanguage;	// ... if true, don't process as MBCS or override as SBCS etc
+
+	CFontInfo(const char *fontName);
+//	CFontInfo(int fill) { memset(this, fill, sizeof(*this)); }	// wtf?
+	~CFontInfo(void) {}	
+
+	const int GetPointSize(void) const { return(mPointSize); }
+	const int GetHeight(void) const { return(mHeight); }
+	const int GetAscender(void) const { return(mAscender); }
+	const int GetDescender(void) const { return(mDescender); }
+
+	const glyphInfo_t *GetLetter(const unsigned int uiLetter, int *piShader = NULL);
+	const int GetCollapsedAsianCode(ulong uiLetter) const;
+
+	const int GetLetterWidth(const unsigned int uiLetter);
+	const int GetLetterHorizAdvance(const unsigned int uiLetter);
+	const int GetShader(void) const { return(mShader); }
+
+	void FlagNoAsianGlyphs(void) { m_hAsianShaders[0] = 0; m_iLanguageModificationCount = -1; }	// used during constructor
+	bool AsianGlyphsAvailable(void) const { return !!(m_hAsianShaders[0]); }
+
+	void UpdateAsianIfNeeded( bool bForceReEval = false);	
+};
+
+//================================================
+
+
+
+
+// round float to one decimal place...
+//
+float RoundTenth( float fValue )
+{
+	return ( floorf( (fValue*10.0f) + 0.5f) ) / 10.0f;
+}
+
+
+int							g_iCurrentFontIndex;	// entry 0 is reserved index for missing/invalid, else ++ with each new font registered
+vector<CFontInfo *>			g_vFontArray;
+typedef map<sstring_t, int>	FontIndexMap_t;
+							FontIndexMap_t g_mapFontIndexes;
+int g_iNonScaledCharRange;	// this is used with auto-scaling of asian fonts, anything below this number is preserved in scale, anything above is scaled down by 0.75f
+
+//paletteRGBA_c				lastcolour;
+
+// =============================== some korean stuff =======================================
+
+#define KSC5601_HANGUL_HIBYTE_START		0xB0	// range is...
+#define KSC5601_HANGUL_HIBYTE_STOP		0xC8	// ... inclusive
+#define KSC5601_HANGUL_LOBYTE_LOBOUND	0xA0	// range is...
+#define KSC5601_HANGUL_LOBYTE_HIBOUND	0xFF	// ...bounding (ie only valid in between these points, but NULLs in charsets for these codes)
+#define KSC5601_HANGUL_CODES_PER_ROW	96		// 2 more than the number of glyphs
+
+extern qboolean Language_IsKorean( void );
+
+static inline bool Korean_ValidKSC5601Hangul( byte _iHi, byte _iLo )
+{
+	return (_iHi >=KSC5601_HANGUL_HIBYTE_START		&&
+			_iHi <=KSC5601_HANGUL_HIBYTE_STOP		&&
+			_iLo > KSC5601_HANGUL_LOBYTE_LOBOUND	&&
+			_iLo < KSC5601_HANGUL_LOBYTE_HIBOUND
+			);
+}
+
+static inline bool Korean_ValidKSC5601Hangul( unsigned int uiCode )
+{
+	return Korean_ValidKSC5601Hangul( uiCode >> 8, uiCode & 0xFF );
+}
+
+
+// takes a KSC5601 double-byte hangul code and collapses down to a 0..n glyph index...
+// Assumes rows are 96 wide (glyph slots), not 94 wide (actual glyphs), so I can ignore boundary markers
+//
+// (invalid hangul codes will return 0)
+//
+static int Korean_CollapseKSC5601HangulCode(unsigned int uiCode)
+{
+	if (Korean_ValidKSC5601Hangul( uiCode ))
+	{
+		uiCode -= (KSC5601_HANGUL_HIBYTE_START * 256) + KSC5601_HANGUL_LOBYTE_LOBOUND;	// sneaky maths on both bytes, reduce to 0x0000 onwards
+		uiCode  = ((uiCode >> 8) * KSC5601_HANGUL_CODES_PER_ROW) + (uiCode & 0xFF);
+		return uiCode;
+	}
+	return 0;
+}
+
+static int Korean_InitFields(int &iGlyphTPs, LPCSTR &psLang)
+{
+	psLang		= "kor";
+	iGlyphTPs	= GLYPH_MAX_KOREAN_SHADERS;
+	g_iNonScaledCharRange = 255;
+	return 32;	// m_iAsianGlyphsAcross
+}
+
+// ======================== some taiwanese stuff ==============================
+
+// (all ranges inclusive for Big5)...
+//
+#define BIG5_HIBYTE_START0		0xA1	// (misc chars + level 1 hanzi)
+#define BIG5_HIBYTE_STOP0		0xC6	// 
+#define BIG5_HIBYTE_START1		0xC9	// (level 2 hanzi)
+#define BIG5_HIBYTE_STOP1		0xF9	// 
+#define BIG5_LOBYTE_LOBOUND0	0x40	// 
+#define BIG5_LOBYTE_HIBOUND0	0x7E	// 
+#define BIG5_LOBYTE_LOBOUND1	0xA1	// 
+#define BIG5_LOBYTE_HIBOUND1	0xFE	// 
+#define BIG5_CODES_PER_ROW		160		// 3 more than the number of glyphs
+
+extern qboolean Language_IsTaiwanese( void );
+
+static bool Taiwanese_ValidBig5Code( unsigned int uiCode )
+{
+	const byte _iHi = (uiCode >> 8)&0xFF;
+	if (	(_iHi >= BIG5_HIBYTE_START0 && _iHi <= BIG5_HIBYTE_STOP0)
+		||	(_iHi >= BIG5_HIBYTE_START1 && _iHi <= BIG5_HIBYTE_STOP1)
+		)
+	{
+		const byte _iLo = uiCode & 0xFF;
+
+		if ( (_iLo >= BIG5_LOBYTE_LOBOUND0 && _iLo <= BIG5_LOBYTE_HIBOUND0) ||
+			 (_iLo >= BIG5_LOBYTE_LOBOUND1 && _iLo <= BIG5_LOBYTE_HIBOUND1)
+			)
+		{
+			return true;
+		}
+	}
+
+	return false;
+}
+
+
+// only call this when Taiwanese_ValidBig5Code() has already returned true...
+//
+static bool Taiwanese_IsTrailingPunctuation( unsigned int uiCode )
+{
+	// so far I'm just counting the first 21 chars, those seem to be all the basic punctuation...
+	//
+	if (	uiCode >= ((BIG5_HIBYTE_START0<<8)|BIG5_LOBYTE_LOBOUND0) && 
+			uiCode <  ((BIG5_HIBYTE_START0<<8)|BIG5_LOBYTE_LOBOUND0+20)
+		)
+	{
+		return true;
+	}
+
+	return false;
+}
+
+
+// takes a BIG5 double-byte code (including level 2 hanzi) and collapses down to a 0..n glyph index...
+// Assumes rows are 160 wide (glyph slots), not 157 wide (actual glyphs), so I can ignore boundary markers
+//
+// (invalid big5 codes will return 0)
+//
+static int Taiwanese_CollapseBig5Code( unsigned int uiCode )
+{
+	if (Taiwanese_ValidBig5Code( uiCode ))
+	{			
+		uiCode -= (BIG5_HIBYTE_START0 * 256) + BIG5_LOBYTE_LOBOUND0;	// sneaky maths on both bytes, reduce to 0x0000 onwards
+		if ( (uiCode & 0xFF) >= (BIG5_LOBYTE_LOBOUND1-1)-BIG5_LOBYTE_LOBOUND0)
+		{
+			uiCode -= ((BIG5_LOBYTE_LOBOUND1-1) - (BIG5_LOBYTE_HIBOUND0+1)) -1;
+		}
+		uiCode = ((uiCode >> 8) * BIG5_CODES_PER_ROW) + (uiCode & 0xFF);
+		return uiCode;
+	}
+	return 0;
+}
+
+static int Taiwanese_InitFields(int &iGlyphTPs, LPCSTR &psLang)
+{
+	psLang		= "tai";
+	iGlyphTPs	= GLYPH_MAX_TAIWANESE_SHADERS;
+	g_iNonScaledCharRange = 255;
+	return 64;	// m_iAsianGlyphsAcross
+}
+
+// ======================== some Japanese stuff ==============================
+
+
+// ( all ranges inclusive for Shift-JIS )
+//
+#define SHIFTJIS_HIBYTE_START0	0x81
+#define SHIFTJIS_HIBYTE_STOP0	0x9F
+#define SHIFTJIS_HIBYTE_START1	0xE0
+#define SHIFTJIS_HIBYTE_STOP1	0xEF
+//
+#define SHIFTJIS_LOBYTE_START0	0x40
+#define SHIFTJIS_LOBYTE_STOP0	0x7E
+#define SHIFTJIS_LOBYTE_START1	0x80
+#define SHIFTJIS_LOBYTE_STOP1	0xFC
+#define SHIFTJIS_CODES_PER_ROW	(((SHIFTJIS_LOBYTE_STOP0-SHIFTJIS_LOBYTE_START0)+1)+((SHIFTJIS_LOBYTE_STOP1-SHIFTJIS_LOBYTE_START1)+1))
+
+
+extern qboolean Language_IsJapanese( void );
+
+static bool Japanese_ValidShiftJISCode( byte _iHi, byte _iLo )
+{
+	if (	(_iHi >= SHIFTJIS_HIBYTE_START0 && _iHi <= SHIFTJIS_HIBYTE_STOP0)
+		||	(_iHi >= SHIFTJIS_HIBYTE_START1 && _iHi <= SHIFTJIS_HIBYTE_STOP1)
+		)
+	{
+		if ( (_iLo >= SHIFTJIS_LOBYTE_START0 && _iLo <= SHIFTJIS_LOBYTE_STOP0) ||
+			 (_iLo >= SHIFTJIS_LOBYTE_START1 && _iLo <= SHIFTJIS_LOBYTE_STOP1)
+			)
+		{
+			return true;
+		}
+	}
+	
+	return false;
+}
+
+static inline bool Japanese_ValidShiftJISCode( unsigned int uiCode )
+{
+	return Japanese_ValidShiftJISCode( uiCode >> 8, uiCode & 0xFF );
+}
+
+
+// only call this when Japanese_ValidShiftJISCode() has already returned true...
+//
+static bool Japanese_IsTrailingPunctuation( unsigned int uiCode )
+{
+	// so far I'm just counting the first 18 chars, those seem to be all the basic punctuation...
+	//
+	if (	uiCode >= ((SHIFTJIS_HIBYTE_START0<<8)|SHIFTJIS_LOBYTE_START0) && 
+			uiCode <  ((SHIFTJIS_HIBYTE_START0<<8)|SHIFTJIS_LOBYTE_START0+18)
+		)
+	{
+		return true;
+	}
+
+	return false;
+}
+
+
+// takes a ShiftJIS double-byte code and collapse down to a 0..n glyph index...
+//
+// (invalid codes will return 0)
+//
+static int Japanese_CollapseShiftJISCode( unsigned int uiCode )
+{
+	if (Japanese_ValidShiftJISCode( uiCode ))
+	{	
+		uiCode -= ((SHIFTJIS_HIBYTE_START0<<8)|SHIFTJIS_LOBYTE_START0);	// sneaky maths on both bytes, reduce to 0x0000 onwards
+		
+		if ( (uiCode & 0xFF) >= (SHIFTJIS_LOBYTE_START1)-SHIFTJIS_LOBYTE_START0)
+		{
+			uiCode -= ((SHIFTJIS_LOBYTE_START1)-SHIFTJIS_LOBYTE_STOP0)-1;
+		}
+
+		if ( ((uiCode>>8)&0xFF) >= (SHIFTJIS_HIBYTE_START1)-SHIFTJIS_HIBYTE_START0)
+		{
+			uiCode -= (((SHIFTJIS_HIBYTE_START1)-SHIFTJIS_HIBYTE_STOP0)-1) << 8;
+		}
+
+		uiCode = ((uiCode >> 8) * SHIFTJIS_CODES_PER_ROW) + (uiCode & 0xFF);
+
+		return uiCode;
+	}
+	return 0;
+}
+
+
+static int Japanese_InitFields(int &iGlyphTPs, LPCSTR &psLang)
+{
+	psLang		= "jap";
+	iGlyphTPs	= GLYPH_MAX_JAPANESE_SHADERS;
+	g_iNonScaledCharRange = 255;
+	return 64;	// m_iAsianGlyphsAcross
+}
+
+// ======================== some Chinese stuff ==============================
+
+#define GB_HIBYTE_START		0xA1	// range is...       
+#define GB_HIBYTE_STOP		0xF7	// ... inclusive     
+#define GB_LOBYTE_LOBOUND	0xA0	// range is...                                                                                
+#define GB_LOBYTE_HIBOUND	0xFF	// ...bounding (ie only valid in between these points, but NULLs in charsets for these codes) 
+#define GB_CODES_PER_ROW	95		// 1 more than the number of glyphs
+
+extern qboolean Language_IsChinese( void );
+
+static inline bool Chinese_ValidGBCode( byte _iHi, byte _iLo )
+{
+	return (_iHi >=GB_HIBYTE_START		&&
+			_iHi <=GB_HIBYTE_STOP		&&
+			_iLo > GB_LOBYTE_LOBOUND	&&
+			_iLo < GB_LOBYTE_HIBOUND
+			);
+}
+
+static inline bool Chinese_ValidGBCode( unsigned int uiCode)
+{
+	return Chinese_ValidGBCode( uiCode >> 8, uiCode & 0xFF );
+}
+
+
+// only call this when Chinese_ValidGBCode() has already returned true...
+//
+static bool Chinese_IsTrailingPunctuation( unsigned int uiCode )
+{
+	// so far I'm just counting the first 13 chars, those seem to be all the basic punctuation...
+	//
+	if (	uiCode >  ((GB_HIBYTE_START<<8)|GB_LOBYTE_LOBOUND) && 
+			uiCode <  ((GB_HIBYTE_START<<8)|GB_LOBYTE_LOBOUND+14)
+		)
+	{
+		return true;
+	}
+
+	return false;
+}
+
+
+// takes a GB double-byte code and collapses down to a 0..n glyph index...
+// Assumes rows are 96 wide (glyph slots), not 94 wide (actual glyphs), so I can ignore boundary markers
+//
+// (invalid GB codes will return 0)
+//
+static int Chinese_CollapseGBCode( unsigned int uiCode )
+{
+	if (Chinese_ValidGBCode( uiCode ))
+	{			
+		uiCode -= (GB_HIBYTE_START * 256) + GB_LOBYTE_LOBOUND;	// sneaky maths on both bytes, reduce to 0x0000 onwards
+		uiCode  = ((uiCode >> 8) * GB_CODES_PER_ROW) + (uiCode & 0xFF);		
+		return uiCode;
+	}
+
+	return 0;
+}
+
+static int Chinese_InitFields(int &iGlyphTPs, LPCSTR &psLang)
+{
+	psLang		= "chi";
+	iGlyphTPs	= GLYPH_MAX_CHINESE_SHADERS;
+	g_iNonScaledCharRange = 255;
+	return 64;	// m_iAsianGlyphsAcross
+}
+
+// ======================== some Thai stuff ==============================
+
+//TIS 620-2533
+
+#define TIS_GLYPHS_START	160
+#define TIS_SARA_AM			0xD3		// special case letter, both a new letter and a trailing accent for the prev one
+ThaiCodes_t g_ThaiCodes;	// the one and only instance of this object
+
+extern qboolean Language_IsThai( void );
+
+/*
+static int Thai_IsAccentChar( unsigned int uiCode )
+{
+	switch (uiCode)
+	{
+		case 209:		
+		case 212:	case 213:	case 214:	case 215:	case 216:	case 217:	case 218:
+		case 231:	case 232:	case 233:	case 234:	case 235:	case 236:	case 237:	case 238:
+		return true;
+	}
+	
+	return false;
+}
+*/
+
+// returns a valid Thai code (or 0), based on taking 1,2 or 3 bytes from the supplied byte stream
+//	Fills in <iThaiBytes> with 1,2 or 3
+static int Thai_ValidTISCode( const byte *psString, int &iThaiBytes )
+{	
+	// try a 1-byte code first...
+	//
+	if (psString[0] >= 160)	// so western letters drop through and use normal font
+	{
+		// this code is heavily little-endian, so someone else will need to port for Mac etc... (not my problem ;-)
+		//		
+		union CodeToTry_t
+		{
+            char sChars[4];
+			unsigned int uiCode;
+		};
+		
+		CodeToTry_t CodeToTry;
+		CodeToTry.uiCode = 0;	// important that we clear all 4 bytes in sChars here
+
+		// thai codes can be up to 3 bytes long, so see how high we can get...
+		//
+		for (int i=0; i<3; i++)
+		{			
+			CodeToTry.sChars[i] = psString[i];
+
+            int iIndex = g_ThaiCodes.GetValidIndex( CodeToTry.uiCode );
+			if (iIndex == -1)
+			{
+				// failed, so return previous-longest code...
+				//
+				CodeToTry.sChars[i] = 0;
+				break;
+			}
+		}
+		iThaiBytes = i;
+		assert(i);	// if 'i' was 0, then this may be an error, trying to get a thai accent as standalone char?
+		return CodeToTry.uiCode;
+	}
+
+	return 0;
+}
+
+// special case, thai can only break on certain letters, and since the rules are complicated then
+//	we tell the translators to put an underscore ('_') between each word even though in Thai they're
+//	all jammed together at final output onscreen...
+//
+static inline bool Thai_IsTrailingPunctuation( unsigned int uiCode )
+{
+	return uiCode == '_';
+}
+
+// takes a TIS 1,2 or 3 byte code and collapse down to a 0..n glyph index...
+//
+// (invalid codes will return 0)
+//
+static int Thai_CollapseTISCode( unsigned int uiCode )
+{
+	if (uiCode >= TIS_GLYPHS_START)	// so western letters drop through as invalid
+	{
+		int iCollapsedIndex = g_ThaiCodes.GetValidIndex( uiCode );
+		if (iCollapsedIndex != -1)
+		{
+			return iCollapsedIndex;
+		}        
+	}
+
+	return 0;
+}
+
+static int Thai_InitFields(int &iGlyphTPs, LPCSTR &psLang)
+{
+	psLang		= "tha";
+	iGlyphTPs	= GLYPH_MAX_THAI_SHADERS;
+	g_iNonScaledCharRange = INT_MAX;	// in other words, don't scale any thai chars down
+	return 32;	// m_iAsianGlyphsAcross
+}
+
+
+// ============================================================================
+
+// takes char *, returns integer char at that point, and advances char * on by enough bytes to move
+//	past the letter (either western 1 byte or Asian multi-byte)...
+//
+// looks messy, but the actual execution route is quite short, so it's fast...
+//
+// Note that I have to have this 3-param form instead of advancing a passed-in "const char **psText" because of VM-crap where you can only change ptr-contents, not ptrs themselves. Bleurgh. Ditto the qtrue:qfalse crap instead of just returning stuff straight through.
+//
+unsigned int AnyLanguage_ReadCharFromString( const char *psText, int *piAdvanceCount, qboolean *pbIsTrailingPunctuation /* = NULL */)
+{	
+	const byte *psString = (const byte *) psText;	// avoid sign-promote bug
+	unsigned int uiLetter;
+
+	switch ( GetLanguageEnum() )
+	{
+		case eKorean:
+		{
+			if ( Korean_ValidKSC5601Hangul( psString[0], psString[1] ))
+			{
+				uiLetter = (psString[0] * 256) + psString[1];
+				*piAdvanceCount = 2;
+
+				// not going to bother testing for korean punctuation here, since korean already 
+				//	uses spaces, and I don't have the punctuation glyphs defined, only the basic 2350 hanguls
+				//
+				if ( pbIsTrailingPunctuation)
+				{
+					*pbIsTrailingPunctuation = qfalse;
+				}
+
+				return uiLetter;
+			}
+		}
+		break;
+
+		case eTaiwanese:
+		{
+			if ( Taiwanese_ValidBig5Code( (psString[0] * 256) + psString[1] ))
+			{
+				uiLetter = (psString[0] * 256) + psString[1];
+				*piAdvanceCount = 2;
+
+				// need to ask if this is a trailing (ie like a comma or full-stop) punctuation?...
+				//
+				if ( pbIsTrailingPunctuation)
+				{
+					*pbIsTrailingPunctuation = Taiwanese_IsTrailingPunctuation( uiLetter ) ? qtrue : qfalse;
+				}
+	
+				return uiLetter;
+			}
+		}
+		break;
+
+		case eJapanese:
+		{
+			if ( Japanese_ValidShiftJISCode( psString[0], psString[1] ))
+			{
+				uiLetter = (psString[0] * 256) + psString[1];
+				*piAdvanceCount = 2;
+	
+				// need to ask if this is a trailing (ie like a comma or full-stop) punctuation?...
+				//
+				if ( pbIsTrailingPunctuation)
+				{
+					*pbIsTrailingPunctuation = Japanese_IsTrailingPunctuation( uiLetter ) ? qtrue : qfalse;
+				}
+
+				return uiLetter;
+			}
+		}
+		break;
+
+		case eChinese:
+		{
+			if ( Chinese_ValidGBCode( (psString[0] * 256) + psString[1] ))
+			{
+				uiLetter = (psString[0] * 256) + psString[1];
+				*piAdvanceCount = 2;
+
+				// need to ask if this is a trailing (ie like a comma or full-stop) punctuation?...
+				//
+				if ( pbIsTrailingPunctuation)
+				{
+					*pbIsTrailingPunctuation = Chinese_IsTrailingPunctuation( uiLetter ) ? qtrue : qfalse;
+				}
+
+				return uiLetter;
+			}
+		}
+		break;
+
+		case eThai:
+		{
+			int iThaiBytes;
+			uiLetter = Thai_ValidTISCode( psString, iThaiBytes );
+			if ( uiLetter )
+			{
+				*piAdvanceCount = iThaiBytes;
+
+				if ( pbIsTrailingPunctuation )
+				{
+					*pbIsTrailingPunctuation = Thai_IsTrailingPunctuation( uiLetter ) ? qtrue : qfalse;
+				}
+
+				return uiLetter;
+			}
+		}
+		break;
+	}
+
+	// ... must not have been an MBCS code...
+	//
+	uiLetter = psString[0];
+	*piAdvanceCount = 1;
+
+	if (pbIsTrailingPunctuation)
+	{
+		*pbIsTrailingPunctuation = (uiLetter == '!' || 
+									uiLetter == '?' || 
+									uiLetter == ',' || 
+									uiLetter == '.' || 
+									uiLetter == ';' || 
+									uiLetter == ':'
+									) ? qtrue : qfalse;
+	}
+
+	return uiLetter;
+}
+
+
+// needed for subtitle printing since original code no longer worked once camera bar height was changed to 480/10
+//	rather than refdef height / 10. I now need to bodge the coords to come out right.
+//
+qboolean Language_IsAsian(void)
+{
+	switch ( GetLanguageEnum() )
+	{
+		case eKorean:
+		case eTaiwanese:
+		case eJapanese:
+		case eChinese:
+		case eThai:	// this is asian, but the query is normally used for scaling
+			return qtrue;
+	}
+
+	return qfalse;
+}
+
+qboolean Language_UsesSpaces(void)
+{
+	// ( korean uses spaces )
+	switch ( GetLanguageEnum() )
+	{
+		case eTaiwanese:	
+		case eJapanese:		
+		case eChinese:		
+		case eThai:			
+			return qfalse;
+	}
+
+	return qtrue;
+}
+
+// ======================================================================
+// name is (eg) "ergo" or "lcd", no extension.
+//
+//  If path present, it's a special language hack for SBCS override languages, eg: "lcd/russian", which means
+//	  just treat the file as "russian", but with the "lcd" part ensuring we don't find a different registered russian font
+//
+CFontInfo::CFontInfo(const char *_fontName)
+{
+	int			len, i;
+	void		*buff;
+	dfontdat_t	*fontdat;
+
+	// remove any special hack name insertions...
+	//
+	char fontName[MAX_QPATH];
+	sprintf(fontName,"fonts/%s.fontdat",COM_SkipPath(const_cast<char*>(_fontName)));	// COM_SkipPath should take a const char *, but it's just possible people use it as a char * I guess, so I have to hack around like this <groan>
+	
+	// clear some general things...
+	//
+	m_pThaiData = NULL;
+	m_iAltSBCSFont = -1;
+	m_iThisFont = -1;
+	m_iOriginalFontWhenSBCSOverriden = -1;
+	m_fAltSBCSFontScaleFactor = -1;
+	m_bIsFakeAlienLanguage = !strcmp(_fontName,"aurabesh");	// dont try and make SBCS or asian overrides for this
+
+	len = FS_ReadFile(fontName, NULL);
+	if (len == sizeof(dfontdat_t))
+	{
+		FS_ReadFile(fontName, &buff);
+		fontdat = (dfontdat_t *)buff;
+
+		for(i = 0; i < GLYPH_COUNT; i++)
+		{
+			mGlyphs[i] = fontdat->mGlyphs[i];
+		}
+		mPointSize = fontdat->mPointSize;
+		mHeight = fontdat->mHeight;
+		mAscender = fontdat->mAscender;
+		mDescender = fontdat->mDescender;
+//		mAsianHack = fontdat->mKoreanHack;	// ignore this crap, it's some junk in the fontdat file that no-one uses
+		mbRoundCalcs = !!strstr(fontName,"ergo");
+
+		// cope with bad fontdat headers...
+		//
+		if (mHeight == 0)
+		{
+			mHeight = mPointSize;
+            mAscender = mPointSize - Round( ((float)mPointSize/10.0f)+2 );	// have to completely guess at the baseline... sigh.
+            mDescender = mHeight - mAscender;
+		}
+
+		FS_FreeFile(buff);
+	}
+	else
+	{
+		mHeight = 0;
+		mShader = 0;
+	}
+
+	Q_strncpyz(m_sFontName, fontName, sizeof(m_sFontName));
+	COM_StripExtension( m_sFontName, m_sFontName );	// so we get better error printing if failed to load shader (ie lose ".fontdat")
+	mShader = RE_RegisterShaderNoMip(m_sFontName);
+
+	FlagNoAsianGlyphs();
+	UpdateAsianIfNeeded(true);
+
+	// finished...
+	g_vFontArray.resize(g_iCurrentFontIndex + 1);
+	g_vFontArray[g_iCurrentFontIndex++] = this;
+
+
+	extern cvar_t *com_buildScript;
+	if (com_buildScript->integer == 2)
+	{
+		Com_Printf( "com_buildScript(2): Registering foreign fonts...\n" );
+		static qboolean bDone = qfalse;	// Do this once only (for speed)...
+		if (!bDone)
+		{
+			bDone = qtrue;
+
+			char sTemp[MAX_QPATH];
+			int iGlyphTPs = 0;
+			const char *psLang = NULL;
+
+			// SBCS override languages...
+			//
+			fileHandle_t f;	
+			for (int i=0; g_SBCSOverrideLanguages[i].m_psName ;i++)
+			{
+				char sTemp[MAX_QPATH];
+
+				sprintf(sTemp,"fonts/%s.tga", g_SBCSOverrideLanguages[i].m_psName );
+				FS_FOpenFileRead( sTemp, &f, qfalse );
+				if (f) FS_FCloseFile( f );
+
+				sprintf(sTemp,"fonts/%s.fontdat", g_SBCSOverrideLanguages[i].m_psName );
+				FS_FOpenFileRead( sTemp, &f, qfalse );
+				if (f) FS_FCloseFile( f );
+			}
+
+			// asian MBCS override languages...
+			//
+			for (int iLang=0; iLang<5; iLang++)
+			{
+				switch (iLang)
+				{
+					case 0:	m_iAsianGlyphsAcross = Korean_InitFields	(iGlyphTPs, psLang);	break;
+					case 1: m_iAsianGlyphsAcross = Taiwanese_InitFields	(iGlyphTPs, psLang);	break;
+					case 2: m_iAsianGlyphsAcross = Japanese_InitFields	(iGlyphTPs, psLang);	break;
+					case 3: m_iAsianGlyphsAcross = Chinese_InitFields	(iGlyphTPs, psLang);	break;
+					case 4: m_iAsianGlyphsAcross = Thai_InitFields		(iGlyphTPs, psLang);	
+					{
+						// additional files needed for Thai language...
+						//						
+						FS_FOpenFileRead( sFILENAME_THAI_WIDTHS , &f, qfalse );
+						if (f) {
+							FS_FCloseFile( f );
+						}
+
+						FS_FOpenFileRead( sFILENAME_THAI_CODES, &f, qfalse );
+						if (f) {
+							FS_FCloseFile( f );
+						}					
+					}
+                    break;
+				}
+
+				for (int i=0; i<iGlyphTPs; i++)
+				{
+					Com_sprintf(sTemp,sizeof(sTemp), "fonts/%s_%d_1024_%d.tga", psLang, 1024/m_iAsianGlyphsAcross, i);
+
+					// RE_RegisterShaderNoMip( sTemp );	// don't actually need to load it, so...					
+					FS_FOpenFileRead( sTemp, &f, qfalse );
+					if (f) {
+						FS_FCloseFile( f );
+					}
+				}
+			}
+		}
+	}
+}
+
+void CFontInfo::UpdateAsianIfNeeded( bool bForceReEval /* = false */ )
+{
+	// if asian language, then provide an alternative glyph set and fill in relevant fields...
+	//
+	if (mHeight && !m_bIsFakeAlienLanguage)	// western charset exists in first place, and isn't alien rubbish?
+	{
+		Language_e eLanguage = GetLanguageEnum();
+
+		if (eLanguage == eKorean || eLanguage == eTaiwanese || eLanguage == eJapanese || eLanguage == eChinese || eLanguage == eThai)
+		{
+			int iCappedHeight = mHeight < 16 ? 16: mHeight;	// arbitrary limit on small char sizes because Asian chars don't squash well
+
+			if (m_iLanguageModificationCount != se_language->modificationCount || !AsianGlyphsAvailable() || bForceReEval)
+			{
+				m_iLanguageModificationCount  = se_language->modificationCount;
+
+				int iGlyphTPs = 0;
+				const char *psLang = NULL;
+
+				switch ( eLanguage )
+				{
+					case eKorean:		m_iAsianGlyphsAcross = Korean_InitFields(iGlyphTPs, psLang);	break;
+					case eTaiwanese:	m_iAsianGlyphsAcross = Taiwanese_InitFields(iGlyphTPs, psLang);	break;
+					case eJapanese:		m_iAsianGlyphsAcross = Japanese_InitFields(iGlyphTPs, psLang);	break;
+					case eChinese:		m_iAsianGlyphsAcross = Chinese_InitFields(iGlyphTPs, psLang);	break;
+					case eThai:
+					{
+						m_iAsianGlyphsAcross = Thai_InitFields(iGlyphTPs, psLang);
+
+						if (!m_pThaiData)
+						{
+							LPCSTR psFailureReason = g_ThaiCodes.Init();
+							if (!psFailureReason[0])
+							{
+								m_pThaiData = &g_ThaiCodes;
+							}
+							else
+							{
+								// failed to load a needed file, reset to English...
+								//
+								Cvar_Set("se_language", "english");
+								Com_Error( ERR_DROP, psFailureReason );
+							}
+						}
+					}
+					break;
+				}
+
+				// textures need loading...
+				//
+				if (m_sFontName[0])
+				{
+					// Use this sometime if we need to do logic to load alternate-height glyphs to better fit other fonts.
+					// (but for now, we just use the one glyph set)
+					//
+				}
+				
+				for (int i = 0; i < iGlyphTPs; i++)
+				{
+					// (Note!!  assumption for S,T calculations: all Asian glyph textures pages are square except for last one)
+					//
+					char sTemp[MAX_QPATH];
+					Com_sprintf(sTemp,sizeof(sTemp), "fonts/%s_%d_1024_%d", psLang, 1024/m_iAsianGlyphsAcross, i);
+					//
+					// returning 0 here will automatically inhibit Asian glyph calculations at runtime...
+					//
+					m_hAsianShaders[i] = RE_RegisterShaderNoMip( sTemp );
+				}
+			
+				// for now I'm hardwiring these, but if we ever have more than one glyph set per language then they'll be changed...
+				//
+				m_iAsianPagesLoaded = iGlyphTPs;	// not necessarily true, but will be safe, and show up obvious if something missing
+				m_bAsianLastPageHalfHeight = true;
+
+				bForceReEval = true;
+			}
+
+			if (bForceReEval)
+			{			
+				// now init the Asian member glyph fields to make them come out the same size as the western ones
+				//	that they serve as an alternative for...
+				//
+				m_AsianGlyph.width			= iCappedHeight;	// square Asian chars same size as height of western set
+				m_AsianGlyph.height			= iCappedHeight;	// ""
+				switch (eLanguage)
+				{
+					default:		m_AsianGlyph.horizAdvance	= iCappedHeight;	break;
+					case eKorean:	m_AsianGlyph.horizAdvance	= iCappedHeight - 1;break;	// korean has a small amount of space at the edge of the glyph
+
+					case eTaiwanese:
+					case eJapanese:
+					case eChinese:	m_AsianGlyph.horizAdvance	= iCappedHeight + 3;	// need to force some spacing for these
+//					case eThai:	// this is done dynamically elsewhere, since Thai glyphs are variable width
+				}
+				m_AsianGlyph.horizOffset	= 0;				// ""
+				m_AsianGlyph.baseline		= mAscender + ((iCappedHeight - mHeight) >> 1);
+			}
+		}
+		else
+		{
+			// not using Asian...
+			//
+			FlagNoAsianGlyphs();
+		}
+	}
+	else
+	{			
+		// no western glyphs available, so don't attempt to match asian...
+		//
+		FlagNoAsianGlyphs();
+	}
+}
+
+static CFontInfo *GetFont_Actual(int index)
+{
+	index &= SET_MASK;
+	if((index >= 1) && (index < g_iCurrentFontIndex))
+	{
+		CFontInfo *pFont = g_vFontArray[index];
+
+		if (pFont)
+		{
+			pFont->UpdateAsianIfNeeded();
+		}
+
+		return pFont;
+	}
+	return(NULL);
+}
+
+
+// needed to add *piShader param because of multiple TPs, 
+//	if not passed in, then I also skip S,T calculations for re-usable static asian glyphinfo struct...
+//
+const glyphInfo_t *CFontInfo::GetLetter(const unsigned int uiLetter, int *piShader /* = NULL */)
+{ 	
+	if ( AsianGlyphsAvailable() )
+	{
+		int iCollapsedAsianCode = GetCollapsedAsianCode( uiLetter );
+		if (iCollapsedAsianCode)
+		{
+			if (piShader)
+			{
+				// (Note!!  assumption for S,T calculations: all asian glyph textures pages are square except for last one
+				//			which may or may not be half height) - but not for Thai
+				//				
+				int iTexturePageIndex = iCollapsedAsianCode / (m_iAsianGlyphsAcross * m_iAsianGlyphsAcross);
+
+				if (iTexturePageIndex > m_iAsianPagesLoaded)
+				{
+					assert(0);				// should never happen
+					iTexturePageIndex = 0;
+				}
+
+				int iOriginalCollapsedAsianCode = iCollapsedAsianCode;	// need to back this up (if Thai) for later
+				iCollapsedAsianCode -= iTexturePageIndex *  (m_iAsianGlyphsAcross * m_iAsianGlyphsAcross);
+
+				const int iColumn	= iCollapsedAsianCode % m_iAsianGlyphsAcross;
+				const int iRow		= iCollapsedAsianCode / m_iAsianGlyphsAcross;				
+				const bool bHalfT	= (iTexturePageIndex == (m_iAsianPagesLoaded - 1) && m_bAsianLastPageHalfHeight);
+				const int iAsianGlyphsDown = (bHalfT) ? m_iAsianGlyphsAcross / 2 : m_iAsianGlyphsAcross;
+
+				switch ( GetLanguageEnum() )
+				{
+					case eKorean:
+					default:					
+					{
+						m_AsianGlyph.s  = (float)( iColumn    ) / (float)m_iAsianGlyphsAcross;
+						m_AsianGlyph.t  = (float)( iRow       ) / (float)  iAsianGlyphsDown;
+						m_AsianGlyph.s2 = (float)( iColumn + 1) / (float)m_iAsianGlyphsAcross;				
+						m_AsianGlyph.t2 = (float)( iRow + 1   ) / (float)  iAsianGlyphsDown;
+					}
+					break;
+
+					case eTaiwanese:
+					{
+						m_AsianGlyph.s  = (float)(((1024 / m_iAsianGlyphsAcross) * ( iColumn    ))+1) / 1024.0f;
+						m_AsianGlyph.t  = (float)(((1024 / iAsianGlyphsDown    ) * ( iRow       ))+1) / 1024.0f;
+						m_AsianGlyph.s2 = (float)(((1024 / m_iAsianGlyphsAcross) * ( iColumn+1  ))  ) / 1024.0f;
+						m_AsianGlyph.t2 = (float)(((1024 / iAsianGlyphsDown    ) * ( iRow+1     ))  ) / 1024.0f;
+					}
+					break;
+
+					case eJapanese:
+					case eChinese:
+					{
+						m_AsianGlyph.s  = (float)(((1024 / m_iAsianGlyphsAcross) * ( iColumn    ))  ) / 1024.0f;
+						m_AsianGlyph.t  = (float)(((1024 / iAsianGlyphsDown    ) * ( iRow       ))  ) / 1024.0f;
+						m_AsianGlyph.s2 = (float)(((1024 / m_iAsianGlyphsAcross) * ( iColumn+1  ))-1) / 1024.0f;
+						m_AsianGlyph.t2 = (float)(((1024 / iAsianGlyphsDown    ) * ( iRow+1     ))-1) / 1024.0f;
+					}
+					break;
+
+					case eThai:
+					{
+						int iGlyphXpos = (1024 / m_iAsianGlyphsAcross) * ( iColumn );
+						int iGlyphWidth = g_ThaiCodes.GetWidth( iOriginalCollapsedAsianCode );
+
+						// very thai-specific language-code...
+						//
+						if (uiLetter == TIS_SARA_AM)
+						{
+							iGlyphXpos += 9;	// these are pixel coords on the source TP, so don't affect scaled output
+							iGlyphWidth= 20;	//
+						}
+						m_AsianGlyph.s  = (float)(iGlyphXpos) / 1024.0f;
+						m_AsianGlyph.t  = (float)(((1024 / iAsianGlyphsDown    ) * ( iRow       ))  ) / 1024.0f;						
+						// technically this .s2 line should be modified to blit only the correct width, but since
+						//	all Thai glyphs are up against the left edge of their cells and have blank to the cell
+						//	boundary then it's better to keep these calculations simpler...
+						
+						m_AsianGlyph.s2 = (float)(iGlyphXpos+iGlyphWidth) / 1024.0f;
+						m_AsianGlyph.t2 = (float)(((1024 / iAsianGlyphsDown    ) * ( iRow+1     ))-1) / 1024.0f;
+
+						// special addition for Thai, need to bodge up the width and advance fields...
+						//
+                        m_AsianGlyph.width = iGlyphWidth;
+						m_AsianGlyph.horizAdvance = iGlyphWidth + 1;
+					}
+					break;
+				}
+				*piShader = m_hAsianShaders[ iTexturePageIndex ];
+			}
+			return &m_AsianGlyph;
+		}
+	}
+
+	if (piShader)
+	{
+		*piShader = GetShader();
+	}
+
+	const glyphInfo_t *pGlyph = &mGlyphs[ uiLetter & 0xff ];
+	//
+	// SBCS language substitution?...
+	//
+	if ( m_fAltSBCSFontScaleFactor != -1 )
+	{
+		// sod it, use the asian glyph, that's fine...
+		//
+		memcpy(&m_AsianGlyph,pGlyph,sizeof(m_AsianGlyph));	// *before* changin pGlyph!
+
+//		CFontInfo *pOriginalFont = GetFont_Actual( this->m_iOriginalFontWhenSBCSOverriden );
+//		pGlyph = &pOriginalFont->mGlyphs[ uiLetter & 0xff ];		
+
+		#define ASSIGN_WITH_ROUNDING(_dst,_src) _dst = mbRoundCalcs ? Round( m_fAltSBCSFontScaleFactor * _src ) : m_fAltSBCSFontScaleFactor * (float)_src;
+
+		ASSIGN_WITH_ROUNDING( m_AsianGlyph.baseline,	pGlyph->baseline );
+		ASSIGN_WITH_ROUNDING( m_AsianGlyph.height,		pGlyph->height );
+		ASSIGN_WITH_ROUNDING( m_AsianGlyph.horizAdvance,pGlyph->horizAdvance );
+//		m_AsianGlyph.horizOffset	= /*Round*/( m_fAltSBCSFontScaleFactor * pGlyph->horizOffset );
+		ASSIGN_WITH_ROUNDING( m_AsianGlyph.width,		pGlyph->width );
+
+		pGlyph = &m_AsianGlyph;
+	}
+
+	return pGlyph;
+}
+
+const int CFontInfo::GetCollapsedAsianCode(ulong uiLetter) const
+{
+	int iCollapsedAsianCode = 0;
+
+	if (AsianGlyphsAvailable())
+	{
+		switch ( GetLanguageEnum() )
+		{
+			case eKorean:		iCollapsedAsianCode = Korean_CollapseKSC5601HangulCode( uiLetter );	break;
+			case eTaiwanese:	iCollapsedAsianCode = Taiwanese_CollapseBig5Code( uiLetter );		break;
+			case eJapanese:		iCollapsedAsianCode = Japanese_CollapseShiftJISCode( uiLetter );	break;
+			case eChinese:		iCollapsedAsianCode = Chinese_CollapseGBCode( uiLetter );			break;
+			case eThai:			iCollapsedAsianCode = Thai_CollapseTISCode( uiLetter );				break;
+			default:			assert(0);	/* unhandled asian language */							break;
+		}
+	}
+
+	return iCollapsedAsianCode;
+}
+
+const int CFontInfo::GetLetterWidth(unsigned int uiLetter)
+{
+	const glyphInfo_t *pGlyph = GetLetter( uiLetter );
+	return pGlyph->width ? pGlyph->width : mGlyphs['.'].width;
+}
+
+const int CFontInfo::GetLetterHorizAdvance(unsigned int uiLetter)
+{	
+	const glyphInfo_t *pGlyph = GetLetter( uiLetter );
+	return pGlyph->horizAdvance ? pGlyph->horizAdvance : mGlyphs['.'].horizAdvance;
+}
+
+// ensure any GetFont calls that need SBCS overriding (such as when playing in Russian) have the appropriate stuff done...
+//
+static CFontInfo *GetFont_SBCSOverride(CFontInfo *pFont, Language_e eLanguageSBCS, LPCSTR psLanguageNameSBCS )
+{
+	if ( !pFont->m_bIsFakeAlienLanguage )
+	{
+		if ( GetLanguageEnum() == eLanguageSBCS )
+		{
+			if ( pFont->m_iAltSBCSFont == -1 ) 	// no reg attempted yet?
+			{
+				// need to register this alternative SBCS font...
+				//
+				int iAltFontIndex = RE_RegisterFont( va("%s/%s",COM_SkipPath(pFont->m_sFontName),psLanguageNameSBCS) );	// ensure unique name (eg: "lcd/russian")
+				CFontInfo *pAltFont = GetFont_Actual( iAltFontIndex );
+				if ( pAltFont )
+				{
+					// work out the scaling factor for this font's glyphs...( round it to 1 decimal place to cut down on silly scale factors like 0.53125 )
+					//
+					pAltFont->m_fAltSBCSFontScaleFactor = RoundTenth((float)pFont->GetPointSize() / (float)pAltFont->GetPointSize());
+					//
+					// then override with the main properties of the original font...
+					//
+					pAltFont->mPointSize = pFont->GetPointSize();//(float) pAltFont->GetPointSize() * pAltFont->m_fAltSBCSFontScaleFactor;
+					pAltFont->mHeight	 = pFont->GetHeight();//(float) pAltFont->GetHeight()	* pAltFont->m_fAltSBCSFontScaleFactor;
+					pAltFont->mAscender	 = pFont->GetAscender();//(float) pAltFont->GetAscender()	* pAltFont->m_fAltSBCSFontScaleFactor;
+					pAltFont->mDescender = pFont->GetDescender();//(float) pAltFont->GetDescender()	* pAltFont->m_fAltSBCSFontScaleFactor;
+
+//					pAltFont->mPointSize = (float) pAltFont->GetPointSize() * pAltFont->m_fAltSBCSFontScaleFactor;
+//					pAltFont->mHeight	 = (float) pAltFont->GetHeight()	* pAltFont->m_fAltSBCSFontScaleFactor;
+//					pAltFont->mAscender	 = (float) pAltFont->GetAscender()	* pAltFont->m_fAltSBCSFontScaleFactor;
+//					pAltFont->mDescender = (float) pAltFont->GetDescender()	* pAltFont->m_fAltSBCSFontScaleFactor;
+
+					pAltFont->mbRoundCalcs = true;
+					pAltFont->m_iOriginalFontWhenSBCSOverriden = pFont->m_iThisFont;
+				}
+				pFont->m_iAltSBCSFont = iAltFontIndex;
+			}
+
+			if ( pFont->m_iAltSBCSFont > 0)
+			{
+				return GetFont_Actual( pFont->m_iAltSBCSFont );
+			}
+		}
+	}
+
+	return NULL;
+}
+
+
+
+CFontInfo *GetFont(int index)
+{
+	CFontInfo *pFont = GetFont_Actual( index );
+
+	if (pFont)
+	{
+		// any SBCS overrides? (this has to be pretty quick, and is (sort of))...
+		//
+		for (int i=0; g_SBCSOverrideLanguages[i].m_psName; i++)
+		{
+			CFontInfo *pAltFont = GetFont_SBCSOverride( pFont, g_SBCSOverrideLanguages[i].m_eLanguage, g_SBCSOverrideLanguages[i].m_psName );
+			if (pAltFont) 
+			{
+				return pAltFont;
+			}
+		}
+	}
+
+	return pFont;
+}
+
+
+int RE_Font_StrLenPixels(const char *psText, const int iFontHandle, const float fScale)
+{			
+	int			iMaxWidth = 0;
+	int			iThisWidth= 0;
+	CFontInfo	*curfont;
+
+	curfont = GetFont(iFontHandle);
+	if(!curfont)
+	{
+		return(0);
+	}
+
+	float fScaleA = fScale;
+	if (Language_IsAsian() && fScale > 0.7f )
+	{
+		fScaleA = fScale * 0.75f;
+	}
+
+	while(*psText)
+	{
+		int iAdvanceCount;
+		unsigned int uiLetter = AnyLanguage_ReadCharFromString( psText, &iAdvanceCount, NULL );
+		psText += iAdvanceCount;
+
+		if (uiLetter == '^' )
+		{
+			if (*psText >= '0' &&
+				*psText <= '9')
+			{
+				uiLetter = AnyLanguage_ReadCharFromString( psText, &iAdvanceCount, NULL );
+				psText += iAdvanceCount;
+				continue;
+			}
+		}
+
+		if (uiLetter == 0x0A)
+		{
+			iThisWidth = 0;
+		}
+		else
+		{
+			int iPixelAdvance = curfont->GetLetterHorizAdvance( uiLetter );
+	
+			float fValue = iPixelAdvance * ((uiLetter > g_iNonScaledCharRange) ? fScaleA : fScale);
+			iThisWidth += curfont->mbRoundCalcs ? Round( fValue ) : fValue;
+			if (iThisWidth > iMaxWidth)
+			{
+				iMaxWidth = iThisWidth;
+			}
+		}
+	}
+
+	return iMaxWidth;
+}
+
+// not really a font function, but keeps naming consistant...
+//
+int RE_Font_StrLenChars(const char *psText)
+{			
+	// logic for this function's letter counting must be kept same in this function and RE_Font_DrawString()
+	//
+	int iCharCount = 0;
+
+	while ( *psText )
+	{
+		// in other words, colour codes and CR/LF don't count as chars, all else does...
+		//
+		int iAdvanceCount;
+		unsigned int uiLetter = AnyLanguage_ReadCharFromString( psText, &iAdvanceCount, NULL );
+		psText += iAdvanceCount;
+
+		switch (uiLetter)
+		{
+			case '^':
+				if (*psText >= '0' &&
+					*psText <= '9')
+				{
+					psText++;
+				}
+				else
+				{
+					iCharCount++;
+				}
+				break;	// colour code (note next-char skip)
+			case 10:								break;	// linefeed
+			case 13:								break;	// return 
+			case '_':	iCharCount += (GetLanguageEnum() == eThai && (((unsigned char *)psText)[0] >= TIS_GLYPHS_START))?0:1; break;	// special word-break hack
+			default:	iCharCount++;				break;
+		}
+	}
+	
+	return iCharCount;
+}
+
+int RE_Font_HeightPixels(const int iFontHandle, const float fScale)
+{			
+	CFontInfo	*curfont;
+
+	curfont = GetFont(iFontHandle);
+	if(curfont)
+	{
+		float fValue = curfont->GetPointSize() * fScale;
+		return curfont->mbRoundCalcs ? Round(fValue) : fValue;
+	}
+	return(0);
+}
+
+// iMaxPixelWidth is -1 for "all of string", else pixel display count...
+//
+void RE_Font_DrawString(int ox, int oy, const char *psText, const float *rgba, const int iFontHandle, int iMaxPixelWidth, const float fScale)
+{
+	static qboolean gbInShadow = qfalse;	// MUST default to this
+	int					x, y, colour, offset;
+	const glyphInfo_t	*pLetter;
+	qhandle_t			hShader;
+
+	assert (psText);
+
+	if(iFontHandle & STYLE_BLINK)
+	{
+		if((Sys_Milliseconds() >> 7) & 1)
+		{
+			return;
+		}
+	}
+
+//	// test code only
+//	if (GetLanguageEnum() == eTaiwanese)
+//	{
+//		psText = "Wp:¶}·F§a ¿p·G´µ¡A§Æ±æ§A¹³¥L­Ì»¡ªº¤@¼Ë¦æ¡C";
+//	}
+//	else 
+//	if (GetLanguageEnum() == eChinese)
+//	{
+//		//psText = "Ó¶±øÕ½³¡II  Ô¼º²?ĪÁÖ˹  ÈÎÎñʧ°Ü  ÄãÒªÌ×Óû­ÃæÉ趨µÄ±ä¸üÂ𣿠 Ô¤Éè,S3 ѹËõ,DXT1 ѹËõ,DXT5 ѹËõ,16 Bit,32 Bit";
+//		psText = "Ó¶±øÕ½³¡II";
+//	}
+//	else 
+//	if (GetLanguageEnum() == eThai)
+//	{
+//		//psText = "Áҵðҹ¼ÅÔµÀѳ±ìÍصÊÒË¡ÃÃÁÃËÑÊÊÓËÃѺÍÑ¡¢ÃÐä·Â·Õèãªé¡Ñº¤ÍÁ¾ÔÇàµÍÃì";
+//		psText = "Áҵðҹ¼ÅÔµ";
+//		psText = "ÃËÑÊÊÓËÃѺ";
+//		psText = "ÃËÑÊÊÓËÃѺ   ÍÒ_¡Ô¹_¤ÍÃì·_1415";
+//	}
+//	else
+//	if (GetLanguageEnum() == eKorean)
+//	{
+//		psText = "Wp:¼îŸÀÓÀÌ´Ù ¸Ö¸°. ±×µéÀÌ ¸»ÇÑ´ë·Î ³×°¡ ÀßÇÒÁö ±â´ëÇÏ°Ú´Ù.";
+//	}
+//	else
+//	if (GetLanguageEnum() == eJapanese)
+//	{
+//		static char sBlah[200];
+//		sprintf(sBlah,va("%c%c%c%c%c%c%c%c",0x82,0xA9,0x82,0xC8,0x8A,0xBF,0x8E,0x9A));
+//		psText = &sBlah[0];
+//	}
+//	else
+//	if (GetLanguageEnum() == eRussian)
+//	{
+////		//psText = "Íà âåðøèíå õîëìà ñòîèò ñòàðûé äîì ñ ïðèâèäåíèÿìè è áàøíÿ ñ âîëøåáíûìè ÷àñàìè."
+//		psText = "Íà âåðøèíå õîëìà ñòîèò";
+//	}
+//	else
+//	if (GetLanguageEnum() == ePolish)
+//	{
+//		psText = "za³o¿ony w 1364 roku, jest najstarsz¹ polsk¹ uczelni¹ i nale¿y...";
+//		psText = "za³o¿ony nale¿y";
+//	}
+
+
+	CFontInfo *curfont = GetFont(iFontHandle);
+	if(!curfont || !psText)
+	{
+		return;
+	}
+
+	float fScaleA = fScale;
+	int iAsianYAdjust = 0;
+	if (Language_IsAsian() && fScale > 0.7f)
+	{
+		fScaleA = fScale * 0.75f;
+		iAsianYAdjust = /*Round*/((((float)curfont->GetPointSize() * fScale) - ((float)curfont->GetPointSize() * fScaleA))/2);
+	}
+
+	// Draw a dropshadow if required
+	if(iFontHandle & STYLE_DROPSHADOW)
+	{
+		offset = Round(curfont->GetPointSize() * fScale * 0.075f);
+
+		static const vec4_t v4DKGREY2 = {0.15f, 0.15f, 0.15f, 1};
+
+		gbInShadow = qtrue;
+		RE_Font_DrawString(ox + offset, oy + offset, psText, v4DKGREY2, iFontHandle & SET_MASK, iMaxPixelWidth, fScale);
+		gbInShadow = qfalse;
+	}
+		
+	RE_SetColor( rgba );
+
+	x = ox;
+	oy += Round((curfont->GetHeight() - (curfont->GetDescender() >> 1)) * fScale);
+
+	qboolean bNextTextWouldOverflow = qfalse;
+	while (*psText && !bNextTextWouldOverflow)
+	{
+		int iAdvanceCount;
+		unsigned int uiLetter = AnyLanguage_ReadCharFromString( psText, &iAdvanceCount, NULL );
+		psText += iAdvanceCount;
+
+		switch( uiLetter )
+		{
+		case 10:						//linefeed
+			x = ox;
+			oy += Round(curfont->GetPointSize() * fScale);
+			if (Language_IsAsian())
+			{
+				oy += 4;	// this only comes into effect when playing in asian for "A long time ago in a galaxy" etc, all other text is line-broken in feeder functions
+			}
+			break;
+		case 13:						// Return
+			break;
+		case 32:						// Space
+			pLetter = curfont->GetLetter(' ');			
+			x += Round(pLetter->horizAdvance * fScale);
+			bNextTextWouldOverflow = ( iMaxPixelWidth != -1 && ((x-ox)>iMaxPixelWidth) ) ? qtrue : qfalse;	// yeuch
+			break;
+		case '_':	// has a special word-break usage if in Thai (and followed by a thai char), and should not be displayed, else treat as normal
+			if (GetLanguageEnum()== eThai && ((unsigned char *)psText)[0] >= TIS_GLYPHS_START)
+			{
+				break;
+			}
+			// else drop through and display as normal...
+		case '^':
+			if (uiLetter != '_')	// necessary because of fallthrough above
+			{
+				if (*psText >= '0' &&
+					*psText <= '9')
+				{
+					colour = ColorIndex(*psText++);
+					if (!gbInShadow)
+					{
+						RE_SetColor( g_color_table[colour] );
+					}
+					break;
+				}
+			}
+			//purposely falls thrugh
+		default:
+			pLetter = curfont->GetLetter( uiLetter, &hShader );			// Description of pLetter
+			if(!pLetter->width)
+			{
+				pLetter = curfont->GetLetter('.');
+			}
+
+			float fThisScale = uiLetter > g_iNonScaledCharRange ? fScaleA : fScale;
+
+			// sigh, super-language-specific hack...
+			//
+			if (uiLetter == TIS_SARA_AM && GetLanguageEnum() == eThai)
+			{
+				x -= Round(7 * fThisScale);
+			}
+
+			int iAdvancePixels = Round(pLetter->horizAdvance * fThisScale);
+			bNextTextWouldOverflow = ( iMaxPixelWidth != -1 && (((x+iAdvancePixels)-ox)>iMaxPixelWidth) ) ? qtrue : qfalse;	// yeuch
+			if (!bNextTextWouldOverflow)
+			{
+				// this 'mbRoundCalcs' stuff is crap, but the only way to make the font code work. Sigh...
+				//				
+				y = oy - (curfont->mbRoundCalcs ? Round(pLetter->baseline * fThisScale) : pLetter->baseline * fThisScale);
+				if (curfont->m_fAltSBCSFontScaleFactor != -1)
+				{
+					y+=3;	// I'm sick and tired of going round in circles trying to do this legally, so bollocks to it
+				}
+
+				RE_StretchPic ( x + Round(pLetter->horizOffset * fScale), // float x
+								(uiLetter > g_iNonScaledCharRange) ? y - iAsianYAdjust : y,	// float y
+								curfont->mbRoundCalcs ? Round(pLetter->width * fThisScale) : pLetter->width * fThisScale,	// float w
+								curfont->mbRoundCalcs ? Round(pLetter->height * fThisScale) : pLetter->height * fThisScale, // float h
+								pLetter->s,						// float s1
+								pLetter->t,						// float t1
+								pLetter->s2,					// float s2
+								pLetter->t2,					// float t2
+								//lastcolour.c, 
+								hShader							// qhandle_t hShader
+								);
+
+				x += iAdvancePixels;
+			}
+			break;
+		}		
+	}
+	//let it remember the old color //RE_SetColor(NULL);;
+}
+
+int RE_RegisterFont(const char *psName) 
+{
+	FontIndexMap_t::iterator it = g_mapFontIndexes.find(psName);
+	if (it != g_mapFontIndexes.end() )
+	{
+		int iFontIndex = (*it).second;
+		return iFontIndex;
+	}
+
+	// not registered, so...
+	//
+	{
+		CFontInfo *pFont = new CFontInfo(psName);
+		if (pFont->GetPointSize() > 0)
+		{
+			int iFontIndex = g_iCurrentFontIndex - 1;
+			g_mapFontIndexes[psName] = iFontIndex;
+			pFont->m_iThisFont = iFontIndex;
+			return iFontIndex;
+		}
+		else
+		{
+			g_mapFontIndexes[psName] = 0;	// missing/invalid
+		}
+	}
+
+	return 0;
+}
+
+void R_InitFonts(void)
+{
+	g_iCurrentFontIndex = 1;			// entry 0 is reserved for "missing/invalid"
+	g_iNonScaledCharRange = INT_MAX;	// default all chars to have no special scaling (other than user supplied)
+}
+
+void R_ShutdownFonts(void)
+{
+	for(int i = 1; i < g_iCurrentFontIndex; i++)	// entry 0 is reserved for "missing/invalid"
+	{
+		delete g_vFontArray[i];
+	}
+	g_mapFontIndexes.clear();
+	g_vFontArray.clear();
+	g_iCurrentFontIndex = 1;	// entry 0 is reserved for "missing/invalid"
+
+	g_ThaiCodes.Clear();
+}
+
+// this is only really for debugging while tinkering with fonts, but harmless to leave in...
+//
+void R_ReloadFonts_f(void)
+{
+	// first, grab all the currently-registered fonts IN THE ORDER THEY WERE REGISTERED...
+	//
+	vector <sstring_t> vstrFonts;
+
+	for (int iFontToFind = 1; iFontToFind < g_iCurrentFontIndex; iFontToFind++)
+	{		
+		for (FontIndexMap_t::iterator it = g_mapFontIndexes.begin(); it != g_mapFontIndexes.end(); ++it)
+		{
+			if (iFontToFind == (*it).second)
+			{
+				vstrFonts.push_back( (*it).first );
+				break;
+			}
+		}
+		if ( it == g_mapFontIndexes.end() )
+		{
+			break;	// couldn't find this font
+		}
+	}
+	if ( iFontToFind == g_iCurrentFontIndex ) // found all of them?
+	{
+		// now restart the font system...
+		//
+		R_ShutdownFonts();
+		R_InitFonts();
+		//
+		// and re-register our fonts in the same order as before (note that some menu items etc cache the string lengths so really a vid_restart is better, but this is just for my testing)
+		//
+		for (int iFont = 0; iFont < vstrFonts.size(); iFont++)
+		{
+#ifdef _DEBUG
+			int iNewFontHandle = RE_RegisterFont( vstrFonts[iFont].c_str() );
+			assert( iNewFontHandle == iFont+1 );
+#else
+			RE_RegisterFont( vstrFonts[iFont].c_str() );
+#endif
+		}
+		Com_Printf( "Done.\n" );
+	}
+	else
+	{
+		Com_Printf( "Problem encountered finding current fonts, ignoring.\n" );	// poo. Oh well, forget it.
+	}
+}
+
+
+// end
diff --git a/codemp/renderer/tr_font.h b/codemp/renderer/tr_font.h
new file mode 100644
index 0000000..f46e611
--- /dev/null
+++ b/codemp/renderer/tr_font.h
@@ -0,0 +1,34 @@
+// Filename:-	tr_font.h
+//
+// font support 
+
+// This file is shared in the single and multiplayer codebases, so be CAREFUL WHAT YOU ADD/CHANGE!!!!!
+
+#ifndef TR_FONT_H
+#define TR_FONT_H
+
+
+void R_ShutdownFonts(void);
+void R_InitFonts(void);
+int RE_RegisterFont(const char *psName);
+int RE_Font_StrLenPixels(const char *psText, const int iFontHandle, const float fScale = 1.0f);
+int RE_Font_StrLenChars(const char *psText);
+int RE_Font_HeightPixels(const int iFontHandle, const float fScale = 1.0f);
+void RE_Font_DrawString(int ox, int oy, const char *psText, const float *rgba, const int iFontHandle, int iMaxPixelWidth, const float fScale = 1.0f);
+
+// Dammit, I can't use this more elegant form because of !@#@!$%% VM code... (can't alter passed in ptrs, only contents of)
+//
+//unsigned int AnyLanguage_ReadCharFromString( const char **ppsText, qboolean *pbIsTrailingPunctuation = NULL);
+//
+// so instead we have to use this messier method...
+//
+unsigned int AnyLanguage_ReadCharFromString( const char *psText, int *piAdvanceCount, qboolean *pbIsTrailingPunctuation = NULL);
+
+qboolean Language_IsAsian(void);
+qboolean Language_UsesSpaces(void);
+
+
+#endif	// #ifndef TR_FONT_H
+
+// end
+
diff --git a/codemp/renderer/tr_ghoul2.cpp b/codemp/renderer/tr_ghoul2.cpp
new file mode 100644
index 0000000..2431451
--- /dev/null
+++ b/codemp/renderer/tr_ghoul2.cpp
@@ -0,0 +1,5509 @@
+// leave this as first line for PCH reasons...
+//
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+ 
+#include "../client/client.h"	//FIXME!! EVIL - just include the definitions needed 
+
+#ifdef _XBOX
+#include "../qcommon/miniheap.h"
+#endif
+						  
+#if !defined(TR_LOCAL_H)
+	#include "tr_local.h"
+#endif
+
+#include "matcomp.h"
+#if !defined(_QCOMMON_H_)
+	#include "../qcommon/qcommon.h"
+#endif
+#if !defined(G2_H_INC)
+	#include "../ghoul2/G2.h"
+#endif
+#include "../ghoul2/G2_local.h"
+#ifdef _G2_GORE
+#include "../ghoul2/G2_gore.h"
+#endif
+#include "matcomp.h"
+
+#ifdef VV_LIGHTING
+#include "tr_lightmanager.h"
+#endif
+
+#pragma warning (disable: 4512)	//default assignment operator could not be gened
+#include "../qcommon/disablewarnings.h"
+
+#define	LL(x) x=LittleLong(x)
+
+#ifdef G2_PERFORMANCE_ANALYSIS
+#include "../qcommon/timing.h"
+
+timing_c G2PerformanceTimer_RenderSurfaces;
+timing_c G2PerformanceTimer_R_AddGHOULSurfaces;
+timing_c G2PerformanceTimer_G2_TransformGhoulBones;
+timing_c G2PerformanceTimer_G2_ProcessGeneratedSurfaceBolts;
+timing_c G2PerformanceTimer_ProcessModelBoltSurfaces;
+timing_c G2PerformanceTimer_G2_ConstructGhoulSkeleton;
+timing_c G2PerformanceTimer_RB_SurfaceGhoul;
+timing_c G2PerformanceTimer_G2_SetupModelPointers;
+timing_c G2PerformanceTimer_PreciseFrame;
+
+int G2PerformanceCounter_G2_TransformGhoulBones = 0;
+
+int G2Time_RenderSurfaces = 0;
+int G2Time_R_AddGHOULSurfaces = 0;
+int G2Time_G2_TransformGhoulBones = 0;
+int G2Time_G2_ProcessGeneratedSurfaceBolts = 0;
+int G2Time_ProcessModelBoltSurfaces = 0;
+int G2Time_G2_ConstructGhoulSkeleton = 0;
+int G2Time_RB_SurfaceGhoul = 0;
+int G2Time_G2_SetupModelPointers = 0;
+int G2Time_PreciseFrame = 0;
+
+void G2Time_ResetTimers(void)
+{
+	G2Time_RenderSurfaces = 0;
+	G2Time_R_AddGHOULSurfaces = 0;
+	G2Time_G2_TransformGhoulBones = 0;
+	G2Time_G2_ProcessGeneratedSurfaceBolts = 0;
+	G2Time_ProcessModelBoltSurfaces = 0;
+	G2Time_G2_ConstructGhoulSkeleton = 0;
+	G2Time_RB_SurfaceGhoul = 0;
+	G2Time_G2_SetupModelPointers = 0;
+	G2Time_PreciseFrame = 0;
+	G2PerformanceCounter_G2_TransformGhoulBones = 0;
+}
+
+void G2Time_ReportTimers(void)
+{
+	Com_Printf("\n---------------------------------\nRenderSurfaces: %i\nR_AddGhoulSurfaces: %i\nG2_TransformGhoulBones: %i\nG2_ProcessGeneratedSurfaceBolts: %i\nProcessModelBoltSurfaces: %i\nG2_ConstructGhoulSkeleton: %i\nRB_SurfaceGhoul: %i\nG2_SetupModelPointers: %i\n\nPrecise frame time: %i\nTransformGhoulBones calls: %i\n---------------------------------\n\n",
+		G2Time_RenderSurfaces,
+		G2Time_R_AddGHOULSurfaces,
+		G2Time_G2_TransformGhoulBones,
+		G2Time_G2_ProcessGeneratedSurfaceBolts,
+		G2Time_ProcessModelBoltSurfaces,
+		G2Time_G2_ConstructGhoulSkeleton,
+		G2Time_RB_SurfaceGhoul,
+		G2Time_G2_SetupModelPointers,
+		G2Time_PreciseFrame,
+		G2PerformanceCounter_G2_TransformGhoulBones
+	);
+}
+#endif
+
+//rww - RAGDOLL_BEGIN
+#ifdef __linux__
+#include <math.h>
+#else
+#include <float.h>
+#endif
+
+//rww - RAGDOLL_END
+
+bool HackadelicOnClient=false; // means this is a render traversal
+
+qboolean G2_SetupModelPointers(CGhoul2Info *ghlInfo);
+qboolean G2_SetupModelPointers(CGhoul2Info_v &ghoul2);
+
+extern cvar_t	*r_Ghoul2AnimSmooth;
+extern cvar_t	*r_Ghoul2UnSqashAfterSmooth;
+
+static inline int G2_Find_Bone_ByNum(const model_t *mod, boneInfo_v &blist, const int boneNum)
+{
+	int i = 0;
+
+	while (i < blist.size())
+	{
+		if (blist[i].boneNumber == boneNum)
+		{
+			return i;
+		}
+		i++;
+	}
+
+	return -1;
+}
+
+const static mdxaBone_t		identityMatrix = 
+{ 
+	0.0f, -1.0f, 0.0f, 0.0f,
+	1.0f, 0.0f, 0.0f, 0.0f,
+	0.0f, 0.0f, 1.0f, 0.0f
+};
+
+// I hate doing this, but this is the simplest way to get this into the routines it needs to be
+mdxaBone_t		worldMatrix;
+mdxaBone_t		worldMatrixInv;
+#ifdef _G2_GORE
+qhandle_t		goreShader=-1;
+#endif
+
+class CConstructBoneList
+{
+public:
+	int				surfaceNum;
+	int				*boneUsedList;
+	surfaceInfo_v	&rootSList;
+	model_t			*currentModel;
+	boneInfo_v		&boneList; 
+
+	CConstructBoneList(
+	int				initsurfaceNum,
+	int				*initboneUsedList,
+	surfaceInfo_v	&initrootSList,
+	model_t			*initcurrentModel,
+	boneInfo_v		&initboneList):
+
+	surfaceNum(initsurfaceNum),
+	boneUsedList(initboneUsedList),
+	rootSList(initrootSList),
+	currentModel(initcurrentModel),
+	boneList(initboneList) { }
+
+};
+
+class CTransformBone
+{
+public:
+#ifdef _XBOX
+	float			renderMatrix[16];
+#endif
+	int				touch; // for minimal recalculation
+	//rww - RAGDOLL_BEGIN
+	int				touchRender;
+	//rww - RAGDOLL_END
+	mdxaBone_t		boneMatrix; //final matrix
+	int				parent; // only set once
+#ifdef _XBOX
+	// This shouldn't be done like this. use declspec(aligned)?!
+	int				pad[1]; // must be 16-byte aligned!
+#endif
+	CTransformBone()
+	{
+		touch=0;
+	//rww - RAGDOLL_BEGIN
+		touchRender = 0;
+	//rww - RAGDOLL_END
+	}
+
+};
+
+struct SBoneCalc
+{
+	int				newFrame;
+	int				currentFrame;
+	float			backlerp;
+	float			blendFrame;
+	int				blendOldFrame;
+	bool			blendMode;
+	float			blendLerp;
+};
+
+class CBoneCache;
+void G2_TransformBone(int index,CBoneCache &CB);
+
+class CBoneCache
+{
+	void SetRenderMatrix(CTransformBone *bone)
+	{
+#ifdef _XBOX
+		float *src = bone->boneMatrix.matrix[0];
+		float *dst = bone->renderMatrix;
+
+		dst[0] = src[0];
+		dst[1] = src[4];
+		dst[2] = src[8];
+		dst[3] = 0;
+
+		dst[4] = src[1];
+		dst[5] = src[5];
+		dst[6] = src[9];
+		dst[7] = 0;
+
+		dst[8] = src[2];
+		dst[9] = src[6];
+		dst[10] = src[10];
+		dst[11] = 0;
+
+		dst[12] = src[3];
+		dst[13] = src[7];
+		dst[14] = src[11];
+		dst[15] = 1;
+#endif
+	}
+
+	void EvalLow(int index)
+	{
+		assert(index>=0&&index<mBones.size());
+		if (mFinalBones[index].touch!=mCurrentTouch)
+		{
+			// need to evaluate the bone
+#ifdef _XBOX
+			assert((mFinalBones[index].parent>=0&&mFinalBones[index].parent<mNumBones)||(index==0&&mFinalBones[index].parent==-1));
+#else
+			assert((mFinalBones[index].parent>=0&&mFinalBones[index].parent<mFinalBones.size())||(index==0&&mFinalBones[index].parent==-1));
+#endif
+			if (mFinalBones[index].parent>=0)
+			{
+				EvalLow(mFinalBones[index].parent); // make sure parent is evaluated
+				SBoneCalc &par=mBones[mFinalBones[index].parent];
+				mBones[index].newFrame=par.newFrame;
+				mBones[index].currentFrame=par.currentFrame;
+				mBones[index].backlerp=par.backlerp;
+				mBones[index].blendFrame=par.blendFrame;
+				mBones[index].blendOldFrame=par.blendOldFrame;
+				mBones[index].blendMode=par.blendMode;
+				mBones[index].blendLerp=par.blendLerp;
+			}
+			G2_TransformBone(index,*this);
+#ifdef _XBOX
+			SetRenderMatrix(mFinalBones + index);
+#endif
+			mFinalBones[index].touch=mCurrentTouch;
+		}
+	}
+//rww - RAGDOLL_BEGIN
+	void SmoothLow(int index)
+	{
+		if (mSmoothBones[index].touch==mLastTouch)
+		{
+			int i;
+			float *oldM=&mSmoothBones[index].boneMatrix.matrix[0][0];
+			float *newM=&mFinalBones[index].boneMatrix.matrix[0][0];
+#if 0 //this is just too slow. I need a better way.
+			static float smoothFactor;
+
+			smoothFactor = mSmoothFactor;
+
+			//Special rag smoothing -rww
+			if (smoothFactor < 0)
+			{ //I need a faster way to do this but I do not want to store more in the bonecache
+				static int blistIndex;
+				assert(mod);
+				assert(rootBoneList);
+				blistIndex = G2_Find_Bone_ByNum(mod, *rootBoneList, index);
+
+				assert(blistIndex != -1);
+
+				boneInfo_t &bone = (*rootBoneList)[blistIndex];
+
+				if (bone.flags & BONE_ANGLES_RAGDOLL)
+				{
+					if ((bone.RagFlags & (0x00008)) || //pelvis
+                        (bone.RagFlags & (0x00004))) //model_root
+					{ //pelvis and root do not smooth much
+						smoothFactor = 0.2f;
+					}
+					else if (bone.solidCount > 4)
+					{ //if stuck in solid a lot then snap out quickly
+						smoothFactor = 0.1f;
+					}
+					else
+					{ //otherwise smooth a bunch
+						smoothFactor = 0.8f;
+					}
+				}
+				else
+				{ //not a rag bone
+					smoothFactor = 0.3f;
+				}
+			}
+#endif
+
+			for (i=0;i<12;i++,oldM++,newM++)
+			{
+				*oldM=mSmoothFactor*(*oldM-*newM)+*newM;
+			}
+		}
+		else
+		{
+			memcpy(&mSmoothBones[index].boneMatrix,&mFinalBones[index].boneMatrix,sizeof(mdxaBone_t));
+		}
+		mdxaSkelOffsets_t *offsets = (mdxaSkelOffsets_t *)((byte *)header + sizeof(mdxaHeader_t));
+		mdxaSkel_t *skel = (mdxaSkel_t *)((byte *)header + sizeof(mdxaHeader_t) + offsets->offsets[index]);
+		mdxaBone_t tempMatrix;
+		Multiply_3x4Matrix(&tempMatrix,&mSmoothBones[index].boneMatrix, &skel->BasePoseMat);
+		float maxl;
+		maxl=VectorLength(&skel->BasePoseMat.matrix[0][0]);
+		VectorNormalize(&tempMatrix.matrix[0][0]);
+		VectorNormalize(&tempMatrix.matrix[1][0]);
+		VectorNormalize(&tempMatrix.matrix[2][0]);
+
+		VectorScale(&tempMatrix.matrix[0][0],maxl,&tempMatrix.matrix[0][0]);
+		VectorScale(&tempMatrix.matrix[1][0],maxl,&tempMatrix.matrix[1][0]);
+		VectorScale(&tempMatrix.matrix[2][0],maxl,&tempMatrix.matrix[2][0]);
+		Multiply_3x4Matrix(&mSmoothBones[index].boneMatrix,&tempMatrix,&skel->BasePoseMatInv);
+#ifdef _XBOX
+		// Added by BTO (VV) - I hope this is right.
+		SetRenderMatrix(mSmoothBones + index);
+#endif
+		mSmoothBones[index].touch=mCurrentTouch;
+#ifdef _DEBUG
+		for ( int i = 0; i < 3; i++ )
+		{
+			for ( int j = 0; j < 4; j++ )
+			{
+				assert( !_isnan(mSmoothBones[index].boneMatrix.matrix[i][j]));
+			}
+		}
+#endif// _DEBUG
+	}
+//rww - RAGDOLL_END
+public:
+	int					frameSize; 
+	const mdxaHeader_t	*header; 
+	const model_t		*mod; 
+
+	// these are split for better cpu cache behavior
+	vector<SBoneCalc> mBones;
+#ifdef _XBOX
+	CTransformBone*		   mFinalBones;
+	CTransformBone*		   mSmoothBones;
+#else
+	vector<CTransformBone> mFinalBones;
+
+	vector<CTransformBone> mSmoothBones; // for render smoothing
+#endif
+	//vector<mdxaSkel_t *>   mSkels;
+
+#ifdef _XBOX
+	int				mNumBones;
+#endif
+
+	boneInfo_v		*rootBoneList;
+	mdxaBone_t		rootMatrix;
+	int				incomingTime;
+
+	int				mCurrentTouch;
+	//rww - RAGDOLL_BEGIN
+	int				mCurrentTouchRender;
+	int				mLastTouch; 
+	int				mLastLastTouch;
+	//rww - RAGDOLL_END
+
+	// for render smoothing
+	bool			mSmoothingActive;
+	bool			mUnsquash;
+	float			mSmoothFactor;
+
+	CBoneCache(const model_t *amod,const mdxaHeader_t *aheader) :
+		mod(amod),
+		header(aheader)
+	{
+		assert(amod);
+		assert(aheader);
+		mSmoothingActive=false;
+		mUnsquash=false;
+		mSmoothFactor=0.0f;
+
+#ifdef _XBOX
+		mNumBones = header->numBones;
+#endif
+		int numBones=header->numBones;
+		mBones.resize(numBones);
+#ifdef _XBOX
+		mFinalBones = (CTransformBone*)Z_Malloc(sizeof(CTransformBone) * mNumBones, TAG_GHOUL2, qtrue, 16);
+		mSmoothBones = (CTransformBone*)Z_Malloc(sizeof(CTransformBone) * mNumBones, TAG_GHOUL2, qtrue, 16);
+#else
+		mFinalBones.resize(numBones);
+		mSmoothBones.resize(numBones);
+#endif
+//		mSkels.resize(numBones);
+		//rww - removed mSkels
+		mdxaSkelOffsets_t *offsets;
+		mdxaSkel_t		*skel;
+		offsets = (mdxaSkelOffsets_t *)((byte *)header + sizeof(mdxaHeader_t));
+
+		int i;
+		for (i=0;i<numBones;i++)
+		{
+			skel = (mdxaSkel_t *)((byte *)header + sizeof(mdxaHeader_t) + offsets->offsets[i]);
+			//mSkels[i]=skel;
+			//ditto
+			mFinalBones[i].parent=skel->parent;
+		}
+		mCurrentTouch=3;
+//rww - RAGDOLL_BEGIN
+		mLastTouch=2;
+		mLastLastTouch=1;
+//rww - RAGDOLL_END
+	}
+#ifdef _XBOX
+	~CBoneCache ()
+	{
+		// Alignment
+		Z_Free(mFinalBones);
+		Z_Free(mSmoothBones);
+	}
+#endif
+
+	SBoneCalc &Root()
+	{
+		assert(mBones.size());
+		return mBones[0];
+	}
+	const mdxaBone_t &EvalUnsmooth(int index)
+	{
+		EvalLow(index);
+		if (mSmoothingActive&&mSmoothBones[index].touch)
+		{
+			return mSmoothBones[index].boneMatrix;
+		}
+		return mFinalBones[index].boneMatrix;
+	}
+	const mdxaBone_t &Eval(int index)
+	{
+		/*
+		bool wasEval=EvalLow(index);
+		if (mSmoothingActive)
+		{
+			if (mSmoothBones[index].touch!=incomingTime||wasEval)
+			{
+				float dif=float(incomingTime)-float(mSmoothBones[index].touch);
+				if (mSmoothBones[index].touch&&dif<300.0f)
+				{
+
+					if (dif<16.0f)  // 60 fps
+					{
+						dif=16.0f;
+					}
+					if (dif>100.0f) // 10 fps
+					{
+						dif=100.0f;
+					}
+					float f=1.0f-pow(1.0f-mSmoothFactor,16.0f/dif);
+
+					int i;
+					float *oldM=&mSmoothBones[index].boneMatrix.matrix[0][0];
+					float *newM=&mFinalBones[index].boneMatrix.matrix[0][0];
+					for (i=0;i<12;i++,oldM++,newM++)
+					{
+						*oldM=f*(*oldM-*newM)+*newM;
+					}
+					if (mUnsquash)
+					{
+						mdxaBone_t tempMatrix;
+						Multiply_3x4Matrix(&tempMatrix,&mSmoothBones[index].boneMatrix, &mSkels[index]->BasePoseMat);
+						float maxl;
+						maxl=VectorLength(&mSkels[index]->BasePoseMat.matrix[0][0]);
+						VectorNormalize(&tempMatrix.matrix[0][0]);
+						VectorNormalize(&tempMatrix.matrix[1][0]);
+						VectorNormalize(&tempMatrix.matrix[2][0]);
+
+						VectorScale(&tempMatrix.matrix[0][0],maxl,&tempMatrix.matrix[0][0]);
+						VectorScale(&tempMatrix.matrix[1][0],maxl,&tempMatrix.matrix[1][0]);
+						VectorScale(&tempMatrix.matrix[2][0],maxl,&tempMatrix.matrix[2][0]);
+						Multiply_3x4Matrix(&mSmoothBones[index].boneMatrix,&tempMatrix,&mSkels[index]->BasePoseMatInv);
+					}
+				}
+				else
+				{
+					memcpy(&mSmoothBones[index].boneMatrix,&mFinalBones[index].boneMatrix,sizeof(mdxaBone_t));
+				}
+				mSmoothBones[index].touch=incomingTime;
+			}
+			return mSmoothBones[index].boneMatrix;
+		}
+		return mFinalBones[index].boneMatrix;
+		*/
+
+		//Hey, this is what sof2 does. Let's try it out.
+		assert(index>=0&&index<mBones.size());
+		if (mFinalBones[index].touch!=mCurrentTouch)
+		{
+			EvalLow(index);
+		}
+		return mFinalBones[index].boneMatrix;
+	}
+	//rww - RAGDOLL_BEGIN
+	const inline mdxaBone_t &EvalRender(int index)
+	{
+		assert(index>=0&&index<mBones.size());
+		if (mFinalBones[index].touch!=mCurrentTouch)
+		{
+			mFinalBones[index].touchRender=mCurrentTouchRender;
+			EvalLow(index);
+		}
+		if (mSmoothingActive)
+		{
+			if (mSmoothBones[index].touch!=mCurrentTouch)
+			{
+				SmoothLow(index);
+			}
+			return mSmoothBones[index].boneMatrix;
+		}
+		return mFinalBones[index].boneMatrix;
+	}
+	//rww - RAGDOLL_END
+	//rww - RAGDOLL_BEGIN
+	bool WasRendered(int index)
+	{
+		assert(index>=0&&index<mBones.size());
+		return mFinalBones[index].touchRender==mCurrentTouchRender;
+	}
+	int GetParent(int index)
+	{
+		if (index==0)
+		{
+			return -1;
+		}
+		assert(index>=0&&index<mBones.size());
+		return mFinalBones[index].parent;
+	}
+	//rww - RAGDOLL_END
+
+#ifdef _XBOX
+	CTransformBone *EvalFull(int index)
+	{
+		EvalRender(index);
+		if (mSmoothingActive)
+		{
+			return mSmoothBones + index;
+		}
+		return mFinalBones + index;
+	}
+#endif
+};
+
+void RemoveBoneCache(CBoneCache *boneCache)
+{
+#ifdef _FULL_G2_LEAK_CHECKING
+	g_Ghoul2Allocations -= sizeof(*boneCache);
+#endif
+
+	delete boneCache;
+}
+
+#ifdef _G2_LISTEN_SERVER_OPT
+void CopyBoneCache(CBoneCache *to, CBoneCache *from)
+{
+	memcpy(to, from, sizeof(CBoneCache));
+}
+#endif
+
+const mdxaBone_t &EvalBoneCache(int index,CBoneCache *boneCache)
+{
+	assert(boneCache);
+	return boneCache->Eval(index);
+}
+
+//rww - RAGDOLL_BEGIN
+const mdxaHeader_t *G2_GetModA(CGhoul2Info &ghoul2)
+{
+	if (!ghoul2.mBoneCache)
+	{
+		return 0;
+	}
+
+	CBoneCache &boneCache=*ghoul2.mBoneCache;
+	return boneCache.header;
+}
+
+int G2_GetBoneDependents(CGhoul2Info &ghoul2,int boneNum,int *tempDependents,int maxDep)
+{
+	// fixme, these should be precomputed
+	if (!ghoul2.mBoneCache||!maxDep)
+	{
+		return 0;
+	}
+
+	CBoneCache &boneCache=*ghoul2.mBoneCache;
+	mdxaSkel_t		*skel;
+	mdxaSkelOffsets_t *offsets;
+	offsets = (mdxaSkelOffsets_t *)((byte *)boneCache.header + sizeof(mdxaHeader_t));
+	skel = (mdxaSkel_t *)((byte *)boneCache.header + sizeof(mdxaHeader_t) + offsets->offsets[boneNum]);
+	int i;
+	int ret=0;
+	for (i=0;i<skel->numChildren;i++)
+	{
+		if (!maxDep)
+		{
+			return i; // number added
+		}
+		*tempDependents=skel->children[i];
+		assert(*tempDependents>0&&*tempDependents<boneCache.header->numBones);
+		maxDep--;
+		tempDependents++;
+		ret++;
+	}
+	for (i=0;i<skel->numChildren;i++)
+	{
+		int num=G2_GetBoneDependents(ghoul2,skel->children[i],tempDependents,maxDep);
+		tempDependents+=num;
+		ret+=num;
+		maxDep-=num;
+		assert(maxDep>=0);
+		if (!maxDep)
+		{
+			break;
+		}
+	}
+	return ret;
+}
+
+bool G2_WasBoneRendered(CGhoul2Info &ghoul2,int boneNum)
+{
+	if (!ghoul2.mBoneCache)
+	{
+		return false;
+	}
+	CBoneCache &boneCache=*ghoul2.mBoneCache;
+
+	return boneCache.WasRendered(boneNum);
+}
+
+void G2_GetBoneBasepose(CGhoul2Info &ghoul2,int boneNum,mdxaBone_t *&retBasepose,mdxaBone_t *&retBaseposeInv)
+{
+	if (!ghoul2.mBoneCache)
+	{
+		// yikes
+		retBasepose=const_cast<mdxaBone_t *>(&identityMatrix);
+		retBaseposeInv=const_cast<mdxaBone_t *>(&identityMatrix);
+		return;
+	}
+	assert(ghoul2.mBoneCache);
+	CBoneCache &boneCache=*ghoul2.mBoneCache;
+	assert(boneCache.mod);
+	assert(boneNum>=0&&boneNum<boneCache.header->numBones);
+
+	mdxaSkel_t		*skel;
+	mdxaSkelOffsets_t *offsets;
+	offsets = (mdxaSkelOffsets_t *)((byte *)boneCache.header + sizeof(mdxaHeader_t));
+	skel = (mdxaSkel_t *)((byte *)boneCache.header + sizeof(mdxaHeader_t) + offsets->offsets[boneNum]);
+	retBasepose=&skel->BasePoseMat;
+	retBaseposeInv=&skel->BasePoseMatInv;
+}
+
+char *G2_GetBoneNameFromSkel(CGhoul2Info &ghoul2, int boneNum)
+{
+	if (!ghoul2.mBoneCache)
+	{
+		return NULL;
+	}
+	CBoneCache &boneCache=*ghoul2.mBoneCache;
+	assert(boneCache.mod);
+	assert(boneNum>=0&&boneNum<boneCache.header->numBones);
+
+	mdxaSkel_t		*skel;
+	mdxaSkelOffsets_t *offsets;
+	offsets = (mdxaSkelOffsets_t *)((byte *)boneCache.header + sizeof(mdxaHeader_t));
+	skel = (mdxaSkel_t *)((byte *)boneCache.header + sizeof(mdxaHeader_t) + offsets->offsets[boneNum]);
+
+	return skel->name;
+}
+
+void G2_RagGetBoneBasePoseMatrixLow(CGhoul2Info &ghoul2, int boneNum, mdxaBone_t &boneMatrix, mdxaBone_t &retMatrix, vec3_t scale)
+{
+	assert(ghoul2.mBoneCache);
+	CBoneCache &boneCache=*ghoul2.mBoneCache;
+	assert(boneCache.mod);
+	assert(boneNum>=0&&boneNum<boneCache.header->numBones);
+
+	mdxaSkel_t		*skel;
+	mdxaSkelOffsets_t *offsets;
+	offsets = (mdxaSkelOffsets_t *)((byte *)boneCache.header + sizeof(mdxaHeader_t));
+	skel = (mdxaSkel_t *)((byte *)boneCache.header + sizeof(mdxaHeader_t) + offsets->offsets[boneNum]);
+	Multiply_3x4Matrix(&retMatrix, &boneMatrix, &skel->BasePoseMat);
+
+	if (scale[0])
+	{
+		retMatrix.matrix[0][3] *= scale[0];
+	}
+	if (scale[1])
+	{
+		retMatrix.matrix[1][3] *= scale[1];
+	}
+	if (scale[2])
+	{
+		retMatrix.matrix[2][3] *= scale[2];
+	}
+
+	VectorNormalize((float*)&retMatrix.matrix[0]);
+	VectorNormalize((float*)&retMatrix.matrix[1]);
+	VectorNormalize((float*)&retMatrix.matrix[2]);
+}
+
+void G2_GetBoneMatrixLow(CGhoul2Info &ghoul2,int boneNum,const vec3_t scale,mdxaBone_t &retMatrix,mdxaBone_t *&retBasepose,mdxaBone_t *&retBaseposeInv)
+{
+	if (!ghoul2.mBoneCache)
+	{
+		retMatrix=identityMatrix;
+		// yikes
+		retBasepose=const_cast<mdxaBone_t *>(&identityMatrix);
+		retBaseposeInv=const_cast<mdxaBone_t *>(&identityMatrix);
+		return;
+	}
+	mdxaBone_t bolt;
+	assert(ghoul2.mBoneCache);
+	CBoneCache &boneCache=*ghoul2.mBoneCache;
+	assert(boneCache.mod);
+	assert(boneNum>=0&&boneNum<boneCache.header->numBones);
+
+	mdxaSkel_t		*skel;
+	mdxaSkelOffsets_t *offsets;
+	offsets = (mdxaSkelOffsets_t *)((byte *)boneCache.header + sizeof(mdxaHeader_t));
+	skel = (mdxaSkel_t *)((byte *)boneCache.header + sizeof(mdxaHeader_t) + offsets->offsets[boneNum]);
+	Multiply_3x4Matrix(&bolt, (mdxaBone_t *)&boneCache.Eval(boneNum), &skel->BasePoseMat); // DEST FIRST ARG
+	retBasepose=&skel->BasePoseMat;
+	retBaseposeInv=&skel->BasePoseMatInv;
+
+	if (scale[0])
+	{
+		bolt.matrix[0][3] *= scale[0];
+	}
+	if (scale[1])
+	{
+		bolt.matrix[1][3] *= scale[1];
+	}
+	if (scale[2])
+	{
+		bolt.matrix[2][3] *= scale[2];
+	}
+	VectorNormalize((float*)&bolt.matrix[0]);
+	VectorNormalize((float*)&bolt.matrix[1]);
+	VectorNormalize((float*)&bolt.matrix[2]);
+
+	Multiply_3x4Matrix(&retMatrix,&worldMatrix, &bolt);												
+	
+#ifdef _DEBUG
+	for ( int i = 0; i < 3; i++ )
+	{
+		for ( int j = 0; j < 4; j++ )
+		{
+			assert( !_isnan(retMatrix.matrix[i][j]));
+		}
+	}
+#endif// _DEBUG
+}
+
+int G2_GetParentBoneMatrixLow(CGhoul2Info &ghoul2,int boneNum,const vec3_t scale,mdxaBone_t &retMatrix,mdxaBone_t *&retBasepose,mdxaBone_t *&retBaseposeInv)
+{
+	int parent=-1;
+	if (ghoul2.mBoneCache)
+	{
+		CBoneCache &boneCache=*ghoul2.mBoneCache;
+		assert(boneCache.mod);
+		assert(boneNum>=0&&boneNum<boneCache.header->numBones);
+		parent=boneCache.GetParent(boneNum);
+		if (parent<0||parent>=boneCache.header->numBones)
+		{
+			parent=-1;
+			retMatrix=identityMatrix;
+			// yikes
+			retBasepose=const_cast<mdxaBone_t *>(&identityMatrix);
+			retBaseposeInv=const_cast<mdxaBone_t *>(&identityMatrix);
+		}
+		else
+		{
+			G2_GetBoneMatrixLow(ghoul2,parent,scale,retMatrix,retBasepose,retBaseposeInv);
+		}
+	}
+	return parent;
+}
+//rww - RAGDOLL_END
+
+class CRenderSurface
+{
+public:
+	int				surfaceNum;
+	surfaceInfo_v	&rootSList;
+	shader_t		*cust_shader;
+	int				fogNum;
+	qboolean		personalModel;
+	CBoneCache		*boneCache;
+	int				renderfx;
+	skin_t			*skin;
+	model_t			*currentModel;
+	int				lod;
+	boltInfo_v		&boltList;
+#ifdef _G2_GORE
+	shader_t		*gore_shader;
+	CGoreSet		*gore_set;
+#endif
+
+	CRenderSurface(
+	int				initsurfaceNum,
+	surfaceInfo_v	&initrootSList,
+	shader_t		*initcust_shader,
+	int				initfogNum,
+	qboolean		initpersonalModel,
+	CBoneCache		*initboneCache,
+	int				initrenderfx,
+	skin_t			*initskin,
+	model_t			*initcurrentModel,
+	int				initlod,
+#ifdef _G2_GORE
+	boltInfo_v		&initboltList,
+	shader_t		*initgore_shader,
+	CGoreSet		*initgore_set):
+#else
+	boltInfo_v		&initboltList):
+#endif
+
+	surfaceNum(initsurfaceNum),
+	rootSList(initrootSList),
+	cust_shader(initcust_shader),
+	fogNum(initfogNum),
+	personalModel(initpersonalModel),
+	boneCache(initboneCache),
+	renderfx(initrenderfx),
+	skin(initskin),
+	currentModel(initcurrentModel),
+	lod(initlod),
+#ifdef _G2_GORE
+	boltList(initboltList),
+	gore_shader(initgore_shader),
+	gore_set(initgore_set)
+#else
+	boltList(initboltList)
+#endif
+	{}
+};
+
+#ifdef _G2_GORE
+#define MAX_RENDER_SURFACES (2048)
+static CRenderableSurface RSStorage[MAX_RENDER_SURFACES];
+static unsigned int NextRS=0;
+
+CRenderableSurface *AllocRS()
+{
+	CRenderableSurface *ret=&RSStorage[NextRS];
+	ret->Init();
+	NextRS++;
+	NextRS%=MAX_RENDER_SURFACES;
+	return ret;
+}
+#endif
+
+/*
+
+All bones should be an identity orientation to display the mesh exactly
+as it is specified.
+
+For all other frames, the bones represent the transformation from the 
+orientation of the bone in the base frame to the orientation in this
+frame.
+
+*/
+
+
+/*
+=============
+R_ACullModel
+=============
+*/
+static int R_GCullModel( trRefEntity_t *ent ) {
+
+	// scale the radius if need be
+	float largestScale = ent->e.modelScale[0];
+
+	if (ent->e.modelScale[1] > largestScale)
+	{
+		largestScale = ent->e.modelScale[1];
+	}
+	if (ent->e.modelScale[2] > largestScale)
+	{
+		largestScale = ent->e.modelScale[2];
+	}
+	if (!largestScale)
+	{
+		largestScale = 1;
+	}
+
+	// cull bounding sphere 
+  	switch ( R_CullLocalPointAndRadius( vec3_origin,  ent->e.radius * largestScale) )
+  	{
+  	case CULL_OUT:
+  		tr.pc.c_sphere_cull_md3_out++;
+  		return CULL_OUT;
+
+	case CULL_IN:
+		tr.pc.c_sphere_cull_md3_in++;
+		return CULL_IN;
+
+	case CULL_CLIP:
+		tr.pc.c_sphere_cull_md3_clip++;
+		return CULL_IN;
+ 	}
+	return CULL_IN;
+}
+
+
+/*
+=================
+R_AComputeFogNum
+
+=================
+*/
+static int R_GComputeFogNum( trRefEntity_t *ent ) {
+
+	int				i, j;
+	fog_t			*fog;
+
+	if ( tr.refdef.rdflags & RDF_NOWORLDMODEL ) {
+		return 0;
+	}
+
+	for ( i = 1 ; i < tr.world->numfogs ; i++ ) {
+		fog = &tr.world->fogs[i];
+		for ( j = 0 ; j < 3 ; j++ ) {
+			if ( ent->e.origin[j] - ent->e.radius >= fog->bounds[1][j] ) {
+				break;
+			}
+			if ( ent->e.origin[j] + ent->e.radius <= fog->bounds[0][j] ) {
+				break;
+			}
+		}
+		if ( j == 3 ) {
+			return i;
+		}
+	}
+
+	return 0;
+}
+
+// work out lod for this entity.
+static int G2_ComputeLOD( trRefEntity_t *ent, const model_t *currentModel, int lodBias ) 
+{
+	float flod, lodscale;
+	float projectedRadius;
+	int lod;
+
+	if ( currentModel->numLods < 2 )
+	{	// model has only 1 LOD level, skip computations and bias
+		return(0);
+	}
+
+	if ( r_lodbias->integer > lodBias ) 
+	{
+		lodBias = r_lodbias->integer;
+	}
+
+	// scale the radius if need be
+	float largestScale = ent->e.modelScale[0];
+
+	if (ent->e.modelScale[1] > largestScale)
+	{
+		largestScale = ent->e.modelScale[1];
+	}
+	if (ent->e.modelScale[2] > largestScale)
+	{
+		largestScale = ent->e.modelScale[2];
+	}
+	if (!largestScale)
+	{
+		largestScale = 1;
+	}
+
+	if ( ( projectedRadius = ProjectRadius( 0.75*largestScale*ent->e.radius, ent->e.origin ) ) != 0 )	//we reduce the radius to make the LOD match other model types which use the actual bound box size
+ 	{
+ 		lodscale = (r_lodscale->value+r_autolodscalevalue->value);
+ 		if ( lodscale > 20 ) 
+		{
+			lodscale = 20;	 
+		}
+		else if ( lodscale < 0 )
+		{
+			lodscale = 0;
+		}
+ 		flod = 1.0f - projectedRadius * lodscale;
+ 	}
+ 	else
+ 	{
+ 		// object intersects near view plane, e.g. view weapon
+ 		flod = 0;
+ 	}
+#ifdef DEDICATED
+#define myftol(x) ((int)(x))
+#endif
+ 	flod *= currentModel->numLods;
+ 	lod = myftol( flod );
+
+ 	if ( lod < 0 )
+ 	{
+ 		lod = 0;
+ 	}
+ 	else if ( lod >= currentModel->numLods )
+ 	{
+ 		lod = currentModel->numLods - 1;
+ 	}
+
+
+	lod += lodBias;
+	
+	if ( lod >= currentModel->numLods )
+		lod = currentModel->numLods - 1;
+	if ( lod < 0 )
+		lod = 0;
+
+	return lod;
+}
+
+//======================================================================
+//
+// Bone Manipulation code
+
+
+void G2_CreateQuaterion(mdxaBone_t *mat, vec4_t quat)
+{
+	// this is revised for the 3x4 matrix we use in G2.
+    float t = 1 + mat->matrix[0][0] + mat->matrix[1][1] + mat->matrix[2][2];
+	float s;
+
+    //If the trace of the matrix is greater than zero, then
+    //perform an "instant" calculation.
+    //Important note wrt. rouning errors:
+    //Test if ( T > 0.00000001 ) to avoid large distortions!
+	if (t > 0.00000001)
+	{
+      s = sqrt(t) * 2;
+      quat[0] = ( mat->matrix[1][2] - mat->matrix[2][1] ) / s;
+      quat[1] = ( mat->matrix[2][0] - mat->matrix[0][2] ) / s;
+      quat[2] = ( mat->matrix[0][1] - mat->matrix[1][0] ) / s;
+      quat[3] = 0.25 * s;
+	}
+	else
+	{
+		//If the trace of the matrix is equal to zero then identify
+		//which major diagonal element has the greatest value.
+
+		//Depending on this, calculate the following:
+
+		if ( mat->matrix[0][0] > mat->matrix[1][1] && mat->matrix[0][0] > mat->matrix[2][2] )  {	// Column 0: 
+			s  = sqrt( 1.0 + mat->matrix[0][0] - mat->matrix[1][1] - mat->matrix[2][2])* 2;
+			quat[0] = 0.25 * s;
+			quat[1] = (mat->matrix[0][1] + mat->matrix[1][0] ) / s;
+			quat[2] = (mat->matrix[2][0] + mat->matrix[0][2] ) / s;
+			quat[3] = (mat->matrix[1][2] - mat->matrix[2][1] ) / s;
+		
+		} else if ( mat->matrix[1][1] > mat->matrix[2][2] ) {			// Column 1: 
+			s  = sqrt( 1.0 + mat->matrix[1][1] - mat->matrix[0][0] - mat->matrix[2][2] ) * 2;
+			quat[0] = (mat->matrix[0][1] + mat->matrix[1][0] ) / s;
+			quat[1] = 0.25 * s;
+			quat[2] = (mat->matrix[1][2] + mat->matrix[2][1] ) / s;
+			quat[3] = (mat->matrix[2][0] - mat->matrix[0][2] ) / s;
+
+		} else {						// Column 2:
+			s  = sqrt( 1.0 + mat->matrix[2][2] - mat->matrix[0][0] - mat->matrix[1][1] ) * 2;
+			quat[0] = (mat->matrix[2][0]+ mat->matrix[0][2] ) / s;
+			quat[1] = (mat->matrix[1][2] + mat->matrix[2][1] ) / s;
+			quat[2] = 0.25 * s;
+			quat[3] = (mat->matrix[0][1] - mat->matrix[1][0] ) / s;
+		}
+	}
+}
+
+void G2_CreateMatrixFromQuaterion(mdxaBone_t *mat, vec4_t quat)
+{
+	
+    float xx      = quat[0] * quat[0];
+    float xy      = quat[0] * quat[1];
+    float xz      = quat[0] * quat[2];
+    float xw      = quat[0] * quat[3];
+
+    float yy      = quat[1] * quat[1];
+    float yz      = quat[1] * quat[2];
+    float yw      = quat[1] * quat[3];
+
+    float zz      = quat[2] * quat[2];
+    float zw      = quat[2] * quat[3];
+
+    mat->matrix[0][0]  = 1 - 2 * ( yy + zz );
+    mat->matrix[1][0]  =     2 * ( xy - zw );
+    mat->matrix[2][0]  =     2 * ( xz + yw );
+
+    mat->matrix[0][1]  =     2 * ( xy + zw );
+    mat->matrix[1][1]  = 1 - 2 * ( xx + zz );
+    mat->matrix[2][1]  =     2 * ( yz - xw );
+
+    mat->matrix[0][2]  =     2 * ( xz - yw );
+    mat->matrix[1][2]  =     2 * ( yz + xw );
+    mat->matrix[2][2]  = 1 - 2 * ( xx + yy );
+
+    mat->matrix[0][3]  = mat->matrix[1][3] = mat->matrix[2][3] = 0;
+}
+
+// nasty little matrix multiply going on here..
+void Multiply_3x4Matrix(mdxaBone_t *out, mdxaBone_t *in2, mdxaBone_t *in) 
+{
+	// first row of out                                                                                      
+	out->matrix[0][0] = (in2->matrix[0][0] * in->matrix[0][0]) + (in2->matrix[0][1] * in->matrix[1][0]) + (in2->matrix[0][2] * in->matrix[2][0]);
+	out->matrix[0][1] = (in2->matrix[0][0] * in->matrix[0][1]) + (in2->matrix[0][1] * in->matrix[1][1]) + (in2->matrix[0][2] * in->matrix[2][1]);
+	out->matrix[0][2] = (in2->matrix[0][0] * in->matrix[0][2]) + (in2->matrix[0][1] * in->matrix[1][2]) + (in2->matrix[0][2] * in->matrix[2][2]);
+	out->matrix[0][3] = (in2->matrix[0][0] * in->matrix[0][3]) + (in2->matrix[0][1] * in->matrix[1][3]) + (in2->matrix[0][2] * in->matrix[2][3]) + in2->matrix[0][3];
+	// second row of outf out                                                                                     
+	out->matrix[1][0] = (in2->matrix[1][0] * in->matrix[0][0]) + (in2->matrix[1][1] * in->matrix[1][0]) + (in2->matrix[1][2] * in->matrix[2][0]);
+	out->matrix[1][1] = (in2->matrix[1][0] * in->matrix[0][1]) + (in2->matrix[1][1] * in->matrix[1][1]) + (in2->matrix[1][2] * in->matrix[2][1]);
+	out->matrix[1][2] = (in2->matrix[1][0] * in->matrix[0][2]) + (in2->matrix[1][1] * in->matrix[1][2]) + (in2->matrix[1][2] * in->matrix[2][2]);
+	out->matrix[1][3] = (in2->matrix[1][0] * in->matrix[0][3]) + (in2->matrix[1][1] * in->matrix[1][3]) + (in2->matrix[1][2] * in->matrix[2][3]) + in2->matrix[1][3];
+	// third row of out  out                                                                                      
+	out->matrix[2][0] = (in2->matrix[2][0] * in->matrix[0][0]) + (in2->matrix[2][1] * in->matrix[1][0]) + (in2->matrix[2][2] * in->matrix[2][0]);
+	out->matrix[2][1] = (in2->matrix[2][0] * in->matrix[0][1]) + (in2->matrix[2][1] * in->matrix[1][1]) + (in2->matrix[2][2] * in->matrix[2][1]);
+	out->matrix[2][2] = (in2->matrix[2][0] * in->matrix[0][2]) + (in2->matrix[2][1] * in->matrix[1][2]) + (in2->matrix[2][2] * in->matrix[2][2]);
+	out->matrix[2][3] = (in2->matrix[2][0] * in->matrix[0][3]) + (in2->matrix[2][1] * in->matrix[1][3]) + (in2->matrix[2][2] * in->matrix[2][3]) + in2->matrix[2][3]; 
+}
+
+
+static int G2_GetBonePoolIndex(	const mdxaHeader_t *pMDXAHeader, int iFrame, int iBone)
+{
+	const int iOffsetToIndex = (iFrame * pMDXAHeader->numBones * 3) + (iBone * 3);
+
+	mdxaIndex_t *pIndex = (mdxaIndex_t *) ((byte*) pMDXAHeader + pMDXAHeader->ofsFrames + iOffsetToIndex);
+
+	return pIndex->iIndex & 0x00FFFFFF;	// this will cause problems for big-endian machines... ;-)
+}
+
+
+/*static inline*/ void UnCompressBone(float mat[3][4], int iBoneIndex, const mdxaHeader_t *pMDXAHeader, int iFrame)
+{
+	mdxaCompQuatBone_t *pCompBonePool = (mdxaCompQuatBone_t *) ((byte *)pMDXAHeader + pMDXAHeader->ofsCompBonePool);
+	MC_UnCompressQuat(mat, pCompBonePool[ G2_GetBonePoolIndex( pMDXAHeader, iFrame, iBoneIndex ) ].Comp);
+}
+
+#define DEBUG_G2_TIMING (0)
+#define DEBUG_G2_TIMING_RENDER_ONLY (1)
+
+void G2_TimingModel(boneInfo_t &bone,int currentTime,int numFramesInFile,int &currentFrame,int &newFrame,float &lerp)
+{
+	assert(bone.startFrame>=0);
+	assert(bone.startFrame<=numFramesInFile);
+	assert(bone.endFrame>=0);
+	assert(bone.endFrame<=numFramesInFile);
+
+	// yes - add in animation speed to current frame
+	float	animSpeed = bone.animSpeed;
+	float	time;
+	if (bone.pauseTime)
+	{
+		time = (bone.pauseTime - bone.startTime) / 50.0f;
+	}
+	else
+	{			
+		time = (currentTime - bone.startTime) / 50.0f;
+	}
+	if (time<0.0f)
+	{
+		time=0.0f;
+	}
+	float	newFrame_g = bone.startFrame + (time * animSpeed);
+
+	int		animSize = bone.endFrame - bone.startFrame;
+	float	endFrame = (float)bone.endFrame;
+	// we are supposed to be animating right?
+	if (animSize)
+	{
+		// did we run off the end?
+		if (((animSpeed > 0.0f) && (newFrame_g > endFrame - 1)) || 
+			((animSpeed < 0.0f) && (newFrame_g < endFrame+1)))
+		{
+			// yep - decide what to do
+			if (bone.flags & BONE_ANIM_OVERRIDE_LOOP)
+			{
+				// get our new animation frame back within the bounds of the animation set
+				if (animSpeed < 0.0f)
+				{
+					// we don't use this case, or so I am told
+					// if we do, let me know, I need to insure the mod works
+
+					// should we be creating a virtual frame?
+					if ((newFrame_g < endFrame+1) && (newFrame_g >= endFrame))
+					{
+						// now figure out what we are lerping between
+						// delta is the fraction between this frame and the next, since the new anim is always at a .0f;
+						lerp = float(endFrame+1)-newFrame_g;
+						// frames are easy to calculate
+						currentFrame = endFrame;
+						assert(currentFrame>=0&&currentFrame<numFramesInFile);
+						newFrame = bone.startFrame;
+						assert(newFrame>=0&&newFrame<numFramesInFile);
+					}
+					else
+					{
+						if (newFrame_g <= endFrame+1)
+						{
+							newFrame_g=endFrame+fmod(newFrame_g-endFrame,animSize)-animSize;
+						}
+						// now figure out what we are lerping between
+						// delta is the fraction between this frame and the next, since the new anim is always at a .0f;
+						lerp = (ceil(newFrame_g)-newFrame_g);
+						// frames are easy to calculate
+						currentFrame = ceil(newFrame_g);
+						assert(currentFrame>=0&&currentFrame<numFramesInFile);
+						// should we be creating a virtual frame?
+						if (currentFrame <= endFrame+1 )
+						{
+							newFrame = bone.startFrame;
+							assert(newFrame>=0&&newFrame<numFramesInFile);
+						}
+						else
+						{
+							newFrame = currentFrame - 1;
+							assert(newFrame>=0&&newFrame<numFramesInFile);
+						}
+					}
+				}
+				else
+				{
+					// should we be creating a virtual frame?
+					if ((newFrame_g > endFrame - 1) && (newFrame_g < endFrame))
+					{
+						// now figure out what we are lerping between
+						// delta is the fraction between this frame and the next, since the new anim is always at a .0f;
+						lerp = (newFrame_g - (int)newFrame_g);
+						// frames are easy to calculate
+						currentFrame = (int)newFrame_g;
+						assert(currentFrame>=0&&currentFrame<numFramesInFile);
+						newFrame = bone.startFrame;
+						assert(newFrame>=0&&newFrame<numFramesInFile);
+					}
+					else
+					{
+						if (newFrame_g >= endFrame)
+						{
+							newFrame_g=endFrame+fmod(newFrame_g-endFrame,animSize)-animSize;
+						}
+						// now figure out what we are lerping between
+						// delta is the fraction between this frame and the next, since the new anim is always at a .0f;
+						lerp = (newFrame_g - (int)newFrame_g);
+						// frames are easy to calculate
+						currentFrame = (int)newFrame_g;
+						assert(currentFrame>=0&&currentFrame<numFramesInFile);
+						// should we be creating a virtual frame?
+						if (newFrame_g >= endFrame - 1)
+						{
+							newFrame = bone.startFrame;
+							assert(newFrame>=0&&newFrame<numFramesInFile);
+						}
+						else
+						{
+							newFrame = currentFrame + 1;
+							assert(newFrame>=0&&newFrame<numFramesInFile);
+						}
+					}
+				}
+				// sanity check
+				assert ((newFrame < endFrame) && (newFrame >= bone.startFrame) || (animSize < 10)); 
+			}
+			else
+			{
+				if (((bone.flags & (BONE_ANIM_OVERRIDE_FREEZE)) == (BONE_ANIM_OVERRIDE_FREEZE)))
+				{
+					// if we are supposed to reset the default anim, then do so
+					if (animSpeed > 0.0f)
+					{
+						currentFrame = bone.endFrame - 1;
+						assert(currentFrame>=0&&currentFrame<numFramesInFile);
+					}
+					else
+					{
+						currentFrame = bone.endFrame+1;
+						assert(currentFrame>=0&&currentFrame<numFramesInFile);
+					}
+
+					newFrame = currentFrame;
+					assert(newFrame>=0&&newFrame<numFramesInFile);
+					lerp = 0;
+				}
+				else
+				{
+					bone.flags &= ~(BONE_ANIM_TOTAL);
+				}
+
+			}
+		}
+		else
+		{
+			if (animSpeed> 0.0)
+			{
+				// frames are easy to calculate
+				currentFrame = (int)newFrame_g;
+
+				// figure out the difference between the two frames	- we have to decide what frame and what percentage of that
+				// frame we want to display
+				lerp = (newFrame_g - currentFrame);
+
+				assert(currentFrame>=0&&currentFrame<numFramesInFile);
+
+				newFrame = currentFrame + 1;
+				// are we now on the end frame?
+				assert((int)endFrame<=numFramesInFile);
+				if (newFrame >= (int)endFrame)
+				{
+					// we only want to lerp with the first frame of the anim if we are looping 
+					if (bone.flags & BONE_ANIM_OVERRIDE_LOOP)
+					{
+					  	newFrame = bone.startFrame;
+						assert(newFrame>=0&&newFrame<numFramesInFile);
+					}
+					// if we intend to end this anim or freeze after this, then just keep on the last frame
+					else
+					{
+						newFrame = bone.endFrame-1;
+						assert(newFrame>=0&&newFrame<numFramesInFile);
+					}
+				}
+				assert(newFrame>=0&&newFrame<numFramesInFile);
+			}
+			else
+			{
+				lerp = (ceil(newFrame_g)-newFrame_g);
+				// frames are easy to calculate
+				currentFrame = ceil(newFrame_g);
+				if (currentFrame>bone.startFrame)
+				{
+					currentFrame=bone.startFrame;
+					newFrame = currentFrame;
+					lerp=0.0f;
+				}
+				else
+				{
+					newFrame=currentFrame-1;
+					// are we now on the end frame?
+					if (newFrame < endFrame+1)
+					{
+						// we only want to lerp with the first frame of the anim if we are looping 
+						if (bone.flags & BONE_ANIM_OVERRIDE_LOOP)
+						{
+					  		newFrame = bone.startFrame;
+							assert(newFrame>=0&&newFrame<numFramesInFile);
+						}
+						// if we intend to end this anim or freeze after this, then just keep on the last frame
+						else
+						{
+							newFrame = bone.endFrame+1;
+							assert(newFrame>=0&&newFrame<numFramesInFile);
+						}
+					}
+				}
+				assert(currentFrame>=0&&currentFrame<numFramesInFile);
+				assert(newFrame>=0&&newFrame<numFramesInFile);
+			}
+		}
+	}
+	else
+	{
+		if (animSpeed<0.0)
+		{
+			currentFrame = bone.endFrame+1;
+		}
+		else
+		{
+			currentFrame = bone.endFrame-1;
+		}
+		if (currentFrame<0)
+		{
+			currentFrame=0;
+		}
+		assert(currentFrame>=0&&currentFrame<numFramesInFile);
+		newFrame = currentFrame;
+		assert(newFrame>=0&&newFrame<numFramesInFile);
+		lerp = 0;
+
+	}
+	assert(currentFrame>=0&&currentFrame<numFramesInFile);
+	assert(newFrame>=0&&newFrame<numFramesInFile);
+	assert(lerp>=0.0f&&lerp<=1.0f);
+}
+
+#ifdef _RAG_PRINT_TEST
+void G2_RagPrintMatrix(mdxaBone_t *mat);
+#endif
+//basically construct a seperate skeleton with full hierarchy to store a matrix
+//off which will give us the desired settling position given the frame in the skeleton
+//that should be used -rww
+int G2_Add_Bone (const model_t *mod, boneInfo_v &blist, const char *boneName);
+int G2_Find_Bone(const model_t *mod, boneInfo_v &blist, const char *boneName);
+void G2_RagGetAnimMatrix(CGhoul2Info &ghoul2, const int boneNum, mdxaBone_t &matrix, const int frame)
+{
+	mdxaBone_t animMatrix;
+	mdxaSkel_t *skel;
+	mdxaSkel_t *pskel;
+	mdxaSkelOffsets_t *offsets;
+	int parent;
+	int bListIndex;
+	int parentBlistIndex;
+#ifdef _RAG_PRINT_TEST
+	bool actuallySet = false;
+#endif
+
+	assert(ghoul2.mBoneCache);
+	assert(ghoul2.animModel);
+
+	offsets = (mdxaSkelOffsets_t *)((byte *)ghoul2.mBoneCache->header + sizeof(mdxaHeader_t));
+	skel = (mdxaSkel_t *)((byte *)ghoul2.mBoneCache->header + sizeof(mdxaHeader_t) + offsets->offsets[boneNum]);
+
+	//find/add the bone in the list
+	if (!skel->name || !skel->name[0])
+	{
+		bListIndex = -1;
+	}
+	else
+	{
+		bListIndex = G2_Find_Bone(ghoul2.animModel, ghoul2.mBlist, skel->name);
+		if (bListIndex == -1)
+		{
+#ifdef _RAG_PRINT_TEST
+			Com_Printf("Attempting to add %s\n", skel->name);
+#endif
+			bListIndex = G2_Add_Bone(ghoul2.animModel, ghoul2.mBlist, skel->name);
+		}
+	}
+
+	assert(bListIndex != -1);
+
+	boneInfo_t &bone = ghoul2.mBlist[bListIndex];
+
+	if (bone.hasAnimFrameMatrix == frame)
+	{ //already calculated so just grab it
+		matrix = bone.animFrameMatrix;
+		return;
+	}
+
+	//get the base matrix for the specified frame
+	UnCompressBone(animMatrix.matrix, boneNum, ghoul2.mBoneCache->header, frame);
+
+	parent = skel->parent;
+	if (boneNum > 0 && parent > -1)
+	{
+		//recursively call to assure all parent matrices are set up
+		G2_RagGetAnimMatrix(ghoul2, parent, matrix, frame);
+
+		//assign the new skel ptr for our parent
+		pskel = (mdxaSkel_t *)((byte *)ghoul2.mBoneCache->header + sizeof(mdxaHeader_t) + offsets->offsets[parent]);
+
+		//taking bone matrix for the skeleton frame and parent's animFrameMatrix into account, determine our final animFrameMatrix
+		if (!pskel->name || !pskel->name[0])
+		{
+			parentBlistIndex = -1;
+		}
+		else
+		{
+			parentBlistIndex = G2_Find_Bone(ghoul2.animModel, ghoul2.mBlist, pskel->name);
+			if (parentBlistIndex == -1)
+			{
+				parentBlistIndex = G2_Add_Bone(ghoul2.animModel, ghoul2.mBlist, pskel->name);
+			}
+		}
+
+		assert(parentBlistIndex != -1);
+
+		boneInfo_t &pbone = ghoul2.mBlist[parentBlistIndex];
+
+		assert(pbone.hasAnimFrameMatrix == frame); //this should have been calc'd in the recursive call
+
+		Multiply_3x4Matrix(&bone.animFrameMatrix, &pbone.animFrameMatrix, &animMatrix);
+
+#ifdef _RAG_PRINT_TEST
+		if (parentBlistIndex != -1 && bListIndex != -1)
+		{
+			actuallySet = true;
+		}
+		else
+		{
+			Com_Printf("BAD LIST INDEX: %s, %s [%i]\n", skel->name, pskel->name, parent);
+		}
+#endif
+	}
+	else
+	{ //root
+		Multiply_3x4Matrix(&bone.animFrameMatrix, &ghoul2.mBoneCache->rootMatrix, &animMatrix);
+#ifdef _RAG_PRINT_TEST
+		if (bListIndex != -1)
+		{
+			actuallySet = true;
+		}
+		else
+		{
+			Com_Printf("BAD LIST INDEX: %s\n", skel->name);
+		}
+#endif
+		//bone.animFrameMatrix = ghoul2.mBoneCache->mFinalBones[boneNum].boneMatrix;
+		//Maybe use this for the root, so that the orientation is in sync with the current
+		//root matrix? However this would require constant recalculation of this base
+		//skeleton which I currently do not want.
+	}
+
+	//never need to figure it out again
+	bone.hasAnimFrameMatrix = frame;
+
+#ifdef _RAG_PRINT_TEST
+	if (!actuallySet)
+	{
+		Com_Printf("SET FAILURE\n");
+		G2_RagPrintMatrix(&bone.animFrameMatrix);
+	}
+#endif
+
+	matrix = bone.animFrameMatrix;
+}
+
+void G2_TransformBone (int child,CBoneCache &BC)
+{
+	SBoneCalc &TB=BC.mBones[child];
+	static mdxaBone_t		tbone[6];
+// 	mdxaFrame_t		*aFrame=0;
+//	mdxaFrame_t		*bFrame=0;
+//	mdxaFrame_t		*aoldFrame=0;
+//	mdxaFrame_t		*boldFrame=0;
+	static mdxaSkel_t		*skel;
+	static mdxaSkelOffsets_t *offsets;
+	boneInfo_v		&boneList = *BC.rootBoneList;
+	static int				j, boneListIndex;
+	int				angleOverride = 0;
+
+#if DEBUG_G2_TIMING
+	bool printTiming=false;
+#endif
+	// should this bone be overridden by a bone in the bone list?
+	boneListIndex = G2_Find_Bone_In_List(boneList, child);
+	if (boneListIndex != -1)
+	{
+		// we found a bone in the list - we need to override something here.
+		
+		// do we override the rotational angles?
+		if ((boneList[boneListIndex].flags) & (BONE_ANGLES_TOTAL))
+		{
+			angleOverride = (boneList[boneListIndex].flags) & (BONE_ANGLES_TOTAL);
+		}
+
+		// set blending stuff if we need to
+		if (boneList[boneListIndex].flags & BONE_ANIM_BLEND)
+		{
+			float blendTime = BC.incomingTime - boneList[boneListIndex].blendStart;
+			// only set up the blend anim if we actually have some blend time left on this bone anim - otherwise we might corrupt some blend higher up the hiearchy
+			if (blendTime>=0.0f&&blendTime < boneList[boneListIndex].blendTime)
+			{
+				TB.blendFrame	 = boneList[boneListIndex].blendFrame;
+				TB.blendOldFrame = boneList[boneListIndex].blendLerpFrame;
+				TB.blendLerp = (blendTime / boneList[boneListIndex].blendTime);
+				TB.blendMode = true;
+			}
+			else
+			{
+				TB.blendMode = false;
+			}
+		}
+		else if (/*r_Ghoul2NoBlend->integer||*/((boneList[boneListIndex].flags) & (BONE_ANIM_OVERRIDE_LOOP | BONE_ANIM_OVERRIDE)))
+		// turn off blending if we are just doing a straing animation override
+		{
+			TB.blendMode = false;
+		}
+
+		// should this animation be overridden by an animation in the bone list?
+		if ((boneList[boneListIndex].flags) & (BONE_ANIM_OVERRIDE_LOOP | BONE_ANIM_OVERRIDE))
+		{
+			G2_TimingModel(boneList[boneListIndex],BC.incomingTime,BC.header->numFrames,TB.currentFrame,TB.newFrame,TB.backlerp);
+		}
+#if DEBUG_G2_TIMING
+		printTiming=true;
+#endif
+		/*
+		if ((r_Ghoul2NoLerp->integer)||((boneList[boneListIndex].flags) & (BONE_ANIM_NO_LERP)))
+		{
+			TB.backlerp = 0.0f;
+		}
+		*/
+		//rwwFIXMEFIXME: Use?
+	}
+	// figure out where the location of the bone animation data is
+	assert(TB.newFrame>=0&&TB.newFrame<BC.header->numFrames);
+	if (!(TB.newFrame>=0&&TB.newFrame<BC.header->numFrames))
+	{
+		TB.newFrame=0;
+	}
+//	aFrame = (mdxaFrame_t *)((byte *)BC.header + BC.header->ofsFrames + TB.newFrame * BC.frameSize );
+	assert(TB.currentFrame>=0&&TB.currentFrame<BC.header->numFrames);
+	if (!(TB.currentFrame>=0&&TB.currentFrame<BC.header->numFrames))
+	{
+		TB.currentFrame=0;
+	}
+//	aoldFrame = (mdxaFrame_t *)((byte *)BC.header + BC.header->ofsFrames + TB.currentFrame * BC.frameSize );
+
+	// figure out where the location of the blended animation data is
+	assert(!(TB.blendFrame < 0.0 || TB.blendFrame >= (BC.header->numFrames+1)));
+	if (TB.blendFrame < 0.0 || TB.blendFrame >= (BC.header->numFrames+1) )
+	{
+		TB.blendFrame=0.0;
+	}
+//	bFrame = (mdxaFrame_t *)((byte *)BC.header + BC.header->ofsFrames + (int)TB.blendFrame * BC.frameSize );
+	assert(TB.blendOldFrame>=0&&TB.blendOldFrame<BC.header->numFrames);
+	if (!(TB.blendOldFrame>=0&&TB.blendOldFrame<BC.header->numFrames))
+	{
+		TB.blendOldFrame=0;
+	}
+#if DEBUG_G2_TIMING
+
+#if DEBUG_G2_TIMING_RENDER_ONLY
+	if (!HackadelicOnClient)
+	{
+		printTiming=false;
+	}
+#endif
+	if (printTiming)
+	{
+		char mess[1000];
+		if (TB.blendMode)
+		{
+			sprintf(mess,"b %2d %5d   %4d %4d %4d %4d  %f %f\n",boneListIndex,BC.incomingTime,(int)TB.newFrame,(int)TB.currentFrame,(int)TB.blendFrame,(int)TB.blendOldFrame,TB.backlerp,TB.blendLerp);
+		}
+		else
+		{
+			sprintf(mess,"a %2d %5d   %4d %4d            %f\n",boneListIndex,BC.incomingTime,TB.newFrame,TB.currentFrame,TB.backlerp);
+		}
+		OutputDebugString(mess);
+		const boneInfo_t &bone=boneList[boneListIndex];
+		if (bone.flags&BONE_ANIM_BLEND)
+		{
+			sprintf(mess,"                                                                    bfb[%2d] %5d  %5d  (%5d-%5d) %4.2f %4x   bt(%5d-%5d) %7.2f %5d\n",
+				boneListIndex,
+				BC.incomingTime,
+				bone.startTime,
+				bone.startFrame,
+				bone.endFrame,
+				bone.animSpeed,
+				bone.flags,
+				bone.blendStart,
+				bone.blendStart+bone.blendTime,
+				bone.blendFrame,
+				bone.blendLerpFrame
+				);
+		}
+		else
+		{
+			sprintf(mess,"                                                                    bfa[%2d] %5d  %5d  (%5d-%5d) %4.2f %4x\n",
+				boneListIndex,
+				BC.incomingTime,
+				bone.startTime,
+				bone.startFrame,
+				bone.endFrame,
+				bone.animSpeed,
+				bone.flags
+				);
+		}
+//		OutputDebugString(mess);
+	}
+#endif
+//	boldFrame = (mdxaFrame_t *)((byte *)BC.header + BC.header->ofsFrames + TB.blendOldFrame * BC.frameSize );
+
+//	mdxaCompBone_t	*compBonePointer = (mdxaCompBone_t *)((byte *)BC.header + BC.header->ofsCompBonePool);
+
+	assert(child>=0&&child<BC.header->numBones);
+//	assert(bFrame->boneIndexes[child]>=0);
+//	assert(boldFrame->boneIndexes[child]>=0);
+//	assert(aFrame->boneIndexes[child]>=0);
+//	assert(aoldFrame->boneIndexes[child]>=0);
+
+	// decide where the transformed bone is going
+
+	// are we blending with another frame of anim?
+	if (TB.blendMode)
+	{
+		float backlerp = TB.blendFrame - (int)TB.blendFrame;
+		float frontlerp = 1.0 - backlerp;
+		
+// 		MC_UnCompress(tbone[3].matrix,compBonePointer[bFrame->boneIndexes[child]].Comp);
+// 		MC_UnCompress(tbone[4].matrix,compBonePointer[boldFrame->boneIndexes[child]].Comp);
+		UnCompressBone(tbone[3].matrix, child, BC.header, TB.blendFrame);
+		UnCompressBone(tbone[4].matrix, child, BC.header, TB.blendOldFrame);
+
+		for ( j = 0 ; j < 12 ; j++ ) 
+		{
+  			((float *)&tbone[5])[j] = (backlerp * ((float *)&tbone[3])[j])
+				+ (frontlerp * ((float *)&tbone[4])[j]);
+		}
+	}
+	
+  	//
+  	// lerp this bone - use the temp space on the ref entity to put the bone transforms into
+  	//
+  	if (!TB.backlerp)
+  	{
+// 		MC_UnCompress(tbone[2].matrix,compBonePointer[aoldFrame->boneIndexes[child]].Comp);
+		UnCompressBone(tbone[2].matrix, child, BC.header, TB.currentFrame);
+
+		// blend in the other frame if we need to
+		if (TB.blendMode)
+		{
+			float blendFrontlerp = 1.0 - TB.blendLerp;
+	  		for ( j = 0 ; j < 12 ; j++ ) 
+			{
+  				((float *)&tbone[2])[j] = (TB.blendLerp * ((float *)&tbone[2])[j])
+					+ (blendFrontlerp * ((float *)&tbone[5])[j]);
+			}
+		}
+
+  		if (!child)
+		{
+			// now multiply by the root matrix, so we can offset this model should we need to
+			Multiply_3x4Matrix(&BC.mFinalBones[child].boneMatrix, &BC.rootMatrix, &tbone[2]);
+ 		}
+  	}
+	else
+  	{
+		float frontlerp = 1.0 - TB.backlerp;
+// 		MC_UnCompress(tbone[0].matrix,compBonePointer[aFrame->boneIndexes[child]].Comp);
+//		MC_UnCompress(tbone[1].matrix,compBonePointer[aoldFrame->boneIndexes[child]].Comp);
+		UnCompressBone(tbone[0].matrix, child, BC.header, TB.newFrame);
+		UnCompressBone(tbone[1].matrix, child, BC.header, TB.currentFrame);		
+
+		for ( j = 0 ; j < 12 ; j++ ) 
+		{
+  			((float *)&tbone[2])[j] = (TB.backlerp * ((float *)&tbone[0])[j])
+				+ (frontlerp * ((float *)&tbone[1])[j]);
+		}
+
+		// blend in the other frame if we need to
+		if (TB.blendMode)
+		{
+			float blendFrontlerp = 1.0 - TB.blendLerp;
+	  		for ( j = 0 ; j < 12 ; j++ ) 
+			{
+  				((float *)&tbone[2])[j] = (TB.blendLerp * ((float *)&tbone[2])[j])
+					+ (blendFrontlerp * ((float *)&tbone[5])[j]);
+			}
+		}
+
+  		if (!child)
+  		{
+			// now multiply by the root matrix, so we can offset this model should we need to
+			Multiply_3x4Matrix(&BC.mFinalBones[child].boneMatrix, &BC.rootMatrix, &tbone[2]);
+  		}
+	}
+	// figure out where the bone hirearchy info is
+	offsets = (mdxaSkelOffsets_t *)((byte *)BC.header + sizeof(mdxaHeader_t));
+	skel = (mdxaSkel_t *)((byte *)BC.header + sizeof(mdxaHeader_t) + offsets->offsets[child]);
+//	skel = BC.mSkels[child];
+	//rww - removed mSkels
+
+	int parent=BC.mFinalBones[child].parent;
+	assert((parent==-1&&child==0)||(parent>=0&&parent<BC.mBones.size()));
+	if (angleOverride & BONE_ANGLES_REPLACE)
+	{
+		bool isRag=!!(angleOverride & BONE_ANGLES_RAGDOLL);
+		if (!isRag)
+		{ //do the same for ik.. I suppose.
+			isRag = !!(angleOverride & BONE_ANGLES_IK);
+		}
+
+		mdxaBone_t &bone = BC.mFinalBones[child].boneMatrix;
+		boneInfo_t &boneOverride = boneList[boneListIndex];
+
+		if (isRag)
+		{
+			mdxaBone_t temp, firstPass;
+			// give us the matrix the animation thinks we should have, so we can get the correct X&Y coors
+			Multiply_3x4Matrix(&firstPass, &BC.mFinalBones[parent].boneMatrix, &tbone[2]);
+			// this is crazy, we are gonna drive the animation to ID while we are doing post mults to compensate.
+			Multiply_3x4Matrix(&temp,&firstPass, &skel->BasePoseMat);
+			float	matrixScale = VectorLength((float*)&temp);
+			static mdxaBone_t		toMatrix = 
+			{ 
+				1.0f, 0.0f, 0.0f, 0.0f,
+				0.0f, 1.0f, 0.0f, 0.0f,
+				0.0f, 0.0f, 1.0f, 0.0f
+			};
+			toMatrix.matrix[0][0]=matrixScale;
+			toMatrix.matrix[1][1]=matrixScale;
+			toMatrix.matrix[2][2]=matrixScale;
+			toMatrix.matrix[0][3]=temp.matrix[0][3];
+			toMatrix.matrix[1][3]=temp.matrix[1][3];
+			toMatrix.matrix[2][3]=temp.matrix[2][3];
+
+ 			Multiply_3x4Matrix(&temp, &toMatrix,&skel->BasePoseMatInv); //dest first arg
+
+			float blendTime = BC.incomingTime - boneList[boneListIndex].boneBlendStart;
+			float blendLerp = (blendTime / boneList[boneListIndex].boneBlendTime);
+			if (blendLerp>0.0f)
+			{
+				// has started
+				if (blendLerp>1.0f)
+				{
+					// done
+//					Multiply_3x4Matrix(&bone, &BC.mFinalBones[parent].boneMatrix,&temp);
+					memcpy (&bone,&temp, sizeof(mdxaBone_t));
+				}
+				else
+				{
+//					mdxaBone_t lerp;
+					// now do the blend into the destination
+					float blendFrontlerp = 1.0 - blendLerp;
+	  				for ( j = 0 ; j < 12 ; j++ ) 
+					{
+  						((float *)&bone)[j] = (blendLerp * ((float *)&temp)[j])
+							+ (blendFrontlerp * ((float *)&tbone[2])[j]);
+					}
+//					Multiply_3x4Matrix(&bone, &BC.mFinalBones[parent].boneMatrix,&lerp);
+				}
+			}
+		}
+		else
+		{
+			mdxaBone_t temp, firstPass;
+
+			// give us the matrix the animation thinks we should have, so we can get the correct X&Y coors
+			Multiply_3x4Matrix(&firstPass, &BC.mFinalBones[parent].boneMatrix, &tbone[2]);
+
+			// are we attempting to blend with the base animation? and still within blend time?
+			if (boneOverride.boneBlendTime && (((boneOverride.boneBlendTime + boneOverride.boneBlendStart) < BC.incomingTime)))
+			{
+				// ok, we are supposed to be blending. Work out lerp
+				float blendTime = BC.incomingTime - boneList[boneListIndex].boneBlendStart;
+				float blendLerp = (blendTime / boneList[boneListIndex].boneBlendTime);
+
+				if (blendLerp <= 1)
+				{
+					if (blendLerp < 0)
+					{
+						assert(0);
+					}
+
+					// now work out the matrix we want to get *to* - firstPass is where we are coming *from*
+					Multiply_3x4Matrix(&temp, &firstPass, &skel->BasePoseMat);
+
+					float	matrixScale = VectorLength((float*)&temp);
+
+					mdxaBone_t	newMatrixTemp;
+					
+					if (HackadelicOnClient)
+					{
+						for (int i=0; i<3;i++)
+						{
+							for(int x=0;x<3; x++)
+							{
+								newMatrixTemp.matrix[i][x] = boneOverride.newMatrix.matrix[i][x]*matrixScale;
+							}
+						}
+
+						newMatrixTemp.matrix[0][3] = temp.matrix[0][3];
+						newMatrixTemp.matrix[1][3] = temp.matrix[1][3]; 
+						newMatrixTemp.matrix[2][3] = temp.matrix[2][3];
+					}
+					else
+					{
+						for (int i=0; i<3;i++)
+						{
+							for(int x=0;x<3; x++)
+							{
+								newMatrixTemp.matrix[i][x] = boneOverride.matrix.matrix[i][x]*matrixScale;
+							}
+						}
+
+						newMatrixTemp.matrix[0][3] = temp.matrix[0][3];
+						newMatrixTemp.matrix[1][3] = temp.matrix[1][3]; 
+						newMatrixTemp.matrix[2][3] = temp.matrix[2][3];
+					}
+				
+ 					Multiply_3x4Matrix(&temp, &newMatrixTemp,&skel->BasePoseMatInv);
+
+					// now do the blend into the destination
+					float blendFrontlerp = 1.0 - blendLerp;
+	  				for ( j = 0 ; j < 12 ; j++ ) 
+					{
+  						((float *)&bone)[j] = (blendLerp * ((float *)&temp)[j])
+							+ (blendFrontlerp * ((float *)&firstPass)[j]);
+					}
+				}
+				else
+				{
+					bone = firstPass;
+				}
+			}
+			// no, so just override it directly
+			else
+			{
+
+				Multiply_3x4Matrix(&temp,&firstPass, &skel->BasePoseMat);
+				float	matrixScale = VectorLength((float*)&temp);
+
+				mdxaBone_t	newMatrixTemp;
+				
+				if (HackadelicOnClient)
+				{
+					for (int i=0; i<3;i++)
+					{
+						for(int x=0;x<3; x++)
+						{
+							newMatrixTemp.matrix[i][x] = boneOverride.newMatrix.matrix[i][x]*matrixScale;
+						}
+					}
+					
+					newMatrixTemp.matrix[0][3] = temp.matrix[0][3];
+					newMatrixTemp.matrix[1][3] = temp.matrix[1][3]; 
+					newMatrixTemp.matrix[2][3] = temp.matrix[2][3];
+				}
+				else
+				{
+					for (int i=0; i<3;i++)
+					{
+						for(int x=0;x<3; x++)
+						{
+							newMatrixTemp.matrix[i][x] = boneOverride.matrix.matrix[i][x]*matrixScale;
+						}
+					}
+					
+					newMatrixTemp.matrix[0][3] = temp.matrix[0][3];
+					newMatrixTemp.matrix[1][3] = temp.matrix[1][3]; 
+					newMatrixTemp.matrix[2][3] = temp.matrix[2][3];
+				}
+			
+ 				Multiply_3x4Matrix(&bone, &newMatrixTemp,&skel->BasePoseMatInv);
+			}
+		}
+	}
+	else if (angleOverride & BONE_ANGLES_PREMULT)
+	{
+		if ((angleOverride&BONE_ANGLES_RAGDOLL) || (angleOverride&BONE_ANGLES_IK))
+		{
+			mdxaBone_t	tmp;
+			if (!child)
+			{
+				if (HackadelicOnClient)
+				{
+					Multiply_3x4Matrix(&tmp, &BC.rootMatrix, &boneList[boneListIndex].newMatrix);
+				}
+				else
+				{
+					Multiply_3x4Matrix(&tmp, &BC.rootMatrix, &boneList[boneListIndex].matrix);
+				}
+			}
+			else
+			{
+				if (HackadelicOnClient)
+				{
+					Multiply_3x4Matrix(&tmp, &BC.mFinalBones[parent].boneMatrix, &boneList[boneListIndex].newMatrix);
+				}
+				else
+				{
+					Multiply_3x4Matrix(&tmp, &BC.mFinalBones[parent].boneMatrix, &boneList[boneListIndex].matrix);
+				}
+			}
+			Multiply_3x4Matrix(&BC.mFinalBones[child].boneMatrix,&tmp, &tbone[2]);
+		}
+		else
+		{
+			if (!child)
+			{
+				// use the in coming root matrix as our basis
+				if (HackadelicOnClient)
+				{
+					Multiply_3x4Matrix(&BC.mFinalBones[child].boneMatrix, &BC.rootMatrix, &boneList[boneListIndex].newMatrix);
+				}
+				else
+				{
+					Multiply_3x4Matrix(&BC.mFinalBones[child].boneMatrix, &BC.rootMatrix, &boneList[boneListIndex].matrix);
+				}
+ 			}
+			else
+			{
+				// convert from 3x4 matrix to a 4x4 matrix
+				if (HackadelicOnClient)
+				{
+					Multiply_3x4Matrix(&BC.mFinalBones[child].boneMatrix, &BC.mFinalBones[parent].boneMatrix, &boneList[boneListIndex].newMatrix);
+				}
+				else
+				{
+					Multiply_3x4Matrix(&BC.mFinalBones[child].boneMatrix, &BC.mFinalBones[parent].boneMatrix, &boneList[boneListIndex].matrix);
+				}
+			}
+		}
+	}
+	else
+	// now transform the matrix by it's parent, asumming we have a parent, and we aren't overriding the angles absolutely
+	if (child)
+	{
+		Multiply_3x4Matrix(&BC.mFinalBones[child].boneMatrix, &BC.mFinalBones[parent].boneMatrix, &tbone[2]);
+	}
+
+	// now multiply our resulting bone by an override matrix should we need to
+	if (angleOverride & BONE_ANGLES_POSTMULT)
+	{
+		mdxaBone_t	tempMatrix;
+		memcpy (&tempMatrix,&BC.mFinalBones[child].boneMatrix, sizeof(mdxaBone_t));
+		if (HackadelicOnClient)
+		{
+		  	Multiply_3x4Matrix(&BC.mFinalBones[child].boneMatrix, &tempMatrix, &boneList[boneListIndex].newMatrix);
+		}
+		else
+		{
+		  	Multiply_3x4Matrix(&BC.mFinalBones[child].boneMatrix, &tempMatrix, &boneList[boneListIndex].matrix);
+		}
+	}
+	/*
+	if (r_Ghoul2UnSqash->integer)
+	{
+		mdxaBone_t tempMatrix;
+		Multiply_3x4Matrix(&tempMatrix,&BC.mFinalBones[child].boneMatrix, &skel->BasePoseMat);
+		float maxl;
+		maxl=VectorLength(&skel->BasePoseMat.matrix[0][0]);
+		VectorNormalize(&tempMatrix.matrix[0][0]);
+		VectorNormalize(&tempMatrix.matrix[1][0]);
+		VectorNormalize(&tempMatrix.matrix[2][0]);
+
+		VectorScale(&tempMatrix.matrix[0][0],maxl,&tempMatrix.matrix[0][0]);
+		VectorScale(&tempMatrix.matrix[1][0],maxl,&tempMatrix.matrix[1][0]);
+		VectorScale(&tempMatrix.matrix[2][0],maxl,&tempMatrix.matrix[2][0]);
+		Multiply_3x4Matrix(&BC.mFinalBones[child].boneMatrix,&tempMatrix,&skel->BasePoseMatInv);
+	}
+	*/
+	//rwwFIXMEFIXME: Care?
+
+}
+
+void G2_SetUpBolts( mdxaHeader_t *header, CGhoul2Info &ghoul2, mdxaBone_v &bonePtr, boltInfo_v &boltList)
+{
+	mdxaSkel_t		*skel;
+	mdxaSkelOffsets_t *offsets;
+	offsets = (mdxaSkelOffsets_t *)((byte *)header + sizeof(mdxaHeader_t));
+
+	for (int i=0; i<boltList.size(); i++)
+	{
+		if (boltList[i].boneNumber != -1)
+		{
+			// figure out where the bone hirearchy info is
+			skel = (mdxaSkel_t *)((byte *)header + sizeof(mdxaHeader_t) + offsets->offsets[boltList[i].boneNumber]);
+			Multiply_3x4Matrix(&boltList[i].position, &bonePtr[boltList[i].boneNumber].second, &skel->BasePoseMat);
+		}
+	}
+}
+
+//rww - RAGDOLL_BEGIN
+#define		GHOUL2_RAG_STARTED						0x0010
+//rww - RAGDOLL_END
+//rwwFIXMEFIXME: Move this into the stupid header or something.
+
+void G2_TransformGhoulBones(boneInfo_v &rootBoneList,mdxaBone_t &rootMatrix, CGhoul2Info &ghoul2, int time,bool smooth=true)
+{
+#ifdef G2_PERFORMANCE_ANALYSIS
+	G2PerformanceTimer_G2_TransformGhoulBones.Start();
+	G2PerformanceCounter_G2_TransformGhoulBones++;
+#endif
+
+	/*
+	model_t			*currentModel;
+	model_t			*animModel;
+	mdxaHeader_t	*aHeader;
+
+	//currentModel = R_GetModelByHandle(RE_RegisterModel(ghoul2.mFileName));
+	currentModel = R_GetModelByHandle(ghoul2.mModel);
+	assert(currentModel);
+	assert(currentModel->mdxm);
+
+	animModel =  R_GetModelByHandle(currentModel->mdxm->animIndex);
+	assert(animModel);
+	aHeader = animModel->mdxa;
+	assert(aHeader);
+	*/
+	model_t			*currentModel = (model_t *)ghoul2.currentModel;
+	mdxaHeader_t	*aHeader = (mdxaHeader_t *)ghoul2.aHeader;
+
+
+	assert(ghoul2.aHeader);
+	assert(ghoul2.currentModel);
+	assert(ghoul2.currentModel->mdxm);
+	if (!aHeader->numBones)
+	{
+		assert(0); // this would be strange
+		return;
+	}
+	if (!ghoul2.mBoneCache)
+	{
+		ghoul2.mBoneCache=new CBoneCache(currentModel,aHeader);
+
+#ifdef _FULL_G2_LEAK_CHECKING
+		g_Ghoul2Allocations += sizeof(*ghoul2.mBoneCache);
+#endif
+	}
+	ghoul2.mBoneCache->mod=currentModel;
+	ghoul2.mBoneCache->header=aHeader; 
+	assert(ghoul2.mBoneCache->mBones.size()==aHeader->numBones);
+
+	ghoul2.mBoneCache->mSmoothingActive=false;
+	ghoul2.mBoneCache->mUnsquash=false;
+
+	// master smoothing control
+	if (HackadelicOnClient && smooth && !com_dedicated->integer)
+	{
+		ghoul2.mBoneCache->mLastTouch=ghoul2.mBoneCache->mLastLastTouch;
+		/*
+		float val=r_Ghoul2AnimSmooth->value;
+		if (smooth&&val>0.0f&&val<1.0f)
+		{
+		//	if (HackadelicOnClient)
+		//	{
+				ghoul2.mBoneCache->mLastTouch=ghoul2.mBoneCache->mLastLastTouch;
+		//	}
+
+			ghoul2.mBoneCache->mSmoothFactor=val;
+			ghoul2.mBoneCache->mSmoothingActive=true;
+			if (r_Ghoul2UnSqashAfterSmooth->integer)
+			{
+				ghoul2.mBoneCache->mUnsquash=true;
+			}
+		}
+		else
+		{
+			ghoul2.mBoneCache->mSmoothFactor=1.0f;
+		}
+		*/
+
+		// master smoothing control
+		float val=r_Ghoul2AnimSmooth->value;
+		if (val>0.0f&&val<1.0f)
+		{
+			//if (ghoul2.mFlags&GHOUL2_RESERVED_FOR_RAGDOLL)
+#if 1
+			if(ghoul2.mFlags & GHOUL2_CRAZY_SMOOTH)
+			{
+				val = 0.9f;
+			}
+			else if(ghoul2.mFlags & GHOUL2_RAG_STARTED)
+			{
+				int k;
+				for (k=0;k<rootBoneList.size();k++)
+				{
+					boneInfo_t &bone=rootBoneList[k];
+					if (bone.flags&BONE_ANGLES_RAGDOLL)
+					{
+						if (bone.firstCollisionTime &&
+							bone.firstCollisionTime>time-250 &&
+							bone.firstCollisionTime<time)
+						{
+							val=0.9f;//(val+0.8f)/2.0f;
+						}
+						else if (bone.airTime > time)
+						{
+							val = 0.2f;
+						}
+						else
+						{
+							val = 0.8f;
+						}
+						break;
+					}
+				}
+			}
+#endif
+
+//			ghoul2.mBoneCache->mSmoothFactor=(val + 1.0f-pow(1.0f-val,50.0f/dif))/2.0f;  // meaningless formula
+			ghoul2.mBoneCache->mSmoothFactor=val;  // meaningless formula
+			ghoul2.mBoneCache->mSmoothingActive=true;
+
+			if (r_Ghoul2UnSqashAfterSmooth->integer)
+			{
+				ghoul2.mBoneCache->mUnsquash=true;
+			}
+		}
+	}
+	else
+	{
+		ghoul2.mBoneCache->mSmoothFactor=1.0f;
+	}
+
+	ghoul2.mBoneCache->mCurrentTouch++;
+
+//rww - RAGDOLL_BEGIN
+	if (HackadelicOnClient)
+	{
+		ghoul2.mBoneCache->mLastLastTouch=ghoul2.mBoneCache->mCurrentTouch;
+		ghoul2.mBoneCache->mCurrentTouchRender=ghoul2.mBoneCache->mCurrentTouch;
+	}
+	else
+	{
+		ghoul2.mBoneCache->mCurrentTouchRender=0;
+	}
+//rww - RAGDOLL_END
+
+	ghoul2.mBoneCache->frameSize = 0;// can be deleted in new G2 format	//(int)( &((mdxaFrame_t *)0)->boneIndexes[ ghoul2.aHeader->numBones ] );   
+
+	ghoul2.mBoneCache->rootBoneList=&rootBoneList;
+	ghoul2.mBoneCache->rootMatrix=rootMatrix;
+	ghoul2.mBoneCache->incomingTime=time;
+
+	SBoneCalc &TB=ghoul2.mBoneCache->Root();
+	TB.newFrame=0;
+	TB.currentFrame=0;
+	TB.backlerp=0.0f;
+	TB.blendFrame=0;
+	TB.blendOldFrame=0;
+	TB.blendMode=false;
+	TB.blendLerp=0;
+
+#ifdef G2_PERFORMANCE_ANALYSIS
+	G2Time_G2_TransformGhoulBones += G2PerformanceTimer_G2_TransformGhoulBones.End();
+#endif
+}
+
+
+#define MDX_TAG_ORIGIN 2
+
+//======================================================================
+//
+// Surface Manipulation code 
+
+
+// We've come across a surface that's designated as a bolt surface, process it and put it in the appropriate bolt place
+void G2_ProcessSurfaceBolt(mdxaBone_v &bonePtr, mdxmSurface_t *surface, int boltNum, boltInfo_v &boltList, surfaceInfo_t *surfInfo, model_t *mod)
+{
+ 	mdxmVertex_t 	*v, *vert0, *vert1, *vert2;
+ 	vec3_t			axes[3], sides[3];
+ 	float			pTri[3][3], d;
+ 	int				j, k;
+
+	// now there are two types of tag surface - model ones and procedural generated types - lets decide which one we have here.
+	if (surfInfo && surfInfo->offFlags == G2SURFACEFLAG_GENERATED)
+	{
+		int surfNumber = surfInfo->genPolySurfaceIndex & 0x0ffff;
+		int	polyNumber = (surfInfo->genPolySurfaceIndex >> 16) & 0x0ffff;
+
+		// find original surface our original poly was in.
+		mdxmSurface_t	*originalSurf = (mdxmSurface_t *)G2_FindSurface((void*)mod, surfNumber, surfInfo->genLod);
+		mdxmTriangle_t	*originalTriangleIndexes = (mdxmTriangle_t *)((byte*)originalSurf + originalSurf->ofsTriangles);
+
+		// get the original polys indexes 
+		int index0 = originalTriangleIndexes[polyNumber].indexes[0];
+		int index1 = originalTriangleIndexes[polyNumber].indexes[1];
+		int index2 = originalTriangleIndexes[polyNumber].indexes[2];
+
+		// decide where the original verts are
+
+ 		vert0 = (mdxmVertex_t *) ((byte *)originalSurf + originalSurf->ofsVerts);
+		vert0+= index0;
+
+ 		vert1 = (mdxmVertex_t *) ((byte *)originalSurf + originalSurf->ofsVerts);
+		vert1+= index1;
+		
+ 		vert2 = (mdxmVertex_t *) ((byte *)originalSurf + originalSurf->ofsVerts);
+		vert2+= index2;
+
+		// clear out the triangle verts to be
+ 	   	VectorClear( pTri[0] );
+ 	   	VectorClear( pTri[1] );
+ 	   	VectorClear( pTri[2] );
+
+//		mdxmWeight_t	*w;
+
+		int *piBoneRefs = (int*) ((byte*)originalSurf + originalSurf->ofsBoneReferences);		
+
+		// now go and transform just the points we need from the surface that was hit originally
+//		w = vert0->weights;
+		float fTotalWeight = 0.0f;
+		int iNumWeights = G2_GetVertWeights( vert0 );
+ 		for ( k = 0 ; k < iNumWeights ; k++ ) 
+ 		{
+			int		iBoneIndex	= G2_GetVertBoneIndex( vert0, k );
+			float	fBoneWeight	= G2_GetVertBoneWeight( vert0, k, fTotalWeight, iNumWeights );
+
+#ifdef _XBOX
+			vec3_t vec;
+			Q_CastShort2FloatScale(&vec[0], &vert0->vertCoords[0], 1.f / (float)GLM_COMP_SIZE);
+			Q_CastShort2FloatScale(&vec[1], &vert0->vertCoords[1], 1.f / (float)GLM_COMP_SIZE);
+			Q_CastShort2FloatScale(&vec[2], &vert0->vertCoords[2], 1.f / (float)GLM_COMP_SIZE);
+
+			pTri[0][0] += fBoneWeight * ( DotProduct( bonePtr[piBoneRefs[iBoneIndex]].second.matrix[0], vec ) + bonePtr[piBoneRefs[iBoneIndex]].second.matrix[0][3] );
+			pTri[0][1] += fBoneWeight * ( DotProduct( bonePtr[piBoneRefs[iBoneIndex]].second.matrix[1], vec ) + bonePtr[piBoneRefs[iBoneIndex]].second.matrix[1][3] );
+			pTri[0][2] += fBoneWeight * ( DotProduct( bonePtr[piBoneRefs[iBoneIndex]].second.matrix[2], vec ) + bonePtr[piBoneRefs[iBoneIndex]].second.matrix[2][3] );
+#else
+ 			pTri[0][0] += fBoneWeight * ( DotProduct( bonePtr[piBoneRefs[iBoneIndex]].second.matrix[0], vert0->vertCoords ) + bonePtr[piBoneRefs[iBoneIndex]].second.matrix[0][3] );
+ 			pTri[0][1] += fBoneWeight * ( DotProduct( bonePtr[piBoneRefs[iBoneIndex]].second.matrix[1], vert0->vertCoords ) + bonePtr[piBoneRefs[iBoneIndex]].second.matrix[1][3] );
+ 			pTri[0][2] += fBoneWeight * ( DotProduct( bonePtr[piBoneRefs[iBoneIndex]].second.matrix[2], vert0->vertCoords ) + bonePtr[piBoneRefs[iBoneIndex]].second.matrix[2][3] );
+#endif
+		}
+//		w = vert1->weights;
+		fTotalWeight = 0.0f;
+		iNumWeights = G2_GetVertWeights( vert1 );
+ 		for ( k = 0 ; k < iNumWeights ; k++ ) 
+ 		{
+			int		iBoneIndex	= G2_GetVertBoneIndex( vert1, k );
+			float	fBoneWeight	= G2_GetVertBoneWeight( vert1, k, fTotalWeight, iNumWeights );
+
+#ifdef _XBOX
+			vec3_t vec;
+			Q_CastShort2FloatScale(&vec[0], &vert1->vertCoords[0], 1.f / (float)GLM_COMP_SIZE);
+			Q_CastShort2FloatScale(&vec[1], &vert1->vertCoords[1], 1.f / (float)GLM_COMP_SIZE);
+			Q_CastShort2FloatScale(&vec[2], &vert1->vertCoords[2], 1.f / (float)GLM_COMP_SIZE);
+
+			pTri[0][0] += fBoneWeight * ( DotProduct( bonePtr[piBoneRefs[iBoneIndex]].second.matrix[0], vec ) + bonePtr[piBoneRefs[iBoneIndex]].second.matrix[0][3] );
+			pTri[0][1] += fBoneWeight * ( DotProduct( bonePtr[piBoneRefs[iBoneIndex]].second.matrix[1], vec ) + bonePtr[piBoneRefs[iBoneIndex]].second.matrix[1][3] );
+			pTri[0][2] += fBoneWeight * ( DotProduct( bonePtr[piBoneRefs[iBoneIndex]].second.matrix[2], vec ) + bonePtr[piBoneRefs[iBoneIndex]].second.matrix[2][3] );
+#else
+ 			pTri[1][0] += fBoneWeight * ( DotProduct( bonePtr[piBoneRefs[iBoneIndex]].second.matrix[0], vert1->vertCoords ) + bonePtr[piBoneRefs[iBoneIndex]].second.matrix[0][3] );
+ 			pTri[1][1] += fBoneWeight * ( DotProduct( bonePtr[piBoneRefs[iBoneIndex]].second.matrix[1], vert1->vertCoords ) + bonePtr[piBoneRefs[iBoneIndex]].second.matrix[1][3] );
+ 			pTri[1][2] += fBoneWeight * ( DotProduct( bonePtr[piBoneRefs[iBoneIndex]].second.matrix[2], vert1->vertCoords ) + bonePtr[piBoneRefs[iBoneIndex]].second.matrix[2][3] );
+#endif
+		}
+//		w = vert2->weights;
+		fTotalWeight = 0.0f;
+		iNumWeights = G2_GetVertWeights( vert2 );
+ 		for ( k = 0 ; k < iNumWeights ; k++ ) 
+ 		{
+			int		iBoneIndex	= G2_GetVertBoneIndex( vert2, k );
+			float	fBoneWeight	= G2_GetVertBoneWeight( vert2, k, fTotalWeight, iNumWeights );
+
+#ifdef _XBOX
+			vec3_t vec;
+			Q_CastShort2FloatScale(&vec[0], &vert2->vertCoords[0], 1.f / (float)GLM_COMP_SIZE);
+			Q_CastShort2FloatScale(&vec[1], &vert2->vertCoords[1], 1.f / (float)GLM_COMP_SIZE);
+			Q_CastShort2FloatScale(&vec[2], &vert2->vertCoords[2], 1.f / (float)GLM_COMP_SIZE);
+
+			pTri[0][0] += fBoneWeight * ( DotProduct( bonePtr[piBoneRefs[iBoneIndex]].second.matrix[0], vec ) + bonePtr[piBoneRefs[iBoneIndex]].second.matrix[0][3] );
+			pTri[0][1] += fBoneWeight * ( DotProduct( bonePtr[piBoneRefs[iBoneIndex]].second.matrix[1], vec ) + bonePtr[piBoneRefs[iBoneIndex]].second.matrix[1][3] );
+			pTri[0][2] += fBoneWeight * ( DotProduct( bonePtr[piBoneRefs[iBoneIndex]].second.matrix[2], vec ) + bonePtr[piBoneRefs[iBoneIndex]].second.matrix[2][3] );
+#else
+ 			pTri[2][0] += fBoneWeight * ( DotProduct( bonePtr[piBoneRefs[iBoneIndex]].second.matrix[0], vert2->vertCoords ) + bonePtr[piBoneRefs[iBoneIndex]].second.matrix[0][3] );
+ 			pTri[2][1] += fBoneWeight * ( DotProduct( bonePtr[piBoneRefs[iBoneIndex]].second.matrix[1], vert2->vertCoords ) + bonePtr[piBoneRefs[iBoneIndex]].second.matrix[1][3] );
+ 			pTri[2][2] += fBoneWeight * ( DotProduct( bonePtr[piBoneRefs[iBoneIndex]].second.matrix[2], vert2->vertCoords ) + bonePtr[piBoneRefs[iBoneIndex]].second.matrix[2][3] );
+#endif
+		}
+ 			
+   		vec3_t normal;
+		vec3_t up;
+		vec3_t right;
+		vec3_t vec0, vec1;
+		// work out baryCentricK
+		float baryCentricK = 1.0 - (surfInfo->genBarycentricI + surfInfo->genBarycentricJ);
+
+		// now we have the model transformed into model space, now generate an origin.
+		boltList[boltNum].position.matrix[0][3] = (pTri[0][0] * surfInfo->genBarycentricI) + (pTri[1][0] * surfInfo->genBarycentricJ) + (pTri[2][0] * baryCentricK);
+		boltList[boltNum].position.matrix[1][3] = (pTri[0][1] * surfInfo->genBarycentricI) + (pTri[1][1] * surfInfo->genBarycentricJ) + (pTri[2][1] * baryCentricK);
+		boltList[boltNum].position.matrix[2][3] = (pTri[0][2] * surfInfo->genBarycentricI) + (pTri[1][2] * surfInfo->genBarycentricJ) + (pTri[2][2] * baryCentricK);
+
+		// generate a normal to this new triangle
+		VectorSubtract(pTri[0], pTri[1], vec0);
+		VectorSubtract(pTri[2], pTri[1], vec1);
+
+		CrossProduct(vec0, vec1, normal);
+		VectorNormalize(normal);
+
+		// forward vector
+		boltList[boltNum].position.matrix[0][0] = normal[0];
+		boltList[boltNum].position.matrix[1][0] = normal[1];
+		boltList[boltNum].position.matrix[2][0] = normal[2];
+
+		// up will be towards point 0 of the original triangle.
+		// so lets work it out. Vector is hit point - point 0
+		up[0] = boltList[boltNum].position.matrix[0][3] - pTri[0][0];
+		up[1] = boltList[boltNum].position.matrix[1][3] - pTri[0][1];
+		up[2] = boltList[boltNum].position.matrix[2][3] - pTri[0][2];
+
+		// normalise it
+		VectorNormalize(up);
+
+		// that's the up vector
+		boltList[boltNum].position.matrix[0][1] = up[0];
+		boltList[boltNum].position.matrix[1][1] = up[1];
+		boltList[boltNum].position.matrix[2][1] = up[2];
+
+		// right is always straight
+
+		CrossProduct( normal, up, right );
+		// that's the up vector
+		boltList[boltNum].position.matrix[0][2] = right[0];
+		boltList[boltNum].position.matrix[1][2] = right[1];
+		boltList[boltNum].position.matrix[2][2] = right[2];
+
+
+	}
+	// no, we are looking at a normal model tag
+	else
+	{
+		int *piBoneRefs = (int*) ((byte*)surface + surface->ofsBoneReferences);		
+
+	 	// whip through and actually transform each vertex
+ 		v = (mdxmVertex_t *) ((byte *)surface + surface->ofsVerts);
+ 		for ( j = 0; j < 3; j++ ) 
+ 		{
+// 			mdxmWeight_t	*w;
+
+ 			VectorClear( pTri[j] );
+ //			w = v->weights;
+
+			const int iNumWeights = G2_GetVertWeights( v );
+			float fTotalWeight = 0.0f;
+ 			for ( k = 0 ; k < iNumWeights ; k++ ) 
+ 			{
+				int		iBoneIndex	= G2_GetVertBoneIndex( v, k );
+				float	fBoneWeight	= G2_GetVertBoneWeight( v, k, fTotalWeight, iNumWeights );
+
+ 				//bone = bonePtr + piBoneRefs[w->boneIndex];
+#ifdef _XBOX
+				vec3_t vec;
+				Q_CastShort2FloatScale(&vec[0], &v->vertCoords[0], 1.f / (float)GLM_COMP_SIZE);
+				Q_CastShort2FloatScale(&vec[1], &v->vertCoords[1], 1.f / (float)GLM_COMP_SIZE);
+				Q_CastShort2FloatScale(&vec[2], &v->vertCoords[2], 1.f / (float)GLM_COMP_SIZE);
+
+				pTri[0][0] += fBoneWeight * ( DotProduct( bonePtr[piBoneRefs[iBoneIndex]].second.matrix[0], vec ) + bonePtr[piBoneRefs[iBoneIndex]].second.matrix[0][3] );
+				pTri[0][1] += fBoneWeight * ( DotProduct( bonePtr[piBoneRefs[iBoneIndex]].second.matrix[1], vec ) + bonePtr[piBoneRefs[iBoneIndex]].second.matrix[1][3] );
+				pTri[0][2] += fBoneWeight * ( DotProduct( bonePtr[piBoneRefs[iBoneIndex]].second.matrix[2], vec ) + bonePtr[piBoneRefs[iBoneIndex]].second.matrix[2][3] );
+#else
+ 				pTri[j][0] += fBoneWeight * ( DotProduct( bonePtr[piBoneRefs[iBoneIndex]].second.matrix[0], v->vertCoords ) + bonePtr[piBoneRefs[iBoneIndex]].second.matrix[0][3] );
+ 				pTri[j][1] += fBoneWeight * ( DotProduct( bonePtr[piBoneRefs[iBoneIndex]].second.matrix[1], v->vertCoords ) + bonePtr[piBoneRefs[iBoneIndex]].second.matrix[1][3] );
+ 				pTri[j][2] += fBoneWeight * ( DotProduct( bonePtr[piBoneRefs[iBoneIndex]].second.matrix[2], v->vertCoords ) + bonePtr[piBoneRefs[iBoneIndex]].second.matrix[2][3] );
+#endif
+ 			}
+ 			
+ 			v++;// = (mdxmVertex_t *)&v->weights[/*v->numWeights*/surface->maxVertBoneWeights];
+ 		}
+
+ 		// clear out used arrays
+ 		memset( axes, 0, sizeof( axes ) );
+ 		memset( sides, 0, sizeof( sides ) );
+
+ 		// work out actual sides of the tag triangle
+ 		for ( j = 0; j < 3; j++ )
+ 		{
+ 			sides[j][0] = pTri[(j+1)%3][0] - pTri[j][0];
+ 			sides[j][1] = pTri[(j+1)%3][1] - pTri[j][1];
+ 			sides[j][2] = pTri[(j+1)%3][2] - pTri[j][2];
+ 		}
+
+ 		// do math trig to work out what the matrix will be from this triangle's translated position
+ 		VectorNormalize2( sides[iG2_TRISIDE_LONGEST], axes[0] );
+ 		VectorNormalize2( sides[iG2_TRISIDE_SHORTEST], axes[1] );
+
+ 		// project shortest side so that it is exactly 90 degrees to the longer side
+ 		d = DotProduct( axes[0], axes[1] );
+ 		VectorMA( axes[0], -d, axes[1], axes[0] );
+ 		VectorNormalize2( axes[0], axes[0] );
+
+ 		CrossProduct( sides[iG2_TRISIDE_LONGEST], sides[iG2_TRISIDE_SHORTEST], axes[2] );
+ 		VectorNormalize2( axes[2], axes[2] );
+
+ 		// set up location in world space of the origin point in out going matrix
+ 		boltList[boltNum].position.matrix[0][3] = pTri[MDX_TAG_ORIGIN][0];
+ 		boltList[boltNum].position.matrix[1][3] = pTri[MDX_TAG_ORIGIN][1];
+ 		boltList[boltNum].position.matrix[2][3] = pTri[MDX_TAG_ORIGIN][2];
+
+ 		// copy axis to matrix - do some magic to orient minus Y to positive X and so on so bolt on stuff is oriented correctly
+		boltList[boltNum].position.matrix[0][0] = axes[1][0];
+		boltList[boltNum].position.matrix[0][1] = axes[0][0];
+		boltList[boltNum].position.matrix[0][2] = -axes[2][0];
+
+		boltList[boltNum].position.matrix[1][0] = axes[1][1];
+		boltList[boltNum].position.matrix[1][1] = axes[0][1];
+		boltList[boltNum].position.matrix[1][2] = -axes[2][1];
+
+		boltList[boltNum].position.matrix[2][0] = axes[1][2];
+		boltList[boltNum].position.matrix[2][1] = axes[0][2];
+		boltList[boltNum].position.matrix[2][2] = -axes[2][2];
+	}
+
+}
+
+ 
+// now go through all the generated surfaces that aren't included in the model surface hierarchy and create the correct bolt info for them				  
+void G2_ProcessGeneratedSurfaceBolts(CGhoul2Info &ghoul2, mdxaBone_v &bonePtr, model_t *mod_t)
+{
+#ifdef G2_PERFORMANCE_ANALYSIS
+	G2PerformanceTimer_G2_ProcessGeneratedSurfaceBolts.Start();
+#endif
+	// look through the surfaces off the end of the pre-defined model surfaces
+	for (int i=0; i< ghoul2.mSlist.size(); i++)
+	{
+		// only look for bolts if we are actually a generated surface, and not just an overriden one
+		if (ghoul2.mSlist[i].offFlags & G2SURFACEFLAG_GENERATED)
+		{
+	   		// well alrighty then. Lets see if there is a bolt that is attempting to use it
+			int boltNum = G2_Find_Bolt_Surface_Num(ghoul2.mBltlist, i, G2SURFACEFLAG_GENERATED);
+			// yes - ok, processing time.
+			if (boltNum != -1)
+			{
+				G2_ProcessSurfaceBolt(bonePtr, NULL, boltNum, ghoul2.mBltlist, &ghoul2.mSlist[i], mod_t);
+			}
+		}
+	}
+#ifdef G2_PERFORMANCE_ANALYSIS
+	G2Time_G2_ProcessGeneratedSurfaceBolts += G2PerformanceTimer_G2_ProcessGeneratedSurfaceBolts.End();
+#endif
+}
+
+#ifndef DEDICATED
+void RenderSurfaces(CRenderSurface &RS) //also ended up just ripping right from SP.
+{
+#ifdef G2_PERFORMANCE_ANALYSIS
+	G2PerformanceTimer_RenderSurfaces.Start();
+#endif
+	int			i;
+	const shader_t	*shader = 0;
+	int			offFlags = 0;
+#ifdef _G2_GORE
+	bool		drawGore = true;
+#endif
+
+	assert(RS.currentModel);
+	assert(RS.currentModel->mdxm);
+	// back track and get the surfinfo struct for this surface
+	mdxmSurface_t			*surface = (mdxmSurface_t *)G2_FindSurface(RS.currentModel, RS.surfaceNum, RS.lod);
+	mdxmHierarchyOffsets_t	*surfIndexes = (mdxmHierarchyOffsets_t *)((byte *)RS.currentModel->mdxm + sizeof(mdxmHeader_t));
+	mdxmSurfHierarchy_t		*surfInfo = (mdxmSurfHierarchy_t *)((byte *)surfIndexes + surfIndexes->offsets[surface->thisSurfaceIndex]);
+	
+	// see if we have an override surface in the surface list
+	const surfaceInfo_t	*surfOverride = G2_FindOverrideSurface(RS.surfaceNum, RS.rootSList);
+
+	// really, we should use the default flags for this surface unless it's been overriden
+	offFlags = surfInfo->flags;
+
+	// set the off flags if we have some
+	if (surfOverride)
+	{
+		offFlags = surfOverride->offFlags;
+	}
+
+	// if this surface is not off, add it to the shader render list
+	if (!offFlags)
+	{	
+ 		if ( RS.cust_shader ) 
+		{
+			shader = RS.cust_shader;
+		} 
+		else if ( RS.skin ) 
+		{
+			int		j;
+			
+			// match the surface name to something in the skin file
+			shader = tr.defaultShader;
+			for ( j = 0 ; j < RS.skin->numSurfaces ; j++ )
+			{
+				// the names have both been lowercased
+				if ( !strcmp( RS.skin->surfaces[j]->name, surfInfo->name ) ) 
+				{
+					shader = RS.skin->surfaces[j]->shader;
+					break;
+				}
+			}
+		} 
+		else 
+		{
+			shader = R_GetShaderByHandle( surfInfo->shaderIndex );
+		}
+
+		//rww - catch surfaces with bad shaders
+		//assert(shader != tr.defaultShader);
+		//Alright, this is starting to annoy me because of the state of the assets. Disabling for now.
+		// we will add shadows even if the main object isn't visible in the view
+		// stencil shadows can't do personal models unless I polyhedron clip
+		//using z-fail now so can do personal models -rww
+		if ( /*!RS.personalModel
+			&& */r_shadows->integer == 2 
+//			&& RS.fogNum == 0
+			&& (RS.renderfx & RF_SHADOW_PLANE )
+			&& !(RS.renderfx & ( RF_NOSHADOW | RF_DEPTHHACK ) ) 
+			&& shader->sort == SS_OPAQUE ) 
+		{		// set the surface info to point at the where the transformed bone list is going to be for when the surface gets rendered out
+			CRenderableSurface *newSurf = new CRenderableSurface;
+#ifdef _XBOX //testing performance benefit vs ugliness
+			// On Xbox, we always use the lowest LOD
+			mdxmSurface_t *lowsurface = (mdxmSurface_t *)G2_FindSurface(RS.currentModel, RS.surfaceNum, RS.currentModel->numLods-1);
+			newSurf->surfaceData = lowsurface;
+#else
+			if (surface->numVerts >= SHADER_MAX_VERTEXES/2)
+			{ //we need numVerts*2 xyz slots free in tess to do shadow, if this surf is going to exceed that then let's try the lowest lod -rww
+				mdxmSurface_t *lowsurface = (mdxmSurface_t *)G2_FindSurface(RS.currentModel, RS.surfaceNum, RS.currentModel->numLods-1);
+				newSurf->surfaceData = lowsurface;
+			}
+			else
+			{
+				newSurf->surfaceData = surface;
+			}
+#endif
+			newSurf->boneCache = RS.boneCache;
+			R_AddDrawSurf( (surfaceType_t *)newSurf, tr.shadowShader, 0, qfalse );
+		}
+
+		// projection shadows work fine with personal models
+		if ( r_shadows->integer == 3
+//			&& RS.fogNum == 0
+			&& (RS.renderfx & RF_SHADOW_PLANE )
+			&& shader->sort == SS_OPAQUE ) 
+		{		// set the surface info to point at the where the transformed bone list is going to be for when the surface gets rendered out
+			CRenderableSurface *newSurf = new CRenderableSurface;
+			newSurf->surfaceData = surface;
+			newSurf->boneCache = RS.boneCache;
+			R_AddDrawSurf( (surfaceType_t *)newSurf, tr.projectionShadowShader, 0, qfalse );
+		}
+
+		// don't add third_person objects if not viewing through a portal
+		if ( !RS.personalModel ) 
+		{		// set the surface info to point at the where the transformed bone list is going to be for when the surface gets rendered out
+			CRenderableSurface *newSurf = new CRenderableSurface;
+			newSurf->surfaceData = surface;
+			newSurf->boneCache = RS.boneCache;
+			R_AddDrawSurf( (surfaceType_t *)newSurf, (shader_t *)shader, RS.fogNum, qfalse );
+
+#ifdef _G2_GORE
+			if (RS.gore_set && drawGore)
+			{
+				int curTime = G2API_GetTime(tr.refdef.time);
+				pair<multimap<int,SGoreSurface>::iterator,multimap<int,SGoreSurface>::iterator> range=
+					RS.gore_set->mGoreRecords.equal_range(RS.surfaceNum);
+				multimap<int,SGoreSurface>::iterator k,kcur;
+				CRenderableSurface *last=newSurf;
+				for (k=range.first;k!=range.second;)
+				{
+					kcur=k;
+					k++;
+					GoreTextureCoordinates *tex=FindGoreRecord((*kcur).second.mGoreTag);
+					if (!tex ||											 // it is gone, lets get rid of it
+						(*kcur).second.mDeleteTime && curTime>=(*kcur).second.mDeleteTime) // out of time
+					{
+						if (tex)
+						{
+							(*tex).~GoreTextureCoordinates();
+							//I don't know what's going on here, it should call the destructor for
+							//this when it erases the record but sometimes it doesn't. -rww
+						}
+
+						RS.gore_set->mGoreRecords.erase(kcur);
+					}
+					else if (tex->tex[RS.lod])
+					{
+						CRenderableSurface *newSurf2 = AllocRS();
+						*newSurf2=*newSurf;
+						newSurf2->goreChain=0;
+						newSurf2->alternateTex=tex->tex[RS.lod];
+						newSurf2->scale=1.0f;
+						newSurf2->fade=1.0f;
+						newSurf2->impactTime=1.0f;	// done with
+						int magicFactor42=500; // ms, impact time
+						if (curTime>(*kcur).second.mGoreGrowStartTime && curTime<(*kcur).second.mGoreGrowStartTime+magicFactor42)
+						{
+							newSurf2->impactTime=float(curTime-(*kcur).second.mGoreGrowStartTime)/float(magicFactor42);  // linear
+						}
+						if (curTime<(*kcur).second.mGoreGrowEndTime)
+						{
+							newSurf2->scale=1.0f/((curTime-(*kcur).second.mGoreGrowStartTime)*(*kcur).second.mGoreGrowFactor + (*kcur).second.mGoreGrowOffset);
+							if (newSurf2->scale<1.0f)
+							{
+								newSurf2->scale=1.0f;
+							}
+						}
+						shader_t *gshader;
+						if ((*kcur).second.shader)
+						{
+ 							gshader=R_GetShaderByHandle((*kcur).second.shader);
+						}
+						else
+						{
+							gshader=R_GetShaderByHandle(goreShader);
+						}
+
+						// Set fade on surf.
+						//Only if we have a fade time set, and let us fade on rgb if we want -rww
+						if ((*kcur).second.mDeleteTime && (*kcur).second.mFadeTime)
+						{
+							if ((*kcur).second.mDeleteTime - curTime < (*kcur).second.mFadeTime)
+							{
+								newSurf2->fade=(float)((*kcur).second.mDeleteTime - curTime)/(*kcur).second.mFadeTime;
+								if ((*kcur).second.mFadeRGB)
+								{ //RGB fades are scaled from 2.0f to 3.0f (simply to differentiate)
+									newSurf2->fade += 2.0f;
+
+									if (newSurf2->fade < 2.01f)
+									{
+										newSurf2->fade = 2.01f;
+									}
+								}
+							}
+						}
+
+						last->goreChain=newSurf2;
+						last=newSurf2;
+						R_AddDrawSurf( (surfaceType_t *)newSurf2,gshader, RS.fogNum, qfalse );
+					}
+				}
+			}
+#endif
+		}
+	}
+	
+	// if we are turning off all descendants, then stop this recursion now
+	if (offFlags & G2SURFACEFLAG_NODESCENDANTS)
+	{
+		return;
+	}
+
+	// now recursively call for the children
+	for (i=0; i< surfInfo->numChildren; i++)
+	{
+		RS.surfaceNum = surfInfo->childIndexes[i];
+		RenderSurfaces(RS);
+	}
+
+#ifdef G2_PERFORMANCE_ANALYSIS
+	G2Time_RenderSurfaces += G2PerformanceTimer_RenderSurfaces.End();
+#endif
+}
+#endif //!DEDICATED
+
+// Go through the model and deal with just the surfaces that are tagged as bolt on points - this is for the server side skeleton construction
+void ProcessModelBoltSurfaces(int surfaceNum, surfaceInfo_v &rootSList,
+					mdxaBone_v &bonePtr, model_t *currentModel, int lod, boltInfo_v &boltList)
+{
+#ifdef G2_PERFORMANCE_ANALYSIS
+	G2PerformanceTimer_ProcessModelBoltSurfaces.Start();
+#endif
+	int			i;
+	int			offFlags = 0;
+	
+	// back track and get the surfinfo struct for this surface
+	mdxmSurface_t			*surface = (mdxmSurface_t *)G2_FindSurface((void *)currentModel, surfaceNum, 0);
+	mdxmHierarchyOffsets_t	*surfIndexes = (mdxmHierarchyOffsets_t *)((byte *)currentModel->mdxm + sizeof(mdxmHeader_t));
+	mdxmSurfHierarchy_t		*surfInfo = (mdxmSurfHierarchy_t *)((byte *)surfIndexes + surfIndexes->offsets[surface->thisSurfaceIndex]);
+	
+	// see if we have an override surface in the surface list
+	surfaceInfo_t	*surfOverride = G2_FindOverrideSurface(surfaceNum, rootSList);
+
+	// really, we should use the default flags for this surface unless it's been overriden
+	offFlags = surfInfo->flags;
+
+	// set the off flags if we have some
+	if (surfOverride)
+	{
+		offFlags = surfOverride->offFlags;
+	}
+
+	// is this surface considered a bolt surface?
+	if (surfInfo->flags & G2SURFACEFLAG_ISBOLT)
+	{
+		// well alrighty then. Lets see if there is a bolt that is attempting to use it
+		int boltNum = G2_Find_Bolt_Surface_Num(boltList, surfaceNum, 0);
+		// yes - ok, processing time.
+		if (boltNum != -1)
+		{
+			G2_ProcessSurfaceBolt(bonePtr, surface, boltNum, boltList, surfOverride, currentModel);
+		}
+	}
+	
+	// if we are turning off all descendants, then stop this recursion now
+	if (offFlags & G2SURFACEFLAG_NODESCENDANTS)
+	{
+		return;
+	}
+
+	// now recursively call for the children
+	for (i=0; i< surfInfo->numChildren; i++)
+	{
+		ProcessModelBoltSurfaces(surfInfo->childIndexes[i], rootSList, bonePtr, currentModel, lod, boltList);
+	}
+
+#ifdef G2_PERFORMANCE_ANALYSIS
+	G2Time_ProcessModelBoltSurfaces += G2PerformanceTimer_ProcessModelBoltSurfaces.End();
+#endif
+}
+
+
+// build the used bone list so when doing bone transforms we can determine if we need to do it or not
+void G2_ConstructUsedBoneList(CConstructBoneList &CBL)
+{
+	int	 		i, j;
+	int			offFlags = 0;
+
+	// back track and get the surfinfo struct for this surface
+	const mdxmSurface_t			*surface = (mdxmSurface_t *)G2_FindSurface((void *)CBL.currentModel, CBL.surfaceNum, 0);
+	const mdxmHierarchyOffsets_t	*surfIndexes = (mdxmHierarchyOffsets_t *)((byte *)CBL.currentModel->mdxm + sizeof(mdxmHeader_t));
+	const mdxmSurfHierarchy_t	*surfInfo = (mdxmSurfHierarchy_t *)((byte *)surfIndexes + surfIndexes->offsets[surface->thisSurfaceIndex]);
+	const model_t				*mod_a = R_GetModelByHandle(CBL.currentModel->mdxm->animIndex);
+	const mdxaSkelOffsets_t		*offsets = (mdxaSkelOffsets_t *)((byte *)mod_a->mdxa + sizeof(mdxaHeader_t));
+	const mdxaSkel_t			*skel, *childSkel;
+
+	// see if we have an override surface in the surface list
+	const surfaceInfo_t	*surfOverride = G2_FindOverrideSurface(CBL.surfaceNum, CBL.rootSList);
+
+	// really, we should use the default flags for this surface unless it's been overriden
+	offFlags = surfInfo->flags;
+
+	// set the off flags if we have some
+	if (surfOverride)
+	{
+		offFlags = surfOverride->offFlags;
+	}
+
+	// if this surface is not off, add it to the shader render list
+	if (!(offFlags & G2SURFACEFLAG_OFF))
+	{
+		int	*bonesReferenced = (int *)((byte*)surface + surface->ofsBoneReferences);
+		// now whip through the bones this surface uses
+		for (i=0; i<surface->numBoneReferences;i++)
+		{
+			int iBoneIndex = bonesReferenced[i];
+			CBL.boneUsedList[iBoneIndex] = 1;
+
+			// now go and check all the descendant bones attached to this bone and see if any have the always flag on them. If so, activate them
+ 			skel = (mdxaSkel_t *)((byte *)mod_a->mdxa + sizeof(mdxaHeader_t) + offsets->offsets[iBoneIndex]);
+
+			// for every child bone...
+			for (j=0; j< skel->numChildren; j++)
+			{
+				// get the skel data struct for each child bone of the referenced bone
+ 				childSkel = (mdxaSkel_t *)((byte *)mod_a->mdxa + sizeof(mdxaHeader_t) + offsets->offsets[skel->children[j]]);
+
+				// does it have the always on flag on?
+				if (childSkel->flags & G2BONEFLAG_ALWAYSXFORM)
+				{
+					// yes, make sure it's in the list of bones to be transformed.
+					CBL.boneUsedList[skel->children[j]] = 1;
+				}
+			}
+
+			// now we need to ensure that the parents of this bone are actually active...
+			//			
+			int iParentBone = skel->parent;
+			while (iParentBone != -1)
+			{	
+				if (CBL.boneUsedList[iParentBone])	// no need to go higher
+					break;
+				CBL.boneUsedList[iParentBone] = 1;
+				skel = (mdxaSkel_t *)((byte *)mod_a->mdxa + sizeof(mdxaHeader_t) + offsets->offsets[iParentBone]);				
+				iParentBone = skel->parent;
+			}
+		}
+	}
+ 	else
+	// if we are turning off all descendants, then stop this recursion now
+	if (offFlags & G2SURFACEFLAG_NODESCENDANTS)
+	{
+		return;
+	}
+
+	// now recursively call for the children
+	for (i=0; i< surfInfo->numChildren; i++)
+	{
+		CBL.surfaceNum = surfInfo->childIndexes[i];
+		G2_ConstructUsedBoneList(CBL);
+	}
+}
+
+
+// sort all the ghoul models in this list so if they go in reference order. This will ensure the bolt on's are attached to the right place
+// on the previous model, since it ensures the model being attached to is built and rendered first.
+
+// NOTE!! This assumes at least one model will NOT have a parent. If it does - we are screwed
+static void G2_Sort_Models(CGhoul2Info_v &ghoul2, int * const modelList, int * const modelCount)
+{
+	int		startPoint, endPoint;
+	int		i, boltTo, j;
+
+	*modelCount = 0;
+
+	// first walk all the possible ghoul2 models, and stuff the out array with those with no parents
+	for (i=0; i<ghoul2.size();i++)
+	{
+		// have a ghoul model here?
+		if (ghoul2[i].mModelindex == -1)
+		{
+			continue;
+		}
+
+		if (!ghoul2[i].mValid)
+		{
+			continue;
+		}
+
+		// are we attached to anything?
+		if (ghoul2[i].mModelBoltLink == -1)
+		{
+			// no, insert us first
+			modelList[(*modelCount)++] = i;
+	 	}
+	}
+
+	startPoint = 0;
+	endPoint = *modelCount;
+
+	// now, using that list of parentless models, walk the descendant tree for each of them, inserting the descendents in the list
+	while (startPoint != endPoint)
+	{
+		for (i=0; i<ghoul2.size(); i++)
+		{
+			// have a ghoul model here?
+			if (ghoul2[i].mModelindex == -1)
+			{
+				continue;
+			}
+
+			if (!ghoul2[i].mValid)
+			{
+				continue;
+			}
+
+			// what does this model think it's attached to?
+			if (ghoul2[i].mModelBoltLink != -1)
+			{
+				boltTo = (ghoul2[i].mModelBoltLink >> MODEL_SHIFT) & MODEL_AND;
+				// is it any of the models we just added to the list?
+				for (j=startPoint; j<endPoint; j++)
+				{
+					// is this my parent model?
+					if (boltTo == modelList[j])
+					{
+						// yes, insert into list and exit now
+						modelList[(*modelCount)++] = i;
+						break;
+					}
+				}
+			}
+		}
+		// update start and end points
+		startPoint = endPoint;
+		endPoint = *modelCount;
+	}
+}
+
+void *G2_FindSurface_BC(const model_s *mod, int index, int lod)
+{
+	assert(mod);
+	assert(mod->mdxm);
+
+	// point at first lod list
+	byte	*current = (byte*)((int)mod->mdxm + (int)mod->mdxm->ofsLODs);
+	int i;
+
+	//walk the lods
+	assert(lod>=0&&lod<mod->mdxm->numLODs);
+	for (i=0; i<lod; i++)
+	{
+		mdxmLOD_t *lodData = (mdxmLOD_t *)current;
+		current += lodData->ofsEnd;
+	}
+
+	// avoid the lod pointer data structure
+	current += sizeof(mdxmLOD_t);
+
+	mdxmLODSurfOffset_t *indexes = (mdxmLODSurfOffset_t *)current;
+	// we are now looking at the offset array
+	assert(index>=0&&index<mod->mdxm->numSurfaces);
+	current += indexes->offsets[index];
+
+	return (void *)current;
+}
+
+//#define G2EVALRENDER
+
+// We've come across a surface that's designated as a bolt surface, process it and put it in the appropriate bolt place
+void G2_ProcessSurfaceBolt2(CBoneCache &boneCache, const mdxmSurface_t *surface, int boltNum, boltInfo_v &boltList, const surfaceInfo_t *surfInfo, const model_t *mod,mdxaBone_t &retMatrix)
+{
+ 	mdxmVertex_t 	*v, *vert0, *vert1, *vert2;
+ 	vec3_t			axes[3], sides[3];
+ 	float			pTri[3][3], d;
+ 	int				j, k;
+
+	// now there are two types of tag surface - model ones and procedural generated types - lets decide which one we have here.
+	if (surfInfo && surfInfo->offFlags == G2SURFACEFLAG_GENERATED)
+	{
+		int surfNumber = surfInfo->genPolySurfaceIndex & 0x0ffff;
+		int	polyNumber = (surfInfo->genPolySurfaceIndex >> 16) & 0x0ffff;
+
+		// find original surface our original poly was in.
+		mdxmSurface_t	*originalSurf = (mdxmSurface_t *)G2_FindSurface_BC(mod, surfNumber, surfInfo->genLod);
+		mdxmTriangle_t	*originalTriangleIndexes = (mdxmTriangle_t *)((byte*)originalSurf + originalSurf->ofsTriangles);
+
+		// get the original polys indexes 
+		int index0 = originalTriangleIndexes[polyNumber].indexes[0];
+		int index1 = originalTriangleIndexes[polyNumber].indexes[1];
+		int index2 = originalTriangleIndexes[polyNumber].indexes[2];
+
+		// decide where the original verts are
+ 		vert0 = (mdxmVertex_t *) ((byte *)originalSurf + originalSurf->ofsVerts);
+		vert0+=index0;
+
+		vert1 = (mdxmVertex_t *) ((byte *)originalSurf + originalSurf->ofsVerts);
+		vert1+=index1;
+
+		vert2 = (mdxmVertex_t *) ((byte *)originalSurf + originalSurf->ofsVerts);
+		vert2+=index2;
+
+		// clear out the triangle verts to be
+ 	   	VectorClear( pTri[0] );
+ 	   	VectorClear( pTri[1] );
+ 	   	VectorClear( pTri[2] );
+		int *piBoneReferences = (int*) ((byte*)originalSurf + originalSurf->ofsBoneReferences);
+
+//		mdxmWeight_t	*w;
+		
+		// now go and transform just the points we need from the surface that was hit originally
+//		w = vert0->weights;
+		float fTotalWeight = 0.0f;
+		int iNumWeights = G2_GetVertWeights( vert0 );
+ 		for ( k = 0 ; k < iNumWeights ; k++ ) 
+ 		{
+			int		iBoneIndex	= G2_GetVertBoneIndex( vert0, k );
+			float	fBoneWeight	= G2_GetVertBoneWeight( vert0, k, fTotalWeight, iNumWeights );
+
+#ifdef G2EVALRENDER
+			const mdxaBone_t &bone=boneCache.EvalRender(piBoneReferences[iBoneIndex]);
+#else
+			const mdxaBone_t &bone=boneCache.Eval(piBoneReferences[iBoneIndex]);
+#endif
+
+#ifdef _XBOX
+			vec3_t vec;
+			Q_CastShort2FloatScale(&vec[0], &vert0->vertCoords[0], 1.f / (float)GLM_COMP_SIZE);
+			Q_CastShort2FloatScale(&vec[1], &vert0->vertCoords[1], 1.f / (float)GLM_COMP_SIZE);
+			Q_CastShort2FloatScale(&vec[2], &vert0->vertCoords[2], 1.f / (float)GLM_COMP_SIZE);
+
+			pTri[0][0] += fBoneWeight * ( DotProduct( bone.matrix[0], vec ) + bone.matrix[0][3] );
+			pTri[0][1] += fBoneWeight * ( DotProduct( bone.matrix[1], vec ) + bone.matrix[1][3] );
+			pTri[0][2] += fBoneWeight * ( DotProduct( bone.matrix[2], vec ) + bone.matrix[2][3] );
+#else
+			pTri[0][0] += fBoneWeight * ( DotProduct( bone.matrix[0], vert0->vertCoords ) + bone.matrix[0][3] );
+ 			pTri[0][1] += fBoneWeight * ( DotProduct( bone.matrix[1], vert0->vertCoords ) + bone.matrix[1][3] );
+ 			pTri[0][2] += fBoneWeight * ( DotProduct( bone.matrix[2], vert0->vertCoords ) + bone.matrix[2][3] );
+#endif
+		}
+
+//		w = vert1->weights;
+		fTotalWeight = 0.0f;
+		iNumWeights = G2_GetVertWeights( vert1 );
+ 		for ( k = 0 ; k < iNumWeights ; k++) 
+ 		{
+			int		iBoneIndex	= G2_GetVertBoneIndex( vert1, k );
+			float	fBoneWeight	= G2_GetVertBoneWeight( vert1, k, fTotalWeight, iNumWeights );
+
+#ifdef G2EVALRENDER
+			const mdxaBone_t &bone=boneCache.EvalRender(piBoneReferences[iBoneIndex]);
+#else
+			const mdxaBone_t &bone=boneCache.Eval(piBoneReferences[iBoneIndex]);
+#endif
+
+#ifdef _XBOX
+			vec3_t vec;
+			Q_CastShort2FloatScale(&vec[0], &vert1->vertCoords[0], 1.f / (float)GLM_COMP_SIZE);
+			Q_CastShort2FloatScale(&vec[1], &vert1->vertCoords[1], 1.f / (float)GLM_COMP_SIZE);
+			Q_CastShort2FloatScale(&vec[2], &vert1->vertCoords[2], 1.f / (float)GLM_COMP_SIZE);
+
+			pTri[1][0] += fBoneWeight * ( DotProduct( bone.matrix[0], vec ) + bone.matrix[0][3] );
+			pTri[1][1] += fBoneWeight * ( DotProduct( bone.matrix[1], vec ) + bone.matrix[1][3] );
+			pTri[1][2] += fBoneWeight * ( DotProduct( bone.matrix[2], vec ) + bone.matrix[2][3] );
+#else
+ 			pTri[1][0] += fBoneWeight * ( DotProduct( bone.matrix[0], vert1->vertCoords ) + bone.matrix[0][3] );
+ 			pTri[1][1] += fBoneWeight * ( DotProduct( bone.matrix[1], vert1->vertCoords ) + bone.matrix[1][3] );
+ 			pTri[1][2] += fBoneWeight * ( DotProduct( bone.matrix[2], vert1->vertCoords ) + bone.matrix[2][3] );
+#endif
+		}
+
+//		w = vert2->weights;
+		fTotalWeight = 0.0f;
+		iNumWeights = G2_GetVertWeights( vert2 );
+ 		for ( k = 0 ; k < iNumWeights ; k++) 
+ 		{
+			int		iBoneIndex	= G2_GetVertBoneIndex( vert2, k );
+			float	fBoneWeight	= G2_GetVertBoneWeight( vert2, k, fTotalWeight, iNumWeights );
+
+#ifdef G2EVALRENDER
+			const mdxaBone_t &bone=boneCache.EvalRender(piBoneReferences[iBoneIndex]);
+#else
+			const mdxaBone_t &bone=boneCache.Eval(piBoneReferences[iBoneIndex]);
+#endif
+
+#ifdef _XBOX
+			vec3_t vec;
+			Q_CastShort2FloatScale(&vec[0], &vert2->vertCoords[0], 1.f / (float)GLM_COMP_SIZE);
+			Q_CastShort2FloatScale(&vec[1], &vert2->vertCoords[1], 1.f / (float)GLM_COMP_SIZE);
+			Q_CastShort2FloatScale(&vec[2], &vert2->vertCoords[2], 1.f / (float)GLM_COMP_SIZE);
+
+			pTri[2][0] += fBoneWeight * ( DotProduct( bone.matrix[0], vec ) + bone.matrix[0][3] );
+			pTri[2][1] += fBoneWeight * ( DotProduct( bone.matrix[1], vec ) + bone.matrix[1][3] );
+			pTri[2][2] += fBoneWeight * ( DotProduct( bone.matrix[2], vec ) + bone.matrix[2][3] );
+#else
+ 			pTri[2][0] += fBoneWeight * ( DotProduct( bone.matrix[0], vert2->vertCoords ) + bone.matrix[0][3] );
+ 			pTri[2][1] += fBoneWeight * ( DotProduct( bone.matrix[1], vert2->vertCoords ) + bone.matrix[1][3] );
+ 			pTri[2][2] += fBoneWeight * ( DotProduct( bone.matrix[2], vert2->vertCoords ) + bone.matrix[2][3] );
+#endif
+		}
+ 			
+   		vec3_t normal;
+		vec3_t up;
+		vec3_t right;
+		vec3_t vec0, vec1;
+		// work out baryCentricK
+		float baryCentricK = 1.0 - (surfInfo->genBarycentricI + surfInfo->genBarycentricJ);
+
+		// now we have the model transformed into model space, now generate an origin.
+		retMatrix.matrix[0][3] = (pTri[0][0] * surfInfo->genBarycentricI) + (pTri[1][0] * surfInfo->genBarycentricJ) + (pTri[2][0] * baryCentricK);
+		retMatrix.matrix[1][3] = (pTri[0][1] * surfInfo->genBarycentricI) + (pTri[1][1] * surfInfo->genBarycentricJ) + (pTri[2][1] * baryCentricK);
+		retMatrix.matrix[2][3] = (pTri[0][2] * surfInfo->genBarycentricI) + (pTri[1][2] * surfInfo->genBarycentricJ) + (pTri[2][2] * baryCentricK);
+
+		// generate a normal to this new triangle
+		VectorSubtract(pTri[0], pTri[1], vec0);
+		VectorSubtract(pTri[2], pTri[1], vec1);
+
+		CrossProduct(vec0, vec1, normal);
+		VectorNormalize(normal);
+
+		// forward vector
+		retMatrix.matrix[0][0] = normal[0];
+		retMatrix.matrix[1][0] = normal[1];
+		retMatrix.matrix[2][0] = normal[2];
+
+		// up will be towards point 0 of the original triangle.
+		// so lets work it out. Vector is hit point - point 0
+		up[0] = retMatrix.matrix[0][3] - pTri[0][0];
+		up[1] = retMatrix.matrix[1][3] - pTri[0][1];
+		up[2] = retMatrix.matrix[2][3] - pTri[0][2];
+
+		// normalise it
+		VectorNormalize(up);
+
+		// that's the up vector
+		retMatrix.matrix[0][1] = up[0];
+		retMatrix.matrix[1][1] = up[1];
+		retMatrix.matrix[2][1] = up[2];
+
+		// right is always straight
+
+		CrossProduct( normal, up, right );
+		// that's the up vector
+		retMatrix.matrix[0][2] = right[0];
+		retMatrix.matrix[1][2] = right[1];
+		retMatrix.matrix[2][2] = right[2];
+
+
+	}
+	// no, we are looking at a normal model tag
+	else
+	{
+	 	// whip through and actually transform each vertex
+ 		v = (mdxmVertex_t *) ((byte *)surface + surface->ofsVerts);
+		int *piBoneReferences = (int*) ((byte*)surface + surface->ofsBoneReferences);
+ 		for ( j = 0; j < 3; j++ ) 
+ 		{
+// 			mdxmWeight_t	*w;
+
+ 			VectorClear( pTri[j] );
+ //			w = v->weights;
+
+			const int iNumWeights = G2_GetVertWeights( v );
+
+			float fTotalWeight = 0.0f;
+ 			for ( k = 0 ; k < iNumWeights ; k++) 
+ 			{
+				int		iBoneIndex	= G2_GetVertBoneIndex( v, k );
+				float	fBoneWeight	= G2_GetVertBoneWeight( v, k, fTotalWeight, iNumWeights );
+
+#ifdef G2EVALRENDER
+				const mdxaBone_t &bone=boneCache.EvalRender(piBoneReferences[iBoneIndex]);
+#else
+				const mdxaBone_t &bone=boneCache.Eval(piBoneReferences[iBoneIndex]);
+#endif
+
+#ifdef _XBOX
+				vec3_t vec;
+				Q_CastShort2FloatScale(&vec[0], &v->vertCoords[0], 1.f / (float)GLM_COMP_SIZE);
+				Q_CastShort2FloatScale(&vec[1], &v->vertCoords[1], 1.f / (float)GLM_COMP_SIZE);
+				Q_CastShort2FloatScale(&vec[2], &v->vertCoords[2], 1.f / (float)GLM_COMP_SIZE);
+
+				pTri[j][0] += fBoneWeight * ( DotProduct( bone.matrix[0], vec ) + bone.matrix[0][3] );
+				pTri[j][1] += fBoneWeight * ( DotProduct( bone.matrix[1], vec ) + bone.matrix[1][3] );
+				pTri[j][2] += fBoneWeight * ( DotProduct( bone.matrix[2], vec ) + bone.matrix[2][3] );
+#else
+ 				pTri[j][0] += fBoneWeight * ( DotProduct( bone.matrix[0], v->vertCoords ) + bone.matrix[0][3] );
+ 				pTri[j][1] += fBoneWeight * ( DotProduct( bone.matrix[1], v->vertCoords ) + bone.matrix[1][3] );
+ 				pTri[j][2] += fBoneWeight * ( DotProduct( bone.matrix[2], v->vertCoords ) + bone.matrix[2][3] );
+#endif
+ 			}
+ 			
+ 			v++;// = (mdxmVertex_t *)&v->weights[/*v->numWeights*/surface->maxVertBoneWeights];
+ 		}
+
+ 		// clear out used arrays
+ 		memset( axes, 0, sizeof( axes ) );
+ 		memset( sides, 0, sizeof( sides ) );
+
+ 		// work out actual sides of the tag triangle
+ 		for ( j = 0; j < 3; j++ )
+ 		{
+ 			sides[j][0] = pTri[(j+1)%3][0] - pTri[j][0];
+ 			sides[j][1] = pTri[(j+1)%3][1] - pTri[j][1];
+ 			sides[j][2] = pTri[(j+1)%3][2] - pTri[j][2];
+ 		}
+
+ 		// do math trig to work out what the matrix will be from this triangle's translated position
+ 		VectorNormalize2( sides[iG2_TRISIDE_LONGEST], axes[0] );
+ 		VectorNormalize2( sides[iG2_TRISIDE_SHORTEST], axes[1] );
+
+ 		// project shortest side so that it is exactly 90 degrees to the longer side
+ 		d = DotProduct( axes[0], axes[1] );
+ 		VectorMA( axes[0], -d, axes[1], axes[0] );
+ 		VectorNormalize2( axes[0], axes[0] );
+
+ 		CrossProduct( sides[iG2_TRISIDE_LONGEST], sides[iG2_TRISIDE_SHORTEST], axes[2] );
+ 		VectorNormalize2( axes[2], axes[2] );
+
+ 		// set up location in world space of the origin point in out going matrix
+ 		retMatrix.matrix[0][3] = pTri[MDX_TAG_ORIGIN][0];
+ 		retMatrix.matrix[1][3] = pTri[MDX_TAG_ORIGIN][1];
+ 		retMatrix.matrix[2][3] = pTri[MDX_TAG_ORIGIN][2];
+
+ 		// copy axis to matrix - do some magic to orient minus Y to positive X and so on so bolt on stuff is oriented correctly
+		retMatrix.matrix[0][0] = axes[1][0];
+		retMatrix.matrix[0][1] = axes[0][0];
+		retMatrix.matrix[0][2] = -axes[2][0];
+
+		retMatrix.matrix[1][0] = axes[1][1];
+		retMatrix.matrix[1][1] = axes[0][1];
+		retMatrix.matrix[1][2] = -axes[2][1];
+
+		retMatrix.matrix[2][0] = axes[1][2];
+		retMatrix.matrix[2][1] = axes[0][2];
+		retMatrix.matrix[2][2] = -axes[2][2];
+	}
+
+}
+
+void G2_GetBoltMatrixLow(CGhoul2Info &ghoul2,int boltNum,const vec3_t scale,mdxaBone_t &retMatrix)
+{
+	if (!ghoul2.mBoneCache)
+	{
+		retMatrix=identityMatrix;
+		return;
+	}
+	assert(ghoul2.mBoneCache);
+	CBoneCache &boneCache=*ghoul2.mBoneCache;
+	assert(boneCache.mod);
+	boltInfo_v &boltList=ghoul2.mBltlist;
+	assert(boltNum>=0&&boltNum<boltList.size());
+#if 0 //rwwFIXMEFIXME: Disable this before release!!!!!! I am just trying to find a crash bug.
+	if (boltNum < 0 || boltNum >= boltList.size())
+	{
+		char fName[MAX_QPATH];
+		char mName[MAX_QPATH];
+		int bLink = ghoul2.mModelBoltLink;
+
+		if (ghoul2.currentModel)
+		{
+			strcpy(mName, ghoul2.currentModel->name);
+		}
+		else
+		{
+			strcpy(mName, "NULL!");
+		}
+
+		if (ghoul2.mFileName && ghoul2.mFileName[0])
+		{
+			strcpy(fName, ghoul2.mFileName);
+		}
+		else
+		{
+			strcpy(fName, "None?!");
+		}
+
+		Com_Error(ERR_DROP, "Write down or save this error message, show it to Rich\nBad bolt index on model %s (filename %s), index %i boltlink %i\n", mName, fName, boltNum, bLink);
+	}
+#endif
+	if (boltList[boltNum].boneNumber>=0)
+	{
+		mdxaSkel_t		*skel;
+		mdxaSkelOffsets_t *offsets;
+		offsets = (mdxaSkelOffsets_t *)((byte *)boneCache.header + sizeof(mdxaHeader_t));
+		skel = (mdxaSkel_t *)((byte *)boneCache.header + sizeof(mdxaHeader_t) + offsets->offsets[boltList[boltNum].boneNumber]);
+		Multiply_3x4Matrix(&retMatrix, (mdxaBone_t *)&boneCache.EvalUnsmooth(boltList[boltNum].boneNumber), &skel->BasePoseMat);
+	}
+	else if (boltList[boltNum].surfaceNumber>=0)
+	{
+		const surfaceInfo_t *surfInfo=0;
+		{
+			int i;
+			for (i=0;i<ghoul2.mSlist.size();i++)
+			{
+				surfaceInfo_t &t=ghoul2.mSlist[i];
+				if (t.surface==boltList[boltNum].surfaceNumber)
+				{
+					surfInfo=&t;
+				}
+			}
+		}
+		mdxmSurface_t *surface = 0;
+		if (!surfInfo)
+		{
+			surface = (mdxmSurface_t *)G2_FindSurface_BC(boneCache.mod,boltList[boltNum].surfaceNumber, 0);
+		}
+		if (!surface&&surfInfo&&surfInfo->surface<10000)
+		{
+			surface = (mdxmSurface_t *)G2_FindSurface_BC(boneCache.mod,surfInfo->surface, 0);
+		}
+		G2_ProcessSurfaceBolt2(boneCache,surface,boltNum,boltList,surfInfo,(model_t *)boneCache.mod,retMatrix);
+	}
+	else
+	{
+		 // we have a bolt without a bone or surface, not a huge problem but we ought to at least clear the bolt matrix
+		retMatrix=identityMatrix;
+	}
+}
+
+static void RootMatrix(CGhoul2Info_v &ghoul2,int time,const vec3_t scale,mdxaBone_t &retMatrix)
+{
+	int i;
+	for (i=0; i<ghoul2.size(); i++)
+	{
+		if (ghoul2[i].mModelindex != -1 && ghoul2[i].mValid)
+		{
+			if (ghoul2[i].mFlags & GHOUL2_NEWORIGIN)
+			{
+				mdxaBone_t bolt;
+				mdxaBone_t		tempMatrix;
+
+				G2_ConstructGhoulSkeleton(ghoul2,time,false,scale); 
+				G2_GetBoltMatrixLow(ghoul2[i],ghoul2[i].mNewOrigin,scale,bolt);
+				tempMatrix.matrix[0][0]=1.0f;
+				tempMatrix.matrix[0][1]=0.0f;
+				tempMatrix.matrix[0][2]=0.0f;
+				tempMatrix.matrix[0][3]=-bolt.matrix[0][3];
+				tempMatrix.matrix[1][0]=0.0f;
+				tempMatrix.matrix[1][1]=1.0f;
+				tempMatrix.matrix[1][2]=0.0f;
+				tempMatrix.matrix[1][3]=-bolt.matrix[1][3];
+				tempMatrix.matrix[2][0]=0.0f;
+				tempMatrix.matrix[2][1]=0.0f;
+				tempMatrix.matrix[2][2]=1.0f;
+				tempMatrix.matrix[2][3]=-bolt.matrix[2][3];
+//				Inverse_Matrix(&bolt, &tempMatrix);
+				Multiply_3x4Matrix(&retMatrix, &tempMatrix, (mdxaBone_t*)&identityMatrix);
+				return;
+			}
+		}
+	}
+	retMatrix=identityMatrix;
+}
+
+extern cvar_t	*r_shadowRange;
+static inline bool bInShadowRange(vec3_t location)
+{
+	const float c = DotProduct( tr.viewParms.ori.axis[0], tr.viewParms.ori.origin );
+	const float dist = DotProduct( tr.viewParms.ori.axis[0], location ) - c;
+
+//	return (dist < tr.distanceCull/1.5f);
+	return (dist < r_shadowRange->value);
+}
+
+/*
+==============
+R_AddGHOULSurfaces
+==============
+*/
+void R_AddGhoulSurfaces( trRefEntity_t *ent ) {
+#ifndef DEDICATED
+#ifdef G2_PERFORMANCE_ANALYSIS
+	G2PerformanceTimer_R_AddGHOULSurfaces.Start();
+#endif
+	shader_t		*cust_shader = 0;
+#ifdef _G2_GORE
+	shader_t		*gore_shader = 0;
+#endif
+	int				fogNum = 0;
+	qboolean		personalModel;
+	int				cull;
+	int				i, whichLod, j;
+	skin_t			*skin;
+	int				modelCount;
+	mdxaBone_t		rootMatrix;
+	CGhoul2Info_v	&ghoul2 = *((CGhoul2Info_v *)ent->e.ghoul2);
+
+	if ( !ghoul2.IsValid() )
+	{
+		return;
+	}
+	// if we don't want server ghoul2 models and this is one, or we just don't want ghoul2 models at all, then return
+	if (r_noServerGhoul2->integer)
+	{
+		return;
+	}
+	if (!G2_SetupModelPointers(ghoul2))
+	{
+		return;
+	}
+
+	int currentTime=G2API_GetTime(tr.refdef.time);
+
+
+	// cull the entire model if merged bounding box of both frames
+	// is outside the view frustum.
+	cull = R_GCullModel (ent );
+	if ( cull == CULL_OUT ) 
+	{
+		return;
+	}
+	HackadelicOnClient=true;
+	// are any of these models setting a new origin?
+	RootMatrix(ghoul2,currentTime, ent->e.modelScale,rootMatrix);
+
+   	// don't add third_person objects if not in a portal
+	personalModel = (qboolean)((ent->e.renderfx & RF_THIRD_PERSON) && !tr.viewParms.isPortal);
+
+	int modelList[256];
+	assert(ghoul2.size()<=255);
+	modelList[255]=548;
+
+	// set up lighting now that we know we aren't culled
+#ifdef VV_LIGHTING
+	if ( !personalModel ) {
+		VVLightMan.R_SetupEntityLighting( &tr.refdef, ent );
+#else
+	if ( !personalModel || r_shadows->integer > 1 ) {
+		R_SetupEntityLighting( &tr.refdef, ent );
+#endif
+	}
+
+	// see if we are in a fog volume
+	fogNum = R_GComputeFogNum( ent );
+
+	// order sort the ghoul 2 models so bolt ons get bolted to the right model
+	G2_Sort_Models(ghoul2, modelList, &modelCount);
+	assert(modelList[255]==548);
+
+#ifdef _G2_GORE
+	if (goreShader == -1)
+	{
+		goreShader=RE_RegisterShader("gfx/damage/burnmark1");
+	}
+#endif
+
+	// construct a world matrix for this entity
+	G2_GenerateWorldMatrix(ent->e.angles, ent->e.origin);
+
+	// walk each possible model for this entity and try rendering it out
+	for (j=0; j<modelCount; j++)
+	{
+		i = modelList[j];
+		if (ghoul2[i].mValid&&!(ghoul2[i].mFlags & GHOUL2_NOMODEL)&&!(ghoul2[i].mFlags & GHOUL2_NORENDER))
+		{
+			//
+			// figure out whether we should be using a custom shader for this model
+			//
+			skin = NULL;
+			if (ent->e.customShader)
+			{
+				cust_shader = R_GetShaderByHandle(ent->e.customShader );
+			}
+			else
+			{
+				cust_shader = NULL;
+				// figure out the custom skin thing
+				if (ghoul2[i].mCustomSkin)
+				{
+					skin = R_GetSkinByHandle(ghoul2[i].mCustomSkin );
+				}
+				else if (ent->e.customSkin)
+				{
+					skin = R_GetSkinByHandle(ent->e.customSkin );
+				}
+				else if ( ghoul2[i].mSkin > 0 && ghoul2[i].mSkin < tr.numSkins ) 
+				{
+					skin = R_GetSkinByHandle( ghoul2[i].mSkin );
+				}
+			}
+
+			if (j&&ghoul2[i].mModelBoltLink != -1)
+			{
+				int	boltMod = (ghoul2[i].mModelBoltLink >> MODEL_SHIFT) & MODEL_AND;
+				int	boltNum = (ghoul2[i].mModelBoltLink >> BOLT_SHIFT) & BOLT_AND;
+				mdxaBone_t bolt;
+				G2_GetBoltMatrixLow(ghoul2[boltMod],boltNum,ent->e.modelScale,bolt);
+				G2_TransformGhoulBones(ghoul2[i].mBlist,bolt, ghoul2[i],currentTime);
+			}
+			else
+			{
+				G2_TransformGhoulBones(ghoul2[i].mBlist, rootMatrix, ghoul2[i],currentTime);
+			}
+			whichLod = G2_ComputeLOD( ent, ghoul2[i].currentModel, ghoul2[i].mLodBias );
+			G2_FindOverrideSurface(-1,ghoul2[i].mSlist); //reset the quick surface override lookup;
+
+#ifdef _G2_GORE
+			CGoreSet *gore=0;
+			if (ghoul2[i].mGoreSetTag)
+			{
+				gore=FindGoreSet(ghoul2[i].mGoreSetTag);
+				if (!gore) // my gore is gone, so remove it
+				{
+					ghoul2[i].mGoreSetTag=0;
+				}
+			}
+
+			CRenderSurface RS(ghoul2[i].mSurfaceRoot, ghoul2[i].mSlist, cust_shader, fogNum, personalModel, ghoul2[i].mBoneCache, ent->e.renderfx, skin, (model_t *)ghoul2[i].currentModel, whichLod, ghoul2[i].mBltlist, gore_shader, gore);
+#else
+			CRenderSurface RS(ghoul2[i].mSurfaceRoot, ghoul2[i].mSlist, cust_shader, fogNum, personalModel, ghoul2[i].mBoneCache, ent->e.renderfx, skin, (model_t *)ghoul2[i].currentModel, whichLod, ghoul2[i].mBltlist);
+#endif
+			if (!personalModel && (RS.renderfx & RF_SHADOW_PLANE) && !bInShadowRange(ent->e.origin))
+			{
+				RS.renderfx |= RF_NOSHADOW;
+			}
+			RenderSurfaces(RS);
+		}
+	}
+	HackadelicOnClient=false;
+
+#ifdef G2_PERFORMANCE_ANALYSIS
+	G2Time_R_AddGHOULSurfaces += G2PerformanceTimer_R_AddGHOULSurfaces.End();
+#endif
+#endif //!DEDICATED
+}
+
+#ifdef _G2_LISTEN_SERVER_OPT
+qboolean G2API_OverrideServerWithClientData(CGhoul2Info *serverInstance);
+#endif
+
+bool G2_NeedsRecalc(CGhoul2Info *ghlInfo,int frameNum)
+{
+	G2_SetupModelPointers(ghlInfo);
+	// not sure if I still need this test, probably
+	if (ghlInfo->mSkelFrameNum!=frameNum||
+		!ghlInfo->mBoneCache||
+		ghlInfo->mBoneCache->mod!=ghlInfo->currentModel)
+	{
+#ifdef _G2_LISTEN_SERVER_OPT
+		if (ghlInfo->entityNum != ENTITYNUM_NONE &&
+			G2API_OverrideServerWithClientData(ghlInfo))
+		{ //if we can manage this, then we don't have to reconstruct
+			return false;
+		}
+#endif
+		ghlInfo->mSkelFrameNum=frameNum;
+		return true;
+	}
+	return false;
+}
+
+/*
+==============
+G2_ConstructGhoulSkeleton - builds a complete skeleton for all ghoul models in a CGhoul2Info_v class	- using LOD 0
+==============
+*/
+void G2_ConstructGhoulSkeleton( CGhoul2Info_v &ghoul2,const int frameNum,bool checkForNewOrigin,const vec3_t scale)
+{
+#ifdef G2_PERFORMANCE_ANALYSIS
+	G2PerformanceTimer_G2_ConstructGhoulSkeleton.Start();
+#endif
+	int				i, j;
+	int				modelCount;
+	mdxaBone_t		rootMatrix;
+
+	int modelList[256];
+	assert(ghoul2.size()<=255);
+	modelList[255]=548;
+
+	if (checkForNewOrigin)
+	{
+		RootMatrix(ghoul2,frameNum,scale,rootMatrix);
+	}
+	else
+	{
+		rootMatrix = identityMatrix;
+	}
+
+	G2_Sort_Models(ghoul2, modelList, &modelCount);
+	assert(modelList[255]==548);
+
+	for (j=0; j<modelCount; j++)
+	{
+		// get the sorted model to play with
+		i = modelList[j];
+
+		if (ghoul2[i].mValid)
+		{
+			if (j&&ghoul2[i].mModelBoltLink != -1)
+			{
+				int	boltMod = (ghoul2[i].mModelBoltLink >> MODEL_SHIFT) & MODEL_AND;
+				int	boltNum = (ghoul2[i].mModelBoltLink >> BOLT_SHIFT) & BOLT_AND;
+
+				mdxaBone_t bolt;
+				G2_GetBoltMatrixLow(ghoul2[boltMod],boltNum,scale,bolt);
+				G2_TransformGhoulBones(ghoul2[i].mBlist,bolt,ghoul2[i],frameNum,checkForNewOrigin);
+			}
+#ifdef _G2_LISTEN_SERVER_OPT
+			else if (ghoul2[i].entityNum == ENTITYNUM_NONE || ghoul2[i].mSkelFrameNum != frameNum)
+#else
+			else
+#endif
+			{
+				G2_TransformGhoulBones(ghoul2[i].mBlist,rootMatrix,ghoul2[i],frameNum,checkForNewOrigin);
+			}
+		}
+	}
+#ifdef G2_PERFORMANCE_ANALYSIS
+	G2Time_G2_ConstructGhoulSkeleton += G2PerformanceTimer_G2_ConstructGhoulSkeleton.End();
+#endif
+}	
+
+#ifndef DEDICATED
+
+static inline float G2_GetVertBoneWeightNotSlow( const mdxmVertex_t *pVert, const int iWeightNum)
+{
+	float fBoneWeight;
+
+	int iTemp = pVert->BoneWeightings[iWeightNum];
+
+	iTemp|= (pVert->uiNmWeightsAndBoneIndexes >> (iG2_BONEWEIGHT_TOPBITS_SHIFT+(iWeightNum*2)) ) & iG2_BONEWEIGHT_TOPBITS_AND;
+
+	fBoneWeight = fG2_BONEWEIGHT_RECIPROCAL_MULT * iTemp;
+
+	return fBoneWeight;
+}
+
+#ifdef _XBOX
+
+static inline void VertTransform(float *out_vert, const float *mat, const float *in_vert)
+{
+	__asm
+	{
+		push      ESI
+			push      EDI
+			push      EAX
+
+			mov       ESI,    in_vert
+			mov       EDI,    out_vert
+			mov       EAX,    mat
+
+			movaps    XMM4,   [EAX + 0]		// Load matrix columns
+			movaps    XMM5,   [EAX + 16]
+			movaps    XMM6,   [EAX + 32]
+			movaps    XMM7,   [EAX + 48]
+
+			movss     XMM0,   [ESI + 0]		// Compute x * column 0
+			shufps    XMM0,   XMM0, 0x0
+				mulps     XMM0,   XMM4
+
+				movss     XMM1,   [ESI + 4]		// Compute y * column 1
+				shufps    XMM1,   XMM1, 0x0
+					mulps     XMM1,   XMM5
+
+					movss     XMM2,   [ESI + 8]		// Compute z * column 2
+					shufps    XMM2,   XMM2, 0x0
+						mulps     XMM2,   XMM6
+
+						addps     XMM0,   XMM1			// Add dot products
+						addps     XMM0,   XMM2
+						addps     XMM0,   XMM7			// Add translation
+
+						movaps    [EDI],  XMM0			// Store result
+
+						pop       EAX
+						pop       EDI
+						pop       ESI
+	}
+}
+
+static inline void VertTransformSR(float *out_vert, const float *mat, const float *in_vert)
+{
+	__asm
+	{
+		push      ESI
+			push      EDI
+			push      EAX
+
+			mov       ESI,    in_vert
+			mov       EDI,    out_vert
+			mov       EAX,    mat
+
+			movaps    XMM4,   [EAX + 0]		// Load matrix columns
+			movaps    XMM5,   [EAX + 16]
+			movaps    XMM6,   [EAX + 32]
+
+			movss     XMM0,   [ESI + 0]		// Compute x * column 0
+			shufps    XMM0,   XMM0, 0x0
+				mulps     XMM0,   XMM4
+
+				movss     XMM1,   [ESI + 4]		// Compute y * column 1
+				shufps    XMM1,   XMM1, 0x0
+					mulps     XMM1,   XMM5
+
+					movss     XMM2,   [ESI + 8]		// Compute z * column 2
+					shufps    XMM2,   XMM2, 0x0
+						mulps     XMM2,   XMM6
+
+						addps     XMM0,   XMM1			// Add dot products
+						addps     XMM0,   XMM2
+
+						movaps    [EDI],  XMM0			// Store result
+
+						pop       EAX
+						pop       EDI
+						pop       ESI
+	}
+}
+
+static inline void VertTransformWeighted(float *out_vert, const float *mat, const float *in_vert, const float *weight)
+{
+	__asm
+	{
+		push      ESI
+			push      EDI
+			push      EAX
+			push      EDX
+
+			mov       ESI,    in_vert
+			mov       EDI,    out_vert
+			mov       EAX,    mat
+			mov       EDX,    weight
+
+			movaps    XMM4,   [EAX + 0]		// Load matrix columns
+			movaps    XMM5,   [EAX + 16]
+			movaps    XMM6,   [EAX + 32]
+			movaps    XMM7,   [EAX + 48]
+
+			movss     XMM0,   [ESI + 0]		// Compute x * column 0
+			shufps    XMM0,   XMM0, 0x0
+				mulps     XMM0,   XMM4
+
+				movss     XMM1,   [ESI + 4]		// Compute y * column 1
+				shufps    XMM1,   XMM1, 0x0
+					mulps     XMM1,   XMM5
+
+					movss     XMM2,   [ESI + 8]		// Compute z * column 2
+					shufps    XMM2,   XMM2, 0x0
+						mulps     XMM2,   XMM6
+
+						addps     XMM0,   XMM1			// Add dot products
+						addps     XMM0,   XMM2
+						addps     XMM0,   XMM7			// Add translation
+
+						movss     XMM4,   [EDX]			// Weight the resulting vector
+						shufps    XMM4,   XMM4, 0x0
+							mulps     XMM0,   XMM4
+
+							movaps    XMM5,   [EDI]			// Add the weighted vector to the current
+							addps     XMM0,   XMM5
+
+								movaps    [EDI],  XMM0			// Store result
+
+								pop       EDX
+								pop       EAX
+								pop       EDI
+								pop       ESI
+	}
+}
+
+static inline void VertTransformSRWeighted(float *out_vert, const float *mat, const float *in_vert, const float *weight)
+{
+	__asm
+	{
+		push      ESI
+			push      EDI
+			push      EAX
+			push      EDX
+
+			mov       ESI,    in_vert
+			mov       EDI,    out_vert
+			mov       EAX,    mat
+			mov       EDX,    weight
+
+			movaps    XMM4,   [EAX + 0]		// Load matrix columns
+			movaps    XMM5,   [EAX + 16]
+			movaps    XMM6,   [EAX + 32]
+
+			movss     XMM0,   [ESI + 0]		// Compute x * column 0
+			shufps    XMM0,   XMM0, 0x0
+				mulps     XMM0,   XMM4
+
+				movss     XMM1,   [ESI + 4]		// Compute y * column 1
+				shufps    XMM1,   XMM1, 0x0
+					mulps     XMM1,   XMM5
+
+					movss     XMM2,   [ESI + 8]		// Compute z * column 2
+					shufps    XMM2,   XMM2, 0x0
+						mulps     XMM2,   XMM6
+
+						addps     XMM0,   XMM1			// Add dot products
+						addps     XMM0,   XMM2
+
+						movss     XMM7,   [EDX]			// Weight the resulting vector
+						shufps    XMM7,   XMM7, 0x0
+							mulps     XMM0,   XMM7
+
+							movaps    XMM4,   [EDI]			// Add the weighted vector to the current
+							addps     XMM0,   XMM4
+
+								movaps    [EDI],  XMM0			// Store result
+
+								pop       EDX
+								pop       EAX
+								pop       EDI
+								pop       ESI
+	}
+}
+
+static void TransformRenderSurface(const mdxmSurface_t *surf, CBoneCache *bones, shaderCommands_t *out)
+{
+	const int *boneRefs = (int*) ((byte*)surf + surf->ofsBoneReferences);
+	int numVerts = surf->numVerts;
+	const mdxmVertex_t *vert = (mdxmVertex_t *) ((byte *)surf + surf->ofsVerts);
+	const mdxmVertexTexCoord_t *texCoord = (mdxmVertexTexCoord_t *) &vert[numVerts];
+
+	int	boneIndex = -1;
+	const float *bone = NULL;
+
+	int baseVert = out->numVertexes;
+
+	while(numVerts--)
+	{
+		__declspec (align(16)) vec4_t vec;
+		__declspec (align(16)) vec4_t nrm;
+
+#ifdef _XBOX
+		__declspec (align(16)) vec4_t tan;
+
+		Q_CastShort2FloatScale(&vec[0], &vert->vertCoords[0], 1.f / GLM_COMP_SIZE);
+		Q_CastShort2FloatScale(&vec[1], &vert->vertCoords[1], 1.f / GLM_COMP_SIZE);
+		Q_CastShort2FloatScale(&vec[2], &vert->vertCoords[2], 1.f / GLM_COMP_SIZE);
+
+		if(tess.shader->needsNormal || tess.dlightBits)
+		{
+            nrm[0] = (((vert->normal & 0x00FF0000) >> 16) - 128.f) / 127.0f;
+			nrm[1] = (((vert->normal & 0x0000FF00) >> 8) - 128.f) / 127.0f;
+			nrm[2] = (((vert->normal & 0x000000FF) >> 0) - 128.f) / 127.0f;
+		}
+
+		if(tess.shader->needsTangent || tess.dlightBits)
+		{
+            tan[0] = (((vert->tangent & 0x00FF0000) >> 16) - 128.f) / 127.0f;
+			tan[1] = (((vert->tangent & 0x0000FF00) >> 8) - 128.f) / 127.0f;
+			tan[2] = (((vert->tangent & 0x000000FF) >> 0) - 128.f) / 127.0f;
+
+			out->setTangents = true;
+		}
+#else
+		VectorCopy(vert->vertCoords, vec);
+		VectorCopy(vert->normal, nrm);
+#endif
+
+		const int numWeights = G2_GetVertWeights( vert );
+
+		if (numWeights == 1)
+		{
+			// Slightly faster single weight path
+			int index = G2_GetVertBoneIndex( vert, 0 );
+
+			if ( index != boneIndex )
+			{
+				CTransformBone *tbone = bones->EvalFull(boneRefs[index]);
+				bone = tbone->renderMatrix;
+				boneIndex = index;
+			}
+
+			VertTransform(out->xyz[baseVert], bone, vec);
+#ifdef _XBOX	
+			if(tess.shader->needsNormal || tess.dlightBits)
+				VertTransformSR(out->normal[baseVert], bone, nrm);
+
+			if(tess.shader->needsTangent || tess.dlightBits)
+				VertTransformSR(out->tangent[baseVert], bone, tan);
+#else
+			VertTransformSR(out->normal[baseVert], bone, nrm);
+#endif
+		}
+		else
+		{
+			// Multi-weight blending path
+			VectorClear( out->xyz[baseVert] );
+
+			// Special case for first weight, as it's the only one we use for the normals
+			boneIndex = G2_GetVertBoneIndex( vert, 0 );
+			CTransformBone *tbone = bones->EvalFull(boneRefs[boneIndex]);
+			bone = tbone->renderMatrix;
+
+			__declspec (align(16)) float weight = G2_GetVertBoneWeightNotSlow( vert, 0 );
+
+			VertTransformWeighted(out->xyz[baseVert], bone, vec, &weight);
+#ifdef _XBOX
+			if(tess.shader->needsNormal || tess.dlightBits)
+				VertTransformSR(out->normal[baseVert], bone, nrm);
+
+			if(tess.shader->needsTangent || tess.dlightBits)
+				VertTransformSR(out->tangent[baseVert], bone, tan);
+#else
+			VertTransformSR(out->normal[baseVert], bone, nrm);
+#endif
+
+			for (int k = 1; k < numWeights; ++k)
+			{
+				boneIndex = G2_GetVertBoneIndex( vert, k );
+
+				tbone = bones->EvalFull(boneRefs[boneIndex]);
+				bone = tbone->renderMatrix;
+
+				weight = G2_GetVertBoneWeightNotSlow( vert, k );
+
+				VertTransformWeighted(out->xyz[baseVert], bone, vec, &weight);
+			}
+		}
+
+#ifdef _XBOX
+		Q_CastShort2FloatScale(&out->texCoords[baseVert][0][0], &texCoord->texCoords[0], 1.f / GLM_COMP_SIZE);
+		Q_CastShort2FloatScale(&out->texCoords[baseVert][0][1], &texCoord->texCoords[1], 1.f / GLM_COMP_SIZE);
+#else
+		out->texCoords[baseVert][0][0] = texCoord->texCoords[0];
+		out->texCoords[baseVert][0][1] = texCoord->texCoords[1];
+#endif
+
+		++vert;
+		++texCoord;
+		++baseVert;
+	}
+
+	// VVFIXME - BTO - commented this out, as it's still being done in SurfaceGhoul now.
+	// Really, I ought to move the Gore surfacing in here.
+	//	out->numVertexes += surf->numVerts;
+}
+
+static void TransformCollideSurface(const mdxmSurface_t *surf, CBoneCache *bones, vec3_t scale, float *out)
+{
+	const int *boneRefs = (int*) ((byte*)surf + surf->ofsBoneReferences);
+	int numVerts = surf->numVerts;
+	const mdxmVertex_t *vert = (mdxmVertex_t *) ((byte *)surf + surf->ofsVerts);
+	const mdxmVertexTexCoord_t *texCoord = (mdxmVertexTexCoord_t *) &vert[numVerts];
+
+	int	boneIndex = -1;
+	const float *bone = NULL;
+
+#ifdef _XBOX
+	vec3_t scl;
+	scl[0] = scale[0] * 1.f / GLM_COMP_SIZE;
+	scl[1] = scale[1] * 1.f / GLM_COMP_SIZE;
+	scl[2] = scale[2] * 1.f / GLM_COMP_SIZE;
+#endif
+
+	while(numVerts--)
+	{
+		__declspec (align(16)) vec4_t vec;
+
+#ifdef _XBOX
+		Q_CastShort2FloatScale(&vec[0], &vert->vertCoords[0], scl[0]);
+		Q_CastShort2FloatScale(&vec[1], &vert->vertCoords[1], scl[1]);
+		Q_CastShort2FloatScale(&vec[2], &vert->vertCoords[2], scl[2]);
+#else
+		VectorCopy(vert->vertCoords, vec);
+#endif
+
+		const int numWeights = G2_GetVertWeights( vert );
+
+		if (numWeights == 1)
+		{
+			// Slightly faster single weight path
+			int index = G2_GetVertBoneIndex( vert, 0 );
+
+			if ( index != boneIndex )
+			{
+				CTransformBone *tbone = bones->EvalFull(boneRefs[index]);
+				bone = tbone->renderMatrix;
+				boneIndex = index;
+			}
+
+			__declspec (align(16)) vec4_t temp;
+
+			VertTransform(temp, bone, vec);
+
+			out[0] = temp[0];
+			out[1] = temp[1];
+			out[2] = temp[2];
+		}
+		else
+		{
+			// Multi-weight blending path
+			float totalWeight = 0.0f;
+
+			__declspec (align(16)) vec4_t temp;
+			temp[0] = 0;
+			temp[1] = 0;
+			temp[2] = 0;
+
+			for (int k = 0; k < numWeights; ++k) 
+			{
+				boneIndex = G2_GetVertBoneIndex( vert, k );
+
+				CTransformBone *tbone = bones->EvalFull(boneRefs[boneIndex]);
+				bone = tbone->renderMatrix;
+
+				__declspec (align(16)) float weight = 
+					G2_GetVertBoneWeight( vert, k, totalWeight, numWeights );
+
+				VertTransformWeighted(temp, bone, vec, &weight);
+			}
+
+			out[0] = temp[0];
+			out[1] = temp[1];
+			out[2] = temp[2];
+		}
+
+#ifdef _XBOX
+		Q_CastShort2FloatScale(out + 3, &texCoord->texCoords[0], 1.f / GLM_COMP_SIZE);
+		Q_CastShort2FloatScale(out + 4, &texCoord->texCoords[1], 1.f / GLM_COMP_SIZE);
+#else
+		out[3] = texCoord->texCoords[0];
+		out[4] = texCoord->texCoords[1];
+#endif
+
+		++vert;
+		++texCoord;
+		out += 5;
+	}
+}
+
+void R_TransformEachSurface( const mdxmSurface_t *surface, vec3_t scale, CMiniHeap *G2VertSpace, int *TransformedVertsArray,CBoneCache *boneCache) 
+{
+	float			*TransformedVerts;
+
+	// alloc some space for the transformed verts to get put in
+	TransformedVerts = (float *)G2VertSpace->MiniHeapAlloc(surface->numVerts * 5 * 4);
+	TransformedVertsArray[surface->thisSurfaceIndex] = (int)TransformedVerts;
+	if (!TransformedVerts)
+	{
+		assert(0);
+		Com_Error(ERR_DROP, "Ran out of transform space for Ghoul2 Models. Adjust MiniHeapSize in SV_SpawnServer.\n");
+	}
+
+	TransformCollideSurface(surface, boneCache, scale, TransformedVerts);
+}
+
+#endif
+
+
+//This is a slightly mangled version of the same function from the sof2sp base.
+//It provides a pretty significant performance increase over the existing one.
+void RB_SurfaceGhoul( CRenderableSurface *surf ) 
+{
+#ifdef G2_PERFORMANCE_ANALYSIS
+	G2PerformanceTimer_RB_SurfaceGhoul.Start();
+#endif
+
+	static int				j, k;
+	static int				baseIndex, baseVertex;
+	static int				numVerts;
+	static mdxmVertex_t 	*v;
+	static int				*triangles;
+	static int				indexes;
+	static glIndex_t		*tessIndexes;
+	static mdxmVertexTexCoord_t *pTexCoords;
+	static int				*piBoneReferences;
+
+#ifdef _G2_GORE
+	if (surf->alternateTex)
+	{
+		// a gore surface ready to go.
+
+		/*
+			sizeof(int)+ // num verts
+			sizeof(int)+ // num tris
+			sizeof(int)*newNumVerts+ // which verts to copy from original surface
+			sizeof(float)*4*newNumVerts+ // storgage for deformed verts
+			sizeof(float)*4*newNumVerts+ // storgage for deformed normal
+			sizeof(float)*2*newNumVerts+ // texture coordinates
+			sizeof(int)*newNumTris*3;  // new indecies
+		*/
+
+		int *data=(int *)surf->alternateTex;
+		numVerts=*data++;
+		indexes=(*data++);
+		// first up, sanity check our numbers
+		RB_CheckOverflow(numVerts,indexes);
+		indexes*=3;
+
+		data+=numVerts;
+
+		baseIndex = tess.numIndexes;
+		baseVertex = tess.numVertexes;
+
+		memcpy(&tess.xyz[baseVertex][0],data,sizeof(float)*4*numVerts);
+		data+=4*numVerts;
+		memcpy(&tess.normal[baseVertex][0],data,sizeof(float)*4*numVerts);
+		data+=4*numVerts;
+		assert(numVerts>0);
+
+		//float *texCoords = tess.texCoords[0][baseVertex];
+		float *texCoords = tess.texCoords[baseVertex][0];
+		int hack = baseVertex;
+		//rww - since the array is arranged as such we cannot increment
+		//the relative memory position to get where we want. Maybe this
+		//is why sof2 has the texCoords array reversed. In any case, I
+		//am currently too lazy to get around it.
+		//Or can you += array[.][x]+2?
+		if (surf->scale>1.0f)
+		{
+			for ( j = 0; j < numVerts; j++) 
+			{
+				texCoords[0]=((*(float *)data)-0.5f)*surf->scale+0.5f;
+				data++;
+				texCoords[1]=((*(float *)data)-0.5f)*surf->scale+0.5f;
+				data++;
+				//texCoords+=2;// Size of gore (s,t).
+				hack++;
+				texCoords = tess.texCoords[hack][0];
+			}
+		}
+		else
+		{
+			for (j=0;j<numVerts;j++)
+			{
+				texCoords[0]=*(float *)(data++);
+				texCoords[1]=*(float *)(data++);
+//				texCoords+=2;// Size of gore (s,t).
+				hack++;
+				texCoords = tess.texCoords[hack][0];
+			}
+		}
+
+		//now check for fade overrides -rww
+		if (surf->fade)
+		{
+			static int lFade;
+			static int j;
+
+			if (surf->fade<1.0)
+			{
+				tess.fading = true;
+				lFade = myftol(254.4f*surf->fade);
+
+				for (j=0;j<numVerts;j++)
+				{
+#ifdef _XBOX
+					DWORD rgb = tess.svars.colors[j+baseVertex] & 0x00ffffff;
+					tess.svars.colors[j+baseVertex] = rgb | ((lFade & 0xff) << 24);
+#else
+					tess.svars.colors[j+baseVertex][3] = lFade;
+#endif
+				}
+			}
+			else if (surf->fade > 2.0f && surf->fade < 3.0f)
+			{ //hack to fade out on RGB if desired (don't want to add more to CRenderableSurface) -rww
+				tess.fading = true;
+				lFade = myftol(254.4f*(surf->fade-2.0f));
+
+				for (j=0;j<numVerts;j++)
+				{
+#ifdef _XBOX
+					if (lFade < ((tess.svars.colors[j+baseVertex] & 0x00ff0000) >> 16))
+					{
+						DWORD a = (tess.svars.colors[j+baseVertex] & 0xff000000) >> 24;
+						tess.svars.colors[j+baseVertex] = D3DCOLOR_RGBA(lFade, lFade, lFade, lFade);
+					}
+					else
+					{
+						DWORD rgb = tess.svars.colors[j+baseVertex] & 0x00ffffff;
+						tess.svars.colors[j+baseVertex] = rgb | ((lFade & 0xff) << 24);
+					}
+#else
+					if (lFade < tess.svars.colors[j+baseVertex][0])
+					{ //don't set it unless the fade is less than the current r value (to avoid brightening suddenly before we start fading)
+						tess.svars.colors[j+baseVertex][0] = tess.svars.colors[j+baseVertex][1] = tess.svars.colors[j+baseVertex][2] = lFade;
+					}
+
+					//Set the alpha as well I suppose, no matter what
+					tess.svars.colors[j+baseVertex][3] = lFade;
+#endif
+				}
+			}
+		}
+		
+		glIndex_t *indexPtr = &tess.indexes[baseIndex];
+		triangles = data;
+		for (j = indexes ; j ; j--) 
+		{
+			*indexPtr++ = baseVertex + (*triangles++);
+		}
+		tess.numIndexes += indexes;
+		tess.numVertexes += numVerts; 
+		return;
+	}
+#endif
+
+	// grab the pointer to the surface info within the loaded mesh file
+	mdxmSurface_t	*surface = surf->surfaceData;
+
+	CBoneCache *bones = surf->boneCache;
+
+#ifndef _G2_GORE //we use this later, for gore
+	delete surf;
+#endif
+
+#ifdef VV_LIGHTING
+	// Set any dynamic lighting needed
+	if(backEnd.currentEntity->dlightBits)
+		tess.dlightBits = backEnd.currentEntity->dlightBits;
+#endif
+
+	// first up, sanity check our numbers
+	RB_CheckOverflow( surface->numVerts, surface->numTriangles );
+
+	//
+	// deform the vertexes by the lerped bones
+	//
+   
+	// first up, sanity check our numbers
+	baseVertex = tess.numVertexes;
+	triangles = (int *) ((byte *)surface + surface->ofsTriangles);
+	baseIndex = tess.numIndexes;
+#if 0
+	indexes = surface->numTriangles * 3;
+	for (j = 0 ; j < indexes ; j++) {
+		tess.indexes[baseIndex + j] = baseVertex + triangles[j];
+	}
+	tess.numIndexes += indexes;
+#else
+	indexes = surface->numTriangles; //*3;	//unrolled 3 times, don't multiply
+	tessIndexes = &tess.indexes[baseIndex];
+	for (j = 0 ; j < indexes ; j++) {
+		*tessIndexes++ = baseVertex + *triangles++;
+		*tessIndexes++ = baseVertex + *triangles++;
+		*tessIndexes++ = baseVertex + *triangles++;
+	}
+	tess.numIndexes += indexes*3;
+#endif
+
+	numVerts = surface->numVerts;
+
+#ifdef _XBOX
+	TransformRenderSurface(surface, surf->boneCache, &tess);
+#else
+	piBoneReferences = (int*) ((byte*)surface + surface->ofsBoneReferences);
+	baseVertex = tess.numVertexes;
+	v = (mdxmVertex_t *) ((byte *)surface + surface->ofsVerts);
+	pTexCoords = (mdxmVertexTexCoord_t *) &v[numVerts];
+
+//	if (r_ghoul2fastnormals&&r_ghoul2fastnormals->integer==0)
+#if 0
+	if (0)
+	{
+		for ( j = 0; j < numVerts; j++, baseVertex++,v++ ) 
+		{
+			const int iNumWeights = G2_GetVertWeights( v );
+
+			float fTotalWeight = 0.0f;
+
+			k=0;
+			int		iBoneIndex = G2_GetVertBoneIndex( v, k );
+			float	fBoneWeight = G2_GetVertBoneWeight( v, k, fTotalWeight, iNumWeights );
+			const mdxaBone_t *bone = &bones->EvalRender(piBoneReferences[iBoneIndex]);
+
+			tess.xyz[baseVertex][0] = fBoneWeight * ( DotProduct( bone->matrix[0], v->vertCoords ) + bone->matrix[0][3] );
+			tess.xyz[baseVertex][1] = fBoneWeight * ( DotProduct( bone->matrix[1], v->vertCoords ) + bone->matrix[1][3] );
+			tess.xyz[baseVertex][2] = fBoneWeight * ( DotProduct( bone->matrix[2], v->vertCoords ) + bone->matrix[2][3] );
+
+			tess.normal[baseVertex][0] = fBoneWeight * DotProduct( bone->matrix[0], v->normal );
+			tess.normal[baseVertex][1] = fBoneWeight * DotProduct( bone->matrix[1], v->normal );
+			tess.normal[baseVertex][2] = fBoneWeight * DotProduct( bone->matrix[2], v->normal );
+
+			for ( k++ ; k < iNumWeights ; k++) 
+			{
+				iBoneIndex	= G2_GetVertBoneIndex( v, k );
+				fBoneWeight	= G2_GetVertBoneWeight( v, k, fTotalWeight, iNumWeights );
+
+				bone = &bones->EvalRender(piBoneReferences[iBoneIndex]);
+
+				tess.xyz[baseVertex][0] += fBoneWeight * ( DotProduct( bone->matrix[0], v->vertCoords ) + bone->matrix[0][3] );
+				tess.xyz[baseVertex][1] += fBoneWeight * ( DotProduct( bone->matrix[1], v->vertCoords ) + bone->matrix[1][3] );
+				tess.xyz[baseVertex][2] += fBoneWeight * ( DotProduct( bone->matrix[2], v->vertCoords ) + bone->matrix[2][3] );
+
+				tess.normal[baseVertex][0] += fBoneWeight * DotProduct( bone->matrix[0], v->normal );
+				tess.normal[baseVertex][1] += fBoneWeight * DotProduct( bone->matrix[1], v->normal );
+				tess.normal[baseVertex][2] += fBoneWeight * DotProduct( bone->matrix[2], v->normal );
+			}
+
+			tess.texCoords[baseVertex][0][0] = pTexCoords[j].texCoords[0];
+			tess.texCoords[baseVertex][0][1] = pTexCoords[j].texCoords[1];
+		}
+	}
+	else
+	{
+#endif
+		float fTotalWeight;
+		float fBoneWeight;
+		float t1;
+		float t2;
+		const mdxaBone_t *bone;
+		const mdxaBone_t *bone2;
+		for ( j = 0; j < numVerts; j++, baseVertex++,v++ ) 
+		{
+
+			bone = &bones->EvalRender(piBoneReferences[G2_GetVertBoneIndex( v, 0 )]);
+			int iNumWeights = G2_GetVertWeights( v );
+			tess.normal[baseVertex][0] = DotProduct( bone->matrix[0], v->normal );
+			tess.normal[baseVertex][1] = DotProduct( bone->matrix[1], v->normal );
+			tess.normal[baseVertex][2] = DotProduct( bone->matrix[2], v->normal );
+
+			if (iNumWeights==1)
+			{
+				tess.xyz[baseVertex][0] = ( DotProduct( bone->matrix[0], v->vertCoords ) + bone->matrix[0][3] );
+				tess.xyz[baseVertex][1] = ( DotProduct( bone->matrix[1], v->vertCoords ) + bone->matrix[1][3] );
+				tess.xyz[baseVertex][2] = ( DotProduct( bone->matrix[2], v->vertCoords ) + bone->matrix[2][3] );
+			}
+			else
+			{
+				fBoneWeight = G2_GetVertBoneWeightNotSlow( v, 0);
+				if (iNumWeights==2)
+				{
+					bone2 = &bones->EvalRender(piBoneReferences[G2_GetVertBoneIndex( v, 1 )]);
+					/*
+					useless transposition
+					tess.xyz[baseVertex][0] =
+					v[0]*(w*(bone->matrix[0][0]-bone2->matrix[0][0])+bone2->matrix[0][0])+
+					v[1]*(w*(bone->matrix[0][1]-bone2->matrix[0][1])+bone2->matrix[0][1])+
+					v[2]*(w*(bone->matrix[0][2]-bone2->matrix[0][2])+bone2->matrix[0][2])+
+					w*(bone->matrix[0][3]-bone2->matrix[0][3]) + bone2->matrix[0][3];
+					*/
+					t1 = ( DotProduct( bone->matrix[0], v->vertCoords ) + bone->matrix[0][3] );
+					t2 = ( DotProduct( bone2->matrix[0], v->vertCoords ) + bone2->matrix[0][3] );
+					tess.xyz[baseVertex][0] = fBoneWeight * (t1-t2) + t2;
+					t1 = ( DotProduct( bone->matrix[1], v->vertCoords ) + bone->matrix[1][3] );
+					t2 = ( DotProduct( bone2->matrix[1], v->vertCoords ) + bone2->matrix[1][3] );
+					tess.xyz[baseVertex][1] = fBoneWeight * (t1-t2) + t2;
+					t1 = ( DotProduct( bone->matrix[2], v->vertCoords ) + bone->matrix[2][3] );
+					t2 = ( DotProduct( bone2->matrix[2], v->vertCoords ) + bone2->matrix[2][3] );
+					tess.xyz[baseVertex][2] = fBoneWeight * (t1-t2) + t2;
+				}
+				else
+				{
+
+					tess.xyz[baseVertex][0] = fBoneWeight * ( DotProduct( bone->matrix[0], v->vertCoords ) + bone->matrix[0][3] );
+					tess.xyz[baseVertex][1] = fBoneWeight * ( DotProduct( bone->matrix[1], v->vertCoords ) + bone->matrix[1][3] );
+					tess.xyz[baseVertex][2] = fBoneWeight * ( DotProduct( bone->matrix[2], v->vertCoords ) + bone->matrix[2][3] );
+
+					fTotalWeight=fBoneWeight;
+					for (k=1; k < iNumWeights-1 ; k++) 
+					{
+						bone = &bones->EvalRender(piBoneReferences[G2_GetVertBoneIndex( v, k )]);
+						fBoneWeight = G2_GetVertBoneWeightNotSlow( v, k);
+						fTotalWeight += fBoneWeight;
+
+						tess.xyz[baseVertex][0] += fBoneWeight * ( DotProduct( bone->matrix[0], v->vertCoords ) + bone->matrix[0][3] );
+						tess.xyz[baseVertex][1] += fBoneWeight * ( DotProduct( bone->matrix[1], v->vertCoords ) + bone->matrix[1][3] );
+						tess.xyz[baseVertex][2] += fBoneWeight * ( DotProduct( bone->matrix[2], v->vertCoords ) + bone->matrix[2][3] );
+					}
+					bone = &bones->EvalRender(piBoneReferences[G2_GetVertBoneIndex( v, k )]);
+					fBoneWeight	= 1.0f-fTotalWeight;
+
+					tess.xyz[baseVertex][0] += fBoneWeight * ( DotProduct( bone->matrix[0], v->vertCoords ) + bone->matrix[0][3] );
+					tess.xyz[baseVertex][1] += fBoneWeight * ( DotProduct( bone->matrix[1], v->vertCoords ) + bone->matrix[1][3] );
+					tess.xyz[baseVertex][2] += fBoneWeight * ( DotProduct( bone->matrix[2], v->vertCoords ) + bone->matrix[2][3] );
+				}
+			}
+
+			tess.texCoords[baseVertex][0][0] = pTexCoords[j].texCoords[0];
+			tess.texCoords[baseVertex][0][1] = pTexCoords[j].texCoords[1];
+		}
+#if 0
+	}
+#endif
+#endif // _XBOX
+
+#ifdef _G2_GORE
+	CRenderableSurface *storeSurf = surf;
+
+	while (surf->goreChain)
+	{
+		surf=(CRenderableSurface *)surf->goreChain;
+		if (surf->alternateTex)
+		{
+			// get a gore surface ready to go.
+
+			/*						  
+				sizeof(int)+ // num verts
+				sizeof(int)+ // num tris
+				sizeof(int)*newNumVerts+ // which verts to copy from original surface
+				sizeof(float)*4*newNumVerts+ // storgage for deformed verts
+				sizeof(float)*4*newNumVerts+ // storgage for deformed normal
+				sizeof(float)*2*newNumVerts+ // texture coordinates
+				sizeof(int)*newNumTris*3;  // new indecies
+			*/
+
+			int *data=(int *)surf->alternateTex;
+			int gnumVerts=*data++;
+			data++;
+
+			float *fdata=(float *)data;
+			fdata+=gnumVerts;
+			for (j=0;j<gnumVerts;j++)
+			{
+				assert(data[j]>=0&&data[j]<numVerts);
+				memcpy(fdata,&tess.xyz[tess.numVertexes+data[j]][0],sizeof(float)*3);
+				fdata+=4;
+			}
+			for (j=0;j<gnumVerts;j++)
+			{
+				assert(data[j]>=0&&data[j]<numVerts);
+				memcpy(fdata,&tess.normal[tess.numVertexes+data[j]][0],sizeof(float)*3);
+				fdata+=4;
+			}
+		}
+		else
+		{
+			assert(0); 
+		}
+
+	}
+
+	// NOTE: This is required because a ghoul model might need to be rendered twice a frame (don't cringe,
+	// it's not THAT bad), so we only delete it when doing the glow pass. Warning though, this assumes that
+	// the glow is rendered _second_!!! If that changes, change this!
+	extern bool g_bRenderGlowingObjects;
+	extern bool g_bDynamicGlowSupported;
+#ifdef _XBOX	// GLOWXXX
+	delete storeSurf;
+#else
+	if ( !tess.shader->hasGlow || g_bRenderGlowingObjects || !g_bDynamicGlowSupported || !r_DynamicGlow->integer )
+	{
+		delete storeSurf;
+	}
+#endif
+#endif
+
+	tess.numVertexes += surface->numVerts;
+
+#ifdef G2_PERFORMANCE_ANALYSIS
+	G2Time_RB_SurfaceGhoul += G2PerformanceTimer_RB_SurfaceGhoul.End();
+#endif
+}
+#endif // !DEDICATED
+ 
+/*
+=================
+R_LoadMDXM - load a Ghoul 2 Mesh file
+=================
+*/
+
+/*
+
+Some information used in the creation of the JK2 - JKA bone remap table
+
+These are the old bones:
+Complete list of all 72 bones:
+
+*/
+
+int OldToNewRemapTable[72] = {
+0,// Bone 0:   "model_root":           Parent: ""  (index -1)
+1,// Bone 1:   "pelvis":               Parent: "model_root"  (index 0)
+2,// Bone 2:   "Motion":               Parent: "pelvis"  (index 1)
+3,// Bone 3:   "lfemurYZ":             Parent: "pelvis"  (index 1)
+4,// Bone 4:   "lfemurX":              Parent: "pelvis"  (index 1)
+5,// Bone 5:   "ltibia":               Parent: "pelvis"  (index 1)
+6,// Bone 6:   "ltalus":               Parent: "pelvis"  (index 1)
+6,// Bone 7:   "ltarsal":              Parent: "pelvis"  (index 1)
+7,// Bone 8:   "rfemurYZ":             Parent: "pelvis"  (index 1)
+8,// Bone 9:   "rfemurX":	            Parent: "pelvis"  (index 1)
+9,// Bone10:   "rtibia":	            Parent: "pelvis"  (index 1)
+10,// Bone11:   "rtalus":	            Parent: "pelvis"  (index 1)
+10,// Bone12:   "rtarsal":              Parent: "pelvis"  (index 1)
+11,// Bone13:   "lower_lumbar":         Parent: "pelvis"  (index 1)
+12,// Bone14:   "upper_lumbar":	        Parent: "lower_lumbar"  (index 13)
+13,// Bone15:   "thoracic":	            Parent: "upper_lumbar"  (index 14)
+14,// Bone16:   "cervical":	            Parent: "thoracic"  (index 15)
+15,// Bone17:   "cranium":              Parent: "cervical"  (index 16)
+16,// Bone18:   "ceyebrow":	            Parent: "face_always_"  (index 71)
+17,// Bone19:   "jaw":                  Parent: "face_always_"  (index 71)
+18,// Bone20:   "lblip2":	            Parent: "face_always_"  (index 71)
+19,// Bone21:   "leye":		            Parent: "face_always_"  (index 71)
+20,// Bone22:   "rblip2":	            Parent: "face_always_"  (index 71)
+21,// Bone23:   "ltlip2":               Parent: "face_always_"  (index 71)
+22,// Bone24:   "rtlip2":	            Parent: "face_always_"  (index 71)
+23,// Bone25:   "reye":		            Parent: "face_always_"  (index 71)
+24,// Bone26:   "rclavical":            Parent: "thoracic"  (index 15)
+25,// Bone27:   "rhumerus":             Parent: "thoracic"  (index 15)
+26,// Bone28:   "rhumerusX":            Parent: "thoracic"  (index 15)
+27,// Bone29:   "rradius":              Parent: "thoracic"  (index 15)
+28,// Bone30:   "rradiusX":             Parent: "thoracic"  (index 15)
+29,// Bone31:   "rhand":                Parent: "thoracic"  (index 15)
+29,// Bone32:   "mc7":                  Parent: "thoracic"  (index 15)
+34,// Bone33:   "r_d5_j1":              Parent: "thoracic"  (index 15)
+35,// Bone34:   "r_d5_j2":              Parent: "thoracic"  (index 15)
+35,// Bone35:   "r_d5_j3":              Parent: "thoracic"  (index 15)
+30,// Bone36:   "r_d1_j1":              Parent: "thoracic"  (index 15)
+31,// Bone37:   "r_d1_j2":              Parent: "thoracic"  (index 15)
+31,// Bone38:   "r_d1_j3":              Parent: "thoracic"  (index 15)
+32,// Bone39:   "r_d2_j1":              Parent: "thoracic"  (index 15)
+33,// Bone40:   "r_d2_j2":              Parent: "thoracic"  (index 15)
+33,// Bone41:   "r_d2_j3":              Parent: "thoracic"  (index 15)
+32,// Bone42:   "r_d3_j1":			    Parent: "thoracic"  (index 15)
+33,// Bone43:   "r_d3_j2":		        Parent: "thoracic"  (index 15)
+33,// Bone44:   "r_d3_j3":              Parent: "thoracic"  (index 15)
+34,// Bone45:   "r_d4_j1":              Parent: "thoracic"  (index 15)
+35,// Bone46:   "r_d4_j2":	            Parent: "thoracic"  (index 15)
+35,// Bone47:   "r_d4_j3":		        Parent: "thoracic"  (index 15)
+36,// Bone48:   "rhang_tag_bone":	    Parent: "thoracic"  (index 15)
+37,// Bone49:   "lclavical":            Parent: "thoracic"  (index 15)
+38,// Bone50:   "lhumerus":	            Parent: "thoracic"  (index 15)
+39,// Bone51:   "lhumerusX":	        Parent: "thoracic"  (index 15)
+40,// Bone52:   "lradius":	            Parent: "thoracic"  (index 15)
+41,// Bone53:   "lradiusX":	            Parent: "thoracic"  (index 15)
+42,// Bone54:   "lhand":	            Parent: "thoracic"  (index 15)
+42,// Bone55:   "mc5":		            Parent: "thoracic"  (index 15)
+43,// Bone56:   "l_d5_j1":	            Parent: "thoracic"  (index 15)
+44,// Bone57:   "l_d5_j2":	            Parent: "thoracic"  (index 15)
+44,// Bone58:   "l_d5_j3":	            Parent: "thoracic"  (index 15)
+43,// Bone59:   "l_d4_j1":	            Parent: "thoracic"  (index 15)
+44,// Bone60:   "l_d4_j2":	            Parent: "thoracic"  (index 15)
+44,// Bone61:   "l_d4_j3":	            Parent: "thoracic"  (index 15)
+45,// Bone62:   "l_d3_j1":	            Parent: "thoracic"  (index 15)
+46,// Bone63:   "l_d3_j2":	            Parent: "thoracic"  (index 15)
+46,// Bone64:   "l_d3_j3":	            Parent: "thoracic"  (index 15)
+45,// Bone65:   "l_d2_j1":	            Parent: "thoracic"  (index 15)
+46,// Bone66:   "l_d2_j2":	            Parent: "thoracic"  (index 15)
+46,// Bone67:   "l_d2_j3":	            Parent: "thoracic"  (index 15)
+47,// Bone68:   "l_d1_j1":				Parent: "thoracic"  (index 15)
+48,// Bone69:   "l_d1_j2":	            Parent: "thoracic"  (index 15)
+48,// Bone70:   "l_d1_j3":				Parent: "thoracic"  (index 15)
+52// Bone71:   "face_always_":			Parent: "cranium"  (index 17)
+};
+
+
+/*
+
+Bone   0:   "model_root":
+            Parent: ""  (index -1)
+            #Kids:  1
+            Child 0: (index 1), name "pelvis"
+
+Bone   1:   "pelvis":
+            Parent: "model_root"  (index 0)
+            #Kids:  4
+            Child 0: (index 2), name "Motion"
+            Child 1: (index 3), name "lfemurYZ"
+            Child 2: (index 7), name "rfemurYZ"
+            Child 3: (index 11), name "lower_lumbar"
+
+Bone   2:   "Motion":
+            Parent: "pelvis"  (index 1)
+            #Kids:  0
+
+Bone   3:   "lfemurYZ":
+            Parent: "pelvis"  (index 1)
+            #Kids:  3
+            Child 0: (index 4), name "lfemurX"
+            Child 1: (index 5), name "ltibia"
+            Child 2: (index 49), name "ltail"
+
+Bone   4:   "lfemurX":
+            Parent: "lfemurYZ"  (index 3)
+            #Kids:  0
+
+Bone   5:   "ltibia":
+            Parent: "lfemurYZ"  (index 3)
+            #Kids:  1
+            Child 0: (index 6), name "ltalus"
+
+Bone   6:   "ltalus":
+            Parent: "ltibia"  (index 5)
+            #Kids:  0
+
+Bone   7:   "rfemurYZ":
+            Parent: "pelvis"  (index 1)
+            #Kids:  3
+            Child 0: (index 8), name "rfemurX"
+            Child 1: (index 9), name "rtibia"
+            Child 2: (index 50), name "rtail"
+
+Bone   8:   "rfemurX":
+            Parent: "rfemurYZ"  (index 7)
+            #Kids:  0
+
+Bone   9:   "rtibia":
+            Parent: "rfemurYZ"  (index 7)
+            #Kids:  1
+            Child 0: (index 10), name "rtalus"
+
+Bone  10:   "rtalus":
+            Parent: "rtibia"  (index 9)
+            #Kids:  0
+
+Bone  11:   "lower_lumbar":
+            Parent: "pelvis"  (index 1)
+            #Kids:  1
+            Child 0: (index 12), name "upper_lumbar"
+
+Bone  12:   "upper_lumbar":
+            Parent: "lower_lumbar"  (index 11)
+            #Kids:  1
+            Child 0: (index 13), name "thoracic"
+
+Bone  13:   "thoracic":
+            Parent: "upper_lumbar"  (index 12)
+            #Kids:  5
+            Child 0: (index 14), name "cervical"
+            Child 1: (index 24), name "rclavical"
+            Child 2: (index 25), name "rhumerus"
+            Child 3: (index 37), name "lclavical"
+            Child 4: (index 38), name "lhumerus"
+
+Bone  14:   "cervical":
+            Parent: "thoracic"  (index 13)
+            #Kids:  1
+            Child 0: (index 15), name "cranium"
+
+Bone  15:   "cranium":
+            Parent: "cervical"  (index 14)
+            #Kids:  1
+            Child 0: (index 52), name "face_always_"
+
+Bone  16:   "ceyebrow":
+            Parent: "face_always_"  (index 52)
+            #Kids:  0
+
+Bone  17:   "jaw":
+            Parent: "face_always_"  (index 52)
+            #Kids:  0
+
+Bone  18:   "lblip2":
+            Parent: "face_always_"  (index 52)
+            #Kids:  0
+
+Bone  19:   "leye":
+            Parent: "face_always_"  (index 52)
+            #Kids:  0
+
+Bone  20:   "rblip2":
+            Parent: "face_always_"  (index 52)
+            #Kids:  0
+
+Bone  21:   "ltlip2":
+            Parent: "face_always_"  (index 52)
+            #Kids:  0
+
+Bone  22:   "rtlip2":
+            Parent: "face_always_"  (index 52)
+            #Kids:  0
+
+Bone  23:   "reye":
+            Parent: "face_always_"  (index 52)
+            #Kids:  0
+
+Bone  24:   "rclavical":
+            Parent: "thoracic"  (index 13)
+            #Kids:  0
+
+Bone  25:   "rhumerus":
+            Parent: "thoracic"  (index 13)
+            #Kids:  2
+            Child 0: (index 26), name "rhumerusX"
+            Child 1: (index 27), name "rradius"
+
+Bone  26:   "rhumerusX":
+            Parent: "rhumerus"  (index 25)
+            #Kids:  0
+
+Bone  27:   "rradius":
+            Parent: "rhumerus"  (index 25)
+            #Kids:  9
+            Child 0: (index 28), name "rradiusX"
+            Child 1: (index 29), name "rhand"
+            Child 2: (index 30), name "r_d1_j1"
+            Child 3: (index 31), name "r_d1_j2"
+            Child 4: (index 32), name "r_d2_j1"
+            Child 5: (index 33), name "r_d2_j2"
+            Child 6: (index 34), name "r_d4_j1"
+            Child 7: (index 35), name "r_d4_j2"
+            Child 8: (index 36), name "rhang_tag_bone"
+
+Bone  28:   "rradiusX":
+            Parent: "rradius"  (index 27)
+            #Kids:  0
+
+Bone  29:   "rhand":
+            Parent: "rradius"  (index 27)
+            #Kids:  0
+
+Bone  30:   "r_d1_j1":
+            Parent: "rradius"  (index 27)
+            #Kids:  0
+
+Bone  31:   "r_d1_j2":
+            Parent: "rradius"  (index 27)
+            #Kids:  0
+
+Bone  32:   "r_d2_j1":
+            Parent: "rradius"  (index 27)
+            #Kids:  0
+
+Bone  33:   "r_d2_j2":
+            Parent: "rradius"  (index 27)
+            #Kids:  0
+
+Bone  34:   "r_d4_j1":
+            Parent: "rradius"  (index 27)
+            #Kids:  0
+
+Bone  35:   "r_d4_j2":
+            Parent: "rradius"  (index 27)
+            #Kids:  0
+
+Bone  36:   "rhang_tag_bone":
+            Parent: "rradius"  (index 27)
+            #Kids:  0
+
+Bone  37:   "lclavical":
+            Parent: "thoracic"  (index 13)
+            #Kids:  0
+
+Bone  38:   "lhumerus":
+            Parent: "thoracic"  (index 13)
+            #Kids:  2
+            Child 0: (index 39), name "lhumerusX"
+            Child 1: (index 40), name "lradius"
+
+Bone  39:   "lhumerusX":
+            Parent: "lhumerus"  (index 38)
+            #Kids:  0
+
+Bone  40:   "lradius":
+            Parent: "lhumerus"  (index 38)
+            #Kids:  9
+            Child 0: (index 41), name "lradiusX"
+            Child 1: (index 42), name "lhand"
+            Child 2: (index 43), name "l_d4_j1"
+            Child 3: (index 44), name "l_d4_j2"
+            Child 4: (index 45), name "l_d2_j1"
+            Child 5: (index 46), name "l_d2_j2"
+            Child 6: (index 47), name "l_d1_j1"
+            Child 7: (index 48), name "l_d1_j2"
+            Child 8: (index 51), name "lhang_tag_bone"
+
+Bone  41:   "lradiusX":
+            Parent: "lradius"  (index 40)
+            #Kids:  0
+
+Bone  42:   "lhand":
+            Parent: "lradius"  (index 40)
+            #Kids:  0
+
+Bone  43:   "l_d4_j1":
+            Parent: "lradius"  (index 40)
+            #Kids:  0
+
+Bone  44:   "l_d4_j2":
+            Parent: "lradius"  (index 40)
+            #Kids:  0
+
+Bone  45:   "l_d2_j1":
+            Parent: "lradius"  (index 40)
+            #Kids:  0
+
+Bone  46:   "l_d2_j2":
+            Parent: "lradius"  (index 40)
+            #Kids:  0
+
+Bone  47:   "l_d1_j1":
+            Parent: "lradius"  (index 40)
+            #Kids:  0
+
+Bone  48:   "l_d1_j2":
+            Parent: "lradius"  (index 40)
+            #Kids:  0
+
+Bone  49:   "ltail":
+            Parent: "lfemurYZ"  (index 3)
+            #Kids:  0
+
+Bone  50:   "rtail":
+            Parent: "rfemurYZ"  (index 7)
+            #Kids:  0
+
+Bone  51:   "lhang_tag_bone":
+            Parent: "lradius"  (index 40)
+            #Kids:  0
+
+Bone  52:   "face_always_":
+            Parent: "cranium"  (index 15)
+            #Kids:  8
+            Child 0: (index 16), name "ceyebrow"
+            Child 1: (index 17), name "jaw"
+            Child 2: (index 18), name "lblip2"
+            Child 3: (index 19), name "leye"
+            Child 4: (index 20), name "rblip2"
+            Child 5: (index 21), name "ltlip2"
+            Child 6: (index 22), name "rtlip2"
+            Child 7: (index 23), name "reye"
+
+
+
+*/
+
+
+qboolean R_LoadMDXM( model_t *mod, void *buffer, const char *mod_name, qboolean &bAlreadyCached ) {
+	int					i,l, j;
+	mdxmHeader_t		*pinmodel, *mdxm;
+	mdxmLOD_t			*lod;
+	mdxmSurface_t		*surf;
+	int					version;
+	int					size;
+	mdxmSurfHierarchy_t	*surfInfo;
+
+#ifndef _M_IX86
+	int					k;
+	int					frameSize;
+	mdxmTag_t			*tag;
+	mdxmTriangle_t		*tri;
+	mdxmVertex_t		*v;
+ 	mdxmFrame_t			*cframe;
+	int					*boneRef;
+#endif
+    
+	pinmodel= (mdxmHeader_t *)buffer;
+	//
+	// read some fields from the binary, but only LittleLong() them when we know this wasn't an already-cached model...
+	//	
+	version = (pinmodel->version);
+	size	= (pinmodel->ofsEnd);
+
+	if (!bAlreadyCached)
+	{
+		version = LittleLong(version);
+		size	= LittleLong(size);
+	}
+
+	if (version != MDXM_VERSION) {
+		Com_Printf (S_COLOR_YELLOW  "R_LoadMDXM: %s has wrong version (%i should be %i)\n",
+				 mod_name, version, MDXM_VERSION);
+		return qfalse;
+	}
+
+	mod->type	   = MOD_MDXM;
+	mod->dataSize += size;	
+	
+	qboolean bAlreadyFound = qfalse;
+	mdxm = mod->mdxm = (mdxmHeader_t*) //Hunk_Alloc( size );
+										RE_RegisterModels_Malloc(size, buffer, mod_name, &bAlreadyFound, TAG_MODEL_GLM);
+
+	assert(bAlreadyCached == bAlreadyFound);
+
+	if (!bAlreadyFound)
+	{
+		// horrible new hackery, if !bAlreadyFound then we've just done a tag-morph, so we need to set the 
+		//	bool reference passed into this function to true, to tell the caller NOT to do an FS_Freefile since
+		//	we've hijacked that memory block...
+		//
+		// Aaaargh. Kill me now...
+		//
+		bAlreadyCached = qtrue;
+		assert( mdxm == buffer );
+//		memcpy( mdxm, buffer, size );	// and don't do this now, since it's the same thing
+
+		LL(mdxm->ident);
+		LL(mdxm->version);
+		LL(mdxm->numLODs);
+		LL(mdxm->ofsLODs);
+		LL(mdxm->numSurfaces);
+		LL(mdxm->ofsSurfHierarchy);
+		LL(mdxm->ofsEnd);
+	}
+		
+	// first up, go load in the animation file we need that has the skeletal animation info for this model
+	mdxm->animIndex = RE_RegisterModel(va ("%s.gla",mdxm->animName));
+
+	if (!mdxm->animIndex) 
+	{
+		Com_Printf (S_COLOR_YELLOW  "R_LoadMDXM: missing animation file %s for mesh %s\n", mdxm->animName, mdxm->name);
+		return qfalse;
+	}
+
+	mod->numLods = mdxm->numLODs -1 ;	//copy this up to the model for ease of use - it wil get inced after this.
+
+	if (bAlreadyFound)
+	{
+		return qtrue;	// All done. Stop, go no further, do not LittleLong(), do not pass Go...
+	}
+
+	bool isAnOldModelFile = false;
+	if (mdxm->numBones == 72 && strstr(mdxm->animName,"_humanoid") )
+	{
+		isAnOldModelFile = true;
+	}
+
+	surfInfo = (mdxmSurfHierarchy_t *)( (byte *)mdxm + mdxm->ofsSurfHierarchy);
+ 	for ( i = 0 ; i < mdxm->numSurfaces ; i++) 
+	{
+		LL(surfInfo->numChildren);
+		LL(surfInfo->parentIndex);
+
+		Q_strlwr(surfInfo->name);	//just in case
+		if ( !strcmp( &surfInfo->name[strlen(surfInfo->name)-4],"_off") )
+		{
+			surfInfo->name[strlen(surfInfo->name)-4]=0;	//remove "_off" from name
+		}
+
+		// do all the children indexs
+		for (j=0; j<surfInfo->numChildren; j++)
+		{
+			LL(surfInfo->childIndexes[j]);
+		}
+#ifdef DEDICATED
+		surfInfo->shaderIndex = 0;
+#else
+		shader_t	*sh;
+		// get the shader name
+		sh = R_FindShader( surfInfo->shader, lightmapsNone, stylesDefault, qtrue );
+		// insert it in the surface list
+		if ( sh->defaultShader ) 
+		{
+			surfInfo->shaderIndex = 0;
+		}
+		else
+		{
+			surfInfo->shaderIndex = sh->index;
+		}
+#endif		
+		RE_RegisterModels_StoreShaderRequest(mod_name, &surfInfo->shader[0], &surfInfo->shaderIndex);		
+
+		// find the next surface
+		surfInfo = (mdxmSurfHierarchy_t *)( (byte *)surfInfo + (int)( &((mdxmSurfHierarchy_t *)0)->childIndexes[ surfInfo->numChildren ] ));
+  	}
+	
+	// swap all the LOD's	(we need to do the middle part of this even for intel, because of shader reg and err-check)
+	lod = (mdxmLOD_t *) ( (byte *)mdxm + mdxm->ofsLODs );
+	for ( l = 0 ; l < mdxm->numLODs ; l++)
+	{
+		int	triCount = 0;
+
+		LL(lod->ofsEnd);
+		// swap all the surfaces
+		surf = (mdxmSurface_t *) ( (byte *)lod + sizeof (mdxmLOD_t) + (mdxm->numSurfaces * sizeof(mdxmLODSurfOffset_t)) );
+		for ( i = 0 ; i < mdxm->numSurfaces ; i++) 
+		{
+			LL(surf->numTriangles);
+			LL(surf->ofsTriangles);
+			LL(surf->numVerts);
+			LL(surf->ofsVerts);
+			LL(surf->ofsEnd);
+			LL(surf->ofsHeader);
+			LL(surf->numBoneReferences);
+			LL(surf->ofsBoneReferences);
+//			LL(surf->maxVertBoneWeights);
+
+			triCount += surf->numTriangles;
+										
+			if ( surf->numVerts > SHADER_MAX_VERTEXES ) {
+				Com_Error (ERR_DROP, "R_LoadMDXM: %s has more than %i verts on a surface (%i)",
+					mod_name, SHADER_MAX_VERTEXES, surf->numVerts );
+			}
+			if ( surf->numTriangles*3 > SHADER_MAX_INDEXES ) {
+				Com_Error (ERR_DROP, "R_LoadMDXM: %s has more than %i triangles on a surface (%i)",
+					mod_name, SHADER_MAX_INDEXES / 3, surf->numTriangles );
+			}
+		
+			// change to surface identifier
+			surf->ident = SF_MDX;
+			// register the shaders
+#ifndef _M_IX86
+//
+// optimisation, we don't bother doing this for standard intel case since our data's already in that format...
+//
+			// FIXME - is this correct? 
+			// do all the bone reference data
+			boneRef = (int *) ( (byte *)surf + surf->ofsBoneReferences );
+			for ( j = 0 ; j < surf->numBoneReferences ; j++ ) 
+			{
+					LL(boneRef[j]);
+			}
+			
+			// swap all the triangles
+			tri = (mdxmTriangle_t *) ( (byte *)surf + surf->ofsTriangles );
+			for ( j = 0 ; j < surf->numTriangles ; j++, tri++ ) 
+			{
+				LL(tri->indexes[0]);
+				LL(tri->indexes[1]);
+				LL(tri->indexes[2]);
+			}
+
+			// swap all the vertexes
+			v = (mdxmVertex_t *) ( (byte *)surf + surf->ofsVerts );
+			for ( j = 0 ; j < surf->numVerts ; j++ ) 
+			{
+				v->normal[0] = LittleFloat( v->normal[0] );
+				v->normal[1] = LittleFloat( v->normal[1] );
+				v->normal[2] = LittleFloat( v->normal[2] );
+
+				v->texCoords[0] = LittleFloat( v->texCoords[0] );
+				v->texCoords[1] = LittleFloat( v->texCoords[1] );
+
+				v->numWeights = LittleLong( v->numWeights );
+  			    v->offset[0] = LittleFloat( v->offset[0] );
+				v->offset[1] = LittleFloat( v->offset[1] );
+				v->offset[2] = LittleFloat( v->offset[2] );
+
+				for ( k = 0 ; k < /*v->numWeights*/surf->maxVertBoneWeights ; k++ ) 
+				{
+					v->weights[k].boneIndex = LittleLong( v->weights[k].boneIndex );
+					v->weights[k].boneWeight = LittleFloat( v->weights[k].boneWeight );
+				}
+				v = (mdxmVertex_t *)&v->weights[/*v->numWeights*/surf->maxVertBoneWeights];
+			}
+#endif
+
+			if (isAnOldModelFile)
+			{
+				int *boneRef = (int *) ( (byte *)surf + surf->ofsBoneReferences );
+				for ( j = 0 ; j < surf->numBoneReferences ; j++ ) 
+				{
+					assert(boneRef[j] >= 0 && boneRef[j] < 72);
+					if (boneRef[j] >= 0 && boneRef[j] < 72)
+					{
+						boneRef[j]=OldToNewRemapTable[boneRef[j]];
+					}
+					else
+					{
+						boneRef[j]=0;
+					}
+				}
+			}
+			// find the next surface
+			surf = (mdxmSurface_t *)( (byte *)surf + surf->ofsEnd );
+		}
+		// find the next LOD
+		lod = (mdxmLOD_t *)( (byte *)lod + lod->ofsEnd );
+	}
+	return qtrue;
+}
+
+//#define CREATE_LIMB_HIERARCHY
+
+#ifdef CREATE_LIMB_HIERARCHY
+
+#define NUM_ROOTPARENTS				4
+#define NUM_OTHERPARENTS			12
+#define NUM_BOTTOMBONES				4
+
+#define CHILD_PADDING				4 //I don't know, I guess this can be changed.
+
+static const char *rootParents[NUM_ROOTPARENTS] =
+{
+	"rfemurYZ",
+	"rhumerus",
+	"lfemurYZ",
+	"lhumerus"
+};
+
+static const char *otherParents[NUM_OTHERPARENTS] =
+{
+	"rhumerusX",
+	"rradius",
+	"rradiusX",
+	"lhumerusX",
+	"lradius",
+	"lradiusX",
+	"rfemurX",
+	"rtibia",
+	"rtalus",
+	"lfemurX",
+	"ltibia",
+	"ltalus"
+};
+
+static const char *bottomBones[NUM_BOTTOMBONES] =
+{
+	"rtarsal",
+	"rhand",
+	"ltarsal",
+	"lhand"
+};
+
+qboolean BoneIsRootParent(char *name)
+{
+	int i = 0;
+
+	while (i < NUM_ROOTPARENTS)
+	{
+		if (!Q_stricmp(name, rootParents[i]))
+		{
+			return qtrue;
+		}
+
+		i++;
+	}
+
+	return qfalse;
+}
+
+qboolean BoneIsOtherParent(char *name)
+{
+	int i = 0;
+
+	while (i < NUM_OTHERPARENTS)
+	{
+		if (!Q_stricmp(name, otherParents[i]))
+		{
+			return qtrue;
+		}
+
+		i++;
+	}
+
+	return qfalse;
+}
+
+qboolean BoneIsBottom(char *name)
+{
+	int i = 0;
+
+	while (i < NUM_BOTTOMBONES)
+	{
+		if (!Q_stricmp(name, bottomBones[i]))
+		{
+			return qtrue;
+		}
+
+		i++;
+	}
+
+	return qfalse;
+}
+
+void ShiftMemoryDown(mdxaSkelOffsets_t *offsets, mdxaHeader_t *mdxa, int boneIndex, byte **endMarker)
+{
+	int i = 0;
+
+	//where the next bone starts
+	byte *nextBone = ((byte *)mdxa + sizeof(mdxaHeader_t) + offsets->offsets[boneIndex+1]);
+	int size = (*endMarker - nextBone);
+
+	memmove((nextBone+CHILD_PADDING), nextBone, size);
+	memset(nextBone, 0, CHILD_PADDING);
+	*endMarker += CHILD_PADDING;
+	//Move the whole thing down CHILD_PADDING amount in memory, clear the new preceding space, and increment the end pointer.
+
+	i = boneIndex+1;
+
+	//Now add CHILD_PADDING amount to every offset beginning at the offset of the bone that was moved.
+	while (i < mdxa->numBones)
+	{
+		offsets->offsets[i] += CHILD_PADDING;
+		i++;
+	}
+
+	mdxa->ofsFrames += CHILD_PADDING;
+	mdxa->ofsCompBonePool += CHILD_PADDING;
+	mdxa->ofsEnd += CHILD_PADDING;
+	//ofsSkel does not need to be updated because we are only moving memory after that point.
+}
+
+//Proper/desired hierarchy list
+static const char *BoneHierarchyList[] =
+{
+	"lfemurYZ",
+	"lfemurX",
+	"ltibia",
+	"ltalus",
+	"ltarsal",
+
+	"rfemurYZ",
+	"rfemurX",
+	"rtibia",
+	"rtalus",
+	"rtarsal",
+
+	"lhumerus",
+	"lhumerusX",
+	"lradius",
+	"lradiusX",
+	"lhand",
+
+	"rhumerus",
+	"rhumerusX",
+	"rradius",
+	"rradiusX",
+	"rhand",
+
+	0
+};
+
+//Gets the index of a child or parent. If child is passed as qfalse then parent is assumed.
+int BoneParentChildIndex(mdxaHeader_t *mdxa, mdxaSkelOffsets_t *offsets, mdxaSkel_t *boneInfo, qboolean child)
+{
+	int i = 0;
+	int matchindex = -1;
+	mdxaSkel_t *bone;
+	const char *match = NULL;
+
+	while (BoneHierarchyList[i])
+	{
+		if (!Q_stricmp(boneInfo->name, BoneHierarchyList[i]))
+		{ //we have a match, the slot above this will be our desired parent. (or below for child)
+			if (child)
+			{
+				match = BoneHierarchyList[i+1];
+			}
+			else
+			{
+				match = BoneHierarchyList[i-1];
+			}
+			break;
+		}
+		i++;
+	}
+
+	if (!match)
+	{ //no good
+		return -1;
+	}
+
+	i = 0;
+
+	while (i < mdxa->numBones)
+	{
+		bone = (mdxaSkel_t *)((byte *)mdxa + sizeof(mdxaHeader_t) + offsets->offsets[i]);
+
+		if (bone && !Q_stricmp(bone->name, match))
+		{ //this is the one
+			matchindex = i;
+			break;
+		}
+
+		i++;
+	}
+
+	return matchindex;
+}
+#endif //CREATE_LIMB_HIERARCHY
+
+/*
+=================
+R_LoadMDXA - load a Ghoul 2 animation file
+=================
+*/
+qboolean R_LoadMDXA( model_t *mod, void *buffer, const char *mod_name, qboolean &bAlreadyCached ) {
+
+	mdxaHeader_t		*pinmodel, *mdxa;
+	int					version;
+	int					size;
+#ifdef CREATE_LIMB_HIERARCHY
+	int					oSize = 0;
+	byte				*sizeMarker;
+#endif
+
+#ifndef _M_IX86
+	int					j, k, i;
+	int					frameSize;
+	mdxaFrame_t			*cframe;
+	mdxaSkel_t			*boneInfo;
+#endif
+
+ 	pinmodel = (mdxaHeader_t *)buffer;
+	//
+	// read some fields from the binary, but only LittleLong() them when we know this wasn't an already-cached model...
+	//	
+	version = (pinmodel->version);
+	size	= (pinmodel->ofsEnd);
+
+	if (!bAlreadyCached)
+	{
+		version = LittleLong(version);
+		size	= LittleLong(size);
+	}
+	
+	if (version != MDXA_VERSION) {
+		Com_Printf (S_COLOR_YELLOW  "R_LoadMDXA: %s has wrong version (%i should be %i)\n",
+				 mod_name, version, MDXA_VERSION);
+		return qfalse;
+	}
+
+	mod->type		= MOD_MDXA;
+	mod->dataSize  += size;
+
+	qboolean bAlreadyFound = qfalse;
+
+#ifdef CREATE_LIMB_HIERARCHY
+	oSize = size;
+
+	int childNumber = (NUM_ROOTPARENTS + NUM_OTHERPARENTS);
+	size += (childNumber*(CHILD_PADDING*8)); //Allocate us some extra space so we can shift memory down.
+#endif //CREATE_LIMB_HIERARCHY
+
+	mdxa = mod->mdxa = (mdxaHeader_t*) //Hunk_Alloc( size );
+										RE_RegisterModels_Malloc(size, 
+										#ifdef CREATE_LIMB_HIERARCHY
+											NULL,	// I think this'll work, can't really test on PC
+										#else
+											buffer, 
+										#endif
+										mod_name, &bAlreadyFound, TAG_MODEL_GLA);
+
+	assert(bAlreadyCached == bAlreadyFound);	// I should probably eliminate 'bAlreadyFound', but wtf?
+
+	if (!bAlreadyFound)
+	{
+#ifdef CREATE_LIMB_HIERARCHY
+		memcpy( mdxa, buffer, oSize );
+#else
+		// horrible new hackery, if !bAlreadyFound then we've just done a tag-morph, so we need to set the 
+		//	bool reference passed into this function to true, to tell the caller NOT to do an FS_Freefile since
+		//	we've hijacked that memory block...
+		//
+		// Aaaargh. Kill me now...
+		//
+		bAlreadyCached = qtrue;
+		assert( mdxa == buffer );
+//		memcpy( mdxa, buffer, size );	// and don't do this now, since it's the same thing
+#endif
+		LL(mdxa->ident);
+		LL(mdxa->version);
+		LL(mdxa->numFrames);
+		LL(mdxa->numBones);
+		LL(mdxa->ofsFrames);
+		LL(mdxa->ofsEnd);
+	}
+
+#ifdef CREATE_LIMB_HIERARCHY
+	if (!bAlreadyFound)
+	{
+		mdxaSkel_t			*boneParent;
+#ifdef _M_IX86
+		mdxaSkel_t			*boneInfo;
+		int i, k;
+#endif
+
+		sizeMarker = (byte *)mdxa + mdxa->ofsEnd;
+
+		//rww - This is probably temporary until we put actual hierarchy in for the models.
+		//It is necessary for the correct operation of ragdoll.
+   		mdxaSkelOffsets_t *offsets = (mdxaSkelOffsets_t *)((byte *)mdxa + sizeof(mdxaHeader_t));
+
+		for ( i = 0 ; i < mdxa->numBones ; i++) 
+		{
+			boneInfo = (mdxaSkel_t *)((byte *)mdxa + sizeof(mdxaHeader_t) + offsets->offsets[i]);
+
+			if (boneInfo)
+			{
+				char *bname = boneInfo->name;
+
+				if (BoneIsRootParent(bname))
+				{ //These are the main parent bones. We don't want to change their parents, but we want to give them children.
+					ShiftMemoryDown(offsets, mdxa, i, &sizeMarker);
+
+					boneInfo = (mdxaSkel_t *)((byte *)mdxa + sizeof(mdxaHeader_t) + offsets->offsets[i]);
+
+					int newChild = BoneParentChildIndex(mdxa, offsets, boneInfo, qtrue);
+
+					if (newChild != -1)
+					{
+						boneInfo->numChildren++;
+						boneInfo->children[boneInfo->numChildren-1] = newChild;
+					}
+					else
+					{
+						assert(!"Failed to find matching child for bone in hierarchy creation");
+					}
+				}
+				else if (BoneIsOtherParent(bname) || BoneIsBottom(bname))
+				{
+					if (!BoneIsBottom(bname))
+					{ //unless it's last in the chain it has the next bone as a child.
+						ShiftMemoryDown(offsets, mdxa, i, &sizeMarker);
+
+						boneInfo = (mdxaSkel_t *)((byte *)mdxa + sizeof(mdxaHeader_t) + offsets->offsets[i]);
+
+						int newChild = BoneParentChildIndex(mdxa, offsets, boneInfo, qtrue);
+
+						if (newChild != -1)
+						{
+							boneInfo->numChildren++;
+							boneInfo->children[boneInfo->numChildren-1] = newChild;
+						}
+						else
+						{
+							assert(!"Failed to find matching child for bone in hierarchy creation");
+						}
+					}
+
+					//Before we set the parent we want to remove this as a child for whoever was parenting it.
+					int oldParent = boneInfo->parent;
+
+					if (oldParent > -1)
+					{
+						boneParent = (mdxaSkel_t *)((byte *)mdxa + sizeof(mdxaHeader_t) + offsets->offsets[oldParent]);
+					}
+					else
+					{
+						boneParent = NULL;
+					}
+
+					if (boneParent)
+					{
+						k = 0;
+
+						while (k < boneParent->numChildren)
+						{
+							if (boneParent->children[k] == i)
+							{ //this bone is the child
+								k++;
+								while (k < boneParent->numChildren)
+								{
+									boneParent->children[k-1] = boneParent->children[k];
+									k++;
+								}
+								boneParent->children[k-1] = 0;
+								boneParent->numChildren--;
+								break;
+							}
+							k++;
+						}
+					}
+
+					//Now that we have cleared the original parent of ownership, mark the bone's new parent.
+					int newParent = BoneParentChildIndex(mdxa, offsets, boneInfo, qfalse);
+
+					if (newParent != -1)
+					{
+						boneInfo->parent = newParent;
+					}
+					else
+					{
+						assert(!"Failed to find matching parent for bone in hierarchy creation");
+					}
+				}
+			}
+		}
+	}
+#endif //CREATE_LIMB_HIERARCHY
+
+ 	if ( mdxa->numFrames < 1 ) {
+		Com_Printf (S_COLOR_YELLOW  "R_LoadMDXA: %s has no frames\n", mod_name );
+		return qfalse;
+	}
+
+	if (bAlreadyFound)
+	{
+		return qtrue;	// All done, stop here, do not LittleLong() etc. Do not pass go...
+	}
+
+#ifndef _M_IX86
+
+	//
+	// optimisation, we don't bother doing this for standard intel case since our data's already in that format...
+	//
+
+	// swap all the skeletal info
+	boneInfo = (mdxaSkel_t *)( (byte *)mdxa + mdxa->ofsSkel);
+	for ( i = 0 ; i < mdxa->numBones ; i++) 
+	{
+		LL(boneInfo->numChildren);
+		LL(boneInfo->parent);
+		for (k=0; k<boneInfo->numChildren; k++)
+		{
+			LL(boneInfo->children[k]);
+		}
+
+		// get next bone
+		boneInfo += (int)( &((mdxaSkel_t *)0)->children[ boneInfo->numChildren ] );
+	}
+
+
+	// swap all the frames
+	frameSize = (int)( &((mdxaFrame_t *)0)->bones[ mdxa->numBones ] );
+	for ( i = 0 ; i < mdxa->numFrames ; i++) 
+	{
+		cframe = (mdxaFrame_t *) ( (byte *)mdxa + mdxa->ofsFrames + i * frameSize );
+   		cframe->radius = LittleFloat( cframe->radius );
+		for ( j = 0 ; j < 3 ; j++ ) 
+		{
+			cframe->bounds[0][j] = LittleFloat( cframe->bounds[0][j] );
+			cframe->bounds[1][j] = LittleFloat( cframe->bounds[1][j] );
+    		cframe->localOrigin[j] = LittleFloat( cframe->localOrigin[j] );
+		}
+		for ( j = 0 ; j < mdxa->numBones * sizeof( mdxaBone_t ) / 2 ; j++ ) 
+		{
+			((short *)cframe->bones)[j] = LittleShort( ((short *)cframe->bones)[j] );
+		}
+	}
+#endif
+	return qtrue;
+}
+
+
+
+
+
+
+
diff --git a/codemp/renderer/tr_image.cpp b/codemp/renderer/tr_image.cpp
new file mode 100644
index 0000000..88be3b3
--- /dev/null
+++ b/codemp/renderer/tr_image.cpp
@@ -0,0 +1,3365 @@
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+// tr_image.c
+#include "tr_local.h"
+#ifndef DEDICATED
+#include "glext.h"
+#endif
+
+#pragma warning (push, 3)	//go back down to 3 for the stl include
+#include <map>
+#pragma warning (pop)
+using namespace std;
+
+
+/*
+ * Include file for users of JPEG library.
+ * You will need to have included system headers that define at least
+ * the typedefs FILE and size_t before you can include jpeglib.h.
+ * (stdio.h is sufficient on ANSI-conforming systems.)
+ * You may also wish to include "jerror.h".
+ */
+
+
+#define JPEG_INTERNALS
+#include "../jpeg-6/jpeglib.h"
+#include "../png/png.h"
+
+#ifndef DEDICATED
+
+static void LoadTGA( const char *name, byte **pic, int *width, int *height );
+static void LoadJPG( const char *name, byte **pic, int *width, int *height );
+
+
+static byte			 s_intensitytable[256];
+static unsigned char s_gammatable[256];
+
+int		gl_filter_min = GL_LINEAR_MIPMAP_NEAREST;
+int		gl_filter_max = GL_LINEAR;
+
+//#define FILE_HASH_SIZE		1024	// actually the shader code still needs this (from another module, great),
+//static	image_t*		hashTable[FILE_HASH_SIZE];
+
+/*
+** R_GammaCorrect
+*/
+void R_GammaCorrect( byte *buffer, int bufSize ) {
+	int i;
+
+	for ( i = 0; i < bufSize; i++ ) {
+		buffer[i] = s_gammatable[buffer[i]];
+	}
+}
+
+typedef struct {
+	char *name;
+	int	minimize, maximize;
+} textureMode_t;
+
+textureMode_t modes[] = {
+	{"GL_NEAREST", GL_NEAREST, GL_NEAREST},
+	{"GL_LINEAR", GL_LINEAR, GL_LINEAR},
+	{"GL_NEAREST_MIPMAP_NEAREST", GL_NEAREST_MIPMAP_NEAREST, GL_NEAREST},
+	{"GL_LINEAR_MIPMAP_NEAREST", GL_LINEAR_MIPMAP_NEAREST, GL_LINEAR},
+	{"GL_NEAREST_MIPMAP_LINEAR", GL_NEAREST_MIPMAP_LINEAR, GL_NEAREST},
+	{"GL_LINEAR_MIPMAP_LINEAR", GL_LINEAR_MIPMAP_LINEAR, GL_LINEAR}
+};
+
+
+// makeup a nice clean, consistant name to query for and file under, for map<> usage...
+//
+static char *GenerateImageMappingName( const char *name )
+{
+	static char sName[MAX_QPATH];
+	int		i=0;
+	char	letter;
+	
+	while (name[i] != '\0' && i<MAX_QPATH-1) 
+	{
+		letter = tolower((unsigned char)name[i]);
+		if (letter =='.') break;				// don't include extension
+		if (letter =='\\') letter = '/';		// damn path names
+		sName[i++] = letter;
+	}
+	sName[i]=0;
+	
+	return &sName[0];
+}
+
+
+
+
+
+/*
+===============
+GL_TextureMode
+===============
+*/
+void GL_TextureMode( const char *string ) {
+	int		i;
+	image_t	*glt;
+
+	for ( i=0 ; i< 6 ; i++ ) {
+		if ( !Q_stricmp( modes[i].name, string ) ) {
+			break;
+		}
+	}
+
+	if ( i == 6 ) {
+		Com_Printf ( "bad filter name\n");
+		for ( i=0 ; i< 6 ; i++ ) {
+			Com_Printf ("%s\n",modes[i].name);
+			}
+		return;
+	}
+
+	gl_filter_min = modes[i].minimize;
+	gl_filter_max = modes[i].maximize;
+
+	// If the level they requested is less than possible, set the max possible...
+	if ( r_ext_texture_filter_anisotropic->value > glConfig.maxTextureFilterAnisotropy )
+	{
+		Cvar_Set( "r_ext_texture_filter_anisotropic", va("%f",glConfig.maxTextureFilterAnisotropy) );
+	}
+	// change all the existing mipmap texture objects
+	   				 R_Images_StartIteration();
+	while ( (glt   = R_Images_GetNextIteration()) != NULL)
+	{
+		if ( glt->mipmap ) {
+			GL_Bind (glt);
+			qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, gl_filter_min);
+			qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, gl_filter_max);
+
+			if(glConfig.maxTextureFilterAnisotropy>0) {
+				if(r_ext_texture_filter_anisotropic->integer>1) {
+					qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, r_ext_texture_filter_anisotropic->value);
+				} else {
+					qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, 1.0f);
+				}
+			}
+		}
+	}
+}
+
+static float R_BytesPerTex (int format)
+{
+	switch ( format ) {
+	case 1:
+		//"I    " 
+		return 1;
+		break;
+	case 2:
+		//"IA   " 
+		return 2;
+		break;
+	case 3:
+		//"RGB  " 
+		return glConfig.colorBits/8.0f;
+		break;
+	case 4:
+		//"RGBA " 
+		return glConfig.colorBits/8.0f;
+		break;
+		
+	case GL_RGBA4:
+		//"RGBA4" 
+		return 2;
+		break;
+	case GL_RGB5:
+		//"RGB5 " 
+		return 2;
+		break;
+		
+	case GL_RGBA8:
+		//"RGBA8" 
+		return 4;
+		break;
+	case GL_RGB8:
+		//"RGB8" 
+		return 4;
+		break;
+		
+	case GL_RGB4_S3TC:
+		//"S3TC " 
+		return 0.33333f;
+		break;
+	case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
+		//"DXT1 " 
+		return 0.33333f;
+		break;
+	case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
+		//"DXT5 " 
+		return 1;
+		break;
+	default:
+		//"???? " 
+		return 4;
+	}
+}
+
+/*
+===============
+R_SumOfUsedImages
+===============
+*/
+float R_SumOfUsedImages( qboolean bUseFormat ) 
+{	
+	int	total = 0;
+	image_t *pImage;
+
+					  R_Images_StartIteration();
+	while ( (pImage = R_Images_GetNextIteration()) != NULL)
+	{
+		if ( pImage->frameUsed == tr.frameCount- 1 ) {//it has already been advanced for the next frame, so...
+			if (bUseFormat)
+			{
+				float  bytePerTex = R_BytesPerTex (pImage->internalFormat);
+				total += bytePerTex * (pImage->width * pImage->height);
+			}
+			else
+			{
+				total += pImage->width * pImage->height;
+			}
+		}
+	}
+
+	return total;
+}
+
+/*
+===============
+R_ImageList_f
+===============
+*/
+void R_ImageList_f( void ) {
+	int		i=0;
+	image_t	*image;
+	int		texels=0;
+	float	texBytes = 0.0f;
+	const char *yesno[] = {"no ", "yes"};
+
+	Com_Printf ( "\n      -w-- -h-- -mm- -if-- wrap --name-------\n");
+
+	int iNumImages = R_Images_StartIteration();
+	while ( (image = R_Images_GetNextIteration()) != NULL)
+	{
+		texels   += image->width*image->height;
+		texBytes += image->width*image->height * R_BytesPerTex (image->internalFormat);
+		Com_Printf (  "%4i: %4i %4i  %s ",
+			i, image->width, image->height, yesno[image->mipmap] );
+		switch ( image->internalFormat ) {
+		case 1:
+			Com_Printf ("I    " );
+			break;
+		case 2:
+			Com_Printf ("IA   " );
+			break;
+		case 3:
+			Com_Printf ("RGB  " );
+			break;
+		case 4:
+			Com_Printf ("RGBA " );
+			break;
+		case GL_RGBA8:
+			Com_Printf ("RGBA8" );
+			break;
+		case GL_RGB8:
+			Com_Printf ("RGB8" );
+			break;
+		case GL_RGB4_S3TC:
+			Com_Printf ("S3TC " );
+			break;
+		case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
+			Com_Printf ("DXT1 " );
+			break;
+		case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
+			Com_Printf ("DXT5 " );
+			break;
+		case GL_RGBA4:
+			Com_Printf ("RGBA4" );
+			break;
+		case GL_RGB5:
+			Com_Printf ("RGB5 " );
+			break;
+		default:
+			Com_Printf ("???? " );
+		}
+
+		switch ( image->wrapClampMode ) {
+		case GL_REPEAT:
+			Com_Printf ("rept " );
+			break;
+		case GL_CLAMP:
+			Com_Printf ("clmp " );
+			break;
+		case GL_CLAMP_TO_EDGE:
+			Com_Printf ("clpE " );
+			break;
+		default:
+			Com_Printf ("%4i ", image->wrapClampMode );
+			break;
+		}
+		
+		Com_Printf ("%s\n", image->imgName );
+		i++;
+	}
+	Com_Printf ( " ---------\n");
+	Com_Printf ( "      -w-- -h-- -mm- -if- wrap --name-------\n");
+	Com_Printf ( " %i total texels (not including mipmaps)\n", texels );
+	Com_Printf ( " %.2fMB total texture mem (not including mipmaps)\n", texBytes/1048576.0f );
+	Com_Printf ( " %i total images\n\n", iNumImages );
+}
+
+//=======================================================================
+
+
+/*
+================
+R_LightScaleTexture
+
+Scale up the pixel values in a texture to increase the
+lighting range
+================
+*/
+void R_LightScaleTexture (unsigned *in, int inwidth, int inheight, qboolean only_gamma )
+{
+	if ( only_gamma )
+	{
+		if ( !glConfig.deviceSupportsGamma )
+		{
+			int		i, c;
+			byte	*p;
+
+			p = (byte *)in;
+
+			c = inwidth*inheight;
+			for (i=0 ; i<c ; i++, p+=4)
+			{
+				p[0] = s_gammatable[p[0]];
+				p[1] = s_gammatable[p[1]];
+				p[2] = s_gammatable[p[2]];
+			}
+		}
+	}
+	else
+	{
+		int		i, c;
+		byte	*p;
+
+		p = (byte *)in;
+
+		c = inwidth*inheight;
+
+		if ( glConfig.deviceSupportsGamma )
+		{
+			for (i=0 ; i<c ; i++, p+=4)
+			{
+				p[0] = s_intensitytable[p[0]];
+				p[1] = s_intensitytable[p[1]];
+				p[2] = s_intensitytable[p[2]];
+			}
+		}
+		else
+		{
+			for (i=0 ; i<c ; i++, p+=4)
+			{
+				p[0] = s_gammatable[s_intensitytable[p[0]]];
+				p[1] = s_gammatable[s_intensitytable[p[1]]];
+				p[2] = s_gammatable[s_intensitytable[p[2]]];
+			}
+		}
+	}
+}
+
+
+/*
+================
+R_MipMap2
+
+Operates in place, quartering the size of the texture
+Proper linear filter
+================
+*/
+static void R_MipMap2( unsigned *in, int inWidth, int inHeight ) {
+	int			i, j, k;
+	byte		*outpix;
+	int			inWidthMask, inHeightMask;
+	int			total;
+	int			outWidth, outHeight;
+	unsigned	*temp;
+
+	outWidth = inWidth >> 1;
+	outHeight = inHeight >> 1;
+	temp = (unsigned int *)Hunk_AllocateTempMemory( outWidth * outHeight * 4 );
+
+	inWidthMask = inWidth - 1;
+	inHeightMask = inHeight - 1;
+
+	for ( i = 0 ; i < outHeight ; i++ ) {
+		for ( j = 0 ; j < outWidth ; j++ ) {
+			outpix = (byte *) ( temp + i * outWidth + j );
+			for ( k = 0 ; k < 4 ; k++ ) {
+				total = 
+					1 * ((byte *)&in[ ((i*2-1)&inHeightMask)*inWidth + ((j*2-1)&inWidthMask) ])[k] +
+					2 * ((byte *)&in[ ((i*2-1)&inHeightMask)*inWidth + ((j*2)&inWidthMask) ])[k] +
+					2 * ((byte *)&in[ ((i*2-1)&inHeightMask)*inWidth + ((j*2+1)&inWidthMask) ])[k] +
+					1 * ((byte *)&in[ ((i*2-1)&inHeightMask)*inWidth + ((j*2+2)&inWidthMask) ])[k] +
+
+					2 * ((byte *)&in[ ((i*2)&inHeightMask)*inWidth + ((j*2-1)&inWidthMask) ])[k] +
+					4 * ((byte *)&in[ ((i*2)&inHeightMask)*inWidth + ((j*2)&inWidthMask) ])[k] +
+					4 * ((byte *)&in[ ((i*2)&inHeightMask)*inWidth + ((j*2+1)&inWidthMask) ])[k] +
+					2 * ((byte *)&in[ ((i*2)&inHeightMask)*inWidth + ((j*2+2)&inWidthMask) ])[k] +
+
+					2 * ((byte *)&in[ ((i*2+1)&inHeightMask)*inWidth + ((j*2-1)&inWidthMask) ])[k] +
+					4 * ((byte *)&in[ ((i*2+1)&inHeightMask)*inWidth + ((j*2)&inWidthMask) ])[k] +
+					4 * ((byte *)&in[ ((i*2+1)&inHeightMask)*inWidth + ((j*2+1)&inWidthMask) ])[k] +
+					2 * ((byte *)&in[ ((i*2+1)&inHeightMask)*inWidth + ((j*2+2)&inWidthMask) ])[k] +
+
+					1 * ((byte *)&in[ ((i*2+2)&inHeightMask)*inWidth + ((j*2-1)&inWidthMask) ])[k] +
+					2 * ((byte *)&in[ ((i*2+2)&inHeightMask)*inWidth + ((j*2)&inWidthMask) ])[k] +
+					2 * ((byte *)&in[ ((i*2+2)&inHeightMask)*inWidth + ((j*2+1)&inWidthMask) ])[k] +
+					1 * ((byte *)&in[ ((i*2+2)&inHeightMask)*inWidth + ((j*2+2)&inWidthMask) ])[k];
+				outpix[k] = total / 36;
+			}
+		}
+	}
+
+	Com_Memcpy( in, temp, outWidth * outHeight * 4 );
+	Hunk_FreeTempMemory( temp );
+}
+
+/*
+================
+R_MipMap
+
+Operates in place, quartering the size of the texture
+================
+*/
+static void R_MipMap (byte *in, int width, int height) {
+	int		i, j;
+	byte	*out;
+	int		row;
+
+	if ( !r_simpleMipMaps->integer ) {
+		R_MipMap2( (unsigned *)in, width, height );
+		return;
+	}
+
+	if ( width == 1 && height == 1 ) {
+		return;
+	}
+
+	row = width * 4;
+	out = in;
+	width >>= 1;
+	height >>= 1;
+
+	if ( width == 0 || height == 0 ) {
+		width += height;	// get largest
+		for (i=0 ; i<width ; i++, out+=4, in+=8 ) {
+			out[0] = ( in[0] + in[4] )>>1;
+			out[1] = ( in[1] + in[5] )>>1;
+			out[2] = ( in[2] + in[6] )>>1;
+			out[3] = ( in[3] + in[7] )>>1;
+		}
+		return;
+	}
+
+	for (i=0 ; i<height ; i++, in+=row) {
+		for (j=0 ; j<width ; j++, out+=4, in+=8) {
+			out[0] = (in[0] + in[4] + in[row+0] + in[row+4])>>2;
+			out[1] = (in[1] + in[5] + in[row+1] + in[row+5])>>2;
+			out[2] = (in[2] + in[6] + in[row+2] + in[row+6])>>2;
+			out[3] = (in[3] + in[7] + in[row+3] + in[row+7])>>2;
+		}
+	}
+}
+
+
+/*
+==================
+R_BlendOverTexture
+
+Apply a color blend over a set of pixels
+==================
+*/
+static void R_BlendOverTexture( byte *data, int pixelCount, byte blend[4] ) {
+	int		i;
+	int		inverseAlpha;
+	int		premult[3];
+
+	inverseAlpha = 255 - blend[3];
+	premult[0] = blend[0] * blend[3];
+	premult[1] = blend[1] * blend[3];
+	premult[2] = blend[2] * blend[3];
+
+	for ( i = 0 ; i < pixelCount ; i++, data+=4 ) {
+		data[0] = ( data[0] * inverseAlpha + premult[0] ) >> 9;
+		data[1] = ( data[1] * inverseAlpha + premult[1] ) >> 9;
+		data[2] = ( data[2] * inverseAlpha + premult[2] ) >> 9;
+	}
+}
+
+byte	mipBlendColors[16][4] = {
+	{0,0,0,0},
+	{255,0,0,128},
+	{0,255,0,128},
+	{0,0,255,128},
+	{255,0,0,128},
+	{0,255,0,128},
+	{0,0,255,128},
+	{255,0,0,128},
+	{0,255,0,128},
+	{0,0,255,128},
+	{255,0,0,128},
+	{0,255,0,128},
+	{0,0,255,128},
+	{255,0,0,128},
+	{0,255,0,128},
+	{0,0,255,128},
+};
+
+
+
+
+
+class CStringComparator
+{
+public:
+	bool operator()(const char *s1, const char *s2) const { return(strcmp(s1, s2) < 0); } 
+};
+
+typedef map <LPCSTR, image_t *, CStringComparator>	AllocatedImages_t;
+													AllocatedImages_t AllocatedImages;
+													AllocatedImages_t::iterator itAllocatedImages;
+int giTextureBindNum = 1024;	// will be set to this anyway at runtime, but wtf?
+
+
+// return = number of images in the list, for those interested
+//
+int R_Images_StartIteration(void)
+{
+	itAllocatedImages = AllocatedImages.begin();
+	return AllocatedImages.size();
+}
+
+image_t *R_Images_GetNextIteration(void)
+{
+	if (itAllocatedImages == AllocatedImages.end())
+		return NULL;
+
+	image_t *pImage = (*itAllocatedImages).second;
+	++itAllocatedImages;
+	return pImage;
+}
+
+// clean up anything to do with an image_t struct, but caller will have to clear the internal to an image_t struct ready for either struct free() or overwrite...
+//
+// (avoid using ri.xxxx stuff here in case running on dedicated)
+//
+static void R_Images_DeleteImageContents( image_t *pImage )
+{
+	assert(pImage);	// should never be called with NULL
+	if (pImage)
+	{
+		if (qglDeleteTextures) {	//won't have one if we switched to dedicated.
+			qglDeleteTextures( 1, &pImage->texnum );
+		}
+		Z_Free(pImage);
+	}
+}
+
+
+
+
+
+/*
+===============
+Upload32
+
+===============
+*/
+extern qboolean charSet;
+static void Upload32( unsigned *data, 
+						 GLenum format,
+						 qboolean mipmap, 
+						 qboolean picmip, 
+						 qboolean isLightmap,
+						 qboolean allowTC,
+						 int *pformat, 
+						 USHORT *pUploadWidth, USHORT *pUploadHeight, bool bRectangle = false )
+{
+	GLuint uiTarget = GL_TEXTURE_2D;
+	if ( bRectangle )
+	{
+		uiTarget = GL_TEXTURE_RECTANGLE_EXT;
+	}
+
+	if (format == GL_RGBA)
+	{
+		int			samples;
+		int			i, c;
+		byte		*scan;
+		float		rMax = 0, gMax = 0, bMax = 0;
+		int			width = *pUploadWidth;
+		int			height = *pUploadHeight; 
+
+		//
+		// perform optional picmip operation
+		//
+		if ( picmip ) {
+			for(i = 0; i < r_picmip->integer; i++) {
+				R_MipMap( (byte *)data, width, height );
+				width >>= 1;
+				height >>= 1;
+				if (width < 1) {
+					width = 1;
+				}
+				if (height < 1) {
+					height = 1;
+				}
+			}
+		}
+
+		//
+		// clamp to the current upper OpenGL limit
+		// scale both axis down equally so we don't have to
+		// deal with a half mip resampling
+		//
+		while ( width > glConfig.maxTextureSize	|| height > glConfig.maxTextureSize ) {
+			R_MipMap( (byte *)data, width, height );
+			width >>= 1;
+			height >>= 1;
+		}
+
+		//
+		// scan the texture for each channel's max values
+		// and verify if the alpha channel is being used or not
+		//
+		c = width*height;
+		scan = ((byte *)data);
+		samples = 3;
+		for ( i = 0; i < c; i++ )
+		{
+			if ( scan[i*4+0] > rMax )
+			{
+				rMax = scan[i*4+0];
+			}
+			if ( scan[i*4+1] > gMax )
+			{
+				gMax = scan[i*4+1];
+			}
+			if ( scan[i*4+2] > bMax )
+			{
+				bMax = scan[i*4+2];
+			}
+			if ( scan[i*4 + 3] != 255 ) 
+			{
+				samples = 4;
+				break;
+			}
+		}
+
+		// select proper internal format
+		if ( samples == 3 )
+		{
+			if ( glConfig.textureCompression == TC_S3TC && allowTC )
+			{
+				*pformat = GL_RGB4_S3TC;
+			}
+			else if ( glConfig.textureCompression == TC_S3TC_DXT && allowTC )
+			{	// Compress purely color - no alpha
+				if ( r_texturebits->integer == 16 ) {
+					*pformat = GL_COMPRESSED_RGB_S3TC_DXT1_EXT;	//this format cuts to 16 bit
+				}
+				else {//if we aren't using 16 bit then, use 32 bit compression
+					*pformat = GL_COMPRESSED_RGBA_S3TC_DXT5_EXT;
+				}
+			}
+			else if ( isLightmap && r_texturebitslm->integer > 0 )
+			{
+				// Allow different bit depth when we are a lightmap
+				if ( r_texturebitslm->integer == 16 )
+				{
+					*pformat = GL_RGB5;
+				}
+				else if ( r_texturebitslm->integer == 32 )
+				{
+					*pformat = GL_RGB8;
+				}
+			}
+			else if ( r_texturebits->integer == 16 )
+			{
+				*pformat = GL_RGB5;
+			}
+			else if ( r_texturebits->integer == 32 )
+			{
+				*pformat = GL_RGB8;
+			}
+			else
+			{
+				*pformat = 3;
+			}
+		}
+		else if ( samples == 4 )
+		{
+			if ( glConfig.textureCompression == TC_S3TC_DXT && allowTC)
+			{	// Compress both alpha and color
+				*pformat = GL_COMPRESSED_RGBA_S3TC_DXT5_EXT;
+			}
+			else if ( r_texturebits->integer == 16 )
+			{
+				*pformat = GL_RGBA4;
+			}
+			else if ( r_texturebits->integer == 32 )
+			{
+				*pformat = GL_RGBA8;
+			}
+			else
+			{
+				*pformat = 4;
+			}
+		}
+
+		*pUploadWidth = width;
+		*pUploadHeight = height;
+
+		// copy or resample data as appropriate for first MIP level
+		if (!mipmap)
+		{
+			qglTexImage2D( uiTarget, 0, *pformat, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, data );
+			goto done;
+		}
+
+		R_LightScaleTexture (data, width, height, (qboolean)!mipmap );
+
+		qglTexImage2D( uiTarget, 0, *pformat, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, data );
+
+		if (mipmap)
+		{
+			int		miplevel;
+
+			miplevel = 0;
+			while (width > 1 || height > 1)
+			{
+				R_MipMap( (byte *)data, width, height );
+				width >>= 1;
+				height >>= 1;
+				if (width < 1)
+					width = 1;
+				if (height < 1)
+					height = 1;
+				miplevel++;
+
+				if ( r_colorMipLevels->integer ) 
+				{
+					R_BlendOverTexture( (byte *)data, width * height, mipBlendColors[miplevel] );
+				}
+
+				qglTexImage2D( uiTarget, miplevel, *pformat, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, data );
+			}
+		}
+	}
+	else
+	{
+	}
+
+done:
+
+	if (mipmap)
+	{
+		qglTexParameterf(uiTarget, GL_TEXTURE_MIN_FILTER, gl_filter_min);
+		qglTexParameterf(uiTarget, GL_TEXTURE_MAG_FILTER, gl_filter_max);
+		if(r_ext_texture_filter_anisotropic->integer>1 && glConfig.maxTextureFilterAnisotropy>0)
+		{			
+			qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, r_ext_texture_filter_anisotropic->value );
+		}
+	}
+	else
+	{
+		qglTexParameterf(uiTarget, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
+		qglTexParameterf(uiTarget, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
+	}
+
+	GL_CheckErrors();
+}
+
+#if 0
+//3d tex version -rww
+static void Upload32_3D( unsigned *data, 
+						 int img_depth,
+						 qboolean mipmap, 
+						 qboolean picmip, 
+						 qboolean isLightmap,
+						 qboolean allowTC,
+						 int *pformat, 
+						 USHORT *pUploadWidth, USHORT *pUploadHeight )
+{
+	int			samples;
+	int			i, c;
+	byte		*scan;
+	float		rMax = 0, gMax = 0, bMax = 0;
+	int			width = *pUploadWidth;
+	int			height = *pUploadHeight; 
+	int			depth = img_depth;
+
+	//
+	// perform optional picmip operation
+	//
+	if ( picmip ) {
+		for(i = 0; i < r_picmip->integer; i++) {
+			R_MipMap( (byte *)data, width, height );
+			width >>= 1;
+			height >>= 1;
+			if (width < 1) {
+				width = 1;
+			}
+			if (height < 1) {
+				height = 1;
+			}
+		}
+	}
+
+	//
+	// clamp to the current upper OpenGL limit
+	// scale both axis down equally so we don't have to
+	// deal with a half mip resampling
+	//
+	while ( width > glConfig.maxTextureSize	|| height > glConfig.maxTextureSize ) {
+		R_MipMap( (byte *)data, width, height );
+		width >>= 1;
+		height >>= 1;
+	}
+
+	//
+	// scan the texture for each channel's max values
+	// and verify if the alpha channel is being used or not
+	//
+	c = width*height;
+	scan = ((byte *)data);
+	samples = 3;
+	for ( i = 0; i < c; i++ )
+	{
+		if ( scan[i*4+0] > rMax )
+		{
+			rMax = scan[i*4+0];
+		}
+		if ( scan[i*4+1] > gMax )
+		{
+			gMax = scan[i*4+1];
+		}
+		if ( scan[i*4+2] > bMax )
+		{
+			bMax = scan[i*4+2];
+		}
+		if ( scan[i*4 + 3] != 255 ) 
+		{
+			samples = 4;
+			break;
+		}
+	}
+
+	// select proper internal format
+	if ( samples == 3 )
+	{
+		if ( glConfig.textureCompression == TC_S3TC && allowTC )
+		{
+			*pformat = GL_RGB4_S3TC;
+		}
+		else if ( glConfig.textureCompression == TC_S3TC_DXT && allowTC )
+		{	// Compress purely color - no alpha
+			if ( r_texturebits->integer == 16 ) {
+				*pformat = GL_COMPRESSED_RGB_S3TC_DXT1_EXT;	//this format cuts to 16 bit
+			}
+			else {//if we aren't using 16 bit then, use 32 bit compression
+				*pformat = GL_COMPRESSED_RGBA_S3TC_DXT5_EXT;
+			}
+		}
+		else if ( isLightmap && r_texturebitslm->integer > 0 )
+		{
+			// Allow different bit depth when we are a lightmap
+			if ( r_texturebitslm->integer == 16 )
+			{
+				*pformat = GL_RGB5;
+			}
+			else if ( r_texturebitslm->integer == 32 )
+			{
+				*pformat = GL_RGB8;
+			}
+		}
+		else if ( r_texturebits->integer == 16 )
+		{
+			*pformat = GL_RGB5;
+		}
+		else if ( r_texturebits->integer == 32 )
+		{
+			*pformat = GL_RGB8;
+		}
+		else
+		{
+			*pformat = 3;
+		}
+	}
+	else if ( samples == 4 )
+	{
+		if ( glConfig.textureCompression == TC_S3TC_DXT && allowTC)
+		{	// Compress both alpha and color
+			*pformat = GL_COMPRESSED_RGBA_S3TC_DXT5_EXT;
+		}
+		else if ( r_texturebits->integer == 16 )
+		{
+			*pformat = GL_RGBA4;
+		}
+		else if ( r_texturebits->integer == 32 )
+		{
+			*pformat = GL_RGBA8;
+		}
+		else
+		{
+			*pformat = 4;
+		}
+	}
+
+	*pUploadWidth = width;
+	*pUploadHeight = height;
+
+	// copy or resample data as appropriate for first MIP level
+	if (!mipmap)
+	{
+		qglTexImage3DEXT (GL_TEXTURE_3D, 0, *pformat, width, height, depth, 0, GL_RGBA, GL_UNSIGNED_BYTE, data);
+		goto done;
+	}
+
+	R_LightScaleTexture (data, width, height, (qboolean)!mipmap );
+
+	qglTexImage3DEXT (GL_TEXTURE_3D, 0, *pformat, width, height, depth, 0, GL_RGBA, GL_UNSIGNED_BYTE, data );
+
+	if (mipmap)
+	{
+		int		miplevel;
+
+		miplevel = 0;
+		while (width > 1 || height > 1)
+		{
+			R_MipMap( (byte *)data, width, height );
+			width >>= 1;
+			height >>= 1;
+			if (width < 1)
+				width = 1;
+			if (height < 1)
+				height = 1;
+			miplevel++;
+
+			if ( r_colorMipLevels->integer ) 
+			{
+				R_BlendOverTexture( (byte *)data, width * height, mipBlendColors[miplevel] );
+			}
+
+			qglTexImage2D (GL_TEXTURE_2D, miplevel, *pformat, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, data );
+		}
+	}
+done:
+
+	if (mipmap)
+	{
+		qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, gl_filter_min);
+		qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, gl_filter_max);
+		if(r_ext_texture_filter_anisotropic->integer>1 && glConfig.maxTextureFilterAnisotropy>0) {
+			qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, 2.0f);
+		}
+	}
+	else
+	{
+		qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
+		qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
+	}
+
+	GL_CheckErrors();
+}
+#endif
+
+static void GL_ResetBinds(void)
+{
+	memset( glState.currenttextures, 0, sizeof( glState.currenttextures ) );
+	if ( qglBindTexture ) 
+	{
+		if ( qglActiveTextureARB ) 
+		{
+			GL_SelectTexture( 1 );
+			qglBindTexture( GL_TEXTURE_2D, 0 );
+			GL_SelectTexture( 0 );
+			qglBindTexture( GL_TEXTURE_2D, 0 );
+		} 
+		else 
+		{
+			qglBindTexture( GL_TEXTURE_2D, 0 );
+		}
+	}
+}
+
+
+// special function used in conjunction with "devmapbsp"...
+//
+// (avoid using ri.xxxx stuff here in case running on dedicated)
+//
+void R_Images_DeleteLightMaps(void)
+{
+	qboolean bEraseOccured = qfalse;
+	for (AllocatedImages_t::iterator itImage = AllocatedImages.begin(); itImage != AllocatedImages.end(); bEraseOccured?itImage:++itImage)
+	{			
+		bEraseOccured = qfalse;
+
+		image_t *pImage = (*itImage).second;
+		
+		if (pImage->imgName[0] == '*' && strstr(pImage->imgName,"lightmap"))	// loose check, but should be ok
+		{
+			R_Images_DeleteImageContents(pImage);
+#ifndef __linux__
+			itImage = AllocatedImages.erase(itImage);
+			bEraseOccured = qtrue;
+#else
+			// MS & Dinkimware got the map::erase return wrong (it's null)
+			AllocatedImages_t::iterator itTemp = itImage;
+			itImage++;
+			AllocatedImages.erase(itTemp);
+#endif
+		}
+	}
+
+	GL_ResetBinds();
+}
+
+// special function currently only called by Dissolve code...
+//
+void R_Images_DeleteImage(image_t *pImage)
+{		
+	// Even though we supply the image handle, we need to get the corresponding iterator entry...
+	//
+	AllocatedImages_t::iterator itImage = AllocatedImages.find(pImage->imgName);
+	if (itImage != AllocatedImages.end())
+	{		
+		R_Images_DeleteImageContents(pImage);
+		AllocatedImages.erase(itImage);
+	}
+	else
+	{
+		assert(0);
+	}
+}
+
+// called only at app startup, vid_restart, app-exit
+//
+void R_Images_Clear(void)
+{		
+	image_t *pImage;
+	//	int iNumImages = 
+	   				  R_Images_StartIteration();
+	while ( (pImage = R_Images_GetNextIteration()) != NULL)
+	{
+		R_Images_DeleteImageContents(pImage);
+	}
+
+	AllocatedImages.clear();
+
+	giTextureBindNum = 1024;
+}
+
+
+void RE_RegisterImages_Info_f( void )
+{
+	image_t *pImage	= NULL;
+	int iImage		= 0;
+	int iTexels		= 0;
+
+	int iNumImages	= R_Images_StartIteration();
+	while ( (pImage	= R_Images_GetNextIteration()) != NULL)
+	{
+		Com_Printf ("%d: (%4dx%4dy) \"%s\"",iImage, pImage->width, pImage->height, pImage->imgName);
+		Com_DPrintf (S_COLOR_RED ", levused %d",pImage->iLastLevelUsedOn);
+		Com_Printf ("\n");
+
+		iTexels += pImage->width * pImage->height;
+		iImage++;
+	}
+	Com_Printf ("%d Images. %d (%.2fMB) texels total, (not including mipmaps)\n",iNumImages, iTexels, (float)iTexels / 1024.0f / 1024.0f);
+	Com_DPrintf (S_COLOR_RED "RE_RegisterMedia_GetLevel(): %d",RE_RegisterMedia_GetLevel());
+}
+
+
+// implement this if you need to, do a find for the caller. I don't need it though, so far.
+//
+//void		RE_RegisterImages_LevelLoadBegin(const char *psMapName);
+
+
+// currently, this just goes through all the images and dumps any not referenced on this level...
+//
+qboolean RE_RegisterImages_LevelLoadEnd(void)
+{
+	Com_DPrintf (S_COLOR_RED "RE_RegisterImages_LevelLoadEnd():\n");
+
+//	int iNumImages = AllocatedImages.size();	// more for curiosity, really.
+
+	qboolean bEraseOccured = qfalse;
+	for (AllocatedImages_t::iterator itImage = AllocatedImages.begin(); itImage != AllocatedImages.end(); bEraseOccured?itImage:++itImage)
+	{			
+		bEraseOccured = qfalse;
+
+		image_t *pImage = (*itImage).second;
+
+		// don't un-register system shaders (*fog, *dlight, *white, *default), but DO de-register lightmaps ("*<mapname>/lightmap%d")
+		if (pImage->imgName[0] != '*' || strchr(pImage->imgName,'/'))
+		{
+			// image used on this level?
+			//
+			if ( pImage->iLastLevelUsedOn != RE_RegisterMedia_GetLevel() )
+			{
+				// nope, so dump it...
+				//
+				Com_DPrintf (S_COLOR_RED "Dumping image \"%s\"\n",pImage->imgName);
+
+				R_Images_DeleteImageContents(pImage);
+#ifndef __linux__
+				itImage = AllocatedImages.erase(itImage);
+				bEraseOccured = qtrue;
+#else
+				AllocatedImages_t::iterator itTemp = itImage;
+				itImage++;
+				AllocatedImages.erase(itTemp);	
+#endif
+			}
+		}
+	}
+
+
+	// this check can be deleted AFAIC, it seems to be just a quake thing...
+	//
+//	iNumImages = R_Images_StartIteration();
+//	if (iNumImages > MAX_DRAWIMAGES)
+//	{
+//		Com_Printf (S_COLOR_YELLOW  "Level uses %d images, old limit was MAX_DRAWIMAGES (%d)\n", iNumImages, MAX_DRAWIMAGES);
+//	}
+
+	Com_DPrintf (S_COLOR_RED "RE_RegisterImages_LevelLoadEnd(): Ok\n");	
+
+	GL_ResetBinds();
+
+	return bEraseOccured;
+}
+
+
+
+// returns image_t struct if we already have this, else NULL. No disk-open performed 
+//	(important for creating default images).
+//
+// This is called by both R_FindImageFile and anything that creates default images...
+//
+static image_t *R_FindImageFile_NoLoad(const char *name, qboolean mipmap, qboolean allowPicmip, qboolean allowTC, int glWrapClampMode )
+{	
+	if (!name) {
+		return NULL;
+	}
+
+	char *pName = GenerateImageMappingName(name);
+
+	//
+	// see if the image is already loaded
+	//
+	AllocatedImages_t::iterator itAllocatedImage = AllocatedImages.find(pName);
+	if (itAllocatedImage != AllocatedImages.end())
+	{	
+		image_t *pImage = (*itAllocatedImage).second;
+
+		// the white image can be used with any set of parms, but other mismatches are errors...
+		//
+		if ( strcmp( pName, "*white" ) ) {
+			if ( pImage->mipmap != !!mipmap ) {
+				Com_Printf (S_COLOR_YELLOW  "WARNING: reused image %s with mixed mipmap parm\n", pName );
+			}
+			if ( pImage->allowPicmip != !!allowPicmip ) {
+				Com_Printf (S_COLOR_YELLOW  "WARNING: reused image %s with mixed allowPicmip parm\n", pName );
+			}
+			if ( pImage->wrapClampMode != glWrapClampMode ) {
+				Com_Printf (S_COLOR_YELLOW  "WARNING: reused image %s with mixed glWrapClampMode parm\n", pName );
+			}
+		}
+			  
+		pImage->iLastLevelUsedOn = RE_RegisterMedia_GetLevel();
+
+		return pImage;
+	}
+
+	return NULL;
+}
+
+
+
+/*
+================
+R_CreateImage
+
+This is the only way any image_t are created
+================
+*/
+image_t *R_CreateImage( const char *name, const byte *pic, int width, int height, 
+					   GLenum format, qboolean mipmap, qboolean allowPicmip, qboolean allowTC, int glWrapClampMode, bool bRectangle )
+{
+	image_t		*image;
+	qboolean	isLightmap = qfalse;
+
+	if (strlen(name) >= MAX_QPATH ) {
+		Com_Error (ERR_DROP, "R_CreateImage: \"%s\" is too long\n", name);
+	}
+
+	if(glConfig.clampToEdgeAvailable && glWrapClampMode == GL_CLAMP) {
+		glWrapClampMode = GL_CLAMP_TO_EDGE;
+	}
+
+	if (name[0] == '*')
+	{
+		char *psLightMapNameSearchPos = strrchr(name,'/');
+		if (  psLightMapNameSearchPos && !strncmp( psLightMapNameSearchPos+1, "lightmap", 8 ) ) {
+			isLightmap = qtrue;
+		}
+	}
+
+	if ( (width&(width-1)) || (height&(height-1)) )
+	{
+		Com_Error( ERR_FATAL, "R_CreateImage: %s dimensions (%i x %i) not power of 2!\n",name,width,height);
+	}
+
+	image = R_FindImageFile_NoLoad(name, mipmap, allowPicmip, allowTC, glWrapClampMode );
+	if (image) {
+		return image;
+	}
+
+	image = (image_t*) Z_Malloc( sizeof( image_t ), TAG_IMAGE_T, qtrue );
+//	memset(image,0,sizeof(*image));	// qtrue above does this 
+	
+	image->texnum = 1024 + giTextureBindNum++;	// ++ is of course staggeringly important...
+
+	// record which map it was used on...
+	//
+	image->iLastLevelUsedOn = RE_RegisterMedia_GetLevel();
+
+	image->mipmap = !!mipmap;
+	image->allowPicmip = !!allowPicmip;
+
+	Q_strncpyz(image->imgName, name, sizeof(image->imgName));
+
+	image->width = width;
+	image->height = height;
+	image->wrapClampMode = glWrapClampMode;
+
+	if ( qglActiveTextureARB ) {
+		GL_SelectTexture( 0 );
+	}
+
+	GLuint uiTarget = GL_TEXTURE_2D;
+	if ( bRectangle ) 
+	{
+		qglDisable( uiTarget ); 
+		uiTarget = GL_TEXTURE_RECTANGLE_EXT;
+		qglEnable( uiTarget );
+		glWrapClampMode = GL_CLAMP_TO_EDGE;	// default mode supported by rectangle.
+		qglBindTexture( uiTarget, image->texnum );
+	}
+	else
+	{
+		GL_Bind(image);
+	}
+
+	Upload32( (unsigned *)pic,	format,
+								(qboolean)image->mipmap,
+								allowPicmip,
+								isLightmap,
+								allowTC,
+								&image->internalFormat,
+								&image->width,
+								&image->height, bRectangle );
+
+	qglTexParameterf( uiTarget, GL_TEXTURE_WRAP_S, glWrapClampMode );
+	qglTexParameterf( uiTarget, GL_TEXTURE_WRAP_T, glWrapClampMode );
+
+	qglBindTexture( uiTarget, 0 );	//jfm: i don't know why this is here, but it breaks lightmaps when there's only 1
+	glState.currenttextures[glState.currenttmu] = 0;	//mark it not bound
+
+	LPCSTR psNewName = GenerateImageMappingName(name);
+	Q_strncpyz(image->imgName, psNewName, sizeof(image->imgName));
+	AllocatedImages[ image->imgName ] = image;
+
+	if ( bRectangle )
+	{
+		qglDisable( uiTarget );
+		qglEnable( GL_TEXTURE_2D );
+	}
+
+	return image;
+}
+
+//rwwRMG - added
+void R_CreateAutomapImage( const char *name, const byte *pic, int width, int height, 
+					   qboolean mipmap, qboolean allowPicmip, qboolean allowTC, int glWrapClampMode ) 
+{
+	R_CreateImage(name, pic, width, height, GL_RGBA, mipmap, allowPicmip, allowTC, glWrapClampMode);
+}
+
+/*
+=========================================================
+
+TARGA LOADING
+
+=========================================================
+*/
+/*
+Ghoul2 Insert Start
+*/
+
+bool LoadTGAPalletteImage ( const char *name, byte **pic, int *width, int *height)
+{
+	int		columns, rows, numPixels;
+	byte	*buf_p;
+	byte	*buffer;
+	TargaHeader	targa_header;
+	byte	*dataStart;
+
+	*pic = NULL;
+
+	//
+	// load the file
+	//
+	FS_ReadFile ( ( char * ) name, (void **)&buffer);
+	if (!buffer) {
+		return false;
+	}
+
+	buf_p = buffer;
+
+	targa_header.id_length = *buf_p++;
+	targa_header.colormap_type = *buf_p++;
+	targa_header.image_type = *buf_p++;
+	
+	targa_header.colormap_index = LittleShort ( *(short *)buf_p );
+	buf_p += 2;
+	targa_header.colormap_length = LittleShort ( *(short *)buf_p );
+	buf_p += 2;
+	targa_header.colormap_size = *buf_p++;
+	targa_header.x_origin = LittleShort ( *(short *)buf_p );
+	buf_p += 2;
+	targa_header.y_origin = LittleShort ( *(short *)buf_p );
+	buf_p += 2;
+	targa_header.width = LittleShort ( *(short *)buf_p );
+	buf_p += 2;
+	targa_header.height = LittleShort ( *(short *)buf_p );
+	buf_p += 2;
+	targa_header.pixel_size = *buf_p++;
+	targa_header.attributes = *buf_p++;
+
+	if (targa_header.image_type!=1 )
+	{
+		Com_Error (ERR_DROP, "LoadTGAPalletteImage: Only type 1 (uncompressed pallettised) TGA images supported\n");
+	}
+
+	if ( targa_header.colormap_type == 0 )
+	{
+		Com_Error( ERR_DROP, "LoadTGAPalletteImage: colormaps ONLY supported\n" );
+	}
+
+	columns = targa_header.width;
+	rows = targa_header.height;
+	numPixels = columns * rows;
+
+	if (width)
+		*width = columns;
+	if (height)
+		*height = rows;
+
+	*pic = (unsigned char *) Z_Malloc (numPixels, TAG_TEMP_WORKSPACE, qfalse );
+	if (targa_header.id_length != 0)
+	{
+		buf_p += targa_header.id_length;  // skip TARGA image comment
+	}
+	dataStart = buf_p + (targa_header.colormap_length * (targa_header.colormap_size / 4));
+	memcpy(*pic, dataStart, numPixels);
+	FS_FreeFile (buffer);
+
+	return true;
+}
+
+#endif	// #ifndef DEDICATED
+
+// My TGA loader...
+//
+//---------------------------------------------------
+#pragma pack(push,1)
+typedef struct
+{
+	byte	byIDFieldLength;	// must be 0
+	byte	byColourmapType;	// 0 = truecolour, 1 = paletted, else bad
+	byte	byImageType;		// 1 = colour mapped (palette), uncompressed, 2 = truecolour, uncompressed, else bad
+	word	w1stColourMapEntry;	// must be 0
+	word	wColourMapLength;	// 256 for 8-bit palettes, else 0 for true-colour
+	byte	byColourMapEntrySize; // 24 for 8-bit palettes, else 0 for true-colour
+	word	wImageXOrigin;		// ignored
+	word	wImageYOrigin;		// ignored
+	word	wImageWidth;		// in pixels
+	word	wImageHeight;		// in pixels
+	byte	byImagePlanes;		// bits per pixel	(8 for paletted, else 24 for true-colour)
+	byte	byScanLineOrder;	// Image descriptor bytes
+								// bits 0-3 = # attr bits (alpha chan)
+								// bits 4-5 = pixel order/dir
+								// bits 6-7 scan line interleave (00b=none,01b=2way interleave,10b=4way)
+} TGAHeader_t;
+#pragma pack(pop)
+
+
+// *pic == pic, else NULL for failed.
+//
+//  returns false if found but had a format error, else true for either OK or not-found (there's a reason for this)
+//
+
+void LoadTGA ( const char *name, byte **pic, int *width, int *height)
+{
+	char sErrorString[1024];
+	bool bFormatErrors = false;
+
+	// these don't need to be declared or initialised until later, but the compiler whines that 'goto' skips them.
+	//
+	byte *pRGBA = NULL;	
+	byte *pOut	= NULL;
+	byte *pIn	= NULL;
+
+
+	*pic = NULL;
+
+#define TGA_FORMAT_ERROR(blah) {sprintf(sErrorString,blah); bFormatErrors = true; goto TGADone;}
+//#define TGA_FORMAT_ERROR(blah) Com_Error( ERR_DROP, blah );
+
+	//
+	// load the file
+	//
+	byte *pTempLoadedBuffer = 0;
+	FS_ReadFile ( ( char * ) name, (void **)&pTempLoadedBuffer);
+	if (!pTempLoadedBuffer) {
+		return;
+	}
+
+	TGAHeader_t *pHeader = (TGAHeader_t *) pTempLoadedBuffer;
+
+	if (pHeader->byColourmapType!=0)
+	{	
+		TGA_FORMAT_ERROR("LoadTGA: colourmaps not supported\n" );		
+	}
+
+	if (pHeader->byImageType != 2 && pHeader->byImageType != 3 && pHeader->byImageType != 10)
+	{
+		TGA_FORMAT_ERROR("LoadTGA: Only type 2 (RGB), 3 (gray), and 10 (RLE-RGB) images supported\n");		
+	}
+		
+	if (pHeader->w1stColourMapEntry != 0)
+	{
+		TGA_FORMAT_ERROR("LoadTGA: colourmaps not supported\n" );		
+	}
+
+	if (pHeader->wColourMapLength !=0 && pHeader->wColourMapLength != 256)
+	{
+		TGA_FORMAT_ERROR("LoadTGA: ColourMapLength must be either 0 or 256\n" );
+	}
+
+	if (pHeader->byColourMapEntrySize != 0 && pHeader->byColourMapEntrySize != 24)
+	{
+		TGA_FORMAT_ERROR("LoadTGA: ColourMapEntrySize must be either 0 or 24\n" );
+	}
+
+	if ( ( pHeader->byImagePlanes != 24 && pHeader->byImagePlanes != 32) && (pHeader->byImagePlanes != 8 && pHeader->byImageType != 3))
+	{
+		TGA_FORMAT_ERROR("LoadTGA: Only type 2 (RGB), 3 (gray), and 10 (RGB) TGA images supported\n");
+	}
+
+	if ((pHeader->byScanLineOrder&0x30)!=0x00 &&
+		(pHeader->byScanLineOrder&0x30)!=0x10 &&
+		(pHeader->byScanLineOrder&0x30)!=0x20 &&
+		(pHeader->byScanLineOrder&0x30)!=0x30
+		)
+	{
+		TGA_FORMAT_ERROR("LoadTGA: ScanLineOrder must be either 0x00,0x10,0x20, or 0x30\n");		
+	}
+
+
+
+	// these last checks are so i can use ID's RLE-code. I don't dare fiddle with it or it'll probably break...
+	//
+	if ( pHeader->byImageType == 10)
+	{
+		if ((pHeader->byScanLineOrder & 0x30) != 0x00)
+		{
+			TGA_FORMAT_ERROR("LoadTGA: RLE-RGB Images (type 10) must be in bottom-to-top format\n");
+		}
+		if (pHeader->byImagePlanes != 24 && pHeader->byImagePlanes != 32)	// probably won't happen, but avoids compressed greyscales?
+		{
+			TGA_FORMAT_ERROR("LoadTGA: RLE-RGB Images (type 10) must be 24 or 32 bit\n");
+		}
+	}
+
+	// now read the actual bitmap in...
+	//
+	// Image descriptor bytes
+	// bits 0-3 = # attr bits (alpha chan)
+	// bits 4-5 = pixel order/dir
+	// bits 6-7 scan line interleave (00b=none,01b=2way interleave,10b=4way)
+	//
+	int iYStart,iXStart,iYStep,iXStep;
+
+	switch(pHeader->byScanLineOrder & 0x30)		
+	{
+		default:	// default case stops the compiler complaining about using uninitialised vars
+		case 0x00:					//	left to right, bottom to top
+
+			iXStart = 0;
+			iXStep  = 1;
+
+			iYStart = pHeader->wImageHeight-1;
+			iYStep  = -1;
+
+			break;
+
+		case 0x10:					//  right to left, bottom to top
+
+			iXStart = pHeader->wImageWidth-1;
+			iXStep  = -1;
+
+			iYStart = pHeader->wImageHeight-1;
+			iYStep	= -1;
+
+			break;
+
+		case 0x20:					//  left to right, top to bottom
+
+			iXStart = 0;
+			iXStep  = 1;
+
+			iYStart = 0;
+			iYStep  = 1;
+
+			break;
+
+		case 0x30:					//  right to left, top to bottom
+
+			iXStart = pHeader->wImageWidth-1;
+			iXStep  = -1;
+
+			iYStart = 0;
+			iYStep  = 1;
+
+			break;
+	}
+
+	// feed back the results...
+	//
+	if (width)
+		*width = pHeader->wImageWidth;
+	if (height)
+		*height = pHeader->wImageHeight;
+
+	pRGBA	= (byte *) Z_Malloc (pHeader->wImageWidth * pHeader->wImageHeight * 4, TAG_TEMP_WORKSPACE, qfalse);
+	*pic	= pRGBA;
+	pOut	= pRGBA;
+	pIn		= pTempLoadedBuffer + sizeof(*pHeader);
+
+	// I don't know if this ID-thing here is right, since comments that I've seen are at the end of the file, 
+	//	with a zero in this field. However, may as well...
+	//
+	if (pHeader->byIDFieldLength != 0)
+		pIn += pHeader->byIDFieldLength;	// skip TARGA image comment
+
+	byte red,green,blue,alpha;
+
+	if ( pHeader->byImageType == 2 || pHeader->byImageType == 3 )	// RGB or greyscale
+	{
+		for (int y=iYStart, iYCount=0; iYCount<pHeader->wImageHeight; y+=iYStep, iYCount++)
+		{
+			pOut = pRGBA + y * pHeader->wImageWidth *4;			
+			for (int x=iXStart, iXCount=0; iXCount<pHeader->wImageWidth; x+=iXStep, iXCount++)
+			{
+				switch (pHeader->byImagePlanes)
+				{
+					case 8:
+						blue	= *pIn++;
+						green	= blue;
+						red		= blue;
+						*pOut++ = red;
+						*pOut++ = green;
+						*pOut++ = blue;
+						*pOut++ = 255;
+						break;
+
+					case 24:
+						blue	= *pIn++;
+						green	= *pIn++;
+						red		= *pIn++;
+						*pOut++ = red;
+						*pOut++ = green;
+						*pOut++ = blue;
+						*pOut++ = 255;
+						break;
+
+					case 32:
+						blue	= *pIn++;
+						green	= *pIn++;
+						red		= *pIn++;
+						alpha	= *pIn++;
+						*pOut++ = red;
+						*pOut++ = green;
+						*pOut++ = blue;
+						*pOut++ = alpha;
+						break;
+					
+					default:
+						assert(0);	// if we ever hit this, someone deleted a header check higher up
+						TGA_FORMAT_ERROR("LoadTGA: Image can only have 8, 24 or 32 planes for RGB/greyscale\n");						
+						break;
+				}
+			}		
+		}
+	}
+	else 
+	if (pHeader->byImageType == 10)   // RLE-RGB
+	{
+		// I've no idea if this stuff works, I normally reject RLE targas, but this is from ID's code
+		//	so maybe I should try and support it...
+		//
+		byte packetHeader, packetSize, j;
+
+		for (int y = pHeader->wImageHeight-1; y >= 0; y--)
+		{
+			pOut = pRGBA + y * pHeader->wImageWidth *4;
+			for (int x=0; x<pHeader->wImageWidth;)
+			{
+				packetHeader = *pIn++;
+				packetSize   = 1 + (packetHeader & 0x7f);
+				if (packetHeader & 0x80)         // run-length packet
+				{
+					switch (pHeader->byImagePlanes) 
+					{
+						case 24:
+
+							blue	= *pIn++;
+							green	= *pIn++;
+							red		= *pIn++;
+							alpha	= 255;
+							break;
+
+						case 32:
+							
+							blue	= *pIn++;
+							green	= *pIn++;
+							red		= *pIn++;
+							alpha	= *pIn++;
+							break;
+
+						default:
+							assert(0);	// if we ever hit this, someone deleted a header check higher up
+							TGA_FORMAT_ERROR("LoadTGA: RLE-RGB can only have 24 or 32 planes\n");
+							break;
+					}
+	
+					for (j=0; j<packetSize; j++) 
+					{
+						*pOut++	= red;
+						*pOut++	= green;
+						*pOut++	= blue;
+						*pOut++	= alpha;
+						x++;
+						if (x == pHeader->wImageWidth)  // run spans across rows
+						{
+							x = 0;
+							if (y > 0)
+								y--;
+							else
+								goto breakOut;
+							pOut = pRGBA + y * pHeader->wImageWidth * 4;
+						}
+					}
+				}
+				else 
+				{	// non run-length packet
+
+					for (j=0; j<packetSize; j++) 
+					{
+						switch (pHeader->byImagePlanes) 
+						{
+							case 24:
+
+								blue	= *pIn++;
+								green	= *pIn++;
+								red		= *pIn++;
+								*pOut++ = red;
+								*pOut++ = green;
+								*pOut++ = blue;
+								*pOut++ = 255;
+								break;
+
+							case 32:
+								blue	= *pIn++;
+								green	= *pIn++;
+								red		= *pIn++;
+								alpha	= *pIn++;
+								*pOut++ = red;
+								*pOut++ = green;
+								*pOut++ = blue;
+								*pOut++ = alpha;
+								break;
+
+							default:
+								assert(0);	// if we ever hit this, someone deleted a header check higher up
+								TGA_FORMAT_ERROR("LoadTGA: RLE-RGB can only have 24 or 32 planes\n");
+								break;
+						}
+						x++;
+						if (x == pHeader->wImageWidth)  // pixel packet run spans across rows
+						{
+							x = 0;
+							if (y > 0)
+								y--;
+							else
+								goto breakOut;
+							pOut = pRGBA + y * pHeader->wImageWidth * 4;
+						}
+					}
+				}
+			}
+			breakOut:;
+		}
+	}
+
+TGADone:
+
+	FS_FreeFile (pTempLoadedBuffer);
+
+	if (bFormatErrors)
+	{
+		Com_Error( ERR_DROP, "%s( File: \"%s\" )\n",sErrorString,name);
+	}
+}
+
+#ifndef DEDICATED
+static void LoadJPG( const char *filename, unsigned char **pic, int *width, int *height ) {
+  /* This struct contains the JPEG decompression parameters and pointers to
+   * working space (which is allocated as needed by the JPEG library).
+   */
+  struct jpeg_decompress_struct cinfo;
+  /* We use our private extension JPEG error handler.
+   * Note that this struct must live as long as the main JPEG parameter
+   * struct, to avoid dangling-pointer problems.
+   */
+  /* This struct represents a JPEG error handler.  It is declared separately
+   * because applications often want to supply a specialized error handler
+   * (see the second half of this file for an example).  But here we just
+   * take the easy way out and use the standard error handler, which will
+   * print a message on stderr and call exit() if compression fails.
+   * Note that this struct must live as long as the main JPEG parameter
+   * struct, to avoid dangling-pointer problems.
+   */
+  struct jpeg_error_mgr jerr;
+  /* More stuff */
+  JSAMPARRAY buffer;		/* Output row buffer */
+  int row_stride;		/* physical row width in output buffer */
+  unsigned char *out;
+  byte	*fbuffer;
+  byte  *bbuf;
+
+  /* In this example we want to open the input file before doing anything else,
+   * so that the setjmp() error recovery below can assume the file is open.
+   * VERY IMPORTANT: use "b" option to fopen() if you are on a machine that
+   * requires it in order to read binary files.
+   */
+
+  fileHandle_t		h;
+  const int len = FS_FOpenFileRead(filename, &h, qfalse);
+  if (!h)
+  {
+	  return;
+  }
+
+  fbuffer = (byte *)Z_Malloc(len + 4096, TAG_TEMP_WORKSPACE);
+  FS_Read(fbuffer, len, h);
+  FS_FCloseFile(h);
+
+  /* Step 1: allocate and initialize JPEG decompression object */
+
+  /* We have to set up the error handler first, in case the initialization
+   * step fails.  (Unlikely, but it could happen if you are out of memory.)
+   * This routine fills in the contents of struct jerr, and returns jerr's
+   * address which we place into the link field in cinfo.
+   */
+  cinfo.err = jpeg_std_error(&jerr);
+
+  /* Now we can initialize the JPEG decompression object. */
+  jpeg_create_decompress(&cinfo);
+
+  /* Step 2: specify data source (eg, a file) */
+
+  jpeg_stdio_src(&cinfo, fbuffer);
+
+  /* Step 3: read file parameters with jpeg_read_header() */
+
+  (void) jpeg_read_header(&cinfo, TRUE);
+  /* We can ignore the return value from jpeg_read_header since
+   *   (a) suspension is not possible with the stdio data source, and
+   *   (b) we passed TRUE to reject a tables-only JPEG file as an error.
+   * See libjpeg.doc for more info.
+   */
+
+  /* Step 4: set parameters for decompression */
+
+  /* In this example, we don't need to change any of the defaults set by
+   * jpeg_read_header(), so we do nothing here.
+   */
+
+  /* Step 5: Start decompressor */
+
+  (void) jpeg_start_decompress(&cinfo);
+  /* We can ignore the return value since suspension is not possible
+   * with the stdio data source.
+   */
+
+  /* We may need to do some setup of our own at this point before reading
+   * the data.  After jpeg_start_decompress() we have the correct scaled
+   * output image dimensions available, as well as the output colormap
+   * if we asked for color quantization.
+   * In this example, we need to make an output work buffer of the right size.
+   */ 
+  /* JSAMPLEs per row in output buffer */
+  row_stride = cinfo.output_width * cinfo.output_components;
+
+  // rww - 9-13-01 [1-26-01-sof2]
+  if (cinfo.output_components != 4 && cinfo.output_components != 1) {
+	  Com_Printf("JPG %s is unsupported color depth (%d)\n",filename,cinfo.output_components);
+  }
+
+  out = (unsigned char *)Z_Malloc(cinfo.output_width*cinfo.output_height*4, TAG_TEMP_WORKSPACE, qfalse );
+
+  *pic = out;
+  *width = cinfo.output_width;
+  *height = cinfo.output_height;
+
+  /* Step 6: while (scan lines remain to be read) */
+  /*           jpeg_read_scanlines(...); */
+
+  /* Here we use the library's state variable cinfo.output_scanline as the
+   * loop counter, so that we don't have to keep track ourselves.
+   */
+  while (cinfo.output_scanline < cinfo.output_height) {
+    /* jpeg_read_scanlines expects an array of pointers to scanlines.
+     * Here the array is only one element long, but you could ask for
+     * more than one scanline at a time if that's more convenient.
+     */
+	bbuf = ((out+(row_stride*cinfo.output_scanline)));
+	buffer = &bbuf;
+    (void) jpeg_read_scanlines(&cinfo, buffer, 1);
+  }
+
+	if (cinfo.output_components == 1)
+	{
+		byte *pbDest = (*pic + (cinfo.output_width * cinfo.output_height * 4))-1;
+		byte *pbSrc  = (*pic + (cinfo.output_width * cinfo.output_height    ))-1;
+		int  iPixels = cinfo.output_width * cinfo.output_height;
+		
+		for (int i=0; i<iPixels; i++)
+		{
+			byte b = *pbSrc--;
+			*pbDest-- = 255;
+			*pbDest-- = b;
+			*pbDest-- = b;
+			*pbDest-- = b;
+		}
+	}
+	else	  
+	// clear all the alphas to 255
+	{
+		int		i, j;
+		byte	*buf;
+
+		buf = *pic;
+
+		j = cinfo.output_width * cinfo.output_height * 4;
+		for ( i = 3 ; i < j ; i+=4 ) 
+		{
+			buf[i] = 255;
+		}
+	}
+
+  /* Step 7: Finish decompression */
+
+  (void) jpeg_finish_decompress(&cinfo);
+  /* We can ignore the return value since suspension is not possible
+   * with the stdio data source.
+   */
+
+  /* Step 8: Release JPEG decompression object */
+
+  /* This is an important step since it will release a good deal of memory. */
+  jpeg_destroy_decompress(&cinfo);
+
+  /* After finish_decompress, we can close the input file.
+   * Here we postpone it until after no more JPEG errors are possible,
+   * so as to simplify the setjmp error logic above.  (Actually, I don't
+   * think that jpeg_destroy can do an error exit, but why assume anything...)
+   */
+	Z_Free(fbuffer);
+  /* At this point you may want to check to see whether any corrupt-data
+   * warnings occurred (test whether jerr.pub.num_warnings is nonzero).
+   */
+
+  /* And we're done! */
+}
+
+
+/* Expanded data destination object for stdio output */
+
+typedef struct {
+  struct jpeg_destination_mgr pub; /* public fields */
+
+  byte* outfile;		/* target stream */
+  int	size;
+} my_destination_mgr;
+
+typedef my_destination_mgr * my_dest_ptr;
+
+
+/*
+ * Initialize destination --- called by jpeg_start_compress
+ * before any data is actually written.
+ */
+
+void init_destination (j_compress_ptr cinfo)
+{
+  my_dest_ptr dest = (my_dest_ptr) cinfo->dest;
+
+  dest->pub.next_output_byte = dest->outfile;
+  dest->pub.free_in_buffer = dest->size;
+}
+
+
+/*
+ * Empty the output buffer --- called whenever buffer fills up.
+ *
+ * In typical applications, this should write the entire output buffer
+ * (ignoring the current state of next_output_byte & free_in_buffer),
+ * reset the pointer & count to the start of the buffer, and return TRUE
+ * indicating that the buffer has been dumped.
+ *
+ * In applications that need to be able to suspend compression due to output
+ * overrun, a FALSE return indicates that the buffer cannot be emptied now.
+ * In this situation, the compressor will return to its caller (possibly with
+ * an indication that it has not accepted all the supplied scanlines).  The
+ * application should resume compression after it has made more room in the
+ * output buffer.  Note that there are substantial restrictions on the use of
+ * suspension --- see the documentation.
+ *
+ * When suspending, the compressor will back up to a convenient restart point
+ * (typically the start of the current MCU). next_output_byte & free_in_buffer
+ * indicate where the restart point will be if the current call returns FALSE.
+ * Data beyond this point will be regenerated after resumption, so do not
+ * write it out when emptying the buffer externally.
+ */
+
+boolean empty_output_buffer (j_compress_ptr cinfo)
+{
+  return TRUE;
+}
+
+
+/*
+ * Compression initialization.
+ * Before calling this, all parameters and a data destination must be set up.
+ *
+ * We require a write_all_tables parameter as a failsafe check when writing
+ * multiple datastreams from the same compression object.  Since prior runs
+ * will have left all the tables marked sent_table=TRUE, a subsequent run
+ * would emit an abbreviated stream (no tables) by default.  This may be what
+ * is wanted, but for safety's sake it should not be the default behavior:
+ * programmers should have to make a deliberate choice to emit abbreviated
+ * images.  Therefore the documentation and examples should encourage people
+ * to pass write_all_tables=TRUE; then it will take active thought to do the
+ * wrong thing.
+ */
+
+GLOBAL void
+jpeg_start_compress (j_compress_ptr cinfo, boolean write_all_tables)
+{
+  if (cinfo->global_state != CSTATE_START)
+    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+
+  if (write_all_tables)
+    jpeg_suppress_tables(cinfo, FALSE);	/* mark all tables to be written */
+
+  /* (Re)initialize error mgr and destination modules */
+  (*cinfo->err->reset_error_mgr) ((j_common_ptr) cinfo);
+  (*cinfo->dest->init_destination) (cinfo);
+  /* Perform master selection of active modules */
+  jinit_compress_master(cinfo);
+  /* Set up for the first pass */
+  (*cinfo->master->prepare_for_pass) (cinfo);
+  /* Ready for application to drive first pass through jpeg_write_scanlines
+   * or jpeg_write_raw_data.
+   */
+  cinfo->next_scanline = 0;
+  cinfo->global_state = (cinfo->raw_data_in ? CSTATE_RAW_OK : CSTATE_SCANNING);
+}
+
+
+/*
+ * Write some scanlines of data to the JPEG compressor.
+ *
+ * The return value will be the number of lines actually written.
+ * This should be less than the supplied num_lines only in case that
+ * the data destination module has requested suspension of the compressor,
+ * or if more than image_height scanlines are passed in.
+ *
+ * Note: we warn about excess calls to jpeg_write_scanlines() since
+ * this likely signals an application programmer error.  However,
+ * excess scanlines passed in the last valid call are *silently* ignored,
+ * so that the application need not adjust num_lines for end-of-image
+ * when using a multiple-scanline buffer.
+ */
+
+GLOBAL JDIMENSION
+jpeg_write_scanlines (j_compress_ptr cinfo, JSAMPARRAY scanlines,
+		      JDIMENSION num_lines)
+{
+  JDIMENSION row_ctr, rows_left;
+
+  if (cinfo->global_state != CSTATE_SCANNING)
+    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
+  if (cinfo->next_scanline >= cinfo->image_height)
+    WARNMS(cinfo, JWRN_TOO_MUCH_DATA);
+
+  /* Call progress monitor hook if present */
+  if (cinfo->progress != NULL) {
+    cinfo->progress->pass_counter = (long) cinfo->next_scanline;
+    cinfo->progress->pass_limit = (long) cinfo->image_height;
+    (*cinfo->progress->progress_monitor) ((j_common_ptr) cinfo);
+  }
+
+  /* Give master control module another chance if this is first call to
+   * jpeg_write_scanlines.  This lets output of the frame/scan headers be
+   * delayed so that application can write COM, etc, markers between
+   * jpeg_start_compress and jpeg_write_scanlines.
+   */
+  if (cinfo->master->call_pass_startup)
+    (*cinfo->master->pass_startup) (cinfo);
+
+  /* Ignore any extra scanlines at bottom of image. */
+  rows_left = cinfo->image_height - cinfo->next_scanline;
+  if (num_lines > rows_left)
+    num_lines = rows_left;
+
+  row_ctr = 0;
+  (*cinfo->main->process_data) (cinfo, scanlines, &row_ctr, num_lines);
+  cinfo->next_scanline += row_ctr;
+  return row_ctr;
+}
+
+/*
+ * Terminate destination --- called by jpeg_finish_compress
+ * after all data has been written.  Usually needs to flush buffer.
+ *
+ * NB: *not* called by jpeg_abort or jpeg_destroy; surrounding
+ * application must deal with any cleanup that should happen even
+ * for error exit.
+ */
+
+static int hackSize;
+
+void term_destination (j_compress_ptr cinfo)
+{
+  my_dest_ptr dest = (my_dest_ptr) cinfo->dest;
+  size_t datacount = dest->size - dest->pub.free_in_buffer;
+  hackSize = datacount;
+}
+
+
+/*
+ * Prepare for output to a stdio stream.
+ * The caller must have already opened the stream, and is responsible
+ * for closing it after finishing compression.
+ */
+
+void jpegDest (j_compress_ptr cinfo, byte* outfile, int size)
+{
+  my_dest_ptr dest;
+
+  /* The destination object is made permanent so that multiple JPEG images
+   * can be written to the same file without re-executing jpeg_stdio_dest.
+   * This makes it dangerous to use this manager and a different destination
+   * manager serially with the same JPEG object, because their private object
+   * sizes may be different.  Caveat programmer.
+   */
+  if (cinfo->dest == NULL) {	/* first time for this JPEG object? */
+    cinfo->dest = (struct jpeg_destination_mgr *)
+      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
+				  sizeof(my_destination_mgr));
+  }
+
+  dest = (my_dest_ptr) cinfo->dest;
+  dest->pub.init_destination = init_destination;
+  dest->pub.empty_output_buffer = empty_output_buffer;
+  dest->pub.term_destination = term_destination;
+  dest->outfile = outfile;
+  dest->size = size;
+}
+
+void SaveJPG(char * filename, int quality, int image_width, int image_height, unsigned char *image_buffer) {
+  /* This struct contains the JPEG compression parameters and pointers to
+   * working space (which is allocated as needed by the JPEG library).
+   * It is possible to have several such structures, representing multiple
+   * compression/decompression processes, in existence at once.  We refer
+   * to any one struct (and its associated working data) as a "JPEG object".
+   */
+  struct jpeg_compress_struct cinfo;
+  /* This struct represents a JPEG error handler.  It is declared separately
+   * because applications often want to supply a specialized error handler
+   * (see the second half of this file for an example).  But here we just
+   * take the easy way out and use the standard error handler, which will
+   * print a message on stderr and call exit() if compression fails.
+   * Note that this struct must live as long as the main JPEG parameter
+   * struct, to avoid dangling-pointer problems.
+   */
+  struct jpeg_error_mgr jerr;
+  /* More stuff */
+  JSAMPROW row_pointer[1];	/* pointer to JSAMPLE row[s] */
+  int row_stride;		/* physical row width in image buffer */
+  unsigned char *out;
+
+  /* Step 1: allocate and initialize JPEG compression object */
+
+  /* We have to set up the error handler first, in case the initialization
+   * step fails.  (Unlikely, but it could happen if you are out of memory.)
+   * This routine fills in the contents of struct jerr, and returns jerr's
+   * address which we place into the link field in cinfo.
+   */
+  cinfo.err = jpeg_std_error(&jerr);
+  /* Now we can initialize the JPEG compression object. */
+  jpeg_create_compress(&cinfo);
+
+  /* Step 2: specify data destination (eg, a file) */
+  /* Note: steps 2 and 3 can be done in either order. */
+
+  /* Here we use the library-supplied code to send compressed data to a
+   * stdio stream.  You can also write your own code to do something else.
+   * VERY IMPORTANT: use "b" option to fopen() if you are on a machine that
+   * requires it in order to write binary files.
+   */
+  out = (unsigned char *)Hunk_AllocateTempMemory(image_width*image_height*4);
+  jpegDest(&cinfo, out, image_width*image_height*4);
+
+  /* Step 3: set parameters for compression */
+
+  /* First we supply a description of the input image.
+   * Four fields of the cinfo struct must be filled in:
+   */
+  cinfo.image_width = image_width; 	/* image width and height, in pixels */
+  cinfo.image_height = image_height;
+  cinfo.input_components = 4;		/* # of color components per pixel */
+  cinfo.in_color_space = JCS_RGB; 	/* colorspace of input image */
+  /* Now use the library's routine to set default compression parameters.
+   * (You must set at least cinfo.in_color_space before calling this,
+   * since the defaults depend on the source color space.)
+   */
+  jpeg_set_defaults(&cinfo);
+  /* Now you can set any non-default parameters you wish to.
+   * Here we just illustrate the use of quality (quantization table) scaling:
+   */
+  jpeg_set_quality(&cinfo, quality, TRUE /* limit to baseline-JPEG values */);
+
+  /* Step 4: Start compressor */
+
+  /* TRUE ensures that we will write a complete interchange-JPEG file.
+   * Pass TRUE unless you are very sure of what you're doing.
+   */
+  jpeg_start_compress(&cinfo, TRUE);
+
+  /* Step 5: while (scan lines remain to be written) */
+  /*           jpeg_write_scanlines(...); */
+
+  /* Here we use the library's state variable cinfo.next_scanline as the
+   * loop counter, so that we don't have to keep track ourselves.
+   * To keep things simple, we pass one scanline per call; you can pass
+   * more if you wish, though.
+   */
+  row_stride = image_width * 4;	/* JSAMPLEs per row in image_buffer */
+
+  while (cinfo.next_scanline < cinfo.image_height) {
+    /* jpeg_write_scanlines expects an array of pointers to scanlines.
+     * Here the array is only one element long, but you could pass
+     * more than one scanline at a time if that's more convenient.
+     */
+    row_pointer[0] = & image_buffer[((cinfo.image_height-1)*row_stride)-cinfo.next_scanline * row_stride];
+    (void) jpeg_write_scanlines(&cinfo, row_pointer, 1);
+  }
+
+  /* Step 6: Finish compression */
+
+  jpeg_finish_compress(&cinfo);
+  /* After finish_compress, we can close the output file. */
+  FS_WriteFile( filename, out, hackSize );
+
+  Hunk_FreeTempMemory(out);
+
+  /* Step 7: release JPEG compression object */
+
+  /* This is an important step since it will release a good deal of memory. */
+  jpeg_destroy_compress(&cinfo);
+
+  /* And we're done! */
+}
+
+//===================================================================
+
+/*
+=================
+R_LoadImage
+
+Loads any of the supported image types into a cannonical
+32 bit format.
+=================
+*/
+void R_LoadImage( const char *shortname, byte **pic, int *width, int *height, GLenum *format ) {
+	int		bytedepth;
+	char	name[MAX_QPATH];
+
+	*pic = NULL;
+	*width = 0;
+	*height = 0;
+	*format = GL_RGBA;
+	COM_StripExtension(shortname,name);
+	COM_DefaultExtension(name, sizeof(name), ".jpg");
+	LoadJPG( name, pic, width, height );
+	if (*pic) {
+		return;
+	}
+
+	COM_StripExtension(shortname,name);
+	COM_DefaultExtension(name, sizeof(name), ".png");	
+	LoadPNG32( name, pic, width, height, &bytedepth ); 			// try png first
+	if (*pic){
+		return;
+	}
+
+	COM_StripExtension(shortname,name);
+	COM_DefaultExtension(name, sizeof(name), ".tga");
+	LoadTGA( name, pic, width, height );            // try tga first
+	if (*pic){
+		return;
+	}
+}
+
+
+void R_LoadDataImage( const char *name, byte **pic, int *width, int *height)
+{
+	int		len;
+	char	work[MAX_QPATH];
+
+	*pic = NULL;
+	*width = 0;
+	*height = 0;
+
+	len = strlen(name);
+	if(len >= MAX_QPATH)
+	{
+		return;
+	}
+	if (len < 5)
+	{
+		return;
+	}
+//	MD_PushTag(TAG_DATA_IMAGE_LOAD);
+
+	strcpy(work, name);
+
+	COM_DefaultExtension( work, sizeof( work ), ".png" );
+	LoadPNG8( work, pic, width, height );
+
+	if (!pic || !*pic)
+	{ //png load failed, try jpeg
+		strcpy(work, name);
+		COM_DefaultExtension( work, sizeof( work ), ".jpg" );
+		LoadJPG( work, pic, width, height );
+	}
+
+	if (!pic || !*pic)
+	{ //both png and jpeg failed, try targa
+		strcpy(work, name);
+		COM_DefaultExtension( work, sizeof( work ), ".tga" );
+		LoadTGA( work, pic, width, height );
+	}
+
+	if(*pic)
+	{
+//		MD_PopTag();
+		return;
+	}
+	// Dataimage loading failed
+	Com_Printf("Couldn't read %s -- dataimage load failed\n", name);
+//	MD_PopTag();
+}
+
+#endif // !DEDICATED
+
+void R_InvertImage(byte *data, int width, int height, int depth)
+{
+	byte	*newData;
+	byte	*oldData;
+	byte	*saveData;
+	int		y, stride;
+
+	stride = width * depth;
+
+	oldData = data + ((height - 1) * stride);
+	newData = (byte *)Z_Malloc(height * stride, TAG_TEMP_IMAGE, qfalse );
+	saveData = newData;
+
+	for(y = 0; y < height; y++)
+	{
+		memcpy(newData, oldData, stride);
+		newData += stride;
+		oldData -= stride;
+	}
+	memcpy(data, saveData, height * stride);
+	Z_Free(saveData);
+}
+
+// Lanczos3 image resampling. Better than bicubic, based on sin(x)/x algorithm
+
+#define	LANCZOS3	(3.0f)
+#define M_PI_OVER_3	(M_PI / 3.0f)
+
+typedef struct
+{
+	int		pixel;
+	float	weight;
+} contrib_t;
+
+typedef struct
+{
+	int			n;		// number of contributors
+	contrib_t	*p;		// pointer to list of contributions
+} contrib_list_t;
+
+// sin(x)/x * sin(x/3)/(x/3)
+
+float Lanczos3(float t)
+{
+	if(!t)
+	{
+		return(1.0f);
+	}
+	t = (float)fabs(t);
+	if(t < 3.0f)
+	{
+		return(sinf(t * M_PI) * sinf(t * M_PI_OVER_3) / (t * M_PI * t * M_PI_OVER_3));
+	}
+	return(0.0f);
+}
+
+void R_Resample(byte *source, int swidth, int sheight, byte *dest, int dwidth, int dheight, int components)
+{
+	int				i, j, k, l, count, left, right, num;
+	int				pixel;
+	byte			*raster;
+	float			center, weight, scale, width, height;
+	contrib_list_t	*contributors;
+
+//	MD_PushTag(TAG_RESAMPLE);
+
+	byte *work = (byte *)Z_Malloc(dwidth * sheight * components, TAG_RESAMPLE);
+
+	// Pre calculate filter contributions for rows
+	contributors = (contrib_list_t *)Z_Malloc(sizeof(contrib_list_t) * dwidth, TAG_RESAMPLE);
+
+	float xscale = (float)dwidth / (float)swidth;
+
+	if(xscale < 1.0f)
+	{
+		width = ceilf(LANCZOS3 / xscale);
+		scale = xscale;
+	}
+	else
+	{
+		width = LANCZOS3;
+		scale = 1.0f;
+	}
+	num = ((int)width * 2) + 1;
+
+	for(i = 0; i < dwidth; i++)
+	{
+		contributors[i].n = 0;
+		contributors[i].p = (contrib_t *)Z_Malloc(num * sizeof(contrib_t), TAG_RESAMPLE);
+
+		center = (float)i / xscale;
+		left = (int)ceilf(center - width);
+		right = (int)floorf(center + width);
+
+		for(j = left; j <= right; j++)
+		{
+			weight = Lanczos3((center - (float)j) * scale) * scale;
+			if(j < 0)
+			{
+				pixel = -j;
+			}
+			else if(j >= swidth)
+			{
+				pixel = (swidth - j) + swidth - 1;
+			}
+			else
+			{
+				pixel = j;
+			}
+			count = contributors[i].n++;
+			contributors[i].p[count].pixel = pixel;
+			contributors[i].p[count].weight = weight;
+		}
+	}
+	// Apply filters to zoom horizontally from source to work
+	for(k = 0; k < sheight; k++)
+	{
+		raster = source + (k * swidth * components);
+		for(i = 0; i < dwidth; i++)
+		{
+			for(l = 0; l < components; l++)
+			{
+				weight = 0.0f;
+				for(j = 0; j < contributors[i].n; j++)
+				{
+					weight += raster[(contributors[i].p[j].pixel * components) + l] * contributors[i].p[j].weight;
+				}
+				pixel = (byte)Com_Clamp(0.0f, 255.0f, weight);
+				work[(k * dwidth * components) + (i * components) + l] = pixel;
+			}
+		}
+	}
+	// Clean up
+	for(i = 0; i < dwidth; i++)
+	{
+		Z_Free(contributors[i].p);
+	}
+	Z_Free(contributors);
+
+	// Columns
+	contributors = (contrib_list_t *)Z_Malloc(sizeof(contrib_list_t) * dheight, TAG_RESAMPLE);
+
+	float yscale = (float)dheight / (float)sheight;
+	if(yscale < 1.0f)
+	{
+		height = ceilf(LANCZOS3 / yscale);
+		scale = yscale;
+	}
+	else
+	{
+		height = LANCZOS3;
+		scale = 1.0f;
+	}
+	num = ((int)height * 2) + 1;
+
+	for(i = 0; i < dheight; i++)
+	{
+		contributors[i].n = 0;
+		contributors[i].p = (contrib_t *)Z_Malloc(num * sizeof(contrib_t), TAG_RESAMPLE);
+
+		center = (float)i / yscale;
+		left = (int)ceilf(center - height);
+		right = (int)floorf(center + height);
+
+		for(j = left; j <= right; j++)
+		{
+			weight = Lanczos3((center - (float)j) * scale) * scale;
+			if(j < 0)
+			{
+				pixel = -j;
+			}
+			else if(j >= sheight)
+			{
+				pixel = (sheight - j) + sheight - 1;
+			}
+			else
+			{
+				pixel = j;
+			}
+			count = contributors[i].n++;
+			contributors[i].p[count].pixel = pixel;
+			contributors[i].p[count].weight = weight;
+		}
+	}
+	// Apply filter to columns
+	for(k = 0; k < dwidth; k++)
+	{
+		for(l = 0; l < components; l++)
+		{
+			for(i = 0; i < dheight; i++)
+			{
+				weight = 0.0f;
+				for(j = 0; j < contributors[i].n; j++)
+				{
+					weight += work[(contributors[i].p[j].pixel * dwidth * components) + (k * components) + l] * contributors[i].p[j].weight;
+				}
+				pixel = (byte)Com_Clamp(0.0f, 255.0f, weight);
+				dest[(i * dwidth * components) + (k * components) + l] = pixel;
+			}
+		}
+	}
+	// Clean up
+	for(i = 0; i < dheight; i++)
+	{
+		Z_Free(contributors[i].p);
+	}
+	Z_Free(contributors);
+	Z_Free(work);
+
+//	MD_PopTag();
+}
+
+#ifndef DEDICATED
+
+/*
+===============
+R_FindImageFile
+
+Finds or loads the given image.
+Returns NULL if it fails, not a default image.
+==============
+*/
+image_t	*R_FindImageFile( const char *name, qboolean mipmap, qboolean allowPicmip, qboolean allowTC, int glWrapClampMode ) {
+	image_t	*image;
+	int		width, height;
+	byte	*pic;
+	GLenum	format;
+
+	if (!name 
+		|| com_dedicated->integer	// stop ghoul2 horribleness as regards image loading from server
+		) 
+	{
+		return NULL;
+	}
+
+	// need to do this here as well as in R_CreateImage, or R_FindImageFile_NoLoad() may complain about
+	//	different clamp parms used...
+	//
+	if(glConfig.clampToEdgeAvailable && glWrapClampMode == GL_CLAMP) {
+		glWrapClampMode = GL_CLAMP_TO_EDGE;
+	}
+
+	image = R_FindImageFile_NoLoad(name, mipmap, allowPicmip, allowTC, glWrapClampMode );
+	if (image) {
+		return image;
+	}
+
+	//
+	// load the pic from disk
+	//
+	R_LoadImage( name, &pic, &width, &height, &format );
+	if ( pic == NULL ) {                                    // if we dont get a successful load
+		return NULL;                                        // bail
+	}
+
+
+	// refuse to find any files not power of 2 dims...
+	//
+	if ( (width&(width-1)) || (height&(height-1)) )
+	{
+		Com_Printf ("Refusing to load non-power-2-dims(%d,%d) pic \"%s\"...\n", width,height,name );
+		return NULL;
+	}
+
+	image = R_CreateImage( ( char * ) name, pic, width, height, format, mipmap, allowPicmip, allowTC, glWrapClampMode );
+	Z_Free( pic );
+	return image;
+}
+
+
+/*
+================
+R_CreateDlightImage
+================
+*/
+#define	DLIGHT_SIZE	16
+static void R_CreateDlightImage( void ) 
+{
+	int		width, height;
+	byte	*pic;
+	GLenum	format;
+
+	R_LoadImage("gfx/2d/dlight", &pic, &width, &height, &format);
+	if (pic)
+	{                                    
+		tr.dlightImage = R_CreateImage("*dlight", pic, width, height, GL_RGBA, qfalse, qfalse, qfalse, GL_CLAMP );
+		Z_Free(pic);
+	}
+	else
+	{	// if we dont get a successful load
+		int		x,y;
+		byte	data[DLIGHT_SIZE][DLIGHT_SIZE][4];
+		int		b;
+
+		// make a centered inverse-square falloff blob for dynamic lighting
+		for (x=0 ; x<DLIGHT_SIZE ; x++) {
+			for (y=0 ; y<DLIGHT_SIZE ; y++) {
+				float	d;
+
+				d = ( DLIGHT_SIZE/2 - 0.5f - x ) * ( DLIGHT_SIZE/2 - 0.5f - x ) +
+					( DLIGHT_SIZE/2 - 0.5f - y ) * ( DLIGHT_SIZE/2 - 0.5f - y );
+				b = 4000 / d;
+				if (b > 255) {
+					b = 255;
+				} else if ( b < 75 ) {
+					b = 0;
+				}
+				data[y][x][0] = 
+					data[y][x][1] = 
+					data[y][x][2] = b;
+				data[y][x][3] = 255;			
+			}
+		}
+		tr.dlightImage = R_CreateImage("*dlight", (byte *)data, DLIGHT_SIZE, DLIGHT_SIZE, GL_RGBA, qfalse, qfalse, qfalse, GL_CLAMP );
+	}
+}
+
+
+/*
+=================
+R_InitFogTable
+=================
+*/
+void R_InitFogTable( void ) {
+	int		i;
+	float	d;
+	float	exp;
+	
+	exp = 0.5;
+
+	for ( i = 0 ; i < FOG_TABLE_SIZE ; i++ ) {
+		d = pow ( (float)i/(FOG_TABLE_SIZE-1), exp );
+
+		tr.fogTable[i] = d;
+	}
+}
+
+/*
+================
+R_FogFactor
+
+Returns a 0.0 to 1.0 fog density value
+This is called for each texel of the fog texture on startup
+and for each vertex of transparent shaders in fog dynamically
+================
+*/
+float	R_FogFactor( float s, float t ) {
+	float	d;
+
+	s -= 1.0/512;
+	if ( s < 0 ) {
+		return 0;
+	}
+	if ( t < 1.0/32 ) {
+		return 0;
+	}
+	if ( t < 31.0/32 ) {
+		s *= (t - 1.0f/32.0f) / (30.0f/32.0f);
+	}
+
+	// we need to leave a lot of clamp range
+	s *= 8;
+
+	if ( s > 1.0 ) {
+		s = 1.0;
+	}
+
+	d = tr.fogTable[ (int)(s * (FOG_TABLE_SIZE-1)) ];
+
+	return d;
+}
+
+/*
+================
+R_CreateFogImage
+================
+*/
+#define	FOG_S	256
+#define	FOG_T	32
+static void R_CreateFogImage( void ) {
+	int		x,y;
+	byte	*data;
+	float	g;
+	float	d;
+	float	borderColor[4];
+
+	data = (unsigned char *)Hunk_AllocateTempMemory( FOG_S * FOG_T * 4 );
+
+	g = 2.0;
+
+	// S is distance, T is depth
+	for (x=0 ; x<FOG_S ; x++) {
+		for (y=0 ; y<FOG_T ; y++) {
+			d = R_FogFactor( ( x + 0.5f ) / FOG_S, ( y + 0.5f ) / FOG_T );
+
+			data[(y*FOG_S+x)*4+0] = 
+			data[(y*FOG_S+x)*4+1] = 
+			data[(y*FOG_S+x)*4+2] = 255;
+			data[(y*FOG_S+x)*4+3] = 255*d;
+		}
+	}
+	// standard openGL clamping doesn't really do what we want -- it includes
+	// the border color at the edges.  OpenGL 1.2 has clamp-to-edge, which does
+	// what we want.
+	tr.fogImage = R_CreateImage("*fog", (byte *)data, FOG_S, FOG_T, GL_RGBA, qfalse, qfalse, qfalse, GL_CLAMP );
+	Hunk_FreeTempMemory( data );
+
+	borderColor[0] = 1.0;
+	borderColor[1] = 1.0;
+	borderColor[2] = 1.0;
+	borderColor[3] = 1;
+
+	qglTexParameterfv( GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, borderColor );
+}
+
+/*
+==================
+R_CreateDefaultImage
+==================
+*/
+#define	DEFAULT_SIZE	16
+static void R_CreateDefaultImage( void ) {
+	int		x;
+	byte	data[DEFAULT_SIZE][DEFAULT_SIZE][4];
+
+	// the default image will be a box, to allow you to see the mapping coordinates
+	Com_Memset( data, 32, sizeof( data ) );
+	for ( x = 0 ; x < DEFAULT_SIZE ; x++ ) {
+		data[0][x][0] =
+		data[0][x][1] =
+		data[0][x][2] =
+		data[0][x][3] = 255;
+
+		data[x][0][0] =
+		data[x][0][1] =
+		data[x][0][2] =
+		data[x][0][3] = 255;
+
+		data[DEFAULT_SIZE-1][x][0] =
+		data[DEFAULT_SIZE-1][x][1] =
+		data[DEFAULT_SIZE-1][x][2] =
+		data[DEFAULT_SIZE-1][x][3] = 255;
+
+		data[x][DEFAULT_SIZE-1][0] =
+		data[x][DEFAULT_SIZE-1][1] =
+		data[x][DEFAULT_SIZE-1][2] =
+		data[x][DEFAULT_SIZE-1][3] = 255;
+	}
+	tr.defaultImage = R_CreateImage("*default", (byte *)data, DEFAULT_SIZE, DEFAULT_SIZE, GL_RGBA, qtrue, qfalse, qfalse, GL_REPEAT );
+}
+
+/*
+==================
+R_CreateBuiltinImages
+==================
+*/
+void R_CreateBuiltinImages( void ) {
+	int		x,y;
+	byte	data[DEFAULT_SIZE][DEFAULT_SIZE][4];
+
+	R_CreateDefaultImage();
+
+	// we use a solid white image instead of disabling texturing
+	Com_Memset( data, 255, sizeof( data ) );
+	tr.whiteImage = R_CreateImage("*white", (byte *)data, 8, 8, GL_RGBA, qfalse, qfalse, qfalse, GL_REPEAT);
+
+	tr.screenImage = R_CreateImage("*screen", (byte *)data, 8, 8, GL_RGBA, qfalse, qfalse, qfalse, GL_REPEAT );
+
+	// Create the scene glow image. - AReis
+	tr.screenGlow = 1024 + giTextureBindNum++;
+	qglDisable( GL_TEXTURE_2D );
+	qglEnable( GL_TEXTURE_RECTANGLE_EXT );
+	qglBindTexture( GL_TEXTURE_RECTANGLE_EXT, tr.screenGlow );
+	qglTexImage2D( GL_TEXTURE_RECTANGLE_EXT, 0, GL_RGBA16, glConfig.vidWidth, glConfig.vidHeight, 0, GL_RGB, GL_FLOAT, 0 );
+	qglTexParameteri( GL_TEXTURE_RECTANGLE_EXT, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
+	qglTexParameteri( GL_TEXTURE_RECTANGLE_EXT, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
+	qglTexParameteri( GL_TEXTURE_RECTANGLE_EXT, GL_TEXTURE_WRAP_S, GL_CLAMP );
+	qglTexParameteri( GL_TEXTURE_RECTANGLE_EXT, GL_TEXTURE_WRAP_T, GL_CLAMP );
+
+	// Create the scene image. - AReis
+	tr.sceneImage = 1024 + giTextureBindNum++;
+	qglBindTexture( GL_TEXTURE_RECTANGLE_EXT, tr.sceneImage );
+	qglTexImage2D( GL_TEXTURE_RECTANGLE_EXT, 0, GL_RGBA16, glConfig.vidWidth, glConfig.vidHeight, 0, GL_RGB, GL_FLOAT, 0 );
+	qglTexParameteri( GL_TEXTURE_RECTANGLE_EXT, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
+	qglTexParameteri( GL_TEXTURE_RECTANGLE_EXT, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
+	qglTexParameteri( GL_TEXTURE_RECTANGLE_EXT, GL_TEXTURE_WRAP_S, GL_CLAMP );
+	qglTexParameteri( GL_TEXTURE_RECTANGLE_EXT, GL_TEXTURE_WRAP_T, GL_CLAMP );
+
+	// Create the minimized scene blur image.
+	if ( r_DynamicGlowWidth->integer > glConfig.vidWidth  )
+	{
+		r_DynamicGlowWidth->integer = glConfig.vidWidth;
+	}
+	if ( r_DynamicGlowHeight->integer > glConfig.vidHeight  )
+	{
+		r_DynamicGlowHeight->integer = glConfig.vidHeight;
+	}
+	tr.blurImage = 1024 + giTextureBindNum++;
+	qglBindTexture( GL_TEXTURE_RECTANGLE_EXT, tr.blurImage );
+	qglTexImage2D( GL_TEXTURE_RECTANGLE_EXT, 0, GL_RGBA16, r_DynamicGlowWidth->integer, r_DynamicGlowHeight->integer, 0, GL_RGB, GL_FLOAT, 0 );
+	qglTexParameteri( GL_TEXTURE_RECTANGLE_EXT, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
+	qglTexParameteri( GL_TEXTURE_RECTANGLE_EXT, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
+	qglTexParameteri( GL_TEXTURE_RECTANGLE_EXT, GL_TEXTURE_WRAP_S, GL_CLAMP );
+	qglTexParameteri( GL_TEXTURE_RECTANGLE_EXT, GL_TEXTURE_WRAP_T, GL_CLAMP );
+	qglDisable( GL_TEXTURE_RECTANGLE_EXT );
+	qglEnable( GL_TEXTURE_2D );
+
+
+	// with overbright bits active, we need an image which is some fraction of full color,
+	// for default lightmaps, etc
+	for (x=0 ; x<DEFAULT_SIZE ; x++) {
+		for (y=0 ; y<DEFAULT_SIZE ; y++) {
+			data[y][x][0] = 
+			data[y][x][1] = 
+			data[y][x][2] = tr.identityLightByte;
+			data[y][x][3] = 255;			
+		}
+	}
+
+	tr.identityLightImage = R_CreateImage("*identityLight", (byte *)data, 8, 8, GL_RGBA, qfalse, qfalse, qfalse, GL_REPEAT);
+
+	for(x=0;x<NUM_SCRATCH_IMAGES;x++) {
+		// scratchimage is usually used for cinematic drawing
+		tr.scratchImage[x] = R_CreateImage(va("*scratch%d",x), (byte *)data, DEFAULT_SIZE, DEFAULT_SIZE, GL_RGBA, qfalse, qtrue, qfalse, GL_CLAMP);
+	}
+
+	R_CreateDlightImage();
+
+	R_CreateFogImage();
+}
+
+
+/*
+===============
+R_SetColorMappings
+===============
+*/
+void R_SetColorMappings( void ) {
+	int		i, j;
+	float	g;
+	int		inf;
+	int		shift;
+
+	// setup the overbright lighting
+	tr.overbrightBits = r_overBrightBits->integer;
+	if ( !glConfig.deviceSupportsGamma ) {
+		tr.overbrightBits = 0;		// need hardware gamma for overbright
+	}
+
+	// never overbright in windowed mode
+	if ( !glConfig.isFullscreen ) 
+	{
+		tr.overbrightBits = 0;
+	}
+
+	if ( tr.overbrightBits > 1 ) {
+		tr.overbrightBits = 1;
+	}
+
+	if ( tr.overbrightBits < 0 ) {
+		tr.overbrightBits = 0;
+	}
+
+	tr.identityLight = 1.0f / ( 1 << tr.overbrightBits );
+	tr.identityLightByte = 255 * tr.identityLight;
+
+
+	if ( r_intensity->value < 1.0f ) {
+		Cvar_Set( "r_intensity", "1" );
+	}
+
+	if ( r_gamma->value < 0.5f ) {
+		Cvar_Set( "r_gamma", "0.5" );
+	} else if ( r_gamma->value > 3.0f ) {
+		Cvar_Set( "r_gamma", "3.0" );
+	}
+
+	g = r_gamma->value;
+
+	shift = tr.overbrightBits;
+
+	for ( i = 0; i < 256; i++ ) {
+		if ( g == 1 ) {
+			inf = i;
+		} else {
+			inf = 255 * pow ( i/255.0f, 1.0f / g ) + 0.5f;
+		}
+		inf <<= shift;
+		if (inf < 0) {
+			inf = 0;
+		}
+		if (inf > 255) {
+			inf = 255;
+		}
+		s_gammatable[i] = inf;
+	}
+
+	for (i=0 ; i<256 ; i++) {
+		j = i * r_intensity->value;
+		if (j > 255) {
+			j = 255;
+		}
+		s_intensitytable[i] = j;
+	}
+
+	if ( glConfig.deviceSupportsGamma )
+	{
+		GLimp_SetGamma( s_gammatable, s_gammatable, s_gammatable );
+	}
+}
+
+/*
+===============
+R_InitImages
+===============
+*/
+void	R_InitImages( void ) {
+	//memset(hashTable, 0, sizeof(hashTable));	// DO NOT DO THIS NOW (because of image cacheing)	-ste.
+	// build brightness translation tables
+	R_SetColorMappings();
+
+	// create default texture and white texture
+	R_CreateBuiltinImages();
+}
+
+/*
+===============
+R_DeleteTextures
+===============
+*/
+// (only gets called during vid_restart now (and app exit), not during map load)
+//
+void R_DeleteTextures( void ) {
+
+	R_Images_Clear();	
+	GL_ResetBinds();
+}
+
+/*
+============================================================================
+
+SKINS
+
+============================================================================
+*/
+
+static char *CommaParse( char **data_p );
+//can't be dec'd here since we need it for non-dedicated builds now as well.
+
+/*
+===============
+RE_RegisterSkin
+
+===============
+*/
+
+#endif // !DEDICATED
+bool gServerSkinHack = false;
+
+
+shader_t *R_FindServerShader( const char *name, const int *lightmapIndex, const byte *styles, qboolean mipRawImage );
+char *CommaParse( char **data_p );
+/*
+===============
+RE_SplitSkins
+input = skinname, possibly being a macro for three skins
+return= true if three part skins found
+output= qualified names to three skins if return is true, undefined if false
+===============
+*/
+bool RE_SplitSkins(const char *INname, char *skinhead, char *skintorso, char *skinlower)
+{	//INname= "models/players/jedi_tf/|head01_skin1|torso01|lower01";
+	if (strchr(INname, '|'))
+	{
+		char name[MAX_QPATH];
+		strcpy(name, INname);
+		char *p = strchr(name, '|');
+		*p=0;
+		p++;
+		//fill in the base path
+		strcpy (skinhead, name);
+		strcpy (skintorso, name);
+		strcpy (skinlower, name);
+
+		//now get the the individual files
+		
+		//advance to second
+		char *p2 = strchr(p, '|'); 
+		assert(p2);
+		*p2=0;
+		p2++;
+		strcat (skinhead, p);
+		strcat (skinhead, ".skin");
+
+
+		//advance to third
+		p = strchr(p2, '|');
+		assert(p);
+		*p=0;
+		p++;
+		strcat (skintorso,p2);
+		strcat (skintorso, ".skin");
+
+		strcat (skinlower,p);
+		strcat (skinlower, ".skin");
+		
+		return true;
+	}
+	return false;
+}
+
+// given a name, go get the skin we want and return
+qhandle_t RE_RegisterIndividualSkin( const char *name , qhandle_t hSkin) 
+{
+	skin_t		*skin;
+	skinSurface_t	*surf;
+	char		*text, *text_p;
+	char		*token;
+	char		surfName[MAX_QPATH];
+
+	// load and parse the skin file
+    FS_ReadFile( name, (void **)&text );
+	if ( !text ) {
+#ifndef FINAL_BUILD
+		Com_Printf( "WARNING: RE_RegisterSkin( '%s' ) failed to load!\n", name );
+#endif
+		return 0;
+	}
+
+	assert (tr.skins[hSkin]);	//should already be setup, but might be an 3part append
+
+	skin = tr.skins[hSkin];
+
+	text_p = text;
+	while ( text_p && *text_p ) {
+		// get surface name
+		token = CommaParse( &text_p );
+		Q_strncpyz( surfName, token, sizeof( surfName ) );
+
+		if ( !token[0] ) {
+			break;
+		}
+		// lowercase the surface name so skin compares are faster
+		Q_strlwr( surfName );
+
+		if ( *text_p == ',' ) {
+			text_p++;
+		}
+
+		if ( !strncmp( token, "tag_", 4 ) ) {	//these aren't in there, but just in case you load an id style one...
+			continue;
+		}
+		
+		// parse the shader name
+		token = CommaParse( &text_p );
+
+		if ( !strcmp( &surfName[strlen(surfName)-4], "_off") )
+		{
+			if ( !strcmp( token ,"*off" ) )
+			{
+				continue;	//don't need these double offs
+			}
+			surfName[strlen(surfName)-4] = 0;	//remove the "_off"
+		}
+		if (sizeof( skin->surfaces) / sizeof( skin->surfaces[0] ) <= skin->numSurfaces)
+		{
+			assert( sizeof( skin->surfaces) / sizeof( skin->surfaces[0] ) > skin->numSurfaces );
+			Com_Printf( "WARNING: RE_RegisterSkin( '%s' ) more than %d surfaces!\n", name, sizeof( skin->surfaces) / sizeof( skin->surfaces[0] ) );
+			break;
+		}
+		surf = skin->surfaces[ skin->numSurfaces ] = (skinSurface_t *) Hunk_Alloc( sizeof( *skin->surfaces[0] ), h_low );
+		Q_strncpyz( surf->name, surfName, sizeof( surf->name ) );
+
+		if (gServerSkinHack)
+		{
+			surf->shader = R_FindServerShader( token, lightmapsNone, stylesDefault, qtrue );
+		}
+		else
+		{
+			surf->shader = R_FindShader( token, lightmapsNone, stylesDefault, qtrue );
+		}
+		skin->numSurfaces++;
+	}
+
+	FS_FreeFile( text );
+
+
+	// never let a skin have 0 shaders
+	if ( skin->numSurfaces == 0 ) {
+		return 0;		// use default skin
+	}
+
+	return hSkin;
+}
+
+qhandle_t RE_RegisterSkin( const char *name ) {
+	qhandle_t	hSkin;
+	skin_t		*skin;
+
+	if ( !name || !name[0] ) {
+		Com_Printf( "Empty name passed to RE_RegisterSkin\n" );
+		return 0;
+	}
+
+	if ( strlen( name ) >= MAX_QPATH ) {
+		Com_Printf( "Skin name exceeds MAX_QPATH\n" );
+		return 0;
+	}
+
+	// see if the skin is already loaded
+	for ( hSkin = 1; hSkin < tr.numSkins ; hSkin++ ) {
+		skin = tr.skins[hSkin];
+		if ( !Q_stricmp( skin->name, name ) ) {
+			if( skin->numSurfaces == 0 ) {
+				return 0;		// default skin
+			}
+			return hSkin;
+		}
+	}
+
+	// allocate a new skin
+	if ( tr.numSkins == MAX_SKINS ) {
+		Com_Printf( "WARNING: RE_RegisterSkin( '%s' ) MAX_SKINS hit\n", name );
+		return 0;
+	}
+	tr.numSkins++;
+	skin = (struct skin_s *)Hunk_Alloc( sizeof( skin_t ), h_low );
+	tr.skins[hSkin] = skin;
+	Q_strncpyz( skin->name, name, sizeof( skin->name ) );
+	skin->numSurfaces = 0;
+
+	// make sure the render thread is stopped
+	R_SyncRenderThread();
+
+	// If not a .skin file, load as a single shader
+	if ( strcmp( name + strlen( name ) - 5, ".skin" ) ) {
+/*		skin->numSurfaces = 1;
+		skin->surfaces[0] = (skinSurface_t *)Hunk_Alloc( sizeof(skin->surfaces[0]), h_low );
+		skin->surfaces[0]->shader = R_FindShader( name, lightmapsNone, stylesDefault, qtrue );
+		return hSkin;
+*/
+	}
+
+	char skinhead[MAX_QPATH]={0};
+	char skintorso[MAX_QPATH]={0};
+	char skinlower[MAX_QPATH]={0};
+	if ( RE_SplitSkins(name, (char*)&skinhead, (char*)&skintorso, (char*)&skinlower ) )
+	{//three part
+		hSkin = RE_RegisterIndividualSkin(skinhead, hSkin);
+		if (hSkin)
+		{
+			hSkin = RE_RegisterIndividualSkin(skintorso, hSkin);
+			if (hSkin)
+			{
+				hSkin = RE_RegisterIndividualSkin(skinlower, hSkin);
+			}
+		}
+	}
+	else
+	{//single skin
+		hSkin = RE_RegisterIndividualSkin(name, hSkin);
+	}
+	return(hSkin);
+}
+
+
+
+/*
+==================
+CommaParse
+
+This is unfortunate, but the skin files aren't
+compatable with our normal parsing rules.
+==================
+*/
+static char *CommaParse( char **data_p ) {
+	int c = 0, len;
+	char *data;
+	static	char	com_token[MAX_TOKEN_CHARS];
+
+	data = *data_p;
+	len = 0;
+	com_token[0] = 0;
+
+	// make sure incoming data is valid
+	if ( !data ) {
+		*data_p = NULL;
+		return com_token;
+	}
+
+	while ( 1 ) {
+		// skip whitespace
+		while( (c = *data) <= ' ') {
+			if( !c ) {
+				break;
+			}
+			data++;
+		}
+
+
+		c = *data;
+
+		// skip double slash comments
+		if ( c == '/' && data[1] == '/' )
+		{
+			while (*data && *data != '\n')
+				data++;
+		}
+		// skip /* */ comments
+		else if ( c=='/' && data[1] == '*' ) 
+		{
+			while ( *data && ( *data != '*' || data[1] != '/' ) ) 
+			{
+				data++;
+			}
+			if ( *data ) 
+			{
+				data += 2;
+			}
+		}
+		else
+		{
+			break;
+		}
+	}
+
+	if ( c == 0 ) {
+		return "";
+	}
+
+	// handle quoted strings
+	if (c == '\"')
+	{
+		data++;
+		while (1)
+		{
+			c = *data++;
+			if (c=='\"' || !c)
+			{
+				com_token[len] = 0;
+				*data_p = ( char * ) data;
+				return com_token;
+			}
+			if (len < MAX_TOKEN_CHARS)
+			{
+				com_token[len] = c;
+				len++;
+			}
+		}
+	}
+
+	// parse a regular word
+	do
+	{
+		if (len < MAX_TOKEN_CHARS)
+		{
+			com_token[len] = c;
+			len++;
+		}
+		data++;
+		c = *data;
+	} while (c>32 && c != ',' );
+
+	if (len == MAX_TOKEN_CHARS)
+	{
+//		Com_Printf ("Token exceeded %i chars, discarded.\n", MAX_TOKEN_CHARS);
+		len = 0;
+	}
+	com_token[len] = 0;
+
+	*data_p = ( char * ) data;
+	return com_token;
+}
+
+/*
+===============
+RE_RegisterServerSkin
+
+Mangled version of the above function to load .skin files on the server.
+===============
+*/
+extern qboolean Com_TheHunkMarkHasBeenMade(void);
+extern qboolean ShaderHashTableExists(void);
+qhandle_t RE_RegisterServerSkin( const char *name ) {
+	qhandle_t r;
+
+	if (com_cl_running &&
+		com_cl_running->integer &&
+		Com_TheHunkMarkHasBeenMade() &&
+		ShaderHashTableExists())
+	{ //If the client is running then we can go straight into the normal registerskin func
+		return RE_RegisterSkin(name);
+	}
+
+	gServerSkinHack = true;
+	r = RE_RegisterSkin(name);
+	gServerSkinHack = false;
+
+	return r;
+}
+
+/*
+===============
+R_InitSkins
+===============
+*/
+void	R_InitSkins( void ) {
+	skin_t		*skin;
+
+	tr.numSkins = 1;
+
+	// make the default skin have all default shaders
+	skin = tr.skins[0] = (struct skin_s *)/*ri.*/Hunk_Alloc( sizeof( skin_t ), h_low );
+	Q_strncpyz( skin->name, "<default skin>", sizeof( skin->name )  );
+	skin->numSurfaces = 1;
+	skin->surfaces[0] = (skinSurface_t *)/*ri.*/Hunk_Alloc( sizeof( skinSurface_t ), h_low );
+	skin->surfaces[0]->shader = tr.defaultShader;
+}
+
+/*
+===============
+R_GetSkinByHandle
+===============
+*/
+skin_t	*R_GetSkinByHandle( qhandle_t hSkin ) {
+	if ( hSkin < 1 || hSkin >= tr.numSkins ) {
+		return tr.skins[0];
+	}
+	return tr.skins[ hSkin ];
+}
+
+#ifndef DEDICATED
+/*
+===============
+R_SkinList_f
+===============
+*/
+void	R_SkinList_f( void ) {
+	int			i, j;
+	skin_t		*skin;
+
+	Com_Printf ( "------------------\n");
+
+	for ( i = 0 ; i < tr.numSkins ; i++ ) {
+		skin = tr.skins[i];
+
+		Com_Printf ("%3i:%s\n", i, skin->name );
+		for ( j = 0 ; j < skin->numSurfaces ; j++ ) {
+			Com_Printf ("       %s = %s\n", 
+				skin->surfaces[j]->name, skin->surfaces[j]->shader->name );
+		}
+	}
+	Com_Printf ( "------------------\n");
+}
+
+#endif // !DEDICATED
diff --git a/codemp/renderer/tr_image_xbox.cpp b/codemp/renderer/tr_image_xbox.cpp
new file mode 100644
index 0000000..849942b
--- /dev/null
+++ b/codemp/renderer/tr_image_xbox.cpp
@@ -0,0 +1,2579 @@
+// tr_image.c
+
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+
+
+#include "tr_local.h"
+#include "../qcommon/sstring.h"
+#include "../zlib/zlib.h"
+#include "../png/png.h"
+#include "../qcommon/sstring.h"
+
+
+static byte			 s_intensitytable[256];
+static unsigned char s_gammatable[256];
+
+int		gl_filter_min = GL_LINEAR_MIPMAP_NEAREST;
+int		gl_filter_max = GL_LINEAR;
+
+#define FILE_HASH_SIZE		1024	// actually, the shader code needs this (from another module, great).
+//static	image_t*		hashTable[FILE_HASH_SIZE];
+
+/*
+** R_GammaCorrect
+*/
+void R_GammaCorrect( byte *buffer, int bufSize ) {
+	int i;
+
+	for ( i = 0; i < bufSize; i++ ) {
+		buffer[i] = s_gammatable[buffer[i]];
+	}
+}
+
+typedef struct {
+	char *name;
+	int	minimize, maximize;
+} textureMode_t;
+
+textureMode_t modes[] = {
+	{"GL_NEAREST", GL_NEAREST, GL_NEAREST},
+	{"GL_LINEAR", GL_LINEAR, GL_LINEAR},
+	{"GL_NEAREST_MIPMAP_NEAREST", GL_NEAREST_MIPMAP_NEAREST, GL_NEAREST},
+	{"GL_LINEAR_MIPMAP_NEAREST", GL_LINEAR_MIPMAP_NEAREST, GL_LINEAR},
+	{"GL_NEAREST_MIPMAP_LINEAR", GL_NEAREST_MIPMAP_LINEAR, GL_NEAREST},
+	{"GL_LINEAR_MIPMAP_LINEAR", GL_LINEAR_MIPMAP_LINEAR, GL_LINEAR}
+};
+
+/*
+================
+return a hash value for the filename
+================
+*/
+long generateHashValue( const char *fname ) {
+	int		i;
+	long	hash;
+	char	letter;
+
+	hash = 0;
+	i = 0;
+	while (fname[i] != '\0') {
+		letter = tolower(fname[i]);
+		if (letter =='.') break;				// don't include extension
+		if (letter =='\\') letter = '/';		// damn path names
+		hash+=(long)(letter)*(i+119);
+		i++;
+	}
+	hash &= (FILE_HASH_SIZE-1);
+	return hash;
+}
+
+// makeup a nice clean, consistant name to query for and file under, for map<> usage...
+//
+char *GenerateImageMappingName( const char *name )
+{
+	static char sName[MAX_QPATH];
+	int		i=0;
+	char	letter;
+	
+	while (name[i] != '\0' && i<MAX_QPATH-1) 
+	{
+		letter = tolower(name[i]);
+		if (letter =='.') break;				// don't include extension
+		if (letter =='\\') letter = '/';		// damn path names
+		sName[i++] = letter;
+	}
+	sName[i]=0;
+	
+	return &sName[0];
+}
+
+/*
+===============
+GL_TextureMode
+===============
+*/
+void GL_TextureMode( const char *string ) {
+	int		i;
+	image_t	*glt;
+
+	for ( i=0 ; i< 6 ; i++ ) {
+		if ( !Q_stricmp( modes[i].name, string ) ) {
+			break;
+		}
+	}
+
+	if ( i == 6 ) {
+		Com_Printf ("bad filter name\n");
+		for ( i=0 ; i< 6 ; i++ ) {
+			Com_Printf( "%s\n",modes[i].name);
+			}
+		return;
+	}
+
+	gl_filter_min = modes[i].minimize;
+	gl_filter_max = modes[i].maximize;
+
+	// change all the existing mipmap texture objects
+//	int iNumImages = 
+	   				 R_Images_StartIteration();
+	while ( (glt   = R_Images_GetNextIteration()) != NULL)
+	{
+		if ( glt->mipcount ) {
+			GL_Bind (glt);
+			qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, gl_filter_min);
+			qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, gl_filter_max);
+
+			if(glConfig.maxTextureFilterAnisotropy) {
+				if(r_ext_texture_filter_anisotropic->integer>1) {
+					qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, r_ext_texture_filter_anisotropic->value); // 2.0f
+				} else {
+					qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, 1.0f);
+				}
+			}
+		}
+	}
+}
+
+static float R_BytesPerTex (int format)
+{
+	switch ( format ) {
+	case 1:
+		//"I    " 
+		return 1;
+		break;
+	case 2:
+		//"IA   " 
+		return 2;
+		break;
+	case 3:
+		//"RGB  " 
+		return glConfig.colorBits/8.0f;
+		break;
+	case 4:
+		//"RGBA " 
+		return glConfig.colorBits/8.0f;
+		break;
+		
+	case GL_RGBA4:
+		//"RGBA4" 
+		return 2;
+		break;
+	case GL_RGB5:
+		//"RGB5 " 
+		return 2;
+		break;
+		
+	case GL_RGBA8:
+		//"RGBA8" 
+		return 4;
+		break;
+	case GL_RGB8:
+		//"RGB8" 
+		return 4;
+		break;
+		
+	case GL_RGB4_S3TC:
+		//"S3TC " 
+		return 0.33333f;
+		break;
+	case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
+		//"DXT1 " 
+		return 0.33333f;
+		break;
+	case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
+		//"DXT5 " 
+		return 1;
+		break;
+	case GL_DDS1_EXT:
+		//"DDS1 "
+		return 0.5f;
+		break;
+	case GL_DDS5_EXT:
+		//"DDS5 "
+		return 1;
+		break;
+	case GL_DDS_RGB16_EXT:
+		//"DDS16"
+		return 2;
+		break;
+	case GL_DDS_RGBA32_EXT:
+		//"DDS32"
+		return 4;
+		break;
+	default:
+		//"???? " 
+		return 4;
+	}
+}
+
+/*
+===============
+R_ImageList_f
+===============
+*/
+void R_ImageList_f( void ) {
+	int		i=0;
+	image_t	*image;
+	int		texels = 0;
+	float	texBytes = 0.0f;
+	const char *yesno[] = {"no ", "yes"};
+
+	Com_Printf ( "\n      -w-- -h-- -mm- -if- wrap --name-------\n");
+
+	int iNumImages = R_Images_StartIteration();
+	while ( (image = R_Images_GetNextIteration()) != NULL)
+	{
+		texels   += image->width*image->height;
+		texBytes += image->width*image->height * R_BytesPerTex (image->internalFormat);
+
+		Com_Printf ( "%4i: %4i %4i  %s ",
+			i, image->width, image->height, yesno[image->mipcount] );
+
+		switch ( image->internalFormat ) {
+		case 1:
+			Com_Printf( "I    " );
+			break;
+		case 2:
+			Com_Printf( "IA   " );
+			break;
+		case 3:
+			Com_Printf( "RGB  " );
+			break;
+		case 4:
+			Com_Printf( "RGBA " );
+			break;
+		case GL_RGBA8:
+			Com_Printf( "RGBA8" );
+			break;
+		case GL_RGB8:
+			Com_Printf( "RGB8 " );
+			break;
+		case GL_RGB4_S3TC:
+			Com_Printf( "S3TC " );
+			break;
+		case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
+			Com_Printf( "DXT1 " );
+			break;
+		case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
+			Com_Printf( "DXT5 " );
+			break;
+		case GL_RGBA4:
+			Com_Printf( "RGBA4" );
+			break;
+		case GL_RGB5:
+			Com_Printf( "RGB5 " );
+			break;
+		case GL_DDS1_EXT:
+			Com_Printf( "DDS1 " );
+			break;
+		case GL_DDS5_EXT:
+			Com_Printf( "DDS5 " );
+			break;
+		case GL_DDS_RGB16_EXT:
+			Com_Printf( "DDS16" );
+			break;
+		case GL_DDS_RGBA32_EXT:
+			Com_Printf( "DDS32" );
+			break;
+		default:
+			Com_Printf( "???? " );
+		}
+
+		switch ( image->wrapClampMode ) {
+		case GL_REPEAT:
+			Com_Printf( "rept " );
+			break;
+		case GL_CLAMP:
+			Com_Printf( "clmp " );
+			break;
+		case GL_CLAMP_TO_EDGE:
+			Com_Printf( "clpE " );
+			break;
+		default:
+			Com_Printf( "%4i ", image->wrapClampMode );
+			break;
+		}
+		
+		i++;
+	}
+	Com_Printf (" ---------\n");
+	Com_Printf ("      -w-- -h-- -mm- -if- wrap --name-------\n");
+	Com_Printf (" %i total texels (not including mipmaps)\n", texels );
+	Com_Printf (" %.2fMB total texture mem (not including mipmaps)\n", texBytes/1048576.0f );
+	Com_Printf (" %i total images\n\n", iNumImages );
+}
+
+//=======================================================================
+
+
+/*
+================
+R_LightScaleTexture
+
+Scale up the pixel values in a texture to increase the
+lighting range
+================
+*/
+static void R_LightScaleTexture (unsigned *in, int inwidth, int inheight, qboolean only_gamma )
+{
+	if ( only_gamma )
+	{
+		if ( !glConfig.deviceSupportsGamma )
+		{
+			int		i, c;
+			byte	*p;
+
+			p = (byte *)in;
+
+			c = inwidth*inheight;
+			for (i=0 ; i<c ; i++, p+=4)
+			{
+				p[0] = s_gammatable[p[0]];
+				p[1] = s_gammatable[p[1]];
+				p[2] = s_gammatable[p[2]];
+			}
+		}
+	}
+	else
+	{
+		int		i, c;
+		byte	*p;
+
+		p = (byte *)in;
+
+		c = inwidth*inheight;
+
+		if ( glConfig.deviceSupportsGamma )
+		{
+			for (i=0 ; i<c ; i++, p+=4)
+			{
+				p[0] = s_intensitytable[p[0]];
+				p[1] = s_intensitytable[p[1]];
+				p[2] = s_intensitytable[p[2]];
+			}
+		}
+		else
+		{
+			for (i=0 ; i<c ; i++, p+=4)
+			{
+				p[0] = s_gammatable[s_intensitytable[p[0]]];
+				p[1] = s_gammatable[s_intensitytable[p[1]]];
+				p[2] = s_gammatable[s_intensitytable[p[2]]];
+			}
+		}
+	}
+}
+
+
+/*
+================
+R_MipMap2
+
+Uses temp mem, but then copies back to input, quartering the size of the texture
+Proper linear filter
+================
+*/
+static void R_MipMap2( unsigned *in, int inWidth, int inHeight ) {
+	int			i, j, k;
+	byte		*outpix;
+	int			inWidthMask, inHeightMask;
+	int			total;
+	int			outWidth, outHeight;
+	unsigned	*temp;
+
+	outWidth = inWidth >> 1;
+	outHeight = inHeight >> 1;
+	temp = (unsigned int *) Z_Malloc( outWidth * outHeight * 4, TAG_TEMP_WORKSPACE, qfalse );
+
+	inWidthMask = inWidth - 1;
+	inHeightMask = inHeight - 1;
+
+	for ( i = 0 ; i < outHeight ; i++ ) {
+		for ( j = 0 ; j < outWidth ; j++ ) {
+			outpix = (byte *) ( temp + i * outWidth + j );
+			for ( k = 0 ; k < 4 ; k++ ) {
+				total = 
+					1 * ((byte *)&in[ ((i*2-1)&inHeightMask)*inWidth + ((j*2-1)&inWidthMask) ])[k] +
+					2 * ((byte *)&in[ ((i*2-1)&inHeightMask)*inWidth + ((j*2)&inWidthMask) ])[k] +
+					2 * ((byte *)&in[ ((i*2-1)&inHeightMask)*inWidth + ((j*2+1)&inWidthMask) ])[k] +
+					1 * ((byte *)&in[ ((i*2-1)&inHeightMask)*inWidth + ((j*2+2)&inWidthMask) ])[k] +
+
+					2 * ((byte *)&in[ ((i*2)&inHeightMask)*inWidth + ((j*2-1)&inWidthMask) ])[k] +
+					4 * ((byte *)&in[ ((i*2)&inHeightMask)*inWidth + ((j*2)&inWidthMask) ])[k] +
+					4 * ((byte *)&in[ ((i*2)&inHeightMask)*inWidth + ((j*2+1)&inWidthMask) ])[k] +
+					2 * ((byte *)&in[ ((i*2)&inHeightMask)*inWidth + ((j*2+2)&inWidthMask) ])[k] +
+
+					2 * ((byte *)&in[ ((i*2+1)&inHeightMask)*inWidth + ((j*2-1)&inWidthMask) ])[k] +
+					4 * ((byte *)&in[ ((i*2+1)&inHeightMask)*inWidth + ((j*2)&inWidthMask) ])[k] +
+					4 * ((byte *)&in[ ((i*2+1)&inHeightMask)*inWidth + ((j*2+1)&inWidthMask) ])[k] +
+					2 * ((byte *)&in[ ((i*2+1)&inHeightMask)*inWidth + ((j*2+2)&inWidthMask) ])[k] +
+
+					1 * ((byte *)&in[ ((i*2+2)&inHeightMask)*inWidth + ((j*2-1)&inWidthMask) ])[k] +
+					2 * ((byte *)&in[ ((i*2+2)&inHeightMask)*inWidth + ((j*2)&inWidthMask) ])[k] +
+					2 * ((byte *)&in[ ((i*2+2)&inHeightMask)*inWidth + ((j*2+1)&inWidthMask) ])[k] +
+					1 * ((byte *)&in[ ((i*2+2)&inHeightMask)*inWidth + ((j*2+2)&inWidthMask) ])[k];
+				outpix[k] = total / 36;
+			}
+		}
+	}
+
+	memcpy( in, temp, outWidth * outHeight * 4 );
+	Z_Free( temp );
+}
+
+/*
+================
+R_MipMap
+
+Operates in place, quartering the size of the texture
+================
+*/
+static void R_MipMap (byte *in, int width, int height) {
+	int		i, j;
+	byte	*out;
+	int		row;
+
+	if ( width == 1 && height == 1 ) {
+		return;
+	}
+
+	if ( !r_simpleMipMaps->integer ) {
+		R_MipMap2( (unsigned *)in, width, height );
+		return;
+	}
+
+	row = width * 4;
+	out = in;
+	width >>= 1;
+	height >>= 1;
+
+	if ( width == 0 || height == 0 ) {
+		width += height;	// get largest
+		for (i=0 ; i<width ; i++, out+=4, in+=8 ) {
+			out[0] = ( in[0] + in[4] )>>1;
+			out[1] = ( in[1] + in[5] )>>1;
+			out[2] = ( in[2] + in[6] )>>1;
+			out[3] = ( in[3] + in[7] )>>1;
+		}
+		return;
+	}
+
+	for (i=0 ; i<height ; i++, in+=row) {
+		for (j=0 ; j<width ; j++, out+=4, in+=8) {
+			out[0] = (in[0] + in[4] + in[row+0] + in[row+4])>>2;
+			out[1] = (in[1] + in[5] + in[row+1] + in[row+5])>>2;
+			out[2] = (in[2] + in[6] + in[row+2] + in[row+6])>>2;
+			out[3] = (in[3] + in[7] + in[row+3] + in[row+7])>>2;
+		}
+	}
+}
+
+
+/*
+==================
+R_BlendOverTexture
+
+Apply a color blend over a set of pixels
+==================
+*/
+static void R_BlendOverTexture( byte *data, int pixelCount, byte blend[4] ) {
+	int		i;
+	int		inverseAlpha;
+	int		premult[3];
+
+	inverseAlpha = 255 - blend[3];
+	premult[0] = blend[0] * blend[3];
+	premult[1] = blend[1] * blend[3];
+	premult[2] = blend[2] * blend[3];
+
+	for ( i = 0 ; i < pixelCount ; i++, data+=4 ) {
+		data[0] = ( data[0] * inverseAlpha + premult[0] ) >> 9;
+		data[1] = ( data[1] * inverseAlpha + premult[1] ) >> 9;
+		data[2] = ( data[2] * inverseAlpha + premult[2] ) >> 9;
+	}
+}
+
+byte	mipBlendColors[16][4] = {
+	{0,0,0,0},
+	{255,0,0,128},
+	{0,255,0,128},
+	{0,0,255,128},
+	{255,0,0,128},
+	{0,255,0,128},
+	{0,0,255,128},
+	{255,0,0,128},
+	{0,255,0,128},
+	{0,0,255,128},
+	{255,0,0,128},
+	{0,255,0,128},
+	{0,0,255,128},
+	{255,0,0,128},
+	{0,255,0,128},
+	{0,0,255,128},
+};
+
+
+/*
+===============
+Upload32
+
+===============
+*/
+static void Upload32( unsigned *data, 
+						  int img_width, int img_height, 
+						  GLenum format,
+						  int mipcount, 
+						  qboolean picmip, 
+						  qboolean isLightmap, 
+						  int *pformat )
+{
+	if (format == GL_RGBA)
+	{
+		int			samples;
+		int			i, c;
+		byte		*scan;
+		int			width = img_width;
+		int			height = img_height; 
+		
+		//
+		// perform optional picmip operation
+		//
+		if ( picmip ) {
+			for(i = 0; i < r_picmip->integer; i++) {
+				R_MipMap( (byte *)data, width, height );
+				width >>= 1;
+				height >>= 1;
+				if (width < 1) {
+					width = 1;
+				}
+				if (height < 1) {
+					height = 1;
+				}
+			}
+		}
+		
+		//
+		// clamp to the current upper OpenGL limit
+		// scale both axis down equally so we don't have to
+		// deal with a half mip resampling
+		//
+		while ( width > glConfig.maxTextureSize	|| height > glConfig.maxTextureSize ) {
+			R_MipMap( (byte *)data, width, height );
+			width >>= 1;
+			height >>= 1;
+		}
+		
+		//
+		// scan the texture for each channel's max values
+		// and verify if the alpha channel is being used or not
+		//
+		c = width*height;
+		scan = ((byte *)data);
+		samples = 3;
+		for ( i = 0; i < c; i++ )
+		{
+			if ( scan[i*4 + 3] != 255 ) 
+			{
+				samples = 4;
+				break;
+			}
+		}
+		
+		// select proper internal format
+		if ( samples == 3 )
+		{
+			if ( isLightmap && r_texturebitslm->integer > 0 )
+			{
+				// Allow different bit depth when we are a lightmap
+				if ( r_texturebitslm->integer == 16 )
+				{
+					*pformat = GL_RGB5;
+				}
+				else if ( r_texturebitslm->integer == 32 )
+				{
+					*pformat = GL_RGB8;
+				}
+			}
+			else if ( r_texturebits->integer == 16 )
+			{
+				*pformat = GL_RGB5;
+			}
+			else if ( r_texturebits->integer == 32 )
+			{
+				*pformat = GL_RGB8;
+			}
+			else
+			{
+				*pformat = 3;
+			}
+		}
+		else if ( samples == 4 )
+		{
+			if ( r_texturebits->integer == 16 )
+			{
+				*pformat = GL_RGBA4;
+			}
+			else if ( r_texturebits->integer == 32 )
+			{
+				*pformat = GL_RGBA8;
+			}
+			else
+			{
+				*pformat = 4;
+			}
+		}
+		
+		// copy or resample data as appropriate for first MIP level
+		if (!mipcount)
+		{
+			qglTexImage2D (GL_TEXTURE_2D, 0, *pformat, width, height, 0, 
+				GL_RGBA, GL_UNSIGNED_BYTE, data);
+		}
+		else
+		{
+			if (mipcount)
+			{
+				int	miplevel = 0;
+				int total = 1;
+				int n = width;
+				if (height > n) n = height;
+				while (n > 1)
+				{
+					n >>= 1;
+					++total;
+				}
+				
+				qglTexImage2DEXT (GL_TEXTURE_2D, 0, total, *pformat, width, height, 
+					0, GL_RGBA, GL_UNSIGNED_BYTE, data );
+			}
+		}
+	}
+	else
+	{
+		*pformat = format;
+
+		qglTexImage2DEXT (GL_TEXTURE_2D, 0, mipcount,
+			format, img_width, img_height, 0, format, 
+			GL_UNSIGNED_BYTE, data);
+	}
+
+	if (mipcount)
+	{
+		qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, gl_filter_min);
+		qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, gl_filter_max);
+		if(r_ext_texture_filter_anisotropic->integer>1 && glConfig.maxTextureFilterAnisotropy>0)
+		{
+			qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, r_ext_texture_filter_anisotropic->value); // 2.0f
+		}
+	}
+	else
+	{
+		qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
+		qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
+	}
+
+	GL_CheckErrors();
+}
+
+
+
+typedef tmap (int, image_t *)	AllocatedImages_t;
+								AllocatedImages_t* AllocatedImages = NULL;
+								AllocatedImages_t::iterator itAllocatedImages;
+
+int giTextureBindNum = 1024;	// will be set to this anyway at runtime, but wtf?
+
+
+// return = number of images in the list, for those interested
+//
+int R_Images_StartIteration(void)
+{
+	if(!AllocatedImages)
+		return 0;
+
+	itAllocatedImages = AllocatedImages->begin();
+	return AllocatedImages->size();
+}
+
+image_t *R_Images_GetNextIteration(void)
+{
+	if(!AllocatedImages)
+		return NULL;
+
+	if (itAllocatedImages == AllocatedImages->end())
+		return NULL;
+
+	image_t *pImage = (*itAllocatedImages).second;
+	++itAllocatedImages;
+	return pImage;
+}
+
+
+// clean up anything to do with an image_t struct, but caller will have to clear the internal to an image_t struct ready for either struct free() or overwrite...
+//
+static void R_Images_DeleteImageContents( image_t *pImage )
+{
+	assert(pImage);	// should never be called with NULL
+	if (pImage)
+	{
+		qglDeleteTextures( 1, &pImage->texnum );
+		Z_Free(pImage);
+	}
+}
+
+static void GL_ResetBinds(void)
+{
+	memset( glState.currenttextures, 0, sizeof( glState.currenttextures ) );
+	if ( qglBindTexture ) 
+	{
+		if ( qglActiveTextureARB ) 
+		{
+			GL_SelectTexture( 1 );
+			qglBindTexture( GL_TEXTURE_2D, 0 );
+			GL_SelectTexture( 0 );
+			qglBindTexture( GL_TEXTURE_2D, 0 );
+		} 
+		else 
+		{
+			qglBindTexture( GL_TEXTURE_2D, 0 );
+		}
+	}
+}
+
+// special function used in conjunction with "devmapbsp"...
+//
+void R_Images_DeleteLightMaps(void)
+{
+	qboolean bEraseOccured = qfalse;
+	for (AllocatedImages_t::iterator itImage = AllocatedImages->begin(); itImage != AllocatedImages->end(); bEraseOccured?itImage:++itImage)
+	{			
+		bEraseOccured = qfalse;
+
+		image_t *pImage = (*itImage).second;
+		
+		if (pImage->isLightmap)
+		{
+			R_Images_DeleteImageContents(pImage);
+
+			AllocatedImages->erase(itImage++);
+			bEraseOccured = qtrue;
+		}
+	}
+
+	GL_ResetBinds();
+}
+
+
+// special function currently only called by Dissolve code...
+//
+void R_Images_DeleteImage(image_t *pImage)
+{		
+	// Even though we supply the image handle, we need to get the corresponding iterator entry...
+	//
+	AllocatedImages_t::iterator itImage = AllocatedImages->find(pImage->imgCode);
+	if (itImage != AllocatedImages->end())
+	{		
+		R_Images_DeleteImageContents(pImage);
+		AllocatedImages->erase(itImage);
+	}
+	else
+	{
+		assert(0);
+	}
+}
+
+
+// called only at app startup, vid_restart, app-exit
+//
+void R_Images_Clear(void)
+{		
+	image_t *pImage;
+	//	int iNumImages = 
+	   				  R_Images_StartIteration();
+	while ( (pImage = R_Images_GetNextIteration()) != NULL)
+	{
+		R_Images_DeleteImageContents(pImage);
+	}
+
+	AllocatedImages->clear();
+
+	giTextureBindNum = 1024;
+}
+
+
+void RE_RegisterImages_Info_f( void )
+{
+
+}
+
+
+// implement this if you need to, do a find for the caller. I don't need it though, so far.
+//
+//void		RE_RegisterImages_LevelLoadBegin(const char *psMapName);
+
+
+// currently, this just goes through all the images and dumps any not referenced on this level...
+//
+qboolean RE_RegisterImages_LevelLoadEnd(void)
+{
+	qboolean bEraseOccured = qfalse;
+	for (AllocatedImages_t::iterator itImage = AllocatedImages->begin(); itImage != AllocatedImages->end(); bEraseOccured?itImage:++itImage)
+	{			
+		bEraseOccured = qfalse;
+
+		image_t *pImage = (*itImage).second;
+
+		// don't un-register system shaders (*fog, *dlight, *white, *default), but DO de-register lightmaps ("$<mapname>/lightmap%d")
+		if (!pImage->isSystem)
+		{
+			// image used on this level?
+			//
+			if ( pImage->iLastLevelUsedOn != RE_RegisterMedia_GetLevel() )
+			{	// nope, so dump it...
+				//Com_Printf( PRINT_DEVELOPER, "Dumping image \"%s\"\n",pImage->imgName);
+				R_Images_DeleteImageContents(pImage);
+				itImage = AllocatedImages->erase(itImage);
+				bEraseOccured = qtrue;
+			}
+		}
+	}
+
+	GL_ResetBinds();
+
+	return bEraseOccured;
+}
+
+
+// returns image_t struct if we already have this, else NULL. No disk-open performed 
+//	(important for creating default images).
+//
+// This is called by both R_FindImageFile and anything that creates default images...
+//
+static image_t *R_FindImageFile_NoLoad(const char *name, int mipcount, qboolean allowPicmip, int glWrapClampMode )
+{	
+	if (!name) {
+		return NULL;
+	}
+
+	char *pName = GenerateImageMappingName(name);
+
+	//
+	// see if the image is already loaded
+	//
+	int code = crc32(0, (const Bytef *)pName, strlen(pName));
+	AllocatedImages_t::iterator itAllocatedImage = AllocatedImages->find(code);
+	if (itAllocatedImage != AllocatedImages->end())
+	{	
+		image_t *pImage = (*itAllocatedImage).second;
+
+		// the white image can be used with any set of parms, but other mismatches are errors...
+		//
+		if ( strcmp( pName, "*white" ) ) {
+			if ( !pImage->mipcount != !mipcount ) {
+				// Test is more lax, but also prevents tons of false positives
+				Com_Printf( "WARNING: reused image %s with mixed mipmap parm\n", pName );
+			}
+			if ( pImage->allowPicmip != !!allowPicmip ) {
+				Com_Printf( "WARNING: reused image %s with mixed allowPicmip parm\n", pName );
+			}
+		}
+
+		pImage->iLastLevelUsedOn = RE_RegisterMedia_GetLevel();
+			  
+		return pImage;
+	}
+
+	return NULL;
+}
+
+
+/*
+================
+R_CreateImage
+
+This is the only way any image_t are created
+================
+*/
+image_t *R_CreateImage( const char *name, const byte *pic, int width, int height, 
+					   GLenum format, int mipcount, qboolean allowPicmip, 
+					   int glWrapClampMode )
+{
+	image_t		*image;
+	qboolean	isLightmap = qfalse;
+
+	if (strlen(name) >= MAX_QPATH ) {
+		Com_Error (ERR_DROP, "R_CreateImage: \"%s\" is too long\n", name);
+	}
+
+	if(glConfig.clampToEdgeAvailable && glWrapClampMode == GL_CLAMP) {
+		glWrapClampMode = GL_CLAMP_TO_EDGE;
+	}
+
+	if (name[0] == '$')
+	{
+		isLightmap = qtrue;
+	}
+
+	if ( (width&(width-1)) || (height&(height-1)) )
+	{
+		Com_Error( ERR_FATAL, "R_CreateImage: %s dimensions (%i x %i) not power of 2!\n",name,width,height);
+	}
+
+	image = R_FindImageFile_NoLoad(name, mipcount, allowPicmip, glWrapClampMode );
+	if (image) {
+		return image;
+	}
+
+	image = (image_t*) Z_Malloc( sizeof( image_t ), TAG_IMAGE_T, qtrue );
+	
+	qglGenTextures(1, (GLuint*)&image->texnum);
+
+	image->iLastLevelUsedOn = RE_RegisterMedia_GetLevel();
+
+	image->mipcount = mipcount;
+	image->allowPicmip = allowPicmip;
+
+	image->imgCode = crc32(0, (const Bytef *)name, strlen(name));
+
+	image->width = width;
+	image->height = height;
+
+	image->isSystem = (name[0] == '*');
+	image->isLightmap = isLightmap;
+
+	GL_SelectTexture( 0 );
+
+	GL_Bind(image);
+
+	Upload32( (unsigned *)pic,	image->width, image->height, 
+								format,
+								image->mipcount,
+								allowPicmip, 
+								isLightmap, 
+								&image->internalFormat );
+
+	qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, glWrapClampMode );
+	qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, glWrapClampMode );
+
+	qglBindTexture( GL_TEXTURE_2D, 0 );	//jfm: i don't know why this is here, but it breaks lightmaps when there's only 1
+	glState.currenttextures[glState.currenttmu] = 0;	//mark it not bound
+
+	const char* psNewName = GenerateImageMappingName(name);
+	image->imgCode = crc32(0, (const Bytef *)psNewName, strlen(psNewName));
+
+	(*AllocatedImages)[ image->imgCode ] = image;
+
+	return image;
+}
+
+
+void R_CreateAutomapImage( const char *name, const byte *pic, int width, int height, 
+					   qboolean mipmap, qboolean allowPicmip, qboolean allowTC, int glWrapClampMode ) 
+{
+	R_CreateImage(name, pic, width, height, GL_RGBA, mipmap, allowPicmip, glWrapClampMode);
+}
+
+/*
+=========================================================
+
+TARGA LOADING
+
+=========================================================
+*/
+
+/*
+Ghoul2 Insert Start
+*/
+
+bool LoadTGAPalletteImage ( const char *name, byte **pic, int *width, int *height)
+{
+	int		columns, rows, numPixels;
+	byte	*buf_p;
+	byte	*buffer;
+	TargaHeader	targa_header;
+	byte	*dataStart;
+
+	*pic = NULL;
+
+	//
+	// load the file
+	//
+	FS_ReadFile ( ( char * ) name, (void **)&buffer);
+	if (!buffer) {
+		return false;
+	}
+
+	buf_p = buffer;
+
+	targa_header.id_length = *buf_p++;
+	targa_header.colormap_type = *buf_p++;
+	targa_header.image_type = *buf_p++;
+	
+	targa_header.colormap_index = LittleShort ( *(short *)buf_p );
+	buf_p += 2;
+	targa_header.colormap_length = LittleShort ( *(short *)buf_p );
+	buf_p += 2;
+	targa_header.colormap_size = *buf_p++;
+	targa_header.x_origin = LittleShort ( *(short *)buf_p );
+	buf_p += 2;
+	targa_header.y_origin = LittleShort ( *(short *)buf_p );
+	buf_p += 2;
+	targa_header.width = LittleShort ( *(short *)buf_p );
+	buf_p += 2;
+	targa_header.height = LittleShort ( *(short *)buf_p );
+	buf_p += 2;
+	targa_header.pixel_size = *buf_p++;
+	targa_header.attributes = *buf_p++;
+
+	if (targa_header.image_type!=1 )
+	{
+		Com_Error (ERR_DROP, "LoadTGAPalletteImage: Only type 1 (uncompressed pallettised) TGA images supported\n");
+	}
+
+	if ( targa_header.colormap_type == 0 )
+	{
+		Com_Error( ERR_DROP, "LoadTGAPalletteImage: colormaps ONLY supported\n" );
+	}
+
+	columns = targa_header.width;
+	rows = targa_header.height;
+	numPixels = columns * rows;
+
+	if (width)
+		*width = columns;
+	if (height)
+		*height = rows;
+
+	*pic = (unsigned char *) Z_Malloc (numPixels, TAG_TEMP_WORKSPACE, qfalse);
+	if (targa_header.id_length != 0)
+	{
+		buf_p += targa_header.id_length;  // skip TARGA image comment
+	}
+	dataStart = buf_p + (targa_header.colormap_length * (targa_header.colormap_size / 4));
+	memcpy(*pic, dataStart, numPixels);
+	FS_FreeFile (buffer);
+
+	return true;
+}
+
+/*
+Ghoul2 Insert End
+*/
+
+
+// My TGA loader...
+//
+//---------------------------------------------------
+#pragma pack(push,1)
+typedef struct
+{
+	byte	byIDFieldLength;	// must be 0
+	byte	byColourmapType;	// 0 = truecolour, 1 = paletted, else bad
+	byte	byImageType;		// 1 = colour mapped (palette), uncompressed, 2 = truecolour, uncompressed, else bad
+	word	w1stColourMapEntry;	// must be 0
+	word	wColourMapLength;	// 256 for 8-bit palettes, else 0 for true-colour
+	byte	byColourMapEntrySize; // 24 for 8-bit palettes, else 0 for true-colour
+	word	wImageXOrigin;		// ignored
+	word	wImageYOrigin;		// ignored
+	word	wImageWidth;		// in pixels
+	word	wImageHeight;		// in pixels
+	byte	byImagePlanes;		// bits per pixel	(8 for paletted, else 24 for true-colour)
+	byte	byScanLineOrder;	// Image descriptor bytes
+								// bits 0-3 = # attr bits (alpha chan)
+								// bits 4-5 = pixel order/dir
+								// bits 6-7 scan line interleave (00b=none,01b=2way interleave,10b=4way)
+} TGAHeader_t;
+#pragma pack(pop)
+
+
+// *pic == pic, else NULL for failed.
+//
+//  returns false if found but had a format error, else true for either OK or not-found (there's a reason for this)
+//
+
+void LoadTGA ( const char *name, byte **pic, int *width, int *height)
+{
+	char sErrorString[1024];
+	bool bFormatErrors = false;
+
+	// these don't need to be declared or initialised until later, but the compiler whines that 'goto' skips them.
+	//
+	byte *pRGBA = NULL;	
+	byte *pOut	= NULL;
+	byte *pIn	= NULL;
+
+
+	*pic = NULL;
+
+#define TGA_FORMAT_ERROR(blah) {sprintf(sErrorString,blah); bFormatErrors = true; goto TGADone;}
+//#define TGA_FORMAT_ERROR(blah) Com_Error( ERR_DROP, blah );
+
+	//
+	// load the file
+	//
+	byte *pTempLoadedBuffer = 0;
+	FS_ReadFile ( ( char * ) name, (void **)&pTempLoadedBuffer);
+	if (!pTempLoadedBuffer) {
+		return;
+	}
+
+	TGAHeader_t *pHeader = (TGAHeader_t *) pTempLoadedBuffer;
+
+	if (pHeader->byColourmapType!=0)
+	{	
+		TGA_FORMAT_ERROR("LoadTGA: colourmaps not supported\n" );		
+	}
+
+	if (pHeader->byImageType != 2 && pHeader->byImageType != 3 && pHeader->byImageType != 10)
+	{
+		TGA_FORMAT_ERROR("LoadTGA: Only type 2 (RGB), 3 (gray), and 10 (RLE-RGB) images supported\n");		
+	}
+		
+	if (pHeader->w1stColourMapEntry != 0)
+	{
+		TGA_FORMAT_ERROR("LoadTGA: colourmaps not supported\n" );		
+	}
+
+	if (pHeader->wColourMapLength !=0 && pHeader->wColourMapLength != 256)
+	{
+		TGA_FORMAT_ERROR("LoadTGA: ColourMapLength must be either 0 or 256\n" );
+	}
+
+	if (pHeader->byColourMapEntrySize != 0 && pHeader->byColourMapEntrySize != 24)
+	{
+		TGA_FORMAT_ERROR("LoadTGA: ColourMapEntrySize must be either 0 or 24\n" );
+	}
+
+	if ( ( pHeader->byImagePlanes != 24 && pHeader->byImagePlanes != 32) && (pHeader->byImagePlanes != 8 && pHeader->byImageType != 3))
+	{
+		TGA_FORMAT_ERROR("LoadTGA: Only type 2 (RGB), 3 (gray), and 10 (RGB) TGA images supported\n");
+	}
+
+	if ((pHeader->byScanLineOrder&0x30)!=0x00 &&
+		(pHeader->byScanLineOrder&0x30)!=0x10 &&
+		(pHeader->byScanLineOrder&0x30)!=0x20 &&
+		(pHeader->byScanLineOrder&0x30)!=0x30
+		)
+	{
+		TGA_FORMAT_ERROR("LoadTGA: ScanLineOrder must be either 0x00,0x10,0x20, or 0x30\n");		
+	}
+
+
+
+	// these last checks are so i can use ID's RLE-code. I don't dare fiddle with it or it'll probably break...
+	//
+	if ( pHeader->byImageType == 10)
+	{
+		if ((pHeader->byScanLineOrder & 0x30) != 0x00)
+		{
+			TGA_FORMAT_ERROR("LoadTGA: RLE-RGB Images (type 10) must be in bottom-to-top format\n");
+		}
+		if (pHeader->byImagePlanes != 24 && pHeader->byImagePlanes != 32)	// probably won't happen, but avoids compressed greyscales?
+		{
+			TGA_FORMAT_ERROR("LoadTGA: RLE-RGB Images (type 10) must be 24 or 32 bit\n");
+		}
+	}
+
+	// now read the actual bitmap in...
+	//
+	// Image descriptor bytes
+	// bits 0-3 = # attr bits (alpha chan)
+	// bits 4-5 = pixel order/dir
+	// bits 6-7 scan line interleave (00b=none,01b=2way interleave,10b=4way)
+	//
+	int iYStart,iXStart,iYStep,iXStep;
+
+	switch(pHeader->byScanLineOrder & 0x30)		
+	{
+		default:	// default case stops the compiler complaining about using uninitialised vars
+		case 0x00:					//	left to right, bottom to top
+
+			iXStart = 0;
+			iXStep  = 1;
+
+			iYStart = pHeader->wImageHeight-1;
+			iYStep  = -1;
+
+			break;
+
+		case 0x10:					//  right to left, bottom to top
+
+			iXStart = pHeader->wImageWidth-1;
+			iXStep  = -1;
+
+			iYStart = pHeader->wImageHeight-1;
+			iYStep	= -1;
+
+			break;
+
+		case 0x20:					//  left to right, top to bottom
+
+			iXStart = 0;
+			iXStep  = 1;
+
+			iYStart = 0;
+			iYStep  = 1;
+
+			break;
+
+		case 0x30:					//  right to left, top to bottom
+
+			iXStart = pHeader->wImageWidth-1;
+			iXStep  = -1;
+
+			iYStart = 0;
+			iYStep  = 1;
+
+			break;
+	}
+
+	// feed back the results...
+	//
+	if (width)
+		*width = pHeader->wImageWidth;
+	if (height)
+		*height = pHeader->wImageHeight;
+
+	pRGBA	= (byte *) Z_Malloc (pHeader->wImageWidth * pHeader->wImageHeight * 4, TAG_TEMP_WORKSPACE, qfalse);
+	*pic	= pRGBA;
+	pOut	= pRGBA;
+	pIn		= pTempLoadedBuffer + sizeof(*pHeader);
+
+	// I don't know if this ID-thing here is right, since comments that I've seen are at the end of the file, 
+	//	with a zero in this field. However, may as well...
+	//
+	if (pHeader->byIDFieldLength != 0)
+		pIn += pHeader->byIDFieldLength;	// skip TARGA image comment
+
+	byte red,green,blue,alpha;
+
+	if ( pHeader->byImageType == 2 || pHeader->byImageType == 3 )	// RGB or greyscale
+	{
+		for (int y=iYStart, iYCount=0; iYCount<pHeader->wImageHeight; y+=iYStep, iYCount++)
+		{
+			pOut = pRGBA + y * pHeader->wImageWidth *4;			
+			for (int x=iXStart, iXCount=0; iXCount<pHeader->wImageWidth; x+=iXStep, iXCount++)
+			{
+				switch (pHeader->byImagePlanes)
+				{
+					case 8:
+						blue	= *pIn++;
+						green	= blue;
+						red		= blue;
+						*pOut++ = red;
+						*pOut++ = green;
+						*pOut++ = blue;
+						*pOut++ = 255;
+						break;
+
+					case 24:
+						blue	= *pIn++;
+						green	= *pIn++;
+						red		= *pIn++;
+						*pOut++ = red;
+						*pOut++ = green;
+						*pOut++ = blue;
+						*pOut++ = 255;
+						break;
+
+					case 32:
+						blue	= *pIn++;
+						green	= *pIn++;
+						red		= *pIn++;
+						alpha	= *pIn++;
+						*pOut++ = red;
+						*pOut++ = green;
+						*pOut++ = blue;
+						*pOut++ = alpha;
+						break;
+					
+					default:
+						assert(0);	// if we ever hit this, someone deleted a header check higher up
+						TGA_FORMAT_ERROR("LoadTGA: Image can only have 8, 24 or 32 planes for RGB/greyscale\n");						
+						break;
+				}
+			}		
+		}
+	}
+	else 
+	if (pHeader->byImageType == 10)   // RLE-RGB
+	{
+		// I've no idea if this stuff works, I normally reject RLE targas, but this is from ID's code
+		//	so maybe I should try and support it...
+		//
+		byte packetHeader, packetSize, j;
+
+		for (int y = pHeader->wImageHeight-1; y >= 0; y--)
+		{
+			pOut = pRGBA + y * pHeader->wImageWidth *4;
+			for (int x=0; x<pHeader->wImageWidth;)
+			{
+				packetHeader = *pIn++;
+				packetSize   = 1 + (packetHeader & 0x7f);
+				if (packetHeader & 0x80)         // run-length packet
+				{
+					switch (pHeader->byImagePlanes) 
+					{
+						case 24:
+
+							blue	= *pIn++;
+							green	= *pIn++;
+							red		= *pIn++;
+							alpha	= 255;
+							break;
+
+						case 32:
+							
+							blue	= *pIn++;
+							green	= *pIn++;
+							red		= *pIn++;
+							alpha	= *pIn++;
+							break;
+
+						default:
+							assert(0);	// if we ever hit this, someone deleted a header check higher up
+							TGA_FORMAT_ERROR("LoadTGA: RLE-RGB can only have 24 or 32 planes\n");
+							break;
+					}
+	
+					for (j=0; j<packetSize; j++) 
+					{
+						*pOut++	= red;
+						*pOut++	= green;
+						*pOut++	= blue;
+						*pOut++	= alpha;
+						x++;
+						if (x == pHeader->wImageWidth)  // run spans across rows
+						{
+							x = 0;
+							if (y > 0)
+								y--;
+							else
+								goto breakOut;
+							pOut = pRGBA + y * pHeader->wImageWidth * 4;
+						}
+					}
+				}
+				else 
+				{	// non run-length packet
+
+					for (j=0; j<packetSize; j++) 
+					{
+						switch (pHeader->byImagePlanes) 
+						{
+							case 24:
+
+								blue	= *pIn++;
+								green	= *pIn++;
+								red		= *pIn++;
+								*pOut++ = red;
+								*pOut++ = green;
+								*pOut++ = blue;
+								*pOut++ = 255;
+								break;
+
+							case 32:
+								blue	= *pIn++;
+								green	= *pIn++;
+								red		= *pIn++;
+								alpha	= *pIn++;
+								*pOut++ = red;
+								*pOut++ = green;
+								*pOut++ = blue;
+								*pOut++ = alpha;
+								break;
+
+							default:
+								assert(0);	// if we ever hit this, someone deleted a header check higher up
+								TGA_FORMAT_ERROR("LoadTGA: RLE-RGB can only have 24 or 32 planes\n");
+								break;
+						}
+						x++;
+						if (x == pHeader->wImageWidth)  // pixel packet run spans across rows
+						{
+							x = 0;
+							if (y > 0)
+								y--;
+							else
+								goto breakOut;
+							pOut = pRGBA + y * pHeader->wImageWidth * 4;
+						}
+					}
+				}
+			}
+			breakOut:;
+		}
+	}
+
+TGADone:
+
+	FS_FreeFile (pTempLoadedBuffer);
+
+	if (bFormatErrors)
+	{
+		Com_Error( ERR_DROP, "%s( File: \"%s\" )\n",sErrorString,name);
+	}
+}
+
+/*
+=========================================================
+
+DDS LOADING
+
+=========================================================
+*/
+
+void LoadDDS ( const char *name, byte **pic, int *width, int *height, int *mipcount, GLenum *format )
+{
+	fileHandle_t h;
+	int len = FS_FOpenFileRead( name, &h, qfalse );
+	if ( h == 0 )
+	{
+		return;
+	}
+	
+	*pic = (byte*)Z_Malloc( len, TAG_TEMP_WORKSPACE, qfalse , 32);
+	FS_Read( *pic, len, h );
+	FS_FCloseFile( h );
+
+	DWORD dds = MAKEFOURCC('D', 'D', 'S', ' ');
+	if (*(DWORD*)(*pic) != dds)
+	{
+		FS_FreeFile (*pic);
+		*pic = NULL;
+		return;
+	}
+	
+	DDS_HEADER *desc = (DDS_HEADER *)(*pic + sizeof(DWORD));
+	DWORD dxt1 = MAKEFOURCC('D', 'X', 'T', '1');
+	DWORD dxt5 = MAKEFOURCC('D', 'X', 'T', '5');
+	
+	if (desc->ddspf.dwFourCC == dxt1)
+	{
+		*format = GL_DDS1_EXT;
+	}
+	else if (desc->ddspf.dwFourCC == dxt5)
+	{
+		*format = GL_DDS5_EXT;
+	}
+	else if (desc->ddspf.dwRGBBitCount == 16)
+	{
+		*format = GL_DDS_RGB16_EXT;
+	}
+	else if (desc->ddspf.dwRGBBitCount == 32)
+	{
+		*format = GL_DDS_RGBA32_EXT;
+	}
+	else
+	{
+		FS_FreeFile (*pic);
+		*pic = NULL;
+		return;
+	}
+
+	*width = desc->dwWidth;
+	*height = desc->dwHeight;
+	*mipcount = desc->dwMipMapCount;
+}
+
+
+//===================================================================
+
+/*
+=================
+R_LoadImage
+
+Loads any of the supported image types into a cannonical
+32 bit format.
+=================
+*/
+void R_LoadImage( const char *shortname, byte **pic, int *width, int *height, int *mipcount, GLenum *format ) {
+	int		bytedepth;
+	char	name[MAX_QPATH];
+
+	*pic = NULL;
+	*width = 0;
+	*height = 0;
+
+	//handle external LMs
+	if (shortname[0] == '$') {
+		Q_strncpyz( name, shortname+1, sizeof( name ) );
+	} else {
+		Q_strncpyz( name, shortname, sizeof( name ) );
+	}
+
+	*format = GL_RGBA;
+	*mipcount = 1;
+
+	COM_StripExtension(name,name);
+	COM_DefaultExtension(name, sizeof(name), ".tga");
+	LoadTGA( name, pic, width, height );
+
+	if (*pic)
+	{
+		int j = (*width) * (*height) * 4;
+		byte *buf = *pic;
+		byte swap;
+		for (int i = 0 ; i < j ; i+=4 ) {
+			swap = buf[i];
+			buf[i] = buf[i+2];
+			buf[i+2] = swap;
+		}
+		return;
+	}
+
+	COM_StripExtension(name,name);
+	COM_DefaultExtension(name, sizeof(name), ".png");	
+	
+	//No .tga existed, try .png
+	LoadPNG32( name, pic, width, height, &bytedepth );
+	if (*pic)
+	{
+		return;
+	}
+
+	// No .png either, fall back to .dds
+	COM_StripExtension(name,name);
+	COM_DefaultExtension(name, sizeof(name), ".dds");
+	LoadDDS( name, pic, width, height, mipcount, format );
+	return;
+}
+
+
+void R_LoadDataImage( const char *name, byte **pic, int *width, int *height)
+{
+	int		len;
+	char	work[MAX_QPATH];
+
+	*pic = NULL;
+	*width = 0;
+	*height = 0;
+
+	len = strlen(name);
+	if(len >= MAX_QPATH)
+	{
+		return;
+	}
+	if (len < 5)
+	{
+		return;
+	}
+//	MD_PushTag(TAG_DATA_IMAGE_LOAD);
+
+	strcpy(work, name);
+
+	COM_DefaultExtension( work, sizeof( work ), ".png" );
+	LoadPNG8( work, pic, width, height );
+
+	if (!pic || !*pic)
+	{ //both png and jpeg failed, try targa
+		strcpy(work, name);
+		COM_DefaultExtension( work, sizeof( work ), ".tga" );
+		LoadTGA( work, pic, width, height );
+	}
+
+	if(*pic)
+	{
+//		MD_PopTag();
+		return;
+	}
+	// Dataimage loading failed
+	Com_Printf("Couldn't read %s -- dataimage load failed\n", name);
+//	MD_PopTag();
+}
+
+void R_InvertImage(byte *data, int width, int height, int depth)
+{
+	byte	*newData;
+	byte	*oldData;
+	byte	*saveData;
+	int		y, stride;
+
+	stride = width * depth;
+
+	oldData = data + ((height - 1) * stride);
+	newData = (byte *)Z_Malloc(height * stride, TAG_TEMP_WORKSPACE, qfalse );
+	saveData = newData;
+
+	for(y = 0; y < height; y++)
+	{
+		memcpy(newData, oldData, stride);
+		newData += stride;
+		oldData -= stride;
+	}
+	memcpy(data, saveData, height * stride);
+	Z_Free(saveData);
+}
+
+// Lanczos3 image resampling. Better than bicubic, based on sin(x)/x algorithm
+
+#define	LANCZOS3	(3.0f)
+#define M_PI_OVER_3	(M_PI / 3.0f)
+
+typedef struct
+{
+	int		pixel;
+	float	weight;
+} contrib_t;
+
+typedef struct
+{
+	int			n;		// number of contributors
+	contrib_t	*p;		// pointer to list of contributions
+} contrib_list_t;
+
+// sin(x)/x * sin(x/3)/(x/3)
+
+float Lanczos3(float t)
+{
+	if(!t)
+	{
+		return(1.0f);
+	}
+	t = (float)fabs(t);
+	if(t < 3.0f)
+	{
+		return(sinf(t * M_PI) * sinf(t * M_PI_OVER_3) / (t * M_PI * t * M_PI_OVER_3));
+	}
+	return(0.0f);
+}
+
+void R_Resample(byte *source, int swidth, int sheight, byte *dest, int dwidth, int dheight, int components)
+{
+	int				i, j, k, l, count, left, right, num;
+	int				pixel;
+	byte			*raster;
+	float			center, weight, scale, width, height;
+	contrib_list_t	*contributors;
+	const memtag_t	usedTag = TAG_TEMP_WORKSPACE;
+
+	byte *work = (byte *)Z_Malloc(dwidth * sheight * components, usedTag, qfalse);
+
+	// Pre calculate filter contributions for rows
+	contributors = (contrib_list_t *)Z_Malloc(sizeof(contrib_list_t) * dwidth, usedTag, qfalse);
+
+	float xscale = (float)dwidth / (float)swidth;
+
+	if(xscale < 1.0f)
+	{
+		width = ceilf(LANCZOS3 / xscale);
+		scale = xscale;
+	}
+	else
+	{
+		width = LANCZOS3;
+		scale = 1.0f;
+	}
+	num = ((int)width * 2) + 1;
+
+	for(i = 0; i < dwidth; i++)
+	{
+		contributors[i].n = 0;
+		contributors[i].p = (contrib_t *)Z_Malloc(num * sizeof(contrib_t), usedTag, qfalse);
+
+		center = (float)i / xscale;
+		left = (int)ceilf(center - width);
+		right = (int)floorf(center + width);
+
+		for(j = left; j <= right; j++)
+		{
+			weight = Lanczos3((center - (float)j) * scale) * scale;
+			if(j < 0)
+			{
+				pixel = -j;
+			}
+			else if(j >= swidth)
+			{
+				pixel = (swidth - j) + swidth - 1;
+			}
+			else
+			{
+				pixel = j;
+			}
+			count = contributors[i].n++;
+			contributors[i].p[count].pixel = pixel;
+			contributors[i].p[count].weight = weight;
+		}
+	}
+	// Apply filters to zoom horizontally from source to work
+	for(k = 0; k < sheight; k++)
+	{
+		raster = source + (k * swidth * components);
+		for(i = 0; i < dwidth; i++)
+		{
+			for(l = 0; l < components; l++)
+			{
+				weight = 0.0f;
+				for(j = 0; j < contributors[i].n; j++)
+				{
+					weight += raster[(contributors[i].p[j].pixel * components) + l] * contributors[i].p[j].weight;
+				}
+				pixel = (byte)Com_Clamp(0.0f, 255.0f, weight);
+				work[(k * dwidth * components) + (i * components) + l] = pixel;
+			}
+		}
+	}
+	// Clean up
+	for(i = 0; i < dwidth; i++)
+	{
+		Z_Free(contributors[i].p);
+	}
+	Z_Free(contributors);
+
+	// Columns
+	contributors = (contrib_list_t *)Z_Malloc(sizeof(contrib_list_t) * dheight, usedTag, qfalse);
+
+	float yscale = (float)dheight / (float)sheight;
+	if(yscale < 1.0f)
+	{
+		height = ceilf(LANCZOS3 / yscale);
+		scale = yscale;
+	}
+	else
+	{
+		height = LANCZOS3;
+		scale = 1.0f;
+	}
+	num = ((int)height * 2) + 1;
+
+	for(i = 0; i < dheight; i++)
+	{
+		contributors[i].n = 0;
+		contributors[i].p = (contrib_t *)Z_Malloc(num * sizeof(contrib_t), usedTag, qfalse);
+
+		center = (float)i / yscale;
+		left = (int)ceilf(center - height);
+		right = (int)floorf(center + height);
+
+		for(j = left; j <= right; j++)
+		{
+			weight = Lanczos3((center - (float)j) * scale) * scale;
+			if(j < 0)
+			{
+				pixel = -j;
+			}
+			else if(j >= sheight)
+			{
+				pixel = (sheight - j) + sheight - 1;
+			}
+			else
+			{
+				pixel = j;
+			}
+			count = contributors[i].n++;
+			contributors[i].p[count].pixel = pixel;
+			contributors[i].p[count].weight = weight;
+		}
+	}
+	// Apply filter to columns
+	for(k = 0; k < dwidth; k++)
+	{
+		for(l = 0; l < components; l++)
+		{
+			for(i = 0; i < dheight; i++)
+			{
+				weight = 0.0f;
+				for(j = 0; j < contributors[i].n; j++)
+				{
+					weight += work[(contributors[i].p[j].pixel * dwidth * components) + (k * components) + l] * contributors[i].p[j].weight;
+				}
+				pixel = (byte)Com_Clamp(0.0f, 255.0f, weight);
+				dest[(i * dwidth * components) + (k * components) + l] = pixel;
+			}
+		}
+	}
+	// Clean up
+	for(i = 0; i < dheight; i++)
+	{
+		Z_Free(contributors[i].p);
+	}
+	Z_Free(contributors);
+	Z_Free(work);
+
+//	MD_PopTag();
+}
+
+/*
+===============
+R_FindImageFile
+
+Finds or loads the given image.
+Returns NULL if it fails, not a default image.
+==============
+*/
+image_t	*R_FindImageFile( const char *name, qboolean mipmap, qboolean allowPicmip, qboolean allowTC, int glWrapClampMode ) {
+	image_t	*image;
+	int		width, height;
+	int		mipcount;
+	byte	*pic;
+	GLenum	format;
+   
+	if (!name) {
+		return NULL;
+	}
+
+	// need to do this here as well as in R_CreateImage, or R_FindImageFile_NoLoad() may complain about
+	//	different clamp parms used...
+	//
+	if(glConfig.clampToEdgeAvailable && glWrapClampMode == GL_CLAMP) {
+		glWrapClampMode = GL_CLAMP_TO_EDGE;
+	}
+
+	image = R_FindImageFile_NoLoad(name, mipmap, allowPicmip, glWrapClampMode );
+	if (image) {
+		return image;
+	}
+
+	//
+	// load the pic from disk
+	//
+	R_LoadImage( name, &pic, &width, &height, &mipcount, &format );
+	if ( !pic ) {
+        return NULL;            
+	}
+
+	image = R_CreateImage( ( char * ) name, pic, width, height, format, mipcount, allowPicmip, glWrapClampMode );
+	Z_Free( pic );
+	return image;
+}
+
+/*
+================
+R_CreateDlightImage
+================
+*/
+#define	DLIGHT_SIZE	64
+static void R_CreateDlightImage( void ) 
+{
+	int		x,y;
+	byte	data[DLIGHT_SIZE][DLIGHT_SIZE][4];
+	int		xs, ys;
+	int b;
+
+	// The old code claims to have made a centered inverse-square falloff blob for dynamic lighting
+	//	and it looked nasty, so, just doing something simpler that seems to have a much softer result
+	for ( x = 0; x < DLIGHT_SIZE; x++ ) 
+	{
+		for ( y = 0; y < DLIGHT_SIZE; y++ ) 
+		{
+			xs = (DLIGHT_SIZE * 0.5f - x);
+			ys = (DLIGHT_SIZE * 0.5f - y);
+
+            b = 255 - sqrt( (float)(xs * xs + ys * ys) ) * 9.0f; // try and generate numbers in the range of 255-0
+
+			// should be close, but clamp anyway
+			if ( b > 255 ) 
+			{
+				b = 255;
+			} 
+			else if ( b < 0 ) 
+			{
+				b = 0;
+			}
+			data[y][x][0] = 
+			data[y][x][1] = 
+			data[y][x][2] = b;
+			data[y][x][3] = 255;			
+		}
+	}
+
+	tr.dlightImage = R_CreateImage("*dlight", (byte *)data, DLIGHT_SIZE, DLIGHT_SIZE, GL_RGBA, qfalse, qfalse, GL_CLAMP);
+}
+
+/*
+=================
+R_InitFogTable
+=================
+*/
+void R_InitFogTable( void ) {
+	int		i;
+	float	d;
+	float	exp;
+	
+	exp = 0.5;
+
+	for ( i = 0 ; i < FOG_TABLE_SIZE ; i++ ) {
+		d = pow ( (float)i/(FOG_TABLE_SIZE-1), exp );
+
+		tr.fogTable[i] = d;
+	}
+}
+
+/*
+================
+R_FogFactor
+
+Returns a 0.0 to 1.0 fog density value
+This is called for each texel of the fog texture on startup
+and for each vertex of transparent shaders in fog dynamically
+================
+*/
+float	R_FogFactor( float s, float t ) {
+	float	d;
+
+	s -= 1.0/512;
+	if ( s < 0 ) {
+		return 0;
+	}
+	if ( t < 1.0/32 ) {
+		return 0;
+	}
+	if ( t < 31.0/32 ) {
+		s *= (t - 1.0/32) / (30.0/32);
+	}
+
+	// we need to leave a lot of clamp range
+	s *= 8;
+
+	if ( s > 1.0 ) {
+		s = 1.0;
+	}
+
+	d = tr.fogTable[ (int)(s * (FOG_TABLE_SIZE-1)) ];
+
+	return d;
+}
+
+/*
+================
+R_CreateFogImage
+================
+*/
+#define	FOG_S	256
+#define	FOG_T	32
+static void R_CreateFogImage( void ) {
+	int		x,y;
+	byte	*data;
+	float	g;
+	float	d;
+	float	borderColor[4];
+
+	data = (byte*) Z_Malloc( FOG_S * FOG_T * 4, TAG_TEMP_WORKSPACE, qfalse );
+
+	g = 2.0;
+
+	// S is distance, T is depth
+	for (x=0 ; x<FOG_S ; x++) {
+		for (y=0 ; y<FOG_T ; y++) {
+			d = R_FogFactor( ( x + 0.5 ) / FOG_S, ( y + 0.5 ) / FOG_T );
+
+			data[(y*FOG_S+x)*4+0] = 
+			data[(y*FOG_S+x)*4+1] = 
+			data[(y*FOG_S+x)*4+2] = 255;
+			data[(y*FOG_S+x)*4+3] = 255*d;
+		}
+	}
+	// standard openGL clamping doesn't really do what we want -- it includes
+	// the border color at the edges.  OpenGL 1.2 has clamp-to-edge, which does
+	// what we want.
+	tr.fogImage = R_CreateImage("*fog", (byte *)data, FOG_S, FOG_T, GL_RGBA, qfalse, qfalse, GL_CLAMP);
+	Z_Free( data );
+
+	borderColor[0] = 1.0;
+	borderColor[1] = 1.0;
+	borderColor[2] = 1.0;
+	borderColor[3] = 1;
+
+	qglTexParameterfv( GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, borderColor );
+}
+
+/*
+==================
+R_CreateDefaultImage
+==================
+*/
+#define	DEFAULT_SIZE	16
+static void R_CreateDefaultImage( void ) {
+	int		x;
+	byte	data[DEFAULT_SIZE][DEFAULT_SIZE][4];
+
+	// the default image will be a box, to allow you to see the mapping coordinates
+	memset( data, 32, sizeof( data ) );
+	for ( x = 0 ; x < DEFAULT_SIZE ; x++ ) {
+		data[0][x][0] =
+		data[0][x][1] =
+		data[0][x][2] =
+		data[0][x][3] = 255;
+
+		data[x][0][0] =
+		data[x][0][1] =
+		data[x][0][2] =
+		data[x][0][3] = 255;
+
+		data[DEFAULT_SIZE-1][x][0] =
+		data[DEFAULT_SIZE-1][x][1] =
+		data[DEFAULT_SIZE-1][x][2] =
+		data[DEFAULT_SIZE-1][x][3] = 255;
+
+		data[x][DEFAULT_SIZE-1][0] =
+		data[x][DEFAULT_SIZE-1][1] =
+		data[x][DEFAULT_SIZE-1][2] =
+		data[x][DEFAULT_SIZE-1][3] = 255;
+	}
+	tr.defaultImage = R_CreateImage("*default", (byte *)data, DEFAULT_SIZE, DEFAULT_SIZE, GL_RGBA, qtrue, qfalse, GL_REPEAT);
+}
+
+/*
+==================
+R_CreateBuiltinImages
+==================
+*/
+void R_CreateBuiltinImages( void ) {
+	int		x,y;
+	byte	data[DEFAULT_SIZE][DEFAULT_SIZE][4];
+
+	R_CreateDefaultImage();
+
+	// we use a solid white image instead of disabling texturing
+	memset( data, 255, sizeof( data ) );
+	tr.whiteImage = R_CreateImage("*white", (byte *)data, 8, 8, GL_RGBA, qfalse, qfalse, GL_REPEAT);
+	//tr.screenImage = R_CreateImage("*screen", (byte *)data, 8, 8, GL_RGBA, qfalse, qfalse, GL_REPEAT );
+	tr.screenImage = R_CreateImage("*screen", (byte *)data, 8, 8, GL_RGBA, 1, qfalse, GL_REPEAT );
+
+	// with overbright bits active, we need an image which is some fraction of full color,
+	// for default lightmaps, etc
+	for (x=0 ; x<DEFAULT_SIZE ; x++) {
+		for (y=0 ; y<DEFAULT_SIZE ; y++) {
+			data[y][x][0] = 
+			data[y][x][1] = 
+			data[y][x][2] = tr.identityLightByte;
+			data[y][x][3] = 255;			
+		}
+	}
+
+	tr.identityLightImage = R_CreateImage("*identityLight", (byte *)data, 8, 8, GL_RGBA, qfalse, qfalse, GL_REPEAT);
+
+	// scratchimage is usually used for cinematic drawing
+	for(x=0;x<32;x++) {
+		// scratchimage is usually used for cinematic drawing
+		tr.scratchImage[x] = R_CreateImage(va("*scratch%d",x), (byte *)data, DEFAULT_SIZE, DEFAULT_SIZE, GL_RGBA, qfalse, qfalse, GL_CLAMP);
+	}
+
+	R_CreateFogImage();
+}
+
+
+/*
+===============
+R_SetColorMappings
+===============
+*/
+void R_SetColorMappings( void ) {
+	int		i, j;
+	float	g;
+	int		inf;
+	int		shift;
+
+	// setup the overbright lighting
+	tr.overbrightBits = r_overBrightBits->integer;
+	if ( !glConfig.deviceSupportsGamma ) {
+		tr.overbrightBits = 0;		// need hardware gamma for overbright
+	}
+
+	// never overbright in windowed mode
+	if ( !glConfig.isFullscreen )
+	{
+		tr.overbrightBits = 0;
+	}
+
+	if ( tr.overbrightBits > 1 ) {
+		tr.overbrightBits = 1;
+	}
+	if ( tr.overbrightBits < 0 ) {
+		tr.overbrightBits = 0;
+	}
+
+	tr.identityLight = 1.0 / ( 1 << tr.overbrightBits );
+	tr.identityLightByte = 255 * tr.identityLight;
+
+
+	if ( r_intensity->value < 1.0f ) {
+		Cvar_Set( "r_intensity", "1.0" );
+	}
+
+	if ( r_gamma->value < 0.5f ) {
+		Cvar_Set( "r_gamma", "0.5" );
+	} else if ( r_gamma->value > 3.0f ) {
+		Cvar_Set( "r_gamma", "3.0" );
+	}
+
+	g = r_gamma->value;
+
+	shift = tr.overbrightBits;
+
+	for ( i = 0; i < 256; i++ ) {
+		if ( g == 1 ) {
+			inf = i;
+		} else {
+			inf = 255 * pow ( i/255.0f, 1.0f / g ) + 0.5f;
+		}
+		inf <<= shift;
+		if (inf < 0) {
+			inf = 0;
+		}
+		if (inf > 255) {
+			inf = 255;
+		}
+		s_gammatable[i] = inf;
+	}
+
+	for (i=0 ; i<256 ; i++) {
+		j = i * r_intensity->value;
+		if (j > 255) {
+			j = 255;
+		}
+		s_intensitytable[i] = j;
+	}
+}
+
+/*
+===============
+R_InitImages
+===============
+*/
+void	R_InitImages( void ) {
+	//memset(hashTable, 0, sizeof(hashTable));	// DO NOT DO THIS NOW (because of image cacheing)	-ste.
+	if (!AllocatedImages)
+	{
+		AllocatedImages = new AllocatedImages_t;
+	}
+
+	// build brightness translation tables
+	R_SetColorMappings();
+
+	// create default texture and white texture
+	R_CreateBuiltinImages();
+}
+
+/*
+===============
+R_DeleteTextures
+===============
+*/
+// (only gets called during vid_restart now (and app exit), not during map load)
+//
+void R_DeleteTextures( void ) {
+
+	R_Images_Clear();	
+	GL_ResetBinds();
+}
+
+/*
+============================================================================
+
+SKINS
+
+============================================================================
+*/
+
+/*
+==================
+CommaParse
+
+This is unfortunate, but the skin files aren't
+compatable with our normal parsing rules.
+==================
+*/
+static char *CommaParse( char **data_p ) {
+	int c = 0, len;
+	char *data;
+	static	char	com_token[MAX_TOKEN_CHARS];
+
+	data = *data_p;
+	len = 0;
+	com_token[0] = 0;
+
+	// make sure incoming data is valid
+	if ( !data ) {
+		*data_p = NULL;
+		return com_token;
+	}
+
+	while ( 1 ) {
+		// skip whitespace
+		while( (c = *data) <= ' ') {
+			if( !c ) {
+				break;
+			}
+			data++;
+		}
+
+
+		c = *data;
+
+		// skip double slash comments
+		if ( c == '/' && data[1] == '/' )
+		{
+			while (*data && *data != '\n')
+				data++;
+		}
+		// skip /* */ comments
+		else if ( c=='/' && data[1] == '*' ) 
+		{
+			while ( *data && ( *data != '*' || data[1] != '/' ) ) 
+			{
+				data++;
+			}
+			if ( *data ) 
+			{
+				data += 2;
+			}
+		}
+		else
+		{
+			break;
+		}
+	}
+
+	if ( c == 0 ) {
+		return "";
+	}
+
+	// handle quoted strings
+	if (c == '\"')
+	{
+		data++;
+		while (1)
+		{
+			c = *data++;
+			if (c=='\"' || !c)
+			{
+				com_token[len] = 0;
+				*data_p = ( char * ) data;
+				return com_token;
+			}
+			if (len < MAX_TOKEN_CHARS)
+			{
+				com_token[len] = c;
+				len++;
+			}
+		}
+	}
+
+	// parse a regular word
+	do
+	{
+		if (len < MAX_TOKEN_CHARS)
+		{
+			com_token[len] = c;
+			len++;
+		}
+		data++;
+		c = *data;
+	} while (c>32 && c != ',' );
+
+	if (len == MAX_TOKEN_CHARS)
+	{
+//		Com_Printf ("Token exceeded %i chars, discarded.\n", MAX_TOKEN_CHARS);
+		len = 0;
+	}
+	com_token[len] = 0;
+
+	*data_p = ( char * ) data;
+	return com_token;
+}
+
+bool gServerSkinHack = false;
+
+shader_t *R_FindServerShader( const char *name, const int *lightmapIndex, const byte *styles, qboolean mipRawImage );
+
+/*
+===============
+RE_SplitSkins
+input = skinname, possibly being a macro for three skins
+return= true if three part skins found
+output= qualified names to three skins if return is true, undefined if false
+===============
+*/
+bool RE_SplitSkins(const char *INname, char *skinhead, char *skintorso, char *skinlower)
+{	//INname= "models/players/jedi_tf/|head01_skin1|torso01|lower01";
+	if (strchr(INname, '|'))
+	{
+		char name[MAX_QPATH];
+		strcpy(name, INname);
+		char *p = strchr(name, '|');
+		*p=0;
+		p++;
+		//fill in the base path
+		strcpy (skinhead, name);
+		strcpy (skintorso, name);
+		strcpy (skinlower, name);
+
+		//now get the the individual files
+		
+		//advance to second
+		char *p2 = strchr(p, '|'); 
+		assert(p2);
+		*p2=0;
+		p2++;
+		strcat (skinhead, p);
+		strcat (skinhead, ".skin");
+
+
+		//advance to third
+		p = strchr(p2, '|');
+		assert(p);
+		*p=0;
+		p++;
+		strcat (skintorso,p2);
+		strcat (skintorso, ".skin");
+
+		strcat (skinlower,p);
+		strcat (skinlower, ".skin");
+		
+		return true;
+	}
+	return false;
+}
+
+
+qhandle_t RE_RegisterIndividualSkin( const char *name , qhandle_t hSkin);
+/*
+===============
+RE_RegisterSkin
+
+===============
+*/
+qhandle_t RE_RegisterSkin( const char *name) {
+	qhandle_t	hSkin;
+	skin_t		*skin;
+
+	if (!cls.cgameStarted && !cls.uiStarted)		
+		//rww - added uiStarted exception because we want ghoul2 models in the menus.
+		return 1;	// cope with Ghoul2's calling-the-renderer-before-its-even-started hackery, must be any NZ amount here to trigger configstring setting
+
+	if ( !name || !name[0] ) {
+		Com_Printf( "Empty name passed to RE_RegisterSkin\n" );
+		return 0;
+	}
+
+	if ( strlen( name ) >= MAX_QPATH ) {
+		Com_Printf( "Skin name exceeds MAX_QPATH\n" );
+		return 0;
+	}
+
+	if (gServerSkinHack)
+	{ //This can happen on the server.
+		if (!tr.numSkins)
+		{ //skins haven't been init'd yet, should start off at 1.
+			R_InitSkins();
+		}
+	}
+
+	// see if the skin is already loaded
+	for ( hSkin = 1; hSkin < tr.numSkins ; hSkin++ ) {
+		skin = tr.skins[hSkin];
+		if ( !Q_stricmp( skin->name, name ) ) {
+			if( skin->numSurfaces == 0 ) {
+				return 0;		// default skin
+			}
+			return(hSkin);
+		}
+	}
+
+	if ( tr.numSkins == MAX_SKINS )	{
+		Com_Printf( "WARNING: RE_RegisterSkin( '%s' ) MAX_SKINS hit\n", name );
+		return 0;
+	}
+	// allocate a new skin
+	tr.numSkins++;
+	skin = (skin_t*) Hunk_Alloc( sizeof( skin_t ), h_low );
+	tr.skins[hSkin] = skin;
+	Q_strncpyz( skin->name, name, sizeof( skin->name ) );	//always make one so it won't search for it again
+
+	// make sure the render thread is stopped
+	R_SyncRenderThread();
+
+	// If not a .skin file, load as a single shader	- then return
+	if ( strcmp( name + strlen( name ) - 5, ".skin" ) ) {
+/*		skin->numSurfaces = 1;
+		skin->surfaces[0] = (skinSurface_t *) Hunk_Alloc( sizeof(skin->surfaces[0]), qtrue );
+		skin->surfaces[0]->shader = R_FindShader( name, lightmapsNone, stylesDefault, qtrue );
+		return hSkin;
+*/
+	}
+
+	char skinhead[MAX_QPATH]={0};
+	char skintorso[MAX_QPATH]={0};
+	char skinlower[MAX_QPATH]={0};
+	if ( RE_SplitSkins(name, (char*)&skinhead, (char*)&skintorso, (char*)&skinlower ) )
+	{//three part
+		hSkin = RE_RegisterIndividualSkin(skinhead, hSkin);
+		if (hSkin)
+		{
+			hSkin = RE_RegisterIndividualSkin(skintorso, hSkin);
+			if (hSkin)
+			{
+				hSkin = RE_RegisterIndividualSkin(skinlower, hSkin);
+			}
+		}
+	}
+	else
+	{//single skin
+		hSkin = RE_RegisterIndividualSkin(name, hSkin);
+	}
+	return(hSkin);
+}
+
+// given a name, go get the skin we want and return
+qhandle_t RE_RegisterIndividualSkin( const char *name , qhandle_t hSkin) 
+{
+	skin_t		*skin;
+	skinSurface_t	*surf;
+	char		*text, *text_p;
+	char		*token;
+	char		surfName[MAX_QPATH];
+
+	// load and parse the skin file
+    FS_ReadFile( name, (void **)&text );
+	if ( !text ) {
+		Com_Printf( "WARNING: RE_RegisterSkin( '%s' ) failed to load!\n", name );
+		return 0;
+	}
+
+	assert (tr.skins[hSkin]);	//should already be setup, but might be an 3part append
+
+	skin = tr.skins[hSkin];
+
+	text_p = text;
+	while ( text_p && *text_p ) {
+		// get surface name
+		token = CommaParse( &text_p );
+		Q_strncpyz( surfName, token, sizeof( surfName ) );
+
+		if ( !token[0] ) {
+			break;
+		}
+		// lowercase the surface name so skin compares are faster
+		Q_strlwr( surfName );
+
+		if ( *text_p == ',' ) {
+			text_p++;
+		}
+
+		if ( !strncmp( token, "tag_", 4 ) ) {	//these aren't in there, but just in case you load an id style one...
+			continue;
+		}
+		
+		// parse the shader name
+		token = CommaParse( &text_p );
+
+		if ( !strcmp( &surfName[strlen(surfName)-4], "_off") )
+		{
+			if ( !strcmp( token ,"*off" ) )
+			{
+				continue;	//don't need these double offs
+			}
+			surfName[strlen(surfName)-4] = 0;	//remove the "_off"
+		}
+		if (sizeof( skin->surfaces) / sizeof( skin->surfaces[0] ) <= skin->numSurfaces)
+		{
+			assert( sizeof( skin->surfaces) / sizeof( skin->surfaces[0] ) > skin->numSurfaces );
+			Com_Printf( "WARNING: RE_RegisterSkin( '%s' ) more than %d surfaces!\n", name, sizeof( skin->surfaces) / sizeof( skin->surfaces[0] ) );
+			break;
+		}
+		surf = skin->surfaces[ skin->numSurfaces ] = (skinSurface_t *) Hunk_Alloc( sizeof( *skin->surfaces[0] ), h_low );
+		Q_strncpyz( surf->name, surfName, sizeof( surf->name ) );
+
+		if (gServerSkinHack)
+		{
+			surf->shader = R_FindServerShader( token, lightmapsNone, stylesDefault, qtrue );
+		}
+		else
+		{
+			surf->shader = R_FindShader( token, lightmapsNone, stylesDefault, qtrue );
+		}
+		skin->numSurfaces++;
+	}
+
+	FS_FreeFile( text );
+
+
+	// never let a skin have 0 shaders
+	if ( skin->numSurfaces == 0 ) {
+		return 0;		// use default skin
+	}
+
+	return hSkin;
+}
+
+
+/*
+===============
+RE_RegisterServerSkin
+
+Mangled version of the above function to load .skin files on the server.
+===============
+*/
+qhandle_t RE_RegisterServerSkin( const char *name ) {
+	qhandle_t r;
+
+	if (com_cl_running &&
+		com_cl_running->integer)
+	{ //If the client is running then we can go straight into the normal registerskin func
+		return RE_RegisterSkin(name);
+	}
+
+	gServerSkinHack = true;
+	r = RE_RegisterSkin(name);
+	gServerSkinHack = false;
+
+	return r;
+}
+
+
+
+/*
+===============
+R_InitSkins
+===============
+*/
+void	R_InitSkins( void ) {
+	skin_t		*skin;
+
+	tr.numSkins = 1;
+
+	// make the default skin have all default shaders
+	skin = tr.skins[0] = (skin_t*) Hunk_Alloc( sizeof( skin_t ), h_low );
+	Q_strncpyz( skin->name, "<default skin>", sizeof( skin->name )  );
+	skin->numSurfaces = 1;
+	skin->surfaces[0] = (skinSurface_t *) Hunk_Alloc( sizeof( *skin->surfaces[0] ), h_low );
+	skin->surfaces[0]->shader = tr.defaultShader;
+}
+
+/*
+===============
+R_GetSkinByHandle
+===============
+*/
+skin_t	*R_GetSkinByHandle( qhandle_t hSkin ) {
+	if ( hSkin < 1 || hSkin >= tr.numSkins ) {
+		return tr.skins[0];
+	}
+	return tr.skins[ hSkin ];
+}
+
+/*
+===============
+R_SkinList_f
+===============
+*/
+void	R_SkinList_f (void) {
+	int			i, j;
+	skin_t		*skin;
+
+	Com_Printf ("------------------\n");
+
+	for ( i = 0 ; i < tr.numSkins ; i++ ) {
+		skin = tr.skins[i];
+		Com_Printf( "%3i:%s\n", i, skin->name );
+		for ( j = 0 ; j < skin->numSurfaces ; j++ ) {
+			Com_Printf( "       %s = %s\n", 
+				skin->surfaces[j]->name, skin->surfaces[j]->shader->name );
+		}
+	}
+	Com_Printf ("------------------\n");
+}
diff --git a/codemp/renderer/tr_init.cpp b/codemp/renderer/tr_init.cpp
new file mode 100644
index 0000000..0559da6
--- /dev/null
+++ b/codemp/renderer/tr_init.cpp
@@ -0,0 +1,1522 @@
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+// tr_init.c -- functions that are not called every frame
+
+#include "tr_local.h"
+
+#ifndef DEDICATED
+#if !defined __TR_WORLDEFFECTS_H
+	#include "tr_WorldEffects.h"
+#endif
+#endif //!DEDICATED
+
+#include "tr_font.h"
+
+#if !defined (MINIHEAP_H_INC)
+	#include "../qcommon/MiniHeap.h"
+
+#include "../ghoul2/G2_local.h"
+#endif
+
+
+//#ifdef __USEA3D
+//// Defined in snd_a3dg_refcommon.c
+//void RE_A3D_RenderGeometry (void *pVoidA3D, void *pVoidGeom, void *pVoidMat, void *pVoidGeomStatus);
+//#endif
+
+#define G2_VERT_SPACE_SERVER_SIZE 256
+CMiniHeap *G2VertSpaceServer = NULL;
+CMiniHeap CMiniHeap_singleton(G2_VERT_SPACE_SERVER_SIZE * 1024);
+
+#ifndef DEDICATED
+glconfig_t	glConfig;
+glstate_t	glState;
+static void GfxInfo_f( void );
+
+#endif 
+
+
+cvar_t	*r_verbose;
+cvar_t	*r_ignore;
+
+cvar_t	*r_displayRefresh;
+
+cvar_t	*r_detailTextures;
+
+cvar_t	*r_znear;
+
+cvar_t	*r_skipBackEnd;
+
+cvar_t	*r_ignorehwgamma;
+cvar_t	*r_measureOverdraw;
+
+cvar_t	*r_inGameVideo;
+cvar_t	*r_fastsky;
+cvar_t	*r_drawSun;
+cvar_t	*r_dynamiclight;
+// rjr - removed for hacking cvar_t	*r_dlightBacks;
+
+cvar_t	*r_lodbias;
+cvar_t	*r_lodscale;
+cvar_t	*r_autolodscalevalue;
+
+cvar_t	*r_norefresh;
+cvar_t	*r_drawentities;
+cvar_t	*r_drawworld;
+cvar_t	*r_drawfog;
+cvar_t	*r_speeds;
+cvar_t	*r_fullbright;
+cvar_t	*r_novis;
+cvar_t	*r_nocull;
+cvar_t	*r_facePlaneCull;
+cvar_t	*r_cullRoofFaces; //attempted smart method of culling out upwards facing surfaces on roofs for automap shots -rww
+cvar_t	*r_roofCullCeilDist; //ceiling distance cull tolerance -rww
+cvar_t	*r_roofCullFloorDist; //floor distance cull tolerance -rww
+cvar_t	*r_showcluster;
+cvar_t	*r_nocurves;
+
+cvar_t	*r_autoMap; //automap renderside toggle for debugging -rww
+cvar_t	*r_autoMapBackAlpha; //alpha of automap bg -rww
+cvar_t	*r_autoMapDisable; //don't calc it (since it's slow in debug) -rww
+
+cvar_t	*r_dlightStyle;
+cvar_t	*r_surfaceSprites;
+cvar_t	*r_surfaceWeather;
+
+cvar_t	*r_windSpeed;
+cvar_t	*r_windAngle;
+cvar_t	*r_windGust;
+cvar_t	*r_windDampFactor;
+cvar_t	*r_windPointForce;
+cvar_t	*r_windPointX;
+cvar_t	*r_windPointY;
+
+cvar_t	*r_allowExtensions;
+
+cvar_t	*r_ext_compressed_textures;
+cvar_t	*r_ext_compressed_lightmaps;
+cvar_t	*r_ext_preferred_tc_method;
+cvar_t	*r_ext_gamma_control;
+cvar_t	*r_ext_multitexture;
+cvar_t	*r_ext_compiled_vertex_array;
+cvar_t	*r_ext_texture_env_add;
+cvar_t	*r_ext_texture_filter_anisotropic;
+
+cvar_t	*r_DynamicGlow;
+cvar_t	*r_DynamicGlowPasses;
+cvar_t	*r_DynamicGlowDelta;
+cvar_t	*r_DynamicGlowIntensity;
+cvar_t	*r_DynamicGlowSoft;
+cvar_t	*r_DynamicGlowWidth;
+cvar_t	*r_DynamicGlowHeight;
+
+cvar_t	*r_ignoreGLErrors;
+cvar_t	*r_logFile;
+
+cvar_t	*r_stencilbits;
+cvar_t	*r_depthbits;
+cvar_t	*r_colorbits;
+cvar_t	*r_stereo;
+cvar_t	*r_primitives;
+cvar_t	*r_texturebits;
+cvar_t	*r_texturebitslm;
+
+cvar_t	*r_lightmap;
+cvar_t	*r_vertexLight;
+cvar_t	*r_uiFullScreen;
+cvar_t	*r_shadows;
+cvar_t	*r_shadowRange;
+cvar_t	*r_flares;
+cvar_t	*r_mode;
+cvar_t	*r_nobind;
+cvar_t	*r_singleShader;
+cvar_t	*r_colorMipLevels;
+cvar_t	*r_picmip;
+cvar_t	*r_showtris;
+cvar_t	*r_showsky;
+cvar_t	*r_shownormals;
+cvar_t	*r_finish;
+cvar_t	*r_clear;
+cvar_t	*r_swapInterval;
+cvar_t	*r_markcount;
+cvar_t	*r_textureMode;
+cvar_t	*r_offsetFactor;
+cvar_t	*r_offsetUnits;
+cvar_t	*r_gamma;
+cvar_t	*r_intensity;
+cvar_t	*r_lockpvs;
+cvar_t	*r_noportals;
+cvar_t	*r_portalOnly;
+
+cvar_t	*r_subdivisions;
+cvar_t	*r_lodCurveError;
+
+cvar_t	*r_fullscreen = 0;
+
+cvar_t	*r_customwidth;
+cvar_t	*r_customheight;
+
+cvar_t	*r_overBrightBits;
+
+cvar_t	*r_debugSurface;
+cvar_t	*r_simpleMipMaps;
+
+cvar_t	*r_showImages;
+
+cvar_t	*r_ambientScale;
+cvar_t	*r_directedScale;
+cvar_t	*r_debugLight;
+cvar_t	*r_debugSort;
+
+cvar_t	*r_maxpolys;
+int		max_polys;
+cvar_t	*r_maxpolyverts;
+int		max_polyverts;
+
+cvar_t	*r_modelpoolmegs;
+
+#ifdef _XBOX
+cvar_t	*r_hdreffect;
+cvar_t  *r_sundir_x;
+cvar_t  *r_sundir_y;
+cvar_t  *r_sundir_z;
+cvar_t  *r_hdrbloom;
+#endif
+
+
+/*
+Ghoul2 Insert Start
+*/
+#ifdef _DEBUG
+cvar_t	*r_noPrecacheGLA;
+#endif
+
+cvar_t	*r_noServerGhoul2;
+cvar_t	*r_Ghoul2AnimSmooth=0;
+cvar_t	*r_Ghoul2UnSqashAfterSmooth=0;
+//cvar_t	*r_Ghoul2UnSqash;
+//cvar_t	*r_Ghoul2TimeBase=0; from single player
+//cvar_t	*r_Ghoul2NoLerp;
+//cvar_t	*r_Ghoul2NoBlend;
+//cvar_t	*r_Ghoul2BlendMultiplier=0;
+
+cvar_t	*broadsword=0;
+cvar_t	*broadsword_kickbones=0;
+cvar_t	*broadsword_kickorigin=0;
+cvar_t	*broadsword_playflop=0;
+cvar_t	*broadsword_dontstopanim=0;
+cvar_t	*broadsword_waitforshot=0;
+cvar_t	*broadsword_smallbbox=0;
+cvar_t	*broadsword_extra1=0;
+cvar_t	*broadsword_extra2=0;
+
+cvar_t	*broadsword_effcorr=0;
+cvar_t	*broadsword_ragtobase=0;
+cvar_t	*broadsword_dircap=0;
+
+/*
+Ghoul2 Insert End
+*/
+
+#ifndef DEDICATED
+void ( APIENTRY * qglMultiTexCoord2fARB )( GLenum texture, GLfloat s, GLfloat t );
+void ( APIENTRY * qglActiveTextureARB )( GLenum texture );
+void ( APIENTRY * qglClientActiveTextureARB )( GLenum texture );
+
+void ( APIENTRY * qglLockArraysEXT)( GLint, GLint);
+void ( APIENTRY * qglUnlockArraysEXT) ( void );
+
+void ( APIENTRY * qglPointParameterfEXT)( GLenum, GLfloat);
+void ( APIENTRY * qglPointParameterfvEXT)( GLenum, GLfloat *);
+
+//3d textures -rww
+void ( APIENTRY * qglTexImage3DEXT) (GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *);
+void ( APIENTRY * qglTexSubImage3DEXT) (GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *);
+
+
+#ifndef _XBOX	// GLOWXXX
+// Declare Register Combiners function pointers.
+PFNGLCOMBINERPARAMETERFVNV				qglCombinerParameterfvNV = NULL;
+PFNGLCOMBINERPARAMETERIVNV				qglCombinerParameterivNV = NULL;
+PFNGLCOMBINERPARAMETERFNV				qglCombinerParameterfNV = NULL;
+PFNGLCOMBINERPARAMETERINV				qglCombinerParameteriNV = NULL;
+PFNGLCOMBINERINPUTNV					qglCombinerInputNV = NULL;
+PFNGLCOMBINEROUTPUTNV					qglCombinerOutputNV = NULL;
+PFNGLFINALCOMBINERINPUTNV				qglFinalCombinerInputNV = NULL;
+PFNGLGETCOMBINERINPUTPARAMETERFVNV		qglGetCombinerInputParameterfvNV = NULL;
+PFNGLGETCOMBINERINPUTPARAMETERIVNV		qglGetCombinerInputParameterivNV = NULL;
+PFNGLGETCOMBINEROUTPUTPARAMETERFVNV		qglGetCombinerOutputParameterfvNV = NULL;
+PFNGLGETCOMBINEROUTPUTPARAMETERIVNV		qglGetCombinerOutputParameterivNV = NULL;
+PFNGLGETFINALCOMBINERINPUTPARAMETERFVNV	qglGetFinalCombinerInputParameterfvNV = NULL;
+PFNGLGETFINALCOMBINERINPUTPARAMETERIVNV	qglGetFinalCombinerInputParameterivNV = NULL;
+
+// Declare Pixel Format function pointers.
+PFNWGLGETPIXELFORMATATTRIBIVARBPROC		qwglGetPixelFormatAttribivARB = NULL;
+PFNWGLGETPIXELFORMATATTRIBFVARBPROC		qwglGetPixelFormatAttribfvARB = NULL;
+PFNWGLCHOOSEPIXELFORMATARBPROC			qwglChoosePixelFormatARB = NULL;
+
+// Declare Pixel Buffer function pointers.
+PFNWGLCREATEPBUFFERARBPROC				qwglCreatePbufferARB = NULL;
+PFNWGLGETPBUFFERDCARBPROC				qwglGetPbufferDCARB = NULL;
+PFNWGLRELEASEPBUFFERDCARBPROC			qwglReleasePbufferDCARB = NULL;
+PFNWGLDESTROYPBUFFERARBPROC				qwglDestroyPbufferARB = NULL;
+PFNWGLQUERYPBUFFERARBPROC				qwglQueryPbufferARB = NULL;
+
+// Declare Render-Texture function pointers.
+PFNWGLBINDTEXIMAGEARBPROC				qwglBindTexImageARB = NULL;
+PFNWGLRELEASETEXIMAGEARBPROC			qwglReleaseTexImageARB = NULL;
+PFNWGLSETPBUFFERATTRIBARBPROC			qwglSetPbufferAttribARB = NULL;
+
+// Declare Vertex and Fragment Program function pointers.
+PFNGLPROGRAMSTRINGARBPROC qglProgramStringARB = NULL;
+PFNGLBINDPROGRAMARBPROC qglBindProgramARB = NULL;
+PFNGLDELETEPROGRAMSARBPROC qglDeleteProgramsARB = NULL;
+PFNGLGENPROGRAMSARBPROC qglGenProgramsARB = NULL;
+PFNGLPROGRAMENVPARAMETER4DARBPROC qglProgramEnvParameter4dARB = NULL;
+PFNGLPROGRAMENVPARAMETER4DVARBPROC qglProgramEnvParameter4dvARB = NULL;
+PFNGLPROGRAMENVPARAMETER4FARBPROC qglProgramEnvParameter4fARB = NULL;
+PFNGLPROGRAMENVPARAMETER4FVARBPROC qglProgramEnvParameter4fvARB = NULL;
+PFNGLPROGRAMLOCALPARAMETER4DARBPROC qglProgramLocalParameter4dARB = NULL;
+PFNGLPROGRAMLOCALPARAMETER4DVARBPROC qglProgramLocalParameter4dvARB = NULL;
+PFNGLPROGRAMLOCALPARAMETER4FARBPROC qglProgramLocalParameter4fARB = NULL;
+PFNGLPROGRAMLOCALPARAMETER4FVARBPROC qglProgramLocalParameter4fvARB = NULL;
+PFNGLGETPROGRAMENVPARAMETERDVARBPROC qglGetProgramEnvParameterdvARB = NULL;
+PFNGLGETPROGRAMENVPARAMETERFVARBPROC qglGetProgramEnvParameterfvARB = NULL;
+PFNGLGETPROGRAMLOCALPARAMETERDVARBPROC qglGetProgramLocalParameterdvARB = NULL;
+PFNGLGETPROGRAMLOCALPARAMETERFVARBPROC qglGetProgramLocalParameterfvARB = NULL;
+PFNGLGETPROGRAMIVARBPROC qglGetProgramivARB = NULL;
+PFNGLGETPROGRAMSTRINGARBPROC qglGetProgramStringARB = NULL;
+PFNGLISPROGRAMARBPROC qglIsProgramARB = NULL;
+#endif
+
+
+void RE_SetLightStyle(int style, int color);
+
+void RE_GetBModelVerts( int bmodelIndex, vec3_t *verts, vec3_t normal );
+
+#endif // !DEDICATED
+
+static void AssertCvarRange( cvar_t *cv, float minVal, float maxVal, qboolean shouldBeIntegral )
+{
+	if ( shouldBeIntegral )
+	{
+		if ( ( int ) cv->value != cv->integer )
+		{
+			Com_Printf (S_COLOR_YELLOW  "WARNING: cvar '%s' must be integral (%f)\n", cv->name, cv->value );
+			Cvar_Set( cv->name, va( "%d", cv->integer ) );
+		}
+	}
+
+	if ( cv->value < minVal )
+	{
+		Com_Printf (S_COLOR_YELLOW  "WARNING: cvar '%s' out of range (%f < %f)\n", cv->name, cv->value, minVal );
+		Cvar_Set( cv->name, va( "%f", minVal ) );
+	}
+	else if ( cv->value > maxVal )
+	{
+		Com_Printf (S_COLOR_YELLOW  "WARNING: cvar '%s' out of range (%f > %f)\n", cv->name, cv->value, maxVal );
+		Cvar_Set( cv->name, va( "%f", maxVal ) );
+	}
+}
+
+#ifndef DEDICATED
+
+void R_Splash()
+{
+#ifndef _XBOX
+	image_t *pImage;
+/*	const char* s = Cvar_VariableString("se_language");
+	if (stricmp(s,"english"))
+	{
+		pImage = R_FindImageFile( "menu/splash_eur", qfalse, qfalse, qfalse, GL_CLAMP);
+	}
+	else
+	{
+		pImage = R_FindImageFile( "menu/splash", qfalse, qfalse, qfalse, GL_CLAMP);
+	}
+*/
+	pImage = R_FindImageFile( "menu/splash", qfalse, qfalse, qfalse, GL_CLAMP);
+	extern void	RB_SetGL2D (void);
+	RB_SetGL2D();	
+	if (pImage )
+	{//invalid paths?
+		GL_Bind( pImage );
+	}
+	GL_State(GLS_SRCBLEND_ONE | GLS_DSTBLEND_ZERO);
+
+	const int width = 640;
+	const int height = 480;
+	const float x1 = 320 - width / 2;
+	const float x2 = 320 + width / 2;
+	const float y1 = 240 - height / 2;
+	const float y2 = 240 + height / 2;
+
+
+	qglBegin (GL_TRIANGLE_STRIP);
+		qglTexCoord2f( 0,  0 );
+		qglVertex2f(x1, y1);
+		qglTexCoord2f( 1 ,  0 );
+		qglVertex2f(x2, y1);
+		qglTexCoord2f( 0, 1 );
+		qglVertex2f(x1, y2);
+		qglTexCoord2f( 1, 1 );
+		qglVertex2f(x2, y2);
+	qglEnd();
+
+	GLimp_EndFrame();
+#endif
+}
+
+/*
+** InitOpenGL
+**
+** This function is responsible for initializing a valid OpenGL subsystem.  This
+** is done by calling GLimp_Init (which gives us a working OGL subsystem) then
+** setting variables, checking GL constants, and reporting the gfx system config
+** to the user.
+*/
+static void InitOpenGL( void )
+{
+	//
+	// initialize OS specific portions of the renderer
+	//
+	// GLimp_Init directly or indirectly references the following cvars:
+	//		- r_fullscreen
+	//		- r_mode
+	//		- r_(color|depth|stencil)bits
+	//		- r_ignorehwgamma
+	//		- r_gamma
+	//
+
+	if ( glConfig.vidWidth == 0 )
+	{
+		GLimp_Init();
+		// print info the first time only
+		GL_SetDefaultState();
+		R_Splash();	//get something on screen asap
+		GfxInfo_f();
+	}
+	else
+	{
+		// set default state
+		GL_SetDefaultState();
+	}
+	// init command buffers and SMP
+	R_InitCommandBuffers();
+}
+
+/*
+==================
+GL_CheckErrors
+==================
+*/
+void GL_CheckErrors( void ) {
+    int		err;
+    char	s[64];
+
+    err = qglGetError();
+    if ( err == GL_NO_ERROR ) {
+        return;
+    }
+    if ( r_ignoreGLErrors->integer ) {
+        return;
+    }
+    switch( err ) {
+        case GL_INVALID_ENUM:
+            strcpy( s, "GL_INVALID_ENUM" );
+            break;
+        case GL_INVALID_VALUE:
+            strcpy( s, "GL_INVALID_VALUE" );
+            break;
+        case GL_INVALID_OPERATION:
+            strcpy( s, "GL_INVALID_OPERATION" );
+            break;
+        case GL_STACK_OVERFLOW:
+            strcpy( s, "GL_STACK_OVERFLOW" );
+            break;
+        case GL_STACK_UNDERFLOW:
+            strcpy( s, "GL_STACK_UNDERFLOW" );
+            break;
+        case GL_OUT_OF_MEMORY:
+            strcpy( s, "GL_OUT_OF_MEMORY" );
+            break;
+        default:
+            Com_sprintf( s, sizeof(s), "%i", err);
+            break;
+    }
+
+    Com_Error( ERR_FATAL, "GL_CheckErrors: %s", s );
+}
+
+#endif //!DEDICATED
+
+#ifndef _XBOX
+
+/*
+** R_GetModeInfo
+*/
+typedef struct vidmode_s
+{
+    const char *description;
+    int         width, height;
+} vidmode_t;
+
+const vidmode_t r_vidModes[] =
+{
+    { "Mode  0: 320x240",		320,	240 },
+    { "Mode  1: 400x300",		400,	300 },
+    { "Mode  2: 512x384",		512,	384 },
+    { "Mode  3: 640x480",		640,	480 },
+    { "Mode  4: 800x600",		800,	600 },
+    { "Mode  5: 960x720",		960,	720 },
+    { "Mode  6: 1024x768",		1024,	768 },
+    { "Mode  7: 1152x864",		1152,	864 },
+    { "Mode  8: 1280x1024",		1280,	1024 },
+    { "Mode  9: 1600x1200",		1600,	1200 },
+    { "Mode 10: 2048x1536",		2048,	1536 },
+    { "Mode 11: 856x480 (wide)", 856,	 480 },
+    { "Mode 12: 2400x600(surround)",2400,600 }
+};
+static const int	s_numVidModes = ( sizeof( r_vidModes ) / sizeof( r_vidModes[0] ) );
+
+qboolean R_GetModeInfo( int *width, int *height, int mode ) {
+	const vidmode_t	*vm;
+
+    if ( mode < -1 ) {
+        return qfalse;
+	}
+	if ( mode >= s_numVidModes ) {
+		return qfalse;
+	}
+
+	if ( mode == -1 ) {
+		*width = r_customwidth->integer;
+		*height = r_customheight->integer;
+		return qtrue;
+	}
+
+	vm = &r_vidModes[mode];
+
+    *width  = vm->width;
+    *height = vm->height;
+
+    return qtrue;
+}
+
+/*
+** R_ModeList_f
+*/
+static void R_ModeList_f( void )
+{
+	int i;
+
+	Com_Printf ("\n" );
+	for ( i = 0; i < s_numVidModes; i++ )
+	{
+		Com_Printf ("%s\n", r_vidModes[i].description );
+	}
+	Com_Printf ("\n" );
+}
+
+#endif	// _XBOX
+
+/* 
+============================================================================== 
+ 
+						SCREEN SHOTS 
+ 
+============================================================================== 
+*/ 
+#ifndef DEDICATED
+/* 
+================== 
+R_TakeScreenshot
+================== 
+*/  
+void R_TakeScreenshot( int x, int y, int width, int height, char *fileName ) {
+#ifndef _XBOX
+	byte		*buffer;
+	int			i, c, temp;
+
+	buffer = (unsigned char *)Hunk_AllocateTempMemory(glConfig.vidWidth*glConfig.vidHeight*3+18);
+
+	Com_Memset (buffer, 0, 18);
+	buffer[2] = 2;		// uncompressed type
+	buffer[12] = width & 255;
+	buffer[13] = width >> 8;
+	buffer[14] = height & 255;
+	buffer[15] = height >> 8;
+	buffer[16] = 24;	// pixel size
+
+	qglReadPixels( x, y, width, height, GL_RGB, GL_UNSIGNED_BYTE, buffer+18 ); 
+
+	// swap rgb to bgr
+	c = 18 + width * height * 3;
+	for (i=18 ; i<c ; i+=3) {
+		temp = buffer[i];
+		buffer[i] = buffer[i+2];
+		buffer[i+2] = temp;
+	}
+
+	// gamma correct
+	if ( ( tr.overbrightBits > 0 ) && glConfig.deviceSupportsGamma ) {
+		R_GammaCorrect( buffer + 18, glConfig.vidWidth * glConfig.vidHeight * 3 );
+	}
+
+	FS_WriteFile( fileName, buffer, c );
+
+	Hunk_FreeTempMemory( buffer );
+#endif
+}
+
+/* 
+================== 
+R_TakeScreenshot
+================== 
+*/  
+void R_TakeScreenshotJPEG( int x, int y, int width, int height, char *fileName ) {
+#ifndef _XBOX
+	byte		*buffer;
+
+	buffer = (unsigned char *)Hunk_AllocateTempMemory(glConfig.vidWidth*glConfig.vidHeight*4);
+
+	qglReadPixels( x, y, width, height, GL_RGBA, GL_UNSIGNED_BYTE, buffer ); 
+
+	// gamma correct
+	if ( ( tr.overbrightBits > 0 ) && glConfig.deviceSupportsGamma ) {
+		R_GammaCorrect( buffer, glConfig.vidWidth * glConfig.vidHeight * 4 );
+	}
+
+	FS_WriteFile( fileName, buffer, 1 );		// create path
+	SaveJPG( fileName, 95, glConfig.vidWidth, glConfig.vidHeight, buffer);
+
+	Hunk_FreeTempMemory( buffer );
+#endif
+}
+
+/* 
+================== 
+R_ScreenshotFilename
+================== 
+*/  
+void R_ScreenshotFilename( int lastNumber, char *fileName, const char *psExt ) {
+	int		a,b,c,d;
+
+	if ( lastNumber < 0 || lastNumber > 9999 ) {
+		Com_sprintf( fileName, MAX_OSPATH, "screenshots/shot9999%s",psExt );
+		return;
+	}
+
+	a = lastNumber / 1000;
+	lastNumber -= a*1000;
+	b = lastNumber / 100;
+	lastNumber -= b*100;
+	c = lastNumber / 10;
+	lastNumber -= c*10;
+	d = lastNumber;
+
+	Com_sprintf( fileName, MAX_OSPATH, "screenshots/shot%i%i%i%i%s"
+		, a, b, c, d, psExt );
+}
+
+/*
+====================
+R_LevelShot
+
+levelshots are specialized 256*256 thumbnails for
+the menu system, sampled down from full screen distorted images
+====================
+*/
+#define LEVELSHOTSIZE 256
+static void R_LevelShot( void ) {
+#ifndef _XBOX
+	char		checkname[MAX_OSPATH];
+	byte		*buffer;
+	byte		*source;
+	byte		*src, *dst;
+	int			x, y;
+	int			r, g, b;
+	float		xScale, yScale;
+	int			xx, yy;
+
+	sprintf( checkname, "levelshots/%s.tga", tr.world->baseName );
+
+	source = (unsigned char *)Hunk_AllocateTempMemory( glConfig.vidWidth * glConfig.vidHeight * 3 );
+
+	buffer = (unsigned char *)Hunk_AllocateTempMemory( LEVELSHOTSIZE * LEVELSHOTSIZE*3 + 18);
+	Com_Memset (buffer, 0, 18);
+	buffer[2] = 2;		// uncompressed type
+	buffer[12] = LEVELSHOTSIZE & 255;
+	buffer[13] = LEVELSHOTSIZE >> 8;
+	buffer[14] = LEVELSHOTSIZE & 255;
+	buffer[15] = LEVELSHOTSIZE >> 8;
+	buffer[16] = 24;	// pixel size
+
+	qglReadPixels( 0, 0, glConfig.vidWidth, glConfig.vidHeight, GL_RGB, GL_UNSIGNED_BYTE, source ); 
+
+	// resample from source
+	xScale = glConfig.vidWidth / (4.0*LEVELSHOTSIZE);
+	yScale = glConfig.vidHeight / (3.0*LEVELSHOTSIZE);
+	for ( y = 0 ; y < LEVELSHOTSIZE ; y++ ) {
+		for ( x = 0 ; x < LEVELSHOTSIZE ; x++ ) {
+			r = g = b = 0;
+			for ( yy = 0 ; yy < 3 ; yy++ ) {
+				for ( xx = 0 ; xx < 4 ; xx++ ) {
+					src = source + 3 * ( glConfig.vidWidth * (int)( (y*3+yy)*yScale ) + (int)( (x*4+xx)*xScale ) );
+					r += src[0];
+					g += src[1];
+					b += src[2];
+				}
+			}
+			dst = buffer + 18 + 3 * ( y * LEVELSHOTSIZE + x );
+			dst[0] = b / 12;
+			dst[1] = g / 12;
+			dst[2] = r / 12;
+		}
+	}
+
+	// gamma correct
+	if ( ( tr.overbrightBits > 0 ) && glConfig.deviceSupportsGamma ) {
+		R_GammaCorrect( buffer + 18, LEVELSHOTSIZE * LEVELSHOTSIZE * 3 );
+	}
+
+	FS_WriteFile( checkname, buffer, LEVELSHOTSIZE * LEVELSHOTSIZE*3 + 18 );
+
+	Hunk_FreeTempMemory( buffer );
+	Hunk_FreeTempMemory( source );
+
+	Com_Printf ("Wrote %s\n", checkname );
+#endif
+}
+
+/* 
+================== 
+R_ScreenShotTGA_f
+
+screenshot
+screenshot [silent]
+screenshot [levelshot]
+screenshot [filename]
+
+Doesn't print the pacifier message if there is a second arg
+================== 
+*/  
+void R_ScreenShotTGA_f (void) {
+#ifndef _XBOX
+	char		checkname[MAX_OSPATH];
+	static	int	lastNumber = -1;
+	qboolean	silent;
+
+	if ( !strcmp( Cmd_Argv(1), "levelshot" ) ) {
+		R_LevelShot();
+		return;
+	}
+
+	if ( !strcmp( Cmd_Argv(1), "silent" ) ) {
+		silent = qtrue;
+	} else {
+		silent = qfalse;
+	}
+
+	if ( Cmd_Argc() == 2 && !silent ) {
+		// explicit filename
+		Com_sprintf( checkname, MAX_OSPATH, "screenshots/%s.tga", Cmd_Argv( 1 ) );
+	} else {
+		// scan for a free filename
+
+		// if we have saved a previous screenshot, don't scan
+		// again, because recording demo avis can involve
+		// thousands of shots
+		if ( lastNumber == -1 ) {
+			lastNumber = 0;
+		}
+		// scan for a free number
+		for ( ; lastNumber <= 9999 ; lastNumber++ ) {
+			R_ScreenshotFilename( lastNumber, checkname, ".tga" );
+
+			if (!FS_FileExists( checkname ))
+			{
+				break; // file doesn't exist
+			}
+		}
+
+		if ( lastNumber >= 9999 ) {
+			Com_Printf ( "ScreenShot: Couldn't create a file\n"); 
+			return;
+ 		}
+
+		lastNumber++;
+	}
+
+
+	R_TakeScreenshot( 0, 0, glConfig.vidWidth, glConfig.vidHeight, checkname );
+
+	if ( !silent ) {
+		Com_Printf ( "Wrote %s\n", checkname);
+	}
+#endif
+} 
+
+//jpeg  vession
+void R_ScreenShot_f (void) {
+#ifndef _XBOX
+	char		checkname[MAX_OSPATH];
+	static	int	lastNumber = -1;
+	qboolean	silent;
+
+	if ( !strcmp( Cmd_Argv(1), "levelshot" ) ) {
+		R_LevelShot();
+		return;
+	}
+	if ( !strcmp( Cmd_Argv(1), "silent" ) ) {
+		silent = qtrue;
+	} else {
+		silent = qfalse;
+	}
+
+	if ( Cmd_Argc() == 2 && !silent ) {
+		// explicit filename
+		Com_sprintf( checkname, MAX_OSPATH, "screenshots/%s.jpg", Cmd_Argv( 1 ) );
+	} else {
+		// scan for a free filename
+
+		// if we have saved a previous screenshot, don't scan
+		// again, because recording demo avis can involve
+		// thousands of shots
+		if ( lastNumber == -1 ) {
+			lastNumber = 0;
+		}
+		// scan for a free number
+		for ( ; lastNumber <= 9999 ; lastNumber++ ) {
+			R_ScreenshotFilename( lastNumber, checkname, ".jpg" );
+
+			if (!FS_FileExists( checkname ))
+			{
+				break; // file doesn't exist
+			}
+		}
+
+		if ( lastNumber == 10000 ) {
+			Com_Printf ( "ScreenShot: Couldn't create a file\n"); 
+			return;
+ 		}
+
+		lastNumber++;
+	}
+
+
+	R_TakeScreenshotJPEG( 0, 0, glConfig.vidWidth, glConfig.vidHeight, checkname );
+
+	if ( !silent ) {
+		Com_Printf ( "Wrote %s\n", checkname);
+	}
+#endif
+} 
+
+//============================================================================
+
+/*
+** GL_SetDefaultState
+*/
+void GL_SetDefaultState( void )
+{
+	qglClearDepth( 1.0f );
+
+	qglCullFace(GL_FRONT);
+
+	qglColor4f (1,1,1,1);
+
+	// initialize downstream texture unit if we're running
+	// in a multitexture environment
+	if ( qglActiveTextureARB ) {
+		GL_SelectTexture( 1 );
+		GL_TextureMode( r_textureMode->string );
+		GL_TexEnv( GL_MODULATE );
+		qglDisable( GL_TEXTURE_2D );
+		GL_SelectTexture( 0 );
+	}
+
+	qglEnable(GL_TEXTURE_2D);
+	GL_TextureMode( r_textureMode->string );
+	GL_TexEnv( GL_MODULATE );
+
+	qglShadeModel( GL_SMOOTH );
+	qglDepthFunc( GL_LEQUAL );
+
+	// the vertex array is always enabled, but the color and texture
+	// arrays are enabled and disabled around the compiled vertex array call
+	qglEnableClientState (GL_VERTEX_ARRAY);
+
+	//
+	// make sure our GL state vector is set correctly
+	//
+	glState.glStateBits = GLS_DEPTHTEST_DISABLE | GLS_DEPTHMASK_TRUE;
+
+	qglPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
+	qglDepthMask( GL_TRUE );
+	qglDisable( GL_DEPTH_TEST );
+	qglEnable( GL_SCISSOR_TEST );
+	qglDisable( GL_CULL_FACE );
+	qglDisable( GL_BLEND );
+#ifdef _XBOX
+	qglDisable( GL_LIGHTING );
+#endif
+}
+
+
+/*
+================
+GfxInfo_f
+================
+*/
+void GfxInfo_f( void ) 
+{
+	cvar_t *sys_cpustring = Cvar_Get( "sys_cpustring", "", CVAR_ROM );
+	const char *enablestrings[] =
+	{
+		"disabled",
+		"enabled"
+	};
+	const char *fsstrings[] =
+	{
+		"windowed",
+		"fullscreen"
+	};
+
+	const char *tc_table[] = 
+	{
+		"None",
+		"GL_S3_s3tc",
+		"GL_EXT_texture_compression_s3tc",
+	};
+
+	Com_Printf ("\nGL_VENDOR: %s\n", glConfig.vendor_string );
+	Com_Printf ("GL_RENDERER: %s\n", glConfig.renderer_string );
+	Com_Printf ("GL_VERSION: %s\n", glConfig.version_string );
+	Com_Printf ("GL_EXTENSIONS: %s\n", glConfig.extensions_string );
+	Com_Printf ("GL_MAX_TEXTURE_SIZE: %d\n", glConfig.maxTextureSize );
+	Com_Printf ("GL_MAX_ACTIVE_TEXTURES_ARB: %d\n", glConfig.maxActiveTextures );
+	Com_Printf ("\nPIXELFORMAT: color(%d-bits) Z(%d-bit) stencil(%d-bits)\n", glConfig.colorBits, glConfig.depthBits, glConfig.stencilBits );
+	Com_Printf ("MODE: %d, %d x %d %s hz:", r_mode->integer, glConfig.vidWidth, glConfig.vidHeight, fsstrings[r_fullscreen->integer == 1] );
+	if ( glConfig.displayFrequency )
+	{
+		Com_Printf ("%d\n", glConfig.displayFrequency );
+	}
+	else
+	{
+		Com_Printf ("N/A\n" );
+	}
+	if ( glConfig.deviceSupportsGamma )
+	{
+		Com_Printf ("GAMMA: hardware w/ %d overbright bits\n", tr.overbrightBits );
+	}
+	else
+	{
+		Com_Printf ("GAMMA: software w/ %d overbright bits\n", tr.overbrightBits );
+	}
+	Com_Printf ("CPU: %s @ %s MHz\n", sys_cpustring->string, Cvar_VariableString("sys_cpuspeed") );
+
+	// rendering primitives
+	{
+		int		primitives;
+
+		// default is to use triangles if compiled vertex arrays are present
+		Com_Printf ("rendering primitives: " );
+		primitives = r_primitives->integer;
+		if ( primitives == 0 ) {
+			if ( qglLockArraysEXT ) {
+				primitives = 2;
+			} else {
+				primitives = 1;
+			}
+		}
+		if ( primitives == -1 ) {
+			Com_Printf ("none\n" );
+		} else if ( primitives == 2 ) {
+			Com_Printf ("single glDrawElements\n" );
+		} else if ( primitives == 1 ) {
+			Com_Printf ("multiple glArrayElement\n" );
+		} else if ( primitives == 3 ) {
+			Com_Printf ("multiple glColor4ubv + glTexCoord2fv + glVertex3fv\n" );
+		}
+	}
+
+	Com_Printf ("texturemode: %s\n", r_textureMode->string );
+	Com_Printf ("picmip: %d\n", r_picmip->integer );
+	Com_Printf ("texture bits: %d\n", r_texturebits->integer );
+	Com_Printf ("lightmap texture bits: %d\n", r_texturebitslm->integer );
+	Com_Printf ("multitexture: %s\n", enablestrings[qglActiveTextureARB != 0] );
+	Com_Printf ("compiled vertex arrays: %s\n", enablestrings[qglLockArraysEXT != 0 ] );
+	Com_Printf ("texenv add: %s\n", enablestrings[glConfig.textureEnvAddAvailable != 0] );
+	Com_Printf ("compressed textures: %s\n", enablestrings[glConfig.textureCompression != TC_NONE] );
+	Com_Printf ("compressed lightmaps: %s\n", enablestrings[(r_ext_compressed_lightmaps->integer != 0 && glConfig.textureCompression != TC_NONE)] );
+	Com_Printf ("texture compression method: %s\n", tc_table[glConfig.textureCompression] );
+	Com_Printf ("anisotropic filtering: %s  ", enablestrings[(r_ext_texture_filter_anisotropic->integer != 0) && glConfig.maxTextureFilterAnisotropy] );
+		Com_Printf ("(%f of %f)\n", r_ext_texture_filter_anisotropic->value, glConfig.maxTextureFilterAnisotropy );
+	Com_Printf ("Dynamic Glow: %s\n", enablestrings[r_DynamicGlow->integer] );
+
+	if ( r_finish->integer ) {
+		Com_Printf ("Forcing glFinish\n" );
+	}
+	if ( r_displayRefresh ->integer ) {
+		Com_Printf ("Display refresh set to %d\n", r_displayRefresh->integer );
+	}
+	if (tr.world)
+	{
+		Com_Printf ("Light Grid size set to (%.2f %.2f %.2f)\n", tr.world->lightGridSize[0], tr.world->lightGridSize[1], tr.world->lightGridSize[2] );
+	}
+}
+
+#endif // !DEDICATED
+/*
+===============
+R_Register
+===============
+*/
+void R_Register( void ) 
+{
+	//
+	// latched and archived variables
+	//
+	r_allowExtensions = Cvar_Get( "r_allowExtensions", "1", CVAR_ARCHIVE | CVAR_LATCH );
+	r_ext_compressed_textures = Cvar_Get( "r_ext_compress_textures", "1", CVAR_ARCHIVE | CVAR_LATCH );
+	r_ext_compressed_lightmaps = Cvar_Get( "r_ext_compress_lightmaps", "0", CVAR_ARCHIVE | CVAR_LATCH );
+	r_ext_preferred_tc_method = Cvar_Get( "r_ext_preferred_tc_method", "0", CVAR_ARCHIVE | CVAR_LATCH );
+	r_ext_gamma_control = Cvar_Get( "r_ext_gamma_control", "1", CVAR_ARCHIVE | CVAR_LATCH );
+	r_ext_multitexture = Cvar_Get( "r_ext_multitexture", "1", CVAR_ARCHIVE | CVAR_LATCH );
+	r_ext_compiled_vertex_array = Cvar_Get( "r_ext_compiled_vertex_array", "1", CVAR_ARCHIVE | CVAR_LATCH);
+#ifdef __linux__ // broken on linux
+	r_ext_texture_env_add = Cvar_Get( "r_ext_texture_env_add", "0", CVAR_ARCHIVE | CVAR_LATCH);
+#else
+	r_ext_texture_env_add = Cvar_Get( "r_ext_texture_env_add", "1", CVAR_ARCHIVE | CVAR_LATCH);
+#endif
+	r_ext_texture_filter_anisotropic = Cvar_Get( "r_ext_texture_filter_anisotropic", "16", CVAR_ARCHIVE );
+
+	r_DynamicGlow = Cvar_Get( "r_DynamicGlow", "1", CVAR_ARCHIVE );
+	r_DynamicGlowPasses = Cvar_Get( "r_DynamicGlowPasses", "5", CVAR_CHEAT );
+	r_DynamicGlowDelta  = Cvar_Get( "r_DynamicGlowDelta", "0.8f", CVAR_CHEAT );
+	r_DynamicGlowIntensity = Cvar_Get( "r_DynamicGlowIntensity", "1.13f", CVAR_CHEAT );
+	r_DynamicGlowSoft = Cvar_Get( "r_DynamicGlowSoft", "1", CVAR_CHEAT );
+	r_DynamicGlowWidth = Cvar_Get( "r_DynamicGlowWidth", "320", CVAR_CHEAT | CVAR_LATCH );
+	r_DynamicGlowHeight = Cvar_Get( "r_DynamicGlowHeight", "240", CVAR_CHEAT | CVAR_LATCH );
+
+	r_picmip = Cvar_Get ("r_picmip", "1", CVAR_ARCHIVE | CVAR_LATCH );
+	r_colorMipLevels = Cvar_Get ("r_colorMipLevels", "0", CVAR_LATCH );
+	AssertCvarRange( r_picmip, 0, 16, qtrue );
+	r_detailTextures = Cvar_Get( "r_detailtextures", "1", CVAR_ARCHIVE | CVAR_LATCH );
+	r_texturebits = Cvar_Get( "r_texturebits", "0", CVAR_ARCHIVE | CVAR_LATCH );
+	r_texturebitslm = Cvar_Get( "r_texturebitslm", "0", CVAR_ARCHIVE | CVAR_LATCH );
+	r_colorbits = Cvar_Get( "r_colorbits", "0", CVAR_ARCHIVE | CVAR_LATCH );
+	r_stereo = Cvar_Get( "r_stereo", "0", CVAR_ARCHIVE | CVAR_LATCH );
+#ifdef __linux__
+	r_stencilbits = Cvar_Get( "r_stencilbits", "0", CVAR_ARCHIVE | CVAR_LATCH );
+#else
+	r_stencilbits = Cvar_Get( "r_stencilbits", "8", CVAR_ARCHIVE | CVAR_LATCH );
+#endif
+	r_depthbits = Cvar_Get( "r_depthbits", "0", CVAR_ARCHIVE | CVAR_LATCH );
+	r_overBrightBits = Cvar_Get ("r_overBrightBits", "0", CVAR_ARCHIVE | CVAR_LATCH );
+	r_ignorehwgamma = Cvar_Get( "r_ignorehwgamma", "0", CVAR_ARCHIVE | CVAR_LATCH);
+	r_mode = Cvar_Get( "r_mode", "4", CVAR_ARCHIVE | CVAR_LATCH );
+	r_fullscreen = Cvar_Get( "r_fullscreen", "1", CVAR_ARCHIVE | CVAR_LATCH );
+	r_customwidth = Cvar_Get( "r_customwidth", "1600", CVAR_ARCHIVE | CVAR_LATCH );
+	r_customheight = Cvar_Get( "r_customheight", "1024", CVAR_ARCHIVE | CVAR_LATCH );
+	r_simpleMipMaps = Cvar_Get( "r_simpleMipMaps", "1", CVAR_ARCHIVE | CVAR_LATCH );
+	r_vertexLight = Cvar_Get( "r_vertexLight", "0", CVAR_ARCHIVE | CVAR_LATCH );
+	r_uiFullScreen = Cvar_Get( "r_uifullscreen", "0", 0);
+	r_subdivisions = Cvar_Get ("r_subdivisions", "4", CVAR_ARCHIVE | CVAR_LATCH);
+
+	//
+	// temporary latched variables that can only change over a restart
+	//
+	r_displayRefresh = Cvar_Get( "r_displayRefresh", "0", CVAR_LATCH );
+	AssertCvarRange( r_displayRefresh, 0, 200, qtrue );
+	r_fullbright = Cvar_Get ("r_fullbright", "0", CVAR_CHEAT );
+	r_intensity = Cvar_Get ("r_intensity", "1", CVAR_LATCH );
+	r_singleShader = Cvar_Get ("r_singleShader", "0", CVAR_CHEAT | CVAR_LATCH );
+
+	//
+	// archived variables that can change at any time
+	//
+	r_lodCurveError = Cvar_Get( "r_lodCurveError", "250", CVAR_ARCHIVE );
+	r_lodbias = Cvar_Get( "r_lodbias", "0", CVAR_ARCHIVE );
+	r_autolodscalevalue = Cvar_Get( "r_autolodscalevalue", "0", CVAR_ROM );
+
+	r_flares = Cvar_Get ("r_flares", "1", CVAR_ARCHIVE );
+#ifdef _XBOX
+	r_znear = Cvar_Get( "r_znear", "2", CVAR_CHEAT );
+#else
+	r_znear = Cvar_Get( "r_znear", "4", CVAR_CHEAT );
+#endif
+	AssertCvarRange( r_znear, 0.001f, 200, qtrue );
+	r_ignoreGLErrors = Cvar_Get( "r_ignoreGLErrors", "1", CVAR_ARCHIVE );
+	r_fastsky = Cvar_Get( "r_fastsky", "0", CVAR_ARCHIVE );
+	r_inGameVideo = Cvar_Get( "r_inGameVideo", "1", CVAR_ARCHIVE );
+	r_drawSun = Cvar_Get( "r_drawSun", "0", CVAR_ARCHIVE );
+	r_dynamiclight = Cvar_Get( "r_dynamiclight", "1", CVAR_ARCHIVE );
+// rjr - removed for hacking r_dlightBacks = Cvar_Get( "r_dlightBacks", "1", CVAR_CHEAT );
+	r_finish = Cvar_Get ("r_finish", "0", CVAR_ARCHIVE);
+	r_textureMode = Cvar_Get( "r_textureMode", "GL_LINEAR_MIPMAP_NEAREST", CVAR_ARCHIVE );
+	r_swapInterval = Cvar_Get( "r_swapInterval", "0", CVAR_ARCHIVE );
+	r_markcount = Cvar_Get( "r_markcount", "100", CVAR_ARCHIVE );
+#ifdef __MACOS__
+	r_gamma = Cvar_Get( "r_gamma", "1.2", CVAR_ARCHIVE );
+#else
+	r_gamma = Cvar_Get( "r_gamma", "1", CVAR_ARCHIVE );
+#endif
+	r_facePlaneCull = Cvar_Get ("r_facePlaneCull", "1", CVAR_ARCHIVE );
+
+	r_cullRoofFaces = Cvar_Get ("r_cullRoofFaces", "0", CVAR_CHEAT ); //attempted smart method of culling out upwards facing surfaces on roofs for automap shots -rww
+	r_roofCullCeilDist = Cvar_Get ("r_roofCullCeilDist", "256", CVAR_CHEAT ); //attempted smart method of culling out upwards facing surfaces on roofs for automap shots -rww
+	r_roofCullFloorDist = Cvar_Get ("r_roofCeilFloorDist", "128", CVAR_CHEAT ); //attempted smart method of culling out upwards facing surfaces on roofs for automap shots -rww
+
+	r_primitives = Cvar_Get( "r_primitives", "0", CVAR_ARCHIVE );
+
+	r_ambientScale = Cvar_Get( "r_ambientScale", "0.6", CVAR_CHEAT );
+	r_directedScale = Cvar_Get( "r_directedScale", "1", CVAR_CHEAT );
+
+	r_autoMap = Cvar_Get( "r_autoMap", "0", CVAR_ARCHIVE ); //automap renderside toggle for debugging -rww
+	r_autoMapBackAlpha = Cvar_Get( "r_autoMapBackAlpha", "0", 0 ); //alpha of automap bg -rww
+	r_autoMapDisable = Cvar_Get( "r_autoMapDisable", "1", 0 );
+
+	//
+	// temporary variables that can change at any time
+	//
+	r_showImages = Cvar_Get( "r_showImages", "0", CVAR_CHEAT );
+
+	r_debugLight = Cvar_Get( "r_debuglight", "0", CVAR_TEMP );
+	r_debugSort = Cvar_Get( "r_debugSort", "0", CVAR_CHEAT );
+
+	r_dlightStyle = Cvar_Get ("r_dlightStyle", "1", CVAR_TEMP);
+	r_surfaceSprites = Cvar_Get ("r_surfaceSprites", "1", CVAR_TEMP);
+	r_surfaceWeather = Cvar_Get ("r_surfaceWeather", "0", CVAR_TEMP);
+
+	r_windSpeed = Cvar_Get ("r_windSpeed", "0", 0);
+	r_windAngle = Cvar_Get ("r_windAngle", "0", 0);
+	r_windGust = Cvar_Get ("r_windGust", "0", 0);
+	r_windDampFactor = Cvar_Get ("r_windDampFactor", "0.1", 0);
+	r_windPointForce = Cvar_Get ("r_windPointForce", "0", 0);
+	r_windPointX = Cvar_Get ("r_windPointX", "0", 0);
+	r_windPointY = Cvar_Get ("r_windPointY", "0", 0);
+
+	r_nocurves = Cvar_Get ("r_nocurves", "0", CVAR_CHEAT );
+	r_drawworld = Cvar_Get ("r_drawworld", "1", CVAR_CHEAT );
+	r_drawfog = Cvar_Get ("r_drawfog", "2", CVAR_CHEAT );
+	r_lightmap = Cvar_Get ("r_lightmap", "0", CVAR_CHEAT );
+	r_portalOnly = Cvar_Get ("r_portalOnly", "0", CVAR_CHEAT );
+
+	r_skipBackEnd = Cvar_Get ("r_skipBackEnd", "0", CVAR_CHEAT);
+
+	r_measureOverdraw = Cvar_Get( "r_measureOverdraw", "0", CVAR_CHEAT );
+	r_lodscale = Cvar_Get( "r_lodscale", "5", 0 );
+	r_norefresh = Cvar_Get ("r_norefresh", "0", CVAR_CHEAT);
+	r_drawentities = Cvar_Get ("r_drawentities", "1", CVAR_CHEAT );
+	r_ignore = Cvar_Get( "r_ignore", "1", CVAR_CHEAT );
+	r_nocull = Cvar_Get ("r_nocull", "0", CVAR_CHEAT);
+	r_novis = Cvar_Get ("r_novis", "0", CVAR_CHEAT);
+	r_showcluster = Cvar_Get ("r_showcluster", "0", CVAR_CHEAT);
+	r_speeds = Cvar_Get ("r_speeds", "0", CVAR_CHEAT);
+	r_verbose = Cvar_Get( "r_verbose", "0", CVAR_CHEAT );
+	r_logFile = Cvar_Get( "r_logFile", "0", CVAR_CHEAT );
+	r_debugSurface = Cvar_Get ("r_debugSurface", "0", CVAR_CHEAT);
+	r_nobind = Cvar_Get ("r_nobind", "0", CVAR_CHEAT);
+	r_showtris = Cvar_Get ("r_showtris", "0", CVAR_CHEAT);
+	r_showsky = Cvar_Get ("r_showsky", "0", CVAR_CHEAT);
+	r_shownormals = Cvar_Get ("r_shownormals", "0", CVAR_CHEAT);
+	r_clear = Cvar_Get ("r_clear", "0", CVAR_CHEAT);
+	r_offsetFactor = Cvar_Get( "r_offsetfactor", "-1", CVAR_CHEAT );
+	r_offsetUnits = Cvar_Get( "r_offsetunits", "-2", CVAR_CHEAT );
+	r_lockpvs = Cvar_Get ("r_lockpvs", "0", CVAR_CHEAT);
+	r_noportals = Cvar_Get ("r_noportals", "0", CVAR_CHEAT);
+	r_shadows = Cvar_Get( "cg_shadows", "1", 0 );
+	r_shadowRange = Cvar_Get( "r_shadowRange", "1000", 0 );
+
+#ifdef _XBOX
+	r_hdreffect = Cvar_Get( "r_hdreffect", "0", 0 );
+	r_sundir_x = Cvar_Get( "r_sundir_x", "0.45", 0 );
+	r_sundir_y = Cvar_Get( "r_sundir_y", "0.3", 0 );
+	r_sundir_z = Cvar_Get( "r_sundir_z", "0.9", 0 );
+	r_hdrbloom = Cvar_Get( "r_hdrbloom", "1.0", 0 );
+#endif
+
+	r_maxpolys = Cvar_Get( "r_maxpolys", va("%d", MAX_POLYS), 0);
+	r_maxpolyverts = Cvar_Get( "r_maxpolyverts", va("%d", MAX_POLYVERTS), 0);
+/*
+Ghoul2 Insert Start
+*/
+#ifdef _DEBUG
+	r_noPrecacheGLA = Cvar_Get( "r_noPrecacheGLA", "0", CVAR_CHEAT);
+#endif
+
+	r_noServerGhoul2 = Cvar_Get( "r_noserverghoul2", "0", CVAR_CHEAT);
+
+	r_Ghoul2AnimSmooth = Cvar_Get( "r_ghoul2animsmooth", "0.3", 0 );
+	r_Ghoul2UnSqashAfterSmooth = Cvar_Get( "r_ghoul2unsqashaftersmooth", "1", 0 );
+
+	broadsword = Cvar_Get( "broadsword", "0", 0);
+	broadsword_kickbones = Cvar_Get( "broadsword_kickbones", "1", 0);
+	broadsword_kickorigin = Cvar_Get( "broadsword_kickorigin", "1", 0);
+	broadsword_dontstopanim = Cvar_Get( "broadsword_dontstopanim", "0", 0);
+	broadsword_waitforshot = Cvar_Get( "broadsword_waitforshot", "0", 0);
+	broadsword_playflop = Cvar_Get( "broadsword_playflop", "1", 0);
+	broadsword_smallbbox = Cvar_Get( "broadsword_smallbbox", "0", 0);
+	broadsword_extra1 = Cvar_Get( "broadsword_extra1", "0", 0);
+	broadsword_extra2 = Cvar_Get( "broadsword_extra2", "0", 0);
+	broadsword_effcorr = Cvar_Get( "broadsword_effcorr", "1", 0);
+	broadsword_ragtobase = Cvar_Get( "broadsword_ragtobase", "2", 0);
+	broadsword_dircap = Cvar_Get( "broadsword_dircap", "64", 0);
+/*
+Ghoul2 Insert End
+*/
+extern qboolean Sys_LowPhysicalMemory();
+	r_modelpoolmegs = Cvar_Get("r_modelpoolmegs", "20", CVAR_ARCHIVE);
+	if (Sys_LowPhysicalMemory() )
+	{
+		Cvar_Set("r_modelpoolmegs", "0");
+	}
+
+	// make sure all the commands added here are also
+	// removed in R_Shutdown
+#ifndef DEDICATED
+	Cmd_AddCommand( "imagelist", R_ImageList_f );
+	Cmd_AddCommand( "shaderlist", R_ShaderList_f );
+	Cmd_AddCommand( "skinlist", R_SkinList_f );
+	Cmd_AddCommand( "screenshot", R_ScreenShot_f );
+	Cmd_AddCommand( "screenshot_tga", R_ScreenShotTGA_f );
+	Cmd_AddCommand( "gfxinfo", GfxInfo_f );
+	Cmd_AddCommand( "r_we", R_WorldEffect_f);
+	Cmd_AddCommand( "imagecacheinfo", RE_RegisterImages_Info_f);
+#endif
+	Cmd_AddCommand( "modellist", R_Modellist_f );
+#ifndef _XBOX
+	Cmd_AddCommand( "modelist", R_ModeList_f );
+#endif
+	Cmd_AddCommand( "modelcacheinfo", RE_RegisterModels_Info_f);
+
+}
+
+
+/*
+===============
+R_Init
+===============
+*/
+extern void R_InitWorldEffects(void); //tr_WorldEffects.cpp
+void R_Init( void ) {	
+	int i;
+	byte *ptr;
+
+//	Com_Printf ("----- R_Init -----\n" );
+#ifdef _XBOX
+	/*
+	Hunk_Clear();
+		
+	extern void CM_Free(void);
+	CM_Free();
+	*/
+
+	//Save visibility info as it has already been set.
+	SPARC<byte> *vis = tr.externalVisData;
+#endif
+
+	// clear all our internal state
+	Com_Memset( &tr, 0, sizeof( tr ) );
+	Com_Memset( &backEnd, 0, sizeof( backEnd ) );
+#ifndef DEDICATED
+	Com_Memset( &tess, 0, sizeof( tess ) );
+#endif
+
+#ifdef _XBOX
+	//Restore visibility info.
+	tr.externalVisData = vis;
+#endif
+
+//	Swap_Init();
+
+#ifndef DEDICATED
+#ifndef FINAL_BUILD
+	if ( (int)tess.xyz & 15 ) {
+		Com_Printf( "WARNING: tess.xyz not 16 byte aligned (%x)\n",(int)tess.xyz & 15 );
+	}
+#endif
+#endif
+	//
+	// init function tables
+	//
+	for ( i = 0; i < FUNCTABLE_SIZE; i++ )
+	{
+		tr.sinTable[i]		= sin( DEG2RAD( i * 360.0f / ( ( float ) ( FUNCTABLE_SIZE - 1 ) ) ) );
+		tr.squareTable[i]	= ( i < FUNCTABLE_SIZE/2 ) ? 1.0f : -1.0f;
+		tr.sawToothTable[i] = (float)i / FUNCTABLE_SIZE;
+		tr.inverseSawToothTable[i] = 1.0f - tr.sawToothTable[i];
+
+		if ( i < FUNCTABLE_SIZE / 2 )
+		{
+			if ( i < FUNCTABLE_SIZE / 4 )
+			{
+				tr.triangleTable[i] = ( float ) i / ( FUNCTABLE_SIZE / 4 );
+			}
+			else
+			{
+				tr.triangleTable[i] = 1.0f - tr.triangleTable[i-FUNCTABLE_SIZE / 4];
+			}
+		}
+		else
+		{
+			tr.triangleTable[i] = -tr.triangleTable[i-FUNCTABLE_SIZE/2];
+		}
+	}
+#ifndef DEDICATED
+	R_InitFogTable();
+
+	R_NoiseInit();
+#endif
+	R_Register();
+
+	max_polys = r_maxpolys->integer;
+	if (max_polys < MAX_POLYS)
+		max_polys = MAX_POLYS;
+
+	max_polyverts = r_maxpolyverts->integer;
+	if (max_polyverts < MAX_POLYVERTS)
+		max_polyverts = MAX_POLYVERTS;
+
+	ptr = (unsigned char *)Hunk_Alloc( sizeof( *backEndData ) + sizeof(srfPoly_t) * max_polys + sizeof(polyVert_t) * max_polyverts, h_low);
+	backEndData = (backEndData_t *) ptr;
+	backEndData->polys = (srfPoly_t *) ((char *) ptr + sizeof( *backEndData ));
+	backEndData->polyVerts = (polyVert_t *) ((char *) ptr + sizeof( *backEndData ) + sizeof(srfPoly_t) * max_polys);
+#ifndef DEDICATED
+	R_ToggleSmpFrame();
+
+	for(i = 0; i < MAX_LIGHT_STYLES; i++)
+	{
+		RE_SetLightStyle(i, -1);
+	}
+	InitOpenGL();
+
+	R_InitImages();
+	R_InitShaders(qfalse);
+	R_InitSkins();
+
+	R_TerrainInit(); //rwwRMG - added
+
+	R_InitFonts();
+#endif
+	R_ModelInit();
+	G2VertSpaceServer = &CMiniHeap_singleton;
+#ifndef DEDICATED
+	R_InitDecals ( );
+
+	R_InitWorldEffects();
+
+	int	err = qglGetError();
+	if ( err != GL_NO_ERROR )
+		Com_Printf ( "glGetError() = 0x%x\n", err);
+#endif
+//	Com_Printf ("----- finished R_Init -----\n" );
+}
+
+/*
+===============
+RE_Shutdown
+===============
+*/
+void RE_Shutdown( qboolean destroyWindow ) {	
+
+//	Com_Printf ("RE_Shutdown( %i )\n", destroyWindow );
+
+	Cmd_RemoveCommand ("imagelist");
+	Cmd_RemoveCommand ("shaderlist");
+	Cmd_RemoveCommand ("skinlist");
+	Cmd_RemoveCommand ("screenshot");
+	Cmd_RemoveCommand ("screenshot_tga");
+	Cmd_RemoveCommand ("gfxinfo");
+	Cmd_RemoveCommand ("r_we");
+	Cmd_RemoveCommand ("imagecacheinfo");
+	Cmd_RemoveCommand ("modellist");
+	Cmd_RemoveCommand ("modelist");
+	Cmd_RemoveCommand ("modelcacheinfo");
+#ifndef DEDICATED
+
+#ifndef _XBOX	// GLOWXXX
+	if ( r_DynamicGlow && r_DynamicGlow->integer )
+	{
+		// Release the Glow Vertex Shader.
+		if ( tr.glowVShader )
+		{
+			qglDeleteProgramsARB( 1, &tr.glowVShader );
+		}
+
+		// Release Pixel Shader.
+		if ( tr.glowPShader )
+		{
+			if ( qglCombinerParameteriNV  )
+			{
+				// Release the Glow Regcom call list.
+				qglDeleteLists( tr.glowPShader, 1 );
+			}
+			else if ( qglGenProgramsARB )
+			{
+				// Release the Glow Fragment Shader.
+				qglDeleteProgramsARB( 1, &tr.glowPShader );
+			}
+		}
+
+		// Release the scene glow texture.
+		qglDeleteTextures( 1, &tr.screenGlow );
+
+		// Release the scene texture.
+		qglDeleteTextures( 1, &tr.sceneImage );
+
+		// Release the blur texture.
+		qglDeleteTextures( 1, &tr.blurImage );
+	}
+#endif
+
+	R_TerrainShutdown(); //rwwRMG - added
+
+	R_ShutdownFonts();
+	if ( tr.registered ) {
+		R_SyncRenderThread();
+		R_ShutdownCommandBuffers();
+//#ifndef _XBOX
+		if (destroyWindow)
+//#endif
+		{
+			R_DeleteTextures();		// only do this for vid_restart now, not during things like map load
+		}
+	}
+
+	// shut down platform specific OpenGL stuff
+	if ( destroyWindow ) {
+		GLimp_Shutdown();
+	}
+#endif //!DEDICATED
+
+	tr.registered = qfalse;
+}
+
+#ifndef DEDICATED
+
+/*
+=============
+RE_EndRegistration
+
+Touch all images to make sure they are resident
+=============
+*/
+void RE_EndRegistration( void ) {
+	R_SyncRenderThread();
+	if (!Sys_LowPhysicalMemory()) {
+#ifndef _XBOX
+		RB_ShowImages();
+#endif
+	}
+}
+
+void RE_GetLightStyle(int style, color4ub_t color)
+{
+	if (style >= MAX_LIGHT_STYLES)
+	{
+	    Com_Error( ERR_FATAL, "RE_GetLightStyle: %d is out of range", (int)style );
+		return;
+	}
+
+	*(int *)color = *(int *)styleColors[style];
+}
+
+void RE_SetLightStyle(int style, int color)
+{
+	if (style >= MAX_LIGHT_STYLES)
+	{
+	    Com_Error( ERR_FATAL, "RE_SetLightStyle: %d is out of range", (int)style );
+		return;
+	}
+
+	if (*(int*)styleColors[style] != color)
+	{
+		*(int *)styleColors[style] = color;
+	}
+}
+
+#endif //!DEDICATED
+/*
+@@@@@@@@@@@@@@@@@@@@@
+GetRefAPI
+
+@@@@@@@@@@@@@@@@@@@@@
+*/
+refexport_t *GetRefAPI ( int apiVersion ) {
+	static refexport_t	re;
+
+	Com_Memset( &re, 0, sizeof( re ) );
+
+	if ( apiVersion != REF_API_VERSION ) {
+		Com_Printf ( "Mismatched REF_API_VERSION: expected %i, got %i\n", 
+			REF_API_VERSION, apiVersion );
+		return NULL;
+	}
+
+	// the RE_ functions are Renderer Entry points
+
+	re.Shutdown = RE_Shutdown;
+#ifndef DEDICATED
+	re.BeginRegistration = RE_BeginRegistration;
+	re.RegisterModel = RE_RegisterModel;
+	re.RegisterSkin = RE_RegisterSkin;
+	re.RegisterShader = RE_RegisterShader;
+	re.RegisterShaderNoMip = RE_RegisterShaderNoMip;
+	re.ShaderNameFromIndex = RE_ShaderNameFromIndex;
+	re.LoadWorld = RE_LoadWorldMap;
+	re.SetWorldVisData = RE_SetWorldVisData;
+	re.EndRegistration = RE_EndRegistration;
+
+	re.BeginFrame = RE_BeginFrame;
+	re.EndFrame = RE_EndFrame;
+
+	re.MarkFragments = R_MarkFragments;
+	re.LerpTag = R_LerpTag;
+	re.ModelBounds = R_ModelBounds;
+
+	re.DrawRotatePic = RE_RotatePic;
+	re.DrawRotatePic2 = RE_RotatePic2;
+
+	re.ClearScene = RE_ClearScene;
+	re.ClearDecals = RE_ClearDecals;
+	re.AddRefEntityToScene = RE_AddRefEntityToScene;
+	re.AddMiniRefEntityToScene = RE_AddMiniRefEntityToScene;
+	re.AddPolyToScene = RE_AddPolyToScene;
+	re.AddDecalToScene = RE_AddDecalToScene;
+	re.LightForPoint = R_LightForPoint;
+#ifndef VV_LIGHTING
+	re.AddLightToScene = RE_AddLightToScene;
+	re.AddAdditiveLightToScene = RE_AddAdditiveLightToScene;
+#endif
+	re.RenderScene = RE_RenderScene;
+
+	re.SetColor = RE_SetColor;
+	re.DrawStretchPic = RE_StretchPic;
+	re.DrawStretchRaw = RE_StretchRaw;
+	re.UploadCinematic = RE_UploadCinematic;
+
+	re.RegisterFont = RE_RegisterFont;
+	re.Font_StrLenPixels = RE_Font_StrLenPixels;
+	re.Font_StrLenChars = RE_Font_StrLenChars;
+	re.Font_HeightPixels = RE_Font_HeightPixels;
+	re.Font_DrawString = RE_Font_DrawString;
+	re.Language_IsAsian = Language_IsAsian;
+	re.Language_UsesSpaces = Language_UsesSpaces;
+	re.AnyLanguage_ReadCharFromString = AnyLanguage_ReadCharFromString;
+
+	re.RemapShader = R_RemapShader;
+	re.GetEntityToken = R_GetEntityToken;
+	re.inPVS = R_inPVS;
+
+	re.GetLightStyle = RE_GetLightStyle;
+	re.SetLightStyle = RE_SetLightStyle;
+
+	re.GetBModelVerts = RE_GetBModelVerts;
+#endif //!DEDICATED
+	return &re;
+}
+
diff --git a/codemp/renderer/tr_landscape.h b/codemp/renderer/tr_landscape.h
new file mode 100644
index 0000000..bfdd78e
--- /dev/null
+++ b/codemp/renderer/tr_landscape.h
@@ -0,0 +1,191 @@
+#ifndef _INC_LANDSCAPE_H
+#define _INC_LANDSCAPE_H
+
+// Number of TriTreeNodes available
+#define POOL_SIZE				(50000)
+
+#define TEXTURE_ALPHA_TL		0x000000ff
+#define TEXTURE_ALPHA_TR		0x0000ff00
+#define TEXTURE_ALPHA_BL		0x00ff0000
+#define TEXTURE_ALPHA_BR		0x000000ff
+
+#define INDEX_TL				0
+#define INDEX_TR				1
+#define INDEX_BL				2
+#define INDEX_BR				3
+
+#define VARIANCE_MIN			0.0f
+#define VARIANCE_MAX			2000.0f
+#define SPLIT_VARIANCE_SIZE		20
+#define SPLIT_VARIANCE_STEP		(VARIANCE_MAX / SPLIT_VARIANCE_SIZE)
+
+class CTerVert
+{
+public:
+	vec3_t		coords;					// real world coords of terxel
+	vec3_t		normal;					// required to calculate lighting and used in physics
+	color4ub_t	tint;					// tint at this terxel
+	float		tex[2];					// texture coordinates at this terxel
+	int			height;					// Copy of heightmap data
+	int			tessIndex;				// Index of the vert in the tess array
+	int			tessRegistration;		// ...... for the tess with this registration
+
+	CTerVert( void ) { memset(this, 0, sizeof(*this)); }
+	~CTerVert( void ) { }
+};
+
+class CTRHeightDetails
+{
+private:
+	qhandle_t	mShader;
+public:
+	CTRHeightDetails( void ) { }
+	~CTRHeightDetails( void ) { }
+
+	const qhandle_t GetShader( void ) const { return(mShader); }
+	void SetShader(const qhandle_t shader) { mShader = shader; }
+};
+
+//
+// Information of each patch (tessellated area) of a CTRLandScape
+//
+class CTRPatch
+{
+private:
+	class CCMLandScape	*owner;
+	class CTRLandScape	*localowner;
+
+	CCMPatch			*common;
+	vec3_t				mCenter;									// Real world center of the patch
+//	vec3_t				mNormal[2];
+//	float				mDistance[2];
+
+	CTerVert			*mRenderMap;								// Modulation value and texture coords per vertex
+	shader_t			*mTLShader;		 							// Dynamically created blended shader for the top left triangle
+	shader_t			*mBRShader;		 							// Dynamically created blended shader for the bottom right triangle
+
+	bool				misVisible;									// Is this patch visible in the current frame?
+
+public:
+	CTRPatch(void) { }
+	~CTRPatch(void) { }
+
+	// Accessors
+	const vec3_t &GetWorld(void) const { return(common->GetWorld()); }
+	const vec3_t &GetMins(void) const { return(common->GetMins()); }
+	const vec3_t &GetMaxs(void) const { return(common->GetMaxs()); }
+	const vec3pair_t &GetBounds(void) const { return(common->GetBounds()); }
+	shader_t			*GetTLShader(void) { return mTLShader; }
+	shader_t			*GetBRShader(void) { return mBRShader; }
+
+	void SetCommon(CCMPatch *in) { common = in; }
+	const CCMPatch *GetCommon(void) const { return(common); }
+	bool isVisible(void) { return(misVisible); }
+	void SetTLShader(qhandle_t in) { mTLShader = R_GetShaderByHandle(in); }
+	void SetBRShader(qhandle_t in) { mBRShader = R_GetShaderByHandle(in); }
+	void SetOwner(CCMLandScape *in) { owner = in; } 
+	void SetLocalOwner(CTRLandScape *in) { localowner = in; } 
+	void Clear(void) { memset(this, 0, sizeof(*this));  }
+	void SetCenter(void) { VectorAverage(common->GetMins(), common->GetMaxs(), mCenter); }
+	void CalcNormal(void);
+
+	// Prototypes
+	void SetVisibility(bool visCheck);
+	void RenderCorner(ivec5_t corner);
+	void Render(int Part);
+	void RecurseRender(int depth, ivec5_t left, ivec5_t right, ivec5_t apex);
+	void SetRenderMap(const int x, const int y);
+	int RenderWaterVert(int x, int y);
+	void RenderWater(void);
+	const bool HasWater(void) const;
+};
+
+
+#define	PI_TOP		1
+#define PI_BOTTOM	2
+#define PI_BOTH		3
+
+typedef struct SPatchInfo
+{
+	CTRPatch	*mPatch;
+	shader_t	*mShader;
+	int			mPart;
+} TPatchInfo;
+
+//
+// The master class used to define an area of terrain
+//
+
+class CTRLandScape
+{
+private:
+	const CCMLandScape	*common;
+	CTRPatch			*mTRPatches;							// Local patch info
+	TPatchInfo			*mSortedPatches;
+
+	int					mPatchMinx, mPatchMaxx;
+	int					mPatchMiny, mPatchMaxy;
+	int					mMaxNode;								// terxels * terxels = exit condition for splitting
+	int					mSortedCount;
+
+	float				mPatchSize;
+
+	shader_t			*mShader;  								// shader the terrain got its contents from
+						
+	CTerVert			*mRenderMap;							// modulation value and texture coords per vertex
+	float				mTextureScale;							// Scale of texture mapped to terrain
+						
+	float				mScalarSize;
+						
+	shader_t			*mWaterShader;							// Water shader
+	qhandle_t			mFlatShader;							// Flat ground shader	
+
+	CTRHeightDetails	mHeightDetails[HEIGHT_RESOLUTION];		// Array of info specific to height
+#if	_DEBUG
+	int					mCycleCount;
+#endif
+public:
+	CTRLandScape(const char *configstring);
+	~CTRLandScape(void);
+
+	// Accessors
+	const int GetBlockWidth(void) const { return(common->GetBlockWidth()); }
+	const int GetBlockHeight(void) const { return(common->GetBlockHeight()); }
+	const vec3_t &GetMins(void) const { return(common->GetMins()); }
+	const vec3_t &GetMaxs(void) const { return(common->GetMaxs()); }
+	const vec3_t &GetTerxelSize(void) const { return(common->GetTerxelSize()); }
+	const vec3_t &GetPatchSize(void) const { return(common->GetPatchSize()); }
+	const int GetWidth(void) const { return(common->GetWidth()); }
+	const int GetHeight(void) const { return(common->GetHeight()); }
+	const int GetRealWidth(void) const { return(common->GetRealWidth()); }
+	const int GetRealHeight(void) const { return(common->GetRealHeight()); }
+
+	void SetCommon(const CCMLandScape *landscape) { common = landscape; }
+	const CCMLandScape *GetCommon( void ) const { return(common); }
+	const thandle_t GetCommonId( void ) const { return(common->GetTerrainId()); }
+	shader_t	*GetShader(void) const { return(mShader); }
+	CTerVert *GetRenderMap(const int x, const int y) const { return(mRenderMap + x + (y * common->GetRealWidth())); }
+	CTRPatch *GetPatch(const int x, const int y) const { return(mTRPatches + (common->GetBlockWidth() * y) + x); }
+	const CTRHeightDetails *GetHeightDetail(int height) const { return(mHeightDetails + height); }
+	const float GetScalarSize(void) const { return(mScalarSize); }
+	const int GetMaxNode(void) const { return(mMaxNode); }
+
+	// Prototypes
+	void CalculateRegion(void);
+	void Reset(bool visCheck = true);
+	void Render(void);
+	void CalculateRealCoords(void);
+	void CalculateNormals(void);
+	void CalculateTextureCoords(void);
+	void CalculateLighting(void);
+	void CalculateShaders(void);
+	qhandle_t GetBlendedShader(qhandle_t a, qhandle_t b, qhandle_t c, bool surfaceSprites);
+	void LoadTerrainDef(const char *td);
+	void CopyHeightMap(void);
+	void SetShaders(const int height, const qhandle_t shader);
+};
+
+void R_CalcTerrainVisBounds(CTRLandScape *landscape);
+void R_AddTerrainSurfaces(void);
+
+#endif //INC_LANDSCAPE_H
diff --git a/codemp/renderer/tr_light.cpp b/codemp/renderer/tr_light.cpp
new file mode 100644
index 0000000..487283c
--- /dev/null
+++ b/codemp/renderer/tr_light.cpp
@@ -0,0 +1,483 @@
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+// tr_light.c
+
+#include "tr_local.h"
+
+#define	DLIGHT_AT_RADIUS		16
+// at the edge of a dlight's influence, this amount of light will be added
+
+#define	DLIGHT_MINIMUM_RADIUS	16		
+// never calculate a range less than this to prevent huge light numbers
+
+
+/*
+===============
+R_TransformDlights
+
+Transforms the origins of an array of dlights.
+Used by both the front end (for DlightBmodel) and
+the back end (before doing the lighting calculation)
+===============
+*/
+void R_TransformDlights( int count, dlight_t *dl, orientationr_t *ori) {
+	int		i;
+	vec3_t	temp;
+
+	for ( i = 0 ; i < count ; i++, dl++ ) {
+		VectorSubtract( dl->origin, ori->origin, temp );
+		dl->transformed[0] = DotProduct( temp, ori->axis[0] );
+		dl->transformed[1] = DotProduct( temp, ori->axis[1] );
+		dl->transformed[2] = DotProduct( temp, ori->axis[2] );
+	}
+}
+
+/*
+=============
+R_DlightBmodel
+
+Determine which dynamic lights may effect this bmodel
+=============
+*/
+#ifndef VV_LIGHTING
+void R_DlightBmodel( bmodel_t *bmodel, bool NoLight )
+{ //rwwRMG - modified args
+	int			i, j;
+	dlight_t	*dl;
+	int			mask;
+	msurface_t	*surf;
+
+	// transform all the lights
+	R_TransformDlights( tr.refdef.num_dlights, tr.refdef.dlights, &tr.ori );
+
+	mask = 0;
+	if (!NoLight)
+	{
+		for ( i=0 ; i<tr.refdef.num_dlights ; i++ ) {
+			dl = &tr.refdef.dlights[i];
+
+			// see if the point is close enough to the bounds to matter
+			for ( j = 0 ; j < 3 ; j++ ) {
+				if ( dl->transformed[j] - bmodel->bounds[1][j] > dl->radius ) {
+					break;
+				}
+				if ( bmodel->bounds[0][j] - dl->transformed[j] > dl->radius ) {
+					break;
+				}
+			}
+			if ( j < 3 ) {
+				continue;
+			}
+
+			// we need to check this light
+			mask |= 1 << i;
+		}
+	}
+
+	tr.currentEntity->needDlights = (qboolean)(mask != 0);
+	tr.currentEntity->dlightBits = mask;
+
+	// set the dlight bits in all the surfaces
+	for ( i = 0 ; i < bmodel->numSurfaces ; i++ ) {
+		surf = bmodel->firstSurface + i;
+		if ( *surf->data == SF_FACE ) {
+			((srfSurfaceFace_t *)surf->data)->dlightBits = mask;
+		} else if ( *surf->data == SF_GRID ) {
+			((srfGridMesh_t *)surf->data)->dlightBits = mask;
+		} else if ( *surf->data == SF_TRIANGLES ) {
+			((srfTriangles_t *)surf->data)->dlightBits = mask;
+		}
+	}
+}
+#endif
+
+
+/*
+=============================================================================
+
+LIGHT SAMPLING
+
+=============================================================================
+*/
+
+extern	cvar_t	*r_ambientScale;
+extern	cvar_t	*r_directedScale;
+extern	cvar_t	*r_debugLight;
+
+//rwwRMG - VectorScaleVector is now a #define
+
+/*
+=================
+R_SetupEntityLightingGrid
+
+=================
+*/
+#ifdef VV_LIGHTING
+void R_SetupEntityLightingGrid( trRefEntity_t *ent) {
+#else
+static void R_SetupEntityLightingGrid( trRefEntity_t *ent ) {
+#endif
+	vec3_t			lightOrigin;
+	int				pos[3];
+	int				i, j;
+	float			frac[3];
+	int				gridStep[3];
+	vec3_t			direction;
+	float			totalFactor;
+	unsigned short	*startGridPos;
+#ifdef _XBOX
+	byte zeroArray[3];
+	byte style;
+
+	zeroArray[0] = zeroArray[1] = zeroArray[2] = 0;
+#endif
+
+
+	if (r_fullbright->integer)
+	{
+		ent->ambientLight[0] = ent->ambientLight[1] = ent->ambientLight[2] = 255.0;
+		ent->directedLight[0] = ent->directedLight[1] = ent->directedLight[2] = 255.0;
+		VectorCopy( tr.sunDirection, ent->lightDir );
+		return;
+	}
+
+	if ( ent->e.renderfx & RF_LIGHTING_ORIGIN ) {
+		// seperate lightOrigins are needed so an object that is
+		// sinking into the ground can still be lit, and so
+		// multi-part models can be lit identically
+		VectorCopy( ent->e.lightingOrigin, lightOrigin );
+	} else {
+		VectorCopy( ent->e.origin, lightOrigin );
+	}
+
+	VectorSubtract( lightOrigin, tr.world->lightGridOrigin, lightOrigin );
+	for ( i = 0 ; i < 3 ; i++ ) {
+		float	v;
+
+		v = lightOrigin[i]*tr.world->lightGridInverseSize[i];
+		pos[i] = floor( v );
+		frac[i] = v - pos[i];
+		if ( pos[i] < 0 ) {
+			pos[i] = 0;
+		} else if ( pos[i] >= tr.world->lightGridBounds[i] - 1 ) {
+			pos[i] = tr.world->lightGridBounds[i] - 1;
+		}
+	}
+
+	VectorClear( ent->ambientLight );
+	VectorClear( ent->directedLight );
+	VectorClear( direction );
+
+	// trilerp the light value
+	gridStep[0] = 1;
+	gridStep[1] = tr.world->lightGridBounds[0];
+	gridStep[2] = tr.world->lightGridBounds[0] * tr.world->lightGridBounds[1];
+	startGridPos = tr.world->lightGridArray + (pos[0] * gridStep[0] + pos[1] * gridStep[1] + pos[2] * gridStep[2]);
+
+	totalFactor = 0;
+	for ( i = 0 ; i < 8 ; i++ ) {
+		float			factor;
+		mgrid_t			*data;
+		unsigned short	*gridPos;
+		int				lat, lng;
+		vec3_t			normal;
+
+		factor = 1.0;
+		gridPos = startGridPos;
+		for ( j = 0 ; j < 3 ; j++ ) {
+			if ( i & (1<<j) ) {
+				factor *= frac[j];
+				gridPos += gridStep[j];
+			} else {
+				factor *= (1.0 - frac[j]);
+			}
+		}
+
+		if (gridPos >= tr.world->lightGridArray + tr.world->numGridArrayElements)
+		{//we've gone off the array somehow
+			continue;
+		}
+		data = tr.world->lightGridData + *gridPos;
+
+#ifdef _XBOX
+		const byte *memory = (const byte *)tr.world->lightGridData + data->data;
+
+		style = data->flags & (1 << 4) ? memory[0] : LS_LSNONE;
+		if ( style == LS_LSNONE ) 
+		{
+			continue;	// ignore samples in walls
+		}
+
+		totalFactor += factor;
+
+		const byte *array;
+
+		for(j=0;j<MAXLIGHTMAPS;j++)
+		{
+			if(data->flags & (1 << (j + 4))) {
+				style = *memory;
+				memory++;
+			} else {
+				style = LS_LSNONE;
+			}
+
+			if (style != LS_LSNONE)
+			{
+				if(data->flags & (1 << j)) {
+					array = memory;
+					memory += 3;
+				} else {
+					array = zeroArray;
+				}
+
+				ent->ambientLight[0] += factor * array[0] * styleColors[style][0] / 255.0f;
+				ent->ambientLight[1] += factor * array[1] * styleColors[style][1] / 255.0f;
+				ent->ambientLight[2] += factor * array[2] * styleColors[style][2] / 255.0f;
+
+				if(array != zeroArray) {
+					array = memory;
+					memory += 3;
+				} 
+
+				ent->directedLight[0] += factor * array[0] * styleColors[style][0] / 255.0f;
+				ent->directedLight[1] += factor * array[1] * styleColors[style][1] / 255.0f;
+				ent->directedLight[2] += factor * array[2] * styleColors[style][2] / 255.0f;
+			}
+			else
+			{
+				break;
+			}
+		}
+
+#else // _XBOX
+
+		if ( data->styles[0] == LS_LSNONE ) 
+		{
+			continue;	// ignore samples in walls
+		}
+
+		totalFactor += factor;
+
+		for(j=0;j<MAXLIGHTMAPS;j++)
+		{
+			if (data->styles[j] != LS_LSNONE)
+			{
+				const byte	style= data->styles[j];
+
+				ent->ambientLight[0] += factor * data->ambientLight[j][0] * styleColors[style][0] / 255.0f;
+				ent->ambientLight[1] += factor * data->ambientLight[j][1] * styleColors[style][1] / 255.0f;
+				ent->ambientLight[2] += factor * data->ambientLight[j][2] * styleColors[style][2] / 255.0f;
+
+				ent->directedLight[0] += factor * data->directLight[j][0] * styleColors[style][0] / 255.0f;
+				ent->directedLight[1] += factor * data->directLight[j][1] * styleColors[style][1] / 255.0f;
+				ent->directedLight[2] += factor * data->directLight[j][2] * styleColors[style][2] / 255.0f;
+			}
+			else
+			{
+				break;
+			}
+		}
+#endif // _XBOX
+
+		lat = data->latLong[1];
+		lng = data->latLong[0];
+		lat *= (FUNCTABLE_SIZE/256);
+		lng *= (FUNCTABLE_SIZE/256);
+
+		// decode X as cos( lat ) * sin( long )
+		// decode Y as sin( lat ) * sin( long )
+		// decode Z as cos( long )
+
+		normal[0] = tr.sinTable[(lat + (FUNCTABLE_SIZE / 4)) & FUNCTABLE_MASK] * tr.sinTable[lng];
+		normal[1] = tr.sinTable[lat] * tr.sinTable[lng];
+		normal[2] = tr.sinTable[(lng + (FUNCTABLE_SIZE / 4)) & FUNCTABLE_MASK];
+
+		VectorMA( direction, factor, normal, direction );
+	}
+
+	if ( totalFactor > 0 && totalFactor < 0.99 ) 
+	{
+		totalFactor = 1.0 / totalFactor;
+		VectorScale( ent->ambientLight, totalFactor, ent->ambientLight );
+		VectorScale( ent->directedLight, totalFactor, ent->directedLight );
+	}
+
+	VectorScale( ent->ambientLight, r_ambientScale->value, ent->ambientLight );
+	VectorScale( ent->directedLight, r_directedScale->value, ent->directedLight );
+
+	VectorNormalize2( direction, ent->lightDir );
+}
+
+
+/*
+===============
+LogLight
+===============
+*/
+static void LogLight( trRefEntity_t *ent ) {
+	int	max1, max2;
+
+	if ( !(ent->e.renderfx & RF_FIRST_PERSON ) ) {
+		return;
+	}
+
+	max1 = ent->ambientLight[0];
+	if ( ent->ambientLight[1] > max1 ) {
+		max1 = ent->ambientLight[1];
+	} else if ( ent->ambientLight[2] > max1 ) {
+		max1 = ent->ambientLight[2];
+	}
+
+	max2 = ent->directedLight[0];
+	if ( ent->directedLight[1] > max2 ) {
+		max2 = ent->directedLight[1];
+	} else if ( ent->directedLight[2] > max2 ) {
+		max2 = ent->directedLight[2];
+	}
+
+	Com_Printf ("amb:%i  dir:%i\n", max1, max2 );
+}
+
+/*
+=================
+R_SetupEntityLighting
+
+Calculates all the lighting values that will be used
+by the Calc_* functions
+=================
+*/
+void R_SetupEntityLighting( const trRefdef_t *refdef, trRefEntity_t *ent ) {
+#ifndef VV_LIGHTING
+	int				i;
+	dlight_t		*dl;
+	float			power;
+	vec3_t			dir;
+	float			d;
+	vec3_t			lightDir;
+	vec3_t			lightOrigin;
+
+	// lighting calculations 
+	if ( ent->lightingCalculated ) {
+		return;
+	}
+	ent->lightingCalculated = qtrue;
+
+	//
+	// trace a sample point down to find ambient light
+	//
+	if ( ent->e.renderfx & RF_LIGHTING_ORIGIN ) {
+		// seperate lightOrigins are needed so an object that is
+		// sinking into the ground can still be lit, and so
+		// multi-part models can be lit identically
+		VectorCopy( ent->e.lightingOrigin, lightOrigin );
+	} else {
+		VectorCopy( ent->e.origin, lightOrigin );
+	}
+
+	// if NOWORLDMODEL, only use dynamic lights (menu system, etc)
+	if ( !(refdef->rdflags & RDF_NOWORLDMODEL ) 
+		&& tr.world->lightGridData ) {
+		R_SetupEntityLightingGrid( ent );
+	} else {
+		ent->ambientLight[0] = ent->ambientLight[1] = 
+			ent->ambientLight[2] = tr.identityLight * 150;
+		ent->directedLight[0] = ent->directedLight[1] = 
+			ent->directedLight[2] = tr.identityLight * 150;
+		VectorCopy( tr.sunDirection, ent->lightDir );
+	}
+
+	// bonus items and view weapons have a fixed minimum add
+	if ( 1 /* ent->e.renderfx & RF_MINLIGHT */ ) {
+		// give everything a minimum light add
+		ent->ambientLight[0] += tr.identityLight * 32;
+		ent->ambientLight[1] += tr.identityLight * 32;
+		ent->ambientLight[2] += tr.identityLight * 32;
+	}
+
+	if (ent->e.renderfx & RF_MINLIGHT)
+	{ //the minlight flag is now for items rotating on their holo thing
+		if (ent->e.shaderRGBA[0] == 255 &&
+			ent->e.shaderRGBA[1] == 255 &&
+			ent->e.shaderRGBA[2] == 0)
+		{
+			ent->ambientLight[0] += tr.identityLight * 255;
+			ent->ambientLight[1] += tr.identityLight * 255;
+			ent->ambientLight[2] += tr.identityLight * 0;
+		}
+		else
+		{
+			ent->ambientLight[0] += tr.identityLight * 16;
+			ent->ambientLight[1] += tr.identityLight * 96;
+			ent->ambientLight[2] += tr.identityLight * 150;
+		}
+	}
+
+	//
+	// modify the light by dynamic lights
+	//
+	d = VectorLength( ent->directedLight );
+	VectorScale( ent->lightDir, d, lightDir );
+
+	for ( i = 0 ; i < refdef->num_dlights ; i++ ) {
+		dl = &refdef->dlights[i];
+		VectorSubtract( dl->origin, lightOrigin, dir );
+		d = VectorNormalize( dir );
+
+		power = DLIGHT_AT_RADIUS * ( dl->radius * dl->radius );
+		if ( d < DLIGHT_MINIMUM_RADIUS ) {
+			d = DLIGHT_MINIMUM_RADIUS;
+		}
+		d = power / ( d * d );
+
+		VectorMA( ent->directedLight, d, dl->color, ent->directedLight );
+		VectorMA( lightDir, d, dir, lightDir );
+	}
+
+	// clamp ambient
+	for ( i = 0 ; i < 3 ; i++ ) {
+		if ( ent->ambientLight[i] > tr.identityLightByte ) {
+			ent->ambientLight[i] = tr.identityLightByte;
+		}
+	}
+
+	if ( r_debugLight->integer ) {
+		LogLight( ent );
+	}
+
+	// save out the byte packet version
+	((byte *)&ent->ambientLightInt)[0] = myftol( ent->ambientLight[0] );
+	((byte *)&ent->ambientLightInt)[1] = myftol( ent->ambientLight[1] );
+	((byte *)&ent->ambientLightInt)[2] = myftol( ent->ambientLight[2] );
+	((byte *)&ent->ambientLightInt)[3] = 0xff;
+	
+	// transform the direction to local space
+	VectorNormalize( lightDir );
+	ent->lightDir[0] = DotProduct( lightDir, ent->e.axis[0] );
+	ent->lightDir[1] = DotProduct( lightDir, ent->e.axis[1] );
+	ent->lightDir[2] = DotProduct( lightDir, ent->e.axis[2] );
+#endif // VV_LIGHTING
+}
+
+/*
+=================
+R_LightForPoint
+=================
+*/
+int R_LightForPoint( vec3_t point, vec3_t ambientLight, vec3_t directedLight, vec3_t lightDir )
+{
+	trRefEntity_t ent;
+	
+	// bk010103 - this segfaults with -nolight maps
+	if ( tr.world->lightGridData == NULL )
+	  return qfalse;
+
+	Com_Memset(&ent, 0, sizeof(ent));
+	VectorCopy( point, ent.e.origin );
+	R_SetupEntityLightingGrid( &ent );
+	VectorCopy(ent.ambientLight, ambientLight);
+	VectorCopy(ent.directedLight, directedLight);
+	VectorCopy(ent.lightDir, lightDir);
+
+	return qtrue;
+}
diff --git a/codemp/renderer/tr_local.h b/codemp/renderer/tr_local.h
new file mode 100644
index 0000000..d23dc75
--- /dev/null
+++ b/codemp/renderer/tr_local.h
@@ -0,0 +1,2365 @@
+#ifndef TR_LOCAL_H
+#define TR_LOCAL_H
+
+#ifdef DEDICATED
+typedef const char * LPCSTR;
+typedef unsigned short USHORT;
+typedef unsigned int GLuint;
+#endif
+
+#include "../qcommon/qfiles.h"
+#include "tr_public.h"
+#if defined(_XBOX)
+#include "qgl_console.h"
+#include "glext_console.h"
+#else
+#ifndef DEDICATED
+#include "qgl.h"
+#endif 
+#endif
+#include "../ghoul2/ghoul2_shared.h" //rwwRMG - added
+
+#ifdef _XBOX
+#define GL_INDEX_TYPE		GL_UNSIGNED_SHORT
+typedef unsigned short glIndex_t;
+#else
+#define GL_INDEX_TYPE		GL_UNSIGNED_INT
+typedef unsigned int glIndex_t;
+#endif
+
+// fast float to int conversion
+#if id386 && !( (defined __linux__ || defined __FreeBSD__ ) && (defined __i386__ ) ) // rb010123
+inline long myftol( float f );
+#else
+#define	myftol(x) ((int)(x))
+#endif
+
+//for 3d textures -rww
+#define GL_TEXTURE_3D                     0x806F
+
+// 14 bits
+// see QSORT_SHADERNUM_SHIFT
+#ifdef _XBOX
+#define	MAX_SHADERS				2048
+#else
+#define	MAX_SHADERS				16384
+#endif
+// can't be increased without changing bit packing for drawsurfs
+
+#define MAX_SHADER_STATES 2048
+#define MAX_STATES_PER_SHADER 32
+#define MAX_STATE_NAME 32
+
+typedef enum
+{
+	DLIGHT_VERTICAL	= 0,
+	DLIGHT_PROJECTED
+} eDLightTypes;
+
+typedef struct dlight_s {
+	eDLightTypes	mType;
+
+	vec3_t			origin;
+	vec3_t			mProjOrigin;		// projected light's origin
+
+	vec3_t			color;				// range from 0.0 to 1.0, should be color normalized
+
+	float			radius;
+	float			mProjRadius;		// desired radius of light 
+
+	int				additive;			// texture detail is lost tho when the lightmap is dark
+
+	vec3_t			transformed;		// origin in local coordinate system
+	vec3_t			mProjTransformed;	// projected light's origin in local coordinate system
+
+	vec3_t			mDirection;
+	vec3_t			mBasis2;
+	vec3_t			mBasis3;
+
+	vec3_t			mTransDirection;
+	vec3_t			mTransBasis2;
+	vec3_t			mTransBasis3;
+} dlight_t;
+
+
+// a trMiniRefEntity_t has all the information passed in by
+// the client game, other info will come from it's parent main ref entity
+typedef struct 
+{
+	miniRefEntity_t	e;
+} trMiniRefEntity_t;
+
+// a trRefEntity_t has all the information passed in by
+// the client game, as well as some locally derived info
+typedef struct {
+	refEntity_t	e;
+
+	float		axisLength;		// compensate for non-normalized axis
+
+	qboolean	needDlights;	// true for bmodels that touch a dlight
+	qboolean	lightingCalculated;
+	vec3_t		lightDir;		// normalized direction towards light
+	vec3_t		ambientLight;	// color normalized to 0-255
+	int			ambientLightInt;	// 32 bit rgba packed
+	vec3_t		directedLight;
+	int			dlightBits;
+} trRefEntity_t;
+
+
+typedef struct {
+	vec3_t		origin;			// in world coordinates
+	vec3_t		axis[3];		// orientation in world
+	vec3_t		viewOrigin;		// viewParms->or.origin in local coordinates
+	float		modelMatrix[16];
+} orientationr_t;
+
+
+#ifdef _XBOX
+typedef struct image_s {
+	int			imgCode;
+	USHORT		width, height;				// source image
+
+	GLuint		texnum;					// gl texture binding
+	int			internalFormat;
+	int			wrapClampMode;		// GL_CLAMP or GL_REPEAT
+
+	bool		isLightmap;
+	bool		isSystem;
+	int			mipcount;
+
+	bool		allowPicmip;
+	short		iLastLevelUsedOn;
+} image_t;
+
+#else // _XBOX
+
+typedef struct image_s {
+	char		imgName[MAX_QPATH];		// game path, including extension
+	USHORT		width, height;	// after power of two and picmip but not including clamp to MAX_TEXTURE_SIZE
+	GLuint		texnum;					// gl texture binding
+
+	int			frameUsed;			// for texture usage in frame statistics
+
+	int			internalFormat;
+	int			wrapClampMode;		// GL_CLAMP or GL_REPEAT
+
+	bool		mipmap;
+	bool		allowPicmip;
+
+	short		iLastLevelUsedOn;
+
+} image_t;
+#endif // _XBOX
+
+//===============================================================================
+
+typedef enum {
+	SS_BAD,
+	SS_PORTAL,			// mirrors, portals, viewscreens
+	SS_ENVIRONMENT,		// sky box
+	SS_OPAQUE,			// opaque
+
+	SS_DECAL,			// scorch marks, etc.
+	SS_SEE_THROUGH,		// ladders, grates, grills that may have small blended edges
+						// in addition to alpha test
+	SS_BANNER,
+
+	SS_INSIDE,			// inside body parts (i.e. heart)
+	SS_MID_INSIDE,
+	SS_MIDDLE,
+	SS_MID_OUTSIDE,
+	SS_OUTSIDE,			// outside body parts (i.e. ribs)
+
+	SS_FOG,
+
+	SS_UNDERWATER,		// for items that should be drawn in front of the water plane
+
+	SS_BLEND0,			// regular transparency and filters
+	SS_BLEND1,			// generally only used for additive type effects
+	SS_BLEND2,
+	SS_BLEND3,
+
+	SS_BLEND6,
+	SS_STENCIL_SHADOW,
+	SS_ALMOST_NEAREST,	// gun smoke puffs
+
+	SS_NEAREST			// blood blobs
+} shaderSort_t;
+
+
+#define MAX_SHADER_STAGES 8
+
+typedef enum {
+	GF_NONE,
+
+	GF_SIN,
+	GF_SQUARE,
+	GF_TRIANGLE,
+	GF_SAWTOOTH, 
+	GF_INVERSE_SAWTOOTH, 
+
+	GF_NOISE,
+	GF_RAND
+
+} genFunc_t;
+
+
+typedef enum {
+	DEFORM_NONE,
+	DEFORM_WAVE,
+	DEFORM_NORMALS,
+	DEFORM_BULGE,
+	DEFORM_MOVE,
+	DEFORM_PROJECTION_SHADOW,
+	DEFORM_AUTOSPRITE,
+	DEFORM_AUTOSPRITE2,
+	DEFORM_TEXT0,
+	DEFORM_TEXT1,
+	DEFORM_TEXT2,
+	DEFORM_TEXT3,
+	DEFORM_TEXT4,
+	DEFORM_TEXT5,
+	DEFORM_TEXT6,
+	DEFORM_TEXT7
+} deform_t;
+
+typedef enum {
+	AGEN_IDENTITY,
+	AGEN_SKIP,
+	AGEN_ENTITY,
+	AGEN_ONE_MINUS_ENTITY,
+	AGEN_VERTEX,
+	AGEN_ONE_MINUS_VERTEX,
+	AGEN_LIGHTING_SPECULAR,
+	AGEN_WAVEFORM,
+	AGEN_PORTAL,
+	AGEN_BLEND,
+	AGEN_CONST,
+	AGEN_DOT,
+	AGEN_ONE_MINUS_DOT
+} alphaGen_t;
+
+typedef enum {
+	CGEN_BAD,
+	CGEN_IDENTITY_LIGHTING,	// tr.identityLight
+	CGEN_IDENTITY,			// always (1,1,1,1)
+	CGEN_ENTITY,			// grabbed from entity's modulate field
+	CGEN_ONE_MINUS_ENTITY,	// grabbed from 1 - entity.modulate
+	CGEN_EXACT_VERTEX,		// tess.vertexColors
+	CGEN_VERTEX,			// tess.vertexColors * tr.identityLight
+	CGEN_ONE_MINUS_VERTEX,
+	CGEN_WAVEFORM,			// programmatically generated
+	CGEN_LIGHTING_DIFFUSE,
+	CGEN_LIGHTING_DIFFUSE_ENTITY, //diffuse lighting * entity
+	CGEN_FOG,				// standard fog
+	CGEN_CONST,				// fixed color
+	CGEN_LIGHTMAPSTYLE,
+} colorGen_t;
+
+typedef enum {
+	TCGEN_BAD,
+	TCGEN_IDENTITY,			// clear to 0,0
+	TCGEN_LIGHTMAP,
+	TCGEN_LIGHTMAP1,
+	TCGEN_LIGHTMAP2,
+	TCGEN_LIGHTMAP3,
+	TCGEN_TEXTURE,
+	TCGEN_ENVIRONMENT_MAPPED,
+	TCGEN_FOG,
+	TCGEN_VECTOR			// S and T from world coordinates
+} texCoordGen_t;
+
+typedef enum {
+	ACFF_NONE,
+	ACFF_MODULATE_RGB,
+	ACFF_MODULATE_RGBA,
+	ACFF_MODULATE_ALPHA
+} acff_t;
+
+typedef enum {
+	GLFOGOVERRIDE_NONE = 0,
+	GLFOGOVERRIDE_BLACK,
+	GLFOGOVERRIDE_WHITE,
+
+	GLFOGOVERRIDE_MAX
+} EGLFogOverride;
+
+typedef struct {
+	genFunc_t	func;
+
+	float base;
+	float amplitude;
+	float phase;
+	float frequency;
+} waveForm_t;
+
+#define TR_MAX_TEXMODS 4
+
+typedef enum {
+	TMOD_NONE,
+	TMOD_TRANSFORM,
+	TMOD_TURBULENT,
+	TMOD_SCROLL,
+	TMOD_SCALE,
+	TMOD_STRETCH,
+	TMOD_ROTATE,
+	TMOD_ENTITY_TRANSLATE
+} texMod_t;
+
+#define	MAX_SHADER_DEFORMS	3
+typedef struct {
+	deform_t	deformation;			// vertex coordinate modification type
+
+	vec3_t		moveVector;
+	waveForm_t	deformationWave;
+	float		deformationSpread;
+
+	float		bulgeWidth;
+	float		bulgeHeight;
+	float		bulgeSpeed;
+} deformStage_t;
+
+
+typedef struct {
+	texMod_t		type;
+
+	// used for TMOD_TURBULENT and TMOD_STRETCH
+	waveForm_t		wave;
+
+	// used for TMOD_TRANSFORM
+	float			matrix[2][2];		// s' = s * m[0][0] + t * m[1][0] + trans[0]
+	float			translate[2];		// t' = s * m[0][1] + t * m[0][1] + trans[1]
+
+	// used for TMOD_SCALE
+	//(moved to translate)
+//	float			scale[2];			// s *= scale[0]
+	                                    // t *= scale[1]
+
+	// used for TMOD_SCROLL
+	//(moved to translate)
+//	float			scroll[2];			// s' = s + scroll[0] * time
+										// t' = t + scroll[1] * time
+
+	// + = clockwise
+	// - = counterclockwise
+	////(moved to translate[0])
+//	float			rotateSpeed;
+
+} texModInfo_t;
+
+
+#define SURFSPRITE_NONE			0
+#define SURFSPRITE_VERTICAL		1
+#define SURFSPRITE_ORIENTED		2
+#define SURFSPRITE_EFFECT		3
+#define SURFSPRITE_WEATHERFX	4
+
+#define SURFSPRITE_FACING_NORMAL	0
+#define SURFSPRITE_FACING_UP		1
+#define SURFSPRITE_FACING_DOWN		2
+#define SURFSPRITE_FACING_ANY		3
+
+
+typedef struct surfaceSprite_s
+{
+	int				surfaceSpriteType;
+	float			width, height, density, wind, windIdle, fadeDist, fadeMax, fadeScale;
+	float			fxAlphaStart, fxAlphaEnd, fxDuration, vertSkew;
+	vec2_t			variance, fxGrow;
+	int				facing;		// Hangdown on vertical sprites, faceup on others.
+} surfaceSprite_t;
+
+typedef struct {
+	image_t			*image;
+
+	texCoordGen_t	tcGen;
+	vec3_t			*tcGenVectors;
+
+	texModInfo_t	*texMods;
+	short			numTexMods;
+	short			numImageAnimations;
+	float			imageAnimationSpeed;
+
+	bool			isLightmap;
+	bool			oneShotAnimMap;
+	bool			vertexLightmap;
+	bool			isVideoMap;
+
+	int				videoMapHandle;
+} textureBundle_t;
+
+
+#define NUM_TEXTURE_BUNDLES 2
+
+typedef struct {
+	bool			active;
+	bool			isDetail;
+#ifdef _XBOX
+	byte			isEnvironment;
+#endif
+#ifdef VV_LIGHTING
+	byte			isSpecular;
+	byte			isBumpMap;
+#endif 
+	byte			index;						// index of stage
+	byte			lightmapStyle;
+	
+	textureBundle_t	bundle[NUM_TEXTURE_BUNDLES];
+
+	waveForm_t		rgbWave;
+	colorGen_t		rgbGen;
+
+	waveForm_t		alphaWave;
+	alphaGen_t		alphaGen;
+
+	byte			constantColor[4];			// for CGEN_CONST and AGEN_CONST
+
+	unsigned int	stateBits;					// GLS_xxxx mask
+
+	acff_t			adjustColorsForFog;
+
+	EGLFogOverride	mGLFogColorOverride;
+
+	surfaceSprite_t	*ss;
+
+	// Whether this object emits a glow or not.
+	bool			glow;
+} shaderStage_t;
+
+struct shaderCommands_s;
+
+#define LIGHTMAP_2D			-4		// shader is for 2D rendering
+#define LIGHTMAP_BY_VERTEX	-3		// pre-lit triangle models
+#define LIGHTMAP_WHITEIMAGE	-2
+#define	LIGHTMAP_NONE		-1
+
+typedef enum {
+	CT_FRONT_SIDED,
+	CT_BACK_SIDED,
+	CT_TWO_SIDED
+} cullType_t;
+
+typedef enum {
+	FP_NONE,		// surface is translucent and will just be adjusted properly
+	FP_EQUAL,		// surface is opaque but possibly alpha tested
+	FP_LE,			// surface is trnaslucent, but still needs a fog pass (fog surface)
+	FP_GLFOG
+} fogPass_t;
+
+typedef struct {
+	float		cloudHeight;
+	image_t		*outerbox[6];
+} skyParms_t;
+
+typedef struct {
+	vec3_t	color;
+	float	depthForOpaque;
+} fogParms_t;
+
+typedef struct shader_s {
+	char		name[MAX_QPATH];		// game path, including extension
+	int			lightmapIndex[MAXLIGHTMAPS];	// for a shader to match, both name and lightmapIndex must match
+	byte		styles[MAXLIGHTMAPS];
+
+	int			index;					// this shader == tr.shaders[index]
+	int			sortedIndex;			// this shader == tr.sortedShaders[sortedIndex]
+
+	float		sort;					// lower numbered shaders draw before higher numbered
+
+	int			surfaceFlags;			// if explicitlyDefined, this will have SURF_* flags
+	int			contentFlags;
+
+	bool		defaultShader;			// we want to return index 0 if the shader failed to
+										// load for some reason, but R_FindShader should
+										// still keep a name allocated for it, so if
+										// something calls RE_RegisterShader again with
+										// the same name, we don't try looking for it again
+	bool		explicitlyDefined;		// found in a .shader file
+	bool		entityMergable;			// merge across entites optimizable (smoke, blood)
+
+	bool		isBumpMap;
+
+#ifdef _XBOX
+	bool		needsNormal;
+	bool		needsTangent;
+#endif
+
+	skyParms_t	*sky;
+	fogParms_t	*fogParms;
+
+	float		portalRange;			// distance to fog out at
+
+	int			multitextureEnv;		// 0, GL_MODULATE, GL_ADD (FIXME: put in stage)
+
+	cullType_t	cullType;				// CT_FRONT_SIDED, CT_BACK_SIDED, or CT_TWO_SIDED
+	bool		polygonOffset;			// set for decals and other items that must be offset 
+	bool		noMipMaps;				// for console fonts, 2D elements, etc.
+	bool		noPicMip;				// for images that must always be full resolution
+	bool		noTC;					// for images that don't want to be texture compressed (eg skies)
+
+	fogPass_t	fogPass;				// draw a blended pass, possibly with depth test equals
+
+	vec3_t		bumpVector;				// The given light vector for bump-mapping
+
+	deformStage_t	*deforms[MAX_SHADER_DEFORMS];
+	short		numDeforms;
+
+	short		numUnfoggedPasses;
+	shaderStage_t	*stages;		
+
+  float clampTime;                                  // time this shader is clamped to
+  float timeOffset;                                 // current time offset for this shader
+
+#ifndef _XBOX	// GLOWXXX
+	// True if this shader has a stage with glow in it (just an optimization).
+	bool hasGlow;
+#endif
+
+/*
+  int numStates;                                    // if non-zero this is a state shader
+  struct shader_s *currentShader;                   // current state if this is a state shader
+  struct shader_s *parentShader;                    // current state if this is a state shader
+  int currentState;                                 // current state index for cycle purposes
+  long expireTime;                                  // time in milliseconds this expires
+
+  int shaderStates[MAX_STATES_PER_SHADER];          // index to valid shader states
+*/
+
+	struct shader_s *remappedShader;                  // current shader this one is remapped too
+	struct	shader_s	*next;
+} shader_t;
+
+typedef struct shaderState_s {
+  char shaderName[MAX_QPATH];     // name of shader this state belongs to
+  char name[MAX_STATE_NAME];      // name of this state
+  char stateShader[MAX_QPATH];    // shader this name invokes
+  int cycleTime;                  // time this cycle lasts, <= 0 is forever
+  shader_t *shader;
+} shaderState_t;
+
+/*
+Ghoul2 Insert Start
+*/
+ // bogus little registration system for hit and location based damage files in hunk memory
+typedef struct
+{
+	byte	*loc;
+	int		width;
+	int		height;
+	char	name[MAX_QPATH];
+} hitMatReg_t;
+
+#define MAX_HITMAT_ENTRIES 1000
+
+extern hitMatReg_t		hitMatReg[MAX_HITMAT_ENTRIES];
+
+/*
+Ghoul2 Insert End
+*/
+
+
+// trRefdef_t holds everything that comes in refdef_t,
+// as well as the locally generated scene information
+typedef struct {
+	int			x, y, width, height;
+	float		fov_x, fov_y;
+	vec3_t		vieworg;
+	vec3_t		viewaxis[3];		// transformation matrix
+
+	int			time;				// time in milliseconds for shader effects and other time dependent rendering issues
+	int			frametime;
+	int			rdflags;			// RDF_NOWORLDMODEL, etc
+
+	// 1 bits will prevent the associated area from rendering at all
+	byte		areamask[MAX_MAP_AREA_BYTES];
+	qboolean	areamaskModified;	// qtrue if areamask changed since last scene
+
+	float		floatTime;			// tr.refdef.time / 1000.0
+
+	// text messages for deform text shaders
+	char		text[MAX_RENDER_STRINGS][MAX_RENDER_STRING_LENGTH];
+
+	int			num_entities;
+	trRefEntity_t	*entities;
+	trMiniRefEntity_t	*miniEntities;
+
+#ifndef VV_LIGHTING
+	int			num_dlights;
+	struct dlight_s	*dlights;
+#endif
+
+	int			numPolys;
+	struct srfPoly_s	*polys;
+
+	int			numDrawSurfs;
+	struct drawSurf_s	*drawSurfs;
+
+
+} trRefdef_t;
+
+
+//=================================================================================
+
+// skins allow models to be retextured without modifying the model file
+typedef struct {
+	char		name[MAX_QPATH];
+	shader_t	*shader;
+} skinSurface_t;
+
+typedef struct skin_s {
+	char		name[MAX_QPATH];		// game path, including extension
+	int			numSurfaces;
+	skinSurface_t	*surfaces[128];
+} skin_t;
+
+
+typedef struct {
+	int			originalBrushNumber;
+	vec3_t		bounds[2];
+
+	unsigned	colorInt;				// in packed byte format
+	float		tcScale;				// texture coordinate vector scales
+	fogParms_t	parms;
+
+	// for clipping distance in fog when outside
+	qboolean	hasSurface;
+	float		surface[4];
+} fog_t;
+
+typedef struct {
+	orientationr_t	ori;				// Can't use "or" as it is a reserved word with gcc DREWS 2/2/2002
+	orientationr_t	world;
+	vec3_t		pvsOrigin;			// may be different than or.origin for portals
+	qboolean	isPortal;			// true if this view is through a portal
+	qboolean	isMirror;			// the portal is a mirror, invert the face culling
+	int			frameSceneNum;		// copied from tr.frameSceneNum
+	int			frameCount;			// copied from tr.frameCount
+	cplane_t	portalPlane;		// clip anything behind this if mirroring
+	int			viewportX, viewportY, viewportWidth, viewportHeight;
+	float		fovX, fovY;
+	float		projectionMatrix[16];
+	cplane_t	frustum[4];
+	vec3_t		visBounds[2];
+	float		zFar;
+} viewParms_t;
+
+
+/*
+==============================================================================
+
+SURFACES
+
+==============================================================================
+*/
+
+// any changes in surfaceType must be mirrored in rb_surfaceTable[]
+typedef enum {
+	SF_BAD,
+	SF_SKIP,				// ignore
+	SF_FACE,
+	SF_GRID,
+	SF_TRIANGLES,
+	SF_POLY,
+	SF_TERRAIN, //rwwRMG - added
+	SF_MD3,
+/*
+Ghoul2 Insert Start
+*/
+	SF_MDX,
+/*
+Ghoul2 Insert End
+*/
+	SF_FLARE,
+	SF_ENTITY,				// beams, rails, lightning, etc that can be determined by entity
+	SF_DISPLAY_LIST,
+
+	SF_NUM_SURFACE_TYPES,
+	SF_MAX = 0xffffffff			// ensures that sizeof( surfaceType_t ) == sizeof( int )
+} surfaceType_t;
+
+typedef struct drawSurf_s {
+	unsigned			sort;			// bit combination for fast compares
+	surfaceType_t		*surface;		// any of surface*_t
+} drawSurf_t;
+
+#define	MAX_FACE_POINTS		64
+
+#define	MAX_PATCH_SIZE		32			// max dimensions of a patch mesh in map file
+#define	MAX_GRID_SIZE		65			// max dimensions of a grid mesh in memory
+
+// when cgame directly specifies a polygon, it becomes a srfPoly_t
+// as soon as it is called
+typedef struct srfPoly_s {
+	surfaceType_t	surfaceType;
+	qhandle_t		hShader;
+	int				fogIndex;
+	int				numVerts;
+	polyVert_t		*verts;
+} srfPoly_t;
+
+typedef struct srfDisplayList_s {
+	surfaceType_t	surfaceType;
+	int				listNum;
+} srfDisplayList_t;
+
+#ifdef _XBOX
+typedef struct srfFlare_s {
+	surfaceType_t	surfaceType;
+	unsigned short	origin[3];
+	unsigned short	normal[3];
+	byte			color[3];
+} srfFlare_t;
+
+#else // _XBOX
+
+typedef struct srfFlare_s {
+	surfaceType_t	surfaceType;
+	vec3_t			origin;
+	vec3_t			normal;
+	vec3_t			color;
+} srfFlare_t;
+
+#endif
+
+#ifdef _XBOX
+// Added tangent size in here
+#define	VERTEXSIZE			(9+(MAXLIGHTMAPS*3))
+#define VERTEX_LM			8  
+#define	VERTEX_COLOR(flags)		(VERTEX_LM + (((flags) & 0x7F) * 2))
+#else
+#define	VERTEXSIZE			(6+(MAXLIGHTMAPS*3))
+#define VERTEX_LM			5
+#define	VERTEX_COLOR		(5+(MAXLIGHTMAPS*2))
+#endif
+
+#define	VERTEX_FINAL_COLOR	(5+(MAXLIGHTMAPS*3))
+
+#ifdef _XBOX
+#define NEXT_SURFPOINT(flags) (VERTEX_LM + (((flags) & 0x7F) * 2) + ((((flags) & 0x80) >> 7) * 4));
+#define POINTS_ST_SCALE 128.0f
+#define POINTS_LIGHT_SCALE 65536.0f
+#define GLM_COMP_SIZE 64.0f
+#endif // _XBOX
+
+typedef struct srfTerrain_s
+{
+	surfaceType_t			surfaceType;
+	class CTRLandScape		*landscape;
+} srfTerrain_t;
+
+typedef struct srfGridMesh_s {
+	surfaceType_t	surfaceType;
+
+	// dynamic lighting information
+	int				dlightBits;
+
+	// culling information
+	vec3_t			meshBounds[2];
+	vec3_t			localOrigin;
+	float			meshRadius;
+
+	// lod information, which may be different
+	// than the culling information to allow for
+	// groups of curves that LOD as a unit
+	vec3_t			lodOrigin;
+	float			lodRadius;
+	int				lodFixed;
+	int				lodStitched;
+
+	// vertexes
+	int				width, height;
+	float			*widthLodError;
+	float			*heightLodError;
+	drawVert_t		verts[1];		// variable sized
+} srfGridMesh_t;
+
+#ifdef _XBOX
+#pragma pack (push, 1)
+typedef struct {
+	surfaceType_t	surfaceType;
+	cplane_t	plane;
+
+	// dynamic lighting information
+	int			dlightBits;
+
+	// triangle definitions (no normals at points)
+	unsigned char	numPoints;
+	unsigned short	numIndices;
+	unsigned short	ofsIndices;
+	unsigned char   flags; //highest bit - true if face uses vertex colors,
+							//low 7 bits - number of light maps
+//	vec3_t			*tangents;
+	unsigned short	*srfPoints;			// variable sized
+										// there is a variable length list of indices here also
+} srfSurfaceFace_t;
+#pragma pack (pop)
+
+#else // _XBOX
+
+typedef struct {
+	surfaceType_t	surfaceType;
+	cplane_t	plane;
+
+	// dynamic lighting information
+	int			dlightBits;
+
+	// triangle definitions (no normals at points)
+	int			numPoints;
+	int			numIndices;
+	int			ofsIndices;
+	float		points[1][VERTEXSIZE];	// variable sized
+										// there is a variable length list of indices here also
+} srfSurfaceFace_t;
+
+#endif // _XBOX
+
+
+// misc_models in maps are turned into direct geometry by q3map
+typedef struct {
+	surfaceType_t	surfaceType;
+
+	// dynamic lighting information
+	int				dlightBits;
+
+	// culling information (FIXME: use this!)
+	vec3_t			bounds[2];
+//	vec3_t			localOrigin;
+//	float			radius;
+
+	// triangle definitions
+	int				numIndexes;
+	int				*indexes;
+
+	int				numVerts;
+	drawVert_t		*verts;
+//	vec3_t			*tangents;
+} srfTriangles_t;
+
+
+extern	void (*rb_surfaceTable[SF_NUM_SURFACE_TYPES])(void *);
+
+/*
+==============================================================================
+
+TERRAIN DATA
+
+==============================================================================
+*/
+
+void RE_InitRendererTerrain( const char *info );
+void RB_SurfaceTerrain( surfaceInfo_t *surface );
+void R_TerrainInit (void);
+void R_TerrainShutdown(void);
+
+
+/*
+==============================================================================
+
+BRUSH MODELS
+
+==============================================================================
+*/
+
+
+//
+// in memory representation
+//
+
+#define	SIDE_FRONT	0
+#define	SIDE_BACK	1
+#define	SIDE_ON		2
+
+typedef struct msurface_s {
+	int					viewCount;		// if == tr.viewCount, already added
+	struct shader_s		*shader;
+	int					fogIndex;
+
+	surfaceType_t		*data;			// any of srf*_t
+} msurface_t;
+
+
+
+#define	CONTENTS_NODE		-1
+
+#ifdef _XBOX
+#pragma pack (push, 1)
+typedef struct mnode_s {
+	// common with leaf and node
+	signed char	contents;		// -1 for nodes, to differentiate from leafs
+	int 		visframe;		// node needs to be traversed if current
+	short		mins[3], maxs[3];		// for bounding box culling
+	struct mnode_s *parent;
+
+	// node specific
+	unsigned int planeNum;
+	struct mnode_s	*children[2];	
+
+} mnode_t;
+
+struct mleaf_s {
+	// common with leaf and node
+	signed char	contents;		// -1 for nodes, to differentiate from leafs
+	int 		visframe;		// node needs to be traversed if current
+	short		mins[3], maxs[3];		// for bounding box culling
+	struct mnode_s *parent;
+
+	// leaf specific
+	short			cluster;
+	signed char		area;
+
+	unsigned short firstMarkSurfNum;
+	short		nummarksurfaces;
+};
+#pragma pack (pop)
+
+#else // _XBOX
+
+typedef struct mnode_s {
+	// common with leaf and node
+	int			contents;		// -1 for nodes, to differentiate from leafs
+	int			visframe;		// node needs to be traversed if current
+	vec3_t		mins, maxs;		// for bounding box culling
+	struct mnode_s	*parent;
+
+	// node specific
+	cplane_t	*plane;
+	struct mnode_s	*children[2];	
+
+	// leaf specific
+	int			cluster;
+	int			area;
+
+	msurface_t	**firstmarksurface;
+	int			nummarksurfaces;
+} mnode_t;
+
+#endif // _XBOX
+
+typedef struct {
+	vec3_t		bounds[2];		// for culling
+	msurface_t	*firstSurface;
+	int			numSurfaces;
+} bmodel_t;
+
+#ifdef _XBOX
+#pragma pack(push, 1)
+typedef struct {
+	byte flags;
+	byte latLong[2];
+	int data;
+
+	/*
+	   flags has the following bits:
+	   0 - ambientLight[0] and directLight[0] are not all zeros
+	   1 - ambientLight[1] and directLight[1] are not all zeros
+	   2 - ambientLight[2] and directLight[2] are not all zeros
+	   3 - ambientLight[3] and directLight[3] are not all zeros
+	   4 - styles[0] is not LS_NONE
+	   5 - styles[1] is not LS_NONE
+	   6 - styles[2] is not LS_NONE
+	   7 - styles[3] is not LS_NONE
+
+	   data points to memory which stores ambientLight, directLight and
+	   styles when they are not 0 or LS_NONE.
+	*/
+} mgrid_t;
+#pragma pack(pop)
+
+#else // _XBOX
+
+typedef struct 
+{
+	byte		ambientLight[MAXLIGHTMAPS][3];
+	byte		directLight[MAXLIGHTMAPS][3];
+	byte		styles[MAXLIGHTMAPS];
+	byte		latLong[2];
+//	byte		pad[2];								// to align to a cache line
+} mgrid_t;
+
+#endif // _XBOX
+
+
+#ifdef _XBOX
+template <class T>
+class SPARC;
+typedef struct {
+	char		name[MAX_QPATH];		// ie: maps/tim_dm2.bsp
+	char		baseName[MAX_QPATH];	// ie: tim_dm2
+
+	int			numShaders;
+	dshader_t	*shaders;
+
+	bmodel_t	*bmodels;
+
+	int			numplanes;
+	cplane_t	*planes;
+
+	int			numnodes;		// includes leafs
+	int			numDecisionNodes;
+	mnode_t		*nodes;
+
+	int			numleafs;
+	mleaf_s		*leafs;
+
+	int			numsurfaces;
+	msurface_t	*surfaces;
+
+	int			nummarksurfaces;
+	msurface_t	**marksurfaces;
+
+	int			numfogs;
+	fog_t		*fogs;
+	int			globalFog;
+
+	int			startLightMapIndex;
+
+	vec3_t		lightGridOrigin;
+	vec3_t		lightGridSize;
+	vec3_t		lightGridInverseSize;
+	int			lightGridBounds[3];
+	mgrid_t			*lightGridData;
+	unsigned short	*lightGridArray;
+	int			numGridArrayElements;
+
+	int			numClusters;
+	int			clusterBytes;
+
+	SPARC<byte>	*vis;
+
+	byte		*novis;			// clusterBytes of 0xff
+
+	qboolean	portalPresent;
+
+	char		*entityString;
+	char		*entityParsePoint;
+} world_t;
+
+#else // _XBOX
+
+typedef struct {
+	char		name[MAX_QPATH];		// ie: maps/tim_dm2.bsp
+	char		baseName[MAX_QPATH];	// ie: tim_dm2
+
+	int			dataSize;
+
+	int			numShaders;
+	dshader_t	*shaders;
+
+	bmodel_t	*bmodels;
+
+	int			numplanes;
+	cplane_t	*planes;
+
+	int			numnodes;		// includes leafs
+	int			numDecisionNodes;
+	mnode_t		*nodes;
+
+	int			numsurfaces;
+	msurface_t	*surfaces;
+
+	int			nummarksurfaces;
+	msurface_t	**marksurfaces;
+
+	int			numfogs;
+	fog_t		*fogs;
+	int			globalFog;
+
+
+	vec3_t		lightGridOrigin;
+	vec3_t		lightGridSize;
+	vec3_t		lightGridInverseSize;
+	int			lightGridBounds[3];
+
+	int			lightGridOffsets[8];
+
+	vec3_t		lightGridStep;
+
+	mgrid_t			*lightGridData;
+	word		*lightGridArray;
+	int			numGridArrayElements;
+
+
+	int			numClusters;
+	int			clusterBytes;
+	const byte	*vis;			// may be passed in by CM_LoadMap to save space
+
+	byte		*novis;			// clusterBytes of 0xff
+
+	char		*entityString;
+	char		*entityParsePoint;
+} world_t;
+
+#endif // _XBOX
+
+//======================================================================
+/*
+Ghoul2 Insert Start
+*/
+#define MDXABONEDEF
+#include "mdx_format.h"
+/*
+Ghoul2 Insert End
+*/
+typedef enum {
+	MOD_BAD,
+	MOD_BRUSH,
+	MOD_MESH,
+/*
+Ghoul2 Insert Start
+*/
+   	MOD_MDXM,
+	MOD_MDXA
+/*
+Ghoul2 Insert End
+*/
+} modtype_t;
+
+typedef struct model_s {
+	char		name[MAX_QPATH];
+	modtype_t	type;
+	int			index;				// model = tr.models[model->index]
+
+	int			dataSize;			// just for listing purposes
+	bmodel_t	*bmodel;			// only if type == MOD_BRUSH
+	md3Header_t	*md3[MD3_MAX_LODS];	// only if type == MOD_MESH
+/*
+Ghoul2 Insert Start
+*/
+	mdxmHeader_t *mdxm;				// only if type == MOD_GL2M which is a GHOUL II Mesh file NOT a GHOUL II animation file
+	mdxaHeader_t *mdxa;				// only if type == MOD_GL2A which is a GHOUL II Animation file
+/*
+Ghoul2 Insert End
+*/
+	int			 numLods;
+	qboolean	bspInstance;
+} model_t;
+
+
+#define	MAX_MOD_KNOWN	1024
+
+void		R_ModelInit (void);
+void		R_InitDecals	(void);
+
+model_t		*R_GetModelByHandle( qhandle_t hModel );
+int			R_LerpTag( orientation_t *tag, qhandle_t handle, int startFrame, int endFrame, 
+					 float frac, const char *tagName );
+void		R_ModelBounds( qhandle_t handle, vec3_t mins, vec3_t maxs );
+
+void		R_Modellist_f (void);
+
+//====================================================
+
+
+// An offscreen buffer used for secondary rendering and render-to-texture support (RTT). - AReis
+#ifndef _XBOX	// GLOWXXX
+#ifndef DEDICATED
+class CPBUFFER
+{
+private:
+	// Pixel Buffer Rendering and Device Contexts.
+	HGLRC m_hRC;
+	HDC m_hDC;
+
+	// The render and device contexts for the previous render target.
+	HGLRC m_hOldRC;
+	HDC m_hOldDC;
+
+	// Buffer handle.
+	HPBUFFERARB m_hBuffer;
+
+	// Buffer Dimensions.
+	int m_iWidth, m_iHeight;
+
+	// Color, depth, and stencil bits for this buffer.
+	int m_iColorBits, m_iDepthBits, m_iStencilBits;
+
+public:
+	// Texture used for displaying the pbuffer.
+	GLuint m_uiPBufferTexture;
+
+	// Constructor.
+	CPBUFFER() {}
+
+	// Destructor.
+	~CPBUFFER() {}
+
+	// Allocate and create a new PBuffer.
+	bool Create( int iWidth, int iHeight, int iColorBits, int iDepthBits, int iStencilBits );
+
+	// Destroy and deallocate a PBuffer.
+	void Destroy();
+
+	// Make this PBuffer the current render device.
+	bool Begin();
+
+	// Restore the previous render device.
+	bool End();
+};
+#endif  // DEDICATED
+#endif	// _XBOX
+
+
+#define	MAX_DRAWIMAGES			2048
+#define	MAX_LIGHTMAPS			256
+#define	MAX_SKINS				1024
+
+
+#ifdef _XBOX
+#define	MAX_DRAWSURFS			0x4000
+#else
+#define	MAX_DRAWSURFS			0x10000
+#endif
+#define	DRAWSURF_MASK			(MAX_DRAWSURFS-1)
+
+/*
+
+the drawsurf sort data is packed into a single 32 bit value so it can be
+compared quickly during the qsorting process
+
+the bits are allocated as follows:
+
+18-31 : sorted shader index
+7-17  : entity index
+2-6   : fog index
+0-1   : dlightmap index
+*/
+#define	QSORT_SHADERNUM_SHIFT	18
+#define	QSORT_ENTITYNUM_SHIFT	7
+#define	QSORT_FOGNUM_SHIFT		2
+
+extern	int			gl_filter_min, gl_filter_max;
+
+/*
+** performanceCounters_t
+*/
+typedef struct {
+	int		c_sphere_cull_patch_in, c_sphere_cull_patch_clip, c_sphere_cull_patch_out;
+	int		c_box_cull_patch_in, c_box_cull_patch_clip, c_box_cull_patch_out;
+	int		c_sphere_cull_md3_in, c_sphere_cull_md3_clip, c_sphere_cull_md3_out;
+	int		c_box_cull_md3_in, c_box_cull_md3_clip, c_box_cull_md3_out;
+
+	int		c_leafs;
+	int		c_dlightSurfaces;
+	int		c_dlightSurfacesCulled;
+} frontEndCounters_t;
+
+#define	FOG_TABLE_SIZE		256
+#define FUNCTABLE_SIZE		1024
+#define FUNCTABLE_SIZE2		10
+#define FUNCTABLE_MASK		(FUNCTABLE_SIZE-1)
+
+
+// the renderer front end should never modify glstate_t
+typedef struct {
+	int			currenttextures[2];
+	int			currenttmu;
+	qboolean	finishCalled;
+	int			texEnv[2];
+	int			faceCulling;
+	unsigned long	glStateBits;
+} glstate_t;
+
+
+typedef struct {
+	int		c_surfaces, c_shaders, c_vertexes, c_indexes, c_totalIndexes;
+	float	c_overDraw;
+	
+	int		c_dlightVertexes;
+	int		c_dlightIndexes;
+
+	int		c_flareAdds;
+	int		c_flareTests;
+	int		c_flareRenders;
+
+	int		msec;			// total msec for backend run
+} backEndCounters_t;
+
+// all state modified by the back end is seperated
+// from the front end state
+typedef struct {
+	trRefdef_t	refdef;
+	viewParms_t	viewParms;
+	orientationr_t	ori;		// Can't use or as it is a c++ reserved word DREWS 2/2/2002
+	backEndCounters_t	pc;
+	qboolean	isHyperspace;
+	trRefEntity_t	*currentEntity;
+	qboolean	skyRenderedThisView;	// flag for drawing sun
+
+	qboolean	projection2D;	// if qtrue, drawstretchpic doesn't need to change modes
+	byte		color2D[4];
+	qboolean	vertexes2D;		// shader needs to be finished
+	trRefEntity_t	entity2D;	// currentEntity will point at this when doing 2D rendering
+} backEndState_t;
+
+/*
+** trGlobals_t 
+**
+** Most renderer globals are defined here.
+** backend functions should never modify any of these fields,
+** but may read fields that aren't dynamically modified
+** by the frontend.
+*/
+
+#ifdef _XBOX
+#define NUM_SCRATCH_IMAGES 2
+#else
+#define NUM_SCRATCH_IMAGES 16
+#endif
+
+typedef struct {
+	qboolean				registered;		// cleared at shutdown, set at beginRegistration
+
+	int						visCount;		// incremented every time a new vis cluster is entered
+	int						frameCount;		// incremented every frame
+	int						sceneCount;		// incremented every scene
+	int						viewCount;		// incremented every view (twice a scene if portaled)
+											// and every R_MarkFragments call
+
+	int						frameSceneNum;	// zeroed at RE_BeginFrame
+
+	qboolean				worldMapLoaded;
+	world_t					*world;
+
+#ifdef _XBOX
+	SPARC<byte>				*externalVisData;	// from RE_SetWorldVisData, shared with CM_Load
+#else
+	const byte				*externalVisData;	// from RE_SetWorldVisData, shared with CM_Load
+#endif
+
+	image_t					*defaultImage;
+	image_t					*scratchImage[NUM_SCRATCH_IMAGES];
+	image_t					*fogImage;
+	image_t					*dlightImage;	// inverse-quare highlight for projective adding
+	image_t					*flareImage;
+	image_t					*whiteImage;			// full of 0xff
+	image_t					*identityLightImage;	// full of tr.identityLightByte
+
+	image_t					*screenImage; //reserve us a gl texnum to use with RF_DISTORTION
+
+#ifndef _XBOX	// GLOWXXX
+	// Handle to the Glow Effect Vertex Shader. - AReis
+	GLuint					glowVShader;
+
+	// Handle to the Glow Effect Pixel Shader. - AReis
+	GLuint					glowPShader;
+
+	// Image the glowing objects are rendered to. - AReis
+	GLuint					screenGlow;
+
+	// A rectangular texture representing the normally rendered scene.
+	GLuint					sceneImage;
+
+	// Image used to downsample and blur scene to.	- AReis
+	GLuint					blurImage;
+#endif
+
+	shader_t				*defaultShader;
+	shader_t				*shadowShader;
+	shader_t				*distortionShader;
+	shader_t				*projectionShadowShader;
+
+	shader_t				*sunShader;
+
+	int						numLightmaps;
+	image_t					*lightmaps[MAX_LIGHTMAPS];
+
+	trRefEntity_t			*currentEntity;
+	trRefEntity_t			worldEntity;		// point currentEntity at this when rendering world
+	int						currentEntityNum;
+	int						shiftedEntityNum;	// currentEntityNum << QSORT_ENTITYNUM_SHIFT
+	model_t					*currentModel;
+
+	viewParms_t				viewParms;
+
+	float					identityLight;		// 1.0 / ( 1 << overbrightBits )
+	int						identityLightByte;	// identityLight * 255
+	int						overbrightBits;		// r_overbrightBits->integer, but set to 0 if no hw gamma
+
+	orientationr_t			ori;					// for current entity
+
+	trRefdef_t				refdef;
+
+	int						viewCluster;
+
+	vec3_t					sunLight;			// from the sky shader for this level
+	vec3_t					sunDirection;
+	int						sunSurfaceLight;	// from the sky shader for this level
+	vec3_t					sunAmbient;			// from the sky shader	(only used for John's terrain system)
+
+	frontEndCounters_t		pc;
+	int						frontEndMsec;		// not in pc due to clearing issue
+
+	//
+	// put large tables at the end, so most elements will be
+	// within the +/32K indexed range on risc processors
+	//
+	model_t					*models[MAX_MOD_KNOWN];
+	int						numModels;
+
+	world_t					bspModels[MAX_SUB_BSP];
+	int						numBSPModels;
+
+	// shader indexes from other modules will be looked up in tr.shaders[]
+	// shader indexes from drawsurfs will be looked up in sortedShaders[]
+	// lower indexed sortedShaders must be rendered first (opaque surfaces before translucent)
+	int						numShaders;
+	shader_t				*shaders[MAX_SHADERS];
+	shader_t				*sortedShaders[MAX_SHADERS];
+
+	int						numSkins;
+	skin_t					*skins[MAX_SKINS];
+
+	float					sinTable[FUNCTABLE_SIZE];
+	float					squareTable[FUNCTABLE_SIZE];
+	float					triangleTable[FUNCTABLE_SIZE];
+	float					sawToothTable[FUNCTABLE_SIZE];
+	float					inverseSawToothTable[FUNCTABLE_SIZE];
+	float					fogTable[FOG_TABLE_SIZE];
+
+	float					rangedFog;
+	float					distanceCull, distanceCullSquared; //rwwRMG - added
+
+	srfTerrain_t			landScape; //rwwRMG - added
+} trGlobals_t;
+
+
+int		 R_Images_StartIteration(void);
+image_t *R_Images_GetNextIteration(void);
+void	 R_Images_Clear(void);
+void	 R_Images_DeleteLightMaps(void);
+void	 R_Images_DeleteImage(image_t *pImage);
+
+
+extern backEndState_t	backEnd;
+extern trGlobals_t	tr;
+extern glconfig_t	glConfig;		// outside of TR since it shouldn't be cleared during ref re-init
+extern glstate_t	glState;		// outside of TR since it shouldn't be cleared during ref re-init
+
+
+//
+// cvars
+//
+extern cvar_t	*r_ignore;				// used for debugging anything
+extern cvar_t	*r_verbose;				// used for verbose debug spew
+
+extern cvar_t	*r_znear;				// near Z clip plane
+
+extern cvar_t	*r_stencilbits;			// number of desired stencil bits
+extern cvar_t	*r_depthbits;			// number of desired depth bits
+extern cvar_t	*r_colorbits;			// number of desired color bits, only relevant for fullscreen
+extern cvar_t	*r_stereo;				// desired pixelformat stereo flag
+extern cvar_t	*r_texturebits;			// number of desired texture bits
+										// 0 = use framebuffer depth
+										// 16 = use 16-bit textures
+										// 32 = use 32-bit textures
+										// all else = error
+extern cvar_t	*r_texturebitslm;		// number of desired lightmap texture bits
+
+extern cvar_t	*r_measureOverdraw;		// enables stencil buffer overdraw measurement
+
+extern cvar_t	*r_lodbias;				// push/pull LOD transitions
+extern cvar_t	*r_lodscale;
+extern cvar_t	*r_autolodscalevalue;
+
+extern cvar_t	*r_primitives;			// "0" = based on compiled vertex array existance
+										// "1" = glDrawElemet tristrips
+										// "2" = glDrawElements triangles
+										// "-1" = no drawing
+
+extern cvar_t	*r_inGameVideo;				// controls whether in game video should be draw
+extern cvar_t	*r_fastsky;				// controls whether sky should be cleared or drawn
+extern cvar_t	*r_drawSun;				// controls drawing of sun quad
+extern cvar_t	*r_dynamiclight;		// dynamic lights enabled/disabled
+// rjr - removed for hacking extern cvar_t	*r_dlightBacks;			// dlight non-facing surfaces for continuity
+
+extern	cvar_t	*r_norefresh;			// bypasses the ref rendering
+extern	cvar_t	*r_drawentities;		// disable/enable entity rendering
+extern	cvar_t	*r_drawworld;			// disable/enable world rendering
+extern	cvar_t	*r_drawfog;				// disable/enable fog rendering
+extern	cvar_t	*r_speeds;				// various levels of information display
+extern  cvar_t	*r_detailTextures;		// enables/disables detail texturing stages
+extern	cvar_t	*r_novis;				// disable/enable usage of PVS
+extern	cvar_t	*r_nocull;
+extern	cvar_t	*r_facePlaneCull;		// enables culling of planar surfaces with back side test
+extern	cvar_t	*r_cullRoofFaces; //attempted smart method of culling out upwards facing surfaces on roofs for automap shots -rww
+extern	cvar_t	*r_roofCullCeilDist; //ceiling distance cull tolerance -rww
+extern	cvar_t	*r_roofCullFloorDist; //floor distance cull tolerance -rww
+extern	cvar_t	*r_nocurves;
+extern	cvar_t	*r_showcluster;
+
+extern	cvar_t	*r_autoMap; //automap renderside toggle for debugging -rww
+extern	cvar_t	*r_autoMapBackAlpha; //alpha of automap bg -rww
+extern	cvar_t	*r_autoMapDisable;
+
+extern cvar_t	*r_dlightStyle;
+extern cvar_t	*r_surfaceSprites;
+extern cvar_t	*r_surfaceWeather;
+
+extern cvar_t	*r_windSpeed;
+extern cvar_t	*r_windAngle;
+extern cvar_t	*r_windGust;
+extern cvar_t	*r_windDampFactor;
+extern cvar_t	*r_windPointForce;
+extern cvar_t	*r_windPointX;
+extern cvar_t	*r_windPointY;
+
+extern cvar_t	*r_mode;				// video mode
+extern cvar_t	*r_fullscreen;
+extern cvar_t	*r_gamma;
+extern cvar_t	*r_displayRefresh;		// optional display refresh option
+extern cvar_t	*r_ignorehwgamma;		// overrides hardware gamma capabilities
+
+extern cvar_t	*r_allowExtensions;				// global enable/disable of OpenGL extensions
+extern cvar_t	*r_ext_compressed_textures;		// these control use of specific extensions
+extern cvar_t	*r_ext_compressed_lightmaps;	// turns on compression of lightmaps, off by default
+extern cvar_t	*r_ext_preferred_tc_method;
+extern cvar_t	*r_ext_gamma_control;
+extern cvar_t	*r_ext_texenv_op;
+extern cvar_t	*r_ext_multitexture;
+extern cvar_t	*r_ext_compiled_vertex_array;
+extern cvar_t	*r_ext_texture_env_add;
+extern cvar_t	*r_ext_texture_filter_anisotropic;
+
+extern cvar_t	*r_DynamicGlow;
+extern cvar_t	*r_DynamicGlowPasses;
+extern cvar_t	*r_DynamicGlowDelta;
+extern cvar_t	*r_DynamicGlowIntensity;
+extern cvar_t	*r_DynamicGlowSoft;
+extern cvar_t	*r_DynamicGlowWidth;
+extern cvar_t	*r_DynamicGlowHeight;
+
+extern	cvar_t	*r_nobind;						// turns off binding to appropriate textures
+extern	cvar_t	*r_singleShader;				// make most world faces use default shader
+extern	cvar_t	*r_colorMipLevels;				// development aid to see texture mip usage
+extern	cvar_t	*r_picmip;						// controls picmip values
+extern	cvar_t	*r_finish;
+extern	cvar_t	*r_swapInterval;
+extern	cvar_t	*r_markcount;
+extern	cvar_t	*r_textureMode;
+extern	cvar_t	*r_offsetFactor;
+extern	cvar_t	*r_offsetUnits;
+
+extern	cvar_t	*r_fullbright;					// avoid lightmap pass
+extern	cvar_t	*r_lightmap;					// render lightmaps only
+extern	cvar_t	*r_vertexLight;					// vertex lighting mode for better performance
+extern	cvar_t	*r_uiFullScreen;				// ui is running fullscreen
+
+extern	cvar_t	*r_logFile;						// number of frames to emit GL logs
+extern	cvar_t	*r_showtris;					// enables wireframe rendering of the world
+extern	cvar_t	*r_showsky;						// forces sky in front of all surfaces
+extern	cvar_t	*r_shownormals;					// draws wireframe normals
+extern	cvar_t	*r_clear;						// force screen clear every frame
+
+extern	cvar_t	*r_shadows;						// controls shadows: 0 = none, 1 = blur, 2 = stencil, 3 = black planar projection
+extern	cvar_t	*r_flares;						// light flares
+
+extern	cvar_t	*r_intensity;
+
+extern	cvar_t	*r_lockpvs;
+extern	cvar_t	*r_noportals;
+extern	cvar_t	*r_portalOnly;
+
+extern	cvar_t	*r_subdivisions;
+extern	cvar_t	*r_lodCurveError;
+extern	cvar_t	*r_skipBackEnd;
+
+extern	cvar_t	*r_ignoreGLErrors;
+
+extern	cvar_t	*r_overBrightBits;
+
+extern	cvar_t	*r_debugSurface;
+extern	cvar_t	*r_simpleMipMaps;
+
+extern	cvar_t	*r_showImages;
+extern	cvar_t	*r_debugSort;
+
+#ifdef _XBOX
+extern	cvar_t	*r_hdreffect;
+extern  cvar_t  *r_sundir_x;
+extern  cvar_t  *r_sundir_y;
+extern  cvar_t  *r_sundir_z;
+extern  cvar_t  *r_hdrbloom;
+#endif
+
+/*
+Ghoul2 Insert Start
+*/
+#ifdef _DEBUG
+extern	cvar_t	*r_noPrecacheGLA;
+#endif
+
+extern	cvar_t	*r_noServerGhoul2;
+/*
+Ghoul2 Insert End
+*/
+//====================================================================
+
+float R_NoiseGet4f( float x, float y, float z, float t );
+void  R_NoiseInit( void );
+
+void R_SwapBuffers( int );
+
+void R_RenderView( viewParms_t *parms );
+
+void R_AddMD3Surfaces( trRefEntity_t *e );
+void R_AddNullModelSurfaces( trRefEntity_t *e );
+void R_AddBeamSurfaces( trRefEntity_t *e );
+void R_AddRailSurfaces( trRefEntity_t *e, qboolean isUnderwater );
+void R_AddLightningBoltSurfaces( trRefEntity_t *e );
+
+void R_AddPolygonSurfaces( void );
+
+void R_DecomposeSort( unsigned sort, int *entityNum, shader_t **shader, 
+					 int *fogNum, int *dlightMap );
+
+void R_AddDrawSurf( surfaceType_t *surface, shader_t *shader, int fogIndex, int dlightMap );
+
+
+#define	CULL_IN		0		// completely unclipped
+#define	CULL_CLIP	1		// clipped by one or more planes
+#define	CULL_OUT	2		// completely outside the clipping planes
+void R_LocalNormalToWorld (const vec3_t local, vec3_t world);
+void R_LocalPointToWorld (const vec3_t local, vec3_t world);
+void R_WorldNormalToEntity (const vec3_t localVec, vec3_t world); 
+int R_CullLocalBox ( const vec3_t bounds[2]);
+int R_CullPointAndRadius( const vec3_t origin, float radius );
+int R_CullLocalPointAndRadius( const vec3_t origin, float radius );
+
+void R_RotateForEntity( const trRefEntity_t *ent, const viewParms_t *viewParms, orientationr_t *ori );
+
+#ifdef VV_LIGHTING
+void R_SetupEntityLightingGrid( trRefEntity_t *ent );
+void R_AddWorldSurface( msurface_t *surf, int dlightBits, qboolean noViewCount = qfalse );
+#endif
+
+/*
+** GL wrapper/helper functions
+*/
+void	GL_Bind( image_t *image );
+void	GL_Bind3D( image_t *image );
+void	GL_SetDefaultState (void);
+void	GL_SelectTexture( int unit );
+void	GL_TextureMode( const char *string );
+void	GL_CheckErrors( void );
+void	GL_State( unsigned long stateVector );
+void	GL_TexEnv( int env );
+void	GL_Cull( int cullType );
+
+#define GLS_SRCBLEND_ZERO						0x00000001
+#define GLS_SRCBLEND_ONE						0x00000002
+#define GLS_SRCBLEND_DST_COLOR					0x00000003
+#define GLS_SRCBLEND_ONE_MINUS_DST_COLOR		0x00000004
+#define GLS_SRCBLEND_SRC_ALPHA					0x00000005
+#define GLS_SRCBLEND_ONE_MINUS_SRC_ALPHA		0x00000006
+#define GLS_SRCBLEND_DST_ALPHA					0x00000007
+#define GLS_SRCBLEND_ONE_MINUS_DST_ALPHA		0x00000008
+#define GLS_SRCBLEND_ALPHA_SATURATE				0x00000009
+#define		GLS_SRCBLEND_BITS					0x0000000f
+
+#define GLS_DSTBLEND_ZERO						0x00000010
+#define GLS_DSTBLEND_ONE						0x00000020
+#define GLS_DSTBLEND_SRC_COLOR					0x00000030
+#define GLS_DSTBLEND_ONE_MINUS_SRC_COLOR		0x00000040
+#define GLS_DSTBLEND_SRC_ALPHA					0x00000050
+#define GLS_DSTBLEND_ONE_MINUS_SRC_ALPHA		0x00000060
+#define GLS_DSTBLEND_DST_ALPHA					0x00000070
+#define GLS_DSTBLEND_ONE_MINUS_DST_ALPHA		0x00000080
+#define		GLS_DSTBLEND_BITS					0x000000f0
+
+#define GLS_DEPTHMASK_TRUE						0x00000100
+
+#define GLS_POLYMODE_LINE						0x00001000
+
+#define GLS_DEPTHTEST_DISABLE					0x00010000
+#define GLS_DEPTHFUNC_EQUAL						0x00020000
+
+#define GLS_ATEST_GT_0							0x10000000
+#define GLS_ATEST_LT_80							0x20000000
+#define GLS_ATEST_GE_80							0x40000000
+#define GLS_ATEST_GE_C0							0x80000000
+#define		GLS_ATEST_BITS						0xF0000000
+
+#define GLS_DEFAULT			GLS_DEPTHMASK_TRUE
+#define GLS_ALPHA			(GLS_SRCBLEND_SRC_ALPHA | GLS_DSTBLEND_ONE_MINUS_SRC_ALPHA)
+
+void	RE_StretchRaw (int x, int y, int w, int h, int cols, int rows, const byte *data, int client, qboolean dirty);
+void	RE_UploadCinematic (int cols, int rows, const byte *data, int client, qboolean dirty);
+
+void		RE_BeginFrame( stereoFrame_t stereoFrame );
+void		RE_BeginRegistration( glconfig_t *glconfig );
+void		R_ColorShiftLightingBytes( byte in[4], byte out[4] ); //rwwRMG - added
+void		RE_LoadWorldMap( const char *mapname );
+
+#ifdef _XBOX
+void		RE_SetWorldVisData( SPARC<byte> *vis );
+#else
+void		RE_SetWorldVisData( const byte *vis );
+#endif
+
+qhandle_t	RE_RegisterServerModel( const char *name );
+qhandle_t	RE_RegisterModel( const char *name );
+qhandle_t	RE_RegisterSkin( const char *name );
+void		RE_Shutdown( qboolean destroyWindow );
+
+void		RE_RegisterMedia_LevelLoadBegin(const char *psMapName, ForceReload_e eForceReload);
+void		RE_RegisterMedia_LevelLoadEnd(void);
+int			RE_RegisterMedia_GetLevel(void);
+//
+//void		RE_RegisterModels_LevelLoadBegin(const char *psMapName);
+qboolean	RE_RegisterModels_LevelLoadEnd(qboolean bDeleteEverythingNotUsedThisLevel = qfalse);
+void*		RE_RegisterModels_Malloc(int iSize, void *pvDiskBufferIfJustLoaded, const char *psModelFileName, qboolean *pqbAlreadyFound, memtag_t eTag);
+void		RE_RegisterModels_StoreShaderRequest(const char *psModelFileName, const char *psShaderName, int *piShaderIndexPoke);
+void		RE_RegisterModels_Info_f(void);
+//
+//void		RE_RegisterImages_LevelLoadBegin(const char *psMapName);
+qboolean	RE_RegisterImages_LevelLoadEnd(void);
+void		RE_RegisterImages_Info_f(void);
+
+
+qboolean	R_GetEntityToken( char *buffer, int size );
+
+model_t		*R_AllocModel( void );
+
+void    	R_Init( void );
+
+#ifndef DEDICATED
+#ifdef _XBOX
+void R_LoadImage( const char *shortname, byte **pic, int *width, int *height, int *mipcount, GLenum *format );
+#else
+void R_LoadImage( const char *name, byte **pic, int *width, int *height, GLenum *format );
+#endif
+#endif // DEDICATED
+
+image_t		*R_FindImageFile( const char *name, qboolean mipmap, qboolean allowPicmip, qboolean allowTC, int glWrapClampMode );
+
+#ifndef DEDICATED
+#ifdef _XBOX
+image_t		*R_CreateImage( const char *name, const byte *pic, int width, int height, GLenum format, qboolean mipmap, qboolean allowPicmip, int wrapClampMode);
+#else
+image_t		*R_CreateImage( const char *name, const byte *pic, int width, int height, GLenum format, qboolean mipmap
+					, qboolean allowPicmip, qboolean allowTC, int wrapClampMode, bool bRectangle = false );
+#endif // _XBOX
+#endif // DEDICATED
+
+qboolean	R_GetModeInfo( int *width, int *height, int mode );
+
+void		R_SetColorMappings( void );
+void		R_GammaCorrect( byte *buffer, int bufSize );
+
+void	R_ImageList_f( void );
+void	R_SkinList_f( void );
+void	R_ScreenShot_f( void );
+
+void	R_InitFogTable( void );
+float	R_FogFactor( float s, float t );
+void	R_InitImages( void );
+void	R_DeleteTextures( void );
+float	R_SumOfUsedImages( qboolean bUseFormat );
+void	R_InitSkins( void );
+skin_t	*R_GetSkinByHandle( qhandle_t hSkin );
+
+
+//
+// tr_shader.c
+//
+extern	const int	lightmapsNone[MAXLIGHTMAPS];
+extern	const int	lightmaps2d[MAXLIGHTMAPS];
+extern	const int	lightmapsVertex[MAXLIGHTMAPS];
+extern	const int	lightmapsFullBright[MAXLIGHTMAPS];
+extern	const byte	stylesDefault[MAXLIGHTMAPS];
+
+qhandle_t RE_RegisterShaderLightMap( const char *name, const int *lightmapIndex, const byte *styles ) ;
+qhandle_t		 RE_RegisterShader( const char *name );
+qhandle_t		 RE_RegisterShaderNoMip( const char *name );
+const char		*RE_ShaderNameFromIndex(int index);
+qhandle_t RE_RegisterShaderFromImage(const char *name, int *lightmapIndex, byte *styles, image_t *image, qboolean mipRawImage);
+
+shader_t	*R_FindShader( const char *name, const int *lightmapIndex, const byte *styles, qboolean mipRawImage );
+shader_t	*R_GetShaderByHandle( qhandle_t hShader );
+shader_t	*R_GetShaderByState( int index, long *cycleTime );
+shader_t *R_FindShaderByName( const char *name );
+void		R_InitShaders(qboolean server);
+void		R_ShaderList_f( void );
+void    R_RemapShader(const char *oldShader, const char *newShader, const char *timeOffset);
+//rwwRMG: Added:
+qhandle_t	R_GetShaderByNum(int index, world_t &worldData);
+qhandle_t	R_CreateBlendedShader(qhandle_t a, qhandle_t b, qhandle_t c, bool surfaceSprites );
+
+
+/*
+====================================================================
+
+IMPLEMENTATION SPECIFIC FUNCTIONS
+
+====================================================================
+*/
+
+void		GLimp_Init( void );
+void		GLimp_Shutdown( void );
+void		GLimp_EndFrame( void );
+
+void		GLimp_LogComment( char *comment );
+
+#ifndef _XBOX
+void		GLimp_SetGamma( unsigned char red[256], 
+						    unsigned char green[256],
+							unsigned char blue[256] );
+#endif
+
+#ifdef _XBOX
+typedef struct 
+{
+	char		levelName[_MAX_PATH];
+	vec3_t		sundir;
+	bool		hdrEnable;
+	float		hdrBloom;
+} levelLightParm_t;
+
+void R_GetLightParmsForLevel();
+void R_LoadLevelLightParms();
+#endif
+
+
+/*
+====================================================================
+
+TESSELATOR/SHADER DECLARATIONS
+
+====================================================================
+*/
+typedef byte color4ub_t[4];
+
+typedef struct stageVars
+{
+#ifdef _XBOX
+	unsigned long colors[SHADER_MAX_VERTEXES];
+#else
+	color4ub_t	colors[SHADER_MAX_VERTEXES];
+#endif
+	vec2_t		texcoords[NUM_TEXTURE_BUNDLES][SHADER_MAX_VERTEXES];
+} stageVars_t;
+
+#define	NUM_TEX_COORDS		(MAXLIGHTMAPS+1)
+
+struct shaderCommands_s 
+{
+	glIndex_t	indexes[SHADER_MAX_INDEXES];
+	vec4_t		xyz[SHADER_MAX_VERTEXES];
+	vec4_t		normal[SHADER_MAX_VERTEXES];
+#ifdef _XBOX
+	vec4_t		tangent[SHADER_MAX_VERTEXES];
+#endif
+	vec2_t		texCoords[SHADER_MAX_VERTEXES][NUM_TEX_COORDS];
+	color4ub_t	vertexColors[SHADER_MAX_VERTEXES];
+	byte		vertexAlphas[SHADER_MAX_VERTEXES][4]; //rwwRMG - added support
+	int			vertexDlightBits[SHADER_MAX_VERTEXES];
+
+	stageVars_t	svars;
+
+	shader_t	*shader;
+  float   shaderTime;
+	int			fogNum;
+
+	int			dlightBits;	// or together of all vertexDlightBits
+
+	int			numIndexes;
+	int			numVertexes;
+
+	// info extracted from current shader
+	int			numPasses;
+#ifdef _XBOX
+	int		    currentPass;
+	bool		setTangents;
+#endif
+	void		(*currentStageIteratorFunc)( void );
+	shaderStage_t	*xstages;
+
+	int			registration;
+
+	qboolean	SSInitializedWind;
+
+	//rww - doing a fade, don't compute shader color/alpha overrides
+	bool		fading;
+};
+#ifndef DEDICATED
+typedef __declspec(align(16)) shaderCommands_s	shaderCommands_t;
+extern	shaderCommands_t	tess;
+#endif
+extern	color4ub_t	styleColors[MAX_LIGHT_STYLES];
+
+void RB_BeginSurface(shader_t *shader, int fogNum );
+void RB_EndSurface(void);
+void RB_CheckOverflow( int verts, int indexes );
+#define RB_CHECKOVERFLOW(v,i) if (tess.numVertexes + (v) >= SHADER_MAX_VERTEXES || tess.numIndexes + (i) >= SHADER_MAX_INDEXES ) {RB_CheckOverflow(v,i);}
+
+void RB_StageIteratorGeneric( void );
+void RB_StageIteratorSky( void );
+
+void RB_AddQuadStamp( vec3_t origin, vec3_t left, vec3_t up, byte *color );
+void RB_AddQuadStampExt( vec3_t origin, vec3_t left, vec3_t up, byte *color, float s1, float t1, float s2, float t2 );
+
+void RB_ShowImages( void );
+
+
+/*
+============================================================
+
+WORLD MAP
+
+============================================================
+*/
+
+void R_AddBrushModelSurfaces( trRefEntity_t *e );
+void R_AddWorldSurfaces( void );
+qboolean R_inPVS( const vec3_t p1, const vec3_t p2, byte *mask );
+
+
+/*
+============================================================
+
+FLARES
+
+============================================================
+*/
+
+void R_ClearFlares( void );
+
+void RB_AddFlare( void *surface, int fogNum, vec3_t point, vec3_t color, vec3_t normal );
+void RB_AddDlightFlares( void );
+void RB_RenderFlares (void);
+
+/*
+============================================================
+
+LIGHTS
+
+============================================================
+*/
+
+void R_DlightBmodel( bmodel_t *bmodel, bool NoLight );
+void R_SetupEntityLighting( const trRefdef_t *refdef, trRefEntity_t *ent );
+void R_TransformDlights( int count, dlight_t *dl, orientationr_t *ori );
+int R_LightForPoint( vec3_t point, vec3_t ambientLight, vec3_t directedLight, vec3_t lightDir );
+
+
+/*
+============================================================
+
+SHADOWS
+
+============================================================
+*/
+
+void RB_ShadowTessEnd( void );
+void RB_ShadowFinish( void );
+void RB_ProjectionShadowDeform( void );
+
+/*
+============================================================
+
+SKIES
+
+============================================================
+*/
+#ifndef DEDICATED
+void R_BuildCloudData( shaderCommands_t *shader );
+void R_InitSkyTexCoords( float cloudLayerHeight );
+void R_DrawSkyBox( shaderCommands_t *shader );
+void RB_DrawSun( void );
+void RB_ClipSkyPolygons( shaderCommands_t *shader );
+#endif
+/*
+============================================================
+
+CURVE TESSELATION
+
+============================================================
+*/
+
+#define PATCH_STITCHING
+
+#ifdef _XBOX
+srfGridMesh_t *R_SubdividePatchToGrid( int width, int height,
+								drawVert_t* points,
+								drawVert_t* ctl, float* errorTable );
+#else
+srfGridMesh_t *R_SubdividePatchToGrid( int width, int height,
+								drawVert_t points[MAX_PATCH_SIZE*MAX_PATCH_SIZE] );
+#endif // _XBOX
+
+srfGridMesh_t *R_GridInsertColumn( srfGridMesh_t *grid, int column, int row, vec3_t point, float loderror );
+srfGridMesh_t *R_GridInsertRow( srfGridMesh_t *grid, int row, int column, vec3_t point, float loderror );
+void R_FreeSurfaceGridMesh( srfGridMesh_t *grid );
+/*
+Ghoul2 Insert Start
+*/
+
+float ProjectRadius( float r, vec3_t location );
+/*
+Ghoul2 Insert End
+*/
+/*
+============================================================
+
+MARKERS, POLYGON PROJECTION ON WORLD POLYGONS
+
+============================================================
+*/
+
+int R_MarkFragments( int numPoints, const vec3_t *points, const vec3_t projection,
+				   int maxPoints, vec3_t pointBuffer, int maxFragments, markFragment_t *fragmentBuffer );
+
+
+/*
+============================================================
+
+SCENE GENERATION
+
+============================================================
+*/
+
+void R_ToggleSmpFrame( void );
+
+void RE_ClearScene( void );
+void RE_ClearDecals ( void );
+void RE_AddRefEntityToScene( const refEntity_t *ent );
+void RE_AddMiniRefEntityToScene( const miniRefEntity_t *ent );
+void RE_AddPolyToScene( qhandle_t hShader , int numVerts, const polyVert_t *verts, int num );
+void RE_AddDecalToScene ( qhandle_t shader, const vec3_t origin, const vec3_t dir, float orientation, float r, float g, float b, float a, qboolean alphaFade, float radius, qboolean temporary );
+void RE_AddLightToScene( const vec3_t org, float intensity, float r, float g, float b );
+void RE_AddAdditiveLightToScene( const vec3_t org, float intensity, float r, float g, float b );
+void RE_RenderScene( const refdef_t *fd );
+
+/*
+=============================================================
+
+ANIMATED MODELS
+
+=============================================================
+*/
+
+void R_MakeAnimModel( model_t *model );
+void R_AddAnimSurfaces( trRefEntity_t *ent );
+/*
+Ghoul2 Insert Start
+*/
+#pragma warning (disable: 4512)	//default assignment operator could not be gened
+class CRenderableSurface
+{
+public:
+#ifdef _G2_GORE
+	int				ident;
+#else
+	const int		ident;			// ident of this surface - required so the materials renderer knows what sort of surface this refers to 
+#endif
+	CBoneCache 		*boneCache;
+	mdxmSurface_t	*surfaceData;	// pointer to surface data loaded into file - only used by client renderer DO NOT USE IN GAME SIDE - if there is a vid restart this will be out of wack on the game
+#ifdef _G2_GORE
+	float			*alternateTex;		// alternate texture coordinates.
+	void			*goreChain;
+
+	float			scale;
+	float			fade;
+	float			impactTime; // this is a number between 0 and 1 that dictates the progression of the bullet impact
+#endif
+
+#ifdef _G2_GORE
+	CRenderableSurface& operator= ( const CRenderableSurface& src )
+	{
+		ident	 = src.ident;
+		boneCache = src.boneCache;
+		surfaceData = src.surfaceData;
+		alternateTex = src.alternateTex;
+		goreChain = src.goreChain;
+
+		return *this;
+	}
+#endif
+
+CRenderableSurface():	
+	ident(SF_MDX),
+	boneCache(0),
+#ifdef _G2_GORE
+	surfaceData(0),
+	alternateTex(0),
+	goreChain(0)
+#else
+	surfaceData(0)
+#endif
+	{}
+
+#ifdef _G2_GORE
+	void Init()
+	{
+		ident = SF_MDX;
+		boneCache=0;
+		surfaceData=0;
+		alternateTex=0;
+		goreChain=0;
+	}
+#endif
+};
+
+void R_AddGhoulSurfaces( trRefEntity_t *ent );
+void RB_SurfaceGhoul( CRenderableSurface *surface );
+/*
+Ghoul2 Insert End
+*/
+/*
+=============================================================
+=============================================================
+*/
+void	R_TransformModelToClip( const vec3_t src, const float *modelMatrix, const float *projectionMatrix,
+							vec4_t eye, vec4_t dst );
+void	R_TransformClipToWindow( const vec4_t clip, const viewParms_t *view, vec4_t normalized, vec4_t window );
+
+void	RB_DeformTessGeometry( void );
+
+void	RB_CalcEnvironmentTexCoords( float *dstTexCoords );
+void	RB_CalcFogTexCoords( float *dstTexCoords );
+void	RB_CalcScrollTexCoords( const float scroll[2], float *dstTexCoords );
+void	RB_CalcRotateTexCoords( float rotSpeed, float *dstTexCoords );
+void	RB_CalcScaleTexCoords( const float scale[2], float *dstTexCoords );
+void	RB_CalcTurbulentTexCoords( const waveForm_t *wf, float *dstTexCoords );
+void	RB_CalcTransformTexCoords( const texModInfo_t *tmi, float *dstTexCoords );
+void	RB_CalcStretchTexCoords( const waveForm_t *wf, float *texCoords );
+#ifdef _XBOX
+void	RB_CalcWaveColor( const waveForm_t *wf, DWORD *dstColors );
+void	RB_CalcColorFromEntity( DWORD *dstColors );
+void	RB_CalcColorFromOneMinusEntity( DWORD *dstColors );
+void	RB_CalcWaveAlpha( const waveForm_t *wf, DWORD *dstColors );
+void	RB_CalcSpecularAlpha( DWORD *alphas );
+void	RB_CalcAlphaFromEntity( DWORD *dstColors );
+void	RB_CalcAlphaFromOneMinusEntity( DWORD *dstColors );
+void	RB_CalcModulateColorsByFog( DWORD *dstColors );
+void	RB_CalcModulateAlphasByFog( DWORD *dstColors );
+void	RB_CalcModulateRGBAsByFog( DWORD *dstColors );
+void	RB_CalcDisintegrateColors( DWORD *colors );
+#else
+void	RB_CalcModulateColorsByFog( unsigned char *dstColors );
+void	RB_CalcModulateAlphasByFog( unsigned char *dstColors );
+void	RB_CalcModulateRGBAsByFog( unsigned char *dstColors );
+void	RB_CalcWaveAlpha( const waveForm_t *wf, unsigned char *dstColors );
+void	RB_CalcWaveColor( const waveForm_t *wf, unsigned char *dstColors );
+void	RB_CalcAlphaFromEntity( unsigned char *dstColors );
+void	RB_CalcAlphaFromOneMinusEntity( unsigned char *dstColors );
+void	RB_CalcColorFromEntity( unsigned char *dstColors );
+void	RB_CalcColorFromOneMinusEntity( unsigned char *dstColors );
+void	RB_CalcSpecularAlpha( unsigned char *alphas );
+void	RB_CalcDisintegrateColors( unsigned char *colors );
+#endif // _XBOX
+void	RB_CalcDiffuseColor( unsigned char *colors );
+void	RB_CalcDiffuseEntityColor( unsigned char *colors );
+void	RB_CalcDisintegrateVertDeform( void );
+
+/*
+=============================================================
+
+RENDERER BACK END FUNCTIONS
+
+=============================================================
+*/
+
+void RB_RenderThread( void );
+void RB_ExecuteRenderCommands( const void *data );
+
+/*
+=============================================================
+
+RENDERER BACK END COMMAND QUEUE
+
+=============================================================
+*/
+
+#ifdef _XBOX
+#define	MAX_RENDER_COMMANDS	0x18000
+#else
+#define	MAX_RENDER_COMMANDS	0x40000
+#endif
+
+typedef struct {
+	byte	cmds[MAX_RENDER_COMMANDS];
+	int		used;
+} renderCommandList_t;
+
+typedef struct {
+	int		commandId;
+	float	color[4];
+} setColorCommand_t;
+
+typedef struct {
+	int		commandId;
+	int		buffer;
+} drawBufferCommand_t;
+
+typedef struct {
+	int		commandId;
+	image_t	*image;
+	int		width;
+	int		height;
+	void	*data;
+} subImageCommand_t;
+
+typedef struct {
+	int		commandId;
+} swapBuffersCommand_t;
+
+typedef struct {
+	int		commandId;
+	int		buffer;
+} endFrameCommand_t;
+
+typedef struct {
+	int		commandId;
+	shader_t	*shader;
+	float	x, y;
+	float	w, h;
+	float	s1, t1;
+	float	s2, t2;
+} stretchPicCommand_t;
+
+typedef struct {
+	int		commandId;
+	shader_t	*shader;
+	float	x, y;
+	float	w, h;
+	float	s1, t1;
+	float	s2, t2;
+	float	a;
+} rotatePicCommand_t;
+
+typedef struct {
+	int		commandId;
+	trRefdef_t	refdef;
+	viewParms_t	viewParms;
+	drawSurf_t *drawSurfs;
+	int		numDrawSurfs;
+} drawSurfsCommand_t;
+
+typedef enum {
+	RC_END_OF_LIST,
+	RC_SET_COLOR,
+	RC_STRETCH_PIC,
+	RC_ROTATE_PIC,
+	RC_ROTATE_PIC2,
+	RC_DRAW_SURFS,
+	RC_DRAW_BUFFER,
+	RC_SWAP_BUFFERS,
+	RC_WORLD_EFFECTS,
+	RC_AUTO_MAP
+} renderCommand_t;
+
+
+// these are sort of arbitrary limits.
+// the limits apply to the sum of all scenes in a frame --
+// the main view, all the 3D icons, etc
+#define	MAX_POLYS		600
+#define	MAX_POLYVERTS	3000
+
+// all of the information needed by the back end must be
+// contained in a backEndData_t.  This entire structure is
+// duplicated so the front and back end can run in parallel
+// on an SMP machine
+typedef struct {
+	drawSurf_t	drawSurfs[MAX_DRAWSURFS];
+#ifndef VV_LIGHTING
+	dlight_t	dlights[MAX_DLIGHTS];
+#endif
+	trRefEntity_t	entities[MAX_ENTITIES];
+	trMiniRefEntity_t	miniEntities[MAX_MINI_ENTITIES];
+	srfPoly_t	*polys;//[MAX_POLYS];
+	polyVert_t	*polyVerts;//[MAX_POLYVERTS];
+	renderCommandList_t	commands;
+} backEndData_t;
+
+extern	int		max_polys;
+extern	int		max_polyverts;
+
+extern	backEndData_t	*backEndData;
+
+
+void *R_GetCommandBuffer( int bytes );
+void RB_ExecuteRenderCommands( const void *data );
+
+void R_InitCommandBuffers( void );
+void R_ShutdownCommandBuffers( void );
+
+void R_SyncRenderThread( void );
+
+void R_AddDrawSurfCmd( drawSurf_t *drawSurfs, int numDrawSurfs );
+
+void RE_SetColor( const float *rgba );
+void RE_StretchPic ( float x, float y, float w, float h, 
+					  float s1, float t1, float s2, float t2, qhandle_t hShader );
+void RE_RotatePic ( float x, float y, float w, float h, 
+					  float s1, float t1, float s2, float t2,float a, qhandle_t hShader );
+void RE_RotatePic2 ( float x, float y, float w, float h, 
+					  float s1, float t1, float s2, float t2,float a, qhandle_t hShader );
+void RE_BeginFrame( stereoFrame_t stereoFrame );
+void RE_EndFrame( int *frontEndMsec, int *backEndMsec );
+void SaveJPG(char * filename, int quality, int image_width, int image_height, unsigned char *image_buffer);
+
+/*
+Ghoul2 Insert Start
+*/
+// tr_ghoul2.cpp
+void		Create_Matrix(const float *angle, mdxaBone_t *matrix);
+void		Multiply_3x4Matrix(mdxaBone_t *out, mdxaBone_t *in2, mdxaBone_t *in);
+extern qboolean R_LoadMDXM (model_t *mod, void *buffer, const char *name, qboolean &bAlreadyCached );
+extern qboolean R_LoadMDXA (model_t *mod, void *buffer, const char *name, qboolean &bAlreadyCached );
+bool LoadTGAPalletteImage ( const char *name, byte **pic, int *width, int *height);
+void		RE_InsertModelIntoHash(const char *name, model_t *mod);
+/*
+Ghoul2 Insert End
+*/
+
+#define	MAX_VERTS_ON_DECAL_POLY	10
+#define	MAX_DECAL_POLYS			500
+
+typedef struct decalPoly_s 
+{
+	int					time;
+	int					fadetime;
+	qhandle_t			shader;
+	float				color[4];
+	poly_t				poly;
+	polyVert_t			verts[MAX_VERTS_ON_DECAL_POLY];
+
+} decalPoly_t;
+
+#ifndef DEDICATED
+// tr_surfacesprites
+void RB_DrawSurfaceSprites( shaderStage_t *stage, shaderCommands_t *input);
+#endif
+
+#ifdef _XBOX
+struct DDS_PIXELFORMAT
+{
+    DWORD dwSize;
+    DWORD dwFlags;
+    DWORD dwFourCC;
+    DWORD dwRGBBitCount;
+    DWORD dwRBitMask;
+    DWORD dwGBitMask;
+    DWORD dwBBitMask;
+    DWORD dwABitMask;
+};
+
+struct DDS_HEADER
+{
+    DWORD dwSize;
+    DWORD dwHeaderFlags;
+    DWORD dwHeight;
+    DWORD dwWidth;
+    DWORD dwPitchOrLinearSize;
+    DWORD dwDepth;
+    DWORD dwMipMapCount;
+    DWORD dwReserved1[11];
+    DDS_PIXELFORMAT ddspf;
+    DWORD dwSurfaceFlags;
+    DWORD dwCubemapFlags;
+    DWORD dwReserved2[3];
+};
+#endif
+
+#endif //TR_LOCAL_H
diff --git a/codemp/renderer/tr_main.cpp b/codemp/renderer/tr_main.cpp
new file mode 100644
index 0000000..e779908
--- /dev/null
+++ b/codemp/renderer/tr_main.cpp
@@ -0,0 +1,1631 @@
+// tr_main.c -- main control flow for each frame
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+#include "tr_local.h"
+#include "../ghoul2/G2_local.h"
+// Yeah, this might be kind of bad, but no linux version is planned so far :-) - AReis
+// Gee- thanks guys - jdrews, the linux porter...
+#ifndef _XBOX
+#ifndef __linux__
+#include "../win32/glw_win.h"
+#endif 
+#endif
+
+trGlobals_t		tr;
+
+static float	s_flipMatrix[16] = {
+	// convert from our coordinate system (looking down X)
+	// to OpenGL's coordinate system (looking down -Z)
+#if defined (_XBOX)
+	0, 0, 1, 0,
+	-1, 0, 0, 0,
+	0, 1, 0, 0,
+	0, 0, 0, 1
+#else
+	0, 0, -1, 0,
+	-1, 0, 0, 0,
+	0, 1, 0, 0,
+	0, 0, 0, 1
+#endif
+};
+
+void R_AddTerrainSurfaces(void);
+
+#ifndef DEDICATED
+
+// entities that will have procedurally generated surfaces will just
+// point at this for their sorting surface
+surfaceType_t	entitySurface = SF_ENTITY;
+
+/*
+=================
+R_CullLocalBox
+
+Returns CULL_IN, CULL_CLIP, or CULL_OUT
+=================
+*/
+int R_CullLocalBox (const vec3_t bounds[2]) {
+	int		i, j;
+	vec3_t	transformed[8];
+	float	dists[8];
+	vec3_t	v;
+	cplane_t	*frust;
+	int			anyBack;
+	int			front, back;
+
+	if ( r_nocull->integer==1 ) {
+		return CULL_CLIP;
+	}
+
+	// transform into world space
+	for (i = 0 ; i < 8 ; i++) {
+		v[0] = bounds[i&1][0];
+		v[1] = bounds[(i>>1)&1][1];
+		v[2] = bounds[(i>>2)&1][2];
+
+		VectorCopy( tr.ori.origin, transformed[i] );
+		VectorMA( transformed[i], v[0], tr.ori.axis[0], transformed[i] );
+		VectorMA( transformed[i], v[1], tr.ori.axis[1], transformed[i] );
+		VectorMA( transformed[i], v[2], tr.ori.axis[2], transformed[i] );
+	}
+
+	// check against frustum planes
+	anyBack = 0;
+	for (i = 0 ; i < 4 ; i++) {
+		frust = &tr.viewParms.frustum[i];
+
+		front = back = 0;
+		for (j = 0 ; j < 8 ; j++) {
+			dists[j] = DotProduct(transformed[j], frust->normal);
+			if ( dists[j] > frust->dist ) {
+				front = 1;
+				if ( back ) {
+					break;		// a point is in front
+				}
+			} else {
+				back = 1;
+			}
+		}
+		if ( !front ) {
+			// all points were behind one of the planes
+			return CULL_OUT;
+		}
+		anyBack |= back;
+	}
+
+	if ( !anyBack ) {
+		return CULL_IN;		// completely inside frustum
+	}
+
+	return CULL_CLIP;		// partially clipped
+}
+
+#endif // !DEDICATED
+
+/*
+** R_CullLocalPointAndRadius
+*/
+int R_CullLocalPointAndRadius( const vec3_t pt, float radius )
+{
+	vec3_t transformed;
+
+	R_LocalPointToWorld( pt, transformed );
+
+	return R_CullPointAndRadius( transformed, radius );
+}
+
+/*
+** R_CullPointAndRadius
+*/
+int R_CullPointAndRadius( const vec3_t pt, float radius )
+{
+	int		i;
+	float	dist;
+	cplane_t	*frust;
+	qboolean mightBeClipped = qfalse;
+
+	if ( r_nocull->integer==1 ) {
+		return CULL_CLIP;
+	}
+
+	// check against frustum planes
+	for (i = 0 ; i < 4 ; i++) 
+	{
+		frust = &tr.viewParms.frustum[i];
+
+		dist = DotProduct( pt, frust->normal) - frust->dist;
+		if ( dist < -radius )
+		{
+			return CULL_OUT;
+		}
+		else if ( dist <= radius ) 
+		{
+			mightBeClipped = qtrue;
+		}
+	}
+
+	if ( mightBeClipped )
+	{
+		return CULL_CLIP;
+	}
+
+	return CULL_IN;		// completely inside frustum
+}
+
+#ifndef DEDICATED
+
+/*
+=================
+R_LocalNormalToWorld
+
+=================
+*/
+void R_LocalNormalToWorld (const vec3_t local, vec3_t world) {
+	world[0] = local[0] * tr.ori.axis[0][0] + local[1] * tr.ori.axis[1][0] + local[2] * tr.ori.axis[2][0];
+	world[1] = local[0] * tr.ori.axis[0][1] + local[1] * tr.ori.axis[1][1] + local[2] * tr.ori.axis[2][1];
+	world[2] = local[0] * tr.ori.axis[0][2] + local[1] * tr.ori.axis[1][2] + local[2] * tr.ori.axis[2][2];
+}
+
+#endif // !DEDICATED
+/*
+=================
+R_LocalPointToWorld
+
+=================
+*/
+void R_LocalPointToWorld (const vec3_t local, vec3_t world) {
+	world[0] = local[0] * tr.ori.axis[0][0] + local[1] * tr.ori.axis[1][0] + local[2] * tr.ori.axis[2][0] + tr.ori.origin[0];
+	world[1] = local[0] * tr.ori.axis[0][1] + local[1] * tr.ori.axis[1][1] + local[2] * tr.ori.axis[2][1] + tr.ori.origin[1];
+	world[2] = local[0] * tr.ori.axis[0][2] + local[1] * tr.ori.axis[1][2] + local[2] * tr.ori.axis[2][2] + tr.ori.origin[2];
+}
+
+#ifndef DEDICATED
+
+float preTransEntMatrix[16];
+
+/*
+=================
+R_WorldNormalToEntity 
+
+=================
+*/
+void R_WorldNormalToEntity (const vec3_t worldvec, vec3_t entvec) 
+{
+	entvec[0] = -worldvec[0] * preTransEntMatrix[0] - worldvec[1] * preTransEntMatrix[4] + worldvec[2] * preTransEntMatrix[8];
+	entvec[1] = -worldvec[0] * preTransEntMatrix[1] - worldvec[1] * preTransEntMatrix[5] + worldvec[2] * preTransEntMatrix[9];
+	entvec[2] = -worldvec[0] * preTransEntMatrix[2] - worldvec[1] * preTransEntMatrix[6] + worldvec[2] * preTransEntMatrix[10];
+}
+
+/*
+=================
+R_WorldPointToEntity 
+
+=================
+*/
+/*void R_WorldPointToEntity (vec3_t worldvec, vec3_t entvec)
+{
+	entvec[0] = worldvec[0] * preTransEntMatrix[0] + worldvec[1] * preTransEntMatrix[4] + worldvec[2] * preTransEntMatrix[8]+preTransEntMatrix[12];
+	entvec[1] = worldvec[0] * preTransEntMatrix[1] + worldvec[1] * preTransEntMatrix[5] + worldvec[2] * preTransEntMatrix[9]+preTransEntMatrix[13];
+	entvec[2] = worldvec[0] * preTransEntMatrix[2] + worldvec[1] * preTransEntMatrix[6] + worldvec[2] * preTransEntMatrix[10]+preTransEntMatrix[14];
+}
+*/
+
+/*
+=================
+R_WorldToLocal
+
+=================
+*/
+void R_WorldToLocal (vec3_t world, vec3_t local) {
+	local[0] = DotProduct(world, tr.ori.axis[0]);
+	local[1] = DotProduct(world, tr.ori.axis[1]);
+	local[2] = DotProduct(world, tr.ori.axis[2]);
+}
+
+/*
+==========================
+R_TransformModelToClip
+
+==========================
+*/
+void R_TransformModelToClip( const vec3_t src, const float *modelMatrix, const float *projectionMatrix,
+							vec4_t eye, vec4_t dst ) {
+	int i;
+
+	for ( i = 0 ; i < 4 ; i++ ) {
+		eye[i] = 
+			src[0] * modelMatrix[ i + 0 * 4 ] +
+			src[1] * modelMatrix[ i + 1 * 4 ] +
+			src[2] * modelMatrix[ i + 2 * 4 ] +
+			1 * modelMatrix[ i + 3 * 4 ];
+	}
+
+	for ( i = 0 ; i < 4 ; i++ ) {
+		dst[i] = 
+			eye[0] * projectionMatrix[ i + 0 * 4 ] +
+			eye[1] * projectionMatrix[ i + 1 * 4 ] +
+			eye[2] * projectionMatrix[ i + 2 * 4 ] +
+			eye[3] * projectionMatrix[ i + 3 * 4 ];
+	}
+}
+
+/*
+==========================
+R_TransformClipToWindow
+
+==========================
+*/
+void R_TransformClipToWindow( const vec4_t clip, const viewParms_t *view, vec4_t normalized, vec4_t window ) {
+	normalized[0] = clip[0] / clip[3];
+	normalized[1] = clip[1] / clip[3];
+	normalized[2] = ( clip[2] + clip[3] ) / ( 2 * clip[3] );
+
+	window[0] = 0.5f * ( 1.0f + normalized[0] ) * view->viewportWidth;
+	window[1] = 0.5f * ( 1.0f + normalized[1] ) * view->viewportHeight;
+	window[2] = normalized[2];
+
+	window[0] = (int) ( window[0] + 0.5 );
+	window[1] = (int) ( window[1] + 0.5 );
+}
+
+
+/*
+==========================
+myGlMultMatrix
+
+==========================
+*/
+void myGlMultMatrix( const float *a, const float *b, float *out ) {
+	int		i, j;
+
+	for ( i = 0 ; i < 4 ; i++ ) {
+		for ( j = 0 ; j < 4 ; j++ ) {
+			out[ i * 4 + j ] =
+				a [ i * 4 + 0 ] * b [ 0 * 4 + j ]
+				+ a [ i * 4 + 1 ] * b [ 1 * 4 + j ]
+				+ a [ i * 4 + 2 ] * b [ 2 * 4 + j ]
+				+ a [ i * 4 + 3 ] * b [ 3 * 4 + j ];
+		}
+	}
+}
+
+/*
+=================
+R_RotateForEntity
+
+Generates an orientation for an entity and viewParms
+Does NOT produce any GL calls
+Called by both the front end and the back end
+=================
+*/
+void R_RotateForEntity( const trRefEntity_t *ent, const viewParms_t *viewParms,
+					   orientationr_t *ori ) {
+//	float	glMatrix[16];
+	vec3_t	delta;
+	float	axisLength;
+
+	if ( ent->e.reType != RT_MODEL ) {
+		*ori = viewParms->world;
+		return;
+	}
+
+	VectorCopy( ent->e.origin, ori->origin );
+
+	VectorCopy( ent->e.axis[0], ori->axis[0] );
+	VectorCopy( ent->e.axis[1], ori->axis[1] );
+	VectorCopy( ent->e.axis[2], ori->axis[2] );
+
+	preTransEntMatrix[0] = ori->axis[0][0];
+	preTransEntMatrix[4] = ori->axis[1][0];
+	preTransEntMatrix[8] = ori->axis[2][0];
+	preTransEntMatrix[12] = ori->origin[0];
+
+	preTransEntMatrix[1] = ori->axis[0][1];
+	preTransEntMatrix[5] = ori->axis[1][1];
+	preTransEntMatrix[9] = ori->axis[2][1];
+	preTransEntMatrix[13] = ori->origin[1];
+
+	preTransEntMatrix[2] = ori->axis[0][2];
+	preTransEntMatrix[6] = ori->axis[1][2];
+	preTransEntMatrix[10] = ori->axis[2][2];
+	preTransEntMatrix[14] = ori->origin[2];
+
+	preTransEntMatrix[3] = 0;
+	preTransEntMatrix[7] = 0;
+	preTransEntMatrix[11] = 0;
+	preTransEntMatrix[15] = 1;
+
+	myGlMultMatrix( preTransEntMatrix, viewParms->world.modelMatrix, ori->modelMatrix );
+
+	// calculate the viewer origin in the model's space
+	// needed for fog, specular, and environment mapping
+	VectorSubtract( viewParms->ori.origin, ori->origin, delta );
+
+	// compensate for scale in the axes if necessary
+	if ( ent->e.nonNormalizedAxes ) {
+		axisLength = VectorLength( ent->e.axis[0] );
+		if ( !axisLength ) {
+			axisLength = 0;
+		} else {
+			axisLength = 1.0f / axisLength;
+		}
+	} else {
+		axisLength = 1.0f;
+	}
+
+	ori->viewOrigin[0] = DotProduct( delta, ori->axis[0] ) * axisLength;
+	ori->viewOrigin[1] = DotProduct( delta, ori->axis[1] ) * axisLength;
+	ori->viewOrigin[2] = DotProduct( delta, ori->axis[2] ) * axisLength;
+}
+
+/*
+=================
+R_RotateForViewer
+
+Sets up the modelview matrix for a given viewParm
+=================
+*/
+void R_RotateForViewer (void) 
+{
+	float	viewerMatrix[16];
+	vec3_t	origin;
+
+	Com_Memset (&tr.ori, 0, sizeof(tr.ori));
+	tr.ori.axis[0][0] = 1;
+	tr.ori.axis[1][1] = 1;
+	tr.ori.axis[2][2] = 1;
+	VectorCopy (tr.viewParms.ori.origin, tr.ori.viewOrigin);
+
+	// transform by the camera placement
+	VectorCopy( tr.viewParms.ori.origin, origin );
+
+	viewerMatrix[0] = tr.viewParms.ori.axis[0][0];
+	viewerMatrix[4] = tr.viewParms.ori.axis[0][1];
+	viewerMatrix[8] = tr.viewParms.ori.axis[0][2];
+	viewerMatrix[12] = -origin[0] * viewerMatrix[0] + -origin[1] * viewerMatrix[4] + -origin[2] * viewerMatrix[8];
+
+	viewerMatrix[1] = tr.viewParms.ori.axis[1][0];
+	viewerMatrix[5] = tr.viewParms.ori.axis[1][1];
+	viewerMatrix[9] = tr.viewParms.ori.axis[1][2];
+	viewerMatrix[13] = -origin[0] * viewerMatrix[1] + -origin[1] * viewerMatrix[5] + -origin[2] * viewerMatrix[9];
+
+	viewerMatrix[2] = tr.viewParms.ori.axis[2][0];
+	viewerMatrix[6] = tr.viewParms.ori.axis[2][1];
+	viewerMatrix[10] = tr.viewParms.ori.axis[2][2];
+	viewerMatrix[14] = -origin[0] * viewerMatrix[2] + -origin[1] * viewerMatrix[6] + -origin[2] * viewerMatrix[10];
+
+	viewerMatrix[3] = 0;
+	viewerMatrix[7] = 0;
+	viewerMatrix[11] = 0;
+	viewerMatrix[15] = 1;
+
+	// convert from our coordinate system (looking down X)
+	// to OpenGL's coordinate system (looking down -Z)
+	myGlMultMatrix( viewerMatrix, s_flipMatrix, tr.ori.modelMatrix );
+
+	tr.viewParms.world = tr.ori;
+
+}
+
+/*
+** SetFarClip
+*/
+static void SetFarClip( void )
+{
+	float	farthestCornerDistance = 0;
+	int		i;
+
+	// if not rendering the world (icons, menus, etc)
+	// set a 2k far clip plane
+	if ( tr.refdef.rdflags & RDF_NOWORLDMODEL ) {
+		if (tr.refdef.rdflags & RDF_AUTOMAP)
+		{ //override the zfar then
+			tr.viewParms.zFar = 32768.0f;
+		}
+		else
+		{
+			tr.viewParms.zFar = 2048.0f;
+		}
+		return;
+	}
+
+	//
+	// set far clipping planes dynamically
+	//
+	for ( i = 0; i < 8; i++ )
+	{
+		vec3_t v;
+		float distance;
+
+		if ( i & 1 )
+		{
+			v[0] = tr.viewParms.visBounds[0][0];
+		}
+		else
+		{
+			v[0] = tr.viewParms.visBounds[1][0];
+		}
+
+		if ( i & 2 )
+		{
+			v[1] = tr.viewParms.visBounds[0][1];
+		}
+		else
+		{
+			v[1] = tr.viewParms.visBounds[1][1];
+		}
+
+		if ( i & 4 )
+		{
+			v[2] = tr.viewParms.visBounds[0][2];
+		}
+		else
+		{
+			v[2] = tr.viewParms.visBounds[1][2];
+		}
+
+		distance = DistanceSquared(tr.viewParms.ori.origin, v);
+
+		if ( distance > farthestCornerDistance )
+		{
+			farthestCornerDistance = distance;
+		}
+	}
+	// Bring in the zFar to the distanceCull distance
+	// The sky renders at zFar so need to move it out a little
+	// ...and make sure there is a minimum zfar to prevent problems
+	tr.viewParms.zFar = Com_Clamp(2048.0f, tr.distanceCull * (1.732), sqrtf( farthestCornerDistance ));
+
+	/*
+	if (r_shadows->integer == 2)
+	{ //volume caps need an "infinite" far clipping plane. So I'm using this semi-arbitrary massive number.
+		tr.viewParms.zFar = 524288.0f;
+	}
+	*/
+}
+
+
+/*
+===============
+R_SetupProjection
+===============
+*/
+void R_SetupProjection( void ) {
+	float	xmin, xmax, ymin, ymax;
+	float	width, height, depth;
+	float	zNear, zFar;
+
+	// dynamically compute far clip plane distance
+	SetFarClip();
+
+	//
+	// set up projection matrix
+	//
+	zNear	= r_znear->value;
+	zFar	= tr.viewParms.zFar;
+
+	ymax = zNear * tan( tr.refdef.fov_y * M_PI / 360.0f );
+	ymin = -ymax;
+
+	xmax = zNear * tan( tr.refdef.fov_x * M_PI / 360.0f );
+	xmin = -xmax;
+
+	width = xmax - xmin;
+	height = ymax - ymin;
+	depth = zFar - zNear;
+
+#if defined (_XBOX)
+	tr.viewParms.projectionMatrix[0] = 2 * zNear / width;
+	tr.viewParms.projectionMatrix[4] = 0;
+	tr.viewParms.projectionMatrix[8] = ( xmax + xmin ) / width;	// normally 0
+	tr.viewParms.projectionMatrix[12] = 0;
+
+	tr.viewParms.projectionMatrix[1] = 0;
+	tr.viewParms.projectionMatrix[5] = 2 * zNear / height;
+	tr.viewParms.projectionMatrix[9] = ( ymax + ymin ) / height;	// normally 0
+	tr.viewParms.projectionMatrix[13] = 0;
+
+	tr.viewParms.projectionMatrix[2] = 0;
+	tr.viewParms.projectionMatrix[6] = 0;
+	tr.viewParms.projectionMatrix[10] = ( zFar + zNear ) / depth;
+	tr.viewParms.projectionMatrix[14] = -2 * zFar * zNear / depth;
+
+	tr.viewParms.projectionMatrix[3] = 0;
+	tr.viewParms.projectionMatrix[7] = 0;
+	tr.viewParms.projectionMatrix[11] = 1;
+	tr.viewParms.projectionMatrix[15] = 0;
+#else
+	tr.viewParms.projectionMatrix[0] = 2 * zNear / width;
+	tr.viewParms.projectionMatrix[4] = 0;
+	tr.viewParms.projectionMatrix[8] = ( xmax + xmin ) / width;	// normally 0
+	tr.viewParms.projectionMatrix[12] = 0;
+
+	tr.viewParms.projectionMatrix[1] = 0;
+	tr.viewParms.projectionMatrix[5] = 2 * zNear / height;
+	tr.viewParms.projectionMatrix[9] = ( ymax + ymin ) / height;	// normally 0
+	tr.viewParms.projectionMatrix[13] = 0;
+
+	tr.viewParms.projectionMatrix[2] = 0;
+	tr.viewParms.projectionMatrix[6] = 0;
+	tr.viewParms.projectionMatrix[10] = -( zFar + zNear ) / depth;
+	tr.viewParms.projectionMatrix[14] = -2 * zFar * zNear / depth;
+
+	tr.viewParms.projectionMatrix[3] = 0;
+	tr.viewParms.projectionMatrix[7] = 0;
+	tr.viewParms.projectionMatrix[11] = -1;
+	tr.viewParms.projectionMatrix[15] = 0;
+#endif
+}
+
+/*
+=================
+R_SetupFrustum
+
+Setup that culling frustum planes for the current view
+=================
+*/
+void R_SetupFrustum (void) {
+	int		i;
+	float	xs, xc;
+	float	ang;
+
+	ang = tr.viewParms.fovX / 180 * M_PI * 0.5f;
+	xs = sin( ang );
+	xc = cos( ang );
+
+	VectorScale( tr.viewParms.ori.axis[0], xs, tr.viewParms.frustum[0].normal );
+	VectorMA( tr.viewParms.frustum[0].normal, xc, tr.viewParms.ori.axis[1], tr.viewParms.frustum[0].normal );
+
+	VectorScale( tr.viewParms.ori.axis[0], xs, tr.viewParms.frustum[1].normal );
+	VectorMA( tr.viewParms.frustum[1].normal, -xc, tr.viewParms.ori.axis[1], tr.viewParms.frustum[1].normal );
+
+	ang = tr.viewParms.fovY / 180 * M_PI * 0.5f;
+	xs = sin( ang );
+	xc = cos( ang );
+
+	VectorScale( tr.viewParms.ori.axis[0], xs, tr.viewParms.frustum[2].normal );
+	VectorMA( tr.viewParms.frustum[2].normal, xc, tr.viewParms.ori.axis[2], tr.viewParms.frustum[2].normal );
+
+	VectorScale( tr.viewParms.ori.axis[0], xs, tr.viewParms.frustum[3].normal );
+	VectorMA( tr.viewParms.frustum[3].normal, -xc, tr.viewParms.ori.axis[2], tr.viewParms.frustum[3].normal );
+
+	for (i=0 ; i<4 ; i++) {
+		tr.viewParms.frustum[i].type = PLANE_NON_AXIAL;
+		tr.viewParms.frustum[i].dist = DotProduct (tr.viewParms.ori.origin, tr.viewParms.frustum[i].normal);
+		SetPlaneSignbits( &tr.viewParms.frustum[i] );
+	}
+}
+
+
+/*
+=================
+R_MirrorPoint
+=================
+*/
+void R_MirrorPoint (vec3_t in, orientation_t *surface, orientation_t *camera, vec3_t out) {
+	int		i;
+	vec3_t	local;
+	vec3_t	transformed;
+	float	d;
+
+	VectorSubtract( in, surface->origin, local );
+
+	VectorClear( transformed );
+	for ( i = 0 ; i < 3 ; i++ ) {
+		d = DotProduct(local, surface->axis[i]);
+		VectorMA( transformed, d, camera->axis[i], transformed );
+	}
+
+	VectorAdd( transformed, camera->origin, out );
+}
+
+void R_MirrorVector (vec3_t in, orientation_t *surface, orientation_t *camera, vec3_t out) {
+	int		i;
+	float	d;
+
+	VectorClear( out );
+	for ( i = 0 ; i < 3 ; i++ ) {
+		d = DotProduct(in, surface->axis[i]);
+		VectorMA( out, d, camera->axis[i], out );
+	}
+}
+
+
+/*
+=============
+R_PlaneForSurface
+=============
+*/
+void R_PlaneForSurface (surfaceType_t *surfType, cplane_t *plane) {
+	srfTriangles_t	*tri;
+	srfPoly_t		*poly;
+	drawVert_t		*v1, *v2, *v3;
+	vec4_t			plane4;
+
+	if (!surfType) {
+		Com_Memset (plane, 0, sizeof(*plane));
+		plane->normal[0] = 1;
+		return;
+	}
+	switch (*surfType) {
+	case SF_FACE:
+		*plane = ((srfSurfaceFace_t *)surfType)->plane;
+		return;
+	case SF_TRIANGLES:
+		tri = (srfTriangles_t *)surfType;
+		v1 = tri->verts + tri->indexes[0];
+		v2 = tri->verts + tri->indexes[1];
+		v3 = tri->verts + tri->indexes[2];
+		PlaneFromPoints( plane4, v1->xyz, v2->xyz, v3->xyz );
+		VectorCopy( plane4, plane->normal ); 
+		plane->dist = plane4[3];
+		return;
+	case SF_POLY:
+		poly = (srfPoly_t *)surfType;
+		PlaneFromPoints( plane4, poly->verts[0].xyz, poly->verts[1].xyz, poly->verts[2].xyz );
+		VectorCopy( plane4, plane->normal ); 
+		plane->dist = plane4[3];
+		return;
+	default:
+		Com_Memset (plane, 0, sizeof(*plane));
+		plane->normal[0] = 1;		
+		return;
+	}
+}
+
+/*
+=================
+R_GetPortalOrientation
+
+entityNum is the entity that the portal surface is a part of, which may
+be moving and rotating.
+
+Returns qtrue if it should be mirrored
+=================
+*/
+qboolean R_GetPortalOrientations( drawSurf_t *drawSurf, int entityNum, 
+							 orientation_t *surface, orientation_t *camera,
+							 vec3_t pvsOrigin, qboolean *mirror ) {
+	int			i;
+	cplane_t	originalPlane, plane;
+	trRefEntity_t	*e;
+	float		d;
+	vec3_t		transformed;
+
+	// create plane axis for the portal we are seeing
+	R_PlaneForSurface( drawSurf->surface, &originalPlane );
+
+	// rotate the plane if necessary
+	if ( entityNum != TR_WORLDENT ) {
+		tr.currentEntityNum = entityNum;
+		tr.currentEntity = &tr.refdef.entities[entityNum];
+
+		// get the orientation of the entity
+		R_RotateForEntity( tr.currentEntity, &tr.viewParms, &tr.ori );
+
+		// rotate the plane, but keep the non-rotated version for matching
+		// against the portalSurface entities
+		R_LocalNormalToWorld( originalPlane.normal, plane.normal );
+		plane.dist = originalPlane.dist + DotProduct( plane.normal, tr.ori.origin );
+
+		// translate the original plane
+		originalPlane.dist = originalPlane.dist + DotProduct( originalPlane.normal, tr.ori.origin );
+	} else {
+		plane = originalPlane;
+	}
+
+	VectorCopy( plane.normal, surface->axis[0] );
+	PerpendicularVector( surface->axis[1], surface->axis[0] );
+	CrossProduct( surface->axis[0], surface->axis[1], surface->axis[2] );
+
+	// locate the portal entity closest to this plane.
+	// origin will be the origin of the portal, origin2 will be
+	// the origin of the camera
+	for ( i = 0 ; i < tr.refdef.num_entities ; i++ ) {
+		e = &tr.refdef.entities[i];
+		if ( e->e.reType != RT_PORTALSURFACE ) {
+			continue;
+		}
+
+		d = DotProduct( e->e.origin, originalPlane.normal ) - originalPlane.dist;
+		if ( d > 64 || d < -64) {
+			continue;
+		}
+
+		// get the pvsOrigin from the entity
+		VectorCopy( e->e.oldorigin, pvsOrigin );
+
+		// if the entity is just a mirror, don't use as a camera point
+		if ( e->e.oldorigin[0] == e->e.origin[0] && 
+			e->e.oldorigin[1] == e->e.origin[1] && 
+			e->e.oldorigin[2] == e->e.origin[2] ) {
+			VectorScale( plane.normal, plane.dist, surface->origin );
+			VectorCopy( surface->origin, camera->origin );
+			VectorSubtract( vec3_origin, surface->axis[0], camera->axis[0] );
+			VectorCopy( surface->axis[1], camera->axis[1] );
+			VectorCopy( surface->axis[2], camera->axis[2] );
+
+			*mirror = qtrue;
+			return qtrue;
+		}
+
+		// project the origin onto the surface plane to get
+		// an origin point we can rotate around
+		d = DotProduct( e->e.origin, plane.normal ) - plane.dist;
+		VectorMA( e->e.origin, -d, surface->axis[0], surface->origin );
+			
+		// now get the camera origin and orientation
+		VectorCopy( e->e.oldorigin, camera->origin );
+		AxisCopy( e->e.axis, camera->axis );
+		VectorSubtract( vec3_origin, camera->axis[0], camera->axis[0] );
+		VectorSubtract( vec3_origin, camera->axis[1], camera->axis[1] );
+
+		// optionally rotate
+		if ( e->e.oldframe ) {
+			// if a speed is specified
+			if ( e->e.frame ) {
+				// continuous rotate
+				d = (tr.refdef.time/1000.0f) * e->e.frame;
+				VectorCopy( camera->axis[1], transformed );
+				RotatePointAroundVector( camera->axis[1], camera->axis[0], transformed, d );
+				CrossProduct( camera->axis[0], camera->axis[1], camera->axis[2] );
+			} else {
+				// bobbing rotate, with skinNum being the rotation offset
+				d = sin( tr.refdef.time * 0.003f );
+				d = e->e.skinNum + d * 4;
+				VectorCopy( camera->axis[1], transformed );
+				RotatePointAroundVector( camera->axis[1], camera->axis[0], transformed, d );
+				CrossProduct( camera->axis[0], camera->axis[1], camera->axis[2] );
+			}
+		}
+		else if ( e->e.skinNum ) {
+			d = e->e.skinNum;
+			VectorCopy( camera->axis[1], transformed );
+			RotatePointAroundVector( camera->axis[1], camera->axis[0], transformed, d );
+			CrossProduct( camera->axis[0], camera->axis[1], camera->axis[2] );
+		}
+		*mirror = qfalse;
+		return qtrue;
+	}
+
+	// if we didn't locate a portal entity, don't render anything.
+	// We don't want to just treat it as a mirror, because without a
+	// portal entity the server won't have communicated a proper entity set
+	// in the snapshot
+
+	// unfortunately, with local movement prediction it is easily possible
+	// to see a surface before the server has communicated the matching
+	// portal surface entity, so we don't want to print anything here...
+
+	//Com_Printf ("Portal surface without a portal entity\n" );
+
+	return qfalse;
+}
+
+static qboolean IsMirror( const drawSurf_t *drawSurf, int entityNum )
+{
+	int			i;
+	cplane_t	originalPlane, plane;
+	trRefEntity_t	*e;
+	float		d;
+
+	// create plane axis for the portal we are seeing
+	R_PlaneForSurface( drawSurf->surface, &originalPlane );
+
+	// rotate the plane if necessary
+	if ( entityNum != TR_WORLDENT ) 
+	{
+		tr.currentEntityNum = entityNum;
+		tr.currentEntity = &tr.refdef.entities[entityNum];
+
+		// get the orientation of the entity
+		R_RotateForEntity( tr.currentEntity, &tr.viewParms, &tr.ori );
+
+		// rotate the plane, but keep the non-rotated version for matching
+		// against the portalSurface entities
+		R_LocalNormalToWorld( originalPlane.normal, plane.normal );
+		plane.dist = originalPlane.dist + DotProduct( plane.normal, tr.ori.origin );
+
+		// translate the original plane
+		originalPlane.dist = originalPlane.dist + DotProduct( originalPlane.normal, tr.ori.origin );
+	} 
+	else 
+	{
+		plane = originalPlane;
+	}
+
+	// locate the portal entity closest to this plane.
+	// origin will be the origin of the portal, origin2 will be
+	// the origin of the camera
+	for ( i = 0 ; i < tr.refdef.num_entities ; i++ ) 
+	{
+		e = &tr.refdef.entities[i];
+		if ( e->e.reType != RT_PORTALSURFACE ) {
+			continue;
+		}
+
+		d = DotProduct( e->e.origin, originalPlane.normal ) - originalPlane.dist;
+		if ( d > 64 || d < -64) {
+			continue;
+		}
+
+		// if the entity is just a mirror, don't use as a camera point
+		if ( e->e.oldorigin[0] == e->e.origin[0] && 
+			e->e.oldorigin[1] == e->e.origin[1] && 
+			e->e.oldorigin[2] == e->e.origin[2] ) 
+		{
+			return qtrue;
+		}
+
+		return qfalse;
+	}
+	return qfalse;
+}
+#ifndef DEDICATED
+/*
+** SurfIsOffscreen
+**
+** Determines if a surface is completely offscreen.
+*/
+static qboolean SurfIsOffscreen( const drawSurf_t *drawSurf, vec4_t clipDest[128] ) {
+	float shortest = 100000000;
+	int entityNum;
+	int numTriangles;
+	shader_t *shader;
+	int		fogNum;
+	int dlighted;
+	vec4_t clip, eye;
+	int i;
+	unsigned int pointOr = 0;
+	unsigned int pointAnd = (unsigned int)~0;
+
+	R_RotateForViewer();
+
+	R_DecomposeSort( drawSurf->sort, &entityNum, &shader, &fogNum, &dlighted );
+	RB_BeginSurface( shader, fogNum );
+	rb_surfaceTable[ *drawSurf->surface ]( drawSurf->surface );
+	assert( tess.numVertexes < 128 );
+	for ( i = 0; i < tess.numVertexes; i++ )
+	{
+		int j;
+		unsigned int pointFlags = 0;
+
+		R_TransformModelToClip( tess.xyz[i], tr.ori.modelMatrix, tr.viewParms.projectionMatrix, eye, clip );
+
+		for ( j = 0; j < 3; j++ )
+		{
+			if ( clip[j] >= clip[3] )
+			{
+				pointFlags |= (1 << (j*2));
+			}
+			else if ( clip[j] <= -clip[3] )
+			{
+				pointFlags |= ( 1 << (j*2+1));
+			}
+		}
+		pointAnd &= pointFlags;
+		pointOr |= pointFlags;
+	}
+
+	// trivially reject
+	if ( pointAnd )
+	{
+		return qtrue;
+	}
+
+	// determine if this surface is backfaced and also determine the distance
+	// to the nearest vertex so we can cull based on portal range.  Culling
+	// based on vertex distance isn't 100% correct (we should be checking for
+	// range to the surface), but it's good enough for the types of portals
+	// we have in the game right now.
+	numTriangles = tess.numIndexes / 3;
+
+	for ( i = 0; i < tess.numIndexes; i += 3 )
+	{
+		vec3_t normal;
+		float dot;
+		float len;
+
+		VectorSubtract( tess.xyz[tess.indexes[i]], tr.viewParms.ori.origin, normal );
+
+		len = VectorLengthSquared( normal );			// lose the sqrt
+		if ( len < shortest )
+		{
+			shortest = len;
+		}
+
+		if ( ( dot = DotProduct( normal, tess.normal[tess.indexes[i]] ) ) >= 0 )
+		{
+			numTriangles--;
+		}
+	}
+	if ( !numTriangles )
+	{
+		return qtrue;
+	}
+
+	// mirrors can early out at this point, since we don't do a fade over distance
+	// with them (although we could)
+	if ( IsMirror( drawSurf, entityNum ) )
+	{
+		return qfalse;
+	}
+
+	if ( shortest > (tess.shader->portalRange*tess.shader->portalRange) )
+	{
+		return qtrue;
+	}
+
+	return qfalse;
+}
+
+#endif // DEDICATED
+/*
+========================
+R_MirrorViewBySurface
+
+Returns qtrue if another view has been rendered
+========================
+*/
+qboolean R_MirrorViewBySurface (drawSurf_t *drawSurf, int entityNum) {
+	vec4_t			clipDest[128];
+	viewParms_t		newParms;
+	viewParms_t		oldParms;
+	orientation_t	surface, camera;
+
+	// don't recursively mirror
+	if (tr.viewParms.isPortal) {
+		Com_DPrintf (S_COLOR_RED "WARNING: recursive mirror/portal found\n" );
+		return qfalse;
+	}
+
+	if ( r_noportals->integer || (r_fastsky->integer == 1) ) {
+		return qfalse;
+	}
+
+	// trivially reject portal/mirror
+	if ( SurfIsOffscreen( drawSurf, clipDest ) ) {
+		return qfalse;
+	}
+
+	// save old viewParms so we can return to it after the mirror view
+	oldParms = tr.viewParms;
+
+	newParms = tr.viewParms;
+	newParms.isPortal = qtrue;
+	if ( !R_GetPortalOrientations( drawSurf, entityNum, &surface, &camera, 
+		newParms.pvsOrigin, &newParms.isMirror ) ) {
+		return qfalse;		// bad portal, no portalentity
+	}
+
+	R_MirrorPoint (oldParms.ori.origin, &surface, &camera, newParms.ori.origin );
+
+	VectorSubtract( vec3_origin, camera.axis[0], newParms.portalPlane.normal );
+	newParms.portalPlane.dist = DotProduct( camera.origin, newParms.portalPlane.normal );
+	
+	R_MirrorVector (oldParms.ori.axis[0], &surface, &camera, newParms.ori.axis[0]);
+	R_MirrorVector (oldParms.ori.axis[1], &surface, &camera, newParms.ori.axis[1]);
+	R_MirrorVector (oldParms.ori.axis[2], &surface, &camera, newParms.ori.axis[2]);
+
+	// OPTIMIZE: restrict the viewport on the mirrored view
+
+	// render the mirror view
+	R_RenderView (&newParms);
+
+	tr.viewParms = oldParms;
+
+	return qtrue;
+}
+
+/*
+=================
+R_SpriteFogNum
+
+See if a sprite is inside a fog volume
+=================
+*/
+int R_SpriteFogNum( trRefEntity_t *ent ) {
+	int				i, j;
+	fog_t			*fog;
+
+	if ( tr.refdef.rdflags & RDF_NOWORLDMODEL ) {
+		return 0;
+	}
+
+	for ( i = 1 ; i < tr.world->numfogs ; i++ ) {
+		fog = &tr.world->fogs[i];
+		for ( j = 0 ; j < 3 ; j++ ) {
+			if ( ent->e.origin[j] - ent->e.radius >= fog->bounds[1][j] ) {
+				break;
+			}
+			if ( ent->e.origin[j] + ent->e.radius <= fog->bounds[0][j] ) {
+				break;
+			}
+		}
+		if ( j == 3 ) {
+			return i;
+		}
+	}
+
+	return 0;
+}
+
+/*
+==========================================================================================
+
+DRAWSURF SORTING
+
+==========================================================================================
+*/
+
+/*
+=================
+qsort replacement
+
+=================
+*/
+#define	SWAP_DRAW_SURF(a,b) temp=((int *)a)[0];((int *)a)[0]=((int *)b)[0];((int *)b)[0]=temp; temp=((int *)a)[1];((int *)a)[1]=((int *)b)[1];((int *)b)[1]=temp;
+
+/* this parameter defines the cutoff between using quick sort and
+   insertion sort for arrays; arrays with lengths shorter or equal to the
+   below value use insertion sort */
+
+#define CUTOFF 8            /* testing shows that this is good value */
+
+static void shortsort( drawSurf_t *lo, drawSurf_t *hi ) {
+    drawSurf_t	*p, *max;
+	int			temp;
+
+    while (hi > lo) {
+        max = lo;
+        for (p = lo + 1; p <= hi; p++ ) {
+            if ( p->sort > max->sort ) {
+                max = p;
+            }
+        }
+        SWAP_DRAW_SURF(max, hi);
+        hi--;
+    }
+}
+
+
+/* sort the array between lo and hi (inclusive)
+FIXME: this was lifted and modified from the microsoft lib source...
+ */
+
+void qsortFast (
+    void *base,
+    unsigned num,
+    unsigned width
+    )
+{
+    char *lo, *hi;              /* ends of sub-array currently sorting */
+    char *mid;                  /* points to middle of subarray */
+    char *loguy, *higuy;        /* traveling pointers for partition step */
+    unsigned size;              /* size of the sub-array */
+    char *lostk[30], *histk[30];
+    int stkptr;                 /* stack for saving sub-array to be processed */
+	int	temp;
+
+	if ( sizeof(drawSurf_t) != 8 ) {
+		Com_Error( ERR_DROP, "change SWAP_DRAW_SURF macro" );
+	}
+
+    /* Note: the number of stack entries required is no more than
+       1 + log2(size), so 30 is sufficient for any array */
+
+    if (num < 2 || width == 0)
+        return;                 /* nothing to do */
+
+    stkptr = 0;                 /* initialize stack */
+
+    lo = (char *)base;
+    hi = (char *)base + width * (num-1);        /* initialize limits */
+
+    /* this entry point is for pseudo-recursion calling: setting
+       lo and hi and jumping to here is like recursion, but stkptr is
+       prserved, locals aren't, so we preserve stuff on the stack */
+recurse:
+
+    size = (hi - lo) / width + 1;        /* number of el's to sort */
+
+    /* below a certain size, it is faster to use a O(n^2) sorting method */
+    if (size <= CUTOFF) {
+         shortsort((drawSurf_t *)lo, (drawSurf_t *)hi);
+    }
+    else {
+        /* First we pick a partititioning element.  The efficiency of the
+           algorithm demands that we find one that is approximately the
+           median of the values, but also that we select one fast.  Using
+           the first one produces bad performace if the array is already
+           sorted, so we use the middle one, which would require a very
+           wierdly arranged array for worst case performance.  Testing shows
+           that a median-of-three algorithm does not, in general, increase
+           performance. */
+
+        mid = lo + (size / 2) * width;      /* find middle element */
+        SWAP_DRAW_SURF(mid, lo);               /* swap it to beginning of array */
+
+        /* We now wish to partition the array into three pieces, one
+           consisiting of elements <= partition element, one of elements
+           equal to the parition element, and one of element >= to it.  This
+           is done below; comments indicate conditions established at every
+           step. */
+
+        loguy = lo;
+        higuy = hi + width;
+
+        /* Note that higuy decreases and loguy increases on every iteration,
+           so loop must terminate. */
+        for (;;) {
+            /* lo <= loguy < hi, lo < higuy <= hi + 1,
+               A[i] <= A[lo] for lo <= i <= loguy,
+               A[i] >= A[lo] for higuy <= i <= hi */
+
+            do  {
+                loguy += width;
+            } while (loguy <= hi &&  
+				( ((drawSurf_t *)loguy)->sort <= ((drawSurf_t *)lo)->sort ) );
+
+            /* lo < loguy <= hi+1, A[i] <= A[lo] for lo <= i < loguy,
+               either loguy > hi or A[loguy] > A[lo] */
+
+            do  {
+                higuy -= width;
+            } while (higuy > lo && 
+				( ((drawSurf_t *)higuy)->sort >= ((drawSurf_t *)lo)->sort ) );
+
+            /* lo-1 <= higuy <= hi, A[i] >= A[lo] for higuy < i <= hi,
+               either higuy <= lo or A[higuy] < A[lo] */
+
+            if (higuy < loguy)
+                break;
+
+            /* if loguy > hi or higuy <= lo, then we would have exited, so
+               A[loguy] > A[lo], A[higuy] < A[lo],
+               loguy < hi, highy > lo */
+
+            SWAP_DRAW_SURF(loguy, higuy);
+
+            /* A[loguy] < A[lo], A[higuy] > A[lo]; so condition at top
+               of loop is re-established */
+        }
+
+        /*     A[i] >= A[lo] for higuy < i <= hi,
+               A[i] <= A[lo] for lo <= i < loguy,
+               higuy < loguy, lo <= higuy <= hi
+           implying:
+               A[i] >= A[lo] for loguy <= i <= hi,
+               A[i] <= A[lo] for lo <= i <= higuy,
+               A[i] = A[lo] for higuy < i < loguy */
+
+        SWAP_DRAW_SURF(lo, higuy);     /* put partition element in place */
+
+        /* OK, now we have the following:
+              A[i] >= A[higuy] for loguy <= i <= hi,
+              A[i] <= A[higuy] for lo <= i < higuy
+              A[i] = A[lo] for higuy <= i < loguy    */
+
+        /* We've finished the partition, now we want to sort the subarrays
+           [lo, higuy-1] and [loguy, hi].
+           We do the smaller one first to minimize stack usage.
+           We only sort arrays of length 2 or more.*/
+
+        if ( higuy - 1 - lo >= hi - loguy ) {
+            if (lo + width < higuy) {
+                lostk[stkptr] = lo;
+                histk[stkptr] = higuy - width;
+                ++stkptr;
+            }                           /* save big recursion for later */
+
+            if (loguy < hi) {
+                lo = loguy;
+                goto recurse;           /* do small recursion */
+            }
+        }
+        else {
+            if (loguy < hi) {
+                lostk[stkptr] = loguy;
+                histk[stkptr] = hi;
+                ++stkptr;               /* save big recursion for later */
+            }
+
+            if (lo + width < higuy) {
+                hi = higuy - width;
+                goto recurse;           /* do small recursion */
+            }
+        }
+    }
+
+    /* We have sorted the array, except for any pending sorts on the stack.
+       Check if there are any, and do them. */
+
+    --stkptr;
+    if (stkptr >= 0) {
+        lo = lostk[stkptr];
+        hi = histk[stkptr];
+        goto recurse;           /* pop subarray from stack */
+    }
+    else
+        return;                 /* all subarrays done */
+}
+
+
+//==========================================================================================
+
+/*
+=================
+R_AddDrawSurf
+=================
+*/
+void R_AddDrawSurf( surfaceType_t *surface, shader_t *shader, 
+				   int fogIndex, int dlightMap ) {
+	int			index;
+
+	if (tr.refdef.rdflags & RDF_NOFOG)
+	{
+		fogIndex = 0;
+	}
+	else
+	{
+		fogIndex = fogIndex;
+	}
+
+	// instead of checking for overflow, we just mask the index
+	// so it wraps around
+	index = tr.refdef.numDrawSurfs & DRAWSURF_MASK;
+	// the sort data is packed into a single 32 bit value so it can be
+	// compared quickly during the qsorting process
+	tr.refdef.drawSurfs[index].sort = (shader->sortedIndex << QSORT_SHADERNUM_SHIFT) 
+		| tr.shiftedEntityNum | ( fogIndex << QSORT_FOGNUM_SHIFT ) | (int)dlightMap;
+	tr.refdef.drawSurfs[index].surface = surface;
+	tr.refdef.numDrawSurfs++;
+}
+
+/*
+=================
+R_DecomposeSort
+=================
+*/
+void R_DecomposeSort( unsigned sort, int *entityNum, shader_t **shader, 
+					 int *fogNum, int *dlightMap ) {
+	*fogNum = ( sort >> QSORT_FOGNUM_SHIFT ) & 31;
+	*shader = tr.sortedShaders[ ( sort >> QSORT_SHADERNUM_SHIFT ) & (MAX_SHADERS-1) ];
+	*entityNum = ( sort >> QSORT_ENTITYNUM_SHIFT ) & (MAX_ENTITIES-1);
+	*dlightMap = sort & 3;
+}
+
+/*
+=================
+R_SortDrawSurfs
+=================
+*/
+void R_SortDrawSurfs( drawSurf_t *drawSurfs, int numDrawSurfs ) {
+	shader_t		*shader;
+	int				fogNum;
+	int				entityNum;
+	int				dlighted;
+	int				i;
+
+	// it is possible for some views to not have any surfaces
+	if ( numDrawSurfs < 1 ) {
+		// we still need to add it for hyperspace cases
+		R_AddDrawSurfCmd( drawSurfs, numDrawSurfs );
+		return;
+	}
+
+	// if we overflowed MAX_DRAWSURFS, the drawsurfs
+	// wrapped around in the buffer and we will be missing
+	// the first surfaces, not the last ones
+	if ( numDrawSurfs > MAX_DRAWSURFS ) {
+		numDrawSurfs = MAX_DRAWSURFS;
+#if defined(_DEBUG) && defined(_XBOX)
+		Com_Printf(S_COLOR_RED"Draw surface overflow!  Tell Brian.\n");
+#endif
+	}
+
+#ifndef _XBOX
+	// sort the drawsurfs by sort type, then orientation, then shader
+	qsortFast (drawSurfs, numDrawSurfs, sizeof(drawSurf_t) );
+#endif
+
+	// check for any pass through drawing, which
+	// may cause another view to be rendered first
+	for ( i = 0 ; i < numDrawSurfs ; i++ ) {
+		R_DecomposeSort( (drawSurfs+i)->sort, &entityNum, &shader, &fogNum, &dlighted );
+
+		if ( shader->sort > SS_PORTAL ) {
+			break;
+		}
+
+		// no shader should ever have this sort type
+		if ( shader->sort == SS_BAD ) {
+			Com_Error (ERR_DROP, "Shader '%s'with sort == SS_BAD", shader->name );
+		}
+
+		// if the mirror was completely clipped away, we may need to check another surface
+		if ( R_MirrorViewBySurface( (drawSurfs+i), entityNum) ) {
+			// this is a debug option to see exactly what is being mirrored
+			if ( r_portalOnly->integer ) {
+				return;
+			}
+			break;		// only one mirror view at a time
+		}
+	}
+
+#ifdef _XBOX
+	qsortFast (drawSurfs, numDrawSurfs, sizeof(drawSurf_t) );
+#endif
+
+	R_AddDrawSurfCmd( drawSurfs, numDrawSurfs );
+}
+
+/*
+=============
+R_AddEntitySurfaces
+=============
+*/
+void R_AddEntitySurfaces (void) {
+	trRefEntity_t	*ent;
+	shader_t		*shader;
+
+	if ( !r_drawentities->integer ) {
+		return;
+	}
+
+	for ( tr.currentEntityNum = 0; 
+	      tr.currentEntityNum < tr.refdef.num_entities; 
+		  tr.currentEntityNum++ ) {
+		ent = tr.currentEntity = &tr.refdef.entities[tr.currentEntityNum];
+
+		assert(ent->e.renderfx >= 0);
+
+		ent->needDlights = qfalse;
+
+		// preshift the value we are going to OR into the drawsurf sort
+		tr.shiftedEntityNum = tr.currentEntityNum << QSORT_ENTITYNUM_SHIFT;
+
+		//
+		// the weapon model must be handled special --
+		// we don't want the hacked weapon position showing in 
+		// mirrors, because the true body position will already be drawn
+		//
+		if ( (ent->e.renderfx & RF_FIRST_PERSON) && tr.viewParms.isPortal) {
+			continue;
+		}
+
+		// simple generated models, like sprites and beams, are not culled
+		switch ( ent->e.reType ) {
+		case RT_PORTALSURFACE:
+			break;		// don't draw anything
+		case RT_SPRITE:
+		case RT_BEAM:
+		case RT_ORIENTED_QUAD:
+		case RT_ELECTRICITY:
+		case RT_LINE:
+		case RT_ORIENTEDLINE:
+		case RT_CYLINDER:
+		case RT_SABER_GLOW:
+			// self blood sprites, talk balloons, etc should not be drawn in the primary
+			// view.  We can't just do this check for all entities, because md3
+			// entities may still want to cast shadows from them
+			if ( (ent->e.renderfx & RF_THIRD_PERSON) && !tr.viewParms.isPortal) {
+				continue;
+			}
+			shader = R_GetShaderByHandle( ent->e.customShader );
+			R_AddDrawSurf( &entitySurface, shader, R_SpriteFogNum( ent ), 0 );
+			break;
+
+		case RT_MODEL:
+			// we must set up parts of tr.ori for model culling
+			R_RotateForEntity( ent, &tr.viewParms, &tr.ori );
+
+			tr.currentModel = R_GetModelByHandle( ent->e.hModel );
+			if (!tr.currentModel) {
+				R_AddDrawSurf( &entitySurface, tr.defaultShader, 0, 0 );
+			} else {
+				switch ( tr.currentModel->type ) {
+				case MOD_MESH:
+					R_AddMD3Surfaces( ent );
+					break;
+				case MOD_BRUSH:
+					R_AddBrushModelSurfaces( ent );
+					break;
+/*
+Ghoul2 Insert Start
+*/
+				case MOD_MDXM:
+  					//g2r
+					if (ent->e.ghoul2)
+					{
+						R_AddGhoulSurfaces( ent);
+					}
+  					break;
+				case MOD_BAD:		// null model axis
+					if ( (ent->e.renderfx & RF_THIRD_PERSON) && !tr.viewParms.isPortal)
+					{
+						if (!(ent->e.renderfx & RF_SHADOW_ONLY))
+						{
+							break;
+						}
+					}
+
+  					if (ent->e.ghoul2 && G2API_HaveWeGhoul2Models(*((CGhoul2Info_v *)ent->e.ghoul2)))
+  					{
+  						R_AddGhoulSurfaces( ent);
+  						break;
+  					}
+
+					R_AddDrawSurf( &entitySurface, tr.defaultShader, 0, false );
+					break;
+/*
+Ghoul2 Insert End
+*/
+				default:
+					Com_Error( ERR_DROP, "R_AddEntitySurfaces: Bad modeltype" );
+					break;
+				}
+			}
+			break;
+
+		case RT_ENT_CHAIN:
+			shader = R_GetShaderByHandle( ent->e.customShader );
+			R_AddDrawSurf( &entitySurface, shader, R_SpriteFogNum( ent ), false );
+			break;
+
+		default:
+			Com_Error( ERR_DROP, "R_AddEntitySurfaces: Bad reType" );
+		}
+	}
+
+}
+
+
+/*
+====================
+R_GenerateDrawSurfs
+====================
+*/
+#ifdef _XBOX
+extern void R_MarkLeaves(mleaf_s*);
+void R_GenerateDrawSurfs( bool isPortal ) {
+	// determine which leaves are in the PVS / areamask
+	if ( !(tr.refdef.rdflags & RDF_NOWORLDMODEL) ) {
+		R_MarkLeaves (NULL);
+	}
+
+	R_AddWorldSurfaces ();
+
+	R_AddPolygonSurfaces();
+
+	R_AddTerrainSurfaces();
+
+	// set the projection matrix with the minimum zfar
+	// now that we have the world bounded
+	// this needs to be done before entities are
+	// added, because they use the projection
+	// matrix for lod calculation
+	R_SetupProjection ();
+
+	R_AddEntitySurfaces ();
+}
+
+#else 
+
+void R_GenerateDrawSurfs( void ) {
+	R_AddWorldSurfaces ();
+
+	R_AddPolygonSurfaces();
+
+	R_AddTerrainSurfaces(); //rwwRMG - added
+
+	// set the projection matrix with the minimum zfar
+	// now that we have the world bounded
+	// this needs to be done before entities are
+	// added, because they use the projection
+	// matrix for lod calculation
+	R_SetupProjection ();
+
+	R_AddEntitySurfaces ();
+}
+
+#endif
+
+/*
+================
+R_DebugPolygon
+================
+*/
+void R_DebugPolygon( int color, int numPoints, float *points ) {
+	int		i;
+
+	GL_State( GLS_DEPTHMASK_TRUE | GLS_SRCBLEND_ONE | GLS_DSTBLEND_ONE );
+
+	// draw solid shade
+
+	qglColor3f( color&1, (color>>1)&1, (color>>2)&1 );
+	qglBegin( GL_POLYGON );
+	for ( i = 0 ; i < numPoints ; i++ ) {
+		qglVertex3fv( points + i * 3 );
+	}
+	qglEnd();
+
+	// draw wireframe outline
+	GL_State( GLS_POLYMODE_LINE | GLS_DEPTHMASK_TRUE | GLS_SRCBLEND_ONE | GLS_DSTBLEND_ONE );
+	qglDepthRange( 0, 0 );
+	qglColor3f( 1, 1, 1 );
+	qglBegin( GL_POLYGON );
+	for ( i = 0 ; i < numPoints ; i++ ) {
+		qglVertex3fv( points + i * 3 );
+	}
+	qglEnd();
+	qglDepthRange( 0, 1 );
+}
+
+/*
+====================
+R_DebugGraphics
+
+Visualization aid for movement clipping debugging
+====================
+*/
+void R_DebugGraphics( void ) {
+	if ( !r_debugSurface->integer ) {
+		return;
+	}
+
+	// the render thread can't make callbacks to the main thread
+	R_SyncRenderThread();
+
+	GL_Bind( tr.whiteImage);
+	GL_Cull( CT_FRONT_SIDED );
+	CM_DrawDebugSurface( R_DebugPolygon );
+}
+
+
+/*
+================
+R_RenderView
+
+A view may be either the actual camera view,
+or a mirror / remote location
+================
+*/
+void R_RenderView (viewParms_t *parms) {
+	int		firstDrawSurf;
+
+	if ( parms->viewportWidth <= 0 || parms->viewportHeight <= 0 ) {
+		return;
+	}
+
+	tr.viewCount++;
+
+	tr.viewParms = *parms;
+	tr.viewParms.frameSceneNum = tr.frameSceneNum;
+	tr.viewParms.frameCount = tr.frameCount;
+
+	firstDrawSurf = tr.refdef.numDrawSurfs;
+
+	tr.viewCount++;
+
+	// set viewParms.world
+	R_RotateForViewer ();
+
+	R_SetupFrustum ();
+
+#ifdef _XBOX
+	R_GenerateDrawSurfs(parms->isPortal);
+#else
+	R_GenerateDrawSurfs();
+#endif
+
+	R_SortDrawSurfs( tr.refdef.drawSurfs + firstDrawSurf, tr.refdef.numDrawSurfs - firstDrawSurf );
+
+	// draw main system development information (surface outlines, etc)
+	R_DebugGraphics();
+}
+
+
+#endif // !DEDICATED
+
diff --git a/codemp/renderer/tr_marks.cpp b/codemp/renderer/tr_marks.cpp
new file mode 100644
index 0000000..09d5e3e
--- /dev/null
+++ b/codemp/renderer/tr_marks.cpp
@@ -0,0 +1,449 @@
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+// tr_marks.c -- polygon projection on the world polygons
+
+#include "tr_local.h"
+//#include "assert.h"
+
+#define MAX_VERTS_ON_POLY		64
+
+#define MARKER_OFFSET			0	// 1
+
+/*
+=============
+R_ChopPolyBehindPlane
+
+Out must have space for two more vertexes than in
+=============
+*/
+#define	SIDE_FRONT	0
+#define	SIDE_BACK	1
+#define	SIDE_ON		2
+static void R_ChopPolyBehindPlane( int numInPoints, vec3_t inPoints[MAX_VERTS_ON_POLY],
+								   int *numOutPoints, vec3_t outPoints[MAX_VERTS_ON_POLY], 
+							vec3_t normal, vec_t dist, vec_t epsilon) {
+	float		dists[MAX_VERTS_ON_POLY+4];
+	int			sides[MAX_VERTS_ON_POLY+4];
+	int			counts[3];
+	float		dot;
+	int			i, j;
+	float		*p1, *p2, *clip;
+	float		d;
+
+	// don't clip if it might overflow
+	if ( numInPoints >= MAX_VERTS_ON_POLY - 2 ) {
+		*numOutPoints = 0;
+		return;
+	}
+
+	counts[0] = counts[1] = counts[2] = 0;
+
+	// determine sides for each point
+	for ( i = 0 ; i < numInPoints ; i++ ) {
+		dot = DotProduct( inPoints[i], normal );
+		dot -= dist;
+		dists[i] = dot;
+		if ( dot > epsilon ) {
+			sides[i] = SIDE_FRONT;
+		} else if ( dot < -epsilon ) {
+			sides[i] = SIDE_BACK;
+		} else {
+			sides[i] = SIDE_ON;
+		}
+		counts[sides[i]]++;
+	}
+	sides[i] = sides[0];
+	dists[i] = dists[0];
+
+	*numOutPoints = 0;
+
+	if ( !counts[0] ) {
+		return;
+	}
+	if ( !counts[1] ) {
+		*numOutPoints = numInPoints;
+		Com_Memcpy( outPoints, inPoints, numInPoints * sizeof(vec3_t) );
+		return;
+	}
+
+	for ( i = 0 ; i < numInPoints ; i++ ) {
+		p1 = inPoints[i];
+		clip = outPoints[ *numOutPoints ];
+		
+		if ( sides[i] == SIDE_ON ) {
+			VectorCopy( p1, clip );
+			(*numOutPoints)++;
+			continue;
+		}
+	
+		if ( sides[i] == SIDE_FRONT ) {
+			VectorCopy( p1, clip );
+			(*numOutPoints)++;
+			clip = outPoints[ *numOutPoints ];
+		}
+
+		if ( sides[i+1] == SIDE_ON || sides[i+1] == sides[i] ) {
+			continue;
+		}
+			
+		// generate a split point
+		p2 = inPoints[ (i+1) % numInPoints ];
+
+		d = dists[i] - dists[i+1];
+		if ( d == 0 ) {
+			dot = 0;
+		} else {
+			dot = dists[i] / d;
+		}
+
+		// clip xyz
+
+		for (j=0 ; j<3 ; j++) {
+			clip[j] = p1[j] + dot * ( p2[j] - p1[j] );
+		}
+
+		(*numOutPoints)++;
+	}
+}
+
+/*
+=================
+R_BoxSurfaces_r
+
+=================
+*/
+void R_BoxSurfaces_r(mnode_t *node, vec3_t mins, vec3_t maxs, surfaceType_t **list, int listsize, int *listlength, vec3_t dir) {
+
+	int			s, c;
+	msurface_t	*surf, **mark;
+
+	// do the tail recursion in a loop
+	while ( node->contents == -1 ) {
+#ifdef _XBOX
+		s = BoxOnPlaneSide( mins, maxs, tr.world->planes + node->planeNum );
+#else
+		s = BoxOnPlaneSide( mins, maxs, node->plane );
+#endif
+		if (s == 1) {
+			node = node->children[0];
+		} else if (s == 2) {
+			node = node->children[1];
+		} else {
+			R_BoxSurfaces_r(node->children[0], mins, maxs, list, listsize, listlength, dir);
+			node = node->children[1];
+		}
+	}
+
+	// add the individual surfaces
+#ifdef _XBOX
+	mleaf_s *leaf = (mleaf_s*)node;
+	mark = tr.world->marksurfaces + leaf->firstMarkSurfNum;
+	c = leaf->nummarksurfaces;
+#else
+	mark = node->firstmarksurface;
+	c = node->nummarksurfaces;
+#endif
+	while (c--) {
+		//
+		if (*listlength >= listsize) break;
+		//
+		surf = *mark;
+		// check if the surface has NOIMPACT or NOMARKS set
+		if ( ( surf->shader->surfaceFlags & ( SURF_NOIMPACT | SURF_NOMARKS ) )
+			|| ( surf->shader->contentFlags & CONTENTS_FOG ) ) {
+			surf->viewCount = tr.viewCount;
+		}
+		// extra check for surfaces to avoid list overflows
+		else if (*(surf->data) == SF_FACE) {
+			// the face plane should go through the box
+			s = BoxOnPlaneSide( mins, maxs, &(( srfSurfaceFace_t * ) surf->data)->plane );
+			if (s == 1 || s == 2) {
+				surf->viewCount = tr.viewCount;
+			} else if (DotProduct((( srfSurfaceFace_t * ) surf->data)->plane.normal, dir) > -0.5) {
+			// don't add faces that make sharp angles with the projection direction
+				surf->viewCount = tr.viewCount;
+			}
+		}
+		else if (*(surfaceType_t *) (surf->data) != SF_GRID) surf->viewCount = tr.viewCount;
+		// check the viewCount because the surface may have
+		// already been added if it spans multiple leafs
+		if (surf->viewCount != tr.viewCount) {
+			surf->viewCount = tr.viewCount;
+			list[*listlength] = (surfaceType_t *) surf->data;
+			(*listlength)++;
+		}
+		mark++;
+	}
+}
+
+/*
+=================
+R_AddMarkFragments
+
+=================
+*/
+void R_AddMarkFragments(int numClipPoints, vec3_t clipPoints[2][MAX_VERTS_ON_POLY],
+				   int numPlanes, vec3_t *normals, float *dists,
+				   int maxPoints, vec3_t pointBuffer,
+				   int maxFragments, markFragment_t *fragmentBuffer,
+				   int *returnedPoints, int *returnedFragments,
+				   vec3_t mins, vec3_t maxs) {
+	int pingPong, i;
+	markFragment_t	*mf;
+
+	// chop the surface by all the bounding planes of the to be projected polygon
+	pingPong = 0;
+
+	for ( i = 0 ; i < numPlanes ; i++ ) {
+
+		R_ChopPolyBehindPlane( numClipPoints, clipPoints[pingPong],
+						   &numClipPoints, clipPoints[!pingPong],
+							normals[i], dists[i], 0.5 );
+		pingPong ^= 1;
+		if ( numClipPoints == 0 ) {
+			break;
+		}
+	}
+	// completely clipped away?
+	if ( numClipPoints == 0 ) {
+		return;
+	}
+
+	// add this fragment to the returned list
+	if ( numClipPoints + (*returnedPoints) > maxPoints ) {
+		return;	// not enough space for this polygon
+	}
+	/*
+	// all the clip points should be within the bounding box
+	for ( i = 0 ; i < numClipPoints ; i++ ) {
+		int j;
+		for ( j = 0 ; j < 3 ; j++ ) {
+			if (clipPoints[pingPong][i][j] < mins[j] - 0.5) break;
+			if (clipPoints[pingPong][i][j] > maxs[j] + 0.5) break;
+		}
+		if (j < 3) break;
+	}
+	if (i < numClipPoints) return;
+	*/
+
+	mf = fragmentBuffer + (*returnedFragments);
+	mf->firstPoint = (*returnedPoints);
+	mf->numPoints = numClipPoints;
+	Com_Memcpy( pointBuffer + (*returnedPoints) * 3, clipPoints[pingPong], numClipPoints * sizeof(vec3_t) );
+
+	(*returnedPoints) += numClipPoints;
+	(*returnedFragments)++;
+}
+
+/*
+=================
+R_MarkFragments
+
+=================
+*/
+int R_MarkFragments( int numPoints, const vec3_t *points, const vec3_t projection,
+				   int maxPoints, vec3_t pointBuffer, int maxFragments, markFragment_t *fragmentBuffer ) {
+	int				numsurfaces, numPlanes;
+	int				i, j, k, m, n;
+	surfaceType_t	*surfaces[64];
+	vec3_t			mins, maxs;
+	int				returnedFragments;
+	int				returnedPoints;
+	vec3_t			normals[MAX_VERTS_ON_POLY+2];
+	float			dists[MAX_VERTS_ON_POLY+2];
+	vec3_t			clipPoints[2][MAX_VERTS_ON_POLY];
+	int				numClipPoints;
+	float			*v;
+	srfSurfaceFace_t *surf;
+	srfGridMesh_t	*cv;
+	drawVert_t		*dv;
+	vec3_t			normal;
+	vec3_t			projectionDir;
+	vec3_t			v1, v2;
+	int				*indexes;
+
+	//increment view count for double check prevention
+	tr.viewCount++;
+
+	//
+	VectorNormalize2( projection, projectionDir );
+	// find all the brushes that are to be considered
+	ClearBounds( mins, maxs );
+	for ( i = 0 ; i < numPoints ; i++ ) {
+		vec3_t	temp;
+
+		AddPointToBounds( points[i], mins, maxs );
+		VectorAdd( points[i], projection, temp );
+		AddPointToBounds( temp, mins, maxs );
+		// make sure we get all the leafs (also the one(s) in front of the hit surface)
+		VectorMA( points[i], -20, projectionDir, temp );
+		AddPointToBounds( temp, mins, maxs );
+	}
+
+	if (numPoints > MAX_VERTS_ON_POLY) numPoints = MAX_VERTS_ON_POLY;
+	// create the bounding planes for the to be projected polygon
+	for ( i = 0 ; i < numPoints ; i++ ) {
+		VectorSubtract(points[(i+1)%numPoints], points[i], v1);
+		VectorAdd(points[i], projection, v2);
+		VectorSubtract(points[i], v2, v2);
+		CrossProduct(v1, v2, normals[i]);
+		VectorNormalizeFast(normals[i]);
+		dists[i] = DotProduct(normals[i], points[i]);
+	}
+	// add near and far clipping planes for projection
+	VectorCopy(projectionDir, normals[numPoints]);
+	dists[numPoints] = DotProduct(normals[numPoints], points[0]) - 32;
+	VectorCopy(projectionDir, normals[numPoints+1]);
+	VectorInverse(normals[numPoints+1]);
+	dists[numPoints+1] = DotProduct(normals[numPoints+1], points[0]) - 20;
+	numPlanes = numPoints + 2;
+
+	numsurfaces = 0;
+	R_BoxSurfaces_r(tr.world->nodes, mins, maxs, surfaces, 64, &numsurfaces, projectionDir);
+	//assert(numsurfaces <= 64);
+	//assert(numsurfaces != 64);
+
+	returnedPoints = 0;
+	returnedFragments = 0;
+
+	for ( i = 0 ; i < numsurfaces ; i++ ) {
+
+		if (*surfaces[i] == SF_GRID) {
+
+			cv = (srfGridMesh_t *) surfaces[i];
+			for ( m = 0 ; m < cv->height - 1 ; m++ ) {
+				for ( n = 0 ; n < cv->width - 1 ; n++ ) {
+					// We triangulate the grid and chop all triangles within
+					// the bounding planes of the to be projected polygon.
+					// LOD is not taken into account, not such a big deal though.
+					//
+					// It's probably much nicer to chop the grid itself and deal
+					// with this grid as a normal SF_GRID surface so LOD will
+					// be applied. However the LOD of that chopped grid must
+					// be synced with the LOD of the original curve.
+					// One way to do this; the chopped grid shares vertices with
+					// the original curve. When LOD is applied to the original
+					// curve the unused vertices are flagged. Now the chopped curve
+					// should skip the flagged vertices. This still leaves the
+					// problems with the vertices at the chopped grid edges.
+					//
+					// To avoid issues when LOD applied to "hollow curves" (like
+					// the ones around many jump pads) we now just add a 2 unit
+					// offset to the triangle vertices.
+					// The offset is added in the vertex normal vector direction
+					// so all triangles will still fit together.
+					// The 2 unit offset should avoid pretty much all LOD problems.
+
+					numClipPoints = 3;
+
+					dv = cv->verts + m * cv->width + n;
+
+					VectorCopy(dv[0].xyz, clipPoints[0][0]);
+					VectorMA(clipPoints[0][0], MARKER_OFFSET, dv[0].normal, clipPoints[0][0]);
+					VectorCopy(dv[cv->width].xyz, clipPoints[0][1]);
+					VectorMA(clipPoints[0][1], MARKER_OFFSET, dv[cv->width].normal, clipPoints[0][1]);
+					VectorCopy(dv[1].xyz, clipPoints[0][2]);
+					VectorMA(clipPoints[0][2], MARKER_OFFSET, dv[1].normal, clipPoints[0][2]);
+					// check the normal of this triangle
+					VectorSubtract(clipPoints[0][0], clipPoints[0][1], v1);
+					VectorSubtract(clipPoints[0][2], clipPoints[0][1], v2);
+					CrossProduct(v1, v2, normal);
+					VectorNormalizeFast(normal);
+					if (DotProduct(normal, projectionDir) < -0.1) {
+						// add the fragments of this triangle
+						R_AddMarkFragments(numClipPoints, clipPoints,
+										   numPlanes, normals, dists,
+										   maxPoints, pointBuffer,
+										   maxFragments, fragmentBuffer,
+										   &returnedPoints, &returnedFragments, mins, maxs);
+
+						if ( returnedFragments == maxFragments ) {
+							return returnedFragments;	// not enough space for more fragments
+						}
+					}
+
+					VectorCopy(dv[1].xyz, clipPoints[0][0]);
+					VectorMA(clipPoints[0][0], MARKER_OFFSET, dv[1].normal, clipPoints[0][0]);
+					VectorCopy(dv[cv->width].xyz, clipPoints[0][1]);
+					VectorMA(clipPoints[0][1], MARKER_OFFSET, dv[cv->width].normal, clipPoints[0][1]);
+					VectorCopy(dv[cv->width+1].xyz, clipPoints[0][2]);
+					VectorMA(clipPoints[0][2], MARKER_OFFSET, dv[cv->width+1].normal, clipPoints[0][2]);
+					// check the normal of this triangle
+					VectorSubtract(clipPoints[0][0], clipPoints[0][1], v1);
+					VectorSubtract(clipPoints[0][2], clipPoints[0][1], v2);
+					CrossProduct(v1, v2, normal);
+					VectorNormalizeFast(normal);
+					if (DotProduct(normal, projectionDir) < -0.05) {
+						// add the fragments of this triangle
+						R_AddMarkFragments(numClipPoints, clipPoints,
+										   numPlanes, normals, dists,
+										   maxPoints, pointBuffer,
+										   maxFragments, fragmentBuffer,
+										   &returnedPoints, &returnedFragments, mins, maxs);
+
+						if ( returnedFragments == maxFragments ) {
+							return returnedFragments;	// not enough space for more fragments
+						}
+					}
+				}
+			}
+		}
+		else if (*surfaces[i] == SF_FACE) {
+
+			surf = ( srfSurfaceFace_t * ) surfaces[i];
+			// check the normal of this face
+			if (DotProduct(surf->plane.normal, projectionDir) > -0.5) {
+				continue;
+			}
+
+			/*
+			VectorSubtract(clipPoints[0][0], clipPoints[0][1], v1);
+			VectorSubtract(clipPoints[0][2], clipPoints[0][1], v2);
+			CrossProduct(v1, v2, normal);
+			VectorNormalize(normal);
+			if (DotProduct(normal, projectionDir) > -0.5) continue;
+			*/
+#ifdef _XBOX
+			const unsigned char * const indexes = (unsigned char *)( (byte *)surf + surf->ofsIndices );
+			int nextSurfPoint = NEXT_SURFPOINT(surf->flags);
+#else
+			indexes = (int *)( (byte *)surf + surf->ofsIndices );
+#endif
+			for ( k = 0 ; k < surf->numIndices ; k += 3 ) {
+				for ( j = 0 ; j < 3 ; j++ ) {
+#ifdef _XBOX
+					const unsigned short* v = surf->srfPoints + nextSurfPoint * indexes[k+j];
+					float fVec[3];
+					Q_CastShort2Float(&fVec[0], (short*)v + 0);
+					Q_CastShort2Float(&fVec[1], (short*)v + 1);
+					Q_CastShort2Float(&fVec[2], (short*)v + 2);
+					VectorMA( fVec, MARKER_OFFSET, surf->plane.normal, clipPoints[0][j] );
+#else
+					v = surf->points[0] + VERTEXSIZE * indexes[k+j];;
+					VectorMA( v, MARKER_OFFSET, surf->plane.normal, clipPoints[0][j] );
+#endif
+				}
+				// add the fragments of this face
+				R_AddMarkFragments( 3 , clipPoints,
+								   numPlanes, normals, dists,
+								   maxPoints, pointBuffer,
+								   maxFragments, fragmentBuffer,
+								   &returnedPoints, &returnedFragments, mins, maxs);
+				if ( returnedFragments == maxFragments ) {
+					return returnedFragments;	// not enough space for more fragments
+				}
+			}
+			continue;
+		}
+		else {
+			// ignore all other world surfaces
+			// might be cool to also project polygons on a triangle soup
+			// however this will probably create huge amounts of extra polys
+			// even more than the projection onto curves
+			continue;
+		}
+	}
+	return returnedFragments;
+}
+
diff --git a/codemp/renderer/tr_mesh.cpp b/codemp/renderer/tr_mesh.cpp
new file mode 100644
index 0000000..6094588
--- /dev/null
+++ b/codemp/renderer/tr_mesh.cpp
@@ -0,0 +1,423 @@
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+// tr_mesh.c: triangle model functions
+
+#include "tr_local.h"
+
+#ifdef VV_LIGHTING
+#include "tr_lightmanager.h"
+#endif
+
+float ProjectRadius( float r, vec3_t location )
+{
+	float pr;
+	float dist;
+	float c;
+	vec3_t	p;
+	float width;
+	float depth;
+
+	c = DotProduct( tr.viewParms.ori.axis[0], tr.viewParms.ori.origin );
+	dist = DotProduct( tr.viewParms.ori.axis[0], location ) - c;
+
+	if ( dist <= 0 )
+		return 0;
+
+	p[0] = 0;
+	p[1] = Q_fabs( r );
+	p[2] = -dist;
+
+	width = p[0] * tr.viewParms.projectionMatrix[1] + 
+		           p[1] * tr.viewParms.projectionMatrix[5] +
+				   p[2] * tr.viewParms.projectionMatrix[9] +
+				   tr.viewParms.projectionMatrix[13];
+
+	depth = p[0] * tr.viewParms.projectionMatrix[3] + 
+		           p[1] * tr.viewParms.projectionMatrix[7] +
+				   p[2] * tr.viewParms.projectionMatrix[11] +
+				   tr.viewParms.projectionMatrix[15];
+
+	pr = width / depth;
+#if defined (_XBOX)
+	pr = -pr;
+#endif
+
+	if ( pr > 1.0f )
+		pr = 1.0f;
+
+	return pr;
+}
+
+#ifndef DEDICATED
+/*
+=============
+R_CullModel
+=============
+*/
+static int R_CullModel( md3Header_t *header, trRefEntity_t *ent ) {
+	vec3_t		bounds[2];
+	md3Frame_t	*oldFrame, *newFrame;
+	int			i;
+
+	// compute frame pointers
+	newFrame = ( md3Frame_t * ) ( ( byte * ) header + header->ofsFrames ) + ent->e.frame;
+	oldFrame = ( md3Frame_t * ) ( ( byte * ) header + header->ofsFrames ) + ent->e.oldframe;
+
+	// cull bounding sphere ONLY if this is not an upscaled entity
+	if ( !ent->e.nonNormalizedAxes )
+	{
+		if ( ent->e.frame == ent->e.oldframe )
+		{
+			switch ( R_CullLocalPointAndRadius( newFrame->localOrigin, newFrame->radius ) )
+			{
+			case CULL_OUT:
+				tr.pc.c_sphere_cull_md3_out++;
+				return CULL_OUT;
+
+			case CULL_IN:
+				tr.pc.c_sphere_cull_md3_in++;
+				return CULL_IN;
+
+			case CULL_CLIP:
+				tr.pc.c_sphere_cull_md3_clip++;
+				break;
+			}
+		}
+		else
+		{
+			int sphereCull, sphereCullB;
+
+			sphereCull  = R_CullLocalPointAndRadius( newFrame->localOrigin, newFrame->radius );
+			if ( newFrame == oldFrame ) {
+				sphereCullB = sphereCull;
+			} else {
+				sphereCullB = R_CullLocalPointAndRadius( oldFrame->localOrigin, oldFrame->radius );
+			}
+
+			if ( sphereCull == sphereCullB )
+			{
+				if ( sphereCull == CULL_OUT )
+				{
+					tr.pc.c_sphere_cull_md3_out++;
+					return CULL_OUT;
+				}
+				else if ( sphereCull == CULL_IN )
+				{
+					tr.pc.c_sphere_cull_md3_in++;
+					return CULL_IN;
+				}
+				else
+				{
+					tr.pc.c_sphere_cull_md3_clip++;
+				}
+			}
+		}
+	}
+	
+	// calculate a bounding box in the current coordinate system
+	for (i = 0 ; i < 3 ; i++) {
+		bounds[0][i] = oldFrame->bounds[0][i] < newFrame->bounds[0][i] ? oldFrame->bounds[0][i] : newFrame->bounds[0][i];
+		bounds[1][i] = oldFrame->bounds[1][i] > newFrame->bounds[1][i] ? oldFrame->bounds[1][i] : newFrame->bounds[1][i];
+	}
+
+	switch ( R_CullLocalBox( bounds ) )
+	{
+	case CULL_IN:
+		tr.pc.c_box_cull_md3_in++;
+		return CULL_IN;
+	case CULL_CLIP:
+		tr.pc.c_box_cull_md3_clip++;
+		return CULL_CLIP;
+	case CULL_OUT:
+	default:
+		tr.pc.c_box_cull_md3_out++;
+		return CULL_OUT;
+	}
+}
+
+/*
+=================
+RE_GetModelBounds
+
+  Returns the bounds of the current model
+  (qhandle_t)hModel and (int)frame need to be set
+=================
+*/
+//rwwRMG - added
+void RE_GetModelBounds(refEntity_t *refEnt, vec3_t bounds1, vec3_t bounds2)
+{
+	md3Frame_t		*frame;
+	md3Header_t		*header;
+	model_t			*model;
+
+	assert(refEnt);
+
+	model = R_GetModelByHandle( refEnt->hModel );
+	assert(model);
+	header = model->md3[0];
+	assert(header);
+	frame = ( md3Frame_t * ) ( ( byte * ) header + header->ofsFrames ) + refEnt->frame;
+	assert(frame);
+
+	VectorCopy(frame->bounds[0], bounds1);
+	VectorCopy(frame->bounds[1], bounds2);
+}
+
+/*
+=================
+R_ComputeLOD
+
+=================
+*/
+int R_ComputeLOD( trRefEntity_t *ent ) {
+	float radius;
+	float flod, lodscale;
+	float projectedRadius;
+	md3Frame_t *frame;
+	int lod;
+
+	if ( tr.currentModel->numLods < 2 )
+	{
+		// model has only 1 LOD level, skip computations and bias
+		lod = 0;
+	}
+	else
+	{
+		// multiple LODs exist, so compute projected bounding sphere
+		// and use that as a criteria for selecting LOD
+
+		frame = ( md3Frame_t * ) ( ( ( unsigned char * ) tr.currentModel->md3[0] ) + tr.currentModel->md3[0]->ofsFrames );
+
+		frame += ent->e.frame;
+
+		radius = RadiusFromBounds( frame->bounds[0], frame->bounds[1] );
+
+		if ( ( projectedRadius = ProjectRadius( radius, ent->e.origin ) ) != 0 )
+		{
+			lodscale = (r_lodscale->value+r_autolodscalevalue->value);
+			if ( lodscale > 20 )
+			{
+				lodscale = 20;
+			}
+			else if ( lodscale < 0 )
+			{
+				lodscale = 0;
+			}
+			flod = 1.0f - projectedRadius * lodscale;
+		}
+		else
+		{
+			// object intersects near view plane, e.g. view weapon
+			flod = 0;
+		}
+
+		flod *= tr.currentModel->numLods;
+		lod = myftol( flod );
+
+		if ( lod < 0 )
+		{
+			lod = 0;
+		}
+		else if ( lod >= tr.currentModel->numLods )
+		{
+			lod = tr.currentModel->numLods - 1;
+		}
+	}
+
+	lod += r_lodbias->integer;
+	
+	if ( lod >= tr.currentModel->numLods )
+		lod = tr.currentModel->numLods - 1;
+	if ( lod < 0 )
+		lod = 0;
+
+	return lod;
+}
+
+/*
+=================
+R_ComputeFogNum
+
+=================
+*/
+int R_ComputeFogNum( md3Header_t *header, trRefEntity_t *ent ) {
+	int				i, j;
+	fog_t			*fog;
+	md3Frame_t		*md3Frame;
+	vec3_t			localOrigin;
+
+	if ( tr.refdef.rdflags & RDF_NOWORLDMODEL ) {
+		return 0;
+	}
+
+	// FIXME: non-normalized axis issues
+	md3Frame = ( md3Frame_t * ) ( ( byte * ) header + header->ofsFrames ) + ent->e.frame;
+	VectorAdd( ent->e.origin, md3Frame->localOrigin, localOrigin );
+	for ( i = 1 ; i < tr.world->numfogs ; i++ ) {
+		fog = &tr.world->fogs[i];
+		for ( j = 0 ; j < 3 ; j++ ) {
+			if ( localOrigin[j] - md3Frame->radius >= fog->bounds[1][j] ) {
+				break;
+			}
+			if ( localOrigin[j] + md3Frame->radius <= fog->bounds[0][j] ) {
+				break;
+			}
+		}
+		if ( j == 3 ) {
+			return i;
+		}
+	}
+
+	return 0;
+}
+
+/*
+=================
+R_AddMD3Surfaces
+
+=================
+*/
+void R_AddMD3Surfaces( trRefEntity_t *ent ) {
+	int				i;
+	md3Header_t		*header = 0;
+	md3Surface_t	*surface = 0;
+	md3Shader_t		*md3Shader = 0;
+	shader_t		*shader = 0;
+	int				cull;
+	int				lod;
+	int				fogNum;
+	qboolean		personalModel;
+
+	// don't add third_person objects if not in a portal
+	personalModel = (qboolean)((ent->e.renderfx & RF_THIRD_PERSON) && !tr.viewParms.isPortal);
+
+	if ( ent->e.renderfx & RF_WRAP_FRAMES ) {
+		ent->e.frame %= tr.currentModel->md3[0]->numFrames;
+		ent->e.oldframe %= tr.currentModel->md3[0]->numFrames;
+	}
+
+	//
+	// Validate the frames so there is no chance of a crash.
+	// This will write directly into the entity structure, so
+	// when the surfaces are rendered, they don't need to be
+	// range checked again.
+	//
+	if ( (ent->e.frame >= tr.currentModel->md3[0]->numFrames) 
+		|| (ent->e.frame < 0)
+		|| (ent->e.oldframe >= tr.currentModel->md3[0]->numFrames)
+		|| (ent->e.oldframe < 0) ) {
+			Com_DPrintf (S_COLOR_RED "R_AddMD3Surfaces: no such frame %d to %d for '%s'\n",
+				ent->e.oldframe, ent->e.frame,
+				tr.currentModel->name );
+			ent->e.frame = 0;
+			ent->e.oldframe = 0;
+	}
+
+	//
+	// compute LOD
+	//
+	lod = R_ComputeLOD( ent );
+
+	header = tr.currentModel->md3[lod];
+
+	//
+	// cull the entire model if merged bounding box of both frames
+	// is outside the view frustum.
+	//
+	cull = R_CullModel ( header, ent );
+	if ( cull == CULL_OUT ) {
+		return;
+	}
+
+	//
+	// set up lighting now that we know we aren't culled
+	//
+#ifdef VV_LIGHTING
+	if ( !personalModel ) {
+		VVLightMan.R_SetupEntityLighting( &tr.refdef, ent );
+#else
+	if ( !personalModel || r_shadows->integer > 1 ) {
+		R_SetupEntityLighting( &tr.refdef, ent );
+#endif
+	}
+
+	//
+	// see if we are in a fog volume
+	//
+	fogNum = R_ComputeFogNum( header, ent );
+
+	//
+	// draw all surfaces
+	//
+	surface = (md3Surface_t *)( (byte *)header + header->ofsSurfaces );
+	for ( i = 0 ; i < header->numSurfaces ; i++ ) {
+
+		if ( ent->e.customShader ) {
+			shader = R_GetShaderByHandle( ent->e.customShader );
+		} else if ( ent->e.customSkin > 0 && ent->e.customSkin < tr.numSkins ) {
+			skin_t *skin;
+			int		j;
+
+			skin = R_GetSkinByHandle( ent->e.customSkin );
+
+			// match the surface name to something in the skin file
+			shader = tr.defaultShader;
+			for ( j = 0 ; j < skin->numSurfaces ; j++ ) {
+				// the names have both been lowercased
+				if ( !strcmp( skin->surfaces[j]->name, surface->name ) ) {
+					shader = skin->surfaces[j]->shader;
+					break;
+				}
+			}
+			if (shader == tr.defaultShader) {
+				Com_DPrintf (S_COLOR_RED "WARNING: no shader for surface %s in skin %s\n", surface->name, skin->name);
+			}
+			else if (shader->defaultShader) {
+				Com_DPrintf (S_COLOR_RED "WARNING: shader %s in skin %s not found\n", shader->name, skin->name);
+			}
+		} else if ( surface->numShaders <= 0 ) {
+			shader = tr.defaultShader;
+		} else {
+			md3Shader = (md3Shader_t *) ( (byte *)surface + surface->ofsShaders );
+			md3Shader += ent->e.skinNum % surface->numShaders;
+			shader = tr.shaders[ md3Shader->shaderIndex ];
+		}
+
+
+		// we will add shadows even if the main object isn't visible in the view
+
+		// stencil shadows can't do personal models unless I polyhedron clip
+		if ( !personalModel
+			&& r_shadows->integer == 2 
+			&& fogNum == 0
+			&& !(ent->e.renderfx & ( RF_NOSHADOW | RF_DEPTHHACK ) ) 
+			&& shader->sort == SS_OPAQUE ) {
+			R_AddDrawSurf( (surfaceType_t *)surface, tr.shadowShader, 0, qfalse );
+		}
+
+		// projection shadows work fine with personal models
+		if ( r_shadows->integer == 3
+			&& fogNum == 0
+			&& (ent->e.renderfx & RF_SHADOW_PLANE )
+			&& shader->sort == SS_OPAQUE ) {
+			R_AddDrawSurf( (surfaceType_t *)surface, tr.projectionShadowShader, 0, qfalse );
+		}
+
+		// don't add third_person objects if not viewing through a portal
+		if ( !personalModel ) {
+#ifdef VV_LIGHTING
+			int dlightBits = ( ent->dlightBits != 0 );
+			R_AddDrawSurf( (surfaceType_t *)surface, shader, fogNum, dlightBits );
+#else
+			R_AddDrawSurf( (surfaceType_t *)surface, shader, fogNum, qfalse );
+#endif
+		}
+
+		surface = (md3Surface_t *)( (byte *)surface + surface->ofsEnd );
+	}
+
+}
+
+#endif // !DEDICATED
+
diff --git a/codemp/renderer/tr_model.cpp b/codemp/renderer/tr_model.cpp
new file mode 100644
index 0000000..2a0f2f3
--- /dev/null
+++ b/codemp/renderer/tr_model.cpp
@@ -0,0 +1,1838 @@
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+// tr_models.c -- model loading and caching
+
+#include "tr_local.h"
+
+
+#include "../qcommon/disablewarnings.h"
+
+#pragma warning (push, 3)	//go back down to 3 for the stl include
+#include "../qcommon/sstring.h"	// #include <string>
+#include <vector>
+#include <map>
+#pragma warning (pop)
+
+using namespace std;
+
+
+#define	LL(x) x=LittleLong(x)
+
+static qboolean R_LoadMD3 (model_t *mod, int lod, void *buffer, const char *name, qboolean &bAlreadyCached );
+/*
+Ghoul2 Insert Start
+*/
+
+typedef	struct modelHash_s
+{
+	char		name[MAX_QPATH];
+	qhandle_t	handle;
+	struct		modelHash_s	*next;
+
+}modelHash_t;
+
+#define FILE_HASH_SIZE		1024
+static	modelHash_t 		*mhHashTable[FILE_HASH_SIZE];
+
+/*
+Ghoul2 Insert End
+*/
+
+
+// This stuff looks a bit messy, but it's kept here as black box, and nothing appears in any .H files for other 
+//	modules to worry about. I may make another module for this sometime.
+//
+typedef pair<int,int> StringOffsetAndShaderIndexDest_t;
+typedef vector <StringOffsetAndShaderIndexDest_t> ShaderRegisterData_t;
+struct CachedEndianedModelBinary_s
+{
+	void	*pModelDiskImage;
+	int		iAllocSize;		// may be useful for mem-query, but I don't actually need it
+	ShaderRegisterData_t ShaderRegisterData;	
+	int		iLastLevelUsedOn;
+	int		iPAKFileCheckSum;	// else -1 if not from PAK
+
+
+	CachedEndianedModelBinary_s()
+	{
+		pModelDiskImage		= 0;
+		iAllocSize			= 0;
+		ShaderRegisterData.clear();
+		iLastLevelUsedOn	= -1;
+		iPAKFileCheckSum	= -1;
+	}
+};
+typedef struct CachedEndianedModelBinary_s CachedEndianedModelBinary_t;
+typedef map <sstring_t,CachedEndianedModelBinary_t>	CachedModels_t;
+CachedModels_t *CachedModels = NULL;	// the important cache item.
+
+void RE_RegisterModels_StoreShaderRequest(const char *psModelFileName, const char *psShaderName, int *piShaderIndexPoke)
+{
+	char sModelName[MAX_QPATH];
+	
+	assert(CachedModels);
+
+	Q_strncpyz(sModelName,psModelFileName,sizeof(sModelName));
+	Q_strlwr  (sModelName);
+
+	CachedEndianedModelBinary_t &ModelBin = (*CachedModels)[sModelName];
+
+	if (ModelBin.pModelDiskImage == NULL)
+	{	
+		assert(0);	// should never happen, means that we're being called on a model that wasn't loaded
+	}
+	else
+	{
+		int iNameOffset =		  psShaderName		- (char *)ModelBin.pModelDiskImage;
+		int iPokeOffset = (char*) piShaderIndexPoke	- (char *)ModelBin.pModelDiskImage;
+
+		ModelBin.ShaderRegisterData.push_back( StringOffsetAndShaderIndexDest_t( iNameOffset,iPokeOffset) );
+	}
+}
+
+
+static const byte FakeGLAFile[] = 
+{
+0x32, 0x4C, 0x47, 0x41, 0x06, 0x00, 0x00, 0x00, 0x2A, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6C, 0x74,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x3F, 0x01, 0x00, 0x00, 0x00,
+0x14, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x18, 0x01, 0x00, 0x00, 0x68, 0x00, 0x00, 0x00,
+0x26, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x4D, 0x6F, 0x64, 0x56, 0x69, 0x65, 0x77, 0x20,
+0x69, 0x6E, 0x74, 0x65, 0x72, 0x6E, 0x61, 0x6C, 0x20, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6C, 0x74,
+0x00, 0xCD, 0xCD, 0xCD, 0xCD, 0xCD, 0xCD, 0xCD, 0xCD, 0xCD, 0xCD, 0xCD, 0xCD, 0xCD, 0xCD, 0xCD,
+0xCD, 0xCD, 0xCD, 0xCD, 0xCD, 0xCD, 0xCD, 0xCD, 0xCD, 0xCD, 0xCD, 0xCD, 0xCD, 0xCD, 0xCD, 0xCD,
+0xCD, 0xCD, 0xCD, 0xCD, 0xCD, 0xCD, 0xCD, 0xCD, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF,
+0x00, 0x00, 0x80, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x3F, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x80, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x3F, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFD, 0xBF, 0xFE, 0x7F, 0xFE, 0x7F, 0xFE, 0x7F,
+0x00, 0x80, 0x00, 0x80, 0x00, 0x80
+};
+
+void RE_LoadWorldMap_Actual( const char *name, world_t &worldData, int index );
+
+// returns qtrue if loaded, and sets the supplied qbool to true if it was from cache (instead of disk)
+//   (which we need to know to avoid LittleLong()ing everything again (well, the Mac needs to know anyway)...
+//
+// don't use ri.xxx functions in case running on dedicated...
+//
+qboolean RE_RegisterModels_GetDiskFile( const char *psModelFileName, void **ppvBuffer, qboolean *pqbAlreadyCached)
+{
+	char sModelName[MAX_QPATH];
+	
+	assert(CachedModels);
+
+	Q_strncpyz(sModelName,psModelFileName,sizeof(sModelName));
+	Q_strlwr  (sModelName);
+
+	CachedEndianedModelBinary_t &ModelBin = (*CachedModels)[sModelName];
+
+	if (ModelBin.pModelDiskImage == NULL)
+	{
+		// didn't have it cached, so try the disk...
+		//
+
+			// special case intercept first...
+			//
+			if (!strcmp(sDEFAULT_GLA_NAME ".gla" , psModelFileName))
+			{
+				// return fake params as though it was found on disk...
+				//
+				void *pvFakeGLAFile = Z_Malloc( sizeof(FakeGLAFile), TAG_FILESYS, qfalse );
+				memcpy(pvFakeGLAFile, &FakeGLAFile[0],  sizeof(FakeGLAFile));
+				*ppvBuffer = pvFakeGLAFile;
+				*pqbAlreadyCached = qfalse;	// faking it like this should mean that it works fine on the Mac as well
+				return qtrue;	
+			}
+
+		FS_ReadFile( sModelName, ppvBuffer );
+		*pqbAlreadyCached = qfalse;
+		qboolean bSuccess = !!(*ppvBuffer)?qtrue:qfalse;
+
+		if (bSuccess)
+		{				
+			Com_DPrintf( "RE_RegisterModels_GetDiskFile(): Disk-loading \"%s\"\n",psModelFileName);
+		}
+
+		return bSuccess;
+	}
+	else
+	{
+		*ppvBuffer = ModelBin.pModelDiskImage;
+		*pqbAlreadyCached = qtrue;
+		return qtrue;
+	}
+}
+
+
+// if return == true, no further action needed by the caller...
+//
+// don't use ri.xxx functions in case running on dedicated
+//
+extern cvar_t *sv_pure;
+void *RE_RegisterModels_Malloc(int iSize, void *pvDiskBufferIfJustLoaded, const char *psModelFileName, qboolean *pqbAlreadyFound, memtag_t eTag)
+{
+	char sModelName[MAX_QPATH];
+
+	assert(CachedModels);
+
+	Q_strncpyz(sModelName,psModelFileName,sizeof(sModelName));
+	Q_strlwr  (sModelName);
+
+	CachedEndianedModelBinary_t &ModelBin = (*CachedModels)[sModelName];
+
+	if (ModelBin.pModelDiskImage == NULL)
+	{
+		// ... then this entry has only just been created, ie we need to load it fully...
+		//
+		// new, instead of doing a Z_Malloc and assigning that we just morph the disk buffer alloc
+		//	then don't thrown it away on return - cuts down on mem overhead
+		//
+		// ... groan, but not if doing a limb hierarchy creation (some VV stuff?), in which case it's NULL
+		//				
+		if ( pvDiskBufferIfJustLoaded )
+		{
+			Z_MorphMallocTag( pvDiskBufferIfJustLoaded, eTag );
+		}
+		else
+		{
+			pvDiskBufferIfJustLoaded =  Z_Malloc(iSize,eTag, qfalse );
+		}
+
+		ModelBin.pModelDiskImage	= pvDiskBufferIfJustLoaded;
+		ModelBin.iAllocSize			= iSize;
+
+		int iCheckSum;		
+		if (FS_FileIsInPAK(sModelName, &iCheckSum) == 1)
+		{
+			ModelBin.iPAKFileCheckSum = iCheckSum;	// else ModelBin's constructor will leave it as -1
+		}
+
+		*pqbAlreadyFound = qfalse;
+	}
+	else
+	{
+#ifndef DEDICATED
+		// if we already had this model entry, then re-register all the shaders it wanted...
+		//
+		int iEntries = ModelBin.ShaderRegisterData.size();
+		for (int i=0; i<iEntries; i++)
+		{
+			int iShaderNameOffset	= ModelBin.ShaderRegisterData[i].first;
+			int iShaderPokeOffset	= ModelBin.ShaderRegisterData[i].second;
+
+			char *psShaderName		=		  &((char*)ModelBin.pModelDiskImage)[iShaderNameOffset];
+			int  *piShaderPokePtr	= (int *) &((char*)ModelBin.pModelDiskImage)[iShaderPokeOffset];
+
+			shader_t *sh = R_FindShader( psShaderName, lightmapsNone, stylesDefault, qtrue );
+	            
+			if ( sh->defaultShader ) 
+			{
+				*piShaderPokePtr = 0;
+			} else {
+				*piShaderPokePtr = sh->index;
+			}
+		}
+#endif //!DEDICATED
+		*pqbAlreadyFound = qtrue;	// tell caller not to re-Endian or re-Shader this binary		
+	}
+
+	ModelBin.iLastLevelUsedOn = RE_RegisterMedia_GetLevel();
+
+	return ModelBin.pModelDiskImage;
+}
+
+// Unfortunately the dedicated server also hates shader loading. So we need an alternate of this func.
+//
+void *RE_RegisterServerModels_Malloc(int iSize, void *pvDiskBufferIfJustLoaded, const char *psModelFileName, qboolean *pqbAlreadyFound, memtag_t eTag)
+{
+	char sModelName[MAX_QPATH];
+
+	assert(CachedModels);
+
+	Q_strncpyz(sModelName,psModelFileName,sizeof(sModelName));
+	Q_strlwr  (sModelName);
+
+	CachedEndianedModelBinary_t &ModelBin = (*CachedModels)[sModelName];
+
+	if (ModelBin.pModelDiskImage == NULL)
+	{
+		// new, instead of doing a Z_Malloc and assigning that we just morph the disk buffer alloc
+		//	then don't thrown it away on return - cuts down on mem overhead
+		//
+		// ... groan, but not if doing a limb hierarchy creation (some VV stuff?), in which case it's NULL
+		//				
+		if ( pvDiskBufferIfJustLoaded )
+		{
+			Z_MorphMallocTag( pvDiskBufferIfJustLoaded, eTag );
+		}
+		else
+		{
+			pvDiskBufferIfJustLoaded =  Z_Malloc(iSize,eTag, qfalse );
+		}
+
+		ModelBin.pModelDiskImage	= pvDiskBufferIfJustLoaded;
+		ModelBin.iAllocSize			= iSize;
+
+		int iCheckSum;		
+		if (FS_FileIsInPAK(sModelName, &iCheckSum) == 1)
+		{
+			ModelBin.iPAKFileCheckSum = iCheckSum;	// else ModelBin's constructor will leave it as -1
+		}
+
+		*pqbAlreadyFound = qfalse;
+	}
+	else
+	{
+		// if we already had this model entry, then re-register all the shaders it wanted...
+		//
+		/*
+		int iEntries = ModelBin.ShaderRegisterData.size();
+		for (int i=0; i<iEntries; i++)
+		{
+			int iShaderNameOffset	= ModelBin.ShaderRegisterData[i].first;
+			int iShaderPokeOffset	= ModelBin.ShaderRegisterData[i].second;
+
+			char *psShaderName		=		  &((char*)ModelBin.pModelDiskImage)[iShaderNameOffset];
+			int  *piShaderPokePtr	= (int *) &((char*)ModelBin.pModelDiskImage)[iShaderPokeOffset];
+
+			shader_t *sh = R_FindShader( psShaderName, lightmapsNone, stylesDefault, qtrue );
+	            
+			if ( sh->defaultShader ) 
+			{
+				*piShaderPokePtr = 0;
+			} else {
+				*piShaderPokePtr = sh->index;
+			}
+		}
+		*/
+		//No. Bad.
+		*pqbAlreadyFound = qtrue;	// tell caller not to re-Endian or re-Shader this binary		
+	}
+
+	ModelBin.iLastLevelUsedOn = RE_RegisterMedia_GetLevel();
+
+	return ModelBin.pModelDiskImage;
+}
+
+// dump any models not being used by this level if we're running low on memory...
+//
+static int GetModelDataAllocSize(void)
+{
+	return	Z_MemSize( TAG_MODEL_MD3) +
+			Z_MemSize( TAG_MODEL_GLM) +
+			Z_MemSize( TAG_MODEL_GLA);
+}
+extern cvar_t *r_modelpoolmegs;
+//
+// return qtrue if at least one cached model was freed (which tells z_malloc()-fail recoveryt code to try again)
+//
+extern qboolean gbInsideRegisterModel;
+qboolean RE_RegisterModels_LevelLoadEnd(qboolean bDeleteEverythingNotUsedThisLevel /* = qfalse */)
+{	
+	qboolean bAtLeastoneModelFreed = qfalse;
+
+	assert(CachedModels);
+
+	Com_DPrintf (S_COLOR_RED "RE_RegisterModels_LevelLoadEnd():\n");
+
+	if (gbInsideRegisterModel)
+	{
+		Com_DPrintf( "(Inside RE_RegisterModel (z_malloc recovery?), exiting...\n");
+	}
+	else
+	{
+		int iLoadedModelBytes	=	GetModelDataAllocSize();
+		const int iMaxModelBytes=	r_modelpoolmegs->integer * 1024 * 1024;
+
+		qboolean bEraseOccured = qfalse;
+		for (CachedModels_t::iterator itModel = CachedModels->begin(); itModel != CachedModels->end() && ( bDeleteEverythingNotUsedThisLevel || iLoadedModelBytes > iMaxModelBytes ); bEraseOccured?itModel:++itModel)
+		{			
+			bEraseOccured = qfalse;
+
+			CachedEndianedModelBinary_t &CachedModel = (*itModel).second;
+
+			qboolean bDeleteThis = qfalse;
+
+			if (bDeleteEverythingNotUsedThisLevel)
+			{
+				bDeleteThis = (CachedModel.iLastLevelUsedOn != RE_RegisterMedia_GetLevel()) ? qtrue : qfalse;
+			}
+			else
+			{
+				bDeleteThis = (CachedModel.iLastLevelUsedOn < RE_RegisterMedia_GetLevel()) ? qtrue : qfalse;
+			}
+
+			// if it wasn't used on this level, dump it...
+			//
+			if (bDeleteThis)
+			{
+				LPCSTR psModelName = (*itModel).first.c_str();
+				Com_DPrintf (S_COLOR_RED "Dumping \"%s\"", psModelName);
+
+	#ifdef _DEBUG
+				Com_DPrintf (S_COLOR_RED ", used on lvl %d\n",CachedModel.iLastLevelUsedOn);
+	#endif				
+
+				if (CachedModel.pModelDiskImage) {
+					Z_Free(CachedModel.pModelDiskImage);	
+					//CachedModel.pModelDiskImage = NULL;	// REM for reference, erase() call below negates the need for it.
+					bAtLeastoneModelFreed = qtrue;
+				}
+#ifndef __linux__
+				itModel = CachedModels->erase(itModel);
+				bEraseOccured = qtrue;
+#else
+				// Both MS and Dinkumware got the map::erase wrong
+				// The STL has the return type as a void
+				CachedModels_t::iterator itTemp;
+				itTemp = itModel;
+				itModel++;
+				CachedModels->erase(itTemp);
+				
+#endif
+
+				iLoadedModelBytes = GetModelDataAllocSize();				
+			}
+		}
+	}
+
+	Com_DPrintf (S_COLOR_RED "RE_RegisterModels_LevelLoadEnd(): Ok\n");	
+
+	return bAtLeastoneModelFreed;	
+}
+
+
+
+// scan through all loaded models and see if their PAK checksums are still valid with the current pure PAK lists,
+//	dump any that aren't (so people can't cheat by using models with huge spikes that show through walls etc)
+//
+// (avoid using ri.xxxx stuff here in case running on dedicated)
+//
+static void RE_RegisterModels_DumpNonPure(void)
+{
+	Com_DPrintf( "RE_RegisterModels_DumpNonPure():\n");
+
+	if(!CachedModels) {
+		return;
+	}
+	qboolean bEraseOccured = qfalse;
+	for (CachedModels_t::iterator itModel = CachedModels->begin(); itModel != CachedModels->end(); bEraseOccured?itModel:++itModel)
+	{			
+		bEraseOccured = qfalse;
+
+		LPCSTR						psModelName	 = (*itModel).first.c_str();
+		CachedEndianedModelBinary_t &CachedModel = (*itModel).second;
+
+		int iCheckSum = -1;
+		int iInPak = FS_FileIsInPAK(psModelName, &iCheckSum);
+
+		if (iInPak == -1 || iCheckSum != CachedModel.iPAKFileCheckSum)
+		{
+			if (stricmp(sDEFAULT_GLA_NAME ".gla" , psModelName))	// don't dump "*default.gla", that's program internal anyway
+			{
+				// either this is not from a PAK, or it's from a non-pure one, so ditch it...
+				//					
+				Com_DPrintf( "Dumping none pure model \"%s\"", psModelName);
+
+				if (CachedModel.pModelDiskImage) {
+					Z_Free(CachedModel.pModelDiskImage);	
+					//CachedModel.pModelDiskImage = NULL;	// REM for reference, erase() call below negates the need for it.
+				}
+#ifndef __linux__
+				itModel = CachedModels->erase(itModel);
+				bEraseOccured = qtrue;
+#else
+				// Both MS and Dinkumware got the map::erase wrong
+				// The STL has the return type as a void
+				CachedModels_t::iterator itTemp;
+				itTemp = itModel;
+				itModel++;
+				CachedModels->erase(itTemp);
+
+#endif
+			}
+		}
+	}
+
+	Com_DPrintf( "RE_RegisterModels_DumpNonPure(): Ok\n");	
+}
+
+void RE_RegisterModels_Info_f( void )
+{	
+	int iTotalBytes = 0;
+	if(!CachedModels) {
+		Com_Printf ("%d bytes total (%.2fMB)\n",iTotalBytes, (float)iTotalBytes / 1024.0f / 1024.0f);
+		return;
+	}
+
+	int iModels = CachedModels->size();
+	int iModel  = 0;
+
+	for (CachedModels_t::iterator itModel = CachedModels->begin(); itModel != CachedModels->end(); ++itModel,iModel++)
+	{	
+		CachedEndianedModelBinary_t &CachedModel = (*itModel).second;
+
+		Com_Printf ("%d/%d: \"%s\" (%d bytes)",iModel,iModels,(*itModel).first.c_str(),CachedModel.iAllocSize );
+
+		#ifdef _DEBUG
+		Com_Printf (", lvl %d\n",CachedModel.iLastLevelUsedOn);
+		#endif
+
+		iTotalBytes += CachedModel.iAllocSize;
+	}
+	Com_Printf ("%d bytes total (%.2fMB)\n",iTotalBytes, (float)iTotalBytes / 1024.0f / 1024.0f);
+}
+
+
+// (don't use ri.xxx functions since the renderer may not be running here)...
+//
+static void RE_RegisterModels_DeleteAll(void)
+{
+	if(!CachedModels) {
+		return;	//argh!
+	}
+
+#ifndef __linux__
+	for (CachedModels_t::iterator itModel = CachedModels->begin(); itModel != CachedModels->end(); )
+	{
+		CachedEndianedModelBinary_t &CachedModel = (*itModel).second;
+
+		if (CachedModel.pModelDiskImage) {
+			Z_Free(CachedModel.pModelDiskImage);					
+		}
+
+		itModel = CachedModels->erase(itModel);			
+	}
+#else
+	CachedModels->erase(CachedModels->begin(),CachedModels->end());
+#endif
+}
+
+
+// do not use ri.xxx functions in here, the renderer may not be running (ie. if on a dedicated server)...
+//
+static int giRegisterMedia_CurrentLevel=0;
+void RE_RegisterMedia_LevelLoadBegin(const char *psMapName, ForceReload_e eForceReload)
+{
+	// for development purposes we may want to ditch certain media just before loading a map...
+	//
+	bool bDeleteModels	= eForceReload == eForceReload_MODELS || eForceReload == eForceReload_ALL;
+//	bool bDeleteBSP		= eForceReload == eForceReload_BSP    || eForceReload == eForceReload_ALL;
+
+	if (bDeleteModels)
+	{
+		RE_RegisterModels_DeleteAll();
+	}
+	else
+	{
+		if (sv_pure->integer)
+		{
+			RE_RegisterModels_DumpNonPure();
+		}
+	}
+
+	tr.numBSPModels = 0;
+
+#ifndef DEDICATED
+// not used in MP codebase...
+//
+//	if (bDeleteBSP)
+//	{
+//		CM_DeleteCachedMap();
+		R_Images_DeleteLightMaps();	// always do this now, makes no real load time difference, and lets designers work ok
+//	}
+#endif
+
+	// at some stage I'll probably want to put some special logic here, like not incrementing the level number
+	//	when going into a map like "brig" or something, so returning to the previous level doesn't require an 
+	//	asset reload etc, but for now...
+	//
+	// only bump level number if we're not on the same level. 
+	//	Note that this will hide uncached models, which is perhaps a bad thing?...
+	//
+	static char sPrevMapName[MAX_QPATH]={0};
+	if (Q_stricmp( psMapName,sPrevMapName ))
+	{
+		Q_strncpyz( sPrevMapName, psMapName, sizeof(sPrevMapName) );
+		giRegisterMedia_CurrentLevel++;
+	}
+}
+
+int RE_RegisterMedia_GetLevel(void)
+{
+	return giRegisterMedia_CurrentLevel;
+}
+
+// this is now only called by the client, so should be ok to dump media...
+//
+extern qboolean SND_RegisterAudio_LevelLoadEnd(qboolean bDeleteEverythingNotUsedThisLevel /* 99% qfalse */);
+extern void S_RestartMusic(void);
+void RE_RegisterMedia_LevelLoadEnd(void)
+{
+	RE_RegisterModels_LevelLoadEnd(qfalse);
+#ifndef DEDICATED
+	RE_RegisterImages_LevelLoadEnd();
+	SND_RegisterAudio_LevelLoadEnd(qfalse);
+//	RE_InitDissolve();
+	S_RestartMusic();
+#endif
+}
+
+
+
+/*
+** R_GetModelByHandle
+*/
+model_t	*R_GetModelByHandle( qhandle_t index ) {
+	model_t		*mod;
+
+	// out of range gets the defualt model
+	if ( index < 1 || index >= tr.numModels ) {
+		return tr.models[0];
+	}
+
+	mod = tr.models[index];
+
+	return mod;
+}
+
+//===============================================================================
+
+/*
+** R_AllocModel
+*/
+model_t *R_AllocModel( void ) {
+	model_t		*mod;
+
+	if ( tr.numModels == MAX_MOD_KNOWN ) {
+		return NULL;
+	}
+
+	mod = (struct model_s *)Hunk_Alloc( sizeof( *tr.models[tr.numModels] ), h_low );
+	mod->index = tr.numModels;
+	tr.models[tr.numModels] = mod;
+	tr.numModels++;
+
+	return mod;
+}
+
+/*
+Ghoul2 Insert Start
+*/
+
+/*
+================
+return a hash value for the filename
+================
+*/
+static long generateHashValue( const char *fname, const int size ) {
+	int		i;
+	long	hash;
+	char	letter;
+
+	hash = 0;
+	i = 0;
+	while (fname[i] != '\0') {
+		letter = tolower((unsigned char)fname[i]);
+		if (letter =='.') break;				// don't include extension
+		if (letter =='\\') letter = '/';		// damn path names
+		hash+=(long)(letter)*(i+119);
+		i++;
+	}
+	hash &= (size-1);
+	return hash;
+}
+
+void RE_InsertModelIntoHash(const char *name, model_t *mod)
+{
+	int			hash;
+	modelHash_t	*mh;
+
+	hash = generateHashValue(name, FILE_HASH_SIZE);
+
+	// insert this file into the hash table so we can look it up faster later
+	mh = (modelHash_t*)Hunk_Alloc( sizeof( modelHash_t ), h_low );
+
+	mh->next = mhHashTable[hash];
+	mh->handle = mod->index;
+	strcpy(mh->name, name);
+	mhHashTable[hash] = mh;
+}
+/*
+Ghoul2 Insert End
+*/
+
+//rww - Please forgive me for all of the below. Feel free to destroy it and replace it with something better.
+//You obviously can't touch anything relating to shaders or ri. functions here in case a dedicated
+//server is running, which is the entire point of having these seperate functions. If anything major
+//is changed in the non-server-only versions of these functions it would be wise to incorporate it
+//here as well.
+
+/*
+=================
+ServerLoadMDXA - load a Ghoul 2 animation file
+=================
+*/
+qboolean ServerLoadMDXA( model_t *mod, void *buffer, const char *mod_name, qboolean &bAlreadyCached ) {
+
+	mdxaHeader_t		*pinmodel, *mdxa;
+	int					version;
+	int					size;
+
+#ifndef _M_IX86
+	int					j, k, i;
+	int					frameSize;
+	mdxaFrame_t			*cframe;
+	mdxaSkel_t			*boneInfo;
+#endif
+
+ 	pinmodel = (mdxaHeader_t *)buffer;
+	//
+	// read some fields from the binary, but only LittleLong() them when we know this wasn't an already-cached model...
+	//	
+	version = (pinmodel->version);
+	size	= (pinmodel->ofsEnd);
+
+	if (!bAlreadyCached)
+	{
+		version = LittleLong(version);
+		size	= LittleLong(size);
+	}
+	
+	if (version != MDXA_VERSION) {
+		return qfalse;
+	}
+
+	mod->type		= MOD_MDXA;
+	mod->dataSize  += size;
+
+	qboolean bAlreadyFound = qfalse;
+	mdxa = mod->mdxa = (mdxaHeader_t*) //Hunk_Alloc( size );
+										RE_RegisterServerModels_Malloc(size, buffer, mod_name, &bAlreadyFound, TAG_MODEL_GLA);
+
+	assert(bAlreadyCached == bAlreadyFound);	// I should probably eliminate 'bAlreadyFound', but wtf?
+
+	if (!bAlreadyFound)
+	{
+		// horrible new hackery, if !bAlreadyFound then we've just done a tag-morph, so we need to set the 
+		//	bool reference passed into this function to true, to tell the caller NOT to do an FS_Freefile since
+		//	we've hijacked that memory block...
+		//
+		// Aaaargh. Kill me now...
+		//
+		bAlreadyCached = qtrue;
+		assert( mdxa == buffer );
+//		memcpy( mdxa, buffer, size );	// and don't do this now, since it's the same thing
+
+		LL(mdxa->ident);
+		LL(mdxa->version);
+		LL(mdxa->numFrames);
+		LL(mdxa->numBones);
+		LL(mdxa->ofsFrames);
+		LL(mdxa->ofsEnd);
+	}
+
+ 	if ( mdxa->numFrames < 1 ) {
+		return qfalse;
+	}
+
+	if (bAlreadyFound)
+	{
+		return qtrue;	// All done, stop here, do not LittleLong() etc. Do not pass go...
+	}
+
+#ifndef _M_IX86
+
+	//
+	// optimisation, we don't bother doing this for standard intel case since our data's already in that format...
+	//
+
+	// swap all the skeletal info
+	boneInfo = (mdxaSkel_t *)( (byte *)mdxa + mdxa->ofsSkel);
+	for ( i = 0 ; i < mdxa->numBones ; i++) 
+	{
+		LL(boneInfo->numChildren);
+		LL(boneInfo->parent);
+		for (k=0; k<boneInfo->numChildren; k++)
+		{
+			LL(boneInfo->children[k]);
+		}
+
+		// get next bone
+		boneInfo += (int)( &((mdxaSkel_t *)0)->children[ boneInfo->numChildren ] );
+	}
+
+
+	// swap all the frames
+	frameSize = (int)( &((mdxaFrame_t *)0)->bones[ mdxa->numBones ] );
+	for ( i = 0 ; i < mdxa->numFrames ; i++) 
+	{
+		cframe = (mdxaFrame_t *) ( (byte *)mdxa + mdxa->ofsFrames + i * frameSize );
+   		cframe->radius = LittleFloat( cframe->radius );
+		for ( j = 0 ; j < 3 ; j++ ) 
+		{
+			cframe->bounds[0][j] = LittleFloat( cframe->bounds[0][j] );
+			cframe->bounds[1][j] = LittleFloat( cframe->bounds[1][j] );
+    		cframe->localOrigin[j] = LittleFloat( cframe->localOrigin[j] );
+		}
+		for ( j = 0 ; j < mdxa->numBones * sizeof( mdxaBone_t ) / 2 ; j++ ) 
+		{
+			((short *)cframe->bones)[j] = LittleShort( ((short *)cframe->bones)[j] );
+		}
+	}
+#endif
+	return qtrue;
+}
+
+/*
+=================
+ServerLoadMDXM - load a Ghoul 2 Mesh file
+=================
+*/
+qboolean ServerLoadMDXM( model_t *mod, void *buffer, const char *mod_name, qboolean &bAlreadyCached ) {
+	int					i,l, j;
+	mdxmHeader_t		*pinmodel, *mdxm;
+	mdxmLOD_t			*lod;
+	mdxmSurface_t		*surf;
+	int					version;
+	int					size;
+	shader_t			*sh;
+	mdxmSurfHierarchy_t	*surfInfo;
+
+#ifndef _M_IX86
+	int					k;
+	int					frameSize;
+	mdxmTag_t			*tag;
+	mdxmTriangle_t		*tri;
+	mdxmVertex_t		*v;
+ 	mdxmFrame_t			*cframe;
+	int					*boneRef;
+#endif
+    
+	pinmodel= (mdxmHeader_t *)buffer;
+	//
+	// read some fields from the binary, but only LittleLong() them when we know this wasn't an already-cached model...
+	//	
+	version = (pinmodel->version);
+	size	= (pinmodel->ofsEnd);
+
+	if (!bAlreadyCached)
+	{
+		version = LittleLong(version);
+		size	= LittleLong(size);
+	}
+
+	if (version != MDXM_VERSION) {
+		return qfalse;
+	}
+
+	mod->type	   = MOD_MDXM;
+	mod->dataSize += size;	
+	
+	qboolean bAlreadyFound = qfalse;
+	mdxm = mod->mdxm = (mdxmHeader_t*) //Hunk_Alloc( size );
+										RE_RegisterServerModels_Malloc(size, buffer, mod_name, &bAlreadyFound, TAG_MODEL_GLM);
+
+	assert(bAlreadyCached == bAlreadyFound);	// I should probably eliminate 'bAlreadyFound', but wtf?
+
+	if (!bAlreadyFound)
+	{
+		// horrible new hackery, if !bAlreadyFound then we've just done a tag-morph, so we need to set the 
+		//	bool reference passed into this function to true, to tell the caller NOT to do an FS_Freefile since
+		//	we've hijacked that memory block...
+		//
+		// Aaaargh. Kill me now...
+		//
+		bAlreadyCached = qtrue;
+		assert( mdxm == buffer );
+//		memcpy( mdxm, buffer, size );	// and don't do this now, since it's the same thing
+
+		LL(mdxm->ident);
+		LL(mdxm->version);
+		LL(mdxm->numLODs);
+		LL(mdxm->ofsLODs);
+		LL(mdxm->numSurfaces);
+		LL(mdxm->ofsSurfHierarchy);
+		LL(mdxm->ofsEnd);
+	}
+		
+	// first up, go load in the animation file we need that has the skeletal animation info for this model
+	mdxm->animIndex = RE_RegisterServerModel(va ("%s.gla",mdxm->animName));
+	if (!mdxm->animIndex) 
+	{
+		return qfalse;
+	}
+
+	mod->numLods = mdxm->numLODs -1 ;	//copy this up to the model for ease of use - it wil get inced after this.
+
+	if (bAlreadyFound)
+	{
+		return qtrue;	// All done. Stop, go no further, do not LittleLong(), do not pass Go...
+	}
+
+	surfInfo = (mdxmSurfHierarchy_t *)( (byte *)mdxm + mdxm->ofsSurfHierarchy);
+ 	for ( i = 0 ; i < mdxm->numSurfaces ; i++) 
+	{
+		LL(surfInfo->numChildren);
+		LL(surfInfo->parentIndex);
+
+		// do all the children indexs
+		for (j=0; j<surfInfo->numChildren; j++)
+		{
+			LL(surfInfo->childIndexes[j]);
+		}
+
+		// We will not be using shaders on the server.
+		sh = 0;
+		// insert it in the surface list
+		
+		surfInfo->shaderIndex = 0;
+
+		RE_RegisterModels_StoreShaderRequest(mod_name, &surfInfo->shader[0], &surfInfo->shaderIndex);
+
+		// find the next surface
+		surfInfo = (mdxmSurfHierarchy_t *)( (byte *)surfInfo + (int)( &((mdxmSurfHierarchy_t *)0)->childIndexes[ surfInfo->numChildren ] ));
+  	}
+	
+	// swap all the LOD's	(we need to do the middle part of this even for intel, because of shader reg and err-check)
+	lod = (mdxmLOD_t *) ( (byte *)mdxm + mdxm->ofsLODs );
+	for ( l = 0 ; l < mdxm->numLODs ; l++)
+	{
+		int	triCount = 0;
+
+		LL(lod->ofsEnd);
+		// swap all the surfaces
+		surf = (mdxmSurface_t *) ( (byte *)lod + sizeof (mdxmLOD_t) + (mdxm->numSurfaces * sizeof(mdxmLODSurfOffset_t)) );
+		for ( i = 0 ; i < mdxm->numSurfaces ; i++) 
+		{
+			LL(surf->numTriangles);
+			LL(surf->ofsTriangles);
+			LL(surf->numVerts);
+			LL(surf->ofsVerts);
+			LL(surf->ofsEnd);
+			LL(surf->ofsHeader);
+			LL(surf->numBoneReferences);
+			LL(surf->ofsBoneReferences);
+//			LL(surf->maxVertBoneWeights);
+
+			triCount += surf->numTriangles;
+										
+			if ( surf->numVerts > SHADER_MAX_VERTEXES ) {
+				return qfalse;
+			}
+			if ( surf->numTriangles*3 > SHADER_MAX_INDEXES ) {
+				return qfalse;
+			}
+		
+			// change to surface identifier
+			surf->ident = SF_MDX;
+
+			// register the shaders
+#ifndef _M_IX86
+//
+// optimisation, we don't bother doing this for standard intel case since our data's already in that format...
+//
+			// FIXME - is this correct? 
+			// do all the bone reference data
+			boneRef = (int *) ( (byte *)surf + surf->ofsBoneReferences );
+			for ( j = 0 ; j < surf->numBoneReferences ; j++ ) 
+			{
+					LL(boneRef[j]);
+			}
+
+			
+			// swap all the triangles
+			tri = (mdxmTriangle_t *) ( (byte *)surf + surf->ofsTriangles );
+			for ( j = 0 ; j < surf->numTriangles ; j++, tri++ ) 
+			{
+				LL(tri->indexes[0]);
+				LL(tri->indexes[1]);
+				LL(tri->indexes[2]);
+			}
+
+			// swap all the vertexes
+			v = (mdxmVertex_t *) ( (byte *)surf + surf->ofsVerts );
+			for ( j = 0 ; j < surf->numVerts ; j++ ) 
+			{
+				v->normal[0] = LittleFloat( v->normal[0] );
+				v->normal[1] = LittleFloat( v->normal[1] );
+				v->normal[2] = LittleFloat( v->normal[2] );
+
+				v->texCoords[0] = LittleFloat( v->texCoords[0] );
+				v->texCoords[1] = LittleFloat( v->texCoords[1] );
+
+				v->numWeights = LittleLong( v->numWeights );
+  			    v->offset[0] = LittleFloat( v->offset[0] );
+				v->offset[1] = LittleFloat( v->offset[1] );
+				v->offset[2] = LittleFloat( v->offset[2] );
+
+				for ( k = 0 ; k < /*v->numWeights*/surf->maxVertBoneWeights ; k++ ) 
+				{
+					v->weights[k].boneIndex = LittleLong( v->weights[k].boneIndex );
+					v->weights[k].boneWeight = LittleFloat( v->weights[k].boneWeight );
+				}
+				v = (mdxmVertex_t *)&v->weights[/*v->numWeights*/surf->maxVertBoneWeights];
+			}
+#endif
+
+			// find the next surface
+			surf = (mdxmSurface_t *)( (byte *)surf + surf->ofsEnd );
+		}
+
+		// find the next LOD
+		lod = (mdxmLOD_t *)( (byte *)lod + lod->ofsEnd );
+	}
+
+	return qtrue;
+}
+
+/*
+====================
+RE_RegisterServerModel
+
+Same as RE_RegisterModel, except used by the server to handle ghoul2 instance models.
+====================
+*/
+qhandle_t RE_RegisterServerModel( const char *name ) {
+	model_t		*mod;
+	unsigned	*buf;
+	int			lod;
+	int			ident;
+	qboolean	loaded;
+//	qhandle_t	hModel;
+	int			numLoaded;
+/*
+Ghoul2 Insert Start
+*/
+	int			hash;
+	modelHash_t	*mh;
+/*
+Ghoul2 Insert End
+*/
+
+	if (!r_noServerGhoul2)
+	{ //keep it from choking when it gets to these checks in the g2 code. Registering all r_ cvars for the server would be a Bad Thing though.
+		r_noServerGhoul2 = Cvar_Get( "r_noserverghoul2", "0", 0);
+	}
+
+	if ( !name || !name[0] ) {
+		return 0;
+	}
+
+	if ( strlen( name ) >= MAX_QPATH ) {
+		return 0;
+	}
+
+	hash = generateHashValue(name, FILE_HASH_SIZE);
+
+	//
+	// see if the model is already loaded
+	//
+	for (mh=mhHashTable[hash]; mh; mh=mh->next) {
+		if (Q_stricmp(mh->name, name) == 0) {
+			return mh->handle;
+		}
+	}
+
+	if ( ( mod = R_AllocModel() ) == NULL ) {
+		return 0;
+	}
+
+	// only set the name after the model has been successfully loaded
+	Q_strncpyz( mod->name, name, sizeof( mod->name ) );
+
+#ifndef DEDICATED
+	// make sure the render thread is stopped
+	R_SyncRenderThread();
+#endif
+
+	int iLODStart = 0;
+	if (strstr (name, ".md3")) {
+		iLODStart = MD3_MAX_LODS-1;	// this loads the md3s in reverse so they can be biased
+	}
+	mod->numLods = 0;
+
+	//
+	// load the files
+	//
+	numLoaded = 0;
+
+	for ( lod = iLODStart; lod >= 0 ; lod-- ) {
+		char filename[1024];
+
+		strcpy( filename, name );
+
+		if ( lod != 0 ) {
+			char namebuf[80];
+
+			if ( strrchr( filename, '.' ) ) {
+				*strrchr( filename, '.' ) = 0;
+			}
+			sprintf( namebuf, "_%d.md3", lod );
+			strcat( filename, namebuf );
+		}
+
+		qboolean bAlreadyCached = qfalse;		
+		if (!RE_RegisterModels_GetDiskFile(filename, (void **)&buf, &bAlreadyCached))
+		{
+			continue;
+		}
+		
+		//loadmodel = mod;	// this seems to be fairly pointless
+
+		// important that from now on we pass 'filename' instead of 'name' to all model load functions,
+		//	because 'filename' accounts for any LOD mangling etc so guarantees unique lookups for yet more
+		//	internal caching...
+		//		
+		ident = *(unsigned *)buf;
+		if (!bAlreadyCached)
+		{
+			ident = LittleLong(ident);
+		}
+
+		switch (ident)
+		{ //if you're trying to register anything else as a model type on the server, you are out of luck
+
+			case MDXA_IDENT:
+				loaded = ServerLoadMDXA( mod, buf, filename, bAlreadyCached );
+				break;
+			case MDXM_IDENT:
+				loaded = ServerLoadMDXM( mod, buf, filename, bAlreadyCached );
+				break;
+			default:
+				goto fail;
+		}
+		
+		if (!bAlreadyCached){	// important to check!!
+			FS_FreeFile (buf);
+		}
+
+		if ( !loaded ) {
+			if ( lod == 0 ) {
+				goto fail;
+			} else {
+				break;
+			}
+		} else {
+			mod->numLods++;
+			numLoaded++;
+		}
+	}
+
+	if ( numLoaded ) {
+		// duplicate into higher lod spots that weren't
+		// loaded, in case the user changes r_lodbias on the fly
+		for ( lod-- ; lod >= 0 ; lod-- ) {
+			mod->numLods++;
+			mod->md3[lod] = mod->md3[lod+1];
+		}
+
+/*
+Ghoul2 Insert Start
+*/
+
+	RE_InsertModelIntoHash(name, mod);
+	return mod->index;
+/*
+Ghoul2 Insert End
+*/
+	}
+
+fail:
+	// we still keep the model_t around, so if the model name is asked for
+	// again, we won't bother scanning the filesystem
+	mod->type = MOD_BAD;
+	RE_InsertModelIntoHash(name, mod);
+	return 0;
+}
+
+
+/*
+====================
+RE_RegisterModel
+
+Loads in a model for the given name
+
+Zero will be returned if the model fails to load.
+An entry will be retained for failed models as an
+optimization to prevent disk rescanning if they are
+asked for again.
+====================
+*/
+static qhandle_t RE_RegisterModel_Actual( const char *name ) {
+	model_t		*mod;
+	unsigned	*buf;
+	int			lod;
+	int			ident;
+	qboolean	loaded;
+//	qhandle_t	hModel;
+	int			numLoaded;
+/*
+Ghoul2 Insert Start
+*/
+	int			hash;
+	modelHash_t	*mh;
+/*
+Ghoul2 Insert End
+*/
+
+	if ( !name || !name[0] ) {
+		Com_Printf ("RE_RegisterModel: NULL name\n" );
+		return 0;
+	}
+
+	if ( strlen( name ) >= MAX_QPATH ) {
+		Com_DPrintf (S_COLOR_RED "Model name exceeds MAX_QPATH\n" );
+		return 0;
+	}
+
+/*
+Ghoul2 Insert Start
+*/
+//	if (!tr.registered) {
+//		Com_Printf (S_COLOR_YELLOW  "RE_RegisterModel (%s) called before ready!\n",name );
+//		return 0;
+//	}
+	//
+	// search the currently loaded models
+	//
+	hash = generateHashValue(name, FILE_HASH_SIZE);
+
+	//
+	// see if the model is already loaded
+	//
+	for (mh=mhHashTable[hash]; mh; mh=mh->next) {
+		if (Q_stricmp(mh->name, name) == 0) {
+			return mh->handle;
+		}
+	}
+
+//	for ( hModel = 1 ; hModel < tr.numModels; hModel++ ) {
+//		mod = tr.models[hModel];
+//		if ( !strcmp( mod->name, name ) ) {
+//			if( mod->type == MOD_BAD ) {
+//				return 0;
+//			}
+//			return hModel;
+//		}
+//	}
+
+	if (name[0] == '#')
+	{
+		char		temp[MAX_QPATH];
+
+		tr.numBSPModels++;
+#ifndef DEDICATED
+		RE_LoadWorldMap_Actual(va("maps/%s.bsp", name + 1), tr.bspModels[tr.numBSPModels - 1], tr.numBSPModels);
+#endif
+		Com_sprintf(temp, MAX_QPATH, "*%d-0", tr.numBSPModels);
+		hash = generateHashValue(temp, FILE_HASH_SIZE);
+		for (mh=mhHashTable[hash]; mh; mh=mh->next) 
+		{
+			if (Q_stricmp(mh->name, temp) == 0) 
+			{
+				return mh->handle;
+			}
+		}
+		
+		return 0;
+	}
+
+	if (name[0] == '*')
+	{	// don't create a bad model for a bsp model
+		if (Q_stricmp(name, "*default.gla"))
+		{
+			return 0;
+		}
+	}
+
+/*
+Ghoul2 Insert End
+*/
+
+	// allocate a new model_t
+
+	if ( ( mod = R_AllocModel() ) == NULL ) {
+		Com_Printf (S_COLOR_YELLOW  "RE_RegisterModel: R_AllocModel() failed for '%s'\n", name);
+		return 0;
+	}
+
+	// only set the name after the model has been successfully loaded
+	Q_strncpyz( mod->name, name, sizeof( mod->name ) );
+
+#ifndef DEDICATED
+	// make sure the render thread is stopped
+	R_SyncRenderThread();
+#endif
+
+	int iLODStart = 0;
+	if (strstr (name, ".md3")) {
+		iLODStart = MD3_MAX_LODS-1;	// this loads the md3s in reverse so they can be biased
+	}
+	mod->numLods = 0;
+
+	//
+	// load the files
+	//
+	numLoaded = 0;
+
+	for ( lod = iLODStart; lod >= 0 ; lod-- ) {
+		char filename[1024];
+
+		strcpy( filename, name );
+
+		if ( lod != 0 ) {
+			char namebuf[80];
+
+			if ( strrchr( filename, '.' ) ) {
+				*strrchr( filename, '.' ) = 0;
+			}
+			sprintf( namebuf, "_%d.md3", lod );
+			strcat( filename, namebuf );
+		}
+
+		qboolean bAlreadyCached = qfalse;		
+		if (!RE_RegisterModels_GetDiskFile(filename, (void **)&buf, &bAlreadyCached))
+		{
+			continue;
+		}
+		
+		//loadmodel = mod;	// this seems to be fairly pointless
+
+		// important that from now on we pass 'filename' instead of 'name' to all model load functions,
+		//	because 'filename' accounts for any LOD mangling etc so guarantees unique lookups for yet more
+		//	internal caching...
+		//		
+		ident = *(unsigned *)buf;
+		if (!bAlreadyCached)
+		{
+			ident = LittleLong(ident);
+		}
+
+		switch (ident)
+		{
+			// if you add any new types of model load in this switch-case, tell me, 
+			//	or copy what I've done with the cache scheme (-ste).
+			//
+			case MDXA_IDENT:
+				loaded = R_LoadMDXA( mod, buf, filename, bAlreadyCached );
+				break;
+		
+			case MDXM_IDENT:
+				loaded = R_LoadMDXM( mod, buf, filename, bAlreadyCached );
+				break;
+
+			case MD3_IDENT:
+				loaded = R_LoadMD3( mod, lod, buf, filename, bAlreadyCached );
+				break;
+
+			default:
+				Com_Printf (S_COLOR_YELLOW"RE_RegisterModel: unknown fileid for %s\n", filename);
+				goto fail;
+		}
+		
+		if (!bAlreadyCached){	// important to check!!
+			FS_FreeFile (buf);
+		}
+
+		if ( !loaded ) {
+			if ( lod == 0 ) {
+				goto fail;
+			} else {
+				break;
+			}
+		} else {
+			mod->numLods++;
+			numLoaded++;
+			// if we have a valid model and are biased
+			// so that we won't see any higher detail ones,
+			// stop loading them
+			if ( lod <= r_lodbias->integer ) {
+				break;
+			}
+		}
+	}
+
+	if ( numLoaded ) {
+		// duplicate into higher lod spots that weren't
+		// loaded, in case the user changes r_lodbias on the fly
+		for ( lod-- ; lod >= 0 ; lod-- ) {
+			mod->numLods++;
+			mod->md3[lod] = mod->md3[lod+1];
+		}
+
+/*
+Ghoul2 Insert Start
+*/
+
+#ifdef _DEBUG
+	if (r_noPrecacheGLA && r_noPrecacheGLA->integer && ident == MDXA_IDENT)
+	{ //I expect this will cause leaks, but I don't care because it's a debugging utility.
+		return mod->index;
+	}
+#endif
+
+	RE_InsertModelIntoHash(name, mod);
+	return mod->index;
+/*
+Ghoul2 Insert End
+*/
+	}
+#ifdef _DEBUG
+	else {
+		Com_Printf (S_COLOR_YELLOW"RE_RegisterModel: couldn't load %s\n", name);
+	}
+#endif
+
+fail:
+	// we still keep the model_t around, so if the model name is asked for
+	// again, we won't bother scanning the filesystem
+	mod->type = MOD_BAD;
+	RE_InsertModelIntoHash(name, mod);
+	return 0;
+}
+
+
+// wrapper function needed to avoid problems with mid-function returns so I can safely use this bool to tell the
+//	z_malloc-fail recovery code whether it's safe to ditch any model caches...
+//
+qboolean gbInsideRegisterModel = qfalse;
+qhandle_t RE_RegisterModel( const char *name )
+{
+	const qboolean bWhatitwas = gbInsideRegisterModel;
+	gbInsideRegisterModel = qtrue;	// !!!!!!!!!!!!!!
+
+		qhandle_t q = RE_RegisterModel_Actual( name );
+
+	gbInsideRegisterModel = bWhatitwas;
+
+	return q;
+}
+
+
+
+
+/*
+=================
+R_LoadMD3
+=================
+*/
+static qboolean R_LoadMD3 (model_t *mod, int lod, void *buffer, const char *mod_name, qboolean &bAlreadyCached ) {
+	int					i, j;
+	md3Header_t			*pinmodel;
+	md3Surface_t		*surf;
+	int					version;
+	int					size;
+
+#ifndef _M_IX86
+	md3Frame_t			*frame;
+	md3Triangle_t		*tri;
+	md3St_t				*st;
+	md3XyzNormal_t		*xyz;
+	md3Tag_t			*tag;
+#endif
+
+
+	pinmodel= (md3Header_t *)buffer;
+	//
+	// read some fields from the binary, but only LittleLong() them when we know this wasn't an already-cached model...
+	//
+	version = pinmodel->version;
+	size	= pinmodel->ofsEnd;
+
+	if (!bAlreadyCached)
+	{
+		version = LittleLong(version);
+		size	= LittleLong(size);
+	}
+	
+	if (version != MD3_VERSION) {
+		Com_Printf (S_COLOR_YELLOW  "R_LoadMD3: %s has wrong version (%i should be %i)\n",
+				 mod_name, version, MD3_VERSION);
+		return qfalse;
+	}
+
+	mod->type      = MOD_MESH;	
+	mod->dataSize += size;
+
+	qboolean bAlreadyFound = qfalse;
+	mod->md3[lod] = (md3Header_t *) //Hunk_Alloc( size );
+										RE_RegisterModels_Malloc(size, buffer, mod_name, &bAlreadyFound, TAG_MODEL_MD3);
+
+	assert(bAlreadyCached == bAlreadyFound);	// I should probably eliminate 'bAlreadyFound', but wtf?
+
+	if (!bAlreadyFound)
+	{	
+		// horrible new hackery, if !bAlreadyFound then we've just done a tag-morph, so we need to set the 
+		//	bool reference passed into this function to true, to tell the caller NOT to do an FS_Freefile since
+		//	we've hijacked that memory block...
+		//
+		// Aaaargh. Kill me now...
+		//
+		bAlreadyCached = qtrue;
+		assert( mod->md3[lod] == buffer );
+//		memcpy( mod->md3[lod], buffer, size );	// and don't do this now, since it's the same thing		
+
+		LL(mod->md3[lod]->ident);
+		LL(mod->md3[lod]->version);
+		LL(mod->md3[lod]->numFrames);
+		LL(mod->md3[lod]->numTags);
+		LL(mod->md3[lod]->numSurfaces);
+		LL(mod->md3[lod]->ofsFrames);
+		LL(mod->md3[lod]->ofsTags);
+		LL(mod->md3[lod]->ofsSurfaces);
+		LL(mod->md3[lod]->ofsEnd);
+	}
+
+	if ( mod->md3[lod]->numFrames < 1 ) {
+		Com_Printf (S_COLOR_YELLOW  "R_LoadMD3: %s has no frames\n", mod_name );
+		return qfalse;
+	}
+
+	if (bAlreadyFound)
+	{
+		return qtrue;	// All done. Stop, go no further, do not pass Go...
+	}
+
+#ifndef _M_IX86
+	//
+	// optimisation, we don't bother doing this for standard intel case since our data's already in that format...
+	//
+
+	// swap all the frames
+    frame = (md3Frame_t *) ( (byte *)mod->md3[lod] + mod->md3[lod]->ofsFrames );
+    for ( i = 0 ; i < mod->md3[lod]->numFrames ; i++, frame++) {
+    	frame->radius = LittleFloat( frame->radius );
+        for ( j = 0 ; j < 3 ; j++ ) {
+            frame->bounds[0][j] = LittleFloat( frame->bounds[0][j] );
+            frame->bounds[1][j] = LittleFloat( frame->bounds[1][j] );
+	    	frame->localOrigin[j] = LittleFloat( frame->localOrigin[j] );
+        }
+	}
+
+	// swap all the tags
+    tag = (md3Tag_t *) ( (byte *)mod->md3[lod] + mod->md3[lod]->ofsTags );
+    for ( i = 0 ; i < mod->md3[lod]->numTags * mod->md3[lod]->numFrames ; i++, tag++) {
+        for ( j = 0 ; j < 3 ; j++ ) {
+			tag->origin[j] = LittleFloat( tag->origin[j] );
+			tag->axis[0][j] = LittleFloat( tag->axis[0][j] );
+			tag->axis[1][j] = LittleFloat( tag->axis[1][j] );
+			tag->axis[2][j] = LittleFloat( tag->axis[2][j] );
+        }
+	}
+#endif
+
+	// swap all the surfaces
+	surf = (md3Surface_t *) ( (byte *)mod->md3[lod] + mod->md3[lod]->ofsSurfaces );
+	for ( i = 0 ; i < mod->md3[lod]->numSurfaces ; i++) {
+        LL(surf->flags);
+        LL(surf->numFrames);
+        LL(surf->numShaders);
+        LL(surf->numTriangles);
+        LL(surf->ofsTriangles);
+        LL(surf->numVerts);
+        LL(surf->ofsShaders);
+        LL(surf->ofsSt);
+        LL(surf->ofsXyzNormals);
+        LL(surf->ofsEnd);
+		
+		if ( surf->numVerts > SHADER_MAX_VERTEXES ) {
+			Com_Error (ERR_DROP, "R_LoadMD3: %s has more than %i verts on a surface (%i)",
+				mod_name, SHADER_MAX_VERTEXES, surf->numVerts );
+		}
+		if ( surf->numTriangles*3 > SHADER_MAX_INDEXES ) {
+			Com_Error (ERR_DROP, "R_LoadMD3: %s has more than %i triangles on a surface (%i)",
+				mod_name, SHADER_MAX_INDEXES / 3, surf->numTriangles );
+		}
+	
+		// change to surface identifier
+		surf->ident = SF_MD3;
+
+		// lowercase the surface name so skin compares are faster
+		Q_strlwr( surf->name );
+
+		// strip off a trailing _1 or _2
+		// this is a crutch for q3data being a mess
+		j = strlen( surf->name );
+		if ( j > 2 && surf->name[j-2] == '_' ) {
+			surf->name[j-2] = 0;
+		}
+#ifndef DEDICATED
+        // register the shaders
+		md3Shader_t		*shader;
+        shader = (md3Shader_t *) ( (byte *)surf + surf->ofsShaders );
+        for ( j = 0 ; j < surf->numShaders ; j++, shader++ ) {
+            shader_t	*sh;
+
+            sh = R_FindShader( shader->name, lightmapsNone, stylesDefault, qtrue );
+			if ( sh->defaultShader ) {
+				shader->shaderIndex = 0;
+			} else {
+				shader->shaderIndex = sh->index;
+			}
+			RE_RegisterModels_StoreShaderRequest(mod_name, &shader->name[0], &shader->shaderIndex);
+        }
+#endif
+
+#ifndef _M_IX86
+//
+// optimisation, we don't bother doing this for standard intel case since our data's already in that format...
+//
+
+		// swap all the triangles
+		tri = (md3Triangle_t *) ( (byte *)surf + surf->ofsTriangles );
+		for ( j = 0 ; j < surf->numTriangles ; j++, tri++ ) {
+			LL(tri->indexes[0]);
+			LL(tri->indexes[1]);
+			LL(tri->indexes[2]);
+		}
+
+		// swap all the ST
+        st = (md3St_t *) ( (byte *)surf + surf->ofsSt );
+        for ( j = 0 ; j < surf->numVerts ; j++, st++ ) {
+            st->st[0] = LittleFloat( st->st[0] );
+            st->st[1] = LittleFloat( st->st[1] );
+        }
+
+		// swap all the XyzNormals
+        xyz = (md3XyzNormal_t *) ( (byte *)surf + surf->ofsXyzNormals );
+        for ( j = 0 ; j < surf->numVerts * surf->numFrames ; j++, xyz++ ) 
+		{
+            xyz->xyz[0] = LittleShort( xyz->xyz[0] );
+            xyz->xyz[1] = LittleShort( xyz->xyz[1] );
+            xyz->xyz[2] = LittleShort( xyz->xyz[2] );
+
+            xyz->normal = LittleShort( xyz->normal );
+        }
+#endif
+
+		// find the next surface
+		surf = (md3Surface_t *)( (byte *)surf + surf->ofsEnd );
+	}
+    
+	return qtrue;
+}
+
+
+//=============================================================================
+#ifndef DEDICATED
+/*
+** RE_BeginRegistration
+*/
+void RE_BeginRegistration( glconfig_t *glconfigOut ) {
+
+	R_Init();
+
+	*glconfigOut = glConfig;
+
+	R_SyncRenderThread();
+
+	tr.viewCluster = -1;		// force markleafs to regenerate
+
+	// rww - 9-13-01 [1-26-01-sof2]
+	//R_ClearFlares();
+
+	RE_ClearScene();
+
+	tr.registered = qtrue;
+
+	// NOTE: this sucks, for some reason the first stretch pic is never drawn
+	// without this we'd see a white flash on a level load because the very
+	// first time the level shot would not be drawn
+	RE_StretchPic(0, 0, 0, 0, 0, 0, 1, 1, 0);
+}
+
+//=============================================================================
+
+#endif // !DEDICATED
+void R_SVModelInit()
+{
+	R_ModelInit();
+}
+
+/*
+===============
+R_ModelInit
+===============
+*/
+void R_ModelInit( void )
+{
+	model_t		*mod;
+
+	if(!CachedModels)
+	{
+		CachedModels = new CachedModels_t;
+	}
+
+	// leave a space for NULL model
+	tr.numModels = 0;
+	memset(mhHashTable, 0, sizeof(mhHashTable));
+
+	mod = R_AllocModel();
+	mod->type = MOD_BAD;
+}
+
+extern void KillTheShaderHashTable(void);
+void R_HunkClearCrap(void)
+{ //get your dirty sticky assets off me, you damn dirty hunk!
+	KillTheShaderHashTable();
+	tr.numModels = 0;
+	memset(mhHashTable, 0, sizeof(mhHashTable));
+	tr.numShaders = 0;
+	tr.numSkins = 0;
+}
+
+void R_ModelFree(void)
+{
+	if(CachedModels) {
+		RE_RegisterModels_DeleteAll();
+		delete CachedModels;
+		CachedModels = NULL;
+	}
+}
+
+
+
+/*
+================
+R_Modellist_f
+================
+*/
+void R_Modellist_f( void ) {
+	int		i, j;
+	model_t	*mod;
+	int		total;
+	int		lods;
+
+	total = 0;
+	for ( i = 1 ; i < tr.numModels; i++ ) {
+		mod = tr.models[i];
+		lods = 1;
+		for ( j = 1 ; j < MD3_MAX_LODS ; j++ ) {
+			if ( mod->md3[j] && mod->md3[j] != mod->md3[j-1] ) {
+				lods++;
+			}
+		}
+		Com_Printf ("%8i : (%i) %s\n",mod->dataSize, lods, mod->name );
+		total += mod->dataSize;
+	}
+	Com_Printf ("%8i : Total models\n", total );
+
+#if	0		// not working right with new hunk
+	if ( tr.world ) {
+		Com_Printf ("\n%8i : %s\n", tr.world->dataSize, tr.world->name );
+	}
+#endif
+}
+
+
+//=============================================================================
+
+
+/*
+================
+R_GetTag
+================
+*/
+static md3Tag_t *R_GetTag( md3Header_t *mod, int frame, const char *tagName ) {
+	md3Tag_t		*tag;
+	int				i;
+
+	if ( frame >= mod->numFrames ) {
+		// it is possible to have a bad frame while changing models, so don't error
+		frame = mod->numFrames - 1;
+	}
+
+	tag = (md3Tag_t *)((byte *)mod + mod->ofsTags) + frame * mod->numTags;
+	for ( i = 0 ; i < mod->numTags ; i++, tag++ ) {
+		if ( !strcmp( tag->name, tagName ) ) {
+			return tag;	// found it
+		}
+	}
+
+	return NULL;
+}
+
+/*
+================
+R_LerpTag
+================
+*/
+int R_LerpTag( orientation_t *tag, qhandle_t handle, int startFrame, int endFrame, 
+					 float frac, const char *tagName ) {
+	md3Tag_t	*start, *end;
+	int		i;
+	float		frontLerp, backLerp;
+	model_t		*model;
+
+	model = R_GetModelByHandle( handle );
+	if ( !model->md3[0] ) {
+		AxisClear( tag->axis );
+		VectorClear( tag->origin );
+		return qfalse;
+	}
+
+	start = R_GetTag( model->md3[0], startFrame, tagName );
+	end = R_GetTag( model->md3[0], endFrame, tagName );
+	if ( !start || !end ) {
+		AxisClear( tag->axis );
+		VectorClear( tag->origin );
+		return qfalse;
+	}
+
+	frontLerp = frac;
+	backLerp = 1.0f - frac;
+
+	for ( i = 0 ; i < 3 ; i++ ) {
+		tag->origin[i] = start->origin[i] * backLerp +  end->origin[i] * frontLerp;
+		tag->axis[0][i] = start->axis[0][i] * backLerp +  end->axis[0][i] * frontLerp;
+		tag->axis[1][i] = start->axis[1][i] * backLerp +  end->axis[1][i] * frontLerp;
+		tag->axis[2][i] = start->axis[2][i] * backLerp +  end->axis[2][i] * frontLerp;
+	}
+	VectorNormalize( tag->axis[0] );
+	VectorNormalize( tag->axis[1] );
+	VectorNormalize( tag->axis[2] );
+	return qtrue;
+}
+
+
+/*
+====================
+R_ModelBounds
+====================
+*/
+void R_ModelBounds( qhandle_t handle, vec3_t mins, vec3_t maxs ) {
+	model_t		*model;
+	md3Header_t	*header;
+	md3Frame_t	*frame;
+
+	model = R_GetModelByHandle( handle );
+
+	if ( model->bmodel ) {
+		VectorCopy( model->bmodel->bounds[0], mins );
+		VectorCopy( model->bmodel->bounds[1], maxs );
+		return;
+	}
+
+	if ( !model->md3[0] ) {
+		VectorClear( mins );
+		VectorClear( maxs );
+		return;
+	}
+
+	header = model->md3[0];
+
+	frame = (md3Frame_t *)( (byte *)header + header->ofsFrames );
+
+	VectorCopy( frame->bounds[0], mins );
+	VectorCopy( frame->bounds[1], maxs );
+}
+
+
diff --git a/codemp/renderer/tr_noise.cpp b/codemp/renderer/tr_noise.cpp
new file mode 100644
index 0000000..879a5df
--- /dev/null
+++ b/codemp/renderer/tr_noise.cpp
@@ -0,0 +1,84 @@
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+// tr_noise.c
+#include "tr_local.h"
+
+#define NOISE_SIZE 256
+#define NOISE_MASK ( NOISE_SIZE - 1 )
+
+#define VAL( a ) s_noise_perm[ ( a ) & ( NOISE_MASK )]
+#define INDEX( x, y, z, t ) VAL( x + VAL( y + VAL( z + VAL( t ) ) ) )
+
+static float s_noise_table[NOISE_SIZE];
+static int s_noise_perm[NOISE_SIZE];
+
+#define LERP( a, b, w ) ( a * ( 1.0f - w ) + b * w )
+
+static float GetNoiseValue( int x, int y, int z, int t )
+{
+	int index = INDEX( ( int ) x, ( int ) y, ( int ) z, ( int ) t );
+
+	return s_noise_table[index];
+}
+
+float GetNoiseTime( int t )
+{
+	int index = VAL( t );
+
+	return (1 + s_noise_table[index]);
+}
+
+void R_NoiseInit( void )
+{
+	int i;
+
+	srand( 1001 );
+
+	for ( i = 0; i < NOISE_SIZE; i++ )
+	{
+		s_noise_table[i] = ( float ) ( ( ( rand() / ( float ) RAND_MAX ) * 2.0 - 1.0 ) );
+		s_noise_perm[i] = ( unsigned char ) ( rand() / ( float ) RAND_MAX * 255 );
+	}
+}
+
+float R_NoiseGet4f( float x, float y, float z, float t )
+{
+	int i;
+	int ix, iy, iz, it;
+	float fx, fy, fz, ft;
+	float front[4];
+	float back[4];
+	float fvalue, bvalue, value[2], finalvalue;
+
+	ix = ( int ) floor( x );
+	fx = x - ix;
+	iy = ( int ) floor( y );
+	fy = y - iy;
+	iz = ( int ) floor( z );
+	fz = z - iz;
+	it = ( int ) floor( t );
+	ft = t - it;
+
+	for ( i = 0; i < 2; i++ )
+	{
+		front[0] = GetNoiseValue( ix, iy, iz, it + i );
+		front[1] = GetNoiseValue( ix+1, iy, iz, it + i );
+		front[2] = GetNoiseValue( ix, iy+1, iz, it + i );
+		front[3] = GetNoiseValue( ix+1, iy+1, iz, it + i );
+
+		back[0] = GetNoiseValue( ix, iy, iz + 1, it + i );
+		back[1] = GetNoiseValue( ix+1, iy, iz + 1, it + i );
+		back[2] = GetNoiseValue( ix, iy+1, iz + 1, it + i );
+		back[3] = GetNoiseValue( ix+1, iy+1, iz + 1, it + i );
+
+		fvalue = LERP( LERP( front[0], front[1], fx ), LERP( front[2], front[3], fx ), fy );
+		bvalue = LERP( LERP( back[0], back[1], fx ), LERP( back[2], back[3], fx ), fy );
+
+		value[i] = LERP( fvalue, bvalue, fz );
+	}
+
+	finalvalue = LERP( value[0], value[1], ft );
+
+	return finalvalue;
+}
diff --git a/codemp/renderer/tr_public.h b/codemp/renderer/tr_public.h
new file mode 100644
index 0000000..60dfecb
--- /dev/null
+++ b/codemp/renderer/tr_public.h
@@ -0,0 +1,118 @@
+#ifndef __TR_PUBLIC_H
+#define __TR_PUBLIC_H
+
+#include "../cgame/tr_types.h"
+
+#define	REF_API_VERSION		8
+
+//
+// these are the functions exported by the refresh module
+//
+#ifdef _XBOX
+template <class T> class SPARC;
+#endif
+typedef struct {
+	// called before the library is unloaded
+	// if the system is just reconfiguring, pass destroyWindow = qfalse,
+	// which will keep the screen from flashing to the desktop.
+	void	(*Shutdown)( qboolean destroyWindow );
+
+	// All data that will be used in a level should be
+	// registered before rendering any frames to prevent disk hits,
+	// but they can still be registered at a later time
+	// if necessary.
+	//
+	// BeginRegistration makes any existing media pointers invalid
+	// and returns the current gl configuration, including screen width
+	// and height, which can be used by the client to intelligently
+	// size display elements
+	void	(*BeginRegistration)( glconfig_t *config );
+	qhandle_t (*RegisterModel)( const char *name );
+	qhandle_t (*RegisterSkin)( const char *name );
+	qhandle_t (*RegisterShader)( const char *name );
+	qhandle_t (*RegisterShaderNoMip)( const char *name );
+	const char *(*ShaderNameFromIndex)( int index );
+	void	(*LoadWorld)( const char *name );
+
+	// the vis data is a large enough block of data that we go to the trouble
+	// of sharing it with the clipmodel subsystem
+#ifdef _XBOX
+	void	(*SetWorldVisData)( SPARC<byte> *vis );
+#else
+	void	(*SetWorldVisData)( const byte *vis );
+#endif
+
+	// EndRegistration will draw a tiny polygon with each texture, forcing
+	// them to be loaded into card memory
+	void	(*EndRegistration)( void );
+
+	// a scene is built up by calls to R_ClearScene and the various R_Add functions.
+	// Nothing is drawn until R_RenderScene is called.
+	void	(*ClearScene)( void );
+	void	(*ClearDecals) ( void );
+	void	(*AddRefEntityToScene)( const refEntity_t *re );
+	void	(*AddMiniRefEntityToScene)( const miniRefEntity_t *re );
+	void	(*AddPolyToScene)( qhandle_t hShader , int numVerts, const polyVert_t *verts, int num );
+	void	(*AddDecalToScene)(qhandle_t shader, const vec3_t origin, const vec3_t dir, float orientation, float r, float g, float b, float a, qboolean alphaFade, float radius, qboolean temporary );
+	int		(*LightForPoint)( vec3_t point, vec3_t ambientLight, vec3_t directedLight, vec3_t lightDir );
+#ifndef VV_LIGHTING
+	void	(*AddLightToScene)( const vec3_t org, float intensity, float r, float g, float b );
+	void	(*AddAdditiveLightToScene)( const vec3_t org, float intensity, float r, float g, float b );
+#endif
+	void	(*RenderScene)( const refdef_t *fd );
+
+	void	(*SetColor)( const float *rgba );	// NULL = 1,1,1,1
+	void	(*DrawStretchPic) ( float x, float y, float w, float h, 
+		float s1, float t1, float s2, float t2, qhandle_t hShader );	// 0 = white
+	void	(*DrawRotatePic) ( float x, float y, float w, float h, 
+		float s1, float t1, float s2, float t2, float a1, qhandle_t hShader );	// 0 = white
+	void	(*DrawRotatePic2) ( float x, float y, float w, float h, 
+		float s1, float t1, float s2, float t2, float a1, qhandle_t hShader );	// 0 = white
+
+	// Draw images for cinematic rendering, pass as 32 bit rgba
+	void	(*DrawStretchRaw) (int x, int y, int w, int h, int cols, int rows, const byte *data, int client, qboolean dirty);
+	void	(*UploadCinematic) (int cols, int rows, const byte *data, int client, qboolean dirty);
+
+	void	(*BeginFrame)( stereoFrame_t stereoFrame );
+
+	// if the pointers are not NULL, timing info will be returned
+	void	(*EndFrame)( int *frontEndMsec, int *backEndMsec );
+
+
+	int		(*MarkFragments)( int numPoints, const vec3_t *points, const vec3_t projection,
+				   int maxPoints, vec3_t pointBuffer, int maxFragments, markFragment_t *fragmentBuffer );
+
+	int		(*LerpTag)( orientation_t *tag,  qhandle_t model, int startFrame, int endFrame, 
+					 float frac, const char *tagName );
+	void	(*ModelBounds)( qhandle_t model, vec3_t mins, vec3_t maxs );
+
+#ifdef __USEA3D
+	void    (*A3D_RenderGeometry) (void *pVoidA3D, void *pVoidGeom, void *pVoidMat, void *pVoidGeomStatus);
+#endif
+
+	qhandle_t (*RegisterFont)( const char *fontName );
+	int		(*Font_StrLenPixels) (const char *text, const int iFontIndex, const float scale);
+	int		(*Font_StrLenChars) (const char *text);
+	int		(*Font_HeightPixels)(const int iFontIndex, const float scale);
+	void	(*Font_DrawString)(int ox, int oy, const char *text, const float *rgba, const int setIndex, int iCharLimit, const float scale);
+	qboolean (*Language_IsAsian)(void);
+	qboolean (*Language_UsesSpaces)(void);
+	unsigned int (*AnyLanguage_ReadCharFromString)( const char *psText, int *piAdvanceCount, qboolean *pbIsTrailingPunctuation/* = NULL*/ );
+
+	void	(*RemapShader)(const char *oldShader, const char *newShader, const char *offsetTime);
+	qboolean (*GetEntityToken)( char *buffer, int size );
+	qboolean (*inPVS)( const vec3_t p1, const vec3_t p2, byte *mask );
+
+	void (*GetLightStyle)(int style, color4ub_t color);
+	void (*SetLightStyle)(int style, int color);
+
+	void	(*GetBModelVerts)( int bmodelIndex, vec3_t *vec, vec3_t normal );
+} refexport_t;
+
+
+// this is the only function actually exported at the linker level
+// If the module can't init to a valid rendering state, NULL will be
+// returned.
+refexport_t*GetRefAPI( int apiVersion );
+
+#endif	// __TR_PUBLIC_H
diff --git a/codemp/renderer/tr_quicksprite.cpp b/codemp/renderer/tr_quicksprite.cpp
new file mode 100644
index 0000000..f510efc
--- /dev/null
+++ b/codemp/renderer/tr_quicksprite.cpp
@@ -0,0 +1,222 @@
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+// tr_QuickSprite.cpp: implementation of the CQuickSpriteSystem class.
+//
+//////////////////////////////////////////////////////////////////////
+//#include "../server/exe_headers.h"
+#include "tr_local.h"
+
+#include "tr_QuickSprite.h"
+
+void R_BindAnimatedImage( textureBundle_t *bundle );
+
+
+//////////////////////////////////////////////////////////////////////
+// Singleton System
+//////////////////////////////////////////////////////////////////////
+CQuickSpriteSystem SQuickSprite;
+
+
+//////////////////////////////////////////////////////////////////////
+// Construction/Destruction
+//////////////////////////////////////////////////////////////////////
+
+CQuickSpriteSystem::CQuickSpriteSystem()
+{
+	int i;
+
+	for (i=0; i<SHADER_MAX_VERTEXES; i+=4)
+	{
+		// Bottom right
+		mTextureCoords[i+0][0] = 1.0;
+		mTextureCoords[i+0][1] = 1.0;
+		// Top right
+		mTextureCoords[i+1][0] = 1.0;
+		mTextureCoords[i+1][1] = 0.0;
+		// Top left
+		mTextureCoords[i+2][0] = 0.0;
+		mTextureCoords[i+2][1] = 0.0;
+		// Bottom left
+		mTextureCoords[i+3][0] = 0.0;
+		mTextureCoords[i+3][1] = 1.0;
+	}
+}
+
+CQuickSpriteSystem::~CQuickSpriteSystem()
+{
+
+}
+
+
+void CQuickSpriteSystem::Flush(void)
+{
+	if (mNextVert==0)
+	{
+		return;
+	}
+
+	/*
+	if (mUseFog && r_drawfog->integer == 2 &&
+		mFogIndex == tr.world->globalFog)
+	{ //enable hardware fog when we draw this thing if applicable -rww
+		fog_t *fog = tr.world->fogs + mFogIndex;
+
+#ifdef _XBOX
+		qglFogi(GL_FOG_MODE, GL_EXP2);
+#else
+		qglFogf(GL_FOG_MODE, GL_EXP2);
+#endif
+		qglFogf(GL_FOG_DENSITY, logtestExp2 / fog->parms.depthForOpaque);
+		qglFogfv(GL_FOG_COLOR, fog->parms.color);
+		qglEnable(GL_FOG);
+	}
+	*/
+	//this should not be needed, since I just wait to disable fog for the surface til after surface sprites are done
+
+	//
+	// render the main pass
+	//
+	R_BindAnimatedImage( mTexBundle );
+	GL_State(mGLStateBits);
+
+	//
+	// set arrays and lock
+	//
+	qglTexCoordPointer( 2, GL_FLOAT, 0, mTextureCoords );
+	qglEnableClientState( GL_TEXTURE_COORD_ARRAY);
+
+	qglEnableClientState( GL_COLOR_ARRAY);
+	qglColorPointer( 4, GL_UNSIGNED_BYTE, 0, mColors );
+
+	qglVertexPointer (3, GL_FLOAT, 16, mVerts);
+
+	if ( qglLockArraysEXT )
+	{
+		qglLockArraysEXT(0, mNextVert);
+		GLimp_LogComment( "glLockArraysEXT\n" );
+	}
+
+	qglDrawArrays(GL_QUADS, 0, mNextVert);
+
+	backEnd.pc.c_vertexes += mNextVert;
+	backEnd.pc.c_indexes += mNextVert;
+	backEnd.pc.c_totalIndexes += mNextVert;
+
+	//only for software fog pass (global soft/volumetric) -rww
+	if (mUseFog && (r_drawfog->integer != 2 || mFogIndex != tr.world->globalFog))
+	{
+		fog_t *fog = tr.world->fogs + mFogIndex;
+
+		//
+		// render the fog pass
+		//
+		GL_Bind( tr.fogImage );
+		GL_State( GLS_SRCBLEND_SRC_ALPHA | GLS_DSTBLEND_ONE_MINUS_SRC_ALPHA | GLS_DEPTHFUNC_EQUAL );
+
+		//
+		// set arrays and lock
+		//
+		qglTexCoordPointer( 2, GL_FLOAT, 0, mFogTextureCoords);
+//		qglEnableClientState( GL_TEXTURE_COORD_ARRAY);	// Done above
+
+		qglDisableClientState( GL_COLOR_ARRAY );
+		qglColor4ubv((GLubyte *)&fog->colorInt);
+
+//		qglVertexPointer (3, GL_FLOAT, 16, mVerts);	// Done above
+
+		qglDrawArrays(GL_QUADS, 0, mNextVert);
+
+		// Second pass from fog
+		backEnd.pc.c_totalIndexes += mNextVert;
+	}
+
+	// 
+	// unlock arrays
+	//
+	if (qglUnlockArraysEXT) 
+	{
+		qglUnlockArraysEXT();
+		GLimp_LogComment( "glUnlockArraysEXT\n" );
+	}
+
+	mNextVert=0;
+}
+
+
+void CQuickSpriteSystem::StartGroup(textureBundle_t *bundle, unsigned long glbits, int fogIndex )
+{
+	mNextVert = 0;
+
+	mTexBundle = bundle;
+	mGLStateBits = glbits;
+	if (fogIndex != -1)
+	{
+		mUseFog = qtrue;
+		mFogIndex = fogIndex;
+	}
+	else
+	{
+		mUseFog = qfalse;
+	}
+
+	qglDisable(GL_CULL_FACE);
+}
+
+
+void CQuickSpriteSystem::EndGroup(void)
+{
+	Flush();
+
+	qglColor4ub(255,255,255,255);
+	qglEnable(GL_CULL_FACE);
+}
+
+
+
+
+void CQuickSpriteSystem::Add(float *pointdata, color4ub_t color, vec2_t fog)
+{
+	float *curcoord;
+	float *curfogtexcoord;
+	unsigned long *curcolor;
+
+	if (mNextVert>SHADER_MAX_VERTEXES-4)
+	{
+		Flush();
+	}
+
+	curcoord = mVerts[mNextVert];
+	memcpy(curcoord, pointdata, 4*sizeof(vec4_t));
+
+	// Set up color
+	curcolor = &mColors[mNextVert];
+	*curcolor++ = *(unsigned long *)color;
+	*curcolor++ = *(unsigned long *)color;
+	*curcolor++ = *(unsigned long *)color;
+	*curcolor++ = *(unsigned long *)color;
+
+	if (fog)
+	{
+		curfogtexcoord = &mFogTextureCoords[mNextVert][0];
+		*curfogtexcoord++ = fog[0];
+		*curfogtexcoord++ = fog[1];
+
+		*curfogtexcoord++ = fog[0];
+		*curfogtexcoord++ = fog[1];
+
+		*curfogtexcoord++ = fog[0];
+		*curfogtexcoord++ = fog[1];
+
+		*curfogtexcoord++ = fog[0];
+		*curfogtexcoord++ = fog[1];
+
+		mUseFog=qtrue;
+	}
+	else
+	{
+		mUseFog=qfalse;
+	}
+
+	mNextVert+=4;
+}
diff --git a/codemp/renderer/tr_quicksprite.h b/codemp/renderer/tr_quicksprite.h
new file mode 100644
index 0000000..37d5691
--- /dev/null
+++ b/codemp/renderer/tr_quicksprite.h
@@ -0,0 +1,47 @@
+// this include must remain at the top of every CPP file
+//#include "../game/q_math.h"
+//#include "tr_headers.h"
+
+// tr_QuickSprite.h: interface for the CQuickSprite class.
+//
+//////////////////////////////////////////////////////////////////////
+
+#if !defined(AFX_TR_QUICKSPRITE_H__6F05EB85_A1ED_4537_9EC0_9F5D82A5D99A__INCLUDED_)
+#define AFX_TR_QUICKSPRITE_H__6F05EB85_A1ED_4537_9EC0_9F5D82A5D99A__INCLUDED_
+
+#if _MSC_VER > 1000
+#pragma once
+#endif // _MSC_VER > 1000
+
+class CQuickSpriteSystem
+{
+private:
+			textureBundle_t	*mTexBundle;
+			unsigned long	mGLStateBits;
+			int				mFogIndex;
+			qboolean		mUseFog;
+			vec4_t			mVerts[SHADER_MAX_VERTEXES];
+			unsigned int	mIndexes[SHADER_MAX_VERTEXES];			// Ideally this would be static, cause it never changes
+			vec2_t			mTextureCoords[SHADER_MAX_VERTEXES];	// Ideally this would be static, cause it never changes
+			vec2_t			mFogTextureCoords[SHADER_MAX_VERTEXES];
+			unsigned long	mColors[SHADER_MAX_VERTEXES];
+			int				mNextVert;
+
+			void Flush(void);
+
+public:
+			CQuickSpriteSystem();
+	virtual ~CQuickSpriteSystem();
+
+			void StartGroup(textureBundle_t *bundle, unsigned long glbits, int fogIndex = -1);
+			void EndGroup(void);
+
+			void Add(float *pointdata, color4ub_t color, vec2_t fog=NULL);
+};
+
+extern CQuickSpriteSystem SQuickSprite;
+
+
+#endif // !defined(AFX_TR_QUICKSPRITE_H__6F05EB85_A1ED_4537_9EC0_9F5D82A5D99A__INCLUDED_)
+
+
diff --git a/codemp/renderer/tr_scene.cpp b/codemp/renderer/tr_scene.cpp
new file mode 100644
index 0000000..79deccf
--- /dev/null
+++ b/codemp/renderer/tr_scene.cpp
@@ -0,0 +1,886 @@
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+#include "tr_local.h"
+
+#if !defined(G2_H_INC)
+	#include "../ghoul2/G2.h"
+#endif
+#include "../ghoul2/G2_local.h"
+#include "MatComp.h"
+
+#ifdef VV_LIGHTING
+#include "tr_lightmanager.h"
+#endif
+
+#pragma warning (disable: 4512)	//default assignment operator could not be gened
+#include "../qcommon/disablewarnings.h"
+
+static	int			r_firstSceneDrawSurf;
+
+static	int			r_numdlights;
+static	int			r_firstSceneDlight;
+
+static	int			r_numentities;
+static	int			r_firstSceneEntity;
+static	int			r_numminientities;
+static	int			r_firstSceneMiniEntity;
+static	int			refEntParent = -1;
+
+static	int			r_numpolys;
+static	int			r_firstScenePoly;
+
+static	int			r_numpolyverts;
+
+int					skyboxportal;
+int					drawskyboxportal;
+
+/*
+====================
+R_ToggleSmpFrame
+
+====================
+*/
+void R_ToggleSmpFrame( void ) {
+	backEndData->commands.used = 0;
+
+	r_firstSceneDrawSurf = 0;
+
+#ifdef VV_LIGHTING
+	VVLightMan.num_dlights = 0;
+#endif
+	r_numdlights = 0;
+	r_firstSceneDlight = 0;
+
+	r_numentities = 0;
+	r_firstSceneEntity = 0;
+	refEntParent = -1;
+	r_numminientities = 0;
+	r_firstSceneMiniEntity = 0;
+
+	r_numpolys = 0;
+	r_firstScenePoly = 0;
+
+	r_numpolyverts = 0;
+}
+
+
+/*
+====================
+RE_ClearScene
+
+====================
+*/
+void RE_ClearScene( void ) {
+	r_firstSceneDlight = r_numdlights;
+	r_firstSceneEntity = r_numentities;
+	r_firstScenePoly = r_numpolys;
+	refEntParent = -1;
+	r_firstSceneMiniEntity = r_numminientities;
+}
+
+/*
+===========================================================================
+
+DISCRETE POLYS
+
+===========================================================================
+*/
+
+/*
+=====================
+R_AddPolygonSurfaces
+
+Adds all the scene's polys into this view's drawsurf list
+=====================
+*/
+void R_AddPolygonSurfaces( void ) {
+	int			i;
+	shader_t	*sh;
+	srfPoly_t	*poly;
+
+	tr.currentEntityNum = TR_WORLDENT;
+	tr.shiftedEntityNum = tr.currentEntityNum << QSORT_ENTITYNUM_SHIFT;
+
+	for ( i = 0, poly = tr.refdef.polys; i < tr.refdef.numPolys ; i++, poly++ ) {
+		sh = R_GetShaderByHandle( poly->hShader );
+		R_AddDrawSurf( (surfaceType_t *)poly, sh, poly->fogIndex, qfalse );
+	}
+}
+
+/*
+=====================
+RE_AddPolyToScene
+
+=====================
+*/
+void RE_AddPolyToScene( qhandle_t hShader, int numVerts, const polyVert_t *verts, int numPolys ) {
+	srfPoly_t	*poly;
+	int			i, j;
+	int			fogIndex;
+	fog_t		*fog;
+	vec3_t		bounds[2];
+
+	if ( !tr.registered ) {
+		return;
+	}
+
+	if ( !hShader ) {
+		Com_Printf (S_COLOR_YELLOW  "WARNING: RE_AddPolyToScene: NULL poly shader\n");
+		return;
+	}
+
+	for ( j = 0; j < numPolys; j++ ) {
+		if ( r_numpolyverts + numVerts > max_polyverts || r_numpolys >= max_polys ) {
+			Com_Printf (S_COLOR_YELLOW  "WARNING: RE_AddPolyToScene: r_max_polys or r_max_polyverts reached\n");
+			return;
+		}
+
+		poly = &backEndData->polys[r_numpolys];
+		poly->surfaceType = SF_POLY;
+		poly->hShader = hShader;
+		poly->numVerts = numVerts;
+		poly->verts = &backEndData->polyVerts[r_numpolyverts];
+		
+		Com_Memcpy( poly->verts, &verts[numVerts*j], numVerts * sizeof( *verts ) );
+
+		// done.
+		r_numpolys++;
+		r_numpolyverts += numVerts;
+
+		// if no world is loaded
+		if ( tr.world == NULL ) {
+			fogIndex = 0;
+		}
+		// see if it is in a fog volume
+		else if ( tr.world->numfogs == 1 ) {
+			fogIndex = 0;
+		} else {
+			// find which fog volume the poly is in
+			VectorCopy( poly->verts[0].xyz, bounds[0] );
+			VectorCopy( poly->verts[0].xyz, bounds[1] );
+			for ( i = 1 ; i < poly->numVerts ; i++ ) {
+				AddPointToBounds( poly->verts[i].xyz, bounds[0], bounds[1] );
+			}
+			for ( fogIndex = 1 ; fogIndex < tr.world->numfogs ; fogIndex++ ) {
+				fog = &tr.world->fogs[fogIndex]; 
+				if ( bounds[1][0] >= fog->bounds[0][0]
+					&& bounds[1][1] >= fog->bounds[0][1]
+					&& bounds[1][2] >= fog->bounds[0][2]
+					&& bounds[0][0] <= fog->bounds[1][0]
+					&& bounds[0][1] <= fog->bounds[1][1]
+					&& bounds[0][2] <= fog->bounds[1][2] ) {
+					break;
+				}
+			}
+			if ( fogIndex == tr.world->numfogs ) {
+				fogIndex = 0;
+			}
+		}
+		poly->fogIndex = fogIndex;
+	}
+}
+
+
+//=================================================================================
+
+
+/*
+=====================
+RE_AddRefEntityToScene
+
+=====================
+*/
+void RE_AddRefEntityToScene( const refEntity_t *ent ) {
+	if ( !tr.registered ) {
+		return;
+	}
+
+	assert(!ent || ent->renderfx >= 0);
+
+	if (ent->reType == RT_ENT_CHAIN)
+	{ //minirefents must die.
+		return;
+	}
+
+#ifdef _DEBUG
+	if (ent->reType == RT_MODEL)
+	{
+		assert(ent->hModel || ent->ghoul2 || ent->customShader);
+	}
+#endif
+
+	if ( r_numentities >= TR_WORLDENT )
+	{
+#ifndef FINAL_BUILD
+		Com_Printf( "WARNING: RE_AddRefEntityToScene: too many entities\n");
+#endif
+		return;
+	}
+	if ( ent->reType < 0 || ent->reType >= RT_MAX_REF_ENTITY_TYPE ) {
+		Com_Error( ERR_DROP, "RE_AddRefEntityToScene: bad reType %i", ent->reType );
+	}
+
+	backEndData->entities[r_numentities].e = *ent;
+	backEndData->entities[r_numentities].lightingCalculated = qfalse;
+
+	if (ent->ghoul2)
+	{
+		CGhoul2Info_v	&ghoul2 = *((CGhoul2Info_v *)ent->ghoul2);
+
+		if (!ghoul2[0].mModel)
+		{
+#ifdef _DEBUG
+			CGhoul2Info &g2 = ghoul2[0];
+#endif
+			//DebugBreak();
+			Com_Printf("Your ghoul2 instance has no model!\n");
+		}
+	}
+
+	/*
+	if (ent->reType == RT_ENT_CHAIN)
+	{
+		refEntParent = r_numentities;
+		backEndData->entities[r_numentities].e.uRefEnt.uMini.miniStart = r_numminientities - r_firstSceneMiniEntity;
+		backEndData->entities[r_numentities].e.uRefEnt.uMini.miniCount = 0;
+	}
+	else
+	{
+	*/
+		refEntParent = -1;
+	//}
+
+	r_numentities++;
+}
+
+
+/************************************************************************************************
+ * RE_AddMiniRefEntityToScene                                                                   *
+ *    Adds a mini ref ent to the scene.  If the input parameter is null, it signifies the end   *
+ *    of the chain.  Otherwise, if there is a valid chain parent, it will be added to that.     *
+ *    If there is no parent, it will be added as a regular ref ent.                             *
+ *                                                                                              *
+ * Input                                                                                        *
+ *    ent: the mini ref ent to be added                                                         *
+ *                                                                                              *
+ * Output / Return                                                                              *
+ *    none                                                                                      *
+ *                                                                                              *
+ ************************************************************************************************/
+void RE_AddMiniRefEntityToScene( const miniRefEntity_t *ent ) 
+{
+#if 0
+	refEntity_t		*parent;
+#endif
+
+	if ( !tr.registered ) 
+	{
+		return;
+	}
+	if (!ent)
+	{
+		refEntParent = -1;
+		return;
+	}
+
+#if 1 //i hate you minirefent!
+	refEntity_t		tempEnt;
+
+	memcpy(&tempEnt, ent, sizeof(*ent));
+	memset(((char *)&tempEnt)+sizeof(*ent), 0, sizeof(tempEnt) - sizeof(*ent));
+	RE_AddRefEntityToScene(&tempEnt);
+#else
+
+	if ( ent->reType < 0 || ent->reType >= RT_MAX_REF_ENTITY_TYPE ) 
+	{
+		Com_Error( ERR_DROP, "RE_AddMiniRefEntityToScene: bad reType %i", ent->reType );
+	}
+
+	if (!r_numentities || refEntParent == -1 || r_numminientities >= MAX_MINI_ENTITIES)
+	{ //rww - add it as a refent also if we run out of minis
+//		Com_Error( ERR_DROP, "RE_AddMiniRefEntityToScene: mini without parent ref ent");
+		refEntity_t		tempEnt;
+
+		memcpy(&tempEnt, ent, sizeof(*ent));
+		memset(((char *)&tempEnt)+sizeof(*ent), 0, sizeof(tempEnt) - sizeof(*ent));
+		RE_AddRefEntityToScene(&tempEnt);
+		return;
+	}
+
+	parent = &backEndData->entities[refEntParent].e;
+	parent->uRefEnt.uMini.miniCount++;
+
+	backEndData->miniEntities[r_numminientities].e = *ent;
+	r_numminientities++;
+#endif
+}
+
+/*
+=====================
+RE_AddDynamicLightToScene
+
+=====================
+*/
+#ifndef VV_LIGHTING
+void RE_AddDynamicLightToScene( const vec3_t org, float intensity, float r, float g, float b, int additive ) {
+	dlight_t	*dl;
+
+	if ( !tr.registered ) {
+		return;
+	}
+	if ( r_numdlights >= MAX_DLIGHTS ) {
+		return;
+	}
+	if ( intensity <= 0 ) {
+		return;
+	}
+	dl = &backEndData->dlights[r_numdlights++];
+	VectorCopy (org, dl->origin);
+	dl->radius = intensity;
+	dl->color[0] = r;
+	dl->color[1] = g;
+	dl->color[2] = b;
+	dl->additive = additive;
+}
+#endif
+
+/*
+=====================
+RE_AddLightToScene
+
+=====================
+*/
+#ifndef VV_LIGHTING
+void RE_AddLightToScene( const vec3_t org, float intensity, float r, float g, float b ) {
+	RE_AddDynamicLightToScene( org, intensity, r, g, b, qfalse );
+}
+#endif
+
+/*
+=====================
+RE_AddAdditiveLightToScene
+
+=====================
+*/
+#ifndef VV_LIGHTING
+void RE_AddAdditiveLightToScene( const vec3_t org, float intensity, float r, float g, float b ) {
+	RE_AddDynamicLightToScene( org, intensity, r, g, b, qtrue );
+}
+#endif
+
+
+enum
+{
+	DECALPOLY_TYPE_NORMAL,
+	DECALPOLY_TYPE_FADE,
+	DECALPOLY_TYPE_MAX
+};
+
+#define		DECAL_FADE_TIME		1000
+
+decalPoly_t*		RE_AllocDecal		( int type );
+
+static decalPoly_t	re_decalPolys[DECALPOLY_TYPE_MAX][MAX_DECAL_POLYS];
+
+static int			re_decalPolyHead[DECALPOLY_TYPE_MAX];
+static int			re_decalPolyTotal[DECALPOLY_TYPE_MAX];
+
+/*
+===================
+RE_ClearDecals
+
+This is called to remove all decals from the world
+===================
+*/
+
+void RE_ClearDecals ( void ) 
+{
+	memset( re_decalPolys, 0, sizeof(re_decalPolys) );
+	memset( re_decalPolyHead, 0, sizeof(re_decalPolyHead) );
+	memset( re_decalPolyTotal, 0, sizeof(re_decalPolyTotal) );
+}
+
+void R_InitDecals ( void )
+{
+	RE_ClearDecals ( );
+}
+
+void RE_FreeDecal ( int type, int index )
+{
+	if ( !re_decalPolys[type][index].time )
+	{
+		return;
+	}
+	
+	if ( type == DECALPOLY_TYPE_NORMAL )
+	{
+		decalPoly_t* fade;
+
+		fade = RE_AllocDecal ( DECALPOLY_TYPE_FADE );
+
+		memcpy ( fade, &re_decalPolys[type][index], sizeof(decalPoly_t) );
+
+		fade->time = tr.refdef.time;
+		fade->fadetime = tr.refdef.time + DECAL_FADE_TIME;
+	}
+
+	re_decalPolys[type][index].time = 0;
+
+	re_decalPolyTotal[type]--;
+}
+
+/*
+===================
+RE_AllocDecal
+
+Will allways succeed, even if it requires freeing an old active mark
+===================
+*/
+decalPoly_t* RE_AllocDecal( int type ) 
+{
+	decalPoly_t	*le;
+	
+	// See if the cvar changed
+	if ( re_decalPolyTotal[type] > r_markcount->integer )
+	{
+		RE_ClearDecals ( );
+	}
+
+	le = &re_decalPolys[type][re_decalPolyHead[type]];
+
+	// If it has no time its the first occasion its been used
+	if ( le->time )
+	{
+		if ( le->time != tr.refdef.time ) 
+		{
+			int i = re_decalPolyHead[type];		
+
+			// since we are killing one that existed before, make sure we 
+			// kill all the other marks that belong to the group
+			do
+			{
+				i++;
+				if ( i >= r_markcount->integer )
+				{
+					i = 0;
+				}
+
+				// Break out on the first one thats not part of the group
+				if ( re_decalPolys[type][i].time != le->time )
+				{
+					break;
+				}
+
+				RE_FreeDecal ( type, i );
+			}
+			while ( i != re_decalPolyHead[type] );			
+
+			RE_FreeDecal ( type, re_decalPolyHead[type] );
+		}
+		else
+		{
+			RE_FreeDecal ( type, re_decalPolyHead[type] );
+		}
+	}
+
+	memset ( le, 0, sizeof(decalPoly_t) );
+	le->time = tr.refdef.time;
+
+	re_decalPolyTotal[type]++;
+
+	// Move on to the next decal poly and wrap around if need be
+	re_decalPolyHead[type]++;
+	if ( re_decalPolyHead[type] >= r_markcount->integer )
+	{
+		re_decalPolyHead[type] = 0;
+	}
+
+	return le;
+}
+
+
+/*
+=================
+RE_AddDecalToScene
+
+origin should be a point within a unit of the plane
+dir should be the plane normal
+
+temporary marks will not be stored or randomly oriented, but immediately
+passed to the renderer.
+=================
+*/
+#define	MAX_DECAL_FRAGMENTS	128
+#define	MAX_DECAL_POINTS		384
+
+void RE_AddDecalToScene ( qhandle_t decalShader, const vec3_t origin, const vec3_t dir, float orientation, float red, float green, float blue, float alpha, qboolean alphaFade, float radius, qboolean temporary )
+{
+	vec3_t			axis[3];
+	float			texCoordScale;
+	vec3_t			originalPoints[4];
+	byte			colors[4];
+	int				i, j;
+	int				numFragments;
+	markFragment_t	markFragments[MAX_DECAL_FRAGMENTS], *mf;
+	vec3_t			markPoints[MAX_DECAL_POINTS];
+	vec3_t			projection;
+
+	assert(decalShader);
+
+	if ( r_markcount->integer <= 0 && !temporary )
+	{
+		return;
+	}
+
+	if ( radius <= 0 ) 
+	{
+		Com_Error( ERR_FATAL, "RE_AddDecalToScene:  called with <= 0 radius" );
+	}
+
+	// create the texture axis
+	VectorNormalize2( dir, axis[0] );
+	PerpendicularVector( axis[1], axis[0] );
+	RotatePointAroundVector( axis[2], axis[0], axis[1], orientation );
+	CrossProduct( axis[0], axis[2], axis[1] );
+
+	texCoordScale = 0.5 * 1.0 / radius;
+
+	// create the full polygon
+	for ( i = 0 ; i < 3 ; i++ ) 
+	{
+		originalPoints[0][i] = origin[i] - radius * axis[1][i] - radius * axis[2][i];
+		originalPoints[1][i] = origin[i] + radius * axis[1][i] - radius * axis[2][i];
+		originalPoints[2][i] = origin[i] + radius * axis[1][i] + radius * axis[2][i];
+		originalPoints[3][i] = origin[i] - radius * axis[1][i] + radius * axis[2][i];
+	}
+
+	// get the fragments
+	VectorScale( dir, -20, projection );
+	numFragments = R_MarkFragments( 4, (const vec3_t*)originalPoints,
+					projection, MAX_DECAL_POINTS, markPoints[0],
+					MAX_DECAL_FRAGMENTS, markFragments );
+
+	colors[0] = red * 255;
+	colors[1] = green * 255;
+	colors[2] = blue * 255;
+	colors[3] = alpha * 255;
+
+	for ( i = 0, mf = markFragments ; i < numFragments ; i++, mf++ ) 
+	{
+		polyVert_t	*v;
+		polyVert_t	verts[MAX_VERTS_ON_DECAL_POLY];
+		decalPoly_t	*decal;
+
+		// we have an upper limit on the complexity of polygons
+		// that we store persistantly
+		if ( mf->numPoints > MAX_VERTS_ON_DECAL_POLY ) 
+		{
+			mf->numPoints = MAX_VERTS_ON_DECAL_POLY;
+		}
+
+		for ( j = 0, v = verts ; j < mf->numPoints ; j++, v++ ) 
+		{
+			vec3_t		delta;
+
+			VectorCopy( markPoints[mf->firstPoint + j], v->xyz );
+
+			VectorSubtract( v->xyz, origin, delta );
+			v->st[0] = 0.5 + DotProduct( delta, axis[1] ) * texCoordScale;
+			v->st[1] = 0.5 + DotProduct( delta, axis[2] ) * texCoordScale;
+
+			*(int *)v->modulate = *(int *)colors;
+		}
+
+		// if it is a temporary (shadow) mark, add it immediately and forget about it
+		if ( temporary ) 
+		{
+			RE_AddPolyToScene( decalShader, mf->numPoints, verts, 1 );
+			continue;
+		}
+
+		// otherwise save it persistantly
+		decal = RE_AllocDecal( DECALPOLY_TYPE_NORMAL );
+		decal->time = tr.refdef.time;
+		decal->shader = decalShader;
+		decal->poly.numVerts = mf->numPoints;
+		decal->color[0] = red;
+		decal->color[1] = green;
+		decal->color[2] = blue;
+		decal->color[3] = alpha;
+		memcpy( decal->verts, verts, mf->numPoints * sizeof( verts[0] ) );
+	}
+}
+
+/*
+===============
+R_AddDecals
+===============
+*/
+static inline void R_AddDecals ( void ) 
+{
+	int			decalPoly;
+	int			type;
+	static int  lastMarkCount = -1;
+
+	if ( r_markcount->integer != lastMarkCount )
+	{
+		if ( lastMarkCount != -1 )
+		{
+			RE_ClearDecals ( );
+		}
+
+		lastMarkCount = r_markcount->integer;
+	}
+
+	if ( r_markcount->integer <= 0 )
+	{
+		return;
+	}
+
+	for ( type = DECALPOLY_TYPE_NORMAL; type < DECALPOLY_TYPE_MAX; type ++ )
+	{
+		decalPoly = re_decalPolyHead[type];
+
+		do
+		{
+			decalPoly_t* p = &re_decalPolys[type][decalPoly];
+
+			if ( p->time )
+			{				
+				if ( p->fadetime )
+				{
+					int t;
+
+					// fade all marks out with time
+					t = tr.refdef.time - p->time;
+					if ( t < DECAL_FADE_TIME ) 
+					{
+						float fade;
+						int	  j;
+
+						fade = 255.0f * (1.0f - ((float)t / DECAL_FADE_TIME));
+						
+						for ( j = 0 ; j < p->poly.numVerts ; j++ ) 
+						{
+							p->verts[j].modulate[3] = fade;
+						}
+
+						RE_AddPolyToScene( p->shader, p->poly.numVerts, p->verts, 1 );
+					}
+					else
+					{
+						RE_FreeDecal ( type, decalPoly );
+					}
+				}
+				else
+				{
+					RE_AddPolyToScene( p->shader, p->poly.numVerts, p->verts, 1 );
+				}
+			}
+
+			decalPoly++;
+			if ( decalPoly >= r_markcount->integer )
+			{
+				decalPoly = 0;
+			}
+		}
+		while ( decalPoly != re_decalPolyHead[type] );
+	}
+}
+
+
+/*
+@@@@@@@@@@@@@@@@@@@@@
+RE_RenderScene
+
+Draw a 3D view into a part of the window, then return
+to 2D drawing.
+
+Rendering a scene may require multiple views to be rendered
+to handle mirrors,
+@@@@@@@@@@@@@@@@@@@@@
+*/
+void RE_RenderWorldEffects(void);
+void RE_RenderAutoMap(void);
+void RE_RenderScene( const refdef_t *fd ) {
+	viewParms_t		parms;
+	int				startTime;
+	static	int		lastTime = 0;
+
+	if ( !tr.registered ) {
+		return;
+	}
+	GLimp_LogComment( "====== RE_RenderScene =====\n" );
+
+	if ( r_norefresh->integer ) {
+		return;
+	}
+
+	startTime = Sys_Milliseconds()*com_timescale->value;
+
+	if (!tr.world && !( fd->rdflags & RDF_NOWORLDMODEL ) ) {
+		Com_Error (ERR_DROP, "R_RenderScene: NULL worldmodel");
+	}
+
+	Com_Memcpy( tr.refdef.text, fd->text, sizeof( tr.refdef.text ) );
+
+	tr.refdef.x = fd->x;
+	tr.refdef.y = fd->y;
+	tr.refdef.width = fd->width;
+	tr.refdef.height = fd->height;
+	tr.refdef.fov_x = fd->fov_x;
+	tr.refdef.fov_y = fd->fov_y;
+
+	VectorCopy( fd->vieworg, tr.refdef.vieworg );
+	VectorCopy( fd->viewaxis[0], tr.refdef.viewaxis[0] );
+	VectorCopy( fd->viewaxis[1], tr.refdef.viewaxis[1] );
+	VectorCopy( fd->viewaxis[2], tr.refdef.viewaxis[2] );
+
+	tr.refdef.time = fd->time;
+	tr.refdef.frametime = fd->time - lastTime;
+	lastTime = fd->time;
+
+	if (fd->rdflags & RDF_SKYBOXPORTAL)
+	{
+		skyboxportal = 1;
+	}
+
+	if (fd->rdflags & RDF_DRAWSKYBOX)
+	{
+		drawskyboxportal = 1;
+	}
+	else
+	{
+		drawskyboxportal = 0;
+	}
+
+	if (tr.refdef.frametime > 500)
+	{
+		tr.refdef.frametime = 500;
+	}
+	else if (tr.refdef.frametime < 0)
+	{
+		tr.refdef.frametime = 0;
+	}
+	tr.refdef.rdflags = fd->rdflags;
+
+	// copy the areamask data over and note if it has changed, which
+	// will force a reset of the visible leafs even if the view hasn't moved
+	tr.refdef.areamaskModified = qfalse;
+	if ( ! (tr.refdef.rdflags & RDF_NOWORLDMODEL) ) {
+		int		areaDiff;
+		int		i;
+
+		// compare the area bits
+		areaDiff = 0;
+		for (i = 0 ; i < MAX_MAP_AREA_BYTES/4 ; i++) {
+			areaDiff |= ((int *)tr.refdef.areamask)[i] ^ ((int *)fd->areamask)[i];
+			((int *)tr.refdef.areamask)[i] = ((int *)fd->areamask)[i];
+		}
+
+		if ( areaDiff ) {
+			// a door just opened or something
+			tr.refdef.areamaskModified = qtrue;
+		}
+	}
+
+
+	// derived info
+
+	tr.refdef.floatTime = tr.refdef.time * 0.001f;
+
+	tr.refdef.numDrawSurfs = r_firstSceneDrawSurf;
+	tr.refdef.drawSurfs = backEndData->drawSurfs;
+
+	tr.refdef.num_entities = r_numentities - r_firstSceneEntity;
+	tr.refdef.entities = &backEndData->entities[r_firstSceneEntity];
+	tr.refdef.miniEntities = &backEndData->miniEntities[r_firstSceneMiniEntity];
+
+#ifndef VV_LIGHTING
+	tr.refdef.num_dlights = r_numdlights - r_firstSceneDlight;
+	tr.refdef.dlights = &backEndData->dlights[r_firstSceneDlight];
+#endif
+
+	// Add the decals here because decals add polys and we need to ensure
+	// that the polys are added before the the renderer is prepared
+	if ( !(tr.refdef.rdflags & RDF_NOWORLDMODEL) ) 
+	{
+		R_AddDecals ( );
+	}
+
+	tr.refdef.numPolys = r_numpolys - r_firstScenePoly;
+	tr.refdef.polys = &backEndData->polys[r_firstScenePoly];
+
+	// turn off dynamic lighting globally by clearing all the
+	// dlights if it needs to be disabled or if vertex lighting is enabled
+#ifndef VV_LIGHTING
+	if ( r_dynamiclight->integer == 0 ||
+		 r_vertexLight->integer == 1 ) {
+		tr.refdef.num_dlights = 0;
+	}
+#endif
+
+	// a single frame may have multiple scenes draw inside it --
+	// a 3D game view, 3D status bar renderings, 3D menus, etc.
+	// They need to be distinguished by the light flare code, because
+	// the visibility state for a given surface may be different in
+	// each scene / view.
+	tr.frameSceneNum++;
+	tr.sceneCount++;
+
+	// setup view parms for the initial view
+	//
+	// set up viewport
+	// The refdef takes 0-at-the-top y coordinates, so
+	// convert to GL's 0-at-the-bottom space
+	//
+	Com_Memset( &parms, 0, sizeof( parms ) );
+	parms.viewportX = tr.refdef.x;
+	parms.viewportY = glConfig.vidHeight - ( tr.refdef.y + tr.refdef.height );
+	parms.viewportWidth = tr.refdef.width;
+	parms.viewportHeight = tr.refdef.height;
+	parms.isPortal = qfalse;
+
+	parms.fovX = tr.refdef.fov_x;
+	parms.fovY = tr.refdef.fov_y;
+
+	VectorCopy( fd->vieworg, parms.ori.origin );
+	VectorCopy( fd->viewaxis[0], parms.ori.axis[0] );
+	VectorCopy( fd->viewaxis[1], parms.ori.axis[1] );
+	VectorCopy( fd->viewaxis[2], parms.ori.axis[2] );
+
+	VectorCopy( fd->vieworg, parms.pvsOrigin );
+
+	R_RenderView( &parms );
+
+	// the next scene rendered in this frame will tack on after this one
+	r_firstSceneDrawSurf = tr.refdef.numDrawSurfs;
+	r_firstSceneEntity = r_numentities;
+	r_firstSceneMiniEntity = r_numminientities;
+	r_firstSceneDlight = r_numdlights;
+	r_firstScenePoly = r_numpolys;
+
+	refEntParent = -1;
+
+	tr.frontEndMsec += Sys_Milliseconds()*com_timescale->value - startTime;
+
+	RE_RenderWorldEffects();
+
+	if (tr.refdef.rdflags & RDF_AUTOMAP)
+	{
+		RE_RenderAutoMap();
+	}
+}
+
+#if 0 //rwwFIXMEFIXME: Disable this before release!!!!!! I am just trying to find a crash bug.
+int R_GetRNumEntities(void)
+{
+	return r_numentities;
+}
+
+void R_SetRNumEntities(int num)
+{
+	r_numentities = num;
+}
+#endif
diff --git a/codemp/renderer/tr_shade.cpp b/codemp/renderer/tr_shade.cpp
new file mode 100644
index 0000000..f8174a4
--- /dev/null
+++ b/codemp/renderer/tr_shade.cpp
@@ -0,0 +1,2475 @@
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+// tr_shade.c
+
+#include "tr_local.h"
+
+#ifdef VV_LIGHTING
+#include "tr_lightmanager.h"
+#include "../win32/glw_win_dx8.h"
+#include "../win32/win_lighteffects.h"
+#endif
+
+#include "tr_QuickSprite.h"
+
+/*
+
+  THIS ENTIRE FILE IS BACK END
+
+  This file deals with applying shaders to surface data in the tess struct.
+*/
+
+shaderCommands_t	tess;
+static qboolean	setArraysOnce;
+
+color4ub_t	styleColors[MAX_LIGHT_STYLES];
+
+extern bool g_bRenderGlowingObjects;
+
+/*
+================
+R_ArrayElementDiscrete
+
+This is just for OpenGL conformance testing, it should never be the fastest
+================
+*/
+static void APIENTRY R_ArrayElementDiscrete( GLint index ) {
+#ifndef _XBOX
+	qglColor4ubv( tess.svars.colors[ index ] );
+	if ( glState.currenttmu ) {
+		qglMultiTexCoord2fARB( 0, tess.svars.texcoords[ 0 ][ index ][0], tess.svars.texcoords[ 0 ][ index ][1] );
+		qglMultiTexCoord2fARB( 1, tess.svars.texcoords[ 1 ][ index ][0], tess.svars.texcoords[ 1 ][ index ][1] );
+	} else {
+		qglTexCoord2fv( tess.svars.texcoords[ 0 ][ index ] );
+	}
+	qglVertex3fv( tess.xyz[ index ] );
+#endif
+}
+
+/*
+===================
+R_DrawStripElements
+
+===================
+*/
+static int		c_vertexes;		// for seeing how long our average strips are
+static int		c_begins;
+static void R_DrawStripElements( int numIndexes, const glIndex_t *indexes, void ( APIENTRY *element )(GLint) ) {
+	int i;
+	glIndex_t last[3];
+	qboolean even;
+
+	c_begins++;
+
+	if ( numIndexes <= 0 ) {
+		return;
+	}
+
+	qglBegin( GL_TRIANGLE_STRIP );
+
+	// prime the strip
+	element( indexes[0] );
+	element( indexes[1] );
+	element( indexes[2] );
+	c_vertexes += 3;
+
+	last[0] = indexes[0];
+	last[1] = indexes[1];
+	last[2] = indexes[2];
+
+	even = qfalse;
+
+	for ( i = 3; i < numIndexes; i += 3 )
+	{
+		// odd numbered triangle in potential strip
+		if ( !even )
+		{
+			// check previous triangle to see if we're continuing a strip
+			if ( ( indexes[i+0] == last[2] ) && ( indexes[i+1] == last[1] ) )
+			{
+				element( indexes[i+2] );
+				c_vertexes++;
+				assert( indexes[i+2] < tess.numVertexes );
+				even = qtrue;
+			}
+			// otherwise we're done with this strip so finish it and start
+			// a new one
+			else
+			{
+				qglEnd();
+
+				qglBegin( GL_TRIANGLE_STRIP );
+				c_begins++;
+
+				element( indexes[i+0] );
+				element( indexes[i+1] );
+				element( indexes[i+2] );
+
+				c_vertexes += 3;
+
+				even = qfalse;
+			}
+		}
+		else
+		{
+			// check previous triangle to see if we're continuing a strip
+			if ( ( last[2] == indexes[i+1] ) && ( last[0] == indexes[i+0] ) )
+			{
+				element( indexes[i+2] );
+				c_vertexes++;
+
+				even = qfalse;
+			}
+			// otherwise we're done with this strip so finish it and start
+			// a new one
+			else
+			{
+				qglEnd();
+
+				qglBegin( GL_TRIANGLE_STRIP );
+				c_begins++;
+
+				element( indexes[i+0] );
+				element( indexes[i+1] );
+				element( indexes[i+2] );
+				c_vertexes += 3;
+
+				even = qfalse;
+			}
+		}
+
+		// cache the last three vertices
+		last[0] = indexes[i+0];
+		last[1] = indexes[i+1];
+		last[2] = indexes[i+2];
+	}
+
+	qglEnd();
+}
+
+
+
+/*
+==================
+R_DrawElements
+
+Optionally performs our own glDrawElements that looks for strip conditions
+instead of using the single glDrawElements call that may be inefficient
+without compiled vertex arrays.
+==================
+*/
+static void R_DrawElements( int numIndexes, const glIndex_t *indexes ) {
+	int		primitives;
+
+	primitives = r_primitives->integer;
+
+	// default is to use triangles if compiled vertex arrays are present
+	if ( primitives == 0 ) {
+		if ( qglLockArraysEXT ) {
+			primitives = 2;
+		} else {
+			primitives = 1;
+		}
+	}
+
+
+	if ( primitives == 2 ) {
+		qglDrawElements( GL_TRIANGLES, 
+						numIndexes,
+						GL_INDEX_TYPE,
+						indexes );
+		return;
+	}
+
+#ifdef _XBOX
+	if (primitives == 1 || primitives == 3)
+	{
+//		if (tess.useConstantColor)
+//		{
+//			qglDisableClientState( GL_COLOR_ARRAY );
+//			qglColor4ubv( tess.constantColor );
+//		}
+		qglDrawElements( GL_TRIANGLES, 
+						numIndexes,
+						GL_INDEX_TYPE,
+						indexes );
+#if 1	// VVFIXME : Temporary solution to try and increase framerate
+//		qglIndexedTriToStrip( numIndexes, indexes );
+#endif
+	
+		return;
+	}
+#else // _XBOX
+	if ( primitives == 1 ) {
+		R_DrawStripElements( numIndexes,  indexes, qglArrayElement );
+		return;
+	}
+	
+	if ( primitives == 3 ) {
+		R_DrawStripElements( numIndexes,  indexes, R_ArrayElementDiscrete );
+		return;
+	}
+#endif // _XBOX
+
+	// anything else will cause no drawing
+}
+
+
+
+
+/*
+=============================================================
+
+SURFACE SHADERS
+
+=============================================================
+*/
+
+/*
+=================
+R_BindAnimatedImage
+
+=================
+*/
+e_status CIN_RunCinematic (int handle);	//cl_cin.cpp
+void CIN_UploadCinematic(int handle);
+
+// de-static'd because tr_quicksprite wants it
+void R_BindAnimatedImage( textureBundle_t *bundle ) {
+	int		index;
+
+	if ( bundle->isVideoMap ) {
+		CIN_RunCinematic(bundle->videoMapHandle);
+		CIN_UploadCinematic(bundle->videoMapHandle);
+		return;
+	}
+
+	if ((r_fullbright->value /*|| tr.refdef.doFullbright */) && bundle->isLightmap)
+	{
+		GL_Bind( tr.whiteImage );
+		return;
+	}
+
+	if ( bundle->numImageAnimations <= 1 ) {
+		GL_Bind( bundle->image );
+		return;
+	}
+
+	if (backEnd.currentEntity->e.renderfx & RF_SETANIMINDEX )
+	{
+		index = backEnd.currentEntity->e.skinNum;
+	}
+	else
+	{
+		// it is necessary to do this messy calc to make sure animations line up
+		// exactly with waveforms of the same frequency
+		index = myftol( tess.shaderTime * bundle->imageAnimationSpeed * FUNCTABLE_SIZE );
+		index >>= FUNCTABLE_SIZE2;
+
+		if ( index < 0 ) {
+			index = 0;	// may happen with shader time offsets
+		}
+	}
+
+	if ( bundle->oneShotAnimMap )
+	{
+		if ( index >= bundle->numImageAnimations )
+		{
+			// stick on last frame
+			index = bundle->numImageAnimations - 1;
+		}
+	}
+	else
+	{
+		// loop
+		index %= bundle->numImageAnimations;
+	}
+
+	GL_Bind( *((image_t**)bundle->image + index) );
+}
+
+/*
+================
+DrawTris
+
+Draws triangle outlines for debugging
+================
+*/
+static void DrawTris (shaderCommands_t *input) {
+	GL_Bind( tr.whiteImage );
+	qglColor3f (1,1,1);
+
+	GL_State( GLS_POLYMODE_LINE | GLS_DEPTHMASK_TRUE );
+	qglDepthRange( 0, 0 );
+
+	qglDisableClientState (GL_COLOR_ARRAY);
+	qglDisableClientState (GL_TEXTURE_COORD_ARRAY);
+
+	qglVertexPointer (3, GL_FLOAT, 16, input->xyz);	// padded for SIMD
+
+	if (qglLockArraysEXT) {
+		qglLockArraysEXT(0, input->numVertexes);
+		GLimp_LogComment( "glLockArraysEXT\n" );
+	}
+
+	R_DrawElements( input->numIndexes, input->indexes );
+
+	if (qglUnlockArraysEXT) {
+		qglUnlockArraysEXT();
+		GLimp_LogComment( "glUnlockArraysEXT\n" );
+	}
+	qglDepthRange( 0, 1 );
+}
+
+
+/*
+================
+DrawNormals
+
+Draws vertex normals for debugging
+================
+*/
+static void DrawNormals (shaderCommands_t *input) {
+	int		i;
+	vec3_t	temp;
+
+	GL_Bind( tr.whiteImage );
+	qglColor3f (1,1,1);
+	qglDepthRange( 0, 0 );	// never occluded
+	GL_State( GLS_POLYMODE_LINE | GLS_DEPTHMASK_TRUE );
+
+	qglBegin (GL_LINES);
+	for (i = 0 ; i < input->numVertexes ; i++) {
+		qglVertex3fv (input->xyz[i]);
+		VectorMA (input->xyz[i], 2, input->normal[i], temp);
+		qglVertex3fv (temp);
+	}
+	qglEnd ();
+
+	qglDepthRange( 0, 1 );
+}
+
+/*
+==============
+RB_BeginSurface
+
+We must set some things up before beginning any tesselation,
+because a surface may be forced to perform a RB_End due
+to overflow.
+==============
+*/
+void RB_BeginSurface( shader_t *shader, int fogNum ) {
+	shader_t *state = (shader->remappedShader) ? shader->remappedShader : shader;
+
+	tess.numIndexes = 0;
+	tess.numVertexes = 0;
+	tess.shader = state;
+	tess.fogNum = fogNum;
+	tess.dlightBits = 0;		// will be OR'd in by surface functions
+	tess.xstages = state->stages;
+	tess.numPasses = state->numUnfoggedPasses;
+	tess.currentStageIteratorFunc = shader->sky ? RB_StageIteratorSky : RB_StageIteratorGeneric;
+
+	tess.shaderTime = backEnd.refdef.floatTime - tess.shader->timeOffset;
+	if (tess.shader->clampTime && tess.shaderTime >= tess.shader->clampTime) {
+		tess.shaderTime = tess.shader->clampTime;
+	}
+
+	tess.fading = false;
+
+	tess.registration++;
+}
+
+/*
+===================
+DrawMultitextured
+
+output = t0 * t1 or t0 + t1
+
+t0 = most upstream according to spec
+t1 = most downstream according to spec
+===================
+*/
+static void DrawMultitextured( shaderCommands_t *input, int stage ) {
+	shaderStage_t	*pStage;
+
+	pStage = &tess.xstages[stage];
+
+	GL_State( pStage->stateBits );
+
+	// this is an ugly hack to work around a GeForce driver
+	// bug with multitexture and clip planes
+	if ( backEnd.viewParms.isPortal ) {
+		qglPolygonMode( GL_FRONT_AND_BACK, GL_FILL );
+	}
+
+	//
+	// base
+	//
+	GL_SelectTexture( 0 );
+	qglTexCoordPointer( 2, GL_FLOAT, 0, input->svars.texcoords[0] );
+	R_BindAnimatedImage( &pStage->bundle[0] );
+
+	//
+	// lightmap/secondary pass
+	//
+	GL_SelectTexture( 1 );
+	qglEnable( GL_TEXTURE_2D );
+	qglEnableClientState( GL_TEXTURE_COORD_ARRAY );
+
+	if ( r_lightmap->integer ) {
+		GL_TexEnv( GL_REPLACE );
+	} else {
+		GL_TexEnv( tess.shader->multitextureEnv );
+	}
+
+	qglTexCoordPointer( 2, GL_FLOAT, 0, input->svars.texcoords[1] );
+
+	R_BindAnimatedImage( &pStage->bundle[1] );
+
+	R_DrawElements( input->numIndexes, input->indexes );
+
+	//
+	// disable texturing on TEXTURE1, then select TEXTURE0
+	//
+	//qglDisableClientState( GL_TEXTURE_COORD_ARRAY );
+	qglDisable( GL_TEXTURE_2D );
+#ifdef _XBOX
+	qglDisableClientState( GL_TEXTURE_COORD_ARRAY );
+#endif
+
+	GL_SelectTexture( 0 );
+}
+
+
+#ifdef VV_LIGHTING
+static void BuildTangentVectors( void ) {
+
+	memset(tess.tangent, 0, sizeof(vec3_t) * SHADER_MAX_VERTEXES);
+
+	for(int i = 0; i < tess.numIndexes; i += 3)
+	{
+		vec3_t vec1, vec2, du, dv, cp;
+
+		vec1[0] = tess.xyz[tess.indexes[i+1]][0] - tess.xyz[tess.indexes[i]][0];
+		vec1[1] = tess.svars.texcoords[0][tess.indexes[i+1]][0] - tess.svars.texcoords[0][tess.indexes[i]][0];
+		vec1[2] = tess.svars.texcoords[0][tess.indexes[i+1]][1] - tess.svars.texcoords[0][tess.indexes[i]][1];
+
+		vec2[0] = tess.xyz[tess.indexes[i+2]][0] - tess.xyz[tess.indexes[i]][0];
+		vec2[1] = tess.svars.texcoords[0][tess.indexes[i+2]][0] - tess.svars.texcoords[0][tess.indexes[i]][0];
+		vec2[2] = tess.svars.texcoords[0][tess.indexes[i+2]][1] - tess.svars.texcoords[0][tess.indexes[i]][1];
+
+		CrossProduct(vec1, vec2, cp);
+
+		du[0] = -cp[1] / cp[0];
+		dv[0] = -cp[2] / cp[0];
+
+		vec1[0] = tess.xyz[tess.indexes[i+1]][1] - tess.xyz[tess.indexes[i]][1];
+		vec1[1] = tess.svars.texcoords[0][tess.indexes[i+1]][0] - tess.svars.texcoords[0][tess.indexes[i]][0];
+		vec1[2] = tess.svars.texcoords[0][tess.indexes[i+1]][1] - tess.svars.texcoords[0][tess.indexes[i]][1];
+
+		vec2[0] = tess.xyz[tess.indexes[i+2]][1] - tess.xyz[tess.indexes[i]][1];
+		vec2[1] = tess.svars.texcoords[0][tess.indexes[i+2]][0] - tess.svars.texcoords[0][tess.indexes[i]][0];
+		vec2[2] = tess.svars.texcoords[0][tess.indexes[i+2]][1] - tess.svars.texcoords[0][tess.indexes[i]][1];
+
+		CrossProduct(vec1, vec2, cp);
+
+		du[1] = -cp[1] / cp[0];
+		dv[1] = -cp[2] / cp[0];
+
+		vec1[0] = tess.xyz[tess.indexes[i+1]][2] - tess.xyz[tess.indexes[i]][2];
+		vec1[1] = tess.svars.texcoords[0][tess.indexes[i+1]][0] - tess.svars.texcoords[0][tess.indexes[i]][0];
+		vec1[2] = tess.svars.texcoords[0][tess.indexes[i+1]][1] - tess.svars.texcoords[0][tess.indexes[i]][1];
+
+		vec2[0] = tess.xyz[tess.indexes[i+2]][2] - tess.xyz[tess.indexes[i]][2];
+		vec2[1] = tess.svars.texcoords[0][tess.indexes[i+2]][0] - tess.svars.texcoords[0][tess.indexes[i]][0];
+		vec2[2] = tess.svars.texcoords[0][tess.indexes[i+2]][1] - tess.svars.texcoords[0][tess.indexes[i]][1];
+
+		CrossProduct(vec1, vec2, cp);
+
+		du[2] = -cp[1] / cp[0];
+		dv[2] = -cp[2] / cp[0];
+
+		tess.tangent[tess.indexes[i]][0] += du[0];
+		tess.tangent[tess.indexes[i]][1] += du[1];
+		tess.tangent[tess.indexes[i]][2] += du[2];
+
+		tess.tangent[tess.indexes[i+1]][0] += du[0];
+		tess.tangent[tess.indexes[i+1]][1] += du[1];
+		tess.tangent[tess.indexes[i+1]][2] += du[2];
+
+		tess.tangent[tess.indexes[i+2]][0] += du[0];
+		tess.tangent[tess.indexes[i+2]][1] += du[1];
+		tess.tangent[tess.indexes[i+2]][2] += du[2];
+	}
+
+	for(i = 0; i < tess.numVertexes; i++)
+	{
+		VectorNormalizeFast(tess.tangent[i]);
+	}
+}
+#endif // VV_LIGHTING
+
+/*
+===================
+ProjectDlightTexture
+
+Perform dynamic lighting with another rendering pass
+===================
+*/
+#ifndef VV_LIGHTING
+
+static void ProjectDlightTexture2( void ) {
+	int		i, l;
+	vec3_t	origin;
+	byte	clipBits[SHADER_MAX_VERTEXES];
+	MAC_STATIC float	texCoordsArray[SHADER_MAX_VERTEXES][2];
+	MAC_STATIC float	oldTexCoordsArray[SHADER_MAX_VERTEXES][2];
+	MAC_STATIC float	vertCoordsArray[SHADER_MAX_VERTEXES][4];
+	unsigned int		colorArray[SHADER_MAX_VERTEXES];
+	glIndex_t	hitIndexes[SHADER_MAX_INDEXES];
+	int		numIndexes;
+	float	radius;
+	int		fogging;
+	shaderStage_t *dStage;
+	vec3_t	posa;
+	vec3_t	posb;
+	vec3_t	posc;
+	vec3_t	dist;
+	vec3_t	e1;
+	vec3_t	e2;
+	vec3_t	normal;
+	float	fac,modulate;
+	vec3_t	floatColor;
+	byte colorTemp[4];
+
+	int		needResetVerts=0;
+
+	if ( !backEnd.refdef.num_dlights ) 
+	{
+		return;
+	}
+
+	for ( l = 0 ; l < backEnd.refdef.num_dlights ; l++ )
+	{
+		dlight_t	*dl;
+
+		if ( !( tess.dlightBits & ( 1 << l ) ) ) {
+			continue;	// this surface definately doesn't have any of this light
+		}
+
+		dl = &backEnd.refdef.dlights[l];
+		VectorCopy( dl->transformed, origin );
+		radius = dl->radius;
+
+		int		clipall = 63;
+		for ( i = 0 ; i < tess.numVertexes ; i++) 
+		{
+			int		clip;
+			VectorSubtract( origin, tess.xyz[i], dist );
+
+			clip = 0;
+			if (  dist[0] < -radius ) 
+			{
+				clip |= 1;
+			}
+			else if ( dist[0] > radius ) 
+			{
+				clip |= 2;
+			}
+			if (  dist[1] < -radius ) 
+			{
+				clip |= 4;
+			}
+			else if ( dist[1] > radius ) 
+			{
+				clip |= 8;
+			}
+			if (  dist[2] < -radius ) 
+			{
+				clip |= 16;
+			}
+			else if ( dist[2] > radius ) 
+			{
+				clip |= 32;
+			}
+
+			clipBits[i] = clip;
+			clipall &= clip;
+		}
+		if ( clipall ) 
+		{
+			continue;	// this surface doesn't have any of this light
+		}
+		floatColor[0] = dl->color[0] * 255.0f;
+		floatColor[1] = dl->color[1] * 255.0f;
+		floatColor[2] = dl->color[2] * 255.0f;
+
+		// build a list of triangles that need light
+		numIndexes = 0;
+		for ( i = 0 ; i < tess.numIndexes ; i += 3 ) 
+		{
+			int		a, b, c;
+
+			a = tess.indexes[i];
+			b = tess.indexes[i+1];
+			c = tess.indexes[i+2];
+			if ( clipBits[a] & clipBits[b] & clipBits[c] ) 
+			{
+				continue;	// not lighted
+			}
+
+			// copy the vertex positions
+			VectorCopy(tess.xyz[a],posa);
+			VectorCopy(tess.xyz[b],posb);
+			VectorCopy(tess.xyz[c],posc);
+
+			VectorSubtract( posa, posb,e1);
+			VectorSubtract( posc, posb,e2);
+			CrossProduct(e1,e2,normal);
+// rjr - removed for hacking 			if ( (!r_dlightBacks->integer && DotProduct(normal,origin)-DotProduct(normal,posa) <= 0.0f) || // backface
+			if ( DotProduct(normal,origin)-DotProduct(normal,posa) <= 0.0f || // backface
+				DotProduct(normal,normal) < 1E-8f) // junk triangle
+			{
+				continue;
+			}
+			VectorNormalize(normal);
+			fac=DotProduct(normal,origin)-DotProduct(normal,posa);
+			if (fac >= radius)  // out of range
+			{
+				continue;
+			}
+			modulate = 1.0f-((fac*fac) / (radius*radius));
+			fac = 0.5f/sqrtf(radius*radius - fac*fac);
+
+			// save the verts
+			VectorCopy(posa,vertCoordsArray[numIndexes]);
+			VectorCopy(posb,vertCoordsArray[numIndexes+1]);
+			VectorCopy(posc,vertCoordsArray[numIndexes+2]);
+
+			// now we need e1 and e2 to be an orthonormal basis
+			if (DotProduct(e1,e1) > DotProduct(e2,e2))
+			{
+				VectorNormalize(e1);
+				CrossProduct(e1,normal,e2);
+			}
+			else
+			{
+				VectorNormalize(e2);
+				CrossProduct(normal,e2,e1);
+			}
+			VectorScale(e1,fac,e1);
+			VectorScale(e2,fac,e2);
+
+			VectorSubtract( posa, origin,dist);
+			texCoordsArray[numIndexes][0]=DotProduct(dist,e1)+0.5f;
+			texCoordsArray[numIndexes][1]=DotProduct(dist,e2)+0.5f;
+
+			VectorSubtract( posb, origin,dist);
+			texCoordsArray[numIndexes+1][0]=DotProduct(dist,e1)+0.5f;
+			texCoordsArray[numIndexes+1][1]=DotProduct(dist,e2)+0.5f;
+
+			VectorSubtract( posc, origin,dist);
+			texCoordsArray[numIndexes+2][0]=DotProduct(dist,e1)+0.5f;
+			texCoordsArray[numIndexes+2][1]=DotProduct(dist,e2)+0.5f;
+
+			if ((texCoordsArray[numIndexes][0] < 0.0f && texCoordsArray[numIndexes+1][0] < 0.0f && texCoordsArray[numIndexes+2][0] < 0.0f) ||
+				(texCoordsArray[numIndexes][0] > 1.0f && texCoordsArray[numIndexes+1][0] > 1.0f && texCoordsArray[numIndexes+2][0] > 1.0f) ||
+				(texCoordsArray[numIndexes][1] < 0.0f && texCoordsArray[numIndexes+1][1] < 0.0f && texCoordsArray[numIndexes+2][1] < 0.0f) ||
+				(texCoordsArray[numIndexes][1] > 1.0f && texCoordsArray[numIndexes+1][1] > 1.0f && texCoordsArray[numIndexes+2][1] > 1.0f) )
+			{
+				continue; // didn't end up hitting this tri
+			}
+			/* old code, get from the svars = wrong
+			oldTexCoordsArray[numIndexes][0]=tess.svars.texcoords[0][a][0];
+			oldTexCoordsArray[numIndexes][1]=tess.svars.texcoords[0][a][1];
+			oldTexCoordsArray[numIndexes+1][0]=tess.svars.texcoords[0][b][0];
+			oldTexCoordsArray[numIndexes+1][1]=tess.svars.texcoords[0][b][1];
+			oldTexCoordsArray[numIndexes+2][0]=tess.svars.texcoords[0][c][0];
+			oldTexCoordsArray[numIndexes+2][1]=tess.svars.texcoords[0][c][1];
+			*/
+			oldTexCoordsArray[numIndexes][0]=tess.texCoords[a][0][0];
+			oldTexCoordsArray[numIndexes][1]=tess.texCoords[a][0][1];
+			oldTexCoordsArray[numIndexes+1][0]=tess.texCoords[b][0][0];
+			oldTexCoordsArray[numIndexes+1][1]=tess.texCoords[b][0][1];
+			oldTexCoordsArray[numIndexes+2][0]=tess.texCoords[c][0][0];
+			oldTexCoordsArray[numIndexes+2][1]=tess.texCoords[c][0][1];
+
+			colorTemp[0] = myftol(floatColor[0] * modulate);
+			colorTemp[1] = myftol(floatColor[1] * modulate);
+			colorTemp[2] = myftol(floatColor[2] * modulate);
+			colorTemp[3] = 255;
+			colorArray[numIndexes]=*(unsigned int *)colorTemp;
+			colorArray[numIndexes+1]=*(unsigned int *)colorTemp;
+			colorArray[numIndexes+2]=*(unsigned int *)colorTemp;
+
+			hitIndexes[numIndexes] = numIndexes;
+			hitIndexes[numIndexes+1] = numIndexes+1;
+			hitIndexes[numIndexes+2] = numIndexes+2;
+			numIndexes += 3;
+
+			if (numIndexes>=SHADER_MAX_VERTEXES-3)
+			{
+				break; // we are out of space, so we are done :)
+			}
+		}
+
+		if ( !numIndexes ) {
+			continue;
+		}
+
+		//don't have fog enabled when we redraw with alpha test, or it will double over
+		//and screw the tri up -rww
+		if (r_drawfog->value == 2 && 
+			tr.world &&
+			(tess.fogNum == tr.world->globalFog || tess.fogNum == tr.world->numfogs))
+		{
+			fogging = qglIsEnabled(GL_FOG);
+
+			if (fogging)
+			{
+				qglDisable(GL_FOG);
+			}
+		}
+		else
+		{
+			fogging = 0;
+		}
+
+
+		dStage = NULL;
+		if (tess.shader && qglActiveTextureARB)
+		{
+			int i = 0;
+			while (i < tess.shader->numUnfoggedPasses)
+			{
+				const int blendBits = (GLS_SRCBLEND_BITS+GLS_DSTBLEND_BITS);
+				if (((tess.shader->stages[i].bundle[0].image && !tess.shader->stages[i].bundle[0].isLightmap && !tess.shader->stages[i].bundle[0].numTexMods && tess.shader->stages[i].bundle[0].tcGen != TCGEN_ENVIRONMENT_MAPPED && tess.shader->stages[i].bundle[0].tcGen != TCGEN_FOG) ||
+					 (tess.shader->stages[i].bundle[1].image && !tess.shader->stages[i].bundle[1].isLightmap && !tess.shader->stages[i].bundle[1].numTexMods && tess.shader->stages[i].bundle[1].tcGen != TCGEN_ENVIRONMENT_MAPPED && tess.shader->stages[i].bundle[1].tcGen != TCGEN_FOG)) &&
+					(tess.shader->stages[i].stateBits & blendBits) == 0 )
+				{ //only use non-lightmap opaque stages
+                    dStage = &tess.shader->stages[i];
+					break;
+				}
+				i++;
+			}
+		}
+		if (!needResetVerts)
+		{
+			needResetVerts=1;
+			if (qglUnlockArraysEXT) 
+			{
+				qglUnlockArraysEXT();
+				GLimp_LogComment( "glUnlockArraysEXT\n" );
+			}
+		}
+		qglVertexPointer (3, GL_FLOAT, 16, vertCoordsArray);	// padded for SIMD
+
+		if (dStage)
+		{
+			GL_SelectTexture( 0 );
+			GL_State(0);
+			qglTexCoordPointer( 2, GL_FLOAT, 0, oldTexCoordsArray[0] );
+			if (dStage->bundle[0].image && !dStage->bundle[0].isLightmap && !dStage->bundle[0].numTexMods && dStage->bundle[0].tcGen != TCGEN_ENVIRONMENT_MAPPED && dStage->bundle[0].tcGen != TCGEN_FOG)
+			{
+				R_BindAnimatedImage( &dStage->bundle[0] );
+			}
+			else
+			{
+				R_BindAnimatedImage( &dStage->bundle[1] );
+			}
+
+			GL_SelectTexture( 1 );
+			qglEnable( GL_TEXTURE_2D );
+			qglEnableClientState( GL_TEXTURE_COORD_ARRAY );
+			qglTexCoordPointer( 2, GL_FLOAT, 0, texCoordsArray[0] );
+			qglEnableClientState( GL_COLOR_ARRAY );
+			qglColorPointer( 4, GL_UNSIGNED_BYTE, 0, colorArray );
+			GL_Bind( tr.dlightImage );
+			GL_TexEnv( GL_MODULATE );
+
+
+			GL_State(GLS_SRCBLEND_ONE | GLS_DSTBLEND_ONE | GLS_DEPTHFUNC_EQUAL);// | GLS_ATEST_GT_0);
+
+			R_DrawElements( numIndexes, hitIndexes );
+
+			qglDisable( GL_TEXTURE_2D );
+			GL_SelectTexture(0);
+		}
+		else
+		{
+			qglEnableClientState( GL_TEXTURE_COORD_ARRAY );
+			qglTexCoordPointer( 2, GL_FLOAT, 0, texCoordsArray[0] );
+
+			qglEnableClientState( GL_COLOR_ARRAY );
+			qglColorPointer( 4, GL_UNSIGNED_BYTE, 0, colorArray );
+
+			GL_Bind( tr.dlightImage );
+			// include GLS_DEPTHFUNC_EQUAL so alpha tested surfaces don't add light
+			// where they aren't rendered
+			if ( dl->additive ) {
+				GL_State( GLS_SRCBLEND_ONE | GLS_DSTBLEND_ONE | GLS_DEPTHFUNC_EQUAL );
+			}
+			else {
+				GL_State( GLS_SRCBLEND_DST_COLOR | GLS_DSTBLEND_ONE | GLS_DEPTHFUNC_EQUAL );
+			}
+
+			R_DrawElements( numIndexes, hitIndexes );
+		}
+
+		if (fogging)
+		{
+			qglEnable(GL_FOG);
+		}
+
+		backEnd.pc.c_totalIndexes += numIndexes;
+		backEnd.pc.c_dlightIndexes += numIndexes;
+	}
+	if (needResetVerts)
+	{
+		qglVertexPointer (3, GL_FLOAT, 16, tess.xyz);	// padded for SIMD
+		if (qglLockArraysEXT)
+		{
+			qglLockArraysEXT(0, tess.numVertexes);
+			GLimp_LogComment( "glLockArraysEXT\n" );
+		}
+	}
+}
+
+static void ProjectDlightTexture( void ) {
+	int		i, l;
+	vec3_t	origin;
+	float	*texCoords;
+	byte	*colors;
+	byte	clipBits[SHADER_MAX_VERTEXES];
+	MAC_STATIC float	texCoordsArray[SHADER_MAX_VERTEXES][2];
+	byte	colorArray[SHADER_MAX_VERTEXES][4];
+	glIndex_t	hitIndexes[SHADER_MAX_INDEXES];
+	int		numIndexes;
+	float	scale;
+	float	radius;
+	int		fogging;
+	vec3_t	floatColor;
+	shaderStage_t *dStage;
+
+	if ( !backEnd.refdef.num_dlights ) {
+		return;
+	}
+
+	for ( l = 0 ; l < backEnd.refdef.num_dlights ; l++ ) {
+		dlight_t	*dl;
+
+		if ( !( tess.dlightBits & ( 1 << l ) ) ) {
+			continue;	// this surface definately doesn't have any of this light
+		}
+
+		texCoords = texCoordsArray[0];
+		colors = colorArray[0];
+
+		dl = &backEnd.refdef.dlights[l];
+		VectorCopy( dl->transformed, origin );
+		radius = dl->radius;
+		scale = 1.0f / radius;
+
+		floatColor[0] = dl->color[0] * 255.0f;
+		floatColor[1] = dl->color[1] * 255.0f;
+		floatColor[2] = dl->color[2] * 255.0f;
+
+		for ( i = 0 ; i < tess.numVertexes ; i++, texCoords += 2, colors += 4 ) {
+			vec3_t	dist;
+			int		clip;
+			float	modulate;
+
+			backEnd.pc.c_dlightVertexes++;
+
+			VectorSubtract( origin, tess.xyz[i], dist );
+			
+			int l = 1;
+			int bestIndex = 0;
+			float greatest = tess.normal[i][0];
+			if (greatest < 0.0f)
+			{
+				greatest = -greatest;
+			}
+
+			if (VectorCompare(tess.normal[i], vec3_origin))
+			{ //damn you terrain!
+				bestIndex = 2;
+			}
+			else
+			{
+				while (l < 3)
+				{
+					if ((tess.normal[i][l] > greatest && tess.normal[i][l] > 0.0f) ||
+						(tess.normal[i][l] < -greatest && tess.normal[i][l] < 0.0f))
+					{
+						greatest = tess.normal[i][l];
+						if (greatest < 0.0f)
+						{
+							greatest = -greatest;
+						}
+						bestIndex = l;
+					}
+					l++;
+				}
+			}
+
+			float dUse = 0.0f;
+			const float maxScale = 1.5f;
+			const float maxGroundScale = 1.4f;
+			const float lightScaleTolerance = 0.1f;
+
+			if (bestIndex == 2)
+			{
+				dUse = origin[2]-tess.xyz[i][2];
+				if (dUse < 0.0f)
+				{
+					dUse = -dUse;
+				}
+				dUse = (radius*0.5f)/dUse;
+				if (dUse > maxGroundScale)
+				{
+					dUse = maxGroundScale;
+				}
+				else if (dUse < 0.1f)
+				{
+					dUse = 0.1f;
+				}
+
+				if (VectorCompare(tess.normal[i], vec3_origin) ||
+					tess.normal[i][0] > lightScaleTolerance ||
+					tess.normal[i][0] < -lightScaleTolerance ||
+					tess.normal[i][1] > lightScaleTolerance ||
+					tess.normal[i][1] < -lightScaleTolerance)
+				{ //if not perfectly flat, we must use a constant dist
+					scale = 1.0f / radius;
+				}
+				else
+				{
+					scale = 1.0f / (radius*dUse);
+				}
+
+				texCoords[0] = 0.5f + dist[0] * scale;
+				texCoords[1] = 0.5f + dist[1] * scale;
+			}
+			else if (bestIndex == 1)
+			{
+				dUse = origin[1]-tess.xyz[i][1];
+				if (dUse < 0.0f)
+				{
+					dUse = -dUse;
+				}
+				dUse = (radius*0.5f)/dUse;
+				if (dUse > maxScale)
+				{
+					dUse = maxScale;
+				}
+				else if (dUse < 0.1f)
+				{
+					dUse = 0.1f;
+				}
+				if (tess.normal[i][0] > lightScaleTolerance ||
+					tess.normal[i][0] < -lightScaleTolerance ||
+					tess.normal[i][2] > lightScaleTolerance ||
+					tess.normal[i][2] < -lightScaleTolerance)
+				{ //if not perfectly flat, we must use a constant dist
+					scale = 1.0f / radius;
+				}
+				else
+				{
+					scale = 1.0f / (radius*dUse);
+				}
+
+				texCoords[0] = 0.5f + dist[0] * scale;
+				texCoords[1] = 0.5f + dist[2] * scale;
+			}
+			else
+			{
+				dUse = origin[0]-tess.xyz[i][0];
+				if (dUse < 0.0f)
+				{
+					dUse = -dUse;
+				}
+				dUse = (radius*0.5f)/dUse;
+				if (dUse > maxScale)
+				{
+					dUse = maxScale;
+				}
+				else if (dUse < 0.1f)
+				{
+					dUse = 0.1f;
+				}
+				if (tess.normal[i][2] > lightScaleTolerance ||
+					tess.normal[i][2] < -lightScaleTolerance ||
+					tess.normal[i][1] > lightScaleTolerance ||
+					tess.normal[i][1] < -lightScaleTolerance)
+				{ //if not perfectly flat, we must use a constant dist
+					scale = 1.0f / radius;
+				}
+				else
+				{
+					scale = 1.0f / (radius*dUse);
+				}
+
+				texCoords[0] = 0.5f + dist[1] * scale;
+				texCoords[1] = 0.5f + dist[2] * scale;
+			}
+
+			clip = 0;
+			if ( texCoords[0] < 0.0f ) {
+				clip |= 1;
+			} else if ( texCoords[0] > 1.0f ) {
+				clip |= 2;
+			}
+			if ( texCoords[1] < 0.0f ) {
+				clip |= 4;
+			} else if ( texCoords[1] > 1.0f ) {
+				clip |= 8;
+			}
+			// modulate the strength based on the height and color
+			if ( dist[bestIndex] > radius ) {
+				clip |= 16;
+				modulate = 0.0f;
+			} else if ( dist[bestIndex] < -radius ) {
+				clip |= 32;
+				modulate = 0.0f;
+			} else {
+				dist[bestIndex] = Q_fabs(dist[bestIndex]);
+				if ( dist[bestIndex] < radius * 0.5f ) {
+					modulate = 1.0f;
+				} else {
+					modulate = 2.0f * (radius - dist[bestIndex]) * scale;
+				}
+			}
+			clipBits[i] = clip;
+
+			colors[0] = myftol(floatColor[0] * modulate);
+			colors[1] = myftol(floatColor[1] * modulate);
+			colors[2] = myftol(floatColor[2] * modulate);
+			colors[3] = 255;
+		}
+
+		// build a list of triangles that need light
+		numIndexes = 0;
+		for ( i = 0 ; i < tess.numIndexes ; i += 3 ) {
+			int		a, b, c;
+
+			a = tess.indexes[i];
+			b = tess.indexes[i+1];
+			c = tess.indexes[i+2];
+			if ( clipBits[a] & clipBits[b] & clipBits[c] ) {
+				continue;	// not lighted
+			}
+			hitIndexes[numIndexes] = a;
+			hitIndexes[numIndexes+1] = b;
+			hitIndexes[numIndexes+2] = c;
+			numIndexes += 3;
+		}
+
+		if ( !numIndexes ) {
+			continue;
+		}
+
+		//don't have fog enabled when we redraw with alpha test, or it will double over
+		//and screw the tri up -rww
+		if (r_drawfog->value == 2 && 
+			tr.world &&
+			(tess.fogNum == tr.world->globalFog || tess.fogNum == tr.world->numfogs))
+		{
+			fogging = qglIsEnabled(GL_FOG);
+
+			if (fogging)
+			{
+				qglDisable(GL_FOG);
+			}
+		}
+		else
+		{
+			fogging = 0;
+		}
+
+
+		dStage = NULL;
+		if (tess.shader && qglActiveTextureARB)
+		{
+			int i = 0;
+			while (i < tess.shader->numUnfoggedPasses)
+			{
+				const int blendBits = (GLS_SRCBLEND_BITS+GLS_DSTBLEND_BITS);
+				if (((tess.shader->stages[i].bundle[0].image && !tess.shader->stages[i].bundle[0].isLightmap && !tess.shader->stages[i].bundle[0].numTexMods) ||
+					 (tess.shader->stages[i].bundle[1].image && !tess.shader->stages[i].bundle[1].isLightmap && !tess.shader->stages[i].bundle[1].numTexMods)) &&
+					(tess.shader->stages[i].stateBits & blendBits) == 0 )
+				{ //only use non-lightmap opaque stages
+                    dStage = &tess.shader->stages[i];
+					break;
+				}
+				i++;
+			}
+		}
+
+		if (dStage)
+		{
+			GL_SelectTexture( 0 );
+			GL_State(0);
+			qglTexCoordPointer( 2, GL_FLOAT, 0, tess.svars.texcoords[0] );
+			if (dStage->bundle[0].image && !dStage->bundle[0].isLightmap && !dStage->bundle[0].numTexMods)
+			{
+				R_BindAnimatedImage( &dStage->bundle[0] );
+			}
+			else
+			{
+				R_BindAnimatedImage( &dStage->bundle[1] );
+			}
+
+			GL_SelectTexture( 1 );
+			qglEnable( GL_TEXTURE_2D );
+			qglEnableClientState( GL_TEXTURE_COORD_ARRAY );
+			qglTexCoordPointer( 2, GL_FLOAT, 0, texCoordsArray[0] );
+			qglEnableClientState( GL_COLOR_ARRAY );
+			qglColorPointer( 4, GL_UNSIGNED_BYTE, 0, colorArray );
+			GL_Bind( tr.dlightImage );
+			GL_TexEnv( GL_MODULATE );
+
+			GL_State(GLS_SRCBLEND_ONE | GLS_DSTBLEND_ONE | GLS_DEPTHFUNC_EQUAL);// | GLS_ATEST_GT_0);
+
+			R_DrawElements( numIndexes, hitIndexes );
+
+			qglDisable( GL_TEXTURE_2D );
+			GL_SelectTexture(0);
+		}
+		else
+		{
+			qglEnableClientState( GL_TEXTURE_COORD_ARRAY );
+			qglTexCoordPointer( 2, GL_FLOAT, 0, texCoordsArray[0] );
+
+			qglEnableClientState( GL_COLOR_ARRAY );
+			qglColorPointer( 4, GL_UNSIGNED_BYTE, 0, colorArray );
+
+			GL_Bind( tr.dlightImage );
+			// include GLS_DEPTHFUNC_EQUAL so alpha tested surfaces don't add light
+			// where they aren't rendered
+			if ( dl->additive ) {
+				GL_State( GLS_SRCBLEND_ONE | GLS_DSTBLEND_ONE | GLS_DEPTHFUNC_EQUAL );
+			}
+			else {
+				GL_State( GLS_SRCBLEND_DST_COLOR | GLS_DSTBLEND_ONE | GLS_DEPTHFUNC_EQUAL );
+			}
+
+			R_DrawElements( numIndexes, hitIndexes );
+		}
+
+		if (fogging)
+		{
+			qglEnable(GL_FOG);
+		}
+
+		backEnd.pc.c_totalIndexes += numIndexes;
+		backEnd.pc.c_dlightIndexes += numIndexes;
+	}
+}
+
+#endif // VV_LIGHTING
+
+
+/*
+===================
+RB_FogPass
+
+Blends a fog texture on top of everything else
+===================
+*/
+static void RB_FogPass( void ) {
+	fog_t		*fog;
+	int			i;
+
+	qglEnableClientState( GL_COLOR_ARRAY );
+	qglColorPointer( 4, GL_UNSIGNED_BYTE, 0, tess.svars.colors );
+
+	qglEnableClientState( GL_TEXTURE_COORD_ARRAY);
+	qglTexCoordPointer( 2, GL_FLOAT, 0, tess.svars.texcoords[0] );
+
+	fog = tr.world->fogs + tess.fogNum;
+
+	for ( i = 0; i < tess.numVertexes; i++ ) {
+		* ( int * )&tess.svars.colors[i] = fog->colorInt;
+	}
+
+	RB_CalcFogTexCoords( ( float * ) tess.svars.texcoords[0] );
+
+	GL_Bind( tr.fogImage );
+
+	if ( tess.shader->fogPass == FP_EQUAL ) {
+		GL_State( GLS_SRCBLEND_SRC_ALPHA | GLS_DSTBLEND_ONE_MINUS_SRC_ALPHA | GLS_DEPTHFUNC_EQUAL );
+	} else {
+		GL_State( GLS_SRCBLEND_SRC_ALPHA | GLS_DSTBLEND_ONE_MINUS_SRC_ALPHA );
+	}
+
+	R_DrawElements( tess.numIndexes, tess.indexes );
+}
+
+/*
+===============
+ComputeColors
+===============
+*/
+#ifdef _XBOX
+static void ComputeColors( shaderStage_t *pStage, int forceRGBGen )
+{
+	int i;
+	qboolean killGen = qfalse;
+	alphaGen_t forceAlphaGen = pStage->alphaGen;//set this up so we can override below
+
+	if ( tess.shader != tr.projectionShadowShader && tess.shader != tr.shadowShader && 
+		( backEnd.currentEntity->e.renderfx & (RF_DISINTEGRATE1|RF_DISINTEGRATE2)))
+	{
+		RB_CalcDisintegrateColors( tess.svars.colors );
+		RB_CalcDisintegrateVertDeform();
+
+		// We've done some custom alpha and color stuff, so we can skip the rest.  Let it do fog though
+		killGen = qtrue;
+	}
+
+	//
+	// rgbGen
+	//
+	if ( !forceRGBGen )
+	{
+		forceRGBGen = pStage->rgbGen;
+	}
+
+	if ( backEnd.currentEntity->e.renderfx & RF_VOLUMETRIC ) // does not work for rotated models, technically, this should also be a CGEN type, but that would entail adding new shader commands....which is too much work for one thing
+	{
+		int			i;
+		float		*normal, dot;
+		DWORD *color;
+		int			numVertexes;
+
+		normal = tess.normal[0];
+		color = tess.svars.colors;
+
+		numVertexes = tess.numVertexes;
+
+		for ( i = 0 ; i < numVertexes ; i++, normal += 4, color ++) 
+		{
+			dot = DotProduct( normal, backEnd.refdef.viewaxis[0] );
+
+			dot *= dot * dot * dot;
+
+			if ( dot < 0.2f ) // so low, so just clamp it
+			{
+				dot = 0.0f;
+			}
+
+			*color = D3DCOLOR_RGBA( (int)(backEnd.currentEntity->e.shaderRGBA[0] * (1-dot)),
+				(int)(backEnd.currentEntity->e.shaderRGBA[0] * (1-dot)),
+				(int)(backEnd.currentEntity->e.shaderRGBA[0] * (1-dot)),
+				(int)(backEnd.currentEntity->e.shaderRGBA[0] * (1-dot)) );
+		}
+
+		killGen = qtrue;
+	}
+
+	if (killGen)
+	{
+		goto avoidGen;
+	}
+
+	DWORD color;
+
+	switch ( forceRGBGen )
+	{
+	case CGEN_IDENTITY:
+		memset( tess.svars.colors, 0xffffffff, sizeof(DWORD) * tess.numVertexes );
+		break;
+	default:
+	case CGEN_IDENTITY_LIGHTING:
+		color = ((tr.identityLightByte & 0xff) << 24 |
+			(tr.identityLightByte & 0xff) << 16 |
+			(tr.identityLightByte & 0xff) << 8  |
+			(tr.identityLightByte & 0xff) << 0);
+		memset( tess.svars.colors, color, sizeof(DWORD) * tess.numVertexes );
+		break;
+	case CGEN_LIGHTING_DIFFUSE:
+#ifdef VV_LIGHTING
+		VVLightMan.RB_CalcDiffuseColor( tess.svars.colors );
+#else
+		RB_CalcDiffuseColor( ( unsigned char * ) tess.svars.colors );
+#endif
+		break;
+	case CGEN_LIGHTING_DIFFUSE_ENTITY:
+#ifdef VV_LIGHTING
+		VVLightMan.RB_CalcDiffuseEntityColor( tess.svars.colors );
+#else
+		RB_CalcDiffuseEntityColor( ( unsigned char * ) tess.svars.colors );
+#endif
+		if ( forceAlphaGen == AGEN_IDENTITY && 
+			backEnd.currentEntity->e.shaderRGBA[3] == 0xff 
+			)
+		{
+			forceAlphaGen = AGEN_SKIP;	//already got it in this set since it does all 4 components
+		}
+		break;
+	case CGEN_EXACT_VERTEX:
+		for( i = 0; i < tess.numVertexes; i++ )
+		{
+			tess.svars.colors[i] = D3DCOLOR_RGBA( (int)(tess.vertexColors[i][0]),
+				(int)(tess.vertexColors[i][1]),
+				(int)(tess.vertexColors[i][2]),
+				(int)(tess.vertexColors[i][3]) );
+		}
+		break;
+	case CGEN_CONST:
+		for ( i = 0; i < tess.numVertexes; i++ ) {
+			tess.svars.colors[i] = D3DCOLOR_RGBA( (int)(pStage->constantColor[0]),
+				(int)(pStage->constantColor[1]),
+				(int)(pStage->constantColor[2]),
+				(int)(pStage->constantColor[3]) );
+		}
+		break;
+	case CGEN_VERTEX:
+		if ( tr.identityLight == 1 )
+		{
+			for( i = 0; i < tess.numVertexes; i++ )
+			{
+				tess.svars.colors[i] = D3DCOLOR_RGBA( (int)(tess.vertexColors[i][0]),
+					(int)(tess.vertexColors[i][1]),
+					(int)(tess.vertexColors[i][2]),
+					(int)(tess.vertexColors[i][3]));
+			}
+		}
+		else
+		{
+			for ( i = 0; i < tess.numVertexes; i++ )
+			{
+				tess.svars.colors[i] = D3DCOLOR_RGBA( (int)(tess.vertexColors[i][0] * tr.identityLight),
+					(int)(tess.vertexColors[i][1] * tr.identityLight),
+					(int)(tess.vertexColors[i][2] * tr.identityLight),
+					(int)(tess.vertexColors[i][3]));
+			}
+		}
+		break;
+	case CGEN_ONE_MINUS_VERTEX:
+		if ( tr.identityLight == 1 )
+		{
+			for ( i = 0; i < tess.numVertexes; i++ )
+			{
+				tess.svars.colors[i] = D3DCOLOR_XRGB( (int)(255 - tess.vertexColors[i][0]),
+					(int)(255 - tess.vertexColors[i][1]),
+					(int)(255 - tess.vertexColors[i][2]));
+			}
+		}
+		else
+		{
+			for ( i = 0; i < tess.numVertexes; i++ )
+			{
+				tess.svars.colors[i] = D3DCOLOR_XRGB( (int)((255 - tess.vertexColors[i][0]) * tr.identityLight),
+					(int)((255 - tess.vertexColors[i][1]) * tr.identityLight),
+					(int)((255 - tess.vertexColors[i][2]) * tr.identityLight));
+			}
+		}
+		break;
+	case CGEN_FOG:
+		{
+			fog_t		*fog;
+
+			fog = tr.world->fogs + tess.fogNum;
+
+			for ( i = 0; i < tess.numVertexes; i++ ) {
+				* ( int * )&tess.svars.colors[i] = fog->colorInt;
+			}
+		}
+		break;
+	case CGEN_WAVEFORM:
+		RB_CalcWaveColor( &pStage->rgbWave, tess.svars.colors );
+		break;
+	case CGEN_ENTITY:
+		RB_CalcColorFromEntity( tess.svars.colors );
+		if ( forceAlphaGen == AGEN_IDENTITY && 
+			backEnd.currentEntity->e.shaderRGBA[3] == 0xff 
+			)
+		{
+			forceAlphaGen = AGEN_SKIP;	//already got it in this set since it does all 4 components
+		}
+		break;
+	case CGEN_ONE_MINUS_ENTITY:
+		RB_CalcColorFromOneMinusEntity( tess.svars.colors );
+		break;
+	case CGEN_LIGHTMAPSTYLE:
+		for ( i = 0; i < tess.numVertexes; i++ ) 
+		{
+			tess.svars.colors[i] = *(DWORD *)styleColors[pStage->lightmapStyle];
+		}
+		break;
+	}
+
+	//
+	// alphaGen
+	//
+	DWORD rgb;
+	switch ( pStage->alphaGen )
+	{
+	case AGEN_SKIP:
+		break;
+	case AGEN_IDENTITY:
+		if ( forceRGBGen != CGEN_IDENTITY &&  forceRGBGen != CGEN_LIGHTING_DIFFUSE ) {
+			if ( ( forceRGBGen == CGEN_VERTEX && tr.identityLight != 1 ) ||
+				forceRGBGen != CGEN_VERTEX ) {
+					for ( i = 0; i < tess.numVertexes; i++ ) {
+						rgb = (DWORD)((tess.svars.colors[i]) & 0x00ffffff);
+						tess.svars.colors[i] = rgb | ((255 & 0xff) << 24);
+					}
+				}
+		}
+		break;
+	case AGEN_CONST:
+		if ( forceRGBGen != CGEN_CONST ) {
+			for ( i = 0; i < tess.numVertexes; i++ ) {
+				rgb = (DWORD)((tess.svars.colors[i]) & 0x00ffffff);
+				tess.svars.colors[i] = rgb | ((pStage->constantColor[3] & 0xff) << 24);
+			}
+		}
+		break;
+	case AGEN_WAVEFORM:
+		RB_CalcWaveAlpha( &pStage->alphaWave, tess.svars.colors );
+		break;
+	case AGEN_LIGHTING_SPECULAR:
+		RB_CalcSpecularAlpha( tess.svars.colors );
+		break;
+	case AGEN_ENTITY:
+		if ( forceRGBGen != CGEN_ENTITY ) { //already got it in the CGEN_entity since it does all 4 components
+			RB_CalcAlphaFromEntity( tess.svars.colors );
+		}
+		break;
+	case AGEN_ONE_MINUS_ENTITY:
+		RB_CalcAlphaFromOneMinusEntity( tess.svars.colors );
+		break;
+	case AGEN_VERTEX:
+		if ( forceRGBGen != CGEN_VERTEX ) {
+			for ( i = 0; i < tess.numVertexes; i++ ) {
+				rgb = (DWORD)((tess.svars.colors[i]) & 0x00ffffff);
+				tess.svars.colors[i] = rgb | ((tess.vertexColors[i][3] & 0xff) << 24);
+			}
+		}
+		break;
+	case AGEN_ONE_MINUS_VERTEX:
+		for ( i = 0; i < tess.numVertexes; i++ )
+		{
+			rgb = (DWORD)((tess.svars.colors[i]) & 0x00ffffff);
+			tess.svars.colors[i] = rgb | (((255 - tess.vertexColors[i][3]) & 0xff) << 24);
+		}
+		break;
+	case AGEN_PORTAL:
+		{
+			unsigned char alpha;
+
+			for ( i = 0; i < tess.numVertexes; i++ )
+			{
+				float len;
+				vec3_t v;
+
+				VectorSubtract( tess.xyz[i], backEnd.viewParms.ori.origin, v );
+				len = VectorLength( v );
+
+				len /= tess.shader->portalRange;
+
+				if ( len < 0 )
+				{
+					alpha = 0;
+				}
+				else if ( len > 1 )
+				{
+					alpha = 0xff;
+				}
+				else
+				{
+					alpha = len * 0xff;
+				}
+
+				rgb = (DWORD)((tess.svars.colors[i]) & 0x00ffffff);
+				tess.svars.colors[i] = rgb | ((alpha & 0xff) << 24);
+			}
+		}
+		break;
+	case AGEN_BLEND:
+		if ( forceRGBGen != CGEN_VERTEX ) 
+		{
+			for ( i = 0; i < tess.numVertexes; i++ ) 
+			{
+				rgb = (DWORD)((tess.svars.colors[i]) & 0x00ffffff);
+				tess.svars.colors[i] = rgb | ((tess.vertexAlphas[i][pStage->index] & 0xff) << 24);
+			}
+		}
+		break;
+	}
+
+avoidGen:
+	//
+	// fog adjustment for colors to fade out as fog increases
+	//
+	if ( tess.fogNum )
+	{
+		switch ( pStage->adjustColorsForFog )
+		{
+		case ACFF_MODULATE_RGB:
+			RB_CalcModulateColorsByFog( tess.svars.colors );
+			break;
+		case ACFF_MODULATE_ALPHA:
+			RB_CalcModulateAlphasByFog( tess.svars.colors );
+			break;
+		case ACFF_MODULATE_RGBA:
+			RB_CalcModulateRGBAsByFog( tess.svars.colors );
+			break;
+		case ACFF_NONE:
+			break;
+		}
+	}
+}
+#else // _XBOX
+static void ComputeColors( shaderStage_t *pStage, int forceRGBGen )
+{
+	int			i;
+	color4ub_t	*colors = tess.svars.colors;
+	qboolean killGen = qfalse;
+	alphaGen_t forceAlphaGen = pStage->alphaGen;//set this up so we can override below
+
+	if ( tess.shader != tr.projectionShadowShader && tess.shader != tr.shadowShader && 
+			( backEnd.currentEntity->e.renderfx & (RF_DISINTEGRATE1|RF_DISINTEGRATE2)))
+	{
+		RB_CalcDisintegrateColors( (unsigned char *)tess.svars.colors );
+		RB_CalcDisintegrateVertDeform();
+
+		// We've done some custom alpha and color stuff, so we can skip the rest.  Let it do fog though
+		killGen = qtrue;
+	}
+
+	//
+	// rgbGen
+	//
+	if ( !forceRGBGen )
+	{
+		forceRGBGen = pStage->rgbGen;
+	}
+
+	if ( backEnd.currentEntity->e.renderfx & RF_VOLUMETRIC ) // does not work for rotated models, technically, this should also be a CGEN type, but that would entail adding new shader commands....which is too much work for one thing
+	{
+		int			i;
+		float		*normal, dot;
+		unsigned char *color;
+		int			numVertexes;
+
+		normal = tess.normal[0];
+		color = tess.svars.colors[0];
+
+		numVertexes = tess.numVertexes;
+
+		for ( i = 0 ; i < numVertexes ; i++, normal += 4, color += 4) 
+		{
+			dot = DotProduct( normal, backEnd.refdef.viewaxis[0] );
+
+			dot *= dot * dot * dot;
+
+			if ( dot < 0.2f ) // so low, so just clamp it
+			{
+				dot = 0.0f;
+			}
+
+			color[0] = color[1] = color[2] = color[3] = myftol( backEnd.currentEntity->e.shaderRGBA[0] * (1-dot) );
+		}
+
+		killGen = qtrue;
+	}
+
+	if (killGen)
+	{
+		goto avoidGen;
+	}
+
+	//
+	// rgbGen
+	//
+	switch ( forceRGBGen )
+	{
+		case CGEN_IDENTITY:
+			Com_Memset( tess.svars.colors, 0xff, tess.numVertexes * 4 );
+			break;
+		default:
+		case CGEN_IDENTITY_LIGHTING:
+			Com_Memset( tess.svars.colors, tr.identityLightByte, tess.numVertexes * 4 );
+			break;
+		case CGEN_LIGHTING_DIFFUSE:
+			RB_CalcDiffuseColor( ( unsigned char * ) tess.svars.colors );
+			break;
+		case CGEN_LIGHTING_DIFFUSE_ENTITY:
+			RB_CalcDiffuseEntityColor( ( unsigned char * ) tess.svars.colors );
+			if ( forceAlphaGen == AGEN_IDENTITY && 
+				 backEnd.currentEntity->e.shaderRGBA[3] == 0xff 
+				)
+			{
+				forceAlphaGen = AGEN_SKIP;	//already got it in this set since it does all 4 components
+			}
+			break;
+		case CGEN_EXACT_VERTEX:
+			Com_Memcpy( tess.svars.colors, tess.vertexColors, tess.numVertexes * sizeof( tess.vertexColors[0] ) );
+			break;
+		case CGEN_CONST:
+			for ( i = 0; i < tess.numVertexes; i++ ) {
+				*(int *)tess.svars.colors[i] = *(int *)pStage->constantColor;
+			}
+			break;
+		case CGEN_VERTEX:
+			if ( tr.identityLight == 1 )
+			{
+				Com_Memcpy( tess.svars.colors, tess.vertexColors, tess.numVertexes * sizeof( tess.vertexColors[0] ) );
+			}
+			else
+			{
+				for ( i = 0; i < tess.numVertexes; i++ )
+				{
+					tess.svars.colors[i][0] = tess.vertexColors[i][0] * tr.identityLight;
+					tess.svars.colors[i][1] = tess.vertexColors[i][1] * tr.identityLight;
+					tess.svars.colors[i][2] = tess.vertexColors[i][2] * tr.identityLight;
+					tess.svars.colors[i][3] = tess.vertexColors[i][3];
+				}
+			}
+			break;
+		case CGEN_ONE_MINUS_VERTEX:
+			if ( tr.identityLight == 1 )
+			{
+				for ( i = 0; i < tess.numVertexes; i++ )
+				{
+					tess.svars.colors[i][0] = 255 - tess.vertexColors[i][0];
+					tess.svars.colors[i][1] = 255 - tess.vertexColors[i][1];
+					tess.svars.colors[i][2] = 255 - tess.vertexColors[i][2];
+				}
+			}
+			else
+			{
+				for ( i = 0; i < tess.numVertexes; i++ )
+				{
+					tess.svars.colors[i][0] = ( 255 - tess.vertexColors[i][0] ) * tr.identityLight;
+					tess.svars.colors[i][1] = ( 255 - tess.vertexColors[i][1] ) * tr.identityLight;
+					tess.svars.colors[i][2] = ( 255 - tess.vertexColors[i][2] ) * tr.identityLight;
+				}
+			}
+			break;
+		case CGEN_FOG:
+			{
+				fog_t		*fog;
+
+				fog = tr.world->fogs + tess.fogNum;
+
+				for ( i = 0; i < tess.numVertexes; i++ ) {
+					* ( int * )&tess.svars.colors[i] = fog->colorInt;
+				}
+			}
+			break;
+		case CGEN_WAVEFORM:
+			RB_CalcWaveColor( &pStage->rgbWave, ( unsigned char * ) tess.svars.colors );
+			break;
+		case CGEN_ENTITY:
+			RB_CalcColorFromEntity( ( unsigned char * ) tess.svars.colors );
+			if ( forceAlphaGen == AGEN_IDENTITY && 
+				 backEnd.currentEntity->e.shaderRGBA[3] == 0xff 
+				)
+			{
+				forceAlphaGen = AGEN_SKIP;	//already got it in this set since it does all 4 components
+			}
+			break;
+		case CGEN_ONE_MINUS_ENTITY:
+			RB_CalcColorFromOneMinusEntity( ( unsigned char * ) tess.svars.colors );
+			break;
+		case CGEN_LIGHTMAPSTYLE:
+			for ( i = 0; i < tess.numVertexes; i++ ) 
+			{
+				*(unsigned *)&colors[i] = *(unsigned *)styleColors[pStage->lightmapStyle];
+			}
+			break;
+	}
+
+	//
+	// alphaGen
+	//
+	switch ( pStage->alphaGen )
+	{
+	case AGEN_SKIP:
+		break;
+	case AGEN_IDENTITY:
+		if ( forceRGBGen != CGEN_IDENTITY ) {
+			if ( ( forceRGBGen == CGEN_VERTEX && tr.identityLight != 1 ) ||
+				 forceRGBGen != CGEN_VERTEX ) {
+				for ( i = 0; i < tess.numVertexes; i++ ) {
+					tess.svars.colors[i][3] = 0xff;
+				}
+			}
+		}
+		break;
+	case AGEN_CONST:
+		if ( forceRGBGen != CGEN_CONST ) {
+			for ( i = 0; i < tess.numVertexes; i++ ) {
+				tess.svars.colors[i][3] = pStage->constantColor[3];
+			}
+		}
+		break;
+	case AGEN_WAVEFORM:
+		RB_CalcWaveAlpha( &pStage->alphaWave, ( unsigned char * ) tess.svars.colors );
+		break;
+	case AGEN_LIGHTING_SPECULAR:
+		RB_CalcSpecularAlpha( ( unsigned char * ) tess.svars.colors );
+		break;
+	case AGEN_ENTITY:
+		RB_CalcAlphaFromEntity( ( unsigned char * ) tess.svars.colors );
+		break;
+	case AGEN_ONE_MINUS_ENTITY:
+		RB_CalcAlphaFromOneMinusEntity( ( unsigned char * ) tess.svars.colors );
+		break;
+    case AGEN_VERTEX:
+		if ( forceRGBGen != CGEN_VERTEX ) {
+			for ( i = 0; i < tess.numVertexes; i++ ) {
+				tess.svars.colors[i][3] = tess.vertexColors[i][3];
+			}
+		}
+        break;
+    case AGEN_ONE_MINUS_VERTEX:
+        for ( i = 0; i < tess.numVertexes; i++ )
+        {
+			tess.svars.colors[i][3] = 255 - tess.vertexColors[i][3];
+        }
+        break;
+	case AGEN_PORTAL:
+		{
+			unsigned char alpha;
+
+			for ( i = 0; i < tess.numVertexes; i++ )
+			{
+				float len;
+				vec3_t v;
+
+				VectorSubtract( tess.xyz[i], backEnd.viewParms.ori.origin, v );
+				len = VectorLength( v );
+
+				len /= tess.shader->portalRange;
+
+				if ( len < 0 )
+				{
+					alpha = 0;
+				}
+				else if ( len > 1 )
+				{
+					alpha = 0xff;
+				}
+				else
+				{
+					alpha = len * 0xff;
+				}
+
+				tess.svars.colors[i][3] = alpha;
+			}
+		}
+		break;
+	case AGEN_BLEND:
+		if ( forceRGBGen != CGEN_VERTEX ) 
+		{
+			for ( i = 0; i < tess.numVertexes; i++ ) 
+			{
+				colors[i][3] = tess.vertexAlphas[i][pStage->index]; //rwwRMG - added support
+			}
+		}
+		break;
+	}
+avoidGen:
+	//
+	// fog adjustment for colors to fade out as fog increases
+	//
+	if ( tess.fogNum )
+	{
+		switch ( pStage->adjustColorsForFog )
+		{
+		case ACFF_MODULATE_RGB:
+			RB_CalcModulateColorsByFog( ( unsigned char * ) tess.svars.colors );
+			break;
+		case ACFF_MODULATE_ALPHA:
+			RB_CalcModulateAlphasByFog( ( unsigned char * ) tess.svars.colors );
+			break;
+		case ACFF_MODULATE_RGBA:
+			RB_CalcModulateRGBAsByFog( ( unsigned char * ) tess.svars.colors );
+			break;
+		case ACFF_NONE:
+			break;
+		}
+	}
+}
+#endif
+
+/*
+===============
+ComputeTexCoords
+===============
+*/
+static void ComputeTexCoords( shaderStage_t *pStage ) {
+	int		i;
+	int		b;
+    float	*texcoords;
+
+	for ( b = 0; b < NUM_TEXTURE_BUNDLES; b++ ) {
+		int tm;
+
+        texcoords = (float *)tess.svars.texcoords[b];
+		//
+		// generate the texture coordinates
+		//
+		switch ( pStage->bundle[b].tcGen )
+		{
+		case TCGEN_IDENTITY:
+			Com_Memset( tess.svars.texcoords[b], 0, sizeof( float ) * 2 * tess.numVertexes );
+			break;
+		case TCGEN_TEXTURE:
+			for ( i = 0 ; i < tess.numVertexes ; i++ ) {
+				tess.svars.texcoords[b][i][0] = tess.texCoords[i][0][0];
+				tess.svars.texcoords[b][i][1] = tess.texCoords[i][0][1];
+			}
+			break;
+		case TCGEN_LIGHTMAP:
+			for ( i = 0 ; i < tess.numVertexes ; i++,texcoords+=2 ) {
+				texcoords[0] = tess.texCoords[i][1][0];
+				texcoords[1] = tess.texCoords[i][1][1];
+			}
+			break;
+		case TCGEN_LIGHTMAP1:
+			for ( i = 0 ; i < tess.numVertexes ; i++,texcoords+=2 ) {
+				texcoords[0] = tess.texCoords[i][2][0];
+				texcoords[1] = tess.texCoords[i][2][1];
+			}
+			break;
+		case TCGEN_LIGHTMAP2:
+			for ( i = 0 ; i < tess.numVertexes ; i++,texcoords+=2 ) {
+				texcoords[0] = tess.texCoords[i][3][0];
+				texcoords[1] = tess.texCoords[i][3][1];
+			}
+			break;
+		case TCGEN_LIGHTMAP3:
+			for ( i = 0 ; i < tess.numVertexes ; i++,texcoords+=2 ) {
+				texcoords[0] = tess.texCoords[i][4][0];
+				texcoords[1] = tess.texCoords[i][4][1];
+			}
+			break;
+		case TCGEN_VECTOR:
+			for ( i = 0 ; i < tess.numVertexes ; i++ ) {
+				tess.svars.texcoords[b][i][0] = DotProduct( tess.xyz[i], pStage->bundle[b].tcGenVectors[0] );
+				tess.svars.texcoords[b][i][1] = DotProduct( tess.xyz[i], pStage->bundle[b].tcGenVectors[1] );
+			}
+			break;
+		case TCGEN_FOG:
+			RB_CalcFogTexCoords( ( float * ) tess.svars.texcoords[b] );
+			break;
+		case TCGEN_ENVIRONMENT_MAPPED:
+//#ifdef VV_LIGHTING
+//			tess.shader->stages[tess.currentPass].isEnvironment = qtrue;
+//#else
+			RB_CalcEnvironmentTexCoords( ( float * ) tess.svars.texcoords[b] );
+//#endif
+			break;
+		case TCGEN_BAD:
+			return;
+		}
+
+		//
+		// alter texture coordinates
+		//
+		for ( tm = 0; tm < pStage->bundle[b].numTexMods ; tm++ ) {
+			switch ( pStage->bundle[b].texMods[tm].type )
+			{
+			case TMOD_NONE:
+				tm = TR_MAX_TEXMODS;		// break out of for loop
+				break;
+
+			case TMOD_TURBULENT:
+				RB_CalcTurbulentTexCoords( &pStage->bundle[b].texMods[tm].wave, 
+						                 ( float * ) tess.svars.texcoords[b] );
+				break;
+
+			case TMOD_ENTITY_TRANSLATE:
+				RB_CalcScrollTexCoords( backEnd.currentEntity->e.shaderTexCoord,
+									 ( float * ) tess.svars.texcoords[b] );
+				break;
+
+			case TMOD_SCROLL:
+				RB_CalcScrollTexCoords( pStage->bundle[b].texMods[tm].translate,	//scroll unioned
+										 ( float * ) tess.svars.texcoords[b] );
+				break;
+
+			case TMOD_SCALE:
+				RB_CalcScaleTexCoords( pStage->bundle[b].texMods[tm].translate,
+									 ( float * ) tess.svars.texcoords[b] );
+				break;
+			
+			case TMOD_STRETCH:
+				RB_CalcStretchTexCoords( &pStage->bundle[b].texMods[tm].wave, 
+						               ( float * ) tess.svars.texcoords[b] );
+				break;
+
+			case TMOD_TRANSFORM:
+				RB_CalcTransformTexCoords( &pStage->bundle[b].texMods[tm],
+						                 ( float * ) tess.svars.texcoords[b] );
+				break;
+
+			case TMOD_ROTATE:
+				RB_CalcRotateTexCoords( pStage->bundle[b].texMods[tm].translate[0],
+										( float * ) tess.svars.texcoords[b] );
+				break;
+
+			default:
+				Com_Error( ERR_DROP, "ERROR: unknown texmod '%d' in shader '%s'\n", pStage->bundle[b].texMods[tm].type, tess.shader->name );
+				break;
+			}
+		}
+	}
+}
+
+void ForceAlpha(unsigned char *dstColors, int TR_ForceEntAlpha)
+{
+	int	i;
+
+	dstColors += 3;
+
+	for ( i = 0; i < tess.numVertexes; i++, dstColors += 4 )
+	{
+		*dstColors = TR_ForceEntAlpha;
+	}
+}
+
+/*
+** RB_IterateStagesGeneric
+*/
+static vec4_t	GLFogOverrideColors[GLFOGOVERRIDE_MAX] =
+{
+	{ 0.0, 0.0, 0.0, 1.0 },	// GLFOGOVERRIDE_NONE
+	{ 0.0, 0.0, 0.0, 1.0 },	// GLFOGOVERRIDE_BLACK
+	{ 1.0, 1.0, 1.0, 1.0 }	// GLFOGOVERRIDE_WHITE
+};
+
+static const float logtestExp2 = (sqrt( -log( 1.0 / 255.0 ) ));
+extern bool tr_stencilled; //tr_backend.cpp
+static void RB_IterateStagesGeneric( shaderCommands_t *input )
+{
+	int stage;
+	bool	UseGLFog = false;
+	bool	FogColorChange = false;
+	fog_t	*fog = NULL;
+
+	if (tess.fogNum && tess.shader->fogPass && (tess.fogNum == tr.world->globalFog || tess.fogNum == tr.world->numfogs) 
+		&& r_drawfog->value == 2) 
+	{	// only gl fog global fog and the "special fog"
+		fog = tr.world->fogs + tess.fogNum;
+
+		if (tr.rangedFog)
+		{ //ranged fog, used for sniper scope
+			float fStart = fog->parms.depthForOpaque;
+
+			if (tr.rangedFog < 0.0f)
+			{ //special designer override
+				fStart = -tr.rangedFog;
+			}
+			else
+			{
+				//the greater tr.rangedFog is, the more fog we will get between the view point and cull distance
+				if ((tr.distanceCull-fStart) < tr.rangedFog)
+				{ //assure a minimum range between fog beginning and cutoff distance
+					fStart = tr.distanceCull-tr.rangedFog;
+
+					if (fStart < 16.0f)
+					{
+						fStart = 16.0f;
+					}
+				}
+			}
+
+			qglFogi(GL_FOG_MODE, GL_LINEAR);
+			
+			qglFogf(GL_FOG_START, fStart);
+			qglFogf(GL_FOG_END, tr.distanceCull);
+		}
+		else
+		{
+			qglFogi(GL_FOG_MODE, GL_EXP2);
+			qglFogf(GL_FOG_DENSITY, logtestExp2 / fog->parms.depthForOpaque);
+		}
+		if ( g_bRenderGlowingObjects )
+		{
+			const float fogColor[3] = { 0.0f, 0.0f, 0.0f };
+			qglFogfv(GL_FOG_COLOR, fogColor );
+		}
+		else
+		{
+			qglFogfv(GL_FOG_COLOR, fog->parms.color);
+		}
+		qglEnable(GL_FOG);
+		UseGLFog = true;
+	}
+
+	for ( stage = 0; stage < input->shader->numUnfoggedPasses; stage++ )
+	{
+		shaderStage_t *pStage = &tess.xstages[stage];
+		int forceRGBGen = 0;
+		int stateBits = 0;
+
+		if ( !pStage->active )
+		{
+			assert(pStage->active);//wtf?
+			break;
+		}
+
+		// Reject this stage if it's not a glow stage but we are doing a glow pass.
+		if ( g_bRenderGlowingObjects && !pStage->glow )
+		{
+			continue;
+		}
+
+#ifdef _XBOX
+		tess.currentPass = stage;
+#endif
+
+		if ( stage && r_lightmap->integer && !( pStage->bundle[0].isLightmap || pStage->bundle[1].isLightmap || pStage->bundle[0].vertexLightmap ) )
+		{
+			break;
+		}
+
+		stateBits = pStage->stateBits;
+
+		if ( backEnd.currentEntity )
+		{
+			assert(backEnd.currentEntity->e.renderfx >= 0);
+
+			if ( backEnd.currentEntity->e.renderfx & RF_DISINTEGRATE1 )
+			{
+				// we want to be able to rip a hole in the thing being disintegrated, and by doing the depth-testing it avoids some kinds of artefacts, but will probably introduce others?
+				stateBits = GLS_SRCBLEND_SRC_ALPHA | GLS_DSTBLEND_ONE_MINUS_SRC_ALPHA | GLS_DEPTHMASK_TRUE | GLS_ATEST_GE_C0;
+			}
+
+			if ( backEnd.currentEntity->e.renderfx & RF_RGB_TINT )
+			{//want to use RGBGen from ent
+				forceRGBGen = CGEN_ENTITY;
+			}
+		}
+
+		if (pStage->ss && pStage->ss->surfaceSpriteType)
+		{
+			// We check for surfacesprites AFTER drawing everything else
+			continue;
+		}
+
+		if (UseGLFog)
+		{
+			if (pStage->mGLFogColorOverride)
+			{
+				qglFogfv(GL_FOG_COLOR, GLFogOverrideColors[pStage->mGLFogColorOverride]);
+				FogColorChange = true;
+			}
+			else if (FogColorChange && fog)
+			{
+				FogColorChange = false;
+				qglFogfv(GL_FOG_COLOR, fog->parms.color);
+			}
+		}
+
+#ifdef _XBOX
+		qglDisable(GL_LIGHTING);
+#endif
+
+		if (!input->fading)
+		{ //this means ignore this, while we do a fade-out
+			ComputeColors( pStage, forceRGBGen );
+		}
+		ComputeTexCoords( pStage );
+
+		if ( !setArraysOnce )
+		{
+			qglEnableClientState( GL_COLOR_ARRAY );
+			qglColorPointer( 4, GL_UNSIGNED_BYTE, 0, input->svars.colors );
+		}
+
+#ifdef VV_LIGHTING
+		if(pStage->rgbGen == CGEN_LIGHTING_DIFFUSE ||
+			pStage->rgbGen == CGEN_LIGHTING_DIFFUSE_ENTITY)
+		{
+            qglEnableClientState( GL_NORMAL_ARRAY );
+			qglNormalPointer(GL_FLOAT, 16, tess.normal );
+		}
+
+		if(pStage->isSpecular)
+		{
+			qglEnableClientState( GL_NORMAL_ARRAY );
+			qglNormalPointer(GL_FLOAT, 16, tess.normal );
+			if(!tess.setTangents)
+                BuildTangentVectors();
+			qglTexCoordPointer( 2, GL_FLOAT, 0, input->svars.texcoords[0] );
+			R_BindAnimatedImage( &pStage->bundle[0] );
+			GL_State( stateBits );
+			glw_state->lightEffects->RenderSpecular();
+			qglDisableClientState( GL_NORMAL_ARRAY );
+			continue;
+		}
+		if(pStage->isEnvironment)
+		{
+			qglEnableClientState( GL_NORMAL_ARRAY );
+			qglNormalPointer( GL_FLOAT, 16, tess.normal );
+			R_BindAnimatedImage( &pStage->bundle[0] );
+			GL_State( stateBits );
+			glw_state->lightEffects->RenderEnvironment();
+			qglDisableClientState( GL_NORMAL_ARRAY );
+			continue;
+		}
+		if(pStage->isBumpMap)
+		{
+			qglEnableClientState( GL_NORMAL_ARRAY );
+			qglNormalPointer( GL_FLOAT, 16, tess.normal );
+			if(!tess.setTangents)
+                BuildTangentVectors();
+			GL_SelectTexture( 0 );
+			R_BindAnimatedImage( &pStage->bundle[0] );
+			GL_SelectTexture( 1 );
+			qglEnable( GL_TEXTURE_2D );
+			qglEnableClientState( GL_TEXTURE_COORD_ARRAY );
+			R_BindAnimatedImage( &pStage->bundle[1] );
+			GL_State( stateBits );
+			glw_state->lightEffects->RenderBump();
+			qglDisable( GL_TEXTURE_2D );
+			qglDisableClientState( GL_TEXTURE_COORD_ARRAY );
+			GL_SelectTexture( 0 );
+			qglDisableClientState( GL_NORMAL_ARRAY );
+			continue;
+		}
+#endif // VV_LIGHTING
+
+		//
+		// do multitexture
+		//
+		if ( pStage->bundle[1].image != 0 )
+		{
+			DrawMultitextured( input, stage );
+		}
+		else
+		{
+			static bool lStencilled = false;
+
+			if ( !setArraysOnce )
+			{
+				qglTexCoordPointer( 2, GL_FLOAT, 0, input->svars.texcoords[0] );
+			}
+
+			//
+			// set state
+			//
+			if ( (tess.shader == tr.distortionShader) || 
+				 (backEnd.currentEntity && (backEnd.currentEntity->e.renderfx & RF_DISTORTION)) )
+			{ //special distortion effect -rww
+				//tr.screenImage should have been set for this specific entity before we got in here.
+				GL_Bind( tr.screenImage );
+				GL_Cull(CT_TWO_SIDED);
+			}
+			else if ( pStage->bundle[0].vertexLightmap && ( r_vertexLight->integer && !r_uiFullScreen->integer ) && r_lightmap->integer )
+			{
+				GL_Bind( tr.whiteImage );
+			}
+			else 
+				R_BindAnimatedImage( &pStage->bundle[0] );
+
+			if (tess.shader == tr.distortionShader &&
+				glConfig.stencilBits >= 4)
+			{ //draw it to the stencil buffer!
+				tr_stencilled = true;
+				lStencilled = true;
+				qglEnable(GL_STENCIL_TEST);
+				qglStencilFunc(GL_ALWAYS, 1, 0xFFFFFFFF);
+				qglStencilOp(GL_KEEP, GL_KEEP, GL_INCR);
+				qglColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
+
+				//don't depthmask, don't blend.. don't do anything
+				GL_State(0);
+			}
+			else if (backEnd.currentEntity && (backEnd.currentEntity->e.renderfx & RF_FORCE_ENT_ALPHA))
+			{
+				ForceAlpha((unsigned char *) tess.svars.colors, backEnd.currentEntity->e.shaderRGBA[3]);
+				if (backEnd.currentEntity->e.renderfx & RF_ALPHA_DEPTH)
+				{ //depth write, so faces through the model will be stomped over by nearer ones. this works because
+					//we draw RF_FORCE_ENT_ALPHA stuff after everything else, including standard alpha surfs.
+					GL_State(GLS_SRCBLEND_SRC_ALPHA | GLS_DSTBLEND_ONE_MINUS_SRC_ALPHA | GLS_DEPTHMASK_TRUE);
+				}
+				else
+				{
+					GL_State(GLS_SRCBLEND_SRC_ALPHA | GLS_DSTBLEND_ONE_MINUS_SRC_ALPHA);
+				}
+			}
+			else
+			{
+				GL_State( stateBits );
+			}
+
+			//
+			// draw
+			//
+			R_DrawElements( input->numIndexes, input->indexes );	
+
+			if (lStencilled)
+			{ //re-enable the color buffer, disable stencil test
+				lStencilled = false;
+				qglDisable(GL_STENCIL_TEST);
+				qglColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
+			}
+		}
+
+#ifdef VV_LIGHTING
+		// Lighting may have been turned on above
+		qglDisable(GL_LIGHTING);
+		qglDisableClientState( GL_NORMAL_ARRAY );
+#endif
+	}
+	if (FogColorChange)
+	{
+		qglFogfv(GL_FOG_COLOR, fog->parms.color);
+	}
+}
+
+
+/*
+** RB_StageIteratorGeneric
+*/
+void RB_StageIteratorGeneric( void )
+{
+	shaderCommands_t *input;
+	int stage;
+
+	input = &tess;
+
+	RB_DeformTessGeometry();
+
+	//
+	// log this call
+	//
+#ifndef _XBOX
+	if ( r_logFile->integer ) 
+	{
+		// don't just call LogComment, or we will get
+		// a call to va() every frame!
+		GLimp_LogComment( va("--- RB_StageIteratorGeneric( %s ) ---\n", tess.shader->name) );
+	}
+#endif
+
+	//
+	// set face culling appropriately
+	//
+	GL_Cull( input->shader->cullType );
+
+	// set polygon offset if necessary
+	if ( input->shader->polygonOffset )
+	{
+		qglEnable( GL_POLYGON_OFFSET_FILL );
+		qglPolygonOffset( r_offsetFactor->value, r_offsetUnits->value );
+	}
+
+	//
+	// if there is only a single pass then we can enable color
+	// and texture arrays before we compile, otherwise we need
+	// to avoid compiling those arrays since they will change
+	// during multipass rendering
+	//
+	if ( tess.numPasses > 1 || input->shader->multitextureEnv )
+	{
+		setArraysOnce = qfalse;
+		qglDisableClientState (GL_COLOR_ARRAY);
+		qglDisableClientState (GL_TEXTURE_COORD_ARRAY);
+	}
+	else
+	{
+		setArraysOnce = qtrue;
+
+		qglEnableClientState( GL_COLOR_ARRAY);
+		qglColorPointer( 4, GL_UNSIGNED_BYTE, 0, tess.svars.colors );
+
+		qglEnableClientState( GL_TEXTURE_COORD_ARRAY);
+		qglTexCoordPointer( 2, GL_FLOAT, 0, tess.svars.texcoords[0] );
+	}
+
+	//
+	// lock XYZ
+	//
+	qglVertexPointer (3, GL_FLOAT, 16, input->xyz);	// padded for SIMD
+	if (qglLockArraysEXT)
+	{
+		qglLockArraysEXT(0, input->numVertexes);
+		GLimp_LogComment( "glLockArraysEXT\n" );
+	}
+
+	//
+	// enable color and texcoord arrays after the lock if necessary
+	//
+	if ( !setArraysOnce )
+	{
+		qglEnableClientState( GL_TEXTURE_COORD_ARRAY );
+		qglEnableClientState( GL_COLOR_ARRAY );
+	}
+
+	//
+	// call shader function
+	//
+	RB_IterateStagesGeneric( input );
+
+	// 
+	// now do any dynamic lighting needed
+	//
+	if ( tess.dlightBits && tess.shader->sort <= SS_OPAQUE
+		&& !(tess.shader->surfaceFlags & (SURF_NODLIGHT | SURF_SKY) ) ) {
+#ifdef VV_LIGHTING
+		qglEnableClientState( GL_NORMAL_ARRAY );
+		qglNormalPointer(GL_FLOAT, 16, tess.normal );
+		if(!tess.setTangents)
+            BuildTangentVectors();
+		glw_state->lightEffects->RenderDynamicLights();
+		qglDisableClientState( GL_NORMAL_ARRAY );
+#else
+		if (r_dlightStyle->integer>0)
+		{
+			ProjectDlightTexture2();
+		}
+		else
+		{
+			ProjectDlightTexture();
+		}
+#endif
+	}
+
+	//
+	// now do fog
+	//
+	if (tr.world && (tess.fogNum != tr.world->globalFog || r_drawfog->value != 2) && r_drawfog->value && tess.fogNum && tess.shader->fogPass)
+	{
+		RB_FogPass();
+	}
+
+	// 
+	// unlock arrays
+	//
+	if (qglUnlockArraysEXT) 
+	{
+		qglUnlockArraysEXT();
+		GLimp_LogComment( "glUnlockArraysEXT\n" );
+	}
+
+	//
+	// reset polygon offset
+	//
+	if ( input->shader->polygonOffset )
+	{
+		qglDisable( GL_POLYGON_OFFSET_FILL );
+	}
+
+	// Now check for surfacesprites.
+	if (r_surfaceSprites->integer)
+	{
+		for ( stage = 1; stage < tess.shader->numUnfoggedPasses; stage++ )
+		{
+			if (tess.xstages[stage].ss && tess.xstages[stage].ss->surfaceSpriteType)
+			{	// Draw the surfacesprite
+				RB_DrawSurfaceSprites(&tess.xstages[stage], input);
+			}
+		}
+	}
+
+	//don't disable the hardware fog til after we do surface sprites
+	if (r_drawfog->value == 2 && 
+		tess.fogNum && tess.shader->fogPass &&
+		(tess.fogNum == tr.world->globalFog || tess.fogNum == tr.world->numfogs))
+	{
+		qglDisable(GL_FOG);
+	}
+}
+
+
+/*
+** RB_EndSurface
+*/
+void RB_EndSurface( void ) {
+	shaderCommands_t *input;
+
+	input = &tess;
+
+	if (input->numIndexes == 0) {
+		return;
+	}
+
+	if (input->indexes[SHADER_MAX_INDEXES-1] != 0) {
+		Com_Error (ERR_DROP, "RB_EndSurface() - SHADER_MAX_INDEXES hit");
+	}	
+	if (input->xyz[SHADER_MAX_VERTEXES-1][0] != 0) {
+		Com_Error (ERR_DROP, "RB_EndSurface() - SHADER_MAX_VERTEXES hit");
+	}
+
+	if ( tess.shader == tr.shadowShader ) {
+		RB_ShadowTessEnd();
+		return;
+	}
+
+	// for debugging of sort order issues, stop rendering after a given sort value
+	if ( r_debugSort->integer && r_debugSort->integer < tess.shader->sort ) {
+		return;
+	}
+
+	if ( skyboxportal )
+	{
+		// world
+		if(!(backEnd.refdef.rdflags & RDF_SKYBOXPORTAL)) 
+		{
+			if(tess.currentStageIteratorFunc == RB_StageIteratorSky)
+			{	// don't process these tris at all
+				return;
+			}
+		}
+		// portal sky
+		else
+		{
+			if(!drawskyboxportal)
+			{
+				if( !(tess.currentStageIteratorFunc == RB_StageIteratorSky))
+				{	// /only/ process sky tris
+					return;
+				}
+			}
+		}
+	}
+
+	//
+	// update performance counters
+	//
+	backEnd.pc.c_shaders++;
+	backEnd.pc.c_vertexes += tess.numVertexes;
+	backEnd.pc.c_indexes += tess.numIndexes;
+	backEnd.pc.c_totalIndexes += tess.numIndexes * tess.numPasses;
+	if (tess.fogNum && tess.shader->fogPass && r_drawfog->value == 1)
+	{	
+		backEnd.pc.c_totalIndexes += tess.numIndexes;
+	}
+
+	//
+	// call off to shader specific tess end function
+	//
+	tess.currentStageIteratorFunc();
+
+#ifdef _XBOX
+	tess.currentPass = 0;
+#endif
+
+	//
+	// draw debugging stuff
+	//
+	if ( r_showtris->integer && com_developer->integer ) {
+		DrawTris (input);
+	}
+	if ( r_shownormals->integer && com_developer->integer && com_sv_running->integer ) {
+		DrawNormals (input);
+	}
+	// clear shader so we can tell we don't have any unclosed surfaces
+	tess.numIndexes = 0;
+
+	GLimp_LogComment( "----------\n" );
+}
+
diff --git a/codemp/renderer/tr_shade_calc.cpp b/codemp/renderer/tr_shade_calc.cpp
new file mode 100644
index 0000000..ccc2c0e
--- /dev/null
+++ b/codemp/renderer/tr_shade_calc.cpp
@@ -0,0 +1,1671 @@
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+// tr_shade_calc.c
+
+#include "tr_local.h"
+
+
+#define	WAVEVALUE( table, base, amplitude, phase, freq )  ((base) + table[ myftol( ( ( (phase) + tess.shaderTime * (freq) ) * FUNCTABLE_SIZE ) ) & FUNCTABLE_MASK ] * (amplitude))
+
+static float *TableForFunc( genFunc_t func ) 
+{
+	switch ( func )
+	{
+	case GF_SIN:
+		return tr.sinTable;
+	case GF_TRIANGLE:
+		return tr.triangleTable;
+	case GF_SQUARE:
+		return tr.squareTable;
+	case GF_SAWTOOTH:
+		return tr.sawToothTable;
+	case GF_INVERSE_SAWTOOTH:
+		return tr.inverseSawToothTable;
+	case GF_NONE:
+	default:
+		break;
+	}
+
+	Com_Error( ERR_DROP, "TableForFunc called with invalid function '%d' in shader '%s'\n", func, tess.shader->name );
+	return NULL;
+}
+
+/*
+** EvalWaveForm
+**
+** Evaluates a given waveForm_t, referencing backEnd.refdef.time directly
+*/
+extern float GetNoiseTime( int t ); //from tr_noise, returns 0 to 2
+static float EvalWaveForm( const waveForm_t *wf ) 
+{
+	float	*table;
+
+	if ( wf->func == GF_NOISE ) {
+		return  ( wf->base + R_NoiseGet4f( 0, 0, 0, ( backEnd.refdef.floatTime + wf->phase ) * wf->frequency ) * wf->amplitude );
+	} else if (wf->func == GF_RAND) {
+		if( GetNoiseTime( backEnd.refdef.time + wf->phase ) <= wf->frequency ) {
+			return (wf->base + wf->amplitude);
+		} else {
+			return wf->base;
+		}
+	}
+	table = TableForFunc( wf->func );
+
+	return WAVEVALUE( table, wf->base, wf->amplitude, wf->phase, wf->frequency );
+}
+
+static float EvalWaveFormClamped( const waveForm_t *wf )
+{
+	float glow  = EvalWaveForm( wf );
+
+	if ( glow < 0 )
+	{
+		return 0;
+	}
+
+	if ( glow > 1 )
+	{
+		return 1;
+	}
+
+	return glow;
+}
+
+/*
+** RB_CalcStretchTexCoords
+*/
+void RB_CalcStretchTexCoords( const waveForm_t *wf, float *st )
+{
+	float p;
+	texModInfo_t tmi;
+
+	p = 1.0f / EvalWaveForm( wf );
+
+	tmi.matrix[0][0] = p;
+	tmi.matrix[1][0] = 0;
+	tmi.translate[0] = 0.5f - 0.5f * p;
+
+	tmi.matrix[0][1] = 0;
+	tmi.matrix[1][1] = p;
+	tmi.translate[1] = 0.5f - 0.5f * p;
+
+	RB_CalcTransformTexCoords( &tmi, st );
+}
+
+/*
+====================================================================
+
+DEFORMATIONS
+
+====================================================================
+*/
+
+/*
+========================
+RB_CalcDeformVertexes
+
+========================
+*/
+void RB_CalcDeformVertexes( deformStage_t *ds )
+{
+	int i;
+	vec3_t	offset;
+	float	scale;
+	float	*xyz = ( float * ) tess.xyz;
+	float	*normal = ( float * ) tess.normal;
+	float	*table;
+
+	if ( ds->deformationWave.frequency == 0 )
+	{
+		scale = EvalWaveForm( &ds->deformationWave );
+
+		for ( i = 0; i < tess.numVertexes; i++, xyz += 4, normal += 4 )
+		{
+			VectorScale( normal, scale, offset );
+			
+			xyz[0] += offset[0];
+			xyz[1] += offset[1];
+			xyz[2] += offset[2];
+		}
+	}
+	else
+	{
+		table = TableForFunc( ds->deformationWave.func );
+
+		for ( i = 0; i < tess.numVertexes; i++, xyz += 4, normal += 4 )
+		{
+			float off = ( xyz[0] + xyz[1] + xyz[2] ) * ds->deformationSpread;
+
+			scale = WAVEVALUE( table, ds->deformationWave.base, 
+				ds->deformationWave.amplitude,
+				ds->deformationWave.phase + off,
+				ds->deformationWave.frequency );
+
+			VectorScale( normal, scale, offset );
+			
+			xyz[0] += offset[0];
+			xyz[1] += offset[1];
+			xyz[2] += offset[2];
+		}
+	}
+}
+
+/*
+=========================
+RB_CalcDeformNormals
+
+Wiggle the normals for wavy environment mapping
+=========================
+*/
+void RB_CalcDeformNormals( deformStage_t *ds ) {
+	int i;
+	float	scale;
+	float	*xyz = ( float * ) tess.xyz;
+	float	*normal = ( float * ) tess.normal;
+
+	for ( i = 0; i < tess.numVertexes; i++, xyz += 4, normal += 4 ) {
+		scale = 0.98f;
+		scale = R_NoiseGet4f( xyz[0] * scale, xyz[1] * scale, xyz[2] * scale,
+			tess.shaderTime * ds->deformationWave.frequency );
+		normal[ 0 ] += ds->deformationWave.amplitude * scale;
+
+		scale = 0.98f;
+		scale = R_NoiseGet4f( 100 + xyz[0] * scale, xyz[1] * scale, xyz[2] * scale,
+			tess.shaderTime * ds->deformationWave.frequency );
+		normal[ 1 ] += ds->deformationWave.amplitude * scale;
+
+		scale = 0.98f;
+		scale = R_NoiseGet4f( 200 + xyz[0] * scale, xyz[1] * scale, xyz[2] * scale,
+			tess.shaderTime * ds->deformationWave.frequency );
+		normal[ 2 ] += ds->deformationWave.amplitude * scale;
+
+		VectorNormalizeFast( normal );
+	}
+}
+
+/*
+========================
+RB_CalcBulgeVertexes
+
+========================
+*/
+void RB_CalcBulgeVertexes( deformStage_t *ds )
+{
+	//Old bulge code:
+	/*
+	int i;
+	const float *st = ( const float * ) tess.texCoords[0];
+	float		*xyz = ( float * ) tess.xyz;
+	float		*normal = ( float * ) tess.normal;
+	float		now;
+
+	now = backEnd.refdef.time * ds->bulgeSpeed * 0.001f;
+
+	for ( i = 0; i < tess.numVertexes; i++, xyz += 4, st += 2 * NUM_TEX_COORDS, normal += 4 ) {
+		int		off;
+		float scale;
+
+		off = (float)( FUNCTABLE_SIZE / (M_PI*2) ) * ( st[0] * ds->bulgeWidth + now );
+
+		scale = tr.sinTable[ off & FUNCTABLE_MASK ] * ds->bulgeHeight;
+			
+		xyz[0] += normal[0] * scale;
+		xyz[1] += normal[1] * scale;
+		xyz[2] += normal[2] * scale;
+	}
+	*/
+
+	int		i;
+	float	*xyz = ( float * ) tess.xyz;
+	float	*normal = ( float * ) tess.normal;
+	float	scale;
+
+	if ( ds->bulgeSpeed == 0.0f && ds->bulgeWidth == 0.0f )
+	{
+		// We don't have a speed and width, so just use height to expand uniformly
+		for ( i = 0; i < tess.numVertexes; i++, xyz += 4, normal += 4 ) 
+		{
+			xyz[0] += normal[0] * ds->bulgeHeight;
+			xyz[1] += normal[1] * ds->bulgeHeight;
+			xyz[2] += normal[2] * ds->bulgeHeight;
+		}
+	}
+	else
+	{
+		// I guess do some extra dumb stuff..the fact that it uses ST seems bad though because skin pages may be set up in certain ways that can cause
+		//	very noticeable seams on sufaces ( like on the huge ion_cannon ).
+		const float *st = ( const float * ) tess.texCoords[0];
+		float		now;
+		int			off;
+
+		now = backEnd.refdef.time * ds->bulgeSpeed * 0.001f;
+
+		for ( i = 0; i < tess.numVertexes; i++, xyz += 4, st += 2 * NUM_TEX_COORDS, normal += 4 ) 
+		{
+			off = (float)( FUNCTABLE_SIZE / (M_PI*2) ) * ( st[0] * ds->bulgeWidth + now );
+
+			scale = tr.sinTable[ off & FUNCTABLE_MASK ] * ds->bulgeHeight;
+				
+			xyz[0] += normal[0] * scale;
+			xyz[1] += normal[1] * scale;
+			xyz[2] += normal[2] * scale;
+		}
+	}
+}
+
+
+/*
+======================
+RB_CalcMoveVertexes
+
+A deformation that can move an entire surface along a wave path
+======================
+*/
+void RB_CalcMoveVertexes( deformStage_t *ds ) {
+	int			i;
+	float		*xyz;
+	float		*table;
+	float		scale;
+	vec3_t		offset;
+
+	table = TableForFunc( ds->deformationWave.func );
+
+	scale = WAVEVALUE( table, ds->deformationWave.base, 
+		ds->deformationWave.amplitude,
+		ds->deformationWave.phase,
+		ds->deformationWave.frequency );
+
+	VectorScale( ds->moveVector, scale, offset );
+
+	xyz = ( float * ) tess.xyz;
+	for ( i = 0; i < tess.numVertexes; i++, xyz += 4 ) {
+		VectorAdd( xyz, offset, xyz );
+	}
+}
+
+
+/*
+=============
+DeformText
+
+Change a polygon into a bunch of text polygons
+=============
+*/
+void DeformText( const char *text ) {
+	int		i;
+	vec3_t	origin, width, height;
+	int		len;
+	int		ch;
+	byte	color[4];
+	float	bottom, top;
+	vec3_t	mid;
+
+	height[0] = 0;
+	height[1] = 0;
+	height[2] = -1;
+	CrossProduct( tess.normal[0], height, width );
+
+	// find the midpoint of the box
+	VectorClear( mid );
+	bottom = 999999;
+	top = -999999;
+	for ( i = 0 ; i < 4 ; i++ ) {
+		VectorAdd( tess.xyz[i], mid, mid );
+		if ( tess.xyz[i][2] < bottom ) {
+			bottom = tess.xyz[i][2];
+		}
+		if ( tess.xyz[i][2] > top ) {
+			top = tess.xyz[i][2];
+		}
+	}
+	VectorScale( mid, 0.25f, origin );
+
+	// determine the individual character size
+	height[0] = 0;
+	height[1] = 0;
+	height[2] = ( top - bottom ) * 0.5f;
+
+	VectorScale( width, height[2] * -0.75f, width );
+
+	// determine the starting position
+	len = strlen( text );
+	VectorMA( origin, (len-1), width, origin );
+
+	// clear the shader indexes
+	tess.numIndexes = 0;
+	tess.numVertexes = 0;
+
+	color[0] = color[1] = color[2] = color[3] = 255;
+
+	// draw each character
+	for ( i = 0 ; i < len ; i++ ) {
+		ch = text[i];
+		ch &= 255;
+
+		if ( ch != ' ' ) {
+			int		row, col;
+			float	frow, fcol, size;
+
+			row = ch>>4;
+			col = ch&15;
+
+			frow = row*0.0625f;
+			fcol = col*0.0625f;
+			size = 0.0625f;
+
+			RB_AddQuadStampExt( origin, width, height, color, fcol, frow, fcol + size, frow + size );
+		}
+		VectorMA( origin, -2, width, origin );
+	}
+}
+
+/*
+==================
+GlobalVectorToLocal
+==================
+*/
+static void GlobalVectorToLocal( const vec3_t in, vec3_t out ) {
+	out[0] = DotProduct( in, backEnd.ori.axis[0] );
+	out[1] = DotProduct( in, backEnd.ori.axis[1] );
+	out[2] = DotProduct( in, backEnd.ori.axis[2] );
+}
+
+/*
+=====================
+AutospriteDeform
+
+Assuming all the triangles for this shader are independant
+quads, rebuild them as forward facing sprites
+=====================
+*/
+static void AutospriteDeform( void ) {
+	int		i;
+	int		oldVerts;
+	float	*xyz;
+	vec3_t	mid, delta;
+	float	radius;
+	vec3_t	left, up;
+	vec3_t	leftDir, upDir;
+
+	if ( tess.numVertexes & 3 ) {
+		Com_Printf (S_COLOR_YELLOW  "Autosprite shader %s had odd vertex count", tess.shader->name );
+	}
+	if ( tess.numIndexes != ( tess.numVertexes >> 2 ) * 6 ) {
+		Com_Printf (S_COLOR_YELLOW  "Autosprite shader %s had odd index count", tess.shader->name );
+	}
+
+	oldVerts = tess.numVertexes;
+	tess.numVertexes = 0;
+	tess.numIndexes = 0;
+
+	if ( backEnd.currentEntity != &tr.worldEntity ) {
+		GlobalVectorToLocal( backEnd.viewParms.ori.axis[1], leftDir );
+		GlobalVectorToLocal( backEnd.viewParms.ori.axis[2], upDir );
+	} else {
+		VectorCopy( backEnd.viewParms.ori.axis[1], leftDir );
+		VectorCopy( backEnd.viewParms.ori.axis[2], upDir );
+	}
+
+	for ( i = 0 ; i < oldVerts ; i+=4 ) {
+		// find the midpoint
+		xyz = tess.xyz[i];
+
+		mid[0] = 0.25f * (xyz[0] + xyz[4] + xyz[8] + xyz[12]);
+		mid[1] = 0.25f * (xyz[1] + xyz[5] + xyz[9] + xyz[13]);
+		mid[2] = 0.25f * (xyz[2] + xyz[6] + xyz[10] + xyz[14]);
+
+		VectorSubtract( xyz, mid, delta );
+		radius = VectorLength( delta ) * 0.707f;		// / sqrt(2)
+
+		VectorScale( leftDir, radius, left );
+		VectorScale( upDir, radius, up );
+
+		if ( backEnd.viewParms.isMirror ) {
+			VectorSubtract( vec3_origin, left, left );
+		}
+
+	  // compensate for scale in the axes if necessary
+  	if ( backEnd.currentEntity->e.nonNormalizedAxes ) {
+      float axisLength;
+		  axisLength = VectorLength( backEnd.currentEntity->e.axis[0] );
+  		if ( !axisLength ) {
+	  		axisLength = 0;
+  		} else {
+	  		axisLength = 1.0f / axisLength;
+  		}
+      VectorScale(left, axisLength, left);
+      VectorScale(up, axisLength, up);
+    }
+
+		RB_AddQuadStamp( mid, left, up, tess.vertexColors[i] );
+	}
+}
+
+
+/*
+=====================
+Autosprite2Deform
+
+Autosprite2 will pivot a rectangular quad along the center of its long axis
+=====================
+*/
+int edgeVerts[6][2] = {
+	{ 0, 1 },
+	{ 0, 2 },
+	{ 0, 3 },
+	{ 1, 2 },
+	{ 1, 3 },
+	{ 2, 3 }
+};
+
+static void Autosprite2Deform( void ) {
+	int		i, j, k;
+	int		indexes;
+	float	*xyz;
+	vec3_t	forward;
+
+	if ( tess.numVertexes & 3 ) {
+		Com_Printf (S_COLOR_YELLOW  "Autosprite2 shader %s had odd vertex count", tess.shader->name );
+	}
+	if ( tess.numIndexes != ( tess.numVertexes >> 2 ) * 6 ) {
+		Com_Printf (S_COLOR_YELLOW  "Autosprite2 shader %s had odd index count", tess.shader->name );
+	}
+
+	if ( backEnd.currentEntity != &tr.worldEntity ) {
+		GlobalVectorToLocal( backEnd.viewParms.ori.axis[0], forward );
+	} else {
+		VectorCopy( backEnd.viewParms.ori.axis[0], forward );
+	}
+
+	// this is a lot of work for two triangles...
+	// we could precalculate a lot of it is an issue, but it would mess up
+	// the shader abstraction
+	for ( i = 0, indexes = 0 ; i < tess.numVertexes ; i+=4, indexes+=6 ) {
+		float	lengths[2];
+		int		nums[2];
+		vec3_t	mid[2];
+		vec3_t	major, minor;
+		float	*v1, *v2;
+
+		// find the midpoint
+		xyz = tess.xyz[i];
+
+		// identify the two shortest edges
+		nums[0] = nums[1] = 0;
+		lengths[0] = lengths[1] = 999999;
+
+		for ( j = 0 ; j < 6 ; j++ ) {
+			float	l;
+			vec3_t	temp;
+
+			v1 = xyz + 4 * edgeVerts[j][0];
+			v2 = xyz + 4 * edgeVerts[j][1];
+
+			VectorSubtract( v1, v2, temp );
+			
+			l = DotProduct( temp, temp );
+			if ( l < lengths[0] ) {
+				nums[1] = nums[0];
+				lengths[1] = lengths[0];
+				nums[0] = j;
+				lengths[0] = l;
+			} else if ( l < lengths[1] ) {
+				nums[1] = j;
+				lengths[1] = l;
+			}
+		}
+
+		for ( j = 0 ; j < 2 ; j++ ) {
+			v1 = xyz + 4 * edgeVerts[nums[j]][0];
+			v2 = xyz + 4 * edgeVerts[nums[j]][1];
+
+			mid[j][0] = 0.5f * (v1[0] + v2[0]);
+			mid[j][1] = 0.5f * (v1[1] + v2[1]);
+			mid[j][2] = 0.5f * (v1[2] + v2[2]);
+		}
+
+		// find the vector of the major axis
+		VectorSubtract( mid[1], mid[0], major );
+
+		// cross this with the view direction to get minor axis
+		CrossProduct( major, forward, minor );
+		VectorNormalize( minor );
+		
+		// re-project the points
+		for ( j = 0 ; j < 2 ; j++ ) {
+			float	l;
+
+			v1 = xyz + 4 * edgeVerts[nums[j]][0];
+			v2 = xyz + 4 * edgeVerts[nums[j]][1];
+
+			l = 0.5 * sqrt( lengths[j] );
+			
+			// we need to see which direction this edge
+			// is used to determine direction of projection
+			for ( k = 0 ; k < 5 ; k++ ) {
+				if ( tess.indexes[ indexes + k ] == i + edgeVerts[nums[j]][0]
+					&& tess.indexes[ indexes + k + 1 ] == i + edgeVerts[nums[j]][1] ) {
+					break;
+				}
+			}
+
+			if ( k == 5 ) {
+				VectorMA( mid[j], l, minor, v1 );
+				VectorMA( mid[j], -l, minor, v2 );
+			} else {
+				VectorMA( mid[j], -l, minor, v1 );
+				VectorMA( mid[j], l, minor, v2 );
+			}
+		}
+	}
+}
+
+
+/*
+=====================
+RB_DeformTessGeometry
+
+=====================
+*/
+void RB_DeformTessGeometry( void ) {
+	int		i;
+	deformStage_t	*ds;
+
+	for ( i = 0 ; i < tess.shader->numDeforms ; i++ ) {
+		ds = tess.shader->deforms[ i ];
+
+		switch ( ds->deformation ) {
+        case DEFORM_NONE:
+            break;
+		case DEFORM_NORMALS:
+			RB_CalcDeformNormals( ds );
+			break;
+		case DEFORM_WAVE:
+			RB_CalcDeformVertexes( ds );
+			break;
+		case DEFORM_BULGE:
+			RB_CalcBulgeVertexes( ds );
+			break;
+		case DEFORM_MOVE:
+			RB_CalcMoveVertexes( ds );
+			break;
+		case DEFORM_PROJECTION_SHADOW:
+			RB_ProjectionShadowDeform();
+			break;
+		case DEFORM_AUTOSPRITE:
+			AutospriteDeform();
+			break;
+		case DEFORM_AUTOSPRITE2:
+			Autosprite2Deform();
+			break;
+		case DEFORM_TEXT0:
+		case DEFORM_TEXT1:
+		case DEFORM_TEXT2:
+		case DEFORM_TEXT3:
+		case DEFORM_TEXT4:
+		case DEFORM_TEXT5:
+		case DEFORM_TEXT6:
+		case DEFORM_TEXT7:
+			DeformText( backEnd.refdef.text[ds->deformation - DEFORM_TEXT0] );
+			break;
+		}
+	}
+}
+
+/*
+====================================================================
+
+COLORS
+
+====================================================================
+*/
+
+
+/*
+** RB_CalcColorFromEntity
+*/
+#ifdef _XBOX
+void RB_CalcColorFromEntity( DWORD *dstColors )
+{
+	int	i;
+	DWORD *pColors = dstColors;
+
+	if ( !backEnd.currentEntity )
+		return;
+
+	for ( i = 0; i < tess.numVertexes; i++, pColors++ )
+	{
+		*pColors = D3DCOLOR_RGBA((int)(backEnd.currentEntity->e.shaderRGBA[0]),
+			(int)(backEnd.currentEntity->e.shaderRGBA[1]),
+			(int)(backEnd.currentEntity->e.shaderRGBA[2]),
+			(int)(backEnd.currentEntity->e.shaderRGBA[3]));
+	}
+}
+#else
+void RB_CalcColorFromEntity( unsigned char *dstColors )
+{
+	int	i;
+	int *pColors = ( int * ) dstColors;
+	int c;
+
+	if ( !backEnd.currentEntity )
+		return;
+
+	c = * ( int * ) backEnd.currentEntity->e.shaderRGBA;
+
+	for ( i = 0; i < tess.numVertexes; i++, pColors++ )
+	{
+		*pColors = c;
+	}
+}
+#endif // _XBOX
+
+/*
+** RB_CalcColorFromOneMinusEntity
+*/
+#ifdef _XBOX
+void RB_CalcColorFromOneMinusEntity( DWORD *dstColors )
+{
+	int	i;
+	DWORD *pColors = dstColors;
+	unsigned char invModulate[3];
+
+	if ( !backEnd.currentEntity )
+		return;
+
+	invModulate[0] = 255 - backEnd.currentEntity->e.shaderRGBA[0];
+	invModulate[1] = 255 - backEnd.currentEntity->e.shaderRGBA[1];
+	invModulate[2] = 255 - backEnd.currentEntity->e.shaderRGBA[2];
+	invModulate[3] = 255 - backEnd.currentEntity->e.shaderRGBA[3];	// this trashes alpha, but the AGEN block fixes it
+
+	for ( i = 0; i < tess.numVertexes; i++, pColors++ )
+	{
+		*pColors = D3DCOLOR_RGBA((int)invModulate[0],
+			(int)invModulate[1],
+			(int)invModulate[2],
+			(int)invModulate[3]);
+	}
+}
+#else
+void RB_CalcColorFromOneMinusEntity( unsigned char *dstColors )
+{
+	int	i;
+	int *pColors = ( int * ) dstColors;
+	unsigned char invModulate[3];
+	int c;
+
+	if ( !backEnd.currentEntity )
+		return;
+
+	invModulate[0] = 255 - backEnd.currentEntity->e.shaderRGBA[0];
+	invModulate[1] = 255 - backEnd.currentEntity->e.shaderRGBA[1];
+	invModulate[2] = 255 - backEnd.currentEntity->e.shaderRGBA[2];
+	invModulate[3] = 255 - backEnd.currentEntity->e.shaderRGBA[3];	// this trashes alpha, but the AGEN block fixes it
+
+	c = * ( int * ) invModulate;
+
+	for ( i = 0; i < tess.numVertexes; i++, pColors++ )
+	{
+		*pColors = * ( int * ) invModulate;
+	}
+}
+#endif // _XBOX
+
+/*
+** RB_CalcAlphaFromEntity
+*/
+#ifdef _XBOX
+void RB_CalcAlphaFromEntity( DWORD *dstColors )
+{
+	int	i;
+
+	if ( !backEnd.currentEntity )
+		return;
+
+	for ( i = 0; i < tess.numVertexes; i++, dstColors ++ )
+	{
+		DWORD rgb = (DWORD)((*dstColors) & 0x00ffffff);
+		*dstColors = rgb | ((backEnd.currentEntity->e.shaderRGBA[3] & 0xff) << 24);
+	}
+}
+#else
+void RB_CalcAlphaFromEntity( unsigned char *dstColors )
+{
+	int	i;
+
+	if ( !backEnd.currentEntity )
+		return;
+
+	dstColors += 3;
+
+	for ( i = 0; i < tess.numVertexes; i++, dstColors += 4 )
+	{
+		*dstColors = backEnd.currentEntity->e.shaderRGBA[3];
+	}
+}
+#endif
+
+/*
+** RB_CalcAlphaFromOneMinusEntity
+*/
+#ifdef _XBOX
+void RB_CalcAlphaFromOneMinusEntity( DWORD *dstColors )
+{
+	int	i;
+
+	if ( !backEnd.currentEntity )
+		return;
+
+	for ( i = 0; i < tess.numVertexes; i++, dstColors ++ )
+	{
+		DWORD rgb = (DWORD)((*dstColors) & 0x00ffffff);
+		*dstColors = rgb | (((255 - backEnd.currentEntity->e.shaderRGBA[3]) & 0xff) << 24);
+	}
+}
+#else
+void RB_CalcAlphaFromOneMinusEntity( unsigned char *dstColors )
+{
+	int	i;
+
+	if ( !backEnd.currentEntity )
+		return;
+
+	dstColors += 3;
+
+	for ( i = 0; i < tess.numVertexes; i++, dstColors += 4 )
+	{
+		*dstColors = 0xff - backEnd.currentEntity->e.shaderRGBA[3];
+	}
+}
+#endif // _XBOX
+
+/*
+** RB_CalcWaveColor
+*/
+#ifdef _XBOX
+void RB_CalcWaveColor( const waveForm_t *wf, DWORD *dstColors )
+{
+	int i;
+	int v;
+	float glow;
+	DWORD *colors = dstColors;
+	byte	color[4];
+
+	if ( wf->func == GF_NOISE ) {
+		glow = wf->base + R_NoiseGet4f( 0, 0, 0, ( backEnd.refdef.floatTime + wf->phase ) * wf->frequency ) * wf->amplitude;
+	} else {
+		glow = EvalWaveForm( wf ) * tr.identityLight;
+	}
+
+	if ( glow < 0 ) {
+		glow = 0;
+	}
+	else if ( glow > 1 ) {
+		glow = 1;
+	}
+
+	v = myftol( 255 * glow );
+	color[0] = color[1] = color[2] = v;
+	color[3] = 255;
+
+	for ( i = 0; i < tess.numVertexes; i++, colors++ ) {
+		*colors = D3DCOLOR_RGBA(color[0], color[1], color[2], color[3]);
+	}
+}
+#else // _XBOX
+void RB_CalcWaveColor( const waveForm_t *wf, unsigned char *dstColors )
+{
+	int i;
+	int v;
+	float glow;
+	int *colors = ( int * ) dstColors;
+	byte	color[4];
+
+
+  if ( wf->func == GF_NOISE ) {
+		glow = wf->base + R_NoiseGet4f( 0, 0, 0, ( tess.shaderTime + wf->phase ) * wf->frequency ) * wf->amplitude;
+	} else {
+		glow = EvalWaveForm( wf ) * tr.identityLight;
+	}
+	
+	if ( glow < 0 ) {
+		glow = 0;
+	}
+	else if ( glow > 1 ) {
+		glow = 1;
+	}
+
+	v = myftol( 255 * glow );
+	color[0] = color[1] = color[2] = v;
+	color[3] = 255;
+	v = *(int *)color;
+	
+	for ( i = 0; i < tess.numVertexes; i++, colors++ ) {
+		*colors = v;
+	}
+}
+#endif
+
+/*
+** RB_CalcWaveAlpha
+*/
+#ifdef _XBOX
+void RB_CalcWaveAlpha( const waveForm_t *wf, DWORD *dstColors )
+{
+	int i;
+	int v;
+	float glow;
+
+	glow = EvalWaveFormClamped( wf );
+
+	v = 255 * glow;
+
+	for ( i = 0; i < tess.numVertexes; i++, dstColors ++ )
+	{
+		DWORD rgb = (DWORD)((*dstColors) & 0x00ffffff);
+		*dstColors = rgb | ((v & 0xff) << 24);
+	}
+}
+#else
+void RB_CalcWaveAlpha( const waveForm_t *wf, unsigned char *dstColors )
+{
+	int i;
+	int v;
+	float glow;
+
+	glow = EvalWaveFormClamped( wf );
+
+	v = 255 * glow;
+
+	for ( i = 0; i < tess.numVertexes; i++, dstColors += 4 )
+	{
+		dstColors[3] = v;
+	}
+}
+#endif
+
+/*
+** RB_CalcModulateColorsByFog
+*/
+#ifdef _XBOX
+void RB_CalcModulateColorsByFog( DWORD *colors ) {
+
+}
+#else
+void RB_CalcModulateColorsByFog( unsigned char *colors ) {
+	int		i;
+	float	texCoords[SHADER_MAX_VERTEXES][2];
+
+	// calculate texcoords so we can derive density
+	// this is not wasted, because it would only have
+	// been previously called if the surface was opaque
+	RB_CalcFogTexCoords( texCoords[0] );
+
+	for ( i = 0; i < tess.numVertexes; i++, colors += 4 ) {
+		float f = 1.0 - R_FogFactor( texCoords[i][0], texCoords[i][1] );
+		colors[0] *= f;
+		colors[1] *= f;
+		colors[2] *= f;
+	}
+}
+#endif
+
+/*
+** RB_CalcModulateAlphasByFog
+*/
+#ifdef _XBOX
+void RB_CalcModulateAlphasByFog( DWORD *colors ) {
+
+}
+#else
+void RB_CalcModulateAlphasByFog( unsigned char *colors ) {
+	int		i;
+	float	texCoords[SHADER_MAX_VERTEXES][2];
+
+	// calculate texcoords so we can derive density
+	// this is not wasted, because it would only have
+	// been previously called if the surface was opaque
+	RB_CalcFogTexCoords( texCoords[0] );
+
+	for ( i = 0; i < tess.numVertexes; i++, colors += 4 ) {
+		float f = 1.0 - R_FogFactor( texCoords[i][0], texCoords[i][1] );
+		colors[3] *= f;
+	}
+}
+#endif
+
+/*
+** RB_CalcModulateRGBAsByFog
+*/
+#ifdef _XBOX
+void RB_CalcModulateRGBAsByFog( DWORD *colors ) {
+
+}
+#else
+void RB_CalcModulateRGBAsByFog( unsigned char *colors ) {
+	int		i;
+	float	texCoords[SHADER_MAX_VERTEXES][2];
+
+	// calculate texcoords so we can derive density
+	// this is not wasted, because it would only have
+	// been previously called if the surface was opaque
+	RB_CalcFogTexCoords( texCoords[0] );
+
+	for ( i = 0; i < tess.numVertexes; i++, colors += 4 ) {
+		float f = 1.0 - R_FogFactor( texCoords[i][0], texCoords[i][1] );
+		colors[0] *= f;
+		colors[1] *= f;
+		colors[2] *= f;
+		colors[3] *= f;
+	}
+}
+#endif
+
+
+/*
+====================================================================
+
+TEX COORDS
+
+====================================================================
+*/
+
+/*
+========================
+RB_CalcFogTexCoords
+
+To do the clipped fog plane really correctly, we should use
+projected textures, but I don't trust the drivers and it
+doesn't fit our shader data.
+========================
+*/
+void RB_CalcFogTexCoords( float *st ) {
+	int			i;
+	float		*v;
+	float		s, t;
+	float		eyeT;
+	qboolean	eyeOutside;
+	fog_t		*fog;
+	vec3_t		localVec;
+	vec4_t		fogDistanceVector, fogDepthVector;
+
+	fog = tr.world->fogs + tess.fogNum;
+
+	// all fogging distance is based on world Z units
+	VectorSubtract( backEnd.ori.origin, backEnd.viewParms.ori.origin, localVec );
+#ifdef _XBOX
+	fogDistanceVector[0] = backEnd.ori.modelMatrix[2];
+	fogDistanceVector[1] = backEnd.ori.modelMatrix[6];
+	fogDistanceVector[2] = backEnd.ori.modelMatrix[10];
+#else
+	fogDistanceVector[0] = -backEnd.ori.modelMatrix[2];
+	fogDistanceVector[1] = -backEnd.ori.modelMatrix[6];
+	fogDistanceVector[2] = -backEnd.ori.modelMatrix[10];
+#endif
+	fogDistanceVector[3] = DotProduct( localVec, backEnd.viewParms.ori.axis[0] );
+
+	// scale the fog vectors based on the fog's thickness
+	fogDistanceVector[0] *= fog->tcScale;
+	fogDistanceVector[1] *= fog->tcScale;
+	fogDistanceVector[2] *= fog->tcScale;
+	fogDistanceVector[3] *= fog->tcScale;
+
+	// rotate the gradient vector for this orientation
+	if ( fog->hasSurface ) {
+		fogDepthVector[0] = fog->surface[0] * backEnd.ori.axis[0][0] + 
+			fog->surface[1] * backEnd.ori.axis[0][1] + fog->surface[2] * backEnd.ori.axis[0][2];
+		fogDepthVector[1] = fog->surface[0] * backEnd.ori.axis[1][0] + 
+			fog->surface[1] * backEnd.ori.axis[1][1] + fog->surface[2] * backEnd.ori.axis[1][2];
+		fogDepthVector[2] = fog->surface[0] * backEnd.ori.axis[2][0] + 
+			fog->surface[1] * backEnd.ori.axis[2][1] + fog->surface[2] * backEnd.ori.axis[2][2];
+		fogDepthVector[3] = -fog->surface[3] + DotProduct( backEnd.ori.origin, fog->surface );
+
+		eyeT = DotProduct( backEnd.ori.viewOrigin, fogDepthVector ) + fogDepthVector[3];
+	} else {
+		eyeT = 1;	// non-surface fog always has eye inside
+
+		fogDepthVector[0] = fogDepthVector[1] = fogDepthVector[2] = 0.0f;
+		fogDepthVector[3] = 1.0f;
+	}
+
+	// see if the viewpoint is outside
+	// this is needed for clipping distance even for constant fog
+
+	if ( eyeT < 0 ) {
+		eyeOutside = qtrue;
+	} else {
+		eyeOutside = qfalse;
+	}
+
+	fogDistanceVector[3] += 1.0/512;
+
+	// calculate density for each point
+	for (i = 0, v = tess.xyz[0] ; i < tess.numVertexes ; i++, v += 4) {
+		// calculate the length in fog
+		s = DotProduct( v, fogDistanceVector ) + fogDistanceVector[3];
+		t = DotProduct( v, fogDepthVector ) + fogDepthVector[3];
+
+		// partially clipped fogs use the T axis		
+		if ( eyeOutside ) {
+			if ( t < 1.0 ) {
+				t = 1.0/32;	// point is outside, so no fogging
+			} else {
+				t = 1.0/32 + 30.0/32 * t / ( t - eyeT );	// cut the distance at the fog plane
+			}
+		} else {
+			if ( t < 0 ) {
+				t = 1.0/32;	// point is outside, so no fogging
+			} else {
+				t = 31.0/32;
+			}
+		}
+
+		st[0] = s;
+		st[1] = t;
+		st += 2;
+	}
+}
+
+
+
+/*
+** RB_CalcEnvironmentTexCoords
+*/
+void RB_CalcEnvironmentTexCoords( float *st ) 
+{
+	int			i;
+	float		*v, *normal;
+	vec3_t		viewer, reflected;
+	float		d;
+
+	v = tess.xyz[0];
+	normal = tess.normal[0];
+
+	for (i = 0 ; i < tess.numVertexes ; i++, v += 4, normal += 4, st += 2 ) 
+	{
+		VectorSubtract (backEnd.ori.viewOrigin, v, viewer);
+		VectorNormalizeFast (viewer);
+
+		d = DotProduct (normal, viewer);
+
+		reflected[0] = normal[0]*2*d - viewer[0];
+		reflected[1] = normal[1]*2*d - viewer[1];
+		reflected[2] = normal[2]*2*d - viewer[2];
+
+		st[0] = 0.5 + reflected[1] * 0.5;
+		st[1] = 0.5 - reflected[2] * 0.5;
+	}
+}
+
+/*
+** RB_CalcTurbulentTexCoords
+*/
+void RB_CalcTurbulentTexCoords( const waveForm_t *wf, float *st )
+{
+	int i;
+	float now;
+
+	now = ( wf->phase + tess.shaderTime * wf->frequency );
+
+	for ( i = 0; i < tess.numVertexes; i++, st += 2 )
+	{
+		float s = st[0];
+		float t = st[1];
+
+		st[0] = s + tr.sinTable[ ( ( int ) ( ( ( tess.xyz[i][0] + tess.xyz[i][2] )* 1.0/128 * 0.125 + now ) * FUNCTABLE_SIZE ) ) & ( FUNCTABLE_MASK ) ] * wf->amplitude;
+		st[1] = t + tr.sinTable[ ( ( int ) ( ( tess.xyz[i][1] * 1.0/128 * 0.125 + now ) * FUNCTABLE_SIZE ) ) & ( FUNCTABLE_MASK ) ] * wf->amplitude;
+	}
+}
+
+/*
+** RB_CalcScaleTexCoords
+*/
+void RB_CalcScaleTexCoords( const float scale[2], float *st )
+{
+	int i;
+
+	for ( i = 0; i < tess.numVertexes; i++, st += 2 )
+	{
+		st[0] *= scale[0];
+		st[1] *= scale[1];
+	}
+}
+
+/*
+** RB_CalcScrollTexCoords
+*/
+void RB_CalcScrollTexCoords( const float scrollSpeed[2], float *st )
+{
+	int i;
+	float timeScale = tess.shaderTime;
+	float adjustedScrollS, adjustedScrollT;
+
+	adjustedScrollS = scrollSpeed[0] * timeScale;
+	adjustedScrollT = scrollSpeed[1] * timeScale;
+
+	// clamp so coordinates don't continuously get larger, causing problems
+	// with hardware limits
+	adjustedScrollS = adjustedScrollS - floor( adjustedScrollS );
+	adjustedScrollT = adjustedScrollT - floor( adjustedScrollT );
+
+	for ( i = 0; i < tess.numVertexes; i++, st += 2 )
+	{
+		st[0] += adjustedScrollS;
+		st[1] += adjustedScrollT;
+	}
+}
+
+/*
+** RB_CalcTransformTexCoords
+*/
+void RB_CalcTransformTexCoords( const texModInfo_t *tmi, float *st  )
+{
+	int i;
+
+	for ( i = 0; i < tess.numVertexes; i++, st += 2 )
+	{
+		float s = st[0];
+		float t = st[1];
+
+		st[0] = s * tmi->matrix[0][0] + t * tmi->matrix[1][0] + tmi->translate[0];
+		st[1] = s * tmi->matrix[0][1] + t * tmi->matrix[1][1] + tmi->translate[1];
+	}
+}
+
+/*
+** RB_CalcRotateTexCoords
+*/
+void RB_CalcRotateTexCoords( float degsPerSecond, float *st )
+{
+	float timeScale = tess.shaderTime;
+	float degs;
+	int index;
+	float sinValue, cosValue;
+	texModInfo_t tmi;
+
+	degs = -degsPerSecond * timeScale;
+	index = degs * ( FUNCTABLE_SIZE / 360.0f );
+
+	sinValue = tr.sinTable[ index & FUNCTABLE_MASK ];
+	cosValue = tr.sinTable[ ( index + FUNCTABLE_SIZE / 4 ) & FUNCTABLE_MASK ];
+
+	tmi.matrix[0][0] = cosValue;
+	tmi.matrix[1][0] = -sinValue;
+	tmi.translate[0] = 0.5 - 0.5 * cosValue + 0.5 * sinValue;
+
+	tmi.matrix[0][1] = sinValue;
+	tmi.matrix[1][1] = cosValue;
+	tmi.translate[1] = 0.5 - 0.5 * sinValue - 0.5 * cosValue;
+
+	RB_CalcTransformTexCoords( &tmi, st );
+}
+
+
+
+
+
+
+#if id386 && !( (defined __linux__ || defined __FreeBSD__ ) && (defined __i386__ ) ) // rb010123
+#pragma warning (disable: 4035)//no return value
+inline long myftol( float f ) {
+	static int tmp;
+	__asm fld f
+	__asm fistp tmp
+	__asm mov eax, tmp
+}
+#pragma warning (default: 4035)
+
+#endif
+
+/*
+** RB_CalcSpecularAlpha
+**
+** Calculates specular coefficient and places it in the alpha channel
+*/
+vec3_t lightOrigin = { -960, 1980, 96 };		// FIXME: track dynamically
+
+#ifdef _XBOX
+void RB_CalcSpecularAlpha( DWORD *alphas ) {
+	int			i;
+	float		*v, *normal;
+	vec3_t		viewer,  reflected;
+	float		l, d;
+	int			a;
+	vec3_t		lightDir;
+	int			numVertexes;
+
+	v = tess.xyz[0];
+	normal = tess.normal[0];
+
+	numVertexes = tess.numVertexes;
+	for (i = 0 ; i < numVertexes ; i++, v += 4, normal += 4, alphas ++) {
+		float ilength;
+
+		if (backEnd.currentEntity && 
+			(backEnd.currentEntity->e.hModel||backEnd.currentEntity->e.ghoul2) )	//this is a model so we can use world lights instead fake light
+		{
+			VectorCopy (backEnd.currentEntity->lightDir, lightDir);
+		} else {
+			VectorSubtract( lightOrigin, v, lightDir );
+			VectorNormalizeFast( lightDir );
+		}
+		// calculate the specular color
+		d = 2 * DotProduct (normal, lightDir);
+
+		// we don't optimize for the d < 0 case since this tends to
+		// cause visual artifacts such as faceted "snapping"
+		reflected[0] = normal[0]*d - lightDir[0];
+		reflected[1] = normal[1]*d - lightDir[1];
+		reflected[2] = normal[2]*d - lightDir[2];
+
+		VectorSubtract (backEnd.ori.viewOrigin, v, viewer);
+		ilength = Q_rsqrt( DotProduct( viewer, viewer ) );
+		l = DotProduct (reflected, viewer);
+		l *= ilength;
+
+		if (l < 0) {
+			a = 0;
+		} else {
+			l = l*l;
+			l = l*l;
+			a = l * 255;
+			if (a > 255) {
+				a = 255;
+			}
+		}
+		DWORD rgb = (DWORD)((*alphas) & 0x00ffffff);
+
+		*alphas = rgb | (a & 0xff) << 24;
+	}
+}
+#else // _XBOX
+void RB_CalcSpecularAlpha( unsigned char *alphas ) {
+	int			i;
+	float		*v, *normal;
+	vec3_t		viewer,  reflected;
+	float		l, d;
+	int			b;
+	vec3_t		lightDir;
+	int			numVertexes;
+
+	v = tess.xyz[0];
+	normal = tess.normal[0];
+
+	alphas += 3;
+
+	numVertexes = tess.numVertexes;
+	for (i = 0 ; i < numVertexes ; i++, v += 4, normal += 4, alphas += 4) {
+		float ilength;
+
+		if (backEnd.currentEntity && 
+			(backEnd.currentEntity->e.hModel||backEnd.currentEntity->e.ghoul2) )	//this is a model so we can use world lights instead fake light
+		{
+			VectorCopy (backEnd.currentEntity->lightDir, lightDir);
+		} else {
+			VectorSubtract( lightOrigin, v, lightDir );
+			VectorNormalizeFast( lightDir );
+		}
+		// calculate the specular color
+		d = 2 * DotProduct (normal, lightDir);
+
+		// we don't optimize for the d < 0 case since this tends to
+		// cause visual artifacts such as faceted "snapping"
+		reflected[0] = normal[0]*d - lightDir[0];
+		reflected[1] = normal[1]*d - lightDir[1];
+		reflected[2] = normal[2]*d - lightDir[2];
+
+		VectorSubtract (backEnd.ori.viewOrigin, v, viewer);
+		ilength = Q_rsqrt( DotProduct( viewer, viewer ) );
+		l = DotProduct (reflected, viewer);
+		l *= ilength;
+
+		if (l < 0) {
+			b = 0;
+		} else {
+			l = l*l;
+			l = l*l;
+			b = l * 255;
+			if (b > 255) {
+				b = 255;
+			}
+		}
+
+		*alphas = b;
+	}
+}
+#endif // _XBOX
+
+/*
+** RB_CalcDiffuseColor
+**
+** The basic vertex lighting calc
+*/
+void RB_CalcDiffuseColor( unsigned char *colors )
+{
+	int				i, j;
+	float			*v, *normal;
+	float			incoming;
+	trRefEntity_t	*ent;
+	int				ambientLightInt;
+	vec3_t			ambientLight;
+	vec3_t			lightDir;
+	vec3_t			directedLight;
+	int				numVertexes;
+
+	ent = backEnd.currentEntity;
+	ambientLightInt = ent->ambientLightInt;
+	VectorCopy( ent->ambientLight, ambientLight );
+	VectorCopy( ent->directedLight, directedLight );
+	VectorCopy( ent->lightDir, lightDir );
+
+	v = tess.xyz[0];
+	normal = tess.normal[0];
+
+	numVertexes = tess.numVertexes;
+	for (i = 0 ; i < numVertexes ; i++, v += 4, normal += 4) {
+		incoming = DotProduct (normal, lightDir);
+		if ( incoming <= 0 ) {
+			*(int *)&colors[i*4] = ambientLightInt;
+			continue;
+		} 
+		j = myftol( ambientLight[0] + incoming * directedLight[0] );
+		if ( j > 255 ) {
+			j = 255;
+		}
+		colors[i*4+0] = j;
+
+		j = myftol( ambientLight[1] + incoming * directedLight[1] );
+		if ( j > 255 ) {
+			j = 255;
+		}
+		colors[i*4+1] = j;
+
+		j = myftol( ambientLight[2] + incoming * directedLight[2] );
+		if ( j > 255 ) {
+			j = 255;
+		}
+		colors[i*4+2] = j;
+
+		colors[i*4+3] = 255;
+	}
+}
+
+/*
+** RB_CalcDiffuseColorEntity
+**
+** The basic vertex lighting calc * Entity Color
+*/
+void RB_CalcDiffuseEntityColor( unsigned char *colors )
+{
+	int				i;
+	float			*v, *normal;
+	float			incoming;
+	trRefEntity_t	*ent;
+	int				ambientLightInt;
+	vec3_t			ambientLight;
+	vec3_t			lightDir;
+	vec3_t			directedLight;
+	int				numVertexes;
+	float			j,r,g,b;
+
+	if ( !backEnd.currentEntity )
+	{//error, use the normal lighting
+		RB_CalcDiffuseColor(colors);
+	}
+
+	ent = backEnd.currentEntity;
+	VectorCopy( ent->ambientLight, ambientLight );
+	VectorCopy( ent->directedLight, directedLight );
+	VectorCopy( ent->lightDir, lightDir );
+
+	r = backEnd.currentEntity->e.shaderRGBA[0]/255.0f;
+	g = backEnd.currentEntity->e.shaderRGBA[1]/255.0f;
+	b = backEnd.currentEntity->e.shaderRGBA[2]/255.0f;
+
+	((byte *)&ambientLightInt)[0] = myftol( r*ent->ambientLight[0] );
+	((byte *)&ambientLightInt)[1] = myftol( g*ent->ambientLight[1] );
+	((byte *)&ambientLightInt)[2] = myftol( b*ent->ambientLight[2] );
+	((byte *)&ambientLightInt)[3] = backEnd.currentEntity->e.shaderRGBA[3];
+
+	v = tess.xyz[0];
+	normal = tess.normal[0];
+
+	numVertexes = tess.numVertexes;
+
+	for ( i = 0 ; i < numVertexes ; i++, v += 4, normal += 4)
+	{
+		incoming = DotProduct (normal, lightDir);
+		if ( incoming <= 0 ) {
+			*(int *)&colors[i*4] = ambientLightInt;
+			continue;
+		} 
+		j = ( ambientLight[0] + incoming * directedLight[0] );
+		if ( j > 255 ) {
+			j = 255;
+		}
+		colors[i*4+0] = myftol(j*r);
+
+		j = ( ambientLight[1] + incoming * directedLight[1] );
+		if ( j > 255 ) {
+			j = 255;
+		}
+		colors[i*4+1] = myftol(j*g);
+
+		j = ( ambientLight[2] + incoming * directedLight[2] );
+		if ( j > 255 ) {
+			j = 255;
+		}
+		colors[i*4+2] = myftol(j*b);
+
+		colors[i*4+3] = backEnd.currentEntity->e.shaderRGBA[3];
+	}
+}
+
+//---------------------------------------------------------
+#ifdef _XBOX
+void RB_CalcDisintegrateColors( DWORD *colors )
+{
+	int			i, numVertexes;
+	float		dis, threshold;
+	float		*v;
+	vec3_t		temp;
+	refEntity_t	*ent;
+	DWORD	    rgb;
+
+	ent = &backEnd.currentEntity->e;
+	v = tess.xyz[0];
+
+	// calculate the burn threshold at the given time, anything that passes the threshold will get burnt
+	threshold = (backEnd.refdef.time - ent->endTime) * 0.045f; // endTime is really the start time, maybe I should just use a completely meaningless substitute?
+
+	numVertexes = tess.numVertexes;
+
+	if ( ent->renderfx & RF_DISINTEGRATE1 )
+	{
+		// this handles the blacken and fading out of the regular player model
+		for ( i = 0 ; i < numVertexes ; i++, v += 4 )
+		{
+			rgb = colors[i] & 0x00ffffff;
+
+			VectorSubtract( backEnd.currentEntity->e.oldorigin, v, temp );
+
+			dis = VectorLengthSquared( temp );
+
+			if ( dis < threshold * threshold )
+			{
+				// completely disintegrated
+				colors[i] = rgb | (0x00 << 24);
+			}
+			else if ( dis < threshold * threshold + 60 )
+			{
+				// blacken before fading out
+				colors[i] = D3DCOLOR_RGBA(0x00, 0x00, 0x00, 0xff);
+			}
+			else if ( dis < threshold * threshold + 150 )
+			{
+				// darken more
+				colors[i] = D3DCOLOR_RGBA(0x6f, 0x6f, 0x6f, 0xff);
+			}
+			else if ( dis < threshold * threshold + 180 )
+			{
+				// darken at edge of burn
+				colors[i] = D3DCOLOR_RGBA(0xaf, 0xaf, 0xaf, 0xff);
+			}
+			else
+			{
+				// not burning at all yet
+				colors[i] = D3DCOLOR_RGBA(0xff, 0xff, 0xff, 0xff);
+			}
+		}
+	}
+	else if ( ent->renderfx & RF_DISINTEGRATE2 )
+	{
+		// this handles the glowing, burning bit that scales away from the model
+		for ( i = 0 ; i < numVertexes ; i++, v += 4 )
+		{
+			VectorSubtract( backEnd.currentEntity->e.oldorigin, v, temp );
+
+			dis = VectorLengthSquared( temp );
+
+			if ( dis < threshold * threshold )
+			{
+				// done burning
+				colors[i] = D3DCOLOR_RGBA(0x00, 0x00, 0x00, 0x00);
+			}
+			else
+			{
+				// still full burn
+				colors[i] = D3DCOLOR_RGBA(0xff, 0xff, 0xff, 0xff);
+			}
+		}
+	}
+}
+#else // _XBOX
+void RB_CalcDisintegrateColors( unsigned char *colors )
+{
+	int			i, numVertexes;
+	float		dis, threshold;
+	float		*v;
+	vec3_t		temp;
+	refEntity_t	*ent;
+
+	ent = &backEnd.currentEntity->e;
+	v = tess.xyz[0];
+
+	// calculate the burn threshold at the given time, anything that passes the threshold will get burnt
+	threshold = (backEnd.refdef.time - ent->endTime) * 0.045f; // endTime is really the start time, maybe I should just use a completely meaningless substitute?
+
+	numVertexes = tess.numVertexes;
+
+	if ( ent->renderfx & RF_DISINTEGRATE1 )
+	{
+		// this handles the blacken and fading out of the regular player model
+		for ( i = 0 ; i < numVertexes ; i++, v += 4 )
+		{
+			VectorSubtract( backEnd.currentEntity->e.oldorigin, v, temp );
+
+			dis = VectorLengthSquared( temp );
+
+			if ( dis < threshold * threshold )
+			{
+				// completely disintegrated
+				colors[i*4+3] = 0x00;
+			}
+			else if ( dis < threshold * threshold + 60 )
+			{
+				// blacken before fading out
+				colors[i*4+0] = 0x0;
+				colors[i*4+1] = 0x0;
+				colors[i*4+2] = 0x0;
+				colors[i*4+3] = 0xff;
+			}
+			else if ( dis < threshold * threshold + 150 )
+			{
+				// darken more
+				colors[i*4+0] = 0x6f;
+				colors[i*4+1] = 0x6f;
+				colors[i*4+2] = 0x6f;
+				colors[i*4+3] = 0xff;
+			}
+			else if ( dis < threshold * threshold + 180 )
+			{
+				// darken at edge of burn
+				colors[i*4+0] = 0xaf;
+				colors[i*4+1] = 0xaf;
+				colors[i*4+2] = 0xaf;
+				colors[i*4+3] = 0xff;
+			}
+			else
+			{
+				// not burning at all yet
+				colors[i*4+0] = 0xff;
+				colors[i*4+1] = 0xff;
+				colors[i*4+2] = 0xff;
+				colors[i*4+3] = 0xff;
+			}
+		}
+	}
+	else if ( ent->renderfx & RF_DISINTEGRATE2 )
+	{
+		// this handles the glowing, burning bit that scales away from the model
+		for ( i = 0 ; i < numVertexes ; i++, v += 4 )
+		{
+			VectorSubtract( backEnd.currentEntity->e.oldorigin, v, temp );
+
+			dis = VectorLengthSquared( temp );
+
+			if ( dis < threshold * threshold )
+			{
+				// done burning
+				colors[i*4+0] = 0x00;
+				colors[i*4+1] = 0x00;
+				colors[i*4+2] = 0x00;
+				colors[i*4+3] = 0x00;
+			}
+			else
+			{
+				// still full burn
+				colors[i*4+0] = 0xff;
+				colors[i*4+1] = 0xff;
+				colors[i*4+2] = 0xff;
+				colors[i*4+3] = 0xff;
+			}
+		}
+	}
+}
+#endif // _XBOX
+
+//---------------------------------------------------------
+void RB_CalcDisintegrateVertDeform( void )
+{
+	float	*xyz = ( float * ) tess.xyz;
+	float	*normal = ( float * ) tess.normal;
+	float	scale;
+	vec3_t	temp;
+
+	if ( backEnd.currentEntity->e.renderfx & RF_DISINTEGRATE2 )
+	{
+		float	threshold = (backEnd.refdef.time - backEnd.currentEntity->e.endTime) * 0.045f;
+
+		for ( int i = 0; i < tess.numVertexes; i++, xyz += 4, normal += 4 ) 
+		{
+			VectorSubtract( backEnd.currentEntity->e.oldorigin, xyz, temp );
+
+			scale = VectorLengthSquared( temp );
+
+			if ( scale < threshold * threshold )
+			{
+				xyz[0] += normal[0] * 2.0f;
+				xyz[1] += normal[1] * 2.0f;
+				xyz[2] += normal[2] * 0.5f;
+			}
+			else if ( scale < threshold * threshold + 50 )
+			{
+				xyz[0] += normal[0] * 1.0f;
+				xyz[1] += normal[1] * 1.0f;
+//				xyz[2] += normal[2] * 1;
+			}
+		}
+	}
+}
diff --git a/codemp/renderer/tr_shader.cpp b/codemp/renderer/tr_shader.cpp
new file mode 100644
index 0000000..d992968
--- /dev/null
+++ b/codemp/renderer/tr_shader.cpp
@@ -0,0 +1,4283 @@
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+#include "tr_local.h"
+
+// tr_shader.c -- this file deals with the parsing and definition of shaders
+int CIN_PlayCinematic( const char *arg0, int xpos, int ypos, int width, int height, int bits);	//cl_cin
+
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// Vertex and Pixel Shader definitions.	- AReis
+/***********************************************************************************************************/
+// This vertex shader basically passes through most values and calculates no lighting. The only
+// unusual thing it does is add the inputed texel offsets to all four texture units (this allows
+// nearest neighbor pixel peeking).
+const unsigned char g_strGlowVShaderARB[] =
+{
+	"!!ARBvp1.0\
+	\
+	# Input.\n\
+	ATTRIB	iPos		= vertex.position;\
+	ATTRIB	iColor		= vertex.color;\
+	ATTRIB	iTex0		= vertex.texcoord[0];\
+	ATTRIB	iTex1		= vertex.texcoord[1];\
+	ATTRIB	iTex2		= vertex.texcoord[2];\
+	ATTRIB	iTex3		= vertex.texcoord[3];\
+	\
+	# Output.\n\
+	OUTPUT	oPos		= result.position;\
+	OUTPUT	oColor		= result.color;\
+	OUTPUT	oTex0		= result.texcoord[0];\
+	OUTPUT	oTex1		= result.texcoord[1];\
+	OUTPUT	oTex2		= result.texcoord[2];\
+	OUTPUT	oTex3		= result.texcoord[3];\
+	\
+	# Constants.\n\
+	PARAM	ModelViewProj[4]= { state.matrix.mvp };\
+	PARAM	TexelOffset0	= program.env[0];\
+	PARAM	TexelOffset1	= program.env[1];\
+	PARAM	TexelOffset2	= program.env[2];\
+	PARAM	TexelOffset3	= program.env[3];\
+	\
+	# Main.\n\
+	DP4		oPos.x, ModelViewProj[0], iPos;\
+	DP4		oPos.y, ModelViewProj[1], iPos;\
+	DP4		oPos.z, ModelViewProj[2], iPos;\
+	DP4		oPos.w, ModelViewProj[3], iPos;\
+	MOV		oColor, iColor;\
+	# Notice the optimization of using one texture coord instead of all four.\n\
+	ADD		oTex0, iTex0, TexelOffset0;\
+	ADD		oTex1, iTex0, TexelOffset1;\
+	ADD		oTex2, iTex0, TexelOffset2;\
+	ADD		oTex3, iTex0, TexelOffset3;\
+	\
+	END"
+};
+
+// This Pixel Shader loads four texture units and adds them all together (with a modifier
+// multiplied to each in the process). The final output is r0 = t0 + t1 + t2 + t3.
+const unsigned char g_strGlowPShaderARB[] =
+{
+	"!!ARBfp1.0\
+	\
+	# Input.\n\
+	ATTRIB	iColor	= fragment.color.primary;\
+	\
+	# Output.\n\
+	OUTPUT	oColor	= result.color;\
+	\
+	# Constants.\n\
+	PARAM	Weight	= program.env[0];\
+	TEMP	t0;\
+	TEMP	t1;\
+	TEMP	t2;\
+	TEMP	t3;\
+	TEMP	r0;\
+	\
+	# Main.\n\
+	TEX		t0, fragment.texcoord[0], texture[0], RECT;\
+	TEX		t1, fragment.texcoord[1], texture[1], RECT;\
+	TEX		t2, fragment.texcoord[2], texture[2], RECT;\
+	TEX		t3, fragment.texcoord[3], texture[3], RECT;\
+	\
+    MUL		r0, t0, Weight;\
+	MAD		r0, t1, Weight, r0;\
+	MAD		r0, t2, Weight, r0;\
+	MAD		r0, t3, Weight, r0;\
+	\
+	MOV		oColor, r0;\
+	\
+	END"
+};
+/***********************************************************************************************************/
+
+
+static char *s_shaderText;
+
+// the shader is parsed into these global variables, then copied into
+// dynamically allocated memory if it is valid.
+static	shaderStage_t	stages[MAX_SHADER_STAGES];		
+static	shader_t		shader;
+static	texModInfo_t	texMods[MAX_SHADER_STAGES][TR_MAX_TEXMODS];
+static	qboolean		deferLoad;
+
+#define FILE_HASH_SIZE		1024
+static	shader_t*		hashTable[FILE_HASH_SIZE];
+
+#define MAX_SHADERTEXT_HASH		2048
+static char **shaderTextHashTable[MAX_SHADERTEXT_HASH] = { 0 };
+
+void KillTheShaderHashTable(void)
+{
+	memset(shaderTextHashTable, 0, sizeof(shaderTextHashTable));
+}
+
+qboolean ShaderHashTableExists(void)
+{
+	if (shaderTextHashTable[0])
+	{
+		return qtrue;
+	}
+	return qfalse;
+}
+
+const int lightmapsNone[MAXLIGHTMAPS] = 
+{ 
+	LIGHTMAP_NONE,
+	LIGHTMAP_NONE,
+	LIGHTMAP_NONE,
+	LIGHTMAP_NONE 
+};
+
+const int lightmaps2d[MAXLIGHTMAPS] = 
+{ 
+	LIGHTMAP_2D,
+	LIGHTMAP_2D,
+	LIGHTMAP_2D,
+	LIGHTMAP_2D 
+};
+
+const int lightmapsVertex[MAXLIGHTMAPS] = 
+{ 
+	LIGHTMAP_BY_VERTEX,
+	LIGHTMAP_BY_VERTEX,
+	LIGHTMAP_BY_VERTEX,
+	LIGHTMAP_BY_VERTEX 
+};
+
+const int lightmapsFullBright[MAXLIGHTMAPS] = 
+{
+	LIGHTMAP_WHITEIMAGE,
+	LIGHTMAP_WHITEIMAGE,
+	LIGHTMAP_WHITEIMAGE,
+	LIGHTMAP_WHITEIMAGE
+};
+
+const byte stylesDefault[MAXLIGHTMAPS] = 
+{
+	LS_NORMAL,
+	LS_LSNONE,
+	LS_LSNONE,
+	LS_LSNONE
+};
+
+/*
+Ghoul2 Insert Start
+*/
+
+/*
+===============
+R_CreateExtendedName
+
+  Creates a unique shader name taking into account lightstyles
+===============
+*/
+//rwwRMG - added
+void R_CreateExtendedName(char *extendedName, const char *name, const int *lightmapIndex, const byte *styles)
+{
+	int		i;
+
+	// Set the basename
+	COM_StripExtension( name, extendedName );
+
+	// Add in lightmaps
+	if(lightmapIndex && styles)
+	{
+		if(lightmapIndex == lightmapsNone)
+		{
+			strcat(extendedName, "_nolightmap");
+		}
+		else if(lightmapIndex == lightmaps2d)
+		{
+			strcat(extendedName, "_2d");
+		}
+		else if(lightmapIndex == lightmapsVertex)
+		{
+			strcat(extendedName, "_vertex");
+		}
+		else if(lightmapIndex == lightmapsFullBright)
+		{
+			strcat(extendedName, "_fullbright");
+		}
+		else
+		{
+			for(i = 0; (i < 4) && (styles[i] != 255); i++)
+			{
+				switch(lightmapIndex[i])
+				{
+				case LIGHTMAP_NONE:
+					strcat(extendedName, va("_style(%d,none)", styles[i]));
+					break;
+				case LIGHTMAP_2D:
+					strcat(extendedName, va("_style(%d,2d)", styles[i]));
+					break;
+				case LIGHTMAP_BY_VERTEX:
+					strcat(extendedName, va("_style(%d,vert)", styles[i]));
+					break;
+				case LIGHTMAP_WHITEIMAGE:
+					strcat(extendedName, va("_style(%d,fb)", styles[i]));
+					break;
+				default:
+					strcat(extendedName, va("_style(%d,%d)", styles[i], lightmapIndex[i]));
+					break;
+				}
+			}
+		}
+	}
+}
+
+/*
+Ghoul2 Insert End
+*/
+
+static void ClearGlobalShader(void)
+{
+	int	i;
+
+	Com_Memset( &shader, 0, sizeof( shader ) );
+	Com_Memset( &stages, 0, sizeof( stages ) );
+	for ( i = 0 ; i < MAX_SHADER_STAGES ; i++ ) {
+		stages[i].bundle[0].texMods = texMods[i];
+		stages[i].mGLFogColorOverride = GLFOGOVERRIDE_NONE;
+	}
+
+	shader.contentFlags = CONTENTS_SOLID | CONTENTS_OPAQUE;
+}
+
+/*
+================
+return a hash value for the filename
+================
+*/
+static long generateHashValue( const char *fname, const int size ) {
+	int		i;
+	long	hash;
+	char	letter;
+
+	hash = 0;
+	i = 0;
+	while (fname[i] != '\0') {
+		letter = tolower((unsigned char)fname[i]);
+		if (letter =='.') break;				// don't include extension
+		if (letter =='\\') letter = '/';		// damn path names
+		if (letter == PATH_SEP) letter = '/';		// damn path names
+		hash+=(long)(letter)*(i+119);
+		i++;
+	}
+	hash = (hash ^ (hash >> 10) ^ (hash >> 20));
+	hash &= (size-1);
+	return hash;
+}
+
+void R_RemapShader(const char *shaderName, const char *newShaderName, const char *timeOffset) {
+	char		strippedName[MAX_QPATH];
+	int			hash;
+	shader_t	*sh, *sh2;
+	qhandle_t	h;
+
+	sh = R_FindShaderByName( shaderName );
+	if (sh == NULL || sh == tr.defaultShader) {
+		h = RE_RegisterShaderLightMap(shaderName, lightmapsNone, stylesDefault);
+		sh = R_GetShaderByHandle(h);
+	}
+	if (sh == NULL || sh == tr.defaultShader) {
+		Com_Printf (S_COLOR_YELLOW  "WARNING: R_RemapShader: shader %s not found\n", shaderName );
+		return;
+	}
+
+	sh2 = R_FindShaderByName( newShaderName );
+	if (sh2 == NULL || sh2 == tr.defaultShader) {
+		h = RE_RegisterShaderLightMap(newShaderName, lightmapsNone, stylesDefault);
+		sh2 = R_GetShaderByHandle(h);
+	}
+
+	if (sh2 == NULL || sh2 == tr.defaultShader) {
+		Com_Printf (S_COLOR_YELLOW  "WARNING: R_RemapShader: new shader %s not found\n", newShaderName );
+		return;
+	}
+
+	// remap all the shaders with the given name
+	// even tho they might have different lightmaps
+	COM_StripExtension( shaderName, strippedName );
+	hash = generateHashValue(strippedName, FILE_HASH_SIZE);
+	for (sh = hashTable[hash]; sh; sh = sh->next) {
+		if (Q_stricmp(sh->name, strippedName) == 0) {
+			if (sh != sh2) {
+				sh->remappedShader = sh2;
+			} else {
+				sh->remappedShader = NULL;
+			}
+		}
+	}
+	if (timeOffset) {
+		sh2->timeOffset = atof(timeOffset);
+	}
+}
+
+/*
+===============
+ParseVector
+===============
+*/
+qboolean ParseVector( const char **text, int count, float *v ) {
+	char	*token;
+	int		i;
+
+	// FIXME: spaces are currently required after parens, should change parseext...
+	token = COM_ParseExt( text, qfalse );
+	if ( strcmp( token, "(" ) ) {
+		Com_Printf (S_COLOR_YELLOW  "WARNING: missing parenthesis in shader '%s'\n", shader.name );
+		return qfalse;
+	}
+
+	for ( i = 0 ; i < count ; i++ ) {
+		token = COM_ParseExt( text, qfalse );
+		if ( !token[0] ) {
+			Com_Printf (S_COLOR_YELLOW  "WARNING: missing vector element in shader '%s'\n", shader.name );
+			return qfalse;
+		}
+		v[i] = atof( token );
+	}
+
+	token = COM_ParseExt( text, qfalse );
+	if ( strcmp( token, ")" ) ) {
+		Com_Printf (S_COLOR_YELLOW  "WARNING: missing parenthesis in shader '%s'\n", shader.name );
+		return qfalse;
+	}
+
+	return qtrue;
+}
+
+
+/*
+===============
+NameToAFunc
+===============
+*/
+static unsigned NameToAFunc( const char *funcname )
+{	
+	if ( !Q_stricmp( funcname, "GT0" ) )
+	{
+		return GLS_ATEST_GT_0;
+	}
+	else if ( !Q_stricmp( funcname, "LT128" ) )
+	{
+		return GLS_ATEST_LT_80;
+	}
+	else if ( !Q_stricmp( funcname, "GE128" ) )
+	{
+		return GLS_ATEST_GE_80;
+	}
+	else if ( !Q_stricmp( funcname, "GE192" ) )
+	{
+		return GLS_ATEST_GE_C0;
+	}
+
+	Com_Printf (S_COLOR_YELLOW  "WARNING: invalid alphaFunc name '%s' in shader '%s'\n", funcname, shader.name );
+	return 0;
+}
+
+
+/*
+===============
+NameToSrcBlendMode
+===============
+*/
+static int NameToSrcBlendMode( const char *name )
+{
+	if ( !Q_stricmp( name, "GL_ONE" ) )
+	{
+		return GLS_SRCBLEND_ONE;
+	}
+	else if ( !Q_stricmp( name, "GL_ZERO" ) )
+	{
+		return GLS_SRCBLEND_ZERO;
+	}
+	else if ( !Q_stricmp( name, "GL_DST_COLOR" ) )
+	{
+		return GLS_SRCBLEND_DST_COLOR;
+	}
+	else if ( !Q_stricmp( name, "GL_ONE_MINUS_DST_COLOR" ) )
+	{
+		return GLS_SRCBLEND_ONE_MINUS_DST_COLOR;
+	}
+	else if ( !Q_stricmp( name, "GL_SRC_ALPHA" ) )
+	{
+		return GLS_SRCBLEND_SRC_ALPHA;
+	}
+	else if ( !Q_stricmp( name, "GL_ONE_MINUS_SRC_ALPHA" ) )
+	{
+		return GLS_SRCBLEND_ONE_MINUS_SRC_ALPHA;
+	}
+	else if ( !Q_stricmp( name, "GL_DST_ALPHA" ) )
+	{
+		return GLS_SRCBLEND_DST_ALPHA;
+	}
+	else if ( !Q_stricmp( name, "GL_ONE_MINUS_DST_ALPHA" ) )
+	{
+		return GLS_SRCBLEND_ONE_MINUS_DST_ALPHA;
+	}
+	else if ( !Q_stricmp( name, "GL_SRC_ALPHA_SATURATE" ) )
+	{
+		return GLS_SRCBLEND_ALPHA_SATURATE;
+	}
+
+	Com_Printf (S_COLOR_YELLOW  "WARNING: unknown blend mode '%s' in shader '%s', substituting GL_ONE\n", name, shader.name );
+	return GLS_SRCBLEND_ONE;
+}
+
+/*
+===============
+NameToDstBlendMode
+===============
+*/
+static int NameToDstBlendMode( const char *name )
+{
+	if ( !Q_stricmp( name, "GL_ONE" ) )
+	{
+		return GLS_DSTBLEND_ONE;
+	}
+	else if ( !Q_stricmp( name, "GL_ZERO" ) )
+	{
+		return GLS_DSTBLEND_ZERO;
+	}
+	else if ( !Q_stricmp( name, "GL_SRC_ALPHA" ) )
+	{
+		return GLS_DSTBLEND_SRC_ALPHA;
+	}
+	else if ( !Q_stricmp( name, "GL_ONE_MINUS_SRC_ALPHA" ) )
+	{
+		return GLS_DSTBLEND_ONE_MINUS_SRC_ALPHA;
+	}
+	else if ( !Q_stricmp( name, "GL_DST_ALPHA" ) )
+	{
+		return GLS_DSTBLEND_DST_ALPHA;
+	}
+	else if ( !Q_stricmp( name, "GL_ONE_MINUS_DST_ALPHA" ) )
+	{
+		return GLS_DSTBLEND_ONE_MINUS_DST_ALPHA;
+	}
+	else if ( !Q_stricmp( name, "GL_SRC_COLOR" ) )
+	{
+		return GLS_DSTBLEND_SRC_COLOR;
+	}
+	else if ( !Q_stricmp( name, "GL_ONE_MINUS_SRC_COLOR" ) )
+	{
+		return GLS_DSTBLEND_ONE_MINUS_SRC_COLOR;
+	}
+
+	Com_Printf (S_COLOR_YELLOW  "WARNING: unknown blend mode '%s' in shader '%s', substituting GL_ONE\n", name, shader.name );
+	return GLS_DSTBLEND_ONE;
+}
+
+/*
+===============
+NameToGenFunc
+===============
+*/
+static genFunc_t NameToGenFunc( const char *funcname )
+{
+	if ( !Q_stricmp( funcname, "sin" ) )
+	{
+		return GF_SIN;
+	}
+	else if ( !Q_stricmp( funcname, "square" ) )
+	{
+		return GF_SQUARE;
+	}
+	else if ( !Q_stricmp( funcname, "triangle" ) )
+	{
+		return GF_TRIANGLE;
+	}
+	else if ( !Q_stricmp( funcname, "sawtooth" ) )
+	{
+		return GF_SAWTOOTH;
+	}
+	else if ( !Q_stricmp( funcname, "inversesawtooth" ) )
+	{
+		return GF_INVERSE_SAWTOOTH;
+	}
+	else if ( !Q_stricmp( funcname, "noise" ) )
+	{
+		return GF_NOISE;
+	}
+	else if ( !Q_stricmp( funcname, "random" ) )
+	{
+		return GF_RAND;
+	}
+
+	Com_Printf (S_COLOR_YELLOW  "WARNING: invalid genfunc name '%s' in shader '%s'\n", funcname, shader.name );
+	return GF_SIN;
+}
+
+
+/*
+===================
+ParseWaveForm
+===================
+*/
+static void ParseWaveForm( const char **text, waveForm_t *wave )
+{
+	char *token;
+
+	token = COM_ParseExt( text, qfalse );
+	if ( token[0] == 0 )
+	{
+		Com_Printf (S_COLOR_YELLOW  "WARNING: missing waveform parm in shader '%s'\n", shader.name );
+		return;
+	}
+	wave->func = NameToGenFunc( token );
+
+	// BASE, AMP, PHASE, FREQ
+	token = COM_ParseExt( text, qfalse );
+	if ( token[0] == 0 )
+	{
+		Com_Printf (S_COLOR_YELLOW  "WARNING: missing waveform parm in shader '%s'\n", shader.name );
+		return;
+	}
+	wave->base = atof( token );
+
+	token = COM_ParseExt( text, qfalse );
+	if ( token[0] == 0 )
+	{
+		Com_Printf (S_COLOR_YELLOW  "WARNING: missing waveform parm in shader '%s'\n", shader.name );
+		return;
+	}
+	wave->amplitude = atof( token );
+
+	token = COM_ParseExt( text, qfalse );
+	if ( token[0] == 0 )
+	{
+		Com_Printf (S_COLOR_YELLOW  "WARNING: missing waveform parm in shader '%s'\n", shader.name );
+		return;
+	}
+	wave->phase = atof( token );
+
+	token = COM_ParseExt( text, qfalse );
+	if ( token[0] == 0 )
+	{
+		Com_Printf (S_COLOR_YELLOW  "WARNING: missing waveform parm in shader '%s'\n", shader.name );
+		return;
+	}
+	wave->frequency = atof( token );
+}
+
+
+/*
+===================
+ParseTexMod
+===================
+*/
+static void ParseTexMod( const char *_text, shaderStage_t *stage )
+{
+	const char *token;
+	const char **text = &_text;
+	texModInfo_t *tmi;
+
+	if ( stage->bundle[0].numTexMods == TR_MAX_TEXMODS ) {
+		Com_Error( ERR_DROP, "ERROR: too many tcMod stages in shader '%s'\n", shader.name );
+		return;
+	}
+
+	tmi = &stage->bundle[0].texMods[stage->bundle[0].numTexMods];
+	stage->bundle[0].numTexMods++;
+
+	token = COM_ParseExt( text, qfalse );
+
+	//
+	// turb
+	//
+	if ( !Q_stricmp( token, "turb" ) )
+	{
+		token = COM_ParseExt( text, qfalse );
+		if ( token[0] == 0 )
+		{
+			Com_Printf (S_COLOR_YELLOW  "WARNING: missing tcMod turb parms in shader '%s'\n", shader.name );
+			return;
+		}
+		tmi->wave.base = atof( token );
+		token = COM_ParseExt( text, qfalse );
+		if ( token[0] == 0 )
+		{
+			Com_Printf (S_COLOR_YELLOW  "WARNING: missing tcMod turb in shader '%s'\n", shader.name );
+			return;
+		}
+		tmi->wave.amplitude = atof( token );
+		token = COM_ParseExt( text, qfalse );
+		if ( token[0] == 0 )
+		{
+			Com_Printf (S_COLOR_YELLOW  "WARNING: missing tcMod turb in shader '%s'\n", shader.name );
+			return;
+		}
+		tmi->wave.phase = atof( token );
+		token = COM_ParseExt( text, qfalse );
+		if ( token[0] == 0 )
+		{
+			Com_Printf (S_COLOR_YELLOW  "WARNING: missing tcMod turb in shader '%s'\n", shader.name );
+			return;
+		}
+		tmi->wave.frequency = atof( token );
+
+		tmi->type = TMOD_TURBULENT;
+	}
+	//
+	// scale
+	//
+	else if ( !Q_stricmp( token, "scale" ) )
+	{
+		token = COM_ParseExt( text, qfalse );
+		if ( token[0] == 0 )
+		{
+			Com_Printf (S_COLOR_YELLOW  "WARNING: missing scale parms in shader '%s'\n", shader.name );
+			return;
+		}
+		tmi->translate[0] = atof( token );	//scale unioned
+
+		token = COM_ParseExt( text, qfalse );
+		if ( token[0] == 0 )
+		{
+			Com_Printf (S_COLOR_YELLOW  "WARNING: missing scale parms in shader '%s'\n", shader.name );
+			return;
+		}
+		tmi->translate[1] = atof( token );	//scale unioned
+		tmi->type = TMOD_SCALE;
+	}
+	//
+	// scroll
+	//
+	else if ( !Q_stricmp( token, "scroll" ) )
+	{
+		token = COM_ParseExt( text, qfalse );
+		if ( token[0] == 0 )
+		{
+			Com_Printf (S_COLOR_YELLOW  "WARNING: missing scale scroll parms in shader '%s'\n", shader.name );
+			return;
+		}
+		tmi->translate[0] = atof( token );	//scroll unioned
+		token = COM_ParseExt( text, qfalse );
+		if ( token[0] == 0 )
+		{
+			Com_Printf (S_COLOR_YELLOW  "WARNING: missing scale scroll parms in shader '%s'\n", shader.name );
+			return;
+		}
+		tmi->translate[1] = atof( token );	//scroll unioned
+		tmi->type = TMOD_SCROLL;
+	}
+	//
+	// stretch
+	//
+	else if ( !Q_stricmp( token, "stretch" ) )
+	{
+		token = COM_ParseExt( text, qfalse );
+		if ( token[0] == 0 )
+		{
+			Com_Printf (S_COLOR_YELLOW  "WARNING: missing stretch parms in shader '%s'\n", shader.name );
+			return;
+		}
+		tmi->wave.func = NameToGenFunc( token );
+
+		token = COM_ParseExt( text, qfalse );
+		if ( token[0] == 0 )
+		{
+			Com_Printf (S_COLOR_YELLOW  "WARNING: missing stretch parms in shader '%s'\n", shader.name );
+			return;
+		}
+		tmi->wave.base = atof( token );
+
+		token = COM_ParseExt( text, qfalse );
+		if ( token[0] == 0 )
+		{
+			Com_Printf (S_COLOR_YELLOW  "WARNING: missing stretch parms in shader '%s'\n", shader.name );
+			return;
+		}
+		tmi->wave.amplitude = atof( token );
+
+		token = COM_ParseExt( text, qfalse );
+		if ( token[0] == 0 )
+		{
+			Com_Printf (S_COLOR_YELLOW  "WARNING: missing stretch parms in shader '%s'\n", shader.name );
+			return;
+		}
+		tmi->wave.phase = atof( token );
+
+		token = COM_ParseExt( text, qfalse );
+		if ( token[0] == 0 )
+		{
+			Com_Printf (S_COLOR_YELLOW  "WARNING: missing stretch parms in shader '%s'\n", shader.name );
+			return;
+		}
+		tmi->wave.frequency = atof( token );
+		
+		tmi->type = TMOD_STRETCH;
+	}
+	//
+	// transform
+	//
+	else if ( !Q_stricmp( token, "transform" ) )
+	{
+		token = COM_ParseExt( text, qfalse );
+		if ( token[0] == 0 )
+		{
+			Com_Printf (S_COLOR_YELLOW  "WARNING: missing transform parms in shader '%s'\n", shader.name );
+			return;
+		}
+		tmi->matrix[0][0] = atof( token );
+
+		token = COM_ParseExt( text, qfalse );
+		if ( token[0] == 0 )
+		{
+			Com_Printf (S_COLOR_YELLOW  "WARNING: missing transform parms in shader '%s'\n", shader.name );
+			return;
+		}
+		tmi->matrix[0][1] = atof( token );
+
+		token = COM_ParseExt( text, qfalse );
+		if ( token[0] == 0 )
+		{
+			Com_Printf (S_COLOR_YELLOW  "WARNING: missing transform parms in shader '%s'\n", shader.name );
+			return;
+		}
+		tmi->matrix[1][0] = atof( token );
+
+		token = COM_ParseExt( text, qfalse );
+		if ( token[0] == 0 )
+		{
+			Com_Printf (S_COLOR_YELLOW  "WARNING: missing transform parms in shader '%s'\n", shader.name );
+			return;
+		}
+		tmi->matrix[1][1] = atof( token );
+
+		token = COM_ParseExt( text, qfalse );
+		if ( token[0] == 0 )
+		{
+			Com_Printf (S_COLOR_YELLOW  "WARNING: missing transform parms in shader '%s'\n", shader.name );
+			return;
+		}
+		tmi->translate[0] = atof( token );
+
+		token = COM_ParseExt( text, qfalse );
+		if ( token[0] == 0 )
+		{
+			Com_Printf (S_COLOR_YELLOW  "WARNING: missing transform parms in shader '%s'\n", shader.name );
+			return;
+		}
+		tmi->translate[1] = atof( token );
+
+		tmi->type = TMOD_TRANSFORM;
+	}
+	//
+	// rotate
+	//
+	else if ( !Q_stricmp( token, "rotate" ) )
+	{
+		token = COM_ParseExt( text, qfalse );
+		if ( token[0] == 0 )
+		{
+			Com_Printf (S_COLOR_YELLOW  "WARNING: missing tcMod rotate parms in shader '%s'\n", shader.name );
+			return;
+		}
+		tmi->translate[0]= atof( token );	//rotateSpeed unioned
+		tmi->type = TMOD_ROTATE;
+	}
+	//
+	// entityTranslate
+	//
+	else if ( !Q_stricmp( token, "entityTranslate" ) )
+	{
+		tmi->type = TMOD_ENTITY_TRANSLATE;
+	}
+	else
+	{
+		Com_Printf (S_COLOR_YELLOW  "WARNING: unknown tcMod '%s' in shader '%s'\n", token, shader.name );
+	}
+}
+
+
+
+/*
+/////===== Part of the VERTIGON system =====/////
+===================
+ParseSurfaceSprites
+===================
+*/
+// surfaceSprites <type> <width> <height> <density> <fadedist>
+//
+// NOTE:  This parsing function used to be 12 pages long and very complex.  The new version of surfacesprites
+// utilizes optional parameters parsed in ParseSurfaceSpriteOptional.
+static void ParseSurfaceSprites( const char *_text, shaderStage_t *stage )
+{
+	const char *token;
+	const char **text = &_text;
+	float width, height, density, fadedist;
+	int sstype=SURFSPRITE_NONE;
+
+	//
+	// spritetype
+	//
+	token = COM_ParseExt( text, qfalse );
+
+	if (token[0]==0)
+	{
+		Com_Printf (S_COLOR_YELLOW  "WARNING: missing surfaceSprites params in shader '%s'\n", shader.name );
+		return;
+	}
+
+	if (!Q_stricmp(token, "vertical"))
+	{
+		sstype = SURFSPRITE_VERTICAL;
+	}
+	else if (!Q_stricmp(token, "oriented"))
+	{
+		sstype = SURFSPRITE_ORIENTED;
+	}
+	else if (!Q_stricmp(token, "effect"))
+	{
+		sstype = SURFSPRITE_EFFECT;
+	}
+	else
+	{
+		Com_Printf (S_COLOR_YELLOW  "WARNING: invalid type in shader '%s'\n", shader.name );
+		return;
+	}
+
+	//
+	// width
+	//
+	token = COM_ParseExt( text, qfalse );
+	if (token[0]==0)
+	{
+		Com_Printf (S_COLOR_YELLOW  "WARNING: missing surfaceSprites params in shader '%s'\n", shader.name );
+		return;
+	}
+	width=atof(token);
+	if (width <= 0)
+	{
+		Com_Printf (S_COLOR_YELLOW  "WARNING: invalid width in shader '%s'\n", shader.name );
+		return;
+	}
+
+	//
+	// height
+	//
+	token = COM_ParseExt( text, qfalse );
+	if (token[0]==0)
+	{
+		Com_Printf (S_COLOR_YELLOW  "WARNING: missing surfaceSprites params in shader '%s'\n", shader.name );
+		return;
+	}
+	height=atof(token);
+	if (height <= 0)
+	{
+		Com_Printf (S_COLOR_YELLOW  "WARNING: invalid height in shader '%s'\n", shader.name );
+		return;
+	}
+
+	//
+	// density
+	//
+	token = COM_ParseExt( text, qfalse );
+	if (token[0]==0)
+	{
+		Com_Printf (S_COLOR_YELLOW  "WARNING: missing surfaceSprites params in shader '%s'\n", shader.name );
+		return;
+	}
+	density=atof(token);
+	if (density <= 0)
+	{
+		Com_Printf (S_COLOR_YELLOW  "WARNING: invalid density in shader '%s'\n", shader.name );
+		return;
+	}
+
+	//
+	// fadedist
+	//
+	token = COM_ParseExt( text, qfalse );
+	if (token[0]==0)
+	{
+		Com_Printf (S_COLOR_YELLOW  "WARNING: missing surfaceSprites params in shader '%s'\n", shader.name );
+		return;
+	}
+	fadedist=atof(token);
+	if (fadedist < 32)
+	{
+		Com_Printf (S_COLOR_YELLOW  "WARNING: invalid fadedist (%f < 32) in shader '%s'\n", fadedist, shader.name );
+		return;
+	}
+
+	if (!stage->ss)
+	{
+		stage->ss = (surfaceSprite_t *)Hunk_Alloc( sizeof( surfaceSprite_t ), h_low );
+	}
+
+	// These are all set by the command lines.
+	stage->ss->surfaceSpriteType = sstype;
+	stage->ss->width = width;
+	stage->ss->height = height;
+	stage->ss->density = density;
+	stage->ss->fadeDist = fadedist;
+
+#ifdef _XBOX
+	shader.needsNormal = true;
+#endif
+
+	// These are defaults that can be overwritten.
+	stage->ss->fadeMax = fadedist*1.33;
+	stage->ss->fadeScale = 0.0;
+	stage->ss->wind = 0.0;
+	stage->ss->windIdle = 0.0;
+	stage->ss->variance[0] = 0.0;
+	stage->ss->variance[1] = 0.0;
+	stage->ss->facing = SURFSPRITE_FACING_NORMAL;
+
+	// A vertical parameter that needs a default regardless
+	stage->ss->vertSkew;
+
+	// These are effect parameters that need defaults nonetheless.
+	stage->ss->fxDuration = 1000;		// 1 second
+	stage->ss->fxGrow[0] = 0.0;
+	stage->ss->fxGrow[1] = 0.0;
+	stage->ss->fxAlphaStart = 1.0;	
+	stage->ss->fxAlphaEnd = 0.0;
+}
+
+
+
+
+/*
+/////===== Part of the VERTIGON system =====/////
+===========================
+ParseSurfaceSpritesOptional
+===========================
+*/
+//
+// ssFademax <fademax>
+// ssFadescale <fadescale>
+// ssVariance <varwidth> <varheight>
+// ssHangdown
+// ssAnyangle
+// ssFaceup
+// ssWind <wind>
+// ssWindIdle <windidle>
+// ssVertSkew <skew>
+// ssFXDuration <duration>
+// ssFXGrow <growwidth> <growheight>
+// ssFXAlphaRange <alphastart> <startend>
+// ssFXWeather
+//
+// Optional parameters that will override the defaults set in the surfacesprites command above.
+//
+static void ParseSurfaceSpritesOptional( const char *param, const char *_text, shaderStage_t *stage )
+{
+	const char *token;
+	const char **text = &_text;
+	float	value;
+
+	if (!stage->ss)
+	{
+		stage->ss = (surfaceSprite_t *)Hunk_Alloc( sizeof( surfaceSprite_t ), h_low );
+	}
+	//
+	// fademax
+	//
+	if (!Q_stricmp(param, "ssFademax"))
+	{
+		token = COM_ParseExt( text, qfalse);
+		if (token[0]==0)
+		{
+			Com_Printf (S_COLOR_YELLOW  "WARNING: missing surfacesprite fademax in shader '%s'\n", shader.name );
+			return;
+		}
+		value = atof(token);
+		if (value <= stage->ss->fadeDist)
+		{
+			Com_Printf (S_COLOR_YELLOW  "WARNING: invalid surfacesprite fademax (%.2f <= fadeDist(%.2f)) in shader '%s'\n", value, stage->ss->fadeDist, shader.name );
+			return;
+		}
+		stage->ss->fadeMax=value;
+		return;
+	}
+
+	//
+	// fadescale
+	//
+	if (!Q_stricmp(param, "ssFadescale"))
+	{
+		token = COM_ParseExt( text, qfalse);
+		if (token[0]==0)
+		{
+			Com_Printf (S_COLOR_YELLOW  "WARNING: missing surfacesprite fadescale in shader '%s'\n", shader.name );
+			return;
+		}
+		value = atof(token);
+		stage->ss->fadeScale=value;
+		return;
+	}
+
+	//
+	// variance
+	//
+	if (!Q_stricmp(param, "ssVariance"))
+	{
+		token = COM_ParseExt( text, qfalse);
+		if (token[0]==0)
+		{
+			Com_Printf (S_COLOR_YELLOW  "WARNING: missing surfacesprite variance width in shader '%s'\n", shader.name );
+			return;
+		}
+		value = atof(token);
+		if (value < 0)
+		{
+			Com_Printf (S_COLOR_YELLOW  "WARNING: invalid surfacesprite variance width in shader '%s'\n", shader.name );
+			return;
+		}
+		stage->ss->variance[0]=value;
+
+		token = COM_ParseExt( text, qfalse);
+		if (token[0]==0)
+		{
+			Com_Printf (S_COLOR_YELLOW  "WARNING: missing surfacesprite variance height in shader '%s'\n", shader.name );
+			return;
+		}
+		value = atof(token);
+		if (value < 0)
+		{
+			Com_Printf (S_COLOR_YELLOW  "WARNING: invalid surfacesprite variance height in shader '%s'\n", shader.name );
+			return;
+		}
+		stage->ss->variance[1]=value;
+		return;
+	}
+
+	//
+	// hangdown
+	//
+	if (!Q_stricmp(param, "ssHangdown"))
+	{
+		if (stage->ss->facing != SURFSPRITE_FACING_NORMAL)
+		{
+			Com_Printf (S_COLOR_YELLOW  "WARNING: Hangdown facing overrides previous facing in shader '%s'\n", shader.name );
+			return;
+		}
+		stage->ss->facing=SURFSPRITE_FACING_DOWN;
+		return;
+	}
+
+	//
+	// anyangle
+	//
+	if (!Q_stricmp(param, "ssAnyangle"))
+	{
+		if (stage->ss->facing != SURFSPRITE_FACING_NORMAL)
+		{
+			Com_Printf (S_COLOR_YELLOW  "WARNING: Anyangle facing overrides previous facing in shader '%s'\n", shader.name );
+			return;
+		}
+		stage->ss->facing=SURFSPRITE_FACING_ANY;
+		return;
+	}
+
+	//
+	// faceup
+	//
+	if (!Q_stricmp(param, "ssFaceup"))
+	{
+		if (stage->ss->facing != SURFSPRITE_FACING_NORMAL)
+		{
+			Com_Printf (S_COLOR_YELLOW  "WARNING: Faceup facing overrides previous facing in shader '%s'\n", shader.name );
+			return;
+		}
+		stage->ss->facing=SURFSPRITE_FACING_UP;
+		return;
+	}
+
+	//
+	// wind
+	//
+	if (!Q_stricmp(param, "ssWind"))
+	{
+		token = COM_ParseExt( text, qfalse);
+		if (token[0]==0)
+		{
+			Com_Printf (S_COLOR_YELLOW  "WARNING: missing surfacesprite wind in shader '%s'\n", shader.name );
+			return;
+		}
+		value = atof(token);
+		if (value < 0.0)
+		{
+			Com_Printf (S_COLOR_YELLOW  "WARNING: invalid surfacesprite wind in shader '%s'\n", shader.name );
+			return;
+		}
+		stage->ss->wind=value;
+		if (stage->ss->windIdle <= 0)
+		{	// Also override the windidle, it usually is the same as wind
+			stage->ss->windIdle = value;
+		}
+		return;
+	}
+
+	//
+	// windidle
+	//
+	if (!Q_stricmp(param, "ssWindidle"))
+	{
+		token = COM_ParseExt( text, qfalse);
+		if (token[0]==0)
+		{
+			Com_Printf (S_COLOR_YELLOW  "WARNING: missing surfacesprite windidle in shader '%s'\n", shader.name );
+			return;
+		}
+		value = atof(token);
+		if (value < 0.0)
+		{
+			Com_Printf (S_COLOR_YELLOW  "WARNING: invalid surfacesprite windidle in shader '%s'\n", shader.name );
+			return;
+		}
+		stage->ss->windIdle=value;
+		return;
+	}
+
+	//
+	// vertskew
+	//
+	if (!Q_stricmp(param, "ssVertskew"))
+	{
+		token = COM_ParseExt( text, qfalse);
+		if (token[0]==0)
+		{
+			Com_Printf (S_COLOR_YELLOW  "WARNING: missing surfacesprite vertskew in shader '%s'\n", shader.name );
+			return;
+		}
+		value = atof(token);
+		if (value < 0.0)
+		{
+			Com_Printf (S_COLOR_YELLOW  "WARNING: invalid surfacesprite vertskew in shader '%s'\n", shader.name );
+			return;
+		}
+		stage->ss->vertSkew=value;
+		return;
+	}
+
+	//
+	// fxduration
+	//
+	if (!Q_stricmp(param, "ssFXDuration"))
+	{
+		token = COM_ParseExt( text, qfalse);
+		if (token[0]==0)
+		{
+			Com_Printf (S_COLOR_YELLOW  "WARNING: missing surfacesprite duration in shader '%s'\n", shader.name );
+			return;
+		}
+		value = atof(token);
+		if (value <= 0)
+		{
+			Com_Printf (S_COLOR_YELLOW  "WARNING: invalid surfacesprite duration in shader '%s'\n", shader.name );
+			return;
+		}
+		stage->ss->fxDuration=value;
+		return;
+	}
+
+	//
+	// fxgrow
+	//
+	if (!Q_stricmp(param, "ssFXGrow"))
+	{
+		token = COM_ParseExt( text, qfalse);
+		if (token[0]==0)
+		{
+			Com_Printf (S_COLOR_YELLOW  "WARNING: missing surfacesprite grow width in shader '%s'\n", shader.name );
+			return;
+		}
+		value = atof(token);
+		if (value < 0)
+		{
+			Com_Printf (S_COLOR_YELLOW  "WARNING: invalid surfacesprite grow width in shader '%s'\n", shader.name );
+			return;
+		}
+		stage->ss->fxGrow[0]=value;
+
+		token = COM_ParseExt( text, qfalse);
+		if (token[0]==0)
+		{
+			Com_Printf (S_COLOR_YELLOW  "WARNING: missing surfacesprite grow height in shader '%s'\n", shader.name );
+			return;
+		}
+		value = atof(token);
+		if (value < 0)
+		{
+			Com_Printf (S_COLOR_YELLOW  "WARNING: invalid surfacesprite grow height in shader '%s'\n", shader.name );
+			return;
+		}
+		stage->ss->fxGrow[1]=value;
+		return;
+	}
+
+	//
+	// fxalpharange
+	//
+	if (!Q_stricmp(param, "ssFXAlphaRange"))
+	{
+		token = COM_ParseExt( text, qfalse);
+		if (token[0]==0)
+		{
+			Com_Printf (S_COLOR_YELLOW  "WARNING: missing surfacesprite fxalpha start in shader '%s'\n", shader.name );
+			return;
+		}
+		value = atof(token);
+		if (value < 0 || value > 1.0)
+		{
+			Com_Printf (S_COLOR_YELLOW  "WARNING: invalid surfacesprite fxalpha start in shader '%s'\n", shader.name );
+			return;
+		}
+		stage->ss->fxAlphaStart=value;
+
+		token = COM_ParseExt( text, qfalse);
+		if (token[0]==0)
+		{
+			Com_Printf (S_COLOR_YELLOW  "WARNING: missing surfacesprite fxalpha end in shader '%s'\n", shader.name );
+			return;
+		}
+		value = atof(token);
+		if (value < 0 || value > 1.0)
+		{
+			Com_Printf (S_COLOR_YELLOW  "WARNING: invalid surfacesprite fxalpha end in shader '%s'\n", shader.name );
+			return;
+		}
+		stage->ss->fxAlphaEnd=value;
+		return;
+	}
+
+	//
+	// fxweather
+	//
+	if (!Q_stricmp(param, "ssFXWeather"))
+	{
+		if (stage->ss->surfaceSpriteType != SURFSPRITE_EFFECT)
+		{
+			Com_Printf (S_COLOR_YELLOW  "WARNING: weather applied to non-effect surfacesprite in shader '%s'\n", shader.name );
+			return;
+		}
+		stage->ss->surfaceSpriteType = SURFSPRITE_WEATHERFX;
+		return;
+	}
+
+	// 
+	// invalid ss command.
+	//
+	Com_Printf (S_COLOR_YELLOW  "WARNING: invalid optional surfacesprite param '%s' in shader '%s'\n", param, shader.name );
+	return;
+}
+
+
+/*
+===================
+ParseStage
+===================
+*/
+static qboolean ParseStage( shaderStage_t *stage, const char **text )
+{
+	char *token;
+	int depthMaskBits = GLS_DEPTHMASK_TRUE, blendSrcBits = 0, blendDstBits = 0, atestBits = 0, depthFuncBits = 0;
+	qboolean depthMaskExplicit = qfalse;
+
+	stage->active = qtrue;
+
+	while ( 1 )
+	{
+		token = COM_ParseExt( text, qtrue );
+		if ( !token[0] )
+		{
+			Com_Printf (S_COLOR_YELLOW  "WARNING: no matching '}' found\n" );
+			return qfalse;
+		}
+
+		if ( token[0] == '}' )
+		{
+			break;
+		}
+		//
+		// map <name>
+		//
+		else if ( !Q_stricmp( token, "map" ) )
+		{
+			token = COM_ParseExt( text, qfalse );
+			if ( !token[0] )
+			{
+				Com_Printf (S_COLOR_YELLOW  "WARNING: missing parameter for 'map' keyword in shader '%s'\n", shader.name );
+				return qfalse;
+			}
+
+			if ( !Q_stricmp( token, "$whiteimage" ) )
+			{
+				stage->bundle[0].image = tr.whiteImage;
+				continue;
+			}
+			else if ( !Q_stricmp( token, "$lightmap" ) )
+			{
+				stage->bundle[0].isLightmap = qtrue;
+				if ( shader.lightmapIndex[0] < 0 || shader.lightmapIndex[0] >= tr.numLightmaps )
+				{
+#ifndef FINAL_BUILD
+					Com_Printf(S_COLOR_RED"Lightmap requested but none available for shader %s\n", shader.name);
+#endif
+					stage->bundle[0].image = tr.whiteImage;
+				}
+				else
+				{
+					stage->bundle[0].image = tr.lightmaps[shader.lightmapIndex[0]];
+				}
+				continue;
+			}
+			else
+			{
+#ifdef DEDICATED
+				stage->bundle[0].image = NULL;
+				return qfalse;
+#else
+				stage->bundle[0].image = R_FindImageFile( token, (qboolean)!shader.noMipMaps, (qboolean)!shader.noPicMip, (qboolean)!shader.noTC, GL_REPEAT );
+				if ( !stage->bundle[0].image )
+				{
+					Com_Printf (S_COLOR_YELLOW  "WARNING: R_FindImageFile could not find '%s' in shader '%s'\n", token, shader.name );
+					return qfalse;
+				}
+#endif // !DEDICATED
+			}
+		}
+#ifdef VV_LIGHTING
+		//
+		// specularmap <name>
+		//
+		else if ( !Q_stricmp( token, "specularmap" ) )
+		{
+			token = COM_ParseExt( text, qfalse );
+			if ( !token[0] )
+			{
+				Com_Printf( S_COLOR_YELLOW "WARNING: missing parameter for 'specularmap' keyword in shader '%s'\n", shader.name );
+				return qfalse;
+			}
+
+			stage->bundle[0].image = R_FindImageFile( token, !shader.noMipMaps, !shader.noPicMip, !shader.noTC, GL_REPEAT );
+			if ( !stage->bundle[0].image )
+			{
+				Com_Printf( S_COLOR_YELLOW "WARNING: R_FindImageFile could not find '%s' in shader '%s'\n", token, shader.name );
+				return qfalse;
+			}
+
+			stage->isSpecular = qtrue;
+
+			shader.needsNormal = true;
+			shader.needsTangent = true;
+		}
+#endif // VV_LIGHTING
+		//
+		// clampmap <name>
+		//
+		else if ( !Q_stricmp( token, "clampmap" ) )
+		{
+			token = COM_ParseExt( text, qfalse );
+			if ( !token[0] )
+			{
+				Com_Printf (S_COLOR_YELLOW  "WARNING: missing parameter for 'clampmap' keyword in shader '%s'\n", shader.name );
+				return qfalse;
+			}
+#ifdef DEDICATED
+			stage->bundle[0].image = NULL;
+			return qfalse;
+#else
+			stage->bundle[0].image = R_FindImageFile( token, (qboolean)!shader.noMipMaps, (qboolean)!shader.noPicMip, (qboolean)!shader.noTC, GL_CLAMP );
+			if ( !stage->bundle[0].image )
+			{
+				Com_Printf (S_COLOR_YELLOW  "WARNING: R_FindImageFile could not find '%s' in shader '%s'\n", token, shader.name );
+				return qfalse;
+			}
+#endif
+		}
+		//
+		// animMap <frequency> <image1> .... <imageN>
+		//
+		else if ( !Q_stricmp( token, "animMap" ) || !Q_stricmp( token, "clampanimMap" ) || !Q_stricmp( token, "oneshotanimMap" ))
+		{
+			#define	MAX_IMAGE_ANIMATIONS	32
+			image_t *images[MAX_IMAGE_ANIMATIONS];
+			bool bClamp = !Q_stricmp( token, "clampanimMap" );
+			bool oneShot = !Q_stricmp( token, "oneshotanimMap" );
+
+			token = COM_ParseExt( text, qfalse );
+			if ( !token[0] )
+			{
+				Com_Printf (S_COLOR_YELLOW  "WARNING: missing parameter for '%s' keyword in shader '%s'\n", (bClamp ? "animMap":"clampanimMap"), shader.name );
+				return qfalse;
+			}
+			stage->bundle[0].imageAnimationSpeed = atof( token );
+			stage->bundle[0].oneShotAnimMap = oneShot;
+
+			// parse up to MAX_IMAGE_ANIMATIONS animations
+			while ( 1 ) {
+				int		num;
+
+				token = COM_ParseExt( text, qfalse );
+				if ( !token[0] ) {
+					break;
+				}
+				num = stage->bundle[0].numImageAnimations;
+				if ( num < MAX_IMAGE_ANIMATIONS ) {
+#ifdef DEDICATED
+					stage->bundle[0].image = NULL;
+					return qfalse;
+#else
+					images[num] = R_FindImageFile( token, (qboolean)!shader.noMipMaps, (qboolean)!shader.noPicMip, (qboolean)!shader.noTC, bClamp?GL_CLAMP:GL_REPEAT );
+					if ( !images[num] )
+					{
+						Com_Printf (S_COLOR_YELLOW  "WARNING: R_FindImageFile could not find '%s' in shader '%s'\n", token, shader.name );
+						return qfalse;
+					}
+					stage->bundle[0].numImageAnimations++;
+#endif
+				}
+			}
+			// Copy image ptrs into an array of ptrs
+			stage->bundle[0].image = (image_t*) Hunk_Alloc( stage->bundle[0].numImageAnimations * sizeof( image_t* ), h_low );
+			memcpy( stage->bundle[0].image,	images,			stage->bundle[0].numImageAnimations * sizeof( image_t* ) );
+		}
+		else if ( !Q_stricmp( token, "videoMap" ) )
+		{
+			token = COM_ParseExt( text, qfalse );
+			if ( !token[0] )
+			{
+				Com_Printf (S_COLOR_YELLOW  "WARNING: missing parameter for 'videoMap' keyword in shader '%s'\n", shader.name );
+				return qfalse;
+			}
+#ifdef DEDICATED
+			stage->bundle[0].videoMapHandle = -1;
+#else
+			stage->bundle[0].videoMapHandle = CIN_PlayCinematic( token, 0, 0, 256, 256, (CIN_loop | CIN_silent | CIN_shader));
+#endif
+			if (stage->bundle[0].videoMapHandle != -1) {
+				stage->bundle[0].isVideoMap = qtrue;
+				assert (stage->bundle[0].videoMapHandle<NUM_SCRATCH_IMAGES);
+				stage->bundle[0].image = tr.scratchImage[stage->bundle[0].videoMapHandle];
+			}
+		}
+#ifdef _XBOX
+		//
+		// bumpmap <name>
+		//
+		else if ( !Q_stricmp( token, "bumpmap" ) )
+		{
+			token = COM_ParseExt( text, qfalse );
+			if( !token[0] )
+			{
+				Com_Printf( S_COLOR_YELLOW, "WARNING: missing parameter for 'bumpmap' keyword in shader '%s'\n", shader.name );
+				return qfalse;
+			}
+
+			stage->bundle[0].image = R_FindImageFile( token, !shader.noMipMaps, !shader.noPicMip, 0, GL_REPEAT );
+			if ( !stage->bundle[0].image )
+			{
+				Com_Printf( S_COLOR_YELLOW, "WARNING: R_FindImageFile could not find '%s' in shader '%s'\n", token, shader.name );
+				return qfalse;
+			}
+
+			stage->isBumpMap = qtrue;
+			shader.isBumpMap = qtrue;
+
+			shader.needsNormal = true;
+			shader.needsTangent = true;
+		}
+#endif
+		//
+		// alphafunc <func>
+		//
+		else if ( !Q_stricmp( token, "alphaFunc" ) )
+		{
+			token = COM_ParseExt( text, qfalse );
+			if ( !token[0] )
+			{
+				Com_Printf (S_COLOR_YELLOW  "WARNING: missing parameter for 'alphaFunc' keyword in shader '%s'\n", shader.name );
+				return qfalse;
+			}
+
+			atestBits = NameToAFunc( token );
+		}
+		//
+		// depthFunc <func>
+		//
+		else if ( !Q_stricmp( token, "depthfunc" ) )
+		{
+			token = COM_ParseExt( text, qfalse );
+
+			if ( !token[0] )
+			{
+				Com_Printf (S_COLOR_YELLOW  "WARNING: missing parameter for 'depthfunc' keyword in shader '%s'\n", shader.name );
+				return qfalse;
+			}
+
+			if ( !Q_stricmp( token, "lequal" ) )
+			{
+				depthFuncBits = 0;
+			}
+			else if ( !Q_stricmp( token, "equal" ) )
+			{
+				depthFuncBits = GLS_DEPTHFUNC_EQUAL;
+			}
+			else if ( !Q_stricmp( token, "disable" ) )
+			{
+				depthFuncBits = GLS_DEPTHTEST_DISABLE;
+			}
+			else
+			{
+				Com_Printf (S_COLOR_YELLOW  "WARNING: unknown depthfunc '%s' in shader '%s'\n", token, shader.name );
+				continue;
+			}
+		}
+		//
+		// detail
+		//
+		else if ( !Q_stricmp( token, "detail" ) )
+		{
+			stage->isDetail = qtrue;
+		}
+		//
+		// blendfunc <srcFactor> <dstFactor>
+		// or blendfunc <add|filter|blend>
+		//
+		else if ( !Q_stricmp( token, "blendfunc" ) )
+		{
+			token = COM_ParseExt( text, qfalse );
+			if ( token[0] == 0 )
+			{
+				Com_Printf (S_COLOR_YELLOW  "WARNING: missing parm for blendFunc in shader '%s'\n", shader.name );
+				continue;
+			}
+			// check for "simple" blends first
+			if ( !Q_stricmp( token, "add" ) ) {
+				blendSrcBits = GLS_SRCBLEND_ONE;
+				blendDstBits = GLS_DSTBLEND_ONE;
+			} else if ( !Q_stricmp( token, "filter" ) ) {
+				blendSrcBits = GLS_SRCBLEND_DST_COLOR;
+				blendDstBits = GLS_DSTBLEND_ZERO;
+			} else if ( !Q_stricmp( token, "blend" ) ) {
+				blendSrcBits = GLS_SRCBLEND_SRC_ALPHA;
+				blendDstBits = GLS_DSTBLEND_ONE_MINUS_SRC_ALPHA;
+			} else {
+				// complex double blends
+				blendSrcBits = NameToSrcBlendMode( token );
+
+				token = COM_ParseExt( text, qfalse );
+				if ( token[0] == 0 )
+				{
+					Com_Printf (S_COLOR_YELLOW  "WARNING: missing parm for blendFunc in shader '%s'\n", shader.name );
+					continue;
+				}
+				blendDstBits = NameToDstBlendMode( token );
+			}
+
+			// clear depth mask for blended surfaces
+			if ( !depthMaskExplicit )
+			{
+				depthMaskBits = 0;
+			}
+		}
+		//
+		// rgbGen
+		//
+		else if ( !Q_stricmp( token, "rgbGen" ) )
+		{
+			token = COM_ParseExt( text, qfalse );
+			if ( token[0] == 0 )
+			{
+				Com_Printf (S_COLOR_YELLOW  "WARNING: missing parameters for rgbGen in shader '%s'\n", shader.name );
+				continue;
+			}
+
+			if ( !Q_stricmp( token, "wave" ) )
+			{
+				ParseWaveForm( text, &stage->rgbWave );
+				stage->rgbGen = CGEN_WAVEFORM;
+			}
+			else if ( !Q_stricmp( token, "const" ) )
+			{
+				vec3_t	color;
+
+				ParseVector( text, 3, color );
+				stage->constantColor[0] = 255 * color[0];
+				stage->constantColor[1] = 255 * color[1];
+				stage->constantColor[2] = 255 * color[2];
+
+				stage->rgbGen = CGEN_CONST;
+			}
+			else if ( !Q_stricmp( token, "identity" ) )
+			{
+				stage->rgbGen = CGEN_IDENTITY;
+			}
+			else if ( !Q_stricmp( token, "identityLighting" ) )
+			{
+				stage->rgbGen = CGEN_IDENTITY_LIGHTING;
+			}
+			else if ( !Q_stricmp( token, "entity" ) )
+			{
+				stage->rgbGen = CGEN_ENTITY;
+			}
+			else if ( !Q_stricmp( token, "oneMinusEntity" ) )
+			{
+				stage->rgbGen = CGEN_ONE_MINUS_ENTITY;
+			}
+			else if ( !Q_stricmp( token, "vertex" ) )
+			{
+				stage->rgbGen = CGEN_VERTEX;
+				if ( stage->alphaGen == 0 ) {
+					stage->alphaGen = AGEN_VERTEX;
+				}
+			}
+			else if ( !Q_stricmp( token, "exactVertex" ) )
+			{
+				stage->rgbGen = CGEN_EXACT_VERTEX;
+			}
+			else if ( !Q_stricmp( token, "lightingDiffuse" ) )
+			{
+				stage->rgbGen = CGEN_LIGHTING_DIFFUSE;
+
+#ifdef _XBOX
+				shader.needsNormal = true;
+#endif
+			}
+			else if ( !Q_stricmp( token, "lightingDiffuseEntity" ) )
+			{
+				if (shader.lightmapIndex[0] != LIGHTMAP_NONE)
+				{
+					Com_Printf( S_COLOR_RED "ERROR: rgbGen lightingDiffuseEntity used on a misc_model! in shader '%s'\n", shader.name );
+				}
+				stage->rgbGen = CGEN_LIGHTING_DIFFUSE_ENTITY;
+
+#ifdef _XBOX
+				shader.needsNormal = true;
+#endif
+			}
+			else if ( !Q_stricmp( token, "oneMinusVertex" ) )
+			{
+				stage->rgbGen = CGEN_ONE_MINUS_VERTEX;
+			}
+			else
+			{
+				Com_Printf (S_COLOR_YELLOW  "WARNING: unknown rgbGen parameter '%s' in shader '%s'\n", token, shader.name );
+				continue;
+			}
+		}
+		//
+		// alphaGen 
+		//
+		else if ( !Q_stricmp( token, "alphaGen" ) )
+		{
+			token = COM_ParseExt( text, qfalse );
+			if ( token[0] == 0 )
+			{
+				Com_Printf (S_COLOR_YELLOW  "WARNING: missing parameters for alphaGen in shader '%s'\n", shader.name );
+				continue;
+			}
+
+			if ( !Q_stricmp( token, "wave" ) )
+			{
+				ParseWaveForm( text, &stage->alphaWave );
+				stage->alphaGen = AGEN_WAVEFORM;
+			}
+			else if ( !Q_stricmp( token, "const" ) )
+			{
+				token = COM_ParseExt( text, qfalse );
+				stage->constantColor[3] = 255 * atof( token );
+				stage->alphaGen = AGEN_CONST;
+			}
+			else if ( !Q_stricmp( token, "identity" ) )
+			{
+				stage->alphaGen = AGEN_IDENTITY;
+			}
+			else if ( !Q_stricmp( token, "entity" ) )
+			{
+				stage->alphaGen = AGEN_ENTITY;
+			}
+			else if ( !Q_stricmp( token, "oneMinusEntity" ) )
+			{
+				stage->alphaGen = AGEN_ONE_MINUS_ENTITY;
+			}
+			else if ( !Q_stricmp( token, "vertex" ) )
+			{
+				stage->alphaGen = AGEN_VERTEX;
+			}
+			else if ( !Q_stricmp( token, "lightingSpecular" ) )
+			{
+				stage->alphaGen = AGEN_LIGHTING_SPECULAR;
+			}
+			else if ( !Q_stricmp( token, "oneMinusVertex" ) )
+			{
+				stage->alphaGen = AGEN_ONE_MINUS_VERTEX;
+			}
+			else if ( !Q_stricmp( token, "dot" ) )
+			{
+				stage->alphaGen = AGEN_DOT;
+			}
+			else if ( !Q_stricmp( token, "oneMinusDot" ) )
+			{
+				stage->alphaGen = AGEN_ONE_MINUS_DOT;
+			}
+			else if ( !Q_stricmp( token, "portal" ) )
+			{
+				stage->alphaGen = AGEN_PORTAL;
+				token = COM_ParseExt( text, qfalse );
+				if ( token[0] == 0 )
+				{
+					shader.portalRange = 256;
+					Com_Printf (S_COLOR_YELLOW  "WARNING: missing range parameter for alphaGen portal in shader '%s', defaulting to 256\n", shader.name );
+				}
+				else
+				{
+					shader.portalRange = atof( token );
+				}
+			}
+			else
+			{
+				Com_Printf (S_COLOR_YELLOW  "WARNING: unknown alphaGen parameter '%s' in shader '%s'\n", token, shader.name );
+				continue;
+			}
+		}
+		//
+		// tcGen <function>
+		//
+		else if ( !Q_stricmp(token, "texgen") || !Q_stricmp( token, "tcGen" ) ) 
+		{
+			token = COM_ParseExt( text, qfalse );
+			if ( token[0] == 0 )
+			{
+				Com_Printf (S_COLOR_YELLOW  "WARNING: missing texgen parm in shader '%s'\n", shader.name );
+				continue;
+			}
+
+			if ( !Q_stricmp( token, "environment" ) )
+			{
+				stage->bundle[0].tcGen = TCGEN_ENVIRONMENT_MAPPED;
+#ifdef _XBOX
+				shader.needsNormal = true;
+#endif
+			}
+			else if ( !Q_stricmp( token, "lightmap" ) )
+			{
+				stage->bundle[0].tcGen = TCGEN_LIGHTMAP;
+			}
+			else if ( !Q_stricmp( token, "texture" ) || !Q_stricmp( token, "base" ) )
+			{
+				stage->bundle[0].tcGen = TCGEN_TEXTURE;
+			}
+			else if ( !Q_stricmp( token, "vector" ) )
+			{
+				stage->bundle[0].tcGenVectors = ( vec3_t *) Hunk_Alloc( 2 * sizeof( vec3_t ), h_low );
+				ParseVector( text, 3, stage->bundle[0].tcGenVectors[0] );
+				ParseVector( text, 3, stage->bundle[0].tcGenVectors[1] );
+
+				stage->bundle[0].tcGen = TCGEN_VECTOR;
+			}
+			else 
+			{
+				Com_Printf (S_COLOR_YELLOW  "WARNING: unknown texgen parm in shader '%s'\n", shader.name );
+			}
+		}
+		//
+		// tcMod <type> <...>
+		//
+		else if ( !Q_stricmp( token, "tcMod" ) )
+		{
+			char buffer[1024] = "";
+
+			while ( 1 )
+			{
+				token = COM_ParseExt( text, qfalse );
+				if ( token[0] == 0 )
+					break;
+				strcat( buffer, token );
+				strcat( buffer, " " );
+			}
+
+			ParseTexMod( buffer, stage );
+
+			continue;
+		}
+		//
+		// depthmask
+		//
+		else if ( !Q_stricmp( token, "depthwrite" ) )
+		{
+			depthMaskBits = GLS_DEPTHMASK_TRUE;
+			depthMaskExplicit = qtrue;
+
+			continue;
+		}
+		// If this stage has glow...	GLOWXXX
+		else if ( Q_stricmp( token, "glow" ) == 0 )
+		{
+			stage->glow = true;
+
+			continue;
+		}
+		//
+		// surfaceSprites <type> ...
+		//
+		else if ( !Q_stricmp( token, "surfaceSprites" ) )
+		{
+			char buffer[1024] = "";
+
+			while ( 1 )
+			{
+				token = COM_ParseExt( text, qfalse );
+				if ( token[0] == 0 )
+					break;
+				strcat( buffer, token );
+				strcat( buffer, " " );
+			}
+
+			ParseSurfaceSprites( buffer, stage );
+
+			continue;
+		}
+		//
+		// ssFademax <fademax>
+		// ssFadescale <fadescale>
+		// ssVariance <varwidth> <varheight>
+		// ssHangdown
+		// ssAnyangle
+		// ssFaceup
+		// ssWind <wind>
+		// ssWindIdle <windidle>
+		// ssDuration <duration>
+		// ssGrow <growwidth> <growheight>
+		// ssWeather
+		//
+		else if (!Q_stricmpn(token, "ss", 2))	// <--- NOTE ONLY COMPARING FIRST TWO LETTERS
+		{
+			char buffer[1024] = "";
+			char param[128];
+			strcpy(param,token);
+
+			while ( 1 )
+			{
+				token = COM_ParseExt( text, qfalse );
+				if ( token[0] == 0 )
+					break;
+				strcat( buffer, token );
+				strcat( buffer, " " );
+			}
+
+			ParseSurfaceSpritesOptional( param, buffer, stage );
+
+			continue;
+		}
+		else
+		{
+			Com_Printf (S_COLOR_YELLOW  "WARNING: unknown parameter '%s' in shader '%s'\n", token, shader.name );
+			return qfalse;
+		}
+	}
+
+	//
+	// if cgen isn't explicitly specified, use either identity or identitylighting
+	//
+	if ( stage->rgbGen == CGEN_BAD ) {
+		if ( //blendSrcBits == 0 ||
+			blendSrcBits == GLS_SRCBLEND_ONE || 
+			blendSrcBits == GLS_SRCBLEND_SRC_ALPHA ) {
+			stage->rgbGen = CGEN_IDENTITY_LIGHTING;
+		} else {
+			stage->rgbGen = CGEN_IDENTITY;
+		}
+	}
+
+
+	//
+	// implicitly assume that a GL_ONE GL_ZERO blend mask disables blending
+	//
+	if ( ( blendSrcBits == GLS_SRCBLEND_ONE ) && 
+		 ( blendDstBits == GLS_DSTBLEND_ZERO ) )
+	{
+		blendDstBits = blendSrcBits = 0;
+		depthMaskBits = GLS_DEPTHMASK_TRUE;
+	}
+
+	// decide which agens we can skip
+	if ( stage->alphaGen == AGEN_IDENTITY ) {
+		if ( stage->rgbGen == CGEN_IDENTITY
+			|| stage->rgbGen == CGEN_LIGHTING_DIFFUSE ) {
+			stage->alphaGen = AGEN_SKIP;
+		}
+	}
+
+	//
+	// compute state bits
+	//
+	stage->stateBits = depthMaskBits | 
+		               blendSrcBits | blendDstBits | 
+					   atestBits | 
+					   depthFuncBits;
+
+	return qtrue;
+}
+
+/*
+===============
+ParseDeform
+
+deformVertexes wave <spread> <waveform> <base> <amplitude> <phase> <frequency>
+deformVertexes normal <frequency> <amplitude>
+deformVertexes move <vector> <waveform> <base> <amplitude> <phase> <frequency>
+deformVertexes bulge <bulgeWidth> <bulgeHeight> <bulgeSpeed>
+deformVertexes projectionShadow
+deformVertexes autoSprite
+deformVertexes autoSprite2
+deformVertexes text[0-7]
+===============
+*/
+static void ParseDeform( const char **text ) {
+	char	*token;
+	deformStage_t	*ds;
+
+	token = COM_ParseExt( text, qfalse );
+	if ( token[0] == 0 )
+	{
+		Com_Printf (S_COLOR_YELLOW  "WARNING: missing deform parm in shader '%s'\n", shader.name );
+		return;
+	}
+
+	if ( shader.numDeforms == MAX_SHADER_DEFORMS ) {
+		Com_Printf (S_COLOR_YELLOW  "WARNING: MAX_SHADER_DEFORMS in '%s'\n", shader.name );
+		return;
+	}
+
+	shader.deforms[ shader.numDeforms ] = (deformStage_t *)Hunk_Alloc( sizeof( deformStage_t ), h_low );
+
+	ds = shader.deforms[ shader.numDeforms ];
+	shader.numDeforms++;
+
+	if ( !Q_stricmp( token, "projectionShadow" ) ) {
+		ds->deformation = DEFORM_PROJECTION_SHADOW;
+		return;
+	}
+
+	if ( !Q_stricmp( token, "autosprite" ) ) {
+		ds->deformation = DEFORM_AUTOSPRITE;
+		return;
+	}
+
+	if ( !Q_stricmp( token, "autosprite2" ) ) {
+		ds->deformation = DEFORM_AUTOSPRITE2;
+		return;
+	}
+
+	if ( !Q_stricmpn( token, "text", 4 ) ) {
+		int		n;
+		
+		n = token[4] - '0';
+		if ( n < 0 || n > 7 ) {
+			n = 0;
+		}
+		ds->deformation = (deform_t)(DEFORM_TEXT0 + n);
+		return;
+	}
+
+	if ( !Q_stricmp( token, "bulge" ) )	{
+		token = COM_ParseExt( text, qfalse );
+		if ( token[0] == 0 )
+		{
+			Com_Printf (S_COLOR_YELLOW  "WARNING: missing deformVertexes bulge parm in shader '%s'\n", shader.name );
+			return;
+		}
+		ds->bulgeWidth = atof( token );
+
+		token = COM_ParseExt( text, qfalse );
+		if ( token[0] == 0 )
+		{
+			Com_Printf (S_COLOR_YELLOW  "WARNING: missing deformVertexes bulge parm in shader '%s'\n", shader.name );
+			return;
+		}
+		ds->bulgeHeight = atof( token );
+
+		token = COM_ParseExt( text, qfalse );
+		if ( token[0] == 0 )
+		{
+			Com_Printf (S_COLOR_YELLOW  "WARNING: missing deformVertexes bulge parm in shader '%s'\n", shader.name );
+			return;
+		}
+		ds->bulgeSpeed = atof( token );
+
+		ds->deformation = DEFORM_BULGE;
+		return;
+	}
+
+	if ( !Q_stricmp( token, "wave" ) )
+	{
+		token = COM_ParseExt( text, qfalse );
+		if ( token[0] == 0 )
+		{
+			Com_Printf (S_COLOR_YELLOW  "WARNING: missing deformVertexes parm in shader '%s'\n", shader.name );
+			return;
+		}
+
+		if ( atof( token ) != 0 )
+		{
+			ds->deformationSpread = 1.0f / atof( token );
+		}
+		else
+		{
+			ds->deformationSpread = 100.0f;
+			Com_Printf (S_COLOR_YELLOW  "WARNING: illegal div value of 0 in deformVertexes command for shader '%s'\n", shader.name );
+		}
+
+		ParseWaveForm( text, &ds->deformationWave );
+		ds->deformation = DEFORM_WAVE;
+		return;
+	}
+
+	if ( !Q_stricmp( token, "normal" ) )
+	{
+		token = COM_ParseExt( text, qfalse );
+		if ( token[0] == 0 )
+		{
+			Com_Printf (S_COLOR_YELLOW  "WARNING: missing deformVertexes parm in shader '%s'\n", shader.name );
+			return;
+		}
+		ds->deformationWave.amplitude = atof( token );
+
+		token = COM_ParseExt( text, qfalse );
+		if ( token[0] == 0 )
+		{
+			Com_Printf (S_COLOR_YELLOW  "WARNING: missing deformVertexes parm in shader '%s'\n", shader.name );
+			return;
+		}
+		ds->deformationWave.frequency = atof( token );
+
+		ds->deformation = DEFORM_NORMALS;
+		return;
+	}
+
+	if ( !Q_stricmp( token, "move" ) ) {
+		int		i;
+
+		for ( i = 0 ; i < 3 ; i++ ) {
+			token = COM_ParseExt( text, qfalse );
+			if ( token[0] == 0 ) {
+				Com_Printf (S_COLOR_YELLOW  "WARNING: missing deformVertexes parm in shader '%s'\n", shader.name );
+				return;
+			}
+			ds->moveVector[i] = atof( token );
+		}
+
+		ParseWaveForm( text, &ds->deformationWave );
+		ds->deformation = DEFORM_MOVE;
+		return;
+	}
+
+	Com_Printf (S_COLOR_YELLOW  "WARNING: unknown deformVertexes subtype '%s' found in shader '%s'\n", token, shader.name );
+}
+
+
+/*
+===============
+ParseSkyParms
+
+skyParms <outerbox> <cloudheight> <innerbox>
+===============
+*/
+static void ParseSkyParms( const char **text ) {
+	char		*token;
+	const char	*suf[6] = {"rt", "lf", "bk", "ft", "up", "dn"};
+	char		pathname[MAX_QPATH];
+	int			i;
+
+	shader.sky = (skyParms_t *)Hunk_Alloc( sizeof( skyParms_t ), h_low );
+
+	// outerbox
+	token = COM_ParseExt( text, qfalse );
+	if ( token[0] == 0 ) {
+		Com_Printf (S_COLOR_YELLOW  "WARNING: 'skyParms' missing parameter in shader '%s'\n", shader.name );
+		return;
+	}
+	if ( strcmp( token, "-" ) ) {
+		for (i=0 ; i<6 ; i++) {
+			Com_sprintf( pathname, sizeof(pathname), "%s_%s", token, suf[i] );
+#ifdef DEDICATED
+			shader.sky->outerbox[i] = NULL;
+#else
+			shader.sky->outerbox[i] = R_FindImageFile( ( char * ) pathname, qtrue, qtrue, (qboolean)!shader.noTC, GL_CLAMP );
+			if ( !shader.sky->outerbox[i] ) {
+				if (i) {
+					shader.sky->outerbox[i] = shader.sky->outerbox[i-1];//not found, so let's use the previous image
+				}else{
+					shader.sky->outerbox[i] = tr.defaultImage;
+				}
+			}
+#endif
+		}
+	}
+
+	// cloudheight
+	token = COM_ParseExt( text, qfalse );
+	if ( token[0] == 0 ) {
+		Com_Printf (S_COLOR_YELLOW  "WARNING: 'skyParms' missing cloudheight in shader '%s'\n", shader.name );
+		return;
+	}
+	shader.sky->cloudHeight = atof( token );
+	if ( !shader.sky->cloudHeight ) {
+		shader.sky->cloudHeight = 512;
+	}
+#ifndef DEDICATED
+	R_InitSkyTexCoords( shader.sky->cloudHeight );
+#endif
+
+	// innerbox
+	token = COM_ParseExt( text, qfalse );
+	if ( strcmp( token, "-" ) ) {
+		Com_Printf (S_COLOR_YELLOW  "WARNING: in shader '%s' 'skyParms', innerbox is not supported!", shader.name);
+	}
+}
+
+
+/*
+=================
+ParseSort
+=================
+*/
+static void ParseSort( const char **text ) {
+	char	*token;
+
+	token = COM_ParseExt( text, qfalse );
+	if ( token[0] == 0 ) {
+		Com_Printf (S_COLOR_YELLOW  "WARNING: missing sort parameter in shader '%s'\n", shader.name );
+		return;
+	}
+
+	if ( !Q_stricmp( token, "portal" ) ) {
+		shader.sort = SS_PORTAL;
+	} else if ( !Q_stricmp( token, "sky" ) ) {
+		shader.sort = SS_ENVIRONMENT;
+	} else if ( !Q_stricmp( token, "opaque" ) ) {
+		shader.sort = SS_OPAQUE;
+	} else if ( !Q_stricmp( token, "decal" ) ) {
+		shader.sort = SS_DECAL;
+	} else if ( !Q_stricmp( token, "seeThrough" ) ) {
+		shader.sort = SS_SEE_THROUGH;
+	} else if ( !Q_stricmp( token, "banner" ) ) {
+		shader.sort = SS_BANNER;
+	} else if ( !Q_stricmp( token, "additive" ) ) {
+		shader.sort = SS_BLEND1;
+	} else if ( !Q_stricmp( token, "nearest" ) ) {
+		shader.sort = SS_NEAREST;
+	} else if ( !Q_stricmp( token, "underwater" ) ) {
+		shader.sort = SS_UNDERWATER;
+	} else if ( !Q_stricmp( token, "inside" ) ) {
+		shader.sort = SS_INSIDE;
+	} else if ( !Q_stricmp( token, "mid_inside" ) ) {
+		shader.sort = SS_MID_INSIDE;
+	} else if ( !Q_stricmp( token, "middle" ) ) {
+		shader.sort = SS_MIDDLE;
+	} else if ( !Q_stricmp( token, "mid_outside" ) ) {
+		shader.sort = SS_MID_OUTSIDE;
+	} else if ( !Q_stricmp( token, "outside" ) ) {
+		shader.sort = SS_OUTSIDE;
+	}	
+	else {
+		shader.sort = atof( token );
+	}
+}
+
+/*
+=================
+ParseMaterial
+=================
+*/
+const char *materialNames[MATERIAL_LAST] =
+{
+	MATERIALS
+};
+
+void ParseMaterial( const char **text ) 
+{
+	char	*token;
+	int		i;
+
+	token = COM_ParseExt( text, qfalse );
+	if ( token[0] == 0 ) 
+	{
+		Com_Printf (S_COLOR_YELLOW  "WARNING: missing material in shader '%s'\n", shader.name );
+		return;
+	}
+	for(i = 0; i < MATERIAL_LAST; i++)
+	{
+		if ( !Q_stricmp( token, materialNames[i] ) ) 
+		{
+			shader.surfaceFlags |= i;
+			break;
+		}
+	}
+}
+
+
+// this table is also present in q3map
+
+typedef struct {
+	char	*name;
+	int		clearSolid, surfaceFlags, contents;
+} infoParm_t;
+
+
+infoParm_t	infoParms[] = {
+	// Game content Flags
+	{"nonsolid", 	~CONTENTS_SOLID,	0, 				0 },						// special hack to clear solid flag
+	{"nonopaque", 	~CONTENTS_OPAQUE,	0, 				0 },						// special hack to clear opaque flag
+	{"lava",		~CONTENTS_SOLID,	0,				CONTENTS_LAVA },			// very damaging
+	{"slime",		~CONTENTS_SOLID,	0,				CONTENTS_SLIME },			// mildly damaging
+	{"water",		~CONTENTS_SOLID,	0,				CONTENTS_WATER },
+	{"fog",			~CONTENTS_SOLID,	0,				CONTENTS_FOG},				// carves surfaces entering
+	{"shotclip",	~CONTENTS_SOLID,	0,				CONTENTS_SHOTCLIP },		/* block shots, but not people */
+	{"playerclip",	~(CONTENTS_SOLID|CONTENTS_OPAQUE),0,CONTENTS_PLAYERCLIP },	   	/* block only the player */ 
+	{"monsterclip",	~(CONTENTS_SOLID|CONTENTS_OPAQUE),0,CONTENTS_MONSTERCLIP },		
+	{"botclip",		~(CONTENTS_SOLID|CONTENTS_OPAQUE),0,CONTENTS_BOTCLIP },		   	/* for bots */															
+	{"trigger",		~(CONTENTS_SOLID|CONTENTS_OPAQUE),0,CONTENTS_TRIGGER },
+	{"nodrop",		~(CONTENTS_SOLID|CONTENTS_OPAQUE),0,CONTENTS_NODROP },			// don't drop items or leave bodies (death fog, lava, etc)
+	{"terrain",		~(CONTENTS_SOLID|CONTENTS_OPAQUE),0,CONTENTS_TERRAIN },		   	/* use special terrain collsion */										
+	{"ladder",		~(CONTENTS_SOLID|CONTENTS_OPAQUE),0,CONTENTS_LADDER },			// climb up in it like water
+	{"abseil",		~(CONTENTS_SOLID|CONTENTS_OPAQUE),0,CONTENTS_ABSEIL },			// can abseil down this brush
+	{"outside",		~(CONTENTS_SOLID|CONTENTS_OPAQUE),0,CONTENTS_OUTSIDE },			// volume is considered to be in the outside (i.e. not indoors)
+	{"inside",		~(CONTENTS_SOLID|CONTENTS_OPAQUE),0,CONTENTS_INSIDE },			// volume is considered to be inside (i.e. indoors)
+
+																		
+	{"detail",		-1,					0,				CONTENTS_DETAIL },			// don't include in structural bsp
+	{"trans",		-1,					0,				CONTENTS_TRANSLUCENT },		// surface has an alpha component
+	
+	/* Game surface flags */
+	{"sky",			-1,					SURF_SKY,		0 },					   	/* emit light from an environment map */
+	{"slick",		-1,					SURF_SLICK,		0 },
+
+	{"nodamage",	-1,					SURF_NODAMAGE,	0 },					   	   																	
+	{"noimpact",	-1,					SURF_NOIMPACT,	0 },					   	/* don't make impact explosions or marks */
+	{"nomarks",		-1,					SURF_NOMARKS,	0 },					   	/* don't make impact marks, but still explode */
+	{"nodraw",		-1,					SURF_NODRAW,	0 },					   	/* don't generate a drawsurface (or a lightmap) */
+	{"nosteps",		-1,					SURF_NOSTEPS,	0 },
+	{"nodlight",	-1,					SURF_NODLIGHT,	0 },					   	/* don't ever add dynamic lights */
+	{"metalsteps",	-1,					SURF_METALSTEPS,0 },
+	{"nomiscents",	-1,					SURF_NOMISCENTS,0 },						/* No misc ents on this surface */
+	{"forcefield",	-1,					SURF_FORCEFIELD,0 },
+};
+
+
+/*
+===============
+ParseSurfaceParm
+
+surfaceparm <name>
+===============
+*/
+static void ParseSurfaceParm( const char **text ) {
+	char	*token;
+	int		numInfoParms = sizeof(infoParms) / sizeof(infoParms[0]);
+	int		i;
+
+	token = COM_ParseExt( text, qfalse );
+	for ( i = 0 ; i < numInfoParms ; i++ ) {
+		if ( !Q_stricmp( token, infoParms[i].name ) ) {
+			shader.surfaceFlags |= infoParms[i].surfaceFlags;
+			shader.contentFlags |= infoParms[i].contents;
+			shader.contentFlags &= infoParms[i].clearSolid;
+			break;
+		}
+	}
+}
+
+/*
+=================
+ParseShader
+
+The current text pointer is at the explicit text definition of the
+shader.  Parse it into the global shader variable.  Later functions
+will optimize it.
+=================
+*/
+static qboolean ParseShader( const char **text )
+{
+	char *token;
+	int s;
+
+	s = 0;
+
+#ifdef _XBOX
+	shader.needsNormal = false;
+	shader.needsTangent = false;
+#endif
+
+	token = COM_ParseExt( text, qtrue );
+	if ( token[0] != '{' )
+	{
+		Com_Printf (S_COLOR_YELLOW  "WARNING: expecting '{', found '%s' instead in shader '%s'\n", token, shader.name );
+		return qfalse;
+	}
+
+	while ( 1 )
+	{
+		token = COM_ParseExt( text, qtrue );
+		if ( !token[0] )
+		{
+			Com_Printf (S_COLOR_YELLOW  "WARNING: no concluding '}' in shader %s\n", shader.name );
+			return qfalse;
+		}
+
+		// end of shader definition
+		if ( token[0] == '}' )
+		{
+			break;
+		}
+		// stage definition
+		else if ( token[0] == '{' )
+		{
+			if ( !ParseStage( &stages[s], text ) )
+			{
+				return qfalse;
+			}
+			stages[s].active = qtrue;
+#ifndef _XBOX	// GLOWXXX
+			if ( stages[s].glow )
+			{
+				shader.hasGlow = true;
+			}
+#endif
+			s++;
+			continue;
+		}
+		// skip stuff that only the QuakeEdRadient needs
+		else if ( !Q_stricmpn( token, "qer", 3 ) ) {
+			SkipRestOfLine( text );
+			continue;
+		}
+		// material deprecated as of 11 Jan 01
+		// material undeprecated as of 7 May 01 - q3map_material deprecated
+		else if ( !Q_stricmp( token, "material" ) || !Q_stricmp( token, "q3map_material" ) )
+		{
+			ParseMaterial( text );
+		}
+		// sun parms
+		else if ( !Q_stricmp( token, "sun" ) || !Q_stricmp( token, "q3map_sun" ) ) 
+		{			
+			token = COM_ParseExt( text, qfalse );
+			tr.sunLight[0] = atof( token );
+			token = COM_ParseExt( text, qfalse );
+			tr.sunLight[1] = atof( token );
+			token = COM_ParseExt( text, qfalse );
+			tr.sunLight[2] = atof( token );
+			
+			VectorNormalize( tr.sunLight );
+
+			token = COM_ParseExt( text, qfalse );
+			float a = atof( token );
+			VectorScale( tr.sunLight, a, tr.sunLight);
+
+			token = COM_ParseExt( text, qfalse );
+			a = atof( token );
+			a = a / 180 * M_PI;
+
+			token = COM_ParseExt( text, qfalse );
+			float b = atof( token );
+			b = b / 180 * M_PI;
+
+			tr.sunDirection[0] = cos( a ) * cos( b );
+			tr.sunDirection[1] = sin( a ) * cos( b );
+			tr.sunDirection[2] = sin( b );
+		}
+		// q3map_surfacelight deprecated as of 16 Jul 01
+		else if ( !Q_stricmp( token, "surfacelight" ) || !Q_stricmp( token, "q3map_surfacelight" ) ) 
+		{
+			token = COM_ParseExt( text, qfalse );
+			tr.sunSurfaceLight = atoi( token );
+		}
+		else if ( !Q_stricmp( token, "lightColor" ) ) 
+		{
+			/*
+			if ( !ParseVector( text, 3, tr.sunAmbient ) ) 
+			{
+				return qfalse;
+			}
+			*/
+			//SP skips this so I'm skipping it here too.
+			SkipRestOfLine( text );
+			continue;
+		}
+		else if ( !Q_stricmp( token, "deformvertexes" ) || !Q_stricmp( token, "deform" )) {
+			ParseDeform( text );
+			continue;
+		}
+		else if ( !Q_stricmp( token, "tesssize" ) ) {
+			SkipRestOfLine( text );
+			continue;
+		}
+		else if ( !Q_stricmp( token, "clampTime" ) ) {
+			token = COM_ParseExt( text, qfalse );
+      if (token[0]) {
+        shader.clampTime = atof(token);
+      }
+    }
+		// skip stuff that only the q3map needs
+		else if ( !Q_stricmpn( token, "q3map", 5 ) ) {
+			SkipRestOfLine( text );
+			continue;
+		}
+		// skip stuff that only q3map or the server needs
+		else if ( !Q_stricmp( token, "surfaceParm" ) ) {
+			ParseSurfaceParm( text );
+			continue;
+		}
+		// no mip maps
+		else if ( !Q_stricmp( token, "nomipmaps" ) )
+		{
+			shader.noMipMaps = true;
+			shader.noPicMip = true;
+			continue;
+		}
+		// no picmip adjustment
+		else if ( !Q_stricmp( token, "nopicmip" ) )
+		{
+			shader.noPicMip = true;
+			continue;
+		}
+		else if ( !Q_stricmp( token, "noglfog" ) )
+		{
+			shader.fogPass = FP_NONE;
+			continue;
+		}
+		// polygonOffset
+		else if ( !Q_stricmp( token, "polygonOffset" ) )
+		{
+			shader.polygonOffset = true;
+			continue;
+		}
+		else if ( !Q_stricmp( token, "noTC" ) )
+		{
+			shader.noTC = true;
+			continue;
+		}
+		// entityMergable, allowing sprite surfaces from multiple entities
+		// to be merged into one batch.  This is a savings for smoke
+		// puffs and blood, but can't be used for anything where the
+		// shader calcs (not the surface function) reference the entity color or scroll
+		else if ( !Q_stricmp( token, "entityMergable" ) )
+		{
+			shader.entityMergable = true;
+			continue;
+		}
+		// fogParms
+		else if ( !Q_stricmp( token, "fogParms" ) ) 
+		{
+			shader.fogParms = (fogParms_t *)Hunk_Alloc( sizeof( fogParms_t ), h_low );
+			if ( !ParseVector( text, 3, shader.fogParms->color ) ) {
+				return qfalse;
+			}
+
+			token = COM_ParseExt( text, qfalse );
+			if ( !token[0] ) 
+			{
+				Com_Printf (S_COLOR_YELLOW  "WARNING: missing parm for 'fogParms' keyword in shader '%s'\n", shader.name );
+				continue;
+			}
+			shader.fogParms->depthForOpaque = atof( token );
+
+			// skip any old gradient directions
+			SkipRestOfLine( text );
+			continue;
+		}
+		// portal
+		else if ( !Q_stricmp(token, "portal") )
+		{
+			shader.sort = SS_PORTAL;
+			continue;
+		}
+		// skyparms <cloudheight> <outerbox> <innerbox>
+		else if ( !Q_stricmp( token, "skyparms" ) )
+		{
+			ParseSkyParms( text );
+			continue;
+		}
+		// light <value> determines flaring in q3map, not needed here
+		else if ( !Q_stricmp(token, "light") ) 
+		{
+			token = COM_ParseExt( text, qfalse );
+			continue;
+		}
+		// cull <face>
+		else if ( !Q_stricmp( token, "cull") ) 
+		{
+			token = COM_ParseExt( text, qfalse );
+			if ( token[0] == 0 )
+			{
+				Com_Printf (S_COLOR_YELLOW  "WARNING: missing cull parms in shader '%s'\n", shader.name );
+				continue;
+			}
+
+			if ( !Q_stricmp( token, "none" ) || !Q_stricmp( token, "twosided" ) || !Q_stricmp( token, "disable" ) )
+			{
+				shader.cullType = CT_TWO_SIDED;
+			}
+			else if ( !Q_stricmp( token, "back" ) || !Q_stricmp( token, "backside" ) || !Q_stricmp( token, "backsided" ) )
+			{
+				shader.cullType = CT_BACK_SIDED;
+			}
+			else
+			{
+				Com_Printf (S_COLOR_YELLOW  "WARNING: invalid cull parm '%s' in shader '%s'\n", token, shader.name );
+			}
+			continue;
+		}
+		// sort
+		else if ( !Q_stricmp( token, "sort" ) )
+		{
+			ParseSort( text );
+			continue;
+		}
+		else
+		{
+			Com_Printf (S_COLOR_YELLOW  "WARNING: unknown general shader parameter '%s' in '%s'\n", token, shader.name );
+			return qfalse;
+		}
+	}
+
+	//
+	// ignore shaders that don't have any stages, unless it is a sky or fog
+	//
+	if ( s == 0 && !shader.sky && !(shader.contentFlags & CONTENTS_FOG ) ) {
+		return qfalse;
+	}
+
+	shader.explicitlyDefined = true;
+
+	return qtrue;
+}
+
+/*
+========================================================================================
+
+SHADER OPTIMIZATION AND FOGGING
+
+========================================================================================
+*/
+
+typedef struct {
+	int		blendA;
+	int		blendB;
+
+	int		multitextureEnv;
+	int		multitextureBlend;
+} collapse_t;
+
+#ifndef DEDICATED
+static collapse_t	collapse[] = {
+	{ 0, GLS_DSTBLEND_SRC_COLOR | GLS_SRCBLEND_ZERO,	
+		GL_MODULATE, 0 },
+
+	{ 0, GLS_DSTBLEND_ZERO | GLS_SRCBLEND_DST_COLOR,
+		GL_MODULATE, 0 },
+
+	{ GLS_DSTBLEND_ZERO | GLS_SRCBLEND_DST_COLOR, GLS_DSTBLEND_ZERO | GLS_SRCBLEND_DST_COLOR,
+		GL_MODULATE, GLS_DSTBLEND_ZERO | GLS_SRCBLEND_DST_COLOR },
+
+	{ GLS_DSTBLEND_SRC_COLOR | GLS_SRCBLEND_ZERO, GLS_DSTBLEND_ZERO | GLS_SRCBLEND_DST_COLOR,
+		GL_MODULATE, GLS_DSTBLEND_ZERO | GLS_SRCBLEND_DST_COLOR },
+
+	{ GLS_DSTBLEND_ZERO | GLS_SRCBLEND_DST_COLOR, GLS_DSTBLEND_SRC_COLOR | GLS_SRCBLEND_ZERO,
+		GL_MODULATE, GLS_DSTBLEND_ZERO | GLS_SRCBLEND_DST_COLOR },
+
+	{ GLS_DSTBLEND_SRC_COLOR | GLS_SRCBLEND_ZERO, GLS_DSTBLEND_SRC_COLOR | GLS_SRCBLEND_ZERO,
+		GL_MODULATE, GLS_DSTBLEND_ZERO | GLS_SRCBLEND_DST_COLOR },
+
+	{ 0, GLS_DSTBLEND_ONE | GLS_SRCBLEND_ONE,
+		GL_ADD, 0 },
+
+	{ GLS_DSTBLEND_ONE | GLS_SRCBLEND_ONE, GLS_DSTBLEND_ONE | GLS_SRCBLEND_ONE,
+		GL_ADD, GLS_DSTBLEND_ONE | GLS_SRCBLEND_ONE },
+#if 0
+	{ 0, GLS_DSTBLEND_ONE_MINUS_SRC_ALPHA | GLS_SRCBLEND_SRC_ALPHA,
+		GL_DECAL, 0 },
+#endif
+	{ -1 }
+};
+#endif // !DEDICATED
+/*
+================
+CollapseMultitexture
+
+Attempt to combine two stages into a single multitexture stage
+FIXME: I think modulated add + modulated add collapses incorrectly
+=================
+*/
+static qboolean CollapseMultitexture( void ) {
+#ifdef DEDICATED
+	return qfalse;
+#else
+	int abits, bbits;
+	int i;
+	textureBundle_t tmpBundle;
+	if ( !qglActiveTextureARB ) {
+		return qfalse;
+	}
+
+	// make sure both stages are active
+	if ( !stages[0].active || !stages[1].active ) {
+		return qfalse;
+	}
+
+	abits = stages[0].stateBits;
+	bbits = stages[1].stateBits;
+
+	// make sure that both stages have identical state other than blend modes
+	if ( ( abits & ~( GLS_DSTBLEND_BITS | GLS_SRCBLEND_BITS | GLS_DEPTHMASK_TRUE ) ) !=
+		( bbits & ~( GLS_DSTBLEND_BITS | GLS_SRCBLEND_BITS | GLS_DEPTHMASK_TRUE ) ) ) {
+		return qfalse;
+	}
+
+	abits &= ( GLS_DSTBLEND_BITS | GLS_SRCBLEND_BITS );
+	bbits &= ( GLS_DSTBLEND_BITS | GLS_SRCBLEND_BITS );
+
+	// search for a valid multitexture blend function
+	for ( i = 0; collapse[i].blendA != -1 ; i++ ) {
+		if ( abits == collapse[i].blendA
+			&& bbits == collapse[i].blendB ) {
+			break;
+		}
+	}
+
+	// nothing found
+	if ( collapse[i].blendA == -1 ) {
+		return qfalse;
+	}
+
+	// GL_ADD is a separate extension
+	if ( collapse[i].multitextureEnv == GL_ADD && !glConfig.textureEnvAddAvailable ) {
+		return qfalse;
+	}
+
+	// make sure waveforms have identical parameters
+	if ( ( stages[0].rgbGen != stages[1].rgbGen ) ||
+		( stages[0].alphaGen != stages[1].alphaGen ) )  {
+		return qfalse;
+	}
+
+	// an add collapse can only have identity colors
+	if ( collapse[i].multitextureEnv == GL_ADD && stages[0].rgbGen != CGEN_IDENTITY ) {
+		return qfalse;
+	}
+
+	if ( stages[0].rgbGen == CGEN_WAVEFORM )
+	{
+		if ( memcmp( &stages[0].rgbWave,
+					 &stages[1].rgbWave,
+					 sizeof( stages[0].rgbWave ) ) )
+		{
+			return qfalse;
+		}
+	}
+	if ( stages[0].alphaGen == CGEN_WAVEFORM )
+	{
+		if ( memcmp( &stages[0].alphaWave,
+					 &stages[1].alphaWave,
+					 sizeof( stages[0].alphaWave ) ) )
+		{
+			return qfalse;
+		}
+	}
+
+
+	// make sure that lightmaps are in bundle 1 for 3dfx
+	if ( stages[0].bundle[0].isLightmap )
+	{
+		tmpBundle = stages[0].bundle[0];
+		stages[0].bundle[0] = stages[1].bundle[0];
+		stages[0].bundle[1] = tmpBundle;
+	}
+	else
+	{
+		stages[0].bundle[1] = stages[1].bundle[0];
+	}
+
+	// set the new blend state bits
+	shader.multitextureEnv = collapse[i].multitextureEnv;
+	stages[0].stateBits &= ~( GLS_DSTBLEND_BITS | GLS_SRCBLEND_BITS );
+	stages[0].stateBits |= collapse[i].multitextureBlend;
+
+	//
+	// move down subsequent shaders
+	//
+	memmove( &stages[1], &stages[2], sizeof( stages[0] ) * ( MAX_SHADER_STAGES - 2 ) );
+	Com_Memset( &stages[MAX_SHADER_STAGES-1], 0, sizeof( stages[0] ) );
+#endif //!DEDICATED
+	return qtrue;
+}
+
+
+/*
+==============
+SortNewShader
+
+Positions the most recently created shader in the tr.sortedShaders[]
+array so that the shader->sort key is sorted reletive to the other
+shaders.
+
+Sets shader->sortedIndex
+==============
+*/
+static void SortNewShader( void ) {
+	int		i;
+	float	sort;
+	shader_t	*newShader;
+
+	newShader = tr.shaders[ tr.numShaders - 1 ];
+	sort = newShader->sort;
+
+	for ( i = tr.numShaders - 2 ; i >= 0 ; i-- ) {
+		if ( tr.sortedShaders[ i ]->sort <= sort ) {
+			break;
+		}
+		tr.sortedShaders[i+1] = tr.sortedShaders[i];
+		tr.sortedShaders[i+1]->sortedIndex++;
+	}
+
+	newShader->sortedIndex = i+1;
+	tr.sortedShaders[i+1] = newShader;
+}
+
+
+/*
+====================
+GeneratePermanentShader
+====================
+*/
+static shader_t *GeneratePermanentShader( void ) {
+	shader_t	*newShader;
+	int			i, b;
+	int			size;
+
+	if ( tr.numShaders == MAX_SHADERS ) {
+		//Com_Printf (S_COLOR_YELLOW  "WARNING: GeneratePermanentShader - MAX_SHADERS hit\n");
+		Com_Printf( "WARNING: GeneratePermanentShader - MAX_SHADERS hit\n");
+		return tr.defaultShader;
+	}
+
+	newShader = (struct shader_s *)/*ri.*/Hunk_Alloc( sizeof( shader_t ), h_low );
+
+	*newShader = shader;
+
+	if ( shader.sort <= /*SS_OPAQUE*/SS_SEE_THROUGH ) {
+		newShader->fogPass = FP_EQUAL;
+	} else if ( shader.contentFlags & CONTENTS_FOG ) {
+		newShader->fogPass = FP_LE;
+	}
+
+	tr.shaders[ tr.numShaders ] = newShader;
+	newShader->index = tr.numShaders;
+	
+	tr.sortedShaders[ tr.numShaders ] = newShader;
+	newShader->sortedIndex = tr.numShaders;
+
+	tr.numShaders++;
+
+	size = newShader->numUnfoggedPasses ? newShader->numUnfoggedPasses * sizeof( stages[0] ) : sizeof( stages[0] );
+	newShader->stages = (shaderStage_t *) Hunk_Alloc( size, h_low );
+
+	for ( i = 0 ; i < newShader->numUnfoggedPasses ; i++ ) {
+		if ( !stages[i].active ) {
+			break;
+		}
+		newShader->stages[i] = stages[i];
+
+		for ( b = 0 ; b < NUM_TEXTURE_BUNDLES ; b++ ) {
+			if (newShader->stages[i].bundle[b].numTexMods)
+			{
+				size = newShader->stages[i].bundle[b].numTexMods * sizeof( texModInfo_t );
+				newShader->stages[i].bundle[b].texMods = (texModInfo_t *)Hunk_Alloc( size, h_low );
+				Com_Memcpy( newShader->stages[i].bundle[b].texMods, stages[i].bundle[b].texMods, size );
+			}
+			else
+			{
+				newShader->stages[i].bundle[b].texMods = 0;	//clear the globabl ptr jic
+			}
+		}
+	}
+
+	SortNewShader();
+
+	const int hash = generateHashValue(newShader->name, FILE_HASH_SIZE);
+	newShader->next = hashTable[hash];
+	hashTable[hash] = newShader;
+
+	return newShader;
+}
+
+/*
+=================
+VertexLightingCollapse
+
+If vertex lighting is enabled, only render a single
+pass, trying to guess which is the correct one to best aproximate
+what it is supposed to look like.
+
+  OUTPUT:  Number of stages after the collapse (in the case of surfacesprites this isn't one).
+=================
+*/
+//rww - no longer used, at least for now. destroys alpha shaders completely.
+#if 0
+static int VertexLightingCollapse( void ) {
+	int		stage, nextopenstage;
+	shaderStage_t	*bestStage;
+	int		bestImageRank;
+	int		rank;
+	int		finalstagenum=1;
+
+	// if we aren't opaque, just use the first pass
+	if ( shader.sort == SS_OPAQUE ) {
+
+		// pick the best texture for the single pass
+		bestStage = &stages[0];
+		bestImageRank = -999999;
+
+		for ( stage = 0; stage < MAX_SHADER_STAGES; stage++ ) {
+			shaderStage_t *pStage = &stages[stage];
+
+			if ( !pStage->active ) {
+				break;
+			}
+			rank = 0;
+
+			if ( pStage->bundle[0].isLightmap ) {
+				rank -= 100;
+			}
+			if ( pStage->bundle[0].tcGen != TCGEN_TEXTURE ) {
+				rank -= 5;
+			}
+			if ( pStage->bundle[0].numTexMods ) {
+				rank -= 5;
+			}
+			if ( pStage->rgbGen != CGEN_IDENTITY && pStage->rgbGen != CGEN_IDENTITY_LIGHTING ) {
+				rank -= 3;
+			}
+
+			// SurfaceSprites are most certainly NOT desireable as the collapsed surface texture.
+			if ( pStage->ss && pstage->ss->surfaceSpriteType)
+			{
+				rank -= 1000;
+			}
+
+			if ( rank > bestImageRank  ) {
+				bestImageRank = rank;
+				bestStage = pStage;
+			}
+		}
+
+		stages[0].bundle[0] = bestStage->bundle[0];
+		stages[0].stateBits &= ~( GLS_DSTBLEND_BITS | GLS_SRCBLEND_BITS );
+		stages[0].stateBits |= GLS_DEPTHMASK_TRUE;
+		if ( shader.lightmapIndex[0] == LIGHTMAP_NONE ) {
+			stages[0].rgbGen = CGEN_LIGHTING_DIFFUSE;
+#ifdef _XBOX
+			shader.needsNormal = true;
+#endif
+		} else {
+			stages[0].rgbGen = CGEN_EXACT_VERTEX;
+		}
+		stages[0].alphaGen = AGEN_SKIP;		
+	} else {
+		// don't use a lightmap (tesla coils)
+		if ( stages[0].bundle[0].isLightmap ) {
+			stages[0] = stages[1];
+		}
+
+		// if we were in a cross-fade cgen, hack it to normal
+		if ( stages[0].rgbGen == CGEN_ONE_MINUS_ENTITY || stages[1].rgbGen == CGEN_ONE_MINUS_ENTITY ) {
+			stages[0].rgbGen = CGEN_IDENTITY_LIGHTING;
+		}
+		if ( ( stages[0].rgbGen == CGEN_WAVEFORM && stages[0].rgbWave.func == GF_SAWTOOTH )
+			&& ( stages[1].rgbGen == CGEN_WAVEFORM && stages[1].rgbWave.func == GF_INVERSE_SAWTOOTH ) ) {
+			stages[0].rgbGen = CGEN_IDENTITY_LIGHTING;
+		}
+		if ( ( stages[0].rgbGen == CGEN_WAVEFORM && stages[0].rgbWave.func == GF_INVERSE_SAWTOOTH )
+			&& ( stages[1].rgbGen == CGEN_WAVEFORM && stages[1].rgbWave.func == GF_SAWTOOTH ) ) {
+			stages[0].rgbGen = CGEN_IDENTITY_LIGHTING;
+		}
+	}
+
+	for ( stage=1, nextopenstage=1; stage < MAX_SHADER_STAGES; stage++ ) {
+		shaderStage_t *pStage = &stages[stage];
+
+		if ( !pStage->active ) {
+			break;
+		}
+
+		if ( pStage->ss && pstage->ss->surfaceSpriteType)
+		{
+			// Copy this stage to the next open stage list (that is, we don't want any inactive stages before this one)
+			if (nextopenstage != stage)
+			{
+				stages[nextopenstage] = *pStage;
+				stages[nextopenstage].bundle[0] = pStage->bundle[0];
+			}
+			nextopenstage++;
+			finalstagenum++;
+			continue;
+		}
+
+		Com_Memset( pStage, 0, sizeof( *pStage ) );
+	}
+
+	return finalstagenum;
+}
+#endif
+
+/*
+=========================
+FinishShader
+
+Returns a freshly allocated shader with all the needed info
+from the current global working shader
+=========================
+*/
+static shader_t *FinishShader( void ) {
+	int				stage, lmStage, stageIndex; //rwwRMG - stageIndex for AGEN_BLEND
+	qboolean		hasLightmapStage;
+	qboolean		vertexLightmap;
+
+	hasLightmapStage = qfalse;
+	vertexLightmap = qfalse;
+
+	//
+	// set sky stuff appropriate
+	//
+	if ( shader.sky ) {
+		shader.sort = SS_ENVIRONMENT;
+	}
+
+	//
+	// set polygon offset
+	//
+	if ( shader.polygonOffset && !shader.sort ) {
+		shader.sort = SS_DECAL;
+	}
+
+	for(lmStage = 0; lmStage < MAX_SHADER_STAGES; lmStage++)
+	{
+		shaderStage_t *pStage = &stages[lmStage];
+		if (pStage->active && pStage->bundle[0].isLightmap)
+		{
+			break;
+		}
+	}
+
+	if (lmStage < MAX_SHADER_STAGES)
+	{
+		if (shader.lightmapIndex[0] == LIGHTMAP_BY_VERTEX)
+		{
+			if (lmStage == 0)	//< MAX_SHADER_STAGES-1)
+			{//copy the rest down over the lightmap slot
+				memmove(&stages[lmStage], &stages[lmStage+1], sizeof(shaderStage_t) * (MAX_SHADER_STAGES-lmStage-1));
+				memset(&stages[MAX_SHADER_STAGES-1], 0, sizeof(shaderStage_t));
+				//change blending on the moved down stage
+				stages[lmStage].stateBits = GLS_DEFAULT;
+			}
+			//change anything that was moved down (or the *white if LM is first) to use vertex color
+			stages[lmStage].rgbGen = CGEN_EXACT_VERTEX;
+			stages[lmStage].alphaGen = AGEN_SKIP;
+			lmStage = MAX_SHADER_STAGES;	//skip the style checking below
+		}
+	}
+
+	if (lmStage < MAX_SHADER_STAGES)// && !r_fullbright->value)
+	{
+		int	numStyles;
+		int	i;
+
+		for(numStyles=0;numStyles<MAXLIGHTMAPS;numStyles++)
+		{
+			if (shader.styles[numStyles] >= LS_UNUSED)
+			{
+				break;
+			}
+		}
+		numStyles--;
+		if (numStyles > 0)
+		{
+			for(i=MAX_SHADER_STAGES-1;i>lmStage+numStyles;i--)
+			{
+				stages[i] = stages[i-numStyles];
+			}
+
+			for(i=0;i<numStyles;i++)
+			{
+				stages[lmStage+i+1] = stages[lmStage];
+				if (shader.lightmapIndex[i+1] == LIGHTMAP_BY_VERTEX)
+				{
+					stages[lmStage+i+1].bundle[0].image = tr.whiteImage;
+				}
+				else if (shader.lightmapIndex[i+1] < 0)
+				{
+					Com_Error( ERR_DROP, "FinishShader: light style with no light map or vertex color for shader %s", shader.name);
+				}
+				else
+				{
+					stages[lmStage+i+1].bundle[0].image = tr.lightmaps[shader.lightmapIndex[i+1]];
+					stages[lmStage+i+1].bundle[0].tcGen = (texCoordGen_t)(TCGEN_LIGHTMAP+i+1);
+				}
+				stages[lmStage+i+1].rgbGen = CGEN_LIGHTMAPSTYLE;
+				stages[lmStage+i+1].stateBits &= ~(GLS_SRCBLEND_BITS | GLS_DSTBLEND_BITS);
+				stages[lmStage+i+1].stateBits |= GLS_SRCBLEND_ONE | GLS_DSTBLEND_ONE;
+			}
+		}
+
+		for(i=0;i<=numStyles;i++)
+		{
+			stages[lmStage+i].lightmapStyle = shader.styles[i];
+		}
+	}
+
+	//
+	// set appropriate stage information
+	//
+	stageIndex = 0; //rwwRMG - needed for AGEN_BLEND
+	for ( stage = 0; stage < MAX_SHADER_STAGES; stage++ ) {
+		shaderStage_t *pStage = &stages[stage];
+
+		if ( !pStage->active ) {
+			break;
+		}
+
+    // check for a missing texture
+		if ( !pStage->bundle[0].image ) {
+			Com_Printf (S_COLOR_YELLOW  "Shader %s has a stage with no image\n", shader.name );
+			pStage->active = qfalse;
+			continue;
+		}
+
+		//
+		// ditch this stage if it's detail and detail textures are disabled
+		//
+		if ( pStage->isDetail && !r_detailTextures->integer ) {
+			if ( stage < ( MAX_SHADER_STAGES - 1 ) ) {
+				memmove( pStage, pStage + 1, sizeof( *pStage ) * ( MAX_SHADER_STAGES - stage - 1 ) );
+				
+				// rww - 9-13-01 [1-26-01-sof2]
+				memset(  pStage + ( MAX_SHADER_STAGES - stage - 1 ), 0, sizeof( *pStage ) );	//clear the last one moved down
+				stage--;	//look at this stage next time around
+			}
+			continue;
+		}
+
+		pStage->index = stageIndex; //rwwRMG - needed for AGEN_BLEND
+
+		//
+		// default texture coordinate generation
+		//
+		if ( pStage->bundle[0].isLightmap ) {
+			if ( pStage->bundle[0].tcGen == TCGEN_BAD ) {
+				pStage->bundle[0].tcGen = TCGEN_LIGHTMAP;
+			}
+			hasLightmapStage = qtrue;
+		} else {
+			if ( pStage->bundle[0].tcGen == TCGEN_BAD ) {
+				pStage->bundle[0].tcGen = TCGEN_TEXTURE;
+			}
+		}
+
+
+    // not a true lightmap but we want to leave existing 
+    // behaviour in place and not print out a warning
+    //if (pStage->rgbGen == CGEN_VERTEX) {
+    //  vertexLightmap = qtrue;
+    //}
+
+
+
+		//
+		// determine sort order and fog color adjustment
+		//
+		if ( ( pStage->stateBits & ( GLS_SRCBLEND_BITS | GLS_DSTBLEND_BITS ) ) &&
+			 ( stages[0].stateBits & ( GLS_SRCBLEND_BITS | GLS_DSTBLEND_BITS ) ) ) {
+			int blendSrcBits = pStage->stateBits & GLS_SRCBLEND_BITS;
+			int blendDstBits = pStage->stateBits & GLS_DSTBLEND_BITS;
+
+			// fog color adjustment only works for blend modes that have a contribution
+			// that aproaches 0 as the modulate values aproach 0 --
+			// GL_ONE, GL_ONE
+			// GL_ZERO, GL_ONE_MINUS_SRC_COLOR
+			// GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA
+
+			// modulate, additive
+			if ( ( ( blendSrcBits == GLS_SRCBLEND_ONE ) && ( blendDstBits == GLS_DSTBLEND_ONE ) ) ||
+				( ( blendSrcBits == GLS_SRCBLEND_ZERO ) && ( blendDstBits == GLS_DSTBLEND_ONE_MINUS_SRC_COLOR ) ) ) {
+				pStage->adjustColorsForFog = ACFF_MODULATE_RGB;
+			}
+			// strict blend
+			else if ( ( blendSrcBits == GLS_SRCBLEND_SRC_ALPHA ) && ( blendDstBits == GLS_DSTBLEND_ONE_MINUS_SRC_ALPHA ) )
+			{
+				pStage->adjustColorsForFog = ACFF_MODULATE_ALPHA;
+			}
+			// premultiplied alpha
+			else if ( ( blendSrcBits == GLS_SRCBLEND_ONE ) && ( blendDstBits == GLS_DSTBLEND_ONE_MINUS_SRC_ALPHA ) )
+			{
+				pStage->adjustColorsForFog = ACFF_MODULATE_RGBA;
+			} else {
+				// we can't adjust this one correctly, so it won't be exactly correct in fog
+			}
+
+			// don't screw with sort order if this is a portal or environment
+			if ( !shader.sort ) {
+				// see through item, like a grill or grate
+				if ( pStage->stateBits & GLS_DEPTHMASK_TRUE ) 
+				{
+					shader.sort = SS_SEE_THROUGH;
+				} 
+				else 
+				{
+					/*
+					if (( blendSrcBits == GLS_SRCBLEND_ONE ) && ( blendDstBits == GLS_DSTBLEND_ONE ))
+					{
+						// GL_ONE GL_ONE needs to come a bit later
+						shader.sort = SS_BLEND2;
+					}
+					else if (( blendSrcBits == GLS_SRCBLEND_SRC_ALPHA ) && ( blendDstBits == GLS_DSTBLEND_ONE_MINUS_SRC_ALPHA ))
+					{ //rww - Pushed SS_BLEND1 up to SS_BLEND2, inserting this so that saber glow will render above water and things.
+					  //Unfortunately it still affects other shaders with the same blend settings, but it seems more or less alright.
+						shader.sort = SS_BLEND1;
+					}
+					else
+					{
+						shader.sort = SS_BLEND0;
+					}
+					*/
+					if (( blendSrcBits == GLS_SRCBLEND_ONE ) && ( blendDstBits == GLS_DSTBLEND_ONE ))
+					{
+						// GL_ONE GL_ONE needs to come a bit later
+						shader.sort = SS_BLEND1;
+					}
+					else
+					{
+						shader.sort = SS_BLEND0;
+					}
+				}
+			}
+		}
+
+		//rww - begin hw fog
+		if ((pStage->stateBits & (GLS_SRCBLEND_BITS|GLS_DSTBLEND_BITS)) == (GLS_SRCBLEND_ONE|GLS_DSTBLEND_ONE))
+		{
+			pStage->mGLFogColorOverride = GLFOGOVERRIDE_BLACK;
+		}
+		else if ((pStage->stateBits & (GLS_SRCBLEND_BITS|GLS_DSTBLEND_BITS)) == (GLS_SRCBLEND_SRC_ALPHA|GLS_DSTBLEND_ONE) &&
+			pStage->alphaGen == AGEN_LIGHTING_SPECULAR && stage)
+		{
+			pStage->mGLFogColorOverride = GLFOGOVERRIDE_BLACK;
+		}
+		else if ((pStage->stateBits & (GLS_SRCBLEND_BITS|GLS_DSTBLEND_BITS)) == (GLS_SRCBLEND_ZERO|GLS_DSTBLEND_ZERO))
+		{
+			pStage->mGLFogColorOverride = GLFOGOVERRIDE_WHITE;
+		}
+		else if ((pStage->stateBits & (GLS_SRCBLEND_BITS|GLS_DSTBLEND_BITS)) == (GLS_SRCBLEND_ONE|GLS_DSTBLEND_ZERO))
+		{
+			pStage->mGLFogColorOverride = GLFOGOVERRIDE_WHITE;
+		}
+		else if ((pStage->stateBits & (GLS_SRCBLEND_BITS|GLS_DSTBLEND_BITS)) == 0 && stage)
+		{	// 
+			pStage->mGLFogColorOverride = GLFOGOVERRIDE_WHITE;
+		}
+		else if ((pStage->stateBits & (GLS_SRCBLEND_BITS|GLS_DSTBLEND_BITS)) == 0 && pStage->bundle[0].isLightmap && stage < MAX_SHADER_STAGES-1 &&
+			stages[stage+1].bundle[0].isLightmap)
+		{	// multiple light map blending
+			pStage->mGLFogColorOverride = GLFOGOVERRIDE_WHITE;
+		}
+		else if ((pStage->stateBits & (GLS_SRCBLEND_BITS|GLS_DSTBLEND_BITS)) == (GLS_SRCBLEND_DST_COLOR|GLS_DSTBLEND_ZERO) && pStage->bundle[0].isLightmap)
+		{ //I don't know, it works. -rww
+			pStage->mGLFogColorOverride = GLFOGOVERRIDE_WHITE;
+		}
+		else if ((pStage->stateBits & (GLS_SRCBLEND_BITS|GLS_DSTBLEND_BITS)) == (GLS_SRCBLEND_DST_COLOR|GLS_DSTBLEND_ZERO))
+		{ //I don't know, it works. -rww
+			pStage->mGLFogColorOverride = GLFOGOVERRIDE_BLACK;
+		}
+		else if ((pStage->stateBits & (GLS_SRCBLEND_BITS|GLS_DSTBLEND_BITS)) == (GLS_SRCBLEND_ONE|GLS_DSTBLEND_ONE_MINUS_SRC_COLOR))
+		{ //I don't know, it works. -rww
+			pStage->mGLFogColorOverride = GLFOGOVERRIDE_BLACK;
+		}
+		else
+		{
+			pStage->mGLFogColorOverride = GLFOGOVERRIDE_NONE;
+		}
+		//rww - end hw fog
+
+		stageIndex++; //rwwRMG - needed for AGEN_BLEND
+	}
+
+	// there are times when you will need to manually apply a sort to
+	// opaque alpha tested shaders that have later blend passes
+	if ( !shader.sort ) {
+		shader.sort = SS_OPAQUE;
+	}
+
+	//
+	// if we are in r_vertexLight mode, never use a lightmap texture
+	//
+	if ( stage > 1 && (r_vertexLight->integer && !r_uiFullScreen->integer) ) {
+		//stage = VertexLightingCollapse();
+		//rww - since this does bad things, I am commenting it out for now. If you want to attempt a fix, feel free.
+		hasLightmapStage = qfalse;
+	}
+
+	//
+	// look for multitexture potential
+	//
+	if ( stage > 1 && CollapseMultitexture() ) {
+		stage--;
+	}
+
+	if ( shader.lightmapIndex[0] >= 0 && !hasLightmapStage ) 
+	{
+		if (vertexLightmap) 
+		{
+//			ri.DPrintf( "WARNING: shader '%s' has VERTEX forced lightmap!\n", shader.name );
+		} 
+		else 
+		{
+			Com_Printf ( "WARNING: shader '%s' has lightmap but no lightmap stage!\n", shader.name );
+			memcpy(shader.lightmapIndex, lightmapsNone, sizeof(shader.lightmapIndex));
+			memcpy(shader.styles, stylesDefault, sizeof(shader.styles));
+		}
+	}
+
+
+	//
+	// compute number of passes
+	//
+	shader.numUnfoggedPasses = stage;
+
+	// fogonly shaders don't have any normal passes
+	if ( stage == 0 ) {
+		shader.sort = SS_FOG;
+	}
+
+	for ( stage = 1; stage < shader.numUnfoggedPasses; stage++ )
+	{
+		// Make sure stage is non detail and active
+		if(stages[stage].isDetail || !stages[stage].active)
+		{
+			break;
+		}
+		// MT lightmaps are always in bundle 1
+		if(stages[stage].bundle[0].isLightmap)
+		{
+			continue;
+		}
+	}
+
+	return GeneratePermanentShader();
+}
+
+//========================================================================================
+
+/*
+====================
+FindShaderInShaderText
+
+Scans the combined text description of all the shader files for
+the given shader name.
+
+return NULL if not found
+
+If found, it will return a valid shader
+=====================
+*/
+static const char *FindShaderInShaderText( const char *shadername ) {
+
+	char *token;
+	const char *p;
+
+	int i, hash;
+
+	hash = generateHashValue(shadername, MAX_SHADERTEXT_HASH);
+
+	for (i = 0; shaderTextHashTable[hash][i]; i++) {
+		p = shaderTextHashTable[hash][i];
+		token = COM_ParseExt(&p, qtrue);
+		if ( !Q_stricmp( token, shadername ) ) {
+			return p;
+		}
+	}
+
+	p = s_shaderText;
+
+	if ( !p ) {
+		return NULL;
+	}
+
+	// look for label
+	while ( 1 ) {
+		token = COM_ParseExt( &p, qtrue );
+		if ( token[0] == 0 ) {
+			break;
+		}
+
+		if ( !Q_stricmp( token, shadername ) ) {
+			return p;
+		}
+		else {
+			// skip the definition
+			SkipBracedSection( &p );
+		}
+	}
+
+	return NULL;
+}
+
+
+/*
+==================
+R_FindShaderByName
+
+Will always return a valid shader, but it might be the
+default shader if the real one can't be found.
+==================
+*/
+shader_t *R_FindShaderByName( const char *name ) {
+	char		strippedName[MAX_QPATH];
+	int			hash;
+	shader_t	*sh;
+
+	if ( (name==NULL) || (name[0] == 0) ) {  // bk001205
+		return tr.defaultShader;
+	}
+
+	COM_StripExtension( name, strippedName );
+
+	hash = generateHashValue(strippedName, FILE_HASH_SIZE);
+
+	//
+	// see if the shader is already loaded
+	//
+	for (sh=hashTable[hash]; sh; sh=sh->next) {
+		// NOTE: if there was no shader or image available with the name strippedName
+		// then a default shader is created with lightmapIndex == LIGHTMAP_NONE, so we
+		// have to check all default shaders otherwise for every call to R_FindShader
+		// with that same strippedName a new default shader is created.
+		if (Q_stricmp(sh->name, strippedName) == 0) {
+			// match found
+			return sh;
+		}
+	}
+
+	return tr.defaultShader;
+}
+
+
+inline qboolean IsShader(shader_t *sh, const char *name, const int *lightmapIndex, const byte *styles)
+{
+	int	i;
+
+	if (Q_stricmp(sh->name, name))
+	{
+		return qfalse;
+	}
+
+	if (!sh->defaultShader)
+	{
+		for(i=0;i<MAXLIGHTMAPS;i++)
+		{
+			if (sh->lightmapIndex[i] != lightmapIndex[i])
+			{
+				return qfalse;
+			}
+			if (sh->styles[i] != styles[i])
+			{
+				return qfalse;
+			}
+		}
+	}
+
+	return qtrue;
+}
+
+/*
+===============
+R_FindShader
+
+Will always return a valid shader, but it might be the
+default shader if the real one can't be found.
+
+In the interest of not requiring an explicit shader text entry to
+be defined for every single image used in the game, three default
+shader behaviors can be auto-created for any image:
+
+If lightmapIndex == LIGHTMAP_NONE, then the image will have
+dynamic diffuse lighting applied to it, as apropriate for most
+entity skin surfaces.
+
+If lightmapIndex == LIGHTMAP_2D, then the image will be used
+for 2D rendering unless an explicit shader is found
+
+If lightmapIndex == LIGHTMAP_BY_VERTEX, then the image will use
+the vertex rgba modulate values, as apropriate for misc_model
+pre-lit surfaces.
+
+Other lightmapIndex values will have a lightmap stage created
+and src*dest blending applied with the texture, as apropriate for
+most world construction surfaces.
+
+===============
+*/
+shader_t *R_FindShader( const char *name, const int *lightmapIndex, const byte *styles, qboolean mipRawImage ) 
+{
+	char		strippedName[MAX_QPATH];
+	char		fileName[MAX_QPATH];
+	int			hash;
+	const char	*shaderText;
+	image_t		*image;
+	shader_t	*sh;
+
+	if ( name[0] == 0 ) {
+		return tr.defaultShader;
+	}
+
+	// use (fullbright) vertex lighting if the bsp file doesn't have
+	// lightmaps
+	if ( lightmapIndex[0] >= 0 && lightmapIndex[0] >= tr.numLightmaps )
+	{
+		lightmapIndex = lightmapsVertex;
+	}
+
+	COM_StripExtension( name, strippedName );
+
+	hash = generateHashValue(strippedName, FILE_HASH_SIZE);
+
+	//
+	// see if the shader is already loaded
+	//
+	for (sh = hashTable[hash]; sh; sh = sh->next) {
+		// NOTE: if there was no shader or image available with the name strippedName
+		// then a default shader is created with lightmapIndex == LIGHTMAP_NONE, so we
+		// have to check all default shaders otherwise for every call to R_FindShader
+		// with that same strippedName a new default shader is created.
+		if (IsShader(sh, strippedName, lightmapIndex, styles))
+		{
+			return sh;
+		}
+	}
+
+	// clear the global shader
+	ClearGlobalShader();
+	Q_strncpyz(shader.name, strippedName, sizeof(shader.name));
+	memcpy(shader.lightmapIndex, lightmapIndex, sizeof(shader.lightmapIndex));
+	memcpy(shader.styles, styles, sizeof(shader.styles));
+	
+	//
+	// attempt to define shader from an explicit parameter file
+	//
+	shaderText = FindShaderInShaderText( strippedName );
+	if ( shaderText ) {
+		if ( !ParseShader( &shaderText ) ) {
+			// had errors, so use default shader
+			shader.defaultShader = true;
+		}
+		sh = FinishShader();
+		return sh;
+	}
+
+
+	//
+	// if not defined in the in-memory shader descriptions,
+	// look for a single TGA, BMP, or PCX
+	//
+	COM_StripExtension(name,fileName);
+#ifdef DEDICATED
+	shader.defaultShader = qtrue;
+	return FinishShader();
+#else
+	image = R_FindImageFile( fileName, mipRawImage, mipRawImage, qtrue, mipRawImage ? GL_REPEAT : GL_CLAMP );
+	if ( !image ) {
+		Com_DPrintf (S_COLOR_RED "Couldn't find image for shader %s\n", name );
+		shader.defaultShader = true;
+		return FinishShader();
+	}
+#endif //!DEDICATED
+	//
+	// create the default shading commands
+	//
+	if ( shader.lightmapIndex[0] == LIGHTMAP_NONE ) {
+		// dynamic colors at vertexes
+		stages[0].bundle[0].image = image;
+		stages[0].active = qtrue;
+		stages[0].rgbGen = CGEN_LIGHTING_DIFFUSE;
+		stages[0].stateBits = GLS_DEFAULT;
+#ifdef _XBOX
+		shader.needsNormal = true;
+#endif
+	} else if ( shader.lightmapIndex[0] == LIGHTMAP_BY_VERTEX ) {
+		// explicit colors at vertexes
+		stages[0].bundle[0].image = image;
+		stages[0].active = qtrue;
+		stages[0].rgbGen = CGEN_EXACT_VERTEX;
+		stages[0].alphaGen = AGEN_SKIP;
+		stages[0].stateBits = GLS_DEFAULT;
+	} else if ( shader.lightmapIndex[0] == LIGHTMAP_2D ) {
+		// GUI elements
+		stages[0].bundle[0].image = image;
+		stages[0].active = qtrue;
+		stages[0].rgbGen = CGEN_VERTEX;
+		stages[0].alphaGen = AGEN_VERTEX;
+		stages[0].stateBits = GLS_DEPTHTEST_DISABLE |
+			  GLS_SRCBLEND_SRC_ALPHA |
+			  GLS_DSTBLEND_ONE_MINUS_SRC_ALPHA;
+	} else if ( shader.lightmapIndex[0] == LIGHTMAP_WHITEIMAGE ) {
+		// fullbright level
+		stages[0].bundle[0].image = tr.whiteImage;
+		stages[0].active = qtrue;
+		stages[0].rgbGen = CGEN_IDENTITY_LIGHTING;
+		stages[0].stateBits = GLS_DEFAULT;
+
+		stages[1].bundle[0].image = image;
+		stages[1].active = qtrue;
+		stages[1].rgbGen = CGEN_IDENTITY;
+		stages[1].stateBits |= GLS_SRCBLEND_DST_COLOR | GLS_DSTBLEND_ZERO;
+	} else {
+		// two pass lightmap
+		stages[0].bundle[0].image = tr.lightmaps[shader.lightmapIndex[0]];
+		stages[0].bundle[0].isLightmap = qtrue;
+		stages[0].active = qtrue;
+		stages[0].rgbGen = CGEN_IDENTITY;	// lightmaps are scaled on creation
+													// for identitylight
+		stages[0].stateBits = GLS_DEFAULT;
+
+		stages[1].bundle[0].image = image;
+		stages[1].active = qtrue;
+		stages[1].rgbGen = CGEN_IDENTITY;
+		stages[1].stateBits |= GLS_SRCBLEND_DST_COLOR | GLS_DSTBLEND_ZERO;
+	}
+
+	return FinishShader();
+}
+
+static void ScanAndLoadShaderFiles( const char *path );
+shader_t *R_FindServerShader( const char *name, const int *lightmapIndex, const byte *styles, qboolean mipRawImage ) 
+{
+	char		strippedName[MAX_QPATH];
+	int			hash;
+	shader_t	*sh;
+
+	if ( name[0] == 0 ) {
+		return tr.defaultShader;
+	}
+
+	COM_StripExtension( name, strippedName );
+
+	hash = generateHashValue(strippedName, FILE_HASH_SIZE);
+
+	//
+	// see if the shader is already loaded
+	//
+	for (sh = hashTable[hash]; sh; sh = sh->next) {
+		// NOTE: if there was no shader or image available with the name strippedName
+		// then a default shader is created with lightmapIndex == LIGHTMAP_NONE, so we
+		// have to check all default shaders otherwise for every call to R_FindShader
+		// with that same strippedName a new default shader is created.
+		if (IsShader(sh, strippedName, lightmapIndex, styles))
+		{
+			return sh;
+		}
+	}
+
+	// clear the global shader
+	ClearGlobalShader();
+	Q_strncpyz(shader.name, strippedName, sizeof(shader.name));
+	memcpy(shader.lightmapIndex, lightmapIndex, sizeof(shader.lightmapIndex));
+	memcpy(shader.styles, styles, sizeof(shader.styles));
+	
+	shader.defaultShader = true;
+	return FinishShader();
+}
+
+qhandle_t RE_RegisterShaderFromImage(const char *name, int *lightmapIndex, byte *styles, image_t *image, qboolean mipRawImage) {
+	int			i, hash;
+	shader_t	*sh;
+
+	hash = generateHashValue(name, FILE_HASH_SIZE);
+	
+	//
+	// see if the shader is already loaded
+	//
+	for (sh=hashTable[hash]; sh; sh=sh->next) {
+		// NOTE: if there was no shader or image available with the name strippedName
+		// then a default shader is created with lightmapIndex == LIGHTMAP_NONE, so we
+		// have to check all default shaders otherwise for every call to R_FindShader
+		// with that same strippedName a new default shader is created.
+		if (IsShader(sh, name, lightmapIndex, styles))
+		{
+			return sh->index;
+		}
+	}
+
+	// clear the global shader
+	Com_Memset( &shader, 0, sizeof( shader ) );
+	Com_Memset( &stages, 0, sizeof( stages ) );
+	Q_strncpyz(shader.name, name, sizeof(shader.name));
+	memcpy(shader.lightmapIndex, lightmapIndex, sizeof(shader.lightmapIndex));
+	memcpy(shader.styles, styles, sizeof(shader.styles));
+
+	for ( i = 0 ; i < MAX_SHADER_STAGES ; i++ ) {
+		stages[i].bundle[0].texMods = texMods[i];
+	}
+
+	//
+	// create the default shading commands
+	//
+	if ( shader.lightmapIndex[0] == LIGHTMAP_NONE ) {
+		// dynamic colors at vertexes
+		stages[0].bundle[0].image = image;
+		stages[0].active = qtrue;
+		stages[0].rgbGen = CGEN_LIGHTING_DIFFUSE;
+		stages[0].stateBits = GLS_DEFAULT;
+	} else if ( shader.lightmapIndex[0] == LIGHTMAP_BY_VERTEX ) {
+		// explicit colors at vertexes
+		stages[0].bundle[0].image = image;
+		stages[0].active = qtrue;
+		stages[0].rgbGen = CGEN_EXACT_VERTEX;
+		stages[0].alphaGen = AGEN_SKIP;
+		stages[0].stateBits = GLS_DEFAULT;
+	} else if ( shader.lightmapIndex[0] == LIGHTMAP_2D ) {
+		// GUI elements
+		stages[0].bundle[0].image = image;
+		stages[0].active = qtrue;
+		stages[0].rgbGen = CGEN_VERTEX;
+		stages[0].alphaGen = AGEN_VERTEX;
+		stages[0].stateBits = GLS_DEPTHTEST_DISABLE |
+			  GLS_SRCBLEND_SRC_ALPHA |
+			  GLS_DSTBLEND_ONE_MINUS_SRC_ALPHA;
+	} else if ( shader.lightmapIndex[0] == LIGHTMAP_WHITEIMAGE ) {
+		// fullbright level
+		stages[0].bundle[0].image = tr.whiteImage;
+		stages[0].active = qtrue;
+		stages[0].rgbGen = CGEN_IDENTITY_LIGHTING;
+		stages[0].stateBits = GLS_DEFAULT;
+
+		stages[1].bundle[0].image = image;
+		stages[1].active = qtrue;
+		stages[1].rgbGen = CGEN_IDENTITY;
+		stages[1].stateBits |= GLS_SRCBLEND_DST_COLOR | GLS_DSTBLEND_ZERO;
+	} else {
+		// two pass lightmap
+		stages[0].bundle[0].image = tr.lightmaps[shader.lightmapIndex[0]];
+		stages[0].bundle[0].isLightmap = qtrue;
+		stages[0].active = qtrue;
+		stages[0].rgbGen = CGEN_IDENTITY;	// lightmaps are scaled on creation
+													// for identitylight
+		stages[0].stateBits = GLS_DEFAULT;
+
+		stages[1].bundle[0].image = image;
+		stages[1].active = qtrue;
+		stages[1].rgbGen = CGEN_IDENTITY;
+		stages[1].stateBits |= GLS_SRCBLEND_DST_COLOR | GLS_DSTBLEND_ZERO;
+	}
+
+	sh = FinishShader();
+  return sh->index; 
+}
+
+
+/* 
+====================
+RE_RegisterShader
+
+This is the exported shader entry point for the rest of the system
+It will always return an index that will be valid.
+
+This should really only be used for explicit shaders, because there is no
+way to ask for different implicit lighting modes (vertex, lightmap, etc)
+====================
+*/
+qhandle_t RE_RegisterShaderLightMap( const char *name, const int *lightmapIndex, const byte *styles ) 
+{
+	shader_t	*sh;
+
+	if ( strlen( name ) >= MAX_QPATH ) {
+		Com_Printf( "Shader name exceeds MAX_QPATH\n" );
+		return 0;
+	}
+
+	sh = R_FindShader( name, lightmapIndex, styles, qtrue );
+
+	// we want to return 0 if the shader failed to
+	// load for some reason, but R_FindShader should
+	// still keep a name allocated for it, so if
+	// something calls RE_RegisterShader again with
+	// the same name, we don't try looking for it again
+	if ( sh->defaultShader ) {
+		return 0;
+	}
+
+	return sh->index;
+}
+
+
+/* 
+====================
+RE_RegisterShader
+
+This is the exported shader entry point for the rest of the system
+It will always return an index that will be valid.
+
+This should really only be used for explicit shaders, because there is no
+way to ask for different implicit lighting modes (vertex, lightmap, etc)
+====================
+*/
+qhandle_t RE_RegisterShader( const char *name ) {
+	shader_t	*sh;
+
+	if ( strlen( name ) >= MAX_QPATH ) {
+		Com_Printf( "Shader name exceeds MAX_QPATH\n" );
+		return 0;
+	}
+
+	sh = R_FindShader( name, lightmaps2d, stylesDefault, qtrue );
+
+	// we want to return 0 if the shader failed to
+	// load for some reason, but R_FindShader should
+	// still keep a name allocated for it, so if
+	// something calls RE_RegisterShader again with
+	// the same name, we don't try looking for it again
+	if ( sh->defaultShader ) {
+		return 0;
+	}
+
+	return sh->index;
+}
+
+
+/*
+====================
+RE_RegisterShaderNoMip
+
+For menu graphics that should never be picmiped
+====================
+*/
+qhandle_t RE_RegisterShaderNoMip( const char *name ) {
+	shader_t	*sh;
+
+	if ( strlen( name ) >= MAX_QPATH ) {
+		Com_Printf( "Shader name exceeds MAX_QPATH\n" );
+		return 0;
+	}
+
+	sh = R_FindShader( name, lightmaps2d, stylesDefault, qfalse );
+
+	// we want to return 0 if the shader failed to
+	// load for some reason, but R_FindShader should
+	// still keep a name allocated for it, so if
+	// something calls RE_RegisterShader again with
+	// the same name, we don't try looking for it again
+	if ( sh->defaultShader ) {
+		return 0;
+	}
+
+	return sh->index;
+}
+
+
+//added for ui -rww
+const char *RE_ShaderNameFromIndex(int index)
+{
+	assert(index >= 0 && index < tr.numShaders && tr.shaders[index]);
+	return tr.shaders[index]->name;
+}
+
+
+/*
+====================
+R_GetShaderByHandle
+
+When a handle is passed in by another module, this range checks
+it and returns a valid (possibly default) shader_t to be used internally.
+====================
+*/
+shader_t *R_GetShaderByHandle( qhandle_t hShader ) {
+	if ( hShader < 0 ) {
+	  Com_Printf (S_COLOR_YELLOW  "R_GetShaderByHandle: out of range hShader '%d'\n", hShader ); // bk: FIXME name
+		return tr.defaultShader;
+	}
+	if ( hShader >= tr.numShaders ) {
+		Com_Printf (S_COLOR_YELLOW  "R_GetShaderByHandle: out of range hShader '%d'\n", hShader );
+		return tr.defaultShader;
+	}
+	return tr.shaders[hShader];
+}
+
+#ifndef DEDICATED
+/*
+===============
+R_ShaderList_f
+
+Dump information on all valid shaders to the console
+A second parameter will cause it to print in sorted order
+===============
+*/
+void	R_ShaderList_f (void) {
+	int			i;
+	int			count;
+	shader_t	*shader;
+
+	Com_Printf ( "-----------------------\n");
+
+	count = 0;
+	for ( i = 0 ; i < tr.numShaders ; i++ ) {
+		if ( Cmd_Argc() > 1 ) {
+			shader = tr.sortedShaders[i];
+		} else {
+			shader = tr.shaders[i];
+		}
+
+		Com_Printf ("%i ", shader->numUnfoggedPasses );
+
+		if (shader->lightmapIndex[0] >= 0 ) {
+			Com_Printf ( "L ");
+		} else {
+			Com_Printf ( "  ");
+		}
+		if ( shader->multitextureEnv == GL_ADD ) {
+			Com_Printf ("MT(a) " );
+		} else if ( shader->multitextureEnv == GL_MODULATE ) {
+			Com_Printf ("MT(m) " );
+		} else if ( shader->multitextureEnv == GL_DECAL ) {
+			Com_Printf ("MT(d) " );
+		} else {
+			Com_Printf ("      " );
+		}
+		if ( shader->explicitlyDefined ) {
+			Com_Printf ("E " );
+		} else {
+			Com_Printf ("  " );
+		}
+
+		if ( shader->sky )
+		{
+			Com_Printf ("sky " );
+		} else {
+			Com_Printf ("gen " );
+		}
+		if ( shader->defaultShader ) {
+			Com_Printf (  ": %s (DEFAULTED)\n", shader->name);
+		} else {
+			Com_Printf (  ": %s\n", shader->name);
+		}
+		count++;
+	}
+	Com_Printf ( "%i total shaders\n", count);
+	Com_Printf ( "------------------\n");
+}
+
+
+/*
+====================
+ScanAndLoadShaderFiles
+
+Finds and loads all .shader files, combining them into
+a single large text block that can be scanned for shader names
+
+rww - Do not access any ri or render data stuff that doesn't get init'd on
+a dedicated server in here. I am calling it for dedicateds now because
+we need all this shader BS for looking up surface indicators in skin
+files if we want to be like SP.
+
+bto (VV) - Rather than keeping all the buffer pointers around forever and
+creating more bugs, do the hash creation with the finalized shadertext.
+Previous code only really worked if FS_ReadFile returned contiguous buffers
+in ascending order on consecutive calls.
+=====================
+*/
+#define	MAX_SHADER_FILES	4096
+static void ScanAndLoadShaderFiles( const char *path )
+{
+	char **shaderFiles;
+	char *buffers[MAX_SHADER_FILES];
+	char *p;
+	int numShaders;
+	int i;
+	char *oldp, *token, *hashMem;
+	int shaderTextHashTableSizes[MAX_SHADERTEXT_HASH], hash, size;
+
+	long sum = 0;
+	// scan for shader files
+	shaderFiles = /*ri.*/FS_ListFiles( path, ".shader", &numShaders );
+
+	if ( !shaderFiles || !numShaders )
+	{
+		Com_Error(ERR_FATAL, "ERROR: no shader files found\n");
+		return;
+	}
+
+	if ( numShaders > MAX_SHADER_FILES ) {
+		numShaders = MAX_SHADER_FILES;
+	}
+
+	// load and parse shader files
+	for ( i = 0; i < numShaders; i++ )
+	{
+		char filename[MAX_QPATH];
+
+		Com_sprintf( filename, sizeof( filename ), "%s/%s", path, shaderFiles[i] );
+		//Com_Printf( "...loading '%s'\n", filename );
+		/*ri.*/FS_ReadFile( filename, (void **)&buffers[i] );
+		if ( !buffers[i] ) {
+			/*ri.*/Com_Error( ERR_DROP, "Couldn't load %s", filename );
+		}
+		sum += COM_Compress( buffers[i] );
+	}
+
+	// free up memory
+	/*ri.*/FS_FreeFileList( shaderFiles );
+
+	// build single large buffer
+	s_shaderText = (char *)/*ri.*/Hunk_Alloc( sum + numShaders*2, h_low );
+
+	// free in reverse order, so the temp files are all dumped
+	for ( i = numShaders - 1; i >= 0 ; i-- ) {
+		strcat( s_shaderText, "\n" );
+		strcat( s_shaderText, buffers[i] );
+		/*ri.*/FS_FreeFile( (void*) buffers[i] );
+	}
+
+	Com_Memset(shaderTextHashTableSizes, 0, sizeof(shaderTextHashTableSizes));
+	size = 0;
+	p = s_shaderText;
+
+	// look for label
+	while ( 1 ) {
+		token = COM_ParseExt( (const char **)&p, qtrue );
+		if ( token[0] == 0 ) {
+			break;
+		}
+
+		hash = generateHashValue(token, MAX_SHADERTEXT_HASH);
+		shaderTextHashTableSizes[hash]++;
+		size++;
+		SkipBracedSection((const char **)&p);
+	}
+
+	size += MAX_SHADERTEXT_HASH;
+
+	hashMem = (char *)/*ri.*/Hunk_Alloc( size * sizeof(char *), h_low );
+
+	for (i = 0; i < MAX_SHADERTEXT_HASH; i++) {
+		shaderTextHashTable[i] = (char **) hashMem;
+		hashMem = ((char *) hashMem) + ((shaderTextHashTableSizes[i] + 1) * sizeof(char *));
+	}
+
+	Com_Memset(shaderTextHashTableSizes, 0, sizeof(shaderTextHashTableSizes));
+	p = s_shaderText;
+	// look for label
+	while ( 1 ) {
+		oldp = p;
+		token = COM_ParseExt( (const char **)&p, qtrue );
+		if ( token[0] == 0 ) {
+			break;
+		}
+
+		hash = generateHashValue(token, MAX_SHADERTEXT_HASH);
+		shaderTextHashTable[hash][shaderTextHashTableSizes[hash]++] = oldp;
+
+		SkipBracedSection((const char **)&p);
+	}
+
+	return;
+}
+
+/*
+====================
+R_CreateBlendedShader
+
+  This takes 4 shaders (one per corner of a quad) and creates a blended shader the fades the textures over
+  eg.
+  if [A][A]
+     [B][B]
+  then the shader would be texture A at the top fading to texture B at the bottom
+
+  This is highly biased towards terrain shaders ie vertex lit surfaces
+====================
+*/
+//rwwRMG: Added:
+
+static void R_CopyStage(shaderStage_t *orig, shaderStage_t *stage)
+{
+	// Assumption: this stage has not been collapsed
+	*stage = *orig;		//Just copy the whole thing!
+}
+
+static void R_CreateBlendedStage(qhandle_t handle, int idx)
+{
+	shader_t	*work;
+	
+	work = R_GetShaderByHandle(handle);
+	R_CopyStage(work->stages, stages + idx);
+	stages[idx].rgbGen = CGEN_EXACT_VERTEX;
+	stages[idx].alphaGen = AGEN_BLEND;
+	stages[idx].stateBits = GLS_SRCBLEND_SRC_ALPHA | GLS_DSTBLEND_ONE | GLS_DEPTHMASK_TRUE;
+
+	if (stages[idx].ss)
+	{
+		stages[idx].ss->density *= 0.33f;
+	}
+}
+
+static qhandle_t R_MergeShaders(const char *blendedName, qhandle_t a, qhandle_t b, qhandle_t c, bool surfaceSprites)
+{
+	shader_t	*blended;
+	shader_t	*work;
+	int			current, i;
+
+	R_SyncRenderThread();
+
+	// Set up default parameters
+	ClearGlobalShader();
+	Q_strncpyz(shader.name, blendedName, sizeof(shader.name));
+	memcpy(shader.lightmapIndex, lightmapsVertex, sizeof(shader.lightmapIndex));
+	memcpy(shader.styles, stylesDefault, sizeof(shader.styles));
+	shader.fogPass = FP_EQUAL;
+
+	// Get the top left shader and set it up as pass 0 - it should be completely opaque
+	work = R_GetShaderByHandle(c);
+	stages[0].active = qtrue;
+	R_CopyStage(work->stages, stages);
+	stages[0].rgbGen = CGEN_EXACT_VERTEX;
+	stages[0].alphaGen = AGEN_BLEND;
+	stages[0].stateBits = GLS_SRCBLEND_SRC_ALPHA | GLS_DSTBLEND_ZERO | GLS_DEPTHMASK_TRUE;
+	shader.multitextureEnv = work->multitextureEnv;	//jic
+		
+	// Go through the other verts and add a pass
+	R_CreateBlendedStage(a, 1);
+	R_CreateBlendedStage(b, 2);
+
+	if ( surfaceSprites )
+	{
+		current = 3;
+		work = R_GetShaderByHandle(a);
+		for(i=1;(i<work->numUnfoggedPasses && current<MAX_SHADER_STAGES);i++)
+		{
+			if (work->stages[i].ss)
+			{
+				stages[current] = work->stages[i];
+	//			stages[current].ss->density *= 0.33f;
+				stages[current].ss->density *= 3;
+				current++;
+			}
+		}
+
+		work = R_GetShaderByHandle(b);
+		for(i=1;(i<work->numUnfoggedPasses && current<MAX_SHADER_STAGES);i++)
+		{
+			if (work->stages[i].ss)
+			{
+				stages[current] = work->stages[i];
+	//			stages[current].ss->density *= 0.33f;
+				stages[current].ss->density *= 3;
+				current++;
+			}
+		}
+
+		work = R_GetShaderByHandle(c);
+		for(i=1;(i<work->numUnfoggedPasses && current<MAX_SHADER_STAGES);i++)
+		{
+			if (work->stages[i].ss)
+			{
+				stages[current] = work->stages[i];
+	//			stages[current].ss->density *= 0.33f;
+				stages[current].ss->density *= 3;
+				current++;
+			}
+		}
+	}
+
+	blended = FinishShader();
+	return(blended->index);
+}
+
+
+// Create a 3 pass shader - the last 2 passes are alpha'd out
+
+qhandle_t R_CreateBlendedShader(qhandle_t a, qhandle_t b, qhandle_t c, bool surfaceSprites )
+{
+	qhandle_t	blended;
+	shader_t	*work;
+	char		blendedName[MAX_QPATH];
+	char		extendedName[MAX_QPATH + MAX_QPATH];
+
+	Com_sprintf(blendedName, MAX_QPATH, "blend(%d,%d,%d)", a, b, c);
+	if (!surfaceSprites)
+	{
+		strcat(blendedName, "noSS");
+	}
+
+	// Find if this shader has already been created
+	R_CreateExtendedName(extendedName, blendedName, lightmapsVertex, stylesDefault);
+	work = hashTable[generateHashValue(extendedName, FILE_HASH_SIZE)];
+	for ( ; work; work = work->next) 
+	{
+		if (Q_stricmp(work->name, extendedName) == 0) 
+		{
+			return work->index;
+		}
+	}
+
+	// Create new shader if it doesn't already exist
+	blended = R_MergeShaders(extendedName, a, b, c, surfaceSprites);
+	return(blended);
+}
+
+/*
+====================
+CreateInternalShaders
+====================
+*/
+static void CreateInternalShaders( void ) {
+	tr.numShaders = 0;
+
+	// init the default shader
+	Com_Memset( &shader, 0, sizeof( shader ) );
+	Com_Memset( &stages, 0, sizeof( stages ) );
+
+	Q_strncpyz( shader.name, "<default>", sizeof( shader.name ) );
+
+	memcpy(shader.lightmapIndex, lightmapsNone, sizeof(shader.lightmapIndex));
+	memcpy(shader.styles, stylesDefault, sizeof(shader.styles));
+	for ( int i = 0 ; i < MAX_SHADER_STAGES ; i++ ) {
+		stages[i].bundle[0].texMods = texMods[i];
+	}
+
+	stages[0].bundle[0].image = tr.defaultImage;
+	stages[0].active = qtrue;
+	stages[0].stateBits = GLS_DEFAULT;
+	tr.defaultShader = FinishShader();
+
+	// shadow shader is just a marker
+	Q_strncpyz( shader.name, "<stencil shadow>", sizeof( shader.name ) );
+	shader.sort = SS_BANNER; //SS_STENCIL_SHADOW;
+	tr.shadowShader = FinishShader();
+
+	// distortion shader is just a marker
+	Q_strncpyz( shader.name, "internal_distortion", sizeof( shader.name ) );
+	shader.sort = SS_BLEND0;
+	shader.defaultShader = qfalse;
+	tr.distortionShader = FinishShader();
+	shader.defaultShader = qtrue;
+
+	
+#ifndef _XBOX	// GLOWXXX
+	#define GL_PROGRAM_ERROR_STRING_ARB						0x8874
+	#define GL_PROGRAM_ERROR_POSITION_ARB					0x864B
+
+	// Allocate and Load the global 'Glow' Vertex Program. - AReis
+	if ( qglGenProgramsARB )
+	{
+		qglGenProgramsARB( 1, &tr.glowVShader );
+		qglBindProgramARB( GL_VERTEX_PROGRAM_ARB, tr.glowVShader );
+		qglProgramStringARB( GL_VERTEX_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB, strlen( ( char * ) g_strGlowVShaderARB ), g_strGlowVShaderARB );
+
+//		const GLubyte *strErr = qglGetString( GL_PROGRAM_ERROR_STRING_ARB );
+		int iErrPos = 0;
+		qglGetIntegerv( GL_PROGRAM_ERROR_POSITION_ARB, &iErrPos );
+		assert( iErrPos == -1 );
+	}
+
+	// NOTE: I make an assumption here. If you have (current) nvidia hardware, you obviously support register combiners instead of fragment
+	// programs, so use those. The problem with this is that nv30 WILL support fragment shaders, breaking this logic. The good thing is that
+	// if you always ask for regcoms before fragment shaders, you'll always just use regcoms (problem solved... for now). - AReis
+
+	// Load Pixel Shaders (either regcoms or fragprogs).
+	if ( qglCombinerParameteriNV )
+	{
+		// The purpose of this regcom is to blend all the pixels together from the 4 texture units, but with their
+		// texture coordinates offset by 1 (or more) texels, effectively letting us blend adjoining pixels. The weight is
+		// used to either strengthen or weaken the pixel intensity. The more it diffuses (the higher the radius of the glow),
+		// the higher the intensity should be for a noticable effect.
+		// Regcom result is: ( tex1 * fBlurWeight ) + ( tex2 * fBlurWeight ) + ( tex2 * fBlurWeight ) + ( tex2 * fBlurWeight )
+
+		// VV guys, this is the pixel shader you would use instead :-)
+		/*
+		// c0 is the blur weight.
+		ps 1.1
+		tex		t0
+		tex		t1
+		tex		t2
+		tex		t3
+
+		mul		r0, c0, t0;
+		madd	r0, c0, t1, r0;
+		madd	r0, c0, t2, r0;
+		madd	r0, c0, t3, r0;
+		*/
+		tr.glowPShader = qglGenLists( 1 );
+		qglNewList( tr.glowPShader, GL_COMPILE );
+			qglCombinerParameteriNV( GL_NUM_GENERAL_COMBINERS_NV, 2 );
+
+			// spare0 = fBlend * tex0 + fBlend * tex1.
+			qglCombinerInputNV( GL_COMBINER0_NV, GL_RGB, GL_VARIABLE_A_NV, GL_TEXTURE0_ARB, GL_UNSIGNED_IDENTITY_NV, GL_RGB );
+			qglCombinerInputNV( GL_COMBINER0_NV, GL_RGB, GL_VARIABLE_B_NV, GL_CONSTANT_COLOR0_NV, GL_UNSIGNED_IDENTITY_NV, GL_RGB );
+			qglCombinerInputNV( GL_COMBINER0_NV, GL_RGB, GL_VARIABLE_C_NV, GL_TEXTURE1_ARB, GL_UNSIGNED_IDENTITY_NV, GL_RGB );
+			qglCombinerInputNV( GL_COMBINER0_NV, GL_RGB, GL_VARIABLE_D_NV, GL_CONSTANT_COLOR0_NV, GL_UNSIGNED_IDENTITY_NV, GL_RGB );
+			qglCombinerOutputNV( GL_COMBINER0_NV, GL_RGB, GL_DISCARD_NV, GL_DISCARD_NV, GL_SPARE0_NV, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE );
+
+			// spare1 = fBlend * tex2 + fBlend * tex3.
+			qglCombinerInputNV( GL_COMBINER1_NV, GL_RGB, GL_VARIABLE_A_NV, GL_TEXTURE2_ARB, GL_UNSIGNED_IDENTITY_NV, GL_RGB );
+			qglCombinerInputNV( GL_COMBINER1_NV, GL_RGB, GL_VARIABLE_B_NV, GL_CONSTANT_COLOR0_NV, GL_UNSIGNED_IDENTITY_NV, GL_RGB );
+			qglCombinerInputNV( GL_COMBINER1_NV, GL_RGB, GL_VARIABLE_C_NV, GL_TEXTURE3_ARB, GL_UNSIGNED_IDENTITY_NV, GL_RGB );
+			qglCombinerInputNV( GL_COMBINER1_NV, GL_RGB, GL_VARIABLE_D_NV, GL_CONSTANT_COLOR0_NV, GL_UNSIGNED_IDENTITY_NV, GL_RGB );
+			qglCombinerOutputNV( GL_COMBINER1_NV, GL_RGB, GL_DISCARD_NV, GL_DISCARD_NV, GL_SPARE1_NV, GL_NONE, GL_NONE, GL_FALSE, GL_FALSE, GL_FALSE );
+
+			// ( A * B ) + ( ( 1 - A ) * C ) + D = ( spare0 * 1 ) + ( ( 1 - spare0 ) * 0 ) + spare1 == spare0 + spare1.
+			qglFinalCombinerInputNV( GL_VARIABLE_A_NV, GL_SPARE0_NV,    GL_UNSIGNED_IDENTITY_NV, GL_RGB );
+			qglFinalCombinerInputNV( GL_VARIABLE_B_NV, GL_ZERO,			GL_UNSIGNED_INVERT_NV, GL_RGB );
+			qglFinalCombinerInputNV( GL_VARIABLE_C_NV, GL_ZERO,			GL_UNSIGNED_IDENTITY_NV, GL_RGB );
+			qglFinalCombinerInputNV( GL_VARIABLE_D_NV, GL_SPARE1_NV,	GL_UNSIGNED_IDENTITY_NV, GL_RGB );
+		qglEndList();
+	}
+	else if ( qglGenProgramsARB )
+	{
+		qglGenProgramsARB( 1, &tr.glowPShader );
+		qglBindProgramARB( GL_FRAGMENT_PROGRAM_ARB, tr.glowPShader );
+		qglProgramStringARB( GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB, strlen( ( char * ) g_strGlowPShaderARB ), g_strGlowPShaderARB );
+
+//		const GLubyte *strErr = qglGetString( GL_PROGRAM_ERROR_STRING_ARB );
+		int iErrPos = 0;
+		qglGetIntegerv( GL_PROGRAM_ERROR_POSITION_ARB, &iErrPos );
+		assert( iErrPos == -1 );
+	}
+#endif
+}
+
+static void CreateExternalShaders( void ) {
+	tr.projectionShadowShader = R_FindShader( "projectionShadow", lightmapsNone, stylesDefault, qtrue );
+	tr.projectionShadowShader->sort = SS_STENCIL_SHADOW;
+	tr.sunShader = R_FindShader( "sun", lightmapsNone, stylesDefault, qtrue );
+}
+
+#endif // !DEDICATED
+/*
+==================
+R_InitShaders
+==================
+*/
+void R_InitShaders(qboolean server)
+{
+	//Com_Printf ("Initializing Shaders\n" );
+
+	Com_Memset(hashTable, 0, sizeof(hashTable));
+
+	deferLoad = qfalse;
+
+#ifndef DEDICATED
+	if (!server)
+	{
+		CreateInternalShaders();
+
+		ScanAndLoadShaderFiles("shaders");
+
+		CreateExternalShaders();
+	}
+#endif
+}
diff --git a/codemp/renderer/tr_shadows.cpp b/codemp/renderer/tr_shadows.cpp
new file mode 100644
index 0000000..13f86b4
--- /dev/null
+++ b/codemp/renderer/tr_shadows.cpp
@@ -0,0 +1,709 @@
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+#include "tr_local.h"
+
+
+/*
+
+  for a projection shadow:
+
+  point[x] += light vector * ( z - shadow plane )
+  point[y] +=
+  point[z] = shadow plane
+
+  1 0 light[x] / light[z]
+
+*/
+
+#define _STENCIL_REVERSE
+
+typedef struct {
+	int		i2;
+	int		facing;
+} edgeDef_t;
+
+#define	MAX_EDGE_DEFS	32
+
+static	edgeDef_t	edgeDefs[SHADER_MAX_VERTEXES][MAX_EDGE_DEFS];
+static	int			numEdgeDefs[SHADER_MAX_VERTEXES];
+static	int			facing[SHADER_MAX_INDEXES/3];
+
+void R_AddEdgeDef( int i1, int i2, int facing ) {
+	int		c;
+
+	c = numEdgeDefs[ i1 ];
+	if ( c == MAX_EDGE_DEFS ) {
+		return;		// overflow
+	}
+	edgeDefs[ i1 ][ c ].i2 = i2;
+	edgeDefs[ i1 ][ c ].facing = facing;
+
+	numEdgeDefs[ i1 ]++;
+}
+
+void R_RenderShadowEdges( void ) {
+	int		i;
+	int		c;
+	int		j;
+	int		i2;
+	int		c_edges, c_rejected;
+#if 0
+	int		c2, k;
+	int		hit[2];
+#endif
+#ifdef _STENCIL_REVERSE
+	int		numTris;
+	int		o1, o2, o3;
+#endif
+
+	// an edge is NOT a silhouette edge if its face doesn't face the light,
+	// or if it has a reverse paired edge that also faces the light.
+	// A well behaved polyhedron would have exactly two faces for each edge,
+	// but lots of models have dangling edges or overfanned edges
+	c_edges = 0;
+	c_rejected = 0;
+
+	for ( i = 0 ; i < tess.numVertexes ; i++ ) {
+		c = numEdgeDefs[ i ];
+		for ( j = 0 ; j < c ; j++ ) {
+			if ( !edgeDefs[ i ][ j ].facing ) {
+				continue;
+			}
+
+			//with this system we can still get edges shared by more than 2 tris which
+			//produces artifacts including seeing the shadow through walls. So for now
+			//we are going to render all edges even though it is a tiny bit slower. -rww
+#if 1
+			i2 = edgeDefs[ i ][ j ].i2;
+			qglBegin( GL_TRIANGLE_STRIP );
+				qglVertex3fv( tess.xyz[ i ] );
+				qglVertex3fv( tess.xyz[ i + tess.numVertexes ] );
+				qglVertex3fv( tess.xyz[ i2 ] );
+				qglVertex3fv( tess.xyz[ i2 + tess.numVertexes ] );
+			qglEnd();
+#else
+			hit[0] = 0;
+			hit[1] = 0;
+
+			i2 = edgeDefs[ i ][ j ].i2;
+			c2 = numEdgeDefs[ i2 ];
+			for ( k = 0 ; k < c2 ; k++ ) {
+				if ( edgeDefs[ i2 ][ k ].i2 == i ) {
+					hit[ edgeDefs[ i2 ][ k ].facing ]++;
+				}
+			}
+
+			// if it doesn't share the edge with another front facing
+			// triangle, it is a sil edge
+			if (hit[1] != 1)
+			{
+				qglBegin( GL_TRIANGLE_STRIP );
+				qglVertex3fv( tess.xyz[ i ] );
+				qglVertex3fv( tess.xyz[ i + tess.numVertexes ] );
+				qglVertex3fv( tess.xyz[ i2 ] );
+				qglVertex3fv( tess.xyz[ i2 + tess.numVertexes ] );
+				qglEnd();
+				c_edges++;
+			} else {
+				c_rejected++;
+			}
+#endif
+		}
+	}
+
+#ifdef _STENCIL_REVERSE
+	//Carmack Reverse<tm> method requires that volumes
+	//be capped properly -rww
+	numTris = tess.numIndexes / 3;
+
+	for ( i = 0 ; i < numTris ; i++ )
+	{
+		if ( !facing[i] )
+		{
+			continue;
+		}
+
+		o1 = tess.indexes[ i*3 + 0 ];
+		o2 = tess.indexes[ i*3 + 1 ];
+		o3 = tess.indexes[ i*3 + 2 ];
+
+		qglBegin(GL_TRIANGLES);
+			qglVertex3fv(tess.xyz[o1]);
+			qglVertex3fv(tess.xyz[o2]);
+			qglVertex3fv(tess.xyz[o3]);
+		qglEnd();
+		qglBegin(GL_TRIANGLES);
+			qglVertex3fv(tess.xyz[o3 + tess.numVertexes]);
+			qglVertex3fv(tess.xyz[o2 + tess.numVertexes]);
+			qglVertex3fv(tess.xyz[o1 + tess.numVertexes]);
+		qglEnd();
+	}
+#endif
+}
+
+//#define _DEBUG_STENCIL_SHADOWS
+
+/*
+=================
+RB_ShadowTessEnd
+
+triangleFromEdge[ v1 ][ v2 ]
+
+
+  set triangle from edge( v1, v2, tri )
+  if ( facing[ triangleFromEdge[ v1 ][ v2 ] ] && !facing[ triangleFromEdge[ v2 ][ v1 ] ) {
+  }
+=================
+*/
+void RB_DoShadowTessEnd( vec3_t lightPos );
+void RB_ShadowTessEnd( void )
+{
+#if 0
+	if (backEnd.currentEntity &&
+		(backEnd.currentEntity->directedLight[0] ||
+			backEnd.currentEntity->directedLight[1] ||
+			backEnd.currentEntity->directedLight[2]))
+	{ //an ent that has its light set for it
+		RB_DoShadowTessEnd(NULL);
+		return;
+	}
+
+//	if (!tess.dlightBits)
+//	{
+//		return;
+//	}
+
+	int i = 0;
+	dlight_t *dl;
+
+	R_TransformDlights( backEnd.refdef.num_dlights, backEnd.refdef.dlights, &backEnd.ori );
+/*	while (i < tr.refdef.num_dlights)
+	{
+		if (tess.dlightBits & (1 << i))
+		{
+			dl = &tr.refdef.dlights[i];
+
+			RB_DoShadowTessEnd(dl->transformed);
+		}
+        
+		i++;
+	}
+	*/
+			dl = &tr.refdef.dlights[0];
+
+			RB_DoShadowTessEnd(dl->transformed);
+
+#else //old ents-only way
+	RB_DoShadowTessEnd(NULL);
+#endif
+}
+
+void RB_DoShadowTessEnd( vec3_t lightPos )
+{
+	int		i;
+	int		numTris;
+	vec3_t	lightDir;
+
+	// we can only do this if we have enough space in the vertex buffers
+	if ( tess.numVertexes >= SHADER_MAX_VERTEXES / 2 ) {
+		return;
+	}
+
+	if ( glConfig.stencilBits < 4 ) {
+		return;
+	}
+
+#if 1 //controlled method - try to keep shadows in range so they don't show through so much -rww
+	vec3_t	worldxyz;
+	vec3_t	entLight;
+	float	groundDist;
+
+	VectorCopy( backEnd.currentEntity->lightDir, entLight );
+	entLight[2] = 0.0f;
+	VectorNormalize(entLight);
+
+	//Oh well, just cast them straight down no matter what onto the ground plane.
+	//This presets no chance of screwups and still looks better than a stupid
+	//shader blob.
+	VectorSet(lightDir, entLight[0]*0.3f, entLight[1]*0.3f, 1.0f);
+	// project vertexes away from light direction
+	for ( i = 0 ; i < tess.numVertexes ; i++ ) {
+		//add or.origin to vert xyz to end up with world oriented coord, then figure
+		//out the ground pos for the vert to project the shadow volume to
+		VectorAdd(tess.xyz[i], backEnd.ori.origin, worldxyz);
+		groundDist = worldxyz[2] - backEnd.currentEntity->e.shadowPlane;
+		groundDist += 16.0f; //fudge factor
+		VectorMA( tess.xyz[i], -groundDist, lightDir, tess.xyz[i+tess.numVertexes] );
+	}
+#else
+	if (lightPos)
+	{
+		for ( i = 0 ; i < tess.numVertexes ; i++ )
+		{
+			tess.xyz[i+tess.numVertexes][0] = tess.xyz[i][0]+(( tess.xyz[i][0]-lightPos[0] )*128.0f);
+			tess.xyz[i+tess.numVertexes][1] = tess.xyz[i][1]+(( tess.xyz[i][1]-lightPos[1] )*128.0f);
+			tess.xyz[i+tess.numVertexes][2] = tess.xyz[i][2]+(( tess.xyz[i][2]-lightPos[2] )*128.0f);
+		}
+	}
+	else
+	{
+		VectorCopy( backEnd.currentEntity->lightDir, lightDir );
+
+		// project vertexes away from light direction
+		for ( i = 0 ; i < tess.numVertexes ; i++ ) {
+			VectorMA( tess.xyz[i], -512, lightDir, tess.xyz[i+tess.numVertexes] );
+		}
+	}
+#endif
+	// decide which triangles face the light
+	Com_Memset( numEdgeDefs, 0, 4 * tess.numVertexes );
+
+	numTris = tess.numIndexes / 3;
+	for ( i = 0 ; i < numTris ; i++ ) {
+		int		i1, i2, i3;
+		vec3_t	d1, d2, normal;
+		float	*v1, *v2, *v3;
+		float	d;
+
+		i1 = tess.indexes[ i*3 + 0 ];
+		i2 = tess.indexes[ i*3 + 1 ];
+		i3 = tess.indexes[ i*3 + 2 ];
+
+		v1 = tess.xyz[ i1 ];
+		v2 = tess.xyz[ i2 ];
+		v3 = tess.xyz[ i3 ];
+
+		if (!lightPos)
+		{
+			VectorSubtract( v2, v1, d1 );
+			VectorSubtract( v3, v1, d2 );
+			CrossProduct( d1, d2, normal );
+
+			d = DotProduct( normal, lightDir );
+		}
+		else
+		{
+			float planeEq[4];
+			planeEq[0] = v1[1]*(v2[2]-v3[2]) + v2[1]*(v3[2]-v1[2]) + v3[1]*(v1[2]-v2[2]);
+			planeEq[1] = v1[2]*(v2[0]-v3[0]) + v2[2]*(v3[0]-v1[0]) + v3[2]*(v1[0]-v2[0]);
+			planeEq[2] = v1[0]*(v2[1]-v3[1]) + v2[0]*(v3[1]-v1[1]) + v3[0]*(v1[1]-v2[1]);
+			planeEq[3] = -( v1[0]*( v2[1]*v3[2] - v3[1]*v2[2] ) +
+						v2[0]*(v3[1]*v1[2] - v1[1]*v3[2]) +
+						v3[0]*(v1[1]*v2[2] - v2[1]*v1[2]) );
+
+			d = planeEq[0]*lightPos[0]+
+				planeEq[1]*lightPos[1]+
+				planeEq[2]*lightPos[2]+
+				planeEq[3];
+		}
+
+		if ( d > 0 ) {
+			facing[ i ] = 1;
+		} else {
+			facing[ i ] = 0;
+		}
+
+		// create the edges
+		R_AddEdgeDef( i1, i2, facing[ i ] );
+		R_AddEdgeDef( i2, i3, facing[ i ] );
+		R_AddEdgeDef( i3, i1, facing[ i ] );
+	}
+
+	GL_Bind( tr.whiteImage );
+	//qglEnable( GL_CULL_FACE );
+	GL_State( GLS_SRCBLEND_ONE | GLS_DSTBLEND_ZERO );
+
+#ifndef _DEBUG_STENCIL_SHADOWS
+	qglColor3f( 0.2f, 0.2f, 0.2f );
+
+	// don't write to the color buffer
+	qglColorMask( GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE );
+
+	qglEnable( GL_STENCIL_TEST );
+	qglStencilFunc( GL_ALWAYS, 1, 255 );
+#else
+	qglColor3f( 1.0f, 0.0f, 0.0f );
+	qglPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
+	//qglDisable(GL_DEPTH_TEST);
+#endif
+
+#ifdef _STENCIL_REVERSE
+	qglDepthFunc(GL_LESS);
+
+	//now using the Carmack Reverse<tm> -rww
+	if ( backEnd.viewParms.isMirror ) {
+		//qglCullFace( GL_BACK );
+		GL_Cull(CT_BACK_SIDED);
+		qglStencilOp( GL_KEEP, GL_INCR, GL_KEEP );
+
+		R_RenderShadowEdges();
+
+		//qglCullFace( GL_FRONT );
+		GL_Cull(CT_FRONT_SIDED);
+		qglStencilOp( GL_KEEP, GL_DECR, GL_KEEP );
+
+		R_RenderShadowEdges();
+	} else {
+		//qglCullFace( GL_FRONT );
+		GL_Cull(CT_FRONT_SIDED);
+		qglStencilOp( GL_KEEP, GL_INCR, GL_KEEP );
+
+		R_RenderShadowEdges();
+
+		//qglCullFace( GL_BACK );
+		GL_Cull(CT_BACK_SIDED);
+		qglStencilOp( GL_KEEP, GL_DECR, GL_KEEP );
+
+		R_RenderShadowEdges();
+	}
+
+	qglDepthFunc(GL_LEQUAL);
+#else
+	// mirrors have the culling order reversed
+	if ( backEnd.viewParms.isMirror ) {
+		qglCullFace( GL_FRONT );
+		qglStencilOp( GL_KEEP, GL_KEEP, GL_INCR );
+
+		R_RenderShadowEdges();
+
+		qglCullFace( GL_BACK );
+		qglStencilOp( GL_KEEP, GL_KEEP, GL_DECR );
+
+		R_RenderShadowEdges();
+	} else {
+		qglCullFace( GL_BACK );
+		qglStencilOp( GL_KEEP, GL_KEEP, GL_INCR );
+
+		R_RenderShadowEdges();
+
+		qglCullFace( GL_FRONT );
+		qglStencilOp( GL_KEEP, GL_KEEP, GL_DECR );
+
+		R_RenderShadowEdges();
+	}
+#endif
+
+	// reenable writing to the color buffer
+	qglColorMask( GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE );
+
+#ifdef _DEBUG_STENCIL_SHADOWS
+	qglPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
+#endif
+}
+
+
+/*
+=================
+RB_ShadowFinish
+
+Darken everything that is is a shadow volume.
+We have to delay this until everything has been shadowed,
+because otherwise shadows from different body parts would
+overlap and double darken.
+=================
+*/
+void RB_ShadowFinish( void ) {
+	if ( r_shadows->integer != 2 ) {
+		return;
+	}
+	if ( glConfig.stencilBits < 4 ) {
+		return;
+	}
+
+#ifdef _DEBUG_STENCIL_SHADOWS
+	return;
+#endif
+
+	qglEnable( GL_STENCIL_TEST );
+	qglStencilFunc( GL_NOTEQUAL, 0, 255 );
+
+	qglStencilOp( GL_KEEP, GL_KEEP, GL_KEEP );
+
+	bool planeZeroBack = false;
+	if (qglIsEnabled(GL_CLIP_PLANE0))
+	{
+		planeZeroBack = true;
+		qglDisable (GL_CLIP_PLANE0);
+	}
+	GL_Cull(CT_TWO_SIDED);
+	//qglDisable (GL_CULL_FACE);
+
+	GL_Bind( tr.whiteImage );
+
+	qglPushMatrix();
+    qglLoadIdentity ();
+
+//	qglColor3f( 0.6f, 0.6f, 0.6f );
+//	GL_State( GLS_DEPTHMASK_TRUE | GLS_SRCBLEND_DST_COLOR | GLS_DSTBLEND_ZERO );
+
+//	qglColor3f( 1, 0, 0 );
+//	GL_State( GLS_DEPTHMASK_TRUE | GLS_SRCBLEND_ONE | GLS_DSTBLEND_ZERO );
+
+	qglColor4f( 0.0f, 0.0f, 0.0f, 0.5f );
+	//GL_State( GLS_DEPTHMASK_TRUE | GLS_SRCBLEND_SRC_ALPHA | GLS_DSTBLEND_ONE_MINUS_SRC_ALPHA );
+	GL_State( GLS_SRCBLEND_SRC_ALPHA | GLS_DSTBLEND_ONE_MINUS_SRC_ALPHA );
+
+	qglBegin( GL_QUADS );
+	qglVertex3f( -100, 100, -10 );
+	qglVertex3f( 100, 100, -10 );
+	qglVertex3f( 100, -100, -10 );
+	qglVertex3f( -100, -100, -10 );
+	qglEnd ();
+
+	qglColor4f(1,1,1,1);
+	qglDisable( GL_STENCIL_TEST );
+	if (planeZeroBack)
+	{
+		qglEnable (GL_CLIP_PLANE0);
+	}
+	qglPopMatrix();
+}
+
+
+/*
+=================
+RB_ProjectionShadowDeform
+
+=================
+*/
+void RB_ProjectionShadowDeform( void ) {
+	float	*xyz;
+	int		i;
+	float	h;
+	vec3_t	ground;
+	vec3_t	light;
+	float	groundDist;
+	float	d;
+	vec3_t	lightDir;
+
+	xyz = ( float * ) tess.xyz;
+
+	ground[0] = backEnd.ori.axis[0][2];
+	ground[1] = backEnd.ori.axis[1][2];
+	ground[2] = backEnd.ori.axis[2][2];
+
+	groundDist = backEnd.ori.origin[2] - backEnd.currentEntity->e.shadowPlane;
+
+	VectorCopy( backEnd.currentEntity->lightDir, lightDir );
+	d = DotProduct( lightDir, ground );
+	// don't let the shadows get too long or go negative
+	if ( d < 0.5 ) {
+		VectorMA( lightDir, (0.5 - d), ground, lightDir );
+		d = DotProduct( lightDir, ground );
+	}
+	d = 1.0 / d;
+
+	light[0] = lightDir[0] * d;
+	light[1] = lightDir[1] * d;
+	light[2] = lightDir[2] * d;
+
+	for ( i = 0; i < tess.numVertexes; i++, xyz += 4 ) {
+		h = DotProduct( xyz, ground ) + groundDist;
+
+		xyz[0] -= light[0] * h;
+		xyz[1] -= light[1] * h;
+		xyz[2] -= light[2] * h;
+	}
+}
+
+//update tr.screenImage
+void RB_CaptureScreenImage(void)
+{
+	int radX = 2048;
+	int radY = 2048;
+	int x = glConfig.vidWidth/2;
+	int y = glConfig.vidHeight/2;
+	int cX, cY;
+
+	GL_Bind( tr.screenImage );
+	//using this method, we could pixel-filter the texture and all sorts of crazy stuff.
+	//but, it is slow as hell.
+	/*
+	static byte *tmp = NULL;
+	if (!tmp)
+	{
+		tmp = (byte *)Z_Malloc((sizeof(byte)*4)*(glConfig.vidWidth*glConfig.vidHeight), TAG_ICARUS, qtrue);
+	}
+	qglReadPixels(0, 0, glConfig.vidWidth, glConfig.vidHeight, GL_RGBA, GL_UNSIGNED_BYTE, tmp);
+	qglTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 512, 512, 0, GL_RGBA, GL_UNSIGNED_BYTE, tmp);
+	*/
+
+	if (radX > glConfig.maxTextureSize)
+	{
+		radX = glConfig.maxTextureSize;
+	}
+	if (radY > glConfig.maxTextureSize)
+	{
+		radY = glConfig.maxTextureSize;
+	}
+
+	while (glConfig.vidWidth < radX)
+	{
+		radX /= 2;
+	}
+	while (glConfig.vidHeight < radY)
+	{
+		radY /= 2;
+	}
+
+	cX = x-(radX/2);
+	cY = y-(radY/2);
+
+	if (cX+radX > glConfig.vidWidth)
+	{ //would it go off screen?
+		cX = glConfig.vidWidth-radX;
+	}
+	else if (cX < 0)
+	{ //cap it off at 0
+		cX = 0;
+	}
+
+	if (cY+radY > glConfig.vidHeight)
+	{ //would it go off screen?
+		cY = glConfig.vidHeight-radY;
+	}
+	else if (cY < 0)
+	{ //cap it off at 0
+		cY = 0;
+	}
+
+	qglCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA16, cX, cY, radX, radY, 0);
+}
+
+//yeah.. not really shadow-related.. but it's stencil-related. -rww
+float tr_distortionAlpha = 1.0f; //opaque
+float tr_distortionStretch = 0.0f; //no stretch override
+qboolean tr_distortionPrePost = qfalse; //capture before postrender phase?
+qboolean tr_distortionNegate = qfalse; //negative blend mode
+void RB_DistortionFill(void)
+{
+	float alpha = tr_distortionAlpha;
+	float spost = 0.0f;
+	float spost2 = 0.0f;
+
+	if ( glConfig.stencilBits < 4 )
+	{
+		return;
+	}
+
+	//ok, cap the stupid thing now I guess
+	if (!tr_distortionPrePost)
+	{
+		RB_CaptureScreenImage();
+	}
+
+	qglEnable(GL_STENCIL_TEST);
+	qglStencilFunc(GL_NOTEQUAL, 0, 0xFFFFFFFF);
+	qglStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
+
+	qglDisable (GL_CLIP_PLANE0);
+	GL_Cull( CT_TWO_SIDED );
+
+	//reset the view matrices and go into ortho mode
+	qglMatrixMode(GL_PROJECTION);
+	qglPushMatrix();
+	qglLoadIdentity();
+	qglOrtho(0, glConfig.vidWidth, glConfig.vidHeight, 32, -1, 1);
+	qglMatrixMode(GL_MODELVIEW);
+	qglPushMatrix();
+	qglLoadIdentity();
+
+	if (tr_distortionStretch)
+	{ //override
+		spost = tr_distortionStretch;
+		spost2 = tr_distortionStretch;
+	}
+	else
+	{ //do slow stretchy effect
+		spost = sin(tr.refdef.time*0.0005f);
+		if (spost < 0.0f)
+		{
+			spost = -spost;
+		}
+		spost *= 0.2f;
+
+		spost2 = sin(tr.refdef.time*0.0005f);
+		if (spost2 < 0.0f)
+		{
+			spost2 = -spost2;
+		}
+		spost2 *= 0.08f;
+	}
+
+	if (alpha != 1.0f)
+	{ //blend
+		GL_State(GLS_SRCBLEND_SRC_ALPHA|GLS_DSTBLEND_SRC_ALPHA);
+	}
+	else
+	{ //be sure to reset the draw state
+		GL_State(0);
+	}
+
+	qglBegin(GL_QUADS);
+		qglColor4f(1.0f, 1.0f, 1.0f, alpha);
+		qglTexCoord2f(0+spost2, 1-spost);
+		qglVertex2f(0, 0);
+
+		qglTexCoord2f(0+spost2, 0+spost);
+		qglVertex2f(0, glConfig.vidHeight);
+
+		qglTexCoord2f(1-spost2, 0+spost);
+		qglVertex2f(glConfig.vidWidth, glConfig.vidHeight);
+
+		qglTexCoord2f(1-spost2, 1-spost);
+		qglVertex2f(glConfig.vidWidth, 0);
+	qglEnd();
+
+	if (tr_distortionAlpha == 1.0f && tr_distortionStretch == 0.0f)
+	{ //no overrides
+		if (tr_distortionNegate)
+		{ //probably the crazy alternate saber trail
+			alpha = 0.8f;
+			GL_State(GLS_SRCBLEND_ZERO|GLS_DSTBLEND_ONE_MINUS_SRC_COLOR);
+		}
+		else
+		{
+			alpha = 0.5f;
+			GL_State(GLS_SRCBLEND_SRC_ALPHA|GLS_DSTBLEND_SRC_ALPHA);
+		}
+
+		spost = sin(tr.refdef.time*0.0008f);
+		if (spost < 0.0f)
+		{
+			spost = -spost;
+		}
+		spost *= 0.08f;
+
+		spost2 = sin(tr.refdef.time*0.0008f);
+		if (spost2 < 0.0f)
+		{
+			spost2 = -spost2;
+		}
+		spost2 *= 0.2f;
+
+		qglBegin(GL_QUADS);
+			qglColor4f(1.0f, 1.0f, 1.0f, alpha);
+			qglTexCoord2f(0+spost2, 1-spost);
+			qglVertex2f(0, 0);
+
+			qglTexCoord2f(0+spost2, 0+spost);
+			qglVertex2f(0, glConfig.vidHeight);
+
+			qglTexCoord2f(1-spost2, 0+spost);
+			qglVertex2f(glConfig.vidWidth, glConfig.vidHeight);
+
+			qglTexCoord2f(1-spost2, 1-spost);
+			qglVertex2f(glConfig.vidWidth, 0);
+		qglEnd();
+	}
+
+	//pop the view matrices back
+	qglMatrixMode(GL_PROJECTION);
+	qglPopMatrix();
+	qglMatrixMode(GL_MODELVIEW);
+	qglPopMatrix();
+
+	qglDisable( GL_STENCIL_TEST );
+}
+
diff --git a/codemp/renderer/tr_sky.cpp b/codemp/renderer/tr_sky.cpp
new file mode 100644
index 0000000..5a3534f
--- /dev/null
+++ b/codemp/renderer/tr_sky.cpp
@@ -0,0 +1,849 @@
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+// tr_sky.c
+#include "tr_local.h"
+
+#define SKY_SUBDIVISIONS		8
+#define HALF_SKY_SUBDIVISIONS	(SKY_SUBDIVISIONS/2)
+
+static float s_cloudTexCoords[6][SKY_SUBDIVISIONS+1][SKY_SUBDIVISIONS+1][2];
+static float s_cloudTexP[6][SKY_SUBDIVISIONS+1][SKY_SUBDIVISIONS+1];
+
+extern bool g_bRenderGlowingObjects;
+
+/*
+===================================================================================
+
+POLYGON TO BOX SIDE PROJECTION
+
+===================================================================================
+*/
+
+static vec3_t sky_clip[6] = 
+{
+	{1,1,0},
+	{1,-1,0},
+	{0,-1,1},
+	{0,1,1},
+	{1,0,1},
+	{-1,0,1} 
+};
+
+static float	sky_mins[2][6], sky_maxs[2][6];
+static float	sky_min, sky_max;
+
+/*
+================
+AddSkyPolygon
+================
+*/
+static void AddSkyPolygon (int nump, vec3_t vecs) 
+{
+	int		i,j;
+	vec3_t	v, av;
+	float	s, t, dv;
+	int		axis;
+	float	*vp;
+	// s = [0]/[2], t = [1]/[2]
+	static int	vec_to_st[6][3] =
+	{
+		{-2,3,1},
+		{2,3,-1},
+
+		{1,3,2},
+		{-1,3,-2},
+
+		{-2,-1,3},
+		{-2,1,-3}
+
+	//	{-1,2,3},
+	//	{1,2,-3}
+	};
+
+	// decide which face it maps to
+	VectorCopy (vec3_origin, v);
+	for (i=0, vp=vecs ; i<nump ; i++, vp+=3)
+	{
+		VectorAdd (vp, v, v);
+	}
+	av[0] = fabs(v[0]);
+	av[1] = fabs(v[1]);
+	av[2] = fabs(v[2]);
+	if (av[0] > av[1] && av[0] > av[2])
+	{
+		if (v[0] < 0)
+			axis = 1;
+		else
+			axis = 0;
+	}
+	else if (av[1] > av[2] && av[1] > av[0])
+	{
+		if (v[1] < 0)
+			axis = 3;
+		else
+			axis = 2;
+	}
+	else
+	{
+		if (v[2] < 0)
+			axis = 5;
+		else
+			axis = 4;
+	}
+
+	// project new texture coords
+	for (i=0 ; i<nump ; i++, vecs+=3)
+	{
+		j = vec_to_st[axis][2];
+		if (j > 0)
+			dv = vecs[j - 1];
+		else
+			dv = -vecs[-j - 1];
+		if (dv < 0.001)
+			continue;	// don't divide by zero
+		j = vec_to_st[axis][0];
+		if (j < 0)
+			s = -vecs[-j -1] / dv;
+		else
+			s = vecs[j-1] / dv;
+		j = vec_to_st[axis][1];
+		if (j < 0)
+			t = -vecs[-j -1] / dv;
+		else
+			t = vecs[j-1] / dv;
+
+		if (s < sky_mins[0][axis])
+			sky_mins[0][axis] = s;
+		if (t < sky_mins[1][axis])
+			sky_mins[1][axis] = t;
+		if (s > sky_maxs[0][axis])
+			sky_maxs[0][axis] = s;
+		if (t > sky_maxs[1][axis])
+			sky_maxs[1][axis] = t;
+	}
+}
+
+#define	ON_EPSILON		0.1f			// point on plane side epsilon
+#define	MAX_CLIP_VERTS	64
+/*
+================
+ClipSkyPolygon
+================
+*/
+static void ClipSkyPolygon (int nump, vec3_t vecs, int stage) 
+{
+	float	*norm;
+	float	*v;
+	qboolean	front, back;
+	float	d, e;
+	float	dists[MAX_CLIP_VERTS];
+	int		sides[MAX_CLIP_VERTS];
+	vec3_t	newv[2][MAX_CLIP_VERTS];
+	int		newc[2];
+	int		i, j;
+
+	if (nump > MAX_CLIP_VERTS-2)
+		Com_Error (ERR_DROP, "ClipSkyPolygon: MAX_CLIP_VERTS");
+	if (stage == 6)
+	{	// fully clipped, so draw it
+		AddSkyPolygon (nump, vecs);
+		return;
+	}
+
+	front = back = qfalse;
+	norm = sky_clip[stage];
+	for (i=0, v = vecs ; i<nump ; i++, v+=3)
+	{
+		d = DotProduct (v, norm);
+		if (d > ON_EPSILON)
+		{
+			front = qtrue;
+			sides[i] = SIDE_FRONT;
+		}
+		else if (d < -ON_EPSILON)
+		{
+			back = qtrue;
+			sides[i] = SIDE_BACK;
+		}
+		else
+			sides[i] = SIDE_ON;
+		dists[i] = d;
+	}
+
+	if (!front || !back)
+	{	// not clipped
+		ClipSkyPolygon (nump, vecs, stage+1);
+		return;
+	}
+
+	// clip it
+	sides[i] = sides[0];
+	dists[i] = dists[0];
+	VectorCopy (vecs, (vecs+(i*3)) );
+	newc[0] = newc[1] = 0;
+
+	for (i=0, v = vecs ; i<nump ; i++, v+=3)
+	{
+		switch (sides[i])
+		{
+		case SIDE_FRONT:
+			VectorCopy (v, newv[0][newc[0]]);
+			newc[0]++;
+			break;
+		case SIDE_BACK:
+			VectorCopy (v, newv[1][newc[1]]);
+			newc[1]++;
+			break;
+		case SIDE_ON:
+			VectorCopy (v, newv[0][newc[0]]);
+			newc[0]++;
+			VectorCopy (v, newv[1][newc[1]]);
+			newc[1]++;
+			break;
+		}
+
+		if (sides[i] == SIDE_ON || sides[i+1] == SIDE_ON || sides[i+1] == sides[i])
+			continue;
+
+		d = dists[i] / (dists[i] - dists[i+1]);
+		for (j=0 ; j<3 ; j++)
+		{
+			e = v[j] + d*(v[j+3] - v[j]);
+			newv[0][newc[0]][j] = e;
+			newv[1][newc[1]][j] = e;
+		}
+		newc[0]++;
+		newc[1]++;
+	}
+
+	// continue
+	ClipSkyPolygon (newc[0], newv[0][0], stage+1);
+	ClipSkyPolygon (newc[1], newv[1][0], stage+1);
+}
+
+/*
+==============
+ClearSkyBox
+==============
+*/
+static void ClearSkyBox (void) {
+	int		i;
+
+	for (i=0 ; i<6 ; i++) {
+		sky_mins[0][i] = sky_mins[1][i] = 9999;
+		sky_maxs[0][i] = sky_maxs[1][i] = -9999;
+	}
+}
+
+/*
+================
+RB_ClipSkyPolygons
+================
+*/
+void RB_ClipSkyPolygons( shaderCommands_t *input )
+{
+	vec3_t		p[5];	// need one extra point for clipping
+	int			i, j;
+
+	ClearSkyBox();
+
+	for ( i = 0; i < input->numIndexes; i += 3 )
+	{
+		for (j = 0 ; j < 3 ; j++) 
+		{
+			VectorSubtract( input->xyz[input->indexes[i+j]],
+							backEnd.viewParms.ori.origin, 
+							p[j] );
+		}
+		ClipSkyPolygon( 3, p[0], 0 );
+	}
+}
+
+/*
+===================================================================================
+
+CLOUD VERTEX GENERATION
+
+===================================================================================
+*/
+
+/*
+** MakeSkyVec
+**
+** Parms: s, t range from -1 to 1
+*/
+static void MakeSkyVec( float s, float t, int axis, float outSt[2], vec3_t outXYZ )
+{
+	// 1 = s, 2 = t, 3 = 2048
+	static int	st_to_vec[6][3] =
+	{
+		{3,-1,2},
+		{-3,1,2},
+
+		{1,3,2},
+		{-1,-3,2},
+
+		{-2,-1,3},		// 0 degrees yaw, look straight up
+		{2,-1,-3}		// look straight down
+	};
+
+	vec3_t		b;
+	int			j, k;
+	float	boxSize;
+
+	boxSize = backEnd.viewParms.zFar / 1.75;		// div sqrt(3)
+	b[0] = s*boxSize;
+	b[1] = t*boxSize;
+	b[2] = boxSize;
+
+	for (j=0 ; j<3 ; j++)
+	{
+		k = st_to_vec[axis][j];
+		if (k < 0)
+		{
+			outXYZ[j] = -b[-k - 1];
+		}
+		else
+		{
+			outXYZ[j] = b[k - 1];
+		}
+	}
+
+	// avoid bilerp seam
+	s = (s+1)*0.5;
+	t = (t+1)*0.5;
+	if (s < sky_min)
+	{
+		s = sky_min;
+	}
+	else if (s > sky_max)
+	{
+		s = sky_max;
+	}
+
+	if (t < sky_min)
+	{
+		t = sky_min;
+	}
+	else if (t > sky_max)
+	{
+		t = sky_max;
+	}
+
+	t = 1.0 - t;
+
+
+	if ( outSt )
+	{
+		outSt[0] = s;
+		outSt[1] = t;
+	}
+}
+
+static vec3_t	s_skyPoints[SKY_SUBDIVISIONS+1][SKY_SUBDIVISIONS+1];
+static float	s_skyTexCoords[SKY_SUBDIVISIONS+1][SKY_SUBDIVISIONS+1][2];
+
+static void DrawSkySide( struct image_s *image, const int mins[2], const int maxs[2] )
+{
+	int s, t;
+
+	GL_Bind( image );
+
+#ifdef _XBOX
+	int verts = ((maxs[0]+HALF_SKY_SUBDIVISIONS) - (mins[0]+HALF_SKY_SUBDIVISIONS)) * 2 + 2;
+#endif
+
+	for ( t = mins[1]+HALF_SKY_SUBDIVISIONS; t < maxs[1]+HALF_SKY_SUBDIVISIONS; t++ )
+	{
+#ifdef _XBOX
+		qglBeginEXT( GL_TRIANGLE_STRIP, verts, 0, 0, verts, 0);
+#else
+		qglBegin( GL_TRIANGLE_STRIP );
+#endif
+
+		for ( s = mins[0]+HALF_SKY_SUBDIVISIONS; s <= maxs[0]+HALF_SKY_SUBDIVISIONS; s++ )
+		{
+			qglTexCoord2fv( s_skyTexCoords[t][s] );
+			qglVertex3fv( s_skyPoints[t][s] );
+
+			qglTexCoord2fv( s_skyTexCoords[t+1][s] );
+			qglVertex3fv( s_skyPoints[t+1][s] );
+		}
+
+		qglEnd();
+	}
+}
+
+static void DrawSkyBox( shader_t *shader )
+{
+	int		i;
+
+	sky_min = 0;
+	sky_max = 1;
+
+	Com_Memset( s_skyTexCoords, 0, sizeof( s_skyTexCoords ) );
+
+	for (i=0 ; i<6 ; i++)
+	{
+		int sky_mins_subd[2], sky_maxs_subd[2];
+		int s, t;
+
+		sky_mins[0][i] = floor( sky_mins[0][i] * HALF_SKY_SUBDIVISIONS ) / HALF_SKY_SUBDIVISIONS;
+		sky_mins[1][i] = floor( sky_mins[1][i] * HALF_SKY_SUBDIVISIONS ) / HALF_SKY_SUBDIVISIONS;
+		sky_maxs[0][i] = ceil( sky_maxs[0][i] * HALF_SKY_SUBDIVISIONS ) / HALF_SKY_SUBDIVISIONS;
+		sky_maxs[1][i] = ceil( sky_maxs[1][i] * HALF_SKY_SUBDIVISIONS ) / HALF_SKY_SUBDIVISIONS;
+
+		if ( ( sky_mins[0][i] >= sky_maxs[0][i] ) ||
+			 ( sky_mins[1][i] >= sky_maxs[1][i] ) )
+		{
+			continue;
+		}
+
+		sky_mins_subd[0] = sky_mins[0][i] * HALF_SKY_SUBDIVISIONS;
+		sky_mins_subd[1] = sky_mins[1][i] * HALF_SKY_SUBDIVISIONS;
+		sky_maxs_subd[0] = sky_maxs[0][i] * HALF_SKY_SUBDIVISIONS;
+		sky_maxs_subd[1] = sky_maxs[1][i] * HALF_SKY_SUBDIVISIONS;
+
+		if ( sky_mins_subd[0] < -HALF_SKY_SUBDIVISIONS ) 
+			sky_mins_subd[0] = -HALF_SKY_SUBDIVISIONS;
+		else if ( sky_mins_subd[0] > HALF_SKY_SUBDIVISIONS ) 
+			sky_mins_subd[0] = HALF_SKY_SUBDIVISIONS;
+		if ( sky_mins_subd[1] < -HALF_SKY_SUBDIVISIONS )
+			sky_mins_subd[1] = -HALF_SKY_SUBDIVISIONS;
+		else if ( sky_mins_subd[1] > HALF_SKY_SUBDIVISIONS ) 
+			sky_mins_subd[1] = HALF_SKY_SUBDIVISIONS;
+
+		if ( sky_maxs_subd[0] < -HALF_SKY_SUBDIVISIONS ) 
+			sky_maxs_subd[0] = -HALF_SKY_SUBDIVISIONS;
+		else if ( sky_maxs_subd[0] > HALF_SKY_SUBDIVISIONS ) 
+			sky_maxs_subd[0] = HALF_SKY_SUBDIVISIONS;
+		if ( sky_maxs_subd[1] < -HALF_SKY_SUBDIVISIONS ) 
+			sky_maxs_subd[1] = -HALF_SKY_SUBDIVISIONS;
+		else if ( sky_maxs_subd[1] > HALF_SKY_SUBDIVISIONS ) 
+			sky_maxs_subd[1] = HALF_SKY_SUBDIVISIONS;
+
+		//
+		// iterate through the subdivisions
+		//
+		for ( t = sky_mins_subd[1]+HALF_SKY_SUBDIVISIONS; t <= sky_maxs_subd[1]+HALF_SKY_SUBDIVISIONS; t++ )
+		{
+			for ( s = sky_mins_subd[0]+HALF_SKY_SUBDIVISIONS; s <= sky_maxs_subd[0]+HALF_SKY_SUBDIVISIONS; s++ )
+			{
+				MakeSkyVec( ( s - HALF_SKY_SUBDIVISIONS ) / ( float ) HALF_SKY_SUBDIVISIONS, 
+							( t - HALF_SKY_SUBDIVISIONS ) / ( float ) HALF_SKY_SUBDIVISIONS, 
+							i, 
+							s_skyTexCoords[t][s], 
+							s_skyPoints[t][s] );
+			}
+		}
+
+		DrawSkySide( shader->sky->outerbox[i],
+			         sky_mins_subd,
+					 sky_maxs_subd );
+	}
+
+}
+
+static void FillCloudySkySide( const int mins[2], const int maxs[2], qboolean addIndexes )
+{
+	int s, t;
+	int vertexStart = tess.numVertexes;
+	int tHeight, sWidth;
+
+	tHeight = maxs[1] - mins[1] + 1;
+	sWidth = maxs[0] - mins[0] + 1;
+
+	for ( t = mins[1]+HALF_SKY_SUBDIVISIONS; t <= maxs[1]+HALF_SKY_SUBDIVISIONS; t++ )
+	{
+		for ( s = mins[0]+HALF_SKY_SUBDIVISIONS; s <= maxs[0]+HALF_SKY_SUBDIVISIONS; s++ )
+		{
+			VectorAdd( s_skyPoints[t][s], backEnd.viewParms.ori.origin, tess.xyz[tess.numVertexes] );
+			tess.texCoords[tess.numVertexes][0][0] = s_skyTexCoords[t][s][0];
+			tess.texCoords[tess.numVertexes][0][1] = s_skyTexCoords[t][s][1];
+
+			tess.numVertexes++;
+
+			if ( tess.numVertexes >= SHADER_MAX_VERTEXES )
+			{
+				Com_Error( ERR_DROP, "SHADER_MAX_VERTEXES hit in FillCloudySkySide()\n" );
+			}
+		}
+	}
+
+	// only add indexes for one pass, otherwise it would draw multiple times for each pass
+	if ( addIndexes ) {
+		for ( t = 0; t < tHeight-1; t++ )
+		{	
+			for ( s = 0; s < sWidth-1; s++ )
+			{
+				tess.indexes[tess.numIndexes] = vertexStart + s + t * ( sWidth );
+				tess.numIndexes++;
+				tess.indexes[tess.numIndexes] = vertexStart + s + ( t + 1 ) * ( sWidth );
+				tess.numIndexes++;
+				tess.indexes[tess.numIndexes] = vertexStart + s + 1 + t * ( sWidth );
+				tess.numIndexes++;
+
+				tess.indexes[tess.numIndexes] = vertexStart + s + ( t + 1 ) * ( sWidth );
+				tess.numIndexes++;
+				tess.indexes[tess.numIndexes] = vertexStart + s + 1 + ( t + 1 ) * ( sWidth );
+				tess.numIndexes++;
+				tess.indexes[tess.numIndexes] = vertexStart + s + 1 + t * ( sWidth );
+				tess.numIndexes++;
+			}
+		}
+	}
+}
+
+static void FillCloudBox( const shader_t *shader, int stage )
+{
+	int i;
+
+	for ( i =0; i < 6; i++ )
+	{
+		int sky_mins_subd[2], sky_maxs_subd[2];
+		int s, t;
+		float MIN_T;
+
+		if ( 1 ) // FIXME? shader->sky->fullClouds )
+		{
+			MIN_T = -HALF_SKY_SUBDIVISIONS;
+
+			// still don't want to draw the bottom, even if fullClouds
+			if ( i == 5 )
+				continue;
+		}
+		else
+		{
+			switch( i )
+			{
+			case 0:
+			case 1:
+			case 2:
+			case 3:
+				MIN_T = -1;
+				break;
+			case 5:
+				// don't draw clouds beneath you
+				continue;
+			case 4:		// top
+			default:
+				MIN_T = -HALF_SKY_SUBDIVISIONS;
+				break;
+			}
+		}
+
+		sky_mins[0][i] = floor( sky_mins[0][i] * HALF_SKY_SUBDIVISIONS ) / HALF_SKY_SUBDIVISIONS;
+		sky_mins[1][i] = floor( sky_mins[1][i] * HALF_SKY_SUBDIVISIONS ) / HALF_SKY_SUBDIVISIONS;
+		sky_maxs[0][i] = ceil( sky_maxs[0][i] * HALF_SKY_SUBDIVISIONS ) / HALF_SKY_SUBDIVISIONS;
+		sky_maxs[1][i] = ceil( sky_maxs[1][i] * HALF_SKY_SUBDIVISIONS ) / HALF_SKY_SUBDIVISIONS;
+
+		if ( ( sky_mins[0][i] >= sky_maxs[0][i] ) ||
+			 ( sky_mins[1][i] >= sky_maxs[1][i] ) )
+		{
+			continue;
+		}
+
+		sky_mins_subd[0] = myftol( sky_mins[0][i] * HALF_SKY_SUBDIVISIONS );
+		sky_mins_subd[1] = myftol( sky_mins[1][i] * HALF_SKY_SUBDIVISIONS );
+		sky_maxs_subd[0] = myftol( sky_maxs[0][i] * HALF_SKY_SUBDIVISIONS );
+		sky_maxs_subd[1] = myftol( sky_maxs[1][i] * HALF_SKY_SUBDIVISIONS );
+
+		if ( sky_mins_subd[0] < -HALF_SKY_SUBDIVISIONS ) 
+			sky_mins_subd[0] = -HALF_SKY_SUBDIVISIONS;
+		else if ( sky_mins_subd[0] > HALF_SKY_SUBDIVISIONS ) 
+			sky_mins_subd[0] = HALF_SKY_SUBDIVISIONS;
+		if ( sky_mins_subd[1] < MIN_T )
+			sky_mins_subd[1] = MIN_T;
+		else if ( sky_mins_subd[1] > HALF_SKY_SUBDIVISIONS ) 
+			sky_mins_subd[1] = HALF_SKY_SUBDIVISIONS;
+
+		if ( sky_maxs_subd[0] < -HALF_SKY_SUBDIVISIONS ) 
+			sky_maxs_subd[0] = -HALF_SKY_SUBDIVISIONS;
+		else if ( sky_maxs_subd[0] > HALF_SKY_SUBDIVISIONS ) 
+			sky_maxs_subd[0] = HALF_SKY_SUBDIVISIONS;
+		if ( sky_maxs_subd[1] < MIN_T )
+			sky_maxs_subd[1] = MIN_T;
+		else if ( sky_maxs_subd[1] > HALF_SKY_SUBDIVISIONS ) 
+			sky_maxs_subd[1] = HALF_SKY_SUBDIVISIONS;
+
+		//
+		// iterate through the subdivisions
+		//
+		for ( t = sky_mins_subd[1]+HALF_SKY_SUBDIVISIONS; t <= sky_maxs_subd[1]+HALF_SKY_SUBDIVISIONS; t++ )
+		{
+			for ( s = sky_mins_subd[0]+HALF_SKY_SUBDIVISIONS; s <= sky_maxs_subd[0]+HALF_SKY_SUBDIVISIONS; s++ )
+			{
+				MakeSkyVec( ( s - HALF_SKY_SUBDIVISIONS ) / ( float ) HALF_SKY_SUBDIVISIONS, 
+							( t - HALF_SKY_SUBDIVISIONS ) / ( float ) HALF_SKY_SUBDIVISIONS, 
+							i, 
+							NULL,
+							s_skyPoints[t][s] );
+
+				s_skyTexCoords[t][s][0] = s_cloudTexCoords[i][t][s][0];
+				s_skyTexCoords[t][s][1] = s_cloudTexCoords[i][t][s][1];
+			}
+		}
+
+		// only add indexes for first stage
+		FillCloudySkySide( sky_mins_subd, sky_maxs_subd, (qboolean)( stage == 0 ) );
+	}
+}
+
+/*
+** R_BuildCloudData
+*/
+void R_BuildCloudData( shaderCommands_t *input )
+{
+	int			i;
+	shader_t	*shader;
+
+	shader = input->shader;
+
+	assert( shader->sky );
+
+	sky_min = 1.0 / 256.0f;		// FIXME: not correct?
+	sky_max = 255.0 / 256.0f;
+
+	// set up for drawing
+	tess.numIndexes = 0;
+	tess.numVertexes = 0;
+
+	if ( input->shader->sky->cloudHeight )
+	{
+		for ( i = 0; i < input->shader->numUnfoggedPasses; i++ )
+		{
+			FillCloudBox( input->shader, i );
+		}
+	}
+}
+
+/*
+** R_InitSkyTexCoords
+** Called when a sky shader is parsed
+*/
+#define SQR( a ) ((a)*(a))
+void R_InitSkyTexCoords( float heightCloud )
+{
+	int i, s, t;
+	float radiusWorld = 4096;
+	float p;
+	float sRad, tRad;
+	vec3_t skyVec;
+	vec3_t v;
+
+	// init zfar so MakeSkyVec works even though
+	// a world hasn't been bounded
+	backEnd.viewParms.zFar = 1024;
+
+	for ( i = 0; i < 6; i++ )
+	{
+		for ( t = 0; t <= SKY_SUBDIVISIONS; t++ )
+		{
+			for ( s = 0; s <= SKY_SUBDIVISIONS; s++ )
+			{
+				// compute vector from view origin to sky side integral point
+				MakeSkyVec( ( s - HALF_SKY_SUBDIVISIONS ) / ( float ) HALF_SKY_SUBDIVISIONS, 
+							( t - HALF_SKY_SUBDIVISIONS ) / ( float ) HALF_SKY_SUBDIVISIONS, 
+							i, 
+							NULL,
+							skyVec );
+
+				// compute parametric value 'p' that intersects with cloud layer
+				p = ( 1.0f / ( 2 * DotProduct( skyVec, skyVec ) ) ) *
+					( -2 * skyVec[2] * radiusWorld + 
+					   2 * sqrt( SQR( skyVec[2] ) * SQR( radiusWorld ) + 
+					             2 * SQR( skyVec[0] ) * radiusWorld * heightCloud +
+								 SQR( skyVec[0] ) * SQR( heightCloud ) + 
+								 2 * SQR( skyVec[1] ) * radiusWorld * heightCloud +
+								 SQR( skyVec[1] ) * SQR( heightCloud ) + 
+								 2 * SQR( skyVec[2] ) * radiusWorld * heightCloud +
+								 SQR( skyVec[2] ) * SQR( heightCloud ) ) );
+
+				s_cloudTexP[i][t][s] = p;
+
+				// compute intersection point based on p
+				VectorScale( skyVec, p, v );
+				v[2] += radiusWorld;
+
+				// compute vector from world origin to intersection point 'v'
+				VectorNormalize( v );
+
+				sRad = Q_acos( v[0] );
+				tRad = Q_acos( v[1] );
+
+				s_cloudTexCoords[i][t][s][0] = sRad;
+				s_cloudTexCoords[i][t][s][1] = tRad;
+			}
+		}
+	}
+}
+
+//======================================================================================
+
+/*
+** RB_DrawSun
+*/
+void RB_DrawSun( void ) {
+	float		size;
+	float		dist;
+	vec3_t		origin, vec1, vec2;
+	vec3_t		temp;
+
+	if ( !backEnd.skyRenderedThisView ) {
+		return;
+	}
+	if ( !r_drawSun->integer ) {
+		return;
+	}
+	qglLoadMatrixf( backEnd.viewParms.world.modelMatrix );
+	qglTranslatef (backEnd.viewParms.ori.origin[0], backEnd.viewParms.ori.origin[1], backEnd.viewParms.ori.origin[2]);
+
+	dist = 	backEnd.viewParms.zFar / 1.75;		// div sqrt(3)
+	size = dist * 0.4;
+
+	VectorScale( tr.sunDirection, dist, origin );
+	PerpendicularVector( vec1, tr.sunDirection );
+	CrossProduct( tr.sunDirection, vec1, vec2 );
+
+	VectorScale( vec1, size, vec1 );
+	VectorScale( vec2, size, vec2 );
+
+	// farthest depth range
+	qglDepthRange( 1.0, 1.0 );
+
+	// FIXME: use quad stamp
+	RB_BeginSurface( tr.sunShader, tess.fogNum );
+		VectorCopy( origin, temp );
+		VectorSubtract( temp, vec1, temp );
+		VectorSubtract( temp, vec2, temp );
+		VectorCopy( temp, tess.xyz[tess.numVertexes] );
+		tess.texCoords[tess.numVertexes][0][0] = 0;
+		tess.texCoords[tess.numVertexes][0][1] = 0;
+		tess.vertexColors[tess.numVertexes][0] = 255;
+		tess.vertexColors[tess.numVertexes][1] = 255;
+		tess.vertexColors[tess.numVertexes][2] = 255;
+		tess.numVertexes++;
+
+		VectorCopy( origin, temp );
+		VectorAdd( temp, vec1, temp );
+		VectorSubtract( temp, vec2, temp );
+		VectorCopy( temp, tess.xyz[tess.numVertexes] );
+		tess.texCoords[tess.numVertexes][0][0] = 0;
+		tess.texCoords[tess.numVertexes][0][1] = 1;
+		tess.vertexColors[tess.numVertexes][0] = 255;
+		tess.vertexColors[tess.numVertexes][1] = 255;
+		tess.vertexColors[tess.numVertexes][2] = 255;
+		tess.numVertexes++;
+
+		VectorCopy( origin, temp );
+		VectorAdd( temp, vec1, temp );
+		VectorAdd( temp, vec2, temp );
+		VectorCopy( temp, tess.xyz[tess.numVertexes] );
+		tess.texCoords[tess.numVertexes][0][0] = 1;
+		tess.texCoords[tess.numVertexes][0][1] = 1;
+		tess.vertexColors[tess.numVertexes][0] = 255;
+		tess.vertexColors[tess.numVertexes][1] = 255;
+		tess.vertexColors[tess.numVertexes][2] = 255;
+		tess.numVertexes++;
+
+		VectorCopy( origin, temp );
+		VectorSubtract( temp, vec1, temp );
+		VectorAdd( temp, vec2, temp );
+		VectorCopy( temp, tess.xyz[tess.numVertexes] );
+		tess.texCoords[tess.numVertexes][0][0] = 1;
+		tess.texCoords[tess.numVertexes][0][1] = 0;
+		tess.vertexColors[tess.numVertexes][0] = 255;
+		tess.vertexColors[tess.numVertexes][1] = 255;
+		tess.vertexColors[tess.numVertexes][2] = 255;
+		tess.numVertexes++;
+
+		tess.indexes[tess.numIndexes++] = 0;
+		tess.indexes[tess.numIndexes++] = 1;
+		tess.indexes[tess.numIndexes++] = 2;
+		tess.indexes[tess.numIndexes++] = 0;
+		tess.indexes[tess.numIndexes++] = 2;
+		tess.indexes[tess.numIndexes++] = 3;
+
+	RB_EndSurface();
+
+	// back to normal depth range
+	qglDepthRange( 0.0, 1.0 );
+}
+
+
+
+
+/*
+================
+RB_StageIteratorSky
+
+All of the visible sky triangles are in tess
+
+Other things could be stuck in here, like birds in the sky, etc
+================
+*/
+void RB_StageIteratorSky( void )
+{
+	if ( g_bRenderGlowingObjects )
+		return;
+
+	if ( r_fastsky->integer ) {
+		return;
+	}
+
+	if (skyboxportal && !(backEnd.refdef.rdflags & RDF_SKYBOXPORTAL))
+	{
+		return;
+	}
+
+	// go through all the polygons and project them onto
+	// the sky box to see which blocks on each side need
+	// to be drawn
+	RB_ClipSkyPolygons( &tess );
+
+	// r_showsky will let all the sky blocks be drawn in
+	// front of everything to allow developers to see how
+	// much sky is getting sucked in
+	if ( r_showsky->integer ) {
+		qglDepthRange( 0.0, 0.0 );
+	} else {
+#ifdef _XBOX
+		qglDepthRange( 0.99, 1.0 );
+#else
+		qglDepthRange( 1.0, 1.0 );
+#endif
+	}
+
+	// draw the outer skybox
+	if ( tess.shader->sky->outerbox[0] && tess.shader->sky->outerbox[0] != tr.defaultImage ) {
+		qglColor3f( tr.identityLight, tr.identityLight, tr.identityLight );
+		
+		qglPushMatrix ();
+		GL_State( 0 );
+		qglTranslatef (backEnd.viewParms.ori.origin[0], backEnd.viewParms.ori.origin[1], backEnd.viewParms.ori.origin[2]);
+
+		DrawSkyBox( tess.shader );
+
+		qglPopMatrix();
+	}
+
+	// generate the vertexes for all the clouds, which will be drawn
+	// by the generic shader routine
+	R_BuildCloudData( &tess );
+
+	if (tess.numIndexes && tess.numVertexes)
+	{
+		RB_StageIteratorGeneric();
+	}
+
+	// draw the inner skybox
+
+
+	// back to normal depth range
+	qglDepthRange( 0.0, 1.0 );
+
+	// note that sky was drawn so we will draw a sun later
+	backEnd.skyRenderedThisView = qtrue;
+}
+
diff --git a/codemp/renderer/tr_surface.cpp b/codemp/renderer/tr_surface.cpp
new file mode 100644
index 0000000..4ce36ef
--- /dev/null
+++ b/codemp/renderer/tr_surface.cpp
@@ -0,0 +1,2033 @@
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+// tr_surf.c
+#include "tr_local.h"
+
+/*
+
+  THIS ENTIRE FILE IS BACK END
+
+backEnd.currentEntity will be valid.
+
+Tess_Begin has already been called for the surface's shader.
+
+The modelview matrix will be set.
+
+It is safe to actually issue drawing commands here if you don't want to
+use the shader system.
+*/
+
+
+//============================================================================
+
+
+/*
+==============
+RB_CheckOverflow
+==============
+*/
+void RB_CheckOverflow( int verts, int indexes ) {
+	if ( tess.shader == tr.shadowShader ) {
+		if (tess.numVertexes + verts < SHADER_MAX_VERTEXES/2
+			&& tess.numIndexes + indexes < SHADER_MAX_INDEXES) {
+			return;
+		}
+	} else 
+		if (tess.numVertexes + verts < SHADER_MAX_VERTEXES
+			&& tess.numIndexes + indexes < SHADER_MAX_INDEXES) {
+			return;
+		}
+
+	RB_EndSurface();
+
+	if ( verts >= SHADER_MAX_VERTEXES ) {
+		Com_Error(ERR_DROP, "RB_CheckOverflow: verts > MAX (%d > %d)", verts, SHADER_MAX_VERTEXES );
+	}
+	if ( indexes >= SHADER_MAX_INDEXES ) {
+		Com_Error(ERR_DROP, "RB_CheckOverflow: indices > MAX (%d > %d)", indexes, SHADER_MAX_INDEXES );
+	}
+
+	RB_BeginSurface(tess.shader, tess.fogNum );
+}
+
+
+/*
+==============
+RB_AddQuadStampExt
+==============
+*/
+void RB_AddQuadStampExt( vec3_t origin, vec3_t left, vec3_t up, byte *color, float s1, float t1, float s2, float t2 ) {
+	vec3_t		normal;
+	int			ndx;
+
+	RB_CHECKOVERFLOW( 4, 6 );
+
+	ndx = tess.numVertexes;
+
+	// triangle indexes for a simple quad
+	tess.indexes[ tess.numIndexes ] = ndx;
+	tess.indexes[ tess.numIndexes + 1 ] = ndx + 1;
+	tess.indexes[ tess.numIndexes + 2 ] = ndx + 3;
+
+	tess.indexes[ tess.numIndexes + 3 ] = ndx + 3;
+	tess.indexes[ tess.numIndexes + 4 ] = ndx + 1;
+	tess.indexes[ tess.numIndexes + 5 ] = ndx + 2;
+
+	tess.xyz[ndx][0] = origin[0] + left[0] + up[0];
+	tess.xyz[ndx][1] = origin[1] + left[1] + up[1];
+	tess.xyz[ndx][2] = origin[2] + left[2] + up[2];
+
+	tess.xyz[ndx+1][0] = origin[0] - left[0] + up[0];
+	tess.xyz[ndx+1][1] = origin[1] - left[1] + up[1];
+	tess.xyz[ndx+1][2] = origin[2] - left[2] + up[2];
+
+	tess.xyz[ndx+2][0] = origin[0] - left[0] - up[0];
+	tess.xyz[ndx+2][1] = origin[1] - left[1] - up[1];
+	tess.xyz[ndx+2][2] = origin[2] - left[2] - up[2];
+
+	tess.xyz[ndx+3][0] = origin[0] + left[0] - up[0];
+	tess.xyz[ndx+3][1] = origin[1] + left[1] - up[1];
+	tess.xyz[ndx+3][2] = origin[2] + left[2] - up[2];
+
+
+	// constant normal all the way around
+	VectorSubtract( vec3_origin, backEnd.viewParms.ori.axis[0], normal );
+
+	tess.normal[ndx][0] = tess.normal[ndx+1][0] = tess.normal[ndx+2][0] = tess.normal[ndx+3][0] = normal[0];
+	tess.normal[ndx][1] = tess.normal[ndx+1][1] = tess.normal[ndx+2][1] = tess.normal[ndx+3][1] = normal[1];
+	tess.normal[ndx][2] = tess.normal[ndx+1][2] = tess.normal[ndx+2][2] = tess.normal[ndx+3][2] = normal[2];
+	
+	// standard square texture coordinates
+	tess.texCoords[ndx][0][0] = tess.texCoords[ndx][1][0] = s1;
+	tess.texCoords[ndx][0][1] = tess.texCoords[ndx][1][1] = t1;
+
+	tess.texCoords[ndx+1][0][0] = tess.texCoords[ndx+1][1][0] = s2;
+	tess.texCoords[ndx+1][0][1] = tess.texCoords[ndx+1][1][1] = t1;
+
+	tess.texCoords[ndx+2][0][0] = tess.texCoords[ndx+2][1][0] = s2;
+	tess.texCoords[ndx+2][0][1] = tess.texCoords[ndx+2][1][1] = t2;
+
+	tess.texCoords[ndx+3][0][0] = tess.texCoords[ndx+3][1][0] = s1;
+	tess.texCoords[ndx+3][0][1] = tess.texCoords[ndx+3][1][1] = t2;
+
+	// constant color all the way around
+	// should this be identity and let the shader specify from entity?
+	* ( unsigned int * ) &tess.vertexColors[ndx] = 
+	* ( unsigned int * ) &tess.vertexColors[ndx+1] = 
+	* ( unsigned int * ) &tess.vertexColors[ndx+2] = 
+	* ( unsigned int * ) &tess.vertexColors[ndx+3] = 
+		* ( unsigned int * )color;
+
+
+	tess.numVertexes += 4;
+	tess.numIndexes += 6;
+}
+
+/*
+==============
+RB_AddQuadStamp
+==============
+*/
+void RB_AddQuadStamp( vec3_t origin, vec3_t left, vec3_t up, byte *color ) {
+	RB_AddQuadStampExt( origin, left, up, color, 0, 0, 1, 1 );
+}
+
+/*
+==============
+RB_SurfaceSprite
+==============
+*/
+static void RB_SurfaceSprite( void ) {
+	vec3_t		left, up;
+	float		radius;
+
+	// calculate the xyz locations for the four corners
+	radius = backEnd.currentEntity->e.radius;
+	if ( backEnd.currentEntity->e.rotation == 0 ) {
+		VectorScale( backEnd.viewParms.ori.axis[1], radius, left );
+		VectorScale( backEnd.viewParms.ori.axis[2], radius, up );
+	} else {
+		float	s, c;
+		float	ang;
+		
+		ang = M_PI * backEnd.currentEntity->e.rotation / 180;
+		s = sin( ang );
+		c = cos( ang );
+
+		VectorScale( backEnd.viewParms.ori.axis[1], c * radius, left );
+		VectorMA( left, -s * radius, backEnd.viewParms.ori.axis[2], left );
+
+		VectorScale( backEnd.viewParms.ori.axis[2], c * radius, up );
+		VectorMA( up, s * radius, backEnd.viewParms.ori.axis[1], up );
+	}
+	if ( backEnd.viewParms.isMirror ) {
+		VectorSubtract( vec3_origin, left, left );
+	}
+
+	RB_AddQuadStamp( backEnd.currentEntity->e.origin, left, up, backEnd.currentEntity->e.shaderRGBA );
+}
+
+
+/*
+=======================
+RB_SurfaceOrientedQuad
+=======================
+*/
+static void RB_SurfaceOrientedQuad( void )
+{
+	vec3_t	left, up;
+	float	radius;
+
+	// calculate the xyz locations for the four corners
+	radius = backEnd.currentEntity->e.radius;
+//	MakeNormalVectors( backEnd.currentEntity->e.axis[0], left, up );
+	VectorCopy( backEnd.currentEntity->e.axis[1], left );
+	VectorCopy( backEnd.currentEntity->e.axis[2], up );
+
+	if ( backEnd.currentEntity->e.rotation == 0 ) 
+	{
+		VectorScale( left, radius, left );
+		VectorScale( up, radius, up );
+	} 
+	else 
+	{
+		vec3_t	tempLeft, tempUp;
+		float	s, c;
+		float	ang;
+		
+		ang = M_PI * backEnd.currentEntity->e.rotation / 180;
+		s = sin( ang );
+		c = cos( ang );
+
+		// Use a temp so we don't trash the values we'll need later
+		VectorScale( left, c * radius, tempLeft );
+		VectorMA( tempLeft, -s * radius, up, tempLeft );
+
+		VectorScale( up, c * radius, tempUp );
+		VectorMA( tempUp, s * radius, left, up ); // no need to use the temp anymore, so copy into the dest vector ( up )
+
+		// This was copied for safekeeping, we're done, so we can move it back to left
+		VectorCopy( tempLeft, left );
+	}
+
+	if ( backEnd.viewParms.isMirror ) 
+	{
+		VectorSubtract( vec3_origin, left, left );
+	}
+
+	RB_AddQuadStamp( backEnd.currentEntity->e.origin, left, up, backEnd.currentEntity->e.shaderRGBA );
+}
+
+/*
+=============
+RB_SurfacePolychain
+=============
+*/
+void RB_SurfacePolychain( srfPoly_t *p ) {
+	int		i;
+	int		numv;
+
+	RB_CHECKOVERFLOW( p->numVerts, 3*(p->numVerts - 2) );
+
+	// fan triangles into the tess array
+	numv = tess.numVertexes;
+	for ( i = 0; i < p->numVerts; i++ ) {
+		VectorCopy( p->verts[i].xyz, tess.xyz[numv] );
+		tess.texCoords[numv][0][0] = p->verts[i].st[0];
+		tess.texCoords[numv][0][1] = p->verts[i].st[1];
+		*(int *)&tess.vertexColors[numv] = *(int *)p->verts[ i ].modulate;
+
+		numv++;
+	}
+
+	// generate fan indexes into the tess array
+	for ( i = 0; i < p->numVerts-2; i++ ) {
+		tess.indexes[tess.numIndexes + 0] = tess.numVertexes;
+		tess.indexes[tess.numIndexes + 1] = tess.numVertexes + i + 1;
+		tess.indexes[tess.numIndexes + 2] = tess.numVertexes + i + 2;
+		tess.numIndexes += 3;
+	}
+
+	tess.numVertexes = numv;
+}
+
+inline static ulong ComputeFinalVertexColor(const byte *colors)
+{
+	int			k;
+	byte		result[4];
+	ulong		r, g, b;
+
+	*(int *)result = *(int *)colors;
+	if (tess.shader->lightmapIndex[0] != LIGHTMAP_BY_VERTEX )
+	{
+		return *(ulong *)result;
+	}
+	if (r_fullbright->integer)
+	{
+		result[0] = 255;
+		result[1] = 255;
+		result[2] = 255;
+		return *(ulong *)result;
+	}
+	// an optimization could be added here to compute the style[0] (which is always the world normal light)
+	r = g = b = 0;
+	for(k = 0; k < MAXLIGHTMAPS; k++)
+	{
+		if (tess.shader->styles[k] < LS_UNUSED)
+		{
+			byte	*styleColor = styleColors[tess.shader->styles[k]];
+
+			r += (ulong)(*colors++) * (ulong)(*styleColor++);
+			g += (ulong)(*colors++) * (ulong)(*styleColor++);
+			b += (ulong)(*colors++) * (ulong)(*styleColor);
+			colors++;
+		}
+		else
+		{
+			break;
+		}
+	}
+	result[0] = Com_Clamp(0, 255, r >> 8);
+	result[1] = Com_Clamp(0, 255, g >> 8);
+	result[2] = Com_Clamp(0, 255, b >> 8);
+
+	return *(ulong *)result;
+}
+
+#ifdef _XBOX
+//16 bits in, 32 bits out
+inline ulong ComputeFinalVertexColor16(const byte *colors)
+{
+	int			k;
+	byte		result[4];
+	byte		color32[4];
+	ulong		r, g, b;
+
+	result[0] = colors[0] & 0xF0;
+	result[1] = colors[0] << 4;
+	result[2] = colors[1] & 0xF0;
+	result[3] = colors[1] << 4;
+	if (tess.shader->lightmapIndex[0] != LIGHTMAP_BY_VERTEX || r_fullbright->integer )
+	{
+		result[0] = 255;
+		result[1] = 255;
+		result[2] = 255;
+		return *(ulong *)result;
+	}
+	// an optimization could be added here to compute the style[0] (which is always the world normal light)
+	r = g = b = 0;
+	for(k = 0; k < MAXLIGHTMAPS; k++)
+	{
+		if (tess.shader->styles[k] < LS_UNUSED)
+		{
+			byte	*styleColor = styleColors[tess.shader->styles[k]];
+
+			color32[0] = colors[k * 2] & 0xF0;
+			color32[1] = colors[k * 2] << 4;
+			color32[2] = colors[k * 2 + 1] & 0xF0;
+
+			r += (ulong)(color32[0]) * (ulong)(*styleColor++);
+			g += (ulong)(color32[1]) * (ulong)(*styleColor++);
+			b += (ulong)(color32[2]) * (ulong)(*styleColor);
+		}
+		else
+		{
+			break;
+		}
+	}
+	result[0] = Com_Clamp(0, 255, r >> 8);
+	result[1] = Com_Clamp(0, 255, g >> 8);
+	result[2] = Com_Clamp(0, 255, b >> 8);
+
+	return *(ulong *)result;
+}
+#endif
+
+
+/*
+=============
+RB_SurfaceTriangles
+=============
+*/
+void RB_SurfaceTriangles( srfTriangles_t *srf ) {
+	int			i, k;
+	drawVert_t	*dv;
+	float		*xyz, *normal, *texCoords;
+#ifdef _XBOX
+	float		*tangent;
+#endif
+	byte		*color;
+	int			dlightBits;
+
+	dlightBits = srf->dlightBits;
+	tess.dlightBits |= dlightBits;
+
+	RB_CHECKOVERFLOW( srf->numVerts, srf->numIndexes );
+
+	for ( i = 0 ; i < srf->numIndexes ; i += 3 ) {
+		tess.indexes[ tess.numIndexes + i + 0 ] = tess.numVertexes + srf->indexes[ i + 0 ];
+		tess.indexes[ tess.numIndexes + i + 1 ] = tess.numVertexes + srf->indexes[ i + 1 ];
+		tess.indexes[ tess.numIndexes + i + 2 ] = tess.numVertexes + srf->indexes[ i + 2 ];
+	}
+	tess.numIndexes += srf->numIndexes;
+
+	dv = srf->verts;
+	xyz = tess.xyz[ tess.numVertexes ];
+	normal = tess.normal[ tess.numVertexes ];
+	texCoords = tess.texCoords[ tess.numVertexes ][0];
+	color = tess.vertexColors[ tess.numVertexes ];
+#ifdef _XBOX
+	tangent = tess.tangent[ tess.numVertexes ];
+#endif
+
+	for ( i = 0 ; i < srf->numVerts ; i++, dv++) 
+	{
+#ifdef _XBOX
+		xyz[0] = dv->xyz[0];
+		xyz[1] = dv->xyz[1];
+		xyz[2] = dv->xyz[2];
+		xyz += 4;
+
+		if ( tess.shader->needsNormal || tess.dlightBits )
+		{
+			normal[0] = (float)dv->normal[0] / 32767.f;
+			normal[1] = (float)dv->normal[1] / 32767.f;
+			normal[2] = (float)dv->normal[2] / 32767.f;
+			normal += 4;
+		}
+
+		if( tess.shader->needsTangent || tess.dlightBits )
+		{
+            tangent[0] = dv->tangent[0];
+			tangent[1] = dv->tangent[1];
+			tangent[2] = dv->tangent[2];
+			tangent += 4;
+
+			tess.setTangents = true;
+		}
+
+		Q_CastShort2FloatScale(&texCoords[0], &dv->dvst[0], 1.f / DRAWVERT_ST_SCALE);
+		Q_CastShort2FloatScale(&texCoords[1], &dv->dvst[1], 1.f / DRAWVERT_ST_SCALE);
+
+		for(k=0;k<MAXLIGHTMAPS;k++)
+		{
+			if (tess.shader->lightmapIndex[k] >= 0)
+			{
+				Q_CastShort2FloatScale(&texCoords[2+(k*2)+0], 
+					&dv->dvlightmap[k][0], 1.f / DRAWVERT_LIGHTMAP_SCALE);
+				Q_CastShort2FloatScale(&texCoords[2+(k*2)+1], 
+					&dv->dvlightmap[k][1], 1.f / DRAWVERT_LIGHTMAP_SCALE);
+			}
+			else
+			{	// can't have an empty slot in the middle, so we are done
+				break;
+			}
+		}
+		texCoords += NUM_TEX_COORDS*2;
+
+		*(unsigned int*)color = ComputeFinalVertexColor16((byte *)dv->dvcolor);
+		color += 4;
+#else
+		xyz[0] = dv->xyz[0];
+		xyz[1] = dv->xyz[1];
+		xyz[2] = dv->xyz[2];
+		xyz += 4;
+
+		normal[0] = dv->normal[0];
+		normal[1] = dv->normal[1];
+		normal[2] = dv->normal[2];
+		normal += 4;
+
+		texCoords[0] = dv->st[0];
+		texCoords[1] = dv->st[1];
+
+		for(k=0;k<MAXLIGHTMAPS;k++)
+		{
+			if (tess.shader->lightmapIndex[k] >= 0)
+			{
+				texCoords[2+(k*2)] = dv->lightmap[k][0];
+				texCoords[2+(k*2)+1] = dv->lightmap[k][1];
+			}
+			else
+			{	// can't have an empty slot in the middle, so we are done
+				break;
+			}
+		}
+		texCoords += NUM_TEX_COORDS*2;
+
+		*(unsigned *)color = ComputeFinalVertexColor((byte *)dv->color);
+		color += 4;
+#endif // _XBOX
+	}
+
+	for ( i = 0 ; i < srf->numVerts ; i++ ) {
+		tess.vertexDlightBits[ tess.numVertexes + i] = dlightBits;
+	}
+
+	tess.numVertexes += srf->numVerts;
+}
+
+
+
+/*
+==============
+RB_SurfaceBeam
+==============
+*/
+static void RB_SurfaceBeam( void ) 
+{
+#define NUM_BEAM_SEGS 6
+	refEntity_t *e;
+	int	i;
+	vec3_t perpvec;
+	vec3_t direction, normalized_direction;
+	vec3_t	start_points[NUM_BEAM_SEGS], end_points[NUM_BEAM_SEGS];
+	vec3_t oldorigin, origin;
+
+	e = &backEnd.currentEntity->e;
+
+	oldorigin[0] = e->oldorigin[0];
+	oldorigin[1] = e->oldorigin[1];
+	oldorigin[2] = e->oldorigin[2];
+
+	origin[0] = e->origin[0];
+	origin[1] = e->origin[1];
+	origin[2] = e->origin[2];
+
+	normalized_direction[0] = direction[0] = oldorigin[0] - origin[0];
+	normalized_direction[1] = direction[1] = oldorigin[1] - origin[1];
+	normalized_direction[2] = direction[2] = oldorigin[2] - origin[2];
+
+	if ( VectorNormalize( normalized_direction ) == 0 )
+		return;
+
+	PerpendicularVector( perpvec, normalized_direction );
+
+	VectorScale( perpvec, 4, perpvec );
+
+	for ( i = 0; i < NUM_BEAM_SEGS ; i++ )
+	{
+		RotatePointAroundVector( start_points[i], normalized_direction, perpvec, (360.0/NUM_BEAM_SEGS)*i );
+//		VectorAdd( start_points[i], origin, start_points[i] );
+		VectorAdd( start_points[i], direction, end_points[i] );
+	}
+
+	GL_Bind( tr.whiteImage );
+
+	GL_State( GLS_SRCBLEND_ONE | GLS_DSTBLEND_ONE );
+
+	qglColor3f( 1, 0, 0 );
+
+	qglBegin( GL_TRIANGLE_STRIP );
+	for ( i = 0; i <= NUM_BEAM_SEGS; i++ ) {
+		qglVertex3fv( start_points[ i % NUM_BEAM_SEGS] );
+		qglVertex3fv( end_points[ i % NUM_BEAM_SEGS] );
+	}
+	qglEnd();
+}
+
+//------------------
+// DoSprite
+//------------------
+static void DoSprite( vec3_t origin, float radius, float rotation ) 
+{
+	float	s, c;
+	float	ang;
+	vec3_t	left, up;
+	
+	ang = M_PI * rotation / 180.0f;
+	s = sin( ang );
+	c = cos( ang );
+
+	VectorScale( backEnd.viewParms.ori.axis[1], c * radius, left );
+	VectorMA( left, -s * radius, backEnd.viewParms.ori.axis[2], left );
+
+	VectorScale( backEnd.viewParms.ori.axis[2], c * radius, up );
+	VectorMA( up, s * radius, backEnd.viewParms.ori.axis[1], up );
+
+	if ( backEnd.viewParms.isMirror ) 
+	{
+		VectorSubtract( vec3_origin, left, left );
+	}
+
+	RB_AddQuadStamp( origin, left, up, backEnd.currentEntity->e.shaderRGBA );
+}
+
+//------------------
+// RB_SurfaceSaber
+//------------------
+static void RB_SurfaceSaberGlow()
+{ 
+	vec3_t		end;
+	refEntity_t *e;
+
+	e = &backEnd.currentEntity->e;
+
+	// Render the glow part of the blade
+	for ( float i = e->saberLength; i > 0; i -= e->radius * 0.65f )
+	{
+		VectorMA( e->origin, i, e->axis[0], end );
+
+		DoSprite( end, e->radius, 0.0f );//random() * 360.0f );
+		e->radius += 0.017f;
+	}
+
+	// Big hilt sprite
+	// Please don't kill me Pat...I liked the hilt glow blob, but wanted a subtle pulse.:)  Feel free to ditch it if you don't like it.  --Jeff
+	// Please don't kill me Jeff...  The pulse is good, but now I want the halo bigger if the saber is shorter...  --Pat
+	DoSprite( e->origin, 5.5f + random() * 0.25f, 0.0f );//random() * 360.0f );
+}
+
+/*
+==============
+RB_SurfaceLine
+==============
+*/
+//
+//	Values for a proper line render primitive...
+//		Width
+//		STScale (how many times to loop a texture)
+//		alpha
+//		RGB
+//		
+//  Values for proper line object...
+//		lifetime
+//		dscale
+//		startalpha, endalpha
+//		startRGB, endRGB
+//		
+
+static void DoLine( const vec3_t start, const vec3_t end, const vec3_t up, float spanWidth )
+{
+	float		spanWidth2;
+	int			vbase;
+
+	RB_CHECKOVERFLOW( 4, 6 );
+
+	vbase = tess.numVertexes;
+
+	spanWidth2 = -spanWidth;
+
+	VectorMA( start, spanWidth, up, tess.xyz[tess.numVertexes] );
+	tess.texCoords[tess.numVertexes][0][0] = 0;
+	tess.texCoords[tess.numVertexes][0][1] = 0;
+	tess.vertexColors[tess.numVertexes][0] = backEnd.currentEntity->e.shaderRGBA[0];// * 0.25;//wtf??not sure why the code would be doing this
+	tess.vertexColors[tess.numVertexes][1] = backEnd.currentEntity->e.shaderRGBA[1];// * 0.25;
+	tess.vertexColors[tess.numVertexes][2] = backEnd.currentEntity->e.shaderRGBA[2];// * 0.25;
+	tess.vertexColors[tess.numVertexes][3] = backEnd.currentEntity->e.shaderRGBA[3];// * 0.25;
+	tess.numVertexes++;
+
+	VectorMA( start, spanWidth2, up, tess.xyz[tess.numVertexes] );
+	tess.texCoords[tess.numVertexes][0][0] = 1;//backEnd.currentEntity->e.shaderTexCoord[0];
+	tess.texCoords[tess.numVertexes][0][1] = 0;
+	tess.vertexColors[tess.numVertexes][0] = backEnd.currentEntity->e.shaderRGBA[0];
+	tess.vertexColors[tess.numVertexes][1] = backEnd.currentEntity->e.shaderRGBA[1];
+	tess.vertexColors[tess.numVertexes][2] = backEnd.currentEntity->e.shaderRGBA[2];
+	tess.vertexColors[tess.numVertexes][3] = backEnd.currentEntity->e.shaderRGBA[3];
+	tess.numVertexes++;
+
+	VectorMA( end, spanWidth, up, tess.xyz[tess.numVertexes] );
+
+	tess.texCoords[tess.numVertexes][0][0] = 0;
+	tess.texCoords[tess.numVertexes][0][1] = 1;//backEnd.currentEntity->e.shaderTexCoord[1];
+	tess.vertexColors[tess.numVertexes][0] = backEnd.currentEntity->e.shaderRGBA[0];
+	tess.vertexColors[tess.numVertexes][1] = backEnd.currentEntity->e.shaderRGBA[1];
+	tess.vertexColors[tess.numVertexes][2] = backEnd.currentEntity->e.shaderRGBA[2];
+	tess.vertexColors[tess.numVertexes][3] = backEnd.currentEntity->e.shaderRGBA[3];
+	tess.numVertexes++;
+
+	VectorMA( end, spanWidth2, up, tess.xyz[tess.numVertexes] );
+	tess.texCoords[tess.numVertexes][0][0] = 1;//backEnd.currentEntity->e.shaderTexCoord[0];
+	tess.texCoords[tess.numVertexes][0][1] = 1;//backEnd.currentEntity->e.shaderTexCoord[1];
+	tess.vertexColors[tess.numVertexes][0] = backEnd.currentEntity->e.shaderRGBA[0];
+	tess.vertexColors[tess.numVertexes][1] = backEnd.currentEntity->e.shaderRGBA[1];
+	tess.vertexColors[tess.numVertexes][2] = backEnd.currentEntity->e.shaderRGBA[2];
+	tess.vertexColors[tess.numVertexes][3] = backEnd.currentEntity->e.shaderRGBA[3];
+	tess.numVertexes++;
+
+	tess.indexes[tess.numIndexes++] = vbase;
+	tess.indexes[tess.numIndexes++] = vbase + 1;
+	tess.indexes[tess.numIndexes++] = vbase + 2;
+
+	tess.indexes[tess.numIndexes++] = vbase + 2;
+	tess.indexes[tess.numIndexes++] = vbase + 1;
+	tess.indexes[tess.numIndexes++] = vbase + 3;
+}
+
+static void DoLine2( const vec3_t start, const vec3_t end, const vec3_t up, float spanWidth, float spanWidth2 )
+{
+	int			vbase;
+
+	RB_CHECKOVERFLOW( 4, 6 );
+
+	vbase = tess.numVertexes;
+
+	VectorMA( start, spanWidth, up, tess.xyz[tess.numVertexes] );
+	tess.texCoords[tess.numVertexes][0][0] = 0;
+	tess.texCoords[tess.numVertexes][0][1] = 0;
+	tess.vertexColors[tess.numVertexes][0] = backEnd.currentEntity->e.shaderRGBA[0];// * 0.25;//wtf??not sure why the code would be doing this
+	tess.vertexColors[tess.numVertexes][1] = backEnd.currentEntity->e.shaderRGBA[1];// * 0.25;
+	tess.vertexColors[tess.numVertexes][2] = backEnd.currentEntity->e.shaderRGBA[2];// * 0.25;
+	tess.vertexColors[tess.numVertexes][3] = backEnd.currentEntity->e.shaderRGBA[3];// * 0.25;
+	tess.numVertexes++;
+
+	VectorMA( start, -spanWidth, up, tess.xyz[tess.numVertexes] );
+	tess.texCoords[tess.numVertexes][0][0] = 1;//backEnd.currentEntity->e.shaderTexCoord[0];
+	tess.texCoords[tess.numVertexes][0][1] = 0;
+	tess.vertexColors[tess.numVertexes][0] = backEnd.currentEntity->e.shaderRGBA[0];
+	tess.vertexColors[tess.numVertexes][1] = backEnd.currentEntity->e.shaderRGBA[1];
+	tess.vertexColors[tess.numVertexes][2] = backEnd.currentEntity->e.shaderRGBA[2];
+	tess.vertexColors[tess.numVertexes][3] = backEnd.currentEntity->e.shaderRGBA[3];
+	tess.numVertexes++;
+
+	VectorMA( end, spanWidth2, up, tess.xyz[tess.numVertexes] );
+
+	tess.texCoords[tess.numVertexes][0][0] = 0;
+	tess.texCoords[tess.numVertexes][0][1] = 1;//backEnd.currentEntity->e.shaderTexCoord[1];
+	tess.vertexColors[tess.numVertexes][0] = backEnd.currentEntity->e.shaderRGBA[0];
+	tess.vertexColors[tess.numVertexes][1] = backEnd.currentEntity->e.shaderRGBA[1];
+	tess.vertexColors[tess.numVertexes][2] = backEnd.currentEntity->e.shaderRGBA[2];
+	tess.vertexColors[tess.numVertexes][3] = backEnd.currentEntity->e.shaderRGBA[3];
+	tess.numVertexes++;
+
+	VectorMA( end, -spanWidth2, up, tess.xyz[tess.numVertexes] );
+	tess.texCoords[tess.numVertexes][0][0] = 1;//backEnd.currentEntity->e.shaderTexCoord[0];
+	tess.texCoords[tess.numVertexes][0][1] = 1;//backEnd.currentEntity->e.shaderTexCoord[1];
+	tess.vertexColors[tess.numVertexes][0] = backEnd.currentEntity->e.shaderRGBA[0];
+	tess.vertexColors[tess.numVertexes][1] = backEnd.currentEntity->e.shaderRGBA[1];
+	tess.vertexColors[tess.numVertexes][2] = backEnd.currentEntity->e.shaderRGBA[2];
+	tess.vertexColors[tess.numVertexes][3] = backEnd.currentEntity->e.shaderRGBA[3];
+	tess.numVertexes++;
+
+	tess.indexes[tess.numIndexes++] = vbase;
+	tess.indexes[tess.numIndexes++] = vbase + 1;
+	tess.indexes[tess.numIndexes++] = vbase + 2;
+
+	tess.indexes[tess.numIndexes++] = vbase + 2;
+	tess.indexes[tess.numIndexes++] = vbase + 1;
+	tess.indexes[tess.numIndexes++] = vbase + 3;
+}
+
+static void DoLine_Oriented( const vec3_t start, const vec3_t end, const vec3_t up, float spanWidth )
+{
+	float		spanWidth2;
+	int			vbase;
+
+	vbase = tess.numVertexes;
+
+	spanWidth2 = -spanWidth;
+
+	// FIXME: use quad stamp?
+	VectorMA( start, spanWidth, up, tess.xyz[tess.numVertexes] );
+	tess.texCoords[tess.numVertexes][0][0] = 0;
+	tess.texCoords[tess.numVertexes][0][1] = 0;
+	tess.vertexColors[tess.numVertexes][0] = backEnd.currentEntity->e.shaderRGBA[0];// * 0.25;
+	tess.vertexColors[tess.numVertexes][1] = backEnd.currentEntity->e.shaderRGBA[1];// * 0.25;
+	tess.vertexColors[tess.numVertexes][2] = backEnd.currentEntity->e.shaderRGBA[2];// * 0.25;
+	tess.vertexColors[tess.numVertexes][3] = backEnd.currentEntity->e.shaderRGBA[3];// * 0.25;
+	tess.numVertexes++;
+
+	VectorMA( start, spanWidth2, up, tess.xyz[tess.numVertexes] );
+	tess.texCoords[tess.numVertexes][0][0] = 1;
+	tess.texCoords[tess.numVertexes][0][1] = 0;
+	tess.vertexColors[tess.numVertexes][0] = backEnd.currentEntity->e.shaderRGBA[0];
+	tess.vertexColors[tess.numVertexes][1] = backEnd.currentEntity->e.shaderRGBA[1];
+	tess.vertexColors[tess.numVertexes][2] = backEnd.currentEntity->e.shaderRGBA[2];
+	tess.vertexColors[tess.numVertexes][3] = backEnd.currentEntity->e.shaderRGBA[3];// * 0.25;
+	tess.numVertexes++;
+
+	VectorMA( end, spanWidth, up, tess.xyz[tess.numVertexes] );
+
+	tess.texCoords[tess.numVertexes][0][0] = 0;
+	tess.texCoords[tess.numVertexes][0][1] = backEnd.currentEntity->e.data.line.stscale;
+	tess.vertexColors[tess.numVertexes][0] = backEnd.currentEntity->e.shaderRGBA[0];
+	tess.vertexColors[tess.numVertexes][1] = backEnd.currentEntity->e.shaderRGBA[1];
+	tess.vertexColors[tess.numVertexes][2] = backEnd.currentEntity->e.shaderRGBA[2];
+	tess.vertexColors[tess.numVertexes][3] = backEnd.currentEntity->e.shaderRGBA[3];// * 0.25;
+	tess.numVertexes++;
+
+	VectorMA( end, spanWidth2, up, tess.xyz[tess.numVertexes] );
+	tess.texCoords[tess.numVertexes][0][0] = 1;
+	tess.texCoords[tess.numVertexes][0][1] = backEnd.currentEntity->e.data.line.stscale;
+	tess.vertexColors[tess.numVertexes][0] = backEnd.currentEntity->e.shaderRGBA[0];
+	tess.vertexColors[tess.numVertexes][1] = backEnd.currentEntity->e.shaderRGBA[1];
+	tess.vertexColors[tess.numVertexes][2] = backEnd.currentEntity->e.shaderRGBA[2];
+	tess.vertexColors[tess.numVertexes][3] = backEnd.currentEntity->e.shaderRGBA[3];// * 0.25;
+	tess.numVertexes++;
+
+	tess.indexes[tess.numIndexes++] = vbase;
+	tess.indexes[tess.numIndexes++] = vbase + 1;
+	tess.indexes[tess.numIndexes++] = vbase + 2;
+
+	tess.indexes[tess.numIndexes++] = vbase + 2;
+	tess.indexes[tess.numIndexes++] = vbase + 1;
+	tess.indexes[tess.numIndexes++] = vbase + 3;
+}
+
+//-----------------
+// RB_SurfaceLine
+//-----------------
+static void RB_SurfaceLine( void ) 
+{
+	refEntity_t *e;
+	vec3_t		right;
+	vec3_t		start, end;
+	vec3_t		v1, v2;
+
+	e = &backEnd.currentEntity->e;
+
+	VectorCopy( e->oldorigin, end );
+	VectorCopy( e->origin, start );
+
+	// compute side vector
+	VectorSubtract( start, backEnd.viewParms.ori.origin, v1 );
+	VectorSubtract( end, backEnd.viewParms.ori.origin, v2 );
+	CrossProduct( v1, v2, right );
+	VectorNormalize( right );
+
+	DoLine( start, end, right, e->radius);
+}
+
+static void RB_SurfaceOrientedLine( void ) 
+{
+	refEntity_t *e;
+	vec3_t		right;
+	vec3_t		start, end;
+
+	e = &backEnd.currentEntity->e;
+
+	VectorCopy( e->oldorigin, end );
+	VectorCopy( e->origin, start );
+
+	// compute side vector
+	VectorNormalize( e->axis[1] );
+	VectorCopy(e->axis[1], right);
+	DoLine_Oriented( start, end, right, e->data.line.width*0.5 );
+}
+
+/*
+==============
+RB_SurfaceCylinder
+==============
+*/
+
+#define NUM_CYLINDER_SEGMENTS 32
+
+// FIXME: use quad stamp?
+static void DoCylinderPart(polyVert_t *verts)
+{
+	int			vbase;
+	int			i;
+
+	RB_CHECKOVERFLOW( 4, 6 );
+
+	vbase = tess.numVertexes;
+
+	for (i=0; i<4; i++)
+	{
+		VectorCopy( verts->xyz, tess.xyz[tess.numVertexes] );
+		tess.texCoords[tess.numVertexes][0][0] = verts->st[0];
+		tess.texCoords[tess.numVertexes][0][1] = verts->st[1];
+		tess.vertexColors[tess.numVertexes][0] = verts->modulate[0];
+		tess.vertexColors[tess.numVertexes][1] = verts->modulate[1];
+		tess.vertexColors[tess.numVertexes][2] = verts->modulate[2];
+		tess.vertexColors[tess.numVertexes][3] = verts->modulate[3];
+		tess.numVertexes++;
+		verts++;
+	}	
+
+	tess.indexes[tess.numIndexes++] = vbase;
+	tess.indexes[tess.numIndexes++] = vbase + 1;
+	tess.indexes[tess.numIndexes++] = vbase + 2;
+
+	tess.indexes[tess.numIndexes++] = vbase + 2;
+	tess.indexes[tess.numIndexes++] = vbase + 3;
+	tess.indexes[tess.numIndexes++] = vbase;
+}
+
+// e->origin holds the bottom point
+// e->oldorigin holds the top point
+// e->radius holds the radius
+
+static void RB_SurfaceCylinder( void )
+{
+	static polyVert_t	lower_points[NUM_CYLINDER_SEGMENTS], upper_points[NUM_CYLINDER_SEGMENTS], verts[4];
+	vec3_t		vr, vu, midpoint, v1;
+	float		detail, length;
+	int			i;
+	int			segments;
+	refEntity_t *e;
+	int			nextSegment;
+
+	e = &backEnd.currentEntity->e;
+
+	//Work out the detail level of this cylinder
+	VectorAdd( e->origin, e->oldorigin, midpoint );
+	VectorScale(midpoint, 0.5f, midpoint);		// Average start and end
+
+	VectorSubtract( midpoint, backEnd.viewParms.ori.origin, midpoint );
+	length = VectorNormalize( midpoint );
+
+	// this doesn't need to be perfect....just a rough compensation for zoom level is enough
+	length *= (backEnd.viewParms.fovX / 90.0f);
+
+	detail = 1 - ((float) length / 1024 );
+	segments = NUM_CYLINDER_SEGMENTS * detail;
+
+	// 3 is the absolute minimum, but the pop between 3-8 is too noticeable
+	if ( segments < 8 )
+	{
+		segments = 8;
+	}
+
+	if ( segments > NUM_CYLINDER_SEGMENTS )
+	{
+		segments = NUM_CYLINDER_SEGMENTS;
+	}
+
+	//Get the direction vector
+	MakeNormalVectors( e->axis[0], vr, vu );
+
+	VectorScale( vu, e->radius, v1 );	// size1
+	VectorScale( vu, e->rotation, vu );	// size2
+
+	// Calculate the step around the cylinder
+	detail = 360.0f / (float)segments;
+
+	for ( i = 0; i < segments; i++ )
+	{
+		//Upper ring
+		RotatePointAroundVector( upper_points[i].xyz, e->axis[0], vu, detail * i );
+		VectorAdd( upper_points[i].xyz, e->origin, upper_points[i].xyz );
+		
+		//Lower ring
+		RotatePointAroundVector( lower_points[i].xyz, e->axis[0], v1, detail * i );
+		VectorAdd( lower_points[i].xyz, e->oldorigin, lower_points[i].xyz );
+	}
+	
+	// Calculate the texture coords so the texture can wrap around the whole cylinder
+	detail = 1.0f / (float)segments;
+
+	for ( i = 0; i < segments; i++ )
+	{
+		if ( i + 1 < segments )
+			nextSegment = i + 1;
+		else
+			nextSegment = 0;
+
+ 		VectorCopy( upper_points[i].xyz, verts[0].xyz );
+		verts[0].st[1] = 1.0f;
+		verts[0].st[0] = detail * i;
+		verts[0].modulate[0] = (byte)(e->shaderRGBA[0]);
+		verts[0].modulate[1] = (byte)(e->shaderRGBA[1]);
+		verts[0].modulate[2] = (byte)(e->shaderRGBA[2]);
+		verts[0].modulate[3] = (byte)(e->shaderRGBA[3]);
+
+		VectorCopy( lower_points[i].xyz, verts[1].xyz );
+		verts[1].st[1] = 0.0f;
+		verts[1].st[0] = detail * i;
+		verts[1].modulate[0] = (byte)(e->shaderRGBA[0]);
+		verts[1].modulate[1] = (byte)(e->shaderRGBA[1]);
+		verts[1].modulate[2] = (byte)(e->shaderRGBA[2]);
+		verts[1].modulate[3] = (byte)(e->shaderRGBA[3]);
+
+		VectorCopy( lower_points[nextSegment].xyz, verts[2].xyz );
+		verts[2].st[1] = 0.0f;
+		verts[2].st[0] = detail * ( i + 1 );
+		verts[2].modulate[0] = (byte)(e->shaderRGBA[0]);
+		verts[2].modulate[1] = (byte)(e->shaderRGBA[1]);
+		verts[2].modulate[2] = (byte)(e->shaderRGBA[2]);
+		verts[2].modulate[3] = (byte)(e->shaderRGBA[3]);
+
+		VectorCopy( upper_points[nextSegment].xyz, verts[3].xyz );
+		verts[3].st[1] = 1.0f;
+		verts[3].st[0] = detail * ( i + 1 );
+		verts[3].modulate[0] = (byte)(e->shaderRGBA[0]);
+		verts[3].modulate[1] = (byte)(e->shaderRGBA[1]);
+		verts[3].modulate[2] = (byte)(e->shaderRGBA[2]);
+		verts[3].modulate[3] = (byte)(e->shaderRGBA[3]);
+
+		DoCylinderPart(verts);
+	}
+}
+
+static vec3_t sh1, sh2;
+static float f_count;
+
+#define LIGHTNING_RECURSION_LEVEL 1 // was 2
+
+// these functions are pretty crappy in terms of returning a nice range of rnd numbers, but it's probably good enough?
+/*static int Q_rand( int *seed ) {
+	*seed = (69069 * *seed + 1);
+	return *seed;
+}
+
+static float Q_random( int *seed ) {
+	return ( Q_rand( seed ) & 0xffff ) / (float)0x10000;
+}
+
+static float Q_crandom( int *seed ) {
+	return 2.0F * ( Q_random( seed ) - 0.5f );
+}
+*/
+// Up front, we create a random "shape", then apply that to each line segment...and then again to each of those segments...kind of like a fractal
+//----------------------------------------------------------------------------
+static void CreateShape()
+//----------------------------------------------------------------------------
+{
+	VectorSet( sh1, 0.66f + crandom() * 0.1f,	// fwd
+				0.07f + crandom() * 0.025f,
+				0.07f + crandom() * 0.025f );
+
+	// it seems to look best to have a point on one side of the ideal line, then the other point on the other side.
+	VectorSet( sh2, 0.33f + crandom() * 0.1f,	// fwd
+					-sh1[1] + crandom() * 0.02f,	// forcing point to be on the opposite side of the line -- right
+					-sh1[2] + crandom() * 0.02f );// up
+}
+
+//----------------------------------------------------------------------------
+static void ApplyShape( vec3_t start, vec3_t end, vec3_t right, float sradius, float eradius, int count )
+//----------------------------------------------------------------------------
+{
+	vec3_t	point1, point2, fwd;
+	vec3_t	rt, up;
+	float	perc, dis;
+
+    if ( count < 1 )
+	{
+		// done recursing
+		DoLine2( start, end, right, sradius, eradius );
+		return;
+	}
+    
+    CreateShape();
+
+	VectorSubtract( end, start, fwd );
+	dis = VectorNormalize( fwd ) * 0.7f;
+	MakeNormalVectors( fwd, rt, up );
+
+	perc = sh1[0];
+
+	VectorScale( start, perc, point1 );
+	VectorMA( point1, 1.0f - perc, end, point1 );
+	VectorMA( point1, dis * sh1[1], rt, point1 );
+	VectorMA( point1, dis * sh1[2], up, point1 );
+
+	// do a quick and dirty interpolation of the radius at that point
+	float rads1, rads2;
+
+	rads1 = sradius * 0.666f + eradius * 0.333f;
+	rads2 = sradius * 0.333f + eradius * 0.666f;
+
+	// recursion
+    ApplyShape( start, point1, right, sradius, rads1, count - 1 );
+
+	perc = sh2[0];
+
+	VectorScale( start, perc, point2 );
+	VectorMA( point2, 1.0f - perc, end, point2 );
+	VectorMA( point2, dis * sh2[1], rt, point2 );
+	VectorMA( point2, dis * sh2[2], up, point2 );
+    
+	// recursion
+    ApplyShape( point2, point1, right, rads1, rads2, count - 1 );
+	ApplyShape( point2, end, right, rads2, eradius, count - 1 );
+}
+
+//----------------------------------------------------------------------------
+static void DoBoltSeg( vec3_t start, vec3_t end, vec3_t right, float radius )
+//----------------------------------------------------------------------------
+{
+	refEntity_t *e;
+	vec3_t fwd, old;
+	vec3_t cur, off={10,10,10};
+	vec3_t rt, up;
+	vec3_t temp;
+	int		i;
+    float dis, oldPerc = 0.0f, perc, oldRadius, newRadius;
+
+	e = &backEnd.currentEntity->e;
+
+	VectorSubtract( end, start, fwd );
+	dis = VectorNormalize( fwd );
+
+	MakeNormalVectors( fwd, rt, up );
+
+	VectorCopy( start, old );
+    
+	oldRadius = newRadius = radius;
+
+    for ( i = 20; i <= dis; i+= 20 )
+	{
+		// because of our large step size, we may not actually draw to the end.  In this case, fudge our percent so that we are basically complete
+		if ( i + 20 > dis )
+		{
+			perc = 1.0f;
+		}
+		else
+		{
+			// percentage of the amount of line completed
+			perc = (float)i / dis;
+		}
+
+		// create our level of deviation for this point
+		VectorScale( fwd, Q_crandom(&e->frame) * 3.0f, temp );				// move less in fwd direction, chaos also does not affect this
+		VectorMA( temp, Q_crandom(&e->frame) * 7.0f * e->axis[0][0], rt, temp );	// move more in direction perpendicular to line, angles is really the chaos
+		VectorMA( temp, Q_crandom(&e->frame) * 7.0f * e->axis[0][0], up, temp );	// move more in direction perpendicular to line
+
+		// track our total level of offset from the ideal line
+		VectorAdd( off, temp, off );
+
+        // Move from start to end, always adding our current level of offset from the ideal line
+		//	Even though we are adding a random offset.....by nature, we always move from exactly start....to end
+		VectorAdd( start, off, cur );
+		VectorScale( cur, 1.0f - perc, cur );
+		VectorMA( cur, perc, end, cur );
+
+		if ( e->renderfx & RF_TAPERED )
+		{
+			// This does pretty close to perfect tapering since apply shape interpolates the old and new as it goes along.
+			//	by using one minus the square, the radius stays fairly constant, then drops off quickly at the very point of the bolt
+			oldRadius = radius * (1.0f-oldPerc*oldPerc);
+			newRadius = radius * (1.0f-perc*perc);
+		}
+
+		// Apply the random shape to our line seg to give it some micro-detail-jaggy-coolness.
+        ApplyShape( cur, old, right, newRadius, oldRadius, LIGHTNING_RECURSION_LEVEL );
+  
+		// randomly split off to create little tendrils, but don't do it too close to the end and especially if we are not even of the forked variety
+        if ( ( e->renderfx & RF_FORKED ) && f_count > 0 && Q_random(&e->frame) > 0.94f && radius * (1.0f - perc) > 0.2f )
+		{
+			vec3_t newDest;
+
+			f_count--;
+
+			// Pick a point somewhere between the current point and the final endpoint
+			VectorAdd( cur, e->oldorigin, newDest );
+			VectorScale( newDest, 0.5f, newDest );
+
+			// And then add some crazy offset
+			for ( int t = 0; t < 3; t++ )
+			{
+				newDest[t] += Q_crandom(&e->frame) * 80;
+			}
+
+			// we could branch off using OLD and NEWDEST, but that would allow multiple forks...whereas, we just want simpler brancing
+            DoBoltSeg( cur, newDest, right, newRadius );
+		}
+
+		// Current point along the line becomes our new old attach point
+		VectorCopy( cur, old );
+		oldPerc = perc;
+	}
+}
+
+//------------------------------------------
+static void RB_SurfaceElectricity()
+//------------------------------------------
+{
+	refEntity_t *e;
+	vec3_t		right, fwd;
+	vec3_t		start, end;
+	vec3_t		v1, v2;
+	float		radius, perc = 1.0f, dis;
+
+	e = &backEnd.currentEntity->e;
+	radius = e->radius;
+
+	VectorCopy( e->origin, start );
+
+	VectorSubtract( e->oldorigin, start, fwd );
+	dis = VectorNormalize( fwd );
+
+	// see if we should grow from start to end
+	if ( e->renderfx & RF_GROW )
+	{
+		perc = 1.0f - ( e->axis[0][2]/*endTime*/ - tr.refdef.time ) / e->axis[0][1]/*duration*/;
+
+		if ( perc > 1.0f )
+		{
+			perc = 1.0f;
+		}
+		else if ( perc < 0.0f )
+		{
+			perc = 0.0f;
+		}
+	}
+
+	VectorMA( start, perc * dis, fwd, e->oldorigin );
+	VectorCopy( e->oldorigin, end );
+
+	// compute side vector
+	VectorSubtract( start, backEnd.viewParms.ori.origin, v1 );
+	VectorSubtract( end, backEnd.viewParms.ori.origin, v2 );
+	CrossProduct( v1, v2, right );
+	VectorNormalize( right );
+
+    DoBoltSeg( start, end, right, radius );
+}    
+
+//================================================================================
+
+
+/*
+** VectorArrayNormalize
+*
+* The inputs to this routing seem to always be close to length = 1.0 (about 0.6 to 2.0)
+* This means that we don't have to worry about zero length or enormously long vectors.
+*/
+static void VectorArrayNormalize(vec4_t *normals, unsigned int count)
+{
+//    assert(count);
+        
+#if idppc
+    {
+        register float half = 0.5;
+        register float one  = 1.0;
+        float *components = (float *)normals;
+        
+        // Vanilla PPC code, but since PPC has a reciprocal square root estimate instruction,
+        // runs *much* faster than calling sqrt().  We'll use a single Newton-Raphson
+        // refinement step to get a little more precision.  This seems to yeild results
+        // that are correct to 3 decimal places and usually correct to at least 4 (sometimes 5).
+        // (That is, for the given input range of about 0.6 to 2.0).
+        do {
+            float x, y, z;
+            float B, y0, y1;
+            
+            x = components[0];
+            y = components[1];
+            z = components[2];
+            components += 4;
+            B = x*x + y*y + z*z;
+
+#ifdef __GNUC__            
+            asm("frsqrte %0,%1" : "=f" (y0) : "f" (B));
+#else
+			y0 = __frsqrte(B);
+#endif
+            y1 = y0 + half*y0*(one - B*y0*y0);
+
+            x = x * y1;
+            y = y * y1;
+            components[-4] = x;
+            z = z * y1;
+            components[-3] = y;
+            components[-2] = z;
+        } while(count--);
+    }
+#else // No assembly version for this architecture, or C_ONLY defined
+	// given the input, it's safe to call VectorNormalizeFast
+    while (count--) {
+        VectorNormalizeFast(normals[0]);
+        normals++;
+    }
+#endif
+
+}
+
+
+
+/*
+** LerpMeshVertexes
+*/
+static void LerpMeshVertexes (md3Surface_t *surf, float backlerp) 
+{
+	short	*oldXyz, *newXyz, *oldNormals, *newNormals;
+	float	*outXyz, *outNormal;
+	float	oldXyzScale, newXyzScale;
+	float	oldNormalScale, newNormalScale;
+	int		vertNum;
+	unsigned lat, lng;
+	int		numVerts;
+
+	outXyz = tess.xyz[tess.numVertexes];
+	outNormal = tess.normal[tess.numVertexes];
+
+	newXyz = (short *)((byte *)surf + surf->ofsXyzNormals)
+		+ (backEnd.currentEntity->e.frame * surf->numVerts * 4);
+	newNormals = newXyz + 3;
+
+	newXyzScale = MD3_XYZ_SCALE * (1.0 - backlerp);
+	newNormalScale = 1.0 - backlerp;
+
+	numVerts = surf->numVerts;
+
+	if ( backlerp == 0 ) {
+		//
+		// just copy the vertexes
+		//
+		for (vertNum=0 ; vertNum < numVerts ; vertNum++,
+			newXyz += 4, newNormals += 4,
+			outXyz += 4, outNormal += 4) 
+		{
+
+			outXyz[0] = newXyz[0] * newXyzScale;
+			outXyz[1] = newXyz[1] * newXyzScale;
+			outXyz[2] = newXyz[2] * newXyzScale;
+
+			lat = ( newNormals[0] >> 8 ) & 0xff;
+			lng = ( newNormals[0] & 0xff );
+			lat *= (FUNCTABLE_SIZE/256);
+			lng *= (FUNCTABLE_SIZE/256);
+
+			// decode X as cos( lat ) * sin( long )
+			// decode Y as sin( lat ) * sin( long )
+			// decode Z as cos( long )
+#ifdef _XBOX
+			if( tess.shader->needsNormal || tess.dlightBits )
+			{
+				outNormal[0] = tr.sinTable[(lat+(FUNCTABLE_SIZE/4))&FUNCTABLE_MASK] * tr.sinTable[lng];
+				outNormal[1] = tr.sinTable[lat] * tr.sinTable[lng];
+				outNormal[2] = tr.sinTable[(lng+(FUNCTABLE_SIZE/4))&FUNCTABLE_MASK];
+			}
+#else
+			outNormal[0] = tr.sinTable[(lat+(FUNCTABLE_SIZE/4))&FUNCTABLE_MASK] * tr.sinTable[lng];
+			outNormal[1] = tr.sinTable[lat] * tr.sinTable[lng];
+			outNormal[2] = tr.sinTable[(lng+(FUNCTABLE_SIZE/4))&FUNCTABLE_MASK];
+#endif
+		}
+	} else {
+		//
+		// interpolate and copy the vertex and normal
+		//
+		oldXyz = (short *)((byte *)surf + surf->ofsXyzNormals)
+			+ (backEnd.currentEntity->e.oldframe * surf->numVerts * 4);
+		oldNormals = oldXyz + 3;
+
+		oldXyzScale = MD3_XYZ_SCALE * backlerp;
+		oldNormalScale = backlerp;
+
+		for (vertNum=0 ; vertNum < numVerts ; vertNum++,
+			oldXyz += 4, newXyz += 4, oldNormals += 4, newNormals += 4,
+			outXyz += 4, outNormal += 4) 
+		{
+			vec3_t uncompressedOldNormal, uncompressedNewNormal;
+
+			// interpolate the xyz
+			outXyz[0] = oldXyz[0] * oldXyzScale + newXyz[0] * newXyzScale;
+			outXyz[1] = oldXyz[1] * oldXyzScale + newXyz[1] * newXyzScale;
+			outXyz[2] = oldXyz[2] * oldXyzScale + newXyz[2] * newXyzScale;
+
+#ifdef _XBOX
+			if(tess.shader->needsNormal || tess.dlightBits )
+			{
+#endif
+			// FIXME: interpolate lat/long instead?
+			lat = ( newNormals[0] >> 8 ) & 0xff;
+			lng = ( newNormals[0] & 0xff );
+			lat *= 4;
+			lng *= 4;
+			uncompressedNewNormal[0] = tr.sinTable[(lat+(FUNCTABLE_SIZE/4))&FUNCTABLE_MASK] * tr.sinTable[lng];
+			uncompressedNewNormal[1] = tr.sinTable[lat] * tr.sinTable[lng];
+			uncompressedNewNormal[2] = tr.sinTable[(lng+(FUNCTABLE_SIZE/4))&FUNCTABLE_MASK];
+
+			lat = ( oldNormals[0] >> 8 ) & 0xff;
+			lng = ( oldNormals[0] & 0xff );
+			lat *= 4;
+			lng *= 4;
+
+			uncompressedOldNormal[0] = tr.sinTable[(lat+(FUNCTABLE_SIZE/4))&FUNCTABLE_MASK] * tr.sinTable[lng];
+			uncompressedOldNormal[1] = tr.sinTable[lat] * tr.sinTable[lng];
+			uncompressedOldNormal[2] = tr.sinTable[(lng+(FUNCTABLE_SIZE/4))&FUNCTABLE_MASK];
+
+			outNormal[0] = uncompressedOldNormal[0] * oldNormalScale + uncompressedNewNormal[0] * newNormalScale;
+			outNormal[1] = uncompressedOldNormal[1] * oldNormalScale + uncompressedNewNormal[1] * newNormalScale;
+			outNormal[2] = uncompressedOldNormal[2] * oldNormalScale + uncompressedNewNormal[2] * newNormalScale;
+
+//			VectorNormalize (outNormal);
+#ifdef _XBOX
+			}
+#endif
+		}
+    	VectorArrayNormalize((vec4_t *)tess.normal[tess.numVertexes], numVerts);
+   	}
+}
+
+/*
+=============
+RB_SurfaceMesh
+=============
+*/
+void RB_SurfaceMesh(md3Surface_t *surface) {
+	int				j;
+	float			backlerp;
+	int				*triangles;
+	float			*texCoords;
+	int				indexes;
+	int				Bob, Doug;
+	int				numVerts;
+
+	if (  backEnd.currentEntity->e.oldframe == backEnd.currentEntity->e.frame ) {
+		backlerp = 0;
+	} else  {
+		backlerp = backEnd.currentEntity->e.backlerp;
+	}
+
+#ifdef VV_LIGHTING
+	if(backEnd.currentEntity->dlightBits)
+		tess.dlightBits = backEnd.currentEntity->dlightBits;
+#endif
+
+	RB_CHECKOVERFLOW( surface->numVerts, surface->numTriangles*3 );
+
+	LerpMeshVertexes (surface, backlerp);
+
+	triangles = (int *) ((byte *)surface + surface->ofsTriangles);
+	indexes = surface->numTriangles * 3;
+	Bob = tess.numIndexes;
+	Doug = tess.numVertexes;
+	for (j = 0 ; j < indexes ; j++) {
+		tess.indexes[Bob + j] = Doug + triangles[j];
+	}
+	tess.numIndexes += indexes;
+
+	texCoords = (float *) ((byte *)surface + surface->ofsSt);
+
+	numVerts = surface->numVerts;
+	for ( j = 0; j < numVerts; j++ ) {
+		tess.texCoords[Doug + j][0][0] = texCoords[j*2+0];
+		tess.texCoords[Doug + j][0][1] = texCoords[j*2+1];
+		// FIXME: fill in lightmapST for completeness?
+	}
+
+	tess.numVertexes += surface->numVerts;
+
+}
+
+
+/*
+==============
+RB_SurfaceFace
+==============
+*/
+void RB_SurfaceFace( srfSurfaceFace_t *surf ) {
+	int			i, k;
+	// VVFIXME : Sooper hack. Indices in the surface are still 32-bit, we need to make them 16 bit here.
+#ifdef _XBOX
+	unsigned char	*indices;
+	unsigned short	*tessIndexes;
+	unsigned short	*v;
+#else
+	unsigned int *indices;
+	glIndex_t	*tessIndexes;
+	float		*v;
+#endif
+	float		*normal;
+	int			ndx;
+	int			Bob;
+	int			numPoints;
+	int			dlightBits;
+
+	RB_CHECKOVERFLOW( surf->numPoints, surf->numIndices );
+
+	dlightBits = surf->dlightBits;
+	tess.dlightBits |= dlightBits;
+
+#ifdef _XBOX
+	indices = ( unsigned char * ) ( ( ( char  * ) surf ) + surf->ofsIndices );
+#else
+	indices = ( unsigned * ) ( ( ( char  * ) surf ) + surf->ofsIndices );
+#endif
+
+	Bob = tess.numVertexes;
+	tessIndexes = tess.indexes + tess.numIndexes;
+	for ( i = surf->numIndices-1 ; i >= 0  ; i-- ) {
+		tessIndexes[i] = indices[i] + Bob;
+	}
+
+	tess.numIndexes += surf->numIndices;
+
+#ifdef _XBOX
+	ndx = tess.numVertexes;
+
+	numPoints = surf->numPoints;
+
+	if ( tess.shader->needsNormal || tess.dlightBits) {
+		normal = surf->plane.normal;
+		for ( i = 0, ndx = tess.numVertexes; i < numPoints; i++, ndx++ ) {
+			VectorCopy( normal, tess.normal[ndx] );
+		}
+	}
+
+	int nextSurfPoint = NEXT_SURFPOINT(surf->flags);
+	int numLightMaps = surf->flags & 0x7F;
+	for ( i = 0, v = surf->srfPoints, ndx = tess.numVertexes; i < numPoints; i++, v += nextSurfPoint, ndx++ ) {
+		Q_CastShort2Float(&tess.xyz[ndx][0], (short*)&v[0]);
+		Q_CastShort2Float(&tess.xyz[ndx][1], (short*)&v[1]);
+		Q_CastShort2Float(&tess.xyz[ndx][2], (short*)&v[2]);
+
+		Q_CastShort2Float(&tess.tangent[ndx][0], (short*)&v[3]);
+		Q_CastShort2Float(&tess.tangent[ndx][1], (short*)&v[4]);
+		Q_CastShort2Float(&tess.tangent[ndx][2], (short*)&v[5]);
+
+		tess.tangent[ndx][0] /= 32767.0f;
+		tess.tangent[ndx][1] /= 32767.0f;
+		tess.tangent[ndx][2] /= 32767.0f;
+
+		tess.setTangents = true;
+
+		Q_CastShort2FloatScale(&tess.texCoords[ndx][0][0], (short*)&v[6], 1.f / POINTS_ST_SCALE);
+		Q_CastShort2FloatScale(&tess.texCoords[ndx][0][1], (short*)&v[7], 1.f / POINTS_ST_SCALE);
+		for(k=0;k<numLightMaps;k++)
+		{
+			if (tess.shader->lightmapIndex[k] >= 0)
+			{
+				Q_CastUShort2FloatScale(&tess.texCoords[ndx][k+1][0], 
+					&v[VERTEX_LM+(k*2)+0], 1.f / POINTS_LIGHT_SCALE);
+				Q_CastUShort2FloatScale(&tess.texCoords[ndx][k+1][1], 
+					&v[VERTEX_LM+(k*2)+1], 1.f / POINTS_LIGHT_SCALE);
+			}
+			else
+			{
+				//This causes problems.  See bug 57.
+				//assert(0);
+				break;
+			}
+		}
+		if((surf->flags & 0x80) >> 7) {
+			*(unsigned int*) &tess.vertexColors[ndx] = ComputeFinalVertexColor16((byte *)&v[VERTEX_COLOR(surf->flags)]);
+		}
+	}
+#else // _XBOX
+
+	v = surf->points[0];
+
+	ndx = tess.numVertexes;
+
+	numPoints = surf->numPoints;
+
+	//if ( tess.shader->needsNormal ) 
+	{
+		normal = surf->plane.normal;
+		for ( i = 0, ndx = tess.numVertexes; i < numPoints; i++, ndx++ ) {
+			VectorCopy( normal, tess.normal[ndx] );
+		}
+	}
+
+	for ( i = 0, v = surf->points[0], ndx = tess.numVertexes; i < numPoints; i++, v += VERTEXSIZE, ndx++ ) 
+	{
+		VectorCopy( v, tess.xyz[ndx]);
+		tess.texCoords[ndx][0][0] = v[3];
+		tess.texCoords[ndx][0][1] = v[4];
+		for(k=0;k<MAXLIGHTMAPS;k++)
+		{
+			if (tess.shader->lightmapIndex[k] >= 0)
+			{
+				tess.texCoords[ndx][k+1][0] = v[VERTEX_LM+(k*2)];
+				tess.texCoords[ndx][k+1][1] = v[VERTEX_LM+(k*2)+1];
+			}
+			else
+			{
+				break;
+			}
+		}
+		*(unsigned int*) &tess.vertexColors[ndx] = ComputeFinalVertexColor((byte *)&v[VERTEX_COLOR]);
+		tess.vertexDlightBits[ndx] = dlightBits;
+	}
+#endif
+
+	tess.numVertexes += surf->numPoints;
+}
+
+
+static float	LodErrorForVolume( vec3_t local, float radius ) {
+	vec3_t		world;
+	float		d;
+
+	// never let it go negative
+	if ( r_lodCurveError->value < 0 ) {
+		return 0;
+	}
+
+	world[0] = local[0] * backEnd.ori.axis[0][0] + local[1] * backEnd.ori.axis[1][0] + 
+		local[2] * backEnd.ori.axis[2][0] + backEnd.ori.origin[0];
+	world[1] = local[0] * backEnd.ori.axis[0][1] + local[1] * backEnd.ori.axis[1][1] + 
+		local[2] * backEnd.ori.axis[2][1] + backEnd.ori.origin[1];
+	world[2] = local[0] * backEnd.ori.axis[0][2] + local[1] * backEnd.ori.axis[1][2] + 
+		local[2] * backEnd.ori.axis[2][2] + backEnd.ori.origin[2];
+
+	VectorSubtract( world, backEnd.viewParms.ori.origin, world );
+	d = DotProduct( world, backEnd.viewParms.ori.axis[0] );
+
+	if ( d < 0 ) {
+		d = -d;
+	}
+	d -= radius;
+	if ( d < 1 ) {
+		d = 1;
+	}
+
+	return r_lodCurveError->value / d;
+}
+
+/*
+=============
+RB_SurfaceGrid
+
+Just copy the grid of points and triangulate
+=============
+*/
+void RB_SurfaceGrid( srfGridMesh_t *cv ) {
+	int		i, j, k;
+	float	*xyz;
+	float	*texCoords;
+	float	*normal;
+	unsigned char *color;
+	drawVert_t	*dv;
+	int		rows, irows, vrows;
+	int		used;
+	int		widthTable[MAX_GRID_SIZE];
+	int		heightTable[MAX_GRID_SIZE];
+	float	lodError;
+	int		lodWidth, lodHeight;
+	int		numVertexes;
+	int		dlightBits;
+	int		*vDlightBits;
+
+	dlightBits = cv->dlightBits;
+	tess.dlightBits |= dlightBits;
+
+	// determine the allowable discrepance
+	lodError = LodErrorForVolume( cv->lodOrigin, cv->lodRadius );
+
+	// determine which rows and columns of the subdivision
+	// we are actually going to use
+	widthTable[0] = 0;
+	lodWidth = 1;
+	for ( i = 1 ; i < cv->width-1 ; i++ ) {
+		if ( cv->widthLodError[i] <= lodError ) {
+			widthTable[lodWidth] = i;
+			lodWidth++;
+		}
+	}
+	widthTable[lodWidth] = cv->width-1;
+	lodWidth++;
+
+	heightTable[0] = 0;
+	lodHeight = 1;
+	for ( i = 1 ; i < cv->height-1 ; i++ ) {
+		if ( cv->heightLodError[i] <= lodError ) {
+			heightTable[lodHeight] = i;
+			lodHeight++;
+		}
+	}
+	heightTable[lodHeight] = cv->height-1;
+	lodHeight++;
+
+
+	// very large grids may have more points or indexes than can be fit
+	// in the tess structure, so we may have to issue it in multiple passes
+
+	used = 0;
+	rows = 0;
+	while ( used < lodHeight - 1 ) {
+		// see how many rows of both verts and indexes we can add without overflowing
+		do {
+			vrows = ( SHADER_MAX_VERTEXES - tess.numVertexes ) / lodWidth;
+			irows = ( SHADER_MAX_INDEXES - tess.numIndexes ) / ( lodWidth * 6 );
+
+			// if we don't have enough space for at least one strip, flush the buffer
+			if ( vrows < 2 || irows < 1 ) {
+				RB_EndSurface();
+				RB_BeginSurface(tess.shader, tess.fogNum );
+			} else {
+				break;
+			}
+		} while ( 1 );
+		
+		rows = irows;
+		if ( vrows < irows + 1 ) {
+			rows = vrows - 1;
+		}
+		if ( used + rows > lodHeight ) {
+			rows = lodHeight - used;
+		}
+
+		numVertexes = tess.numVertexes;
+
+		xyz = tess.xyz[numVertexes];
+		normal = tess.normal[numVertexes];
+		texCoords = tess.texCoords[numVertexes][0];
+		color = ( unsigned char * ) &tess.vertexColors[numVertexes];
+		vDlightBits = &tess.vertexDlightBits[numVertexes];
+
+#ifdef _XBOX
+		for ( i = 0 ; i < rows ; i++ ) {
+			for ( j = 0 ; j < lodWidth ; j++ ) {
+				dv = cv->verts + heightTable[ used + i ] * cv->width
+					+ widthTable[ j ];
+
+				xyz[0] = dv->xyz[0];
+				xyz[1] = dv->xyz[1];
+				xyz[2] = dv->xyz[2];
+				xyz += 4;
+
+				Q_CastShort2FloatScale(&texCoords[0], &dv->dvst[0], 1.f / GRID_DRAWVERT_ST_SCALE);
+				Q_CastShort2FloatScale(&texCoords[1], &dv->dvst[1], 1.f / GRID_DRAWVERT_ST_SCALE);
+
+				for(k=0;k<MAXLIGHTMAPS;k++)
+				{
+					Q_CastShort2FloatScale(&texCoords[2+(k*2)+0], 
+						&dv->dvlightmap[k][0], 1.f / DRAWVERT_LIGHTMAP_SCALE);
+					Q_CastShort2FloatScale(&texCoords[2+(k*2)+1], 
+						&dv->dvlightmap[k][1], 1.f / DRAWVERT_LIGHTMAP_SCALE);
+				}
+				texCoords += NUM_TEX_COORDS*2;
+
+				if ( tess.shader->needsNormal || tess.dlightBits) 
+				{
+					normal[0] = dv->normal[0];
+					normal[1] = dv->normal[1];
+					normal[2] = dv->normal[2];
+					normal += 4;
+				}
+				
+				*(unsigned *)color = ComputeFinalVertexColor16((byte *)dv->dvcolor);
+				color += 4;
+				*vDlightBits++ = dlightBits;
+			}
+		}
+#else // _XBOX
+
+		for ( i = 0 ; i < rows ; i++ ) {
+			for ( j = 0 ; j < lodWidth ; j++ ) {
+				dv = cv->verts + heightTable[ used + i ] * cv->width
+					+ widthTable[ j ];
+
+				xyz[0] = dv->xyz[0];
+				xyz[1] = dv->xyz[1];
+				xyz[2] = dv->xyz[2];
+				xyz += 4;
+
+				texCoords[0] = dv->st[0];
+				texCoords[1] = dv->st[1];
+				for(k=0;k<MAXLIGHTMAPS;k++)
+				{
+					texCoords[2+(k*2)]= dv->lightmap[k][0];
+					texCoords[2+(k*2)+1]= dv->lightmap[k][1];
+				}
+				texCoords += NUM_TEX_COORDS*2;
+
+				//if ( needsNormal ) 
+				{
+					normal[0] = dv->normal[0];
+					normal[1] = dv->normal[1];
+					normal[2] = dv->normal[2];
+				}
+				normal += 4;
+
+				*(unsigned *)color = ComputeFinalVertexColor((byte *)dv->color);
+				color += 4;
+				*vDlightBits++ = dlightBits;
+			}
+		}
+#endif // _XBOX
+
+		// add the indexes
+		{
+			int		numIndexes;
+			int		w, h;
+
+			h = rows - 1;
+			w = lodWidth - 1;
+			numIndexes = tess.numIndexes;
+			for (i = 0 ; i < h ; i++) {
+				for (j = 0 ; j < w ; j++) {
+					int		v1, v2, v3, v4;
+			
+					// vertex order to be reckognized as tristrips
+					v1 = numVertexes + i*lodWidth + j + 1;
+					v2 = v1 - 1;
+					v3 = v2 + lodWidth;
+					v4 = v3 + 1;
+
+					tess.indexes[numIndexes] = v2;
+					tess.indexes[numIndexes+1] = v3;
+					tess.indexes[numIndexes+2] = v1;
+					
+					tess.indexes[numIndexes+3] = v1;
+					tess.indexes[numIndexes+4] = v3;
+					tess.indexes[numIndexes+5] = v4;
+					numIndexes += 6;
+				}
+			}
+
+			tess.numIndexes = numIndexes;
+		}
+
+		tess.numVertexes += rows * lodWidth;
+
+		used += rows - 1;
+	}
+}
+
+
+/*
+===========================================================================
+
+NULL MODEL
+
+===========================================================================
+*/
+
+/*
+===================
+RB_SurfaceAxis
+
+Draws x/y/z lines from the origin for orientation debugging
+===================
+*/
+static void RB_SurfaceAxis( void ) {
+	GL_Bind( tr.whiteImage );
+	qglLineWidth( 3 );
+#ifdef _XBOX
+	qglBeginEXT( GL_LINES, 6, 3, 0, 0, 0);
+#else
+	qglBegin( GL_LINES );
+#endif
+	qglColor3f( 1,0,0 );
+	qglVertex3f( 0,0,0 );
+	qglVertex3f( 16,0,0 );
+	qglColor3f( 0,1,0 );
+	qglVertex3f( 0,0,0 );
+	qglVertex3f( 0,16,0 );
+	qglColor3f( 0,0,1 );
+	qglVertex3f( 0,0,0 );
+	qglVertex3f( 0,0,16 );
+	qglEnd();
+	qglLineWidth( 1 );
+}
+
+//===========================================================================
+
+/*
+====================
+RB_SurfaceEntity
+
+Entities that have a single procedurally generated surface
+====================
+*/
+void RB_SurfaceEntity( surfaceType_t *surfType ) {
+	switch( backEnd.currentEntity->e.reType ) {
+	case RT_SPRITE:
+		RB_SurfaceSprite();
+		break;
+	case RT_ORIENTED_QUAD:
+		RB_SurfaceOrientedQuad();
+		break;
+	case RT_BEAM:
+		RB_SurfaceBeam();
+		break;
+	case RT_ELECTRICITY:
+		RB_SurfaceElectricity();
+		break;
+	case RT_LINE:
+		RB_SurfaceLine();
+		break;
+	case RT_ORIENTEDLINE:
+		RB_SurfaceOrientedLine();
+		break;
+	case RT_SABER_GLOW:
+		RB_SurfaceSaberGlow();
+		break;
+	case RT_CYLINDER:
+		RB_SurfaceCylinder();
+		break;
+	case RT_ENT_CHAIN:
+		{
+			int				i, count, start;
+			static trRefEntity_t	tempEnt = *backEnd.currentEntity;
+			//rww - if not static then currentEntity is garbage because
+			//this is a local. This was not static in sof2.. but I guess
+			//they never check ce.renderfx so it didn't show up.
+
+			start = backEnd.currentEntity->e.uRefEnt.uMini.miniStart;
+			count = backEnd.currentEntity->e.uRefEnt.uMini.miniCount;
+			assert(count > 0);
+			backEnd.currentEntity = &tempEnt;
+			
+			assert(backEnd.currentEntity->e.renderfx >= 0);
+
+			for(i=0;i<count;i++)
+			{
+				memcpy(&backEnd.currentEntity->e, &backEnd.refdef.miniEntities[start+i], sizeof(backEnd.refdef.miniEntities[start+i]));
+			
+				assert(backEnd.currentEntity->e.renderfx >= 0);
+
+				RB_SurfaceEntity(surfType);
+			}
+		}
+		break;
+	default:
+		RB_SurfaceAxis();
+		break;
+	}
+	return;
+}
+
+void RB_SurfaceBad( surfaceType_t *surfType ) {
+	Com_Printf ("Bad surface tesselated.\n" );
+}
+
+/*
+==================
+RB_TestZFlare
+
+This is called at surface tesselation time
+==================
+*/
+static bool RB_TestZFlare( vec3_t point) {
+	int				i;
+	vec4_t			eye, clip, normalized, window;
+
+	// if the point is off the screen, don't bother adding it
+	// calculate screen coordinates and depth
+	R_TransformModelToClip( point, backEnd.ori.modelMatrix, 
+		backEnd.viewParms.projectionMatrix, eye, clip );
+
+	// check to see if the point is completely off screen
+	for ( i = 0 ; i < 3 ; i++ ) {
+		if ( clip[i] >= clip[3] || clip[i] <= -clip[3] ) {
+			return qfalse;
+		}
+	}
+
+	R_TransformClipToWindow( clip, &backEnd.viewParms, normalized, window );
+
+	if ( window[0] < 0 || window[0] >= backEnd.viewParms.viewportWidth
+		|| window[1] < 0 || window[1] >= backEnd.viewParms.viewportHeight ) {
+		return qfalse;	// shouldn't happen, since we check the clip[] above, except for FP rounding
+	}
+
+//do test
+	float			depth = 0.0f;
+	bool			visible;
+	float			screenZ;
+
+	// read back the z buffer contents
+#ifdef _XBOX
+	depth = 0.0f;
+#else
+	if ( r_flares->integer !=1 ) {	//skipping the the z-test
+		return true;
+	}
+	// doing a readpixels is as good as doing a glFinish(), so
+	// don't bother with another sync
+	glState.finishCalled = qfalse;
+	qglReadPixels( backEnd.viewParms.viewportX + window[0],backEnd.viewParms.viewportY + window[1], 1, 1, GL_DEPTH_COMPONENT, GL_FLOAT, &depth );
+#endif
+
+	screenZ = backEnd.viewParms.projectionMatrix[14] / 
+		( ( 2*depth - 1 ) * backEnd.viewParms.projectionMatrix[11] - backEnd.viewParms.projectionMatrix[10] );
+
+	visible = ( -eye[2] - -screenZ ) < 24;
+	return visible;
+}
+
+void RB_SurfaceFlare( srfFlare_t *surf ) {
+	vec3_t		left, up;
+	float		radius;
+	byte		color[4];
+	vec3_t		dir;
+	vec3_t		origin;
+	float		d, dist;
+
+	if ( !r_flares->integer ) {
+		return;
+	}
+
+#ifdef _XBOX
+	vec3_t     sorigin, snormal;
+
+	Q_CastShort2Float(&sorigin[0], (short*)&surf->origin[0]);
+	Q_CastShort2Float(&sorigin[1], (short*)&surf->origin[1]);
+	Q_CastShort2Float(&sorigin[2], (short*)&surf->origin[2]);
+	Q_CastShort2Float(&snormal[0], (short*)&surf->normal[0]);
+	Q_CastShort2Float(&snormal[1], (short*)&surf->normal[1]);
+	Q_CastShort2Float(&snormal[2], (short*)&surf->normal[2]);
+	snormal[0] /= 32767.0f;
+	snormal[1] /= 32767.0f;
+	snormal[2] /= 32767.0f;
+
+	if (!RB_TestZFlare( sorigin) ) {
+		return;
+	}
+
+	// calculate the xyz locations for the four corners
+	VectorMA( sorigin, 3, snormal, origin );
+#else
+	if (!RB_TestZFlare( surf->origin ) ) {
+		return;
+	}
+
+	// calculate the xyz locations for the four corners
+	VectorMA( surf->origin, 3, surf->normal, origin );
+	float* snormal = surf->normal;
+#endif // _XBOX
+
+	VectorSubtract( origin, backEnd.viewParms.ori.origin, dir );
+	dist = VectorNormalize( dir );
+
+	d = -DotProduct( dir, snormal );
+	if ( d < 0 ) {
+		d = -d;
+	}
+
+	// fade the intensity of the flare down as the
+	// light surface turns away from the viewer
+	color[0] = d * 255;
+	color[1] = d * 255;
+	color[2] = d * 255;
+	color[3] = 255;	//only gets used if the shader has cgen exact_vertex!
+
+	radius = tess.shader->portalRange ? tess.shader->portalRange: 30;
+	if (dist < 512.0f)
+	{
+		radius = radius * dist / 512.0f;
+	}
+	if (radius<5.0f)
+	{
+		radius = 5.0f;
+	}
+	VectorScale( backEnd.viewParms.ori.axis[1], radius, left );
+	VectorScale( backEnd.viewParms.ori.axis[2], radius, up );
+	if ( backEnd.viewParms.isMirror ) {
+		VectorSubtract( vec3_origin, left, left );
+	}
+
+	RB_AddQuadStamp( origin, left, up, color );
+}
+
+
+void RB_SurfaceDisplayList( srfDisplayList_t *surf ) {
+	// all apropriate state must be set in RB_BeginSurface
+	// this isn't implemented yet...
+	qglCallList( surf->listNum );
+}
+
+void RB_SurfaceSkip( void *surf ) {
+}
+
+
+void (*rb_surfaceTable[SF_NUM_SURFACE_TYPES])( void *) = {
+	(void(*)(void*))RB_SurfaceBad,			// SF_BAD, 
+	(void(*)(void*))RB_SurfaceSkip,			// SF_SKIP, 
+	(void(*)(void*))RB_SurfaceFace,			// SF_FACE,
+	(void(*)(void*))RB_SurfaceGrid,			// SF_GRID,
+	(void(*)(void*))RB_SurfaceTriangles,	// SF_TRIANGLES,
+	(void(*)(void*))RB_SurfacePolychain,	// SF_POLY,
+	(void(*)(void*))RB_SurfaceTerrain,		// SF_TERRAIN, //rwwRMG - added
+	(void(*)(void*))RB_SurfaceMesh,			// SF_MD3,
+/*
+Ghoul2 Insert Start
+*/
+	(void(*)(void*))RB_SurfaceGhoul,		// SF_MDX,
+/*
+Ghoul2 Insert End
+*/
+	(void(*)(void*))RB_SurfaceFlare,		// SF_FLARE,
+	(void(*)(void*))RB_SurfaceEntity,		// SF_ENTITY
+	(void(*)(void*))RB_SurfaceDisplayList	// SF_DISPLAY_LIST
+};
diff --git a/codemp/renderer/tr_surfacesprites.cpp b/codemp/renderer/tr_surfacesprites.cpp
new file mode 100644
index 0000000..0725c4e
--- /dev/null
+++ b/codemp/renderer/tr_surfacesprites.cpp
@@ -0,0 +1,1463 @@
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+// tr_shade.c
+
+#include "tr_local.h"
+
+#include "tr_QuickSprite.h"
+#include "tr_WorldEffects.h"
+
+
+/////===== Part of the VERTIGON system =====/////
+// The surfacesprites are a simple system.  When a polygon with this shader stage on it is drawn,
+// there are randomly distributed images (defined by the shader stage) placed on the surface.
+// these are capable of doing effects, grass, or simple oriented sprites.  
+// They usually stick vertically off the surface, hence the term vertigons.
+
+// The vertigons are applied as part of the renderer backend.  That is, they access OpenGL calls directly.
+
+
+unsigned char randomindex, randominterval;
+const float randomchart[256] = {
+	0.6554f, 0.6909f, 0.4806f, 0.6218f, 0.5717f, 0.3896f, 0.0677f, 0.7356f, 
+	0.8333f, 0.1105f, 0.4445f, 0.8161f, 0.4689f, 0.0433f, 0.7152f, 0.0336f, 
+	0.0186f, 0.9140f, 0.1626f, 0.6553f, 0.8340f, 0.7094f, 0.2020f, 0.8087f, 
+	0.9119f, 0.8009f, 0.1339f, 0.8492f, 0.9173f, 0.5003f, 0.6012f, 0.6117f, 
+	0.5525f, 0.5787f, 0.1586f, 0.3293f, 0.9273f, 0.7791f, 0.8589f, 0.4985f, 
+	0.0883f, 0.8545f, 0.2634f, 0.4727f, 0.3624f, 0.1631f, 0.7825f, 0.0662f, 
+	0.6704f, 0.3510f, 0.7525f, 0.9486f, 0.4685f, 0.1535f, 0.1545f, 0.1121f, 
+	0.4724f, 0.8483f, 0.3833f, 0.1917f, 0.8207f, 0.3885f, 0.9702f, 0.9200f, 
+	0.8348f, 0.7501f, 0.6675f, 0.4994f, 0.0301f, 0.5225f, 0.8011f, 0.1696f, 
+	0.5351f, 0.2752f, 0.2962f, 0.7550f, 0.5762f, 0.7303f, 0.2835f, 0.4717f, 
+	0.1818f, 0.2739f, 0.6914f, 0.7748f, 0.7640f, 0.8355f, 0.7314f, 0.5288f, 
+	0.7340f, 0.6692f, 0.6813f, 0.2810f, 0.8057f, 0.0648f, 0.8749f, 0.9199f, 
+	0.1462f, 0.5237f, 0.3014f, 0.4994f, 0.0278f, 0.4268f, 0.7238f, 0.5107f, 
+	0.1378f, 0.7303f, 0.7200f, 0.3819f, 0.2034f, 0.7157f, 0.5552f, 0.4887f, 
+	0.0871f, 0.3293f, 0.2892f, 0.4545f, 0.0088f, 0.1404f, 0.0275f, 0.0238f, 
+	0.0515f, 0.4494f, 0.7206f, 0.2893f, 0.6060f, 0.5785f, 0.4182f, 0.5528f, 
+	0.9118f, 0.8742f, 0.3859f, 0.6030f, 0.3495f, 0.4550f, 0.9875f, 0.6900f, 
+	0.6416f, 0.2337f, 0.7431f, 0.9788f, 0.6181f, 0.2464f, 0.4661f, 0.7621f, 
+	0.7020f, 0.8203f, 0.8869f, 0.2145f, 0.7724f, 0.6093f, 0.6692f, 0.9686f, 
+	0.5609f, 0.0310f, 0.2248f, 0.2950f, 0.2365f, 0.1347f, 0.2342f, 0.1668f, 
+	0.3378f, 0.4330f, 0.2775f, 0.9901f, 0.7053f, 0.7266f, 0.4840f, 0.2820f, 
+	0.5733f, 0.4555f, 0.6049f, 0.0770f, 0.4760f, 0.6060f, 0.4159f, 0.3427f, 
+	0.1234f, 0.7062f, 0.8569f, 0.1878f, 0.9057f, 0.9399f, 0.8139f, 0.1407f, 
+	0.1794f, 0.9123f, 0.9493f, 0.2827f, 0.9934f, 0.0952f, 0.4879f, 0.5160f, 
+	0.4118f, 0.4873f, 0.3642f, 0.7470f, 0.0866f, 0.5172f, 0.6365f, 0.2676f, 
+	0.2407f, 0.7223f, 0.5761f, 0.1143f, 0.7137f, 0.2342f, 0.3353f, 0.6880f, 
+	0.2296f, 0.6023f, 0.6027f, 0.4138f, 0.5408f, 0.9859f, 0.1503f, 0.7238f, 
+	0.6054f, 0.2477f, 0.6804f, 0.1432f, 0.4540f, 0.9776f, 0.8762f, 0.7607f, 
+	0.9025f, 0.9807f, 0.0652f, 0.8661f, 0.7663f, 0.2586f, 0.3994f, 0.0335f, 
+	0.7328f, 0.0166f, 0.9589f, 0.4348f, 0.5493f, 0.7269f, 0.6867f, 0.6614f, 
+	0.6800f, 0.7804f, 0.5591f, 0.8381f, 0.0910f, 0.7573f, 0.8985f, 0.3083f, 
+	0.3188f, 0.8481f, 0.2356f, 0.6736f, 0.4770f, 0.4560f, 0.6266f, 0.4677f
+};
+
+#define WIND_DAMP_INTERVAL 50
+#define WIND_GUST_TIME 2500.0
+#define WIND_GUST_DECAY (1.0 / WIND_GUST_TIME)
+
+int		lastSSUpdateTime = 0;
+float	curWindSpeed=0;
+float	curWindGust=5;
+float	curWeatherAmount=1;
+vec3_t	curWindBlowVect={0,0,0}, targetWindBlowVect={0,0,0};
+vec3_t	curWindGrassDir={0,0,0}, targetWindGrassDir={0,0,0};
+int		totalsurfsprites=0, sssurfaces=0;
+
+qboolean curWindPointActive=qfalse;
+float curWindPointForce = 0;
+vec3_t curWindPoint;
+int nextGustTime=0;
+float gustLeft=0;
+
+qboolean standardfovinitialized=qfalse;
+float	standardfovx = 90, standardscalex = 1.0;
+float	rangescalefactor=1.0;
+
+vec3_t  ssrightvectors[4];
+vec3_t  ssfwdvector;
+int		rightvectorcount;
+
+trRefEntity_t *ssLastEntityDrawn=NULL;
+vec3_t	ssViewOrigin, ssViewRight, ssViewUp;
+
+
+static void R_SurfaceSpriteFrameUpdate(void)
+{
+	float dtime, dampfactor;	// Time since last update and damping time for wind changes
+	float ratio;
+	vec3_t ang, diff, retwindvec;
+	float targetspeed;
+	vec3_t up={0,0,1};
+
+	if (backEnd.refdef.time == lastSSUpdateTime)
+		return;
+
+	if (backEnd.refdef.time < lastSSUpdateTime)
+	{	// Time is BEFORE the last update time, so reset everything.
+		curWindGust = 5;
+		curWindSpeed = r_windSpeed->value;
+		nextGustTime = 0;
+		gustLeft = 0;
+	}
+
+	// Reset the last entity drawn, since this is a new frame.
+	ssLastEntityDrawn = NULL;
+
+	// Adjust for an FOV.  If things look twice as wide on the screen, pretend the shaders have twice the range.
+	// ASSUMPTION HERE IS THAT "standard" fov is the first one rendered.
+	
+	if (!standardfovinitialized)
+	{	// This isn't initialized yet.
+		if (backEnd.refdef.fov_x > 50 && backEnd.refdef.fov_x < 135)		// I don't consider anything below 50 or above 135 to be "normal".
+		{
+			standardfovx = backEnd.refdef.fov_x;
+			standardscalex = tan(standardfovx * 0.5 * (M_PI/180.0f));
+			standardfovinitialized = qtrue;
+		}
+		else
+		{
+			standardfovx = 90;
+			standardscalex = tan(standardfovx * 0.5 * (M_PI/180.0f));
+		}
+		rangescalefactor = 1.0;		// Don't multiply the shader range by anything.
+	}
+	else if (standardfovx == backEnd.refdef.fov_x)
+	{	// This is the standard FOV (or higher), don't multiply the shader range.
+		rangescalefactor = 1.0;
+	}
+	else
+	{	// We are using a non-standard FOV.  We need to multiply the range of the shader by a scale factor.
+		if (backEnd.refdef.fov_x > 135)
+		{
+			rangescalefactor = standardscalex / tan(135.0f * 0.5f * (M_PI/180.0f));
+		}
+		else
+		{
+			rangescalefactor = standardscalex / tan(backEnd.refdef.fov_x * 0.5 * (M_PI/180.0f));
+		}
+	}
+
+	// Create a set of four right vectors so that vertical sprites aren't always facing the same way.
+	// First generate a HORIZONTAL forward vector (important).
+	CrossProduct(ssViewRight, up, ssfwdvector);
+	
+	// Right Zero has a nudge forward (10 degrees).
+	VectorScale(ssViewRight, 0.985f, ssrightvectors[0]);
+	VectorMA(ssrightvectors[0], 0.174f, ssfwdvector, ssrightvectors[0]);
+
+	// Right One has a big nudge back (30 degrees).
+	VectorScale(ssViewRight, 0.866f, ssrightvectors[1]);
+	VectorMA(ssrightvectors[1], -0.5f, ssfwdvector, ssrightvectors[1]);
+
+
+	// Right two has a big nudge forward (30 degrees).
+	VectorScale(ssViewRight, 0.866f, ssrightvectors[2]);
+	VectorMA(ssrightvectors[2], 0.5f, ssfwdvector, ssrightvectors[2]);
+
+
+	// Right three has a nudge back (10 degrees).
+	VectorScale(ssViewRight, 0.985f, ssrightvectors[3]);
+	VectorMA(ssrightvectors[3], -0.174f, ssfwdvector, ssrightvectors[3]);
+
+
+	// Update the wind.
+	// If it is raining, get the windspeed from the rain system rather than the cvar
+	if (R_IsRaining() || R_IsPuffing())
+	{
+		curWeatherAmount = 1.0;
+	}
+	else
+	{
+		curWeatherAmount = r_surfaceWeather->value;
+	}
+
+	if (R_GetWindSpeed(targetspeed))
+	{	// We successfully got a speed from the rain system.
+		// Set the windgust to 5, since that looks pretty good.
+		targetspeed *= 0.3f;
+		if (targetspeed >= 1.0)
+		{
+			curWindGust = 300/targetspeed;
+		}
+		else
+		{
+			curWindGust = 0;
+		}
+	}
+	else
+	{	// Use the cvar.
+		targetspeed = r_windSpeed->value;	// Minimum gust delay, in seconds.
+		curWindGust = r_windGust->value;
+	}
+	
+	if (targetspeed > 0 && curWindGust)
+	{
+		if (gustLeft > 0)
+		{	// We are gusting
+			// Add an amount to the target wind speed
+			targetspeed *= 1.0 + gustLeft;
+
+			gustLeft -= (float)(backEnd.refdef.time - lastSSUpdateTime)*WIND_GUST_DECAY;
+			if (gustLeft <= 0)
+			{
+				nextGustTime = backEnd.refdef.time + (curWindGust*1000)*flrand(1.0f,4.0f);
+			}
+		}
+		else if (backEnd.refdef.time >= nextGustTime)
+		{	// See if there is another right now
+			// Gust next time, mano
+			gustLeft = flrand(0.75f,1.5f);
+		}
+	}
+
+	// See if there is a weather system that will tell us a windspeed.
+	if (R_GetWindVector(retwindvec))
+	{
+		retwindvec[2]=0;
+		VectorScale(retwindvec, -1.0f, retwindvec);
+		vectoangles(retwindvec, ang);
+	}
+	else
+	{	// Calculate the target wind vector based off cvars
+		ang[YAW] = r_windAngle->value;
+	}
+
+	ang[PITCH] = -90.0 + targetspeed;
+	if (ang[PITCH]>-45.0)
+	{
+		ang[PITCH] = -45.0;
+	}
+	ang[ROLL] = 0;
+
+	if (targetspeed>0)
+	{
+//		ang[YAW] += cos(tr.refdef.time*0.01+flrand(-1.0,1.0))*targetspeed*0.5;
+//		ang[PITCH] += sin(tr.refdef.time*0.01+flrand(-1.0,1.0))*targetspeed*0.5;
+	}
+	
+	// Get the grass wind vector first
+	AngleVectors(ang, targetWindGrassDir, NULL, NULL);
+	targetWindGrassDir[2]-=1.0;
+//		VectorScale(targetWindGrassDir, targetspeed, targetWindGrassDir);
+
+	// Now get the general wind vector (no pitch)
+	ang[PITCH]=0;
+	AngleVectors(ang, targetWindBlowVect, NULL, NULL);
+
+	// Start calculating a smoothing factor so wind doesn't change abruptly between speeds.
+	dampfactor = 1.0-r_windDampFactor->value;	// We must exponent the amount LEFT rather than the amount bled off
+	dtime = (float)(backEnd.refdef.time - lastSSUpdateTime) * (1.0/(float)WIND_DAMP_INTERVAL);	// Our dampfactor is geared towards a time interval equal to "1".
+
+	// Note that since there are a finite number of "practical" delta millisecond values possible, 
+	// the ratio should be initialized into a chart ultimately.
+	ratio = pow(dampfactor, dtime);
+
+	// Apply this ratio to the windspeed...
+	curWindSpeed = targetspeed - (ratio * (targetspeed-curWindSpeed));
+
+	// Use the curWindSpeed to calculate the final target wind vector (with speed)
+	VectorScale(targetWindBlowVect, curWindSpeed, targetWindBlowVect);
+	VectorSubtract(targetWindBlowVect, curWindBlowVect, diff);
+	VectorMA(targetWindBlowVect, -ratio, diff, curWindBlowVect);
+
+	// Update the grass vector now
+	VectorSubtract(targetWindGrassDir, curWindGrassDir, diff);
+	VectorMA(targetWindGrassDir, -ratio, diff, curWindGrassDir);
+
+	lastSSUpdateTime = backEnd.refdef.time;
+
+	curWindPointForce = r_windPointForce->value - (ratio * (r_windPointForce->value - curWindPointForce));
+	if (curWindPointForce < 0.01)
+	{
+		curWindPointActive = qfalse;
+	}
+	else
+	{
+		curWindPointActive = qtrue;
+		curWindPoint[0] = r_windPointX->value;
+		curWindPoint[1] = r_windPointY->value;
+		curWindPoint[2] = 0;
+	}
+
+	if (r_surfaceSprites->integer >= 2)
+	{
+		Com_Printf("Surfacesprites Drawn: %d, on %d surfaces\n", totalsurfsprites, sssurfaces);
+	}
+
+	totalsurfsprites=0;
+	sssurfaces=0;
+}
+
+
+
+/////////////////////////////////////////////
+// Surface sprite calculation and drawing.
+/////////////////////////////////////////////
+
+#define FADE_RANGE			250.0
+#define WINDPOINT_RADIUS	750.0
+
+float SSVertAlpha[SHADER_MAX_VERTEXES];
+float SSVertWindForce[SHADER_MAX_VERTEXES];
+vec2_t SSVertWindDir[SHADER_MAX_VERTEXES];
+
+qboolean SSAdditiveTransparency=qfalse;
+qboolean SSUsingFog=qfalse;
+
+
+/////////////////////////////////////////////
+// Vertical surface sprites
+
+static void RB_VerticalSurfaceSprite(vec3_t loc, float width, float height, byte light, 
+										byte alpha, float wind, float windidle, vec2_t fog, int hangdown, vec2_t skew)
+{
+	vec3_t loc2, right;
+	float angle;
+	float windsway;
+	float points[16];
+	color4ub_t color;
+
+	angle = ((loc[0]+loc[1])*0.02+(tr.refdef.time*0.0015));
+
+	if (windidle>0.0)
+	{
+		windsway = (height*windidle*0.075);
+		loc2[0] = loc[0]+skew[0]+cos(angle)*windsway;
+		loc2[1] = loc[1]+skew[1]+sin(angle)*windsway;
+
+		if (hangdown)
+		{
+			loc2[2] = loc[2]-height;
+		}
+		else
+		{
+			loc2[2] = loc[2]+height;
+		}
+	}
+	else
+	{
+		loc2[0] = loc[0]+skew[0];
+		loc2[1] = loc[1]+skew[1];
+		if (hangdown)
+		{
+			loc2[2] = loc[2]-height;
+		}
+		else
+		{
+			loc2[2] = loc[2]+height;
+		}
+	}
+
+	if (wind>0.0 && curWindSpeed > 0.001)
+	{
+		windsway = (height*wind*0.075);
+
+		// Add the angle
+		VectorMA(loc2, height*wind, curWindGrassDir, loc2);
+		// Bob up and down
+		if (curWindSpeed < 40.0)
+		{
+			windsway *= curWindSpeed*(1.0/100.0);
+		}
+		else
+		{
+			windsway *= 0.4f;
+		}
+		loc2[2] += sin(angle*2.5)*windsway;
+	}
+
+	VectorScale(ssrightvectors[rightvectorcount], width*0.5, right);
+
+	color[0]=light;
+	color[1]=light;
+	color[2]=light;
+	color[3]=alpha;
+
+	// Bottom right
+//	VectorAdd(loc, right, point);
+	points[0] = loc[0] + right[0];
+	points[1] = loc[1] + right[1];
+	points[2] = loc[2] + right[2];
+	points[3] = 0;
+
+	// Top right
+//	VectorAdd(loc2, right, point);
+	points[4] = loc2[0] + right[0];
+	points[5] = loc2[1] + right[1];
+	points[6] = loc2[2] + right[2];
+	points[7] = 0;
+
+	// Top left
+//	VectorSubtract(loc2, right, point);
+	points[8] = loc2[0] - right[0] + ssfwdvector[0] * width * 0.2;
+	points[9] = loc2[1] - right[1] + ssfwdvector[1] * width * 0.2;
+	points[10] = loc2[2] - right[2];
+	points[11] = 0;
+
+	// Bottom left
+//	VectorSubtract(loc, right, point);
+	points[12] = loc[0] - right[0];
+	points[13] = loc[1] - right[1];
+	points[14] = loc[2] - right[2];
+	points[15] = 0;
+
+	// Add the sprite to the render list.
+	SQuickSprite.Add(points, color, fog);
+}
+
+static void RB_VerticalSurfaceSpriteWindPoint(vec3_t loc, float width, float height, byte light, 
+												byte alpha, float wind, float windidle, vec2_t fog, 
+												int hangdown, vec2_t skew, vec2_t winddiff, float windforce)
+{
+	vec3_t loc2, right;
+	float angle;
+	float windsway;
+	float points[16];
+	color4ub_t color;
+
+	if (windforce > 1)
+		windforce = 1;
+
+//	wind += 1.0-windforce;
+
+	angle = (loc[0]+loc[1])*0.02+(tr.refdef.time*0.0015);
+
+	if (curWindSpeed <80.0)
+	{
+		windsway = (height*windidle*0.1)*(1.0+windforce);
+		loc2[0] = loc[0]+skew[0]+cos(angle)*windsway;
+		loc2[1] = loc[1]+skew[1]+sin(angle)*windsway;
+	}
+	else
+	{
+		loc2[0] = loc[0]+skew[0];
+		loc2[1] = loc[1]+skew[1];
+	}
+	if (hangdown)
+	{
+		loc2[2] = loc[2]-height;
+	}
+	else
+	{
+		loc2[2] = loc[2]+height;
+	}
+
+	if (curWindSpeed > 0.001)
+	{
+		// Add the angle
+		VectorMA(loc2, height*wind, curWindGrassDir, loc2);
+	}
+
+	loc2[0] += height*winddiff[0]*windforce;
+	loc2[1] += height*winddiff[1]*windforce;
+	loc2[2] -= height*windforce*(0.75 + 0.15*sin((tr.refdef.time + 500*windforce)*0.01));
+
+	VectorScale(ssrightvectors[rightvectorcount], width*0.5, right);
+
+	color[0]=light;
+	color[1]=light;
+	color[2]=light;
+	color[3]=alpha;
+
+	// Bottom right
+//	VectorAdd(loc, right, point);
+	points[0] = loc[0] + right[0];
+	points[1] = loc[1] + right[1];
+	points[2] = loc[2] + right[2];
+	points[3] = 0;
+
+	// Top right
+//	VectorAdd(loc2, right, point);
+	points[4] = loc2[0] + right[0];
+	points[5] = loc2[1] + right[1];
+	points[6] = loc2[2] + right[2];
+	points[7] = 0;
+
+	// Top left
+//	VectorSubtract(loc2, right, point);
+	points[8] = loc2[0] - right[0] + ssfwdvector[0] * width * 0.15;
+	points[9] = loc2[1] - right[1] + ssfwdvector[1] * width * 0.15;
+	points[10] = loc2[2] - right[2];
+	points[11] = 0;
+
+	// Bottom left
+//	VectorSubtract(loc, right, point);
+	points[12] = loc[0] - right[0];
+	points[13] = loc[1] - right[1];
+	points[14] = loc[2] - right[2];
+	points[15] = 0;
+
+	// Add the sprite to the render list.
+	SQuickSprite.Add(points, color, fog);
+}
+
+static void RB_DrawVerticalSurfaceSprites( shaderStage_t *stage, shaderCommands_t *input) 
+{
+	int curindex, curvert;
+ 	vec3_t dist;
+	float triarea;
+	vec2_t vec1to2, vec1to3;
+
+	vec3_t v1,v2,v3;
+	float a1,a2,a3;
+	float l1,l2,l3;
+	vec2_t fog1, fog2, fog3;
+	vec2_t winddiff1, winddiff2, winddiff3;
+	float  windforce1, windforce2, windforce3;
+
+	float posi, posj;
+	float step;
+	float fa,fb,fc;
+
+	vec3_t curpoint;
+	float width, height;
+	float alpha, alphapos, thisspritesfadestart, light;
+
+	byte randomindex2;
+
+	vec2_t skew={0,0};
+	vec2_t fogv;
+	vec2_t winddiffv;
+	float windforce=0;
+	qboolean usewindpoint = (qboolean) !! (curWindPointActive && stage->ss->wind > 0);
+
+	float cutdist=stage->ss->fadeMax*rangescalefactor, cutdist2=cutdist*cutdist;
+	float fadedist=stage->ss->fadeDist*rangescalefactor, fadedist2=fadedist*fadedist;
+
+	assert(cutdist2 != fadedist2);
+	float inv_fadediff = 1.0/(cutdist2-fadedist2);
+
+	// The faderange is the fraction amount it takes for these sprites to fade out, assuming an ideal fade range of 250
+	float faderange = FADE_RANGE/(cutdist-fadedist);
+
+	if (faderange > 1.0)
+	{	// Don't want to force a new fade_rand
+		faderange = 1.0;
+	}
+
+	// Quickly calc all the alphas and windstuff for each vertex
+	for (curvert=0; curvert<input->numVertexes; curvert++)
+	{
+		VectorSubtract(ssViewOrigin, input->xyz[curvert], dist);
+		SSVertAlpha[curvert] = 1.0 - (VectorLengthSquared(dist) - fadedist2) * inv_fadediff;
+	}
+
+	// Wind only needs initialization once per tess.
+	if (usewindpoint && !tess.SSInitializedWind)
+	{
+		for (curvert=0; curvert<input->numVertexes;curvert++)
+		{	// Calc wind at each point
+			dist[0]=input->xyz[curvert][0] - curWindPoint[0];
+			dist[1]=input->xyz[curvert][1] - curWindPoint[1];
+			step = (dist[0]*dist[0] + dist[1]*dist[1]);	// dist squared
+
+			if (step >= (float)(WINDPOINT_RADIUS*WINDPOINT_RADIUS))
+			{	// No wind
+				SSVertWindDir[curvert][0] = 0;
+				SSVertWindDir[curvert][1] = 0;
+				SSVertWindForce[curvert]=0;		// Should be < 1
+			}
+			else
+			{
+				if (step<1)
+				{	// Don't want to divide by zero
+					SSVertWindDir[curvert][0] = 0;
+					SSVertWindDir[curvert][1] = 0;
+					SSVertWindForce[curvert] = curWindPointForce * stage->ss->wind;
+				}
+				else
+				{
+					step = Q_rsqrt(step);		// Equals 1 over the distance.
+					SSVertWindDir[curvert][0] = dist[0] * step;
+					SSVertWindDir[curvert][1] = dist[1] * step;
+					step = 1.0 - (1.0 / (step * WINDPOINT_RADIUS));	// 1- (dist/maxradius) = a scale from 0 to 1 linearly dropping off
+					SSVertWindForce[curvert] = curWindPointForce * stage->ss->wind * step;	// *step means divide by the distance.
+				}
+			}
+		}
+		tess.SSInitializedWind = qtrue;
+	}
+	
+	for (curindex=0; curindex<input->numIndexes-2; curindex+=3)
+	{
+		curvert = input->indexes[curindex];
+		VectorCopy(input->xyz[curvert], v1);
+		if (stage->ss->facing)
+		{	// Hang down
+			if (input->normal[curvert][2] > -0.5)
+			{
+				continue;
+			}
+		}
+		else
+		{	// Point up
+			if (input->normal[curvert][2] < 0.5)
+			{
+				continue;
+			}
+		}
+		l1 = input->vertexColors[curvert][2];
+		a1 = SSVertAlpha[curvert];
+		fog1[0] = *((float *)(tess.svars.texcoords[0])+(curvert<<1));
+		fog1[1] = *((float *)(tess.svars.texcoords[0])+(curvert<<1)+1);
+		winddiff1[0] = SSVertWindDir[curvert][0];
+		winddiff1[1] = SSVertWindDir[curvert][1];
+		windforce1 = SSVertWindForce[curvert];
+
+		curvert = input->indexes[curindex+1];
+		VectorCopy(input->xyz[curvert], v2);
+		if (stage->ss->facing)
+		{	// Hang down
+			if (input->normal[curvert][2] > -0.5)
+			{
+				continue;
+			}
+		}
+		else
+		{	// Point up
+			if (input->normal[curvert][2] < 0.5)
+			{
+				continue;
+			}
+		}
+		l2 = input->vertexColors[curvert][2];
+		a2 = SSVertAlpha[curvert];
+		fog2[0] = *((float *)(tess.svars.texcoords[0])+(curvert<<1));
+		fog2[1] = *((float *)(tess.svars.texcoords[0])+(curvert<<1)+1);
+		winddiff2[0] = SSVertWindDir[curvert][0];
+		winddiff2[1] = SSVertWindDir[curvert][1];
+		windforce2 = SSVertWindForce[curvert];
+
+		curvert = input->indexes[curindex+2];
+		VectorCopy(input->xyz[curvert], v3);
+		if (stage->ss->facing)
+		{	// Hang down
+			if (input->normal[curvert][2] > -0.5)
+			{
+				continue;
+			}
+		}
+		else
+		{	// Point up
+			if (input->normal[curvert][2] < 0.5)
+			{
+				continue;
+			}
+		}
+		l3 = input->vertexColors[curvert][2];
+		a3 = SSVertAlpha[curvert];
+		fog3[0] = *((float *)(tess.svars.texcoords[0])+(curvert<<1));
+		fog3[1] = *((float *)(tess.svars.texcoords[0])+(curvert<<1)+1);
+		winddiff3[0] = SSVertWindDir[curvert][0];
+		winddiff3[1] = SSVertWindDir[curvert][1];
+		windforce3 = SSVertWindForce[curvert];
+
+		if (a1 <= 0.0 && a2 <= 0.0 && a3 <= 0.0)
+		{
+			continue;
+		}
+
+		// Find the area in order to calculate the stepsize
+		vec1to2[0] = v2[0] - v1[0];
+		vec1to2[1] = v2[1] - v1[1];
+		vec1to3[0] = v3[0] - v1[0];
+		vec1to3[1] = v3[1] - v1[1];
+
+		// Now get the cross product of this sum.
+		triarea = vec1to3[0]*vec1to2[1] - vec1to3[1]*vec1to2[0];
+		triarea=fabs(triarea);
+		if (triarea <= 1.0)
+		{	// Insanely small abhorrent triangle.
+			continue;
+		}
+		step = stage->ss->density * Q_rsqrt(triarea);
+
+		randomindex = (byte)(v1[0]+v1[1]+v2[0]+v2[1]+v3[0]+v3[1]);
+		randominterval = (byte)(v1[0]+v2[1]+v3[2])|0x03;	// Make sure the interval is at least 3, and always odd
+		rightvectorcount = 0;
+
+		for (posi=0; posi<1.0; posi+=step)
+		{
+			for (posj=0; posj<(1.0-posi); posj+=step)
+			{
+				fa=posi+randomchart[randomindex]*step;
+				randomindex += randominterval;
+
+				fb=posj+randomchart[randomindex]*step;
+				randomindex += randominterval;
+
+				rightvectorcount=(rightvectorcount+1)&3;
+
+				if (fa>1.0)
+					continue;
+
+				if (fb>(1.0-fa))
+					continue;
+
+				fc = 1.0-fa-fb;
+
+				// total alpha, minus random factor so some things fade out sooner.
+				alphapos = a1*fa + a2*fb + a3*fc;
+				
+				// Note that the alpha at this point is a value from 1.0 to 0.0, but represents when to START fading
+				thisspritesfadestart = faderange + (1.0-faderange) * randomchart[randomindex];
+				randomindex += randominterval;
+
+				// Find where the alpha is relative to the fadestart, and calc the real alpha to draw at.
+				alpha = 1.0 - ((thisspritesfadestart-alphapos)/faderange);
+				if (alpha > 0.0)
+				{
+					if (alpha > 1.0) 
+						alpha=1.0;
+
+					if (SSUsingFog)
+					{
+						fogv[0] = fog1[0]*fa + fog2[0]*fb + fog3[0]*fc;
+						fogv[1] = fog1[1]*fa + fog2[1]*fb + fog3[1]*fc;
+					}
+
+					if (usewindpoint)
+					{
+						winddiffv[0] = winddiff1[0]*fa + winddiff2[0]*fb + winddiff3[0]*fc;
+						winddiffv[1] = winddiff1[1]*fa + winddiff2[1]*fb + winddiff3[1]*fc;
+						windforce = windforce1*fa + windforce2*fb + windforce3*fc;
+					}
+			
+					VectorScale(v1, fa, curpoint);
+					VectorMA(curpoint, fb, v2, curpoint);
+					VectorMA(curpoint, fc, v3, curpoint);
+
+					light = l1*fa + l2*fb + l3*fc;
+					if (SSAdditiveTransparency)
+					{	// Additive transparency, scale light value
+//						light *= alpha;
+						light = (128 + (light*0.5))*alpha;
+						alpha = 1.0;
+					}
+
+					randomindex2 = randomindex;
+					width = stage->ss->width*(1.0 + (stage->ss->variance[0]*randomchart[randomindex2]));
+					height = stage->ss->height*(1.0 + (stage->ss->variance[1]*randomchart[randomindex2++]));
+					if (randomchart[randomindex2++]>0.5)
+					{
+						width = -width;
+					}
+					if (stage->ss->fadeScale!=0 && alphapos < 1.0)
+					{
+						width *= 1.0 + (stage->ss->fadeScale*(1.0-alphapos));
+					}
+
+					if (stage->ss->vertSkew != 0)
+					{	// flrand(-vertskew, vertskew)
+						skew[0] = height * ((stage->ss->vertSkew*2.0f*randomchart[randomindex2++])-stage->ss->vertSkew);
+						skew[1] = height * ((stage->ss->vertSkew*2.0f*randomchart[randomindex2++])-stage->ss->vertSkew);
+					}
+
+					if (usewindpoint && windforce > 0 && stage->ss->wind > 0.0)
+					{
+						if (SSUsingFog)
+						{
+							RB_VerticalSurfaceSpriteWindPoint(curpoint, width, height, (byte)light, (byte)(alpha*255.0), 
+										stage->ss->wind, stage->ss->windIdle, fogv, stage->ss->facing, skew,
+										winddiffv, windforce);
+						}
+						else
+						{
+							RB_VerticalSurfaceSpriteWindPoint(curpoint, width, height, (byte)light, (byte)(alpha*255.0), 
+										stage->ss->wind, stage->ss->windIdle, NULL, stage->ss->facing, skew, 
+										winddiffv, windforce);
+						}
+					}
+					else
+					{
+						if (SSUsingFog)
+						{
+							RB_VerticalSurfaceSprite(curpoint, width, height, (byte)light, (byte)(alpha*255.0), 
+										stage->ss->wind, stage->ss->windIdle, fogv, stage->ss->facing, skew);
+						}
+						else
+						{
+							RB_VerticalSurfaceSprite(curpoint, width, height, (byte)light, (byte)(alpha*255.0), 
+										stage->ss->wind, stage->ss->windIdle, NULL, stage->ss->facing, skew);
+						}
+					}
+
+					totalsurfsprites++;
+				}
+			}
+		}
+	}
+}
+
+
+/////////////////////////////////////////////
+// Oriented surface sprites
+
+static void RB_OrientedSurfaceSprite(vec3_t loc, float width, float height, byte light, byte alpha, vec2_t fog, int faceup)
+{
+	vec3_t loc2, right;
+	float points[16];
+	color4ub_t color;
+
+	color[0]=light;
+	color[1]=light;
+	color[2]=light;
+	color[3]=alpha;
+
+	if (faceup)
+	{
+		width *= 0.5;
+		height *= 0.5;
+
+		// Bottom right
+	//	VectorAdd(loc, right, point);
+		points[0] = loc[0] + width;
+		points[1] = loc[1] - width;
+		points[2] = loc[2] + 1.0;
+		points[3] = 0;
+
+		// Top right
+	//	VectorAdd(loc, right, point);
+		points[4] = loc[0] + width;
+		points[5] = loc[1] + width;
+		points[6] = loc[2] + 1.0;
+		points[7] = 0;
+
+		// Top left
+	//	VectorSubtract(loc, right, point);
+		points[8] = loc[0] - width;
+		points[9] = loc[1] + width;
+		points[10] = loc[2] + 1.0;
+		points[11] = 0;
+
+		// Bottom left
+	//	VectorSubtract(loc, right, point);
+		points[12] = loc[0] - width;
+		points[13] = loc[1] - width;
+		points[14] = loc[2] + 1.0;
+		points[15] = 0;
+	}
+	else
+	{
+		VectorMA(loc, height, ssViewUp, loc2);
+		VectorScale(ssViewRight, width*0.5, right);
+
+		// Bottom right
+	//	VectorAdd(loc, right, point);
+		points[0] = loc[0] + right[0];
+		points[1] = loc[1] + right[1];
+		points[2] = loc[2] + right[2];
+		points[3] = 0;
+
+		// Top right
+	//	VectorAdd(loc2, right, point);
+		points[4] = loc2[0] + right[0];
+		points[5] = loc2[1] + right[1];
+		points[6] = loc2[2] + right[2];
+		points[7] = 0;
+
+		// Top left
+	//	VectorSubtract(loc2, right, point);
+		points[8] = loc2[0] - right[0];
+		points[9] = loc2[1] - right[1];
+		points[10] = loc2[2] - right[2];
+		points[11] = 0;
+
+		// Bottom left
+	//	VectorSubtract(loc, right, point);
+		points[12] = loc[0] - right[0];
+		points[13] = loc[1] - right[1];
+		points[14] = loc[2] - right[2];
+		points[15] = 0;
+	}
+
+	// Add the sprite to the render list.
+	SQuickSprite.Add(points, color, fog);
+}
+
+static void RB_DrawOrientedSurfaceSprites( shaderStage_t *stage, shaderCommands_t *input) 
+{
+	int curindex, curvert;
+ 	vec3_t dist;
+	float triarea, minnormal;
+	vec2_t vec1to2, vec1to3;
+
+	vec3_t v1,v2,v3;
+	float a1,a2,a3;
+	float l1,l2,l3;
+	vec2_t fog1, fog2, fog3;
+
+	float posi, posj;
+	float step;
+	float fa,fb,fc;
+
+	vec3_t curpoint;
+	float width, height;
+	float alpha, alphapos, thisspritesfadestart, light;
+	byte randomindex2;
+	vec2_t fogv;
+	
+	float cutdist=stage->ss->fadeMax*rangescalefactor, cutdist2=cutdist*cutdist;
+	float fadedist=stage->ss->fadeDist*rangescalefactor, fadedist2=fadedist*fadedist;
+
+	assert(cutdist2 != fadedist2);
+	float inv_fadediff = 1.0/(cutdist2-fadedist2);
+
+	// The faderange is the fraction amount it takes for these sprites to fade out, assuming an ideal fade range of 250
+	float faderange = FADE_RANGE/(cutdist-fadedist);
+
+	if (faderange > 1.0)
+	{	// Don't want to force a new fade_rand
+		faderange = 1.0;
+	}
+
+	if (stage->ss->facing)
+	{	// Faceup sprite.
+		minnormal = 0.99f;
+	}
+	else
+	{	// Normal oriented sprite
+		minnormal = 0.5f;
+	}
+
+	// Quickly calc all the alphas for each vertex
+	for (curvert=0; curvert<input->numVertexes; curvert++)
+	{
+		// Calc alpha at each point
+		VectorSubtract(ssViewOrigin, input->xyz[curvert], dist);
+		SSVertAlpha[curvert] = 1.0 - (VectorLengthSquared(dist) - fadedist2) * inv_fadediff;
+	}
+
+	for (curindex=0; curindex<input->numIndexes-2; curindex+=3)
+	{
+		curvert = input->indexes[curindex];
+		VectorCopy(input->xyz[curvert], v1);
+		if (input->normal[curvert][2] < minnormal)
+		{
+			continue;
+		}
+		l1 = input->vertexColors[curvert][2];
+		a1 = SSVertAlpha[curvert];
+		fog1[0] = *((float *)(tess.svars.texcoords[0])+(curvert<<1));
+		fog1[1] = *((float *)(tess.svars.texcoords[0])+(curvert<<1)+1);
+
+		curvert = input->indexes[curindex+1];
+		VectorCopy(input->xyz[curvert], v2);
+		if (input->normal[curvert][2] < minnormal)
+		{
+			continue;
+		}
+		l2 = input->vertexColors[curvert][2];
+		a2 = SSVertAlpha[curvert];
+		fog2[0] = *((float *)(tess.svars.texcoords[0])+(curvert<<1));
+		fog2[1] = *((float *)(tess.svars.texcoords[0])+(curvert<<1)+1);
+
+		curvert = input->indexes[curindex+2];
+		VectorCopy(input->xyz[curvert], v3);
+		if (input->normal[curvert][2] < minnormal)
+		{
+			continue;
+		}
+		l3 = input->vertexColors[curvert][2];
+		a3 = SSVertAlpha[curvert];
+		fog3[0] = *((float *)(tess.svars.texcoords[0])+(curvert<<1));
+		fog3[1] = *((float *)(tess.svars.texcoords[0])+(curvert<<1)+1);
+
+		if (a1 <= 0.0 && a2 <= 0.0 && a3 <= 0.0)
+		{
+			continue;
+		}
+
+		// Find the area in order to calculate the stepsize
+		vec1to2[0] = v2[0] - v1[0];
+		vec1to2[1] = v2[1] - v1[1];
+		vec1to3[0] = v3[0] - v1[0];
+		vec1to3[1] = v3[1] - v1[1];
+
+		// Now get the cross product of this sum.
+		triarea = vec1to3[0]*vec1to2[1] - vec1to3[1]*vec1to2[0];
+		triarea=fabs(triarea);
+		if (triarea <= 1.0)
+		{	// Insanely small abhorrent triangle.
+			continue;
+		}
+		step = stage->ss->density * Q_rsqrt(triarea);
+
+		randomindex = (byte)(v1[0]+v1[1]+v2[0]+v2[1]+v3[0]+v3[1]);
+		randominterval = (byte)(v1[0]+v2[1]+v3[2])|0x03;	// Make sure the interval is at least 3, and always odd
+
+		for (posi=0; posi<1.0; posi+=step)
+		{
+			for (posj=0; posj<(1.0-posi); posj+=step)
+			{
+				fa=posi+randomchart[randomindex]*step;
+				randomindex += randominterval;
+				if (fa>1.0)
+					continue;
+
+				fb=posj+randomchart[randomindex]*step;
+				randomindex += randominterval;
+				if (fb>(1.0-fa))
+					continue;
+
+				fc = 1.0-fa-fb;
+
+				// total alpha, minus random factor so some things fade out sooner.
+				alphapos = a1*fa + a2*fb + a3*fc;
+				
+				// Note that the alpha at this point is a value from 1.0 to 0.0, but represents when to START fading
+				thisspritesfadestart = faderange + (1.0-faderange) * randomchart[randomindex];
+				randomindex += randominterval;
+
+				// Find where the alpha is relative to the fadestart, and calc the real alpha to draw at.
+				alpha = 1.0 - ((thisspritesfadestart-alphapos)/faderange);
+
+				randomindex += randominterval;
+				if (alpha > 0.0)
+				{
+					if (alpha > 1.0) 
+						alpha=1.0;
+
+					if (SSUsingFog)
+					{
+						fogv[0] = fog1[0]*fa + fog2[0]*fb + fog3[0]*fc;
+						fogv[1] = fog1[1]*fa + fog2[1]*fb + fog3[1]*fc;
+					}
+
+					VectorScale(v1, fa, curpoint);
+					VectorMA(curpoint, fb, v2, curpoint);
+					VectorMA(curpoint, fc, v3, curpoint);
+
+					light = l1*fa + l2*fb + l3*fc;
+					if (SSAdditiveTransparency)
+					{	// Additive transparency, scale light value
+//						light *= alpha;
+						light = (128 + (light*0.5))*alpha;
+						alpha = 1.0;
+					}
+
+					randomindex2 = randomindex;
+					width = stage->ss->width*(1.0 + (stage->ss->variance[0]*randomchart[randomindex2]));
+					height = stage->ss->height*(1.0 + (stage->ss->variance[1]*randomchart[randomindex2++]));
+					if (randomchart[randomindex2++]>0.5)
+					{
+						width = -width;
+					}
+					if (stage->ss->fadeScale!=0 && alphapos < 1.0)
+					{
+						width *= 1.0 + (stage->ss->fadeScale*(1.0-alphapos));
+					}
+
+					if (SSUsingFog)
+					{
+						RB_OrientedSurfaceSprite(curpoint, width, height, (byte)light, (byte)(alpha*255.0), fogv, stage->ss->facing);
+					}
+					else
+					{
+						RB_OrientedSurfaceSprite(curpoint, width, height, (byte)light, (byte)(alpha*255.0), NULL, stage->ss->facing);
+					}
+
+					totalsurfsprites++;
+				}
+			}
+		}
+	}
+}
+
+
+/////////////////////////////////////////////
+// Effect surface sprites
+
+static void RB_EffectSurfaceSprite(vec3_t loc, float width, float height, byte light, byte alpha, float life, int faceup)
+{
+	vec3_t loc2, right;
+	float points[16];
+	color4ub_t color;
+
+	color[0]=light;	//light;
+	color[1]=light;	//light;
+	color[2]=light;	//light;
+	color[3]=alpha;	//alpha;
+
+	if (faceup)
+	{
+		width *= 0.5;
+		height *= 0.5;
+
+		// Bottom right
+	//	VectorAdd(loc, right, point);
+		points[0] = loc[0] + width;
+		points[1] = loc[1] - width;
+		points[2] = loc[2] + 1.0;
+		points[3] = 0;
+
+		// Top right
+	//	VectorAdd(loc, right, point);
+		points[4] = loc[0] + width;
+		points[5] = loc[1] + width;
+		points[6] = loc[2] + 1.0;
+		points[7] = 0;
+
+		// Top left
+	//	VectorSubtract(loc, right, point);
+		points[8] = loc[0] - width;
+		points[9] = loc[1] + width;
+		points[10] = loc[2] + 1.0;
+		points[11] = 0;
+
+		// Bottom left
+	//	VectorSubtract(loc, right, point);
+		points[12] = loc[0] - width;
+		points[13] = loc[1] - width;
+		points[14] = loc[2] + 1.0;
+		points[15] = 0;
+	}
+	else
+	{
+		VectorMA(loc, height, ssViewUp, loc2);
+		VectorScale(ssViewRight, width*0.5, right);
+
+		// Bottom right
+	//	VectorAdd(loc, right, point);
+		points[0] = loc[0] + right[0];
+		points[1] = loc[1] + right[1];
+		points[2] = loc[2] + right[2];
+		points[3] = 0;
+
+		// Top right
+	//	VectorAdd(loc2, right, point);
+		points[4] = loc2[0] + right[0];
+		points[5] = loc2[1] + right[1];
+		points[6] = loc2[2] + right[2];
+		points[7] = 0;
+
+		// Top left
+	//	VectorSubtract(loc2, right, point);
+		points[8] = loc2[0] - right[0];
+		points[9] = loc2[1] - right[1];
+		points[10] = loc2[2] - right[2];
+		points[11] = 0;
+
+		// Bottom left
+	//	VectorSubtract(loc, right, point);
+		points[12] = loc[0] - right[0];
+		points[13] = loc[1] - right[1];
+		points[14] = loc[2] - right[2];
+		points[15] = 0;
+	}
+
+	// Add the sprite to the render list.
+	SQuickSprite.Add(points, color, NULL);
+}
+
+static void RB_DrawEffectSurfaceSprites( shaderStage_t *stage, shaderCommands_t *input) 
+{
+	int curindex, curvert;
+ 	vec3_t dist;
+	float triarea, minnormal;
+	vec2_t vec1to2, vec1to3;
+
+	vec3_t v1,v2,v3;
+	float a1,a2,a3;
+	float l1,l2,l3;
+
+	float posi, posj;
+	float step;
+	float fa,fb,fc;
+	float effecttime, effectpos;
+	float density;
+
+	vec3_t curpoint;
+	float width, height;
+	float alpha, alphapos, thisspritesfadestart, light;
+	byte randomindex2;
+	
+	float cutdist=stage->ss->fadeMax*rangescalefactor, cutdist2=cutdist*cutdist;
+	float fadedist=stage->ss->fadeDist*rangescalefactor, fadedist2=fadedist*fadedist;
+
+	float fxalpha = stage->ss->fxAlphaEnd - stage->ss->fxAlphaStart;
+	qboolean fadeinout=qfalse;
+	
+	assert(cutdist2 != fadedist2);
+	float inv_fadediff = 1.0/(cutdist2-fadedist2);
+
+	// The faderange is the fraction amount it takes for these sprites to fade out, assuming an ideal fade range of 250
+	float faderange = FADE_RANGE/(cutdist-fadedist);
+	if (faderange > 1.0f)
+	{	// Don't want to force a new fade_rand
+		faderange = 1.0f;
+	}
+
+	if (stage->ss->facing)
+	{	// Faceup sprite.
+		minnormal = 0.99f;
+	}
+	else
+	{	// Normal oriented sprite
+		minnormal = 0.5f;
+	}
+
+	// Make the object fade in.
+	if (stage->ss->fxAlphaEnd < 0.05 && stage->ss->height >= 0.1 && stage->ss->width >= 0.1)
+	{	// The sprite fades out, and it doesn't start at a pinpoint.  Let's fade it in.
+		fadeinout=qtrue;
+	}
+
+	if (stage->ss->surfaceSpriteType == SURFSPRITE_WEATHERFX)
+	{	// This effect is affected by weather settings.
+		if (curWeatherAmount < 0.01)
+		{	// Don't show these effects
+			return;
+		}
+		else
+		{
+			density = stage->ss->density / curWeatherAmount;
+		}
+	}
+	else
+	{
+		density = stage->ss->density;
+	}
+
+	// Quickly calc all the alphas for each vertex
+	for (curvert=0; curvert<input->numVertexes; curvert++)
+	{
+		// Calc alpha at each point
+		VectorSubtract(ssViewOrigin, input->xyz[curvert], dist);
+		SSVertAlpha[curvert] = 1.0f - (VectorLengthSquared(dist) - fadedist2) * inv_fadediff;
+
+	// Note this is the proper equation, but isn't used right now because it would be just a tad slower.
+		// Formula for alpha is 1.0f - ((len-fade)/(cut-fade))
+		// Which is equal to (1.0+fade/(cut-fade)) - (len/(cut-fade))
+		// So mult=1/(cut-fade), and base=(1+fade*mult).
+	//	SSVertAlpha[curvert] = fadebase - (VectorLength(dist) * fademult);
+
+	}
+
+	for (curindex=0; curindex<input->numIndexes-2; curindex+=3)
+	{
+		curvert = input->indexes[curindex];
+		VectorCopy(input->xyz[curvert], v1);
+		if (input->normal[curvert][2] < minnormal)
+		{
+			continue;
+		}
+		l1 = input->vertexColors[curvert][2];
+		a1 = SSVertAlpha[curvert];
+
+		curvert = input->indexes[curindex+1];
+		VectorCopy(input->xyz[curvert], v2);
+		if (input->normal[curvert][2] < minnormal)
+		{
+			continue;
+		}
+		l2 = input->vertexColors[curvert][2];
+		a2 = SSVertAlpha[curvert];
+
+		curvert = input->indexes[curindex+2];
+		VectorCopy(input->xyz[curvert], v3);
+		if (input->normal[curvert][2] < minnormal)
+		{
+			continue;
+		}
+		l3 = input->vertexColors[curvert][2];
+		a3 = SSVertAlpha[curvert];
+
+		if (a1 <= 0.0f && a2 <= 0.0f && a3 <= 0.0f)
+		{
+			continue;
+		}
+
+		// Find the area in order to calculate the stepsize
+		vec1to2[0] = v2[0] - v1[0];
+		vec1to2[1] = v2[1] - v1[1];
+		vec1to3[0] = v3[0] - v1[0];
+		vec1to3[1] = v3[1] - v1[1];
+
+		// Now get the cross product of this sum.
+		triarea = vec1to3[0]*vec1to2[1] - vec1to3[1]*vec1to2[0];
+		triarea=fabs(triarea);
+		if (triarea <= 1.0f)
+		{	// Insanely small abhorrent triangle.
+			continue;
+		}
+		step = density * Q_rsqrt(triarea);
+
+		randomindex = (byte)(v1[0]+v1[1]+v2[0]+v2[1]+v3[0]+v3[1]);
+		randominterval = (byte)(v1[0]+v2[1]+v3[2])|0x03;	// Make sure the interval is at least 3, and always odd
+
+		for (posi=0; posi<1.0f; posi+=step)
+		{
+			for (posj=0; posj<(1.0-posi); posj+=step)
+			{
+				effecttime = (tr.refdef.time+10000.0*randomchart[randomindex])/stage->ss->fxDuration;
+				effectpos = (float)effecttime - (int)effecttime;
+
+				randomindex2 = randomindex+effecttime;
+				randomindex += randominterval;
+				fa=posi+randomchart[randomindex2++]*step;
+				if (fa>1.0f)
+					continue;
+
+				fb=posj+randomchart[randomindex2++]*step;
+				if (fb>(1.0-fa))
+					continue;
+
+				fc = 1.0-fa-fb;
+
+				// total alpha, minus random factor so some things fade out sooner.
+				alphapos = a1*fa + a2*fb + a3*fc;
+				
+				// Note that the alpha at this point is a value from 1.0f to 0.0, but represents when to START fading
+				thisspritesfadestart = faderange + (1.0-faderange) * randomchart[randomindex2];
+				randomindex2 += randominterval;
+
+				// Find where the alpha is relative to the fadestart, and calc the real alpha to draw at.
+				alpha = 1.0f - ((thisspritesfadestart-alphapos)/faderange);
+				if (alpha > 0.0f)
+				{
+					if (alpha > 1.0f) 
+						alpha=1.0f;
+
+					VectorScale(v1, fa, curpoint);
+					VectorMA(curpoint, fb, v2, curpoint);
+					VectorMA(curpoint, fc, v3, curpoint);
+
+					light = l1*fa + l2*fb + l3*fc;
+					randomindex2 = randomindex;
+					width = stage->ss->width*(1.0f + (stage->ss->variance[0]*randomchart[randomindex2]));
+					height = stage->ss->height*(1.0f + (stage->ss->variance[1]*randomchart[randomindex2++]));
+
+					width = width + (effectpos*stage->ss->fxGrow[0]*width);
+					height = height + (effectpos*stage->ss->fxGrow[1]*height);
+
+					// If we want to fade in and out, that's different than a straight fade.
+					if (fadeinout)
+					{
+						if (effectpos > 0.5)
+						{	// Fade out
+							alpha = alpha*(stage->ss->fxAlphaStart+(fxalpha*(effectpos-0.5)*2.0));
+						}
+						else
+						{	// Fade in
+							alpha = alpha*(stage->ss->fxAlphaStart+(fxalpha*(0.5-effectpos)*2.0));
+						}
+					}
+					else
+					{	// Normal fade
+						alpha = alpha*(stage->ss->fxAlphaStart+(fxalpha*effectpos));
+					}
+
+					if (SSAdditiveTransparency)
+					{	// Additive transparency, scale light value
+//						light *= alpha;
+						light = (128 + (light*0.5))*alpha;
+						alpha = 1.0;
+					}
+
+					if (randomchart[randomindex2]>0.5f)
+					{
+						width = -width;
+					}
+					if (stage->ss->fadeScale!=0 && alphapos < 1.0f)
+					{
+						width *= 1.0f + (stage->ss->fadeScale*(1.0-alphapos));
+					}
+
+					if (stage->ss->wind>0.0f && curWindSpeed > 0.001)
+					{
+						vec3_t drawpoint;
+
+						VectorMA(curpoint, effectpos*stage->ss->wind, curWindBlowVect, drawpoint);
+						RB_EffectSurfaceSprite(drawpoint, width, height, (byte)light, (byte)(alpha*255.0f), stage->ss->fxDuration, stage->ss->facing);
+					}
+					else
+					{
+						RB_EffectSurfaceSprite(curpoint, width, height, (byte)light, (byte)(alpha*255.0f), stage->ss->fxDuration, stage->ss->facing);
+					}
+
+					totalsurfsprites++;
+				}
+			}
+		}
+	}
+}
+
+extern void R_WorldToLocal (vec3_t world, vec3_t localVec) ;
+extern float preTransEntMatrix[16], invEntMatrix[16];
+extern void R_InvertMatrix(float *sourcemat, float *destmat);
+
+void RB_DrawSurfaceSprites( shaderStage_t *stage, shaderCommands_t *input) 
+{
+	unsigned long	glbits=stage->stateBits;
+	
+	R_SurfaceSpriteFrameUpdate();
+
+	//
+	// Check fog
+	//
+	if ( tess.fogNum && tess.shader->fogPass && r_drawfog->value)
+	{
+		SSUsingFog = qtrue;
+		SQuickSprite.StartGroup(&stage->bundle[0], glbits, tess.fogNum);
+	}
+	else
+	{
+		SSUsingFog = qfalse;
+		SQuickSprite.StartGroup(&stage->bundle[0], glbits);
+	}
+
+	// Special provision in case the transparency is additive.
+	if ((glbits & (GLS_SRCBLEND_BITS|GLS_DSTBLEND_BITS)) == (GLS_SRCBLEND_ONE|GLS_DSTBLEND_ONE))
+	{	// Additive transparency, scale light value
+		SSAdditiveTransparency=qtrue;
+	}
+	else
+	{
+		SSAdditiveTransparency=qfalse;
+	}
+
+
+	//Check if this is a new entity transformation (incl. world entity), and update the appropriate vectors if so.
+	if (backEnd.currentEntity != ssLastEntityDrawn)
+	{	
+		if (backEnd.currentEntity == &tr.worldEntity)
+		{	// Drawing the world, so our job is dead-easy, in the viewparms
+			VectorCopy(backEnd.viewParms.ori.origin, ssViewOrigin);
+			VectorCopy(backEnd.viewParms.ori.axis[1], ssViewRight);
+			VectorCopy(backEnd.viewParms.ori.axis[2], ssViewUp);
+		}
+		else
+		{	// Drawing an entity, so we need to transform the viewparms to the model's coordinate system
+//			R_WorldPointToEntity (backEnd.viewParms.ori.origin, ssViewOrigin);
+			R_WorldNormalToEntity (backEnd.viewParms.ori.axis[1], ssViewRight); 
+			R_WorldNormalToEntity (backEnd.viewParms.ori.axis[2], ssViewUp);
+			VectorCopy(backEnd.ori.viewOrigin, ssViewOrigin);
+//			R_WorldToLocal(backEnd.viewParms.ori.axis[1], ssViewRight);
+//			R_WorldToLocal(backEnd.viewParms.ori.axis[2], ssViewUp);
+		}
+		ssLastEntityDrawn = backEnd.currentEntity;
+	}
+
+	switch(stage->ss->surfaceSpriteType)
+	{
+	case SURFSPRITE_VERTICAL:
+		RB_DrawVerticalSurfaceSprites(stage, input);
+		break;
+	case SURFSPRITE_ORIENTED:
+		RB_DrawOrientedSurfaceSprites(stage, input);
+		break;
+	case SURFSPRITE_EFFECT:
+	case SURFSPRITE_WEATHERFX:
+		RB_DrawEffectSurfaceSprites(stage, input);
+		break;
+	}
+
+	SQuickSprite.EndGroup();
+
+	sssurfaces++;
+}
+
diff --git a/codemp/renderer/tr_terrain.cpp b/codemp/renderer/tr_terrain.cpp
new file mode 100644
index 0000000..db51b61
--- /dev/null
+++ b/codemp/renderer/tr_terrain.cpp
@@ -0,0 +1,1056 @@
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+// this include must remain at the top of every CPP file
+#include "tr_local.h"
+
+#if !defined(GENERICPARSER2_H_INC)
+	#include "../qcommon/GenericParser2.h"
+#endif
+
+// To do:
+// Alter variance dependent on global distance from player (colour code this for cg_terrainCollisionDebug)
+// Improve texture blending on edge conditions
+// Link to neightbouring terrains or architecture (edge conditions)
+// Post process generated light data to make sure there are no bands within a patch
+
+#include "../qcommon/cm_landscape.h"
+#include "tr_landscape.h"
+
+cvar_t		*r_drawTerrain;
+cvar_t		*r_showFrameVariance;
+cvar_t		*r_terrainTessellate;
+cvar_t		*r_terrainWaterOffset;
+
+static int		TerrainFog = 0;
+static float	TerrainDistanceCull;
+
+//
+// Render the tree.
+//
+void CTRPatch::RenderCorner(ivec5_t corner)
+{
+	if((corner[3] < 0) || (tess.registration != corner[4]))
+	{
+		CTerVert	*vert;
+
+		vert = mRenderMap + (corner[1] * owner->GetRealWidth()) + corner[0];
+
+		VectorCopy(vert->coords, tess.xyz[tess.numVertexes]);
+		VectorCopy(vert->normal, tess.normal[tess.numVertexes]);
+
+		*(ulong *)tess.vertexColors[tess.numVertexes] = *(ulong *)vert->tint;
+		*(ulong *)tess.vertexAlphas[tess.numVertexes] = corner[2];
+
+		tess.texCoords[tess.numVertexes][0][0] = vert->tex[0]; //rwwRMG - reverse coords array from sof2
+		tess.texCoords[tess.numVertexes][0][1] = vert->tex[1];
+
+		tess.indexes[tess.numIndexes++] = tess.numVertexes;
+		corner[3] = tess.numVertexes++;
+		corner[4] = tess.registration;
+	}
+	else
+	{
+		tess.indexes[tess.numIndexes++] = corner[3];
+	}
+}
+
+void CTRPatch::RecurseRender(int depth, ivec5_t left, ivec5_t right, ivec5_t apex)
+{
+	// All non-leaf nodes have both children, so just check for one
+	if (depth >= 0)
+	{
+		ivec5_t		center;
+		byte		*centerAlphas;
+		byte		*leftAlphas;
+		byte		*rightAlphas;
+
+		// Work out the centre of the hypoteneuse
+		center[0] = (left[0] + right[0]) >> 1;
+		center[1] = (left[1] + right[1]) >> 1;
+		
+		// Work out the relevant texture coefficients at that point
+		leftAlphas = (byte *)&left[2];
+		rightAlphas = (byte *)&right[2];
+		centerAlphas = (byte *)&center[2];
+
+		centerAlphas[0] = (leftAlphas[0] + rightAlphas[0]) >> 1;
+		centerAlphas[1] = (leftAlphas[1] + rightAlphas[1]) >> 1;
+		centerAlphas[2] = (leftAlphas[2] + rightAlphas[2]) >> 1;
+		centerAlphas[3] = (leftAlphas[3] + rightAlphas[3]) >> 1;
+
+		// Make sure the vert index and tesselation registration are not set
+		center[3] = -1;
+		center[4] = 0;
+
+		if (apex[0] == left[0] && apex[0] == center[0])
+		{
+			depth = 0;
+		}
+
+		RecurseRender(depth-1, apex, left, center);
+		RecurseRender(depth-1, right, apex, center);
+	}
+	else										
+	{
+		if (left[0] == right[0] && left[0] == apex[0])
+		{
+			return;
+		}
+		if (left[1] == right[1] && left[1] == apex[1])
+		{
+			return;
+		}
+		// A leaf node!  Output a triangle to be rendered.
+		RB_CheckOverflow(4, 4);
+
+//		assert(left[0] != right[0] || left[1] != right[1]);
+//		assert(left[0] != apex[0] || left[1] != apex[1]);
+
+	  	RenderCorner(left);
+		RenderCorner(right);
+		RenderCorner(apex);
+	}
+}
+
+//
+// Render the mesh.
+//
+// The order of triangles is critical to the subdivision working
+
+void CTRPatch::Render(int Part)
+{
+	ivec5_t		TL, TR, BL, BR;
+
+	VectorSet5(TL, 0, 0, TEXTURE_ALPHA_TL, -1, 0);
+	VectorSet5(TR, owner->GetTerxels(), 0, TEXTURE_ALPHA_TR, -1, 0);
+	VectorSet5(BL, 0, owner->GetTerxels(), TEXTURE_ALPHA_BL, -1, 0);
+	VectorSet5(BR, owner->GetTerxels(), owner->GetTerxels(), TEXTURE_ALPHA_BR, -1, 0);
+
+	if ((Part & PI_TOP) && mTLShader)
+	{
+/*		float		d;
+
+		d = DotProduct (backEnd.refdef.vieworg, mNormal[0]) - mDistance[0];
+
+		if (d <= 0.0)*/
+		{
+			RecurseRender(r_terrainTessellate->integer, BL, TR, TL);
+		}
+	}
+	
+	if ((Part & PI_BOTTOM) && mBRShader)
+	{
+/*		float		d;
+
+		d = DotProduct (backEnd.refdef.vieworg, mNormal[1]) - mDistance[1];
+
+		if (d >= 0.0)*/
+		{
+			RecurseRender(r_terrainTessellate->integer, TR, BL, BR);
+		}
+	}
+}
+
+//
+// At this point the patch is visible and at least part of it is below water level
+//
+int CTRPatch::RenderWaterVert(int x, int y)
+{
+	CTerVert	*vert;
+
+	vert = mRenderMap + x + (y * owner->GetRealWidth());
+
+	if(vert->tessRegistration == tess.registration)
+	{
+		return(vert->tessIndex);
+	}
+	tess.xyz[tess.numVertexes][0] = vert->coords[0];
+	tess.xyz[tess.numVertexes][1] = vert->coords[1];
+	tess.xyz[tess.numVertexes][2] = owner->GetWaterHeight();
+
+	*(ulong *)tess.vertexColors[tess.numVertexes] = 0xffffffff;
+
+	tess.texCoords[tess.numVertexes][0][0] = vert->tex[0]; //rwwRMG - reverse coords from sof2mp
+	tess.texCoords[tess.numVertexes][0][1] = vert->tex[1];
+
+	vert->tessIndex = tess.numVertexes;
+	vert->tessRegistration = tess.registration;
+
+	tess.numVertexes++;
+	return(vert->tessIndex);
+}
+
+void CTRPatch::RenderWater(void)
+{
+	RB_CheckOverflow(4, 6);
+
+	// Get the neighbouring patches
+	int TL = RenderWaterVert(0, 0);
+	int TR = RenderWaterVert(owner->GetTerxels(), 0);
+	int BL = RenderWaterVert(0, owner->GetTerxels());
+	int BR = RenderWaterVert(owner->GetTerxels(), owner->GetTerxels());
+
+	// TL
+	tess.indexes[tess.numIndexes++] = BL;
+	tess.indexes[tess.numIndexes++] = TR;
+	tess.indexes[tess.numIndexes++] = TL;
+
+	// BR
+	tess.indexes[tess.numIndexes++] = TR;
+	tess.indexes[tess.numIndexes++] = BL;
+	tess.indexes[tess.numIndexes++] = BR;
+}
+
+const bool CTRPatch::HasWater(void) const
+{
+	owner->SetRealWaterHeight( owner->GetBaseWaterHeight() + r_terrainWaterOffset->integer );
+	return(common->GetMins()[2] < owner->GetWaterHeight()); 
+}
+
+extern bool CM_CullWorldBox (const cplane_t *frustum, const vec3pair_t bounds); //rwwRMG - added (cm_trace.cpp)
+
+void CTRPatch::SetVisibility(bool visCheck)
+{
+	if(visCheck)
+	{
+		if(DistanceSquared(mCenter, backEnd.refdef.vieworg) > TerrainDistanceCull)
+		{
+			misVisible = false;
+		}
+		else
+		{
+			// Set the visibility of the patch
+			misVisible = !CM_CullWorldBox(backEnd.viewParms.frustum, GetBounds());
+		}
+	}
+	else
+	{
+		misVisible = true;
+	}
+}
+
+/*
+void CTRPatch::CalcNormal(void)
+{
+	CTerVert	*vert1, *vert2, *vert3;
+	ivec5_t		TL, TR, BL, BR;
+	vec3_t		v1, v2;
+
+	VectorSet5(TL, 0, 0, TEXTURE_ALPHA_TL, -1, 0);
+	VectorSet5(TR, owner->GetTerxels(), 0, TEXTURE_ALPHA_TR, -1, 0);
+	VectorSet5(BL, 0, owner->GetTerxels(), TEXTURE_ALPHA_BL, -1, 0);
+	VectorSet5(BR, owner->GetTerxels(), owner->GetTerxels(), TEXTURE_ALPHA_BR, -1, 0);
+
+	vert1 = mRenderMap + (BL[1] * owner->GetRealWidth()) + BL[0];
+	vert2 = mRenderMap + (TR[1] * owner->GetRealWidth()) + TR[0];
+	vert3 = mRenderMap + (TL[1] * owner->GetRealWidth()) + TL[0];
+	VectorSubtract(vert2->coords, vert1->coords, v1);
+	VectorSubtract(vert3->coords, vert1->coords, v2);
+	CrossProduct(v1, v2, mNormal[0]);
+	VectorNormalize(mNormal[0]);
+	mDistance[0] = DotProduct (vert1->coords, mNormal[0]);
+
+	vert1 = mRenderMap + (BL[1] * owner->GetRealWidth()) + BL[0];
+	vert2 = mRenderMap + (TR[1] * owner->GetRealWidth()) + TR[0];
+	vert3 = mRenderMap + (BR[1] * owner->GetRealWidth()) + BR[0];
+	VectorSubtract(vert2->coords, vert1->coords, v1);
+	VectorSubtract(vert3->coords, vert1->coords, v2);
+	CrossProduct(v1, v2, mNormal[1]);
+	VectorNormalize(mNormal[1]);
+	mDistance[1] = DotProduct (vert1->coords, mNormal[1]);
+}
+*/
+//
+// Reset all patches, recompute variance if needed
+//
+void CTRLandScape::Reset(bool visCheck)
+{
+	int			x, y;
+	CTRPatch	*patch;
+
+	TerrainDistanceCull = tr.distanceCull + mPatchSize;
+	TerrainDistanceCull *= TerrainDistanceCull;
+
+	// Go through the patches performing resets, compute variances, and linking.
+	for(y = mPatchMiny; y < mPatchMaxy; y++)
+	{
+		for(x = mPatchMinx; x < mPatchMaxx; x++, patch++)
+		{
+			patch = GetPatch(x, y);
+			patch->SetVisibility(visCheck);
+		}
+	}
+}
+
+
+//
+// Render each patch of the landscape & adjust the frame variance.
+//
+
+void CTRLandScape::Render(void)
+{
+	int			x, y;
+	CTRPatch	*patch;
+	TPatchInfo	*current;
+	int			i;
+	
+	// Render all the visible patches
+	current = mSortedPatches;
+	for(i=0;i<mSortedCount;i++)
+	{
+		if (current->mPatch->isVisible())
+		{
+			if (tess.shader != current->mShader)
+			{
+				RB_EndSurface();
+				RB_BeginSurface(current->mShader, TerrainFog);
+			}
+			current->mPatch->Render(current->mPart);
+		}
+		current++;
+	}
+	RB_EndSurface();
+
+	// Render all the water for visible patches
+	// Done as a separate iteration to reduce the number of tesses created
+	if(mWaterShader && (mWaterShader != tr.defaultShader))
+	{
+		RB_BeginSurface( mWaterShader, tr.world->globalFog );
+
+		for(y = mPatchMiny; y < mPatchMaxy; y++ )
+		{
+			for(x = mPatchMinx; x < mPatchMaxx; x++ )
+			{
+				patch = GetPatch(x, y);
+				if(patch->isVisible() && patch->HasWater())
+				{
+					patch->RenderWater();
+				}
+			}
+		}
+		RB_EndSurface();
+	}
+}
+
+void CTRLandScape::CalculateRegion(void)
+{
+	vec3_t	mins, maxs, size, offset;
+
+#if	_DEBUG
+	mCycleCount++;
+#endif
+	VectorCopy(GetPatchSize(), size);
+	VectorCopy(GetMins(), offset);
+
+	mins[0] = backEnd.refdef.vieworg[0] - tr.distanceCull - (size[0] * 2.0f) - offset[0];
+	mins[1] = backEnd.refdef.vieworg[1] - tr.distanceCull - (size[1] * 2.0f) - offset[1];
+
+	maxs[0] = backEnd.refdef.vieworg[0] + tr.distanceCull + (size[0] * 2.0f) - offset[0];
+	maxs[1] = backEnd.refdef.vieworg[1] + tr.distanceCull + (size[1] * 2.0f) - offset[1];
+
+	mPatchMinx = Com_Clampi(0, GetBlockWidth(), floorf(mins[0] / size[0]));
+	mPatchMaxx = Com_Clampi(0, GetBlockWidth(), ceilf(maxs[0] / size[0]));
+
+	mPatchMiny = Com_Clampi(0, GetBlockHeight(), floorf(mins[1] / size[1]));
+	mPatchMaxy = Com_Clampi(0, GetBlockHeight(), ceilf(maxs[1] / size[1]));
+}
+
+void CTRLandScape::CalculateRealCoords(void)
+{
+	int			x, y;
+
+	// Work out the real world coordinates of each heightmap entry
+	for(y = 0; y < GetRealHeight(); y++)
+	{
+		for(x = 0; x < GetRealWidth(); x++)
+		{
+			ivec3_t		icoords;
+			int			offset;
+
+			offset = (y * GetRealWidth()) + x;
+
+			VectorSet(icoords, x, y, mRenderMap[offset].height);
+			VectorScaleVectorAdd(GetMins(), icoords, GetTerxelSize(), mRenderMap[offset].coords);
+		}
+	}
+}
+
+void CTRLandScape::CalculateNormals(void)
+{
+	int		x, y, offset = 0;
+
+	// Work out the normals for every face
+	for(y = 0; y < GetHeight(); y++)
+	{
+		for(x = 0; x < GetWidth(); x++)
+		{
+			vec3_t		vcenter, vleft;
+			
+			offset = (y * GetRealWidth()) + x;
+
+			VectorSubtract(mRenderMap[offset].coords, mRenderMap[offset + 1].coords, vcenter);
+			VectorSubtract(mRenderMap[offset].coords, mRenderMap[offset + GetRealWidth()].coords, vleft);
+
+			CrossProduct(vcenter, vleft, mRenderMap[offset].normal);
+			VectorNormalize(mRenderMap[offset].normal);
+		}
+		// Duplicate right edge condition
+		VectorCopy(mRenderMap[offset].normal, mRenderMap[offset + 1].normal);
+	}
+	// Duplicate bottom line
+	offset = GetHeight() * GetRealWidth();
+	for(x = 0; x < GetRealWidth(); x++)
+	{
+		VectorCopy(mRenderMap[offset - GetRealWidth() + x].normal, mRenderMap[offset + x].normal);
+	}
+}
+
+void CTRLandScape::CalculateLighting(void)
+{
+	int		x, y, offset = 0;
+
+	// Work out the vertex normal (average of every attached face normal) and apply to the direction of the light
+	for(y = 0; y < GetHeight(); y++)
+	{
+		for(x = 0; x < GetWidth(); x++)
+		{
+			vec3_t		ambient;
+			vec3_t		directed, direction;
+			vec3_t		total, tint;
+			vec_t		dp;
+			
+			offset = (y * GetRealWidth()) + x;
+			
+			// Work out average normal
+		   	VectorCopy(GetRenderMap(x, y)->normal, total);
+		   	VectorAdd(total, GetRenderMap(x + 1, y)->normal, total);
+		   	VectorAdd(total, GetRenderMap(x + 1, y + 1)->normal, total);
+		   	VectorAdd(total, GetRenderMap(x, y + 1)->normal, total);
+			VectorNormalize(total);
+
+			if (!R_LightForPoint(mRenderMap[offset].coords, ambient, directed, direction))
+			{
+				mRenderMap[offset].tint[0] = 
+					mRenderMap[offset].tint[1] =
+					mRenderMap[offset].tint[2] = 255 >> tr.overbrightBits;
+				mRenderMap[offset].tint[3] = 255;
+				continue;
+			}
+
+			if(mRenderMap[offset].coords[2] < common->GetBaseWaterHeight())
+			{
+				VectorScale(ambient, 0.75f, ambient);
+			}
+
+			// Both normalised, so -1.0 < dp < 1.0
+			dp = Com_Clampi(0.0f, 1.0f, DotProduct(direction, total));
+			dp = powf(dp, 3);
+			VectorScale(ambient, (1.0 - dp) * 0.5, ambient);
+			VectorMA(ambient, dp, directed, tint);
+
+			mRenderMap[offset].tint[0] = (byte)Com_Clampi(0.0f, 255.0f, tint[0] ) >> tr.overbrightBits;
+			mRenderMap[offset].tint[1] = (byte)Com_Clampi(0.0f, 255.0f, tint[1] ) >> tr.overbrightBits;
+			mRenderMap[offset].tint[2] = (byte)Com_Clampi(0.0f, 255.0f, tint[2] ) >> tr.overbrightBits;
+			mRenderMap[offset].tint[3] = 0xff;
+
+			/*
+			mRenderMap[offset].tint[0] += tr.identityLight * 32;
+			mRenderMap[offset].tint[1] += tr.identityLight * 32;
+			mRenderMap[offset].tint[2] += tr.identityLight * 32;
+			*/
+		}
+		mRenderMap[offset + 1].tint[0] = mRenderMap[offset].tint[0];
+		mRenderMap[offset + 1].tint[1] = mRenderMap[offset].tint[1];
+		mRenderMap[offset + 1].tint[2] = mRenderMap[offset].tint[2];
+		mRenderMap[offset + 1].tint[3] = 0xff;
+	}
+	// Duplicate bottom line
+	offset = GetHeight() * GetRealWidth();
+	for(x = 0; x < GetRealWidth(); x++)
+	{
+		mRenderMap[offset + x].tint[0] = mRenderMap[offset - GetRealWidth() + x].tint[0];
+		mRenderMap[offset + x].tint[1] = mRenderMap[offset - GetRealWidth() + x].tint[1];
+		mRenderMap[offset + x].tint[2] = mRenderMap[offset - GetRealWidth() + x].tint[2];
+		mRenderMap[offset + x].tint[3] = 0xff;
+	}
+}
+
+void CTRLandScape::CalculateTextureCoords(void)
+{
+	int		x, y;
+
+	for(y = 0; y < GetRealHeight(); y++)
+	{
+		for(x = 0; x < GetRealWidth(); x++)
+		{
+			int offset = (y * GetRealWidth()) + x;
+
+			mRenderMap[offset].tex[0] = x * mTextureScale * GetTerxelSize()[0];
+			mRenderMap[offset].tex[1] = y * mTextureScale * GetTerxelSize()[1];
+		}
+	}
+}
+
+void CTRLandScape::SetShaders(const int height, const qhandle_t shader)
+{
+	int		i;
+
+	for(i = height; shader && (i < HEIGHT_RESOLUTION); i++)
+	{
+		if(!mHeightDetails[i].GetShader())
+		{
+			mHeightDetails[i].SetShader(shader);
+		}
+	}
+}
+
+void CTRLandScape::LoadTerrainDef(const char *td)
+{
+#ifndef PRE_RELEASE_DEMO
+	char			terrainDef[MAX_QPATH];
+	CGenericParser2	parse;
+	CGPGroup		*basegroup, *classes, *items;
+
+	Com_sprintf(terrainDef, MAX_QPATH, "ext_data/RMG/%s.terrain", td);
+	Com_Printf("R_Terrain: Loading and parsing terrainDef %s.....\n", td);
+
+	mWaterShader = NULL;
+	mFlatShader  = NULL;
+
+	if(!Com_ParseTextFile(terrainDef, parse))
+	{
+		Com_sprintf(terrainDef, MAX_QPATH, "ext_data/arioche/%s.terrain", td);
+		if(!Com_ParseTextFile(terrainDef, parse))
+		{
+			Com_Printf("Could not open %s\n", terrainDef);
+			return;
+		}
+	}
+	// The whole file....
+	basegroup = parse.GetBaseParseGroup();
+
+	// The root { } struct
+	classes = basegroup->GetSubGroups();
+	while(classes)
+	{
+		items = classes->GetSubGroups();
+		while(items)
+		{
+			const char* type = items->GetName ( );
+
+			if(!stricmp( type, "altitudetexture"))
+			{
+				int			height;
+				const char	*shaderName;
+			  	qhandle_t	shader;
+
+				// Height must exist - the rest are optional
+				height = atol(items->FindPairValue("height", "0"));
+
+				// Shader for this height
+				shaderName = items->FindPairValue("shader", "");
+				if(strlen(shaderName))
+				{
+					shader = RE_RegisterShader(shaderName);
+					if(shader)
+					{
+						SetShaders(height, shader); 
+					}
+				}
+			}
+			else if(!stricmp(type, "water"))
+			{
+				mWaterShader = R_GetShaderByHandle(RE_RegisterShader(items->FindPairValue("shader", "")));
+			}
+			else if(!stricmp(type, "flattexture"))
+			{
+				mFlatShader = RE_RegisterShader ( items->FindPairValue("shader", "") );
+			}
+
+			items = (CGPGroup *)items->GetNext();
+		}
+		classes = (CGPGroup *)classes->GetNext();
+	}
+	
+	Com_ParseTextFileDestroy(parse);
+#endif // PRE_RELEASE_DEMO
+}
+
+qhandle_t CTRLandScape::GetBlendedShader(qhandle_t a, qhandle_t b, qhandle_t c, bool surfaceSprites)
+{
+	qhandle_t	blended;
+
+	// Special case single pass shader
+	if((a == b) && (a == c))
+	{
+		return(a);
+	}
+
+	blended = R_CreateBlendedShader(a, b, c, surfaceSprites );
+	return(blended);
+}
+
+static int ComparePatchInfo(const TPatchInfo *arg1, const TPatchInfo *arg2)
+{
+	shader_t	*s1, *s2;
+
+	if ((arg1->mPart & PI_TOP))
+	{
+		s1 = arg1->mPatch->GetTLShader();
+	}
+	else
+	{
+		s1 = arg1->mPatch->GetBRShader();
+	}
+
+	if ((arg2->mPart & PI_TOP))
+	{
+		s2 = arg2->mPatch->GetTLShader();
+	}
+	else
+	{
+		s2 = arg2->mPatch->GetBRShader();
+	}
+
+	if (s1 < s2)
+	{
+		return -1;
+	}
+	else if (s1 > s2)
+	{
+		return 1;
+	}
+
+	return 0;
+}
+
+void CTRLandScape::CalculateShaders(void)
+{
+#ifndef PRE_RELEASE_DEMO
+	int						x, y;
+	int						width, height;
+	int						offset;
+//	int						offsets[4];
+	qhandle_t				handles[4];
+	CTRPatch				*patch;
+	qhandle_t				*shaders;
+	TPatchInfo				*current = mSortedPatches;
+	
+	width  = GetWidth ( ) / common->GetTerxels ( );
+	height = GetHeight ( ) / common->GetTerxels ( );
+
+	shaders = new qhandle_t [ (width+1) * (height+1) ];
+
+	// On the first pass determine all of the shaders for the entire 
+	// terrain assuming no flat ground
+	offset = 0;
+	for ( y = 0; y < height + 1; y ++ )
+	{
+		if ( y <= height )
+		{
+			offset = common->GetTerxels ( ) * y * GetRealWidth ( );		
+		}
+		else
+		{
+			offset = common->GetTerxels ( ) * (y-1) * GetRealWidth ( );	
+			offset += GetRealWidth ( );
+		}
+
+		for ( x = 0; x < width + 1; x ++, offset += common->GetTerxels ( ) )
+		{
+			// Save the shader
+			shaders[y * width + x] = GetHeightDetail(mRenderMap[offset].height)->GetShader ( );
+		}
+	}
+
+	// On the second pass determine flat ground and replace the shader
+	// at that point with the flat ground shader
+	if ( mFlatShader )
+	{
+		for ( y = 1; y < height; y ++ )
+		{
+			for ( x = 1; x < width; x ++ )
+			{
+				int		offset;
+				int		xx;
+				int		yy;
+				byte*	flattenMap = common->GetFlattenMap ( );
+				bool	flat	   = false;
+
+				offset  = (x) * common->GetTerxels ( );
+				offset += (y) * common->GetTerxels ( ) * GetRealWidth();
+
+				offset -= GetRealWidth();
+				offset -= 1;
+				
+				for ( yy = 0; yy < 3 && !flat; yy++ )
+				{
+					for ( xx = 0; xx < 3 && !flat; xx++ )
+					{
+						if ( flattenMap [ offset + xx] & 0x80)
+						{
+							flat = true;
+							break;
+						}		
+					}
+
+					offset += GetRealWidth();
+				}
+
+/*
+				// Calculate the height map offset
+				offset  = x * common->GetTerxels ( );
+				offset += (y * common->GetTerxels ( ) * GetRealWidth());
+
+				// Calculate the offsets around this particular shader location
+				offsets[INDEX_TL] = offset - 1 - GetRealWidth();
+				offsets[INDEX_TR] = offsets[INDEX_TL] + 1;
+				offsets[INDEX_BL] = offsets[INDEX_TL] + GetRealWidth();
+				offsets[INDEX_BR] = offsets[INDEX_BL] + 1;
+
+				// If not equal to the top left one then skip
+				if ( mRenderMap[offset].height != mRenderMap[offsets[INDEX_TL]].height )
+				{
+					continue;
+				}
+
+				// If not equal to the top right one then skip
+				if ( mRenderMap[offset].height != mRenderMap[offsets[INDEX_TR]].height )
+				{
+					continue;
+				}
+
+				// If not equal to the bottom left one then skip
+				if ( mRenderMap[offset].height != mRenderMap[offsets[INDEX_BL]].height )
+				{
+					continue;
+				}
+
+				// If not equal to the bottom right one then skip
+				if ( mRenderMap[offset].height != mRenderMap[offsets[INDEX_BR]].height )
+				{
+					continue;
+				}
+	*/
+
+				// This shader is now a flat shader
+				if ( flat )
+				{
+					shaders[y * width + x] = mFlatShader;
+				}
+
+#ifdef _DEBUG
+				OutputDebugString ( va("Flat Area:  %f %f\n", 
+									GetMins()[0] + (GetMaxs()[0]-GetMins()[0])/width * x,
+									GetMins()[1] + (GetMaxs()[1]-GetMins()[1])/height * y) );
+#endif
+			}
+		}
+	}
+
+	// Now that the shaders have been determined, set them for each patch
+	patch = mTRPatches;
+	mSortedCount = 0;
+	for ( y = 0; y < height; y ++ )
+	{
+		for ( x = 0; x < width; x ++, patch++ )
+		{
+			bool surfaceSprites = true;
+
+			handles[INDEX_TL] = shaders[ x + y * width ];
+			handles[INDEX_TR] = shaders[ x + 1 + y * width ];
+			handles[INDEX_BL] = shaders[ x + (y + 1) * width ];
+			handles[INDEX_BR] = shaders[ x + 1 + (y + 1) * width ];
+			
+			if ( handles[INDEX_TL] == mFlatShader ||
+				 handles[INDEX_TR] == mFlatShader ||
+				 handles[INDEX_BL] == mFlatShader ||
+				 handles[INDEX_BR] == mFlatShader    )
+			{
+				surfaceSprites = false;
+			}
+
+			patch->SetTLShader(GetBlendedShader(handles[INDEX_TR], handles[INDEX_BL], handles[INDEX_TL], surfaceSprites));
+			current->mPatch = patch;
+			current->mShader = patch->GetTLShader();
+			current->mPart = PI_TOP;
+			
+			patch->SetBRShader(GetBlendedShader(handles[INDEX_TR], handles[INDEX_BL], handles[INDEX_BR], surfaceSprites));
+			if (patch->GetBRShader() == current->mShader)
+			{
+				current->mPart |= PI_BOTTOM;
+			}
+			else
+			{
+				mSortedCount++;
+				current++;
+
+				current->mPatch = patch;
+				current->mShader = patch->GetBRShader();
+				current->mPart = PI_BOTTOM;
+			}
+			mSortedCount++;
+			current++;
+		}
+	}
+
+	// Cleanup our temporary array
+	delete[] shaders;
+
+	qsort(mSortedPatches, mSortedCount, sizeof(*mSortedPatches), (int (__cdecl *)(const void *,const void *))ComparePatchInfo);
+
+#endif // PRE_RELEASE_DEMO
+}
+
+void CTRPatch::SetRenderMap(const int x, const int y) 
+{ 
+	mRenderMap = localowner->GetRenderMap(x, y); 
+}
+
+void InitRendererPatches( CCMPatch *patch, void *userdata )
+{
+	int			  	tx, ty, bx, by;
+	CTRPatch	  	*localpatch;
+	CCMLandScape	*owner;
+	CTRLandScape	*localowner;
+
+	// Set owning landscape
+	localowner = (CTRLandScape *)userdata;
+	owner = (CCMLandScape *)localowner->GetCommon();
+
+	// Get TRPatch pointer
+	tx = patch->GetHeightMapX();
+	ty = patch->GetHeightMapY();
+	bx = tx / owner->GetTerxels();
+	by = ty / owner->GetTerxels();
+
+	localpatch = localowner->GetPatch(bx, by);
+	localpatch->Clear();
+
+	localpatch->SetCommon(patch);
+	localpatch->SetOwner(owner);
+	localpatch->SetLocalOwner(localowner);
+	localpatch->SetRenderMap(tx, ty);
+	localpatch->SetCenter();
+//	localpatch->CalcNormal();
+}
+
+void CTRLandScape::CopyHeightMap(void)
+{
+	const CCMLandScape	*common = GetCommon();
+	const byte			*heightMap = common->GetHeightMap();
+	CTerVert			*renderMap = mRenderMap;
+	int					i;
+
+	for(i = 0; i < common->GetRealArea(); i++)
+	{
+		renderMap->height = *heightMap;
+		renderMap++;
+		heightMap++;
+	}
+}
+
+CTRLandScape::~CTRLandScape(void)
+{
+	if(mTRPatches)
+	{
+		Z_Free(mTRPatches);
+		mTRPatches = NULL;
+	}
+	if (mSortedPatches)
+	{
+		Z_Free(mSortedPatches);
+		mSortedPatches = 0;
+	}
+	if(mRenderMap)
+	{
+		Z_Free(mRenderMap);
+		mRenderMap = NULL;
+	}
+}
+
+extern CCMLandScape *CM_RegisterTerrain(const char *config, bool server);	//cm_load.cpp
+
+CTRLandScape::CTRLandScape(const char *configstring)
+{
+#ifndef PRE_RELEASE_DEMO
+	int					shaderNum;
+	const CCMLandScape	*common;
+
+	memset(this, 0, sizeof(*this));
+
+	// Sets up the common aspects of the terrain
+	common = CM_RegisterTerrain(configstring, false);
+	SetCommon(common);
+
+	tr.landScape.landscape = this;
+
+	mTextureScale = (float)atof(Info_ValueForKey(configstring, "texturescale")) / common->GetTerxels();
+	LoadTerrainDef(Info_ValueForKey(configstring, "terrainDef"));
+
+	// To normalise the variance value to a reasonable number
+	mScalarSize = VectorLengthSquared(common->GetSize());
+
+	// Calculate and set variance depth
+	mMaxNode = (Q_log2(common->GetTerxels()) << 1) - 1;
+
+	// Allocate space for the renderer specific data
+	mRenderMap = (CTerVert *)Z_Malloc(sizeof(CTerVert) * common->GetRealArea(), TAG_R_TERRAIN);
+
+	// Copy byte heightmap to rendermap to speed up calcs
+	CopyHeightMap();
+
+	// Calculate the real world location for each heightmap entry
+	CalculateRealCoords();
+
+	// Calculate the normal of each terxel
+	CalculateNormals();
+
+	// Calculate modulation values for the heightmap
+	CalculateLighting();
+
+	// Calculate texture coords (not projected - real)
+	CalculateTextureCoords();
+
+	Com_Printf ("R_Terrain: Creating renderer patches.....\n");
+	// Initialise all terrain patches
+	mTRPatches = (CTRPatch *)Z_Malloc(sizeof(CTRPatch) * common->GetBlockCount(), TAG_R_TERRAIN); 
+
+	mSortedCount = 2 * common->GetBlockCount();
+	mSortedPatches = (TPatchInfo *)Z_Malloc(sizeof(TPatchInfo) * mSortedCount, TAG_R_TERRAIN);
+
+	CM_TerrainPatchIterate(common, InitRendererPatches, this);
+
+	// Calculate shaders dependent on the .terrain file
+	CalculateShaders();
+
+	// Get the contents shader
+	shaderNum = atol(Info_ValueForKey(configstring, "shader"));;
+	mShader = R_GetShaderByHandle(R_GetShaderByNum(shaderNum, *tr.world));
+
+	mPatchSize = VectorLength(common->GetPatchSize());
+
+#if	_DEBUG
+	mCycleCount = 0;
+#endif
+#endif // PRE_RELEASE_DEMO
+}
+
+// ---------------------------------------------------------------------
+
+void RB_SurfaceTerrain( surfaceInfo_t *surf )
+{
+	/*
+	if(backEnd.refdef.rdflags & RDF_PROJECTION2D)
+	{
+		return;
+	}
+	*/
+	srfTerrain_t *ls = (srfTerrain_t *)surf;
+	CTRLandScape *landscape = ls->landscape;
+
+	TerrainFog = tr.world->globalFog;
+
+	landscape->CalculateRegion();
+	landscape->Reset();
+//	landscape->Tessellate();
+	landscape->Render();
+}
+
+void R_CalcTerrainVisBounds(CTRLandScape *landscape)
+{
+	const CCMLandScape *common = landscape->GetCommon();
+
+	// Set up the visbounds using terrain data
+	if ( common->GetMins()[0] < tr.viewParms.visBounds[0][0] ) 
+	{
+		tr.viewParms.visBounds[0][0] = common->GetMins()[0];
+	}
+	if ( common->GetMins()[1] < tr.viewParms.visBounds[0][1] ) 
+	{
+		tr.viewParms.visBounds[0][1] = common->GetMins()[1];
+	}
+	if ( common->GetMins()[2] < tr.viewParms.visBounds[0][2] ) 
+	{
+		tr.viewParms.visBounds[0][2] = common->GetMins()[2];
+	}
+
+	if ( common->GetMaxs()[0] > tr.viewParms.visBounds[1][0] ) 
+	{
+		tr.viewParms.visBounds[1][0] = common->GetMaxs()[0];
+	}
+	if ( common->GetMaxs()[1] > tr.viewParms.visBounds[1][1] ) 
+	{
+		tr.viewParms.visBounds[1][1] = common->GetMaxs()[1];
+	}
+	if ( common->GetMaxs()[2] > tr.viewParms.visBounds[1][2] ) 
+	{
+		tr.viewParms.visBounds[1][2] = common->GetMaxs()[2];
+	}
+}
+
+void R_AddTerrainSurfaces(void)
+{
+	CTRLandScape	*landscape;
+
+	if (!r_drawTerrain->integer || (tr.refdef.rdflags & RDF_NOWORLDMODEL))
+	{
+		return;
+	}
+
+	landscape = tr.landScape.landscape;
+	if(landscape)
+	{
+		R_AddDrawSurf( (surfaceType_t *)(&tr.landScape), landscape->GetShader(), 0, qfalse );
+		R_CalcTerrainVisBounds(landscape);
+	}
+}
+
+void RE_InitRendererTerrain( const char *info )
+{
+	CTRLandScape	*ls;
+
+	if ( !info || !info[0] )
+	{
+		Com_Printf( "RE_RegisterTerrain: NULL name\n" );
+		return;
+	}
+
+	Com_Printf("R_Terrain: Creating RENDERER data.....\n");
+
+	// Create and register a new landscape structure
+	ls = new CTRLandScape(info);
+}
+
+void R_TerrainInit(void)
+{
+	tr.landScape.surfaceType = SF_TERRAIN;
+	tr.landScape.landscape = NULL;
+
+	r_terrainTessellate = Cvar_Get("r_terrainTessellate", "3", CVAR_CHEAT);
+	r_drawTerrain = Cvar_Get("r_drawTerrain", "1", CVAR_CHEAT);
+	r_showFrameVariance = Cvar_Get("r_showFrameVariance", "0", 0);
+	r_terrainWaterOffset = Cvar_Get("r_terrainWaterOffset", "0", 0);
+
+	tr.distanceCull = 6000;
+	tr.distanceCullSquared = tr.distanceCull * tr.distanceCull;
+}
+
+extern void CM_ShutdownTerrain( thandle_t terrainId );	//cm_load.cpp
+
+void R_TerrainShutdown(void)
+{
+	CTRLandScape	*ls;
+
+//	Com_Printf("R_Terrain: Shutting down RENDERER terrain.....\n");
+	ls = tr.landScape.landscape;
+	if(ls)
+	{
+		CM_ShutdownTerrain(0);
+		delete ls;
+		tr.landScape.landscape = NULL;
+	}
+}
+
+// end
diff --git a/codemp/renderer/tr_world.cpp b/codemp/renderer/tr_world.cpp
new file mode 100644
index 0000000..370bd1b
--- /dev/null
+++ b/codemp/renderer/tr_world.cpp
@@ -0,0 +1,1959 @@
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+#include "tr_local.h"
+
+#ifdef VV_LIGHTING
+#include "tr_lightmanager.h"
+#endif
+
+#ifdef _XBOX
+#include "../qcommon/sparc.h"
+static bool lookingForWorstLeaf = false;
+#endif
+
+#ifndef _XBOX
+inline void Q_CastShort2Float(float *f, const short *s)
+{
+	*f = ((float)*s);
+}
+#endif
+
+
+#ifdef _XBOX
+static bool GetCoordsForLeaf(int leafNum, vec3_t coords)
+{
+	srfSurfaceFace_t *face;
+	msurface_t *surf;
+	int i;
+
+	for(i=0; i<tr.world->leafs[leafNum].nummarksurfaces; i++) {
+		surf = *(tr.world->marksurfaces + 
+				tr.world->leafs[leafNum].firstMarkSurfNum + i);
+		
+		if(!surf->data || *surf->data != SF_FACE) {
+			continue;
+		}
+
+		face = (srfSurfaceFace_t*)surf->data;
+		Q_CastShort2Float(&coords[0], (short*)(face->srfPoints + 0));
+		Q_CastShort2Float(&coords[1], (short*)(face->srfPoints + 1));
+		Q_CastShort2Float(&coords[2], (short*)(face->srfPoints + 2));
+		return true;
+	}
+
+	return false;
+}
+#endif
+
+
+/*
+=================
+R_CullTriSurf
+
+Returns true if the grid is completely culled away.
+Also sets the clipped hint bit in tess
+=================
+*/
+static qboolean	R_CullTriSurf( srfTriangles_t *cv ) {
+	int 	boxCull;
+
+	boxCull = R_CullLocalBox( cv->bounds );
+
+	if ( boxCull == CULL_OUT ) {
+		return qtrue;
+	}
+	return qfalse;
+}
+
+/*
+=================
+R_CullGrid
+
+Returns true if the grid is completely culled away.
+Also sets the clipped hint bit in tess
+=================
+*/
+static qboolean	R_CullGrid( srfGridMesh_t *cv ) {
+	int 	boxCull;
+	int 	sphereCull;
+
+	if ( r_nocurves->integer ) {
+		return qtrue;
+	}
+
+	if ( tr.currentEntityNum != TR_WORLDENT ) {
+		sphereCull = R_CullLocalPointAndRadius( cv->localOrigin, cv->meshRadius );
+	} else {
+		sphereCull = R_CullPointAndRadius( cv->localOrigin, cv->meshRadius );
+	}
+	boxCull = CULL_OUT;
+	
+	// check for trivial reject
+	if ( sphereCull == CULL_OUT )
+	{
+		tr.pc.c_sphere_cull_patch_out++;
+		return qtrue;
+	}
+	// check bounding box if necessary
+	else if ( sphereCull == CULL_CLIP )
+	{
+		tr.pc.c_sphere_cull_patch_clip++;
+
+		boxCull = R_CullLocalBox( cv->meshBounds );
+
+		if ( boxCull == CULL_OUT ) 
+		{
+			tr.pc.c_box_cull_patch_out++;
+			return qtrue;
+		}
+		else if ( boxCull == CULL_IN )
+		{
+			tr.pc.c_box_cull_patch_in++;
+		}
+		else
+		{
+			tr.pc.c_box_cull_patch_clip++;
+		}
+	}
+	else
+	{
+		tr.pc.c_sphere_cull_patch_in++;
+	}
+
+	return qfalse;
+}
+
+
+/*
+================
+R_CullSurface
+
+Tries to back face cull surfaces before they are lighted or
+added to the sorting list.
+
+This will also allow mirrors on both sides of a model without recursion.
+================
+*/
+static qboolean	R_CullSurface( surfaceType_t *surface, shader_t *shader ) {
+	srfSurfaceFace_t *sface;
+	float			d;
+
+	if ( r_nocull->integer ) {
+		return qfalse;
+	}
+
+	if ( *surface == SF_GRID ) {
+		return R_CullGrid( (srfGridMesh_t *)surface );
+	}
+
+	if ( *surface == SF_TRIANGLES ) {
+		return R_CullTriSurf( (srfTriangles_t *)surface );
+	}
+
+	if ( *surface != SF_FACE ) {
+		return qfalse;
+	}
+
+	if ( shader->cullType == CT_TWO_SIDED ) {
+		return qfalse;
+	}
+
+	// face culling
+	if ( !r_facePlaneCull->integer ) {
+		return qfalse;
+	}
+
+	sface = ( srfSurfaceFace_t * ) surface;
+
+	if (r_cullRoofFaces->integer)
+	{ //Very slow, but this is only intended for taking shots for automap images.
+		if (sface->plane.normal[2] > 0.0f &&
+			sface->numPoints > 0)
+		{ //it's facing up I guess
+			static int i;
+			static trace_t tr;
+			static vec3_t basePoint;
+			static vec3_t endPoint;
+			static vec3_t nNormal;
+			static vec3_t v;
+
+			//The fact that this point is in the middle of the array has no relation to the
+			//orientation in the surface outline.
+#ifdef _XBOX
+			Q_CastShort2Float(&basePoint[0], (short*)(sface->srfPoints + (sface->numPoints / 2) + 0));
+			Q_CastShort2Float(&basePoint[1], (short*)(sface->srfPoints + (sface->numPoints / 2) + 1));
+			Q_CastShort2Float(&basePoint[2], (short*)(sface->srfPoints + (sface->numPoints / 2) + 2));
+#else
+			basePoint[0] = sface->points[sface->numPoints/2][0];
+			basePoint[1] = sface->points[sface->numPoints/2][1];
+			basePoint[2] = sface->points[sface->numPoints/2][2];
+#endif
+			basePoint[2] += 2.0f;
+
+			//the endpoint will be 8192 units from the chosen point
+			//in the direction of the surface normal
+
+			//just go straight up I guess, for now (slight hack)
+			VectorSet(nNormal, 0.0f, 0.0f, 1.0f);
+			VectorMA(basePoint, 8192.0f, nNormal, endPoint);
+
+			CM_BoxTrace(&tr, basePoint, endPoint, NULL, NULL, 0, (CONTENTS_SOLID|CONTENTS_TERRAIN), qfalse);
+
+			if (!tr.startsolid &&
+				!tr.allsolid &&
+				(tr.fraction == 1.0f || (tr.surfaceFlags & SURF_NOIMPACT)))
+			{ //either hit nothing or sky, so this surface is near the top of the level I guess. Or the floor of a really tall room, but if that's the case we're just screwed.
+				VectorSubtract(basePoint, tr.endpos, v);
+				if (tr.fraction == 1.0f || VectorLength(v) < r_roofCullCeilDist->value)
+				{ //ignore it if it's not close to the top, unless it just hit nothing
+					//Let's try to dig back into the brush based on the negative direction of the plane,
+					//and if we pop out on the other side we'll see if it's ground or not.
+					i = 4;
+					VectorCopy(sface->plane.normal, nNormal);
+					VectorInverse(nNormal);
+
+					while (i < 4096)
+					{
+						VectorMA(basePoint, i, nNormal, endPoint);
+						CM_BoxTrace(&tr, endPoint, endPoint, NULL, NULL, 0, (CONTENTS_SOLID|CONTENTS_TERRAIN), qfalse);
+						if (!tr.startsolid &&
+							!tr.allsolid &&
+							tr.fraction == 1.0f)
+						{ //in the clear
+							break;
+						}
+						i++;
+					}
+					if (i < 4096)
+					{ //Make sure we got into clearance
+						VectorCopy(endPoint, basePoint);
+						basePoint[2] -= 2.0f;
+
+						//just go straight down I guess, for now (slight hack)
+						VectorSet(nNormal, 0.0f, 0.0f, -1.0f);
+						VectorMA(basePoint, 4096.0f, nNormal, endPoint);
+
+						//trace a second time from the clear point in the inverse normal direction of the surface.
+						//If we hit something within a set amount of units, we will assume it's a bridge type object
+						//and leave it to be drawn. Otherwise we will assume it is a roof or other obstruction and
+						//cull it out.
+						CM_BoxTrace(&tr, basePoint, endPoint, NULL, NULL, 0, (CONTENTS_SOLID|CONTENTS_TERRAIN), qfalse);
+
+						if (!tr.startsolid &&
+							!tr.allsolid &&
+							(tr.fraction != 1.0f && !(tr.surfaceFlags & SURF_NOIMPACT)))
+						{ //if we hit nothing or a noimpact going down then this is probably "ground".
+							VectorSubtract(basePoint, tr.endpos, endPoint);
+							if (VectorLength(endPoint) > r_roofCullCeilDist->value)
+							{ //128 (by default) is our maximum tolerance, above that will be removed
+								return qtrue;
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+
+	d = DotProduct (tr.ori.viewOrigin, sface->plane.normal);
+
+	// don't cull exactly on the plane, because there are levels of rounding
+	// through the BSP, ICD, and hardware that may cause pixel gaps if an
+	// epsilon isn't allowed here 
+	if ( shader->cullType == CT_FRONT_SIDED ) {
+		if ( d < sface->plane.dist - 8 ) {
+			return qtrue;
+		}
+	} else {
+		if ( d > sface->plane.dist + 8 ) {
+			return qtrue;
+		}
+	}
+
+	return qfalse;
+}
+
+#ifndef VV_LIGHTING
+static int R_DlightFace( srfSurfaceFace_t *face, int dlightBits ) {
+	float		d;
+	int			i;
+	dlight_t	*dl;
+
+	for ( i = 0 ; i < tr.refdef.num_dlights ; i++ ) {
+		if ( ! ( dlightBits & ( 1 << i ) ) ) {
+			continue;
+		}
+		dl = &tr.refdef.dlights[i];
+		d = DotProduct( dl->origin, face->plane.normal ) - face->plane.dist;
+		if ( !VectorCompare(face->plane.normal, vec3_origin) && (d < -dl->radius || d > dl->radius) ) {
+			// dlight doesn't reach the plane
+			dlightBits &= ~( 1 << i );
+		}
+	}
+
+	if ( !dlightBits ) {
+		tr.pc.c_dlightSurfacesCulled++;
+	}
+
+	face->dlightBits = dlightBits;
+	return dlightBits;
+}
+
+static int R_DlightGrid( srfGridMesh_t *grid, int dlightBits ) {
+	int			i;
+	dlight_t	*dl;
+
+	for ( i = 0 ; i < tr.refdef.num_dlights ; i++ ) {
+		if ( ! ( dlightBits & ( 1 << i ) ) ) {
+			continue;
+		}
+		dl = &tr.refdef.dlights[i];
+		if ( dl->origin[0] - dl->radius > grid->meshBounds[1][0]
+			|| dl->origin[0] + dl->radius < grid->meshBounds[0][0]
+			|| dl->origin[1] - dl->radius > grid->meshBounds[1][1]
+			|| dl->origin[1] + dl->radius < grid->meshBounds[0][1]
+			|| dl->origin[2] - dl->radius > grid->meshBounds[1][2]
+			|| dl->origin[2] + dl->radius < grid->meshBounds[0][2] ) {
+			// dlight doesn't reach the bounds
+			dlightBits &= ~( 1 << i );
+		}
+	}
+
+	if ( !dlightBits ) {
+		tr.pc.c_dlightSurfacesCulled++;
+	}
+
+	grid->dlightBits = dlightBits;
+	return dlightBits;
+}
+
+
+static int R_DlightTrisurf( srfTriangles_t *surf, int dlightBits ) {
+	// FIXME: more dlight culling to trisurfs...
+	surf->dlightBits = dlightBits;
+	return dlightBits;
+#if 0
+	int			i;
+	dlight_t	*dl;
+
+	for ( i = 0 ; i < tr.refdef.num_dlights ; i++ ) {
+		if ( ! ( dlightBits & ( 1 << i ) ) ) {
+			continue;
+		}
+		dl = &tr.refdef.dlights[i];
+		if ( dl->origin[0] - dl->radius > grid->meshBounds[1][0]
+			|| dl->origin[0] + dl->radius < grid->meshBounds[0][0]
+			|| dl->origin[1] - dl->radius > grid->meshBounds[1][1]
+			|| dl->origin[1] + dl->radius < grid->meshBounds[0][1]
+			|| dl->origin[2] - dl->radius > grid->meshBounds[1][2]
+			|| dl->origin[2] + dl->radius < grid->meshBounds[0][2] ) {
+			// dlight doesn't reach the bounds
+			dlightBits &= ~( 1 << i );
+		}
+	}
+
+	if ( !dlightBits ) {
+		tr.pc.c_dlightSurfacesCulled++;
+	}
+
+	grid->dlightBits = dlightBits;
+	return dlightBits;
+#endif
+}
+
+/*
+====================
+R_DlightSurface
+
+The given surface is going to be drawn, and it touches a leaf
+that is touched by one or more dlights, so try to throw out
+more dlights if possible.
+====================
+*/
+static int R_DlightSurface( msurface_t *surf, int dlightBits ) {
+	if ( *surf->data == SF_FACE ) {
+		dlightBits = R_DlightFace( (srfSurfaceFace_t *)surf->data, dlightBits );
+	} else if ( *surf->data == SF_GRID ) {
+		dlightBits = R_DlightGrid( (srfGridMesh_t *)surf->data, dlightBits );
+	} else if ( *surf->data == SF_TRIANGLES ) {
+		dlightBits = R_DlightTrisurf( (srfTriangles_t *)surf->data, dlightBits );
+	} else {
+		dlightBits = 0;
+	}
+
+	if ( dlightBits ) {
+		tr.pc.c_dlightSurfaces++;
+	}
+
+	return dlightBits;
+}
+#endif // VV_LIGHTING
+
+
+
+#ifdef _ALT_AUTOMAP_METHOD
+static bool tr_drawingAutoMap = false;
+#endif
+static float g_playerHeight = 0.0f;
+
+/*
+======================
+R_AddWorldSurface
+======================
+*/
+#ifdef VV_LIGHTING
+void R_AddWorldSurface( msurface_t *surf, int dlightBits, qboolean noViewCount ) 
+#else
+static void R_AddWorldSurface( msurface_t *surf, int dlightBits, qboolean noViewCount = qfalse )
+#endif
+{
+	if (!noViewCount)
+	{
+		if ( surf->viewCount == tr.viewCount ) 
+		{
+			// already in this view, but lets make sure all the dlight bits are set
+			if ( *surf->data == SF_FACE ) 
+			{
+				((srfSurfaceFace_t *)surf->data)->dlightBits |= dlightBits;
+			} 
+			else if ( *surf->data == SF_GRID ) 
+			{
+				((srfGridMesh_t *)surf->data)->dlightBits |= dlightBits;
+			} 
+			else if ( *surf->data == SF_TRIANGLES ) 
+			{
+				((srfTriangles_t *)surf->data)->dlightBits |= dlightBits;
+			}
+			return;
+		}
+		surf->viewCount = tr.viewCount;
+		// FIXME: bmodel fog?
+	}
+
+	/*
+	if (r_shadows->integer == 2)
+	{
+		dlightBits = R_DlightSurface( surf, dlightBits );
+		//dlightBits = ( dlightBits != 0 );
+		R_AddDrawSurf( surf->data, tr.shadowShader, surf->fogIndex, dlightBits );
+	}
+	*/
+	//world shadows?
+
+	// try to cull before dlighting or adding
+#ifdef _ALT_AUTOMAP_METHOD
+	if (!tr_drawingAutoMap && R_CullSurface( surf->data, surf->shader ) )
+#else
+	if (R_CullSurface(surf->data, surf->shader))
+#endif
+	{
+		return;
+	}
+
+	// check for dlighting
+	if ( dlightBits ) {
+#ifdef VV_LIGHTING
+		dlightBits = VVLightMan.R_DlightSurface( surf, dlightBits );
+#else
+		dlightBits = R_DlightSurface( surf, dlightBits );
+#endif
+		dlightBits = ( dlightBits != 0 );
+	}
+
+#ifdef _ALT_AUTOMAP_METHOD
+	if (tr_drawingAutoMap)
+	{
+	//	if (g_playerHeight != g_lastHeight ||
+	//		!g_lastHeightValid)
+		if (*surf->data == SF_FACE)
+		{ //only do this if we need to
+			bool completelyTransparent = true;
+			int i = 0;
+			srfSurfaceFace_t *face = (srfSurfaceFace_t *)surf->data;
+			byte *indices = (byte *)(face + face->ofsIndices);
+			float *point;
+			vec3_t color;
+			float alpha;
+			float e;
+			bool polyStarted = false;
+
+			while (i < face->numIndices)
+			{
+				point = &face->points[indices[i]][0];
+
+				//base the color on the elevation... for now, just check the first point height
+				if (point[2] < g_playerHeight)
+				{
+					e = point[2]-g_playerHeight;
+				}
+				else
+				{
+					e = g_playerHeight-point[2];
+				}
+				if (e < 0.0f)
+				{
+					e = -e;
+				}
+
+				//set alpha and color based on relative height of point
+				alpha = e/256.0f;
+				e /= 512.0f;
+
+				//cap color
+				if (e > 1.0f)
+				{
+					e = 1.0f;
+				}
+				else if (e < 0.0f)
+				{
+					e = 0.0f;
+				}
+				VectorSet(color, e, 1.0f-e, 0.0f);
+
+				//cap alpha
+				if (alpha > 1.0f)
+				{
+					alpha = 1.0f;
+				}
+				else if (alpha < 0.0f)
+				{
+					alpha = 0.0f;
+				}
+
+				if (alpha != 1.0f)
+				{ //this point is not entirely alpha'd out, so still draw the surface
+					completelyTransparent = false;
+				}
+
+				if (!completelyTransparent)
+				{
+					if (!polyStarted)
+					{
+						qglBegin(GL_POLYGON);
+						polyStarted = true;
+					}
+
+					qglColor4f(color[0], color[1], color[2], 1.0f-alpha);
+					qglVertex3f(point[i], point[i], point[2]);
+				}
+
+				i++;
+			}
+
+			if (polyStarted)
+			{
+				qglEnd();
+			}
+		}
+	}
+	else
+#endif
+	{
+		R_AddDrawSurf( surf->data, surf->shader, surf->fogIndex, dlightBits );
+	}
+}
+
+/*
+=============================================================
+
+	BRUSH MODELS
+
+=============================================================
+*/
+
+/*
+=================
+R_AddBrushModelSurfaces
+=================
+*/
+void R_AddBrushModelSurfaces ( trRefEntity_t *ent ) {
+	bmodel_t	*bmodel;
+	int			clip;
+	model_t		*pModel;
+	int			i;
+
+	pModel = R_GetModelByHandle( ent->e.hModel );
+
+	bmodel = pModel->bmodel;
+
+	clip = R_CullLocalBox( bmodel->bounds );
+	if ( clip == CULL_OUT ) {
+		return;
+	}
+	
+	if(pModel->bspInstance)
+	{ //rwwRMG - added
+#ifdef VV_LIGHTING
+		VVLightMan.R_SetupEntityLighting(&tr.refdef, ent);
+#else
+		R_SetupEntityLighting(&tr.refdef, ent);
+#endif
+	}
+
+	//rww - Take this into account later?
+//	if (!com_RMG || !com_RMG->integer)
+//	{	// don't dlight bmodels on rmg, as multiple copies of the same instance will light up
+#ifdef VV_LIGHTING
+		VVLightMan.R_DlightBmodel( bmodel, false );
+#else
+		R_DlightBmodel( bmodel, false );
+#endif
+//	}
+//	else
+//	{
+//		R_DlightBmodel( bmodel, true );
+//	}
+
+	for ( i = 0 ; i < bmodel->numSurfaces ; i++ ) {
+		R_AddWorldSurface( bmodel->firstSurface + i, tr.currentEntity->dlightBits, qtrue );
+	}
+}
+
+float GetQuadArea( vec3_t v1, vec3_t v2, vec3_t v3, vec3_t v4 )
+{
+	vec3_t	vec1, vec2, dis1, dis2;
+
+	// Get area of tri1
+	VectorSubtract( v1, v2, vec1 );
+	VectorSubtract( v1, v4, vec2 ); 
+	CrossProduct( vec1, vec2, dis1 );
+	VectorScale( dis1, 0.25f, dis1 );
+
+	// Get area of tri2
+	VectorSubtract( v3, v2, vec1 );
+	VectorSubtract( v3, v4, vec2 );
+	CrossProduct( vec1, vec2, dis2 );
+	VectorScale( dis2, 0.25f, dis2 );
+
+	// Return addition of disSqr of each tri area
+	return ( dis1[0] * dis1[0] + dis1[1] * dis1[1] + dis1[2] * dis1[2] +
+				dis2[0] * dis2[0] + dis2[1] * dis2[1] + dis2[2] * dis2[2] );
+}
+
+#ifdef _XBOX
+float GetQuadArea( unsigned short v1[3], unsigned short v2[3], unsigned short v3[3], unsigned short v4[3])
+{
+	vec3_t fv1;
+	vec3_t fv2;
+	vec3_t fv3;
+	vec3_t fv4;
+
+	for(int i=0; i<3; i++) {
+		Q_CastShort2Float(&fv1[i], (short*)&v1[i]);
+		Q_CastShort2Float(&fv2[i], (short*)&v2[i]);
+		Q_CastShort2Float(&fv3[i], (short*)&v3[i]);
+		Q_CastShort2Float(&fv4[i], (short*)&v4[i]);
+	}
+
+	return GetQuadArea(fv1, fv2, fv3, fv4);
+}
+#endif
+
+void RE_GetBModelVerts( int bmodelIndex, vec3_t *verts, vec3_t normal )
+{
+	msurface_t			*surfs;
+	srfSurfaceFace_t	*face;
+	bmodel_t			*bmodel;
+	model_t				*pModel;
+	int					i;
+	//	Not sure if we really need to track the best two candidates
+	int					maxDist[2]={0,0};
+	int					maxIndx[2]={0,0};
+	int					dist = 0;
+	float				dot1, dot2;
+
+	pModel = R_GetModelByHandle( bmodelIndex );
+	bmodel = pModel->bmodel;
+
+	// Loop through all surfaces on the brush and find the best two candidates
+	for ( i = 0 ; i < bmodel->numSurfaces; i++ ) 
+	{
+		surfs = bmodel->firstSurface + i;
+		face = ( srfSurfaceFace_t *)surfs->data;
+
+		// It seems that the safest way to handle this is by finding the area of the faces
+#ifdef _XBOX
+		int nextSurfPoint = NEXT_SURFPOINT(face->flags);
+		dist = GetQuadArea( face->srfPoints, face->srfPoints + nextSurfPoint, 
+				face->srfPoints + nextSurfPoint * 2, face->srfPoints +
+						 nextSurfPoint * 3 );
+#else
+		dist = GetQuadArea( face->points[0], face->points[1], face->points[2], face->points[3] );
+#endif
+
+		// Check against the highest max
+		if ( dist > maxDist[0] )
+		{
+			// Shuffle our current maxes down
+			maxDist[1] = maxDist[0];
+			maxIndx[1] = maxIndx[0];
+
+			maxDist[0] = dist;
+			maxIndx[0] = i;
+		}
+		// Check against the second highest max
+		else if ( dist >= maxDist[1] )
+		{
+			// just stomp the old
+			maxDist[1] = dist;
+			maxIndx[1] = i;
+		}
+	}
+
+	// Hopefully we've found two best case candidates.  Now we should see which of these faces the viewer
+	surfs = bmodel->firstSurface + maxIndx[0];
+	face = ( srfSurfaceFace_t *)surfs->data;
+	dot1 = DotProduct( face->plane.normal, tr.refdef.viewaxis[0] );
+	
+	surfs = bmodel->firstSurface + maxIndx[1];
+	face = ( srfSurfaceFace_t *)surfs->data;
+	dot2 = DotProduct( face->plane.normal, tr.refdef.viewaxis[0] );
+
+	if ( dot2 < dot1 && dot2 < 0.0f )
+	{
+		i = maxIndx[1]; // use the second face
+	}
+	else if ( dot1 < dot2 && dot1 < 0.0f )
+	{
+		i = maxIndx[0]; // use the first face
+	}
+	else
+	{ // Possibly only have one face, so may as well use the first face, which also should be the best one
+		//i = rand() & 1; // ugh, we don't know which to use.  I'd hope this would never happen
+		i = maxIndx[0]; // use the first face
+	}
+
+	surfs = bmodel->firstSurface + i;
+	face = ( srfSurfaceFace_t *)surfs->data;
+
+#ifdef _XBOX
+	int nextSurfPoint = NEXT_SURFPOINT(face->flags);
+	for ( int t = 0; t < 4; t++ )
+	{
+		Q_CastShort2Float(&verts[t][0], (short*)(face->srfPoints + nextSurfPoint * t + 0));
+		Q_CastShort2Float(&verts[t][1], (short*)(face->srfPoints + nextSurfPoint * t + 1));
+		Q_CastShort2Float(&verts[t][2], (short*)(face->srfPoints + nextSurfPoint * t + 2));
+	}
+#else
+	for ( int t = 0; t < 4; t++ )
+	{
+		VectorCopy(	face->points[t], verts[t] );
+	}
+#endif
+}
+
+/*
+=============================================================
+
+	WORLD MODEL
+
+=============================================================
+*/
+
+/*
+=============================================================
+WIREFRAME AUTOMAP GENERATION SYSTEM - BEGIN
+=============================================================
+*/
+#ifndef _ALT_AUTOMAP_METHOD
+typedef struct wireframeSurfPoint_s
+{
+	vec3_t					xyz;
+	float					alpha;
+	vec3_t					color;
+} wireframeSurfPoint_t;
+
+typedef struct wireframeMapSurf_s
+{
+	bool					completelyTransparent;
+
+	int						numPoints;
+	wireframeSurfPoint_t	*points;
+
+	wireframeMapSurf_s		*next;
+} wireframeMapSurf_t;
+
+typedef struct wireframeMap_s
+{
+    wireframeMapSurf_t		*surfs;
+} wireframeMap_t;
+
+static wireframeMap_t g_autoMapFrame;
+static wireframeMapSurf_t **g_autoMapNextFree = NULL;
+static bool g_autoMapValid = false; //set to true of g_autoMapFrame is valid.
+
+//get the next available wireframe automap surface. -rww
+static inline wireframeMapSurf_t *R_GetNewWireframeMapSurf(void)
+{
+	wireframeMapSurf_t **next = &g_autoMapFrame.surfs;
+
+	if (g_autoMapNextFree)
+	{ //save us the time of going through the entire linked list from root
+		next = g_autoMapNextFree;
+	}
+
+	while (*next)
+	{ //iterate through until we find the next unused one
+		next = &(*next)->next;
+	}
+
+	//allocate memory for it and pass it back
+	(*next) = (wireframeMapSurf_t *)Z_Malloc(sizeof(wireframeMapSurf_t), TAG_ALL, qtrue);
+	g_autoMapNextFree = &(*next)->next;
+	return (*next);
+}
+
+//evaluate a surface, see if it is valid for being part of the
+//wireframe map render. -rww
+#ifdef _XBOX
+static inline void R_EvaluateWireframeSurf(msurface_t *surf)
+{
+	if (*surf->data == SF_FACE)
+	{
+		srfSurfaceFace_t *face = (srfSurfaceFace_t *)surf->data;
+		int numPoints = face->numPoints;
+		unsigned char *indices = (unsigned char *)(((char *)face) + face->ofsIndices );
+
+		if (numPoints > 0)
+		{ //we can add it
+			int i = 0;
+			wireframeMapSurf_t *nextSurf = R_GetNewWireframeMapSurf();
+
+			//now go through the indices and add a point for each
+			nextSurf->points = (wireframeSurfPoint_t *)Z_Malloc(sizeof(wireframeSurfPoint_t)*face->numIndices, TAG_ALL, qtrue);
+			nextSurf->numPoints = face->numIndices;
+			while (i < face->numIndices)
+			{
+				vec3_t point;
+				Q_CastShort2Float(&point[0], (short*)face->srfPoints + indices[i] + 0);
+				Q_CastShort2Float(&point[1], (short*)face->srfPoints + indices[i] + 1);
+				Q_CastShort2Float(&point[2], (short*)face->srfPoints + indices[i] + 2);
+				VectorCopy(point, nextSurf->points[i].xyz);
+
+				i++;
+			}
+		}
+	}
+	else if (*surf->data == SF_TRIANGLES)
+	{
+		//srfTriangles_t *surfTri = (srfTriangles_t *)surf->data;
+		return; //not handled
+	}
+	else if (*surf->data == SF_GRID)
+	{
+		//srfGridMesh_t *gridMesh = (srfGridMesh_t *)surf->data;
+		return; //not handled
+	}
+	else
+	{ //...unknown type?
+		return;
+	}
+}
+
+#else // _XBOX
+
+static inline void R_EvaluateWireframeSurf(msurface_t *surf)
+{
+	if (*surf->data == SF_FACE)
+	{
+		srfSurfaceFace_t *face = (srfSurfaceFace_t *)surf->data;
+		float *points = &face->points[0][0];
+		int numPoints = face->numIndices;
+		int *indices = (int *)((byte *)face + face->ofsIndices);
+		//byte *indices = (byte *)(face + face->ofsIndices);
+
+		if (points && numPoints > 0)
+		{ //we can add it
+			int i = 0;
+			wireframeMapSurf_t *nextSurf = R_GetNewWireframeMapSurf();
+
+#if 0 //doing in realtime now
+			float e;
+
+			//base the color on the elevation... for now, just check the first point height
+			if (points[2] < 0.0f)
+			{
+				e = -points[2];
+			}
+			else
+			{
+				e = points[2];
+			}
+			e /= 2048.0f;
+			if (e > 1.0f)
+			{
+				e = 1.0f;
+			}
+			else if (e < 0.0f)
+			{
+				e = 0.0f;
+			}
+			VectorSet(color, e, 1.0f-e, 0.0f);
+#endif
+
+			//now go through the indices and add a point for each
+			nextSurf->points = (wireframeSurfPoint_t *)Z_Malloc(sizeof(wireframeSurfPoint_t)*face->numIndices, TAG_ALL, qtrue);
+			nextSurf->numPoints = face->numIndices;
+			while (i < face->numIndices)
+			{
+				points = &face->points[indices[i]][0];
+				VectorCopy(points, nextSurf->points[i].xyz);
+
+				i++;
+			}
+		}
+	}
+	else if (*surf->data == SF_TRIANGLES)
+	{
+		//srfTriangles_t *surfTri = (srfTriangles_t *)surf->data;
+		return; //not handled
+	}
+	else if (*surf->data == SF_GRID)
+	{
+		//srfGridMesh_t *gridMesh = (srfGridMesh_t *)surf->data;
+		return; //not handled
+	}
+	else
+	{ //...unknown type?
+		return;
+	}
+}
+
+#endif // _XBOX
+
+//see if any surfaces on the node are facing opposite directions
+//using plane normals. -rww
+static inline bool R_NodeHasOppositeFaces(mnode_t *node)
+{
+	int c, d;
+	msurface_t *surf, *surf2, **mark, **mark2;
+	srfSurfaceFace_t *face, *face2;
+	vec3_t normalDif;
+
+#ifdef _XBOX
+	mleaf_s *leaf;
+	leaf = (mleaf_s*)node;
+	mark = tr.world->marksurfaces + leaf->firstMarkSurfNum;
+	c = leaf->nummarksurfaces;
+#else
+	mark = node->firstmarksurface;
+	c = node->nummarksurfaces;
+#endif
+
+	while (c--)
+	{
+		surf = *mark;
+
+		if (*surf->data != SF_FACE)
+		{ //if this node is not entirely comprised of faces, I guess we shouldn't check it?
+			return false;
+		}
+
+		face = (srfSurfaceFace_t *)surf->data;
+
+		//go through other surfs and compare against this surf
+#ifdef _XBOX
+		leaf = (mleaf_s*)node;
+		d = leaf->nummarksurfaces;
+		mark2 = tr.world->marksurfaces + leaf->firstMarkSurfNum;
+#else
+		d = node->nummarksurfaces;
+		mark2 = node->firstmarksurface;
+#endif
+		while (d--)
+		{
+			surf2 = *mark2;
+
+			if (*surf2->data != SF_FACE)
+			{
+				return false;
+			}
+			face2 = (srfSurfaceFace_t *)surf2->data;
+			//see if this normal has a drastic angular change
+			VectorSubtract(face->plane.normal, face2->plane.normal, normalDif);
+			if (VectorLength(normalDif) >= 1.8f)
+			{
+				return true;
+			}
+
+			mark2++;
+		}
+		mark++;
+	}
+
+	return false;
+}
+
+//recursively called for each node to go through the surfaces on that
+//node and generate the wireframe map. -rww
+static inline void R_RecursiveWireframeSurf(mnode_t *node)
+{
+	int c;
+	msurface_t *surf, **mark;
+
+	if (!node)
+	{
+		return;
+	}
+
+	while (1)
+	{
+		if (!node ||
+			node->visframe != tr.visCount)
+		{ //not valid, stop this chain of recursion
+			return;
+		}
+
+		if ( node->contents != -1 )
+		{
+			break;
+		}
+
+		R_RecursiveWireframeSurf(node->children[0]);
+
+		node = node->children[1];
+	}
+
+	// add the individual surfaces
+#ifdef _XBOX
+	mleaf_s *leaf;
+	leaf = (mleaf_s*)node;
+	mark = tr.world->marksurfaces + leaf->firstMarkSurfNum;
+	c = leaf->nummarksurfaces;
+#else
+	mark = node->firstmarksurface;
+	c = node->nummarksurfaces;
+#endif
+	while (c--)
+	{
+		// the surface may have already been added if it
+		// spans multiple leafs
+		surf = *mark;
+		R_EvaluateWireframeSurf(surf);
+		mark++;
+	}
+}
+
+//generates a wireframe model of the map for the automap view -rww
+static void R_GenerateWireframeMap(mnode_t *baseNode)
+{
+	int i;
+
+	//initialize data to all 0
+	memset(&g_autoMapFrame, 0, sizeof(g_autoMapFrame));
+
+	//take the hit for this frame, mark all of these things as visible
+	//so we know which are valid for automap generation, but only the
+	//ones that are facing outside the world! (well, ideally.)
+	for (i = 0; i < tr.world->numnodes; i++)
+	{
+		if (tr.world->nodes[i].contents != CONTENTS_SOLID)
+		{
+#if 0 //doesn't work, I take it surfs on nodes are not related to surfs on brushes
+			if (!R_NodeHasOppositeFaces(&tr.world->nodes[i]))
+#endif
+			{
+				tr.world->nodes[i].visframe = tr.visCount;
+			}
+		}
+	}
+
+	//now start the recursive evaluation
+	R_RecursiveWireframeSurf(baseNode);
+}
+
+//clear out the wireframe map data -rww
+void R_DestroyWireframeMap(void)
+{
+	wireframeMapSurf_t *next;
+	wireframeMapSurf_t *last;
+
+	if (!g_autoMapValid)
+	{ //not valid to begin with
+		return;
+	}
+
+	next = g_autoMapFrame.surfs;
+	while (next)
+	{
+		//free memory allocated for points on this surface
+		Z_Free(next->points);
+
+		//get the next surface
+		last = next;
+		next = next->next;
+
+		//free memory for this surface
+		Z_Free(last);
+	}
+
+	//invalidate everything
+	memset(&g_autoMapFrame, 0, sizeof(g_autoMapFrame));
+	g_autoMapValid = false;
+	g_autoMapNextFree = NULL;
+}
+
+//save 3d automap data to file -rww
+qboolean R_WriteWireframeMapToFile(void)
+{
+	fileHandle_t f;
+	int requiredSize = 0;
+	wireframeMapSurf_t *surf = g_autoMapFrame.surfs;
+	byte *out, *rOut;
+
+	//let's go through and see how much space we're going to need to stuff all this
+	//data into
+    while (surf)
+	{
+		//memory for each point
+		requiredSize += sizeof(wireframeSurfPoint_t)*surf->numPoints;
+
+		//memory for numPoints
+		requiredSize += sizeof(int);
+
+		surf = surf->next;
+	}
+
+	if (requiredSize <= 0)
+	{ //nothing to do..?
+		return qfalse;
+	}
+	
+
+	f = FS_FOpenFileWrite("blahblah.bla");
+	if (!f)
+	{ //can't create?
+		return qfalse;
+	}
+
+	//allocate the memory we will need
+    out = (byte *)Z_Malloc(requiredSize, TAG_ALL, qtrue);
+	rOut = out;
+
+	//now go through and put the data into the memory
+	surf = g_autoMapFrame.surfs;
+    while (surf)
+	{
+		memcpy(out, surf, (sizeof(wireframeSurfPoint_t)*surf->numPoints) + sizeof(int));
+
+		//memory for each point
+		out += sizeof(wireframeSurfPoint_t)*surf->numPoints;
+
+		//memory for numPoints
+		out += sizeof(int);
+
+		surf = surf->next;
+	}
+
+	//now write the buffer, and close
+	FS_Write(rOut, requiredSize, f);
+	Z_Free(rOut);
+	FS_FCloseFile(f);
+
+	return qtrue;
+}
+
+//load 3d automap data from file -rww
+qboolean R_GetWireframeMapFromFile(void)
+{
+	wireframeMapSurf_t *surfs, *rSurfs;
+	wireframeMapSurf_t *newSurf;
+	fileHandle_t f;
+	int i = 0;
+	int len;
+	int stepBytes;
+
+	len = FS_FOpenFileRead("blahblah.bla", &f, qfalse);
+	if (!f || len <= 0)
+	{ //it doesn't exist
+		return qfalse;
+	}
+
+	surfs = (wireframeMapSurf_t *)Z_Malloc(len, TAG_ALL, qtrue);
+	rSurfs = surfs;
+	FS_Read(surfs, len, f);
+
+	while (i < len)
+	{
+		newSurf = R_GetNewWireframeMapSurf();
+		newSurf->points = (wireframeSurfPoint_t *)Z_Malloc(sizeof(wireframeSurfPoint_t)*surfs->numPoints, TAG_ALL, qtrue);
+
+		//copy the surf data into the new surf
+		//note - the surfs->points pointer is NOT pointing to valid memory, a pointer to that
+		//pointer is actually what we want to use as the location of the point offsets.
+		memcpy(newSurf->points, &surfs->points, sizeof(wireframeSurfPoint_t)*surfs->numPoints);
+		newSurf->numPoints = surfs->numPoints;
+
+		//the size of the point data, plus an int (the number of points)
+		stepBytes = (sizeof(wireframeSurfPoint_t)*surfs->numPoints) + sizeof(int);
+		i += stepBytes;
+
+		//increment the pointer to the start of the next surface
+		surfs = (wireframeMapSurf_t *)((byte *)surfs+stepBytes);
+	}
+
+	//it should end up being equal, if not something was wrong with this file.
+	assert(i == len);
+
+	FS_FCloseFile(f);
+	Z_Free(rSurfs);
+	return qtrue;
+}
+
+//create everything, after destroying any existing data -rww
+qboolean R_InitializeWireframeAutomap(void)
+{
+	if (r_autoMapDisable && r_autoMapDisable->integer)
+	{
+		return qfalse;
+	}
+
+	if (tr.world &&
+		tr.world->nodes)
+	{
+		R_DestroyWireframeMap();
+#if 0 //file load-save
+		if (!R_GetWireframeMapFromFile())
+		{ //first try loading the data from a file. If there is none, generate it.
+			R_GenerateWireframeMap(tr.world->nodes);
+
+			//now write it to file, since we have generated it successfully.
+			R_WriteWireframeMapToFile();
+		}
+#else //always generate
+		R_GenerateWireframeMap(tr.world->nodes);
+#endif
+		g_autoMapValid = true;
+	}
+
+	return (qboolean)g_autoMapValid;
+}
+#endif //0
+/*
+=============================================================
+WIREFRAME AUTOMAP GENERATION SYSTEM - END
+=============================================================
+*/
+
+void R_AutomapElevationAdjustment(float newHeight)
+{
+	g_playerHeight = newHeight;
+}
+
+#ifdef _ALT_AUTOMAP_METHOD
+//adjust the player height for gradient elevation colors -rww
+qboolean R_InitializeWireframeAutomap(void)
+{ //yoink
+	return qtrue;
+}
+#endif
+
+//draw the automap with the given transformation matrix -rww
+#define QUADINFINITY			16777216 
+static float g_lastHeight = 0.0f;
+static bool g_lastHeightValid = false;
+static void R_RecursiveWorldNode( mnode_t *node, int planeBits, int dlightBits );
+const void *R_DrawWireframeAutomap(const void *data)
+{
+	const drawBufferCommand_t *cmd = (const drawBufferCommand_t *)data;
+	float e = 0.0f;
+	float alpha;
+	wireframeMapSurf_t *s = g_autoMapFrame.surfs;
+#ifndef _ALT_AUTOMAP_METHOD
+	int i;
+#endif
+
+	if (!r_autoMap || !r_autoMap->integer)
+	{
+		return (const void *)(cmd + 1);
+	}
+
+#ifndef _ALT_AUTOMAP_METHOD
+	if (!g_autoMapValid)
+	{ //data is not valid, don't draw
+		return (const void *)(cmd + 1);
+	}
+#endif
+
+#if 0 //instead of this method, just do the automap as a new "scene"
+	//projection matrix mode
+	qglMatrixMode(GL_PROJECTION);
+
+	//store the current matrix
+	qglPushMatrix();
+	//translate to our proper pos/angles from identity
+	qglLoadIdentity();
+	qglTranslatef(pos[0], pos[1], pos[2]);
+	//presumeably this is correct for compensating for quake's
+	//crazy angle system.
+	qglRotatef(angles[1], 0.0f, 0.0f, 1.0f);
+	qglRotatef(-angles[0], 0.0f, 1.0f, 0.0f);
+	qglRotatef(angles[2], 1.0f, 0.0f, 0.0f);
+#endif
+
+	//disable 2d texturing
+	qglDisable( GL_TEXTURE_2D );
+
+	//now draw the backdrop
+#if 0 //this does no good sadly, because of the issue of having to clear with a second scene
+	//in order for global fog clearing to work.
+	if (r_autoMapBackAlpha && r_autoMapBackAlpha->value)
+	{ //specify the automap background alpha
+		alpha = r_autoMapBackAlpha->value;
+
+		//cap it reasonably
+		if (alpha < 0.0f)
+		{
+			alpha = 0.0f;
+		}
+		else if (alpha > 1.0f)
+		{
+			alpha = 1.0f;
+		}
+		GL_State(GLS_SRCBLEND_SRC_ALPHA|GLS_DSTBLEND_SRC_ALPHA);
+	}
+	else
+#endif
+	{
+		alpha = 1.0f;
+		GL_State(0);
+	}
+	//black
+	qglColor4f(0.0f, 0.0f, 0.0f, alpha);
+
+	//draw a black backdrop
+	qglPushMatrix();
+	qglLoadIdentity(); //get the ident matrix
+
+	qglBegin( GL_QUADS );
+	qglVertex3f( -QUADINFINITY, QUADINFINITY, -(backEnd.viewParms.zFar-1) );
+	qglVertex3f( QUADINFINITY, QUADINFINITY, -(backEnd.viewParms.zFar-1) );
+	qglVertex3f( QUADINFINITY, -QUADINFINITY, -(backEnd.viewParms.zFar-1) );
+	qglVertex3f( -QUADINFINITY, -QUADINFINITY, -(backEnd.viewParms.zFar-1) );
+	qglEnd ();
+
+	//pop back the viewmatrix
+	qglPopMatrix();
+
+
+	//set the mode to line draw
+	if (r_autoMap->integer == 2)
+	{ //line mode
+		GL_State(GLS_POLYMODE_LINE|GLS_SRCBLEND_SRC_ALPHA|GLS_DSTBLEND_SRC_COLOR|GLS_DEPTHMASK_TRUE);
+	}
+	else
+	{ //fill mode
+		//GL_State(GLS_SRCBLEND_SRC_ALPHA|GLS_DSTBLEND_SRC_COLOR|GLS_DEPTHMASK_TRUE);
+		GL_State(GLS_DEPTHMASK_TRUE);
+	}
+
+	//set culling
+	GL_Cull(CT_TWO_SIDED);
+
+#ifndef _ALT_AUTOMAP_METHOD
+	//Draw the triangles
+	while (s)
+	{
+		//first, loop through and set the alpha on every point for this surf.
+		//if the alpha ends up being completely transparent for every point, we don't even
+		//need to draw it
+		if (g_playerHeight != g_lastHeight ||
+			!g_lastHeightValid)
+		{ //only do this if we need to
+			i = 0;
+			s->completelyTransparent = true;
+			while (i < s->numPoints)
+			{
+				//base the color on the elevation... for now, just check the first point height
+				if (s->points[i].xyz[2] < g_playerHeight)
+				{
+					e = s->points[i].xyz[2]-g_playerHeight;
+				}
+				else
+				{
+					e = g_playerHeight-s->points[i].xyz[2];
+				}
+				if (e < 0.0f)
+				{
+					e = -e;
+				}
+
+				if (r_autoMap->integer != 2)
+				{ //fill mode
+					if (s->points[i].xyz[2] > (g_playerHeight+64.0f))
+					{
+						s->points[i].alpha = 1.0f;
+					}
+					else
+					{
+						s->points[i].alpha = e/256.0f;
+					}
+				}
+				else
+				{
+					//set alpha and color based on relative height of point
+					s->points[i].alpha = e/256.0f;
+				}
+				e /= 512.0f;
+
+				//cap color
+				if (e > 1.0f)
+				{
+					e = 1.0f;
+				}
+				else if (e < 0.0f)
+				{
+					e = 0.0f;
+				}
+				VectorSet(s->points[i].color, e, 1.0f-e, 0.0f);
+
+				//cap alpha
+				if (s->points[i].alpha > 1.0f)
+				{
+					s->points[i].alpha = 1.0f;
+				}
+				else if (s->points[i].alpha < 0.0f)
+				{
+					s->points[i].alpha = 0.0f;
+				}
+
+				if (s->points[i].alpha != 1.0f)
+				{ //this point is not entirely alpha'd out, so still draw the surface
+					s->completelyTransparent = false;
+				}
+
+				i++;
+			}
+		}
+
+		if (s->completelyTransparent)
+		{
+			s = s->next;
+			continue;
+		}
+
+		i = 0;
+		qglBegin(GL_TRIANGLES);
+		while (i < s->numPoints)
+		{
+			if (r_autoMap->integer == 2 || s->numPoints < 3)
+			{ //line mode or not enough verts on surface
+				qglColor4f(s->points[i].color[0], s->points[i].color[1], s->points[i].color[2], s->points[i].alpha);
+			}
+			else
+			{ //fill mode
+				vec3_t planeNormal;
+				float fAlpha = s->points[i].alpha;
+				planeNormal[0] = s->points[0].xyz[1]*(s->points[1].xyz[2]-s->points[2].xyz[2]) + s->points[1].xyz[1]*(s->points[2].xyz[2]-s->points[0].xyz[2]) + s->points[2].xyz[1]*(s->points[0].xyz[2]-s->points[1].xyz[2]);
+				planeNormal[1] = s->points[0].xyz[2]*(s->points[1].xyz[0]-s->points[2].xyz[0]) + s->points[1].xyz[2]*(s->points[2].xyz[0]-s->points[0].xyz[0]) + s->points[2].xyz[2]*(s->points[0].xyz[0]-s->points[1].xyz[0]);
+				planeNormal[2] = s->points[0].xyz[0]*(s->points[1].xyz[1]-s->points[2].xyz[1]) + s->points[1].xyz[0]*(s->points[2].xyz[1]-s->points[0].xyz[1]) + s->points[2].xyz[0]*(s->points[0].xyz[1]-s->points[1].xyz[1]);
+
+				if (planeNormal[0] < 0.0f) planeNormal[0] = -planeNormal[0];
+				if (planeNormal[1] < 0.0f) planeNormal[1] = -planeNormal[1];
+				if (planeNormal[2] < 0.0f) planeNormal[2] = -planeNormal[2];
+
+				/*
+				if (s->points[i].xyz[2] > g_playerHeight+64.0f &&
+					planeNormal[2] > 0.7f)
+				{ //surface above player facing up/down directly
+					fAlpha = 1.0f-planeNormal[2];
+				}
+				*/
+
+				//qglColor4f(planeNormal[0], planeNormal[1], planeNormal[2], fAlpha);
+				qglColor4f(s->points[i].color[0], s->points[i].color[1], 1.0f-planeNormal[2], fAlpha);
+			}
+			qglVertex3f(s->points[i].xyz[0], s->points[i].xyz[1], s->points[i].xyz[2]);
+			i++;
+		}
+		qglEnd();
+		s = s->next;
+	}
+#else
+	tr_drawingAutoMap = true;
+	R_RecursiveWorldNode( tr.world->nodes, 15, 0 );
+	tr_drawingAutoMap = false;
+#endif
+
+	g_lastHeight = g_playerHeight;
+	g_lastHeightValid = true;
+
+#if 0 //instead of this method, just do the automap as a new "scene"
+	//pop back the view matrix
+	qglPopMatrix();
+#endif
+
+	//reenable 2d texturing
+	qglEnable( GL_TEXTURE_2D );
+
+	//white color/full alpha
+	qglColor4f(1.0f, 1.0f, 1.0f, 1.0f);
+
+	return (const void *)(cmd + 1);
+}
+
+
+/*
+================
+R_RecursiveWorldNode
+================
+*/
+#ifndef VV_LIGHTING
+static void R_RecursiveWorldNode( mnode_t *node, int planeBits, int dlightBits ) {
+
+	do
+	{
+		int			newDlights[2];
+
+#ifdef _ALT_AUTOMAP_METHOD
+		if (tr_drawingAutoMap)
+		{
+			node->visframe = tr.visCount;
+		}
+#endif
+
+		// if the node wasn't marked as potentially visible, exit
+		if (node->visframe != tr.visCount)
+		{
+			return;
+		}
+
+		// if the bounding volume is outside the frustum, nothing
+		// inside can be visible OPTIMIZE: don't do this all the way to leafs?
+
+#ifdef _ALT_AUTOMAP_METHOD
+		if ( r_nocull->integer!=1 && !tr_drawingAutoMap )
+#else
+		if (r_nocull->integer!=1)
+#endif
+		{
+			int		r;
+
+			if ( planeBits & 1 ) {
+				r = BoxOnPlaneSide(node->mins, node->maxs, &tr.viewParms.frustum[0]);
+				if (r == 2) {
+					return;						// culled
+				}
+				if ( r == 1 ) {
+					planeBits &= ~1;			// all descendants will also be in front
+				}
+			}
+
+			if ( planeBits & 2 ) {
+				r = BoxOnPlaneSide(node->mins, node->maxs, &tr.viewParms.frustum[1]);
+				if (r == 2) {
+					return;						// culled
+				}
+				if ( r == 1 ) {
+					planeBits &= ~2;			// all descendants will also be in front
+				}
+			}
+
+			if ( planeBits & 4 ) {
+				r = BoxOnPlaneSide(node->mins, node->maxs, &tr.viewParms.frustum[2]);
+				if (r == 2) {
+					return;						// culled
+				}
+				if ( r == 1 ) {
+					planeBits &= ~4;			// all descendants will also be in front
+				}
+			}
+
+			if ( planeBits & 8 ) {
+				r = BoxOnPlaneSide(node->mins, node->maxs, &tr.viewParms.frustum[3]);
+				if (r == 2) {
+					return;						// culled
+				}
+				if ( r == 1 ) {
+					planeBits &= ~8;			// all descendants will also be in front
+				}
+			}
+
+		}
+
+		if ( node->contents != -1 ) {
+			break;
+		}
+
+		// node is just a decision point, so go down both sides
+		// since we don't care about sort orders, just go positive to negative
+
+		// determine which dlights are needed
+		if ( r_nocull->integer!=2 ) 
+		{
+			newDlights[0] = 0;
+			newDlights[1] = 0;
+			if ( dlightBits ) 
+			{
+				int	i;
+				for ( i = 0 ; i < tr.refdef.num_dlights ; i++ )
+				{
+					dlight_t	*dl;
+					float		dist;
+
+					if ( dlightBits & ( 1 << i ) ) {
+						dl = &tr.refdef.dlights[i];
+						dist = DotProduct( dl->origin, node->plane->normal ) - node->plane->dist;
+						
+						if ( dist > -dl->radius ) {
+							newDlights[0] |= ( 1 << i );
+						}
+						if ( dist < dl->radius ) {
+							newDlights[1] |= ( 1 << i );
+						}
+					}
+				}
+			}
+		}
+		else
+		{
+			newDlights[0] = dlightBits;
+			newDlights[1] = dlightBits;
+		}
+
+		// recurse down the children, front side first
+		R_RecursiveWorldNode (node->children[0], planeBits, newDlights[0] );
+
+		// tail recurse
+		node = node->children[1];
+		dlightBits = newDlights[1];
+	} while ( 1 );
+
+	{
+		// leaf node, so add mark surfaces
+		int			c;
+		msurface_t	*surf, **mark;
+
+		tr.pc.c_leafs++;
+
+		// add to z buffer bounds
+		if ( node->mins[0] < tr.viewParms.visBounds[0][0] ) {
+			tr.viewParms.visBounds[0][0] = node->mins[0];
+		}
+		if ( node->mins[1] < tr.viewParms.visBounds[0][1] ) {
+			tr.viewParms.visBounds[0][1] = node->mins[1];
+		}
+		if ( node->mins[2] < tr.viewParms.visBounds[0][2] ) {
+			tr.viewParms.visBounds[0][2] = node->mins[2];
+		}
+
+		if ( node->maxs[0] > tr.viewParms.visBounds[1][0] ) {
+			tr.viewParms.visBounds[1][0] = node->maxs[0];
+		}
+		if ( node->maxs[1] > tr.viewParms.visBounds[1][1] ) {
+			tr.viewParms.visBounds[1][1] = node->maxs[1];
+		}
+		if ( node->maxs[2] > tr.viewParms.visBounds[1][2] ) {
+			tr.viewParms.visBounds[1][2] = node->maxs[2];
+		}
+
+		// add the individual surfaces
+		mark = node->firstmarksurface;
+		c = node->nummarksurfaces;
+		while (c--) {
+			// the surface may have already been added if it
+			// spans multiple leafs
+			surf = *mark;
+			R_AddWorldSurface( surf, dlightBits );
+			mark++;
+		}
+	}
+
+}
+#endif // VV_LIGHTING
+
+
+/*
+===============
+R_PointInLeaf
+===============
+*/
+static mnode_t *R_PointInLeaf( const vec3_t p ) {
+	mnode_t		*node;
+	float		d;
+	cplane_t	*plane;
+	
+	if ( !tr.world ) {
+		Com_Error (ERR_DROP, "R_PointInLeaf: bad model");
+	}
+
+	node = tr.world->nodes;
+	while( 1 ) {
+		if (node->contents != -1) {
+			break;
+		}
+#ifdef _XBOX
+		plane = tr.world->planes + node->planeNum;
+#else
+		plane = node->plane;
+#endif
+		d = DotProduct (p,plane->normal) - plane->dist;
+		if (d > 0) {
+			node = node->children[0];
+		} else {
+			node = node->children[1];
+		}
+	}
+	
+	return node;
+}
+
+/*
+==============
+R_ClusterPVS
+==============
+*/
+static const byte *R_ClusterPVS (int cluster) {
+	if (!tr.world || !tr.world->vis || cluster < 0 || cluster >= tr.world->numClusters ) {
+		return tr.world->novis;
+	}
+
+#ifdef _XBOX
+	return tr.world->vis->Decompress(cluster * tr.world->clusterBytes,
+			tr.world->numClusters);
+#else
+	return tr.world->vis + cluster * tr.world->clusterBytes;
+#endif
+}
+
+/*
+=================
+R_inPVS
+=================
+*/
+qboolean R_inPVS( const vec3_t p1, const vec3_t p2, byte *mask ) {
+	int		leafnum;
+	int		cluster;
+	int		area1, area2;
+
+	leafnum = CM_PointLeafnum (p1);
+	cluster = CM_LeafCluster (leafnum);
+	area1 = CM_LeafArea (leafnum);
+
+	//agh, the damn snapshot mask doesn't work for this
+	mask = (byte *) CM_ClusterPVS (cluster);
+
+	leafnum = CM_PointLeafnum (p2);
+	cluster = CM_LeafCluster (leafnum);
+	area2 = CM_LeafArea (leafnum);
+	if ( mask && (!(mask[cluster>>3] & (1<<(cluster&7)) ) ) )
+		return qfalse;
+	//this doesn't freakin work
+//	if (!CM_AreasConnected (area1, area2))
+//		return qfalse;		// a door blocks sight
+	return qtrue;
+}
+
+/*
+===============
+R_MarkLeaves
+
+Mark the leaves and nodes that are in the PVS for the current
+cluster
+===============
+*/
+#ifdef _XBOX
+void R_MarkLeaves (mleaf_s *leafOverride) {
+	const byte	*vis;
+	mleaf_s	*leaf;
+   	mnode_s	*parent;
+	int		i;
+	int		cluster;
+
+	// lockpvs lets designers walk around to determine the
+	// extent of the current pvs
+	if ( r_lockpvs->integer ) {
+		return;
+	}
+
+	// current viewcluster
+	if(!leafOverride) {
+		leaf = (mleaf_s*)R_PointInLeaf( tr.viewParms.pvsOrigin );
+	} else {
+		leaf = leafOverride;
+	}
+	cluster = leaf->cluster;
+
+	assert(leaf->contents != -1);
+
+	// if the cluster is the same and the area visibility matrix
+	// hasn't changed, we don't need to mark everything again
+
+	if ( tr.viewCluster == cluster && !tr.refdef.areamaskModified ) {
+		return;
+	}
+
+	tr.visCount++;
+	tr.viewCluster = cluster;
+
+	if ( r_novis->integer || tr.viewCluster == -1 ) {
+		for (i=0 ; i<tr.world->numnodes ; i++) {
+			if (tr.world->nodes[i].contents != CONTENTS_SOLID) {
+				tr.world->nodes[i].visframe = tr.visCount;
+			}
+		}
+		return;
+	}
+
+	vis = R_ClusterPVS (tr.viewCluster);
+	
+	for (i=0,leaf=tr.world->leafs ; i<tr.world->numleafs ; i++, leaf++) {
+		cluster = leaf->cluster;
+		if ( cluster < 0 || cluster >= tr.world->numClusters ) {
+			continue;
+		}
+
+		// check general pvs
+		if ( !(vis[cluster>>3] & (1<<(cluster&7))) ) {
+			continue;
+		}
+
+		// check for door connection
+		if (!lookingForWorstLeaf &&
+			   (tr.refdef.areamask[leaf->area>>3] & (1<<(leaf->area&7)) ) ) {
+			continue;		// not visible
+		}
+
+		parent = (mnode_t*)leaf;
+		assert(leaf->contents != -1);
+		do {
+			if (parent->visframe == tr.visCount)
+				break;
+			parent->visframe = tr.visCount;
+			parent = parent->parent;
+		} while (parent);
+	}
+}
+#else // _XBOX
+
+static void R_MarkLeaves (void) {
+	const byte	*vis;
+	mnode_t	*leaf, *parent;
+	int		i;
+	int		cluster;
+
+	// lockpvs lets designers walk around to determine the
+	// extent of the current pvs
+	if ( r_lockpvs->integer ) {
+		return;
+	}
+
+	// current viewcluster
+	leaf = R_PointInLeaf( tr.viewParms.pvsOrigin );
+	cluster = leaf->cluster;
+
+	// if the cluster is the same and the area visibility matrix
+	// hasn't changed, we don't need to mark everything again
+
+	// if r_showcluster was just turned on, remark everything 
+	if ( tr.viewCluster == cluster && !tr.refdef.areamaskModified 
+		&& !r_showcluster->modified ) {
+		return;
+	}
+
+	if ( r_showcluster->modified || r_showcluster->integer ) {
+		r_showcluster->modified = qfalse;
+		if ( r_showcluster->integer ) {
+			Com_Printf ("cluster:%i  area:%i\n", cluster, leaf->area );
+		}
+	}
+
+	tr.visCount++;
+	tr.viewCluster = cluster;
+
+	if ( r_novis->integer || tr.viewCluster == -1 ) {
+		for (i=0 ; i<tr.world->numnodes ; i++) {
+			if (tr.world->nodes[i].contents != CONTENTS_SOLID) {
+				tr.world->nodes[i].visframe = tr.visCount;
+			}
+		}
+		return;
+	}
+
+	vis = R_ClusterPVS (tr.viewCluster);
+	
+	for (i=0,leaf=tr.world->nodes ; i<tr.world->numnodes ; i++, leaf++) {
+		cluster = leaf->cluster;
+		if ( cluster < 0 || cluster >= tr.world->numClusters ) {
+			continue;
+		}
+
+		// check general pvs
+		if ( !(vis[cluster>>3] & (1<<(cluster&7))) ) {
+			continue;
+		}
+
+		// check for door connection
+		if ( (tr.refdef.areamask[leaf->area>>3] & (1<<(leaf->area&7)) ) ) {
+			continue;		// not visible
+		}
+
+		parent = leaf;
+		do {
+			if (parent->visframe == tr.visCount)
+				break;
+			parent->visframe = tr.visCount;
+			parent = parent->parent;
+		} while (parent);
+	}
+}
+#endif // _XBOX
+
+/*
+=============
+R_AddWorldSurfaces
+=============
+*/
+#ifdef _XBOX
+void R_AddWorldSurfaces (void) {
+	if ( !r_drawworld->integer ) {
+		return;
+	}
+
+	if ( tr.refdef.rdflags & RDF_NOWORLDMODEL ) {
+		return;
+	}
+
+	tr.currentEntityNum = TR_WORLDENT;//ENTITYNUM_WORLD;
+	tr.shiftedEntityNum = tr.currentEntityNum << QSORT_ENTITYNUM_SHIFT;
+
+	// clear out the visible min/max
+	ClearBounds( tr.viewParms.visBounds[0], tr.viewParms.visBounds[1] );
+
+	// perform frustum culling and add all the potentially visible surfaces
+	if ( VVLightMan.num_dlights > MAX_DLIGHTS ) {
+		VVLightMan.num_dlights = MAX_DLIGHTS ;
+	}
+
+	VVLightMan.R_RecursiveWorldNode( tr.world->nodes, 15, ( 1 << VVLightMan.num_dlights ) - 1 );
+}
+
+#else // _XBOX
+
+void R_AddWorldSurfaces (void) {
+	if ( !r_drawworld->integer ) {
+		return;
+	}
+
+	if ( tr.refdef.rdflags & RDF_NOWORLDMODEL ) {
+		return;
+	}
+
+	tr.currentEntityNum = TR_WORLDENT;
+	tr.shiftedEntityNum = tr.currentEntityNum << QSORT_ENTITYNUM_SHIFT;
+
+	// determine which leaves are in the PVS / areamask
+	R_MarkLeaves ();
+
+	// clear out the visible min/max
+	ClearBounds( tr.viewParms.visBounds[0], tr.viewParms.visBounds[1] );
+
+	// perform frustum culling and add all the potentially visible surfaces
+	if ( tr.refdef.num_dlights > 32 ) {
+		tr.refdef.num_dlights = 32 ;
+	}
+
+	R_RecursiveWorldNode( tr.world->nodes, 15, ( 1 << tr.refdef.num_dlights ) - 1 );
+}
+#endif // _XBOX
diff --git a/codemp/renderer/vssver.scc b/codemp/renderer/vssver.scc
new file mode 100644
index 0000000..6f5404c
Binary files /dev/null and b/codemp/renderer/vssver.scc differ
diff --git a/codemp/server/NPCNav/gameCallbacks.cpp b/codemp/server/NPCNav/gameCallbacks.cpp
new file mode 100644
index 0000000..05bb1e1
--- /dev/null
+++ b/codemp/server/NPCNav/gameCallbacks.cpp
@@ -0,0 +1,49 @@
+//rww - callbacks the navigation system needs to make to the game code.
+#include "../../game/q_shared.h"
+#include "../../game/g_public.h"
+#include "../server.h"
+
+qboolean GNavCallback_NAV_ClearPathToPoint( sharedEntity_t *self, vec3_t pmins, vec3_t pmaxs, vec3_t point, int clipmask, int okToHitEntNum )
+{
+	return (qboolean)VM_Call(gvm, GAME_NAV_CLEARPATHTOPOINT, self->s.number, pmins, pmaxs, point, clipmask, okToHitEntNum);
+}
+
+qboolean GNavCallback_NPC_ClearLOS( sharedEntity_t *ent, const vec3_t end )
+{
+	return (qboolean)VM_Call(gvm, GAME_NAV_CLEARLOS, ent->s.number, end);
+}
+
+int GNavCallback_NAVNEW_ClearPathBetweenPoints(vec3_t start, vec3_t end, vec3_t mins, vec3_t maxs, int ignore, int clipmask)
+{
+	return VM_Call(gvm, GAME_NAV_CLEARPATHBETWEENPOINTS, start, end, mins, maxs, ignore, clipmask);
+}
+
+qboolean GNavCallback_NAV_CheckNodeFailedForEnt( sharedEntity_t *ent, int nodeNum )
+{
+	return (qboolean)VM_Call(gvm, GAME_NAV_CHECKNODEFAILEDFORENT, ent->s.number, nodeNum);
+}
+
+qboolean GNavCallback_G_EntIsUnlockedDoor( int entityNum )
+{
+	return (qboolean)VM_Call(gvm, GAME_NAV_ENTISUNLOCKEDDOOR, entityNum);
+}
+
+qboolean GNavCallback_G_EntIsDoor( int entityNum )
+{
+	return (qboolean)VM_Call(gvm, GAME_NAV_ENTISDOOR, entityNum);
+}
+
+qboolean GNavCallback_G_EntIsBreakable( int entityNum )
+{
+	return (qboolean)VM_Call(gvm, GAME_NAV_ENTISBREAKABLE, entityNum);
+}
+
+qboolean GNavCallback_G_EntIsRemovableUsable( int entNum )
+{
+	return (qboolean)VM_Call(gvm, GAME_NAV_ENTISREMOVABLEUSABLE, entNum);
+}
+
+void GNavCallback_CP_FindCombatPointWaypoints( void )
+{
+	VM_Call(gvm, GAME_NAV_FINDCOMBATPOINTWAYPOINTS);
+}
diff --git a/codemp/server/NPCNav/navigator.cpp b/codemp/server/NPCNav/navigator.cpp
new file mode 100644
index 0000000..eb0c891
--- /dev/null
+++ b/codemp/server/NPCNav/navigator.cpp
@@ -0,0 +1,2783 @@
+#include "../../game/q_shared.h"
+
+#pragma warning( disable : 4018)
+#pragma warning( disable : 4245)
+#pragma warning( disable : 4284)
+#pragma warning( disable : 4512)
+#pragma warning( disable : 4786)
+
+#pragma warning ( disable : 4663 )	//spcialize class
+#pragma warning( push, 3 )
+#include <algorithm>
+#pragma warning (pop)
+
+#include "navigator.h"
+#include "../../game/g_nav.h"
+#include <time.h>
+#ifdef __linux__
+DWORD timeGetTime(void);
+#endif
+
+extern qboolean GNavCallback_NAV_ClearPathToPoint( sharedEntity_t *self, vec3_t pmins, vec3_t pmaxs, vec3_t point, int clipmask, int okToHitEntNum );
+extern qboolean GNavCallback_NPC_ClearLOS( sharedEntity_t *ent, const vec3_t end );
+extern int GNavCallback_NAVNEW_ClearPathBetweenPoints(vec3_t start, vec3_t end, vec3_t mins, vec3_t maxs, int ignore, int clipmask);
+extern qboolean GNavCallback_NAV_CheckNodeFailedForEnt( sharedEntity_t *ent, int nodeNum );
+extern qboolean GNavCallback_G_EntIsUnlockedDoor( int entityNum );
+extern qboolean GNavCallback_G_EntIsDoor( int entityNum );
+extern qboolean GNavCallback_G_EntIsBreakable( int entityNum );
+extern qboolean GNavCallback_G_EntIsRemovableUsable( int entNum );
+extern void GNavCallback_CP_FindCombatPointWaypoints( void );
+
+//Global navigator
+CNavigator		navigator;
+//this was in the game before. But now it's all handled in the engine, and we make navigator. calls
+//via traps.
+
+cvar_t		*d_altRoutes;
+cvar_t		*d_patched;
+
+void NAV_CvarInit()
+{
+	d_altRoutes = Cvar_Get("d_altRoutes", "0", CVAR_CHEAT);
+	d_patched = Cvar_Get("d_patched", "0", CVAR_CHEAT);
+}
+
+void NAV_Free()
+{
+	navigator.Free();
+}
+
+static vec3_t	wpMaxs = {  16,  16, 32 };
+static vec3_t	wpMins = { -16, -16, -24+STEPSIZE };//WTF:  was 16??!!!
+
+
+static byte CHECKED_NO = 0;
+static byte CHECKED_FAILED = 1;
+static byte CHECKED_PASSED = 2;
+
+
+#if	AI_TIMERS
+int GetTime ( int lastTime )
+{
+	int			curtime;
+	static int	timeBase = 0;
+	static qboolean	initialized = qfalse;
+
+	if (!initialized) {
+		timeBase = timeGetTime();
+		initialized = qtrue;
+	}
+	curtime = timeGetTime() - timeBase - lastTime;
+
+	return curtime;
+}
+#endif
+
+/*
+-------------------------
+CEdge
+-------------------------
+*/
+
+CEdge::CEdge( void )
+{
+	CEdge( -1, -1, -1 );
+}
+
+CEdge::CEdge( int first, int second, int cost )
+{
+	m_first		= first;
+	m_second	= second;
+	m_cost		= cost;
+}
+
+CEdge::~CEdge( void )
+{
+}
+
+/*
+-------------------------
+CNode
+-------------------------
+*/
+
+CNode::CNode( void )
+{
+	m_numEdges		= 0;
+	m_radius		= 0;
+	m_ranks			= NULL;
+}
+
+CNode::~CNode( void )
+{
+	m_edges.clear();
+
+	if ( m_ranks )
+		delete [] m_ranks;
+}
+
+/*
+-------------------------
+Create
+-------------------------
+*/
+
+CNode *CNode::Create( vec3_t position, int flags, int radius, int ID )
+{
+	CNode	*node = new CNode;
+
+	VectorCopy( position, node->m_position );
+	
+	node->m_flags = flags;
+	node->m_ID = ID;
+	node->m_radius = radius;
+
+	return node;
+}
+
+/*
+-------------------------
+Create
+-------------------------
+*/
+
+CNode *CNode::Create( void )
+{
+	return new CNode;
+}
+
+/*
+-------------------------
+AddEdge
+-------------------------
+*/
+
+void CNode::AddEdge( int ID, int cost, int flags )
+{
+	if ( m_numEdges )
+	{//already have at least 1
+		//see if it exists already
+		edge_v::iterator	ei;
+		STL_ITERATE( ei, m_edges )
+		{
+			if ( (*ei).ID == ID )
+			{//found it
+				(*ei).cost	= cost;
+				(*ei).flags	= flags;
+				return;
+			}
+		}
+	}
+	
+	edge_t	edge;
+
+	edge.ID		= ID;
+	edge.cost	= cost;
+	edge.flags	= flags;
+
+	STL_INSERT( m_edges, edge );
+
+	m_numEdges++;
+
+	assert( m_numEdges < 9 );//8 is the max
+}
+
+/*
+-------------------------
+GetEdge
+-------------------------
+*/
+
+int CNode::GetEdgeNumToNode( int ID )
+{
+	int count = 0;
+
+	edge_v::iterator	ei;
+	STL_ITERATE( ei, m_edges )
+	{
+		if ( (*ei).ID == ID )
+		{
+			return count;
+		}
+
+		count++;
+	}
+	return -1;
+}
+
+/*
+-------------------------
+AddRank
+-------------------------
+*/
+
+void CNode::AddRank( int ID, int rank )
+{
+	assert( m_ranks );
+
+	m_ranks[ ID ] = rank;
+}
+
+/*
+-------------------------
+Draw
+-------------------------
+*/
+
+void CNode::Draw( qboolean showRadius )
+{ //rwwFIXMEFIXME: ...
+	/*
+	CG_DrawNode( m_position, NODE_NORMAL );
+	if( showRadius )
+	{
+		CG_DrawRadius( m_position, m_radius, NODE_NORMAL );
+	}
+	*/
+}
+
+/*
+-------------------------
+GetEdge
+-------------------------
+*/
+
+int CNode::GetEdge( int edgeNum )
+{
+	if ( edgeNum > m_numEdges )
+		return -1;
+
+	int count = 0;
+
+	edge_v::iterator	ei;
+	STL_ITERATE( ei, m_edges )
+	{
+		if ( count == edgeNum )
+		{
+			return (*ei).ID;
+		}
+
+		count++;
+	}
+
+	return -1;
+}
+
+/*
+-------------------------
+GetEdgeCost
+-------------------------
+*/
+
+int CNode::GetEdgeCost( int edgeNum )
+{
+	if ( edgeNum > m_numEdges )
+		return Q3_INFINITE; // return -1;
+
+	int count = 0;
+
+	edge_v::iterator	ei;
+	STL_ITERATE( ei, m_edges )
+	{
+		if ( count == edgeNum )
+		{
+			return (*ei).cost;
+		}
+
+		count++;
+	}
+
+	return Q3_INFINITE; // return -1;
+}
+
+/*
+-------------------------
+GetEdgeFlags
+-------------------------
+*/
+
+BYTE CNode::GetEdgeFlags( int edgeNum )
+{
+	if ( edgeNum > m_numEdges )
+		return 0;
+
+	int count = 0;
+
+	edge_v::iterator	ei;
+	STL_ITERATE( ei, m_edges )
+	{
+		if ( count == edgeNum )
+		{
+			return (*ei).flags;
+		}
+
+		count++;
+	}
+	
+	return 0;
+}
+
+/*
+-------------------------
+SetEdgeFlags
+-------------------------
+*/
+
+void CNode::SetEdgeFlags( int edgeNum, int newFlags )
+{
+	if ( edgeNum > m_numEdges )
+		return;
+
+	int count = 0;
+
+	edge_v::iterator	ei;
+	STL_ITERATE( ei, m_edges )
+	{
+		if ( count == edgeNum )
+		{
+			(*ei).flags = newFlags;
+			return;
+		}
+
+		count++;
+	}
+
+}
+/*
+-------------------------
+InitRanks
+-------------------------
+*/
+
+void CNode::InitRanks( int size )
+{
+	//Clear it if it's already allocated
+	if ( m_ranks != NULL )
+	{
+		delete [] m_ranks;
+		m_ranks = NULL;
+	}
+
+	m_ranks = new int[size];
+
+	memset( m_ranks, -1, sizeof(int)*size );
+}
+
+/*
+-------------------------
+GetRank
+-------------------------
+*/
+
+int CNode::GetRank( int ID )
+{
+	assert( m_ranks );
+
+	return m_ranks[ ID ];
+}
+
+
+/*
+-------------------------
+Save
+-------------------------
+*/
+
+int	CNode::Save( int numNodes, fileHandle_t file )
+{
+	//Write out the header
+	unsigned long header = NODE_HEADER_ID;
+	FS_Write( &header, sizeof( header ), file );
+
+	//Write out the basic information
+	int i;
+	for ( i = 0; i < 3; i++ )
+		FS_Write( &m_position[i], sizeof( float ), file );
+
+	FS_Write( &m_flags, sizeof( m_flags ), file );
+	FS_Write( &m_ID, sizeof( m_ID ), file );
+	FS_Write( &m_radius, sizeof( m_radius ), file );
+
+	//Write out the edge information
+	FS_Write( &m_numEdges, sizeof( m_numEdges ), file );
+
+	edge_v::iterator	ei;
+	STL_ITERATE( ei, m_edges )
+	{
+		FS_Write( &(*ei), sizeof( edge_t ), file );
+	}
+
+	//Write out the node ranks
+	FS_Write( &numNodes, sizeof( numNodes ), file );
+
+	for ( i = 0; i < numNodes; i++ )
+	{
+		FS_Write( &m_ranks[i], sizeof( int ), file );
+	}
+
+	return true;
+}
+
+/*
+-------------------------
+Load
+-------------------------
+*/
+
+int CNode::Load( int numNodes, fileHandle_t file )
+{
+	unsigned long header;
+	FS_Read( &header, sizeof(header), file );
+
+	//Validate the header
+	if ( header != NODE_HEADER_ID )
+		return false;
+
+	//Get the basic information
+	int i;
+	for ( i = 0; i < 3; i++ )
+		FS_Read( &m_position[i], sizeof( float ), file );
+
+	FS_Read( &m_flags, sizeof( m_flags ), file );
+	FS_Read( &m_ID, sizeof( m_ID ), file );
+	FS_Read( &m_radius, sizeof( m_radius ), file );
+
+	//Get the edge information
+	FS_Read( &m_numEdges, sizeof( m_numEdges ), file );
+
+	for ( i = 0; i < m_numEdges; i++ )
+	{
+		edge_t	edge;
+
+		FS_Read( &edge, sizeof( edge_t ), file );
+
+		STL_INSERT( m_edges, edge );
+	}
+
+	//Read the node ranks
+	int	numRanks;
+
+	FS_Read( &numRanks, sizeof( numRanks ), file );
+
+	//Allocate the memory
+	InitRanks( numRanks );
+
+	for ( i = 0; i < numRanks; i++ )
+	{
+		FS_Read( &m_ranks[i], sizeof( int ), file );
+	}
+
+	return true;
+}
+
+/*
+-------------------------
+CNavigator
+-------------------------
+*/
+
+CNavigator::CNavigator( void )
+{
+	if (!d_altRoutes || !d_patched)
+	{
+		NAV_CvarInit();
+	}
+}
+
+CNavigator::~CNavigator( void )
+{
+}
+
+/*
+-------------------------
+FlagAllNodes
+-------------------------
+*/
+
+void CNavigator::FlagAllNodes( int newFlag )
+{
+	node_v::iterator	ni;
+
+	STL_ITERATE( ni, m_nodes )
+	{
+		(*ni)->AddFlag( newFlag );
+	}
+}
+
+/*
+-------------------------
+GetChar
+-------------------------
+*/
+
+char CNavigator::GetChar( fileHandle_t file )
+{
+	char value;
+
+	FS_Read( &value, sizeof( value ), file );
+
+	return value;
+}
+
+/*
+-------------------------
+GetInt
+-------------------------
+*/
+
+int	CNavigator::GetInt( fileHandle_t file )
+{
+	int value;
+
+	FS_Read( &value, sizeof( value ), file );
+
+	return value;
+}
+
+/*
+-------------------------
+GetFloat
+-------------------------
+*/
+
+float CNavigator::GetFloat( fileHandle_t file )
+{
+	float value;
+
+	FS_Read( &value, sizeof( value ), file );
+
+	return value;
+}
+
+/*
+-------------------------
+GetLong
+-------------------------
+*/
+
+long CNavigator::GetLong( fileHandle_t file )
+{
+	long value;
+
+	FS_Read( &value, sizeof( value ), file );
+
+	return value;
+}
+
+/*
+-------------------------
+Init
+-------------------------
+*/
+
+void CNavigator::Init( void )
+{
+	Free();
+}
+
+/*
+-------------------------
+Free
+-------------------------
+*/
+
+void CNavigator::Free( void )
+{
+	node_v::iterator	ni;
+
+	STL_ITERATE( ni, m_nodes )
+	{
+		delete (*ni);
+	}
+
+	m_nodes.clear();
+	m_edgeLookupMap.clear();
+}
+
+/*
+-------------------------
+Load
+-------------------------
+*/
+
+bool CNavigator::Load( const char *filename, int checksum )
+{
+	fileHandle_t	file;
+
+	//Attempt to load the file
+	FS_FOpenFileByMode( va( "maps/%s.nav", filename ), &file, FS_READ );
+
+	//See if we succeeded
+	if ( file == NULL )
+		return false;
+
+	//Check the header id
+	long navID = GetLong( file );
+
+	if ( navID != NAV_HEADER_ID )
+	{
+		FS_FCloseFile( file );
+		return false;
+	}
+
+	//Check the checksum to see if this file is out of date
+	int check = GetInt( file );
+
+	if ( check != checksum )
+	{
+		FS_FCloseFile( file );
+		return false;
+	}
+
+	int numNodes = GetInt( file );
+	
+	for ( int i = 0; i < numNodes; i++ )
+	{
+		CNode	*node = CNode::Create();
+
+		if ( node->Load( numNodes, file ) == false )
+		{
+			FS_FCloseFile( file );
+			return false;
+		}
+
+		STL_INSERT( m_nodes, node );
+	}
+
+	//read in the failed edges
+	FS_Read( &failedEdges, sizeof( failedEdges ), file );
+	for ( int j = 0; j < MAX_FAILED_EDGES; j++ )
+	{
+		m_edgeLookupMap.insert(pair<int, int>(failedEdges[j].startID, j));		
+	}
+		
+
+	FS_FCloseFile( file );
+
+	return true;
+}
+
+/*
+-------------------------
+Save
+-------------------------
+*/
+
+bool CNavigator::Save( const char *filename, int checksum )
+{
+	fileHandle_t	file;
+
+	//Attempt to load the file
+	FS_FOpenFileByMode( va( "maps/%s.nav", filename ), &file, FS_WRITE );
+
+	if ( file == NULL )
+		return false;
+
+	//Write out the header id
+	unsigned long id = NAV_HEADER_ID;
+
+	FS_Write( &id, sizeof (id), file );
+
+	//Write out the checksum
+	FS_Write( &checksum, sizeof( checksum ), file );
+
+	int	numNodes = m_nodes.size();
+
+	//Write out the number of nodes to follow
+	FS_Write( &numNodes, sizeof(numNodes), file );
+
+	//Write out all the nodes
+	node_v::iterator	ni;
+
+	STL_ITERATE( ni, m_nodes )
+	{
+		(*ni)->Save( numNodes, file );
+	}
+
+	//write out failed edges
+	FS_Write( &failedEdges, sizeof( failedEdges ), file );
+
+	FS_FCloseFile( file );
+
+	return true;
+}
+
+/*
+-------------------------
+AddRawPoint
+-------------------------
+*/
+
+int CNavigator::AddRawPoint( vec3_t point, int flags, int radius )
+{
+	CNode	*node	= CNode::Create( point, flags, radius, m_nodes.size() );
+
+	if ( node == NULL )
+	{
+		Com_Error( ERR_DROP, "Error adding node!\n" );
+		return -1;
+	}
+	
+	//TODO: Validate the position
+	//TODO: Correct stuck waypoints
+
+	STL_INSERT( m_nodes, node );
+
+	return node->GetID();
+}
+
+/*
+-------------------------
+GetEdgeCost
+-------------------------
+*/
+
+int	CNavigator::GetEdgeCost( CNode *first, CNode *second )
+{
+	trace_t	trace;
+	vec3_t	start, end;
+	vec3_t	mins, maxs;
+
+	//Setup the player size
+	VectorSet( mins, -8, -8, -8 );
+	VectorSet( maxs,  8,  8,  8 );
+
+	//Setup the points
+	first->GetPosition( start );
+	second->GetPosition( end );
+
+	SV_Trace( &trace, start, mins, maxs, end, ENTITYNUM_NONE, MASK_SOLID, qfalse, 0, 10 );
+
+	if ( trace.fraction < 1.0f || trace.allsolid || trace.startsolid )
+		return Q3_INFINITE; // return -1;
+
+	//Connection successful, return the cost
+	return Distance( start, end );
+}
+
+void CNavigator::SetEdgeCost( int ID1, int ID2, int cost )
+{
+	if( (ID1 == -1) || (ID2 == -1) )
+	{//not valid nodes, must have come from the ClearAllFailedEdges initization-type calls
+		return;
+	}
+
+	CNode	*node1 = m_nodes[ID1];
+	CNode	*node2 = m_nodes[ID2];
+
+	if ( cost == -1 )
+	{//they want us to calc it
+		//FIXME: can we just remember this instead of recalcing every time?
+		vec3_t	pos1, pos2;
+		
+		node1->GetPosition( pos1 );
+		node2->GetPosition( pos2 );
+		cost = Distance( pos1, pos2 );
+	}
+
+	//set it
+	node1->AddEdge( ID2, cost );
+	node2->AddEdge( ID1, cost );
+}
+
+/*
+-------------------------
+AddNodeEdges
+-------------------------
+*/
+
+void CNavigator::AddNodeEdges( CNode *node, int addDist, edge_l	&edgeList, bool *checkedNodes )
+{
+	//Add all edge
+	for ( int i = 0; i < node->GetNumEdges(); i++ )
+	{
+		//Make sure we don't add an old edge twice
+		if ( checkedNodes[ node->GetEdge( i ) ] == true )
+			continue;
+
+		//Get the node
+		CNode	*nextNode = m_nodes[ node->GetEdge( i ) ];
+
+		//This node has now been checked
+		checkedNodes[ nextNode->GetID() ] = true;
+
+		//Add it to the list
+		STL_INSERT( edgeList, CEdge( nextNode->GetID(), node->GetID(), addDist + ( node->GetEdgeCost( i ) ) ) );
+	}
+}
+
+/*
+-------------------------
+CalculatePath
+-------------------------
+*/
+
+void CNavigator::CalculatePath( CNode *node )
+{
+	int	curRank = 0;
+
+	CPriorityQueue	*pathList = new CPriorityQueue();
+	BYTE			*checked;
+
+	//Init the completion table
+	checked = new BYTE[ m_nodes.size() ];
+	memset( checked, 0, m_nodes.size() );
+
+	//Mark this node as checked
+	checked[ node->GetID() ] = true;
+	node->AddRank( node->GetID(), curRank++ );
+
+	//Add all initial nodes
+	int i;
+	for ( i = 0; i < node->GetNumEdges(); i++ )
+	{
+		CNode	*nextNode = m_nodes[ node->GetEdge(i) ];
+		assert(nextNode);
+
+		checked[ nextNode->GetID() ] = true;
+
+		pathList->Push( new CEdge( nextNode->GetID(), nextNode->GetID(), node->GetEdgeCost(i) ) );
+	}
+
+	float				minDist;
+	CEdge				*test;	
+
+	//Now flood fill all the others
+	while ( !pathList->Empty() )
+	{
+		minDist = Q3_INFINITE;			
+		test	 = pathList->Pop();
+		
+		CNode	*testNode = m_nodes[ (*test).m_first ];
+		assert( testNode );
+
+		node->AddRank( testNode->GetID(), curRank++ );
+
+		//Add in all the new edges
+		for ( i = 0; i < testNode->GetNumEdges(); i++ )
+		{
+			CNode	*addNode = m_nodes[ testNode->GetEdge(i) ];
+			assert( addNode );
+
+			if ( checked[ addNode->GetID() ] )
+				continue;
+
+			int	newDist = (*test).m_cost + testNode->GetEdgeCost(i);
+			pathList->Push( new CEdge( addNode->GetID(), (*test).m_second, newDist ) );
+
+			checked[ addNode->GetID() ] = true;
+		}
+		delete test;
+
+	}
+
+	node->RemoveFlag( NF_RECALC );
+
+	delete pathList;
+	delete [] checked;
+}
+
+/*
+-------------------------
+CalculatePaths
+-------------------------
+*/
+void CNavigator::CalculatePaths( qboolean recalc )
+{
+#if _HARD_CONNECT
+#else
+#endif	
+
+	int i;
+	for ( i = 0; i < m_nodes.size(); i++ )
+	{
+		//Allocate the needed memory
+		m_nodes[i]->InitRanks( m_nodes.size() );
+	}
+
+	for ( i = 0; i < m_nodes.size(); i++ )
+	{
+		CalculatePath( m_nodes[i] );
+	}
+		
+	if(!recalc)	//Mike says doesn't need to happen on recalc
+	{
+		GNavCallback_CP_FindCombatPointWaypoints();
+	}
+
+	pathsCalculated = qtrue;
+}
+
+/*
+-------------------------
+ShowNodes
+-------------------------
+*/
+
+void CNavigator::ShowNodes( void )
+{
+	node_v::iterator	ni;
+
+	vec3_t	position;
+	qboolean showRadius;
+	float	dist,
+			radius;
+
+	STL_ITERATE( ni, m_nodes )
+	{
+		(*ni)->GetPosition( position );
+
+		showRadius = qfalse;
+		//if( NAVDEBUG_showRadius )
+		if (0)
+		{	
+			dist = DistanceSquared( SV_GentityNum(0)->r.currentOrigin, position );
+			radius = (*ni)->GetRadius();
+			// if player within node radius or 256, draw radius (sometimes the radius is really small, so we check for 256 to catch everything)
+			if( (dist <= radius*radius) || dist <= 65536 ) 
+			{
+				showRadius = qtrue;
+			}
+		}
+		else
+		{
+			dist = DistanceSquared( SV_GentityNum(0)->r.currentOrigin, position );
+		}
+		if ( dist < 1048576 )
+		{
+			if ( SV_inPVS( SV_GentityNum(0)->r.currentOrigin, position ) )
+			{
+				(*ni)->Draw(showRadius);
+			}
+		}
+	}
+}
+
+/*
+-------------------------
+ShowEdges
+-------------------------
+*/
+
+typedef	map < int, bool >		drawMap_m;
+
+void CNavigator::ShowEdges( void )
+{
+	node_v::iterator	ni;
+	vec3_t	start, end;
+
+	drawMap_m	*drawMap;
+
+	drawMap = new drawMap_m[ m_nodes.size() ];
+
+	STL_ITERATE( ni, m_nodes )
+	{
+		(*ni)->GetPosition( start );
+		if ( DistanceSquared( SV_GentityNum(0)->r.currentOrigin, start ) >= 1048576 )
+		{
+			continue;
+		}
+
+		if (!SV_inPVS(SV_GentityNum(0)->r.currentOrigin, start))
+		{
+			continue;
+		}
+
+		//Attempt to draw each connection
+		for ( int i = 0; i < (*ni)->GetNumEdges(); i++ )
+		{
+			int id = (*ni)->GetEdge( i );
+
+			if ( id == -1 )
+				continue;
+
+			//Already drawn?
+			if ( drawMap[(*ni)->GetID()].find( id ) != drawMap[(*ni)->GetID()].end() )
+				continue;
+
+			//BYTE flags = (*ni)->GetEdgeFlags( i );
+
+			CNode	*node = m_nodes[id];
+
+			node->GetPosition( end );
+
+			//Set this as drawn
+			drawMap[id][(*ni)->GetID()] = true;
+
+			if ( DistanceSquared( SV_GentityNum(0)->r.currentOrigin, end ) >= 1048576 )
+			{
+				continue;
+			}
+
+			if ( !SV_inPVS( SV_GentityNum(0)->r.currentOrigin, end ) )
+				continue;
+
+			/*
+			if ( EdgeFailed( id, (*ni)->GetID() ) != -1 )//flags & EFLAG_FAILED )
+				CG_DrawEdge( start, end, EDGE_FAILED );
+			else if ( flags & EFLAG_BLOCKED )
+				CG_DrawEdge( start, end, EDGE_BLOCKED );
+			else
+				CG_DrawEdge( start, end, EDGE_NORMAL );
+			*/
+			//rwwFIXMEFIXME: ...
+		}
+	}
+
+	delete [] drawMap;
+}
+
+int CNavigator::GetNodeRadius( int nodeID )
+{
+	if ( m_nodes.size() == 0 )
+		return 0;
+	return m_nodes[nodeID]->GetRadius();
+}
+
+void CNavigator::CheckBlockedEdges( void )
+{
+	CNode	*start, *end;
+	vec3_t	p1, p2;
+	int		flags, first, second;
+	trace_t	trace;
+	qboolean failed;
+	int		edgeNum;
+	node_v::iterator	ni;
+
+	//Go through all edges and test the ones that were blocked
+	STL_ITERATE( ni, m_nodes )
+	{
+		//Attempt to draw each connection
+		for ( edgeNum = 0; edgeNum < (*ni)->GetNumEdges(); edgeNum++ )
+		{
+			flags = (*ni)->GetEdgeFlags( edgeNum );
+			if ( (flags&EFLAG_BLOCKED) )
+			{
+				first	= (*ni)->GetID();
+				second	= (*ni)->GetEdge( edgeNum );
+				start	= m_nodes[first];
+				end		= m_nodes[second];
+				failed	= qfalse;
+
+				start->GetPosition( p1 );
+				end->GetPosition( p2 );
+
+				//FIXME: can't we just store the trace.entityNum from the HardConnect trace?  So we don't have to do another trace here...
+				SV_Trace( &trace, p1, wpMins, wpMaxs, p2, ENTITYNUM_NONE, MASK_SOLID|CONTENTS_MONSTERCLIP|CONTENTS_BOTCLIP, qfalse, 0, 10 );
+
+				if ( trace.entityNum < ENTITYNUM_WORLD && (trace.fraction < 1.0f || trace.startsolid == qtrue || trace.allsolid == qtrue) )
+				{//could be assumed, since failed before
+					if ( GNavCallback_G_EntIsDoor( trace.entityNum ) )
+					{//door
+						if ( !GNavCallback_G_EntIsUnlockedDoor( trace.entityNum ) )
+						{//locked door
+							failed = qtrue;
+						}
+					}
+					else
+					{
+						if ( GNavCallback_G_EntIsBreakable( trace.entityNum ) )
+						{//do same for breakable brushes/models/glass?
+							failed = qtrue;
+						}
+						else if ( GNavCallback_G_EntIsRemovableUsable( trace.entityNum ) )
+						{
+							failed = qtrue;
+						}
+						else if ( trace.allsolid || trace.startsolid )
+						{//FIXME: the entitynum would be none here, so how do we know if this is stuck inside an ent or the world?
+						}
+						else
+						{//FIXME: what about func_plats and scripted movers?
+						}
+					}
+				}
+
+				if ( failed )
+				{
+					//could add the EFLAG_FAILED to the two edges, but we stopped doing that since it was pointless
+					AddFailedEdge( ENTITYNUM_NONE, first, second );
+				}
+			}
+		}
+	}
+}
+
+#if _HARD_CONNECT
+
+/*
+-------------------------
+HardConnect
+-------------------------
+*/
+
+void CNavigator::HardConnect( int first, int second )
+{
+	CNode	*start, *end;
+
+	start	= m_nodes[first];
+	end		= m_nodes[second];
+
+	vec3_t	p1, p2;
+
+	start->GetPosition( p1 );
+	end->GetPosition( p2 );
+
+	trace_t	trace;
+	
+	int		flags = EFLAG_NONE;
+
+	SV_Trace( &trace, p1, wpMins, wpMaxs, p2, ENTITYNUM_NONE, MASK_SOLID|CONTENTS_BOTCLIP|CONTENTS_MONSTERCLIP, qfalse, 0, 10 );
+
+	int cost = Distance( p1, p2 );
+
+	if ( trace.fraction != 1.0f || trace.startsolid == qtrue || trace.allsolid == qtrue )
+	{
+		flags |= EFLAG_BLOCKED;
+	}
+
+	start->AddEdge( second, cost, flags );
+	end->AddEdge( first, cost, flags );
+}
+
+#endif
+
+/*
+-------------------------
+TestNodePath
+-------------------------
+*/
+
+int CNavigator::TestNodePath( sharedEntity_t *ent, int okToHitEntNum, vec3_t position, qboolean includeEnts )
+{ //rwwFIXMEFIXME: Share clipmask?
+	int clipmask = MASK_SOLID;//ent->clipmask;
+
+	if ( !includeEnts )
+	{
+		clipmask &= ~CONTENTS_BODY;
+	}
+	//Check the path
+	if ( GNavCallback_NAV_ClearPathToPoint( ent, ent->r.mins, ent->r.maxs, position, clipmask, okToHitEntNum ) == false )
+		return false;
+	
+	return true;
+}
+
+/*
+-------------------------
+TestNodeLOS
+-------------------------
+*/
+
+int CNavigator::TestNodeLOS( sharedEntity_t *ent, vec3_t position )
+{
+	return GNavCallback_NPC_ClearLOS( ent, position );
+}
+
+/*
+-------------------------
+TestBestFirst
+-------------------------
+*/
+
+int	CNavigator::TestBestFirst( sharedEntity_t *ent, int lastID, int flags )
+{
+	//Must be a valid one to begin with
+	if ( lastID == NODE_NONE )
+		return NODE_NONE;
+
+	if ( lastID >= m_nodes.size() )
+		return NODE_NONE;
+
+	//Get the info
+	vec3_t	nodePos;
+	CNode	*node = m_nodes[ lastID ];
+	CNode	*testNode;
+	int		numEdges = node->GetNumEdges();
+	float	dist;
+
+	node->GetPosition( nodePos );
+
+	//Setup our last node as our root, and search for a closer one according to its edges	
+	int bestNode = ( TestNodePath( ent, ENTITYNUM_NONE, nodePos, qtrue ) ) ? lastID : NODE_NONE;
+	float bestDist = ( bestNode == NODE_NONE ) ? Q3_INFINITE : DistanceSquared( ent->r.currentOrigin, nodePos );
+
+	//Test all these edges first
+	for ( int i = 0; i < numEdges; i++ )
+	{
+		//Get this node and its distance
+		testNode = m_nodes[ node->GetEdge(i) ];
+
+		if ( NodeFailed( ent, testNode->GetID() ) )
+		{
+			continue;
+		}
+
+		testNode->GetPosition( nodePos );
+
+		dist = DistanceSquared( ent->r.currentOrigin, nodePos );
+
+		//Test against current best
+		if ( dist < bestDist )
+		{
+			//See if this node is valid
+			if ( CheckedNode(testNode->GetID(),ent->s.number) == CHECKED_PASSED || TestNodePath( ent, ENTITYNUM_NONE, nodePos, qtrue ) )
+			{
+				bestDist = dist;
+				bestNode = testNode->GetID();
+				SetCheckedNode(testNode->GetID(),ent->s.number,CHECKED_PASSED);
+			}
+			else
+			{
+				SetCheckedNode(testNode->GetID(),ent->s.number,CHECKED_FAILED);
+			}
+		}	
+	}
+
+	return bestNode;
+}
+
+/*
+-------------------------
+CollectNearestNodes
+-------------------------
+*/
+
+#define	NODE_COLLECT_MAX	16		//Maximum # of nodes collected at any time
+#define NODE_COLLECT_RADIUS	512		//Default radius to search for nodes in
+#define NODE_COLLECT_RADIUS_SQR		( NODE_COLLECT_RADIUS * NODE_COLLECT_RADIUS )
+
+int CNavigator::CollectNearestNodes( vec3_t origin, int radius, int maxCollect, nodeChain_l &nodeChain )
+{
+	node_v::iterator	ni;
+	float				dist;
+	vec3_t				position;
+	int					collected = 0;
+	bool				added = false;
+
+	//Get a distance rating for each node in the system
+	STL_ITERATE( ni, m_nodes )
+	{
+		//If we've got our quota, then stop looking
+		//Get the distance to the node
+		(*ni)->GetPosition( position );
+		dist = DistanceSquared( position, origin );
+
+		//Must be within our radius range
+		if ( dist > (float) ( radius * radius ) )
+			continue;
+		
+		nodeList_t				nChain;
+		nodeChain_l::iterator	nci;
+
+		//Always add the first node
+		if ( nodeChain.size() == 0 )
+		{
+			nChain.nodeID = (*ni)->GetID();
+			nChain.distance = dist;
+
+			nodeChain.insert( nodeChain.begin(), nChain );
+			continue;
+		}
+
+		added = false;
+
+		//Compare it to what we already have
+		STL_ITERATE( nci, nodeChain )
+		{
+			//If we're less, than this entry, then insert before it
+			if ( dist < (*nci).distance )
+			{
+				nChain.nodeID = (*ni)->GetID();
+				nChain.distance = dist;
+
+				nodeChain.insert( nci, nChain );
+				collected = nodeChain.size();
+				added = true;
+				
+				//If we've hit our collection limit, throw off the oldest one
+				if ( nodeChain.size() > maxCollect )
+				{
+					nodeChain.pop_back();
+				}
+
+				break;
+			}
+		}
+
+		//Otherwise, always pad out the collection if possible so we don't miss anything
+		if ( ( added == false ) && ( nodeChain.size() < maxCollect ) )
+		{
+			nChain.nodeID = (*ni)->GetID();
+			nChain.distance = dist;
+
+			nodeChain.insert( nodeChain.end(), nChain );
+		}
+	}
+
+	return collected;
+}
+
+int CNavigator::GetBestPathBetweenEnts( sharedEntity_t *ent, sharedEntity_t *goal, int flags )
+{
+	//Must have nodes
+	if ( m_nodes.size() == 0 )
+		return NODE_NONE;
+
+#define	MAX_Z_DELTA	18
+
+	nodeChain_l				nodeChain;
+	nodeChain_l::iterator	nci;
+	nodeChain_l				nodeChain2;
+	nodeChain_l::iterator	nci2;
+
+	//Collect all nodes within a certain radius
+	CollectNearestNodes( ent->r.currentOrigin, NODE_COLLECT_RADIUS, NODE_COLLECT_MAX, nodeChain );
+	CollectNearestNodes( goal->r.currentOrigin, NODE_COLLECT_RADIUS, NODE_COLLECT_MAX, nodeChain2 );
+
+	vec3_t				position;
+	vec3_t				position2;
+	int					radius;
+	int					cost, pathCost, bestCost = Q3_INFINITE;
+	CNode				*node, *node2;
+	int					nodeNum, nodeNum2;
+	int					nextNode = NODE_NONE, bestNode = NODE_NONE;
+	int					nodeFlags = 0;
+//	bool				recalc = false;
+
+	ent->waypoint = NODE_NONE;
+	goal->waypoint = NODE_NONE;
+
+	//Look through all nodes
+	STL_ITERATE( nci, nodeChain )
+	{
+		node = m_nodes[(*nci).nodeID];
+		nodeNum = (*nci).nodeID;
+
+		node->GetPosition( position );
+
+		if ( CheckedNode(nodeNum,ent->s.number) == CHECKED_FAILED )
+		{//already checked this node against ent and it failed
+			continue;
+		}
+		if ( CheckedNode(nodeNum,ent->s.number) == CHECKED_PASSED )
+		{//already checked this node against ent and it passed
+		}
+		else
+		{//haven't checked this node against ent yet
+			if ( NodeFailed( ent, nodeNum ) )
+			{
+				SetCheckedNode( nodeNum, ent->s.number, CHECKED_FAILED );
+				continue;
+			}
+			//okay, since we only have to do this once, let's check to see if this node is even usable (could help us short-circuit a whole loop of the dest nodes)
+			radius	= node->GetRadius();
+			
+			//If we're not within the known clear radius of this node OR out of Z height range...
+			if ( (*nci).distance >= (radius*radius) || ( fabs( position[2] - ent->r.currentOrigin[2] ) >= MAX_Z_DELTA ) )
+			{
+				//We're not *within* this node, so check clear path, etc.
+
+				//FIXME: any way to call G_FindClosestPointOnLineSegment and see if I can at least get to the waypoint's path
+				if ( flags & NF_CLEAR_PATH )//|| flags & NF_CLEAR_LOS )
+				{//need a clear path or LOS
+					if ( !SV_inPVS( ent->r.currentOrigin, position ) )
+					{//not even potentially clear
+						SetCheckedNode( nodeNum, ent->s.number, CHECKED_FAILED );
+						continue;
+					}
+				}
+
+				//Do we need a clear path?
+				if ( flags & NF_CLEAR_PATH )
+				{
+					if ( TestNodePath( ent, goal->s.number, position, qtrue ) == false )
+					{
+						SetCheckedNode( nodeNum, ent->s.number, CHECKED_FAILED );
+						continue;
+					}
+				}
+			}//otherwise, inside the node so it must be clear (?)
+			SetCheckedNode( nodeNum, ent->s.number, CHECKED_PASSED );
+		}
+
+		if ( d_altRoutes->integer )
+		{
+			//calc the paths for this node if they're out of date
+			nodeFlags = node->GetFlags();
+			if ( (nodeFlags&NF_RECALC) )
+			{
+				//Com_Printf( S_COLOR_CYAN"%d recalcing paths from node %d\n", svs.time, nodeNum );
+				CalculatePath( node );
+			}
+		}
+
+		STL_ITERATE( nci2, nodeChain2 )
+		{
+			node2 = m_nodes[(*nci2).nodeID];
+			nodeNum2 = (*nci2).nodeID;
+			if ( d_altRoutes->integer )
+			{
+				//calc the paths for this node if they're out of date
+				nodeFlags = node2->GetFlags();
+				if ( (nodeFlags&NF_RECALC) )
+				{
+					//Com_Printf( S_COLOR_CYAN"%d recalcing paths from node %d\n", svs.time, nodeNum2 );
+					CalculatePath( node2 );
+				}
+			}
+
+			node2->GetPosition( position2 );
+			//Okay, first get the entire path cost, including distance to first node from ents' positions
+			cost = floor(Distance( ent->r.currentOrigin, position ) + Distance( goal->r.currentOrigin, position2 ));
+
+			if ( d_altRoutes->integer )
+			{
+				nextNode = GetBestNodeAltRoute( (*nci).nodeID, (*nci2).nodeID, &pathCost, bestNode );
+				cost += pathCost;
+			}
+			else
+			{
+				cost += GetPathCost( (*nci).nodeID, (*nci2).nodeID );
+			}
+
+			if ( cost >= bestCost )
+			{
+				continue;
+			}
+
+			//okay, this is the shortest path we've found yet, check clear path, etc.
+			if ( CheckedNode( nodeNum2, goal->s.number ) == CHECKED_FAILED )
+			{//already checked this node against goal and it failed
+				continue;
+			}
+			if ( CheckedNode( nodeNum2, goal->s.number ) == CHECKED_PASSED )
+			{//already checked this node against goal and it passed
+			}
+			else
+			{//haven't checked this node against goal yet
+				if ( NodeFailed( goal, nodeNum2 ) )
+				{
+					SetCheckedNode( nodeNum2, goal->s.number, CHECKED_FAILED );
+					continue;
+				}
+				radius	= node2->GetRadius();
+				
+				//If we're not within the known clear radius of this node OR out of Z height range...
+				if ( (*nci2).distance >= (radius*radius) || ( fabs( position2[2] - goal->r.currentOrigin[2] ) >= MAX_Z_DELTA ) )
+				{
+					//We're not *within* this node, so check clear path, etc.
+
+					if ( flags & NF_CLEAR_PATH )//|| flags & NF_CLEAR_LOS )
+					{//need a clear path or LOS
+						if ( !SV_inPVS( goal->r.currentOrigin, position2 ) )
+						{//not even potentially clear
+							SetCheckedNode( nodeNum2, goal->s.number, CHECKED_FAILED );
+							continue;
+						}
+					}
+					//Do we need a clear path?
+					if ( flags & NF_CLEAR_PATH )
+					{
+						if ( TestNodePath( goal, ent->s.number, position2, qfalse ) == false )//qtrue?
+						{
+							SetCheckedNode( nodeNum2, goal->s.number, CHECKED_FAILED );
+							continue;
+						}
+					}
+				}//otherwise, inside the node so it must be clear (?)
+				SetCheckedNode( nodeNum2, goal->s.number, CHECKED_PASSED );
+			}
+
+			bestCost = cost;
+			bestNode = nextNode;
+			ent->waypoint = (*nci).nodeID;
+			goal->waypoint = (*nci2).nodeID;
+		}
+	}
+
+	if ( !d_altRoutes->integer )
+	{//bestNode would not have been set by GetBestNodeAltRoute above, so get it here
+		if ( ent->waypoint != NODE_NONE && goal->waypoint != NODE_NONE )
+		{//have 2 valid waypoints which means a valid path
+			bestNode = GetBestNodeAltRoute( ent->waypoint, goal->waypoint, &bestCost, NODE_NONE );
+		}
+	}
+	return bestNode;
+}
+
+/*
+-------------------------
+GetNearestWaypoint
+-------------------------
+*/
+
+int CNavigator::GetNearestNode( sharedEntity_t *ent, int lastID, int flags, int targetID )
+{
+	int	bestNode = NODE_NONE;
+	//Must have nodes
+	if ( m_nodes.size() == 0 )
+		return NODE_NONE;
+
+	if ( targetID == NODE_NONE )
+	{
+		//Try and find an early match using our last node
+		bestNode = TestBestFirst( ent, lastID, flags );
+
+		if ( bestNode != NODE_NONE )
+			return bestNode;
+	}//else can't rely on testing last, we want best to targetID
+
+/////////////////////////////////////////////////
+
+#define	MAX_Z_DELTA	18
+
+/////////////////////////////////////////////////
+
+	nodeChain_l				nodeChain;
+	nodeChain_l::iterator	nci;
+
+	//Collect all nodes within a certain radius
+	CollectNearestNodes( ent->r.currentOrigin, NODE_COLLECT_RADIUS, NODE_COLLECT_MAX, nodeChain );
+
+	vec3_t				position;
+	int					radius;
+	int					dist, bestDist = Q3_INFINITE;
+	CNode				*node;
+
+	//Look through all nodes
+	STL_ITERATE( nci, nodeChain )
+	{
+		node = m_nodes[(*nci).nodeID];
+
+		node->GetPosition( position );
+
+		radius	= node->GetRadius();
+		
+		if ( NodeFailed( ent, (*nci).nodeID ) )
+		{
+			continue;
+		}
+		//Are we within the known clear radius of this node?
+		if ( (*nci).distance < (radius*radius) )
+		{
+			//Do a z-difference sanity check
+			if ( fabs( position[2] - ent->r.currentOrigin[2] ) < MAX_Z_DELTA )
+			{
+				//Found one		
+				return (*nci).nodeID;
+			}
+		}
+
+		//We're not *within* this node, so...
+		if ( CheckedNode((*nci).nodeID,ent->s.number) == CHECKED_FAILED )
+		{
+			continue;
+		}
+		else if ( CheckedNode((*nci).nodeID,ent->s.number) == CHECKED_FAILED )
+		{
+			continue;
+		}
+		else
+		{
+			//Do we need a clear path?
+			if ( flags & NF_CLEAR_PATH )
+			{
+				if ( TestNodePath( ent, ENTITYNUM_NONE, position, qfalse ) == false )//qtrue?
+				{
+					SetCheckedNode((*nci).nodeID,ent->s.number,CHECKED_FAILED);
+					continue;
+				}
+			}
+
+			//Do we need a clear line of sight?
+			/*
+			if ( flags & NF_CLEAR_LOS )
+			{
+				if ( TestNodeLOS( ent, position ) == false )
+				{
+					nodeChecked[(*nci).nodeID][ent->s.number] = CHECKED_FAILED;
+					continue;
+				}
+			}
+			*/
+			SetCheckedNode((*nci).nodeID,ent->s.number,CHECKED_PASSED);
+		}
+
+		if ( targetID != WAYPOINT_NONE )
+		{//we want to find the one with the shortest route here
+			dist = GetPathCost( (*nci).nodeID, targetID );
+			if ( dist < bestDist )
+			{
+				bestDist = dist;
+				bestNode = (*nci).nodeID;
+			}
+		}
+		else
+		{//first one we find is fine
+			bestNode = (*nci).nodeID;
+			break;
+		}
+	}
+
+	//Found one, we're done
+	return bestNode;
+}
+
+/*
+-------------------------
+ShowPath
+-------------------------
+*/
+
+void CNavigator::ShowPath( int start, int end )
+{	
+	//Validate the start position
+	if ( ( start < 0 ) || ( start >= m_nodes.size() ) )
+		return;
+
+	//Validate the end position
+	if ( ( end < 0 ) || ( end >= m_nodes.size() ) )
+		return;
+
+	CNode	*startNode	= m_nodes[ start ];
+	CNode	*endNode	= m_nodes[ end ];
+	
+	CNode	*moveNode = startNode;
+	CNode	*testNode = NULL;
+
+	int		bestNode;
+	vec3_t	startPos, endPos;
+
+	int		runAway = 0;
+
+	//Draw out our path
+	while ( moveNode != endNode )
+	{
+		bestNode = GetBestNode( moveNode->GetID(), end );
+		
+		//Some nodes may be fragmented
+		if ( bestNode == -1 )
+		{
+			Com_Printf("No connection possible between node %d and %d\n", start, end );
+			return;
+		}
+
+		//This is our next node on the path
+		testNode = m_nodes[ bestNode ];
+
+		//Get their origins
+		moveNode->GetPosition( startPos );
+		testNode->GetPosition( endPos );
+		
+		//Draw the edge
+		//rwwFIXMEFIXME: ...
+		//CG_DrawEdge( startPos, endPos, EDGE_PATH );
+
+		//Take a new best node
+		moveNode = testNode;
+
+		if ( runAway++ > 64 )
+		{
+			Com_Printf("Potential Run-away path!\n");
+			return;
+		}
+	}
+}
+
+static map<int,byte> CheckedNodes;
+void CNavigator::ClearCheckedNodes( void )
+{
+	CheckedNodes.clear();
+}
+
+byte CNavigator::CheckedNode(int wayPoint,int ent)
+{
+	//assert(wayPoint>=0&&wayPoint<MAX_STORED_WAYPOINTS);
+	if (wayPoint < 0 || wayPoint >= MAX_STORED_WAYPOINTS)
+	{
+		return CHECKED_NO;
+	}
+	assert(ent>=0&&ent<MAX_GENTITIES);
+	map<int,byte>::iterator f=CheckedNodes.find(wayPoint*MAX_GENTITIES+ent);
+	if (f!=CheckedNodes.end())
+	{
+		return (*f).second;
+	}
+	return CHECKED_NO;
+}
+
+void CNavigator::SetCheckedNode(int wayPoint,int ent,byte value)
+{
+	//assert(wayPoint>=0&&wayPoint<MAX_STORED_WAYPOINTS);
+	if (wayPoint < 0 || wayPoint >= MAX_STORED_WAYPOINTS)
+	{
+		return;
+	}
+	assert(ent>=0&&ent<MAX_GENTITIES);
+	assert(value==CHECKED_FAILED||value==CHECKED_PASSED);
+	CheckedNodes[wayPoint*MAX_GENTITIES+ent]=value;
+}
+
+#define	CHECK_FAILED_EDGE_INTERVAL	1000
+#define	CHECK_FAILED_EDGE_INTITIAL	5000//10000
+
+void CNavigator::CheckFailedNodes( sharedEntity_t *ent )
+{
+	vec3_t	nodePos;
+	int		j;
+
+	//Must have nodes
+	if ( m_nodes.size() == 0 )
+		return;
+
+	if ( ent->failedWaypointCheckTime && ent->failedWaypointCheckTime < svs.time )
+	{
+		int failed = 0;
+		//do this only once every 1 second
+		for ( j = 0; j < MAX_FAILED_NODES; j++ )
+		{
+			if ( ent->failedWaypoints[j] != 0 )
+			{
+				failed++;
+				//-1 because 0 is a valid node but also the default, so we add one when we add one
+				m_nodes[ent->failedWaypoints[j]-1]->GetPosition( nodePos );
+				if ( !GNavCallback_NAV_ClearPathToPoint( ent, ent->r.mins, ent->r.maxs, nodePos, (CONTENTS_SOLID|CONTENTS_MONSTERCLIP|CONTENTS_BOTCLIP), ENTITYNUM_NONE ) )
+				{//no path clear of architecture, so clear this since we can't check against entities
+					ent->failedWaypoints[j] = 0;
+					failed--;
+				}
+				//have clear architectural path, now check against ents only
+				else if ( GNavCallback_NAV_ClearPathToPoint( ent, ent->r.mins, ent->r.maxs, nodePos, CONTENTS_BODY, ENTITYNUM_NONE ) )
+				{//clear of ents, too, so all clear, clear this one out
+					ent->failedWaypoints[j] = 0;
+					failed--;
+				}
+			}
+		}
+		if ( !failed )
+		{
+			ent->failedWaypointCheckTime = 0;
+		}
+		else
+		{
+			ent->failedWaypointCheckTime = svs.time + CHECK_FAILED_EDGE_INTERVAL + Q_irand( 0, 1000 );
+		}
+	}
+}
+
+void CNavigator::AddFailedNode( sharedEntity_t *ent, int nodeID )
+{
+	int j;
+	for ( j = 0; j < MAX_FAILED_NODES; j++ )
+	{
+		if ( ent->failedWaypoints[j] == 0 )
+		{
+			ent->failedWaypoints[j] = nodeID+1;//+1 because 0 is the default value and that's a valid node, so we take the +1 out when we check the node above
+			if ( !ent->failedWaypointCheckTime )
+			{
+				ent->failedWaypointCheckTime = svs.time + CHECK_FAILED_EDGE_INTITIAL;
+			}
+			return;
+		}
+		if ( ent->failedWaypoints[j] == nodeID+1 )
+		{//already have this one marked as failed
+			return;
+		}
+	}
+	if ( j == MAX_FAILED_NODES )//check not needed, but...
+	{//ran out of failed nodes, get rid of first one, shift rest up
+		for ( j = 0; j < MAX_FAILED_NODES-1; j++ )
+		{
+			ent->failedWaypoints[j] = ent->failedWaypoints[j+1];
+		}
+	}
+	ent->failedWaypoints[MAX_FAILED_NODES-1] = nodeID+1;
+	if ( !ent->failedWaypointCheckTime )
+	{
+		ent->failedWaypointCheckTime = svs.time + CHECK_FAILED_EDGE_INTITIAL;
+	}
+}
+
+qboolean CNavigator::NodeFailed( sharedEntity_t *ent, int nodeID )
+{
+	for ( int j = 0; j < MAX_FAILED_NODES; j++ )
+	{
+		if ( (ent->failedWaypoints[j]-1) == nodeID )
+		{
+			return qtrue;
+		}
+	}
+	return qfalse;
+}
+
+qboolean CNavigator::NodesAreNeighbors( int startID, int endID )
+{//See if these 2 are neighbors
+	if ( startID == endID )
+	{
+		return qfalse;
+	}
+
+	CNode *start = m_nodes[startID];
+	int	nextID = -1;
+	//NOTE: we only check start because we assume all connections are 2-way
+	for ( int i = 0; i < start->GetNumEdges(); i++ )
+	{
+		nextID = start->GetEdge(i);
+		if ( nextID == endID )
+		{
+			return qtrue;
+		}
+	}
+	//not neighbors
+	return qfalse;
+}
+
+void CNavigator::ClearFailedEdge( failedEdge_t *failedEdge )
+{
+	if ( !failedEdge )
+	{
+		return;
+	}
+
+	//clear the edge failed flags
+	/*
+	CNode *node = m_nodes[failedEdge->startID];
+	int edgeNum = node->GetEdgeNumToNode( failedEdge->endID );
+	int	flags;
+	if ( edgeNum != -1 )
+	{
+		flags = node->GetEdgeFlags( edgeNum )&~EFLAG_FAILED;
+		node->SetEdgeFlags( edgeNum, flags );
+	}
+	node = m_nodes[failedEdge->endID];
+	edgeNum = node->GetEdgeNumToNode( failedEdge->startID );
+	if ( edgeNum != -1 )
+	{
+		flags = node->GetEdgeFlags( edgeNum )&~EFLAG_FAILED;
+		node->SetEdgeFlags( edgeNum, flags );
+	}
+	*/
+	//clear failedEdge info
+	SetEdgeCost( failedEdge->startID, failedEdge->endID, -1 );
+	failedEdge->startID = failedEdge->endID = WAYPOINT_NONE;
+	failedEdge->entID = ENTITYNUM_NONE;
+	failedEdge->checkTime = 0;
+}
+
+void CNavigator::ClearAllFailedEdges( void )
+{
+	memset( &failedEdges, WAYPOINT_NONE, sizeof( failedEdges ) );
+	for ( int j = 0; j < MAX_FAILED_EDGES; j++ )
+	{
+		ClearFailedEdge( &failedEdges[j] );
+	}
+}
+
+int CNavigator::EdgeFailed( int startID, int endID )
+{	
+	//OPTIMIZED WAY  (bjg 01/02)
+	//find in lookup map
+	pair <EdgeMultimapIt, EdgeMultimapIt> findValue;
+	findValue = m_edgeLookupMap.equal_range(startID);	
+	while ( findValue.first != findValue.second ) 
+	{
+		if( failedEdges[findValue.first->second].endID == endID)
+		{	
+			return findValue.first->second;		
+		}
+		++findValue.first;
+	}
+	findValue = m_edgeLookupMap.equal_range(endID);	
+	while ( findValue.first != findValue.second ) 
+	{
+		if( failedEdges[findValue.first->second].endID == startID)
+		{	
+			return findValue.first->second;		
+		}
+		++findValue.first;
+	}
+
+	return -1;
+
+	//Old way (linear search)
+	/*
+	for ( int j = 0; j < MAX_FAILED_EDGES; j++ )
+	{
+		if ( failedEdges[j].startID == startID )
+		{
+			if ( failedEdges[j].endID == endID )
+			{
+				return j;
+			}
+		}
+		else if ( failedEdges[j].startID == endID )
+		{
+			if ( failedEdges[j].endID == startID )
+			{
+				return j;
+			}
+		}
+	}
+	return -1;
+	*/
+}
+
+void CNavigator::AddFailedEdge( int entID, int startID, int endID )
+{
+	int	j;//, nextID;
+
+	//Must have nodes
+	if ( m_nodes.size() == 0 )
+		return;
+
+	if ( d_patched->integer )
+	{//use patch-style navigation
+		if ( startID == endID )
+		{//not an edge!
+			return;
+		}
+	}
+
+	//Validate the ent number
+	if ( ( entID < 0 ) || ( entID > ENTITYNUM_NONE ) )
+	{
+#ifndef FINAL_BUILD
+		Com_Printf( S_COLOR_RED"NAV ERROR: envalid ent %d\n", entID );
+		assert(0&&"invalid entID");
+#endif
+		return;
+	}
+
+	//Validate the start position
+	if ( ( startID < 0 ) || ( startID >= m_nodes.size() ) )
+	{
+#ifndef FINAL_BUILD
+		Com_Printf( S_COLOR_RED"NAV ERROR: tried to fail invalid waypoint %d\n", startID );
+		assert(0&&"invalid failed edge");
+#endif
+		return;
+	}
+
+	//Validate the end position
+	if ( ( endID < 0 ) || ( endID >= m_nodes.size() ) )
+	{
+#ifndef FINAL_BUILD
+		Com_Printf( S_COLOR_RED"NAV ERROR: tried to fail invalid waypoint %d\n", endID );
+		assert(0&&"invalid failed edge");
+#endif
+		return;
+	}
+
+	//First see if we already have this one
+	if ( (j = EdgeFailed( startID, endID )) != -1 )
+	{
+		//just remember this guy instead
+		failedEdges[j].entID = entID;
+		return;
+	}
+
+	//Okay, new one, find an empty slot
+	for ( j = 0; j < MAX_FAILED_EDGES; j++ )
+	{
+		if ( failedEdges[j].startID == WAYPOINT_NONE )
+		{
+			failedEdges[j].startID = startID;
+			failedEdges[j].endID = endID;
+			//Check one second from now to see if it's clear
+			failedEdges[j].checkTime = svs.time + CHECK_FAILED_EDGE_INTERVAL + Q_irand( 0, 1000 );
+
+			m_edgeLookupMap.insert(pair<int, int>(startID, j));
+
+			/*
+			//DISABLED this for now, makes people stand around too long when
+			//			collision avoidance just wasn't at it's best but path is clear
+			CNode *start = m_nodes[startID];
+			CNode *end = m_nodes[endID];
+
+			for ( int i = 0; i < start->GetNumEdges(); i++ )
+			{
+				nextID = start->GetEdge(i);
+
+				if ( EdgeFailed( startID, nextID ) != -1 )
+				{
+					//This edge blocked, check next
+					continue;
+				}
+
+				if ( nextID == endID || end->GetRank( nextID ) >= 0 )
+				{//neighbor of or route to end
+					//There's an alternate route, so don't check this one for 10 seconds
+					failedEdges[j].checkTime = svs.time + CHECK_FAILED_EDGE_INTITIAL;
+					break;
+				}
+			}
+			*/
+			
+			//Remember who needed it
+			failedEdges[j].entID = entID;
+
+			//set the edge failed flags
+			/*
+			CNode *node = m_nodes[startID];
+			int edgeNum = node->GetEdgeNumToNode( endID );
+			int	flags;
+			if ( edgeNum != -1 )
+			{
+				flags = node->GetEdgeFlags( edgeNum )|EFLAG_FAILED;
+				node->SetEdgeFlags( edgeNum, flags );
+			}
+			node = m_nodes[endID];
+			edgeNum = node->GetEdgeNumToNode( startID );
+			if ( edgeNum != -1 )
+			{
+				flags = node->GetEdgeFlags( edgeNum )|EFLAG_FAILED;
+				node->SetEdgeFlags( edgeNum, flags );
+			}
+			*/
+
+			//stuff the index to this one in our lookup map
+
+			//now recalc all the paths!
+			if ( pathsCalculated )
+			{
+				//reconnect the nodes and mark every node's flag NF_RECALC
+				//Com_Printf( S_COLOR_CYAN"%d marking all nodes for recalc\n", svs.time );
+				SetEdgeCost( startID, endID, Q3_INFINITE );
+				FlagAllNodes( NF_RECALC );
+			}
+			return;
+		}
+	}
+
+#ifndef FINAL_BUILD
+	Com_Printf( S_COLOR_RED"NAV ERROR: too many blocked waypoint connections (%d)!!!\n", j );
+#endif
+}
+
+qboolean CNavigator::CheckFailedEdge( failedEdge_t *failedEdge )
+{
+	if ( !failedEdge )
+	{
+		return qfalse;
+	}
+
+	//Every 1 second, see if our failed edges are clear
+	if ( failedEdge->checkTime < svs.time )
+	{
+		if ( failedEdge->startID != WAYPOINT_NONE )
+		{
+			vec3_t		start, end, mins, maxs;
+			int			ignore, clipmask;
+			sharedEntity_t	*ent = SV_GentityNum(failedEdge->entID); //(failedEdge->entID<ENTITYNUM_WORLD)?&g_entities[failedEdge->entID]:NULL;
+			int			hitEntNum;
+
+			if ( !ent || /*!ent->inuse || !ent->client || ent->health <= 0*/ (ent->s.eType != ET_PLAYER && ent->s.eType != ET_NPC) ||
+				(ent->s.eFlags & EF_DEAD))
+			{
+				VectorSet( mins, -15, -15, DEFAULT_MINS_2+STEPSIZE );
+				VectorSet( maxs, 15, 15, DEFAULT_MAXS_2 );
+				ignore = ENTITYNUM_NONE;
+				clipmask = MASK_NPCSOLID;
+			}
+			else
+			{
+				VectorCopy( ent->r.mins, mins );
+				mins[2] += STEPSIZE;
+				VectorCopy( ent->r.maxs, maxs );
+				ignore = failedEdge->entID;
+				clipmask = MASK_SOLID;//ent->clipmask; //rwwFIXMEFIXME: share clipmask?
+			}
+
+			if ( maxs[2] < mins[2] )
+			{//don't invert bounding box
+				maxs[2] = mins[2];
+			}
+
+			m_nodes[failedEdge->startID]->GetPosition( start );
+			m_nodes[failedEdge->endID]->GetPosition( end );
+
+			//See if it's NAV_ClearPath...
+#if 0
+			hitEntNum = NAVNEW_ClearPathBetweenPoints( start, end, mins, maxs, ignore, clipmask|CONTENTS_MONSTERCLIP|CONTENTS_BOTCLIP );//NOTE: should we really always include monsterclip (physically blocks NPCs) and botclip (do not enter)?
+#else
+			trace_t	trace;
+
+			//Test if they're even conceivably close to one another
+			if ( !SV_inPVS( start, end ) )
+			{
+				return qfalse;
+			}
+
+			SV_Trace( &trace, start, mins, maxs, end, ignore, clipmask|CONTENTS_MONSTERCLIP|CONTENTS_BOTCLIP, qfalse, 0, 10 );//NOTE: should we really always include monsterclip (physically blocks NPCs) and botclip (do not enter)?
+
+			if( trace.startsolid == qtrue || trace.allsolid == qtrue )
+			{
+				return qfalse;
+			}
+			hitEntNum = trace.entityNum;
+#endif
+			//if we did hit something, see if it's just an auto-door and allow it
+			if ( hitEntNum != ENTITYNUM_NONE && GNavCallback_G_EntIsUnlockedDoor( hitEntNum ) )
+			{
+				hitEntNum = ENTITYNUM_NONE;
+			}
+			else if ( hitEntNum == failedEdge->entID )
+			{//don't hit the person who initially marked the edge failed
+				hitEntNum = ENTITYNUM_NONE;
+			}
+			if ( hitEntNum == ENTITYNUM_NONE )
+			{
+				//If so, clear it
+				ClearFailedEdge( failedEdge );
+				return qtrue;
+			}
+			else
+			{
+				//Check again in one second
+				failedEdge->checkTime = svs.time + CHECK_FAILED_EDGE_INTERVAL + Q_irand( 0, 1000 );
+			}
+		}
+	}
+	return qfalse;
+}
+
+void CNavigator::CheckAllFailedEdges( void )
+{
+	failedEdge_t	*failedEdge;
+	qboolean		clearedAny = qfalse;
+
+	//Must have nodes
+	if ( m_nodes.size() == 0 )
+		return;
+
+	for ( int j = 0; j < MAX_FAILED_EDGES; j++ )
+	{
+		failedEdge = &failedEdges[j];
+
+		clearedAny = CheckFailedEdge( failedEdge )?qtrue:clearedAny;
+	}
+	if ( clearedAny )
+	{//need to recalc the paths
+		if ( pathsCalculated )
+		{
+			//reconnect the nodes and mark every node's flag NF_RECALC
+			//Com_Printf( S_COLOR_CYAN"%d marking all nodes for recalc\n", svs.time );
+			FlagAllNodes( NF_RECALC );
+		}
+	}
+}
+
+qboolean CNavigator::RouteBlocked( int startID, int testEdgeID, int endID, int rejectRank )
+{
+	int		nextID, edgeID, lastID, bestNextID = NODE_NONE;
+	int		bestRank = rejectRank;
+	int		testRank;
+	qboolean	allEdgesFailed;
+	CNode	*end;
+	CNode	*next;
+
+
+	if ( EdgeFailed( startID, testEdgeID ) != -1 )
+	{
+		return qtrue;
+	}
+
+	if ( testEdgeID == endID )
+	{//Neighbors, checked out, all clear
+		return qfalse;
+	}
+	
+	//Okay, first edge is clear, now check rest of route!
+	end	= m_nodes[ endID ];
+	nextID = testEdgeID;
+	lastID = startID;
+
+	while( 1 )
+	{
+		next = m_nodes[ nextID ];
+		allEdgesFailed = qtrue;
+
+		for ( int i = 0; i < next->GetNumEdges(); i++ )
+		{
+			edgeID = next->GetEdge(i);
+
+			if ( edgeID == lastID )
+			{//Don't backtrack
+				continue;
+			}
+
+			if ( edgeID == startID )
+			{//Don't loop around
+				continue;
+			}
+
+			if ( EdgeFailed( nextID, edgeID ) != -1 )
+			{
+				//This edge blocked, check next
+				continue;
+			}
+
+			if ( edgeID == endID )
+			{//We got there all clear!
+				return qfalse;
+			}
+
+			//Still going...
+			testRank = end->GetRank( edgeID );
+
+			if ( testRank < 0 )
+			{//No route this way
+				continue;
+			}
+
+			//Is the rank good enough?
+			if ( testRank < bestRank )
+			{
+				bestNextID = edgeID;
+				bestRank = testRank;
+				allEdgesFailed = qfalse;
+			}
+		}
+		
+		if ( allEdgesFailed )
+		{
+			//This route has no clear way of getting to end
+			return qtrue;
+		}
+		else
+		{
+			lastID = nextID;
+			nextID = bestNextID;
+		}
+	}
+}
+
+/*
+-------------------------
+GetBestNodeAltRoute
+-------------------------
+*/
+
+int CNavigator::GetBestNodeAltRoute( int startID, int endID, int *pathCost, int rejectID )
+{
+	//Must have nodes
+	if ( m_nodes.size() == 0 )
+		return WAYPOINT_NONE;
+
+	//Validate the start position
+	if ( ( startID < 0 ) || ( startID >= m_nodes.size() ) )
+		return WAYPOINT_NONE;
+
+	//Validate the end position
+	if ( ( endID < 0 ) || ( endID >= m_nodes.size() ) )
+		return WAYPOINT_NONE;
+
+	//Is it the same node?
+	if ( startID == endID )
+	{
+		if ( !d_altRoutes->integer || EdgeFailed( startID, endID ) == -1 )
+		{
+			return startID;
+		}
+		else
+		{
+			return WAYPOINT_NONE;
+		}
+	}
+
+	CNode	*start	= m_nodes[ startID ];
+
+	int		bestNode = -1;
+	int		bestRank = Q3_INFINITE;
+	int		testRank, rejectRank = Q3_INFINITE;
+	int		bestCost = Q3_INFINITE;
+
+	*pathCost = 0;
+
+	//Find the minimum rank of the edge(s) we want to reject as paths
+	if ( rejectID != WAYPOINT_NONE )
+	{
+		for ( int i = 0; i < start->GetNumEdges(); i++ )
+		{
+			if ( start->GetEdge(i) == rejectID )
+			{
+				rejectRank = GetPathCost( startID, endID );//end->GetRank( start->GetEdge(i) );
+				break;
+			}
+		}
+	}
+
+	for ( int i = 0; i < start->GetNumEdges(); i++ )
+	{
+		int	edgeID = start->GetEdge(i);
+
+		testRank = GetPathCost( edgeID, endID );//end->GetRank( edgeID );
+
+		//Make sure it's not worse than our reject rank
+		if ( testRank >= rejectRank )
+			continue;
+
+		//Found one
+		if ( edgeID == endID )
+		{
+			if ( !d_altRoutes->integer || !RouteBlocked( startID, edgeID, endID, rejectRank ) )
+			{
+				*pathCost += start->GetEdgeCost( i );
+				return edgeID;
+			}
+			else
+			{//this is blocked, can't consider it
+				continue;
+			}
+		}
+
+		//No possible connection
+		if ( testRank == NODE_NONE )
+		{
+			*pathCost = Q3_INFINITE;
+			return NODE_NONE;
+		}
+
+		//Found a better one
+		if ( testRank < bestRank )
+		{
+			//FIXME: make sure all the edges down from startID through edgeID to endID
+			//		does NOT include a failedEdge...
+			if ( !d_altRoutes->integer || !RouteBlocked( startID, edgeID, endID, rejectRank ) )
+			{
+				bestNode = edgeID;
+				bestRank = testRank;
+				bestCost = start->GetEdgeCost(i)+testRank;
+			}
+		}
+	}
+
+	*pathCost = bestCost;
+
+	return bestNode;
+}
+/*
+-------------------------
+GetBestNodeAltRoute
+overloaded so you don't have to pass a pathCost int pointer in
+-------------------------
+*/
+
+int CNavigator::GetBestNodeAltRoute( int startID, int endID, int rejectID )
+{
+	int	junk;
+	return GetBestNodeAltRoute( startID, endID, &junk, rejectID );
+}
+/*
+-------------------------
+GetBestNode
+-------------------------
+*/
+
+int CNavigator::GetBestNode( int startID, int endID, int rejectID )
+{
+	//Validate the start position
+	if ( ( startID < 0 ) || ( startID >= m_nodes.size() ) )
+		return WAYPOINT_NONE;
+
+	//Validate the end position
+	if ( ( endID < 0 ) || ( endID >= m_nodes.size() ) )
+		return WAYPOINT_NONE;
+
+	if ( startID == endID )
+		return startID;
+
+	CNode	*start	= m_nodes[ startID ];
+	CNode	*end	= m_nodes[ endID ];
+
+	int		bestNode = -1;
+	int		bestRank = Q3_INFINITE;
+	int		testRank, rejectRank = 0;
+
+	if ( rejectID != WAYPOINT_NONE )
+	{
+		for ( int i = 0; i < start->GetNumEdges(); i++ )
+		{
+			if ( start->GetEdge(i) == rejectID )
+			{
+				rejectRank = end->GetRank( start->GetEdge(i) );
+				break;
+			}
+		}
+	}
+
+	for ( int i = 0; i < start->GetNumEdges(); i++ )
+	{
+		int	edgeID = start->GetEdge(i);
+
+		//Found one
+		if ( edgeID == endID )
+			return edgeID;
+
+		testRank = end->GetRank( edgeID );
+
+		//Found one
+		if ( testRank <= rejectRank )
+			continue;
+
+		//No possible connection
+		if ( testRank == NODE_NONE )
+			return NODE_NONE;
+
+		//Found a better one
+		if ( testRank < bestRank )
+		{
+			bestNode = edgeID;
+			bestRank = testRank;
+		}
+	}
+
+	return bestNode;
+}
+
+/*
+-------------------------
+GetNodePosition
+-------------------------
+*/
+
+int CNavigator::GetNodePosition( int nodeID, vec3_t out )
+{
+	//Validate the number
+	if ( ( nodeID < 0 ) || ( nodeID >= m_nodes.size() ) )
+		return false;
+
+	CNode	*node = m_nodes[ nodeID ];
+
+	node->GetPosition( out );
+
+	return true;
+}
+
+/*
+-------------------------
+GetNodeNumEdges
+-------------------------
+*/
+
+int CNavigator::GetNodeNumEdges( int nodeID )
+{
+	if ( ( nodeID < 0 ) || ( nodeID >=  m_nodes.size() ) )
+		return -1;
+
+	CNode	*node = m_nodes[ nodeID ];
+
+	assert( node );
+
+	return node->GetNumEdges();
+}
+
+/*
+-------------------------
+GetNodeEdge
+-------------------------
+*/
+
+int CNavigator::GetNodeEdge( int nodeID, int edge )
+{
+	if ( ( nodeID < 0 ) || ( nodeID >=  m_nodes.size() ) )
+		return -1;
+
+	CNode	*node = m_nodes[ nodeID ];
+
+	assert( node );
+
+	return node->GetEdge( edge );
+}
+
+/*
+-------------------------
+Connected
+-------------------------
+*/
+
+bool CNavigator::Connected( int startID, int endID )
+{
+	//Validate the start position
+	if ( ( startID < 0 ) || ( startID >= m_nodes.size() ) )
+		return false;
+
+	//Validate the end position
+	if ( ( endID < 0 ) || ( endID >= m_nodes.size() ) )
+		return false;
+
+	if ( startID == endID )
+		return true;
+
+	CNode	*start	= m_nodes[ startID ];
+	CNode	*end	= m_nodes[ endID ];
+
+	for ( int i = 0; i < start->GetNumEdges(); i++ )
+	{
+		int	edgeID = start->GetEdge(i);
+
+		//Found one
+		if ( edgeID == endID )
+			return true;
+
+		if ( ( end->GetRank( edgeID ) ) != NODE_NONE )
+			return true;
+	}
+
+	return false;
+}
+
+/*
+-------------------------
+GetPathCost
+-------------------------
+*/
+
+unsigned int CNavigator::GetPathCost( int startID, int endID )
+{
+	//Validate the start position
+	if ( ( startID < 0 ) || ( startID >= m_nodes.size() ) )
+		return Q3_INFINITE; // return 0;
+
+	//Validate the end position
+	if ( ( endID < 0 ) || ( endID >= m_nodes.size() ) )
+		return Q3_INFINITE; // return 0;
+
+	CNode	*startNode	= m_nodes[ startID ];
+
+	if ( !startNode->GetNumEdges() )
+	{//WTF?  Solitary waypoint!  Bad designer!
+		return Q3_INFINITE; // return 0;
+	}
+
+	CNode	*endNode	= m_nodes[ endID ];
+	
+	CNode	*moveNode = startNode;
+
+	int		bestNode;
+	int		pathCost = 0;
+	int		bestCost;
+
+	int		bestRank;
+	int		testRank;
+
+	int		dontScrewUp = 0;
+
+	//Draw out our path
+	while ( moveNode != endNode )
+	{
+		bestRank = WORLD_SIZE;
+		bestNode = -1;
+		bestCost = 0;
+
+		for ( int i = 0; i < moveNode->GetNumEdges(); i++ )
+		{
+			int	edgeID = moveNode->GetEdge(i);
+
+			//Done
+			if ( edgeID == endID )
+			{
+				return pathCost + moveNode->GetEdgeCost( i );
+			}	
+
+			testRank = endNode->GetRank( edgeID );
+
+			//No possible connection
+			if ( testRank == NODE_NONE )
+			{
+				return Q3_INFINITE; // return 0;
+			}
+
+			//Found a better one
+			if ( testRank < bestRank )
+			{
+				bestNode = edgeID;
+				bestRank = testRank;
+				bestCost = moveNode->GetEdgeCost( i );
+			}
+		}
+
+		pathCost += bestCost;
+
+		//Take a new best node
+		moveNode = m_nodes[ bestNode ];
+		dontScrewUp++;
+
+		if (dontScrewUp > 40000)
+		{ //ok, I think something probably screwed up.
+			break;
+		}
+	}
+
+	return pathCost;
+}
+
+/*
+-------------------------
+GetEdgeCost
+-------------------------
+*/
+
+unsigned int CNavigator::GetEdgeCost( int startID, int endID )
+{
+	//Validate the start position
+	if ( ( startID < 0 ) || ( startID >= m_nodes.size() ) )
+		return Q3_INFINITE; // return 0;
+
+	//Validate the end position
+	if ( ( endID < 0 ) || ( endID >= m_nodes.size() ) )
+		return Q3_INFINITE; // return 0;
+
+	CNode	*start	= m_nodes[startID];
+	CNode	*end	= m_nodes[endID];
+
+	return GetEdgeCost( start, end );
+}
+
+/*
+-------------------------
+GetProjectedNode
+-------------------------
+*/
+
+int CNavigator::GetProjectedNode( vec3_t origin, int nodeID )
+{
+	//Validate the start position
+	if ( ( nodeID < 0 ) || ( nodeID >= m_nodes.size() ) )
+		return NODE_NONE;
+
+	CNode	*node = m_nodes[nodeID];
+	CNode	*tempNode;
+
+	float	bestDot		= 0.0f;
+	int		bestNode	= NODE_NONE;
+
+	vec3_t	targetDir, basePos, tempDir, tempPos;
+	float	dot;
+
+	//Setup our target direction
+	node->GetPosition( basePos );
+
+	VectorSubtract( origin, basePos, targetDir );
+	VectorNormalize( targetDir );
+
+	//Go through all the edges
+	for ( int i = 0; i < node->GetNumEdges(); i++ )
+	{
+		tempNode = m_nodes[node->GetEdge(i)];
+		tempNode->GetPosition( tempPos );
+
+		VectorSubtract( tempPos, basePos, tempDir );
+		VectorNormalize( tempDir );	//FIXME: Retain the length here if you want it
+
+		dot = DotProduct( targetDir, tempDir );
+
+		if ( dot < 0.0f )
+			continue;
+
+		if ( dot > bestDot )
+		{
+			bestDot		= dot;
+			bestNode	= tempNode->GetID();
+		}
+	}
+
+	return bestNode;
+}
+
+// This is the PriorityQueue stuff for lists of connections
+// better than linear		(1/21/02 BJG)
+//////////////////////////////////////////////////////////////////
+// Helper pop_mHeap algorithm class
+//////////////////////////////////////////////////////////////////
+class NodeTotalGreater 
+{
+public:
+   bool operator()( CEdge * first, CEdge * second ) const {
+      return( first->m_cost > second->m_cost );
+   }
+};
+
+
+//////////////////////////////////////////////////////////////////
+// Destructor - Deallocate any remaining pointers in the queue
+//////////////////////////////////////////////////////////////////
+CPriorityQueue::~CPriorityQueue()
+{
+	while (!Empty())
+	{
+		delete Pop();
+	}
+}
+
+//////////////////////////////////////////////////////////////////
+// Standard Iterative Search
+//////////////////////////////////////////////////////////////////
+CEdge* CPriorityQueue::Find(int npNum)
+{
+	for(vector<CEdge*>::iterator HeapIter=mHeap.begin(); HeapIter!=mHeap.end(); HeapIter++)
+	{
+		if ((*HeapIter)->m_first == npNum)
+		{
+			return *HeapIter;
+		}
+	}
+	return 0;
+}
+
+//////////////////////////////////////////////////////////////////
+// Remove Node And Resort
+//////////////////////////////////////////////////////////////////
+CEdge* CPriorityQueue::Pop()
+{  
+   CEdge *edge = mHeap.front();
+
+   //pop_mHeap will move the node at the front to the position N
+   //and then sort the mHeap to make positions 1 through N-1 correct
+   //(STL makes no assumptions about your data and doesn't want to change
+   //the size of the container.)
+   std::pop_heap(mHeap.begin(), mHeap.end(), NodeTotalGreater() );
+
+   //pop_back() will actually remove the last element from the mHeap
+   //now the mHeap is sorted for positions 1 through N
+   mHeap.pop_back();
+
+   return( edge );
+}
+
+//////////////////////////////////////////////////////////////////
+// Add New Node And Resort
+//////////////////////////////////////////////////////////////////
+void CPriorityQueue::Push(CEdge* theEdge )
+{    
+   //Pushes the node onto the back of the mHeap
+   mHeap.push_back( theEdge );
+
+   //Sorts the new element into the mHeap
+   std::push_heap( mHeap.begin(), mHeap.end(), NodeTotalGreater() );
+}
+
+//////////////////////////////////////////////////////////////////
+// Find The Node In Question And Resort mHeap Around It
+//////////////////////////////////////////////////////////////////
+void CPriorityQueue::Update( CEdge* edge )
+{  
+   for(vector<CEdge*>::iterator i=mHeap.begin(); i!=mHeap.end(); i++)
+   {
+      if( (*i)->m_first == edge->m_first )
+      {  //Found node - resort from this position in the mHeap
+         //(its total value was changed before this function was called)
+         std::push_heap( mHeap.begin(), i+1, NodeTotalGreater() );
+         return;
+      }
+   }
+}
+
+//////////////////////////////////////////////////////////////////
+// Just a wrapper for stl empty function.
+//////////////////////////////////////////////////////////////////
+bool CPriorityQueue::Empty()
+{
+   return( mHeap.empty() );
+};
+
diff --git a/codemp/server/NPCNav/navigator.h b/codemp/server/NPCNav/navigator.h
new file mode 100644
index 0000000..e75f075
--- /dev/null
+++ b/codemp/server/NPCNav/navigator.h
@@ -0,0 +1,280 @@
+#ifndef __G_NAVIGATOR__
+#define __G_NAVIGATOR__
+
+#define	__NEWCOLLECT	1
+
+#define _HARD_CONNECT	1
+
+//Node flags
+#define	NF_ANY			0
+//#define	NF_CLEAR_LOS	0x00000001
+#define NF_CLEAR_PATH	0x00000002
+#define NF_RECALC		0x00000004
+
+//Edge flags
+#define	EFLAG_NONE		0
+#define EFLAG_BLOCKED	0x00000001
+#define EFLAG_FAILED	0x00000002
+
+//Miscellaneous defines
+#define	NODE_NONE		-1
+#define	NAV_HEADER_ID	'JNV5'
+#define	NODE_HEADER_ID	'NODE'
+
+#pragma warning( disable : 4786) 
+
+#if defined(_WIN32) && !defined(_XBOX)
+#define COM_NO_WINDOWS_H
+#include <objbase.h>
+#endif
+
+#include <map>
+#include <vector>
+#include <list>
+using namespace std;
+
+#include "../server.h"
+#include "../../game/q_shared.h"
+
+
+typedef multimap<int, int> EdgeMultimap;
+typedef multimap<int, int>::iterator EdgeMultimapIt;
+
+
+/*
+-------------------------
+CEdge
+-------------------------
+*/
+
+class CEdge
+{
+
+public:
+
+	CEdge( void );
+	CEdge( int first, int second, int cost );
+	~CEdge( void );
+
+	int		m_first;
+	int		m_second;
+	int		m_cost;
+};
+
+/*
+-------------------------
+CNode
+-------------------------
+*/
+
+class CNode
+{
+	typedef	struct edge_s
+	{
+		int		ID;
+		int		cost;
+		BYTE	flags;
+	} edge_t;
+
+	typedef	vector< edge_t >	edge_v;
+
+public:
+
+	CNode( void );
+	~CNode( void );
+
+	static CNode *Create( vec3_t position, int flags, int radius, int ID );
+	static CNode *Create( void );
+
+	void AddEdge( int ID, int cost, int flags = EFLAG_NONE );
+	void AddRank( int ID, int rank );
+
+	void Draw( qboolean radius );
+
+	int	GetID( void )					const	{	return m_ID;	}
+	void GetPosition( vec3_t position )	const	{	if ( position )	VectorCopy( m_position, position );	}
+ 	
+	int GetNumEdges( void )				const	{	return m_numEdges;	}
+	int	GetEdgeNumToNode( int ID );
+	int GetEdge( int edgeNum );
+	int GetEdgeCost( int edgeNum );
+	BYTE GetEdgeFlags( int edgeNum );
+	void SetEdgeFlags( int edgeNum, int newFlags );
+	int	GetRadius( void )				const	{	return m_radius;	}
+
+	void InitRanks( int size );
+	int GetRank( int ID );
+
+	int	GetFlags( void )				const	{	return m_flags;	}
+	void AddFlag( int newFlag )			{	m_flags |= newFlag;	}
+	void RemoveFlag( int oldFlag )		{	m_flags &= ~oldFlag; }
+
+	int	Save( int numNodes, fileHandle_t file );
+	int Load( int numNodes, fileHandle_t file );
+
+protected:
+
+	vec3_t			m_position;
+	int				m_flags;
+	int				m_radius;
+	int				m_ID;
+	
+	edge_v	m_edges;
+
+	int		*m_ranks;
+	int		m_numEdges;
+};
+
+/*
+-------------------------
+CNavigator
+-------------------------
+*/
+#define MAX_FAILED_EDGES	32
+class CNavigator
+{
+	typedef	vector < CNode * >			node_v;
+	typedef	list < CEdge >				edge_l;
+
+#if __NEWCOLLECT
+	
+	typedef struct nodeList_t
+	{
+		int				nodeID;
+		unsigned int	distance;
+	};
+
+	typedef list < nodeList_t >		nodeChain_l;
+
+#endif	//__NEWCOLLECT
+
+public:
+
+	CNavigator( void );
+	~CNavigator( void );
+
+	void Init( void );
+	void Free( void );
+
+	bool Load( const char *filename, int checksum );
+	bool Save( const char *filename, int checksum );
+
+	int  AddRawPoint( vec3_t point, int flags, int radius );
+	void CalculatePaths( qboolean recalc=qfalse );
+
+#if _HARD_CONNECT
+
+	void HardConnect( int first, int second );
+
+#endif
+
+	void ShowNodes( void );
+	void ShowEdges( void );
+	void ShowPath( int start, int end );
+
+	int GetNearestNode( sharedEntity_t *ent, int lastID, int flags, int targetID );
+
+	int GetBestNode( int startID, int endID, int rejectID = NODE_NONE );
+
+	int GetNodePosition( int nodeID, vec3_t out );
+	int GetNodeNumEdges( int nodeID );
+	int GetNodeEdge( int nodeID, int edge );
+	float GetNodeLeadDistance( int nodeID );
+
+	int GetNumNodes( void )		const	{	return m_nodes.size();		}
+	
+	bool Connected( int startID, int endID );
+
+	unsigned int GetPathCost( int startID, int endID );
+	unsigned int GetEdgeCost( int startID, int endID );
+
+	int GetProjectedNode( vec3_t origin, int nodeID );
+//MCG Added BEGIN
+	void CheckFailedNodes( sharedEntity_t *ent );
+	void AddFailedNode( sharedEntity_t *ent, int nodeID );
+	qboolean NodeFailed( sharedEntity_t *ent, int nodeID );
+	qboolean NodesAreNeighbors( int startID, int endID );
+	void ClearFailedEdge( failedEdge_t	*failedEdge );
+	void ClearAllFailedEdges( void );
+	int EdgeFailed( int startID, int endID );
+	void AddFailedEdge( int entID, int startID, int endID );
+	qboolean CheckFailedEdge( failedEdge_t *failedEdge );
+	void CheckAllFailedEdges( void );
+	qboolean RouteBlocked( int startID, int testEdgeID, int endID, int rejectRank );
+	int GetBestNodeAltRoute( int startID, int endID, int *pathCost, int rejectID = NODE_NONE );
+	int GetBestNodeAltRoute( int startID, int endID, int rejectID = NODE_NONE );
+	int GetBestPathBetweenEnts( sharedEntity_t *ent, sharedEntity_t *goal, int flags );
+	int	GetNodeRadius( int nodeID );
+	void CheckBlockedEdges( void );
+	void ClearCheckedNodes( void );
+	byte CheckedNode(int wayPoint,int ent);
+	void SetCheckedNode(int wayPoint,int ent,byte value);
+
+	void FlagAllNodes( int newFlag );
+
+	qboolean pathsCalculated;
+//MCG Added END
+
+protected:
+
+	int		TestNodePath( sharedEntity_t *ent, int okToHitEntNum, vec3_t position, qboolean includeEnts );
+	int		TestNodeLOS( sharedEntity_t *ent, vec3_t position );
+	int		TestBestFirst( sharedEntity_t *ent, int lastID, int flags );
+	
+#if __NEWCOLLECT
+	int		CollectNearestNodes( vec3_t origin, int radius, int maxCollect, nodeChain_l &nodeChain );
+#else
+	int		CollectNearestNodes( vec3_t origin, int radius, int maxCollect, int *nodeChain );
+#endif	//__NEWCOLLECT
+
+	char	GetChar( fileHandle_t file );
+	int		GetInt( fileHandle_t file );
+	float	GetFloat( fileHandle_t file );
+	long	GetLong( fileHandle_t file );
+
+	//void	ConnectNodes( void );
+	void	SetEdgeCost( int ID1, int ID2, int cost );
+	int		GetEdgeCost( CNode *first, CNode *second );
+	void	AddNodeEdges( CNode *node, int addDist, edge_l &edgeList, bool *checkedNodes );
+
+	void	CalculatePath( CNode *node );
+
+	//rww - made failedEdges private as it doesn't seem to need to be public.
+	//And I'd rather shoot myself than have to devise a way of setting/accessing this
+	//array via trap calls.
+	failedEdge_t	failedEdges[MAX_FAILED_EDGES];	
+
+	node_v			m_nodes;
+	EdgeMultimap	m_edgeLookupMap;
+};
+
+//////////////////////////////////////////////////////////////////////
+// class Priority Queue
+//////////////////////////////////////////////////////////////////////
+class CPriorityQueue
+{
+// CONSTRUCTION /DESTRUCTION
+//--------------------------------------------------------------
+public:
+	CPriorityQueue() {};
+	~CPriorityQueue();
+	
+// Functionality
+//--------------------------------------------------------------
+public:
+	CEdge*	Pop();
+	CEdge*	Find(int npNum);
+	void	Push( CEdge* theEdge );
+	void	Update(CEdge* edge );
+	bool	Empty();
+	
+
+// DATA
+//--------------------------------------------------------------
+private:
+	vector<CEdge*>	mHeap;
+};
+
+extern CNavigator navigator;
+
+#endif	//__G_NAVIGATOR__
\ No newline at end of file
diff --git a/codemp/server/NPCNav/vssver.scc b/codemp/server/NPCNav/vssver.scc
new file mode 100644
index 0000000..1e3f995
Binary files /dev/null and b/codemp/server/NPCNav/vssver.scc differ
diff --git a/codemp/server/exe_headers.h b/codemp/server/exe_headers.h
new file mode 100644
index 0000000..03475b9
--- /dev/null
+++ b/codemp/server/exe_headers.h
@@ -0,0 +1,13 @@
+// stuff added for PCH files.  I want to have a lot of stuff included here so the PCH is pretty rich,
+//	but without exposing too many extra protos, so for now (while I experiment)...
+//
+
+#include "../game/q_shared.h"
+#include "../qcommon/qcommon.h"
+
+#include "../client/client.h"
+#include "../server/server.h"
+#include "../renderer/tr_local.h"
+
+#pragma hdrstop
+
diff --git a/codemp/server/server.h b/codemp/server/server.h
new file mode 100644
index 0000000..86341ef
--- /dev/null
+++ b/codemp/server/server.h
@@ -0,0 +1,437 @@
+#if defined (_MSC_VER) && (_MSC_VER >= 1020)
+#pragma once
+#endif
+
+#if !defined(SERVER_H_INC)
+#define SERVER_H_INC
+
+
+#include "../game/q_shared.h"
+#include "../qcommon/qcommon.h"
+#include "../game/g_public.h"
+#include "../game/bg_public.h"
+
+#ifdef _XBOX
+#include "../xbox/XBLive.h"
+#include "../xbox/XBoxCommon.h"
+#include "../xbox/XBVoice.h"
+#endif
+
+//=============================================================================
+
+#define	PERS_SCORE				0		// !!! MUST NOT CHANGE, SERVER AND
+										// GAME BOTH REFERENCE !!!
+
+#define	MAX_ENT_CLUSTERS	16
+
+typedef struct svEntity_s {
+	struct worldSector_s *worldSector;
+	struct svEntity_s *nextEntityInWorldSector;
+	
+	entityState_t	baseline;		// for delta compression of initial sighting
+#ifdef _XBOX
+	signed char		numClusters;		// if -1, use headnode instead
+	short			clusternums[MAX_ENT_CLUSTERS];
+	short			lastCluster;		// if all the clusters don't fit in clusternums
+	short			areanum, areanum2;
+	char			snapshotCounter;	// used to prevent double adding from portal views
+#else
+	int			numClusters;		// if -1, use headnode instead
+	int			clusternums[MAX_ENT_CLUSTERS];
+	int			lastCluster;		// if all the clusters don't fit in clusternums
+	int			areanum, areanum2;
+	int			snapshotCounter;	// used to prevent double adding from portal views
+#endif
+} svEntity_t;
+
+typedef enum {
+	SS_DEAD,			// no map loaded
+	SS_LOADING,			// spawning level entities
+	SS_GAME				// actively running
+} serverState_t;
+
+typedef struct {
+	serverState_t	state;
+	qboolean		restarting;			// if true, send configstring changes during SS_LOADING
+	int				serverId;			// changes each server start
+	int				restartedServerId;	// serverId before a map_restart
+	int				checksumFeed;		//
+#ifdef _XBOX
+	char			snapshotCounter;	// incremented for each snapshot built
+#else
+	int				snapshotCounter;	// incremented for each snapshot built
+#endif
+	int				timeResidual;		// <= 1000 / sv_frame->value
+	int				nextFrameTime;		// when time > nextFrameTime, process world
+	struct cmodel_s	*models[MAX_MODELS];
+	char			*configstrings[MAX_CONFIGSTRINGS];
+	svEntity_t		svEntities[MAX_GENTITIES];
+
+	char			*entityParsePoint;	// used during game VM init
+
+	// the game virtual machine will update these on init and changes
+	sharedEntity_t	*gentities;
+	int				gentitySize;
+	int				num_entities;		// current number, <= MAX_GENTITIES
+
+	playerState_t	*gameClients;
+	int				gameClientSize;		// will be > sizeof(playerState_t) due to game private data
+
+	int				restartTime;
+
+	//rwwRMG - added:
+	int				mLocalSubBSPIndex;
+	int				mLocalSubBSPModelOffset;
+	char			*mLocalSubBSPEntityParsePoint;
+
+	char			*mSharedMemory;
+} server_t;
+
+
+
+
+
+typedef struct {
+	int				areabytes;
+	byte			areabits[MAX_MAP_AREA_BYTES];		// portalarea visibility bits
+	playerState_t	ps;
+	playerState_t	vps; //vehicle I'm riding's playerstate (if applicable) -rww
+#ifdef _ONEBIT_COMBO
+	int				*pDeltaOneBit;
+	int				*pDeltaOneBitVeh;
+	int				*pDeltaNumBit;
+	int				*pDeltaNumBitVeh;
+#endif
+	int				num_entities;
+	int				first_entity;		// into the circular sv_packet_entities[]
+										// the entities MUST be in increasing state number
+										// order, otherwise the delta compression will fail
+	int				messageSent;		// time the message was transmitted
+	int				messageAcked;		// time the message was acked
+	int				messageSize;		// used to rate drop packets
+} clientSnapshot_t;
+
+typedef enum {
+	CS_FREE,		// can be reused for a new connection
+	CS_ZOMBIE,		// client has been disconnected, but don't reuse
+					// connection for a couple seconds
+	CS_CONNECTED,	// has been assigned to a client_t, but no gamestate yet
+	CS_PRIMED,		// gamestate has been sent, but client hasn't sent a usercmd
+	CS_ACTIVE		// client is fully in game
+} clientState_t;
+
+
+typedef struct client_s {
+	clientState_t	state;
+	char			userinfo[MAX_INFO_STRING];		// name, etc
+
+	qboolean		sentGamedir; //see if he has been sent an svc_setgame
+
+	char			reliableCommands[MAX_RELIABLE_COMMANDS][MAX_STRING_CHARS];
+	int				reliableSequence;		// last added reliable message, not necesarily sent or acknowledged yet
+	int				reliableAcknowledge;	// last acknowledged reliable message
+	int				reliableSent;			// last sent reliable message, not necesarily acknowledged yet
+	int				messageAcknowledge;
+
+	int				gamestateMessageNum;	// netchan->outgoingSequence of gamestate
+	int				challenge;
+
+	usercmd_t		lastUsercmd;
+	int				lastMessageNum;		// for delta compression
+	int				lastClientCommand;	// reliable client message sequence
+	char			lastClientCommandString[MAX_STRING_CHARS];
+	sharedEntity_t	*gentity;			// SV_GentityNum(clientnum)
+	char			name[MAX_NAME_LENGTH];			// extracted from userinfo, high bits masked
+
+	// downloading
+#ifndef _XBOX	// No downloads on Xbox
+	char			downloadName[MAX_QPATH]; // if not empty string, we are downloading
+	fileHandle_t	download;			// file being downloaded
+ 	int				downloadSize;		// total bytes (can't use EOF because of paks)
+ 	int				downloadCount;		// bytes sent
+	int				downloadClientBlock;	// last block we sent to the client, awaiting ack
+	int				downloadCurrentBlock;	// current block number
+	int				downloadXmitBlock;	// last block we xmited
+	unsigned char	*downloadBlocks[MAX_DOWNLOAD_WINDOW];	// the buffers for the download blocks
+	int				downloadBlockSize[MAX_DOWNLOAD_WINDOW];
+	qboolean		downloadEOF;		// We have sent the EOF block
+	int				downloadSendTime;	// time we last got an ack from the client
+#endif
+
+	int				deltaMessage;		// frame last client usercmd message
+	int				nextReliableTime;	// svs.time when another reliable command will be allowed
+	int				lastPacketTime;		// svs.time when packet was last received
+	int				lastConnectTime;	// svs.time when connection started
+	int				nextSnapshotTime;	// send another snapshot when svs.time >= nextSnapshotTime
+	qboolean		rateDelayed;		// true if nextSnapshotTime was set based on rate instead of snapshotMsec
+	int				timeoutCount;		// must timeout a few frames in a row so debugging doesn't break
+	clientSnapshot_t	frames[PACKET_BACKUP];	// updates can be delta'd from here
+	int				ping;
+	int				rate;				// bytes / second
+	int				snapshotMsec;		// requests a snapshot every snapshotMsec unless rate choked
+	int				pureAuthentic;
+	netchan_t		netchan;
+
+	int				lastUserInfoChange; //if > svs.time && count > x, deny change -rww
+	int				lastUserInfoCount; //allow a certain number of changes within a certain time period -rww
+
+#ifdef _XBOX
+	int				refIndex;			// Copy of refIndex in xbOnlineInfo.xbPlayerList[]
+	qboolean		usePrivateSlot;		// Was this person eligble for a private slot when they joined?
+#endif
+} client_t;
+
+//=============================================================================
+
+
+// MAX_CHALLENGES is made large to prevent a denial
+// of service attack that could cycle all of them
+// out before legitimate users connected
+#define	MAX_CHALLENGES	1024
+
+#define	AUTHORIZE_TIMEOUT	5000
+
+typedef struct {
+	netadr_t	adr;
+	int			challenge;
+	int			time;				// time the last packet was sent to the autherize server
+	int			pingTime;			// time the challenge response was sent to client
+	int			firstTime;			// time the adr was first used, for authorize timeout checks
+	qboolean	connected;
+} challenge_t;
+
+
+#define	MAX_MASTERS	8				// max recipients for heartbeat packets
+
+
+// this structure will be cleared only when the game dll changes
+typedef struct {
+	qboolean	initialized;				// sv_init has completed
+
+	int			time;						// will be strictly increasing across level changes
+
+	int			snapFlagServerBit;			// ^= SNAPFLAG_SERVERCOUNT every SV_SpawnServer()
+
+	client_t	*clients;					// [sv_maxclients->integer];
+	int			numSnapshotEntities;		// sv_maxclients->integer*PACKET_BACKUP*MAX_PACKET_ENTITIES
+	int			nextSnapshotEntities;		// next snapshotEntities to use
+	entityState_t	*snapshotEntities;		// [numSnapshotEntities]
+	int			nextHeartbeatTime;
+	challenge_t	challenges[MAX_CHALLENGES];	// to prevent invalid IPs from connecting
+	netadr_t	redirectAddress;			// for rcon return messages
+
+	netadr_t	authorizeAddress;			// for rcon return messages
+
+#ifdef _XBOX
+	int			clientRefNum;				// Index into xbonlineinfo array
+#endif
+} serverStatic_t;
+
+//=============================================================================
+
+extern	serverStatic_t	svs;				// persistant server info across maps
+extern	server_t		sv;					// cleared each map
+extern	vm_t			*gvm;				// game virtual machine
+
+#define	MAX_MASTER_SERVERS	5
+
+extern	cvar_t	*sv_fps;
+extern	cvar_t	*sv_timeout;
+extern	cvar_t	*sv_zombietime;
+extern	cvar_t	*sv_rconPassword;
+extern	cvar_t	*sv_privatePassword;
+extern	cvar_t	*sv_allowDownload;
+extern	cvar_t	*sv_maxclients;
+extern	cvar_t	*sv_privateClients;
+extern	cvar_t	*sv_hostname;
+extern	cvar_t	*sv_master[MAX_MASTER_SERVERS];
+extern	cvar_t	*sv_reconnectlimit;
+extern	cvar_t	*sv_showghoultraces;
+extern	cvar_t	*sv_showloss;
+extern	cvar_t	*sv_padPackets;
+extern	cvar_t	*sv_killserver;
+extern	cvar_t	*sv_mapname;
+extern	cvar_t	*sv_mapChecksum;
+extern	cvar_t	*sv_serverid;
+extern	cvar_t	*sv_maxRate;
+extern	cvar_t	*sv_minPing;
+extern	cvar_t	*sv_maxPing;
+extern	cvar_t	*sv_gametype;
+extern	cvar_t	*sv_pure;
+extern	cvar_t	*sv_floodProtect;
+extern	cvar_t	*sv_allowAnonymous;
+extern	cvar_t	*sv_needpass;
+
+
+//===========================================================
+
+//
+// sv_main.c
+//
+void SV_FinalMessage (char *message);
+void QDECL SV_SendServerCommand( client_t *cl, const char *fmt, ...);
+
+
+void SV_AddOperatorCommands (void);
+void SV_RemoveOperatorCommands (void);
+
+
+void SV_MasterHeartbeat (void);
+void SV_MasterShutdown (void);
+
+
+
+
+//
+// sv_init.c
+//
+void SV_SetConfigstring( int index, const char *val );
+void SV_GetConfigstring( int index, char *buffer, int bufferSize );
+int SV_AddConfigstring (const char *name, int start, int max);
+
+void SV_SetUserinfo( int index, const char *val );
+void SV_GetUserinfo( int index, char *buffer, int bufferSize );
+
+void SV_ChangeMaxClients( void );
+void SV_SpawnServer( char *server, qboolean killBots, ForceReload_e eForceReload );
+
+
+
+//
+// sv_client.c
+//
+void SV_GetChallenge( netadr_t from );
+
+void SV_DirectConnect( netadr_t from );
+
+void SV_AuthorizeIpPacket( netadr_t from );
+
+void SV_SendClientMapChange( client_t *client );
+void SV_ExecuteClientMessage( client_t *cl, msg_t *msg );
+void SV_UserinfoChanged( client_t *cl );
+
+void SV_ClientEnterWorld( client_t *client, usercmd_t *cmd );
+void SV_DropClient( client_t *drop, const char *reason );
+
+void SV_ExecuteClientCommand( client_t *cl, const char *s, qboolean clientOK );
+void SV_ClientThink (client_t *cl, usercmd_t *cmd);
+
+void SV_WriteDownloadToClient( client_t *cl , msg_t *msg );
+
+// Need to broadcast info about clients on join/leave
+#ifdef _XBOX
+struct XBPlayerInfo;
+void SV_SendClientNewPeer(client_t* client, XBPlayerInfo* info);
+void SV_SendClientRemovePeer(client_t* client, int index);
+void SV_SendClientXbInfo(client_t *client);
+#endif
+
+//
+// sv_ccmds.c
+//
+void SV_Heartbeat_f( void );
+
+//
+// sv_snapshot.c
+//
+void SV_AddServerCommand( client_t *client, const char *cmd );
+void SV_UpdateServerCommandsToClient( client_t *client, msg_t *msg );
+void SV_WriteFrameToClient (client_t *client, msg_t *msg);
+void SV_SendMessageToClient( msg_t *msg, client_t *client );
+void SV_SendClientMessages( void );
+void SV_SendClientSnapshot( client_t *client );
+
+//
+// sv_game.c
+//
+int	SV_NumForGentity( sharedEntity_t *ent );
+sharedEntity_t *SV_GentityNum( int num );
+playerState_t *SV_GameClientNum( int num );
+svEntity_t	*SV_SvEntityForGentity( sharedEntity_t *gEnt );
+sharedEntity_t *SV_GEntityForSvEntity( svEntity_t *svEnt );
+void		SV_InitGameProgs ( void );
+void		SV_ShutdownGameProgs ( void );
+void		SV_RestartGameProgs( void );
+qboolean	SV_inPVS (const vec3_t p1, const vec3_t p2);
+
+//
+// sv_bot.c
+//
+void		SV_BotFrame( int time );
+int			SV_BotAllocateClient(void);
+void		SV_BotFreeClient( int clientNum );
+
+void		SV_BotInitCvars(void);
+int			SV_BotLibSetup( void );
+int			SV_BotLibShutdown( void );
+int			SV_BotGetSnapshotEntity( int client, int ent );
+int			SV_BotGetConsoleMessage( int client, char *buf, int size );
+
+void *Bot_GetMemoryGame(int size);
+void Bot_FreeMemoryGame(void *ptr);
+
+int BotImport_DebugPolygonCreate(int color, int numPoints, vec3_t *points);
+void BotImport_DebugPolygonDelete(int id);
+
+//============================================================
+//
+// high level object sorting to reduce interaction tests
+//
+
+void SV_ClearWorld (void);
+// called after the world model has been loaded, before linking any entities
+
+void SV_UnlinkEntity( sharedEntity_t *ent );
+// call before removing an entity, and before trying to move one,
+// so it doesn't clip against itself
+
+void SV_LinkEntity( sharedEntity_t *ent );
+// Needs to be called any time an entity changes origin, mins, maxs,
+// or solid.  Automatically unlinks if needed.
+// sets ent->v.absmin and ent->v.absmax
+// sets ent->leafnums[] for pvs determination even if the entity
+// is not solid
+
+
+clipHandle_t SV_ClipHandleForEntity( const sharedEntity_t *ent );
+
+
+void SV_SectorList_f( void );
+
+
+int SV_AreaEntities( const vec3_t mins, const vec3_t maxs, int *entityList, int maxcount );
+// fills in a table of entity numbers with entities that have bounding boxes
+// that intersect the given area.  It is possible for a non-axial bmodel
+// to be returned that doesn't actually intersect the area on an exact
+// test.
+// returns the number of pointers filled in
+// The world entity is never returned in this list.
+
+
+int SV_PointContents( const vec3_t p, int passEntityNum );
+// returns the CONTENTS_* value from the world and all entities at the given point.
+
+
+void SV_Trace( trace_t *results, const vec3_t start, const vec3_t mins, const vec3_t maxs, const vec3_t end, int passEntityNum, int contentmask, int capsule, int traceFlags, int useLod );
+// mins and maxs are relative
+
+// if the entire move stays in a solid volume, trace.allsolid will be set,
+// trace.startsolid will be set, and trace.fraction will be 0
+
+// if the starting point is in a solid, it will be allowed to move out
+// to an open area
+
+// passEntityNum is explicitly excluded from clipping checks (normally ENTITYNUM_NONE)
+
+
+void SV_ClipToEntity( trace_t *trace, const vec3_t start, const vec3_t mins, const vec3_t maxs, const vec3_t end, int entityNum, int contentmask, int capsule );
+// clip to a specific entity
+
+//
+// sv_net_chan.c
+//
+void SV_Netchan_Transmit( client_t *client, msg_t *msg);	//int length, const byte *data );
+void SV_Netchan_TransmitNextFragment( netchan_t *chan );
+qboolean SV_Netchan_Process( client_t *client, msg_t *msg );
+
+#endif // SERVER_H_INC
diff --git a/codemp/server/sv_bot.cpp b/codemp/server/sv_bot.cpp
new file mode 100644
index 0000000..6de6e72
--- /dev/null
+++ b/codemp/server/sv_bot.cpp
@@ -0,0 +1,797 @@
+// sv_bot.c
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+#include "server.h"
+#include "../game/botlib.h"
+
+typedef struct bot_debugpoly_s
+{
+	int inuse;
+	int color;
+	int numPoints;
+	vec3_t points[128];
+} bot_debugpoly_t;
+
+static bot_debugpoly_t *debugpolygons;
+int bot_maxdebugpolys;
+
+extern botlib_export_t	*botlib_export;
+int	bot_enable;
+
+static int gWPNum = 0;
+static wpobject_t *gWPArray[MAX_WPARRAY_SIZE];
+
+static int NotWithinRange(int base, int extent)
+{
+	if (extent > base && base+5 >= extent)
+	{
+		return 0;
+	}
+
+	if (extent < base && base-5 <= extent)
+	{
+		return 0;
+	}
+
+	return 1;
+}
+
+int SV_OrgVisibleBox(vec3_t org1, vec3_t mins, vec3_t maxs, vec3_t org2, int ignore, int rmg)
+{
+	trace_t tr;
+
+	if (rmg)
+	{
+		SV_Trace(&tr, org1, NULL, NULL, org2, ignore, MASK_SOLID, 0, 0, 10);
+	}
+	else
+	{
+		SV_Trace(&tr, org1, mins, maxs, org2, ignore, MASK_SOLID, 0, 0, 10);
+	}
+
+	if (tr.fraction == 1 && !tr.startsolid && !tr.allsolid)
+	{
+		return 1;
+	}
+
+	return 0;
+}
+
+void *BotVMShift( int ptr );
+
+void SV_BotWaypointReception(int wpnum, wpobject_t **wps)
+{
+	int i = 0;
+
+	gWPNum = wpnum;
+
+	while (i < gWPNum)
+	{
+		gWPArray[i] = (wpobject_t *)BotVMShift((int)wps[i]);
+		i++;
+	}
+}
+
+/*
+==================
+SV_BotCalculatePaths
+==================
+*/
+void SV_BotCalculatePaths(int rmg)
+{
+	int i;
+	int c;
+	int forceJumpable;
+	int maxNeighborDist = MAX_NEIGHBOR_LINK_DISTANCE;
+	float nLDist;
+	vec3_t a;
+	vec3_t mins, maxs;
+
+	if (!gWPNum)
+	{
+		return;
+	}
+
+	if (rmg)
+	{
+		maxNeighborDist = DEFAULT_GRID_SPACING + (DEFAULT_GRID_SPACING*0.5);
+	}
+
+	mins[0] = -15;
+	mins[1] = -15;
+	mins[2] = -15; //-1
+	maxs[0] = 15;
+	maxs[1] = 15;
+	maxs[2] = 15; //1
+
+	//now clear out all the neighbor data before we recalculate
+	i = 0;
+
+	while (i < gWPNum)
+	{
+		if (gWPArray[i] && gWPArray[i]->inuse && gWPArray[i]->neighbornum)
+		{
+			while (gWPArray[i]->neighbornum >= 0)
+			{
+				gWPArray[i]->neighbors[gWPArray[i]->neighbornum].num = 0;
+				gWPArray[i]->neighbors[gWPArray[i]->neighbornum].forceJumpTo = 0;
+				gWPArray[i]->neighbornum--;
+			}
+			gWPArray[i]->neighbornum = 0;
+		}
+
+		i++;
+	}
+
+	i = 0;
+
+	while (i < gWPNum)
+	{
+		if (gWPArray[i] && gWPArray[i]->inuse)
+		{
+			c = 0;
+
+			while (c < gWPNum)
+			{
+				if (gWPArray[c] && gWPArray[c]->inuse && i != c &&
+					NotWithinRange(i, c))
+				{
+					VectorSubtract(gWPArray[i]->origin, gWPArray[c]->origin, a);
+
+					nLDist = VectorLength(a);
+					forceJumpable = qfalse;//CanForceJumpTo(i, c, nLDist);
+
+					if ((nLDist < maxNeighborDist || forceJumpable) &&
+						((int)gWPArray[i]->origin[2] == (int)gWPArray[c]->origin[2] || forceJumpable) &&
+						(SV_OrgVisibleBox(gWPArray[i]->origin, mins, maxs, gWPArray[c]->origin, ENTITYNUM_NONE, rmg) || forceJumpable))
+					{
+						gWPArray[i]->neighbors[gWPArray[i]->neighbornum].num = c;
+						if (forceJumpable && ((int)gWPArray[i]->origin[2] != (int)gWPArray[c]->origin[2] || nLDist < maxNeighborDist))
+						{
+							gWPArray[i]->neighbors[gWPArray[i]->neighbornum].forceJumpTo = 999;//forceJumpable; //FJSR
+						}
+						else
+						{
+							gWPArray[i]->neighbors[gWPArray[i]->neighbornum].forceJumpTo = 0;
+						}
+						gWPArray[i]->neighbornum++;
+					}
+
+					if (gWPArray[i]->neighbornum >= MAX_NEIGHBOR_SIZE)
+					{
+						break;
+					}
+				}
+				c++;
+			}
+		}
+		i++;
+	}
+}
+
+/*
+==================
+SV_BotAllocateClient
+==================
+*/
+int SV_BotAllocateClient(void) {
+	int			i;
+	client_t	*cl;
+
+	// find a client slot
+	for ( i = 0, cl = svs.clients; i < sv_maxclients->integer; i++, cl++ ) {
+		if ( cl->state == CS_FREE ) {
+			break;
+		}
+	}
+
+	if ( i == sv_maxclients->integer ) {
+		return -1;
+	}
+
+	cl->gentity = SV_GentityNum( i );
+	cl->gentity->s.number = i;
+	cl->state = CS_ACTIVE;
+	cl->lastPacketTime = svs.time;
+	cl->netchan.remoteAddress.type = NA_BOT;
+	cl->rate = 16384;
+
+	return i;
+}
+
+/*
+==================
+SV_BotFreeClient
+==================
+*/
+void SV_BotFreeClient( int clientNum ) {
+	client_t	*cl;
+
+	if ( clientNum < 0 || clientNum >= sv_maxclients->integer ) {
+		Com_Error( ERR_DROP, "SV_BotFreeClient: bad clientNum: %i", clientNum );
+	}
+	cl = &svs.clients[clientNum];
+	cl->state = CS_FREE;
+	cl->name[0] = 0;
+	if ( cl->gentity ) {
+		cl->gentity->r.svFlags &= ~SVF_BOT;
+	}
+}
+
+/*
+==================
+BotDrawDebugPolygons
+==================
+*/
+void BotDrawDebugPolygons(void (*drawPoly)(int color, int numPoints, float *points), int value) {
+	static cvar_t *bot_debug, *bot_groundonly, *bot_reachability, *bot_highlightarea;
+	bot_debugpoly_t *poly;
+	int i, parm0;
+
+	if (!debugpolygons)
+		return;
+	//bot debugging
+	if (!bot_debug) bot_debug = Cvar_Get("bot_debug", "0", 0);
+	//
+	if (bot_enable && bot_debug->integer) {
+		//show reachabilities
+		if (!bot_reachability) bot_reachability = Cvar_Get("bot_reachability", "0", 0);
+		//show ground faces only
+		if (!bot_groundonly) bot_groundonly = Cvar_Get("bot_groundonly", "1", 0);
+		//get the hightlight area
+		if (!bot_highlightarea) bot_highlightarea = Cvar_Get("bot_highlightarea", "0", 0);
+		//
+		parm0 = 0;
+		if (svs.clients[0].lastUsercmd.buttons & BUTTON_ATTACK) parm0 |= 1;
+		if (bot_reachability->integer) parm0 |= 2;
+		if (bot_groundonly->integer) parm0 |= 4;
+		botlib_export->BotLibVarSet("bot_highlightarea", bot_highlightarea->string);
+		botlib_export->Test(parm0, NULL, svs.clients[0].gentity->r.currentOrigin, 
+			svs.clients[0].gentity->r.currentAngles);
+	} //end if
+	//draw all debug polys
+	for (i = 0; i < bot_maxdebugpolys; i++) {
+		poly = &debugpolygons[i];
+		if (!poly->inuse) continue;
+		drawPoly(poly->color, poly->numPoints, (float *) poly->points);
+		//Com_Printf("poly %i, numpoints = %d\n", i, poly->numPoints);
+	}
+}
+
+/*
+==================
+BotImport_Print
+==================
+*/
+void QDECL BotImport_Print(int type, char *fmt, ...)
+{
+	char str[2048];
+	va_list ap;
+
+	va_start(ap, fmt);
+	vsprintf(str, fmt, ap);
+	va_end(ap);
+
+	switch(type) {
+		case PRT_MESSAGE: {
+			Com_Printf("%s", str);
+			break;
+		}
+		case PRT_WARNING: {
+			Com_Printf(S_COLOR_YELLOW "Warning: %s", str);
+			break;
+		}
+		case PRT_ERROR: {
+			Com_Printf(S_COLOR_RED "Error: %s", str);
+			break;
+		}
+		case PRT_FATAL: {
+			Com_Printf(S_COLOR_RED "Fatal: %s", str);
+			break;
+		}
+		case PRT_EXIT: {
+			Com_Error(ERR_DROP, S_COLOR_RED "Exit: %s", str);
+			break;
+		}
+		default: {
+			Com_Printf("unknown print type\n");
+			break;
+		}
+	}
+}
+
+/*
+==================
+BotImport_Trace
+==================
+*/
+void BotImport_Trace(bsp_trace_t *bsptrace, vec3_t start, vec3_t mins, vec3_t maxs, vec3_t end, int passent, int contentmask) {
+	trace_t trace;
+
+	SV_Trace(&trace, start, mins, maxs, end, passent, contentmask, qfalse, 0, 10);
+	//copy the trace information
+	bsptrace->allsolid = (qboolean)trace.allsolid;
+	bsptrace->startsolid = (qboolean)trace.startsolid;
+	bsptrace->fraction = trace.fraction;
+	VectorCopy(trace.endpos, bsptrace->endpos);
+	bsptrace->plane.dist = trace.plane.dist;
+	VectorCopy(trace.plane.normal, bsptrace->plane.normal);
+	bsptrace->plane.signbits = trace.plane.signbits;
+	bsptrace->plane.type = trace.plane.type;
+	bsptrace->surface.value = trace.surfaceFlags;
+	bsptrace->ent = trace.entityNum;
+	bsptrace->exp_dist = 0;
+	bsptrace->sidenum = 0;
+	bsptrace->contents = 0;
+}
+
+/*
+==================
+BotImport_EntityTrace
+==================
+*/
+void BotImport_EntityTrace(bsp_trace_t *bsptrace, vec3_t start, vec3_t mins, vec3_t maxs, vec3_t end, int entnum, int contentmask) {
+	trace_t trace;
+
+	SV_ClipToEntity(&trace, start, mins, maxs, end, entnum, contentmask, qfalse);
+	//copy the trace information
+	bsptrace->allsolid = (qboolean)trace.allsolid;
+	bsptrace->startsolid = (qboolean)trace.startsolid;
+	bsptrace->fraction = trace.fraction;
+	VectorCopy(trace.endpos, bsptrace->endpos);
+	bsptrace->plane.dist = trace.plane.dist;
+	VectorCopy(trace.plane.normal, bsptrace->plane.normal);
+	bsptrace->plane.signbits = trace.plane.signbits;
+	bsptrace->plane.type = trace.plane.type;
+	bsptrace->surface.value = trace.surfaceFlags;
+	bsptrace->ent = trace.entityNum;
+	bsptrace->exp_dist = 0;
+	bsptrace->sidenum = 0;
+	bsptrace->contents = 0;
+}
+
+
+/*
+==================
+BotImport_PointContents
+==================
+*/
+int BotImport_PointContents(vec3_t point) {
+	return SV_PointContents(point, -1);
+}
+
+/*
+==================
+BotImport_inPVS
+==================
+*/
+int BotImport_inPVS(vec3_t p1, vec3_t p2) {
+	return SV_inPVS (p1, p2);
+}
+
+/*
+==================
+BotImport_BSPEntityData
+==================
+*/
+char *BotImport_BSPEntityData(void) {
+	return CM_EntityString();
+}
+
+/*
+==================
+BotImport_BSPModelMinsMaxsOrigin
+==================
+*/
+void BotImport_BSPModelMinsMaxsOrigin(int modelnum, vec3_t angles, vec3_t outmins, vec3_t outmaxs, vec3_t origin) {
+	clipHandle_t h;
+	vec3_t mins, maxs;
+	float max;
+	int	i;
+
+	h = CM_InlineModel(modelnum);
+	CM_ModelBounds(h, mins, maxs);
+	//if the model is rotated
+	if ((angles[0] || angles[1] || angles[2])) {
+		// expand for rotation
+
+		max = RadiusFromBounds(mins, maxs);
+		for (i = 0; i < 3; i++) {
+			mins[i] = -max;
+			maxs[i] = max;
+		}
+	}
+	if (outmins) VectorCopy(mins, outmins);
+	if (outmaxs) VectorCopy(maxs, outmaxs);
+	if (origin) VectorClear(origin);
+}
+
+/*
+==================
+BotImport_GetMemoryGame
+==================
+*/
+#ifndef _XBOX	// These are unused, I want the tag back
+void *Bot_GetMemoryGame(int size) {
+	void *ptr;
+
+	ptr = Z_Malloc( size, TAG_BOTGAME, qtrue );
+
+	return ptr;
+}
+
+/*
+==================
+BotImport_FreeMemoryGame
+==================
+*/
+void Bot_FreeMemoryGame(void *ptr) {
+	Z_Free(ptr);
+}
+#endif
+/*
+==================
+BotImport_GetMemory
+==================
+*/
+void *BotImport_GetMemory(int size) {
+	void *ptr;
+
+	ptr = Z_Malloc( size, TAG_BOTLIB, qtrue );
+	return ptr;
+}
+
+/*
+==================
+BotImport_FreeMemory
+==================
+*/
+void BotImport_FreeMemory(void *ptr) {
+	Z_Free(ptr);
+}
+
+/*
+=================
+BotImport_HunkAlloc
+=================
+*/
+void *BotImport_HunkAlloc( int size ) {
+	if( Hunk_CheckMark() ) {
+		Com_Error( ERR_DROP, "SV_Bot_HunkAlloc: Alloc with marks already set\n" );
+	}
+	return Hunk_Alloc( size, h_high );
+}
+
+/*
+==================
+BotImport_DebugPolygonCreate
+==================
+*/
+int BotImport_DebugPolygonCreate(int color, int numPoints, vec3_t *points) {
+	bot_debugpoly_t *poly;
+	int i;
+
+	if (!debugpolygons)
+		return 0;
+
+	for (i = 1; i < bot_maxdebugpolys; i++) 	{
+		if (!debugpolygons[i].inuse)
+			break;
+	}
+	if (i >= bot_maxdebugpolys)
+		return 0;
+	poly = &debugpolygons[i];
+	poly->inuse = qtrue;
+	poly->color = color;
+	poly->numPoints = numPoints;
+	Com_Memcpy(poly->points, points, numPoints * sizeof(vec3_t));
+	//
+	return i;
+}
+
+/*
+==================
+BotImport_DebugPolygonShow
+==================
+*/
+void BotImport_DebugPolygonShow(int id, int color, int numPoints, vec3_t *points) {
+	bot_debugpoly_t *poly;
+
+	if (!debugpolygons) return;
+	poly = &debugpolygons[id];
+	poly->inuse = qtrue;
+	poly->color = color;
+	poly->numPoints = numPoints;
+	Com_Memcpy(poly->points, points, numPoints * sizeof(vec3_t));
+}
+
+/*
+==================
+BotImport_DebugPolygonDelete
+==================
+*/
+void BotImport_DebugPolygonDelete(int id)
+{
+	if (!debugpolygons) return;
+	debugpolygons[id].inuse = qfalse;
+}
+
+/*
+==================
+BotImport_DebugLineCreate
+==================
+*/
+int BotImport_DebugLineCreate(void) {
+	vec3_t points[1];
+	return BotImport_DebugPolygonCreate(0, 0, points);
+}
+
+/*
+==================
+BotImport_DebugLineDelete
+==================
+*/
+void BotImport_DebugLineDelete(int line) {
+	BotImport_DebugPolygonDelete(line);
+}
+
+/*
+==================
+BotImport_DebugLineShow
+==================
+*/
+void BotImport_DebugLineShow(int line, vec3_t start, vec3_t end, int color) {
+	vec3_t points[4], dir, cross, up = {0, 0, 1};
+	float dot;
+
+	VectorCopy(start, points[0]);
+	VectorCopy(start, points[1]);
+	//points[1][2] -= 2;
+	VectorCopy(end, points[2]);
+	//points[2][2] -= 2;
+	VectorCopy(end, points[3]);
+
+
+	VectorSubtract(end, start, dir);
+	VectorNormalize(dir);
+	dot = DotProduct(dir, up);
+	if (dot > 0.99 || dot < -0.99) VectorSet(cross, 1, 0, 0);
+	else CrossProduct(dir, up, cross);
+
+	VectorNormalize(cross);
+
+	VectorMA(points[0], 2, cross, points[0]);
+	VectorMA(points[1], -2, cross, points[1]);
+	VectorMA(points[2], -2, cross, points[2]);
+	VectorMA(points[3], 2, cross, points[3]);
+
+	BotImport_DebugPolygonShow(line, color, 4, points);
+}
+
+/*
+==================
+SV_BotClientCommand
+==================
+*/
+void BotClientCommand( int client, char *command ) {
+	SV_ExecuteClientCommand( &svs.clients[client], command, qtrue );
+}
+
+/*
+==================
+SV_BotFrame
+==================
+*/
+void SV_BotFrame( int time ) {
+	if (!bot_enable) return;
+	//NOTE: maybe the game is already shutdown
+	if (!gvm) return;
+	VM_Call( gvm, BOTAI_START_FRAME, time );
+}
+
+/*
+===============
+SV_BotLibSetup
+===============
+*/
+int SV_BotLibSetup( void ) {
+	if (!bot_enable) {
+		return 0;
+	}
+
+	if ( !botlib_export ) {
+		Com_Printf( S_COLOR_RED "Error: SV_BotLibSetup without SV_BotInitBotLib\n" );
+		return -1;
+	}
+
+	return botlib_export->BotLibSetup();
+}
+
+/*
+===============
+SV_ShutdownBotLib
+
+Called when either the entire server is being killed, or
+it is changing to a different game directory.
+===============
+*/
+int SV_BotLibShutdown( void ) {
+
+	if ( !botlib_export ) {
+		return -1;
+	}
+
+	return botlib_export->BotLibShutdown();
+}
+
+/*
+==================
+SV_BotInitCvars
+==================
+*/
+void SV_BotInitCvars(void) {
+
+	Cvar_Get("bot_enable", "1", 0);						//enable the bot
+	Cvar_Get("bot_developer", "0", CVAR_CHEAT);			//bot developer mode
+	Cvar_Get("bot_debug", "0", CVAR_CHEAT);				//enable bot debugging
+	Cvar_Get("bot_maxdebugpolys", "2", 0);				//maximum number of debug polys
+	Cvar_Get("bot_groundonly", "1", 0);					//only show ground faces of areas
+	Cvar_Get("bot_reachability", "0", 0);				//show all reachabilities to other areas
+	Cvar_Get("bot_visualizejumppads", "0", CVAR_CHEAT);	//show jumppads
+	Cvar_Get("bot_forceclustering", "0", 0);			//force cluster calculations
+	Cvar_Get("bot_forcereachability", "0", 0);			//force reachability calculations
+	Cvar_Get("bot_forcewrite", "0", 0);					//force writing aas file
+	Cvar_Get("bot_aasoptimize", "0", 0);				//no aas file optimisation
+	Cvar_Get("bot_saveroutingcache", "0", 0);			//save routing cache
+	Cvar_Get("bot_thinktime", "100", CVAR_CHEAT);		//msec the bots thinks
+	Cvar_Get("bot_reloadcharacters", "0", 0);			//reload the bot characters each time
+	Cvar_Get("bot_testichat", "0", 0);					//test ichats
+	Cvar_Get("bot_testrchat", "0", 0);					//test rchats
+	Cvar_Get("bot_testsolid", "0", CVAR_CHEAT);			//test for solid areas
+	Cvar_Get("bot_testclusters", "0", CVAR_CHEAT);		//test the AAS clusters
+	Cvar_Get("bot_fastchat", "0", 0);					//fast chatting bots
+	Cvar_Get("bot_nochat", "0", 0);						//disable chats
+	Cvar_Get("bot_pause", "0", CVAR_CHEAT);				//pause the bots thinking
+	Cvar_Get("bot_report", "0", CVAR_CHEAT);			//get a full report in ctf
+	Cvar_Get("bot_grapple", "0", 0);					//enable grapple
+	Cvar_Get("bot_rocketjump", "1", 0);					//enable rocket jumping
+	Cvar_Get("bot_challenge", "0", 0);					//challenging bot
+	Cvar_Get("bot_minplayers", "0", 0);					//minimum players in a team or the game
+	Cvar_Get("bot_interbreedchar", "", CVAR_CHEAT);		//bot character used for interbreeding
+	Cvar_Get("bot_interbreedbots", "10", CVAR_CHEAT);	//number of bots used for interbreeding
+	Cvar_Get("bot_interbreedcycle", "20", CVAR_CHEAT);	//bot interbreeding cycle
+	Cvar_Get("bot_interbreedwrite", "", CVAR_CHEAT);	//write interbreeded bots to this file
+}
+
+extern botlib_export_t *GetBotLibAPI( int apiVersion, botlib_import_t *import );
+
+// there's no such thing as this now, since the zone is unlimited, but I have to provide something
+//	so it doesn't run out of control alloc-wise (since the bot code calls this in a while() loop to free
+//	up bot mem until zone has > 1MB available again. So, simulate a reasonable limit...
+//
+static int bot_Z_AvailableMemory(void)
+{
+	const int iMaxBOTLIBMem = 8 * 1024 * 1024;	// adjust accordingly.
+	return iMaxBOTLIBMem - Z_MemSize( TAG_BOTLIB );
+}
+
+/*
+==================
+SV_BotInitBotLib
+==================
+*/
+void SV_BotInitBotLib(void) {
+	botlib_import_t	botlib_import;
+
+	if (debugpolygons) Z_Free(debugpolygons);
+	bot_maxdebugpolys = Cvar_VariableIntegerValue("bot_maxdebugpolys");
+	debugpolygons = (struct bot_debugpoly_s *)Z_Malloc(sizeof(bot_debugpoly_t) * bot_maxdebugpolys, TAG_BOTLIB, qtrue);
+
+	botlib_import.Print = BotImport_Print;
+	botlib_import.Trace = BotImport_Trace;
+	botlib_import.EntityTrace = BotImport_EntityTrace;
+	botlib_import.PointContents = BotImport_PointContents;
+	botlib_import.inPVS = BotImport_inPVS;
+	botlib_import.BSPEntityData = BotImport_BSPEntityData;
+	botlib_import.BSPModelMinsMaxsOrigin = BotImport_BSPModelMinsMaxsOrigin;
+	botlib_import.BotClientCommand = BotClientCommand;
+
+	//memory management
+	botlib_import.GetMemory = BotImport_GetMemory;
+	botlib_import.FreeMemory = BotImport_FreeMemory;
+	botlib_import.AvailableMemory = bot_Z_AvailableMemory;	//Z_AvailableMemory;
+	botlib_import.HunkAlloc = BotImport_HunkAlloc;
+
+	// file system access
+	botlib_import.FS_FOpenFile = FS_FOpenFileByMode;
+	botlib_import.FS_Read = FS_Read2;
+	botlib_import.FS_Write = FS_Write;
+	botlib_import.FS_FCloseFile = FS_FCloseFile;
+	botlib_import.FS_Seek = FS_Seek;
+
+	//debug lines
+	botlib_import.DebugLineCreate = BotImport_DebugLineCreate;
+	botlib_import.DebugLineDelete = BotImport_DebugLineDelete;
+	botlib_import.DebugLineShow = BotImport_DebugLineShow;
+
+	//debug polygons
+	botlib_import.DebugPolygonCreate = BotImport_DebugPolygonCreate;
+	botlib_import.DebugPolygonDelete = BotImport_DebugPolygonDelete;
+
+	botlib_export = (botlib_export_t *)GetBotLibAPI( BOTLIB_API_VERSION, &botlib_import );
+	assert(botlib_export); 	// bk001129 - somehow we end up with a zero import.
+}
+
+
+//
+//  * * * BOT AI CODE IS BELOW THIS POINT * * *
+//
+
+/*
+==================
+SV_BotGetConsoleMessage
+==================
+*/
+int SV_BotGetConsoleMessage( int client, char *buf, int size )
+{
+	client_t	*cl;
+	int			index;
+
+	cl = &svs.clients[client];
+	cl->lastPacketTime = svs.time;
+
+	if ( cl->reliableAcknowledge == cl->reliableSequence ) {
+		return qfalse;
+	}
+
+	cl->reliableAcknowledge++;
+	index = cl->reliableAcknowledge & ( MAX_RELIABLE_COMMANDS - 1 );
+
+	if ( !cl->reliableCommands[index][0] ) {
+		return qfalse;
+	}
+
+	Q_strncpyz( buf, cl->reliableCommands[index], size );
+	return qtrue;
+}
+
+#if 0
+/*
+==================
+EntityInPVS
+==================
+*/
+int EntityInPVS( int client, int entityNum ) {
+	client_t			*cl;
+	clientSnapshot_t	*frame;
+	int					i;
+
+	cl = &svs.clients[client];
+	frame = &cl->frames[cl->netchan.outgoingSequence & PACKET_MASK];
+	for ( i = 0; i < frame->num_entities; i++ )	{
+		if ( svs.snapshotEntities[(frame->first_entity + i) % svs.numSnapshotEntities].number == entityNum ) {
+			return qtrue;
+		}
+	}
+	return qfalse;
+}
+#endif
+
+/*
+==================
+SV_BotGetSnapshotEntity
+==================
+*/
+int SV_BotGetSnapshotEntity( int client, int sequence ) {
+	client_t			*cl;
+	clientSnapshot_t	*frame;
+
+	cl = &svs.clients[client];
+	frame = &cl->frames[cl->netchan.outgoingSequence & PACKET_MASK];
+	if (sequence < 0 || sequence >= frame->num_entities) {
+		return -1;
+	}
+	return svs.snapshotEntities[(frame->first_entity + sequence) % svs.numSnapshotEntities].number;
+}
+
diff --git a/codemp/server/sv_ccmds.cpp b/codemp/server/sv_ccmds.cpp
new file mode 100644
index 0000000..599ce07
--- /dev/null
+++ b/codemp/server/sv_ccmds.cpp
@@ -0,0 +1,1019 @@
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+#include "server.h"
+#include "../qcommon/stringed_ingame.h"
+
+/*
+===============================================================================
+
+OPERATOR CONSOLE ONLY COMMANDS
+
+These commands can only be entered from stdin or by a remote operator datagram
+===============================================================================
+*/
+
+const char *SV_GetStringEdString(char *refSection, char *refName)
+{
+	/*
+	static char text[1024]={0};
+	trap_SP_GetStringTextString(va("%s_%s", refSection, refName), text, sizeof(text));
+	return text;
+	*/
+
+	//Well, it would've been lovely doing it the above way, but it would mean mixing
+	//languages for the client depending on what the server is. So we'll mark this as
+	//a stringed reference with @@@ and send the refname to the client, and when it goes
+	//to print it will get scanned for the stringed reference indication and dealt with
+	//properly.
+	static char text[1024]={0};
+	Com_sprintf(text, sizeof(text), "@@@%s", refName);
+	return text;
+}
+
+
+
+/*
+==================
+SV_GetPlayerByName
+
+Returns the player with name from Cmd_Argv(1)
+==================
+*/
+static client_t *SV_GetPlayerByName( void ) {
+	client_t	*cl;
+	int			i;
+	char		*s;
+	char		cleanName[64];
+
+	// make sure server is running
+	if ( !com_sv_running->integer ) {
+		return NULL;
+	}
+
+	if ( Cmd_Argc() < 2 ) {
+		Com_Printf( "No player specified.\n" );
+		return NULL;
+	}
+
+	s = Cmd_Argv(1);
+
+	// check for a name match
+	for ( i=0, cl=svs.clients ; i < sv_maxclients->integer ; i++,cl++ ) {
+		if ( !cl->state ) {
+			continue;
+		}
+		if ( !Q_stricmp( cl->name, s ) ) {
+			return cl;
+		}
+
+		Q_strncpyz( cleanName, cl->name, sizeof(cleanName) );
+		Q_CleanStr( cleanName );
+		if ( !Q_stricmp( cleanName, s ) ) {
+			return cl;
+		}
+	}
+
+	Com_Printf( "Player %s is not on the server\n", s );
+
+	return NULL;
+}
+
+/*
+==================
+SV_GetPlayerByNum
+
+Returns the player with idnum from Cmd_Argv(1)
+==================
+*/
+static client_t *SV_GetPlayerByNum( void ) {
+	client_t	*cl;
+	int			i;
+	int			idnum;
+	char		*s;
+
+	// make sure server is running
+	if ( !com_sv_running->integer ) {
+		return NULL;
+	}
+
+	if ( Cmd_Argc() < 2 ) {
+		Com_Printf( "No player specified.\n" );
+		return NULL;
+	}
+
+	s = Cmd_Argv(1);
+
+	for (i = 0; s[i]; i++) {
+		if (s[i] < '0' || s[i] > '9') {
+			Com_Printf( "Bad slot number: %s\n", s);
+			return NULL;
+		}
+	}
+	idnum = atoi( s );
+	if ( idnum < 0 || idnum >= sv_maxclients->integer ) {
+		Com_Printf( "Bad client slot: %i\n", idnum );
+		return NULL;
+	}
+
+	cl = &svs.clients[idnum];
+	if ( !cl->state ) {
+		Com_Printf( "Client %i is not active\n", idnum );
+		return NULL;
+	}
+	return cl;
+}
+
+//=========================================================
+
+
+
+/*
+==================
+SV_Map_f
+
+Restart the server on a different map
+==================
+*/
+static void SV_Map_f( void ) {
+	char		*cmd;
+	char		*map;
+	qboolean	killBots, cheat;
+	char		expanded[MAX_QPATH];
+	char		mapname[MAX_QPATH];
+
+	map = Cmd_Argv(1);
+	if ( !map ) {
+		return;
+	}
+
+	// make sure the level exists before trying to change, so that
+	// a typo at the server console won't end the game
+	if (strchr (map, '\\') ) {
+		Com_Printf ("Can't have mapnames with a \\\n");
+		return;
+	}
+
+#ifndef _XBOX
+	Com_sprintf (expanded, sizeof(expanded), "maps/%s.bsp", map);
+	if ( FS_ReadFile (expanded, NULL) == -1 ) {
+		Com_Printf ("Can't find map %s\n", expanded);
+		return;
+	}
+#endif
+
+	// force latched values to get set
+	Cvar_Get ("g_gametype", "0", CVAR_SERVERINFO | CVAR_USERINFO | CVAR_LATCH );
+
+	cmd = Cmd_Argv(0);
+	if( Q_stricmpn( cmd, "sp", 2 ) == 0 ) {
+		Cvar_SetValue( "g_gametype", GT_SINGLE_PLAYER );
+		Cvar_SetValue( "g_doWarmup", 0 );
+		// may not set sv_maxclients directly, always set latched
+		Cvar_SetLatched( "sv_maxclients", "8" );
+		cmd += 2;
+		cheat = qfalse;
+		killBots = qtrue;
+	}
+	else {
+		if ( !Q_stricmpn( cmd, "devmap",6 ) || !Q_stricmp( cmd, "spdevmap" ) ) {
+			cheat = qtrue;
+			killBots = qtrue;
+		} else {
+			cheat = qfalse;
+			killBots = qfalse;
+		}
+		/*
+		if( sv_gametype->integer == GT_SINGLE_PLAYER ) {
+			Cvar_SetValue( "g_gametype", GT_FFA );
+		}
+		*/
+	}
+
+	// save the map name here cause on a map restart we reload the jampconfig.cfg
+	// and thus nuke the arguments of the map command
+	Q_strncpyz(mapname, map, sizeof(mapname));
+
+	ForceReload_e eForceReload = eForceReload_NOTHING;	// default for normal load
+
+//	if ( !Q_stricmp( cmd, "devmapbsp") ) {	// not relevant in MP codebase
+//		eForceReload = eForceReload_BSP;
+//	}
+//	else
+	if ( !Q_stricmp( cmd, "devmapmdl") ) {
+		eForceReload = eForceReload_MODELS;
+	}
+	else
+	if ( !Q_stricmp( cmd, "devmapall") ) {
+		eForceReload = eForceReload_ALL;
+	}
+
+	// start up the map
+	SV_SpawnServer( mapname, killBots, eForceReload );
+
+	// set the cheat value
+	// if the level was started with "map <levelname>", then
+	// cheats will not be allowed.  If started with "devmap <levelname>"
+	// then cheats will be allowed
+	if ( cheat ) {
+		Cvar_Set( "sv_cheats", "1" );
+	} else {
+		Cvar_Set( "sv_cheats", "0" );
+	}
+}
+
+
+/*
+================
+SV_MapRestart_f
+
+Completely restarts a level, but doesn't send a new gamestate to the clients.
+This allows fair starts with variable load times.
+================
+*/
+static void SV_MapRestart_f( void ) {
+	int			i;
+	client_t	*client;
+	char		*denied;
+	qboolean	isBot;
+	int			delay;
+
+	// make sure we aren't restarting twice in the same frame
+	if ( com_frameTime == sv.serverId ) {
+		return;
+	}
+
+	// make sure server is running
+	if ( !com_sv_running->integer ) {
+		Com_Printf( "Server is not running.\n" );
+		return;
+	}
+
+	if ( sv.restartTime ) {
+		return;
+	}
+
+	if (Cmd_Argc() > 1 ) {
+		delay = atoi( Cmd_Argv(1) );
+	}
+	else {
+		delay = 5;
+	}
+	if( delay ) {
+		sv.restartTime = svs.time + delay * 1000;
+		SV_SetConfigstring( CS_WARMUP, va("%i", sv.restartTime) );
+		return;
+	}
+
+	// check for changes in variables that can't just be restarted
+	// check for maxclients change
+	if ( sv_maxclients->modified || sv_gametype->modified ) {
+		char	mapname[MAX_QPATH];
+
+		Com_Printf( "variable change -- restarting.\n" );
+		// restart the map the slow way
+		Q_strncpyz( mapname, Cvar_VariableString( "mapname" ), sizeof( mapname ) );
+
+		SV_SpawnServer( mapname, qfalse, eForceReload_NOTHING );
+		return;
+	}
+
+	// toggle the server bit so clients can detect that a
+	// map_restart has happened
+	svs.snapFlagServerBit ^= SNAPFLAG_SERVERCOUNT;
+
+	// generate a new serverid
+	sv.restartedServerId = sv.serverId;
+	sv.serverId = com_frameTime;
+	Cvar_Set( "sv_serverid", va("%i", sv.serverId ) );
+
+	// reset all the vm data in place without changing memory allocation
+	// note that we do NOT set sv.state = SS_LOADING, so configstrings that
+	// had been changed from their default values will generate broadcast updates
+	sv.state = SS_LOADING;
+	sv.restarting = qtrue;
+
+	SV_RestartGameProgs();
+
+	// run a few frames to allow everything to settle
+	for ( i = 0 ;i < 3 ; i++ ) {
+		VM_Call( gvm, GAME_RUN_FRAME, svs.time );
+		svs.time += 100;
+	}
+
+	sv.state = SS_GAME;
+	sv.restarting = qfalse;
+
+	// connect and begin all the clients
+	for (i=0 ; i<sv_maxclients->integer ; i++) {
+		client = &svs.clients[i];
+
+		// send the new gamestate to all connected clients
+		if ( client->state < CS_CONNECTED) {
+			continue;
+		}
+
+		if ( client->netchan.remoteAddress.type == NA_BOT ) {
+			isBot = qtrue;
+		} else {
+			isBot = qfalse;
+		}
+
+		// add the map_restart command
+		SV_AddServerCommand( client, "map_restart\n" );
+
+		// connect the client again, without the firstTime flag
+		denied = (char *)VM_ExplicitArgPtr( gvm, VM_Call( gvm, GAME_CLIENT_CONNECT, i, qfalse, isBot ) );
+		if ( denied ) {
+			// this generally shouldn't happen, because the client
+			// was connected before the level change
+			SV_DropClient( client, denied );
+			Com_Printf( "SV_MapRestart_f(%d): dropped client %i - denied!\n", delay, i ); // bk010125
+			continue;
+		}
+
+		client->state = CS_ACTIVE;
+
+		SV_ClientEnterWorld( client, &client->lastUsercmd );
+	}	
+
+	// run another frame to allow things to look at all the players
+	VM_Call( gvm, GAME_RUN_FRAME, svs.time );
+	svs.time += 100;
+}
+
+//===============================================================
+
+/*
+==================
+SV_GetPlayerByName
+
+Returns the player with name from Cmd_Argv(1)
+==================
+*/
+static client_t *SV_GetPlayerByFedName( const char *name )
+{
+	client_t	*cl;
+	int			i;
+	char		cleanName[64];
+
+	// make sure server is running
+	if ( !com_sv_running->integer )
+	{
+		return NULL;
+	}
+
+	// check for a name match
+	for ( i=0, cl=svs.clients ; i < sv_maxclients->integer ; i++,cl++ )
+	{
+		if ( !cl->state )
+		{
+			continue;
+		}
+		if ( !Q_stricmp( cl->name, name ) )
+		{
+			return cl;
+		}
+
+		Q_strncpyz( cleanName, cl->name, sizeof(cleanName) );
+		Q_CleanStr( cleanName );
+		if ( !Q_stricmp( cleanName, name ) )
+		{
+			return cl;
+		}
+	}
+
+	return NULL;
+}
+
+static void SV_KickByName( const char *name )
+{
+	client_t	*cl;
+	int			i;
+
+	// make sure server is running
+	if ( !com_sv_running->integer )
+	{
+		return;
+	}
+
+	cl = SV_GetPlayerByFedName(name);
+	if ( !cl )
+	{
+		if ( !Q_stricmp(name, "all") )
+		{
+			for ( i=0, cl=svs.clients ; i < sv_maxclients->integer ; i++,cl++ )
+			{
+				if ( !cl->state )
+				{
+					continue;
+				}
+				if( cl->netchan.remoteAddress.type == NA_LOOPBACK )
+				{
+					continue;
+				}
+				SV_DropClient( cl, SV_GetStringEdString("MP_SVGAME","WAS_KICKED"));	// "was kicked" );
+				cl->lastPacketTime = svs.time;	// in case there is a funny zombie
+			}
+		}
+		else if ( !Q_stricmp(name, "allbots") )
+		{
+			for ( i=0, cl=svs.clients ; i < sv_maxclients->integer ; i++,cl++ )
+			{
+				if ( !cl->state )
+				{
+					continue;
+				}
+				if( cl->netchan.remoteAddress.type != NA_BOT )
+				{
+					continue;
+				}
+				SV_DropClient( cl, SV_GetStringEdString("MP_SVGAME","WAS_KICKED"));	// "was kicked" );
+				cl->lastPacketTime = svs.time;	// in case there is a funny zombie
+			}
+		}
+		return;
+	}
+	if( cl->netchan.remoteAddress.type == NA_LOOPBACK )
+	{
+//		SV_SendServerCommand(NULL, "print \"%s\"", "Cannot kick host player\n");
+		SV_SendServerCommand(NULL, "print \"%s\"", SV_GetStringEdString("MP_SVGAME","CANNOT_KICK_HOST"));
+		return;
+	}
+
+	SV_DropClient( cl, SV_GetStringEdString("MP_SVGAME","WAS_KICKED"));	// "was kicked" );
+	cl->lastPacketTime = svs.time;	// in case there is a funny zombie
+}
+
+/*
+==================
+SV_Kick_f
+
+Kick a user off of the server  FIXME: move to game
+==================
+*/
+static void SV_Kick_f( void ) {
+	client_t	*cl;
+	int			i;
+
+	// make sure server is running
+	if ( !com_sv_running->integer ) {
+		Com_Printf( "Server is not running.\n" );
+		return;
+	}
+
+	if ( Cmd_Argc() != 2 ) {
+		Com_Printf ("Usage: kick <player name>\nkick all = kick everyone\nkick allbots = kick all bots\n");
+		return;
+	}
+
+	if (!Q_stricmp(Cmd_Argv(1), "Padawan"))
+	{ //if you try to kick the default name, also try to kick ""
+		SV_KickByName("");
+	}
+
+	cl = SV_GetPlayerByName();
+	if ( !cl ) {
+		if ( !Q_stricmp(Cmd_Argv(1), "all") ) {
+			for ( i=0, cl=svs.clients ; i < sv_maxclients->integer ; i++,cl++ ) {
+				if ( !cl->state ) {
+					continue;
+				}
+				if( cl->netchan.remoteAddress.type == NA_LOOPBACK ) {
+					continue;
+				}
+				SV_DropClient( cl, SV_GetStringEdString("MP_SVGAME","WAS_KICKED"));	// "was kicked" );
+				cl->lastPacketTime = svs.time;	// in case there is a funny zombie
+			}
+		}
+		else if ( !Q_stricmp(Cmd_Argv(1), "allbots") ) {
+			for ( i=0, cl=svs.clients ; i < sv_maxclients->integer ; i++,cl++ ) {
+				if ( !cl->state ) {
+					continue;
+				}
+				if( cl->netchan.remoteAddress.type != NA_BOT ) {
+					continue;
+				}
+				SV_DropClient( cl, SV_GetStringEdString("MP_SVGAME","WAS_KICKED"));	// "was kicked" );
+				cl->lastPacketTime = svs.time;	// in case there is a funny zombie
+			}
+		}
+		return;
+	}
+	if( cl->netchan.remoteAddress.type == NA_LOOPBACK ) {
+//		SV_SendServerCommand(NULL, "print \"%s\"", "Cannot kick host player\n");
+		SV_SendServerCommand(NULL, "print \"%s\"", SV_GetStringEdString("MP_SVGAME","CANNOT_KICK_HOST"));
+		return;
+	}
+
+	SV_DropClient( cl, SV_GetStringEdString("MP_SVGAME","WAS_KICKED"));	// "was kicked" );
+	cl->lastPacketTime = svs.time;	// in case there is a funny zombie
+}
+
+/*
+==================
+SV_Ban_f
+
+Ban a user from being able to play on this server through the auth
+server
+==================
+*/
+#ifdef USE_CD_KEY
+
+static void SV_Ban_f( void ) {
+	client_t	*cl;
+
+	// make sure server is running
+	if ( !com_sv_running->integer ) {
+		Com_Printf( "Server is not running.\n" );
+		return;
+	}
+
+	if ( Cmd_Argc() != 2 ) {
+		Com_Printf ("Usage: banUser <player name>\n");
+		return;
+	}
+
+	cl = SV_GetPlayerByName();
+
+	if (!cl) {
+		return;
+	}
+
+	if( cl->netchan.remoteAddress.type == NA_LOOPBACK ) {
+//		SV_SendServerCommand(NULL, "print \"%s\"", "Cannot kick host player\n");
+		SV_SendServerCommand(NULL, "print \"%s\"", SV_GetStringEdString("MP_SVGAME","CANNOT_KICK_HOST"));
+		return;
+	}
+
+	// look up the authorize server's IP
+	if ( !svs.authorizeAddress.ip[0] && svs.authorizeAddress.type != NA_BAD ) {
+		Com_Printf( "Resolving %s\n", AUTHORIZE_SERVER_NAME );
+		if ( !NET_StringToAdr( AUTHORIZE_SERVER_NAME, &svs.authorizeAddress ) ) {
+			Com_Printf( "Couldn't resolve address\n" );
+			return;
+		}
+		svs.authorizeAddress.port = BigShort( PORT_AUTHORIZE );
+		Com_Printf( "%s resolved to %i.%i.%i.%i:%i\n", AUTHORIZE_SERVER_NAME,
+			svs.authorizeAddress.ip[0], svs.authorizeAddress.ip[1],
+			svs.authorizeAddress.ip[2], svs.authorizeAddress.ip[3],
+			BigShort( svs.authorizeAddress.port ) );
+	}
+
+	// otherwise send their ip to the authorize server
+	if ( svs.authorizeAddress.type != NA_BAD ) {
+		NET_OutOfBandPrint( NS_SERVER, svs.authorizeAddress,
+			"banUser %i.%i.%i.%i", cl->netchan.remoteAddress.ip[0], cl->netchan.remoteAddress.ip[1], 
+								   cl->netchan.remoteAddress.ip[2], cl->netchan.remoteAddress.ip[3] );
+		Com_Printf("%s was banned from coming back\n", cl->name);
+	}
+}
+
+/*
+==================
+SV_BanNum_f
+
+Ban a user from being able to play on this server through the auth
+server
+==================
+*/
+static void SV_BanNum_f( void ) {
+	client_t	*cl;
+
+	// make sure server is running
+	if ( !com_sv_running->integer ) {
+		Com_Printf( "Server is not running.\n" );
+		return;
+	}
+
+	if ( Cmd_Argc() != 2 ) {
+		Com_Printf ("Usage: banClient <client number>\n");
+		return;
+	}
+
+	cl = SV_GetPlayerByNum();
+	if ( !cl ) {
+		return;
+	}
+	if( cl->netchan.remoteAddress.type == NA_LOOPBACK ) {
+//		SV_SendServerCommand(NULL, "print \"%s\"", "Cannot kick host player\n");
+		SV_SendServerCommand(NULL, "print \"%s\"", SV_GetStringEdString("MP_SVGAME","CANNOT_KICK_HOST"));
+		return;
+	}
+
+	// look up the authorize server's IP
+	if ( !svs.authorizeAddress.ip[0] && svs.authorizeAddress.type != NA_BAD ) {
+		Com_Printf( "Resolving %s\n", AUTHORIZE_SERVER_NAME );
+		if ( !NET_StringToAdr( AUTHORIZE_SERVER_NAME, &svs.authorizeAddress ) ) {
+			Com_Printf( "Couldn't resolve address\n" );
+			return;
+		}
+		svs.authorizeAddress.port = BigShort( PORT_AUTHORIZE );
+		Com_Printf( "%s resolved to %i.%i.%i.%i:%i\n", AUTHORIZE_SERVER_NAME,
+			svs.authorizeAddress.ip[0], svs.authorizeAddress.ip[1],
+			svs.authorizeAddress.ip[2], svs.authorizeAddress.ip[3],
+			BigShort( svs.authorizeAddress.port ) );
+	}
+
+	// otherwise send their ip to the authorize server
+	if ( svs.authorizeAddress.type != NA_BAD ) {
+		NET_OutOfBandPrint( NS_SERVER, svs.authorizeAddress,
+			"banUser %i.%i.%i.%i", cl->netchan.remoteAddress.ip[0], cl->netchan.remoteAddress.ip[1], 
+								   cl->netchan.remoteAddress.ip[2], cl->netchan.remoteAddress.ip[3] );
+		Com_Printf("%s was banned from coming back\n", cl->name);
+	}
+}
+
+#endif	// USE_CD_KEY
+
+/*
+==================
+SV_KickNum_f
+
+Kick a user off of the server  FIXME: move to game
+==================
+*/
+static void SV_KickNum_f( void ) {
+	client_t	*cl;
+
+	// make sure server is running
+	if ( !com_sv_running->integer ) {
+		Com_Printf( "Server is not running.\n" );
+		return;
+	}
+
+	if ( Cmd_Argc() != 2 ) {
+		Com_Printf ("Usage: kicknum <client number>\n");
+		return;
+	}
+
+	cl = SV_GetPlayerByNum();
+	if ( !cl ) {
+		return;
+	}
+	if( cl->netchan.remoteAddress.type == NA_LOOPBACK ) {
+//		SV_SendServerCommand(NULL, "print \"%s\"", "Cannot kick host player\n");
+		SV_SendServerCommand(NULL, "print \"%s\"", SV_GetStringEdString("MP_SVGAME","CANNOT_KICK_HOST"));
+		return;
+	}
+
+	SV_DropClient( cl, SV_GetStringEdString("MP_SVGAME","WAS_KICKED"));	// "was kicked" );
+	cl->lastPacketTime = svs.time;	// in case there is a funny zombie
+}
+
+/*
+================
+SV_Status_f
+================
+*/
+static void SV_Status_f( void ) 
+{
+	int				i;
+	client_t		*cl;
+	playerState_t	*ps;
+	const char		*s;
+	int				ping;
+	char			state[32];
+	qboolean		avoidTruncation = qfalse;
+
+	// make sure server is running
+	if ( !com_sv_running->integer ) 
+	{
+		Com_Printf( SE_GetString("STR_SERVER_SERVER_NOT_RUNNING") );
+		return;
+	}
+
+	if ( Cmd_Argc() > 1 )
+	{
+		if (!Q_stricmp("notrunc", Cmd_Argv(1)))
+		{
+			avoidTruncation = qtrue;
+		}
+	}
+
+	Com_Printf ("map: %s\n", sv_mapname->string );
+
+	Com_Printf ("num score ping name            lastmsg address               qport rate\n");
+	Com_Printf ("--- ----- ---- --------------- ------- --------------------- ----- -----\n");
+	for (i=0,cl=svs.clients ; i < sv_maxclients->integer ; i++,cl++)
+	{
+		if (!cl->state)
+		{
+			continue;
+		}
+
+		if (cl->state == CS_CONNECTED)
+		{
+			strcpy(state, "CNCT ");
+		}
+		else if (cl->state == CS_ZOMBIE)
+		{
+			strcpy(state, "ZMBI ");
+		}
+		else
+		{
+			ping = cl->ping < 9999 ? cl->ping : 9999;
+			sprintf(state, "%4i", ping);
+		}
+
+		ps = SV_GameClientNum( i );
+		s = NET_AdrToString( cl->netchan.remoteAddress );
+
+		if (!avoidTruncation)
+		{
+			Com_Printf ("%3i %5i %s %-15.15s %7i %21s %5i %5i\n", 
+				i, 
+				ps->persistant[PERS_SCORE],
+				state,
+				cl->name,
+				svs.time - cl->lastPacketTime,
+				s,
+				cl->netchan.qport,
+				cl->rate
+				);
+		}
+		else
+		{
+			Com_Printf ("%3i %5i %s %s %7i %21s %5i %5i\n", 
+				i, 
+				ps->persistant[PERS_SCORE],
+				state,
+				cl->name,
+				svs.time - cl->lastPacketTime,
+				s,
+				cl->netchan.qport,
+				cl->rate
+				);
+		}
+	}
+	Com_Printf ("\n");
+}
+
+/*
+==================
+SV_ConSay_f
+==================
+*/
+static void SV_ConSay_f(void) {
+	char	*p;
+	char	text[1024];
+
+	if( !com_dedicated->integer ) {
+		Com_Printf( "Server is not dedicated.\n" );
+		return;
+	}
+
+	// make sure server is running
+	if ( !com_sv_running->integer ) {
+		Com_Printf( "Server is not running.\n" );
+		return;
+	}
+
+	if ( Cmd_Argc () < 2 ) {
+		return;
+	}
+
+	strcpy (text, "Server: ");
+	p = Cmd_Args();
+
+	if ( *p == '"' ) {
+		p++;
+		p[strlen(p)-1] = 0;
+	}
+
+	strcat(text, p);
+
+	SV_SendServerCommand(NULL, "chat \"%s\n\"", text);
+}
+
+static const char *forceToggleNamePrints[] = 
+{
+	"HEAL",//FP_HEAL
+	"JUMP",//FP_LEVITATION
+	"SPEED",//FP_SPEED
+	"PUSH",//FP_PUSH
+	"PULL",//FP_PULL
+	"MINDTRICK",//FP_TELEPTAHY
+	"GRIP",//FP_GRIP
+	"LIGHTNING",//FP_LIGHTNING
+	"DARK RAGE",//FP_RAGE
+	"PROTECT",//FP_PROTECT
+	"ABSORB",//FP_ABSORB
+	"TEAM HEAL",//FP_TEAM_HEAL
+	"TEAM REPLENISH",//FP_TEAM_FORCE
+	"DRAIN",//FP_DRAIN
+	"SEEING",//FP_SEE
+	"SABER OFFENSE",//FP_SABER_OFFENSE
+	"SABER DEFENSE",//FP_SABER_DEFENSE
+	"SABER THROW",//FP_SABERTHROW
+	NULL
+};
+
+/*
+==================
+SV_ForceToggle_f
+==================
+*/
+void SV_ForceToggle_f(void)
+{
+	int i = 0;
+	int fpDisabled = Cvar_VariableValue("g_forcePowerDisable");
+	int targetPower = 0;
+	const char *powerDisabled = "Enabled";
+
+	if ( Cmd_Argc () < 2 )
+	{ //no argument supplied, spit out a list of force powers and their numbers
+		while (i < NUM_FORCE_POWERS)
+		{
+			if (fpDisabled & (1 << i))
+			{
+				powerDisabled = "Disabled";
+			}
+			else
+			{
+				powerDisabled = "Enabled";
+			}
+
+			Com_Printf(va("%i - %s - Status: %s\n", i, forceToggleNamePrints[i], powerDisabled));
+			i++;
+		}
+
+		Com_Printf("Example usage: forcetoggle 3\n(toggles PUSH)\n");
+		return;
+	}
+
+	targetPower = atoi(Cmd_Argv(1));
+
+	if (targetPower < 0 || targetPower >= NUM_FORCE_POWERS)
+	{
+		Com_Printf("Specified a power that does not exist.\nExample usage: forcetoggle 3\n(toggles PUSH)\n");
+		return;
+	}
+
+	if (fpDisabled & (1 << targetPower))
+	{
+		powerDisabled = "enabled";
+		fpDisabled &= ~(1 << targetPower);
+	}
+	else
+	{
+		powerDisabled = "disabled";
+		fpDisabled |= (1 << targetPower);
+	}
+
+	Cvar_Set("g_forcePowerDisable", va("%i", fpDisabled));
+
+	Com_Printf("%s has been %s.\n", forceToggleNamePrints[targetPower], powerDisabled);
+}
+
+/*
+==================
+SV_Heartbeat_f
+
+Also called by SV_DropClient, SV_DirectConnect, and SV_SpawnServer
+==================
+*/
+void SV_Heartbeat_f( void ) {
+	svs.nextHeartbeatTime = -9999999;
+}
+
+
+/*
+===========
+SV_Serverinfo_f
+
+Examine the serverinfo string
+===========
+*/
+static void SV_Serverinfo_f( void ) {
+	Com_Printf ("Server info settings:\n");
+	Info_Print ( Cvar_InfoString( CVAR_SERVERINFO ) );
+	if ( !com_sv_running->integer ) {
+		Com_Printf( "Server is not running.\n" );
+	}
+}
+
+
+/*
+===========
+SV_Systeminfo_f
+
+Examine or change the serverinfo string
+===========
+*/
+static void SV_Systeminfo_f( void ) {
+	Com_Printf ("System info settings:\n");
+	Info_Print ( Cvar_InfoString( CVAR_SYSTEMINFO ) );
+}
+
+
+/*
+===========
+SV_DumpUser_f
+
+Examine all a users info strings FIXME: move to game
+===========
+*/
+static void SV_DumpUser_f( void ) {
+	client_t	*cl;
+
+	// make sure server is running
+	if ( !com_sv_running->integer ) {
+		Com_Printf( "Server is not running.\n" );
+		return;
+	}
+
+	if ( Cmd_Argc() != 2 ) {
+		Com_Printf ("Usage: info <userid>\n");
+		return;
+	}
+
+	cl = SV_GetPlayerByName();
+	if ( !cl ) {
+		return;
+	}
+
+	Com_Printf( "userinfo\n" );
+	Com_Printf( "--------\n" );
+	Info_Print( cl->userinfo );
+}
+
+
+/*
+=================
+SV_KillServer
+=================
+*/
+static void SV_KillServer_f( void ) {
+	SV_Shutdown( "killserver" );
+}
+
+//===========================================================
+
+/*
+==================
+SV_AddOperatorCommands
+==================
+*/
+void SV_AddOperatorCommands( void ) {
+	static qboolean	initialized;
+
+	if ( initialized ) {
+		return;
+	}
+	initialized = qtrue;
+
+	Cmd_AddCommand ("heartbeat", SV_Heartbeat_f);
+	Cmd_AddCommand ("kick", SV_Kick_f);
+#ifdef USE_CD_KEY
+	Cmd_AddCommand ("banUser", SV_Ban_f);
+	Cmd_AddCommand ("banClient", SV_BanNum_f);
+#endif	// USE_CD_KEY
+
+	Cmd_AddCommand ("clientkick", SV_KickNum_f);
+	Cmd_AddCommand ("status", SV_Status_f);
+	Cmd_AddCommand ("serverinfo", SV_Serverinfo_f);
+	Cmd_AddCommand ("systeminfo", SV_Systeminfo_f);
+	Cmd_AddCommand ("dumpuser", SV_DumpUser_f);
+	Cmd_AddCommand ("map_restart", SV_MapRestart_f);
+	Cmd_AddCommand ("sectorlist", SV_SectorList_f);
+	Cmd_AddCommand ("map", SV_Map_f);
+#ifndef PRE_RELEASE_DEMO
+	Cmd_AddCommand ("devmap", SV_Map_f);
+	Cmd_AddCommand ("spmap", SV_Map_f);
+	Cmd_AddCommand ("spdevmap", SV_Map_f);
+//	Cmd_AddCommand ("devmapbsp", SV_Map_f);	// not used in MP codebase, no server BSP_cacheing
+	Cmd_AddCommand ("devmapmdl", SV_Map_f);
+	Cmd_AddCommand ("devmapall", SV_Map_f);
+#endif
+	Cmd_AddCommand ("killserver", SV_KillServer_f);
+//	if( com_dedicated->integer ) 
+	{
+		Cmd_AddCommand ("svsay", SV_ConSay_f);
+	}
+
+	Cmd_AddCommand ("forcetoggle", SV_ForceToggle_f);
+}
+
+/*
+==================
+SV_RemoveOperatorCommands
+==================
+*/
+void SV_RemoveOperatorCommands( void ) {
+#if 0
+	// removing these won't let the server start again
+	Cmd_RemoveCommand ("heartbeat");
+	Cmd_RemoveCommand ("kick");
+	Cmd_RemoveCommand ("banUser");
+	Cmd_RemoveCommand ("banClient");
+	Cmd_RemoveCommand ("status");
+	Cmd_RemoveCommand ("serverinfo");
+	Cmd_RemoveCommand ("systeminfo");
+	Cmd_RemoveCommand ("dumpuser");
+	Cmd_RemoveCommand ("map_restart");
+	Cmd_RemoveCommand ("sectorlist");
+	Cmd_RemoveCommand ("svsay");
+#endif
+}
+
diff --git a/codemp/server/sv_client.cpp b/codemp/server/sv_client.cpp
new file mode 100644
index 0000000..4f24b30
--- /dev/null
+++ b/codemp/server/sv_client.cpp
@@ -0,0 +1,1855 @@
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+// sv_client.c -- server code for dealing with clients
+
+#include "server.h"
+#include "../qcommon/stringed_ingame.h"
+#include "../RMG/RM_Headers.h"
+#include "../zlib32/zip.h"
+
+static void SV_CloseDownload( client_t *cl );
+
+/*
+=================
+SV_GetChallenge
+
+A "getchallenge" OOB command has been received
+Returns a challenge number that can be used
+in a subsequent connectResponse command.
+We do this to prevent denial of service attacks that
+flood the server with invalid connection IPs.  With a
+challenge, they must give a valid IP address.
+
+If we are authorizing, a challenge request will cause a packet
+to be sent to the authorize server.
+
+When an authorizeip is returned, a challenge response will be
+sent to that ip.
+=================
+*/
+void SV_GetChallenge( netadr_t from ) {
+	int		i;
+	int		oldest;
+	int		oldestTime;
+	challenge_t	*challenge;
+
+	// ignore if we are in single player
+	/*
+	if ( Cvar_VariableValue( "g_gametype" ) == GT_SINGLE_PLAYER || Cvar_VariableValue("ui_singlePlayerActive")) {
+		return;
+	}
+	*/
+	if (Cvar_VariableValue("ui_singlePlayerActive"))
+	{
+		return;
+	}
+
+	oldest = 0;
+	oldestTime = 0x7fffffff;
+
+	// see if we already have a challenge for this ip
+	challenge = &svs.challenges[0];
+	for (i = 0 ; i < MAX_CHALLENGES ; i++, challenge++) {
+		if ( !challenge->connected && NET_CompareAdr( from, challenge->adr ) ) {
+			break;
+		}
+		if ( challenge->time < oldestTime ) {
+			oldestTime = challenge->time;
+			oldest = i;
+		}
+	}
+
+	if (i == MAX_CHALLENGES) {
+		// this is the first time this client has asked for a challenge
+		challenge = &svs.challenges[oldest];
+
+		challenge->challenge = ( (rand() << 16) ^ rand() ) ^ svs.time;
+		challenge->adr = from;
+		challenge->firstTime = svs.time;
+		challenge->time = svs.time;
+		challenge->connected = qfalse;
+		i = oldest;
+	}
+
+	// if they are on a lan address, send the challengeResponse immediately
+	if ( Sys_IsLANAddress( from ) ) {
+		challenge->pingTime = svs.time;
+		NET_OutOfBandPrint( NS_SERVER, from, "challengeResponse %i", challenge->challenge );
+		return;
+	}
+
+#ifdef USE_CD_KEY
+	// look up the authorize server's IP
+	if ( !svs.authorizeAddress.ip[0] && svs.authorizeAddress.type != NA_BAD ) {
+		Com_Printf( "Resolving %s\n", AUTHORIZE_SERVER_NAME );
+		if ( !NET_StringToAdr( AUTHORIZE_SERVER_NAME, &svs.authorizeAddress ) ) {
+			Com_Printf( "Couldn't resolve address\n" );
+			return;
+		}
+		svs.authorizeAddress.port = BigShort( PORT_AUTHORIZE );
+		Com_Printf( "%s resolved to %i.%i.%i.%i:%i\n", AUTHORIZE_SERVER_NAME,
+			svs.authorizeAddress.ip[0], svs.authorizeAddress.ip[1],
+			svs.authorizeAddress.ip[2], svs.authorizeAddress.ip[3],
+			BigShort( svs.authorizeAddress.port ) );
+	}
+
+	// if they have been challenging for a long time and we
+	// haven't heard anything from the authoirze server, go ahead and
+	// let them in, assuming the id server is down
+	if ( svs.time - challenge->firstTime > AUTHORIZE_TIMEOUT ) {
+		Com_DPrintf( "authorize server timed out\n" );
+
+		challenge->pingTime = svs.time;
+		NET_OutOfBandPrint( NS_SERVER, challenge->adr, 
+			"challengeResponse %i", challenge->challenge );
+		return;
+	}
+
+	// otherwise send their ip to the authorize server
+	if ( svs.authorizeAddress.type != NA_BAD ) {
+		cvar_t	*fs;
+		char	game[1024];
+
+		game[0] = 0;
+		fs = Cvar_Get ("fs_game", "", CVAR_INIT|CVAR_SYSTEMINFO );
+		if (fs && fs->string[0] != 0) {
+			strcpy(game, fs->string);
+		}
+		Com_DPrintf( "sending getIpAuthorize for %s\n", NET_AdrToString( from ));
+		fs = Cvar_Get ("sv_allowAnonymous", "0", CVAR_SERVERINFO);
+
+		NET_OutOfBandPrint( NS_SERVER, svs.authorizeAddress,
+			"getIpAuthorize %i %i.%i.%i.%i %s %s",  svs.challenges[i].challenge,
+			from.ip[0], from.ip[1], from.ip[2], from.ip[3], game, fs->integer );
+	}
+#else
+	challenge->pingTime = svs.time;
+	NET_OutOfBandPrint( NS_SERVER, challenge->adr, "challengeResponse %i", challenge->challenge );
+#endif	// USE_CD_KEY
+}
+
+/*
+====================
+SV_AuthorizeIpPacket
+
+A packet has been returned from the authorize server.
+If we have a challenge adr for that ip, send the
+challengeResponse to it
+====================
+*/
+#ifndef _XBOX	// No authorization on Xbox
+void SV_AuthorizeIpPacket( netadr_t from ) {
+	int		challenge;
+	int		i;
+	char	*s;
+	char	*r;
+	char	ret[1024];
+
+	if ( !NET_CompareBaseAdr( from, svs.authorizeAddress ) ) {
+		Com_Printf( "SV_AuthorizeIpPacket: not from authorize server\n" );
+		return;
+	}
+
+	challenge = atoi( Cmd_Argv( 1 ) );
+
+	for (i = 0 ; i < MAX_CHALLENGES ; i++) {
+		if ( svs.challenges[i].challenge == challenge ) {
+			break;
+		}
+	}
+	if ( i == MAX_CHALLENGES ) {
+		Com_Printf( "SV_AuthorizeIpPacket: challenge not found\n" );
+		return;
+	}
+
+	// send a packet back to the original client
+	svs.challenges[i].pingTime = svs.time;
+	s = Cmd_Argv( 2 );
+	r = Cmd_Argv( 3 );			// reason
+
+	if ( !Q_stricmp( s, "demo" ) ) {
+		if ( Cvar_VariableValue( "fs_restrict" ) ) {
+			// a demo client connecting to a demo server
+			NET_OutOfBandPrint( NS_SERVER, svs.challenges[i].adr, 
+				"challengeResponse %i", svs.challenges[i].challenge );
+			return;
+		}
+		// they are a demo client trying to connect to a real server
+		NET_OutOfBandPrint( NS_SERVER, svs.challenges[i].adr, "print\nServer is not a demo server\n" );
+		// clear the challenge record so it won't timeout and let them through
+		Com_Memset( &svs.challenges[i], 0, sizeof( svs.challenges[i] ) );
+		return;
+	}
+	if ( !Q_stricmp( s, "accept" ) ) {
+		NET_OutOfBandPrint( NS_SERVER, svs.challenges[i].adr, 
+			"challengeResponse %i", svs.challenges[i].challenge );
+		return;
+	}
+	if ( !Q_stricmp( s, "unknown" ) ) {
+		if (!r) {
+			NET_OutOfBandPrint( NS_SERVER, svs.challenges[i].adr, "print\nAwaiting CD key authorization\n" );
+		} else {
+			sprintf(ret, "print\n%s\n", r);
+			NET_OutOfBandPrint( NS_SERVER, svs.challenges[i].adr, ret );
+		}
+		// clear the challenge record so it won't timeout and let them through
+		Com_Memset( &svs.challenges[i], 0, sizeof( svs.challenges[i] ) );
+		return;
+	}
+
+	// authorization failed
+	if (!r) {
+		NET_OutOfBandPrint( NS_SERVER, svs.challenges[i].adr, "print\nSomeone is using this CD Key\n" );
+	} else {
+		sprintf(ret, "print\n%s\n", r);
+		NET_OutOfBandPrint( NS_SERVER, svs.challenges[i].adr, ret );
+	}
+
+	// clear the challenge record so it won't timeout and let them through
+	Com_Memset( &svs.challenges[i], 0, sizeof( svs.challenges[i] ) );
+}
+#endif
+
+/*
+==================
+SV_DirectConnect
+
+A "connect" OOB command has been received
+==================
+*/
+void SV_DirectConnect( netadr_t from ) {
+	char		userinfo[MAX_INFO_STRING];
+	int			i;
+	client_t	*cl, *newcl;
+	MAC_STATIC client_t	temp;
+	sharedEntity_t *ent;
+	int			clientNum;
+	int			version;
+	int			qport;
+	int			challenge;
+	char		*password;
+	int			startIndex;
+	char		*denied;
+	int			count;
+	bool		reconnect = false;
+
+	Com_DPrintf ("SVC_DirectConnect ()\n");
+
+	Q_strncpyz( userinfo, Cmd_Argv(1), sizeof(userinfo) );
+
+	version = atoi( Info_ValueForKey( userinfo, "protocol" ) );
+	if ( version != PROTOCOL_VERSION ) {
+		NET_OutOfBandPrint( NS_SERVER, from, "print\nServer uses protocol version %i.\n", PROTOCOL_VERSION );
+		Com_DPrintf ("    rejected connect from version %i\n", version);
+		return;
+	}
+
+	challenge = atoi( Info_ValueForKey( userinfo, "challenge" ) );
+	qport = atoi( Info_ValueForKey( userinfo, "qport" ) );
+
+	// quick reject
+	for (i=0,cl=svs.clients ; i < sv_maxclients->integer ; i++,cl++) {
+
+/* This was preventing sv_reconnectlimit from working.  It seems like commenting this
+   out has solved the problem.  HOwever, if there is a future problem then it could
+   be this.
+   
+		if ( cl->state == CS_FREE ) {
+			continue;
+		}
+*/
+
+		if ( NET_CompareBaseAdr( from, cl->netchan.remoteAddress )
+			&& ( cl->netchan.qport == qport 
+			|| from.port == cl->netchan.remoteAddress.port ) ) {
+			if (( svs.time - cl->lastConnectTime) 
+				< (sv_reconnectlimit->integer * 1000)) {
+				NET_OutOfBandPrint( NS_SERVER, from, "print\nReconnect rejected : too soon\n" );
+				Com_DPrintf ("%s:reconnect rejected : too soon\n", NET_AdrToString (from));
+				return;
+			}
+			break;
+		}
+	}
+
+	// see if the challenge is valid (LAN clients don't need to challenge)
+	if ( !NET_IsLocalAddress (from) ) {
+		int		ping;
+
+		for (i=0 ; i<MAX_CHALLENGES ; i++) {
+			if (NET_CompareAdr(from, svs.challenges[i].adr)) {
+				if ( challenge == svs.challenges[i].challenge ) {
+					break;		// good
+				}
+			}
+		}
+		if (i == MAX_CHALLENGES) {
+			NET_OutOfBandPrint( NS_SERVER, from, "print\nNo or bad challenge for address.\n" );
+			return;
+		}
+		// force the IP key/value pair so the game can filter based on ip
+		Info_SetValueForKey( userinfo, "ip", NET_AdrToString( from ) );
+
+		ping = svs.time - svs.challenges[i].pingTime;
+		Com_Printf( SE_GetString("MP_SVGAME", "CLIENT_CONN_WITH_PING"), i, ping);//"Client %i connecting with %i challenge ping\n", i, ping );
+		svs.challenges[i].connected = qtrue;
+
+		// never reject a LAN client based on ping
+		if ( !Sys_IsLANAddress( from ) ) {
+			if ( sv_minPing->value && ping < sv_minPing->value ) {
+				// don't let them keep trying until they get a big delay
+				NET_OutOfBandPrint( NS_SERVER, from, va("print\n%s\n", SE_GetString("MP_SVGAME", "SERVER_FOR_HIGH_PING")));//Server is for high pings only\n" );
+				Com_DPrintf (SE_GetString("MP_SVGAME", "CLIENT_REJECTED_LOW_PING"), i);//"Client %i rejected on a too low ping\n", i);
+				// reset the address otherwise their ping will keep increasing
+				// with each connect message and they'd eventually be able to connect
+				svs.challenges[i].adr.port = 0;
+				return;
+			}
+			if ( sv_maxPing->value && ping > sv_maxPing->value ) {
+				NET_OutOfBandPrint( NS_SERVER, from, va("print\n%s\n", SE_GetString("MP_SVGAME", "SERVER_FOR_LOW_PING")));//Server is for low pings only\n" );
+				Com_DPrintf (SE_GetString("MP_SVGAME", "CLIENT_REJECTED_HIGH_PING"), i);//"Client %i rejected on a too high ping\n", i);
+				return;
+			}
+		}
+	} else {
+		// force the "ip" info key to "localhost"
+		Info_SetValueForKey( userinfo, "ip", "localhost" );
+	}
+
+	newcl = &temp;
+	Com_Memset (newcl, 0, sizeof(client_t));
+
+	// if there is already a slot for this ip, reuse it
+	for (i=0,cl=svs.clients ; i < sv_maxclients->integer ; i++,cl++) {
+		if ( cl->state == CS_FREE ) {
+			continue;
+		}
+		if ( NET_CompareBaseAdr( from, cl->netchan.remoteAddress )
+			&& ( cl->netchan.qport == qport 
+			|| from.port == cl->netchan.remoteAddress.port ) ) {
+			Com_Printf ("%s:reconnect\n", NET_AdrToString (from));
+			newcl = cl;
+			reconnect = true;
+			// VVFIXME - both SOF2 and Wolf remove this call, claiming it blows away the user's info
+			// disconnect the client from the game first so any flags the
+			// player might have are dropped
+			VM_Call( gvm, GAME_CLIENT_DISCONNECT, newcl - svs.clients );
+			//
+			goto gotnewcl;
+		}
+	}
+
+	// find a client slot
+	// if "sv_privateClients" is set > 0, then that number
+	// of client slots will be reserved for connections that
+	// have "password" set to the value of "sv_privatePassword"
+	// Info requests will report the maxclients as if the private
+	// slots didn't exist, to prevent people from trying to connect
+	// to a full server.
+	// This is to allow us to reserve a couple slots here on our
+	// servers so we can play without having to kick people.
+
+	// check for privateClient password
+	password = Info_ValueForKey( userinfo, "password" );
+#ifdef _XBOX	// We don't do private slots quite the same
+	startIndex = 0;
+#else
+	if ( !strcmp( password, sv_privatePassword->string ) ) {
+		startIndex = 0;
+	} else {
+		// skip past the reserved slots
+		startIndex = sv_privateClients->integer;
+	}
+#endif
+
+	newcl = NULL;
+	for ( i = startIndex; i < sv_maxclients->integer ; i++ ) {
+		cl = &svs.clients[i];
+		if (cl->state == CS_FREE) {
+			newcl = cl;
+			break;
+		}
+	}
+
+	if ( !newcl ) {
+		if ( NET_IsLocalAddress( from ) ) {
+			count = 0;
+			for ( i = startIndex; i < sv_maxclients->integer ; i++ ) {
+				cl = &svs.clients[i];
+				if (cl->netchan.remoteAddress.type == NA_BOT) {
+					count++;
+				}
+			}
+			// if they're all bots
+			if (count >= sv_maxclients->integer - startIndex) {
+				SV_DropClient(&svs.clients[sv_maxclients->integer - 1], "only bots on server");
+				newcl = &svs.clients[sv_maxclients->integer - 1];
+			}
+			else {
+				Com_Error( ERR_FATAL, "server is full on local connect\n" );
+				return;
+			}
+		}
+		else {
+			const char *SV_GetStringEdString(char *refSection, char *refName);
+			NET_OutOfBandPrint( NS_SERVER, from, va("print\n%s\n", SV_GetStringEdString("MP_SVGAME","SERVER_IS_FULL")));
+			Com_DPrintf ("Rejected a connection.\n");
+			return;
+		}
+	}
+
+	// we got a newcl, so reset the reliableSequence and reliableAcknowledge
+	cl->reliableAcknowledge = 0;
+	cl->reliableSequence = 0;
+
+gotnewcl:	
+
+#ifdef _XBOX
+	// OK. We used to manually search for a spot in the xbOnlineInfo player list now.
+	// But we MUST keep svs.clients in sync with the player list, so that clients
+	// can keep their cgs.clientinfo in sync as well. So...
+	int index = newcl - svs.clients;
+
+	// Sanity check
+	assert( index >= 0 && index < MAX_ONLINE_PLAYERS );
+
+	// Avoid a nasty bug situation: if the client is not logged on, they didn't send
+	// an XUID. Don't let live clients on syslink servers or vice-versa. Localhost
+	// doesn't need this check.
+	const char *sxuid = Info_ValueForKey( userinfo, "xuid" );
+	if ( !NET_IsLocalAddress(from) && ((logged_on && !*sxuid) || (!logged_on && *sxuid)) )
+	{
+		// We may not be able to reply to them - we might not have their address registered
+		NET_OutOfBandPrint( NS_SERVER, from, "print\nLive/SystemLink mismatch\n" );
+		return;
+	}
+
+	if ( reconnect )
+	{
+		// This is a reconnect message. They're going into the same slot as before.
+
+		// We don't need to grab much off the net here. Everything should still be valid.
+		// In particular, keep the old refIndex. If they sent an XUID, we'll update that,
+		// but if not we want to continue using their fake one from earlier.
+		if (logged_on)
+		{
+			StringToXUID(&xbOnlineInfo.xbPlayerList[index].xuid, sxuid);
+		}
+
+		// Ensure the client is active
+		xbOnlineInfo.xbPlayerList[index].isActive = true;
+	}
+	else
+	{
+		// OK. New client. First, sanity check that player and client lists are in sync:
+		assert( !xbOnlineInfo.xbPlayerList[index].isActive );
+
+		// Again, we don't have a full PlayerInfo like SOF2, but this is fine
+		XBPlayerInfo *pPlayer = &xbOnlineInfo.xbPlayerList[index];
+
+		// Zero it out to start with
+		memset(pPlayer, 0, sizeof(XBPlayerInfo));
+
+		// Copy XNADDR
+		StringToXnAddr(&pPlayer->xbAddr, Info_ValueForKey( userinfo, "xnaddr" ));
+
+		// Copy XUID
+		if(logged_on)
+		{
+			StringToXUID(&pPlayer->xuid, sxuid);
+		}
+		else
+		{
+			// Users have no XUID if not logged on. We make one up.
+			pPlayer->xuid.qwUserID = svs.clientRefNum;
+		}
+
+		pPlayer->refIndex = svs.clientRefNum++;
+		pPlayer->isActive = true;
+	}
+
+	// One more thing we need - the client will send an xbps "1" if they can
+	// use a private slot (XBox Private Slot). Just check for its existence...
+	bool usePrivateSlot = (strcmp( Info_ValueForKey( userinfo, "xbps" ), "1" ) == 0);
+
+	// Set our refIndex for later. We also remember if they were a private slot
+	// candidate when they joined, so we can free up the right type of slot when
+	// they leave later.
+	temp.refIndex = xbOnlineInfo.xbPlayerList[index].refIndex;
+	temp.usePrivateSlot = usePrivateSlot;
+
+	// Remove any mute flags as they are local to the client.
+	xbOnlineInfo.xbPlayerList[index].flags &= ~MUTED_PLAYER;
+	xbOnlineInfo.xbPlayerList[index].flags &= ~REMOTE_MUTED;
+
+	// Disable new player's voice until they send their VOICESTATE
+	xbOnlineInfo.xbPlayerList[index].flags &= ~VOICE_CAN_RECV;
+	xbOnlineInfo.xbPlayerList[index].flags &= ~VOICE_CAN_SEND;
+
+	// Now send the new client's info to all other relevant clients
+	for (int j = 0; j < sv_maxclients->integer; j++) {
+		if ( svs.clients[j].state < CS_PRIMED ) {
+			continue;
+		}
+		if (svs.clients[j].netchan.remoteAddress.type == NA_BOT) {
+			continue;
+		}
+		SV_SendClientNewPeer( &svs.clients[j], &xbOnlineInfo.xbPlayerList[index] );
+	}
+#endif
+
+	// build a new connection
+	// accept the new client
+	// this is the only place a client_t is ever initialized
+	*newcl = temp;
+	clientNum = newcl - svs.clients;
+	ent = SV_GentityNum( clientNum );
+	newcl->gentity = ent;
+
+	// save the challenge
+	newcl->challenge = challenge;
+
+	// save the address
+	Netchan_Setup (NS_SERVER, &newcl->netchan , from, qport);
+
+	// save the userinfo
+	Q_strncpyz( newcl->userinfo, userinfo, sizeof(newcl->userinfo) );
+
+	// get the game a chance to reject this connection or modify the userinfo
+	denied = (char *)VM_Call( gvm, GAME_CLIENT_CONNECT, clientNum, qtrue, qfalse ); // firstTime = qtrue
+	if ( denied ) {
+		// we can't just use VM_ArgPtr, because that is only valid inside a VM_Call
+		denied = (char *)VM_ExplicitArgPtr( gvm, (int)denied );
+
+		NET_OutOfBandPrint( NS_SERVER, from, "print\n%s\n", denied );
+		Com_DPrintf ("Game rejected a connection: %s.\n", denied);
+		return;
+	}
+
+	SV_UserinfoChanged( newcl );
+
+	// update the advertised session
+    //
+#ifdef _XBOX
+	if (!reconnect)
+	    XBL_MM_AddPlayer( usePrivateSlot );
+#endif
+
+	// send the connect packet to the client
+	NET_OutOfBandPrint( NS_SERVER, from, "connectResponse" );
+
+	Com_DPrintf( "Going from CS_FREE to CS_CONNECTED for %s\n", newcl->name );
+
+	newcl->state = CS_CONNECTED;
+	newcl->nextSnapshotTime = svs.time;
+	newcl->lastPacketTime = svs.time;
+	newcl->lastConnectTime = svs.time;
+	
+	// when we receive the first packet from the client, we will
+	// notice that it is from a different serverid and that the
+	// gamestate message was not just sent, forcing a retransmit
+	newcl->gamestateMessageNum = -1;
+
+	newcl->lastUserInfoChange = 0; //reset the delay
+	newcl->lastUserInfoCount = 0; //reset the count
+
+	// if this was the first client on the server, or the last client
+	// the server can hold, send a heartbeat to the master.
+	count = 0;
+	for (i=0,cl=svs.clients ; i < sv_maxclients->integer ; i++,cl++) {
+		if ( svs.clients[i].state >= CS_CONNECTED ) {
+			count++;
+		}
+	}
+	if ( count == 1 || count == sv_maxclients->integer ) {
+		SV_Heartbeat_f();
+	}
+}
+
+
+/*
+=====================
+SV_DropClient
+
+Called when the player is totally leaving the server, either willingly
+or unwillingly.  This is NOT called if the entire server is quiting
+or crashing -- SV_FinalMessage() will handle that
+=====================
+*/
+void SV_DropClient( client_t *drop, const char *reason ) {
+	int		i;
+	challenge_t	*challenge;
+
+	if ( drop->state == CS_ZOMBIE ) {
+		return;		// already dropped
+	}
+
+	if ( !drop->gentity || !(drop->gentity->r.svFlags & SVF_BOT) ) {
+		// see if we already have a challenge for this ip
+		challenge = &svs.challenges[0];
+
+		for (i = 0 ; i < MAX_CHALLENGES ; i++, challenge++) {
+			if ( NET_CompareAdr( drop->netchan.remoteAddress, challenge->adr ) ) {
+				challenge->connected = qfalse;
+				break;
+			}
+		}
+	}
+
+#ifdef _XBOX
+	// Tells all clients to remove the dropped player from their list, if not a bot
+	if ( drop->netchan.remoteAddress.type != NA_BOT )
+	{
+		int index = drop - svs.clients;
+		for (int j = 0; j < sv_maxclients->integer ; j++) {
+			if ( svs.clients[j].state < CS_PRIMED ) {
+				continue;
+			}
+			if ( svs.clients[j].netchan.remoteAddress.type == NA_BOT ) {
+				continue;
+			}
+			SV_SendClientRemovePeer(&svs.clients[j], index);
+		}
+
+		// update the advertised session
+		XBL_MM_RemovePlayer( drop->usePrivateSlot );
+	}
+#endif
+
+	// Kill any download
+#ifndef _XBOX	// No downloads on Xbox
+	SV_CloseDownload( drop );
+#endif
+
+	// tell everyone why they got dropped
+	SV_SendServerCommand( NULL, "print \"%s" S_COLOR_WHITE " %s\n\"", drop->name, reason );
+
+	Com_DPrintf( "Going to CS_ZOMBIE for %s\n", drop->name );
+	drop->state = CS_ZOMBIE;		// become free in a few seconds
+
+#ifndef _XBOX	// No downloads on Xbox
+	if (drop->download)	{
+		FS_FCloseFile( drop->download );
+		drop->download = 0;
+	}
+#endif
+
+	// call the prog function for removing a client
+	// this will remove the body, among other things
+	VM_Call( gvm, GAME_CLIENT_DISCONNECT, drop - svs.clients );
+
+	// add the disconnect command
+	SV_SendServerCommand( drop, va("disconnect \"%s\"", reason ) );
+
+	if ( drop->netchan.remoteAddress.type == NA_BOT ) {
+		SV_BotFreeClient( drop - svs.clients );
+	}
+
+	// nuke user info
+	SV_SetUserinfo( drop - svs.clients, "" );
+
+	// if this was the last client on the server, send a heartbeat
+	// to the master so it is known the server is empty
+	// send a heartbeat now so the master will get up to date info
+	// if there is already a slot for this ip, reuse it
+#ifndef _XBOX	// No master on Xbox
+	for (i=0 ; i < sv_maxclients->integer ; i++ ) {
+		if ( svs.clients[i].state >= CS_CONNECTED ) {
+			break;
+		}
+	}
+	if ( i == sv_maxclients->integer ) {
+		SV_Heartbeat_f();
+	}
+#endif
+}
+
+void SV_WriteRMGAutomapSymbols ( msg_t* msg )
+{
+	int count = TheRandomMissionManager->GetAutomapSymbolCount ( );
+	int i;
+
+	MSG_WriteShort ( msg, count );
+
+	for ( i = 0; i < count; i ++ )
+	{
+		rmAutomapSymbol_t* symbol = TheRandomMissionManager->GetAutomapSymbol ( i );
+
+		MSG_WriteByte ( msg, symbol->mType );
+		MSG_WriteByte ( msg, symbol->mSide );
+		MSG_WriteLong ( msg, (long)symbol->mOrigin[0] );
+		MSG_WriteLong ( msg, (long)symbol->mOrigin[1] );
+	}
+}
+
+/*
+================
+SV_SendClientGameState
+
+Sends the first message from the server to a connected client.
+This will be sent on the initial connection and upon each new map load.
+
+It will be resent if the client acknowledges a later message but has
+the wrong gamestate.
+================
+*/
+void SV_SendClientGameState( client_t *client ) {
+	int			start;
+	entityState_t	*base, nullstate;
+	msg_t		msg;
+	byte		msgBuffer[MAX_MSGLEN];
+
+	// MW - my attempt to fix illegible server message errors caused by 
+	// packet fragmentation of initial snapshot.
+	while(client->state&&client->netchan.unsentFragments)
+	{
+		// send additional message fragments if the last message
+		// was too large to send at once
+	
+		Com_Printf ("[ISM]SV_SendClientGameState() [2] for %s, writing out old fragments\n", client->name);
+		SV_Netchan_TransmitNextFragment(&client->netchan);
+	}
+
+	Com_DPrintf ("SV_SendClientGameState() for %s\n", client->name);
+	Com_DPrintf( "Going from CS_CONNECTED to CS_PRIMED for %s\n", client->name );
+	client->state = CS_PRIMED;
+	client->pureAuthentic = 0;
+
+	// when we receive the first packet from the client, we will
+	// notice that it is from a different serverid and that the
+	// gamestate message was not just sent, forcing a retransmit
+	client->gamestateMessageNum = client->netchan.outgoingSequence;
+
+	MSG_Init( &msg, msgBuffer, sizeof( msgBuffer ) );
+
+	// NOTE, MRE: all server->client messages now acknowledge
+	// let the client know which reliable clientCommands we have received
+	MSG_WriteLong( &msg, client->lastClientCommand );
+
+	// send any server commands waiting to be sent first.
+	// we have to do this cause we send the client->reliableSequence
+	// with a gamestate and it sets the clc.serverCommandSequence at
+	// the client side
+	SV_UpdateServerCommandsToClient( client, &msg );
+
+	// send the gamestate
+	MSG_WriteByte( &msg, svc_gamestate );
+	MSG_WriteLong( &msg, client->reliableSequence );
+
+	// write the configstrings
+	for ( start = 0 ; start < MAX_CONFIGSTRINGS ; start++ ) {
+		if (sv.configstrings[start][0]) {
+			MSG_WriteByte( &msg, svc_configstring );
+			MSG_WriteShort( &msg, start );
+			MSG_WriteBigString( &msg, sv.configstrings[start] );
+		}
+	}
+
+	// write the baselines
+	Com_Memset( &nullstate, 0, sizeof( nullstate ) );
+	for ( start = 0 ; start < MAX_GENTITIES; start++ ) {
+		base = &sv.svEntities[start].baseline;
+		if ( !base->number ) {
+			continue;
+		}
+		MSG_WriteByte( &msg, svc_baseline );
+		MSG_WriteDeltaEntity( &msg, &nullstate, base, qtrue );
+	}
+
+	MSG_WriteByte( &msg, svc_EOF );
+
+	MSG_WriteLong( &msg, client - svs.clients);
+
+	// write the checksum feed
+	MSG_WriteLong( &msg, sv.checksumFeed);
+
+	//rwwRMG - send info for the terrain
+	if ( TheRandomMissionManager )
+	{
+		z_stream zdata;
+
+		// Send the height map
+		memset(&zdata, 0, sizeof(z_stream));
+		deflateInit ( &zdata, Z_MAX_COMPRESSION );
+
+		unsigned char heightmap[15000];
+		zdata.next_out = (unsigned char*)heightmap;
+		zdata.avail_out = 15000;
+		zdata.next_in = TheRandomMissionManager->GetLandScape()->GetHeightMap();
+		zdata.avail_in = TheRandomMissionManager->GetLandScape()->GetRealArea();
+		deflate(&zdata, Z_SYNC_FLUSH);
+
+		MSG_WriteShort ( &msg, (unsigned short)zdata.total_out );
+		MSG_WriteBits ( &msg, 1, 1 );
+		MSG_WriteData ( &msg, heightmap, zdata.total_out);
+
+		deflateEnd(&zdata);
+
+		// Send the flatten map
+		memset(&zdata, 0, sizeof(z_stream));
+		deflateInit ( &zdata, Z_MAX_COMPRESSION );
+
+		zdata.next_out = (unsigned char*)heightmap;
+		zdata.avail_out = 15000;
+		zdata.next_in = TheRandomMissionManager->GetLandScape()->GetFlattenMap();
+		zdata.avail_in = TheRandomMissionManager->GetLandScape()->GetRealArea();
+		deflate(&zdata, Z_SYNC_FLUSH);
+
+		MSG_WriteShort ( &msg, (unsigned short)zdata.total_out );
+		MSG_WriteBits ( &msg, 1, 1 );
+		MSG_WriteData ( &msg, heightmap, zdata.total_out);
+
+		deflateEnd(&zdata);
+
+		// Seed is needed for misc ents and noise
+		MSG_WriteLong ( &msg, TheRandomMissionManager->GetLandScape()->get_rand_seed ( ) );
+
+		SV_WriteRMGAutomapSymbols ( &msg );
+	}
+	else
+	{
+		MSG_WriteShort ( &msg, 0 );
+	}
+
+	// deliver this to the client
+	SV_SendMessageToClient( &msg, client );
+}
+
+
+void SV_SendClientMapChange( client_t *client ) 
+{
+	msg_t		msg;
+	byte		msgBuffer[MAX_MSGLEN];
+
+	MSG_Init( &msg, msgBuffer, sizeof( msgBuffer ) );
+
+	// NOTE, MRE: all server->client messages now acknowledge
+	// let the client know which reliable clientCommands we have received
+	MSG_WriteLong( &msg, client->lastClientCommand );
+
+	// send any server commands waiting to be sent first.
+	// we have to do this cause we send the client->reliableSequence
+	// with a gamestate and it sets the clc.serverCommandSequence at
+	// the client side
+	SV_UpdateServerCommandsToClient( client, &msg );
+
+	// send the gamestate
+	MSG_WriteByte( &msg, svc_mapchange );
+
+	// deliver this to the client
+	SV_SendMessageToClient( &msg, client );
+}
+
+#ifdef _XBOX	// Utilities to notify clients of various XBL state changes
+/*
+	SV_SendClientNewPeer - tell a client to add a player to his xbOnlineInfo.xbPlayerList
+*/
+void SV_SendClientNewPeer(client_t *client, XBPlayerInfo* info) 
+{
+	msg_t		msg;
+	byte		msgBuffer[MAX_MSGLEN];
+
+	MSG_Init( &msg, msgBuffer, sizeof( msgBuffer ) );
+
+	// NOTE, MRE: all server->client messages now acknowledge
+	// let the client know which reliable clientCommands we have received
+	MSG_WriteLong( &msg, client->lastClientCommand );
+
+	// send any server commands waiting to be sent first.
+	// we have to do this cause we send the client->reliableSequence
+	// with a gamestate and it sets the clc.serverCommandSequence at
+	// the client side
+	SV_UpdateServerCommandsToClient( client, &msg );
+
+	// send the command
+	MSG_WriteByte( &msg, svc_newpeer );
+
+	// We now write the specific player number as well, so the clients know where
+	// to put this info. (That keeps cgs.clientinfo in sync with xbPlayerList)
+	MSG_WriteLong( &msg, info - xbOnlineInfo.xbPlayerList );
+	MSG_WriteData(&msg, info, sizeof(XBPlayerInfo));
+
+	// deliver this to the client
+	SV_SendMessageToClient( &msg, client );
+}
+
+/*
+	SV_SendClientRemovePeer - tell a client to remove a player from his xbOnlineInfo.xbPlayerList
+*/
+void SV_SendClientRemovePeer(client_t *client, int index) 
+{
+	msg_t		msg;
+	byte		msgBuffer[MAX_MSGLEN];
+
+	MSG_Init( &msg, msgBuffer, sizeof( msgBuffer ) );
+
+	// NOTE, MRE: all server->client messages now acknowledge
+	// let the client know which reliable clientCommands we have received
+	MSG_WriteLong( &msg, client->lastClientCommand );
+
+	// send any server commands waiting to be sent first.
+	// we have to do this cause we send the client->reliableSequence
+	// with a gamestate and it sets the clc.serverCommandSequence at
+	// the client side
+	SV_UpdateServerCommandsToClient( client, &msg );
+
+	// send the command
+	MSG_WriteByte( &msg, svc_removepeer );
+
+	// All clients have IDENTICAL ordering within xbPlayerList, so just
+	// send the index (rather than the XUID, like we did before).
+	MSG_WriteLong( &msg, index );
+
+	// deliver this to the client
+	SV_SendMessageToClient( &msg, client );
+}
+
+/*
+	SV_SendClientXbInfo - Sends the server's xbOnlineInfo to a given client
+*/
+void SV_SendClientXbInfo(client_t *client) 
+{
+	msg_t		msg;
+	byte		msgBuffer[MAX_MSGLEN];
+
+	MSG_Init( &msg, msgBuffer, sizeof( msgBuffer ) );
+
+	// NOTE, MRE: all server->client messages now acknowledge
+	// let the client know which reliable clientCommands we have received
+	MSG_WriteLong( &msg, client->lastClientCommand );
+
+	// send any server commands waiting to be sent first.
+	// we have to do this cause we send the client->reliableSequence
+	// with a gamestate and it sets the clc.serverCommandSequence at
+	// the client side
+	SV_UpdateServerCommandsToClient( client, &msg );
+
+	// send the command
+	MSG_WriteByte( &msg, svc_xbInfo );
+
+	MSG_WriteData(&msg, &(xbOnlineInfo), sizeof(XBOnlineInfo));
+
+	// deliver this to the client
+	SV_SendMessageToClient( &msg, client );
+}
+#endif	// _XBOX
+
+/*
+==================
+SV_ClientEnterWorld
+==================
+*/
+void SV_ClientEnterWorld( client_t *client, usercmd_t *cmd ) {
+	int		clientNum;
+	sharedEntity_t *ent;
+
+	Com_DPrintf( "Going from CS_PRIMED to CS_ACTIVE for %s\n", client->name );
+	client->state = CS_ACTIVE;
+
+#ifdef _XBOX
+	//update XbOnlineInfo with client
+	SV_SendClientXbInfo(client);
+#endif
+
+	// set up the entity for the client
+	clientNum = client - svs.clients;
+	ent = SV_GentityNum( clientNum );
+	ent->s.number = clientNum;
+	client->gentity = ent;
+
+	client->lastUserInfoChange = 0; //reset the delay
+	client->lastUserInfoCount = 0; //reset the count
+
+	client->deltaMessage = -1;
+	client->nextSnapshotTime = svs.time;	// generate a snapshot immediately
+	client->lastUsercmd = *cmd;
+
+	// call the game begin function
+	VM_Call( gvm, GAME_CLIENT_BEGIN, client - svs.clients );
+}
+
+/*
+============================================================
+
+CLIENT COMMAND EXECUTION
+
+============================================================
+*/
+
+/*
+==================
+SV_CloseDownload
+
+clear/free any download vars
+==================
+*/
+#ifndef _XBOX	// No downloads on Xbox
+static void SV_CloseDownload( client_t *cl ) {
+	int i;
+
+	// EOF
+	if (cl->download) {
+		FS_FCloseFile( cl->download );
+	}
+	cl->download = 0;
+	*cl->downloadName = 0;
+
+	// Free the temporary buffer space
+	for (i = 0; i < MAX_DOWNLOAD_WINDOW; i++) {
+		if (cl->downloadBlocks[i]) {
+			Z_Free( cl->downloadBlocks[i] );
+			cl->downloadBlocks[i] = NULL;
+		}
+	}
+
+}
+
+/*
+==================
+SV_StopDownload_f
+
+Abort a download if in progress
+==================
+*/
+void SV_StopDownload_f( client_t *cl ) {
+	if (*cl->downloadName)
+		Com_DPrintf( "clientDownload: %d : file \"%s\" aborted\n", cl - svs.clients, cl->downloadName );
+
+	SV_CloseDownload( cl );
+}
+
+/*
+==================
+SV_DoneDownload_f
+
+Downloads are finished
+==================
+*/
+void SV_DoneDownload_f( client_t *cl ) {
+	Com_DPrintf( "clientDownload: %s Done\n", cl->name);
+	// resend the game state to update any clients that entered during the download
+	SV_SendClientGameState(cl);
+}
+
+/*
+==================
+SV_NextDownload_f
+
+The argument will be the last acknowledged block from the client, it should be
+the same as cl->downloadClientBlock
+==================
+*/
+void SV_NextDownload_f( client_t *cl )
+{
+	int block = atoi( Cmd_Argv(1) );
+
+	if (block == cl->downloadClientBlock) {
+		Com_DPrintf( "clientDownload: %d : client acknowledge of block %d\n", cl - svs.clients, block );
+
+		// Find out if we are done.  A zero-length block indicates EOF
+		if (cl->downloadBlockSize[cl->downloadClientBlock % MAX_DOWNLOAD_WINDOW] == 0) {
+			Com_Printf( "clientDownload: %d : file \"%s\" completed\n", cl - svs.clients, cl->downloadName );
+			SV_CloseDownload( cl );
+			return;
+		}
+
+		cl->downloadSendTime = svs.time;
+		cl->downloadClientBlock++;
+		return;
+	}
+	// We aren't getting an acknowledge for the correct block, drop the client
+	// FIXME: this is bad... the client will never parse the disconnect message
+	//			because the cgame isn't loaded yet
+	SV_DropClient( cl, "broken download" );
+}
+
+/*
+==================
+SV_BeginDownload_f
+==================
+*/
+void SV_BeginDownload_f( client_t *cl ) {
+
+	// Kill any existing download
+	SV_CloseDownload( cl );
+
+	// cl->downloadName is non-zero now, SV_WriteDownloadToClient will see this and open
+	// the file itself
+	Q_strncpyz( cl->downloadName, Cmd_Argv(1), sizeof(cl->downloadName) );
+}
+
+/*
+==================
+SV_WriteDownloadToClient
+
+Check to see if the client wants a file, open it if needed and start pumping the client
+Fill up msg with data 
+==================
+*/
+void SV_WriteDownloadToClient( client_t *cl , msg_t *msg )
+{
+	int curindex;
+	int rate;
+	int blockspersnap;
+	int idPack, missionPack;
+	char errorMessage[1024];
+
+	if (!*cl->downloadName)
+		return;	// Nothing being downloaded
+
+	if (!cl->download) {
+		// We open the file here
+
+		Com_Printf( "clientDownload: %d : begining \"%s\"\n", cl - svs.clients, cl->downloadName );
+
+		missionPack = FS_idPak(cl->downloadName, "missionpack");
+		idPack = missionPack || FS_idPak(cl->downloadName, "base");
+
+		if ( !sv_allowDownload->integer || idPack ||
+			( cl->downloadSize = FS_SV_FOpenFileRead( cl->downloadName, &cl->download ) ) <= 0 ) {
+			// cannot auto-download file
+			if (idPack) {
+				Com_Printf("clientDownload: %d : \"%s\" cannot download id pk3 files\n", cl - svs.clients, cl->downloadName);
+				if (missionPack) {
+					Com_sprintf(errorMessage, sizeof(errorMessage), "Cannot autodownload Team Arena file \"%s\"\n"
+									"The Team Arena mission pack can be found in your local game store.", cl->downloadName);
+				}
+				else {
+					Com_sprintf(errorMessage, sizeof(errorMessage), "Cannot autodownload id pk3 file \"%s\"", cl->downloadName);
+				}
+			} else if ( !sv_allowDownload->integer ) {
+				Com_Printf("clientDownload: %d : \"%s\" download disabled", cl - svs.clients, cl->downloadName);
+				if (sv_pure->integer) {
+					Com_sprintf(errorMessage, sizeof(errorMessage), "Could not download \"%s\" because autodownloading is disabled on the server.\n\n"
+										"You will need to get this file elsewhere before you "
+										"can connect to this pure server.\n", cl->downloadName);
+				} else {
+					Com_sprintf(errorMessage, sizeof(errorMessage), "Could not download \"%s\" because autodownloading is disabled on the server.\n\n"
+										"Set autodownload to No in your settings and you might be "
+										"able to connect if you do have the file.\n", cl->downloadName);
+				}
+			} else {
+				Com_Printf("clientDownload: %d : \"%s\" file not found on server\n", cl - svs.clients, cl->downloadName);
+				Com_sprintf(errorMessage, sizeof(errorMessage), "File \"%s\" not found on server for autodownloading.\n", cl->downloadName);
+			}
+			MSG_WriteByte( msg, svc_download );
+			MSG_WriteShort( msg, 0 ); // client is expecting block zero
+			MSG_WriteLong( msg, -1 ); // illegal file size
+			MSG_WriteString( msg, errorMessage );
+
+			*cl->downloadName = 0;
+			return;
+		}
+ 
+		// Init
+		cl->downloadCurrentBlock = cl->downloadClientBlock = cl->downloadXmitBlock = 0;
+		cl->downloadCount = 0;
+		cl->downloadEOF = qfalse;
+	}
+
+	// Perform any reads that we need to
+	while (cl->downloadCurrentBlock - cl->downloadClientBlock < MAX_DOWNLOAD_WINDOW &&
+		cl->downloadSize != cl->downloadCount) {
+
+		curindex = (cl->downloadCurrentBlock % MAX_DOWNLOAD_WINDOW);
+
+		if (!cl->downloadBlocks[curindex])
+			cl->downloadBlocks[curindex] = (unsigned char *)Z_Malloc( MAX_DOWNLOAD_BLKSIZE, TAG_DOWNLOAD, qtrue );
+
+		cl->downloadBlockSize[curindex] = FS_Read( cl->downloadBlocks[curindex], MAX_DOWNLOAD_BLKSIZE, cl->download );
+
+		if (cl->downloadBlockSize[curindex] < 0) {
+			// EOF right now
+			cl->downloadCount = cl->downloadSize;
+			break;
+		}
+
+		cl->downloadCount += cl->downloadBlockSize[curindex];
+
+		// Load in next block
+		cl->downloadCurrentBlock++;
+	}
+
+	// Check to see if we have eof condition and add the EOF block
+	if (cl->downloadCount == cl->downloadSize &&
+		!cl->downloadEOF &&
+		cl->downloadCurrentBlock - cl->downloadClientBlock < MAX_DOWNLOAD_WINDOW) {
+
+		cl->downloadBlockSize[cl->downloadCurrentBlock % MAX_DOWNLOAD_WINDOW] = 0;
+		cl->downloadCurrentBlock++;
+
+		cl->downloadEOF = qtrue;  // We have added the EOF block
+	}
+
+	// Loop up to window size times based on how many blocks we can fit in the
+	// client snapMsec and rate
+
+	// based on the rate, how many bytes can we fit in the snapMsec time of the client
+	// normal rate / snapshotMsec calculation
+	rate = cl->rate;
+	if ( sv_maxRate->integer ) {
+		if ( sv_maxRate->integer < 1000 ) {
+			Cvar_Set( "sv_MaxRate", "1000" );
+		}
+		if ( sv_maxRate->integer < rate ) {
+			rate = sv_maxRate->integer;
+		}
+	}
+
+	if (!rate) {
+		blockspersnap = 1;
+	} else {
+		blockspersnap = ( (rate * cl->snapshotMsec) / 1000 + MAX_DOWNLOAD_BLKSIZE ) /
+			MAX_DOWNLOAD_BLKSIZE;
+	}
+
+	if (blockspersnap < 0)
+		blockspersnap = 1;
+
+	while (blockspersnap--) {
+
+		// Write out the next section of the file, if we have already reached our window,
+		// automatically start retransmitting
+
+		if (cl->downloadClientBlock == cl->downloadCurrentBlock)
+			return; // Nothing to transmit
+
+		if (cl->downloadXmitBlock == cl->downloadCurrentBlock) {
+			// We have transmitted the complete window, should we start resending?
+
+			//FIXME:  This uses a hardcoded one second timeout for lost blocks
+			//the timeout should be based on client rate somehow
+			if (svs.time - cl->downloadSendTime > 1000)
+				cl->downloadXmitBlock = cl->downloadClientBlock;
+			else
+				return;
+		}
+
+		// Send current block
+		curindex = (cl->downloadXmitBlock % MAX_DOWNLOAD_WINDOW);
+
+		MSG_WriteByte( msg, svc_download );
+		MSG_WriteShort( msg, cl->downloadXmitBlock );
+
+		// block zero is special, contains file size
+		if ( cl->downloadXmitBlock == 0 )
+			MSG_WriteLong( msg, cl->downloadSize );
+ 
+		MSG_WriteShort( msg, cl->downloadBlockSize[curindex] );
+
+		// Write the block
+		if ( cl->downloadBlockSize[curindex] ) {
+			MSG_WriteData( msg, cl->downloadBlocks[curindex], cl->downloadBlockSize[curindex] );
+		}
+
+		Com_DPrintf( "clientDownload: %d : writing block %d\n", cl - svs.clients, cl->downloadXmitBlock );
+
+		// Move on to the next block
+		// It will get sent with next snap shot.  The rate will keep us in line.
+		cl->downloadXmitBlock++;
+
+		cl->downloadSendTime = svs.time;
+	}
+}
+#endif	// Xbox	- No downloads on Xbox
+
+/*
+=================
+SV_Disconnect_f
+
+The client is going to disconnect, so remove the connection immediately  FIXME: move to game?
+=================
+*/
+const char *SV_GetStringEdString(char *refSection, char *refName);
+static void SV_Disconnect_f( client_t *cl ) {
+//	SV_DropClient( cl, "disconnected" );
+	SV_DropClient( cl, SV_GetStringEdString("MP_SVGAME","DISCONNECTED") );
+}
+
+/*
+=================
+SV_VerifyPaks_f
+
+If we are pure, disconnect the client if they do no meet the following conditions:
+
+1. the first two checksums match our view of cgame and ui
+2. there are no any additional checksums that we do not have
+
+This routine would be a bit simpler with a goto but i abstained
+
+=================
+*/
+static void SV_VerifyPaks_f( client_t *cl ) {
+#ifndef _XBOX
+	int nChkSum1, nChkSum2, nClientPaks, nServerPaks, i, j, nCurArg;
+	int nClientChkSum[1024];
+	int nServerChkSum[1024];
+	const char *pPaks, *pArg;
+	qboolean bGood = qtrue;
+
+	// if we are pure, we "expect" the client to load certain things from 
+	// certain pk3 files, namely we want the client to have loaded the
+	// ui and cgame that we think should be loaded based on the pure setting
+	//
+	if ( sv_pure->integer != 0 ) {
+
+		bGood = qtrue;
+		nChkSum1 = nChkSum2 = 0;
+		// we run the game, so determine which cgame and ui the client "should" be running
+		//dlls are valid too now -rww
+		if (Cvar_VariableValue( "vm_cgame" ))
+		{
+			bGood = (qboolean)(FS_FileIsInPAK("vm/cgame.qvm", &nChkSum1) == 1);
+		}
+		else
+		{
+			bGood = (qboolean)(FS_FileIsInPAK("cgamex86.dll", &nChkSum1) == 1);
+		}
+
+		if (bGood)
+		{
+			if (Cvar_VariableValue( "vm_ui" ))
+			{
+				bGood = (qboolean)(FS_FileIsInPAK("vm/ui.qvm", &nChkSum2) == 1);
+			}
+			else
+			{
+				bGood = (qboolean)(FS_FileIsInPAK("uix86.dll", &nChkSum2) == 1);
+			}
+		}
+
+		nClientPaks = Cmd_Argc();
+
+		// start at arg 1 ( skip cl_paks )
+		nCurArg = 1;
+
+		// we basically use this while loop to avoid using 'goto' :)
+		while (bGood) {
+
+			// must be at least 6: "cl_paks cgame ui @ firstref ... numChecksums"
+			// numChecksums is encoded
+			if (nClientPaks < 6) {
+				bGood = qfalse;
+				break;
+			}
+			// verify first to be the cgame checksum
+			pArg = Cmd_Argv(nCurArg++);
+			if (!pArg || *pArg == '@' || atoi(pArg) != nChkSum1 ) {
+				bGood = qfalse;
+				break;
+			}
+			// verify the second to be the ui checksum
+			pArg = Cmd_Argv(nCurArg++);
+			if (!pArg || *pArg == '@' || atoi(pArg) != nChkSum2 ) {
+				bGood = qfalse;
+				break;
+			}
+			// should be sitting at the delimeter now
+			pArg = Cmd_Argv(nCurArg++);
+			if (*pArg != '@') {
+				bGood = qfalse;
+				break;
+			}
+			// store checksums since tokenization is not re-entrant
+			for (i = 0; nCurArg < nClientPaks; i++) {
+				nClientChkSum[i] = atoi(Cmd_Argv(nCurArg++));
+			}
+
+			// store number to compare against (minus one cause the last is the number of checksums)
+			nClientPaks = i - 1;
+
+			// make sure none of the client check sums are the same
+			// so the client can't send 5 the same checksums
+			for (i = 0; i < nClientPaks; i++) {
+				for (j = 0; j < nClientPaks; j++) {
+					if (i == j)
+						continue;
+					if (nClientChkSum[i] == nClientChkSum[j]) {
+						bGood = qfalse;
+						break;
+					}
+				}
+				if (bGood == qfalse)
+					break;
+			}
+			if (bGood == qfalse)
+				break;
+
+			// get the pure checksums of the pk3 files loaded by the server
+			pPaks = FS_LoadedPakPureChecksums();
+			Cmd_TokenizeString( pPaks );
+			nServerPaks = Cmd_Argc();
+			if (nServerPaks > 1024)
+				nServerPaks = 1024;
+
+			for (i = 0; i < nServerPaks; i++) {
+				nServerChkSum[i] = atoi(Cmd_Argv(i));
+			}
+
+			// check if the client has provided any pure checksums of pk3 files not loaded by the server
+			for (i = 0; i < nClientPaks; i++) {
+				for (j = 0; j < nServerPaks; j++) {
+					if (nClientChkSum[i] == nServerChkSum[j]) {
+						break;
+					}
+				}
+				if (j >= nServerPaks) {
+					bGood = qfalse;
+					break;
+				}
+			}
+			if ( bGood == qfalse ) {
+				break;
+			}
+
+			// check if the number of checksums was correct
+			nChkSum1 = sv.checksumFeed;
+			for (i = 0; i < nClientPaks; i++) {
+				nChkSum1 ^= nClientChkSum[i];
+			}
+			nChkSum1 ^= nClientPaks;
+			if (nChkSum1 != nClientChkSum[nClientPaks]) {
+				bGood = qfalse;
+				break;
+			}
+
+			// break out
+			break;
+		}
+
+		if (bGood) {
+			cl->pureAuthentic = 1;
+		} 
+		else {
+			cl->pureAuthentic = 0;
+			cl->nextSnapshotTime = -1;
+			cl->state = CS_ACTIVE;
+			SV_SendClientSnapshot( cl );
+			SV_DropClient( cl, "Unpure client detected. Invalid .PK3 files referenced!" );
+		}
+	}
+#endif
+}
+
+/*
+=================
+SV_ResetPureClient_f
+=================
+*/
+static void SV_ResetPureClient_f( client_t *cl ) {
+	cl->pureAuthentic = 0;
+}
+
+/*
+=================
+SV_UserinfoChanged
+
+Pull specific info from a newly changed userinfo string
+into a more C friendly form.
+=================
+*/
+void SV_UserinfoChanged( client_t *cl ) {
+	char	*val;
+	int		i;
+
+	// name for C code
+	Q_strncpyz( cl->name, Info_ValueForKey (cl->userinfo, "name"), sizeof(cl->name) );
+
+	// rate command
+
+	// if the client is on the same subnet as the server and we aren't running an
+	// internet public server, assume they don't need a rate choke
+	if ( Sys_IsLANAddress( cl->netchan.remoteAddress ) && com_dedicated->integer != 2 ) {
+		cl->rate = 99999;	// lans should not rate limit
+	} else {
+		val = Info_ValueForKey (cl->userinfo, "rate");
+		if (strlen(val)) {
+			i = atoi(val);
+			cl->rate = i;
+			if (cl->rate < 1000) {
+				cl->rate = 1000;
+			} else if (cl->rate > 90000) {
+				cl->rate = 90000;
+			}
+		} else {
+			cl->rate = 3000;
+		}
+	}
+	val = Info_ValueForKey (cl->userinfo, "handicap");
+	if (strlen(val)) {
+		i = atoi(val);
+		if (i<=0 || i>100 || strlen(val) > 4) {
+			Info_SetValueForKey( cl->userinfo, "handicap", "100" );
+		}
+	}
+
+	// snaps command
+	val = Info_ValueForKey (cl->userinfo, "snaps");
+	if (strlen(val)) {
+		i = atoi(val);
+		if ( i < 1 ) {
+			i = 1;
+		} else if ( i > 30 ) {
+			i = 30;
+		}
+		cl->snapshotMsec = 1000/i;
+	} else {
+		cl->snapshotMsec = 50;
+	}
+}
+
+#define INFO_CHANGE_MIN_INTERVAL	6000 //6 seconds is reasonable I suppose
+#define INFO_CHANGE_MAX_COUNT		3 //only allow 3 changes within the 6 seconds
+
+/*
+==================
+SV_UpdateUserinfo_f
+==================
+*/
+static void SV_UpdateUserinfo_f( client_t *cl ) {
+	Q_strncpyz( cl->userinfo, Cmd_Argv(1), sizeof(cl->userinfo) );
+
+#ifdef FINAL_BUILD
+	if (cl->lastUserInfoChange > svs.time)
+	{
+		cl->lastUserInfoCount++;
+
+		if (cl->lastUserInfoCount >= INFO_CHANGE_MAX_COUNT)
+		{
+		//	SV_SendServerCommand(cl, "print \"Warning: Too many info changes, last info ignored\n\"\n");
+			SV_SendServerCommand(cl, "print \"@@@TOO_MANY_INFO\n\"\n");
+			return;
+		}
+	}
+	else
+#endif
+	{
+		cl->lastUserInfoCount = 0;
+		cl->lastUserInfoChange = svs.time + INFO_CHANGE_MIN_INTERVAL;
+	}
+
+	SV_UserinfoChanged( cl );
+	// call prog code to allow overrides
+	VM_Call( gvm, GAME_CLIENT_USERINFO_CHANGED, cl - svs.clients );
+}
+
+typedef struct {
+	char	*name;
+	void	(*func)( client_t *cl );
+} ucmd_t;
+
+static ucmd_t ucmds[] = {
+	{"userinfo", SV_UpdateUserinfo_f},
+	{"disconnect", SV_Disconnect_f},
+	{"cp", SV_VerifyPaks_f},
+	{"vdr", SV_ResetPureClient_f},
+#ifndef _XBOX	// No downloads on Xbox
+	{"download", SV_BeginDownload_f},
+	{"nextdl", SV_NextDownload_f},
+	{"stopdl", SV_StopDownload_f},
+	{"donedl", SV_DoneDownload_f},
+#endif
+
+	{NULL, NULL}
+};
+
+/*
+==================
+SV_ExecuteClientCommand
+
+Also called by bot code
+==================
+*/
+void SV_ExecuteClientCommand( client_t *cl, const char *s, qboolean clientOK ) {
+	ucmd_t	*u;
+	
+	Cmd_TokenizeString( s );
+
+	// see if it is a server level command
+	for (u=ucmds ; u->name ; u++) {
+		if (!strcmp (Cmd_Argv(0), u->name) ) {
+			u->func( cl );
+			break;
+		}
+	}
+
+	if (clientOK) {
+		// pass unknown strings to the game
+		if (!u->name && sv.state == SS_GAME) {
+			VM_Call( gvm, GAME_CLIENT_COMMAND, cl - svs.clients );
+		}
+	}
+}
+
+/*
+===============
+SV_ClientCommand
+===============
+*/
+static qboolean SV_ClientCommand( client_t *cl, msg_t *msg ) {
+	int		seq;
+	const char	*s;
+	qboolean clientOk = qtrue;
+
+	seq = MSG_ReadLong( msg );
+	s = MSG_ReadString( msg );
+
+	// see if we have already executed it
+	if ( cl->lastClientCommand >= seq ) {
+		return qtrue;
+	}
+
+	Com_DPrintf( "clientCommand: %s : %i : %s\n", cl->name, seq, s );
+
+	// drop the connection if we have somehow lost commands
+	if ( seq > cl->lastClientCommand + 1 ) {
+		Com_Printf( "Client %s lost %i clientCommands\n", cl->name, 
+			seq - cl->lastClientCommand + 1 );
+		SV_DropClient( cl, "Lost reliable commands" );
+		return qfalse;
+	}
+
+	// malicious users may try using too many string commands
+	// to lag other players.  If we decide that we want to stall
+	// the command, we will stop processing the rest of the packet,
+	// including the usercmd.  This causes flooders to lag themselves
+	// but not other people
+	// We don't do this when the client hasn't been active yet since its
+	// normal to spam a lot of commands when downloading
+	if ( !com_cl_running->integer && 
+		cl->state >= CS_ACTIVE &&
+		sv_floodProtect->integer && 
+		svs.time < cl->nextReliableTime ) {
+		// ignore any other text messages from this client but let them keep playing
+		clientOk = qfalse;
+		Com_DPrintf( "client text ignored for %s\n", cl->name );
+		//return qfalse;	// stop processing
+	} 
+
+	// don't allow another command for one second
+	cl->nextReliableTime = svs.time + 1000;
+
+	SV_ExecuteClientCommand( cl, s, clientOk );
+
+	cl->lastClientCommand = seq;
+	Com_sprintf(cl->lastClientCommandString, sizeof(cl->lastClientCommandString), "%s", s);
+
+	return qtrue;		// continue procesing
+}
+
+
+//==================================================================================
+
+
+/*
+==================
+SV_ClientThink
+
+Also called by bot code
+==================
+*/
+void SV_ClientThink (client_t *cl, usercmd_t *cmd) {
+	cl->lastUsercmd = *cmd;
+
+	if ( cl->state != CS_ACTIVE ) {
+		return;		// may have been kicked during the last usercmd
+	}
+
+	VM_Call( gvm, GAME_CLIENT_THINK, cl - svs.clients );
+}
+
+/*
+==================
+SV_UserMove
+
+The message usually contains all the movement commands 
+that were in the last three packets, so that the information
+in dropped packets can be recovered.
+
+On very fast clients, there may be multiple usercmd packed into
+each of the backup packets.
+==================
+*/
+static void SV_UserMove( client_t *cl, msg_t *msg, qboolean delta ) {
+	int			i, key;
+	int			cmdCount;
+	usercmd_t	nullcmd;
+	usercmd_t	cmds[MAX_PACKET_USERCMDS];
+	usercmd_t	*cmd, *oldcmd;
+
+	if ( delta ) {
+		cl->deltaMessage = cl->messageAcknowledge;
+	} else {
+		cl->deltaMessage = -1;
+	}
+
+	cmdCount = MSG_ReadByte( msg );
+
+	if ( cmdCount < 1 ) {
+		Com_Printf( "cmdCount < 1\n" );
+		return;
+	}
+
+	if ( cmdCount > MAX_PACKET_USERCMDS ) {
+		Com_Printf( "cmdCount > MAX_PACKET_USERCMDS\n" );
+		return;
+	}
+
+	// use the checksum feed in the key
+	key = sv.checksumFeed;
+	// also use the message acknowledge
+	key ^= cl->messageAcknowledge;
+	// also use the last acknowledged server command in the key
+	key ^= Com_HashKey(cl->reliableCommands[ cl->reliableAcknowledge & (MAX_RELIABLE_COMMANDS-1) ], 32);
+
+	Com_Memset( &nullcmd, 0, sizeof(nullcmd) );
+	oldcmd = &nullcmd;
+	for ( i = 0 ; i < cmdCount ; i++ ) {
+		cmd = &cmds[i];
+		MSG_ReadDeltaUsercmdKey( msg, key, oldcmd, cmd );
+		oldcmd = cmd;
+	}
+
+	// save time for ping calculation
+	cl->frames[ cl->messageAcknowledge & PACKET_MASK ].messageAcked = svs.time;
+
+	// if this is the first usercmd we have received
+	// this gamestate, put the client into the world
+	if ( cl->state == CS_PRIMED ) {
+		SV_ClientEnterWorld( cl, &cmds[0] );
+		// the moves can be processed normaly
+	}
+	//
+#ifndef _XBOX	// No pure on Xbox
+	if (sv_pure->integer != 0 && cl->pureAuthentic == 0) {
+		SV_DropClient( cl, "Cannot validate pure client!");
+		return;
+	}
+#endif
+
+	if ( cl->state != CS_ACTIVE ) {
+		cl->deltaMessage = -1;
+		return;
+	}
+
+	// usually, the first couple commands will be duplicates
+	// of ones we have previously received, but the servertimes
+	// in the commands will cause them to be immediately discarded
+	for ( i =  0 ; i < cmdCount ; i++ ) {
+		// if this is a cmd from before a map_restart ignore it
+		if ( cmds[i].serverTime > cmds[cmdCount-1].serverTime ) {
+			continue;
+		}
+		// extremely lagged or cmd from before a map_restart
+		//if ( cmds[i].serverTime > svs.time + 3000 ) {
+		//	continue;
+		//}
+		// don't execute if this is an old cmd which is already executed
+		// these old cmds are included when cl_packetdup > 0
+		if ( cmds[i].serverTime <= cl->lastUsercmd.serverTime ) {
+			continue;
+		}
+		SV_ClientThink (cl, &cmds[ i ]);
+	}
+}
+
+
+/*
+===========================================================================
+
+USER CMD EXECUTION
+
+===========================================================================
+*/
+
+/*
+===================
+SV_ExecuteClientMessage
+
+Parse a client packet
+===================
+*/
+void SV_ExecuteClientMessage( client_t *cl, msg_t *msg ) {
+	int			c;
+	int			serverId;
+
+	MSG_Bitstream(msg);
+
+	serverId = MSG_ReadLong( msg );
+	cl->messageAcknowledge = MSG_ReadLong( msg );
+
+	if (cl->messageAcknowledge < 0) {
+		// usually only hackers create messages like this
+		// it is more annoying for them to let them hanging
+		//SV_DropClient( cl, "illegible client message" );
+		return;
+	}
+
+	cl->reliableAcknowledge = MSG_ReadLong( msg );
+
+	// NOTE: when the client message is fux0red the acknowledgement numbers
+	// can be out of range, this could cause the server to send thousands of server
+	// commands which the server thinks are not yet acknowledged in SV_UpdateServerCommandsToClient
+	if (cl->reliableAcknowledge < cl->reliableSequence - MAX_RELIABLE_COMMANDS) {
+		// usually only hackers create messages like this
+		// it is more annoying for them to let them hanging
+		//SV_DropClient( cl, "illegible client message" );
+		cl->reliableAcknowledge = cl->reliableSequence;
+		return;
+	}
+	// if this is a usercmd from a previous gamestate,
+	// ignore it or retransmit the current gamestate
+	// 
+	// if the client was downloading, let it stay at whatever serverId and
+	// gamestate it was at.  This allows it to keep downloading even when
+	// the gamestate changes.  After the download is finished, we'll
+	// notice and send it a new game state
+#ifdef _XBOX	// No downloads on Xbox
+	if ( serverId != sv.serverId ) {
+#else
+	if ( serverId != sv.serverId && !*cl->downloadName ) {
+#endif
+		if ( serverId == sv.restartedServerId ) {
+			// they just haven't caught the map_restart yet
+			return;
+		}
+		// if we can tell that the client has dropped the last
+		// gamestate we sent them, resend it
+		if ( cl->messageAcknowledge > cl->gamestateMessageNum ) {
+			Com_DPrintf( "%s : dropped gamestate, resending\n", cl->name );
+			SV_SendClientGameState( cl );
+		}
+		return;
+	}
+
+	// read optional clientCommand strings
+	do {
+		c = MSG_ReadByte( msg );
+		if ( c == clc_EOF ) {
+			break;
+		}
+		if ( c != clc_clientCommand ) {
+			break;
+		}
+		if ( !SV_ClientCommand( cl, msg ) ) {
+			return;	// we couldn't execute it because of the flood protection
+		}
+		if (cl->state == CS_ZOMBIE) {
+			return;	// disconnect command
+		}
+	} while ( 1 );
+
+	// read the usercmd_t
+	if ( c == clc_move ) {
+		SV_UserMove( cl, msg, qtrue );
+	} else if ( c == clc_moveNoDelta ) {
+		SV_UserMove( cl, msg, qfalse );
+	} else if ( c != clc_EOF ) {
+		Com_Printf( "WARNING: bad command byte for client %i\n", cl - svs.clients );
+	}
+//	if ( msg->readcount != msg->cursize ) {
+//		Com_Printf( "WARNING: Junk at end of packet for client %i\n", cl - svs.clients );
+//	}
+}
+
diff --git a/codemp/server/sv_game.cpp b/codemp/server/sv_game.cpp
new file mode 100644
index 0000000..28af282
--- /dev/null
+++ b/codemp/server/sv_game.cpp
@@ -0,0 +1,1758 @@
+// sv_game.c -- interface to the game dll
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+#include "server.h"
+
+#include "../game/botlib.h"
+#include "../qcommon/stringed_ingame.h"
+
+#if !defined(CROFFSYSTEM_H_INC)
+	#include "../qcommon/RoffSystem.h"
+#endif
+
+#include "../renderer/tr_WorldEffects.h"
+
+#if !defined(G2_H_INC)
+	#include "../ghoul2/G2_local.h"
+#endif
+
+#include "../ghoul2/G2_gore.h"
+
+#include "../RMG/RM_Headers.h"
+#include "../qcommon/cm_local.h"
+#include "../qcommon/cm_public.h"
+
+#include "../icarus/GameInterface.h"
+
+#include "../qcommon/timing.h"
+
+#include "NPCNav/navigator.h"
+
+botlib_export_t	*botlib_export;
+
+extern CMiniHeap *G2VertSpaceServer;
+
+void SV_GameError( const char *string ) {
+	Com_Error( ERR_DROP, "%s", string );
+}
+
+void SV_GamePrint( const char *string ) {
+	Com_Printf( "%s", string );
+}
+
+// these functions must be used instead of pointer arithmetic, because
+// the game allocates gentities with private information after the server shared part
+int	SV_NumForGentity( sharedEntity_t *ent ) {
+	int		num;
+
+	num = ( (byte *)ent - (byte *)sv.gentities ) / sv.gentitySize;
+
+	return num;
+}
+
+sharedEntity_t *SV_GentityNum( int num ) {
+	sharedEntity_t *ent;
+
+	ent = (sharedEntity_t *)((byte *)sv.gentities + sv.gentitySize*(num));
+
+	return ent;
+}
+
+playerState_t *SV_GameClientNum( int num ) {
+	playerState_t	*ps;
+
+	ps = (playerState_t *)((byte *)sv.gameClients + sv.gameClientSize*(num));
+
+	return ps;
+}
+
+svEntity_t	*SV_SvEntityForGentity( sharedEntity_t *gEnt ) {
+	if ( !gEnt || gEnt->s.number < 0 || gEnt->s.number >= MAX_GENTITIES ) {
+		Com_Error( ERR_DROP, "SV_SvEntityForGentity: bad gEnt" );
+	}
+	return &sv.svEntities[ gEnt->s.number ];
+}
+
+sharedEntity_t *SV_GEntityForSvEntity( svEntity_t *svEnt ) {
+	int		num;
+
+	num = svEnt - sv.svEntities;
+	return SV_GentityNum( num );
+}
+
+/*
+===============
+SV_GameSendServerCommand
+
+Sends a command string to a client
+===============
+*/
+void SV_GameSendServerCommand( int clientNum, const char *text ) {
+	if ( clientNum == -1 ) {
+		SV_SendServerCommand( NULL, "%s", text );
+	} else {
+		if ( clientNum < 0 || clientNum >= sv_maxclients->integer ) {
+			return;
+		}
+		SV_SendServerCommand( svs.clients + clientNum, "%s", text );	
+	}
+}
+
+
+/*
+===============
+SV_GameDropClient
+
+Disconnects the client with a message
+===============
+*/
+void SV_GameDropClient( int clientNum, const char *reason ) {
+	if ( clientNum < 0 || clientNum >= sv_maxclients->integer ) {
+		return;
+	}
+	SV_DropClient( svs.clients + clientNum, reason );	
+}
+
+int		CM_ModelContents( clipHandle_t model, int subBSPIndex );
+int CM_LoadSubBSP(const char *name, qboolean clientload);
+int CM_FindSubBSP(int modelIndex);
+char *CM_SubBSPEntityString( int index );
+/*
+=================
+SV_SetBrushModel
+
+sets mins and maxs for inline bmodels
+=================
+*/
+void SV_SetBrushModel( sharedEntity_t *ent, const char *name ) 
+{
+	clipHandle_t	h;
+	vec3_t			mins, maxs;
+
+	if (!name) 
+	{
+		Com_Error( ERR_DROP, "SV_SetBrushModel: NULL" );
+	}
+
+	if (name[0] == '*')
+	{
+		ent->s.modelindex = atoi( name + 1 );
+
+		if (sv.mLocalSubBSPIndex != -1)
+		{
+			ent->s.modelindex += sv.mLocalSubBSPModelOffset;
+		}
+
+		h = CM_InlineModel( ent->s.modelindex );
+
+		CM_ModelBounds(h, mins, maxs);
+
+		VectorCopy (mins, ent->r.mins);
+		VectorCopy (maxs, ent->r.maxs);
+		ent->r.bmodel = qtrue;
+
+		if (com_RMG && com_RMG->integer)
+		{
+			ent->r.contents = CM_ModelContents( h, sv.mLocalSubBSPIndex );
+		}
+		else
+		{
+			ent->r.contents = CM_ModelContents( h, -1 );
+		}
+	}
+	else if (name[0] == '#')
+	{
+		ent->s.modelindex = CM_LoadSubBSP(va("maps/%s.bsp", name + 1), qfalse);
+		CM_ModelBounds( ent->s.modelindex, mins, maxs );
+
+		VectorCopy (mins, ent->r.mins);
+		VectorCopy (maxs, ent->r.maxs);
+		ent->r.bmodel = qtrue;
+
+		//rwwNOTE: We don't ever want to set contents -1, it includes CONTENTS_LIGHTSABER.
+		//Lots of stuff will explode if there's a brush with CONTENTS_LIGHTSABER that isn't attached to a client owner.
+		//ent->contents = -1;		// we don't know exactly what is in the brushes
+		h = CM_InlineModel( ent->s.modelindex );
+		ent->r.contents = CM_ModelContents( h, CM_FindSubBSP(ent->s.modelindex) );
+	}
+	else
+	{
+		Com_Error( ERR_DROP, "SV_SetBrushModel: %s isn't a brush model", name );
+	}
+}
+
+const char *SV_SetActiveSubBSP(int index)
+{
+	if (index >= 0)
+	{
+		sv.mLocalSubBSPIndex = CM_FindSubBSP(index);
+		sv.mLocalSubBSPModelOffset = index;
+		sv.mLocalSubBSPEntityParsePoint = CM_SubBSPEntityString (sv.mLocalSubBSPIndex);
+		return sv.mLocalSubBSPEntityParsePoint;
+	}
+	else
+	{
+		sv.mLocalSubBSPIndex = -1;
+	}
+
+	return NULL;
+}
+
+/*
+=================
+SV_inPVS
+
+Also checks portalareas so that doors block sight
+=================
+*/
+qboolean SV_inPVS (const vec3_t p1, const vec3_t p2)
+{
+	int		leafnum;
+	int		cluster;
+	int		area1, area2;
+#ifdef _XBOX 
+	const byte *mask;
+#else
+	byte	*mask;
+#endif
+
+	leafnum = CM_PointLeafnum (p1);
+	cluster = CM_LeafCluster (leafnum);
+	area1 = CM_LeafArea (leafnum);
+	mask = CM_ClusterPVS (cluster);
+
+	leafnum = CM_PointLeafnum (p2);
+	cluster = CM_LeafCluster (leafnum);
+	area2 = CM_LeafArea (leafnum);
+	if ( mask && (!(mask[cluster>>3] & (1<<(cluster&7)) ) ) )
+		return qfalse;
+	if (!CM_AreasConnected (area1, area2))
+		return qfalse;		// a door blocks sight
+	return qtrue;
+}
+
+
+/*
+=================
+SV_inPVSIgnorePortals
+
+Does NOT check portalareas
+=================
+*/
+qboolean SV_inPVSIgnorePortals( const vec3_t p1, const vec3_t p2)
+{
+	int		leafnum;
+	int		cluster;
+	int		area1, area2;
+#ifdef _XBOX
+	const byte *mask;
+#else
+	byte	*mask;
+#endif
+
+	leafnum = CM_PointLeafnum (p1);
+	cluster = CM_LeafCluster (leafnum);
+	area1 = CM_LeafArea (leafnum);
+	mask = CM_ClusterPVS (cluster);
+
+	leafnum = CM_PointLeafnum (p2);
+	cluster = CM_LeafCluster (leafnum);
+	area2 = CM_LeafArea (leafnum);
+
+	if ( mask && (!(mask[cluster>>3] & (1<<(cluster&7)) ) ) )
+		return qfalse;
+
+	return qtrue;
+}
+
+
+/*
+========================
+SV_AdjustAreaPortalState
+========================
+*/
+void SV_AdjustAreaPortalState( sharedEntity_t *ent, qboolean open ) {
+	svEntity_t	*svEnt;
+
+	svEnt = SV_SvEntityForGentity( ent );
+	if ( svEnt->areanum2 == -1 ) {
+		return;
+	}
+	CM_AdjustAreaPortalState( svEnt->areanum, svEnt->areanum2, open );
+}
+
+
+/*
+==================
+SV_GameAreaEntities
+==================
+*/
+qboolean	SV_EntityContact( const vec3_t mins, const vec3_t maxs, const sharedEntity_t *gEnt, int capsule ) {
+	const float	*origin, *angles;
+	clipHandle_t	ch;
+	trace_t			trace;
+
+	// check for exact collision
+	origin = gEnt->r.currentOrigin;
+	angles = gEnt->r.currentAngles;
+
+	ch = SV_ClipHandleForEntity( gEnt );
+	CM_TransformedBoxTrace ( &trace, vec3_origin, vec3_origin, mins, maxs,
+		ch, -1, origin, angles, capsule );
+
+	return (qboolean)trace.startsolid;
+}
+
+
+/*
+===============
+SV_GetServerinfo
+
+===============
+*/
+void SV_GetServerinfo( char *buffer, int bufferSize ) {
+	if ( bufferSize < 1 ) {
+		Com_Error( ERR_DROP, "SV_GetServerinfo: bufferSize == %i", bufferSize );
+	}
+	Q_strncpyz( buffer, Cvar_InfoString( CVAR_SERVERINFO ), bufferSize );
+}
+
+/*
+===============
+SV_LocateGameData
+
+===============
+*/
+void SV_LocateGameData( sharedEntity_t *gEnts, int numGEntities, int sizeofGEntity_t,
+					   playerState_t *clients, int sizeofGameClient ) {
+	sv.gentities = gEnts;
+	sv.gentitySize = sizeofGEntity_t;
+	sv.num_entities = numGEntities;
+
+	sv.gameClients = clients;
+	sv.gameClientSize = sizeofGameClient;
+}
+
+qboolean SV_GetEntityToken( char *buffer, int bufferSize )
+{
+	char	*s;
+
+	if (sv.mLocalSubBSPIndex == -1)
+	{
+		s = COM_Parse( (const char **)&sv.entityParsePoint );
+		Q_strncpyz( buffer, s, bufferSize );
+		if ( !sv.entityParsePoint && !s[0] ) 
+		{
+			return qfalse;
+		}
+		else
+		{
+			return qtrue;
+		}
+	}
+	else
+	{
+		s = COM_Parse( (const char **)&sv.mLocalSubBSPEntityParsePoint);
+		Q_strncpyz( buffer, s, bufferSize );
+		if ( !sv.mLocalSubBSPEntityParsePoint && !s[0] ) 
+		{
+			return qfalse;
+		}
+		else
+		{
+			return qtrue;
+		}
+	}
+}
+
+/*
+===============
+SV_GetUsercmd
+
+===============
+*/
+void SV_GetUsercmd( int clientNum, usercmd_t *cmd ) {
+	if ( clientNum < 0 || clientNum >= sv_maxclients->integer ) {
+		Com_Error( ERR_DROP, "SV_GetUsercmd: bad clientNum:%i", clientNum );
+	}
+	*cmd = svs.clients[clientNum].lastUsercmd;
+}
+
+//==============================================
+
+static int	FloatAsInt( float f ) {
+	int		temp;
+
+	*(float *)&temp = f;
+
+	return temp;
+}
+
+/*
+====================
+SV_GameSystemCalls
+
+The module is making a system call
+====================
+*/
+//rcg010207 - see my comments in VM_DllSyscall(), in qcommon/vm.c ...
+#if ((defined __linux__) && (defined __powerpc__))
+#define VMA(x) ((void *) args[x])
+#else
+#define	VMA(x) VM_ArgPtr(args[x])
+#endif
+
+#define	VMF(x)	((float *)args)[x]
+
+void SV_BotWaypointReception(int wpnum, wpobject_t **wps);
+void SV_BotCalculatePaths(int rmg);
+
+qboolean Q3_TaskIDPending( sharedEntity_t *ent, taskID_t taskType );
+void Q3_TaskIDSet( sharedEntity_t *ent, taskID_t taskType, int taskID );
+void Q3_TaskIDComplete( sharedEntity_t *ent, taskID_t taskType );
+void Q3_SetVar( int taskID, int entID, const char *type_name, const char *data );
+int Q3_VariableDeclared( const char *name );
+int Q3_GetFloatVariable( const char *name, float *value );
+int Q3_GetStringVariable( const char *name, const char **value );
+int Q3_GetVectorVariable( const char *name, vec3_t value );
+
+sharedEntity_t gLocalModifier;
+
+sharedEntity_t *ConvertedEntity(sharedEntity_t *ent)
+{ //Return an entity with the memory shifted around to allow reading/modifying VM memory
+	int i = 0;
+
+	assert(ent);
+
+	gLocalModifier.s = ent->s;
+	gLocalModifier.r = ent->r;
+	while (i < NUM_TIDS)
+	{
+		gLocalModifier.taskID[i] = ent->taskID[i];
+		i++;
+	}
+	i = 0;
+	gLocalModifier.parms = (parms_t *)VM_ArgPtr((int)ent->parms);
+	while (i < NUM_BSETS)
+	{
+		gLocalModifier.behaviorSet[i] = (char *)VM_ArgPtr((int)ent->behaviorSet[i]);
+		i++;
+	}
+	i = 0;
+	gLocalModifier.script_targetname = (char *)VM_ArgPtr((int)ent->script_targetname);
+	gLocalModifier.delayScriptTime = ent->delayScriptTime;
+	gLocalModifier.fullName = (char *)VM_ArgPtr((int)ent->fullName);
+	gLocalModifier.targetname = (char *)VM_ArgPtr((int)ent->targetname);
+	gLocalModifier.classname = (char *)VM_ArgPtr((int)ent->classname);
+
+	gLocalModifier.ghoul2 = ent->ghoul2;
+
+	return &gLocalModifier;
+}
+
+siegePers_t sv_siegePersData = {qfalse, 0, 0};
+
+qhandle_t RE_RegisterServerSkin( const char *name );
+extern float g_svCullDist;
+int SV_GameSystemCalls( int *args ) {
+	switch( args[0] ) {
+
+	//rww - alright, DO NOT EVER add a GAME/CGAME/UI generic call without adding a trap to match, and
+	//all of these traps must be shared and have cases in sv_game, cl_cgame, and cl_ui. They must also
+	//all be in the same order, and start at 100.
+	case TRAP_MEMSET:
+		Com_Memset( VMA(1), args[2], args[3] );
+		return 0;
+	case TRAP_MEMCPY:
+		Com_Memcpy( VMA(1), VMA(2), args[3] );
+		return 0;
+	case TRAP_STRNCPY:
+		return (int)strncpy( (char *)VMA(1), (const char *)VMA(2), args[3] );
+	case TRAP_SIN:
+		return FloatAsInt( sin( VMF(1) ) );
+	case TRAP_COS:
+		return FloatAsInt( cos( VMF(1) ) );
+	case TRAP_ATAN2:
+		return FloatAsInt( atan2( VMF(1), VMF(2) ) );
+	case TRAP_SQRT:
+		return FloatAsInt( sqrt( VMF(1) ) );
+	case TRAP_MATRIXMULTIPLY:
+		MatrixMultiply( (vec3_t *)VMA(1), (vec3_t *)VMA(2), (vec3_t *)VMA(3) );
+		return 0;
+	case TRAP_ANGLEVECTORS:
+		AngleVectors( (const float *)VMA(1), (float *)VMA(2), (float *)VMA(3), (float *)VMA(4) );
+		return 0;
+	case TRAP_PERPENDICULARVECTOR:
+		PerpendicularVector( (float *)VMA(1), (const float *)VMA(2) );
+		return 0;
+	case TRAP_FLOOR:
+		return FloatAsInt( floor( VMF(1) ) );
+	case TRAP_CEIL:
+		return FloatAsInt( ceil( VMF(1) ) );
+	case TRAP_TESTPRINTINT:
+		return 0;
+	case TRAP_TESTPRINTFLOAT:
+		return 0;
+	case TRAP_ACOS:
+		return FloatAsInt( Q_acos( VMF(1) ) );
+	case TRAP_ASIN:
+		return FloatAsInt( Q_asin( VMF(1) ) );
+
+
+	case G_PRINT:
+		Com_Printf( "%s", VMA(1) );
+		return 0;
+	case G_ERROR:
+		Com_Error( ERR_DROP, "%s", VMA(1) );
+		return 0;
+	case G_MILLISECONDS:
+		return Sys_Milliseconds();
+	//rww - precision timer funcs... -ALWAYS- call end after start with supplied ptr, or you'll get a nasty memory leak.
+	//not that you should be using these outside of debug anyway.. because you shouldn't be. So don't.
+	case CG_PRECISIONTIMER_START:
+		{
+			void **suppliedPtr =(void **)VMA(1); //we passed in a pointer to a point
+			timing_c *newTimer = new timing_c; //create the new timer
+			*suppliedPtr = newTimer; //assign the pointer within the pointer to point at the mem addr of our new timer
+			newTimer->Start(); //start the timer
+		}
+		return 0;
+	case CG_PRECISIONTIMER_END:
+		{
+			int r;
+			timing_c *timer = (timing_c *)args[1]; //this is the pointer we assigned in start, so we can directly cast it back
+			r = timer->End(); //get the result
+			delete timer; //delete the timer since we're done with it
+			return r; //return the result
+		}
+	case G_CVAR_REGISTER:
+		Cvar_Register( (vmCvar_t *)VMA(1), (const char *)VMA(2), (const char *)VMA(3), args[4] ); 
+		return 0;
+	case G_CVAR_UPDATE:
+		Cvar_Update( (vmCvar_t *)VMA(1) );
+		return 0;
+	case G_CVAR_SET:
+		Cvar_Set( (const char *)VMA(1), (const char *)VMA(2) );
+		return 0;
+	case G_CVAR_VARIABLE_INTEGER_VALUE:
+		return Cvar_VariableIntegerValue( (const char *)VMA(1) );
+	case G_CVAR_VARIABLE_STRING_BUFFER:
+		Cvar_VariableStringBuffer( (const char *)VMA(1), (char *)VMA(2), args[3] );
+		return 0;
+	case G_ARGC:
+		return Cmd_Argc();
+	case G_ARGV:
+		Cmd_ArgvBuffer( args[1], (char *)VMA(2), args[3] );
+		return 0;
+	case G_SEND_CONSOLE_COMMAND:
+		Cbuf_ExecuteText( args[1], (const char *)VMA(2) );
+		return 0;
+
+	case G_FS_FOPEN_FILE:
+		return FS_FOpenFileByMode( (const char *)VMA(1), (int *)VMA(2), (fsMode_t)args[3] );
+	case G_FS_READ:
+		FS_Read2( VMA(1), args[2], args[3] );
+		return 0;
+	case G_FS_WRITE:
+		FS_Write( VMA(1), args[2], args[3] );
+		return 0;
+	case G_FS_FCLOSE_FILE:
+		FS_FCloseFile( args[1] );
+		return 0;
+	case G_FS_GETFILELIST:
+		return FS_GetFileList( (const char *)VMA(1), (const char *)VMA(2), (char *)VMA(3), args[4] );
+
+	case G_LOCATE_GAME_DATA:
+		SV_LocateGameData( (sharedEntity_t *)VMA(1), args[2], args[3], (struct playerState_s *)VMA(4), args[5] );
+		return 0;
+	case G_DROP_CLIENT:
+		SV_GameDropClient( args[1], (const char *)VMA(2) );
+		return 0;
+	case G_SEND_SERVER_COMMAND:
+		SV_GameSendServerCommand( args[1], (const char *)VMA(2) );
+		return 0;
+	case G_LINKENTITY:
+		SV_LinkEntity( (sharedEntity_t *)VMA(1) );
+		return 0;
+	case G_UNLINKENTITY:
+		SV_UnlinkEntity( (sharedEntity_t *)VMA(1) );
+		return 0;
+	case G_ENTITIES_IN_BOX:
+		return SV_AreaEntities( (const float *)VMA(1), (const float *)VMA(2), (int *)VMA(3), args[4] );
+	case G_ENTITY_CONTACT:
+		return SV_EntityContact( (const float *)VMA(1), (const float *)VMA(2), (const sharedEntity_t *)VMA(3), /*int capsule*/ qfalse );
+	case G_ENTITY_CONTACTCAPSULE:
+		return SV_EntityContact( (const float *)VMA(1), (const float *)VMA(2), (const sharedEntity_t *)VMA(3), /*int capsule*/ qtrue );
+	case G_TRACE:
+		SV_Trace( (trace_t *)VMA(1), (const float *)VMA(2), (const float *)VMA(3), (const float *)VMA(4), (const float *)VMA(5), args[6], args[7], /*int capsule*/ qfalse, /*args[8]*/0, args[9] );
+		return 0;
+	case G_G2TRACE:
+		SV_Trace( (trace_t *)VMA(1), (const float *)VMA(2), (const float *)VMA(3), (const float *)VMA(4), (const float *)VMA(5), args[6], args[7], /*int capsule*/ qfalse, args[8], args[9] );
+		return 0;
+	case G_TRACECAPSULE:
+		SV_Trace( (trace_t *)VMA(1), (const float *)VMA(2), (const float *)VMA(3), (const float *)VMA(4), (const float *)VMA(5), args[6], args[7], /*int capsule*/ qtrue, args[8], args[9]  );
+		return 0;
+	case G_POINT_CONTENTS:
+		return SV_PointContents( (const float *)VMA(1), args[2] );
+	case G_SET_SERVER_CULL:
+		g_svCullDist = VMF(1);
+		return 0;
+	case G_SET_BRUSH_MODEL:
+		SV_SetBrushModel( (sharedEntity_t *)VMA(1), (const char *)VMA(2) );
+		return 0;
+	case G_IN_PVS:
+		return SV_inPVS( (const float *)VMA(1), (const float *)VMA(2) );
+	case G_IN_PVS_IGNORE_PORTALS:
+		return SV_inPVSIgnorePortals( (const float *)VMA(1), (const float *)VMA(2) );
+
+	case G_SET_CONFIGSTRING:
+		SV_SetConfigstring( args[1], (const char *)VMA(2) );
+		return 0;
+	case G_GET_CONFIGSTRING:
+		SV_GetConfigstring( args[1], (char *)VMA(2), args[3] );
+		return 0;
+	case G_SET_USERINFO:
+		SV_SetUserinfo( args[1], (const char *)VMA(2) );
+		return 0;
+	case G_GET_USERINFO:
+		SV_GetUserinfo( args[1], (char *)VMA(2), args[3] );
+		return 0;
+	case G_GET_SERVERINFO:
+		SV_GetServerinfo( (char *)VMA(1), args[2] );
+		return 0;
+	case G_ADJUST_AREA_PORTAL_STATE:
+		SV_AdjustAreaPortalState( (sharedEntity_t *)VMA(1), (qboolean)args[2] );
+		return 0;
+	case G_AREAS_CONNECTED:
+		return CM_AreasConnected( args[1], args[2] );
+
+	case G_BOT_ALLOCATE_CLIENT:
+		return SV_BotAllocateClient();
+	case G_BOT_FREE_CLIENT:
+		SV_BotFreeClient( args[1] );
+		return 0;
+
+	case G_GET_USERCMD:
+		SV_GetUsercmd( args[1], (struct usercmd_s *)VMA(2) );
+		return 0;
+
+	case G_SIEGEPERSSET:
+		sv_siegePersData = *((siegePers_t *)VMA(1));
+		return 0;
+
+	case G_SIEGEPERSGET:
+		*((siegePers_t *)VMA(1)) = sv_siegePersData;
+		return 0;
+
+		//rwwRMG - see below
+		/*
+	case G_GET_ENTITY_TOKEN:
+		{
+			const char	*s;
+
+			s = COM_Parse( (const char **) &sv.entityParsePoint );
+			Q_strncpyz( (char *)VMA(1), s, args[2] );
+			if ( !sv.entityParsePoint && !s[0] ) {
+				return qfalse;
+			} else {
+				return qtrue;
+			}
+		}
+		*/
+
+		/*
+	case G_BOT_GET_MEMORY:
+		void *ptr;
+		ptr = Bot_GetMemoryGame(args[1]);
+		return (int)ptr;
+	case G_BOT_FREE_MEMORY:
+		Bot_FreeMemoryGame((void *)VMA(1));
+		return 0;
+		*/
+	case G_DEBUG_POLYGON_CREATE:
+		return BotImport_DebugPolygonCreate( args[1], args[2], (float (*)[3])VMA(3) );
+	case G_DEBUG_POLYGON_DELETE:
+		BotImport_DebugPolygonDelete( args[1] );
+		return 0;
+	case G_REAL_TIME:
+		return Com_RealTime( (struct qtime_s *)VMA(1) );
+	case G_SNAPVECTOR:
+		Sys_SnapVector( (float *)VMA(1) );
+		return 0;
+
+//	case SP_REGISTER_SERVER_CMD:
+//		return SP_RegisterServer( (const char *)VMA(1) );
+	case SP_GETSTRINGTEXTSTRING:
+		//return (int)SP_GetStringTextString((char *)VMA(1));
+		const char* text;
+
+		assert(VMA(1));
+		assert(VMA(2));
+
+//		if (args[0] == CG_SP_GETSTRINGTEXT)
+//		{
+//			text = SP_GetStringText( args[1] );
+//		}
+//		else
+		{
+			text = SE_GetString( (const char *) VMA(1) );
+		}
+
+		if ( text[0] )
+		{
+			Q_strncpyz( (char *) VMA(2), text, args[3] );
+			return qtrue;
+		}
+		else 
+		{
+			Q_strncpyz( (char *) VMA(2), "??", args[3] );
+			return qfalse;
+		}
+		break;
+
+	case G_ROFF_CLEAN:
+		return theROFFSystem.Clean(qfalse);
+	
+	case G_ROFF_UPDATE_ENTITIES:
+		theROFFSystem.UpdateEntities(qfalse);
+		return 0;
+
+	case G_ROFF_CACHE:
+		return theROFFSystem.Cache( (char *)VMA(1), qfalse );
+		
+	case G_ROFF_PLAY:
+		return theROFFSystem.Play(args[1], args[2], (qboolean)args[3], qfalse );
+
+	case G_ROFF_PURGE_ENT:
+		return theROFFSystem.PurgeEnt( args[1], qfalse );
+
+	//rww - dynamic vm memory allocation!
+	case G_TRUEMALLOC:
+		VM_Shifted_Alloc((void **)VMA(1), args[2]);
+		return 0;
+	case G_TRUEFREE:
+		VM_Shifted_Free((void **)VMA(1));
+		return 0;
+
+	//rww - icarus traps
+	case G_ICARUS_RUNSCRIPT:
+		return ICARUS_RunScript(ConvertedEntity((sharedEntity_t *)VMA(1)), (const char *)VMA(2));
+
+	case G_ICARUS_REGISTERSCRIPT:
+		return ICARUS_RegisterScript((const char *)VMA(1), (qboolean)args[2]);
+
+	case G_ICARUS_INIT:
+		ICARUS_Init();
+		return 0;
+
+	case G_ICARUS_VALIDENT:
+		return ICARUS_ValidEnt(ConvertedEntity((sharedEntity_t *)VMA(1)));
+
+	case G_ICARUS_ISINITIALIZED:
+		{
+			int entID = args[1];
+
+			if (!gSequencers[entID] || !gTaskManagers[entID])
+			{
+				return 0;
+			}
+		}
+		return 1;
+
+	case G_ICARUS_MAINTAINTASKMANAGER:
+		{
+			int entID = args[1];
+
+			if (gTaskManagers[entID])
+			{
+				gTaskManagers[entID]->Update();
+				return 1;
+			}
+		}
+		return 0;
+	case G_ICARUS_ISRUNNING:
+		{
+			int entID = args[1];
+
+			if (!gTaskManagers[entID] || !gTaskManagers[entID]->IsRunning())
+			{
+				return 0;
+			}
+		}
+		return 1;
+
+	case G_ICARUS_TASKIDPENDING:
+		return Q3_TaskIDPending((sharedEntity_t *)VMA(1), (taskID_t)args[2]);
+
+	case G_ICARUS_INITENT:
+		ICARUS_InitEnt(ConvertedEntity((sharedEntity_t *)VMA(1)));
+		return 0;
+
+	case G_ICARUS_FREEENT:
+		ICARUS_FreeEnt(ConvertedEntity((sharedEntity_t *)VMA(1)));
+		return 0;
+
+	case G_ICARUS_ASSOCIATEENT:
+		ICARUS_AssociateEnt(ConvertedEntity((sharedEntity_t *)VMA(1)));
+		return 0;
+
+	case G_ICARUS_SHUTDOWN:
+		ICARUS_Shutdown();
+		return 0;
+
+	case G_ICARUS_TASKIDSET:
+		//rww - note that we are passing in the true entity here.
+		//This is because we allow modification of certain non-pointer values,
+		//which is valid.
+		Q3_TaskIDSet((sharedEntity_t *)VMA(1), (taskID_t)args[2], args[3]);
+		return 0;
+
+	case G_ICARUS_TASKIDCOMPLETE:
+		//same as above.
+		Q3_TaskIDComplete((sharedEntity_t *)VMA(1), (taskID_t)args[2]);
+		return 0;
+
+	case G_ICARUS_SETVAR:
+		Q3_SetVar(args[1], args[2], (const char *)VMA(3), (const char *)VMA(4));
+		return 0;
+
+	case G_ICARUS_VARIABLEDECLARED:
+		return Q3_VariableDeclared((const char *)VMA(1));
+
+	case G_ICARUS_GETFLOATVARIABLE:
+		return Q3_GetFloatVariable((const char *)VMA(1), (float *)VMA(2));
+
+	case G_ICARUS_GETSTRINGVARIABLE:
+		{
+			const char *rec = (const char *)VMA(2);
+			return Q3_GetStringVariable((const char *)VMA(1), (const char **)&rec);
+		}
+
+	case G_ICARUS_GETVECTORVARIABLE:
+		return Q3_GetVectorVariable((const char *)VMA(1), (float *)VMA(2));
+
+
+	//rww - BEGIN NPC NAV TRAPS
+	case G_NAV_INIT:
+		navigator.Init();
+		return 0;
+	case G_NAV_FREE:
+		navigator.Free();
+		return 0;
+	case G_NAV_LOAD:
+		return navigator.Load((const char *)VMA(1), args[2]);
+	case G_NAV_SAVE:
+		return navigator.Save((const char *)VMA(1), args[2]);
+	case G_NAV_ADDRAWPOINT:
+		return navigator.AddRawPoint((float *)VMA(1), args[2], args[3]);
+	case G_NAV_CALCULATEPATHS:
+		navigator.CalculatePaths((qboolean)args[1]);
+		return 0;
+	case G_NAV_HARDCONNECT:
+		navigator.HardConnect(args[1], args[2]);
+		return 0;
+	case G_NAV_SHOWNODES:
+		navigator.ShowNodes();
+		return 0;
+	case G_NAV_SHOWEDGES:
+		navigator.ShowEdges();
+		return 0;
+	case G_NAV_SHOWPATH:
+		navigator.ShowPath(args[1], args[2]);
+		return 0;
+	case G_NAV_GETNEARESTNODE:
+		return navigator.GetNearestNode((sharedEntity_t *)VMA(1), args[2], args[3], args[4]);
+	case G_NAV_GETBESTNODE:
+		return navigator.GetBestNode(args[1], args[2], args[3]);
+	case G_NAV_GETNODEPOSITION:
+		return navigator.GetNodePosition(args[1], (float *)VMA(2));
+	case G_NAV_GETNODENUMEDGES:
+		return navigator.GetNodeNumEdges(args[1]);
+	case G_NAV_GETNODEEDGE:
+		return navigator.GetNodeEdge(args[1], args[2]);
+	case G_NAV_GETNUMNODES:
+		return navigator.GetNumNodes();
+	case G_NAV_CONNECTED:
+		return navigator.Connected(args[1], args[2]);
+	case G_NAV_GETPATHCOST:
+		return navigator.GetPathCost(args[1], args[2]);
+	case G_NAV_GETEDGECOST:
+		return navigator.GetEdgeCost(args[1], args[2]);
+	case G_NAV_GETPROJECTEDNODE:
+		return navigator.GetProjectedNode((float *)VMA(1), args[2]);
+	case G_NAV_CHECKFAILEDNODES:
+		navigator.CheckFailedNodes((sharedEntity_t *)VMA(1));
+		return 0;
+	case G_NAV_ADDFAILEDNODE:
+		navigator.AddFailedNode((sharedEntity_t *)VMA(1), args[2]);
+		return 0;
+	case G_NAV_NODEFAILED:
+		return navigator.NodeFailed((sharedEntity_t *)VMA(1), args[2]);
+	case G_NAV_NODESARENEIGHBORS:
+		return navigator.NodesAreNeighbors(args[1], args[2]);
+	case G_NAV_CLEARFAILEDEDGE:
+		navigator.ClearFailedEdge((failedEdge_t *)VMA(1));
+		return 0;
+	case G_NAV_CLEARALLFAILEDEDGES:
+		navigator.ClearAllFailedEdges();
+		return 0;
+	case G_NAV_EDGEFAILED:
+		return navigator.EdgeFailed(args[1], args[2]);
+	case G_NAV_ADDFAILEDEDGE:
+		navigator.AddFailedEdge(args[1], args[2], args[3]);
+		return 0;
+	case G_NAV_CHECKFAILEDEDGE:
+		return navigator.CheckFailedEdge((failedEdge_t *)VMA(1));
+	case G_NAV_CHECKALLFAILEDEDGES:
+		navigator.CheckAllFailedEdges();
+		return 0;
+	case G_NAV_ROUTEBLOCKED:
+		return navigator.RouteBlocked(args[1], args[2], args[3], args[4]);
+	case G_NAV_GETBESTNODEALTROUTE:
+		return navigator.GetBestNodeAltRoute(args[1], args[2], (int *)VMA(3), args[4]);
+	case G_NAV_GETBESTNODEALT2:
+		return navigator.GetBestNodeAltRoute(args[1], args[2], args[3]);
+	case G_NAV_GETBESTPATHBETWEENENTS:
+		return navigator.GetBestPathBetweenEnts((sharedEntity_t *)VMA(1), (sharedEntity_t *)VMA(2), args[3]);
+	case G_NAV_GETNODERADIUS:
+		return navigator.GetNodeRadius(args[1]);
+	case G_NAV_CHECKBLOCKEDEDGES:
+		navigator.CheckBlockedEdges();
+		return 0;
+	case G_NAV_CLEARCHECKEDNODES:
+		navigator.ClearCheckedNodes();
+		return 0;
+	case G_NAV_CHECKEDNODE:
+		return navigator.CheckedNode(args[1], args[2]);
+	case G_NAV_SETCHECKEDNODE:
+		navigator.SetCheckedNode(args[1], args[2], args[3]);
+	case G_NAV_FLAGALLNODES:
+		navigator.FlagAllNodes(args[1]);
+	case G_NAV_GETPATHSCALCULATED:
+		return navigator.pathsCalculated;
+	case G_NAV_SETPATHSCALCULATED:
+		navigator.pathsCalculated = (qboolean)args[1];
+		return 0;
+	//rww - END NPC NAV TRAPS
+
+	case G_SET_SHARED_BUFFER:
+		sv.mSharedMemory = ((char *)VMA(1));
+		return 0;
+		//====================================
+
+	case BOTLIB_SETUP:
+		return SV_BotLibSetup();
+	case BOTLIB_SHUTDOWN:
+		return SV_BotLibShutdown();
+	case BOTLIB_LIBVAR_SET:
+		return botlib_export->BotLibVarSet( (char *)VMA(1), (char *)VMA(2) );
+	case BOTLIB_LIBVAR_GET:
+		return botlib_export->BotLibVarGet( (char *)VMA(1), (char *)VMA(2), args[3] );
+
+	case BOTLIB_PC_ADD_GLOBAL_DEFINE:
+		return botlib_export->PC_AddGlobalDefine( (char *)VMA(1) );
+	case BOTLIB_PC_LOAD_SOURCE:
+		return botlib_export->PC_LoadSourceHandle( (const char *)VMA(1) );
+	case BOTLIB_PC_FREE_SOURCE:
+		return botlib_export->PC_FreeSourceHandle( args[1] );
+	case BOTLIB_PC_READ_TOKEN:
+		return botlib_export->PC_ReadTokenHandle( args[1], (struct pc_token_s *)VMA(2) );
+	case BOTLIB_PC_SOURCE_FILE_AND_LINE:
+		return botlib_export->PC_SourceFileAndLine( args[1], (char *)VMA(2), (int *)VMA(3) );
+
+	case BOTLIB_START_FRAME:
+		return botlib_export->BotLibStartFrame( VMF(1) );
+	case BOTLIB_LOAD_MAP:
+		return botlib_export->BotLibLoadMap( (const char *)VMA(1) );
+	case BOTLIB_UPDATENTITY:
+		return botlib_export->BotLibUpdateEntity( args[1], (struct bot_entitystate_s *)VMA(2) );
+	case BOTLIB_TEST:
+		return botlib_export->Test( args[1], (char *)VMA(2), (float *)VMA(3), (float *)VMA(4) );
+
+	case BOTLIB_GET_SNAPSHOT_ENTITY:
+		return SV_BotGetSnapshotEntity( args[1], args[2] );
+	case BOTLIB_GET_CONSOLE_MESSAGE:
+		return SV_BotGetConsoleMessage( args[1], (char *)VMA(2), args[3] );
+	case BOTLIB_USER_COMMAND:
+		SV_ClientThink( &svs.clients[args[1]], (struct usercmd_s *)VMA(2) );
+		return 0;
+
+	case BOTLIB_AAS_BBOX_AREAS:
+		return botlib_export->aas.AAS_BBoxAreas( (float *)VMA(1), (float *)VMA(2), (int *)VMA(3), args[4] );
+	case BOTLIB_AAS_AREA_INFO:
+		return botlib_export->aas.AAS_AreaInfo( args[1], (struct aas_areainfo_s *)VMA(2) );
+	case BOTLIB_AAS_ALTERNATIVE_ROUTE_GOAL:
+		return botlib_export->aas.AAS_AlternativeRouteGoals( (float *)VMA(1), args[2], (float *)VMA(3), args[4], args[5], (struct aas_altroutegoal_s *)VMA(6), args[7], args[8] );
+	case BOTLIB_AAS_ENTITY_INFO:
+		botlib_export->aas.AAS_EntityInfo( args[1], (struct aas_entityinfo_s *)VMA(2) );
+		return 0;
+
+	case BOTLIB_AAS_INITIALIZED:
+		return botlib_export->aas.AAS_Initialized();
+	case BOTLIB_AAS_PRESENCE_TYPE_BOUNDING_BOX:
+		botlib_export->aas.AAS_PresenceTypeBoundingBox( args[1], (float *)VMA(2), (float *)VMA(3) );
+		return 0;
+	case BOTLIB_AAS_TIME:
+		return FloatAsInt( botlib_export->aas.AAS_Time() );
+
+	case BOTLIB_AAS_POINT_AREA_NUM:
+		return botlib_export->aas.AAS_PointAreaNum( (float *)VMA(1) );
+	case BOTLIB_AAS_POINT_REACHABILITY_AREA_INDEX:
+		return botlib_export->aas.AAS_PointReachabilityAreaIndex( (float *)VMA(1) );
+	case BOTLIB_AAS_TRACE_AREAS:
+		return botlib_export->aas.AAS_TraceAreas( (float *)VMA(1), (float *)VMA(2), (int *)VMA(3), (float (*)[3])VMA(4), args[5] );
+
+	case BOTLIB_AAS_POINT_CONTENTS:
+		return botlib_export->aas.AAS_PointContents( (float *)VMA(1) );
+	case BOTLIB_AAS_NEXT_BSP_ENTITY:
+		return botlib_export->aas.AAS_NextBSPEntity( args[1] );
+	case BOTLIB_AAS_VALUE_FOR_BSP_EPAIR_KEY:
+		return botlib_export->aas.AAS_ValueForBSPEpairKey( args[1], (char *)VMA(2), (char *)VMA(3), args[4] );
+	case BOTLIB_AAS_VECTOR_FOR_BSP_EPAIR_KEY:
+		return botlib_export->aas.AAS_VectorForBSPEpairKey( args[1], (char *)VMA(2), (float *)VMA(3) );
+	case BOTLIB_AAS_FLOAT_FOR_BSP_EPAIR_KEY:
+		return botlib_export->aas.AAS_FloatForBSPEpairKey( args[1], (char *)VMA(2), (float *)VMA(3) );
+	case BOTLIB_AAS_INT_FOR_BSP_EPAIR_KEY:
+		return botlib_export->aas.AAS_IntForBSPEpairKey( args[1], (char *)VMA(2), (int *)VMA(3) );
+
+	case BOTLIB_AAS_AREA_REACHABILITY:
+		return botlib_export->aas.AAS_AreaReachability( args[1] );
+
+	case BOTLIB_AAS_AREA_TRAVEL_TIME_TO_GOAL_AREA:
+		return botlib_export->aas.AAS_AreaTravelTimeToGoalArea( args[1], (float *)VMA(2), args[3], args[4] );
+	case BOTLIB_AAS_ENABLE_ROUTING_AREA:
+		return botlib_export->aas.AAS_EnableRoutingArea( args[1], args[2] );
+	case BOTLIB_AAS_PREDICT_ROUTE:
+		return botlib_export->aas.AAS_PredictRoute( (struct aas_predictroute_s *)VMA(1), args[2], (float *)VMA(3), args[4], args[5], args[6], args[7], args[8], args[9], args[10], args[11] );
+
+	case BOTLIB_AAS_SWIMMING:
+		return botlib_export->aas.AAS_Swimming( (float *)VMA(1) );
+	case BOTLIB_AAS_PREDICT_CLIENT_MOVEMENT:
+		return botlib_export->aas.AAS_PredictClientMovement( (struct aas_clientmove_s *)VMA(1), args[2], (float *)VMA(3), args[4], args[5],
+			(float *)VMA(6), (float *)VMA(7), args[8], args[9], VMF(10), args[11], args[12], args[13] );
+
+	case BOTLIB_EA_SAY:
+		botlib_export->ea.EA_Say( args[1], (char *)VMA(2) );
+		return 0;
+	case BOTLIB_EA_SAY_TEAM:
+		botlib_export->ea.EA_SayTeam( args[1], (char *)VMA(2) );
+		return 0;
+	case BOTLIB_EA_COMMAND:
+		botlib_export->ea.EA_Command( args[1], (char *)VMA(2) );
+		return 0;
+
+	case BOTLIB_EA_ACTION:
+		botlib_export->ea.EA_Action( args[1], args[2] );
+		break;
+	case BOTLIB_EA_GESTURE:
+		botlib_export->ea.EA_Gesture( args[1] );
+		return 0;
+	case BOTLIB_EA_TALK:
+		botlib_export->ea.EA_Talk( args[1] );
+		return 0;
+	case BOTLIB_EA_ATTACK:
+		botlib_export->ea.EA_Attack( args[1] );
+		return 0;
+	case BOTLIB_EA_ALT_ATTACK:
+		botlib_export->ea.EA_Alt_Attack( args[1] );
+		return 0;
+	case BOTLIB_EA_FORCEPOWER:
+		botlib_export->ea.EA_ForcePower( args[1] );
+		return 0;
+	case BOTLIB_EA_USE:
+		botlib_export->ea.EA_Use( args[1] );
+		return 0;
+	case BOTLIB_EA_RESPAWN:
+		botlib_export->ea.EA_Respawn( args[1] );
+		return 0;
+	case BOTLIB_EA_CROUCH:
+		botlib_export->ea.EA_Crouch( args[1] );
+		return 0;
+	case BOTLIB_EA_MOVE_UP:
+		botlib_export->ea.EA_MoveUp( args[1] );
+		return 0;
+	case BOTLIB_EA_MOVE_DOWN:
+		botlib_export->ea.EA_MoveDown( args[1] );
+		return 0;
+	case BOTLIB_EA_MOVE_FORWARD:
+		botlib_export->ea.EA_MoveForward( args[1] );
+		return 0;
+	case BOTLIB_EA_MOVE_BACK:
+		botlib_export->ea.EA_MoveBack( args[1] );
+		return 0;
+	case BOTLIB_EA_MOVE_LEFT:
+		botlib_export->ea.EA_MoveLeft( args[1] );
+		return 0;
+	case BOTLIB_EA_MOVE_RIGHT:
+		botlib_export->ea.EA_MoveRight( args[1] );
+		return 0;
+
+	case BOTLIB_EA_SELECT_WEAPON:
+		botlib_export->ea.EA_SelectWeapon( args[1], args[2] );
+		return 0;
+	case BOTLIB_EA_JUMP:
+		botlib_export->ea.EA_Jump( args[1] );
+		return 0;
+	case BOTLIB_EA_DELAYED_JUMP:
+		botlib_export->ea.EA_DelayedJump( args[1] );
+		return 0;
+	case BOTLIB_EA_MOVE:
+		botlib_export->ea.EA_Move( args[1], (float *)VMA(2), VMF(3) );
+		return 0;
+	case BOTLIB_EA_VIEW:
+		botlib_export->ea.EA_View( args[1], (float *)VMA(2) );
+		return 0;
+
+	case BOTLIB_EA_END_REGULAR:
+		botlib_export->ea.EA_EndRegular( args[1], VMF(2) );
+		return 0;
+	case BOTLIB_EA_GET_INPUT:
+		botlib_export->ea.EA_GetInput( args[1], VMF(2), (struct bot_input_s *)VMA(3) );
+		return 0;
+	case BOTLIB_EA_RESET_INPUT:
+		botlib_export->ea.EA_ResetInput( args[1] );
+		return 0;
+
+	case BOTLIB_AI_LOAD_CHARACTER:
+		return botlib_export->ai.BotLoadCharacter( (char *)VMA(1), VMF(2) );
+	case BOTLIB_AI_FREE_CHARACTER:
+		botlib_export->ai.BotFreeCharacter( args[1] );
+		return 0;
+	case BOTLIB_AI_CHARACTERISTIC_FLOAT:
+		return FloatAsInt( botlib_export->ai.Characteristic_Float( args[1], args[2] ) );
+	case BOTLIB_AI_CHARACTERISTIC_BFLOAT:
+		return FloatAsInt( botlib_export->ai.Characteristic_BFloat( args[1], args[2], VMF(3), VMF(4) ) );
+	case BOTLIB_AI_CHARACTERISTIC_INTEGER:
+		return botlib_export->ai.Characteristic_Integer( args[1], args[2] );
+	case BOTLIB_AI_CHARACTERISTIC_BINTEGER:
+		return botlib_export->ai.Characteristic_BInteger( args[1], args[2], args[3], args[4] );
+	case BOTLIB_AI_CHARACTERISTIC_STRING:
+		botlib_export->ai.Characteristic_String( args[1], args[2], (char *)VMA(3), args[4] );
+		return 0;
+
+	case BOTLIB_AI_ALLOC_CHAT_STATE:
+		return botlib_export->ai.BotAllocChatState();
+	case BOTLIB_AI_FREE_CHAT_STATE:
+		botlib_export->ai.BotFreeChatState( args[1] );
+		return 0;
+	case BOTLIB_AI_QUEUE_CONSOLE_MESSAGE:
+		botlib_export->ai.BotQueueConsoleMessage( args[1], args[2], (char *)VMA(3) );
+		return 0;
+	case BOTLIB_AI_REMOVE_CONSOLE_MESSAGE:
+		botlib_export->ai.BotRemoveConsoleMessage( args[1], args[2] );
+		return 0;
+	case BOTLIB_AI_NEXT_CONSOLE_MESSAGE:
+		return botlib_export->ai.BotNextConsoleMessage( args[1], (struct bot_consolemessage_s *)VMA(2) );
+	case BOTLIB_AI_NUM_CONSOLE_MESSAGE:
+		return botlib_export->ai.BotNumConsoleMessages( args[1] );
+	case BOTLIB_AI_INITIAL_CHAT:
+		botlib_export->ai.BotInitialChat( args[1], (char *)VMA(2), args[3], (char *)VMA(4), (char *)VMA(5), (char *)VMA(6), (char *)VMA(7), (char *)VMA(8), (char *)VMA(9), (char *)VMA(10), (char *)VMA(11) );
+		return 0;
+	case BOTLIB_AI_NUM_INITIAL_CHATS:
+		return botlib_export->ai.BotNumInitialChats( args[1], (char *)VMA(2) );
+	case BOTLIB_AI_REPLY_CHAT:
+		return botlib_export->ai.BotReplyChat( args[1], (char *)VMA(2), args[3], args[4], (char *)VMA(5), (char *)VMA(6), (char *)VMA(7), (char *)VMA(8), (char *)VMA(9), (char *)VMA(10), (char *)VMA(11), (char *)VMA(12) );
+	case BOTLIB_AI_CHAT_LENGTH:
+		return botlib_export->ai.BotChatLength( args[1] );
+	case BOTLIB_AI_ENTER_CHAT:
+		botlib_export->ai.BotEnterChat( args[1], args[2], args[3] );
+		return 0;
+	case BOTLIB_AI_GET_CHAT_MESSAGE:
+		botlib_export->ai.BotGetChatMessage( args[1], (char *)VMA(2), args[3] );
+		return 0;
+	case BOTLIB_AI_STRING_CONTAINS:
+		return botlib_export->ai.StringContains( (char *)VMA(1), (char *)VMA(2), args[3] );
+	case BOTLIB_AI_FIND_MATCH:
+		return botlib_export->ai.BotFindMatch( (char *)VMA(1), (struct bot_match_s *)VMA(2), args[3] );
+	case BOTLIB_AI_MATCH_VARIABLE:
+		botlib_export->ai.BotMatchVariable( (struct bot_match_s *)VMA(1), args[2], (char *)VMA(3), args[4] );
+		return 0;
+	case BOTLIB_AI_UNIFY_WHITE_SPACES:
+		botlib_export->ai.UnifyWhiteSpaces( (char *)VMA(1) );
+		return 0;
+	case BOTLIB_AI_REPLACE_SYNONYMS:
+		botlib_export->ai.BotReplaceSynonyms( (char *)VMA(1), args[2] );
+		return 0;
+	case BOTLIB_AI_LOAD_CHAT_FILE:
+		return botlib_export->ai.BotLoadChatFile( args[1], (char *)VMA(2), (char *)VMA(3) );
+	case BOTLIB_AI_SET_CHAT_GENDER:
+		botlib_export->ai.BotSetChatGender( args[1], args[2] );
+		return 0;
+	case BOTLIB_AI_SET_CHAT_NAME:
+		botlib_export->ai.BotSetChatName( args[1], (char *)VMA(2), args[3] );
+		return 0;
+
+	case BOTLIB_AI_RESET_GOAL_STATE:
+		botlib_export->ai.BotResetGoalState( args[1] );
+		return 0;
+	case BOTLIB_AI_RESET_AVOID_GOALS:
+		botlib_export->ai.BotResetAvoidGoals( args[1] );
+		return 0;
+	case BOTLIB_AI_REMOVE_FROM_AVOID_GOALS:
+		botlib_export->ai.BotRemoveFromAvoidGoals( args[1], args[2] );
+		return 0;
+	case BOTLIB_AI_PUSH_GOAL:
+		botlib_export->ai.BotPushGoal( args[1], (struct bot_goal_s *)VMA(2) );
+		return 0;
+	case BOTLIB_AI_POP_GOAL:
+		botlib_export->ai.BotPopGoal( args[1] );
+		return 0;
+	case BOTLIB_AI_EMPTY_GOAL_STACK:
+		botlib_export->ai.BotEmptyGoalStack( args[1] );
+		return 0;
+	case BOTLIB_AI_DUMP_AVOID_GOALS:
+		botlib_export->ai.BotDumpAvoidGoals( args[1] );
+		return 0;
+	case BOTLIB_AI_DUMP_GOAL_STACK:
+		botlib_export->ai.BotDumpGoalStack( args[1] );
+		return 0;
+	case BOTLIB_AI_GOAL_NAME:
+		botlib_export->ai.BotGoalName( args[1], (char *)VMA(2), args[3] );
+		return 0;
+	case BOTLIB_AI_GET_TOP_GOAL:
+		return botlib_export->ai.BotGetTopGoal( args[1], (struct bot_goal_s *)VMA(2) );
+	case BOTLIB_AI_GET_SECOND_GOAL:
+		return botlib_export->ai.BotGetSecondGoal( args[1], (struct bot_goal_s *)VMA(2) );
+	case BOTLIB_AI_CHOOSE_LTG_ITEM:
+		return botlib_export->ai.BotChooseLTGItem( args[1], (float *)VMA(2), (int *)VMA(3), args[4] );
+	case BOTLIB_AI_CHOOSE_NBG_ITEM:
+		return botlib_export->ai.BotChooseNBGItem( args[1], (float *)VMA(2), (int *)VMA(3), args[4], (struct bot_goal_s *)VMA(5), VMF(6) );
+	case BOTLIB_AI_TOUCHING_GOAL:
+		return botlib_export->ai.BotTouchingGoal( (float *)VMA(1), (struct bot_goal_s *)VMA(2) );
+	case BOTLIB_AI_ITEM_GOAL_IN_VIS_BUT_NOT_VISIBLE:
+		return botlib_export->ai.BotItemGoalInVisButNotVisible( args[1], (float *)VMA(2), (float *)VMA(3), (struct bot_goal_s *)VMA(4) );
+	case BOTLIB_AI_GET_LEVEL_ITEM_GOAL:
+		return botlib_export->ai.BotGetLevelItemGoal( args[1], (char *)VMA(2), (struct bot_goal_s *)VMA(3) );
+	case BOTLIB_AI_GET_NEXT_CAMP_SPOT_GOAL:
+		return botlib_export->ai.BotGetNextCampSpotGoal( args[1], (struct bot_goal_s *)VMA(2) );
+	case BOTLIB_AI_GET_MAP_LOCATION_GOAL:
+		return botlib_export->ai.BotGetMapLocationGoal( (char *)VMA(1), (struct bot_goal_s *)VMA(2) );
+	case BOTLIB_AI_AVOID_GOAL_TIME:
+		return FloatAsInt( botlib_export->ai.BotAvoidGoalTime( args[1], args[2] ) );
+	case BOTLIB_AI_SET_AVOID_GOAL_TIME:
+		botlib_export->ai.BotSetAvoidGoalTime( args[1], args[2], VMF(3));
+		return 0;
+	case BOTLIB_AI_INIT_LEVEL_ITEMS:
+		botlib_export->ai.BotInitLevelItems();
+		return 0;
+	case BOTLIB_AI_UPDATE_ENTITY_ITEMS:
+		botlib_export->ai.BotUpdateEntityItems();
+		return 0;
+	case BOTLIB_AI_LOAD_ITEM_WEIGHTS:
+		return botlib_export->ai.BotLoadItemWeights( args[1], (char *)VMA(2) );
+	case BOTLIB_AI_FREE_ITEM_WEIGHTS:
+		botlib_export->ai.BotFreeItemWeights( args[1] );
+		return 0;
+	case BOTLIB_AI_INTERBREED_GOAL_FUZZY_LOGIC:
+		botlib_export->ai.BotInterbreedGoalFuzzyLogic( args[1], args[2], args[3] );
+		return 0;
+	case BOTLIB_AI_SAVE_GOAL_FUZZY_LOGIC:
+		botlib_export->ai.BotSaveGoalFuzzyLogic( args[1], (char *)VMA(2) );
+		return 0;
+	case BOTLIB_AI_MUTATE_GOAL_FUZZY_LOGIC:
+		botlib_export->ai.BotMutateGoalFuzzyLogic( args[1], VMF(2) );
+		return 0;
+	case BOTLIB_AI_ALLOC_GOAL_STATE:
+		return botlib_export->ai.BotAllocGoalState( args[1] );
+	case BOTLIB_AI_FREE_GOAL_STATE:
+		botlib_export->ai.BotFreeGoalState( args[1] );
+		return 0;
+
+	case BOTLIB_AI_RESET_MOVE_STATE:
+		botlib_export->ai.BotResetMoveState( args[1] );
+		return 0;
+	case BOTLIB_AI_ADD_AVOID_SPOT:
+		botlib_export->ai.BotAddAvoidSpot( args[1], (float *)VMA(2), VMF(3), args[4] );
+		return 0;
+	case BOTLIB_AI_MOVE_TO_GOAL:
+		botlib_export->ai.BotMoveToGoal( (struct bot_moveresult_s *)VMA(1), args[2], (struct bot_goal_s *)VMA(3), args[4] );
+		return 0;
+	case BOTLIB_AI_MOVE_IN_DIRECTION:
+		return botlib_export->ai.BotMoveInDirection( args[1], (float *)VMA(2), VMF(3), args[4] );
+	case BOTLIB_AI_RESET_AVOID_REACH:
+		botlib_export->ai.BotResetAvoidReach( args[1] );
+		return 0;
+	case BOTLIB_AI_RESET_LAST_AVOID_REACH:
+		botlib_export->ai.BotResetLastAvoidReach( args[1] );
+		return 0;
+	case BOTLIB_AI_REACHABILITY_AREA:
+		return botlib_export->ai.BotReachabilityArea( (float *)VMA(1), args[2] );
+	case BOTLIB_AI_MOVEMENT_VIEW_TARGET:
+		return botlib_export->ai.BotMovementViewTarget( args[1], (struct bot_goal_s *)VMA(2), args[3], VMF(4), (float *)VMA(5) );
+	case BOTLIB_AI_PREDICT_VISIBLE_POSITION:
+		return botlib_export->ai.BotPredictVisiblePosition( (float *)VMA(1), args[2], (struct bot_goal_s *)VMA(3), args[4], (float *)VMA(5) );
+	case BOTLIB_AI_ALLOC_MOVE_STATE:
+		return botlib_export->ai.BotAllocMoveState();
+	case BOTLIB_AI_FREE_MOVE_STATE:
+		botlib_export->ai.BotFreeMoveState( args[1] );
+		return 0;
+	case BOTLIB_AI_INIT_MOVE_STATE:
+		botlib_export->ai.BotInitMoveState( args[1], (struct bot_initmove_s *)VMA(2) );
+		return 0;
+
+	case BOTLIB_AI_CHOOSE_BEST_FIGHT_WEAPON:
+		return botlib_export->ai.BotChooseBestFightWeapon( args[1], (int *)VMA(2) );
+	case BOTLIB_AI_GET_WEAPON_INFO:
+		botlib_export->ai.BotGetWeaponInfo( args[1], args[2], (struct weaponinfo_s *)VMA(3) );
+		return 0;
+	case BOTLIB_AI_LOAD_WEAPON_WEIGHTS:
+		return botlib_export->ai.BotLoadWeaponWeights( args[1], (char *)VMA(2) );
+	case BOTLIB_AI_ALLOC_WEAPON_STATE:
+		return botlib_export->ai.BotAllocWeaponState();
+	case BOTLIB_AI_FREE_WEAPON_STATE:
+		botlib_export->ai.BotFreeWeaponState( args[1] );
+		return 0;
+	case BOTLIB_AI_RESET_WEAPON_STATE:
+		botlib_export->ai.BotResetWeaponState( args[1] );
+		return 0;
+
+	case BOTLIB_AI_GENETIC_PARENTS_AND_CHILD_SELECTION:
+		return botlib_export->ai.GeneticParentsAndChildSelection(args[1], (float *)VMA(2), (int *)VMA(3), (int *)VMA(4), (int *)VMA(5));
+
+	case G_R_REGISTERSKIN:
+		return RE_RegisterServerSkin((const char *)VMA(1));
+
+	case G_G2_LISTBONES:
+		G2API_ListBones( (CGhoul2Info *) VMA(1), args[2]);
+		return 0;
+
+	case G_G2_LISTSURFACES:
+		G2API_ListSurfaces( (CGhoul2Info *) args[1] );
+		return 0;
+
+	case G_G2_HAVEWEGHOULMODELS:
+		return G2API_HaveWeGhoul2Models( *((CGhoul2Info_v *)args[1]) );
+
+	case G_G2_SETMODELS:
+		G2API_SetGhoul2ModelIndexes( *((CGhoul2Info_v *)args[1]),(qhandle_t *)VMA(2),(qhandle_t *)VMA(3));
+		return 0;
+
+	case G_G2_GETBOLT:
+		return G2API_GetBoltMatrix(*((CGhoul2Info_v *)args[1]), args[2], args[3], (mdxaBone_t *)VMA(4), (const float *)VMA(5),(const float *)VMA(6), args[7], (qhandle_t *)VMA(8), (float *)VMA(9));
+
+	case G_G2_GETBOLT_NOREC:
+		gG2_GBMNoReconstruct = qtrue;
+		return G2API_GetBoltMatrix(*((CGhoul2Info_v *)args[1]), args[2], args[3], (mdxaBone_t *)VMA(4), (const float *)VMA(5),(const float *)VMA(6), args[7], (qhandle_t *)VMA(8), (float *)VMA(9));
+
+	case G_G2_GETBOLT_NOREC_NOROT:
+		gG2_GBMNoReconstruct = qtrue;
+		gG2_GBMUseSPMethod = qtrue;
+		return G2API_GetBoltMatrix(*((CGhoul2Info_v *)args[1]), args[2], args[3], (mdxaBone_t *)VMA(4), (const float *)VMA(5),(const float *)VMA(6), args[7], (qhandle_t *)VMA(8), (float *)VMA(9));
+
+	case G_G2_INITGHOUL2MODEL:
+#ifdef _FULL_G2_LEAK_CHECKING
+		g_G2AllocServer = 1;
+#endif
+		return	G2API_InitGhoul2Model((CGhoul2Info_v **)VMA(1), (const char *)VMA(2), args[3], (qhandle_t) args[4],
+									  (qhandle_t) args[5], args[6], args[7]);
+
+	case G_G2_SETSKIN:
+		{
+			CGhoul2Info_v &g2 = *((CGhoul2Info_v *)args[1]);
+			int modelIndex = args[2];
+			
+			return G2API_SetSkin(&g2[modelIndex], args[3], args[4]);
+		}
+
+	case G_G2_SIZE:
+		return G2API_Ghoul2Size ( *((CGhoul2Info_v *)args[1]) );
+		break;
+
+	case G_G2_ADDBOLT:
+		return	G2API_AddBolt(*((CGhoul2Info_v *)args[1]), args[2], (const char *)VMA(3));
+
+	case G_G2_SETBOLTINFO:
+		G2API_SetBoltInfo(*((CGhoul2Info_v *)args[1]), args[2], args[3]);
+		return 0;
+
+	case G_G2_ANGLEOVERRIDE:
+		return G2API_SetBoneAngles(*((CGhoul2Info_v *)args[1]), args[2], (const char *)VMA(3), (float *)VMA(4), args[5],
+							 (const Eorientations) args[6], (const Eorientations) args[7], (const Eorientations) args[8],
+							 (qhandle_t *)VMA(9), args[10], args[11] );
+	
+	case G_G2_PLAYANIM:
+		return G2API_SetBoneAnim(*((CGhoul2Info_v *)args[1]), args[2], (const char *)VMA(3), args[4], args[5],
+								args[6], VMF(7), args[8], VMF(9), args[10]);
+
+	case G_G2_GETBONEANIM:
+		{
+			CGhoul2Info_v &g2 = *((CGhoul2Info_v *)args[1]);
+			int modelIndex = args[10];
+
+			return G2API_GetBoneAnim(&g2[modelIndex], (const char*)VMA(2), args[3], (float *)VMA(4), (int *)VMA(5),
+								(int *)VMA(6), (int *)VMA(7), (float *)VMA(8), (int *)VMA(9));
+		}
+
+	case G_G2_GETGLANAME:
+		//return (int)G2API_GetGLAName(*((CGhoul2Info_v *)args[1]), args[2]);
+		{ //Since returning a pointer in such a way to a VM seems to cause MASSIVE FAILURE<tm>, we will shove data into the pointer the vm passes instead
+			char *point = ((char *)VMA(3));
+			char *local;
+			local = G2API_GetGLAName(*((CGhoul2Info_v *)args[1]), args[2]);
+			if (local)
+			{
+				strcpy(point, local);
+			}
+		}
+
+		return 0;
+
+	case G_G2_COPYGHOUL2INSTANCE:
+		return (int)G2API_CopyGhoul2Instance(*((CGhoul2Info_v *)args[1]), *((CGhoul2Info_v *)args[2]), args[3]);
+
+	case G_G2_COPYSPECIFICGHOUL2MODEL:
+		G2API_CopySpecificG2Model(*((CGhoul2Info_v *)args[1]), args[2], *((CGhoul2Info_v *)args[3]), args[4]);
+		return 0;
+
+	case G_G2_DUPLICATEGHOUL2INSTANCE:
+#ifdef _FULL_G2_LEAK_CHECKING
+		g_G2AllocServer = 1;
+#endif
+		G2API_DuplicateGhoul2Instance(*((CGhoul2Info_v *)args[1]), (CGhoul2Info_v **)VMA(2));
+		return 0;
+
+	case G_G2_HASGHOUL2MODELONINDEX:
+		//return (int)G2API_HasGhoul2ModelOnIndex((CGhoul2Info_v **)args[1], args[2]);
+		return (int)G2API_HasGhoul2ModelOnIndex((CGhoul2Info_v **)VMA(1), args[2]);
+
+	case G_G2_REMOVEGHOUL2MODEL:
+#ifdef _FULL_G2_LEAK_CHECKING
+		g_G2AllocServer = 1;
+#endif
+		//return (int)G2API_RemoveGhoul2Model((CGhoul2Info_v **)args[1], args[2]);
+		return (int)G2API_RemoveGhoul2Model((CGhoul2Info_v **)VMA(1), args[2]);
+
+	case G_G2_REMOVEGHOUL2MODELS:
+#ifdef _FULL_G2_LEAK_CHECKING
+		g_G2AllocServer = 1;
+#endif
+		//return (int)G2API_RemoveGhoul2Models((CGhoul2Info_v **)args[1]);
+		return (int)G2API_RemoveGhoul2Models((CGhoul2Info_v **)VMA(1));
+
+	case G_G2_CLEANMODELS:
+#ifdef _FULL_G2_LEAK_CHECKING
+		g_G2AllocServer = 1;
+#endif
+		G2API_CleanGhoul2Models((CGhoul2Info_v **)VMA(1));
+	//	G2API_CleanGhoul2Models((CGhoul2Info_v **)args[1]);
+		return 0;
+
+	case G_G2_COLLISIONDETECT:
+		G2API_CollisionDetect ( (CollisionRecord_t*)VMA(1), *((CGhoul2Info_v *)args[2]), 
+								   (const float*)VMA(3),
+								   (const float*)VMA(4),
+								   args[5],
+								   args[6],
+								   (float*)VMA(7),
+								   (float*)VMA(8),
+								   (float*)VMA(9),
+								   G2VertSpaceServer,
+								   args[10],
+								   args[11],
+								   VMF(12) );
+		return 0;
+	
+	case G_G2_SETROOTSURFACE:
+		return G2API_SetRootSurface(*((CGhoul2Info_v *)args[1]), args[2], (const char *)VMA(3));
+
+	case G_G2_SETSURFACEONOFF:
+		return G2API_SetSurfaceOnOff(*((CGhoul2Info_v *)args[1]), (const char *)VMA(2), /*(const int)VMA(3)*/args[3]);
+
+	case G_G2_SETNEWORIGIN:
+		return G2API_SetNewOrigin(*((CGhoul2Info_v *)args[1]), /*(const int)VMA(2)*/args[2]);
+
+	case G_G2_DOESBONEEXIST:
+		{
+			CGhoul2Info_v &g2 = *((CGhoul2Info_v *)args[1]);
+			return G2API_DoesBoneExist(&g2[args[2]], (const char *)VMA(3));
+		}
+
+	case G_G2_GETSURFACERENDERSTATUS:
+	{
+		CGhoul2Info_v &g2 = *((CGhoul2Info_v *)args[1]);
+
+		return G2API_GetSurfaceRenderStatus(&g2[args[2]], (const char *)VMA(3));
+	}
+
+	case G_G2_ABSURDSMOOTHING:
+		{
+			CGhoul2Info_v &g2 = *((CGhoul2Info_v *)args[1]);
+
+			G2API_AbsurdSmoothing(g2, (qboolean)args[2]);
+		}
+		return 0;
+
+	case G_G2_SETRAGDOLL:
+		{
+			//Convert the info in the shared structure over to the class-based version.
+			sharedRagDollParams_t *rdParamst = (sharedRagDollParams_t *)VMA(2);
+			CRagDollParams rdParams;
+
+			if (!rdParamst)
+			{
+				G2API_ResetRagDoll(*((CGhoul2Info_v *)args[1]));
+				return 0;
+			}
+
+			VectorCopy(rdParamst->angles, rdParams.angles);
+			VectorCopy(rdParamst->position, rdParams.position);
+			VectorCopy(rdParamst->scale, rdParams.scale);
+			VectorCopy(rdParamst->pelvisAnglesOffset, rdParams.pelvisAnglesOffset);
+			VectorCopy(rdParamst->pelvisPositionOffset, rdParams.pelvisPositionOffset);
+
+			rdParams.fImpactStrength = rdParamst->fImpactStrength;
+			rdParams.fShotStrength = rdParamst->fShotStrength;
+			rdParams.me = rdParamst->me;
+
+			rdParams.startFrame = rdParamst->startFrame;
+			rdParams.endFrame = rdParamst->endFrame;
+
+			rdParams.collisionType = rdParamst->collisionType;
+			rdParams.CallRagDollBegin = rdParamst->CallRagDollBegin;
+
+			rdParams.RagPhase = (CRagDollParams::ERagPhase)rdParamst->RagPhase;
+			rdParams.effectorsToTurnOff = (CRagDollParams::ERagEffector)rdParamst->effectorsToTurnOff;
+
+			G2API_SetRagDoll(*((CGhoul2Info_v *)args[1]), &rdParams);
+		}
+		return 0;
+		break;
+	case G_G2_ANIMATEG2MODELS:
+		{
+			sharedRagDollUpdateParams_t *rduParamst = (sharedRagDollUpdateParams_t *)VMA(3);
+			CRagDollUpdateParams rduParams;
+
+			if (!rduParamst)
+			{
+				return 0;
+			}
+
+			VectorCopy(rduParamst->angles, rduParams.angles);
+			VectorCopy(rduParamst->position, rduParams.position);
+			VectorCopy(rduParamst->scale, rduParams.scale);
+			VectorCopy(rduParamst->velocity, rduParams.velocity);
+
+			rduParams.me = rduParamst->me;
+			rduParams.settleFrame = rduParamst->settleFrame;
+
+			G2API_AnimateG2Models(*((CGhoul2Info_v *)args[1]), args[2], &rduParams);
+		}
+		return 0;
+		break;
+
+	//additional ragdoll options -rww
+	case G_G2_RAGPCJCONSTRAINT:
+		return G2API_RagPCJConstraint(*((CGhoul2Info_v *)args[1]), (const char *)VMA(2), (float *)VMA(3), (float *)VMA(4));
+	case G_G2_RAGPCJGRADIENTSPEED:
+		return G2API_RagPCJGradientSpeed(*((CGhoul2Info_v *)args[1]), (const char *)VMA(2), VMF(3));
+	case G_G2_RAGEFFECTORGOAL:
+		return G2API_RagEffectorGoal(*((CGhoul2Info_v *)args[1]), (const char *)VMA(2), (float *)VMA(3));
+	case G_G2_GETRAGBONEPOS:
+		return G2API_GetRagBonePos(*((CGhoul2Info_v *)args[1]), (const char *)VMA(2), (float *)VMA(3), (float *)VMA(4), (float *)VMA(5), (float *)VMA(6));
+	case G_G2_RAGEFFECTORKICK:
+		return G2API_RagEffectorKick(*((CGhoul2Info_v *)args[1]), (const char *)VMA(2), (float *)VMA(3));
+	case G_G2_RAGFORCESOLVE:
+		return G2API_RagForceSolve(*((CGhoul2Info_v *)args[1]), (qboolean)args[2]);
+
+	case G_G2_SETBONEIKSTATE:
+		return G2API_SetBoneIKState(*((CGhoul2Info_v *)args[1]), args[2], (const char *)VMA(3), args[4], (sharedSetBoneIKStateParams_t *)VMA(5));
+	case G_G2_IKMOVE:
+		return G2API_IKMove(*((CGhoul2Info_v *)args[1]), args[2], (sharedIKMoveParams_t *)VMA(3));
+
+	case G_G2_REMOVEBONE:
+		{
+			CGhoul2Info_v &g2 = *((CGhoul2Info_v *)args[1]);
+
+			return G2API_RemoveBone(&g2[args[3]], (const char *)VMA(2));
+		}
+
+	case G_G2_ATTACHINSTANCETOENTNUM:
+		{
+			G2API_AttachInstanceToEntNum(*((CGhoul2Info_v *)args[1]), args[2], (qboolean)args[3]);
+		}
+		return 0;
+	case G_G2_CLEARATTACHEDINSTANCE:
+		G2API_ClearAttachedInstance(args[1]);
+		return 0;
+	case G_G2_CLEANENTATTACHMENTS:
+		G2API_CleanEntAttachments();
+		return 0;
+	case G_G2_OVERRIDESERVER:
+		{
+			CGhoul2Info_v &g2 = *((CGhoul2Info_v *)args[1]);
+			return G2API_OverrideServerWithClientData(&g2[0]);
+		}
+
+	case G_G2_GETSURFACENAME:
+		{ //Since returning a pointer in such a way to a VM seems to cause MASSIVE FAILURE<tm>, we will shove data into the pointer the vm passes instead
+			char *point = ((char *)VMA(4));
+			char *local;
+			int modelindex = args[3];
+
+			CGhoul2Info_v &g2 = *((CGhoul2Info_v *)args[1]);
+
+			local = G2API_GetSurfaceName(&g2[modelindex], args[2]);
+			if (local)
+			{
+				strcpy(point, local);
+			}
+		}
+
+
+		return 0;
+
+	case G_SET_ACTIVE_SUBBSP:
+		SV_SetActiveSubBSP(args[1]);
+		return 0;
+
+	case G_RMG_INIT:
+		if (com_RMG && com_RMG->integer)
+		{
+			if (!TheRandomMissionManager)
+			{
+				TheRandomMissionManager = new CRMManager;
+			}
+			TheRandomMissionManager->SetLandScape(cmg.landScape);
+			if (TheRandomMissionManager->LoadMission(qtrue))
+			{
+				TheRandomMissionManager->SpawnMission(qtrue);
+			}
+//			cmg.landScape->UpdatePatches();
+		}
+		return 0;
+
+	case G_CM_REGISTER_TERRAIN:
+		return CM_RegisterTerrain((const char *)VMA(1), true)->GetTerrainId();
+
+	case G_BOT_UPDATEWAYPOINTS:
+		SV_BotWaypointReception(args[1], (wpobject_t **)VMA(2));
+		return 0;
+	case G_BOT_CALCULATEPATHS:
+		SV_BotCalculatePaths(args[1]);
+		return 0;
+
+	case G_GET_ENTITY_TOKEN:
+		return SV_GetEntityToken((char *)VMA(1), args[2]);
+
+	default:
+		Com_Error( ERR_DROP, "Bad game system trap: %i", args[0] );
+	}
+	return -1;
+}
+
+/*
+===============
+SV_ShutdownGameProgs
+
+Called every time a map changes
+===============
+*/
+void SV_ShutdownGameProgs( void ) {
+	if ( !gvm ) {
+		return;
+	}
+	VM_Call( gvm, GAME_SHUTDOWN, qfalse );
+	VM_Free( gvm );
+	gvm = NULL;
+}
+
+/*
+==================
+SV_InitGameVM
+
+Called for both a full init and a restart
+==================
+*/
+static void SV_InitGameVM( qboolean restart ) {
+	int		i;
+
+	// start the entity parsing at the beginning
+	sv.entityParsePoint = CM_EntityString();
+
+	// use the current msec count for a random seed
+	// init for this gamestate
+	VM_Call( gvm, GAME_INIT, svs.time, Com_Milliseconds(), restart );
+
+	// clear all gentity pointers that might still be set from
+	// a previous level
+	for ( i = 0 ; i < sv_maxclients->integer ; i++ ) {
+		svs.clients[i].gentity = NULL;
+	}
+}
+
+
+
+/*
+===================
+SV_RestartGameProgs
+
+Called on a map_restart, but not on a normal map change
+===================
+*/
+void SV_RestartGameProgs( void ) {
+	if ( !gvm ) {
+		return;
+	}
+	VM_Call( gvm, GAME_SHUTDOWN, qtrue );
+
+	// do a restart instead of a free
+	gvm = VM_Restart( gvm );
+	if ( !gvm ) { // bk001212 - as done below
+		Com_Error( ERR_FATAL, "VM_Restart on game failed" );
+	}
+
+	SV_InitGameVM( qtrue );
+}
+
+
+/*
+===============
+SV_InitGameProgs
+
+Called on a normal map change, not on a map_restart
+===============
+*/
+void SV_InitGameProgs( void ) {
+	cvar_t	*var;
+	//FIXME these are temp while I make bots run in vm
+	extern int	bot_enable;
+
+	var = Cvar_Get( "bot_enable", "1", CVAR_LATCH );
+	if ( var ) {
+		bot_enable = var->integer;
+	}
+	else {
+		bot_enable = 0;
+	}
+
+	if ( !Cvar_VariableValue("fs_restrict") && !com_dedicated->integer && !Sys_CheckCD() ) 
+	{
+		Com_Error( ERR_NEED_CD, SE_GetString("CON_TEXT_NEED_CD") ); //"Game CD not in drive" );		
+	}
+
+	// load the dll or bytecode
+	gvm = VM_Create( "jampgame", SV_GameSystemCalls, (vmInterpret_t)(int)Cvar_VariableValue( "vm_game" ) );
+	if ( !gvm ) {
+		Com_Error( ERR_FATAL, "VM_Create on game failed" );
+	}
+
+	SV_InitGameVM( qfalse );
+}
+
+
+/*
+====================
+SV_GameCommand
+
+See if the current console command is claimed by the game
+====================
+*/
+qboolean SV_GameCommand( void ) {
+	if ( sv.state != SS_GAME ) {
+		return qfalse;
+	}
+
+	return (qboolean)VM_Call( gvm, GAME_CONSOLE_COMMAND );
+}
+
diff --git a/codemp/server/sv_init.cpp b/codemp/server/sv_init.cpp
new file mode 100644
index 0000000..647666d
--- /dev/null
+++ b/codemp/server/sv_init.cpp
@@ -0,0 +1,988 @@
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+#include "server.h"
+
+/*
+Ghoul2 Insert Start
+*/
+#if !defined(TR_LOCAL_H)
+	#include "../renderer/tr_local.h"
+#endif
+
+#if !defined (MINIHEAP_H_INC)
+#include "../qcommon/MiniHeap.h"
+#endif
+
+#include "../qcommon/stringed_ingame.h"
+
+/*
+===============
+SV_SetConfigstring
+
+===============
+*/
+void SV_SetConfigstring (int index, const char *val) {
+	int		len, i;
+	int		maxChunkSize = MAX_STRING_CHARS - 24;
+	client_t	*client;
+
+	if ( index < 0 || index >= MAX_CONFIGSTRINGS ) {
+		Com_Error (ERR_DROP, "SV_SetConfigstring: bad index %i\n", index);
+	}
+
+	if ( !val ) {
+		val = "";
+	}
+
+	// don't bother broadcasting an update if no change
+	if ( !strcmp( val, sv.configstrings[ index ] ) ) {
+		return;
+	}
+
+	// change the string in sv
+	Z_Free( sv.configstrings[index] );
+	sv.configstrings[index] = CopyString( val );
+
+	// send it to all the clients if we aren't
+	// spawning a new server
+	if ( sv.state == SS_GAME || sv.restarting ) {
+
+		// send the data to all relevent clients
+		for (i = 0, client = svs.clients; i < sv_maxclients->integer ; i++, client++) {
+			if ( client->state < CS_PRIMED ) {
+				continue;
+			}
+			// do not always send server info to all clients
+			if ( index == CS_SERVERINFO && client->gentity && (client->gentity->r.svFlags & SVF_NOSERVERINFO) ) {
+				continue;
+			}
+
+			len = strlen( val );
+			if( len >= maxChunkSize ) {
+				int		sent = 0;
+				int		remaining = len;
+				char	*cmd;
+				char	buf[MAX_STRING_CHARS];
+
+				while (remaining > 0 ) {
+					if ( sent == 0 ) {
+						cmd = "bcs0";
+					}
+					else if( remaining < maxChunkSize ) {
+						cmd = "bcs2";
+					}
+					else {
+						cmd = "bcs1";
+					}
+					Q_strncpyz( buf, &val[sent], maxChunkSize );
+
+					SV_SendServerCommand( client, "%s %i \"%s\"\n", cmd, index, buf );
+
+					sent += (maxChunkSize - 1);
+					remaining -= (maxChunkSize - 1);
+				}
+			} else {
+				// standard cs, just send it
+				SV_SendServerCommand( client, "cs %i \"%s\"\n", index, val );
+			}
+		}
+	}
+}
+
+
+
+/*
+===============
+SV_GetConfigstring
+
+===============
+*/
+void SV_GetConfigstring( int index, char *buffer, int bufferSize ) {
+	if ( bufferSize < 1 ) {
+		Com_Error( ERR_DROP, "SV_GetConfigstring: bufferSize == %i", bufferSize );
+	}
+	if ( index < 0 || index >= MAX_CONFIGSTRINGS ) {
+		Com_Error (ERR_DROP, "SV_GetConfigstring: bad index %i\n", index);
+	}
+	if ( !sv.configstrings[index] ) {
+		buffer[0] = 0;
+		return;
+	}
+
+	Q_strncpyz( buffer, sv.configstrings[index], bufferSize );
+}
+
+
+/*
+================
+SV_AddConfigstring
+
+================
+*/
+int SV_AddConfigstring (const char *name, int start, int max)
+{
+	int		i;
+	
+	if (!name || !name[0])
+	{
+		return 0;
+	}
+
+	if (name[0] == '/' || name[0] == '\\')
+	{
+#if _DEBUG
+		Com_DPrintf( "WARNING: Leading slash on '%s'\n", name);
+#endif
+		name++;
+
+		if (!name[0])
+		{
+			return 0;
+		}
+	}
+
+	for (i=1 ; i < max ; i++)
+	{
+		if (sv.configstrings[start+i][0] == 0)
+		{	// Didn't find it
+			SV_SetConfigstring ((start+i), name);
+			break;
+		}
+		else if (!Q_stricmp(sv.configstrings[start+i], name))
+		{
+			return i;
+		}
+	}
+
+	return 0;
+
+}
+
+/*
+===============
+SV_SetUserinfo
+
+===============
+*/
+void SV_SetUserinfo( int index, const char *val ) {
+	if ( index < 0 || index >= sv_maxclients->integer ) {
+		Com_Error (ERR_DROP, "SV_SetUserinfo: bad index %i\n", index);
+	}
+
+	if ( !val ) {
+		val = "";
+	}
+
+	Q_strncpyz( svs.clients[index].userinfo, val, sizeof( svs.clients[ index ].userinfo ) );
+	Q_strncpyz( svs.clients[index].name, Info_ValueForKey( val, "name" ), sizeof(svs.clients[index].name) );
+}
+
+
+
+/*
+===============
+SV_GetUserinfo
+
+===============
+*/
+void SV_GetUserinfo( int index, char *buffer, int bufferSize ) {
+	if ( bufferSize < 1 ) {
+		Com_Error( ERR_DROP, "SV_GetUserinfo: bufferSize == %i", bufferSize );
+	}
+	if ( index < 0 || index >= sv_maxclients->integer ) {
+		Com_Error (ERR_DROP, "SV_GetUserinfo: bad index %i\n", index);
+	}
+	Q_strncpyz( buffer, svs.clients[ index ].userinfo, bufferSize );
+}
+
+
+/*
+================
+SV_CreateBaseline
+
+Entity baselines are used to compress non-delta messages
+to the clients -- only the fields that differ from the
+baseline will be transmitted
+================
+*/
+void SV_CreateBaseline( void ) {
+	sharedEntity_t *svent;
+	int				entnum;	
+
+	for ( entnum = 1; entnum < sv.num_entities ; entnum++ ) {
+		svent = SV_GentityNum(entnum);
+		if (!svent->r.linked) {
+			continue;
+		}
+		svent->s.number = entnum;
+
+		//
+		// take current state as baseline
+		//
+		sv.svEntities[entnum].baseline = svent->s;
+	}
+}
+
+
+/*
+===============
+SV_BoundMaxClients
+
+===============
+*/
+void SV_BoundMaxClients( int minimum ) {
+	// get the current maxclients value
+	Cvar_Get( "sv_maxclients", "8", 0 );
+
+	sv_maxclients->modified = qfalse;
+
+	if ( sv_maxclients->integer < minimum ) {
+		Cvar_Set( "sv_maxclients", va("%i", minimum) );
+	} else if ( sv_maxclients->integer > MAX_CLIENTS ) {
+		Cvar_Set( "sv_maxclients", va("%i", MAX_CLIENTS) );
+	}
+}
+
+
+/*
+===============
+SV_Startup
+
+Called when a host starts a map when it wasn't running
+one before.  Successive map or map_restart commands will
+NOT cause this to be called, unless the game is exited to
+the menu system first.
+===============
+*/
+void SV_Startup( void ) {
+	if ( svs.initialized ) {
+		Com_Error( ERR_FATAL, "SV_Startup: svs.initialized" );
+	}
+	SV_BoundMaxClients( 1 );
+
+	svs.clients = (struct client_s *)Z_Malloc (sizeof(client_t) * sv_maxclients->integer, TAG_CLIENTS, qtrue );
+	if ( com_dedicated->integer ) {
+		svs.numSnapshotEntities = sv_maxclients->integer * PACKET_BACKUP * 64;
+		Cvar_Set( "r_ghoul2animsmooth", "0");
+		Cvar_Set( "r_ghoul2unsqashaftersmooth", "0");
+
+	} else {
+		// we don't need nearly as many when playing locally
+		svs.numSnapshotEntities = sv_maxclients->integer * 4 * 64;
+	}
+	svs.initialized = qtrue;
+
+	Cvar_Set( "sv_running", "1" );
+
+}
+
+/*
+Ghoul2 Insert Start
+*/
+
+ void SV_InitSV(void)
+{
+	// clear out most of the sv struct
+	memset(&sv, 0, (sizeof(sv)));
+	sv.mLocalSubBSPIndex = -1;
+}
+/*
+Ghoul2 Insert End
+*/
+
+/*
+==================
+SV_ChangeMaxClients
+==================
+*/
+void SV_ChangeMaxClients( void ) {
+	int		oldMaxClients;
+	int		i;
+	client_t	*oldClients;
+	int		count;
+
+	// get the highest client number in use
+	count = 0;
+	for ( i = 0 ; i < sv_maxclients->integer ; i++ ) {
+		if ( svs.clients[i].state >= CS_CONNECTED ) {
+			if (i > count)
+				count = i;
+		}
+	}
+	count++;
+
+	oldMaxClients = sv_maxclients->integer;
+	// never go below the highest client number in use
+	SV_BoundMaxClients( count );
+	// if still the same
+	if ( sv_maxclients->integer == oldMaxClients ) {
+		return;
+	}
+
+	oldClients = (struct client_s *)Hunk_AllocateTempMemory( count * sizeof(client_t) );
+	// copy the clients to hunk memory
+	for ( i = 0 ; i < count ; i++ ) {
+		if ( svs.clients[i].state >= CS_CONNECTED ) {
+			oldClients[i] = svs.clients[i];
+		}
+		else {
+			Com_Memset(&oldClients[i], 0, sizeof(client_t));
+		}
+	}
+
+	// free old clients arrays
+	Z_Free( svs.clients );
+
+	// allocate new clients
+	svs.clients = (struct client_s *)Z_Malloc ( sv_maxclients->integer * sizeof(client_t), TAG_CLIENTS, qtrue );
+	Com_Memset( svs.clients, 0, sv_maxclients->integer * sizeof(client_t) );
+
+	// copy the clients over
+	for ( i = 0 ; i < count ; i++ ) {
+		if ( oldClients[i].state >= CS_CONNECTED ) {
+			svs.clients[i] = oldClients[i];
+		}
+	}
+
+	// free the old clients on the hunk
+	Hunk_FreeTempMemory( oldClients );
+	
+	// allocate new snapshot entities
+	if ( com_dedicated->integer ) {
+		svs.numSnapshotEntities = sv_maxclients->integer * PACKET_BACKUP * 64;
+	} else {
+		// we don't need nearly as many when playing locally
+		svs.numSnapshotEntities = sv_maxclients->integer * 4 * 64;
+	}
+}
+
+/*
+================
+SV_ClearServer
+================
+*/
+void SV_ClearServer(void) {
+	int i;
+
+	for ( i = 0 ; i < MAX_CONFIGSTRINGS ; i++ ) {
+		if ( sv.configstrings[i] ) {
+			Z_Free( sv.configstrings[i] );
+		}
+	}
+
+//	CM_ClearMap();
+
+	/*
+Ghoul2 Insert Start
+*/
+
+	// nope, can't do this anymore.. sv contains entitystates with STL in them.
+//	memset (&sv, 0, sizeof(sv));
+ 	SV_InitSV();
+/*
+Ghoul2 Insert End
+*/
+//	Com_Memset (&sv, 0, sizeof(sv));
+}
+
+/*
+================
+SV_TouchCGame
+
+  touch the cgame.vm so that a pure client can load it if it's in a seperate pk3
+================
+*/
+void SV_TouchCGame(void) {
+	fileHandle_t	f;
+	char filename[MAX_QPATH];
+
+	if (Cvar_VariableValue( "vm_cgame" ))
+	{
+		Com_sprintf( filename, sizeof(filename), "vm/%s.qvm", "cgame" );
+	}
+	else
+	{
+		Com_sprintf( filename, sizeof(filename), "cgamex86.dll" );
+	}
+	FS_FOpenFileRead( filename, &f, qfalse );
+	if ( f ) {
+		FS_FCloseFile( f );
+	}
+}
+
+void SV_SendMapChange(void)
+{
+	int		i;
+
+	if (svs.clients)
+	{
+		for (i=0 ; i<sv_maxclients->integer ; i++) 
+		{
+			if (svs.clients[i].state >= CS_CONNECTED) 
+			{
+				if ( svs.clients[i].netchan.remoteAddress.type != NA_BOT ) 
+				{
+					SV_SendClientMapChange( &svs.clients[i] ) ;
+				}
+			}
+		}	
+	}
+}
+
+void R_SVModelInit();
+
+
+#ifdef _XBOX
+//To avoid fragmentation, we want everything free by this point.
+//Much of this probably violates DLL boundaries, so it's done on
+//Xbox only.
+extern void NAV_Free(void);
+extern void CL_ClearLastLevel(void);
+void SV_ClearLastLevel(void)
+{
+	CL_ClearLastLevel();
+	NAV_Free();
+
+	int i;
+	for ( i = 0 ; i < MAX_CONFIGSTRINGS ; i++ ) {
+		if ( sv.configstrings[i] ) {
+			Z_Free( sv.configstrings[i] );
+			sv.configstrings[i] = NULL;
+		}
+	}
+
+}
+#endif
+
+
+/*
+================
+SV_SpawnServer
+
+Change the server to a new map, taking all connected
+clients along with it.
+This is NOT called for map_restart
+================
+*/
+extern CMiniHeap *G2VertSpaceServer;
+extern CMiniHeap CMiniHeap_singleton;
+
+extern void RE_RegisterMedia_LevelLoadBegin(const char *psMapName, ForceReload_e eForceReload);
+void SV_SpawnServer( char *server, qboolean killBots, ForceReload_e eForceReload ) {
+	int			i;
+	int			checksum;
+	qboolean	isBot;
+	char		systemInfo[16384];
+	const char	*p;
+
+	SV_SendMapChange();
+
+	RE_RegisterMedia_LevelLoadBegin(server, eForceReload);
+
+	// shut down the existing game if it is running
+	SV_ShutdownGameProgs();
+
+	Com_Printf ("------ Server Initialization ------\n");
+	Com_Printf ("Server: %s\n",server);
+
+/*
+Ghoul2 Insert Start
+*/
+ 	// de allocate the snapshot entities 
+	if (svs.snapshotEntities)
+	{
+		delete[] svs.snapshotEntities;
+		svs.snapshotEntities = NULL;
+	}
+/*
+Ghoul2 Insert End
+*/
+
+	SV_SendMapChange();
+
+#ifdef _XBOX
+	// disable vsync during load for speed
+	qglDisable(GL_VSYNC);
+#endif
+
+	// if not running a dedicated server CL_MapLoading will connect the client to the server
+	// also print some status stuff
+	CL_MapLoading();
+
+#ifndef DEDICATED
+	// make sure all the client stuff is unloaded
+	CL_ShutdownAll();
+#endif
+
+	CM_ClearMap();
+
+#ifdef _XBOX
+//	extern qboolean RE_RegisterImages_LevelLoadEnd(void);
+//	RE_RegisterImages_LevelLoadEnd();
+	R_DeleteTextures();
+#endif
+
+	// clear the whole hunk because we're (re)loading the server
+	Hunk_Clear();
+
+#ifdef _XBOX
+	SV_ClearLastLevel();
+#endif
+
+	R_InitSkins();
+	R_InitShaders(qtrue);
+
+#if defined(_XBOX) && defined(_DEBUG)
+	//Useful for memory debugging.  Please don't delete.  Comment out if
+	//necessary.
+	extern void Z_DisplayLevelMemory(int, int, int);
+	extern void Z_Details_f(void);
+	extern void Z_TagPointers(memtag_t);
+	Z_DisplayLevelMemory(0, 0, 0);
+	Z_Details_f();
+#endif
+
+	// init client structures and svs.numSnapshotEntities 
+	if ( !Cvar_VariableValue("sv_running") ) {
+		SV_Startup();
+	} else {
+		// check for maxclients change
+		if ( sv_maxclients->modified ) {
+			SV_ChangeMaxClients();
+		}
+	}
+
+	SV_SendMapChange();
+
+/*
+Ghoul2 Insert Start
+*/
+ 	// clear out those shaders, images and Models as long as this 
+	// isnt a dedicated server.
+	/*
+	if ( !com_dedicated->integer )
+	{
+#ifndef DEDICATED
+		R_InitImages();
+
+		R_InitShaders();
+
+		R_ModelInit();
+#endif
+	}
+	else
+	*/
+	if (com_dedicated->integer)
+	{
+		R_SVModelInit();
+	}
+
+	SV_SendMapChange();
+
+	// clear pak references
+	FS_ClearPakReferences(0);
+
+/*
+Ghoul2 Insert Start
+*/
+	// allocate the snapshot entities on the hunk
+//	svs.snapshotEntities = (struct entityState_s *)Hunk_Alloc( sizeof(entityState_t)*svs.numSnapshotEntities, h_high );
+	svs.nextSnapshotEntities = 0;
+
+	// allocate the snapshot entities 
+	svs.snapshotEntities = new entityState_s[svs.numSnapshotEntities];
+	// we CAN afford to do this here, since we know the STL vectors in Ghoul2 are empty
+	memset(svs.snapshotEntities, 0, sizeof(entityState_t)*svs.numSnapshotEntities);
+
+/*
+Ghoul2 Insert End
+*/
+
+	// toggle the server bit so clients can detect that a
+	// server has changed
+	svs.snapFlagServerBit ^= SNAPFLAG_SERVERCOUNT;
+
+	// set nextmap to the same map, but it may be overriden
+	// by the game startup or another console command
+	Cvar_Set( "nextmap", "map_restart 0");
+//	Cvar_Set( "nextmap", va("map %s", server) );
+
+	// wipe the entire per-level structure
+	SV_ClearServer();
+	for ( i = 0 ; i < MAX_CONFIGSTRINGS ; i++ ) {
+		sv.configstrings[i] = CopyString("");
+	}
+
+	//rww - RAGDOLL_BEGIN
+	G2API_SetTime(svs.time,0);
+	//rww - RAGDOLL_END
+
+	// make sure we are not paused
+	Cvar_Set("cl_paused", "0");
+
+	// get a new checksum feed and restart the file system
+	srand(Com_Milliseconds());
+	sv.checksumFeed = ( ((int) rand() << 16) ^ rand() ) ^ Com_Milliseconds();
+	FS_Restart( sv.checksumFeed );
+
+#ifdef _XBOX
+	CL_StartHunkUsers();
+	CM_LoadMap( va("maps/%s.bsp", server), qfalse, &checksum );
+//	RE_LoadWorldMap(va("maps/%s.bsp", server));
+
+	// Start up voice system if it isn't running yet. (ie, if we're on syslink)
+	if( !logged_on )
+		g_Voice.Initialize();
+#else
+	CM_LoadMap( va("maps/%s.bsp", server), qfalse, &checksum );
+#endif
+
+	SV_SendMapChange();
+
+	// set serverinfo visible name
+	Cvar_Set( "mapname", server );
+
+	Cvar_Set( "sv_mapChecksum", va("%i",checksum) );
+
+	// serverid should be different each time
+	sv.serverId = com_frameTime;
+	sv.restartedServerId = sv.serverId;
+	Cvar_Set( "sv_serverid", va("%i", sv.serverId ) );
+
+	// clear physics interaction links
+	SV_ClearWorld ();
+	
+	// media configstring setting should be done during
+	// the loading stage, so connected clients don't have
+	// to load during actual gameplay
+	sv.state = SS_LOADING;
+
+	// load and spawn all other entities
+	SV_InitGameProgs();
+
+	// don't allow a map_restart if game is modified
+	sv_gametype->modified = qfalse;
+
+	// run a few frames to allow everything to settle
+	for ( i = 0 ;i < 3 ; i++ ) {
+		//rww - RAGDOLL_BEGIN
+		G2API_SetTime(svs.time,0);
+		//rww - RAGDOLL_END
+		VM_Call( gvm, GAME_RUN_FRAME, svs.time );
+		SV_BotFrame( svs.time );
+		svs.time += 100;
+	}
+	//rww - RAGDOLL_BEGIN
+	G2API_SetTime(svs.time,0);
+	//rww - RAGDOLL_END
+
+	// create a baseline for more efficient communications
+	SV_CreateBaseline ();
+
+	for (i=0 ; i<sv_maxclients->integer ; i++) {
+		// send the new gamestate to all connected clients
+		if (svs.clients[i].state >= CS_CONNECTED) {
+			char	*denied;
+
+			if ( svs.clients[i].netchan.remoteAddress.type == NA_BOT ) {
+				if ( killBots ) {
+					SV_DropClient( &svs.clients[i], "" );
+					continue;
+				}
+				isBot = qtrue;
+			}
+			else {
+				isBot = qfalse;
+			}
+
+			// connect the client again
+			denied = (char *)VM_ExplicitArgPtr( gvm, VM_Call( gvm, GAME_CLIENT_CONNECT, i, qfalse, isBot ) );	// firstTime = qfalse
+			if ( denied ) {
+				// this generally shouldn't happen, because the client
+				// was connected before the level change
+				SV_DropClient( &svs.clients[i], denied );
+			} else {
+				if( !isBot ) {
+					// when we get the next packet from a connected client,
+					// the new gamestate will be sent
+					svs.clients[i].state = CS_CONNECTED;
+				}
+				else {
+					client_t		*client;
+					sharedEntity_t	*ent;
+
+					client = &svs.clients[i];
+					client->state = CS_ACTIVE;
+					ent = SV_GentityNum( i );
+					ent->s.number = i;
+					client->gentity = ent;
+
+					client->deltaMessage = -1;
+					client->nextSnapshotTime = svs.time;	// generate a snapshot immediately
+
+					VM_Call( gvm, GAME_CLIENT_BEGIN, i );
+				}
+			}
+		}
+	}	
+
+	// run another frame to allow things to look at all the players
+	VM_Call( gvm, GAME_RUN_FRAME, svs.time );
+	SV_BotFrame( svs.time );
+	svs.time += 100;
+	//rww - RAGDOLL_BEGIN
+	G2API_SetTime(svs.time,0);
+	//rww - RAGDOLL_END
+
+	if ( sv_pure->integer ) {
+		// the server sends these to the clients so they will only
+		// load pk3s also loaded at the server
+		p = FS_LoadedPakChecksums();
+		Cvar_Set( "sv_paks", p );
+		if (strlen(p) == 0) {
+			Com_Printf( "WARNING: sv_pure set but no PK3 files loaded\n" );
+		}
+		p = FS_LoadedPakNames();
+		Cvar_Set( "sv_pakNames", p );
+
+		// if a dedicated pure server we need to touch the cgame because it could be in a
+		// seperate pk3 file and the client will need to load the latest cgame.qvm
+		if ( com_dedicated->integer ) {
+			SV_TouchCGame();
+		}
+	}
+	else {
+		Cvar_Set( "sv_paks", "" );
+		Cvar_Set( "sv_pakNames", "" );
+	}
+	// the server sends these to the clients so they can figure
+	// out which pk3s should be auto-downloaded
+	p = FS_ReferencedPakChecksums();
+	Cvar_Set( "sv_referencedPaks", p );
+	p = FS_ReferencedPakNames();
+	Cvar_Set( "sv_referencedPakNames", p );
+
+	// save systeminfo and serverinfo strings
+	Q_strncpyz( systemInfo, Cvar_InfoString_Big( CVAR_SYSTEMINFO ), sizeof( systemInfo ) );
+	cvar_modifiedFlags &= ~CVAR_SYSTEMINFO;
+	SV_SetConfigstring( CS_SYSTEMINFO, systemInfo );
+
+	SV_SetConfigstring( CS_SERVERINFO, Cvar_InfoString( CVAR_SERVERINFO ) );
+	cvar_modifiedFlags &= ~CVAR_SERVERINFO;
+
+	// any media configstring setting now should issue a warning
+	// and any configstring changes should be reliably transmitted
+	// to all clients
+	sv.state = SS_GAME;
+
+	// send a heartbeat now so the master will get up to date info
+	SV_Heartbeat_f();
+
+	Hunk_SetMark();
+
+	/* MrE: 2000-09-13: now called in CL_DownloadsComplete
+	// don't call when running dedicated
+	if ( !com_dedicated->integer ) {
+		// note that this is called after setting the hunk mark with Hunk_SetMark
+		CL_StartHunkUsers();
+	}
+	*/
+}
+
+
+/*
+===============
+SV_Init
+
+Only called at main exe startup, not for each game
+===============
+*/
+void SV_BotInitBotLib(void);
+
+void SV_Init (void) {
+	SV_AddOperatorCommands ();
+
+	// serverinfo vars
+	Cvar_Get ("dmflags", "0", CVAR_SERVERINFO);
+	Cvar_Get ("fraglimit", "20", CVAR_SERVERINFO);
+	Cvar_Get ("timelimit", "0", CVAR_SERVERINFO);
+	
+	// Get these to establish them and to make sure they have a default before the menus decide to stomp them.
+	Cvar_Get ("g_maxHolocronCarry", "3", CVAR_SERVERINFO);
+	Cvar_Get ("g_privateDuel", "1", CVAR_SERVERINFO );
+	Cvar_Get ("g_saberLocking", "1", CVAR_SERVERINFO );
+	Cvar_Get ("g_maxForceRank", "6", CVAR_SERVERINFO );
+	Cvar_Get ("duel_fraglimit", "10", CVAR_SERVERINFO);
+	Cvar_Get ("g_forceBasedTeams", "0", CVAR_SERVERINFO);
+	Cvar_Get ("g_duelWeaponDisable", "1", CVAR_SERVERINFO);
+
+	sv_gametype = Cvar_Get ("g_gametype", "0", CVAR_SERVERINFO | CVAR_LATCH );
+	sv_needpass = Cvar_Get ("g_needpass", "0", CVAR_SERVERINFO | CVAR_ROM );
+	Cvar_Get ("sv_keywords", "", CVAR_SERVERINFO);
+	Cvar_Get ("protocol", va("%i", PROTOCOL_VERSION), CVAR_SERVERINFO | CVAR_ROM);
+	sv_mapname = Cvar_Get ("mapname", "nomap", CVAR_SERVERINFO | CVAR_ROM);
+	sv_privateClients = Cvar_Get ("sv_privateClients", "0", CVAR_SERVERINFO);
+	sv_hostname = Cvar_Get ("sv_hostname", "*Jedi*", CVAR_SERVERINFO | CVAR_ARCHIVE );
+	sv_maxclients = Cvar_Get ("sv_maxclients", "8", CVAR_SERVERINFO | CVAR_LATCH);
+	sv_maxRate = Cvar_Get ("sv_maxRate", "0", CVAR_ARCHIVE | CVAR_SERVERINFO );
+	sv_minPing = Cvar_Get ("sv_minPing", "0", CVAR_ARCHIVE | CVAR_SERVERINFO );
+	sv_maxPing = Cvar_Get ("sv_maxPing", "0", CVAR_ARCHIVE | CVAR_SERVERINFO );
+	sv_floodProtect = Cvar_Get ("sv_floodProtect", "1", CVAR_ARCHIVE | CVAR_SERVERINFO );
+	sv_allowAnonymous = Cvar_Get ("sv_allowAnonymous", "0", CVAR_SERVERINFO);
+
+	// systeminfo
+	Cvar_Get ("sv_cheats", "0", CVAR_SYSTEMINFO | CVAR_ROM );
+	sv_serverid = Cvar_Get ("sv_serverid", "0", CVAR_SYSTEMINFO | CVAR_ROM );
+#ifndef DLL_ONLY // bk010216 - for DLL-only servers
+	sv_pure = Cvar_Get ("sv_pure", "1", CVAR_SYSTEMINFO );
+#else
+	sv_pure = Cvar_Get ("sv_pure", "0", CVAR_SYSTEMINFO | CVAR_INIT | CVAR_ROM );
+#endif
+	Cvar_Get ("sv_paks", "", CVAR_SYSTEMINFO | CVAR_ROM );
+	Cvar_Get ("sv_pakNames", "", CVAR_SYSTEMINFO | CVAR_ROM );
+	Cvar_Get ("sv_referencedPaks", "", CVAR_SYSTEMINFO | CVAR_ROM );
+	Cvar_Get ("sv_referencedPakNames", "", CVAR_SYSTEMINFO | CVAR_ROM );
+
+	// server vars
+	sv_rconPassword = Cvar_Get ("rconPassword", "", CVAR_TEMP );
+	sv_privatePassword = Cvar_Get ("sv_privatePassword", "", CVAR_TEMP );
+	sv_fps = Cvar_Get ("sv_fps", "20", CVAR_TEMP );
+	sv_timeout = Cvar_Get ("sv_timeout", "200", CVAR_TEMP );
+	sv_zombietime = Cvar_Get ("sv_zombietime", "2", CVAR_TEMP );
+	Cvar_Get ("nextmap", "", CVAR_TEMP );
+
+#ifndef _XBOX	// No master or downloads on Xbox
+	sv_allowDownload = Cvar_Get ("sv_allowDownload", "0", CVAR_SERVERINFO);
+	sv_master[0] = Cvar_Get ("sv_master1", MASTER_SERVER_NAME, 0 );
+	sv_master[1] = Cvar_Get ("sv_master2", "", CVAR_ARCHIVE );
+	sv_master[2] = Cvar_Get ("sv_master3", "", CVAR_ARCHIVE );
+	sv_master[3] = Cvar_Get ("sv_master4", "", CVAR_ARCHIVE );
+	sv_master[4] = Cvar_Get ("sv_master5", "", CVAR_ARCHIVE );
+#endif
+	sv_reconnectlimit = Cvar_Get ("sv_reconnectlimit", "3", 0);
+	sv_showghoultraces = Cvar_Get ("sv_showghoultraces", "0", 0);
+	sv_showloss = Cvar_Get ("sv_showloss", "0", 0);
+	sv_padPackets = Cvar_Get ("sv_padPackets", "0", 0);
+	sv_killserver = Cvar_Get ("sv_killserver", "0", 0);
+	sv_mapChecksum = Cvar_Get ("sv_mapChecksum", "", CVAR_ROM);
+
+//	sv_debugserver = Cvar_Get ("sv_debugserver", "0", 0);
+
+	// initialize bot cvars so they are listed and can be set before loading the botlib
+	SV_BotInitCvars();
+
+	// init the botlib here because we need the pre-compiler in the UI
+	SV_BotInitBotLib();
+
+#ifdef _XBOX
+	svs.clientRefNum = 0;
+#endif
+	// Only allocated once, no point in moving it around and fragmenting
+	// create a heap for Ghoul2 to use for game side model vertex transforms used in collision detection
+	G2VertSpaceServer = &CMiniHeap_singleton;
+}
+
+
+/*
+==================
+SV_FinalMessage
+
+Used by SV_Shutdown to send a final message to all
+connected clients before the server goes down.  The messages are sent immediately,
+not just stuck on the outgoing message list, because the server is going
+to totally exit after returning from this function.
+==================
+*/
+void SV_FinalMessage( char *message ) {
+	int			i, j;
+	client_t	*cl;
+	
+	// send it twice, ignoring rate
+	for ( j = 0 ; j < 2 ; j++ ) {
+		for (i=0, cl = svs.clients ; i < sv_maxclients->integer ; i++, cl++) {
+			if (cl->state >= CS_CONNECTED) {
+				// don't send a disconnect to a local client
+				if ( cl->netchan.remoteAddress.type != NA_LOOPBACK ) {
+					SV_SendServerCommand( cl, "print \"%s\"", message );
+					SV_SendServerCommand( cl, "disconnect" );
+				}
+				// force a snapshot to be sent
+				cl->nextSnapshotTime = -1;
+				SV_SendClientSnapshot( cl );
+			}
+		}
+	}
+}
+
+
+/*
+================
+SV_Shutdown
+
+Called when each game quits,
+before Sys_Quit or Sys_Error
+================
+*/
+void SV_Shutdown( char *finalmsg ) 
+{
+	if ( !com_sv_running || !com_sv_running->integer ) 
+	{
+		return;
+	}
+
+//	Com_Printf( "----- Server Shutdown -----\n" );
+
+	if ( svs.clients && !com_errorEntered ) {
+		SV_FinalMessage( finalmsg );
+	}
+
+	SV_RemoveOperatorCommands();
+#ifndef _XBOX	// No master on Xbox
+	SV_MasterShutdown();
+#endif
+	SV_ShutdownGameProgs();
+/*
+Ghoul2 Insert Start
+*/
+ 	// de allocate the snapshot entities 
+	if (svs.snapshotEntities)
+	{
+		delete[] svs.snapshotEntities;
+		svs.snapshotEntities = NULL;
+	}
+
+	// free current level
+	SV_ClearServer();
+	CM_ClearMap();//jfm: add a clear here since it's commented out in clearServer.  This prevents crashing cmShaderTable on exit.
+
+	// free server static data
+	if ( svs.clients ) {
+		Z_Free( svs.clients );
+	}
+	Com_Memset( &svs, 0, sizeof( svs ) );
+
+	Cvar_Set( "sv_running", "0" );
+	Cvar_Set("ui_singlePlayerActive", "0");
+
+//	Com_Printf( "---------------------------\n" );
+
+#ifdef _XBOX
+	// If we were advertising on Live, remove the listing. This also unregisters
+	// the server's key. SysLink keys are never unregistered, so we don't do anything
+	// special here for them.
+	if ( logged_on )
+		XBL_MM_Shutdown();
+
+	// Tear down voice now if we're on system link (Live keeps it active)
+	if( !logged_on )
+		g_Voice.Shutdown();
+
+	// Wipe our player list - this is important
+	memset( &xbOnlineInfo, 0, sizeof(xbOnlineInfo) );
+#endif
+
+	// disconnect any local clients
+	CL_Disconnect( qfalse );
+}
+
diff --git a/codemp/server/sv_main.cpp b/codemp/server/sv_main.cpp
new file mode 100644
index 0000000..16507a2
--- /dev/null
+++ b/codemp/server/sv_main.cpp
@@ -0,0 +1,937 @@
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+#include "server.h"
+
+//rww - RAGDOLL_BEGIN
+#include "../ghoul2/ghoul2_shared.h"
+//rww - RAGDOLL_END
+
+serverStatic_t	svs;				// persistant server info
+server_t		sv;					// local server
+vm_t			*gvm = NULL;				// game virtual machine // bk001212 init
+
+cvar_t	*sv_fps;				// time rate for running non-clients
+cvar_t	*sv_timeout;			// seconds without any message
+cvar_t	*sv_zombietime;			// seconds to sink messages after disconnect
+cvar_t	*sv_rconPassword;		// password for remote server commands
+cvar_t	*sv_privatePassword;	// password for the privateClient slots
+cvar_t	*sv_maxclients;
+cvar_t	*sv_privateClients;		// number of clients reserved for password
+cvar_t	*sv_hostname;
+#ifndef _XBOX	// No master or downloads on Xbox
+cvar_t	*sv_allowDownload;
+cvar_t	*sv_master[MAX_MASTER_SERVERS];		// master server ip address
+#endif
+cvar_t	*sv_reconnectlimit;		// minimum seconds between connect messages
+cvar_t	*sv_showghoultraces;	// report ghoul2 traces
+cvar_t	*sv_showloss;			// report when usercmds are lost
+cvar_t	*sv_padPackets;			// add nop bytes to messages
+cvar_t	*sv_killserver;			// menu system can set to 1 to shut server down
+cvar_t	*sv_mapname;
+cvar_t	*sv_mapChecksum;
+cvar_t	*sv_serverid;
+cvar_t	*sv_maxRate;
+cvar_t	*sv_minPing;
+cvar_t	*sv_maxPing;
+cvar_t	*sv_gametype;
+cvar_t	*sv_pure;
+cvar_t	*sv_floodProtect;
+cvar_t	*sv_allowAnonymous;
+cvar_t	*sv_needpass;
+
+/*
+=============================================================================
+
+EVENT MESSAGES
+
+=============================================================================
+*/
+
+/*
+===============
+SV_ExpandNewlines
+
+Converts newlines to "\n" so a line prints nicer
+===============
+*/
+char	*SV_ExpandNewlines( char *in ) {
+	static	char	string[1024];
+	int		l;
+
+	l = 0;
+	while ( *in && l < sizeof(string) - 3 ) {
+		if ( *in == '\n' ) {
+			string[l++] = '\\';
+			string[l++] = 'n';
+		} else {
+			string[l++] = *in;
+		}
+		in++;
+	}
+	string[l] = 0;
+
+	return string;
+}
+
+/*
+======================
+SV_ReplacePendingServerCommands
+
+  This is ugly
+======================
+*/
+int SV_ReplacePendingServerCommands( client_t *client, const char *cmd ) {
+	int i, index, csnum1, csnum2;
+
+	for ( i = client->reliableSent+1; i <= client->reliableSequence; i++ ) {
+		index = i & ( MAX_RELIABLE_COMMANDS - 1 );
+		//
+		if ( !Q_strncmp(cmd, client->reliableCommands[ index ], strlen("cs")) ) {
+			sscanf(cmd, "cs %i", &csnum1);
+			sscanf(client->reliableCommands[ index ], "cs %i", &csnum2);
+			if ( csnum1 == csnum2 ) {
+				Q_strncpyz( client->reliableCommands[ index ], cmd, sizeof( client->reliableCommands[ index ] ) );
+				/*
+				if ( client->netchan.remoteAddress.type != NA_BOT ) {
+					Com_Printf( "WARNING: client %i removed double pending config string %i: %s\n", client-svs.clients, csnum1, cmd );
+				}
+				*/
+				return qtrue;
+			}
+		}
+	}
+	return qfalse;
+}
+
+/*
+======================
+SV_AddServerCommand
+
+The given command will be transmitted to the client, and is guaranteed to
+not have future snapshot_t executed before it is executed
+======================
+*/
+void SV_AddServerCommand( client_t *client, const char *cmd ) {
+	int		index, i;
+
+	// this is very ugly but it's also a waste to for instance send multiple config string updates
+	// for the same config string index in one snapshot
+//	if ( SV_ReplacePendingServerCommands( client, cmd ) ) {
+//		return;
+//	}
+
+	client->reliableSequence++;
+	// if we would be losing an old command that hasn't been acknowledged,
+	// we must drop the connection
+	// we check == instead of >= so a broadcast print added by SV_DropClient()
+	// doesn't cause a recursive drop client
+	if ( client->reliableSequence - client->reliableAcknowledge == MAX_RELIABLE_COMMANDS + 1 ) {
+		Com_Printf( "===== pending server commands =====\n" );
+		for ( i = client->reliableAcknowledge + 1 ; i <= client->reliableSequence ; i++ ) {
+			Com_Printf( "cmd %5d: %s\n", i, client->reliableCommands[ i & (MAX_RELIABLE_COMMANDS-1) ] );
+		}
+		Com_Printf( "cmd %5d: %s\n", i, cmd );
+		SV_DropClient( client, "Server command overflow" );
+		return;
+	}
+	index = client->reliableSequence & ( MAX_RELIABLE_COMMANDS - 1 );
+	Q_strncpyz( client->reliableCommands[ index ], cmd, sizeof( client->reliableCommands[ index ] ) );
+}
+
+
+/*
+=================
+SV_SendServerCommand
+
+Sends a reliable command string to be interpreted by 
+the client game module: "cp", "print", "chat", etc
+A NULL client will broadcast to all clients
+=================
+*/
+void QDECL SV_SendServerCommand(client_t *cl, const char *fmt, ...) {
+	va_list		argptr;
+	byte		message[MAX_MSGLEN];
+	client_t	*client;
+	int			j;
+	
+	va_start (argptr,fmt);
+	vsprintf ((char *)message, fmt,argptr);
+	va_end (argptr);
+
+	if ( cl != NULL ) {
+		SV_AddServerCommand( cl, (char *)message );
+		return;
+	}
+
+	// hack to echo broadcast prints to console
+	if ( com_dedicated->integer && !strncmp( (char *)message, "print", 5) ) {
+		Com_Printf ("broadcast: %s\n", SV_ExpandNewlines((char *)message) );
+	}
+
+	// send the data to all relevent clients
+	for (j = 0, client = svs.clients; j < sv_maxclients->integer ; j++, client++) {
+		if ( client->state < CS_PRIMED ) {
+			continue;
+		}
+		SV_AddServerCommand( client, (char *)message );
+	}
+}
+
+
+/*
+==============================================================================
+
+MASTER SERVER FUNCTIONS
+
+==============================================================================
+*/
+#ifndef _XBOX	// No master on Xbox
+#define NEW_RESOLVE_DURATION		86400000 //24 hours
+static int g_lastResolveTime[MAX_MASTER_SERVERS];
+
+static inline bool SV_MasterNeedsResolving(int server, int time)
+{ //refresh every so often regardless of if the actual address was modified -rww
+	if (g_lastResolveTime[server] > time)
+	{ //time flowed backwards?
+		return true;
+	}
+
+	if ((time-g_lastResolveTime[server]) > NEW_RESOLVE_DURATION)
+	{ //it's time again
+		return true;
+	}
+
+	return false;
+}
+
+/*
+================
+SV_MasterHeartbeat
+
+Send a message to the masters every few minutes to
+let it know we are alive, and log information.
+We will also have a heartbeat sent when a server
+changes from empty to non-empty, and full to non-full,
+but not on every player enter or exit.
+================
+*/
+#define	HEARTBEAT_MSEC	300*1000
+#define	HEARTBEAT_GAME	"QuakeArena-1"
+void SV_MasterHeartbeat( void ) {
+	static netadr_t	adr[MAX_MASTER_SERVERS];
+	int			i;
+	int			time;
+
+	// "dedicated 1" is for lan play, "dedicated 2" is for inet public play
+	if ( !com_dedicated || com_dedicated->integer != 2 ) {
+		return;		// only dedicated servers send heartbeats
+	}
+
+	// if not time yet, don't send anything
+	if ( svs.time < svs.nextHeartbeatTime ) {
+		return;
+	}
+	svs.nextHeartbeatTime = svs.time + HEARTBEAT_MSEC;
+
+	//we need to use this instead of svs.time since svs.time resets over map changes (or rather
+	//every time the game restarts), and we don't really need to resolve every map change
+	time = Com_Milliseconds();
+
+	// send to group masters
+	for ( i = 0 ; i < MAX_MASTER_SERVERS ; i++ ) {
+		if ( !sv_master[i]->string[0] ) {
+			continue;
+		}
+
+		// see if we haven't already resolved the name
+		// resolving usually causes hitches on win95, so only
+		// do it when needed
+		if ( sv_master[i]->modified || SV_MasterNeedsResolving(i, time) ) {
+			sv_master[i]->modified = qfalse;
+
+			g_lastResolveTime[i] = time;
+	
+			Com_Printf( "Resolving %s\n", sv_master[i]->string );
+			if ( !NET_StringToAdr( sv_master[i]->string, &adr[i] ) ) {
+				// if the address failed to resolve, clear it
+				// so we don't take repeated dns hits
+				Com_Printf( "Couldn't resolve address: %s\n", sv_master[i]->string );
+				Cvar_Set( sv_master[i]->name, "" );
+				sv_master[i]->modified = qfalse;
+				continue;
+			}
+			if ( !strstr( ":", sv_master[i]->string ) ) {
+				adr[i].port = BigShort( PORT_MASTER );
+			}
+			Com_Printf( "%s resolved to %i.%i.%i.%i:%i\n", sv_master[i]->string,
+				adr[i].ip[0], adr[i].ip[1], adr[i].ip[2], adr[i].ip[3],
+				BigShort( adr[i].port ) );
+		}
+
+
+		Com_Printf ("Sending heartbeat to %s\n", sv_master[i]->string );
+		// this command should be changed if the server info / status format
+		// ever incompatably changes
+		NET_OutOfBandPrint( NS_SERVER, adr[i], "heartbeat %s\n", HEARTBEAT_GAME );
+	}
+}
+
+/*
+=================
+SV_MasterShutdown
+
+Informs all masters that this server is going down
+=================
+*/
+void SV_MasterShutdown( void ) {
+	// send a hearbeat right now
+	svs.nextHeartbeatTime = -9999;
+	SV_MasterHeartbeat();
+
+	// send it again to minimize chance of drops
+	svs.nextHeartbeatTime = -9999;
+	SV_MasterHeartbeat();
+
+	// when the master tries to poll the server, it won't respond, so
+	// it will be removed from the list
+}
+#endif	// _XBOX	- No master on Xbox
+
+
+/*
+==============================================================================
+
+CONNECTIONLESS COMMANDS
+
+==============================================================================
+*/
+
+/*
+================
+SVC_Status
+
+Responds with all the info that qplug or qspy can see about the server
+and all connected players.  Used for getting detailed information after
+the simple info query.
+================
+*/
+void SVC_Status( netadr_t from ) {
+	char	player[1024];
+	char	status[MAX_MSGLEN];
+	int		i;
+	client_t	*cl;
+	playerState_t	*ps;
+	int		statusLength;
+	int		playerLength;
+	char	infostring[MAX_INFO_STRING];
+
+	// ignore if we are in single player
+	/*
+	if ( Cvar_VariableValue( "g_gametype" ) == GT_SINGLE_PLAYER ) {
+		return;
+	}
+	*/
+
+	strcpy( infostring, Cvar_InfoString( CVAR_SERVERINFO ) );
+
+	// echo back the parameter to status. so master servers can use it as a challenge
+	// to prevent timed spoofed reply packets that add ghost servers
+	Info_SetValueForKey( infostring, "challenge", Cmd_Argv(1) );
+
+	// add "demo" to the sv_keywords if restricted
+	if ( Cvar_VariableValue( "fs_restrict" ) ) {
+		char	keywords[MAX_INFO_STRING];
+
+		Com_sprintf( keywords, sizeof( keywords ), "demo %s",
+			Info_ValueForKey( infostring, "sv_keywords" ) );
+		Info_SetValueForKey( infostring, "sv_keywords", keywords );
+	}
+
+	status[0] = 0;
+	statusLength = 0;
+
+	for (i=0 ; i < sv_maxclients->integer ; i++) {
+		cl = &svs.clients[i];
+		if ( cl->state >= CS_CONNECTED ) {
+			ps = SV_GameClientNum( i );
+			Com_sprintf (player, sizeof(player), "%i %i \"%s\"\n", 
+				ps->persistant[PERS_SCORE], cl->ping, cl->name);
+			playerLength = strlen(player);
+			if (statusLength + playerLength >= sizeof(status) ) {
+				break;		// can't hold any more
+			}
+			strcpy (status + statusLength, player);
+			statusLength += playerLength;
+		}
+	}
+
+	NET_OutOfBandPrint( NS_SERVER, from, "statusResponse\n%s\n%s", infostring, status );
+}
+
+/*
+================
+SVC_Info
+
+Responds with a short info message that should be enough to determine
+if a user is interested in a server to do a full status
+================
+*/
+void SVC_Info( netadr_t from ) {
+	int		i, count, wDisable;
+	char	*gamedir;
+	char	infostring[MAX_INFO_STRING];
+
+	// ignore if we are in single player
+	/*
+	if ( Cvar_VariableValue( "g_gametype" ) == GT_SINGLE_PLAYER || Cvar_VariableValue("ui_singlePlayerActive")) {
+		return;
+	}
+	*/
+
+#ifdef _XBOX
+	// don't send system link info if in Xbox Live
+	if (logged_on)
+		return;
+#endif
+
+	if (Cvar_VariableValue("ui_singlePlayerActive"))
+	{
+		return;
+	}
+
+	// don't count privateclients
+	count = 0;
+	for ( i = sv_privateClients->integer ; i < sv_maxclients->integer ; i++ ) {
+		if ( svs.clients[i].state >= CS_CONNECTED ) {
+			count++;
+		}
+	}
+
+	infostring[0] = 0;
+
+	// echo back the parameter to status. so servers can use it as a challenge
+	// to prevent timed spoofed reply packets that add ghost servers
+	Info_SetValueForKey( infostring, "challenge", Cmd_Argv(1) );
+
+	Info_SetValueForKey( infostring, "protocol", va("%i", PROTOCOL_VERSION) );
+	Info_SetValueForKey( infostring, "hostname", sv_hostname->string );
+	Info_SetValueForKey( infostring, "mapname", sv_mapname->string );
+	Info_SetValueForKey( infostring, "clients", va("%i", count) );
+	Info_SetValueForKey( infostring, "sv_maxclients", 
+		va("%i", sv_maxclients->integer - sv_privateClients->integer ) );
+	Info_SetValueForKey( infostring, "gametype", va("%i", sv_gametype->integer ) );
+	Info_SetValueForKey( infostring, "needpass", va("%i", sv_needpass->integer ) );
+	Info_SetValueForKey( infostring, "truejedi", va("%i", Cvar_VariableIntegerValue( "g_jediVmerc" ) ) );
+	if ( sv_gametype->integer == GT_DUEL || sv_gametype->integer == GT_POWERDUEL )
+	{
+		wDisable = Cvar_VariableIntegerValue( "g_duelWeaponDisable" );
+	}
+	else
+	{
+		wDisable = Cvar_VariableIntegerValue( "g_weaponDisable" );
+	}
+	Info_SetValueForKey( infostring, "wdisable", va("%i", wDisable ) );
+	Info_SetValueForKey( infostring, "fdisable", va("%i", Cvar_VariableIntegerValue( "g_forcePowerDisable" ) ) );
+	//Info_SetValueForKey( infostring, "pure", va("%i", sv_pure->integer ) );
+
+	if( sv_minPing->integer ) {
+		Info_SetValueForKey( infostring, "minPing", va("%i", sv_minPing->integer) );
+	}
+	if( sv_maxPing->integer ) {
+		Info_SetValueForKey( infostring, "maxPing", va("%i", sv_maxPing->integer) );
+	}
+	gamedir = Cvar_VariableString( "fs_game" );
+	if( *gamedir ) {
+		Info_SetValueForKey( infostring, "game", gamedir );
+	}
+	Info_SetValueForKey( infostring, "sv_allowAnonymous", va("%i", sv_allowAnonymous->integer) );
+
+#ifdef _XBOX
+	// Include Xbox specific networking info
+	char sxnkid[XNKID_STRING_LEN];
+	XNKIDToString(SysLink_GetXNKID(), sxnkid);
+	Info_SetValueForKey(infostring, "xnkid", sxnkid);
+
+	char sxnkey[XNKEY_STRING_LEN];
+	XNKEYToString(SysLink_GetXNKEY(), sxnkey);
+	Info_SetValueForKey(infostring, "xnkey", sxnkey);
+
+	char sxnaddr[XNADDR_STRING_LEN];
+	XnAddrToString(Net_GetXNADDR(), sxnaddr);
+	Info_SetValueForKey(infostring, "xnaddr", sxnaddr);
+#endif
+
+	NET_OutOfBandPrint( NS_SERVER, from, "infoResponse\n%s", infostring );
+}
+
+/*
+================
+SVC_FlushRedirect
+
+================
+*/
+void SV_FlushRedirect( char *outputbuf ) {
+	NET_OutOfBandPrint( NS_SERVER, svs.redirectAddress, "print\n%s", outputbuf );
+}
+
+/*
+===============
+SVC_RemoteCommand
+
+An rcon packet arrived from the network.
+Shift down the remaining args
+Redirect all printfs
+===============
+*/
+void SVC_RemoteCommand( netadr_t from, msg_t *msg ) {
+	qboolean	valid;
+	unsigned int	i, time;
+	char		remaining[1024];
+#define	SV_OUTPUTBUF_LENGTH	(MAX_MSGLEN - 16)
+	char		sv_outputbuf[SV_OUTPUTBUF_LENGTH];
+	static		unsigned int	lasttime = 0;
+
+	time = Com_Milliseconds();
+	if (time<(lasttime+500)) {
+		return;
+	}
+	lasttime = time;
+
+	if ( !strlen( sv_rconPassword->string ) ||
+		strcmp (Cmd_Argv(1), sv_rconPassword->string) ) {
+		valid = qfalse;
+		Com_DPrintf ("Bad rcon from %s:\n%s\n", NET_AdrToString (from), Cmd_Argv(2) );
+	} else {
+		valid = qtrue;
+		Com_DPrintf ("Rcon from %s:\n%s\n", NET_AdrToString (from), Cmd_Argv(2) );
+	}
+
+	// start redirecting all print outputs to the packet
+	svs.redirectAddress = from;
+	Com_BeginRedirect (sv_outputbuf, SV_OUTPUTBUF_LENGTH, SV_FlushRedirect);
+
+	if ( !strlen( sv_rconPassword->string ) ) {
+		Com_Printf ("No rconpassword set.\n");
+	} else if ( !valid ) {
+		Com_Printf ("Bad rconpassword.\n");
+	} else {
+		remaining[0] = 0;
+
+		for (i=2 ; i<Cmd_Argc() ; i++) {
+			strcat (remaining, Cmd_Argv(i) );
+			strcat (remaining, " ");
+		}
+
+		Cmd_ExecuteString (remaining);
+	}
+
+	Com_EndRedirect ();
+}
+
+/*
+=================
+SV_ConnectionlessPacket
+
+A connectionless packet has four leading 0xff
+characters to distinguish it from a game channel.
+Clients that are in the game can still send
+connectionless packets.
+=================
+*/
+void SV_ConnectionlessPacket( netadr_t from, msg_t *msg ) {
+	char	*s;
+	char	*c;
+
+	MSG_BeginReadingOOB( msg );
+	MSG_ReadLong( msg );		// skip the -1 marker
+
+	if (!Q_strncmp("connect", (const char *)&msg->data[4], 7)) {
+		Huff_Decompress(msg, 12);
+	}
+
+	s = MSG_ReadStringLine( msg );
+	Cmd_TokenizeString( s );
+
+	c = Cmd_Argv(0);
+	Com_DPrintf ("SV packet %s : %s\n", NET_AdrToString(from), c);
+
+	if (!Q_stricmp(c, "getstatus")) {
+		SVC_Status( from  );
+	} else if (!Q_stricmp(c, "getinfo")) {
+		SVC_Info( from );
+	} else if (!Q_stricmp(c, "getchallenge")) {
+		SV_GetChallenge( from );
+	} else if (!Q_stricmp(c, "connect")) {
+		SV_DirectConnect( from );
+#ifndef _XBOX	// No authorization on Xbox
+	} else if (!Q_stricmp(c, "ipAuthorize")) {
+		SV_AuthorizeIpPacket( from );
+#endif
+	} else if (!Q_stricmp(c, "rcon")) {
+		SVC_RemoteCommand( from, msg );
+	} else if (!Q_stricmp(c, "disconnect")) {
+		// if a client starts up a local server, we may see some spurious
+		// server disconnect messages when their new server sees our final
+		// sequenced messages to the old client
+	} else {
+		Com_DPrintf ("bad connectionless packet from %s:\n%s\n"
+		, NET_AdrToString (from), s);
+	}
+}
+
+
+//============================================================================
+
+/*
+=================
+SV_ReadPackets
+=================
+*/
+void SV_PacketEvent( netadr_t from, msg_t *msg ) {
+	int			i;
+	client_t	*cl;
+	int			qport;
+
+	// check for connectionless packet (0xffffffff) first
+	if ( msg->cursize >= 4 && *(int *)msg->data == -1) {
+		SV_ConnectionlessPacket( from, msg );
+		return;
+	}
+
+	// read the qport out of the message so we can fix up
+	// stupid address translating routers
+	MSG_BeginReadingOOB( msg );
+	MSG_ReadLong( msg );				// sequence number
+	qport = MSG_ReadShort( msg ) & 0xffff;
+
+	// find which client the message is from
+	for (i=0, cl=svs.clients ; i < sv_maxclients->integer ; i++,cl++) {
+		if (cl->state == CS_FREE) {
+			continue;
+		}
+		if ( !NET_CompareBaseAdr( from, cl->netchan.remoteAddress ) ) {
+			continue;
+		}
+		// it is possible to have multiple clients from a single IP
+		// address, so they are differentiated by the qport variable
+		if (cl->netchan.qport != qport) {
+			continue;
+		}
+
+		// the IP port can't be used to differentiate them, because
+		// some address translating routers periodically change UDP
+		// port assignments
+		if (cl->netchan.remoteAddress.port != from.port) {
+			Com_Printf( "SV_ReadPackets: fixing up a translated port\n" );
+			cl->netchan.remoteAddress.port = from.port;
+		}
+
+		// make sure it is a valid, in sequence packet
+		if (SV_Netchan_Process(cl, msg)) {
+			// zombie clients still need to do the Netchan_Process
+			// to make sure they don't need to retransmit the final
+			// reliable message, but they don't do any other processing
+			if (cl->state != CS_ZOMBIE) {
+				cl->lastPacketTime = svs.time;	// don't timeout
+				SV_ExecuteClientMessage( cl, msg );
+			}
+		}
+		return;
+	}
+	
+	// if we received a sequenced packet from an address we don't reckognize,
+	// send an out of band disconnect packet to it
+	NET_OutOfBandPrint( NS_SERVER, from, "disconnect" );
+}
+
+
+/*
+===================
+SV_CalcPings
+
+Updates the cl->ping variables
+===================
+*/
+void SV_CalcPings( void ) {
+	int			i, j;
+	client_t	*cl;
+	int			total, count;
+	int			delta;
+	playerState_t	*ps;
+
+	for (i=0 ; i < sv_maxclients->integer ; i++) {
+		cl = &svs.clients[i];
+		if ( cl->state != CS_ACTIVE ) {
+			cl->ping = 999;
+			continue;
+		}
+		if ( !cl->gentity ) {
+			cl->ping = 999;
+			continue;
+		}
+		if ( cl->gentity->r.svFlags & SVF_BOT ) {
+			cl->ping = 0;
+			continue;
+		}
+
+		total = 0;
+		count = 0;
+		for ( j = 0 ; j < PACKET_BACKUP ; j++ ) {
+			if ( cl->frames[j].messageAcked <= 0 ) {
+				continue;
+			}
+			delta = cl->frames[j].messageAcked - cl->frames[j].messageSent;
+			count++;
+			total += delta;
+		}
+		if (!count) {
+			cl->ping = 999;
+		} else {
+			cl->ping = total/count;
+			if ( cl->ping > 999 ) {
+				cl->ping = 999;
+			}
+		}
+
+		// let the game dll know about the ping
+		ps = SV_GameClientNum( i );
+		ps->ping = cl->ping;
+	}
+}
+
+/*
+==================
+SV_CheckTimeouts
+
+If a packet has not been received from a client for timeout->integer 
+seconds, drop the conneciton.  Server time is used instead of
+realtime to avoid dropping the local client while debugging.
+
+When a client is normally dropped, the client_t goes into a zombie state
+for a few seconds to make sure any final reliable message gets resent
+if necessary
+==================
+*/
+void SV_CheckTimeouts( void ) {
+	int		i;
+	client_t	*cl;
+	int			droppoint;
+	int			zombiepoint;
+
+	droppoint = svs.time - 1000 * sv_timeout->integer;
+	zombiepoint = svs.time - 1000 * sv_zombietime->integer;
+
+	for (i=0,cl=svs.clients ; i < sv_maxclients->integer ; i++,cl++) {
+		// message times may be wrong across a changelevel
+		if (cl->lastPacketTime > svs.time) {
+			cl->lastPacketTime = svs.time;
+		}
+
+		if (cl->state == CS_ZOMBIE
+		&& cl->lastPacketTime < zombiepoint) {
+			Com_DPrintf( "Going from CS_ZOMBIE to CS_FREE for %s\n", cl->name );
+			cl->state = CS_FREE;	// can now be reused
+			continue;
+		}
+		if ( cl->state >= CS_CONNECTED && cl->lastPacketTime < droppoint) {
+			// wait several frames so a debugger session doesn't
+			// cause a timeout
+			if ( ++cl->timeoutCount > 5 ) {
+				SV_DropClient (cl, "timed out"); 
+				cl->state = CS_FREE;	// don't bother with zombie state
+			}
+		} else {
+			cl->timeoutCount = 0;
+		}
+	}
+}
+
+
+/*
+==================
+SV_CheckPaused
+==================
+*/
+qboolean SV_CheckPaused( void ) {
+	int		count;
+	client_t	*cl;
+	int		i;
+
+	if ( !cl_paused->integer ) {
+		return qfalse;
+	}
+
+	// only pause if there is just a single client connected
+	count = 0;
+	for (i=0,cl=svs.clients ; i < sv_maxclients->integer ; i++,cl++) {
+		if ( cl->state >= CS_CONNECTED && cl->netchan.remoteAddress.type != NA_BOT ) {
+			count++;
+		}
+	}
+
+	if ( count > 1 ) {
+		// don't pause
+		sv_paused->integer = 0;
+		return qfalse;
+	}
+
+	sv_paused->integer = 1;
+	return qtrue;
+}
+
+/*
+==================
+SV_CheckCvars
+==================
+*/
+void SV_CheckCvars( void ) {
+	static int lastMod = -1;
+	qboolean	changed = qfalse;
+	
+	if ( sv_hostname->modificationCount != lastMod ) {
+		char hostname[MAX_INFO_STRING];
+		char *c = hostname;
+		lastMod = sv_hostname->modificationCount;
+		
+		strcpy( hostname, sv_hostname->string );
+		while( *c )
+		{
+			if ( (*c == '\\') || (*c == ';') || (*c == '"'))
+			{
+				*c = '.';
+				changed = qtrue;
+			}
+			c++;
+		}
+		if( changed )
+		{
+			Cvar_Set("sv_hostname", hostname );
+		}
+		
+	}
+}
+
+/*
+==================
+SV_Frame
+
+Player movement occurs as a result of packet events, which
+happen before SV_Frame is called
+==================
+*/
+void SV_Frame( int msec ) {
+	int		frameMsec;
+	int		startTime;
+
+	// the menu kills the server with this cvar
+	if ( sv_killserver->integer ) {
+		SV_Shutdown ("Server was killed.\n");
+		Cvar_Set( "sv_killserver", "0" );
+		return;
+	}
+
+	if ( !com_sv_running->integer ) {
+		return;
+	}
+
+	// allow pause if only the local client is connected
+	if ( SV_CheckPaused() ) {
+		return;
+	}
+
+	// if it isn't time for the next frame, do nothing
+	if ( sv_fps->integer < 1 ) {
+		Cvar_Set( "sv_fps", "10" );
+	}
+	frameMsec = 1000 / sv_fps->integer ;
+
+	sv.timeResidual += msec;
+
+	if (!com_dedicated->integer) SV_BotFrame( svs.time + sv.timeResidual );
+
+	if ( com_dedicated->integer && sv.timeResidual < frameMsec && (!com_timescale || com_timescale->value >= 1) ) {
+		// NET_Sleep will give the OS time slices until either get a packet
+		// or time enough for a server frame has gone by
+		NET_Sleep(frameMsec - sv.timeResidual);
+		return;
+	}
+
+	// if time is about to hit the 32nd bit, kick all clients
+	// and clear sv.time, rather
+	// than checking for negative time wraparound everywhere.
+	// 2giga-milliseconds = 23 days, so it won't be too often
+	if ( svs.time > 0x70000000 ) {
+		SV_Shutdown( "Restarting server due to time wrapping" );
+		//Cbuf_AddText( "vstr nextmap\n" );
+		Cbuf_AddText( "map_restart 0\n" );
+		return;
+	}
+	// this can happen considerably earlier when lots of clients play and the map doesn't change
+	if ( svs.nextSnapshotEntities >= 0x7FFFFFFE - svs.numSnapshotEntities ) {
+		SV_Shutdown( "Restarting server due to numSnapshotEntities wrapping" );
+		//Cbuf_AddText( "vstr nextmap\n" );
+		Cbuf_AddText( "map_restart 0\n" );
+		return;
+	}
+
+	if( sv.restartTime && svs.time >= sv.restartTime ) {
+		sv.restartTime = 0;
+		Cbuf_AddText( "map_restart 0\n" );
+		return;
+	}
+
+	// update infostrings if anything has been changed
+	if ( cvar_modifiedFlags & CVAR_SERVERINFO ) {
+		SV_SetConfigstring( CS_SERVERINFO, Cvar_InfoString( CVAR_SERVERINFO ) );
+		cvar_modifiedFlags &= ~CVAR_SERVERINFO;
+	}
+	if ( cvar_modifiedFlags & CVAR_SYSTEMINFO ) {
+		SV_SetConfigstring( CS_SYSTEMINFO, Cvar_InfoString_Big( CVAR_SYSTEMINFO ) );
+		cvar_modifiedFlags &= ~CVAR_SYSTEMINFO;
+	}
+
+	if ( com_speeds->integer ) {
+		startTime = Sys_Milliseconds ();
+	} else {
+		startTime = 0;	// quite a compiler warning
+	}
+
+	// update ping based on the all received frames
+	SV_CalcPings();
+
+	if (com_dedicated->integer) SV_BotFrame( svs.time );
+
+	// run the game simulation in chunks
+	while ( sv.timeResidual >= frameMsec ) {
+		sv.timeResidual -= frameMsec;
+		svs.time += frameMsec;
+
+		// let everything in the world think and move
+		VM_Call( gvm, GAME_RUN_FRAME, svs.time );
+	}
+
+	//rww - RAGDOLL_BEGIN
+	G2API_SetTime(svs.time,0);
+	//rww - RAGDOLL_END
+
+	if ( com_speeds->integer ) {
+		time_game = Sys_Milliseconds () - startTime;
+	}
+
+	// check timeouts
+	SV_CheckTimeouts();
+
+	// send messages back to the clients
+	SV_SendClientMessages();
+
+	SV_CheckCvars();
+
+	// send a heartbeat to the master if needed
+#ifndef _XBOX	// No master on Xbox
+	SV_MasterHeartbeat();
+#endif
+}
+
+//============================================================================
+
diff --git a/codemp/server/sv_net_chan.cpp b/codemp/server/sv_net_chan.cpp
new file mode 100644
index 0000000..13427b9
--- /dev/null
+++ b/codemp/server/sv_net_chan.cpp
@@ -0,0 +1,169 @@
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+#include "server.h"
+
+// TTimo: unused, commenting out to make gcc happy
+#if 1
+/*
+==============
+SV_Netchan_Encode
+
+	// first four bytes of the data are always:
+	long reliableAcknowledge;
+
+==============
+*/
+static void SV_Netchan_Encode( client_t *client, msg_t *msg ) {
+#ifdef _XBOX
+	return;
+#endif
+	long reliableAcknowledge, i, index;
+	byte key, *string;
+        int	srdc, sbit, soob;
+        
+	if ( msg->cursize < SV_ENCODE_START ) {
+		return;
+	}
+
+        srdc = msg->readcount;
+        sbit = msg->bit;
+        soob = msg->oob;
+        
+        msg->bit = 0;
+        msg->readcount = 0;
+        msg->oob = (qboolean)0;
+        
+	reliableAcknowledge = MSG_ReadLong(msg);
+
+        msg->oob = (qboolean)soob;
+        msg->bit = sbit;
+        msg->readcount = srdc;
+        
+	string = (byte *)client->lastClientCommandString;
+	index = 0;
+	// xor the client challenge with the netchan sequence number
+	key = client->challenge ^ client->netchan.outgoingSequence;
+	for (i = SV_ENCODE_START; i < msg->cursize; i++) {
+		// modify the key with the last received and with this message acknowledged client command
+		if (!string[index])
+			index = 0;
+		if (/*string[index] > 127 ||*/	// eurofix: remove this so we can chat in european languages...	-ste
+			string[index] == '%') 
+		{
+			key ^= '.' << (i & 1);
+		}
+		else {
+			key ^= string[index] << (i & 1);
+		}
+		index++;
+		// encode the data with this key
+		*(msg->data + i) = *(msg->data + i) ^ key;
+	}
+}
+
+/*
+==============
+SV_Netchan_Decode
+
+	// first 12 bytes of the data are always:
+	long serverId;
+	long messageAcknowledge;
+	long reliableAcknowledge;
+
+==============
+*/
+static void SV_Netchan_Decode( client_t *client, msg_t *msg ) {
+#ifdef _XBOX
+	return;
+#endif
+	int serverId, messageAcknowledge, reliableAcknowledge;
+	int i, index, srdc, sbit, soob;
+	byte key, *string;
+
+        srdc = msg->readcount;
+        sbit = msg->bit;
+        soob = msg->oob;
+        
+        msg->oob = (qboolean)0;
+        
+        serverId = MSG_ReadLong(msg);
+	messageAcknowledge = MSG_ReadLong(msg);
+	reliableAcknowledge = MSG_ReadLong(msg);
+
+        msg->oob = (qboolean)soob;
+        msg->bit = sbit;
+        msg->readcount = srdc;
+        
+	string = (byte *)client->reliableCommands[ reliableAcknowledge & (MAX_RELIABLE_COMMANDS-1) ];
+	index = 0;
+	//
+	key = client->challenge ^ serverId ^ messageAcknowledge;
+	for (i = msg->readcount + SV_DECODE_START; i < msg->cursize; i++) {
+		// modify the key with the last sent and acknowledged server command
+		if (!string[index])
+			index = 0;
+		if (/*string[index] > 127 || */	// eurofix: remove this so we can chat in european languages...	-ste
+			string[index] == '%') 
+		{
+			key ^= '.' << (i & 1);
+		}
+		else {
+			key ^= string[index] << (i & 1);
+		}
+		index++;
+		// decode the data with this key
+		*(msg->data + i) = *(msg->data + i) ^ key;
+	}
+}
+#endif
+
+/*
+=================
+SV_Netchan_TransmitNextFragment
+=================
+*/
+void SV_Netchan_TransmitNextFragment( netchan_t *chan ) {
+	Netchan_TransmitNextFragment( chan );
+}
+
+
+/*
+===============
+SV_Netchan_Transmit
+================
+*/
+
+//extern byte chksum[65536];
+void SV_Netchan_Transmit( client_t *client, msg_t *msg) {	//int length, const byte *data ) {
+//	int i;
+	MSG_WriteByte( msg, svc_EOF );
+//	for(i=SV_ENCODE_START;i<msg->cursize;i++) {
+//		chksum[i-SV_ENCODE_START] = msg->data[i];
+//	}
+//	Huff_Compress( msg, SV_ENCODE_START );
+	SV_Netchan_Encode( client, msg );
+	Netchan_Transmit( &client->netchan, msg->cursize, msg->data );
+}
+
+/*
+=================
+Netchan_SV_Process
+=================
+*/
+qboolean SV_Netchan_Process( client_t *client, msg_t *msg ) {
+	int ret;
+//	int i;
+	ret = Netchan_Process( &client->netchan, msg );
+	if (!ret)
+		return qfalse;
+	SV_Netchan_Decode( client, msg );
+//	Huff_Decompress( msg, SV_DECODE_START );
+//	for(i=SV_DECODE_START+msg->readcount;i<msg->cursize;i++) {
+//		if (msg->data[i] != chksum[i-(SV_DECODE_START+msg->readcount)]) {
+//			Com_Error(ERR_DROP,"bad\n");
+//		}
+//	}
+	return qtrue;
+}
+
diff --git a/codemp/server/sv_snapshot.cpp b/codemp/server/sv_snapshot.cpp
new file mode 100644
index 0000000..21b61e0
--- /dev/null
+++ b/codemp/server/sv_snapshot.cpp
@@ -0,0 +1,833 @@
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+#include "server.h"
+
+
+/*
+=============================================================================
+
+Delta encode a client frame onto the network channel
+
+A normal server packet will look like:
+
+4	sequence number (high bit set if an oversize fragment)
+<optional reliable commands>
+1	svc_snapshot
+4	last client reliable command
+4	serverTime
+1	lastframe for delta compression
+1	snapFlags
+1	areaBytes
+<areabytes>
+<playerstate>
+<packetentities>
+
+=============================================================================
+*/
+
+/*
+=============
+SV_EmitPacketEntities
+
+Writes a delta update of an entityState_t list to the message.
+=============
+*/
+static void SV_EmitPacketEntities( clientSnapshot_t *from, clientSnapshot_t *to, msg_t *msg ) {
+	entityState_t	*oldent, *newent;
+	int		oldindex, newindex;
+	int		oldnum, newnum;
+	int		from_num_entities;
+
+	// generate the delta update
+	if ( !from ) {
+		from_num_entities = 0;
+	} else {
+		from_num_entities = from->num_entities;
+	}
+
+	newent = NULL;
+	oldent = NULL;
+	newindex = 0;
+	oldindex = 0;
+	while ( newindex < to->num_entities || oldindex < from_num_entities ) {
+		if ( newindex >= to->num_entities ) {
+			newnum = 9999;
+		} else {
+			newent = &svs.snapshotEntities[(to->first_entity+newindex) % svs.numSnapshotEntities];
+			newnum = newent->number;
+		}
+
+		if ( oldindex >= from_num_entities ) {
+			oldnum = 9999;
+		} else {
+			oldent = &svs.snapshotEntities[(from->first_entity+oldindex) % svs.numSnapshotEntities];
+			oldnum = oldent->number;
+		}
+
+		if ( newnum == oldnum ) {
+			// delta update from old position
+			// because the force parm is qfalse, this will not result
+			// in any bytes being emited if the entity has not changed at all
+			MSG_WriteDeltaEntity (msg, oldent, newent, qfalse );
+			oldindex++;
+			newindex++;
+			continue;
+		}
+
+		if ( newnum < oldnum ) {
+			// this is a new entity, send it from the baseline
+			MSG_WriteDeltaEntity (msg, &sv.svEntities[newnum].baseline, newent, qtrue );
+			newindex++;
+			continue;
+		}
+
+		if ( newnum > oldnum ) {
+			// the old entity isn't present in the new message
+			MSG_WriteDeltaEntity (msg, oldent, NULL, qtrue );
+			oldindex++;
+			continue;
+		}
+	}
+
+	MSG_WriteBits( msg, (MAX_GENTITIES-1), GENTITYNUM_BITS );	// end of packetentities
+}
+
+
+
+/*
+==================
+SV_WriteSnapshotToClient
+==================
+*/
+static void SV_WriteSnapshotToClient( client_t *client, msg_t *msg ) {
+	clientSnapshot_t	*frame, *oldframe;
+	int					lastframe;
+	int					i;
+	int					snapFlags;
+
+	// this is the snapshot we are creating
+	frame = &client->frames[ client->netchan.outgoingSequence & PACKET_MASK ];
+
+	// try to use a previous frame as the source for delta compressing the snapshot
+	if ( client->deltaMessage <= 0 || client->state != CS_ACTIVE ) {
+		// client is asking for a retransmit
+		oldframe = NULL;
+		lastframe = 0;
+	} else if ( client->netchan.outgoingSequence - client->deltaMessage 
+		>= (PACKET_BACKUP - 3) ) {
+		// client hasn't gotten a good message through in a long time
+		Com_DPrintf ("%s: Delta request from out of date packet.\n", client->name);
+		oldframe = NULL;
+		lastframe = 0;
+	} else {
+		// we have a valid snapshot to delta from
+		oldframe = &client->frames[ client->deltaMessage & PACKET_MASK ];
+		lastframe = client->netchan.outgoingSequence - client->deltaMessage;
+
+		// the snapshot's entities may still have rolled off the buffer, though
+		if ( oldframe->first_entity <= svs.nextSnapshotEntities - svs.numSnapshotEntities ) {
+			Com_DPrintf ("%s: Delta request from out of date entities.\n", client->name);
+			oldframe = NULL;
+			lastframe = 0;
+		}
+	}
+
+	MSG_WriteByte (msg, svc_snapshot);
+
+	// NOTE, MRE: now sent at the start of every message from server to client
+	// let the client know which reliable clientCommands we have received
+	//MSG_WriteLong( msg, client->lastClientCommand );
+
+	// send over the current server time so the client can drift
+	// its view of time to try to match
+	MSG_WriteLong (msg, svs.time);
+
+	// what we are delta'ing from
+	MSG_WriteByte (msg, lastframe);
+
+	snapFlags = svs.snapFlagServerBit;
+	if ( client->rateDelayed ) {
+		snapFlags |= SNAPFLAG_RATE_DELAYED;
+	}
+	if ( client->state != CS_ACTIVE ) {
+		snapFlags |= SNAPFLAG_NOT_ACTIVE;
+	}
+
+	MSG_WriteByte (msg, snapFlags);
+
+	// send over the areabits
+	MSG_WriteByte (msg, frame->areabytes);
+	MSG_WriteData (msg, frame->areabits, frame->areabytes);
+
+	// delta encode the playerstate
+	if ( oldframe ) {
+#ifdef _ONEBIT_COMBO
+		MSG_WriteDeltaPlayerstate( msg, &oldframe->ps, &frame->ps, frame->pDeltaOneBit, frame->pDeltaNumBit );
+#else
+		MSG_WriteDeltaPlayerstate( msg, &oldframe->ps, &frame->ps );
+#endif
+		if (frame->ps.m_iVehicleNum)
+		{ //then write the vehicle's playerstate too
+			if (!oldframe->ps.m_iVehicleNum)
+			{ //if last frame didn't have vehicle, then the old vps isn't gonna delta
+				//properly (because our vps on the client could be anything)
+#ifdef _ONEBIT_COMBO
+				MSG_WriteDeltaPlayerstate( msg, NULL, &frame->vps, NULL, NULL, qtrue );
+#else
+				MSG_WriteDeltaPlayerstate( msg, NULL, &frame->vps, qtrue );
+#endif
+			}
+			else
+			{
+#ifdef _ONEBIT_COMBO
+				MSG_WriteDeltaPlayerstate( msg, &oldframe->vps, &frame->vps, frame->pDeltaOneBitVeh, frame->pDeltaNumBitVeh, qtrue );
+#else
+				MSG_WriteDeltaPlayerstate( msg, &oldframe->vps, &frame->vps, qtrue );
+#endif
+			}
+		}
+	} else {
+#ifdef _ONEBIT_COMBO
+		MSG_WriteDeltaPlayerstate( msg, NULL, &frame->ps, NULL, NULL );
+#else
+		MSG_WriteDeltaPlayerstate( msg, NULL, &frame->ps );
+#endif
+		if (frame->ps.m_iVehicleNum)
+		{ //then write the vehicle's playerstate too
+#ifdef _ONEBIT_COMBO
+			MSG_WriteDeltaPlayerstate( msg, NULL, &frame->vps, NULL, NULL, qtrue );
+#else
+			MSG_WriteDeltaPlayerstate( msg, NULL, &frame->vps, qtrue );
+#endif
+		}
+	}
+
+	// delta encode the entities
+	SV_EmitPacketEntities (oldframe, frame, msg);
+
+	// padding for rate debugging
+	if ( sv_padPackets->integer ) {
+		for ( i = 0 ; i < sv_padPackets->integer ; i++ ) {
+			MSG_WriteByte (msg, svc_nop);
+		}
+	}
+}
+
+
+/*
+==================
+SV_UpdateServerCommandsToClient
+
+(re)send all server commands the client hasn't acknowledged yet
+==================
+*/
+void SV_UpdateServerCommandsToClient( client_t *client, msg_t *msg ) {
+	int		i;
+
+	// write any unacknowledged serverCommands
+	for ( i = client->reliableAcknowledge + 1 ; i <= client->reliableSequence ; i++ ) {
+		MSG_WriteByte( msg, svc_serverCommand );
+		MSG_WriteLong( msg, i );
+		MSG_WriteString( msg, client->reliableCommands[ i & (MAX_RELIABLE_COMMANDS-1) ] );
+	}
+	client->reliableSent = client->reliableSequence;
+}
+
+/*
+=============================================================================
+
+Build a client snapshot structure
+
+=============================================================================
+*/
+
+#define	MAX_SNAPSHOT_ENTITIES	1024
+typedef struct {
+	int		numSnapshotEntities;
+	int		snapshotEntities[MAX_SNAPSHOT_ENTITIES];	
+} snapshotEntityNumbers_t;
+
+/*
+=======================
+SV_QsortEntityNumbers
+=======================
+*/
+static int QDECL SV_QsortEntityNumbers( const void *a, const void *b ) {
+	int	*ea, *eb;
+
+	ea = (int *)a;
+	eb = (int *)b;
+
+	if ( *ea == *eb ) {
+		Com_Error( ERR_DROP, "SV_QsortEntityStates: duplicated entity" );
+	}
+
+	if ( *ea < *eb ) {
+		return -1;
+	}
+
+	return 1;
+}
+
+
+/*
+===============
+SV_AddEntToSnapshot
+===============
+*/
+static void SV_AddEntToSnapshot( svEntity_t *svEnt, sharedEntity_t *gEnt, snapshotEntityNumbers_t *eNums ) {
+	// if we have already added this entity to this snapshot, don't add again
+	if ( svEnt->snapshotCounter == sv.snapshotCounter ) {
+		return;
+	}
+	svEnt->snapshotCounter = sv.snapshotCounter;
+
+	// if we are full, silently discard entities
+	if ( eNums->numSnapshotEntities == MAX_SNAPSHOT_ENTITIES ) {
+		return;
+	}
+
+	eNums->snapshotEntities[ eNums->numSnapshotEntities ] = gEnt->s.number;
+	eNums->numSnapshotEntities++;
+}
+
+/*
+===============
+SV_AddEntitiesVisibleFromPoint
+===============
+*/
+float g_svCullDist = -1.0f;
+static void SV_AddEntitiesVisibleFromPoint( vec3_t origin, clientSnapshot_t *frame, 
+									snapshotEntityNumbers_t *eNums, qboolean portal ) {
+	int		e, i;
+	sharedEntity_t *ent;
+	svEntity_t	*svEnt;
+	int		l;
+	int		clientarea, clientcluster;
+	int		leafnum;
+	int		c_fullsend;
+#ifdef _XBOX
+	const byte *clientpvs;
+	const byte *bitvector;
+#else
+	byte	*clientpvs;
+	byte	*bitvector;
+#endif
+	vec3_t	difference;
+	float	length, radius;
+
+	// during an error shutdown message we may need to transmit
+	// the shutdown message after the server has shutdown, so
+	// specfically check for it
+	if ( !sv.state ) {
+		return;
+	}
+
+	leafnum = CM_PointLeafnum (origin);
+	clientarea = CM_LeafArea (leafnum);
+	clientcluster = CM_LeafCluster (leafnum);
+
+	// calculate the visible areas
+	frame->areabytes = CM_WriteAreaBits( frame->areabits, clientarea );
+
+	clientpvs = CM_ClusterPVS (clientcluster);
+
+	c_fullsend = 0;
+
+	for ( e = 0 ; e < sv.num_entities ; e++ ) {
+		ent = SV_GentityNum(e);
+
+		// never send entities that aren't linked in
+		if ( !ent->r.linked ) {
+			continue;
+		}
+
+		if (ent->s.eFlags & EF_PERMANENT)
+		{	// he's permanent, so don't send him down!
+			continue;
+		}
+
+		if (ent->s.number != e) {
+			Com_DPrintf ("FIXING ENT->S.NUMBER!!!\n");
+			ent->s.number = e;
+		}
+
+		// entities can be flagged to explicitly not be sent to the client
+		if ( ent->r.svFlags & SVF_NOCLIENT ) {
+			continue;
+		}
+
+		// entities can be flagged to be sent to only one client
+		if ( ent->r.svFlags & SVF_SINGLECLIENT ) {
+			if ( ent->r.singleClient != frame->ps.clientNum ) {
+				continue;
+			}
+		}
+		// entities can be flagged to be sent to everyone but one client
+		if ( ent->r.svFlags & SVF_NOTSINGLECLIENT ) {
+			if ( ent->r.singleClient == frame->ps.clientNum ) {
+				continue;
+			}
+		}
+
+		svEnt = SV_SvEntityForGentity( ent );
+
+		// don't double add an entity through portals
+		if ( svEnt->snapshotCounter == sv.snapshotCounter ) {
+			continue;
+		}
+
+		// broadcast entities are always sent, and so is the main player so we don't see noclip weirdness
+		if ( ent->r.svFlags & SVF_BROADCAST || (e == frame->ps.clientNum) || (ent->r.broadcastClients[frame->ps.clientNum/32] & (1<<(frame->ps.clientNum%32))))
+		{
+			SV_AddEntToSnapshot( svEnt, ent, eNums );
+			continue;
+		}
+
+		if (ent->s.isPortalEnt)
+		{ //rww - portal entities are always sent as well
+			SV_AddEntToSnapshot( svEnt, ent, eNums );
+			continue;
+		}
+
+		if (com_RMG && com_RMG->integer)
+		{
+			VectorAdd(ent->r.absmax, ent->r.absmin, difference);
+			VectorScale(difference, 0.5f, difference);
+			VectorSubtract(origin, difference, difference);
+			length = VectorLength(difference);
+
+			// calculate the diameter
+			VectorSubtract(ent->r.absmax, ent->r.absmin, difference);
+			radius = VectorLength(difference);
+			if (length-radius < /*sv_RMGDistanceCull->integer*/5000.0f)
+			{	// more of a diameter check
+				SV_AddEntToSnapshot( svEnt, ent, eNums );
+			}
+		}
+		else
+		{
+			// ignore if not touching a PV leaf
+			// check area
+			if ( !CM_AreasConnected( clientarea, svEnt->areanum ) ) {
+				// doors can legally straddle two areas, so
+				// we may need to check another one
+				if ( !CM_AreasConnected( clientarea, svEnt->areanum2 ) ) {
+					continue;		// blocked by a door
+				}
+			}
+
+			bitvector = clientpvs;
+
+			// check individual leafs
+			if ( !svEnt->numClusters ) {
+				continue;
+			}
+			l = 0;
+#ifdef _XBOX
+			if(bitvector) {
+#endif
+			for ( i=0 ; i < svEnt->numClusters ; i++ ) {
+				l = svEnt->clusternums[i];
+				if ( bitvector[l >> 3] & (1 << (l&7) ) ) {
+					break;
+				}
+			}
+#ifdef _XBOX
+			}
+#endif
+
+			// if we haven't found it to be visible,
+			// check overflow clusters that coudln't be stored
+#ifdef _XBOX
+			if ( bitvector && i == svEnt->numClusters ) {
+#else
+			if ( i == svEnt->numClusters ) {
+#endif
+				if ( svEnt->lastCluster ) {
+					for ( ; l <= svEnt->lastCluster ; l++ ) {
+						if ( bitvector[l >> 3] & (1 << (l&7) ) ) {
+							break;
+						}
+					}
+					if ( l == svEnt->lastCluster ) {
+						continue;	// not visible
+					}
+				} else {
+					continue;
+				}
+			}
+
+			if (g_svCullDist != -1.0f)
+			{ //do a distance cull check
+				VectorAdd(ent->r.absmax, ent->r.absmin, difference);
+				VectorScale(difference, 0.5f, difference);
+				VectorSubtract(origin, difference, difference);
+				length = VectorLength(difference);
+
+				// calculate the diameter
+				VectorSubtract(ent->r.absmax, ent->r.absmin, difference);
+				radius = VectorLength(difference);
+				if (length-radius >= g_svCullDist)
+				{ //then don't add it
+					continue;
+				}
+			}
+
+			// add it
+			SV_AddEntToSnapshot( svEnt, ent, eNums );
+
+			// if its a portal entity, add everything visible from its camera position
+			if ( ent->r.svFlags & SVF_PORTAL ) {
+				if ( ent->s.generic1 ) {
+					vec3_t dir;
+					VectorSubtract(ent->s.origin, origin, dir);
+					if ( VectorLengthSquared(dir) > (float) ent->s.generic1 * ent->s.generic1 ) {
+						continue;
+					}
+				}
+				SV_AddEntitiesVisibleFromPoint( ent->s.origin2, frame, eNums, qtrue );
+#ifdef _XBOX
+				//Must get clientpvs again since above call destroyed it.
+			clientpvs = CM_ClusterPVS (clientcluster);
+#endif
+			}
+		}
+	}
+}
+
+/*
+=============
+SV_BuildClientSnapshot
+
+Decides which entities are going to be visible to the client, and
+copies off the playerstate and areabits.
+
+This properly handles multiple recursive portals, but the render
+currently doesn't.
+
+For viewing through other player's eyes, clent can be something other than client->gentity
+=============
+*/
+static void SV_BuildClientSnapshot( client_t *client ) {
+	vec3_t						org;
+	clientSnapshot_t			*frame;
+	snapshotEntityNumbers_t		entityNumbers;
+	int							i;
+	sharedEntity_t				*ent;
+	entityState_t				*state;
+	svEntity_t					*svEnt;
+	sharedEntity_t				*clent;
+	playerState_t				*ps;
+
+	// bump the counter used to prevent double adding
+	sv.snapshotCounter++;
+
+	// this is the frame we are creating
+	frame = &client->frames[ client->netchan.outgoingSequence & PACKET_MASK ];
+
+	// clear everything in this snapshot
+	entityNumbers.numSnapshotEntities = 0;
+	Com_Memset( frame->areabits, 0, sizeof( frame->areabits ) );
+
+	frame->num_entities = 0;
+
+	clent = client->gentity;
+	if ( !clent || client->state == CS_ZOMBIE ) {
+		return;
+	}
+
+	// grab the current playerState_t
+	ps = SV_GameClientNum( client - svs.clients );
+	frame->ps = *ps;
+#ifdef _ONEBIT_COMBO
+	frame->pDeltaOneBit = &ps->deltaOneBits;
+	frame->pDeltaNumBit = &ps->deltaNumBits;
+#endif
+
+	if (ps->m_iVehicleNum)
+	{ //get the vehicle's playerstate too then
+		sharedEntity_t *veh = SV_GentityNum(ps->m_iVehicleNum);
+
+		if (veh && veh->playerState)
+		{ //Now VMA it and we've got ourselves a playerState
+			playerState_t *vps = ((playerState_t *)VM_ArgPtr((int)veh->playerState));
+
+            frame->vps = *vps;
+#ifdef _ONEBIT_COMBO
+			frame->pDeltaOneBitVeh = &vps->deltaOneBits;
+			frame->pDeltaNumBitVeh = &vps->deltaNumBits;
+#endif
+		}
+	}
+
+	int							clientNum;
+	// never send client's own entity, because it can
+	// be regenerated from the playerstate
+	clientNum = frame->ps.clientNum;
+	if ( clientNum < 0 || clientNum >= MAX_GENTITIES ) {
+		Com_Error( ERR_DROP, "SV_SvEntityForGentity: bad gEnt" );
+	}
+	svEnt = &sv.svEntities[ clientNum ];
+	svEnt->snapshotCounter = sv.snapshotCounter;
+
+	
+	// find the client's viewpoint
+	VectorCopy( ps->origin, org );
+	org[2] += ps->viewheight;
+
+	// add all the entities directly visible to the eye, which
+	// may include portal entities that merge other viewpoints
+	SV_AddEntitiesVisibleFromPoint( org, frame, &entityNumbers, qfalse );
+
+	// if there were portals visible, there may be out of order entities
+	// in the list which will need to be resorted for the delta compression
+	// to work correctly.  This also catches the error condition
+	// of an entity being included twice.
+	qsort( entityNumbers.snapshotEntities, entityNumbers.numSnapshotEntities, 
+		sizeof( entityNumbers.snapshotEntities[0] ), SV_QsortEntityNumbers );
+
+	// now that all viewpoint's areabits have been OR'd together, invert
+	// all of them to make it a mask vector, which is what the renderer wants
+	for ( i = 0 ; i < MAX_MAP_AREA_BYTES/4 ; i++ ) {
+		((int *)frame->areabits)[i] = ((int *)frame->areabits)[i] ^ -1;
+	}
+
+	// copy the entity states out
+	frame->num_entities = 0;
+	frame->first_entity = svs.nextSnapshotEntities;
+	for ( i = 0 ; i < entityNumbers.numSnapshotEntities ; i++ ) {
+		ent = SV_GentityNum(entityNumbers.snapshotEntities[i]);
+		state = &svs.snapshotEntities[svs.nextSnapshotEntities % svs.numSnapshotEntities];
+		*state = ent->s;
+		svs.nextSnapshotEntities++;
+		// this should never hit, map should always be restarted first in SV_Frame
+		if ( svs.nextSnapshotEntities >= 0x7FFFFFFE ) {
+			Com_Error(ERR_FATAL, "svs.nextSnapshotEntities wrapped");
+		}
+		frame->num_entities++;
+	}
+}
+
+
+/*
+====================
+SV_RateMsec
+
+Return the number of msec a given size message is supposed
+to take to clear, based on the current rate
+====================
+*/
+#define	HEADER_RATE_BYTES	48		// include our header, IP header, and some overhead
+static int SV_RateMsec( client_t *client, int messageSize ) {
+	int		rate;
+	int		rateMsec;
+
+	// individual messages will never be larger than fragment size
+	if ( messageSize > 1500 ) {
+		messageSize = 1500;
+	}
+	rate = client->rate;
+	if ( sv_maxRate->integer ) {
+		if ( sv_maxRate->integer < 1000 ) {
+			Cvar_Set( "sv_MaxRate", "1000" );
+		}
+		if ( sv_maxRate->integer < rate ) {
+			rate = sv_maxRate->integer;
+		}
+	}
+	rateMsec = ( messageSize + HEADER_RATE_BYTES ) * 1000 / rate;
+
+	return rateMsec;
+}
+
+/*
+=======================
+SV_SendMessageToClient
+
+Called by SV_SendClientSnapshot and SV_SendClientGameState
+=======================
+*/
+void SV_SendMessageToClient( msg_t *msg, client_t *client ) {
+	int			rateMsec;
+
+	// MW - my attempt to fix illegible server message errors caused by 
+	// packet fragmentation of initial snapshot.
+	while(client->state&&client->netchan.unsentFragments)
+	{
+		// send additional message fragments if the last message
+		// was too large to send at once
+		Com_Printf ("[ISM]SV_SendClientGameState() [1] for %s, writing out old fragments\n", client->name);
+		SV_Netchan_TransmitNextFragment(&client->netchan);
+	}
+
+	// record information about the message
+	client->frames[client->netchan.outgoingSequence & PACKET_MASK].messageSize = msg->cursize;
+	client->frames[client->netchan.outgoingSequence & PACKET_MASK].messageSent = svs.time;
+	client->frames[client->netchan.outgoingSequence & PACKET_MASK].messageAcked = -1;
+
+	// send the datagram
+	SV_Netchan_Transmit( client, msg );	//msg->cursize, msg->data );
+
+	// set nextSnapshotTime based on rate and requested number of updates
+
+	// local clients get snapshots every frame
+	if ( client->netchan.remoteAddress.type == NA_LOOPBACK || Sys_IsLANAddress (client->netchan.remoteAddress) ) {
+		client->nextSnapshotTime = svs.time - 1;
+		return;
+	}
+
+	// normal rate / snapshotMsec calculation
+	rateMsec = SV_RateMsec( client, msg->cursize );
+
+	if ( rateMsec < client->snapshotMsec ) {
+		// never send more packets than this, no matter what the rate is at
+		rateMsec = client->snapshotMsec;
+		client->rateDelayed = qfalse;
+	} else {
+		client->rateDelayed = qtrue;
+	}
+
+	client->nextSnapshotTime = svs.time + rateMsec;
+
+	// don't pile up empty snapshots while connecting
+	if ( client->state != CS_ACTIVE ) {
+		// a gigantic connection message may have already put the nextSnapshotTime
+		// more than a second away, so don't shorten it
+		// do shorten if client is downloading
+#ifdef _XBOX	// No downloads on Xbox
+		if ( client->nextSnapshotTime < svs.time + 1000 ) {
+#else
+		if ( !*client->downloadName && client->nextSnapshotTime < svs.time + 1000 ) {
+#endif
+			client->nextSnapshotTime = svs.time + 1000;
+		}
+	}
+}
+
+
+/*
+=======================
+SV_SendClientSnapshot
+
+Also called by SV_FinalMessage
+
+=======================
+*/
+extern cvar_t	*fs_gamedirvar;
+void SV_SendClientSnapshot( client_t *client ) {
+	byte		msg_buf[MAX_MSGLEN];
+	msg_t		msg;
+
+	if (!client->sentGamedir)
+	{ //rww - if this is the case then make sure there is an svc_setgame sent before this snap
+		int i = 0;
+
+		MSG_Init (&msg, msg_buf, sizeof(msg_buf));
+
+		//have to include this for each message.
+		MSG_WriteLong( &msg, client->lastClientCommand );
+
+		MSG_WriteByte (&msg, svc_setgame);
+
+		while (fs_gamedirvar->string[i])
+		{
+			MSG_WriteByte(&msg, fs_gamedirvar->string[i]);
+			i++;
+		}
+		MSG_WriteByte(&msg, 0);
+
+		// MW - my attempt to fix illegible server message errors caused by 
+		// packet fragmentation of initial snapshot.
+		//rww - reusing this code here
+		while(client->state&&client->netchan.unsentFragments)
+		{
+			// send additional message fragments if the last message
+			// was too large to send at once
+			Com_Printf ("[ISM]SV_SendClientGameState() [1] for %s, writing out old fragments\n", client->name);
+			SV_Netchan_TransmitNextFragment(&client->netchan);
+		}
+
+		// record information about the message
+		client->frames[client->netchan.outgoingSequence & PACKET_MASK].messageSize = msg.cursize;
+		client->frames[client->netchan.outgoingSequence & PACKET_MASK].messageSent = svs.time;
+		client->frames[client->netchan.outgoingSequence & PACKET_MASK].messageAcked = -1;
+
+		// send the datagram
+		SV_Netchan_Transmit( client, &msg );	//msg->cursize, msg->data );
+
+		client->sentGamedir = qtrue;
+	}
+
+	// build the snapshot
+	SV_BuildClientSnapshot( client );
+
+	// bots need to have their snapshots build, but
+	// the query them directly without needing to be sent
+	if ( client->gentity && client->gentity->r.svFlags & SVF_BOT ) {
+		return;
+	}
+
+	MSG_Init (&msg, msg_buf, sizeof(msg_buf));
+	msg.allowoverflow = qtrue;
+
+	// NOTE, MRE: all server->client messages now acknowledge
+	// let the client know which reliable clientCommands we have received
+	MSG_WriteLong( &msg, client->lastClientCommand );
+
+	// (re)send any reliable server commands
+	SV_UpdateServerCommandsToClient( client, &msg );
+
+	// send over all the relevant entityState_t
+	// and the playerState_t
+	SV_WriteSnapshotToClient( client, &msg );
+
+	// Add any download data if the client is downloading
+#ifndef _XBOX	// No downloads on Xbox
+	SV_WriteDownloadToClient( client, &msg );
+#endif
+
+	// check for overflow
+	if ( msg.overflowed ) {
+		Com_Printf ("WARNING: msg overflowed for %s\n", client->name);
+		MSG_Clear (&msg);
+	}
+
+	SV_SendMessageToClient( &msg, client );
+}
+
+
+/*
+=======================
+SV_SendClientMessages
+=======================
+*/
+void SV_SendClientMessages( void ) {
+	int			i;
+	client_t	*c;
+
+	// send a message to each connected client
+	for (i=0, c = svs.clients ; i < sv_maxclients->integer ; i++, c++) {
+		if (!c->state) {
+			continue;		// not connected
+		}
+
+		if ( svs.time < c->nextSnapshotTime ) {
+			continue;		// not time yet
+		}
+
+		// send additional message fragments if the last message
+		// was too large to send at once
+		if ( c->netchan.unsentFragments ) {
+			c->nextSnapshotTime = svs.time + 
+				SV_RateMsec( c, c->netchan.unsentLength - c->netchan.unsentFragmentStart );
+			SV_Netchan_TransmitNextFragment( &c->netchan );
+			continue;
+		}
+
+		// generate and send a new message
+		SV_SendClientSnapshot( c );
+	}
+}
+
diff --git a/codemp/server/sv_world.cpp b/codemp/server/sv_world.cpp
new file mode 100644
index 0000000..f05fb1f
--- /dev/null
+++ b/codemp/server/sv_world.cpp
@@ -0,0 +1,894 @@
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+// world.c -- world query functions
+
+#include "server.h"
+#include "../ghoul2/G2_local.h"
+extern CMiniHeap *G2VertSpaceServer;
+
+/*
+================
+SV_ClipHandleForEntity
+
+Returns a headnode that can be used for testing or clipping to a
+given entity.  If the entity is a bsp model, the headnode will
+be returned, otherwise a custom box tree will be constructed.
+================
+*/
+clipHandle_t SV_ClipHandleForEntity( const sharedEntity_t *ent ) {
+	if ( ent->r.bmodel ) {
+		// explicit hulls in the BSP model
+		return CM_InlineModel( ent->s.modelindex );
+	}
+	if ( ent->r.svFlags & SVF_CAPSULE ) {
+		// create a temp capsule from bounding box sizes
+		return CM_TempBoxModel( ent->r.mins, ent->r.maxs, qtrue );
+	}
+
+	// create a temp tree from bounding box sizes
+	return CM_TempBoxModel( ent->r.mins, ent->r.maxs, qfalse );
+}
+
+
+
+/*
+===============================================================================
+
+ENTITY CHECKING
+
+To avoid linearly searching through lists of entities during environment testing,
+the world is carved up with an evenly spaced, axially aligned bsp tree.  Entities
+are kept in chains either at the final leafs, or at the first node that splits
+them, which prevents having to deal with multiple fragments of a single entity.
+
+===============================================================================
+*/
+
+typedef struct worldSector_s {
+	int		axis;		// -1 = leaf node
+	float	dist;
+	struct worldSector_s	*children[2];
+	svEntity_t	*entities;
+} worldSector_t;
+
+#define	AREA_DEPTH	4
+#define	AREA_NODES	64
+
+worldSector_t	sv_worldSectors[AREA_NODES];
+int			sv_numworldSectors;
+
+
+/*
+===============
+SV_SectorList_f
+===============
+*/
+void SV_SectorList_f( void ) {
+	int				i, c;
+	worldSector_t	*sec;
+	svEntity_t		*ent;
+
+	for ( i = 0 ; i < AREA_NODES ; i++ ) {
+		sec = &sv_worldSectors[i];
+
+		c = 0;
+		for ( ent = sec->entities ; ent ; ent = ent->nextEntityInWorldSector ) {
+			c++;
+		}
+		Com_Printf( "sector %i: %i entities\n", i, c );
+	}
+}
+
+/*
+===============
+SV_CreateworldSector
+
+Builds a uniformly subdivided tree for the given world size
+===============
+*/
+worldSector_t *SV_CreateworldSector( int depth, vec3_t mins, vec3_t maxs ) {
+	worldSector_t	*anode;
+	vec3_t		size;
+	vec3_t		mins1, maxs1, mins2, maxs2;
+
+	anode = &sv_worldSectors[sv_numworldSectors];
+	sv_numworldSectors++;
+
+	if (depth == AREA_DEPTH) {
+		anode->axis = -1;
+		anode->children[0] = anode->children[1] = NULL;
+		return anode;
+	}
+	
+	VectorSubtract (maxs, mins, size);
+	if (size[0] > size[1]) {
+		anode->axis = 0;
+	} else {
+		anode->axis = 1;
+	}
+
+	anode->dist = 0.5 * (maxs[anode->axis] + mins[anode->axis]);
+	VectorCopy (mins, mins1);	
+	VectorCopy (mins, mins2);	
+	VectorCopy (maxs, maxs1);	
+	VectorCopy (maxs, maxs2);	
+	
+	maxs1[anode->axis] = mins2[anode->axis] = anode->dist;
+	
+	anode->children[0] = SV_CreateworldSector (depth+1, mins2, maxs2);
+	anode->children[1] = SV_CreateworldSector (depth+1, mins1, maxs1);
+
+	return anode;
+}
+
+/*
+===============
+SV_ClearWorld
+
+===============
+*/
+void SV_ClearWorld( void ) {
+	clipHandle_t	h;
+	vec3_t			mins, maxs;
+
+	Com_Memset( sv_worldSectors, 0, sizeof(sv_worldSectors) );
+	sv_numworldSectors = 0;
+
+	// get world map bounds
+	h = CM_InlineModel( 0 );
+	CM_ModelBounds( h, mins, maxs );
+	SV_CreateworldSector( 0, mins, maxs );
+}
+
+
+/*
+===============
+SV_UnlinkEntity
+
+===============
+*/
+void SV_UnlinkEntity( sharedEntity_t *gEnt ) {
+	svEntity_t		*ent;
+	svEntity_t		*scan;
+	worldSector_t	*ws;
+
+	ent = SV_SvEntityForGentity( gEnt );
+
+	gEnt->r.linked = qfalse;
+
+	ws = ent->worldSector;
+	if ( !ws ) {
+		return;		// not linked in anywhere
+	}
+	ent->worldSector = NULL;
+
+	if ( ws->entities == ent ) {
+		ws->entities = ent->nextEntityInWorldSector;
+		return;
+	}
+
+	for ( scan = ws->entities ; scan ; scan = scan->nextEntityInWorldSector ) {
+		if ( scan->nextEntityInWorldSector == ent ) {
+			scan->nextEntityInWorldSector = ent->nextEntityInWorldSector;
+			return;
+		}
+	}
+
+	Com_Printf( "WARNING: SV_UnlinkEntity: not found in worldSector\n" );
+}
+
+
+/*
+===============
+SV_LinkEntity
+
+===============
+*/
+#define MAX_TOTAL_ENT_LEAFS		128
+void SV_LinkEntity( sharedEntity_t *gEnt ) {
+	worldSector_t	*node;
+	int			leafs[MAX_TOTAL_ENT_LEAFS];
+	int			cluster;
+	int			num_leafs;
+	int			i, j, k;
+	int			area;
+	int			lastLeaf;
+	float		*origin, *angles;
+	svEntity_t	*ent;
+
+	ent = SV_SvEntityForGentity( gEnt );
+
+	if ( ent->worldSector ) {
+		SV_UnlinkEntity( gEnt );	// unlink from old position
+	}
+
+	// encode the size into the entityState_t for client prediction
+	if ( gEnt->r.bmodel ) {
+		gEnt->s.solid = SOLID_BMODEL;		// a solid_box will never create this value
+	} else if ( gEnt->r.contents & ( CONTENTS_SOLID | CONTENTS_BODY ) ) {
+		// assume that x/y are equal and symetric
+		i = gEnt->r.maxs[0];
+		if (i<1)
+			i = 1;
+		if (i>255)
+			i = 255;
+
+		// z is not symetric
+		j = (-gEnt->r.mins[2]);
+		if (j<1)
+			j = 1;
+		if (j>255)
+			j = 255;
+
+		// and z maxs can be negative...
+		k = (gEnt->r.maxs[2]+32);
+		if (k<1)
+			k = 1;
+		if (k>255)
+			k = 255;
+
+		gEnt->s.solid = (k<<16) | (j<<8) | i;
+
+		if (gEnt->s.solid == SOLID_BMODEL)
+		{ //yikes, this would make everything explode violently.
+			gEnt->s.solid = (k<<16) | (j<<8) | i-1;
+		}
+	}
+	else
+	{
+		gEnt->s.solid = 0;
+	}
+
+	// get the position
+	origin = gEnt->r.currentOrigin;
+	angles = gEnt->r.currentAngles;
+
+	// set the abs box
+	if ( gEnt->r.bmodel && (angles[0] || angles[1] || angles[2]) ) {
+		// expand for rotation
+		float		max;
+		int			i;
+
+		max = RadiusFromBounds( gEnt->r.mins, gEnt->r.maxs );
+		for (i=0 ; i<3 ; i++) {
+			gEnt->r.absmin[i] = origin[i] - max;
+			gEnt->r.absmax[i] = origin[i] + max;
+		}
+	} else {
+		// normal
+		VectorAdd (origin, gEnt->r.mins, gEnt->r.absmin);	
+		VectorAdd (origin, gEnt->r.maxs, gEnt->r.absmax);
+	}
+
+	// because movement is clipped an epsilon away from an actual edge,
+	// we must fully check even when bounding boxes don't quite touch
+	gEnt->r.absmin[0] -= 1;
+	gEnt->r.absmin[1] -= 1;
+	gEnt->r.absmin[2] -= 1;
+	gEnt->r.absmax[0] += 1;
+	gEnt->r.absmax[1] += 1;
+	gEnt->r.absmax[2] += 1;
+
+	// link to PVS leafs
+	ent->numClusters = 0;
+	ent->lastCluster = 0;
+	ent->areanum = -1;
+	ent->areanum2 = -1;
+
+	//get all leafs, including solids
+	num_leafs = CM_BoxLeafnums( gEnt->r.absmin, gEnt->r.absmax,
+		leafs, MAX_TOTAL_ENT_LEAFS, &lastLeaf );
+
+	// if none of the leafs were inside the map, the
+	// entity is outside the world and can be considered unlinked
+	if ( !num_leafs ) {
+		return;
+	}
+
+	// set areas, even from clusters that don't fit in the entity array
+	for (i=0 ; i<num_leafs ; i++) {
+		area = CM_LeafArea (leafs[i]);
+		if (area != -1) {
+			// doors may legally straggle two areas,
+			// but nothing should evern need more than that
+			if (ent->areanum != -1 && ent->areanum != area) {
+				if (ent->areanum2 != -1 && ent->areanum2 != area && sv.state == SS_LOADING) {
+					Com_DPrintf ("Object %i touching 3 areas at %f %f %f\n",
+					gEnt->s.number,
+					gEnt->r.absmin[0], gEnt->r.absmin[1], gEnt->r.absmin[2]);
+				}
+				ent->areanum2 = area;
+			} else {
+				ent->areanum = area;
+			}
+		}
+	}
+
+	// store as many explicit clusters as we can
+	ent->numClusters = 0;
+	for (i=0 ; i < num_leafs ; i++) {
+		cluster = CM_LeafCluster( leafs[i] );
+		if ( cluster != -1 ) {
+			ent->clusternums[ent->numClusters++] = cluster;
+			if ( ent->numClusters == MAX_ENT_CLUSTERS ) {
+				break;
+			}
+		}
+	}
+
+	// store off a last cluster if we need to
+	if ( i != num_leafs ) {
+		ent->lastCluster = CM_LeafCluster( lastLeaf );
+	}
+
+	gEnt->r.linkcount++;
+
+	// find the first world sector node that the ent's box crosses
+	node = sv_worldSectors;
+	while (1)
+	{
+		if (node->axis == -1)
+			break;
+		if ( gEnt->r.absmin[node->axis] > node->dist)
+			node = node->children[0];
+		else if ( gEnt->r.absmax[node->axis] < node->dist)
+			node = node->children[1];
+		else
+			break;		// crosses the node
+	}
+	
+	// link it in
+	ent->worldSector = node;
+	ent->nextEntityInWorldSector = node->entities;
+	node->entities = ent;
+
+	gEnt->r.linked = qtrue;
+}
+
+/*
+============================================================================
+
+AREA QUERY
+
+Fills in a list of all entities who's absmin / absmax intersects the given
+bounds.  This does NOT mean that they actually touch in the case of bmodels.
+============================================================================
+*/
+
+typedef struct {
+	const float	*mins;
+	const float	*maxs;
+	int			*list;
+	int			count, maxcount;
+} areaParms_t;
+
+
+/*
+====================
+SV_AreaEntities_r
+
+====================
+*/
+void SV_AreaEntities_r( worldSector_t *node, areaParms_t *ap ) {
+	svEntity_t	*check, *next;
+	sharedEntity_t *gcheck;
+	int			count;
+
+	count = 0;
+
+	for ( check = node->entities  ; check ; check = next ) {
+		next = check->nextEntityInWorldSector;
+
+		gcheck = SV_GEntityForSvEntity( check );
+
+		if ( gcheck->r.absmin[0] > ap->maxs[0]
+		|| gcheck->r.absmin[1] > ap->maxs[1]
+		|| gcheck->r.absmin[2] > ap->maxs[2]
+		|| gcheck->r.absmax[0] < ap->mins[0]
+		|| gcheck->r.absmax[1] < ap->mins[1]
+		|| gcheck->r.absmax[2] < ap->mins[2]) {
+			continue;
+		}
+
+		if ( ap->count == ap->maxcount ) {
+			Com_DPrintf ("SV_AreaEntities: MAXCOUNT\n");
+			return;
+		}
+
+		ap->list[ap->count] = check - sv.svEntities;
+		ap->count++;
+	}
+	
+	if (node->axis == -1) {
+		return;		// terminal node
+	}
+
+	// recurse down both sides
+	if ( ap->maxs[node->axis] > node->dist ) {
+		SV_AreaEntities_r ( node->children[0], ap );
+	}
+	if ( ap->mins[node->axis] < node->dist ) {
+		SV_AreaEntities_r ( node->children[1], ap );
+	}
+}
+
+/*
+================
+SV_AreaEntities
+================
+*/
+int SV_AreaEntities( const vec3_t mins, const vec3_t maxs, int *entityList, int maxcount ) {
+	areaParms_t		ap;
+
+	ap.mins = mins;
+	ap.maxs = maxs;
+	ap.list = entityList;
+	ap.count = 0;
+	ap.maxcount = maxcount;
+
+	SV_AreaEntities_r( sv_worldSectors, &ap );
+
+	return ap.count;
+}
+
+
+
+//===========================================================================
+
+
+typedef struct {
+	vec3_t		boxmins, boxmaxs;// enclose the test object along entire move
+	const float	*mins;
+	const float *maxs;	// size of the moving object
+/*
+Ghoul2 Insert Start
+*/
+	vec3_t		start;
+
+	vec3_t		end;
+
+	int			passEntityNum;
+	int			contentmask;
+	int			capsule;
+
+	int			traceFlags;
+	int			useLod;
+	trace_t		trace;			// make sure nothing goes under here for Ghoul2 collision purposes
+/*
+Ghoul2 Insert End
+*/
+} moveclip_t;
+
+
+/*
+====================
+SV_ClipToEntity
+
+====================
+*/
+void SV_ClipToEntity( trace_t *trace, const vec3_t start, const vec3_t mins, const vec3_t maxs, const vec3_t end, int entityNum, int contentmask, int capsule ) {
+	sharedEntity_t	*touch;
+	clipHandle_t	clipHandle;
+	float			*origin, *angles;
+
+	touch = SV_GentityNum( entityNum );
+
+	Com_Memset(trace, 0, sizeof(trace_t));
+
+	// if it doesn't have any brushes of a type we
+	// are looking for, ignore it
+	if ( ! ( contentmask & touch->r.contents ) ) {
+		trace->fraction = 1.0;
+		return;
+	}
+
+	// might intersect, so do an exact clip
+	clipHandle = SV_ClipHandleForEntity (touch);
+
+	origin = touch->r.currentOrigin;
+	angles = touch->r.currentAngles;
+
+	if ( !touch->r.bmodel ) {
+		angles = vec3_origin;	// boxes don't rotate
+	}
+
+	CM_TransformedBoxTrace ( trace, (float *)start, (float *)end,
+		(float *)mins, (float *)maxs, clipHandle,  contentmask,
+		origin, angles, capsule);
+
+	if ( trace->fraction < 1 ) {
+		trace->entityNum = touch->s.number;
+	}
+}
+
+
+/*
+====================
+SV_ClipMoveToEntities
+
+====================
+*/
+#ifndef FINAL_BUILD
+static float VectorDistance(vec3_t p1, vec3_t p2) 
+{
+	vec3_t dir;
+
+	VectorSubtract(p2, p1, dir);
+	return VectorLength(dir);
+}
+#endif
+#pragma warning(disable : 4701) //local variable used without having been init
+static void SV_ClipMoveToEntities( moveclip_t *clip ) {
+	static int	touchlist[MAX_GENTITIES];
+	int			i, num;
+	sharedEntity_t *touch;
+	int			passOwnerNum;
+	trace_t		trace, oldTrace= {0};
+	clipHandle_t	clipHandle;
+	float		*origin, *angles;
+	int			thisOwnerShared = 1;
+
+	num = SV_AreaEntities( clip->boxmins, clip->boxmaxs, touchlist, MAX_GENTITIES);
+
+	if ( clip->passEntityNum != ENTITYNUM_NONE ) {
+		passOwnerNum = ( SV_GentityNum( clip->passEntityNum ) )->r.ownerNum;
+		if ( passOwnerNum == ENTITYNUM_NONE ) {
+			passOwnerNum = -1;
+		}
+	} else {
+		passOwnerNum = -1;
+	}
+
+	if ( SV_GentityNum(clip->passEntityNum)->r.svFlags & SVF_OWNERNOTSHARED )
+	{
+		thisOwnerShared = 0;
+	}
+
+	for ( i=0 ; i<num ; i++ ) {
+		if ( clip->trace.allsolid ) {
+			return;
+		}
+		touch = SV_GentityNum( touchlist[i] );
+
+		// see if we should ignore this entity
+		if ( clip->passEntityNum != ENTITYNUM_NONE ) {
+			if ( touchlist[i] == clip->passEntityNum ) {
+				continue;	// don't clip against the pass entity
+			}
+			if ( touch->r.ownerNum == clip->passEntityNum) {
+				if (touch->r.svFlags & SVF_OWNERNOTSHARED)
+				{
+					if ( clip->contentmask != (MASK_SHOT | CONTENTS_LIGHTSABER) &&
+						clip->contentmask != (MASK_SHOT))
+					{ //it's not a laser hitting the other "missile", don't care then
+						continue;
+					}
+				}
+				else
+				{
+					continue;	// don't clip against own missiles
+				}
+			}
+			if ( touch->r.ownerNum == passOwnerNum &&
+				!(touch->r.svFlags & SVF_OWNERNOTSHARED) &&
+				thisOwnerShared ) {
+				continue;	// don't clip against other missiles from our owner
+			}
+
+			if (touch->s.eType == ET_MISSILE &&
+				!(touch->r.svFlags & SVF_OWNERNOTSHARED) &&
+				touch->r.ownerNum == passOwnerNum)
+			{ //blah, hack
+				continue;
+			}
+		}
+
+		// if it doesn't have any brushes of a type we
+		// are looking for, ignore it
+		if ( ! ( clip->contentmask & touch->r.contents ) ) {
+			continue;
+		}
+
+		if ((clip->contentmask == (MASK_SHOT|CONTENTS_LIGHTSABER) || clip->contentmask == MASK_SHOT) && (touch->r.contents > 0 && (touch->r.contents & CONTENTS_NOSHOT)))
+		{
+			continue;
+		}
+
+		// might intersect, so do an exact clip
+		clipHandle = SV_ClipHandleForEntity (touch);
+
+		origin = touch->r.currentOrigin;
+		angles = touch->r.currentAngles;
+
+
+		if ( !touch->r.bmodel ) {
+			angles = vec3_origin;	// boxes don't rotate
+		}
+
+		CM_TransformedBoxTrace ( &trace, (float *)clip->start, (float *)clip->end,
+			(float *)clip->mins, (float *)clip->maxs, clipHandle,  clip->contentmask,
+			origin, angles, clip->capsule);
+
+
+		if (clip->traceFlags & G2TRFLAG_DOGHOULTRACE)
+		{ // keep these older variables around for a bit, incase we need to replace them in the Ghoul2 Collision check
+			oldTrace = clip->trace;
+		}
+
+		if ( trace.allsolid ) {
+			clip->trace.allsolid = qtrue;
+			trace.entityNum = touch->s.number;
+		} else if ( trace.startsolid ) {
+			clip->trace.startsolid = qtrue;
+			trace.entityNum = touch->s.number;
+
+			//rww - added this because we want to get the number of an ent even if our trace starts inside it.
+			clip->trace.entityNum = touch->s.number;
+		}
+
+		if ( trace.fraction < clip->trace.fraction ) {
+			byte	oldStart;
+
+			// make sure we keep a startsolid from a previous trace
+			oldStart = clip->trace.startsolid;
+
+			trace.entityNum = touch->s.number;
+			clip->trace = trace;
+			clip->trace.startsolid = (qboolean)((unsigned)clip->trace.startsolid | (unsigned)oldStart);
+		}
+/*
+Ghoul2 Insert Start
+*/
+#if 0
+		// decide if we should do the ghoul2 collision detection right here
+		if ((trace.entityNum == touch->s.number) && (clip->traceFlags))
+		{
+			// do we actually have a ghoul2 model here?
+			if (touch->s.ghoul2)
+			{
+				int			oldTraceRecSize = 0;
+				int			newTraceRecSize = 0;
+				int			z;
+
+				// we have to do this because sometimes you may hit a model's bounding box, but not actually penetrate the Ghoul2 Models polygons
+				// this is, needless to say, not good. So we must check to see if we did actually hit the model, and if not, reset the trace stuff
+				// to what it was to begin with
+
+				// set our trace record size
+				for (z=0;z<MAX_G2_COLLISIONS;z++)
+				{
+					if (clip->trace.G2CollisionMap[z].mEntityNum != -1)
+					{
+						oldTraceRecSize++;
+					}
+				}
+
+				G2API_CollisionDetect(&clip->trace.G2CollisionMap[0], *((CGhoul2Info_v *)touch->s.ghoul2),
+					touch->s.angles, touch->s.origin, svs.time, touch->s.number, clip->start, clip->end, touch->s.modelScale, G2VertSpaceServer, clip->traceFlags, clip->useLod);
+
+				// set our new trace record size
+ 
+				for (z=0;z<MAX_G2_COLLISIONS;z++)
+				{
+					if (clip->trace.G2CollisionMap[z].mEntityNum != -1)
+					{
+						newTraceRecSize++;
+					}
+				}
+
+				// did we actually touch this model? If not, lets reset this ent as being hit..
+				if (newTraceRecSize == oldTraceRecSize)
+				{
+					clip->trace = oldTrace;
+				}
+			}
+		}
+#else
+		//rww - since this is multiplayer and we don't have the luxury of violating networking rules in horrible ways,
+		//this must be done somewhat differently.
+		if ((clip->traceFlags & G2TRFLAG_DOGHOULTRACE) && trace.entityNum == touch->s.number && touch->ghoul2 && ((clip->traceFlags & G2TRFLAG_HITCORPSES) || !(touch->s.eFlags & EF_DEAD)))
+		{ //standard behavior will be to ignore g2 col on dead ents, but if traceFlags is set to allow, then we'll try g2 col on EF_DEAD people too.
+			static G2Trace_t G2Trace;
+			vec3_t angles;
+			float fRadius = 0.0f;
+			int tN = 0;
+			int bestTr = -1;
+
+			if (clip->mins[0] ||
+				clip->maxs[0])
+			{
+				fRadius=(clip->maxs[0]-clip->mins[0])/2.0f;
+			}
+
+			if (clip->traceFlags & G2TRFLAG_THICK)
+			{ //if using this flag, make sure it's at least 1.0f
+				if (fRadius < 1.0f)
+				{
+					fRadius = 1.0f;
+				}
+			}
+
+			memset (&G2Trace, 0, sizeof(G2Trace));
+			while (tN < MAX_G2_COLLISIONS)
+			{
+				G2Trace[tN].mEntityNum = -1;
+				tN++;
+			}
+
+			if (touch->s.number < MAX_CLIENTS)
+			{
+				VectorCopy(touch->s.apos.trBase, angles);
+			}
+			else
+			{
+				VectorCopy(touch->r.currentAngles, angles);
+			}
+			angles[ROLL] = angles[PITCH] = 0;
+
+			//I would think that you could trace from trace.endpos instead of clip->start, but that causes it to miss sometimes.. Not sure what it's off, but if it could be done like that, it would probably
+			//be faster.
+#ifndef FINAL_BUILD
+			if (sv_showghoultraces->integer)
+			{
+				Com_Printf( "Ghoul2 trace   lod=%1d   length=%6.0f   to %s\n",clip->useLod,VectorDistance(clip->start, clip->end),(*((CGhoul2Info_v *)touch->ghoul2))[0].mFileName);
+			}
+#endif
+			G2API_CollisionDetect(G2Trace, *((CGhoul2Info_v *)touch->ghoul2), angles, touch->r.currentOrigin, svs.time, touch->s.number, clip->start, clip->end, touch->modelScale, G2VertSpaceServer, 0, clip->useLod, fRadius);
+
+
+			tN = 0;
+			while (tN < MAX_G2_COLLISIONS)
+			{
+				if (G2Trace[tN].mEntityNum == touch->s.number)
+				{ //ok, valid
+					bestTr = tN;
+					break;
+				}
+				else if (G2Trace[tN].mEntityNum == -1)
+				{ //there should not be any after the first -1
+					break;
+				}
+				tN++;
+			}
+
+			if (bestTr == -1)
+			{ //Well then, put the trace back to the old one.
+				clip->trace = oldTrace;
+			}
+			else
+			{ //Otherwise, set the endpos/normal/etc. to the model location hit instead of leaving it out in space.
+				VectorCopy(G2Trace[bestTr].mCollisionPosition, clip->trace.endpos);
+				VectorCopy(G2Trace[bestTr].mCollisionNormal, clip->trace.plane.normal);
+
+				if (clip->traceFlags & G2TRFLAG_GETSURFINDEX)
+				{ //we have requested that surfaceFlags be stomped over with the g2 hit surface index.
+					if (clip->trace.entityNum == G2Trace[bestTr].mEntityNum)
+					{
+						clip->trace.surfaceFlags = G2Trace[bestTr].mSurfaceIndex;
+					}
+				}
+			}
+		}
+#endif
+/*
+Ghoul2 Insert End
+*/
+	}
+}
+#pragma warning(default : 4701) //local variable used without having been init
+
+/*
+==================
+SV_Trace
+
+Moves the given mins/maxs volume through the world from start to end.
+passEntityNum and entities owned by passEntityNum are explicitly not checked.
+==================
+*/
+/*
+Ghoul2 Insert Start
+*/
+void SV_Trace( trace_t *results, const vec3_t start, const vec3_t mins, const vec3_t maxs, const vec3_t end, int passEntityNum, int contentmask, int capsule, int traceFlags, int useLod ) {
+/*
+Ghoul2 Insert End
+*/
+	moveclip_t	clip;
+	int			i;
+
+	if ( !mins ) {
+		mins = vec3_origin;
+	}
+	if ( !maxs ) {
+		maxs = vec3_origin;
+	}
+
+	Com_Memset ( &clip, 0, sizeof ( moveclip_t ) );
+
+	// clip to world
+	CM_BoxTrace( &clip.trace, start, end, mins, maxs, 0, contentmask, capsule );
+	clip.trace.entityNum = clip.trace.fraction != 1.0 ? ENTITYNUM_WORLD : ENTITYNUM_NONE;
+	if ( clip.trace.fraction == 0 ) {
+		*results = clip.trace;
+		return;		// blocked immediately by the world
+	}
+
+	clip.contentmask = contentmask;
+/*
+Ghoul2 Insert Start
+*/	
+	VectorCopy( start, clip.start );
+	clip.traceFlags = traceFlags;
+	clip.useLod = useLod;
+/*
+Ghoul2 Insert End
+*/
+//	VectorCopy( clip.trace.endpos, clip.end );
+	VectorCopy( end, clip.end );
+	clip.mins = mins;
+	clip.maxs = maxs;
+	clip.passEntityNum = passEntityNum;
+	clip.capsule = capsule;
+
+	// create the bounding box of the entire move
+	// we can limit it to the part of the move not
+	// already clipped off by the world, which can be
+	// a significant savings for line of sight and shot traces
+	for ( i=0 ; i<3 ; i++ ) {
+		if ( end[i] > start[i] ) {
+			clip.boxmins[i] = clip.start[i] + clip.mins[i] - 1;
+			clip.boxmaxs[i] = clip.end[i] + clip.maxs[i] + 1;
+		} else {
+			clip.boxmins[i] = clip.end[i] + clip.mins[i] - 1;
+			clip.boxmaxs[i] = clip.start[i] + clip.maxs[i] + 1;
+		}
+	}
+
+	// clip to other solid entities
+	SV_ClipMoveToEntities ( &clip );
+
+	*results = clip.trace;
+}
+
+
+
+/*
+=============
+SV_PointContents
+=============
+*/
+int SV_PointContents( const vec3_t p, int passEntityNum ) {
+	int			touch[MAX_GENTITIES];
+	sharedEntity_t *hit;
+	int			i, num;
+	int			contents, c2;
+	clipHandle_t	clipHandle;
+	float		*angles;
+
+	// get base contents from world
+	contents = CM_PointContents( p, 0 );
+
+	// or in contents from all the other entities
+	num = SV_AreaEntities( p, p, touch, MAX_GENTITIES );
+
+	for ( i=0 ; i<num ; i++ ) {
+		if ( touch[i] == passEntityNum ) {
+			continue;
+		}
+		hit = SV_GentityNum( touch[i] );
+		// might intersect, so do an exact clip
+		clipHandle = SV_ClipHandleForEntity( hit );
+		angles = hit->s.angles;
+		if ( !hit->r.bmodel ) {
+			angles = vec3_origin;	// boxes don't rotate
+		}
+
+		c2 = CM_TransformedPointContents (p, clipHandle, hit->s.origin, hit->s.angles);
+
+		contents |= c2;
+	}
+
+	return contents;
+}
+
+
diff --git a/codemp/server/vssver.scc b/codemp/server/vssver.scc
new file mode 100644
index 0000000..a124f85
Binary files /dev/null and b/codemp/server/vssver.scc differ
diff --git a/codemp/smartheap/HA312W32.DLL b/codemp/smartheap/HA312W32.DLL
new file mode 100644
index 0000000..2b1ea82
Binary files /dev/null and b/codemp/smartheap/HA312W32.DLL differ
diff --git a/codemp/smartheap/HAW32M.LIB b/codemp/smartheap/HAW32M.LIB
new file mode 100644
index 0000000..1fc259c
Binary files /dev/null and b/codemp/smartheap/HAW32M.LIB differ
diff --git a/codemp/smartheap/HEAPAGNT.H b/codemp/smartheap/HEAPAGNT.H
new file mode 100644
index 0000000..6dbdb8c
--- /dev/null
+++ b/codemp/smartheap/HEAPAGNT.H
@@ -0,0 +1,442 @@
+/* heapagnt.h -- HeapAgent (tm) public C/C++ header file
+ *
+ * Copyright (C) 1991-1997 Compuware Corporation.
+ * All Rights Reserved.
+ *
+ * No part of this source code may be copied, modified or reproduced
+ * in any form without retaining the above copyright notice.
+ * This source code, or source code derived from it, may not be redistributed
+ * without express written permission of the copyright owner.
+ *
+ */
+
+#if !defined(_HEAPAGNT_H)
+#define _HEAPAGNT_H
+
+#if !defined(_SMARTHEAP_H)
+#include "smrtheap.h"
+#endif /* _SMARTHEAP_H */
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define HA_MAJOR_VERSION 3
+#define HA_MINOR_VERSION 1
+#define HA_UPDATE_LEVEL 2
+
+   
+/*** Types ***/
+
+/* Saftey Levels: parameter to dbgMemSetSafetyLevel */
+typedef enum
+{
+   MEM_SAFETY_SOME=2,     /* fast: minimal debug performance degredation   */
+   MEM_SAFETY_FULL,       /* slower: recommended during development        */
+   MEM_SAFETY_DEBUG,      /* entire memory pool is checked each entrypoint */
+   MEM_SAFETY_LEVEL_INT_MAX = INT_MAX  /* to ensure enum is full int in size */
+} MEM_SAFETY_LEVEL;
+
+/* Pointer types: parameter to dbgMemCheckPtr */
+typedef enum
+{
+   MEM_POINTER_HEAP,
+   MEM_POINTER_STACK,
+   MEM_POINTER_STATIC,
+   MEM_POINTER_CODE,
+   MEM_POINTER_READONLY,
+   MEM_POINTER_READWRITE
+} MEM_POINTER_TYPE;
+
+/* Debug Pool Info: parameter to dbgMemPoolInfo */
+typedef struct
+{
+   MEM_POOL pool;
+   const char MEM_FAR *name;
+   MEM_API createAPI;
+   const char MEM_FAR *createFile;
+   int createLine;
+   unsigned long createPass;
+   unsigned long createAllocCount;
+   unsigned createCheckpoint;
+   int isDeferFreeing;
+   unsigned long deferQueueLength;
+   unsigned checkFrequency;
+   MEM_ERROR_INFO lastOkInfo;
+   unsigned long threadID;
+   unsigned long pid;
+	void *callStack[MEM_MAXCALLSTACK];
+} DBGMEM_POOL_INFO;
+
+/* Debug Ptr Info: parameter to dbgMemPtrInfo */
+typedef struct
+{
+   void MEM_FAR *ptr;
+   MEM_POOL pool;
+   unsigned long argSize;
+   MEM_BLOCK_TYPE blockType;
+   MEM_BOOL isInUse;
+   MEM_API createAPI;
+   const char MEM_FAR *createFile;
+   int createLine;
+   unsigned long createPass;
+   unsigned checkpoint;
+   unsigned long allocCount;
+   MEM_BOOL isDeferFreed;
+   MEM_BOOL isFreeFillSuppressed;
+   MEM_BOOL isReadOnly;
+   MEM_BOOL isNoFree;
+   MEM_BOOL isNoRealloc;
+   unsigned long threadID;
+   unsigned long pid;
+	void MEM_FAR *callStack[MEM_MAXCALLSTACK];
+} DBGMEM_PTR_INFO;
+
+/* Stack checking settting: parameter to dbgMemSetStackChecking */
+typedef enum
+{
+	DBGMEM_STACK_CHECK_NONE=1,
+	DBGMEM_STACK_CHECK_ENTRY,
+	DBGMEM_STACK_CHECK_RETURN,
+	DBGMEM_STACK_CHECK_INT_MAX = INT_MAX  /* to ensure enum is full int size */
+} DBGMEM_STACK_CHECKING;
+
+/* Debug Settings Info: parameter to dbgMemSettingsInfo */
+typedef struct
+{
+   MEM_SAFETY_LEVEL safetyLevel;
+   unsigned checkFrequency;
+   unsigned long allocCount;
+   unsigned checkpoint;
+   MEM_BOOL isDeferFreeing;
+   unsigned long deferQueueLength;
+   unsigned long deferSizeThreshold;
+   MEM_BOOL isFreeFillSuppressed;
+   MEM_BOOL isReallocAlwaysMoves;
+   MEM_BOOL isWrongTaskRefReported;
+   unsigned outputFlags;
+   const char MEM_FAR *outputFile;
+   unsigned guardSize;
+	unsigned callstackChains;
+	DBGMEM_STACK_CHECKING stackChecking;
+   unsigned char guardFill;
+   unsigned char freeFill;
+   unsigned char inUseFill;
+} DBGMEM_SETTINGS_INFO;
+
+/* Trace function pointer: parameter to dbgMemSet[Entry/Exit]Handler */
+typedef void (MEM_ENTRY2 * MEM_ENTRY3 MEM_TRACE_FN)
+   (MEM_ERROR_INFO MEM_FAR *, unsigned long);
+
+/* define and initialize these variables at file scope to change defaults */
+extern const unsigned dbgMemGuardSize;
+extern const unsigned char dbgMemGuardFill;
+extern const unsigned char dbgMemFreeFill;
+extern const unsigned char dbgMemInUseFill;
+
+#define DBGMEM_PTR_NOPROTECTION    0x0000u
+#define DBGMEM_PTR_READONLY        0x0001u
+#define DBGMEM_PTR_NOFREE          0x0002u
+#define DBGMEM_PTR_NOREALLOC       0x0004u
+
+#define DBGMEM_OUTPUT_PROMPT       0x0001u
+#define DBGMEM_OUTPUT_CONSOLE      0x0002u
+#define DBGMEM_OUTPUT_BEEP         0x0004u
+#define DBGMEM_OUTPUT_FILE         0x0010u
+#define DBGMEM_OUTPUT_FILE_APPEND  0x0020u
+
+
+
+/*** Function Prototypes ***/
+
+#ifdef MEM_DEBUG
+
+#if defined(MEM_WIN16) || defined(MEM_WIN32)
+#define SHI_MAJOR_VERSION HA_MAJOR_VERSION
+#define SHI_MINOR_VERSION HA_MINOR_VERSION
+#define SHI_UPDATE_LEVEL HA_UPDATE_LEVEL
+#endif /* MEM_WIN16 || MEM_WIN32 */
+
+/* malloc, new, et al call these entry-point in debug lib */
+MEM_ENTRY1 void MEM_FAR * MEM_ENTRY _dbgMemAllocPtr1(MEM_POOL, unsigned long,
+   unsigned, MEM_API, const char MEM_FAR *, int);
+MEM_ENTRY1 MEM_BOOL MEM_ENTRY _dbgMemFreePtr1(void MEM_FAR *, MEM_API,
+   const char MEM_FAR *, int);
+MEM_ENTRY1 void MEM_FAR * MEM_ENTRY _dbgMemReAllocPtr1(void MEM_FAR *,
+   unsigned long, unsigned, MEM_API, const char MEM_FAR *, int);
+MEM_ENTRY1 unsigned long MEM_ENTRY _dbgMemSizePtr1(void MEM_FAR *, MEM_API,
+   const char MEM_FAR *, int);
+void MEM_FAR * MEM_ENTRY _dbgMEM_alloc(size_t, unsigned, MEM_API,
+                                       const char MEM_FAR *, int);
+void MEM_FAR * MEM_ENTRY _dbgMEM_realloc(void MEM_FAR *, size_t,
+                                         const char MEM_FAR *, int);
+void MEM_ENTRY _dbgMEM_free(void MEM_FAR *, const char MEM_FAR *, int);
+MEM_ENTRY1 void MEM_ENTRY _shi_deleteLoc(const char MEM_FAR *file, int line);
+
+
+/* functions to control error detection */
+MEM_ENTRY1 MEM_SAFETY_LEVEL MEM_ENTRY dbgMemSetSafetyLevel(MEM_SAFETY_LEVEL);
+MEM_ENTRY1 MEM_BOOL MEM_ENTRY dbgMemSetGuardSize(unsigned);
+MEM_ENTRY1 MEM_BOOL MEM_ENTRY dbgMemSetGuardFill(MEM_UCHAR);
+MEM_ENTRY1 MEM_BOOL MEM_ENTRY dbgMemSetFreeFill(MEM_UCHAR);
+MEM_ENTRY1 MEM_BOOL MEM_ENTRY dbgMemSetInUseFill(MEM_UCHAR);
+MEM_ENTRY1 MEM_BOOL MEM_ENTRY dbgMemSetCallstackChains(unsigned);
+MEM_ENTRY1 MEM_BOOL MEM_ENTRY dbgMemSetStackChecking(DBGMEM_STACK_CHECKING);
+MEM_ENTRY1 unsigned MEM_ENTRY dbgMemSetCheckpoint(unsigned);
+MEM_ENTRY1 unsigned MEM_ENTRY _dbgMemPoolSetCheckFrequency(MEM_POOL,
+   unsigned, const char MEM_FAR *, int);
+MEM_ENTRY1 MEM_BOOL MEM_ENTRY _dbgMemPoolDeferFreeing(MEM_POOL, int,
+   const char MEM_FAR *, int);
+MEM_ENTRY1 MEM_BOOL MEM_ENTRY _dbgMemPoolFreeDeferred(MEM_POOL,
+   const char MEM_FAR *, int);
+MEM_ENTRY1 MEM_BOOL MEM_ENTRY _dbgMemProtectPtr(void MEM_FAR *, unsigned,
+   const char MEM_FAR *, int);
+
+/* functions to control error reporting */
+MEM_ENTRY1 unsigned MEM_ENTRY dbgMemFormatErrorInfo(MEM_ERROR_INFO MEM_FAR *,
+   char MEM_FAR *, unsigned);
+MEM_ENTRY1 unsigned MEM_ENTRY dbgMemFormatCall(MEM_ERROR_INFO MEM_FAR *,
+   char MEM_FAR *, unsigned);
+MEM_ENTRY1 MEM_BOOL MEM_ENTRY dbgMemSetDefaultErrorOutput(unsigned flags,
+   const char MEM_FAR *file);
+MEM_ENTRY1 MEM_TRACE_FN MEM_ENTRY dbgMemSetEntryHandler(MEM_TRACE_FN);
+MEM_ENTRY1 MEM_TRACE_FN MEM_ENTRY dbgMemSetExitHandler(MEM_TRACE_FN);
+MEM_ENTRY1 MEM_BOOL MEM_ENTRY _dbgMemReportLeakage(MEM_POOL,unsigned,unsigned,
+   const char MEM_FAR *, unsigned);
+
+MEM_ENTRY1 unsigned long MEM_ENTRY _dbgMemTotalCount(const char MEM_FAR *, int);
+MEM_ENTRY1 unsigned long MEM_ENTRY _dbgMemTotalSize(const char MEM_FAR *, int);
+MEM_ENTRY1 void MEM_ENTRY _dbgMemBreakpoint(const char MEM_FAR *, int);
+MEM_ENTRY1 MEM_BOOL MEM_ENTRY _dbg_MemPoolInfo(MEM_POOL,
+   DBGMEM_POOL_INFO MEM_FAR *, const char MEM_FAR *, int);
+MEM_ENTRY1 MEM_BOOL MEM_ENTRY _dbgMemPtrInfo(void MEM_FAR *,
+   DBGMEM_PTR_INFO MEM_FAR *, const char MEM_FAR *, int);
+MEM_ENTRY1 MEM_BOOL MEM_ENTRY _dbgMemSettingsInfo(
+   DBGMEM_SETTINGS_INFO MEM_FAR *, const char MEM_FAR *, int);
+MEM_ENTRY1 unsigned MEM_ENTRY dbgMemSetCheckFrequency(unsigned);
+MEM_ENTRY1 MEM_BOOL MEM_ENTRY dbgMemDeferFreeing(MEM_BOOL);
+MEM_ENTRY1 MEM_BOOL MEM_ENTRY _dbgMemFreeDeferred(const char MEM_FAR *, int);
+MEM_ENTRY1 MEM_BOOL MEM_ENTRY dbgMemReallocMoves(MEM_BOOL);
+MEM_ENTRY1 MEM_BOOL MEM_ENTRY dbgMemSuppressFreeFill(MEM_BOOL);
+MEM_ENTRY1 MEM_BOOL MEM_ENTRY dbgMemReportWrongTaskRef(MEM_BOOL);
+MEM_ENTRY1 unsigned long MEM_ENTRY dbgMemSetDeferQueueLen(unsigned long);
+MEM_ENTRY1 unsigned long MEM_ENTRY dbgMemSetDeferSizeThreshold(unsigned long);
+MEM_ENTRY1 MEM_BOOL MEM_ENTRY _dbgMemPoolSetName(MEM_POOL,
+   const char MEM_FAR *, const char MEM_FAR *, int);
+MEM_ENTRY1 unsigned long MEM_ENTRY _dbgMemPoolSetDeferQueueLen(MEM_POOL,
+   unsigned long, const char MEM_FAR *, int);
+MEM_ENTRY1 MEM_BOOL MEM_ENTRY _dbgMemCheckAll(const char MEM_FAR *, int);
+MEM_POOL_STATUS MEM_ENTRY _dbgMemWalkHeap(
+   MEM_POOL_ENTRY MEM_FAR *, const char MEM_FAR *, int);
+MEM_ENTRY1 MEM_BOOL MEM_ENTRY _dbg_MemCheckPtr(void MEM_FAR *,
+   MEM_POINTER_TYPE, unsigned long, const char MEM_FAR *, int);
+MEM_ENTRY1 MEM_BOOL MEM_ENTRY dbgMemScheduleChecking(MEM_BOOL, int, unsigned);
+#endif
+
+
+/* Wrapper macros for passing file/line info */
+
+#ifndef _SHI_dbgMacros
+#ifdef MEM_DEBUG
+#ifndef MALLOC_MACRO
+#define MEM_malloc(s_) _dbgMEM_alloc(s_, 0, MEM_MEM_MALLOC, __FILE__, __LINE__)
+#define MEM_calloc(s_, c_) _dbgMEM_alloc((s_)*(c_), 1 /*MEM_ZEROINIT*/, \
+   MEM_MEM_CALLOC, __FILE__, __LINE__)
+#define MEM_realloc(p_, s_) _dbgMEM_realloc(p_, s_, __FILE__, __LINE__)
+#define MEM_free(p_) _dbgMEM_free(p_, __FILE__, __LINE__)
+#endif
+#if !defined(NO_MALLOC_MACRO)
+#ifdef malloc
+#undef malloc
+#endif
+#ifdef calloc
+#undef calloc
+#endif
+#ifdef realloc
+#undef realloc
+#endif
+#ifdef free
+#undef free
+#endif
+#define malloc(s_) MEM_malloc(s_)
+#define calloc(s_, c_) MEM_calloc(s_, c_)
+#define realloc(p_, s_) MEM_realloc(p_, s_)
+#define free(p_) MEM_free(p_)
+#endif /* NO_MALLOC_MACRO */
+
+#define dbgMemPoolSetCheckFrequency(p, b) \
+     _dbgMemPoolSetCheckFrequency(p, b, __FILE__, __LINE__)
+#define dbgMemPoolDeferFreeing(p, b) \
+     _dbgMemPoolDeferFreeing(p, b, __FILE__, __LINE__)
+#define dbgMemPoolFreeDeferred(p) _dbgMemPoolFreeDeferred(p,__FILE__,__LINE__)
+#define dbgMemProtectPtr(p, b)    _dbgMemProtectPtr(p, b, __FILE__, __LINE__)
+#define dbgMemReportLeakage(p, c1, c2) \
+     _dbgMemReportLeakage(p, c1, c2, __FILE__, __LINE__)
+
+#define dbgMemTotalCount() _dbgMemTotalCount(__FILE__, __LINE__)
+#define dbgMemTotalSize() _dbgMemTotalSize(__FILE__, __LINE__)
+#define dbgMemPoolInfo(p, b) _dbg_MemPoolInfo(p, b, __FILE__, __LINE__)
+#define dbgMemPtrInfo(p, b) _dbgMemPtrInfo(p, b, __FILE__, __LINE__)
+#define dbgMemSettingsInfo(b) _dbgMemSettingsInfo(b, __FILE__, __LINE__)
+#define dbgMemPoolSetName(p, n) _dbgMemPoolSetName(p, n, __FILE__, __LINE__)
+#define dbgMemPoolSetDeferQueueLen(p, l) \
+   _dbgMemPoolSetDeferQueueLen(p, l, __FILE__, __LINE__)
+#define dbgMemFreeDeferred() _dbgMemFreeDeferred(__FILE__, __LINE__)
+#define dbgMemWalkHeap(b) _dbgMemWalkHeap(b, __FILE__, __LINE__)
+#define dbgMemCheckAll() _dbgMemCheckAll(__FILE__, __LINE__)
+#define dbgMemCheckPtr(p, t, s) _dbg_MemCheckPtr(p, t, s, __FILE__, __LINE__)
+#define dbgMemBreakpoint() _dbgMemBreakpoint(__FILE__, __LINE__)
+
+#endif /* MEM_DEBUG */
+#endif /* _SHI_dbgMacros */
+
+       
+#ifdef __cplusplus
+}
+
+#ifndef __BORLANDC__
+/* Borland C++ does not treat extern "C++" correctly */
+extern "C++"
+{
+#endif /* __BORLANDC__ */
+
+#if defined(_MSC_VER) && _MSC_VER >= 900
+#pragma warning(disable : 4507)
+#endif
+
+#if defined(new)
+#if defined(MEM_DEBUG)
+#undef new
+#define DEFINE_NEW_MACRO 1
+#endif
+#endif
+
+#ifdef DEBUG_NEW
+#undef DEBUG_NEW
+#endif
+#ifdef DEBUG_DELETE
+#undef DEBUG_DELETE
+#endif
+   
+#ifdef MEM_DEBUG
+#define DBG_FORMAL , const char MEM_FAR *file, int line
+#define DBG_ACTUAL , file, line
+
+
+/* both debug and non-debug versions are both defined so that calls
+ * to shi_New from inline versions of operator new in modules
+ * that were not recompiled with MEM_DEBUG will resolve correctly
+ */
+void MEM_FAR * MEM_ENTRY_ANSI shi_New(unsigned long DBG_FORMAL, unsigned=0,
+   MEM_POOL=0);
+
+/* operator new variants: */
+
+/* compiler-specific versions of new */
+#if UINT_MAX == 0xFFFFu
+#if defined(__BORLANDC__)
+#if (defined(__LARGE__) || defined(__COMPACT__) || defined(__HUGE__))
+inline void far *operator new(unsigned long sz DBG_FORMAL)
+   { return shi_New(sz DBG_ACTUAL); }
+#if __BORLANDC__ >= 0x450
+inline void MEM_FAR *operator new[](unsigned long sz DBG_FORMAL)
+   { return shi_New(sz DBG_ACTUAL); }
+#endif /* __BORLANDC__ >= 0x450 */
+#endif /* __LARGE__ */
+
+#elif defined(_MSC_VER)
+#if (defined(M_I86LM) || defined(M_I86CM) || defined(M_I86HM))
+inline void __huge * operator new(unsigned long count, size_t sz DBG_FORMAL)
+   { return (void __huge *)shi_New(count * sz DBG_ACTUAL, MEM_HUGE); }
+#endif /* M_I86LM */
+#endif /* _MSC_VER */
+
+#endif /* compiler-specific versions of new */
+
+/* version of new that passes memory allocation flags */
+inline void MEM_FAR *operator new(size_t sz DBG_FORMAL, unsigned flags)
+   { return shi_New(sz DBG_ACTUAL, flags); }
+
+/* version of new that allocates from a specified memory pool with alloc flags*/
+inline void MEM_FAR *operator new(size_t sz DBG_FORMAL, MEM_POOL pool)
+   { return shi_New(sz DBG_ACTUAL, 0, pool); }
+inline void MEM_FAR *operator new(size_t sz DBG_FORMAL, MEM_POOL pool, 
+                                  unsigned flags)
+   { return shi_New(sz DBG_ACTUAL, flags, pool); }
+#ifdef SHI_ARRAY_NEW
+inline void MEM_FAR *operator new[](size_t sz DBG_FORMAL, MEM_POOL pool)
+   { return shi_New(sz DBG_ACTUAL, 0, pool); }
+inline void MEM_FAR *operator new[](size_t sz DBG_FORMAL, MEM_POOL pool, 
+                                  unsigned flags)
+   { return shi_New(sz DBG_ACTUAL, flags, pool); }
+#endif /* SHI_ARRAY_NEW */
+
+/* version of new that changes the size of a memory block */
+inline void MEM_FAR *operator new(size_t new_sz DBG_FORMAL,
+                                  void MEM_FAR *lpMem, unsigned flags)
+   { return _dbgMemReAllocPtr1(lpMem, new_sz, flags, MEM_NEW DBG_ACTUAL); }
+#ifdef SHI_ARRAY_NEW
+inline void MEM_FAR *operator new[](size_t new_sz DBG_FORMAL,
+                                    void MEM_FAR *lpMem, unsigned flags)
+   { return _dbgMemReAllocPtr1(lpMem, new_sz, flags, MEM_NEW DBG_ACTUAL); }
+#endif /* SHI_ARRAY_NEW */
+
+/* To have HeapAgent track file/line of C++ allocations,
+ * define new/delete as macros:
+ * #define new DEBUG_NEW
+ * #define delete DEBUG_DELETE
+ *
+ * In cases where you use explicit placement syntax, or in modules that define
+ * operator new/delete, you must undefine the new/delete macros, e.g.:
+ * #undef new
+ *    void *x = new(placementArg) char[30];  // cannot track file/line info
+ * #define new DEBUG_NEW
+ *    void *y = new char[20];                // resume tracking file/line info
+ */
+
+#if (!(defined(_AFX) && defined(_DEBUG)) \
+	  && !(defined(_MSC_VER) && _MSC_VER >= 900))
+/* this must be defined out-of-line for _DEBUG MFC and MEM_DEBUG VC++/Win32 */
+inline void MEM_FAR *operator new(size_t sz DBG_FORMAL)
+   { return shi_New(sz DBG_ACTUAL); }
+#else
+void MEM_FAR * MEM_ENTRY_ANSI operator new(size_t sz DBG_FORMAL);
+#endif /* _AFX && _DEBUG */
+
+#ifdef SHI_ARRAY_NEW
+inline void MEM_FAR *operator new[](size_t sz DBG_FORMAL)
+   { return shi_New(sz DBG_ACTUAL); }
+#endif /* SHI_ARRAY_NEW */
+
+#if !(defined(__IBMCPP__) && defined(__DEBUG_ALLOC__))
+/* debug new/delete built in for IBM Set C++ and Visual Age C++ */
+
+#define DEBUG_NEW new(__FILE__, __LINE__)
+#define DEBUG_NEW1(x_) new(__FILE__, __LINE__, x_)
+#define DEBUG_NEW2(x_, y_) new(__FILE__, __LINE__, x_, y_)
+#define DEBUG_NEW3(x_, y_, z_) new(__FILE__, __LINE__, x_, y_, z_)
+
+#define DEBUG_DELETE _shi_deleteLoc(__FILE__, __LINE__), delete
+
+#ifdef DEFINE_NEW_MACRO
+#ifdef macintosh  /* MPW C++ bug precludes new --> DEBUG_NEW --> new(...) */
+#define new new(__FILE__, __LINE__)
+#define delete _shi_deleteLoc(__FILE__, __LINE__), delete
+#else
+#define new DEBUG_NEW
+#define delete DEBUG_DELETE
+#endif /* macintosh */
+#endif /* DEFINE_NEW_MACRO */
+#endif /* __IBMCPP__ */
+#endif /* MEM_DEBUG */
+
+#include "smrtheap.hpp"
+
+#ifndef __BORLANDC__
+}
+#endif /* __BORLANDC__ */
+
+#endif /* __cplusplus */
+
+#endif /* !defined(_HEAPAGNT_H) */
diff --git a/codemp/smartheap/SHW32.DLL b/codemp/smartheap/SHW32.DLL
new file mode 100644
index 0000000..42b2f67
Binary files /dev/null and b/codemp/smartheap/SHW32.DLL differ
diff --git a/codemp/smartheap/SMRTHEAP.C b/codemp/smartheap/SMRTHEAP.C
new file mode 100644
index 0000000..925f52d
--- /dev/null
+++ b/codemp/smartheap/SMRTHEAP.C
@@ -0,0 +1,54 @@
+extern int SmartHeap_malloc;
+extern int SmartHeap_new;
+
+static void *refSmartHeap_malloc = &SmartHeap_malloc;
+
+#if defined(_DEBUG) && !defined(MEM_DEBUG)
+#define MEM_DEBUG 1
+#endif
+
+#if defined(MFC) && !defined(_AFXDLL)
+
+static void *refSmartHeap_new = &SmartHeap_new;
+
+#ifdef MEM_DEBUG
+#if _MSC_VER < 1000
+#pragma comment(lib, "hamfc32m.lib")
+#else
+#pragma comment(lib, "hamfc4m.lib")
+#endif /* _MSC_VER */
+#else
+#if _MSC_VER >= 1000
+#ifdef _MT
+#pragma comment(lib, "shmfc4mt.lib")
+#else
+#pragma comment(lib, "shmfc4m.lib")
+#endif /* _MT */
+#endif /* _MSC_VER */
+#endif /* MEM_DEBUG */
+
+#endif /* MFC */
+
+#if defined(MEM_DEBUG)
+#pragma comment(lib, "haw32m.lib")
+#elif defined(_DLL)
+#ifdef _MT
+#ifdef MEM_SMP
+#pragma comment(lib, "shdsmpmt.lib")
+#else
+#pragma comment(lib, "shdw32mt.lib")
+#endif /* MEM_SMP */
+#else
+#pragma comment(lib, "shdw32m.lib")
+#endif /* _MT */
+#else /* _DLL */
+#ifdef _MT
+#ifdef MEM_SMP
+#pragma comment(lib, "shlsmpmt.lib")
+#else
+#pragma comment(lib, "shlw32mt.lib")
+#endif /* MEM_SMP */
+#else
+#pragma comment(lib, "shlw32m.lib")
+#endif /* _MT */
+#endif /* MEM_DEBUG */
diff --git a/codemp/smartheap/SMRTHEAP.H b/codemp/smartheap/SMRTHEAP.H
new file mode 100644
index 0000000..90bce42
--- /dev/null
+++ b/codemp/smartheap/SMRTHEAP.H
@@ -0,0 +1,847 @@
+/* smrtheap.h -- SmartHeap (tm) public C header file
+ * Professional Memory Management Library
+ *
+ * Copyright (C) 1991-1999 Compuware Corporation.
+ * All Rights Reserved.
+ *
+ * No part of this source code may be copied, modified or reproduced
+ * in any form without retaining the above copyright notice.
+ * This source code, or source code derived from it, may not be redistributed
+ * without express written permission of the author.
+ *
+ */
+
+#if !defined(_SMARTHEAP_H)
+#define _SMARTHEAP_H
+
+#include <limits.h>
+#include <stddef.h>
+
+#if !defined(macintosh) && !defined(THINK_C) && !defined(__MWERKS__) \
+   && !defined(SHANSI) && UINT_MAX == 0xFFFFu \
+   && (defined(_Windows) || defined(_WINDOWS) || defined(__WINDOWS__))
+   #define MEM_WIN16
+#endif
+
+#if (UINT_MAX == 0xFFFFu) && (defined(MEM_WIN16) \
+	|| defined(MSDOS) || defined(__MSDOS__) || defined(__DOS__))
+   /* 16-bit X86 */
+   #if defined(SYS_DLL)
+      #if defined(_MSC_VER) && _MSC_VER <= 600
+         #define MEM_ENTRY _export _loadds far pascal
+      #else
+         #define MEM_ENTRY _export far pascal
+      #endif
+   #else
+      #define MEM_ENTRY far pascal
+   #endif
+   #ifdef __WATCOMC__
+      #define MEM_ENTRY_ANSI __far
+   #else
+      #define MEM_ENTRY_ANSI far cdecl
+   #endif
+   #define MEM_FAR far
+   #if defined(MEM_WIN16)
+      #define MEM_ENTRY2 _export far pascal
+   #elif defined(DOS16M) || defined(DOSX286)
+      #define MEM_ENTRY2 _export _loadds far pascal
+   #endif
+
+#else  /* not 16-bit X86 */
+
+#if defined(WIN32) || defined(_WIN32) || defined(__WIN32) \
+    || defined(__WIN32__) || defined(__NT__)
+   #define MEM_WIN32
+   #if defined(_MSC_VER)
+      #if defined(_SHI_Pool) && defined(SYS_DLL)
+         #define MEM_ENTRY1 __declspec(dllexport)
+         #define MEM_ENTRY4 __declspec(dllexport) extern
+      #elif !defined(_SHI_Pool) && (defined(MEM_DEBUG) || defined(MEM_DLL))
+         #define MEM_ENTRY1 __declspec(dllimport)
+         #if defined(_M_IX86) || defined(_X86_)
+            #define MemDefaultPool shi_MemDefaultPool
+            #define MEM_ENTRY4 __declspec(dllimport)
+         #endif
+      #endif
+   #endif
+   #if (defined(_MT) || defined(__MT__)) && !defined(MEM_DEBUG)
+/* @@@     #define MEM_MT 1 */
+   #endif
+   #if !defined(_MSC_VER) || defined(_M_IX86) || defined(_X86_)
+      #define MEM_ENTRY __stdcall
+   #else
+      #define MEM_ENTRY __cdecl  /* for NT/RISC */
+   #endif
+   #ifndef __WATCOMC__
+      #define MEM_ENTRY_ANSI __cdecl
+   #endif
+
+#elif defined(__OS2__)
+   #if defined(__BORLANDC__) || defined(__WATCOMC__)
+      #if defined(SYS_DLL)
+         #define MEM_ENTRY __export __syscall
+      #else
+         #define MEM_ENTRY __syscall
+      #endif /* SYS_DLL */
+      #ifdef __BORLANDC__
+         #define MEM_ENTRY_ANSI __stdcall
+      #endif
+   #elif defined(__IBMC__) || defined(__IBMCPP__)
+      #if defined(SYS_DLL) && 0
+         #define MEM_ENTRY _Export _System
+      #else
+         #define MEM_ENTRY _System
+      #endif
+      #define MEM_ENTRY_ANSI _Optlink
+      #define MEM_ENTRY3 MEM_ENTRY
+      #define MEM_CALLBACK MEM_ENTRY3
+      #define MEM_ENTRY2
+   #endif
+
+#elif defined(__sun) || defined(__hpux) || defined(__osf__) || defined(sgi)
+   #if defined(_REENTRANT) && !defined(MEM_DEBUG)
+/* @@@   #define MEM_MT 1 */
+   #endif
+
+#elif defined(_AIX)
+   #if defined(_THREAD_SAFE) && !defined(MEM_DEBUG)
+/*   #define MEM_MT 1 */
+   #endif
+
+#endif /* WIN32, OS2, UNIX */
+
+#if defined(__WATCOMC__) && defined(__SW_3S)
+   /* Watcom stack calling convention */
+#ifndef __OS2__
+#ifdef __WINDOWS_386__
+   #pragma aux syscall "*_" parm routine [eax ebx ecx edx fs gs] modify [eax];
+#else
+   #pragma aux syscall "*_" parm routine [eax ebx ecx edx] modify [eax];
+#endif
+#ifndef MEM_ENTRY
+   #define MEM_ENTRY __syscall
+#endif /* MEM_ENTRY */
+#endif
+#endif /* Watcom stack calling convention */
+
+#endif /* end of system-specific declarations */
+
+#ifndef MEM_ENTRY
+   #define MEM_ENTRY
+#endif
+#ifndef MEM_ENTRY1
+   #define MEM_ENTRY1
+#endif
+#ifndef MEM_ENTRY2
+   #define MEM_ENTRY2 MEM_ENTRY
+#endif
+#ifndef MEM_ENTRY3
+   #define MEM_ENTRY3
+#endif
+#ifndef MEM_ENTRY4
+   #define MEM_ENTRY4 extern
+#endif
+#ifndef MEM_CALLBACK
+#define MEM_CALLBACK MEM_ENTRY2
+#endif
+#ifndef MEM_ENTRY_ANSI
+   #define MEM_ENTRY_ANSI
+#endif
+#ifndef MEM_FAR
+   #define MEM_FAR
+#endif
+
+#ifdef applec
+/* Macintosh: Apple MPW C/C++ passes char/short parms as longs (4 bytes),
+ * whereas Symantec C/C++ for MPW passes these as words (2 bytes);
+ * therefore, canonicalize all integer parms as 'int' for this platform.
+ */
+   #define MEM_USHORT unsigned
+   #define MEM_UCHAR unsigned
+#else
+   #define MEM_USHORT unsigned short
+   #define MEM_UCHAR unsigned char
+#endif /* applec */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+#if !defined(MEM_DEBUG) || !(defined(MEM_WIN16) || defined(MEM_WIN32))
+#define SHI_MAJOR_VERSION 5
+#define SHI_MINOR_VERSION 0
+#define SHI_UPDATE_LEVEL 0
+#endif /* !(MEM_WIN16 || MEM_WIN32) */
+
+	 
+/*** Types ***/
+
+typedef int MEM_BOOL;
+
+/* Version Masks */
+typedef unsigned MEM_VERSION;
+#define MEM_MAJOR_VERSION(v) (((v) & 0xF000u) >> 12)
+#define MEM_MINOR_VERSION(v) (((v) & 0x0F00u) >> 8)
+#define MEM_UPDATE_VERSION(v) ((v) & 0x00FFu)
+
+/* Note: these types are struct's rather than integral types to facilitate
+ * compile-time type-checking.  MEM_POOL and MEM_HANDLE should be regarded
+ * as black boxes, and treated just like handles.
+ * You should not have any type casts to or from MEM_POOL or MEM_HANDLE;
+ * nor should you dereference variables of type MEM_POOL or MEM_HANDLE
+ * (unless you are using SmartHeap to replace NewHandle on the Mac, and
+ * you have existing code that dereferences handles).
+ */
+#ifdef _SHI_Pool
+  typedef struct _SHI_Pool MEM_FAR *MEM_POOL;
+  typedef struct _SHI_MovHandle MEM_FAR *MEM_HANDLE;
+#else
+  #ifdef THINK_C
+    typedef void *MEM_POOL;
+    typedef void **MEM_HANDLE;
+  #else
+    typedef struct _SHI_Pool { int reserved; } MEM_FAR *MEM_POOL;
+    typedef struct _SHI_MovHandle { int reserved; } MEM_FAR *MEM_HANDLE;
+  #endif
+#endif
+    
+
+/* Error codes: errorCode field of MEM_ERROR_INFO */
+typedef enum
+{
+   MEM_NO_ERROR=0,
+   MEM_INTERNAL_ERROR,
+   MEM_OUT_OF_MEMORY,
+   MEM_BLOCK_TOO_BIG,
+   MEM_ALLOC_ZERO,
+   MEM_RESIZE_FAILED,
+   MEM_LOCK_ERROR,
+   MEM_EXCEEDED_CEILING,
+   MEM_TOO_MANY_PAGES,
+   MEM_TOO_MANY_TASKS,
+   MEM_BAD_MEM_POOL,
+   MEM_BAD_BLOCK,
+   MEM_BAD_FREE_BLOCK,
+   MEM_BAD_HANDLE,
+   MEM_BAD_POINTER,
+   MEM_WRONG_TASK,
+   MEM_NOT_FIXED_SIZE,
+   MEM_BAD_FLAGS,
+#ifdef MEM_DEBUG
+   MEM_BAD_BUFFER,
+   MEM_DOUBLE_FREE,
+   MEM_UNDERWRITE,
+   MEM_OVERWRITE, 
+   MEM_FREE_BLOCK_WRITE,
+   MEM_READONLY_MODIFIED,
+   MEM_NOFREE,
+   MEM_NOREALLOC,
+   MEM_LEAKAGE,
+   MEM_FREE_BLOCK_READ,
+   MEM_UNINITIALIZED_READ,
+   MEM_UNINITIALIZED_WRITE,
+   MEM_OUT_OF_BOUNDS_READ,
+	MEM_UNDERWRITE_STACK,
+	MEM_OVERWRITE_STACK,
+	MEM_FREE_STACK_READ,
+	MEM_UNINITIALIZED_READ_STACK,
+	MEM_UNINITIALIZED_WRITE_STACK,
+	MEM_OUT_OF_BOUNDS_READ_STACK,
+   MEM_LASTOK,
+   MEM_BREAKPOINT,
+   MEM_ERROR_CODE_COUNT,
+#endif /* MEM_DEBUG */
+   MEM_ERROR_CODE_INT_MAX = INT_MAX  /* to ensure enum is full int in size */
+} MEM_ERROR_CODE;
+
+/* HeapAgent Entry-Point API identifiers: errorAPI field of MEM_ERROR_INFO */
+typedef enum
+{
+   MEM_NO_API,
+   MEM_MEMVERSION,
+   MEM_MEMREGISTERTASK,
+   MEM_MEMUNREGISTERTASK,
+   MEM_MEMPOOLINIT,
+   MEM_MEMPOOLINITFS,
+   MEM_MEMPOOLFREE,
+   MEM_MEMPOOLSETPAGESIZE,
+   MEM_MEMPOOLSETBLOCKSIZEFS,
+   MEM_MEMPOOLSETFLOOR,
+   MEM_MEMPOOLSETCEILING,
+   MEM_MEMPOOLPREALLOCATE,
+   MEM_MEMPOOLPREALLOCATEHANDLES,
+   MEM_MEMPOOLSHRINK,
+   MEM_MEMPOOLSIZE,
+   MEM_MEMPOOLCOUNT,
+   MEM_MEMPOOLINFO,
+   MEM_MEMPOOLFIRST,
+   MEM_MEMPOOLNEXT,
+   MEM_MEMPOOLWALK,
+   MEM_MEMPOOLCHECK,
+   MEM_MEMALLOC,
+   MEM_MEMREALLOC,
+   MEM_MEMFREE,
+   MEM_MEMLOCK,
+   MEM_MEMUNLOCK,
+   MEM_MEMFIX,
+   MEM_MEMUNFIX,
+   MEM_MEMLOCKCOUNT,
+   MEM_MEMISMOVEABLE,
+   MEM_MEMREFERENCE,
+   MEM_MEMHANDLE,
+   MEM_MEMSIZE,
+   MEM_MEMALLOCPTR,
+   MEM_MEMREALLOCPTR,
+   MEM_MEMFREEPTR,
+   MEM_MEMSIZEPTR,
+   MEM_MEMCHECKPTR,
+   MEM_MEMALLOCFS,
+   MEM_MEMFREEFS,
+   MEM_MEM_MALLOC,
+   MEM_MEM_CALLOC,
+   MEM_MEM_REALLOC,
+   MEM_MEM_FREE,
+   MEM_NEW,
+   MEM_DELETE,
+   MEM_DBGMEMPOOLSETCHECKFREQUENCY,
+   MEM_DBGMEMPOOLDEFERFREEING,
+   MEM_DBGMEMPOOLFREEDEFERRED,
+   MEM_DBGMEMPROTECTPTR,
+   MEM_DBGMEMREPORTLEAKAGE,
+   MEM_MEMPOOLINITNAMEDSHARED,
+   MEM_MEMPOOLINITNAMEDSHAREDEX,
+   MEM_MEMPOOLATTACHSHARED,
+   MEM_DBGMEMPOOLINFO,
+   MEM_DBGMEMPTRINFO,
+   MEM_DBGMEMSETTINGSINFO,
+   MEM_DBGMEMCHECKPTR,
+   MEM_DBGMEMPOOLSETNAME,
+   MEM_DBGMEMPOOLSETDEFERQUEUELEN,
+   MEM_DBGMEMFREEDEFERRED,
+   MEM_DBGMEMCHECKALL,
+   MEM_DBGMEMBREAKPOINT,
+   MEM_MEMPOOLLOCK,
+   MEM_MEMPOOLUNLOCK,
+	MEM_MEMPOOLSETSMALLBLOCKSIZE,
+   MEM_MEMSIZEREQUESTED,
+	MEM_MSIZE,
+	MEM_EXPAND,
+	MEM_GETPROCESSHEAP,
+	MEM_GETPROCESSHEAPS,
+	MEM_GLOBALALLOC,
+	MEM_GLOBALFLAGS,
+	MEM_GLOBALFREE,
+	MEM_GLOBALHANDLE,
+	MEM_GLOBALLOCK,
+	MEM_GLOBALREALLOC,
+	MEM_GLOBALSIZE,
+	MEM_GLOBALUNLOCK,
+	MEM_HEAPALLOC,
+	MEM_HEAPCOMPACT,
+	MEM_HEAPCREATE,
+	MEM_HEAPDESTROY,
+	MEM_HEAPFREE,
+	MEM_HEAPLOCK,
+	MEM_HEAPREALLOC,
+	MEM_HEAPSIZE,
+	MEM_HEAPUNLOCK,
+	MEM_HEAPVALIDATE,
+	MEM_HEAPWALK,
+	MEM_LOCALALLOC,
+	MEM_LOCALFLAGS,
+	MEM_LOCALFREE,
+	MEM_LOCALHANDLE,
+	MEM_LOCALLOCK,
+	MEM_LOCALREALLOC,
+	MEM_LOCALSIZE,
+	MEM_LOCALUNLOCK,
+	MEM_MEMPOOLINITREGION,
+	MEM_TERMINATE,
+   MEM_HEAPAGENT,
+   MEM_USER_API,
+   MEM_API_COUNT,
+   MEM_API_INT_MAX = INT_MAX  /* to ensure enum is full int in size */
+} MEM_API;
+
+#define MEM_MAXCALLSTACK 16  /* maximum number of call stack frames recorded */
+
+/* Error info, passed to error-handling callback routine */
+typedef struct _MEM_ERROR_INFO
+{
+   MEM_ERROR_CODE errorCode; /* error code identifying type of error      */
+   MEM_POOL pool;            /* pool in which error occurred, if known    */
+
+/* all fields below this are valid only for debugging lib                 */
+   /* the following seven fields identify the call where error detected   */
+   MEM_API errorAPI;         /* fn ID of entry-point where error detected */
+   MEM_POOL argPool;         /* memory pool parameter, if applicable      */
+   void MEM_FAR *argPtr;     /* memory pointer parameter, if applicable   */
+   void MEM_FAR *argBuf;     /* result buffer parameter, if applicable    */
+   MEM_HANDLE argHandle;     /* memory handle parameter, if applicable    */
+   unsigned long argSize;    /* size parameter, if applicable             */
+   unsigned long argCount;   /* count parameter, if applicable            */
+   unsigned argFlags;        /* flags parameter, if applicable            */
+
+   /* the following two fields identify the app source file and line      */
+   const char MEM_FAR *file; /* app source file containing above call     */
+   int line;            /* source line in above file                 */
+
+   /* the following two fields identify call instance of error detection  */
+   unsigned long allocCount; /* enumeration of allocation since 1st alloc */
+   unsigned long passCount;  /* enumeration of call at at above file/line */
+   unsigned checkpoint;      /* group with which call has been tagged     */
+   
+   /* the following fields, if non-NULL, points to the address where an
+      overwrite was detected and another MEM_ERROR_INFO structure
+      identifying where the corrupted object was first created, if known  */
+   void MEM_FAR *errorAlloc;  /* ptr to beginning of alloc related to error */
+   void MEM_FAR *corruptAddr;
+   struct _MEM_ERROR_INFO MEM_FAR *objectCreationInfo;
+
+   unsigned long threadID;    /* ID of thread where error detected */
+   unsigned long pid;         /* ID of process where error detected */
+
+	void MEM_FAR *callStack[MEM_MAXCALLSTACK];
+} MEM_ERROR_INFO;
+
+/* Error handling callback function */
+typedef MEM_BOOL (MEM_ENTRY2 * MEM_ENTRY3 MEM_ERROR_FN)
+   (MEM_ERROR_INFO MEM_FAR *);
+
+
+/* Block Type: field of MEM_POOL_ENTRY, field of MEM_POOL_INFO,
+ * parameter to MemPoolPreAllocate
+ */
+typedef enum
+{
+   MEM_FS_BLOCK               = 0x0001u,
+   MEM_VAR_MOVEABLE_BLOCK     = 0x0002u,
+   MEM_VAR_FIXED_BLOCK        = 0x0004u,
+   MEM_EXTERNAL_BLOCK         = 0x0008u,
+   MEM_BLOCK_TYPE_INT_MAX = INT_MAX  /* to ensure enum is full int in size */
+} MEM_BLOCK_TYPE;
+
+typedef enum
+{
+	MEM_SMALL_BLOCK_NONE,
+	MEM_SMALL_BLOCK_SH3,
+	MEM_SMALL_BLOCK_SH5,
+   MEM_SMALL_BLOCK_INT_MAX = INT_MAX  /* to ensure enum is full int in size */
+} MEM_SMALL_BLOCK_ALLOCATOR;
+
+/* Pool Entry: parameter to MemPoolWalk */
+typedef struct
+{
+   void MEM_FAR *entry;
+   MEM_POOL pool;
+   MEM_BLOCK_TYPE type;
+   MEM_BOOL isInUse;
+   unsigned long size;
+   MEM_HANDLE handle;
+   unsigned lockCount;
+   void MEM_FAR *reserved_ptr;
+} MEM_POOL_ENTRY;
+
+/* Pool Status: returned by MemPoolWalk, MemPoolFirst, MemPoolNext */
+typedef enum
+{
+   MEM_POOL_OK            = 1,
+   MEM_POOL_CORRUPT       = -1,
+   MEM_POOL_CORRUPT_FATAL = -2,
+   MEM_POOL_END           = 0,
+   MEM_POOL_STATUS_INT_MAX = INT_MAX  /* to ensure enum is full int in size */
+} MEM_POOL_STATUS;
+
+/* Pointer Status: returned by MemCheckPtr */
+typedef enum
+{
+   MEM_POINTER_OK    = 1,
+   MEM_POINTER_WILD  = 0,
+   MEM_POINTER_FREE  = -1,
+   MEM_POINTER_STATUS_INT_MAX = INT_MAX /* to ensure enum is full int */
+} MEM_POINTER_STATUS;
+
+/* Pool Info: parameter to MemPoolInfo, MemPoolFirst, MemPoolNext */
+typedef struct
+{
+   MEM_POOL pool;
+   MEM_BLOCK_TYPE type; /* disjunctive combination of block type flags */
+	unsigned short blockSizeFS;
+	unsigned short smallBlockSize;
+   unsigned pageSize;
+   unsigned long floor;
+   unsigned long ceiling;
+   unsigned flags;
+   MEM_ERROR_FN errorFn;
+} MEM_POOL_INFO;
+
+/* Flags passed to MemAlloc, MemAllocPtr, MemReAlloc, MemReAllocPtr */
+#define MEM_FIXED           0x0000u /* fixed handle-based block            */
+#define MEM_ZEROINIT        0x0001u /* == TRUE for SH 1.5 compatibility    */
+#define MEM_MOVEABLE        0x0002u /* moveable handle-based block         */
+#define MEM_RESIZEABLE      0x0004u /* reserve space above block           */
+#define MEM_RESIZE_IN_PLACE 0x0008u /* do not move block (realloc)         */
+#define MEM_NOGROW          0x0010u /* do not grow heap to satisfy request */
+#define MEM_NOEXTERNAL      0x0020u /* reserved for internal use           */
+#define MEM_NOCOMPACT       0x0040u /* do not compact to satisfy request   */
+#define MEM_NO_SERIALIZE    0x0080u /* do not serialize this request       */
+#define MEM_HANDLEBASED     0x4000u /* for internal use */
+#define MEM_RESERVED        0x8000u /* for internal use */
+
+#define MEM_UNLOCK_FAILED USHRT_MAX
+
+/* Flags passed to MemPoolInit, MemPoolInitFS */
+#define MEM_POOL_SHARED       0x0001u /* == TRUE for SH 1.5 compatibility  */
+#define MEM_POOL_SERIALIZE    0x0002u /* pool used in more than one thread */
+#define MEM_POOL_VIRTUAL_LOCK 0x0004u /* pool is locked in physical memory */
+#define MEM_POOL_ZEROINIT     0x0008u /* malloc/new from pool zero-inits   */
+#define MEM_POOL_REGION       0x0010u /* store pool in user-supplied region*/
+#define MEM_POOL_DEFAULT      0x8000u /* pool with default characteristics */
+
+/* Default memory pool for C malloc, C++ new (for backwards compatibility) */
+#define MEM_DEFAULT_POOL MemDefaultPool
+
+/* define and initialize these variables at file scope to change defaults */
+extern unsigned short MemDefaultPoolBlockSizeFS;
+extern unsigned MemDefaultPoolPageSize;
+extern unsigned MemDefaultPoolFlags;
+
+/* define SmartHeap_malloc at file scope if you
+ * are intentionally _NOT_ linking in the SmartHeap malloc definition
+ * ditto for SmartHeap operator new, and fmalloc et al.
+ */
+extern int SmartHeap_malloc;
+extern int SmartHeap_far_malloc;
+extern int SmartHeap_new;
+
+#define MEM_ERROR_RET ULONG_MAX
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#ifdef MEM_DEBUG
+#include "heapagnt.h"
+#endif
+
+#endif /* !defined(_SMARTHEAP_H) */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef MEM_MT
+#ifdef MemDefaultPool
+#undef MemDefaultPool
+#endif
+#define MemDefaultPool shi_getThreadPool()
+#ifndef MemInitDefaultPool
+#define MemInitDefaultPool() shi_getThreadPool()
+#define MemFreeDefaultPool() shi_freeThreadPools()
+#endif
+MEM_ENTRY1 MEM_POOL MEM_ENTRY shi_getThreadPool(void);
+MEM_ENTRY1 MEM_BOOL MEM_ENTRY shi_freeThreadPools(void);
+
+#else /* MEM_MT */
+MEM_ENTRY4 MEM_POOL MemDefaultPool;
+MEM_POOL MEM_ENTRY MemInitDefaultPool(void);
+MEM_BOOL MEM_ENTRY MemFreeDefaultPool(void);
+#endif /* MEM_MT */
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+/*** Function Prototypes ***/
+
+#ifndef _SMARTHEAP_PROT
+#define _SMARTHEAP_PROT
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef _shAPI
+   #if defined(MEM_DEBUG) && !defined(SHI_NO_MEM_DEBUG)
+      #define _shAPI(ret, name) MEM_ENTRY1 ret MEM_ENTRY _dbg ## name
+   #else
+      #define _shAPI(ret, name) MEM_ENTRY1 ret MEM_ENTRY name
+   #endif
+#endif
+
+#ifndef _dbgARGS
+   #if defined(MEM_DEBUG) && !defined(SHI_NO_MEM_DEBUG)
+      #define _dbgARGS1 const char MEM_FAR *, int
+      #define _dbgARGS , _dbgARGS1
+   #else
+      #define _dbgARGS1 void
+      #define _dbgARGS
+   #endif
+#endif
+
+   
+/**** HOW TO READ SmartHeap PROTOTYPES ****
+ * prototypes below have the follow syntax in order to support both debug
+ * and non-debug APIs with single-source:
+ *
+ * _shiAPI(<return-type>, <API name>)([<parms>] _dbgARGS);
+ *
+ * the above translates to a C prototype as follows:
+ *
+ * <return-type> <API name>([<parms>]);
+ */
+   
+/* Library Version */
+MEM_ENTRY1 MEM_VERSION MEM_ENTRY MemVersion(void);
+
+/* Library Registration */
+_shAPI(MEM_BOOL, MemRegisterTask)(_dbgARGS1);
+_shAPI(MEM_BOOL, MemUnregisterTask)(_dbgARGS1);
+
+/* Process heap usage */
+MEM_ENTRY1 void MEM_ENTRY MemProcessSetGrowIncrement(unsigned long);
+
+/* Memory Pool Functions */
+_shAPI(MEM_POOL, MemPoolInit)(unsigned _dbgARGS);
+_shAPI(MEM_POOL, MemPoolInitFS)(MEM_USHORT, unsigned long, 
+   unsigned _dbgARGS);
+_shAPI(MEM_POOL, MemPoolInitRegion)(void MEM_FAR *,
+												unsigned long size, unsigned _dbgARGS);
+_shAPI(MEM_POOL, MemPoolInitRegionEx)(void MEM_FAR *addr,
+	unsigned long size, unsigned flags, void MEM_FAR *security _dbgARGS);
+_shAPI(MEM_POOL, MemPoolInitNamedShared)(const char MEM_FAR *,
+                                         unsigned long size,unsigned _dbgARGS);
+_shAPI(MEM_POOL, MemPoolInitNamedSharedEx)(void MEM_FAR *addr,
+   unsigned pidCount, unsigned long MEM_FAR *pids, void MEM_FAR *security,
+   const char MEM_FAR *name, unsigned long size, unsigned flags _dbgARGS);
+_shAPI(MEM_POOL, MemPoolAttachShared)(MEM_POOL, const char MEM_FAR * _dbgARGS);
+_shAPI(MEM_BOOL, MemPoolFree)(MEM_POOL _dbgARGS);
+_shAPI(unsigned, MemPoolSetPageSize)(MEM_POOL, unsigned _dbgARGS);
+_shAPI(MEM_BOOL, MemPoolSetBlockSizeFS)(MEM_POOL, MEM_USHORT _dbgARGS);
+MEM_ENTRY1 unsigned long MEM_ENTRY MemPoolSetGrowIncrement(MEM_POOL,
+	unsigned long);
+MEM_ENTRY1 MEM_BOOL MEM_ENTRY MemPoolSetSmallBlockAllocator(MEM_POOL, MEM_SMALL_BLOCK_ALLOCATOR);
+_shAPI(MEM_BOOL, MemPoolSetSmallBlockSize)(MEM_POOL, MEM_USHORT _dbgARGS);
+_shAPI(unsigned long, MemPoolSetFloor)(MEM_POOL, unsigned long _dbgARGS);
+_shAPI(unsigned long, MemPoolSetCeiling)(MEM_POOL, unsigned long _dbgARGS);
+_shAPI(unsigned long, MemPoolPreAllocate)(MEM_POOL, unsigned long, 
+   MEM_BLOCK_TYPE _dbgARGS);
+_shAPI(unsigned long, MemPoolPreAllocateHandles)(MEM_POOL,
+   unsigned long _dbgARGS);
+_shAPI(unsigned long, MemPoolShrink)(MEM_POOL _dbgARGS);
+_shAPI(unsigned long, MemPoolSize)(MEM_POOL _dbgARGS);
+_shAPI(unsigned long, MemPoolCount)(MEM_POOL _dbgARGS);
+_shAPI(MEM_BOOL, MemPoolInfo)(MEM_POOL, void MEM_FAR *, 
+   MEM_POOL_INFO MEM_FAR* _dbgARGS);
+_shAPI(MEM_POOL_STATUS, MemPoolFirst)(MEM_POOL_INFO MEM_FAR *,
+   MEM_BOOL _dbgARGS);
+_shAPI(MEM_POOL_STATUS,MemPoolNext)(MEM_POOL_INFO MEM_FAR*,MEM_BOOL _dbgARGS);
+_shAPI(MEM_POOL_STATUS,MemPoolWalk)(MEM_POOL,MEM_POOL_ENTRY MEM_FAR*_dbgARGS);
+_shAPI(MEM_BOOL, MemPoolCheck)(MEM_POOL _dbgARGS);
+_shAPI(MEM_BOOL, MemPoolLock)(MEM_POOL _dbgARGS);
+_shAPI(MEM_BOOL, MemPoolUnlock)(MEM_POOL _dbgARGS);
+
+/* Handle-based API for moveable memory within heap. */
+_shAPI(MEM_HANDLE, MemAlloc)(MEM_POOL, unsigned, unsigned long _dbgARGS);
+_shAPI(MEM_HANDLE, MemReAlloc)(MEM_HANDLE,unsigned long,unsigned _dbgARGS);
+_shAPI(MEM_BOOL, MemFree)(MEM_HANDLE _dbgARGS);
+_shAPI(void MEM_FAR *, MemLock)(MEM_HANDLE _dbgARGS);
+_shAPI(unsigned, MemUnlock)(MEM_HANDLE _dbgARGS);
+_shAPI(void MEM_FAR *, MemFix)(MEM_HANDLE _dbgARGS);
+_shAPI(unsigned, MemUnfix)(MEM_HANDLE _dbgARGS);
+_shAPI(unsigned, MemLockCount)(MEM_HANDLE _dbgARGS);
+#ifndef MemFlags
+#define MemFlags(mem) MemLockCount(mem)
+#endif
+_shAPI(MEM_BOOL, MemIsMoveable)(MEM_HANDLE _dbgARGS);
+_shAPI(unsigned long, MemSize)(MEM_HANDLE _dbgARGS);
+_shAPI(unsigned long, MemSizeRequested)(MEM_HANDLE _dbgARGS);
+_shAPI(MEM_HANDLE, MemHandle)(void MEM_FAR * _dbgARGS);
+#ifndef MEM_REFERENCE
+   #ifdef MEM_DEBUG
+      MEM_ENTRY1 void MEM_FAR * MEM_ENTRY _dbgMemReference(MEM_HANDLE, 
+        const char MEM_FAR *, int);
+      #define MEM_REFERENCE(handle) \
+         _dbgMemReference(handle, __FILE__, __LINE__)
+   #else
+      #define MEM_REFERENCE(handle) (*(void MEM_FAR * MEM_FAR *)handle)
+   #endif
+#endif
+
+/* General Heap Allocator (returns direct pointer to memory) */
+_shAPI(void MEM_FAR*,MemAllocPtr)(MEM_POOL,unsigned long,unsigned _dbgARGS);
+_shAPI(void MEM_FAR *, MemReAllocPtr)(void MEM_FAR *, unsigned long,
+   unsigned _dbgARGS);
+_shAPI(MEM_BOOL, MemFreePtr)(void MEM_FAR * _dbgARGS);
+_shAPI(unsigned long, MemSizePtr)(void MEM_FAR * _dbgARGS);
+_shAPI(MEM_POINTER_STATUS, MemCheckPtr)(MEM_POOL, void MEM_FAR * _dbgARGS);
+
+/* Fixed-Size Allocator */
+_shAPI(void MEM_FAR *, MemAllocFS)(MEM_POOL _dbgARGS);
+_shAPI(MEM_BOOL, MemFreeFS)(void MEM_FAR * _dbgARGS);
+
+/* Error Handling Functions */
+MEM_ENTRY1 MEM_ERROR_FN MEM_ENTRY MemSetErrorHandler(MEM_ERROR_FN);
+MEM_ENTRY1 MEM_BOOL MEM_ENTRY MemDefaultErrorHandler(MEM_ERROR_INFO MEM_FAR*);
+MEM_ENTRY1 void MEM_ENTRY MemErrorUnwind(void);
+
+#ifdef MEM_WIN32
+/* patching control */
+
+#ifndef MEM_PATCHING_DEFINED
+#define MEM_PATCHING_DEFINED
+typedef enum
+{
+	MEM_PATCH_ALL = 0,
+	MEM_SKIP_PATCHING_THIS_DLL = 1,
+	MEM_DISABLE_SYSTEM_HEAP_PATCHING = 2,
+	MEM_DISABLE_ALL_PATCHING = 4|2|1,
+   MEM_PATCHING_INT_MAX = INT_MAX /* to ensure enum is full int in size */
+} MEM_PATCHING;
+#endif /* MEM_PATCHING_DEFINED */
+
+#ifdef _MSC_VER
+__declspec(dllexport)
+#endif
+MEM_PATCHING MEM_ENTRY MemSetPatching(const char ***skipDLLs);
+
+#endif /* MEM_WIN32 */
+
+/* Internal routines */
+MEM_ENTRY1 MEM_BOOL MEM_ENTRY _shi_enterCriticalSection(void);
+MEM_ENTRY1 void MEM_ENTRY _shi_leaveCriticalSection(void);
+MEM_BOOL shi_call_new_handler_msc(size_t, MEM_BOOL);
+
+
+/* Wrapper macros for debugging API */
+#ifndef _SHI_dbgMacros
+#ifdef MEM_DEBUG
+#define MemRegisterTask()        _dbgMemRegisterTask(__FILE__, __LINE__)
+#define MemUnregisterTask()      _dbgMemUnregisterTask(__FILE__, __LINE__)
+#define MemPoolInit(flags)       _dbgMemPoolInit(flags, __FILE__, __LINE__)
+#define MemPoolInitFS(bs, bc, f) _dbgMemPoolInitFS(bs,bc,f,__FILE__,__LINE__)
+#define MemPoolInitRegion(addr, sz, f) \
+     _dbgMemPoolInitRegion(addr, sz, f, __FILE__, __LINE__)
+#define MemPoolInitRegionEx(addr, sz, f) \
+     _dbgMemPoolInitRegionEx(addr, sz, f, s, __FILE__, __LINE__)
+#define MemPoolInitNamedShared(nm, sz, f) \
+     _dbgMemPoolInitNamedShared(nm, sz, f, __FILE__, __LINE__)
+#define MemPoolInitNamedSharedEx(a, c, p, sec, nm, sz, f) \
+     _dbgMemPoolInitNamedSharedEx(a, c, p, sec, nm, sz, f, __FILE__, __LINE__)
+#define MemPoolAttachShared(p, n) \
+     _dbgMemPoolAttachShared(p, n, __FILE__, __LINE__)
+#define MemPoolFree(pool)        _dbgMemPoolFree(pool, __FILE__, __LINE__)
+#define MemPoolSetPageSize(p, s) _dbgMemPoolSetPageSize(p,s,__FILE__,__LINE__)
+#define MemPoolSetBlockSizeFS(p, s) \
+     _dbgMemPoolSetBlockSizeFS(p, s, __FILE__, __LINE__)
+#define MemPoolSetSmallBlockSize(p, s) \
+     _dbgMemPoolSetSmallBlockSize(p, s, __FILE__, __LINE__)
+#define MemPoolSetFloor(p, f)    _dbgMemPoolSetFloor(p, f, __FILE__, __LINE__)
+#define MemPoolSetCeiling(p, c)  _dbgMemPoolSetCeiling(p,c,__FILE__, __LINE__)
+#define MemPoolPreAllocate(p,s,t) \
+     _dbgMemPoolPreAllocate(p,s,t,__FILE__, __LINE__)
+#define MemPoolPreAllocateHandles(p,h) \
+     _dbgMemPoolPreAllocateHandles(p,h,__FILE__, __LINE__)
+#define MemPoolShrink(p)         _dbgMemPoolShrink(p, __FILE__, __LINE__)
+#define MemPoolCheck(p)          _dbgMemPoolCheck(p, __FILE__, __LINE__)
+#define MemPoolWalk(p, e)        _dbgMemPoolWalk(p, e, __FILE__, __LINE__)
+#define MemPoolSize(p)           _dbgMemPoolSize(p, __FILE__, __LINE__)
+#define MemPoolCount(p)          _dbgMemPoolCount(p, __FILE__, __LINE__)
+#define MemPoolInfo(p,x,i)       _dbgMemPoolInfo(p,x,i, __FILE__, __LINE__)
+#define MemPoolFirst(i, b)       _dbgMemPoolFirst(i, b, __FILE__, __LINE__)
+#define MemPoolNext(i, b)        _dbgMemPoolNext(i, b, __FILE__, __LINE__)
+#define MemPoolLock(p)           _dbgMemPoolLock(p, __FILE__, __LINE__)
+#define MemPoolUnlock(p)         _dbgMemPoolUnlock(p, __FILE__, __LINE__)
+#define MemAlloc(p, f, s)        _dbgMemAlloc(p, f, s, __FILE__, __LINE__)
+#define MemReAlloc(h, s, f)      _dbgMemReAlloc(h, s, f, __FILE__, __LINE__)
+#define MemFree(h)               _dbgMemFree(h, __FILE__, __LINE__)
+#define MemLock(h)               _dbgMemLock(h, __FILE__, __LINE__)
+#define MemUnlock(h)             _dbgMemUnlock(h, __FILE__, __LINE__)
+#define MemFix(h)                _dbgMemFix(h, __FILE__, __LINE__)
+#define MemUnfix(h)              _dbgMemUnfix(h, __FILE__, __LINE__)
+#define MemSize(h)               _dbgMemSize(h, __FILE__, __LINE__)
+#define MemSizeRequested(h)      _dbgMemSizeRequested(h, __FILE__, __LINE__)
+#define MemLockCount(h)          _dbgMemLockCount(h, __FILE__, __LINE__)
+#define MemIsMoveable(h)         _dbgMemIsMoveable(h, __FILE__, __LINE__)
+#define MemHandle(p)             _dbgMemHandle(p, __FILE__, __LINE__)
+#define MemAllocPtr(p, s, f)     _dbgMemAllocPtr(p, s, f, __FILE__, __LINE__)
+#define MemReAllocPtr(p, s, f)   _dbgMemReAllocPtr(p, s, f, __FILE__,__LINE__)
+#define MemFreePtr(p)            _dbgMemFreePtr(p, __FILE__, __LINE__)
+#define MemSizePtr(p)            _dbgMemSizePtr(p, __FILE__, __LINE__)
+#define MemCheckPtr(p, x)        _dbgMemCheckPtr(p, x, __FILE__, __LINE__)
+#define MemAllocFS(p)            _dbgMemAllocFS(p, __FILE__, __LINE__)
+#define MemFreeFS(p)             _dbgMemFreeFS(p, __FILE__, __LINE__)
+
+#else /* MEM_DEBUG */
+
+/* MEM_DEBUG not defined: define dbgMemXXX as no-op macros
+ * each macro returns "success" value when MEM_DEBUG not defined
+ */
+#ifndef dbgMemBreakpoint
+#define dbgMemBreakpoint() ((void)0)
+#define dbgMemCheckAll() 1
+#define dbgMemCheckPtr(p, f, s) 1
+#define dbgMemDeferFreeing(b) 1
+#define dbgMemFormatCall(i, b, s) 0
+#define dbgMemFormatErrorInfo(i, b, s) 0
+#define dbgMemPoolDeferFreeing(p, b) 1
+#define dbgMemFreeDeferred() 1
+#define dbgMemPoolFreeDeferred(p) 1
+#define dbgMemPoolInfo(p, b) 1
+#define dbgMemPoolSetCheckFrequency(p, f) 1
+#define dbgMemPoolSetDeferQueueLen(p, b) 1
+#define dbgMemPoolSetName(p, n) 1
+#define dbgMemProtectPtr(p, f) 1
+#define dbgMemPtrInfo(p, b) 1
+#define dbgMemReallocMoves(b) 1
+#define dbgMemReportLeakage(p, c1, c2) 1
+#define dbgMemReportWrongTaskRef(b) 1
+#define dbgMemScheduleChecking(b, p, i) 1
+#define dbgMemSetCheckFrequency(f) 1
+#define dbgMemSetCheckpoint(c) 1
+#define dbgMemSetDefaultErrorOutput(x, f) 1
+#define dbgMemSetDeferQueueLen(l) 1
+#define dbgMemSetDeferSizeThreshold(s) 1
+#define dbgMemSetEntryHandler(f) 0
+#define dbgMemSetExitHandler(f) 0
+#define dbgMemSetFreeFill(c) 1
+#define dbgMemSetGuardFill(c) 1
+#define dbgMemSetGuardSize(s) 1
+#define dbgMemSetInUseFill(c) 1
+#define dbgMemSetCallstackChains(s) 1
+#define dbgMemSetStackChecking(s) 1
+#define dbgMemSetSafetyLevel(s) 1
+#define dbgMemSettingsInfo(b) 1
+#define dbgMemSuppressFreeFill(b) 1
+#define dbgMemTotalCount() 1
+#define dbgMemTotalSize() 1
+#define dbgMemWalkHeap(b) MEM_POOL_OK
+#endif /* dbgMemBreakpoint */
+
+#endif /* MEM_DEBUG */
+#endif /* _SHI_dbgMacros */
+
+#if defined(__WATCOMC__) && defined(__SW_3S)
+/* Watcom stack calling convention */
+   #pragma aux MemDefaultPool "_*";
+   #pragma aux MemDefaultPoolBlockSizeFS "_*";
+   #pragma aux MemDefaultPoolPageSize "_*";
+   #pragma aux MemDefaultPoolFlags "_*";
+   #pragma aux SmartHeap_malloc "_*";
+   #pragma aux SmartHeap_far_malloc "_*";
+   #pragma aux SmartHeap_new "_*";
+#ifdef MEM_DEBUG
+   #pragma aux dbgMemGuardSize "_*";
+   #pragma aux dbgMemGuardFill "_*";
+   #pragma aux dbgMemFreeFill "_*";
+   #pragma aux dbgMemInUseFill "_*";
+#endif
+#endif
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* !defined(_SMARTHEAP_PROT) */
diff --git a/codemp/smartheap/smrtheap.hpp b/codemp/smartheap/smrtheap.hpp
new file mode 100644
index 0000000..dfc8435
--- /dev/null
+++ b/codemp/smartheap/smrtheap.hpp
@@ -0,0 +1,197 @@
+// smrtheap.hpp -- SmartHeap public C++ header file
+// Professional Memory Management Library
+//
+// Copyright (C) 1991-1999 Compuware Corporation.
+// All Rights Reserved.
+//
+// No part of this source code may be copied, modified or reproduced
+// in any form without retaining the above copyright notice.
+// This source code, or source code derived from it, may not be redistributed
+// without express written permission of the copyright owner.
+//
+// COMMENTS:
+// - Include this header file to call the SmartHeap-specific versions of
+//   operators new (i.e. with placement syntax), to:
+//     o allocate from a specific memory pool;
+//     o specify allocation flags, such as zero-initialization;
+//     o resize an allocation.
+//
+// - If you include this header file, you must compile and link shnew.cpp, or
+//   link with one of the SmartHeap static operator new libraries:
+//   sh[l|d]XXXX.lib
+//
+// - Can be used in both EXEs and DLLs.
+//
+// - For 16-bit x86 platforms, use only in large or compact memory model.
+//
+// - If you do not want to use SmartHeap's global operator new but you do
+//   want to use SmartHeap's other facilities in a C++ application, then 
+//   include the smrtheap.h header file but do not include this header file,
+//   and do not link with shnew.cpp.  The two ".Xpp" files are present
+//   ONLY for the purpose of defining operator new and operator delete.
+//
+// - Use the MemDefaultPool global variable to refer to a memory pool to pass
+//   to SmartHeap functions that accept a pool as a parameter,
+//   e.g. MemPoolCount, MemPoolSize, MemPoolWalk, etc.
+//
+
+#if !defined(_SMARTHEAP_HPP)
+#define _SMARTHEAP_HPP
+
+#if defined(_MSC_VER) \
+   && (defined(M_I86LM) || defined(M_I86CM) || defined(M_I86HM)) \
+   && !defined(MEM_HUGE)
+#define MEM_HUGE 0x8000u
+#endif
+
+#ifndef __BORLANDC__
+/* Borland C++ does not treat extern "C++" correctly */
+extern "C++"
+{
+#endif /* __BORLANDC__ */
+
+#if defined(_MSC_VER) && _MSC_VER >= 900
+#pragma warning(disable : 4507)
+#endif
+
+#if defined(new)
+#if defined(MEM_DEBUG)
+#undef new
+#endif
+#endif
+
+#include <new.h>
+
+#include "smrtheap.h"
+
+#if defined(new)
+#if defined(MEM_DEBUG)
+#undef new
+#endif
+#endif
+
+#if ((defined(__BORLANDC__) && (__BORLANDC__ >= 0x450)) \
+   || (defined(__WATCOMC__) && __WATCOMC__ >= 1000) \
+   || (defined(__IBMCPP__) && __IBMCPP__ >= 250) \
+	|| defined(__hpux) \
+	|| defined(__osf__) \
+	|| (defined(__SUNPRO_CC) && __SUNPRO_CC >= 0x500) \
+	|| defined(_AIX43))
+#define SHI_ARRAY_NEW 1
+#define SHI_ARRAY_DELETE 1
+#endif
+
+#if !(defined(__SUNPRO_CC) && __SUNPRO_CC >= 0x500)
+#define SHI_NEWDEFARGS 1
+#endif
+
+void MEM_FAR * MEM_ENTRY_ANSI shi_New(unsigned long sz, unsigned flags=0, MEM_POOL pool=0);
+
+// operator new variants:
+
+
+// version of new that passes memory allocation flags
+// (e.g. MEM_ZEROINIT to zero-initialize memory)
+// call with syntax 'ptr = new (flags) <type>'
+inline void MEM_FAR *operator new(size_t sz, unsigned flags)
+   { return shi_New(sz, flags); }
+#if defined(_MSC_VER) && _MSC_VER >= 1200
+inline void MEM_FAR operator delete(void *p, unsigned)
+   { ::operator delete(p); }
+#endif // _MSC_VER
+
+// version of new that allocates from a specified memory pool with alloc flags
+// call with the syntax 'ptr = new (pool, [flags=0]) <type>'
+inline void MEM_FAR *operator new(size_t sz, MEM_POOL pool, unsigned flags
+#ifdef SHI_NEWDEFARGS
+											 =0
+#endif
+											  )
+   { return shi_New(sz, flags, pool); }
+#if defined(_MSC_VER) && _MSC_VER >= 1200
+inline void MEM_FAR operator delete(void *p, MEM_POOL, unsigned)
+   { ::operator delete(p); }
+#endif // _MSC_VER
+
+#ifdef SHI_ARRAY_NEW
+inline void MEM_FAR *operator new[](size_t sz, MEM_POOL pool, unsigned flags
+#ifdef SHI_NEWDEFARGS
+												=0
+#endif
+												 )
+   { return shi_New(sz, flags, pool); }
+#endif
+
+// version of new that changes the size of a memory block previously allocated
+// from an SmartHeap memory pool
+// call with the syntax 'ptr = new (ptr, flags) <type>'
+#if !defined(__BORLANDC__) && !defined(__HIGHC__)
+/* bug in BC++, MetaWare High C++ parsers confuse this with new(file,line) */
+inline void MEM_FAR *operator new(size_t new_sz, void MEM_FAR *lpMem,
+                                  unsigned flags)
+   { return MemReAllocPtr(lpMem, new_sz, flags); }
+#if defined(_MSC_VER) && _MSC_VER >= 1200
+inline void MEM_FAR operator delete(void *p, void MEM_FAR *, unsigned)
+   { ::operator delete(p); }
+#endif // _MSC_VER
+
+#ifdef SHI_ARRAY_NEW
+inline void MEM_FAR *operator new[](size_t new_sz, void MEM_FAR *lpMem,
+                                  unsigned flags)
+   { return MemReAllocPtr(lpMem, new_sz, flags); }
+#endif // SHI_ARRAY_NEW
+#endif
+
+
+// new_handler prototypes: note that MSC/C++ prototype differs from the
+// protosed ANSI standard prototype for set_new_handler
+#if defined(__MWERKS__) \
+	|| defined(__hpux) \
+	|| (defined(__SUNPRO_CC) && __SUNPRO_CC >= 0x500)
+
+#define MEM_CPP_THROW throw()
+#define MEM_CPP_THROW1(x) throw(x)
+//#elif defined(_MSC_VER) && _MSC_VER >= 1100 && defined(_CPPUNWIND)
+//#define MEM_CPP_THROW throw()
+#else
+#define MEM_CPP_THROW
+#define MEM_CPP_THROW1(x)
+#endif // __MWERKS__
+#ifndef _CRTIMP
+#define _CRTIMP
+#endif // _CRTIMP
+#ifdef _MSC_VER
+_CRTIMP _PNH MEM_ENTRY_ANSI _set_new_handler(_PNH);
+#if UINT_MAX == 0xFFFFu
+_PNH MEM_ENTRY_ANSI _set_fnew_handler(_PNH);
+_PNHH MEM_ENTRY_ANSI _set_hnew_handler(_PNHH);
+#endif // UINT_MAX
+#endif // _MSC_VER
+typedef void (MEM_ENTRY_ANSI * pnh)();
+_CRTIMP pnh MEM_ENTRY_ANSI set_new_handler(pnh) MEM_CPP_THROW;
+
+#ifndef DBG_FORMAL
+#define DBG_FORMAL
+#define DBG_ACTUAL
+#ifndef DEBUG_NEW
+#define DEBUG_NEW new
+#endif // DEBUG_NEW
+#define DEBUG_NEW1(x_) new(x_)
+#define DEBUG_NEW2(x_, y_) new(x_, y_)
+#define DEBUG_NEW3(x_, y_, z_) new(x_, y_, z_)
+#define DEBUG_DELETE delete
+#endif
+
+#ifdef DEFINE_NEW_MACRO
+#define new DEBUG_NEW
+#endif
+
+#if defined(_MSC_VER) && _MSC_VER >= 900
+#pragma warning(default : 4507)
+#endif
+
+#ifndef __BORLANDC__
+}
+#endif /* __BORLANDC__ */
+
+#endif /* !defined(_SMARTHEAP_HPP) */
diff --git a/codemp/smartheap/vssver.scc b/codemp/smartheap/vssver.scc
new file mode 100644
index 0000000..2d62d88
Binary files /dev/null and b/codemp/smartheap/vssver.scc differ
diff --git a/codemp/strings/str_server.h b/codemp/strings/str_server.h
new file mode 100644
index 0000000..5301bff
--- /dev/null
+++ b/codemp/strings/str_server.h
@@ -0,0 +1,23 @@
+#ifndef __str_server_h
+#define __str_server_h
+
+
+/********************************************************************************
+
+Server strings
+
+********************************************************************************/
+
+/*
+
+// findmeste
+
+#define PACKAGE_STR_SERVER		0x01
+
+enum
+{
+	STR_SERVER_SERVER_NOT_RUNNING = 0x0100
+};
+*/
+
+#endif // __str_server_h
diff --git a/codemp/strings/vssver.scc b/codemp/strings/vssver.scc
new file mode 100644
index 0000000..725fcc8
Binary files /dev/null and b/codemp/strings/vssver.scc differ
diff --git a/codemp/tonet.bat b/codemp/tonet.bat
new file mode 100644
index 0000000..942935d
--- /dev/null
+++ b/codemp/tonet.bat
@@ -0,0 +1,30 @@
+@echo off
+call vu.bat
+
+xcopy/d/y release\jamp.exe w:\game
+if errorlevel 4 goto lowmemory 
+if errorlevel 2 goto abort 
+
+xcopy/d/y release\jampgamex86.dll w:\game\base\
+if errorlevel 4 goto lowmemory 
+if errorlevel 2 goto abort 
+
+xcopy/d/y release\cgamex86.dll w:\game\base\
+xcopy/d/y release\uix86.dll w:\game\base\
+
+xcopy/d/y release\*.map w:\game
+
+goto exit 
+
+:lowmemory 
+echo *********************************************************************
+echo could not copy file.  Some one might be running off the net!
+echo *********************************************************************
+goto exit 
+
+:abort 
+echo You pressed CTRL+C to end the copy operation. 
+goto exit 
+
+:exit 
+
diff --git a/codemp/tosend.bat b/codemp/tosend.bat
new file mode 100644
index 0000000..bcdf9af
--- /dev/null
+++ b/codemp/tosend.bat
@@ -0,0 +1,5 @@
+xcopy/y release\jamp.exe c:\send\game\jamp_nocd.exe
+xcopy/y final\jamp.exe c:\send\game
+xcopy/y final\*.dll c:\send\game\base
+xcopy/y final\*.map c:\send\game
+xcopy/y release\jampDed.exe c:\send\game
diff --git a/codemp/ui/asm2mak.cfg b/codemp/ui/asm2mak.cfg
new file mode 100644
index 0000000..dc02236
--- /dev/null
+++ b/codemp/ui/asm2mak.cfg
@@ -0,0 +1,34 @@
+;Do not add whitespaces outside the value quotes or change the formatting. The parser is sensitive.
+ui:
+{
+ReleaseFolder="../Release/ui"
+CompileFlags="-DQ3_VM -D_FINAL -S -Wf-target=bytecode -Wf-g -I..\game -I..\cgame -I..\ui"
+SysMaker="ui_public.h ui_syscalls.c vm/ui_syscalls.asm"
+StripPrepend="vm/"
+CompileFolder="vm"
+SkipFile="ui_syscalls"
+OverridePath="bg_lib,../game/bg_lib"
+OverridePath="bg_misc,../game/bg_misc"
+OverridePath="bg_panimate,../game/bg_panimate"
+OverridePath="bg_pmove,../game/bg_pmove"
+OverridePath="bg_saber,../game/bg_saber"
+OverridePath="bg_saberLoad,../game/bg_saberLoad"
+OverridePath="bg_saga,../game/bg_saga"
+OverridePath="bg_vehicleLoad,../game/bg_vehicleLoad"
+OverridePath="bg_weapons,../game/bg_weapons"
+OverridePath="q_math,../game/q_math"
+OverridePath="q_shared,../game/q_shared"
+OverridePath="ui_shared,../ui/ui_shared"
+OverrideDep="bg_lib,../game/bg_lib.c"
+OverrideDep="bg_misc,../Release/JK2game/bg_misc.obj"
+OverrideDep="bg_panimate,../Release/JK2game/bg_panimate.obj"
+OverrideDep="bg_pmove,../Release/JK2game/bg_pmove.obj"
+OverrideDep="bg_saber,../Release/JK2game/bg_saber.obj"
+OverrideDep="bg_saberLoad,../Release/JK2game/bg_saberLoad.obj"
+OverrideDep="bg_saga,../Release/JK2game/bg_saga.obj"
+OverrideDep="bg_vehicleLoad,../Release/JK2game/bg_vehicleLoad.obj"
+OverrideDep="bg_weapons,../Release/JK2game/bg_weapons.obj"
+OverrideDep="q_math,../Release/JK2game/q_math.obj"
+OverrideDep="q_shared,../Release/JK2game/q_shared.obj"
+OverrideDep="ui_shared,../Release/ui/ui_shared.obj"
+}
diff --git a/codemp/ui/keycodes.h b/codemp/ui/keycodes.h
new file mode 100644
index 0000000..e62f49f
--- /dev/null
+++ b/codemp/ui/keycodes.h
@@ -0,0 +1,349 @@
+// Copyright (C) 1999-2000 Id Software, Inc.
+//
+#ifndef __KEYCODES_H__
+#define __KEYCODES_H__
+
+// these are the key numbers that should be passed to KeyEvent
+
+typedef enum
+{
+	A_NULL = 0,
+	A_SHIFT,
+	A_CTRL,
+	A_ALT,
+	A_CAPSLOCK,
+	A_NUMLOCK,
+	A_SCROLLLOCK,
+	A_PAUSE,
+	A_BACKSPACE,
+	A_TAB,
+	A_ENTER,
+	A_KP_PLUS,
+	A_KP_MINUS,
+	A_KP_ENTER,
+	A_KP_PERIOD,
+	A_PRINTSCREEN,
+	A_KP_0,
+	A_KP_1,
+	A_KP_2,
+	A_KP_3,
+	A_KP_4,
+	A_KP_5,
+	A_KP_6,
+	A_KP_7,
+	A_KP_8,
+	A_KP_9,
+	A_CONSOLE,
+	A_ESCAPE,
+	A_F1,
+	A_F2,
+	A_F3,
+	A_F4,
+
+	A_SPACE,
+	A_PLING,
+	A_DOUBLE_QUOTE,
+	A_HASH,
+	A_STRING,
+	A_PERCENT,
+	A_AND,
+	A_SINGLE_QUOTE,
+	A_OPEN_BRACKET,
+	A_CLOSE_BRACKET,
+	A_STAR,
+	A_PLUS,
+	A_COMMA,
+	A_MINUS,
+	A_PERIOD,
+	A_FORWARD_SLASH,
+	A_0,
+	A_1,
+	A_2,
+	A_3,
+	A_4,
+	A_5,
+	A_6,
+	A_7,
+	A_8,
+	A_9,
+	A_COLON,
+	A_SEMICOLON,
+	A_LESSTHAN,
+	A_EQUALS,
+	A_GREATERTHAN,
+	A_QUESTION,
+
+	A_AT,
+	A_CAP_A,
+	A_CAP_B,
+	A_CAP_C,
+	A_CAP_D,
+	A_CAP_E,
+	A_CAP_F,
+	A_CAP_G,
+	A_CAP_H,
+	A_CAP_I,
+	A_CAP_J,
+	A_CAP_K,
+	A_CAP_L,
+	A_CAP_M,
+	A_CAP_N,
+	A_CAP_O,
+	A_CAP_P,
+	A_CAP_Q,
+	A_CAP_R,
+	A_CAP_S,
+	A_CAP_T,
+	A_CAP_U,
+	A_CAP_V,
+	A_CAP_W,
+	A_CAP_X,
+	A_CAP_Y,
+	A_CAP_Z,
+	A_OPEN_SQUARE,
+	A_BACKSLASH,
+	A_CLOSE_SQUARE,
+	A_CARET,
+	A_UNDERSCORE,
+
+	A_LEFT_SINGLE_QUOTE,
+	A_LOW_A,
+	A_LOW_B,
+	A_LOW_C,
+	A_LOW_D,
+	A_LOW_E,
+	A_LOW_F,
+	A_LOW_G,
+	A_LOW_H,
+	A_LOW_I,
+	A_LOW_J,
+	A_LOW_K,
+	A_LOW_L,
+	A_LOW_M,
+	A_LOW_N,
+	A_LOW_O,
+	A_LOW_P,
+	A_LOW_Q,
+	A_LOW_R,
+	A_LOW_S,
+	A_LOW_T,
+	A_LOW_U,
+	A_LOW_V,
+	A_LOW_W,
+	A_LOW_X,
+	A_LOW_Y,
+	A_LOW_Z,
+	A_OPEN_BRACE,
+	A_BAR,
+	A_CLOSE_BRACE,
+	A_TILDE,
+	A_DELETE,
+
+	A_EURO,
+	A_SHIFT2,
+	A_CTRL2,
+	A_ALT2,
+	A_F5,
+	A_F6,
+	A_F7,
+	A_F8,
+	A_CIRCUMFLEX,
+	A_MWHEELUP,
+	A_CAP_SCARON,
+	A_MWHEELDOWN,
+	A_CAP_OE,
+	A_MOUSE1,
+	A_MOUSE2,
+	A_INSERT,
+	A_HOME,
+	A_PAGE_UP,
+	A_RIGHT_SINGLE_QUOTE,
+	A_LEFT_DOUBLE_QUOTE,
+	A_RIGHT_DOUBLE_QUOTE,
+	A_F9,
+	A_F10,
+	A_F11,
+	A_F12,
+	A_TRADEMARK,
+	A_LOW_SCARON,
+	A_SHIFT_ENTER,
+	A_LOW_OE,
+	A_END,
+	A_PAGE_DOWN,
+	A_CAP_YDIERESIS,
+
+	A_SHIFT_SPACE,
+	A_EXCLAMDOWN,
+	A_CENT,
+	A_POUND,
+	A_SHIFT_KP_ENTER,
+	A_YEN,
+	A_MOUSE3,
+	A_MOUSE4,
+	A_MOUSE5,
+	A_COPYRIGHT,
+	A_CURSOR_UP,
+	A_CURSOR_DOWN,
+	A_CURSOR_LEFT,
+	A_CURSOR_RIGHT,
+	A_REGISTERED,
+	A_UNDEFINED_7,
+	A_UNDEFINED_8,
+	A_UNDEFINED_9,
+	A_UNDEFINED_10,
+	A_UNDEFINED_11,
+	A_UNDEFINED_12,
+	A_UNDEFINED_13,
+	A_UNDEFINED_14,
+	A_UNDEFINED_15,
+	A_UNDEFINED_16,
+	A_UNDEFINED_17,
+	A_UNDEFINED_18,
+	A_UNDEFINED_19,
+	A_UNDEFINED_20,
+	A_UNDEFINED_21,
+	A_UNDEFINED_22,
+	A_QUESTION_DOWN,
+
+	A_CAP_AGRAVE,
+	A_CAP_AACUTE,
+	A_CAP_ACIRCUMFLEX,
+	A_CAP_ATILDE,
+	A_CAP_ADIERESIS,
+	A_CAP_ARING,
+	A_CAP_AE,
+	A_CAP_CCEDILLA,
+	A_CAP_EGRAVE,
+	A_CAP_EACUTE,
+	A_CAP_ECIRCUMFLEX,
+	A_CAP_EDIERESIS,
+	A_CAP_IGRAVE,
+	A_CAP_IACUTE,
+	A_CAP_ICIRCUMFLEX,
+	A_CAP_IDIERESIS,
+	A_CAP_ETH,
+	A_CAP_NTILDE,
+	A_CAP_OGRAVE,
+	A_CAP_OACUTE,
+	A_CAP_OCIRCUMFLEX,
+	A_CAP_OTILDE,
+	A_CAP_ODIERESIS,
+	A_MULTIPLY,
+	A_CAP_OSLASH,
+	A_CAP_UGRAVE,
+	A_CAP_UACUTE,
+	A_CAP_UCIRCUMFLEX,
+	A_CAP_UDIERESIS,
+	A_CAP_YACUTE,
+	A_CAP_THORN,
+	A_GERMANDBLS,
+
+	A_LOW_AGRAVE,
+	A_LOW_AACUTE,
+	A_LOW_ACIRCUMFLEX,
+	A_LOW_ATILDE,
+	A_LOW_ADIERESIS,
+	A_LOW_ARING,
+	A_LOW_AE,
+	A_LOW_CCEDILLA,
+	A_LOW_EGRAVE,
+	A_LOW_EACUTE,
+	A_LOW_ECIRCUMFLEX,
+	A_LOW_EDIERESIS,
+	A_LOW_IGRAVE,
+	A_LOW_IACUTE,
+	A_LOW_ICIRCUMFLEX,
+	A_LOW_IDIERESIS,
+	A_LOW_ETH,
+	A_LOW_NTILDE,
+	A_LOW_OGRAVE,
+	A_LOW_OACUTE,
+	A_LOW_OCIRCUMFLEX,
+	A_LOW_OTILDE,
+	A_LOW_ODIERESIS,
+	A_DIVIDE,
+	A_LOW_OSLASH,
+	A_LOW_UGRAVE,
+	A_LOW_UACUTE,
+	A_LOW_UCIRCUMFLEX,
+	A_LOW_UDIERESIS,
+	A_LOW_YACUTE,
+	A_LOW_THORN,
+	A_LOW_YDIERESIS,
+	
+	A_JOY0,
+	A_JOY1,
+	A_JOY2,
+	A_JOY3,
+	A_JOY4,
+	A_JOY5,
+	A_JOY6,
+	A_JOY7,
+	A_JOY8,
+	A_JOY9,
+	A_JOY10,
+	A_JOY11,
+	A_JOY12,
+	A_JOY13,
+	A_JOY14,
+	A_JOY15,
+	A_JOY16,
+	A_JOY17,
+	A_JOY18,
+	A_JOY19,
+	A_JOY20,
+	A_JOY21,
+	A_JOY22,
+	A_JOY23,
+	A_JOY24,
+	A_JOY25,
+	A_JOY26,
+	A_JOY27,
+	A_JOY28,
+	A_JOY29,
+	A_JOY30,
+	A_JOY31,
+
+	A_AUX0,
+	A_AUX1,
+	A_AUX2,
+	A_AUX3,
+	A_AUX4,
+	A_AUX5,
+	A_AUX6,
+	A_AUX7,
+	A_AUX8,
+	A_AUX9,
+	A_AUX10,
+	A_AUX11,
+	A_AUX12,
+	A_AUX13,
+	A_AUX14,
+	A_AUX15,
+	A_AUX16,
+	A_AUX17,
+	A_AUX18,
+	A_AUX19,
+	A_AUX20,
+	A_AUX21,
+	A_AUX22,
+	A_AUX23,
+	A_AUX24,
+	A_AUX25,
+	A_AUX26,
+	A_AUX27,
+	A_AUX28,
+	A_AUX29,
+	A_AUX30,
+	A_AUX31,
+
+	MAX_KEYS
+} fakeAscii_t;
+
+
+// The menu code needs to get both key and char events, but
+// to avoid duplicating the paths, the char events are just
+// distinguished by or'ing in K_CHAR_FLAG (ugly)
+#define	K_CHAR_FLAG		1024
+
+#endif
diff --git a/codemp/ui/mssccprj.scc b/codemp/ui/mssccprj.scc
new file mode 100644
index 0000000..468ec41
--- /dev/null
+++ b/codemp/ui/mssccprj.scc
@@ -0,0 +1,5 @@
+SCC = This is a Source Code Control file
+
+[ui.vcproj]
+SCC_Aux_Path = "\\ravendata1\vss\central_code"
+SCC_Project_Name = "$/jedi/codemp/ui", YSAAAAAA
diff --git a/codemp/ui/ui.bat b/codemp/ui/ui.bat
new file mode 100644
index 0000000..66cf790
--- /dev/null
+++ b/codemp/ui/ui.bat
@@ -0,0 +1,19 @@
+echo off
+
+REM del /q vm
+REM rww - removed this.. point of makefile is not have to rebuild all of it
+
+mkdir vm
+
+del vm\bg_lib.asm
+asm2mak ui makefile
+make ui
+
+cd vm
+
+mkdir "..\..\base\vm"
+copy *.map "..\..\base\vm"
+copy *.qvm "..\..\base\vm"
+
+:quit
+cd ..
diff --git a/codemp/ui/ui.def b/codemp/ui/ui.def
new file mode 100644
index 0000000..01861ba
--- /dev/null
+++ b/codemp/ui/ui.def
@@ -0,0 +1,3 @@
+EXPORTS
+	vmMain
+	dllEntry
diff --git a/codemp/ui/ui.q3asm b/codemp/ui/ui.q3asm
new file mode 100644
index 0000000..a65d2d6
--- /dev/null
+++ b/codemp/ui/ui.q3asm
@@ -0,0 +1,14 @@
+-o "vm/ui"
+vm/ui_main
+vm/ui_syscalls
+vm/ui_atoms
+vm/ui_force
+vm/ui_shared
+vm/ui_gameinfo
+vm/bg_misc
+vm/bg_weapons
+vm/bg_lib
+vm/bg_saga
+vm/bg_vehicleLoad
+vm/q_math
+vm/q_shared
diff --git a/codemp/ui/ui.vcproj b/codemp/ui/ui.vcproj
new file mode 100644
index 0000000..57ce734
--- /dev/null
+++ b/codemp/ui/ui.vcproj
@@ -0,0 +1,433 @@
+<?xml version="1.0" encoding = "Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="7.00"
+	Name="ui"
+	SccProjectName="&quot;$/jedi/codemp/ui&quot;, YSAAAAAA"
+	SccAuxPath=""
+	SccLocalPath="."
+	SccProvider="MSSCCI:Microsoft Visual SourceSafe">
+	<Platforms>
+		<Platform
+			Name="Win32"/>
+	</Platforms>
+	<Configurations>
+		<Configuration
+			Name="Final|Win32"
+			OutputDirectory=".\../Final"
+			IntermediateDirectory=".\../Final/ui"
+			ConfigurationType="2"
+			UseOfMFC="0"
+			ATLMinimizesCRunTimeLibraryUsage="FALSE"
+			CharacterSet="0">
+			<Tool
+				Name="VCCLCompilerTool"
+				GlobalOptimizations="TRUE"
+				InlineFunctionExpansion="2"
+				EnableIntrinsicFunctions="TRUE"
+				ImproveFloatingPointConsistency="TRUE"
+				FavorSizeOrSpeed="1"
+				OptimizeForProcessor="2"
+				OptimizeForWindowsApplication="TRUE"
+				PreprocessorDefinitions="NDEBUG;_USRDL;_WINDOWS;UI_EXPORTS;MISSIONPACK;WIN32;_JK2;FINAL_BUILD"
+				StringPooling="TRUE"
+				RuntimeLibrary="4"
+				BufferSecurityCheck="FALSE"
+				EnableFunctionLevelLinking="TRUE"
+				UsePrecompiledHeader="2"
+				PrecompiledHeaderFile=".\../Final/ui/ui.pch"
+				AssemblerListingLocation=".\../Final/ui/"
+				ObjectFile=".\../Final/ui/"
+				ProgramDataBaseFileName=".\../Final/ui/"
+				WarningLevel="4"
+				SuppressStartupBanner="TRUE"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalOptions="/MACHINE:I386"
+				AdditionalDependencies="odbc32.lib odbccp32.lib"
+				OutputFile="../Final/uix86.dll"
+				LinkIncremental="1"
+				SuppressStartupBanner="TRUE"
+				ModuleDefinitionFile=".\ui.def"
+				GenerateDebugInformation="FALSE"
+				ProgramDatabaseFile=""
+				GenerateMapFile="TRUE"
+				MapFileName=".\../Final/uix86.map"
+				OptimizeReferences="2"
+				EnableCOMDATFolding="2"
+				SetChecksum="TRUE"
+				BaseAddress="0x40000000"
+				ImportLibrary=".\../Final/uix86.lib"/>
+			<Tool
+				Name="VCMIDLTool"
+				PreprocessorDefinitions="NDebug"
+				MkTypLibCompatible="TRUE"
+				SuppressStartupBanner="TRUE"
+				TargetEnvironment="1"
+				TypeLibraryName=".\../Final/ui.tlb"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="VCResourceCompilerTool"
+				PreprocessorDefinitions="NDebug"
+				Culture="1033"/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"/>
+			<Tool
+				Name="VCWebDeploymentTool"/>
+		</Configuration>
+		<Configuration
+			Name="Debug|Win32"
+			OutputDirectory=".\../Debug"
+			IntermediateDirectory=".\../Debug/ui"
+			ConfigurationType="2"
+			UseOfMFC="0"
+			ATLMinimizesCRunTimeLibraryUsage="FALSE"
+			CharacterSet="0">
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				OptimizeForProcessor="2"
+				PreprocessorDefinitions="_DEBUG;_USRDLL;WIN32;_WINDOWS;UI_EXPORTS;MISSIONPACK;_JK2"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="5"
+				UsePrecompiledHeader="2"
+				PrecompiledHeaderFile=".\../Debug/ui/ui.pch"
+				AssemblerListingLocation=".\../Debug/ui/"
+				ObjectFile=".\../Debug/ui/"
+				ProgramDataBaseFileName=".\../Debug/ui/"
+				BrowseInformation="1"
+				WarningLevel="3"
+				SuppressStartupBanner="TRUE"
+				DebugInformationFormat="4"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalOptions="/MACHINE:I386"
+				AdditionalDependencies="odbc32.lib odbccp32.lib"
+				OutputFile="../Debug/uix86.dll"
+				LinkIncremental="2"
+				SuppressStartupBanner="TRUE"
+				ModuleDefinitionFile=".\ui.def"
+				GenerateDebugInformation="TRUE"
+				ProgramDatabaseFile=".\../Debug/uix86.pdb"
+				GenerateMapFile="TRUE"
+				MapFileName=".\../Debug/uix86.map"
+				BaseAddress="0x40000000"
+				ImportLibrary=".\../Debug/uix86.lib"/>
+			<Tool
+				Name="VCMIDLTool"
+				PreprocessorDefinitions="_Debug"
+				MkTypLibCompatible="TRUE"
+				SuppressStartupBanner="TRUE"
+				TargetEnvironment="1"
+				TypeLibraryName=".\../Debug/ui.tlb"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="VCResourceCompilerTool"
+				PreprocessorDefinitions="_Debug"
+				Culture="1033"/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"/>
+			<Tool
+				Name="VCWebDeploymentTool"/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			OutputDirectory=".\../Release"
+			IntermediateDirectory=".\../Release/ui"
+			ConfigurationType="2"
+			UseOfMFC="0"
+			ATLMinimizesCRunTimeLibraryUsage="FALSE"
+			CharacterSet="0">
+			<Tool
+				Name="VCCLCompilerTool"
+				GlobalOptimizations="TRUE"
+				InlineFunctionExpansion="2"
+				EnableIntrinsicFunctions="TRUE"
+				ImproveFloatingPointConsistency="TRUE"
+				FavorSizeOrSpeed="1"
+				OptimizeForProcessor="2"
+				OptimizeForWindowsApplication="TRUE"
+				PreprocessorDefinitions="NDEBUG;_USRDL;WIN32;_WINDOWS;UI_EXPORTS;MISSIONPACK;_JK2"
+				StringPooling="TRUE"
+				MinimalRebuild="TRUE"
+				RuntimeLibrary="4"
+				BufferSecurityCheck="FALSE"
+				EnableFunctionLevelLinking="TRUE"
+				UsePrecompiledHeader="2"
+				PrecompiledHeaderFile=".\../Release/ui/ui.pch"
+				AssemblerListingLocation=".\../Release/ui/"
+				ObjectFile=".\../Release/ui/"
+				ProgramDataBaseFileName=".\../Release/ui/"
+				WarningLevel="4"
+				SuppressStartupBanner="TRUE"
+				DebugInformationFormat="3"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalOptions="/MACHINE:I386"
+				AdditionalDependencies="odbc32.lib odbccp32.lib"
+				OutputFile="../Release/uix86.dll"
+				LinkIncremental="1"
+				SuppressStartupBanner="TRUE"
+				ModuleDefinitionFile=".\ui.def"
+				GenerateDebugInformation="TRUE"
+				ProgramDatabaseFile=".\../Release/uix86.pdb"
+				GenerateMapFile="TRUE"
+				MapFileName=".\../Release/uix86.map"
+				OptimizeReferences="2"
+				EnableCOMDATFolding="2"
+				SetChecksum="TRUE"
+				BaseAddress="0x40000000"
+				ImportLibrary=".\../Release/uix86.lib"/>
+			<Tool
+				Name="VCMIDLTool"
+				PreprocessorDefinitions="NDebug"
+				MkTypLibCompatible="TRUE"
+				SuppressStartupBanner="TRUE"
+				TargetEnvironment="1"
+				TypeLibraryName=".\../Release/ui.tlb"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="VCResourceCompilerTool"
+				PreprocessorDefinitions="NDebug"
+				Culture="1033"/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"/>
+			<Tool
+				Name="VCWebDeploymentTool"/>
+		</Configuration>
+		<Configuration
+			Name="Debug(SH)|Win32"
+			OutputDirectory="Debug(SH)"
+			IntermediateDirectory="Debug(SH)"
+			ConfigurationType="2"
+			UseOfMFC="0"
+			ATLMinimizesCRunTimeLibraryUsage="FALSE"
+			CharacterSet="0">
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				OptimizeForProcessor="2"
+				PreprocessorDefinitions="_DEBUG;_USRDLL;WIN32;_WINDOWS;UI_EXPORTS;MISSIONPACK;_JK2"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="1"
+				UsePrecompiledHeader="2"
+				PrecompiledHeaderFile=".\../Debug/ui/ui.pch"
+				AssemblerListingLocation=".\../Debug/ui/"
+				ObjectFile=".\../Debug/ui/"
+				ProgramDataBaseFileName=".\../Debug/ui/"
+				BrowseInformation="1"
+				WarningLevel="3"
+				SuppressStartupBanner="TRUE"
+				DebugInformationFormat="4"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalOptions="/MACHINE:I386"
+				AdditionalDependencies="odbc32.lib odbccp32.lib"
+				OutputFile="../Debug/uix86.dll"
+				LinkIncremental="2"
+				SuppressStartupBanner="TRUE"
+				ModuleDefinitionFile=".\ui.def"
+				GenerateDebugInformation="TRUE"
+				ProgramDatabaseFile=".\../Debug/uix86.pdb"
+				GenerateMapFile="TRUE"
+				MapFileName=".\../Debug/uix86.map"
+				BaseAddress="0x40000000"
+				ImportLibrary=".\../Debug/uix86.lib"/>
+			<Tool
+				Name="VCMIDLTool"
+				PreprocessorDefinitions="_Debug"
+				MkTypLibCompatible="TRUE"
+				SuppressStartupBanner="TRUE"
+				TargetEnvironment="1"
+				TypeLibraryName=".\../Debug/ui.tlb"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="VCResourceCompilerTool"
+				PreprocessorDefinitions="_Debug"
+				Culture="1033"/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"/>
+			<Tool
+				Name="VCWebDeploymentTool"/>
+		</Configuration>
+	</Configurations>
+	<Files>
+		<Filter
+			Name="Source Files"
+			Filter="cpp;c;cxx;rc;def;r;odl;idl;hpj;bat">
+			<File
+				RelativePath="..\game\bg_lib.c">
+				<FileConfiguration
+					Name="Final|Win32"
+					ExcludedFromBuild="TRUE">
+					<Tool
+						Name="VCCLCompilerTool"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|Win32"
+					ExcludedFromBuild="TRUE">
+					<Tool
+						Name="VCCLCompilerTool"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32"
+					ExcludedFromBuild="TRUE">
+					<Tool
+						Name="VCCLCompilerTool"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug(SH)|Win32"
+					ExcludedFromBuild="TRUE">
+					<Tool
+						Name="VCCLCompilerTool"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\bg_misc.c">
+			</File>
+			<File
+				RelativePath="..\game\bg_saga.c">
+			</File>
+			<File
+				RelativePath="..\game\bg_vehicleLoad.c">
+			</File>
+			<File
+				RelativePath="..\game\bg_weapons.c">
+			</File>
+			<File
+				RelativePath="..\game\q_math.c">
+			</File>
+			<File
+				RelativePath="..\game\q_shared.c">
+			</File>
+			<File
+				RelativePath=".\ui_atoms.c">
+			</File>
+			<File
+				RelativePath=".\ui_force.c">
+			</File>
+			<File
+				RelativePath=".\ui_gameinfo.c">
+			</File>
+			<File
+				RelativePath=".\ui_main.c">
+			</File>
+			<File
+				RelativePath="ui_saber.c">
+			</File>
+			<File
+				RelativePath=".\ui_shared.c">
+			</File>
+			<File
+				RelativePath=".\ui_syscalls.c">
+			</File>
+		</Filter>
+		<Filter
+			Name="Header Files"
+			Filter="h;hpp;hxx;hm;inl">
+			<File
+				RelativePath="..\game\anims.h">
+			</File>
+			<File
+				RelativePath="..\game\bg_local.h">
+			</File>
+			<File
+				RelativePath="..\game\bg_public.h">
+			</File>
+			<File
+				RelativePath="..\game\bg_saga.h">
+			</File>
+			<File
+				RelativePath="..\game\bg_strap.h">
+			</File>
+			<File
+				RelativePath="..\game\bg_weapons.h">
+			</File>
+			<File
+				RelativePath="..\qcommon\disablewarnings.h">
+			</File>
+			<File
+				RelativePath="..\qcommon\game_version.h">
+			</File>
+			<File
+				RelativePath=".\keycodes.h">
+			</File>
+			<File
+				RelativePath="..\..\ui\menudef.h">
+			</File>
+			<File
+				RelativePath="..\game\q_shared.h">
+			</File>
+			<File
+				RelativePath="..\qcommon\qfiles.h">
+			</File>
+			<File
+				RelativePath="..\game\surfaceflags.h">
+			</File>
+			<File
+				RelativePath="..\qcommon\tags.h">
+			</File>
+			<File
+				RelativePath="..\cgame\tr_types.h">
+			</File>
+			<File
+				RelativePath=".\ui.def">
+			</File>
+			<File
+				RelativePath=".\ui_force.h">
+			</File>
+			<File
+				RelativePath=".\ui_local.h">
+			</File>
+			<File
+				RelativePath=".\ui_public.h">
+			</File>
+			<File
+				RelativePath=".\ui_shared.h">
+			</File>
+		</Filter>
+		<Filter
+			Name="win32"
+			Filter="">
+			<File
+				RelativePath="..\win32\ui.rc">
+			</File>
+		</Filter>
+		<File
+			RelativePath=".\ui.bat">
+		</File>
+		<File
+			RelativePath=".\ui.q3asm">
+		</File>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>
diff --git a/codemp/ui/ui.vcproj.vspscc b/codemp/ui/ui.vcproj.vspscc
new file mode 100644
index 0000000..312b2f9
--- /dev/null
+++ b/codemp/ui/ui.vcproj.vspscc
@@ -0,0 +1,10 @@
+""
+{
+"FILE_VERSION" = "9237"
+"ENLISTMENT_CHOICE" = "NEVER"
+"PROJECT_FILE_RELATIVE_PATH" = ""
+"NUMBER_OF_EXCLUDED_FILES" = "0"
+"ORIGINAL_PROJECT_FILE_PATH" = "file:C:\\projects\\Jedi\\codemp\\ui\\ui.vcproj"
+"NUMBER_OF_NESTED_PROJECTS" = "0"
+"SOURCE_CONTROL_SETTINGS_PROVIDER" = "PROJECT"
+}
diff --git a/codemp/ui/ui_atoms.c b/codemp/ui/ui_atoms.c
new file mode 100644
index 0000000..0c023db
--- /dev/null
+++ b/codemp/ui/ui_atoms.c
@@ -0,0 +1,493 @@
+// Copyright (C) 1999-2000 Id Software, Inc.
+//
+/**********************************************************************
+	UI_ATOMS.C
+
+	User interface building blocks and support functions.
+**********************************************************************/
+#include "ui_local.h"
+
+qboolean		m_entersound;		// after a frame, so caching won't disrupt the sound
+
+// these are here so the functions in q_shared.c can link
+#ifndef UI_HARD_LINKED
+
+void QDECL Com_Error( int level, const char *error, ... ) {
+	va_list		argptr;
+	char		text[1024];
+
+	va_start (argptr, error);
+	vsprintf (text, error, argptr);
+	va_end (argptr);
+
+	trap_Error( va("%s", text) );
+}
+
+void QDECL Com_Printf( const char *msg, ... ) {
+	va_list		argptr;
+	char		text[1024];
+
+	va_start (argptr, msg);
+	vsprintf (text, msg, argptr);
+	va_end (argptr);
+
+	trap_Print( va("%s", text) );
+}
+
+#endif
+
+qboolean newUI = qfalse;
+
+
+/*
+=================
+UI_ClampCvar
+=================
+*/
+float UI_ClampCvar( float min, float max, float value )
+{
+	if ( value < min ) return min;
+	if ( value > max ) return max;
+	return value;
+}
+
+/*
+=================
+UI_StartDemoLoop
+=================
+*/
+void UI_StartDemoLoop( void ) {
+	trap_Cmd_ExecuteText( EXEC_APPEND, "d1\n" );
+}
+
+
+char *UI_Argv( int arg ) {
+	static char	buffer[MAX_STRING_CHARS];
+
+	trap_Argv( arg, buffer, sizeof( buffer ) );
+
+	return buffer;
+}
+
+
+char *UI_Cvar_VariableString( const char *var_name ) {
+	static char	buffer[MAX_STRING_CHARS];
+
+	trap_Cvar_VariableStringBuffer( var_name, buffer, sizeof( buffer ) );
+
+	return buffer;
+}
+
+
+
+void UI_SetBestScores(postGameInfo_t *newInfo, qboolean postGame) {
+	trap_Cvar_Set("ui_scoreAccuracy",     va("%i%%", newInfo->accuracy));
+	trap_Cvar_Set("ui_scoreImpressives",	va("%i", newInfo->impressives));
+	trap_Cvar_Set("ui_scoreExcellents", 	va("%i", newInfo->excellents));
+	trap_Cvar_Set("ui_scoreDefends", 			va("%i", newInfo->defends));
+	trap_Cvar_Set("ui_scoreAssists", 			va("%i", newInfo->assists));
+	trap_Cvar_Set("ui_scoreGauntlets", 		va("%i", newInfo->gauntlets));
+	trap_Cvar_Set("ui_scoreScore", 				va("%i", newInfo->score));
+	trap_Cvar_Set("ui_scorePerfect",	 		va("%i", newInfo->perfects));
+	trap_Cvar_Set("ui_scoreTeam",					va("%i to %i", newInfo->redScore, newInfo->blueScore));
+	trap_Cvar_Set("ui_scoreBase",					va("%i", newInfo->baseScore));
+	trap_Cvar_Set("ui_scoreTimeBonus",		va("%i", newInfo->timeBonus));
+	trap_Cvar_Set("ui_scoreSkillBonus",		va("%i", newInfo->skillBonus));
+	trap_Cvar_Set("ui_scoreShutoutBonus",	va("%i", newInfo->shutoutBonus));
+	trap_Cvar_Set("ui_scoreTime",					va("%02i:%02i", newInfo->time / 60, newInfo->time % 60));
+	trap_Cvar_Set("ui_scoreCaptures",		va("%i", newInfo->captures));
+  if (postGame) {
+		trap_Cvar_Set("ui_scoreAccuracy2",     va("%i%%", newInfo->accuracy));
+		trap_Cvar_Set("ui_scoreImpressives2",	va("%i", newInfo->impressives));
+		trap_Cvar_Set("ui_scoreExcellents2", 	va("%i", newInfo->excellents));
+		trap_Cvar_Set("ui_scoreDefends2", 			va("%i", newInfo->defends));
+		trap_Cvar_Set("ui_scoreAssists2", 			va("%i", newInfo->assists));
+		trap_Cvar_Set("ui_scoreGauntlets2", 		va("%i", newInfo->gauntlets));
+		trap_Cvar_Set("ui_scoreScore2", 				va("%i", newInfo->score));
+		trap_Cvar_Set("ui_scorePerfect2",	 		va("%i", newInfo->perfects));
+		trap_Cvar_Set("ui_scoreTeam2",					va("%i to %i", newInfo->redScore, newInfo->blueScore));
+		trap_Cvar_Set("ui_scoreBase2",					va("%i", newInfo->baseScore));
+		trap_Cvar_Set("ui_scoreTimeBonus2",		va("%i", newInfo->timeBonus));
+		trap_Cvar_Set("ui_scoreSkillBonus2",		va("%i", newInfo->skillBonus));
+		trap_Cvar_Set("ui_scoreShutoutBonus2",	va("%i", newInfo->shutoutBonus));
+		trap_Cvar_Set("ui_scoreTime2",					va("%02i:%02i", newInfo->time / 60, newInfo->time % 60));
+		trap_Cvar_Set("ui_scoreCaptures2",		va("%i", newInfo->captures));
+	}
+}
+
+void UI_LoadBestScores(const char *map, int game) {
+	char		fileName[MAX_QPATH];
+	fileHandle_t f;
+	postGameInfo_t newInfo;
+	memset(&newInfo, 0, sizeof(postGameInfo_t));
+	Com_sprintf(fileName, MAX_QPATH, "games/%s_%i.game", map, game);
+	if (trap_FS_FOpenFile(fileName, &f, FS_READ) >= 0) {
+		int size = 0;
+		trap_FS_Read(&size, sizeof(int), f);
+		if (size == sizeof(postGameInfo_t)) {
+			trap_FS_Read(&newInfo, sizeof(postGameInfo_t), f);
+		}
+		trap_FS_FCloseFile(f);
+	}
+	UI_SetBestScores(&newInfo, qfalse);
+
+	Com_sprintf(fileName, MAX_QPATH, "demos/%s_%d.dm_%d", map, game, (int)trap_Cvar_VariableValue("protocol"));
+	uiInfo.demoAvailable = qfalse;
+	if (trap_FS_FOpenFile(fileName, &f, FS_READ) >= 0) {
+		uiInfo.demoAvailable = qtrue;
+		trap_FS_FCloseFile(f);
+	} 
+}
+
+/*
+===============
+UI_ClearScores
+===============
+*/
+void UI_ClearScores() {
+	char	gameList[4096];
+	char *gameFile;
+	int		i, len, count, size;
+	fileHandle_t f;
+	postGameInfo_t newInfo;
+
+	count = trap_FS_GetFileList( "games", "game", gameList, sizeof(gameList) );
+
+	size = sizeof(postGameInfo_t);
+	memset(&newInfo, 0, size);
+
+	if (count > 0) {
+		gameFile = gameList;
+		for ( i = 0; i < count; i++ ) {
+			len = strlen(gameFile);
+			if (trap_FS_FOpenFile(va("games/%s",gameFile), &f, FS_WRITE) >= 0) {
+				trap_FS_Write(&size, sizeof(int), f);
+				trap_FS_Write(&newInfo, size, f);
+				trap_FS_FCloseFile(f);
+			}
+			gameFile += len + 1;
+		}
+	}
+	
+	UI_SetBestScores(&newInfo, qfalse);
+
+}
+
+
+
+static void	UI_Cache_f() {
+	int i;
+	Display_CacheAll();
+	if (trap_Argc() == 2) {
+		for (i = 0; i < uiInfo.q3HeadCount; i++)
+		{
+			trap_Print( va("model %s\n", uiInfo.q3HeadNames[i]) );
+		}
+	}
+}
+
+/*
+=======================
+UI_CalcPostGameStats
+=======================
+*/
+static void UI_CalcPostGameStats() {
+	char		map[MAX_QPATH];
+	char		fileName[MAX_QPATH];
+	char		info[MAX_INFO_STRING];
+	fileHandle_t f;
+	int size, game, time, adjustedTime;
+	postGameInfo_t oldInfo;
+	postGameInfo_t newInfo;
+	qboolean newHigh = qfalse;
+
+	trap_GetConfigString( CS_SERVERINFO, info, sizeof(info) );
+	Q_strncpyz( map, Info_ValueForKey( info, "mapname" ), sizeof(map) );
+	game = atoi(Info_ValueForKey(info, "g_gametype"));
+
+	// compose file name
+	Com_sprintf(fileName, MAX_QPATH, "games/%s_%i.game", map, game);
+	// see if we have one already
+	memset(&oldInfo, 0, sizeof(postGameInfo_t));
+	if (trap_FS_FOpenFile(fileName, &f, FS_READ) >= 0) {
+	// if so load it
+		size = 0;
+		trap_FS_Read(&size, sizeof(int), f);
+		if (size == sizeof(postGameInfo_t)) {
+			trap_FS_Read(&oldInfo, sizeof(postGameInfo_t), f);
+		}
+		trap_FS_FCloseFile(f);
+	}					 
+
+	newInfo.accuracy = atoi(UI_Argv(3));
+	newInfo.impressives = atoi(UI_Argv(4));
+	newInfo.excellents = atoi(UI_Argv(5));
+	newInfo.defends = atoi(UI_Argv(6));
+	newInfo.assists = atoi(UI_Argv(7));
+	newInfo.gauntlets = atoi(UI_Argv(8));
+	newInfo.baseScore = atoi(UI_Argv(9));
+	newInfo.perfects = atoi(UI_Argv(10));
+	newInfo.redScore = atoi(UI_Argv(11));
+	newInfo.blueScore = atoi(UI_Argv(12));
+	time = atoi(UI_Argv(13));
+	newInfo.captures = atoi(UI_Argv(14));
+
+	newInfo.time = (time - trap_Cvar_VariableValue("ui_matchStartTime")) / 1000;
+	adjustedTime = uiInfo.mapList[ui_currentMap.integer].timeToBeat[game];
+	if (newInfo.time < adjustedTime) { 
+		newInfo.timeBonus = (adjustedTime - newInfo.time) * 10;
+	} else {
+		newInfo.timeBonus = 0;
+	}
+
+	if (newInfo.redScore > newInfo.blueScore && newInfo.blueScore <= 0) {
+		newInfo.shutoutBonus = 100;
+	} else {
+		newInfo.shutoutBonus = 0;
+	}
+
+	newInfo.skillBonus = trap_Cvar_VariableValue("g_spSkill");
+	if (newInfo.skillBonus <= 0) {
+		newInfo.skillBonus = 1;
+	}
+	newInfo.score = newInfo.baseScore + newInfo.shutoutBonus + newInfo.timeBonus;
+	newInfo.score *= newInfo.skillBonus;
+
+	// see if the score is higher for this one
+	newHigh = (newInfo.redScore > newInfo.blueScore && newInfo.score > oldInfo.score);
+
+	if  (newHigh) {
+		// if so write out the new one
+		uiInfo.newHighScoreTime = uiInfo.uiDC.realTime + 20000;
+		if (trap_FS_FOpenFile(fileName, &f, FS_WRITE) >= 0) {
+			size = sizeof(postGameInfo_t);
+			trap_FS_Write(&size, sizeof(int), f);
+			trap_FS_Write(&newInfo, sizeof(postGameInfo_t), f);
+			trap_FS_FCloseFile(f);
+		}
+	}
+
+	if (newInfo.time < oldInfo.time) {
+		uiInfo.newBestTime = uiInfo.uiDC.realTime + 20000;
+	}
+ 
+	// put back all the ui overrides
+	trap_Cvar_Set("capturelimit", UI_Cvar_VariableString("ui_saveCaptureLimit"));
+	trap_Cvar_Set("fraglimit", UI_Cvar_VariableString("ui_saveFragLimit"));
+	trap_Cvar_Set("duel_fraglimit", UI_Cvar_VariableString("ui_saveDuelLimit"));
+	trap_Cvar_Set("cg_drawTimer", UI_Cvar_VariableString("ui_drawTimer"));
+	trap_Cvar_Set("g_doWarmup", UI_Cvar_VariableString("ui_doWarmup"));
+	trap_Cvar_Set("g_Warmup", UI_Cvar_VariableString("ui_Warmup"));
+	trap_Cvar_Set("sv_pure", UI_Cvar_VariableString("ui_pure"));
+	trap_Cvar_Set("g_friendlyFire", UI_Cvar_VariableString("ui_friendlyFire"));
+
+	UI_SetBestScores(&newInfo, qtrue);
+	UI_ShowPostGame(newHigh);
+
+
+}
+
+
+/*
+=================
+UI_ConsoleCommand
+=================
+*/
+qboolean UI_ConsoleCommand( int realTime ) {
+	char	*cmd;
+
+	uiInfo.uiDC.frameTime = realTime - uiInfo.uiDC.realTime;
+	uiInfo.uiDC.realTime = realTime;
+
+	cmd = UI_Argv( 0 );
+
+	// ensure minimum menu data is available
+	//Menu_Cache();
+
+	if ( Q_stricmp (cmd, "ui_test") == 0 ) {
+		UI_ShowPostGame(qtrue);
+	}
+
+	if ( Q_stricmp (cmd, "ui_report") == 0 ) {
+		UI_Report();
+		return qtrue;
+	}
+	
+	if ( Q_stricmp (cmd, "ui_load") == 0 ) {
+		UI_Load();
+		return qtrue;
+	}
+
+	if ( Q_stricmp (cmd, "ui_opensiegemenu" ) == 0 ) 
+	{
+		if ( trap_Cvar_VariableValue ( "g_gametype" ) == GT_SIEGE )
+		{
+			Menus_CloseAll();
+			if (Menus_ActivateByName(UI_Argv(1)))
+			{
+				trap_Key_SetCatcher( KEYCATCH_UI );
+			}
+		}
+		return qtrue;
+	}
+
+	if ( Q_stricmp (cmd, "ui_openmenu" ) == 0 ) 
+	{
+		//if ( trap_Cvar_VariableValue ( "developer" ) )
+		{
+			Menus_CloseAll();
+			if (Menus_ActivateByName(UI_Argv(1)))
+			{
+				trap_Key_SetCatcher( KEYCATCH_UI );
+			}
+			return qtrue;
+		}
+	}
+
+	/*
+	if ( Q_stricmp (cmd, "remapShader") == 0 ) {
+		if (trap_Argc() == 4) {
+			char shader1[MAX_QPATH];
+			char shader2[MAX_QPATH];
+			Q_strncpyz(shader1, UI_Argv(1), sizeof(shader1));
+			Q_strncpyz(shader2, UI_Argv(2), sizeof(shader2));
+			trap_R_RemapShader(shader1, shader2, UI_Argv(3));
+			return qtrue;
+		}
+	}
+	*/
+
+	if ( Q_stricmp (cmd, "postgame") == 0 ) {
+		UI_CalcPostGameStats();
+		return qtrue;
+	}
+
+	if ( Q_stricmp (cmd, "ui_cache") == 0 ) {
+		UI_Cache_f();
+		return qtrue;
+	}
+
+	if ( Q_stricmp (cmd, "ui_teamOrders") == 0 ) {
+		//UI_TeamOrdersMenu_f();
+		return qtrue;
+	}
+
+
+	if ( Q_stricmp (cmd, "ui_cdkey") == 0 ) {
+		//UI_CDKeyMenu_f();
+		return qtrue;
+	}
+
+	return qfalse;
+}
+
+/*
+=================
+UI_Shutdown
+=================
+*/
+void UI_Shutdown( void ) {
+}
+
+
+void UI_DrawNamedPic( float x, float y, float width, float height, const char *picname ) {
+	qhandle_t	hShader;
+
+	hShader = trap_R_RegisterShaderNoMip( picname );
+	trap_R_DrawStretchPic( x, y, width, height, 0, 0, 1, 1, hShader );
+}
+
+void UI_DrawHandlePic( float x, float y, float w, float h, qhandle_t hShader ) {
+	float	s0;
+	float	s1;
+	float	t0;
+	float	t1;
+
+	if( w < 0 ) {	// flip about vertical
+		w  = -w;
+		s0 = 1;
+		s1 = 0;
+	}
+	else {
+		s0 = 0;
+		s1 = 1;
+	}
+
+	if( h < 0 ) {	// flip about horizontal
+		h  = -h;
+		t0 = 1;
+		t1 = 0;
+	}
+	else {
+		t0 = 0;
+		t1 = 1;
+	}
+	
+	trap_R_DrawStretchPic( x, y, w, h, s0, t0, s1, t1, hShader );
+}
+
+/*
+================
+UI_FillRect
+
+Coordinates are 640*480 virtual values
+=================
+*/
+void UI_FillRect( float x, float y, float width, float height, const float *color ) {
+	trap_R_SetColor( color );
+
+	trap_R_DrawStretchPic( x, y, width, height, 0, 0, 0, 0, uiInfo.uiDC.whiteShader );
+
+	trap_R_SetColor( NULL );
+}
+
+void UI_DrawSides(float x, float y, float w, float h) {
+	trap_R_DrawStretchPic( x, y, 1, h, 0, 0, 0, 0, uiInfo.uiDC.whiteShader );
+	trap_R_DrawStretchPic( x + w - 1, y, 1, h, 0, 0, 0, 0, uiInfo.uiDC.whiteShader );
+}
+
+void UI_DrawTopBottom(float x, float y, float w, float h) {
+	trap_R_DrawStretchPic( x, y, w, 1, 0, 0, 0, 0, uiInfo.uiDC.whiteShader );
+	trap_R_DrawStretchPic( x, y + h - 1, w, 1, 0, 0, 0, 0, uiInfo.uiDC.whiteShader );
+}
+/*
+================
+UI_DrawRect
+
+Coordinates are 640*480 virtual values
+=================
+*/
+void UI_DrawRect( float x, float y, float width, float height, const float *color ) {
+	trap_R_SetColor( color );
+
+  UI_DrawTopBottom(x, y, width, height);
+  UI_DrawSides(x, y, width, height);
+
+	trap_R_SetColor( NULL );
+}
+
+void UI_SetColor( const float *rgba ) {
+	trap_R_SetColor( rgba );
+}
+
+void UI_UpdateScreen( void ) {
+	trap_UpdateScreen();
+}
+
+
+void UI_DrawTextBox (int x, int y, int width, int lines)
+{
+	UI_FillRect( x + BIGCHAR_WIDTH/2, y + BIGCHAR_HEIGHT/2, ( width + 1 ) * BIGCHAR_WIDTH, ( lines + 1 ) * BIGCHAR_HEIGHT, colorBlack );
+	UI_DrawRect( x + BIGCHAR_WIDTH/2, y + BIGCHAR_HEIGHT/2, ( width + 1 ) * BIGCHAR_WIDTH, ( lines + 1 ) * BIGCHAR_HEIGHT, colorWhite );
+}
+
+qboolean UI_CursorInRect (int x, int y, int width, int height)
+{
+	if (uiInfo.uiDC.cursorx < x ||
+		uiInfo.uiDC.cursory < y ||
+		uiInfo.uiDC.cursorx > x+width ||
+		uiInfo.uiDC.cursory > y+height)
+		return qfalse;
+
+	return qtrue;
+}
diff --git a/codemp/ui/ui_force.c b/codemp/ui/ui_force.c
new file mode 100644
index 0000000..dc5e265
--- /dev/null
+++ b/codemp/ui/ui_force.c
@@ -0,0 +1,1345 @@
+//
+/*
+=======================================================================
+
+FORCE INTERFACE 
+
+=======================================================================
+*/
+
+// use this to get a demo build without an explicit demo build, i.e. to get the demo ui files to build
+#include "ui_local.h"
+#include "../qcommon/qfiles.h"
+#include "ui_force.h"
+
+int uiForceSide = FORCE_LIGHTSIDE;
+int uiJediNonJedi = -1;
+int uiForceRank = FORCE_MASTERY_JEDI_KNIGHT;
+int uiMaxRank = MAX_FORCE_RANK;
+int uiMaxPoints = 20;
+int	uiForceUsed = 0;
+int uiForceAvailable=0;
+
+extern const char *UI_TeamName(int team);
+
+qboolean gTouchedForce = qfalse;
+vmCvar_t	ui_freeSaber, ui_forcePowerDisable;
+
+#include "../namespace_begin.h"
+void Menu_ShowItemByName(menuDef_t *menu, const char *p, qboolean bShow);
+#include "../namespace_end.h"
+
+qboolean uiForcePowersDisabled[NUM_FORCE_POWERS] = {
+	qfalse,//FP_HEAL,//instant
+	qfalse,//FP_LEVITATION,//hold/duration
+	qfalse,//FP_SPEED,//duration
+	qfalse,//FP_PUSH,//hold/duration
+	qfalse,//FP_PULL,//hold/duration
+	qfalse,//FP_TELEPATHY,//instant
+	qfalse,//FP_GRIP,//hold/duration
+	qfalse,//FP_LIGHTNING,//hold/duration
+	qfalse,//FP_RAGE,//duration
+	qfalse,//FP_PROTECT,
+	qfalse,//FP_ABSORB,
+	qfalse,//FP_TEAM_HEAL,
+	qfalse,//FP_TEAM_FORCE,
+	qfalse,//FP_DRAIN,
+	qfalse,//FP_SEE,
+	qfalse,//FP_SABER_OFFENSE,
+	qfalse,//FP_SABER_DEFENSE,
+	qfalse//FP_SABERTHROW,
+};
+
+int uiForcePowersRank[NUM_FORCE_POWERS] = {
+	0,//FP_HEAL = 0,//instant
+	1,//FP_LEVITATION,//hold/duration, this one defaults to 1 (gives a free point)
+	0,//FP_SPEED,//duration
+	0,//FP_PUSH,//hold/duration
+	0,//FP_PULL,//hold/duration
+	0,//FP_TELEPATHY,//instant
+	0,//FP_GRIP,//hold/duration
+	0,//FP_LIGHTNING,//hold/duration
+	0,//FP_RAGE,//duration
+	0,//FP_PROTECT,
+	0,//FP_ABSORB,
+	0,//FP_TEAM_HEAL,
+	0,//FP_TEAM_FORCE,
+	0,//FP_DRAIN,
+	0,//FP_SEE,
+	1,//FP_SABER_OFFENSE, //default to 1 point in attack
+	1,//FP_SABER_DEFENSE, //defualt to 1 point in defense
+	0//FP_SABERTHROW,
+};
+
+int uiForcePowerDarkLight[NUM_FORCE_POWERS] = //0 == neutral
+{ //nothing should be usable at rank 0..
+	FORCE_LIGHTSIDE,//FP_HEAL,//instant
+	0,//FP_LEVITATION,//hold/duration
+	0,//FP_SPEED,//duration
+	0,//FP_PUSH,//hold/duration
+	0,//FP_PULL,//hold/duration
+	FORCE_LIGHTSIDE,//FP_TELEPATHY,//instant
+	FORCE_DARKSIDE,//FP_GRIP,//hold/duration
+	FORCE_DARKSIDE,//FP_LIGHTNING,//hold/duration
+	FORCE_DARKSIDE,//FP_RAGE,//duration
+	FORCE_LIGHTSIDE,//FP_PROTECT,//duration
+	FORCE_LIGHTSIDE,//FP_ABSORB,//duration
+	FORCE_LIGHTSIDE,//FP_TEAM_HEAL,//instant
+	FORCE_DARKSIDE,//FP_TEAM_FORCE,//instant
+	FORCE_DARKSIDE,//FP_DRAIN,//hold/duration
+	0,//FP_SEE,//duration
+	0,//FP_SABER_OFFENSE,
+	0,//FP_SABER_DEFENSE,
+	0//FP_SABERTHROW,
+		//NUM_FORCE_POWERS
+};
+
+int uiForceStarShaders[NUM_FORCE_STAR_IMAGES][2];
+int uiSaberColorShaders[NUM_SABER_COLORS];
+void UI_InitForceShaders(void)
+{
+	uiForceStarShaders[0][0] = trap_R_RegisterShaderNoMip("forcestar0");
+	uiForceStarShaders[0][1] = trap_R_RegisterShaderNoMip("forcestar0");
+	uiForceStarShaders[1][0] = trap_R_RegisterShaderNoMip("forcecircle1");
+	uiForceStarShaders[1][1] = trap_R_RegisterShaderNoMip("forcestar1");
+	uiForceStarShaders[2][0] = trap_R_RegisterShaderNoMip("forcecircle2");
+	uiForceStarShaders[2][1] = trap_R_RegisterShaderNoMip("forcestar2");
+	uiForceStarShaders[3][0] = trap_R_RegisterShaderNoMip("forcecircle3");
+	uiForceStarShaders[3][1] = trap_R_RegisterShaderNoMip("forcestar3");
+	uiForceStarShaders[4][0] = trap_R_RegisterShaderNoMip("forcecircle4");
+	uiForceStarShaders[4][1] = trap_R_RegisterShaderNoMip("forcestar4");
+	uiForceStarShaders[5][0] = trap_R_RegisterShaderNoMip("forcecircle5");
+	uiForceStarShaders[5][1] = trap_R_RegisterShaderNoMip("forcestar5");
+	uiForceStarShaders[6][0] = trap_R_RegisterShaderNoMip("forcecircle6");
+	uiForceStarShaders[6][1] = trap_R_RegisterShaderNoMip("forcestar6");
+	uiForceStarShaders[7][0] = trap_R_RegisterShaderNoMip("forcecircle7");
+	uiForceStarShaders[7][1] = trap_R_RegisterShaderNoMip("forcestar7");
+	uiForceStarShaders[8][0] = trap_R_RegisterShaderNoMip("forcecircle8");
+	uiForceStarShaders[8][1] = trap_R_RegisterShaderNoMip("forcestar8");
+
+	uiSaberColorShaders[SABER_RED]		= trap_R_RegisterShaderNoMip("menu/art/saber_red");
+	uiSaberColorShaders[SABER_ORANGE]	= trap_R_RegisterShaderNoMip("menu/art/saber_orange");
+	uiSaberColorShaders[SABER_YELLOW]	= trap_R_RegisterShaderNoMip("menu/art/saber_yellow");
+	uiSaberColorShaders[SABER_GREEN]	= trap_R_RegisterShaderNoMip("menu/art/saber_green");
+	uiSaberColorShaders[SABER_BLUE]		= trap_R_RegisterShaderNoMip("menu/art/saber_blue");
+	uiSaberColorShaders[SABER_PURPLE]	= trap_R_RegisterShaderNoMip("menu/art/saber_purple");
+}
+
+// Draw the stars spent on the current force power
+void UI_DrawForceStars(rectDef_t *rect, float scale, vec4_t color, int textStyle, int forceindex, int val, int min, int max) 
+{
+	int	i,pad = 4;
+	int	xPos,width = 16;
+	int starcolor;
+
+	if (val < min || val > max) 
+	{
+		val = min;
+	}
+
+	if (1)	// if (val)
+	{
+		xPos = rect->x;
+
+		for (i=FORCE_LEVEL_1;i<=max;i++)
+		{
+			starcolor = bgForcePowerCost[forceindex][i];
+
+			if (uiForcePowersDisabled[forceindex])
+			{
+				vec4_t grColor = {0.2f, 0.2f, 0.2f, 1.0f};
+				trap_R_SetColor(grColor);
+			}
+
+			if (val >= i)
+			{	// Draw a star.
+				UI_DrawHandlePic( xPos, rect->y+6, width, width, uiForceStarShaders[starcolor][1] );
+			}
+			else
+			{	// Draw a circle.
+				UI_DrawHandlePic( xPos, rect->y+6, width, width, uiForceStarShaders[starcolor][0] );
+			}
+
+			if (uiForcePowersDisabled[forceindex])
+			{
+				trap_R_SetColor(NULL);
+			}
+
+			xPos += width + pad;
+		}
+	}
+}
+
+// Set the client's force power layout.
+void UI_UpdateClientForcePowers(const char *teamArg)
+{
+	trap_Cvar_Set( "forcepowers", va("%i-%i-%i%i%i%i%i%i%i%i%i%i%i%i%i%i%i%i%i%i",
+		uiForceRank, uiForceSide, uiForcePowersRank[0], uiForcePowersRank[1],
+		uiForcePowersRank[2], uiForcePowersRank[3], uiForcePowersRank[4],
+		uiForcePowersRank[5], uiForcePowersRank[6], uiForcePowersRank[7],
+		uiForcePowersRank[8], uiForcePowersRank[9], uiForcePowersRank[10],
+		uiForcePowersRank[11], uiForcePowersRank[12], uiForcePowersRank[13],
+		uiForcePowersRank[14], uiForcePowersRank[15], uiForcePowersRank[16],
+		uiForcePowersRank[17]) );
+
+	if (gTouchedForce)
+	{
+		if (teamArg && teamArg[0])
+		{
+			trap_Cmd_ExecuteText( EXEC_APPEND, va("forcechanged \"%s\"\n", teamArg) );
+		}
+		else
+		{
+			trap_Cmd_ExecuteText( EXEC_APPEND, "forcechanged\n" );
+		}
+	}
+
+	gTouchedForce = qfalse;
+}
+
+int UI_TranslateFCFIndex(int index)
+{
+	if (uiForceSide == FORCE_LIGHTSIDE)
+	{
+		return index-uiInfo.forceConfigLightIndexBegin;
+	}
+
+	return index-uiInfo.forceConfigDarkIndexBegin;
+}
+
+void UI_SaveForceTemplate()
+{
+	char *selectedName = UI_Cvar_VariableString("ui_SaveFCF");
+	char fcfString[512];
+	char forceStringValue[4];
+	fileHandle_t f;
+	int strPlace = 0;
+	int forcePlace = 0;
+	int i = 0;
+	qboolean foundFeederItem = qfalse;
+
+	if (!selectedName || !selectedName[0])
+	{
+		Com_Printf("You did not provide a name for the template.\n");
+		return;
+	}
+
+	if (uiForceSide == FORCE_LIGHTSIDE)
+	{ //write it into the light side folder
+		trap_FS_FOpenFile(va("forcecfg/light/%s.fcf", selectedName), &f, FS_WRITE);
+	}
+	else
+	{ //if it isn't light it must be dark
+		trap_FS_FOpenFile(va("forcecfg/dark/%s.fcf", selectedName), &f, FS_WRITE);
+	}
+
+	if (!f)
+	{
+		Com_Printf("There was an error writing the template file (read-only?).\n");
+		return;
+	}
+
+	Com_sprintf(fcfString, sizeof(fcfString), "%i-%i-", uiForceRank, uiForceSide);
+	strPlace = strlen(fcfString);
+
+	while (forcePlace < NUM_FORCE_POWERS)
+	{
+		Com_sprintf(forceStringValue, sizeof(forceStringValue), "%i", uiForcePowersRank[forcePlace]);
+		//Just use the force digit even if multiple digits. Shouldn't be longer than 1.
+		fcfString[strPlace] = forceStringValue[0];
+		strPlace++;
+		forcePlace++;
+	}
+	fcfString[strPlace] = '\n';
+	fcfString[strPlace+1] = 0;
+
+	trap_FS_Write(fcfString, strlen(fcfString), f);
+	trap_FS_FCloseFile(f);
+
+	Com_Printf("Template saved as \"%s\".\n", selectedName);
+
+	//Now, update the FCF list
+	UI_LoadForceConfig_List();
+
+	//Then, scroll through and select the template for the file we just saved
+	while (i < uiInfo.forceConfigCount)
+	{
+		if (!Q_stricmp(uiInfo.forceConfigNames[i], selectedName))
+		{
+			if ((uiForceSide == FORCE_LIGHTSIDE && uiInfo.forceConfigSide[i]) ||
+				(uiForceSide == FORCE_DARKSIDE && !uiInfo.forceConfigSide[i]))
+			{
+				Menu_SetFeederSelection(NULL, FEEDER_FORCECFG, UI_TranslateFCFIndex(i), NULL);
+				foundFeederItem = qtrue;
+			}
+		}
+
+		i++;
+	}
+
+	//Else, go back to 0
+	if (!foundFeederItem)
+	{
+		Menu_SetFeederSelection(NULL, FEEDER_FORCECFG, 0, NULL);
+	}
+}
+
+
+// 
+extern qboolean UI_TrueJediEnabled( void );
+void UpdateForceUsed()
+{
+	int curpower, currank;
+	menuDef_t *menu;
+
+	// Currently we don't make a distinction between those that wish to play Jedi of lower than maximum skill.
+	uiForceRank = uiMaxRank;
+
+	uiForceUsed = 0;
+	uiForceAvailable = forceMasteryPoints[uiForceRank];
+
+	// Make sure that we have one freebie in jump.
+	if (uiForcePowersRank[FP_LEVITATION]<1)
+	{
+		uiForcePowersRank[FP_LEVITATION]=1;
+	}
+
+	if ( UI_TrueJediEnabled() )
+	{//true jedi mode is set
+		if ( uiJediNonJedi == -1 )
+		{
+			int x = 0;
+			qboolean clear = qfalse, update = qfalse;
+			uiJediNonJedi = FORCE_NONJEDI;
+			while ( x < NUM_FORCE_POWERS )
+			{//if any force power is set, we must be a jedi
+				if ( x == FP_LEVITATION || x == FP_SABER_OFFENSE )
+				{
+					if ( uiForcePowersRank[x] > 1 )
+					{
+						uiJediNonJedi = FORCE_JEDI;
+						break;
+					}
+					else if ( uiForcePowersRank[x] > 0 )
+					{
+						clear = qtrue;
+					}
+				}
+				else if ( uiForcePowersRank[x] > 0 )
+				{
+					uiJediNonJedi = FORCE_JEDI;
+					break;
+				}
+				x++;
+			}
+			if ( uiJediNonJedi == FORCE_JEDI )
+			{
+				if ( uiForcePowersRank[FP_SABER_OFFENSE] < 1 )
+				{
+					uiForcePowersRank[FP_SABER_OFFENSE]=1;
+					update = qtrue;
+				}
+			}
+			else if ( clear )
+			{
+				x = 0;
+				while ( x < NUM_FORCE_POWERS )
+				{//clear all force
+					uiForcePowersRank[x] = 0;
+					x++;
+				}
+				update = qtrue;
+			}
+			if ( update )
+			{
+				int myTeam;
+				myTeam = (int)(trap_Cvar_VariableValue("ui_myteam"));
+				if ( myTeam != TEAM_SPECTATOR )
+				{
+					UI_UpdateClientForcePowers(UI_TeamName(myTeam));//will cause him to respawn, if it's been 5 seconds since last one
+				}
+				else
+				{
+					UI_UpdateClientForcePowers(NULL);//just update powers
+				}
+			}
+		}
+	}
+
+	menu = Menus_FindByName("ingame_playerforce");
+	// Set the cost of the saberattack according to whether its free.
+	if (ui_freeSaber.integer)
+	{	// Make saber free
+		bgForcePowerCost[FP_SABER_OFFENSE][FORCE_LEVEL_1] = 0;
+		bgForcePowerCost[FP_SABER_DEFENSE][FORCE_LEVEL_1] = 0;
+		// Make sure that we have one freebie in saber if applicable.
+		if (uiForcePowersRank[FP_SABER_OFFENSE]<1)
+		{
+			uiForcePowersRank[FP_SABER_OFFENSE]=1;
+		}
+		if (uiForcePowersRank[FP_SABER_DEFENSE]<1)
+		{
+			uiForcePowersRank[FP_SABER_DEFENSE]=1;
+		}
+		if (menu)
+		{
+			Menu_ShowItemByName(menu, "setFP_SABER_DEFENSE", qtrue);
+			Menu_ShowItemByName(menu, "setfp_saberthrow", qtrue);
+			Menu_ShowItemByName(menu, "effectentry", qtrue);
+			Menu_ShowItemByName(menu, "effectfield", qtrue);
+			Menu_ShowItemByName(menu, "nosaber", qfalse);
+		}
+	}
+	else
+	{	// Make saber normal cost
+		bgForcePowerCost[FP_SABER_OFFENSE][FORCE_LEVEL_1] = 1;
+		bgForcePowerCost[FP_SABER_DEFENSE][FORCE_LEVEL_1] = 1;
+		// Also, check if there is no saberattack.  If there isn't, there had better not be any defense or throw!
+		if (uiForcePowersRank[FP_SABER_OFFENSE]<1)
+		{
+			uiForcePowersRank[FP_SABER_DEFENSE]=0;
+			uiForcePowersRank[FP_SABERTHROW]=0;
+			if (menu)
+			{
+				Menu_ShowItemByName(menu, "setfp_saberdefend", qfalse);
+				Menu_ShowItemByName(menu, "setfp_saberthrow", qfalse);
+				Menu_ShowItemByName(menu, "effectentry", qfalse);
+				Menu_ShowItemByName(menu, "effectfield", qfalse);
+				Menu_ShowItemByName(menu, "nosaber", qtrue);
+			}
+		}
+		else
+		{
+			if (menu)
+			{
+				Menu_ShowItemByName(menu, "setfp_saberdefend", qtrue);
+				Menu_ShowItemByName(menu, "setfp_saberthrow", qtrue);
+				Menu_ShowItemByName(menu, "effectentry", qtrue);
+				Menu_ShowItemByName(menu, "effectfield", qtrue);
+				Menu_ShowItemByName(menu, "nosaber", qfalse);
+			}
+		}
+	}
+
+	// Make sure that we're still legal.
+	for (curpower=0;curpower<NUM_FORCE_POWERS;curpower++)
+	{	// Make sure that our ranks are within legal limits.
+		if (uiForcePowersRank[curpower]<0)
+			uiForcePowersRank[curpower]=0;
+		else if (uiForcePowersRank[curpower]>=NUM_FORCE_POWER_LEVELS)
+			uiForcePowersRank[curpower]=(NUM_FORCE_POWER_LEVELS-1);
+
+		for (currank=FORCE_LEVEL_1;currank<=uiForcePowersRank[curpower];currank++)
+		{	// Check on this force power
+			if (uiForcePowersRank[curpower]>0)
+			{	// Do not charge the player for the one freebie in jump, or if there is one in saber.
+				if  (	(curpower == FP_LEVITATION && currank == FORCE_LEVEL_1) ||
+						(curpower == FP_SABER_OFFENSE && currank == FORCE_LEVEL_1 && ui_freeSaber.integer) ||
+						(curpower == FP_SABER_DEFENSE && currank == FORCE_LEVEL_1 && ui_freeSaber.integer) )
+				{
+					// Do nothing (written this way for clarity)
+				}
+				else
+				{	// Check if we can accrue the cost of this power.
+					if (bgForcePowerCost[curpower][currank] > uiForceAvailable)
+					{	// We can't afford this power.  Break to the next one.
+						// Remove this power from the player's roster.
+						uiForcePowersRank[curpower] = currank-1;
+						break;
+					}
+					else
+					{	// Sure we can afford it.
+						uiForceUsed += bgForcePowerCost[curpower][currank];
+						uiForceAvailable -= bgForcePowerCost[curpower][currank];
+					}
+				}
+			}
+		}
+	}
+
+}
+
+
+//Mostly parts of other functions merged into one another.
+//Puts the current UI stuff into a string, legalizes it, and then reads it back out.
+void UI_ReadLegalForce(void)
+{
+	char fcfString[512];
+	char forceStringValue[4];
+	int strPlace = 0;
+	int forcePlace = 0;
+	int i = 0;
+	char singleBuf[64];
+	char info[MAX_INFO_VALUE];
+	int c = 0;
+	int iBuf = 0;
+	int forcePowerRank = 0;
+	int currank = 0;
+	int forceTeam = 0;
+	qboolean updateForceLater = qfalse;
+
+	//First, stick them into a string.
+	Com_sprintf(fcfString, sizeof(fcfString), "%i-%i-", uiForceRank, uiForceSide);
+	strPlace = strlen(fcfString);
+
+	while (forcePlace < NUM_FORCE_POWERS)
+	{
+		Com_sprintf(forceStringValue, sizeof(forceStringValue), "%i", uiForcePowersRank[forcePlace]);
+		//Just use the force digit even if multiple digits. Shouldn't be longer than 1.
+		fcfString[strPlace] = forceStringValue[0];
+		strPlace++;
+		forcePlace++;
+	}
+	fcfString[strPlace] = '\n';
+	fcfString[strPlace+1] = 0;
+
+	info[0] = '\0';
+	trap_GetConfigString(CS_SERVERINFO, info, sizeof(info));
+
+	if (atoi( Info_ValueForKey( info, "g_forceBasedTeams" ) ))
+	{
+		switch((int)(trap_Cvar_VariableValue("ui_myteam")))
+		{
+		case TEAM_RED:
+			forceTeam = FORCE_DARKSIDE;
+			break;
+		case TEAM_BLUE:
+			forceTeam = FORCE_LIGHTSIDE;
+			break;
+		default:
+			break;
+		}
+	}
+	//Second, legalize them.
+	if (!BG_LegalizedForcePowers(fcfString, uiMaxRank, ui_freeSaber.integer, forceTeam, atoi( Info_ValueForKey( info, "g_gametype" )), 0))
+	{ //if they were illegal, we should refresh them.
+		updateForceLater = qtrue;
+	}
+
+	//Lastly, put them back into the UI storage from the legalized string
+	i = 0;
+
+	while (fcfString[i] && fcfString[i] != '-')
+	{
+		singleBuf[c] = fcfString[i];
+		c++;
+		i++;
+	}
+	singleBuf[c] = 0;
+	c = 0;
+	i++;
+
+	iBuf = atoi(singleBuf);
+
+	if (iBuf > uiMaxRank || iBuf < 0)
+	{ //this force config uses a rank level higher than our currently restricted level.. so we can't use it
+	  //FIXME: Print a message indicating this to the user
+	//	return;
+	}
+
+	uiForceRank = iBuf;
+
+	while (fcfString[i] && fcfString[i] != '-')
+	{
+		singleBuf[c] = fcfString[i];
+		c++;
+		i++;
+	}
+	singleBuf[c] = 0;
+	c = 0;
+	i++;
+
+	uiForceSide = atoi(singleBuf);
+
+	if (uiForceSide != FORCE_LIGHTSIDE &&
+		uiForceSide != FORCE_DARKSIDE)
+	{
+		uiForceSide = FORCE_LIGHTSIDE;
+		return;
+	}
+
+	//clear out the existing powers
+	while (c < NUM_FORCE_POWERS)
+	{
+		uiForcePowersRank[c] = 0;
+		c++;
+	}
+	uiForceUsed = 0;
+	uiForceAvailable = forceMasteryPoints[uiForceRank];
+	gTouchedForce = qtrue;
+
+	for (c=0;fcfString[i]&&c<NUM_FORCE_POWERS;c++,i++)
+	{
+		singleBuf[0] = fcfString[i];
+		singleBuf[1] = 0;
+		iBuf = atoi(singleBuf);	// So, that means that Force Power "c" wants to be set to rank "iBuf".
+		
+		if (iBuf < 0)
+		{
+			iBuf = 0;
+		}
+
+		forcePowerRank = iBuf;
+
+		if (forcePowerRank > FORCE_LEVEL_3 || forcePowerRank < 0)
+		{ //err..  not correct
+			continue;  // skip this power
+		}
+
+		if (uiForcePowerDarkLight[c] && uiForcePowerDarkLight[c] != uiForceSide)
+		{ //Apparently the user has crafted a force config that has powers that don't fit with the config's side.
+			continue;  // skip this power
+		}
+
+		// Accrue cost for each assigned rank for this power.
+		for (currank=FORCE_LEVEL_1;currank<=forcePowerRank;currank++)
+		{	
+			if (bgForcePowerCost[c][currank] > uiForceAvailable)
+			{	// Break out, we can't afford any more power.
+				break;
+			}
+			// Pay for this rank of this power.
+			uiForceUsed += bgForcePowerCost[c][currank];
+			uiForceAvailable -= bgForcePowerCost[c][currank];
+
+			uiForcePowersRank[c]++;
+		}
+	}
+
+	if (uiForcePowersRank[FP_LEVITATION] < 1)
+	{
+		uiForcePowersRank[FP_LEVITATION]=1;
+	}
+	if (uiForcePowersRank[FP_SABER_OFFENSE] < 1 && ui_freeSaber.integer)
+	{
+		uiForcePowersRank[FP_SABER_OFFENSE]=1;
+	}
+	if (uiForcePowersRank[FP_SABER_DEFENSE] < 1 && ui_freeSaber.integer)
+	{
+		uiForcePowersRank[FP_SABER_DEFENSE]=1;
+	}
+
+	UpdateForceUsed();
+
+	if (updateForceLater)
+	{
+		gTouchedForce = qtrue;
+		UI_UpdateClientForcePowers(NULL);
+	}
+}
+
+void UI_UpdateForcePowers()
+{
+	char *forcePowers = UI_Cvar_VariableString("forcepowers");
+	char readBuf[256];
+	int i = 0, i_f = 0, i_r = 0;
+
+	uiForceSide = 0;
+
+	if (forcePowers && forcePowers[0])
+	{
+		while (forcePowers[i])
+		{
+			i_r = 0;
+
+			while (forcePowers[i] && forcePowers[i] != '-' && i_r < 255)
+			{
+				readBuf[i_r] = forcePowers[i];
+				i_r++;
+				i++;
+			}
+			readBuf[i_r] = '\0';
+			if (i_r >= 255 || !forcePowers[i] || forcePowers[i] != '-')
+			{
+				uiForceSide = 0;
+				goto validitycheck;
+			}
+			uiForceRank = atoi(readBuf);
+			i_r = 0;
+
+			if (uiForceRank > uiMaxRank)
+			{
+				uiForceRank = uiMaxRank;
+			}
+
+			i++;
+
+			while (forcePowers[i] && forcePowers[i] != '-' && i_r < 255)
+			{
+				readBuf[i_r] = forcePowers[i];
+				i_r++;
+				i++;
+			}
+			readBuf[i_r] = '\0';
+			if (i_r >= 255 || !forcePowers[i] || forcePowers[i] != '-')
+			{
+				uiForceSide = 0;
+				goto validitycheck;
+			}
+			uiForceSide = atoi(readBuf);
+			i_r = 0;
+
+			i++;
+
+			i_f = FP_HEAL;
+
+			while (forcePowers[i] && i_f < NUM_FORCE_POWERS)
+			{
+				readBuf[0] = forcePowers[i];
+				readBuf[1] = '\0';
+				uiForcePowersRank[i_f] = atoi(readBuf);
+
+				if (i_f == FP_LEVITATION &&
+					uiForcePowersRank[i_f] < 1)
+				{
+					uiForcePowersRank[i_f] = 1;
+				}
+
+				if (i_f == FP_SABER_OFFENSE &&
+					uiForcePowersRank[i_f] < 1 &&
+					ui_freeSaber.integer)
+				{
+					uiForcePowersRank[i_f] = 1;
+				}
+
+				if (i_f == FP_SABER_DEFENSE &&
+					uiForcePowersRank[i_f] < 1 &&
+					ui_freeSaber.integer)
+				{
+					uiForcePowersRank[i_f] = 1;
+				}
+
+				i_f++;
+				i++;
+			}
+
+			if (i_f < NUM_FORCE_POWERS)
+			{ //info for all the powers wasn't there..
+				uiForceSide = 0;
+				goto validitycheck;
+			}
+			i++;
+		}
+	}
+
+validitycheck:
+
+	if (!uiForceSide)
+	{
+		uiForceSide = 1;
+		uiForceRank = 1;
+		i = 0;
+		while (i < NUM_FORCE_POWERS)
+		{
+			if (i == FP_LEVITATION)
+			{
+				uiForcePowersRank[i] = 1;
+			}
+			else if (i == FP_SABER_OFFENSE && ui_freeSaber.integer)
+			{
+				uiForcePowersRank[i] = 1;
+			}
+			else if (i == FP_SABER_DEFENSE && ui_freeSaber.integer)
+			{
+				uiForcePowersRank[i] = 1;
+			}
+			else
+			{
+				uiForcePowersRank[i] = 0;
+			}
+
+			i++;
+		}
+
+		UI_UpdateClientForcePowers(NULL);
+	}
+
+	UpdateForceUsed();
+}
+extern int	uiSkinColor;
+extern int	uiHoldSkinColor;
+
+qboolean UI_SkinColor_HandleKey(int flags, float *special, int key, int num, int min, int max, int type) 
+{
+  if (key == A_MOUSE1 || key == A_MOUSE2 || key == A_ENTER || key == A_KP_ENTER) 
+  {
+  	int i = num;
+
+	if (key == A_MOUSE2)
+	{
+	    i--;
+	}
+	else
+	{
+	    i++;
+	}
+
+    if (i < min)
+	{
+		i = max;
+	}
+	else if (i > max)
+	{
+      i = min;
+    }
+
+    num = i;
+
+	uiSkinColor = num;
+
+	uiHoldSkinColor = uiSkinColor;
+
+	UI_FeederSelection(FEEDER_Q3HEADS, uiInfo.q3SelectedHead, NULL);
+
+    return qtrue;
+  }
+  return qfalse;
+}
+
+
+
+
+qboolean UI_ForceSide_HandleKey(int flags, float *special, int key, int num, int min, int max, int type) 
+{
+	char info[MAX_INFO_VALUE];
+
+	info[0] = '\0';
+	trap_GetConfigString(CS_SERVERINFO, info, sizeof(info));
+
+	if (atoi( Info_ValueForKey( info, "g_forceBasedTeams" ) ))
+	{
+		switch((int)(trap_Cvar_VariableValue("ui_myteam")))
+		{
+		case TEAM_RED:
+			return qfalse;
+		case TEAM_BLUE:
+			return qfalse;
+		default:
+			break;
+		}
+	}
+
+	if (key == A_MOUSE1 || key == A_MOUSE2 || key == A_ENTER || key == A_KP_ENTER) 
+	{
+		int i = num;
+		int x = 0;
+
+		//update the feeder item selection, it might be different depending on side
+		Menu_SetFeederSelection(NULL, FEEDER_FORCECFG, 0, NULL);
+
+		if (key == A_MOUSE2)
+		{
+			i--;
+		}
+		else
+		{
+			i++;
+		}
+
+		if (i < min)
+		{
+			i = max;
+		}
+		else if (i > max)
+		{
+			i = min;
+		}
+
+		num = i;
+
+		uiForceSide = num;
+
+		// Resetting power ranks based on if light or dark side is chosen
+		while (x < NUM_FORCE_POWERS)
+		{
+			if (uiForcePowerDarkLight[x] && uiForceSide != uiForcePowerDarkLight[x])
+			{
+				uiForcePowersRank[x] = 0;
+			}
+			x++;
+		}
+
+		UpdateForceUsed();
+
+		gTouchedForce = qtrue;
+		return qtrue;
+	}
+	return qfalse;
+}
+
+qboolean UI_JediNonJedi_HandleKey(int flags, float *special, int key, int num, int min, int max, int type) 
+{
+	char info[MAX_INFO_VALUE];
+
+	info[0] = '\0';
+	trap_GetConfigString(CS_SERVERINFO, info, sizeof(info));
+
+	if ( !UI_TrueJediEnabled() )
+	{//true jedi mode is not set
+		return qfalse;
+	}
+
+	if (key == A_MOUSE1 || key == A_MOUSE2 || key == A_ENTER || key == A_KP_ENTER) 
+	{
+		int i = num;
+		int x = 0;
+
+		if (key == A_MOUSE2)
+		{
+			i--;
+		}
+		else
+		{
+			i++;
+		}
+
+		if (i < min)
+		{
+			i = max;
+		}
+		else if (i > max)
+		{
+			i = min;
+		}
+
+		num = i;
+
+		uiJediNonJedi = num;
+
+		// Resetting power ranks based on if light or dark side is chosen
+		if ( !num )
+		{//not a jedi?
+			int myTeam = (int)(trap_Cvar_VariableValue("ui_myteam"));
+			while ( x < NUM_FORCE_POWERS )
+			{//clear all force powers
+				uiForcePowersRank[x] = 0;
+				x++;
+			}
+			if ( myTeam != TEAM_SPECTATOR )
+			{
+				UI_UpdateClientForcePowers(UI_TeamName(myTeam));//will cause him to respawn, if it's been 5 seconds since last one
+			}
+			else
+			{
+				UI_UpdateClientForcePowers(NULL);//just update powers
+			}
+		}
+		else if ( num )
+		{//a jedi, set the minimums, hopefuly they know to set the rest!
+			if ( uiForcePowersRank[FP_LEVITATION] < FORCE_LEVEL_1 )
+			{//force jump 1 minimum
+				uiForcePowersRank[FP_LEVITATION] = FORCE_LEVEL_1;
+			}
+			if ( uiForcePowersRank[FP_SABER_OFFENSE] < FORCE_LEVEL_1 )
+			{//saber attack 1, minimum
+				uiForcePowersRank[FP_SABER_OFFENSE] = FORCE_LEVEL_1;
+			}
+		}
+
+		UpdateForceUsed();
+
+		gTouchedForce = qtrue;
+		return qtrue;
+	}
+	return qfalse;
+}
+
+qboolean UI_ForceMaxRank_HandleKey(int flags, float *special, int key, int num, int min, int max, int type) 
+{
+  if (key == A_MOUSE1 || key == A_MOUSE2 || key == A_ENTER || key == A_KP_ENTER) 
+  {
+  	int i = num;
+
+	if (key == A_MOUSE2)
+	{
+	    i--;
+	}
+	else
+	{
+	    i++;
+	}
+
+    if (i < min)
+	{
+		i = max;
+	}
+	else if (i > max)
+	{
+      i = min;
+    }
+
+    num = i;
+
+	uiMaxRank = num;
+
+	trap_Cvar_Set( "g_maxForceRank", va("%i", num));
+
+	// The update force used will remove overallocated powers automatically.
+	UpdateForceUsed();
+
+	gTouchedForce = qtrue;
+
+    return qtrue;
+  }
+  return qfalse;
+}
+
+
+// This function will either raise or lower a power by one rank.
+qboolean UI_ForcePowerRank_HandleKey(int flags, float *special, int key, int num, int min, int max, int type) 
+{
+	qboolean raising;
+
+	if (key == A_MOUSE1 || key == A_MOUSE2 || key == A_ENTER || key == A_KP_ENTER || key == A_BACKSPACE) 
+	{
+		int forcepower, rank;
+
+		//this will give us the index as long as UI_FORCE_RANK is always one below the first force rank index
+		forcepower = (type-UI_FORCE_RANK)-1;
+		
+		//the power is disabled on the server
+		if (uiForcePowersDisabled[forcepower])
+		{
+			return qtrue;
+		}
+
+		// If we are not on the same side as a power, or if we are not of any rank at all.
+		if (uiForcePowerDarkLight[forcepower] && uiForceSide != uiForcePowerDarkLight[forcepower])
+		{
+			return qtrue;
+		}
+		else if (forcepower == FP_SABER_DEFENSE || forcepower == FP_SABERTHROW)
+		{	// Saberdefend and saberthrow can't be bought if there is no saberattack
+			if (uiForcePowersRank[FP_SABER_OFFENSE] < 1)
+			{
+				return qtrue;
+			}
+		}
+
+		if (type == UI_FORCE_RANK_LEVITATION)
+		{
+			min += 1;
+		}
+		if (type == UI_FORCE_RANK_SABERATTACK && ui_freeSaber.integer)
+		{
+			min += 1;
+		}
+		if (type == UI_FORCE_RANK_SABERDEFEND && ui_freeSaber.integer)
+		{
+			min += 1;
+		}
+
+		if (key == A_MOUSE2 || key == A_BACKSPACE)
+		{	// Lower a point.
+			if (uiForcePowersRank[forcepower]<=min)
+			{
+				return qtrue;
+			}
+			raising = qfalse;
+		}
+		else
+		{	// Raise a point.
+			if (uiForcePowersRank[forcepower]>=max)
+			{
+				return qtrue;
+			}
+			raising = qtrue;
+		}
+
+		if (raising)
+		{	// Check if we can accrue the cost of this power.
+			rank = uiForcePowersRank[forcepower]+1;
+			if (bgForcePowerCost[forcepower][rank] > uiForceAvailable)
+			{	// We can't afford this power.  Abandon ship.
+				return qtrue;
+			}
+			else
+			{	// Sure we can afford it.
+				uiForceUsed += bgForcePowerCost[forcepower][rank];
+				uiForceAvailable -= bgForcePowerCost[forcepower][rank];
+				uiForcePowersRank[forcepower]=rank;
+			}
+		}
+		else
+		{	// Lower the point.
+			rank = uiForcePowersRank[forcepower];
+			uiForceUsed -= bgForcePowerCost[forcepower][rank];
+			uiForceAvailable += bgForcePowerCost[forcepower][rank];
+			uiForcePowersRank[forcepower]--;
+		}
+
+		UpdateForceUsed();
+
+		gTouchedForce = qtrue;
+
+		return qtrue;
+	}
+	return qfalse;
+}
+
+
+int gCustRank = 0;
+int gCustSide = 0;
+
+int gCustPowersRank[NUM_FORCE_POWERS] = {
+	0,//FP_HEAL = 0,//instant
+	1,//FP_LEVITATION,//hold/duration, this one defaults to 1 (gives a free point)
+	0,//FP_SPEED,//duration
+	0,//FP_PUSH,//hold/duration
+	0,//FP_PULL,//hold/duration
+	0,//FP_TELEPATHY,//instant
+	0,//FP_GRIP,//hold/duration
+	0,//FP_LIGHTNING,//hold/duration
+	0,//FP_RAGE,//duration
+	0,//FP_PROTECT,
+	0,//FP_ABSORB,
+	0,//FP_TEAM_HEAL,
+	0,//FP_TEAM_FORCE,
+	0,//FP_DRAIN,
+	0,//FP_SEE,
+	0,//FP_SABER_OFFENSE,
+	0,//FP_SABER_DEFENSE,
+	0//FP_SABERTHROW,
+};
+
+/*
+=================
+UI_ForceConfigHandle
+=================
+*/
+void UI_ForceConfigHandle( int oldindex, int newindex )
+{
+	fileHandle_t f;
+	int len = 0;
+	int i = 0;
+	int c = 0;
+	int iBuf = 0, forcePowerRank, currank;
+	char fcfBuffer[8192];
+	char singleBuf[64];
+	char info[MAX_INFO_VALUE];
+	int forceTeam = 0;
+
+	if (oldindex == 0)
+	{ //switching out from custom config, so first shove the current values into the custom storage
+		i = 0;
+
+		while (i < NUM_FORCE_POWERS)
+		{
+			gCustPowersRank[i] = uiForcePowersRank[i];
+			i++;
+		}
+		gCustRank = uiForceRank;
+		gCustSide = uiForceSide;
+	}
+
+	if (newindex == 0)
+	{ //switching back to custom, shove the values back in from the custom storage
+		i = 0;
+		uiForceUsed = 0;
+		gTouchedForce = qtrue;
+
+		while (i < NUM_FORCE_POWERS)
+		{
+			uiForcePowersRank[i] = gCustPowersRank[i];
+			uiForceUsed += uiForcePowersRank[i];
+			i++;
+		}
+		uiForceRank = gCustRank;
+		uiForceSide = gCustSide;
+
+		UpdateForceUsed();
+		return;
+	}
+
+	//If we made it here, we want to load in a new config
+	if (uiForceSide == FORCE_LIGHTSIDE)
+	{ //we should only be displaying lightside configs, so.. look in the light folder
+		newindex += uiInfo.forceConfigLightIndexBegin;
+		if (newindex >= uiInfo.forceConfigCount)
+		{
+			return;
+		}
+		len = trap_FS_FOpenFile(va("forcecfg/light/%s.fcf", uiInfo.forceConfigNames[newindex]), &f, FS_READ);
+	}
+	else
+	{ //else dark
+		newindex += uiInfo.forceConfigDarkIndexBegin;
+		if (newindex >= uiInfo.forceConfigCount || newindex > uiInfo.forceConfigLightIndexBegin)
+		{ //dark gets read in before light
+			return;
+		}
+		len = trap_FS_FOpenFile(va("forcecfg/dark/%s.fcf", uiInfo.forceConfigNames[newindex]), &f, FS_READ);
+	}
+
+	if (len <= 0)
+	{ //This should not have happened. But, before we quit out, attempt searching the other light/dark folder for the file.
+		if (uiForceSide == FORCE_LIGHTSIDE)
+		{
+			len = trap_FS_FOpenFile(va("forcecfg/dark/%s.fcf", uiInfo.forceConfigNames[newindex]), &f, FS_READ);
+		}
+		else
+		{
+			len = trap_FS_FOpenFile(va("forcecfg/light/%s.fcf", uiInfo.forceConfigNames[newindex]), &f, FS_READ);
+		}
+
+		if (len <= 0)
+		{ //still failure? Oh well.
+			return;
+		}
+	}
+
+	if (len >= 8192)
+	{
+		return;
+	}
+
+	trap_FS_Read(fcfBuffer, len, f);
+	fcfBuffer[len] = 0;
+	trap_FS_FCloseFile(f);
+
+	i = 0;
+
+	info[0] = '\0';
+	trap_GetConfigString(CS_SERVERINFO, info, sizeof(info));
+
+	if (atoi( Info_ValueForKey( info, "g_forceBasedTeams" ) ))
+	{
+		switch((int)(trap_Cvar_VariableValue("ui_myteam")))
+		{
+		case TEAM_RED:
+			forceTeam = FORCE_DARKSIDE;
+			break;
+		case TEAM_BLUE:
+			forceTeam = FORCE_LIGHTSIDE;
+			break;
+		default:
+			break;
+		}
+	}
+
+	BG_LegalizedForcePowers(fcfBuffer, uiMaxRank, ui_freeSaber.integer, forceTeam, atoi( Info_ValueForKey( info, "g_gametype" )), 0);
+	//legalize the config based on the max rank
+
+	//now that we're done with the handle, it's time to parse our force data out of the string
+	//we store strings in rank-side-xxxxxxxxx format (where the x's are individual force power levels)
+	while (fcfBuffer[i] && fcfBuffer[i] != '-')
+	{
+		singleBuf[c] = fcfBuffer[i];
+		c++;
+		i++;
+	}
+	singleBuf[c] = 0;
+	c = 0;
+	i++;
+
+	iBuf = atoi(singleBuf);
+
+	if (iBuf > uiMaxRank || iBuf < 0)
+	{ //this force config uses a rank level higher than our currently restricted level.. so we can't use it
+	  //FIXME: Print a message indicating this to the user
+		return;
+	}
+
+	uiForceRank = iBuf;
+
+	while (fcfBuffer[i] && fcfBuffer[i] != '-')
+	{
+		singleBuf[c] = fcfBuffer[i];
+		c++;
+		i++;
+	}
+	singleBuf[c] = 0;
+	c = 0;
+	i++;
+
+	uiForceSide = atoi(singleBuf);
+
+	if (uiForceSide != FORCE_LIGHTSIDE &&
+		uiForceSide != FORCE_DARKSIDE)
+	{
+		uiForceSide = FORCE_LIGHTSIDE;
+		return;
+	}
+
+	//clear out the existing powers
+	while (c < NUM_FORCE_POWERS)
+	{
+		/*
+		if (c==FP_LEVITATION)
+		{
+			uiForcePowersRank[c]=1;
+		}
+		else if (c==FP_SABER_OFFENSE && ui_freeSaber.integer)
+		{
+			uiForcePowersRank[c]=1;
+		}
+		else if (c==FP_SABER_DEFENSE && ui_freeSaber.integer)
+		{
+			uiForcePowersRank[c]=1;
+		}
+		else
+		{
+			uiForcePowersRank[c] = 0;
+		}
+		*/
+		//rww - don't need to do these checks. Just trust whatever the saber config says.
+		uiForcePowersRank[c] = 0;
+		c++;
+	}
+	uiForceUsed = 0;
+	uiForceAvailable = forceMasteryPoints[uiForceRank];
+	gTouchedForce = qtrue;
+
+	for (c=0;fcfBuffer[i]&&c<NUM_FORCE_POWERS;c++,i++)
+	{
+		singleBuf[0] = fcfBuffer[i];
+		singleBuf[1] = 0;
+		iBuf = atoi(singleBuf);	// So, that means that Force Power "c" wants to be set to rank "iBuf".
+		
+		if (iBuf < 0)
+		{
+			iBuf = 0;
+		}
+
+		forcePowerRank = iBuf;
+
+		if (forcePowerRank > FORCE_LEVEL_3 || forcePowerRank < 0)
+		{ //err..  not correct
+			continue;  // skip this power
+		}
+
+		if (uiForcePowerDarkLight[c] && uiForcePowerDarkLight[c] != uiForceSide)
+		{ //Apparently the user has crafted a force config that has powers that don't fit with the config's side.
+			continue;  // skip this power
+		}
+
+		// Accrue cost for each assigned rank for this power.
+		for (currank=FORCE_LEVEL_1;currank<=forcePowerRank;currank++)
+		{	
+			if (bgForcePowerCost[c][currank] > uiForceAvailable)
+			{	// Break out, we can't afford any more power.
+				break;
+			}
+			// Pay for this rank of this power.
+			uiForceUsed += bgForcePowerCost[c][currank];
+			uiForceAvailable -= bgForcePowerCost[c][currank];
+
+			uiForcePowersRank[c]++;
+		}
+	}
+
+	if (uiForcePowersRank[FP_LEVITATION] < 1)
+	{
+		uiForcePowersRank[FP_LEVITATION]=1;
+	}
+	if (uiForcePowersRank[FP_SABER_OFFENSE] < 1 && ui_freeSaber.integer)
+	{
+		uiForcePowersRank[FP_SABER_OFFENSE]=1;
+	}
+	if (uiForcePowersRank[FP_SABER_DEFENSE] < 1 && ui_freeSaber.integer)
+	{
+		uiForcePowersRank[FP_SABER_DEFENSE]=1;
+	}
+
+	UpdateForceUsed();
+}
diff --git a/codemp/ui/ui_force.h b/codemp/ui/ui_force.h
new file mode 100644
index 0000000..088721e
--- /dev/null
+++ b/codemp/ui/ui_force.h
@@ -0,0 +1,33 @@
+#include "../qcommon/qfiles.h"
+
+#define NUM_FORCE_STAR_IMAGES  9
+#define FORCE_NONJEDI	0
+#define FORCE_JEDI		1
+
+extern int uiForceSide;
+extern int uiJediNonJedi;
+extern int uiForceRank;
+extern int uiMaxRank;
+extern int uiForceUsed;
+extern int uiForceAvailable;
+extern qboolean gTouchedForce;
+extern qboolean uiForcePowersDisabled[NUM_FORCE_POWERS];
+extern int uiForcePowersRank[NUM_FORCE_POWERS];
+extern int uiForcePowerDarkLight[NUM_FORCE_POWERS];
+extern int uiSaberColorShaders[NUM_SABER_COLORS];
+// Dots above or equal to a given rank carry a certain color.
+extern vmCvar_t	ui_freeSaber, ui_forcePowerDisable;
+
+void UI_InitForceShaders(void);
+void UI_ReadLegalForce(void);
+void UI_DrawTotalForceStars(rectDef_t *rect, float scale, vec4_t color, int textStyle);
+void UI_DrawForceStars(rectDef_t *rect, float scale, vec4_t color, int textStyle, int findex, int val, int min, int max) ;
+void UI_UpdateClientForcePowers(const char *teamArg);
+void UI_SaveForceTemplate();
+void UI_UpdateForcePowers();
+qboolean UI_SkinColor_HandleKey(int flags, float *special, int key, int num, int min, int max, int type);
+qboolean UI_ForceSide_HandleKey(int flags, float *special, int key, int num, int min, int max, int type);
+qboolean UI_JediNonJedi_HandleKey(int flags, float *special, int key, int num, int min, int max, int type);
+qboolean UI_ForceMaxRank_HandleKey(int flags, float *special, int key, int num, int min, int max, int type);
+qboolean UI_ForcePowerRank_HandleKey(int flags, float *special, int key, int num, int min, int max, int type);
+extern void UI_ForceConfigHandle( int oldindex, int newindex );
diff --git a/codemp/ui/ui_gameinfo.c b/codemp/ui/ui_gameinfo.c
new file mode 100644
index 0000000..bfcc625
--- /dev/null
+++ b/codemp/ui/ui_gameinfo.c
@@ -0,0 +1,333 @@
+// Copyright (C) 1999-2000 Id Software, Inc.
+//
+//
+// gameinfo.c
+//
+
+#include "ui_local.h"
+
+
+//
+// arena and bot info
+//
+
+
+int				ui_numBots;
+static char		*ui_botInfos[MAX_BOTS];
+
+static int		ui_numArenas;
+static char		*ui_arenaInfos[MAX_ARENAS];
+
+/*
+===============
+UI_ParseInfos
+===============
+*/
+int UI_ParseInfos( char *buf, int max, char *infos[] ) {
+	char	*token;
+	int		count;
+	char	key[MAX_TOKEN_CHARS];
+	char	info[MAX_INFO_STRING];
+
+	count = 0;
+
+	while ( 1 ) {
+		token = COM_Parse( (const char **)&buf );
+		if ( !token[0] ) {
+			break;
+		}
+		if ( strcmp( token, "{" ) ) {
+			Com_Printf( "Missing { in info file\n" );
+			break;
+		}
+
+		if ( count == max ) {
+			Com_Printf( "Max infos exceeded\n" );
+			break;
+		}
+
+		info[0] = '\0';
+		while ( 1 ) {
+			token = COM_ParseExt( (const char **)&buf, qtrue );
+			if ( !token[0] ) {
+				Com_Printf( "Unexpected end of info file\n" );
+				break;
+			}
+			if ( !strcmp( token, "}" ) ) {
+				break;
+			}
+			Q_strncpyz( key, token, sizeof( key ) );
+
+			token = COM_ParseExt( (const char **)&buf, qfalse );
+			if ( !token[0] ) {
+				strcpy( token, "<NULL>" );
+			}
+			Info_SetValueForKey( info, key, token );
+		}
+		//NOTE: extra space for arena number
+		infos[count] = (char *) UI_Alloc(strlen(info) + strlen("\\num\\") + strlen(va("%d", MAX_ARENAS)) + 1);
+		if (infos[count]) {
+			strcpy(infos[count], info);
+#ifndef FINAL_BUILD
+			if (trap_Cvar_VariableValue("com_buildScript"))
+			{
+				char *botFile = Info_ValueForKey(info, "personality");
+				if (botFile && botFile[0])
+				{
+					int fh = 0;
+					trap_FS_FOpenFile(botFile, &fh, FS_READ);
+					if (fh)
+					{
+						trap_FS_FCloseFile(fh);
+					}
+				}
+			}
+#endif
+			count++;
+		}
+	}
+	return count;
+}
+
+/*
+===============
+UI_LoadArenasFromFile
+===============
+*/
+static void UI_LoadArenasFromFile( char *filename ) {
+	int				len;
+	fileHandle_t	f;
+	char			buf[MAX_ARENAS_TEXT];
+
+	len = trap_FS_FOpenFile( filename, &f, FS_READ );
+	if ( !f ) {
+		trap_Print( va( S_COLOR_RED "file not found: %s\n", filename ) );
+		return;
+	}
+	if ( len >= MAX_ARENAS_TEXT ) {
+		trap_Print( va( S_COLOR_RED "file too large: %s is %i, max allowed is %i", filename, len, MAX_ARENAS_TEXT ) );
+		trap_FS_FCloseFile( f );
+		return;
+	}
+
+	trap_FS_Read( buf, len, f );
+	buf[len] = 0;
+	trap_FS_FCloseFile( f );
+
+	ui_numArenas += UI_ParseInfos( buf, MAX_ARENAS - ui_numArenas, &ui_arenaInfos[ui_numArenas] );
+}
+
+/*
+===============
+UI_LoadArenas
+===============
+*/
+void UI_LoadArenas( void ) {
+	int			numdirs;
+	char		filename[128];
+	char		dirlist[1024];
+	char*		dirptr;
+	int			i, n;
+	int			dirlen;
+	char		*type;
+
+	ui_numArenas = 0;
+	uiInfo.mapCount = 0;
+
+	// get all arenas from .arena files
+	numdirs = trap_FS_GetFileList("scripts", ".arena", dirlist, 1024 );
+	dirptr  = dirlist;
+	for (i = 0; i < numdirs; i++, dirptr += dirlen+1) {
+		dirlen = strlen(dirptr);
+		strcpy(filename, "scripts/");
+		strcat(filename, dirptr);
+		UI_LoadArenasFromFile(filename);
+	}
+//	trap_Print( va( "%i arenas parsed\n", ui_numArenas ) );
+	if (UI_OutOfMemory()) {
+		trap_Print(S_COLOR_YELLOW"WARNING: not anough memory in pool to load all arenas\n");
+	}
+
+	for( n = 0; n < ui_numArenas; n++ ) {
+		// determine type
+
+		uiInfo.mapList[uiInfo.mapCount].cinematic = -1;
+		uiInfo.mapList[uiInfo.mapCount].mapLoadName = String_Alloc(Info_ValueForKey(ui_arenaInfos[n], "map"));
+		uiInfo.mapList[uiInfo.mapCount].mapName = String_Alloc(Info_ValueForKey(ui_arenaInfos[n], "longname"));
+		uiInfo.mapList[uiInfo.mapCount].levelShot = -1;
+		uiInfo.mapList[uiInfo.mapCount].imageName = String_Alloc(va("levelshots/%s", uiInfo.mapList[uiInfo.mapCount].mapLoadName));
+		uiInfo.mapList[uiInfo.mapCount].typeBits = 0;
+
+		type = Info_ValueForKey( ui_arenaInfos[n], "type" );
+		// if no type specified, it will be treated as "ffa"
+		if( *type ) {
+			if( strstr( type, "ffa" ) ) {
+				uiInfo.mapList[uiInfo.mapCount].typeBits |= (1 << GT_FFA);
+			}
+			if( strstr( type, "holocron" ) ) {
+				uiInfo.mapList[uiInfo.mapCount].typeBits |= (1 << GT_HOLOCRON);
+			}
+			if( strstr( type, "jedimaster" ) ) {
+				uiInfo.mapList[uiInfo.mapCount].typeBits |= (1 << GT_JEDIMASTER);
+			}
+			if( strstr( type, "duel" ) ) {
+				uiInfo.mapList[uiInfo.mapCount].typeBits |= (1 << GT_DUEL);
+				uiInfo.mapList[uiInfo.mapCount].typeBits |= (1 << GT_POWERDUEL);
+			}
+			if( strstr( type, "powerduel" ) ) {
+				uiInfo.mapList[uiInfo.mapCount].typeBits |= (1 << GT_DUEL);
+				uiInfo.mapList[uiInfo.mapCount].typeBits |= (1 << GT_POWERDUEL);
+			}
+			if( strstr( type, "siege" ) ) {
+				uiInfo.mapList[uiInfo.mapCount].typeBits |= (1 << GT_SIEGE);
+			}
+			if( strstr( type, "ctf" ) ) {
+				uiInfo.mapList[uiInfo.mapCount].typeBits |= (1 << GT_CTF);
+			}
+			if( strstr( type, "cty" ) ) {
+				uiInfo.mapList[uiInfo.mapCount].typeBits |= (1 << GT_CTY);
+			}
+		} else {
+			uiInfo.mapList[uiInfo.mapCount].typeBits |= (1 << GT_FFA);
+		}
+
+		uiInfo.mapCount++;
+		if (uiInfo.mapCount >= MAX_MAPS) {
+			break;
+		}
+	}
+}
+
+
+/*
+===============
+UI_LoadBotsFromFile
+===============
+*/
+static void UI_LoadBotsFromFile( char *filename ) {
+	int				len;
+	fileHandle_t	f;
+	char			buf[MAX_BOTS_TEXT];
+	char			*stopMark;
+
+	len = trap_FS_FOpenFile( filename, &f, FS_READ );
+	if ( !f ) {
+		trap_Print( va( S_COLOR_RED "file not found: %s\n", filename ) );
+		return;
+	}
+	if ( len >= MAX_BOTS_TEXT ) {
+		trap_Print( va( S_COLOR_RED "file too large: %s is %i, max allowed is %i", filename, len, MAX_BOTS_TEXT ) );
+		trap_FS_FCloseFile( f );
+		return;
+	}
+
+	trap_FS_Read( buf, len, f );
+	buf[len] = 0;
+
+	stopMark = strstr(buf, "@STOPHERE");
+
+	//This bot is in place as a mark for modview's bot viewer.
+	//If we hit it just stop and trace back to the beginning of the bot define and cut the string off.
+	//This is only done in the UI and not the game so that "test" bots can be added manually and still
+	//not show up in the menu.
+	if (stopMark)
+	{
+		int startPoint = stopMark - buf;
+
+		while (buf[startPoint] != '{')
+		{
+			startPoint--;
+		}
+
+		buf[startPoint] = 0;
+	}
+
+	trap_FS_FCloseFile( f );
+
+	COM_Compress(buf);
+
+	ui_numBots += UI_ParseInfos( buf, MAX_BOTS - ui_numBots, &ui_botInfos[ui_numBots] );
+}
+
+/*
+===============
+UI_LoadBots
+===============
+*/
+void UI_LoadBots( void ) {
+	vmCvar_t	botsFile;
+	int			numdirs;
+	char		filename[128];
+	char		dirlist[1024];
+	char*		dirptr;
+	int			i;
+	int			dirlen;
+
+	ui_numBots = 0;
+
+	trap_Cvar_Register( &botsFile, "g_botsFile", "", CVAR_INIT|CVAR_ROM );
+	if( *botsFile.string ) {
+		UI_LoadBotsFromFile(botsFile.string);
+	}
+	else {
+		UI_LoadBotsFromFile("botfiles/bots.txt");
+	}
+
+	// get all bots from .bot files
+	numdirs = trap_FS_GetFileList("scripts", ".bot", dirlist, 1024 );
+	dirptr  = dirlist;
+	for (i = 0; i < numdirs; i++, dirptr += dirlen+1) {
+		dirlen = strlen(dirptr);
+		strcpy(filename, "scripts/");
+		strcat(filename, dirptr);
+		UI_LoadBotsFromFile(filename);
+	}
+//	trap_Print( va( "%i bots parsed\n", ui_numBots ) );
+}
+
+
+/*
+===============
+UI_GetBotInfoByNumber
+===============
+*/
+char *UI_GetBotInfoByNumber( int num ) {
+	if( num < 0 || num >= ui_numBots ) {
+		trap_Print( va( S_COLOR_RED "Invalid bot number: %i\n", num ) );
+		return NULL;
+	}
+	return ui_botInfos[num];
+}
+
+
+/*
+===============
+UI_GetBotInfoByName
+===============
+*/
+char *UI_GetBotInfoByName( const char *name ) {
+	int		n;
+	char	*value;
+
+	for ( n = 0; n < ui_numBots ; n++ ) {
+		value = Info_ValueForKey( ui_botInfos[n], "name" );
+		if ( !Q_stricmp( value, name ) ) {
+			return ui_botInfos[n];
+		}
+	}
+
+	return NULL;
+}
+
+int UI_GetNumBots() {
+	return ui_numBots;
+}
+
+
+char *UI_GetBotNameByNumber( int num ) {
+	char *info = UI_GetBotInfoByNumber(num);
+	if (info) {
+		return Info_ValueForKey( info, "name" );
+	}
+	return "Kyle";
+}
diff --git a/codemp/ui/ui_local.h b/codemp/ui/ui_local.h
new file mode 100644
index 0000000..f72aa20
--- /dev/null
+++ b/codemp/ui/ui_local.h
@@ -0,0 +1,1166 @@
+// Copyright (C) 1999-2000 Id Software, Inc.
+//
+#ifndef __UI_LOCAL_H__
+#define __UI_LOCAL_H__
+
+#include "../game/q_shared.h"
+#include "../cgame/tr_types.h"
+#include "ui_public.h"
+#include "keycodes.h"
+#include "../game/bg_public.h"
+#include "ui_shared.h"
+
+// global display context
+
+extern vmCvar_t	ui_ffa_fraglimit;
+extern vmCvar_t	ui_ffa_timelimit;
+
+extern vmCvar_t	ui_tourney_fraglimit;
+extern vmCvar_t	ui_tourney_timelimit;
+
+extern vmCvar_t ui_selectedModelIndex;
+
+extern vmCvar_t	ui_team_fraglimit;
+extern vmCvar_t	ui_team_timelimit;
+extern vmCvar_t	ui_team_friendly;
+
+extern vmCvar_t	ui_ctf_capturelimit;
+extern vmCvar_t	ui_ctf_timelimit;
+extern vmCvar_t	ui_ctf_friendly;
+
+extern vmCvar_t	ui_arenasFile;
+extern vmCvar_t	ui_botsFile;
+
+extern vmCvar_t	ui_browserMaster;
+extern vmCvar_t	ui_browserGameType;
+extern vmCvar_t	ui_browserSortKey;
+extern vmCvar_t	ui_browserShowFull;
+extern vmCvar_t	ui_browserShowEmpty;
+
+extern vmCvar_t	ui_drawCrosshair;
+extern vmCvar_t	ui_drawCrosshairNames;
+extern vmCvar_t	ui_marks;
+
+extern vmCvar_t	ui_server1;
+extern vmCvar_t	ui_server2;
+extern vmCvar_t	ui_server3;
+extern vmCvar_t	ui_server4;
+extern vmCvar_t	ui_server5;
+extern vmCvar_t	ui_server6;
+extern vmCvar_t	ui_server7;
+extern vmCvar_t	ui_server8;
+extern vmCvar_t	ui_server9;
+extern vmCvar_t	ui_server10;
+extern vmCvar_t	ui_server11;
+extern vmCvar_t	ui_server12;
+extern vmCvar_t	ui_server13;
+extern vmCvar_t	ui_server14;
+extern vmCvar_t	ui_server15;
+extern vmCvar_t	ui_server16;
+
+extern vmCvar_t	ui_captureLimit;
+extern vmCvar_t	ui_fragLimit;
+extern vmCvar_t	ui_gameType;
+extern vmCvar_t	ui_netGameType;
+extern vmCvar_t	ui_actualNetGameType;
+extern vmCvar_t	ui_joinGameType;
+#ifdef _XBOX
+extern vmCvar_t ui_optiGameType;
+extern vmCvar_t ui_optiCurrentMap;
+extern vmCvar_t ui_optiMinPlayers;
+extern vmCvar_t ui_optiMaxPlayers;
+extern vmCvar_t ui_optiFriendlyFire;
+extern vmCvar_t ui_optiJediMastery;
+extern vmCvar_t ui_optiSaberOnly;
+#endif
+extern vmCvar_t	ui_netSource;
+extern vmCvar_t	ui_serverFilterType;
+extern vmCvar_t	ui_dedicated;
+extern vmCvar_t	ui_opponentName;
+extern vmCvar_t	ui_menuFiles;
+extern vmCvar_t	ui_currentMap;
+extern vmCvar_t	ui_currentNetMap;
+extern vmCvar_t	ui_mapIndex;
+extern vmCvar_t	ui_currentOpponent;
+extern vmCvar_t	ui_selectedPlayer;
+extern vmCvar_t	ui_selectedPlayerName;
+extern vmCvar_t	ui_lastServerRefresh_0;
+extern vmCvar_t	ui_lastServerRefresh_1;
+extern vmCvar_t	ui_lastServerRefresh_2;
+extern vmCvar_t	ui_lastServerRefresh_3;
+extern vmCvar_t	ui_singlePlayerActive;
+extern vmCvar_t	ui_scoreAccuracy;
+extern vmCvar_t	ui_scoreImpressives;
+extern vmCvar_t	ui_scoreExcellents;
+extern vmCvar_t	ui_scoreDefends;
+extern vmCvar_t	ui_scoreAssists;
+extern vmCvar_t	ui_scoreGauntlets;
+extern vmCvar_t	ui_scoreScore;
+extern vmCvar_t	ui_scorePerfect;
+extern vmCvar_t	ui_scoreTeam;
+extern vmCvar_t	ui_scoreBase;
+extern vmCvar_t	ui_scoreTimeBonus;
+extern vmCvar_t	ui_scoreSkillBonus;
+extern vmCvar_t	ui_scoreShutoutBonus;
+extern vmCvar_t	ui_scoreTime;
+extern vmCvar_t ui_serverStatusTimeOut;
+
+extern vmCvar_t ui_bypassMainMenuLoad;
+
+//
+// ui_qmenu.c
+//
+
+#define RCOLUMN_OFFSET			( BIGCHAR_WIDTH )
+#define LCOLUMN_OFFSET			(-BIGCHAR_WIDTH )
+
+#define SLIDER_RANGE			10
+#define	MAX_EDIT_LINE			256
+
+#define MAX_MENUDEPTH			8
+#define MAX_MENUITEMS			256
+
+#define MAX_FORCE_CONFIGS		128
+
+#define MTYPE_NULL				0
+#define MTYPE_SLIDER			1	
+#define MTYPE_ACTION			2
+#define MTYPE_SPINCONTROL		3
+#define MTYPE_FIELD				4
+#define MTYPE_RADIOBUTTON		5
+#define MTYPE_BITMAP			6	
+#define MTYPE_TEXT				7
+#define MTYPE_SCROLLLIST		8
+#define MTYPE_PTEXT				9
+#define MTYPE_BTEXT				10
+
+#define QMF_BLINK				0x00000001
+#define QMF_SMALLFONT			0x00000002
+#define QMF_LEFT_JUSTIFY		0x00000004
+#define QMF_CENTER_JUSTIFY		0x00000008
+#define QMF_RIGHT_JUSTIFY		0x00000010
+#define QMF_NUMBERSONLY			0x00000020	// edit field is only numbers
+#define QMF_HIGHLIGHT			0x00000040
+#define QMF_HIGHLIGHT_IF_FOCUS	0x00000080	// steady focus
+#define QMF_PULSEIFFOCUS		0x00000100	// pulse if focus
+#define QMF_HASMOUSEFOCUS		0x00000200
+#define QMF_NOONOFFTEXT			0x00000400
+#define QMF_MOUSEONLY			0x00000800	// only mouse input allowed
+#define QMF_HIDDEN				0x00001000	// skips drawing
+#define QMF_GRAYED				0x00002000	// grays and disables
+#define QMF_INACTIVE			0x00004000	// disables any input
+#define QMF_NODEFAULTINIT		0x00008000	// skip default initialization
+#define QMF_OWNERDRAW			0x00010000
+#define QMF_PULSE				0x00020000
+#define QMF_LOWERCASE			0x00040000	// edit field is all lower case
+#define QMF_UPPERCASE			0x00080000	// edit field is all upper case
+#define QMF_SILENT				0x00100000
+
+// callback notifications
+#define QM_GOTFOCUS				1
+#define QM_LOSTFOCUS			2
+#define QM_ACTIVATED			3
+
+typedef struct _tag_menuframework
+{
+	int	cursor;
+	int cursor_prev;
+
+	int	nitems;
+	void *items[MAX_MENUITEMS];
+
+	void (*draw) (void);
+	sfxHandle_t (*key) (int key);
+
+	qboolean	wrapAround;
+	qboolean	fullscreen;
+	qboolean	showlogo;
+} menuframework_s;
+
+typedef struct
+{
+	int type;
+	const char *name;
+	int	id;
+	int x, y;
+	int left;
+	int	top;
+	int	right;
+	int	bottom;
+	menuframework_s *parent;
+	int menuPosition;
+	unsigned flags;
+
+	void (*callback)( void *self, int event );
+	void (*statusbar)( void *self );
+	void (*ownerdraw)( void *self );
+} menucommon_s;
+
+typedef struct {
+	int		cursor;
+	int		scroll;
+	int		widthInChars;
+	char	buffer[MAX_EDIT_LINE];
+	int		maxchars;
+} mfield_t;
+
+typedef struct
+{
+	menucommon_s	generic;
+	mfield_t		field;
+} menufield_s;
+
+typedef struct 
+{
+	menucommon_s generic;
+
+	float minvalue;
+	float maxvalue;
+	float curvalue;
+
+	float range;
+} menuslider_s;
+
+typedef struct
+{
+	menucommon_s generic;
+
+	int	oldvalue;
+	int curvalue;
+	int	numitems;
+	int	top;
+		
+	const char **itemnames;
+
+	int width;
+	int height;
+	int	columns;
+	int	seperation;
+} menulist_s;
+
+typedef struct
+{
+	menucommon_s generic;
+} menuaction_s;
+
+typedef struct
+{
+	menucommon_s generic;
+	int curvalue;
+} menuradiobutton_s;
+
+typedef struct
+{
+	menucommon_s	generic;
+	char*			focuspic;	
+	char*			errorpic;
+	qhandle_t		shader;
+	qhandle_t		focusshader;
+	int				width;
+	int				height;
+	float*			focuscolor;
+} menubitmap_s;
+
+typedef struct
+{
+	menucommon_s	generic;
+	char*			string;
+	int				style;
+	float*			color;
+} menutext_s;
+
+extern void			Menu_Cache( void );
+extern void			Menu_Focus( menucommon_s *m );
+extern void			Menu_AddItem( menuframework_s *menu, void *item );
+extern void			Menu_AdjustCursor( menuframework_s *menu, int dir );
+extern void			Menu_Draw( menuframework_s *menu );
+extern void			*Menu_ItemAtCursor( menuframework_s *m );
+extern sfxHandle_t	Menu_ActivateItem( menuframework_s *s, menucommon_s* item );
+extern void			Menu_SetCursor( menuframework_s *s, int cursor );
+extern void			Menu_SetCursorToItem( menuframework_s *m, void* ptr );
+extern sfxHandle_t	Menu_DefaultKey( menuframework_s *s, int key );
+extern void			Bitmap_Init( menubitmap_s *b );
+extern void			Bitmap_Draw( menubitmap_s *b );
+extern void			ScrollList_Draw( menulist_s *l );
+extern sfxHandle_t	ScrollList_Key( menulist_s *l, int key );
+extern sfxHandle_t	menu_in_sound;
+extern sfxHandle_t	menu_move_sound;
+extern sfxHandle_t	menu_out_sound;
+extern sfxHandle_t	menu_buzz_sound;
+extern sfxHandle_t	menu_null_sound;
+extern sfxHandle_t	weaponChangeSound;
+extern vec4_t		menu_text_color;
+extern vec4_t		menu_grayed_color;
+extern vec4_t		menu_dark_color;
+extern vec4_t		menu_highlight_color;
+extern vec4_t		menu_red_color;
+extern vec4_t		menu_black_color;
+extern vec4_t		menu_dim_color;
+extern vec4_t		color_black;
+extern vec4_t		color_white;
+extern vec4_t		color_yellow;
+extern vec4_t		color_blue;
+extern vec4_t		color_orange;
+extern vec4_t		color_red;
+extern vec4_t		color_dim;
+extern vec4_t		name_color;
+extern vec4_t		list_color;
+extern vec4_t		listbar_color;
+extern vec4_t		text_color_disabled; 
+extern vec4_t		text_color_normal;
+extern vec4_t		text_color_highlight;
+
+extern char	*ui_medalNames[];
+extern char	*ui_medalPicNames[];
+extern char	*ui_medalSounds[];
+
+//
+// ui_mfield.c
+//
+extern void			MField_Clear( mfield_t *edit );
+extern void			MField_KeyDownEvent( mfield_t *edit, int key );
+extern void			MField_CharEvent( mfield_t *edit, int ch );
+extern void			MField_Draw( mfield_t *edit, int x, int y, int style, vec4_t color );
+extern void			MenuField_Init( menufield_s* m );
+extern void			MenuField_Draw( menufield_s *f );
+extern sfxHandle_t	MenuField_Key( menufield_s* m, int* key );
+
+//
+// ui_main.c
+//
+qboolean UI_FeederSelection( float feederID, int index, itemDef_t *item );
+void UI_Report();
+void UI_Load();
+void UI_LoadMenus(const char *menuFile, qboolean reset);
+void _UI_SetActiveMenu( uiMenuCommand_t menu );
+int UI_AdjustTimeByGame(int time);
+void UI_ShowPostGame(qboolean newHigh);
+void UI_ClearScores();
+void UI_LoadArenas(void);
+void UI_LoadForceConfig_List( void );
+
+//
+// ui_menu.c
+//
+extern void MainMenu_Cache( void );
+extern void UI_MainMenu(void);
+extern void UI_RegisterCvars( void );
+extern void UI_UpdateCvars( void );
+
+//
+// ui_credits.c
+//
+extern void UI_CreditMenu( void );
+
+//
+// ui_ingame.c
+//
+extern void InGame_Cache( void );
+extern void UI_InGameMenu(void);
+
+//
+// ui_confirm.c
+//
+extern void ConfirmMenu_Cache( void );
+extern void UI_ConfirmMenu( const char *question, void (*draw)( void ), void (*action)( qboolean result ) );
+
+//
+// ui_setup.c
+//
+extern void UI_SetupMenu_Cache( void );
+extern void UI_SetupMenu(void);
+
+//
+// ui_team.c
+//
+extern void UI_TeamMainMenu( void );
+extern void TeamMain_Cache( void );
+
+//
+// ui_connect.c
+//
+extern void UI_DrawConnectScreen( qboolean overlay );
+
+//
+// ui_controls2.c
+//
+extern void UI_ControlsMenu( void );
+extern void Controls_Cache( void );
+
+//
+// ui_demo2.c
+//
+extern void UI_DemosMenu( void );
+extern void Demos_Cache( void );
+
+//
+// ui_cinematics.c
+//
+extern void UI_CinematicsMenu( void );
+extern void UI_CinematicsMenu_f( void );
+extern void UI_CinematicsMenu_Cache( void );
+
+//
+// ui_mods.c
+//
+extern void UI_ModsMenu( void );
+extern void UI_ModsMenu_Cache( void );
+
+//
+// ui_cdkey.c
+//
+extern void UI_CDKeyMenu( void );
+extern void UI_CDKeyMenu_Cache( void );
+extern void UI_CDKeyMenu_f( void );
+
+//
+// ui_playermodel.c
+//
+extern void UI_PlayerModelMenu( void );
+extern void PlayerModel_Cache( void );
+
+//
+// ui_playersettings.c
+//
+extern void UI_PlayerSettingsMenu( void );
+extern void PlayerSettings_Cache( void );
+
+//
+// ui_preferences.c
+//
+extern void UI_PreferencesMenu( void );
+extern void Preferences_Cache( void );
+
+//
+// ui_specifyleague.c
+//
+extern void UI_SpecifyLeagueMenu( void );
+extern void SpecifyLeague_Cache( void );
+
+//
+// ui_specifyserver.c
+//
+extern void UI_SpecifyServerMenu( void );
+extern void SpecifyServer_Cache( void );
+
+//
+// ui_servers2.c
+//
+#define MAX_FAVORITESERVERS 16
+
+extern void UI_ArenaServersMenu( void );
+extern void ArenaServers_Cache( void );
+
+//
+// ui_startserver.c
+//
+extern void UI_StartServerMenu( qboolean multiplayer );
+extern void StartServer_Cache( void );
+extern void ServerOptions_Cache( void );
+extern void UI_BotSelectMenu( char *bot );
+extern void UI_BotSelectMenu_Cache( void );
+
+//
+// ui_serverinfo.c
+//
+extern void UI_ServerInfoMenu( void );
+extern void ServerInfo_Cache( void );
+
+//
+// ui_video.c
+//
+extern void UI_GraphicsOptionsMenu( void );
+extern void GraphicsOptions_Cache( void );
+extern void DriverInfo_Cache( void );
+
+//
+// ui_players.c
+//
+
+//FIXME ripped from cg_local.h
+typedef struct {
+	int			oldFrame;
+	int			oldFrameTime;		// time when ->oldFrame was exactly on
+
+	int			frame;
+	int			frameTime;			// time when ->frame will be exactly on
+
+	float		backlerp;
+
+	float		yawAngle;
+	qboolean	yawing;
+	float		pitchAngle;
+	qboolean	pitching;
+
+	int			animationNumber;
+	animation_t	*animation;
+	int			animationTime;		// time when the first frame of the animation will be exact
+} lerpFrame_t;
+
+typedef struct {
+	// model info
+	qhandle_t		legsModel;
+	qhandle_t		legsSkin;
+	lerpFrame_t		legs;
+
+	qhandle_t		torsoModel;
+	qhandle_t		torsoSkin;
+	lerpFrame_t		torso;
+
+//	qhandle_t		headModel;
+//	qhandle_t		headSkin;
+
+	animation_t		animations[MAX_TOTALANIMATIONS];
+
+	qhandle_t		weaponModel;
+	qhandle_t		barrelModel;
+	qhandle_t		flashModel;
+	vec3_t			flashDlightColor;
+	int				muzzleFlashTime;
+
+	// currently in use drawing parms
+	vec3_t			viewAngles;
+	vec3_t			moveAngles;
+	weapon_t		currentWeapon;
+	int				legsAnim;
+	int				torsoAnim;
+
+	// animation vars
+	weapon_t		weapon;
+	weapon_t		lastWeapon;
+	weapon_t		pendingWeapon;
+	int				weaponTimer;
+	int				pendingLegsAnim;
+	int				torsoAnimationTimer;
+
+	int				pendingTorsoAnim;
+	int				legsAnimationTimer;
+
+	qboolean		chat;
+	qboolean		newModel;
+
+	qboolean		barrelSpinning;
+	float			barrelAngle;
+	int				barrelTime;
+
+	int				realWeapon;
+} playerInfo_t;
+
+//void UI_DrawPlayer( float x, float y, float w, float h, playerInfo_t *pi, int time );
+//void UI_PlayerInfo_SetModel( playerInfo_t *pi, const char *model, const char *headmodel, char *teamName );
+//void UI_PlayerInfo_SetInfo( playerInfo_t *pi, int legsAnim, int torsoAnim, vec3_t viewAngles, vec3_t moveAngles, weapon_t weaponNum, qboolean chat );
+//qboolean UI_RegisterClientModelname( playerInfo_t *pi, const char *modelSkinName , const char *headName, const char *teamName);
+
+//
+// ui_atoms.c
+//
+// this is only used in the old ui, the new ui has it's own version
+typedef struct {
+	int					frametime;
+	int					realtime;
+	int					cursorx;
+	int					cursory;
+	glconfig_t 	glconfig;
+	qboolean		debug;
+	qhandle_t		whiteShader;
+	qhandle_t		menuBackShader;
+	qhandle_t		menuBackShader2;
+	qhandle_t		menuBackNoLogoShader;
+	qhandle_t		charset;
+	qhandle_t		cursor;
+	qhandle_t		rb_on;
+	qhandle_t		rb_off;
+	float				scale;
+	float				bias;
+	qboolean		demoversion;
+	qboolean		firstdraw;
+} uiStatic_t;
+
+
+// new ui stuff
+#define UI_NUMFX 7
+#define MAX_HEADS 64
+#define MAX_ALIASES 64
+#define MAX_HEADNAME  32
+#define MAX_TEAMS 64
+#define MAX_GAMETYPES 16
+#define MAX_MAPS 128
+#define MAX_SPMAPS 16
+#define PLAYERS_PER_TEAM 8//5
+#define MAX_PINGREQUESTS		32
+#define MAX_ADDRESSLENGTH		64
+#define MAX_HOSTNAMELENGTH		22
+#define MAX_MAPNAMELENGTH		16
+#define MAX_STATUSLENGTH		64
+#define MAX_LISTBOXWIDTH		59
+#define UI_FONT_THRESHOLD		0.1
+#define MAX_DISPLAY_SERVERS		2048
+#define MAX_SERVERSTATUS_LINES	128
+#define MAX_SERVERSTATUS_TEXT	1024
+#define MAX_FOUNDPLAYER_SERVERS	16
+#define TEAM_MEMBERS 8//5
+#define GAMES_ALL			0
+#define GAMES_FFA			1
+#define GAMES_HOLOCRON		2
+#define GAMES_TEAMPLAY		3
+#define GAMES_TOURNEY		4
+#define GAMES_CTF			5
+#define MAPS_PER_TIER 3
+#define MAX_TIERS 16
+#define MAX_MODS 64
+#define MAX_DEMOS 256
+#define MAX_MOVIES 256
+#define MAX_Q3PLAYERMODELS 256
+#define MAX_PLAYERMODELS 32
+
+#define MAX_SCROLLTEXT_SIZE		4096
+#define MAX_SCROLLTEXT_LINES		64
+
+typedef struct {
+  const char *name;
+	const char *imageName;
+  qhandle_t headImage;
+	const char *base;
+	qboolean active;
+	int reference;
+} characterInfo;
+
+typedef struct {
+	const char *name;
+	const char *ai;
+	const char *action;
+} aliasInfo;
+
+typedef struct {
+  const char *teamName;
+	const char *imageName;
+	const char *teamMembers[TEAM_MEMBERS];
+  qhandle_t teamIcon;
+  qhandle_t teamIcon_Metal;
+  qhandle_t teamIcon_Name;
+	int cinematic;
+} teamInfo;
+
+typedef struct {
+  const char *gameType;
+  int gtEnum;
+} gameTypeInfo;
+
+typedef struct {
+  const char *mapName;
+  const char *mapLoadName;
+	const char *imageName;
+	const char *opponentName;
+	int teamMembers;
+  int typeBits;
+	int cinematic;
+	int timeToBeat[MAX_GAMETYPES];
+	qhandle_t levelShot;
+	qboolean active;
+} mapInfo;
+
+typedef struct {
+	const char *tierName;
+	const char *maps[MAPS_PER_TIER];
+	int gameTypes[MAPS_PER_TIER];
+	qhandle_t mapHandles[MAPS_PER_TIER];
+} tierInfo;
+
+typedef struct serverFilter_s {
+	const char *description;
+	const char *basedir;
+} serverFilter_t;
+
+typedef struct {
+	char	adrstr[MAX_ADDRESSLENGTH];
+	int		start;
+} pinglist_t;
+
+
+typedef struct serverStatus_s {
+	pinglist_t pingList[MAX_PINGREQUESTS];
+	int		numqueriedservers;
+	int		currentping;
+	int		nextpingtime;
+	int		maxservers;
+	int		refreshtime;
+	int		numServers;
+	int		sortKey;
+	int		sortDir;
+	int		lastCount;
+	qboolean refreshActive;
+	int		currentServer;
+	int		displayServers[MAX_DISPLAY_SERVERS];
+	int		numDisplayServers;
+	int		numPlayersOnServers;
+	int		nextDisplayRefresh;
+	int		nextSortTime;
+	qhandle_t currentServerPreview;
+	int		currentServerCinematic;
+	int		motdLen;
+	int		motdWidth;
+	int		motdPaintX;
+	int		motdPaintX2;
+	int		motdOffset;
+	int		motdTime;
+	char	motd[MAX_STRING_CHARS];
+} serverStatus_t;
+
+
+typedef struct {
+	char		adrstr[MAX_ADDRESSLENGTH];
+	char		name[MAX_ADDRESSLENGTH];
+	int			startTime;
+	int			serverNum;
+	qboolean	valid;
+} pendingServer_t;
+
+typedef struct {
+	int num;
+	pendingServer_t server[MAX_SERVERSTATUSREQUESTS];
+} pendingServerStatus_t;
+
+typedef struct {
+	char address[MAX_ADDRESSLENGTH];
+	char *lines[MAX_SERVERSTATUS_LINES][4];
+	char text[MAX_SERVERSTATUS_TEXT];
+	char pings[MAX_CLIENTS * 3];
+	int numLines;
+} serverStatusInfo_t;
+
+typedef struct {
+	const char *modName;
+	const char *modDescr;
+} modInfo_t;
+
+typedef struct {
+	char		Name[64];
+	int			SkinHeadCount;
+	char		SkinHeadNames[MAX_PLAYERMODELS][16];
+	int			SkinTorsoCount;
+	char		SkinTorsoNames[MAX_PLAYERMODELS][16];
+	int			SkinLegCount;
+	char		SkinLegNames[MAX_PLAYERMODELS][16];
+	char		ColorShader[MAX_PLAYERMODELS][64];
+	int			ColorCount;
+	char		ColorActionText[MAX_PLAYERMODELS][128];
+} playerSpeciesInfo_t;
+
+typedef struct {
+	displayContextDef_t uiDC;
+	int newHighScoreTime;
+	int newBestTime;
+	int showPostGameTime;
+	qboolean newHighScore;
+	qboolean demoAvailable;
+	qboolean soundHighScore;
+	
+	int characterCount;
+	int botIndex;
+//	characterInfo characterList[MAX_HEADS];
+
+	int aliasCount;
+	aliasInfo aliasList[MAX_ALIASES];
+
+	int teamCount;
+	teamInfo teamList[MAX_TEAMS];
+
+	int numGameTypes;
+	gameTypeInfo gameTypes[MAX_GAMETYPES];
+
+	int numJoinGameTypes;
+	gameTypeInfo joinGameTypes[MAX_GAMETYPES];
+
+	int redBlue;
+	int playerCount;
+	int myTeamCount;
+	int teamIndex;
+	int playerRefresh;
+	int playerIndex;
+	int playerNumber; 
+	qboolean teamLeader;
+	char playerNames[MAX_CLIENTS][MAX_NAME_LENGTH];
+	char teamNames[MAX_CLIENTS][MAX_NAME_LENGTH];
+	int teamClientNums[MAX_CLIENTS];
+
+	int playerIndexes[MAX_CLIENTS]; //so we can vote-kick by index
+
+	int mapCount;
+	mapInfo mapList[MAX_MAPS];
+
+
+	int tierCount;
+	tierInfo tierList[MAX_TIERS];
+
+	int skillIndex;
+
+	modInfo_t modList[MAX_MODS];
+	int modCount;
+	int modIndex;
+
+	const char *demoList[MAX_DEMOS];
+	int demoCount;
+	int demoIndex;
+
+	const char *movieList[MAX_MOVIES];
+	int movieCount;
+	int movieIndex;
+	int previewMovie;
+
+	char scrolltext[MAX_SCROLLTEXT_SIZE];
+	const char *scrolltextLine[MAX_SCROLLTEXT_LINES];
+	int scrolltextLineCount;
+
+	serverStatus_t serverStatus;
+
+	// for the showing the status of a server
+	char serverStatusAddress[MAX_ADDRESSLENGTH];
+	serverStatusInfo_t serverStatusInfo;
+	int nextServerStatusRefresh;
+
+	// to retrieve the status of server to find a player
+	pendingServerStatus_t pendingServerStatus;
+	char findPlayerName[MAX_STRING_CHARS];
+	char foundPlayerServerAddresses[MAX_FOUNDPLAYER_SERVERS][MAX_ADDRESSLENGTH];
+	char foundPlayerServerNames[MAX_FOUNDPLAYER_SERVERS][MAX_ADDRESSLENGTH];
+	int currentFoundPlayerServer;
+	int numFoundPlayerServers;
+	int nextFindPlayerRefresh;
+
+	int currentCrosshair;
+	int startPostGameTime;
+	sfxHandle_t newHighScoreSound;
+
+	int				q3HeadCount;
+	char			q3HeadNames[MAX_Q3PLAYERMODELS][64];
+	qhandle_t		q3HeadIcons[MAX_Q3PLAYERMODELS];
+	int				q3SelectedHead;
+
+	int				forceConfigCount;
+	int				forceConfigSelected;
+	char			forceConfigNames[MAX_FORCE_CONFIGS][128];
+	qboolean		forceConfigSide[MAX_FORCE_CONFIGS]; //true if it's a light side config, false if dark side
+	int				forceConfigDarkIndexBegin; //mark the index number dark configs start at
+	int				forceConfigLightIndexBegin; //mark the index number light configs start at
+
+	int effectsColor;
+
+	qboolean inGameLoad;
+
+	int					playerSpeciesCount;
+	playerSpeciesInfo_t	playerSpecies[MAX_PLAYERMODELS];
+	int					playerSpeciesIndex;
+
+	short		movesTitleIndex;
+	char		*movesBaseAnim;
+	int			moveAnimTime;
+
+	int			languageCount;
+	int			languageCountIndex;
+
+}	uiInfo_t;
+
+extern uiInfo_t uiInfo;
+
+
+extern void			UI_Init( void );
+extern void			UI_Shutdown( void );
+extern void			UI_KeyEvent( int key );
+extern void			UI_MouseEvent( int dx, int dy );
+extern void			UI_Refresh( int realtime );
+extern qboolean		UI_ConsoleCommand( int realTime );
+extern float		UI_ClampCvar( float min, float max, float value );
+extern void			UI_DrawNamedPic( float x, float y, float width, float height, const char *picname );
+extern void			UI_DrawHandlePic( float x, float y, float w, float h, qhandle_t hShader ); 
+extern void			UI_FillRect( float x, float y, float width, float height, const float *color );
+extern void			UI_DrawRect( float x, float y, float width, float height, const float *color );
+extern void     UI_DrawTopBottom(float x, float y, float w, float h);
+extern void     UI_DrawSides(float x, float y, float w, float h);
+extern void			UI_UpdateScreen( void );
+extern void			UI_SetColor( const float *rgba );
+extern void			UI_LerpColor(vec4_t a, vec4_t b, vec4_t c, float t);
+extern void			UI_DrawBannerString( int x, int y, const char* str, int style, vec4_t color );
+extern float		UI_ProportionalSizeScale( int style );
+extern void			UI_DrawProportionalString( int x, int y, const char* str, int style, vec4_t color );
+extern int			UI_ProportionalStringWidth( const char* str );
+extern void			UI_DrawString( int x, int y, const char* str, int style, vec4_t color );
+extern void			UI_DrawChar( int x, int y, int ch, int style, vec4_t color );
+extern qboolean 	UI_CursorInRect (int x, int y, int width, int height);
+extern void			UI_DrawTextBox (int x, int y, int width, int lines);
+extern qboolean		UI_IsFullscreen( void );
+extern void			UI_SetActiveMenu( uiMenuCommand_t menu );
+extern void			UI_PushMenu ( menuframework_s *menu );
+extern void			UI_PopMenu (void);
+extern void			UI_ForceMenuOff (void);
+extern char			*UI_Argv( int arg );
+extern char			*UI_Cvar_VariableString( const char *var_name );
+extern void			UI_Refresh( int time );
+extern void			UI_KeyEvent( int key );
+extern void			UI_StartDemoLoop( void );
+extern qboolean		m_entersound;
+void UI_LoadBestScores(const char *map, int game);
+extern uiStatic_t	uis;
+
+//
+// ui_spLevel.c
+//
+void UI_SPLevelMenu_Cache( void );
+void UI_SPLevelMenu( void );
+void UI_SPLevelMenu_f( void );
+void UI_SPLevelMenu_ReInit( void );
+
+//
+// ui_spArena.c
+//
+void UI_SPArena_Start( const char *arenaInfo );
+
+//
+// ui_spPostgame.c
+//
+void UI_SPPostgameMenu_Cache( void );
+void UI_SPPostgameMenu_f( void );
+
+//
+// ui_spSkill.c
+//
+void UI_SPSkillMenu( const char *arenaInfo );
+void UI_SPSkillMenu_Cache( void );
+
+//
+// ui_syscalls.c
+//
+
+#include "../namespace_begin.h"
+
+void			trap_Print( const char *string );
+void			trap_Error( const char *string );
+int				trap_Milliseconds( void );
+void			trap_Cvar_Register( vmCvar_t *vmCvar, const char *varName, const char *defaultValue, int flags );
+void			trap_Cvar_Update( vmCvar_t *vmCvar );
+void			trap_Cvar_Set( const char *var_name, const char *value );
+float			trap_Cvar_VariableValue( const char *var_name );
+void			trap_Cvar_VariableStringBuffer( const char *var_name, char *buffer, int bufsize );
+void			trap_Cvar_SetValue( const char *var_name, float value );
+void			trap_Cvar_Reset( const char *name );
+void			trap_Cvar_Create( const char *var_name, const char *var_value, int flags );
+void			trap_Cvar_InfoStringBuffer( int bit, char *buffer, int bufsize );
+int				trap_Argc( void );
+void			trap_Argv( int n, char *buffer, int bufferLength );
+void			trap_Cmd_ExecuteText( int exec_when, const char *text );	// don't use EXEC_NOW!
+int				trap_FS_FOpenFile( const char *qpath, fileHandle_t *f, fsMode_t mode );
+void			trap_FS_Read( void *buffer, int len, fileHandle_t f );
+void			trap_FS_Write( const void *buffer, int len, fileHandle_t f );
+void			trap_FS_FCloseFile( fileHandle_t f );
+int				trap_FS_GetFileList(  const char *path, const char *extension, char *listbuf, int bufsize );
+qhandle_t		trap_R_RegisterModel( const char *name );
+qhandle_t		trap_R_RegisterSkin( const char *name );
+qhandle_t		trap_R_RegisterShaderNoMip( const char *name );
+void			trap_R_ShaderNameFromIndex(char *name, int index);
+void			trap_R_ClearScene( void );
+void			trap_R_AddRefEntityToScene( const refEntity_t *re );
+void			trap_R_AddPolyToScene( qhandle_t hShader , int numVerts, const polyVert_t *verts );
+void			trap_R_AddLightToScene( const vec3_t org, float intensity, float r, float g, float b );
+void			trap_R_RenderScene( const refdef_t *fd );
+void			trap_R_SetColor( const float *rgba );
+void			trap_R_DrawStretchPic( float x, float y, float w, float h, float s1, float t1, float s2, float t2, qhandle_t hShader );
+void			trap_R_ModelBounds( clipHandle_t model, vec3_t mins, vec3_t maxs );
+void			trap_UpdateScreen( void );
+int				trap_CM_LerpTag( orientation_t *tag, clipHandle_t mod, int startFrame, int endFrame, float frac, const char *tagName );
+void			trap_S_StartLocalSound( sfxHandle_t sfx, int channelNum );
+sfxHandle_t		trap_S_RegisterSound( const char *sample );
+void			trap_Key_KeynumToStringBuf( int keynum, char *buf, int buflen );
+void			trap_Key_GetBindingBuf( int keynum, char *buf, int buflen );
+void			trap_Key_SetBinding( int keynum, const char *binding );
+qboolean		trap_Key_IsDown( int keynum );
+qboolean		trap_Key_GetOverstrikeMode( void );
+void			trap_Key_SetOverstrikeMode( qboolean state );
+void			trap_Key_ClearStates( void );
+int				trap_Key_GetCatcher( void );
+void			trap_Key_SetCatcher( int catcher );
+void			trap_GetClipboardData( char *buf, int bufsize );
+void			trap_GetClientState( uiClientState_t *state );
+void			trap_GetGlconfig( glconfig_t *glconfig );
+int				trap_GetConfigString( int index, char* buff, int buffsize );
+int				trap_LAN_GetServerCount( int source );
+void			trap_LAN_GetServerAddressString( int source, int n, char *buf, int buflen );
+void			trap_LAN_GetServerInfo( int source, int n, char *buf, int buflen );
+int				trap_LAN_GetServerPing( int source, int n );
+int				trap_LAN_GetPingQueueCount( void );
+void			trap_LAN_ClearPing( int n );
+void			trap_LAN_GetPing( int n, char *buf, int buflen, int *pingtime );
+void			trap_LAN_GetPingInfo( int n, char *buf, int buflen );
+void			trap_LAN_LoadCachedServers();
+void			trap_LAN_SaveCachedServers();
+void			trap_LAN_MarkServerVisible(int source, int n, qboolean visible);
+int				trap_LAN_ServerIsVisible( int source, int n);
+qboolean		trap_LAN_UpdateVisiblePings( int source );
+int				trap_LAN_AddServer(int source, const char *name, const char *addr);
+void			trap_LAN_RemoveServer(int source, const char *addr);
+void			trap_LAN_ResetPings(int n);
+int				trap_LAN_ServerStatus( const char *serverAddress, char *serverStatus, int maxLen );
+int				trap_LAN_CompareServers( int source, int sortKey, int sortDir, int s1, int s2 );
+int				trap_MemoryRemaining( void );
+
+#ifdef USE_CD_KEY
+
+void			trap_GetCDKey( char *buf, int buflen );
+void			trap_SetCDKey( char *buf );
+qboolean		trap_VerifyCDKey( const char *key, const char *chksum);
+
+#endif // USE_CD_KEY
+
+qhandle_t		trap_R_RegisterFont( const char *name );
+int				trap_R_Font_StrLenPixels(const char *text, const int iFontIndex, const float scale);
+int				trap_R_Font_StrLenChars(const char *text);
+int				trap_R_Font_HeightPixels(const int iFontIndex, const float scale);
+void			trap_R_Font_DrawString(int ox, int oy, const char *text, const float *rgba, const int setIndex, int iCharLimit, const float scale);
+qboolean		trap_Language_IsAsian(void);
+qboolean		trap_Language_UsesSpaces(void);
+unsigned		trap_AnyLanguage_ReadCharFromString( const char *psText, int *piAdvanceCount, qboolean *pbIsTrailingPunctuation/* = NULL*/ );
+void			trap_S_StopBackgroundTrack( void );
+void			trap_S_StartBackgroundTrack( const char *intro, const char *loop, qboolean bReturnWithoutStarting);
+int				trap_CIN_PlayCinematic( const char *arg0, int xpos, int ypos, int width, int height, int bits);
+e_status		trap_CIN_StopCinematic(int handle);
+e_status		trap_CIN_RunCinematic (int handle);
+void			trap_CIN_DrawCinematic (int handle);
+void			trap_CIN_SetExtents (int handle, int x, int y, int w, int h);
+int				trap_RealTime(qtime_t *qtime);
+void			trap_R_RemapShader( const char *oldShader, const char *newShader, const char *timeOffset );
+
+#include "../namespace_end.h"
+
+//
+// ui_addbots.c
+//
+void UI_AddBots_Cache( void );
+void UI_AddBotsMenu( void );
+
+//
+// ui_removebots.c
+//
+void UI_RemoveBots_Cache( void );
+void UI_RemoveBotsMenu( void );
+
+//
+// ui_teamorders.c
+//
+extern void UI_TeamOrdersMenu( void );
+extern void UI_TeamOrdersMenu_f( void );
+extern void UI_TeamOrdersMenu_Cache( void );
+
+//
+// ui_loadconfig.c
+//
+void UI_LoadConfig_Cache( void );
+void UI_LoadConfigMenu( void );
+
+//
+// ui_saveconfig.c
+//
+void UI_SaveConfigMenu_Cache( void );
+void UI_SaveConfigMenu( void );
+
+//
+// ui_display.c
+//
+void UI_DisplayOptionsMenu_Cache( void );
+void UI_DisplayOptionsMenu( void );
+
+//
+// ui_sound.c
+//
+void UI_SoundOptionsMenu_Cache( void );
+void UI_SoundOptionsMenu( void );
+
+//
+// ui_network.c
+//
+void UI_NetworkOptionsMenu_Cache( void );
+void UI_NetworkOptionsMenu( void );
+
+//
+// ui_gameinfo.c
+//
+typedef enum {
+	AWARD_ACCURACY,
+	AWARD_IMPRESSIVE,
+	AWARD_EXCELLENT,
+	AWARD_GAUNTLET,
+	AWARD_FRAGS,
+	AWARD_PERFECT
+} awardType_t;
+
+const char *UI_GetArenaInfoByNumber( int num );
+const char *UI_GetArenaInfoByMap( const char *map );
+const char *UI_GetSpecialArenaInfo( const char *tag );
+int UI_GetNumArenas( void );
+int UI_GetNumSPArenas( void );
+int UI_GetNumSPTiers( void );
+
+char *UI_GetBotInfoByNumber( int num );
+char *UI_GetBotInfoByName( const char *name );
+int UI_GetNumBots( void );
+void UI_LoadBots( void );
+char *UI_GetBotNameByNumber( int num );
+
+void UI_GetBestScore( int level, int *score, int *skill );
+void UI_SetBestScore( int level, int score );
+int UI_TierCompleted( int levelWon );
+qboolean UI_ShowTierVideo( int tier );
+qboolean UI_CanShowTierVideo( int tier );
+int  UI_GetCurrentGame( void );
+void UI_NewGame( void );
+void UI_LogAwardData( int award, int data );
+int UI_GetAwardLevel( int award );
+
+void UI_SPUnlock_f( void );
+void UI_SPUnlockMedals_f( void );
+
+void UI_InitGameinfo( void );
+
+//
+// ui_login.c
+//
+void Login_Cache( void );
+void UI_LoginMenu( void );
+
+//
+// ui_signup.c
+//
+void Signup_Cache( void );
+void UI_SignupMenu( void );
+
+//
+// ui_rankstatus.c
+//
+void RankStatus_Cache( void );
+void UI_RankStatusMenu( void );
+
+
+// new ui 
+
+#define ASSET_BACKGROUND "uiBackground"
+
+// for tracking sp game info in Team Arena
+typedef struct postGameInfo_s {
+	int score;
+	int redScore;
+	int blueScore;
+	int perfects;
+	int accuracy;
+	int impressives;
+	int excellents;
+	int defends;
+	int assists;
+	int gauntlets;
+	int	captures;
+	int time;
+	int timeBonus;
+	int shutoutBonus;
+	int skillBonus;
+	int baseScore;
+} postGameInfo_t;
+
+
+
+#endif
diff --git a/codemp/ui/ui_main.c b/codemp/ui/ui_main.c
new file mode 100644
index 0000000..19401d1
--- /dev/null
+++ b/codemp/ui/ui_main.c
@@ -0,0 +1,11735 @@
+// Copyright (C) 1999-2000 Id Software, Inc.
+//
+/*
+=======================================================================
+
+USER INTERFACE MAIN
+
+=======================================================================
+*/
+
+// use this to get a demo build without an explicit demo build, i.e. to get the demo ui files to build
+//#define PRE_RELEASE_TADEMO
+
+#include "../ghoul2/G2.h"
+#include "ui_local.h"
+#include "../qcommon/qfiles.h"
+#include "../qcommon/game_version.h"
+#include "ui_force.h"
+#include "../cgame/animtable.h" //we want this to be compiled into the module because we access it in the shared module.
+#include "../game/bg_saga.h"
+
+#include "..\cgame\holocronicons.h"
+
+extern void UI_SaberAttachToChar( itemDef_t *item );
+
+char *forcepowerDesc[NUM_FORCE_POWERS] = 
+{
+"@MENUS_OF_EFFECT_JEDI_ONLY_NEFFECT",
+"@MENUS_DURATION_IMMEDIATE_NAREA",
+"@MENUS_DURATION_5_SECONDS_NAREA",
+"@MENUS_DURATION_INSTANTANEOUS",
+"@MENUS_INSTANTANEOUS_EFFECT_NAREA",
+"@MENUS_DURATION_VARIABLE_20",
+"@MENUS_DURATION_INSTANTANEOUS_NAREA",
+"@MENUS_OF_EFFECT_LIVING_PERSONS",
+"@MENUS_DURATION_VARIABLE_10",
+"@MENUS_DURATION_VARIABLE_NAREA",
+"@MENUS_DURATION_CONTINUOUS_NAREA",
+"@MENUS_OF_EFFECT_JEDI_ALLIES_NEFFECT",
+"@MENUS_EFFECT_JEDI_ALLIES_NEFFECT",
+"@MENUS_VARIABLE_NAREA_OF_EFFECT",
+"@MENUS_EFFECT_NAREA_OF_EFFECT",
+"@SP_INGAME_FORCE_SABER_OFFENSE_DESC",
+"@SP_INGAME_FORCE_SABER_DEFENSE_DESC",
+"@SP_INGAME_FORCE_SABER_THROW_DESC"
+};
+
+#ifdef _XBOX
+#include "../xbox/XBLive.h"
+#include "../xbox/XBoxCommon.h"
+#include "../xbox/XBVoice.h"
+
+
+/*
+===============
+UI_XBL_PlayerListScript
+Handle all UI script calls for player list
+===============
+*/
+void UI_XBL_PlayerListScript(char **args, const char *name)
+{
+	if ( !String_Parse(args, &name) || !name )
+	{
+		return;
+	}
+	//
+	// General player-list management
+	//
+	else if(Q_stricmp(name, "init") == 0)
+	{
+		XBL_PL_Init();
+		Menu_SetFeederSelection(NULL, FEEDER_XBL_PLAYERS, 0, NULL);
+	}
+	else if(Q_stricmp(name, "shutdown") == 0)
+	{
+		XBL_PL_Cleanup();
+	}
+	else if (Q_stricmp(name, "popup") == 0)
+	{
+		// Copy selected player's info into the cvars
+		if (!XBL_PL_SetCurrentInfo())
+			return;
+
+		// Show the popup
+		Menus_ActivateByName("playerlist_popup");
+	}
+	//
+	// User-specific actions
+	//
+	else if (Q_stricmp(name, "friendAdd") == 0)
+	{
+		XBL_PL_MakeFriend();
+	}
+	else if (Q_stricmp(name, "friendRemove") == 0)
+	{
+		XBL_PL_CancelFriend();
+	}
+	else if (Q_stricmp(name, "toggleMute") == 0)
+	{
+		XBL_PL_ToggleMute();
+	}
+	else if (Q_stricmp(name, "sendFeedback") == 0)
+	{
+		XBL_PL_SendFeedBack();
+	}
+	else if (Q_stricmp(name, "kick") == 0)
+	{
+		XBL_PL_KickPlayer();
+	}
+}
+
+void UI_JoinSession()
+{
+	HRESULT result = XBL_F_PerformMenuAction(UI_F_JOINSESSION);
+    
+    // if not S_OK then it was a different game, request disk swap
+    //
+    if( result != S_OK )
+    {
+        Menus_ActivateByName("ingame_med_bgd");
+        trap_Cvar_Set("ui_xboxreboottitle", "Swap disks");//StringTable_Get(XSTR_SWAP_DISCS)); //"Swap Discs"
+		XONLINE_FRIEND* curFriend = XBL_F_GetChosenFriend();
+		char titleString[MAX_TITLENAME_LEN+1];
+		if(curFriend)
+		{
+			XBL_F_GetTitleString(curFriend->dwTitleID, titleString);
+	        trap_Cvar_Set( "ui_xboxrebootmessage", va("%s %s. %s","Please insert", titleString, "This will let you play that crappy game instead of this awesome one."));
+		}
+		else
+	        trap_Cvar_Set( "ui_xboxrebootmessage", "Put in the right disc. That'll shut down this fine piece of software" );
+        Menus_ActivateByName("xbox_swap_disks");
+    }
+}
+
+/*
+===============
+UI_XBL_HandleFriendsPopUp
+Determines which friend pop up to activate based on friend state.
+===============
+*/
+void UI_XBL_HandleFriendsPopUp( void )
+{
+	// Get the chosen friend
+	const XONLINE_FRIEND* curFriend = XBL_F_GetChosenFriend();
+
+	if( !curFriend )
+		return;
+
+	// Is the friend's game joinable?
+	bool joinAvail = (bool)(curFriend->dwFriendState & XONLINE_FRIENDSTATE_FLAG_JOINABLE);
+
+	// We can invite if we're playing...
+	bool inviteAvail = XBL_F_GetState( XONLINE_FRIENDSTATE_FLAG_PLAYING );
+
+	// Double check that we're REALLY in a game
+	uiClientState_t	cstate;
+	trap_GetClientState( &cstate );
+	if( cstate.connState != CA_ACTIVE )
+		inviteAvail = false;
+
+	// If we're in the same game, neither option makes sense
+	if( memcmp( &curFriend->sessionID, Net_GetXNKID(), sizeof(XNKID) ) == 0 )
+		inviteAvail = joinAvail = false;
+
+	// Put the friend's name into the cvar used to display it in all the popups
+	trap_Cvar_Set( "fl_selectedName", curFriend->szGamertag );
+
+	// Based on current friendstates activate correct popup
+
+	// Player has received a game invite fom the indicated friend (Accept/Decline/Remove)
+	if( curFriend->dwFriendState & XONLINE_FRIENDSTATE_FLAG_RECEIVEDINVITE )
+		Menus_ActivateByName("xbf_ReceivedInvite_popup");
+
+	// We sent an invite, didn't hear back. Player is online and playing (joinable). (Cancel/Join/Remove)
+	else if( (curFriend->dwFriendState & XONLINE_FRIENDSTATE_FLAG_SENTINVITE) &&
+			 !(curFriend->dwFriendState & XONLINE_FRIENDSTATE_FLAG_INVITEACCEPTED) && 
+			 !(curFriend->dwFriendState & XONLINE_FRIENDSTATE_FLAG_INVITEREJECTED) && 
+			 (curFriend->dwFriendState & XONLINE_FRIENDSTATE_FLAG_PLAYING) &&
+			 joinAvail )
+		Menus_ActivateByName("xbf_SentInviteCanJoin_popup");
+
+	// We sent an invite, didn't hear back. Player is idle, offline, or in our game (not joinable). (Cancel/Remove)
+	else if( (curFriend->dwFriendState & XONLINE_FRIENDSTATE_FLAG_SENTINVITE) && 
+			 !(curFriend->dwFriendState & XONLINE_FRIENDSTATE_FLAG_INVITEACCEPTED) && 
+			 !(curFriend->dwFriendState & XONLINE_FRIENDSTATE_FLAG_INVITEREJECTED) && 
+			 !(curFriend->dwFriendState & XONLINE_FRIENDSTATE_FLAG_PLAYING) )
+		Menus_ActivateByName("xbf_SentInviteNoJoin_popup");
+
+	// Player has received a friend request. (Accept/Decline/Block)
+	else if( curFriend->dwFriendState & XONLINE_FRIENDSTATE_FLAG_RECEIVEDREQUEST )
+		Menus_ActivateByName("xbf_ReceivedRequest_popup");
+
+	// Player has sent a friend request. (Revoke)
+	else if( curFriend->dwFriendState & XONLINE_FRIENDSTATE_FLAG_SENTREQUEST )
+		Menus_ActivateByName("xbf_SentRequest_popup");
+
+	// Now, there are four more options, for all combinations of join and invite being available.
+	// It really doesn't matter if the user is online or offline.
+
+	// Player is joinable, and we have the option to invite (Invite/Join/Remove)
+	else if( joinAvail && inviteAvail )
+		Menus_ActivateByName("xbf_BasicInviteJoin_popup");
+
+	// Player is joinable, but we can't send an invitation (Join/Remove)
+	else if( joinAvail && !inviteAvail )
+		Menus_ActivateByName("xbf_BasicJoin_popup");
+
+	// Player can be invited, but we can't join their game (Invite/Remove)
+	else if( !joinAvail && inviteAvail )
+		Menus_ActivateByName("xbf_BasicInvite_popup");
+
+	// We can't invite, can't join (Remove)
+	else
+		Menus_ActivateByName("xbf_Basic_popup");
+}
+
+/*
+===============
+UI_XBL_FriendsListScript
+Handle all UI script calls for friends list
+===============
+*/
+void UI_XBL_FriendsListScript(char **args, const char *name)
+{
+	if ( !String_Parse(args, &name) || !name )
+	{
+		return;
+	}
+	//
+	// General friends-list management
+	//
+	else if(Q_stricmp(name, "init") == 0)
+	{
+		// VVFIXME - Initialize selection or something? - generate isn't instant!
+		XBL_F_GenerateFriendsList();
+		Menu_SetFeederSelection(NULL, FEEDER_XBL_FRIENDS, 0, NULL);
+	}
+	else if(Q_stricmp(name, "shutdown") == 0)
+	{
+		XBL_F_ReleaseFriendsList();
+	}
+	else if (Q_stricmp(name, "popup") == 0)
+	{
+		// Display the correct popup, depending on many factors
+		UI_XBL_HandleFriendsPopUp();
+	}
+	//
+	// Respond to friend requests
+	//
+	else if (Q_stricmp(name, "accept") == 0)
+	{
+		XBL_F_PerformMenuAction(UI_F_FRIENDACCEPTED);
+	}
+	else if (Q_stricmp(name, "decline") == 0)
+	{
+		XBL_F_PerformMenuAction(UI_F_FRIENDDECLINE);
+	}
+	else if (Q_stricmp(name, "block") == 0)
+	{
+		XBL_F_PerformMenuAction(UI_F_FRIENDBLOCK);
+	}
+	// VVFIXME - Why is this here? It makes no sense.
+//	else if (Q_stricmp(name, "request") == 0)
+//	{
+//		XBL_F_PerformMenuAction(UI_F_FRIENDREQUESTED);
+//	}
+
+	//
+	// Remove an existing friend or cancel a pending friend request
+	//
+	else if (Q_stricmp(name, "remove") == 0)
+	{
+		XBL_F_PerformMenuAction(UI_F_FRIENDREMOVE);
+	}
+	else if (Q_stricmp(name, "cancel") == 0)
+	{
+		XBL_F_PerformMenuAction(UI_F_FRIENDCANCEL);
+	}
+
+	//
+	// Invite someone to play, or cancel a pending invitation
+	//
+	else if (Q_stricmp(name, "invite") == 0)
+	{
+		XBL_F_PerformMenuAction(UI_F_GAMEREQUESTED);
+	}
+	else if(Q_stricmp(name, "uninvite") == 0)
+	{
+		XBL_F_PerformMenuAction(UI_F_GAMECANCEL);
+	}
+
+	//
+	// Respond to a game invitation
+	//
+	else if (Q_stricmp(name, "acceptInvite") == 0)
+	{
+//        strcpy( hostName, "friend" );
+
+		HRESULT result = XBL_F_PerformMenuAction(UI_F_GAMEACCEPTED);
+
+        // if not S_OK then it was a different game, request disk swap
+        //
+        if( result != S_OK )
+        {
+            Menus_ActivateByName("ingame_med_bgd");
+            trap_Cvar_Set("ui_xboxreboottitle", "Swap Disks");//StringTable_Get(XSTR_SWAP_DISCS)); //"Swap Disks"
+            //strcpy( str, "Please insert the appropriate Xbox Game Disk. This will close down your Soldier Of Fortune II Double Helix session and reboot your Xbox.");
+			XONLINE_FRIEND* curFriend = XBL_F_GetChosenFriend();
+			char titleString[MAX_TITLENAME_LEN+1];
+			if(curFriend)
+			{
+				XBL_F_GetTitleString(curFriend->dwTitleID, titleString);
+	            trap_Cvar_Set( "ui_xboxrebootmessage", va("%s %s. %s", "Please insert", titleString, "Close JA session"));
+			}
+			else
+	            trap_Cvar_Set( "ui_xboxrebootmessage", "Plz put in the disk. This will close down this game."); //"Please insert the appropriate Xbox Game Disc. This will close down your Soldier Of Fortune II Double Helix session."
+
+            Menus_ActivateByName("xbox_swap_disks");
+        }
+
+	}
+	else if (Q_stricmp(name, "declineInvite") == 0)
+	{
+		XBL_F_PerformMenuAction(UI_F_GAMEDECLINE);
+	}
+	else if (Q_stricmp(name, "removeInviter") == 0)
+	{
+		XBL_F_PerformMenuAction(UI_F_GAMEFRIENDREMOVED);
+	}
+
+	//
+	// Join someone else's game uninvited
+	//
+	else if (Q_stricmp(name, "join") == 0)
+	{
+        XONLINE_FRIEND* curFriend = XBL_F_GetChosenFriend();
+
+        if( curFriend && XBL_MM_ThisSessionIsLagging( &curFriend->sessionID ) )
+        {
+            XBL_MM_SetJoinType(VIA_FRIEND_JOIN);
+	        trap_Cvar_Set("ui_xboxreboottitle", " ");
+            trap_Cvar_Set("ui_xboxrebootmessage", "The net suxors. You might not want to do this.");
+		    Menus_ActivateByName("ingame_small_bgd");
+            Menus_ActivateByName("xblive_slow_warning");
+        }
+        else
+        {
+		    Menus_CloseByName("ingame_small_bgd");
+            UI_JoinSession();
+        }
+	}
+
+	// Appear online/offline
+	else if(Q_stricmp(name, "toggleOnline") == 0)
+	{
+		XBL_F_PerformMenuAction(UI_F_TOGGLEONLINE);		
+	}
+}
+#endif	// _XBOX
+
+// Movedata Sounds
+typedef enum
+{
+	MDS_NONE = 0,
+	MDS_FORCE_JUMP,
+	MDS_ROLL,
+	MDS_SABER,
+	MDS_MOVE_SOUNDS_MAX
+};
+
+typedef enum
+{
+	MD_ACROBATICS = 0,
+	MD_SINGLE_FAST,
+	MD_SINGLE_MEDIUM,
+	MD_SINGLE_STRONG,
+	MD_DUAL_SABERS,
+	MD_SABER_STAFF,
+	MD_MOVE_TITLE_MAX
+};
+
+// Some hard coded badness
+// At some point maybe this should be externalized to a .dat file
+char *datapadMoveTitleData[MD_MOVE_TITLE_MAX] =
+{
+"@MENUS_ACROBATICS",
+"@MENUS_SINGLE_FAST",
+"@MENUS_SINGLE_MEDIUM",
+"@MENUS_SINGLE_STRONG",
+"@MENUS_DUAL_SABERS",
+"@MENUS_SABER_STAFF",
+};
+
+char *datapadMoveTitleBaseAnims[MD_MOVE_TITLE_MAX] =
+{
+"BOTH_RUN1",
+"BOTH_SABERFAST_STANCE",
+"BOTH_STAND2",
+"BOTH_SABERSLOW_STANCE",
+"BOTH_SABERDUAL_STANCE",
+"BOTH_SABERSTAFF_STANCE",
+};
+
+#define MAX_MOVES 16
+
+typedef struct 
+{
+	char	*title;	
+	char	*desc;	
+	char	*anim;
+	short	sound;
+} datpadmovedata_t;
+
+static datpadmovedata_t datapadMoveData[MD_MOVE_TITLE_MAX][MAX_MOVES] = 
+{
+// Acrobatics
+"@MENUS_FORCE_JUMP1",				"@MENUS_FORCE_JUMP1_DESC",			"BOTH_FORCEJUMP1",				MDS_FORCE_JUMP,
+"@MENUS_FORCE_FLIP",				"@MENUS_FORCE_FLIP_DESC",			"BOTH_FLIP_F",					MDS_FORCE_JUMP,
+"@MENUS_ROLL",						"@MENUS_ROLL_DESC",					"BOTH_ROLL_F",					MDS_ROLL,
+"@MENUS_BACKFLIP_OFF_WALL",			"@MENUS_BACKFLIP_OFF_WALL_DESC",	"BOTH_WALL_FLIP_BACK1",			MDS_FORCE_JUMP,
+"@MENUS_SIDEFLIP_OFF_WALL",			"@MENUS_SIDEFLIP_OFF_WALL_DESC",	"BOTH_WALL_FLIP_RIGHT",			MDS_FORCE_JUMP,
+"@MENUS_WALL_RUN",					"@MENUS_WALL_RUN_DESC",				"BOTH_WALL_RUN_RIGHT",			MDS_FORCE_JUMP,
+"@MENUS_WALL_GRAB_JUMP",			"@MENUS_WALL_GRAB_JUMP_DESC",		"BOTH_FORCEWALLREBOUND_FORWARD",MDS_FORCE_JUMP,
+"@MENUS_RUN_UP_WALL_BACKFLIP",		"@MENUS_RUN_UP_WALL_BACKFLIP_DESC",	"BOTH_FORCEWALLRUNFLIP_START",	MDS_FORCE_JUMP,
+"@MENUS_JUMPUP_FROM_KNOCKDOWN",		"@MENUS_JUMPUP_FROM_KNOCKDOWN_DESC","BOTH_KNOCKDOWN3",				MDS_NONE,
+"@MENUS_JUMPKICK_FROM_KNOCKDOWN",	"@MENUS_JUMPKICK_FROM_KNOCKDOWN_DESC","BOTH_KNOCKDOWN2",			MDS_NONE,
+"@MENUS_ROLL_FROM_KNOCKDOWN",		"@MENUS_ROLL_FROM_KNOCKDOWN_DESC",	"BOTH_KNOCKDOWN1",				MDS_NONE,
+NULL, NULL, 0,	MDS_NONE,
+NULL, NULL, 0,	MDS_NONE,
+NULL, NULL, 0,	MDS_NONE,
+NULL, NULL, 0,	MDS_NONE,
+NULL, NULL, 0,	MDS_NONE,
+
+//Single Saber, Fast Style
+"@MENUS_STAB_BACK",					"@MENUS_STAB_BACK_DESC",			"BOTH_A2_STABBACK1",			MDS_SABER,
+"@MENUS_LUNGE_ATTACK",				"@MENUS_LUNGE_ATTACK_DESC",			"BOTH_LUNGE2_B__T_",			MDS_SABER,
+"@MENUS_FAST_ATTACK_KATA",			"@MENUS_FAST_ATTACK_KATA_DESC",		"BOTH_A1_SPECIAL",				MDS_SABER,
+"@MENUS_ATTACK_ENEMYONGROUND",		"@MENUS_ATTACK_ENEMYONGROUND_DESC", "BOTH_STABDOWN",				MDS_FORCE_JUMP,
+"@MENUS_CARTWHEEL",					"@MENUS_CARTWHEEL_DESC",			"BOTH_ARIAL_RIGHT",				MDS_FORCE_JUMP,
+"@MENUS_BOTH_ROLL_STAB",			"@MENUS_BOTH_ROLL_STAB2_DESC",		"BOTH_ROLL_STAB",				MDS_SABER,
+NULL, NULL, 0,	MDS_NONE,
+NULL, NULL, 0,	MDS_NONE,
+NULL, NULL, 0,	MDS_NONE,
+NULL, NULL, 0,	MDS_NONE,
+NULL, NULL, 0,	MDS_NONE,
+NULL, NULL, 0,	MDS_NONE,
+NULL, NULL, 0,	MDS_NONE,
+NULL, NULL, 0,	MDS_NONE,
+NULL, NULL, 0,	MDS_NONE,
+NULL, NULL, 0,	MDS_NONE,
+
+//Single Saber, Medium Style
+"@MENUS_SLASH_BACK",				"@MENUS_SLASH_BACK_DESC",			"BOTH_ATTACK_BACK",				MDS_SABER,
+"@MENUS_FLIP_ATTACK",				"@MENUS_FLIP_ATTACK_DESC",			"BOTH_JUMPFLIPSLASHDOWN1",		MDS_FORCE_JUMP,
+"@MENUS_MEDIUM_ATTACK_KATA",		"@MENUS_MEDIUM_ATTACK_KATA_DESC",	"BOTH_A2_SPECIAL",				MDS_SABER,
+"@MENUS_ATTACK_ENEMYONGROUND",		"@MENUS_ATTACK_ENEMYONGROUND_DESC", "BOTH_STABDOWN",				MDS_FORCE_JUMP,
+"@MENUS_CARTWHEEL",					"@MENUS_CARTWHEEL_DESC",			"BOTH_ARIAL_RIGHT",				MDS_FORCE_JUMP,
+"@MENUS_BOTH_ROLL_STAB",			"@MENUS_BOTH_ROLL_STAB2_DESC",		"BOTH_ROLL_STAB",				MDS_SABER,
+NULL, NULL, 0,	MDS_NONE,
+NULL, NULL, 0,	MDS_NONE,
+NULL, NULL, 0,	MDS_NONE,
+NULL, NULL, 0,	MDS_NONE,
+NULL, NULL, 0,	MDS_NONE,
+NULL, NULL, 0,	MDS_NONE,
+NULL, NULL, 0,	MDS_NONE,
+NULL, NULL, 0,	MDS_NONE,
+NULL, NULL, 0,	MDS_NONE,
+NULL, NULL, 0,	MDS_NONE,
+
+//Single Saber, Strong Style
+"@MENUS_SLASH_BACK",				"@MENUS_SLASH_BACK_DESC",			"BOTH_ATTACK_BACK",				MDS_SABER,
+"@MENUS_JUMP_ATTACK",				"@MENUS_JUMP_ATTACK_DESC",			"BOTH_FORCELEAP2_T__B_",		MDS_FORCE_JUMP,
+"@MENUS_STRONG_ATTACK_KATA",		"@MENUS_STRONG_ATTACK_KATA_DESC",	"BOTH_A3_SPECIAL",				MDS_SABER,
+"@MENUS_ATTACK_ENEMYONGROUND",		"@MENUS_ATTACK_ENEMYONGROUND_DESC", "BOTH_STABDOWN",				MDS_FORCE_JUMP,
+"@MENUS_CARTWHEEL",					"@MENUS_CARTWHEEL_DESC",			"BOTH_ARIAL_RIGHT",				MDS_FORCE_JUMP,
+"@MENUS_BOTH_ROLL_STAB",			"@MENUS_BOTH_ROLL_STAB2_DESC",		"BOTH_ROLL_STAB",				MDS_SABER,
+NULL, NULL, 0,	MDS_NONE,
+NULL, NULL, 0,	MDS_NONE,
+NULL, NULL, 0,	MDS_NONE,
+NULL, NULL, 0,	MDS_NONE,
+NULL, NULL, 0,	MDS_NONE,
+NULL, NULL, 0,	MDS_NONE,
+NULL, NULL, 0,	MDS_NONE,
+NULL, NULL, 0,	MDS_NONE,
+NULL, NULL, 0,	MDS_NONE,
+NULL, NULL, 0,	MDS_NONE,
+
+//Dual Sabers
+"@MENUS_SLASH_BACK",				"@MENUS_SLASH_BACK_DESC",			"BOTH_ATTACK_BACK",				MDS_SABER,
+"@MENUS_FLIP_FORWARD_ATTACK",		"@MENUS_FLIP_FORWARD_ATTACK_DESC",	"BOTH_JUMPATTACK6",				MDS_FORCE_JUMP,
+"@MENUS_DUAL_SABERS_TWIRL",			"@MENUS_DUAL_SABERS_TWIRL_DESC",	"BOTH_SPINATTACK6",				MDS_SABER,
+"@MENUS_ATTACK_ENEMYONGROUND",		"@MENUS_ATTACK_ENEMYONGROUND_DESC", "BOTH_STABDOWN_DUAL",				MDS_FORCE_JUMP,
+"@MENUS_DUAL_SABER_BARRIER",		"@MENUS_DUAL_SABER_BARRIER_DESC",	"BOTH_A6_SABERPROTECT",			MDS_SABER,
+"@MENUS_DUAL_STAB_FRONT_BACK",		"@MENUS_DUAL_STAB_FRONT_BACK_DESC", "BOTH_A6_FB",					MDS_SABER,
+"@MENUS_DUAL_STAB_LEFT_RIGHT",		"@MENUS_DUAL_STAB_LEFT_RIGHT_DESC", "BOTH_A6_LR",					MDS_SABER,
+"@MENUS_CARTWHEEL",					"@MENUS_CARTWHEEL_DESC",			"BOTH_ARIAL_RIGHT",				MDS_FORCE_JUMP,
+"@MENUS_BOTH_ROLL_STAB",			"@MENUS_BOTH_ROLL_STAB_DESC",		"BOTH_ROLL_STAB",				MDS_SABER,
+NULL, NULL, 0,	MDS_NONE,
+NULL, NULL, 0,	MDS_NONE,
+NULL, NULL, 0,	MDS_NONE,
+NULL, NULL, 0,	MDS_NONE,
+NULL, NULL, 0,	MDS_NONE,
+NULL, NULL, 0,	MDS_NONE,
+NULL, NULL, 0,	MDS_NONE,
+
+// Saber Staff
+"@MENUS_STAB_BACK",					"@MENUS_STAB_BACK_DESC",			"BOTH_A2_STABBACK1",			MDS_SABER,
+"@MENUS_BACK_FLIP_ATTACK",			"@MENUS_BACK_FLIP_ATTACK_DESC",		"BOTH_JUMPATTACK7",				MDS_FORCE_JUMP,
+"@MENUS_SABER_STAFF_TWIRL",			"@MENUS_SABER_STAFF_TWIRL_DESC",	"BOTH_SPINATTACK7",				MDS_SABER,
+"@MENUS_ATTACK_ENEMYONGROUND",		"@MENUS_ATTACK_ENEMYONGROUND_DESC", "BOTH_STABDOWN_STAFF",			MDS_FORCE_JUMP,
+"@MENUS_SPINNING_KATA",				"@MENUS_SPINNING_KATA_DESC",		"BOTH_A7_SOULCAL",				MDS_SABER,
+"@MENUS_KICK1",						"@MENUS_KICK1_DESC",				"BOTH_A7_KICK_F",				MDS_FORCE_JUMP,
+"@MENUS_JUMP_KICK",					"@MENUS_JUMP_KICK_DESC",			"BOTH_A7_KICK_F_AIR",			MDS_FORCE_JUMP,
+"@MENUS_BUTTERFLY_ATTACK",			"@MENUS_BUTTERFLY_ATTACK_DESC",		"BOTH_BUTTERFLY_FR1",			MDS_SABER,
+"@MENUS_BOTH_ROLL_STAB",			"@MENUS_BOTH_ROLL_STAB2_DESC",		"BOTH_ROLL_STAB",				MDS_SABER,
+NULL, NULL, 0,	MDS_NONE,
+NULL, NULL, 0,	MDS_NONE,
+NULL, NULL, 0,	MDS_NONE,
+NULL, NULL, 0,	MDS_NONE,
+NULL, NULL, 0,	MDS_NONE,
+NULL, NULL, 0,	MDS_NONE,
+NULL, NULL, 0,	MDS_NONE,
+};
+
+
+/*
+================
+vmMain
+
+This is the only way control passes into the module.
+!!! This MUST BE THE VERY FIRST FUNCTION compiled into the .qvm file !!!
+================
+*/
+vmCvar_t  ui_debug;
+vmCvar_t  ui_initialized;
+vmCvar_t	ui_char_color_red;
+vmCvar_t	ui_char_color_green;
+vmCvar_t	ui_char_color_blue;
+vmCvar_t	ui_PrecacheModels;
+vmCvar_t	ui_char_anim;
+
+//JLFCALLOUT 
+#ifdef _XBOX
+vmCvar_t	ui_hideAcallout;
+vmCvar_t	ui_hideBcallout;
+vmCvar_t	ui_hideXcallout;
+#endif
+//END JLFCALLOUT
+
+void _UI_Init( qboolean );
+void _UI_Shutdown( void );
+void _UI_KeyEvent( int key, qboolean down );
+void _UI_MouseEvent( int dx, int dy );
+void _UI_Refresh( int realtime );
+qboolean _UI_IsFullscreen( void );
+void UI_SetSiegeTeams(void);
+extern qboolean UI_SaberModelForSaber( const char *saberName, char *saberModel );
+void UI_SiegeSetCvarsForClass(siegeClass_t *scl);
+int UI_SiegeClassNum(siegeClass_t *scl);
+void UI_UpdateCvarsForClass(const int team,const baseClass,const int index);
+void	UI_UpdateSiegeStatusIcons(void);
+void UI_ClampMaxPlayers(void);
+static void UI_CheckServerName( void );
+static qboolean UI_CheckPassword( void );
+static void UI_JoinServer( void );
+
+#include "../namespace_begin.h"
+// Functions in BG or ui_shared
+void Menu_ShowGroup (menuDef_t *menu, char *itemName, qboolean showFlag);
+void Menu_ItemDisable(menuDef_t *menu, char *name,int disableFlag);
+int Menu_ItemsMatchingGroup(menuDef_t *menu, const char *name);
+itemDef_t *Menu_GetMatchingItemByNumber(menuDef_t *menu, int index, const char *name);
+
+int BG_GetUIPortrait(const int team, const short classIndex, const short cntIndex);
+char *BG_GetUIPortraitFile(const int team, const short classIndex, const short cntIndex);
+
+siegeClass_t *BG_GetClassOnBaseClass(const int team, const short classIndex, const short cntIndex);
+
+int vmMain( int command, int arg0, int arg1, int arg2, int arg3, int arg4, int arg5, int arg6, int arg7, int arg8, int arg9, int arg10, int arg11  ) {
+  switch ( command ) {
+	  case UI_GETAPIVERSION:
+		  return UI_API_VERSION;
+
+	  case UI_INIT:
+		  _UI_Init(arg0);
+		  return 0;
+
+	  case UI_SHUTDOWN:
+		  _UI_Shutdown();
+		  return 0;
+
+	  case UI_KEY_EVENT:
+		  _UI_KeyEvent( arg0, arg1 );
+		  return 0;
+
+	  case UI_MOUSE_EVENT:
+		  _UI_MouseEvent( arg0, arg1 );
+		  return 0;
+
+	  case UI_REFRESH:
+		  _UI_Refresh( arg0 );
+		  return 0;
+
+	  case UI_IS_FULLSCREEN:
+		  return _UI_IsFullscreen();
+
+	  case UI_SET_ACTIVE_MENU:
+		  _UI_SetActiveMenu( arg0 );
+		  return 0;
+
+	  case UI_CONSOLE_COMMAND:
+		  return UI_ConsoleCommand(arg0);
+
+	  case UI_DRAW_CONNECT_SCREEN:
+		  UI_DrawConnectScreen( arg0 );
+		  return 0;
+	  case UI_HASUNIQUECDKEY: // mod authors need to observe this
+	    return qtrue; // bk010117 - change this to qfalse for mods!
+	  case UI_MENU_RESET:
+		  Menu_Reset();
+		  return 0;
+	}
+
+	return -1;
+}
+#include "../namespace_end.h"
+
+siegeClassDesc_t g_UIClassDescriptions[MAX_SIEGE_CLASSES];
+siegeTeam_t *siegeTeam1 = NULL;
+siegeTeam_t *siegeTeam2 = NULL;
+int g_UIGloballySelectedSiegeClass = -1;
+
+//Cut down version of the stuff used in the game code
+//This is just the bare essentials of what we need to load animations properly for ui ghoul2 models.
+//This function doesn't need to be sync'd with the BG_ version in bg_panimate.c unless some sort of fundamental change
+//is made. Just make sure the variables/functions accessed in ui_shared.c exist in both modules.
+qboolean	UIPAFtextLoaded = qfalse;
+animation_t	uiHumanoidAnimations[MAX_TOTALANIMATIONS]; //humanoid animations are the only ones that are statically allocated.
+
+#include "../namespace_begin.h"
+bgLoadedAnim_t bgAllAnims[MAX_ANIM_FILES];
+int uiNumAllAnims = 1; //start off at 0, because 0 will always be assigned to humanoid.
+#include "../namespace_end.h"
+
+animation_t *UI_AnimsetAlloc(void)
+{
+	assert (uiNumAllAnims < MAX_ANIM_FILES);
+	bgAllAnims[uiNumAllAnims].anims = (animation_t *) BG_Alloc(sizeof(animation_t)*MAX_TOTALANIMATIONS);
+
+	return bgAllAnims[uiNumAllAnims].anims;
+}
+
+/*
+======================
+UI_ParseAnimationFile
+
+Read a configuration file containing animation coutns and rates
+models/players/visor/animation.cfg, etc
+
+======================
+*/
+#include "../namespace_begin.h"
+static char UIPAFtext[60000];
+int UI_ParseAnimationFile(const char *filename, animation_t *animset, qboolean isHumanoid) 
+{
+	char		*text_p;
+	int			len;
+	int			i;
+	char		*token;
+	float		fps;
+	int			skip;
+	int			usedIndex = -1;
+	int			nextIndex = uiNumAllAnims;
+
+	fileHandle_t	f;
+	int				animNum;
+
+	if (!isHumanoid)
+	{
+		i = 1;
+		while (i < uiNumAllAnims)
+		{ //see if it's been loaded already
+			if (!Q_stricmp(bgAllAnims[i].filename, filename))
+			{
+				animset = bgAllAnims[i].anims;
+				return i; //alright, we already have it.
+			}
+			i++;
+		}
+
+		//Looks like it has not yet been loaded. Allocate space for the anim set if we need to, and continue along.
+		if (!animset)
+		{
+			if (strstr(filename, "players/_humanoid/"))
+			{ //then use the static humanoid set.
+				animset = uiHumanoidAnimations;
+				isHumanoid = qtrue;
+				nextIndex = 0;
+			}
+			else
+			{
+				animset = UI_AnimsetAlloc();
+
+				if (!animset)
+				{
+					assert(!"Anim set alloc failed!");
+					return -1;
+				}
+			}
+		}
+	}
+#ifdef _DEBUG
+	else
+	{
+		assert(animset);
+	}
+#endif
+
+	// load the file
+	if (!UIPAFtextLoaded || !isHumanoid)
+	{ //rww - We are always using the same animation config now. So only load it once.
+		len = trap_FS_FOpenFile( filename, &f, FS_READ );
+		if ( (len <= 0) || (len >= sizeof( UIPAFtext ) - 1) ) 
+		{
+			if (len > 0)
+			{
+				Com_Error(ERR_DROP, "%s exceeds the allowed ui-side animation buffer!", filename);
+			}
+			return -1;
+		}
+
+		trap_FS_Read( UIPAFtext, len, f );
+		UIPAFtext[len] = 0;
+		trap_FS_FCloseFile( f );
+	}
+	else
+	{
+		return 0; //humanoid index
+	}
+
+	// parse the text
+	text_p = UIPAFtext;
+	skip = 0;	// quiet the compiler warning
+
+	//FIXME: have some way of playing anims backwards... negative numFrames?
+
+	//initialize anim array so that from 0 to MAX_ANIMATIONS, set default values of 0 1 0 100
+	for(i = 0; i < MAX_ANIMATIONS; i++)
+	{
+		animset[i].firstFrame = 0;
+		animset[i].numFrames = 0;
+		animset[i].loopFrames = -1;
+		animset[i].frameLerp = 100;
+//		animset[i].initialLerp = 100;
+	}
+
+	// read information for each frame
+	while(1) 
+	{
+		token = COM_Parse( (const char **)(&text_p) );
+
+		if ( !token || !token[0]) 
+		{
+			break;
+		}
+
+		animNum = GetIDForString(animTable, token);
+		if(animNum == -1)
+		{
+//#ifndef FINAL_BUILD
+#ifdef _DEBUG
+			//Com_Printf(S_COLOR_RED"WARNING: Unknown token %s in %s\n", token, filename);
+#endif
+			continue;
+		}
+
+		token = COM_Parse( (const char **)(&text_p) );
+		if ( !token ) 
+		{
+			break;
+		}
+		animset[animNum].firstFrame = atoi( token );
+
+		token = COM_Parse( (const char **)(&text_p) );
+		if ( !token ) 
+		{
+			break;
+		}
+		animset[animNum].numFrames = atoi( token );
+
+		token = COM_Parse( (const char **)(&text_p) );
+		if ( !token ) 
+		{
+			break;
+		}
+		animset[animNum].loopFrames = atoi( token );
+
+		token = COM_Parse( (const char **)(&text_p) );
+		if ( !token ) 
+		{
+			break;
+		}
+		fps = atof( token );
+		if ( fps == 0 ) 
+		{
+			fps = 1;//Don't allow divide by zero error
+		}
+		if ( fps < 0 )
+		{//backwards
+			animset[animNum].frameLerp = floor(1000.0f / fps);
+		}
+		else
+		{
+			animset[animNum].frameLerp = ceil(1000.0f / fps);
+		}
+
+//		animset[animNum].initialLerp = ceil(1000.0f / fabs(fps));
+	}
+
+#ifdef _DEBUG
+	//Check the array, and print the ones that have nothing in them.
+	/*
+	for(i = 0; i < MAX_ANIMATIONS; i++)
+	{	
+		if (animTable[i].name != NULL)		// This animation reference exists.
+		{
+			if (animset[i].firstFrame <= 0 && animset[i].numFrames <=0)
+			{	// This is an empty animation reference.
+				Com_Printf("***ANIMTABLE reference #%d (%s) is empty!\n", i, animTable[i].name);
+			}
+		}
+	}
+	*/
+#endif // _DEBUG
+
+	if (isHumanoid)
+	{
+		bgAllAnims[0].anims = animset;
+		strcpy(bgAllAnims[0].filename, filename);
+		UIPAFtextLoaded = qtrue;
+
+		usedIndex = 0;
+	}
+	else
+	{
+		bgAllAnims[nextIndex].anims = animset;
+		strcpy(bgAllAnims[nextIndex].filename, filename);
+
+		usedIndex = nextIndex;
+
+		if (nextIndex)
+		{ //don't bother increasing the number if this ended up as a humanoid load.
+			uiNumAllAnims++;
+		}
+		else
+		{
+			UIPAFtextLoaded = qtrue;
+			usedIndex = 0;
+		}
+	}
+
+	return usedIndex;
+}
+
+//menuDef_t *Menus_FindByName(const char *p);
+void Menu_ShowItemByName(menuDef_t *menu, const char *p, qboolean bShow);
+
+#include "../namespace_end.h"
+
+void UpdateForceUsed();
+
+char holdSPString[MAX_STRING_CHARS]={0};
+char holdSPString2[MAX_STRING_CHARS]={0};
+
+uiInfo_t uiInfo;
+
+static void UI_StartServerRefresh(qboolean full);
+static void UI_StopServerRefresh( void );
+static void UI_DoServerRefresh( void );
+static void UI_BuildServerDisplayList(qboolean force);
+static void UI_BuildServerStatus(qboolean force);
+static void UI_BuildFindPlayerList(qboolean force);
+static int QDECL UI_ServersQsortCompare( const void *arg1, const void *arg2 );
+static int UI_MapCountByGameType(qboolean singlePlayer);
+static int UI_HeadCountByColor( void );
+static void UI_ParseGameInfo(const char *teamFile);
+static const char *UI_SelectedMap(int index, int *actual);
+static int UI_GetIndexFromSelection(int actual);
+static void UI_SiegeClassCnt( const int team );
+
+
+int ProcessNewUI( int command, int arg0, int arg1, int arg2, int arg3, int arg4, int arg5, int arg6 );
+int	uiSkinColor=TEAM_FREE;
+int	uiHoldSkinColor=TEAM_FREE;	// Stores the skin color so that in non-team games, the player screen remembers the team you chose, in case you're coming back from the force powers screen.
+
+static const serverFilter_t serverFilters[] = {
+	{"MENUS_ALL", "" },
+	{"MENUS_JEDI_ACADEMY", "" },
+};
+static const int numServerFilters = sizeof(serverFilters) / sizeof(serverFilter_t);
+
+static const char *skillLevels[] = {
+  "SKILL1",//"I Can Win",
+  "SKILL2",//"Bring It On",
+  "SKILL3",//"Hurt Me Plenty",
+  "SKILL4",//"Hardcore",
+  "SKILL5"//"Nightmare"
+};
+static const int numSkillLevels = sizeof(skillLevels) / sizeof(const char*);
+
+
+
+static const char *teamArenaGameTypes[] = {
+	"FFA",
+	"Holocron",
+	"JediMaster",
+	"Duel",
+	"PowerDuel",
+	"SP",
+	"Team FFA",
+	"Siege",
+	"CTF",
+	"CTY",
+	"TeamTournament"
+};
+static int const numTeamArenaGameTypes = sizeof(teamArenaGameTypes) / sizeof(const char*);
+
+
+
+static char* netnames[] = {
+	"???",
+	"UDP",
+	"IPX",
+	NULL
+};
+
+static int gamecodetoui[] = {4,2,3,0,5,1,6};
+static int uitogamecode[] = {4,6,2,3,1,5,7};
+
+const char *UI_GetStringEdString(const char *refSection, const char *refName);
+
+const char *UI_TeamName(int team)  {
+	if (team==TEAM_RED)
+		return "RED";
+	else if (team==TEAM_BLUE)
+		return "BLUE";
+	else if (team==TEAM_SPECTATOR)
+		return "SPECTATOR";
+	return "FREE";
+}
+
+// returns either string or NULL for OOR...
+//
+static const char *GetCRDelineatedString( const char *psStripFileRef, const char *psStripStringRef, int iIndex)
+{
+	static char sTemp[256];
+	const char *psList = UI_GetStringEdString(psStripFileRef, psStripStringRef);
+	char *p;
+
+	while (iIndex--)
+	{
+		psList = strchr(psList,'\n');
+		if (!psList){
+			return NULL;	// OOR
+		}
+		psList++;
+	}
+
+	strcpy(sTemp,psList);
+	p = strchr(sTemp,'\n');
+	if (p) {
+		*p = '\0';
+	}
+
+	return sTemp;
+}
+
+
+static const char *GetMonthAbbrevString( int iMonth )
+{
+	const char *p = GetCRDelineatedString("MP_INGAME","MONTHS", iMonth);
+	
+	return p ? p : "Jan";	// sanity
+}
+
+
+
+
+/*
+static const char *netSources[] = {
+	"Local",
+	"Internet",
+	"Favorites"
+//	"Mplayer"
+};
+static const int numNetSources = sizeof(netSources) / sizeof(const char*);
+*/
+static const int numNetSources = 3;	// now hard-entered in StringEd file
+static const char *GetNetSourceString(int iSource)
+{
+	const char *p = GetCRDelineatedString("MP_INGAME","NET_SOURCES", iSource);
+
+	return p ? p : "??";
+}
+
+
+
+
+void AssetCache() {
+	int n;
+	//if (Assets.textFont == NULL) {
+	//}
+	//Assets.background = trap_R_RegisterShaderNoMip( ASSET_BACKGROUND );
+	//Com_Printf("Menu Size: %i bytes\n", sizeof(Menus));
+	uiInfo.uiDC.Assets.gradientBar = trap_R_RegisterShaderNoMip( ASSET_GRADIENTBAR );
+	uiInfo.uiDC.Assets.fxBasePic = trap_R_RegisterShaderNoMip( ART_FX_BASE );
+	uiInfo.uiDC.Assets.fxPic[0] = trap_R_RegisterShaderNoMip( ART_FX_RED );
+	uiInfo.uiDC.Assets.fxPic[1] = trap_R_RegisterShaderNoMip( ART_FX_ORANGE );//trap_R_RegisterShaderNoMip( ART_FX_YELLOW );
+	uiInfo.uiDC.Assets.fxPic[2] = trap_R_RegisterShaderNoMip( ART_FX_YELLOW );//trap_R_RegisterShaderNoMip( ART_FX_GREEN );
+	uiInfo.uiDC.Assets.fxPic[3] = trap_R_RegisterShaderNoMip( ART_FX_GREEN );//trap_R_RegisterShaderNoMip( ART_FX_TEAL );
+	uiInfo.uiDC.Assets.fxPic[4] = trap_R_RegisterShaderNoMip( ART_FX_BLUE );
+	uiInfo.uiDC.Assets.fxPic[5] = trap_R_RegisterShaderNoMip( ART_FX_PURPLE );//trap_R_RegisterShaderNoMip( ART_FX_CYAN );
+	uiInfo.uiDC.Assets.fxPic[6] = trap_R_RegisterShaderNoMip( ART_FX_WHITE );
+	uiInfo.uiDC.Assets.scrollBar = trap_R_RegisterShaderNoMip( ASSET_SCROLLBAR );
+	uiInfo.uiDC.Assets.scrollBarArrowDown = trap_R_RegisterShaderNoMip( ASSET_SCROLLBAR_ARROWDOWN );
+	uiInfo.uiDC.Assets.scrollBarArrowUp = trap_R_RegisterShaderNoMip( ASSET_SCROLLBAR_ARROWUP );
+	uiInfo.uiDC.Assets.scrollBarArrowLeft = trap_R_RegisterShaderNoMip( ASSET_SCROLLBAR_ARROWLEFT );
+	uiInfo.uiDC.Assets.scrollBarArrowRight = trap_R_RegisterShaderNoMip( ASSET_SCROLLBAR_ARROWRIGHT );
+	uiInfo.uiDC.Assets.scrollBarThumb = trap_R_RegisterShaderNoMip( ASSET_SCROLL_THUMB );
+	uiInfo.uiDC.Assets.sliderBar = trap_R_RegisterShaderNoMip( ASSET_SLIDER_BAR );
+	uiInfo.uiDC.Assets.sliderThumb = trap_R_RegisterShaderNoMip( ASSET_SLIDER_THUMB );
+
+	// Icons for various server settings.
+	uiInfo.uiDC.Assets.needPass = trap_R_RegisterShaderNoMip( "gfx/menus/needpass" );
+	uiInfo.uiDC.Assets.noForce = trap_R_RegisterShaderNoMip( "gfx/menus/noforce" );
+	uiInfo.uiDC.Assets.forceRestrict = trap_R_RegisterShaderNoMip( "gfx/menus/forcerestrict" );
+	uiInfo.uiDC.Assets.saberOnly = trap_R_RegisterShaderNoMip( "gfx/menus/saberonly" );
+	uiInfo.uiDC.Assets.trueJedi = trap_R_RegisterShaderNoMip( "gfx/menus/truejedi" );
+							
+	for( n = 0; n < NUM_CROSSHAIRS; n++ ) {
+		uiInfo.uiDC.Assets.crosshairShader[n] = trap_R_RegisterShaderNoMip( va("gfx/2d/crosshair%c", 'a' + n ) );
+	}
+
+	uiInfo.newHighScoreSound = 0;//trap_S_RegisterSound("sound/feedback/voc_newhighscore.wav");
+}
+
+void _UI_DrawSides(float x, float y, float w, float h, float size) {
+	size *= uiInfo.uiDC.xscale;
+	trap_R_DrawStretchPic( x, y, size, h, 0, 0, 0, 0, uiInfo.uiDC.whiteShader );
+	trap_R_DrawStretchPic( x + w - size, y, size, h, 0, 0, 0, 0, uiInfo.uiDC.whiteShader );
+}
+
+void _UI_DrawTopBottom(float x, float y, float w, float h, float size) {
+	size *= uiInfo.uiDC.yscale;
+	trap_R_DrawStretchPic( x, y, w, size, 0, 0, 0, 0, uiInfo.uiDC.whiteShader );
+	trap_R_DrawStretchPic( x, y + h - size, w, size, 0, 0, 0, 0, uiInfo.uiDC.whiteShader );
+}
+/*
+================
+UI_DrawRect
+
+Coordinates are 640*480 virtual values
+=================
+*/
+void _UI_DrawRect( float x, float y, float width, float height, float size, const float *color ) {
+	trap_R_SetColor( color );
+
+  _UI_DrawTopBottom(x, y, width, height, size);
+  _UI_DrawSides(x, y, width, height, size);
+
+	trap_R_SetColor( NULL );
+}
+
+#include "../namespace_begin.h"
+int MenuFontToHandle(int iMenuFont)
+{
+	switch (iMenuFont)
+	{
+		case 1: return uiInfo.uiDC.Assets.qhSmallFont;
+		case 2: return uiInfo.uiDC.Assets.qhMediumFont;
+		case 3: return uiInfo.uiDC.Assets.qhBigFont;
+		case 4: return uiInfo.uiDC.Assets.qhSmall2Font;
+	}
+
+	return uiInfo.uiDC.Assets.qhMediumFont;	// 0;
+}
+#include "../namespace_end.h"
+
+int Text_Width(const char *text, float scale, int iMenuFont) 
+{	
+	int iFontIndex = MenuFontToHandle(iMenuFont);
+
+	return trap_R_Font_StrLenPixels(text, iFontIndex, scale);
+}
+
+int Text_Height(const char *text, float scale, int iMenuFont) 
+{
+	int iFontIndex = MenuFontToHandle(iMenuFont);
+
+	return trap_R_Font_HeightPixels(iFontIndex, scale);
+}
+
+void Text_Paint(float x, float y, float scale, vec4_t color, const char *text, float adjust, int limit, int style, int iMenuFont)
+{
+	int iStyleOR = 0;
+
+	int iFontIndex = MenuFontToHandle(iMenuFont);
+	//
+	// kludge.. convert JK2 menu styles to SOF2 printstring ctrl codes...
+	//	
+	switch (style)
+	{
+	case  ITEM_TEXTSTYLE_NORMAL:			iStyleOR = 0;break;					// JK2 normal text
+	case  ITEM_TEXTSTYLE_BLINK:				iStyleOR = (int)STYLE_BLINK;break;		// JK2 fast blinking
+	case  ITEM_TEXTSTYLE_PULSE:				iStyleOR = (int)STYLE_BLINK;break;		// JK2 slow pulsing
+	case  ITEM_TEXTSTYLE_SHADOWED:			iStyleOR = (int)STYLE_DROPSHADOW;break;	// JK2 drop shadow
+	case  ITEM_TEXTSTYLE_OUTLINED:			iStyleOR = (int)STYLE_DROPSHADOW;break;	// JK2 drop shadow
+	case  ITEM_TEXTSTYLE_OUTLINESHADOWED:	iStyleOR = (int)STYLE_DROPSHADOW;break;	// JK2 drop shadow
+	case  ITEM_TEXTSTYLE_SHADOWEDMORE:		iStyleOR = (int)STYLE_DROPSHADOW;break;	// JK2 drop shadow
+	}
+
+	trap_R_Font_DrawString(	x,		// int ox
+							y,		// int oy
+							text,	// const char *text
+							color,	// paletteRGBA_c c
+							iStyleOR | iFontIndex,	// const int iFontHandle
+							!limit?-1:limit,		// iCharLimit (-1 = none)
+							scale	// const float scale = 1.0f
+							);
+}
+
+
+void Text_PaintWithCursor(float x, float y, float scale, vec4_t color, const char *text, int cursorPos, char cursor, int limit, int style, int iMenuFont) 
+{
+	Text_Paint(x, y, scale, color, text, 0, limit, style, iMenuFont);
+
+	// now print the cursor as well...  (excuse the braces, it's for porting C++ to C)
+	//
+	{
+		char sTemp[1024];
+		int iCopyCount = limit ? min(strlen(text), limit) : strlen(text);
+			iCopyCount = min(iCopyCount,cursorPos);
+			iCopyCount = min(iCopyCount,sizeof(sTemp));
+
+			// copy text into temp buffer for pixel measure...
+			//			
+			strncpy(sTemp,text,iCopyCount);
+					sTemp[iCopyCount] = '\0';
+
+			{
+				int iFontIndex = MenuFontToHandle( iMenuFont );	
+				int iNextXpos  = trap_R_Font_StrLenPixels(sTemp, iFontIndex, scale );
+
+				Text_Paint(x+iNextXpos, y, scale, color, va("%c",cursor), 0, limit, style|ITEM_TEXTSTYLE_BLINK, iMenuFont);
+			}
+	}
+}
+
+
+// maxX param is initially an X limit, but is also used as feedback. 0 = text was clipped to fit within, else maxX = next pos
+//
+static void Text_Paint_Limit(float *maxX, float x, float y, float scale, vec4_t color, const char* text, float adjust, int limit, int iMenuFont) 
+{
+	// this is kinda dirty, but...
+	//
+	int iFontIndex = MenuFontToHandle(iMenuFont);
+	
+	//float fMax = *maxX;
+	int iPixelLen = trap_R_Font_StrLenPixels(text, iFontIndex, scale);
+	if (x + iPixelLen > *maxX)
+	{
+		// whole text won't fit, so we need to print just the amount that does...
+		//  Ok, this is slow and tacky, but only called occasionally, and it works...
+		//
+		char sTemp[4096]={0};	// lazy assumption
+		const char *psText = text;
+		char *psOut = &sTemp[0];
+		char *psOutLastGood = psOut;
+		unsigned int uiLetter;
+
+		while (*psText && (x + trap_R_Font_StrLenPixels(sTemp, iFontIndex, scale)<=*maxX) 
+			   && psOut < &sTemp[sizeof(sTemp)-1]	// sanity
+				)
+		{
+			int iAdvanceCount;
+			psOutLastGood = psOut;
+			
+			uiLetter = trap_AnyLanguage_ReadCharFromString(psText, &iAdvanceCount, NULL);
+			psText += iAdvanceCount;
+
+			if (uiLetter > 255)
+			{
+				*psOut++ = uiLetter>>8;
+				*psOut++ = uiLetter&0xFF;
+			}
+			else
+			{
+				*psOut++ = uiLetter&0xFF;
+			}
+		}
+		*psOutLastGood = '\0';
+
+		*maxX = 0;	// feedback
+		Text_Paint(x, y, scale, color, sTemp, adjust, limit, ITEM_TEXTSTYLE_NORMAL, iMenuFont);
+	}
+	else
+	{
+		// whole text fits fine, so print it all...
+		//
+		*maxX = x + iPixelLen;	// feedback the next position, as the caller expects		
+		Text_Paint(x, y, scale, color, text, adjust, limit, ITEM_TEXTSTYLE_NORMAL, iMenuFont);
+	}
+}
+
+
+void UI_ShowPostGame(qboolean newHigh) {
+	trap_Cvar_Set ("cg_cameraOrbit", "0");
+	trap_Cvar_Set("cg_thirdPerson", "0");
+	trap_Cvar_Set( "sv_killserver", "1" );
+	uiInfo.soundHighScore = newHigh;
+  _UI_SetActiveMenu(UIMENU_POSTGAME);
+}
+/*
+=================
+_UI_Refresh
+=================
+*/
+
+void UI_DrawCenteredPic(qhandle_t image, int w, int h) {
+  int x, y;
+  x = (SCREEN_WIDTH - w) / 2;
+  y = (SCREEN_HEIGHT - h) / 2;
+  UI_DrawHandlePic(x, y, w, h, image);
+}
+
+int frameCount = 0;
+int startTime;
+
+vmCvar_t	ui_rankChange;
+static void UI_BuildPlayerList();
+char parsedFPMessage[1024];
+
+#include "../namespace_begin.h"
+extern int FPMessageTime;
+#include "../namespace_end.h"
+
+void Text_PaintCenter(float x, float y, float scale, vec4_t color, const char *text, float adjust, int iMenuFont);
+
+const char *UI_GetStringEdString(const char *refSection, const char *refName)
+{
+	static char text[1024]={0};
+
+	trap_SP_GetStringTextString(va("%s_%s", refSection, refName), text, sizeof(text));
+	return text;
+}
+
+#define	UI_FPS_FRAMES	4
+void _UI_Refresh( int realtime )
+{
+	static int index;
+	static int	previousTimes[UI_FPS_FRAMES];
+
+	//if ( !( trap_Key_GetCatcher() & KEYCATCH_UI ) ) {
+	//	return;
+	//}
+
+	trap_G2API_SetTime(realtime, 0);
+	trap_G2API_SetTime(realtime, 1);
+	//ghoul2 timer must be explicitly updated during ui rendering.
+
+	uiInfo.uiDC.frameTime = realtime - uiInfo.uiDC.realTime;
+	uiInfo.uiDC.realTime = realtime;
+
+	previousTimes[index % UI_FPS_FRAMES] = uiInfo.uiDC.frameTime;
+	index++;
+	if ( index > UI_FPS_FRAMES ) {
+		int i, total;
+		// average multiple frames together to smooth changes out a bit
+		total = 0;
+		for ( i = 0 ; i < UI_FPS_FRAMES ; i++ ) {
+			total += previousTimes[i];
+		}
+		if ( !total ) {
+			total = 1;
+		}
+		uiInfo.uiDC.FPS = 1000 * UI_FPS_FRAMES / total;
+	}
+
+
+
+	UI_UpdateCvars();
+
+	if (Menu_Count() > 0) {
+		// paint all the menus
+		Menu_PaintAll();
+		// refresh server browser list
+		UI_DoServerRefresh();
+		// refresh server status
+		UI_BuildServerStatus(qfalse);
+		// refresh find player list
+		UI_BuildFindPlayerList(qfalse);
+	} 
+#ifndef _XBOX	
+	// draw cursor
+	UI_SetColor( NULL );
+	if (Menu_Count() > 0) {
+		UI_DrawHandlePic( uiInfo.uiDC.cursorx, uiInfo.uiDC.cursory, 48, 48, uiInfo.uiDC.Assets.cursor);
+	}
+#endif
+
+#ifndef NDEBUG
+	if (uiInfo.uiDC.debug)
+	{
+		// cursor coordinates
+		//FIXME
+		//UI_DrawString( 0, 0, va("(%d,%d)",uis.cursorx,uis.cursory), UI_LEFT|UI_SMALLFONT, colorRed );
+	}
+#endif
+
+	if (ui_rankChange.integer)
+	{
+		FPMessageTime = realtime + 3000;
+
+		if (!parsedFPMessage[0] /*&& uiMaxRank > ui_rankChange.integer*/)
+		{
+			const char *printMessage = UI_GetStringEdString("MP_INGAME", "SET_NEW_RANK");
+
+			int i = 0;
+			int p = 0;
+			int linecount = 0;
+
+			while (printMessage[i] && p < 1024)
+			{
+				parsedFPMessage[p] = printMessage[i];
+				p++;
+				i++;
+				linecount++;
+
+				if (linecount > 64 && printMessage[i] == ' ')
+				{
+					parsedFPMessage[p] = '\n';
+					p++;
+					linecount = 0;
+				}
+			}
+			parsedFPMessage[p] = '\0';
+		}
+
+		//if (uiMaxRank > ui_rankChange.integer)
+		{
+			uiMaxRank = ui_rankChange.integer;
+			uiForceRank = uiMaxRank;
+
+			/*
+			while (x < NUM_FORCE_POWERS)
+			{
+				//For now just go ahead and clear force powers upon rank change
+				uiForcePowersRank[x] = 0;
+				x++;
+			}
+			uiForcePowersRank[FP_LEVITATION] = 1;
+			uiForceUsed = 0;
+			*/
+
+			//Use BG_LegalizedForcePowers and transfer the result into the UI force settings
+			UI_ReadLegalForce();
+		}
+
+		if (ui_freeSaber.integer && uiForcePowersRank[FP_SABER_OFFENSE] < 1)
+		{
+			uiForcePowersRank[FP_SABER_OFFENSE] = 1;
+		}
+		if (ui_freeSaber.integer && uiForcePowersRank[FP_SABER_DEFENSE] < 1)
+		{
+			uiForcePowersRank[FP_SABER_DEFENSE] = 1;
+		}
+		trap_Cvar_Set("ui_rankChange", "0");
+
+		//remember to update the force power count after changing the max rank
+		UpdateForceUsed();
+	}
+
+	if (ui_freeSaber.integer)
+	{
+		bgForcePowerCost[FP_SABER_OFFENSE][FORCE_LEVEL_1] = 0;
+		bgForcePowerCost[FP_SABER_DEFENSE][FORCE_LEVEL_1] = 0;
+	}
+	else
+	{
+		bgForcePowerCost[FP_SABER_OFFENSE][FORCE_LEVEL_1] = 1;
+		bgForcePowerCost[FP_SABER_DEFENSE][FORCE_LEVEL_1] = 1;
+	}
+
+	/*
+	if (parsedFPMessage[0] && FPMessageTime > realtime)
+	{
+		vec4_t txtCol;
+		int txtStyle = ITEM_TEXTSTYLE_SHADOWED;
+
+		if ((FPMessageTime - realtime) < 2000)
+		{
+			txtCol[0] = colorWhite[0];
+			txtCol[1] = colorWhite[1];
+			txtCol[2] = colorWhite[2];
+			txtCol[3] = (((float)FPMessageTime - (float)realtime)/2000);
+
+			txtStyle = 0;
+		}
+		else
+		{
+			txtCol[0] = colorWhite[0];
+			txtCol[1] = colorWhite[1];
+			txtCol[2] = colorWhite[2];
+			txtCol[3] = colorWhite[3];
+		}
+
+		Text_Paint(10, 0, 1, txtCol, parsedFPMessage, 0, 1024, txtStyle, FONT_MEDIUM);
+	}
+	*/
+	//For now, don't bother.
+}
+
+/*
+=================
+_UI_Shutdown
+=================
+*/
+#include "../namespace_begin.h"
+void UI_CleanupGhoul2(void);
+#include "../namespace_end.h"
+
+void _UI_Shutdown( void ) {
+	trap_LAN_SaveCachedServers();
+	UI_CleanupGhoul2();
+}
+
+char *defaultMenu = NULL;
+
+char *GetMenuBuffer(const char *filename) {
+	int	len;
+	fileHandle_t	f;
+	static char buf[MAX_MENUFILE];
+
+	len = trap_FS_FOpenFile( filename, &f, FS_READ );
+	if ( !f ) {
+		trap_Print( va( S_COLOR_RED "menu file not found: %s, using default\n", filename ) );
+		return defaultMenu;
+	}
+	if ( len >= MAX_MENUFILE ) {
+		trap_Print( va( S_COLOR_RED "menu file too large: %s is %i, max allowed is %i", filename, len, MAX_MENUFILE ) );
+		trap_FS_FCloseFile( f );
+		return defaultMenu;
+	}
+
+	trap_FS_Read( buf, len, f );
+	buf[len] = 0;
+	trap_FS_FCloseFile( f );
+	//COM_Compress(buf);
+  return buf;
+
+}
+
+qboolean Asset_Parse(int handle) {
+	pc_token_t token;
+
+	if (!trap_PC_ReadToken(handle, &token))
+		return qfalse;
+	if (Q_stricmp(token.string, "{") != 0) {
+		return qfalse;
+	}
+    
+	while ( 1 ) {
+
+		memset(&token, 0, sizeof(pc_token_t));
+
+		if (!trap_PC_ReadToken(handle, &token))
+			return qfalse;
+
+		if (Q_stricmp(token.string, "}") == 0) {
+			return qtrue;
+		}
+
+		// font
+		if (Q_stricmp(token.string, "font") == 0) {
+			int pointSize;
+			if (!trap_PC_ReadToken(handle, &token) || !PC_Int_Parse(handle,&pointSize)) {
+				return qfalse;
+			}			
+			//trap_R_RegisterFont(tempStr, pointSize, &uiInfo.uiDC.Assets.textFont);
+			uiInfo.uiDC.Assets.qhMediumFont = trap_R_RegisterFont(token.string);
+			uiInfo.uiDC.Assets.fontRegistered = qtrue;
+			continue;
+		}
+
+		if (Q_stricmp(token.string, "smallFont") == 0) {
+			int pointSize;
+			if (!trap_PC_ReadToken(handle, &token) || !PC_Int_Parse(handle,&pointSize)) {
+				return qfalse;
+			}
+			//trap_R_RegisterFont(token, pointSize, &uiInfo.uiDC.Assets.smallFont);
+			uiInfo.uiDC.Assets.qhSmallFont = trap_R_RegisterFont(token.string);
+			continue;
+		}
+
+		if (Q_stricmp(token.string, "small2Font") == 0) {
+			int pointSize;
+			if (!trap_PC_ReadToken(handle, &token) || !PC_Int_Parse(handle,&pointSize)) {
+				return qfalse;
+			}
+			//trap_R_RegisterFont(token, pointSize, &uiInfo.uiDC.Assets.smallFont);
+			uiInfo.uiDC.Assets.qhSmall2Font = trap_R_RegisterFont(token.string);
+			continue;
+		}
+
+		if (Q_stricmp(token.string, "bigFont") == 0) {
+			int pointSize;
+			if (!trap_PC_ReadToken(handle, &token) || !PC_Int_Parse(handle,&pointSize)) {
+				return qfalse;
+			}
+			//trap_R_RegisterFont(token, pointSize, &uiInfo.uiDC.Assets.bigFont);
+			uiInfo.uiDC.Assets.qhBigFont = trap_R_RegisterFont(token.string);
+			continue;
+		}
+
+		if (Q_stricmp(token.string, "cursor") == 0) 
+		{
+			if (!PC_String_Parse(handle, &uiInfo.uiDC.Assets.cursorStr))
+			{
+				Com_Printf(S_COLOR_YELLOW,"Bad 1st parameter for keyword 'cursor'");
+				return qfalse;
+			}
+			uiInfo.uiDC.Assets.cursor = trap_R_RegisterShaderNoMip( uiInfo.uiDC.Assets.cursorStr);
+			continue;
+		}
+
+		// gradientbar
+		if (Q_stricmp(token.string, "gradientbar") == 0) {
+			if (!trap_PC_ReadToken(handle, &token)) {
+				return qfalse;
+			}
+			uiInfo.uiDC.Assets.gradientBar = trap_R_RegisterShaderNoMip(token.string);
+			continue;
+		}
+
+		// enterMenuSound
+		if (Q_stricmp(token.string, "menuEnterSound") == 0) {
+			if (!trap_PC_ReadToken(handle, &token)) {
+				return qfalse;
+			}
+			uiInfo.uiDC.Assets.menuEnterSound = trap_S_RegisterSound( token.string );
+			continue;
+		}
+
+		// exitMenuSound
+		if (Q_stricmp(token.string, "menuExitSound") == 0) {
+			if (!trap_PC_ReadToken(handle, &token)) {
+				return qfalse;
+			}
+			uiInfo.uiDC.Assets.menuExitSound = trap_S_RegisterSound( token.string );
+			continue;
+		}
+
+		// itemFocusSound
+		if (Q_stricmp(token.string, "itemFocusSound") == 0) {
+			if (!trap_PC_ReadToken(handle, &token)) {
+				return qfalse;
+			}
+			uiInfo.uiDC.Assets.itemFocusSound = trap_S_RegisterSound( token.string );
+			continue;
+		}
+
+		// menuBuzzSound
+		if (Q_stricmp(token.string, "menuBuzzSound") == 0) {
+			if (!trap_PC_ReadToken(handle, &token)) {
+				return qfalse;
+			}
+			uiInfo.uiDC.Assets.menuBuzzSound = trap_S_RegisterSound( token.string );
+			continue;
+		}
+
+		if (Q_stricmp(token.string, "fadeClamp") == 0) {
+			if (!PC_Float_Parse(handle, &uiInfo.uiDC.Assets.fadeClamp)) {
+				return qfalse;
+			}
+			continue;
+		}
+
+		if (Q_stricmp(token.string, "fadeCycle") == 0) {
+			if (!PC_Int_Parse(handle, &uiInfo.uiDC.Assets.fadeCycle)) {
+				return qfalse;
+			}
+			continue;
+		}
+
+		if (Q_stricmp(token.string, "fadeAmount") == 0) {
+			if (!PC_Float_Parse(handle, &uiInfo.uiDC.Assets.fadeAmount)) {
+				return qfalse;
+			}
+			continue;
+		}
+
+		if (Q_stricmp(token.string, "shadowX") == 0) {
+			if (!PC_Float_Parse(handle, &uiInfo.uiDC.Assets.shadowX)) {
+				return qfalse;
+			}
+			continue;
+		}
+
+		if (Q_stricmp(token.string, "shadowY") == 0) {
+			if (!PC_Float_Parse(handle, &uiInfo.uiDC.Assets.shadowY)) {
+				return qfalse;
+			}
+			continue;
+		}
+
+		if (Q_stricmp(token.string, "shadowColor") == 0) {
+			if (!PC_Color_Parse(handle, &uiInfo.uiDC.Assets.shadowColor)) {
+				return qfalse;
+			}
+			uiInfo.uiDC.Assets.shadowFadeClamp = uiInfo.uiDC.Assets.shadowColor[3];
+			continue;
+		}
+
+		if (Q_stricmp(token.string, "moveRollSound") == 0) 
+		{
+			if (trap_PC_ReadToken(handle,&token))
+			{
+				uiInfo.uiDC.Assets.moveRollSound = trap_S_RegisterSound( token.string );
+			}
+			continue;
+		}
+
+		if (Q_stricmp(token.string, "moveJumpSound") == 0) 
+		{
+			if (trap_PC_ReadToken(handle,&token))
+			{
+				uiInfo.uiDC.Assets.moveJumpSound = trap_S_RegisterSound( token.string );
+			}
+
+			continue;
+		}
+		if (Q_stricmp(token.string, "datapadmoveSaberSound1") == 0) 
+		{
+			if (trap_PC_ReadToken(handle,&token))
+			{
+				uiInfo.uiDC.Assets.datapadmoveSaberSound1 = trap_S_RegisterSound( token.string );
+			}
+
+			continue;
+		}
+
+		if (Q_stricmp(token.string, "datapadmoveSaberSound2") == 0) 
+		{
+			if (trap_PC_ReadToken(handle,&token))
+			{
+				uiInfo.uiDC.Assets.datapadmoveSaberSound2 = trap_S_RegisterSound( token.string );
+			}
+
+			continue;
+		}
+
+		if (Q_stricmp(token.string, "datapadmoveSaberSound3") == 0) 
+		{
+			if (trap_PC_ReadToken(handle,&token))
+			{
+				uiInfo.uiDC.Assets.datapadmoveSaberSound3 = trap_S_RegisterSound( token.string );
+			}
+
+			continue;
+		}
+
+		if (Q_stricmp(token.string, "datapadmoveSaberSound4") == 0) 
+		{
+			if (trap_PC_ReadToken(handle,&token))
+			{
+				uiInfo.uiDC.Assets.datapadmoveSaberSound4 = trap_S_RegisterSound( token.string );
+			}
+
+			continue;
+		}
+
+		if (Q_stricmp(token.string, "datapadmoveSaberSound5") == 0) 
+		{
+			if (trap_PC_ReadToken(handle,&token))
+			{
+				uiInfo.uiDC.Assets.datapadmoveSaberSound5 = trap_S_RegisterSound( token.string );
+			}
+
+			continue;
+		}
+
+		if (Q_stricmp(token.string, "datapadmoveSaberSound6") == 0) 
+		{
+			if (trap_PC_ReadToken(handle,&token))
+			{
+				uiInfo.uiDC.Assets.datapadmoveSaberSound6 = trap_S_RegisterSound( token.string );
+			}
+
+			continue;
+		}
+
+
+		// precaching various sound files used in the menus
+		if (Q_stricmp(token.string, "precacheSound") == 0)
+		{
+			const char *tempStr;
+			if (PC_Script_Parse(handle, &tempStr)) 
+			{
+				char *soundFile;
+				do
+				{
+					soundFile = COM_ParseExt(&tempStr, qfalse);	
+					if (soundFile[0] != 0 && soundFile[0] != ';') {
+						trap_S_RegisterSound( soundFile);
+					}
+				} while (soundFile[0]);
+			}
+			continue;
+		}
+	}
+	return qfalse;
+}
+
+
+void UI_Report() {
+  String_Report();
+  //Font_Report();
+
+}
+
+void UI_ParseMenu(const char *menuFile) {
+	int handle;
+	pc_token_t token;
+
+	//Com_Printf("Parsing menu file: %s\n", menuFile);
+
+	handle = trap_PC_LoadSource(menuFile);
+	if (!handle) {
+		return;
+	}
+
+	while ( 1 ) {
+		memset(&token, 0, sizeof(pc_token_t));
+		if (!trap_PC_ReadToken( handle, &token )) {
+			break;
+		}
+
+		//if ( Q_stricmp( token, "{" ) ) {
+		//	Com_Printf( "Missing { in menu file\n" );
+		//	break;
+		//}
+
+		//if ( menuCount == MAX_MENUS ) {
+		//	Com_Printf( "Too many menus!\n" );
+		//	break;
+		//}
+
+		if ( token.string[0] == '}' ) {
+			break;
+		}
+
+		if (Q_stricmp(token.string, "assetGlobalDef") == 0) {
+			if (Asset_Parse(handle)) {
+				continue;
+			} else {
+				break;
+			}
+		}
+
+		if (Q_stricmp(token.string, "menudef") == 0) {
+			// start a new menu
+			Menu_New(handle);
+		}
+	}
+	trap_PC_FreeSource(handle);
+}
+
+qboolean Load_Menu(int handle) {
+	pc_token_t token;
+
+	if (!trap_PC_ReadToken(handle, &token))
+		return qfalse;
+	if (token.string[0] != '{') {
+		return qfalse;
+	}
+
+	while ( 1 ) {
+
+		if (!trap_PC_ReadToken(handle, &token))
+			return qfalse;
+    
+		if ( token.string[0] == 0 ) {
+			return qfalse;
+		}
+
+		if ( token.string[0] == '}' ) {
+			return qtrue;
+		}
+
+		UI_ParseMenu(token.string); 
+	}
+	return qfalse;
+}
+
+void UI_LoadMenus(const char *menuFile, qboolean reset) {
+	pc_token_t token;
+	int handle;
+	int start;
+
+	start = trap_Milliseconds();
+
+	trap_PC_LoadGlobalDefines ( "ui/jamp/menudef.h" );
+
+	handle = trap_PC_LoadSource( menuFile );
+	if (!handle) {
+		Com_Printf( S_COLOR_YELLOW "menu file not found: %s, using default\n", menuFile );
+		handle = trap_PC_LoadSource( "ui/jampmenus.txt" );
+		if (!handle) {
+			trap_Error( va( S_COLOR_RED "default menu file not found: ui/menus.txt, unable to continue!\n", menuFile ) );
+		}
+	}
+
+	if (reset) {
+		Menu_Reset();
+	}
+
+	while ( 1 ) {
+		if (!trap_PC_ReadToken(handle, &token))
+			break;
+		if( token.string[0] == 0 || token.string[0] == '}') {
+			break;
+		}
+
+		if ( token.string[0] == '}' ) {
+			break;
+		}
+
+		if (Q_stricmp(token.string, "loadmenu") == 0) {
+			if (Load_Menu(handle)) {
+				continue;
+			} else {
+				break;
+			}
+		}
+	}
+
+//	Com_Printf("UI menu load time = %d milli seconds\n", trap_Milliseconds() - start);
+
+	trap_PC_FreeSource( handle );
+
+	trap_PC_RemoveAllGlobalDefines ( );
+}
+
+void UI_Load() {
+	char *menuSet;
+	char lastName[1024];
+	menuDef_t *menu = Menu_GetFocused();
+
+	if (menu && menu->window.name) {
+		strcpy(lastName, menu->window.name);
+	}
+	else
+	{
+		lastName[0] = 0;
+	}
+
+	if (uiInfo.inGameLoad)
+	{
+		menuSet= "ui/jampingame.txt";
+	}
+	else
+	{
+		menuSet= UI_Cvar_VariableString("ui_menuFilesMP");
+	}
+	if (menuSet == NULL || menuSet[0] == '\0') {
+		menuSet = "ui/jampmenus.txt";
+	}
+
+	String_Init();
+
+#ifdef PRE_RELEASE_TADEMO
+	UI_ParseGameInfo("demogameinfo.txt");
+#else
+	UI_ParseGameInfo("ui/jamp/gameinfo.txt");
+#endif
+	UI_LoadArenas();
+	UI_LoadBots();
+
+	UI_LoadMenus(menuSet, qtrue);
+	Menus_CloseAll();
+	Menus_ActivateByName(lastName);
+
+}
+
+static const char *handicapValues[] = {"None","95","90","85","80","75","70","65","60","55","50","45","40","35","30","25","20","15","10","5",NULL};
+
+static void UI_DrawHandicap(rectDef_t *rect, float scale, vec4_t color, int textStyle, int iMenuFont) {
+  int i, h;
+
+  h = Com_Clamp( 5, 100, trap_Cvar_VariableValue("handicap") );
+  i = 20 - h / 5;
+
+  Text_Paint(rect->x, rect->y, scale, color, handicapValues[i], 0, 0, textStyle, iMenuFont);
+}
+
+static void UI_DrawClanName(rectDef_t *rect, float scale, vec4_t color, int textStyle, int iMenuFont) {
+  Text_Paint(rect->x, rect->y, scale, color, UI_Cvar_VariableString("ui_teamName"), 0, 0, textStyle, iMenuFont);
+}
+
+
+static void UI_SetCapFragLimits(qboolean uiVars) {
+	int cap = 5;
+	int frag = 10;
+
+	if (uiVars) {
+		trap_Cvar_Set("ui_captureLimit", va("%d", cap));
+		trap_Cvar_Set("ui_fragLimit", va("%d", frag));
+	} else {
+		trap_Cvar_Set("capturelimit", va("%d", cap));
+		trap_Cvar_Set("fraglimit", va("%d", frag));
+	}
+}
+
+static const char* UI_GetGameTypeName(int gtEnum)
+{
+	switch ( gtEnum ) 
+	{
+	case GT_FFA:
+		return UI_GetStringEdString("MENUS", "FREE_FOR_ALL");//"Free For All";
+	case GT_HOLOCRON:
+		return UI_GetStringEdString("MENUS", "HOLOCRON_FFA");//"Holocron FFA";
+	case GT_JEDIMASTER:
+		return UI_GetStringEdString("MENUS", "SAGA");//"Jedi Master";??
+	case GT_SINGLE_PLAYER:
+		return UI_GetStringEdString("MENUS", "SAGA");//"Team FFA";
+	case GT_DUEL:
+		return UI_GetStringEdString("MENUS", "DUEL");//"Team FFA";
+	case GT_POWERDUEL:
+		return UI_GetStringEdString("MENUS", "POWERDUEL");//"Team FFA";
+	case GT_TEAM:
+		return UI_GetStringEdString("MENUS", "TEAM_FFA");//"Team FFA";
+	case GT_SIEGE:
+		return UI_GetStringEdString("MENUS", "SIEGE");//"Siege";
+	case GT_CTF:
+		return UI_GetStringEdString("MENUS", "CAPTURE_THE_FLAG");//"Capture the Flag";
+	case GT_CTY:
+		return UI_GetStringEdString("MENUS", "CAPTURE_THE_YSALIMARI");//"Capture the Ysalamiri";
+	}
+	return UI_GetStringEdString("MENUS", "SAGA");//"Team FFA";
+}
+
+
+
+// ui_gameType assumes gametype 0 is -1 ALL and will not show
+static void UI_DrawGameType(rectDef_t *rect, float scale, vec4_t color, int textStyle, int iMenuFont) 
+{
+  Text_Paint(rect->x, rect->y, scale, color, UI_GetGameTypeName(uiInfo.gameTypes[ui_gameType.integer].gtEnum), 0, 0, textStyle, iMenuFont);
+}
+
+static void UI_DrawNetGameType(rectDef_t *rect, float scale, vec4_t color, int textStyle, int iMenuFont) 
+{
+	if (ui_netGameType.integer < 0 || ui_netGameType.integer >= uiInfo.numGameTypes) 
+	{
+		trap_Cvar_Set("ui_netGameType", "0");
+		trap_Cvar_Set("ui_actualNetGameType", "0");
+	}
+	Text_Paint(rect->x, rect->y, scale, color, UI_GetGameTypeName(uiInfo.gameTypes[ui_netGameType.integer].gtEnum) , 0, 0, textStyle, iMenuFont);
+}
+
+static void UI_DrawAutoSwitch(rectDef_t *rect, float scale, vec4_t color, int textStyle, int iMenuFont) {
+	int switchVal = trap_Cvar_VariableValue("cg_autoswitch");
+	const char *switchString = "AUTOSWITCH1";
+	const char *stripString = NULL;
+
+	switch(switchVal)
+	{
+	case 2:
+		switchString = "AUTOSWITCH2";
+		break;
+	case 3:
+		switchString = "AUTOSWITCH3";
+		break;
+	case 0:
+		switchString = "AUTOSWITCH0";
+		break;
+	default:
+		break;
+	}
+
+	stripString = UI_GetStringEdString("MP_INGAME", (char *)switchString);
+
+	if (stripString)
+	{
+		Text_Paint(rect->x, rect->y, scale, color, stripString, 0, 0, textStyle, iMenuFont);
+	}
+}
+
+static void UI_DrawJoinGameType(rectDef_t *rect, float scale, vec4_t color, int textStyle, int iMenuFont) 
+{
+	if (ui_joinGameType.integer < 0 || ui_joinGameType.integer > uiInfo.numJoinGameTypes) 
+	{
+		trap_Cvar_Set("ui_joinGameType", "0");
+	}
+
+	Text_Paint(rect->x, rect->y, scale, color, UI_GetGameTypeName(uiInfo.joinGameTypes[ui_joinGameType.integer].gtEnum) , 0, 0, textStyle, iMenuFont);
+}
+
+
+
+static int UI_TeamIndexFromName(const char *name) {
+  int i;
+
+  if (name && *name) {
+    for (i = 0; i < uiInfo.teamCount; i++) {
+      if (Q_stricmp(name, uiInfo.teamList[i].teamName) == 0) {
+        return i;
+      }
+    }
+  } 
+
+  return 0;
+
+}
+
+static void UI_DrawClanLogo(rectDef_t *rect, float scale, vec4_t color) {
+  int i;
+  i = UI_TeamIndexFromName(UI_Cvar_VariableString("ui_teamName"));
+  if (i >= 0 && i < uiInfo.teamCount) {
+  	trap_R_SetColor( color );
+
+		if (uiInfo.teamList[i].teamIcon == -1) {
+      uiInfo.teamList[i].teamIcon = trap_R_RegisterShaderNoMip(uiInfo.teamList[i].imageName);
+      uiInfo.teamList[i].teamIcon_Metal = trap_R_RegisterShaderNoMip(va("%s_metal",uiInfo.teamList[i].imageName));
+      uiInfo.teamList[i].teamIcon_Name = trap_R_RegisterShaderNoMip(va("%s_name", uiInfo.teamList[i].imageName));
+		}
+
+  	UI_DrawHandlePic( rect->x, rect->y, rect->w, rect->h, uiInfo.teamList[i].teamIcon);
+    trap_R_SetColor(NULL);
+  }
+}
+
+static void UI_DrawClanCinematic(rectDef_t *rect, float scale, vec4_t color) {
+  int i;
+  i = UI_TeamIndexFromName(UI_Cvar_VariableString("ui_teamName"));
+  if (i >= 0 && i < uiInfo.teamCount) {
+
+		if (uiInfo.teamList[i].cinematic >= -2) {
+			if (uiInfo.teamList[i].cinematic == -1) {
+				uiInfo.teamList[i].cinematic = trap_CIN_PlayCinematic(va("%s.roq", uiInfo.teamList[i].imageName), 0, 0, 0, 0, (CIN_loop | CIN_silent) );
+			}
+			if (uiInfo.teamList[i].cinematic >= 0) {
+			  trap_CIN_RunCinematic(uiInfo.teamList[i].cinematic);
+				trap_CIN_SetExtents(uiInfo.teamList[i].cinematic, rect->x, rect->y, rect->w, rect->h);
+	 			trap_CIN_DrawCinematic(uiInfo.teamList[i].cinematic);
+			} else {
+			  	trap_R_SetColor( color );
+				UI_DrawHandlePic( rect->x, rect->y, rect->w, rect->h, uiInfo.teamList[i].teamIcon_Metal);
+				trap_R_SetColor(NULL);
+				uiInfo.teamList[i].cinematic = -2;
+			}
+		} else {
+	  	trap_R_SetColor( color );
+			UI_DrawHandlePic( rect->x, rect->y, rect->w, rect->h, uiInfo.teamList[i].teamIcon);
+			trap_R_SetColor(NULL);
+		}
+	}
+
+}
+
+static void UI_DrawPreviewCinematic(rectDef_t *rect, float scale, vec4_t color) {
+	if (uiInfo.previewMovie > -2) {
+		uiInfo.previewMovie = trap_CIN_PlayCinematic(va("%s.roq", uiInfo.movieList[uiInfo.movieIndex]), 0, 0, 0, 0, (CIN_loop | CIN_silent) );
+		if (uiInfo.previewMovie >= 0) {
+		  trap_CIN_RunCinematic(uiInfo.previewMovie);
+			trap_CIN_SetExtents(uiInfo.previewMovie, rect->x, rect->y, rect->w, rect->h);
+ 			trap_CIN_DrawCinematic(uiInfo.previewMovie);
+		} else {
+			uiInfo.previewMovie = -2;
+		}
+	} 
+
+}
+
+static void UI_DrawSkill(rectDef_t *rect, float scale, vec4_t color, int textStyle, int iMenuFont) {
+  int i;
+	i = trap_Cvar_VariableValue( "g_spSkill" );
+  if (i < 1 || i > numSkillLevels) {
+    i = 1;
+  }
+  Text_Paint(rect->x, rect->y, scale, color, (char *)UI_GetStringEdString("MP_INGAME", (char *)skillLevels[i-1]),0, 0, textStyle, iMenuFont);
+}
+
+
+static void UI_DrawGenericNum(rectDef_t *rect, float scale, vec4_t color, int textStyle, int val, int min, int max, int type,int iMenuFont) 
+{
+	int i;
+	char s[256];
+
+	i = val;
+	if (i < min || i > max) 
+	{
+		i = min;
+	}
+
+	Com_sprintf(s, sizeof(s), "%i\0", val);
+	Text_Paint(rect->x, rect->y, scale, color, s,0, 0, textStyle, iMenuFont);
+}
+
+static void UI_DrawForceMastery(rectDef_t *rect, float scale, vec4_t color, int textStyle, int val, int min, int max, int iMenuFont)
+{
+	int i;
+	char *s;
+
+	i = val;
+	if (i < min || i > max) 
+	{
+		i = min;
+	}
+
+	s = (char *)UI_GetStringEdString("MP_INGAME", forceMasteryLevels[val]);
+	Text_Paint(rect->x, rect->y, scale, color, s, 0, 0, textStyle, iMenuFont);
+}
+
+
+static void UI_DrawSkinColor(rectDef_t *rect, float scale, vec4_t color, int textStyle, int val, int min, int max, int iMenuFont)
+{
+	int i;
+	char s[256];
+
+	i = val;
+	if (i < min || i > max) 
+	{
+		i = min;
+	}
+
+	switch(val)
+	{
+	case TEAM_RED:
+		trap_SP_GetStringTextString("MENUS_TEAM_RED", s, sizeof(s));
+//		Com_sprintf(s, sizeof(s), "Red\0");
+		break;
+	case TEAM_BLUE:
+		trap_SP_GetStringTextString("MENUS_TEAM_BLUE", s, sizeof(s));
+//		Com_sprintf(s, sizeof(s), "Blue\0");
+		break;
+	default:
+		trap_SP_GetStringTextString("MENUS_DEFAULT", s, sizeof(s));
+//		Com_sprintf(s, sizeof(s), "Default\0");
+		break;
+	}
+
+	Text_Paint(rect->x, rect->y, scale, color, s, 0, 0, textStyle, iMenuFont);
+}
+
+static void UI_DrawForceSide(rectDef_t *rect, float scale, vec4_t color, int textStyle, int val, int min, int max, int iMenuFont)
+{
+	int i;
+	char s[256];
+	menuDef_t *menu;
+	
+	char info[MAX_INFO_VALUE];
+
+	i = val;
+	if (i < min || i > max) 
+	{
+		i = min;
+	}
+
+	info[0] = '\0';
+	trap_GetConfigString(CS_SERVERINFO, info, sizeof(info));
+
+	if (atoi( Info_ValueForKey( info, "g_forceBasedTeams" ) ))
+	{
+		switch((int)(trap_Cvar_VariableValue("ui_myteam")))
+		{
+		case TEAM_RED:
+			uiForceSide = FORCE_DARKSIDE;
+			color[0] = 0.2;
+			color[1] = 0.2;
+			color[2] = 0.2;
+			break;
+		case TEAM_BLUE:
+			uiForceSide = FORCE_LIGHTSIDE;
+			color[0] = 0.2;
+			color[1] = 0.2;
+			color[2] = 0.2;
+			break;
+		default:
+			break;
+		}
+	}
+
+	if (val == FORCE_LIGHTSIDE)
+	{
+		trap_SP_GetStringTextString("MENUS_FORCEDESC_LIGHT",s, sizeof(s));
+		menu = Menus_FindByName("forcealloc");
+		if (menu)
+		{
+			Menu_ShowItemByName(menu, "lightpowers", qtrue);
+			Menu_ShowItemByName(menu, "darkpowers", qfalse);
+			Menu_ShowItemByName(menu, "darkpowers_team", qfalse);
+
+			Menu_ShowItemByName(menu, "lightpowers_team", qtrue);//(ui_gameType.integer >= GT_TEAM));
+
+		}
+		menu = Menus_FindByName("ingame_playerforce");
+		if (menu)
+		{
+			Menu_ShowItemByName(menu, "lightpowers", qtrue);
+			Menu_ShowItemByName(menu, "darkpowers", qfalse);
+			Menu_ShowItemByName(menu, "darkpowers_team", qfalse);
+
+			Menu_ShowItemByName(menu, "lightpowers_team", qtrue);//(ui_gameType.integer >= GT_TEAM));
+		}
+	}
+	else
+	{
+		trap_SP_GetStringTextString("MENUS_FORCEDESC_DARK",s, sizeof(s));
+		menu = Menus_FindByName("forcealloc");
+		if (menu)
+		{
+			Menu_ShowItemByName(menu, "lightpowers", qfalse);
+			Menu_ShowItemByName(menu, "lightpowers_team", qfalse);
+			Menu_ShowItemByName(menu, "darkpowers", qtrue);
+
+			Menu_ShowItemByName(menu, "darkpowers_team", qtrue);//(ui_gameType.integer >= GT_TEAM));
+		}
+		menu = Menus_FindByName("ingame_playerforce");
+		if (menu)
+		{
+			Menu_ShowItemByName(menu, "lightpowers", qfalse);
+			Menu_ShowItemByName(menu, "lightpowers_team", qfalse);
+			Menu_ShowItemByName(menu, "darkpowers", qtrue);
+
+			Menu_ShowItemByName(menu, "darkpowers_team", qtrue);//(ui_gameType.integer >= GT_TEAM));
+		}
+	}
+
+	Text_Paint(rect->x, rect->y, scale, color, s,0, 0, textStyle, iMenuFont);
+}
+
+qboolean UI_HasSetSaberOnly( void )
+{
+	char	info[MAX_INFO_STRING];
+	int i = 0;
+	int wDisable = 0;
+	int	gametype = 0;
+
+	gametype = atoi(Info_ValueForKey(info, "g_gametype"));
+
+	if ( gametype == GT_JEDIMASTER )
+	{ //set to 0 
+		return qfalse;
+	}
+
+	trap_GetConfigString( CS_SERVERINFO, info, sizeof(info) );
+
+	if (gametype == GT_DUEL || gametype == GT_POWERDUEL)
+	{
+		wDisable = atoi(Info_ValueForKey(info, "g_duelWeaponDisable"));
+	}
+	else
+	{
+		wDisable = atoi(Info_ValueForKey(info, "g_weaponDisable"));
+	}
+
+	while (i < WP_NUM_WEAPONS)
+	{
+		if (!(wDisable & (1 << i)) &&
+			i != WP_SABER && i != WP_NONE)
+		{
+			return qfalse;
+		}
+
+		i++;
+	}
+
+	return qtrue;
+}
+
+static qboolean UI_AllForceDisabled(int force)
+{
+	int i;
+
+	if (force)
+	{
+		for (i=0;i<NUM_FORCE_POWERS;i++)
+		{
+			if (!(force & (1<<i)))
+			{
+				return qfalse;
+			}
+		}
+
+		return qtrue;
+	}
+
+	return qfalse;
+}
+
+qboolean UI_TrueJediEnabled( void )
+{
+	char	info[MAX_INFO_STRING];
+	int		gametype = 0, disabledForce = 0, trueJedi = 0;
+	qboolean saberOnly = qfalse, allForceDisabled = qfalse;
+
+	trap_GetConfigString( CS_SERVERINFO, info, sizeof(info) );
+
+	//already have serverinfo at this point for stuff below. Don't bother trying to use ui_forcePowerDisable.
+	//if (ui_forcePowerDisable.integer)
+	//if (atoi(Info_ValueForKey(info, "g_forcePowerDisable")))
+	disabledForce = atoi(Info_ValueForKey(info, "g_forcePowerDisable"));
+	allForceDisabled = UI_AllForceDisabled(disabledForce);
+	gametype = atoi(Info_ValueForKey(info, "g_gametype"));
+	saberOnly = UI_HasSetSaberOnly();
+
+	if ( gametype == GT_HOLOCRON 
+		|| gametype == GT_JEDIMASTER 
+		|| saberOnly 
+		|| allForceDisabled )
+	{
+		trueJedi = 0;
+	}
+	else
+	{
+		trueJedi = atoi( Info_ValueForKey( info, "g_jediVmerc" ) );
+	}
+	return (trueJedi != 0);
+}
+
+static void UI_DrawJediNonJedi(rectDef_t *rect, float scale, vec4_t color, int textStyle, int val, int min, int max, int iMenuFont)
+{
+	int i;
+	char s[256];
+	//menuDef_t *menu;
+	
+	char info[MAX_INFO_VALUE];
+
+	i = val;
+	if (i < min || i > max) 
+	{
+		i = min;
+	}
+
+	info[0] = '\0';
+	trap_GetConfigString(CS_SERVERINFO, info, sizeof(info));
+
+	if ( !UI_TrueJediEnabled() )
+	{//true jedi mode is not on, do not draw this button type
+		return;
+	}
+
+	if ( val == FORCE_NONJEDI )
+	{
+		trap_SP_GetStringTextString("MENUS_NO",s, sizeof(s));
+	}
+	else
+	{
+		trap_SP_GetStringTextString("MENUS_YES",s, sizeof(s));
+	}
+
+	Text_Paint(rect->x, rect->y, scale, color, s,0, 0, textStyle, iMenuFont);
+}
+
+static void UI_DrawTeamName(rectDef_t *rect, float scale, vec4_t color, qboolean blue, int textStyle, int iMenuFont) {
+  int i;
+  i = UI_TeamIndexFromName(UI_Cvar_VariableString((blue) ? "ui_blueTeam" : "ui_redTeam"));
+  if (i >= 0 && i < uiInfo.teamCount) {
+    Text_Paint(rect->x, rect->y, scale, color, va("%s: %s", (blue) ? "Blue" : "Red", uiInfo.teamList[i].teamName),0, 0, textStyle, iMenuFont);
+  }
+}
+
+static void UI_DrawTeamMember(rectDef_t *rect, float scale, vec4_t color, qboolean blue, int num, int textStyle, int iMenuFont) 
+{
+	// 0 - None
+	// 1 - Human
+	// 2..NumCharacters - Bot
+	int value = trap_Cvar_VariableValue(va(blue ? "ui_blueteam%i" : "ui_redteam%i", num));
+	const char *text;
+	int maxcl = trap_Cvar_VariableValue( "sv_maxClients" );
+	vec4_t finalColor;
+	int numval = num;
+
+	numval *= 2;
+
+	if (blue)
+	{
+		numval -= 1;
+	}
+
+	finalColor[0] = color[0];
+	finalColor[1] = color[1];
+	finalColor[2] = color[2];
+	finalColor[3] = color[3];
+
+	if (numval > maxcl)
+	{
+		finalColor[0] *= 0.5;
+		finalColor[1] *= 0.5;
+		finalColor[2] *= 0.5;
+
+		value = -1;
+	}
+
+	if (uiInfo.gameTypes[ui_netGameType.integer].gtEnum == GT_SIEGE)
+	{
+		if (value > 1 )
+		{
+			value = 1;
+		}
+	}
+
+	if (value <= 1) {
+		if (value == -1)
+		{
+			//text = "Closed";
+			text = UI_GetStringEdString("MENUS", "CLOSED");
+		}
+		else
+		{
+			//text = "Human";
+			text = UI_GetStringEdString("MENUS", "HUMAN");
+		}
+	} else {
+		value -= 2;
+		if (value >= UI_GetNumBots()) {
+			value = 1;
+		}
+		text = UI_GetBotNameByNumber(value);
+	}
+
+  Text_Paint(rect->x, rect->y, scale, finalColor, text, 0, 0, textStyle, iMenuFont);
+}
+
+static void UI_DrawEffects(rectDef_t *rect, float scale, vec4_t color) 
+{
+	UI_DrawHandlePic( rect->x, rect->y, rect->w, rect->h, uiSaberColorShaders[uiInfo.effectsColor]);
+}
+
+static void UI_DrawMapPreview(rectDef_t *rect, float scale, vec4_t color, qboolean net) {
+	int map = (net) ? ui_currentNetMap.integer : ui_currentMap.integer;
+	if (map < 0 || map > uiInfo.mapCount) {
+		if (net) {
+			ui_currentNetMap.integer = 0;
+			trap_Cvar_Set("ui_currentNetMap", "0");
+		} else {
+			ui_currentMap.integer = 0;
+			trap_Cvar_Set("ui_currentMap", "0");
+		}
+		map = 0;
+	}
+
+	if (uiInfo.mapList[map].levelShot == -1) {
+		uiInfo.mapList[map].levelShot = trap_R_RegisterShaderNoMip(uiInfo.mapList[map].imageName);
+	}
+
+	if (uiInfo.mapList[map].levelShot > 0) {
+		UI_DrawHandlePic( rect->x, rect->y, rect->w, rect->h, uiInfo.mapList[map].levelShot);
+	} else {
+		UI_DrawHandlePic( rect->x, rect->y, rect->w, rect->h, trap_R_RegisterShaderNoMip("menu/art/unknownmap_mp"));
+	}
+}						 
+
+
+static void UI_DrawMapTimeToBeat(rectDef_t *rect, float scale, vec4_t color, int textStyle, int iMenuFont) {
+	int minutes, seconds, time;
+	if (ui_currentMap.integer < 0 || ui_currentMap.integer > uiInfo.mapCount) {
+		ui_currentMap.integer = 0;
+		trap_Cvar_Set("ui_currentMap", "0");
+	}
+
+	time = uiInfo.mapList[ui_currentMap.integer].timeToBeat[uiInfo.gameTypes[ui_gameType.integer].gtEnum];
+
+	minutes = time / 60;
+	seconds = time % 60;
+
+  Text_Paint(rect->x, rect->y, scale, color, va("%02i:%02i", minutes, seconds), 0, 0, textStyle, iMenuFont);
+}
+
+
+
+static void UI_DrawMapCinematic(rectDef_t *rect, float scale, vec4_t color, qboolean net) {
+
+	int map = (net) ? ui_currentNetMap.integer : ui_currentMap.integer; 
+	if (map < 0 || map > uiInfo.mapCount) {
+		if (net) {
+			ui_currentNetMap.integer = 0;
+			trap_Cvar_Set("ui_currentNetMap", "0");
+		} else {
+			ui_currentMap.integer = 0;
+			trap_Cvar_Set("ui_currentMap", "0");
+		}
+		map = 0;
+	}
+
+	if (uiInfo.mapList[map].cinematic >= -1) {
+		if (uiInfo.mapList[map].cinematic == -1) {
+			uiInfo.mapList[map].cinematic = trap_CIN_PlayCinematic(va("%s.roq", uiInfo.mapList[map].mapLoadName), 0, 0, 0, 0, (CIN_loop | CIN_silent) );
+		}
+		if (uiInfo.mapList[map].cinematic >= 0) {
+		  trap_CIN_RunCinematic(uiInfo.mapList[map].cinematic);
+		  trap_CIN_SetExtents(uiInfo.mapList[map].cinematic, rect->x, rect->y, rect->w, rect->h);
+ 			trap_CIN_DrawCinematic(uiInfo.mapList[map].cinematic);
+		} else {
+			uiInfo.mapList[map].cinematic = -2;
+		}
+	} else {
+		UI_DrawMapPreview(rect, scale, color, net);
+	}
+}
+
+static void UI_SetForceDisabled(int force)
+{
+	int i = 0;
+
+	if (force)
+	{
+		while (i < NUM_FORCE_POWERS)
+		{
+			if (force & (1 << i))
+			{
+				uiForcePowersDisabled[i] = qtrue;
+
+				if (i != FP_LEVITATION && i != FP_SABER_OFFENSE && i != FP_SABER_DEFENSE)
+				{
+					uiForcePowersRank[i] = 0;
+				}
+				else
+				{
+					if (i == FP_LEVITATION)
+					{
+						uiForcePowersRank[i] = 1;
+					}
+					else
+					{
+						uiForcePowersRank[i] = 3;
+					}
+				}
+			}
+			else
+			{
+				uiForcePowersDisabled[i] = qfalse;
+			}
+			i++;
+		}
+	}
+	else
+	{
+		i = 0;
+
+		while (i < NUM_FORCE_POWERS)
+		{
+			uiForcePowersDisabled[i] = qfalse;
+			i++;
+		}
+	}
+}
+// The game type on create server has changed - make the HUMAN/BOTS fields active 
+void UpdateBotButtons(void)
+{
+	menuDef_t *menu;
+
+	menu = Menu_GetFocused();	
+
+	if (!menu)
+	{
+		return;
+	}
+
+	if (uiInfo.gameTypes[ui_netGameType.integer].gtEnum == GT_SIEGE)
+	{
+		Menu_ShowItemByName(menu, "humanbotfield", qfalse);
+		Menu_ShowItemByName(menu, "humanbotnonfield", qtrue);
+	}
+	else
+	{
+		Menu_ShowItemByName(menu, "humanbotfield", qtrue);
+		Menu_ShowItemByName(menu, "humanbotnonfield", qfalse);
+	}
+
+}
+
+void UpdateForceStatus()
+{
+	menuDef_t *menu;
+
+	// Currently we don't make a distinction between those that wish to play Jedi of lower than maximum skill.
+/*	if (ui_forcePowerDisable.integer)
+	{
+		uiForceRank = 0;
+		uiForceAvailable = 0;
+		uiForceUsed = 0;
+	}
+	else
+	{
+		uiForceRank = uiMaxRank;
+		uiForceUsed = 0;
+		uiForceAvailable = forceMasteryPoints[uiForceRank];
+	}
+*/
+	menu = Menus_FindByName("ingame_player");
+	if (menu)
+	{
+		char	info[MAX_INFO_STRING];
+		int		disabledForce = 0;
+		qboolean trueJedi = qfalse, allForceDisabled = qfalse;
+
+		trap_GetConfigString( CS_SERVERINFO, info, sizeof(info) );
+
+		//already have serverinfo at this point for stuff below. Don't bother trying to use ui_forcePowerDisable.
+		//if (ui_forcePowerDisable.integer)
+		//if (atoi(Info_ValueForKey(info, "g_forcePowerDisable")))
+		disabledForce = atoi(Info_ValueForKey(info, "g_forcePowerDisable"));
+		allForceDisabled = UI_AllForceDisabled(disabledForce);
+		trueJedi = UI_TrueJediEnabled();
+
+		if ( !trueJedi || allForceDisabled )
+		{
+			Menu_ShowItemByName(menu, "jedinonjedi", qfalse);
+		}
+		else
+		{
+			Menu_ShowItemByName(menu, "jedinonjedi", qtrue);
+		}
+		if ( allForceDisabled == qtrue || (trueJedi && uiJediNonJedi == FORCE_NONJEDI) )
+		{	// No force stuff
+			Menu_ShowItemByName(menu, "noforce", qtrue);
+			Menu_ShowItemByName(menu, "yesforce", qfalse);
+			// We don't want the saber explanation to say "configure saber attack 1" since we can't.
+			Menu_ShowItemByName(menu, "sabernoneconfigme", qfalse);
+		}
+		else
+		{
+			UI_SetForceDisabled(disabledForce);
+			Menu_ShowItemByName(menu, "noforce", qfalse);
+			Menu_ShowItemByName(menu, "yesforce", qtrue);
+		}
+
+		//Moved this to happen after it's done with force power disabling stuff
+		if (uiForcePowersRank[FP_SABER_OFFENSE] > 0 || ui_freeSaber.integer)
+		{	// Show lightsaber stuff.
+			Menu_ShowItemByName(menu, "nosaber", qfalse);
+			Menu_ShowItemByName(menu, "yessaber", qtrue);
+		}
+		else
+		{
+			Menu_ShowItemByName(menu, "nosaber", qtrue);
+			Menu_ShowItemByName(menu, "yessaber", qfalse);
+		}
+
+		// The leftmost button should be "apply" unless you are in spectator, where you can join any team.
+		if ((int)(trap_Cvar_VariableValue("ui_myteam")) != TEAM_SPECTATOR)
+		{
+			Menu_ShowItemByName(menu, "playerapply", qtrue);
+			Menu_ShowItemByName(menu, "playerforcejoin", qfalse);
+			Menu_ShowItemByName(menu, "playerforcered", qtrue);
+			Menu_ShowItemByName(menu, "playerforceblue", qtrue);
+			Menu_ShowItemByName(menu, "playerforcespectate", qtrue);
+		}
+		else
+		{
+			// Set or reset buttons based on choices
+			if (atoi(Info_ValueForKey(info, "g_gametype")) >= GT_TEAM)
+			{	// This is a team-based game.
+				Menu_ShowItemByName(menu, "playerforcespectate", qtrue);
+				
+				// This is disabled, always show both sides from spectator.
+				if ( 0 && atoi(Info_ValueForKey(info, "g_forceBasedTeams")))
+				{	// Show red or blue based on what side is chosen.
+					if (uiForceSide==FORCE_LIGHTSIDE)
+					{
+						Menu_ShowItemByName(menu, "playerforcered", qfalse);
+						Menu_ShowItemByName(menu, "playerforceblue", qtrue);
+					}
+					else if (uiForceSide==FORCE_DARKSIDE)
+					{
+						Menu_ShowItemByName(menu, "playerforcered", qtrue);
+						Menu_ShowItemByName(menu, "playerforceblue", qfalse);
+					}
+					else
+					{
+						Menu_ShowItemByName(menu, "playerforcered", qtrue);
+						Menu_ShowItemByName(menu, "playerforceblue", qtrue);
+					}
+				}
+				else
+				{
+					Menu_ShowItemByName(menu, "playerforcered", qtrue);
+					Menu_ShowItemByName(menu, "playerforceblue", qtrue);
+				}
+			}
+			else
+			{
+				Menu_ShowItemByName(menu, "playerforcered", qfalse);
+				Menu_ShowItemByName(menu, "playerforceblue", qfalse);
+			}
+
+			Menu_ShowItemByName(menu, "playerapply", qfalse);
+			Menu_ShowItemByName(menu, "playerforcejoin", qtrue);
+			Menu_ShowItemByName(menu, "playerforcespectate", qtrue);
+		}
+	}
+
+
+	if ( !UI_TrueJediEnabled() )
+	{// Take the current team and force a skin color based on it.
+		char	info[MAX_INFO_STRING];
+
+		switch((int)(trap_Cvar_VariableValue("ui_myteam")))
+		{
+		case TEAM_RED:
+			uiSkinColor = TEAM_RED;
+			uiInfo.effectsColor = SABER_RED;
+			break;
+		case TEAM_BLUE:
+			uiSkinColor = TEAM_BLUE;
+			uiInfo.effectsColor = SABER_BLUE;
+			break;
+		default:
+			trap_GetConfigString( CS_SERVERINFO, info, sizeof(info) );
+
+			if (atoi(Info_ValueForKey(info, "g_gametype")) >= GT_TEAM)
+			{
+				uiSkinColor = TEAM_FREE;
+			}
+			else	// A bit of a hack so non-team games will remember which skin set you chose in the player menu
+			{
+				uiSkinColor = uiHoldSkinColor;
+			}
+			break;
+		}
+	}
+}
+
+
+
+static void UI_DrawNetSource(rectDef_t *rect, float scale, vec4_t color, int textStyle, int iMenuFont) 
+{
+	if (ui_netSource.integer < 0 || ui_netSource.integer > uiInfo.numGameTypes) 
+	{
+		ui_netSource.integer = 0;
+	}
+
+	trap_SP_GetStringTextString("MENUS_SOURCE", holdSPString, sizeof(holdSPString) );
+	Text_Paint(rect->x, rect->y, scale, color, va("%s %s",holdSPString,
+		 GetNetSourceString(ui_netSource.integer)), 0, 0, textStyle, iMenuFont);
+}
+
+static void UI_DrawNetMapPreview(rectDef_t *rect, float scale, vec4_t color) {
+
+	if (uiInfo.serverStatus.currentServerPreview > 0) {
+		UI_DrawHandlePic( rect->x, rect->y, rect->w, rect->h, uiInfo.serverStatus.currentServerPreview);
+	} else {
+		UI_DrawHandlePic( rect->x, rect->y, rect->w, rect->h, trap_R_RegisterShaderNoMip("menu/art/unknownmap_mp"));
+	}
+}
+
+static void UI_DrawNetMapCinematic(rectDef_t *rect, float scale, vec4_t color) {
+	if (ui_currentNetMap.integer < 0 || ui_currentNetMap.integer > uiInfo.mapCount) {
+		ui_currentNetMap.integer = 0;
+		trap_Cvar_Set("ui_currentNetMap", "0");
+	}
+
+	if (uiInfo.serverStatus.currentServerCinematic >= 0) {
+	  trap_CIN_RunCinematic(uiInfo.serverStatus.currentServerCinematic);
+	  trap_CIN_SetExtents(uiInfo.serverStatus.currentServerCinematic, rect->x, rect->y, rect->w, rect->h);
+ 	  trap_CIN_DrawCinematic(uiInfo.serverStatus.currentServerCinematic);
+	} else {
+		UI_DrawNetMapPreview(rect, scale, color);
+	}
+}
+
+
+
+static void UI_DrawNetFilter(rectDef_t *rect, float scale, vec4_t color, int textStyle, int iMenuFont) 
+{
+
+	if (ui_serverFilterType.integer < 0 || ui_serverFilterType.integer > numServerFilters) 
+	{
+		ui_serverFilterType.integer = 0;
+	}
+
+	trap_SP_GetStringTextString("MENUS_GAME", holdSPString, sizeof(holdSPString));
+
+	trap_SP_GetStringTextString(serverFilters[ui_serverFilterType.integer].description, holdSPString2, sizeof(holdSPString2));
+
+	Text_Paint(rect->x, rect->y, scale, color, va("%s %s",holdSPString,
+		 holdSPString2), 0, 0, textStyle, iMenuFont);
+}
+
+
+static void UI_DrawTier(rectDef_t *rect, float scale, vec4_t color, int textStyle, int iMenuFont) {
+  int i;
+	i = trap_Cvar_VariableValue( "ui_currentTier" );
+  if (i < 0 || i >= uiInfo.tierCount) {
+    i = 0;
+  }
+  Text_Paint(rect->x, rect->y, scale, color, va("Tier: %s", uiInfo.tierList[i].tierName),0, 0, textStyle, iMenuFont);
+}
+
+static void UI_DrawTierMap(rectDef_t *rect, int index) {
+  int i;
+	i = trap_Cvar_VariableValue( "ui_currentTier" );
+  if (i < 0 || i >= uiInfo.tierCount) {
+    i = 0;
+  }
+
+	if (uiInfo.tierList[i].mapHandles[index] == -1) {
+		uiInfo.tierList[i].mapHandles[index] = trap_R_RegisterShaderNoMip(va("levelshots/%s", uiInfo.tierList[i].maps[index]));
+	}
+												 
+	UI_DrawHandlePic( rect->x, rect->y, rect->w, rect->h, uiInfo.tierList[i].mapHandles[index]);
+}
+
+static const char *UI_EnglishMapName(const char *map) {
+	int i;
+	for (i = 0; i < uiInfo.mapCount; i++) {
+		if (Q_stricmp(map, uiInfo.mapList[i].mapLoadName) == 0) {
+			return uiInfo.mapList[i].mapName;
+		}
+	}
+	return "";
+}
+
+static void UI_DrawTierMapName(rectDef_t *rect, float scale, vec4_t color, int textStyle, int iMenuFont) {
+  int i, j;
+	i = trap_Cvar_VariableValue( "ui_currentTier" );
+  if (i < 0 || i >= uiInfo.tierCount) {
+    i = 0;
+  }
+	j = trap_Cvar_VariableValue("ui_currentMap");
+	if (j < 0 || j > MAPS_PER_TIER) {
+		j = 0;
+	}
+
+  Text_Paint(rect->x, rect->y, scale, color, UI_EnglishMapName(uiInfo.tierList[i].maps[j]), 0, 0, textStyle, iMenuFont);
+}
+
+static void UI_DrawTierGameType(rectDef_t *rect, float scale, vec4_t color, int textStyle, int iMenuFont) {
+  int i, j;
+	i = trap_Cvar_VariableValue( "ui_currentTier" );
+  if (i < 0 || i >= uiInfo.tierCount) {
+    i = 0;
+  }
+	j = trap_Cvar_VariableValue("ui_currentMap");
+	if (j < 0 || j > MAPS_PER_TIER) {
+		j = 0;
+	}
+
+  Text_Paint(rect->x, rect->y, scale, color, uiInfo.gameTypes[uiInfo.tierList[i].gameTypes[j]].gameType , 0, 0, textStyle,iMenuFont);
+}
+
+
+static const char *UI_AIFromName(const char *name) {
+	int j;
+	for (j = 0; j < uiInfo.aliasCount; j++) {
+		if (Q_stricmp(uiInfo.aliasList[j].name, name) == 0) {
+			return uiInfo.aliasList[j].ai;
+		}
+	}
+	return "Kyle";
+}
+
+
+/*
+static qboolean updateOpponentModel = qtrue;
+static void UI_DrawOpponent(rectDef_t *rect) {
+  static playerInfo_t info2;
+  char model[MAX_QPATH];
+  char headmodel[MAX_QPATH];
+  char team[256];
+	vec3_t	viewangles;
+	vec3_t	moveangles;
+  
+	if (updateOpponentModel) {
+		
+		strcpy(model, UI_Cvar_VariableString("ui_opponentModel"));
+	  strcpy(headmodel, UI_Cvar_VariableString("ui_opponentModel"));
+		team[0] = '\0';
+
+  	memset( &info2, 0, sizeof(playerInfo_t) );
+  	viewangles[YAW]   = 180 - 10;
+  	viewangles[PITCH] = 0;
+  	viewangles[ROLL]  = 0;
+  	VectorClear( moveangles );
+    UI_PlayerInfo_SetModel( &info2, model, headmodel, "");
+    UI_PlayerInfo_SetInfo( &info2, TORSO_WEAPONREADY3, TORSO_WEAPONREADY3, viewangles, vec3_origin, WP_BRYAR_PISTOL, qfalse );
+		UI_RegisterClientModelname( &info2, model, headmodel, team);
+    updateOpponentModel = qfalse;
+  }
+
+  UI_DrawPlayer( rect->x, rect->y, rect->w, rect->h, &info2, uiInfo.uiDC.realTime / 2);
+
+}
+*/
+static void UI_NextOpponent() {
+  int i = UI_TeamIndexFromName(UI_Cvar_VariableString("ui_opponentName"));
+  int j = UI_TeamIndexFromName(UI_Cvar_VariableString("ui_teamName"));
+	i++;
+	if (i >= uiInfo.teamCount) {
+		i = 0;
+	}
+	if (i == j) {
+		i++;
+		if ( i >= uiInfo.teamCount) {
+			i = 0;
+		}
+	}
+ 	trap_Cvar_Set( "ui_opponentName", uiInfo.teamList[i].teamName );
+}
+
+static void UI_PriorOpponent() {
+  int i = UI_TeamIndexFromName(UI_Cvar_VariableString("ui_opponentName"));
+  int j = UI_TeamIndexFromName(UI_Cvar_VariableString("ui_teamName"));
+	i--;
+	if (i < 0) {
+		i = uiInfo.teamCount - 1;
+	}
+	if (i == j) {
+		i--;
+		if ( i < 0) {
+			i = uiInfo.teamCount - 1;
+		}
+	}
+ 	trap_Cvar_Set( "ui_opponentName", uiInfo.teamList[i].teamName );
+}
+
+static void	UI_DrawPlayerLogo(rectDef_t *rect, vec3_t color) {
+  int i = UI_TeamIndexFromName(UI_Cvar_VariableString("ui_teamName"));
+
+	if (uiInfo.teamList[i].teamIcon == -1) {
+    uiInfo.teamList[i].teamIcon = trap_R_RegisterShaderNoMip(uiInfo.teamList[i].imageName);
+    uiInfo.teamList[i].teamIcon_Metal = trap_R_RegisterShaderNoMip(va("%s_metal",uiInfo.teamList[i].imageName));
+    uiInfo.teamList[i].teamIcon_Name = trap_R_RegisterShaderNoMip(va("%s_name", uiInfo.teamList[i].imageName));
+	}
+
+ 	trap_R_SetColor( color );
+	UI_DrawHandlePic( rect->x, rect->y, rect->w, rect->h, uiInfo.teamList[i].teamIcon );
+ 	trap_R_SetColor( NULL );
+}
+
+static void	UI_DrawPlayerLogoMetal(rectDef_t *rect, vec3_t color) {
+  int i = UI_TeamIndexFromName(UI_Cvar_VariableString("ui_teamName"));
+	if (uiInfo.teamList[i].teamIcon == -1) {
+    uiInfo.teamList[i].teamIcon = trap_R_RegisterShaderNoMip(uiInfo.teamList[i].imageName);
+    uiInfo.teamList[i].teamIcon_Metal = trap_R_RegisterShaderNoMip(va("%s_metal",uiInfo.teamList[i].imageName));
+    uiInfo.teamList[i].teamIcon_Name = trap_R_RegisterShaderNoMip(va("%s_name", uiInfo.teamList[i].imageName));
+	}
+
+ 	trap_R_SetColor( color );
+	UI_DrawHandlePic( rect->x, rect->y, rect->w, rect->h, uiInfo.teamList[i].teamIcon_Metal );
+ 	trap_R_SetColor( NULL );
+}
+
+static void	UI_DrawPlayerLogoName(rectDef_t *rect, vec3_t color) {
+  int i = UI_TeamIndexFromName(UI_Cvar_VariableString("ui_teamName"));
+	if (uiInfo.teamList[i].teamIcon == -1) {
+    uiInfo.teamList[i].teamIcon = trap_R_RegisterShaderNoMip(uiInfo.teamList[i].imageName);
+    uiInfo.teamList[i].teamIcon_Metal = trap_R_RegisterShaderNoMip(va("%s_metal",uiInfo.teamList[i].imageName));
+    uiInfo.teamList[i].teamIcon_Name = trap_R_RegisterShaderNoMip(va("%s_name", uiInfo.teamList[i].imageName));
+	}
+
+ 	trap_R_SetColor( color );
+	UI_DrawHandlePic( rect->x, rect->y, rect->w, rect->h, uiInfo.teamList[i].teamIcon_Name );
+ 	trap_R_SetColor( NULL );
+}
+
+static void	UI_DrawOpponentLogo(rectDef_t *rect, vec3_t color) {
+  int i = UI_TeamIndexFromName(UI_Cvar_VariableString("ui_opponentName"));
+	if (uiInfo.teamList[i].teamIcon == -1) {
+    uiInfo.teamList[i].teamIcon = trap_R_RegisterShaderNoMip(uiInfo.teamList[i].imageName);
+    uiInfo.teamList[i].teamIcon_Metal = trap_R_RegisterShaderNoMip(va("%s_metal",uiInfo.teamList[i].imageName));
+    uiInfo.teamList[i].teamIcon_Name = trap_R_RegisterShaderNoMip(va("%s_name", uiInfo.teamList[i].imageName));
+	}
+
+ 	trap_R_SetColor( color );
+	UI_DrawHandlePic( rect->x, rect->y, rect->w, rect->h, uiInfo.teamList[i].teamIcon );
+ 	trap_R_SetColor( NULL );
+}
+
+static void	UI_DrawOpponentLogoMetal(rectDef_t *rect, vec3_t color) {
+  int i = UI_TeamIndexFromName(UI_Cvar_VariableString("ui_opponentName"));
+	if (uiInfo.teamList[i].teamIcon == -1) {
+    uiInfo.teamList[i].teamIcon = trap_R_RegisterShaderNoMip(uiInfo.teamList[i].imageName);
+    uiInfo.teamList[i].teamIcon_Metal = trap_R_RegisterShaderNoMip(va("%s_metal",uiInfo.teamList[i].imageName));
+    uiInfo.teamList[i].teamIcon_Name = trap_R_RegisterShaderNoMip(va("%s_name", uiInfo.teamList[i].imageName));
+	}
+
+ 	trap_R_SetColor( color );
+	UI_DrawHandlePic( rect->x, rect->y, rect->w, rect->h, uiInfo.teamList[i].teamIcon_Metal );
+ 	trap_R_SetColor( NULL );
+}
+
+static void	UI_DrawOpponentLogoName(rectDef_t *rect, vec3_t color) {
+  int i = UI_TeamIndexFromName(UI_Cvar_VariableString("ui_opponentName"));
+	if (uiInfo.teamList[i].teamIcon == -1) {
+    uiInfo.teamList[i].teamIcon = trap_R_RegisterShaderNoMip(uiInfo.teamList[i].imageName);
+    uiInfo.teamList[i].teamIcon_Metal = trap_R_RegisterShaderNoMip(va("%s_metal",uiInfo.teamList[i].imageName));
+    uiInfo.teamList[i].teamIcon_Name = trap_R_RegisterShaderNoMip(va("%s_name", uiInfo.teamList[i].imageName));
+	}
+
+ 	trap_R_SetColor( color );
+	UI_DrawHandlePic( rect->x, rect->y, rect->w, rect->h, uiInfo.teamList[i].teamIcon_Name );
+ 	trap_R_SetColor( NULL );
+}
+
+static void UI_DrawAllMapsSelection(rectDef_t *rect, float scale, vec4_t color, int textStyle, qboolean net, int iMenuFont) {
+	int map = (net) ? ui_currentNetMap.integer : ui_currentMap.integer;
+	if (map >= 0 && map < uiInfo.mapCount) {
+	  Text_Paint(rect->x, rect->y, scale, color, uiInfo.mapList[map].mapName, 0, 0, textStyle, iMenuFont);
+	}
+}
+
+static void UI_DrawOpponentName(rectDef_t *rect, float scale, vec4_t color, int textStyle, int iMenuFont) {
+  Text_Paint(rect->x, rect->y, scale, color, UI_Cvar_VariableString("ui_opponentName"), 0, 0, textStyle, iMenuFont);
+}
+
+static int UI_OwnerDrawWidth(int ownerDraw, float scale) {
+	int i, h, value, findex, iUse = 0;
+	const char *text;
+	const char *s = NULL;
+
+
+  switch (ownerDraw) {
+    case UI_HANDICAP:
+			  h = Com_Clamp( 5, 100, trap_Cvar_VariableValue("handicap") );
+				i = 20 - h / 5;
+				s = handicapValues[i];
+      break;
+    case UI_SKIN_COLOR:
+		switch(uiSkinColor)
+		{
+		case TEAM_RED:
+//			s = "Red";
+			s = (char *)UI_GetStringEdString("MENUS", "TEAM_RED");
+			break;
+		case TEAM_BLUE:
+//			s = "Blue";
+			s = (char *)UI_GetStringEdString("MENUS", "TEAM_BLUE");
+			break;
+		default:
+//			s = "Default";
+			s = (char *)UI_GetStringEdString("MENUS", "DEFAULT");
+			break;
+		}
+		break;
+    case UI_FORCE_SIDE:
+		i = uiForceSide;
+		if (i < 1 || i > 2) {
+			i = 1;
+		}
+
+		if (i == FORCE_LIGHTSIDE)
+		{
+//			s = "Light";
+			s = (char *)UI_GetStringEdString("MENUS", "FORCEDESC_LIGHT");
+		}
+		else
+		{
+//			s = "Dark";
+			s = (char *)UI_GetStringEdString("MENUS", "FORCEDESC_DARK");
+		}
+		break;
+    case UI_JEDI_NONJEDI:
+		i = uiJediNonJedi;
+		if (i < 0 || i > 1)
+		{
+			i = 0;
+		}
+
+		if (i == FORCE_NONJEDI)
+		{
+//			s = "Non-Jedi";
+			s = (char *)UI_GetStringEdString("MENUS", "NO");
+		}
+		else
+		{
+//			s = "Jedi";
+			s = (char *)UI_GetStringEdString("MENUS", "YES");
+		}
+		break;
+    case UI_FORCE_RANK:
+		i = uiForceRank;
+		if (i < 1 || i > MAX_FORCE_RANK) {
+			i = 1;
+		}
+
+		s = (char *)UI_GetStringEdString("MP_INGAME", forceMasteryLevels[i]);
+		break;
+	case UI_FORCE_RANK_HEAL:
+	case UI_FORCE_RANK_LEVITATION:
+	case UI_FORCE_RANK_SPEED:
+	case UI_FORCE_RANK_PUSH:
+	case UI_FORCE_RANK_PULL:
+	case UI_FORCE_RANK_TELEPATHY:
+	case UI_FORCE_RANK_GRIP:
+	case UI_FORCE_RANK_LIGHTNING:
+	case UI_FORCE_RANK_RAGE:
+	case UI_FORCE_RANK_PROTECT:
+	case UI_FORCE_RANK_ABSORB:
+	case UI_FORCE_RANK_TEAM_HEAL:
+	case UI_FORCE_RANK_TEAM_FORCE:
+	case UI_FORCE_RANK_DRAIN:
+	case UI_FORCE_RANK_SEE:
+	case UI_FORCE_RANK_SABERATTACK:
+	case UI_FORCE_RANK_SABERDEFEND:
+	case UI_FORCE_RANK_SABERTHROW:
+		findex = (ownerDraw - UI_FORCE_RANK)-1;
+		//this will give us the index as long as UI_FORCE_RANK is always one below the first force rank index
+		i = uiForcePowersRank[findex];
+
+		if (i < 0 || i > NUM_FORCE_POWER_LEVELS-1)
+		{
+			i = 0;
+		}
+
+		s = va("%i", uiForcePowersRank[findex]);
+		break;
+    case UI_CLANNAME:
+				s = UI_Cvar_VariableString("ui_teamName");
+      break;
+    case UI_GAMETYPE:
+				s = uiInfo.gameTypes[ui_gameType.integer].gameType;
+      break;
+    case UI_SKILL:
+				i = trap_Cvar_VariableValue( "g_spSkill" );
+				if (i < 1 || i > numSkillLevels) {
+					i = 1;
+				}
+			  s = (char *)UI_GetStringEdString("MP_INGAME", (char *)skillLevels[i-1]);
+      break;
+    case UI_BLUETEAMNAME:
+			  i = UI_TeamIndexFromName(UI_Cvar_VariableString("ui_blueTeam"));
+			  if (i >= 0 && i < uiInfo.teamCount) {
+			    s = va("%s: %s", (char *)UI_GetStringEdString("MENUS", "TEAM_BLUE"), uiInfo.teamList[i].teamName);
+			  }
+      break;
+    case UI_REDTEAMNAME:
+			  i = UI_TeamIndexFromName(UI_Cvar_VariableString("ui_redTeam"));
+			  if (i >= 0 && i < uiInfo.teamCount) {
+			    s = va("%s: %s",  (char *)UI_GetStringEdString("MENUS", "TEAM_RED"), uiInfo.teamList[i].teamName);
+			  }
+      break;
+    case UI_BLUETEAM1:
+		case UI_BLUETEAM2:
+		case UI_BLUETEAM3:
+		case UI_BLUETEAM4:
+		case UI_BLUETEAM5:
+		case UI_BLUETEAM6:
+		case UI_BLUETEAM7:
+		case UI_BLUETEAM8:
+			if (ownerDraw <= UI_BLUETEAM5)
+			{
+			  iUse = ownerDraw-UI_BLUETEAM1 + 1;
+			}
+			else
+			{
+			  iUse = ownerDraw-274; //unpleasent hack because I don't want to move up all the UI_BLAHTEAM# defines
+			}
+
+			value = trap_Cvar_VariableValue(va("ui_blueteam%i", iUse));
+			if (value <= 1) {
+				text = "Human";
+			} else {
+				value -= 2;
+				if (value >= uiInfo.aliasCount) {
+					value = 1;
+				}
+				text = uiInfo.aliasList[value].name;
+			}
+			s = va("%i. %s", iUse, text);
+      break;
+    case UI_REDTEAM1:
+		case UI_REDTEAM2:
+		case UI_REDTEAM3:
+		case UI_REDTEAM4:
+		case UI_REDTEAM5:
+		case UI_REDTEAM6:
+		case UI_REDTEAM7:
+		case UI_REDTEAM8:
+			if (ownerDraw <= UI_REDTEAM5)
+			{
+			  iUse = ownerDraw-UI_REDTEAM1 + 1;
+			}
+			else
+			{
+			  iUse = ownerDraw-277; //unpleasent hack because I don't want to move up all the UI_BLAHTEAM# defines
+			}
+
+			value = trap_Cvar_VariableValue(va("ui_redteam%i", iUse));
+			if (value <= 1) {
+				text = "Human";
+			} else {
+				value -= 2;
+				if (value >= uiInfo.aliasCount) {
+					value = 1;
+				}
+				text = uiInfo.aliasList[value].name;
+			}
+			s = va("%i. %s", iUse, text);
+      break;
+		case UI_NETSOURCE:
+			if (ui_netSource.integer < 0 || ui_netSource.integer > uiInfo.numJoinGameTypes) {
+				ui_netSource.integer = 0;
+			}
+			trap_SP_GetStringTextString("MENUS_SOURCE", holdSPString, sizeof(holdSPString));
+			s = va("%s %s", holdSPString, GetNetSourceString(ui_netSource.integer));
+			break;
+		case UI_NETFILTER:
+			if (ui_serverFilterType.integer < 0 || ui_serverFilterType.integer > numServerFilters) {
+				ui_serverFilterType.integer = 0;
+			}
+			trap_SP_GetStringTextString("MENUS_GAME", holdSPString, sizeof(holdSPString));
+			trap_SP_GetStringTextString(serverFilters[ui_serverFilterType.integer].description, holdSPString2, sizeof(holdSPString2));
+
+			s = va("%s %s", holdSPString, holdSPString2 );
+			break;
+		case UI_TIER:
+			break;
+		case UI_TIER_MAPNAME:
+			break;
+		case UI_TIER_GAMETYPE:
+			break;
+		case UI_ALLMAPS_SELECTION:
+			break;
+		case UI_OPPONENT_NAME:
+			break;
+		case UI_KEYBINDSTATUS:
+			if (Display_KeyBindPending()) {
+				s = UI_GetStringEdString("MP_INGAME", "WAITING_FOR_NEW_KEY");
+			} else {
+			//	s = "Press ENTER or CLICK to change, Press BACKSPACE to clear";
+			}
+			break;
+		case UI_SERVERREFRESHDATE:
+			s = UI_Cvar_VariableString(va("ui_lastServerRefresh_%i", ui_netSource.integer));
+			break;
+    default:
+      break;
+  }
+
+	if (s) {
+		return Text_Width(s, scale, 0);
+	}
+	return 0;
+}
+
+static void UI_DrawBotName(rectDef_t *rect, float scale, vec4_t color, int textStyle,int iMenuFont) 
+{
+	int value = uiInfo.botIndex;
+	const char *text = "";
+	if (value >= UI_GetNumBots()) {
+		value = 0;
+	}
+	text = UI_GetBotNameByNumber(value);
+	Text_Paint(rect->x, rect->y, scale, color, text, 0, 0, textStyle,iMenuFont);
+}
+
+static void UI_DrawBotSkill(rectDef_t *rect, float scale, vec4_t color, int textStyle,int iMenuFont) 
+{
+	if (uiInfo.skillIndex >= 0 && uiInfo.skillIndex < numSkillLevels) 
+	{
+		Text_Paint(rect->x, rect->y, scale, color, (char *)UI_GetStringEdString("MP_INGAME", (char *)skillLevels[uiInfo.skillIndex]), 0, 0, textStyle,iMenuFont);
+	}
+}
+
+static void UI_DrawRedBlue(rectDef_t *rect, float scale, vec4_t color, int textStyle,int iMenuFont) 
+{
+	Text_Paint(rect->x, rect->y, scale, color, (uiInfo.redBlue == 0) ? UI_GetStringEdString("MP_INGAME","RED") : UI_GetStringEdString("MP_INGAME","BLUE"), 0, 0, textStyle,iMenuFont);
+}
+
+static void UI_DrawCrosshair(rectDef_t *rect, float scale, vec4_t color) {
+ 	trap_R_SetColor( color );
+	if (uiInfo.currentCrosshair < 0 || uiInfo.currentCrosshair >= NUM_CROSSHAIRS) {
+		uiInfo.currentCrosshair = 0;
+	}
+	UI_DrawHandlePic( rect->x, rect->y, rect->w, rect->h, uiInfo.uiDC.Assets.crosshairShader[uiInfo.currentCrosshair]);
+ 	trap_R_SetColor( NULL );
+}
+
+/*
+===============
+UI_BuildPlayerList
+===============
+*/
+static void UI_BuildPlayerList() {
+	uiClientState_t	cs;
+	int		n, count, team, team2, playerTeamNumber;
+	char	info[MAX_INFO_STRING];
+
+	trap_GetClientState( &cs );
+	trap_GetConfigString( CS_PLAYERS + cs.clientNum, info, MAX_INFO_STRING );
+	uiInfo.playerNumber = cs.clientNum;
+	uiInfo.teamLeader = atoi(Info_ValueForKey(info, "tl"));
+	team = atoi(Info_ValueForKey(info, "t"));
+	trap_GetConfigString( CS_SERVERINFO, info, sizeof(info) );
+	count = atoi( Info_ValueForKey( info, "sv_maxclients" ) );
+	uiInfo.playerCount = 0;
+	uiInfo.myTeamCount = 0;
+	playerTeamNumber = 0;
+	for( n = 0; n < count; n++ ) {
+		trap_GetConfigString( CS_PLAYERS + n, info, MAX_INFO_STRING );
+
+		if (info[0]) {
+			Q_strncpyz( uiInfo.playerNames[uiInfo.playerCount], Info_ValueForKey( info, "n" ), MAX_NAME_LENGTH );
+			Q_CleanStr( uiInfo.playerNames[uiInfo.playerCount] );
+			uiInfo.playerIndexes[uiInfo.playerCount] = n;
+			uiInfo.playerCount++;
+			team2 = atoi(Info_ValueForKey(info, "t"));
+			if (team2 == team && n != uiInfo.playerNumber) {
+				Q_strncpyz( uiInfo.teamNames[uiInfo.myTeamCount], Info_ValueForKey( info, "n" ), MAX_NAME_LENGTH );
+				Q_CleanStr( uiInfo.teamNames[uiInfo.myTeamCount] );
+				uiInfo.teamClientNums[uiInfo.myTeamCount] = n;
+				if (uiInfo.playerNumber == n) {
+					playerTeamNumber = uiInfo.myTeamCount;
+				}
+				uiInfo.myTeamCount++;
+			}
+		}
+	}
+
+	if (!uiInfo.teamLeader) {
+		trap_Cvar_Set("cg_selectedPlayer", va("%d", playerTeamNumber));
+	}
+
+	n = trap_Cvar_VariableValue("cg_selectedPlayer");
+	if (n < 0 || n > uiInfo.myTeamCount) {
+		n = 0;
+	}
+
+
+	if (n < uiInfo.myTeamCount) {
+		trap_Cvar_Set("cg_selectedPlayerName", uiInfo.teamNames[n]);
+	}
+	else
+	{
+		trap_Cvar_Set("cg_selectedPlayerName", "Everyone");
+	}
+
+	if (!team || team == TEAM_SPECTATOR || !uiInfo.teamLeader)
+	{
+		n = uiInfo.myTeamCount;
+		trap_Cvar_Set("cg_selectedPlayer", va("%d", n));
+		trap_Cvar_Set("cg_selectedPlayerName", "N/A");
+	}
+}
+
+
+static void UI_DrawSelectedPlayer(rectDef_t *rect, float scale, vec4_t color, int textStyle, int iMenuFont) {
+	if (uiInfo.uiDC.realTime > uiInfo.playerRefresh) {
+		uiInfo.playerRefresh = uiInfo.uiDC.realTime + 3000;
+		UI_BuildPlayerList();
+	}
+  Text_Paint(rect->x, rect->y, scale, color, UI_Cvar_VariableString("cg_selectedPlayerName"), 0, 0, textStyle, iMenuFont);
+}
+
+static void UI_DrawServerRefreshDate(rectDef_t *rect, float scale, vec4_t color, int textStyle, int iMenuFont) 
+{
+	if (uiInfo.serverStatus.refreshActive) 
+	{
+		vec4_t lowLight, newColor;
+		lowLight[0] = 0.8 * color[0]; 
+		lowLight[1] = 0.8 * color[1]; 
+		lowLight[2] = 0.8 * color[2]; 
+		lowLight[3] = 0.8 * color[3]; 
+		LerpColor(color,lowLight,newColor,0.5+0.5*sin((float)(uiInfo.uiDC.realTime / PULSE_DIVISOR)));
+
+		trap_SP_GetStringTextString("MP_INGAME_GETTINGINFOFORSERVERS", holdSPString, sizeof(holdSPString));
+		Text_Paint(rect->x, rect->y, scale, newColor, va((char *) holdSPString, trap_LAN_GetServerCount(ui_netSource.integer)), 0, 0, textStyle, iMenuFont);
+	} 
+	else 
+	{
+		char buff[64];
+		Q_strncpyz(buff, UI_Cvar_VariableString(va("ui_lastServerRefresh_%i", ui_netSource.integer)), 64);
+		trap_SP_GetStringTextString("MP_INGAME_SERVER_REFRESHTIME", holdSPString, sizeof(holdSPString));
+
+		Text_Paint(rect->x, rect->y, scale, color, va("%s: %s", holdSPString, buff), 0, 0, textStyle, iMenuFont);
+	}
+}
+
+static void UI_DrawServerMOTD(rectDef_t *rect, float scale, vec4_t color, int iMenuFont) {
+	if (uiInfo.serverStatus.motdLen) {
+		float maxX;
+	 
+		if (uiInfo.serverStatus.motdWidth == -1) {
+			uiInfo.serverStatus.motdWidth = 0;
+			uiInfo.serverStatus.motdPaintX = rect->x + 1;
+			uiInfo.serverStatus.motdPaintX2 = -1;
+		}
+
+		if (uiInfo.serverStatus.motdOffset > uiInfo.serverStatus.motdLen) {
+			uiInfo.serverStatus.motdOffset = 0;
+			uiInfo.serverStatus.motdPaintX = rect->x + 1;
+			uiInfo.serverStatus.motdPaintX2 = -1;
+		}
+
+		if (uiInfo.uiDC.realTime > uiInfo.serverStatus.motdTime) {
+			uiInfo.serverStatus.motdTime = uiInfo.uiDC.realTime + 10;
+			if (uiInfo.serverStatus.motdPaintX <= rect->x + 2) {
+				if (uiInfo.serverStatus.motdOffset < uiInfo.serverStatus.motdLen) {
+					uiInfo.serverStatus.motdPaintX += Text_Width(&uiInfo.serverStatus.motd[uiInfo.serverStatus.motdOffset], scale, 1) - 1;
+					uiInfo.serverStatus.motdOffset++;
+				} else {
+					uiInfo.serverStatus.motdOffset = 0;
+					if (uiInfo.serverStatus.motdPaintX2 >= 0) {
+						uiInfo.serverStatus.motdPaintX = uiInfo.serverStatus.motdPaintX2;
+					} else {
+						uiInfo.serverStatus.motdPaintX = rect->x + rect->w - 2;
+					}
+					uiInfo.serverStatus.motdPaintX2 = -1;
+				}
+			} else {
+				//serverStatus.motdPaintX--;
+				uiInfo.serverStatus.motdPaintX -= 2;
+				if (uiInfo.serverStatus.motdPaintX2 >= 0) {
+					//serverStatus.motdPaintX2--;
+					uiInfo.serverStatus.motdPaintX2 -= 2;
+				}
+			}
+		}
+
+		maxX = rect->x + rect->w - 2;
+		Text_Paint_Limit(&maxX, uiInfo.serverStatus.motdPaintX, rect->y + rect->h - 3, scale, color, &uiInfo.serverStatus.motd[uiInfo.serverStatus.motdOffset], 0, 0, iMenuFont); 
+		if (uiInfo.serverStatus.motdPaintX2 >= 0) {
+			float maxX2 = rect->x + rect->w - 2;
+			Text_Paint_Limit(&maxX2, uiInfo.serverStatus.motdPaintX2, rect->y + rect->h - 3, scale, color, uiInfo.serverStatus.motd, 0, uiInfo.serverStatus.motdOffset, iMenuFont); 
+		}
+		if (uiInfo.serverStatus.motdOffset && maxX > 0) {
+			// if we have an offset ( we are skipping the first part of the string ) and we fit the string
+			if (uiInfo.serverStatus.motdPaintX2 == -1) {
+						uiInfo.serverStatus.motdPaintX2 = rect->x + rect->w - 2;
+			}
+		} else {
+			uiInfo.serverStatus.motdPaintX2 = -1;
+		}
+
+	}
+}
+
+static void UI_DrawKeyBindStatus(rectDef_t *rect, float scale, vec4_t color, int textStyle,int iMenuFont) {
+//	int ofs = 0; TTimo: unused
+	if (Display_KeyBindPending()) 
+	{
+		Text_Paint(rect->x, rect->y, scale, color, UI_GetStringEdString("MP_INGAME", "WAITING_FOR_NEW_KEY"), 0, 0, textStyle,iMenuFont);
+	} else {
+//		Text_Paint(rect->x, rect->y, scale, color, "Press ENTER or CLICK to change, Press BACKSPACE to clear", 0, 0, textStyle,iMenuFont);
+	}
+}
+
+static void UI_DrawGLInfo(rectDef_t *rect, float scale, vec4_t color, int textStyle,int iMenuFont) 
+{
+	char * eptr;
+	char buff[4096];
+	const char *lines[128];
+	int y, numLines, i;
+
+	Text_Paint(rect->x + 2, rect->y, scale, color, va("GL_VENDOR: %s", uiInfo.uiDC.glconfig.vendor_string), 0, rect->w, textStyle,iMenuFont);
+	Text_Paint(rect->x + 2, rect->y + 15, scale, color, va("GL_VERSION: %s: %s", uiInfo.uiDC.glconfig.version_string,uiInfo.uiDC.glconfig.renderer_string), 0, rect->w, textStyle,iMenuFont);
+	Text_Paint(rect->x + 2, rect->y + 30, scale, color, va ("GL_PIXELFORMAT: color(%d-bits) Z(%d-bits) stencil(%d-bits)", uiInfo.uiDC.glconfig.colorBits, uiInfo.uiDC.glconfig.depthBits, uiInfo.uiDC.glconfig.stencilBits), 0, rect->w, textStyle,iMenuFont);
+
+	// build null terminated extension strings
+	Q_strncpyz(buff, uiInfo.uiDC.glconfig.extensions_string, 4096);
+	eptr = buff;
+	y = rect->y + 45;
+	numLines = 0;
+	while ( y < rect->y + rect->h && *eptr )
+	{
+		while ( *eptr && *eptr == ' ' )
+			*eptr++ = '\0';
+
+		// track start of valid string
+		if (*eptr && *eptr != ' ') 
+		{
+			lines[numLines++] = eptr;
+		}
+
+		while ( *eptr && *eptr != ' ' )
+			eptr++;
+	}
+
+	i = 0;
+	while (i < numLines) 
+	{
+		Text_Paint(rect->x + 2, y, scale, color, lines[i++], 0, (rect->w/2), textStyle,iMenuFont);
+		if (i < numLines) 
+		{
+			Text_Paint(rect->x + rect->w / 2, y, scale, color, lines[i++], 0, (rect->w/2), textStyle,iMenuFont);
+		}
+		y += 10;
+		if (y > rect->y + rect->h - 11) 
+		{
+			break;
+		}
+	}
+
+
+}
+
+/*
+=================
+UI_Version
+=================
+*/
+static void UI_Version(rectDef_t *rect, float scale, vec4_t color, int iMenuFont) 
+{
+	int width;
+	
+	width = uiInfo.uiDC.textWidth(Q3_VERSION, scale, iMenuFont);
+
+	uiInfo.uiDC.drawText(rect->x - width, rect->y, scale, color, Q3_VERSION, 0, 0, 0, iMenuFont);
+}
+
+/*
+=================
+UI_OwnerDraw
+=================
+*/
+// FIXME: table drive
+//
+static void UI_OwnerDraw(float x, float y, float w, float h, float text_x, float text_y, int ownerDraw, int ownerDrawFlags, int align, float special, float scale, vec4_t color, qhandle_t shader, int textStyle,int iMenuFont) 
+{
+	rectDef_t rect;
+	int findex;
+	int drawRank = 0, iUse = 0;
+
+	rect.x = x + text_x;
+	rect.y = y + text_y;
+	rect.w = w;
+	rect.h = h;
+
+  switch (ownerDraw) 
+  {
+    case UI_HANDICAP:
+      UI_DrawHandicap(&rect, scale, color, textStyle, iMenuFont);
+      break;
+    case UI_SKIN_COLOR:
+      UI_DrawSkinColor(&rect, scale, color, textStyle, uiSkinColor, TEAM_FREE, TEAM_BLUE, iMenuFont);
+      break;
+	case UI_FORCE_SIDE:
+      UI_DrawForceSide(&rect, scale, color, textStyle, uiForceSide, 1, 2, iMenuFont);
+      break;
+	case UI_JEDI_NONJEDI:
+      UI_DrawJediNonJedi(&rect, scale, color, textStyle, uiJediNonJedi, 0, 1, iMenuFont);
+      break;
+    case UI_FORCE_POINTS:
+      UI_DrawGenericNum(&rect, scale, color, textStyle, uiForceAvailable, 1, forceMasteryPoints[MAX_FORCE_RANK], ownerDraw,iMenuFont);
+      break;
+	case UI_FORCE_MASTERY_SET:
+      UI_DrawForceMastery(&rect, scale, color, textStyle, uiForceRank, 0, MAX_FORCE_RANK, iMenuFont);
+      break;
+    case UI_FORCE_RANK:
+      UI_DrawForceMastery(&rect, scale, color, textStyle, uiForceRank, 0, MAX_FORCE_RANK, iMenuFont);
+      break;
+	case UI_FORCE_RANK_HEAL:
+	case UI_FORCE_RANK_LEVITATION:
+	case UI_FORCE_RANK_SPEED:
+	case UI_FORCE_RANK_PUSH:
+	case UI_FORCE_RANK_PULL:
+	case UI_FORCE_RANK_TELEPATHY:
+	case UI_FORCE_RANK_GRIP:
+	case UI_FORCE_RANK_LIGHTNING:
+	case UI_FORCE_RANK_RAGE:
+	case UI_FORCE_RANK_PROTECT:
+	case UI_FORCE_RANK_ABSORB:
+	case UI_FORCE_RANK_TEAM_HEAL:
+	case UI_FORCE_RANK_TEAM_FORCE:
+	case UI_FORCE_RANK_DRAIN:
+	case UI_FORCE_RANK_SEE:
+	case UI_FORCE_RANK_SABERATTACK:
+	case UI_FORCE_RANK_SABERDEFEND:
+	case UI_FORCE_RANK_SABERTHROW:
+
+//		uiForceRank
+/*
+		uiForceUsed
+		// Only fields for white stars
+		if (uiForceUsed<3)
+		{
+		    Menu_ShowItemByName(menu, "lightpowers_team", qtrue);
+		}
+		else if (uiForceUsed<6)
+		{
+		    Menu_ShowItemByName(menu, "lightpowers_team", qtrue);
+		}
+*/
+
+		findex = (ownerDraw - UI_FORCE_RANK)-1;
+		//this will give us the index as long as UI_FORCE_RANK is always one below the first force rank index
+		if (uiForcePowerDarkLight[findex] && uiForceSide != uiForcePowerDarkLight[findex])
+		{
+			color[0] *= 0.5;
+			color[1] *= 0.5;
+			color[2] *= 0.5;
+		}
+/*		else if (uiForceRank < UI_ForceColorMinRank[bgForcePowerCost[findex][FORCE_LEVEL_1]])
+		{
+			color[0] *= 0.5;
+			color[1] *= 0.5;
+			color[2] *= 0.5;
+		}
+*/		drawRank = uiForcePowersRank[findex];
+
+		UI_DrawForceStars(&rect, scale, color, textStyle, findex, drawRank, 0, NUM_FORCE_POWER_LEVELS-1);
+		break;
+    case UI_EFFECTS:
+      UI_DrawEffects(&rect, scale, color);
+      break;
+    case UI_PLAYERMODEL:
+      //UI_DrawPlayerModel(&rect);
+      break;
+    case UI_CLANNAME:
+      UI_DrawClanName(&rect, scale, color, textStyle, iMenuFont);
+      break;
+    case UI_CLANLOGO:
+      UI_DrawClanLogo(&rect, scale, color);
+      break;
+    case UI_CLANCINEMATIC:
+      UI_DrawClanCinematic(&rect, scale, color);
+      break;
+    case UI_PREVIEWCINEMATIC:
+      UI_DrawPreviewCinematic(&rect, scale, color);
+      break;
+    case UI_GAMETYPE:
+      UI_DrawGameType(&rect, scale, color, textStyle, iMenuFont);
+      break;
+    case UI_NETGAMETYPE:
+      UI_DrawNetGameType(&rect, scale, color, textStyle, iMenuFont);
+      break;
+    case UI_AUTOSWITCHLIST:
+      UI_DrawAutoSwitch(&rect, scale, color, textStyle, iMenuFont);
+      break;
+    case UI_JOINGAMETYPE:
+	  UI_DrawJoinGameType(&rect, scale, color, textStyle, iMenuFont);
+	  break;
+    case UI_MAPPREVIEW:
+      UI_DrawMapPreview(&rect, scale, color, qtrue);
+      break;
+    case UI_MAP_TIMETOBEAT:
+      UI_DrawMapTimeToBeat(&rect, scale, color, textStyle, iMenuFont);
+      break;
+    case UI_MAPCINEMATIC:
+      UI_DrawMapCinematic(&rect, scale, color, qfalse);
+      break;
+    case UI_STARTMAPCINEMATIC:
+      UI_DrawMapCinematic(&rect, scale, color, qtrue);
+      break;
+    case UI_SKILL:
+      UI_DrawSkill(&rect, scale, color, textStyle, iMenuFont);
+      break;
+    case UI_TOTALFORCESTARS:
+//      UI_DrawTotalForceStars(&rect, scale, color, textStyle);
+      break;
+    case UI_BLUETEAMNAME:
+      UI_DrawTeamName(&rect, scale, color, qtrue, textStyle, iMenuFont);
+      break;
+    case UI_REDTEAMNAME:
+      UI_DrawTeamName(&rect, scale, color, qfalse, textStyle, iMenuFont);
+      break;
+    case UI_BLUETEAM1:
+		case UI_BLUETEAM2:
+		case UI_BLUETEAM3:
+		case UI_BLUETEAM4:
+		case UI_BLUETEAM5:
+		case UI_BLUETEAM6:
+		case UI_BLUETEAM7:
+		case UI_BLUETEAM8:
+	if (ownerDraw <= UI_BLUETEAM5)
+	{
+	  iUse = ownerDraw-UI_BLUETEAM1 + 1;
+	}
+	else
+	{
+	  iUse = ownerDraw-274; //unpleasent hack because I don't want to move up all the UI_BLAHTEAM# defines
+	}
+      UI_DrawTeamMember(&rect, scale, color, qtrue, iUse, textStyle, iMenuFont);
+      break;
+    case UI_REDTEAM1:
+		case UI_REDTEAM2:
+		case UI_REDTEAM3:
+		case UI_REDTEAM4:
+		case UI_REDTEAM5:
+		case UI_REDTEAM6:
+		case UI_REDTEAM7:
+		case UI_REDTEAM8:
+	if (ownerDraw <= UI_REDTEAM5)
+	{
+	  iUse = ownerDraw-UI_REDTEAM1 + 1;
+	}
+	else
+	{
+	  iUse = ownerDraw-277; //unpleasent hack because I don't want to move up all the UI_BLAHTEAM# defines
+	}
+      UI_DrawTeamMember(&rect, scale, color, qfalse, iUse, textStyle, iMenuFont);
+      break;
+		case UI_NETSOURCE:
+      UI_DrawNetSource(&rect, scale, color, textStyle, iMenuFont);
+			break;
+    case UI_NETMAPPREVIEW:
+      UI_DrawNetMapPreview(&rect, scale, color);
+      break;
+    case UI_NETMAPCINEMATIC:
+      UI_DrawNetMapCinematic(&rect, scale, color);
+      break;
+		case UI_NETFILTER:
+      UI_DrawNetFilter(&rect, scale, color, textStyle, iMenuFont);
+			break;
+		case UI_TIER:
+			UI_DrawTier(&rect, scale, color, textStyle, iMenuFont);
+			break;
+		case UI_OPPONENTMODEL:
+			//UI_DrawOpponent(&rect);
+			break;
+		case UI_TIERMAP1:
+			UI_DrawTierMap(&rect, 0);
+			break;
+		case UI_TIERMAP2:
+			UI_DrawTierMap(&rect, 1);
+			break;
+		case UI_TIERMAP3:
+			UI_DrawTierMap(&rect, 2);
+			break;
+		case UI_PLAYERLOGO:
+			UI_DrawPlayerLogo(&rect, color);
+			break;
+		case UI_PLAYERLOGO_METAL:
+			UI_DrawPlayerLogoMetal(&rect, color);
+			break;
+		case UI_PLAYERLOGO_NAME:
+			UI_DrawPlayerLogoName(&rect, color);
+			break;
+		case UI_OPPONENTLOGO:
+			UI_DrawOpponentLogo(&rect, color);
+			break;
+		case UI_OPPONENTLOGO_METAL:
+			UI_DrawOpponentLogoMetal(&rect, color);
+			break;
+		case UI_OPPONENTLOGO_NAME:
+			UI_DrawOpponentLogoName(&rect, color);
+			break;
+		case UI_TIER_MAPNAME:
+			UI_DrawTierMapName(&rect, scale, color, textStyle, iMenuFont);
+			break;
+		case UI_TIER_GAMETYPE:
+			UI_DrawTierGameType(&rect, scale, color, textStyle, iMenuFont);
+			break;
+		case UI_ALLMAPS_SELECTION:
+			UI_DrawAllMapsSelection(&rect, scale, color, textStyle, qtrue, iMenuFont);
+			break;
+		case UI_MAPS_SELECTION:
+			UI_DrawAllMapsSelection(&rect, scale, color, textStyle, qfalse, iMenuFont);
+			break;
+		case UI_OPPONENT_NAME:
+			UI_DrawOpponentName(&rect, scale, color, textStyle, iMenuFont);
+			break;
+		case UI_BOTNAME:
+			UI_DrawBotName(&rect, scale, color, textStyle,iMenuFont);
+			break;
+		case UI_BOTSKILL:
+			UI_DrawBotSkill(&rect, scale, color, textStyle,iMenuFont);
+			break;
+		case UI_REDBLUE:
+			UI_DrawRedBlue(&rect, scale, color, textStyle,iMenuFont);
+			break;
+		case UI_CROSSHAIR:
+			UI_DrawCrosshair(&rect, scale, color);
+			break;
+		case UI_SELECTEDPLAYER:
+			UI_DrawSelectedPlayer(&rect, scale, color, textStyle, iMenuFont);
+			break;
+		case UI_SERVERREFRESHDATE:
+			UI_DrawServerRefreshDate(&rect, scale, color, textStyle, iMenuFont);
+			break;
+		case UI_SERVERMOTD:
+			UI_DrawServerMOTD(&rect, scale, color, iMenuFont);
+			break;
+		case UI_GLINFO:
+			UI_DrawGLInfo(&rect,scale, color, textStyle, iMenuFont);
+			break;
+		case UI_KEYBINDSTATUS:
+			UI_DrawKeyBindStatus(&rect,scale, color, textStyle,iMenuFont);
+			break;
+		case UI_VERSION:
+			UI_Version(&rect, scale, color, iMenuFont);
+			break;
+    default:
+      break;
+  }
+
+}
+
+static qboolean UI_OwnerDrawVisible(int flags) {
+	qboolean vis = qtrue;
+
+	while (flags) {
+
+		if (flags & UI_SHOW_FFA) {
+			if (trap_Cvar_VariableValue("g_gametype") != GT_FFA && trap_Cvar_VariableValue("g_gametype") != GT_HOLOCRON && trap_Cvar_VariableValue("g_gametype") != GT_JEDIMASTER) {
+				vis = qfalse;
+			}
+			flags &= ~UI_SHOW_FFA;
+		}
+
+		if (flags & UI_SHOW_NOTFFA) {
+			if (trap_Cvar_VariableValue("g_gametype") == GT_FFA || trap_Cvar_VariableValue("g_gametype") == GT_HOLOCRON || trap_Cvar_VariableValue("g_gametype") != GT_JEDIMASTER) {
+				vis = qfalse;
+			}
+			flags &= ~UI_SHOW_NOTFFA;
+		}
+
+		if (flags & UI_SHOW_LEADER) {
+			// these need to show when this client can give orders to a player or a group
+			if (!uiInfo.teamLeader) {
+				vis = qfalse;
+			} else {
+				// if showing yourself
+				if (ui_selectedPlayer.integer < uiInfo.myTeamCount && uiInfo.teamClientNums[ui_selectedPlayer.integer] == uiInfo.playerNumber) { 
+					vis = qfalse;
+				}
+			}
+			flags &= ~UI_SHOW_LEADER;
+		} 
+		if (flags & UI_SHOW_NOTLEADER) {
+			// these need to show when this client is assigning their own status or they are NOT the leader
+			if (uiInfo.teamLeader) {
+				// if not showing yourself
+				if (!(ui_selectedPlayer.integer < uiInfo.myTeamCount && uiInfo.teamClientNums[ui_selectedPlayer.integer] == uiInfo.playerNumber)) { 
+					vis = qfalse;
+				}
+				// these need to show when this client can give orders to a player or a group
+			}
+			flags &= ~UI_SHOW_NOTLEADER;
+		} 
+		if (flags & UI_SHOW_FAVORITESERVERS) {
+			// this assumes you only put this type of display flag on something showing in the proper context
+			if (ui_netSource.integer != AS_FAVORITES) {
+				vis = qfalse;
+			}
+			flags &= ~UI_SHOW_FAVORITESERVERS;
+		} 
+		if (flags & UI_SHOW_NOTFAVORITESERVERS) {
+			// this assumes you only put this type of display flag on something showing in the proper context
+			if (ui_netSource.integer == AS_FAVORITES) {
+				vis = qfalse;
+			}
+			flags &= ~UI_SHOW_NOTFAVORITESERVERS;
+		} 
+		if (flags & UI_SHOW_ANYTEAMGAME) {
+			if (uiInfo.gameTypes[ui_gameType.integer].gtEnum <= GT_TEAM ) {
+				vis = qfalse;
+			}
+			flags &= ~UI_SHOW_ANYTEAMGAME;
+		} 
+		if (flags & UI_SHOW_ANYNONTEAMGAME) {
+			if (uiInfo.gameTypes[ui_gameType.integer].gtEnum > GT_TEAM ) {
+				vis = qfalse;
+			}
+			flags &= ~UI_SHOW_ANYNONTEAMGAME;
+		} 
+		if (flags & UI_SHOW_NETANYTEAMGAME) {
+			if (uiInfo.gameTypes[ui_netGameType.integer].gtEnum <= GT_TEAM ) {
+				vis = qfalse;
+			}
+			flags &= ~UI_SHOW_NETANYTEAMGAME;
+		} 
+		if (flags & UI_SHOW_NETANYNONTEAMGAME) {
+			if (uiInfo.gameTypes[ui_netGameType.integer].gtEnum > GT_TEAM ) {
+				vis = qfalse;
+			}
+			flags &= ~UI_SHOW_NETANYNONTEAMGAME;
+		} 
+		if (flags & UI_SHOW_NEWHIGHSCORE) {
+			if (uiInfo.newHighScoreTime < uiInfo.uiDC.realTime) {
+				vis = qfalse;
+			} else {
+				if (uiInfo.soundHighScore) {
+					if (trap_Cvar_VariableValue("sv_killserver") == 0) {
+						// wait on server to go down before playing sound
+						//trap_S_StartLocalSound(uiInfo.newHighScoreSound, CHAN_ANNOUNCER);
+						uiInfo.soundHighScore = qfalse;
+					}
+				}
+			}
+			flags &= ~UI_SHOW_NEWHIGHSCORE;
+		} 
+		if (flags & UI_SHOW_NEWBESTTIME) {
+			if (uiInfo.newBestTime < uiInfo.uiDC.realTime) {
+				vis = qfalse;
+			}
+			flags &= ~UI_SHOW_NEWBESTTIME;
+		} 
+		if (flags & UI_SHOW_DEMOAVAILABLE) {
+			if (!uiInfo.demoAvailable) {
+				vis = qfalse;
+			}
+			flags &= ~UI_SHOW_DEMOAVAILABLE;
+		} else {
+			flags = 0;
+		}
+	}
+  return vis;
+}
+
+static qboolean UI_Handicap_HandleKey(int flags, float *special, int key) {
+  if (key == A_MOUSE1 || key == A_MOUSE2 || key == A_ENTER || key == A_KP_ENTER) {
+    int h;
+    h = Com_Clamp( 5, 100, trap_Cvar_VariableValue("handicap") );
+		if (key == A_MOUSE2) {
+	    h -= 5;
+		} else {
+	    h += 5;
+		}
+    if (h > 100) {
+      h = 5;
+    } else if (h < 0) {
+			h = 100;
+		}
+  	trap_Cvar_Set( "handicap", va( "%i", h) );
+    return qtrue;
+  }
+  return qfalse;
+}
+
+static qboolean UI_Effects_HandleKey(int flags, float *special, int key) {
+	if (key == A_MOUSE1 || key == A_MOUSE2 || key == A_ENTER || key == A_KP_ENTER) {
+		
+		if ( !UI_TrueJediEnabled() )
+		{
+			int team = (int)(trap_Cvar_VariableValue("ui_myteam"));
+					
+			if (team == TEAM_RED || team==TEAM_BLUE)
+			{
+				return qfalse;
+			}
+		}
+				
+		if (key == A_MOUSE2) {
+			uiInfo.effectsColor--;
+		} else {
+			uiInfo.effectsColor++;
+		}
+		
+		if( uiInfo.effectsColor > 5 ) {
+			uiInfo.effectsColor = 0;
+		} else if (uiInfo.effectsColor < 0) {
+			uiInfo.effectsColor = 5;
+		}
+		
+		trap_Cvar_SetValue( "color1", /*uitogamecode[uiInfo.effectsColor]*/uiInfo.effectsColor );
+		return qtrue;
+	}
+	return qfalse;
+}
+
+#include "../namespace_begin.h"
+extern void	Item_RunScript(itemDef_t *item, const char *s);		//from ui_shared;
+#include "../namespace_end.h"
+
+// For hot keys on the chat main menu.
+static qboolean UI_Chat_Main_HandleKey(int key) 
+{
+	menuDef_t *menu;
+	itemDef_t *item;
+
+	menu = Menu_GetFocused();	
+
+	if (!menu)
+	{
+		return (qfalse);
+	}
+
+	if ((key == A_1) || ( key == A_PLING))
+	{
+		item = Menu_FindItemByName(menu, "attack");
+	}
+	else if ((key == A_2) || ( key == A_AT))
+	{
+		item = Menu_FindItemByName(menu, "defend");
+	}
+	else if ((key == A_3) || ( key == A_HASH))
+	{
+		item = Menu_FindItemByName(menu, "request");
+	}
+	else if ((key == A_4) || ( key == A_STRING))
+	{
+		item = Menu_FindItemByName(menu, "reply");
+	}
+	else if ((key == A_5) || ( key == A_PERCENT))
+	{
+		item = Menu_FindItemByName(menu, "spot");
+	}
+	else if ((key == A_6) || ( key == A_CARET))
+	{
+		item = Menu_FindItemByName(menu, "tactics");
+	}
+	else
+	{
+		return (qfalse);
+	}
+
+	if (item)
+	{
+	    Item_RunScript(item, item->action);
+	}
+
+	return (qtrue);
+}
+
+// For hot keys on the chat main menu.
+static qboolean UI_Chat_Attack_HandleKey(int key) 
+{
+	menuDef_t *menu;
+	itemDef_t *item;
+
+	menu = Menu_GetFocused();	
+
+	if (!menu)
+	{
+		return (qfalse);
+	}
+
+	if ((key == A_1) || ( key == A_PLING))
+	{
+		item = Menu_FindItemByName(menu, "att_01");
+	}
+	else if ((key == A_2) || ( key == A_AT))
+	{
+		item = Menu_FindItemByName(menu, "att_02");
+	}
+	else if ((key == A_3) || ( key == A_HASH))
+	{
+		item = Menu_FindItemByName(menu, "att_03");
+	}
+	else
+	{
+		return (qfalse);
+	}
+
+	if (item)
+	{
+	    Item_RunScript(item, item->action);
+	}
+
+	return (qtrue);
+}
+
+// For hot keys on the chat main menu.
+static qboolean UI_Chat_Defend_HandleKey(int key) 
+{
+	menuDef_t *menu;
+	itemDef_t *item;
+
+	menu = Menu_GetFocused();	
+
+	if (!menu)
+	{
+		return (qfalse);
+	}
+
+	if ((key == A_1) || ( key == A_PLING))
+	{
+		item = Menu_FindItemByName(menu, "def_01");
+	}
+	else if ((key == A_2) || ( key == A_AT))
+	{
+		item = Menu_FindItemByName(menu, "def_02");
+	}
+	else if ((key == A_3) || ( key == A_HASH))
+	{
+		item = Menu_FindItemByName(menu, "def_03");
+	}
+	else if ((key == A_4) || ( key == A_STRING))
+	{
+		item = Menu_FindItemByName(menu, "def_04");
+	}
+	else
+	{
+		return (qfalse);
+	}
+
+	if (item)
+	{
+	    Item_RunScript(item, item->action);
+	}
+
+	return (qtrue);
+}
+
+// For hot keys on the chat main menu.
+static qboolean UI_Chat_Request_HandleKey(int key) 
+{
+	menuDef_t *menu;
+	itemDef_t *item;
+
+	menu = Menu_GetFocused();	
+
+	if (!menu)
+	{
+		return (qfalse);
+	}
+
+	if ((key == A_1) || ( key == A_PLING))
+	{
+		item = Menu_FindItemByName(menu, "req_01");
+	}
+	else if ((key == A_2) || ( key == A_AT))
+	{
+		item = Menu_FindItemByName(menu, "req_02");
+	}
+	else if ((key == A_3) || ( key == A_HASH))
+	{
+		item = Menu_FindItemByName(menu, "req_03");
+	}
+	else if ((key == A_4) || ( key == A_STRING))
+	{
+		item = Menu_FindItemByName(menu, "req_04");
+	}
+	else if ((key == A_5) || ( key == A_PERCENT))
+	{
+		item = Menu_FindItemByName(menu, "req_05");
+	}
+	else if ((key == A_6) || ( key == A_CARET))
+	{
+		item = Menu_FindItemByName(menu, "req_06");
+	}
+	else
+	{
+		return (qfalse);
+	}
+
+	if (item)
+	{
+	    Item_RunScript(item, item->action);
+	}
+
+	return (qtrue);
+}
+
+// For hot keys on the chat main menu.
+static qboolean UI_Chat_Reply_HandleKey(int key) 
+{
+	menuDef_t *menu;
+	itemDef_t *item;
+
+	menu = Menu_GetFocused();	
+
+	if (!menu)
+	{
+		return (qfalse);
+	}
+
+	if ((key == A_1) || ( key == A_PLING))
+	{
+		item = Menu_FindItemByName(menu, "rep_01");
+	}
+	else if ((key == A_2) || ( key == A_AT))
+	{
+		item = Menu_FindItemByName(menu, "rep_02");
+	}
+	else if ((key == A_3) || ( key == A_HASH))
+	{
+		item = Menu_FindItemByName(menu, "rep_03");
+	}
+	else if ((key == A_4) || ( key == A_STRING))
+	{
+		item = Menu_FindItemByName(menu, "rep_04");
+	}
+	else if ((key == A_5) || ( key == A_PERCENT))
+	{
+		item = Menu_FindItemByName(menu, "rep_05");
+	}
+	else
+	{
+		return (qfalse);
+	}
+
+	if (item)
+	{
+	    Item_RunScript(item, item->action);
+	}
+
+	return (qtrue);
+}
+
+// For hot keys on the chat main menu.
+static qboolean UI_Chat_Spot_HandleKey(int key) 
+{
+	menuDef_t *menu;
+	itemDef_t *item;
+
+	menu = Menu_GetFocused();	
+
+	if (!menu)
+	{
+		return (qfalse);
+	}
+
+	if ((key == A_1) || ( key == A_PLING))
+	{
+		item = Menu_FindItemByName(menu, "spot_01");
+	}
+	else if ((key == A_2) || ( key == A_AT))
+	{
+		item = Menu_FindItemByName(menu, "spot_02");
+	}
+	else if ((key == A_3) || ( key == A_HASH))
+	{
+		item = Menu_FindItemByName(menu, "spot_03");
+	}
+	else if ((key == A_4) || ( key == A_STRING))
+	{
+		item = Menu_FindItemByName(menu, "spot_04");
+	}
+	else
+	{
+		return (qfalse);
+	}
+
+	if (item)
+	{
+	    Item_RunScript(item, item->action);
+	}
+
+	return (qtrue);
+}
+
+// For hot keys on the chat main menu.
+static qboolean UI_Chat_Tactical_HandleKey(int key) 
+{
+	menuDef_t *menu;
+	itemDef_t *item;
+
+	menu = Menu_GetFocused();	
+
+	if (!menu)
+	{
+		return (qfalse);
+	}
+
+	if ((key == A_1) || ( key == A_PLING))
+	{
+		item = Menu_FindItemByName(menu, "tac_01");
+	}
+	else if ((key == A_2) || ( key == A_AT))
+	{
+		item = Menu_FindItemByName(menu, "tac_02");
+	}
+	else if ((key == A_3) || ( key == A_HASH))
+	{
+		item = Menu_FindItemByName(menu, "tac_03");
+	}
+	else if ((key == A_4) || ( key == A_STRING))
+	{
+		item = Menu_FindItemByName(menu, "tac_04");
+	}
+	else if ((key == A_5) || ( key == A_PERCENT))
+	{
+		item = Menu_FindItemByName(menu, "tac_05");
+	}
+	else if ((key == A_6) || ( key == A_CARET))
+	{
+		item = Menu_FindItemByName(menu, "tac_06");
+	}
+	else
+	{
+		return (qfalse);
+	}
+
+	if (item)
+	{
+	    Item_RunScript(item, item->action);
+	}
+
+	return (qtrue);
+}
+
+static qboolean UI_GameType_HandleKey(int flags, float *special, int key, qboolean resetMap) {
+  if (key == A_MOUSE1 || key == A_MOUSE2 || key == A_ENTER || key == A_KP_ENTER) {
+		int oldCount = UI_MapCountByGameType(qtrue);
+
+		// hard coded mess here
+		if (key == A_MOUSE2) {
+			ui_gameType.integer--;
+			if (ui_gameType.integer == 2) {
+				ui_gameType.integer = 1;
+			} else if (ui_gameType.integer < 2) {
+				ui_gameType.integer = uiInfo.numGameTypes - 1;
+			}
+		} else {
+			ui_gameType.integer++;
+			if (ui_gameType.integer >= uiInfo.numGameTypes) {
+				ui_gameType.integer = 1;
+			} else if (ui_gameType.integer == 2) {
+				ui_gameType.integer = 3;
+			}
+		}
+    
+		trap_Cvar_Set("ui_gameType", va("%d", ui_gameType.integer));
+		UI_SetCapFragLimits(qtrue);
+		UI_LoadBestScores(uiInfo.mapList[ui_currentMap.integer].mapLoadName, uiInfo.gameTypes[ui_gameType.integer].gtEnum);
+		if (resetMap && oldCount != UI_MapCountByGameType(qtrue)) {
+	  	trap_Cvar_Set( "ui_currentMap", "0");
+			Menu_SetFeederSelection(NULL, FEEDER_MAPS, 0, NULL);
+		}
+    return qtrue;
+  }
+  return qfalse;
+}
+
+// If we're in the solo menu, don't let them see siege maps.
+static qboolean UI_InSoloMenu( void )
+{
+	menuDef_t *menu;
+	itemDef_t *item;
+	char *name = "solo_gametypefield";
+
+	menu = Menu_GetFocused();	// Get current menu (either video or ingame video, I would assume)
+
+	if (!menu)
+	{
+		return (qfalse);
+	}
+
+	item = Menu_FindItemByName(menu, name);
+	if (item)
+	{
+		return qtrue;
+	}
+
+	return (qfalse);
+}
+
+static qboolean UI_NetGameType_HandleKey(int flags, float *special, int key) 
+{
+#ifdef _XBOX
+  if (key == A_CURSOR_RIGHT || key == A_CURSOR_LEFT)
+#else
+  if (key == A_MOUSE1 || key == A_MOUSE2 || key == A_ENTER || key == A_KP_ENTER) 
+#endif
+  {
+
+#ifdef _XBOX
+	if (key == A_CURSOR_LEFT) 
+#else
+	if (key == A_MOUSE2) 
+#endif
+	{
+		ui_netGameType.integer--;
+		if (UI_InSoloMenu())
+		{
+			if (uiInfo.gameTypes[ui_netGameType.integer].gtEnum == GT_SIEGE)
+			{
+				ui_netGameType.integer--;
+			}
+		}
+	} 
+	else 
+	{
+		ui_netGameType.integer++;
+		if (UI_InSoloMenu())
+		{
+			if (uiInfo.gameTypes[ui_netGameType.integer].gtEnum == GT_SIEGE)
+			{
+				ui_netGameType.integer++;
+			}
+		}
+	}
+
+    if (ui_netGameType.integer < 0) 
+	{
+		ui_netGameType.integer = uiInfo.numGameTypes - 1;
+	} 
+	else if (ui_netGameType.integer >= uiInfo.numGameTypes) 
+	{
+		ui_netGameType.integer = 0;
+    } 
+
+  	trap_Cvar_Set( "ui_netGameType", va("%d", ui_netGameType.integer));
+  	trap_Cvar_Set( "ui_actualnetGameType", va("%d", uiInfo.gameTypes[ui_netGameType.integer].gtEnum));
+  	trap_Cvar_Set( "ui_currentNetMap", "0");
+		UI_MapCountByGameType(qfalse);
+		Menu_SetFeederSelection(NULL, FEEDER_ALLMAPS, 0, NULL);
+    return qtrue;
+  }
+  return qfalse;
+}
+
+static qboolean UI_AutoSwitch_HandleKey(int flags, float *special, int key) {
+  if (key == A_MOUSE1 || key == A_MOUSE2 || key == A_ENTER || key == A_KP_ENTER) {
+	 int switchVal = trap_Cvar_VariableValue("cg_autoswitch");
+
+		if (key == A_MOUSE2) {
+			switchVal--;
+		} else {
+			switchVal++;
+		}
+
+    if (switchVal < 0)
+	{
+		switchVal = 2;
+	}
+	else if (switchVal >= 3)
+	{
+      switchVal = 0;
+    } 
+
+  	trap_Cvar_Set( "cg_autoswitch", va("%i", switchVal));
+    return qtrue;
+  }
+  return qfalse;
+}
+
+static qboolean UI_JoinGameType_HandleKey(int flags, float *special, int key) {
+	if (key == A_MOUSE1 || key == A_MOUSE2 || key == A_ENTER || key == A_KP_ENTER) {
+
+		if (key == A_MOUSE2) {
+			ui_joinGameType.integer--;
+		} else {
+			ui_joinGameType.integer++;
+		}
+
+		if (ui_joinGameType.integer < 0) {
+			ui_joinGameType.integer = uiInfo.numJoinGameTypes - 1;
+		} else if (ui_joinGameType.integer >= uiInfo.numJoinGameTypes) {
+			ui_joinGameType.integer = 0;
+		}
+
+		trap_Cvar_Set( "ui_joinGameType", va("%d", ui_joinGameType.integer));
+		UI_BuildServerDisplayList(qtrue);
+		return qtrue;
+	}
+	return qfalse;
+}
+
+
+
+static qboolean UI_Skill_HandleKey(int flags, float *special, int key) {
+  if (key == A_MOUSE1 || key == A_MOUSE2 || key == A_ENTER || key == A_KP_ENTER) {
+  	int i = trap_Cvar_VariableValue( "g_spSkill" );
+
+		if (key == A_MOUSE2) {
+	    i--;
+		} else {
+	    i++;
+		}
+
+    if (i < 1) {
+			i = numSkillLevels;
+		} else if (i > numSkillLevels) {
+      i = 1;
+    }
+
+    trap_Cvar_Set("g_spSkill", va("%i", i));
+    return qtrue;
+  }
+  return qfalse;
+}
+
+
+static qboolean UI_TeamName_HandleKey(int flags, float *special, int key, qboolean blue) {
+  if (key == A_MOUSE1 || key == A_MOUSE2 || key == A_ENTER || key == A_KP_ENTER) {
+    int i;
+    i = UI_TeamIndexFromName(UI_Cvar_VariableString((blue) ? "ui_blueTeam" : "ui_redTeam"));
+
+		if (key == A_MOUSE2) {
+	    i--;
+		} else {
+	    i++;
+		}
+
+    if (i >= uiInfo.teamCount) {
+      i = 0;
+    } else if (i < 0) {
+			i = uiInfo.teamCount - 1;
+		}
+
+    trap_Cvar_Set( (blue) ? "ui_blueTeam" : "ui_redTeam", uiInfo.teamList[i].teamName);
+
+    return qtrue;
+  }
+  return qfalse;
+}
+
+static qboolean UI_TeamMember_HandleKey(int flags, float *special, int key, qboolean blue, int num) {
+  if (key == A_MOUSE1 || key == A_MOUSE2 || key == A_ENTER || key == A_KP_ENTER) {
+		// 0 - None
+		// 1 - Human
+		// 2..NumCharacters - Bot
+		char *cvar = va(blue ? "ui_blueteam%i" : "ui_redteam%i", num);
+		int value = trap_Cvar_VariableValue(cvar);
+		int maxcl = trap_Cvar_VariableValue( "sv_maxClients" );
+		int numval = num;
+
+		numval *= 2;
+
+		if (blue)
+		{
+			numval -= 1;
+		}
+
+		if (numval > maxcl)
+		{
+			return qfalse;
+		}
+
+		if (value < 1)
+		{
+			value = 1;
+		}
+
+		if (key == A_MOUSE2) {
+			value--;
+		} else {
+			value++;
+		}
+
+		/*if (ui_actualNetGameType.integer >= GT_TEAM) {
+			if (value >= uiInfo.characterCount + 2) {
+				value = 0;
+			} else if (value < 0) {
+				value = uiInfo.characterCount + 2 - 1;
+			}
+		} else {*/
+			if (value >= UI_GetNumBots() + 2) {
+				value = 1;
+			} else if (value < 1) {
+				value = UI_GetNumBots() + 2 - 1;
+			}
+		//}
+
+		trap_Cvar_Set(cvar, va("%i", value));
+    return qtrue;
+  }
+  return qfalse;
+}
+
+static qboolean UI_NetSource_HandleKey(int flags, float *special, int key) {
+  if (key == A_MOUSE1 || key == A_MOUSE2 || key == A_ENTER || key == A_KP_ENTER) {
+		
+		if (key == A_MOUSE2) {
+			ui_netSource.integer--;
+		} else {
+			ui_netSource.integer++;
+		}
+    
+		if (ui_netSource.integer >= numNetSources) {
+      ui_netSource.integer = 0;
+    } else if (ui_netSource.integer < 0) {
+      ui_netSource.integer = numNetSources - 1;
+		}
+
+		UI_BuildServerDisplayList(qtrue);
+		if (ui_netSource.integer != AS_GLOBAL) {
+			UI_StartServerRefresh(qtrue);
+		}
+  	trap_Cvar_Set( "ui_netSource", va("%d", ui_netSource.integer));
+    return qtrue;
+  }
+  return qfalse;
+}
+
+static qboolean UI_NetFilter_HandleKey(int flags, float *special, int key) {
+  if (key == A_MOUSE1 || key == A_MOUSE2 || key == A_ENTER || key == A_KP_ENTER) {
+
+		if (key == A_MOUSE2) {
+			ui_serverFilterType.integer--;
+		} else {
+			ui_serverFilterType.integer++;
+		}
+
+    if (ui_serverFilterType.integer >= numServerFilters) {
+      ui_serverFilterType.integer = 0;
+    } else if (ui_serverFilterType.integer < 0) {
+      ui_serverFilterType.integer = numServerFilters - 1;
+		}
+		UI_BuildServerDisplayList(qtrue);
+    return qtrue;
+  }
+  return qfalse;
+}
+
+static qboolean UI_OpponentName_HandleKey(int flags, float *special, int key) {
+  if (key == A_MOUSE1 || key == A_MOUSE2 || key == A_ENTER || key == A_KP_ENTER) {
+		if (key == A_MOUSE2) {
+			UI_PriorOpponent();
+		} else {
+			UI_NextOpponent();
+		}
+    return qtrue;
+  }
+  return qfalse;
+}
+
+static qboolean UI_BotName_HandleKey(int flags, float *special, int key) {
+  if (key == A_MOUSE1 || key == A_MOUSE2 || key == A_ENTER || key == A_KP_ENTER) {
+//		int game = trap_Cvar_VariableValue("g_gametype");
+		int value = uiInfo.botIndex;
+
+		if (key == A_MOUSE2) {
+			value--;
+		} else {
+			value++;
+		}
+
+		/*
+		if (game >= GT_TEAM) {
+			if (value >= uiInfo.characterCount + 2) {
+				value = 0;
+			} else if (value < 0) {
+				value = uiInfo.characterCount + 2 - 1;
+			}
+		} else {
+		*/
+			if (value >= UI_GetNumBots()/* + 2*/) {
+				value = 0;
+			} else if (value < 0) {
+				value = UI_GetNumBots()/* + 2*/ - 1;
+			}
+		//}
+		uiInfo.botIndex = value;
+    return qtrue;
+  }
+  return qfalse;
+}
+
+static qboolean UI_BotSkill_HandleKey(int flags, float *special, int key) {
+  if (key == A_MOUSE1 || key == A_MOUSE2 || key == A_ENTER || key == A_KP_ENTER) {
+		if (key == A_MOUSE2) {
+			uiInfo.skillIndex--;
+		} else {
+			uiInfo.skillIndex++;
+		}
+		if (uiInfo.skillIndex >= numSkillLevels) {
+			uiInfo.skillIndex = 0;
+		} else if (uiInfo.skillIndex < 0) {
+			uiInfo.skillIndex = numSkillLevels-1;
+		}
+    return qtrue;
+  }
+	return qfalse;
+}
+
+static qboolean UI_RedBlue_HandleKey(int flags, float *special, int key) {
+  if (key == A_MOUSE1 || key == A_MOUSE2 || key == A_ENTER || key == A_KP_ENTER) {
+		uiInfo.redBlue ^= 1;
+		return qtrue;
+	}
+	return qfalse;
+}
+
+static qboolean UI_Crosshair_HandleKey(int flags, float *special, int key) {
+  if (key == A_MOUSE1 || key == A_MOUSE2 || key == A_ENTER || key == A_KP_ENTER) {
+		if (key == A_MOUSE2) {
+			uiInfo.currentCrosshair--;
+		} else {
+			uiInfo.currentCrosshair++;
+		}
+
+		if (uiInfo.currentCrosshair >= NUM_CROSSHAIRS) {
+			uiInfo.currentCrosshair = 0;
+		} else if (uiInfo.currentCrosshair < 0) {
+			uiInfo.currentCrosshair = NUM_CROSSHAIRS - 1;
+		}
+		trap_Cvar_Set("cg_drawCrosshair", va("%d", uiInfo.currentCrosshair)); 
+		return qtrue;
+	}
+	return qfalse;
+}
+
+
+
+static qboolean UI_SelectedPlayer_HandleKey(int flags, float *special, int key) {
+  if (key == A_MOUSE1 || key == A_MOUSE2 || key == A_ENTER || key == A_KP_ENTER) {
+		int selected;
+
+		UI_BuildPlayerList();
+		if (!uiInfo.teamLeader) {
+			return qfalse;
+		}
+		selected = trap_Cvar_VariableValue("cg_selectedPlayer");
+		
+		if (key == A_MOUSE2) {
+			selected--;
+		} else {
+			selected++;
+		}
+
+		if (selected > uiInfo.myTeamCount) {
+			selected = 0;
+		} else if (selected < 0) {
+			selected = uiInfo.myTeamCount;
+		}
+
+		if (selected == uiInfo.myTeamCount) {
+		 	trap_Cvar_Set( "cg_selectedPlayerName", "Everyone");
+		} else {
+		 	trap_Cvar_Set( "cg_selectedPlayerName", uiInfo.teamNames[selected]);
+		}
+	 	trap_Cvar_Set( "cg_selectedPlayer", va("%d", selected));
+	}
+	return qfalse;
+}
+
+/*
+static qboolean UI_VoiceChat_HandleKey(int flags, float *special, int key)
+{
+
+	qboolean ret = qfalse;
+
+	switch(key)
+	{
+		case A_1:
+		case A_KP_1:
+			ret = qtrue;
+			break;
+		case A_2:
+		case A_KP_2:
+			ret = qtrue;
+			break;
+
+	}
+  
+	return ret;
+}
+*/
+
+
+#ifdef _XBOX
+static qboolean UI_XboxPasscode_HandleKey(int flags, float *special, int key)
+{
+	static BYTE passcode[XONLINE_PASSCODE_LENGTH];
+	int passcodeState = trap_Cvar_VariableValue( "xb_passcodeState" );
+
+	// If the user hasn't entered a full passcode yet
+	if (passcodeState >= 0 && passcodeState <= 3)
+	{
+		switch (key)
+		{
+			// Undo our stupid UI joy2key mapping that was done in the input system
+			case A_CURSOR_DOWN:
+				passcode[passcodeState++] = XONLINE_PASSCODE_DPAD_DOWN; break;
+			case A_CURSOR_LEFT:
+				passcode[passcodeState++] = XONLINE_PASSCODE_DPAD_LEFT; break;
+			case A_CURSOR_RIGHT:
+				passcode[passcodeState++] = XONLINE_PASSCODE_DPAD_RIGHT; break;
+			case A_CURSOR_UP:
+				passcode[passcodeState++] = XONLINE_PASSCODE_DPAD_UP; break;
+			case A_PAGE_UP:
+				passcode[passcodeState++] = XONLINE_PASSCODE_GAMEPAD_LEFT_TRIGGER; break;
+			case A_PAGE_DOWN:
+				passcode[passcodeState++] = XONLINE_PASSCODE_GAMEPAD_RIGHT_TRIGGER; break;
+			case A_DELETE:
+				passcode[passcodeState++] = XONLINE_PASSCODE_GAMEPAD_X; break;
+			case A_BACKSPACE:
+				passcode[passcodeState++] = XONLINE_PASSCODE_GAMEPAD_Y; break;
+			default:
+				// No other button (including "A") does anything here
+				return qfalse;
+		}
+
+		// User has incremented passcodeState - change the cvar, and we're done
+		trap_Cvar_Set( "xb_passcodeState", va("%d", passcodeState) );
+		return qtrue;
+	}
+
+	// If the user has a full passcode on screen:
+	if (passcodeState == 4)
+	{
+		// Pressing "A" tests the code. Every other button does nothing
+		if (key != A_MOUSE1)
+			return qfalse;
+
+		// Test the passcode
+		XONLINE_USER *pUser = XBL_GetUserInfo( XBL_GetSelectedAccountIndex() );
+		if (memcmp(pUser->passcode, passcode, sizeof(passcode)) == 0)
+		{
+			// Success - resume logging in
+			Menus_CloseByName( "xbox_passcode" );
+			XBL_Login( LOGIN_CONNECT );
+			return qtrue;
+		}
+		else
+		{
+			// Wrong - set state to invalid - so menu changes
+			trap_Cvar_Set( "xb_passcodeState", "5" );
+			return qtrue;
+		}
+	}
+
+	// If the user had already entered an invalid passcode
+	if (passcodeState == 5)
+	{
+		// Pressing "A" brings them back to the beginning, to try again.
+		// All other buttons do nothing
+		if (key != A_MOUSE1)
+			return qfalse;
+
+		trap_Cvar_Set( "xb_passcodeState", "0" );
+		return qtrue;
+	}
+
+	// No other state is valid!
+	assert( 0 );
+	return qfalse;
+}
+#endif
+
+
+static qboolean UI_OwnerDrawHandleKey(int ownerDraw, int flags, float *special, int key) {
+	int findex, iUse = 0;
+
+  switch (ownerDraw) {
+    case UI_HANDICAP:
+      return UI_Handicap_HandleKey(flags, special, key);
+      break;
+    case UI_SKIN_COLOR:
+      return UI_SkinColor_HandleKey(flags, special, key, uiSkinColor, TEAM_FREE, TEAM_BLUE, ownerDraw);
+      break;
+    case UI_FORCE_SIDE:
+      return UI_ForceSide_HandleKey(flags, special, key, uiForceSide, 1, 2, ownerDraw);
+      break;
+    case UI_JEDI_NONJEDI:
+      return UI_JediNonJedi_HandleKey(flags, special, key, uiJediNonJedi, 0, 1, ownerDraw);
+      break;
+	case UI_FORCE_MASTERY_SET:
+      return UI_ForceMaxRank_HandleKey(flags, special, key, uiForceRank, 1, MAX_FORCE_RANK, ownerDraw);
+      break;
+    case UI_FORCE_RANK:
+		break;		
+	case UI_CHAT_MAIN:
+		return UI_Chat_Main_HandleKey(key);
+		break;
+	case UI_CHAT_ATTACK:
+		return UI_Chat_Attack_HandleKey(key);
+		break;
+	case UI_CHAT_DEFEND:
+		return UI_Chat_Defend_HandleKey(key);
+		break;
+	case UI_CHAT_REQUEST:
+		return UI_Chat_Request_HandleKey(key);
+		break;
+	case UI_CHAT_REPLY:
+		return UI_Chat_Reply_HandleKey(key);
+		break;
+	case UI_CHAT_SPOT:
+		return UI_Chat_Spot_HandleKey(key);
+		break;
+	case UI_CHAT_TACTICAL:
+		return UI_Chat_Tactical_HandleKey(key);
+		break;
+	case UI_FORCE_RANK_HEAL:
+	case UI_FORCE_RANK_LEVITATION:
+	case UI_FORCE_RANK_SPEED:
+	case UI_FORCE_RANK_PUSH:
+	case UI_FORCE_RANK_PULL:
+	case UI_FORCE_RANK_TELEPATHY:
+	case UI_FORCE_RANK_GRIP:
+	case UI_FORCE_RANK_LIGHTNING:
+	case UI_FORCE_RANK_RAGE:
+	case UI_FORCE_RANK_PROTECT:
+	case UI_FORCE_RANK_ABSORB:
+	case UI_FORCE_RANK_TEAM_HEAL:
+	case UI_FORCE_RANK_TEAM_FORCE:
+	case UI_FORCE_RANK_DRAIN:
+	case UI_FORCE_RANK_SEE:
+	case UI_FORCE_RANK_SABERATTACK:
+	case UI_FORCE_RANK_SABERDEFEND:
+	case UI_FORCE_RANK_SABERTHROW:
+		findex = (ownerDraw - UI_FORCE_RANK)-1;
+		//this will give us the index as long as UI_FORCE_RANK is always one below the first force rank index
+		return UI_ForcePowerRank_HandleKey(flags, special, key, uiForcePowersRank[findex], 0, NUM_FORCE_POWER_LEVELS-1, ownerDraw);
+		break;
+    case UI_EFFECTS:
+      return UI_Effects_HandleKey(flags, special, key);
+      break;
+    case UI_GAMETYPE:
+      return UI_GameType_HandleKey(flags, special, key, qtrue);
+      break;
+    case UI_NETGAMETYPE:
+      return UI_NetGameType_HandleKey(flags, special, key);
+      break;
+    case UI_AUTOSWITCHLIST:
+      return UI_AutoSwitch_HandleKey(flags, special, key);
+      break;
+    case UI_JOINGAMETYPE:
+      return UI_JoinGameType_HandleKey(flags, special, key);
+      break;
+    case UI_SKILL:
+      return UI_Skill_HandleKey(flags, special, key);
+      break;
+    case UI_BLUETEAMNAME:
+      return UI_TeamName_HandleKey(flags, special, key, qtrue);
+      break;
+    case UI_REDTEAMNAME:
+      return UI_TeamName_HandleKey(flags, special, key, qfalse);
+      break;
+    case UI_BLUETEAM1:
+		case UI_BLUETEAM2:
+		case UI_BLUETEAM3:
+		case UI_BLUETEAM4:
+		case UI_BLUETEAM5:
+		case UI_BLUETEAM6:
+		case UI_BLUETEAM7:
+		case UI_BLUETEAM8:
+	if (ownerDraw <= UI_BLUETEAM5)
+	{
+	  iUse = ownerDraw-UI_BLUETEAM1 + 1;
+	}
+	else
+	{
+	  iUse = ownerDraw-274; //unpleasent hack because I don't want to move up all the UI_BLAHTEAM# defines
+	}
+
+      UI_TeamMember_HandleKey(flags, special, key, qtrue, iUse);
+      break;
+    case UI_REDTEAM1:
+		case UI_REDTEAM2:
+		case UI_REDTEAM3:
+		case UI_REDTEAM4:
+		case UI_REDTEAM5:
+		case UI_REDTEAM6:
+		case UI_REDTEAM7:
+		case UI_REDTEAM8:
+	if (ownerDraw <= UI_REDTEAM5)
+	{
+	  iUse = ownerDraw-UI_REDTEAM1 + 1;
+	}
+	else
+	{
+	  iUse = ownerDraw-277; //unpleasent hack because I don't want to move up all the UI_BLAHTEAM# defines
+	}
+      UI_TeamMember_HandleKey(flags, special, key, qfalse, iUse);
+      break;
+		case UI_NETSOURCE:
+      UI_NetSource_HandleKey(flags, special, key);
+			break;
+		case UI_NETFILTER:
+      UI_NetFilter_HandleKey(flags, special, key);
+			break;
+		case UI_OPPONENT_NAME:
+			UI_OpponentName_HandleKey(flags, special, key);
+			break;
+		case UI_BOTNAME:
+			return UI_BotName_HandleKey(flags, special, key);
+			break;
+		case UI_BOTSKILL:
+			return UI_BotSkill_HandleKey(flags, special, key);
+			break;
+		case UI_REDBLUE:
+			UI_RedBlue_HandleKey(flags, special, key);
+			break;
+		case UI_CROSSHAIR:
+			UI_Crosshair_HandleKey(flags, special, key);
+			break;
+		case UI_SELECTEDPLAYER:
+			UI_SelectedPlayer_HandleKey(flags, special, key);
+			break;
+	//	case UI_VOICECHAT:
+	//		UI_VoiceChat_HandleKey(flags, special, key);
+	//		break;
+#ifdef _XBOX
+		case UI_XBOX_PASSCODE:
+			UI_XboxPasscode_HandleKey(flags, special, key);
+			break;
+#endif
+    default:
+      break;
+  }
+
+  return qfalse;
+}
+
+
+static float UI_GetValue(int ownerDraw) {
+  return 0;
+}
+
+/*
+=================
+UI_ServersQsortCompare
+=================
+*/
+static int QDECL UI_ServersQsortCompare( const void *arg1, const void *arg2 ) {
+	return trap_LAN_CompareServers( ui_netSource.integer, uiInfo.serverStatus.sortKey, uiInfo.serverStatus.sortDir, *(int*)arg1, *(int*)arg2);
+}
+
+
+/*
+=================
+UI_ServersSort
+=================
+*/
+void UI_ServersSort(int column, qboolean force) {
+
+	if ( !force ) {
+		if ( uiInfo.serverStatus.sortKey == column ) {
+			return;
+		}
+	}
+
+	uiInfo.serverStatus.sortKey = column;
+	qsort( &uiInfo.serverStatus.displayServers[0], uiInfo.serverStatus.numDisplayServers, sizeof(int), UI_ServersQsortCompare);
+}
+
+/*
+static void UI_StartSinglePlayer() {
+	int i,j, k, skill;
+	char buff[1024];
+	i = trap_Cvar_VariableValue( "ui_currentTier" );
+  if (i < 0 || i >= tierCount) {
+    i = 0;
+  }
+	j = trap_Cvar_VariableValue("ui_currentMap");
+	if (j < 0 || j > MAPS_PER_TIER) {
+		j = 0;
+	}
+
+ 	trap_Cvar_SetValue( "singleplayer", 1 );
+ 	trap_Cvar_SetValue( "g_gametype", Com_Clamp( 0, 7, tierList[i].gameTypes[j] ) );
+	trap_Cmd_ExecuteText( EXEC_APPEND, va( "wait ; wait ; map %s\n", tierList[i].maps[j] ) );
+	skill = trap_Cvar_VariableValue( "g_spSkill" );
+
+	if (j == MAPS_PER_TIER-1) {
+		k = UI_TeamIndexFromName(UI_Cvar_VariableString("ui_opponentName"));
+		Com_sprintf( buff, sizeof(buff), "wait ; addbot %s %i %s 250 %s\n", UI_AIFromName(teamList[k].teamMembers[0]), skill, "", teamList[k].teamMembers[0]);
+	} else {
+		k = UI_TeamIndexFromName(UI_Cvar_VariableString("ui_opponentName"));
+		for (i = 0; i < PLAYERS_PER_TEAM; i++) {
+			Com_sprintf( buff, sizeof(buff), "wait ; addbot %s %i %s 250 %s\n", UI_AIFromName(teamList[k].teamMembers[i]), skill, "Blue", teamList[k].teamMembers[i]);
+			trap_Cmd_ExecuteText( EXEC_APPEND, buff );
+		}
+
+		k = UI_TeamIndexFromName(UI_Cvar_VariableString("ui_teamName"));
+		for (i = 1; i < PLAYERS_PER_TEAM; i++) {
+			Com_sprintf( buff, sizeof(buff), "wait ; addbot %s %i %s 250 %s\n", UI_AIFromName(teamList[k].teamMembers[i]), skill, "Red", teamList[k].teamMembers[i]);
+			trap_Cmd_ExecuteText( EXEC_APPEND, buff );
+		}
+		trap_Cmd_ExecuteText( EXEC_APPEND, "wait 5; team Red\n" );
+	}
+	
+
+}
+*/
+
+/*
+===============
+UI_LoadMods
+===============
+*/
+static void UI_LoadMods() {
+	int		numdirs;
+	char	dirlist[2048];
+	char	*dirptr;
+  char  *descptr;
+	int		i;
+	int		dirlen;
+
+	uiInfo.modCount = 0;
+	numdirs = trap_FS_GetFileList( "$modlist", "", dirlist, sizeof(dirlist) );
+	dirptr  = dirlist;
+	for( i = 0; i < numdirs; i++ ) {
+		dirlen = strlen( dirptr ) + 1;
+    descptr = dirptr + dirlen;
+		uiInfo.modList[uiInfo.modCount].modName = String_Alloc(dirptr);
+		uiInfo.modList[uiInfo.modCount].modDescr = String_Alloc(descptr);
+    dirptr += dirlen + strlen(descptr) + 1;
+		uiInfo.modCount++;
+		if (uiInfo.modCount >= MAX_MODS) {
+			break;
+		}
+	}
+
+}
+
+
+/*
+===============
+UI_LoadMovies
+===============
+*/
+static void UI_LoadMovies() {
+	char	movielist[4096];
+	char	*moviename;
+	int		i, len;
+
+	uiInfo.movieCount = trap_FS_GetFileList( "video", "roq", movielist, 4096 );
+
+	if (uiInfo.movieCount) {
+		if (uiInfo.movieCount > MAX_MOVIES) {
+			uiInfo.movieCount = MAX_MOVIES;
+		}
+		moviename = movielist;
+		for ( i = 0; i < uiInfo.movieCount; i++ ) {
+			len = strlen( moviename );
+			if (!Q_stricmp(moviename +  len - 4,".roq")) {
+				moviename[len-4] = '\0';
+			}
+			Q_strupr(moviename);
+			uiInfo.movieList[i] = String_Alloc(moviename);
+			moviename += len + 1;
+		}
+	}
+
+}
+
+
+
+/*
+===============
+UI_LoadDemos
+===============
+*/
+static void UI_LoadDemos() {
+	char	demolist[4096];
+	char demoExt[32];
+	char	*demoname;
+	int		i, len;
+
+	Com_sprintf(demoExt, sizeof(demoExt), "dm_%d", (int)trap_Cvar_VariableValue("protocol"));
+
+	uiInfo.demoCount = trap_FS_GetFileList( "demos", demoExt, demolist, 4096 );
+
+	Com_sprintf(demoExt, sizeof(demoExt), ".dm_%d", (int)trap_Cvar_VariableValue("protocol"));
+
+	if (uiInfo.demoCount) {
+		if (uiInfo.demoCount > MAX_DEMOS) {
+			uiInfo.demoCount = MAX_DEMOS;
+		}
+		demoname = demolist;
+		for ( i = 0; i < uiInfo.demoCount; i++ ) {
+			len = strlen( demoname );
+			if (!Q_stricmp(demoname +  len - strlen(demoExt), demoExt)) {
+				demoname[len-strlen(demoExt)] = '\0';
+			}
+			Q_strupr(demoname);
+			uiInfo.demoList[i] = String_Alloc(demoname);
+			demoname += len + 1;
+		}
+	}
+
+}
+
+
+static qboolean UI_SetNextMap(int actual, int index) {
+	int i;
+	for (i = actual + 1; i < uiInfo.mapCount; i++) {
+		if (uiInfo.mapList[i].active) {
+			Menu_SetFeederSelection(NULL, FEEDER_MAPS, index + 1, "skirmish");
+			return qtrue;
+		}
+	}
+	return qfalse;
+}
+
+
+static void UI_StartSkirmish(qboolean next) {
+	int i, k, g, delay, temp;
+	float skill;
+	char buff[MAX_STRING_CHARS];
+
+	temp = trap_Cvar_VariableValue( "g_gametype" );
+	trap_Cvar_Set("ui_gameType", va("%i", temp));
+
+	if (next) {
+		int actual;
+		int index = trap_Cvar_VariableValue("ui_mapIndex");
+	 	UI_MapCountByGameType(qtrue);
+		UI_SelectedMap(index, &actual);
+		if (UI_SetNextMap(actual, index)) {
+		} else {
+			UI_GameType_HandleKey(0, 0, A_MOUSE1, qfalse);
+			UI_MapCountByGameType(qtrue);
+			Menu_SetFeederSelection(NULL, FEEDER_MAPS, 0, "skirmish");
+		}
+	}
+
+	g = uiInfo.gameTypes[ui_gameType.integer].gtEnum;
+	trap_Cvar_SetValue( "g_gametype", g );
+	trap_Cmd_ExecuteText( EXEC_APPEND, va( "wait ; wait ; map %s\n", uiInfo.mapList[ui_currentMap.integer].mapLoadName) );
+	skill = trap_Cvar_VariableValue( "g_spSkill" );
+	trap_Cvar_Set("ui_scoreMap", uiInfo.mapList[ui_currentMap.integer].mapName);
+
+	k = UI_TeamIndexFromName(UI_Cvar_VariableString("ui_opponentName"));
+
+	trap_Cvar_Set("ui_singlePlayerActive", "1");
+
+	// set up sp overrides, will be replaced on postgame
+	temp = trap_Cvar_VariableValue( "capturelimit" );
+	trap_Cvar_Set("ui_saveCaptureLimit", va("%i", temp));
+	temp = trap_Cvar_VariableValue( "fraglimit" );
+	trap_Cvar_Set("ui_saveFragLimit", va("%i", temp));
+	temp = trap_Cvar_VariableValue( "duel_fraglimit" );
+	trap_Cvar_Set("ui_saveDuelLimit", va("%i", temp));
+
+	UI_SetCapFragLimits(qfalse);
+
+	temp = trap_Cvar_VariableValue( "cg_drawTimer" );
+	trap_Cvar_Set("ui_drawTimer", va("%i", temp));
+	temp = trap_Cvar_VariableValue( "g_doWarmup" );
+	trap_Cvar_Set("ui_doWarmup", va("%i", temp));
+	temp = trap_Cvar_VariableValue( "g_friendlyFire" );
+	trap_Cvar_Set("ui_friendlyFire", va("%i", temp));
+	temp = trap_Cvar_VariableValue( "sv_maxClients" );
+	trap_Cvar_Set("ui_maxClients", va("%i", temp));
+	temp = trap_Cvar_VariableValue( "g_warmup" );
+	trap_Cvar_Set("ui_Warmup", va("%i", temp));
+	temp = trap_Cvar_VariableValue( "sv_pure" );
+	trap_Cvar_Set("ui_pure", va("%i", temp));
+
+	trap_Cvar_Set("cg_cameraOrbit", "0");
+	trap_Cvar_Set("cg_thirdPerson", "0");
+	trap_Cvar_Set("cg_drawTimer", "1");
+	trap_Cvar_Set("g_doWarmup", "1");
+	trap_Cvar_Set("g_warmup", "15");
+	trap_Cvar_Set("sv_pure", "0");
+	trap_Cvar_Set("g_friendlyFire", "0");
+	trap_Cvar_Set("g_redTeam", UI_Cvar_VariableString("ui_teamName"));
+	trap_Cvar_Set("g_blueTeam", UI_Cvar_VariableString("ui_opponentName"));
+
+	if (trap_Cvar_VariableValue("ui_recordSPDemo")) {
+		Com_sprintf(buff, MAX_STRING_CHARS, "%s_%i", uiInfo.mapList[ui_currentMap.integer].mapLoadName, g);
+		trap_Cvar_Set("ui_recordSPDemoName", buff);
+	}
+
+	delay = 500;
+
+	if (g == GT_DUEL || g == GT_POWERDUEL) {
+		temp = uiInfo.mapList[ui_currentMap.integer].teamMembers * 2;
+		trap_Cvar_Set("sv_maxClients", va("%d", temp));
+		Com_sprintf( buff, sizeof(buff), "wait ; addbot %s %f "", %i \n", uiInfo.mapList[ui_currentMap.integer].opponentName, skill, delay);
+		trap_Cmd_ExecuteText( EXEC_APPEND, buff );
+	} else if (g == GT_HOLOCRON || g == GT_JEDIMASTER) {
+		temp = uiInfo.mapList[ui_currentMap.integer].teamMembers * 2;
+		trap_Cvar_Set("sv_maxClients", va("%d", temp));
+		for (i =0; i < uiInfo.mapList[ui_currentMap.integer].teamMembers; i++) {
+			Com_sprintf( buff, sizeof(buff), "addbot \"%s\" %f %s %i %s\n", UI_AIFromName(uiInfo.teamList[k].teamMembers[i]), skill, (g == GT_HOLOCRON) ? "" : "Blue", delay, uiInfo.teamList[k].teamMembers[i]);
+			trap_Cmd_ExecuteText( EXEC_APPEND, buff );
+			delay += 500;
+		}
+		k = UI_TeamIndexFromName(UI_Cvar_VariableString("ui_teamName"));
+		for (i =0; i < uiInfo.mapList[ui_currentMap.integer].teamMembers-1; i++) {
+			Com_sprintf( buff, sizeof(buff), "addbot \"%s\" %f %s %i %s\n", UI_AIFromName(uiInfo.teamList[k].teamMembers[i]), skill, (g == GT_HOLOCRON) ? "" : "Red", delay, uiInfo.teamList[k].teamMembers[i]);
+			trap_Cmd_ExecuteText( EXEC_APPEND, buff );
+			delay += 500;
+		}
+	} else {
+		temp = uiInfo.mapList[ui_currentMap.integer].teamMembers * 2;
+		trap_Cvar_Set("sv_maxClients", va("%d", temp));
+		for (i =0; i < uiInfo.mapList[ui_currentMap.integer].teamMembers; i++) {
+			Com_sprintf( buff, sizeof(buff), "addbot \"%s\" %f %s %i %s\n", UI_AIFromName(uiInfo.teamList[k].teamMembers[i]), skill, (g == GT_FFA) ? "" : "Blue", delay, uiInfo.teamList[k].teamMembers[i]);
+			trap_Cmd_ExecuteText( EXEC_APPEND, buff );
+			delay += 500;
+		}
+		k = UI_TeamIndexFromName(UI_Cvar_VariableString("ui_teamName"));
+		for (i =0; i < uiInfo.mapList[ui_currentMap.integer].teamMembers-1; i++) {
+			Com_sprintf( buff, sizeof(buff), "addbot \"%s\" %f %s %i %s\n", UI_AIFromName(uiInfo.teamList[k].teamMembers[i]), skill, (g == GT_FFA) ? "" : "Red", delay, uiInfo.teamList[k].teamMembers[i]);
+			trap_Cmd_ExecuteText( EXEC_APPEND, buff );
+			delay += 500;
+		}
+	}
+	if (g >= GT_TEAM ) {
+		trap_Cmd_ExecuteText( EXEC_APPEND, "wait 5; team Red\n" );
+	}
+}
+
+static void UI_Update(const char *name) {
+	int	val = trap_Cvar_VariableValue(name);
+
+	if (Q_stricmp(name, "s_khz") == 0) 
+	{
+		trap_Cmd_ExecuteText( EXEC_APPEND, "snd_restart\n" );
+		return;
+	}
+
+ 	if (Q_stricmp(name, "ui_SetName") == 0) {
+		trap_Cvar_Set( "name", UI_Cvar_VariableString("ui_Name"));
+ 	} else if (Q_stricmp(name, "ui_setRate") == 0) {
+		float rate = trap_Cvar_VariableValue("rate");
+		if (rate >= 5000) {
+			trap_Cvar_Set("cl_maxpackets", "30");
+			trap_Cvar_Set("cl_packetdup", "1");
+		} else if (rate >= 4000) {
+			trap_Cvar_Set("cl_maxpackets", "15");
+			trap_Cvar_Set("cl_packetdup", "2");		// favor less prediction errors when there's packet loss
+		} else {
+			trap_Cvar_Set("cl_maxpackets", "15");
+			trap_Cvar_Set("cl_packetdup", "1");		// favor lower bandwidth
+		}
+ 	} 
+	else if (Q_stricmp(name, "ui_GetName") == 0) 
+	{
+		trap_Cvar_Set( "ui_Name", UI_Cvar_VariableString("name"));
+	}
+	else if (Q_stricmp(name, "ui_r_colorbits") == 0) 
+	{
+		switch (val) 
+		{
+			case 0:
+				trap_Cvar_SetValue( "ui_r_depthbits", 0 );
+				break;
+
+			case 16:
+				trap_Cvar_SetValue( "ui_r_depthbits", 16 );
+				break;
+
+			case 32:
+				trap_Cvar_SetValue( "ui_r_depthbits", 24 );
+				break;
+		}
+	} 
+	else if (Q_stricmp(name, "ui_r_lodbias") == 0) 
+	{
+		switch (val) 
+		{
+			case 0:
+				trap_Cvar_SetValue( "ui_r_subdivisions", 4 );
+				break;
+			case 1:
+				trap_Cvar_SetValue( "ui_r_subdivisions", 12 );
+				break;
+
+			case 2:
+				trap_Cvar_SetValue( "ui_r_subdivisions", 20 );
+				break;
+		}
+	} 
+	else if (Q_stricmp(name, "ui_r_glCustom") == 0) 
+	{
+		switch (val) 
+		{
+			case 0:	// high quality
+
+				trap_Cvar_SetValue( "ui_r_fullScreen", 1 );
+				trap_Cvar_SetValue( "ui_r_subdivisions", 4 );
+				trap_Cvar_SetValue( "ui_r_lodbias", 0 );
+				trap_Cvar_SetValue( "ui_r_colorbits", 32 );
+				trap_Cvar_SetValue( "ui_r_depthbits", 24 );
+				trap_Cvar_SetValue( "ui_r_picmip", 0 );
+				trap_Cvar_SetValue( "ui_r_mode", 4 );
+				trap_Cvar_SetValue( "ui_r_texturebits", 32 );
+				trap_Cvar_SetValue( "ui_r_fastSky", 0 );
+				trap_Cvar_SetValue( "ui_r_inGameVideo", 1 );
+				//trap_Cvar_SetValue( "ui_cg_shadows", 2 );//stencil
+				trap_Cvar_Set( "ui_r_texturemode", "GL_LINEAR_MIPMAP_LINEAR" );
+				break;
+
+			case 1: // normal 
+				trap_Cvar_SetValue( "ui_r_fullScreen", 1 );
+				trap_Cvar_SetValue( "ui_r_subdivisions", 4 );
+				trap_Cvar_SetValue( "ui_r_lodbias", 0 );
+				trap_Cvar_SetValue( "ui_r_colorbits", 0 );
+				trap_Cvar_SetValue( "ui_r_depthbits", 24 );
+				trap_Cvar_SetValue( "ui_r_picmip", 1 );
+				trap_Cvar_SetValue( "ui_r_mode", 3 );
+				trap_Cvar_SetValue( "ui_r_texturebits", 0 );
+				trap_Cvar_SetValue( "ui_r_fastSky", 0 );
+				trap_Cvar_SetValue( "ui_r_inGameVideo", 1 );
+				//trap_Cvar_SetValue( "ui_cg_shadows", 2 );
+				trap_Cvar_Set( "ui_r_texturemode", "GL_LINEAR_MIPMAP_LINEAR" );
+				break;
+
+			case 2: // fast
+
+				trap_Cvar_SetValue( "ui_r_fullScreen", 1 );
+				trap_Cvar_SetValue( "ui_r_subdivisions", 12 );
+				trap_Cvar_SetValue( "ui_r_lodbias", 1 );
+				trap_Cvar_SetValue( "ui_r_colorbits", 0 );
+				trap_Cvar_SetValue( "ui_r_depthbits", 0 );
+				trap_Cvar_SetValue( "ui_r_picmip", 2 );
+				trap_Cvar_SetValue( "ui_r_mode", 3 );
+				trap_Cvar_SetValue( "ui_r_texturebits", 0 );
+				trap_Cvar_SetValue( "ui_r_fastSky", 1 );
+				trap_Cvar_SetValue( "ui_r_inGameVideo", 0 );
+				//trap_Cvar_SetValue( "ui_cg_shadows", 1 );
+				trap_Cvar_Set( "ui_r_texturemode", "GL_LINEAR_MIPMAP_NEAREST" );
+				break;
+
+			case 3: // fastest
+
+				trap_Cvar_SetValue( "ui_r_fullScreen", 1 );
+				trap_Cvar_SetValue( "ui_r_subdivisions", 20 );
+				trap_Cvar_SetValue( "ui_r_lodbias", 2 );
+				trap_Cvar_SetValue( "ui_r_colorbits", 16 );
+				trap_Cvar_SetValue( "ui_r_depthbits", 16 );
+				trap_Cvar_SetValue( "ui_r_mode", 3 );
+				trap_Cvar_SetValue( "ui_r_picmip", 3 );
+				trap_Cvar_SetValue( "ui_r_texturebits", 16 );
+				trap_Cvar_SetValue( "ui_r_fastSky", 1 );
+				trap_Cvar_SetValue( "ui_r_inGameVideo", 0 );
+				//trap_Cvar_SetValue( "ui_cg_shadows", 0 );
+				trap_Cvar_Set( "ui_r_texturemode", "GL_LINEAR_MIPMAP_NEAREST" );
+			break;
+		}
+	} 
+	else if (Q_stricmp(name, "ui_mousePitch") == 0) 
+	{
+		if (val == 0) 
+		{
+			trap_Cvar_SetValue( "m_pitch", 0.022f );
+		} 
+		else 
+		{
+			trap_Cvar_SetValue( "m_pitch", -0.022f );
+		}
+	}
+	else if (Q_stricmp(name, "ui_mousePitchVeh") == 0) 
+	{
+		if (val == 0) 
+		{
+			trap_Cvar_SetValue( "m_pitchVeh", 0.022f );
+		} 
+		else 
+		{
+			trap_Cvar_SetValue( "m_pitchVeh", -0.022f );
+		}
+	}
+}
+
+int gUISelectedMap = 0;
+
+/*
+===============
+UI_DeferMenuScript
+
+Return true if the menu script should be deferred for later
+===============
+*/
+static qboolean UI_DeferMenuScript ( char **args )
+{
+	const char* name;
+
+	// Whats the reason for being deferred?
+	if (!String_Parse( (char**)args, &name)) 
+	{
+		return qfalse;
+	}
+
+	// Handle the custom cases
+	if ( !Q_stricmp ( name, "VideoSetup" ) )
+	{
+		const char* warningMenuName;
+		qboolean	deferred;
+
+		// No warning menu specified
+		if ( !String_Parse( (char**)args, &warningMenuName) )
+		{
+			return qfalse;
+		}
+
+		// Defer if the video options were modified
+		deferred = trap_Cvar_VariableValue ( "ui_r_modified" ) ? qtrue : qfalse;
+
+		if ( deferred )
+		{
+			// Open the warning menu
+			Menus_OpenByName(warningMenuName);
+		}
+
+		return deferred;
+	}
+	else if ( !Q_stricmp ( name, "RulesBackout" ) )
+	{
+		qboolean deferred;
+		
+		deferred = trap_Cvar_VariableValue ( "ui_rules_backout" ) ? qtrue : qfalse ;
+
+		trap_Cvar_Set ( "ui_rules_backout", "0" );
+
+		return deferred;
+	}
+
+	return qfalse;
+}
+
+/*
+=================
+UI_UpdateVideoSetup
+
+Copies the temporary user interface version of the video cvars into
+their real counterparts.  This is to create a interface which allows 
+you to discard your changes if you did something you didnt want
+=================
+*/
+void UI_UpdateVideoSetup ( void )
+{
+	trap_Cvar_Set ( "r_mode", UI_Cvar_VariableString ( "ui_r_mode" ) );
+	trap_Cvar_Set ( "r_fullscreen", UI_Cvar_VariableString ( "ui_r_fullscreen" ) );
+	trap_Cvar_Set ( "r_colorbits", UI_Cvar_VariableString ( "ui_r_colorbits" ) );
+	trap_Cvar_Set ( "r_lodbias", UI_Cvar_VariableString ( "ui_r_lodbias" ) );
+	trap_Cvar_Set ( "r_picmip", UI_Cvar_VariableString ( "ui_r_picmip" ) );
+	trap_Cvar_Set ( "r_texturebits", UI_Cvar_VariableString ( "ui_r_texturebits" ) );
+	trap_Cvar_Set ( "r_texturemode", UI_Cvar_VariableString ( "ui_r_texturemode" ) );
+	trap_Cvar_Set ( "r_detailtextures", UI_Cvar_VariableString ( "ui_r_detailtextures" ) );
+	trap_Cvar_Set ( "r_ext_compress_textures", UI_Cvar_VariableString ( "ui_r_ext_compress_textures" ) );
+	trap_Cvar_Set ( "r_depthbits", UI_Cvar_VariableString ( "ui_r_depthbits" ) );
+	trap_Cvar_Set ( "r_subdivisions", UI_Cvar_VariableString ( "ui_r_subdivisions" ) );
+	trap_Cvar_Set ( "r_fastSky", UI_Cvar_VariableString ( "ui_r_fastSky" ) );
+	trap_Cvar_Set ( "r_inGameVideo", UI_Cvar_VariableString ( "ui_r_inGameVideo" ) );
+	trap_Cvar_Set ( "r_allowExtensions", UI_Cvar_VariableString ( "ui_r_allowExtensions" ) );
+	trap_Cvar_Set ( "cg_shadows", UI_Cvar_VariableString ( "ui_cg_shadows" ) );
+	trap_Cvar_Set ( "ui_r_modified", "0" );
+
+	trap_Cmd_ExecuteText( EXEC_APPEND, "vid_restart;" );
+}
+
+/*
+=================
+UI_GetVideoSetup
+
+Retrieves the current actual video settings into the temporary user
+interface versions of the cvars.
+=================
+*/
+void UI_GetVideoSetup ( void )
+{
+	// Make sure the cvars are registered as read only.
+	trap_Cvar_Register ( NULL, "ui_r_glCustom",				"4", CVAR_ROM|CVAR_INTERNAL|CVAR_ARCHIVE );
+
+	trap_Cvar_Register ( NULL, "ui_r_mode",					"0", CVAR_ROM|CVAR_INTERNAL );
+	trap_Cvar_Register ( NULL, "ui_r_fullscreen",			"0", CVAR_ROM|CVAR_INTERNAL );
+	trap_Cvar_Register ( NULL, "ui_r_colorbits",			"0", CVAR_ROM|CVAR_INTERNAL );
+	trap_Cvar_Register ( NULL, "ui_r_lodbias",				"0", CVAR_ROM|CVAR_INTERNAL );
+	trap_Cvar_Register ( NULL, "ui_r_picmip",				"0", CVAR_ROM|CVAR_INTERNAL );
+	trap_Cvar_Register ( NULL, "ui_r_texturebits",			"0", CVAR_ROM|CVAR_INTERNAL );
+	trap_Cvar_Register ( NULL, "ui_r_texturemode",			"0", CVAR_ROM|CVAR_INTERNAL );
+	trap_Cvar_Register ( NULL, "ui_r_detailtextures",		"0", CVAR_ROM|CVAR_INTERNAL );
+	trap_Cvar_Register ( NULL, "ui_r_ext_compress_textures","0", CVAR_ROM|CVAR_INTERNAL );
+	trap_Cvar_Register ( NULL, "ui_r_depthbits",			"0", CVAR_ROM|CVAR_INTERNAL );
+	trap_Cvar_Register ( NULL, "ui_r_subdivisions",			"0", CVAR_ROM|CVAR_INTERNAL );
+	trap_Cvar_Register ( NULL, "ui_r_fastSky",				"0", CVAR_ROM|CVAR_INTERNAL );
+	trap_Cvar_Register ( NULL, "ui_r_inGameVideo",			"0", CVAR_ROM|CVAR_INTERNAL );
+	trap_Cvar_Register ( NULL, "ui_r_allowExtensions",		"0", CVAR_ROM|CVAR_INTERNAL );
+	trap_Cvar_Register ( NULL, "ui_cg_shadows",				"0", CVAR_ROM|CVAR_INTERNAL );
+	trap_Cvar_Register ( NULL, "ui_r_modified",				"0", CVAR_ROM|CVAR_INTERNAL );
+	
+	// Copy over the real video cvars into their temporary counterparts
+	trap_Cvar_Set ( "ui_r_mode",		UI_Cvar_VariableString ( "r_mode" ) );
+	trap_Cvar_Set ( "ui_r_colorbits",	UI_Cvar_VariableString ( "r_colorbits" ) );
+	trap_Cvar_Set ( "ui_r_fullscreen",	UI_Cvar_VariableString ( "r_fullscreen" ) );
+	trap_Cvar_Set ( "ui_r_lodbias",		UI_Cvar_VariableString ( "r_lodbias" ) );
+	trap_Cvar_Set ( "ui_r_picmip",		UI_Cvar_VariableString ( "r_picmip" ) );
+	trap_Cvar_Set ( "ui_r_texturebits", UI_Cvar_VariableString ( "r_texturebits" ) );
+	trap_Cvar_Set ( "ui_r_texturemode", UI_Cvar_VariableString ( "r_texturemode" ) );
+	trap_Cvar_Set ( "ui_r_detailtextures", UI_Cvar_VariableString ( "r_detailtextures" ) );
+	trap_Cvar_Set ( "ui_r_ext_compress_textures", UI_Cvar_VariableString ( "r_ext_compress_textures" ) );
+	trap_Cvar_Set ( "ui_r_depthbits", UI_Cvar_VariableString ( "r_depthbits" ) );
+	trap_Cvar_Set ( "ui_r_subdivisions", UI_Cvar_VariableString ( "r_subdivisions" ) );
+	trap_Cvar_Set ( "ui_r_fastSky", UI_Cvar_VariableString ( "r_fastSky" ) );
+	trap_Cvar_Set ( "ui_r_inGameVideo", UI_Cvar_VariableString ( "r_inGameVideo" ) );
+	trap_Cvar_Set ( "ui_r_allowExtensions", UI_Cvar_VariableString ( "r_allowExtensions" ) );
+	trap_Cvar_Set ( "ui_cg_shadows", UI_Cvar_VariableString ( "cg_shadows" ) );
+	trap_Cvar_Set ( "ui_r_modified", "0" );
+}
+
+// If the game type is siege, hide the addbot button. I would have done a cvar text on that item,
+// but it already had one on it.
+static void UI_SetBotButton ( void )
+{
+	int gameType = trap_Cvar_VariableValue( "g_gametype" );
+	int server;
+	menuDef_t *menu;
+	itemDef_t *item;
+	char *name = "addBot";
+
+	server = trap_Cvar_VariableValue( "sv_running" );
+
+	// If in siege or a client, don't show add bot button
+	if ((gameType==GT_SIEGE) || (server==0))	// If it's not siege, don't worry about it
+	{
+		menu = Menu_GetFocused();	// Get current menu (either video or ingame video, I would assume)
+
+		if (!menu)
+		{
+			return;
+		}
+
+		item = Menu_FindItemByName(menu, name);
+		if (item)
+		{
+			Menu_ShowItemByName(menu, name, qfalse);
+		}
+	}
+}
+
+// Update the model cvar and everything is good.
+static void UI_UpdateCharacterCvars ( void )
+{
+	char skin[MAX_QPATH];
+	char model[MAX_QPATH];
+	char head[MAX_QPATH];
+	char torso[MAX_QPATH];
+	char legs[MAX_QPATH];
+
+	trap_Cvar_VariableStringBuffer("ui_char_model", model, sizeof(model));
+	trap_Cvar_VariableStringBuffer("ui_char_skin_head", head, sizeof(head));
+	trap_Cvar_VariableStringBuffer("ui_char_skin_torso", torso, sizeof(torso));
+	trap_Cvar_VariableStringBuffer("ui_char_skin_legs", legs, sizeof(legs));
+
+	Com_sprintf( skin, sizeof( skin ), "%s/%s|%s|%s", 
+										model, 
+										head, 
+										torso, 
+										legs 
+				);
+
+	trap_Cvar_Set ( "model", skin );
+
+	trap_Cvar_Set ( "char_color_red", UI_Cvar_VariableString ( "ui_char_color_red" ) );
+	trap_Cvar_Set ( "char_color_green", UI_Cvar_VariableString ( "ui_char_color_green" ) );
+	trap_Cvar_Set ( "char_color_blue", UI_Cvar_VariableString ( "ui_char_color_blue" ) );
+	trap_Cvar_Set ( "ui_selectedModelIndex", "-1");
+
+}
+
+static void UI_GetCharacterCvars ( void )
+{
+	char *model;
+	char *skin;
+	int i;
+
+	trap_Cvar_Set ( "ui_char_color_red", UI_Cvar_VariableString ( "char_color_red" ) );
+	trap_Cvar_Set ( "ui_char_color_green", UI_Cvar_VariableString ( "char_color_green" ) );
+	trap_Cvar_Set ( "ui_char_color_blue", UI_Cvar_VariableString ( "char_color_blue" ) );
+
+	model = UI_Cvar_VariableString ( "model" );
+	skin = strrchr(model,'/');
+	if (skin && strchr(model,'|'))	//we have a multipart custom jedi
+	{
+		char skinhead[MAX_QPATH];
+		char skintorso[MAX_QPATH];
+		char skinlower[MAX_QPATH];
+		char *p2;
+
+		*skin=0;
+		skin++;
+		//now get the the individual files
+
+		//advance to second
+		p2 = strchr(skin, '|'); 
+		assert(p2);
+		*p2=0;
+		p2++;
+		strcpy (skinhead, skin);
+
+
+		//advance to third
+		skin = strchr(p2, '|');
+		assert(skin);
+		*skin=0;
+		skin++;
+		strcpy (skintorso,p2);
+
+		strcpy (skinlower,skin);
+
+
+
+		trap_Cvar_Set("ui_char_model", model);
+		trap_Cvar_Set("ui_char_skin_head", skinhead);
+		trap_Cvar_Set("ui_char_skin_torso", skintorso);
+		trap_Cvar_Set("ui_char_skin_legs", skinlower);
+
+		for (i = 0; i < uiInfo.playerSpeciesCount; i++)
+		{
+			if ( !stricmp(model, uiInfo.playerSpecies[i].Name) )
+			{
+				uiInfo.playerSpeciesIndex = i;
+				break;
+			}
+		}
+	}
+	else
+	{
+		model = UI_Cvar_VariableString ( "ui_char_model" );
+		for (i = 0; i < uiInfo.playerSpeciesCount; i++)
+		{
+			if ( !stricmp(model, uiInfo.playerSpecies[i].Name) )
+			{
+				uiInfo.playerSpeciesIndex = i;
+				return;	//FOUND IT, don't fall through
+			}
+		}
+		//nope, didn't find it.
+		uiInfo.playerSpeciesIndex = 0;//jic
+		trap_Cvar_Set("ui_char_model", uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].Name);
+		trap_Cvar_Set("ui_char_skin_head", "head_a1");
+		trap_Cvar_Set("ui_char_skin_torso","torso_a1");
+		trap_Cvar_Set("ui_char_skin_legs", "lower_a1");
+	}
+}
+
+void UI_SetSiegeObjectiveGraphicPos(menuDef_t *menu,const char *itemName,const char *cvarName)
+{
+	itemDef_t	*item;
+	char		cvarBuf[1024];
+	const char	*holdVal;
+	char		*holdBuf;
+
+	item = Menu_FindItemByName(menu, itemName);
+
+	if (item)
+	{
+		// get cvar data
+		trap_Cvar_VariableStringBuffer(cvarName, cvarBuf, sizeof(cvarBuf));
+		
+		holdBuf = cvarBuf;
+		if (String_Parse(&holdBuf,&holdVal))
+		{
+			item->window.rectClient.x = atof(holdVal);
+			if (String_Parse(&holdBuf,&holdVal))
+			{
+				item->window.rectClient.y = atof(holdVal);
+				if (String_Parse(&holdBuf,&holdVal))
+				{
+					item->window.rectClient.w = atof(holdVal);
+					if (String_Parse(&holdBuf,&holdVal))
+					{
+						item->window.rectClient.h = atof(holdVal);
+
+						item->window.rect.x = item->window.rectClient.x;
+						item->window.rect.y = item->window.rectClient.y;
+
+						item->window.rect.w = item->window.rectClient.w;
+						item->window.rect.h = item->window.rectClient.h;
+					}
+				}
+			}
+		}
+	}
+}
+
+void UI_FindCurrentSiegeTeamClass( void )
+{
+	menuDef_t *menu;
+	int myTeam = (int)(trap_Cvar_VariableValue("ui_myteam"));
+	char *itemname;
+	itemDef_t *item;
+	int	baseClass;
+
+	menu = Menu_GetFocused();	// Get current menu
+
+	if (!menu)
+	{
+		return;
+	}
+
+	if (( myTeam != TEAM_RED ) && ( myTeam != TEAM_BLUE ))
+	{
+		return;
+	}
+
+	// If the player is on a team, 
+	if ( myTeam == TEAM_RED )
+	{			
+		itemDef_t *item;
+		item = (itemDef_t *) Menu_FindItemByName(menu, "onteam1" );
+		if (item)
+		{
+		    Item_RunScript(item, item->action);
+		}
+	}
+	else if ( myTeam == TEAM_BLUE )
+	{			
+		itemDef_t *item;
+		item = (itemDef_t *) Menu_FindItemByName(menu, "onteam2" );
+		if (item)
+		{
+		    Item_RunScript(item, item->action);
+		}
+	}	
+
+
+	baseClass = (int)trap_Cvar_VariableValue("ui_siege_class");
+
+	// Find correct class button and activate it.
+	if (baseClass == SPC_INFANTRY)
+	{
+		itemname = "class1_button";
+	}
+	else if (baseClass == SPC_HEAVY_WEAPONS)
+	{
+		itemname = "class2_button";
+	}
+	else if (baseClass == SPC_DEMOLITIONIST)
+	{
+		itemname = "class3_button";
+	}
+	else if (baseClass == SPC_VANGUARD)
+	{
+		itemname = "class4_button";
+	}
+	else if (baseClass == SPC_SUPPORT)
+	{
+		itemname = "class5_button";
+	}
+	else if (baseClass == SPC_SUPPORT)
+	{
+		itemname = "class5_button";
+	}
+	else if (baseClass == SPC_JEDI)
+	{
+		itemname = "class6_button";
+	}
+	else 
+	{
+		return;
+	}
+
+	item = (itemDef_t *) Menu_FindItemByName(menu, itemname );
+	if (item)
+	{
+		Item_RunScript(item, item->action);
+	}
+
+}
+
+void UI_UpdateSiegeObjectiveGraphics( void )
+{
+	menuDef_t *menu;
+	int	teamI,objI;
+
+	menu = Menu_GetFocused();	// Get current menu
+
+	if (!menu)
+	{
+		return;
+	}
+
+	// Hiding a bunch of fields because the opening section of the siege menu was getting too long
+	Menu_ShowGroup(menu,"class_button",qfalse);
+	Menu_ShowGroup(menu,"class_count",qfalse);
+	Menu_ShowGroup(menu,"feeders",qfalse);
+	Menu_ShowGroup(menu,"classdescription",qfalse);
+	Menu_ShowGroup(menu,"minidesc",qfalse);
+	Menu_ShowGroup(menu,"obj_longdesc",qfalse);
+	Menu_ShowGroup(menu,"objective_pic",qfalse);
+	Menu_ShowGroup(menu,"stats",qfalse);
+	Menu_ShowGroup(menu,"forcepowerlevel",qfalse);
+
+	// Get objective icons for each team
+	for (teamI=1;teamI<3;teamI++)
+	{
+		for (objI=1;objI<8;objI++)
+		{
+			Menu_SetItemBackground(menu,va("tm%i_icon%i",teamI,objI),va("*team%i_objective%i_mapicon",teamI,objI));
+			Menu_SetItemBackground(menu,va("tm%i_l_icon%i",teamI,objI),va("*team%i_objective%i_mapicon",teamI,objI));
+		}
+	}
+
+	// Now get their placement on the map
+	for (teamI=1;teamI<3;teamI++)
+	{
+		for (objI=1;objI<8;objI++)
+		{
+			UI_SetSiegeObjectiveGraphicPos(menu,va("tm%i_icon%i",teamI,objI),va("team%i_objective%i_mappos",teamI,objI));
+		}
+	}
+
+}
+
+saber_colors_t TranslateSaberColor( const char *name );
+
+static void UI_UpdateSaberCvars ( void )
+{
+	saber_colors_t colorI;
+
+	trap_Cvar_Set ( "saber1", UI_Cvar_VariableString ( "ui_saber" ) );
+	trap_Cvar_Set ( "saber2", UI_Cvar_VariableString ( "ui_saber2" ) );
+
+	colorI = TranslateSaberColor( UI_Cvar_VariableString ( "ui_saber_color" ) );
+	trap_Cvar_Set ( "color1", va("%d",colorI));
+	trap_Cvar_Set ( "g_saber_color", UI_Cvar_VariableString ( "ui_saber_color" ));
+
+	colorI = TranslateSaberColor( UI_Cvar_VariableString ( "ui_saber2_color" ) );
+	trap_Cvar_Set ( "color2", va("%d",colorI) );
+	trap_Cvar_Set ( "g_saber2_color", UI_Cvar_VariableString ( "ui_saber2_color" ));
+}
+
+// More hard coded goodness for the menus.
+static void UI_SetSaberBoxesandHilts (void)
+{
+	menuDef_t *menu;
+	itemDef_t *item;
+	qboolean	getBig = qfalse;
+	char sType[MAX_QPATH];
+
+	menu = Menu_GetFocused();	// Get current menu (either video or ingame video, I would assume)
+
+	if (!menu)
+	{
+		return;
+	}
+
+	trap_Cvar_VariableStringBuffer( "ui_saber_type", sType, sizeof(sType) );
+
+	if ( Q_stricmp( "dual", sType ) != 0 )
+	{
+//		trap_Cvar_Set("ui_saber", "single_1");
+//		trap_Cvar_Set("ui_saber2", "single_1");
+		getBig = qtrue;
+	}
+
+	else if (Q_stricmp( "staff", sType ) != 0 )
+	{
+//		trap_Cvar_Set("ui_saber", "dual_1");
+//		trap_Cvar_Set("ui_saber2", "none");
+		getBig = qtrue;
+	}
+
+	if (!getBig)
+	{
+		return;
+	}
+
+	item = (itemDef_t *) Menu_FindItemByName(menu, "box2middle" );
+
+	if(item)
+	{
+		item->window.rect.x = 212;
+		item->window.rect.y = 126;
+		item->window.rect.w = 219;
+		item->window.rect.h = 44;
+	}
+
+	item = (itemDef_t *) Menu_FindItemByName(menu, "box2bottom" );
+
+	if(item)
+	{
+		item->window.rect.x = 212;
+		item->window.rect.y = 170;
+		item->window.rect.w = 219;
+		item->window.rect.h = 60;
+	}
+
+	item = (itemDef_t *) Menu_FindItemByName(menu, "box3middle" );
+
+	if(item)
+	{
+		item->window.rect.x = 418;
+		item->window.rect.y = 126;
+		item->window.rect.w = 219;
+		item->window.rect.h = 44;
+	}
+
+	item = (itemDef_t *) Menu_FindItemByName(menu, "box3bottom" );
+
+	if(item)
+	{
+		item->window.rect.x = 418;
+		item->window.rect.y = 170;
+		item->window.rect.w = 219;
+		item->window.rect.h = 60;
+	}
+}
+
+//extern qboolean UI_SaberModelForSaber( const char *saberName, char *saberModel );
+extern qboolean UI_SaberSkinForSaber( const char *saberName, char *saberSkin );
+#include "../namespace_begin.h"
+extern qboolean ItemParse_asset_model_go( itemDef_t *item, const char *name,int *runTimeLength );
+extern qboolean ItemParse_model_g2skin_go( itemDef_t *item, const char *skinName );
+#include "../namespace_end.h"
+
+static void UI_UpdateSaberType( void )
+{
+	char sType[MAX_QPATH];
+	trap_Cvar_VariableStringBuffer( "ui_saber_type", sType, sizeof(sType) );
+
+	if ( Q_stricmp( "single", sType ) == 0 ||
+		Q_stricmp( "staff", sType ) == 0 )
+	{
+		trap_Cvar_Set( "ui_saber2", "" );
+	}
+}
+
+static void UI_UpdateSaberHilt( qboolean secondSaber )
+{
+	menuDef_t *menu;
+	itemDef_t *item;
+	char model[MAX_QPATH];
+	char modelPath[MAX_QPATH];
+	char skinPath[MAX_QPATH];
+	char *itemName;
+	char *saberCvarName;
+	int	animRunLength;
+
+	menu = Menu_GetFocused();	// Get current menu (either video or ingame video, I would assume)
+
+	if (!menu)
+	{
+		return;
+	}
+
+	if ( secondSaber )
+	{
+		itemName = "saber2";
+		saberCvarName = "ui_saber2";
+	}
+	else
+	{
+		itemName = "saber";
+		saberCvarName = "ui_saber";
+	}
+
+	item = (itemDef_t *) Menu_FindItemByName(menu, itemName );
+
+	if(!item)
+	{
+		Com_Error( ERR_FATAL, "UI_UpdateSaberHilt: Could not find item (%s) in menu (%s)", itemName, menu->window.name);
+	}
+
+	trap_Cvar_VariableStringBuffer( saberCvarName, model, sizeof(model) );
+
+	item->text = model;
+	//read this from the sabers.cfg
+	if ( UI_SaberModelForSaber( model, modelPath ) )
+	{//successfully found a model
+		ItemParse_asset_model_go( item, modelPath, &animRunLength );//set the model
+		//get the customSkin, if any
+		//COM_StripExtension( modelPath, skinPath );
+		//COM_DefaultExtension( skinPath, sizeof( skinPath ), ".skin" );
+		if ( UI_SaberSkinForSaber( model, skinPath ) )
+		{
+			ItemParse_model_g2skin_go( item, skinPath );//apply the skin
+		}
+		else
+		{
+			ItemParse_model_g2skin_go( item, NULL );//apply the skin
+		}
+	}
+}
+
+static void UI_UpdateSaberColor( qboolean secondSaber )
+{
+}
+
+extern char * SaberColorToString(saber_colors_t color);
+
+static void UI_GetSaberCvars ( void )
+{
+//	trap_Cvar_Set ( "ui_saber_type", UI_Cvar_VariableString ( "g_saber_type" ) );
+	trap_Cvar_Set ( "ui_saber", UI_Cvar_VariableString ( "saber1" ) );
+	trap_Cvar_Set ( "ui_saber2", UI_Cvar_VariableString ( "saber2" ));
+
+	trap_Cvar_Set("g_saber_color", SaberColorToString(trap_Cvar_VariableValue("color1")));
+	trap_Cvar_Set("g_saber2_color", SaberColorToString(trap_Cvar_VariableValue("color2")));
+
+	trap_Cvar_Set ( "ui_saber_color", UI_Cvar_VariableString ( "g_saber_color" ) );
+	trap_Cvar_Set ( "ui_saber2_color", UI_Cvar_VariableString ( "g_saber2_color" ) );
+
+
+}
+
+
+//extern qboolean ItemParse_model_g2skin_go( itemDef_t *item, const char *skinName );
+#include "../namespace_begin.h"
+extern qboolean ItemParse_model_g2anim_go( itemDef_t *item, const char *animName );
+#include "../namespace_end.h"
+//extern qboolean ItemParse_asset_model_go( itemDef_t *item, const char *name );
+
+void UI_UpdateCharacterSkin( void )
+{
+	menuDef_t *menu;
+	itemDef_t *item;
+	char skin[MAX_QPATH];
+	char model[MAX_QPATH];
+	char head[MAX_QPATH];
+	char torso[MAX_QPATH];
+	char legs[MAX_QPATH];
+
+	menu = Menu_GetFocused();	// Get current menu
+
+	if (!menu)
+	{
+		return;
+	}
+
+	item = (itemDef_t *) Menu_FindItemByName(menu, "character");
+
+	if (!item)
+	{
+		Com_Error( ERR_FATAL, "UI_UpdateCharacterSkin: Could not find item (character) in menu (%s)", menu->window.name);
+	}
+
+	trap_Cvar_VariableStringBuffer("ui_char_model", model, sizeof(model));
+	trap_Cvar_VariableStringBuffer("ui_char_skin_head", head, sizeof(head));
+	trap_Cvar_VariableStringBuffer("ui_char_skin_torso", torso, sizeof(torso));
+	trap_Cvar_VariableStringBuffer("ui_char_skin_legs", legs, sizeof(legs));
+
+	Com_sprintf( skin, sizeof( skin ), "models/players/%s/|%s|%s|%s", 
+										model, 
+										head, 
+										torso, 
+										legs 
+				);
+
+	ItemParse_model_g2skin_go( item, skin );
+}
+
+static void UI_ResetCharacterListBoxes( void )
+{
+
+	itemDef_t *item;
+	menuDef_t *menu;
+	listBoxDef_t *listPtr;
+
+	menu = Menu_GetFocused();
+
+	if (menu)
+	{
+		item = (itemDef_t *) Menu_FindItemByName((menuDef_t *) menu, "headlistbox");
+		if (item)
+		{
+			listBoxDef_t *listPtr = (listBoxDef_t*)item->typeData;
+			if( listPtr )
+			{
+				listPtr->cursorPos = 0;
+			}
+			item->cursorPos = 0;
+		}
+
+		item = (itemDef_t *) Menu_FindItemByName((menuDef_t *) menu, "torsolistbox");
+		if (item)
+		{
+			listPtr = (listBoxDef_t*)item->typeData;
+			if( listPtr )
+			{
+				listPtr->cursorPos = 0;
+			}
+			item->cursorPos = 0;
+		}
+
+		item = (itemDef_t *) Menu_FindItemByName((menuDef_t *) menu, "lowerlistbox");
+		if (item)
+		{
+			listPtr = (listBoxDef_t*)item->typeData;
+			if( listPtr )
+			{
+				listPtr->cursorPos = 0;
+			}
+			item->cursorPos = 0;
+		}
+
+		item = (itemDef_t *) Menu_FindItemByName((menuDef_t *) menu, "colorbox");
+		if (item)
+		{
+			listPtr = (listBoxDef_t*)item->typeData;
+			if( listPtr )
+			{
+				listPtr->cursorPos = 0;
+			}
+			item->cursorPos = 0;
+		}
+	}
+}
+
+#define MAX_SABER_HILTS	64
+
+char *saberSingleHiltInfo [MAX_SABER_HILTS];
+char *saberStaffHiltInfo [MAX_SABER_HILTS];
+
+qboolean UI_SaberProperNameForSaber( const char *saberName, char *saberProperName );
+void UI_SaberGetHiltInfo( char *singleHilts[MAX_SABER_HILTS],char *staffHilts[MAX_SABER_HILTS] );
+
+
+static void UI_UpdateCharacter( qboolean changedModel )
+{
+	menuDef_t *menu;
+	itemDef_t *item;
+	char modelPath[MAX_QPATH];
+	int	animRunLength;
+
+	menu = Menu_GetFocused();	// Get current menu
+
+	if (!menu)
+	{
+		return;
+	}
+
+	item = (itemDef_t *) Menu_FindItemByName(menu, "character");
+
+	if (!item)
+	{
+		Com_Error( ERR_FATAL, "UI_UpdateCharacter: Could not find item (character) in menu (%s)", menu->window.name);
+	}
+
+	ItemParse_model_g2anim_go( item, ui_char_anim.string );
+
+	Com_sprintf( modelPath, sizeof( modelPath ), "models/players/%s/model.glm", UI_Cvar_VariableString ( "ui_char_model" ) );
+	ItemParse_asset_model_go( item, modelPath, &animRunLength );
+
+	if ( changedModel )
+	{//set all skins to first skin since we don't know you always have all skins
+		//FIXME: could try to keep the same spot in each list as you swtich models
+		UI_FeederSelection(FEEDER_PLAYER_SKIN_HEAD, 0, item);	//fixme, this is not really the right item!!
+		UI_FeederSelection(FEEDER_PLAYER_SKIN_TORSO, 0, item);
+		UI_FeederSelection(FEEDER_PLAYER_SKIN_LEGS, 0, item);
+		UI_FeederSelection(FEEDER_COLORCHOICES, 0, item);
+	}
+	UI_UpdateCharacterSkin();
+}
+
+static void UI_RunMenuScript(char **args) 
+{
+	const char *name, *name2;
+	char buff[1024];
+
+	if (String_Parse(args, &name)) 
+	{
+		if (Q_stricmp(name, "StartServer") == 0) 
+		{
+			int i, added = 0;
+			float skill;
+			int warmupTime = 0;
+			int doWarmup = 0;
+			
+			trap_Cvar_Set("cg_thirdPerson", "0");
+			trap_Cvar_Set("cg_cameraOrbit", "0");
+			// for Solo games I set this to 1 in the menu and don't want it stomped here,
+			// this cvar seems to be reset to 0 in all the proper places so... -dmv
+		//	trap_Cvar_Set("ui_singlePlayerActive", "0");
+
+			// if a solo game is started, automatically turn dedicated off here (don't want to do it in the menu, might get annoying)
+			if( trap_Cvar_VariableValue( "ui_singlePlayerActive" ) )
+			{
+				trap_Cvar_Set( "dedicated", "0" );
+			}
+			else
+			{
+				trap_Cvar_SetValue( "dedicated", Com_Clamp( 0, 2, ui_dedicated.integer ) );
+			}
+			trap_Cvar_SetValue( "g_gametype", Com_Clamp( 0, 8, uiInfo.gameTypes[ui_netGameType.integer].gtEnum ) );
+			trap_Cvar_Set("g_redTeam", UI_Cvar_VariableString("ui_teamName"));
+			trap_Cvar_Set("g_blueTeam", UI_Cvar_VariableString("ui_opponentName"));
+			trap_Cmd_ExecuteText( EXEC_APPEND, va( "wait ; wait ; map %s\n", uiInfo.mapList[ui_currentNetMap.integer].mapLoadName ) );
+			skill = trap_Cvar_VariableValue( "g_spSkill" );
+
+			//Cap the warmup values in case the user tries a dumb setting.
+			warmupTime = trap_Cvar_VariableValue( "g_warmup" );
+			doWarmup = trap_Cvar_VariableValue( "g_doWarmup" );
+
+			if (doWarmup && warmupTime < 1)
+			{
+				trap_Cvar_Set("g_doWarmup", "0");
+			}
+			if (warmupTime < 5)
+			{
+				trap_Cvar_Set("g_warmup", "5");
+			}
+			if (warmupTime > 120)
+			{
+				trap_Cvar_Set("g_warmup", "120");
+			}
+
+			if (trap_Cvar_VariableValue( "g_gametype" ) == GT_DUEL ||
+				trap_Cvar_VariableValue( "g_gametype" ) == GT_POWERDUEL)
+			{ //always set fraglimit 1 when starting a duel game
+				trap_Cvar_Set("fraglimit", "1");
+			}
+
+			for (i = 0; i < PLAYERS_PER_TEAM; i++) 
+			{
+				int bot = trap_Cvar_VariableValue( va("ui_blueteam%i", i+1));
+				int maxcl = trap_Cvar_VariableValue( "sv_maxClients" );
+
+				if (bot > 1) 
+				{
+					int numval = i+1;
+
+					numval *= 2;
+
+					numval -= 1;
+
+					if (numval <= maxcl)
+					{
+						if (ui_actualNetGameType.integer >= GT_TEAM) {
+							Com_sprintf( buff, sizeof(buff), "addbot \"%s\" %f %s\n", UI_GetBotNameByNumber(bot-2), skill, "Blue");
+						} else {
+							Com_sprintf( buff, sizeof(buff), "addbot \"%s\" %f \n", UI_GetBotNameByNumber(bot-2), skill);
+						}
+						trap_Cmd_ExecuteText( EXEC_APPEND, buff );
+						added++;
+					}
+				}
+				bot = trap_Cvar_VariableValue( va("ui_redteam%i", i+1));
+				if (bot > 1) {
+					int numval = i+1;
+
+					numval *= 2;
+
+					if (numval <= maxcl)
+					{
+						if (ui_actualNetGameType.integer >= GT_TEAM) {
+							Com_sprintf( buff, sizeof(buff), "addbot \"%s\" %f %s\n", UI_GetBotNameByNumber(bot-2), skill, "Red");
+						} else {
+							Com_sprintf( buff, sizeof(buff), "addbot \"%s\" %f \n", UI_GetBotNameByNumber(bot-2), skill);
+						}
+						trap_Cmd_ExecuteText( EXEC_APPEND, buff );
+						added++;
+					}
+				}
+				if (added >= maxcl)
+				{ //this means the client filled up all their slots in the UI with bots. So stretch out an extra slot for them, and then stop adding bots.
+					trap_Cvar_Set("sv_maxClients", va("%i", added+1));
+					break;
+				}
+			}
+		} else if (Q_stricmp(name, "updateSPMenu") == 0) {
+			UI_SetCapFragLimits(qtrue);
+			UI_MapCountByGameType(qtrue);
+			ui_mapIndex.integer = UI_GetIndexFromSelection(ui_currentMap.integer);
+			trap_Cvar_Set("ui_mapIndex", va("%d", ui_mapIndex.integer));
+			Menu_SetFeederSelection(NULL, FEEDER_MAPS, ui_mapIndex.integer, "skirmish");
+			UI_GameType_HandleKey(0, 0, A_MOUSE1, qfalse);
+			UI_GameType_HandleKey(0, 0, A_MOUSE2, qfalse);
+		} else if (Q_stricmp(name, "resetDefaults") == 0) {
+			trap_Cmd_ExecuteText( EXEC_APPEND, "cvar_restart\n");
+			trap_Cmd_ExecuteText( EXEC_APPEND, "exec mpdefault.cfg\n");
+			trap_Cmd_ExecuteText( EXEC_APPEND, "vid_restart\n" );
+			trap_Cvar_Set("com_introPlayed", "1" );
+#ifdef USE_CD_KEY
+		} else if (Q_stricmp(name, "getCDKey") == 0) {
+			char out[17];
+			trap_GetCDKey(buff, 17);
+			trap_Cvar_Set("cdkey1", "");
+			trap_Cvar_Set("cdkey2", "");
+			trap_Cvar_Set("cdkey3", "");
+			trap_Cvar_Set("cdkey4", "");
+			if (strlen(buff) == CDKEY_LEN) {
+				Q_strncpyz(out, buff, 5);
+				trap_Cvar_Set("cdkey1", out);
+				Q_strncpyz(out, buff + 4, 5);
+				trap_Cvar_Set("cdkey2", out);
+				Q_strncpyz(out, buff + 8, 5);
+				trap_Cvar_Set("cdkey3", out);
+				Q_strncpyz(out, buff + 12, 5);
+				trap_Cvar_Set("cdkey4", out);
+			}
+
+		} else if (Q_stricmp(name, "verifyCDKey") == 0) {
+			buff[0] = '\0';
+			Q_strcat(buff, 1024, UI_Cvar_VariableString("cdkey1")); 
+			Q_strcat(buff, 1024, UI_Cvar_VariableString("cdkey2")); 
+			Q_strcat(buff, 1024, UI_Cvar_VariableString("cdkey3")); 
+			Q_strcat(buff, 1024, UI_Cvar_VariableString("cdkey4")); 
+			trap_Cvar_Set("cdkey", buff);
+			if (trap_VerifyCDKey(buff, UI_Cvar_VariableString("cdkeychecksum"))) {
+				trap_Cvar_Set("ui_cdkeyvalid", "CD Key Appears to be valid.");
+				trap_SetCDKey(buff);
+			} else {
+				trap_Cvar_Set("ui_cdkeyvalid", "CD Key does not appear to be valid.");
+			}
+#endif // USE_CD_KEY
+		} else if (Q_stricmp(name, "loadArenas") == 0) {
+			UI_LoadArenas();
+			UI_MapCountByGameType(qfalse);
+			Menu_SetFeederSelection(NULL, FEEDER_ALLMAPS, gUISelectedMap, "createserver");
+			uiForceRank = trap_Cvar_VariableValue("g_maxForceRank");
+		} else if (Q_stricmp(name, "saveControls") == 0) {
+			Controls_SetConfig(qtrue);
+		} else if (Q_stricmp(name, "loadControls") == 0) {
+			Controls_GetConfig();
+		} else if (Q_stricmp(name, "clearError") == 0) {
+			trap_Cvar_Set("com_errorMessage", "");
+		} else if (Q_stricmp(name, "loadGameInfo") == 0) {
+			UI_ParseGameInfo("ui/jamp/gameinfo.txt");
+			UI_LoadBestScores(uiInfo.mapList[ui_currentMap.integer].mapLoadName, uiInfo.gameTypes[ui_gameType.integer].gtEnum);
+		} else if (Q_stricmp(name, "resetScores") == 0) {
+			UI_ClearScores();
+		} else if (Q_stricmp(name, "RefreshServers") == 0) {
+			UI_StartServerRefresh(qtrue);
+			UI_BuildServerDisplayList(qtrue);
+		} else if (Q_stricmp(name, "RefreshFilter") == 0) {
+			UI_StartServerRefresh(qfalse);
+			UI_BuildServerDisplayList(qtrue);
+		} else if (Q_stricmp(name, "RunSPDemo") == 0) {
+			if (uiInfo.demoAvailable) {
+			  trap_Cmd_ExecuteText( EXEC_APPEND, va("demo %s_%i\n", uiInfo.mapList[ui_currentMap.integer].mapLoadName, uiInfo.gameTypes[ui_gameType.integer].gtEnum));
+			}
+		} else if (Q_stricmp(name, "LoadDemos") == 0) {
+			UI_LoadDemos();
+		} else if (Q_stricmp(name, "LoadMovies") == 0) {
+			UI_LoadMovies();
+		} else if (Q_stricmp(name, "LoadMods") == 0) {
+			UI_LoadMods();
+		} else if (Q_stricmp(name, "playMovie") == 0) {
+			if (uiInfo.previewMovie >= 0) {
+			  trap_CIN_StopCinematic(uiInfo.previewMovie);
+			}
+			trap_Cmd_ExecuteText( EXEC_APPEND, va("cinematic %s.roq 2\n", uiInfo.movieList[uiInfo.movieIndex]));
+		} else if (Q_stricmp(name, "RunMod") == 0) {
+			trap_Cvar_Set( "fs_game", uiInfo.modList[uiInfo.modIndex].modName);
+			trap_Cmd_ExecuteText( EXEC_APPEND, "vid_restart;" );
+		} else if (Q_stricmp(name, "RunDemo") == 0) {
+			trap_Cmd_ExecuteText( EXEC_APPEND, va("demo \"%s\"\n", uiInfo.demoList[uiInfo.demoIndex]));
+		} else if (Q_stricmp(name, "Quake3") == 0) {
+			trap_Cvar_Set( "fs_game", "");
+			trap_Cmd_ExecuteText( EXEC_APPEND, "vid_restart;" );
+		} else if (Q_stricmp(name, "closeJoin") == 0) {
+			if (uiInfo.serverStatus.refreshActive) {
+				UI_StopServerRefresh();
+				uiInfo.serverStatus.nextDisplayRefresh = 0;
+				uiInfo.nextServerStatusRefresh = 0;
+				uiInfo.nextFindPlayerRefresh = 0;
+				UI_BuildServerDisplayList(qtrue);
+			} else {
+				Menus_CloseByName("joinserver");
+				Menus_OpenByName("main");
+			}
+		} else if (Q_stricmp(name, "StopRefresh") == 0) {
+			UI_StopServerRefresh();
+			uiInfo.serverStatus.nextDisplayRefresh = 0;
+			uiInfo.nextServerStatusRefresh = 0;
+			uiInfo.nextFindPlayerRefresh = 0;
+		} else if (Q_stricmp(name, "UpdateFilter") == 0) {
+			if (ui_netSource.integer == AS_LOCAL) {
+				UI_StartServerRefresh(qtrue);
+			}
+			UI_BuildServerDisplayList(qtrue);
+			UI_FeederSelection(FEEDER_SERVERS, 0, NULL );
+
+		} else if (Q_stricmp(name, "ServerStatus") == 0) {
+			trap_LAN_GetServerAddressString(ui_netSource.integer, uiInfo.serverStatus.displayServers[uiInfo.serverStatus.currentServer], uiInfo.serverStatusAddress, sizeof(uiInfo.serverStatusAddress));
+			UI_BuildServerStatus(qtrue);
+		} else if (Q_stricmp(name, "FoundPlayerServerStatus") == 0) {
+			Q_strncpyz(uiInfo.serverStatusAddress, uiInfo.foundPlayerServerAddresses[uiInfo.currentFoundPlayerServer], sizeof(uiInfo.serverStatusAddress));
+			UI_BuildServerStatus(qtrue);
+			Menu_SetFeederSelection(NULL, FEEDER_FINDPLAYER, 0, NULL);
+		} else if (Q_stricmp(name, "FindPlayer") == 0) {
+			UI_BuildFindPlayerList(qtrue);
+			// clear the displayed server status info
+			uiInfo.serverStatusInfo.numLines = 0;
+			Menu_SetFeederSelection(NULL, FEEDER_FINDPLAYER, 0, NULL);
+		}
+		else if (Q_stricmp(name, "checkservername") == 0)
+		{
+			UI_CheckServerName();
+			
+		}
+		else if (Q_stricmp(name, "checkpassword") == 0)
+		{
+			if( UI_CheckPassword() )
+			{
+				UI_JoinServer();
+			}
+			
+		}
+		else if (Q_stricmp(name, "JoinServer") == 0)
+		{
+			UI_JoinServer();
+		}
+		else if (Q_stricmp(name, "FoundPlayerJoinServer") == 0) {
+			trap_Cvar_Set("ui_singlePlayerActive", "0");
+			if (uiInfo.currentFoundPlayerServer >= 0 && uiInfo.currentFoundPlayerServer < uiInfo.numFoundPlayerServers) {
+				trap_Cmd_ExecuteText( EXEC_APPEND, va( "connect %s\n", uiInfo.foundPlayerServerAddresses[uiInfo.currentFoundPlayerServer] ) );
+			}
+		} else if (Q_stricmp(name, "Quit") == 0) {
+			trap_Cvar_Set("ui_singlePlayerActive", "0");
+			trap_Cmd_ExecuteText( EXEC_NOW, "quit");
+		} else if (Q_stricmp(name, "Controls") == 0) {
+		  trap_Cvar_Set( "cl_paused", "1" );
+			trap_Key_SetCatcher( KEYCATCH_UI );
+			Menus_CloseAll();
+			Menus_ActivateByName("setup_menu2");
+		} 
+		else if (Q_stricmp(name, "Leave") == 0) 
+		{
+			trap_Cmd_ExecuteText( EXEC_APPEND, "disconnect\n" );
+			trap_Key_SetCatcher( KEYCATCH_UI );
+			Menus_CloseAll();
+			Menus_ActivateByName("main");
+		} 
+		else if (Q_stricmp(name, "getvideosetup") == 0) 
+		{
+			UI_GetVideoSetup ( );
+		}
+		else if (Q_stricmp(name, "getsaberhiltinfo") == 0) 
+		{
+			UI_SaberGetHiltInfo(saberSingleHiltInfo,saberStaffHiltInfo);
+		}
+		// On the solo game creation screen, we can't see siege maps
+		else if (Q_stricmp(name, "checkforsiege") == 0) 
+		{
+			if (uiInfo.gameTypes[ui_netGameType.integer].gtEnum == GT_SIEGE)
+			{
+				// fake out the handler to advance to the next game type
+				UI_NetGameType_HandleKey(0, NULL, A_MOUSE1);
+			}
+		}
+		else if (Q_stricmp(name, "updatevideosetup") == 0)
+		{
+			UI_UpdateVideoSetup ( );
+		}
+		else if (Q_stricmp(name, "ServerSort") == 0) 
+		{
+			int sortColumn;
+			if (Int_Parse(args, &sortColumn)) {
+				// if same column we're already sorting on then flip the direction
+				if (sortColumn == uiInfo.serverStatus.sortKey) {
+					uiInfo.serverStatus.sortDir = !uiInfo.serverStatus.sortDir;
+				}
+				// make sure we sort again
+				UI_ServersSort(sortColumn, qtrue);
+			}
+		} else if (Q_stricmp(name, "nextSkirmish") == 0) {
+			UI_StartSkirmish(qtrue);
+		} else if (Q_stricmp(name, "SkirmishStart") == 0) {
+			UI_StartSkirmish(qfalse);
+		} else if (Q_stricmp(name, "closeingame") == 0) {
+			trap_Key_SetCatcher( trap_Key_GetCatcher() & ~KEYCATCH_UI );
+			trap_Key_ClearStates();
+			trap_Cvar_Set( "cl_paused", "0" );
+			Menus_CloseAll();
+		} else if (Q_stricmp(name, "voteMap") == 0) {
+			if (ui_currentNetMap.integer >=0 && ui_currentNetMap.integer < uiInfo.mapCount) {
+				trap_Cmd_ExecuteText( EXEC_APPEND, va("callvote map %s\n",uiInfo.mapList[ui_currentNetMap.integer].mapLoadName) );
+			}
+		} else if (Q_stricmp(name, "voteKick") == 0) {
+			if (uiInfo.playerIndex >= 0 && uiInfo.playerIndex < uiInfo.playerCount) {
+				//trap_Cmd_ExecuteText( EXEC_APPEND, va("callvote kick \"%s\"\n",uiInfo.playerNames[uiInfo.playerIndex]) );
+				trap_Cmd_ExecuteText( EXEC_APPEND, va("callvote clientkick \"%i\"\n",uiInfo.playerIndexes[uiInfo.playerIndex]) );
+			}
+		} else if (Q_stricmp(name, "voteGame") == 0) {
+			if (ui_netGameType.integer >= 0 && ui_netGameType.integer < uiInfo.numGameTypes) {
+				trap_Cmd_ExecuteText( EXEC_APPEND, va("callvote g_gametype %i\n",uiInfo.gameTypes[ui_netGameType.integer].gtEnum) );
+			}
+		} else if (Q_stricmp(name, "voteLeader") == 0) {
+			if (uiInfo.teamIndex >= 0 && uiInfo.teamIndex < uiInfo.myTeamCount) {
+				trap_Cmd_ExecuteText( EXEC_APPEND, va("callteamvote leader \"%s\"\n",uiInfo.teamNames[uiInfo.teamIndex]) );
+			}
+		} else if (Q_stricmp(name, "addBot") == 0) {
+			if (trap_Cvar_VariableValue("g_gametype") >= GT_TEAM) {
+				trap_Cmd_ExecuteText( EXEC_APPEND, va("addbot \"%s\" %i %s\n", UI_GetBotNameByNumber(uiInfo.botIndex), uiInfo.skillIndex+1, (uiInfo.redBlue == 0) ? "Red" : "Blue") );
+			} else {
+				trap_Cmd_ExecuteText( EXEC_APPEND, va("addbot \"%s\" %i %s\n", UI_GetBotNameByNumber(uiInfo.botIndex), uiInfo.skillIndex+1, (uiInfo.redBlue == 0) ? "Red" : "Blue") );
+			}
+		} else if (Q_stricmp(name, "addFavorite") == 0) 
+		{
+			if (ui_netSource.integer != AS_FAVORITES) 
+			{
+				char name[MAX_NAME_LENGTH];
+				char addr[MAX_NAME_LENGTH];
+				int res;
+
+				trap_LAN_GetServerInfo(ui_netSource.integer, uiInfo.serverStatus.displayServers[uiInfo.serverStatus.currentServer], buff, MAX_STRING_CHARS);
+				name[0] = addr[0] = '\0';
+				Q_strncpyz(name, 	Info_ValueForKey(buff, "hostname"), MAX_NAME_LENGTH);
+				Q_strncpyz(addr, 	Info_ValueForKey(buff, "addr"), MAX_NAME_LENGTH);
+				if (strlen(name) > 0 && strlen(addr) > 0) 
+				{
+					res = trap_LAN_AddServer(AS_FAVORITES, name, addr);
+					if (res == 0) 
+					{
+						// server already in the list
+						Com_Printf("Favorite already in list\n");
+					}
+					else if (res == -1) 
+					{
+						// list full
+						Com_Printf("Favorite list full\n");
+					}
+					else 
+					{
+						// successfully added
+						Com_Printf("Added favorite server %s\n", addr);
+
+
+//						trap_SP_GetStringTextString((char *)va("%s_GETTINGINFOFORSERVERS",uiInfo.uiDC.Assets.stringedFile), holdSPString, sizeof(holdSPString));
+//						Text_Paint(rect->x, rect->y, scale, newColor, va((char *) holdSPString, trap_LAN_GetServerCount(ui_netSource.integer)), 0, 0, textStyle);
+
+					}
+				}
+			}
+		} 
+		else if (Q_stricmp(name, "deleteFavorite") == 0) 
+		{
+			if (ui_netSource.integer == AS_FAVORITES) 
+			{
+				char addr[MAX_NAME_LENGTH];
+				trap_LAN_GetServerInfo(ui_netSource.integer, uiInfo.serverStatus.displayServers[uiInfo.serverStatus.currentServer], buff, MAX_STRING_CHARS);
+				addr[0] = '\0';
+				Q_strncpyz(addr, 	Info_ValueForKey(buff, "addr"), MAX_NAME_LENGTH);
+				if (strlen(addr) > 0) 
+				{
+					trap_LAN_RemoveServer(AS_FAVORITES, addr);
+				}
+			}
+		} 
+		else if (Q_stricmp(name, "createFavorite") == 0) 
+		{
+		//	if (ui_netSource.integer == AS_FAVORITES) 
+		//rww - don't know why this check was here.. why would you want to only add new favorites when the filter was favorites?
+			{
+				char name[MAX_NAME_LENGTH];
+				char addr[MAX_NAME_LENGTH];
+				int res;
+
+				name[0] = addr[0] = '\0';
+				Q_strncpyz(name, 	UI_Cvar_VariableString("ui_favoriteName"), MAX_NAME_LENGTH);
+				Q_strncpyz(addr, 	UI_Cvar_VariableString("ui_favoriteAddress"), MAX_NAME_LENGTH);
+				if (/*strlen(name) > 0 &&*/ strlen(addr) > 0) {
+					res = trap_LAN_AddServer(AS_FAVORITES, name, addr);
+					if (res == 0) {
+						// server already in the list
+						Com_Printf("Favorite already in list\n");
+					}
+					else if (res == -1) {
+						// list full
+						Com_Printf("Favorite list full\n");
+					}
+					else {
+						// successfully added
+						Com_Printf("Added favorite server %s\n", addr);
+					}
+				}
+			}
+		} else if (Q_stricmp(name, "orders") == 0) {
+			const char *orders;
+			if (String_Parse(args, &orders)) {
+				int selectedPlayer = trap_Cvar_VariableValue("cg_selectedPlayer");
+				if (selectedPlayer < uiInfo.myTeamCount) {
+					strcpy(buff, orders);
+					trap_Cmd_ExecuteText( EXEC_APPEND, va(buff, uiInfo.teamClientNums[selectedPlayer]) );
+					trap_Cmd_ExecuteText( EXEC_APPEND, "\n" );
+				} else {
+					int i;
+					for (i = 0; i < uiInfo.myTeamCount; i++) {
+						if (Q_stricmp(UI_Cvar_VariableString("name"), uiInfo.teamNames[i]) == 0) {
+							continue;
+						}
+						strcpy(buff, orders);
+						trap_Cmd_ExecuteText( EXEC_APPEND, va(buff, uiInfo.teamNames[i]) );
+						trap_Cmd_ExecuteText( EXEC_APPEND, "\n" );
+					}
+				}
+				trap_Key_SetCatcher( trap_Key_GetCatcher() & ~KEYCATCH_UI );
+				trap_Key_ClearStates();
+				trap_Cvar_Set( "cl_paused", "0" );
+				Menus_CloseAll();
+			}
+		} else if (Q_stricmp(name, "voiceOrdersTeam") == 0) {
+			const char *orders;
+			if (String_Parse(args, &orders)) {
+				int selectedPlayer = trap_Cvar_VariableValue("cg_selectedPlayer");
+				if (selectedPlayer == uiInfo.myTeamCount) {
+					trap_Cmd_ExecuteText( EXEC_APPEND, orders );
+					trap_Cmd_ExecuteText( EXEC_APPEND, "\n" );
+				}
+				trap_Key_SetCatcher( trap_Key_GetCatcher() & ~KEYCATCH_UI );
+				trap_Key_ClearStates();
+				trap_Cvar_Set( "cl_paused", "0" );
+				Menus_CloseAll();
+			}
+		} else if (Q_stricmp(name, "voiceOrders") == 0) {
+			const char *orders;
+			if (String_Parse(args, &orders)) {
+				int selectedPlayer = trap_Cvar_VariableValue("cg_selectedPlayer");
+
+				if (selectedPlayer == uiInfo.myTeamCount)
+				{
+					selectedPlayer = -1;
+					strcpy(buff, orders);
+					trap_Cmd_ExecuteText( EXEC_APPEND, va(buff, selectedPlayer) );
+				}
+				else
+				{
+					strcpy(buff, orders);
+					trap_Cmd_ExecuteText( EXEC_APPEND, va(buff, uiInfo.teamClientNums[selectedPlayer]) );
+				}
+				trap_Cmd_ExecuteText( EXEC_APPEND, "\n" );
+
+				trap_Key_SetCatcher( trap_Key_GetCatcher() & ~KEYCATCH_UI );
+				trap_Key_ClearStates();
+				trap_Cvar_Set( "cl_paused", "0" );
+				Menus_CloseAll();
+			}
+		}
+		else if (Q_stricmp(name, "setForce") == 0)
+		{
+			const char *teamArg;
+
+			if (String_Parse(args, &teamArg))
+			{
+				if ( Q_stricmp( "none", teamArg ) == 0 )
+				{
+					UI_UpdateClientForcePowers(NULL);
+				}
+				else if ( Q_stricmp( "same", teamArg ) == 0 )
+				{//stay on current team
+					int myTeam = (int)(trap_Cvar_VariableValue("ui_myteam"));
+					if ( myTeam != TEAM_SPECTATOR )
+					{
+						UI_UpdateClientForcePowers(UI_TeamName(myTeam));//will cause him to respawn, if it's been 5 seconds since last one
+					}
+					else
+					{
+						UI_UpdateClientForcePowers(NULL);//just update powers
+					}
+				}
+				else
+				{
+					UI_UpdateClientForcePowers(teamArg);
+				}
+			}
+			else
+			{
+				UI_UpdateClientForcePowers(NULL);
+			}
+		}
+		else if (Q_stricmp(name, "setsiegeclassandteam") == 0)
+		{
+			int team = (int)trap_Cvar_VariableValue("ui_holdteam");
+			int oldteam = (int)trap_Cvar_VariableValue("ui_startsiegeteam");
+			qboolean	goTeam = qtrue;
+			char	newclassString[512];
+			char	startclassString[512];
+
+			trap_Cvar_VariableStringBuffer( "ui_mySiegeClass", newclassString, sizeof(newclassString) );
+			trap_Cvar_VariableStringBuffer( "ui_startsiegeclass", startclassString, sizeof(startclassString) );
+
+			// Was just a spectator - is still just a spectator
+			if ((oldteam == team) && (oldteam == 3))
+			{
+				goTeam = qfalse;
+			}
+			// If new team and class match old team and class, just return to the game.
+			else if ((oldteam == team))
+			{	// Classes match?
+				if (g_UIGloballySelectedSiegeClass != -1)
+				{	
+					if (!strcmp(startclassString,bgSiegeClasses[g_UIGloballySelectedSiegeClass].name))
+					{
+						goTeam = qfalse;
+					}
+				}
+			}
+
+			if (goTeam)
+			{
+				if (team == 1)	// Team red
+				{
+					trap_Cvar_Set("ui_team", va("%d", team));
+				}
+				else if (team == 2)	// Team blue
+				{
+					trap_Cvar_Set("ui_team", va("%d", team));
+				}
+				else if (team == 3)	// Team spectator
+				{
+					trap_Cvar_Set("ui_team", va("%d", team));
+				}
+
+				if (g_UIGloballySelectedSiegeClass != -1)
+				{
+					trap_Cmd_ExecuteText( EXEC_APPEND, va("siegeclass \"%s\"\n", bgSiegeClasses[g_UIGloballySelectedSiegeClass].name) );
+				}
+			}
+		}
+		else if (Q_stricmp(name, "setBotButton") == 0) 
+		{
+			UI_SetBotButton();
+		}
+		else if (Q_stricmp(name, "saveTemplate") == 0) {
+			UI_SaveForceTemplate();
+		} else if (Q_stricmp(name, "refreshForce") == 0) {
+			UI_UpdateForcePowers();
+		} else if (Q_stricmp(name, "glCustom") == 0) {
+			trap_Cvar_Set("ui_r_glCustom", "4");
+		} 
+		else if (Q_stricmp(name, "setMovesListDefault") == 0) 
+		{
+			uiInfo.movesTitleIndex = 2;
+		}
+		else if (Q_stricmp(name, "resetMovesList") == 0) 
+		{
+			menuDef_t *menu;
+			menu = Menus_FindByName("rulesMenu_moves");
+			//update saber models
+			if (menu)
+			{
+				itemDef_t *item  = (itemDef_t *) Menu_FindItemByName((menuDef_t *) menu, "character");
+				if (item)
+				{
+					UI_SaberAttachToChar( item );
+				}
+			}
+
+			trap_Cvar_Set( "ui_move_desc", " " );
+		}
+		else if (Q_stricmp(name, "resetcharacterlistboxes") == 0) 
+		{
+			UI_ResetCharacterListBoxes();
+		}
+		else if (Q_stricmp(name, "setMoveCharacter") == 0) 
+		{
+			itemDef_t *item;
+			menuDef_t *menu;
+			modelDef_t *modelPtr;
+			int	animRunLength;
+
+			UI_GetCharacterCvars();
+
+			uiInfo.movesTitleIndex = 0;
+
+			menu = Menus_FindByName("rulesMenu_moves");
+
+			if (menu)
+			{
+				item = (itemDef_t *) Menu_FindItemByName((menuDef_t *) menu, "character");
+				if (item)
+				{
+					modelPtr = (modelDef_t*)item->typeData;
+					if (modelPtr)
+					{
+						char modelPath[MAX_QPATH];
+
+						uiInfo.movesBaseAnim = datapadMoveTitleBaseAnims[uiInfo.movesTitleIndex];
+						ItemParse_model_g2anim_go( item,  uiInfo.movesBaseAnim );
+						uiInfo.moveAnimTime = 0 ;
+
+						Com_sprintf( modelPath, sizeof( modelPath ), "models/players/%s/model.glm", UI_Cvar_VariableString ( "ui_char_model" ) );
+						ItemParse_asset_model_go( item, modelPath, &animRunLength);
+
+						UI_UpdateCharacterSkin();
+						UI_SaberAttachToChar( item );
+					}
+				}
+			} 
+		}
+		else if (Q_stricmp(name, "character") == 0) 
+		{
+			UI_UpdateCharacter( qfalse );
+		}
+		else if (Q_stricmp(name, "characterchanged") == 0) 
+		{
+			UI_UpdateCharacter( qtrue );
+		}
+		else if (Q_stricmp(name, "updatecharcvars") == 0
+			|| (Q_stricmp(name, "updatecharmodel") == 0) )
+		{
+			UI_UpdateCharacterCvars();
+		}
+		else if (Q_stricmp(name, "getcharcvars") == 0) 
+		{
+			UI_GetCharacterCvars();
+		}
+		else if (Q_stricmp(name, "char_skin") == 0) 
+		{
+			UI_UpdateCharacterSkin();
+		}
+		else if (Q_stricmp(name, "setui_dualforcepower") == 0) 
+		{
+			int forcePowerDisable = trap_Cvar_VariableValue("g_forcePowerDisable");
+			int	i, forceBitFlag=0;
+
+			// Turn off all powers but a few
+			for (i=0;i<NUM_FORCE_POWERS;i++)
+			{
+				if ((i != FP_LEVITATION) &&
+					(i != FP_PUSH) &&
+					(i != FP_PULL) &&
+					(i != FP_SABERTHROW) &&
+					(i != FP_SABER_DEFENSE) &&
+					(i != FP_SABER_OFFENSE))
+				{
+					forceBitFlag |= (1<<i);
+				}
+			}
+
+
+			if (forcePowerDisable==0)
+			{
+				trap_Cvar_Set("ui_dualforcepower", "0");
+			}
+			else if (forcePowerDisable==forceBitFlag)
+			{
+				trap_Cvar_Set("ui_dualforcepower", "2");
+			}
+			else 
+			{
+				trap_Cvar_Set("ui_dualforcepower", "1");
+			}
+
+		}
+		else if (Q_stricmp(name, "dualForcePowers") == 0) 
+		{
+			int	dualforcePower,i, forcePowerDisable;
+			dualforcePower = trap_Cvar_VariableValue("ui_dualforcepower");
+
+			if (dualforcePower==0)	// All force powers
+			{
+				forcePowerDisable = 0;
+			}
+			else if (dualforcePower==1)	// Remove All force powers
+			{
+				// It was set to something, so might as well make sure it got all flags set.
+				for (i=0;i<NUM_FORCE_POWERS;i++)
+				{
+					forcePowerDisable |= (1<<i);
+				}
+			}
+			else if (dualforcePower==2)	// Limited force powers
+			{
+				forcePowerDisable = 0;						
+				
+				// Turn off all powers but a few
+				for (i=0;i<NUM_FORCE_POWERS;i++)
+				{
+					if ((i != FP_LEVITATION) &&
+						(i != FP_PUSH) &&
+						(i != FP_PULL) &&
+						(i != FP_SABERTHROW) &&
+						(i != FP_SABER_DEFENSE) &&
+						(i != FP_SABER_OFFENSE))
+					{
+						forcePowerDisable |= (1<<i);
+					}
+				}
+			}
+
+			trap_Cvar_Set("g_forcePowerDisable", va("%i",forcePowerDisable));
+		}
+		else if (Q_stricmp(name, "forcePowersDisable") == 0) 
+		{
+			int	forcePowerDisable,i;
+
+			forcePowerDisable = trap_Cvar_VariableValue("g_forcePowerDisable");
+
+			// It was set to something, so might as well make sure it got all flags set.
+			if (forcePowerDisable)
+			{
+				for (i=0;i<NUM_FORCE_POWERS;i++)
+				{
+					forcePowerDisable |= (1<<i);
+				}
+
+				trap_Cvar_Set("g_forcePowerDisable", va("%i",forcePowerDisable));
+			}
+
+		} 
+		else if (Q_stricmp(name, "weaponDisable") == 0) 
+		{
+			int	weaponDisable,i;
+			const char *cvarString;
+
+			if (uiInfo.gameTypes[ui_netGameType.integer].gtEnum == GT_DUEL ||
+				uiInfo.gameTypes[ui_netGameType.integer].gtEnum == GT_POWERDUEL)
+			{
+				cvarString = "g_duelWeaponDisable";
+			}
+			else
+			{
+				cvarString = "g_weaponDisable";
+			}
+
+			weaponDisable = trap_Cvar_VariableValue(cvarString);
+
+			// It was set to something, so might as well make sure it got all flags set.
+			if (weaponDisable)
+			{
+				for (i=0;i<WP_NUM_WEAPONS;i++)
+				{
+					if (i!=WP_SABER)
+					{
+						weaponDisable |= (1<<i);
+					}
+				}
+
+				trap_Cvar_Set(cvarString, va("%i",weaponDisable));
+			}
+		} 
+		// If this is siege, change all the bots to humans, because we faked it earlier 
+		//  swapping humans for bots on the menu
+		else if (Q_stricmp(name, "setSiegeNoBots") == 0) 
+		{
+			int blueValue,redValue,i;
+
+			if (uiInfo.gameTypes[ui_netGameType.integer].gtEnum == GT_SIEGE)
+			{
+                //hmm, I guess I'll set bot_minplayers to 0 here too. -rww
+				trap_Cvar_Set("bot_minplayers", "0");
+
+				for (i=1;i<9;i++)
+				{
+					blueValue = trap_Cvar_VariableValue(va("ui_blueteam%i",i ));
+					if (blueValue>1)
+					{
+						trap_Cvar_Set(va("ui_blueteam%i",i ), "1");
+					}
+
+					redValue = trap_Cvar_VariableValue(va("ui_redteam%i",i ));
+					if (redValue>1)
+					{
+						trap_Cvar_Set(va("ui_redteam%i",i ), "1");
+					}
+
+				}
+			}
+		}
+		else if (Q_stricmp(name, "clearmouseover") == 0) 
+		{
+			itemDef_t *item;
+			menuDef_t *menu = Menu_GetFocused();
+
+			if (menu) 
+			{
+				int count,j;
+				const char *itemName;
+				String_Parse(args, &itemName);
+
+				count = Menu_ItemsMatchingGroup(menu, itemName);
+
+				for (j = 0; j < count; j++) 
+				{
+					item = Menu_GetMatchingItemByNumber( menu, j, itemName);
+					if (item != NULL) 
+					{
+							item->window.flags &= ~WINDOW_MOUSEOVER;
+					}
+				}
+			}
+
+		}
+		else if (Q_stricmp(name, "updateForceStatus") == 0)
+		{
+			UpdateForceStatus();
+		}
+		else if (Q_stricmp(name, "update") == 0) 
+		{
+			if (String_Parse(args, &name2)) 
+			{
+				UI_Update(name2);
+			}
+		}
+		else if (Q_stricmp(name, "setBotButtons") == 0)
+		{
+			UpdateBotButtons();
+		}
+		else if (Q_stricmp(name, "getsabercvars") == 0) 
+		{
+			UI_GetSaberCvars();
+		}
+		else if (Q_stricmp(name, "setsaberboxesandhilts") == 0) 
+		{
+			UI_SetSaberBoxesandHilts();
+		}
+		else if (Q_stricmp(name, "saber_type") == 0) 
+		{
+			UI_UpdateSaberType();
+		}
+		else if (Q_stricmp(name, "saber_hilt") == 0) 
+		{
+			UI_UpdateSaberHilt( qfalse );
+		}
+		else if (Q_stricmp(name, "saber_color") == 0) 
+		{
+			UI_UpdateSaberColor( qfalse );
+		}
+		else if (Q_stricmp(name, "setscreensaberhilt") == 0) 
+		{
+			menuDef_t *menu;
+			itemDef_t *item;
+
+			menu = Menu_GetFocused();	// Get current menu
+			if (menu)
+			{
+				item = (itemDef_t *) Menu_FindItemByName((menuDef_t *) menu, "hiltbut");
+				if (item)
+				{
+					if (saberSingleHiltInfo[item->cursorPos])
+					{
+						trap_Cvar_Set( "ui_saber", saberSingleHiltInfo[item->cursorPos] );
+					}
+				}
+			}
+		}
+		else if (Q_stricmp(name, "setscreensaberhilt1") == 0) 
+		{
+			menuDef_t *menu;
+			itemDef_t *item;
+
+			menu = Menu_GetFocused();	// Get current menu
+			if (menu)
+			{
+				item = (itemDef_t *) Menu_FindItemByName((menuDef_t *) menu, "hiltbut1");
+				if (item)
+				{
+					if (saberSingleHiltInfo[item->cursorPos])
+					{
+						trap_Cvar_Set( "ui_saber", saberSingleHiltInfo[item->cursorPos] );
+					}
+				}
+			}
+		}
+		else if (Q_stricmp(name, "setscreensaberhilt2") == 0) 
+		{
+			menuDef_t *menu;
+			itemDef_t *item;
+
+			menu = Menu_GetFocused();	// Get current menu
+			if (menu)
+			{
+				item = (itemDef_t *) Menu_FindItemByName((menuDef_t *) menu, "hiltbut2");
+				if (item)
+				{
+					if (saberSingleHiltInfo[item->cursorPos])
+					{
+						trap_Cvar_Set( "ui_saber2", saberSingleHiltInfo[item->cursorPos] );
+					}
+				}
+			}
+		}
+		else if (Q_stricmp(name, "setscreensaberstaff") == 0) 
+		{
+			menuDef_t *menu;
+			itemDef_t *item;
+
+			menu = Menu_GetFocused();	// Get current menu
+			if (menu)
+			{
+				item = (itemDef_t *) Menu_FindItemByName((menuDef_t *) menu, "hiltbut_staves");
+				if (item)
+				{
+					if (saberSingleHiltInfo[item->cursorPos])
+					{
+						trap_Cvar_Set( "ui_saber", saberStaffHiltInfo[item->cursorPos] );
+					}
+				}
+			}
+		}
+		else if (Q_stricmp(name, "saber2_hilt") == 0) 
+		{
+			UI_UpdateSaberHilt( qtrue );
+		}
+		else if (Q_stricmp(name, "saber2_color") == 0) 
+		{
+			UI_UpdateSaberColor( qtrue );
+		}
+		else if (Q_stricmp(name, "updatesabercvars") == 0) 
+		{
+			UI_UpdateSaberCvars();
+		}
+		else if (Q_stricmp(name, "updatesiegeobjgraphics") == 0) 
+		{
+			int team = (int)trap_Cvar_VariableValue("ui_team");
+			trap_Cvar_Set("ui_holdteam", va("%d", team));
+
+			UI_UpdateSiegeObjectiveGraphics();
+		}
+		else if (Q_stricmp(name, "setsiegeobjbuttons") == 0) 
+		{
+			const char *itemArg;
+			const char *cvarLitArg;
+			const char *cvarNormalArg;
+			char	string[512];
+			char	string2[512];
+			menuDef_t *menu;
+			itemDef_t *item;
+
+			menu = Menu_GetFocused();	// Get current menu
+			if (menu)
+			{
+				// Set the new item to the background 
+				if (String_Parse(args, &itemArg))
+				{
+
+					// Set the old button to it's original background
+					trap_Cvar_VariableStringBuffer( "currentObjMapIconItem", string, sizeof(string) );
+					item = (itemDef_t *) Menu_FindItemByName((menuDef_t *) menu, string);
+					if (item)
+					{
+							// A cvar holding the name of a cvar - how crazy is that?
+							trap_Cvar_VariableStringBuffer( "currentObjMapIconBackground", string, sizeof(string) );
+							trap_Cvar_VariableStringBuffer( string, string2, sizeof(string2) );
+							Menu_SetItemBackground(menu, item->window.name, string2);
+
+							// Re-enable this button
+							Menu_ItemDisable(menu,(char *) item->window.name, qfalse);
+					}
+
+					// Set the new item to the given background
+					item = (itemDef_t *) Menu_FindItemByName((menuDef_t *) menu, itemArg);
+					if (item)
+					{	// store item name
+						trap_Cvar_Set("currentObjMapIconItem",	 item->window.name);
+						if (String_Parse(args, &cvarNormalArg))
+						{	// Store normal background
+							trap_Cvar_Set("currentObjMapIconBackground", cvarNormalArg);
+							// Get higlight background
+							if (String_Parse(args, &cvarLitArg))
+							{	// set hightlight background
+								trap_Cvar_VariableStringBuffer( cvarLitArg, string, sizeof(string) );
+								Menu_SetItemBackground(menu, item->window.name, string);
+								// Disable button
+								Menu_ItemDisable(menu,(char *) item->window.name, qtrue);
+							}
+						}
+					}
+				}
+			}
+
+
+		}
+		else if (Q_stricmp(name, "updatesiegeclasscnt") == 0) 
+		{
+			const char *teamArg;
+
+			if (String_Parse(args, &teamArg))
+			{
+					UI_SiegeClassCnt(atoi(teamArg));
+			}
+		}
+		else if (Q_stricmp(name, "updatesiegecvars") == 0) 
+		{
+			int team,baseClass; 
+	
+			team = (int)trap_Cvar_VariableValue("ui_holdteam");
+			baseClass = (int)trap_Cvar_VariableValue("ui_siege_class");
+
+			UI_UpdateCvarsForClass(team, baseClass, 0);
+
+		}
+		// Save current team and class
+		else if (Q_stricmp(name, "setteamclassicons") == 0)
+		{
+			int team = (int)trap_Cvar_VariableValue("ui_holdteam");
+			char	classString[512];
+
+			trap_Cvar_VariableStringBuffer( "ui_mySiegeClass", classString, sizeof(classString) );
+
+			trap_Cvar_Set("ui_startsiegeteam", va("%d", team));
+		 	trap_Cvar_Set( "ui_startsiegeclass", classString);
+
+			// If player is already on a team, set up icons to show it.
+			UI_FindCurrentSiegeTeamClass();
+
+		}
+		else if (Q_stricmp(name, "updatesiegeweapondesc") == 0)
+		{
+			menuDef_t *menu;
+			itemDef_t *item;
+
+			menu = Menu_GetFocused();	// Get current menu
+			if (menu)
+			{
+				item = (itemDef_t *) Menu_FindItemByName((menuDef_t *) menu, "base_class_weapons_feed");
+				if (item)
+				{
+					char	info[MAX_INFO_VALUE];
+					trap_Cvar_VariableStringBuffer( va("ui_class_weapondesc%i", item->cursorPos), info, sizeof(info) );
+					trap_Cvar_Set( "ui_itemforceinvdesc", info );
+				}
+			}
+		}
+		else if (Q_stricmp(name, "updatesiegeinventorydesc") == 0)
+		{
+			menuDef_t *menu;
+			itemDef_t *item;
+
+			menu = Menu_GetFocused();	// Get current menu
+			if (menu)
+			{
+				item = (itemDef_t *) Menu_FindItemByName((menuDef_t *) menu, "base_class_inventory_feed");
+				if (item)
+				{
+					char info[MAX_INFO_VALUE];
+					trap_Cvar_VariableStringBuffer( va("ui_class_itemdesc%i", item->cursorPos), info, sizeof(info) );
+					trap_Cvar_Set( "ui_itemforceinvdesc", info );
+				}
+			}
+		}
+		else if (Q_stricmp(name, "updatesiegeforcedesc") == 0)
+		{
+			menuDef_t *menu;
+			itemDef_t *item;
+
+			menu = Menu_GetFocused();	// Get current menu
+			if (menu)
+			{
+				item = (itemDef_t *) Menu_FindItemByName((menuDef_t *) menu, "base_class_force_feed");
+				if (item)
+				{
+					int i;
+					char info[MAX_STRING_CHARS];
+
+					trap_Cvar_VariableStringBuffer( va("ui_class_power%i", item->cursorPos), info, sizeof(info) );
+
+					//count them up
+					for (i=0;i< NUM_FORCE_POWERS;i++)
+					{
+						if (!strcmp(HolocronIcons[i],info))
+						{
+							trap_Cvar_Set( "ui_itemforceinvdesc", forcepowerDesc[i] );
+						}
+					}
+				}
+			}
+		}
+		else if (Q_stricmp(name, "resetitemdescription") == 0)
+		{
+			menuDef_t *menu;
+			itemDef_t *item;
+
+			menu = Menu_GetFocused();	// Get current menu
+			if (menu)
+			{
+
+				item = (itemDef_t *) Menu_FindItemByName((menuDef_t *) menu, "itemdescription");
+				if (item)
+				{
+					listBoxDef_t *listPtr = (listBoxDef_t*)item->typeData;
+					if (listPtr)
+					{
+						listPtr->startPos = 0;
+						listPtr->cursorPos = 0;
+					}
+					item->cursorPos = 0;
+				}
+			}
+		}
+		else if (Q_stricmp(name, "resetsiegelistboxes") == 0)
+		{
+			menuDef_t *menu;
+			itemDef_t *item;
+
+			menu = Menu_GetFocused();	// Get current menu
+			if (menu)
+			{
+				item = (itemDef_t *) Menu_FindItemByName((menuDef_t *) menu, "description");
+				if (item)
+				{
+					listBoxDef_t *listPtr = (listBoxDef_t*)item->typeData;
+					if (listPtr)
+					{
+						listPtr->startPos = 0;
+					}
+					item->cursorPos = 0;
+				}
+			}
+
+			menu = Menu_GetFocused();	// Get current menu
+			if (menu)
+			{
+				item = (itemDef_t *) Menu_FindItemByName((menuDef_t *) menu, "base_class_weapons_feed");
+				if (item)
+				{
+					listBoxDef_t *listPtr = (listBoxDef_t*)item->typeData;
+					if (listPtr)
+					{
+						listPtr->startPos = 0;
+					}
+					item->cursorPos = 0;
+				}
+
+				item = (itemDef_t *) Menu_FindItemByName((menuDef_t *) menu, "base_class_inventory_feed");
+				if (item)
+				{
+					listBoxDef_t *listPtr = (listBoxDef_t*)item->typeData;
+					if (listPtr)
+					{
+						listPtr->startPos = 0;
+					}
+					item->cursorPos = 0;
+				}
+
+				item = (itemDef_t *) Menu_FindItemByName((menuDef_t *) menu, "base_class_force_feed");
+				if (item)
+				{
+					listBoxDef_t *listPtr = (listBoxDef_t*)item->typeData;
+					if (listPtr)
+					{
+						listPtr->startPos = 0;
+					}
+					item->cursorPos = 0;
+				}	
+			}
+		}
+		else if (Q_stricmp(name, "updatesiegestatusicons") == 0) 
+		{
+			UI_UpdateSiegeStatusIcons();
+		}
+		else if (Q_stricmp(name, "setcurrentNetMap") == 0) 
+		{
+			menuDef_t *menu;
+			itemDef_t *item;
+
+			menu = Menu_GetFocused();	// Get current menu
+			if (menu)
+			{
+				item = (itemDef_t *) Menu_FindItemByName((menuDef_t *) menu, "maplist");
+				if (item)
+				{
+					listBoxDef_t *listPtr = (listBoxDef_t*)item->typeData;
+					if (listPtr)
+					{
+						trap_Cvar_Set("ui_currentNetMap", va("%d",listPtr->cursorPos));
+					}
+				}
+			}
+		}
+		else if (Q_stricmp(name, "resetmaplist") == 0) 
+		{
+			menuDef_t *menu;
+			itemDef_t *item;
+		
+			menu = Menu_GetFocused();	// Get current menu
+			if (menu)
+			{
+				item = (itemDef_t *) Menu_FindItemByName((menuDef_t *) menu, "maplist");
+				if (item)
+				{
+					uiInfo.uiDC.feederSelection(item->special, item->cursorPos, item);
+				}
+			}
+		}
+		else if (Q_stricmp(name, "getmousepitch") == 0)
+		{
+			trap_Cvar_Set("ui_mousePitch", (trap_Cvar_VariableValue("m_pitch") >= 0) ? "0" : "1");
+		}
+		else if (Q_stricmp(name, "clampmaxplayers") == 0)
+		{
+			UI_ClampMaxPlayers();
+		}
+#ifdef _XBOX
+		// XBL uiScript commands
+		else if (Q_stricmp(name, "initaccountlist") == 0)
+		{
+			// Make sure that things are up and running
+			XBL_Init();
+		}
+		else if (Q_stricmp(name, "createaccount") == 0)
+		{
+			UI_xboxErrorPopup( XB_POPUP_CONFIRM_NEW_ACCOUNT );
+		}
+		else if (Q_stricmp(name, "logonlive") == 0)
+		{
+			// We've already called SetAccountIndex somewhere
+			// We don't even check for return value - this just kicks off a
+			// giant sequence of popups and such, ending with the lobby
+			XBL_Login( LOGIN_PASSCODE_CHECK );
+		}
+		else if (Q_stricmp(name, "logofflive") == 0)
+		{
+			// User is already logged on - is trying to back out. Get confirmation
+			UI_xboxErrorPopup( XB_POPUP_CONFIRM_LOGOFF );
+		}
+		else if (Q_stricmp(name, "quickmatch") == 0)
+		{
+			// VVFIXME - Someone needs to handle quickmatch resulting UI (errors)
+			// Probably done within XBL_MM_QuickMatch() though...
+			if (XBL_MM_QuickMatch())
+			{
+				// QuickMatch code has already issued a connect...
+				Menus_CloseAll();
+			}
+		}
+		else if (Q_stricmp(name, "optimatch") == 0)
+		{
+			// Run the query
+			XBL_MM_Find_Session(
+				(ui_optiGameType.integer >= 0) ? ui_optiGameType.integer : X_MATCH_NULL_INTEGER,
+				(ui_optiCurrentMap.integer >= 0) ? ui_optiCurrentMap.integer : X_MATCH_NULL_INTEGER,
+				ui_optiMinPlayers.integer,
+				ui_optiMaxPlayers.integer,
+				(ui_optiFriendlyFire.integer >= 0) ? ui_optiFriendlyFire.integer : X_MATCH_NULL_INTEGER,
+				(ui_optiJediMastery.integer >= 0) ? ui_optiJediMastery.integer : X_MATCH_NULL_INTEGER,
+				(ui_optiSaberOnly.integer >= 0) ? ui_optiSaberOnly.integer : X_MATCH_NULL_INTEGER);
+
+			// Everything else is handled automatically. XBL_MM_Tick is getting pings for us,
+			// results already exists and will be pulled by the listbox drawing code.
+			Menus_CloseAll();
+			Menus_OpenByName("optimatch_results");
+		}
+		else if (Q_stricmp(name, "haltoptimatch") == 0)
+		{
+			// Cancels probing of QoS from results once we've backed out or started joining a server
+			XBL_MM_CancelProbing();
+		}
+		else if (Q_stricmp(name, "xboxErrorResponse") == 0)
+		{
+			// User closed the Xbox Error Popup in some way. Do TheRightThing(TM)
+			UI_xboxPopupResponse();
+		}
+		else if (Q_stricmp(name, "singleplayer") == 0)
+		{
+			extern void Sys_Reboot( const char *reason );
+			Sys_Reboot("singleplayer");
+		}
+		else if (Q_stricmp(name, "plyrList") == 0)
+		{
+			// Handles all player list functionality as secondary commands
+			UI_XBL_PlayerListScript(args, name);
+		}
+		else if (Q_stricmp(name, "friendsList") == 0)
+		{
+			// Handles all friends list functionality as secondary commands
+			UI_XBL_FriendsListScript(args, name);
+		}
+		else if (Q_stricmp(name, "getvoicemask") == 0)
+		{
+			// Retrieve current voice mask value for UI display
+			trap_Cvar_SetValue( "ui_voiceMask", g_Voice.GetVoiceMask() );
+		}
+		else if (Q_stricmp(name, "setvoicemask") == 0)
+		{
+			// Update voice mask being used from UI version
+			g_Voice.SetVoiceMask( trap_Cvar_VariableValue( "ui_voiceMask" ) );
+		}
+#endif
+		else 
+		{
+			Com_Printf("unknown UI script %s\n", name);
+		}
+	}
+}
+
+static void UI_GetTeamColor(vec4_t *color) {
+}
+
+#include "../namespace_begin.h"
+int BG_SiegeCountBaseClass(const int team, const short classIndex);
+#include "../namespace_end.h"
+
+static void UI_SiegeClassCnt( const int team )
+{
+	UI_SetSiegeTeams();
+
+	trap_Cvar_Set("ui_infantry_cnt", va("%d", BG_SiegeCountBaseClass(team,0)));
+	trap_Cvar_Set("ui_vanguard_cnt", va("%d", BG_SiegeCountBaseClass(team,1)));
+	trap_Cvar_Set("ui_support_cnt", va("%d", BG_SiegeCountBaseClass(team,2)));
+	trap_Cvar_Set("ui_jedi_cnt", va("%d", BG_SiegeCountBaseClass(team,3)));
+	trap_Cvar_Set("ui_demo_cnt", va("%d", BG_SiegeCountBaseClass(team,4)));
+	trap_Cvar_Set("ui_heavy_cnt", va("%d", BG_SiegeCountBaseClass(team,5)));
+
+}
+
+void UI_ClampMaxPlayers(void)
+{
+	char	buf[32];
+	// min checks
+	//
+	if( uiInfo.gameTypes[ui_netGameType.integer].gtEnum == GT_DUEL ) //DUEL
+	{
+		if( trap_Cvar_VariableValue("sv_maxClients") < 2 )
+		{
+			trap_Cvar_Set("sv_maxClients", "2");
+		}
+	}
+	else if( uiInfo.gameTypes[ui_netGameType.integer].gtEnum == GT_POWERDUEL ) // POWER DUEL
+	{
+		if( trap_Cvar_VariableValue("sv_maxClients") < 3 )
+		{
+			trap_Cvar_Set("sv_maxClients", "3");
+		}
+	}
+
+	
+	// max check for all game types
+	if( trap_Cvar_VariableValue("sv_maxClients") > MAX_CLIENTS )
+	{
+		sprintf(buf,"%d",MAX_CLIENTS);
+		trap_Cvar_Set("sv_maxClients", buf);
+	}
+
+}
+
+void	UI_UpdateSiegeStatusIcons(void)
+{
+    menuDef_t *menu = Menu_GetFocused();
+	int i;
+
+	menu = Menu_GetFocused();	// Get current menu
+
+	if (!menu)
+	{
+		return;
+	}
+
+	for (i=0;i<7;i++)
+	{
+
+		Menu_SetItemBackground(menu,va("wpnicon0%d",i), va("*ui_class_weapon%d",i));
+	}
+
+	for (i=0;i<7;i++)
+	{
+		Menu_SetItemBackground(menu,va("itemicon0%d",i), va("*ui_class_item%d",i));
+	}
+
+	for (i=0;i<10;i++)
+	{
+		Menu_SetItemBackground(menu,va("forceicon0%d",i), va("*ui_class_power%d",i));
+	}
+
+	for (i=10;i<15;i++)
+	{
+		Menu_SetItemBackground(menu,va("forceicon%d",i), va("*ui_class_power%d",i));
+	}
+
+}
+
+/*
+==================
+UI_MapCountByGameType
+==================
+*/
+static int UI_MapCountByGameType(qboolean singlePlayer) {
+	int i, c, game;
+	c = 0;
+	game = singlePlayer ? uiInfo.gameTypes[ui_gameType.integer].gtEnum : uiInfo.gameTypes[ui_netGameType.integer].gtEnum;
+	if (game == GT_SINGLE_PLAYER) {
+		game++;
+	} 
+	if (game == GT_TEAM) {
+		game = GT_FFA;
+	}
+	if (game == GT_HOLOCRON || game == GT_JEDIMASTER) {
+		game = GT_FFA;
+	}
+
+	for (i = 0; i < uiInfo.mapCount; i++) {
+		uiInfo.mapList[i].active = qfalse;
+		if ( uiInfo.mapList[i].typeBits & (1 << game)) {
+			if (singlePlayer) {
+				if (!(uiInfo.mapList[i].typeBits & (1 << GT_SINGLE_PLAYER))) {
+					continue;
+				}
+			}
+			c++;
+			uiInfo.mapList[i].active = qtrue;
+		}
+	}
+	return c;
+}
+
+qboolean UI_hasSkinForBase(const char *base, const char *team) {
+	char	test[1024];
+	fileHandle_t	f;
+	
+	Com_sprintf( test, sizeof( test ), "models/players/%s/%s/lower_default.skin", base, team );
+	trap_FS_FOpenFile(test, &f, FS_READ);
+	if (f != 0) {
+		trap_FS_FCloseFile(f);
+		return qtrue;
+	}
+	Com_sprintf( test, sizeof( test ), "models/players/characters/%s/%s/lower_default.skin", base, team );
+	trap_FS_FOpenFile(test, &f, FS_READ);
+	if (f != 0) {
+		trap_FS_FCloseFile(f);
+		return qtrue;
+	}
+	return qfalse;
+}
+
+/*
+==================
+UI_HeadCountByColor
+==================
+*/
+static int UI_HeadCountByColor() {
+	int i, c;
+	char *teamname;
+
+	c = 0;
+
+	switch(uiSkinColor)
+	{
+		case TEAM_BLUE:
+			teamname = "/blue";
+			break;
+		case TEAM_RED:
+			teamname = "/red";
+			break;
+		default:
+			teamname = "/default";
+	}
+
+	// Count each head with this color
+	for (i=0; i<uiInfo.q3HeadCount; i++)
+	{
+		if (uiInfo.q3HeadNames[i] && strstr(uiInfo.q3HeadNames[i], teamname))
+		{
+			c++;
+		}
+	}
+	return c;
+}
+
+/*
+==================
+UI_InsertServerIntoDisplayList
+==================
+*/
+static void UI_InsertServerIntoDisplayList(int num, int position) {
+	int i;
+
+	if (position < 0 || position > uiInfo.serverStatus.numDisplayServers ) {
+		return;
+	}
+	//
+	uiInfo.serverStatus.numDisplayServers++;
+	for (i = uiInfo.serverStatus.numDisplayServers; i > position; i--) {
+		uiInfo.serverStatus.displayServers[i] = uiInfo.serverStatus.displayServers[i-1];
+	}
+	uiInfo.serverStatus.displayServers[position] = num;
+}
+
+/*
+==================
+UI_RemoveServerFromDisplayList
+==================
+*/
+static void UI_RemoveServerFromDisplayList(int num) {
+	int i, j;
+
+	for (i = 0; i < uiInfo.serverStatus.numDisplayServers; i++) {
+		if (uiInfo.serverStatus.displayServers[i] == num) {
+			uiInfo.serverStatus.numDisplayServers--;
+			for (j = i; j < uiInfo.serverStatus.numDisplayServers; j++) {
+				uiInfo.serverStatus.displayServers[j] = uiInfo.serverStatus.displayServers[j+1];
+			}
+			return;
+		}
+	}
+}
+
+/*
+==================
+UI_BinaryServerInsertion
+==================
+*/
+static void UI_BinaryServerInsertion(int num) {
+	int mid, offset, res, len;
+
+	// use binary search to insert server
+	len = uiInfo.serverStatus.numDisplayServers;
+	mid = len;
+	offset = 0;
+	res = 0;
+	while(mid > 0) {
+		mid = len >> 1;
+		//
+		res = trap_LAN_CompareServers( ui_netSource.integer, uiInfo.serverStatus.sortKey,
+					uiInfo.serverStatus.sortDir, num, uiInfo.serverStatus.displayServers[offset+mid]);
+		// if equal
+		if (res == 0) {
+			UI_InsertServerIntoDisplayList(num, offset+mid);
+			return;
+		}
+		// if larger
+		else if (res == 1) {
+			offset += mid;
+			len -= mid;
+		}
+		// if smaller
+		else {
+			len -= mid;
+		}
+	}
+	if (res == 1) {
+		offset++;
+	}
+	UI_InsertServerIntoDisplayList(num, offset);
+}
+
+/*
+==================
+UI_BuildServerDisplayList
+==================
+*/
+static void UI_BuildServerDisplayList(qboolean force) {
+	int i, count, clients, maxClients, ping, game, len/*, visible*/;
+	char info[MAX_STRING_CHARS];
+//	qboolean startRefresh = qtrue; TTimo: unused
+	static int numinvisible;
+
+	if (!(force || uiInfo.uiDC.realTime > uiInfo.serverStatus.nextDisplayRefresh)) {
+		return;
+	}
+	// if we shouldn't reset
+	if ( force == 2 ) {
+		force = 0;
+	}
+
+	// do motd updates here too
+	trap_Cvar_VariableStringBuffer( "cl_motdString", uiInfo.serverStatus.motd, sizeof(uiInfo.serverStatus.motd) );
+	len = strlen(uiInfo.serverStatus.motd);
+	if (len == 0) {
+		strcpy(uiInfo.serverStatus.motd, "Welcome to Jedi Academy MP!");
+		len = strlen(uiInfo.serverStatus.motd);
+	} 
+	if (len != uiInfo.serverStatus.motdLen) {
+		uiInfo.serverStatus.motdLen = len;
+		uiInfo.serverStatus.motdWidth = -1;
+	} 
+
+	if (force) {
+		numinvisible = 0;
+		// clear number of displayed servers
+		uiInfo.serverStatus.numDisplayServers = 0;
+		uiInfo.serverStatus.numPlayersOnServers = 0;
+		// set list box index to zero
+		Menu_SetFeederSelection(NULL, FEEDER_SERVERS, 0, NULL);
+		// mark all servers as visible so we store ping updates for them
+		trap_LAN_MarkServerVisible(ui_netSource.integer, -1, qtrue);
+	}
+
+	// get the server count (comes from the master)
+	count = trap_LAN_GetServerCount(ui_netSource.integer);
+	if (count == -1 || (ui_netSource.integer == AS_LOCAL && count == 0) ) {
+		// still waiting on a response from the master
+		uiInfo.serverStatus.numDisplayServers = 0;
+		uiInfo.serverStatus.numPlayersOnServers = 0;
+		uiInfo.serverStatus.nextDisplayRefresh = uiInfo.uiDC.realTime + 500;
+		return;
+	}
+
+//	visible = qfalse;
+	for (i = 0; i < count; i++) {
+		// if we already got info for this server
+		if (!trap_LAN_ServerIsVisible(ui_netSource.integer, i)) {
+			continue;
+		}
+//		visible = qtrue;
+		// get the ping for this server
+		ping = trap_LAN_GetServerPing(ui_netSource.integer, i);
+		if (ping > 0 || ui_netSource.integer == AS_FAVORITES) {
+
+			trap_LAN_GetServerInfo(ui_netSource.integer, i, info, MAX_STRING_CHARS);
+
+			clients = atoi(Info_ValueForKey(info, "clients"));
+			uiInfo.serverStatus.numPlayersOnServers += clients;
+
+			if (ui_browserShowEmpty.integer == 0) {
+				if (clients == 0) {
+					trap_LAN_MarkServerVisible(ui_netSource.integer, i, qfalse);
+					continue;
+				}
+			}
+
+			if (ui_browserShowFull.integer == 0) {
+				maxClients = atoi(Info_ValueForKey(info, "sv_maxclients"));
+				if (clients == maxClients) {
+					trap_LAN_MarkServerVisible(ui_netSource.integer, i, qfalse);
+					continue;
+				}
+			}
+
+			if (uiInfo.joinGameTypes[ui_joinGameType.integer].gtEnum != -1) {
+				game = atoi(Info_ValueForKey(info, "gametype"));
+				if (game != uiInfo.joinGameTypes[ui_joinGameType.integer].gtEnum) {
+					trap_LAN_MarkServerVisible(ui_netSource.integer, i, qfalse);
+					continue;
+				}
+			}
+				
+			if (ui_serverFilterType.integer > 0) {
+				if (Q_stricmp(Info_ValueForKey(info, "game"), serverFilters[ui_serverFilterType.integer].basedir) != 0) {
+					trap_LAN_MarkServerVisible(ui_netSource.integer, i, qfalse);
+					continue;
+				}
+			}
+			// make sure we never add a favorite server twice
+			if (ui_netSource.integer == AS_FAVORITES) {
+				UI_RemoveServerFromDisplayList(i);
+			}
+			// insert the server into the list
+			UI_BinaryServerInsertion(i);
+			// done with this server
+			if (ping > 0) {
+				trap_LAN_MarkServerVisible(ui_netSource.integer, i, qfalse);
+				numinvisible++;
+			}
+		}
+		else
+		{
+			trap_LAN_MarkServerVisible(ui_netSource.integer, i, qfalse);
+//			visible = qfalse;
+		}
+	}
+
+	uiInfo.serverStatus.refreshtime = uiInfo.uiDC.realTime;
+
+	// if there were no servers visible for ping updates
+//	if (!visible) {
+//		UI_StopServerRefresh();
+//		uiInfo.serverStatus.nextDisplayRefresh = 0;
+//	}
+}
+
+typedef struct
+{
+	char *name, *altName;
+} serverStatusCvar_t;
+
+serverStatusCvar_t serverStatusCvars[] = {
+	{"sv_hostname", "Name"},
+	{"Address", ""},
+	{"gamename", "Game name"},
+	{"g_gametype", "Game type"},
+	{"mapname", "Map"},
+	{"version", ""},
+	{"protocol", ""},
+	{"timelimit", ""},
+	{"fraglimit", ""},
+	{NULL, NULL}
+};
+
+/*
+==================
+UI_SortServerStatusInfo
+==================
+*/
+static void UI_SortServerStatusInfo( serverStatusInfo_t *info ) {
+	int i, j, index;
+	char *tmp1, *tmp2;
+
+	// FIXME: if "gamename" == "base" or "missionpack" then
+	// replace the gametype number by FFA, CTF etc.
+	//
+	index = 0;
+	for (i = 0; serverStatusCvars[i].name; i++) {
+		for (j = 0; j < info->numLines; j++) {
+			if ( !info->lines[j][1] || info->lines[j][1][0] ) {
+				continue;
+			}
+			if ( !Q_stricmp(serverStatusCvars[i].name, info->lines[j][0]) ) {
+				// swap lines
+				tmp1 = info->lines[index][0];
+				tmp2 = info->lines[index][3];
+				info->lines[index][0] = info->lines[j][0];
+				info->lines[index][3] = info->lines[j][3];
+				info->lines[j][0] = tmp1;
+				info->lines[j][3] = tmp2;
+				//
+				if ( strlen(serverStatusCvars[i].altName) ) {
+					info->lines[index][0] = serverStatusCvars[i].altName;
+				}
+				index++;
+			}
+		}
+	}
+}
+
+
+/*
+==================
+UI_CheckPassword
+==================
+*/
+static qboolean UI_CheckPassword( void )
+{
+	static char info[MAX_STRING_CHARS];
+	
+	int index = uiInfo.serverStatus.currentServer;
+	if( (index < 0) || (index >= uiInfo.serverStatus.numDisplayServers) )
+	{	// warning?
+		return qfalse;
+	}
+	
+	trap_LAN_GetServerInfo(ui_netSource.integer, uiInfo.serverStatus.displayServers[index], info, MAX_STRING_CHARS);
+
+	if ( atoi(Info_ValueForKey(info, "needpass")) )
+	{
+
+		Menus_OpenByName("password_request");
+		return qfalse;
+		
+	}
+
+	// This isn't going to make it (too late in dev), like James said I should check to see when we receive
+	// a packet *if* we do indeed get a 0 ping just make it 1 so then a 0 ping is guaranteed to be bad
+	/*
+	// also check ping!
+    ping = atoi(Info_ValueForKey(info, "ping"));
+	// NOTE : PING -- it's very questionable as to whether a ping of < 0 or <= 0 indicates a bad server
+	// what I do know, is that getting "ping" from the ServerInfo on a bad server returns 0.
+	// So I'm left with no choice but to not allow you to enter a server with a ping of 0
+	if( ping <= 0 )
+	{
+		Menus_OpenByName("bad_server");
+		return qfalse;
+	}
+	*/
+
+
+	return qtrue;
+	
+
+}
+
+/*
+==================
+UI_JoinServer
+==================
+*/
+static void UI_JoinServer( void )
+{
+	char buff[1024];
+
+	trap_Cvar_Set("cg_thirdPerson", "0");
+	trap_Cvar_Set("cg_cameraOrbit", "0");
+	trap_Cvar_Set("ui_singlePlayerActive", "0");
+#ifdef _XBOX
+	if (logged_on)
+	{ // Live server
+		XBL_MM_JoinServer( uiInfo.serverStatus.displayServers[uiInfo.serverStatus.currentServer] );
+	}
+	else
+	{ // System link
+		SysLink_JoinServer( uiInfo.serverStatus.displayServers[uiInfo.serverStatus.currentServer] );
+	}
+#else
+	if (uiInfo.serverStatus.currentServer >= 0 && uiInfo.serverStatus.currentServer < uiInfo.serverStatus.numDisplayServers)
+	{
+		trap_LAN_GetServerAddressString(ui_netSource.integer, uiInfo.serverStatus.displayServers[uiInfo.serverStatus.currentServer], buff, 1024);
+		trap_Cmd_ExecuteText( EXEC_APPEND, va( "connect %s\n", buff ) );
+	}
+#endif
+	
+}
+
+
+
+/*
+==================
+UI_CheckServerName
+==================
+*/
+static void UI_CheckServerName( void )
+{
+	qboolean	changed = qfalse;
+	
+	char hostname[MAX_INFO_STRING];
+	char *c = hostname;
+			
+	trap_Cvar_VariableStringBuffer( "sv_hostname", hostname, MAX_INFO_STRING );
+	
+	while( *c )
+	{
+		if ( (*c == '\\') || (*c == ';') || (*c == '"'))
+		{
+			*c = '.';
+			changed = qtrue;
+		}
+		c++;
+	}
+	if( changed )
+	{
+		trap_Cvar_Set("sv_hostname", hostname );
+	}
+	
+}
+
+
+/*
+==================
+UI_GetServerStatusInfo
+==================
+*/
+static int UI_GetServerStatusInfo( const char *serverAddress, serverStatusInfo_t *info ) {
+	char *p, *score, *ping, *name;
+	int i, len;
+
+	if (!info) {
+		trap_LAN_ServerStatus( serverAddress, NULL, 0);
+		return qfalse;
+	}
+	memset(info, 0, sizeof(*info));
+	if ( trap_LAN_ServerStatus( serverAddress, info->text, sizeof(info->text)) ) {
+		Q_strncpyz(info->address, serverAddress, sizeof(info->address));
+		p = info->text;
+		info->numLines = 0;
+		info->lines[info->numLines][0] = "Address";
+		info->lines[info->numLines][1] = "";
+		info->lines[info->numLines][2] = "";
+		info->lines[info->numLines][3] = info->address;
+		info->numLines++;
+		// get the cvars
+		while (p && *p) {
+			p = strchr(p, '\\');
+			if (!p) break;
+			*p++ = '\0';
+			if (*p == '\\')
+				break;
+			info->lines[info->numLines][0] = p;
+			info->lines[info->numLines][1] = "";
+			info->lines[info->numLines][2] = "";
+			p = strchr(p, '\\');
+			if (!p) break;
+			*p++ = '\0';
+			info->lines[info->numLines][3] = p;
+
+			info->numLines++;
+			if (info->numLines >= MAX_SERVERSTATUS_LINES)
+				break;
+		}
+		// get the player list
+		if (info->numLines < MAX_SERVERSTATUS_LINES-3) {
+			// empty line
+			info->lines[info->numLines][0] = "";
+			info->lines[info->numLines][1] = "";
+			info->lines[info->numLines][2] = "";
+			info->lines[info->numLines][3] = "";
+			info->numLines++;
+			// header
+			info->lines[info->numLines][0] = "num";
+			info->lines[info->numLines][1] = "score";
+			info->lines[info->numLines][2] = "ping";
+			info->lines[info->numLines][3] = "name";
+			info->numLines++;
+			// parse players
+			i = 0;
+			len = 0;
+			while (p && *p) {
+				if (*p == '\\')
+					*p++ = '\0';
+				if (!p)
+					break;
+				score = p;
+				p = strchr(p, ' ');
+				if (!p)
+					break;
+				*p++ = '\0';
+				ping = p;
+				p = strchr(p, ' ');
+				if (!p)
+					break;
+				*p++ = '\0';
+				name = p;
+				Com_sprintf(&info->pings[len], sizeof(info->pings)-len, "%d", i);
+				info->lines[info->numLines][0] = &info->pings[len];
+				len += strlen(&info->pings[len]) + 1;
+				info->lines[info->numLines][1] = score;
+				info->lines[info->numLines][2] = ping;
+				info->lines[info->numLines][3] = name;
+				info->numLines++;
+				if (info->numLines >= MAX_SERVERSTATUS_LINES)
+					break;
+				p = strchr(p, '\\');
+				if (!p)
+					break;
+				*p++ = '\0';
+				//
+				i++;
+			}
+		}
+		UI_SortServerStatusInfo( info );
+		return qtrue;
+	}
+	return qfalse;
+}
+
+/*
+==================
+stristr
+==================
+*/
+static char *stristr(char *str, char *charset) {
+	int i;
+
+	while(*str) {
+		for (i = 0; charset[i] && str[i]; i++) {
+			if (toupper(charset[i]) != toupper(str[i])) break;
+		}
+		if (!charset[i]) return str;
+		str++;
+	}
+	return NULL;
+}
+
+/*
+==================
+UI_BuildFindPlayerList
+==================
+*/
+static void UI_BuildFindPlayerList(qboolean force) {
+	static int numFound, numTimeOuts;
+	int i, j, resend;
+	serverStatusInfo_t info;
+	char name[MAX_NAME_LENGTH+2];
+	char infoString[MAX_STRING_CHARS];
+
+	if (!force) {
+		if (!uiInfo.nextFindPlayerRefresh || uiInfo.nextFindPlayerRefresh > uiInfo.uiDC.realTime) {
+			return;
+		}
+	}
+	else {
+		memset(&uiInfo.pendingServerStatus, 0, sizeof(uiInfo.pendingServerStatus));
+		uiInfo.numFoundPlayerServers = 0;
+		uiInfo.currentFoundPlayerServer = 0;
+		trap_Cvar_VariableStringBuffer( "ui_findPlayer", uiInfo.findPlayerName, sizeof(uiInfo.findPlayerName));
+		Q_CleanStr(uiInfo.findPlayerName);
+		// should have a string of some length
+		if (!strlen(uiInfo.findPlayerName)) {
+			uiInfo.nextFindPlayerRefresh = 0;
+			return;
+		}
+		// set resend time
+		resend = ui_serverStatusTimeOut.integer / 2 - 10;
+		if (resend < 50) {
+			resend = 50;
+		}
+		trap_Cvar_Set("cl_serverStatusResendTime", va("%d", resend));
+		// reset all server status requests
+		trap_LAN_ServerStatus( NULL, NULL, 0);
+		//
+		uiInfo.numFoundPlayerServers = 1;
+
+		trap_SP_GetStringTextString("MENUS_SEARCHING", holdSPString, sizeof(holdSPString));
+				trap_Cvar_Set( "ui_playerServersFound", va(	holdSPString,uiInfo.pendingServerStatus.num, numFound));
+	//	Com_sprintf(uiInfo.foundPlayerServerNames[uiInfo.numFoundPlayerServers-1],
+	//					sizeof(uiInfo.foundPlayerServerNames[uiInfo.numFoundPlayerServers-1]),
+	//						"searching %d...", uiInfo.pendingServerStatus.num);
+		numFound = 0;
+		numTimeOuts++;
+	}
+	for (i = 0; i < MAX_SERVERSTATUSREQUESTS; i++) {
+		// if this pending server is valid
+		if (uiInfo.pendingServerStatus.server[i].valid) {
+			// try to get the server status for this server
+			if (UI_GetServerStatusInfo( uiInfo.pendingServerStatus.server[i].adrstr, &info ) ) {
+				//
+				numFound++;
+				// parse through the server status lines
+				for (j = 0; j < info.numLines; j++) {
+					// should have ping info
+					if ( !info.lines[j][2] || !info.lines[j][2][0] ) {
+						continue;
+					}
+					// clean string first
+					Q_strncpyz(name, info.lines[j][3], sizeof(name));
+					Q_CleanStr(name);
+					// if the player name is a substring
+					if (stristr(name, uiInfo.findPlayerName)) {
+						// add to found server list if we have space (always leave space for a line with the number found)
+						if (uiInfo.numFoundPlayerServers < MAX_FOUNDPLAYER_SERVERS-1) {
+							//
+							Q_strncpyz(uiInfo.foundPlayerServerAddresses[uiInfo.numFoundPlayerServers-1],
+										uiInfo.pendingServerStatus.server[i].adrstr,
+											sizeof(uiInfo.foundPlayerServerAddresses[0]));
+							Q_strncpyz(uiInfo.foundPlayerServerNames[uiInfo.numFoundPlayerServers-1],
+										uiInfo.pendingServerStatus.server[i].name,
+											sizeof(uiInfo.foundPlayerServerNames[0]));
+							uiInfo.numFoundPlayerServers++;
+						}
+						else {
+							// can't add any more so we're done
+							uiInfo.pendingServerStatus.num = uiInfo.serverStatus.numDisplayServers;
+						}
+					}
+				}
+
+				trap_SP_GetStringTextString("MENUS_SEARCHING", holdSPString, sizeof(holdSPString));
+				trap_Cvar_Set( "ui_playerServersFound", va(	holdSPString,uiInfo.pendingServerStatus.num, numFound));
+			//	Com_sprintf(uiInfo.foundPlayerServerNames[uiInfo.numFoundPlayerServers-1],
+			//					sizeof(uiInfo.foundPlayerServerNames[uiInfo.numFoundPlayerServers-1]),
+			//						"searching %d/%d...", uiInfo.pendingServerStatus.num, numFound);
+				// retrieved the server status so reuse this spot
+				uiInfo.pendingServerStatus.server[i].valid = qfalse;
+			}
+		}
+		// if empty pending slot or timed out
+		if (!uiInfo.pendingServerStatus.server[i].valid ||
+			uiInfo.pendingServerStatus.server[i].startTime < uiInfo.uiDC.realTime - ui_serverStatusTimeOut.integer) {
+			if (uiInfo.pendingServerStatus.server[i].valid) {
+				numTimeOuts++;
+			}
+			// reset server status request for this address
+			UI_GetServerStatusInfo( uiInfo.pendingServerStatus.server[i].adrstr, NULL );
+			// reuse pending slot
+			uiInfo.pendingServerStatus.server[i].valid = qfalse;
+			// if we didn't try to get the status of all servers in the main browser yet
+			if (uiInfo.pendingServerStatus.num < uiInfo.serverStatus.numDisplayServers) {
+				uiInfo.pendingServerStatus.server[i].startTime = uiInfo.uiDC.realTime;
+				trap_LAN_GetServerAddressString(ui_netSource.integer, uiInfo.serverStatus.displayServers[uiInfo.pendingServerStatus.num],
+							uiInfo.pendingServerStatus.server[i].adrstr, sizeof(uiInfo.pendingServerStatus.server[i].adrstr));
+				trap_LAN_GetServerInfo(ui_netSource.integer, uiInfo.serverStatus.displayServers[uiInfo.pendingServerStatus.num], infoString, sizeof(infoString));
+				Q_strncpyz(uiInfo.pendingServerStatus.server[i].name, Info_ValueForKey(infoString, "hostname"), sizeof(uiInfo.pendingServerStatus.server[0].name));
+				uiInfo.pendingServerStatus.server[i].valid = qtrue;
+				uiInfo.pendingServerStatus.num++;
+
+				trap_SP_GetStringTextString("MENUS_SEARCHING", holdSPString, sizeof(holdSPString));
+				trap_Cvar_Set( "ui_playerServersFound", va(	holdSPString,uiInfo.pendingServerStatus.num, numFound));
+														
+			//	Com_sprintf(uiInfo.foundPlayerServerNames[uiInfo.numFoundPlayerServers-1],
+			//					sizeof(uiInfo.foundPlayerServerNames[uiInfo.numFoundPlayerServers-1]),
+			//						"searching %d/%d...", uiInfo.pendingServerStatus.num, numFound);
+			}
+		}
+	}
+	for (i = 0; i < MAX_SERVERSTATUSREQUESTS; i++) {
+		if (uiInfo.pendingServerStatus.server[i].valid) {
+			break;
+		}
+	}
+	// if still trying to retrieve server status info
+	if (i < MAX_SERVERSTATUSREQUESTS) {
+		uiInfo.nextFindPlayerRefresh = uiInfo.uiDC.realTime + 25;
+	}
+	else {
+		// add a line that shows the number of servers found
+		if (!uiInfo.numFoundPlayerServers) 
+		{
+			Com_sprintf(uiInfo.foundPlayerServerNames[uiInfo.numFoundPlayerServers-1], sizeof(uiInfo.foundPlayerServerAddresses[0]), "no servers found");
+		}
+		else 
+		{
+			trap_SP_GetStringTextString("MENUS_SERVERS_FOUNDWITH", holdSPString, sizeof(holdSPString));
+			trap_Cvar_Set( "ui_playerServersFound", va(	holdSPString,
+														uiInfo.numFoundPlayerServers-1,
+														uiInfo.numFoundPlayerServers == 2 ? "":"s",
+														uiInfo.findPlayerName) );
+		}
+		uiInfo.nextFindPlayerRefresh = 0;
+		// show the server status info for the selected server
+		UI_FeederSelection(FEEDER_FINDPLAYER, uiInfo.currentFoundPlayerServer, NULL);
+	}
+}
+
+/*
+==================
+UI_BuildServerStatus
+==================
+*/
+static void UI_BuildServerStatus(qboolean force) {
+
+	if (uiInfo.nextFindPlayerRefresh) {
+		return;
+	}
+	if (!force) {
+		if (!uiInfo.nextServerStatusRefresh || uiInfo.nextServerStatusRefresh > uiInfo.uiDC.realTime) {
+			return;
+		}
+	}
+	else {
+		Menu_SetFeederSelection(NULL, FEEDER_SERVERSTATUS, 0, NULL);
+		uiInfo.serverStatusInfo.numLines = 0;
+		// reset all server status requests
+		trap_LAN_ServerStatus( NULL, NULL, 0);
+	}
+	if (uiInfo.serverStatus.currentServer < 0 || uiInfo.serverStatus.currentServer > uiInfo.serverStatus.numDisplayServers || uiInfo.serverStatus.numDisplayServers == 0) {
+		return;
+	}
+	if (UI_GetServerStatusInfo( uiInfo.serverStatusAddress, &uiInfo.serverStatusInfo ) ) {
+		uiInfo.nextServerStatusRefresh = 0;
+		UI_GetServerStatusInfo( uiInfo.serverStatusAddress, NULL );
+	}
+	else {
+		uiInfo.nextServerStatusRefresh = uiInfo.uiDC.realTime + 500;
+	}
+}
+
+int UI_SiegeClassNum(siegeClass_t *scl)
+{
+	int i = 0;
+
+	while (i < bgNumSiegeClasses)
+	{
+		if (&bgSiegeClasses[i] == scl)
+		{
+			return i;
+		}
+		i++;
+	}
+
+	return 0;
+}
+
+void UI_SetSiegeTeams(void)
+{
+	char			info[MAX_INFO_VALUE];
+	char			*mapname = NULL;
+	char			levelname[MAX_QPATH];
+	char			btime[1024];
+	char			teams[2048];
+	char			teamInfo[MAX_SIEGE_INFO_SIZE];
+	char			team1[1024];
+	char			team2[1024];
+	int				len = 0;
+	int				gametype;
+	fileHandle_t	f;
+
+	//Get the map name from the server info
+	if (trap_GetConfigString( CS_SERVERINFO, info, sizeof(info) ))
+	{
+		mapname = Info_ValueForKey( info, "mapname" );
+	}
+
+	if (!mapname || !mapname[0])
+	{
+		return;
+	}
+
+	gametype = atoi(Info_ValueForKey(info, "g_gametype"));
+
+	//If the server we are connected to is not siege we cannot choose a class anyway
+	if (gametype != GT_SIEGE)
+	{
+		return;
+	}
+
+	Com_sprintf(levelname, sizeof(levelname), "maps/%s.siege", mapname);
+
+	if (!levelname || !levelname[0])
+	{
+		return;
+	}
+
+	len = trap_FS_FOpenFile(levelname, &f, FS_READ);
+
+	if (!f || len >= MAX_SIEGE_INFO_SIZE)
+	{
+		return;
+	}
+
+	trap_FS_Read(siege_info, len, f);
+	siege_info[len] = 0;	//ensure null terminated
+
+	trap_FS_FCloseFile(f);
+
+	//Found the .siege file
+
+	if (BG_SiegeGetValueGroup(siege_info, "Teams", teams))
+	{
+		char buf[1024];
+
+		trap_Cvar_VariableStringBuffer("cg_siegeTeam1", buf, 1024);
+		if (buf[0] && Q_stricmp(buf, "none"))
+		{
+			strcpy(team1, buf);
+		}
+		else
+		{
+			BG_SiegeGetPairedValue(teams, "team1", team1);
+		}
+
+		trap_Cvar_VariableStringBuffer("cg_siegeTeam2", buf, 1024);
+		if (buf[0] && Q_stricmp(buf, "none"))
+		{
+			strcpy(team2, buf);
+		}
+		else
+		{
+			BG_SiegeGetPairedValue(teams, "team2", team2);
+		}
+	}
+	else
+	{
+		return;
+	}
+
+	//Set the team themes so we know what classes to make available for selection
+	if (BG_SiegeGetValueGroup(siege_info, team1, teamInfo))
+	{
+		if (BG_SiegeGetPairedValue(teamInfo, "UseTeam", btime))
+		{
+			BG_SiegeSetTeamTheme(SIEGETEAM_TEAM1, btime);
+		}
+	}
+	if (BG_SiegeGetValueGroup(siege_info, team2, teamInfo))
+	{
+		if (BG_SiegeGetPairedValue(teamInfo, "UseTeam", btime))
+		{
+			BG_SiegeSetTeamTheme(SIEGETEAM_TEAM2, btime);
+		}
+	}
+
+	siegeTeam1 = BG_SiegeFindThemeForTeam(SIEGETEAM_TEAM1);
+	siegeTeam2 = BG_SiegeFindThemeForTeam(SIEGETEAM_TEAM2);
+
+	//set the default description for the default selection
+	if (!siegeTeam1 || !siegeTeam1->classes[0])
+	{
+		Com_Error(ERR_DROP, "Error loading teams in UI");
+	}
+
+	Menu_SetFeederSelection(NULL, FEEDER_SIEGE_TEAM1, 0, NULL);
+	Menu_SetFeederSelection(NULL, FEEDER_SIEGE_TEAM2, -1, NULL);
+}
+
+/*
+==================
+UI_FeederCount
+==================
+*/
+static int UI_FeederCount(float feederID) 
+{
+	int team,baseClass,count=0,i; 
+	static char info[MAX_STRING_CHARS];
+	
+	switch ( (int)feederID )
+	{
+
+		case FEEDER_SABER_SINGLE_INFO:
+
+			for (i=0;i<MAX_SABER_HILTS;i++)
+			{
+				if (saberSingleHiltInfo[i])
+				{
+					count++;
+				}
+				else
+				{//done
+					break;
+				}
+			}
+			return count;
+
+		case FEEDER_SABER_STAFF_INFO:
+
+			for (i=0;i<MAX_SABER_HILTS;i++)
+			{
+				if (saberStaffHiltInfo[i])
+				{
+					count++;
+				}
+				else
+				{//done
+					break;
+				}
+			}
+			return count;
+
+		case FEEDER_Q3HEADS:
+			return UI_HeadCountByColor();
+
+		case FEEDER_SIEGE_TEAM1:
+			if (!siegeTeam1)
+			{
+				UI_SetSiegeTeams();
+				if (!siegeTeam1)
+				{
+					return 0;
+				}
+			}
+			return siegeTeam1->numClasses;
+		case FEEDER_SIEGE_TEAM2:
+			if (!siegeTeam2)
+			{
+				UI_SetSiegeTeams();
+				if (!siegeTeam2)
+				{
+					return 0;
+				}
+			}
+			return siegeTeam2->numClasses;
+
+		case FEEDER_FORCECFG:
+			if (uiForceSide == FORCE_LIGHTSIDE)
+			{
+				return uiInfo.forceConfigCount-uiInfo.forceConfigLightIndexBegin;
+			}
+			else
+			{
+				return uiInfo.forceConfigLightIndexBegin+1;
+			}
+			//return uiInfo.forceConfigCount;
+
+		case FEEDER_CINEMATICS:
+			return uiInfo.movieCount;
+
+		case FEEDER_MAPS:
+		case FEEDER_ALLMAPS:
+			return UI_MapCountByGameType(feederID == FEEDER_MAPS ? qtrue : qfalse);
+	
+		case FEEDER_SERVERS:
+			return uiInfo.serverStatus.numDisplayServers;
+	
+		case FEEDER_SERVERSTATUS:
+			return uiInfo.serverStatusInfo.numLines;
+	
+		case FEEDER_FINDPLAYER:
+			return uiInfo.numFoundPlayerServers;
+
+		case FEEDER_PLAYER_LIST:
+			if (uiInfo.uiDC.realTime > uiInfo.playerRefresh) 
+			{
+				uiInfo.playerRefresh = uiInfo.uiDC.realTime + 3000;
+				UI_BuildPlayerList();
+			}
+			return uiInfo.playerCount;
+
+		case FEEDER_TEAM_LIST:
+			if (uiInfo.uiDC.realTime > uiInfo.playerRefresh) 
+			{
+				uiInfo.playerRefresh = uiInfo.uiDC.realTime + 3000;
+				UI_BuildPlayerList();
+			}
+			return uiInfo.myTeamCount;
+
+		case FEEDER_MODS:
+			return uiInfo.modCount;
+	
+		case FEEDER_DEMOS:
+			return uiInfo.demoCount;
+
+		case FEEDER_MOVES :
+
+			for (i=0;i<MAX_MOVES;i++)
+			{
+				if (datapadMoveData[uiInfo.movesTitleIndex][i].title)
+				{
+					count++;
+				}
+			}
+
+			return count;
+
+		case FEEDER_MOVES_TITLES :
+			return (MD_MOVE_TITLE_MAX);
+
+		case FEEDER_PLAYER_SPECIES:
+			return uiInfo.playerSpeciesCount;
+
+		case FEEDER_PLAYER_SKIN_HEAD:
+			return uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].SkinHeadCount;
+
+		case FEEDER_PLAYER_SKIN_TORSO:
+			return uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].SkinTorsoCount;
+
+		case FEEDER_PLAYER_SKIN_LEGS:
+			return uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].SkinLegCount;
+
+		case FEEDER_COLORCHOICES:
+			return uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].ColorCount;
+
+		case FEEDER_SIEGE_BASE_CLASS:		
+			team = (int)trap_Cvar_VariableValue("ui_team");
+			baseClass = (int)trap_Cvar_VariableValue("ui_siege_class");
+
+			if ((team == SIEGETEAM_TEAM1) || 
+				(team == SIEGETEAM_TEAM2)) 
+			{
+				// Is it a valid base class?
+				if ((baseClass >= SPC_INFANTRY) && (baseClass < SPC_MAX))
+				{
+					return (BG_SiegeCountBaseClass( team, baseClass ));
+				}
+			}
+			return 0;
+
+		// Get the count of weapons
+		case FEEDER_SIEGE_CLASS_WEAPONS:	
+			//count them up
+			for (i=0;i< WP_NUM_WEAPONS;i++)
+			{
+				trap_Cvar_VariableStringBuffer( va("ui_class_weapon%i", i), info, sizeof(info) );
+				if (stricmp(info,"gfx/2d/select")!=0)
+				{
+					count++;
+				}
+			}
+
+			return count;
+
+		// Get the count of inventory
+		case FEEDER_SIEGE_CLASS_INVENTORY:	
+			//count them up
+			for (i=0;i< HI_NUM_HOLDABLE;i++)
+			{
+				trap_Cvar_VariableStringBuffer( va("ui_class_item%i", i), info, sizeof(info) );
+				// A hack so health and ammo dispenser icons don't show up.
+				if ((stricmp(info,"gfx/2d/select")!=0) && (stricmp(info,"gfx/hud/i_icon_healthdisp")!=0) &&
+					(stricmp(info,"gfx/hud/i_icon_ammodisp")!=0))
+				{
+					count++;
+				}
+			}
+			return count;
+
+		// Get the count of force powers
+		case FEEDER_SIEGE_CLASS_FORCE:	
+			//count them up
+			for (i=0;i< NUM_FORCE_POWERS;i++)
+			{
+				trap_Cvar_VariableStringBuffer( va("ui_class_power%i", i), info, sizeof(info) );
+				if (stricmp(info,"gfx/2d/select")!=0)
+				{
+					count++;
+				}
+			}
+			return count;
+
+#ifdef _XBOX
+		// Get the count of xbl accounts
+		case FEEDER_XBL_ACCOUNTS:
+			// VVFIXME - Again, SOF2 had all kinds of silliness here. Do we need it?
+			return XBL_GetNumAccounts( false );
+
+		// Number of active players, plus number in history list, plus one for divider
+		case FEEDER_XBL_PLAYERS:
+			return XBL_PL_GetNumPlayers() + 1;
+
+		// Number of friends
+		case FEEDER_XBL_FRIENDS:
+			return XBL_F_GetNumFriends();
+
+		// Number of results from an optimatch query
+		case FEEDER_XBL_SERVERS:
+			return XBL_MM_GetNumServers();
+#endif
+	}
+
+	return 0;
+}
+
+static const char *UI_SelectedMap(int index, int *actual) {
+	int i, c;
+	c = 0;
+	*actual = 0;
+
+	for (i = 0; i < uiInfo.mapCount; i++) {
+		if (uiInfo.mapList[i].active) {
+			if (c == index) {
+				*actual = i;
+				return uiInfo.mapList[i].mapName;
+			} else {
+				c++;
+			}
+		}
+	}
+	return "";
+}
+
+/*
+==================
+UI_HeadCountByColor
+==================
+*/
+static const char *UI_SelectedTeamHead(int index, int *actual) {
+	char *teamname;
+	int i,c=0;
+
+	switch(uiSkinColor)
+	{
+		case TEAM_BLUE:
+			teamname = "/blue";
+			break;
+		case TEAM_RED:
+			teamname = "/red";
+			break;
+		default:
+			teamname = "/default";
+			break;
+	}
+
+	// Count each head with this color
+
+	for (i=0; i<uiInfo.q3HeadCount; i++)
+	{
+		if (uiInfo.q3HeadNames[i] && strstr(uiInfo.q3HeadNames[i], teamname))
+		{
+			if (c==index)
+			{
+				*actual = i;
+				return uiInfo.q3HeadNames[i];
+			}
+			else
+			{
+				c++;
+			}
+		}
+	}
+	return "";
+}
+
+
+static int UI_GetIndexFromSelection(int actual) {
+	int i, c;
+	c = 0;
+	for (i = 0; i < uiInfo.mapCount; i++) {
+		if (uiInfo.mapList[i].active) {
+			if (i == actual) {
+				return c;
+			}
+				c++;
+		}
+	}
+  return 0;
+}
+
+static void UI_UpdatePendingPings() { 
+	trap_LAN_ResetPings(ui_netSource.integer);
+	uiInfo.serverStatus.refreshActive = qtrue;
+	uiInfo.serverStatus.refreshtime = uiInfo.uiDC.realTime + 1000;
+
+
+
+}
+
+static const char *UI_FeederItemText(float feederID, int index, int column, 
+									 qhandle_t *handle1, qhandle_t *handle2, qhandle_t *handle3) {
+	static char info[MAX_STRING_CHARS]; // don't change this size without changing the sizes inside the SaberProperName calls
+	static char hostname[1024];
+	static char clientBuff[32];
+	static char needPass[32];
+	static int lastColumn = -1;
+	static int lastTime = 0;
+	*handle1 = *handle2 = *handle3 = -1;
+
+	if (feederID == FEEDER_SABER_SINGLE_INFO)
+	{
+		//char *saberProperName=0;
+		UI_SaberProperNameForSaber( saberSingleHiltInfo[index], info );
+		return info;
+	}
+	else if	(feederID == FEEDER_SABER_STAFF_INFO)
+	{
+		//char *saberProperName=0;
+		UI_SaberProperNameForSaber( saberStaffHiltInfo[index], info );
+		return info;
+	}
+	else if (feederID == FEEDER_Q3HEADS) {
+		int actual;
+		return UI_SelectedTeamHead(index, &actual);
+	} 
+	else if (feederID == FEEDER_SIEGE_TEAM1)
+	{
+		return ""; //nothing I guess, the description part can cover this
+		/*
+		if (!siegeTeam1)
+		{
+			UI_SetSiegeTeams();
+			if (!siegeTeam1)
+			{
+				return "";
+			}
+		}
+
+		if (siegeTeam1->classes[index])
+		{
+			return siegeTeam1->classes[index]->name;
+		}
+		return "";
+		*/
+	}
+	else if (feederID == FEEDER_SIEGE_TEAM2)
+	{
+		return ""; //nothing I guess, the description part can cover this
+		/*
+		if (!siegeTeam1)
+		{
+			UI_SetSiegeTeams();
+			if (!siegeTeam1)
+			{
+				return "";
+			}
+		}
+
+		if (siegeTeam2->classes[index])
+		{
+			return siegeTeam2->classes[index]->name;
+		}
+		return "";
+		*/
+	}
+	else if (feederID == FEEDER_FORCECFG) {
+		if (index >= 0 && index < uiInfo.forceConfigCount) {
+			if (index == 0)
+			{ //always show "custom"
+				return uiInfo.forceConfigNames[index];
+			}
+			else
+			{
+				if (uiForceSide == FORCE_LIGHTSIDE)
+				{
+					index += uiInfo.forceConfigLightIndexBegin;
+					if (index < 0)
+					{
+						return NULL;
+					}
+					if (index >= uiInfo.forceConfigCount)
+					{
+						return NULL;
+					}
+					return uiInfo.forceConfigNames[index];
+				}
+				else if (uiForceSide == FORCE_DARKSIDE)
+				{
+					index += uiInfo.forceConfigDarkIndexBegin;
+					if (index < 0)
+					{
+						return NULL;
+					}
+					if (index > uiInfo.forceConfigLightIndexBegin)
+					{ //dark gets read in before light
+						return NULL;
+					}
+					if (index >= uiInfo.forceConfigCount)
+					{
+						return NULL;
+					}
+					return uiInfo.forceConfigNames[index];
+				}
+				else
+				{
+					return NULL;
+				}
+			}
+		}
+	} else if (feederID == FEEDER_MAPS || feederID == FEEDER_ALLMAPS) {
+		int actual;
+		return UI_SelectedMap(index, &actual);
+	} else if (feederID == FEEDER_SERVERS) {
+		if (index >= 0 && index < uiInfo.serverStatus.numDisplayServers) {
+			int ping, game;
+			if (lastColumn != column || lastTime > uiInfo.uiDC.realTime + 5000) {
+				trap_LAN_GetServerInfo(ui_netSource.integer, uiInfo.serverStatus.displayServers[index], info, MAX_STRING_CHARS);
+				lastColumn = column;
+				lastTime = uiInfo.uiDC.realTime;
+			}
+			ping = atoi(Info_ValueForKey(info, "ping"));
+			if (ping == -1) {
+				// if we ever see a ping that is out of date, do a server refresh
+				// UI_UpdatePendingPings();
+			}
+			switch (column) {
+				case SORT_HOST : 
+					if (ping <= 0) {
+						return Info_ValueForKey(info, "addr");
+					} else {
+						int gametype = 0;
+						//check for password
+						if ( atoi(Info_ValueForKey(info, "needpass")) )
+						{
+							*handle3 = uiInfo.uiDC.Assets.needPass;
+						}
+						//check for saberonly and restricted force powers
+						gametype = atoi(Info_ValueForKey(info, "gametype"));
+						if ( gametype != GT_JEDIMASTER )
+						{
+							qboolean saberOnly = qtrue;
+							qboolean restrictedForce = qfalse;
+							qboolean allForceDisabled = qfalse;
+							int wDisable, i = 0;
+
+							//check force
+							restrictedForce = atoi(Info_ValueForKey(info, "fdisable"));
+							if ( UI_AllForceDisabled( restrictedForce ) )
+							{//all force powers are disabled
+								allForceDisabled = qtrue;
+								*handle2 = uiInfo.uiDC.Assets.noForce;
+							}
+							else if ( restrictedForce )
+							{//at least one force power is disabled
+								*handle2 = uiInfo.uiDC.Assets.forceRestrict;
+							}
+							
+							//check weaps
+							wDisable = atoi(Info_ValueForKey(info, "wdisable"));
+
+							while ( i < WP_NUM_WEAPONS )
+							{
+								if ( !(wDisable & (1 << i)) && i != WP_SABER && i != WP_NONE )
+								{
+									saberOnly = qfalse;
+								}
+
+								i++;
+							}
+							if ( saberOnly )
+							{
+								*handle1 = uiInfo.uiDC.Assets.saberOnly;
+							}
+							else if ( atoi(Info_ValueForKey(info, "truejedi")) != 0 )
+							{
+								if ( gametype != GT_HOLOCRON 
+									&& gametype != GT_JEDIMASTER 
+									&& !saberOnly 
+									&& !allForceDisabled )
+								{//truejedi is on and allowed in this mode
+									*handle1 = uiInfo.uiDC.Assets.trueJedi;
+								}
+							}
+						}
+						if ( ui_netSource.integer == AS_LOCAL ) {
+							Com_sprintf( hostname, sizeof(hostname), "%s [%s]",
+											Info_ValueForKey(info, "hostname"),
+											netnames[atoi(Info_ValueForKey(info, "nettype"))] );
+							return hostname;
+						}
+						else {
+							if (atoi(Info_ValueForKey(info, "sv_allowAnonymous")) != 0) {				// anonymous server
+								Com_sprintf( hostname, sizeof(hostname), "(A) %s",
+												Info_ValueForKey(info, "hostname"));
+							} else {
+								Com_sprintf( hostname, sizeof(hostname), "%s",
+												Info_ValueForKey(info, "hostname"));
+							}
+							return hostname;
+						}
+					}
+				case SORT_MAP : 
+					return Info_ValueForKey(info, "mapname");
+				case SORT_CLIENTS : 
+					Com_sprintf( clientBuff, sizeof(clientBuff), "%s (%s)", Info_ValueForKey(info, "clients"), Info_ValueForKey(info, "sv_maxclients"));
+					return clientBuff;
+				case SORT_GAME : 
+					game = atoi(Info_ValueForKey(info, "gametype"));
+					if (game >= 0 && game < numTeamArenaGameTypes) {
+						strcpy(needPass,teamArenaGameTypes[game]);
+					} else {
+						if (ping <= 0)
+						{
+							strcpy(needPass,"Inactive");
+						}
+						strcpy(needPass,"Unknown");
+					}
+
+					return needPass;
+				case SORT_PING : 
+					if (ping <= 0) {
+						return "...";
+					} else {
+						return Info_ValueForKey(info, "ping");
+					}
+			}
+		}
+	} else if (feederID == FEEDER_SERVERSTATUS) {
+		if ( index >= 0 && index < uiInfo.serverStatusInfo.numLines ) {
+			if ( column >= 0 && column < 4 ) {
+				return uiInfo.serverStatusInfo.lines[index][column];
+			}
+		}
+	} else if (feederID == FEEDER_FINDPLAYER) {
+		if ( index >= 0 && index < uiInfo.numFoundPlayerServers ) {
+			//return uiInfo.foundPlayerServerAddresses[index];
+			return uiInfo.foundPlayerServerNames[index];
+		}
+	} else if (feederID == FEEDER_PLAYER_LIST) {
+		if (index >= 0 && index < uiInfo.playerCount) {
+			return uiInfo.playerNames[index];
+		}
+	} else if (feederID == FEEDER_TEAM_LIST) {
+		if (index >= 0 && index < uiInfo.myTeamCount) {
+			return uiInfo.teamNames[index];
+		}
+	} else if (feederID == FEEDER_MODS) {
+		if (index >= 0 && index < uiInfo.modCount) {
+			if (uiInfo.modList[index].modDescr && *uiInfo.modList[index].modDescr) {
+				return uiInfo.modList[index].modDescr;
+			} else {
+				return uiInfo.modList[index].modName;
+			}
+		}
+	} else if (feederID == FEEDER_CINEMATICS) {
+		if (index >= 0 && index < uiInfo.movieCount) {
+			return uiInfo.movieList[index];
+		}
+	} else if (feederID == FEEDER_DEMOS) {
+		if (index >= 0 && index < uiInfo.demoCount) {
+			return uiInfo.demoList[index];
+		}
+	} 
+	else if (feederID == FEEDER_MOVES) 
+	{
+		return datapadMoveData[uiInfo.movesTitleIndex][index].title;
+	}
+	else if (feederID == FEEDER_MOVES_TITLES) 
+	{
+		return datapadMoveTitleData[index];
+	}
+	else if (feederID == FEEDER_PLAYER_SPECIES) 
+	{
+		return uiInfo.playerSpecies[index].Name;
+	} 
+	else if (feederID == FEEDER_LANGUAGES) 
+	{
+		return 0;
+	} 
+	else if (feederID == FEEDER_COLORCHOICES)
+	{
+		if (index >= 0 && index < uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].ColorCount) 
+		{
+			*handle1 = trap_R_RegisterShaderNoMip( uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].ColorShader[index]);
+			return uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].ColorShader[index];
+		}
+	}
+	else if (feederID == FEEDER_PLAYER_SKIN_HEAD)
+	{
+		if (index >= 0 && index < uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].SkinHeadCount) 
+		{
+			*handle1 = trap_R_RegisterShaderNoMip(va("models/players/%s/icon_%s", uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].Name, uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].SkinHeadNames[index]));
+			return uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].SkinHeadNames[index];
+		}
+	}
+	else if (feederID == FEEDER_PLAYER_SKIN_TORSO)
+	{
+		if (index >= 0 && index < uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].SkinTorsoCount) 
+		{
+			*handle1 = trap_R_RegisterShaderNoMip(va("models/players/%s/icon_%s", uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].Name, uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].SkinTorsoNames[index]));
+			return uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].SkinTorsoNames[index];
+		}
+	}
+	else if (feederID == FEEDER_PLAYER_SKIN_LEGS)
+	{
+		if (index >= 0 && index < uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].SkinLegCount) 
+		{
+			*handle1 = trap_R_RegisterShaderNoMip(va("models/players/%s/icon_%s", uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].Name, uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].SkinLegNames[index]));
+			return uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].SkinLegNames[index];
+		}
+	}
+	else if (feederID == FEEDER_SIEGE_BASE_CLASS)
+	{
+		return ""; 
+	}
+	else if (feederID == FEEDER_SIEGE_CLASS_WEAPONS)
+	{
+		return ""; 
+	}
+#ifdef _XBOX
+	else if (feederID == FEEDER_XBL_ACCOUNTS)
+	{
+		// VVFIXME - SOF2 keeps track of old number of accounts, to force a
+		// refresh when someone yanks an MU. Probably necessary
+		int numAccounts = XBL_GetNumAccounts( false );
+		if (index >= 0 && index < numAccounts)
+		{
+			XONLINE_USER *pUser = XBL_GetUserInfo( index );
+			if (pUser)
+			{
+				static char displayName[XONLINE_GAMERTAG_SIZE];
+				strcpy( displayName, pUser->szGamertag );
+				return displayName;
+			}
+		}
+	}
+	else if (feederID == FEEDER_XBL_PLAYERS)
+	{
+		int numEntries = XBL_PL_GetNumPlayers() + 1;
+
+		if (index >= 0 && index < numEntries)
+		{
+			if (column == 0)
+				return XBL_PL_GetPlayerName( index );
+			else if (column == 1)
+				return XBL_PL_GetStatusIcon( index );
+			else if (column == 2)
+				return XBL_PL_GetVoiceIcon( index );
+			else
+				return "";
+		}
+	}
+	else if (feederID == FEEDER_XBL_FRIENDS)
+	{
+		if (index >= 0 && index < XBL_F_GetNumFriends())
+		{
+			if (column == 0)
+				return XBL_F_GetFriendName( index );
+			else if (column == 1)
+				return XBL_F_GetStatusIcon( index );
+			else if (column == 2)
+				return XBL_F_GetVoiceIcon( index );
+			else
+				return "";
+		}
+	}
+	else if (feederID == FEEDER_XBL_SERVERS)
+	{
+		// We handle the optimatch results listbox separately from the rest
+		// of the UI server browser code. It's just nasty otherwise.
+		if (index >= 0 && index < XBL_MM_GetNumServers())
+		{
+			switch (column)
+			{
+				case SORT_HOST:
+					return XBL_MM_GetServerName( index );
+				case SORT_MAP:
+					return XBL_MM_GetServerMap( index );
+				case SORT_CLIENTS:
+					return XBL_MM_GetServerClients( index );
+				case SORT_GAME:
+					return XBL_MM_GetServerGametype( index );
+				case SORT_PING:
+					return XBL_MM_GetServerPing( index );
+			}
+		}
+	}
+#endif
+
+	return "";
+}
+
+
+static qhandle_t UI_FeederItemImage(float feederID, int index) {
+	int	validCnt,i;
+	static char info[MAX_STRING_CHARS];
+
+	if (feederID == FEEDER_SABER_SINGLE_INFO) 
+	{
+		return 0;
+	}
+	else if (feederID == FEEDER_SABER_STAFF_INFO)
+	{
+		return 0;
+	}
+	else if (feederID == FEEDER_Q3HEADS) 
+	{
+		int actual;
+		UI_SelectedTeamHead(index, &actual);
+		index = actual;
+
+		if (index >= 0 && index < uiInfo.q3HeadCount)
+		{ //we want it to load them as it draws them, like the TA feeder
+		      //return uiInfo.q3HeadIcons[index];
+			int selModel = trap_Cvar_VariableValue("ui_selectedModelIndex");
+
+			if (selModel != -1)
+			{
+				if (uiInfo.q3SelectedHead != selModel)
+				{
+					uiInfo.q3SelectedHead = selModel;
+					//UI_FeederSelection(FEEDER_Q3HEADS, uiInfo.q3SelectedHead);
+					Menu_SetFeederSelection(NULL, FEEDER_Q3HEADS, selModel, NULL);
+				}
+			}
+
+			if (!uiInfo.q3HeadIcons[index])
+			{ //this isn't the best way of doing this I guess, but I didn't want a whole seperate string array
+			  //for storing shader names. I can't just replace q3HeadNames with the shader name, because we
+			  //print what's in q3HeadNames and the icon name would look funny.
+				char iconNameFromSkinName[256];
+				int i = 0;
+				int skinPlace;
+
+				i = strlen(uiInfo.q3HeadNames[index]);
+
+				while (uiInfo.q3HeadNames[index][i] != '/')
+				{
+					i--;
+				}
+
+				i++;
+				skinPlace = i; //remember that this is where the skin name begins
+
+				//now, build a full path out of what's in q3HeadNames, into iconNameFromSkinName
+				Com_sprintf(iconNameFromSkinName, sizeof(iconNameFromSkinName), "models/players/%s", uiInfo.q3HeadNames[index]);
+
+				i = strlen(iconNameFromSkinName);
+
+				while (iconNameFromSkinName[i] != '/')
+				{
+					i--;
+				}
+				
+				i++;
+				iconNameFromSkinName[i] = 0; //terminate, and append..
+				Q_strcat(iconNameFromSkinName, 256, "icon_");
+
+				//and now, for the final step, append the skin name from q3HeadNames onto the end of iconNameFromSkinName
+				i = strlen(iconNameFromSkinName);
+
+				while (uiInfo.q3HeadNames[index][skinPlace])
+				{
+					iconNameFromSkinName[i] = uiInfo.q3HeadNames[index][skinPlace];
+					i++;
+					skinPlace++;
+				}
+				iconNameFromSkinName[i] = 0;
+
+				//and now we are ready to register (thankfully this will only happen once)
+				uiInfo.q3HeadIcons[index] = trap_R_RegisterShaderNoMip(iconNameFromSkinName);
+			}
+			return uiInfo.q3HeadIcons[index];
+		}
+    }
+	else if (feederID == FEEDER_SIEGE_TEAM1) 
+	{
+		if (!siegeTeam1)
+		{
+			UI_SetSiegeTeams();
+			if (!siegeTeam1)
+			{
+				return 0;
+			}
+		}
+
+		if (siegeTeam1->classes[index])
+		{
+			return siegeTeam1->classes[index]->uiPortraitShader;
+		}
+		return 0;
+	}
+	else if (feederID == FEEDER_SIEGE_TEAM2) 
+	{
+		if (!siegeTeam2)
+		{
+			UI_SetSiegeTeams();
+			if (!siegeTeam2)
+			{
+				return 0;
+			}
+		}
+
+		if (siegeTeam2->classes[index])
+		{
+			return siegeTeam2->classes[index]->uiPortraitShader;
+		}
+		return 0;
+	}
+	else if (feederID == FEEDER_ALLMAPS || feederID == FEEDER_MAPS) 
+	{
+		int actual;
+		UI_SelectedMap(index, &actual);
+		index = actual;
+		if (index >= 0 && index < uiInfo.mapCount) {
+			if (uiInfo.mapList[index].levelShot == -1) {
+				uiInfo.mapList[index].levelShot = trap_R_RegisterShaderNoMip(uiInfo.mapList[index].imageName);
+			}
+			return uiInfo.mapList[index].levelShot;
+		}
+	}
+	else if (feederID == FEEDER_PLAYER_SKIN_HEAD) 
+	{
+		if (index >= 0 && index < uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].SkinHeadCount) 
+		{
+			//return uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].SkinHeadIcons[index];
+			return trap_R_RegisterShaderNoMip(va("models/players/%s/icon_%s", uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].Name, uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].SkinHeadNames[index]));
+		}
+	} 
+	else if (feederID == FEEDER_PLAYER_SKIN_TORSO) 
+	{
+		if (index >= 0 && index < uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].SkinTorsoCount) 
+		{
+			//return uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].SkinTorsoIcons[index];
+			return trap_R_RegisterShaderNoMip(va("models/players/%s/icon_%s", uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].Name, uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].SkinTorsoNames[index]));
+		}
+	} 
+	else if (feederID == FEEDER_PLAYER_SKIN_LEGS) 
+	{
+		if (index >= 0 && index < uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].SkinLegCount) 
+		{
+			//return uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].SkinLegIcons[index];
+			return trap_R_RegisterShaderNoMip(va("models/players/%s/icon_%s", uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].Name, uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].SkinLegNames[index]));
+		}
+	} 
+	else if (feederID == FEEDER_COLORCHOICES)
+	{
+		if (index >= 0 && index < uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].ColorCount) 
+		{
+			return trap_R_RegisterShaderNoMip( uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].ColorShader[index]);
+		}
+	}
+
+	else if ( feederID == FEEDER_SIEGE_BASE_CLASS)
+	{
+		int team,baseClass; 
+
+		team = (int)trap_Cvar_VariableValue("ui_team");
+		baseClass = (int)trap_Cvar_VariableValue("ui_siege_class");
+
+		if ((team == SIEGETEAM_TEAM1) || 
+			(team == SIEGETEAM_TEAM2)) 
+		{
+			// Is it a valid base class?
+			if ((baseClass >= SPC_INFANTRY) && (baseClass < SPC_MAX))
+			{
+				if (index >= 0) 
+				{
+					return(BG_GetUIPortrait(team, baseClass, index));
+				}
+			}
+		}
+	}
+	else if ( feederID == FEEDER_SIEGE_CLASS_WEAPONS)
+	{
+		validCnt = 0;
+		//count them up
+		for (i=0;i< WP_NUM_WEAPONS;i++)
+		{
+			trap_Cvar_VariableStringBuffer( va("ui_class_weapon%i", i), info, sizeof(info) );
+			if (stricmp(info,"gfx/2d/select")!=0)
+			{
+				if (validCnt == index)
+				{
+					return(trap_R_RegisterShaderNoMip(info));
+				}
+				validCnt++;
+			}
+		}
+	}
+	else if ( feederID == FEEDER_SIEGE_CLASS_INVENTORY)
+	{
+		validCnt = 0;
+		//count them up
+		for (i=0;i< HI_NUM_HOLDABLE;i++)
+		{
+			trap_Cvar_VariableStringBuffer( va("ui_class_item%i", i), info, sizeof(info) );
+			// A hack so health and ammo dispenser icons don't show up.
+			if ((stricmp(info,"gfx/2d/select")!=0) && (stricmp(info,"gfx/hud/i_icon_healthdisp")!=0) &&
+				(stricmp(info,"gfx/hud/i_icon_ammodisp")!=0))
+			{
+				if (validCnt == index)
+				{
+					return(trap_R_RegisterShaderNoMip(info));
+				}
+				validCnt++;
+			}
+		}
+	}
+	else if ( feederID == FEEDER_SIEGE_CLASS_FORCE)
+	{
+		int slotI=0;
+		static char info2[MAX_STRING_CHARS];
+		menuDef_t *menu;
+		itemDef_t *item;
+
+
+		validCnt = 0;
+
+
+		menu = Menu_GetFocused();	// Get current menu
+		if (menu)
+		{
+			item = (itemDef_t *) Menu_FindItemByName((menuDef_t *) menu, "base_class_force_feed");
+			if (item)
+			{
+				listBoxDef_t *listPtr = (listBoxDef_t*)item->typeData;
+				if (listPtr)
+				{
+					slotI = listPtr->startPos;
+				}
+			}
+		}
+
+		//count them up
+		for (i=0;i< NUM_FORCE_POWERS;i++)
+		{
+			trap_Cvar_VariableStringBuffer( va("ui_class_power%i", i), info, sizeof(info) );
+			if (stricmp(info,"gfx/2d/select")!=0)
+			{
+				if (validCnt == index)
+				{
+					trap_Cvar_VariableStringBuffer( va("ui_class_powerlevel%i", validCnt), info2, sizeof(info2) );
+
+					trap_Cvar_Set(va("ui_class_powerlevelslot%i", index-slotI), info2);
+					return(trap_R_RegisterShaderNoMip(info));
+				}
+				validCnt++;
+			}
+		}
+	}
+
+  return 0;
+}
+
+
+
+//called every time a class is selected from a feeder, sets info
+//for shaders to be displayed in the menu about the class -rww
+extern qboolean UI_SaberTypeForSaber( const char *saberName, char *saberType );
+void UI_SiegeSetCvarsForClass(siegeClass_t *scl)
+{
+	int i = 0;
+	int count = 0;
+	char shader[MAX_QPATH];
+
+	//let's clear the things out first
+	while (i < WP_NUM_WEAPONS)
+	{
+		trap_Cvar_Set(va("ui_class_weapon%i", i), "gfx/2d/select");
+		i++;
+	}
+	//now for inventory items
+	i = 0;
+	while (i < HI_NUM_HOLDABLE)
+	{
+		trap_Cvar_Set(va("ui_class_item%i", i), "gfx/2d/select");
+		i++;
+	}
+	//now for force powers
+	i = 0;
+	while (i < NUM_FORCE_POWERS)
+	{
+		trap_Cvar_Set(va("ui_class_power%i", i), "gfx/2d/select");
+		i++;
+	}
+
+	//now health and armor
+	trap_Cvar_Set("ui_class_health", "0");
+	trap_Cvar_Set("ui_class_armor", "0");
+
+	trap_Cvar_Set("ui_class_icon", "");
+
+	if (!scl)
+	{ //no select?
+		return;
+	}
+
+	//set cvars for which weaps we have
+	i = 0;
+	trap_Cvar_Set(va("ui_class_weapondesc%i", count), " ");	// Blank it out to start with
+	while (i < WP_NUM_WEAPONS)
+	{
+
+		if (scl->weapons & (1<<i))
+		{
+
+			if (i == WP_SABER)
+			{ //we want to see what kind of saber they have, and set the cvar based on that
+				char saberType[1024];
+
+				if (scl->saber1[0] &&
+					scl->saber2[0])
+				{
+					strcpy(saberType, "gfx/hud/w_icon_duallightsaber");
+				} //fixme: need saber data access on ui to determine if staff, "gfx/hud/w_icon_saberstaff"
+				else
+				{
+					char buf[1024];
+					if (scl->saber1[0] && UI_SaberTypeForSaber(scl->saber1, buf))
+					{
+						if ( !Q_stricmp( buf, "SABER_STAFF" ) )
+						{
+							strcpy(saberType, "gfx/hud/w_icon_saberstaff");
+						}
+						else
+						{
+							strcpy(saberType, "gfx/hud/w_icon_lightsaber");
+						}
+					}
+					else
+					{
+						strcpy(saberType, "gfx/hud/w_icon_lightsaber");
+					}
+				}
+
+				trap_Cvar_Set(va("ui_class_weapon%i", count), saberType);
+				trap_Cvar_Set(va("ui_class_weapondesc%i", count), "@MENUS_AN_ELEGANT_WEAPON_FOR");
+				count++;
+				trap_Cvar_Set(va("ui_class_weapondesc%i", count), " ");	// Blank it out to start with
+			}
+			else
+			{
+				gitem_t *item = BG_FindItemForWeapon( i );
+				trap_Cvar_Set(va("ui_class_weapon%i", count), item->icon);
+				trap_Cvar_Set(va("ui_class_weapondesc%i", count), item->description);
+				count++;
+				trap_Cvar_Set(va("ui_class_weapondesc%i", count), " ");	// Blank it out to start with
+			}
+		}
+
+		i++;
+	}
+
+	//now for inventory items
+	i = 0;
+	count = 0;
+
+	while (i < HI_NUM_HOLDABLE)
+	{
+		if (scl->invenItems & (1<<i))
+		{
+			gitem_t *item = BG_FindItemForHoldable(i);
+			trap_Cvar_Set(va("ui_class_item%i", count), item->icon);
+			trap_Cvar_Set(va("ui_class_itemdesc%i", count), item->description);
+			count++;
+		}
+		else
+		{
+			trap_Cvar_Set(va("ui_class_itemdesc%i", count), " ");
+		}
+		i++;
+	}
+
+	//now for force powers
+	i = 0;
+	count = 0;
+
+	while (i < NUM_FORCE_POWERS)
+	{
+		trap_Cvar_Set(va("ui_class_powerlevel%i", i), "0");	// Zero this out to start.
+		if (i<9)
+		{
+			trap_Cvar_Set(va("ui_class_powerlevelslot%i", i), "0");	// Zero this out to start.
+		}
+
+		if (scl->forcePowerLevels[i])
+		{
+			trap_Cvar_Set(va("ui_class_powerlevel%i", count), va("%i",scl->forcePowerLevels[i]));
+			trap_Cvar_Set(va("ui_class_power%i", count), HolocronIcons[i]);
+			count++;
+		}
+
+		i++;
+	}
+
+	//now health and armor
+	trap_Cvar_Set("ui_class_health", va("%i", scl->maxhealth));
+	trap_Cvar_Set("ui_class_armor", va("%i", scl->maxarmor));
+	trap_Cvar_Set("ui_class_speed", va("%3.2f", scl->speed));
+
+	//now get the icon path based on the shader index
+	if (scl->classShader)
+	{
+		trap_R_ShaderNameFromIndex(shader, scl->classShader);
+	}
+	else
+	{ //no shader
+		shader[0] = 0;
+	}
+	trap_Cvar_Set("ui_class_icon", shader);
+}
+
+int g_siegedFeederForcedSet = 0;
+
+void UI_UpdateCvarsForClass(const int team,const baseClass,const int index)
+{
+	siegeClass_t *holdClass=0;
+	char *holdBuf;
+
+	// Is it a valid team
+	if ((team == SIEGETEAM_TEAM1) || 
+		(team == SIEGETEAM_TEAM2)) 
+	{
+
+		// Is it a valid base class?
+		if ((baseClass >= SPC_INFANTRY) && (baseClass < SPC_MAX))
+		{
+			// A valid index?
+			if ((index>=0) && (index < BG_SiegeCountBaseClass( team, baseClass )))
+			{
+				if (!g_siegedFeederForcedSet)
+				{
+					holdClass = BG_GetClassOnBaseClass( team, baseClass, index);					
+					if (holdClass)	//clicked a valid item
+					{
+						g_UIGloballySelectedSiegeClass = UI_SiegeClassNum(holdClass);
+						trap_Cvar_Set("ui_classDesc", g_UIClassDescriptions[g_UIGloballySelectedSiegeClass].desc);
+						g_siegedFeederForcedSet = 1;
+						Menu_SetFeederSelection(NULL, FEEDER_SIEGE_BASE_CLASS, -1, NULL);
+						UI_SiegeSetCvarsForClass(holdClass);
+
+						holdBuf = BG_GetUIPortraitFile(team, baseClass, index);
+						if (holdBuf)
+						{
+							trap_Cvar_Set("ui_classPortrait",holdBuf);
+						}
+					}
+				}
+				g_siegedFeederForcedSet = 0;
+			}
+			else
+			{
+				trap_Cvar_Set("ui_classDesc", " ");
+			}
+		}
+	}
+
+}
+
+
+qboolean UI_FeederSelection(float feederFloat, int index, itemDef_t *item) 
+{
+	static char info[MAX_STRING_CHARS];
+	const int feederID = feederFloat;
+
+	if (feederID == FEEDER_Q3HEADS) 
+	{
+		int actual;
+		UI_SelectedTeamHead(index, &actual);
+		uiInfo.q3SelectedHead = index;
+		trap_Cvar_Set("ui_selectedModelIndex", va("%i", index));
+		index = actual;
+		if (index >= 0 && index < uiInfo.q3HeadCount) 
+		{
+			trap_Cvar_Set( "model", uiInfo.q3HeadNames[index]);
+		}
+	} 
+	else if (feederID == FEEDER_MOVES) 
+	{
+		itemDef_t *item;
+		menuDef_t *menu;
+		modelDef_t *modelPtr;
+
+		menu = Menus_FindByName("rulesMenu_moves");
+
+		if (menu)
+		{
+			item = (itemDef_t *) Menu_FindItemByName((menuDef_t *) menu, "character");
+			if (item)
+			{
+				modelPtr = (modelDef_t*)item->typeData;
+				if (modelPtr)
+				{
+					char modelPath[MAX_QPATH];
+					int animRunLength;
+
+					ItemParse_model_g2anim_go( item,  datapadMoveData[uiInfo.movesTitleIndex][index].anim );
+
+					Com_sprintf( modelPath, sizeof( modelPath ), "models/players/%s/model.glm", UI_Cvar_VariableString ( "ui_char_model" ) );
+					ItemParse_asset_model_go( item, modelPath, &animRunLength );
+					UI_UpdateCharacterSkin();
+
+					uiInfo.moveAnimTime = uiInfo.uiDC.realTime + animRunLength;
+
+					if (datapadMoveData[uiInfo.movesTitleIndex][index].anim)
+					{
+
+						// Play sound for anim
+						if (datapadMoveData[uiInfo.movesTitleIndex][index].sound == MDS_FORCE_JUMP)
+						{
+							trap_S_StartLocalSound( uiInfo.uiDC.Assets.moveJumpSound, CHAN_LOCAL );
+						}
+						else if (datapadMoveData[uiInfo.movesTitleIndex][index].sound == MDS_ROLL)
+						{
+							trap_S_StartLocalSound( uiInfo.uiDC.Assets.moveRollSound, CHAN_LOCAL );
+						}
+						else if (datapadMoveData[uiInfo.movesTitleIndex][index].sound == MDS_SABER)
+						{
+							// Randomly choose one sound
+							int soundI = Q_irand( 1, 6 );
+							sfxHandle_t *soundPtr;
+							soundPtr = &uiInfo.uiDC.Assets.datapadmoveSaberSound1;
+							if (soundI == 2)
+							{
+								soundPtr = &uiInfo.uiDC.Assets.datapadmoveSaberSound2;
+							}
+							else if (soundI == 3)
+							{
+								soundPtr = &uiInfo.uiDC.Assets.datapadmoveSaberSound3;
+							}
+							else if (soundI == 4)
+							{
+								soundPtr = &uiInfo.uiDC.Assets.datapadmoveSaberSound4;
+							}
+							else if (soundI == 5)
+							{
+								soundPtr = &uiInfo.uiDC.Assets.datapadmoveSaberSound5;
+							}
+							else if (soundI == 6)
+							{
+								soundPtr = &uiInfo.uiDC.Assets.datapadmoveSaberSound6;
+							}
+
+							trap_S_StartLocalSound( *soundPtr, CHAN_LOCAL );
+						}
+
+						if (datapadMoveData[uiInfo.movesTitleIndex][index].desc)
+						{
+							trap_Cvar_Set( "ui_move_desc", datapadMoveData[uiInfo.movesTitleIndex][index].desc);
+						}
+					}
+					UI_SaberAttachToChar( item );
+				}
+			}
+		}
+	} 
+	else if (feederID == FEEDER_MOVES_TITLES) 
+	{
+		itemDef_t *item;
+		menuDef_t *menu;
+		modelDef_t *modelPtr;
+
+		uiInfo.movesTitleIndex = index;
+		uiInfo.movesBaseAnim = datapadMoveTitleBaseAnims[uiInfo.movesTitleIndex];
+		menu = Menus_FindByName("rulesMenu_moves");
+
+		if (menu)
+		{
+			item = (itemDef_t *) Menu_FindItemByName((menuDef_t *) menu, "character");
+			if (item)
+			{
+				modelPtr = (modelDef_t*)item->typeData;
+				if (modelPtr)
+				{
+					char modelPath[MAX_QPATH];
+					int	animRunLength;
+
+					uiInfo.movesBaseAnim = datapadMoveTitleBaseAnims[uiInfo.movesTitleIndex];
+					ItemParse_model_g2anim_go( item,  uiInfo.movesBaseAnim );
+
+					Com_sprintf( modelPath, sizeof( modelPath ), "models/players/%s/model.glm", UI_Cvar_VariableString ( "ui_char_model" ) );
+					ItemParse_asset_model_go( item, modelPath, &animRunLength );
+
+					UI_UpdateCharacterSkin();
+
+				}
+			}
+		}
+	}
+	else if (feederID == FEEDER_SIEGE_TEAM1)
+	{
+		if (!g_siegedFeederForcedSet)
+		{
+			g_UIGloballySelectedSiegeClass = UI_SiegeClassNum(siegeTeam1->classes[index]);
+			trap_Cvar_Set("ui_classDesc", g_UIClassDescriptions[g_UIGloballySelectedSiegeClass].desc);
+
+			//g_siegedFeederForcedSet = 1;
+			//Menu_SetFeederSelection(NULL, FEEDER_SIEGE_TEAM2, -1, NULL);
+
+			UI_SiegeSetCvarsForClass(siegeTeam1->classes[index]);
+		}
+		g_siegedFeederForcedSet = 0;
+	}
+	else if (feederID == FEEDER_SIEGE_TEAM2)
+	{
+		if (!g_siegedFeederForcedSet)
+		{
+			g_UIGloballySelectedSiegeClass = UI_SiegeClassNum(siegeTeam2->classes[index]);
+			trap_Cvar_Set("ui_classDesc", g_UIClassDescriptions[g_UIGloballySelectedSiegeClass].desc);
+
+			//g_siegedFeederForcedSet = 1;
+			//Menu_SetFeederSelection(NULL, FEEDER_SIEGE_TEAM2, -1, NULL);
+
+			UI_SiegeSetCvarsForClass(siegeTeam2->classes[index]);
+		}
+		g_siegedFeederForcedSet = 0;
+	}
+	else if (feederID == FEEDER_FORCECFG) 
+	{
+		int newindex = index;
+
+		if (uiForceSide == FORCE_LIGHTSIDE)
+		{
+			newindex += uiInfo.forceConfigLightIndexBegin;
+			if (newindex >= uiInfo.forceConfigCount)
+			{
+				return qfalse;
+			}
+		}
+		else
+		{ //else dark
+			newindex += uiInfo.forceConfigDarkIndexBegin;
+			if (newindex >= uiInfo.forceConfigCount || newindex > uiInfo.forceConfigLightIndexBegin)
+			{ //dark gets read in before light
+				return qfalse;
+			}
+		}
+
+		if (index >= 0 && index < uiInfo.forceConfigCount) 
+		{
+				UI_ForceConfigHandle(uiInfo.forceConfigSelected, index);
+				uiInfo.forceConfigSelected = index;
+		}
+	} 
+	else if (feederID == FEEDER_MAPS || feederID == FEEDER_ALLMAPS) 
+	{
+		int actual, map;
+		const char *checkValid = NULL;
+
+		map = (feederID == FEEDER_ALLMAPS) ? ui_currentNetMap.integer : ui_currentMap.integer;
+		if (uiInfo.mapList[map].cinematic >= 0) {
+		  trap_CIN_StopCinematic(uiInfo.mapList[map].cinematic);
+		  uiInfo.mapList[map].cinematic = -1;
+		}
+		checkValid = UI_SelectedMap(index, &actual);
+
+		if (!checkValid || !checkValid[0])
+		{ //this isn't a valid map to select, so reselect the current
+			index = ui_mapIndex.integer;
+			UI_SelectedMap(index, &actual);
+		}
+
+		trap_Cvar_Set("ui_mapIndex", va("%d", index));
+		gUISelectedMap = index;
+		ui_mapIndex.integer = index;
+
+		if (feederID == FEEDER_MAPS) {
+			ui_currentMap.integer = actual;
+			trap_Cvar_Set("ui_currentMap", va("%d", actual));
+		uiInfo.mapList[ui_currentMap.integer].cinematic = trap_CIN_PlayCinematic(va("%s.roq", uiInfo.mapList[ui_currentMap.integer].mapLoadName), 0, 0, 0, 0, (CIN_loop | CIN_silent) );
+			UI_LoadBestScores(uiInfo.mapList[ui_currentMap.integer].mapLoadName, uiInfo.gameTypes[ui_gameType.integer].gtEnum);
+			//trap_Cvar_Set("ui_opponentModel", uiInfo.mapList[ui_currentMap.integer].opponentName);
+			//updateOpponentModel = qtrue;
+		} else {
+			ui_currentNetMap.integer = actual;
+			trap_Cvar_Set("ui_currentNetMap", va("%d", actual));
+		uiInfo.mapList[ui_currentNetMap.integer].cinematic = trap_CIN_PlayCinematic(va("%s.roq", uiInfo.mapList[ui_currentNetMap.integer].mapLoadName), 0, 0, 0, 0, (CIN_loop | CIN_silent) );
+		}
+
+	} else if (feederID == FEEDER_SERVERS) {
+		const char *mapName = NULL;
+		uiInfo.serverStatus.currentServer = index;
+		trap_LAN_GetServerInfo(ui_netSource.integer, uiInfo.serverStatus.displayServers[index], info, MAX_STRING_CHARS);
+		uiInfo.serverStatus.currentServerPreview = trap_R_RegisterShaderNoMip(va("levelshots/%s", Info_ValueForKey(info, "mapname")));
+		if (uiInfo.serverStatus.currentServerCinematic >= 0) {
+		  trap_CIN_StopCinematic(uiInfo.serverStatus.currentServerCinematic);
+			uiInfo.serverStatus.currentServerCinematic = -1;
+		}
+		mapName = Info_ValueForKey(info, "mapname");
+		if (mapName && *mapName) {
+			uiInfo.serverStatus.currentServerCinematic = trap_CIN_PlayCinematic(va("%s.roq", mapName), 0, 0, 0, 0, (CIN_loop | CIN_silent) );
+		}
+	} else if (feederID == FEEDER_SERVERSTATUS) {
+		//
+	} else if (feederID == FEEDER_FINDPLAYER) {
+	  uiInfo.currentFoundPlayerServer = index;
+	  //
+	  if ( index < uiInfo.numFoundPlayerServers-1) {
+			// build a new server status for this server
+			Q_strncpyz(uiInfo.serverStatusAddress, uiInfo.foundPlayerServerAddresses[uiInfo.currentFoundPlayerServer], sizeof(uiInfo.serverStatusAddress));
+			Menu_SetFeederSelection(NULL, FEEDER_SERVERSTATUS, 0, NULL);
+			UI_BuildServerStatus(qtrue);
+	  }
+	} else if (feederID == FEEDER_PLAYER_LIST) {
+		uiInfo.playerIndex = index;
+	} else if (feederID == FEEDER_TEAM_LIST) {
+		uiInfo.teamIndex = index;
+	} else if (feederID == FEEDER_MODS) {
+		uiInfo.modIndex = index;
+	} else if (feederID == FEEDER_CINEMATICS) {
+		uiInfo.movieIndex = index;
+		if (uiInfo.previewMovie >= 0) {
+		  trap_CIN_StopCinematic(uiInfo.previewMovie);
+		}
+		uiInfo.previewMovie = -1;
+	} else if (feederID == FEEDER_DEMOS) {
+		uiInfo.demoIndex = index;
+	}
+	else if (feederID == FEEDER_COLORCHOICES) 
+	{
+		if (index >= 0 && index < uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].ColorCount)
+		{
+			Item_RunScript(item, uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].ColorActionText[index]);
+		}
+	}
+	else if (feederID == FEEDER_PLAYER_SKIN_HEAD) 
+	{
+		if (index >= 0 && index < uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].SkinHeadCount)
+		{
+			trap_Cvar_Set("ui_char_skin_head", uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].SkinHeadNames[index]);
+		}
+	} 
+	else if (feederID == FEEDER_PLAYER_SKIN_TORSO) 
+	{
+		if (index >= 0 && index < uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].SkinTorsoCount)
+		{
+			trap_Cvar_Set("ui_char_skin_torso", uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].SkinTorsoNames[index]);
+		}
+	} 
+	else if (feederID == FEEDER_PLAYER_SKIN_LEGS) 
+	{
+		if (index >= 0 && index < uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].SkinLegCount)
+		{
+			trap_Cvar_Set("ui_char_skin_legs", uiInfo.playerSpecies[uiInfo.playerSpeciesIndex].SkinLegNames[index]);
+		}
+	} 
+	else if (feederID == FEEDER_PLAYER_SPECIES) 
+	{
+		uiInfo.playerSpeciesIndex = index;
+	} 
+	else if (feederID == FEEDER_LANGUAGES) 
+	{
+		uiInfo.languageCountIndex = index;
+	} 
+	else if (  feederID == FEEDER_SIEGE_BASE_CLASS )
+	{
+		int team,baseClass; 
+
+		team = (int)trap_Cvar_VariableValue("ui_team");
+		baseClass = (int)trap_Cvar_VariableValue("ui_siege_class");
+
+		UI_UpdateCvarsForClass(team, baseClass, index);
+	}
+	else if (feederID == FEEDER_SIEGE_CLASS_WEAPONS) 
+	{
+//		trap_Cvar_VariableStringBuffer( va("ui_class_weapondesc%i", index), info, sizeof(info) );
+//		trap_Cvar_Set( "ui_itemforceinvdesc", info );
+	} 
+	else if (feederID == FEEDER_SIEGE_CLASS_INVENTORY) 
+	{
+//		trap_Cvar_VariableStringBuffer( va("ui_class_itemdesc%i", index), info, sizeof(info) );
+//		trap_Cvar_Set( "ui_itemforceinvdesc", info );
+	} 
+	else if (feederID == FEEDER_SIEGE_CLASS_FORCE) 
+	{
+		int i;
+//		int validCnt = 0;
+
+		trap_Cvar_VariableStringBuffer( va("ui_class_power%i", index), info, sizeof(info) );
+
+		//count them up
+		for (i=0;i< NUM_FORCE_POWERS;i++)
+		{
+			if (!strcmp(HolocronIcons[i],info))
+			{
+				trap_Cvar_Set( "ui_itemforceinvdesc", forcepowerDesc[i] );
+			}
+		}
+	} 
+#ifdef _XBOX
+	else if (feederID == FEEDER_XBL_ACCOUNTS)
+	{
+		XBL_SetAccountIndex( index );
+	}
+	else if (feederID == FEEDER_XBL_PLAYERS)
+	{
+		XBL_PL_SetPlayerIndex( index );
+	}
+	else if (feederID == FEEDER_XBL_FRIENDS)
+	{
+		XBL_F_SetChosenFriendIndex( index );
+	}
+	else if (feederID == FEEDER_XBL_SERVERS)
+	{
+		XBL_MM_SetChosenServerIndex( index );
+	}
+#endif
+
+	return qtrue;
+}
+
+
+static qboolean GameType_Parse(char **p, qboolean join) {
+	char *token;
+
+	token = COM_ParseExt((const char **)p, qtrue);
+
+	if (token[0] != '{') {
+		return qfalse;
+	}
+
+	if (join) {
+		uiInfo.numJoinGameTypes = 0;
+	} else {
+		uiInfo.numGameTypes = 0;
+	}
+
+	while ( 1 ) {
+		token = COM_ParseExt((const char **)p, qtrue);
+
+		if (Q_stricmp(token, "}") == 0) {
+			return qtrue;
+		}
+
+		if ( !token || token[0] == 0 ) {
+			return qfalse;
+		}
+
+		if (token[0] == '{') {
+			// two tokens per line, character name and sex
+			if (join) {
+				if (!String_Parse(p, &uiInfo.joinGameTypes[uiInfo.numJoinGameTypes].gameType) || !Int_Parse(p, &uiInfo.joinGameTypes[uiInfo.numJoinGameTypes].gtEnum)) {
+					return qfalse;
+				}
+			} else {
+				if (!String_Parse(p, &uiInfo.gameTypes[uiInfo.numGameTypes].gameType) || !Int_Parse(p, &uiInfo.gameTypes[uiInfo.numGameTypes].gtEnum)) {
+					return qfalse;
+				}
+			}
+    
+			if (join) {
+				if (uiInfo.numJoinGameTypes < MAX_GAMETYPES) {
+					uiInfo.numJoinGameTypes++;
+				} else {
+					Com_Printf("Too many net game types, last one replace!\n");
+				}		
+			} else {
+				if (uiInfo.numGameTypes < MAX_GAMETYPES) {
+					uiInfo.numGameTypes++;
+				} else {
+					Com_Printf("Too many game types, last one replace!\n");
+				}		
+			}
+     
+			token = COM_ParseExt((const char **)p, qtrue);
+			if (token[0] != '}') {
+				return qfalse;
+			}
+		}
+	}
+	return qfalse;
+}
+
+static qboolean MapList_Parse(char **p) {
+	char *token;
+
+	token = COM_ParseExt((const char **)p, qtrue);
+
+	if (token[0] != '{') {
+		return qfalse;
+	}
+
+	uiInfo.mapCount = 0;
+
+	while ( 1 ) {
+		token = COM_ParseExt((const char **)p, qtrue);
+
+		if (Q_stricmp(token, "}") == 0) {
+			return qtrue;
+		}
+
+		if ( !token || token[0] == 0 ) {
+			return qfalse;
+		}
+
+		if (token[0] == '{') {
+			if (!String_Parse(p, &uiInfo.mapList[uiInfo.mapCount].mapName) || !String_Parse(p, &uiInfo.mapList[uiInfo.mapCount].mapLoadName) 
+				||!Int_Parse(p, &uiInfo.mapList[uiInfo.mapCount].teamMembers) ) {
+				return qfalse;
+			}
+
+			if (!String_Parse(p, &uiInfo.mapList[uiInfo.mapCount].opponentName)) {
+				return qfalse;
+			}
+
+			uiInfo.mapList[uiInfo.mapCount].typeBits = 0;
+
+			while (1) {
+				token = COM_ParseExt((const char **)p, qtrue);
+				if (token[0] >= '0' && token[0] <= '9') {
+					uiInfo.mapList[uiInfo.mapCount].typeBits |= (1 << (token[0] - 0x030));
+					if (!Int_Parse(p, &uiInfo.mapList[uiInfo.mapCount].timeToBeat[token[0] - 0x30])) {
+						return qfalse;
+					}
+				} else {
+					break;
+				} 
+			}
+
+			//mapList[mapCount].imageName = String_Alloc(va("levelshots/%s", mapList[mapCount].mapLoadName));
+			//if (uiInfo.mapCount == 0) {
+			  // only load the first cinematic, selection loads the others
+  			//  uiInfo.mapList[uiInfo.mapCount].cinematic = trap_CIN_PlayCinematic(va("%s.roq",uiInfo.mapList[uiInfo.mapCount].mapLoadName), qfalse, qfalse, qtrue, 0, 0, 0, 0);
+			//}
+  		uiInfo.mapList[uiInfo.mapCount].cinematic = -1;
+			uiInfo.mapList[uiInfo.mapCount].levelShot = trap_R_RegisterShaderNoMip(va("levelshots/%s_small", uiInfo.mapList[uiInfo.mapCount].mapLoadName));
+
+			if (uiInfo.mapCount < MAX_MAPS) {
+				uiInfo.mapCount++;
+			} else {
+				Com_Printf("Too many maps, last one replaced!\n");
+			}
+		}
+	}
+	return qfalse;
+}
+
+static void UI_ParseGameInfo(const char *teamFile) {
+	char	*token;
+	char *p;
+	char *buff = NULL;
+	//int mode = 0; TTimo: unused
+
+	buff = GetMenuBuffer(teamFile);
+	if (!buff) {
+		return;
+	}
+
+	p = buff;
+
+	while ( 1 ) {
+		token = COM_ParseExt( (const char **)(&p), qtrue );
+		if( !token || token[0] == 0 || token[0] == '}') {
+			break;
+		}
+
+		if ( Q_stricmp( token, "}" ) == 0 ) {
+			break;
+		}
+
+		if (Q_stricmp(token, "gametypes") == 0) {
+
+			if (GameType_Parse(&p, qfalse)) {
+				continue;
+			} else {
+				break;
+			}
+		}
+
+		if (Q_stricmp(token, "joingametypes") == 0) {
+
+			if (GameType_Parse(&p, qtrue)) {
+				continue;
+			} else {
+				break;
+			}
+		}
+
+		if (Q_stricmp(token, "maps") == 0) {
+			// start a new menu
+			MapList_Parse(&p);
+		}
+
+	}
+}
+
+static void UI_Pause(qboolean b) {
+	if (b) {
+		// pause the game and set the ui keycatcher
+	  trap_Cvar_Set( "cl_paused", "1" );
+		trap_Key_SetCatcher( KEYCATCH_UI );
+	} else {
+		// unpause the game and clear the ui keycatcher
+		trap_Key_SetCatcher( trap_Key_GetCatcher() & ~KEYCATCH_UI );
+		trap_Key_ClearStates();
+		trap_Cvar_Set( "cl_paused", "0" );
+	}
+}
+
+static int UI_PlayCinematic(const char *name, float x, float y, float w, float h) {
+  return trap_CIN_PlayCinematic(name, x, y, w, h, (CIN_loop | CIN_silent));
+}
+
+static void UI_StopCinematic(int handle) {
+	if (handle >= 0) {
+	  trap_CIN_StopCinematic(handle);
+	} else {
+		handle = abs(handle);
+		if (handle == UI_MAPCINEMATIC) {
+			if (uiInfo.mapList[ui_currentMap.integer].cinematic >= 0) {
+			  trap_CIN_StopCinematic(uiInfo.mapList[ui_currentMap.integer].cinematic);
+			  uiInfo.mapList[ui_currentMap.integer].cinematic = -1;
+			}
+		} else if (handle == UI_NETMAPCINEMATIC) {
+			if (uiInfo.serverStatus.currentServerCinematic >= 0) {
+			  trap_CIN_StopCinematic(uiInfo.serverStatus.currentServerCinematic);
+				uiInfo.serverStatus.currentServerCinematic = -1;
+			}
+		} else if (handle == UI_CLANCINEMATIC) {
+		  int i = UI_TeamIndexFromName(UI_Cvar_VariableString("ui_teamName"));
+		  if (i >= 0 && i < uiInfo.teamCount) {
+				if (uiInfo.teamList[i].cinematic >= 0) {
+				  trap_CIN_StopCinematic(uiInfo.teamList[i].cinematic);
+					uiInfo.teamList[i].cinematic = -1;
+				}
+			}
+		}
+	}
+}
+
+static void UI_DrawCinematic(int handle, float x, float y, float w, float h) {
+	trap_CIN_SetExtents(handle, x, y, w, h);
+  trap_CIN_DrawCinematic(handle);
+}
+
+static void UI_RunCinematicFrame(int handle) {
+  trap_CIN_RunCinematic(handle);
+}
+
+
+/*
+=================
+UI_LoadForceConfig_List
+=================
+Looks in the directory for force config files (.fcf) and loads the name in
+*/
+void UI_LoadForceConfig_List( void )
+{
+	int			numfiles = 0;
+	char		filelist[2048];
+	char		configname[128];
+	char		*fileptr = NULL;
+	int			j = 0;
+	int			filelen = 0;
+	qboolean	lightSearch = qfalse;
+
+	uiInfo.forceConfigCount = 0;
+	Com_sprintf( uiInfo.forceConfigNames[uiInfo.forceConfigCount], sizeof(uiInfo.forceConfigNames[uiInfo.forceConfigCount]), "Custom");
+	uiInfo.forceConfigCount++;
+	//Always reserve index 0 as the "custom" config
+
+nextSearch:
+	if (lightSearch)
+	{ //search light side folder
+		numfiles = trap_FS_GetFileList("forcecfg/light", "fcf", filelist, 2048 );
+		uiInfo.forceConfigLightIndexBegin = uiInfo.forceConfigCount-1;
+	}
+	else
+	{ //search dark side folder
+		numfiles = trap_FS_GetFileList("forcecfg/dark", "fcf", filelist, 2048 );
+		uiInfo.forceConfigDarkIndexBegin = uiInfo.forceConfigCount-1;
+	}
+
+	fileptr = filelist;
+
+	for (j=0; j<numfiles && uiInfo.forceConfigCount < MAX_FORCE_CONFIGS;j++,fileptr+=filelen+1)
+	{
+		filelen = strlen(fileptr);
+		COM_StripExtension(fileptr, configname);
+
+		if (lightSearch)
+		{
+			uiInfo.forceConfigSide[uiInfo.forceConfigCount] = qtrue; //light side config
+		}
+		else
+		{
+			uiInfo.forceConfigSide[uiInfo.forceConfigCount] = qfalse; //dark side config
+		}
+
+		Com_sprintf( uiInfo.forceConfigNames[uiInfo.forceConfigCount], sizeof(uiInfo.forceConfigNames[uiInfo.forceConfigCount]), configname);
+		uiInfo.forceConfigCount++;
+	}
+
+	if (!lightSearch)
+	{
+		lightSearch = qtrue;
+		goto nextSearch;
+	}
+}
+
+
+/*
+=================
+bIsImageFile
+builds path and scans for valid image extentions
+=================
+*/
+static qboolean bIsImageFile(const char* dirptr, const char* skinname)
+{
+	char fpath[MAX_QPATH];
+	int f;
+
+#ifdef _XBOX
+	Com_sprintf(fpath, MAX_QPATH, "models/players/%s/icon_%s.dds", dirptr, skinname);
+#else
+	Com_sprintf(fpath, MAX_QPATH, "models/players/%s/icon_%s.jpg", dirptr, skinname);
+#endif
+	trap_FS_FOpenFile(fpath, &f, FS_READ);
+#if !defined(_XBOX) || defined(_DEBUG)
+	if (!f)
+	{ //not there, try png
+		Com_sprintf(fpath, MAX_QPATH, "models/players/%s/icon_%s.png", dirptr, skinname);
+		trap_FS_FOpenFile(fpath, &f, FS_READ);
+	}
+	if (!f)
+	{ //not there, try tga
+		Com_sprintf(fpath, MAX_QPATH, "models/players/%s/icon_%s.tga", dirptr, skinname);
+		trap_FS_FOpenFile(fpath, &f, FS_READ);
+	}
+#endif
+	if (f) 
+	{
+		trap_FS_FCloseFile(f);
+		return qtrue;
+	}
+
+	return qfalse;
+}
+
+
+/*
+=================
+PlayerModel_BuildList
+=================
+*/
+static void UI_BuildQ3Model_List( void )
+{
+	int		numdirs;
+	int		numfiles;
+	char	dirlist[2048];
+	char	filelist[2048];
+	char	skinname[64];
+	char*	dirptr;
+	char*	fileptr;
+	char*	check;
+	int		i;
+	int		j, k, p, s;
+	int		dirlen;
+	int		filelen;
+
+	uiInfo.q3HeadCount = 0;
+
+	// iterate directory of all player models
+	numdirs = trap_FS_GetFileList("models/players", "/", dirlist, 2048 );
+	dirptr  = dirlist;
+	for (i=0; i<numdirs && uiInfo.q3HeadCount < MAX_Q3PLAYERMODELS; i++,dirptr+=dirlen+1)
+	{
+		dirlen = strlen(dirptr);
+		
+		if (dirlen && dirptr[dirlen-1]=='/') dirptr[dirlen-1]='\0';
+
+		if (!strcmp(dirptr,".") || !strcmp(dirptr,".."))
+			continue;
+			
+
+		numfiles = trap_FS_GetFileList( va("models/players/%s",dirptr), "skin", filelist, 2048 );
+		fileptr  = filelist;
+		for (j=0; j<numfiles && uiInfo.q3HeadCount < MAX_Q3PLAYERMODELS;j++,fileptr+=filelen+1)
+		{
+			int skinLen = 0;
+
+			filelen = strlen(fileptr);
+
+			COM_StripExtension(fileptr,skinname);
+
+			skinLen = strlen(skinname);
+			k = 0;
+			while (k < skinLen && skinname[k] && skinname[k] != '_')
+			{
+				k++;
+			}
+			if (skinname[k] == '_')
+			{
+				p = 0;
+
+				while (skinname[k])
+				{
+					skinname[p] = skinname[k];
+					k++;
+					p++;
+				}
+				skinname[p] = '\0';
+			}
+
+			/*
+#ifdef _XBOX
+			Com_sprintf(fpath, 2048, "models/players/%s/icon%s.dds", dirptr, skinname);
+#else
+			Com_sprintf(fpath, 2048, "models/players/%s/icon%s.jpg", dirptr, skinname);
+#endif
+
+			trap_FS_FOpenFile(fpath, &f, FS_READ);
+
+			if (f)
+			*/
+			check = &skinname[1];
+			if (bIsImageFile(dirptr, check))
+			{ //if it exists
+				qboolean iconExists = qfalse;
+
+				//trap_FS_FCloseFile(f);
+
+				if (skinname[0] == '_')
+				{ //change character to append properly
+					skinname[0] = '/';
+				}
+
+				s = 0;
+
+				while (s < uiInfo.q3HeadCount)
+				{ //check for dupes
+					if (!Q_stricmp(va("%s%s", dirptr, skinname), uiInfo.q3HeadNames[s]))
+					{
+						iconExists = qtrue;
+						break;
+					}
+					s++;
+				}
+
+				if (iconExists)
+				{
+					continue;
+				}
+
+				Com_sprintf( uiInfo.q3HeadNames[uiInfo.q3HeadCount], sizeof(uiInfo.q3HeadNames[uiInfo.q3HeadCount]), va("%s%s", dirptr, skinname));
+				uiInfo.q3HeadIcons[uiInfo.q3HeadCount++] = 0;//trap_R_RegisterShaderNoMip(fpath);
+				//rww - we are now registering them as they are drawn like the TA feeder, so as to decrease UI load time.
+			}
+
+			if (uiInfo.q3HeadCount >= MAX_Q3PLAYERMODELS)
+			{
+				return;
+			}
+		}
+	}	
+
+}
+
+void UI_SiegeInit(void)
+{
+	//Load the player class types
+	BG_SiegeLoadClasses(g_UIClassDescriptions);
+
+	if (!bgNumSiegeClasses)
+	{ //We didn't find any?!
+		Com_Error(ERR_DROP, "Couldn't find any player classes for Siege");
+	}
+
+	//Now load the teams since we have class data.
+	BG_SiegeLoadTeams();
+
+	if (!bgNumSiegeTeams)
+	{ //React same as with classes.
+		Com_Error(ERR_DROP, "Couldn't find any player teams for Siege");
+	}
+}
+
+/*
+=================
+UI_ParseColorData
+=================
+*/
+//static qboolean UI_ParseColorData(char* buf, playerSpeciesInfo_t &species)
+static qboolean UI_ParseColorData(char* buf, playerSpeciesInfo_t *species,char*	file)
+{
+	const char	*token;
+	const char	*p;
+
+	p = buf;
+	COM_BeginParseSession(file);
+	species->ColorCount = 0;
+
+	while ( p )
+	{
+		token = COM_ParseExt( &p, qtrue );	//looking for the shader
+		if ( token[0] == 0 )
+		{
+			return species->ColorCount;
+		}
+		Q_strncpyz( species->ColorShader[species->ColorCount], token, sizeof(species->ColorShader[0]) );
+
+		token = COM_ParseExt( &p, qtrue );	//looking for action block {
+		if ( token[0] != '{' )
+		{
+			return qfalse;
+		}
+
+		assert(!species->ColorActionText[species->ColorCount][0]);
+		token = COM_ParseExt( &p, qtrue );	//looking for action commands
+		while (token[0] != '}')
+		{
+			if ( token[0] == 0)
+			{	//EOF
+				return qfalse;
+			}
+			assert(species->ColorCount < sizeof(species->ColorActionText)/sizeof(species->ColorActionText[0]) );
+			Q_strcat(species->ColorActionText[species->ColorCount], sizeof(species->ColorActionText[0]), token);
+			Q_strcat(species->ColorActionText[species->ColorCount], sizeof(species->ColorActionText[0]), " ");
+			token = COM_ParseExt( &p, qtrue );	//looking for action commands or final }
+		}
+		species->ColorCount++;	//next color please
+	}
+	return qtrue;//never get here
+}
+
+/*
+=================
+UI_BuildPlayerModel_List
+=================
+*/
+static void UI_BuildPlayerModel_List( qboolean inGameLoad )
+{
+	int		numdirs;
+	char	dirlist[2048];
+	char*	dirptr;
+	int		dirlen;
+	int		i;
+	int		j;
+
+
+	uiInfo.playerSpeciesCount = 0;
+	uiInfo.playerSpeciesIndex = 0;
+	memset(uiInfo.playerSpecies, 0, sizeof (uiInfo.playerSpecies) );
+
+	// iterate directory of all player models
+	numdirs = trap_FS_GetFileList("models/players", "/", dirlist, 2048 );
+	dirptr  = dirlist;
+	for (i=0; i<numdirs; i++,dirptr+=dirlen+1)
+	{
+		char	filelist[2048];
+		char*	fileptr;
+		int		filelen;
+		int f = 0;
+		char fpath[2048];
+
+		dirlen = strlen(dirptr);
+		
+		if (dirlen)
+		{
+			if (dirptr[dirlen-1]=='/')
+				dirptr[dirlen-1]='\0';
+		}
+		else
+		{
+			continue;
+		}
+
+		if (!strcmp(dirptr,".") || !strcmp(dirptr,".."))
+			continue;
+			
+		Com_sprintf(fpath, 2048, "models/players/%s/PlayerChoice.txt", dirptr);
+		filelen = trap_FS_FOpenFile(fpath, &f, FS_READ);
+
+		if (f)
+		{ 
+			char buffer[2048];
+			char	skinname[64];
+			int		numfiles;
+			int		iSkinParts=0;
+
+			trap_FS_Read(&buffer, filelen, f);
+			trap_FS_FCloseFile(f);
+			buffer[filelen] = 0;	//ensure trailing NULL
+
+			//record this species
+			Q_strncpyz( uiInfo.playerSpecies[uiInfo.playerSpeciesCount].Name, dirptr, sizeof(uiInfo.playerSpecies[0].Name) );
+
+			if (!UI_ParseColorData(buffer,&uiInfo.playerSpecies[uiInfo.playerSpeciesCount],fpath))
+			{
+				Com_Printf(S_COLOR_RED"UI_BuildPlayerModel_List: Errors parsing '%s'\n", fpath);
+			}
+
+			numfiles = trap_FS_GetFileList( va("models/players/%s",dirptr), ".skin", filelist, 2048 );
+			fileptr  = filelist;
+			for (j=0; j<numfiles; j++,fileptr+=filelen+1)
+			{
+				if (trap_Cvar_VariableValue("fs_copyfiles") > 0 )
+				{
+					trap_FS_FOpenFile(va("models/players/%s/%s",dirptr,fileptr), &f, FS_READ);
+					if (f) trap_FS_FCloseFile(f);
+				}
+
+				filelen = strlen(fileptr);
+				COM_StripExtension(fileptr,skinname);
+
+				if (bIsImageFile(dirptr, skinname))
+				{ //if it exists
+					if (strnicmp(skinname,"head_",5) == 0)
+					{
+						if (uiInfo.playerSpecies[uiInfo.playerSpeciesCount].SkinHeadCount < MAX_PLAYERMODELS) 
+						{
+							Q_strncpyz(
+								uiInfo.playerSpecies[uiInfo.playerSpeciesCount].SkinHeadNames[uiInfo.playerSpecies[uiInfo.playerSpeciesCount].SkinHeadCount++], 
+								skinname, 
+								sizeof(uiInfo.playerSpecies[0].SkinHeadNames[0])
+								);
+							iSkinParts |= 1<<0;
+						}
+					} else
+					if (strnicmp(skinname,"torso_",6) == 0)
+					{
+						if (uiInfo.playerSpecies[uiInfo.playerSpeciesCount].SkinTorsoCount < MAX_PLAYERMODELS) 
+						{
+							Q_strncpyz(uiInfo.playerSpecies[uiInfo.playerSpeciesCount].SkinTorsoNames[uiInfo.playerSpecies[uiInfo.playerSpeciesCount].SkinTorsoCount++], 
+								skinname, 
+								sizeof(uiInfo.playerSpecies[0].SkinTorsoNames[0])
+								);
+							iSkinParts |= 1<<1;
+						}
+					} else
+					if (strnicmp(skinname,"lower_",6) == 0)
+					{
+						if (uiInfo.playerSpecies[uiInfo.playerSpeciesCount].SkinLegCount < MAX_PLAYERMODELS) 
+						{
+							Q_strncpyz(uiInfo.playerSpecies[uiInfo.playerSpeciesCount].SkinLegNames[uiInfo.playerSpecies[uiInfo.playerSpeciesCount].SkinLegCount++], 
+								skinname, 
+								sizeof(uiInfo.playerSpecies[0].SkinLegNames[0]) 
+								);
+								iSkinParts |= 1<<2;
+						}
+					}
+					
+				}
+			}
+			if (iSkinParts != 7)
+			{	//didn't get a skin for each, then skip this model.
+				memset(&uiInfo.playerSpecies[uiInfo.playerSpeciesCount], 0, sizeof(uiInfo.playerSpecies[uiInfo.playerSpeciesCount]));//undo the colors
+				continue;
+			}
+			uiInfo.playerSpeciesCount++;
+			if (!inGameLoad && ui_PrecacheModels.integer)
+			{
+				int g2Model;
+				void *ghoul2 = 0;
+				Com_sprintf( fpath, sizeof( fpath ), "models/players/%s/model.glm", dirptr );
+				g2Model = trap_G2API_InitGhoul2Model(&ghoul2, fpath, 0, 0, 0, 0, 0);
+				if (g2Model >= 0)
+				{
+//					trap_G2API_RemoveGhoul2Model( &ghoul2, 0 );
+					trap_G2API_CleanGhoul2Models (&ghoul2);
+				}
+			}
+			if (uiInfo.playerSpeciesCount >= MAX_PLAYERMODELS)
+			{
+				return;
+			}
+		}
+	}	
+
+}
+
+/*
+=================
+UI_Init
+=================
+*/
+void _UI_Init( qboolean inGameLoad ) {
+	const char *menuSet;
+	int start;
+
+	//register this freakin thing now
+	vmCvar_t siegeTeamSwitch;
+	trap_Cvar_Register(&siegeTeamSwitch, "g_siegeTeamSwitch", "1", CVAR_SERVERINFO|CVAR_ARCHIVE);
+
+	// Get the list of possible languages
+	uiInfo.languageCount = trap_SP_GetNumLanguages();	// this does a dir scan, so use carefully
+
+	uiInfo.inGameLoad = inGameLoad;
+
+	//initialize all these cvars to "0"
+	UI_SiegeSetCvarsForClass(NULL);
+
+	UI_SiegeInit();
+
+	UI_UpdateForcePowers();
+
+	UI_RegisterCvars();
+	UI_InitMemory();
+
+	// cache redundant calulations
+	trap_GetGlconfig( &uiInfo.uiDC.glconfig );
+
+	// for 640x480 virtualized screen
+	uiInfo.uiDC.yscale = uiInfo.uiDC.glconfig.vidHeight * (1.0/480.0);
+	uiInfo.uiDC.xscale = uiInfo.uiDC.glconfig.vidWidth * (1.0/640.0);
+	if ( uiInfo.uiDC.glconfig.vidWidth * 480 > uiInfo.uiDC.glconfig.vidHeight * 640 ) {
+		// wide screen
+		uiInfo.uiDC.bias = 0.5 * ( uiInfo.uiDC.glconfig.vidWidth - ( uiInfo.uiDC.glconfig.vidHeight * (640.0/480.0) ) );
+	}
+	else {
+		// no wide screen
+		uiInfo.uiDC.bias = 0;
+	}
+
+
+  //UI_Load();
+	uiInfo.uiDC.registerShaderNoMip = &trap_R_RegisterShaderNoMip;
+	uiInfo.uiDC.setColor = &UI_SetColor;
+	uiInfo.uiDC.drawHandlePic = &UI_DrawHandlePic;
+	uiInfo.uiDC.drawStretchPic = &trap_R_DrawStretchPic;
+	uiInfo.uiDC.drawText = &Text_Paint;
+	uiInfo.uiDC.textWidth = &Text_Width;
+	uiInfo.uiDC.textHeight = &Text_Height;
+	uiInfo.uiDC.registerModel = &trap_R_RegisterModel;
+	uiInfo.uiDC.modelBounds = &trap_R_ModelBounds;
+	uiInfo.uiDC.fillRect = &UI_FillRect;
+	uiInfo.uiDC.drawRect = &_UI_DrawRect;
+	uiInfo.uiDC.drawSides = &_UI_DrawSides;
+	uiInfo.uiDC.drawTopBottom = &_UI_DrawTopBottom;
+	uiInfo.uiDC.clearScene = &trap_R_ClearScene;
+	uiInfo.uiDC.drawSides = &_UI_DrawSides;
+	uiInfo.uiDC.addRefEntityToScene = &trap_R_AddRefEntityToScene;
+	uiInfo.uiDC.renderScene = &trap_R_RenderScene;
+	uiInfo.uiDC.RegisterFont = &trap_R_RegisterFont;
+	uiInfo.uiDC.Font_StrLenPixels = trap_R_Font_StrLenPixels;
+	uiInfo.uiDC.Font_StrLenChars = trap_R_Font_StrLenChars;
+	uiInfo.uiDC.Font_HeightPixels = trap_R_Font_HeightPixels;
+	uiInfo.uiDC.Font_DrawString = trap_R_Font_DrawString;
+	uiInfo.uiDC.Language_IsAsian = trap_Language_IsAsian;
+	uiInfo.uiDC.Language_UsesSpaces = trap_Language_UsesSpaces;
+	uiInfo.uiDC.AnyLanguage_ReadCharFromString = trap_AnyLanguage_ReadCharFromString;
+	uiInfo.uiDC.ownerDrawItem = &UI_OwnerDraw;
+	uiInfo.uiDC.getValue = &UI_GetValue;
+	uiInfo.uiDC.ownerDrawVisible = &UI_OwnerDrawVisible;
+	uiInfo.uiDC.runScript = &UI_RunMenuScript;
+	uiInfo.uiDC.deferScript = &UI_DeferMenuScript;
+	uiInfo.uiDC.getTeamColor = &UI_GetTeamColor;
+	uiInfo.uiDC.setCVar = trap_Cvar_Set;
+	uiInfo.uiDC.getCVarString = trap_Cvar_VariableStringBuffer;
+	uiInfo.uiDC.getCVarValue = trap_Cvar_VariableValue;
+	uiInfo.uiDC.drawTextWithCursor = &Text_PaintWithCursor;
+	uiInfo.uiDC.setOverstrikeMode = &trap_Key_SetOverstrikeMode;
+	uiInfo.uiDC.getOverstrikeMode = &trap_Key_GetOverstrikeMode;
+	uiInfo.uiDC.startLocalSound = &trap_S_StartLocalSound;
+	uiInfo.uiDC.ownerDrawHandleKey = &UI_OwnerDrawHandleKey;
+	uiInfo.uiDC.feederCount = &UI_FeederCount;
+	uiInfo.uiDC.feederItemImage = &UI_FeederItemImage;
+	uiInfo.uiDC.feederItemText = &UI_FeederItemText;
+	uiInfo.uiDC.feederSelection = &UI_FeederSelection;
+	uiInfo.uiDC.setBinding = &trap_Key_SetBinding;
+	uiInfo.uiDC.getBindingBuf = &trap_Key_GetBindingBuf;
+	uiInfo.uiDC.keynumToStringBuf = &trap_Key_KeynumToStringBuf;
+	uiInfo.uiDC.executeText = &trap_Cmd_ExecuteText;
+	uiInfo.uiDC.Error = &Com_Error; 
+	uiInfo.uiDC.Print = &Com_Printf; 
+	uiInfo.uiDC.Pause = &UI_Pause;
+	uiInfo.uiDC.ownerDrawWidth = &UI_OwnerDrawWidth;
+	uiInfo.uiDC.registerSound = &trap_S_RegisterSound;
+	uiInfo.uiDC.startBackgroundTrack = &trap_S_StartBackgroundTrack;
+	uiInfo.uiDC.stopBackgroundTrack = &trap_S_StopBackgroundTrack;
+	uiInfo.uiDC.playCinematic = &UI_PlayCinematic;
+	uiInfo.uiDC.stopCinematic = &UI_StopCinematic;
+	uiInfo.uiDC.drawCinematic = &UI_DrawCinematic;
+	uiInfo.uiDC.runCinematicFrame = &UI_RunCinematicFrame;
+
+	Init_Display(&uiInfo.uiDC);
+
+	UI_BuildPlayerModel_List(inGameLoad);
+
+	String_Init();
+  
+	uiInfo.uiDC.cursor	= trap_R_RegisterShaderNoMip( "menu/art/3_cursor2" );
+	uiInfo.uiDC.whiteShader = trap_R_RegisterShaderNoMip( "white" );
+
+	AssetCache();
+
+	start = trap_Milliseconds();
+
+  uiInfo.teamCount = 0;
+  uiInfo.characterCount = 0;
+  uiInfo.aliasCount = 0;
+
+	UI_ParseGameInfo("ui/jamp/gameinfo.txt");
+
+	menuSet = UI_Cvar_VariableString("ui_menuFilesMP");
+	if (menuSet == NULL || menuSet[0] == '\0') {
+		menuSet = "ui/jampmenus.txt";
+	}
+
+#if 1
+	if (inGameLoad)
+	{
+		UI_LoadMenus("ui/jampingame.txt", qtrue);
+	}
+	else if (!ui_bypassMainMenuLoad.integer)
+	{
+		UI_LoadMenus(menuSet, qtrue);
+	}
+#else //this was adding quite a giant amount of time to the load time
+	UI_LoadMenus(menuSet, qtrue);
+	UI_LoadMenus("ui/jampingame.txt", qtrue);
+#endif
+	
+	trap_Cvar_Register(NULL, "ui_name", UI_Cvar_VariableString("name"), CVAR_INTERNAL );	//get this now, jic the menus change again trying to setName before getName
+
+	Menus_CloseAll();
+
+	trap_LAN_LoadCachedServers();
+	UI_LoadBestScores(uiInfo.mapList[ui_currentMap.integer].mapLoadName, uiInfo.gameTypes[ui_gameType.integer].gtEnum);
+
+	UI_BuildQ3Model_List();
+	UI_LoadBots();
+
+	UI_LoadForceConfig_List();
+
+	UI_InitForceShaders();
+
+	// sets defaults for ui temp cvars
+	uiInfo.effectsColor = /*gamecodetoui[*/(int)trap_Cvar_VariableValue("color1");//-1];
+	uiInfo.currentCrosshair = (int)trap_Cvar_VariableValue("cg_drawCrosshair");
+	trap_Cvar_Set("ui_mousePitch", (trap_Cvar_VariableValue("m_pitch") >= 0) ? "0" : "1");
+	trap_Cvar_Set("ui_mousePitchVeh", (trap_Cvar_VariableValue("m_pitchVeh") >= 0) ? "0" : "1");
+
+	uiInfo.serverStatus.currentServerCinematic = -1;
+	uiInfo.previewMovie = -1;
+
+	trap_Cvar_Register(NULL, "debug_protocol", "", 0 );
+
+	trap_Cvar_Set("ui_actualNetGameType", va("%d", ui_netGameType.integer));
+}
+
+#ifdef _XBOX
+#include "../namespace_begin.h"
+extern void UpdateDemoTimer();
+#include "../namespace_end.h"
+#endif
+
+/*
+=================
+UI_KeyEvent
+=================
+*/
+void _UI_KeyEvent( int key, qboolean down ) {
+
+  if (Menu_Count() > 0) {
+    menuDef_t *menu = Menu_GetFocused();
+		if (menu) {
+//JLF
+#ifdef _XBOX
+
+			UpdateDemoTimer();
+
+#endif
+			if (key == A_ESCAPE && down && !Menus_AnyFullScreenVisible()) {
+				Menus_CloseAll();
+			} else {
+				Menu_HandleKey(menu, key, down );
+			}
+		} else {
+			trap_Key_SetCatcher( trap_Key_GetCatcher() & ~KEYCATCH_UI );
+			trap_Key_ClearStates();
+			trap_Cvar_Set( "cl_paused", "0" );
+		}
+  }
+
+  //if ((s > 0) && (s != menu_null_sound)) {
+	//  trap_S_StartLocalSound( s, CHAN_LOCAL_SOUND );
+  //}
+}
+
+
+/*
+=================
+UI_MouseEvent
+=================
+*/
+void _UI_MouseEvent( int dx, int dy )
+{
+	// update mouse screen position
+	uiInfo.uiDC.cursorx += dx;
+	if (uiInfo.uiDC.cursorx < 0)
+		uiInfo.uiDC.cursorx = 0;
+	else if (uiInfo.uiDC.cursorx > SCREEN_WIDTH)
+		uiInfo.uiDC.cursorx = SCREEN_WIDTH;
+
+	uiInfo.uiDC.cursory += dy;
+	if (uiInfo.uiDC.cursory < 0)
+		uiInfo.uiDC.cursory = 0;
+	else if (uiInfo.uiDC.cursory > SCREEN_HEIGHT)
+		uiInfo.uiDC.cursory = SCREEN_HEIGHT;
+
+  if (Menu_Count() > 0) {
+    //menuDef_t *menu = Menu_GetFocused();
+    //Menu_HandleMouseMove(menu, uiInfo.uiDC.cursorx, uiInfo.uiDC.cursory);
+		Display_MouseMove(NULL, uiInfo.uiDC.cursorx, uiInfo.uiDC.cursory);
+  }
+
+}
+
+void UI_LoadNonIngame() {
+	const char *menuSet = UI_Cvar_VariableString("ui_menuFilesMP");
+	if (menuSet == NULL || menuSet[0] == '\0') {
+		menuSet = "ui/jampmenus.txt";
+	}
+	UI_LoadMenus(menuSet, qfalse);
+	uiInfo.inGameLoad = qfalse;
+}
+
+void _UI_SetActiveMenu( uiMenuCommand_t menu ) {
+	char buf[256];
+
+	// this should be the ONLY way the menu system is brought up
+	// enusure minumum menu data is cached
+  if (Menu_Count() > 0) {
+		vec3_t v;
+		v[0] = v[1] = v[2] = 0;
+	  switch ( menu ) {
+	  case UIMENU_NONE:
+			trap_Key_SetCatcher( trap_Key_GetCatcher() & ~KEYCATCH_UI );
+			trap_Key_ClearStates();
+			trap_Cvar_Set( "cl_paused", "0" );
+			Menus_CloseAll();
+
+		  return;
+	  case UIMENU_MAIN:
+		{
+			qboolean active = qfalse;
+
+			//trap_Cvar_Set( "sv_killserver", "1" );
+			trap_Key_SetCatcher( KEYCATCH_UI );
+			//trap_S_StartLocalSound( trap_S_RegisterSound("sound/misc/menu_background.wav", qfalse) , CHAN_LOCAL_SOUND );
+			//trap_S_StartBackgroundTrack("sound/misc/menu_background.wav", NULL);
+			if (uiInfo.inGameLoad) 
+			{
+//				UI_LoadNonIngame();
+			}
+			
+			Menus_CloseAll();
+			Menus_ActivateByName("main");
+			trap_Cvar_VariableStringBuffer("com_errorMessage", buf, sizeof(buf));
+			
+			if (buf[0]) 
+			{
+				if (!ui_singlePlayerActive.integer) 
+				{
+#ifdef _XBOX
+					// Display Xbox popups after an ERR_DROP?
+					UI_xboxErrorPopup( XB_POPUP_COM_ERROR );
+#else
+					Menus_ActivateByName("error_popmenu");
+#endif
+					active = qtrue;
+				} 
+				else 
+				{
+					trap_Cvar_Set("com_errorMessage", "");
+				}
+			}
+			return;
+		}
+
+	  case UIMENU_TEAM:
+			trap_Key_SetCatcher( KEYCATCH_UI );
+      Menus_ActivateByName("team");
+		  return;
+	  case UIMENU_POSTGAME:
+			//trap_Cvar_Set( "sv_killserver", "1" );
+			trap_Key_SetCatcher( KEYCATCH_UI );
+			if (uiInfo.inGameLoad) {
+//				UI_LoadNonIngame();
+			}
+			Menus_CloseAll();
+			Menus_ActivateByName("endofgame");
+		  //UI_ConfirmMenu( "Bad CD Key", NULL, NeedCDKeyAction );
+		  return;
+	  case UIMENU_INGAME:
+		  trap_Cvar_Set( "cl_paused", "1" );
+			trap_Key_SetCatcher( KEYCATCH_UI );
+			UI_BuildPlayerList();
+			Menus_CloseAll();
+			Menus_ActivateByName("ingame");
+		  return;
+	  case UIMENU_PLAYERCONFIG:
+		 // trap_Cvar_Set( "cl_paused", "1" );
+			trap_Key_SetCatcher( KEYCATCH_UI );
+			UI_BuildPlayerList();
+			Menus_CloseAll();
+			Menus_ActivateByName("ingame_player");
+			UpdateForceUsed();
+		  return;
+	  case UIMENU_PLAYERFORCE:
+		 // trap_Cvar_Set( "cl_paused", "1" );
+			trap_Key_SetCatcher( KEYCATCH_UI );
+			UI_BuildPlayerList();
+			Menus_CloseAll();
+			Menus_ActivateByName("ingame_playerforce");
+			UpdateForceUsed();
+		  return;
+	  case UIMENU_SIEGEMESSAGE:
+		 // trap_Cvar_Set( "cl_paused", "1" );
+			trap_Key_SetCatcher( KEYCATCH_UI );
+			Menus_CloseAll();
+			Menus_ActivateByName("siege_popmenu");
+		  return;
+	  case UIMENU_SIEGEOBJECTIVES:
+		 // trap_Cvar_Set( "cl_paused", "1" );
+			trap_Key_SetCatcher( KEYCATCH_UI );
+			Menus_CloseAll();
+			Menus_ActivateByName("ingame_siegeobjectives");
+			return;
+	  case UIMENU_VOICECHAT:
+		 // trap_Cvar_Set( "cl_paused", "1" );
+			// No chatin non-siege games.
+		 
+		  	if (trap_Cvar_VariableValue( "g_gametype" ) < GT_TEAM)
+			{
+				return;
+			}
+				 
+			trap_Key_SetCatcher( KEYCATCH_UI );
+			Menus_CloseAll();
+			Menus_ActivateByName("ingame_voicechat");
+			return;
+	  case UIMENU_CLOSEALL:
+			Menus_CloseAll();
+			return;
+	  case UIMENU_CLASSSEL:
+			trap_Key_SetCatcher( KEYCATCH_UI );
+			Menus_CloseAll();
+			Menus_ActivateByName("ingame_siegeclass");
+		  return;
+	  }
+  }
+}
+
+qboolean _UI_IsFullscreen( void ) {
+	return Menus_AnyFullScreenVisible();
+}
+
+
+
+static connstate_t	lastConnState;
+static char			lastLoadingText[MAX_INFO_VALUE];
+
+static void UI_ReadableSize ( char *buf, int bufsize, int value )
+{
+	if (value > 1024*1024*1024 ) { // gigs
+		Com_sprintf( buf, bufsize, "%d", value / (1024*1024*1024) );
+		Com_sprintf( buf+strlen(buf), bufsize-strlen(buf), ".%02d GB", 
+			(value % (1024*1024*1024))*100 / (1024*1024*1024) );
+	} else if (value > 1024*1024 ) { // megs
+		Com_sprintf( buf, bufsize, "%d", value / (1024*1024) );
+		Com_sprintf( buf+strlen(buf), bufsize-strlen(buf), ".%02d MB", 
+			(value % (1024*1024))*100 / (1024*1024) );
+	} else if (value > 1024 ) { // kilos
+		Com_sprintf( buf, bufsize, "%d KB", value / 1024 );
+	} else { // bytes
+		Com_sprintf( buf, bufsize, "%d bytes", value );
+	}
+}
+
+// Assumes time is in msec
+static void UI_PrintTime ( char *buf, int bufsize, int time ) {
+	time /= 1000;  // change to seconds
+
+	if (time > 3600) { // in the hours range
+		Com_sprintf( buf, bufsize, "%d hr %2d min", time / 3600, (time % 3600) / 60 );
+	} else if (time > 60) { // mins
+		Com_sprintf( buf, bufsize, "%2d min %2d sec", time / 60, time % 60 );
+	} else  { // secs
+		Com_sprintf( buf, bufsize, "%2d sec", time );
+	}
+}
+
+void Text_PaintCenter(float x, float y, float scale, vec4_t color, const char *text, float adjust, int iMenuFont) {
+	int len = Text_Width(text, scale, iMenuFont);
+	Text_Paint(x - len / 2, y, scale, color, text, 0, 0, ITEM_TEXTSTYLE_SHADOWEDMORE, iMenuFont);
+}
+
+
+static void UI_DisplayDownloadInfo( const char *downloadName, float centerPoint, float yStart, float scale, int iMenuFont) {
+	char sDownLoading[256];
+	char sEstimatedTimeLeft[256];
+	char sTransferRate[256];
+	char sOf[20];
+	char sCopied[256];
+	char sSec[20];
+	//
+	int downloadSize, downloadCount, downloadTime;
+	char dlSizeBuf[64], totalSizeBuf[64], xferRateBuf[64], dlTimeBuf[64];
+	int xferRate;
+	int leftWidth;
+	const char *s;
+
+	vec4_t colorLtGreyAlpha = {0, 0, 0, .5};
+
+	UI_FillRect( 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, colorLtGreyAlpha );
+
+	s = GetCRDelineatedString("MENUS","DOWNLOAD_STUFF", 0);	// "Downloading:"
+	strcpy(sDownLoading,s?s:"");
+	s = GetCRDelineatedString("MENUS","DOWNLOAD_STUFF", 1);	// "Estimated time left:"
+	strcpy(sEstimatedTimeLeft,s?s:"");
+	s = GetCRDelineatedString("MENUS","DOWNLOAD_STUFF", 2);	// "Transfer rate:"
+	strcpy(sTransferRate,s?s:"");
+	s = GetCRDelineatedString("MENUS","DOWNLOAD_STUFF", 3);	// "of"
+	strcpy(sOf,s?s:"");
+	s = GetCRDelineatedString("MENUS","DOWNLOAD_STUFF", 4);	// "copied"
+	strcpy(sCopied,s?s:"");
+	s = GetCRDelineatedString("MENUS","DOWNLOAD_STUFF", 5);	// "sec."
+	strcpy(sSec,s?s:"");
+
+	downloadSize = trap_Cvar_VariableValue( "cl_downloadSize" );
+	downloadCount = trap_Cvar_VariableValue( "cl_downloadCount" );
+	downloadTime = trap_Cvar_VariableValue( "cl_downloadTime" );
+
+	leftWidth = 320;
+
+	UI_SetColor(colorWhite);
+
+	Text_PaintCenter(centerPoint, yStart + 112, scale, colorWhite, sDownLoading, 0, iMenuFont);
+	Text_PaintCenter(centerPoint, yStart + 192, scale, colorWhite, sEstimatedTimeLeft, 0, iMenuFont);
+	Text_PaintCenter(centerPoint, yStart + 248, scale, colorWhite, sTransferRate, 0, iMenuFont);
+
+	if (downloadSize > 0) {
+		s = va( "%s (%d%%)", downloadName, downloadCount * 100 / downloadSize );
+	} else {
+		s = downloadName;
+	}
+
+	Text_PaintCenter(centerPoint, yStart+136, scale, colorWhite, s, 0, iMenuFont);
+
+	UI_ReadableSize( dlSizeBuf,		sizeof dlSizeBuf,		downloadCount );
+	UI_ReadableSize( totalSizeBuf,	sizeof totalSizeBuf,	downloadSize );
+
+	if (downloadCount < 4096 || !downloadTime) {
+		Text_PaintCenter(leftWidth, yStart+216, scale, colorWhite, "estimating", 0, iMenuFont);
+		Text_PaintCenter(leftWidth, yStart+160, scale, colorWhite, va("(%s %s %s %s)", dlSizeBuf, sOf, totalSizeBuf, sCopied), 0, iMenuFont);
+	} else {
+		if ((uiInfo.uiDC.realTime - downloadTime) / 1000) {
+			xferRate = downloadCount / ((uiInfo.uiDC.realTime - downloadTime) / 1000);
+		} else {
+			xferRate = 0;
+		}
+		UI_ReadableSize( xferRateBuf, sizeof xferRateBuf, xferRate );
+
+		// Extrapolate estimated completion time
+		if (downloadSize && xferRate) {
+			int n = downloadSize / xferRate; // estimated time for entire d/l in secs
+
+			// We do it in K (/1024) because we'd overflow around 4MB
+			UI_PrintTime ( dlTimeBuf, sizeof dlTimeBuf, 
+				(n - (((downloadCount/1024) * n) / (downloadSize/1024))) * 1000);
+
+			Text_PaintCenter(leftWidth, yStart+216, scale, colorWhite, dlTimeBuf, 0, iMenuFont);
+			Text_PaintCenter(leftWidth, yStart+160, scale, colorWhite, va("(%s %s %s %s)", dlSizeBuf, sOf, totalSizeBuf, sCopied), 0, iMenuFont);
+		} else {
+			Text_PaintCenter(leftWidth, yStart+216, scale, colorWhite, "estimating", 0, iMenuFont);
+			if (downloadSize) {
+				Text_PaintCenter(leftWidth, yStart+160, scale, colorWhite, va("(%s %s %s %s)", dlSizeBuf, sOf, totalSizeBuf, sCopied), 0, iMenuFont);
+			} else {
+				Text_PaintCenter(leftWidth, yStart+160, scale, colorWhite, va("(%s %s)", dlSizeBuf, sCopied), 0, iMenuFont);
+			}
+		}
+
+		if (xferRate) {
+			Text_PaintCenter(leftWidth, yStart+272, scale, colorWhite, va("%s/%s", xferRateBuf,sSec), 0, iMenuFont);
+		}
+	}
+}
+
+/*
+========================
+UI_DrawConnectScreen
+
+This will also be overlaid on the cgame info screen during loading
+to prevent it from blinking away too rapidly on local or lan games.
+========================
+*/
+void UI_DrawConnectScreen( qboolean overlay ) {
+	const char *s;
+	uiClientState_t	cstate;
+	char			info[MAX_INFO_VALUE];
+	char text[256];
+	float centerPoint, yStart, scale;
+
+	char sStringEdTemp[256];
+
+	menuDef_t *menu = Menus_FindByName("Connect");
+
+
+	if ( !overlay && menu ) {
+		Menu_Paint(menu, qtrue);
+	}
+
+	if (!overlay) {
+		centerPoint = 320;
+		yStart = 130;
+		scale = 1.0f;	// -ste
+	} else {
+		centerPoint = 320;
+		yStart = 32;
+		scale = 1.0f;	// -ste
+		return;
+	}
+
+	// see what information we should display
+	trap_GetClientState( &cstate );
+
+
+	info[0] = '\0';
+	if( trap_GetConfigString( CS_SERVERINFO, info, sizeof(info) ) ) {
+		trap_SP_GetStringTextString("MENUS_LOADING_MAPNAME", sStringEdTemp, sizeof(sStringEdTemp));
+		Text_PaintCenter(centerPoint, yStart, scale, colorWhite, va( /*"Loading %s"*/sStringEdTemp, Info_ValueForKey( info, "mapname" )), 0, FONT_MEDIUM);
+	}
+
+	if (!Q_stricmp(cstate.servername,"localhost")) {
+		trap_SP_GetStringTextString("MENUS_STARTING_UP", sStringEdTemp, sizeof(sStringEdTemp));
+		Text_PaintCenter(centerPoint, yStart + 48, scale, colorWhite, sStringEdTemp, ITEM_TEXTSTYLE_SHADOWEDMORE, FONT_MEDIUM);
+	} else {
+		trap_SP_GetStringTextString("MENUS_CONNECTING_TO", sStringEdTemp, sizeof(sStringEdTemp));
+		strcpy(text, va(/*"Connecting to %s"*/sStringEdTemp, cstate.servername));
+		Text_PaintCenter(centerPoint, yStart + 48, scale, colorWhite,text , ITEM_TEXTSTYLE_SHADOWEDMORE, FONT_MEDIUM);
+	}
+
+	//UI_DrawProportionalString( 320, 96, "Press Esc to abort", UI_CENTER|UI_SMALLFONT|UI_DROPSHADOW, menu_text_color );
+
+	// display global MOTD at bottom
+	Text_PaintCenter(centerPoint, 425, scale, colorWhite, Info_ValueForKey( cstate.updateInfoString, "motd" ), 0, FONT_MEDIUM);
+	// print any server info (server full, bad version, etc)
+	if ( cstate.connState < CA_CONNECTED ) {
+		Text_PaintCenter(centerPoint, yStart + 176, scale, colorWhite, cstate.messageString, 0, FONT_MEDIUM);
+	}
+
+	if ( lastConnState > cstate.connState ) {
+		lastLoadingText[0] = '\0';
+	}
+	lastConnState = cstate.connState;
+
+	switch ( cstate.connState ) {
+	case CA_CONNECTING:
+		{
+			trap_SP_GetStringTextString("MENUS_AWAITING_CONNECTION", sStringEdTemp, sizeof(sStringEdTemp));
+			s = va(/*"Awaiting connection...%i"*/sStringEdTemp, cstate.connectPacketCount);
+		}
+		break;
+	case CA_CHALLENGING:
+		{
+			trap_SP_GetStringTextString("MENUS_AWAITING_CHALLENGE", sStringEdTemp, sizeof(sStringEdTemp));
+			s = va(/*"Awaiting challenge...%i"*/sStringEdTemp, cstate.connectPacketCount);
+		}
+		break;
+	case CA_CONNECTED: {
+		char downloadName[MAX_INFO_VALUE];
+
+			trap_Cvar_VariableStringBuffer( "cl_downloadName", downloadName, sizeof(downloadName) );
+			if (*downloadName) {
+				UI_DisplayDownloadInfo( downloadName, centerPoint, yStart, scale, FONT_MEDIUM );
+				return;
+			}
+		}
+		trap_SP_GetStringTextString("MENUS_AWAITING_GAMESTATE", sStringEdTemp, sizeof(sStringEdTemp));
+		s = /*"Awaiting gamestate..."*/sStringEdTemp;
+		break;
+	case CA_LOADING:
+		return;
+	case CA_PRIMED:
+		return;
+	default:
+		return;
+	}
+
+	if (Q_stricmp(cstate.servername,"localhost")) {
+		Text_PaintCenter(centerPoint, yStart + 80, scale, colorWhite, s, 0, FONT_MEDIUM);
+	}
+	// password required / connection rejected information goes here
+}
+
+
+/*
+================
+cvars
+================
+*/
+
+typedef struct {
+	vmCvar_t	*vmCvar;
+	char		*cvarName;
+	char		*defaultString;
+	int			cvarFlags;
+} cvarTable_t;
+
+vmCvar_t	ui_ffa_fraglimit;
+vmCvar_t	ui_ffa_timelimit;
+
+vmCvar_t	ui_tourney_fraglimit;
+vmCvar_t	ui_tourney_timelimit;
+
+vmCvar_t	ui_selectedModelIndex;
+vmCvar_t	ui_char_model;
+vmCvar_t	ui_char_skin_head;
+vmCvar_t	ui_char_skin_torso;
+vmCvar_t	ui_char_skin_legs;
+
+vmCvar_t	ui_saber_type;
+vmCvar_t	ui_saber;
+vmCvar_t	ui_saber2;
+vmCvar_t	ui_saber_color;
+vmCvar_t	ui_saber2_color;
+
+vmCvar_t	ui_team_fraglimit;
+vmCvar_t	ui_team_timelimit;
+vmCvar_t	ui_team_friendly;
+
+vmCvar_t	ui_ctf_capturelimit;
+vmCvar_t	ui_ctf_timelimit;
+vmCvar_t	ui_ctf_friendly;
+
+vmCvar_t	ui_arenasFile;
+vmCvar_t	ui_botsFile;
+vmCvar_t	ui_spSkill;
+
+vmCvar_t	ui_browserMaster;
+vmCvar_t	ui_browserGameType;
+vmCvar_t	ui_browserSortKey;
+vmCvar_t	ui_browserShowFull;
+vmCvar_t	ui_browserShowEmpty;
+
+vmCvar_t	ui_drawCrosshair;
+vmCvar_t	ui_drawCrosshairNames;
+vmCvar_t	ui_marks;
+
+vmCvar_t	ui_server1;
+vmCvar_t	ui_server2;
+vmCvar_t	ui_server3;
+vmCvar_t	ui_server4;
+vmCvar_t	ui_server5;
+vmCvar_t	ui_server6;
+vmCvar_t	ui_server7;
+vmCvar_t	ui_server8;
+vmCvar_t	ui_server9;
+vmCvar_t	ui_server10;
+vmCvar_t	ui_server11;
+vmCvar_t	ui_server12;
+vmCvar_t	ui_server13;
+vmCvar_t	ui_server14;
+vmCvar_t	ui_server15;
+vmCvar_t	ui_server16;
+
+vmCvar_t	ui_redteam;
+vmCvar_t	ui_redteam1;
+vmCvar_t	ui_redteam2;
+vmCvar_t	ui_redteam3;
+vmCvar_t	ui_redteam4;
+vmCvar_t	ui_redteam5;
+vmCvar_t	ui_redteam6;
+vmCvar_t	ui_redteam7;
+vmCvar_t	ui_redteam8;
+vmCvar_t	ui_blueteam;
+vmCvar_t	ui_blueteam1;
+vmCvar_t	ui_blueteam2;
+vmCvar_t	ui_blueteam3;
+vmCvar_t	ui_blueteam4;
+vmCvar_t	ui_blueteam5;
+vmCvar_t	ui_blueteam6;
+vmCvar_t	ui_blueteam7;
+vmCvar_t	ui_blueteam8;
+vmCvar_t	ui_teamName;
+vmCvar_t	ui_dedicated;
+vmCvar_t	ui_gameType;
+vmCvar_t	ui_netGameType;
+vmCvar_t	ui_actualNetGameType;
+vmCvar_t	ui_joinGameType;
+#ifdef _XBOX
+vmCvar_t	ui_optiGameType;
+vmCvar_t	ui_optiCurrentMap;
+vmCvar_t	ui_optiMinPlayers;
+vmCvar_t	ui_optiMaxPlayers;
+vmCvar_t	ui_optiFriendlyFire;
+vmCvar_t	ui_optiJediMastery;
+vmCvar_t	ui_optiSaberOnly;
+#endif
+vmCvar_t	ui_netSource;
+vmCvar_t	ui_serverFilterType;
+vmCvar_t	ui_opponentName;
+vmCvar_t	ui_menuFiles;
+vmCvar_t	ui_currentMap;
+vmCvar_t	ui_currentNetMap;
+vmCvar_t	ui_mapIndex;
+vmCvar_t	ui_currentOpponent;
+vmCvar_t	ui_selectedPlayer;
+vmCvar_t	ui_selectedPlayerName;
+vmCvar_t	ui_lastServerRefresh_0;
+vmCvar_t	ui_lastServerRefresh_1;
+vmCvar_t	ui_lastServerRefresh_2;
+vmCvar_t	ui_lastServerRefresh_3;
+vmCvar_t	ui_singlePlayerActive;
+vmCvar_t	ui_scoreAccuracy;
+vmCvar_t	ui_scoreImpressives;
+vmCvar_t	ui_scoreExcellents;
+vmCvar_t	ui_scoreCaptures;
+vmCvar_t	ui_scoreDefends;
+vmCvar_t	ui_scoreAssists;
+vmCvar_t	ui_scoreGauntlets;
+vmCvar_t	ui_scoreScore;
+vmCvar_t	ui_scorePerfect;
+vmCvar_t	ui_scoreTeam;
+vmCvar_t	ui_scoreBase;
+vmCvar_t	ui_scoreTimeBonus;
+vmCvar_t	ui_scoreSkillBonus;
+vmCvar_t	ui_scoreShutoutBonus;
+vmCvar_t	ui_scoreTime;
+vmCvar_t	ui_captureLimit;
+vmCvar_t	ui_fragLimit;
+vmCvar_t	ui_findPlayer;
+vmCvar_t	ui_hudFiles;
+vmCvar_t	ui_recordSPDemo;
+vmCvar_t	ui_realCaptureLimit;
+vmCvar_t	ui_realWarmUp;
+vmCvar_t	ui_serverStatusTimeOut;
+vmCvar_t	se_language;
+
+vmCvar_t	ui_bypassMainMenuLoad;
+
+// bk001129 - made static to avoid aliasing
+static cvarTable_t		cvarTable[] = {
+	{ &ui_ffa_fraglimit, "ui_ffa_fraglimit", "20", CVAR_ARCHIVE|CVAR_INTERNAL },
+	{ &ui_ffa_timelimit, "ui_ffa_timelimit", "0", CVAR_ARCHIVE|CVAR_INTERNAL },
+
+	{ &ui_tourney_fraglimit, "ui_tourney_fraglimit", "0", CVAR_ARCHIVE|CVAR_INTERNAL },
+	{ &ui_tourney_timelimit, "ui_tourney_timelimit", "15", CVAR_ARCHIVE|CVAR_INTERNAL },
+
+	{ &ui_selectedModelIndex, "ui_selectedModelIndex", "16", CVAR_ARCHIVE|CVAR_INTERNAL },
+
+	{ &ui_char_model,			"ui_char_model",		"jedi_tf",CVAR_ROM|CVAR_INTERNAL},
+	{ &ui_char_skin_head,		"ui_char_skin_head",	"head_a1",CVAR_ROM|CVAR_INTERNAL},
+	{ &ui_char_skin_torso,		"ui_char_skin_torso",	"torso_a1",CVAR_ROM|CVAR_INTERNAL}, 
+	{ &ui_char_skin_legs,		"ui_char_skin_legs",	"lower_a1",CVAR_ROM|CVAR_INTERNAL}, 
+
+	{ &ui_char_anim,			"ui_char_anim",			"BOTH_WALK1",CVAR_ROM|CVAR_INTERNAL}, 
+
+	{ &ui_saber_type,			"ui_saber_type",		"single",CVAR_ROM|CVAR_INTERNAL},
+	{ &ui_saber,				"ui_saber",				"single_1",CVAR_ROM|CVAR_INTERNAL}, 
+	{ &ui_saber2,				"ui_saber2",			"none",CVAR_ROM|CVAR_INTERNAL}, 
+	{ &ui_saber_color,			"ui_saber_color",		"yellow",CVAR_ROM|CVAR_INTERNAL},
+	{ &ui_saber2_color,			"ui_saber2_color",		"yellow",CVAR_ROM|CVAR_INTERNAL},
+
+	{ &ui_char_color_red,		"ui_char_color_red",	"255", CVAR_ROM|CVAR_INTERNAL}, 
+	{ &ui_char_color_green,		"ui_char_color_green",	"255", CVAR_ROM|CVAR_INTERNAL}, 
+	{ &ui_char_color_blue,		"ui_char_color_blue",	"255", CVAR_ROM|CVAR_INTERNAL}, 
+
+	{ &ui_PrecacheModels,		"ui_PrecacheModels",	"0", CVAR_ARCHIVE}, 
+
+	{ &ui_team_fraglimit, "ui_team_fraglimit", "0", CVAR_ARCHIVE|CVAR_INTERNAL },
+	{ &ui_team_timelimit, "ui_team_timelimit", "20", CVAR_ARCHIVE|CVAR_INTERNAL },
+	{ &ui_team_friendly, "ui_team_friendly",  "1", CVAR_ARCHIVE|CVAR_INTERNAL },
+
+	{ &ui_ctf_capturelimit, "ui_ctf_capturelimit", "8", CVAR_ARCHIVE|CVAR_INTERNAL },
+	{ &ui_ctf_timelimit, "ui_ctf_timelimit", "30", CVAR_ARCHIVE|CVAR_INTERNAL },
+	{ &ui_ctf_friendly, "ui_ctf_friendly",  "0", CVAR_ARCHIVE|CVAR_INTERNAL },
+
+	{ &ui_botsFile, "g_botsFile", "", CVAR_INIT|CVAR_ROM },
+	{ &ui_spSkill, "g_spSkill", "2", CVAR_ARCHIVE|CVAR_INTERNAL },
+
+	{ &ui_browserMaster, "ui_browserMaster", "0", CVAR_ARCHIVE|CVAR_INTERNAL },
+	{ &ui_browserGameType, "ui_browserGameType", "0", CVAR_ARCHIVE|CVAR_INTERNAL },
+	{ &ui_browserSortKey, "ui_browserSortKey", "4", CVAR_ARCHIVE|CVAR_INTERNAL },
+	{ &ui_browserShowFull, "ui_browserShowFull", "1", CVAR_ARCHIVE|CVAR_INTERNAL },
+	{ &ui_browserShowEmpty, "ui_browserShowEmpty", "1", CVAR_ARCHIVE|CVAR_INTERNAL },
+
+	{ &ui_drawCrosshair, "cg_drawCrosshair", "1", CVAR_ARCHIVE|CVAR_INTERNAL },
+	{ &ui_drawCrosshairNames, "cg_drawCrosshairNames", "1", CVAR_ARCHIVE|CVAR_INTERNAL },
+	{ &ui_marks, "cg_marks", "1", CVAR_ARCHIVE|CVAR_INTERNAL },
+
+	{ &ui_server1, "server1", "", CVAR_ARCHIVE|CVAR_INTERNAL },
+	{ &ui_server2, "server2", "", CVAR_ARCHIVE|CVAR_INTERNAL },
+	{ &ui_server3, "server3", "", CVAR_ARCHIVE|CVAR_INTERNAL },
+	{ &ui_server4, "server4", "", CVAR_ARCHIVE|CVAR_INTERNAL },
+	{ &ui_server5, "server5", "", CVAR_ARCHIVE|CVAR_INTERNAL },
+	{ &ui_server6, "server6", "", CVAR_ARCHIVE|CVAR_INTERNAL },
+	{ &ui_server7, "server7", "", CVAR_ARCHIVE|CVAR_INTERNAL },
+	{ &ui_server8, "server8", "", CVAR_ARCHIVE|CVAR_INTERNAL },
+	{ &ui_server9, "server9", "", CVAR_ARCHIVE|CVAR_INTERNAL },
+	{ &ui_server10, "server10", "", CVAR_ARCHIVE|CVAR_INTERNAL },
+	{ &ui_server11, "server11", "", CVAR_ARCHIVE|CVAR_INTERNAL },
+	{ &ui_server12, "server12", "", CVAR_ARCHIVE|CVAR_INTERNAL },
+	{ &ui_server13, "server13", "", CVAR_ARCHIVE|CVAR_INTERNAL },
+	{ &ui_server14, "server14", "", CVAR_ARCHIVE|CVAR_INTERNAL },
+	{ &ui_server15, "server15", "", CVAR_ARCHIVE|CVAR_INTERNAL },
+	{ &ui_server16, "server16", "", CVAR_ARCHIVE|CVAR_INTERNAL },
+	{ &ui_debug, "ui_debug", "0", CVAR_TEMP|CVAR_INTERNAL },
+	{ &ui_initialized, "ui_initialized", "0", CVAR_TEMP|CVAR_INTERNAL },
+	{ &ui_teamName, "ui_teamName", "Empire", CVAR_ARCHIVE|CVAR_INTERNAL },
+	{ &ui_opponentName, "ui_opponentName", "Rebellion", CVAR_ARCHIVE|CVAR_INTERNAL },
+	{ &ui_rankChange, "ui_rankChange", "0", CVAR_ARCHIVE|CVAR_INTERNAL },
+	{ &ui_freeSaber, "ui_freeSaber", "0", CVAR_ARCHIVE|CVAR_INTERNAL },
+	{ &ui_forcePowerDisable, "ui_forcePowerDisable", "0", CVAR_ARCHIVE|CVAR_INTERNAL },
+	{ &ui_redteam, "ui_redteam", "Empire", CVAR_ARCHIVE|CVAR_INTERNAL },
+	{ &ui_blueteam, "ui_blueteam", "Rebellion", CVAR_ARCHIVE|CVAR_INTERNAL },
+	{ &ui_dedicated, "ui_dedicated", "0", CVAR_ARCHIVE|CVAR_INTERNAL },
+	{ &ui_gameType, "ui_gametype", "0", CVAR_ARCHIVE|CVAR_INTERNAL },
+	{ &ui_joinGameType, "ui_joinGametype", "0", CVAR_ARCHIVE|CVAR_INTERNAL },
+	{ &ui_netGameType, "ui_netGametype", "0", CVAR_ARCHIVE|CVAR_INTERNAL },
+	{ &ui_actualNetGameType, "ui_actualNetGametype", "3", CVAR_ARCHIVE|CVAR_INTERNAL },
+#ifdef _XBOX
+	{ &ui_optiGameType, "ui_optiGameType", "0", CVAR_ARCHIVE },
+	{ &ui_optiCurrentMap, "ui_optiCurrentMap", "0", CVAR_ARCHIVE },
+	{ &ui_optiMinPlayers, "ui_optiMinPlayers", "0", CVAR_ARCHIVE },
+	{ &ui_optiMaxPlayers, "ui_optiMaxPlayers", "0", CVAR_ARCHIVE },
+	{ &ui_optiFriendlyFire, "ui_optiFriendlyFire", "0", CVAR_ARCHIVE },
+	{ &ui_optiJediMastery, "ui_optiJediMastery", "0", CVAR_ARCHIVE },
+	{ &ui_optiSaberOnly, "ui_optiSaberOnly", "0", CVAR_ARCHIVE },
+#endif
+	{ &ui_redteam1, "ui_redteam1", "1", CVAR_ARCHIVE|CVAR_INTERNAL }, //rww - these used to all default to 0 (closed).. I changed them to 1 (human)
+	{ &ui_redteam2, "ui_redteam2", "1", CVAR_ARCHIVE|CVAR_INTERNAL },
+	{ &ui_redteam3, "ui_redteam3", "1", CVAR_ARCHIVE|CVAR_INTERNAL },
+	{ &ui_redteam4, "ui_redteam4", "1", CVAR_ARCHIVE|CVAR_INTERNAL },
+	{ &ui_redteam5, "ui_redteam5", "1", CVAR_ARCHIVE|CVAR_INTERNAL },
+	{ &ui_redteam6, "ui_redteam6", "1", CVAR_ARCHIVE|CVAR_INTERNAL },
+	{ &ui_redteam7, "ui_redteam7", "1", CVAR_ARCHIVE|CVAR_INTERNAL },
+	{ &ui_redteam8, "ui_redteam8", "1", CVAR_ARCHIVE|CVAR_INTERNAL },
+	{ &ui_blueteam1, "ui_blueteam1", "1", CVAR_ARCHIVE|CVAR_INTERNAL },
+	{ &ui_blueteam2, "ui_blueteam2", "1", CVAR_ARCHIVE|CVAR_INTERNAL },
+	{ &ui_blueteam3, "ui_blueteam3", "1", CVAR_ARCHIVE|CVAR_INTERNAL },
+	{ &ui_blueteam4, "ui_blueteam4", "1", CVAR_ARCHIVE|CVAR_INTERNAL },
+	{ &ui_blueteam5, "ui_blueteam5", "1", CVAR_ARCHIVE|CVAR_INTERNAL },
+	{ &ui_blueteam6, "ui_blueteam6", "1", CVAR_ARCHIVE|CVAR_INTERNAL },
+	{ &ui_blueteam7, "ui_blueteam7", "1", CVAR_ARCHIVE|CVAR_INTERNAL },
+	{ &ui_blueteam8, "ui_blueteam8", "1", CVAR_ARCHIVE|CVAR_INTERNAL },
+	{ &ui_netSource, "ui_netSource", "0", CVAR_ARCHIVE|CVAR_INTERNAL },
+	{ &ui_menuFiles, "ui_menuFilesMP", "ui/jampmenus.txt", CVAR_ARCHIVE|CVAR_INTERNAL },
+	{ &ui_currentMap, "ui_currentMap", "0", CVAR_ARCHIVE|CVAR_INTERNAL },
+	{ &ui_currentNetMap, "ui_currentNetMap", "0", CVAR_ARCHIVE|CVAR_INTERNAL },
+	{ &ui_mapIndex, "ui_mapIndex", "0", CVAR_ARCHIVE|CVAR_INTERNAL },
+	{ &ui_currentOpponent, "ui_currentOpponent", "0", CVAR_ARCHIVE|CVAR_INTERNAL },
+	{ &ui_selectedPlayer, "cg_selectedPlayer", "0", CVAR_ARCHIVE|CVAR_INTERNAL},
+	{ &ui_selectedPlayerName, "cg_selectedPlayerName", "", CVAR_ARCHIVE|CVAR_INTERNAL},
+	{ &ui_lastServerRefresh_0, "ui_lastServerRefresh_0", "", CVAR_ARCHIVE|CVAR_INTERNAL},
+	{ &ui_lastServerRefresh_1, "ui_lastServerRefresh_1", "", CVAR_ARCHIVE|CVAR_INTERNAL},
+	{ &ui_lastServerRefresh_2, "ui_lastServerRefresh_2", "", CVAR_ARCHIVE|CVAR_INTERNAL},
+	{ &ui_lastServerRefresh_3, "ui_lastServerRefresh_3", "", CVAR_ARCHIVE|CVAR_INTERNAL},
+	{ &ui_singlePlayerActive, "ui_singlePlayerActive", "0", CVAR_INTERNAL},
+	{ &ui_scoreAccuracy, "ui_scoreAccuracy", "0", CVAR_ARCHIVE|CVAR_INTERNAL},
+	{ &ui_scoreImpressives, "ui_scoreImpressives", "0", CVAR_ARCHIVE|CVAR_INTERNAL},
+	{ &ui_scoreExcellents, "ui_scoreExcellents", "0", CVAR_ARCHIVE|CVAR_INTERNAL},
+	{ &ui_scoreCaptures, "ui_scoreCaptures", "0", CVAR_ARCHIVE|CVAR_INTERNAL},
+	{ &ui_scoreDefends, "ui_scoreDefends", "0", CVAR_ARCHIVE|CVAR_INTERNAL},
+	{ &ui_scoreAssists, "ui_scoreAssists", "0", CVAR_ARCHIVE|CVAR_INTERNAL},
+	{ &ui_scoreGauntlets, "ui_scoreGauntlets", "0",CVAR_ARCHIVE|CVAR_INTERNAL},
+	{ &ui_scoreScore, "ui_scoreScore", "0", CVAR_ARCHIVE|CVAR_INTERNAL},
+	{ &ui_scorePerfect, "ui_scorePerfect", "0", CVAR_ARCHIVE|CVAR_INTERNAL},
+	{ &ui_scoreTeam, "ui_scoreTeam", "0 to 0", CVAR_ARCHIVE|CVAR_INTERNAL},
+	{ &ui_scoreBase, "ui_scoreBase", "0", CVAR_ARCHIVE|CVAR_INTERNAL},
+	{ &ui_scoreTime, "ui_scoreTime", "00:00", CVAR_ARCHIVE|CVAR_INTERNAL},
+	{ &ui_scoreTimeBonus, "ui_scoreTimeBonus", "0", CVAR_ARCHIVE|CVAR_INTERNAL},
+	{ &ui_scoreSkillBonus, "ui_scoreSkillBonus", "0", CVAR_ARCHIVE|CVAR_INTERNAL},
+	{ &ui_scoreShutoutBonus, "ui_scoreShutoutBonus", "0", CVAR_ARCHIVE|CVAR_INTERNAL},
+	{ &ui_fragLimit, "ui_fragLimit", "10", CVAR_INTERNAL},
+	{ &ui_captureLimit, "ui_captureLimit", "5", CVAR_INTERNAL},
+	{ &ui_findPlayer, "ui_findPlayer", "Kyle", CVAR_ARCHIVE|CVAR_INTERNAL},
+	{ &ui_recordSPDemo, "ui_recordSPDemo", "0", CVAR_ARCHIVE|CVAR_INTERNAL},
+	{ &ui_realWarmUp, "g_warmup", "20", CVAR_ARCHIVE|CVAR_INTERNAL},
+	{ &ui_realCaptureLimit, "capturelimit", "8", CVAR_SERVERINFO | CVAR_ARCHIVE| CVAR_INTERNAL | CVAR_NORESTART},
+	{ &ui_serverStatusTimeOut, "ui_serverStatusTimeOut", "7000", CVAR_ARCHIVE|CVAR_INTERNAL},
+	{ &se_language, "se_language","english", CVAR_ARCHIVE | CVAR_NORESTART},	//text (string ed)
+
+	{ &ui_bypassMainMenuLoad, "ui_bypassMainMenuLoad", "0", CVAR_INTERNAL },
+//JLFCALLOUT
+#ifdef _XBOX
+	{ &ui_hideAcallout,		"ui_hideAcallout",	"", 0}, 
+	{ &ui_hideBcallout,		"ui_hideBcallout",	"", 0}, 
+	{ &ui_hideXcallout,		"ui_hideXcallout",	"", 0}, 
+#endif
+//END JLFCALLOUT
+};
+
+// bk001129 - made static to avoid aliasing
+static int		cvarTableSize = sizeof(cvarTable) / sizeof(cvarTable[0]);
+
+
+/*
+=================
+UI_RegisterCvars
+=================
+*/
+void UI_RegisterCvars( void ) {
+	int			i;
+	cvarTable_t	*cv;
+
+	for ( i = 0, cv = cvarTable ; i < cvarTableSize ; i++, cv++ ) {
+		trap_Cvar_Register( cv->vmCvar, cv->cvarName, cv->defaultString, cv->cvarFlags );
+	}
+}
+
+/*
+=================
+UI_UpdateCvars
+=================
+*/
+void UI_UpdateCvars( void ) {
+	int			i;
+	cvarTable_t	*cv;
+
+	for ( i = 0, cv = cvarTable ; i < cvarTableSize ; i++, cv++ ) {
+		trap_Cvar_Update( cv->vmCvar );
+	}
+}
+
+
+/*
+=================
+ArenaServers_StopRefresh
+=================
+*/
+static void UI_StopServerRefresh( void )
+{
+	int count;
+
+	if (!uiInfo.serverStatus.refreshActive) {
+		// not currently refreshing
+		return;
+	}
+	uiInfo.serverStatus.refreshActive = qfalse;
+	Com_Printf("%d servers listed in browser with %d players.\n",
+					uiInfo.serverStatus.numDisplayServers,
+					uiInfo.serverStatus.numPlayersOnServers);
+	count = trap_LAN_GetServerCount(ui_netSource.integer);
+	if (count - uiInfo.serverStatus.numDisplayServers > 0) {
+		Com_Printf("%d servers not listed due to packet loss or pings higher than %d\n",
+						count - uiInfo.serverStatus.numDisplayServers,
+						(int) trap_Cvar_VariableValue("cl_maxPing"));
+	}
+
+}
+
+
+/*
+=================
+UI_DoServerRefresh
+=================
+*/
+static void UI_DoServerRefresh( void )
+{
+	qboolean wait = qfalse;
+
+	if (!uiInfo.serverStatus.refreshActive) {
+		return;
+	}
+	if (ui_netSource.integer != AS_FAVORITES) {
+		if (ui_netSource.integer == AS_LOCAL) {
+			if (!trap_LAN_GetServerCount(ui_netSource.integer)) {
+				wait = qtrue;
+			}
+		} else {
+			if (trap_LAN_GetServerCount(ui_netSource.integer) < 0) {
+				wait = qtrue;
+			}
+		}
+	}
+
+	if (uiInfo.uiDC.realTime < uiInfo.serverStatus.refreshtime) {
+		if (wait) {
+			return;
+		}
+	}
+
+	// if still trying to retrieve pings
+	if (trap_LAN_UpdateVisiblePings(ui_netSource.integer)) {
+		uiInfo.serverStatus.refreshtime = uiInfo.uiDC.realTime + 1000;
+	} else if (!wait) {
+		// get the last servers in the list
+		UI_BuildServerDisplayList(2);
+		// stop the refresh
+		UI_StopServerRefresh();
+	}
+	//
+	UI_BuildServerDisplayList(qfalse);
+}
+
+/*
+=================
+UI_StartServerRefresh
+=================
+*/
+static void UI_StartServerRefresh(qboolean full)
+{
+	int		i;
+	char	*ptr;
+
+	qtime_t q;
+	trap_RealTime(&q);
+ 	trap_Cvar_Set( va("ui_lastServerRefresh_%i", ui_netSource.integer), va("%s-%i, %i @ %i:%2i", GetMonthAbbrevString(q.tm_mon),q.tm_mday, 1900+q.tm_year,q.tm_hour,q.tm_min));
+
+	if (!full) {
+		UI_UpdatePendingPings();
+		return;
+	}
+
+	uiInfo.serverStatus.refreshActive = qtrue;
+	uiInfo.serverStatus.nextDisplayRefresh = uiInfo.uiDC.realTime + 1000;
+	// clear number of displayed servers
+	uiInfo.serverStatus.numDisplayServers = 0;
+	uiInfo.serverStatus.numPlayersOnServers = 0;
+	// mark all servers as visible so we store ping updates for them
+	trap_LAN_MarkServerVisible(ui_netSource.integer, -1, qtrue);
+	// reset all the pings
+	trap_LAN_ResetPings(ui_netSource.integer);
+	//
+	if( ui_netSource.integer == AS_LOCAL ) {
+		trap_Cmd_ExecuteText( EXEC_NOW, "localservers\n" );
+		uiInfo.serverStatus.refreshtime = uiInfo.uiDC.realTime + 1000;
+		return;
+	}
+
+	uiInfo.serverStatus.refreshtime = uiInfo.uiDC.realTime + 5000;
+#ifndef _XBOX	// Optimatch is handled elsewhere
+	if( ui_netSource.integer == AS_GLOBAL || ui_netSource.integer == AS_MPLAYER ) {
+		if( ui_netSource.integer == AS_GLOBAL ) {
+			i = 0;
+		}
+		else {
+			i = 1;
+		}
+
+		ptr = UI_Cvar_VariableString("debug_protocol");
+		if (strlen(ptr)) {
+			trap_Cmd_ExecuteText( EXEC_NOW, va( "globalservers %d %s\n", i, ptr));
+		}
+		else {
+			trap_Cmd_ExecuteText( EXEC_NOW, va( "globalservers %d %d\n", i, (int)trap_Cvar_VariableValue( "protocol" ) ) );
+		}
+	}
+#endif
+}
+
diff --git a/codemp/ui/ui_players.c b/codemp/ui/ui_players.c
new file mode 100644
index 0000000..5111460
--- /dev/null
+++ b/codemp/ui/ui_players.c
@@ -0,0 +1,1338 @@
+// Copyright (C) 1999-2000 Id Software, Inc.
+//
+// ui_players.c
+
+#include "ui_local.h"
+
+
+#define UI_TIMER_GESTURE		2300
+#define UI_TIMER_JUMP			1000
+#define UI_TIMER_LAND			130
+#define UI_TIMER_WEAPON_SWITCH	300
+#define UI_TIMER_ATTACK			500
+#define	UI_TIMER_MUZZLE_FLASH	20
+#define	UI_TIMER_WEAPON_DELAY	250
+
+#define JUMP_HEIGHT				56
+
+#define SWINGSPEED				0.3f
+
+#define SPIN_SPEED				0.9f
+#define COAST_TIME				1000
+
+
+static int			dp_realtime;
+static float		jumpHeight;
+sfxHandle_t weaponChangeSound;
+
+
+/*
+===============
+UI_PlayerInfo_SetWeapon
+===============
+*/
+static void UI_PlayerInfo_SetWeapon( playerInfo_t *pi, weapon_t weaponNum ) {
+	gitem_t *	item;
+	char		path[MAX_QPATH];
+
+	pi->currentWeapon = weaponNum;
+tryagain:
+	pi->realWeapon = weaponNum;
+	pi->weaponModel = 0;
+	pi->barrelModel = 0;
+	pi->flashModel = 0;
+
+	if ( weaponNum == WP_NONE ) {
+		return;
+	}
+
+	for ( item = bg_itemlist + 1; item->classname ; item++ ) {
+		if ( item->giType != IT_WEAPON ) {
+			continue;
+		}
+		if ( item->giTag == weaponNum ) {
+			break;
+		}
+	}
+
+	if ( item->classname ) {
+		pi->weaponModel = trap_R_RegisterModel( item->world_model[0] );
+	}
+
+	if( pi->weaponModel == 0 ) {
+		if( weaponNum == WP_BRYAR_PISTOL ) {
+			weaponNum = WP_NONE;
+			goto tryagain;
+		}
+		weaponNum = WP_BRYAR_PISTOL;
+		goto tryagain;
+	}
+/*
+	if ( weaponNum == WP_MACHINEGUN || weaponNum == WP_BFG ) {
+		strcpy( path, item->world_model[0] );
+		COM_StripExtension( path, path );
+		strcat( path, "_barrel.md3" );
+		pi->barrelModel = trap_R_RegisterModel( path );
+	}
+*/
+	strcpy( path, item->world_model[0] );
+	COM_StripExtension( path, path );
+	strcat( path, "_flash.md3" );
+	pi->flashModel = trap_R_RegisterModel( path );
+
+	switch( weaponNum ) {
+	case WP_STUN_BATON:
+	case WP_SABER:
+		MAKERGB( pi->flashDlightColor, 0.6f, 0.6f, 1 );
+		break;
+
+	case WP_BRYAR_PISTOL:
+	case WP_BLASTER:
+	case WP_DISRUPTOR:
+	case WP_BOWCASTER:
+	case WP_REPEATER:
+	case WP_DEMP2:
+	case WP_FLECHETTE:
+	case WP_ROCKET_LAUNCHER:
+	case WP_THERMAL:
+	case WP_TRIP_MINE:
+	case WP_DET_PACK:
+		MAKERGB( pi->flashDlightColor, 1, 1, 0 );
+		break;
+
+	default:
+		MAKERGB( pi->flashDlightColor, 1, 1, 1 );
+		break;
+	}
+}
+
+
+/*
+===============
+UI_ForceLegsAnim
+===============
+*/
+static void UI_ForceLegsAnim( playerInfo_t *pi, int anim ) {
+	pi->legsAnim = ( ( pi->legsAnim & ANIM_TOGGLEBIT ) ^ ANIM_TOGGLEBIT ) | anim;
+
+	if ( anim == BOTH_JUMP1 ) {
+		pi->legsAnimationTimer = UI_TIMER_JUMP;
+	}
+}
+
+
+/*
+===============
+UI_SetLegsAnim
+===============
+*/
+static void UI_SetLegsAnim( playerInfo_t *pi, int anim ) {
+	if ( pi->pendingLegsAnim ) {
+		anim = pi->pendingLegsAnim;
+		pi->pendingLegsAnim = 0;
+	}
+	UI_ForceLegsAnim( pi, anim );
+}
+
+
+/*
+===============
+UI_ForceTorsoAnim
+===============
+*/
+static void UI_ForceTorsoAnim( playerInfo_t *pi, int anim ) {
+	pi->torsoAnim = ( ( pi->torsoAnim & ANIM_TOGGLEBIT ) ^ ANIM_TOGGLEBIT ) | anim;
+
+	if ( anim == BOTH_GESTURE1 ) {
+		pi->torsoAnimationTimer = UI_TIMER_GESTURE;
+	}
+
+	if ( anim == BOTH_ATTACK3 || anim == BOTH_A1_T__B_ ) {
+		pi->torsoAnimationTimer = UI_TIMER_ATTACK;
+	}
+}
+
+
+/*
+===============
+UI_SetTorsoAnim
+===============
+*/
+static void UI_SetTorsoAnim( playerInfo_t *pi, int anim ) {
+	if ( pi->pendingTorsoAnim ) {
+		anim = pi->pendingTorsoAnim;
+		pi->pendingTorsoAnim = 0;
+	}
+
+	UI_ForceTorsoAnim( pi, anim );
+}
+
+
+/*
+===============
+UI_TorsoSequencing
+===============
+*/
+static void UI_TorsoSequencing( playerInfo_t *pi ) {
+	int		currentAnim;
+
+	currentAnim = pi->torsoAnim & ~ANIM_TOGGLEBIT;
+
+	if ( pi->weapon != pi->currentWeapon ) {
+		if ( currentAnim != TORSO_DROPWEAP1 ) {
+			pi->torsoAnimationTimer = UI_TIMER_WEAPON_SWITCH;
+			UI_ForceTorsoAnim( pi, TORSO_DROPWEAP1 );
+		}
+	}
+
+	if ( pi->torsoAnimationTimer > 0 ) {
+		return;
+	}
+
+	if( currentAnim == BOTH_GESTURE1 ) {
+		UI_SetTorsoAnim( pi, TORSO_WEAPONREADY3 );
+		return;
+	}
+
+	if( currentAnim == BOTH_ATTACK3 || currentAnim == BOTH_A1_T__B_ ) {
+		UI_SetTorsoAnim( pi, TORSO_WEAPONREADY3 );
+		return;
+	}
+
+	if ( currentAnim == TORSO_DROPWEAP1 ) {
+		UI_PlayerInfo_SetWeapon( pi, pi->weapon );
+		pi->torsoAnimationTimer = UI_TIMER_WEAPON_SWITCH;
+		UI_ForceTorsoAnim( pi, TORSO_RAISEWEAP1 );
+		return;
+	}
+
+	if ( currentAnim == TORSO_RAISEWEAP1 ) {
+		UI_SetTorsoAnim( pi, TORSO_WEAPONREADY3 );
+		return;
+	}
+}
+
+
+/*
+===============
+UI_LegsSequencing
+===============
+*/
+static void UI_LegsSequencing( playerInfo_t *pi ) {
+	int		currentAnim;
+
+	currentAnim = pi->legsAnim & ~ANIM_TOGGLEBIT;
+
+	if ( pi->legsAnimationTimer > 0 ) {
+		if ( currentAnim == BOTH_JUMP1 ) {
+			jumpHeight = JUMP_HEIGHT * sin( M_PI * ( UI_TIMER_JUMP - pi->legsAnimationTimer ) / UI_TIMER_JUMP );
+		}
+		return;
+	}
+
+	if ( currentAnim == BOTH_JUMP1 ) {
+		UI_ForceLegsAnim( pi, BOTH_LAND1 );
+		pi->legsAnimationTimer = UI_TIMER_LAND;
+		jumpHeight = 0;
+		return;
+	}
+
+	if ( currentAnim == BOTH_LAND1 ) {
+		UI_SetLegsAnim( pi, TORSO_WEAPONREADY3 );
+		return;
+	}
+}
+
+
+/*
+======================
+UI_PositionEntityOnTag
+======================
+*/
+static void UI_PositionEntityOnTag( refEntity_t *entity, const refEntity_t *parent, 
+							clipHandle_t parentModel, char *tagName ) {
+	int				i;
+	orientation_t	lerped;
+	
+	// lerp the tag
+	trap_CM_LerpTag( &lerped, parentModel, parent->oldframe, parent->frame,
+		1.0 - parent->backlerp, tagName );
+
+	// FIXME: allow origin offsets along tag?
+	VectorCopy( parent->origin, entity->origin );
+	for ( i = 0 ; i < 3 ; i++ ) {
+		VectorMA( entity->origin, lerped.origin[i], parent->axis[i], entity->origin );
+	}
+
+	// cast away const because of compiler problems
+	MatrixMultiply( lerped.axis, ((refEntity_t*)parent)->axis, entity->axis );
+	entity->backlerp = parent->backlerp;
+}
+
+
+/*
+======================
+UI_PositionRotatedEntityOnTag
+======================
+*/
+static void UI_PositionRotatedEntityOnTag( refEntity_t *entity, const refEntity_t *parent, 
+							clipHandle_t parentModel, char *tagName ) {
+	int				i;
+	orientation_t	lerped;
+	vec3_t			tempAxis[3];
+
+	// lerp the tag
+	trap_CM_LerpTag( &lerped, parentModel, parent->oldframe, parent->frame,
+		1.0 - parent->backlerp, tagName );
+
+	// FIXME: allow origin offsets along tag?
+	VectorCopy( parent->origin, entity->origin );
+	for ( i = 0 ; i < 3 ; i++ ) {
+		VectorMA( entity->origin, lerped.origin[i], parent->axis[i], entity->origin );
+	}
+
+	// cast away const because of compiler problems
+	MatrixMultiply( entity->axis, ((refEntity_t *)parent)->axis, tempAxis );
+	MatrixMultiply( lerped.axis, tempAxis, entity->axis );
+}
+
+
+/*
+===============
+UI_SetLerpFrameAnimation
+===============
+*/
+static void UI_SetLerpFrameAnimation( playerInfo_t *ci, lerpFrame_t *lf, int newAnimation ) {
+	animation_t	*anim;
+
+	lf->animationNumber = newAnimation;
+	newAnimation &= ~ANIM_TOGGLEBIT;
+
+	if ( newAnimation < 0 || newAnimation >= MAX_ANIMATIONS ) {
+		trap_Error( va("Bad animation number: %i", newAnimation) );
+	}
+
+	anim = &ci->animations[ newAnimation ];
+
+	lf->animation = anim;
+	lf->animationTime = lf->frameTime + anim->initialLerp;
+}
+
+
+/*
+===============
+UI_RunLerpFrame
+===============
+*/
+static void UI_RunLerpFrame( playerInfo_t *ci, lerpFrame_t *lf, int newAnimation ) {
+	int			f;
+	animation_t	*anim;
+
+	// see if the animation sequence is switching
+	if ( newAnimation != lf->animationNumber || !lf->animation ) {
+		UI_SetLerpFrameAnimation( ci, lf, newAnimation );
+	}
+
+	// if we have passed the current frame, move it to
+	// oldFrame and calculate a new frame
+	if ( dp_realtime >= lf->frameTime ) {
+		lf->oldFrame = lf->frame;
+		lf->oldFrameTime = lf->frameTime;
+
+		// get the next frame based on the animation
+		anim = lf->animation;
+		if ( dp_realtime < lf->animationTime ) {
+			lf->frameTime = lf->animationTime;		// initial lerp
+		} else {
+			lf->frameTime = lf->oldFrameTime + anim->frameLerp;
+		}
+		f = ( lf->frameTime - lf->animationTime ) / anim->frameLerp;
+		if ( f >= anim->numFrames ) {
+			f -= anim->numFrames;
+			if ( anim->loopFrames ) {
+				f %= anim->loopFrames;
+				f += anim->numFrames - anim->loopFrames;
+			} else {
+				f = anim->numFrames - 1;
+				// the animation is stuck at the end, so it
+				// can immediately transition to another sequence
+				lf->frameTime = dp_realtime;
+			}
+		}
+		lf->frame = anim->firstFrame + f;
+		if ( dp_realtime > lf->frameTime ) {
+			lf->frameTime = dp_realtime;
+		}
+	}
+
+	if ( lf->frameTime > dp_realtime + 200 ) {
+		lf->frameTime = dp_realtime;
+	}
+
+	if ( lf->oldFrameTime > dp_realtime ) {
+		lf->oldFrameTime = dp_realtime;
+	}
+	// calculate current lerp value
+	if ( lf->frameTime == lf->oldFrameTime ) {
+		lf->backlerp = 0;
+	} else {
+		lf->backlerp = 1.0 - (float)( dp_realtime - lf->oldFrameTime ) / ( lf->frameTime - lf->oldFrameTime );
+	}
+}
+
+
+/*
+===============
+UI_PlayerAnimation
+===============
+*/
+static void UI_PlayerAnimation( playerInfo_t *pi, int *legsOld, int *legs, float *legsBackLerp,
+						int *torsoOld, int *torso, float *torsoBackLerp ) {
+
+	// legs animation
+	pi->legsAnimationTimer -= uiInfo.uiDC.frameTime;
+	if ( pi->legsAnimationTimer < 0 ) {
+		pi->legsAnimationTimer = 0;
+	}
+
+	UI_LegsSequencing( pi );
+
+	if ( pi->legs.yawing && ( pi->legsAnim & ~ANIM_TOGGLEBIT ) == TORSO_WEAPONREADY3 ) {
+		UI_RunLerpFrame( pi, &pi->legs, TORSO_WEAPONREADY3 );
+	} else {
+		UI_RunLerpFrame( pi, &pi->legs, pi->legsAnim );
+	}
+	*legsOld = pi->legs.oldFrame;
+	*legs = pi->legs.frame;
+	*legsBackLerp = pi->legs.backlerp;
+
+	// torso animation
+	pi->torsoAnimationTimer -= uiInfo.uiDC.frameTime;
+	if ( pi->torsoAnimationTimer < 0 ) {
+		pi->torsoAnimationTimer = 0;
+	}
+
+	UI_TorsoSequencing( pi );
+
+	UI_RunLerpFrame( pi, &pi->torso, pi->torsoAnim );
+	*torsoOld = pi->torso.oldFrame;
+	*torso = pi->torso.frame;
+	*torsoBackLerp = pi->torso.backlerp;
+}
+
+
+/*
+==================
+UI_SwingAngles
+==================
+*/
+static void UI_SwingAngles( float destination, float swingTolerance, float clampTolerance,
+					float speed, float *angle, qboolean *swinging ) {
+	float	swing;
+	float	move;
+	float	scale;
+
+	if ( !*swinging ) {
+		// see if a swing should be started
+		swing = AngleSubtract( *angle, destination );
+		if ( swing > swingTolerance || swing < -swingTolerance ) {
+			*swinging = qtrue;
+		}
+	}
+
+	if ( !*swinging ) {
+		return;
+	}
+	
+	// modify the speed depending on the delta
+	// so it doesn't seem so linear
+	swing = AngleSubtract( destination, *angle );
+	scale = fabs( swing );
+	if ( scale < swingTolerance * 0.5 ) {
+		scale = 0.5;
+	} else if ( scale < swingTolerance ) {
+		scale = 1.0;
+	} else {
+		scale = 2.0;
+	}
+
+	// swing towards the destination angle
+	if ( swing >= 0 ) {
+		move = uiInfo.uiDC.frameTime * scale * speed;
+		if ( move >= swing ) {
+			move = swing;
+			*swinging = qfalse;
+		}
+		*angle = AngleMod( *angle + move );
+	} else if ( swing < 0 ) {
+		move = uiInfo.uiDC.frameTime * scale * -speed;
+		if ( move <= swing ) {
+			move = swing;
+			*swinging = qfalse;
+		}
+		*angle = AngleMod( *angle + move );
+	}
+
+	// clamp to no more than tolerance
+	swing = AngleSubtract( destination, *angle );
+	if ( swing > clampTolerance ) {
+		*angle = AngleMod( destination - (clampTolerance - 1) );
+	} else if ( swing < -clampTolerance ) {
+		*angle = AngleMod( destination + (clampTolerance - 1) );
+	}
+}
+
+
+/*
+======================
+UI_MovedirAdjustment
+======================
+*/
+static float UI_MovedirAdjustment( playerInfo_t *pi ) {
+	vec3_t		relativeAngles;
+	vec3_t		moveVector;
+
+	VectorSubtract( pi->viewAngles, pi->moveAngles, relativeAngles );
+	AngleVectors( relativeAngles, moveVector, NULL, NULL );
+	if ( Q_fabs( moveVector[0] ) < 0.01 ) {
+		moveVector[0] = 0.0;
+	}
+	if ( Q_fabs( moveVector[1] ) < 0.01 ) {
+		moveVector[1] = 0.0;
+	}
+
+	if ( moveVector[1] == 0 && moveVector[0] > 0 ) {
+		return 0;
+	}
+	if ( moveVector[1] < 0 && moveVector[0] > 0 ) {
+		return 22;
+	}
+	if ( moveVector[1] < 0 && moveVector[0] == 0 ) {
+		return 45;
+	}
+	if ( moveVector[1] < 0 && moveVector[0] < 0 ) {
+		return -22;
+	}
+	if ( moveVector[1] == 0 && moveVector[0] < 0 ) {
+		return 0;
+	}
+	if ( moveVector[1] > 0 && moveVector[0] < 0 ) {
+		return 22;
+	}
+	if ( moveVector[1] > 0 && moveVector[0] == 0 ) {
+		return  -45;
+	}
+
+	return -22;
+}
+
+
+/*
+===============
+UI_PlayerAngles
+===============
+*/
+static void UI_PlayerAngles( playerInfo_t *pi, vec3_t legs[3], vec3_t torso[3], vec3_t head[3] ) {
+	vec3_t		legsAngles, torsoAngles, headAngles;
+	float		dest;
+	float		adjust;
+
+	VectorCopy( pi->viewAngles, headAngles );
+	headAngles[YAW] = AngleMod( headAngles[YAW] );
+	VectorClear( legsAngles );
+	VectorClear( torsoAngles );
+
+	// --------- yaw -------------
+
+	// allow yaw to drift a bit
+	if ( ( pi->legsAnim & ~ANIM_TOGGLEBIT ) != TORSO_WEAPONREADY3
+		|| ( pi->torsoAnim & ~ANIM_TOGGLEBIT ) != TORSO_WEAPONREADY3 ) {
+		// if not standing still, always point all in the same direction
+		pi->torso.yawing = qtrue;	// always center
+		pi->torso.pitching = qtrue;	// always center
+		pi->legs.yawing = qtrue;	// always center
+	}
+
+	// adjust legs for movement dir
+	adjust = UI_MovedirAdjustment( pi );
+	legsAngles[YAW] = headAngles[YAW] + adjust;
+	torsoAngles[YAW] = headAngles[YAW] + 0.25 * adjust;
+
+
+	// torso
+	UI_SwingAngles( torsoAngles[YAW], 25, 90, SWINGSPEED, &pi->torso.yawAngle, &pi->torso.yawing );
+	UI_SwingAngles( legsAngles[YAW], 40, 90, SWINGSPEED, &pi->legs.yawAngle, &pi->legs.yawing );
+
+	torsoAngles[YAW] = pi->torso.yawAngle;
+	legsAngles[YAW] = pi->legs.yawAngle;
+
+	// --------- pitch -------------
+
+	// only show a fraction of the pitch angle in the torso
+	if ( headAngles[PITCH] > 180 ) {
+		dest = (-360 + headAngles[PITCH]) * 0.75;
+	} else {
+		dest = headAngles[PITCH] * 0.75;
+	}
+	UI_SwingAngles( dest, 15, 30, 0.1f, &pi->torso.pitchAngle, &pi->torso.pitching );
+	torsoAngles[PITCH] = pi->torso.pitchAngle;
+
+	// pull the angles back out of the hierarchial chain
+	AnglesSubtract( headAngles, torsoAngles, headAngles );
+	AnglesSubtract( torsoAngles, legsAngles, torsoAngles );
+	AnglesToAxis( legsAngles, legs );
+	AnglesToAxis( torsoAngles, torso );
+	AnglesToAxis( headAngles, head );
+}
+
+
+/*
+===============
+UI_PlayerFloatSprite
+===============
+*/
+static void UI_PlayerFloatSprite( playerInfo_t *pi, vec3_t origin, qhandle_t shader ) {
+	refEntity_t		ent;
+
+	memset( &ent, 0, sizeof( ent ) );
+	VectorCopy( origin, ent.origin );
+	ent.origin[2] += 48;
+	ent.reType = RT_SPRITE;
+	ent.customShader = shader;
+	ent.radius = 10;
+	ent.renderfx = 0;
+	trap_R_AddRefEntityToScene( &ent );
+}
+
+
+/*
+======================
+UI_MachinegunSpinAngle
+======================
+*/
+float	UI_MachinegunSpinAngle( playerInfo_t *pi ) {
+	int		delta;
+	float	angle;
+	float	speed;
+	int		torsoAnim;
+
+	delta = dp_realtime - pi->barrelTime;
+	if ( pi->barrelSpinning ) {
+		angle = pi->barrelAngle + delta * SPIN_SPEED;
+	} else {
+		if ( delta > COAST_TIME ) {
+			delta = COAST_TIME;
+		}
+
+		speed = 0.5 * ( SPIN_SPEED + (float)( COAST_TIME - delta ) / COAST_TIME );
+		angle = pi->barrelAngle + delta * speed;
+	}
+
+	torsoAnim = pi->torsoAnim  & ~ANIM_TOGGLEBIT;
+	if( torsoAnim == BOTH_A1_T__B_ ) {
+		torsoAnim = BOTH_ATTACK3;
+	}
+	if ( pi->barrelSpinning == !(torsoAnim == BOTH_ATTACK3) ) {
+		pi->barrelTime = dp_realtime;
+		pi->barrelAngle = AngleMod( angle );
+		pi->barrelSpinning = !!(torsoAnim == BOTH_ATTACK3);
+	}
+
+	return angle;
+}
+
+
+/*
+===============
+UI_DrawPlayer
+===============
+*/
+void UI_DrawPlayer( float x, float y, float w, float h, playerInfo_t *pi, int time ) {
+	refdef_t		refdef;
+	refEntity_t		legs;
+	refEntity_t		torso;
+	refEntity_t		head;
+	refEntity_t		gun;
+//	refEntity_t		barrel;
+	refEntity_t		flash;
+	vec3_t			origin;
+	int				renderfx;
+	vec3_t			mins = {-16, -16, -24};
+	vec3_t			maxs = {16, 16, 32};
+	float			len;
+	float			xx;
+
+	if ( !pi->legsModel || !pi->torsoModel || !pi->headModel || !pi->animations[0].numFrames ) {
+		return;
+	}
+
+	// this allows the ui to cache the player model on the main menu
+	if (w == 0 || h == 0) {
+		return;
+	}
+
+	dp_realtime = time;
+
+	if ( pi->pendingWeapon != -1 && dp_realtime > pi->weaponTimer ) {
+		pi->weapon = pi->pendingWeapon;
+		pi->lastWeapon = pi->pendingWeapon;
+		pi->pendingWeapon = -1;
+		pi->weaponTimer = 0;
+		if( pi->currentWeapon != pi->weapon ) {
+			trap_S_StartLocalSound( weaponChangeSound, CHAN_LOCAL );
+		}
+	}
+
+	y -= jumpHeight;
+
+	memset( &refdef, 0, sizeof( refdef ) );
+	memset( &legs, 0, sizeof(legs) );
+	memset( &torso, 0, sizeof(torso) );
+	memset( &head, 0, sizeof(head) );
+
+	refdef.rdflags = RDF_NOWORLDMODEL;
+
+	AxisClear( refdef.viewaxis );
+
+	refdef.x = x;
+	refdef.y = y;
+	refdef.width = w;
+	refdef.height = h;
+
+	refdef.fov_x = (int)((float)refdef.width / 640.0f * 90.0f);
+	xx = refdef.width / tan( refdef.fov_x / 360 * M_PI );
+	refdef.fov_y = atan2( refdef.height, xx );
+	refdef.fov_y *= ( 360 / (float)M_PI );
+
+	// calculate distance so the player nearly fills the box
+	len = 0.7 * ( maxs[2] - mins[2] );		
+	origin[0] = len / tan( DEG2RAD(refdef.fov_x) * 0.5 );
+	origin[1] = 0.5 * ( mins[1] + maxs[1] );
+	origin[2] = -0.5 * ( mins[2] + maxs[2] );
+
+	refdef.time = dp_realtime;
+
+	trap_R_ClearScene();
+
+	// get the rotation information
+	UI_PlayerAngles( pi, legs.axis, torso.axis, head.axis );
+	
+	// get the animation state (after rotation, to allow feet shuffle)
+	UI_PlayerAnimation( pi, &legs.oldframe, &legs.frame, &legs.backlerp,
+		 &torso.oldframe, &torso.frame, &torso.backlerp );
+
+	renderfx = RF_LIGHTING_ORIGIN | RF_NOSHADOW;
+
+	//
+	// add the legs
+	//
+	legs.hModel = pi->legsModel;
+	legs.customSkin = pi->legsSkin;
+
+	VectorCopy( origin, legs.origin );
+
+	VectorCopy( origin, legs.lightingOrigin );
+	legs.renderfx = renderfx;
+	VectorCopy (legs.origin, legs.oldorigin);
+
+	trap_R_AddRefEntityToScene( &legs );
+
+	if (!legs.hModel) {
+		return;
+	}
+
+	//
+	// add the torso
+	//
+	torso.hModel = pi->torsoModel;
+	if (!torso.hModel) {
+		return;
+	}
+
+	torso.customSkin = pi->torsoSkin;
+
+	VectorCopy( origin, torso.lightingOrigin );
+
+	UI_PositionRotatedEntityOnTag( &torso, &legs, pi->legsModel, "tag_torso");
+
+	torso.renderfx = renderfx;
+
+	trap_R_AddRefEntityToScene( &torso );
+
+	//
+	// add the head
+	//
+	head.hModel = pi->headModel;
+	if (!head.hModel) {
+		return;
+	}
+	head.customSkin = pi->headSkin;
+
+	VectorCopy( origin, head.lightingOrigin );
+
+	UI_PositionRotatedEntityOnTag( &head, &torso, pi->torsoModel, "tag_head");
+
+	head.renderfx = renderfx;
+
+	trap_R_AddRefEntityToScene( &head );
+
+	//
+	// add the gun
+	//
+	if ( pi->currentWeapon != WP_NONE ) {
+		memset( &gun, 0, sizeof(gun) );
+		gun.hModel = pi->weaponModel;
+		VectorCopy( origin, gun.lightingOrigin );
+		UI_PositionEntityOnTag( &gun, &torso, pi->torsoModel, "tag_weapon");
+		gun.renderfx = renderfx;
+		trap_R_AddRefEntityToScene( &gun );
+	}
+
+	//
+	// add the spinning barrel
+	//
+/*
+	if ( pi->realWeapon == WP_MACHINEGUN || pi->realWeapon == WP_BFG ) {
+		vec3_t	angles;
+
+		memset( &barrel, 0, sizeof(barrel) );
+		VectorCopy( origin, barrel.lightingOrigin );
+		barrel.renderfx = renderfx;
+
+		barrel.hModel = pi->barrelModel;
+		angles[YAW] = 0;
+		angles[PITCH] = 0;
+		angles[ROLL] = UI_MachinegunSpinAngle( pi );
+		if(pi->realWeapon == WP_BFG ) {
+			angles[PITCH] = angles[ROLL];
+			angles[ROLL] = 0;
+		}
+		AnglesToAxis( angles, barrel.axis );
+
+		UI_PositionRotatedEntityOnTag( &barrel, &gun, pi->weaponModel, "tag_barrel");
+
+		trap_R_AddRefEntityToScene( &barrel );
+	}
+*/
+	//
+	// add muzzle flash
+	//
+	if ( dp_realtime <= pi->muzzleFlashTime ) {
+		if ( pi->flashModel ) {
+			memset( &flash, 0, sizeof(flash) );
+			flash.hModel = pi->flashModel;
+			VectorCopy( origin, flash.lightingOrigin );
+			UI_PositionEntityOnTag( &flash, &gun, pi->weaponModel, "tag_flash");
+			flash.renderfx = renderfx;
+			trap_R_AddRefEntityToScene( &flash );
+		}
+
+		// make a dlight for the flash
+		if ( pi->flashDlightColor[0] || pi->flashDlightColor[1] || pi->flashDlightColor[2] ) {
+			trap_R_AddLightToScene( flash.origin, 200 + (rand()&31), pi->flashDlightColor[0],
+				pi->flashDlightColor[1], pi->flashDlightColor[2] );
+		}
+	}
+
+	//
+	// add the chat icon
+	//
+	if ( pi->chat ) {
+		UI_PlayerFloatSprite( pi, origin, trap_R_RegisterShaderNoMip( "sprites/balloon3" ) );
+	}
+
+	//
+	// add an accent light
+	//
+	origin[0] -= 100;	// + = behind, - = in front
+	origin[1] += 100;	// + = left, - = right
+	origin[2] += 100;	// + = above, - = below
+	trap_R_AddLightToScene( origin, 500, 1.0, 1.0, 1.0 );
+
+	origin[0] -= 100;
+	origin[1] -= 100;
+	origin[2] -= 100;
+	trap_R_AddLightToScene( origin, 500, 1.0, 0.0, 0.0 );
+
+	trap_R_RenderScene( &refdef );
+}
+
+/*
+==========================
+UI_FileExists
+==========================
+*/
+static qboolean	UI_FileExists(const char *filename) {
+	int len;
+	fileHandle_t	f;
+
+	len = trap_FS_FOpenFile( filename, &f, FS_READ );
+	if (len>0) {
+		trap_FS_FCloseFile(f);
+		return qtrue;
+	}
+	return qfalse;
+}
+
+/*
+==========================
+UI_FindClientHeadFile
+==========================
+*/
+static qboolean	UI_FindClientHeadFile( char *filename, int length, const char *teamName, const char *headModelName, const char *headSkinName, const char *base, const char *ext ) {
+	char *team, *headsFolder;
+	int i;
+
+	team = "default";
+
+	if ( headModelName[0] == '*' ) {
+		headsFolder = "heads/";
+		headModelName++;
+	}
+	else {
+		headsFolder = "";
+	}
+	while(1) {
+		for ( i = 0; i < 2; i++ ) {
+			if ( i == 0 && teamName && *teamName ) {
+				Com_sprintf( filename, length, "models/players/%s%s/%s/%s%s_%s.%s", headsFolder, headModelName, headSkinName, teamName, base, team, ext );
+			}
+			else {
+				Com_sprintf( filename, length, "models/players/%s%s/%s/%s_%s.%s", headsFolder, headModelName, headSkinName, base, team, ext );
+			}
+			if ( UI_FileExists( filename ) ) {
+				return qtrue;
+			}
+			if ( i == 0 && teamName && *teamName ) {
+				Com_sprintf( filename, length, "models/players/%s%s/%s%s_%s.%s", headsFolder, headModelName, teamName, base, headSkinName, ext );
+			}
+			else {
+				Com_sprintf( filename, length, "models/players/%s%s/%s_%s.%s", headsFolder, headModelName, base, headSkinName, ext );
+			}
+			if ( UI_FileExists( filename ) ) {
+				return qtrue;
+			}
+			if ( !teamName || !*teamName ) {
+				break;
+			}
+		}
+		// if tried the heads folder first
+		if ( headsFolder[0] ) {
+			break;
+		}
+		headsFolder = "heads/";
+	}
+
+	return qfalse;
+}
+
+/*
+==========================
+UI_RegisterClientSkin
+==========================
+*/
+static qboolean	UI_RegisterClientSkin( playerInfo_t *pi, const char *modelName, const char *skinName, const char *headModelName, const char *headSkinName , const char *teamName) {
+	char		filename[MAX_QPATH*2];
+
+	if (teamName && *teamName) {
+		Com_sprintf( filename, sizeof( filename ), "models/players/%s/%s/lower_%s.skin", modelName, teamName, skinName );
+	} else {
+		Com_sprintf( filename, sizeof( filename ), "models/players/%s/lower_%s.skin", modelName, skinName );
+	}
+	pi->legsSkin = trap_R_RegisterSkin( filename );
+	if (!pi->legsSkin) {
+		if (teamName && *teamName) {
+			Com_sprintf( filename, sizeof( filename ), "models/players/characters/%s/%s/lower_%s.skin", modelName, teamName, skinName );
+		} else {
+			Com_sprintf( filename, sizeof( filename ), "models/players/characters/%s/lower_%s.skin", modelName, skinName );
+		}
+		pi->legsSkin = trap_R_RegisterSkin( filename );
+	}
+
+	if (teamName && *teamName) {
+		Com_sprintf( filename, sizeof( filename ), "models/players/%s/%s/upper_%s.skin", modelName, teamName, skinName );
+	} else {
+		Com_sprintf( filename, sizeof( filename ), "models/players/%s/upper_%s.skin", modelName, skinName );
+	}
+	pi->torsoSkin = trap_R_RegisterSkin( filename );
+	if (!pi->torsoSkin) {
+		if (teamName && *teamName) {
+			Com_sprintf( filename, sizeof( filename ), "models/players/characters/%s/%s/upper_%s.skin", modelName, teamName, skinName );
+		} else {
+			Com_sprintf( filename, sizeof( filename ), "models/players/characters/%s/upper_%s.skin", modelName, skinName );
+		}
+		pi->torsoSkin = trap_R_RegisterSkin( filename );
+	}
+
+	if ( UI_FindClientHeadFile( filename, sizeof(filename), teamName, headModelName, headSkinName, "head", "skin" ) ) {
+		pi->headSkin = trap_R_RegisterSkin( filename );
+	}
+
+	if ( !pi->legsSkin || !pi->torsoSkin || !pi->headSkin ) {
+		return qfalse;
+	}
+
+	return qtrue;
+}
+
+
+/*
+======================
+UI_ParseAnimationFile
+======================
+*/
+static qboolean UI_ParseAnimationFile( const char *filename, animation_t *animations ) {
+	char		*text_p, *prev;
+	int			len;
+	int			i;
+	char		*token;
+	float		fps;
+	int			skip;
+	char		text[20000];
+	fileHandle_t	f;
+
+	memset( animations, 0, sizeof( animation_t ) * MAX_ANIMATIONS );
+
+	// load the file
+	len = trap_FS_FOpenFile( filename, &f, FS_READ );
+	if ( len <= 0 ) {
+		return qfalse;
+	}
+	if ( len >= ( sizeof( text ) - 1 ) ) {
+		Com_Printf( "File %s too long\n", filename );
+		return qfalse;
+	}
+	trap_FS_Read( text, len, f );
+	text[len] = 0;
+	trap_FS_FCloseFile( f );
+
+	COM_Compress(text);
+
+	// parse the text
+	text_p = text;
+	skip = 0;	// quite the compiler warning
+
+	// read optional parameters
+	while ( 1 ) {
+		prev = text_p;	// so we can unget
+		token = COM_Parse( (const char **)&text_p );
+		if ( !token ) {
+			break;
+		}
+		if ( !Q_stricmp( token, "footsteps" ) ) {
+			token = COM_Parse( (const char **)&text_p );
+			if ( !token ) {
+				break;
+			}
+			continue;
+		} else if ( !Q_stricmp( token, "headoffset" ) ) {
+			for ( i = 0 ; i < 3 ; i++ ) {
+				token = COM_Parse( (const char **)&text_p );
+				if ( !token ) {
+					break;
+				}
+			}
+			continue;
+		} else if ( !Q_stricmp( token, "sex" ) ) {
+			token = COM_Parse( (const char **)&text_p );
+			if ( !token ) {
+				break;
+			}
+			continue;
+		}
+
+		// if it is a number, start parsing animations
+		if ( token[0] >= '0' && token[0] <= '9' ) {
+			text_p = prev;	// unget the token
+			break;
+		}
+
+		Com_Printf( "unknown token '%s' is %s\n", token, filename );
+	}
+
+	// read information for each frame
+	for ( i = 0 ; i < MAX_ANIMATIONS ; i++ ) {
+
+		token = COM_Parse( (const char **)&text_p );
+		if ( !token ) {
+			break;
+		}
+		animations[i].firstFrame = atoi( token );
+		// leg only frames are adjusted to not count the upper body only frames
+		if ( i == BOTH_CROUCH1WALK ) {
+			skip = animations[BOTH_CROUCH1WALK].firstFrame - animations[BOTH_GESTURE1].firstFrame;
+		}
+		if ( i >= BOTH_CROUCH1WALK ) {
+			animations[i].firstFrame -= skip;
+		}
+
+		token = COM_Parse( (const char **)&text_p );
+		if ( !token ) {
+			break;
+		}
+		animations[i].numFrames = atoi( token );
+
+		token = COM_Parse( (const char **)&text_p );
+		if ( !token ) {
+			break;
+		}
+		animations[i].loopFrames = atoi( token );
+
+		token = COM_Parse( (const char **)&text_p );
+		if ( !token ) {
+			break;
+		}
+		fps = atof( token );
+		if ( fps == 0 ) {
+			fps = 1;
+		}
+		animations[i].frameLerp = 1000 / fps;
+		animations[i].initialLerp = 1000 / fps;
+	}
+
+	if ( i != MAX_ANIMATIONS ) {
+		Com_Printf( "Error parsing animation file: %s", filename );
+		return qfalse;
+	}
+
+	return qtrue;
+}
+
+/*
+==========================
+UI_RegisterClientModelname
+==========================
+*/
+qboolean UI_RegisterClientModelname( playerInfo_t *pi, const char *modelSkinName, const char *headModelSkinName, const char *teamName ) {
+	char		modelName[MAX_QPATH];
+	char		skinName[MAX_QPATH];
+	char		headModelName[MAX_QPATH];
+	char		headSkinName[MAX_QPATH];
+	char		filename[MAX_QPATH];
+	char		*slash;
+
+	pi->torsoModel = 0;
+	pi->headModel = 0;
+
+	if ( !modelSkinName[0] ) {
+		return qfalse;
+	}
+
+	Q_strncpyz( modelName, modelSkinName, sizeof( modelName ) );
+
+	slash = strchr( modelName, '/' );
+	if ( !slash ) {
+		// modelName did not include a skin name
+		Q_strncpyz( skinName, "default", sizeof( skinName ) );
+	} else {
+		Q_strncpyz( skinName, slash + 1, sizeof( skinName ) );
+		*slash = '\0';
+	}
+
+	Q_strncpyz( headModelName, headModelSkinName, sizeof( headModelName ) );
+	slash = strchr( headModelName, '/' );
+	if ( !slash ) {
+		// modelName did not include a skin name
+		Q_strncpyz( headSkinName, "default", sizeof( skinName ) );
+	} else {
+		Q_strncpyz( headSkinName, slash + 1, sizeof( skinName ) );
+		*slash = '\0';
+	}
+
+	// load cmodels before models so filecache works
+
+	Com_sprintf( filename, sizeof( filename ), "models/players/%s/lower.md3", modelName );
+	pi->legsModel = trap_R_RegisterModel( filename );
+	if ( !pi->legsModel ) {
+		Com_sprintf( filename, sizeof( filename ), "models/players/characters/%s/lower.md3", modelName );
+		pi->legsModel = trap_R_RegisterModel( filename );
+		if ( !pi->legsModel ) {
+			Com_Printf( "Failed to load model file %s\n", filename );
+			return qfalse;
+		}
+	}
+
+	Com_sprintf( filename, sizeof( filename ), "models/players/%s/upper.md3", modelName );
+	pi->torsoModel = trap_R_RegisterModel( filename );
+	if ( !pi->torsoModel ) {
+		Com_sprintf( filename, sizeof( filename ), "models/players/characters/%s/upper.md3", modelName );
+		pi->torsoModel = trap_R_RegisterModel( filename );
+		if ( !pi->torsoModel ) {
+			Com_Printf( "Failed to load model file %s\n", filename );
+			return qfalse;
+		}
+	}
+
+	if (headModelName && headModelName[0] == '*' ) {
+		Com_sprintf( filename, sizeof( filename ), "models/players/heads/%s/%s.md3", &headModelName[1], &headModelName[1] );
+	}
+	else {
+		Com_sprintf( filename, sizeof( filename ), "models/players/%s/head.md3", headModelName );
+	}
+	pi->headModel = trap_R_RegisterModel( filename );
+	if ( !pi->headModel && headModelName[0] != '*') {
+		Com_sprintf( filename, sizeof( filename ), "models/players/heads/%s/%s.md3", headModelName, headModelName );
+		pi->headModel = trap_R_RegisterModel( filename );
+	}
+
+	if (!pi->headModel) {
+		Com_Printf( "Failed to load model file %s\n", filename );
+		return qfalse;
+	}
+
+	// if any skins failed to load, fall back to default
+	if ( !UI_RegisterClientSkin( pi, modelName, skinName, headModelName, headSkinName, teamName) ) {
+		if ( !UI_RegisterClientSkin( pi, modelName, "default", headModelName, "default", teamName ) ) {
+			Com_Printf( "Failed to load skin file: %s : %s\n", modelName, skinName );
+			return qfalse;
+		}
+	}
+
+	// load the animations
+	Com_sprintf( filename, sizeof( filename ), "models/players/%s/animation.cfg", modelName );
+	if ( !UI_ParseAnimationFile( filename, pi->animations ) ) {
+		Com_sprintf( filename, sizeof( filename ), "models/players/characters/%s/animation.cfg", modelName );
+		if ( !UI_ParseAnimationFile( filename, pi->animations ) ) {
+			Com_Printf( "Failed to load animation file %s\n", filename );
+			return qfalse;
+		}
+	}
+
+	return qtrue;
+}
+
+
+/*
+===============
+UI_PlayerInfo_SetModel
+===============
+*/
+void UI_PlayerInfo_SetModel( playerInfo_t *pi, const char *model, const char *headmodel, char *teamName ) {
+	memset( pi, 0, sizeof(*pi) );
+	UI_RegisterClientModelname( pi, model, headmodel, teamName );
+	pi->weapon = WP_BRYAR_PISTOL;
+	pi->currentWeapon = pi->weapon;
+	pi->lastWeapon = pi->weapon;
+	pi->pendingWeapon = -1;
+	pi->weaponTimer = 0;
+	pi->chat = qfalse;
+	pi->newModel = qtrue;
+	UI_PlayerInfo_SetWeapon( pi, pi->weapon );
+}
+
+
+/*
+===============
+UI_PlayerInfo_SetInfo
+===============
+*/
+void UI_PlayerInfo_SetInfo( playerInfo_t *pi, int legsAnim, int torsoAnim, vec3_t viewAngles, vec3_t moveAngles, weapon_t weaponNumber, qboolean chat ) {
+	int			currentAnim;
+	weapon_t	weaponNum;
+
+	pi->chat = chat;
+
+	// view angles
+	VectorCopy( viewAngles, pi->viewAngles );
+
+	// move angles
+	VectorCopy( moveAngles, pi->moveAngles );
+
+	if ( pi->newModel ) {
+		pi->newModel = qfalse;
+
+		jumpHeight = 0;
+		pi->pendingLegsAnim = 0;
+		UI_ForceLegsAnim( pi, legsAnim );
+		pi->legs.yawAngle = viewAngles[YAW];
+		pi->legs.yawing = qfalse;
+
+		pi->pendingTorsoAnim = 0;
+		UI_ForceTorsoAnim( pi, torsoAnim );
+		pi->torso.yawAngle = viewAngles[YAW];
+		pi->torso.yawing = qfalse;
+
+		if ( weaponNumber != -1 ) {
+			pi->weapon = weaponNumber;
+			pi->currentWeapon = weaponNumber;
+			pi->lastWeapon = weaponNumber;
+			pi->pendingWeapon = -1;
+			pi->weaponTimer = 0;
+			UI_PlayerInfo_SetWeapon( pi, pi->weapon );
+		}
+
+		return;
+	}
+
+	// weapon
+	if ( weaponNumber == -1 ) {
+		pi->pendingWeapon = -1;
+		pi->weaponTimer = 0;
+	}
+	else if ( weaponNumber != WP_NONE ) {
+		pi->pendingWeapon = weaponNumber;
+		pi->weaponTimer = dp_realtime + UI_TIMER_WEAPON_DELAY;
+	}
+	weaponNum = pi->lastWeapon;
+	pi->weapon = weaponNum;
+
+	if ( torsoAnim == BOTH_DEATH1 || legsAnim == BOTH_DEATH1 ) {
+		torsoAnim = legsAnim = BOTH_DEATH1;
+		pi->weapon = pi->currentWeapon = WP_NONE;
+		UI_PlayerInfo_SetWeapon( pi, pi->weapon );
+
+		jumpHeight = 0;
+		pi->pendingLegsAnim = 0;
+		UI_ForceLegsAnim( pi, legsAnim );
+
+		pi->pendingTorsoAnim = 0;
+		UI_ForceTorsoAnim( pi, torsoAnim );
+
+		return;
+	}
+
+	// leg animation
+	currentAnim = pi->legsAnim & ~ANIM_TOGGLEBIT;
+	if ( legsAnim != BOTH_JUMP1 && ( currentAnim == BOTH_JUMP1 || currentAnim == BOTH_LAND1 ) ) {
+		pi->pendingLegsAnim = legsAnim;
+	}
+	else if ( legsAnim != currentAnim ) {
+		jumpHeight = 0;
+		pi->pendingLegsAnim = 0;
+		UI_ForceLegsAnim( pi, legsAnim );
+	}
+
+	// torso animation
+	if ( torsoAnim == TORSO_WEAPONREADY3 || torsoAnim == BOTH_STAND2 ) {
+		if ( weaponNum == WP_NONE || weaponNum == WP_SABER ) {
+			torsoAnim = BOTH_STAND2;
+		}
+		else {
+			torsoAnim = TORSO_WEAPONREADY3;
+		}
+	}
+ 
+	if ( torsoAnim == BOTH_ATTACK3 || torsoAnim == BOTH_A1_T__B_ ) {
+		if ( weaponNum == WP_NONE || weaponNum == WP_SABER ) {
+			torsoAnim = BOTH_A1_T__B_;
+		}
+		else {
+			torsoAnim = BOTH_ATTACK3;
+		}
+		pi->muzzleFlashTime = dp_realtime + UI_TIMER_MUZZLE_FLASH;
+		//FIXME play firing sound here
+	}
+
+	currentAnim = pi->torsoAnim & ~ANIM_TOGGLEBIT;
+
+	if ( weaponNum != pi->currentWeapon || currentAnim == TORSO_RAISEWEAP1|| currentAnim == TORSO_DROPWEAP1 ) {
+		pi->pendingTorsoAnim = torsoAnim;
+	}
+	else if ( ( currentAnim == BOTH_GESTURE1 || currentAnim == BOTH_ATTACK3 ) && ( torsoAnim != currentAnim ) ) {
+		pi->pendingTorsoAnim = torsoAnim;
+	}
+	else if ( torsoAnim != currentAnim ) {
+		pi->pendingTorsoAnim = 0;
+		UI_ForceTorsoAnim( pi, torsoAnim );
+	}
+}
diff --git a/codemp/ui/ui_public.h b/codemp/ui/ui_public.h
new file mode 100644
index 0000000..5c9ae58
--- /dev/null
+++ b/codemp/ui/ui_public.h
@@ -0,0 +1,252 @@
+// Copyright (C) 1999-2000 Id Software, Inc.
+//
+#ifndef __UI_PUBLIC_H__
+#define __UI_PUBLIC_H__
+
+#define UI_API_VERSION	7
+
+typedef struct {
+	connstate_t		connState;
+	int				connectPacketCount;
+	int				clientNum;
+	char			servername[MAX_STRING_CHARS];
+	char			updateInfoString[MAX_STRING_CHARS];
+	char			messageString[MAX_STRING_CHARS];
+} uiClientState_t;
+
+typedef enum {
+	UI_ERROR,
+	UI_PRINT,
+	UI_MILLISECONDS,
+	UI_CVAR_SET,
+	UI_CVAR_VARIABLEVALUE,
+	UI_CVAR_VARIABLESTRINGBUFFER,
+	UI_CVAR_SETVALUE,
+	UI_CVAR_RESET,
+	UI_CVAR_CREATE,
+	UI_CVAR_INFOSTRINGBUFFER,
+	UI_ARGC,
+	UI_ARGV,
+	UI_CMD_EXECUTETEXT,
+	UI_FS_FOPENFILE,
+	UI_FS_READ,
+	UI_FS_WRITE,
+	UI_FS_FCLOSEFILE,
+	UI_FS_GETFILELIST,
+	UI_R_REGISTERMODEL,
+	UI_R_REGISTERSKIN,
+	UI_R_REGISTERSHADERNOMIP,
+	UI_R_SHADERNAMEFROMINDEX,
+	UI_R_CLEARSCENE,
+	UI_R_ADDREFENTITYTOSCENE,
+	UI_R_ADDPOLYTOSCENE,
+	UI_R_ADDLIGHTTOSCENE,
+	UI_R_RENDERSCENE,
+	UI_R_SETCOLOR,
+	UI_R_DRAWSTRETCHPIC,
+	UI_UPDATESCREEN,
+	UI_CM_LERPTAG,
+	UI_CM_LOADMODEL,
+	UI_S_REGISTERSOUND,
+	UI_S_STARTLOCALSOUND,
+	UI_KEY_KEYNUMTOSTRINGBUF,
+	UI_KEY_GETBINDINGBUF,
+	UI_KEY_SETBINDING,
+	UI_KEY_ISDOWN,
+	UI_KEY_GETOVERSTRIKEMODE,
+	UI_KEY_SETOVERSTRIKEMODE,
+	UI_KEY_CLEARSTATES,
+	UI_KEY_GETCATCHER,
+	UI_KEY_SETCATCHER,
+	UI_GETCLIPBOARDDATA,
+	UI_GETGLCONFIG,
+	UI_GETCLIENTSTATE,
+	UI_GETCONFIGSTRING,
+	UI_LAN_GETPINGQUEUECOUNT,
+	UI_LAN_CLEARPING,
+	UI_LAN_GETPING,
+	UI_LAN_GETPINGINFO,
+	UI_CVAR_REGISTER,
+	UI_CVAR_UPDATE,
+	UI_MEMORY_REMAINING,
+	UI_GET_CDKEY,
+	UI_SET_CDKEY,
+	UI_VERIFY_CDKEY,
+	UI_R_REGISTERFONT,
+	UI_R_FONT_STRLENPIXELS,
+	UI_R_FONT_STRLENCHARS,
+	UI_R_FONT_STRHEIGHTPIXELS,
+	UI_R_FONT_DRAWSTRING,
+	UI_LANGUAGE_ISASIAN,
+	UI_LANGUAGE_USESSPACES,
+	UI_ANYLANGUAGE_READCHARFROMSTRING,
+	UI_R_MODELBOUNDS,
+	UI_PC_ADD_GLOBAL_DEFINE,
+	UI_PC_LOAD_SOURCE,
+	UI_PC_FREE_SOURCE,
+	UI_PC_READ_TOKEN,
+	UI_PC_SOURCE_FILE_AND_LINE,
+	UI_PC_LOAD_GLOBAL_DEFINES,
+	UI_PC_REMOVE_ALL_GLOBAL_DEFINES,
+
+	UI_S_STOPBACKGROUNDTRACK,
+	UI_S_STARTBACKGROUNDTRACK,
+	UI_REAL_TIME,
+	UI_LAN_GETSERVERCOUNT,
+	UI_LAN_GETSERVERADDRESSSTRING,
+	UI_LAN_GETSERVERINFO,
+	UI_LAN_MARKSERVERVISIBLE,
+	UI_LAN_UPDATEVISIBLEPINGS,
+	UI_LAN_RESETPINGS,
+	UI_LAN_LOADCACHEDSERVERS,
+	UI_LAN_SAVECACHEDSERVERS,
+	UI_LAN_ADDSERVER,
+	UI_LAN_REMOVESERVER,
+	UI_CIN_PLAYCINEMATIC,
+	UI_CIN_STOPCINEMATIC,
+	UI_CIN_RUNCINEMATIC,
+	UI_CIN_DRAWCINEMATIC,
+	UI_CIN_SETEXTENTS,
+	UI_R_REMAP_SHADER,
+	UI_LAN_SERVERSTATUS,
+	UI_LAN_GETSERVERPING,
+	UI_LAN_SERVERISVISIBLE,
+	UI_LAN_COMPARESERVERS,
+
+	UI_MEMSET = 100,
+	UI_MEMCPY,
+	UI_STRNCPY,
+	UI_SIN,
+	UI_COS,
+	UI_ATAN2,
+	UI_SQRT,
+	UI_MATRIXMULTIPLY,
+	UI_ANGLEVECTORS,
+	UI_PERPENDICULARVECTOR,
+	UI_FLOOR,
+	UI_CEIL,
+
+	UI_TESTPRINTINT,
+	UI_TESTPRINTFLOAT,
+
+	UI_ACOS,
+	UI_ASIN,
+
+	UI_SP_GETNUMLANGUAGES,
+	UI_SP_GETLANGUAGENAME,
+	UI_SP_GETSTRINGTEXTSTRING = 200,
+
+/*
+Ghoul2 Insert Start
+*/
+	UI_G2_LISTSURFACES,
+	UI_G2_LISTBONES,
+	UI_G2_SETMODELS,
+	UI_G2_HAVEWEGHOULMODELS,
+	UI_G2_GETBOLT,
+	UI_G2_GETBOLT_NOREC,
+	UI_G2_GETBOLT_NOREC_NOROT,
+	UI_G2_INITGHOUL2MODEL,
+	UI_G2_COLLISIONDETECT,
+	UI_G2_CLEANMODELS,
+	UI_G2_ANGLEOVERRIDE,
+	UI_G2_PLAYANIM,
+	UI_G2_GETBONEANIM,
+	UI_G2_GETBONEFRAME, //trimmed down version of GBA, so I don't have to pass all those unused args across the VM-exe border
+	UI_G2_GETGLANAME,
+	UI_G2_COPYGHOUL2INSTANCE,
+	UI_G2_COPYSPECIFICGHOUL2MODEL,
+	UI_G2_DUPLICATEGHOUL2INSTANCE,
+	UI_G2_HASGHOUL2MODELONINDEX,
+	UI_G2_REMOVEGHOUL2MODEL,
+	UI_G2_ADDBOLT,
+	UI_G2_SETBOLTON,
+	UI_G2_SETROOTSURFACE,
+	UI_G2_SETSURFACEONOFF,
+	UI_G2_SETNEWORIGIN,
+
+	UI_G2_GETTIME,
+	UI_G2_SETTIME,
+
+/*
+	//rww - RAGDOLL_BEGIN
+*/
+	UI_G2_SETRAGDOLL,
+	UI_G2_ANIMATEG2MODELS,
+/*
+	//rww - RAGDOLL_END
+*/
+
+	//rww - ik move method, allows you to specify a bone and move it to a world point (within joint constraints)
+	//by using the majority of gil's existing bone angling stuff from the ragdoll code.
+	UI_G2_SETBONEIKSTATE,
+	UI_G2_IKMOVE,
+
+	UI_G2_GETSURFACENAME,
+	UI_G2_SETSKIN,
+	UI_G2_ATTACHG2MODEL,
+/*
+Ghoul2 Insert End
+*/
+} uiImport_t;
+
+typedef enum {
+	UIMENU_NONE,
+	UIMENU_MAIN,
+	UIMENU_INGAME,
+	UIMENU_PLAYERCONFIG,
+	UIMENU_TEAM,
+	UIMENU_POSTGAME,
+	UIMENU_PLAYERFORCE,
+	UIMENU_SIEGEMESSAGE,
+	UIMENU_SIEGEOBJECTIVES,
+	UIMENU_VOICECHAT,
+	UIMENU_CLOSEALL,
+	UIMENU_CLASSSEL
+};
+typedef int uiMenuCommand_t;
+
+#define SORT_HOST			0
+#define SORT_MAP			1
+#define SORT_CLIENTS		2
+#define SORT_GAME			3
+#define SORT_PING			4
+
+typedef enum {
+	UI_GETAPIVERSION = 0,	// system reserved
+
+	UI_INIT,
+//	void	UI_Init( void );
+
+	UI_SHUTDOWN,
+//	void	UI_Shutdown( void );
+
+	UI_KEY_EVENT,
+//	void	UI_KeyEvent( int key );
+
+	UI_MOUSE_EVENT,
+//	void	UI_MouseEvent( int dx, int dy );
+
+	UI_REFRESH,
+//	void	UI_Refresh( int time );
+
+	UI_IS_FULLSCREEN,
+//	qboolean UI_IsFullscreen( void );
+
+	UI_SET_ACTIVE_MENU,
+//	void	UI_SetActiveMenu( uiMenuCommand_t menu );
+
+	UI_CONSOLE_COMMAND,
+//	qboolean UI_ConsoleCommand( int realTime );
+
+	UI_DRAW_CONNECT_SCREEN,
+//	void	UI_DrawConnectScreen( qboolean overlay );
+	UI_HASUNIQUECDKEY,
+// if !overlay, the background will be drawn, otherwise it will be
+// overlayed over whatever the cgame has drawn.
+// a GetClientState syscall will be made to get the current strings
+
+	UI_MENU_RESET
+} uiExport_t;
+
+#endif
diff --git a/codemp/ui/ui_saber.c b/codemp/ui/ui_saber.c
new file mode 100644
index 0000000..ce230b8
--- /dev/null
+++ b/codemp/ui/ui_saber.c
@@ -0,0 +1,1107 @@
+//
+/*
+=======================================================================
+
+USER INTERFACE SABER LOADING & DISPLAY CODE
+
+=======================================================================
+*/
+
+// leave this at the top of all UI_xxxx files for PCH reasons...
+//
+//#include "../server/exe_headers.h"
+#include "ui_local.h"
+#include "ui_shared.h"
+
+//#define MAX_SABER_DATA_SIZE 0x8000
+#define MAX_SABER_DATA_SIZE 0x9000
+
+// On Xbox, static linking lets us steal the buffer from wp_saberLoad
+// Just make sure that the saber data size is the same
+// Damn. OK. Gotta fix this again. Later.
+static char	SaberParms[MAX_SABER_DATA_SIZE];
+qboolean	ui_saber_parms_parsed = qfalse;
+
+static qhandle_t redSaberGlowShader;
+static qhandle_t redSaberCoreShader;
+static qhandle_t orangeSaberGlowShader;
+static qhandle_t orangeSaberCoreShader;
+static qhandle_t yellowSaberGlowShader;
+static qhandle_t yellowSaberCoreShader;
+static qhandle_t greenSaberGlowShader;
+static qhandle_t greenSaberCoreShader;
+static qhandle_t blueSaberGlowShader;
+static qhandle_t blueSaberCoreShader;
+static qhandle_t purpleSaberGlowShader;
+static qhandle_t purpleSaberCoreShader;
+
+void UI_CacheSaberGlowGraphics( void )
+{//FIXME: these get fucked by vid_restarts
+	redSaberGlowShader			= trap_R_RegisterShaderNoMip( "gfx/effects/sabers/red_glow" );
+	redSaberCoreShader			= trap_R_RegisterShaderNoMip( "gfx/effects/sabers/red_line" );
+	orangeSaberGlowShader		= trap_R_RegisterShaderNoMip( "gfx/effects/sabers/orange_glow" );
+	orangeSaberCoreShader		= trap_R_RegisterShaderNoMip( "gfx/effects/sabers/orange_line" );
+	yellowSaberGlowShader		= trap_R_RegisterShaderNoMip( "gfx/effects/sabers/yellow_glow" );
+	yellowSaberCoreShader		= trap_R_RegisterShaderNoMip( "gfx/effects/sabers/yellow_line" );
+	greenSaberGlowShader		= trap_R_RegisterShaderNoMip( "gfx/effects/sabers/green_glow" );
+	greenSaberCoreShader		= trap_R_RegisterShaderNoMip( "gfx/effects/sabers/green_line" );
+	blueSaberGlowShader			= trap_R_RegisterShaderNoMip( "gfx/effects/sabers/blue_glow" );
+	blueSaberCoreShader			= trap_R_RegisterShaderNoMip( "gfx/effects/sabers/blue_line" );
+	purpleSaberGlowShader		= trap_R_RegisterShaderNoMip( "gfx/effects/sabers/purple_glow" );
+	purpleSaberCoreShader		= trap_R_RegisterShaderNoMip( "gfx/effects/sabers/purple_line" );
+}
+
+qboolean UI_ParseLiteral( const char **data, const char *string ) 
+{
+	const char	*token;
+
+	token = COM_ParseExt( data, qtrue );
+	if ( token[0] == 0 ) 
+	{
+		Com_Printf( "unexpected EOF\n" );
+		return qtrue;
+	}
+
+	if ( Q_stricmp( token, string ) ) 
+	{
+		Com_Printf( "required string '%s' missing\n", string );
+		return qtrue;
+	}
+
+	return qfalse;
+}
+
+qboolean UI_ParseLiteralSilent( const char **data, const char *string ) 
+{
+	const char	*token;
+
+	token = COM_ParseExt( data, qtrue );
+	if ( token[0] == 0 ) 
+	{
+		return qtrue;
+	}
+
+	if ( Q_stricmp( token, string ) ) 
+	{
+		return qtrue;
+	}
+
+	return qfalse;
+}
+
+qboolean UI_SaberParseParm( const char *saberName, const char *parmname, char *saberData ) 
+{
+	const char	*token;
+	const char	*value;
+	const char	*p;
+
+	if ( !saberName || !saberName[0] ) 
+	{
+		return qfalse;
+	}
+
+	//try to parse it out
+	p = SaberParms;
+	// A bogus name is passed in
+	COM_BeginParseSession("saberinfo");
+
+	// look for the right saber
+	while ( p )
+	{
+		token = COM_ParseExt( &p, qtrue );
+		if ( token[0] == 0 )
+		{
+			return qfalse;
+		}
+
+		if ( !Q_stricmp( token, saberName ) ) 
+		{
+			break;
+		}
+
+		SkipBracedSection( &p );
+	}
+	if ( !p ) 
+	{
+		return qfalse;
+	}
+
+	if ( UI_ParseLiteral( &p, "{" ) ) 
+	{
+		return qfalse;
+	}
+		
+	// parse the saber info block
+	while ( 1 ) 
+	{
+		token = COM_ParseExt( &p, qtrue );
+		if ( !token[0] ) 
+		{
+			Com_Printf( S_COLOR_RED"ERROR: unexpected EOF while parsing '%s'\n", saberName );
+			return qfalse;
+		}
+
+		if ( !Q_stricmp( token, "}" ) ) 
+		{
+			break;
+		}
+
+		if ( !Q_stricmp( token, parmname ) ) 
+		{
+			if ( COM_ParseString( &p, &value ) ) 
+			{
+				continue;
+			}
+			strcpy( saberData, value );
+			return qtrue;
+		}
+
+		SkipRestOfLine( &p );
+		continue;
+	}
+
+	return qfalse;
+}
+
+
+qboolean UI_SaberModelForSaber( const char *saberName, char *saberModel )
+{
+	return UI_SaberParseParm( saberName, "saberModel", saberModel );
+}
+
+qboolean UI_SaberSkinForSaber( const char *saberName, char *saberSkin )
+{
+	return UI_SaberParseParm( saberName, "customSkin", saberSkin );
+}
+
+qboolean UI_SaberTypeForSaber( const char *saberName, char *saberType )
+{
+	return UI_SaberParseParm( saberName, "saberType", saberType );
+}
+
+int UI_SaberNumBladesForSaber( const char *saberName )
+{
+	int numBlades;
+	char	numBladesString[8]={0};
+	UI_SaberParseParm( saberName, "numBlades", numBladesString );
+	numBlades = atoi( numBladesString );
+	if ( numBlades < 1 )
+	{
+		numBlades = 1;
+	}
+	else if ( numBlades > 8 )
+	{
+		numBlades = 8;
+	}
+	return numBlades;
+}
+
+
+qboolean UI_IsSaberTwoHanded( const char *saberName )
+{
+	int twoHanded;
+	char	twoHandedString[8]={0};
+	UI_SaberParseParm( saberName, "twoHanded", twoHandedString );
+	if ( !twoHandedString[0] )
+	{//not defined defaults to "no"
+		return qfalse;
+	}
+	twoHanded = atoi( twoHandedString );
+	return ((qboolean)(twoHanded!=0));
+}
+
+float UI_SaberBladeLengthForSaber( const char *saberName, int bladeNum )
+{
+	char	lengthString[8]={0};
+	float	length = 40.0f;
+	UI_SaberParseParm( saberName, "saberLength", lengthString );
+	if ( lengthString[0] )
+	{
+		length = atof( lengthString );
+		if ( length < 0.0f )
+		{
+			length = 0.0f;
+		}
+	}
+
+	UI_SaberParseParm( saberName, va("saberLength%d", bladeNum+1), lengthString );
+	if ( lengthString[0] )
+	{
+		length = atof( lengthString );
+		if ( length < 0.0f )
+		{
+			length = 0.0f;
+		}
+	}
+
+	return length;
+}
+
+float UI_SaberBladeRadiusForSaber( const char *saberName, int bladeNum )
+{
+	char	radiusString[8]={0};
+	float	radius = 3.0f;
+	UI_SaberParseParm( saberName, "saberRadius", radiusString );
+	if ( radiusString[0] )
+	{
+		radius = atof( radiusString );
+		if ( radius < 0.0f )
+		{
+			radius = 0.0f;
+		}
+	}
+
+	UI_SaberParseParm( saberName, va("saberRadius%d", bladeNum+1), radiusString );
+	if ( radiusString[0] )
+	{
+		radius = atof( radiusString );
+		if ( radius < 0.0f )
+		{
+			radius = 0.0f;
+		}
+	}
+
+	return radius;
+}
+
+qboolean UI_SaberProperNameForSaber( const char *saberName, char *saberProperName )
+{
+	char	stringedSaberName[1024];
+	qboolean ret = UI_SaberParseParm( saberName, "name", stringedSaberName );
+	// if it's a stringed reference translate it
+	if( ret && stringedSaberName && stringedSaberName[0] == '@')
+	{
+		trap_SP_GetStringTextString(&stringedSaberName[1], saberProperName, 1024);
+	}
+	else
+	{
+		// no stringed so just use it as it
+		strcpy( saberProperName, stringedSaberName );
+	}
+
+	return ret;
+	
+}
+
+qboolean UI_SaberValidForPlayerInMP( const char *saberName )
+{
+	char allowed [8]={0};
+	if ( !UI_SaberParseParm( saberName, "notInMP", allowed ) )
+	{//not defined, default is yes
+		return qtrue;
+	}
+	if ( !allowed[0] )
+	{//not defined, default is yes
+		return qtrue;
+	}
+	else
+	{//return value
+		return ((qboolean)(atoi(allowed)==0));
+	}
+}
+
+void UI_SaberLoadParms( void ) 
+{
+	int			len, totallen, saberExtFNLen, fileCnt, i;
+	char		*holdChar, *marker;
+	char		saberExtensionListBuf[2048];			//	The list of file names read in
+	fileHandle_t f;
+	char buffer[MAX_MENUFILE];
+
+	//ui.Printf( "UI Parsing *.sab saber definitions\n" );
+	
+	ui_saber_parms_parsed = qtrue;
+	UI_CacheSaberGlowGraphics();
+
+	//set where to store the first one
+	totallen = 0;
+	marker = SaberParms;
+	marker[0] = '\0';
+
+	//now load in the extra .npc extensions
+	fileCnt = trap_FS_GetFileList("ext_data/sabers", ".sab", saberExtensionListBuf, sizeof(saberExtensionListBuf) );
+
+	holdChar = saberExtensionListBuf;
+	for ( i = 0; i < fileCnt; i++, holdChar += saberExtFNLen + 1 ) 
+	{
+		saberExtFNLen = strlen( holdChar );
+
+		len = trap_FS_FOpenFile( va( "ext_data/sabers/%s", holdChar), &f, FS_READ );
+
+		if (!f)
+		{
+			continue;
+		}
+
+		if ( len == -1 ) 
+		{
+			Com_Printf( "UI_SaberLoadParms: error reading %s\n", holdChar );
+		}
+		else
+		{
+			if (len > sizeof(buffer) )
+			{
+				Com_Error( ERR_FATAL, "UI_SaberLoadParms: file %s too large to read (max=%d)", holdChar, sizeof(buffer) );
+			}
+			trap_FS_Read( buffer, len, f );
+			trap_FS_FCloseFile( f );
+			buffer[len] = 0;
+
+			if ( totallen && *(marker-1) == '}' )
+			{//don't let it end on a } because that should be a stand-alone token
+				strcat( marker, " " );
+				totallen++;
+				marker++; 
+			}
+			len = COM_Compress( buffer );
+
+			if ( totallen + len >= MAX_SABER_DATA_SIZE ) {
+				Com_Error( ERR_FATAL, "UI_SaberLoadParms: ran out of space before reading %s\n(you must make the .sab files smaller)", holdChar );
+			}
+			strcat( marker, buffer );
+
+			totallen += len;
+			marker += len;
+		}
+	}
+}
+
+void UI_DoSaber( vec3_t origin, vec3_t dir, float length, float lengthMax, float radius, saber_colors_t color )
+{
+	vec3_t		mid, rgb={1,1,1};
+	qhandle_t	blade = 0, glow = 0;
+	refEntity_t saber;
+	float radiusmult;
+	float radiusRange;
+	float radiusStart;
+
+	if ( length < 0.5f )
+	{
+		// if the thing is so short, just forget even adding me.
+		return;
+	}
+
+	// Find the midpoint of the saber for lighting purposes
+	VectorMA( origin, length * 0.5f, dir, mid );
+
+	switch( color )
+	{
+		case SABER_RED:
+			glow = redSaberGlowShader;
+			blade = redSaberCoreShader;
+			VectorSet( rgb, 1.0f, 0.2f, 0.2f );
+			break;
+		case SABER_ORANGE:
+			glow = orangeSaberGlowShader;
+			blade = orangeSaberCoreShader;
+			VectorSet( rgb, 1.0f, 0.5f, 0.1f );
+			break;
+		case SABER_YELLOW:
+			glow = yellowSaberGlowShader;
+			blade = yellowSaberCoreShader;
+			VectorSet( rgb, 1.0f, 1.0f, 0.2f );
+			break;
+		case SABER_GREEN:
+			glow = greenSaberGlowShader;
+			blade = greenSaberCoreShader;
+			VectorSet( rgb, 0.2f, 1.0f, 0.2f );
+			break;
+		case SABER_BLUE:
+			glow = blueSaberGlowShader;
+			blade = blueSaberCoreShader;
+			VectorSet( rgb, 0.2f, 0.4f, 1.0f );
+			break;
+		case SABER_PURPLE:
+			glow = purpleSaberGlowShader;
+			blade = purpleSaberCoreShader;
+			VectorSet( rgb, 0.9f, 0.2f, 1.0f );
+			break;
+	}
+
+	// always add a light because sabers cast a nice glow before they slice you in half!!  or something...
+	/*
+	if ( doLight )
+	{//FIXME: RGB combine all the colors of the sabers you're using into one averaged color!
+		cgi_R_AddLightToScene( mid, (length*2.0f) + (random()*8.0f), rgb[0], rgb[1], rgb[2] );
+	}
+	*/
+
+	memset( &saber, 0, sizeof( refEntity_t ));
+
+	// Saber glow is it's own ref type because it uses a ton of sprites, otherwise it would eat up too many
+	//	refEnts to do each glow blob individually
+	saber.saberLength = length;
+
+	// Jeff, I did this because I foolishly wished to have a bright halo as the saber is unleashed.  
+	// It's not quite what I'd hoped tho.  If you have any ideas, go for it!  --Pat
+	if (length < lengthMax )
+	{
+		radiusmult = 1.0 + (2.0 / length);		// Note this creates a curve, and length cannot be < 0.5.
+	}
+	else
+	{
+		radiusmult = 1.0;
+	}
+
+	radiusRange = radius * 0.075f;
+	radiusStart = radius-radiusRange;
+
+	saber.radius = (radiusStart + crandom() * radiusRange)*radiusmult;
+	//saber.radius = (2.8f + crandom() * 0.2f)*radiusmult;
+
+
+	VectorCopy( origin, saber.origin );
+	VectorCopy( dir, saber.axis[0] );
+	saber.reType = RT_SABER_GLOW;
+	saber.customShader = glow;
+	saber.shaderRGBA[0] = saber.shaderRGBA[1] = saber.shaderRGBA[2] = saber.shaderRGBA[3] = 0xff;
+	//saber.renderfx = rfx;
+
+	trap_R_AddRefEntityToScene( &saber );
+
+	// Do the hot core
+	VectorMA( origin, length, dir, saber.origin );
+	VectorMA( origin, -1, dir, saber.oldorigin );
+	saber.customShader = blade;
+	saber.reType = RT_LINE;
+	radiusStart = radius/3.0f;
+	saber.radius = (radiusStart + crandom() * radiusRange)*radiusmult;
+//	saber.radius = (1.0 + crandom() * 0.2f)*radiusmult;
+
+	trap_R_AddRefEntityToScene( &saber );
+}
+
+char * SaberColorToString(saber_colors_t color)
+{
+	if ( color == SABER_RED)
+		return "red";
+	
+	if ( color == SABER_ORANGE)
+		return "orange";
+
+	if ( color == SABER_YELLOW)
+		return "yellow";
+
+	if ( color == SABER_GREEN)
+		return "green";
+
+	if (color == SABER_BLUE)
+		return "blue";
+
+	if ( color == SABER_PURPLE)
+		return "purple";
+	return NULL;
+}
+saber_colors_t TranslateSaberColor( const char *name ) 
+{
+	if ( !Q_stricmp( name, "red" ) ) 
+	{
+		return SABER_RED;
+	}
+	if ( !Q_stricmp( name, "orange" ) ) 
+	{
+		return SABER_ORANGE;
+	}
+	if ( !Q_stricmp( name, "yellow" ) ) 
+	{
+		return SABER_YELLOW;
+	}
+	if ( !Q_stricmp( name, "green" ) ) 
+	{
+		return SABER_GREEN;
+	}
+	if ( !Q_stricmp( name, "blue" ) ) 
+	{
+		return SABER_BLUE;
+	}
+	if ( !Q_stricmp( name, "purple" ) ) 
+	{
+		return SABER_PURPLE;
+	}
+	if ( !Q_stricmp( name, "random" ) ) 
+	{
+		return ((saber_colors_t)(Q_irand( SABER_ORANGE, SABER_PURPLE )));
+	}
+	return SABER_BLUE;
+}
+
+saberType_t TranslateSaberType( const char *name ) 
+{
+	if ( !Q_stricmp( name, "SABER_SINGLE" ) ) 
+	{
+		return SABER_SINGLE;
+	}
+	if ( !Q_stricmp( name, "SABER_STAFF" ) ) 
+	{
+		return SABER_STAFF;
+	}
+	if ( !Q_stricmp( name, "SABER_BROAD" ) ) 
+	{
+		return SABER_BROAD;
+	}
+	if ( !Q_stricmp( name, "SABER_PRONG" ) ) 
+	{
+		return SABER_PRONG;
+	}
+	if ( !Q_stricmp( name, "SABER_DAGGER" ) ) 
+	{
+		return SABER_DAGGER;
+	}
+	if ( !Q_stricmp( name, "SABER_ARC" ) ) 
+	{
+		return SABER_ARC;
+	}
+	if ( !Q_stricmp( name, "SABER_SAI" ) ) 
+	{
+		return SABER_SAI;
+	}
+	if ( !Q_stricmp( name, "SABER_CLAW" ) ) 
+	{
+		return SABER_CLAW;
+	}
+	if ( !Q_stricmp( name, "SABER_LANCE" ) ) 
+	{
+		return SABER_LANCE;
+	}
+	if ( !Q_stricmp( name, "SABER_STAR" ) ) 
+	{
+		return SABER_STAR;
+	}
+	if ( !Q_stricmp( name, "SABER_TRIDENT" ) ) 
+	{
+		return SABER_TRIDENT;
+	}
+	if ( !Q_stricmp( name, "SABER_SITH_SWORD" ) ) 
+	{
+		return SABER_SITH_SWORD;
+	}
+	return SABER_SINGLE;
+}
+
+void UI_SaberDrawBlade( itemDef_t *item, char *saberName, int saberModel, saberType_t saberType, vec3_t origin, vec3_t angles, int bladeNum )
+{
+
+	char bladeColorString[MAX_QPATH];
+	saber_colors_t bladeColor;
+	float bladeLength,bladeRadius;
+	vec3_t	bladeOrigin={0};
+	vec3_t	axis[3]={0};
+//	vec3_t	angles={0};
+	mdxaBone_t	boltMatrix;
+	qboolean tagHack = qfalse;
+	char *tagName;
+	int bolt;
+	float scale;
+
+	if ( (item->flags&ITF_ISSABER) && saberModel < 2 )
+	{
+		trap_Cvar_VariableStringBuffer("ui_saber_color", bladeColorString, sizeof(bladeColorString) );
+	}
+	else//if ( item->flags&ITF_ISSABER2 ) - presumed
+	{
+		trap_Cvar_VariableStringBuffer("ui_saber2_color", bladeColorString, sizeof(bladeColorString) );
+	}
+
+	if ( !trap_G2API_HasGhoul2ModelOnIndex(&(item->ghoul2),saberModel) )
+	{//invalid index!
+		return;
+	}
+
+	bladeColor = TranslateSaberColor( bladeColorString );
+
+	bladeLength = UI_SaberBladeLengthForSaber( saberName, bladeNum );
+	bladeRadius = UI_SaberBladeRadiusForSaber( saberName, bladeNum );
+
+	tagName = va( "*blade%d", bladeNum+1 );
+	bolt = trap_G2API_AddBolt( item->ghoul2,saberModel, tagName );
+	
+	if ( bolt == -1 )
+	{
+		tagHack = qtrue;
+		//hmm, just fall back to the most basic tag (this will also make it work with pre-JKA saber models
+		bolt = trap_G2API_AddBolt( item->ghoul2,saberModel, "*flash" );
+		if ( bolt == -1 )
+		{//no tag_flash either?!!
+			bolt = 0;
+		}
+	}
+	
+//	angles[PITCH] = curYaw;
+//	angles[ROLL] = 0;
+
+	trap_G2API_GetBoltMatrix( item->ghoul2, saberModel, bolt, &boltMatrix, angles, origin, uiInfo.uiDC.realTime, NULL, vec3_origin );//NULL was cgs.model_draw
+
+	// work the matrix axis stuff into the original axis and origins used.
+	BG_GiveMeVectorFromMatrix(&boltMatrix, ORIGIN, bladeOrigin);
+	BG_GiveMeVectorFromMatrix(&boltMatrix, NEGATIVE_Y, axis[0]);//front (was NEGATIVE_Y, but the md3->glm exporter screws up this tag somethin' awful)
+																//		...changed this back to NEGATIVE_Y		
+	BG_GiveMeVectorFromMatrix(&boltMatrix, NEGATIVE_X, axis[1]);//right ... and changed this to NEGATIVE_X
+	BG_GiveMeVectorFromMatrix(&boltMatrix, POSITIVE_Z, axis[2]);//up
+
+	// Where do I get scale from?
+//	scale = DC->xscale;
+	scale = 1.0f;
+
+	if ( tagHack )
+	{
+		switch ( saberType )
+		{
+		case SABER_SINGLE:
+				VectorMA( bladeOrigin, scale, axis[0], bladeOrigin );
+			break;
+		case SABER_DAGGER:
+		case SABER_LANCE:
+			break;
+		case SABER_STAFF:
+			if ( bladeNum == 0 )
+			{
+				VectorMA( bladeOrigin, 12*scale, axis[0], bladeOrigin );
+			}
+			if ( bladeNum == 1 )
+			{
+				VectorScale( axis[0], -1, axis[0] );
+				VectorMA( bladeOrigin, 12*scale, axis[0], bladeOrigin );
+			}
+			break;
+		case SABER_BROAD:
+			if ( bladeNum == 0 )
+			{
+				VectorMA( bladeOrigin, -1*scale, axis[1], bladeOrigin );
+			}
+			else if ( bladeNum == 1 )
+			{
+				VectorMA( bladeOrigin, 1*scale, axis[1], bladeOrigin );
+			}
+			break;
+		case SABER_PRONG:
+			if ( bladeNum == 0 )
+			{
+				VectorMA( bladeOrigin, -3*scale, axis[1], bladeOrigin );
+			}
+			else if ( bladeNum == 1 )
+			{
+				VectorMA( bladeOrigin, 3*scale, axis[1], bladeOrigin );
+			}
+			break;
+		case SABER_ARC:
+			VectorSubtract( axis[1], axis[2], axis[1] );
+			VectorNormalize( axis[1] );
+			switch ( bladeNum )
+			{
+			case 0:
+				VectorMA( bladeOrigin, 8*scale, axis[0], bladeOrigin );
+				VectorScale( axis[0], 0.75f, axis[0] );
+				VectorScale( axis[1], 0.25f, axis[1] );
+				VectorAdd( axis[0], axis[1], axis[0] );
+				break;
+			case 1:
+				VectorScale( axis[0], 0.25f, axis[0] );
+				VectorScale( axis[1], 0.75f, axis[1] );
+				VectorAdd( axis[0], axis[1], axis[0] );
+				break;
+			case 2:
+				VectorMA( bladeOrigin, -8*scale, axis[0], bladeOrigin );
+				VectorScale( axis[0], -0.25f, axis[0] );
+				VectorScale( axis[1], 0.75f, axis[1] );
+				VectorAdd( axis[0], axis[1], axis[0] );
+				break;
+			case 3:
+				VectorMA( bladeOrigin, -16*scale, axis[0], bladeOrigin );
+				VectorScale( axis[0], -0.75f, axis[0] );
+				VectorScale( axis[1], 0.25f, axis[1] );
+				VectorAdd( axis[0], axis[1], axis[0] );
+				break;
+			}
+			break;
+		case SABER_SAI:
+			if ( bladeNum == 1 )
+			{
+				VectorMA( bladeOrigin, -3*scale, axis[1], bladeOrigin );
+			}
+			else if ( bladeNum == 2 )
+			{
+				VectorMA( bladeOrigin, 3*scale, axis[1], bladeOrigin );
+			}
+			break;
+		case SABER_CLAW:
+			switch ( bladeNum )
+			{
+			case 0:
+				VectorMA( bladeOrigin, 2*scale, axis[0], bladeOrigin );
+				VectorMA( bladeOrigin, 2*scale, axis[2], bladeOrigin );
+				break;
+			case 1:
+				VectorMA( bladeOrigin, 2*scale, axis[0], bladeOrigin );
+				VectorMA( bladeOrigin, 2*scale, axis[2], bladeOrigin );
+				VectorMA( bladeOrigin, 2*scale, axis[1], bladeOrigin );
+				break;
+			case 2:
+				VectorMA( bladeOrigin, 2*scale, axis[0], bladeOrigin );
+				VectorMA( bladeOrigin, 2*scale, axis[2], bladeOrigin );
+				VectorMA( bladeOrigin, -2*scale, axis[1], bladeOrigin );
+				break;
+			}
+			break;
+		case SABER_STAR:
+			switch ( bladeNum )
+			{
+			case 0:
+				VectorMA( bladeOrigin, 8*scale, axis[0], bladeOrigin );
+				break;
+			case 1:
+				VectorScale( axis[0], 0.33f, axis[0] );
+				VectorScale( axis[2], 0.67f, axis[2] );
+				VectorAdd( axis[0], axis[2], axis[0] );
+				VectorMA( bladeOrigin, 8*scale, axis[0], bladeOrigin );
+				break;
+			case 2:
+				VectorScale( axis[0], -0.33f, axis[0] );
+				VectorScale( axis[2], 0.67f, axis[2] );
+				VectorAdd( axis[0], axis[2], axis[0] );
+				VectorMA( bladeOrigin, 8*scale, axis[0], bladeOrigin );
+				break;
+			case 3:
+				VectorScale( axis[0], -1, axis[0] );
+				VectorMA( bladeOrigin, 8*scale, axis[0], bladeOrigin );
+				break;
+			case 4:
+				VectorScale( axis[0], -0.33f, axis[0] );
+				VectorScale( axis[2], -0.67f, axis[2] );
+				VectorAdd( axis[0], axis[2], axis[0] );
+				VectorMA( bladeOrigin, 8*scale, axis[0], bladeOrigin );
+				break;
+			case 5:
+				VectorScale( axis[0], 0.33f, axis[0] );
+				VectorScale( axis[2], -0.67f, axis[2] );
+				VectorAdd( axis[0], axis[2], axis[0] );
+				VectorMA( bladeOrigin, 8*scale, axis[0], bladeOrigin );
+				break;
+			}
+			break;
+		case SABER_TRIDENT:
+			switch ( bladeNum )
+			{
+			case 0:
+				VectorMA( bladeOrigin, 24*scale, axis[0], bladeOrigin );
+				break;
+			case 1:
+				VectorMA( bladeOrigin, -6*scale, axis[1], bladeOrigin );
+				VectorMA( bladeOrigin, 24*scale, axis[0], bladeOrigin );
+				break;
+			case 2:
+				VectorMA( bladeOrigin, 6*scale, axis[1], bladeOrigin );
+				VectorMA( bladeOrigin, 24*scale, axis[0], bladeOrigin );
+				break;
+			case 3:
+				VectorMA( bladeOrigin, -32*scale, axis[0], bladeOrigin );
+				VectorScale( axis[0], -1, axis[0] );
+				break;
+			}
+			break;
+		case SABER_SITH_SWORD:
+			//no blade
+			break;
+		}
+	}
+	if ( saberType == SABER_SITH_SWORD )
+	{//draw no blade
+		return;
+	}
+
+	UI_DoSaber( bladeOrigin, axis[0], bladeLength, bladeLength, bladeRadius, bladeColor );
+
+}
+
+/*
+void UI_SaberDrawBlades( itemDef_t *item, vec3_t origin, vec3_t angles )
+{
+	//NOTE: only allows one saber type in view at a time
+	char saber[MAX_QPATH];
+	if ( item->flags&ITF_ISSABER )
+	{
+		trap_Cvar_VariableStringBuffer("ui_saber", saber, sizeof(saber) );
+		if ( !UI_SaberValidForPlayerInMP( saber ) )
+		{
+			trap_Cvar_Set( "ui_saber", "kyle" );
+			trap_Cvar_VariableStringBuffer("ui_saber", saber, sizeof(saber) );
+		}
+	}
+	else if ( item->flags&ITF_ISSABER2 )
+	{
+		trap_Cvar_VariableStringBuffer("ui_saber2", saber, sizeof(saber) );
+		if ( !UI_SaberValidForPlayerInMP( saber ) )
+		{
+			trap_Cvar_Set( "ui_saber2", "kyle" );
+			trap_Cvar_VariableStringBuffer("ui_saber2", saber, sizeof(saber) );
+		}
+	}
+	else
+	{
+		return;
+	}
+	if ( saber[0] )
+	{
+		saberType_t saberType;
+		int curBlade;
+		int numBlades = UI_SaberNumBladesForSaber( saber );
+		if ( numBlades )
+		{//okay, here we go, time to draw each blade...
+			char	saberTypeString[MAX_QPATH]={0};
+			UI_SaberTypeForSaber( saber, saberTypeString );
+			saberType = TranslateSaberType( saberTypeString );
+			for ( curBlade = 0; curBlade < numBlades; curBlade++ )
+			{
+				UI_SaberDrawBlade( item, saber, saberType, origin, angles, curBlade );
+			}
+		}
+	}
+}
+*/
+
+void UI_GetSaberForMenu( char *saber, int saberNum )
+{
+	char saberTypeString[MAX_QPATH]={0};
+	saberType_t saberType = SABER_NONE;
+
+	if ( saberNum == 0 )
+	{
+		trap_Cvar_VariableStringBuffer("ui_saber", saber, MAX_QPATH );
+		if ( !UI_SaberValidForPlayerInMP( saber ) )
+		{
+			trap_Cvar_Set( "ui_saber", "kyle" );
+			trap_Cvar_VariableStringBuffer("ui_saber", saber, MAX_QPATH );
+		}
+	}
+	else
+	{
+		trap_Cvar_VariableStringBuffer("ui_saber2", saber, MAX_QPATH );
+		if ( !UI_SaberValidForPlayerInMP( saber ) )
+		{
+			trap_Cvar_Set( "ui_saber2", "kyle" );
+			trap_Cvar_VariableStringBuffer("ui_saber2", saber, MAX_QPATH );
+		}
+	}
+	//read this from the sabers.cfg
+	UI_SaberTypeForSaber( saber, saberTypeString );
+	if ( saberTypeString[0] )
+	{
+		saberType = TranslateSaberType( saberTypeString );
+	}
+
+	switch ( uiInfo.movesTitleIndex )
+	{
+	case 0://MD_ACROBATICS:
+		break;
+	case 1://MD_SINGLE_FAST:
+	case 2://MD_SINGLE_MEDIUM:
+	case 3://MD_SINGLE_STRONG:
+		if ( saberType != SABER_SINGLE )
+		{
+			Q_strncpyz(saber,"single_1",MAX_QPATH);
+		}
+		break;
+	case 4://MD_DUAL_SABERS:
+		if ( saberType != SABER_SINGLE )
+		{
+			Q_strncpyz(saber,"single_1",MAX_QPATH);
+		}
+		break;
+	case 5://MD_SABER_STAFF:
+		if ( saberType == SABER_SINGLE || saberType == SABER_NONE )
+		{
+			Q_strncpyz(saber,"dual_1",MAX_QPATH);
+		}
+		break;
+	}
+
+}
+
+void UI_SaberDrawBlades( itemDef_t *item, vec3_t origin, vec3_t angles )
+{
+	//NOTE: only allows one saber type in view at a time
+	char saber[MAX_QPATH];
+	int saberNum = 0;
+	int saberModel = 0;
+	int	numSabers = 1;
+
+	if ( (item->flags&ITF_ISCHARACTER)//hacked sabermoves sabers in character's hand
+		&& uiInfo.movesTitleIndex == 4 /*MD_DUAL_SABERS*/ )
+	{
+		numSabers = 2;
+	}
+
+	for ( saberNum = 0; saberNum < numSabers; saberNum++ )
+	{
+		if ( (item->flags&ITF_ISCHARACTER) )//hacked sabermoves sabers in character's hand
+		{
+			UI_GetSaberForMenu( saber, saberNum );
+			saberModel = saberNum + 1;
+		}
+		else if ( (item->flags&ITF_ISSABER) )
+		{
+			trap_Cvar_VariableStringBuffer("ui_saber", saber, sizeof(saber) );
+			if ( !UI_SaberValidForPlayerInMP( saber ) )
+			{
+				trap_Cvar_Set( "ui_saber", "kyle" );
+				trap_Cvar_VariableStringBuffer("ui_saber", saber, sizeof(saber) );
+			}
+			saberModel = 0;
+		}
+		else if ( (item->flags&ITF_ISSABER2) )
+		{
+			trap_Cvar_VariableStringBuffer("ui_saber2", saber, sizeof(saber) );
+			if ( !UI_SaberValidForPlayerInMP( saber ) )
+			{
+				trap_Cvar_Set( "ui_saber2", "kyle" );
+				trap_Cvar_VariableStringBuffer("ui_saber2", saber, sizeof(saber) );
+			}
+			saberModel = 0;
+		}
+		else
+		{
+			return;
+		}
+		if ( saber[0] )
+		{
+			saberType_t saberType;
+			int curBlade = 0;
+			int numBlades = UI_SaberNumBladesForSaber( saber );
+			if ( numBlades )
+			{//okay, here we go, time to draw each blade...
+				char	saberTypeString[MAX_QPATH]={0};
+				UI_SaberTypeForSaber( saber, saberTypeString );
+				saberType = TranslateSaberType( saberTypeString );
+				for ( curBlade = 0; curBlade < numBlades; curBlade++ )
+				{
+					UI_SaberDrawBlade( item, saber, saberModel, saberType, origin, angles, curBlade );
+				}
+			}
+		}
+	}
+}
+
+void UI_SaberAttachToChar( itemDef_t *item )
+{
+	int	numSabers = 1;
+ 	int	saberNum = 0;
+
+	if ( trap_G2API_HasGhoul2ModelOnIndex(&(item->ghoul2),2) )
+	{//remove any extra models
+		trap_G2API_RemoveGhoul2Model(&(item->ghoul2), 2);
+	}
+	if ( trap_G2API_HasGhoul2ModelOnIndex(&(item->ghoul2),1) )
+	{//remove any extra models
+		trap_G2API_RemoveGhoul2Model(&(item->ghoul2), 1);
+	}
+
+	if ( uiInfo.movesTitleIndex == 4 /*MD_DUAL_SABERS*/ )
+	{
+		numSabers = 2;
+	}
+
+	for ( saberNum = 0; saberNum < numSabers; saberNum++ )
+	{
+		//bolt sabers
+		char modelPath[MAX_QPATH];
+		char skinPath[MAX_QPATH];
+		char saber[MAX_QPATH]; 
+
+		UI_GetSaberForMenu( saber, saberNum );
+
+		if ( UI_SaberModelForSaber( saber, modelPath ) )
+		{//successfully found a model
+			int g2Saber = trap_G2API_InitGhoul2Model( &(item->ghoul2), modelPath, 0, 0, 0, 0, 0 ); //add the model
+			if ( g2Saber )
+			{
+				int boltNum;
+				//get the customSkin, if any
+				if ( UI_SaberSkinForSaber( saber, skinPath ) )
+				{
+					int g2skin = trap_R_RegisterSkin(skinPath);
+					trap_G2API_SetSkin( item->ghoul2, g2Saber, 0, g2skin );//this is going to set the surfs on/off matching the skin file
+				}
+				else
+				{
+					trap_G2API_SetSkin( item->ghoul2, g2Saber, 0, 0 );//turn off custom skin
+				}
+				if ( saberNum == 0 )
+				{
+					boltNum = trap_G2API_AddBolt( item->ghoul2, 0, "*r_hand");
+				}
+				else
+				{
+					boltNum = trap_G2API_AddBolt( item->ghoul2, 0, "*l_hand");
+				}
+				trap_G2API_AttachG2Model( item->ghoul2, g2Saber, item->ghoul2, boltNum, 0);
+			}
+		}
+	}
+}
+
+#define MAX_SABER_HILTS	64
+
+// Fill in with saber hilts
+void UI_SaberGetHiltInfo( const char *singleHilts[MAX_SABER_HILTS], const char *staffHilts[MAX_SABER_HILTS] )
+{
+	int	numSingleHilts = 0, numStaffHilts = 0;
+	const char	*saberName;
+	const char	*token;
+	const char	*p;
+
+	//go through all the loaded sabers and put the valid ones in the proper list
+	p = SaberParms;
+	COM_BeginParseSession("saberlist");
+
+	// look for a saber
+	while ( p )
+	{
+		token = COM_ParseExt( &p, qtrue );
+		if ( token[0] == 0 )
+		{//invalid name
+			continue;
+		}
+		saberName = String_Alloc( token );
+		//see if there's a "{" on the next line
+		SkipRestOfLine( &p );
+
+		if ( UI_ParseLiteralSilent( &p, "{" ) ) 
+		{//nope, not a name, keep looking
+			continue;
+		}
+
+		//this is a saber name
+		if ( !UI_SaberValidForPlayerInMP( saberName ) )
+		{
+			SkipBracedSection( &p );
+			continue;
+		}
+
+		if ( UI_IsSaberTwoHanded( saberName ) )
+		{
+			if ( numStaffHilts < MAX_SABER_HILTS-1 )//-1 because we have to NULL terminate the list
+			{
+				staffHilts[numStaffHilts++] = saberName;
+			}
+			else
+			{
+				Com_Printf( "WARNING: too many two-handed sabers, ignoring saber '%s'\n", saberName );
+			}
+		}
+		else
+		{
+			if ( numSingleHilts < MAX_SABER_HILTS-1 )//-1 because we have to NULL terminate the list
+			{
+				singleHilts[numSingleHilts++] = saberName;
+			}
+			else
+			{
+				Com_Printf( "WARNING: too many one-handed sabers, ignoring saber '%s'\n", saberName );
+			}
+		}
+		//skip the whole braced section and move on to the next entry
+		SkipBracedSection( &p );
+	}
+	//null terminate the list so the UI code knows where to stop listing them
+	singleHilts[numSingleHilts] = NULL;
+	staffHilts[numStaffHilts] = NULL;
+}
\ No newline at end of file
diff --git a/codemp/ui/ui_shared.c b/codemp/ui/ui_shared.c
new file mode 100644
index 0000000..55fe8de
--- /dev/null
+++ b/codemp/ui/ui_shared.c
@@ -0,0 +1,10157 @@
+// 
+// string allocation/managment
+
+#ifndef CGAME
+	#include "ui_local.h"
+#endif
+#ifdef _XBOX
+#include "../client/client.h"
+#endif
+
+#include "ui_shared.h"
+#include "../game/bg_public.h"
+#include "../game/anims.h"
+#include "../ghoul2/G2.h"
+extern stringID_table_t animTable [MAX_ANIMATIONS+1];
+extern void UI_UpdateCharacterSkin( void );
+
+
+#define SCROLL_TIME_START					500
+#define SCROLL_TIME_ADJUST					150
+#define SCROLL_TIME_ADJUSTOFFSET			40
+#define SCROLL_TIME_FLOOR					20
+
+typedef struct scrollInfo_s {
+	int nextScrollTime;
+	int nextAdjustTime;
+	int adjustValue;
+	int scrollKey;
+	float xStart;
+	float yStart;
+	itemDef_t *item;
+	qboolean scrollDir;
+} scrollInfo_t;
+
+#ifdef _XBOX
+//extern void *Z_Malloc(int iSize, memtag_t eTag, qboolean bZeroit, int iAlign);
+//extern void Z_TagFree(memtag_t eTag);
+#endif
+
+
+#ifndef CGAME	// Defined in ui_main.c, not in the namespace
+extern vmCvar_t	ui_char_color_red;
+extern vmCvar_t	ui_char_color_green;
+extern vmCvar_t	ui_char_color_blue;
+extern vmCvar_t	se_language;
+
+// Some extern functions hoisted from the middle of this file to get all the non-cgame,
+// non-namespace stuff together
+extern void UI_SaberDrawBlades( itemDef_t *item, vec3_t origin, vec3_t angles );
+
+extern void UI_SaberLoadParms( void );
+extern qboolean ui_saber_parms_parsed;
+extern void UI_CacheSaberGlowGraphics( void );
+
+#endif //
+
+#include "../namespace_begin.h"
+
+#ifdef CGAME
+
+extern int trap_Key_GetCatcher( void ) ;
+extern void trap_Key_SetCatcher( int catcher );
+extern void trap_Cvar_Set( const char *var_name, const char *value );
+
+#endif
+
+//JLF DEMOCODE
+#ifdef _XBOX
+
+//support for attract mode demo timer
+#define DEMO_TIME_MAX  45000 //g_demoTimeBeforeStart
+int g_demoLastKeypress = 0;  //milliseconds
+bool  g_ReturnToSplash = false;
+bool g_runningDemo = false;
+
+void G_DemoStart();
+void G_DemoEnd();
+void G_DemoFrame();
+void G_DemoKeypress();
+
+void PlayDemo();
+//void UpdateDemoTimer();
+bool TestDemoTimer();
+//END DEMOCODE
+
+//JLF used by sliders
+#define TICK_COUNT 20
+
+//JLF MORE PROTOTYPES
+qboolean Item_HandleSelectionNext(itemDef_t * item);
+qboolean Item_HandleSelectionPrev(itemDef_t * item);
+
+#endif	// _XBOX
+
+qboolean Item_SetFocus(itemDef_t *item, float x, float y);
+
+static scrollInfo_t scrollInfo;
+
+static void (*captureFunc) (void *p) = 0;
+static void *captureData = NULL;
+static itemDef_t *itemCapture = NULL;   // item that has the mouse captured ( if any )
+
+displayContextDef_t *DC = NULL;
+
+static qboolean g_waitingForKey = qfalse;
+static qboolean g_editingField = qfalse;
+
+static itemDef_t *g_bindItem = NULL;
+static itemDef_t *g_editItem = NULL;
+
+menuDef_t Menus[MAX_MENUS];      // defined menus
+int menuCount = 0;               // how many
+
+menuDef_t *menuStack[MAX_OPEN_MENUS];
+int openMenuCount = 0;
+
+static qboolean debugMode = qfalse;
+
+#define DOUBLE_CLICK_DELAY 300
+static int lastListBoxClickTime = 0;
+
+void Item_RunScript(itemDef_t *item, const char *s);
+void Item_SetupKeywordHash(void);
+void Menu_SetupKeywordHash(void);
+int BindingIDFromName(const char *name);
+qboolean Item_Bind_HandleKey(itemDef_t *item, int key, qboolean down);
+itemDef_t *Menu_SetPrevCursorItem(menuDef_t *menu);
+itemDef_t *Menu_SetNextCursorItem(menuDef_t *menu);
+static qboolean Menu_OverActiveItem(menuDef_t *menu, float x, float y);
+static void Item_TextScroll_BuildLines ( itemDef_t* item );
+void Menu_SetItemText(const menuDef_t *menu,const char *itemName, const char *text);
+extern qboolean ItemParse_asset_model_go( itemDef_t *item, const char *name,int *runTimeLength );
+extern qboolean ItemParse_model_g2anim_go( itemDef_t *item, const char *animName );
+
+
+#ifdef CGAME
+#define MEM_POOL_SIZE  128 * 1024
+#define UI_ALLOCATION_TAG	TAG_CG_UI_ALLOC
+#else
+//#define MEM_POOL_SIZE  1024 * 1024
+#define MEM_POOL_SIZE  2048 * 1024
+#define	UI_ALLOCATION_TAG	TAG_UI_ALLOC
+#endif
+
+#ifndef _XBOX
+static char		memoryPool[MEM_POOL_SIZE];
+#endif // _XBOX
+
+static int		allocPoint, outOfMemory;
+
+
+typedef struct  itemFlagsDef_s {
+	char *string;
+	int value;
+}	itemFlagsDef_t;
+
+itemFlagsDef_t itemFlags [] = {
+"WINDOW_INACTIVE",		WINDOW_INACTIVE,
+NULL,					(int) NULL
+};
+
+char *styles [] = {
+"WINDOW_STYLE_EMPTY",
+"WINDOW_STYLE_FILLED",
+"WINDOW_STYLE_GRADIENT",
+"WINDOW_STYLE_SHADER",
+"WINDOW_STYLE_TEAMCOLOR",
+"WINDOW_STYLE_CINEMATIC",
+NULL
+};
+
+char *alignment [] = {
+"ITEM_ALIGN_LEFT",
+"ITEM_ALIGN_CENTER",
+"ITEM_ALIGN_RIGHT",
+NULL
+};
+
+char *types [] = {
+"ITEM_TYPE_TEXT",
+"ITEM_TYPE_BUTTON",
+"ITEM_TYPE_RADIOBUTTON",
+"ITEM_TYPE_CHECKBOX",
+"ITEM_TYPE_EDITFIELD",
+"ITEM_TYPE_COMBO",
+"ITEM_TYPE_LISTBOX",
+"ITEM_TYPE_MODEL",
+"ITEM_TYPE_OWNERDRAW",
+"ITEM_TYPE_NUMERICFIELD",
+"ITEM_TYPE_SLIDER",
+"ITEM_TYPE_YESNO",
+"ITEM_TYPE_MULTI",
+"ITEM_TYPE_BIND",
+"ITEM_TYPE_TEXTSCROLL",
+NULL
+};
+
+
+extern int MenuFontToHandle(int iMenuFont);
+
+
+
+
+/*
+===============
+UI_Alloc
+===============
+*/
+void *UI_Alloc( int size ) {
+#ifdef _XBOX
+
+	allocPoint += size;
+	return Z_Malloc(size, UI_ALLOCATION_TAG, qfalse, 4);
+
+#else	// _XBOX
+
+	char	*p; 
+
+	if ( allocPoint + size > MEM_POOL_SIZE ) {
+		outOfMemory = qtrue;
+		if (DC->Print) {
+			DC->Print("UI_Alloc: Failure. Out of memory!\n");
+		}
+    //DC->trap_Print(S_COLOR_YELLOW"WARNING: UI Out of Memory!\n");
+		return NULL;
+	}
+
+	p = &memoryPool[allocPoint];
+
+	allocPoint += ( size + 15 ) & ~15;
+
+	return p;
+#endif
+}
+
+/*
+===============
+UI_InitMemory
+===============
+*/
+void UI_InitMemory( void ) {
+	allocPoint = 0;
+	outOfMemory = qfalse;
+#ifdef _XBOX
+	Z_TagFree(UI_ALLOCATION_TAG);
+#endif
+}
+
+qboolean UI_OutOfMemory() {
+	return outOfMemory;
+}
+
+
+
+
+
+#define HASH_TABLE_SIZE 2048
+/*
+================
+return a hash value for the string
+================
+*/
+static long hashForString(const char *str) {
+	int		i;
+	long	hash;
+	char	letter;
+
+	hash = 0;
+	i = 0;
+	while (str[i] != '\0') {
+		letter = tolower((unsigned char)str[i]);
+		hash+=(long)(letter)*(i+119);
+		i++;
+	}
+	hash &= (HASH_TABLE_SIZE-1);
+	return hash;
+}
+
+typedef struct stringDef_s {
+	struct stringDef_s *next;
+	const char *str;
+} stringDef_t;
+
+static int strPoolIndex = 0;
+static char strPool[STRING_POOL_SIZE];
+
+static int strHandleCount = 0;
+static stringDef_t *strHandle[HASH_TABLE_SIZE];
+
+
+const char *String_Alloc(const char *p) {
+	int len;
+	long hash;
+	stringDef_t *str, *last;
+	static const char *staticNULL = "";
+
+	if (p == NULL) {
+		return NULL;
+	}
+
+	if (*p == 0) {
+		return staticNULL;
+	}
+
+	hash = hashForString(p);
+
+	str = strHandle[hash];
+	while (str) {
+		if (strcmp(p, str->str) == 0) {
+			return str->str;
+		}
+		str = str->next;
+	}
+
+	len = strlen(p);
+	if (len + strPoolIndex + 1 < STRING_POOL_SIZE) {
+		int ph = strPoolIndex;
+		strcpy(&strPool[strPoolIndex], p);
+		strPoolIndex += len + 1;
+
+		str = strHandle[hash];
+		last = str;
+		while (last && last->next) 
+		{
+			last = last->next;
+		}
+
+		str  = (stringDef_t *) UI_Alloc(sizeof(stringDef_t));
+		str->next = NULL;
+		str->str = &strPool[ph];
+		if (last) {
+			last->next = str;
+		} else {
+			strHandle[hash] = str;
+		}
+		return &strPool[ph];
+	}
+
+	//Increase STRING_POOL_SIZE.
+	assert(0);
+	return NULL;
+}
+
+void String_Report() {
+	float f;
+	Com_Printf("Memory/String Pool Info\n");
+	Com_Printf("----------------\n");
+	f = strPoolIndex;
+	f /= STRING_POOL_SIZE;
+	f *= 100;
+	Com_Printf("String Pool is %.1f%% full, %i bytes out of %i used.\n", f, strPoolIndex, STRING_POOL_SIZE);
+	f = allocPoint;
+	f /= MEM_POOL_SIZE;
+	f *= 100;
+	Com_Printf("Memory Pool is %.1f%% full, %i bytes out of %i used.\n", f, allocPoint, MEM_POOL_SIZE);
+}
+
+/*
+=================
+String_Init
+=================
+*/
+void String_Init() {
+	int i;
+	for (i = 0; i < HASH_TABLE_SIZE; i++) {
+		strHandle[i] = 0;
+	}
+	strHandleCount = 0;
+	strPoolIndex = 0;
+	menuCount = 0;
+	openMenuCount = 0;
+	UI_InitMemory();
+	Item_SetupKeywordHash();
+	Menu_SetupKeywordHash();
+	if (DC && DC->getBindingBuf) {
+		Controls_GetConfig();
+	}
+}
+
+/*
+=================
+PC_SourceWarning
+=================
+*/
+void PC_SourceWarning(int handle, char *format, ...) {
+	int line;
+	char filename[128];
+	va_list argptr;
+	static char string[4096];
+
+	va_start (argptr, format);
+	vsprintf (string, format, argptr);
+	va_end (argptr);
+
+	filename[0] = '\0';
+	line = 0;
+	trap_PC_SourceFileAndLine(handle, filename, &line);
+
+	Com_Printf(S_COLOR_YELLOW "WARNING: %s, line %d: %s\n", filename, line, string);
+}
+
+/*
+=================
+PC_SourceError
+=================
+*/
+void PC_SourceError(int handle, char *format, ...) {
+	int line;
+	char filename[128];
+	va_list argptr;
+	static char string[4096];
+
+	va_start (argptr, format);
+	vsprintf (string, format, argptr);
+	va_end (argptr);
+
+	filename[0] = '\0';
+	line = 0;
+	trap_PC_SourceFileAndLine(handle, filename, &line);
+
+	Com_Printf(S_COLOR_RED "ERROR: %s, line %d: %s\n", filename, line, string);
+}
+
+/*
+=================
+LerpColor
+=================
+*/
+void LerpColor(vec4_t a, vec4_t b, vec4_t c, float t)
+{
+	int i;
+
+	// lerp and clamp each component
+	for (i=0; i<4; i++)
+	{
+		c[i] = a[i] + t*(b[i]-a[i]);
+		if (c[i] < 0)
+			c[i] = 0;
+		else if (c[i] > 1.0)
+			c[i] = 1.0;
+	}
+}
+
+/*
+=================
+Float_Parse
+=================
+*/
+qboolean Float_Parse(char **p, float *f) {
+	char	*token;
+	token = COM_ParseExt((const char **)p, qfalse);
+	if (token && token[0] != 0) {
+		*f = atof(token);
+		return qtrue;
+	} else {
+		return qfalse;
+	}
+}
+
+/*
+=================
+PC_Float_Parse
+=================
+*/
+qboolean PC_Float_Parse(int handle, float *f) {
+	pc_token_t token;
+	int negative = qfalse;
+
+	if (!trap_PC_ReadToken(handle, &token))
+		return qfalse;
+	if (token.string[0] == '-') {
+		if (!trap_PC_ReadToken(handle, &token))
+			return qfalse;
+		negative = qtrue;
+	}
+	if (token.type != TT_NUMBER) {
+		PC_SourceError(handle, "expected float but found %s\n", token.string);
+		return qfalse;
+	}
+	if (negative)
+		*f = -token.floatvalue;
+	else
+		*f = token.floatvalue;
+	return qtrue;
+}
+
+/*
+=================
+Color_Parse
+=================
+*/
+qboolean Color_Parse(char **p, vec4_t *c) {
+	int i;
+	float f;
+
+	for (i = 0; i < 4; i++) {
+		if (!Float_Parse(p, &f)) {
+			return qfalse;
+		}
+		(*c)[i] = f;
+	}
+	return qtrue;
+}
+
+/*
+=================
+PC_Color_Parse
+=================
+*/
+qboolean PC_Color_Parse(int handle, vec4_t *c) {
+	int i;
+	float f;
+
+	for (i = 0; i < 4; i++) {
+		if (!PC_Float_Parse(handle, &f)) {
+			return qfalse;
+		}
+		(*c)[i] = f;
+	}
+	return qtrue;
+}
+
+/*
+=================
+Int_Parse
+=================
+*/
+qboolean Int_Parse(char **p, int *i) {
+	char	*token;
+	token = COM_ParseExt((const char **)p, qfalse);
+
+	if (token && token[0] != 0) {
+		*i = atoi(token);
+		return qtrue;
+	} else {
+		return qfalse;
+	}
+}
+
+/*
+=================
+PC_Int_Parse
+=================
+*/
+qboolean PC_Int_Parse(int handle, int *i) {
+	pc_token_t token;
+	int negative = qfalse;
+
+	if (!trap_PC_ReadToken(handle, &token))
+		return qfalse;
+	if (token.string[0] == '-') {
+		if (!trap_PC_ReadToken(handle, &token))
+			return qfalse;
+		negative = qtrue;
+	}
+	if (token.type != TT_NUMBER) {
+		PC_SourceError(handle, "expected integer but found %s\n", token.string);
+		return qfalse;
+	}
+	*i = token.intvalue;
+	if (negative)
+		*i = - *i;
+	return qtrue;
+}
+
+/*
+=================
+Rect_Parse
+=================
+*/
+qboolean Rect_Parse(char **p, rectDef_t *r) {
+	if (Float_Parse(p, &r->x)) {
+		if (Float_Parse(p, &r->y)) {
+			if (Float_Parse(p, &r->w)) {
+				if (Float_Parse(p, &r->h)) {
+					return qtrue;
+				}
+			}
+		}
+	}
+	return qfalse;
+}
+
+/*
+=================
+PC_Rect_Parse
+=================
+*/
+qboolean PC_Rect_Parse(int handle, rectDef_t *r) {
+	if (PC_Float_Parse(handle, &r->x)) {
+		if (PC_Float_Parse(handle, &r->y)) {
+			if (PC_Float_Parse(handle, &r->w)) {
+				if (PC_Float_Parse(handle, &r->h)) {
+					return qtrue;
+				}
+			}
+		}
+	}
+	return qfalse;
+}
+
+/*
+=================
+String_Parse
+=================
+*/
+qboolean String_Parse(char **p, const char **out) {
+	char *token;
+
+	token = COM_ParseExt((const char **)p, qfalse);
+	if (token && token[0] != 0) {
+		*(out) = String_Alloc(token);
+		return *(out)!=NULL;
+	}
+	return qfalse;
+}
+
+/*
+=================
+PC_String_Parse
+=================
+*/
+qboolean PC_String_Parse(int handle, const char **out) 
+{
+	static char*	squiggy = "}";
+	pc_token_t		token;
+
+	if (!trap_PC_ReadToken(handle, &token))
+	{
+		return qfalse;
+	}
+
+	// Save some memory by not return the end squiggy as an allocated string
+	if ( !Q_stricmp ( token.string, "}" ) )
+	{
+		*(out) = squiggy;
+	}
+	else
+	{
+		*(out) = String_Alloc(token.string);
+	}
+	return qtrue;
+}
+
+/*
+=================
+PC_Script_Parse
+=================
+*/
+qboolean PC_Script_Parse(int handle, const char **out) {
+	char script[2048];
+	pc_token_t token;
+
+	script[0] = 0;
+	// scripts start with { and have ; separated command lists.. commands are command, arg.. 
+	// basically we want everything between the { } as it will be interpreted at run time
+  
+	if (!trap_PC_ReadToken(handle, &token))
+		return qfalse;
+	if (Q_stricmp(token.string, "{") != 0) {
+	    return qfalse;
+	}
+
+	while ( 1 ) {
+		if (!trap_PC_ReadToken(handle, &token))
+			return qfalse;
+
+		if (Q_stricmp(token.string, "}") == 0) {
+			*out = String_Alloc(script);
+			return qtrue;
+		}
+
+		if (token.string[1] != '\0') {
+			Q_strcat(script, 2048, va("\"%s\"", token.string));
+		} else {
+			Q_strcat(script, 2048, token.string);
+		}
+		Q_strcat(script, 2048, " ");
+	}
+	return qfalse; 	// bk001105 - LCC   missing return value
+}
+
+// display, window, menu, item code
+// 
+
+/*
+==================
+Init_Display
+
+Initializes the display with a structure to all the drawing routines
+ ==================
+*/
+void Init_Display(displayContextDef_t *dc) {
+	DC = dc;
+}
+
+
+
+// type and style painting 
+
+void GradientBar_Paint(rectDef_t *rect, vec4_t color) {
+	// gradient bar takes two paints
+	DC->setColor( color );
+	DC->drawHandlePic(rect->x, rect->y, rect->w, rect->h, DC->Assets.gradientBar);
+	DC->setColor( NULL );
+}
+
+
+/*
+==================
+Window_Init
+
+Initializes a window structure ( windowDef_t ) with defaults
+ 
+==================
+*/
+void Window_Init(Window *w) {
+	memset(w, 0, sizeof(windowDef_t));
+	w->borderSize = 1;
+	w->foreColor[0] = w->foreColor[1] = w->foreColor[2] = w->foreColor[3] = 1.0;
+	w->cinematic = -1;
+}
+
+void Fade(int *flags, float *f, float clamp, int *nextTime, int offsetTime, qboolean bFlags, float fadeAmount) {
+  if (*flags & (WINDOW_FADINGOUT | WINDOW_FADINGIN)) {
+    if (DC->realTime > *nextTime) {
+      *nextTime = DC->realTime + offsetTime;
+      if (*flags & WINDOW_FADINGOUT) {
+        *f -= fadeAmount;
+        if (bFlags && *f <= 0.0) {
+          *flags &= ~(WINDOW_FADINGOUT | WINDOW_VISIBLE);
+        }
+      } else {
+        *f += fadeAmount;
+        if (*f >= clamp) {
+          *f = clamp;
+          if (bFlags) {
+            *flags &= ~WINDOW_FADINGIN;
+          }
+        }
+      }
+    }
+  }
+}
+
+
+
+void Window_Paint(Window *w, float fadeAmount, float fadeClamp, float fadeCycle) 
+{
+	//float bordersize = 0;
+	vec4_t color;
+	rectDef_t fillRect = w->rect;
+
+
+	if (debugMode) 
+	{
+		color[0] = color[1] = color[2] = color[3] = 1;
+		DC->drawRect(w->rect.x, w->rect.y, w->rect.w, w->rect.h, 1, color);
+	}
+
+	if (w == NULL || (w->style == 0 && w->border == 0)) 
+	{
+		return;
+	}
+
+	if (w->border != 0) 
+	{
+		fillRect.x += w->borderSize;
+		fillRect.y += w->borderSize;
+		fillRect.w -= w->borderSize + 1;
+		fillRect.h -= w->borderSize + 1;
+	}
+
+	if (w->style == WINDOW_STYLE_FILLED) 
+	{
+		// box, but possible a shader that needs filled
+		if (w->background) 
+		{
+			Fade(&w->flags, &w->backColor[3], fadeClamp, &w->nextTime, fadeCycle, qtrue, fadeAmount);
+			DC->setColor(w->backColor);
+			DC->drawHandlePic(fillRect.x, fillRect.y, fillRect.w, fillRect.h, w->background);
+			DC->setColor(NULL);
+		} 
+		else 
+		{
+			DC->fillRect(fillRect.x, fillRect.y, fillRect.w, fillRect.h, w->backColor);
+		}
+	} 
+	else if (w->style == WINDOW_STYLE_GRADIENT) 
+	{
+		GradientBar_Paint(&fillRect, w->backColor);
+	// gradient bar
+	} 
+	else if (w->style == WINDOW_STYLE_SHADER) 
+	{
+#ifndef CGAME
+		if (w->flags & WINDOW_PLAYERCOLOR) 
+		{
+			vec4_t	color;
+			color[0] = ui_char_color_red.integer/255.0f;
+			color[1] = ui_char_color_green.integer/255.0f;
+			color[2] = ui_char_color_blue.integer/255.0f;
+			color[3] = 1;
+			DC->setColor(color);
+		}
+#endif // 
+
+		if (w->flags & WINDOW_FORECOLORSET) 
+		{
+			DC->setColor(w->foreColor);
+		}
+		DC->drawHandlePic(fillRect.x, fillRect.y, fillRect.w, fillRect.h, w->background);
+		DC->setColor(NULL);
+	} 
+	else if (w->style == WINDOW_STYLE_TEAMCOLOR) 
+	{
+		if (DC->getTeamColor) 
+		{
+			DC->getTeamColor(&color);
+			DC->fillRect(fillRect.x, fillRect.y, fillRect.w, fillRect.h, color);
+		}
+	} 
+	else if (w->style == WINDOW_STYLE_CINEMATIC) 
+	{
+		if (w->cinematic == -1) 
+		{
+			w->cinematic = DC->playCinematic(w->cinematicName, fillRect.x, fillRect.y, fillRect.w, fillRect.h);
+			if (w->cinematic == -1) 
+			{
+				w->cinematic = -2;
+			}
+		} 
+		if (w->cinematic >= 0) 
+		{
+			DC->runCinematicFrame(w->cinematic);
+			DC->drawCinematic(w->cinematic, fillRect.x, fillRect.y, fillRect.w, fillRect.h);
+		}
+	}
+
+	if (w->border == WINDOW_BORDER_FULL) 
+	{
+		// full
+		// HACK HACK HACK
+		if (w->style == WINDOW_STYLE_TEAMCOLOR) 
+		{
+			if (color[0] > 0) 
+			{				
+				// red
+				color[0] = 1;
+				color[1] = color[2] = .5;
+			} 
+			else 
+			{
+				color[2] = 1;
+				color[0] = color[1] = .5;
+			}
+			color[3] = 1;
+			DC->drawRect(w->rect.x, w->rect.y, w->rect.w, w->rect.h, w->borderSize, color);
+		} 
+		else 
+		{
+			DC->drawRect(w->rect.x, w->rect.y, w->rect.w, w->rect.h, w->borderSize, w->borderColor);
+		}
+	} 
+	else if (w->border == WINDOW_BORDER_HORZ) 
+	{
+		// top/bottom
+		DC->setColor(w->borderColor);
+		DC->drawTopBottom(w->rect.x, w->rect.y, w->rect.w, w->rect.h, w->borderSize);
+		DC->setColor( NULL );
+	} 
+	else if (w->border == WINDOW_BORDER_VERT) 
+	{
+		// left right
+		DC->setColor(w->borderColor);
+		DC->drawSides(w->rect.x, w->rect.y, w->rect.w, w->rect.h, w->borderSize);
+		DC->setColor( NULL );
+	} 
+	else if (w->border == WINDOW_BORDER_KCGRADIENT) 
+	{
+		// this is just two gradient bars along each horz edge
+		rectDef_t r = w->rect;
+		r.h = w->borderSize;
+		GradientBar_Paint(&r, w->borderColor);
+		r.y = w->rect.y + w->rect.h - 1;
+		GradientBar_Paint(&r, w->borderColor);
+	}
+}
+
+
+void Item_SetScreenCoords(itemDef_t *item, float x, float y) 
+{ 
+
+	if (item == NULL) 
+	{
+		return;
+	}
+
+	if (item->window.border != 0) 
+	{
+		x += item->window.borderSize;
+		y += item->window.borderSize;
+	}
+
+	item->window.rect.x = x + item->window.rectClient.x;
+	item->window.rect.y = y + item->window.rectClient.y;
+	item->window.rect.w = item->window.rectClient.w;
+	item->window.rect.h = item->window.rectClient.h;
+
+	// force the text rects to recompute
+	item->textRect.w = 0;
+	item->textRect.h = 0;
+
+	switch ( item->type)
+	{
+		case ITEM_TYPE_TEXTSCROLL:
+		{
+			textScrollDef_t *scrollPtr = (textScrollDef_t*)item->typeData;
+			if ( scrollPtr )
+			{
+				scrollPtr->startPos = 0;
+				scrollPtr->endPos = 0;
+			}
+
+			Item_TextScroll_BuildLines ( item );
+
+			break;
+		}
+	}
+}
+
+// FIXME: consolidate this with nearby stuff
+void Item_UpdatePosition(itemDef_t *item) 
+{
+	float x, y;
+	menuDef_t *menu;
+  
+	if (item == NULL || item->parent == NULL) 
+	{
+		return;
+	}
+
+	menu = (menuDef_t *) item->parent;
+
+	x = menu->window.rect.x;
+	y = menu->window.rect.y;
+  
+	if (menu->window.border != 0) 
+	{
+		x += menu->window.borderSize;
+		y += menu->window.borderSize;
+	}
+
+	Item_SetScreenCoords(item, x, y);
+
+}
+
+// menus
+void Menu_UpdatePosition(menuDef_t *menu) {
+  int i;
+  float x, y;
+
+  if (menu == NULL) {
+    return;
+  }
+  
+  x = menu->window.rect.x;
+  y = menu->window.rect.y;
+  if (menu->window.border != 0) {
+    x += menu->window.borderSize;
+    y += menu->window.borderSize;
+  }
+
+  for (i = 0; i < menu->itemCount; i++) {
+    Item_SetScreenCoords(menu->items[i], x, y);
+  }
+}
+
+void Menu_PostParse(menuDef_t *menu) {
+	if (menu == NULL) {
+		return;
+	}
+	if (menu->fullScreen) {
+		menu->window.rect.x = 0;
+		menu->window.rect.y = 0;
+		menu->window.rect.w = 640;
+		menu->window.rect.h = 480;
+	}
+	Menu_UpdatePosition(menu);
+}
+
+itemDef_t *Menu_ClearFocus(menuDef_t *menu) {
+  int i;
+  itemDef_t *ret = NULL;
+
+  if (menu == NULL) {
+    return NULL;
+  }
+
+  for (i = 0; i < menu->itemCount; i++) {
+    if (menu->items[i]->window.flags & WINDOW_HASFOCUS) {
+      ret = menu->items[i];
+    } 
+    menu->items[i]->window.flags &= ~WINDOW_HASFOCUS;
+    if (menu->items[i]->leaveFocus) {
+      Item_RunScript(menu->items[i], menu->items[i]->leaveFocus);
+    }
+  }
+ 
+  return ret;
+}
+
+qboolean IsVisible(int flags) {
+  return (flags & WINDOW_VISIBLE && !(flags & WINDOW_FADINGOUT));
+}
+
+qboolean Rect_ContainsPoint(rectDef_t *rect, float x, float y) {
+  if (rect) {
+    if (x > rect->x && x < rect->x + rect->w && y > rect->y && y < rect->y + rect->h) {
+      return qtrue;
+    }
+  }
+  return qfalse;
+}
+
+int Menu_ItemsMatchingGroup(menuDef_t *menu, const char *name) 
+{
+	int i;
+	int count = 0;
+
+	for (i = 0; i < menu->itemCount; i++) 
+	{
+		if ((!menu->items[i]->window.name) && (!menu->items[i]->window.group))
+		{
+			Com_Printf(S_COLOR_YELLOW"WARNING: item has neither name or group\n");
+			continue;
+		}
+
+		if (Q_stricmp(menu->items[i]->window.name, name) == 0 || 
+			(menu->items[i]->window.group && Q_stricmp(menu->items[i]->window.group, name) == 0)) 
+		{
+			count++;
+		} 
+	}
+
+	return count;
+}
+
+itemDef_t *Menu_GetMatchingItemByNumber(menuDef_t *menu, int index, const char *name) {
+  int i;
+  int count = 0;
+  for (i = 0; i < menu->itemCount; i++) {
+    if (Q_stricmp(menu->items[i]->window.name, name) == 0 || (menu->items[i]->window.group && Q_stricmp(menu->items[i]->window.group, name) == 0)) {
+      if (count == index) {
+        return menu->items[i];
+      }
+      count++;
+    } 
+  }
+  return NULL;
+}
+
+qboolean Script_SetColor ( itemDef_t *item, char **args ) 
+{
+	const char *name;
+	int i;
+	float f;
+	vec4_t *out;
+	
+	// expecting type of color to set and 4 args for the color
+	if (String_Parse(args, &name)) 
+	{
+		out = NULL;
+		if (Q_stricmp(name, "backcolor") == 0) 
+		{
+			out = &item->window.backColor;
+			item->window.flags |= WINDOW_BACKCOLORSET;
+		} 
+		else if (Q_stricmp(name, "forecolor") == 0) 
+		{
+			out = &item->window.foreColor;
+			item->window.flags |= WINDOW_FORECOLORSET;
+		} 
+		else if (Q_stricmp(name, "bordercolor") == 0) 
+		{
+			out = &item->window.borderColor;
+		}
+
+		if (out) 
+		{
+			for (i = 0; i < 4; i++) 
+			{
+				if (!Float_Parse(args, &f)) 
+				{
+					return qtrue;
+				}
+			(*out)[i] = f;
+			}
+		}
+	}
+
+	return qtrue;
+}
+
+qboolean Script_SetAsset(itemDef_t *item, char **args) 
+{
+	const char *name;
+	// expecting name to set asset to
+	if (String_Parse(args, &name)) 
+	{
+		// check for a model 
+		if (item->type == ITEM_TYPE_MODEL) 
+		{
+		}
+	}
+	return qtrue;
+}
+
+qboolean Script_SetBackground(itemDef_t *item, char **args) 
+{
+	const char *name;
+	// expecting name to set asset to
+	if (String_Parse(args, &name)) 
+	{
+		item->window.background = DC->registerShaderNoMip(name);
+	}
+	return qtrue;
+}
+
+qboolean Script_SetItemRectCvar(itemDef_t *item, char **args) 
+{
+	const char	*itemName;
+	const char	*cvarName;
+	char		cvarBuf[1024];
+	const char	*holdVal;
+	char		*holdBuf;
+	itemDef_t	*item2=0;
+	menuDef_t	*menu;	
+
+	// expecting item group and cvar to get value from
+	if (String_Parse(args, &itemName) && String_Parse(args, &cvarName)) 
+	{
+		item2 = Menu_FindItemByName((menuDef_t *) item->parent, itemName);
+
+		if (item2)
+		{
+			// get cvar data
+			DC->getCVarString(cvarName, cvarBuf, sizeof(cvarBuf));
+			
+			holdBuf = cvarBuf;
+			if (String_Parse(&holdBuf,&holdVal))
+			{
+				menu = (menuDef_t *) item->parent;
+
+				item2->window.rectClient.x = atof(holdVal) + menu->window.rect.x;
+				if (String_Parse(&holdBuf,&holdVal))
+				{
+					item2->window.rectClient.y = atof(holdVal) + menu->window.rect.y;
+					if (String_Parse(&holdBuf,&holdVal))
+					{
+						item2->window.rectClient.w = atof(holdVal);
+						if (String_Parse(&holdBuf,&holdVal))
+						{
+							item2->window.rectClient.h = atof(holdVal);
+
+							item2->window.rect.x = item2->window.rectClient.x;
+							item2->window.rect.y = item2->window.rectClient.y;
+							item2->window.rect.w = item2->window.rectClient.w;
+							item2->window.rect.h = item2->window.rectClient.h;
+
+							return qtrue;
+						}
+					}
+				}
+			}
+		}
+	}
+
+	// Default values in case things screw up
+	if (item2)
+	{
+		item2->window.rectClient.x = 0;
+		item2->window.rectClient.y = 0;
+		item2->window.rectClient.w = 0;
+		item2->window.rectClient.h = 0;
+	}
+
+//	Com_Printf(S_COLOR_YELLOW"WARNING: SetItemRectCvar: problems. Set cvar to 0's\n" );
+
+	return qtrue;
+}
+
+qboolean Script_SetItemBackground(itemDef_t *item, char **args) 
+{
+	const char *itemName;
+	const char *name;
+
+	// expecting name of shader
+	if (String_Parse(args, &itemName) && String_Parse(args, &name)) 
+	{
+		Menu_SetItemBackground((menuDef_t *) item->parent, itemName, name);
+	}
+	return qtrue;
+}
+
+qboolean Script_SetItemText(itemDef_t *item, char **args) 
+{
+	const char *itemName;
+	const char *text;
+
+	// expecting text
+	if (String_Parse(args, &itemName) && String_Parse(args, &text)) 
+	{
+		Menu_SetItemText((menuDef_t *) item->parent, itemName, text);
+	}
+	return qtrue;
+}
+
+
+itemDef_t *Menu_FindItemByName(menuDef_t *menu, const char *p) {
+  int i;
+  if (menu == NULL || p == NULL) {
+    return NULL;
+  }
+
+  for (i = 0; i < menu->itemCount; i++) {
+    if (Q_stricmp(p, menu->items[i]->window.name) == 0) {
+      return menu->items[i];
+    }
+  }
+
+  return NULL;
+}
+
+qboolean Script_SetTeamColor(itemDef_t *item, char **args) 
+{
+	if (DC->getTeamColor) 
+	{
+		int i;
+		vec4_t color;
+		DC->getTeamColor(&color);
+		for (i = 0; i < 4; i++) 
+		{
+			item->window.backColor[i] = color[i];
+		}
+	}
+	return qtrue;
+}
+
+qboolean Script_SetItemColor(itemDef_t *item, char **args) 
+{
+	const char *itemname;
+	const char *name;
+	vec4_t color;
+	int i;
+	vec4_t *out;
+
+	// expecting type of color to set and 4 args for the color
+	if (String_Parse(args, &itemname) && String_Parse(args, &name)) 
+	{
+		itemDef_t	*item2;
+		int			j,count;
+		char buff[1024];
+
+		// Is is specifying a cvar to get the item name from?
+		if (itemname[0] == '*')
+		{
+			itemname += 1;
+		    DC->getCVarString(itemname, buff, sizeof(buff));
+			itemname = buff;
+		}
+
+		count = Menu_ItemsMatchingGroup((menuDef_t *) item->parent, itemname);
+
+		if (!Color_Parse(args, &color)) 
+		{
+			return qtrue;
+		}
+
+		for (j = 0; j < count; j++) 
+		{
+			item2 = Menu_GetMatchingItemByNumber((menuDef_t *) item->parent, j, itemname);
+			if (item2 != NULL) 
+			{
+				out = NULL;
+				if (Q_stricmp(name, "backcolor") == 0) 
+				{
+					out = &item2->window.backColor;
+				} 
+				else if (Q_stricmp(name, "forecolor") == 0) 
+				{
+					out = &item2->window.foreColor;
+					item2->window.flags |= WINDOW_FORECOLORSET;
+				} 
+				else if (Q_stricmp(name, "bordercolor") == 0) 
+				{
+					out = &item2->window.borderColor;
+				}
+
+				if (out) 
+				{
+					for (i = 0; i < 4; i++) 
+					{
+						(*out)[i] = color[i];
+					}
+				}
+			}
+		}
+	}
+
+	return qtrue;
+}
+
+qboolean Script_SetItemColorCvar(itemDef_t *item, char **args) 
+{
+	const char *itemname;
+	char	*colorCvarName,*holdBuf,*holdVal;
+	char cvarBuf[1024];
+	const char *name;
+	vec4_t color;
+	int i;
+	vec4_t *out;
+
+	// expecting type of color to set and 4 args for the color
+	if (String_Parse(args, &itemname) && String_Parse(args, &name)) 
+	{
+		itemDef_t	*item2;
+		int			j,count;
+		char buff[1024];
+
+		// Is is specifying a cvar to get the item name from?
+		if (itemname[0] == '*')
+		{
+			itemname += 1;
+		    DC->getCVarString(itemname, buff, sizeof(buff));
+			itemname = buff;
+		}
+
+		count = Menu_ItemsMatchingGroup((menuDef_t *) item->parent, itemname);
+
+		// Get the cvar with the color
+		if (!String_Parse(args,(const char **) &colorCvarName))
+		{
+			return qtrue;
+		}
+		else
+		{
+			DC->getCVarString(colorCvarName, cvarBuf, sizeof(cvarBuf));
+			
+			holdBuf = cvarBuf;
+			if (String_Parse(&holdBuf,(const char **) &holdVal))
+			{
+				color[0] = atof(holdVal);
+				if (String_Parse(&holdBuf,(const char **) &holdVal))
+				{
+					color[1] = atof(holdVal);
+					if (String_Parse(&holdBuf,(const char **) &holdVal))
+					{
+						color[2] = atof(holdVal);
+						if (String_Parse(&holdBuf,(const char **) &holdVal))
+						{
+							color[3] = atof(holdVal);
+						}
+					}
+				}
+			}
+		}
+
+		for (j = 0; j < count; j++) 
+		{
+			item2 = Menu_GetMatchingItemByNumber((menuDef_t *) item->parent, j, itemname);
+			if (item2 != NULL) 
+			{
+				out = NULL;
+				if (Q_stricmp(name, "backcolor") == 0) 
+				{
+					out = &item2->window.backColor;
+				} 
+				else if (Q_stricmp(name, "forecolor") == 0) 
+				{
+					out = &item2->window.foreColor;
+					item2->window.flags |= WINDOW_FORECOLORSET;
+				} 
+				else if (Q_stricmp(name, "bordercolor") == 0) 
+				{
+					out = &item2->window.borderColor;
+				}
+
+				if (out) 
+				{
+					for (i = 0; i < 4; i++) 
+					{
+						(*out)[i] = color[i];
+					}
+				}
+			}
+		}
+	}
+
+	return qtrue;
+}
+
+qboolean Script_SetItemRect(itemDef_t *item, char **args) 
+{
+	const char *itemname;
+	rectDef_t *out;
+	rectDef_t rect;
+	menuDef_t	*menu;	
+
+	// expecting type of color to set and 4 args for the color
+	if (String_Parse(args, &itemname)) 
+	{
+		itemDef_t *item2;
+		int j;
+		int count = Menu_ItemsMatchingGroup((menuDef_t *) item->parent, itemname);
+
+		if (!Rect_Parse(args, &rect)) 
+		{
+			return qtrue;
+		}
+
+		menu = (menuDef_t *) item->parent;
+
+		for (j = 0; j < count; j++) 
+		{
+			item2 = Menu_GetMatchingItemByNumber(menu, j, itemname);
+			if (item2 != NULL) 
+			{
+				out = &item2->window.rect;
+
+				if (out) 
+				{
+					item2->window.rect.x = rect.x  + menu->window.rect.x;
+					item2->window.rect.y = rect.y  + menu->window.rect.y;
+					item2->window.rect.w = rect.w;
+					item2->window.rect.h = rect.h;					
+				}
+			}
+		}
+	}
+	return qtrue;
+}
+
+void Menu_ShowGroup (menuDef_t *menu, char *groupName, qboolean showFlag)
+{
+	itemDef_t *item;
+	int count,j;
+
+	count = Menu_ItemsMatchingGroup( menu, groupName);
+	for (j = 0; j < count; j++) 
+	{
+		item = Menu_GetMatchingItemByNumber( menu, j, groupName);
+		if (item != NULL) 
+		{
+			if (showFlag) 
+			{
+				item->window.flags |= WINDOW_VISIBLE;
+			} 
+			else 
+			{
+				item->window.flags &= ~(WINDOW_VISIBLE | WINDOW_HASFOCUS);
+			}
+		}
+	}
+}
+
+void Menu_ShowItemByName(menuDef_t *menu, const char *p, qboolean bShow) {
+	itemDef_t *item;
+	int i;
+	int count = Menu_ItemsMatchingGroup(menu, p);
+	for (i = 0; i < count; i++) {
+		item = Menu_GetMatchingItemByNumber(menu, i, p);
+		if (item != NULL) {
+			if (bShow) {
+				item->window.flags |= WINDOW_VISIBLE;
+			} else {
+				item->window.flags &= ~WINDOW_VISIBLE;
+				// stop cinematics playing in the window
+				if (item->window.cinematic >= 0) {
+					DC->stopCinematic(item->window.cinematic);
+					item->window.cinematic = -1;
+				}
+			}
+		}
+	}
+}
+
+void Menu_FadeItemByName(menuDef_t *menu, const char *p, qboolean fadeOut) {
+  itemDef_t *item;
+  int i;
+  int count = Menu_ItemsMatchingGroup(menu, p);
+  for (i = 0; i < count; i++) {
+    item = Menu_GetMatchingItemByNumber(menu, i, p);
+    if (item != NULL) {
+      if (fadeOut) {
+        item->window.flags |= (WINDOW_FADINGOUT | WINDOW_VISIBLE);
+        item->window.flags &= ~WINDOW_FADINGIN;
+      } else {
+        item->window.flags |= (WINDOW_VISIBLE | WINDOW_FADINGIN);
+        item->window.flags &= ~WINDOW_FADINGOUT;
+      }
+    }
+  }
+}
+
+menuDef_t *Menus_FindByName(const char *p) {
+  int i;
+  for (i = 0; i < menuCount; i++) {
+    if (Q_stricmp(Menus[i].window.name, p) == 0) {
+      return &Menus[i];
+    } 
+  }
+  return NULL;
+}
+
+void Menus_ShowByName(const char *p) {
+	menuDef_t *menu = Menus_FindByName(p);
+	if (menu) {
+		Menus_Activate(menu);
+	}
+}
+
+void Menus_OpenByName(const char *p) {
+  Menus_ActivateByName(p);
+}
+
+static void Menu_RunCloseScript(menuDef_t *menu) {
+	if (menu && menu->window.flags & WINDOW_VISIBLE && menu->onClose) {
+		itemDef_t item;
+    item.parent = menu;
+    Item_RunScript(&item, menu->onClose);
+	}
+}
+
+void Menus_CloseByName ( const char *p )
+{
+	menuDef_t *menu = Menus_FindByName(p);
+	
+	// If the menu wasnt found just exit
+	if (menu == NULL) 
+	{
+		return;
+	}
+
+	// Run the close script for the menu
+	Menu_RunCloseScript(menu);
+
+	// If this window had the focus then take it away
+	if ( menu->window.flags & WINDOW_HASFOCUS )
+	{	
+		// If there is something still in the open menu list then
+		// set it to have focus now
+		if ( openMenuCount )
+		{
+			// Subtract one from the open menu count to prepare to
+			// remove the top menu from the list
+			openMenuCount -= 1;
+
+			// Set the top menu to have focus now
+			menuStack[openMenuCount]->window.flags |= WINDOW_HASFOCUS;
+
+			// Remove the top menu from the list
+			menuStack[openMenuCount] = NULL;
+		}
+	}
+
+	// Window is now invisible and doenst have focus
+	menu->window.flags &= ~(WINDOW_VISIBLE | WINDOW_HASFOCUS);
+}
+
+int FPMessageTime = 0;
+
+void Menus_CloseAll() 
+{
+	int i;
+	
+	g_waitingForKey = qfalse;
+	
+	for (i = 0; i < menuCount; i++) 
+	{
+		Menu_RunCloseScript ( &Menus[i] );
+		Menus[i].window.flags &= ~(WINDOW_HASFOCUS | WINDOW_VISIBLE);
+	}
+
+	// Clear the menu stack
+	openMenuCount = 0;
+
+	FPMessageTime = 0;
+}
+
+qboolean Script_Show(itemDef_t *item, char **args) 
+{
+	const char *name;
+	if (String_Parse(args, &name)) 
+	{
+		Menu_ShowItemByName((menuDef_t *) item->parent, name, qtrue);
+	}
+	return qtrue;
+}
+
+qboolean Script_Hide(itemDef_t *item, char **args) 
+{
+	const char *name;
+	if (String_Parse(args, &name)) 
+	{
+		Menu_ShowItemByName((menuDef_t *) item->parent, name, qfalse);
+	}
+	return qtrue;
+}
+
+qboolean Script_FadeIn(itemDef_t *item, char **args) 
+{
+	const char *name;
+	if (String_Parse(args, &name)) 
+	{
+		Menu_FadeItemByName((menuDef_t *) item->parent, name, qfalse);
+	}
+
+	return qtrue;
+}
+
+qboolean Script_FadeOut(itemDef_t *item, char **args) 
+{
+	const char *name;
+	if (String_Parse(args, &name)) 
+	{
+		Menu_FadeItemByName((menuDef_t *) item->parent, name, qtrue);
+	}
+	return qtrue;
+}
+
+qboolean Script_Open(itemDef_t *item, char **args) 
+{
+	const char *name;
+	if (String_Parse(args, &name)) 
+	{
+		Menus_OpenByName(name);
+	}
+	return qtrue;
+}
+
+qboolean Script_Close(itemDef_t *item, char **args) 
+{
+	const char *name;
+	if (String_Parse(args, &name)) 
+	{
+		if (Q_stricmp(name, "all") == 0)
+		{
+			Menus_CloseAll();
+		}
+		else
+		{
+			Menus_CloseByName(name);
+		}
+	}
+	return qtrue;
+}
+
+//void Menu_TransitionItemByName(menuDef_t *menu, const char *p, rectDef_t rectFrom, rectDef_t rectTo, int time, float amt) 
+void Menu_TransitionItemByName(menuDef_t *menu, const char *p, const rectDef_t *rectFrom, const rectDef_t *rectTo, int time, float amt) 
+{
+	itemDef_t *item;
+	int i;
+	int count = Menu_ItemsMatchingGroup(menu, p);
+	for (i = 0; i < count; i++) 
+	{
+		item = Menu_GetMatchingItemByNumber(menu, i, p);
+		if (item != NULL) 
+		{
+			if (!rectFrom)
+			{
+				rectFrom = &item->window.rect;	//if there are more than one of these with the same name, they'll all use the FIRST one's FROM.
+			}
+			item->window.flags |= (WINDOW_INTRANSITION | WINDOW_VISIBLE);
+			item->window.offsetTime = time;
+			memcpy(&item->window.rectClient, rectFrom, sizeof(rectDef_t));
+			memcpy(&item->window.rectEffects, rectTo, sizeof(rectDef_t));
+			item->window.rectEffects2.x = abs(rectTo->x - rectFrom->x) / amt;
+			item->window.rectEffects2.y = abs(rectTo->y - rectFrom->y) / amt;
+			item->window.rectEffects2.w = abs(rectTo->w - rectFrom->w) / amt;
+			item->window.rectEffects2.h = abs(rectTo->h - rectFrom->h) / amt;
+
+			Item_UpdatePosition(item);
+		}
+	}
+}
+
+/*
+=================
+Menu_Transition3ItemByName
+=================
+*/
+//JLF
+#define _TRANS3
+#ifdef _TRANS3
+void Menu_Transition3ItemByName(menuDef_t *menu, const char *p, const float minx, const float miny, const float minz,
+								const float maxx, const float maxy, const float maxz, const float fovtx, const float fovty,
+								const int time, const float amt)
+{
+	itemDef_t *item;
+	int i;
+	int count = Menu_ItemsMatchingGroup(menu, p);
+	modelDef_t  * modelptr;
+	for (i = 0; i < count; i++) 
+	{
+		item = Menu_GetMatchingItemByNumber(menu, i, p);
+		if (item != NULL) 
+		{
+			if ( item->type == ITEM_TYPE_MODEL)
+			{
+				modelptr = (modelDef_t*)item->typeData;
+
+				item->window.flags |= (WINDOW_INTRANSITIONMODEL | WINDOW_VISIBLE);
+				item->window.offsetTime = time;
+				modelptr->fov_x2 = fovtx;
+				modelptr->fov_y2 = fovty;
+				VectorSet(modelptr->g2maxs2, maxx, maxy, maxz);
+				VectorSet(modelptr->g2mins2, minx, miny, minz);
+
+//				//modelptr->g2maxs2.x= maxx;
+//				modelptr->g2maxs2.y= maxy;
+//				modelptr->g2maxs2.z= maxz;
+//				modelptr->g2mins2.x= minx;
+//				modelptr->g2mins2.y= miny;
+//				modelptr->g2mins2.z= minz;
+
+//				VectorSet(modelptr->g2maxs2, maxx, maxy, maxz);
+
+				modelptr->g2maxsEffect[0] = abs(modelptr->g2maxs2[0] - modelptr->g2maxs[0]) / amt;
+				modelptr->g2maxsEffect[1] = abs(modelptr->g2maxs2[1] - modelptr->g2maxs[1]) / amt;
+				modelptr->g2maxsEffect[2] = abs(modelptr->g2maxs2[2] - modelptr->g2maxs[2]) / amt;
+
+				modelptr->g2minsEffect[0] = abs(modelptr->g2mins2[0] - modelptr->g2mins[0]) / amt;
+				modelptr->g2minsEffect[1] = abs(modelptr->g2mins2[1] - modelptr->g2mins[1]) / amt;
+				modelptr->g2minsEffect[2] = abs(modelptr->g2mins2[2] - modelptr->g2mins[2]) / amt;
+				
+
+				modelptr->fov_Effectx = abs(modelptr->fov_x2 - modelptr->fov_x) / amt;
+				modelptr->fov_Effecty = abs(modelptr->fov_y2 - modelptr->fov_y) / amt;
+			}
+				
+		}
+	}
+}
+
+#endif
+
+
+
+
+
+
+
+#define MAX_DEFERRED_SCRIPT		2048
+
+char		ui_deferredScript [ MAX_DEFERRED_SCRIPT ];
+itemDef_t*	ui_deferredScriptItem = NULL;
+
+/*
+=================
+Script_Defer
+
+Defers the rest of the script based on the defer condition.  The deferred
+portion of the script can later be run with the "rundeferred"
+=================
+*/
+qboolean Script_Defer ( itemDef_t* item, char **args )
+{
+	// Should the script be deferred?
+	if ( DC->deferScript ( (char**)args ) )
+	{
+		// Need the item the script was being run on
+		ui_deferredScriptItem = item;
+
+		// Save the rest of the script
+		Q_strncpyz ( ui_deferredScript, *args, MAX_DEFERRED_SCRIPT );
+
+		// No more running
+		return qfalse;
+	}
+
+	// Keep running the script, its ok
+	return qtrue;
+}
+
+/*
+=================
+Script_RunDeferred
+
+Runs the last deferred script, there can only be one script deferred at a 
+time so be careful of recursion
+=================
+*/
+qboolean Script_RunDeferred ( itemDef_t* item, char **args )
+{
+	// Make sure there is something to run.
+	if ( !ui_deferredScript[0] || !ui_deferredScriptItem )
+	{
+		return qtrue;
+	}
+
+	// Run the deferred script now
+	Item_RunScript ( ui_deferredScriptItem, ui_deferredScript );
+
+	return qtrue;
+}
+
+qboolean Script_Transition(itemDef_t *item, char **args) 
+{
+	const char *name;
+	rectDef_t rectFrom, rectTo;
+	int time;
+	float amt;
+
+	if (String_Parse(args, &name)) 
+	{
+	    if ( Rect_Parse(args, &rectFrom) && Rect_Parse(args, &rectTo) && Int_Parse(args, &time) && Float_Parse(args, &amt)) 
+		{
+			Menu_TransitionItemByName((menuDef_t *) item->parent, name, &rectFrom, &rectTo, time, amt);
+		}
+	}
+
+	return qtrue;
+}
+
+void Menu_OrbitItemByName(menuDef_t *menu, const char *p, float x, float y, float cx, float cy, int time) 
+{
+  itemDef_t *item;
+  int i;
+  int count = Menu_ItemsMatchingGroup(menu, p);
+  for (i = 0; i < count; i++) {
+    item = Menu_GetMatchingItemByNumber(menu, i, p);
+    if (item != NULL) {
+      item->window.flags |= (WINDOW_ORBITING | WINDOW_VISIBLE);
+      item->window.offsetTime = time;
+      item->window.rectEffects.x = cx;
+      item->window.rectEffects.y = cy;
+      item->window.rectClient.x = x;
+      item->window.rectClient.y = y;
+      Item_UpdatePosition(item);
+    }
+  }
+}
+
+void Menu_ItemDisable(menuDef_t *menu, char *name,int disableFlag)
+{
+	int	j,count;
+	itemDef_t *itemFound;
+
+	count = Menu_ItemsMatchingGroup(menu, name);
+	// Loop through all items that have this name
+	for (j = 0; j < count; j++) 
+	{
+		itemFound = Menu_GetMatchingItemByNumber( menu, j, name);
+		if (itemFound != NULL) 
+		{
+			itemFound->disabled = disableFlag;
+			// Just in case it had focus
+			itemFound->window.flags &= ~WINDOW_MOUSEOVER;
+		}
+	}
+}
+
+// Set item disable flags
+qboolean Script_Disable(itemDef_t *item, char **args) 
+{
+	char *name;
+	int	value;
+	menuDef_t *menu;
+
+	if (String_Parse(args, (const char **)&name)) 
+	{
+		char buff[1024];
+
+		// Is is specifying a cvar to get the item name from?
+		if (name[0] == '*')
+		{
+			name += 1;
+		    DC->getCVarString(name, buff, sizeof(buff));
+			name = buff;
+		}
+
+		if ( Int_Parse(args, &value)) 
+		{
+			menu = Menu_GetFocused();
+			Menu_ItemDisable(menu, name,value);
+		}
+	}
+
+	return qtrue;
+}
+
+
+// Scale the given item instantly.
+qboolean Script_Scale(itemDef_t *item, char **args) 
+{
+	const char *name;
+	float scale;
+	int	j,count;
+	itemDef_t *itemFound;
+	rectDef_t rectTo;
+
+	if (String_Parse(args, &name)) 
+	{
+		char buff[1024];
+
+		// Is is specifying a cvar to get the item name from?
+		if (name[0] == '*')
+		{
+			name += 1;
+		    DC->getCVarString(name, buff, sizeof(buff));
+			name = buff;
+		}
+
+		count = Menu_ItemsMatchingGroup((menuDef_t *) item->parent, name);
+
+		if ( Float_Parse(args, &scale)) 
+		{
+			for (j = 0; j < count; j++) 
+			{
+				itemFound = Menu_GetMatchingItemByNumber( (menuDef_t *) item->parent, j, name);
+				if (itemFound != NULL) 
+				{
+					rectTo.h = itemFound->window.rect.h * scale;
+					rectTo.w = itemFound->window.rect.w * scale;
+
+					rectTo.x = itemFound->window.rect.x + ((itemFound->window.rect.h - rectTo.h)/2);
+					rectTo.y = itemFound->window.rect.y + ((itemFound->window.rect.w - rectTo.w)/2);
+
+					Menu_TransitionItemByName((menuDef_t *) item->parent, name, 0, &rectTo, 1, 1);
+				}
+			}
+		}
+	}
+
+	return qtrue;
+}
+
+qboolean Script_Orbit(itemDef_t *item, char **args) 
+{
+	const char *name;
+	float cx, cy, x, y;
+	int time;
+
+	if (String_Parse(args, &name)) 
+	{
+		if ( Float_Parse(args, &x) && Float_Parse(args, &y) && Float_Parse(args, &cx) && Float_Parse(args, &cy) && Int_Parse(args, &time) ) 
+		{
+			Menu_OrbitItemByName((menuDef_t *) item->parent, name, x, y, cx, cy, time);
+		}
+	}
+
+	return qtrue;
+}
+
+qboolean Script_SetFocus(itemDef_t *item, char **args) 
+{
+  const char *name;
+  itemDef_t *focusItem;
+
+  if (String_Parse(args, &name)) {
+    focusItem = Menu_FindItemByName((menuDef_t *) item->parent, name);
+    if (focusItem && !(focusItem->window.flags & WINDOW_DECORATION) && !(focusItem->window.flags & WINDOW_HASFOCUS)) {
+      Menu_ClearFocus((menuDef_t *) item->parent);
+//JLF
+#ifdef _XBOX
+			Item_SetFocus(focusItem, 0,0); 
+#else
+			focusItem->window.flags |= WINDOW_HASFOCUS;
+#endif
+//END JLF
+
+      
+      if (focusItem->onFocus) {
+        Item_RunScript(focusItem, focusItem->onFocus);
+      }
+      if (DC->Assets.itemFocusSound) {
+        DC->startLocalSound( DC->Assets.itemFocusSound, CHAN_LOCAL_SOUND );
+      }
+    }
+  }
+
+	return qtrue;
+}
+
+qboolean Script_SetPlayerModel(itemDef_t *item, char **args) 
+{
+	const char *name;
+	if (String_Parse(args, &name)) 
+	{
+		DC->setCVar("model", name);
+	}
+
+	return qtrue;
+}
+
+/*
+=================
+ParseRect
+=================
+*/
+qboolean ParseRect(const char **p, rectDef_t *r) 
+{
+	if (!COM_ParseFloat(p, &r->x)) 
+	{
+		if (!COM_ParseFloat(p, &r->y)) 
+		{
+			if (!COM_ParseFloat(p, &r->w)) 
+			{
+				if (!COM_ParseFloat(p, &r->h)) 
+				{
+					return qtrue;
+				}
+			}
+		}
+	}
+	return qfalse;
+}
+/*
+=================
+Script_Transition2
+uses current origin instead of specifing a starting origin
+
+transition2		lfvscr		25 0 202 264  20 25
+=================
+*/
+qboolean Script_Transition2(itemDef_t *item, char **args) 
+{
+	const char *name;
+	rectDef_t rectTo;
+	int time;
+	float amt;
+
+	if (String_Parse(args, &name)) 
+	{
+		if ( ParseRect((const char **) args, &rectTo) && Int_Parse(args, &time) && !COM_ParseFloat((const char **) args, &amt)) 
+		{
+			Menu_TransitionItemByName((menuDef_t *) item->parent, name, 0, &rectTo, time, amt);
+		}
+		else
+		{
+			Com_Printf(S_COLOR_YELLOW"WARNING: Script_Transition2: error parsing '%s'\n", name );
+		}
+	}
+
+	return qtrue;
+}
+
+#ifdef _TRANS3
+/*
+JLF 
+=================
+Script_Transition3
+
+used exclusively with model views
+uses current origin instead of specifing a starting origin
+
+
+transition3		lfvscr		(min extent) (max extent) (fovx,y)  20 25
+=================
+*/
+qboolean Script_Transition3(itemDef_t *item, char **args) 
+{
+	const char *name;
+	const char *value;
+	float minx, miny, minz, maxx, maxy, maxz, fovtx, fovty;
+	int time;
+	float amt;
+
+	if (String_Parse(args, &name)) 
+	{	
+		if (String_Parse( args, &value))
+		{
+			minx = atof(value);
+			if (String_Parse( args, &value))
+			{	
+				miny = atof(value);
+				if (String_Parse( args, &value))
+				{
+					minz = atof(value);
+					if (String_Parse( args, &value))
+					{	
+						maxx = atof(value);
+						if (String_Parse( args, &value))
+						{
+							maxy = atof(value);
+							if (String_Parse( args, &value))
+							{
+								maxz = atof(value);
+								if (String_Parse( args, &value))
+								{
+									fovtx = atof(value);
+									if (String_Parse( args, &value))
+									{	
+										fovty = atof(value);
+										
+										if (String_Parse( args, &value))
+										{	
+											time = atoi(value);
+											if (String_Parse( args, &value))
+											{	
+												amt = atof(value);
+												//set up the variables
+												Menu_Transition3ItemByName((menuDef_t *) item->parent, 
+														name,
+														minx, miny, minz,
+														maxx, maxy, maxz, 
+														fovtx, fovty,
+														time, amt);
+												
+												return qtrue;
+											}
+										}
+									}
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+	Com_Printf(S_COLOR_YELLOW"WARNING: Script_Transition2: error parsing '%s'\n", name );
+	return qtrue;
+}
+#endif
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+qboolean Script_SetCvar(itemDef_t *item, char **args) 
+{
+	const char *cvar, *val;
+	if (String_Parse(args, &cvar) && String_Parse(args, &val)) 
+	{
+		DC->setCVar(cvar, val);
+	}
+	return qtrue;
+}
+
+qboolean Script_SetCvarToCvar(itemDef_t *item, char **args) {
+	const char *cvar, *val;
+	if (String_Parse(args, &cvar) && String_Parse(args, &val)) {
+		char cvarBuf[1024];
+		DC->getCVarString(val, cvarBuf, sizeof(cvarBuf));
+		DC->setCVar(cvar, cvarBuf);
+	}
+	return qtrue;
+}
+
+qboolean Script_Exec(itemDef_t *item, char **args) {
+	const char *val;
+	if (String_Parse(args, &val)) {
+		DC->executeText(EXEC_APPEND, va("%s ; ", val));
+	}
+	return qtrue;
+}
+
+qboolean Script_Play(itemDef_t *item, char **args) {
+	const char *val;
+	if (String_Parse(args, &val)) {
+		DC->startLocalSound(DC->registerSound(val), CHAN_AUTO);
+	}
+	return qtrue;
+}
+
+qboolean Script_playLooped(itemDef_t *item, char **args) {
+	const char *val;
+	if (String_Parse(args, &val)) {
+		DC->stopBackgroundTrack();
+		DC->startBackgroundTrack(val, val, qfalse);
+	}
+	return qtrue;
+}
+
+
+commandDef_t commandList[] =
+{
+  {"fadein", &Script_FadeIn},                   // group/name
+  {"fadeout", &Script_FadeOut},                 // group/name
+  {"show", &Script_Show},                       // group/name
+  {"hide", &Script_Hide},                       // group/name
+  {"setcolor", &Script_SetColor},               // works on this
+  {"open", &Script_Open},                       // nenu
+  {"close", &Script_Close},                     // menu
+  {"setasset", &Script_SetAsset},               // works on this
+  {"setbackground", &Script_SetBackground},     // works on this
+  {"setitemrectcvar", &Script_SetItemRectCvar},			// group/name
+  {"setitembackground", &Script_SetItemBackground},// group/name
+  {"setitemtext", &Script_SetItemText},			// group/name
+  {"setitemcolor", &Script_SetItemColor},       // group/name
+  {"setitemcolorcvar", &Script_SetItemColorCvar},// group/name
+  {"setitemrect", &Script_SetItemRect},			// group/name
+  {"setteamcolor", &Script_SetTeamColor},       // sets this background color to team color
+  {"setfocus", &Script_SetFocus},               // sets focus
+  {"setplayermodel", &Script_SetPlayerModel},   // sets model
+  {"transition", &Script_Transition},           // group/name
+  {"setcvar", &Script_SetCvar},					// name
+  {"setcvartocvar", &Script_SetCvarToCvar},     // name
+  {"exec", &Script_Exec},						// group/name
+  {"play", &Script_Play},						// group/name
+  {"playlooped", &Script_playLooped},           // group/name
+  {"orbit", &Script_Orbit},                     // group/name
+  {"scale",			&Script_Scale},				// group/name
+  {"disable",		&Script_Disable},			// group/name
+  {"defer",			&Script_Defer},				// 
+  {"rundeferred",	&Script_RunDeferred},		//
+  {"transition2",	&Script_Transition2},			// group/name
+};
+
+// Set all the items within a given menu, with the given itemName, to the given shader
+void Menu_SetItemBackground(const menuDef_t *menu,const char *itemName, const char *background) 
+{
+	itemDef_t	*item;
+	int			j, count;
+
+	if (!menu)	// No menu???
+	{
+		return;
+	}
+
+	count = Menu_ItemsMatchingGroup( (menuDef_t *) menu, itemName);
+
+	for (j = 0; j < count; j++) 
+	{
+		item = Menu_GetMatchingItemByNumber( (menuDef_t *) menu, j, itemName);
+		if (item != NULL) 
+		{
+			item->window.background = DC->registerShaderNoMip(background);
+		}
+	}
+}
+
+// Set all the items within a given menu, with the given itemName, to the given text
+void Menu_SetItemText(const menuDef_t *menu,const char *itemName, const char *text) 
+{
+	itemDef_t	*item;
+	int			j, count;
+
+	if (!menu)	// No menu???
+	{
+		return;
+	}
+
+	count = Menu_ItemsMatchingGroup( (menuDef_t *) menu, itemName);
+
+	for (j = 0; j < count; j++) 
+	{
+		item = Menu_GetMatchingItemByNumber( (menuDef_t *) menu, j, itemName);
+		if (item != NULL) 
+		{
+			if (text[0] == '*')
+			{
+				item->text = NULL;		// Null this out because this would take presidence over cvar text.
+				item->cvar = text+1;
+				// Just copying what was in ItemParse_cvar()
+				if ( item->typeData)
+				{
+					editFieldDef_t *editPtr;
+					editPtr = (editFieldDef_t*)item->typeData;
+					editPtr->minVal = -1;
+					editPtr->maxVal = -1;
+					editPtr->defVal = -1;
+				}
+			}
+			else
+			{
+				item->text = text;
+				if ( item->type == ITEM_TYPE_TEXTSCROLL )
+				{
+					textScrollDef_t *scrollPtr = (textScrollDef_t*)item->typeData;
+					if ( scrollPtr )
+					{
+						scrollPtr->startPos = 0;
+						scrollPtr->endPos = 0;
+					}
+
+					Item_TextScroll_BuildLines ( item );
+				}
+			}
+		}
+	}
+}
+
+int scriptCommandCount = sizeof(commandList) / sizeof(commandDef_t);
+
+void Item_RunScript(itemDef_t *item, const char *s) 
+{
+	char script[2048], *p;
+	int i;
+	qboolean bRan;
+
+	script[0] = 0;
+	
+	if (item && s && s[0]) 
+	{
+		Q_strcat(script, 2048, s);
+		p = script;
+		
+		while (1) 
+		{
+			const char *command;
+
+			// expect command then arguments, ; ends command, NULL ends script
+			if (!String_Parse(&p, &command)) 
+			{
+				return;
+			}
+
+			if (command[0] == ';' && command[1] == '\0') 
+			{
+				continue;
+			}
+
+			bRan = qfalse;
+			for (i = 0; i < scriptCommandCount; i++) 
+			{
+				if (Q_stricmp(command, commandList[i].name) == 0) 
+				{
+					// Allow a script command to stop processing the script
+					if ( !commandList[i].handler(item, &p) )
+					{
+						return;
+					}
+
+					bRan = qtrue;
+					break;
+				}
+			}
+
+			// not in our auto list, pass to handler
+			if (!bRan) 
+			{
+				DC->runScript(&p);
+			}
+		}
+	}
+}
+
+
+qboolean Item_EnableShowViaCvar(itemDef_t *item, int flag) {
+  char script[2048], *p;
+  if (item && item->enableCvar && *item->enableCvar && item->cvarTest && *item->cvarTest) {
+		char buff[2048];
+	  DC->getCVarString(item->cvarTest, buff, sizeof(buff));
+
+    Q_strncpyz(script, item->enableCvar, 2048);
+    p = script;
+    while (1) {
+      const char *val;
+      // expect value then ; or NULL, NULL ends list
+      if (!String_Parse(&p, &val)) {
+				return (item->cvarFlags & flag) ? qfalse : qtrue;
+      }
+
+      if (val[0] == ';' && val[1] == '\0') {
+        continue;
+      }
+
+			// enable it if any of the values are true
+			if (item->cvarFlags & flag) {
+        if (Q_stricmp(buff, val) == 0) {
+					return qtrue;
+				}
+			} else {
+				// disable it if any of the values are true
+        if (Q_stricmp(buff, val) == 0) {
+					return qfalse;
+				}
+			}
+
+    }
+		return (item->cvarFlags & flag) ? qfalse : qtrue;
+  }
+	return qtrue;
+}
+
+
+// will optionaly set focus to this item 
+qboolean Item_SetFocus(itemDef_t *item, float x, float y) {
+	int i;
+	itemDef_t *oldFocus;
+	sfxHandle_t *sfx = &DC->Assets.itemFocusSound;
+	qboolean playSound = qfalse;
+	menuDef_t *parent; // bk001206: = (menuDef_t*)item->parent;
+	// sanity check, non-null, not a decoration and does not already have the focus
+	if (item == NULL || item->window.flags & WINDOW_DECORATION || item->window.flags & WINDOW_HASFOCUS || !(item->window.flags & WINDOW_VISIBLE)) {
+		return qfalse;
+	}
+
+	// bk001206 - this can be NULL.
+	parent = (menuDef_t*)item->parent; 
+
+	// items can be enabled and disabled 
+	if (item->disabled) 
+	{
+		return qfalse;
+	}
+      
+	// items can be enabled and disabled based on cvars
+	if (item->cvarFlags & (CVAR_ENABLE | CVAR_DISABLE) && !Item_EnableShowViaCvar(item, CVAR_ENABLE)) {
+		return qfalse;
+	}
+
+	if (item->cvarFlags & (CVAR_SHOW | CVAR_HIDE) && !Item_EnableShowViaCvar(item, CVAR_SHOW)) {
+		return qfalse;
+	}
+
+	oldFocus = Menu_ClearFocus((menuDef_t *) item->parent);
+
+	if (item->type == ITEM_TYPE_TEXT) {
+		rectDef_t r;
+		r = item->textRect;
+		r.y -= r.h;
+
+//JLFMOUSE
+#ifndef _XBOX
+		if (Rect_ContainsPoint(&r, x, y)) 
+#endif
+		{
+			item->window.flags |= WINDOW_HASFOCUS;
+			if (item->focusSound) {
+				sfx = &item->focusSound;
+			}
+			playSound = qtrue;
+		}
+#ifndef _XBOX
+		else 
+#endif
+		{
+			if (oldFocus) {
+				oldFocus->window.flags |= WINDOW_HASFOCUS;
+				if (oldFocus->onFocus) {
+					Item_RunScript(oldFocus, oldFocus->onFocus);
+				}
+			}
+		}
+	} else {
+	    item->window.flags |= WINDOW_HASFOCUS;
+		if (item->onFocus) {
+			Item_RunScript(item, item->onFocus);
+		}
+		if (item->focusSound) {
+			sfx = &item->focusSound;
+		}
+		playSound = qtrue;
+	}
+
+	if (playSound && sfx) {
+		DC->startLocalSound( *sfx, CHAN_LOCAL_SOUND );
+	}
+
+	for (i = 0; i < parent->itemCount; i++) {
+		if (parent->items[i] == item) {
+			parent->cursorItem = i;
+			break;
+		}
+	}
+
+	return qtrue;
+}
+
+int Item_TextScroll_MaxScroll ( itemDef_t *item ) 
+{
+	textScrollDef_t *scrollPtr = (textScrollDef_t*)item->typeData;
+	
+	int count = scrollPtr->iLineCount;
+	int max   = count - (int)(item->window.rect.h / scrollPtr->lineHeight) + 1;
+
+	if (max < 0) 
+	{
+		return 0;
+	}
+
+	return max;
+}
+
+int Item_TextScroll_ThumbPosition ( itemDef_t *item ) 
+{
+	float max, pos, size;
+	textScrollDef_t *scrollPtr = (textScrollDef_t*)item->typeData;
+
+	max  = Item_TextScroll_MaxScroll ( item );
+	size = item->window.rect.h - (SCROLLBAR_SIZE * 2) - 2;
+
+	if (max > 0) 
+	{
+		pos = (size-SCROLLBAR_SIZE) / (float) max;
+	} 
+	else 
+	{
+		pos = 0;
+	}
+	
+	pos *= scrollPtr->startPos;
+	
+	return item->window.rect.y + 1 + SCROLLBAR_SIZE + pos;
+}
+
+int Item_TextScroll_ThumbDrawPosition ( itemDef_t *item ) 
+{
+	int min, max;
+
+	if (itemCapture == item) 
+	{
+		min = item->window.rect.y + SCROLLBAR_SIZE + 1;
+		max = item->window.rect.y + item->window.rect.h - 2*SCROLLBAR_SIZE - 1;
+
+		if (DC->cursory >= min + SCROLLBAR_SIZE/2 && DC->cursory <= max + SCROLLBAR_SIZE/2) 
+		{
+			return DC->cursory - SCROLLBAR_SIZE/2;
+		}
+
+		return Item_TextScroll_ThumbPosition(item);
+	}
+
+	return Item_TextScroll_ThumbPosition(item);
+}
+
+int Item_TextScroll_OverLB ( itemDef_t *item, float x, float y ) 
+{
+	rectDef_t		r;
+	textScrollDef_t *scrollPtr;
+	int				thumbstart;
+	int				count;
+
+	scrollPtr = (textScrollDef_t*)item->typeData;
+	count     = scrollPtr->iLineCount;
+
+	r.x = item->window.rect.x + item->window.rect.w - SCROLLBAR_SIZE;
+	r.y = item->window.rect.y;
+	r.h = r.w = SCROLLBAR_SIZE;
+	if (Rect_ContainsPoint(&r, x, y)) 
+	{
+		return WINDOW_LB_LEFTARROW;
+	}
+
+	r.y = item->window.rect.y + item->window.rect.h - SCROLLBAR_SIZE;
+	if (Rect_ContainsPoint(&r, x, y)) 
+	{
+		return WINDOW_LB_RIGHTARROW;
+	}
+
+	thumbstart = Item_TextScroll_ThumbPosition(item);
+	r.y = thumbstart;
+	if (Rect_ContainsPoint(&r, x, y)) 
+	{
+		return WINDOW_LB_THUMB;
+	}
+
+	r.y = item->window.rect.y + SCROLLBAR_SIZE;
+	r.h = thumbstart - r.y;
+	if (Rect_ContainsPoint(&r, x, y)) 
+	{
+		return WINDOW_LB_PGUP;
+	}
+
+	r.y = thumbstart + SCROLLBAR_SIZE;
+	r.h = item->window.rect.y + item->window.rect.h - SCROLLBAR_SIZE;
+	if (Rect_ContainsPoint(&r, x, y)) 
+	{
+		return WINDOW_LB_PGDN;
+	}
+
+	return 0;
+}
+
+void Item_TextScroll_MouseEnter (itemDef_t *item, float x, float y) 
+{
+	item->window.flags &= ~(WINDOW_LB_LEFTARROW | WINDOW_LB_RIGHTARROW | WINDOW_LB_THUMB | WINDOW_LB_PGUP | WINDOW_LB_PGDN);
+	item->window.flags |= Item_TextScroll_OverLB(item, x, y);
+}
+
+qboolean Item_TextScroll_HandleKey ( itemDef_t *item, int key, qboolean down, qboolean force) 
+{
+	textScrollDef_t *scrollPtr = (textScrollDef_t*)item->typeData;
+	int				max;
+	int				viewmax;
+
+	if (force || (Rect_ContainsPoint(&item->window.rect, DC->cursorx, DC->cursory) && item->window.flags & WINDOW_HASFOCUS)) 
+	{
+		max = Item_TextScroll_MaxScroll(item);
+
+		viewmax = (item->window.rect.h / scrollPtr->lineHeight);
+		if ( key == A_CURSOR_UP || key == A_KP_8 ) 
+		{
+			scrollPtr->startPos--;
+			if (scrollPtr->startPos < 0)
+			{
+				scrollPtr->startPos = 0;
+			}
+			return qtrue;
+		}
+
+		if ( key == A_CURSOR_DOWN || key == A_KP_2 ) 
+		{
+			scrollPtr->startPos++;
+			if (scrollPtr->startPos > max)
+			{
+				scrollPtr->startPos = max;
+			}
+
+			return qtrue;
+		}
+
+		// mouse hit
+		if (key == A_MOUSE1 || key == A_MOUSE2) 
+		{
+			if (item->window.flags & WINDOW_LB_LEFTARROW) 
+			{
+				scrollPtr->startPos--;
+				if (scrollPtr->startPos < 0) 
+				{
+					scrollPtr->startPos = 0;
+				}
+			} 
+			else if (item->window.flags & WINDOW_LB_RIGHTARROW) 
+			{
+				// one down
+				scrollPtr->startPos++;
+				if (scrollPtr->startPos > max) 
+				{
+					scrollPtr->startPos = max;
+				}
+			} 
+			else if (item->window.flags & WINDOW_LB_PGUP) 
+			{
+				// page up
+				scrollPtr->startPos -= viewmax;
+				if (scrollPtr->startPos < 0) 
+				{
+					scrollPtr->startPos = 0;
+				}
+			} 
+			else if (item->window.flags & WINDOW_LB_PGDN) 
+			{
+				// page down
+				scrollPtr->startPos += viewmax;
+				if (scrollPtr->startPos > max) 
+				{
+					scrollPtr->startPos = max;
+				}
+			} 
+			else if (item->window.flags & WINDOW_LB_THUMB) 
+			{
+				// Display_SetCaptureItem(item);
+			} 
+
+			return qtrue;
+		}
+
+		if ( key == A_HOME || key == A_KP_7) 
+		{
+			// home
+			scrollPtr->startPos = 0;
+			return qtrue;
+		}
+		if ( key == A_END || key == A_KP_1) 
+		{
+			// end
+			scrollPtr->startPos = max;
+			return qtrue;
+		}
+		if (key == A_PAGE_UP || key == A_KP_9 ) 
+		{
+			scrollPtr->startPos -= viewmax;
+			if (scrollPtr->startPos < 0) 
+			{
+					scrollPtr->startPos = 0;
+			}
+
+			return qtrue;
+		}
+		if ( key == A_PAGE_DOWN || key == A_KP_3 ) 
+		{
+			scrollPtr->startPos += viewmax;
+			if (scrollPtr->startPos > max) 
+			{
+				scrollPtr->startPos = max;
+			}
+			return qtrue;
+		}
+	}
+
+	return qfalse;
+}
+
+int Item_ListBox_MaxScroll(itemDef_t *item) {
+	listBoxDef_t *listPtr = (listBoxDef_t*)item->typeData;
+	int count = DC->feederCount(item->special);
+	int max;
+
+	if (item->window.flags & WINDOW_HORIZONTAL) {
+		max = count - (item->window.rect.w / listPtr->elementWidth) + 1;
+	}
+	else {
+		max = count - (item->window.rect.h / listPtr->elementHeight) + 1;
+	}
+	if (max < 0) {
+		return 0;
+	}
+	return max;
+}
+
+int Item_ListBox_ThumbPosition(itemDef_t *item) {
+	float max, pos, size;
+	listBoxDef_t *listPtr = (listBoxDef_t*)item->typeData;
+
+	max = Item_ListBox_MaxScroll(item);
+	if (item->window.flags & WINDOW_HORIZONTAL) {
+		size = item->window.rect.w - (SCROLLBAR_SIZE * 2) - 2;
+		if (max > 0) {
+			pos = (size-SCROLLBAR_SIZE) / (float) max;
+		} else {
+			pos = 0;
+		}
+		pos *= listPtr->startPos;
+		return item->window.rect.x + 1 + SCROLLBAR_SIZE + pos;
+	}
+	else {
+		size = item->window.rect.h - (SCROLLBAR_SIZE * 2) - 2;
+		if (max > 0) {
+			pos = (size-SCROLLBAR_SIZE) / (float) max;
+		} else {
+			pos = 0;
+		}
+		pos *= listPtr->startPos;
+		return item->window.rect.y + 1 + SCROLLBAR_SIZE + pos;
+	}
+}
+
+int Item_ListBox_ThumbDrawPosition(itemDef_t *item) 
+{
+	int min, max;
+
+	if (itemCapture == item) 
+	{
+		if (item->window.flags & WINDOW_HORIZONTAL) 
+		{
+			min = item->window.rect.x + SCROLLBAR_SIZE + 1;
+			max = item->window.rect.x + item->window.rect.w - 2*SCROLLBAR_SIZE - 1;
+			if (DC->cursorx >= min + SCROLLBAR_SIZE/2 && DC->cursorx <= max + SCROLLBAR_SIZE/2) 
+			{
+				return DC->cursorx - SCROLLBAR_SIZE/2;
+			}
+			else 
+			{
+				return Item_ListBox_ThumbPosition(item);
+			}
+		}
+		else 
+		{
+			min = item->window.rect.y + SCROLLBAR_SIZE + 1;
+			max = item->window.rect.y + item->window.rect.h - 2*SCROLLBAR_SIZE - 1;
+			if (DC->cursory >= min + SCROLLBAR_SIZE/2 && DC->cursory <= max + SCROLLBAR_SIZE/2) 
+			{
+				return DC->cursory - SCROLLBAR_SIZE/2;
+			}
+			else 
+			{
+				return Item_ListBox_ThumbPosition(item);
+			}
+		}
+	}
+	else 
+	{
+		return Item_ListBox_ThumbPosition(item);
+	}
+}
+
+float Item_Slider_ThumbPosition(itemDef_t *item) {
+	float value, range, x;
+	editFieldDef_t *editDef = (editFieldDef_t *) item->typeData;
+
+	if (item->text) {
+		x = item->textRect.x + item->textRect.w + 8;
+	} else {
+		x = item->window.rect.x;
+	}
+
+	if (editDef == NULL && item->cvar) {
+		return x;
+	}
+
+	value = DC->getCVarValue(item->cvar);
+
+	if (value < editDef->minVal) {
+		value = editDef->minVal;
+	} else if (value > editDef->maxVal) {
+		value = editDef->maxVal;
+	}
+
+	range = editDef->maxVal - editDef->minVal;
+	value -= editDef->minVal;
+	value /= range;
+	//value /= (editDef->maxVal - editDef->minVal);
+	value *= SLIDER_WIDTH;
+	x += value;
+	// vm fuckage
+	//x = x + (((float)value / editDef->maxVal) * SLIDER_WIDTH);
+	return x;
+}
+
+int Item_Slider_OverSlider(itemDef_t *item, float x, float y) {
+	rectDef_t r;
+
+	r.x = Item_Slider_ThumbPosition(item) - (SLIDER_THUMB_WIDTH / 2);
+	r.y = item->window.rect.y - 2;
+	r.w = SLIDER_THUMB_WIDTH;
+	r.h = SLIDER_THUMB_HEIGHT;
+
+	if (Rect_ContainsPoint(&r, x, y)) {
+		return WINDOW_LB_THUMB;
+	}
+	return 0;
+}
+
+int Item_ListBox_OverLB(itemDef_t *item, float x, float y) 
+{
+	rectDef_t r;
+	listBoxDef_t *listPtr;
+	int thumbstart;
+	int count;
+
+	count = DC->feederCount(item->special);
+	listPtr = (listBoxDef_t*)item->typeData;
+	if (item->window.flags & WINDOW_HORIZONTAL) 
+	{
+		// check if on left arrow
+		r.x = item->window.rect.x;
+		r.y = item->window.rect.y + item->window.rect.h - SCROLLBAR_SIZE;
+		r.h = r.w = SCROLLBAR_SIZE;
+		if (Rect_ContainsPoint(&r, x, y)) 
+		{
+			return WINDOW_LB_LEFTARROW;
+		}
+
+		// check if on right arrow
+		r.x = item->window.rect.x + item->window.rect.w - SCROLLBAR_SIZE;
+		if (Rect_ContainsPoint(&r, x, y)) 
+		{
+			return WINDOW_LB_RIGHTARROW;
+		}
+
+		// check if on thumb
+		thumbstart = Item_ListBox_ThumbPosition(item);
+		r.x = thumbstart;
+		if (Rect_ContainsPoint(&r, x, y)) 
+		{
+			return WINDOW_LB_THUMB;
+		}
+
+		r.x = item->window.rect.x + SCROLLBAR_SIZE;
+		r.w = thumbstart - r.x;
+		if (Rect_ContainsPoint(&r, x, y)) 
+		{
+			return WINDOW_LB_PGUP;
+		}
+
+		r.x = thumbstart + SCROLLBAR_SIZE;
+		r.w = item->window.rect.x + item->window.rect.w - SCROLLBAR_SIZE;
+		if (Rect_ContainsPoint(&r, x, y)) 
+		{
+			return WINDOW_LB_PGDN;
+		}
+	}
+	// Vertical Scroll
+	else 
+	{
+		// Multiple rows and columns (since it's more than twice as wide as an element)
+		if (( item->window.rect.w > (listPtr->elementWidth*2)) &&  (listPtr->elementStyle == LISTBOX_IMAGE))
+		{
+			r.x = item->window.rect.x + item->window.rect.w - SCROLLBAR_SIZE;
+			r.y = item->window.rect.y;
+			r.h = r.w = SCROLLBAR_SIZE;
+			if (Rect_ContainsPoint(&r, x, y)) 
+			{
+				return WINDOW_LB_PGUP;
+			}
+
+			r.y = item->window.rect.y + item->window.rect.h - SCROLLBAR_SIZE;
+			if (Rect_ContainsPoint(&r, x, y)) 
+			{
+				return WINDOW_LB_PGDN;
+			}
+
+			thumbstart = Item_ListBox_ThumbPosition(item);
+			r.y = thumbstart;
+			if (Rect_ContainsPoint(&r, x, y)) 
+			{
+				return WINDOW_LB_THUMB;
+			}
+
+		}
+		else
+		{
+			r.x = item->window.rect.x + item->window.rect.w - SCROLLBAR_SIZE;
+			r.y = item->window.rect.y;
+			r.h = r.w = SCROLLBAR_SIZE;
+			if (Rect_ContainsPoint(&r, x, y)) 
+			{
+				return WINDOW_LB_LEFTARROW;
+			}
+
+			r.y = item->window.rect.y + item->window.rect.h - SCROLLBAR_SIZE;
+			if (Rect_ContainsPoint(&r, x, y)) 
+			{
+				return WINDOW_LB_RIGHTARROW;
+			}
+
+			thumbstart = Item_ListBox_ThumbPosition(item);
+			r.y = thumbstart;
+			if (Rect_ContainsPoint(&r, x, y)) 
+			{
+				return WINDOW_LB_THUMB;
+			}
+
+			r.y = item->window.rect.y + SCROLLBAR_SIZE;
+			r.h = thumbstart - r.y;
+			if (Rect_ContainsPoint(&r, x, y)) 
+			{
+				return WINDOW_LB_PGUP;
+			}
+
+			r.y = thumbstart + SCROLLBAR_SIZE;
+			r.h = item->window.rect.y + item->window.rect.h - SCROLLBAR_SIZE;
+			if (Rect_ContainsPoint(&r, x, y)) 
+			{
+				return WINDOW_LB_PGDN;
+			}
+		}
+	}
+	return 0;
+}
+
+
+void Item_ListBox_MouseEnter(itemDef_t *item, float x, float y) 
+{
+	rectDef_t r;
+	listBoxDef_t *listPtr = (listBoxDef_t*)item->typeData;
+        
+	item->window.flags &= ~(WINDOW_LB_LEFTARROW | WINDOW_LB_RIGHTARROW | WINDOW_LB_THUMB | WINDOW_LB_PGUP | WINDOW_LB_PGDN);
+	item->window.flags |= Item_ListBox_OverLB(item, x, y);
+
+	if (item->window.flags & WINDOW_HORIZONTAL) 
+	{
+		if (!(item->window.flags & (WINDOW_LB_LEFTARROW | WINDOW_LB_RIGHTARROW | WINDOW_LB_THUMB | WINDOW_LB_PGUP | WINDOW_LB_PGDN))) 
+		{
+			// check for selection hit as we have exausted buttons and thumb
+			if (listPtr->elementStyle == LISTBOX_IMAGE) 
+			{
+				r.x = item->window.rect.x;
+				r.y = item->window.rect.y;
+				r.h = item->window.rect.h - SCROLLBAR_SIZE;
+				r.w = item->window.rect.w - listPtr->drawPadding;
+				if (Rect_ContainsPoint(&r, x, y)) 
+				{
+					listPtr->cursorPos =  (int)((x - r.x) / listPtr->elementWidth)  + listPtr->startPos;
+					if (listPtr->cursorPos >= listPtr->endPos) 
+					{
+						listPtr->cursorPos = listPtr->endPos;
+					}
+				}
+			} 
+			else 
+			{
+				// text hit.. 
+			}
+		}
+	} 
+	// Window Vertical Scroll
+	else if (!(item->window.flags & (WINDOW_LB_LEFTARROW | WINDOW_LB_RIGHTARROW | WINDOW_LB_THUMB | WINDOW_LB_PGUP | WINDOW_LB_PGDN))) 
+	{
+		// Calc which element the mouse is over
+		r.x = item->window.rect.x;
+		r.y = item->window.rect.y;
+		r.w = item->window.rect.w - SCROLLBAR_SIZE;
+		r.h = item->window.rect.h - listPtr->drawPadding;
+		if (Rect_ContainsPoint(&r, x, y)) 
+		{
+			// Multiple rows and columns (since it's more than twice as wide as an element)
+			if (( item->window.rect.w > (listPtr->elementWidth*2)) &&  (listPtr->elementStyle == LISTBOX_IMAGE))
+			{
+				int row,column,rowLength;
+
+				row = (int)((y - 2 - r.y) / listPtr->elementHeight);
+				rowLength = (int) r.w / listPtr->elementWidth;
+				column = (int)((x - r.x) / listPtr->elementWidth);
+
+				listPtr->cursorPos = (row * rowLength)+column  + listPtr->startPos;
+				if (listPtr->cursorPos >= listPtr->endPos) 
+				{
+					listPtr->cursorPos = listPtr->endPos;
+				}
+			}
+			// single column
+			else
+			{
+				listPtr->cursorPos =  (int)((y - 2 - r.y) / listPtr->elementHeight)  + listPtr->startPos;
+				if (listPtr->cursorPos > listPtr->endPos) 
+				{
+                    listPtr->cursorPos = listPtr->endPos;
+				}
+			}
+		}
+	}
+}
+
+void Item_MouseEnter(itemDef_t *item, float x, float y) {
+
+	rectDef_t r;
+	if (item) {
+		r = item->textRect;
+		r.y -= r.h;
+		// in the text rect?
+
+		// items can be enabled and disabled 
+		if (item->disabled) 
+		{
+			return;
+		}
+
+		// items can be enabled and disabled based on cvars
+		if (item->cvarFlags & (CVAR_ENABLE | CVAR_DISABLE) && !Item_EnableShowViaCvar(item, CVAR_ENABLE)) {
+			return;
+		}
+
+		if (item->cvarFlags & (CVAR_SHOW | CVAR_HIDE) && !Item_EnableShowViaCvar(item, CVAR_SHOW)) {
+			return;
+		}
+
+//JLFMOUSE 
+#ifndef _XBOX
+		if (Rect_ContainsPoint(&r, x, y)) 
+#else
+		if (item->flags & WINDOW_HASFOCUS)
+#endif
+		{
+			if (!(item->window.flags & WINDOW_MOUSEOVERTEXT)) {
+				Item_RunScript(item, item->mouseEnterText);
+				item->window.flags |= WINDOW_MOUSEOVERTEXT;
+			}
+			if (!(item->window.flags & WINDOW_MOUSEOVER)) {
+				Item_RunScript(item, item->mouseEnter);
+				item->window.flags |= WINDOW_MOUSEOVER;
+			}
+
+		} else {
+			// not in the text rect
+			if (item->window.flags & WINDOW_MOUSEOVERTEXT) {
+				// if we were
+				Item_RunScript(item, item->mouseExitText);
+				item->window.flags &= ~WINDOW_MOUSEOVERTEXT;
+			}
+			if (!(item->window.flags & WINDOW_MOUSEOVER)) {
+				Item_RunScript(item, item->mouseEnter);
+				item->window.flags |= WINDOW_MOUSEOVER;
+			}
+
+			if (item->type == ITEM_TYPE_LISTBOX) {
+				Item_ListBox_MouseEnter(item, x, y);
+			}
+			else if ( item->type == ITEM_TYPE_TEXTSCROLL )
+			{
+				Item_TextScroll_MouseEnter ( item, x, y );
+			}
+		}
+	}
+}
+
+void Item_MouseLeave(itemDef_t *item) {
+  if (item) {
+    if (item->window.flags & WINDOW_MOUSEOVERTEXT) {
+      Item_RunScript(item, item->mouseExitText);
+      item->window.flags &= ~WINDOW_MOUSEOVERTEXT;
+    }
+    Item_RunScript(item, item->mouseExit);
+    item->window.flags &= ~(WINDOW_LB_RIGHTARROW | WINDOW_LB_LEFTARROW);
+  }
+}
+
+itemDef_t *Menu_HitTest(menuDef_t *menu, float x, float y) {
+  int i;
+  for (i = 0; i < menu->itemCount; i++) {
+    if (Rect_ContainsPoint(&menu->items[i]->window.rect, x, y)) {
+      return menu->items[i];
+    }
+  }
+  return NULL;
+}
+
+void Item_SetMouseOver(itemDef_t *item, qboolean focus) {
+  if (item) {
+    if (focus) {
+      item->window.flags |= WINDOW_MOUSEOVER;
+    } else {
+      item->window.flags &= ~WINDOW_MOUSEOVER;
+    }
+  }
+}
+
+
+qboolean Item_OwnerDraw_HandleKey(itemDef_t *item, int key) {
+  if (item && DC->ownerDrawHandleKey)
+  {
+	
+	  // yep this is an ugly hack
+	  if( key == A_MOUSE1 || key == A_MOUSE2 )
+	  {
+		switch( item->window.ownerDraw )
+		{
+			case UI_FORCE_SIDE:
+			case UI_FORCE_RANK_HEAL:
+			case UI_FORCE_RANK_LEVITATION:
+			case UI_FORCE_RANK_SPEED:
+			case UI_FORCE_RANK_PUSH:
+			case UI_FORCE_RANK_PULL:
+			case UI_FORCE_RANK_TELEPATHY:
+			case UI_FORCE_RANK_GRIP:
+			case UI_FORCE_RANK_LIGHTNING:
+			case UI_FORCE_RANK_RAGE:
+			case UI_FORCE_RANK_PROTECT:
+			case UI_FORCE_RANK_ABSORB:
+			case UI_FORCE_RANK_TEAM_HEAL:
+			case UI_FORCE_RANK_TEAM_FORCE:
+			case UI_FORCE_RANK_DRAIN:
+			case UI_FORCE_RANK_SEE:
+			case UI_FORCE_RANK_SABERATTACK:
+			case UI_FORCE_RANK_SABERDEFEND:
+			case UI_FORCE_RANK_SABERTHROW:
+	  			if(!Rect_ContainsPoint(&item->window.rect, DC->cursorx, DC->cursory) )
+				{
+					return qfalse;
+				}
+				break;
+		}
+	  }
+	  
+
+    return DC->ownerDrawHandleKey(item->window.ownerDraw, item->window.ownerDrawFlags, &item->special, key);
+  }
+  return qfalse;
+}
+
+
+#ifdef _XBOX
+// Xbox-only key handlers
+
+//JLF new func
+qboolean Item_Button_HandleKey(itemDef_t *item, int key) 
+{
+	if ( key == A_CURSOR_RIGHT)
+	{
+		if (Item_HandleSelectionNext(item))
+		{
+			//Item processed it 
+			return qtrue;
+		}
+	}
+	else if ( key ==  A_CURSOR_LEFT)
+	{
+		if (Item_HandleSelectionPrev(item))
+		{
+			//Item processed it 
+			return qtrue;
+		}
+	}
+	return qfalse;
+}
+
+/*
+=================
+Item_Text_HandleKey
+=================
+*/
+qboolean Item_Text_HandleKey(itemDef_t *item, int key) 
+{
+//JLFSELECTIONRightLeft
+	if ( key == A_CURSOR_RIGHT)
+	{
+		if (Item_HandleSelectionNext(item))
+		{
+			//Item processed it 
+			return qtrue;
+		}
+	}
+	else if ( key ==  A_CURSOR_LEFT)
+	{
+		if (Item_HandleSelectionPrev(item))
+		{
+			//Item processed it 
+			return qtrue;
+		}
+	}
+	return qfalse;
+}
+
+#endif // _XBOX
+
+
+qboolean Item_ListBox_HandleKey(itemDef_t *item, int key, qboolean down, qboolean force) {
+	listBoxDef_t *listPtr = (listBoxDef_t*)item->typeData;
+	int count = DC->feederCount(item->special);
+	int max, viewmax;
+//JLFMOUSE
+#ifndef _XBOX
+	if (force || (Rect_ContainsPoint(&item->window.rect, DC->cursorx, DC->cursory) && item->window.flags & WINDOW_HASFOCUS))
+#else
+	if (force || item->window.flags & WINDOW_HASFOCUS)
+#endif
+	{
+		max = Item_ListBox_MaxScroll(item);
+		if (item->window.flags & WINDOW_HORIZONTAL) {
+			viewmax = (item->window.rect.w / listPtr->elementWidth);
+			if ( key == A_CURSOR_LEFT || key == A_KP_4 ) 
+			{
+				if (!listPtr->notselectable) {
+					listPtr->cursorPos--;
+#ifdef _XBOX
+					listPtr->startPos--;
+#endif
+					if (listPtr->cursorPos < 0) {
+						listPtr->cursorPos = 0;
+						return qfalse;
+					}
+					if (listPtr->cursorPos < listPtr->startPos) {
+						listPtr->startPos = listPtr->cursorPos;
+//JLF
+#ifndef _XBOX
+						return qfalse;
+#endif
+					}
+					if (listPtr->cursorPos >= listPtr->startPos + viewmax) {
+						listPtr->startPos = listPtr->cursorPos - viewmax + 1;
+					}
+					item->cursorPos = listPtr->cursorPos;
+					DC->feederSelection(item->special, item->cursorPos, NULL);
+				}
+				else {
+					listPtr->startPos--;
+					if (listPtr->startPos < 0)
+						listPtr->startPos = 0;
+				}
+				return qtrue;
+			}
+			if ( key == A_CURSOR_RIGHT || key == A_KP_6 ) 
+			{
+				if (!listPtr->notselectable) {
+					listPtr->cursorPos++;
+					if (listPtr->cursorPos < listPtr->startPos) {
+						listPtr->startPos = listPtr->cursorPos;
+//JLF
+#ifndef _XBOX
+						return qfalse;
+#endif
+					}
+					if (listPtr->cursorPos >= count) {
+						listPtr->cursorPos = count-1;
+						return qfalse;
+					}
+					if (listPtr->cursorPos >= listPtr->startPos + viewmax) {
+						listPtr->startPos = listPtr->cursorPos - viewmax + 1;
+					}
+					item->cursorPos = listPtr->cursorPos;
+					DC->feederSelection(item->special, item->cursorPos, NULL);
+				}
+				else {
+					listPtr->startPos++;
+					if (listPtr->startPos >= count)
+						listPtr->startPos = count-1;
+				}
+				return qtrue;
+			}
+		}
+		// Vertical scroll
+		else {
+
+			// Multiple rows and columns (since it's more than twice as wide as an element)
+			if (( item->window.rect.w > (listPtr->elementWidth*2)) &&  (listPtr->elementStyle == LISTBOX_IMAGE))
+			{
+				viewmax = (item->window.rect.w / listPtr->elementWidth);
+			}
+			else 
+			{
+				viewmax = (item->window.rect.h / listPtr->elementHeight);
+			}
+
+			if ( key == A_CURSOR_UP || key == A_KP_8 ) 
+			{
+				if (!listPtr->notselectable) {
+					listPtr->cursorPos--;
+					if (listPtr->cursorPos < 0) {
+						listPtr->cursorPos = 0;
+						return qfalse;
+					}
+					if (listPtr->cursorPos < listPtr->startPos) {
+						listPtr->startPos = listPtr->cursorPos;
+//JLF
+#ifndef _XBOX
+						return qfalse;
+#endif
+					}
+					if (listPtr->cursorPos >= listPtr->startPos + viewmax) {
+						listPtr->startPos = listPtr->cursorPos - viewmax + 1;
+					}
+					item->cursorPos = listPtr->cursorPos;
+					DC->feederSelection(item->special, item->cursorPos, NULL);
+				}
+				else {
+					listPtr->startPos--;
+					if (listPtr->startPos < 0)
+						listPtr->startPos = 0;
+				}
+				return qtrue;
+			}
+			if ( key == A_CURSOR_DOWN || key == A_KP_2 ) 
+			{
+				if (!listPtr->notselectable) {
+					listPtr->cursorPos++;
+					if (listPtr->cursorPos < listPtr->startPos) {
+						listPtr->startPos = listPtr->cursorPos;
+//JLF
+#ifndef _XBOX
+						return qfalse;
+#endif
+					}
+					if (listPtr->cursorPos >= count) {
+						listPtr->cursorPos = count-1;
+						return qfalse;
+					}
+					if (listPtr->cursorPos >= listPtr->startPos + viewmax) {
+						listPtr->startPos = listPtr->cursorPos - viewmax + 1;
+					}
+					item->cursorPos = listPtr->cursorPos;
+					DC->feederSelection(item->special, item->cursorPos, NULL);
+				}
+				else {
+					listPtr->startPos++;
+					if (listPtr->startPos > max)
+						listPtr->startPos = max;
+				}
+				return qtrue;
+			}
+		}
+		// mouse hit
+		if (key == A_MOUSE1 || key == A_MOUSE2) {
+			if (item->window.flags & WINDOW_LB_LEFTARROW) {
+				listPtr->startPos--;
+				if (listPtr->startPos < 0) {
+					listPtr->startPos = 0;
+				}
+			} else if (item->window.flags & WINDOW_LB_RIGHTARROW) {
+				// one down
+				listPtr->startPos++;
+				if (listPtr->startPos > max) {
+					listPtr->startPos = max;
+				}
+			} else if (item->window.flags & WINDOW_LB_PGUP) {
+				// page up
+				listPtr->startPos -= viewmax;
+				if (listPtr->startPos < 0) {
+					listPtr->startPos = 0;
+				}
+			} else if (item->window.flags & WINDOW_LB_PGDN) {
+				// page down
+				listPtr->startPos += viewmax;
+				if (listPtr->startPos > (max)) {
+					listPtr->startPos = (max);
+				}
+			} else if (item->window.flags & WINDOW_LB_THUMB) {
+				// Display_SetCaptureItem(item);
+			} else {
+				// select an item
+#ifdef _XBOX
+				if (listPtr->doubleClick) {
+#else
+				if (DC->realTime < lastListBoxClickTime && listPtr->doubleClick) {
+#endif
+					Item_RunScript(item, listPtr->doubleClick);
+				}
+				lastListBoxClickTime = DC->realTime + DOUBLE_CLICK_DELAY;
+//				if (item->cursorPos != listPtr->cursorPos) 
+				{
+					int prePos = item->cursorPos;
+					
+					item->cursorPos = listPtr->cursorPos;
+
+					if (!DC->feederSelection(item->special, item->cursorPos, item))
+					{
+						item->cursorPos = listPtr->cursorPos = prePos;
+					}
+				}
+			}
+			return qtrue;
+		}
+		if ( key == A_HOME || key == A_KP_7) {
+			// home
+			listPtr->startPos = 0;
+			return qtrue;
+		}
+		if ( key == A_END || key == A_KP_1) {
+			// end
+			listPtr->startPos = max;
+			return qtrue;
+		}
+		if (key == A_PAGE_UP || key == A_KP_9 ) {
+			// page up
+			if (!listPtr->notselectable) {
+				listPtr->cursorPos -= viewmax;
+				if (listPtr->cursorPos < 0) {
+					listPtr->cursorPos = 0;
+				}
+				if (listPtr->cursorPos < listPtr->startPos) {
+					listPtr->startPos = listPtr->cursorPos;
+				}
+				if (listPtr->cursorPos >= listPtr->startPos + viewmax) {
+					listPtr->startPos = listPtr->cursorPos - viewmax + 1;
+				}
+				item->cursorPos = listPtr->cursorPos;
+				DC->feederSelection(item->special, item->cursorPos, NULL);
+			}
+			else {
+				listPtr->startPos -= viewmax;
+				if (listPtr->startPos < 0) {
+					listPtr->startPos = 0;
+				}
+			}
+			return qtrue;
+		}
+		if ( key == A_PAGE_DOWN || key == A_KP_3 ) {
+			// page down
+			if (!listPtr->notselectable) {
+				listPtr->cursorPos += viewmax;
+				if (listPtr->cursorPos < listPtr->startPos) {
+					listPtr->startPos = listPtr->cursorPos;
+				}
+				if (listPtr->cursorPos >= count) {
+					listPtr->cursorPos = count-1;
+				}
+				if (listPtr->cursorPos >= listPtr->startPos + viewmax) {
+					listPtr->startPos = listPtr->cursorPos - viewmax + 1;
+				}
+				item->cursorPos = listPtr->cursorPos;
+				DC->feederSelection(item->special, item->cursorPos, NULL);
+			}
+			else {
+				listPtr->startPos += viewmax;
+				if (listPtr->startPos > max) {
+					listPtr->startPos = max;
+				}
+			}
+			return qtrue;
+		}
+	}
+	return qfalse;
+}
+
+qboolean Item_YesNo_HandleKey(itemDef_t *item, int key) {
+//JLFMOUSE MPMOVED
+#ifndef _XBOX
+  if (Rect_ContainsPoint(&item->window.rect, DC->cursorx, DC->cursory) && item->window.flags & WINDOW_HASFOCUS && item->cvar) 
+#else
+	if (item->window.flags & WINDOW_HASFOCUS && item->cvar) 
+#endif
+	{
+
+//JLFDPAD MPMOVED
+#ifndef _XBOX
+		if (key == A_MOUSE1 || key == A_ENTER || key == A_MOUSE2 || key == A_MOUSE3) 
+#else
+		if ( key == A_CURSOR_RIGHT || key == A_CURSOR_LEFT)
+#endif
+//end JLFDPAD
+
+		{
+	    DC->setCVar(item->cvar, va("%i", !DC->getCVarValue(item->cvar)));
+		  return qtrue;
+		}
+  }
+
+  return qfalse;
+
+}
+
+int Item_Multi_CountSettings(itemDef_t *item) {
+	multiDef_t *multiPtr = (multiDef_t*)item->typeData;
+	if (multiPtr == NULL) {
+		return 0;
+	}
+	return multiPtr->count;
+}
+
+int Item_Multi_FindCvarByValue(itemDef_t *item) {
+	char buff[2048];
+	float value = 0;
+	int i;
+	multiDef_t *multiPtr = (multiDef_t*)item->typeData;
+	if (multiPtr) {
+		if (multiPtr->strDef) {
+	    DC->getCVarString(item->cvar, buff, sizeof(buff));
+		} else {
+			value = DC->getCVarValue(item->cvar);
+		}
+		for (i = 0; i < multiPtr->count; i++) {
+			if (multiPtr->strDef) {
+				if (Q_stricmp(buff, multiPtr->cvarStr[i]) == 0) {
+					return i;
+				}
+			} else {
+ 				if (multiPtr->cvarValue[i] == value) {
+ 					return i;
+ 				}
+ 			}
+ 		}
+	}
+	return 0;
+}
+
+const char *Item_Multi_Setting(itemDef_t *item) {
+	char buff[2048];
+	float value = 0;
+	int i;
+	multiDef_t *multiPtr = (multiDef_t*)item->typeData;
+	if (multiPtr) 
+	{
+		if (multiPtr->strDef) 
+		{
+			if (item->cvar)
+			{
+			    DC->getCVarString(item->cvar, buff, sizeof(buff));
+			}
+		} 
+		else 
+		{
+			if (item->cvar)	// Was a cvar given?
+			{
+				value = DC->getCVarValue(item->cvar);
+			}
+		}
+
+		for (i = 0; i < multiPtr->count; i++) 
+		{
+			if (multiPtr->strDef) 
+			{
+				if (Q_stricmp(buff, multiPtr->cvarStr[i]) == 0) 
+				{
+					return multiPtr->cvarList[i];
+				}
+			} 
+			else 
+			{
+ 				if (multiPtr->cvarValue[i] == value) 
+				{
+					return multiPtr->cvarList[i];
+ 				}
+ 			}
+ 		}
+	}
+	return "";
+}
+
+qboolean Item_Multi_HandleKey(itemDef_t *item, int key) 
+{
+	multiDef_t *multiPtr = (multiDef_t*)item->typeData;
+	if (multiPtr) 
+	{
+//JLF MPMOVED
+#ifndef _XBOX
+		if (Rect_ContainsPoint(&item->window.rect, DC->cursorx, DC->cursory) && item->window.flags & WINDOW_HASFOCUS) 
+#else
+		if (item->window.flags & WINDOW_HASFOCUS)// JLF* && item->cvar)
+#endif
+		{
+#ifndef _XBOX
+					
+			if (key == A_MOUSE1 || key == A_ENTER || key == A_MOUSE2 || key == A_MOUSE3) 
+#else
+//JLFDPAD MPMOVED
+			if ( key == A_CURSOR_RIGHT || key == A_CURSOR_LEFT)
+//end JLFDPAD
+#endif
+			{
+				int current = Item_Multi_FindCvarByValue(item);
+				int max = Item_Multi_CountSettings(item);
+
+				if (key == A_MOUSE2 || key == A_CURSOR_LEFT)	// Xbox uses CURSOR_LEFT
+				{
+					current--;
+					if ( current < 0 ) 
+					{
+						current = max-1;
+					}
+				}
+				else
+				{
+					current++;
+					if ( current >= max ) 
+					{
+						current = 0;
+					}
+				}
+
+				if (multiPtr->strDef) 
+				{
+					DC->setCVar(item->cvar, multiPtr->cvarStr[current]);
+				} 
+				else 
+				{
+					float value = multiPtr->cvarValue[current];
+					if (((float)((int) value)) == value) 
+					{
+						DC->setCVar(item->cvar, va("%i", (int) value ));
+					}
+					else 
+					{
+						DC->setCVar(item->cvar, va("%f", value ));
+					}
+				}
+				if (item->special)
+				{//its a feeder?
+					DC->feederSelection(item->special, current, item);
+				}
+
+				return qtrue;
+			}
+		}
+	}
+  return qfalse;
+}
+
+// Leaving an edit field so reset it so it prints from the beginning.
+void Leaving_EditField(itemDef_t *item)
+{
+	// switching fields so reset printed text of edit field
+	if ((g_editingField==qtrue) && (item->type==ITEM_TYPE_EDITFIELD))
+	{
+		editFieldDef_t *editPtr = (editFieldDef_t*)item->typeData;
+		if (editPtr)
+		{
+			editPtr->paintOffset = 0;
+		}
+	}
+}
+
+qboolean Item_TextField_HandleKey(itemDef_t *item, int key) {
+	char buff[2048];
+	int len;
+	itemDef_t *newItem = NULL;
+	editFieldDef_t *editPtr = (editFieldDef_t*)item->typeData;
+
+	if (item->cvar) {
+
+		buff[0] = 0;
+		DC->getCVarString(item->cvar, buff, sizeof(buff));
+		len = strlen(buff);
+		if (editPtr->maxChars && len > editPtr->maxChars) {
+			len = editPtr->maxChars;
+		}
+		if ( key & K_CHAR_FLAG ) {
+			key &= ~K_CHAR_FLAG;
+
+
+			if (key == 'h' - 'a' + 1 )	{	// ctrl-h is backspace
+				if ( item->cursorPos > 0 ) {
+					memmove( &buff[item->cursorPos - 1], &buff[item->cursorPos], len + 1 - item->cursorPos);
+					item->cursorPos--;
+					if (item->cursorPos < editPtr->paintOffset) {
+						editPtr->paintOffset--;
+					}
+				}
+				DC->setCVar(item->cvar, buff);
+	    		return qtrue;
+			}
+
+
+			//
+			// ignore any non printable chars
+			//
+			if ( key < 32 || !item->cvar) {
+			    return qtrue;
+		    }
+
+			if (item->type == ITEM_TYPE_NUMERICFIELD) {
+				if (key < '0' || key > '9') {
+					return qfalse;
+				}
+			}
+
+			if (!DC->getOverstrikeMode()) {
+				if (( len == MAX_EDITFIELD - 1 ) || (editPtr->maxChars && len >= editPtr->maxChars)) {
+					return qtrue;
+				}
+				memmove( &buff[item->cursorPos + 1], &buff[item->cursorPos], len + 1 - item->cursorPos );
+			} else {
+				if (editPtr->maxChars && item->cursorPos >= editPtr->maxChars) {
+					return qtrue;
+				}
+			}
+
+			buff[item->cursorPos] = key;
+
+			//rww - nul-terminate!
+			if (item->cursorPos+1 < 2048)
+			{
+				buff[item->cursorPos+1] = 0;
+			}
+			else
+			{
+				buff[item->cursorPos] = 0;
+			}
+
+			DC->setCVar(item->cvar, buff);
+
+			if (item->cursorPos < len + 1) {
+				item->cursorPos++;
+				if (editPtr->maxPaintChars && item->cursorPos > editPtr->maxPaintChars) {
+					editPtr->paintOffset++;
+				}
+			}
+
+		} else {
+
+			if ( key == A_DELETE || key == A_KP_PERIOD ) {
+				if ( item->cursorPos < len ) {
+					memmove( buff + item->cursorPos, buff + item->cursorPos + 1, len - item->cursorPos);
+					DC->setCVar(item->cvar, buff);
+				}
+				return qtrue;
+			}
+
+			if ( key == A_CURSOR_RIGHT || key == A_KP_6 ) 
+			{
+				if (editPtr->maxPaintChars && item->cursorPos >= editPtr->maxPaintChars && item->cursorPos < len) {
+					item->cursorPos++;
+					editPtr->paintOffset++;
+					return qtrue;
+				}
+				if (item->cursorPos < len) {
+					item->cursorPos++;
+				} 
+				return qtrue;
+			}
+
+			if ( key == A_CURSOR_LEFT || key == A_KP_4 ) 
+			{
+				if ( item->cursorPos > 0 ) {
+					item->cursorPos--;
+				}
+				if (item->cursorPos < editPtr->paintOffset) {
+					editPtr->paintOffset--;
+				}
+				return qtrue;
+			}
+
+			if ( key == A_HOME || key == A_KP_7) {// || ( tolower(key) == 'a' && trap_Key_IsDown( K_CTRL ) ) ) {
+				item->cursorPos = 0;
+				editPtr->paintOffset = 0;
+				return qtrue;
+			}
+
+			if ( key == A_END || key == A_KP_1)  {// ( tolower(key) == 'e' && trap_Key_IsDown( K_CTRL ) ) ) {
+				item->cursorPos = len;
+				if(item->cursorPos > editPtr->maxPaintChars) {
+					editPtr->paintOffset = len - editPtr->maxPaintChars;
+				}
+				return qtrue;
+			}
+
+			if ( key == A_INSERT || key == A_KP_0 ) {
+				DC->setOverstrikeMode(!DC->getOverstrikeMode());
+				return qtrue;
+			}
+		}
+
+		if (key == A_TAB || key == A_CURSOR_DOWN || key == A_KP_2)
+		{
+			// switching fields so reset printed text of edit field
+			Leaving_EditField(item);
+			g_editingField = qfalse;
+			newItem = Menu_SetNextCursorItem((menuDef_t *) item->parent);
+			if (newItem && (newItem->type == ITEM_TYPE_EDITFIELD || newItem->type == ITEM_TYPE_NUMERICFIELD))
+			{
+				g_editItem = newItem;
+				g_editingField = qtrue;
+			}
+		}
+
+		if (key == A_CURSOR_UP || key == A_KP_8)
+		{
+			// switching fields so reset printed text of edit field
+			Leaving_EditField(item);
+
+			g_editingField = qfalse;
+			newItem = Menu_SetPrevCursorItem((menuDef_t *) item->parent);
+			if (newItem && (newItem->type == ITEM_TYPE_EDITFIELD || newItem->type == ITEM_TYPE_NUMERICFIELD))
+			{
+				g_editItem = newItem;
+				g_editingField = qtrue;
+			}
+		}
+
+		if ( key == A_ENTER || key == A_KP_ENTER || key == A_ESCAPE)  {
+			return qfalse;
+		}
+
+		return qtrue;
+	}
+	return qfalse;
+
+}
+
+static void Scroll_TextScroll_AutoFunc (void *p) 
+{
+	scrollInfo_t *si = (scrollInfo_t*)p;
+
+	if (DC->realTime > si->nextScrollTime) 
+	{ 
+		// need to scroll which is done by simulating a click to the item
+		// this is done a bit sideways as the autoscroll "knows" that the item is a listbox
+		// so it calls it directly
+		Item_TextScroll_HandleKey(si->item, si->scrollKey, qtrue, qfalse);
+		si->nextScrollTime = DC->realTime + si->adjustValue; 
+	}
+
+	if (DC->realTime > si->nextAdjustTime) 
+	{
+		si->nextAdjustTime = DC->realTime + SCROLL_TIME_ADJUST;
+		if (si->adjustValue > SCROLL_TIME_FLOOR) 
+		{
+			si->adjustValue -= SCROLL_TIME_ADJUSTOFFSET;
+		}
+	}
+}
+
+static void Scroll_TextScroll_ThumbFunc(void *p) 
+{
+	scrollInfo_t *si = (scrollInfo_t*)p;
+	rectDef_t	 r;
+	int			 pos;
+	int			 max;
+
+	textScrollDef_t *scrollPtr = (textScrollDef_t*)si->item->typeData;
+
+	if (DC->cursory != si->yStart) 
+	{
+		r.x = si->item->window.rect.x + si->item->window.rect.w - SCROLLBAR_SIZE - 1;
+		r.y = si->item->window.rect.y + SCROLLBAR_SIZE + 1;
+		r.h = si->item->window.rect.h - (SCROLLBAR_SIZE*2) - 2;
+		r.w = SCROLLBAR_SIZE;
+		max = Item_TextScroll_MaxScroll(si->item);
+		//
+		pos = (DC->cursory - r.y - SCROLLBAR_SIZE/2) * max / (r.h - SCROLLBAR_SIZE);
+		if (pos < 0) 
+		{
+			pos = 0;
+		}
+		else if (pos > max) 
+		{
+			pos = max;
+		}
+
+		scrollPtr->startPos = pos;
+		si->yStart = DC->cursory;
+	}
+
+	if (DC->realTime > si->nextScrollTime) 
+	{ 
+		// need to scroll which is done by simulating a click to the item
+		// this is done a bit sideways as the autoscroll "knows" that the item is a listbox
+		// so it calls it directly
+		Item_TextScroll_HandleKey(si->item, si->scrollKey, qtrue, qfalse);
+		si->nextScrollTime = DC->realTime + si->adjustValue; 
+	}
+
+	if (DC->realTime > si->nextAdjustTime) 
+	{
+		si->nextAdjustTime = DC->realTime + SCROLL_TIME_ADJUST;
+		if (si->adjustValue > SCROLL_TIME_FLOOR) 
+		{
+			si->adjustValue -= SCROLL_TIME_ADJUSTOFFSET;
+		}
+	}
+}
+
+static void Scroll_ListBox_AutoFunc(void *p) {
+	scrollInfo_t *si = (scrollInfo_t*)p;
+	if (DC->realTime > si->nextScrollTime) { 
+		// need to scroll which is done by simulating a click to the item
+		// this is done a bit sideways as the autoscroll "knows" that the item is a listbox
+		// so it calls it directly
+		Item_ListBox_HandleKey(si->item, si->scrollKey, qtrue, qfalse);
+		si->nextScrollTime = DC->realTime + si->adjustValue; 
+	}
+
+	if (DC->realTime > si->nextAdjustTime) {
+		si->nextAdjustTime = DC->realTime + SCROLL_TIME_ADJUST;
+		if (si->adjustValue > SCROLL_TIME_FLOOR) {
+			si->adjustValue -= SCROLL_TIME_ADJUSTOFFSET;
+		}
+	}
+}
+
+static void Scroll_ListBox_ThumbFunc(void *p) {
+	scrollInfo_t *si = (scrollInfo_t*)p;
+	rectDef_t r;
+	int pos, max;
+
+	listBoxDef_t *listPtr = (listBoxDef_t*)si->item->typeData;
+	if (si->item->window.flags & WINDOW_HORIZONTAL) {
+		if (DC->cursorx == si->xStart) {
+			return;
+		}
+		r.x = si->item->window.rect.x + SCROLLBAR_SIZE + 1;
+		r.y = si->item->window.rect.y + si->item->window.rect.h - SCROLLBAR_SIZE - 1;
+		r.h = SCROLLBAR_SIZE;
+		r.w = si->item->window.rect.w - (SCROLLBAR_SIZE*2) - 2;
+		max = Item_ListBox_MaxScroll(si->item);
+		//
+		pos = (DC->cursorx - r.x - SCROLLBAR_SIZE/2) * max / (r.w - SCROLLBAR_SIZE);
+		if (pos < 0) {
+			pos = 0;
+		}
+		else if (pos > max) {
+			pos = max;
+		}
+		listPtr->startPos = pos;
+		si->xStart = DC->cursorx;
+	}
+	else if (DC->cursory != si->yStart) {
+
+		r.x = si->item->window.rect.x + si->item->window.rect.w - SCROLLBAR_SIZE - 1;
+		r.y = si->item->window.rect.y + SCROLLBAR_SIZE + 1;
+		r.h = si->item->window.rect.h - (SCROLLBAR_SIZE*2) - 2;
+		r.w = SCROLLBAR_SIZE;
+		max = Item_ListBox_MaxScroll(si->item);
+
+		// Multiple rows and columns (since it's more than twice as wide as an element)
+		if (( si->item->window.rect.w > (listPtr->elementWidth*2)) &&  (listPtr->elementStyle == LISTBOX_IMAGE))
+		{
+			int rowLength, rowMax;
+			rowLength = si->item->window.rect.w / listPtr->elementWidth; 
+			rowMax = max / rowLength;
+
+			pos = (DC->cursory - r.y - SCROLLBAR_SIZE/2) * rowMax / (r.h - SCROLLBAR_SIZE);
+			pos *= rowLength;
+		}
+		else
+		{
+			pos = (DC->cursory - r.y - SCROLLBAR_SIZE/2) * max / (r.h - SCROLLBAR_SIZE);
+		}
+
+		if (pos < 0) {
+			pos = 0;
+		}
+		else if (pos > max) {
+			pos = max;
+		}
+		listPtr->startPos = pos;
+		si->yStart = DC->cursory;
+	}
+
+	if (DC->realTime > si->nextScrollTime) { 
+		// need to scroll which is done by simulating a click to the item
+		// this is done a bit sideways as the autoscroll "knows" that the item is a listbox
+		// so it calls it directly
+		Item_ListBox_HandleKey(si->item, si->scrollKey, qtrue, qfalse);
+		si->nextScrollTime = DC->realTime + si->adjustValue; 
+	}
+
+	if (DC->realTime > si->nextAdjustTime) {
+		si->nextAdjustTime = DC->realTime + SCROLL_TIME_ADJUST;
+		if (si->adjustValue > SCROLL_TIME_FLOOR) {
+			si->adjustValue -= SCROLL_TIME_ADJUSTOFFSET;
+		}
+	}
+}
+
+static void Scroll_Slider_ThumbFunc(void *p) {
+	float x, value, cursorx;
+	scrollInfo_t *si = (scrollInfo_t*)p;
+	editFieldDef_t *editDef = (editFieldDef_t *) si->item->typeData;
+
+	if (si->item->text) {
+		x = si->item->textRect.x + si->item->textRect.w + 8;
+	} else {
+		x = si->item->window.rect.x;
+	}
+
+	cursorx = DC->cursorx;
+
+	if (cursorx < x) {
+		cursorx = x;
+	} else if (cursorx > x + SLIDER_WIDTH) {
+		cursorx = x + SLIDER_WIDTH;
+	}
+	value = cursorx - x;
+	value /= SLIDER_WIDTH;
+	value *= (editDef->maxVal - editDef->minVal);
+	value += editDef->minVal;
+	DC->setCVar(si->item->cvar, va("%f", value));
+}
+
+void Item_StartCapture(itemDef_t *item, int key) 
+{
+	int flags;
+	switch (item->type) 
+	{
+	    case ITEM_TYPE_EDITFIELD:
+		case ITEM_TYPE_NUMERICFIELD:
+		case ITEM_TYPE_LISTBOX:
+		{
+			flags = Item_ListBox_OverLB(item, DC->cursorx, DC->cursory);
+			if (flags & (WINDOW_LB_LEFTARROW | WINDOW_LB_RIGHTARROW)) {
+				scrollInfo.nextScrollTime = DC->realTime + SCROLL_TIME_START;
+				scrollInfo.nextAdjustTime = DC->realTime + SCROLL_TIME_ADJUST;
+				scrollInfo.adjustValue = SCROLL_TIME_START;
+				scrollInfo.scrollKey = key;
+				scrollInfo.scrollDir = (flags & WINDOW_LB_LEFTARROW) ? qtrue : qfalse;
+				scrollInfo.item = item;
+				captureData = &scrollInfo;
+				captureFunc = &Scroll_ListBox_AutoFunc;
+				itemCapture = item;
+			} else if (flags & WINDOW_LB_THUMB) {
+				scrollInfo.scrollKey = key;
+				scrollInfo.item = item;
+				scrollInfo.xStart = DC->cursorx;
+				scrollInfo.yStart = DC->cursory;
+				captureData = &scrollInfo;
+				captureFunc = &Scroll_ListBox_ThumbFunc;
+				itemCapture = item;
+			}
+			break;
+		}
+
+		case ITEM_TYPE_TEXTSCROLL:
+			flags = Item_TextScroll_OverLB (item, DC->cursorx, DC->cursory);
+			if (flags & (WINDOW_LB_LEFTARROW | WINDOW_LB_RIGHTARROW)) 
+			{
+				scrollInfo.nextScrollTime = DC->realTime + SCROLL_TIME_START;
+				scrollInfo.nextAdjustTime = DC->realTime + SCROLL_TIME_ADJUST;
+				scrollInfo.adjustValue = SCROLL_TIME_START;
+				scrollInfo.scrollKey = key;
+				scrollInfo.scrollDir = (flags & WINDOW_LB_LEFTARROW) ? qtrue : qfalse;
+				scrollInfo.item = item;
+				captureData = &scrollInfo;
+				captureFunc = &Scroll_TextScroll_AutoFunc;
+				itemCapture = item;
+			} 
+			else if (flags & WINDOW_LB_THUMB) 
+			{
+				scrollInfo.scrollKey = key;
+				scrollInfo.item = item;
+				scrollInfo.xStart = DC->cursorx;
+				scrollInfo.yStart = DC->cursory;
+				captureData = &scrollInfo;
+				captureFunc = &Scroll_TextScroll_ThumbFunc;
+				itemCapture = item;
+			}
+			break;
+
+		case ITEM_TYPE_SLIDER:
+		{
+			flags = Item_Slider_OverSlider(item, DC->cursorx, DC->cursory);
+			if (flags & WINDOW_LB_THUMB) {
+				scrollInfo.scrollKey = key;
+				scrollInfo.item = item;
+				scrollInfo.xStart = DC->cursorx;
+				scrollInfo.yStart = DC->cursory;
+				captureData = &scrollInfo;
+				captureFunc = &Scroll_Slider_ThumbFunc;
+				itemCapture = item;
+			}
+			break;
+		}
+	}
+}
+
+void Item_StopCapture(itemDef_t *item) {
+
+}
+
+qboolean Item_Slider_HandleKey(itemDef_t *item, int key, qboolean down) {
+	float x, value, width, work;
+
+	//DC->Print("slider handle key\n");
+//JLF MPMOVED
+#ifndef _XBOX
+	if (item->window.flags & WINDOW_HASFOCUS && item->cvar && Rect_ContainsPoint(&item->window.rect, DC->cursorx, DC->cursory)) {
+		if (key == A_MOUSE1 || key == A_ENTER || key == A_MOUSE2 || key == A_MOUSE3) {
+			editFieldDef_t *editDef = (editFieldDef_t *) item->typeData;
+			if (editDef) {
+				rectDef_t testRect;
+				width = SLIDER_WIDTH;
+				if (item->text) {
+					x = item->textRect.x + item->textRect.w + 8;
+				} else {
+					x = item->window.rect.x;
+				}
+
+				testRect = item->window.rect;
+				testRect.x = x;
+				value = (float)SLIDER_THUMB_WIDTH / 2;
+				testRect.x -= value;
+				//DC->Print("slider x: %f\n", testRect.x);
+				testRect.w = (SLIDER_WIDTH + (float)SLIDER_THUMB_WIDTH / 2);
+				//DC->Print("slider w: %f\n", testRect.w);
+				if (Rect_ContainsPoint(&testRect, DC->cursorx, DC->cursory)) {
+					work = DC->cursorx - x;
+					value = work / width;
+					value *= (editDef->maxVal - editDef->minVal);
+					// vm fuckage
+					// value = (((float)(DC->cursorx - x)/ SLIDER_WIDTH) * (editDef->maxVal - editDef->minVal));
+					value += editDef->minVal;
+					DC->setCVar(item->cvar, va("%f", value));
+					return qtrue;
+				}
+			}
+		}
+	}
+#else  //def _XBOX
+//JLF
+	if (item->window.flags & WINDOW_HASFOCUS && item->cvar)
+	{
+		if (key == A_CURSOR_LEFT)
+		{
+			editFieldDef_t *editDef = (editFieldDef_s *) item->typeData;
+			if (editDef) 
+			{
+				value = DC->getCVarValue(item->cvar);
+				value -= (editDef->maxVal-editDef->minVal)/TICK_COUNT;
+				if ( value < editDef->minVal)
+					value = editDef->minVal;
+				DC->setCVar(item->cvar, va("%f", value));
+				return qtrue;
+			}
+		}
+		if (key == A_CURSOR_RIGHT)
+		{
+			editFieldDef_t *editDef = (editFieldDef_s *) item->typeData;
+			if (editDef) 
+			{
+				value = DC->getCVarValue(item->cvar);
+				value += (editDef->maxVal-editDef->minVal)/TICK_COUNT;
+				if ( value > editDef->maxVal)
+					value = editDef->maxVal;
+				DC->setCVar(item->cvar, va("%f", value));
+				return qtrue;
+			}
+		}
+	}
+#endif
+	DC->Print("slider handle key exit\n");
+	return qfalse;
+}
+
+
+qboolean Item_HandleKey(itemDef_t *item, int key, qboolean down) {
+
+	if (itemCapture) {
+		Item_StopCapture(itemCapture);
+		itemCapture = NULL;
+		captureFunc = 0;
+		captureData = NULL;
+	} else {
+	  // bk001206 - parentheses
+		if ( down && ( key == A_MOUSE1 || key == A_MOUSE2 || key == A_MOUSE3 ) ) {
+			Item_StartCapture(item, key);
+		}
+	}
+
+	if (!down) {
+		return qfalse;
+	}
+
+  switch (item->type) {
+    case ITEM_TYPE_BUTTON:
+#ifdef _XBOX
+			return Item_Button_HandleKey(item, key);
+#else
+			return qfalse;
+#endif
+      break;
+    case ITEM_TYPE_RADIOBUTTON:
+      return qfalse;
+      break;
+    case ITEM_TYPE_CHECKBOX:
+      return qfalse;
+      break;
+    case ITEM_TYPE_EDITFIELD:
+    case ITEM_TYPE_NUMERICFIELD:
+		if (key == A_MOUSE1 || key == A_MOUSE2 || key == A_ENTER)
+		{
+			editFieldDef_t *editPtr = (editFieldDef_t*)item->typeData;
+
+			if (item->cvar && editPtr)
+			{
+				editPtr->paintOffset = 0;
+			}
+
+      //return Item_TextField_HandleKey(item, key);
+		}
+      return qfalse;
+      break;
+    case ITEM_TYPE_COMBO:
+      return qfalse;
+      break;
+    case ITEM_TYPE_LISTBOX:
+      return Item_ListBox_HandleKey(item, key, down, qfalse);
+      break;
+	case ITEM_TYPE_TEXTSCROLL:
+      return Item_TextScroll_HandleKey(item, key, down, qfalse);
+      break;
+    case ITEM_TYPE_YESNO:
+      return Item_YesNo_HandleKey(item, key);
+      break;
+    case ITEM_TYPE_MULTI:
+      return Item_Multi_HandleKey(item, key);
+      break;
+    case ITEM_TYPE_OWNERDRAW:
+      return Item_OwnerDraw_HandleKey(item, key);
+      break;
+    case ITEM_TYPE_BIND:
+			return Item_Bind_HandleKey(item, key, down);
+      break;
+    case ITEM_TYPE_SLIDER:
+      return Item_Slider_HandleKey(item, key, down);
+      break;
+#ifdef _XBOX
+	case ITEM_TYPE_TEXT:
+	  return Item_Text_HandleKey(item, key);
+	  break;
+#endif
+    //case ITEM_TYPE_IMAGE:
+    //  Item_Image_Paint(item);
+    //  break;
+    default:
+      return qfalse;
+      break;
+  }
+
+  //return qfalse;
+}
+
+
+//JLFACCEPT MPMOVED
+/*
+-----------------------------------------
+Item_HandleAccept
+	If Item has an accept script, run it.
+-------------------------------------------
+*/
+qboolean Item_HandleAccept(itemDef_t * item)
+{
+	if (item->accept)
+	{
+		Item_RunScript(item, item->accept);
+		return qtrue;
+	}
+	return qfalse;
+}
+
+#ifdef _XBOX	// Xbox-only event handlers
+
+//JLFDPADSCRIPT MPMOVED
+/*
+-----------------------------------------
+Item_HandleSelectionNext
+	If Item has an selectionNext script, run it.
+-------------------------------------------
+*/
+qboolean Item_HandleSelectionNext(itemDef_t * item)
+{
+	if (item->selectionNext)
+	{
+		Item_RunScript(item, item->selectionNext);
+		return qtrue;
+	}
+	return qfalse;
+}
+
+//JLFDPADSCRIPT MPMOVED
+/*
+-----------------------------------------
+Item_HandleSelectionPrev
+	If Item has an selectionPrev script, run it.
+-------------------------------------------
+*/
+qboolean Item_HandleSelectionPrev(itemDef_t * item)
+{
+	if (item->selectionPrev)
+	{
+		Item_RunScript(item, item->selectionPrev);
+		return qtrue;
+	}
+	return qfalse;
+}
+
+//JLF END
+#endif	// _XBOX
+
+
+void Item_Action(itemDef_t *item) {
+  if (item) {
+    Item_RunScript(item, item->action);
+  }
+}
+
+
+
+itemDef_t *Menu_SetPrevCursorItem(menuDef_t *menu) {
+	qboolean wrapped = qfalse;
+	int oldCursor = menu->cursorItem;
+
+	if (menu->cursorItem < 0) {
+		menu->cursorItem = menu->itemCount-1;
+		wrapped = qtrue;
+	} 
+
+	while (menu->cursorItem > -1) 
+	{
+		menu->cursorItem--;
+		if (menu->cursorItem < 0) {
+			if (wrapped)
+			{
+				break;
+			}
+			wrapped = qtrue;
+			menu->cursorItem = menu->itemCount -1;
+		}
+
+		if (Item_SetFocus(menu->items[menu->cursorItem], DC->cursorx, DC->cursory)) {
+			Menu_HandleMouseMove(menu, menu->items[menu->cursorItem]->window.rect.x + 1, menu->items[menu->cursorItem]->window.rect.y + 1);
+			return menu->items[menu->cursorItem];
+		}
+	}
+	menu->cursorItem = oldCursor;
+	return NULL;
+
+}
+
+itemDef_t *Menu_SetNextCursorItem(menuDef_t *menu) {
+
+  qboolean wrapped = qfalse;
+	int oldCursor = menu->cursorItem;
+
+
+  if (menu->cursorItem == -1) {
+    menu->cursorItem = 0;
+    wrapped = qtrue;
+  }
+
+  while (menu->cursorItem < menu->itemCount) {
+
+    menu->cursorItem++;
+    if (menu->cursorItem >= menu->itemCount && !wrapped) {
+      wrapped = qtrue;
+      menu->cursorItem = 0;
+    }
+		if (Item_SetFocus(menu->items[menu->cursorItem], DC->cursorx, DC->cursory)) {
+			Menu_HandleMouseMove(menu, menu->items[menu->cursorItem]->window.rect.x + 1, menu->items[menu->cursorItem]->window.rect.y + 1);
+      return menu->items[menu->cursorItem];
+    }
+    
+  }
+
+	menu->cursorItem = oldCursor;
+	return NULL;
+}
+
+static void Window_CloseCinematic(windowDef_t *window) {
+	if (window->style == WINDOW_STYLE_CINEMATIC && window->cinematic >= 0) {
+		DC->stopCinematic(window->cinematic);
+		window->cinematic = -1;
+	}
+}
+
+static void Menu_CloseCinematics(menuDef_t *menu) {
+	if (menu) {
+		int i;
+		Window_CloseCinematic(&menu->window);
+	  for (i = 0; i < menu->itemCount; i++) {
+		  Window_CloseCinematic(&menu->items[i]->window);
+			if (menu->items[i]->type == ITEM_TYPE_OWNERDRAW) {
+				DC->stopCinematic(0-menu->items[i]->window.ownerDraw);
+			}
+	  }
+	}
+}
+
+static void Display_CloseCinematics() {
+	int i;
+	for (i = 0; i < menuCount; i++) {
+		Menu_CloseCinematics(&Menus[i]);
+	}
+}
+
+void  Menus_Activate(menuDef_t *menu) {
+
+//JLFCALLOUT MPMOVED
+#ifdef _XBOX
+	DC->setCVar("ui_hideAcallout" ,"0");
+	DC->setCVar("ui_hideBcallout" ,"0");
+	DC->setCVar("ui_hideCcallout" ,"0");
+#endif
+//JLF END
+	menu->window.flags |= (WINDOW_HASFOCUS | WINDOW_VISIBLE);
+	if (menu->onOpen) {
+		itemDef_t item;
+		item.parent = menu;
+		Item_RunScript(&item, menu->onOpen);
+	}
+
+	if (menu->soundName && *menu->soundName) {
+//		DC->stopBackgroundTrack();					// you don't want to do this since it will reset s_rawend
+		DC->startBackgroundTrack(menu->soundName, menu->soundName, qfalse);
+	}
+
+	menu->appearanceTime = 0;
+	Display_CloseCinematics();
+
+}
+
+int Display_VisibleMenuCount() {
+	int i, count;
+	count = 0;
+	for (i = 0; i < menuCount; i++) {
+		if (Menus[i].window.flags & (WINDOW_FORCED | WINDOW_VISIBLE)) {
+			count++;
+		}
+	}
+	return count;
+}
+
+void Menus_HandleOOBClick(menuDef_t *menu, int key, qboolean down) {
+	if (menu) {
+//JLFMOUSE
+#ifdef _XBOX
+		Menu_HandleMouseMove(menu, DC->cursorx, DC->cursory);
+		Menu_HandleKey(menu, key, down);
+		return; 
+#endif
+		int i;
+		// basically the behaviour we are looking for is if there are windows in the stack.. see if 
+		// the cursor is within any of them.. if not close them otherwise activate them and pass the 
+		// key on.. force a mouse move to activate focus and script stuff 
+		if (down && menu->window.flags & WINDOW_OOB_CLICK) {
+			Menu_RunCloseScript(menu);
+			menu->window.flags &= ~(WINDOW_HASFOCUS | WINDOW_VISIBLE);
+		}
+
+		for (i = 0; i < menuCount; i++) {
+			if (Menu_OverActiveItem(&Menus[i], DC->cursorx, DC->cursory)) {
+				Menu_RunCloseScript(menu);
+				menu->window.flags &= ~(WINDOW_HASFOCUS | WINDOW_VISIBLE);
+				Menus_Activate(&Menus[i]);
+				Menu_HandleMouseMove(&Menus[i], DC->cursorx, DC->cursory);
+				Menu_HandleKey(&Menus[i], key, down);
+			}
+		}
+
+		if (Display_VisibleMenuCount() == 0) {
+			if (DC->Pause) {
+				DC->Pause(qfalse);
+			}
+		}
+		Display_CloseCinematics();
+	}
+}
+
+
+void Menu_HandleKey(menuDef_t *menu, int key, qboolean down) {
+	int i;
+	itemDef_t *item = NULL;
+	qboolean inHandler = qfalse;
+
+	if (inHandler) {
+		return;
+	}
+
+	inHandler = qtrue;
+	if (g_waitingForKey && down) {
+		Item_Bind_HandleKey(g_bindItem, key, down);
+		inHandler = qfalse;
+		return;
+	}
+
+	if (g_editingField && down) 
+	{
+		if (!Item_TextField_HandleKey(g_editItem, key)) 
+		{
+			g_editingField = qfalse;
+			g_editItem = NULL;
+			inHandler = qfalse;
+			return;
+		} 
+		else if (key == A_MOUSE1 || key == A_MOUSE2 || key == A_MOUSE3) 
+		{
+			// switching fields so reset printed text of edit field
+			Leaving_EditField(g_editItem);
+			g_editingField = qfalse;
+			g_editItem = NULL;
+			Display_MouseMove(NULL, DC->cursorx, DC->cursory);
+		} 
+		else if (key == A_TAB || key == A_CURSOR_UP || key == A_CURSOR_DOWN) 
+		{
+			return;
+		}
+	}
+
+	if (menu == NULL) {
+		inHandler = qfalse;
+		return;
+	}
+	//JLFMOUSE  
+		// see if the mouse is within the window bounds and if so is this a mouse click
+#ifndef _XBOX
+	if (down && !(menu->window.flags & WINDOW_POPUP) && !Rect_ContainsPoint(&menu->window.rect, DC->cursorx, DC->cursory)) 
+#else
+	if (down) 
+#endif
+	{
+		static qboolean inHandleKey = qfalse;
+		// bk001206 - parentheses
+		if (!inHandleKey && ( key == A_MOUSE1 || key == A_MOUSE2 || key == A_MOUSE3 ) ) {
+			inHandleKey = qtrue;
+			Menus_HandleOOBClick(menu, key, down);
+			inHandleKey = qfalse;
+			inHandler = qfalse;
+			return;
+		}
+	}
+
+	// get the item with focus
+	for (i = 0; i < menu->itemCount; i++) {
+		if (menu->items[i]->window.flags & WINDOW_HASFOCUS) {
+			item = menu->items[i];
+		}
+	}
+
+	// Ignore if disabled
+	if (item && item->disabled) 
+	{
+		return;
+	}
+
+	if (item != NULL) {
+		if (Item_HandleKey(item, key, down)) 
+		{
+
+#ifdef _XBOX
+			if (key == A_MOUSE1 || key == A_MOUSE2 ||(item->type == ITEM_TYPE_MULTI && (key == A_CURSOR_RIGHT || key == A_CURSOR_LEFT)))
+			{
+#endif
+				// It is possible for an item to be disable after Item_HandleKey is run (like in Voice Chat)
+				if (!item->disabled) 
+				{
+					Item_Action(item);
+				}
+#ifdef _XBOX
+			}
+#endif
+			inHandler = qfalse;
+			return;
+		}
+	}
+
+	if (!down) {
+		inHandler = qfalse;
+		return;
+	}
+
+	// default handling
+	switch ( key ) {
+
+		case A_F11:
+			if (DC->getCVarValue("developer")) {
+				debugMode ^= 1;
+			}
+			break;
+
+		case A_F12:
+			if (DC->getCVarValue("developer")) {
+				DC->executeText(EXEC_APPEND, "screenshot\n");
+			}
+			break;
+		case A_KP_8:
+		case A_CURSOR_UP:
+			Menu_SetPrevCursorItem(menu);
+			break;
+
+		case A_ESCAPE:
+			if (!g_waitingForKey && menu->onESC) {
+				itemDef_t it;
+		    it.parent = menu;
+		    Item_RunScript(&it, menu->onESC);
+			}
+		    g_waitingForKey = qfalse;
+			break;
+		case A_TAB:
+		case A_KP_2:
+		case A_CURSOR_DOWN:
+			Menu_SetNextCursorItem(menu);
+			break;
+
+		case A_MOUSE1:
+		case A_MOUSE2:
+			if (item) {
+				if (item->type == ITEM_TYPE_TEXT) {
+//JLFMOUSE
+#ifndef _XBOX
+					if (Rect_ContainsPoint(&item->window.rect, DC->cursorx, DC->cursory))
+#endif
+					{
+						Item_Action(item);
+					}
+				} else if (item->type == ITEM_TYPE_EDITFIELD || item->type == ITEM_TYPE_NUMERICFIELD) {
+//JLFMOUSE
+#ifndef _XBOX
+					if (Rect_ContainsPoint(&item->window.rect, DC->cursorx, DC->cursory)) 
+#endif			
+					{	
+						Item_Action(item);
+						item->cursorPos = 0;
+						g_editingField = qtrue;
+						g_editItem = item;
+						DC->setOverstrikeMode(qtrue);
+					}
+				}
+				
+	//JLFACCEPT
+// add new types here as needed
+/* Notes:
+	Most controls will use the dpad to move through the selection possibilies.  Buttons are the only exception.
+	Buttons will be assumed to all be on one menu together.  If the start or A button is pressed on a control focus, that
+	means that the menu is accepted and move onto the next menu.  If the start or A button is pressed on a button focus it
+	should just process the action and not support the accept functionality.
+*/
+
+//JLFACCEPT MPMOVED
+				else if ( item->type == ITEM_TYPE_MULTI || item->type == ITEM_TYPE_YESNO || item->type == ITEM_TYPE_SLIDER)
+				{
+					if (Item_HandleAccept(item))
+					{
+						//Item processed it overriding the menu processing
+						return;
+					}
+					else if (menu->onAccept) 
+					{
+						itemDef_t it;
+						it.parent = menu;
+						Item_RunScript(&it, menu->onAccept);
+					}
+				}
+//END JLFACCEPT			
+				else {
+//JLFMOUSE
+#ifndef _XBOX
+					if (Rect_ContainsPoint(&item->window.rect, DC->cursorx, DC->cursory))
+#endif
+					{
+
+						Item_Action(item);
+					}
+				}
+			}
+			break;
+
+		case A_JOY0:
+		case A_JOY1:
+		case A_JOY2:
+		case A_JOY3:
+		case A_JOY4:
+		case A_AUX0:
+		case A_AUX1:
+		case A_AUX2:
+		case A_AUX3:
+		case A_AUX4:
+		case A_AUX5:
+		case A_AUX6:
+		case A_AUX7:
+		case A_AUX8:
+		case A_AUX9:
+		case A_AUX10:
+		case A_AUX11:
+		case A_AUX12:
+		case A_AUX13:
+		case A_AUX14:
+		case A_AUX15:
+		case A_AUX16:
+			break;
+		case A_KP_ENTER:
+		case A_ENTER:
+			if (item) {
+				if (item->type == ITEM_TYPE_EDITFIELD || item->type == ITEM_TYPE_NUMERICFIELD) {
+					item->cursorPos = 0;
+					g_editingField = qtrue;
+					g_editItem = item;
+					DC->setOverstrikeMode(qtrue);
+				} else {
+						Item_Action(item);
+				}
+			}
+			break;
+	}
+	inHandler = qfalse;
+}
+
+void ToWindowCoords(float *x, float *y, windowDef_t *window) {
+	if (window->border != 0) {
+		*x += window->borderSize;
+		*y += window->borderSize;
+	} 
+	*x += window->rect.x;
+	*y += window->rect.y;
+}
+
+void Rect_ToWindowCoords(rectDef_t *rect, windowDef_t *window) {
+	ToWindowCoords(&rect->x, &rect->y, window);
+}
+
+void Item_SetTextExtents(itemDef_t *item, int *width, int *height, const char *text) {
+	const char *textPtr = (text) ? text : item->text;
+
+	if (textPtr == NULL ) {
+		return;
+	}
+
+	*width = item->textRect.w;
+	*height = item->textRect.h;
+
+	// keeps us from computing the widths and heights more than once
+	if (*width == 0 || (item->type == ITEM_TYPE_OWNERDRAW && item->textalignment == ITEM_ALIGN_CENTER)
+#ifndef CGAME
+		|| (item->text && item->text[0]=='@' && item->asset != se_language.modificationCount )	//string package language changed
+#endif
+		)
+	{
+		int originalWidth = DC->textWidth(textPtr, item->textscale, item->iMenuFont);
+
+		if (item->type == ITEM_TYPE_OWNERDRAW && (item->textalignment == ITEM_ALIGN_CENTER || item->textalignment == ITEM_ALIGN_RIGHT)) 
+		{
+			originalWidth += DC->ownerDrawWidth(item->window.ownerDraw, item->textscale);
+		} 
+		else if (item->type == ITEM_TYPE_EDITFIELD && item->textalignment == ITEM_ALIGN_CENTER && item->cvar) 
+		{
+			char buff[256];
+			DC->getCVarString(item->cvar, buff, 256);
+			originalWidth += DC->textWidth(buff, item->textscale, item->iMenuFont);
+		}
+
+		*width = DC->textWidth(textPtr, item->textscale, item->iMenuFont);
+		*height = DC->textHeight(textPtr, item->textscale, item->iMenuFont);
+		
+		item->textRect.w = *width;
+		item->textRect.h = *height;
+		item->textRect.x = item->textalignx;
+		item->textRect.y = item->textaligny;
+		if (item->textalignment == ITEM_ALIGN_RIGHT) {
+			item->textRect.x = item->textalignx - originalWidth;
+		} else if (item->textalignment == ITEM_ALIGN_CENTER) {
+			item->textRect.x = item->textalignx - originalWidth / 2;
+		}
+
+		ToWindowCoords(&item->textRect.x, &item->textRect.y, &item->window);
+#ifndef CGAME
+		if (item->text && item->text[0]=='@' )//string package
+		{//mark language
+			item->asset = se_language.modificationCount;
+		}
+#endif
+	}
+}
+
+void Item_TextColor(itemDef_t *item, vec4_t *newColor) {
+	vec4_t lowLight;
+	menuDef_t *parent = (menuDef_t*)item->parent;
+
+	Fade(&item->window.flags, &item->window.foreColor[3], parent->fadeClamp, &item->window.nextTime, parent->fadeCycle, qtrue, parent->fadeAmount);
+
+	if (item->window.flags & WINDOW_HASFOCUS) {
+		lowLight[0] = 0.8 * parent->focusColor[0]; 
+		lowLight[1] = 0.8 * parent->focusColor[1]; 
+		lowLight[2] = 0.8 * parent->focusColor[2]; 
+		lowLight[3] = 0.8 * parent->focusColor[3]; 
+		LerpColor(parent->focusColor,lowLight,*newColor,0.5+0.5*sin((float)(DC->realTime / PULSE_DIVISOR)));
+	} else if (item->textStyle == ITEM_TEXTSTYLE_BLINK && !((DC->realTime/BLINK_DIVISOR) & 1)) {
+		lowLight[0] = 0.8 * item->window.foreColor[0]; 
+		lowLight[1] = 0.8 * item->window.foreColor[1]; 
+		lowLight[2] = 0.8 * item->window.foreColor[2]; 
+		lowLight[3] = 0.8 * item->window.foreColor[3]; 
+		LerpColor(item->window.foreColor,lowLight,*newColor,0.5+0.5*sin((float)(DC->realTime / PULSE_DIVISOR)));
+	} else {
+		memcpy(newColor, &item->window.foreColor, sizeof(vec4_t));
+		// items can be enabled and disabled based on cvars
+	}
+
+	if (item->disabled) 
+	{
+		memcpy(newColor, &parent->disableColor, sizeof(vec4_t));
+	}
+
+	if (item->enableCvar && *item->enableCvar && item->cvarTest && *item->cvarTest) {
+		if (item->cvarFlags & (CVAR_ENABLE | CVAR_DISABLE) && !Item_EnableShowViaCvar(item, CVAR_ENABLE)) {
+			memcpy(newColor, &parent->disableColor, sizeof(vec4_t));
+		}
+	}
+}
+
+void Item_Text_AutoWrapped_Paint(itemDef_t *item) {
+	char text[2048];
+	const char *p, *textPtr, *newLinePtr;
+	char buff[2048];
+	int height, len, textWidth, newLine, newLineWidth;	//int width;
+	float y;
+	vec4_t color;
+
+	textWidth = 0;
+	newLinePtr = NULL;
+
+	if (item->text == NULL) {
+		if (item->cvar == NULL) {
+			return;
+		}
+		else {
+			DC->getCVarString(item->cvar, text, sizeof(text));
+			textPtr = text;
+		}
+	}
+	else {
+		textPtr = item->text;
+	}
+	if (*textPtr == '@')	// string reference
+	{
+		trap_SP_GetStringTextString( &textPtr[1], text, sizeof(text));
+		textPtr = text;
+	}
+	if (*textPtr == '\0') {
+		return;
+	}
+	Item_TextColor(item, &color);
+	//Item_SetTextExtents(item, &width, &height, textPtr);
+	//if (item->value == 0)
+	//{
+	//	item->value = (int)(0.5 + (float)DC->textWidth(textPtr, item->textscale, item->font) / item->window.rect.w);
+	//}
+	height = DC->textHeight(textPtr, item->textscale, item->iMenuFont);
+
+	y = item->textaligny;
+	len = 0;
+	buff[0] = '\0';
+	newLine = 0;
+	newLineWidth = 0;
+	p = textPtr;
+	while (p) {	//findmeste (this will break widechar languages)!
+		if (*p == ' ' || *p == '\t' || *p == '\n' || *p == '\0') {
+			newLine = len;
+			newLinePtr = p+1;
+			newLineWidth = textWidth;
+		}
+		textWidth = DC->textWidth(buff, item->textscale, 0);
+		if ( (newLine && textWidth > item->window.rect.w) || *p == '\n' || *p == '\0') {
+			if (len) {
+				if (item->textalignment == ITEM_ALIGN_LEFT) {
+					item->textRect.x = item->textalignx;
+				} else if (item->textalignment == ITEM_ALIGN_RIGHT) {
+					item->textRect.x = item->textalignx - newLineWidth;
+				} else if (item->textalignment == ITEM_ALIGN_CENTER) {
+					item->textRect.x = item->textalignx - newLineWidth / 2;
+				}
+				item->textRect.y = y;
+				ToWindowCoords(&item->textRect.x, &item->textRect.y, &item->window);
+				//
+				buff[newLine] = '\0';
+				DC->drawText(item->textRect.x, item->textRect.y, item->textscale, color, buff, 0, 0, item->textStyle, item->iMenuFont);
+			}
+			if (*p == '\0') {
+				break;
+			}
+			//
+			y += height + 5;
+			p = newLinePtr;
+			len = 0;
+			newLine = 0;
+			newLineWidth = 0;
+			continue;
+		}
+		buff[len++] = *p++;
+		buff[len] = '\0';
+	}
+}
+
+void Item_Text_Wrapped_Paint(itemDef_t *item) {
+	char text[1024];
+	const char *p, *start, *textPtr;
+	char buff[1024];
+	int width, height;
+	float x, y;
+	vec4_t color;
+
+	// now paint the text and/or any optional images
+	// default to left
+
+	if (item->text == NULL) {
+		if (item->cvar == NULL) {
+			return;
+		}
+		else {
+			DC->getCVarString(item->cvar, text, sizeof(text));
+			textPtr = text;
+		}
+	}
+	else {
+		textPtr = item->text;
+	}
+	if (*textPtr == '@')	// string reference
+	{
+		trap_SP_GetStringTextString( &textPtr[1], text, sizeof(text));
+		textPtr = text;
+	}
+	if (*textPtr == '\0') {
+		return;
+	}
+
+	Item_TextColor(item, &color);
+	Item_SetTextExtents(item, &width, &height, textPtr);
+
+	x = item->textRect.x;
+	y = item->textRect.y;
+	start = textPtr;
+	p = strchr(textPtr, '\r');
+	while (p && *p) {
+		strncpy(buff, start, p-start+1);
+		buff[p-start] = '\0';
+		DC->drawText(x, y, item->textscale, color, buff, 0, 0, item->textStyle, item->iMenuFont);
+		y += height + 2;
+		start += p - start + 1;
+		p = strchr(p+1, '\r');
+	}
+	DC->drawText(x, y, item->textscale, color, start, 0, 0, item->textStyle, item->iMenuFont);
+}
+
+void Item_Text_Paint(itemDef_t *item) {
+	char text[1024];
+	const char *textPtr;
+	int height, width;
+	vec4_t color;
+
+	if (item->window.flags & WINDOW_WRAPPED) {
+		Item_Text_Wrapped_Paint(item);
+		return;
+	}
+	if (item->window.flags & WINDOW_AUTOWRAPPED) {
+		Item_Text_AutoWrapped_Paint(item);
+		return;
+	}
+
+	if (item->text == NULL) {
+		if (item->cvar == NULL) {
+			return;
+		}
+		else {
+			DC->getCVarString(item->cvar, text, sizeof(text));
+			textPtr = text;
+		}
+	}
+	else {
+		textPtr = item->text;
+	}
+	if (*textPtr == '@')	// string reference
+	{
+		trap_SP_GetStringTextString( &textPtr[1], text, sizeof(text));
+		textPtr = text;
+	}
+
+	// this needs to go here as it sets extents for cvar types as well
+	Item_SetTextExtents(item, &width, &height, textPtr);
+
+	if (*textPtr == '\0') {
+		return;
+	}
+
+
+	Item_TextColor(item, &color);
+
+	DC->drawText(item->textRect.x, item->textRect.y, item->textscale, color, textPtr, 0, 0, item->textStyle, item->iMenuFont);
+
+	if (item->text2)	// Is there a second line of text?
+	{
+		textPtr = item->text2;
+		if (*textPtr == '@')	// string reference
+		{
+			trap_SP_GetStringTextString( &textPtr[1], text, sizeof(text));
+			textPtr = text;
+		}
+		Item_TextColor(item, &color);
+		DC->drawText(item->textRect.x + item->text2alignx, item->textRect.y + item->text2aligny, item->textscale, color, textPtr, 0, 0, item->textStyle,item->iMenuFont);
+	}
+}
+
+
+
+//float			trap_Cvar_VariableValue( const char *var_name );
+//void			trap_Cvar_VariableStringBuffer( const char *var_name, char *buffer, int bufsize );
+
+void Item_TextField_Paint(itemDef_t *item) {
+	char buff[1024];
+	vec4_t newColor, lowLight;
+	int offset;
+	menuDef_t *parent = (menuDef_t*)item->parent;
+	editFieldDef_t *editPtr = (editFieldDef_t*)item->typeData;
+
+	Item_Text_Paint(item);
+
+	buff[0] = '\0';
+
+	if (item->cvar) {
+		DC->getCVarString(item->cvar, buff, sizeof(buff));
+		if (buff[0] == '@')	// string reference
+		{
+			trap_SP_GetStringTextString( &buff[1], buff, sizeof(buff));
+		}
+	} 
+
+	parent = (menuDef_t*)item->parent;
+
+	if (item->window.flags & WINDOW_HASFOCUS) {
+		lowLight[0] = 0.8 * parent->focusColor[0]; 
+		lowLight[1] = 0.8 * parent->focusColor[1]; 
+		lowLight[2] = 0.8 * parent->focusColor[2]; 
+		lowLight[3] = 0.8 * parent->focusColor[3]; 
+		LerpColor(parent->focusColor,lowLight,newColor,0.5+0.5*sin((float)(DC->realTime / PULSE_DIVISOR)));
+	} else {
+		memcpy(&newColor, &item->window.foreColor, sizeof(vec4_t));
+	}
+
+	offset = (item->text && *item->text) ? 8 : 0;
+	if (item->window.flags & WINDOW_HASFOCUS && g_editingField) {
+		char cursor = DC->getOverstrikeMode() ? '_' : '|';
+		DC->drawTextWithCursor(item->textRect.x + item->textRect.w + offset, item->textRect.y, item->textscale, newColor, buff + editPtr->paintOffset, item->cursorPos - editPtr->paintOffset , cursor, item->window.rect.w, item->textStyle, item->iMenuFont);
+	} else {
+		DC->drawText(item->textRect.x + item->textRect.w + offset, item->textRect.y, item->textscale, newColor, buff + editPtr->paintOffset, 0, item->window.rect.w, item->textStyle,item->iMenuFont);
+	}
+}
+
+void Item_YesNo_Paint(itemDef_t *item) {
+	char	sYES[20];
+	char	sNO[20];
+	vec4_t newColor, lowLight;
+	float value;
+	menuDef_t *parent = (menuDef_t*)item->parent;
+	const char *yesnovalue;
+	
+	value = (item->cvar) ? DC->getCVarValue(item->cvar) : 0;
+
+	if (item->window.flags & WINDOW_HASFOCUS) {
+		lowLight[0] = 0.8 * parent->focusColor[0]; 
+		lowLight[1] = 0.8 * parent->focusColor[1]; 
+		lowLight[2] = 0.8 * parent->focusColor[2]; 
+		lowLight[3] = 0.8 * parent->focusColor[3]; 
+		LerpColor(parent->focusColor,lowLight,newColor,0.5+0.5*sin((float)(DC->realTime / PULSE_DIVISOR)));
+	} else {
+		memcpy(&newColor, &item->window.foreColor, sizeof(vec4_t));
+	}
+
+
+	trap_SP_GetStringTextString("MENUS_YES",sYES, sizeof(sYES));
+	trap_SP_GetStringTextString("MENUS_NO", sNO,  sizeof(sNO));
+
+//JLFYESNO MPMOVED
+	if (item->invertYesNo)
+		yesnovalue = (value == 0) ? sYES : sNO;
+	else
+		yesnovalue = (value != 0) ? sYES : sNO;
+	
+	if (item->text) 
+	{
+		Item_Text_Paint(item);
+//JLF MPMOVED
+#ifdef _XBOX
+		if (item->xoffset == 0)
+			DC->drawText(item->textRect.x + item->textRect.w + item->xoffset + 8, item->textRect.y, item->textscale, newColor, yesnovalue, 0, 0,item->textStyle, item->iMenuFont);
+		else
+#endif
+			DC->drawText(item->textRect.x + item->textRect.w + 8, item->textRect.y, item->textscale, newColor, yesnovalue, 0, 0, item->textStyle, item->iMenuFont);
+
+	} 
+	else 
+	{
+//JLF MPMOVED
+#ifdef _XBOX
+		DC->drawText(item->textRect.x + item->xoffset, item->textRect.y, item->textscale, newColor, yesnovalue , 0, 0, item->textStyle, item->iMenuFont);
+#else
+		DC->drawText(item->textRect.x, item->textRect.y, item->textscale, newColor, yesnovalue , 0, 0, item->textStyle, item->iMenuFont);
+#endif
+	}		
+
+/* JLF ORIGINAL CODE
+	if (item->text) {
+		Item_Text_Paint(item);
+//		DC->drawText(item->textRect.x + item->textRect.w + 8, item->textRect.y, item->textscale, newColor, (value != 0) ? sYES : sNO, 0, 0, item->textStyle);
+		DC->drawText(item->textRect.x + item->textRect.w + 8, item->textRect.y, item->textscale, newColor, (value != 0) ? sYES : sNO, 0, 0, item->textStyle,item->iMenuFont);
+	} else {
+//		DC->drawText(item->textRect.x, item->textRect.y, item->textscale, newColor, (value != 0) ? sYES : sNO, 0, 0, item->textStyle);
+		DC->drawText(item->textRect.x, item->textRect.y, item->textscale, newColor, (value != 0) ? sYES : sNO, 0, 0, item->textStyle,item->iMenuFont);
+	}
+*/
+}
+
+void Item_Multi_Paint(itemDef_t *item) {
+	vec4_t newColor, lowLight;
+	const char *text = "";
+	menuDef_t *parent = (menuDef_t*)item->parent;
+	char	temp[MAX_STRING_CHARS];
+
+	if (item->window.flags & WINDOW_HASFOCUS) {
+		lowLight[0] = 0.8 * parent->focusColor[0]; 
+		lowLight[1] = 0.8 * parent->focusColor[1]; 
+		lowLight[2] = 0.8 * parent->focusColor[2]; 
+		lowLight[3] = 0.8 * parent->focusColor[3]; 
+		LerpColor(parent->focusColor,lowLight,newColor,0.5+0.5*sin((float)(DC->realTime / PULSE_DIVISOR)));
+	} else {
+		memcpy(&newColor, &item->window.foreColor, sizeof(vec4_t));
+	}
+
+	text = Item_Multi_Setting(item);
+	if (*text == '@')	// string reference
+	{
+		trap_SP_GetStringTextString( &text[1]  , temp, sizeof(temp));
+		text = temp;
+	}
+	// Is is specifying a cvar to get the item name from?
+	else if (*text == '*')
+	{
+		DC->getCVarString(&text[1], temp, sizeof(temp));
+		text = temp;
+	}
+
+	if (item->text) {
+		Item_Text_Paint(item);
+//JLF  MPMOVED
+#ifdef _XBOX
+		if ( item->xoffset)
+			DC->drawText(item->textRect.x + item->textRect.w + item->xoffset, item->textRect.y, item->textscale, newColor, text, 0,0, item->textStyle, item->iMenuFont);
+		else
+#endif
+			DC->drawText(item->textRect.x + item->textRect.w + 8, item->textRect.y, item->textscale, newColor, text, 0, 0, item->textStyle,item->iMenuFont);
+	} else {
+		//JLF added xoffset
+		DC->drawText(item->textRect.x+item->xoffset, item->textRect.y, item->textscale, newColor, text, 0, 0, item->textStyle,item->iMenuFont);
+	}
+}
+
+
+typedef struct {
+	char	*command;
+	int		id;
+	int		defaultbind1;
+	int		defaultbind2;
+	int		bind1;
+	int		bind2;
+} bind_t;
+
+typedef struct
+{
+	char*	name;
+	float	defaultvalue;
+	float	value;	
+} configcvar_t;
+
+
+static bind_t g_bindings[] = 
+{
+	{"+scores",			 A_TAB,				-1,		-1, -1},
+	{"+button2",		 A_ENTER,			-1,		-1, -1},
+	{"+speed", 			 A_SHIFT,			-1,		-1,	-1},
+	{"+forward", 		 A_CURSOR_UP,		-1,		-1, -1},
+	{"+back", 			 A_CURSOR_DOWN,		-1,		-1, -1},
+	{"+moveleft",		 ',',				-1,		-1, -1},
+	{"+moveright", 		 '.',				-1,		-1, -1},
+	{"+moveup",			 A_SPACE,			-1,		-1, -1},
+	{"+movedown",		 'c',				-1,		-1, -1},
+	{"+left", 			 A_CURSOR_LEFT,		-1,		-1, -1},
+	{"+right", 			 A_CURSOR_RIGHT,	-1,		-1, -1},
+	{"+strafe", 		 A_ALT,				-1,		-1, -1},
+	{"+lookup", 		 A_PAGE_DOWN,		-1,		-1, -1},
+	{"+lookdown",	 	 A_DELETE,			-1,		-1, -1},
+	{"+mlook", 			 '/',				-1,		-1, -1},
+	{"centerview",		 A_END,				-1,		-1, -1},
+//	{"+zoom", 			 -1,				-1,		-1, -1},
+	{"weapon 1",		 '1',				-1,		-1, -1},
+	{"weapon 2",		 '2',				-1,		-1, -1},
+	{"weapon 3",		 '3',				-1,		-1, -1},
+	{"weapon 4",		 '4',				-1,		-1, -1},
+	{"weapon 5",		 '5',				-1,		-1, -1},
+	{"weapon 6",		 '6',				-1,		-1, -1},
+	{"weapon 7",		 '7',				-1,		-1, -1},
+	{"weapon 8",		 '8',				-1,		-1, -1},
+	{"weapon 9",		 '9',				-1,		-1, -1},
+	{"weapon 10",		 '0',				-1,		-1, -1},
+	{"saberAttackCycle", 'l',				-1,		-1, -1},
+	{"weapon 11",		 -1,				-1,		-1, -1},
+	{"weapon 12",		 -1,				-1,		-1, -1},
+	{"weapon 13",		 -1,				-1,		-1, -1},
+	{"+attack", 		 A_CTRL,			-1,		-1, -1},
+	{"+altattack", 		-1,					-1,		-1,	-1},
+	{"+use",			-1,					-1,		-1, -1},
+	{"engage_duel",		'h',				-1,		-1, -1},
+	{"taunt",			'u',				-1,		-1, -1},
+	{"bow",				-1,					-1,		-1, -1},
+	{"meditate",		-1,					-1,		-1, -1},
+	{"flourish",		-1,					-1,		-1, -1},
+	{"gloat",			-1,					-1,		-1, -1},
+	{"weapprev",		 '[',				-1,		-1, -1},
+	{"weapnext", 		 ']',				-1,		-1, -1},
+	{"prevTeamMember",	'w',				-1,		-1, -1},
+	{"nextTeamMember",	'r',				-1,		-1, -1},
+	{"nextOrder",		't',				-1,		-1, -1},
+	{"confirmOrder",	'y',				-1,		-1, -1},
+	{"denyOrder",		'n',				-1,		-1, -1},
+	{"taskOffense",		'o',				-1,		-1, -1},
+	{"taskDefense",		'd',				-1,		-1, -1},
+	{"taskPatrol",		'p',				-1,		-1, -1},
+	{"taskCamp",		'c',				-1,		-1, -1},
+	{"taskFollow",		'f',				-1,		-1, -1},
+	{"taskRetrieve",	'v',				-1,		-1, -1},
+	{"taskEscort",		'e',				-1,		-1, -1},
+	{"taskOwnFlag",		'i',				-1,		-1, -1},
+	{"taskSuicide",		'k',				-1,		-1, -1},
+	{"tauntKillInsult", -1,					-1,		-1, -1},
+	{"tauntPraise",		-1,					-1,		-1, -1},
+	{"tauntTaunt",		-1,					-1,		-1, -1},
+	{"tauntDeathInsult",-1,					-1,		-1, -1},
+	{"tauntGauntlet",	-1,					-1,		-1, -1},
+	{"scoresUp",		A_INSERT,			-1,		-1, -1},
+	{"scoresDown",		A_DELETE,			-1,		-1, -1},
+	{"messagemode",		-1,					-1,		-1, -1},
+	{"messagemode2",	-1,					-1,		-1, -1},
+	{"messagemode3",	-1,					-1,		-1, -1},
+	{"messagemode4",	-1,					-1,		-1, -1},
+	{"+use",			-1,					-1,		-1,	-1},
+	{"+force_jump",		-1,					-1,		-1,	-1},
+	{"force_throw",		A_F1,				-1,		-1,	-1},
+	{"force_pull",		A_F2,				-1,		-1,	-1},
+	{"force_speed",		A_F3,				-1,		-1,	-1},
+	{"force_distract",	A_F4,				-1,		-1,	-1},
+	{"force_heal",		A_F5,				-1,		-1,	-1},
+	{"+force_grip",		A_F6,				-1,		-1,	-1},
+	{"+force_lightning",A_F7,				-1,		-1,	-1},
+//mp only
+	{"+force_drain",	-1,					-1,		-1,	-1},
+	{"force_rage",		-1,					-1,		-1,	-1},
+	{"force_protect",	-1,					-1,		-1,	-1},
+	{"force_absorb",	-1,					-1,		-1,	-1},
+	{"force_healother",	-1,					-1,		-1,	-1},
+	{"force_forcepowerother",	-1,			-1,		-1,	-1},
+	{"force_seeing",	-1,					-1,		-1,	-1},
+
+	{"+useforce",		-1,					-1,		-1,	-1},
+	{"forcenext",		-1,					-1,		-1,	-1},
+	{"forceprev",		-1,					-1,		-1,	-1},
+	{"invnext",			-1,					-1,		-1,	-1},
+	{"invprev",			-1,					-1,		-1,	-1},
+	{"use_seeker",		-1,					-1,		-1,	-1},
+	{"use_field",		-1,					-1,		-1,	-1},
+	{"use_bacta",		-1,					-1,		-1,	-1},
+	{"use_electrobinoculars",	-1,			-1,		-1,	-1},
+	{"use_sentry",		-1,					-1,		-1,	-1},
+	{"cg_thirdperson !",-1,					-1,		-1,	-1},
+	{"automap_button",	-1,					-1,		-1,	-1},
+	{"automap_toggle",	-1,					-1,		-1,	-1},
+	{"voicechat",		-1,					-1,		-1,	-1},
+
+};
+
+
+static const int g_bindCount = sizeof(g_bindings) / sizeof(bind_t);
+
+/*
+=================
+Controls_GetKeyAssignment
+=================
+*/
+static void Controls_GetKeyAssignment (char *command, int *twokeys)
+{
+	int		count;
+	int		j;
+	char	b[256];
+
+	twokeys[0] = twokeys[1] = -1;
+	count = 0;
+
+	for ( j = 0; j < MAX_KEYS; j++ )
+	{
+		DC->getBindingBuf( j, b, 256 );
+		if ( *b == 0 ) {
+			continue;
+		}
+		if ( !Q_stricmp( b, command ) ) {
+			twokeys[count] = j;
+			count++;
+			if (count == 2) {
+				break;
+			}
+		}
+	}
+}
+
+/*
+=================
+Controls_GetConfig
+=================
+*/
+void Controls_GetConfig( void )
+{
+	int		i;
+	int		twokeys[2];
+
+	// iterate each command, get its numeric binding
+	for (i=0; i < g_bindCount; i++)
+	{
+
+		Controls_GetKeyAssignment(g_bindings[i].command, twokeys);
+
+		g_bindings[i].bind1 = twokeys[0];
+		g_bindings[i].bind2 = twokeys[1];
+	}
+
+	//s_controls.invertmouse.curvalue  = DC->getCVarValue( "m_pitch" ) < 0;
+	//s_controls.smoothmouse.curvalue  = UI_ClampCvar( 0, 1, Controls_GetCvarValue( "m_filter" ) );
+	//s_controls.alwaysrun.curvalue    = UI_ClampCvar( 0, 1, Controls_GetCvarValue( "cl_run" ) );
+	//s_controls.autoswitch.curvalue   = UI_ClampCvar( 0, 1, Controls_GetCvarValue( "cg_autoswitch" ) );
+	//s_controls.sensitivity.curvalue  = UI_ClampCvar( 2, 30, Controls_GetCvarValue( "sensitivity" ) );
+	//s_controls.joyenable.curvalue    = UI_ClampCvar( 0, 1, Controls_GetCvarValue( "in_joystick" ) );
+	//s_controls.joythreshold.curvalue = UI_ClampCvar( 0.05, 0.75, Controls_GetCvarValue( "joy_threshold" ) );
+	//s_controls.freelook.curvalue     = UI_ClampCvar( 0, 1, Controls_GetCvarValue( "cl_freelook" ) );
+}
+
+/*
+=================
+Controls_SetConfig
+=================
+*/
+void Controls_SetConfig(qboolean restart)
+{
+	int		i;
+
+	// iterate each command, get its numeric binding
+	for (i=0; i < g_bindCount; i++)
+	{
+		if (g_bindings[i].bind1 != -1)
+		{	
+			DC->setBinding( g_bindings[i].bind1, g_bindings[i].command );
+
+			if (g_bindings[i].bind2 != -1)
+				DC->setBinding( g_bindings[i].bind2, g_bindings[i].command );
+		}
+	}
+
+	//if ( s_controls.invertmouse.curvalue )
+	//	DC->setCVar("m_pitch", va("%f),-fabs( DC->getCVarValue( "m_pitch" ) ) );
+	//else
+	//	trap_Cvar_SetValue( "m_pitch", fabs( trap_Cvar_VariableValue( "m_pitch" ) ) );
+
+	//trap_Cvar_SetValue( "m_filter", s_controls.smoothmouse.curvalue );
+	//trap_Cvar_SetValue( "cl_run", s_controls.alwaysrun.curvalue );
+	//trap_Cvar_SetValue( "cg_autoswitch", s_controls.autoswitch.curvalue );
+	//trap_Cvar_SetValue( "sensitivity", s_controls.sensitivity.curvalue );
+	//trap_Cvar_SetValue( "in_joystick", s_controls.joyenable.curvalue );
+	//trap_Cvar_SetValue( "joy_threshold", s_controls.joythreshold.curvalue );
+	//trap_Cvar_SetValue( "cl_freelook", s_controls.freelook.curvalue );
+//
+//	DC->executeText(EXEC_APPEND, "in_restart\n");
+// ^--this is bad, it shows the cursor during map load, if you need to, add it as an exec cmd to use_joy or something.
+}
+
+
+int BindingIDFromName(const char *name) {
+	int i;
+  for (i=0; i < g_bindCount; i++)
+	{
+		if (Q_stricmp(name, g_bindings[i].command) == 0) {
+			return i;
+		}
+	}
+	return -1;
+}
+
+char g_nameBind1[32];
+char g_nameBind2[32];
+
+void BindingFromName(const char *cvar) {
+	int		i, b1, b2;
+	char	sOR[32];
+
+
+	// iterate each command, set its default binding
+	for (i=0; i < g_bindCount; i++)
+	{
+		if (Q_stricmp(cvar, g_bindings[i].command) == 0) {
+			b1 = g_bindings[i].bind1;
+			if (b1 == -1) {
+				break;
+			}
+				DC->keynumToStringBuf( b1, g_nameBind1, 32 );
+// do NOT do this or it corrupts asian text!!!					Q_strupr(g_nameBind1);
+
+				b2 = g_bindings[i].bind2;
+				if (b2 != -1)
+				{
+					DC->keynumToStringBuf( b2, g_nameBind2, 32 );
+// do NOT do this or it corrupts asian text!!!					Q_strupr(g_nameBind2);
+
+					trap_SP_GetStringTextString("MENUS_KEYBIND_OR",sOR, sizeof(sOR));
+
+					strcat( g_nameBind1, va(" %s ",sOR));
+					strcat( g_nameBind1, g_nameBind2 );
+				}
+			return;
+		}
+	}
+	strcpy(g_nameBind1, "???");
+}
+
+void Item_Slider_Paint(itemDef_t *item) {
+	vec4_t newColor, lowLight;
+	float x, y, value;
+	menuDef_t *parent = (menuDef_t*)item->parent;
+
+	value = (item->cvar) ? DC->getCVarValue(item->cvar) : 0;
+
+	if (item->window.flags & WINDOW_HASFOCUS) {
+		lowLight[0] = 0.8 * parent->focusColor[0]; 
+		lowLight[1] = 0.8 * parent->focusColor[1]; 
+		lowLight[2] = 0.8 * parent->focusColor[2]; 
+		lowLight[3] = 0.8 * parent->focusColor[3]; 
+		LerpColor(parent->focusColor,lowLight,newColor,0.5+0.5*sin((float)(DC->realTime / PULSE_DIVISOR)));
+	} else {
+		memcpy(&newColor, &item->window.foreColor, sizeof(vec4_t));
+	}
+
+	y = item->window.rect.y;
+	if (item->text) {
+		Item_Text_Paint(item);
+		x = item->textRect.x + item->textRect.w + 8;
+	} else {
+		x = item->window.rect.x;
+	}
+	DC->setColor(newColor);
+	DC->drawHandlePic( x, y, SLIDER_WIDTH, SLIDER_HEIGHT, DC->Assets.sliderBar );
+
+	x = Item_Slider_ThumbPosition(item);
+	DC->drawHandlePic( x - (SLIDER_THUMB_WIDTH / 2), y - 2, SLIDER_THUMB_WIDTH, SLIDER_THUMB_HEIGHT, DC->Assets.sliderThumb );
+
+}
+
+void Item_Bind_Paint(itemDef_t *item) 
+{
+	vec4_t newColor, lowLight;
+	float value;
+	int maxChars = 0;
+	float	textScale,textWidth;
+	int		textHeight,yAdj,startingXPos;
+
+
+	menuDef_t *parent = (menuDef_t*)item->parent;
+	editFieldDef_t *editPtr = (editFieldDef_t*)item->typeData;
+	if (editPtr) 
+	{
+		maxChars = editPtr->maxPaintChars;
+	}
+
+	value = (item->cvar) ? DC->getCVarValue(item->cvar) : 0;
+
+	if (item->window.flags & WINDOW_HASFOCUS) 
+	{
+		if (g_bindItem == item) 
+		{
+			lowLight[0] = 0.8f * 1.0f;
+			lowLight[1] = 0.8f * 0.0f;
+			lowLight[2] = 0.8f * 0.0f;
+			lowLight[3] = 0.8f * 1.0f;
+		} 
+		else 
+		{
+			lowLight[0] = 0.8f * parent->focusColor[0]; 
+			lowLight[1] = 0.8f * parent->focusColor[1]; 
+			lowLight[2] = 0.8f * parent->focusColor[2]; 
+			lowLight[3] = 0.8f * parent->focusColor[3]; 
+		}
+		LerpColor(parent->focusColor,lowLight,newColor,0.5+0.5*sin((float)(DC->realTime / PULSE_DIVISOR)));
+	} 
+	else 
+	{
+		memcpy(&newColor, &item->window.foreColor, sizeof(vec4_t));
+	}
+
+	if (item->text) 
+	{
+		Item_Text_Paint(item);
+		BindingFromName(item->cvar);
+
+		// If the text runs past the limit bring the scale down until it fits.
+		textScale = item->textscale;
+		textWidth = DC->textWidth(g_nameBind1,(float) textScale, item->iMenuFont);
+		startingXPos = (item->textRect.x + item->textRect.w + 8);
+
+		while ((startingXPos + textWidth) >= SCREEN_WIDTH)
+		{
+			textScale -= .05f;
+			textWidth = DC->textWidth(g_nameBind1,(float) textScale, item->iMenuFont);
+		}
+
+		// Try to adjust it's y placement if the scale has changed.
+		yAdj = 0;
+		if (textScale != item->textscale)
+		{
+			textHeight = DC->textHeight(g_nameBind1, item->textscale, item->iMenuFont);
+			yAdj = textHeight - DC->textHeight(g_nameBind1, textScale, item->iMenuFont);
+		}
+
+		DC->drawText(startingXPos, item->textRect.y + yAdj, textScale, newColor, g_nameBind1, 0, maxChars, item->textStyle,item->iMenuFont);
+	} 
+	else 
+	{
+		DC->drawText(item->textRect.x, item->textRect.y, item->textscale, newColor, (value != 0) ? "FIXME" : "FIXME", 0, maxChars, item->textStyle,item->iMenuFont);
+	}
+}
+
+qboolean Display_KeyBindPending() {
+	return g_waitingForKey;
+}
+
+qboolean Item_Bind_HandleKey(itemDef_t *item, int key, qboolean down) {
+	int			id;
+	int			i;
+
+	if (key == A_MOUSE1 && Rect_ContainsPoint(&item->window.rect, DC->cursorx, DC->cursory) && !g_waitingForKey)
+	{
+		if (down) {
+			g_waitingForKey = qtrue;
+			g_bindItem = item;
+		}
+		return qtrue;
+	}
+	else if (key == A_ENTER && !g_waitingForKey)
+	{
+		if (down) 
+		{
+			g_waitingForKey = qtrue;
+			g_bindItem = item;
+		}
+		return qtrue;
+	}
+	else
+	{
+		if (!g_waitingForKey || g_bindItem == NULL) {
+			return qfalse;
+		}
+
+		if (key & K_CHAR_FLAG) {
+			return qtrue;
+		}
+
+		switch (key)
+		{
+			case A_ESCAPE:
+				g_waitingForKey = qfalse;
+				return qtrue;
+	
+			case A_BACKSPACE:
+				id = BindingIDFromName(item->cvar);
+				if (id != -1) 
+				{
+					if ( g_bindings[id].bind1 != -1 )
+					{
+						DC->setBinding ( g_bindings[id].bind1, "" );
+					}
+					
+					if ( g_bindings[id].bind2 != -1 )
+					{
+						DC->setBinding ( g_bindings[id].bind2, "" );
+					}
+								
+					g_bindings[id].bind1 = -1;
+					g_bindings[id].bind2 = -1;
+				}
+				Controls_SetConfig(qtrue);
+				g_waitingForKey = qfalse;
+				g_bindItem = NULL;
+				return qtrue;
+
+			case '`':
+				return qtrue;
+		}
+	}
+
+	if (key != -1)
+	{
+
+		for (i=0; i < g_bindCount; i++)
+		{
+
+			if (g_bindings[i].bind2 == key) {
+				g_bindings[i].bind2 = -1;
+			}
+
+			if (g_bindings[i].bind1 == key)
+			{
+				g_bindings[i].bind1 = g_bindings[i].bind2;
+				g_bindings[i].bind2 = -1;
+			}
+		}
+	}
+
+
+	id = BindingIDFromName(item->cvar);
+
+	if (id != -1) {
+		if (key == -1) {
+			if( g_bindings[id].bind1 != -1 ) {
+				DC->setBinding( g_bindings[id].bind1, "" );
+				g_bindings[id].bind1 = -1;
+			}
+			if( g_bindings[id].bind2 != -1 ) {
+				DC->setBinding( g_bindings[id].bind2, "" );
+				g_bindings[id].bind2 = -1;
+			}
+		}
+		else if (g_bindings[id].bind1 == -1) {
+			g_bindings[id].bind1 = key;
+		}
+		else if (g_bindings[id].bind1 != key && g_bindings[id].bind2 == -1) {
+			g_bindings[id].bind2 = key;
+		}
+		else {
+			DC->setBinding( g_bindings[id].bind1, "" );
+			DC->setBinding( g_bindings[id].bind2, "" );
+			g_bindings[id].bind1 = key;
+			g_bindings[id].bind2 = -1;
+		}						
+	}
+
+	Controls_SetConfig(qtrue);	
+	g_waitingForKey = qfalse;
+
+	return qtrue;
+}
+
+void UI_ScaleModelAxis(refEntity_t	*ent)
+
+{		// scale the model should we need to
+		if (ent->modelScale[0] && ent->modelScale[0] != 1.0f)
+		{
+			VectorScale( ent->axis[0], ent->modelScale[0] , ent->axis[0] );
+			ent->nonNormalizedAxes = qtrue;
+		}
+		if (ent->modelScale[1] && ent->modelScale[1] != 1.0f)
+		{
+			VectorScale( ent->axis[1], ent->modelScale[1] , ent->axis[1] );
+			ent->nonNormalizedAxes = qtrue;
+		}
+		if (ent->modelScale[2] && ent->modelScale[2] != 1.0f)
+		{
+			VectorScale( ent->axis[2], ent->modelScale[2] , ent->axis[2] );
+			ent->nonNormalizedAxes = qtrue;
+		}
+}
+
+#ifndef CGAME
+#include "../namespace_end.h"	// Yes, these are inverted. The whole file is in the namespace.
+extern void UI_SaberAttachToChar( itemDef_t *item );
+#include "../namespace_begin.h"
+#endif
+
+void Item_Model_Paint(itemDef_t *item) 
+{
+	float x, y, w, h;
+	refdef_t refdef;
+	refEntity_t		ent;
+	vec3_t			mins, maxs, origin;
+	vec3_t			angles;
+	modelDef_t *modelPtr = (modelDef_t*)item->typeData;
+
+	if (modelPtr == NULL) 
+	{
+		return;
+	}
+
+	// a moves datapad anim is playing
+#ifndef CGAME
+	if (uiInfo.moveAnimTime && (uiInfo.moveAnimTime < uiInfo.uiDC.realTime))
+	{
+		modelDef_t *modelPtr;
+		modelPtr = (modelDef_t*)item->typeData;
+		if (modelPtr)
+		{
+			char modelPath[MAX_QPATH];
+
+			Com_sprintf( modelPath, sizeof( modelPath ), "models/players/%s/model.glm", UI_Cvar_VariableString ( "ui_char_model" ) );
+			//HACKHACKHACK: check for any multi-part anim sequences, and play the next anim, if needbe
+			switch( modelPtr->g2anim )
+			{
+			case BOTH_FORCEWALLREBOUND_FORWARD:
+			case BOTH_FORCEJUMP1: 
+				ItemParse_model_g2anim_go( item, animTable[BOTH_FORCEINAIR1].name );
+				ItemParse_asset_model_go( item, modelPath, &uiInfo.moveAnimTime );
+				if ( !uiInfo.moveAnimTime )
+				{
+					uiInfo.moveAnimTime = 500;
+				}
+				uiInfo.moveAnimTime += uiInfo.uiDC.realTime;
+				break;
+			case BOTH_FORCEINAIR1:
+				ItemParse_model_g2anim_go( item, animTable[BOTH_FORCELAND1].name );
+				ItemParse_asset_model_go( item, modelPath, &uiInfo.moveAnimTime );
+				uiInfo.moveAnimTime += uiInfo.uiDC.realTime;
+				break;
+			case BOTH_FORCEWALLRUNFLIP_START:
+				ItemParse_model_g2anim_go( item, animTable[BOTH_FORCEWALLRUNFLIP_END].name );
+				ItemParse_asset_model_go( item, modelPath, &uiInfo.moveAnimTime );
+				uiInfo.moveAnimTime += uiInfo.uiDC.realTime;
+				break;
+			case BOTH_FORCELONGLEAP_START:
+				ItemParse_model_g2anim_go( item, animTable[BOTH_FORCELONGLEAP_LAND].name );
+				ItemParse_asset_model_go( item, modelPath, &uiInfo.moveAnimTime );
+				uiInfo.moveAnimTime += uiInfo.uiDC.realTime;
+				break;
+			case BOTH_KNOCKDOWN3://on front - into force getup
+				trap_S_StartLocalSound( uiInfo.uiDC.Assets.moveJumpSound, CHAN_LOCAL );
+				ItemParse_model_g2anim_go( item, animTable[BOTH_FORCE_GETUP_F1].name );
+				ItemParse_asset_model_go( item, modelPath, &uiInfo.moveAnimTime );
+				uiInfo.moveAnimTime += uiInfo.uiDC.realTime;
+				break;
+			case BOTH_KNOCKDOWN2://on back - kick forward getup
+				trap_S_StartLocalSound( uiInfo.uiDC.Assets.moveJumpSound, CHAN_LOCAL );
+				ItemParse_model_g2anim_go( item, animTable[BOTH_GETUP_BROLL_F].name );
+				ItemParse_asset_model_go( item, modelPath, &uiInfo.moveAnimTime );
+				uiInfo.moveAnimTime += uiInfo.uiDC.realTime;
+				break;
+			case BOTH_KNOCKDOWN1://on back - roll-away
+				trap_S_StartLocalSound( uiInfo.uiDC.Assets.moveRollSound, CHAN_LOCAL );
+				ItemParse_model_g2anim_go( item, animTable[BOTH_GETUP_BROLL_R].name );
+				ItemParse_asset_model_go( item, modelPath, &uiInfo.moveAnimTime );
+				uiInfo.moveAnimTime += uiInfo.uiDC.realTime;
+				break;
+			default:
+				ItemParse_model_g2anim_go( item,  uiInfo.movesBaseAnim );
+				ItemParse_asset_model_go( item, modelPath, &uiInfo.moveAnimTime );
+				uiInfo.moveAnimTime = 0;
+				break;
+			}
+
+			UI_UpdateCharacterSkin();
+
+			//update saber models
+			UI_SaberAttachToChar( item );
+		}
+	}
+#endif
+
+	// setup the refdef
+	memset( &refdef, 0, sizeof( refdef ) );
+
+	refdef.rdflags = RDF_NOWORLDMODEL;
+	AxisClear( refdef.viewaxis );
+	x = item->window.rect.x+1;
+	y = item->window.rect.y+1;
+	w = item->window.rect.w-2;
+	h = item->window.rect.h-2;
+
+	refdef.x = x * DC->xscale;
+	refdef.y = y * DC->yscale;
+	refdef.width = w * DC->xscale;
+	refdef.height = h * DC->yscale;
+
+	if (item->ghoul2)
+	{ //ghoul2 models don't have bounds, so we have to parse them.
+		VectorCopy(modelPtr->g2mins, mins);
+		VectorCopy(modelPtr->g2maxs, maxs);
+
+		if (!mins[0] && !mins[1] && !mins[2] &&
+			!maxs[0] && !maxs[1] && !maxs[2])
+		{ //we'll use defaults then I suppose.
+			VectorSet(mins, -16, -16, -24);
+			VectorSet(maxs, 16, 16, 32);
+		}
+	}
+	else
+	{
+		DC->modelBounds( item->asset, mins, maxs );
+	}
+
+	origin[2] = -0.5 * ( mins[2] + maxs[2] );
+	origin[1] = 0.5 * ( mins[1] + maxs[1] );
+
+	// calculate distance so the model nearly fills the box
+	if (qtrue) 
+	{
+		float len = 0.5 * ( maxs[2] - mins[2] );		
+		origin[0] = len / 0.268;	// len / tan( fov/2 )
+		//origin[0] = len / tan(w/2);
+	} 
+	else 
+	{
+		origin[0] = item->textscale;
+	}
+	refdef.fov_x = (modelPtr->fov_x) ? modelPtr->fov_x : (int)((float)refdef.width / 640.0f * 90.0f);
+	refdef.fov_y = (modelPtr->fov_y) ? modelPtr->fov_y : atan2( refdef.height, refdef.width / tan( refdef.fov_x / 360 * M_PI ) ) * ( 360 / M_PI );
+	
+	//refdef.fov_x = (int)((float)refdef.width / 640.0f * 90.0f);
+	//refdef.fov_y = atan2( refdef.height, refdef.width / tan( refdef.fov_x / 360 * M_PI ) ) * ( 360 / M_PI );
+
+	DC->clearScene();
+
+	refdef.time = DC->realTime;
+
+	// add the model
+
+	memset( &ent, 0, sizeof(ent) );
+
+	// use item storage to track
+	if (modelPtr->rotationSpeed) 
+	{
+		VectorSet( angles, 0, modelPtr->angle + (float)refdef.time/modelPtr->rotationSpeed, 0 );
+	}
+	else 
+	{
+		VectorSet( angles, 0, modelPtr->angle, 0 );
+	}
+
+	if ( (item->flags&ITF_ISANYSABER) && !(item->flags&ITF_ISCHARACTER) )
+	{//hack to put saber on it's side
+		VectorSet( angles, modelPtr->angle, 0, 90 );
+	}
+
+	AnglesToAxis( angles, ent.axis );
+
+	if (item->ghoul2)
+	{
+		ent.ghoul2 = item->ghoul2;
+		ent.radius = 1000;
+		ent.customSkin = modelPtr->g2skin;
+
+		VectorCopy(modelPtr->g2scale, ent.modelScale);
+		UI_ScaleModelAxis(&ent);
+#ifndef CGAME
+		if ( (item->flags&ITF_ISCHARACTER) )
+		{
+			ent.shaderRGBA[0] = ui_char_color_red.integer;
+			ent.shaderRGBA[1] = ui_char_color_green.integer;
+			ent.shaderRGBA[2] = ui_char_color_blue.integer;
+			ent.shaderRGBA[3] = 255;
+//			UI_TalkingHead(item);
+		}
+		if ( item->flags&ITF_ISANYSABER )
+		{//UGH, draw the saber blade!
+			UI_SaberDrawBlades( item, origin, angles );
+		}
+#endif
+	}
+	else
+	{
+		ent.hModel = item->asset;
+	}
+	VectorCopy( origin, ent.origin );
+	VectorCopy( ent.origin, ent.oldorigin );
+
+	// Set up lighting
+	VectorCopy( origin, ent.lightingOrigin );
+	ent.renderfx = RF_LIGHTING_ORIGIN | RF_NOSHADOW;
+
+	DC->addRefEntityToScene( &ent );
+	DC->renderScene( &refdef );
+
+}
+
+
+void Item_Image_Paint(itemDef_t *item) {
+	if (item == NULL) {
+		return;
+	}
+	DC->drawHandlePic(item->window.rect.x+1, item->window.rect.y+1, item->window.rect.w-2, item->window.rect.h-2, item->asset);
+}
+
+
+void Item_TextScroll_Paint(itemDef_t *item) 
+{
+	char cvartext[1024];
+	float x, y, size, count, thumb;
+	int	  i;
+	textScrollDef_t *scrollPtr = (textScrollDef_t*)item->typeData;
+
+	count = scrollPtr->iLineCount;
+
+	// draw scrollbar to right side of the window
+	x = item->window.rect.x + item->window.rect.w - SCROLLBAR_SIZE - 1;
+	y = item->window.rect.y + 1;
+	DC->drawHandlePic(x, y, SCROLLBAR_SIZE, SCROLLBAR_SIZE, DC->Assets.scrollBarArrowUp);
+	y += SCROLLBAR_SIZE - 1;
+
+	scrollPtr->endPos = scrollPtr->startPos;
+	size = item->window.rect.h - (SCROLLBAR_SIZE * 2);
+	DC->drawHandlePic(x, y, SCROLLBAR_SIZE, size+1, DC->Assets.scrollBar);
+	y += size - 1;
+	DC->drawHandlePic(x, y, SCROLLBAR_SIZE, SCROLLBAR_SIZE, DC->Assets.scrollBarArrowDown);
+	
+	// thumb
+	thumb = Item_TextScroll_ThumbDrawPosition(item);
+	if (thumb > y - SCROLLBAR_SIZE - 1) 
+	{
+		thumb = y - SCROLLBAR_SIZE - 1;
+	}
+	DC->drawHandlePic(x, thumb, SCROLLBAR_SIZE, SCROLLBAR_SIZE, DC->Assets.scrollBarThumb);
+
+	if (item->cvar) 
+	{
+		DC->getCVarString(item->cvar, cvartext, sizeof(cvartext));
+		item->text = cvartext;
+		Item_TextScroll_BuildLines ( item );
+	}
+
+	// adjust size for item painting
+	size = item->window.rect.h - 2;
+	x	 = item->window.rect.x + item->textalignx + 1;
+	y	 = item->window.rect.y + item->textaligny + 1;
+
+	for (i = scrollPtr->startPos; i < count; i++) 
+	{
+		const char *text;
+
+		text = scrollPtr->pLines[i];
+		if (!text) 
+		{
+			continue;
+		}
+
+		DC->drawText(x + 4, y, item->textscale, item->window.foreColor, text, 0, 0, item->textStyle, item->iMenuFont);
+
+		size -= scrollPtr->lineHeight;
+		if (size < scrollPtr->lineHeight) 
+		{
+			scrollPtr->drawPadding = scrollPtr->lineHeight - size;
+			break;
+		}
+
+		scrollPtr->endPos++;
+		y += scrollPtr->lineHeight;
+	}
+}
+
+#define COLOR_MAX 255.0f
+
+// Draw routine for list boxes
+void Item_ListBox_Paint(itemDef_t *item) {
+	float x, y, sizeWidth, count, i, i2,sizeHeight, thumb;
+	int startPos;
+	qhandle_t image;
+	qhandle_t optionalImage1, optionalImage2, optionalImage3;
+	listBoxDef_t *listPtr = (listBoxDef_t*)item->typeData;
+//JLF MPMOVED
+	int numlines;
+
+
+	// the listbox is horizontal or vertical and has a fixed size scroll bar going either direction
+	// elements are enumerated from the DC and either text or image handles are acquired from the DC as well
+	// textscale is used to size the text, textalignx and textaligny are used to size image elements
+	// there is no clipping available so only the last completely visible item is painted
+	count = DC->feederCount(item->special);
+
+//JLFLISTBOX  MPMOVED
+#ifdef _XBOX
+	listPtr->startPos = listPtr->cursorPos;
+	//item->cursorPos = listPtr->startPos;
+#endif
+//JLFLISTBOX MPMOVED
+	if (listPtr->startPos > (count?count-1:count))
+	{//probably changed feeders, so reset
+		listPtr->startPos = 0;
+	}
+//JLF END
+	if (item->cursorPos > (count?count-1:count))
+	{//probably changed feeders, so reset
+		item->cursorPos = (count?count-1:count);
+		// NOTE : might consider moving this to any spot in here we change the cursor position
+		DC->feederSelection( item->special, item->cursorPos, NULL );
+	}
+
+	
+
+	// default is vertical if horizontal flag is not here
+	if (item->window.flags & WINDOW_HORIZONTAL) 
+	{
+#ifdef	_DEBUG
+		const char *text;
+#endif
+
+//JLF new variable (code just indented) MPMOVED
+		if (!listPtr->scrollhidden)
+		{
+		// draw scrollbar in bottom of the window
+		// bar
+			if (Item_ListBox_MaxScroll(item) > 0) 
+			{
+				x = item->window.rect.x + 1;
+				y = item->window.rect.y + item->window.rect.h - SCROLLBAR_SIZE - 1;
+				DC->drawHandlePic(x, y, SCROLLBAR_SIZE, SCROLLBAR_SIZE, DC->Assets.scrollBarArrowLeft);
+				x += SCROLLBAR_SIZE - 1;
+				sizeWidth = item->window.rect.w - (SCROLLBAR_SIZE * 2);
+				DC->drawHandlePic(x, y, sizeWidth+1, SCROLLBAR_SIZE, DC->Assets.scrollBar);
+				x += sizeWidth - 1;
+				DC->drawHandlePic(x, y, SCROLLBAR_SIZE, SCROLLBAR_SIZE, DC->Assets.scrollBarArrowRight);
+				// thumb
+				thumb = Item_ListBox_ThumbDrawPosition(item);//Item_ListBox_ThumbPosition(item);
+				if (thumb > x - SCROLLBAR_SIZE - 1) {
+					thumb = x - SCROLLBAR_SIZE - 1;
+				}
+				DC->drawHandlePic(thumb, y, SCROLLBAR_SIZE, SCROLLBAR_SIZE, DC->Assets.scrollBarThumb);
+			}
+			else if (listPtr->startPos > 0)
+			{
+				listPtr->startPos = 0;
+			}
+		}
+//JLF end
+		//
+		listPtr->endPos = listPtr->startPos;
+		sizeWidth = item->window.rect.w - 2;
+		// items
+		// size contains max available space
+		if (listPtr->elementStyle == LISTBOX_IMAGE) 
+		{
+			// fit = 0;
+			x = item->window.rect.x + 1;
+			y = item->window.rect.y + 1;
+			for (i = listPtr->startPos; i < count; i++) 
+			{
+				// always draw at least one
+				// which may overdraw the box if it is too small for the element
+				image = DC->feederItemImage(item->special, i);
+				if (image) 
+				{
+#ifndef CGAME
+					if (item->window.flags & WINDOW_PLAYERCOLOR) 
+					{
+						vec4_t	color;
+
+						color[0] = ui_char_color_red.integer/COLOR_MAX;
+						color[1] = ui_char_color_green.integer/COLOR_MAX;
+						color[2] = ui_char_color_blue.integer/COLOR_MAX;
+						color[3] = 1.0f;
+						DC->setColor(color);
+					}
+#endif
+					DC->drawHandlePic(x+1, y+1, listPtr->elementWidth - 2, listPtr->elementHeight - 2, image);
+				}
+
+				if (i == item->cursorPos) 
+				{
+					DC->drawRect(x, y, listPtr->elementWidth-1, listPtr->elementHeight-1, item->window.borderSize, item->window.borderColor);
+				}
+
+				sizeWidth -= listPtr->elementWidth;
+				if (sizeWidth < listPtr->elementWidth) 
+				{
+					listPtr->drawPadding = sizeWidth; //listPtr->elementWidth - size;
+					break;
+				}
+				x += listPtr->elementWidth;
+				listPtr->endPos++;
+				// fit++;
+			}
+		} 
+		else 
+		{
+			//
+		}
+
+#ifdef	_DEBUG
+		// Show pic name
+		text = DC->feederItemText(item->special, item->cursorPos, 0, &optionalImage1, &optionalImage2, &optionalImage3);
+		if (text) 
+		{
+			DC->drawText(item->window.rect.x, item->window.rect.y+item->window.rect.h, item->textscale, item->window.foreColor, text, 0, 0, item->textStyle, item->iMenuFont);
+		}
+#endif
+
+	} 
+	// A vertical list box
+	else 
+	{
+//JLF MPMOVED
+		numlines = item->window.rect.h / listPtr->elementHeight;
+//JLFEND
+		//JLF new variable (code idented with if)
+		if (!listPtr->scrollhidden)
+		{
+
+			// draw scrollbar to right side of the window
+			x = item->window.rect.x + item->window.rect.w - SCROLLBAR_SIZE - 1;
+			y = item->window.rect.y + 1;
+			DC->drawHandlePic(x, y, SCROLLBAR_SIZE, SCROLLBAR_SIZE, DC->Assets.scrollBarArrowUp);
+			y += SCROLLBAR_SIZE - 1;
+
+			listPtr->endPos = listPtr->startPos;
+			sizeHeight = item->window.rect.h - (SCROLLBAR_SIZE * 2);
+			DC->drawHandlePic(x, y, SCROLLBAR_SIZE, sizeHeight+1, DC->Assets.scrollBar);
+			y += sizeHeight - 1;
+			DC->drawHandlePic(x, y, SCROLLBAR_SIZE, SCROLLBAR_SIZE, DC->Assets.scrollBarArrowDown);
+			// thumb
+			thumb = Item_ListBox_ThumbDrawPosition(item);//Item_ListBox_ThumbPosition(item);
+			if (thumb > y - SCROLLBAR_SIZE - 1) {
+				thumb = y - SCROLLBAR_SIZE - 1;
+			}
+			DC->drawHandlePic(x, thumb, SCROLLBAR_SIZE, SCROLLBAR_SIZE, DC->Assets.scrollBarThumb);
+		}
+//JLF end
+
+		// adjust size for item painting
+		sizeWidth = item->window.rect.w - 2;
+		sizeHeight = item->window.rect.h - 2;
+
+		if (listPtr->elementStyle == LISTBOX_IMAGE) 
+		{
+			// Multiple rows and columns (since it's more than twice as wide as an element)
+			if ( item->window.rect.w > (listPtr->elementWidth*2) )
+			{
+				startPos = listPtr->startPos;
+				x = item->window.rect.x + 1;
+				y = item->window.rect.y + 1;
+				// Next row
+				for (i2 = startPos; i2 < count; i2++) 
+				{
+					x = item->window.rect.x + 1;
+					sizeWidth = item->window.rect.w - 2;
+					// print a row
+					for (i = startPos; i < count; i++) 
+					{
+						// always draw at least one
+						// which may overdraw the box if it is too small for the element
+						image = DC->feederItemImage(item->special, i);
+						if (image) 
+						{
+		#ifndef CGAME
+							if (item->window.flags & WINDOW_PLAYERCOLOR) 
+							{
+								vec4_t	color;
+
+								color[0] = ui_char_color_red.integer/COLOR_MAX;
+								color[1] = ui_char_color_green.integer/COLOR_MAX;
+								color[2] = ui_char_color_blue.integer/COLOR_MAX;
+								color[3] = 1.0f;
+								DC->setColor(color);
+							}
+		#endif
+							DC->drawHandlePic(x+1, y+1, listPtr->elementWidth - 2, listPtr->elementHeight - 2, image);
+						}
+
+						if (i == item->cursorPos) 
+						{
+							DC->drawRect(x, y, listPtr->elementWidth-1, listPtr->elementHeight-1, item->window.borderSize, item->window.borderColor);
+						}
+
+						sizeWidth -= listPtr->elementWidth;
+						if (sizeWidth < listPtr->elementWidth) 
+						{
+							listPtr->drawPadding = sizeWidth; //listPtr->elementWidth - size;
+							break;
+						}
+						x += listPtr->elementWidth;
+						listPtr->endPos++;
+					}
+
+					sizeHeight -= listPtr->elementHeight;
+					if (sizeHeight < listPtr->elementHeight) 
+					{
+						listPtr->drawPadding = sizeHeight; //listPtr->elementWidth - size;
+						break;
+					}
+					// NOTE : Is endPos supposed to be valid or not? It was being used as a valid entry but I changed those
+					// few spots that were causing bugs
+					listPtr->endPos++;
+					startPos = listPtr->endPos;
+					y += listPtr->elementHeight;
+
+				}
+			}
+			// single column
+			else
+			{
+				x = item->window.rect.x + 1;
+				y = item->window.rect.y + 1;
+				for (i = listPtr->startPos; i < count; i++) 
+				{
+					// always draw at least one
+					// which may overdraw the box if it is too small for the element
+					image = DC->feederItemImage(item->special, i);
+					if (image) 
+					{
+						DC->drawHandlePic(x+1, y+1, listPtr->elementWidth - 2, listPtr->elementHeight - 2, image);
+					}
+
+					if (i == item->cursorPos) 
+					{
+						DC->drawRect(x, y, listPtr->elementWidth - 1, listPtr->elementHeight - 1, item->window.borderSize, item->window.borderColor);
+					}
+
+					listPtr->endPos++;
+					sizeHeight -= listPtr->elementHeight;
+					if (sizeHeight < listPtr->elementHeight) 
+					{
+						listPtr->drawPadding = listPtr->elementHeight - sizeHeight;
+						break;
+					}
+					y += listPtr->elementHeight;
+					// fit++;
+				}
+			}
+		} 
+		else 
+		{
+			x = item->window.rect.x + 1;
+			y = item->window.rect.y + 1;
+//JLF MPMOVED
+			y = item->window.rect.y + 1 - listPtr->elementHeight;
+#ifdef _XBOX
+			i = listPtr->startPos - (numlines/2);
+#else
+			i = listPtr->startPos;
+#endif
+
+			for (; i < count; i++) 
+//JLF END
+			{
+				const char *text;
+				// always draw at least one
+				// which may overdraw the box if it is too small for the element
+				if (listPtr->numColumns > 0) {
+					int j;//, subX = listPtr->elementHeight;
+
+					for (j = 0; j < listPtr->numColumns; j++) 
+					{
+						char	temp[MAX_STRING_CHARS];
+						int imageStartX = listPtr->columnInfo[j].pos;
+						text = DC->feederItemText(item->special, i, j, &optionalImage1, &optionalImage2, &optionalImage3);
+
+						if( !text )
+						{
+							continue;
+						}
+
+						if (text[0]=='@')
+						{
+							trap_SP_GetStringTextString( &text[1]  , temp, sizeof(temp));
+							text = temp;
+						}
+
+						/*
+						if (optionalImage >= 0) {
+							DC->drawHandlePic(x + 4 + listPtr->columnInfo[j].pos, y - 1 + listPtr->elementHeight / 2, listPtr->columnInfo[j].width, listPtr->columnInfo[j].width, optionalImage);
+						} 
+						else 
+						*/
+						if ( text )
+						{
+//JLF MPMOVED
+#ifdef _XBOX
+							float fScaleA = item->textscale;
+#endif
+							int textyOffset;
+#ifdef _XBOX
+							textyOffset = DC->textHeight (text, fScaleA, item->iMenuFont);
+							textyOffset *= -1;
+							textyOffset /=2;
+							textyOffset += listPtr->elementHeight/2;
+#else
+							textyOffset = 0;
+#endif
+//							DC->drawText(x + 4 + listPtr->columnInfo[j].pos, y + listPtr->elementHeight, item->textscale, item->window.foreColor, text, 0, listPtr->columnInfo[j].maxChars, item->textStyle);
+	//WAS LAST						DC->drawText(x + 4 + listPtr->columnInfo[j].pos, y, item->textscale, item->window.foreColor, text, 0, listPtr->columnInfo[j].maxChars, item->textStyle, item->iMenuFont);
+							DC->drawText(x + 4 + listPtr->columnInfo[j].pos, y + listPtr->elementHeight+ textyOffset + item->textaligny, item->textscale, item->window.foreColor, text, 0,listPtr->columnInfo[j].maxChars, item->textStyle, item->iMenuFont);
+
+
+//JLF END
+						}
+						if ( j < listPtr->numColumns - 1 )
+						{
+							imageStartX = listPtr->columnInfo[j+1].pos;
+						}
+						DC->setColor( NULL );
+						if (optionalImage3 >= 0) 
+						{
+							DC->drawHandlePic(imageStartX - listPtr->elementHeight*3, y+listPtr->elementHeight+2, listPtr->elementHeight, listPtr->elementHeight, optionalImage3);
+						} 
+						if (optionalImage2 >= 0) 
+						{
+							DC->drawHandlePic(imageStartX - listPtr->elementHeight*2, y+listPtr->elementHeight+2, listPtr->elementHeight, listPtr->elementHeight, optionalImage2);
+						} 
+						if (optionalImage1 >= 0) 
+						{
+							DC->drawHandlePic(imageStartX - listPtr->elementHeight, y+listPtr->elementHeight+2, listPtr->elementHeight, listPtr->elementHeight, optionalImage1);
+						} 
+					}
+				} 
+				else 
+				{
+#ifdef _XBOX
+					if (i >= 0)
+					{
+#endif
+					text = DC->feederItemText(item->special, i, 0, &optionalImage1, &optionalImage2, &optionalImage3 );
+					if ( optionalImage1 >= 0 || optionalImage2 >= 0 || optionalImage3 >= 0) 
+					{
+						//DC->drawHandlePic(x + 4 + listPtr->elementHeight, y, listPtr->columnInfo[j].width, listPtr->columnInfo[j].width, optionalImage);
+					} 
+					else if (text) 
+					{
+//						DC->drawText(x + 4, y + listPtr->elementHeight, item->textscale, item->window.foreColor, text, 0, 0, item->textStyle);
+						DC->drawText(x + 4, y + item->textaligny, item->textscale, item->window.foreColor, text, 0, 0, item->textStyle, item->iMenuFont);
+					}
+#ifdef _XBOX
+					}
+#endif
+				}
+
+				if (i == item->cursorPos) 
+				{
+					DC->fillRect(x + 2, y + listPtr->elementHeight + 2, item->window.rect.w - SCROLLBAR_SIZE - 4, listPtr->elementHeight, item->window.outlineColor);
+				}
+
+				sizeHeight -= listPtr->elementHeight;
+				if (sizeHeight < listPtr->elementHeight) 
+				{
+					listPtr->drawPadding = listPtr->elementHeight - sizeHeight;
+					break;
+				}
+				listPtr->endPos++;
+				y += listPtr->elementHeight;
+				// fit++;
+			}
+		}
+	}
+}
+
+
+void Item_OwnerDraw_Paint(itemDef_t *item) {
+  menuDef_t *parent;
+
+	if (item == NULL) {
+		return;
+	}
+  parent = (menuDef_t*)item->parent;
+
+	if (DC->ownerDrawItem) {
+		vec4_t color, lowLight;
+		menuDef_t *parent = (menuDef_t*)item->parent;
+		Fade(&item->window.flags, &item->window.foreColor[3], parent->fadeClamp, &item->window.nextTime, parent->fadeCycle, qtrue, parent->fadeAmount);
+		memcpy(&color, &item->window.foreColor, sizeof(color));
+		if (item->numColors > 0 && DC->getValue) {
+			// if the value is within one of the ranges then set color to that, otherwise leave at default
+			int i;
+			float f = DC->getValue(item->window.ownerDraw);
+			for (i = 0; i < item->numColors; i++) {
+				if (f >= item->colorRanges[i].low && f <= item->colorRanges[i].high) {
+					memcpy(&color, &item->colorRanges[i].color, sizeof(color));
+					break;
+				}
+			}
+		}
+
+		if (item->window.flags & WINDOW_HASFOCUS) {
+			lowLight[0] = 0.8 * parent->focusColor[0]; 
+			lowLight[1] = 0.8 * parent->focusColor[1]; 
+			lowLight[2] = 0.8 * parent->focusColor[2]; 
+			lowLight[3] = 0.8 * parent->focusColor[3]; 
+			LerpColor(parent->focusColor,lowLight,color,0.5+0.5*sin((float)(DC->realTime / PULSE_DIVISOR)));
+		} else if (item->textStyle == ITEM_TEXTSTYLE_BLINK && !((DC->realTime/BLINK_DIVISOR) & 1)) {
+			lowLight[0] = 0.8 * item->window.foreColor[0]; 
+			lowLight[1] = 0.8 * item->window.foreColor[1]; 
+			lowLight[2] = 0.8 * item->window.foreColor[2]; 
+			lowLight[3] = 0.8 * item->window.foreColor[3]; 
+			LerpColor(item->window.foreColor,lowLight,color,0.5+0.5*sin((float)(DC->realTime / PULSE_DIVISOR)));
+		}
+
+		if (item->disabled) 
+		{
+			memcpy(color, parent->disableColor, sizeof(vec4_t)); // bk001207 - FIXME: Com_Memcpy
+		}
+
+		if (item->cvarFlags & (CVAR_ENABLE | CVAR_DISABLE) && !Item_EnableShowViaCvar(item, CVAR_ENABLE)) {
+		  memcpy(color, parent->disableColor, sizeof(vec4_t)); // bk001207 - FIXME: Com_Memcpy
+		}
+	
+		if (item->text) {
+			Item_Text_Paint(item);
+				if (item->text[0]) {
+					// +8 is an offset kludge to properly align owner draw items that have text combined with them
+					DC->ownerDrawItem(item->textRect.x + item->textRect.w + 8, item->window.rect.y, item->window.rect.w, item->window.rect.h, 0, item->textaligny, item->window.ownerDraw, item->window.ownerDrawFlags, item->alignment, item->special, item->textscale, color, item->window.background, item->textStyle,item->iMenuFont);
+				} else {
+					DC->ownerDrawItem(item->textRect.x + item->textRect.w, item->window.rect.y, item->window.rect.w, item->window.rect.h, 0, item->textaligny, item->window.ownerDraw, item->window.ownerDrawFlags, item->alignment, item->special, item->textscale, color, item->window.background, item->textStyle,item->iMenuFont);
+				}
+			} else {
+			DC->ownerDrawItem(item->window.rect.x, item->window.rect.y, item->window.rect.w, item->window.rect.h, item->textalignx, item->textaligny, item->window.ownerDraw, item->window.ownerDrawFlags, item->alignment, item->special, item->textscale, color, item->window.background, item->textStyle,item->iMenuFont);
+		}
+	}
+}
+
+
+void Item_Paint(itemDef_t *item) 
+{
+	vec4_t		red;
+	menuDef_t *parent = (menuDef_t*)item->parent;
+	int			xPos,textWidth;
+	vec4_t		color = {1, 1, 1, 1};
+
+	red[0] = red[3] = 1;
+	red[1] = red[2] = 0;
+
+	if (item == NULL) 
+	{
+		return;
+	}
+
+	if (item->window.flags & WINDOW_ORBITING) 
+	{
+		if (DC->realTime > item->window.nextTime) 
+		{
+			float rx, ry, a, c, s, w, h;
+      
+			item->window.nextTime = DC->realTime + item->window.offsetTime;
+			// translate
+			w = item->window.rectClient.w / 2;
+			h = item->window.rectClient.h / 2;
+			rx = item->window.rectClient.x + w - item->window.rectEffects.x;
+			ry = item->window.rectClient.y + h - item->window.rectEffects.y;
+			a = 3 * M_PI / 180;
+			c = cos(a);
+			s = sin(a);
+			item->window.rectClient.x = (rx * c - ry * s) + item->window.rectEffects.x - w;
+			item->window.rectClient.y = (rx * s + ry * c) + item->window.rectEffects.y - h;
+			Item_UpdatePosition(item);
+		}
+	}
+
+
+	if (item->window.flags & WINDOW_INTRANSITION) 
+	{
+		if (DC->realTime > item->window.nextTime) 
+		{
+			int done = 0;
+			item->window.nextTime = DC->realTime + item->window.offsetTime;
+
+			// transition the x,y
+			if (item->window.rectClient.x == item->window.rectEffects.x) 
+			{
+				done++;
+			} 
+			else 
+			{
+				if (item->window.rectClient.x < item->window.rectEffects.x) 
+				{
+					item->window.rectClient.x += item->window.rectEffects2.x;
+					if (item->window.rectClient.x > item->window.rectEffects.x) 
+					{
+						item->window.rectClient.x = item->window.rectEffects.x;
+						done++;
+					}
+				} 
+				else 
+				{
+					item->window.rectClient.x -= item->window.rectEffects2.x;
+					if (item->window.rectClient.x < item->window.rectEffects.x) 
+					{
+						item->window.rectClient.x = item->window.rectEffects.x;
+						done++;
+					}
+				}
+			}
+
+			if (item->window.rectClient.y == item->window.rectEffects.y) 
+			{
+				done++;
+			} 
+			else 
+			{
+				if (item->window.rectClient.y < item->window.rectEffects.y) 
+				{
+					item->window.rectClient.y += item->window.rectEffects2.y;
+					if (item->window.rectClient.y > item->window.rectEffects.y) 
+					{
+						item->window.rectClient.y = item->window.rectEffects.y;
+						done++;
+					}
+				} 
+				else 
+				{
+					item->window.rectClient.y -= item->window.rectEffects2.y;
+					if (item->window.rectClient.y < item->window.rectEffects.y) 
+					{
+						item->window.rectClient.y = item->window.rectEffects.y;
+						done++;
+					}
+				}
+			}
+
+			if (item->window.rectClient.w == item->window.rectEffects.w) 
+			{
+				done++;
+			} 
+			else 
+			{
+				if (item->window.rectClient.w < item->window.rectEffects.w) 
+				{
+					item->window.rectClient.w += item->window.rectEffects2.w;
+					if (item->window.rectClient.w > item->window.rectEffects.w) 
+					{
+						item->window.rectClient.w = item->window.rectEffects.w;
+						done++;
+					}
+				} 
+				else 
+				{
+					item->window.rectClient.w -= item->window.rectEffects2.w;
+					if (item->window.rectClient.w < item->window.rectEffects.w) 
+					{
+						item->window.rectClient.w = item->window.rectEffects.w;
+						done++;
+					}
+				}
+			}
+
+			if (item->window.rectClient.h == item->window.rectEffects.h) 
+			{
+				done++;
+			} 
+			else 
+			{
+				if (item->window.rectClient.h < item->window.rectEffects.h) 
+				{
+					item->window.rectClient.h += item->window.rectEffects2.h;
+					if (item->window.rectClient.h > item->window.rectEffects.h) 
+					{
+						item->window.rectClient.h = item->window.rectEffects.h;
+						done++;
+					}
+				} 
+				else 
+				{
+					item->window.rectClient.h -= item->window.rectEffects2.h;
+					if (item->window.rectClient.h < item->window.rectEffects.h) 
+					{
+						item->window.rectClient.h = item->window.rectEffects.h;
+						done++;
+					}
+				}
+			}
+
+			Item_UpdatePosition(item);
+
+			if (done == 4) 
+			{
+				item->window.flags &= ~WINDOW_INTRANSITION;
+			}
+
+		}
+	}
+
+#ifdef _TRANS3
+	
+//JLF begin model transition stuff
+	if (item->window.flags & WINDOW_INTRANSITIONMODEL) 
+	{
+		if ( item->type == ITEM_TYPE_MODEL)
+		{
+//fields ing modelptr
+//				vec3_t g2mins2, g2maxs2, g2minsEffect, g2maxsEffect;
+//	float fov_x2, fov_y2, fov_Effectx, fov_Effecty;
+
+			modelDef_t  * modelptr = (modelDef_t *)item->typeData;
+
+			if (DC->realTime > item->window.nextTime) 
+			{
+				int done = 0;
+				item->window.nextTime = DC->realTime + item->window.offsetTime;
+
+
+// transition the x,y,z max
+				if (modelptr->g2maxs[0] == modelptr->g2maxs2[0]) 
+				{
+					done++;
+				} 
+				else 
+				{
+					if (modelptr->g2maxs[0] < modelptr->g2maxs2[0]) 
+					{
+						modelptr->g2maxs[0] += modelptr->g2maxsEffect[0];
+						if (modelptr->g2maxs[0] > modelptr->g2maxs2[0]) 
+						{
+							modelptr->g2maxs[0] = modelptr->g2maxs2[0];
+							done++;
+						}
+					} 
+					else 
+					{
+						modelptr->g2maxs[0] -= modelptr->g2maxsEffect[0];
+						if (modelptr->g2maxs[0] < modelptr->g2maxs2[0]) 
+						{
+							modelptr->g2maxs[0] = modelptr->g2maxs2[0];
+							done++;
+						}
+					}
+				}
+//y
+				if (modelptr->g2maxs[1] == modelptr->g2maxs2[1]) 
+				{
+					done++;
+				} 
+				else 
+				{
+					if (modelptr->g2maxs[1] < modelptr->g2maxs2[1]) 
+					{
+						modelptr->g2maxs[1] += modelptr->g2maxsEffect[1];
+						if (modelptr->g2maxs[1] > modelptr->g2maxs2[1]) 
+						{
+							modelptr->g2maxs[1] = modelptr->g2maxs2[1];
+							done++;
+						}
+					} 
+					else 
+					{
+						modelptr->g2maxs[1] -= modelptr->g2maxsEffect[1];
+						if (modelptr->g2maxs[1] < modelptr->g2maxs2[1]) 
+						{
+							modelptr->g2maxs[1] = modelptr->g2maxs2[1];
+							done++;
+						}
+					}
+				}
+
+
+//z
+
+				if (modelptr->g2maxs[2] == modelptr->g2maxs2[2]) 
+				{
+					done++;
+				} 
+				else 
+				{
+					if (modelptr->g2maxs[2] < modelptr->g2maxs2[2]) 
+					{
+						modelptr->g2maxs[2] += modelptr->g2maxsEffect[2];
+						if (modelptr->g2maxs[2] > modelptr->g2maxs2[2]) 
+						{
+							modelptr->g2maxs[2] = modelptr->g2maxs2[2];
+							done++;
+						}
+					} 
+					else 
+					{
+						modelptr->g2maxs[2] -= modelptr->g2maxsEffect[2];
+						if (modelptr->g2maxs[2] < modelptr->g2maxs2[2]) 
+						{
+							modelptr->g2maxs[2] = modelptr->g2maxs2[2];
+							done++;
+						}
+					}
+				}
+
+// transition the x,y,z min
+				if (modelptr->g2mins[0] == modelptr->g2mins2[0]) 
+				{
+					done++;
+				} 
+				else 
+				{
+					if (modelptr->g2mins[0] < modelptr->g2mins2[0]) 
+					{
+						modelptr->g2mins[0] += modelptr->g2minsEffect[0];
+						if (modelptr->g2mins[0] > modelptr->g2mins2[0]) 
+						{
+							modelptr->g2mins[0] = modelptr->g2mins2[0];
+							done++;
+						}
+					} 
+					else 
+					{
+						modelptr->g2mins[0] -= modelptr->g2minsEffect[0];
+						if (modelptr->g2mins[0] < modelptr->g2mins2[0]) 
+						{
+							modelptr->g2mins[0] = modelptr->g2mins2[0];
+							done++;
+						}
+					}
+				}
+//y
+				if (modelptr->g2mins[1] == modelptr->g2mins2[1]) 
+				{
+					done++;
+				} 
+				else 
+				{
+					if (modelptr->g2mins[1] < modelptr->g2mins2[1]) 
+					{
+						modelptr->g2mins[1] += modelptr->g2minsEffect[1];
+						if (modelptr->g2mins[1] > modelptr->g2mins2[1]) 
+						{
+							modelptr->g2mins[1] = modelptr->g2mins2[1];
+							done++;
+						}
+					} 
+					else 
+					{
+						modelptr->g2mins[1] -= modelptr->g2minsEffect[1];
+						if (modelptr->g2mins[1] < modelptr->g2mins2[1]) 
+						{
+							modelptr->g2mins[1] = modelptr->g2mins2[1];
+							done++;
+						}
+					}
+				}
+
+
+//z
+
+				if (modelptr->g2mins[2] == modelptr->g2mins2[2]) 
+				{
+					done++;
+				} 
+				else 
+				{
+					if (modelptr->g2mins[2] < modelptr->g2mins2[2]) 
+					{
+						modelptr->g2mins[2] += modelptr->g2minsEffect[2];
+						if (modelptr->g2mins[2] > modelptr->g2mins2[2]) 
+						{
+							modelptr->g2mins[2] = modelptr->g2mins2[2];
+							done++;
+						}
+					} 
+					else 
+					{
+						modelptr->g2mins[2] -= modelptr->g2minsEffect[2];
+						if (modelptr->g2mins[2] < modelptr->g2mins2[2]) 
+						{
+							modelptr->g2mins[2] = modelptr->g2mins2[2];
+							done++;
+						}
+					}
+				}
+
+
+
+//fovx
+				if (modelptr->fov_x == modelptr->fov_x2) 
+				{
+					done++;
+				} 
+				else 
+				{
+					if (modelptr->fov_x < modelptr->fov_x2) 
+					{
+						modelptr->fov_x += modelptr->fov_Effectx;
+						if (modelptr->fov_x > modelptr->fov_x2) 
+						{
+							modelptr->fov_x = modelptr->fov_x2;
+							done++;
+						}
+					} 
+					else 
+					{
+						modelptr->fov_x -= modelptr->fov_Effectx;
+						if (modelptr->fov_x < modelptr->fov_x2) 
+						{
+							modelptr->fov_x = modelptr->fov_x2;
+							done++;
+						}
+					}
+				}
+
+//fovy
+				if (modelptr->fov_y == modelptr->fov_y2) 
+				{
+					done++;
+				} 
+				else 
+				{
+					if (modelptr->fov_y < modelptr->fov_y2) 
+					{
+						modelptr->fov_y += modelptr->fov_Effecty;
+						if (modelptr->fov_y > modelptr->fov_y2) 
+						{
+							modelptr->fov_y = modelptr->fov_y2;
+							done++;
+						}
+					} 
+					else 
+					{
+						modelptr->fov_y -= modelptr->fov_Effecty;
+						if (modelptr->fov_y < modelptr->fov_y2) 
+						{
+							modelptr->fov_y = modelptr->fov_y2;
+							done++;
+						}
+					}
+				}
+
+				if (done == 5) 
+				{
+					item->window.flags &= ~WINDOW_INTRANSITIONMODEL;
+				}
+
+			}
+		}
+	}
+#endif
+//JLF end transition stuff for models
+
+
+
+	if (item->window.ownerDrawFlags && DC->ownerDrawVisible) {
+		if (!DC->ownerDrawVisible(item->window.ownerDrawFlags)) {
+			item->window.flags &= ~WINDOW_VISIBLE;
+		} else {
+			item->window.flags |= WINDOW_VISIBLE;
+		}
+	}
+
+	if (item->cvarFlags & (CVAR_SHOW | CVAR_HIDE)) {
+		if (!Item_EnableShowViaCvar(item, CVAR_SHOW)) {
+			return;
+		}
+	}
+
+  if (item->window.flags & WINDOW_TIMEDVISIBLE) {
+
+	}
+
+	if (!(item->window.flags & WINDOW_VISIBLE)) 
+	{
+		return;
+	}
+
+
+//JLFMOUSE
+#ifndef _XBOX
+	if (item->window.flags & WINDOW_MOUSEOVER)
+#else
+	if (item->window.flags & WINDOW_HASFOCUS)
+#endif
+	{
+		if (item->descText && !Display_KeyBindPending())
+		{
+			// Make DOUBLY sure that this item should have desctext.
+#ifndef _XBOX
+			// NOTE : we can't just check the mouse position on this, what if we TABBED
+			// to the current menu item -- in that case our mouse isn't over the item.
+			// Removing the WINDOW_MOUSEOVER flag just prevents the item's OnExit script from running
+	//	    if (!Rect_ContainsPoint(&item->window.rect, DC->cursorx, DC->cursory)) 
+	//		{	// It isn't something that should, because it isn't live anymore.
+	//			item->window.flags &= ~WINDOW_MOUSEOVER;
+	//		}
+	//		else
+#endif
+	//END JLFMOUSE
+			{	// Draw the desctext
+				const char *textPtr = item->descText;
+				if (*textPtr == '@')	// string reference
+				{
+					char	temp[MAX_STRING_CHARS];
+					trap_SP_GetStringTextString( &textPtr[1]  , temp, sizeof(temp));
+					textPtr = temp;
+				}
+
+				Item_TextColor(item, &color);
+
+				{// stupid C language
+					float fDescScale = parent->descScale ? parent->descScale : 1;
+					float fDescScaleCopy = fDescScale;
+					int iYadj = 0;
+					while (1)
+					{
+						textWidth = DC->textWidth(textPtr,fDescScale, FONT_SMALL2);
+
+						if (parent->descAlignment == ITEM_ALIGN_RIGHT)
+						{
+							xPos = parent->descX - textWidth;	// Right justify
+						}
+						else if (parent->descAlignment == ITEM_ALIGN_CENTER)
+						{
+							xPos = parent->descX - (textWidth/2);	// Center justify
+						}
+						else										// Left justify	
+						{
+							xPos = parent->descX;
+						}
+
+						if (parent->descAlignment == ITEM_ALIGN_CENTER)
+						{
+							// only this one will auto-shrink the scale until we eventually fit...
+							//
+							if (xPos + textWidth > (SCREEN_WIDTH-4)) {
+								fDescScale -= 0.001f;
+								continue;
+							}
+						}
+
+						// Try to adjust it's y placement if the scale has changed...
+						//
+						if (fDescScale != fDescScaleCopy)
+						{
+							int iOriginalTextHeight = DC->textHeight(textPtr, fDescScaleCopy, FONT_MEDIUM);
+							iYadj = iOriginalTextHeight - DC->textHeight(textPtr, fDescScale, FONT_MEDIUM);
+						}
+
+						DC->drawText(xPos, parent->descY + iYadj, fDescScale, parent->descColor, textPtr, 0, 0, item->textStyle, FONT_SMALL2);
+						break;
+					}
+				}
+			}
+		}
+	}
+
+  // paint the rect first.. 
+  Window_Paint(&item->window, parent->fadeAmount , parent->fadeClamp, parent->fadeCycle);
+
+  // Draw box to show rectangle extents, in debug mode
+  if (debugMode) 
+  {
+	vec4_t color;
+    color[1] = color[3] = 1;
+    color[0] = color[2] = 0;
+	DC->drawRect(
+		item->window.rect.x, 
+		item->window.rect.y, 
+		item->window.rect.w, 
+		item->window.rect.h, 
+		1, 
+		color);
+  }
+
+  //DC->drawRect(item->window.rect.x, item->window.rect.y, item->window.rect.w, item->window.rect.h, 1, red);
+
+  switch (item->type) {
+    case ITEM_TYPE_OWNERDRAW:
+      Item_OwnerDraw_Paint(item);
+      break;
+    case ITEM_TYPE_TEXT:
+    case ITEM_TYPE_BUTTON:
+      Item_Text_Paint(item);
+      break;
+    case ITEM_TYPE_RADIOBUTTON:
+      break;
+    case ITEM_TYPE_CHECKBOX:
+      break;
+    case ITEM_TYPE_EDITFIELD:
+    case ITEM_TYPE_NUMERICFIELD:
+      Item_TextField_Paint(item);
+      break;
+    case ITEM_TYPE_COMBO:
+      break;
+    case ITEM_TYPE_LISTBOX:
+      Item_ListBox_Paint(item);
+      break;
+	case ITEM_TYPE_TEXTSCROLL:
+	  Item_TextScroll_Paint ( item );
+	  break;
+    //case ITEM_TYPE_IMAGE:
+    //  Item_Image_Paint(item);
+    //  break;
+    case ITEM_TYPE_MODEL:
+      Item_Model_Paint(item);
+      break;
+    case ITEM_TYPE_YESNO:
+      Item_YesNo_Paint(item);
+      break;
+    case ITEM_TYPE_MULTI:
+      Item_Multi_Paint(item);
+      break;
+    case ITEM_TYPE_BIND:
+      Item_Bind_Paint(item);
+      break;
+    case ITEM_TYPE_SLIDER:
+      Item_Slider_Paint(item);
+      break;
+    default:
+      break;
+  }
+
+}
+
+void Menu_Init(menuDef_t *menu) {
+	memset(menu, 0, sizeof(menuDef_t));
+	menu->cursorItem = -1;
+	menu->fadeAmount = DC->Assets.fadeAmount;
+	menu->fadeClamp = DC->Assets.fadeClamp;
+	menu->fadeCycle = DC->Assets.fadeCycle;
+	Window_Init(&menu->window);
+}
+
+itemDef_t *Menu_GetFocusedItem(menuDef_t *menu) {
+  int i;
+  if (menu) {
+    for (i = 0; i < menu->itemCount; i++) {
+      if (menu->items[i]->window.flags & WINDOW_HASFOCUS) {
+        return menu->items[i];
+      }
+    }
+  }
+  return NULL;
+}
+
+menuDef_t *Menu_GetFocused() {
+  int i;
+  for (i = 0; i < menuCount; i++) {
+    if (Menus[i].window.flags & WINDOW_HASFOCUS && Menus[i].window.flags & WINDOW_VISIBLE) {
+      return &Menus[i];
+    }
+  }
+  return NULL;
+}
+
+void Menu_ScrollFeeder(menuDef_t *menu, int feeder, qboolean down) {
+	if (menu) {
+		int i;
+    for (i = 0; i < menu->itemCount; i++) {
+			if (menu->items[i]->special == feeder) {
+				Item_ListBox_HandleKey(menu->items[i], (down) ? A_CURSOR_DOWN : A_CURSOR_UP, qtrue, qtrue);
+				return;
+			}
+		}
+	}
+}
+
+
+
+void Menu_SetFeederSelection(menuDef_t *menu, int feeder, int index, const char *name) {
+	if (menu == NULL) {
+		if (name == NULL) {
+			menu = Menu_GetFocused();
+		} else {
+			menu = Menus_FindByName(name);
+		}
+	}
+
+	if (menu) {
+		int i;
+    for (i = 0; i < menu->itemCount; i++) {
+			if (menu->items[i]->special == feeder) {
+				if (index == 0) {
+					listBoxDef_t *listPtr = (listBoxDef_t*)menu->items[i]->typeData;
+					listPtr->cursorPos = 0;
+					listPtr->startPos = 0;
+				}
+				menu->items[i]->cursorPos = index;
+				DC->feederSelection(menu->items[i]->special, menu->items[i]->cursorPos, NULL);
+				return;
+			}
+		}
+	}
+}
+
+qboolean Menus_AnyFullScreenVisible() {
+  int i;
+  for (i = 0; i < menuCount; i++) {
+    if (Menus[i].window.flags & WINDOW_VISIBLE && Menus[i].fullScreen) {
+			return qtrue;
+    }
+  }
+  return qfalse;
+}
+
+menuDef_t *Menus_ActivateByName(const char *p) {
+  int i;
+  menuDef_t *m = NULL;
+	menuDef_t *focus = Menu_GetFocused();
+  for (i = 0; i < menuCount; i++) {
+    if (Q_stricmp(Menus[i].window.name, p) == 0) {
+	    m = &Menus[i];
+			Menus_Activate(m);
+			if (openMenuCount < MAX_OPEN_MENUS && focus != NULL) {
+				menuStack[openMenuCount++] = focus;
+			}
+    } else {
+      Menus[i].window.flags &= ~WINDOW_HASFOCUS;
+    }
+  }
+	Display_CloseCinematics();
+
+	// Want to handle a mouse move on the new menu in case your already over an item
+	Menu_HandleMouseMove ( m, DC->cursorx, DC->cursory );
+
+	return m;
+}
+
+
+void Item_Init(itemDef_t *item) {
+	memset(item, 0, sizeof(itemDef_t));
+	item->textscale = 0.55f;
+	Window_Init(&item->window);
+}
+
+void Menu_HandleMouseMove(menuDef_t *menu, float x, float y) {
+
+	//JLFMOUSE  I THINK THIS JUST SETS THE FOCUS BASED ON THE MOUSE
+#ifdef _XBOX
+	return ;
+#endif
+	//END JLF
+
+
+  int i, pass;
+  qboolean focusSet = qfalse;
+
+  itemDef_t *overItem;
+  if (menu == NULL) {
+    return;
+  }
+
+  if (!(menu->window.flags & (WINDOW_VISIBLE | WINDOW_FORCED))) {
+    return;
+  }
+
+	if (itemCapture) {
+		//Item_MouseMove(itemCapture, x, y);
+		return;
+	}
+
+	if (g_waitingForKey || g_editingField) {
+		return;
+	}
+
+  // FIXME: this is the whole issue of focus vs. mouse over.. 
+  // need a better overall solution as i don't like going through everything twice
+  for (pass = 0; pass < 2; pass++) {
+    for (i = 0; i < menu->itemCount; i++) {
+      // turn off focus each item
+      // menu->items[i].window.flags &= ~WINDOW_HASFOCUS;
+
+      if (!(menu->items[i]->window.flags & (WINDOW_VISIBLE | WINDOW_FORCED))) {
+        continue;
+      }
+
+			if (menu->items[i]->disabled) 
+			{
+				continue;
+			}
+
+			// items can be enabled and disabled based on cvars
+			if (menu->items[i]->cvarFlags & (CVAR_ENABLE | CVAR_DISABLE) && !Item_EnableShowViaCvar(menu->items[i], CVAR_ENABLE)) {
+				continue;
+			}
+
+			if (menu->items[i]->cvarFlags & (CVAR_SHOW | CVAR_HIDE) && !Item_EnableShowViaCvar(menu->items[i], CVAR_SHOW)) {
+				continue;
+			}
+
+
+
+      if (Rect_ContainsPoint(&menu->items[i]->window.rect, x, y)) {
+				if (pass == 1) {
+					overItem = menu->items[i];
+					if (overItem->type == ITEM_TYPE_TEXT && overItem->text) {
+						if (!Rect_ContainsPoint(&overItem->window.rect, x, y)) {
+							continue;
+						}
+					}
+					// if we are over an item
+					if (IsVisible(overItem->window.flags)) {
+						// different one
+						Item_MouseEnter(overItem, x, y);
+						// Item_SetMouseOver(overItem, qtrue);
+
+						// if item is not a decoration see if it can take focus
+						if (!focusSet) {
+							focusSet = Item_SetFocus(overItem, x, y);
+						}
+					}
+				}
+      } else if (menu->items[i]->window.flags & WINDOW_MOUSEOVER) {
+          Item_MouseLeave(menu->items[i]);
+          Item_SetMouseOver(menu->items[i], qfalse);
+      }
+    }
+  }
+
+}
+
+void Menu_Paint(menuDef_t *menu, qboolean forcePaint) {
+	int i;
+
+	if (menu == NULL) {
+		return;
+	}
+
+	if (!(menu->window.flags & WINDOW_VISIBLE) &&  !forcePaint) {
+		return;
+	}
+
+	if (menu->window.ownerDrawFlags && DC->ownerDrawVisible && !DC->ownerDrawVisible(menu->window.ownerDrawFlags)) {
+		return;
+	}
+	
+	if (forcePaint) {
+		menu->window.flags |= WINDOW_FORCED;
+	}
+
+	// draw the background if necessary
+	if (menu->fullScreen) {
+		// implies a background shader
+		// FIXME: make sure we have a default shader if fullscreen is set with no background
+		DC->drawHandlePic( 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, menu->window.background );
+	} else if (menu->window.background) {
+		// this allows a background shader without being full screen
+		//UI_DrawHandlePic(menu->window.rect.x, menu->window.rect.y, menu->window.rect.w, menu->window.rect.h, menu->backgroundShader);
+	}
+
+	// paint the background and or border
+	Window_Paint(&menu->window, menu->fadeAmount, menu->fadeClamp, menu->fadeCycle );
+
+	// Loop through all items for the menu and paint them
+	for (i = 0; i < menu->itemCount; i++) 
+	{
+		if (!menu->items[i]->appearanceSlot)
+		{
+			Item_Paint(menu->items[i]);
+		}
+		else // Timed order of appearance
+		{
+			if (menu->appearanceTime < DC->realTime)	// Time to show another item
+			{
+				menu->appearanceTime = DC->realTime + menu->appearanceIncrement;
+				menu->appearanceCnt++;
+			}
+
+			if (menu->items[i]->appearanceSlot<=menu->appearanceCnt)
+			{
+				Item_Paint(menu->items[i]);
+			}
+		}
+	}
+
+	if (debugMode) {
+		vec4_t color;
+		color[0] = color[2] = color[3] = 1;
+		color[1] = 0;
+		DC->drawRect(menu->window.rect.x, menu->window.rect.y, menu->window.rect.w, menu->window.rect.h, 1, color);
+	}
+}
+
+/*
+===============
+Item_ValidateTypeData
+===============
+*/
+void Item_ValidateTypeData(itemDef_t *item) 
+{
+	if (item->typeData) 
+	{
+		return;
+	}
+
+	if (item->type == ITEM_TYPE_LISTBOX) 
+	{
+		item->typeData = UI_Alloc(sizeof(listBoxDef_t));
+		memset(item->typeData, 0, sizeof(listBoxDef_t));
+	}
+	else if (item->type == ITEM_TYPE_EDITFIELD || item->type == ITEM_TYPE_NUMERICFIELD || item->type == ITEM_TYPE_YESNO || item->type == ITEM_TYPE_BIND || item->type == ITEM_TYPE_SLIDER || item->type == ITEM_TYPE_TEXT) 
+	{
+		item->typeData = UI_Alloc(sizeof(editFieldDef_t));
+		memset(item->typeData, 0, sizeof(editFieldDef_t));
+		if (item->type == ITEM_TYPE_EDITFIELD) 
+		{
+			if (!((editFieldDef_t *) item->typeData)->maxPaintChars) 
+			{
+				((editFieldDef_t *) item->typeData)->maxPaintChars = MAX_EDITFIELD;
+			}
+		}
+	} 
+	else if (item->type == ITEM_TYPE_MULTI) 
+	{
+		item->typeData = UI_Alloc(sizeof(multiDef_t));
+	} 
+	else if (item->type == ITEM_TYPE_MODEL) 
+	{
+		item->typeData = UI_Alloc(sizeof(modelDef_t));
+		memset(item->typeData, 0, sizeof(modelDef_t));
+	}
+	else if (item->type == ITEM_TYPE_TEXTSCROLL )
+	{
+		item->typeData = UI_Alloc(sizeof(textScrollDef_t));
+	}
+}
+
+/*
+===============
+Keyword Hash
+===============
+*/
+
+#define KEYWORDHASH_SIZE	512
+
+typedef struct keywordHash_s
+{
+	char *keyword;
+	qboolean (*func)(itemDef_t *item, int handle);
+	struct keywordHash_s *next;
+} keywordHash_t;
+
+int KeywordHash_Key(char *keyword) {
+	int register hash, i;
+
+	hash = 0;
+	for (i = 0; keyword[i] != '\0'; i++) {
+		if (keyword[i] >= 'A' && keyword[i] <= 'Z')
+			hash += (keyword[i] + ('a' - 'A')) * (119 + i);
+		else
+			hash += keyword[i] * (119 + i);
+	}
+	hash = (hash ^ (hash >> 10) ^ (hash >> 20)) & (KEYWORDHASH_SIZE-1);
+	return hash;
+}
+
+void KeywordHash_Add(keywordHash_t *table[], keywordHash_t *key) {
+	int hash;
+
+	hash = KeywordHash_Key(key->keyword);
+/*
+	if (table[hash]) {
+		int collision = qtrue;
+	}
+*/
+	key->next = table[hash];
+	table[hash] = key;
+}
+
+keywordHash_t *KeywordHash_Find(keywordHash_t *table[], char *keyword)
+{
+	keywordHash_t *key;
+	int hash;
+
+	hash = KeywordHash_Key(keyword);
+	for (key = table[hash]; key; key = key->next) {
+		if (!Q_stricmp(key->keyword, keyword))
+			return key;
+	}
+	return NULL;
+}
+
+/*
+===============
+Item Keyword Parse functions
+===============
+*/
+
+// name <string>
+qboolean ItemParse_name( itemDef_t *item, int handle ) {
+	if (!PC_String_Parse(handle, &item->window.name)) {
+		return qfalse;
+	}
+	return qtrue;
+}
+
+// name <string>
+qboolean ItemParse_focusSound( itemDef_t *item, int handle ) {
+	pc_token_t token;
+	if (!trap_PC_ReadToken(handle, &token)) {
+		return qfalse;
+	}
+	item->focusSound = DC->registerSound(token.string);
+	return qtrue;
+}
+
+
+// text <string>
+qboolean ItemParse_text( itemDef_t *item, int handle ) {
+	if (!PC_String_Parse(handle, &item->text)) {
+		return qfalse;
+	}
+	return qtrue;
+}
+
+/*
+===============
+ItemParse_descText 
+	text <string>
+===============
+*/
+qboolean ItemParse_descText( itemDef_t *item, int handle) 
+{
+
+	if (!PC_String_Parse(handle, &item->descText))
+	{
+		return qfalse;
+	}
+
+	return qtrue;
+
+}
+
+
+/*
+===============
+ItemParse_text 
+	text <string>
+===============
+*/
+qboolean ItemParse_text2( itemDef_t *item, int handle) 
+{
+
+	if (!PC_String_Parse(handle, &item->text2))
+	{
+		return qfalse;
+	}
+
+	return qtrue;
+
+}
+
+/*
+===============
+ItemParse_text2alignx 
+===============
+*/
+qboolean ItemParse_text2alignx( itemDef_t *item, int handle) 
+{
+	if (!PC_Float_Parse(handle, &item->text2alignx)) 
+	{
+		return qfalse;
+	}
+	return qtrue;
+}
+
+/*
+===============
+ItemParse_text2aligny 
+===============
+*/
+qboolean ItemParse_text2aligny( itemDef_t *item, int handle) 
+{
+	if (!PC_Float_Parse(handle, &item->text2aligny)) 
+	{
+		return qfalse;
+	}
+	return qtrue;
+}
+
+// group <string>
+qboolean ItemParse_group( itemDef_t *item, int handle ) {
+	if (!PC_String_Parse(handle, &item->window.group)) {
+		return qfalse;
+	}
+	return qtrue;
+}
+
+typedef struct uiG2PtrTracker_s uiG2PtrTracker_t;
+
+struct uiG2PtrTracker_s
+{
+	void *ghoul2;
+	uiG2PtrTracker_t *next;
+};
+
+uiG2PtrTracker_t *ui_G2PtrTracker = NULL;
+
+//rww - UI G2 shared management functions.
+
+//Insert the pointer into our chain so we can keep track of it for freeing.
+void UI_InsertG2Pointer(void *ghoul2)
+{
+	uiG2PtrTracker_t **nextFree = &ui_G2PtrTracker;
+
+	while ((*nextFree) && (*nextFree)->ghoul2)
+	{ //check if it has a ghoul2, if not we can reuse it.
+		nextFree = &((*nextFree)->next);
+	}
+
+	if (!nextFree)
+	{ //shouldn't happen
+		assert(0);
+		return;
+	}
+
+	if (!(*nextFree))
+	{ //if we aren't reusing a chain then allocate space for it.
+		(*nextFree) = (uiG2PtrTracker_t *)BG_Alloc(sizeof(uiG2PtrTracker_t));
+		(*nextFree)->next = NULL;
+	}
+
+	(*nextFree)->ghoul2 = ghoul2;
+}
+
+//Remove a ghoul2 pointer from the chain if it's there.
+void UI_ClearG2Pointer(void *ghoul2)
+{
+	uiG2PtrTracker_t *next = ui_G2PtrTracker;
+
+	if (!ghoul2)
+	{
+		return;
+	}
+
+	while (next)
+	{
+		if (next->ghoul2 == ghoul2)
+		{ //found it, set it to null so we can reuse this link.
+			next->ghoul2 = NULL;
+			break;
+		}
+
+		next = next->next;
+	}
+}
+
+//Called on shutdown, cleans up all the ghoul2 instances laying around.
+void UI_CleanupGhoul2(void)
+{
+	uiG2PtrTracker_t *next = ui_G2PtrTracker;
+
+	while (next)
+	{
+		if (next->ghoul2 && trap_G2_HaveWeGhoul2Models(next->ghoul2))
+		{ //found a g2 instance, clean it.
+			trap_G2API_CleanGhoul2Models(&next->ghoul2);
+		}
+
+		next = next->next;
+	}
+
+#ifdef _XBOX
+	ui_G2PtrTracker = NULL;
+#endif
+}
+
+// asset_model <string>
+int UI_ParseAnimationFile(const char *filename, animation_t *animset, qboolean isHumanoid);
+
+/*
+===============
+ItemParse_asset_model 
+	asset_model <string>
+===============
+*/
+qboolean ItemParse_asset_model_go( itemDef_t *item, const char *name,int *runTimeLength ) 
+{
+#ifndef CGAME
+	int g2Model;
+	modelDef_t *modelPtr;
+	Item_ValidateTypeData(item);
+	modelPtr = (modelDef_t*)item->typeData;
+	*runTimeLength =0.0f;
+
+	if (!Q_stricmp(&name[strlen(name) - 4], ".glm"))
+	{ //it's a ghoul2 model then
+		if ( item->ghoul2 )
+		{
+			UI_ClearG2Pointer(item->ghoul2);	//remove from tracking list
+			trap_G2API_CleanGhoul2Models(&item->ghoul2);	//remove ghoul info
+			item->flags &= ~ITF_G2VALID;
+		}
+
+		g2Model = trap_G2API_InitGhoul2Model(&item->ghoul2, name, 0, modelPtr->g2skin, 0, 0, 0);
+		if (g2Model >= 0)
+		{
+			UI_InsertG2Pointer(item->ghoul2); //remember it so we can free it when the ui shuts down.
+			item->flags |= ITF_G2VALID;
+
+			if (modelPtr->g2anim)
+			{ //does the menu request this model be playing an animation?
+//					DC->g2hilev_SetAnim(&item->ghoul2[0], "model_root", modelPtr->g2anim);
+
+				char GLAName[MAX_QPATH];	
+
+				GLAName[0] = 0;
+				trap_G2API_GetGLAName(item->ghoul2, 0, GLAName);
+
+				if (GLAName[0])
+				{
+					int animIndex;
+					char *slash;
+
+					slash = Q_strrchr( GLAName, '/' );
+
+					if ( slash )
+					{ //If this isn't true the gla path must be messed up somehow.
+						strcpy(slash, "/animation.cfg");
+					
+						animIndex = UI_ParseAnimationFile(GLAName, NULL, qfalse);
+						if (animIndex != -1)
+						{ //We parsed out the animation info for whatever model this is
+							animation_t *anim = &bgAllAnims[animIndex].anims[modelPtr->g2anim];
+
+							int sFrame = anim->firstFrame;
+							int eFrame = anim->firstFrame + anim->numFrames;
+							int flags = BONE_ANIM_OVERRIDE_FREEZE;
+							int time = DC->realTime;
+							float animSpeed = 50.0f / anim->frameLerp;
+							int blendTime = 150;
+
+							if (anim->loopFrames != -1)
+							{
+								flags |= BONE_ANIM_OVERRIDE_LOOP;
+							}
+
+							trap_G2API_SetBoneAnim(item->ghoul2, 0, "model_root", sFrame, eFrame, flags, animSpeed, time, -1, blendTime);
+							*runTimeLength =((anim->frameLerp * (anim->numFrames-2)));					
+						}
+					}
+				} 
+			}
+
+			if ( modelPtr->g2skin )
+			{
+//					DC->g2_SetSkin( &item->ghoul2[0], 0, modelPtr->g2skin );//this is going to set the surfs on/off matching the skin file
+				//trap_G2API_InitGhoul2Model(&item->ghoul2, name, 0, modelPtr->g2skin, 0, 0, 0);
+				//ahh, what are you doing?!
+				trap_G2API_SetSkin(item->ghoul2, 0, modelPtr->g2skin, modelPtr->g2skin);
+			}
+		}
+		/*
+		else
+		{
+			Com_Error(ERR_FATAL, "%s does not exist.", name);
+		}
+		*/
+	}
+	else if(!(item->asset)) 
+	{ //guess it's just an md3
+		item->asset = DC->registerModel(name);
+		item->flags &= ~ITF_G2VALID;
+	}
+#endif
+	return qtrue;
+}
+
+qboolean ItemParse_asset_model( itemDef_t *item, int handle ) {
+	const char *temp;
+	modelDef_t *modelPtr;
+	int animRunLength;
+	pc_token_t token;
+
+	Item_ValidateTypeData(item);
+	modelPtr = (modelDef_t*)item->typeData;
+
+	if (!trap_PC_ReadToken(handle, &token)) {
+		return qfalse;
+	}
+	temp = token.string;
+
+#ifndef CGAME
+	if (!stricmp(token.string,"ui_char_model") )
+	{
+		char modelPath[MAX_QPATH];
+		char ui_char_model[MAX_QPATH];
+		trap_Cvar_VariableStringBuffer("ui_char_model", ui_char_model, sizeof(ui_char_model) );
+		Com_sprintf( modelPath, sizeof( modelPath ), "models/players/%s/model.glm", ui_char_model );
+		temp = modelPath;
+	}
+#endif
+	return (ItemParse_asset_model_go( item, temp, &animRunLength ));
+}
+
+// asset_shader <string>
+qboolean ItemParse_asset_shader( itemDef_t *item, int handle ) {
+	pc_token_t token;
+	if (!trap_PC_ReadToken(handle, &token)) {
+		return qfalse;
+	}
+	item->asset = DC->registerShaderNoMip(token.string);
+	return qtrue;
+}
+
+// model_origin <number> <number> <number>
+qboolean ItemParse_model_origin( itemDef_t *item, int handle ) {
+	modelDef_t *modelPtr;
+	Item_ValidateTypeData(item);
+	modelPtr = (modelDef_t*)item->typeData;
+
+	if (PC_Float_Parse(handle, &modelPtr->origin[0])) {
+		if (PC_Float_Parse(handle, &modelPtr->origin[1])) {
+			if (PC_Float_Parse(handle, &modelPtr->origin[2])) {
+				return qtrue;
+			}
+		}
+	}
+	return qfalse;
+}
+
+// model_fovx <number>
+qboolean ItemParse_model_fovx( itemDef_t *item, int handle ) {
+	modelDef_t *modelPtr;
+	Item_ValidateTypeData(item);
+	modelPtr = (modelDef_t*)item->typeData;
+
+	if (!PC_Float_Parse(handle, &modelPtr->fov_x)) {
+		return qfalse;
+	}
+	return qtrue;
+}
+
+// model_fovy <number>
+qboolean ItemParse_model_fovy( itemDef_t *item, int handle ) {
+	modelDef_t *modelPtr;
+	Item_ValidateTypeData(item);
+	modelPtr = (modelDef_t*)item->typeData;
+
+	if (!PC_Float_Parse(handle, &modelPtr->fov_y)) {
+		return qfalse;
+	}
+	return qtrue;
+}
+
+// model_rotation <integer>
+qboolean ItemParse_model_rotation( itemDef_t *item, int handle ) {
+	modelDef_t *modelPtr;
+	Item_ValidateTypeData(item);
+	modelPtr = (modelDef_t*)item->typeData;
+
+	if (!PC_Int_Parse(handle, &modelPtr->rotationSpeed)) {
+		return qfalse;
+	}
+	return qtrue;
+}
+
+// model_angle <integer>
+qboolean ItemParse_model_angle( itemDef_t *item, int handle ) {
+	modelDef_t *modelPtr;
+	Item_ValidateTypeData(item);
+	modelPtr = (modelDef_t*)item->typeData;
+
+	if (!PC_Int_Parse(handle, &modelPtr->angle)) {
+		return qfalse;
+	}
+	return qtrue;
+}
+
+// model_g2mins <number> <number> <number>
+qboolean ItemParse_model_g2mins( itemDef_t *item, int handle ) {
+	modelDef_t *modelPtr;
+	Item_ValidateTypeData(item);
+	modelPtr = (modelDef_t*)item->typeData;
+
+	if (PC_Float_Parse(handle, &modelPtr->g2mins[0])) {
+		if (PC_Float_Parse(handle, &modelPtr->g2mins[1])) {
+			if (PC_Float_Parse(handle, &modelPtr->g2mins[2])) {
+				return qtrue;
+			}
+		}
+	}
+	return qfalse;
+}
+
+// model_g2maxs <number> <number> <number>
+qboolean ItemParse_model_g2maxs( itemDef_t *item, int handle ) {
+	modelDef_t *modelPtr;
+	Item_ValidateTypeData(item);
+	modelPtr = (modelDef_t*)item->typeData;
+
+	if (PC_Float_Parse(handle, &modelPtr->g2maxs[0])) {
+		if (PC_Float_Parse(handle, &modelPtr->g2maxs[1])) {
+			if (PC_Float_Parse(handle, &modelPtr->g2maxs[2])) {
+				return qtrue;
+			}
+		}
+	}
+	return qfalse;
+}
+
+// model_g2scale <number> <number> <number>
+qboolean ItemParse_model_g2scale( itemDef_t *item, int handle ) {
+	modelDef_t *modelPtr;
+	Item_ValidateTypeData(item);
+	modelPtr = (modelDef_t*)item->typeData;
+
+	if (PC_Float_Parse(handle, &modelPtr->g2scale[0])) {
+		if (PC_Float_Parse(handle, &modelPtr->g2scale[1])) {
+			if (PC_Float_Parse(handle, &modelPtr->g2scale[2])) {
+				return qtrue;
+			}
+		}
+	}
+	return qfalse;
+}
+
+// model_g2skin <string>
+qhandle_t trap_R_RegisterSkin( const char *name );
+
+qboolean ItemParse_model_g2skin( itemDef_t *item, int handle ) {
+	modelDef_t *modelPtr;
+	pc_token_t token;
+
+	Item_ValidateTypeData(item);
+	modelPtr = (modelDef_t*)item->typeData;
+
+	if (!trap_PC_ReadToken(handle, &token)) {
+		return qfalse;
+	}
+
+	if (!token.string[0])
+	{ //it was parsed correctly so still return true.
+		return qtrue;
+	}
+
+	modelPtr->g2skin = trap_R_RegisterSkin(token.string);
+
+	return qtrue;
+}
+
+// model_g2anim <number>
+qboolean ItemParse_model_g2anim( itemDef_t *item, int handle ) {
+	modelDef_t *modelPtr;
+	pc_token_t token;
+	int i = 0;
+
+	Item_ValidateTypeData(item);
+	modelPtr = (modelDef_t*)item->typeData;
+
+	if (!trap_PC_ReadToken(handle, &token)) {
+		return qfalse;
+	}
+
+	if ( !token.string[0])
+	{ //it was parsed correctly so still return true.
+		return qtrue;
+	}
+
+	while (i < MAX_ANIMATIONS)
+	{
+		if (!Q_stricmp(token.string, animTable[i].name))
+		{ //found it
+			modelPtr->g2anim = i;
+			return qtrue;
+		}
+		i++;
+	}
+
+	Com_Printf("Could not find '%s' in the anim table\n", token.string);
+	return qtrue;
+}
+
+// model_g2skin <string>
+qboolean ItemParse_model_g2skin_go( itemDef_t *item, const char *skinName ) 
+{
+
+	modelDef_t *modelPtr;
+	int defSkin;
+
+
+	Item_ValidateTypeData(item);
+	modelPtr = (modelDef_t*)item->typeData;
+
+	if (!skinName || !skinName[0])
+	{ //it was parsed correctly so still return true.
+		modelPtr->g2skin = 0;
+		trap_G2API_SetSkin(item->ghoul2, 0, 0, 0);
+
+		return qtrue;
+	}
+
+	// set skin
+	if ( item->ghoul2 )
+	{
+		defSkin = trap_R_RegisterSkin(skinName);
+		trap_G2API_SetSkin(item->ghoul2, 0, defSkin, defSkin);
+	}
+
+	return qtrue;
+}
+
+// model_g2anim <number>
+qboolean ItemParse_model_g2anim_go( itemDef_t *item, const char *animName ) 
+{
+	modelDef_t *modelPtr;
+	int i = 0;
+
+	Item_ValidateTypeData(item);
+	modelPtr = (modelDef_t*)item->typeData;
+
+	if (!animName || !animName[0])
+	{ //it was parsed correctly so still return true.
+		return qtrue;
+	}
+
+	while (i < MAX_ANIMATIONS)
+	{
+		if (!Q_stricmp(animName, animTable[i].name))
+		{ //found it
+			modelPtr->g2anim = animTable[i].id;
+			return qtrue;
+		}
+		i++;
+	}
+
+	Com_Printf("Could not find '%s' in the anim table\n", animName);
+	return qtrue;
+}
+
+// Get the cvar, get the values and stuff them in the rect structure.
+qboolean ItemParse_rectcvar( itemDef_t *item, int handle ) 
+{
+	char	cvarBuf[1024];
+	const char	*holdVal;
+	char	*holdBuf;
+
+	// get Cvar name
+	pc_token_t token;
+	if (!trap_PC_ReadToken(handle, &token))
+	{
+		return qfalse;
+	}
+
+	// get cvar data
+	DC->getCVarString(token.string, cvarBuf, sizeof(cvarBuf));
+	
+	holdBuf = cvarBuf;
+	if (String_Parse(&holdBuf,&holdVal))
+	{
+		item->window.rectClient.x = atof(holdVal);
+		if (String_Parse(&holdBuf,&holdVal))
+		{
+			item->window.rectClient.y = atof(holdVal);
+			if (String_Parse(&holdBuf,&holdVal))
+			{
+				item->window.rectClient.w = atof(holdVal);
+				if (String_Parse(&holdBuf,&holdVal))
+				{
+					item->window.rectClient.h = atof(holdVal);
+					return qtrue;
+				}
+			}
+		}
+	}
+
+	// There may be no cvar built for this, and that's okay. . . I guess.
+	return qtrue;
+}
+
+// rect <rectangle>
+qboolean ItemParse_rect( itemDef_t *item, int handle ) {
+	if (!PC_Rect_Parse(handle, &item->window.rectClient)) {
+		return qfalse;
+	}
+	return qtrue;
+}
+
+/*
+===============
+ItemParse_flag
+	style <integer>
+===============
+*/
+qboolean ItemParse_flag( itemDef_t *item, int handle) 
+{
+	int		i;
+	pc_token_t token;
+
+	if (!trap_PC_ReadToken(handle, &token))
+	{
+		return qfalse;
+	}
+
+	i=0;
+	while (styles[i])
+	{
+		if (Q_stricmp(token.string,itemFlags[i].string)==0)
+		{
+			item->window.flags |= itemFlags[i].value;
+			break;
+		}
+		i++;
+	}
+
+	if (itemFlags[i].string == NULL)
+	{
+		Com_Printf(va( S_COLOR_YELLOW "Unknown item style value '%s'",token.string));
+	}
+
+	return qtrue;
+}
+
+/*
+===============
+ItemParse_style 
+	style <integer>
+===============
+*/
+qboolean ItemParse_style( itemDef_t *item, int handle) 
+{
+	if (!PC_Int_Parse(handle, &item->window.style))
+	{
+		Com_Printf(S_COLOR_YELLOW "Unknown item style value");
+		return qfalse;
+	}
+
+	return qtrue;
+}
+
+
+// decoration
+qboolean ItemParse_decoration( itemDef_t *item, int handle ) {
+	item->window.flags |= WINDOW_DECORATION;
+	return qtrue;
+}
+
+// notselectable
+qboolean ItemParse_notselectable( itemDef_t *item, int handle ) {
+	listBoxDef_t *listPtr;
+	Item_ValidateTypeData(item);
+	listPtr = (listBoxDef_t*)item->typeData;
+	if (item->type == ITEM_TYPE_LISTBOX && listPtr) {
+		listPtr->notselectable = qtrue;
+	}
+	return qtrue;
+}
+
+/*
+===============
+ItemParse_scrollhidden
+	scrollhidden
+===============
+*/
+qboolean ItemParse_scrollhidden( itemDef_t *item , int handle) 
+{
+	listBoxDef_t *listPtr;
+	Item_ValidateTypeData(item);
+	listPtr = (listBoxDef_t*)item->typeData;
+
+	if (item->type == ITEM_TYPE_LISTBOX && listPtr) 
+	{
+		listPtr->scrollhidden = qtrue;
+	}
+	return qtrue;
+}
+
+
+
+
+
+// manually wrapped
+qboolean ItemParse_wrapped( itemDef_t *item, int handle ) {
+	item->window.flags |= WINDOW_WRAPPED;
+	return qtrue;
+}
+
+// auto wrapped
+qboolean ItemParse_autowrapped( itemDef_t *item, int handle ) {
+	item->window.flags |= WINDOW_AUTOWRAPPED;
+	return qtrue;
+}
+
+
+// horizontalscroll
+qboolean ItemParse_horizontalscroll( itemDef_t *item, int handle ) {
+	item->window.flags |= WINDOW_HORIZONTAL;
+	return qtrue;
+}
+
+/*
+===============
+ItemParse_type 
+	type <integer>
+===============
+*/
+qboolean ItemParse_type( itemDef_t *item, int handle  ) 
+{
+//	int		i,holdInt;
+
+	if (!PC_Int_Parse(handle, &item->type)) 
+	{
+		return qfalse;
+	}
+	Item_ValidateTypeData(item);
+	return qtrue;
+}
+
+// elementwidth, used for listbox image elements
+// uses textalignx for storage
+qboolean ItemParse_elementwidth( itemDef_t *item, int handle ) {
+	listBoxDef_t *listPtr;
+
+	Item_ValidateTypeData(item);
+	listPtr = (listBoxDef_t*)item->typeData;
+	if (!PC_Float_Parse(handle, &listPtr->elementWidth)) {
+		return qfalse;
+	}
+	return qtrue;
+}
+
+// elementheight, used for listbox image elements
+// uses textaligny for storage
+qboolean ItemParse_elementheight( itemDef_t *item, int handle ) {
+	listBoxDef_t *listPtr;
+
+	Item_ValidateTypeData(item);
+	listPtr = (listBoxDef_t*)item->typeData;
+	if (!PC_Float_Parse(handle, &listPtr->elementHeight)) {
+		return qfalse;
+	}
+	return qtrue;
+}
+
+// feeder <float>
+qboolean ItemParse_feeder( itemDef_t *item, int handle ) {
+	if (!PC_Float_Parse(handle, &item->special)) {
+		return qfalse;
+	}
+	return qtrue;
+}
+
+// elementtype, used to specify what type of elements a listbox contains
+// uses textstyle for storage
+qboolean ItemParse_elementtype( itemDef_t *item, int handle ) {
+	listBoxDef_t *listPtr;
+
+	Item_ValidateTypeData(item);
+	if (!item->typeData)
+		return qfalse;
+	listPtr = (listBoxDef_t*)item->typeData;
+	if (!PC_Int_Parse(handle, &listPtr->elementStyle)) {
+		return qfalse;
+	}
+	return qtrue;
+}
+
+// columns sets a number of columns and an x pos and width per.. 
+qboolean ItemParse_columns( itemDef_t *item, int handle ) {
+	int num, i;
+	listBoxDef_t *listPtr;
+
+	Item_ValidateTypeData(item);
+	if (!item->typeData)
+		return qfalse;
+	listPtr = (listBoxDef_t*)item->typeData;
+	if (PC_Int_Parse(handle, &num)) {
+		if (num > MAX_LB_COLUMNS) {
+			num = MAX_LB_COLUMNS;
+		}
+		listPtr->numColumns = num;
+		for (i = 0; i < num; i++) {
+			int pos, width, maxChars;
+
+			if (PC_Int_Parse(handle, &pos) && PC_Int_Parse(handle, &width) && PC_Int_Parse(handle, &maxChars)) {
+				listPtr->columnInfo[i].pos = pos;
+				listPtr->columnInfo[i].width = width;
+				listPtr->columnInfo[i].maxChars = maxChars;
+			} else {
+				return qfalse;
+			}
+		}
+	} else {
+		return qfalse;
+	}
+	return qtrue;
+}
+
+qboolean ItemParse_border( itemDef_t *item, int handle ) {
+	if (!PC_Int_Parse(handle, &item->window.border)) {
+		return qfalse;
+	}
+	return qtrue;
+}
+
+qboolean ItemParse_bordersize( itemDef_t *item, int handle ) {
+	if (!PC_Float_Parse(handle, &item->window.borderSize)) {
+		return qfalse;
+	}
+	return qtrue;
+}
+
+qboolean ItemParse_visible( itemDef_t *item, int handle ) {
+	int i;
+
+	if (!PC_Int_Parse(handle, &i)) {
+		return qfalse;
+	}
+	if (i) {
+		item->window.flags |= WINDOW_VISIBLE;
+	}
+	return qtrue;
+}
+
+qboolean ItemParse_ownerdraw( itemDef_t *item, int handle ) {
+	if (!PC_Int_Parse(handle, &item->window.ownerDraw)) {
+		return qfalse;
+	}
+	item->type = ITEM_TYPE_OWNERDRAW;
+	return qtrue;
+}
+
+qboolean ItemParse_align( itemDef_t *item, int handle ) {
+	if (!PC_Int_Parse(handle, &item->alignment)) {
+		return qfalse;
+	}
+	return qtrue;
+}
+
+/*
+===============
+ItemParse_isCharacter 
+
+Sets item flag showing this is a character
+===============
+*/
+qboolean ItemParse_isCharacter( itemDef_t *item, int handle  )
+{
+	int flag;
+
+	if (PC_Int_Parse(handle, &flag)) 
+	{
+		if ( flag )
+		{
+			item->flags |= ITF_ISCHARACTER;
+		}
+		else
+		{
+			item->flags &= ~ITF_ISCHARACTER;
+		}
+		return qtrue;
+	}
+	return qfalse;
+}
+
+
+/*
+===============
+ItemParse_textalign 
+===============
+*/
+qboolean ItemParse_textalign( itemDef_t *item, int handle ) 
+{
+	if (!PC_Int_Parse(handle, &item->textalignment)) 
+	{
+		Com_Printf(S_COLOR_YELLOW "Unknown text alignment value");
+	
+		return qfalse;
+	}
+
+	return qtrue;
+}
+
+qboolean ItemParse_textalignx( itemDef_t *item, int handle ) {
+	if (!PC_Float_Parse(handle, &item->textalignx)) {
+		return qfalse;
+	}
+	return qtrue;
+}
+
+qboolean ItemParse_textaligny( itemDef_t *item, int handle ) {
+	if (!PC_Float_Parse(handle, &item->textaligny)) {
+		return qfalse;
+	}
+	return qtrue;
+}
+
+qboolean ItemParse_textscale( itemDef_t *item, int handle ) {
+	if (!PC_Float_Parse(handle, &item->textscale)) {
+		return qfalse;
+	}
+	return qtrue;
+}
+
+qboolean ItemParse_textstyle( itemDef_t *item, int handle ) {
+	if (!PC_Int_Parse(handle, &item->textStyle)) {
+		return qfalse;
+	}
+	return qtrue;
+}
+
+/*
+===============
+ItemParse_invertyesno
+===============
+*/
+//JLFYESNO MPMOVED
+qboolean ItemParse_invertyesno( itemDef_t *item, int handle) 
+{
+	if (!PC_Int_Parse(handle, &item->invertYesNo)) 
+	{
+		return qfalse;
+	}
+	return qtrue;
+}
+
+/*
+===============
+ItemParse_xoffset (used for yes/no and multi)
+===============
+*/
+qboolean ItemParse_xoffset( itemDef_t *item, int handle) 
+{
+	if (PC_Int_Parse(handle, &item->xoffset)) 
+	{
+		return qfalse;
+	}
+	return qtrue;
+}
+
+
+qboolean ItemParse_backcolor( itemDef_t *item, int handle ) {
+	int i;
+	float f;
+
+	for (i = 0; i < 4; i++) {
+		if (!PC_Float_Parse(handle, &f)) {
+			return qfalse;
+		}
+		item->window.backColor[i]  = f;
+	}
+	return qtrue;
+}
+
+qboolean ItemParse_forecolor( itemDef_t *item, int handle ) {
+	int i;
+	float f;
+
+	for (i = 0; i < 4; i++) {
+		if (!PC_Float_Parse(handle, &f)) {
+			return qfalse;
+		}
+
+		if (f < 0)
+		{	//special case for player color
+			item->window.flags |= WINDOW_PLAYERCOLOR;
+			return qtrue;
+		}
+
+		item->window.foreColor[i]  = f;
+		item->window.flags |= WINDOW_FORECOLORSET;
+	}
+	return qtrue;
+}
+
+qboolean ItemParse_bordercolor( itemDef_t *item, int handle ) {
+	int i;
+	float f;
+
+	for (i = 0; i < 4; i++) {
+		if (!PC_Float_Parse(handle, &f)) {
+			return qfalse;
+		}
+		item->window.borderColor[i]  = f;
+	}
+	return qtrue;
+}
+
+qboolean ItemParse_outlinecolor( itemDef_t *item, int handle ) {
+	if (!PC_Color_Parse(handle, &item->window.outlineColor)){
+		return qfalse;
+	}
+	return qtrue;
+}
+
+qboolean ItemParse_background( itemDef_t *item, int handle ) {
+	pc_token_t token;
+
+	if (!trap_PC_ReadToken(handle, &token)) {
+		return qfalse;
+	}
+	item->window.background = DC->registerShaderNoMip(token.string);
+	return qtrue;
+}
+
+qboolean ItemParse_cinematic( itemDef_t *item, int handle ) {
+	if (!PC_String_Parse(handle, &item->window.cinematicName)) {
+		return qfalse;
+	}
+	return qtrue;
+}
+
+qboolean ItemParse_doubleClick( itemDef_t *item, int handle ) {
+	listBoxDef_t *listPtr;
+
+	Item_ValidateTypeData(item);
+	if (!item->typeData) {
+		return qfalse;
+	}
+
+	listPtr = (listBoxDef_t*)item->typeData;
+
+	if (!PC_Script_Parse(handle, &listPtr->doubleClick)) {
+		return qfalse;
+	}
+	return qtrue;
+}
+
+qboolean ItemParse_onFocus( itemDef_t *item, int handle ) {
+	if (!PC_Script_Parse(handle, &item->onFocus)) {
+		return qfalse;
+	}
+	return qtrue;
+}
+
+qboolean ItemParse_leaveFocus( itemDef_t *item, int handle ) {
+	if (!PC_Script_Parse(handle, &item->leaveFocus)) {
+		return qfalse;
+	}
+	return qtrue;
+}
+
+qboolean ItemParse_mouseEnter( itemDef_t *item, int handle ) {
+	if (!PC_Script_Parse(handle, &item->mouseEnter)) {
+		return qfalse;
+	}
+	return qtrue;
+}
+
+qboolean ItemParse_mouseExit( itemDef_t *item, int handle ) {
+	if (!PC_Script_Parse(handle, &item->mouseExit)) {
+		return qfalse;
+	}
+	return qtrue;
+}
+
+qboolean ItemParse_mouseEnterText( itemDef_t *item, int handle ) {
+	if (!PC_Script_Parse(handle, &item->mouseEnterText)) {
+		return qfalse;
+	}
+	return qtrue;
+}
+
+qboolean ItemParse_mouseExitText( itemDef_t *item, int handle ) {
+	if (!PC_Script_Parse(handle, &item->mouseExitText)) {
+		return qfalse;
+	}
+	return qtrue;
+}
+
+qboolean ItemParse_action( itemDef_t *item, int handle ) {
+	if (!PC_Script_Parse(handle, &item->action)) {
+		return qfalse;
+	}
+	return qtrue;
+}
+
+qboolean ItemParse_special( itemDef_t *item, int handle ) {
+	if (!PC_Float_Parse(handle, &item->special)) {
+		return qfalse;
+	}
+	return qtrue;
+}
+
+qboolean ItemParse_cvarTest( itemDef_t *item, int handle ) {
+	if (!PC_String_Parse(handle, &item->cvarTest)) {
+		return qfalse;
+	}
+	return qtrue;
+}
+
+qboolean ItemParse_cvar( itemDef_t *item, int handle ) 
+{
+	Item_ValidateTypeData(item);
+	if (!PC_String_Parse(handle, &item->cvar)) 
+	{
+		return qfalse;
+	}
+
+	if ( item->typeData)
+	{
+		editFieldDef_t *editPtr;
+
+		switch ( item->type )
+		{
+			case ITEM_TYPE_EDITFIELD:
+			case ITEM_TYPE_NUMERICFIELD:
+			case ITEM_TYPE_YESNO:
+			case ITEM_TYPE_BIND:
+			case ITEM_TYPE_SLIDER:
+			case ITEM_TYPE_TEXT:
+				editPtr = (editFieldDef_t*)item->typeData;
+				editPtr->minVal = -1;
+				editPtr->maxVal = -1;
+				editPtr->defVal = -1;
+				break;
+		}
+	}
+	return qtrue;
+}
+
+qboolean ItemParse_font( itemDef_t *item, int handle ) 
+{
+	Item_ValidateTypeData(item);
+	if (!PC_Int_Parse(handle, &item->iMenuFont)) 
+	{
+		return qfalse;
+	}
+	return qtrue;
+}
+
+
+qboolean ItemParse_maxChars( itemDef_t *item, int handle ) {
+	editFieldDef_t *editPtr;
+	int maxChars;
+
+	Item_ValidateTypeData(item);
+	if (!item->typeData)
+		return qfalse;
+
+	if (!PC_Int_Parse(handle, &maxChars)) {
+		return qfalse;
+	}
+	editPtr = (editFieldDef_t*)item->typeData;
+	editPtr->maxChars = maxChars;
+	return qtrue;
+}
+
+qboolean ItemParse_maxPaintChars( itemDef_t *item, int handle ) {
+	editFieldDef_t *editPtr;
+	int maxChars;
+
+	Item_ValidateTypeData(item);
+	if (!item->typeData)
+		return qfalse;
+
+	if (!PC_Int_Parse(handle, &maxChars)) {
+		return qfalse;
+	}
+	editPtr = (editFieldDef_t*)item->typeData;
+	editPtr->maxPaintChars = maxChars;
+	return qtrue;
+}
+
+qboolean ItemParse_maxLineChars( itemDef_t *item, int handle ) 
+{
+	textScrollDef_t *scrollPtr;
+	int				maxChars;
+
+	Item_ValidateTypeData(item);
+	if (!item->typeData)
+		return qfalse;
+
+	if (!PC_Int_Parse(handle, &maxChars)) 
+	{
+		return qfalse;
+	}
+
+	scrollPtr = (textScrollDef_t*)item->typeData;
+	scrollPtr->maxLineChars = maxChars;
+
+	return qtrue;
+}
+
+qboolean ItemParse_lineHeight( itemDef_t *item, int handle ) 
+{
+	textScrollDef_t *scrollPtr;
+	int				height;
+
+	Item_ValidateTypeData(item);
+	if (!item->typeData)
+		return qfalse;
+
+	if (!PC_Int_Parse(handle, &height)) 
+	{
+		return qfalse;
+	}
+
+	scrollPtr = (textScrollDef_t*)item->typeData;
+	scrollPtr->lineHeight = height;
+
+	return qtrue;
+}
+
+qboolean ItemParse_cvarFloat( itemDef_t *item, int handle ) {
+	editFieldDef_t *editPtr;
+
+	Item_ValidateTypeData(item);
+	if (!item->typeData)
+		return qfalse;
+	editPtr = (editFieldDef_t*)item->typeData;
+	if (PC_String_Parse(handle, &item->cvar) &&
+		PC_Float_Parse(handle, &editPtr->defVal) &&
+		PC_Float_Parse(handle, &editPtr->minVal) &&
+		PC_Float_Parse(handle, &editPtr->maxVal)) {
+		return qtrue;
+	}
+	return qfalse;
+}
+
+char currLanguage[32][128];
+static const char languageString[32] = "@MENUS_MYLANGUAGE";
+
+qboolean ItemParse_cvarStrList( itemDef_t *item, int handle ) {
+	pc_token_t token;
+	multiDef_t *multiPtr;
+	int pass;
+	
+	Item_ValidateTypeData(item);
+	if (!item->typeData)
+		return qfalse;
+	multiPtr = (multiDef_t*)item->typeData;
+	multiPtr->count = 0;
+	multiPtr->strDef = qtrue;
+
+	if (!trap_PC_ReadToken(handle, &token))
+	{
+		return qfalse;
+	}
+
+	if (!Q_stricmp(token.string,"feeder") && item->special == FEEDER_PLAYER_SPECIES) 
+	{
+#ifndef CGAME
+		for (; multiPtr->count < uiInfo.playerSpeciesCount; multiPtr->count++)
+		{
+			multiPtr->cvarList[multiPtr->count] = String_Alloc(strupr(va("@MENUS_%s",uiInfo.playerSpecies[multiPtr->count].Name )));	//look up translation
+			multiPtr->cvarStr[multiPtr->count] = uiInfo.playerSpecies[multiPtr->count].Name;	//value
+		}
+#endif
+		return qtrue;
+	}
+	// languages
+	if (!Q_stricmp(token.string,"feeder") && item->special == FEEDER_LANGUAGES) 
+	{
+#ifndef CGAME
+		for (; multiPtr->count < uiInfo.languageCount; multiPtr->count++)
+		{
+			// The displayed text
+			trap_GetLanguageName( (const int) multiPtr->count,(char *) currLanguage[multiPtr->count]  );	// eg "English"
+			multiPtr->cvarList[multiPtr->count] = languageString;
+			// The cvar value that goes into se_language
+			trap_GetLanguageName( (const int) multiPtr->count,(char *) currLanguage[multiPtr->count] );
+			multiPtr->cvarStr[multiPtr->count] = currLanguage[multiPtr->count];
+		}
+#endif
+		return qtrue;
+	}
+
+	if (*token.string != '{') {
+		return qfalse;
+	}
+
+	pass = 0;
+	while ( 1 ) {
+		char* psString;
+
+//		if (!trap_PC_ReadToken(handle, &token)) {
+//			PC_SourceError(handle, "end of file inside menu item\n");
+//			return qfalse;
+//		}		   
+
+		if (!PC_String_Parse(handle, (const char **)&psString)) 
+		{
+			PC_SourceError(handle, "end of file inside menu item\n");
+			return qfalse;
+		}
+
+		//a normal StringAlloc ptr
+		if ((int)psString > 0)	
+		{
+			if (*psString == '}') {
+				return qtrue;
+			}
+
+			if (*psString == ',' || *psString == ';') {
+				continue;
+			}
+		}
+
+		if (pass == 0) {
+			multiPtr->cvarList[multiPtr->count] = psString;
+			pass = 1;
+		} else {
+			multiPtr->cvarStr[multiPtr->count] = psString;
+			pass = 0;
+			multiPtr->count++;
+			if (multiPtr->count >= MAX_MULTI_CVARS) {
+				return qfalse;
+			}
+		}
+
+	}
+	return qfalse; 	// bk001205 - LCC missing return value
+}
+
+qboolean ItemParse_cvarFloatList( itemDef_t *item, int handle ) 
+{
+	pc_token_t token;
+	multiDef_t *multiPtr;
+	
+	Item_ValidateTypeData(item);
+	if (!item->typeData)
+	{
+		return qfalse;
+	}
+	
+	multiPtr = (multiDef_t*)item->typeData;
+	multiPtr->count = 0;
+	multiPtr->strDef = qfalse;
+
+	if (!trap_PC_ReadToken(handle, &token))
+	{
+		return qfalse;
+	}
+	
+	if (*token.string != '{') 
+	{
+		return qfalse;
+	}
+
+	while ( 1 ) 
+	{
+		char* string;
+
+		if ( !PC_String_Parse ( handle, (const char **)&string ) )
+		{
+			PC_SourceError(handle, "end of file inside menu item\n");
+			return qfalse;
+		}
+			
+		//a normal StringAlloc ptr
+		if ((int)string > 0)	
+		{
+			if (*string == '}') 
+			{
+				return qtrue;
+			}
+
+			if (*string == ',' || *string == ';') 
+			{
+				continue;
+			}
+		}
+
+		multiPtr->cvarList[multiPtr->count] = string;
+		if (!PC_Float_Parse(handle, &multiPtr->cvarValue[multiPtr->count])) 
+		{
+			return qfalse;
+		}
+
+		multiPtr->count++;
+		if (multiPtr->count >= MAX_MULTI_CVARS) 
+		{
+			return qfalse;
+		}
+
+	}
+	return qfalse; 	// bk001205 - LCC missing return value
+}
+
+
+
+qboolean ItemParse_addColorRange( itemDef_t *item, int handle ) {
+	colorRangeDef_t color;
+
+	if (PC_Float_Parse(handle, &color.low) &&
+		PC_Float_Parse(handle, &color.high) &&
+		PC_Color_Parse(handle, &color.color) ) {
+		if (item->numColors < MAX_COLOR_RANGES) {
+			memcpy(&item->colorRanges[item->numColors], &color, sizeof(color));
+			item->numColors++;
+		}
+		return qtrue;
+	}
+	return qfalse;
+}
+
+qboolean ItemParse_ownerdrawFlag( itemDef_t *item, int handle ) {
+	int i;
+	if (!PC_Int_Parse(handle, &i)) {
+		return qfalse;
+	}
+	item->window.ownerDrawFlags |= i;
+	return qtrue;
+}
+
+qboolean ItemParse_enableCvar( itemDef_t *item, int handle ) {
+	if (PC_Script_Parse(handle, &item->enableCvar)) {
+		item->cvarFlags = CVAR_ENABLE;
+		return qtrue;
+	}
+	return qfalse;
+}
+
+qboolean ItemParse_disableCvar( itemDef_t *item, int handle ) {
+	if (PC_Script_Parse(handle, &item->enableCvar)) {
+		item->cvarFlags = CVAR_DISABLE;
+		return qtrue;
+	}
+	return qfalse;
+}
+
+qboolean ItemParse_showCvar( itemDef_t *item, int handle ) {
+	if (PC_Script_Parse(handle, &item->enableCvar)) {
+		item->cvarFlags = CVAR_SHOW;
+		return qtrue;
+	}
+	return qfalse;
+}
+
+qboolean ItemParse_hideCvar( itemDef_t *item, int handle ) {
+	if (PC_Script_Parse(handle, &item->enableCvar)) {
+		item->cvarFlags = CVAR_HIDE;
+		return qtrue;
+	}
+	return qfalse;
+}
+
+/*
+===============
+ItemParse_align 
+===============
+*/
+qboolean ItemParse_Appearance_slot( itemDef_t *item, int handle ) 
+{
+	if (!PC_Int_Parse(handle, &item->appearanceSlot))
+	{
+		return qfalse;
+	}
+	return qtrue;
+}
+
+qboolean ItemParse_isSaber( itemDef_t *item, int handle  )
+{
+#ifndef CGAME
+
+	int	i;
+
+	if (PC_Int_Parse(handle, &i)) 
+	{
+		if ( i )
+		{
+			item->flags |= ITF_ISSABER;
+			UI_CacheSaberGlowGraphics();
+			if ( !ui_saber_parms_parsed )
+			{
+				UI_SaberLoadParms();
+			}
+		}
+		else
+		{
+			item->flags &= ~ITF_ISSABER;
+		}
+	
+		return qtrue;
+	}
+#endif
+	return qfalse;
+}
+
+//extern void UI_SaberLoadParms( void );
+//extern qboolean ui_saber_parms_parsed;
+//extern void UI_CacheSaberGlowGraphics( void );
+
+qboolean ItemParse_isSaber2( itemDef_t *item, int handle  )
+{
+#ifndef CGAME
+	int	i;
+	if (PC_Int_Parse(handle, &i)) 
+	{
+		if ( i )
+		{
+			item->flags |= ITF_ISSABER2;
+			UI_CacheSaberGlowGraphics();
+			if ( !ui_saber_parms_parsed )
+			{
+				UI_SaberLoadParms();
+			}
+		}
+		else
+		{
+			item->flags &= ~ITF_ISSABER2;
+		}
+
+		return qtrue;
+	}
+#endif
+	
+	return qfalse;
+}
+
+keywordHash_t itemParseKeywords[] = {
+	{"action",			ItemParse_action,			NULL	},
+	{"addColorRange",	ItemParse_addColorRange,	NULL	},
+	{"align",			ItemParse_align,			NULL	},
+	{"autowrapped",		ItemParse_autowrapped,		NULL	},
+	{"appearance_slot",	ItemParse_Appearance_slot,	NULL	},
+	{"asset_model",		ItemParse_asset_model,		NULL	},
+	{"asset_shader",	ItemParse_asset_shader,		NULL	},
+	{"backcolor",		ItemParse_backcolor,		NULL	},
+	{"background",		ItemParse_background,		NULL	},
+	{"border",			ItemParse_border,			NULL	},
+	{"bordercolor",		ItemParse_bordercolor,		NULL	},
+	{"bordersize",		ItemParse_bordersize,		NULL	},
+	{"cinematic",		ItemParse_cinematic,		NULL	},
+	{"columns",			ItemParse_columns,			NULL	},
+	{"cvar",			ItemParse_cvar,				NULL	},
+	{"cvarFloat",		ItemParse_cvarFloat,		NULL	},
+	{"cvarFloatList",	ItemParse_cvarFloatList,	NULL	},
+	{"cvarStrList",		ItemParse_cvarStrList,		NULL	},
+	{"cvarTest",		ItemParse_cvarTest,			NULL	},
+	{"desctext",		ItemParse_descText,			NULL	},
+	{"decoration",		ItemParse_decoration,		NULL	},
+	{"disableCvar",		ItemParse_disableCvar,		NULL	},
+	{"doubleclick",		ItemParse_doubleClick,		NULL	},
+	{"elementheight",	ItemParse_elementheight,	NULL	},
+	{"elementtype",		ItemParse_elementtype,		NULL	},
+	{"elementwidth",	ItemParse_elementwidth,		NULL	},
+	{"enableCvar",		ItemParse_enableCvar,		NULL	},
+	{"feeder",			ItemParse_feeder,			NULL	},
+	{"flag",			ItemParse_flag,				NULL	},
+	{"focusSound",		ItemParse_focusSound,		NULL	},
+	{"font",			ItemParse_font,				NULL	},
+	{"forecolor",		ItemParse_forecolor,		NULL	},
+	{"group",			ItemParse_group,			NULL	},
+	{"hideCvar",		ItemParse_hideCvar,			NULL	},
+	{"horizontalscroll", ItemParse_horizontalscroll, NULL	},
+	{"isCharacter",		ItemParse_isCharacter,		NULL	},
+	{"isSaber",			ItemParse_isSaber,			NULL	},
+	{"isSaber2",		ItemParse_isSaber2,			NULL	},
+	{"leaveFocus",		ItemParse_leaveFocus,		NULL	},
+	{"maxChars",		ItemParse_maxChars,			NULL	},
+	{"maxPaintChars",	ItemParse_maxPaintChars,	NULL	},
+	{"model_angle",		ItemParse_model_angle,		NULL	},
+	{"model_fovx",		ItemParse_model_fovx,		NULL	},
+	{"model_fovy",		ItemParse_model_fovy,		NULL	},
+	{"model_origin",	ItemParse_model_origin,		NULL	},
+	{"model_rotation",	ItemParse_model_rotation,	NULL	},
+	//rww - g2 begin
+	{"model_g2mins",	ItemParse_model_g2mins,		NULL	},
+	{"model_g2maxs",	ItemParse_model_g2maxs,		NULL	},
+	{"model_g2scale",	ItemParse_model_g2scale,	NULL	},
+	{"model_g2skin",	ItemParse_model_g2skin,		NULL	},
+	{"model_g2anim",	ItemParse_model_g2anim,		NULL	},
+	//rww - g2 end
+	{"mouseEnter",		ItemParse_mouseEnter,		NULL	},
+	{"mouseEnterText",	ItemParse_mouseEnterText,	NULL	},
+	{"mouseExit",		ItemParse_mouseExit,		NULL	},
+	{"mouseExitText",	ItemParse_mouseExitText,	NULL	},
+	{"name",			ItemParse_name,				NULL	},
+	{"notselectable",	ItemParse_notselectable,	NULL	},
+	{"onFocus",			ItemParse_onFocus,			NULL	},
+	{"outlinecolor",	ItemParse_outlinecolor,		NULL	},
+	{"ownerdraw",		ItemParse_ownerdraw,		NULL	},
+	{"ownerdrawFlag",	ItemParse_ownerdrawFlag,	NULL	},
+	{"rect",			ItemParse_rect,				NULL	},
+	{"rectcvar",		ItemParse_rectcvar,			NULL	},
+	{"showCvar",		ItemParse_showCvar,			NULL	},
+	{"special",			ItemParse_special,			NULL	},
+	{"style",			ItemParse_style,			NULL	},
+	{"text",			ItemParse_text,				NULL	},
+	{"textalign",		ItemParse_textalign,		NULL	},
+	{"textalignx",		ItemParse_textalignx,		NULL	},
+	{"textaligny",		ItemParse_textaligny,		NULL	},
+	{"textscale",		ItemParse_textscale,		NULL	},
+	{"textstyle",		ItemParse_textstyle,		NULL	},
+	{"text2",			ItemParse_text2,			NULL	},
+	{"text2alignx",		ItemParse_text2alignx,		NULL	},
+	{"text2aligny",		ItemParse_text2aligny,		NULL	},
+	{"type",			ItemParse_type,				NULL	},
+	{"visible",			ItemParse_visible,			NULL	},
+	{"wrapped",			ItemParse_wrapped,			NULL	},
+
+	// Text scroll specific
+	{"maxLineChars",	ItemParse_maxLineChars,		NULL	},
+	{"lineHeight",		ItemParse_lineHeight,		NULL	},
+	{"invertyesno",		ItemParse_invertyesno,		NULL	},
+	//JLF MPMOVED
+	{"scrollhidden",	ItemParse_scrollhidden,		NULL	},
+	{"xoffset		",	ItemParse_xoffset,			NULL	},
+	//JLF end
+
+
+
+	{0,					0,							0		}
+};
+
+keywordHash_t *itemParseKeywordHash[KEYWORDHASH_SIZE];
+
+/*
+===============
+Item_SetupKeywordHash
+===============
+*/
+void Item_SetupKeywordHash(void) {
+	int i;
+
+	memset(itemParseKeywordHash, 0, sizeof(itemParseKeywordHash));
+	for (i = 0; itemParseKeywords[i].keyword; i++) {
+		KeywordHash_Add(itemParseKeywordHash, &itemParseKeywords[i]);
+	}
+}
+
+/*
+===============
+Item_Parse
+===============
+*/
+qboolean Item_Parse(int handle, itemDef_t *item) {
+	pc_token_t token;
+	keywordHash_t *key;
+
+
+	if (!trap_PC_ReadToken(handle, &token))
+		return qfalse;
+	if (*token.string != '{') {
+		return qfalse;
+	}
+	while ( 1 ) {
+		if (!trap_PC_ReadToken(handle, &token)) {
+			PC_SourceError(handle, "end of file inside menu item\n");
+			return qfalse;
+		}
+
+		if (*token.string == '}') {
+			return qtrue;
+		}
+
+		key = KeywordHash_Find(itemParseKeywordHash, token.string);
+		if (!key) {
+			PC_SourceError(handle, "unknown menu item keyword %s", token.string);
+			continue;
+		}
+		if ( !key->func(item, handle) ) {
+			PC_SourceError(handle, "couldn't parse menu item keyword %s", token.string);
+			return qfalse;
+		}
+	}
+	return qfalse; 	// bk001205 - LCC missing return value
+}
+
+static void Item_TextScroll_BuildLines ( itemDef_t* item )
+{
+	char text[2048];
+
+#if 1
+
+	// new asian-aware line breaker...  (pasted from elsewhere late @ night, hence aliasing-vars ;-)
+	//
+	textScrollDef_t* scrollPtr = (textScrollDef_t*) item->typeData;
+	const char *psText = item->text;	// for copy/paste ease
+	int iBoxWidth = item->window.rect.w - SCROLLBAR_SIZE - 10;
+
+	// this could probably be simplified now, but it was converted from something else I didn't originally write, 
+	//	and it works anyway so wtf...
+	//
+	const char *psCurrentTextReadPos;
+	const char *psReadPosAtLineStart;	
+	const char *psBestLineBreakSrcPos;
+	const char *psLastGood_s;	// needed if we get a full screen of chars with no punctuation or space (see usage notes)
+	qboolean bIsTrailingPunctuation;
+	unsigned int uiLetter;
+
+	if (*psText == '@')	// string reference
+	{
+		trap_SP_GetStringTextString( &psText[1], text, sizeof(text));
+		psText = text;
+	}
+
+	psCurrentTextReadPos = psText;
+	psReadPosAtLineStart = psCurrentTextReadPos;
+	psBestLineBreakSrcPos = psCurrentTextReadPos;
+
+	scrollPtr->iLineCount = 0;
+	memset((char*)scrollPtr->pLines,0,sizeof(scrollPtr->pLines));
+
+	while (*psCurrentTextReadPos && (scrollPtr->iLineCount < MAX_TEXTSCROLL_LINES) )
+	{
+		char sLineForDisplay[2048];	// ott
+
+		// construct a line...
+		//
+		psCurrentTextReadPos = psReadPosAtLineStart;
+		sLineForDisplay[0] = '\0';
+		while ( *psCurrentTextReadPos )
+		{
+			int iAdvanceCount;
+			psLastGood_s = psCurrentTextReadPos;
+
+			// read letter...
+			//
+			uiLetter = trap_AnyLanguage_ReadCharFromString(psCurrentTextReadPos, &iAdvanceCount, &bIsTrailingPunctuation);
+			psCurrentTextReadPos += iAdvanceCount;
+
+			// concat onto string so far...
+			//
+			if (uiLetter == 32 && sLineForDisplay[0] == '\0')
+			{
+				psReadPosAtLineStart++;
+				continue;	// unless it's a space at the start of a line, in which case ignore it.
+			}
+
+			if (uiLetter > 255)
+			{
+				Q_strcat(sLineForDisplay, sizeof(sLineForDisplay),va("%c%c",uiLetter >> 8, uiLetter & 0xFF));
+			}
+			else
+			{
+				Q_strcat(sLineForDisplay, sizeof(sLineForDisplay),va("%c",uiLetter & 0xFF));
+			}
+
+			if (uiLetter == '\n')
+			{
+				// explicit new line...
+				//
+				sLineForDisplay[ strlen(sLineForDisplay)-1 ] = '\0';	// kill the CR
+				psReadPosAtLineStart = psCurrentTextReadPos;
+				psBestLineBreakSrcPos = psCurrentTextReadPos;
+
+				// hack it to fit in with this code...
+				//
+				scrollPtr->pLines[ scrollPtr->iLineCount ] = String_Alloc ( sLineForDisplay );
+				break;	// print this line
+			}
+			else 
+			if ( DC->textWidth( sLineForDisplay, item->textscale, item->iMenuFont ) >= iBoxWidth )
+			{					
+				// reached screen edge, so cap off string at bytepos after last good position...
+				//
+				if (uiLetter > 255 && bIsTrailingPunctuation && !trap_Language_UsesSpaces())
+				{
+					// Special case, don't consider line breaking if you're on an asian punctuation char of
+					//	a language that doesn't use spaces...
+					//
+					uiLetter = uiLetter;	// breakpoint line only
+				}
+				else
+				{
+					if (psBestLineBreakSrcPos == psReadPosAtLineStart)
+					{
+						//  aarrrggh!!!!!   we'll only get here is someone has fed in a (probably) garbage string,
+						//		since it doesn't have a single space or punctuation mark right the way across one line
+						//		of the screen.  So far, this has only happened in testing when I hardwired a taiwanese 
+						//		string into this function while the game was running in english (which should NEVER happen 
+						//		normally).  On the other hand I suppose it's entirely possible that some taiwanese string 
+						//		might have no punctuation at all, so...
+						//
+						psBestLineBreakSrcPos = psLastGood_s;	// force a break after last good letter
+					}
+
+					sLineForDisplay[ psBestLineBreakSrcPos - psReadPosAtLineStart ] = '\0';
+					psReadPosAtLineStart = psCurrentTextReadPos = psBestLineBreakSrcPos;
+
+					// hack it to fit in with this code...
+					//
+					scrollPtr->pLines[ scrollPtr->iLineCount ] = String_Alloc( sLineForDisplay );
+					break;	// print this line
+				}
+			}
+
+			// record last-good linebreak pos...  (ie if we've just concat'd a punctuation point (western or asian) or space)
+			//
+			if (bIsTrailingPunctuation || uiLetter == ' ' || (uiLetter > 255 && !trap_Language_UsesSpaces()))
+			{
+				psBestLineBreakSrcPos = psCurrentTextReadPos;
+			}
+		}
+
+		/// arrgghh, this is gettng horrible now...
+		//
+		if (scrollPtr->pLines[ scrollPtr->iLineCount ] == NULL && strlen(sLineForDisplay))
+		{
+			// then this is the last line and we've just run out of text, no CR, no overflow etc...
+			//
+			scrollPtr->pLines[ scrollPtr->iLineCount ] = String_Alloc( sLineForDisplay );
+		}
+			
+		scrollPtr->iLineCount++;
+	}
+	
+#else
+	// old version...
+	//
+	int				 width;
+	char*			 lineStart;
+	char*			 lineEnd;
+	float			 w;
+	float			 cw;
+
+	textScrollDef_t* scrollPtr = (textScrollDef_t*) item->typeData;
+
+	scrollPtr->iLineCount = 0;
+	width = scrollPtr->maxLineChars;
+	lineStart = (char*)item->text;
+	lineEnd   = lineStart;
+	w		  = 0;
+
+	// Keep going as long as there are more lines
+	while ( scrollPtr->iLineCount < MAX_TEXTSCROLL_LINES )
+	{
+		// End of the road
+		if ( *lineEnd == '\0')
+		{
+			if ( lineStart < lineEnd )
+			{
+				scrollPtr->pLines[ scrollPtr->iLineCount++ ] = lineStart;
+			}
+
+			break;
+		}
+
+		// Force a line end if its a '\n'
+		else if ( *lineEnd == '\n' )
+		{
+			*lineEnd = '\0';
+			scrollPtr->pLines[ scrollPtr->iLineCount++ ] = lineStart;
+			lineStart = lineEnd + 1;
+			lineEnd   = lineStart;
+			w = 0;
+			continue;
+		}
+
+		// Get the current character width 
+		cw = DC->textWidth ( va("%c", *lineEnd), item->textscale, item->iMenuFont );
+
+		// Past the end of the boundary?
+		if ( w + cw > (item->window.rect.w - SCROLLBAR_SIZE - 10) )
+		{
+			// Past the end so backtrack to the word boundary
+			while ( *lineEnd != ' ' && *lineEnd != '\t' && lineEnd > lineStart )
+			{
+				lineEnd--;
+			}					
+
+			*lineEnd = '\0';
+			scrollPtr->pLines[ scrollPtr->iLineCount++ ] = lineStart;
+
+			// Skip any whitespaces
+			lineEnd++;
+			while ( (*lineEnd == ' ' || *lineEnd == '\t') && *lineEnd )
+			{
+				lineEnd++;
+			}
+
+			lineStart = lineEnd;
+			w = 0;
+		}
+		else
+		{
+			w += cw;
+			lineEnd++;
+		}
+	}
+#endif
+}
+
+// Item_InitControls
+// init's special control types
+void Item_InitControls(itemDef_t *item) 
+{
+	if (item == NULL) 
+	{
+		return;
+	}
+
+	switch ( item->type )
+	{
+		case ITEM_TYPE_LISTBOX:
+		{
+			listBoxDef_t *listPtr = (listBoxDef_t*)item->typeData;
+			item->cursorPos = 0;
+			if (listPtr) 
+			{
+				listPtr->cursorPos = 0;
+				listPtr->startPos = 0;
+				listPtr->endPos = 0;
+				listPtr->cursorPos = 0;
+			}
+
+			break;
+		}
+	}
+}
+
+/*
+===============
+Menu Keyword Parse functions
+===============
+*/
+
+qboolean MenuParse_font( itemDef_t *item, int handle ) {
+	menuDef_t *menu = (menuDef_t*)item;
+	if (!PC_String_Parse(handle, &menu->font)) {
+		return qfalse;
+	}
+	if (!DC->Assets.fontRegistered) {
+		//DC->registerFont(menu->font, 48, &DC->Assets.textFont);
+		DC->Assets.qhMediumFont = DC->RegisterFont(menu->font);
+		DC->Assets.fontRegistered = qtrue;
+	}
+	return qtrue;
+}
+
+qboolean MenuParse_name( itemDef_t *item, int handle ) {
+	menuDef_t *menu = (menuDef_t*)item;
+	if (!PC_String_Parse(handle, &menu->window.name)) {
+		return qfalse;
+	}
+	if (Q_stricmp(menu->window.name, "main") == 0) {
+		// default main as having focus
+		//menu->window.flags |= WINDOW_HASFOCUS;
+	}
+	return qtrue;
+}
+
+qboolean MenuParse_fullscreen( itemDef_t *item, int handle ) {
+	menuDef_t *menu = (menuDef_t*)item;
+	if (!PC_Int_Parse(handle, (int*) &menu->fullScreen)) { // bk001206 - cast qboolean
+		return qfalse;
+	}
+	return qtrue;
+}
+
+qboolean MenuParse_rect( itemDef_t *item, int handle ) {
+	menuDef_t *menu = (menuDef_t*)item;
+	if (!PC_Rect_Parse(handle, &menu->window.rect)) {
+		return qfalse;
+	}
+	return qtrue;
+}
+
+/*
+=================
+MenuParse_style
+=================
+*/
+qboolean MenuParse_style( itemDef_t *item, int handle) 
+{
+	menuDef_t *menu = (menuDef_t*)item;
+
+	if (!PC_Int_Parse(handle, &menu->window.style))
+	{
+		Com_Printf(S_COLOR_YELLOW "Unknown menu style value");
+		return qfalse;
+	}
+
+	return qtrue;
+}
+
+qboolean MenuParse_visible( itemDef_t *item, int handle ) {
+	int i;
+	menuDef_t *menu = (menuDef_t*)item;
+
+	if (!PC_Int_Parse(handle, &i)) {
+		return qfalse;
+	}
+	if (i) {
+		menu->window.flags |= WINDOW_VISIBLE;
+	}
+	return qtrue;
+}
+
+qboolean MenuParse_onOpen( itemDef_t *item, int handle ) {
+	menuDef_t *menu = (menuDef_t*)item;
+	if (!PC_Script_Parse(handle, &menu->onOpen)) {
+		return qfalse;
+	}
+	return qtrue;
+}
+
+qboolean MenuParse_onClose( itemDef_t *item, int handle ) {
+	menuDef_t *menu = (menuDef_t*)item;
+	if (!PC_Script_Parse(handle, &menu->onClose)) {
+		return qfalse;
+	}
+	return qtrue;
+}
+
+//JLFACCEPT MPMOVED
+/*
+=================
+MenuParse_onAccept
+=================
+*/
+qboolean MenuParse_onAccept( itemDef_t *item, int handle ) 
+{
+	menuDef_t *menu = (menuDef_t*)item;
+
+	if (!PC_Script_Parse(handle, &menu->onAccept)) 
+	{
+		return qfalse;
+	}
+	return qtrue;
+}
+
+qboolean MenuParse_onESC( itemDef_t *item, int handle ) {
+	menuDef_t *menu = (menuDef_t*)item;
+	if (!PC_Script_Parse(handle, &menu->onESC)) {
+		return qfalse;
+	}
+	return qtrue;
+}
+
+
+
+qboolean MenuParse_border( itemDef_t *item, int handle ) {
+	menuDef_t *menu = (menuDef_t*)item;
+	if (!PC_Int_Parse(handle, &menu->window.border)) {
+		return qfalse;
+	}
+	return qtrue;
+}
+
+qboolean MenuParse_borderSize( itemDef_t *item, int handle ) {
+	menuDef_t *menu = (menuDef_t*)item;
+	if (!PC_Float_Parse(handle, &menu->window.borderSize)) {
+		return qfalse;
+	}
+	return qtrue;
+}
+
+qboolean MenuParse_backcolor( itemDef_t *item, int handle ) {
+	int i;
+	float f;
+	menuDef_t *menu = (menuDef_t*)item;
+
+	for (i = 0; i < 4; i++) {
+		if (!PC_Float_Parse(handle, &f)) {
+			return qfalse;
+		}
+		menu->window.backColor[i]  = f;
+	}
+	return qtrue;
+}
+
+/*
+=================
+MenuParse_descAlignment
+=================
+*/
+qboolean MenuParse_descAlignment( itemDef_t *item, int handle ) 
+{
+	menuDef_t *menu = (menuDef_t*)item;
+
+	if (!PC_Int_Parse(handle, &menu->descAlignment)) 
+	{
+		Com_Printf(S_COLOR_YELLOW "Unknown desc alignment value");
+		return qfalse;
+	}
+
+	return qtrue;
+}
+
+/*
+=================
+MenuParse_descX
+=================
+*/
+qboolean MenuParse_descX( itemDef_t *item, int handle ) 
+{
+	menuDef_t *menu = (menuDef_t*)item;
+
+	if (!PC_Int_Parse(handle, &menu->descX))
+	{
+		return qfalse;
+	}
+	return qtrue;
+}
+
+/*
+=================
+MenuParse_descY
+=================
+*/
+qboolean MenuParse_descY( itemDef_t *item, int handle ) 
+{
+	menuDef_t *menu = (menuDef_t*)item;
+
+	if (!PC_Int_Parse(handle, &menu->descY))
+	{
+		return qfalse;
+	}
+	return qtrue;
+}
+
+/*
+=================
+MenuParse_descScale
+=================
+*/
+qboolean MenuParse_descScale( itemDef_t *item, int handle) 
+{
+	menuDef_t *menu = (menuDef_t*)item;
+
+	if (!PC_Float_Parse(handle, &menu->descScale)) 
+	{
+		return qfalse;
+	}
+	return qtrue;
+}
+
+/*
+=================
+MenuParse_descColor
+=================
+*/
+qboolean MenuParse_descColor( itemDef_t *item, int handle) 
+{
+	int i;
+	float f;
+	menuDef_t *menu = (menuDef_t*)item;
+
+	for (i = 0; i < 4; i++) 
+	{
+		if (!PC_Float_Parse(handle, &f)) 
+		{
+			return qfalse;
+		}
+		menu->descColor[i]  = f;
+	}
+	return qtrue;
+}
+
+qboolean MenuParse_forecolor( itemDef_t *item, int handle ) {
+	int i;
+	float f;
+	menuDef_t *menu = (menuDef_t*)item;
+
+	for (i = 0; i < 4; i++) {
+		if (!PC_Float_Parse(handle, &f)) {
+			return qfalse;
+		}
+		if (f < 0)
+		{	//special case for player color
+			menu->window.flags |= WINDOW_PLAYERCOLOR;
+			return qtrue;
+		}
+		menu->window.foreColor[i]  = f;
+		menu->window.flags |= WINDOW_FORECOLORSET;
+	}
+	return qtrue;
+}
+
+qboolean MenuParse_bordercolor( itemDef_t *item, int handle ) {
+	int i;
+	float f;
+	menuDef_t *menu = (menuDef_t*)item;
+
+	for (i = 0; i < 4; i++) {
+		if (!PC_Float_Parse(handle, &f)) {
+			return qfalse;
+		}
+		menu->window.borderColor[i]  = f;
+	}
+	return qtrue;
+}
+
+qboolean MenuParse_focuscolor( itemDef_t *item, int handle ) {
+	int i;
+	float f;
+	menuDef_t *menu = (menuDef_t*)item;
+
+	for (i = 0; i < 4; i++) {
+		if (!PC_Float_Parse(handle, &f)) {
+			return qfalse;
+		}
+		menu->focusColor[i]  = f;
+	}
+	return qtrue;
+}
+
+qboolean MenuParse_disablecolor( itemDef_t *item, int handle ) {
+	int i;
+	float f;
+	menuDef_t *menu = (menuDef_t*)item;
+	for (i = 0; i < 4; i++) {
+		if (!PC_Float_Parse(handle, &f)) {
+			return qfalse;
+		}
+		menu->disableColor[i]  = f;
+	}
+	return qtrue;
+}
+
+
+qboolean MenuParse_outlinecolor( itemDef_t *item, int handle ) {
+	menuDef_t *menu = (menuDef_t*)item;
+	if (!PC_Color_Parse(handle, &menu->window.outlineColor)){
+		return qfalse;
+	}
+	return qtrue;
+}
+
+qboolean MenuParse_background( itemDef_t *item, int handle ) {
+	pc_token_t token;
+	menuDef_t *menu = (menuDef_t*)item;
+
+	if (!trap_PC_ReadToken(handle, &token)) {
+		return qfalse;
+	}
+	menu->window.background = DC->registerShaderNoMip(token.string);
+	return qtrue;
+}
+
+qboolean MenuParse_cinematic( itemDef_t *item, int handle ) {
+	menuDef_t *menu = (menuDef_t*)item;
+
+	if (!PC_String_Parse(handle, &menu->window.cinematicName)) {
+		return qfalse;
+	}
+	return qtrue;
+}
+
+qboolean MenuParse_ownerdrawFlag( itemDef_t *item, int handle ) {
+	int i;
+	menuDef_t *menu = (menuDef_t*)item;
+
+	if (!PC_Int_Parse(handle, &i)) {
+		return qfalse;
+	}
+	menu->window.ownerDrawFlags |= i;
+	return qtrue;
+}
+
+qboolean MenuParse_ownerdraw( itemDef_t *item, int handle ) {
+	menuDef_t *menu = (menuDef_t*)item;
+
+	if (!PC_Int_Parse(handle, &menu->window.ownerDraw)) {
+		return qfalse;
+	}
+	return qtrue;
+}
+
+
+// decoration
+qboolean MenuParse_popup( itemDef_t *item, int handle ) {
+	menuDef_t *menu = (menuDef_t*)item;
+	menu->window.flags |= WINDOW_POPUP;
+	return qtrue;
+}
+
+
+qboolean MenuParse_outOfBounds( itemDef_t *item, int handle ) {
+	menuDef_t *menu = (menuDef_t*)item;
+
+	menu->window.flags |= WINDOW_OOB_CLICK;
+	return qtrue;
+}
+
+qboolean MenuParse_soundLoop( itemDef_t *item, int handle ) {
+	menuDef_t *menu = (menuDef_t*)item;
+
+	if (!PC_String_Parse(handle, &menu->soundName)) {
+		return qfalse;
+	}
+	return qtrue;
+}
+
+qboolean MenuParse_fadeClamp( itemDef_t *item, int handle ) {
+	menuDef_t *menu = (menuDef_t*)item;
+
+	if (!PC_Float_Parse(handle, &menu->fadeClamp)) {
+		return qfalse;
+	}
+	return qtrue;
+}
+
+qboolean MenuParse_fadeAmount( itemDef_t *item, int handle ) {
+	menuDef_t *menu = (menuDef_t*)item;
+
+	if (!PC_Float_Parse(handle, &menu->fadeAmount)) {
+		return qfalse;
+	}
+	return qtrue;
+}
+
+
+qboolean MenuParse_fadeCycle( itemDef_t *item, int handle ) {
+	menuDef_t *menu = (menuDef_t*)item;
+
+	if (!PC_Int_Parse(handle, &menu->fadeCycle)) {
+		return qfalse;
+	}
+	return qtrue;
+}
+
+
+qboolean MenuParse_itemDef( itemDef_t *item, int handle ) {
+	menuDef_t *menu = (menuDef_t*)item;
+	if (menu->itemCount < MAX_MENUITEMS) {
+		menu->items[menu->itemCount] = (itemDef_t *) UI_Alloc(sizeof(itemDef_t));
+		Item_Init(menu->items[menu->itemCount]);
+		if (!Item_Parse(handle, menu->items[menu->itemCount])) {
+			return qfalse;
+		}
+		Item_InitControls(menu->items[menu->itemCount]);
+		menu->items[menu->itemCount++]->parent = menu;
+	}
+	return qtrue;
+}
+/*
+=================
+MenuParse_focuscolor
+=================
+*/
+qboolean MenuParse_appearanceIncrement( itemDef_t *item, int handle ) 
+{
+	menuDef_t *menu = (menuDef_t*)item;
+
+	if (!PC_Float_Parse(handle, &menu->appearanceIncrement))
+	{
+		return qfalse;
+	}
+	return qtrue;
+}
+
+keywordHash_t menuParseKeywords[] = {
+	{"appearanceIncrement",	MenuParse_appearanceIncrement,	NULL	},
+	{"backcolor",			MenuParse_backcolor,	NULL	},
+	{"background",			MenuParse_background,	NULL	},
+	{"border",				MenuParse_border,		NULL	},
+	{"bordercolor",			MenuParse_bordercolor,	NULL	},
+	{"borderSize",			MenuParse_borderSize,	NULL	},
+	{"cinematic",			MenuParse_cinematic,	NULL	},
+	{"descAlignment",		MenuParse_descAlignment,NULL	},
+	{"desccolor",			MenuParse_descColor,	NULL	},
+	{"descX",				MenuParse_descX,		NULL	},
+	{"descY",				MenuParse_descY,		NULL	},
+	{"descScale",			MenuParse_descScale,	NULL	},
+	{"disablecolor",		MenuParse_disablecolor, NULL	},
+	{"fadeAmount",			MenuParse_fadeAmount,	NULL	},
+	{"fadeClamp",			MenuParse_fadeClamp,	NULL	},
+	{"fadeCycle",			MenuParse_fadeCycle,	NULL	},
+	{"focuscolor",			MenuParse_focuscolor,	NULL	},
+	{"font",				MenuParse_font,			NULL	},
+	{"forecolor",			MenuParse_forecolor,	NULL	},
+	{"fullscreen",			MenuParse_fullscreen,	NULL	},
+	{"itemDef",				MenuParse_itemDef,		NULL	},
+	{"name",				MenuParse_name,			NULL	},
+	{"onClose",				MenuParse_onClose,		NULL	},
+	//JLFACCEPT MPMOVED
+	{"onAccept",			MenuParse_onAccept,		NULL    },
+
+	{"onESC",				MenuParse_onESC,		NULL	},
+	{"outOfBoundsClick",	MenuParse_outOfBounds,	NULL	},
+	{"onOpen",				MenuParse_onOpen,		NULL	},
+	{"outlinecolor",		MenuParse_outlinecolor, NULL	},
+	{"ownerdraw",			MenuParse_ownerdraw,	NULL	},
+	{"ownerdrawFlag",		MenuParse_ownerdrawFlag,NULL	},
+	{"popup",				MenuParse_popup,		NULL	},
+	{"rect",				MenuParse_rect,			NULL	},
+	{"soundLoop",			MenuParse_soundLoop,	NULL	},
+	{"style",				MenuParse_style,		NULL	},
+	{"visible",				MenuParse_visible,		NULL	},
+	{0,						0,						0		}
+};
+
+keywordHash_t *menuParseKeywordHash[KEYWORDHASH_SIZE];
+
+/*
+===============
+Menu_SetupKeywordHash
+===============
+*/
+void Menu_SetupKeywordHash(void) {
+	int i;
+
+	memset(menuParseKeywordHash, 0, sizeof(menuParseKeywordHash));
+	for (i = 0; menuParseKeywords[i].keyword; i++) {
+		KeywordHash_Add(menuParseKeywordHash, &menuParseKeywords[i]);
+	}
+}
+
+/*
+===============
+Menu_Parse
+===============
+*/
+qboolean Menu_Parse(int handle, menuDef_t *menu) {
+	pc_token_t token;
+	keywordHash_t *key;
+
+	if (!trap_PC_ReadToken(handle, &token))
+		return qfalse;
+	if (*token.string != '{') {
+		return qfalse;
+	}
+    
+	while ( 1 ) {
+		if (!trap_PC_ReadToken(handle, &token)) {
+			PC_SourceError(handle, "end of file inside menu\n");
+			return qfalse;
+		}
+
+		if (*token.string == '}') {
+			return qtrue;
+		}
+
+		key = KeywordHash_Find(menuParseKeywordHash, token.string);
+		if (!key) {
+			PC_SourceError(handle, "unknown menu keyword %s", token.string);
+			continue;
+		}
+		if ( !key->func((itemDef_t*)menu, handle) ) {
+			PC_SourceError(handle, "couldn't parse menu keyword %s", token.string);
+			return qfalse;
+		}
+	}
+	return qfalse; 	// bk001205 - LCC missing return value
+}
+
+/*
+===============
+Menu_New
+===============
+*/
+void Menu_New(int handle) {
+	menuDef_t *menu = &Menus[menuCount];
+
+	if (menuCount < MAX_MENUS) {
+		Menu_Init(menu);
+		if (Menu_Parse(handle, menu)) {
+			Menu_PostParse(menu);
+			menuCount++;
+		}
+	}
+}
+
+int Menu_Count() {
+	return menuCount;
+}
+
+void Menu_PaintAll() {
+	int i;
+	if (captureFunc) {
+		captureFunc(captureData);
+	}
+
+	for (i = 0; i < Menu_Count(); i++) {
+		Menu_Paint(&Menus[i], qfalse);
+	}
+
+	if (debugMode) {
+		vec4_t v = {1, 1, 1, 1};
+		DC->drawText(5, 25, .75, v, va("fps: %f", DC->FPS), 0, 0, 0, 0);
+		DC->drawText(5, 45, .75, v, va("x: %d  y:%d", DC->cursorx,DC->cursory), 0, 0, 0, 0);
+	}
+}
+
+void Menu_Reset() {
+	menuCount = 0;
+}
+
+displayContextDef_t *Display_GetContext() {
+	return DC;
+}
+ 
+void *Display_CaptureItem(int x, int y) {
+	int i;
+
+	for (i = 0; i < menuCount; i++) {
+		// turn off focus each item
+		// menu->items[i].window.flags &= ~WINDOW_HASFOCUS;
+		if (Rect_ContainsPoint(&Menus[i].window.rect, x, y)) {
+			return &Menus[i];
+		}
+	}
+	return NULL;
+}
+
+
+// FIXME: 
+qboolean Display_MouseMove(void *p, int x, int y) {
+
+//JLFMOUSE  AGAIN I THINK THIS SHOULD BE MOOT
+#ifdef _XBOX
+	return qtrue;
+#endif
+	//END JLF
+	int i;
+	menuDef_t *menu = (menuDef_t *) p;
+
+	if (menu == NULL) {
+    menu = Menu_GetFocused();
+		if (menu) {
+			if (menu->window.flags & WINDOW_POPUP) {
+				Menu_HandleMouseMove(menu, x, y);
+				return qtrue;
+			}
+		}
+		for (i = 0; i < menuCount; i++) {
+			Menu_HandleMouseMove(&Menus[i], x, y);
+		}
+	} else {
+		menu->window.rect.x += x;
+		menu->window.rect.y += y;
+		Menu_UpdatePosition(menu);
+	}
+ 	return qtrue;
+
+}
+
+int Display_CursorType(int x, int y) {
+	int i;
+	for (i = 0; i < menuCount; i++) {
+		rectDef_t r2;
+		r2.x = Menus[i].window.rect.x - 3;
+		r2.y = Menus[i].window.rect.y - 3;
+		r2.w = r2.h = 7;
+		if (Rect_ContainsPoint(&r2, x, y)) {
+			return CURSOR_SIZER;
+		}
+	}
+	return CURSOR_ARROW;
+}
+
+
+void Display_HandleKey(int key, qboolean down, int x, int y) {
+	menuDef_t *menu = (menuDef_t *) Display_CaptureItem(x, y);
+	if (menu == NULL) {  
+		menu = Menu_GetFocused();
+	}
+	if (menu) {
+		Menu_HandleKey(menu, key, down );
+	}
+}
+
+static void Window_CacheContents(windowDef_t *window) {
+	if (window) {
+		if (window->cinematicName) {
+			int cin = DC->playCinematic(window->cinematicName, 0, 0, 0, 0);
+			DC->stopCinematic(cin);
+		}
+	}
+}
+
+
+static void Item_CacheContents(itemDef_t *item) {
+	if (item) {
+		Window_CacheContents(&item->window);
+	}
+
+}
+
+static void Menu_CacheContents(menuDef_t *menu) {
+	if (menu) {
+		int i;
+		Window_CacheContents(&menu->window);
+		for (i = 0; i < menu->itemCount; i++) {
+			Item_CacheContents(menu->items[i]);
+		}
+
+		if (menu->soundName && *menu->soundName) {
+			DC->registerSound(menu->soundName);
+		}
+	}
+
+}
+
+void Display_CacheAll() {
+	int i;
+	for (i = 0; i < menuCount; i++) {
+		Menu_CacheContents(&Menus[i]);
+	}
+}
+
+
+static qboolean Menu_OverActiveItem(menuDef_t *menu, float x, float y) {
+ 	if (menu && menu->window.flags & (WINDOW_VISIBLE | WINDOW_FORCED)) {
+//JLFMOUSE
+#ifdef _XBOX
+		return qtrue;
+#endif
+		if (Rect_ContainsPoint(&menu->window.rect, x, y)) {
+			int i;
+			for (i = 0; i < menu->itemCount; i++) {
+				// turn off focus each item
+				// menu->items[i].window.flags &= ~WINDOW_HASFOCUS;
+
+				if (!(menu->items[i]->window.flags & (WINDOW_VISIBLE | WINDOW_FORCED))) {
+					continue;
+				}
+
+				if (menu->items[i]->window.flags & WINDOW_DECORATION) {
+					continue;
+				}
+
+				if (Rect_ContainsPoint(&menu->items[i]->window.rect, x, y)) {
+					itemDef_t *overItem = menu->items[i];
+					if (overItem->type == ITEM_TYPE_TEXT && overItem->text) {
+						if (Rect_ContainsPoint(&overItem->window.rect, x, y)) {
+							return qtrue;
+						} else {
+							continue;
+						}
+					} else {
+						return qtrue;
+					}
+				}
+			}
+
+		}
+	}
+	return qfalse;
+}
+
+//JLF DEMOCODE MPMOVED
+#ifdef _XBOX
+
+void G_DemoStart()
+{
+//	demoDelay = 0;
+//	lastChange = 0;
+	g_runningDemo = true;
+
+//	g_demoLastChange = 0;
+
+
+	extern void Menus_CloseAll();
+	
+	Menus_CloseAll();
+
+	trap_Key_SetCatcher( trap_Key_GetCatcher() & ~KEYCATCH_UI );
+#ifndef CGAME
+	trap_Key_ClearStates();
+#endif
+	trap_Cvar_Set( "cl_paused", "0" );
+
+//	g_demoStartFade = 0;
+//	g_demoStartTransition = 0;
+}
+
+
+
+const char *attractMovieNames[] = {
+	"jk1",
+	"jk2",
+	"jk3",
+	"jk4",
+	"jk5",
+};
+
+extern int trap_Milliseconds( void );
+
+const int	numAttractMovies = sizeof(attractMovieNames) / sizeof(attractMovieNames[0]);
+static int	curAttractMovie = 0;
+
+void G_DemoFrame()
+{
+	bool keypressed = false;
+	if (g_runningDemo)
+	{
+		while (!keypressed)
+			keypressed = CIN_PlayAllFrames( "atvi.bik", 0, 0, 640, 480, 0, true );
+		G_DemoEnd();
+
+
+
+	}
+	else 
+	{
+		menuDef_t* curMenu = Menu_GetFocused();
+		
+		if (curMenu && curMenu->window.name &&
+			(!Q_stricmp(curMenu->window.name , "mainMenu") ||
+			!Q_stricmp(curMenu->window.name, "splashMenu")))
+		{
+			if (!g_demoLastKeypress)
+				g_demoLastKeypress = trap_Milliseconds();
+			else if (g_demoLastKeypress + DEMO_TIME_MAX < trap_Milliseconds())
+				G_DemoStart();
+		}
+		else
+		{
+			g_demoLastKeypress = trap_Milliseconds();
+		}
+	}
+}
+
+void G_DemoKeypress()
+{
+	g_demoLastKeypress = trap_Milliseconds();
+		
+//JLF moved
+//	g_demoLastKeypress = Sys_Milliseconds();
+	
+}
+
+
+void G_DemoEnd()
+{
+	
+	if (!g_runningDemo)
+		return;
+	//CIN_StopCinematic(1);
+	CIN_CloseAllVideos();
+//	Key_SetCatcher( KEYCATCH_UI );
+	Menus_CloseAll();
+	g_ReturnToSplash = true;
+	g_runningDemo = qfalse;
+	G_DemoKeypress();
+	trap_Key_SetCatcher( trap_Key_GetCatcher() & KEYCATCH_UI );
+#ifndef CGAME
+	trap_Key_ClearStates();
+#endif
+	trap_Cvar_Set( "cl_paused", "0" );
+
+//	g_demoStartFade = 0;
+//	g_demoStartTransition = 0;
+//	g_demoLastKeypress = 0;
+}
+
+void PlayDemo()
+{
+//	bool keypressed = false;
+	G_DemoStart();
+	CIN_PlayAllFrames( attractMovieNames[curAttractMovie], 0, 0, 640, 480, 0, true );
+	curAttractMovie = (curAttractMovie + 1) % numAttractMovies;
+//	while (!keypressed)
+//		keypressed = CIN_PlayAllFrames( "atvi.bik", 0, 0, 640, 480, 0, true );
+	G_DemoEnd();
+}
+
+void UpdateDemoTimer()
+{
+	g_demoLastKeypress = trap_Milliseconds();
+}
+
+bool TestDemoTimer()
+{
+//JLF TEMP DEBUG
+	return false;
+
+
+	menuDef_t* curMenu = Menu_GetFocused();
+	if (curMenu && curMenu->window.name &&
+			(!Q_stricmp(curMenu->window.name , "mainMenu") ||
+			!Q_stricmp(curMenu->window.name, "splashMenu")))
+	{	
+		if (!g_demoLastKeypress)
+			g_demoLastKeypress = trap_Milliseconds();
+		else if (g_demoLastKeypress + DEMO_TIME_MAX < trap_Milliseconds())
+			return true;
+	}
+	return false;
+}
+
+//END DEMOCODE
+
+
+#endif // _XBOX
+
+
+
+
+
+
+
+
+
+
+
+#include "../namespace_end.h"
diff --git a/codemp/ui/ui_shared.h b/codemp/ui/ui_shared.h
new file mode 100644
index 0000000..e631e45
--- /dev/null
+++ b/codemp/ui/ui_shared.h
@@ -0,0 +1,622 @@
+#ifndef __UI_SHARED_H
+#define __UI_SHARED_H
+
+
+#include "../game/q_shared.h"
+#include "../cgame/tr_types.h"
+#include "keycodes.h"
+
+#include "../../ui/menudef.h"
+
+#define MAX_MENUNAME				32
+#define MAX_ITEMTEXT				64
+#define MAX_ITEMACTION				64
+#define MAX_MENUDEFFILE				4096
+#define MAX_MENUFILE				32768
+#define MAX_MENUS					64
+#define MAX_MENUITEMS				256
+#define MAX_COLOR_RANGES			10
+#define MAX_OPEN_MENUS				16
+#define	MAX_TEXTSCROLL_LINES		256
+
+#define WINDOW_MOUSEOVER			0x00000001	// mouse is over it, non exclusive
+#define WINDOW_HASFOCUS				0x00000002	// has cursor focus, exclusive
+#define WINDOW_VISIBLE				0x00000004	// is visible
+#define WINDOW_INACTIVE				0x00000008	// is visible but grey ( non-active )
+#define WINDOW_DECORATION			0x00000010	// for decoration only, no mouse, keyboard, etc.. 
+#define WINDOW_FADINGOUT			0x00000020	// fading out, non-active
+#define WINDOW_FADINGIN				0x00000040	// fading in
+#define WINDOW_MOUSEOVERTEXT		0x00000080	// mouse is over it, non exclusive
+#define WINDOW_INTRANSITION			0x00000100	// window is in transition
+#define WINDOW_FORECOLORSET			0x00000200	// forecolor was explicitly set ( used to color alpha images or not )
+#define WINDOW_HORIZONTAL			0x00000400	// for list boxes and sliders, vertical is default this is set of horizontal
+#define WINDOW_LB_LEFTARROW			0x00000800	// mouse is over left/up arrow
+#define WINDOW_LB_RIGHTARROW		0x00001000	// mouse is over right/down arrow
+#define WINDOW_LB_THUMB				0x00002000	// mouse is over thumb
+#define WINDOW_LB_PGUP				0x00004000	// mouse is over page up
+#define WINDOW_LB_PGDN				0x00008000	// mouse is over page down
+#define WINDOW_ORBITING				0x00010000	// item is in orbit
+#define WINDOW_OOB_CLICK			0x00020000	// close on out of bounds click
+#define WINDOW_WRAPPED				0x00040000	// manually wrap text
+#define WINDOW_AUTOWRAPPED			0x00080000	// auto wrap text
+#define WINDOW_FORCED				0x00100000	// forced open
+#define WINDOW_POPUP				0x00200000	// popup
+#define WINDOW_BACKCOLORSET			0x00400000	// backcolor was explicitly set 
+#define WINDOW_TIMEDVISIBLE			0x00800000	// visibility timing ( NOT implemented )
+#define WINDOW_PLAYERCOLOR			0x01000000	// hack the forecolor to match ui_char_color_*
+
+//JLF
+#define WINDOW_INTRANSITIONMODEL	0x04000000	// delayed script waiting to run
+
+
+// CGAME cursor type bits
+#define CURSOR_NONE					0x00000001
+#define CURSOR_ARROW				0x00000002
+#define CURSOR_SIZER				0x00000004
+
+#ifdef _XBOX
+
+#ifdef CGAME
+#define STRING_POOL_SIZE 32*1024
+#else
+#define STRING_POOL_SIZE 128*1024
+#endif
+
+#else
+
+#ifdef CGAME
+#define STRING_POOL_SIZE 128*1024
+#else
+#define STRING_POOL_SIZE 384*1024
+#endif
+
+#endif
+
+#define MAX_STRING_HANDLES 4096
+#define MAX_SCRIPT_ARGS 12
+#define MAX_EDITFIELD 256
+
+#define ART_FX_BASE			"menu/art/fx_base"
+#define ART_FX_BLUE			"menu/art/fx_blue"
+#define ART_FX_CYAN			"menu/art/fx_cyan"
+#define ART_FX_GREEN		"menu/art/fx_grn"
+#define ART_FX_RED			"menu/art/fx_red"
+#define ART_FX_TEAL			"menu/art/fx_teal"
+#define ART_FX_WHITE		"menu/art/fx_white"
+#define ART_FX_YELLOW		"menu/art/fx_yel"
+#define ART_FX_ORANGE		"menu/art/fx_orange"
+#define ART_FX_PURPLE		"menu/art/fx_purple"
+
+#define ASSET_GRADIENTBAR			"ui/assets/gradientbar2.tga"
+#define ASSET_SCROLLBAR             "gfx/menus/scrollbar.tga"
+#define ASSET_SCROLLBAR_ARROWDOWN   "gfx/menus/scrollbar_arrow_dwn_a.tga"
+#define ASSET_SCROLLBAR_ARROWUP     "gfx/menus/scrollbar_arrow_up_a.tga"
+#define ASSET_SCROLLBAR_ARROWLEFT   "gfx/menus/scrollbar_arrow_left.tga"
+#define ASSET_SCROLLBAR_ARROWRIGHT  "gfx/menus/scrollbar_arrow_right.tga"
+#define ASSET_SCROLL_THUMB          "gfx/menus/scrollbar_thumb.tga"
+#define ASSET_SLIDER_BAR			"menu/new/slider"
+#define ASSET_SLIDER_THUMB			"menu/new/sliderthumb"
+#define SCROLLBAR_SIZE 16.0
+#define SLIDER_WIDTH 96.0
+#define SLIDER_HEIGHT 16.0
+#define SLIDER_THUMB_WIDTH 12.0
+#define SLIDER_THUMB_HEIGHT 20.0
+#define	NUM_CROSSHAIRS			9
+
+typedef struct {
+  const char *command;
+  const char *args[MAX_SCRIPT_ARGS];
+} scriptDef_t;
+
+
+typedef struct {
+  float x;    // horiz position
+  float y;    // vert position
+  float w;    // width
+  float h;    // height;
+} rectDef_t;
+
+typedef rectDef_t Rectangle;
+
+// FIXME: do something to separate text vs window stuff
+typedef struct {
+  Rectangle rect;                 // client coord rectangle
+  Rectangle rectClient;           // screen coord rectangle
+  const char *name;               //
+  const char *group;              // if it belongs to a group
+  const char *cinematicName;		  // cinematic name
+  int cinematic;								  // cinematic handle
+  int style;                      //
+  int border;                     //
+  int ownerDraw;									// ownerDraw style
+	int ownerDrawFlags;							// show flags for ownerdraw items
+  float borderSize;               // 
+  int flags;                      // visible, focus, mouseover, cursor
+  Rectangle rectEffects;          // for various effects
+  Rectangle rectEffects2;         // for various effects
+  int offsetTime;                 // time based value for various effects
+  int nextTime;                   // time next effect should cycle
+  vec4_t foreColor;               // text color
+  vec4_t backColor;               // border color
+  vec4_t borderColor;             // border color
+  vec4_t outlineColor;            // border color
+  qhandle_t background;           // background asset  
+} windowDef_t;
+
+typedef windowDef_t Window;
+
+typedef struct {
+	vec4_t	color;
+	float		low;
+	float		high;
+} colorRangeDef_t;
+
+// FIXME: combine flags into bitfields to save space
+// FIXME: consolidate all of the common stuff in one structure for menus and items
+// THINKABOUTME: is there any compelling reason not to have items contain items
+// and do away with a menu per say.. major issue is not being able to dynamically allocate 
+// and destroy stuff.. Another point to consider is adding an alloc free call for vm's and have 
+// the engine just allocate the pool for it based on a cvar
+// many of the vars are re-used for different item types, as such they are not always named appropriately
+// the benefits of c++ in DOOM will greatly help crap like this
+// FIXME: need to put a type ptr that points to specific type info per type
+// 
+#define MAX_LB_COLUMNS 16
+
+typedef struct columnInfo_s {
+	int pos;
+	int width;
+	int maxChars;
+} columnInfo_t;
+
+typedef struct listBoxDef_s {
+	int startPos;
+	int endPos;
+	int drawPadding;
+	int cursorPos;
+	float elementWidth;
+	float elementHeight;
+	int elementStyle;
+	int numColumns;
+	columnInfo_t columnInfo[MAX_LB_COLUMNS];
+	const char *doubleClick;
+	qboolean notselectable;
+	//JLF MPMOVED
+	qboolean	scrollhidden;
+} listBoxDef_t;
+
+typedef struct editFieldDef_s {
+  float minVal;                  //	edit field limits
+  float maxVal;                  //
+  float defVal;                  //
+	float range;									 // 
+  int maxChars;                  // for edit fields
+  int maxPaintChars;             // for edit fields
+	int paintOffset;							 // 
+} editFieldDef_t;
+
+#define MAX_MULTI_CVARS 32
+
+typedef struct multiDef_s {
+	const char *cvarList[MAX_MULTI_CVARS];
+	const char *cvarStr[MAX_MULTI_CVARS];
+	float cvarValue[MAX_MULTI_CVARS];
+	int count;
+	qboolean strDef;
+} multiDef_t;
+
+typedef struct modelDef_s {
+	int angle;
+	vec3_t origin;
+	float fov_x;
+	float fov_y;
+	int rotationSpeed;
+
+	vec3_t g2mins; //required
+	vec3_t g2maxs; //required
+	vec3_t g2scale; //optional
+	int g2skin; //optional
+	int g2anim; //optional
+	//JLF
+//Transition extras
+	vec3_t g2mins2, g2maxs2, g2minsEffect, g2maxsEffect;
+	float fov_x2, fov_y2, fov_Effectx, fov_Effecty;
+} modelDef_t;
+
+typedef struct textScrollDef_s 
+{
+	int				startPos;
+	int				endPos;
+
+	float			lineHeight;
+	int				maxLineChars;
+	int				drawPadding;
+
+	// changed spelling to make them fall out during compile while I made them asian-aware	-Ste
+	//
+	int				iLineCount;
+	const char*		pLines[MAX_TEXTSCROLL_LINES];	// can contain NULL ptrs that you should skip over during paint.
+
+} textScrollDef_t;
+
+#define ITEM_ALIGN_LEFT		0		// left alignment
+#define ITEM_ALIGN_CENTER	1		// center alignment
+#define ITEM_ALIGN_RIGHT	2		// right alignment
+
+#define CVAR_ENABLE			0x00000001
+#define CVAR_DISABLE		0x00000002
+#define CVAR_SHOW			0x00000004
+#define CVAR_HIDE			0x00000008
+
+#define ITF_G2VALID			0x0001					// indicates whether or not g2 instance is valid.
+#define ITF_ISCHARACTER		0x0002					// a character item, uses customRGBA
+#define ITF_ISSABER			0x0004					// first saber item, draws blade
+#define ITF_ISSABER2		0x0008					// second saber item, draws blade
+
+#define ITF_ISANYSABER		(ITF_ISSABER|ITF_ISSABER2)	//either saber
+
+typedef struct itemDef_s {
+	Window		window;						// common positional, border, style, layout info
+	Rectangle	textRect;					// rectangle the text ( if any ) consumes     
+	int			type;						// text, button, radiobutton, checkbox, textfield, listbox, combo
+	int			alignment;					// left center right
+	int			textalignment;				// ( optional ) alignment for text within rect based on text width
+	float		textalignx;					// ( optional ) text alignment x coord
+	float		textaligny;					// ( optional ) text alignment x coord
+	float		textscale;					// scale percentage from 72pts
+	int			textStyle;					// ( optional ) style, normal and shadowed are it for now
+	const char	*text;						// display text
+	const char	*text2;						// display text, 2nd line
+	float		text2alignx;				// ( optional ) text2 alignment x coord
+	float		text2aligny;				// ( optional ) text2 alignment y coord
+	void		*parent;					// menu owner
+	qhandle_t	asset;						// handle to asset
+	void		*ghoul2;					// ghoul2 instance if available instead of a model.
+	int			flags;						// flags like g2valid, character, saber, saber2, etc.
+	const char	*mouseEnterText;			// mouse enter script
+	const char	*mouseExitText;				// mouse exit script
+	const char	*mouseEnter;				// mouse enter script
+	const char	*mouseExit;					// mouse exit script 
+	const char	*action;					// select script
+//JLFACCEPT MPMOVED
+	const char  *accept;
+//JLFDPADSCRIPT
+	const char * selectionNext;
+	const char * selectionPrev;
+
+	const char	*onFocus;					// select script
+	const char	*leaveFocus;				// select script
+	const char	*cvar;						// associated cvar 
+	const char	*cvarTest;					// associated cvar for enable actions
+	const char	*enableCvar;				// enable, disable, show, or hide based on value, this can contain a list
+	int			cvarFlags;					//	what type of action to take on cvarenables
+	sfxHandle_t focusSound;
+	int			numColors;					// number of color ranges
+	colorRangeDef_t colorRanges[MAX_COLOR_RANGES];
+	float		special;					// used for feeder id's etc.. diff per type
+	int			cursorPos;					// cursor position in characters
+	void		*typeData;					// type specific data ptr's	
+	const char	*descText;					//	Description text
+	int			appearanceSlot;				// order of appearance
+	int			iMenuFont;					// FONT_SMALL,FONT_MEDIUM,FONT_LARGE	// changed from 'font' so I could see what didn't compile, and differentiate between font handles returned from RegisterFont -ste
+	qboolean	disabled;					// Does this item ignore mouse and keyboard focus
+	int			invertYesNo;
+	int			xoffset;
+} itemDef_t;
+
+typedef struct {
+	Window window;
+	const char  *font;						// font
+	qboolean fullScreen;					// covers entire screen 
+	int itemCount;							// number of items;
+	int fontIndex;							// 
+	int cursorItem;							// which item as the cursor
+	int fadeCycle;							//
+	float fadeClamp;						//
+	float fadeAmount;						//
+	const char *onOpen;						// run when the menu is first opened
+	const char *onClose;					// run when the menu is closed
+//JLFACCEPT
+	const char  *onAccept;					// run when menu is closed with acceptance
+
+	const char *onESC;						// run when the menu is closed
+	const char *soundName;					// background loop sound for menu
+
+	vec4_t focusColor;						// focus color for items
+	vec4_t disableColor;					// focus color for items
+	itemDef_t *items[MAX_MENUITEMS];		// items this menu contains   
+	int			descX;						// X position of description
+	int			descY;						// X position of description
+	vec4_t		descColor;					// description text color for items
+	int			descAlignment;				// Description of alignment
+	float		descScale;					// Description scale
+	float		appearanceTime;				//	when next item should appear
+	int			appearanceCnt;				//	current item displayed
+	float		appearanceIncrement;		//
+} menuDef_t;
+
+typedef struct {
+  const char *fontStr;
+  const char *cursorStr;
+  const char *gradientStr;
+  qhandle_t	qhSmallFont;
+  qhandle_t	qhSmall2Font;
+  qhandle_t	qhMediumFont;
+  qhandle_t	qhBigFont;
+  qhandle_t cursor;
+  qhandle_t gradientBar;
+  qhandle_t scrollBarArrowUp;
+  qhandle_t scrollBarArrowDown;
+  qhandle_t scrollBarArrowLeft;
+  qhandle_t scrollBarArrowRight;
+  qhandle_t scrollBar;
+  qhandle_t scrollBarThumb;
+  qhandle_t buttonMiddle;
+  qhandle_t buttonInside;
+  qhandle_t solidBox;
+  qhandle_t sliderBar;
+  qhandle_t sliderThumb;
+  sfxHandle_t menuEnterSound;
+  sfxHandle_t menuExitSound;
+  sfxHandle_t menuBuzzSound;
+  sfxHandle_t itemFocusSound;
+  float fadeClamp;
+  int fadeCycle;
+  float fadeAmount;
+  float shadowX;
+  float shadowY;
+  vec4_t shadowColor;
+  float shadowFadeClamp;
+  qboolean fontRegistered;
+
+    qhandle_t needPass;
+    qhandle_t noForce;
+    qhandle_t forceRestrict;
+    qhandle_t saberOnly;
+    qhandle_t trueJedi;
+
+	sfxHandle_t moveRollSound;
+	sfxHandle_t moveJumpSound;
+	sfxHandle_t datapadmoveSaberSound1;
+	sfxHandle_t datapadmoveSaberSound2;
+	sfxHandle_t datapadmoveSaberSound3;
+	sfxHandle_t datapadmoveSaberSound4;
+	sfxHandle_t datapadmoveSaberSound5;
+	sfxHandle_t datapadmoveSaberSound6;
+
+  // player settings
+	qhandle_t fxBasePic;
+  qhandle_t fxPic[7];
+	qhandle_t	crosshairShader[NUM_CROSSHAIRS];
+
+} cachedAssets_t;
+
+typedef struct 
+{
+	const char *name;
+	qboolean (*handler) (itemDef_t *item, char** args);
+} commandDef_t;
+
+typedef struct {
+  qhandle_t (*registerShaderNoMip) (const char *p);
+  void (*setColor) (const vec4_t v);
+  void (*drawHandlePic) (float x, float y, float w, float h, qhandle_t asset);
+  void (*drawStretchPic) (float x, float y, float w, float h, float s1, float t1, float s2, float t2, qhandle_t hShader );
+  void (*drawText) (float x, float y, float scale, vec4_t color, const char *text, float adjust, int limit, int style, int iMenuFont);  
+  int (*textWidth) (const char *text, float scale, int iMenuFont);  
+  int (*textHeight) (const char *text, float scale, int iMenuFont);
+  qhandle_t (*registerModel) (const char *p);
+  void (*modelBounds) (qhandle_t model, vec3_t min, vec3_t max);
+  void (*fillRect) ( float x, float y, float w, float h, const vec4_t color);
+  void (*drawRect) ( float x, float y, float w, float h, float size, const vec4_t color);
+  void (*drawSides) (float x, float y, float w, float h, float size);
+  void (*drawTopBottom) (float x, float y, float w, float h, float size);
+  void (*clearScene) ();
+  void (*addRefEntityToScene) (const refEntity_t *re );
+  void (*renderScene) ( const refdef_t *fd );
+
+	qhandle_t (*RegisterFont)( const char *fontName );
+	int		(*Font_StrLenPixels) (const char *text, const int iFontIndex, const float scale);
+	int		(*Font_StrLenChars) (const char *text);
+	int		(*Font_HeightPixels)(const int iFontIndex, const float scale);
+	void	(*Font_DrawString)(int ox, int oy, const char *text, const float *rgba, const int setIndex, int iCharLimit, const float scale);
+	qboolean (*Language_IsAsian)(void);
+	qboolean (*Language_UsesSpaces)(void);
+	unsigned int (*AnyLanguage_ReadCharFromString)( const char *psText, int *piAdvanceCount, qboolean *pbIsTrailingPunctuation/* = NULL*/ );
+  void (*ownerDrawItem) (float x, float y, float w, float h, float text_x, float text_y, int ownerDraw, int ownerDrawFlags, int align, float special, float scale, vec4_t color, qhandle_t shader, int textStyle,int iMenuFont);
+	float (*getValue) (int ownerDraw);
+	qboolean (*ownerDrawVisible) (int flags);
+  void (*runScript)(char **p);
+  qboolean (*deferScript)(char **p);
+  void (*getTeamColor)(vec4_t *color);
+  void (*getCVarString)(const char *cvar, char *buffer, int bufsize);
+  float (*getCVarValue)(const char *cvar);
+  void (*setCVar)(const char *cvar, const char *value);
+  void (*drawTextWithCursor)(float x, float y, float scale, vec4_t color, const char *text, int cursorPos, char cursor, int limit, int style, int iFontIndex);
+  void (*setOverstrikeMode)(qboolean b);
+  qboolean (*getOverstrikeMode)();
+  void (*startLocalSound)( sfxHandle_t sfx, int channelNum );
+  qboolean (*ownerDrawHandleKey)(int ownerDraw, int flags, float *special, int key);
+  int (*feederCount)(float feederID);
+  const char *(*feederItemText)(float feederID, int index, int column, qhandle_t *handle1, qhandle_t *handle2, qhandle_t *handle3);
+  qhandle_t (*feederItemImage)(float feederID, int index);
+  qboolean (*feederSelection)(float feederID, int index, itemDef_t *item);
+	void (*keynumToStringBuf)( int keynum, char *buf, int buflen );
+	void (*getBindingBuf)( int keynum, char *buf, int buflen );
+	void (*setBinding)( int keynum, const char *binding );
+	void (*executeText)(int exec_when, const char *text );	
+	void (*Error)(int level, const char *error, ...);
+	void (*Print)(const char *msg, ...);
+	void (*Pause)(qboolean b);
+	int (*ownerDrawWidth)(int ownerDraw, float scale);
+	sfxHandle_t (*registerSound)(const char *name);
+	void (*startBackgroundTrack)( const char *intro, const char *loop, qboolean bReturnWithoutStarting);
+	void (*stopBackgroundTrack)();
+	int (*playCinematic)(const char *name, float x, float y, float w, float h);
+	void (*stopCinematic)(int handle);
+	void (*drawCinematic)(int handle, float x, float y, float w, float h);
+	void (*runCinematicFrame)(int handle);
+
+  float			yscale;
+  float			xscale;
+  float			bias;
+  int				realTime;
+  int				frameTime;
+	int				cursorx;
+	int				cursory;
+	qboolean	debug;
+
+  cachedAssets_t Assets;
+
+	glconfig_t glconfig;
+	qhandle_t	whiteShader;
+  qhandle_t gradientImage;
+  qhandle_t cursor;
+	float FPS;
+
+} displayContextDef_t;
+
+#include "../namespace_begin.h"
+
+const char *String_Alloc(const char *p);
+void String_Init();
+void String_Report();
+void Init_Display(displayContextDef_t *dc);
+void Display_ExpandMacros(char * buff);
+void Menu_Init(menuDef_t *menu);
+void Item_Init(itemDef_t *item);
+void Menu_PostParse(menuDef_t *menu);
+menuDef_t *Menu_GetFocused();
+void Menu_HandleKey(menuDef_t *menu, int key, qboolean down);
+void Menu_HandleMouseMove(menuDef_t *menu, float x, float y);
+void Menu_ScrollFeeder(menuDef_t *menu, int feeder, qboolean down);
+qboolean Float_Parse(char **p, float *f);
+qboolean Color_Parse(char **p, vec4_t *c);
+qboolean Int_Parse(char **p, int *i);
+qboolean Rect_Parse(char **p, rectDef_t *r);
+qboolean String_Parse(char **p, const char **out);
+qboolean Script_Parse(char **p, const char **out);
+qboolean PC_Float_Parse(int handle, float *f);
+qboolean PC_Color_Parse(int handle, vec4_t *c);
+qboolean PC_Int_Parse(int handle, int *i);
+qboolean PC_Rect_Parse(int handle, rectDef_t *r);
+qboolean PC_String_Parse(int handle, const char **out);
+qboolean PC_Script_Parse(int handle, const char **out);
+int Menu_Count();
+void Menu_New(int handle);
+void Menu_PaintAll();
+menuDef_t *Menus_ActivateByName(const char *p);
+void Menu_Reset();
+qboolean Menus_AnyFullScreenVisible();
+void  Menus_Activate(menuDef_t *menu);
+itemDef_t *Menu_FindItemByName(menuDef_t *menu, const char *p);
+
+displayContextDef_t *Display_GetContext();
+void *Display_CaptureItem(int x, int y);
+qboolean Display_MouseMove(void *p, int x, int y);
+int Display_CursorType(int x, int y);
+qboolean Display_KeyBindPending();
+void Menus_OpenByName(const char *p);
+menuDef_t *Menus_FindByName(const char *p);
+void Menus_ShowByName(const char *p);
+void Menus_CloseByName(const char *p);
+void Display_HandleKey(int key, qboolean down, int x, int y);
+void LerpColor(vec4_t a, vec4_t b, vec4_t c, float t);
+void Menus_CloseAll();
+void Menu_Paint(menuDef_t *menu, qboolean forcePaint);
+void Menu_SetFeederSelection(menuDef_t *menu, int feeder, int index, const char *name);
+void Display_CacheAll();
+void Menu_SetItemBackground(const menuDef_t *menu,const char *itemName, const char *background);
+
+void *UI_Alloc( int size );
+void UI_InitMemory( void );
+qboolean UI_OutOfMemory();
+
+void Controls_GetConfig( void );
+void Controls_SetConfig(qboolean restart);
+
+
+int			trap_PC_AddGlobalDefine			( char *define );
+int			trap_PC_LoadSource				( const char *filename );
+int			trap_PC_FreeSource				( int handle );
+int			trap_PC_ReadToken				( int handle, pc_token_t *pc_token );
+int			trap_PC_SourceFileAndLine		( int handle, char *filename, int *line );
+int			trap_PC_LoadGlobalDefines		( const char* filename );
+void		trap_PC_RemoveAllGlobalDefines	( void );
+
+int			trap_R_Font_StrLenPixels(const char *text, const int iFontIndex, const float scale);
+int			trap_R_Font_StrLenChars(const char *text);
+int			trap_R_Font_HeightPixels(const int iFontIndex, const float scale);
+void		trap_R_Font_DrawString(int ox, int oy, const char *text, const float *rgba, const int setIndex, int iCharLimit, const float scale);
+qboolean	trap_Language_IsAsian(void);
+qboolean	trap_Language_UsesSpaces(void);
+unsigned int trap_AnyLanguage_ReadCharFromString( const char *psText, int *piAdvanceCount, qboolean *pbIsTrailingPunctuation );
+
+int trap_SP_GetStringTextString(const char *text, char *buffer, int bufferLength);
+int trap_SP_GetNumLanguages( void );
+void trap_GetLanguageName( const int languageIndex, char *buffer );
+
+//these traps must exist both on the cgame and ui
+/*
+Ghoul2 Insert Start
+*/
+// UI specific API access
+void		trap_G2API_CollisionDetect		( CollisionRecord_t *collRecMap, void* ghoul2, const vec3_t angles, const vec3_t position,int frameNumber, int entNum, const vec3_t rayStart, const vec3_t rayEnd, const vec3_t scale, int traceFlags, int useLod, float fRadius );
+
+void		trap_G2_ListModelSurfaces(void *ghlInfo);
+void		trap_G2_ListModelBones(void *ghlInfo, int frame);
+void		trap_G2_SetGhoul2ModelIndexes(void *ghoul2, qhandle_t *modelList, qhandle_t *skinList);
+qboolean	trap_G2_HaveWeGhoul2Models(void *ghoul2);
+qboolean	trap_G2API_GetBoltMatrix(void *ghoul2, const int modelIndex, const int boltIndex, mdxaBone_t *matrix,
+								const vec3_t angles, const vec3_t position, const int frameNum, qhandle_t *modelList, vec3_t scale);
+qboolean	trap_G2API_GetBoltMatrix_NoReconstruct(void *ghoul2, const int modelIndex, const int boltIndex, mdxaBone_t *matrix,
+								const vec3_t angles, const vec3_t position, const int frameNum, qhandle_t *modelList, vec3_t scale);
+qboolean	trap_G2API_GetBoltMatrix_NoRecNoRot(void *ghoul2, const int modelIndex, const int boltIndex, mdxaBone_t *matrix,
+								const vec3_t angles, const vec3_t position, const int frameNum, qhandle_t *modelList, vec3_t scale);
+int			trap_G2API_InitGhoul2Model(void **ghoul2Ptr, const char *fileName, int modelIndex, qhandle_t customSkin,
+						  qhandle_t customShader, int modelFlags, int lodBias);
+qboolean	trap_G2API_SetSkin(void *ghoul2, int modelIndex, qhandle_t customSkin, qhandle_t renderSkin);
+qboolean	trap_G2API_AttachG2Model(void *ghoul2From, int modelIndexFrom, void *ghoul2To, int toBoltIndex, int toModel);
+
+
+int			trap_G2API_CopyGhoul2Instance(void *g2From, void *g2To, int modelIndex);
+void		trap_G2API_CopySpecificGhoul2Model(void *g2From, int modelFrom, void *g2To, int modelTo);
+void		trap_G2API_DuplicateGhoul2Instance(void *g2From, void **g2To);
+qboolean	trap_G2API_HasGhoul2ModelOnIndex(void *ghlInfo, int modelIndex);
+qboolean	trap_G2API_RemoveGhoul2Model(void *ghlInfo, int modelIndex);
+
+int			trap_G2API_AddBolt(void *ghoul2, int modelIndex, const char *boneName);
+//qboolean	trap_G2API_RemoveBolt(void *ghoul2, int index);
+void		trap_G2API_SetBoltInfo(void *ghoul2, int modelIndex, int boltInfo);
+void		trap_G2API_CleanGhoul2Models(void **ghoul2Ptr);
+qboolean	trap_G2API_SetBoneAngles(void *ghoul2, int modelIndex, const char *boneName, const vec3_t angles, const int flags,
+								const int up, const int right, const int forward, qhandle_t *modelList,
+								int blendTime , int currentTime );
+void		trap_G2API_GetGLAName(void *ghoul2, int modelIndex, char *fillBuf);
+qboolean	trap_G2API_SetBoneAnim(void *ghoul2, const int modelIndex, const char *boneName, const int startFrame, const int endFrame,
+							  const int flags, const float animSpeed, const int currentTime, const float setFrame , const int blendTime );
+qboolean	trap_G2API_GetBoneAnim(void *ghoul2, const char *boneName, const int currentTime, float *currentFrame, int *startFrame,
+								int *endFrame, int *flags, float *animSpeed, int *modelList, const int modelIndex);
+qboolean	trap_G2API_GetBoneFrame(void *ghoul2, const char *boneName, const int currentTime, float *currentFrame, int *modelList, const int modelIndex);
+
+qboolean	trap_G2API_SetRootSurface(void *ghoul2, const int modelIndex, const char *surfaceName);
+qboolean	trap_G2API_SetSurfaceOnOff(void *ghoul2, const char *surfaceName, const int flags);
+qboolean	trap_G2API_SetNewOrigin(void *ghoul2, const int boltIndex);
+
+int			trap_G2API_GetTime(void);
+void		trap_G2API_SetTime(int time, int clock);
+
+void		trap_G2API_SetRagDoll(void *ghoul2, sharedRagDollParams_t *params);
+void		trap_G2API_AnimateG2Models(void *ghoul2, int time, sharedRagDollUpdateParams_t *params);
+
+qboolean	trap_G2API_SetBoneIKState(void *ghoul2, int time, const char *boneName, int ikState, sharedSetBoneIKStateParams_t *params);
+qboolean	trap_G2API_IKMove(void *ghoul2, int time, sharedIKMoveParams_t *params);
+
+void		trap_G2API_GetSurfaceName(void *ghoul2, int surfNumber, int modelIndex, char *fillBuf);
+
+#include "../namespace_end.h"
+
+/*
+Ghoul2 Insert End
+*/
+#endif
diff --git a/codemp/ui/ui_syscalls.c b/codemp/ui/ui_syscalls.c
new file mode 100644
index 0000000..cbbda6c
--- /dev/null
+++ b/codemp/ui/ui_syscalls.c
@@ -0,0 +1,651 @@
+// Copyright (C) 1999-2000 Id Software, Inc.
+//
+#include "ui_local.h"
+
+// this file is only included when building a dll
+// syscalls.asm is included instead when building a qvm
+
+static int (QDECL *syscall)( int arg, ... ) = (int (QDECL *)( int, ...))-1;
+
+#include "../namespace_begin.h"
+void dllEntry( int (QDECL *syscallptr)( int arg,... ) ) {
+	syscall = syscallptr;
+}
+
+int PASSFLOAT( float x ) {
+	float	floatTemp;
+	floatTemp = x;
+	return *(int *)&floatTemp;
+}
+
+void trap_Print( const char *string ) {
+	syscall( UI_PRINT, string );
+}
+
+void trap_Error( const char *string ) {
+	syscall( UI_ERROR, string );
+}
+
+int trap_Milliseconds( void ) {
+	return syscall( UI_MILLISECONDS ); 
+}
+
+void trap_Cvar_Register( vmCvar_t *cvar, const char *var_name, const char *value, int flags ) {
+	syscall( UI_CVAR_REGISTER, cvar, var_name, value, flags );
+}
+
+void trap_Cvar_Update( vmCvar_t *cvar ) {
+	syscall( UI_CVAR_UPDATE, cvar );
+}
+
+void trap_Cvar_Set( const char *var_name, const char *value ) {
+	syscall( UI_CVAR_SET, var_name, value );
+}
+
+float trap_Cvar_VariableValue( const char *var_name ) {
+	int temp;
+	temp = syscall( UI_CVAR_VARIABLEVALUE, var_name );
+	return (*(float*)&temp);
+}
+
+void trap_Cvar_VariableStringBuffer( const char *var_name, char *buffer, int bufsize ) {
+	syscall( UI_CVAR_VARIABLESTRINGBUFFER, var_name, buffer, bufsize );
+}
+
+void trap_Cvar_SetValue( const char *var_name, float value ) {
+	syscall( UI_CVAR_SETVALUE, var_name, PASSFLOAT( value ) );
+}
+
+void trap_Cvar_Reset( const char *name ) {
+	syscall( UI_CVAR_RESET, name ); 
+}
+
+void trap_Cvar_Create( const char *var_name, const char *var_value, int flags ) {
+	syscall( UI_CVAR_CREATE, var_name, var_value, flags );
+}
+
+void trap_Cvar_InfoStringBuffer( int bit, char *buffer, int bufsize ) {
+	syscall( UI_CVAR_INFOSTRINGBUFFER, bit, buffer, bufsize );
+}
+
+int trap_Argc( void ) {
+	return syscall( UI_ARGC );
+}
+
+void trap_Argv( int n, char *buffer, int bufferLength ) {
+	syscall( UI_ARGV, n, buffer, bufferLength );
+}
+
+void trap_Cmd_ExecuteText( int exec_when, const char *text ) {
+	syscall( UI_CMD_EXECUTETEXT, exec_when, text );
+}
+
+int trap_FS_FOpenFile( const char *qpath, fileHandle_t *f, fsMode_t mode ) {
+	return syscall( UI_FS_FOPENFILE, qpath, f, mode );
+}
+
+void trap_FS_Read( void *buffer, int len, fileHandle_t f ) {
+	syscall( UI_FS_READ, buffer, len, f );
+}
+
+void trap_FS_Write( const void *buffer, int len, fileHandle_t f ) {
+	syscall( UI_FS_WRITE, buffer, len, f );
+}
+
+void trap_FS_FCloseFile( fileHandle_t f ) {
+	syscall( UI_FS_FCLOSEFILE, f );
+}
+
+int trap_FS_GetFileList(  const char *path, const char *extension, char *listbuf, int bufsize ) {
+	return syscall( UI_FS_GETFILELIST, path, extension, listbuf, bufsize );
+}
+
+qhandle_t trap_R_RegisterModel( const char *name ) {
+	return syscall( UI_R_REGISTERMODEL, name );
+}
+
+qhandle_t trap_R_RegisterSkin( const char *name ) {
+	return syscall( UI_R_REGISTERSKIN, name );
+}
+
+qhandle_t trap_R_RegisterFont( const char *fontName )
+{
+	return syscall( UI_R_REGISTERFONT, fontName);
+}
+
+int	trap_R_Font_StrLenPixels(const char *text, const int iFontIndex, const float scale)
+{
+	return syscall( UI_R_FONT_STRLENPIXELS, text, iFontIndex, PASSFLOAT(scale));
+}
+
+int trap_R_Font_StrLenChars(const char *text)
+{
+	return syscall( UI_R_FONT_STRLENCHARS, text);
+}
+
+int trap_R_Font_HeightPixels(const int iFontIndex, const float scale)
+{
+	return syscall( UI_R_FONT_STRHEIGHTPIXELS, iFontIndex, PASSFLOAT(scale));
+}
+
+void trap_R_Font_DrawString(int ox, int oy, const char *text, const float *rgba, const int setIndex, int iCharLimit, const float scale)
+{
+	syscall( UI_R_FONT_DRAWSTRING, ox, oy, text, rgba, setIndex, iCharLimit, PASSFLOAT(scale));
+}
+
+qboolean trap_Language_IsAsian(void)
+{
+	return syscall( UI_LANGUAGE_ISASIAN );
+}
+
+qboolean trap_Language_UsesSpaces(void)
+{
+	return syscall( UI_LANGUAGE_USESSPACES );
+}
+
+unsigned int trap_AnyLanguage_ReadCharFromString( const char *psText, int *piAdvanceCount, qboolean *pbIsTrailingPunctuation )
+{
+	return syscall( UI_ANYLANGUAGE_READCHARFROMSTRING, psText, piAdvanceCount, pbIsTrailingPunctuation);
+}
+
+qhandle_t trap_R_RegisterShaderNoMip( const char *name ) {
+	char buf[1024];
+	
+	if (name[0] == '*') {
+		trap_Cvar_VariableStringBuffer(name+1, buf, sizeof(buf));
+		if (buf[0]) {
+			return syscall( UI_R_REGISTERSHADERNOMIP, &buf );
+		}
+	}
+	return syscall( UI_R_REGISTERSHADERNOMIP, name );
+}
+
+//added so I don't have to store a string containing the path of
+//the shader icon for a class -rww
+void trap_R_ShaderNameFromIndex(char *name, int index)
+{
+	syscall( UI_R_SHADERNAMEFROMINDEX, name, index );
+}
+
+void trap_R_ClearScene( void ) {
+	syscall( UI_R_CLEARSCENE );
+}
+
+void trap_R_AddRefEntityToScene( const refEntity_t *re ) {
+	syscall( UI_R_ADDREFENTITYTOSCENE, re );
+}
+
+void trap_R_AddPolyToScene( qhandle_t hShader , int numVerts, const polyVert_t *verts ) {
+	syscall( UI_R_ADDPOLYTOSCENE, hShader, numVerts, verts );
+}
+
+void trap_R_AddLightToScene( const vec3_t org, float intensity, float r, float g, float b ) {
+	syscall( UI_R_ADDLIGHTTOSCENE, org, PASSFLOAT(intensity), PASSFLOAT(r), PASSFLOAT(g), PASSFLOAT(b) );
+}
+
+void trap_R_RenderScene( const refdef_t *fd ) {
+	syscall( UI_R_RENDERSCENE, fd );
+}
+
+void trap_R_SetColor( const float *rgba ) {
+	syscall( UI_R_SETCOLOR, rgba );
+}
+
+void trap_R_DrawStretchPic( float x, float y, float w, float h, float s1, float t1, float s2, float t2, qhandle_t hShader ) {
+	syscall( UI_R_DRAWSTRETCHPIC, PASSFLOAT(x), PASSFLOAT(y), PASSFLOAT(w), PASSFLOAT(h), PASSFLOAT(s1), PASSFLOAT(t1), PASSFLOAT(s2), PASSFLOAT(t2), hShader );
+}
+
+void	trap_R_ModelBounds( clipHandle_t model, vec3_t mins, vec3_t maxs ) {
+	syscall( UI_R_MODELBOUNDS, model, mins, maxs );
+}
+
+void trap_UpdateScreen( void ) {
+	syscall( UI_UPDATESCREEN );
+}
+
+int trap_CM_LerpTag( orientation_t *tag, clipHandle_t mod, int startFrame, int endFrame, float frac, const char *tagName ) {
+	return syscall( UI_CM_LERPTAG, tag, mod, startFrame, endFrame, PASSFLOAT(frac), tagName );
+}
+
+void trap_S_StartLocalSound( sfxHandle_t sfx, int channelNum ) {
+	syscall( UI_S_STARTLOCALSOUND, sfx, channelNum );
+}
+
+sfxHandle_t	trap_S_RegisterSound( const char *sample ) {
+	return syscall( UI_S_REGISTERSOUND, sample );
+}
+
+void trap_Key_KeynumToStringBuf( int keynum, char *buf, int buflen ) {
+	syscall( UI_KEY_KEYNUMTOSTRINGBUF, keynum, buf, buflen );
+}
+
+void trap_Key_GetBindingBuf( int keynum, char *buf, int buflen ) {
+	syscall( UI_KEY_GETBINDINGBUF, keynum, buf, buflen );
+}
+
+void trap_Key_SetBinding( int keynum, const char *binding ) {
+	syscall( UI_KEY_SETBINDING, keynum, binding );
+}
+
+qboolean trap_Key_IsDown( int keynum ) {
+	return syscall( UI_KEY_ISDOWN, keynum );
+}
+
+qboolean trap_Key_GetOverstrikeMode( void ) {
+	return syscall( UI_KEY_GETOVERSTRIKEMODE );
+}
+
+void trap_Key_SetOverstrikeMode( qboolean state ) {
+	syscall( UI_KEY_SETOVERSTRIKEMODE, state );
+}
+
+void trap_Key_ClearStates( void ) {
+	syscall( UI_KEY_CLEARSTATES );
+}
+
+int trap_Key_GetCatcher( void ) {
+	return syscall( UI_KEY_GETCATCHER );
+}
+
+void trap_Key_SetCatcher( int catcher ) {
+	syscall( UI_KEY_SETCATCHER, catcher );
+}
+
+void trap_GetClipboardData( char *buf, int bufsize ) {
+	syscall( UI_GETCLIPBOARDDATA, buf, bufsize );
+}
+
+void trap_GetClientState( uiClientState_t *state ) {
+	syscall( UI_GETCLIENTSTATE, state );
+}
+
+void trap_GetGlconfig( glconfig_t *glconfig ) {
+	syscall( UI_GETGLCONFIG, glconfig );
+}
+
+int trap_GetConfigString( int index, char* buff, int buffsize ) {
+	return syscall( UI_GETCONFIGSTRING, index, buff, buffsize );
+}
+
+int	trap_LAN_GetServerCount( int source ) {
+	return syscall( UI_LAN_GETSERVERCOUNT, source );
+}
+
+void trap_LAN_GetServerAddressString( int source, int n, char *buf, int buflen ) {
+	syscall( UI_LAN_GETSERVERADDRESSSTRING, source, n, buf, buflen );
+}
+
+void trap_LAN_GetServerInfo( int source, int n, char *buf, int buflen ) {
+	syscall( UI_LAN_GETSERVERINFO, source, n, buf, buflen );
+}
+
+int trap_LAN_GetServerPing( int source, int n ) {
+	return syscall( UI_LAN_GETSERVERPING, source, n );
+}
+
+int trap_LAN_GetPingQueueCount( void ) {
+	return syscall( UI_LAN_GETPINGQUEUECOUNT );
+}
+
+int trap_LAN_ServerStatus( const char *serverAddress, char *serverStatus, int maxLen ) {
+	return syscall( UI_LAN_SERVERSTATUS, serverAddress, serverStatus, maxLen );
+}
+
+void trap_LAN_SaveCachedServers() {
+	syscall( UI_LAN_SAVECACHEDSERVERS );
+}
+
+void trap_LAN_LoadCachedServers() {
+	syscall( UI_LAN_LOADCACHEDSERVERS );
+}
+
+void trap_LAN_ResetPings(int n) {
+	syscall( UI_LAN_RESETPINGS, n );
+}
+
+void trap_LAN_ClearPing( int n ) {
+	syscall( UI_LAN_CLEARPING, n );
+}
+
+void trap_LAN_GetPing( int n, char *buf, int buflen, int *pingtime ) {
+	syscall( UI_LAN_GETPING, n, buf, buflen, pingtime );
+}
+
+void trap_LAN_GetPingInfo( int n, char *buf, int buflen ) {
+	syscall( UI_LAN_GETPINGINFO, n, buf, buflen );
+}
+
+void trap_LAN_MarkServerVisible( int source, int n, qboolean visible ) {
+	syscall( UI_LAN_MARKSERVERVISIBLE, source, n, visible );
+}
+
+int trap_LAN_ServerIsVisible( int source, int n) {
+	return syscall( UI_LAN_SERVERISVISIBLE, source, n );
+}
+
+qboolean trap_LAN_UpdateVisiblePings( int source ) {
+	return syscall( UI_LAN_UPDATEVISIBLEPINGS, source );
+}
+
+int trap_LAN_AddServer(int source, const char *name, const char *addr) {
+	return syscall( UI_LAN_ADDSERVER, source, name, addr );
+}
+
+void trap_LAN_RemoveServer(int source, const char *addr) {
+	syscall( UI_LAN_REMOVESERVER, source, addr );
+}
+
+int trap_LAN_CompareServers( int source, int sortKey, int sortDir, int s1, int s2 ) {
+	return syscall( UI_LAN_COMPARESERVERS, source, sortKey, sortDir, s1, s2 );
+}
+
+int trap_MemoryRemaining( void ) {
+	return syscall( UI_MEMORY_REMAINING );
+}
+
+#ifdef USE_CD_KEY
+
+void trap_GetCDKey( char *buf, int buflen ) {
+	syscall( UI_GET_CDKEY, buf, buflen );
+}
+
+void trap_SetCDKey( char *buf ) {
+	syscall( UI_SET_CDKEY, buf );
+}
+
+qboolean trap_VerifyCDKey( const char *key, const char *chksum) {
+	return syscall( UI_VERIFY_CDKEY, key, chksum);
+}
+
+#endif // USE_CD_KEY
+
+int trap_PC_AddGlobalDefine( char *define ) {
+	return syscall( UI_PC_ADD_GLOBAL_DEFINE, define );
+}
+
+int trap_PC_LoadSource( const char *filename ) {
+	return syscall( UI_PC_LOAD_SOURCE, filename );
+}
+
+int trap_PC_FreeSource( int handle ) {
+	return syscall( UI_PC_FREE_SOURCE, handle );
+}
+
+int trap_PC_ReadToken( int handle, pc_token_t *pc_token ) {
+	return syscall( UI_PC_READ_TOKEN, handle, pc_token );
+}
+
+int trap_PC_SourceFileAndLine( int handle, char *filename, int *line ) {
+	return syscall( UI_PC_SOURCE_FILE_AND_LINE, handle, filename, line );
+}
+
+int trap_PC_LoadGlobalDefines ( const char* filename )
+{
+	return syscall ( UI_PC_LOAD_GLOBAL_DEFINES, filename );
+}
+
+void trap_PC_RemoveAllGlobalDefines ( void )
+{
+	syscall ( UI_PC_REMOVE_ALL_GLOBAL_DEFINES );
+}
+
+void trap_S_StopBackgroundTrack( void ) {
+	syscall( UI_S_STOPBACKGROUNDTRACK );
+}
+
+void trap_S_StartBackgroundTrack( const char *intro, const char *loop, qboolean bReturnWithoutStarting) {
+	syscall( UI_S_STARTBACKGROUNDTRACK, intro, loop, bReturnWithoutStarting );
+}
+
+int trap_RealTime(qtime_t *qtime) {
+	return syscall( UI_REAL_TIME, qtime );
+}
+
+// this returns a handle.  arg0 is the name in the format "idlogo.roq", set arg1 to NULL, alteredstates to qfalse (do not alter gamestate)
+int trap_CIN_PlayCinematic( const char *arg0, int xpos, int ypos, int width, int height, int bits) {
+  return syscall(UI_CIN_PLAYCINEMATIC, arg0, xpos, ypos, width, height, bits);
+}
+ 
+// stops playing the cinematic and ends it.  should always return FMV_EOF
+// cinematics must be stopped in reverse order of when they are started
+e_status trap_CIN_StopCinematic(int handle) {
+  return syscall(UI_CIN_STOPCINEMATIC, handle);
+}
+
+
+// will run a frame of the cinematic but will not draw it.  Will return FMV_EOF if the end of the cinematic has been reached.
+e_status trap_CIN_RunCinematic (int handle) {
+  return syscall(UI_CIN_RUNCINEMATIC, handle);
+}
+ 
+
+// draws the current frame
+void trap_CIN_DrawCinematic (int handle) {
+  syscall(UI_CIN_DRAWCINEMATIC, handle);
+}
+ 
+
+// allows you to resize the animation dynamically
+void trap_CIN_SetExtents (int handle, int x, int y, int w, int h) {
+  syscall(UI_CIN_SETEXTENTS, handle, x, y, w, h);
+}
+
+
+void	trap_R_RemapShader( const char *oldShader, const char *newShader, const char *timeOffset ) {
+	syscall( UI_R_REMAP_SHADER, oldShader, newShader, timeOffset );
+}
+
+int trap_SP_GetNumLanguages( void )
+{
+	return syscall( UI_SP_GETNUMLANGUAGES );
+}
+
+void trap_GetLanguageName( const int languageIndex, char *buffer )
+{
+	syscall( UI_SP_GETLANGUAGENAME, languageIndex, buffer);
+}
+
+int trap_SP_GetStringTextString(const char *text, char *buffer, int bufferLength)
+{
+	return syscall( UI_SP_GETSTRINGTEXTSTRING, text, buffer, bufferLength );
+}
+/*
+Ghoul2 Insert Start
+*/
+void trap_G2_ListModelSurfaces(void *ghlInfo)
+{
+	syscall( UI_G2_LISTSURFACES, ghlInfo);
+}
+
+void trap_G2_ListModelBones(void *ghlInfo, int frame)
+{
+	syscall( UI_G2_LISTBONES, ghlInfo, frame);
+}
+
+void trap_G2_SetGhoul2ModelIndexes(void *ghoul2, qhandle_t *modelList, qhandle_t *skinList)
+{
+	syscall( UI_G2_SETMODELS, ghoul2, modelList, skinList);
+}
+
+qboolean trap_G2_HaveWeGhoul2Models(void *ghoul2)
+{
+	return (qboolean)(syscall(UI_G2_HAVEWEGHOULMODELS, ghoul2));
+}
+
+qboolean trap_G2API_GetBoltMatrix(void *ghoul2, const int modelIndex, const int boltIndex, mdxaBone_t *matrix,
+								const vec3_t angles, const vec3_t position, const int frameNum, qhandle_t *modelList, vec3_t scale)
+{
+	return (qboolean)(syscall(UI_G2_GETBOLT, ghoul2, modelIndex, boltIndex, matrix, angles, position, frameNum, modelList, scale));
+}
+
+qboolean trap_G2API_GetBoltMatrix_NoReconstruct(void *ghoul2, const int modelIndex, const int boltIndex, mdxaBone_t *matrix,
+								const vec3_t angles, const vec3_t position, const int frameNum, qhandle_t *modelList, vec3_t scale)
+{ //Same as above but force it to not reconstruct the skeleton before getting the bolt position
+	return (qboolean)(syscall(UI_G2_GETBOLT_NOREC, ghoul2, modelIndex, boltIndex, matrix, angles, position, frameNum, modelList, scale));
+}
+
+qboolean trap_G2API_GetBoltMatrix_NoRecNoRot(void *ghoul2, const int modelIndex, const int boltIndex, mdxaBone_t *matrix,
+								const vec3_t angles, const vec3_t position, const int frameNum, qhandle_t *modelList, vec3_t scale)
+{ //Same as above but force it to not reconstruct the skeleton before getting the bolt position
+	return (qboolean)(syscall(UI_G2_GETBOLT_NOREC_NOROT, ghoul2, modelIndex, boltIndex, matrix, angles, position, frameNum, modelList, scale));
+}
+
+int trap_G2API_InitGhoul2Model(void **ghoul2Ptr, const char *fileName, int modelIndex, qhandle_t customSkin,
+						  qhandle_t customShader, int modelFlags, int lodBias)
+{
+	return syscall(UI_G2_INITGHOUL2MODEL, ghoul2Ptr, fileName, modelIndex, customSkin, customShader, modelFlags, lodBias);
+}
+
+qboolean trap_G2API_SetSkin(void *ghoul2, int modelIndex, qhandle_t customSkin, qhandle_t renderSkin)
+{
+	return syscall(UI_G2_SETSKIN, ghoul2, modelIndex, customSkin, renderSkin);
+}
+
+void trap_G2API_CollisionDetect ( 
+	CollisionRecord_t *collRecMap, 
+	void* ghoul2, 
+	const vec3_t angles, 
+	const vec3_t position,
+	int frameNumber, 
+	int entNum, 
+	const vec3_t rayStart, 
+	const vec3_t rayEnd, 
+	const vec3_t scale, 
+	int traceFlags, 
+	int useLod,
+	float fRadius
+	)
+{
+	syscall ( UI_G2_COLLISIONDETECT, collRecMap, ghoul2, angles, position, frameNumber, entNum, rayStart, rayEnd, scale, traceFlags, useLod, PASSFLOAT(fRadius) );
+}
+
+void trap_G2API_CleanGhoul2Models(void **ghoul2Ptr)
+{
+	syscall(UI_G2_CLEANMODELS, ghoul2Ptr);
+}
+
+qboolean trap_G2API_SetBoneAngles(void *ghoul2, int modelIndex, const char *boneName, const vec3_t angles, const int flags,
+								const int up, const int right, const int forward, qhandle_t *modelList,
+								int blendTime , int currentTime )
+{
+	return (syscall(UI_G2_ANGLEOVERRIDE, ghoul2, modelIndex, boneName, angles, flags, up, right, forward, modelList, blendTime, currentTime));
+}
+
+qboolean trap_G2API_SetBoneAnim(void *ghoul2, const int modelIndex, const char *boneName, const int startFrame, const int endFrame,
+							  const int flags, const float animSpeed, const int currentTime, const float setFrame , const int blendTime )
+{
+	return syscall(UI_G2_PLAYANIM, ghoul2, modelIndex, boneName, startFrame, endFrame, flags, PASSFLOAT(animSpeed), currentTime, PASSFLOAT(setFrame), blendTime);
+}
+
+qboolean trap_G2API_GetBoneAnim(void *ghoul2, const char *boneName, const int currentTime, float *currentFrame,
+						   int *startFrame, int *endFrame, int *flags, float *animSpeed, int *modelList, const int modelIndex)
+{
+	return syscall(UI_G2_GETBONEANIM, ghoul2, boneName, currentTime, currentFrame, startFrame, endFrame, flags, animSpeed, modelList, modelIndex);
+}
+
+qboolean trap_G2API_GetBoneFrame(void *ghoul2, const char *boneName, const int currentTime, float *currentFrame, int *modelList, const int modelIndex)
+{
+	return syscall(UI_G2_GETBONEFRAME, ghoul2, boneName, currentTime, currentFrame, modelList, modelIndex);
+}
+
+void trap_G2API_GetGLAName(void *ghoul2, int modelIndex, char *fillBuf)
+{
+	syscall(UI_G2_GETGLANAME, ghoul2, modelIndex, fillBuf);
+}
+
+int trap_G2API_CopyGhoul2Instance(void *g2From, void *g2To, int modelIndex)
+{
+	return syscall(UI_G2_COPYGHOUL2INSTANCE, g2From, g2To, modelIndex);
+}
+
+void trap_G2API_CopySpecificGhoul2Model(void *g2From, int modelFrom, void *g2To, int modelTo)
+{
+	syscall(UI_G2_COPYSPECIFICGHOUL2MODEL, g2From, modelFrom, g2To, modelTo);
+}
+
+void trap_G2API_DuplicateGhoul2Instance(void *g2From, void **g2To)
+{
+	syscall(UI_G2_DUPLICATEGHOUL2INSTANCE, g2From, g2To);
+}
+
+qboolean trap_G2API_HasGhoul2ModelOnIndex(void *ghlInfo, int modelIndex)
+{
+	return syscall(UI_G2_HASGHOUL2MODELONINDEX, ghlInfo, modelIndex);
+}
+
+qboolean trap_G2API_RemoveGhoul2Model(void *ghlInfo, int modelIndex)
+{
+	return syscall(UI_G2_REMOVEGHOUL2MODEL, ghlInfo, modelIndex);
+}
+
+int	trap_G2API_AddBolt(void *ghoul2, int modelIndex, const char *boneName)
+{
+	return syscall(UI_G2_ADDBOLT, ghoul2, modelIndex, boneName);
+}
+
+void trap_G2API_SetBoltInfo(void *ghoul2, int modelIndex, int boltInfo)
+{
+	syscall(UI_G2_SETBOLTON, ghoul2, modelIndex, boltInfo);
+}
+
+qboolean trap_G2API_SetRootSurface(void *ghoul2, const int modelIndex, const char *surfaceName)
+{
+	return syscall(UI_G2_SETROOTSURFACE, ghoul2, modelIndex, surfaceName);
+}
+
+qboolean trap_G2API_SetSurfaceOnOff(void *ghoul2, const char *surfaceName, const int flags)
+{
+	return syscall(UI_G2_SETSURFACEONOFF, ghoul2, surfaceName, flags);
+}
+
+qboolean trap_G2API_SetNewOrigin(void *ghoul2, const int boltIndex)
+{
+	return syscall(UI_G2_SETNEWORIGIN, ghoul2, boltIndex);
+}
+
+int trap_G2API_GetTime(void)
+{
+	return syscall(UI_G2_GETTIME);
+}
+
+void trap_G2API_SetTime(int time, int clock)
+{
+	syscall(UI_G2_SETTIME, time, clock);
+}
+
+//rww - RAGDOLL_BEGIN
+void trap_G2API_SetRagDoll(void *ghoul2, sharedRagDollParams_t *params)
+{
+	syscall(UI_G2_SETRAGDOLL, ghoul2, params);
+}
+
+void trap_G2API_AnimateG2Models(void *ghoul2, int time, sharedRagDollUpdateParams_t *params)
+{
+	syscall(UI_G2_ANIMATEG2MODELS, ghoul2, time, params);
+}
+//rww - RAGDOLL_END
+
+qboolean trap_G2API_SetBoneIKState(void *ghoul2, int time, const char *boneName, int ikState, sharedSetBoneIKStateParams_t *params)
+{
+	return syscall(UI_G2_SETBONEIKSTATE, ghoul2, time, boneName, ikState, params);
+}
+
+qboolean trap_G2API_IKMove(void *ghoul2, int time, sharedIKMoveParams_t *params)
+{
+	return syscall(UI_G2_IKMOVE, ghoul2, time, params);
+}
+
+void trap_G2API_GetSurfaceName(void *ghoul2, int surfNumber, int modelIndex, char *fillBuf)
+{
+	syscall(UI_G2_GETSURFACENAME, ghoul2, surfNumber, modelIndex, fillBuf);
+}
+
+qboolean trap_G2API_AttachG2Model(void *ghoul2From, int modelIndexFrom, void *ghoul2To, int toBoltIndex, int toModel)
+{
+	return syscall(UI_G2_ATTACHG2MODEL, ghoul2From, modelIndexFrom, ghoul2To, toBoltIndex, toModel);
+}
+/*
+Ghoul2 Insert End
+*/
+
+#include "../namespace_end.h"
diff --git a/codemp/ui/ui_util.c b/codemp/ui/ui_util.c
new file mode 100644
index 0000000..96d04e8
--- /dev/null
+++ b/codemp/ui/ui_util.c
@@ -0,0 +1,11 @@
+// ui_util.c
+//
+// origin: rad
+// new ui support stuff
+// 
+// memory, string alloc
+
+void RichIsGettingTiredOfEmptyFileVMCompilerWarnings()
+{
+	int andUnderstandablySo = 0;
+}
diff --git a/codemp/ui/vssver.scc b/codemp/ui/vssver.scc
new file mode 100644
index 0000000..6a3ff90
Binary files /dev/null and b/codemp/ui/vssver.scc differ
diff --git a/codemp/unix/files_linux.cpp b/codemp/unix/files_linux.cpp
new file mode 100644
index 0000000..9425d87
--- /dev/null
+++ b/codemp/unix/files_linux.cpp
@@ -0,0 +1,3071 @@
+/*****************************************************************************
+ * name:		files_pc.cpp
+ *
+ * desc:		PC-specific file code
+ *
+ *****************************************************************************/
+
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+#include "../client/client.h"
+//#include "../zlib32/zip.h"
+//#include "unzip.h"
+#include "../qcommon/files.h"
+
+//#include <windows.h> //rww - included to make fs_copyfiles 2 related functions happy.
+#include "../qcommon/platform.h"
+
+// productId: This file is copyright 2000 Raven Software, and may not be duplicated except during a licensed installation of the full commercial version of Star Wars: Jedi Outcast
+static byte fs_scrambledProductId[165] = {
+ 42, 143, 149, 190,  10, 197, 225, 133, 243,  63, 189, 182, 226,  56, 143,  17, 215,  37, 197, 218,  50, 103,  24, 235, 246, 191, 180, 149, 160, 170, 230,
+ 52, 176, 231,  15, 194, 236, 247, 159, 168, 132, 154,  24, 133,  67,  85,  36,  97,  99,  86, 117, 189, 212, 156, 236, 153,  68,  10, 196, 241,  39,
+219, 156,  88,  93, 198, 200, 232, 142,  67,  45, 209,  53, 186, 228, 241, 162, 127, 213,  83,   7, 121,  11,  93, 123, 243, 148, 240, 229,  42,  42,
+  6, 215, 239, 112, 120, 240, 244, 104,  12,  38,  47, 201, 253, 223, 208, 154,  69, 141, 157,  32, 117, 166, 146, 236,  59,  15, 223,  52,  89, 133,
+ 64, 201,  56, 119,  25, 211, 152, 159,  11,  92,  59, 207,  81, 123,   0, 121, 241, 116,  42,  36, 251,  51, 149,  79, 165,  12, 106, 187, 225, 203,
+ 99, 102,  69,  97,  81,  27, 107,  95, 164,  42,  36, 189,  94, 126
+};
+
+
+/*
+=================
+FS_PakIsPure
+=================
+*/
+qboolean FS_PakIsPure( pack_t *pack ) {
+	int i;
+
+	if ( fs_numServerPaks ) {
+    // NOTE TTimo we are matching checksums without checking the pak names
+    //   this means you can have the same pk3 as the server under a different name, you will still get through sv_pure validation
+    //   (what happens when two pk3's have the same checkums? is it a likely situation?)
+    //   also, if there's a wrong checksumed pk3 and autodownload is enabled, the checksum will be appended to the downloaded pk3 name
+		for ( i = 0 ; i < fs_numServerPaks ; i++ ) {
+			// FIXME: also use hashed file names
+			if ( pack->checksum == fs_serverPaks[i] ) {
+				return qtrue;		// on the aproved list
+			}
+		}
+		return qfalse;	// not on the pure server pak list
+	}
+	return qtrue;
+}
+
+
+/*
+================
+return a hash value for the filename
+================
+*/
+static long FS_HashFileName( const char *fname, int hashSize ) {
+	int		i;
+	long	hash;
+	char	letter;
+
+	hash = 0;
+	i = 0;
+	while (fname[i] != '\0') {
+		letter = tolower(fname[i]);
+		if (letter =='.') break;				// don't include extension
+		if (letter =='\\') letter = '/';		// damn path names
+		if (letter == PATH_SEP) letter = '/';		// damn path names
+		hash+=(long)(letter)*(i+119);
+		i++;
+	}
+	hash = (hash ^ (hash >> 10) ^ (hash >> 20));
+	hash &= (hashSize-1);
+	return hash;
+}
+
+
+static FILE	*FS_FileForHandle( fileHandle_t f ) {
+	if ( f < 0 || f > MAX_FILE_HANDLES ) {
+		Com_Error( ERR_DROP, "FS_FileForHandle: out of reange" );
+	}
+	if (fsh[f].zipFile == qtrue) {
+		Com_Error( ERR_DROP, "FS_FileForHandle: can't get FILE on zip file" );
+	}
+	if ( ! fsh[f].handleFiles.file.o ) {
+		Com_Error( ERR_DROP, "FS_FileForHandle: NULL" );
+	}
+	
+	return fsh[f].handleFiles.file.o;
+}
+
+
+void	FS_ForceFlush( fileHandle_t f ) {
+	FILE *file;
+
+	file = FS_FileForHandle(f);
+	setvbuf( file, NULL, _IONBF, 0 );
+}
+
+
+/*
+================
+FS_filelength
+
+If this is called on a non-unique FILE (from a pak file),
+it will return the size of the pak file, not the expected
+size of the file.
+================
+*/
+int FS_filelength( fileHandle_t f ) {
+	int		pos;
+	int		end;
+	FILE*	h;
+
+	h = FS_FileForHandle(f);
+	pos = ftell (h);
+	fseek (h, 0, SEEK_END);
+	end = ftell (h);
+	fseek (h, pos, SEEK_SET);
+
+	return end;
+}
+
+/*
+============
+FS_CreatePath
+
+Creates any directories needed to store the given filename
+============
+*/
+qboolean FS_CreatePath (char *OSPath) {
+	char	*ofs;
+	
+	// make absolutely sure that it can't back up the path
+	// FIXME: is c: allowed???
+	if ( strstr( OSPath, ".." ) || strstr( OSPath, "::" ) ) {
+		Com_Printf( "WARNING: refusing to create relative path \"%s\"\n", OSPath );
+		return qtrue;
+	}
+
+	for (ofs = OSPath+1 ; *ofs ; ofs++) {
+		if (*ofs == PATH_SEP) {	
+			// create the directory
+			*ofs = 0;
+			Sys_Mkdir (OSPath);
+			*ofs = PATH_SEP;
+		}
+	}
+	return qfalse;
+}
+
+/*
+=================
+FS_CopyFile
+
+Copy a fully specified file from one place to another
+=================
+*/
+void FS_CopyFile( char *fromOSPath, char *toOSPath ) {
+	FILE	*f;
+	int		len;
+	byte	*buf;
+
+	Com_Printf( "copy %s to %s\n", fromOSPath, toOSPath );
+
+	if (strstr(fromOSPath, "journal.dat") || strstr(fromOSPath, "journaldata.dat")) {
+		Com_Printf( "Ignoring journal files\n");
+		return;
+	}
+
+	f = fopen( fromOSPath, "rb" );
+	if ( !f ) {
+		return;
+	}
+	fseek (f, 0, SEEK_END);
+	len = ftell (f);
+	fseek (f, 0, SEEK_SET);
+
+	// we are using direct malloc instead of Z_Malloc here, so it
+	// probably won't work on a mac... Its only for developers anyway...
+	buf = (unsigned char *)malloc( len );
+	if (fread( buf, 1, len, f ) != len)
+		Com_Error( ERR_FATAL, "Short read in FS_Copyfiles()\n" );
+	fclose( f );
+
+	if( FS_CreatePath( toOSPath ) ) {
+		return;
+	}
+
+	f = fopen( toOSPath, "wb" );
+	if ( !f ) {
+		return;
+	}
+	if (fwrite( buf, 1, len, f ) != len)
+		Com_Error( ERR_FATAL, "Short write in FS_Copyfiles()\n" );
+	fclose( f );
+	free( buf );
+}
+
+/*
+===========
+FS_Remove
+
+===========
+*/
+void FS_Remove( const char *osPath ) {
+	remove( osPath );
+}
+
+/*
+================
+FS_FileExists
+
+Tests if the file exists in the current gamedir, this DOES NOT
+search the paths.  This is to determine if opening a file to write
+(which always goes into the current gamedir) will cause any overwrites.
+NOTE TTimo: this goes with FS_FOpenFileWrite for opening the file afterwards
+================
+*/
+qboolean FS_FileExists( const char *file )
+{
+	FILE *f;
+	char *testpath;
+
+	testpath = FS_BuildOSPath( fs_homepath->string, fs_gamedir, file );
+
+	f = fopen( testpath, "rb" );
+	if (f) {
+		fclose( f );
+		return qtrue;
+	}
+	return qfalse;
+}
+
+/*
+================
+FS_SV_FileExists
+
+Tests if the file exists 
+================
+*/
+qboolean FS_SV_FileExists( const char *file )
+{
+	FILE *f;
+	char *testpath;
+
+	testpath = FS_BuildOSPath( fs_homepath->string, file, "");
+	testpath[strlen(testpath)-1] = '\0';
+
+	f = fopen( testpath, "rb" );
+	if (f) {
+		fclose( f );
+		return qtrue;
+	}
+	return qfalse;
+}
+
+
+/*
+===========
+FS_SV_FOpenFileWrite
+
+===========
+*/
+fileHandle_t FS_SV_FOpenFileWrite( const char *filename ) {
+	char *ospath;
+	fileHandle_t	f;
+
+	if ( !fs_searchpaths ) {
+		Com_Error( ERR_FATAL, "Filesystem call made without initialization\n" );
+	}
+
+	ospath = FS_BuildOSPath( fs_homepath->string, filename, "" );
+	ospath[strlen(ospath)-1] = '\0';
+
+	f = FS_HandleForFile();
+	fsh[f].zipFile = qfalse;
+
+	if ( fs_debug->integer ) {
+		Com_Printf( "FS_SV_FOpenFileWrite: %s\n", ospath );
+	}
+
+	if( FS_CreatePath( ospath ) ) {
+		return 0;
+	}
+
+	Com_DPrintf( "writing to: %s\n", ospath );
+	fsh[f].handleFiles.file.o = fopen( ospath, "wb" );
+
+	Q_strncpyz( fsh[f].name, filename, sizeof( fsh[f].name ) );
+
+	fsh[f].handleSync = qfalse;
+	if (!fsh[f].handleFiles.file.o) {
+		f = 0;
+	}
+	return f;
+}
+
+/*
+===========
+FS_SV_FOpenFileRead
+search for a file somewhere below the home path, base path or cd path
+we search in that order, matching FS_SV_FOpenFileRead order
+===========
+*/
+int FS_SV_FOpenFileRead( const char *filename, fileHandle_t *fp ) {
+	char *ospath;
+	fileHandle_t	f = 0; // bk001129 - from cvs1.17
+
+	if ( !fs_searchpaths ) {
+		Com_Error( ERR_FATAL, "Filesystem call made without initialization\n" );
+	}
+
+	f = FS_HandleForFile();
+	fsh[f].zipFile = qfalse;
+
+	Q_strncpyz( fsh[f].name, filename, sizeof( fsh[f].name ) );
+
+	// don't let sound stutter
+	S_ClearSoundBuffer();
+
+  // search homepath
+	ospath = FS_BuildOSPath( fs_homepath->string, filename, "" );
+	// remove trailing slash
+	ospath[strlen(ospath)-1] = '\0';
+
+	if ( fs_debug->integer ) {
+		Com_Printf( "FS_SV_FOpenFileRead (fs_homepath): %s\n", ospath );
+	}
+
+	fsh[f].handleFiles.file.o = fopen( ospath, "rb" );
+	fsh[f].handleSync = qfalse;
+  if (!fsh[f].handleFiles.file.o)
+  {
+    // NOTE TTimo on non *nix systems, fs_homepath == fs_basepath, might want to avoid
+    if (Q_stricmp(fs_homepath->string,fs_basepath->string))
+    {
+      // search basepath
+      ospath = FS_BuildOSPath( fs_basepath->string, filename, "" );
+      ospath[strlen(ospath)-1] = '\0';
+
+      if ( fs_debug->integer )
+      {
+        Com_Printf( "FS_SV_FOpenFileRead (fs_basepath): %s\n", ospath );
+      }
+
+      fsh[f].handleFiles.file.o = fopen( ospath, "rb" );
+      fsh[f].handleSync = qfalse;
+
+      if ( !fsh[f].handleFiles.file.o )
+      {
+        f = 0;
+      }
+    }
+  }
+
+	if (!fsh[f].handleFiles.file.o) {
+    // search cd path
+    ospath = FS_BuildOSPath( fs_cdpath->string, filename, "" );
+    ospath[strlen(ospath)-1] = '\0';
+
+    if (fs_debug->integer)
+    {
+      Com_Printf( "FS_SV_FOpenFileRead (fs_cdpath) : %s\n", ospath );
+    }
+
+	  fsh[f].handleFiles.file.o = fopen( ospath, "rb" );
+	  fsh[f].handleSync = qfalse;
+
+	  if( !fsh[f].handleFiles.file.o ) {
+	    f = 0;
+	  }
+  }
+  
+	*fp = f;
+	if (f) {
+		return FS_filelength(f);
+	}
+	return 0;
+}
+
+/*
+===========
+FS_SV_Rename
+
+===========
+*/
+void FS_SV_Rename( const char *from, const char *to ) {
+	char			*from_ospath, *to_ospath;
+
+	if ( !fs_searchpaths ) {
+		Com_Error( ERR_FATAL, "Filesystem call made without initialization\n" );
+	}
+
+	// don't let sound stutter
+	S_ClearSoundBuffer();
+
+	from_ospath = FS_BuildOSPath( fs_homepath->string, from, "" );
+	to_ospath = FS_BuildOSPath( fs_homepath->string, to, "" );
+	from_ospath[strlen(from_ospath)-1] = '\0';
+	to_ospath[strlen(to_ospath)-1] = '\0';
+
+	if ( fs_debug->integer ) {
+		Com_Printf( "FS_SV_Rename: %s --> %s\n", from_ospath, to_ospath );
+	}
+
+	if (rename( from_ospath, to_ospath )) {
+		// Failed, try copying it and deleting the original
+		FS_CopyFile ( from_ospath, to_ospath );
+		FS_Remove ( from_ospath );
+	}
+}
+
+/*
+===========
+FS_Rename
+
+===========
+*/
+void FS_Rename( const char *from, const char *to ) {
+	char			*from_ospath, *to_ospath;
+
+	if ( !fs_searchpaths ) {
+		Com_Error( ERR_FATAL, "Filesystem call made without initialization\n" );
+	}
+
+	// don't let sound stutter
+	S_ClearSoundBuffer();
+
+	from_ospath = FS_BuildOSPath( fs_homepath->string, fs_gamedir, from );
+	to_ospath = FS_BuildOSPath( fs_homepath->string, fs_gamedir, to );
+
+	if ( fs_debug->integer ) {
+		Com_Printf( "FS_Rename: %s --> %s\n", from_ospath, to_ospath );
+	}
+
+	if (rename( from_ospath, to_ospath )) {
+		// Failed, try copying it and deleting the original
+		FS_CopyFile ( from_ospath, to_ospath );
+		FS_Remove ( from_ospath );
+	}
+}
+
+/*
+==============
+FS_FCloseFile
+
+If the FILE pointer is an open pak file, leave it open.
+
+For some reason, other dll's can't just cal fclose()
+on files returned by FS_FOpenFile...
+==============
+*/
+void FS_FCloseFile( fileHandle_t f ) {
+	if ( !fs_searchpaths ) {
+		Com_Error( ERR_FATAL, "Filesystem call made without initialization\n" );
+	}
+
+	if (fsh[f].streamed) {
+		Sys_EndStreamedFile(f);
+	}
+	if (fsh[f].zipFile == qtrue) {
+		unzCloseCurrentFile( fsh[f].handleFiles.file.z );
+		if ( fsh[f].handleFiles.unique ) {
+			unzClose( fsh[f].handleFiles.file.z );
+		}
+		Com_Memset( &fsh[f], 0, sizeof( fsh[f] ) );
+		return;
+	}
+
+	// we didn't find it as a pak, so close it as a unique file
+	if (fsh[f].handleFiles.file.o) {
+		fclose (fsh[f].handleFiles.file.o);
+	}
+	Com_Memset( &fsh[f], 0, sizeof( fsh[f] ) );
+}
+
+/*
+===========
+FS_FOpenFileWrite
+
+===========
+*/
+fileHandle_t FS_FOpenFileWrite( const char *filename ) {
+	char			*ospath;
+	fileHandle_t	f;
+
+	if ( !fs_searchpaths ) {
+		Com_Error( ERR_FATAL, "Filesystem call made without initialization\n" );
+	}
+
+	f = FS_HandleForFile();
+	fsh[f].zipFile = qfalse;
+
+	ospath = FS_BuildOSPath( fs_homepath->string, fs_gamedir, filename );
+
+	if ( fs_debug->integer ) {
+		Com_Printf( "FS_FOpenFileWrite: %s\n", ospath );
+	}
+
+	if( FS_CreatePath( ospath ) ) {
+		return 0;
+	}
+
+	// enabling the following line causes a recursive function call loop
+	// when running with +set logfile 1 +set developer 1
+	//Com_DPrintf( "writing to: %s\n", ospath );
+	fsh[f].handleFiles.file.o = fopen( ospath, "wb" );
+
+	Q_strncpyz( fsh[f].name, filename, sizeof( fsh[f].name ) );
+
+	fsh[f].handleSync = qfalse;
+	if (!fsh[f].handleFiles.file.o) {
+		f = 0;
+	}
+	return f;
+}
+
+/*
+===========
+FS_FOpenFileAppend
+
+===========
+*/
+fileHandle_t FS_FOpenFileAppend( const char *filename ) {
+	char			*ospath;
+	fileHandle_t	f;
+
+	if ( !fs_searchpaths ) {
+		Com_Error( ERR_FATAL, "Filesystem call made without initialization\n" );
+	}
+
+	f = FS_HandleForFile();
+	fsh[f].zipFile = qfalse;
+
+	Q_strncpyz( fsh[f].name, filename, sizeof( fsh[f].name ) );
+
+	// don't let sound stutter
+	S_ClearSoundBuffer();
+
+	ospath = FS_BuildOSPath( fs_homepath->string, fs_gamedir, filename );
+
+	if ( fs_debug->integer ) {
+		Com_Printf( "FS_FOpenFileAppend: %s\n", ospath );
+	}
+
+	if( FS_CreatePath( ospath ) ) {
+		return 0;
+	}
+
+	fsh[f].handleFiles.file.o = fopen( ospath, "ab" );
+	fsh[f].handleSync = qfalse;
+	if (!fsh[f].handleFiles.file.o) {
+		f = 0;
+	}
+	return f;
+}
+
+#ifdef NOTHERE
+bool Sys_GetFileTime(LPCSTR psFileName, FILETIME &ft)
+{
+	bool bSuccess = false;
+	HANDLE hFile = INVALID_HANDLE_VALUE;	
+
+	hFile = CreateFile(	psFileName,	// LPCTSTR lpFileName,          // pointer to name of the file
+						GENERIC_READ,			// DWORD dwDesiredAccess,       // access (read-write) mode
+						FILE_SHARE_READ,		// DWORD dwShareMode,           // share mode
+						NULL,					// LPSECURITY_ATTRIBUTES lpSecurityAttributes,	// pointer to security attributes
+						OPEN_EXISTING,			// DWORD dwCreationDisposition,  // how to create
+						FILE_FLAG_NO_BUFFERING,// DWORD dwFlagsAndAttributes,   // file attributes
+						NULL					// HANDLE hTemplateFile          // handle to file with attributes to 
+						);
+
+	if (hFile != INVALID_HANDLE_VALUE)
+	{			
+		if (GetFileTime(hFile,	// handle to file
+						NULL,	// LPFILETIME lpCreationTime
+						NULL,	// LPFILETIME lpLastAccessTime
+						&ft		// LPFILETIME lpLastWriteTime
+						)
+			)
+		{
+			bSuccess = true;
+		}
+
+		CloseHandle(hFile);
+	}
+
+	return bSuccess;
+}
+
+
+bool Sys_FileOutOfDate( LPCSTR psFinalFileName /* dest */, LPCSTR psDataFileName /* src */ )
+{
+	_FILETIME ftFinalFile, ftDataFile;
+
+	if (Sys_GetFileTime(psFinalFileName, ftFinalFile) && Sys_GetFileTime(psDataFileName, ftDataFile))
+	{
+		// timer res only accurate to within 2 seconds on FAT, so can't do exact compare...
+		//
+		//LONG l = CompareFileTime( &ftFinalFile, &ftDataFile );
+		if (  (abs(ftFinalFile.dwLowDateTime - ftDataFile.dwLowDateTime) <= 20000000 ) &&
+				  ftFinalFile.dwHighDateTime == ftDataFile.dwHighDateTime				
+			)
+		{
+			return false;	// file not out of date, ie use it.
+		}
+		return true;	// flag return code to copy over a replacement version of this file
+	}
+
+
+	// extra error check, report as suspicious if you find a file locally but not out on the net.,.
+	//
+	if (com_developer->integer)
+	{
+		if (!Sys_GetFileTime(psDataFileName, ftDataFile))
+		{
+			Com_Printf( "Sys_FileOutOfDate: reading %s but it's not on the net!\n", psFinalFileName);
+		}
+	}
+
+	return false;
+}
+
+#endif 
+bool FS_FileCacheable(const char* const filename) 
+{
+	extern	cvar_t	*com_buildScript;
+	if (com_buildScript && com_buildScript->integer)
+	{ 
+		return true;
+	}
+	return( strchr(filename, '/') != 0 );
+}
+
+/*
+===========
+FS_ShiftedStrStr
+===========
+*/
+char *FS_ShiftedStrStr(const char *string, const char *substring, int shift) {
+	char buf[MAX_STRING_TOKENS];
+	int i;
+
+	for (i = 0; substring[i]; i++) {
+		buf[i] = substring[i] + shift;
+	}
+	buf[i] = '\0';
+	return strstr(string, buf);
+}
+
+/*
+===========
+FS_FOpenFileRead
+
+Finds the file in the search path.
+Returns filesize and an open FILE pointer.
+Used for streaming data out of either a
+separate file or a ZIP file.
+===========
+*/
+extern qboolean		com_fullyInitialized;
+
+int FS_FOpenFileRead( const char *filename, fileHandle_t *file, qboolean uniqueFILE ) {
+	searchpath_t	*search;
+	char			*netpath;
+	pack_t			*pak;
+	fileInPack_t	*pakFile;
+	directory_t		*dir;
+	long			hash;
+	unz_s			*zfi;
+	ZIP_FILE		*temp;
+	int				l;
+	char demoExt[16];
+
+	hash = 0;
+
+	if ( !fs_searchpaths ) {
+		Com_Error( ERR_FATAL, "Filesystem call made without initialization\n" );
+	}
+
+	if ( file == NULL ) {
+		Com_Error( ERR_FATAL, "FS_FOpenFileRead: NULL 'file' parameter passed\n" );
+	}
+
+	if ( !filename ) {
+		Com_Error( ERR_FATAL, "FS_FOpenFileRead: NULL 'filename' parameter passed\n" );
+	}
+
+	Com_sprintf (demoExt, sizeof(demoExt), ".dm_%d",PROTOCOL_VERSION );
+	// qpaths are not supposed to have a leading slash
+	if ( filename[0] == '/' || filename[0] == '\\' ) {
+		filename++;
+	}
+
+	// make absolutely sure that it can't back up the path.
+	// The searchpaths do guarantee that something will always
+	// be prepended, so we don't need to worry about "c:" or "//limbo" 
+	if ( strstr( filename, ".." ) || strstr( filename, "::" ) ) {
+		*file = 0;
+		return -1;
+	}
+
+	// make sure the q3key file is only readable by the quake3.exe at initialization
+	// any other time the key should only be accessed in memory using the provided functions
+	if( com_fullyInitialized && strstr( filename, "q3key" ) ) {
+		*file = 0;
+		return -1;
+	}
+
+	//
+	// search through the path, one element at a time
+	//
+
+	*file = FS_HandleForFile();
+	fsh[*file].handleFiles.unique = uniqueFILE;
+
+	// this new bool is in for an optimisation, if you (eg) opened a BSP file under fs_copyfiles==2,
+	//	then it triggered a copy operation to update your local HD version, then this will re-open the
+	//	file handle on your local version, not the net build. This uses a bit more CPU to re-do the loop
+	//	logic, but should read faster than accessing the net version a second time.
+	//
+	qboolean bFasterToReOpenUsingNewLocalFile = qfalse;
+
+	do
+	{
+		bFasterToReOpenUsingNewLocalFile = qfalse;
+
+		for ( search = fs_searchpaths ; search ; search = search->next ) {
+			//
+			if ( search->pack ) {
+				hash = FS_HashFileName(filename, search->pack->hashSize);
+			}
+			// is the element a pak file?
+			if ( search->pack && search->pack->hashTable[hash] ) {
+				// disregard if it doesn't match one of the allowed pure pak files
+				if ( !FS_PakIsPure(search->pack) ) {
+					continue;
+				}
+
+				// look through all the pak file elements
+				pak = search->pack;
+				pakFile = pak->hashTable[hash];
+				do {
+					// case and separator insensitive comparisons
+					if ( !FS_FilenameCompare( pakFile->name, filename ) ) {
+						// found it!
+
+						// mark the pak as having been referenced and mark specifics on cgame and ui
+						// shaders, txt, arena files  by themselves do not count as a reference as 
+						// these are loaded from all pk3s 
+						// from every pk3 file.. 
+						l = strlen( filename );
+						if ( !(pak->referenced & FS_GENERAL_REF)) {
+							if ( Q_stricmp(filename + l - 7, ".shader") != 0 &&
+								Q_stricmp(filename + l - 4, ".txt") != 0 &&
+								Q_stricmp(filename + l - 4, ".str") != 0 &&
+								Q_stricmp(filename + l - 4, ".cfg") != 0 &&
+								Q_stricmp(filename + l - 4, ".fcf") != 0 &&
+								Q_stricmp(filename + l - 7, ".config") != 0 &&
+								strstr(filename, "levelshots") == NULL &&
+								Q_stricmp(filename + l - 4, ".bot") != 0 &&
+								Q_stricmp(filename + l - 6, ".arena") != 0 &&
+								Q_stricmp(filename + l - 5, ".menu") != 0) {
+								pak->referenced |= FS_GENERAL_REF;
+							}
+						}
+
+						/*
+						FS_ShiftedStrStr(filename, "jampgamex86.dll", -13);
+												  //]^&`cZT`Xk+)!W__
+						FS_ShiftedStrStr(filename, "cgamex86.dll", -7);
+												  //\`Zf^q1/']ee
+						FS_ShiftedStrStr(filename, "uix86.dll", -5);
+												  //pds31)_gg
+						*/
+
+						// jampgame.qvm	- 13
+						// ]^&`cZT`X!di`
+						if (!(pak->referenced & FS_QAGAME_REF))
+						{
+							if (FS_ShiftedStrStr(filename, "]T`cZT`X!di`", 13) ||
+								FS_ShiftedStrStr(filename, "]T`cZT`Xk+)!W__", 13))
+							{
+								pak->referenced |= FS_QAGAME_REF;
+							}
+						}
+						// cgame.qvm	- 7
+						// \`Zf^'jof
+						if (!(pak->referenced & FS_CGAME_REF))
+						{
+							if (FS_ShiftedStrStr(filename , "\\`Zf^'jof", 7) ||
+								FS_ShiftedStrStr(filename , "\\`Zf^q1/']ee", 7))
+							{
+								pak->referenced |= FS_CGAME_REF;
+							}
+						}
+						// ui.qvm		- 5
+						// pd)lqh
+						if (!(pak->referenced & FS_UI_REF))
+						{
+							if (FS_ShiftedStrStr(filename , "pd)lqh", 5) ||
+								FS_ShiftedStrStr(filename , "pds31)_gg", 5))
+							{
+								pak->referenced |= FS_UI_REF;
+							}
+						}
+
+						if ( uniqueFILE ) {
+							// open a new file on the pakfile
+							fsh[*file].handleFiles.file.z = unzReOpen (pak->pakFilename, pak->handle);
+							if (fsh[*file].handleFiles.file.z == NULL) {
+								Com_Error (ERR_FATAL, "Couldn't reopen %s", pak->pakFilename);
+							}
+						} else {
+							fsh[*file].handleFiles.file.z = pak->handle;
+						}
+						Q_strncpyz( fsh[*file].name, filename, sizeof( fsh[*file].name ) );
+						fsh[*file].zipFile = qtrue;
+						zfi = (unz_s *)fsh[*file].handleFiles.file.z;
+						// in case the file was new
+						temp = zfi->file;
+						// set the file position in the zip file (also sets the current file info)
+						unzSetCurrentFileInfoPosition(pak->handle, pakFile->pos);
+						// copy the file info into the unzip structure
+						Com_Memcpy( zfi, pak->handle, sizeof(unz_s) );
+						// we copy this back into the structure
+						zfi->file = temp;
+						// open the file in the zip
+						unzOpenCurrentFile( fsh[*file].handleFiles.file.z );
+						fsh[*file].zipFilePos = pakFile->pos;
+
+						if ( fs_debug->integer ) {
+							Com_Printf( "FS_FOpenFileRead: %s (found in '%s')\n", 
+								filename, pak->pakFilename );
+						}
+	#ifndef DEDICATED
+	#ifndef FINAL_BUILD
+						// Check for unprecached files when in game but not in the menus
+						if((cls.state == CA_ACTIVE) && !(cls.keyCatchers & KEYCATCH_UI))
+						{
+							Com_Printf(S_COLOR_YELLOW "WARNING: File %s not precached\n", filename);
+						}
+	#endif
+	#endif // DEDICATED
+						return zfi->cur_file_info.uncompressed_size;
+					}
+					pakFile = pakFile->next;
+				} while(pakFile != NULL);
+			} else if ( search->dir ) {
+				// check a file in the directory tree
+
+				// if we are running restricted, the only files we
+				// will allow to come from the directory are .cfg files
+				l = strlen( filename );
+		  // FIXME TTimo I'm not sure about the fs_numServerPaks test
+		  // if you are using FS_ReadFile to find out if a file exists,
+		  //   this test can make the search fail although the file is in the directory
+		  // I had the problem on https://zerowing.idsoftware.com/bugzilla/show_bug.cgi?id=8
+		  // turned out I used FS_FileExists instead
+				if ( fs_restrict->integer || fs_numServerPaks ) {
+
+					if ( Q_stricmp( filename + l - 4, ".cfg" )		// for config files
+						&& Q_stricmp( filename + l - 4, ".fcf" )	// force configuration files
+						&& Q_stricmp( filename + l - 5, ".menu" )	// menu files
+						&& Q_stricmp( filename + l - 5, ".game" )	// menu files
+						&& Q_stricmp( filename + l - strlen(demoExt), demoExt )	// menu files
+						&& Q_stricmp( filename + l - 4, ".dat" ) ) {	// for journal files
+						continue;
+					}
+				}
+
+				dir = search->dir;
+				
+				netpath = FS_BuildOSPath( dir->path, dir->gamedir, filename );
+				fsh[*file].handleFiles.file.o = fopen (netpath, "rb");
+				if ( !fsh[*file].handleFiles.file.o ) {
+					continue;
+				}
+
+				if ( Q_stricmp( filename + l - 4, ".cfg" )		// for config files
+					&& Q_stricmp( filename + l - 4, ".fcf" )	// force configuration files
+					&& Q_stricmp( filename + l - 5, ".menu" )	// menu files
+					&& Q_stricmp( filename + l - 5, ".game" )	// menu files
+					&& Q_stricmp( filename + l - strlen(demoExt), demoExt )	// menu files
+					&& Q_stricmp( filename + l - 4, ".dat" ) ) {	// for journal files
+					fs_fakeChkSum = random();
+				}
+			
+#ifndef DEDICATED	
+				// if running with fs_copyfiles 2, and search path == local, then we need to fail to open
+				//	if the time/date stamp != the network version (so it'll loop round again and use the network path,
+				//	which comes later in the search order)
+				//
+				if ( fs_copyfiles->integer == 2 && fs_cdpath->string[0] && !Q_stricmp( dir->path, fs_basepath->string ) 
+					&& FS_FileCacheable(filename) )
+				{
+					if ( Sys_FileOutOfDate( netpath, FS_BuildOSPath( fs_cdpath->string, dir->gamedir, filename ) ))
+					{
+						fclose(fsh[*file].handleFiles.file.o);
+						fsh[*file].handleFiles.file.o = 0;
+						continue;	//carry on to find the cdpath version.
+					}
+				}      
+#endif
+				Q_strncpyz( fsh[*file].name, filename, sizeof( fsh[*file].name ) );
+				fsh[*file].zipFile = qfalse;
+				if ( fs_debug->integer ) {
+					Com_Printf( "FS_FOpenFileRead: %s (found in '%s/%s')\n", filename,
+						dir->path, dir->gamedir );
+				}
+
+#ifndef DEDICATED
+				// if we are getting it from the cdpath, optionally copy it
+				//  to the basepath
+				if ( fs_copyfiles->integer && !Q_stricmp( dir->path, fs_cdpath->string ) ) {
+					char	*copypath;
+
+					copypath = FS_BuildOSPath( fs_basepath->string, dir->gamedir, filename );
+					switch ( fs_copyfiles->integer )
+					{
+						default:
+						case 1:
+						{
+							FS_CopyFile( netpath, copypath );
+						}
+						break;
+
+						case 2:
+						{
+					
+							if (FS_FileCacheable(filename) )
+							{
+								// maybe change this to Com_DPrintf?   On the other hand...
+								//
+								Com_Printf( "fs_copyfiles(2), Copying: %s to %s\n", netpath, copypath );
+								
+								FS_CreatePath( copypath );
+
+								bool bOk = true;
+								if (!CopyFile( netpath, copypath, FALSE ))
+								{
+									DWORD dwAttrs = GetFileAttributes(copypath);
+									SetFileAttributes(copypath, dwAttrs & ~FILE_ATTRIBUTE_READONLY);
+									bOk = !!CopyFile( netpath, copypath, FALSE );
+								}
+
+								if (bOk)
+								{
+									// clear this handle and setup for re-opening of the new local copy...
+									//
+									bFasterToReOpenUsingNewLocalFile = qtrue;
+									fclose(fsh[*file].handleFiles.file.o);
+									fsh[*file].handleFiles.file.o = NULL;
+								}
+							}
+						}
+						break;
+					}
+				}
+#endif 
+				if (bFasterToReOpenUsingNewLocalFile)
+				{
+					break;	// and re-read the local copy, not the net version
+				}
+
+	#ifndef DEDICATED
+	#ifndef FINAL_BUILD
+				// Check for unprecached files when in game but not in the menus
+				if((cls.state == CA_ACTIVE) && !(cls.keyCatchers & KEYCATCH_UI))
+				{
+					Com_Printf(S_COLOR_YELLOW "WARNING: File %s not precached\n", filename);
+				}
+	#endif
+	#endif // dedicated
+				return FS_filelength (*file);
+			}		
+		}
+	}
+	while ( bFasterToReOpenUsingNewLocalFile );
+	
+	Com_DPrintf ("Can't find %s\n", filename);
+#ifdef FS_MISSING
+	if (missingFiles) {
+		fprintf(missingFiles, "%s\n", filename);
+	}
+#endif
+	*file = 0;
+	return -1;
+}
+
+
+/*
+=================
+FS_Read
+
+Properly handles partial reads
+=================
+*/
+int FS_Read2( void *buffer, int len, fileHandle_t f ) {
+	if ( !fs_searchpaths ) {
+		Com_Error( ERR_FATAL, "Filesystem call made without initialization\n" );
+	}
+
+	if ( !f ) {
+		return 0;
+	}
+	if (fsh[f].streamed) {
+		int r;
+		fsh[f].streamed = qfalse;
+		r = Sys_StreamedRead( buffer, len, 1, f);
+		fsh[f].streamed = qtrue;
+		return r;
+	} else {
+		return FS_Read( buffer, len, f);
+	}
+}
+
+int FS_Read( void *buffer, int len, fileHandle_t f ) {
+	int		block, remaining;
+	int		read;
+	byte	*buf;
+	int		tries;
+
+	if ( !fs_searchpaths ) {
+		Com_Error( ERR_FATAL, "Filesystem call made without initialization\n" );
+	}
+
+	if ( !f ) {
+		return 0;
+	}
+
+	buf = (byte *)buffer;
+	fs_readCount += len;
+
+	if (fsh[f].zipFile == qfalse) {
+		remaining = len;
+		tries = 0;
+		while (remaining) {
+			block = remaining;
+			read = fread (buf, 1, block, fsh[f].handleFiles.file.o);
+			if (read == 0) {
+				// we might have been trying to read from a CD, which
+				// sometimes returns a 0 read on windows
+				if (!tries) {
+					tries = 1;
+				} else {
+					return len-remaining;	//Com_Error (ERR_FATAL, "FS_Read: 0 bytes read");
+				}
+			}
+
+			if (read == -1) {
+				Com_Error (ERR_FATAL, "FS_Read: -1 bytes read");
+			}
+
+			remaining -= read;
+			buf += read;
+		}
+		return len;
+	} else {
+		return unzReadCurrentFile(fsh[f].handleFiles.file.z, buffer, len);
+	}
+}
+
+/*
+=================
+FS_Write
+
+Properly handles partial writes
+=================
+*/
+int FS_Write( const void *buffer, int len, fileHandle_t h ) {
+	int		block, remaining;
+	int		written;
+	byte	*buf;
+	int		tries;
+	FILE	*f;
+
+	if ( !fs_searchpaths ) {
+		Com_Error( ERR_FATAL, "Filesystem call made without initialization\n" );
+	}
+
+	if ( !h ) {
+		return 0;
+	}
+
+	f = FS_FileForHandle(h);
+	buf = (byte *)buffer;
+
+	remaining = len;
+	tries = 0;
+	while (remaining) {
+		block = remaining;
+		written = fwrite (buf, 1, block, f);
+		if (written == 0) {
+			if (!tries) {
+				tries = 1;
+			} else {
+				Com_Printf( "FS_Write: 0 bytes written\n" );
+				return 0;
+			}
+		}
+
+		if (written == -1) {
+			Com_Printf( "FS_Write: -1 bytes written\n" );
+			return 0;
+		}
+
+		remaining -= written;
+		buf += written;
+	}
+	if ( fsh[h].handleSync ) {
+		fflush( f );
+	}
+	return len;
+}
+
+/*
+=================
+FS_Seek
+
+=================
+*/
+int FS_Seek( fileHandle_t f, long offset, int origin ) {
+	int		_origin;
+	char	foo[65536];
+
+	if ( !fs_searchpaths ) {
+		Com_Error( ERR_FATAL, "Filesystem call made without initialization\n" );
+		return -1;
+	}
+
+	if (fsh[f].streamed) {
+		fsh[f].streamed = qfalse;
+		Sys_StreamSeek( f, offset, origin );
+		fsh[f].streamed = qtrue;
+	}
+
+	if (fsh[f].zipFile == qtrue) {
+		if (offset == 0 && origin == FS_SEEK_SET) {
+			// set the file position in the zip file (also sets the current file info)
+			unzSetCurrentFileInfoPosition(fsh[f].handleFiles.file.z, fsh[f].zipFilePos);
+			return unzOpenCurrentFile(fsh[f].handleFiles.file.z);
+		} else if (offset<65536) {
+			// set the file position in the zip file (also sets the current file info)
+			unzSetCurrentFileInfoPosition(fsh[f].handleFiles.file.z, fsh[f].zipFilePos);
+			unzOpenCurrentFile(fsh[f].handleFiles.file.z);
+			return FS_Read(foo, offset, f);
+		} else {
+			Com_Error( ERR_FATAL, "ZIP FILE FSEEK NOT YET IMPLEMENTED\n" );
+			return -1;
+		}
+	} else {
+		FILE *file;
+		file = FS_FileForHandle(f);
+		switch( origin ) {
+		case FS_SEEK_CUR:
+			_origin = SEEK_CUR;
+			break;
+		case FS_SEEK_END:
+			_origin = SEEK_END;
+			break;
+		case FS_SEEK_SET:
+			_origin = SEEK_SET;
+			break;
+		default:
+			_origin = SEEK_CUR;
+			Com_Error( ERR_FATAL, "Bad origin in FS_Seek\n" );
+			break;
+		}
+
+		return fseek( file, offset, _origin );
+	}
+}
+
+/*
+======================================================================================
+
+CONVENIENCE FUNCTIONS FOR ENTIRE FILES
+
+======================================================================================
+*/
+
+int	FS_FileIsInPAK(const char *filename, int *pChecksum ) {
+	searchpath_t	*search;
+	pack_t			*pak;
+	fileInPack_t	*pakFile;
+	long			hash = 0;
+
+	if ( !fs_searchpaths ) {
+		Com_Error( ERR_FATAL, "Filesystem call made without initialization\n" );
+	}
+
+	if ( !filename ) {
+		Com_Error( ERR_FATAL, "FS_FOpenFileRead: NULL 'filename' parameter passed\n" );
+	}
+
+	// qpaths are not supposed to have a leading slash
+	if ( filename[0] == '/' || filename[0] == '\\' ) {
+		filename++;
+	}
+
+	// make absolutely sure that it can't back up the path.
+	// The searchpaths do guarantee that something will always
+	// be prepended, so we don't need to worry about "c:" or "//limbo" 
+	if ( strstr( filename, ".." ) || strstr( filename, "::" ) ) {
+		return -1;
+	}
+
+	//
+	// search through the path, one element at a time
+	//
+
+	for ( search = fs_searchpaths ; search ; search = search->next ) {
+		//
+		if (search->pack) {
+			hash = FS_HashFileName(filename, search->pack->hashSize);
+		}
+		// is the element a pak file?
+		if ( search->pack && search->pack->hashTable[hash] ) {
+			// disregard if it doesn't match one of the allowed pure pak files
+			if ( !FS_PakIsPure(search->pack) ) {
+				continue;
+			}
+
+			// look through all the pak file elements
+			pak = search->pack;
+			pakFile = pak->hashTable[hash];
+			do {
+				// case and separator insensitive comparisons
+				if ( !FS_FilenameCompare( pakFile->name, filename ) ) {
+					if (pChecksum) {
+						*pChecksum = pak->pure_checksum;
+					}
+					return 1;
+				}
+				pakFile = pakFile->next;
+			} while(pakFile != NULL);
+		}
+	}
+	return -1;
+}
+
+/*
+============
+FS_ReadFile
+
+Filename are relative to the quake search path
+a null buffer will just return the file length without loading
+============
+*/
+int FS_ReadFile( const char *qpath, void **buffer ) {
+	fileHandle_t	h;
+	byte*			buf;
+	qboolean		isConfig;
+	int				len;
+
+	if ( !fs_searchpaths ) {
+		Com_Error( ERR_FATAL, "Filesystem call made without initialization\n" );
+	}
+
+	if ( !qpath || !qpath[0] ) {
+		Com_Error( ERR_FATAL, "FS_ReadFile with empty name\n" );
+	}
+
+	buf = NULL;	// quiet compiler warning
+
+	// if this is a .cfg file and we are playing back a journal, read
+	// it from the journal file
+	if ( strstr( qpath, ".cfg" ) ) {
+		isConfig = qtrue;
+		if ( com_journal && com_journal->integer == 2 ) {
+			int		r;
+
+			Com_DPrintf( "Loading %s from journal file.\n", qpath );
+			r = FS_Read( &len, sizeof( len ), com_journalDataFile );
+			if ( r != sizeof( len ) ) {
+				if (buffer != NULL) *buffer = NULL;
+				return -1;
+			}
+			// if the file didn't exist when the journal was created
+			if (!len) {
+				if (buffer == NULL) {
+					return 1;			// hack for old journal files
+				}
+				*buffer = NULL;
+				return -1;
+			}
+			if (buffer == NULL) {
+				return len;
+			}
+
+			buf = (unsigned char *)Hunk_AllocateTempMemory(len+1);
+			*buffer = buf;
+
+			r = FS_Read( buf, len, com_journalDataFile );
+			if ( r != len ) {
+				Com_Error( ERR_FATAL, "Read from journalDataFile failed" );
+			}
+
+			fs_loadCount++;
+			fs_loadStack++;
+
+			// guarantee that it will have a trailing 0 for string operations
+			buf[len] = 0;
+
+			return len;
+		}
+	} else {
+		isConfig = qfalse;
+	}
+
+	// look for it in the filesystem or pack files
+	len = FS_FOpenFileRead( qpath, &h, qfalse );
+	if ( h == 0 ) {
+		if ( buffer ) {
+			*buffer = NULL;
+		}
+		// if we are journalling and it is a config file, write a zero to the journal file
+		if ( isConfig && com_journal && com_journal->integer == 1 ) {
+			Com_DPrintf( "Writing zero for %s to journal file.\n", qpath );
+			len = 0;
+			FS_Write( &len, sizeof( len ), com_journalDataFile );
+			FS_Flush( com_journalDataFile );
+		}
+		return -1;
+	}
+	
+	if ( !buffer ) {
+		if ( isConfig && com_journal && com_journal->integer == 1 ) {
+			Com_DPrintf( "Writing len for %s to journal file.\n", qpath );
+			FS_Write( &len, sizeof( len ), com_journalDataFile );
+			FS_Flush( com_journalDataFile );
+		}
+		FS_FCloseFile( h);
+		return len;
+	}
+
+	fs_loadCount++;
+/*	fs_loadStack++;
+
+	buf = (unsigned char *)Hunk_AllocateTempMemory(len+1);
+	*buffer = buf;*/
+
+	buf = (byte*)Z_Malloc( len+1, TAG_FILESYS, qfalse);
+	buf[len]='\0';	// because we're not calling Z_Malloc with optional trailing 'bZeroIt' bool
+	*buffer = buf;	
+
+//	Z_Label(buf, qpath);
+
+	FS_Read (buf, len, h);
+
+	// guarantee that it will have a trailing 0 for string operations
+	buf[len] = 0;
+	FS_FCloseFile( h );
+
+	// if we are journalling and it is a config file, write it to the journal file
+	if ( isConfig && com_journal && com_journal->integer == 1 ) {
+		Com_DPrintf( "Writing %s to journal file.\n", qpath );
+		FS_Write( &len, sizeof( len ), com_journalDataFile );
+		FS_Write( buf, len, com_journalDataFile );
+		FS_Flush( com_journalDataFile );
+	}
+	return len;
+}
+
+/*
+=============
+FS_FreeFile
+=============
+*/
+void FS_FreeFile( void *buffer ) {
+	/*	
+	if ( !fs_searchpaths ) {
+		Com_Error( ERR_FATAL, "Filesystem call made without initialization\n" );
+	}
+	if ( !buffer ) {
+		Com_Error( ERR_FATAL, "FS_FreeFile( NULL )" );
+	}
+	fs_loadStack--;
+
+	Hunk_FreeTempMemory( buffer );
+
+	// if all of our temp files are free, clear all of our space
+	if ( fs_loadStack == 0 ) {
+		Hunk_ClearTempMemory();
+	}
+	*/
+
+	if ( !fs_searchpaths ) {
+		Com_Error( ERR_FATAL, "Filesystem call made without initialization\n" );
+	}
+	if ( !buffer ) {
+		Com_Error( ERR_FATAL, "FS_FreeFile( NULL )" );
+	}
+
+	Z_Free( buffer );
+}
+
+/*
+==========================================================================
+
+ZIP FILE LOADING
+
+==========================================================================
+*/
+
+/*
+=================
+FS_LoadZipFile
+
+Creates a new pak_t in the search chain for the contents
+of a zip file.
+=================
+*/
+static pack_t *FS_LoadZipFile( char *zipfile, const char *basename )
+{
+	fileInPack_t	*buildBuffer;
+	pack_t			*pack;
+	unzFile			uf;
+	int				err;
+	unz_global_info gi;
+	char			filename_inzip[MAX_ZPATH];
+	unz_file_info	file_info;
+	int				i, len;
+	long			hash;
+	int				fs_numHeaderLongs;
+	int				*fs_headerLongs;
+	char			*namePtr;
+
+	fs_numHeaderLongs = 0;
+
+	uf = unzOpen(zipfile);
+	err = unzGetGlobalInfo (uf,&gi);
+
+	if (err != UNZ_OK)
+		return NULL;
+
+	fs_packFiles += gi.number_entry;
+
+	len = 0;
+	unzGoToFirstFile(uf);
+	for (i = 0; i < gi.number_entry; i++)
+	{
+		err = unzGetCurrentFileInfo(uf, &file_info, filename_inzip, sizeof(filename_inzip), NULL, 0, NULL, 0);
+		if (err != UNZ_OK) {
+			break;
+		}
+		len += strlen(filename_inzip) + 1;
+		unzGoToNextFile(uf);
+	}
+
+	buildBuffer = (struct fileInPack_s *)Z_Malloc( (gi.number_entry * sizeof( fileInPack_t )) + len, TAG_FILESYS, qtrue );
+	namePtr = ((char *) buildBuffer) + gi.number_entry * sizeof( fileInPack_t );
+	fs_headerLongs = (int *)Z_Malloc( gi.number_entry * sizeof(int), TAG_FILESYS, qtrue );
+
+	// get the hash table size from the number of files in the zip
+	// because lots of custom pk3 files have less than 32 or 64 files
+	for (i = 1; i <= MAX_FILEHASH_SIZE; i <<= 1) {
+		if (i > gi.number_entry) {
+			break;
+		}
+	}
+
+	pack = (pack_t *)Z_Malloc( sizeof( pack_t ) + i * sizeof(fileInPack_t *), TAG_FILESYS, qtrue );
+	pack->hashSize = i;
+	pack->hashTable = (fileInPack_t **) (((char *) pack) + sizeof( pack_t ));
+	for(i = 0; i < pack->hashSize; i++) {
+		pack->hashTable[i] = NULL;
+	}
+
+	Q_strncpyz( pack->pakFilename, zipfile, sizeof( pack->pakFilename ) );
+	Q_strncpyz( pack->pakBasename, basename, sizeof( pack->pakBasename ) );
+
+	// strip .pk3 if needed
+	if ( strlen( pack->pakBasename ) > 4 && !Q_stricmp( pack->pakBasename + strlen( pack->pakBasename ) - 4, ".pk3" ) ) {
+		pack->pakBasename[strlen( pack->pakBasename ) - 4] = 0;
+	}
+
+	pack->handle = uf;
+	pack->numfiles = gi.number_entry;
+	unzGoToFirstFile(uf);
+
+	for (i = 0; i < gi.number_entry; i++)
+	{
+		err = unzGetCurrentFileInfo(uf, &file_info, filename_inzip, sizeof(filename_inzip), NULL, 0, NULL, 0);
+		if (err != UNZ_OK) {
+			break;
+		}
+		if (file_info.uncompressed_size > 0) {
+			fs_headerLongs[fs_numHeaderLongs++] = LittleLong(file_info.crc);
+		}
+		Q_strlwr( filename_inzip );
+		hash = FS_HashFileName(filename_inzip, pack->hashSize);
+		buildBuffer[i].name = namePtr;
+		strcpy( buildBuffer[i].name, filename_inzip );
+		namePtr += strlen(filename_inzip) + 1;
+		// store the file position in the zip
+		unzGetCurrentFileInfoPosition(uf, &buildBuffer[i].pos);
+		//
+		buildBuffer[i].next = pack->hashTable[hash];
+		pack->hashTable[hash] = &buildBuffer[i];
+		unzGoToNextFile(uf);
+	}
+
+	pack->checksum = Com_BlockChecksum( fs_headerLongs, 4 * fs_numHeaderLongs );
+	pack->pure_checksum = Com_BlockChecksumKey( fs_headerLongs, 4 * fs_numHeaderLongs, LittleLong(fs_checksumFeed) );
+	pack->checksum = LittleLong( pack->checksum );
+	pack->pure_checksum = LittleLong( pack->pure_checksum );
+
+	Z_Free(fs_headerLongs);
+
+	pack->buildBuffer = buildBuffer;
+	return pack;
+}
+
+/*
+=================================================================================
+
+DIRECTORY SCANNING FUNCTIONS
+
+=================================================================================
+*/
+
+#define	MAX_FOUND_FILES	0x1000
+
+static int FS_ReturnPath( const char *zname, char *zpath, int *depth ) {
+	int len, at, newdep;
+
+	newdep = 0;
+	zpath[0] = 0;
+	len = 0;
+	at = 0;
+
+	while(zname[at] != 0)
+	{
+		if (zname[at]=='/' || zname[at]=='\\') {
+			len = at;
+			newdep++;
+		}
+		at++;
+	}
+	strcpy(zpath, zname);
+	zpath[len] = 0;
+	*depth = newdep;
+
+	return len;
+}
+
+/*
+==================
+FS_AddFileToList
+==================
+*/
+static int FS_AddFileToList( char *name, char *list[MAX_FOUND_FILES], int nfiles ) {
+	int		i;
+
+	if ( nfiles == MAX_FOUND_FILES - 1 ) {
+		return nfiles;
+	}
+	for ( i = 0 ; i < nfiles ; i++ ) {
+		if ( !Q_stricmp( name, list[i] ) ) {
+			return nfiles;		// allready in list
+		}
+	}
+	list[nfiles] = CopyString( name );
+	nfiles++;
+
+	return nfiles;
+}
+
+/*
+===============
+FS_ListFilteredFiles
+
+Returns a uniqued list of files that match the given criteria
+from all search paths
+===============
+*/
+char **FS_ListFilteredFiles( const char *path, const char *extension, char *filter, int *numfiles ) {
+	int				nfiles;
+	char			**listCopy;
+	char			*list[MAX_FOUND_FILES];
+	searchpath_t	*search;
+	int				i;
+	int				pathLength;
+	int				extensionLength;
+	int				length, pathDepth, temp;
+	pack_t			*pak;
+	fileInPack_t	*buildBuffer;
+	char			zpath[MAX_ZPATH];
+
+	if ( !fs_searchpaths ) {
+		Com_Error( ERR_FATAL, "Filesystem call made without initialization\n" );
+	}
+
+	if ( !path ) {
+		*numfiles = 0;
+		return NULL;
+	}
+	if ( !extension ) {
+		extension = "";
+	}
+
+	pathLength = strlen( path );
+	if ( path[pathLength-1] == '\\' || path[pathLength-1] == '/' ) {
+		pathLength--;
+	}
+	extensionLength = strlen( extension );
+	nfiles = 0;
+	FS_ReturnPath(path, zpath, &pathDepth);
+
+	//
+	// search through the path, one element at a time, adding to list
+	//
+	for (search = fs_searchpaths ; search ; search = search->next) {
+		// is the element a pak file?
+		if (search->pack) {
+
+			//ZOID:  If we are pure, don't search for files on paks that
+			// aren't on the pure list
+			if ( !FS_PakIsPure(search->pack) ) {
+				continue;
+			}
+
+			// look through all the pak file elements
+			pak = search->pack;
+			buildBuffer = pak->buildBuffer;
+			for (i = 0; i < pak->numfiles; i++) {
+				char	*name;
+				int		zpathLen, depth;
+
+				// check for directory match
+				name = buildBuffer[i].name;
+				//
+				if (filter) {
+					// case insensitive
+					if (!Com_FilterPath( filter, name, qfalse ))
+						continue;
+					// unique the match
+					nfiles = FS_AddFileToList( name, list, nfiles );
+				}
+				else {
+
+					zpathLen = FS_ReturnPath(name, zpath, &depth);
+
+					if ( (depth-pathDepth)>2 || pathLength > zpathLen || Q_stricmpn( name, path, pathLength ) ) {
+						continue;
+					}
+
+					// check for extension match
+					length = strlen( name );
+					if ( length < extensionLength ) {
+						continue;
+					}
+
+					if ( Q_stricmp( name + length - extensionLength, extension ) ) {
+						continue;
+					}
+					// unique the match
+
+					temp = pathLength;
+					if (pathLength) {
+						temp++;		// include the '/'
+					}
+					nfiles = FS_AddFileToList( name + temp, list, nfiles );
+				}
+			}
+		} else if (search->dir) { // scan for files in the filesystem
+			char	*netpath;
+			int		numSysFiles;
+			char	**sysFiles;
+			char	*name;
+
+			// don't scan directories for files if we are pure or restricted
+			if ( (fs_restrict->integer || fs_numServerPaks) &&
+				 (!extension || Q_stricmp(extension, "fcf") || fs_restrict->integer) )
+			{
+				//rww - allow scanning for fcf files outside of pak even if pure
+			    continue;
+		    }
+			else
+			{
+				netpath = FS_BuildOSPath( search->dir->path, search->dir->gamedir, path );
+				sysFiles = Sys_ListFiles( netpath, extension, filter, &numSysFiles, qfalse );
+				for ( i = 0 ; i < numSysFiles ; i++ ) {
+					// unique the match
+					name = sysFiles[i];
+					nfiles = FS_AddFileToList( name, list, nfiles );
+				}
+				Sys_FreeFileList( sysFiles );
+			}
+		}		
+	}
+
+	// return a copy of the list
+	*numfiles = nfiles;
+
+	if ( !nfiles ) {
+		return NULL;
+	}
+
+	listCopy = (char **)Z_Malloc( ( nfiles + 1 ) * sizeof( *listCopy ), TAG_FILESYS );
+	for ( i = 0 ; i < nfiles ; i++ ) {
+		listCopy[i] = list[i];
+	}
+	listCopy[i] = NULL;
+
+	return listCopy;
+}
+
+/*
+=================
+FS_ListFiles
+=================
+*/
+char **FS_ListFiles( const char *path, const char *extension, int *numfiles ) {
+	return FS_ListFilteredFiles( path, extension, NULL, numfiles );
+}
+
+/*
+=================
+FS_FreeFileList
+=================
+*/
+void FS_FreeFileList( char **fileList ) {
+	//rwwRMG - changed to fileList to not conflict with list type
+	int		i;
+
+	if ( !fs_searchpaths ) {
+		Com_Error( ERR_FATAL, "Filesystem call made without initialization\n" );
+	}
+
+	if ( !fileList ) {
+		return;
+	}
+
+	for ( i = 0 ; fileList[i] ; i++ ) {
+		Z_Free( fileList[i] );
+	}
+
+	Z_Free( fileList );
+}
+
+
+/*
+================
+FS_GetFileList
+================
+*/
+int	FS_GetFileList(  const char *path, const char *extension, char *listbuf, int bufsize ) {
+	int		nFiles, i, nTotal, nLen;
+	char **pFiles = NULL;
+
+	*listbuf = 0;
+	nFiles = 0;
+	nTotal = 0;
+
+	if (Q_stricmp(path, "$modlist") == 0) {
+		return FS_GetModList(listbuf, bufsize);
+	}
+
+	pFiles = FS_ListFiles(path, extension, &nFiles);
+
+	for (i =0; i < nFiles; i++) {
+		nLen = strlen(pFiles[i]) + 1;
+		if (nTotal + nLen + 1 < bufsize) {
+			strcpy(listbuf, pFiles[i]);
+			listbuf += nLen;
+			nTotal += nLen;
+		}
+		else {
+			nFiles = i;
+			break;
+		}
+	}
+
+	FS_FreeFileList(pFiles);
+
+	return nFiles;
+}
+
+// NOTE: could prolly turn out useful for the win32 version too, but it's used only by linux and Mac OS X
+//#if defined(__linux__) || defined(MACOS_X)
+/*
+=======================
+Sys_ConcatenateFileLists
+
+mkv: Naive implementation. Concatenates three lists into a
+     new list, and frees the old lists from the heap.
+bk001129 - from cvs1.17 (mkv)
+
+FIXME TTimo those two should move to common.c next to Sys_ListFiles
+=======================
+ */
+static unsigned int Sys_CountFileList(char **list)
+{
+  int i = 0;
+
+  if (list)
+  {
+    while (*list)
+    {
+      list++;
+      i++;
+    }
+  }
+  return i;
+}
+
+static char** Sys_ConcatenateFileLists( char **list0, char **list1, char **list2 )
+{
+        int totalLength = 0;
+	char** cat = NULL, **dst, **src;
+
+        totalLength += Sys_CountFileList(list0);
+        totalLength += Sys_CountFileList(list1);
+        totalLength += Sys_CountFileList(list2);
+        
+	/* Create new list. */
+	dst = cat = (char **)Z_Malloc( ( totalLength + 1 ) * sizeof( char* ), TAG_FILESYS, qtrue );
+        
+	/* Copy over lists. */
+        if (list0) {
+            for (src = list0; *src; src++, dst++)
+                *dst = *src;
+        }
+        if (list1) {
+            for (src = list1; *src; src++, dst++)
+                *dst = *src;
+        }
+        if (list2) {
+            for (src = list2; *src; src++, dst++)
+                *dst = *src;
+        }
+
+        // Terminate the list
+	*dst = NULL;
+
+  // Free our old lists.
+  // NOTE: not freeing their content, it's been merged in dst and still being used
+  if (list0) Z_Free( list0 );
+  if (list1) Z_Free( list1 );
+  if (list2) Z_Free( list2 );
+
+	return cat;
+}
+//#endif
+
+/*
+================
+FS_GetModList
+
+Returns a list of mod directory names
+A mod directory is a peer to base with a pk3 in it
+The directories are searched in base path, cd path and home path
+================
+*/
+int	FS_GetModList( char *listbuf, int bufsize ) {
+  int		nMods, i, j, nTotal, nLen, nPaks, nPotential, nDescLen;
+  char **pFiles = NULL;
+  char **pPaks = NULL;
+  char *name, *path;
+  char descPath[MAX_OSPATH];
+  fileHandle_t descHandle;
+
+  int dummy;
+  char **pFiles0 = NULL;
+  char **pFiles1 = NULL;
+  char **pFiles2 = NULL;
+  qboolean bDrop = qfalse;
+
+  *listbuf = 0;
+  nMods = nPotential = nTotal = 0;
+
+  pFiles0 = Sys_ListFiles( fs_homepath->string, NULL, NULL, &dummy, qtrue );
+  pFiles1 = Sys_ListFiles( fs_basepath->string, NULL, NULL, &dummy, qtrue );
+  pFiles2 = Sys_ListFiles( fs_cdpath->string, NULL, NULL, &dummy, qtrue );
+  // we searched for mods in the three paths
+  // it is likely that we have duplicate names now, which we will cleanup below
+  pFiles = Sys_ConcatenateFileLists( pFiles0, pFiles1, pFiles2 );
+  nPotential = Sys_CountFileList(pFiles);
+
+  for ( i = 0 ; i < nPotential ; i++ ) {
+    name = pFiles[i];
+    // NOTE: cleaner would involve more changes
+    // ignore duplicate mod directories
+    if (i!=0) {
+      bDrop = qfalse;
+      for(j=0; j<i; j++)
+      {
+        if (Q_stricmp(pFiles[j],name)==0) {
+          // this one can be dropped
+          bDrop = qtrue;
+          break;
+        }
+      }
+    }
+    if (bDrop) {
+      continue;
+    }
+    // we drop "base" "." and ".."
+    if (Q_stricmp(name, "base") && Q_stricmpn(name, ".", 1)) {
+      // now we need to find some .pk3 files to validate the mod
+      // NOTE TTimo: (actually I'm not sure why .. what if it's a mod under developement with no .pk3?)
+      // we didn't keep the information when we merged the directory names, as to what OS Path it was found under
+      //   so it could be in base path, cd path or home path
+      //   we will try each three of them here (yes, it's a bit messy)
+      path = FS_BuildOSPath( fs_basepath->string, name, "" );
+      nPaks = 0;
+      pPaks = Sys_ListFiles(path, ".pk3", NULL, &nPaks, qfalse); 
+      Sys_FreeFileList( pPaks ); // we only use Sys_ListFiles to check wether .pk3 files are present
+
+      /* Try on cd path */
+      if( nPaks <= 0 ) {
+        path = FS_BuildOSPath( fs_cdpath->string, name, "" );
+        nPaks = 0;
+        pPaks = Sys_ListFiles( path, ".pk3", NULL, &nPaks, qfalse );
+        Sys_FreeFileList( pPaks );
+      }
+
+      /* try on home path */
+      if ( nPaks <= 0 )
+      {
+        path = FS_BuildOSPath( fs_homepath->string, name, "" );
+        nPaks = 0;
+        pPaks = Sys_ListFiles( path, ".pk3", NULL, &nPaks, qfalse );
+        Sys_FreeFileList( pPaks );
+      }
+
+      if (nPaks > 0) {
+        nLen = strlen(name) + 1;
+        // nLen is the length of the mod path
+        // we need to see if there is a description available
+        descPath[0] = '\0';
+        strcpy(descPath, name);
+        strcat(descPath, "/description.txt");
+        nDescLen = FS_SV_FOpenFileRead( descPath, &descHandle );
+        if ( nDescLen > 0 && descHandle) {
+          FILE *file;
+          file = FS_FileForHandle(descHandle);
+          Com_Memset( descPath, 0, sizeof( descPath ) );
+          nDescLen = fread(descPath, 1, 48, file);
+          if (nDescLen >= 0) {
+            descPath[nDescLen] = '\0';
+          }
+          FS_FCloseFile(descHandle);
+        } else {
+          strcpy(descPath, name);
+        }
+        nDescLen = strlen(descPath) + 1;
+
+        if (nTotal + nLen + 1 + nDescLen + 1 < bufsize) {
+          strcpy(listbuf, name);
+          listbuf += nLen;
+          strcpy(listbuf, descPath);
+          listbuf += nDescLen;
+          nTotal += nLen + nDescLen;
+          nMods++;
+        }
+        else {
+          break;
+        }
+      }
+    }
+  }
+  Sys_FreeFileList( pFiles );
+
+  return nMods;
+}
+
+
+
+
+//============================================================================
+
+/*
+================
+FS_Dir_f
+================
+*/
+void FS_Dir_f( void ) {
+	char	*path;
+	char	*extension;
+	char	**dirnames;
+	int		ndirs;
+	int		i;
+
+	if ( Cmd_Argc() < 2 || Cmd_Argc() > 3 ) {
+		Com_Printf( "usage: dir <directory> [extension]\n" );
+		return;
+	}
+
+	if ( Cmd_Argc() == 2 ) {
+		path = Cmd_Argv( 1 );
+		extension = "";
+	} else {
+		path = Cmd_Argv( 1 );
+		extension = Cmd_Argv( 2 );
+	}
+
+	Com_Printf( "Directory of %s %s\n", path, extension );
+	Com_Printf( "---------------\n" );
+
+	dirnames = FS_ListFiles( path, extension, &ndirs );
+
+	for ( i = 0; i < ndirs; i++ ) {
+		Com_Printf( "%s\n", dirnames[i] );
+	}
+	FS_FreeFileList( dirnames );
+}
+
+/*
+===========
+FS_ConvertPath
+===========
+*/
+void FS_ConvertPath( char *s ) {
+	while (*s) {
+		if ( *s == '\\' || *s == ':' ) {
+			*s = '/';
+		}
+		s++;
+	}
+}
+
+/*
+===========
+FS_PathCmp
+
+Ignore case and seprator char distinctions
+===========
+*/
+int FS_PathCmp( const char *s1, const char *s2 ) {
+	int		c1, c2;
+	
+	do {
+		c1 = *s1++;
+		c2 = *s2++;
+
+		if (c1 >= 'a' && c1 <= 'z') {
+			c1 -= ('a' - 'A');
+		}
+		if (c2 >= 'a' && c2 <= 'z') {
+			c2 -= ('a' - 'A');
+		}
+
+		if ( c1 == '\\' || c1 == ':' ) {
+			c1 = '/';
+		}
+		if ( c2 == '\\' || c2 == ':' ) {
+			c2 = '/';
+		}
+		
+		if (c1 < c2) {
+			return -1;		// strings not equal
+		}
+		if (c1 > c2) {
+			return 1;
+		}
+	} while (c1);
+	
+	return 0;		// strings are equal
+}
+
+/*
+================
+FS_SortFileList
+================
+*/
+void FS_SortFileList(char **filelist, int numfiles) {
+	int i, j, k, numsortedfiles;
+	char **sortedlist;
+
+	sortedlist = (char **)Z_Malloc( ( numfiles + 1 ) * sizeof( *sortedlist ), TAG_FILESYS, qtrue );
+	sortedlist[0] = NULL;
+	numsortedfiles = 0;
+	for (i = 0; i < numfiles; i++) {
+		for (j = 0; j < numsortedfiles; j++) {
+			if (FS_PathCmp(filelist[i], sortedlist[j]) < 0) {
+				break;
+			}
+		}
+		for (k = numsortedfiles; k > j; k--) {
+			sortedlist[k] = sortedlist[k-1];
+		}
+		sortedlist[j] = filelist[i];
+		numsortedfiles++;
+	}
+	Com_Memcpy(filelist, sortedlist, numfiles * sizeof( *filelist ) );
+	Z_Free(sortedlist);
+}
+
+/*
+================
+FS_NewDir_f
+================
+*/
+void FS_NewDir_f( void ) {
+	char	*filter;
+	char	**dirnames;
+	int		ndirs;
+	int		i;
+
+	if ( Cmd_Argc() < 2 ) {
+		Com_Printf( "usage: fdir <filter>\n" );
+		Com_Printf( "example: fdir *q3dm*.bsp\n");
+		return;
+	}
+
+	filter = Cmd_Argv( 1 );
+
+	Com_Printf( "---------------\n" );
+
+	dirnames = FS_ListFilteredFiles( "", "", filter, &ndirs );
+
+	FS_SortFileList(dirnames, ndirs);
+
+	for ( i = 0; i < ndirs; i++ ) {
+		FS_ConvertPath(dirnames[i]);
+		Com_Printf( "%s\n", dirnames[i] );
+	}
+	Com_Printf( "%d files listed\n", ndirs );
+	FS_FreeFileList( dirnames );
+}
+
+/*
+============
+FS_Path_f
+
+============
+*/
+void FS_Path_f( void ) {
+	searchpath_t	*s;
+	int				i;
+
+	Com_Printf ("Current search path:\n");
+	for (s = fs_searchpaths; s; s = s->next) {
+		if (s->pack) {
+			Com_Printf ("%s (%i files)\n", s->pack->pakFilename, s->pack->numfiles);
+			if ( fs_numServerPaks ) {
+				if ( !FS_PakIsPure(s->pack) ) {
+					Com_Printf( "    not on the pure list\n" );
+				} else {
+					Com_Printf( "    on the pure list\n" );
+				}
+			}
+		} else {
+			Com_Printf ("%s/%s\n", s->dir->path, s->dir->gamedir );
+		}
+	}
+
+
+	Com_Printf( "\n" );
+	for ( i = 1 ; i < MAX_FILE_HANDLES ; i++ ) {
+		if ( fsh[i].handleFiles.file.o ) {
+			Com_Printf( "handle %i: %s\n", i, fsh[i].name );
+		}
+	}
+}
+
+/*
+============
+FS_TouchFile_f
+
+The only purpose of this function is to allow game script files to copy
+arbitrary files furing an "fs_copyfiles 1" run.
+============
+*/
+void FS_TouchFile_f( void ) {
+	fileHandle_t	f;
+
+	if ( Cmd_Argc() != 2 ) {
+		Com_Printf( "Usage: touchFile <file>\n" );
+		return;
+	}
+
+	FS_FOpenFileRead( Cmd_Argv( 1 ), &f, qfalse );
+	if ( f ) {
+		FS_FCloseFile( f );
+	}
+}
+
+//===========================================================================
+
+
+static int QDECL paksort( const void *a, const void *b ) {
+	char	*aa, *bb;
+
+	aa = *(char **)a;
+	bb = *(char **)b;
+
+	return FS_PathCmp( aa, bb );
+}
+
+/*
+================
+FS_AddGameDirectory
+
+Sets fs_gamedir, adds the directory to the head of the path,
+then loads the zip headers
+================
+*/
+#define	MAX_PAKFILES	1024
+static void FS_AddGameDirectory( const char *path, const char *dir ) {
+	searchpath_t	*sp;
+	int				i;
+	searchpath_t	*search;
+	searchpath_t	*thedir;
+	pack_t			*pak;
+	char			*pakfile;
+	int				numfiles;
+	char			**pakfiles;
+	char			*sorted[MAX_PAKFILES];
+
+	// this fixes the case where fs_basepath is the same as fs_cdpath
+	// which happens on full installs
+	for ( sp = fs_searchpaths ; sp ; sp = sp->next ) {
+		if ( sp->dir && !Q_stricmp(sp->dir->path, path) && !Q_stricmp(sp->dir->gamedir, dir)) {
+			return;			// we've already got this one
+		}
+	}
+	
+	Q_strncpyz( fs_gamedir, dir, sizeof( fs_gamedir ) );
+
+	//
+	// add the directory to the search path
+	//
+	search = (struct searchpath_s *)Z_Malloc (sizeof(searchpath_t), TAG_FILESYS, qtrue);
+	search->dir = (directory_t *)Z_Malloc( sizeof( *search->dir ), TAG_FILESYS, qtrue );
+
+	Q_strncpyz( search->dir->path, path, sizeof( search->dir->path ) );
+	Q_strncpyz( search->dir->gamedir, dir, sizeof( search->dir->gamedir ) );
+	search->next = fs_searchpaths;
+	fs_searchpaths = search;
+
+	thedir = search;
+
+	// find all pak files in this directory
+	pakfile = FS_BuildOSPath( path, dir, "" );
+	pakfile[ strlen(pakfile) - 1 ] = 0;	// strip the trailing slash
+
+	pakfiles = Sys_ListFiles( pakfile, ".pk3", NULL, &numfiles, qfalse );
+
+	// sort them so that later alphabetic matches override
+	// earlier ones.  This makes pak1.pk3 override pak0.pk3
+	if ( numfiles > MAX_PAKFILES ) {
+		numfiles = MAX_PAKFILES;
+	}
+	for ( i = 0 ; i < numfiles ; i++ ) {
+		sorted[i] = pakfiles[i];
+	}
+
+	qsort( sorted, numfiles, 4, paksort );
+
+	for ( i = 0 ; i < numfiles ; i++ ) {
+		pakfile = FS_BuildOSPath( path, dir, sorted[i] );
+		if ( ( pak = FS_LoadZipFile( pakfile, sorted[i] ) ) == 0 )
+			continue;
+		// store the game name for downloading
+		strcpy(pak->pakGamename, dir);
+
+		search = (searchpath_s *)Z_Malloc (sizeof(searchpath_t), TAG_FILESYS, qtrue);
+		search->pack = pak;
+
+		if (fs_dirbeforepak && fs_dirbeforepak->integer && thedir)
+		{
+			searchpath_t *oldnext = thedir->next;
+			thedir->next = search;
+
+			while (oldnext)
+			{
+				search->next = oldnext;
+				search = search->next;
+				oldnext = oldnext->next;
+			}
+		}
+		else
+		{
+			search->next = fs_searchpaths;
+			fs_searchpaths = search;
+		}
+	}
+
+	// done
+	Sys_FreeFileList( pakfiles );
+}
+
+/*
+================
+FS_idPak
+================
+*/
+qboolean FS_idPak( char *pak, char *base ) {
+	int i;
+
+	for (i = 0; i < NUM_ID_PAKS; i++) {
+		if ( !FS_FilenameCompare(pak, va("%s/assets%d", base, i)) ) {
+			break;
+		}
+	}
+	if (i < NUM_ID_PAKS) {
+		return qtrue;
+	}
+	return qfalse;
+}
+
+/*
+================
+FS_ComparePaks
+
+if dlstring == qtrue
+
+Returns a list of pak files that we should download from the server. They all get stored
+in the current gamedir and an FS_Restart will be fired up after we download them all.
+
+The string is the format:
+
+@remotename@localname [repeat]
+
+static int		fs_numServerReferencedPaks;
+static int		fs_serverReferencedPaks[MAX_SEARCH_PATHS];
+static char		*fs_serverReferencedPakNames[MAX_SEARCH_PATHS];
+
+----------------
+dlstring == qfalse
+
+we are not interested in a download string format, we want something human-readable
+(this is used for diagnostics while connecting to a pure server)
+================
+*/
+qboolean FS_ComparePaks( char *neededpaks, int len, qboolean dlstring ) {
+	searchpath_t	*sp;
+	qboolean havepak, badchecksum;
+	int i;
+
+	if ( !fs_numServerReferencedPaks ) {
+		return qfalse; // Server didn't send any pack information along
+	}
+
+	*neededpaks = 0;
+
+	for ( i = 0 ; i < fs_numServerReferencedPaks ; i++ ) {
+		// Ok, see if we have this pak file
+		badchecksum = qfalse;
+		havepak = qfalse;
+
+		// never autodownload any of the id paks
+		if ( FS_idPak(fs_serverReferencedPakNames[i], "base") || FS_idPak(fs_serverReferencedPakNames[i], "missionpack") ) {
+			continue;
+		}
+
+		for ( sp = fs_searchpaths ; sp ; sp = sp->next ) {
+			if ( sp->pack && sp->pack->checksum == fs_serverReferencedPaks[i] ) {
+				havepak = qtrue; // This is it!
+				break;
+			}
+		}
+
+		if ( !havepak && fs_serverReferencedPakNames[i] && *fs_serverReferencedPakNames[i] ) { 
+			// Don't got it
+			
+			if (dlstring)
+			{
+				// Remote name
+				Q_strcat( neededpaks, len, "@");
+				Q_strcat( neededpaks, len, fs_serverReferencedPakNames[i] );
+				Q_strcat( neededpaks, len, ".pk3" );
+				
+				// Local name
+				Q_strcat( neededpaks, len, "@");
+				// Do we have one with the same name?
+				if ( FS_SV_FileExists( va( "%s.pk3", fs_serverReferencedPakNames[i] ) ) ) {
+					char st[MAX_ZPATH];
+					// We already have one called this, we need to download it to another name
+					// Make something up with the checksum in it
+					Com_sprintf( st, sizeof( st ), "%s.%08x.pk3", fs_serverReferencedPakNames[i], fs_serverReferencedPaks[i] );
+					Q_strcat( neededpaks, len, st );
+				} else {
+					Q_strcat( neededpaks, len, fs_serverReferencedPakNames[i] );
+					Q_strcat( neededpaks, len, ".pk3" );
+				}
+			}
+			else
+			{
+				Q_strcat( neededpaks, len, fs_serverReferencedPakNames[i] );
+				Q_strcat( neededpaks, len, ".pk3" );
+				// Do we have one with the same name?
+				if ( FS_SV_FileExists( va( "%s.pk3", fs_serverReferencedPakNames[i] ) ) )
+				{
+					Q_strcat( neededpaks, len, " (local file exists with wrong checksum)");
+				}
+				Q_strcat( neededpaks, len, "\n");
+			}
+		}
+	}
+	if ( *neededpaks ) {
+		return qtrue;
+	}
+
+	return qfalse; // We have them all
+}
+
+#ifdef USE_CD_KEY
+
+void Com_AppendCDKey( const char *filename );
+void Com_ReadCDKey( const char *filename );
+
+#endif // USE_CD_KEY
+
+//rww - add search paths in for received svc_setgame
+void FS_UpdateGamedir(void)
+{
+	if ( fs_gamedirvar->string[0] && Q_stricmp( fs_gamedirvar->string, BASEGAME ) )
+	{
+		if (fs_cdpath->string[0])
+		{
+			FS_AddGameDirectory(fs_cdpath->string, fs_gamedirvar->string);
+		}
+		if (fs_basepath->string[0])
+		{
+			FS_AddGameDirectory(fs_basepath->string, fs_gamedirvar->string);
+		}
+		if (fs_homepath->string[0] && Q_stricmp(fs_homepath->string,fs_basepath->string))
+		{
+			FS_AddGameDirectory(fs_homepath->string, fs_gamedirvar->string);
+		}
+	}
+}
+
+/*
+================
+FS_Startup
+================
+*/
+void FS_Startup( const char *gameName ) {
+        const char *homePath;
+#ifdef USE_CD_KEY
+	cvar_t	*fs;
+#endif	// USE_CD_KEY
+
+	Com_Printf( "----- FS_Startup -----\n" );
+
+	fs_debug = Cvar_Get( "fs_debug", "0", 0 );
+	fs_copyfiles = Cvar_Get( "fs_copyfiles", "0", CVAR_INIT );
+	fs_cdpath = Cvar_Get ("fs_cdpath", Sys_DefaultCDPath(), CVAR_INIT );
+	fs_basepath = Cvar_Get ("fs_basepath", Sys_DefaultInstallPath(), CVAR_INIT );
+	fs_basegame = Cvar_Get ("fs_basegame", "", CVAR_INIT );
+  homePath = Sys_DefaultHomePath();
+  if (!homePath || !homePath[0]) {
+		homePath = fs_basepath->string;
+	}
+	fs_homepath = Cvar_Get ("fs_homepath", homePath, CVAR_INIT );
+	fs_gamedirvar = Cvar_Get ("fs_game", "", CVAR_INIT|CVAR_SYSTEMINFO );
+	fs_restrict = Cvar_Get ("fs_restrict", "", CVAR_INIT );
+
+	fs_dirbeforepak = Cvar_Get("fs_dirbeforepak", "0", CVAR_INIT);
+
+	// add search path elements in reverse priority order
+	if (fs_cdpath->string[0]) {
+		FS_AddGameDirectory( fs_cdpath->string, gameName );
+	}
+	if (fs_basepath->string[0]) {
+		FS_AddGameDirectory( fs_basepath->string, gameName );
+	}
+  // fs_homepath is somewhat particular to *nix systems, only add if relevant
+  // NOTE: same filtering below for mods and basegame
+	if (fs_basepath->string[0] && Q_stricmp(fs_homepath->string,fs_basepath->string)) {
+		FS_AddGameDirectory ( fs_homepath->string, gameName );
+	}
+        
+	// check for additional base game so mods can be based upon other mods
+	if ( fs_basegame->string[0] && !Q_stricmp( gameName, BASEGAME ) && Q_stricmp( fs_basegame->string, gameName ) ) {
+		if (fs_cdpath->string[0]) {
+			FS_AddGameDirectory(fs_cdpath->string, fs_basegame->string);
+		}
+		if (fs_basepath->string[0]) {
+			FS_AddGameDirectory(fs_basepath->string, fs_basegame->string);
+		}
+		if (fs_homepath->string[0] && Q_stricmp(fs_homepath->string,fs_basepath->string)) {
+			FS_AddGameDirectory(fs_homepath->string, fs_basegame->string);
+		}
+	}
+
+	// check for additional game folder for mods
+	if ( fs_gamedirvar->string[0] && !Q_stricmp( gameName, BASEGAME ) && Q_stricmp( fs_gamedirvar->string, gameName ) ) {
+		if (fs_cdpath->string[0]) {
+			FS_AddGameDirectory(fs_cdpath->string, fs_gamedirvar->string);
+		}
+		if (fs_basepath->string[0]) {
+			FS_AddGameDirectory(fs_basepath->string, fs_gamedirvar->string);
+		}
+		if (fs_homepath->string[0] && Q_stricmp(fs_homepath->string,fs_basepath->string)) {
+			FS_AddGameDirectory(fs_homepath->string, fs_gamedirvar->string);
+		}
+	}
+
+#ifdef USE_CD_KEY
+	Com_ReadCDKey( "base" );
+	fs = Cvar_Get ("fs_game", "", CVAR_INIT|CVAR_SYSTEMINFO );
+	if (fs && fs->string[0] != 0) {
+		Com_AppendCDKey( fs->string );
+	}
+#endif // USE_CD_KEY
+
+	// add our commands
+	Cmd_AddCommand ("path", FS_Path_f);
+	Cmd_AddCommand ("dir", FS_Dir_f );
+	Cmd_AddCommand ("fdir", FS_NewDir_f );
+	Cmd_AddCommand ("touchFile", FS_TouchFile_f );
+
+	// print the current search paths
+	FS_Path_f();
+
+	fs_gamedirvar->modified = qfalse; // We just loaded, it's not modified
+
+	Com_Printf( "----------------------\n" );
+
+#ifdef FS_MISSING
+	if (missingFiles == NULL) {
+		missingFiles = fopen( "\\missing.txt", "ab" );
+	}
+#endif
+	Com_Printf( "%d files in pk3 files\n", fs_packFiles );
+}
+
+
+/*
+===================
+FS_SetRestrictions
+
+Looks for product keys and restricts media add on ability
+if the full version is not found
+===================
+*/
+void FS_SetRestrictions( void ) {
+	searchpath_t	*path;
+
+#ifndef PRE_RELEASE_DEMO
+	char	*productId;
+
+	// if fs_restrict is set, don't even look for the id file,
+	// which allows the demo release to be tested even if
+	// the full game is present
+	if ( !fs_restrict->integer ) {
+		// look for the full game id
+		FS_ReadFile( "productid.txt", (void **)&productId );
+		if ( productId ) {
+			// check against the hardcoded string
+			int		seed, i;
+
+			seed = 102270;
+			for ( i = 0 ; i < sizeof( fs_scrambledProductId ) ; i++ ) {
+				if ( ( fs_scrambledProductId[i] ^ (seed&255) ) != productId[i] ) {
+					break;
+				}
+				seed = (69069 * seed + 1);
+			}
+
+			FS_FreeFile( productId );
+
+			if ( i == sizeof( fs_scrambledProductId ) ) {
+				return;	// no restrictions
+			}
+			Com_Error( ERR_FATAL, "Invalid product identification" );
+		}
+	}
+#endif
+	Cvar_Set( "fs_restrict", "1" );
+
+	Com_Printf( "\nRunning in restricted demo mode.\n\n" );
+
+	// restart the filesystem with just the demo directory
+	FS_Shutdown(qfalse);
+	FS_Startup( DEMOGAME );
+
+	// make sure that the pak file has the header checksum we expect
+	for ( path = fs_searchpaths ; path ; path = path->next ) {
+		if ( path->pack ) {
+			// a tiny attempt to keep the checksum from being scannable from the exe
+			if ( (path->pack->checksum ^ 0x02261994u) != (DEMO_PAK_CHECKSUM ^ 0x02261994u) ) {
+				Com_Error( ERR_FATAL, "Corrupted pak0.pk3: %u", path->pack->checksum );
+			}
+		}
+	}
+}
+
+/*
+=====================
+FS_GamePureChecksum
+
+Returns the checksum of the pk3 from which the server loaded the qagame.qvm
+=====================
+*/
+const char *FS_GamePureChecksum( void ) {
+	static char	info[MAX_STRING_TOKENS];
+	searchpath_t *search;
+
+	info[0] = 0;
+
+	for ( search = fs_searchpaths ; search ; search = search->next ) {
+		// is the element a pak file?
+		if ( search->pack ) {
+			if (search->pack->referenced & FS_QAGAME_REF) {
+				Com_sprintf(info, sizeof(info), "%d", search->pack->checksum);
+			}
+		}
+	}
+
+	return info;
+}
+
+/*
+=====================
+FS_LoadedPakChecksums
+
+Returns a space separated string containing the checksums of all loaded pk3 files.
+Servers with sv_pure set will get this string and pass it to clients.
+=====================
+*/
+const char *FS_LoadedPakChecksums( void ) {
+	static char	info[BIG_INFO_STRING];
+	searchpath_t	*search;
+
+	info[0] = 0;
+
+	for ( search = fs_searchpaths ; search ; search = search->next ) {
+		// is the element a pak file? 
+		if ( !search->pack ) {
+			continue;
+		}
+
+		Q_strcat( info, sizeof( info ), va("%i ", search->pack->checksum ) );
+	}
+
+	return info;
+}
+
+/*
+=====================
+FS_LoadedPakNames
+
+Returns a space separated string containing the names of all loaded pk3 files.
+Servers with sv_pure set will get this string and pass it to clients.
+=====================
+*/
+const char *FS_LoadedPakNames( void ) {
+	static char	info[BIG_INFO_STRING];
+	searchpath_t	*search;
+
+	info[0] = 0;
+
+	for ( search = fs_searchpaths ; search ; search = search->next ) {
+		// is the element a pak file?
+		if ( !search->pack ) {
+			continue;
+		}
+
+		if (*info) {
+			Q_strcat(info, sizeof( info ), " " );
+		}
+		Q_strcat( info, sizeof( info ), search->pack->pakBasename );
+	}
+
+	return info;
+}
+
+/*
+=====================
+FS_LoadedPakPureChecksums
+
+Returns a space separated string containing the pure checksums of all loaded pk3 files.
+Servers with sv_pure use these checksums to compare with the checksums the clients send
+back to the server.
+=====================
+*/
+const char *FS_LoadedPakPureChecksums( void ) {
+	static char	info[BIG_INFO_STRING];
+	searchpath_t	*search;
+
+	info[0] = 0;
+
+	for ( search = fs_searchpaths ; search ; search = search->next ) {
+		// is the element a pak file? 
+		if ( !search->pack ) {
+			continue;
+		}
+
+		Q_strcat( info, sizeof( info ), va("%i ", search->pack->pure_checksum ) );
+	}
+
+	return info;
+}
+
+/*
+=====================
+FS_ReferencedPakChecksums
+
+Returns a space separated string containing the checksums of all referenced pk3 files.
+The server will send this to the clients so they can check which files should be auto-downloaded. 
+=====================
+*/
+const char *FS_ReferencedPakChecksums( void ) {
+	static char	info[BIG_INFO_STRING];
+	searchpath_t *search;
+
+	info[0] = 0;
+
+
+	for ( search = fs_searchpaths ; search ; search = search->next ) {
+		// is the element a pak file?
+		if ( search->pack ) {
+			if (search->pack->referenced || Q_stricmpn(search->pack->pakGamename, BASEGAME, strlen(BASEGAME))) {
+				Q_strcat( info, sizeof( info ), va("%i ", search->pack->checksum ) );
+			}
+		}
+	}
+
+	return info;
+}
+
+/*
+=====================
+FS_ReferencedPakPureChecksums
+
+Returns a space separated string containing the pure checksums of all referenced pk3 files.
+Servers with sv_pure set will get this string back from clients for pure validation 
+
+The string has a specific order, "cgame ui @ ref1 ref2 ref3 ..."
+=====================
+*/
+const char *FS_ReferencedPakPureChecksums( void ) {
+	static char	info[BIG_INFO_STRING];
+	searchpath_t	*search;
+	int nFlags, numPaks, checksum;
+
+	info[0] = 0;
+
+	checksum = fs_checksumFeed;
+	numPaks = 0;
+	for (nFlags = FS_CGAME_REF; nFlags; nFlags = nFlags >> 1) {
+		if (nFlags & FS_GENERAL_REF) {
+			// add a delimter between must haves and general refs
+			//Q_strcat(info, sizeof(info), "@ ");
+			info[strlen(info)+1] = '\0';
+			info[strlen(info)+2] = '\0';
+			info[strlen(info)] = '@';
+			info[strlen(info)] = ' ';
+		}
+		for ( search = fs_searchpaths ; search ; search = search->next ) {
+			// is the element a pak file and has it been referenced based on flag?
+			if ( search->pack && (search->pack->referenced & nFlags)) {
+				Q_strcat( info, sizeof( info ), va("%i ", search->pack->pure_checksum ) );
+				if (nFlags & (FS_CGAME_REF | FS_UI_REF)) {
+					break;
+				}
+				checksum ^= search->pack->pure_checksum;
+				numPaks++;
+			}
+		}
+		if (fs_fakeChkSum != 0) {
+			// only added if a non-pure file is referenced
+			Q_strcat( info, sizeof( info ), va("%i ", fs_fakeChkSum ) );
+		}
+	}
+	// last checksum is the encoded number of referenced pk3s
+	checksum ^= numPaks;
+	Q_strcat( info, sizeof( info ), va("%i ", checksum ) );
+
+	return info;
+}
+
+/*
+=====================
+FS_ReferencedPakNames
+
+Returns a space separated string containing the names of all referenced pk3 files.
+The server will send this to the clients so they can check which files should be auto-downloaded. 
+=====================
+*/
+const char *FS_ReferencedPakNames( void ) {
+	static char	info[BIG_INFO_STRING];
+	searchpath_t	*search;
+
+	info[0] = 0;
+
+	// we want to return ALL pk3's from the fs_game path
+	// and referenced one's from base
+	for ( search = fs_searchpaths ; search ; search = search->next ) {
+		// is the element a pak file?
+		if ( search->pack ) {
+			if (*info) {
+				Q_strcat(info, sizeof( info ), " " );
+			}
+			if (search->pack->referenced || Q_stricmpn(search->pack->pakGamename, BASEGAME, strlen(BASEGAME))) {
+				Q_strcat( info, sizeof( info ), search->pack->pakGamename );
+				Q_strcat( info, sizeof( info ), "/" );
+				Q_strcat( info, sizeof( info ), search->pack->pakBasename );
+			}
+		}
+	}
+
+	return info;
+}
+
+/*
+=====================
+FS_ClearPakReferences
+=====================
+*/
+void FS_ClearPakReferences( int flags ) {
+	searchpath_t *search;
+
+	if ( !flags ) {
+		flags = -1;
+	}
+	for ( search = fs_searchpaths; search; search = search->next ) {
+		// is the element a pak file and has it been referenced?
+		if ( search->pack ) {
+			search->pack->referenced &= ~flags;
+		}
+	}
+}
+
+
+/*
+=====================
+FS_PureServerSetLoadedPaks
+
+If the string is empty, all data sources will be allowed.
+If not empty, only pk3 files that match one of the space
+separated checksums will be checked for files, with the
+exception of .cfg and .dat files.
+=====================
+*/
+void FS_PureServerSetLoadedPaks( const char *pakSums, const char *pakNames ) {
+	int		i, c, d;
+
+	Cmd_TokenizeString( pakSums );
+
+	c = Cmd_Argc();
+	if ( c > MAX_SEARCH_PATHS ) {
+		c = MAX_SEARCH_PATHS;
+	}
+
+	fs_numServerPaks = c;
+
+	for ( i = 0 ; i < c ; i++ ) {
+		fs_serverPaks[i] = atoi( Cmd_Argv( i ) );
+	}
+
+	if (fs_numServerPaks) {
+		Com_DPrintf( "Connected to a pure server.\n" );
+	}
+
+	for ( i = 0 ; i < c ; i++ ) {
+		if (fs_serverPakNames[i]) {
+			Z_Free(fs_serverPakNames[i]);
+		}
+		fs_serverPakNames[i] = NULL;
+	}
+	if ( pakNames && *pakNames ) {
+		Cmd_TokenizeString( pakNames );
+
+		d = Cmd_Argc();
+		if ( d > MAX_SEARCH_PATHS ) {
+			d = MAX_SEARCH_PATHS;
+		}
+
+		for ( i = 0 ; i < d ; i++ ) {
+			fs_serverPakNames[i] = CopyString( Cmd_Argv( i ) );
+		}
+	}
+}
+
+/*
+=====================
+FS_PureServerSetReferencedPaks
+
+The checksums and names of the pk3 files referenced at the server
+are sent to the client and stored here. The client will use these
+checksums to see if any pk3 files need to be auto-downloaded. 
+=====================
+*/
+void FS_PureServerSetReferencedPaks( const char *pakSums, const char *pakNames ) {
+	int		i, c, d;
+
+	Cmd_TokenizeString( pakSums );
+
+	c = Cmd_Argc();
+	if ( c > MAX_SEARCH_PATHS ) {
+		c = MAX_SEARCH_PATHS;
+	}
+
+	fs_numServerReferencedPaks = c;
+
+	for ( i = 0 ; i < c ; i++ ) {
+		fs_serverReferencedPaks[i] = atoi( Cmd_Argv( i ) );
+	}
+
+	for ( i = 0 ; i < c ; i++ ) {
+		if (fs_serverReferencedPakNames[i]) {
+			Z_Free(fs_serverReferencedPakNames[i]);
+		}
+		fs_serverReferencedPakNames[i] = NULL;
+	}
+	if ( pakNames && *pakNames ) {
+		Cmd_TokenizeString( pakNames );
+
+		d = Cmd_Argc();
+		if ( d > MAX_SEARCH_PATHS ) {
+			d = MAX_SEARCH_PATHS;
+		}
+
+		for ( i = 0 ; i < d ; i++ ) {
+			fs_serverReferencedPakNames[i] = CopyString( Cmd_Argv( i ) );
+		}
+	}
+}
+
+/*
+================
+FS_Restart
+================
+*/
+void FS_Restart( int checksumFeed ) {
+
+	// free anything we currently have loaded
+	FS_Shutdown(qfalse);
+
+	// set the checksum feed
+	fs_checksumFeed = checksumFeed;
+
+	// clear pak references
+	FS_ClearPakReferences(0);
+
+	// try to start up normally
+	FS_Startup( BASEGAME );
+
+	// see if we are going to allow add-ons
+	FS_SetRestrictions();
+
+	// if we can't find default.cfg, assume that the paths are
+	// busted and error out now, rather than getting an unreadable
+	// graphics screen when the font fails to load
+	if ( FS_ReadFile( "mpdefault.cfg", NULL ) <= 0 ) {
+		// this might happen when connecting to a pure server not using BASEGAME/pak0.pk3
+		// (for instance a TA demo server)
+		if (lastValidBase[0]) {
+			FS_PureServerSetLoadedPaks("", "");
+			Cvar_Set("fs_basepath", lastValidBase);
+			Cvar_Set("fs_gamedirvar", lastValidGame);
+			lastValidBase[0] = '\0';
+			lastValidGame[0] = '\0';
+			Cvar_Set( "fs_restrict", "0" );
+			FS_Restart(checksumFeed);
+			Com_Error( ERR_DROP, "Invalid game folder\n" );
+			return;
+		}
+		Com_Error( ERR_FATAL, "Couldn't load mpdefault.cfg" );
+	}
+
+	// bk010116 - new check before safeMode
+	if ( Q_stricmp(fs_gamedirvar->string, lastValidGame) ) {
+		// skip the jampconfig.cfg if "safe" is on the command line
+		if ( !Com_SafeMode() ) {
+#ifdef DEDICATED
+			Cbuf_AddText ("exec jampserver.cfg\n");
+#else
+			Cbuf_AddText ("exec jampconfig.cfg\n");
+#endif
+		}
+	}
+
+	Q_strncpyz(lastValidBase, fs_basepath->string, sizeof(lastValidBase));
+	Q_strncpyz(lastValidGame, fs_gamedirvar->string, sizeof(lastValidGame));
+
+}
+
+/*
+=================
+FS_ConditionalRestart
+restart if necessary
+=================
+*/
+qboolean FS_ConditionalRestart( int checksumFeed ) {
+	if( fs_gamedirvar->modified || checksumFeed != fs_checksumFeed ) {
+		FS_Restart( checksumFeed );
+		return qtrue;
+	}
+	return qfalse;
+}
+
+/*
+========================================================================================
+
+Handle based file calls for virtual machines
+
+========================================================================================
+*/
+
+int		FS_FOpenFileByMode( const char *qpath, fileHandle_t *f, fsMode_t mode ) {
+	int		r;
+	qboolean	sync;
+
+	sync = qfalse;
+
+	switch( mode ) {
+	case FS_READ:
+		r = FS_FOpenFileRead( qpath, f, qtrue );
+		break;
+	case FS_WRITE:
+		*f = FS_FOpenFileWrite( qpath );
+		r = 0;
+		if (*f == 0) {
+			r = -1;
+		}
+		break;
+	case FS_APPEND_SYNC:
+		sync = qtrue;
+	case FS_APPEND:
+		*f = FS_FOpenFileAppend( qpath );
+		r = 0;
+		if (*f == 0) {
+			r = -1;
+		}
+		break;
+	default:
+		Com_Error( ERR_FATAL, "FSH_FOpenFile: bad mode" );
+		return -1;
+	}
+
+	if (!f) {
+		return r;
+	}
+
+	if ( *f ) {
+		if (fsh[*f].zipFile == qtrue) {
+			fsh[*f].baseOffset = unztell(fsh[*f].handleFiles.file.z);
+		} else {
+			fsh[*f].baseOffset = ftell(fsh[*f].handleFiles.file.o);
+		}
+		fsh[*f].fileSize = r;
+		fsh[*f].streamed = qfalse;
+
+		if (mode == FS_READ) {
+			Sys_BeginStreamedFile( *f, 0x4000 );
+			fsh[*f].streamed = qtrue;
+		}
+	}
+	fsh[*f].handleSync = sync;
+
+	return r;
+}
+
+int		FS_FTell( fileHandle_t f ) {
+	int pos;
+	if (fsh[f].zipFile == qtrue) {
+		pos = unztell(fsh[f].handleFiles.file.z);
+	} else {
+		pos = ftell(fsh[f].handleFiles.file.o);
+	}
+	return pos;
+}
+
+void	FS_Flush( fileHandle_t f ) {
+	fflush(fsh[f].handleFiles.file.o);
+}
diff --git a/codemp/unix/ftol.nasm b/codemp/unix/ftol.nasm
new file mode 100644
index 0000000..48437f3
--- /dev/null
+++ b/codemp/unix/ftol.nasm
@@ -0,0 +1,131 @@
+;
+; qftol -- fast floating point to long conversion.
+;
+
+segment .data
+
+temp    dd 0.0
+fpucw   dd 0
+
+; Precision Control Field , 2 bits / 0x0300 
+; PC24 0x0000   Single precision (24 bits). 
+; PC53 0x0200   Double precision (53 bits). 
+; PC64 0x0300   Extended precision (64 bits).
+
+; Rounding Control Field, 2 bits / 0x0C00
+; RCN  0x0000   Rounding to nearest (even). 
+; RCD  0x0400   Rounding down (directed, minus). 
+; RCU  0x0800   Rounding up (directed plus).
+; RC0  0x0C00   Rounding towards zero (chop mode).
+
+
+; rounding towards nearest (even)
+cw027F  dd 0x027F ; double precision
+cw037F  dd 0x037F ; extended precision
+
+; rounding towards zero (chop mode)
+cw0E7F  dd 0x0E7F ; double precision
+cw0F7F  dd 0x0F7F ; extended precision
+
+
+segment .text
+
+;
+; int qftol( void ) - default control word
+;
+
+global qftol
+
+qftol: 
+        fistp dword [temp]
+        mov eax, [temp]
+        ret
+
+
+;
+; int qftol027F( void ) - DirectX FPU 
+;
+
+global qftol027F
+
+qftol027F:
+	fnstcw [fpucw]
+	fldcw  [cw027F]  
+        fistp dword [temp]
+	fldcw  [fpucw]
+        mov eax, [temp]
+        ret
+
+;
+; int qftol037F( void ) - Linux FPU 
+;
+
+global qftol037F
+
+qftol037F:
+	fnstcw [fpucw]
+	fldcw  [cw037F]  
+        fistp dword [temp]
+	fldcw  [fpucw]
+        mov eax, [temp]
+        ret
+
+
+;
+; int qftol0F7F( void ) - ANSI
+;
+
+global qftol0F7F
+
+qftol0F7F:
+	fnstcw [fpucw]
+	fldcw  [cw0F7F]  
+        fistp dword [temp]
+	fldcw  [fpucw]
+        mov eax, [temp]
+        ret
+
+;
+; int qftol0E7F( void ) 
+;
+
+global qftol0E7F
+
+qftol0E7F:
+	fnstcw [fpucw]
+	fldcw  [cw0E7F]  
+        fistp dword [temp]
+	fldcw  [fpucw]
+        mov eax, [temp]
+        ret
+
+
+
+;
+; long Q_ftol( float q )
+;
+
+global Q_ftol
+
+Q_ftol:
+        fld dword [esp+4]  
+        fistp dword [temp]
+        mov eax, [temp]
+        ret
+
+
+;
+; long qftol0F7F( float q ) - Linux FPU 
+;
+
+global Q_ftol0F7F
+
+Q_ftol0F7F:
+	fnstcw [fpucw]
+	fld dword [esp+4]  
+	fldcw  [cw0F7F]  
+        fistp dword [temp]
+	fldcw  [fpucw]
+        mov eax, [temp]
+        ret
+
diff --git a/codemp/unix/linux_common.c b/codemp/unix/linux_common.c
new file mode 100644
index 0000000..042e3b1
--- /dev/null
+++ b/codemp/unix/linux_common.c
@@ -0,0 +1,323 @@
+/** 
+ * GAS syntax equivalents of the MSVC asm memory calls in common.c
+ *
+ * The following changes have been made to the asm:
+ * 1. Registers are loaded by the inline asm arguments when possible
+ * 2. Labels have been changed to local label format (0,1,etc.) to allow inlining
+ *
+ * HISTORY:
+ *	AH - Created on 08 Dec 2000
+ */
+
+#include <unistd.h>   // AH - for size_t
+#include <string.h>
+
+// bk001207 - we need something under Linux, too. Mac?
+#if 1 // defined(C_ONLY) // bk010102 - dedicated?
+void Com_Memcpy (void* dest, const void* src, const size_t count) {
+  memcpy(dest, src, count);
+}
+
+void Com_Memset (void* dest, const int val, const size_t count) {
+  memset(dest, val, count);
+}
+
+#else
+
+typedef enum {
+  PRE_READ,         // prefetch assuming that buffer is used for reading only
+  PRE_WRITE,        // prefetch assuming that buffer is used for writing only
+  PRE_READ_WRITE    // prefetch assuming that buffer is used for both reading and writing
+} e_prefetch;
+
+void Com_Prefetch (const void *s, const unsigned int bytes, e_prefetch type);
+
+void _copyDWord (unsigned int* dest, const unsigned int constant, const unsigned int count) {
+	// MMX version not used on standard Pentium MMX
+	// because the dword version is faster (with
+	// proper destination prefetching)
+		__asm__ __volatile__ ("
+			//mov			eax,constant		// eax = val
+			//mov			edx,dest			// dest
+			//mov			ecx,count
+			movd		%%eax, %%mm0
+			punpckldq	%%mm0, %%mm0
+
+			// ensure that destination is qword aligned
+
+			testl		$7, %%edx				// qword padding?
+			jz		0f	
+			movl		%%eax, (%%edx)
+			decl		%%ecx
+			addl		$4, %%edx
+
+0:			movl		%%ecx, %%ebx				
+			andl		$0xfffffff0, %%ecx				
+			jz		2f
+			jmp		1f
+			.align 		16
+
+			// funny ordering here to avoid commands
+			// that cross 32-byte boundaries (the
+			// [edx+0] version has a special 3-byte opcode...
+1:			movq		%%mm0, 8(%%edx)
+			movq		%%mm0, 16(%%edx)
+			movq		%%mm0, 24(%%edx)
+			movq		%%mm0, 32(%%edx)
+			movq		%%mm0, 40(%%edx)
+			movq		%%mm0, 48(%%edx)
+			movq		%%mm0, 56(%%edx)
+			movq		%%mm0, (%%edx)
+			addl		$64, %%edx
+			subl		$16, %%ecx
+			jnz		1b
+2:	
+			movl		%%ebx, %%ecx				// ebx = cnt
+			andl		$0xfffffff0, %%ecx				// ecx = cnt&~15
+			subl		%%ecx, %%ebx
+			jz		6f
+			cmpl		$8, %%ebx
+			jl		3f
+
+			movq		%%mm0, (%%edx)
+			movq		%%mm0, 8(%%edx)
+			movq		%%mm0, 16(%%edx)
+			movq		%%mm0, 24(%%edx)
+			addl		$32, %%edx
+			subl		$8, %%ebx
+			jz		6f
+
+3:			cmpl		$4, %%ebx
+			jl		4f
+			
+			movq		%%mm0, (%%edx)
+			movq		%%mm0, 8(%%edx)
+			addl		$16, %%edx
+			subl		$4, %%ebx
+
+4:			cmpl		$2, %%ebx
+			jl		5f
+			movq		%%mm0, (%%edx)
+			addl		$8, %%edx
+			subl		$2, %%ebx
+
+5:			cmpl		$1, %%ebx
+			jl		6f
+			movl		%%eax, (%%edx)
+6:
+			emms
+	"
+	: : "a" (constant), "c" (count), "d" (dest)
+	: "%ebx", "%edi", "%esi", "cc", "memory");
+}
+
+// optimized memory copy routine that handles all alignment
+// cases and block sizes efficiently
+void Com_Memcpy (void* dest, const void* src, const size_t count) {
+	Com_Prefetch (src, count, PRE_READ);
+	__asm__ __volatile__ ("
+		pushl		%%edi
+		pushl		%%esi
+		//mov		ecx,count
+		cmpl		$0, %%ecx						// count = 0 check (just to be on the safe side)
+		je		6f
+		//mov		edx,dest
+		movl		%0, %%ebx
+		cmpl		$32, %%ecx						// padding only?
+		jl		1f
+
+		movl		%%ecx, %%edi					
+		andl		$0xfffffe00, %%edi					// edi = count&~31
+		subl		$32, %%edi
+
+		.align 16
+0:
+		movl		(%%ebx, %%edi, 1), %%eax
+		movl		4(%%ebx, %%edi, 1), %%esi
+		movl		%%eax, (%%edx, %%edi, 1)
+		movl		%%esi, 4(%%edx, %%edi, 1)
+		movl		8(%%ebx, %%edi, 1), %%eax
+		movl		12(%%ebx, %%edi, 1), %%esi
+		movl		%%eax, 8(%%edx, %%edi, 1)
+		movl		%%esi, 12(%%edx, %%edi, 1)
+		movl		16(%%ebx, %%edi, 1), %%eax
+		movl		20(%%ebx, %%edi, 1), %%esi
+		movl		%%eax, 16(%%edx, %%edi, 1)
+		movl		%%esi, 20(%%edx, %%edi, 1)
+		movl		24(%%ebx, %%edi, 1), %%eax
+		movl		28(%%ebx, %%edi, 1), %%esi
+		movl		%%eax, 24(%%edx, %%edi, 1)
+		movl		%%esi, 28(%%edx, %%edi, 1)
+		subl		$32, %%edi
+		jge		0b
+		
+		movl		%%ecx, %%edi
+		andl		$0xfffffe00, %%edi
+		addl		%%edi, %%ebx					// increase src pointer
+		addl		%%edi, %%edx					// increase dst pointer
+		andl		$31, %%ecx					// new count
+		jz		6f					// if count = 0, get outta here
+
+1:
+		cmpl		$16, %%ecx
+		jl		2f
+		movl		(%%ebx), %%eax
+		movl		%%eax, (%%edx)
+		movl		4(%%ebx), %%eax
+		movl		%%eax, 4(%%edx)
+		movl		8(%%ebx), %%eax
+		movl		%%eax, 8(%%edx)
+		movl		12(%%ebx), %%eax
+		movl		%%eax, 12(%%edx)
+		subl		$16, %%ecx
+		addl		$16, %%ebx
+		addl		$16, %%edx
+2:
+		cmpl		$8, %%ecx
+		jl		3f
+		movl		(%%ebx), %%eax
+		movl		%%eax, (%%edx)
+		movl		4(%%ebx), %%eax
+		subl		$8, %%ecx
+		movl		%%eax, 4(%%edx)
+		addl		$8, %%ebx
+		addl		$8, %%edx
+3:
+		cmpl		$4, %%ecx
+		jl		4f
+		movl		(%%ebx), %%eax	// here 4-7 bytes
+		addl		$4, %%ebx
+		subl		$4, %%ecx
+		movl		%%eax, (%%edx)
+		addl		$4, %%edx
+4:							// 0-3 remaining bytes
+		cmpl		$2, %%ecx
+		jl		5f
+		movw		(%%ebx), %%ax	// two bytes
+		cmpl		$3, %%ecx				// less than 3?
+		movw		%%ax, (%%edx)
+		jl		6f
+		movb		2(%%ebx), %%al	// last byte
+		movb		%%al, 2(%%edx)
+		jmp		6f
+5:
+		cmpl		$1, %%ecx
+		jl		6f
+		movb		(%%ebx), %%al
+		movb		%%al, (%%edx)
+6:
+		popl		%%esi
+		popl		%%edi
+	"
+	: : "m" (src), "d" (dest), "c" (count)
+	: "%eax", "%ebx", "%edi", "%esi", "cc", "memory");
+}
+
+void Com_Memset (void* dest, const int val, const size_t count)
+{
+	unsigned int fillval;
+
+	if (count < 8)
+	{
+		__asm__ __volatile__ ("
+			//mov		edx,dest
+			//mov		eax, val
+			movb		%%al, %%ah
+			movl		%%eax, %%ebx
+			andl		$0xffff, %%ebx
+			shll		$16, %%eax
+			addl		%%ebx, %%eax	// eax now contains pattern
+			//mov		ecx,count
+			cmpl		$4, %%ecx
+			jl		0f
+			movl		%%eax, (%%edx)	// copy first dword
+			addl		$4, %%edx
+			subl		$4, %%ecx
+	0:		cmpl		$2, %%ecx
+			jl		1f
+			movw		%%ax, (%%edx)	// copy 2 bytes
+			addl		$2, %%edx
+			subl		$2, %%ecx
+	1:		cmpl		$0, %%ecx
+			je		2f
+			movb		%%al, (%%edx)	// copy single byte
+	2:		
+		"
+		: : "d" (dest), "a" (val), "c" (count)
+		: "%ebx", "%edi", "%esi", "cc", "memory");
+		
+		return;
+	}
+
+	fillval = val;
+	
+	fillval = fillval|(fillval<<8);
+	fillval = fillval|(fillval<<16);		// fill dword with 8-bit pattern
+
+	_copyDWord ((unsigned int*)(dest),fillval, count/4);
+	
+	__asm__ __volatile__ ("     		// padding of 0-3 bytes
+		//mov		ecx,count
+		movl		%%ecx, %%eax
+		andl		$3, %%ecx
+		jz		1f
+		andl		$0xffffff00, %%eax
+		//mov		ebx,dest
+		addl		%%eax, %%edx
+		movl		%0, %%eax
+		cmpl		$2, %%ecx
+		jl		0f
+		movw		%%ax, (%%edx)
+		cmpl		$2, %%ecx
+		je		1f					
+		movb		%%al, 2(%%edx)		
+		jmp		1f
+0:		
+		cmpl		$0, %%ecx
+		je		1f
+		movb		%%al, (%%edx)
+1:	
+	"
+	: : "m" (fillval), "c" (count), "d" (dest)
+	: "%eax", "%ebx", "%edi", "%esi", "cc", "memory");	
+}
+
+void Com_Prefetch (const void *s, const unsigned int bytes, e_prefetch type)
+{
+	// write buffer prefetching is performed only if
+	// the processor benefits from it. Read and read/write
+	// prefetching is always performed.
+
+	switch (type)
+	{
+		case PRE_WRITE : break;
+		case PRE_READ:
+		case PRE_READ_WRITE:
+
+		__asm__ __volatile__ ("
+			//mov		ebx,s
+			//mov		ecx,bytes
+			cmpl		$4096, %%ecx				// clamp to 4kB
+			jle		0f
+			movl		$4096, %%ecx
+	0:
+			addl		$0x1f, %%ecx
+			shrl		$5, %%ecx					// number of cache lines
+			jz		2f
+			jmp		1f
+
+			.align 16
+	1:		testb		%%al, (%%edx)
+			addl		$32, %%edx
+			decl		%%ecx
+			jnz		1b
+	2:
+		"
+		: : "d" (s), "c" (bytes)
+		: "%eax", "%ebx", "%edi", "%esi", "memory", "cc");
+		
+		break;
+	}
+}
+
+#endif
diff --git a/codemp/unix/linux_glimp.c b/codemp/unix/linux_glimp.c
new file mode 100644
index 0000000..4de5929
--- /dev/null
+++ b/codemp/unix/linux_glimp.c
@@ -0,0 +1,1543 @@
+/*
+** GLW_IMP.C
+**
+** This file contains ALL Linux specific stuff having to do with the
+** OpenGL refresh.  When a port is being made the following functions
+** must be implemented by the port:
+**
+** GLimp_EndFrame
+** GLimp_Init
+** GLimp_Shutdown
+** GLimp_SwitchFullscreen
+**
+*/
+
+#include <termios.h>
+#include <sys/ioctl.h>
+#ifdef __linux__
+#include <sys/stat.h>
+#include <sys/vt.h>
+#endif
+#include <stdarg.h>
+#include <stdio.h>
+#include <signal.h>
+#include <pthread.h>
+#include <semaphore.h>
+
+// bk001204
+#include <dlfcn.h>
+
+// bk001206 - from my Heretic2 by way of Ryan's Fakk2
+// Needed for the new X11_PendingInput() function.
+#include <sys/time.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#include "../renderer/tr_local.h"
+#include "../client/client.h"
+#include "linux_local.h" // bk001130
+
+#include "unix_glw.h"
+
+#include <GL/glx.h>
+
+#include <X11/keysym.h>
+#include <X11/cursorfont.h>
+
+#include <X11/extensions/xf86dga.h>
+#include <X11/extensions/xf86vmode.h>
+
+#define	WINDOW_CLASS_NAME	"Quake 3: Arena"
+
+typedef enum {
+	RSERR_OK,
+
+	RSERR_INVALID_FULLSCREEN,
+	RSERR_INVALID_MODE,
+
+	RSERR_UNKNOWN
+} rserr_t;
+
+glwstate_t glw_state;
+
+static Display *dpy = NULL;
+static int scrnum;
+static Window win = 0;
+static GLXContext ctx = NULL;
+
+// bk001206 - not needed anymore
+// static qboolean autorepeaton = qtrue;
+
+#define KEY_MASK (KeyPressMask | KeyReleaseMask)
+#define MOUSE_MASK (ButtonPressMask | ButtonReleaseMask | \
+		    PointerMotionMask | ButtonMotionMask )
+#define X_MASK (KEY_MASK | MOUSE_MASK | VisibilityChangeMask | StructureNotifyMask )
+
+static qboolean        mouse_avail;
+static qboolean        mouse_active;
+static int mwx, mwy;
+static int mx = 0, my = 0;
+
+// Time mouse was reset, we ignore the first 50ms of the mouse to allow settling of events
+static int mouseResetTime = 0;
+#define MOUSE_RESET_DELAY 50
+
+static cvar_t	*in_mouse;
+static cvar_t	*in_dgamouse;
+
+// bk001130 - from cvs1.17 (mkv), but not static
+cvar_t   *in_joystick      = NULL;
+cvar_t   *in_joystickDebug = NULL;
+cvar_t   *joy_threshold    = NULL;
+
+cvar_t	*r_allowSoftwareGL;		// don't abort out if the pixelformat claims software
+cvar_t	*r_previousglDriver;
+
+qboolean dgamouse = qfalse;
+qboolean vidmode_ext = qfalse;
+
+static int win_x, win_y;
+
+static XF86VidModeModeInfo **vidmodes;
+//static int default_dotclock_vidmode; // bk001204 - unused
+static int num_vidmodes;
+static qboolean vidmode_active = qfalse;
+
+static int mouse_accel_numerator;
+static int mouse_accel_denominator;
+static int mouse_threshold;    
+
+/*
+* Find the first occurrence of find in s.
+*/
+// bk001130 - from cvs1.17 (mkv), const
+// bk001130 - made first argument const
+static const char *Q_stristr( const char *s, const char *find)
+{
+register char c, sc;
+register size_t len;
+
+	if ((c = *find++) != 0) {
+		if (c >= 'a' && c <= 'z') {
+			c -= ('a' - 'A');
+		}
+		len = strlen(find);
+		do {
+			do {
+				if ((sc = *s++) == 0)
+					return NULL;
+				if (sc >= 'a' && sc <= 'z') {
+					sc -= ('a' - 'A');
+				}
+			} while (sc != c);
+		} while (Q_stricmpn(s, find, len) != 0);
+		s--;
+	}
+	return s;
+}
+
+/*****************************************************************************/
+/* KEYBOARD                                                                  */
+/*****************************************************************************/
+
+// bk001204 - unused
+// static unsigned int	keyshift[256];		// key to map to if shift held down in console
+// static qboolean shift_down=qfalse;
+
+static char *XLateKey(XKeyEvent *ev, int *key)
+{
+	static char buf[64];
+	KeySym keysym;
+	// static qboolean setup = qfalse; // bk001204 - unused
+	// int i; // bk001204 - unused
+
+	*key = 0;
+
+	XLookupString(ev, buf, sizeof buf, &keysym, 0);
+
+	switch(keysym)
+	{
+		case XK_KP_Page_Up:	
+		case XK_KP_9:	 *key = K_KP_PGUP; break;
+		case XK_Page_Up:	 *key = K_PGUP; break;
+
+		case XK_KP_Page_Down: 
+		case XK_KP_3: *key = K_KP_PGDN; break;
+		case XK_Page_Down:	 *key = K_PGDN; break;
+
+		case XK_KP_Home: *key = K_KP_HOME; break;
+		case XK_KP_7: *key = K_KP_HOME; break;
+		case XK_Home:	 *key = K_HOME; break;
+
+		case XK_KP_End:
+		case XK_KP_1:	  *key = K_KP_END; break;
+		case XK_End:	 *key = K_END; break;
+
+		case XK_KP_Left: *key = K_KP_LEFTARROW; break;
+		case XK_KP_4: *key = K_KP_LEFTARROW; break;
+		case XK_Left:	 *key = K_LEFTARROW; break;
+
+		case XK_KP_Right: *key = K_KP_RIGHTARROW; break;
+		case XK_KP_6: *key = K_KP_RIGHTARROW; break;
+		case XK_Right:	*key = K_RIGHTARROW;		break;
+
+		case XK_KP_Down:
+		case XK_KP_2: 	 *key = K_KP_DOWNARROW; break;
+		case XK_Down:	 *key = K_DOWNARROW; break;
+
+		case XK_KP_Up:   
+		case XK_KP_8:    *key = K_KP_UPARROW; break;
+		case XK_Up:		 *key = K_UPARROW;	 break;
+
+		case XK_Escape: *key = K_ESCAPE;		break;
+
+		case XK_KP_Enter: *key = K_KP_ENTER;	break;
+		case XK_Return: *key = K_ENTER;		 break;
+
+		case XK_Tab:		*key = K_TAB;			 break;
+
+		case XK_F1:		 *key = K_F1;				break;
+
+		case XK_F2:		 *key = K_F2;				break;
+
+		case XK_F3:		 *key = K_F3;				break;
+
+		case XK_F4:		 *key = K_F4;				break;
+
+		case XK_F5:		 *key = K_F5;				break;
+
+		case XK_F6:		 *key = K_F6;				break;
+
+		case XK_F7:		 *key = K_F7;				break;
+
+		case XK_F8:		 *key = K_F8;				break;
+
+		case XK_F9:		 *key = K_F9;				break;
+
+		case XK_F10:		*key = K_F10;			 break;
+
+		case XK_F11:		*key = K_F11;			 break;
+
+		case XK_F12:		*key = K_F12;			 break;
+
+		  // bk001206 - from Ryan's Fakk2 
+		  //case XK_BackSpace: *key = 8; break; // ctrl-h
+                  case XK_BackSpace: *key = K_BACKSPACE; break; // ctrl-h
+
+		case XK_KP_Delete:
+		case XK_KP_Decimal: *key = K_KP_DEL; break;
+		case XK_Delete: *key = K_DEL; break;
+
+		case XK_Pause:	*key = K_PAUSE;		 break;
+
+		case XK_Shift_L:
+		case XK_Shift_R:	*key = K_SHIFT;		break;
+
+		case XK_Execute: 
+		case XK_Control_L: 
+		case XK_Control_R:	*key = K_CTRL;		 break;
+
+		case XK_Alt_L:	
+		case XK_Meta_L: 
+		case XK_Alt_R:	
+		case XK_Meta_R: *key = K_ALT;			break;
+
+		case XK_KP_Begin: *key = K_KP_5;	break;
+
+		case XK_Insert:		*key = K_INS; break;
+		case XK_KP_Insert:
+		case XK_KP_0: *key = K_KP_INS; break;
+
+		case XK_KP_Multiply: *key = '*'; break;
+		case XK_KP_Add:  *key = K_KP_PLUS; break;
+		case XK_KP_Subtract: *key = K_KP_MINUS; break;
+		case XK_KP_Divide: *key = K_KP_SLASH; break;
+
+		  // bk001130 - from cvs1.17 (mkv)
+	case XK_exclam: *key = '1'; break;
+	case XK_at: *key = '2'; break;
+	case XK_numbersign: *key = '3'; break;
+	case XK_dollar: *key = '4'; break;
+	case XK_percent: *key = '5'; break;
+	case XK_asciicircum: *key = '6'; break;
+	case XK_ampersand: *key = '7'; break;
+	case XK_asterisk: *key = '8'; break;
+	case XK_parenleft: *key = '9'; break;
+	case XK_parenright: *key = '0'; break;
+
+		default:
+			*key = *(unsigned char *)buf;
+			if (*key >= 'A' && *key <= 'Z')
+				*key = *key - 'A' + 'a';
+			break;
+	} 
+
+	return buf;
+}
+
+// ========================================================================
+// makes a null cursor
+// ========================================================================
+
+static Cursor CreateNullCursor(Display *display, Window root)
+{
+    Pixmap cursormask; 
+    XGCValues xgc;
+    GC gc;
+    XColor dummycolour;
+    Cursor cursor;
+
+    cursormask = XCreatePixmap(display, root, 1, 1, 1/*depth*/);
+    xgc.function = GXclear;
+    gc =  XCreateGC(display, cursormask, GCFunction, &xgc);
+    XFillRectangle(display, cursormask, gc, 0, 0, 1, 1);
+    dummycolour.pixel = 0;
+    dummycolour.red = 0;
+    dummycolour.flags = 04;
+    cursor = XCreatePixmapCursor(display, cursormask, cursormask,
+          &dummycolour,&dummycolour, 0,0);
+    XFreePixmap(display,cursormask);
+    XFreeGC(display,gc);
+    return cursor;
+}
+
+static void install_grabs(void)
+{
+	// inviso cursor
+	XWarpPointer(dpy, None, win,
+				 0, 0, 0, 0,
+				 glConfig.vidWidth / 2, glConfig.vidHeight / 2);
+	XSync(dpy, False);
+
+	XDefineCursor(dpy, win, CreateNullCursor(dpy, win));
+
+	XGrabPointer(dpy, win, // bk010108 - do this earlier?
+				 False,
+				 MOUSE_MASK,
+				 GrabModeAsync, GrabModeAsync,
+				 win,
+				 None,
+				 CurrentTime);
+
+	XGetPointerControl(dpy, &mouse_accel_numerator, &mouse_accel_denominator,
+		&mouse_threshold);
+
+	XChangePointerControl(dpy, True, True, 1, 1, 0);
+
+	XSync(dpy, False);
+
+	mouseResetTime = Sys_Milliseconds ();
+
+	if (in_dgamouse->value) {
+		int MajorVersion, MinorVersion;
+
+		if (!XF86DGAQueryVersion(dpy, &MajorVersion, &MinorVersion)) { 
+			// unable to query, probalby not supported
+			ri.Printf( PRINT_ALL, "Failed to detect XF86DGA Mouse\n" );
+			ri.Cvar_Set( "in_dgamouse", "0" );
+		} else {
+			dgamouse = qtrue;
+			XF86DGADirectVideo(dpy, DefaultScreen(dpy), XF86DGADirectMouse);
+			XWarpPointer(dpy, None, win, 0, 0, 0, 0, 0, 0);
+		}
+	} else {
+		mwx = glConfig.vidWidth / 2;
+		mwy = glConfig.vidHeight / 2;
+		mx = my = 0;
+	}
+
+	XGrabKeyboard(dpy, win,
+				  False,
+				  GrabModeAsync, GrabModeAsync,
+				  CurrentTime);
+
+	XSync(dpy, False);
+}
+
+static void uninstall_grabs(void)
+{
+	if (dgamouse) {
+		dgamouse = qfalse;
+		XF86DGADirectVideo(dpy, DefaultScreen(dpy), 0);
+	}
+
+	XChangePointerControl(dpy, qtrue, qtrue, mouse_accel_numerator, 
+		mouse_accel_denominator, mouse_threshold);
+
+	XUngrabPointer(dpy, CurrentTime);
+	XUngrabKeyboard(dpy, CurrentTime);
+
+	XWarpPointer(dpy, None, win,
+				 0, 0, 0, 0,
+				 glConfig.vidWidth / 2, glConfig.vidHeight / 2);
+
+	// inviso cursor
+	XUndefineCursor(dpy, win);
+}
+
+
+
+// bk001206 - from Ryan's Fakk2
+/**
+ * XPending() actually performs a blocking read 
+ *  if no events available. From Fakk2, by way of
+ *  Heretic2, by way of SDL, original idea GGI project.
+ * The benefit of this approach over the quite
+ *  badly behaved XAutoRepeatOn/Off is that you get
+ *  focus handling for free, which is a major win
+ *  with debug and windowed mode. It rests on the
+ *  assumption that the X server will use the
+ *  same timestamp on press/release event pairs 
+ *  for key repeats. 
+ */
+static qboolean X11_PendingInput(void) {
+
+  assert(dpy != NULL);
+
+  // Flush the display connection
+  //  and look to see if events are queued
+  XFlush( dpy );
+  if ( XEventsQueued( dpy, QueuedAlready) ) {
+    return qtrue;
+  }
+
+  // More drastic measures are required -- see if X is ready to talk
+  {
+    static struct timeval zero_time;
+    int x11_fd;
+    fd_set fdset;
+
+    x11_fd = ConnectionNumber( dpy );
+    FD_ZERO(&fdset);
+    FD_SET(x11_fd, &fdset);
+    if ( select(x11_fd+1, &fdset, NULL, NULL, &zero_time) == 1 ) {
+      return(XPending(dpy));
+    }
+  }
+  
+  // Oh well, nothing is ready ..
+  return qfalse;
+}
+
+
+// bk001206 - from Ryan's Fakk2. See above.
+static qboolean repeated_press(XEvent *event)
+{
+    XEvent        peekevent;
+    qboolean      repeated = qfalse;
+
+    assert(dpy != NULL);
+  
+    if (X11_PendingInput())
+    {
+        XPeekEvent(dpy, &peekevent);
+
+        if ((peekevent.type == KeyPress) &&
+            (peekevent.xkey.keycode == event->xkey.keycode) &&
+            (peekevent.xkey.time == event->xkey.time))
+        {
+            repeated = qtrue;
+            XNextEvent(dpy, &peekevent);  // skip event.
+        } // if
+    } // if
+
+    return(repeated);
+} // repeated_press
+
+
+
+static void HandleEvents(void)
+{
+	int b;
+	int key;
+	XEvent event;
+	qboolean dowarp = qfalse;
+	char *p;
+	int dx, dy;
+	int t;
+   
+	if (!dpy)
+		return;
+
+	while (XPending(dpy)) {
+		XNextEvent(dpy, &event);
+		switch(event.type) {
+		case KeyPress:
+			p = XLateKey(&event.xkey, &key);
+			if (key)
+				Sys_QueEvent( 0, SE_KEY, key, qtrue, 0, NULL );
+			while (*p)
+				Sys_QueEvent( 0, SE_CHAR, *p++, 0, 0, NULL );
+			break;
+
+		case KeyRelease:
+
+                // bk001206 - handle key repeat w/o XAutRepatOn/Off
+                //            also: not done if console/menu is active.
+		// From Ryan's Fakk2.
+		// see game/q_shared.h, KEYCATCH_* . 0 == in 3d game.  
+		  if (cls.keyCatchers == 0) {   // FIXME: KEYCATCH_NONE
+                   if (repeated_press(&event) == qtrue)
+                      continue;
+                } // if
+			XLateKey(&event.xkey, &key);
+			
+			Sys_QueEvent( 0, SE_KEY, key, qfalse, 0, NULL );
+			break;
+
+		case MotionNotify:
+			if (mouse_active) {
+				if (dgamouse) {
+					if (abs(event.xmotion.x_root) > 1)
+						mx += event.xmotion.x_root * 2;
+					else
+						mx += event.xmotion.x_root;
+					if (abs(event.xmotion.y_root) > 1)
+						my += event.xmotion.y_root * 2;
+					else
+						my += event.xmotion.y_root;
+					t = Sys_Milliseconds();
+					if (t - mouseResetTime > MOUSE_RESET_DELAY ) {
+						Sys_QueEvent( t, SE_MOUSE, mx, my, 0, NULL );
+					}
+					mx = my = 0;
+				} 
+				else 
+				{
+// ri.Printf( PRINT_ALL, "MotionNotify: %d,%d:  ", event.xmotion.x, event.xmotion.y );
+					// If it's a center motion, we've just returned from our warp
+					if (event.xmotion.x == glConfig.vidWidth/2 &&
+						event.xmotion.y == glConfig.vidHeight/2) {
+						mwx = glConfig.vidWidth/2;
+						mwy = glConfig.vidHeight/2;
+// ri.Printf( PRINT_ALL, "SE_MOUSE (%d,%d)\n", mx, my );
+						t = Sys_Milliseconds();
+						if (t - mouseResetTime > MOUSE_RESET_DELAY ) {
+							Sys_QueEvent( t, SE_MOUSE, mx, my, 0, NULL );
+						}
+						mx = my = 0;
+						break;
+					}
+
+					dx = ((int)event.xmotion.x - mwx);
+					dy = ((int)event.xmotion.y - mwy);
+					if (abs(dx) > 1)
+						mx += dx * 2;
+					else
+						mx += dx;
+					if (abs(dy) > 1)
+						my += dy * 2;
+					else
+						my += dy;
+
+// ri.Printf( PRINT_ALL, "mx=%d,my=%d [%d - %d,%d - %d]\n", mx, my, event.xmotion.x, mwx, event.xmotion.y, mwy );
+					mwx = event.xmotion.x;
+					mwy = event.xmotion.y;
+						dowarp = qtrue;
+				}
+			}
+			break;
+
+		case ButtonPress:
+			if (event.xbutton.button == 4) {
+				Sys_QueEvent( 0, SE_KEY, K_MWHEELUP, qtrue, 0, NULL );
+			} else if (event.xbutton.button == 5) {
+				Sys_QueEvent( 0, SE_KEY, K_MWHEELDOWN, qtrue, 0, NULL );
+			} else {
+			b=-1;
+				if (event.xbutton.button == 1) {
+				b = 0;
+				} else if (event.xbutton.button == 2) {
+				b = 2;
+				} else if (event.xbutton.button == 3) {
+				b = 1;
+				}
+
+			Sys_QueEvent( 0, SE_KEY, K_MOUSE1 + b, qtrue, 0, NULL );
+			}
+			break;
+
+		case ButtonRelease:
+			if (event.xbutton.button == 4) {
+				Sys_QueEvent( 0, SE_KEY, K_MWHEELUP, qfalse, 0, NULL );
+			} else if (event.xbutton.button == 5) {
+				Sys_QueEvent( 0, SE_KEY, K_MWHEELDOWN, qfalse, 0, NULL );
+			} else {
+			b=-1;
+				if (event.xbutton.button == 1) {
+				b = 0;
+				} else if (event.xbutton.button == 2) {
+				b = 2;
+				} else if (event.xbutton.button == 3) {
+				b = 1;
+				}
+			Sys_QueEvent( 0, SE_KEY, K_MOUSE1 + b, qfalse, 0, NULL );
+			}
+			break;
+
+		case CreateNotify :
+			win_x = event.xcreatewindow.x;
+			win_y = event.xcreatewindow.y;
+			break;
+
+		case ConfigureNotify :
+			win_x = event.xconfigure.x;
+			win_y = event.xconfigure.y;
+			break;
+		}
+	}
+
+	if (dowarp) {
+		XWarpPointer(dpy,None,win,0,0,0,0, 
+				(glConfig.vidWidth/2),(glConfig.vidHeight/2));
+	}
+}
+
+void KBD_Init(void)
+{
+}
+
+void KBD_Close(void)
+{
+}
+
+void IN_ActivateMouse( void ) 
+{
+	if (!mouse_avail || !dpy || !win)
+		return;
+
+	if (!mouse_active) {
+		install_grabs();
+		mouse_active = qtrue;
+	}
+}
+
+void IN_DeactivateMouse( void ) 
+{
+	if (!mouse_avail || !dpy || !win)
+		return;
+
+	if (mouse_active) {
+		uninstall_grabs();
+		mouse_active = qfalse;
+	}
+}
+/*****************************************************************************/
+
+static qboolean signalcaught = qfalse;;
+
+void Sys_Exit(int); // bk010104 - abstraction
+
+static void signal_handler(int sig) // bk010104 - replace this...
+{
+	if (signalcaught) {
+	  printf("DOUBLE SIGNAL FAULT: Received signal %d, exiting...\n", sig);
+	  Sys_Exit(1); // bk010104 - abstraction
+	}
+
+	signalcaught = qtrue;
+	printf("Received signal %d, exiting...\n", sig);
+	GLimp_Shutdown(); // bk010104 - shouldn't this be CL_Shutdown
+	Sys_Exit(1); // bk010104 - abstraction
+}
+
+static void InitSig(void)
+{
+	signal(SIGHUP, signal_handler);
+	signal(SIGQUIT, signal_handler);
+	signal(SIGILL, signal_handler);
+	signal(SIGTRAP, signal_handler);
+	signal(SIGIOT, signal_handler);
+	signal(SIGBUS, signal_handler);
+	signal(SIGFPE, signal_handler);
+	signal(SIGSEGV, signal_handler);
+	signal(SIGTERM, signal_handler);
+}
+
+/*
+** GLimp_SetGamma
+**
+** This routine should only be called if glConfig.deviceSupportsGamma is TRUE
+*/
+void GLimp_SetGamma( unsigned char red[256], unsigned char green[256], unsigned char blue[256] )
+{
+}
+
+/*
+** GLimp_Shutdown
+**
+** This routine does all OS specific shutdown procedures for the OpenGL
+** subsystem.  Under OpenGL this means NULLing out the current DC and
+** HGLRC, deleting the rendering context, and releasing the DC acquired
+** for the window.  The state structure is also nulled out.
+**
+*/
+void GLimp_Shutdown( void )
+{
+	if (!ctx || !dpy)
+		return;
+	IN_DeactivateMouse();
+	// bk001206 - replaced with H2/Fakk2 solution
+	// XAutoRepeatOn(dpy);
+	// autorepeaton = qfalse; // bk001130 - from cvs1.17 (mkv)
+	if (dpy) {
+		if (ctx)
+			qglXDestroyContext(dpy, ctx);
+		if (win)
+			XDestroyWindow(dpy, win);
+		if (vidmode_active)
+			XF86VidModeSwitchToMode(dpy, scrnum, vidmodes[0]);
+		XCloseDisplay(dpy);
+	}
+	vidmode_active = qfalse;
+	dpy = NULL;
+	win = 0;
+	ctx = NULL;
+
+	memset( &glConfig, 0, sizeof( glConfig ) );
+	memset( &glState, 0, sizeof( glState ) );
+
+	QGL_Shutdown();
+}
+
+/*
+** GLimp_LogComment
+*/
+void GLimp_LogComment( char *comment ) 
+{
+	if ( glw_state.log_fp ) {
+		fprintf( glw_state.log_fp, "%s", comment );
+	}
+}
+
+/*
+** GLW_StartDriverAndSetMode
+*/
+// bk001204 - prototype needed
+int GLW_SetMode( const char *drivername, int mode, qboolean fullscreen );
+static qboolean GLW_StartDriverAndSetMode( const char *drivername, 
+										   int mode, 
+										   qboolean fullscreen )
+{
+	rserr_t err;
+
+	// don't ever bother going into fullscreen with a voodoo card
+#if 1	// JDC: I reenabled this
+	if ( Q_stristr( drivername, "Voodoo" ) ) {
+		ri.Cvar_Set( "r_fullscreen", "0" );
+		r_fullscreen->modified = qfalse;
+		fullscreen = qfalse;
+	}
+#endif
+
+	err = GLW_SetMode( drivername, mode, fullscreen );
+
+	switch ( err )
+	{
+	case RSERR_INVALID_FULLSCREEN:
+		ri.Printf( PRINT_ALL, "...WARNING: fullscreen unavailable in this mode\n" );
+		return qfalse;
+	case RSERR_INVALID_MODE:
+		ri.Printf( PRINT_ALL, "...WARNING: could not set the given mode (%d)\n", mode );
+		return qfalse;
+	default:
+		break;
+	}
+	return qtrue;
+}
+
+/*
+** GLW_SetMode
+*/
+int GLW_SetMode( const char *drivername, int mode, qboolean fullscreen )
+{
+	int attrib[] = {
+		GLX_RGBA,					// 0
+		GLX_RED_SIZE, 4,			// 1, 2
+		GLX_GREEN_SIZE, 4,			// 3, 4
+		GLX_BLUE_SIZE, 4,			// 5, 6
+		GLX_DOUBLEBUFFER,			// 7
+		GLX_DEPTH_SIZE, 1,			// 8, 9
+		GLX_STENCIL_SIZE, 1,		// 10, 11
+		None
+	};
+	// these match in the array
+#define ATTR_RED_IDX 2
+#define ATTR_GREEN_IDX 4
+#define ATTR_BLUE_IDX 6
+#define ATTR_DEPTH_IDX 9
+#define ATTR_STENCIL_IDX 11
+	Window root;
+	XVisualInfo *visinfo;
+	XSetWindowAttributes attr;
+	unsigned long mask;
+	int colorbits, depthbits, stencilbits;
+	int tcolorbits, tdepthbits, tstencilbits;
+	int MajorVersion, MinorVersion;
+	int actualWidth, actualHeight;
+	int i;
+	const char*   glstring; // bk001130 - from cvs1.17 (mkv)
+
+	ri.Printf( PRINT_ALL, "Initializing OpenGL display\n");
+
+	ri.Printf (PRINT_ALL, "...setting mode %d:", mode );
+
+	if ( !R_GetModeInfo( &glConfig.vidWidth, &glConfig.vidHeight, &glConfig.windowAspect, mode ) )
+	{
+		ri.Printf( PRINT_ALL, " invalid mode\n" );
+		return RSERR_INVALID_MODE;
+	}
+	ri.Printf( PRINT_ALL, " %d %d\n", glConfig.vidWidth, glConfig.vidHeight);
+
+	if (!(dpy = XOpenDisplay(NULL))) {
+		fprintf(stderr, "Error couldn't open the X display\n");
+		return RSERR_INVALID_MODE;
+	}
+
+	scrnum = DefaultScreen(dpy);
+	root = RootWindow(dpy, scrnum);
+
+	actualWidth = glConfig.vidWidth;
+	actualHeight = glConfig.vidHeight;
+
+	// Get video mode list
+	MajorVersion = MinorVersion = 0;
+	if (!XF86VidModeQueryVersion(dpy, &MajorVersion, &MinorVersion)) { 
+		vidmode_ext = qfalse;
+	} else {
+		ri.Printf(PRINT_ALL, "Using XFree86-VidModeExtension Version %d.%d\n",
+			MajorVersion, MinorVersion);
+		vidmode_ext = qtrue;
+	}
+
+	// Check for DGA
+	if (in_dgamouse->value) {
+		if (!XF86DGAQueryVersion(dpy, &MajorVersion, &MinorVersion)) { 
+			// unable to query, probalby not supported
+			ri.Printf( PRINT_ALL, "Failed to detect XF86DGA Mouse\n" );
+			ri.Cvar_Set( "in_dgamouse", "0" );
+		} else {
+			ri.Printf( PRINT_ALL, "XF86DGA Mouse (Version %d.%d) initialized\n",
+				MajorVersion, MinorVersion);
+		}
+	}
+
+	if (vidmode_ext) {
+		int best_fit, best_dist, dist, x, y;
+		
+		XF86VidModeGetAllModeLines(dpy, scrnum, &num_vidmodes, &vidmodes);
+
+		// Are we going fullscreen?  If so, let's change video mode
+		if (fullscreen) {
+			best_dist = 9999999;
+			best_fit = -1;
+
+			for (i = 0; i < num_vidmodes; i++) {
+				if (glConfig.vidWidth > vidmodes[i]->hdisplay ||
+					glConfig.vidHeight > vidmodes[i]->vdisplay)
+					continue;
+
+				x = glConfig.vidWidth - vidmodes[i]->hdisplay;
+				y = glConfig.vidHeight - vidmodes[i]->vdisplay;
+				dist = (x * x) + (y * y);
+				if (dist < best_dist) {
+					best_dist = dist;
+					best_fit = i;
+				}
+			}
+
+			if (best_fit != -1) {
+				actualWidth = vidmodes[best_fit]->hdisplay;
+				actualHeight = vidmodes[best_fit]->vdisplay;
+
+				// change to the mode
+				XF86VidModeSwitchToMode(dpy, scrnum, vidmodes[best_fit]);
+				vidmode_active = qtrue;
+
+				// Move the viewport to top left
+				XF86VidModeSetViewPort(dpy, scrnum, 0, 0);
+
+				ri.Printf(PRINT_ALL, "XFree86-VidModeExtension Activated at %dx%d\n",
+					actualWidth, actualHeight);
+
+			} else {
+				fullscreen = 0;
+				ri.Printf(PRINT_ALL, "XFree86-VidModeExtension: No acceptable modes found\n");
+			}
+		} else {
+			ri.Printf(PRINT_ALL, "XFree86-VidModeExtension:  Ignored on non-fullscreen/Voodoo\n");
+		}
+	}
+
+
+	if (!r_colorbits->value)
+		colorbits = 24;
+	else
+		colorbits = r_colorbits->value;
+
+	if ( !Q_stricmp( r_glDriver->string, _3DFX_DRIVER_NAME ) )
+		colorbits = 16;
+
+	if (!r_depthbits->value)
+		depthbits = 24;
+	else
+		depthbits = r_depthbits->value;
+	stencilbits = r_stencilbits->value;
+
+	for (i = 0; i < 16; i++) {
+		// 0 - default
+		// 1 - minus colorbits
+		// 2 - minus depthbits
+		// 3 - minus stencil
+		if ((i % 4) == 0 && i) {
+			// one pass, reduce
+			switch (i / 4) {
+			case 2 :
+				if (colorbits == 24)
+					colorbits = 16;
+				break;
+			case 1 :
+				if (depthbits == 24)
+					depthbits = 16;
+				else if (depthbits == 16)
+					depthbits = 8;
+			case 3 :
+				if (stencilbits == 24)
+					stencilbits = 16;
+				else if (stencilbits == 16)
+					stencilbits = 8;
+			}
+		}
+
+		tcolorbits = colorbits;
+		tdepthbits = depthbits;
+		tstencilbits = stencilbits;
+
+		if ((i % 4) == 3) { // reduce colorbits
+			if (tcolorbits == 24)
+				tcolorbits = 16;
+		}	
+
+		if ((i % 4) == 2) { // reduce depthbits
+			if (tdepthbits == 24)
+				tdepthbits = 16;
+			else if (tdepthbits == 16)
+				tdepthbits = 8;
+		}
+
+		if ((i % 4) == 1) { // reduce stencilbits
+			if (tstencilbits == 24)
+				tstencilbits = 16;
+			else if (tstencilbits == 16)
+				tstencilbits = 8;
+			else
+				tstencilbits = 0;
+		}
+
+		if (tcolorbits == 24) {
+			attrib[ATTR_RED_IDX] = 8;
+			attrib[ATTR_GREEN_IDX] = 8;
+			attrib[ATTR_BLUE_IDX] = 8;
+		} else  {
+			// must be 16 bit
+			attrib[ATTR_RED_IDX] = 4;
+			attrib[ATTR_GREEN_IDX] = 4;
+			attrib[ATTR_BLUE_IDX] = 4;
+		}
+
+		attrib[ATTR_DEPTH_IDX] = tdepthbits; // default to 24 depth
+		attrib[ATTR_STENCIL_IDX] = tstencilbits;
+
+		visinfo = qglXChooseVisual(dpy, scrnum, attrib);
+		if (!visinfo) {
+			continue;
+		}
+
+		ri.Printf( PRINT_ALL, "Using %d/%d/%d Color bits, %d depth, %d stencil display.\n", 
+			attrib[ATTR_RED_IDX], attrib[ATTR_GREEN_IDX], attrib[ATTR_BLUE_IDX],
+			attrib[ATTR_DEPTH_IDX], attrib[ATTR_STENCIL_IDX]);
+
+		glConfig.colorBits = tcolorbits;
+		glConfig.depthBits = tdepthbits;
+		glConfig.stencilBits = tstencilbits;
+		break;
+	}
+
+	if (!visinfo) {
+		ri.Printf( PRINT_ALL, "Couldn't get a visual\n" );
+		return RSERR_INVALID_MODE;
+	}
+
+	/* window attributes */
+	attr.background_pixel = BlackPixel(dpy, scrnum);
+	attr.border_pixel = 0;
+	attr.colormap = XCreateColormap(dpy, root, visinfo->visual, AllocNone);
+	attr.event_mask = X_MASK;
+	if (vidmode_active) {
+		mask = CWBackPixel | CWColormap | CWSaveUnder | CWBackingStore | 
+			CWEventMask | CWOverrideRedirect;
+		attr.override_redirect = True;
+		attr.backing_store = NotUseful;
+		attr.save_under = False;
+	} else
+		mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask;
+
+	win = XCreateWindow(dpy, root, 0, 0, 
+			actualWidth, actualHeight, 
+			0, visinfo->depth, InputOutput,
+			visinfo->visual, mask, &attr);
+
+	XStoreName( dpy, win, WINDOW_CLASS_NAME );
+
+	XMapWindow( dpy, win );
+
+	if (vidmode_active)
+		XMoveWindow(dpy, win, 0, 0);
+
+	XFlush(dpy);
+	XSync(dpy,False); // bk001130 - from cvs1.17 (mkv)
+	ctx = qglXCreateContext(dpy, visinfo, NULL, True);
+	XSync(dpy,False); // bk001130 - from cvs1.17 (mkv)
+
+	qglXMakeCurrent(dpy, win, ctx);
+
+	// bk001130 - from cvs1.17 (mkv)
+	glstring = qglGetString (GL_RENDERER);
+        ri.Printf( PRINT_ALL, "GL_RENDERER: %s\n", glstring );
+
+	// bk010122 - new software token (Indirect)
+	if ( !Q_stricmp( glstring, "Mesa X11")
+	     || !Q_stricmp( glstring, "Mesa GLX Indirect") ) 
+	{
+	        if ( !r_allowSoftwareGL->integer ) {
+		  ri.Printf( PRINT_ALL, "\n\n***********************************************************\n" );
+		  ri.Printf( PRINT_ALL, " You are using software Mesa (no hardware acceleration)!   \n" );
+		  ri.Printf( PRINT_ALL, " Driver DLL used: %s\n", drivername ); 
+		  ri.Printf( PRINT_ALL, " If this is intentional, add\n" );
+		  ri.Printf( PRINT_ALL, "       \"+set r_allowSoftwareGL 1\"\n" );
+		  ri.Printf( PRINT_ALL, " to the command line when starting the game.\n" );
+		  ri.Printf( PRINT_ALL, "***********************************************************\n");
+		  GLimp_Shutdown( );
+		  return RSERR_INVALID_MODE;
+		} else {
+		  ri.Printf( PRINT_ALL, "...using software Mesa (r_allowSoftwareGL==1).\n" );
+		}
+	}
+
+	return RSERR_OK;
+}
+
+/*
+** GLW_InitExtensions
+*/
+static void GLW_InitExtensions( void )
+{
+	if ( !r_allowExtensions->integer )
+	{
+		ri.Printf( PRINT_ALL, "*** IGNORING OPENGL EXTENSIONS ***\n" );
+		return;
+	}
+
+	ri.Printf( PRINT_ALL, "Initializing OpenGL extensions\n" );
+
+	// GL_S3_s3tc
+	if ( Q_stristr( glConfig.extensions_string, "GL_S3_s3tc" ) )
+	{
+		if ( r_ext_compressed_textures->value )
+		{
+			glConfig.textureCompression = TC_S3TC;
+			ri.Printf( PRINT_ALL, "...using GL_S3_s3tc\n" );
+		}
+		else
+		{
+			glConfig.textureCompression = TC_NONE;
+			ri.Printf( PRINT_ALL, "...ignoring GL_S3_s3tc\n" );
+		}
+	}
+	else
+	{
+		glConfig.textureCompression = TC_NONE;
+		ri.Printf( PRINT_ALL, "...GL_S3_s3tc not found\n" );
+	}
+
+	// GL_EXT_texture_env_add
+	glConfig.textureEnvAddAvailable = qfalse;
+	if ( Q_stristr( glConfig.extensions_string, "EXT_texture_env_add" ) )
+	{
+		if ( r_ext_texture_env_add->integer )
+		{
+			glConfig.textureEnvAddAvailable = qtrue;
+			ri.Printf( PRINT_ALL, "...using GL_EXT_texture_env_add\n" );
+		}
+		else
+		{
+			glConfig.textureEnvAddAvailable = qfalse;
+			ri.Printf( PRINT_ALL, "...ignoring GL_EXT_texture_env_add\n" );
+		}
+	}
+	else
+	{
+		ri.Printf( PRINT_ALL, "...GL_EXT_texture_env_add not found\n" );
+	}
+
+	// GL_ARB_multitexture
+	qglMultiTexCoord2fARB = NULL;
+	qglActiveTextureARB = NULL;
+	qglClientActiveTextureARB = NULL;
+	if ( Q_stristr( glConfig.extensions_string, "GL_ARB_multitexture" ) )
+	{
+		if ( r_ext_multitexture->value )
+		{
+			qglMultiTexCoord2fARB = ( PFNGLMULTITEXCOORD2FARBPROC ) dlsym( glw_state.OpenGLLib, "glMultiTexCoord2fARB" );
+			qglActiveTextureARB = ( PFNGLACTIVETEXTUREARBPROC ) dlsym( glw_state.OpenGLLib, "glActiveTextureARB" );
+			qglClientActiveTextureARB = ( PFNGLCLIENTACTIVETEXTUREARBPROC ) dlsym( glw_state.OpenGLLib, "glClientActiveTextureARB" );
+
+			if ( qglActiveTextureARB )
+			{
+				qglGetIntegerv( GL_MAX_ACTIVE_TEXTURES_ARB, &glConfig.maxActiveTextures );
+
+				if ( glConfig.maxActiveTextures > 1 )
+				{
+					ri.Printf( PRINT_ALL, "...using GL_ARB_multitexture\n" );
+				}
+				else
+				{
+					qglMultiTexCoord2fARB = NULL;
+					qglActiveTextureARB = NULL;
+					qglClientActiveTextureARB = NULL;
+					ri.Printf( PRINT_ALL, "...not using GL_ARB_multitexture, < 2 texture units\n" );
+				}
+			}
+		}
+		else
+		{
+			ri.Printf( PRINT_ALL, "...ignoring GL_ARB_multitexture\n" );
+		}
+	}
+	else
+	{
+		ri.Printf( PRINT_ALL, "...GL_ARB_multitexture not found\n" );
+	}
+
+	// GL_EXT_compiled_vertex_array
+	if ( Q_stristr( glConfig.extensions_string, "GL_EXT_compiled_vertex_array" ) )
+	{
+		if ( r_ext_compiled_vertex_array->value )
+		{
+			ri.Printf( PRINT_ALL, "...using GL_EXT_compiled_vertex_array\n" );
+			qglLockArraysEXT = ( void ( APIENTRY * )( int, int ) ) dlsym( glw_state.OpenGLLib, "glLockArraysEXT" );
+			qglUnlockArraysEXT = ( void ( APIENTRY * )( void ) ) dlsym( glw_state.OpenGLLib, "glUnlockArraysEXT" );
+			if (!qglLockArraysEXT || !qglUnlockArraysEXT) {
+				ri.Error (ERR_FATAL, "bad getprocaddress");
+			}
+		}
+		else
+		{
+			ri.Printf( PRINT_ALL, "...ignoring GL_EXT_compiled_vertex_array\n" );
+		}
+	}
+	else
+	{
+		ri.Printf( PRINT_ALL, "...GL_EXT_compiled_vertex_array not found\n" );
+	}
+
+}
+
+/*
+** GLW_LoadOpenGL
+**
+** GLimp_win.c internal function that that attempts to load and use 
+** a specific OpenGL DLL.
+*/
+static qboolean GLW_LoadOpenGL( const char *name )
+{
+	qboolean fullscreen;
+
+	ri.Printf( PRINT_ALL, "...loading %s: ", name );
+
+	// disable the 3Dfx splash screen and set gamma
+	// we do this all the time, but it shouldn't hurt anything
+	// on non-3Dfx stuff
+	putenv("FX_GLIDE_NO_SPLASH=0");
+
+	// Mesa VooDoo hacks
+	putenv("MESA_GLX_FX=fullscreen\n");
+
+	// load the QGL layer
+	if ( QGL_Init( name ) ) 
+	{
+		fullscreen = r_fullscreen->integer;
+
+		// create the window and set up the context
+		if ( !GLW_StartDriverAndSetMode( name, r_mode->integer, fullscreen ) )
+		{
+			if (r_mode->integer != 3) {
+				if ( !GLW_StartDriverAndSetMode( name, 3, fullscreen ) ) {
+					goto fail;
+				}
+			} else
+				goto fail;
+		}
+
+		return qtrue;
+	}
+	else
+	{
+		ri.Printf( PRINT_ALL, "failed\n" );
+	}
+fail:
+
+	QGL_Shutdown();
+
+	return qfalse;
+}
+
+/*
+** GLimp_Init
+**
+** This routine is responsible for initializing the OS specific portions
+** of OpenGL.  
+*/
+void GLimp_Init( void )
+{
+	qboolean attemptedlibGL = qfalse;
+	qboolean attempted3Dfx = qfalse;
+	qboolean success = qfalse;
+	char	buf[1024];
+	cvar_t *lastValidRenderer = ri.Cvar_Get( "r_lastValidRenderer", "(uninitialized)", CVAR_ARCHIVE );
+	// cvar_t	*cv; // bk001204 - unused
+
+	r_allowSoftwareGL = ri.Cvar_Get( "r_allowSoftwareGL", "0", CVAR_LATCH );
+
+	r_previousglDriver = ri.Cvar_Get( "r_previousglDriver", "", CVAR_ROM );
+
+	glConfig.deviceSupportsGamma = qfalse;
+
+	InitSig();
+
+	// Hack here so that if the UI 
+	if ( *r_previousglDriver->string ) {
+		// The UI changed it on us, hack it back
+		// This means the renderer can't be changed on the fly
+		ri.Cvar_Set( "r_glDriver", r_previousglDriver->string );
+	}
+
+	//
+	// load and initialize the specific OpenGL driver
+	//
+	if ( !GLW_LoadOpenGL( r_glDriver->string ) )
+	{
+		if ( !Q_stricmp( r_glDriver->string, OPENGL_DRIVER_NAME ) )
+		{
+			attemptedlibGL = qtrue;
+		}
+		else if ( !Q_stricmp( r_glDriver->string, _3DFX_DRIVER_NAME ) )
+		{
+			attempted3Dfx = qtrue;
+		}
+
+		if ( !attempted3Dfx && !success )
+		{
+			attempted3Dfx = qtrue;
+			if ( GLW_LoadOpenGL( _3DFX_DRIVER_NAME ) )
+			{
+				ri.Cvar_Set( "r_glDriver", _3DFX_DRIVER_NAME );
+				r_glDriver->modified = qfalse;
+				success = qtrue;
+			}
+		}
+
+		// try ICD before trying 3Dfx standalone driver
+		if ( !attemptedlibGL && !success )
+		{
+			attemptedlibGL = qtrue;
+			if ( GLW_LoadOpenGL( OPENGL_DRIVER_NAME ) )
+			{
+				ri.Cvar_Set( "r_glDriver", OPENGL_DRIVER_NAME );
+				r_glDriver->modified = qfalse;
+				success = qtrue;
+			}
+		} 
+		
+		if (!success)
+			ri.Error( ERR_FATAL, "GLimp_Init() - could not load OpenGL subsystem\n" );
+
+	}
+
+	// Save it in case the UI stomps it
+	ri.Cvar_Set( "r_previousglDriver", r_glDriver->string );
+
+	// This values force the UI to disable driver selection
+	glConfig.driverType = GLDRV_ICD;
+	glConfig.hardwareType = GLHW_GENERIC;
+
+	// get our config strings
+	Q_strncpyz( glConfig.vendor_string, qglGetString (GL_VENDOR), sizeof( glConfig.vendor_string ) );
+	Q_strncpyz( glConfig.renderer_string, qglGetString (GL_RENDERER), sizeof( glConfig.renderer_string ) );
+	if (*glConfig.renderer_string && glConfig.renderer_string[strlen(glConfig.renderer_string) - 1] == '\n')
+		glConfig.renderer_string[strlen(glConfig.renderer_string) - 1] = 0;
+	Q_strncpyz( glConfig.version_string, qglGetString (GL_VERSION), sizeof( glConfig.version_string ) );
+	Q_strncpyz( glConfig.extensions_string, qglGetString (GL_EXTENSIONS), sizeof( glConfig.extensions_string ) );
+
+	//
+	// chipset specific configuration
+	//
+	strcpy( buf, glConfig.renderer_string );
+	strlwr( buf );
+
+	//
+	// NOTE: if changing cvars, do it within this block.  This allows them
+	// to be overridden when testing driver fixes, etc. but only sets
+	// them to their default state when the hardware is first installed/run.
+	//
+	if ( Q_stricmp( lastValidRenderer->string, glConfig.renderer_string ) )
+	{
+		glConfig.hardwareType = GLHW_GENERIC;
+
+		ri.Cvar_Set( "r_textureMode", "GL_LINEAR_MIPMAP_NEAREST" );
+
+		// VOODOO GRAPHICS w/ 2MB
+		if ( Q_stristr( buf, "voodoo graphics/1 tmu/2 mb" ) )
+		{
+			ri.Cvar_Set( "r_picmip", "2" );
+			ri.Cvar_Get( "r_picmip", "1", CVAR_ARCHIVE | CVAR_LATCH );
+		}
+		else
+		{
+			ri.Cvar_Set( "r_picmip", "1" );
+
+			if ( Q_stristr( buf, "rage 128" ) || Q_stristr( buf, "rage128" ) )
+			{
+				ri.Cvar_Set( "r_finish", "0" );
+			}
+			// Savage3D and Savage4 should always have trilinear enabled
+			else if ( Q_stristr( buf, "savage3d" ) || Q_stristr( buf, "s3 savage4" ) )
+			{
+				ri.Cvar_Set( "r_texturemode", "GL_LINEAR_MIPMAP_LINEAR" );
+			}
+		}
+	}
+	
+	//
+	// this is where hardware specific workarounds that should be
+	// detected/initialized every startup should go.
+	//
+	if ( Q_stristr( buf, "banshee" ) || Q_stristr( buf, "Voodoo_Graphics" ) )
+	{
+		glConfig.hardwareType = GLHW_3DFX_2D3D;
+	}
+	else if ( Q_stristr( buf, "rage pro" ) || Q_stristr( buf, "RagePro" ) )
+	{
+		glConfig.hardwareType = GLHW_RAGEPRO;
+	}
+	else if ( Q_stristr( buf, "permedia2" ) )
+	{
+		glConfig.hardwareType = GLHW_PERMEDIA2;
+	}
+	else if ( Q_stristr( buf, "riva 128" ) )
+	{
+		glConfig.hardwareType = GLHW_RIVA128;
+	}
+	else if ( Q_stristr( buf, "riva tnt " ) )
+	{
+	}
+
+	ri.Cvar_Set( "r_lastValidRenderer", glConfig.renderer_string );
+
+	// initialize extensions
+	GLW_InitExtensions();
+
+	InitSig();
+
+	return;
+}
+
+
+/*
+** GLimp_EndFrame
+** 
+** Responsible for doing a swapbuffers and possibly for other stuff
+** as yet to be determined.  Probably better not to make this a GLimp
+** function and instead do a call to GLimp_SwapBuffers.
+*/
+void GLimp_EndFrame (void)
+{
+	// don't flip if drawing to front buffer
+	if ( stricmp( r_drawBuffer->string, "GL_FRONT" ) != 0 )
+	{
+		qglXSwapBuffers(dpy, win);
+	}
+
+	// check logging
+	QGL_EnableLogging( (qboolean)r_logFile->integer ); // bk001205 - was ->value
+}
+
+#ifdef SMP
+/*
+===========================================================
+
+SMP acceleration
+
+===========================================================
+*/
+
+sem_t	renderCommandsEvent;
+sem_t	renderCompletedEvent;
+sem_t	renderActiveEvent;
+
+void (*glimpRenderThread)( void );
+
+void *GLimp_RenderThreadWrapper( void *stub ) {
+	glimpRenderThread();
+	return NULL;
+}
+
+
+/*
+=======================
+GLimp_SpawnRenderThread
+=======================
+*/
+pthread_t	renderThreadHandle;
+qboolean GLimp_SpawnRenderThread( void (*function)( void ) ) {
+
+	sem_init( &renderCommandsEvent, 0, 0 );
+	sem_init( &renderCompletedEvent, 0, 0 );
+	sem_init( &renderActiveEvent, 0, 0 );
+
+	glimpRenderThread = function;
+
+	if (pthread_create( &renderThreadHandle, NULL,
+		GLimp_RenderThreadWrapper, NULL)) {
+		return qfalse;
+	}
+
+	return qtrue;
+}
+
+static	void	*smpData;
+//static	int		glXErrors; // bk001204 - unused
+
+void *GLimp_RendererSleep( void ) {
+	void	*data;
+
+	// after this, the front end can exit GLimp_FrontEndSleep
+	sem_post ( &renderCompletedEvent );
+
+	sem_wait ( &renderCommandsEvent );
+
+	data = smpData;
+
+	// after this, the main thread can exit GLimp_WakeRenderer
+	sem_post ( &renderActiveEvent );
+
+	return data;
+}
+
+
+void GLimp_FrontEndSleep( void ) {
+	sem_wait ( &renderCompletedEvent );
+}
+
+
+void GLimp_WakeRenderer( void *data ) {
+	smpData = data;
+
+	// after this, the renderer can continue through GLimp_RendererSleep
+	sem_post( &renderCommandsEvent );
+
+	sem_wait( &renderActiveEvent );
+}
+
+#else
+
+void GLimp_RenderThreadWrapper( void *stub ) { }
+qboolean GLimp_SpawnRenderThread( void (*function)( void ) ) {
+	return qfalse;
+}
+void *GLimp_RendererSleep( void ) {
+	return NULL;
+}
+void GLimp_FrontEndSleep( void ) { }
+void GLimp_WakeRenderer( void *data ) { }
+
+#endif
+
+/*****************************************************************************/
+/* MOUSE                                                                     */
+/*****************************************************************************/
+
+void IN_Init(void) {
+  // mouse variables
+  in_mouse = Cvar_Get ("in_mouse", "1", CVAR_ARCHIVE);
+  in_dgamouse = Cvar_Get ("in_dgamouse", "1", CVAR_ARCHIVE);
+  
+  // bk001130 - from cvs.17 (mkv), joystick variables
+  in_joystick = Cvar_Get ("in_joystick", "0", CVAR_ARCHIVE|CVAR_LATCH);
+  // bk001130 - changed this to match win32
+  in_joystickDebug = Cvar_Get ("in_debugjoystick", "0", CVAR_TEMP);
+  joy_threshold = Cvar_Get ("joy_threshold", "0.15", CVAR_ARCHIVE); // FIXME: in_joythreshold
+
+  if (in_mouse->value)
+    mouse_avail = qtrue;
+  else
+    mouse_avail = qfalse;
+
+  IN_StartupJoystick( ); // bk001130 - from cvs1.17 (mkv)
+}
+
+void IN_Shutdown(void)
+{
+	mouse_avail = qfalse;
+}
+
+void IN_Frame (void) {
+
+  // bk001130 - from cvs 1.17 (mkv)
+  IN_JoyMove(); // FIXME: disable if on desktop?
+  
+  if ( cls.keyCatchers & KEYCATCH_CONSOLE ) {
+    // temporarily deactivate if not in the game and
+    // running on the desktop
+    // voodoo always counts as full screen
+    if (Cvar_VariableValue ("r_fullscreen") == 0
+	&& strcmp( Cvar_VariableString("r_glDriver"), _3DFX_DRIVER_NAME ) )	{
+      IN_DeactivateMouse ();
+      return;
+    }
+    // bk001206 - not used, now done the H2/Fakk2 way
+    //if (dpy && !autorepeaton) {
+    //  XAutoRepeatOn(dpy);
+    //  autorepeaton = qtrue;
+    //}
+  } 
+  //else if (dpy && autorepeaton) {
+  //XAutoRepeatOff(dpy);
+  //autorepeaton = qfalse;
+  //}
+ 
+  IN_ActivateMouse();
+}
+
+void IN_Activate(void)
+{
+}
+
+// bk001130 - cvs1.17 joystick code (mkv) was here, no linux_joystick.c
+
+void Sys_SendKeyEvents (void) {
+  // XEvent event; // bk001204 - unused
+
+  if (!dpy)
+    return;
+  HandleEvents();
+}
+
+
+// bk010216 - added stubs for non-Linux UNIXes here
+// FIXME - use NO_JOYSTICK or something else generic
+
+#if defined( __FreeBSD__ ) // rb010123
+void IN_StartupJoystick( void ) {}
+void IN_JoyMove( void ) {}
+#endif
diff --git a/codemp/unix/linux_joystick.c b/codemp/unix/linux_joystick.c
new file mode 100644
index 0000000..662c8b2
--- /dev/null
+++ b/codemp/unix/linux_joystick.c
@@ -0,0 +1,186 @@
+/*
+** linux_joystick.c
+**
+** This file contains ALL Linux specific stuff having to do with the
+** Joystick input.  When a port is being made the following functions
+** must be implemented by the port:
+**
+** Authors: mkv, bk
+**
+*/
+
+#include <linux/joystick.h>
+#include <sys/types.h>
+#include <fcntl.h>
+#include <sys/ioctl.h>
+#include <unistd.h>  // bk001204
+
+
+#include "../client/client.h"
+#include "linux_local.h"
+
+/* We translate axes movement into keypresses. */
+int joy_keys[16] = {
+     K_LEFTARROW, K_RIGHTARROW,
+     K_UPARROW, K_DOWNARROW,
+     K_JOY16, K_JOY17,
+     K_JOY18, K_JOY19,
+     K_JOY20, K_JOY21,
+     K_JOY22, K_JOY23,
+
+     K_JOY24, K_JOY25,
+     K_JOY26, K_JOY27
+};
+
+/* Our file descriptor for the joystick device. */
+static int             joy_fd = -1;
+
+
+// bk001130 - from linux_glimp.c
+extern cvar_t *  in_joystick;
+extern cvar_t *  in_joystickDebug;
+extern cvar_t *  joy_threshold;
+
+
+/**********************************************/
+/* Joystick routines.                         */
+/**********************************************/
+// bk001130 - from cvs1.17 (mkv), removed from linux_glimp.c
+void IN_StartupJoystick( void )
+{
+  int i = 0;
+
+  joy_fd = -1;
+
+  if( !in_joystick->integer ) {
+    Com_Printf( "Joystick is not active.\n" );
+    return;
+  }
+
+  for( i = 0; i < 4; i++ ) {
+    char filename[PATH_MAX];
+
+    snprintf( filename, PATH_MAX, "/dev/js%d", i );
+
+    joy_fd = open( filename, O_RDONLY | O_NONBLOCK );
+
+    if( joy_fd != -1 ) {
+      struct js_event event;
+      char axes = 0;
+      char buttons = 0;
+      char name[128];
+      int n = -1;
+
+      Com_Printf( "Joystick %s found\n", filename );
+
+      /* Get rid of initialization messages. */
+      do {
+	n = read( joy_fd, &event, sizeof( event ) );
+
+	if( n == -1 ) {
+	  break;
+	}
+
+      } while( ( event.type & JS_EVENT_INIT ) );
+
+      /* Get joystick statistics. */
+      ioctl( joy_fd, JSIOCGAXES, &axes );
+      ioctl( joy_fd, JSIOCGBUTTONS, &buttons );
+
+      if( ioctl( joy_fd, JSIOCGNAME( sizeof( name ) ), name ) < 0 ) {
+	strncpy( name, "Unknown", sizeof( name ) );
+      }
+
+      Com_Printf( "Name:    %s\n", name );
+      Com_Printf( "Axes:    %d\n", axes );
+      Com_Printf( "Buttons: %d\n", buttons );
+
+      /* Our work here is done. */
+      return;
+    }
+
+  }
+
+  /* No soup for you. */
+  if( joy_fd == -1 ) {
+    Com_Printf( "No joystick found.\n" );
+    return;
+  }
+
+}
+
+void IN_JoyMove( void )
+{
+  /* Store instantaneous joystick state. Hack to get around
+   * event model used in Linux joystick driver.
+	 */
+  static int axes_state[16];
+  /* Old bits for Quake-style input compares. */
+  static unsigned int old_axes = 0;
+  /* Our current goodies. */
+  unsigned int axes = 0;
+  int i = 0;
+
+  if( joy_fd == -1 ) {
+    return;
+  }
+
+  /* Empty the queue, dispatching button presses immediately
+	 * and updating the instantaneous state for the axes.
+	 */
+  do {
+    int n = -1;
+    struct js_event event;
+
+    n = read( joy_fd, &event, sizeof( event ) );
+
+    if( n == -1 ) {
+      /* No error, we're non-blocking. */
+      break;
+    }
+
+    if( event.type & JS_EVENT_BUTTON ) {
+      Sys_QueEvent( 0, SE_KEY, K_JOY1 + event.number, event.value, 0, NULL );
+    } else if( event.type & JS_EVENT_AXIS ) {
+
+      if( event.number >= 16 ) {
+	continue;
+      }
+
+      axes_state[event.number] = event.value;
+    } else {
+      Com_Printf( "Unknown joystick event type\n" );
+    }
+
+  } while( 1 );
+
+
+  /* Translate our instantaneous state to bits. */
+  for( i = 0; i < 16; i++ ) {
+    float f = ( (float) axes_state[i] ) / 32767.0f;
+
+    if( f < -joy_threshold->value ) {
+      axes |= ( 1 << ( i * 2 ) );
+    } else if( f > joy_threshold->value ) {
+      axes |= ( 1 << ( ( i * 2 ) + 1 ) );
+    }
+
+  }
+
+  /* Time to update axes state based on old vs. new. */
+  for( i = 0; i < 16; i++ ) {
+
+    if( ( axes & ( 1 << i ) ) && !( old_axes & ( 1 << i ) ) ) {
+      Sys_QueEvent( 0, SE_KEY, joy_keys[i], qtrue, 0, NULL );
+    }
+
+    if( !( axes & ( 1 << i ) ) && ( old_axes & ( 1 << i ) ) ) {
+      Sys_QueEvent( 0, SE_KEY, joy_keys[i], qfalse, 0, NULL );
+    }
+  }
+
+  /* Save for future generations. */
+  old_axes = axes;
+}
+
+
diff --git a/codemp/unix/linux_local.h b/codemp/unix/linux_local.h
new file mode 100644
index 0000000..008bea9
--- /dev/null
+++ b/codemp/unix/linux_local.h
@@ -0,0 +1,29 @@
+// linux_local.h: Linux-specific Quake3 header file
+
+void Sys_QueEvent( int time, sysEventType_t type, int value, int value2, int ptrLength, void *ptr );
+qboolean Sys_GetPacket ( netadr_t *net_from, msg_t *net_message );
+void Sys_SendKeyEvents (void);
+
+// Input subsystem
+
+void IN_Init (void);
+void IN_Frame (void);
+void IN_Shutdown (void);
+
+
+void IN_JoyMove( void );
+void IN_StartupJoystick( void );
+
+// GL subsystem
+qboolean QGL_Init( const char *dllname );
+void QGL_EnableLogging( qboolean enable );
+void QGL_Shutdown( void );
+
+
+
+
+
+// bk001130 - win32
+// void IN_JoystickCommands (void);
+
+char *strlwr (char *s);
diff --git a/codemp/unix/linux_qgl.c b/codemp/unix/linux_qgl.c
new file mode 100644
index 0000000..339bfe9
--- /dev/null
+++ b/codemp/unix/linux_qgl.c
@@ -0,0 +1,4132 @@
+/*
+** LINUX_QGL.C
+**
+** This file implements the operating system binding of GL to QGL function
+** pointers.  When doing a port of Quake2 you must implement the following
+** two functions:
+**
+** QGL_Init() - loads libraries, assigns function pointers, etc.
+** QGL_Shutdown() - unloads libraries, NULLs function pointers
+*/
+
+// bk001204
+#include <unistd.h>
+#include <sys/types.h>
+
+
+#include <float.h>
+#include "../renderer/tr_local.h"
+#include "unix_glw.h"
+
+// bk001129 - from cvs1.17 (mkv)
+//#if defined(__FX__)
+//#include <GL/fxmesa.h>
+//#endif
+//#include <GL/glx.h> // bk010216 - FIXME: all of the above redundant? renderer/qgl.h
+
+#include <dlfcn.h>
+
+
+// bk001129 - from cvs1.17 (mkv)
+#if defined(__FX__)
+//FX Mesa Functions
+fxMesaContext (*qfxMesaCreateContext)(GLuint win, GrScreenResolution_t, GrScreenRefresh_t, const GLint attribList[]);
+fxMesaContext (*qfxMesaCreateBestContext)(GLuint win, GLint width, GLint height, const GLint attribList[]);
+void (*qfxMesaDestroyContext)(fxMesaContext ctx);
+void (*qfxMesaMakeCurrent)(fxMesaContext ctx);
+fxMesaContext (*qfxMesaGetCurrentContext)(void);
+void (*qfxMesaSwapBuffers)(void);
+#endif
+
+//GLX Functions
+XVisualInfo * (*qglXChooseVisual)( Display *dpy, int screen, int *attribList );
+GLXContext (*qglXCreateContext)( Display *dpy, XVisualInfo *vis, GLXContext shareList, Bool direct );
+void (*qglXDestroyContext)( Display *dpy, GLXContext ctx );
+Bool (*qglXMakeCurrent)( Display *dpy, GLXDrawable drawable, GLXContext ctx);
+void (*qglXCopyContext)( Display *dpy, GLXContext src, GLXContext dst, GLuint mask );
+void (*qglXSwapBuffers)( Display *dpy, GLXDrawable drawable );
+
+void ( APIENTRY * qglAccum )(GLenum op, GLfloat value);
+void ( APIENTRY * qglAlphaFunc )(GLenum func, GLclampf ref);
+GLboolean ( APIENTRY * qglAreTexturesResident )(GLsizei n, const GLuint *textures, GLboolean *residences);
+void ( APIENTRY * qglArrayElement )(GLint i);
+void ( APIENTRY * qglBegin )(GLenum mode);
+void ( APIENTRY * qglBindTexture )(GLenum target, GLuint texture);
+void ( APIENTRY * qglBitmap )(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap);
+void ( APIENTRY * qglBlendFunc )(GLenum sfactor, GLenum dfactor);
+void ( APIENTRY * qglCallList )(GLuint list);
+void ( APIENTRY * qglCallLists )(GLsizei n, GLenum type, const GLvoid *lists);
+void ( APIENTRY * qglClear )(GLbitfield mask);
+void ( APIENTRY * qglClearAccum )(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
+void ( APIENTRY * qglClearColor )(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
+void ( APIENTRY * qglClearDepth )(GLclampd depth);
+void ( APIENTRY * qglClearIndex )(GLfloat c);
+void ( APIENTRY * qglClearStencil )(GLint s);
+void ( APIENTRY * qglClipPlane )(GLenum plane, const GLdouble *equation);
+void ( APIENTRY * qglColor3b )(GLbyte red, GLbyte green, GLbyte blue);
+void ( APIENTRY * qglColor3bv )(const GLbyte *v);
+void ( APIENTRY * qglColor3d )(GLdouble red, GLdouble green, GLdouble blue);
+void ( APIENTRY * qglColor3dv )(const GLdouble *v);
+void ( APIENTRY * qglColor3f )(GLfloat red, GLfloat green, GLfloat blue);
+void ( APIENTRY * qglColor3fv )(const GLfloat *v);
+void ( APIENTRY * qglColor3i )(GLint red, GLint green, GLint blue);
+void ( APIENTRY * qglColor3iv )(const GLint *v);
+void ( APIENTRY * qglColor3s )(GLshort red, GLshort green, GLshort blue);
+void ( APIENTRY * qglColor3sv )(const GLshort *v);
+void ( APIENTRY * qglColor3ub )(GLubyte red, GLubyte green, GLubyte blue);
+void ( APIENTRY * qglColor3ubv )(const GLubyte *v);
+void ( APIENTRY * qglColor3ui )(GLuint red, GLuint green, GLuint blue);
+void ( APIENTRY * qglColor3uiv )(const GLuint *v);
+void ( APIENTRY * qglColor3us )(GLushort red, GLushort green, GLushort blue);
+void ( APIENTRY * qglColor3usv )(const GLushort *v);
+void ( APIENTRY * qglColor4b )(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha);
+void ( APIENTRY * qglColor4bv )(const GLbyte *v);
+void ( APIENTRY * qglColor4d )(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha);
+void ( APIENTRY * qglColor4dv )(const GLdouble *v);
+void ( APIENTRY * qglColor4f )(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
+void ( APIENTRY * qglColor4fv )(const GLfloat *v);
+void ( APIENTRY * qglColor4i )(GLint red, GLint green, GLint blue, GLint alpha);
+void ( APIENTRY * qglColor4iv )(const GLint *v);
+void ( APIENTRY * qglColor4s )(GLshort red, GLshort green, GLshort blue, GLshort alpha);
+void ( APIENTRY * qglColor4sv )(const GLshort *v);
+void ( APIENTRY * qglColor4ub )(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha);
+void ( APIENTRY * qglColor4ubv )(const GLubyte *v);
+void ( APIENTRY * qglColor4ui )(GLuint red, GLuint green, GLuint blue, GLuint alpha);
+void ( APIENTRY * qglColor4uiv )(const GLuint *v);
+void ( APIENTRY * qglColor4us )(GLushort red, GLushort green, GLushort blue, GLushort alpha);
+void ( APIENTRY * qglColor4usv )(const GLushort *v);
+void ( APIENTRY * qglColorMask )(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
+void ( APIENTRY * qglColorMaterial )(GLenum face, GLenum mode);
+void ( APIENTRY * qglColorPointer )(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
+void ( APIENTRY * qglCopyPixels )(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type);
+void ( APIENTRY * qglCopyTexImage1D )(GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border);
+void ( APIENTRY * qglCopyTexImage2D )(GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
+void ( APIENTRY * qglCopyTexSubImage1D )(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);
+void ( APIENTRY * qglCopyTexSubImage2D )(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
+void ( APIENTRY * qglCullFace )(GLenum mode);
+void ( APIENTRY * qglDeleteLists )(GLuint list, GLsizei range);
+void ( APIENTRY * qglDeleteTextures )(GLsizei n, const GLuint *textures);
+void ( APIENTRY * qglDepthFunc )(GLenum func);
+void ( APIENTRY * qglDepthMask )(GLboolean flag);
+void ( APIENTRY * qglDepthRange )(GLclampd zNear, GLclampd zFar);
+void ( APIENTRY * qglDisable )(GLenum cap);
+void ( APIENTRY * qglDisableClientState )(GLenum array);
+void ( APIENTRY * qglDrawArrays )(GLenum mode, GLint first, GLsizei count);
+void ( APIENTRY * qglDrawBuffer )(GLenum mode);
+void ( APIENTRY * qglDrawElements )(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices);
+void ( APIENTRY * qglDrawPixels )(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
+void ( APIENTRY * qglEdgeFlag )(GLboolean flag);
+void ( APIENTRY * qglEdgeFlagPointer )(GLsizei stride, const GLvoid *pointer);
+void ( APIENTRY * qglEdgeFlagv )(const GLboolean *flag);
+void ( APIENTRY * qglEnable )(GLenum cap);
+void ( APIENTRY * qglEnableClientState )(GLenum array);
+void ( APIENTRY * qglEnd )(void);
+void ( APIENTRY * qglEndList )(void);
+void ( APIENTRY * qglEvalCoord1d )(GLdouble u);
+void ( APIENTRY * qglEvalCoord1dv )(const GLdouble *u);
+void ( APIENTRY * qglEvalCoord1f )(GLfloat u);
+void ( APIENTRY * qglEvalCoord1fv )(const GLfloat *u);
+void ( APIENTRY * qglEvalCoord2d )(GLdouble u, GLdouble v);
+void ( APIENTRY * qglEvalCoord2dv )(const GLdouble *u);
+void ( APIENTRY * qglEvalCoord2f )(GLfloat u, GLfloat v);
+void ( APIENTRY * qglEvalCoord2fv )(const GLfloat *u);
+void ( APIENTRY * qglEvalMesh1 )(GLenum mode, GLint i1, GLint i2);
+void ( APIENTRY * qglEvalMesh2 )(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2);
+void ( APIENTRY * qglEvalPoint1 )(GLint i);
+void ( APIENTRY * qglEvalPoint2 )(GLint i, GLint j);
+void ( APIENTRY * qglFeedbackBuffer )(GLsizei size, GLenum type, GLfloat *buffer);
+void ( APIENTRY * qglFinish )(void);
+void ( APIENTRY * qglFlush )(void);
+void ( APIENTRY * qglFogf )(GLenum pname, GLfloat param);
+void ( APIENTRY * qglFogfv )(GLenum pname, const GLfloat *params);
+void ( APIENTRY * qglFogi )(GLenum pname, GLint param);
+void ( APIENTRY * qglFogiv )(GLenum pname, const GLint *params);
+void ( APIENTRY * qglFrontFace )(GLenum mode);
+void ( APIENTRY * qglFrustum )(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
+GLuint ( APIENTRY * qglGenLists )(GLsizei range);
+void ( APIENTRY * qglGenTextures )(GLsizei n, GLuint *textures);
+void ( APIENTRY * qglGetBooleanv )(GLenum pname, GLboolean *params);
+void ( APIENTRY * qglGetClipPlane )(GLenum plane, GLdouble *equation);
+void ( APIENTRY * qglGetDoublev )(GLenum pname, GLdouble *params);
+GLenum ( APIENTRY * qglGetError )(void);
+void ( APIENTRY * qglGetFloatv )(GLenum pname, GLfloat *params);
+void ( APIENTRY * qglGetIntegerv )(GLenum pname, GLint *params);
+void ( APIENTRY * qglGetLightfv )(GLenum light, GLenum pname, GLfloat *params);
+void ( APIENTRY * qglGetLightiv )(GLenum light, GLenum pname, GLint *params);
+void ( APIENTRY * qglGetMapdv )(GLenum target, GLenum query, GLdouble *v);
+void ( APIENTRY * qglGetMapfv )(GLenum target, GLenum query, GLfloat *v);
+void ( APIENTRY * qglGetMapiv )(GLenum target, GLenum query, GLint *v);
+void ( APIENTRY * qglGetMaterialfv )(GLenum face, GLenum pname, GLfloat *params);
+void ( APIENTRY * qglGetMaterialiv )(GLenum face, GLenum pname, GLint *params);
+void ( APIENTRY * qglGetPixelMapfv )(GLenum map, GLfloat *values);
+void ( APIENTRY * qglGetPixelMapuiv )(GLenum map, GLuint *values);
+void ( APIENTRY * qglGetPixelMapusv )(GLenum map, GLushort *values);
+void ( APIENTRY * qglGetPointerv )(GLenum pname, GLvoid* *params);
+void ( APIENTRY * qglGetPolygonStipple )(GLubyte *mask);
+const GLubyte * ( APIENTRY * qglGetString )(GLenum name);
+void ( APIENTRY * qglGetTexEnvfv )(GLenum target, GLenum pname, GLfloat *params);
+void ( APIENTRY * qglGetTexEnviv )(GLenum target, GLenum pname, GLint *params);
+void ( APIENTRY * qglGetTexGendv )(GLenum coord, GLenum pname, GLdouble *params);
+void ( APIENTRY * qglGetTexGenfv )(GLenum coord, GLenum pname, GLfloat *params);
+void ( APIENTRY * qglGetTexGeniv )(GLenum coord, GLenum pname, GLint *params);
+void ( APIENTRY * qglGetTexImage )(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels);
+void ( APIENTRY * qglGetTexLevelParameterfv )(GLenum target, GLint level, GLenum pname, GLfloat *params);
+void ( APIENTRY * qglGetTexLevelParameteriv )(GLenum target, GLint level, GLenum pname, GLint *params);
+void ( APIENTRY * qglGetTexParameterfv )(GLenum target, GLenum pname, GLfloat *params);
+void ( APIENTRY * qglGetTexParameteriv )(GLenum target, GLenum pname, GLint *params);
+void ( APIENTRY * qglHint )(GLenum target, GLenum mode);
+void ( APIENTRY * qglIndexMask )(GLuint mask);
+void ( APIENTRY * qglIndexPointer )(GLenum type, GLsizei stride, const GLvoid *pointer);
+void ( APIENTRY * qglIndexd )(GLdouble c);
+void ( APIENTRY * qglIndexdv )(const GLdouble *c);
+void ( APIENTRY * qglIndexf )(GLfloat c);
+void ( APIENTRY * qglIndexfv )(const GLfloat *c);
+void ( APIENTRY * qglIndexi )(GLint c);
+void ( APIENTRY * qglIndexiv )(const GLint *c);
+void ( APIENTRY * qglIndexs )(GLshort c);
+void ( APIENTRY * qglIndexsv )(const GLshort *c);
+void ( APIENTRY * qglIndexub )(GLubyte c);
+void ( APIENTRY * qglIndexubv )(const GLubyte *c);
+void ( APIENTRY * qglInitNames )(void);
+void ( APIENTRY * qglInterleavedArrays )(GLenum format, GLsizei stride, const GLvoid *pointer);
+GLboolean ( APIENTRY * qglIsEnabled )(GLenum cap);
+GLboolean ( APIENTRY * qglIsList )(GLuint list);
+GLboolean ( APIENTRY * qglIsTexture )(GLuint texture);
+void ( APIENTRY * qglLightModelf )(GLenum pname, GLfloat param);
+void ( APIENTRY * qglLightModelfv )(GLenum pname, const GLfloat *params);
+void ( APIENTRY * qglLightModeli )(GLenum pname, GLint param);
+void ( APIENTRY * qglLightModeliv )(GLenum pname, const GLint *params);
+void ( APIENTRY * qglLightf )(GLenum light, GLenum pname, GLfloat param);
+void ( APIENTRY * qglLightfv )(GLenum light, GLenum pname, const GLfloat *params);
+void ( APIENTRY * qglLighti )(GLenum light, GLenum pname, GLint param);
+void ( APIENTRY * qglLightiv )(GLenum light, GLenum pname, const GLint *params);
+void ( APIENTRY * qglLineStipple )(GLint factor, GLushort pattern);
+void ( APIENTRY * qglLineWidth )(GLfloat width);
+void ( APIENTRY * qglListBase )(GLuint base);
+void ( APIENTRY * qglLoadIdentity )(void);
+void ( APIENTRY * qglLoadMatrixd )(const GLdouble *m);
+void ( APIENTRY * qglLoadMatrixf )(const GLfloat *m);
+void ( APIENTRY * qglLoadName )(GLuint name);
+void ( APIENTRY * qglLogicOp )(GLenum opcode);
+void ( APIENTRY * qglMap1d )(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points);
+void ( APIENTRY * qglMap1f )(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points);
+void ( APIENTRY * qglMap2d )(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points);
+void ( APIENTRY * qglMap2f )(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points);
+void ( APIENTRY * qglMapGrid1d )(GLint un, GLdouble u1, GLdouble u2);
+void ( APIENTRY * qglMapGrid1f )(GLint un, GLfloat u1, GLfloat u2);
+void ( APIENTRY * qglMapGrid2d )(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2);
+void ( APIENTRY * qglMapGrid2f )(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2);
+void ( APIENTRY * qglMaterialf )(GLenum face, GLenum pname, GLfloat param);
+void ( APIENTRY * qglMaterialfv )(GLenum face, GLenum pname, const GLfloat *params);
+void ( APIENTRY * qglMateriali )(GLenum face, GLenum pname, GLint param);
+void ( APIENTRY * qglMaterialiv )(GLenum face, GLenum pname, const GLint *params);
+void ( APIENTRY * qglMatrixMode )(GLenum mode);
+void ( APIENTRY * qglMultMatrixd )(const GLdouble *m);
+void ( APIENTRY * qglMultMatrixf )(const GLfloat *m);
+void ( APIENTRY * qglNewList )(GLuint list, GLenum mode);
+void ( APIENTRY * qglNormal3b )(GLbyte nx, GLbyte ny, GLbyte nz);
+void ( APIENTRY * qglNormal3bv )(const GLbyte *v);
+void ( APIENTRY * qglNormal3d )(GLdouble nx, GLdouble ny, GLdouble nz);
+void ( APIENTRY * qglNormal3dv )(const GLdouble *v);
+void ( APIENTRY * qglNormal3f )(GLfloat nx, GLfloat ny, GLfloat nz);
+void ( APIENTRY * qglNormal3fv )(const GLfloat *v);
+void ( APIENTRY * qglNormal3i )(GLint nx, GLint ny, GLint nz);
+void ( APIENTRY * qglNormal3iv )(const GLint *v);
+void ( APIENTRY * qglNormal3s )(GLshort nx, GLshort ny, GLshort nz);
+void ( APIENTRY * qglNormal3sv )(const GLshort *v);
+void ( APIENTRY * qglNormalPointer )(GLenum type, GLsizei stride, const GLvoid *pointer);
+void ( APIENTRY * qglOrtho )(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
+void ( APIENTRY * qglPassThrough )(GLfloat token);
+void ( APIENTRY * qglPixelMapfv )(GLenum map, GLsizei mapsize, const GLfloat *values);
+void ( APIENTRY * qglPixelMapuiv )(GLenum map, GLsizei mapsize, const GLuint *values);
+void ( APIENTRY * qglPixelMapusv )(GLenum map, GLsizei mapsize, const GLushort *values);
+void ( APIENTRY * qglPixelStoref )(GLenum pname, GLfloat param);
+void ( APIENTRY * qglPixelStorei )(GLenum pname, GLint param);
+void ( APIENTRY * qglPixelTransferf )(GLenum pname, GLfloat param);
+void ( APIENTRY * qglPixelTransferi )(GLenum pname, GLint param);
+void ( APIENTRY * qglPixelZoom )(GLfloat xfactor, GLfloat yfactor);
+void ( APIENTRY * qglPointSize )(GLfloat size);
+void ( APIENTRY * qglPolygonMode )(GLenum face, GLenum mode);
+void ( APIENTRY * qglPolygonOffset )(GLfloat factor, GLfloat units);
+void ( APIENTRY * qglPolygonStipple )(const GLubyte *mask);
+void ( APIENTRY * qglPopAttrib )(void);
+void ( APIENTRY * qglPopClientAttrib )(void);
+void ( APIENTRY * qglPopMatrix )(void);
+void ( APIENTRY * qglPopName )(void);
+void ( APIENTRY * qglPrioritizeTextures )(GLsizei n, const GLuint *textures, const GLclampf *priorities);
+void ( APIENTRY * qglPushAttrib )(GLbitfield mask);
+void ( APIENTRY * qglPushClientAttrib )(GLbitfield mask);
+void ( APIENTRY * qglPushMatrix )(void);
+void ( APIENTRY * qglPushName )(GLuint name);
+void ( APIENTRY * qglRasterPos2d )(GLdouble x, GLdouble y);
+void ( APIENTRY * qglRasterPos2dv )(const GLdouble *v);
+void ( APIENTRY * qglRasterPos2f )(GLfloat x, GLfloat y);
+void ( APIENTRY * qglRasterPos2fv )(const GLfloat *v);
+void ( APIENTRY * qglRasterPos2i )(GLint x, GLint y);
+void ( APIENTRY * qglRasterPos2iv )(const GLint *v);
+void ( APIENTRY * qglRasterPos2s )(GLshort x, GLshort y);
+void ( APIENTRY * qglRasterPos2sv )(const GLshort *v);
+void ( APIENTRY * qglRasterPos3d )(GLdouble x, GLdouble y, GLdouble z);
+void ( APIENTRY * qglRasterPos3dv )(const GLdouble *v);
+void ( APIENTRY * qglRasterPos3f )(GLfloat x, GLfloat y, GLfloat z);
+void ( APIENTRY * qglRasterPos3fv )(const GLfloat *v);
+void ( APIENTRY * qglRasterPos3i )(GLint x, GLint y, GLint z);
+void ( APIENTRY * qglRasterPos3iv )(const GLint *v);
+void ( APIENTRY * qglRasterPos3s )(GLshort x, GLshort y, GLshort z);
+void ( APIENTRY * qglRasterPos3sv )(const GLshort *v);
+void ( APIENTRY * qglRasterPos4d )(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+void ( APIENTRY * qglRasterPos4dv )(const GLdouble *v);
+void ( APIENTRY * qglRasterPos4f )(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+void ( APIENTRY * qglRasterPos4fv )(const GLfloat *v);
+void ( APIENTRY * qglRasterPos4i )(GLint x, GLint y, GLint z, GLint w);
+void ( APIENTRY * qglRasterPos4iv )(const GLint *v);
+void ( APIENTRY * qglRasterPos4s )(GLshort x, GLshort y, GLshort z, GLshort w);
+void ( APIENTRY * qglRasterPos4sv )(const GLshort *v);
+void ( APIENTRY * qglReadBuffer )(GLenum mode);
+void ( APIENTRY * qglReadPixels )(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels);
+void ( APIENTRY * qglRectd )(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2);
+void ( APIENTRY * qglRectdv )(const GLdouble *v1, const GLdouble *v2);
+void ( APIENTRY * qglRectf )(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2);
+void ( APIENTRY * qglRectfv )(const GLfloat *v1, const GLfloat *v2);
+void ( APIENTRY * qglRecti )(GLint x1, GLint y1, GLint x2, GLint y2);
+void ( APIENTRY * qglRectiv )(const GLint *v1, const GLint *v2);
+void ( APIENTRY * qglRects )(GLshort x1, GLshort y1, GLshort x2, GLshort y2);
+void ( APIENTRY * qglRectsv )(const GLshort *v1, const GLshort *v2);
+GLint ( APIENTRY * qglRenderMode )(GLenum mode);
+void ( APIENTRY * qglRotated )(GLdouble angle, GLdouble x, GLdouble y, GLdouble z);
+void ( APIENTRY * qglRotatef )(GLfloat angle, GLfloat x, GLfloat y, GLfloat z);
+void ( APIENTRY * qglScaled )(GLdouble x, GLdouble y, GLdouble z);
+void ( APIENTRY * qglScalef )(GLfloat x, GLfloat y, GLfloat z);
+void ( APIENTRY * qglScissor )(GLint x, GLint y, GLsizei width, GLsizei height);
+void ( APIENTRY * qglSelectBuffer )(GLsizei size, GLuint *buffer);
+void ( APIENTRY * qglShadeModel )(GLenum mode);
+void ( APIENTRY * qglStencilFunc )(GLenum func, GLint ref, GLuint mask);
+void ( APIENTRY * qglStencilMask )(GLuint mask);
+void ( APIENTRY * qglStencilOp )(GLenum fail, GLenum zfail, GLenum zpass);
+void ( APIENTRY * qglTexCoord1d )(GLdouble s);
+void ( APIENTRY * qglTexCoord1dv )(const GLdouble *v);
+void ( APIENTRY * qglTexCoord1f )(GLfloat s);
+void ( APIENTRY * qglTexCoord1fv )(const GLfloat *v);
+void ( APIENTRY * qglTexCoord1i )(GLint s);
+void ( APIENTRY * qglTexCoord1iv )(const GLint *v);
+void ( APIENTRY * qglTexCoord1s )(GLshort s);
+void ( APIENTRY * qglTexCoord1sv )(const GLshort *v);
+void ( APIENTRY * qglTexCoord2d )(GLdouble s, GLdouble t);
+void ( APIENTRY * qglTexCoord2dv )(const GLdouble *v);
+void ( APIENTRY * qglTexCoord2f )(GLfloat s, GLfloat t);
+void ( APIENTRY * qglTexCoord2fv )(const GLfloat *v);
+void ( APIENTRY * qglTexCoord2i )(GLint s, GLint t);
+void ( APIENTRY * qglTexCoord2iv )(const GLint *v);
+void ( APIENTRY * qglTexCoord2s )(GLshort s, GLshort t);
+void ( APIENTRY * qglTexCoord2sv )(const GLshort *v);
+void ( APIENTRY * qglTexCoord3d )(GLdouble s, GLdouble t, GLdouble r);
+void ( APIENTRY * qglTexCoord3dv )(const GLdouble *v);
+void ( APIENTRY * qglTexCoord3f )(GLfloat s, GLfloat t, GLfloat r);
+void ( APIENTRY * qglTexCoord3fv )(const GLfloat *v);
+void ( APIENTRY * qglTexCoord3i )(GLint s, GLint t, GLint r);
+void ( APIENTRY * qglTexCoord3iv )(const GLint *v);
+void ( APIENTRY * qglTexCoord3s )(GLshort s, GLshort t, GLshort r);
+void ( APIENTRY * qglTexCoord3sv )(const GLshort *v);
+void ( APIENTRY * qglTexCoord4d )(GLdouble s, GLdouble t, GLdouble r, GLdouble q);
+void ( APIENTRY * qglTexCoord4dv )(const GLdouble *v);
+void ( APIENTRY * qglTexCoord4f )(GLfloat s, GLfloat t, GLfloat r, GLfloat q);
+void ( APIENTRY * qglTexCoord4fv )(const GLfloat *v);
+void ( APIENTRY * qglTexCoord4i )(GLint s, GLint t, GLint r, GLint q);
+void ( APIENTRY * qglTexCoord4iv )(const GLint *v);
+void ( APIENTRY * qglTexCoord4s )(GLshort s, GLshort t, GLshort r, GLshort q);
+void ( APIENTRY * qglTexCoord4sv )(const GLshort *v);
+void ( APIENTRY * qglTexCoordPointer )(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
+void ( APIENTRY * qglTexEnvf )(GLenum target, GLenum pname, GLfloat param);
+void ( APIENTRY * qglTexEnvfv )(GLenum target, GLenum pname, const GLfloat *params);
+void ( APIENTRY * qglTexEnvi )(GLenum target, GLenum pname, GLint param);
+void ( APIENTRY * qglTexEnviv )(GLenum target, GLenum pname, const GLint *params);
+void ( APIENTRY * qglTexGend )(GLenum coord, GLenum pname, GLdouble param);
+void ( APIENTRY * qglTexGendv )(GLenum coord, GLenum pname, const GLdouble *params);
+void ( APIENTRY * qglTexGenf )(GLenum coord, GLenum pname, GLfloat param);
+void ( APIENTRY * qglTexGenfv )(GLenum coord, GLenum pname, const GLfloat *params);
+void ( APIENTRY * qglTexGeni )(GLenum coord, GLenum pname, GLint param);
+void ( APIENTRY * qglTexGeniv )(GLenum coord, GLenum pname, const GLint *params);
+void ( APIENTRY * qglTexImage1D )(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
+void ( APIENTRY * qglTexImage2D )(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
+void ( APIENTRY * qglTexParameterf )(GLenum target, GLenum pname, GLfloat param);
+void ( APIENTRY * qglTexParameterfv )(GLenum target, GLenum pname, const GLfloat *params);
+void ( APIENTRY * qglTexParameteri )(GLenum target, GLenum pname, GLint param);
+void ( APIENTRY * qglTexParameteriv )(GLenum target, GLenum pname, const GLint *params);
+void ( APIENTRY * qglTexSubImage1D )(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels);
+void ( APIENTRY * qglTexSubImage2D )(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
+void ( APIENTRY * qglTranslated )(GLdouble x, GLdouble y, GLdouble z);
+void ( APIENTRY * qglTranslatef )(GLfloat x, GLfloat y, GLfloat z);
+void ( APIENTRY * qglVertex2d )(GLdouble x, GLdouble y);
+void ( APIENTRY * qglVertex2dv )(const GLdouble *v);
+void ( APIENTRY * qglVertex2f )(GLfloat x, GLfloat y);
+void ( APIENTRY * qglVertex2fv )(const GLfloat *v);
+void ( APIENTRY * qglVertex2i )(GLint x, GLint y);
+void ( APIENTRY * qglVertex2iv )(const GLint *v);
+void ( APIENTRY * qglVertex2s )(GLshort x, GLshort y);
+void ( APIENTRY * qglVertex2sv )(const GLshort *v);
+void ( APIENTRY * qglVertex3d )(GLdouble x, GLdouble y, GLdouble z);
+void ( APIENTRY * qglVertex3dv )(const GLdouble *v);
+void ( APIENTRY * qglVertex3f )(GLfloat x, GLfloat y, GLfloat z);
+void ( APIENTRY * qglVertex3fv )(const GLfloat *v);
+void ( APIENTRY * qglVertex3i )(GLint x, GLint y, GLint z);
+void ( APIENTRY * qglVertex3iv )(const GLint *v);
+void ( APIENTRY * qglVertex3s )(GLshort x, GLshort y, GLshort z);
+void ( APIENTRY * qglVertex3sv )(const GLshort *v);
+void ( APIENTRY * qglVertex4d )(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+void ( APIENTRY * qglVertex4dv )(const GLdouble *v);
+void ( APIENTRY * qglVertex4f )(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+void ( APIENTRY * qglVertex4fv )(const GLfloat *v);
+void ( APIENTRY * qglVertex4i )(GLint x, GLint y, GLint z, GLint w);
+void ( APIENTRY * qglVertex4iv )(const GLint *v);
+void ( APIENTRY * qglVertex4s )(GLshort x, GLshort y, GLshort z, GLshort w);
+void ( APIENTRY * qglVertex4sv )(const GLshort *v);
+void ( APIENTRY * qglVertexPointer )(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
+void ( APIENTRY * qglViewport )(GLint x, GLint y, GLsizei width, GLsizei height);
+
+void ( APIENTRY * qglMultiTexCoord2fARB )( GLenum texture, GLfloat s, GLfloat t );
+void ( APIENTRY * qglActiveTextureARB )( GLenum texture );
+void ( APIENTRY * qglClientActiveTextureARB )( GLenum texture );
+
+void ( APIENTRY * qglLockArraysEXT)( int, int);
+void ( APIENTRY * qglUnlockArraysEXT) ( void );
+
+void ( APIENTRY * qglPointParameterfEXT)( GLenum param, GLfloat value );
+void ( APIENTRY * qglPointParameterfvEXT)( GLenum param, const GLfloat *value );
+void ( APIENTRY * qglColorTableEXT)( int, int, int, int, int, const void * );
+void ( APIENTRY * qgl3DfxSetPaletteEXT)( GLuint * );
+void ( APIENTRY * qglSelectTextureSGIS)( GLenum );
+void ( APIENTRY * qglMTexCoord2fSGIS)( GLenum, GLfloat, GLfloat );
+
+static void ( APIENTRY * dllAccum )(GLenum op, GLfloat value);
+static void ( APIENTRY * dllAlphaFunc )(GLenum func, GLclampf ref);
+GLboolean ( APIENTRY * dllAreTexturesResident )(GLsizei n, const GLuint *textures, GLboolean *residences);
+static void ( APIENTRY * dllArrayElement )(GLint i);
+static void ( APIENTRY * dllBegin )(GLenum mode);
+static void ( APIENTRY * dllBindTexture )(GLenum target, GLuint texture);
+static void ( APIENTRY * dllBitmap )(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap);
+static void ( APIENTRY * dllBlendFunc )(GLenum sfactor, GLenum dfactor);
+static void ( APIENTRY * dllCallList )(GLuint list);
+static void ( APIENTRY * dllCallLists )(GLsizei n, GLenum type, const GLvoid *lists);
+static void ( APIENTRY * dllClear )(GLbitfield mask);
+static void ( APIENTRY * dllClearAccum )(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
+static void ( APIENTRY * dllClearColor )(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
+static void ( APIENTRY * dllClearDepth )(GLclampd depth);
+static void ( APIENTRY * dllClearIndex )(GLfloat c);
+static void ( APIENTRY * dllClearStencil )(GLint s);
+static void ( APIENTRY * dllClipPlane )(GLenum plane, const GLdouble *equation);
+static void ( APIENTRY * dllColor3b )(GLbyte red, GLbyte green, GLbyte blue);
+static void ( APIENTRY * dllColor3bv )(const GLbyte *v);
+static void ( APIENTRY * dllColor3d )(GLdouble red, GLdouble green, GLdouble blue);
+static void ( APIENTRY * dllColor3dv )(const GLdouble *v);
+static void ( APIENTRY * dllColor3f )(GLfloat red, GLfloat green, GLfloat blue);
+static void ( APIENTRY * dllColor3fv )(const GLfloat *v);
+static void ( APIENTRY * dllColor3i )(GLint red, GLint green, GLint blue);
+static void ( APIENTRY * dllColor3iv )(const GLint *v);
+static void ( APIENTRY * dllColor3s )(GLshort red, GLshort green, GLshort blue);
+static void ( APIENTRY * dllColor3sv )(const GLshort *v);
+static void ( APIENTRY * dllColor3ub )(GLubyte red, GLubyte green, GLubyte blue);
+static void ( APIENTRY * dllColor3ubv )(const GLubyte *v);
+static void ( APIENTRY * dllColor3ui )(GLuint red, GLuint green, GLuint blue);
+static void ( APIENTRY * dllColor3uiv )(const GLuint *v);
+static void ( APIENTRY * dllColor3us )(GLushort red, GLushort green, GLushort blue);
+static void ( APIENTRY * dllColor3usv )(const GLushort *v);
+static void ( APIENTRY * dllColor4b )(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha);
+static void ( APIENTRY * dllColor4bv )(const GLbyte *v);
+static void ( APIENTRY * dllColor4d )(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha);
+static void ( APIENTRY * dllColor4dv )(const GLdouble *v);
+static void ( APIENTRY * dllColor4f )(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
+static void ( APIENTRY * dllColor4fv )(const GLfloat *v);
+static void ( APIENTRY * dllColor4i )(GLint red, GLint green, GLint blue, GLint alpha);
+static void ( APIENTRY * dllColor4iv )(const GLint *v);
+static void ( APIENTRY * dllColor4s )(GLshort red, GLshort green, GLshort blue, GLshort alpha);
+static void ( APIENTRY * dllColor4sv )(const GLshort *v);
+static void ( APIENTRY * dllColor4ub )(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha);
+static void ( APIENTRY * dllColor4ubv )(const GLubyte *v);
+static void ( APIENTRY * dllColor4ui )(GLuint red, GLuint green, GLuint blue, GLuint alpha);
+static void ( APIENTRY * dllColor4uiv )(const GLuint *v);
+static void ( APIENTRY * dllColor4us )(GLushort red, GLushort green, GLushort blue, GLushort alpha);
+static void ( APIENTRY * dllColor4usv )(const GLushort *v);
+static void ( APIENTRY * dllColorMask )(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
+static void ( APIENTRY * dllColorMaterial )(GLenum face, GLenum mode);
+static void ( APIENTRY * dllColorPointer )(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
+static void ( APIENTRY * dllCopyPixels )(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type);
+static void ( APIENTRY * dllCopyTexImage1D )(GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border);
+static void ( APIENTRY * dllCopyTexImage2D )(GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
+static void ( APIENTRY * dllCopyTexSubImage1D )(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);
+static void ( APIENTRY * dllCopyTexSubImage2D )(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
+static void ( APIENTRY * dllCullFace )(GLenum mode);
+static void ( APIENTRY * dllDeleteLists )(GLuint list, GLsizei range);
+static void ( APIENTRY * dllDeleteTextures )(GLsizei n, const GLuint *textures);
+static void ( APIENTRY * dllDepthFunc )(GLenum func);
+static void ( APIENTRY * dllDepthMask )(GLboolean flag);
+static void ( APIENTRY * dllDepthRange )(GLclampd zNear, GLclampd zFar);
+static void ( APIENTRY * dllDisable )(GLenum cap);
+static void ( APIENTRY * dllDisableClientState )(GLenum array);
+static void ( APIENTRY * dllDrawArrays )(GLenum mode, GLint first, GLsizei count);
+static void ( APIENTRY * dllDrawBuffer )(GLenum mode);
+static void ( APIENTRY * dllDrawElements )(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices);
+static void ( APIENTRY * dllDrawPixels )(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
+static void ( APIENTRY * dllEdgeFlag )(GLboolean flag);
+static void ( APIENTRY * dllEdgeFlagPointer )(GLsizei stride, const GLvoid *pointer);
+static void ( APIENTRY * dllEdgeFlagv )(const GLboolean *flag);
+static void ( APIENTRY * dllEnable )(GLenum cap);
+static void ( APIENTRY * dllEnableClientState )(GLenum array);
+static void ( APIENTRY * dllEnd )(void);
+static void ( APIENTRY * dllEndList )(void);
+static void ( APIENTRY * dllEvalCoord1d )(GLdouble u);
+static void ( APIENTRY * dllEvalCoord1dv )(const GLdouble *u);
+static void ( APIENTRY * dllEvalCoord1f )(GLfloat u);
+static void ( APIENTRY * dllEvalCoord1fv )(const GLfloat *u);
+static void ( APIENTRY * dllEvalCoord2d )(GLdouble u, GLdouble v);
+static void ( APIENTRY * dllEvalCoord2dv )(const GLdouble *u);
+static void ( APIENTRY * dllEvalCoord2f )(GLfloat u, GLfloat v);
+static void ( APIENTRY * dllEvalCoord2fv )(const GLfloat *u);
+static void ( APIENTRY * dllEvalMesh1 )(GLenum mode, GLint i1, GLint i2);
+static void ( APIENTRY * dllEvalMesh2 )(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2);
+static void ( APIENTRY * dllEvalPoint1 )(GLint i);
+static void ( APIENTRY * dllEvalPoint2 )(GLint i, GLint j);
+static void ( APIENTRY * dllFeedbackBuffer )(GLsizei size, GLenum type, GLfloat *buffer);
+static void ( APIENTRY * dllFinish )(void);
+static void ( APIENTRY * dllFlush )(void);
+static void ( APIENTRY * dllFogf )(GLenum pname, GLfloat param);
+static void ( APIENTRY * dllFogfv )(GLenum pname, const GLfloat *params);
+static void ( APIENTRY * dllFogi )(GLenum pname, GLint param);
+static void ( APIENTRY * dllFogiv )(GLenum pname, const GLint *params);
+static void ( APIENTRY * dllFrontFace )(GLenum mode);
+static void ( APIENTRY * dllFrustum )(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
+GLuint ( APIENTRY * dllGenLists )(GLsizei range);
+static void ( APIENTRY * dllGenTextures )(GLsizei n, GLuint *textures);
+static void ( APIENTRY * dllGetBooleanv )(GLenum pname, GLboolean *params);
+static void ( APIENTRY * dllGetClipPlane )(GLenum plane, GLdouble *equation);
+static void ( APIENTRY * dllGetDoublev )(GLenum pname, GLdouble *params);
+GLenum ( APIENTRY * dllGetError )(void);
+static void ( APIENTRY * dllGetFloatv )(GLenum pname, GLfloat *params);
+static void ( APIENTRY * dllGetIntegerv )(GLenum pname, GLint *params);
+static void ( APIENTRY * dllGetLightfv )(GLenum light, GLenum pname, GLfloat *params);
+static void ( APIENTRY * dllGetLightiv )(GLenum light, GLenum pname, GLint *params);
+static void ( APIENTRY * dllGetMapdv )(GLenum target, GLenum query, GLdouble *v);
+static void ( APIENTRY * dllGetMapfv )(GLenum target, GLenum query, GLfloat *v);
+static void ( APIENTRY * dllGetMapiv )(GLenum target, GLenum query, GLint *v);
+static void ( APIENTRY * dllGetMaterialfv )(GLenum face, GLenum pname, GLfloat *params);
+static void ( APIENTRY * dllGetMaterialiv )(GLenum face, GLenum pname, GLint *params);
+static void ( APIENTRY * dllGetPixelMapfv )(GLenum map, GLfloat *values);
+static void ( APIENTRY * dllGetPixelMapuiv )(GLenum map, GLuint *values);
+static void ( APIENTRY * dllGetPixelMapusv )(GLenum map, GLushort *values);
+static void ( APIENTRY * dllGetPointerv )(GLenum pname, GLvoid* *params);
+static void ( APIENTRY * dllGetPolygonStipple )(GLubyte *mask);
+const GLubyte * ( APIENTRY * dllGetString )(GLenum name);
+static void ( APIENTRY * dllGetTexEnvfv )(GLenum target, GLenum pname, GLfloat *params);
+static void ( APIENTRY * dllGetTexEnviv )(GLenum target, GLenum pname, GLint *params);
+static void ( APIENTRY * dllGetTexGendv )(GLenum coord, GLenum pname, GLdouble *params);
+static void ( APIENTRY * dllGetTexGenfv )(GLenum coord, GLenum pname, GLfloat *params);
+static void ( APIENTRY * dllGetTexGeniv )(GLenum coord, GLenum pname, GLint *params);
+static void ( APIENTRY * dllGetTexImage )(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels);
+static void ( APIENTRY * dllGetTexLevelParameterfv )(GLenum target, GLint level, GLenum pname, GLfloat *params);
+static void ( APIENTRY * dllGetTexLevelParameteriv )(GLenum target, GLint level, GLenum pname, GLint *params);
+static void ( APIENTRY * dllGetTexParameterfv )(GLenum target, GLenum pname, GLfloat *params);
+static void ( APIENTRY * dllGetTexParameteriv )(GLenum target, GLenum pname, GLint *params);
+static void ( APIENTRY * dllHint )(GLenum target, GLenum mode);
+static void ( APIENTRY * dllIndexMask )(GLuint mask);
+static void ( APIENTRY * dllIndexPointer )(GLenum type, GLsizei stride, const GLvoid *pointer);
+static void ( APIENTRY * dllIndexd )(GLdouble c);
+static void ( APIENTRY * dllIndexdv )(const GLdouble *c);
+static void ( APIENTRY * dllIndexf )(GLfloat c);
+static void ( APIENTRY * dllIndexfv )(const GLfloat *c);
+static void ( APIENTRY * dllIndexi )(GLint c);
+static void ( APIENTRY * dllIndexiv )(const GLint *c);
+static void ( APIENTRY * dllIndexs )(GLshort c);
+static void ( APIENTRY * dllIndexsv )(const GLshort *c);
+static void ( APIENTRY * dllIndexub )(GLubyte c);
+static void ( APIENTRY * dllIndexubv )(const GLubyte *c);
+static void ( APIENTRY * dllInitNames )(void);
+static void ( APIENTRY * dllInterleavedArrays )(GLenum format, GLsizei stride, const GLvoid *pointer);
+GLboolean ( APIENTRY * dllIsEnabled )(GLenum cap);
+GLboolean ( APIENTRY * dllIsList )(GLuint list);
+GLboolean ( APIENTRY * dllIsTexture )(GLuint texture);
+static void ( APIENTRY * dllLightModelf )(GLenum pname, GLfloat param);
+static void ( APIENTRY * dllLightModelfv )(GLenum pname, const GLfloat *params);
+static void ( APIENTRY * dllLightModeli )(GLenum pname, GLint param);
+static void ( APIENTRY * dllLightModeliv )(GLenum pname, const GLint *params);
+static void ( APIENTRY * dllLightf )(GLenum light, GLenum pname, GLfloat param);
+static void ( APIENTRY * dllLightfv )(GLenum light, GLenum pname, const GLfloat *params);
+static void ( APIENTRY * dllLighti )(GLenum light, GLenum pname, GLint param);
+static void ( APIENTRY * dllLightiv )(GLenum light, GLenum pname, const GLint *params);
+static void ( APIENTRY * dllLineStipple )(GLint factor, GLushort pattern);
+static void ( APIENTRY * dllLineWidth )(GLfloat width);
+static void ( APIENTRY * dllListBase )(GLuint base);
+static void ( APIENTRY * dllLoadIdentity )(void);
+static void ( APIENTRY * dllLoadMatrixd )(const GLdouble *m);
+static void ( APIENTRY * dllLoadMatrixf )(const GLfloat *m);
+static void ( APIENTRY * dllLoadName )(GLuint name);
+static void ( APIENTRY * dllLogicOp )(GLenum opcode);
+static void ( APIENTRY * dllMap1d )(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points);
+static void ( APIENTRY * dllMap1f )(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points);
+static void ( APIENTRY * dllMap2d )(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points);
+static void ( APIENTRY * dllMap2f )(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points);
+static void ( APIENTRY * dllMapGrid1d )(GLint un, GLdouble u1, GLdouble u2);
+static void ( APIENTRY * dllMapGrid1f )(GLint un, GLfloat u1, GLfloat u2);
+static void ( APIENTRY * dllMapGrid2d )(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2);
+static void ( APIENTRY * dllMapGrid2f )(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2);
+static void ( APIENTRY * dllMaterialf )(GLenum face, GLenum pname, GLfloat param);
+static void ( APIENTRY * dllMaterialfv )(GLenum face, GLenum pname, const GLfloat *params);
+static void ( APIENTRY * dllMateriali )(GLenum face, GLenum pname, GLint param);
+static void ( APIENTRY * dllMaterialiv )(GLenum face, GLenum pname, const GLint *params);
+static void ( APIENTRY * dllMatrixMode )(GLenum mode);
+static void ( APIENTRY * dllMultMatrixd )(const GLdouble *m);
+static void ( APIENTRY * dllMultMatrixf )(const GLfloat *m);
+static void ( APIENTRY * dllNewList )(GLuint list, GLenum mode);
+static void ( APIENTRY * dllNormal3b )(GLbyte nx, GLbyte ny, GLbyte nz);
+static void ( APIENTRY * dllNormal3bv )(const GLbyte *v);
+static void ( APIENTRY * dllNormal3d )(GLdouble nx, GLdouble ny, GLdouble nz);
+static void ( APIENTRY * dllNormal3dv )(const GLdouble *v);
+static void ( APIENTRY * dllNormal3f )(GLfloat nx, GLfloat ny, GLfloat nz);
+static void ( APIENTRY * dllNormal3fv )(const GLfloat *v);
+static void ( APIENTRY * dllNormal3i )(GLint nx, GLint ny, GLint nz);
+static void ( APIENTRY * dllNormal3iv )(const GLint *v);
+static void ( APIENTRY * dllNormal3s )(GLshort nx, GLshort ny, GLshort nz);
+static void ( APIENTRY * dllNormal3sv )(const GLshort *v);
+static void ( APIENTRY * dllNormalPointer )(GLenum type, GLsizei stride, const GLvoid *pointer);
+static void ( APIENTRY * dllOrtho )(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
+static void ( APIENTRY * dllPassThrough )(GLfloat token);
+static void ( APIENTRY * dllPixelMapfv )(GLenum map, GLsizei mapsize, const GLfloat *values);
+static void ( APIENTRY * dllPixelMapuiv )(GLenum map, GLsizei mapsize, const GLuint *values);
+static void ( APIENTRY * dllPixelMapusv )(GLenum map, GLsizei mapsize, const GLushort *values);
+static void ( APIENTRY * dllPixelStoref )(GLenum pname, GLfloat param);
+static void ( APIENTRY * dllPixelStorei )(GLenum pname, GLint param);
+static void ( APIENTRY * dllPixelTransferf )(GLenum pname, GLfloat param);
+static void ( APIENTRY * dllPixelTransferi )(GLenum pname, GLint param);
+static void ( APIENTRY * dllPixelZoom )(GLfloat xfactor, GLfloat yfactor);
+static void ( APIENTRY * dllPointSize )(GLfloat size);
+static void ( APIENTRY * dllPolygonMode )(GLenum face, GLenum mode);
+static void ( APIENTRY * dllPolygonOffset )(GLfloat factor, GLfloat units);
+static void ( APIENTRY * dllPolygonStipple )(const GLubyte *mask);
+static void ( APIENTRY * dllPopAttrib )(void);
+static void ( APIENTRY * dllPopClientAttrib )(void);
+static void ( APIENTRY * dllPopMatrix )(void);
+static void ( APIENTRY * dllPopName )(void);
+static void ( APIENTRY * dllPrioritizeTextures )(GLsizei n, const GLuint *textures, const GLclampf *priorities);
+static void ( APIENTRY * dllPushAttrib )(GLbitfield mask);
+static void ( APIENTRY * dllPushClientAttrib )(GLbitfield mask);
+static void ( APIENTRY * dllPushMatrix )(void);
+static void ( APIENTRY * dllPushName )(GLuint name);
+static void ( APIENTRY * dllRasterPos2d )(GLdouble x, GLdouble y);
+static void ( APIENTRY * dllRasterPos2dv )(const GLdouble *v);
+static void ( APIENTRY * dllRasterPos2f )(GLfloat x, GLfloat y);
+static void ( APIENTRY * dllRasterPos2fv )(const GLfloat *v);
+static void ( APIENTRY * dllRasterPos2i )(GLint x, GLint y);
+static void ( APIENTRY * dllRasterPos2iv )(const GLint *v);
+static void ( APIENTRY * dllRasterPos2s )(GLshort x, GLshort y);
+static void ( APIENTRY * dllRasterPos2sv )(const GLshort *v);
+static void ( APIENTRY * dllRasterPos3d )(GLdouble x, GLdouble y, GLdouble z);
+static void ( APIENTRY * dllRasterPos3dv )(const GLdouble *v);
+static void ( APIENTRY * dllRasterPos3f )(GLfloat x, GLfloat y, GLfloat z);
+static void ( APIENTRY * dllRasterPos3fv )(const GLfloat *v);
+static void ( APIENTRY * dllRasterPos3i )(GLint x, GLint y, GLint z);
+static void ( APIENTRY * dllRasterPos3iv )(const GLint *v);
+static void ( APIENTRY * dllRasterPos3s )(GLshort x, GLshort y, GLshort z);
+static void ( APIENTRY * dllRasterPos3sv )(const GLshort *v);
+static void ( APIENTRY * dllRasterPos4d )(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+static void ( APIENTRY * dllRasterPos4dv )(const GLdouble *v);
+static void ( APIENTRY * dllRasterPos4f )(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+static void ( APIENTRY * dllRasterPos4fv )(const GLfloat *v);
+static void ( APIENTRY * dllRasterPos4i )(GLint x, GLint y, GLint z, GLint w);
+static void ( APIENTRY * dllRasterPos4iv )(const GLint *v);
+static void ( APIENTRY * dllRasterPos4s )(GLshort x, GLshort y, GLshort z, GLshort w);
+static void ( APIENTRY * dllRasterPos4sv )(const GLshort *v);
+static void ( APIENTRY * dllReadBuffer )(GLenum mode);
+static void ( APIENTRY * dllReadPixels )(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels);
+static void ( APIENTRY * dllRectd )(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2);
+static void ( APIENTRY * dllRectdv )(const GLdouble *v1, const GLdouble *v2);
+static void ( APIENTRY * dllRectf )(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2);
+static void ( APIENTRY * dllRectfv )(const GLfloat *v1, const GLfloat *v2);
+static void ( APIENTRY * dllRecti )(GLint x1, GLint y1, GLint x2, GLint y2);
+static void ( APIENTRY * dllRectiv )(const GLint *v1, const GLint *v2);
+static void ( APIENTRY * dllRects )(GLshort x1, GLshort y1, GLshort x2, GLshort y2);
+static void ( APIENTRY * dllRectsv )(const GLshort *v1, const GLshort *v2);
+GLint ( APIENTRY * dllRenderMode )(GLenum mode);
+static void ( APIENTRY * dllRotated )(GLdouble angle, GLdouble x, GLdouble y, GLdouble z);
+static void ( APIENTRY * dllRotatef )(GLfloat angle, GLfloat x, GLfloat y, GLfloat z);
+static void ( APIENTRY * dllScaled )(GLdouble x, GLdouble y, GLdouble z);
+static void ( APIENTRY * dllScalef )(GLfloat x, GLfloat y, GLfloat z);
+static void ( APIENTRY * dllScissor )(GLint x, GLint y, GLsizei width, GLsizei height);
+static void ( APIENTRY * dllSelectBuffer )(GLsizei size, GLuint *buffer);
+static void ( APIENTRY * dllShadeModel )(GLenum mode);
+static void ( APIENTRY * dllStencilFunc )(GLenum func, GLint ref, GLuint mask);
+static void ( APIENTRY * dllStencilMask )(GLuint mask);
+static void ( APIENTRY * dllStencilOp )(GLenum fail, GLenum zfail, GLenum zpass);
+static void ( APIENTRY * dllTexCoord1d )(GLdouble s);
+static void ( APIENTRY * dllTexCoord1dv )(const GLdouble *v);
+static void ( APIENTRY * dllTexCoord1f )(GLfloat s);
+static void ( APIENTRY * dllTexCoord1fv )(const GLfloat *v);
+static void ( APIENTRY * dllTexCoord1i )(GLint s);
+static void ( APIENTRY * dllTexCoord1iv )(const GLint *v);
+static void ( APIENTRY * dllTexCoord1s )(GLshort s);
+static void ( APIENTRY * dllTexCoord1sv )(const GLshort *v);
+static void ( APIENTRY * dllTexCoord2d )(GLdouble s, GLdouble t);
+static void ( APIENTRY * dllTexCoord2dv )(const GLdouble *v);
+static void ( APIENTRY * dllTexCoord2f )(GLfloat s, GLfloat t);
+static void ( APIENTRY * dllTexCoord2fv )(const GLfloat *v);
+static void ( APIENTRY * dllTexCoord2i )(GLint s, GLint t);
+static void ( APIENTRY * dllTexCoord2iv )(const GLint *v);
+static void ( APIENTRY * dllTexCoord2s )(GLshort s, GLshort t);
+static void ( APIENTRY * dllTexCoord2sv )(const GLshort *v);
+static void ( APIENTRY * dllTexCoord3d )(GLdouble s, GLdouble t, GLdouble r);
+static void ( APIENTRY * dllTexCoord3dv )(const GLdouble *v);
+static void ( APIENTRY * dllTexCoord3f )(GLfloat s, GLfloat t, GLfloat r);
+static void ( APIENTRY * dllTexCoord3fv )(const GLfloat *v);
+static void ( APIENTRY * dllTexCoord3i )(GLint s, GLint t, GLint r);
+static void ( APIENTRY * dllTexCoord3iv )(const GLint *v);
+static void ( APIENTRY * dllTexCoord3s )(GLshort s, GLshort t, GLshort r);
+static void ( APIENTRY * dllTexCoord3sv )(const GLshort *v);
+static void ( APIENTRY * dllTexCoord4d )(GLdouble s, GLdouble t, GLdouble r, GLdouble q);
+static void ( APIENTRY * dllTexCoord4dv )(const GLdouble *v);
+static void ( APIENTRY * dllTexCoord4f )(GLfloat s, GLfloat t, GLfloat r, GLfloat q);
+static void ( APIENTRY * dllTexCoord4fv )(const GLfloat *v);
+static void ( APIENTRY * dllTexCoord4i )(GLint s, GLint t, GLint r, GLint q);
+static void ( APIENTRY * dllTexCoord4iv )(const GLint *v);
+static void ( APIENTRY * dllTexCoord4s )(GLshort s, GLshort t, GLshort r, GLshort q);
+static void ( APIENTRY * dllTexCoord4sv )(const GLshort *v);
+static void ( APIENTRY * dllTexCoordPointer )(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
+static void ( APIENTRY * dllTexEnvf )(GLenum target, GLenum pname, GLfloat param);
+static void ( APIENTRY * dllTexEnvfv )(GLenum target, GLenum pname, const GLfloat *params);
+static void ( APIENTRY * dllTexEnvi )(GLenum target, GLenum pname, GLint param);
+static void ( APIENTRY * dllTexEnviv )(GLenum target, GLenum pname, const GLint *params);
+static void ( APIENTRY * dllTexGend )(GLenum coord, GLenum pname, GLdouble param);
+static void ( APIENTRY * dllTexGendv )(GLenum coord, GLenum pname, const GLdouble *params);
+static void ( APIENTRY * dllTexGenf )(GLenum coord, GLenum pname, GLfloat param);
+static void ( APIENTRY * dllTexGenfv )(GLenum coord, GLenum pname, const GLfloat *params);
+static void ( APIENTRY * dllTexGeni )(GLenum coord, GLenum pname, GLint param);
+static void ( APIENTRY * dllTexGeniv )(GLenum coord, GLenum pname, const GLint *params);
+static void ( APIENTRY * dllTexImage1D )(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
+static void ( APIENTRY * dllTexImage2D )(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
+static void ( APIENTRY * dllTexParameterf )(GLenum target, GLenum pname, GLfloat param);
+static void ( APIENTRY * dllTexParameterfv )(GLenum target, GLenum pname, const GLfloat *params);
+static void ( APIENTRY * dllTexParameteri )(GLenum target, GLenum pname, GLint param);
+static void ( APIENTRY * dllTexParameteriv )(GLenum target, GLenum pname, const GLint *params);
+static void ( APIENTRY * dllTexSubImage1D )(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels);
+static void ( APIENTRY * dllTexSubImage2D )(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
+static void ( APIENTRY * dllTranslated )(GLdouble x, GLdouble y, GLdouble z);
+static void ( APIENTRY * dllTranslatef )(GLfloat x, GLfloat y, GLfloat z);
+static void ( APIENTRY * dllVertex2d )(GLdouble x, GLdouble y);
+static void ( APIENTRY * dllVertex2dv )(const GLdouble *v);
+static void ( APIENTRY * dllVertex2f )(GLfloat x, GLfloat y);
+static void ( APIENTRY * dllVertex2fv )(const GLfloat *v);
+static void ( APIENTRY * dllVertex2i )(GLint x, GLint y);
+static void ( APIENTRY * dllVertex2iv )(const GLint *v);
+static void ( APIENTRY * dllVertex2s )(GLshort x, GLshort y);
+static void ( APIENTRY * dllVertex2sv )(const GLshort *v);
+static void ( APIENTRY * dllVertex3d )(GLdouble x, GLdouble y, GLdouble z);
+static void ( APIENTRY * dllVertex3dv )(const GLdouble *v);
+static void ( APIENTRY * dllVertex3f )(GLfloat x, GLfloat y, GLfloat z);
+static void ( APIENTRY * dllVertex3fv )(const GLfloat *v);
+static void ( APIENTRY * dllVertex3i )(GLint x, GLint y, GLint z);
+static void ( APIENTRY * dllVertex3iv )(const GLint *v);
+static void ( APIENTRY * dllVertex3s )(GLshort x, GLshort y, GLshort z);
+static void ( APIENTRY * dllVertex3sv )(const GLshort *v);
+static void ( APIENTRY * dllVertex4d )(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+static void ( APIENTRY * dllVertex4dv )(const GLdouble *v);
+static void ( APIENTRY * dllVertex4f )(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+static void ( APIENTRY * dllVertex4fv )(const GLfloat *v);
+static void ( APIENTRY * dllVertex4i )(GLint x, GLint y, GLint z, GLint w);
+static void ( APIENTRY * dllVertex4iv )(const GLint *v);
+static void ( APIENTRY * dllVertex4s )(GLshort x, GLshort y, GLshort z, GLshort w);
+static void ( APIENTRY * dllVertex4sv )(const GLshort *v);
+static void ( APIENTRY * dllVertexPointer )(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
+static void ( APIENTRY * dllViewport )(GLint x, GLint y, GLsizei width, GLsizei height);
+
+static void APIENTRY logAccum(GLenum op, GLfloat value)
+{
+	fprintf( glw_state.log_fp, "glAccum\n" );
+	dllAccum( op, value );
+}
+
+static void APIENTRY logAlphaFunc(GLenum func, GLclampf ref)
+{
+	fprintf( glw_state.log_fp, "glAlphaFunc( 0x%x, %f )\n", func, ref );
+	dllAlphaFunc( func, ref );
+}
+
+static GLboolean APIENTRY logAreTexturesResident(GLsizei n, const GLuint *textures, GLboolean *residences)
+{
+	fprintf( glw_state.log_fp, "glAreTexturesResident\n" );
+	return dllAreTexturesResident( n, textures, residences );
+}
+
+static void APIENTRY logArrayElement(GLint i)
+{
+	fprintf( glw_state.log_fp, "glArrayElement\n" );
+	dllArrayElement( i );
+}
+
+static void APIENTRY logBegin(GLenum mode)
+{
+	fprintf( glw_state.log_fp, "glBegin( 0x%x )\n", mode );
+	dllBegin( mode );
+}
+
+static void APIENTRY logBindTexture(GLenum target, GLuint texture)
+{
+	fprintf( glw_state.log_fp, "glBindTexture( 0x%x, %u )\n", target, texture );
+	dllBindTexture( target, texture );
+}
+
+static void APIENTRY logBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap)
+{
+	fprintf( glw_state.log_fp, "glBitmap\n" );
+	dllBitmap( width, height, xorig, yorig, xmove, ymove, bitmap );
+}
+
+static void APIENTRY logBlendFunc(GLenum sfactor, GLenum dfactor)
+{
+	fprintf( glw_state.log_fp, "glBlendFunc( 0x%x, 0x%x )\n", sfactor, dfactor );
+	dllBlendFunc( sfactor, dfactor );
+}
+
+static void APIENTRY logCallList(GLuint list)
+{
+	fprintf( glw_state.log_fp, "glCallList( %u )\n", list );
+	dllCallList( list );
+}
+
+static void APIENTRY logCallLists(GLsizei n, GLenum type, const void *lists)
+{
+	fprintf( glw_state.log_fp, "glCallLists\n" );
+	dllCallLists( n, type, lists );
+}
+
+static void APIENTRY logClear(GLbitfield mask)
+{
+	fprintf( glw_state.log_fp, "glClear\n" );
+	dllClear( mask );
+}
+
+static void APIENTRY logClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
+{
+	fprintf( glw_state.log_fp, "glClearAccum\n" );
+	dllClearAccum( red, green, blue, alpha );
+}
+
+static void APIENTRY logClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
+{
+	fprintf( glw_state.log_fp, "glClearColor\n" );
+	dllClearColor( red, green, blue, alpha );
+}
+
+static void APIENTRY logClearDepth(GLclampd depth)
+{
+	fprintf( glw_state.log_fp, "glClearDepth\n" );
+	dllClearDepth( depth );
+}
+
+static void APIENTRY logClearIndex(GLfloat c)
+{
+	fprintf( glw_state.log_fp, "glClearIndex\n" );
+	dllClearIndex( c );
+}
+
+static void APIENTRY logClearStencil(GLint s)
+{
+	fprintf( glw_state.log_fp, "glClearStencil\n" );
+	dllClearStencil( s );
+}
+
+static void APIENTRY logClipPlane(GLenum plane, const GLdouble *equation)
+{
+	fprintf( glw_state.log_fp, "glClipPlane\n" );
+	dllClipPlane( plane, equation );
+}
+
+static void APIENTRY logColor3b(GLbyte red, GLbyte green, GLbyte blue)
+{
+	fprintf( glw_state.log_fp, "glColor3b\n" );
+	dllColor3b( red, green, blue );
+}
+
+static void APIENTRY logColor3bv(const GLbyte *v)
+{
+	fprintf( glw_state.log_fp, "glColor3bv\n" );
+	dllColor3bv( v );
+}
+
+static void APIENTRY logColor3d(GLdouble red, GLdouble green, GLdouble blue)
+{
+	fprintf( glw_state.log_fp, "glColor3d\n" );
+	dllColor3d( red, green, blue );
+}
+
+static void APIENTRY logColor3dv(const GLdouble *v)
+{
+	fprintf( glw_state.log_fp, "glColor3dv\n" );
+	dllColor3dv( v );
+}
+
+static void APIENTRY logColor3f(GLfloat red, GLfloat green, GLfloat blue)
+{
+	fprintf( glw_state.log_fp, "glColor3f\n" );
+	dllColor3f( red, green, blue );
+}
+
+static void APIENTRY logColor3fv(const GLfloat *v)
+{
+	fprintf( glw_state.log_fp, "glColor3fv\n" );
+	dllColor3fv( v );
+}
+
+static void APIENTRY logColor3i(GLint red, GLint green, GLint blue)
+{
+	fprintf( glw_state.log_fp, "glColor3i\n" );
+	dllColor3i( red, green, blue );
+}
+
+static void APIENTRY logColor3iv(const GLint *v)
+{
+	fprintf( glw_state.log_fp, "glColor3iv\n" );
+	dllColor3iv( v );
+}
+
+static void APIENTRY logColor3s(GLshort red, GLshort green, GLshort blue)
+{
+	fprintf( glw_state.log_fp, "glColor3s\n" );
+	dllColor3s( red, green, blue );
+}
+
+static void APIENTRY logColor3sv(const GLshort *v)
+{
+	fprintf( glw_state.log_fp, "glColor3sv\n" );
+	dllColor3sv( v );
+}
+
+static void APIENTRY logColor3ub(GLubyte red, GLubyte green, GLubyte blue)
+{
+	fprintf( glw_state.log_fp, "glColor3ub\n" );
+	dllColor3ub( red, green, blue );
+}
+
+static void APIENTRY logColor3ubv(const GLubyte *v)
+{
+	fprintf( glw_state.log_fp, "glColor3ubv\n" );
+	dllColor3ubv( v );
+}
+
+#define SIG( x ) fprintf( glw_state.log_fp, x "\n" )
+
+static void APIENTRY logColor3ui(GLuint red, GLuint green, GLuint blue)
+{
+	SIG( "glColor3ui" );
+	dllColor3ui( red, green, blue );
+}
+
+static void APIENTRY logColor3uiv(const GLuint *v)
+{
+	SIG( "glColor3uiv" );
+	dllColor3uiv( v );
+}
+
+static void APIENTRY logColor3us(GLushort red, GLushort green, GLushort blue)
+{
+	SIG( "glColor3us" );
+	dllColor3us( red, green, blue );
+}
+
+static void APIENTRY logColor3usv(const GLushort *v)
+{
+	SIG( "glColor3usv" );
+	dllColor3usv( v );
+}
+
+static void APIENTRY logColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha)
+{
+	SIG( "glColor4b" );
+	dllColor4b( red, green, blue, alpha );
+}
+
+static void APIENTRY logColor4bv(const GLbyte *v)
+{
+	SIG( "glColor4bv" );
+	dllColor4bv( v );
+}
+
+static void APIENTRY logColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha)
+{
+	SIG( "glColor4d" );
+	dllColor4d( red, green, blue, alpha );
+}
+static void APIENTRY logColor4dv(const GLdouble *v)
+{
+	SIG( "glColor4dv" );
+	dllColor4dv( v );
+}
+static void APIENTRY logColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
+{
+	fprintf( glw_state.log_fp, "glColor4f( %f,%f,%f,%f )\n", red, green, blue, alpha );
+	dllColor4f( red, green, blue, alpha );
+}
+static void APIENTRY logColor4fv(const GLfloat *v)
+{
+	fprintf( glw_state.log_fp, "glColor4fv( %f,%f,%f,%f )\n", v[0], v[1], v[2], v[3] );
+	dllColor4fv( v );
+}
+static void APIENTRY logColor4i(GLint red, GLint green, GLint blue, GLint alpha)
+{
+	SIG( "glColor4i" );
+	dllColor4i( red, green, blue, alpha );
+}
+static void APIENTRY logColor4iv(const GLint *v)
+{
+	SIG( "glColor4iv" );
+	dllColor4iv( v );
+}
+static void APIENTRY logColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha)
+{
+	SIG( "glColor4s" );
+	dllColor4s( red, green, blue, alpha );
+}
+static void APIENTRY logColor4sv(const GLshort *v)
+{
+	SIG( "glColor4sv" );
+	dllColor4sv( v );
+}
+static void APIENTRY logColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
+{
+	SIG( "glColor4b" );
+	dllColor4b( red, green, blue, alpha );
+}
+static void APIENTRY logColor4ubv(const GLubyte *v)
+{
+	SIG( "glColor4ubv" );
+	dllColor4ubv( v );
+}
+static void APIENTRY logColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha)
+{
+	SIG( "glColor4ui" );
+	dllColor4ui( red, green, blue, alpha );
+}
+static void APIENTRY logColor4uiv(const GLuint *v)
+{
+	SIG( "glColor4uiv" );
+	dllColor4uiv( v );
+}
+static void APIENTRY logColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha)
+{
+	SIG( "glColor4us" );
+	dllColor4us( red, green, blue, alpha );
+}
+static void APIENTRY logColor4usv(const GLushort *v)
+{
+	SIG( "glColor4usv" );
+	dllColor4usv( v );
+}
+static void APIENTRY logColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
+{
+	SIG( "glColorMask" );
+	dllColorMask( red, green, blue, alpha );
+}
+static void APIENTRY logColorMaterial(GLenum face, GLenum mode)
+{
+	SIG( "glColorMaterial" );
+	dllColorMaterial( face, mode );
+}
+
+static void APIENTRY logColorPointer(GLint size, GLenum type, GLsizei stride, const void *pointer)
+{
+	SIG( "glColorPointer" );
+	dllColorPointer( size, type, stride, pointer );
+}
+
+static void APIENTRY logCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type)
+{
+	SIG( "glCopyPixels" );
+	dllCopyPixels( x, y, width, height, type );
+}
+
+static void APIENTRY logCopyTexImage1D(GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border)
+{
+	SIG( "glCopyTexImage1D" );
+	dllCopyTexImage1D( target, level, internalFormat, x, y, width, border );
+}
+
+static void APIENTRY logCopyTexImage2D(GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
+{
+	SIG( "glCopyTexImage2D" );
+	dllCopyTexImage2D( target, level, internalFormat, x, y, width, height, border );
+}
+
+static void APIENTRY logCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
+{
+	SIG( "glCopyTexSubImage1D" );
+	dllCopyTexSubImage1D( target, level, xoffset, x, y, width );
+}
+
+static void APIENTRY logCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
+{
+	SIG( "glCopyTexSubImage2D" );
+	dllCopyTexSubImage2D( target, level, xoffset, yoffset, x, y, width, height );
+}
+
+static void APIENTRY logCullFace(GLenum mode)
+{
+	SIG( "glCullFace" );
+	dllCullFace( mode );
+}
+
+static void APIENTRY logDeleteLists(GLuint list, GLsizei range)
+{
+	SIG( "glDeleteLists" );
+	dllDeleteLists( list, range );
+}
+
+static void APIENTRY logDeleteTextures(GLsizei n, const GLuint *textures)
+{
+	SIG( "glDeleteTextures" );
+	dllDeleteTextures( n, textures );
+}
+
+static void APIENTRY logDepthFunc(GLenum func)
+{
+	SIG( "glDepthFunc" );
+	dllDepthFunc( func );
+}
+
+static void APIENTRY logDepthMask(GLboolean flag)
+{
+	SIG( "glDepthMask" );
+	dllDepthMask( flag );
+}
+
+static void APIENTRY logDepthRange(GLclampd zNear, GLclampd zFar)
+{
+	SIG( "glDepthRange" );
+	dllDepthRange( zNear, zFar );
+}
+
+static void APIENTRY logDisable(GLenum cap)
+{
+	fprintf( glw_state.log_fp, "glDisable( 0x%x )\n", cap );
+	dllDisable( cap );
+}
+
+static void APIENTRY logDisableClientState(GLenum array)
+{
+	SIG( "glDisableClientState" );
+	dllDisableClientState( array );
+}
+
+static void APIENTRY logDrawArrays(GLenum mode, GLint first, GLsizei count)
+{
+	SIG( "glDrawArrays" );
+	dllDrawArrays( mode, first, count );
+}
+
+static void APIENTRY logDrawBuffer(GLenum mode)
+{
+	SIG( "glDrawBuffer" );
+	dllDrawBuffer( mode );
+}
+
+static void APIENTRY logDrawElements(GLenum mode, GLsizei count, GLenum type, const void *indices)
+{
+	SIG( "glDrawElements" );
+	dllDrawElements( mode, count, type, indices );
+}
+
+static void APIENTRY logDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels)
+{
+	SIG( "glDrawPixels" );
+	dllDrawPixels( width, height, format, type, pixels );
+}
+
+static void APIENTRY logEdgeFlag(GLboolean flag)
+{
+	SIG( "glEdgeFlag" );
+	dllEdgeFlag( flag );
+}
+
+static void APIENTRY logEdgeFlagPointer(GLsizei stride, const void *pointer)
+{
+	SIG( "glEdgeFlagPointer" );
+	dllEdgeFlagPointer( stride, pointer );
+}
+
+static void APIENTRY logEdgeFlagv(const GLboolean *flag)
+{
+	SIG( "glEdgeFlagv" );
+	dllEdgeFlagv( flag );
+}
+
+static void APIENTRY logEnable(GLenum cap)
+{
+	fprintf( glw_state.log_fp, "glEnable( 0x%x )\n", cap );
+	dllEnable( cap );
+}
+
+static void APIENTRY logEnableClientState(GLenum array)
+{
+	SIG( "glEnableClientState" );
+	dllEnableClientState( array );
+}
+
+static void APIENTRY logEnd(void)
+{
+	SIG( "glEnd" );
+	dllEnd();
+}
+
+static void APIENTRY logEndList(void)
+{
+	SIG( "glEndList" );
+	dllEndList();
+}
+
+static void APIENTRY logEvalCoord1d(GLdouble u)
+{
+	SIG( "glEvalCoord1d" );
+	dllEvalCoord1d( u );
+}
+
+static void APIENTRY logEvalCoord1dv(const GLdouble *u)
+{
+	SIG( "glEvalCoord1dv" );
+	dllEvalCoord1dv( u );
+}
+
+static void APIENTRY logEvalCoord1f(GLfloat u)
+{
+	SIG( "glEvalCoord1f" );
+	dllEvalCoord1f( u );
+}
+
+static void APIENTRY logEvalCoord1fv(const GLfloat *u)
+{
+	SIG( "glEvalCoord1fv" );
+	dllEvalCoord1fv( u );
+}
+static void APIENTRY logEvalCoord2d(GLdouble u, GLdouble v)
+{
+	SIG( "glEvalCoord2d" );
+	dllEvalCoord2d( u, v );
+}
+static void APIENTRY logEvalCoord2dv(const GLdouble *u)
+{
+	SIG( "glEvalCoord2dv" );
+	dllEvalCoord2dv( u );
+}
+static void APIENTRY logEvalCoord2f(GLfloat u, GLfloat v)
+{
+	SIG( "glEvalCoord2f" );
+	dllEvalCoord2f( u, v );
+}
+static void APIENTRY logEvalCoord2fv(const GLfloat *u)
+{
+	SIG( "glEvalCoord2fv" );
+	dllEvalCoord2fv( u );
+}
+
+static void APIENTRY logEvalMesh1(GLenum mode, GLint i1, GLint i2)
+{
+	SIG( "glEvalMesh1" );
+	dllEvalMesh1( mode, i1, i2 );
+}
+static void APIENTRY logEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)
+{
+	SIG( "glEvalMesh2" );
+	dllEvalMesh2( mode, i1, i2, j1, j2 );
+}
+static void APIENTRY logEvalPoint1(GLint i)
+{
+	SIG( "glEvalPoint1" );
+	dllEvalPoint1( i );
+}
+static void APIENTRY logEvalPoint2(GLint i, GLint j)
+{
+	SIG( "glEvalPoint2" );
+	dllEvalPoint2( i, j );
+}
+
+static void APIENTRY logFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer)
+{
+	SIG( "glFeedbackBuffer" );
+	dllFeedbackBuffer( size, type, buffer );
+}
+
+static void APIENTRY logFinish(void)
+{
+	SIG( "glFinish" );
+	dllFinish();
+}
+
+static void APIENTRY logFlush(void)
+{
+	SIG( "glFlush" );
+	dllFlush();
+}
+
+static void APIENTRY logFogf(GLenum pname, GLfloat param)
+{
+	SIG( "glFogf" );
+	dllFogf( pname, param );
+}
+
+static void APIENTRY logFogfv(GLenum pname, const GLfloat *params)
+{
+	SIG( "glFogfv" );
+	dllFogfv( pname, params );
+}
+
+static void APIENTRY logFogi(GLenum pname, GLint param)
+{
+	SIG( "glFogi" );
+	dllFogi( pname, param );
+}
+
+static void APIENTRY logFogiv(GLenum pname, const GLint *params)
+{
+	SIG( "glFogiv" );
+	dllFogiv( pname, params );
+}
+
+static void APIENTRY logFrontFace(GLenum mode)
+{
+	SIG( "glFrontFace" );
+	dllFrontFace( mode );
+}
+
+static void APIENTRY logFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
+{
+	SIG( "glFrustum" );
+	dllFrustum( left, right, bottom, top, zNear, zFar );
+}
+
+static GLuint APIENTRY logGenLists(GLsizei range)
+{
+	SIG( "glGenLists" );
+	return dllGenLists( range );
+}
+
+static void APIENTRY logGenTextures(GLsizei n, GLuint *textures)
+{
+	SIG( "glGenTextures" );
+	dllGenTextures( n, textures );
+}
+
+static void APIENTRY logGetBooleanv(GLenum pname, GLboolean *params)
+{
+	SIG( "glGetBooleanv" );
+	dllGetBooleanv( pname, params );
+}
+
+static void APIENTRY logGetClipPlane(GLenum plane, GLdouble *equation)
+{
+	SIG( "glGetClipPlane" );
+	dllGetClipPlane( plane, equation );
+}
+
+static void APIENTRY logGetDoublev(GLenum pname, GLdouble *params)
+{
+	SIG( "glGetDoublev" );
+	dllGetDoublev( pname, params );
+}
+
+static GLenum APIENTRY logGetError(void)
+{
+	SIG( "glGetError" );
+	return dllGetError();
+}
+
+static void APIENTRY logGetFloatv(GLenum pname, GLfloat *params)
+{
+	SIG( "glGetFloatv" );
+	dllGetFloatv( pname, params );
+}
+
+static void APIENTRY logGetIntegerv(GLenum pname, GLint *params)
+{
+	SIG( "glGetIntegerv" );
+	dllGetIntegerv( pname, params );
+}
+
+static void APIENTRY logGetLightfv(GLenum light, GLenum pname, GLfloat *params)
+{
+	SIG( "glGetLightfv" );
+	dllGetLightfv( light, pname, params );
+}
+
+static void APIENTRY logGetLightiv(GLenum light, GLenum pname, GLint *params)
+{
+	SIG( "glGetLightiv" );
+	dllGetLightiv( light, pname, params );
+}
+
+static void APIENTRY logGetMapdv(GLenum target, GLenum query, GLdouble *v)
+{
+	SIG( "glGetMapdv" );
+	dllGetMapdv( target, query, v );
+}
+
+static void APIENTRY logGetMapfv(GLenum target, GLenum query, GLfloat *v)
+{
+	SIG( "glGetMapfv" );
+	dllGetMapfv( target, query, v );
+}
+
+static void APIENTRY logGetMapiv(GLenum target, GLenum query, GLint *v)
+{
+	SIG( "glGetMapiv" );
+	dllGetMapiv( target, query, v );
+}
+
+static void APIENTRY logGetMaterialfv(GLenum face, GLenum pname, GLfloat *params)
+{
+	SIG( "glGetMaterialfv" );
+	dllGetMaterialfv( face, pname, params );
+}
+
+static void APIENTRY logGetMaterialiv(GLenum face, GLenum pname, GLint *params)
+{
+	SIG( "glGetMaterialiv" );
+	dllGetMaterialiv( face, pname, params );
+}
+
+static void APIENTRY logGetPixelMapfv(GLenum map, GLfloat *values)
+{
+	SIG( "glGetPixelMapfv" );
+	dllGetPixelMapfv( map, values );
+}
+
+static void APIENTRY logGetPixelMapuiv(GLenum map, GLuint *values)
+{
+	SIG( "glGetPixelMapuiv" );
+	dllGetPixelMapuiv( map, values );
+}
+
+static void APIENTRY logGetPixelMapusv(GLenum map, GLushort *values)
+{
+	SIG( "glGetPixelMapusv" );
+	dllGetPixelMapusv( map, values );
+}
+
+static void APIENTRY logGetPointerv(GLenum pname, GLvoid* *params)
+{
+	SIG( "glGetPointerv" );
+	dllGetPointerv( pname, params );
+}
+
+static void APIENTRY logGetPolygonStipple(GLubyte *mask)
+{
+	SIG( "glGetPolygonStipple" );
+	dllGetPolygonStipple( mask );
+}
+
+static const GLubyte * APIENTRY logGetString(GLenum name)
+{
+	SIG( "glGetString" );
+	return dllGetString( name );
+}
+
+static void APIENTRY logGetTexEnvfv(GLenum target, GLenum pname, GLfloat *params)
+{
+	SIG( "glGetTexEnvfv" );
+	dllGetTexEnvfv( target, pname, params );
+}
+
+static void APIENTRY logGetTexEnviv(GLenum target, GLenum pname, GLint *params)
+{
+	SIG( "glGetTexEnviv" );
+	dllGetTexEnviv( target, pname, params );
+}
+
+static void APIENTRY logGetTexGendv(GLenum coord, GLenum pname, GLdouble *params)
+{
+	SIG( "glGetTexGendv" );
+	dllGetTexGendv( coord, pname, params );
+}
+
+static void APIENTRY logGetTexGenfv(GLenum coord, GLenum pname, GLfloat *params)
+{
+	SIG( "glGetTexGenfv" );
+	dllGetTexGenfv( coord, pname, params );
+}
+
+static void APIENTRY logGetTexGeniv(GLenum coord, GLenum pname, GLint *params)
+{
+	SIG( "glGetTexGeniv" );
+	dllGetTexGeniv( coord, pname, params );
+}
+
+static void APIENTRY logGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, void *pixels)
+{
+	SIG( "glGetTexImage" );
+	dllGetTexImage( target, level, format, type, pixels );
+}
+static void APIENTRY logGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params )
+{
+	SIG( "glGetTexLevelParameterfv" );
+	dllGetTexLevelParameterfv( target, level, pname, params );
+}
+
+static void APIENTRY logGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params)
+{
+	SIG( "glGetTexLevelParameteriv" );
+	dllGetTexLevelParameteriv( target, level, pname, params );
+}
+
+static void APIENTRY logGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params)
+{
+	SIG( "glGetTexParameterfv" );
+	dllGetTexParameterfv( target, pname, params );
+}
+
+static void APIENTRY logGetTexParameteriv(GLenum target, GLenum pname, GLint *params)
+{
+	SIG( "glGetTexParameteriv" );
+	dllGetTexParameteriv( target, pname, params );
+}
+
+static void APIENTRY logHint(GLenum target, GLenum mode)
+{
+	fprintf( glw_state.log_fp, "glHint( 0x%x, 0x%x )\n", target, mode );
+	dllHint( target, mode );
+}
+
+static void APIENTRY logIndexMask(GLuint mask)
+{
+	SIG( "glIndexMask" );
+	dllIndexMask( mask );
+}
+
+static void APIENTRY logIndexPointer(GLenum type, GLsizei stride, const void *pointer)
+{
+	SIG( "glIndexPointer" );
+	dllIndexPointer( type, stride, pointer );
+}
+
+static void APIENTRY logIndexd(GLdouble c)
+{
+	SIG( "glIndexd" );
+	dllIndexd( c );
+}
+
+static void APIENTRY logIndexdv(const GLdouble *c)
+{
+	SIG( "glIndexdv" );
+	dllIndexdv( c );
+}
+
+static void APIENTRY logIndexf(GLfloat c)
+{
+	SIG( "glIndexf" );
+	dllIndexf( c );
+}
+
+static void APIENTRY logIndexfv(const GLfloat *c)
+{
+	SIG( "glIndexfv" );
+	dllIndexfv( c );
+}
+
+static void APIENTRY logIndexi(GLint c)
+{
+	SIG( "glIndexi" );
+	dllIndexi( c );
+}
+
+static void APIENTRY logIndexiv(const GLint *c)
+{
+	SIG( "glIndexiv" );
+	dllIndexiv( c );
+}
+
+static void APIENTRY logIndexs(GLshort c)
+{
+	SIG( "glIndexs" );
+	dllIndexs( c );
+}
+
+static void APIENTRY logIndexsv(const GLshort *c)
+{
+	SIG( "glIndexsv" );
+	dllIndexsv( c );
+}
+
+static void APIENTRY logIndexub(GLubyte c)
+{
+	SIG( "glIndexub" );
+	dllIndexub( c );
+}
+
+static void APIENTRY logIndexubv(const GLubyte *c)
+{
+	SIG( "glIndexubv" );
+	dllIndexubv( c );
+}
+
+static void APIENTRY logInitNames(void)
+{
+	SIG( "glInitNames" );
+	dllInitNames();
+}
+
+static void APIENTRY logInterleavedArrays(GLenum format, GLsizei stride, const void *pointer)
+{
+	SIG( "glInterleavedArrays" );
+	dllInterleavedArrays( format, stride, pointer );
+}
+
+static GLboolean APIENTRY logIsEnabled(GLenum cap)
+{
+	SIG( "glIsEnabled" );
+	return dllIsEnabled( cap );
+}
+static GLboolean APIENTRY logIsList(GLuint list)
+{
+	SIG( "glIsList" );
+	return dllIsList( list );
+}
+static GLboolean APIENTRY logIsTexture(GLuint texture)
+{
+	SIG( "glIsTexture" );
+	return dllIsTexture( texture );
+}
+
+static void APIENTRY logLightModelf(GLenum pname, GLfloat param)
+{
+	SIG( "glLightModelf" );
+	dllLightModelf( pname, param );
+}
+
+static void APIENTRY logLightModelfv(GLenum pname, const GLfloat *params)
+{
+	SIG( "glLightModelfv" );
+	dllLightModelfv( pname, params );
+}
+
+static void APIENTRY logLightModeli(GLenum pname, GLint param)
+{
+	SIG( "glLightModeli" );
+	dllLightModeli( pname, param );
+
+}
+
+static void APIENTRY logLightModeliv(GLenum pname, const GLint *params)
+{
+	SIG( "glLightModeliv" );
+	dllLightModeliv( pname, params );
+}
+
+static void APIENTRY logLightf(GLenum light, GLenum pname, GLfloat param)
+{
+	SIG( "glLightf" );
+	dllLightf( light, pname, param );
+}
+
+static void APIENTRY logLightfv(GLenum light, GLenum pname, const GLfloat *params)
+{
+	SIG( "glLightfv" );
+	dllLightfv( light, pname, params );
+}
+
+static void APIENTRY logLighti(GLenum light, GLenum pname, GLint param)
+{
+	SIG( "glLighti" );
+	dllLighti( light, pname, param );
+}
+
+static void APIENTRY logLightiv(GLenum light, GLenum pname, const GLint *params)
+{
+	SIG( "glLightiv" );
+	dllLightiv( light, pname, params );
+}
+
+static void APIENTRY logLineStipple(GLint factor, GLushort pattern)
+{
+	SIG( "glLineStipple" );
+	dllLineStipple( factor, pattern );
+}
+
+static void APIENTRY logLineWidth(GLfloat width)
+{
+	SIG( "glLineWidth" );
+	dllLineWidth( width );
+}
+
+static void APIENTRY logListBase(GLuint base)
+{
+	SIG( "glListBase" );
+	dllListBase( base );
+}
+
+static void APIENTRY logLoadIdentity(void)
+{
+	SIG( "glLoadIdentity" );
+	dllLoadIdentity();
+}
+
+static void APIENTRY logLoadMatrixd(const GLdouble *m)
+{
+	SIG( "glLoadMatrixd" );
+	dllLoadMatrixd( m );
+}
+
+static void APIENTRY logLoadMatrixf(const GLfloat *m)
+{
+	SIG( "glLoadMatrixf" );
+	dllLoadMatrixf( m );
+}
+
+static void APIENTRY logLoadName(GLuint name)
+{
+	SIG( "glLoadName" );
+	dllLoadName( name );
+}
+
+static void APIENTRY logLogicOp(GLenum opcode)
+{
+	SIG( "glLogicOp" );
+	dllLogicOp( opcode );
+}
+
+static void APIENTRY logMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points)
+{
+	SIG( "glMap1d" );
+	dllMap1d( target, u1, u2, stride, order, points );
+}
+
+static void APIENTRY logMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points)
+{
+	SIG( "glMap1f" );
+	dllMap1f( target, u1, u2, stride, order, points );
+}
+
+static void APIENTRY logMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points)
+{
+	SIG( "glMap2d" );
+	dllMap2d( target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points );
+}
+
+static void APIENTRY logMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points)
+{
+	SIG( "glMap2f" );
+	dllMap2f( target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points );
+}
+
+static void APIENTRY logMapGrid1d(GLint un, GLdouble u1, GLdouble u2)
+{
+	SIG( "glMapGrid1d" );
+	dllMapGrid1d( un, u1, u2 );
+}
+
+static void APIENTRY logMapGrid1f(GLint un, GLfloat u1, GLfloat u2)
+{
+	SIG( "glMapGrid1f" );
+	dllMapGrid1f( un, u1, u2 );
+}
+
+static void APIENTRY logMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2)
+{
+	SIG( "glMapGrid2d" );
+	dllMapGrid2d( un, u1, u2, vn, v1, v2 );
+}
+static void APIENTRY logMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2)
+{
+	SIG( "glMapGrid2f" );
+	dllMapGrid2f( un, u1, u2, vn, v1, v2 );
+}
+static void APIENTRY logMaterialf(GLenum face, GLenum pname, GLfloat param)
+{
+	SIG( "glMaterialf" );
+	dllMaterialf( face, pname, param );
+}
+static void APIENTRY logMaterialfv(GLenum face, GLenum pname, const GLfloat *params)
+{
+	SIG( "glMaterialfv" );
+	dllMaterialfv( face, pname, params );
+}
+
+static void APIENTRY logMateriali(GLenum face, GLenum pname, GLint param)
+{
+	SIG( "glMateriali" );
+	dllMateriali( face, pname, param );
+}
+
+static void APIENTRY logMaterialiv(GLenum face, GLenum pname, const GLint *params)
+{
+	SIG( "glMaterialiv" );
+	dllMaterialiv( face, pname, params );
+}
+
+static void APIENTRY logMatrixMode(GLenum mode)
+{
+	SIG( "glMatrixMode" );
+	dllMatrixMode( mode );
+}
+
+static void APIENTRY logMultMatrixd(const GLdouble *m)
+{
+	SIG( "glMultMatrixd" );
+	dllMultMatrixd( m );
+}
+
+static void APIENTRY logMultMatrixf(const GLfloat *m)
+{
+	SIG( "glMultMatrixf" );
+	dllMultMatrixf( m );
+}
+
+static void APIENTRY logNewList(GLuint list, GLenum mode)
+{
+	SIG( "glNewList" );
+	dllNewList( list, mode );
+}
+
+static void APIENTRY logNormal3b(GLbyte nx, GLbyte ny, GLbyte nz)
+{
+	SIG ("glNormal3b" );
+	dllNormal3b( nx, ny, nz );
+}
+
+static void APIENTRY logNormal3bv(const GLbyte *v)
+{
+	SIG( "glNormal3bv" );
+	dllNormal3bv( v );
+}
+
+static void APIENTRY logNormal3d(GLdouble nx, GLdouble ny, GLdouble nz)
+{
+	SIG( "glNormal3d" );
+	dllNormal3d( nx, ny, nz );
+}
+
+static void APIENTRY logNormal3dv(const GLdouble *v)
+{
+	SIG( "glNormal3dv" );
+	dllNormal3dv( v );
+}
+
+static void APIENTRY logNormal3f(GLfloat nx, GLfloat ny, GLfloat nz)
+{
+	SIG( "glNormal3f" );
+	dllNormal3f( nx, ny, nz );
+}
+
+static void APIENTRY logNormal3fv(const GLfloat *v)
+{
+	SIG( "glNormal3fv" );
+	dllNormal3fv( v );
+}
+static void APIENTRY logNormal3i(GLint nx, GLint ny, GLint nz)
+{
+	SIG( "glNormal3i" );
+	dllNormal3i( nx, ny, nz );
+}
+static void APIENTRY logNormal3iv(const GLint *v)
+{
+	SIG( "glNormal3iv" );
+	dllNormal3iv( v );
+}
+static void APIENTRY logNormal3s(GLshort nx, GLshort ny, GLshort nz)
+{
+	SIG( "glNormal3s" );
+	dllNormal3s( nx, ny, nz );
+}
+static void APIENTRY logNormal3sv(const GLshort *v)
+{
+	SIG( "glNormal3sv" );
+	dllNormal3sv( v );
+}
+static void APIENTRY logNormalPointer(GLenum type, GLsizei stride, const void *pointer)
+{
+	SIG( "glNormalPointer" );
+	dllNormalPointer( type, stride, pointer );
+}
+static void APIENTRY logOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
+{
+	SIG( "glOrtho" );
+	dllOrtho( left, right, bottom, top, zNear, zFar );
+}
+
+static void APIENTRY logPassThrough(GLfloat token)
+{
+	SIG( "glPassThrough" );
+	dllPassThrough( token );
+}
+
+static void APIENTRY logPixelMapfv(GLenum map, GLsizei mapsize, const GLfloat *values)
+{
+	SIG( "glPixelMapfv" );
+	dllPixelMapfv( map, mapsize, values );
+}
+
+static void APIENTRY logPixelMapuiv(GLenum map, GLsizei mapsize, const GLuint *values)
+{
+	SIG( "glPixelMapuiv" );
+	dllPixelMapuiv( map, mapsize, values );
+}
+
+static void APIENTRY logPixelMapusv(GLenum map, GLsizei mapsize, const GLushort *values)
+{
+	SIG( "glPixelMapusv" );
+	dllPixelMapusv( map, mapsize, values );
+}
+static void APIENTRY logPixelStoref(GLenum pname, GLfloat param)
+{
+	SIG( "glPixelStoref" );
+	dllPixelStoref( pname, param );
+}
+static void APIENTRY logPixelStorei(GLenum pname, GLint param)
+{
+	SIG( "glPixelStorei" );
+	dllPixelStorei( pname, param );
+}
+static void APIENTRY logPixelTransferf(GLenum pname, GLfloat param)
+{
+	SIG( "glPixelTransferf" );
+	dllPixelTransferf( pname, param );
+}
+
+static void APIENTRY logPixelTransferi(GLenum pname, GLint param)
+{
+	SIG( "glPixelTransferi" );
+	dllPixelTransferi( pname, param );
+}
+
+static void APIENTRY logPixelZoom(GLfloat xfactor, GLfloat yfactor)
+{
+	SIG( "glPixelZoom" );
+	dllPixelZoom( xfactor, yfactor );
+}
+
+static void APIENTRY logPointSize(GLfloat size)
+{
+	SIG( "glPointSize" );
+	dllPointSize( size );
+}
+
+static void APIENTRY logPolygonMode(GLenum face, GLenum mode)
+{
+	fprintf( glw_state.log_fp, "glPolygonMode( 0x%x, 0x%x )\n", face, mode );
+	dllPolygonMode( face, mode );
+}
+
+static void APIENTRY logPolygonOffset(GLfloat factor, GLfloat units)
+{
+	SIG( "glPolygonOffset" );
+	dllPolygonOffset( factor, units );
+}
+static void APIENTRY logPolygonStipple(const GLubyte *mask )
+{
+	SIG( "glPolygonStipple" );
+	dllPolygonStipple( mask );
+}
+static void APIENTRY logPopAttrib(void)
+{
+	SIG( "glPopAttrib" );
+	dllPopAttrib();
+}
+
+static void APIENTRY logPopClientAttrib(void)
+{
+	SIG( "glPopClientAttrib" );
+	dllPopClientAttrib();
+}
+
+static void APIENTRY logPopMatrix(void)
+{
+	SIG( "glPopMatrix" );
+	dllPopMatrix();
+}
+
+static void APIENTRY logPopName(void)
+{
+	SIG( "glPopName" );
+	dllPopName();
+}
+
+static void APIENTRY logPrioritizeTextures(GLsizei n, const GLuint *textures, const GLclampf *priorities)
+{
+	SIG( "glPrioritizeTextures" );
+	dllPrioritizeTextures( n, textures, priorities );
+}
+
+static void APIENTRY logPushAttrib(GLbitfield mask)
+{
+	SIG( "glPushAttrib" );
+	dllPushAttrib( mask );
+}
+
+static void APIENTRY logPushClientAttrib(GLbitfield mask)
+{
+	SIG( "glPushClientAttrib" );
+	dllPushClientAttrib( mask );
+}
+
+static void APIENTRY logPushMatrix(void)
+{
+	SIG( "glPushMatrix" );
+	dllPushMatrix();
+}
+
+static void APIENTRY logPushName(GLuint name)
+{
+	SIG( "glPushName" );
+	dllPushName( name );
+}
+
+static void APIENTRY logRasterPos2d(GLdouble x, GLdouble y)
+{
+	SIG ("glRasterPot2d" );
+	dllRasterPos2d( x, y );
+}
+
+static void APIENTRY logRasterPos2dv(const GLdouble *v)
+{
+	SIG( "glRasterPos2dv" );
+	dllRasterPos2dv( v );
+}
+
+static void APIENTRY logRasterPos2f(GLfloat x, GLfloat y)
+{
+	SIG( "glRasterPos2f" );
+	dllRasterPos2f( x, y );
+}
+static void APIENTRY logRasterPos2fv(const GLfloat *v)
+{
+	SIG( "glRasterPos2dv" );
+	dllRasterPos2fv( v );
+}
+static void APIENTRY logRasterPos2i(GLint x, GLint y)
+{
+	SIG( "glRasterPos2if" );
+	dllRasterPos2i( x, y );
+}
+static void APIENTRY logRasterPos2iv(const GLint *v)
+{
+	SIG( "glRasterPos2iv" );
+	dllRasterPos2iv( v );
+}
+static void APIENTRY logRasterPos2s(GLshort x, GLshort y)
+{
+	SIG( "glRasterPos2s" );
+	dllRasterPos2s( x, y );
+}
+static void APIENTRY logRasterPos2sv(const GLshort *v)
+{
+	SIG( "glRasterPos2sv" );
+	dllRasterPos2sv( v );
+}
+static void APIENTRY logRasterPos3d(GLdouble x, GLdouble y, GLdouble z)
+{
+	SIG( "glRasterPos3d" );
+	dllRasterPos3d( x, y, z );
+}
+static void APIENTRY logRasterPos3dv(const GLdouble *v)
+{
+	SIG( "glRasterPos3dv" );
+	dllRasterPos3dv( v );
+}
+static void APIENTRY logRasterPos3f(GLfloat x, GLfloat y, GLfloat z)
+{
+	SIG( "glRasterPos3f" );
+	dllRasterPos3f( x, y, z );
+}
+static void APIENTRY logRasterPos3fv(const GLfloat *v)
+{
+	SIG( "glRasterPos3fv" );
+	dllRasterPos3fv( v );
+}
+static void APIENTRY logRasterPos3i(GLint x, GLint y, GLint z)
+{
+	SIG( "glRasterPos3i" );
+	dllRasterPos3i( x, y, z );
+}
+static void APIENTRY logRasterPos3iv(const GLint *v)
+{
+	SIG( "glRasterPos3iv" );
+	dllRasterPos3iv( v );
+}
+static void APIENTRY logRasterPos3s(GLshort x, GLshort y, GLshort z)
+{
+	SIG( "glRasterPos3s" );
+	dllRasterPos3s( x, y, z );
+}
+static void APIENTRY logRasterPos3sv(const GLshort *v)
+{
+	SIG( "glRasterPos3sv" );
+	dllRasterPos3sv( v );
+}
+static void APIENTRY logRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
+{
+	SIG( "glRasterPos4d" );
+	dllRasterPos4d( x, y, z, w );
+}
+static void APIENTRY logRasterPos4dv(const GLdouble *v)
+{
+	SIG( "glRasterPos4dv" );
+	dllRasterPos4dv( v );
+}
+static void APIENTRY logRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
+{
+	SIG( "glRasterPos4f" );
+	dllRasterPos4f( x, y, z, w );
+}
+static void APIENTRY logRasterPos4fv(const GLfloat *v)
+{
+	SIG( "glRasterPos4fv" );
+	dllRasterPos4fv( v );
+}
+static void APIENTRY logRasterPos4i(GLint x, GLint y, GLint z, GLint w)
+{
+	SIG( "glRasterPos4i" );
+	dllRasterPos4i( x, y, z, w );
+}
+static void APIENTRY logRasterPos4iv(const GLint *v)
+{
+	SIG( "glRasterPos4iv" );
+	dllRasterPos4iv( v );
+}
+static void APIENTRY logRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w)
+{
+	SIG( "glRasterPos4s" );
+	dllRasterPos4s( x, y, z, w );
+}
+static void APIENTRY logRasterPos4sv(const GLshort *v)
+{
+	SIG( "glRasterPos4sv" );
+	dllRasterPos4sv( v );
+}
+static void APIENTRY logReadBuffer(GLenum mode)
+{
+	SIG( "glReadBuffer" );
+	dllReadBuffer( mode );
+}
+static void APIENTRY logReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void *pixels)
+{
+	SIG( "glReadPixels" );
+	dllReadPixels( x, y, width, height, format, type, pixels );
+}
+
+static void APIENTRY logRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2)
+{
+	SIG( "glRectd" );
+	dllRectd( x1, y1, x2, y2 );
+}
+
+static void APIENTRY logRectdv(const GLdouble *v1, const GLdouble *v2)
+{
+	SIG( "glRectdv" );
+	dllRectdv( v1, v2 );
+}
+
+static void APIENTRY logRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)
+{
+	SIG( "glRectf" );
+	dllRectf( x1, y1, x2, y2 );
+}
+
+static void APIENTRY logRectfv(const GLfloat *v1, const GLfloat *v2)
+{
+	SIG( "glRectfv" );
+	dllRectfv( v1, v2 );
+}
+static void APIENTRY logRecti(GLint x1, GLint y1, GLint x2, GLint y2)
+{
+	SIG( "glRecti" );
+	dllRecti( x1, y1, x2, y2 );
+}
+static void APIENTRY logRectiv(const GLint *v1, const GLint *v2)
+{
+	SIG( "glRectiv" );
+	dllRectiv( v1, v2 );
+}
+static void APIENTRY logRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2)
+{
+	SIG( "glRects" );
+	dllRects( x1, y1, x2, y2 );
+}
+static void APIENTRY logRectsv(const GLshort *v1, const GLshort *v2)
+{
+	SIG( "glRectsv" );
+	dllRectsv( v1, v2 );
+}
+static GLint APIENTRY logRenderMode(GLenum mode)
+{
+	SIG( "glRenderMode" );
+	return dllRenderMode( mode );
+}
+static void APIENTRY logRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z)
+{
+	SIG( "glRotated" );
+	dllRotated( angle, x, y, z );
+}
+
+static void APIENTRY logRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
+{
+	SIG( "glRotatef" );
+	dllRotatef( angle, x, y, z );
+}
+
+static void APIENTRY logScaled(GLdouble x, GLdouble y, GLdouble z)
+{
+	SIG( "glScaled" );
+	dllScaled( x, y, z );
+}
+
+static void APIENTRY logScalef(GLfloat x, GLfloat y, GLfloat z)
+{
+	SIG( "glScalef" );
+	dllScalef( x, y, z );
+}
+
+static void APIENTRY logScissor(GLint x, GLint y, GLsizei width, GLsizei height)
+{
+	SIG( "glScissor" );
+	dllScissor( x, y, width, height );
+}
+
+static void APIENTRY logSelectBuffer(GLsizei size, GLuint *buffer)
+{
+	SIG( "glSelectBuffer" );
+	dllSelectBuffer( size, buffer );
+}
+
+static void APIENTRY logShadeModel(GLenum mode)
+{
+	SIG( "glShadeModel" );
+	dllShadeModel( mode );
+}
+
+static void APIENTRY logStencilFunc(GLenum func, GLint ref, GLuint mask)
+{
+	SIG( "glStencilFunc" );
+	dllStencilFunc( func, ref, mask );
+}
+
+static void APIENTRY logStencilMask(GLuint mask)
+{
+	SIG( "glStencilMask" );
+	dllStencilMask( mask );
+}
+
+static void APIENTRY logStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
+{
+	SIG( "glStencilOp" );
+	dllStencilOp( fail, zfail, zpass );
+}
+
+static void APIENTRY logTexCoord1d(GLdouble s)
+{
+	SIG( "glTexCoord1d" );
+	dllTexCoord1d( s );
+}
+
+static void APIENTRY logTexCoord1dv(const GLdouble *v)
+{
+	SIG( "glTexCoord1dv" );
+	dllTexCoord1dv( v );
+}
+
+static void APIENTRY logTexCoord1f(GLfloat s)
+{
+	SIG( "glTexCoord1f" );
+	dllTexCoord1f( s );
+}
+static void APIENTRY logTexCoord1fv(const GLfloat *v)
+{
+	SIG( "glTexCoord1fv" );
+	dllTexCoord1fv( v );
+}
+static void APIENTRY logTexCoord1i(GLint s)
+{
+	SIG( "glTexCoord1i" );
+	dllTexCoord1i( s );
+}
+static void APIENTRY logTexCoord1iv(const GLint *v)
+{
+	SIG( "glTexCoord1iv" );
+	dllTexCoord1iv( v );
+}
+static void APIENTRY logTexCoord1s(GLshort s)
+{
+	SIG( "glTexCoord1s" );
+	dllTexCoord1s( s );
+}
+static void APIENTRY logTexCoord1sv(const GLshort *v)
+{
+	SIG( "glTexCoord1sv" );
+	dllTexCoord1sv( v );
+}
+static void APIENTRY logTexCoord2d(GLdouble s, GLdouble t)
+{
+	SIG( "glTexCoord2d" );
+	dllTexCoord2d( s, t );
+}
+
+static void APIENTRY logTexCoord2dv(const GLdouble *v)
+{
+	SIG( "glTexCoord2dv" );
+	dllTexCoord2dv( v );
+}
+static void APIENTRY logTexCoord2f(GLfloat s, GLfloat t)
+{
+	SIG( "glTexCoord2f" );
+	dllTexCoord2f( s, t );
+}
+static void APIENTRY logTexCoord2fv(const GLfloat *v)
+{
+	SIG( "glTexCoord2fv" );
+	dllTexCoord2fv( v );
+}
+static void APIENTRY logTexCoord2i(GLint s, GLint t)
+{
+	SIG( "glTexCoord2i" );
+	dllTexCoord2i( s, t );
+}
+static void APIENTRY logTexCoord2iv(const GLint *v)
+{
+	SIG( "glTexCoord2iv" );
+	dllTexCoord2iv( v );
+}
+static void APIENTRY logTexCoord2s(GLshort s, GLshort t)
+{
+	SIG( "glTexCoord2s" );
+	dllTexCoord2s( s, t );
+}
+static void APIENTRY logTexCoord2sv(const GLshort *v)
+{
+	SIG( "glTexCoord2sv" );
+	dllTexCoord2sv( v );
+}
+static void APIENTRY logTexCoord3d(GLdouble s, GLdouble t, GLdouble r)
+{
+	SIG( "glTexCoord3d" );
+	dllTexCoord3d( s, t, r );
+}
+static void APIENTRY logTexCoord3dv(const GLdouble *v)
+{
+	SIG( "glTexCoord3dv" );
+	dllTexCoord3dv( v );
+}
+static void APIENTRY logTexCoord3f(GLfloat s, GLfloat t, GLfloat r)
+{
+	SIG( "glTexCoord3f" );
+	dllTexCoord3f( s, t, r );
+}
+static void APIENTRY logTexCoord3fv(const GLfloat *v)
+{
+	SIG( "glTexCoord3fv" );
+	dllTexCoord3fv( v );
+}
+static void APIENTRY logTexCoord3i(GLint s, GLint t, GLint r)
+{
+	SIG( "glTexCoord3i" );
+	dllTexCoord3i( s, t, r );
+}
+static void APIENTRY logTexCoord3iv(const GLint *v)
+{
+	SIG( "glTexCoord3iv" );
+	dllTexCoord3iv( v );
+}
+static void APIENTRY logTexCoord3s(GLshort s, GLshort t, GLshort r)
+{
+	SIG( "glTexCoord3s" );
+	dllTexCoord3s( s, t, r );
+}
+static void APIENTRY logTexCoord3sv(const GLshort *v)
+{
+	SIG( "glTexCoord3sv" );
+	dllTexCoord3sv( v );
+}
+static void APIENTRY logTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q)
+{
+	SIG( "glTexCoord4d" );
+	dllTexCoord4d( s, t, r, q );
+}
+static void APIENTRY logTexCoord4dv(const GLdouble *v)
+{
+	SIG( "glTexCoord4dv" );
+	dllTexCoord4dv( v );
+}
+static void APIENTRY logTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q)
+{
+	SIG( "glTexCoord4f" );
+	dllTexCoord4f( s, t, r, q );
+}
+static void APIENTRY logTexCoord4fv(const GLfloat *v)
+{
+	SIG( "glTexCoord4fv" );
+	dllTexCoord4fv( v );
+}
+static void APIENTRY logTexCoord4i(GLint s, GLint t, GLint r, GLint q)
+{
+	SIG( "glTexCoord4i" );
+	dllTexCoord4i( s, t, r, q );
+}
+static void APIENTRY logTexCoord4iv(const GLint *v)
+{
+	SIG( "glTexCoord4iv" );
+	dllTexCoord4iv( v );
+}
+static void APIENTRY logTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q)
+{
+	SIG( "glTexCoord4s" );
+	dllTexCoord4s( s, t, r, q );
+}
+static void APIENTRY logTexCoord4sv(const GLshort *v)
+{
+	SIG( "glTexCoord4sv" );
+	dllTexCoord4sv( v );
+}
+static void APIENTRY logTexCoordPointer(GLint size, GLenum type, GLsizei stride, const void *pointer)
+{
+	SIG( "glTexCoordPointer" );
+	dllTexCoordPointer( size, type, stride, pointer );
+}
+
+static void APIENTRY logTexEnvf(GLenum target, GLenum pname, GLfloat param)
+{
+	fprintf( glw_state.log_fp, "glTexEnvf( 0x%x, 0x%x, %f )\n", target, pname, param );
+	dllTexEnvf( target, pname, param );
+}
+
+static void APIENTRY logTexEnvfv(GLenum target, GLenum pname, const GLfloat *params)
+{
+	SIG( "glTexEnvfv" );
+	dllTexEnvfv( target, pname, params );
+}
+
+static void APIENTRY logTexEnvi(GLenum target, GLenum pname, GLint param)
+{
+	fprintf( glw_state.log_fp, "glTexEnvi( 0x%x, 0x%x, 0x%x )\n", target, pname, param );
+	dllTexEnvi( target, pname, param );
+}
+static void APIENTRY logTexEnviv(GLenum target, GLenum pname, const GLint *params)
+{
+	SIG( "glTexEnviv" );
+	dllTexEnviv( target, pname, params );
+}
+
+static void APIENTRY logTexGend(GLenum coord, GLenum pname, GLdouble param)
+{
+	SIG( "glTexGend" );
+	dllTexGend( coord, pname, param );
+}
+
+static void APIENTRY logTexGendv(GLenum coord, GLenum pname, const GLdouble *params)
+{
+	SIG( "glTexGendv" );
+	dllTexGendv( coord, pname, params );
+}
+
+static void APIENTRY logTexGenf(GLenum coord, GLenum pname, GLfloat param)
+{
+	SIG( "glTexGenf" );
+	dllTexGenf( coord, pname, param );
+}
+static void APIENTRY logTexGenfv(GLenum coord, GLenum pname, const GLfloat *params)
+{
+	SIG( "glTexGenfv" );
+	dllTexGenfv( coord, pname, params );
+}
+static void APIENTRY logTexGeni(GLenum coord, GLenum pname, GLint param)
+{
+	SIG( "glTexGeni" );
+	dllTexGeni( coord, pname, param );
+}
+static void APIENTRY logTexGeniv(GLenum coord, GLenum pname, const GLint *params)
+{
+	SIG( "glTexGeniv" );
+	dllTexGeniv( coord, pname, params );
+}
+static void APIENTRY logTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void *pixels)
+{
+	SIG( "glTexImage1D" );
+	dllTexImage1D( target, level, internalformat, width, border, format, type, pixels );
+}
+static void APIENTRY logTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels)
+{
+	SIG( "glTexImage2D" );
+	dllTexImage2D( target, level, internalformat, width, height, border, format, type, pixels );
+}
+
+static void APIENTRY logTexParameterf(GLenum target, GLenum pname, GLfloat param)
+{
+	fprintf( glw_state.log_fp, "glTexParameterf( 0x%x, 0x%x, %f )\n", target, pname, param );
+	dllTexParameterf( target, pname, param );
+}
+
+static void APIENTRY logTexParameterfv(GLenum target, GLenum pname, const GLfloat *params)
+{
+	SIG( "glTexParameterfv" );
+	dllTexParameterfv( target, pname, params );
+}
+static void APIENTRY logTexParameteri(GLenum target, GLenum pname, GLint param)
+{
+	fprintf( glw_state.log_fp, "glTexParameteri( 0x%x, 0x%x, 0x%x )\n", target, pname, param );
+	dllTexParameteri( target, pname, param );
+}
+static void APIENTRY logTexParameteriv(GLenum target, GLenum pname, const GLint *params)
+{
+	SIG( "glTexParameteriv" );
+	dllTexParameteriv( target, pname, params );
+}
+static void APIENTRY logTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels)
+{
+	SIG( "glTexSubImage1D" );
+	dllTexSubImage1D( target, level, xoffset, width, format, type, pixels );
+}
+static void APIENTRY logTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels)
+{
+	SIG( "glTexSubImage2D" );
+	dllTexSubImage2D( target, level, xoffset, yoffset, width, height, format, type, pixels );
+}
+static void APIENTRY logTranslated(GLdouble x, GLdouble y, GLdouble z)
+{
+	SIG( "glTranslated" );
+	dllTranslated( x, y, z );
+}
+
+static void APIENTRY logTranslatef(GLfloat x, GLfloat y, GLfloat z)
+{
+	SIG( "glTranslatef" );
+	dllTranslatef( x, y, z );
+}
+
+static void APIENTRY logVertex2d(GLdouble x, GLdouble y)
+{
+	SIG( "glVertex2d" );
+	dllVertex2d( x, y );
+}
+
+static void APIENTRY logVertex2dv(const GLdouble *v)
+{
+	SIG( "glVertex2dv" );
+	dllVertex2dv( v );
+}
+static void APIENTRY logVertex2f(GLfloat x, GLfloat y)
+{
+	SIG( "glVertex2f" );
+	dllVertex2f( x, y );
+}
+static void APIENTRY logVertex2fv(const GLfloat *v)
+{
+	SIG( "glVertex2fv" );
+	dllVertex2fv( v );
+}
+static void APIENTRY logVertex2i(GLint x, GLint y)
+{
+	SIG( "glVertex2i" );
+	dllVertex2i( x, y );
+}
+static void APIENTRY logVertex2iv(const GLint *v)
+{
+	SIG( "glVertex2iv" );
+	dllVertex2iv( v );
+}
+static void APIENTRY logVertex2s(GLshort x, GLshort y)
+{
+	SIG( "glVertex2s" );
+	dllVertex2s( x, y );
+}
+static void APIENTRY logVertex2sv(const GLshort *v)
+{
+	SIG( "glVertex2sv" );
+	dllVertex2sv( v );
+}
+static void APIENTRY logVertex3d(GLdouble x, GLdouble y, GLdouble z)
+{
+	SIG( "glVertex3d" );
+	dllVertex3d( x, y, z );
+}
+static void APIENTRY logVertex3dv(const GLdouble *v)
+{
+	SIG( "glVertex3dv" );
+	dllVertex3dv( v );
+}
+static void APIENTRY logVertex3f(GLfloat x, GLfloat y, GLfloat z)
+{
+	SIG( "glVertex3f" );
+	dllVertex3f( x, y, z );
+}
+static void APIENTRY logVertex3fv(const GLfloat *v)
+{
+	SIG( "glVertex3fv" );
+	dllVertex3fv( v );
+}
+static void APIENTRY logVertex3i(GLint x, GLint y, GLint z)
+{
+	SIG( "glVertex3i" );
+	dllVertex3i( x, y, z );
+}
+static void APIENTRY logVertex3iv(const GLint *v)
+{
+	SIG( "glVertex3iv" );
+	dllVertex3iv( v );
+}
+static void APIENTRY logVertex3s(GLshort x, GLshort y, GLshort z)
+{
+	SIG( "glVertex3s" );
+	dllVertex3s( x, y, z );
+}
+static void APIENTRY logVertex3sv(const GLshort *v)
+{
+	SIG( "glVertex3sv" );
+	dllVertex3sv( v );
+}
+static void APIENTRY logVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
+{
+	SIG( "glVertex4d" );
+	dllVertex4d( x, y, z, w );
+}
+static void APIENTRY logVertex4dv(const GLdouble *v)
+{
+	SIG( "glVertex4dv" );
+	dllVertex4dv( v );
+}
+static void APIENTRY logVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
+{
+	SIG( "glVertex4f" );
+	dllVertex4f( x, y, z, w );
+}
+static void APIENTRY logVertex4fv(const GLfloat *v)
+{
+	SIG( "glVertex4fv" );
+	dllVertex4fv( v );
+}
+static void APIENTRY logVertex4i(GLint x, GLint y, GLint z, GLint w)
+{
+	SIG( "glVertex4i" );
+	dllVertex4i( x, y, z, w );
+}
+static void APIENTRY logVertex4iv(const GLint *v)
+{
+	SIG( "glVertex4iv" );
+	dllVertex4iv( v );
+}
+static void APIENTRY logVertex4s(GLshort x, GLshort y, GLshort z, GLshort w)
+{
+	SIG( "glVertex4s" );
+	dllVertex4s( x, y, z, w );
+}
+static void APIENTRY logVertex4sv(const GLshort *v)
+{
+	SIG( "glVertex4sv" );
+	dllVertex4sv( v );
+}
+static void APIENTRY logVertexPointer(GLint size, GLenum type, GLsizei stride, const void *pointer)
+{
+	SIG( "glVertexPointer" );
+	dllVertexPointer( size, type, stride, pointer );
+}
+static void APIENTRY logViewport(GLint x, GLint y, GLsizei width, GLsizei height)
+{
+	SIG( "glViewport" );
+	dllViewport( x, y, width, height );
+}
+
+/*
+** QGL_Shutdown
+**
+** Unloads the specified DLL then nulls out all the proc pointers.
+*/
+void QGL_Shutdown( void )
+{
+	if ( glw_state.OpenGLLib )
+	{
+		dlclose ( glw_state.OpenGLLib );
+		glw_state.OpenGLLib = NULL;
+	}
+
+	glw_state.OpenGLLib = NULL;
+
+	qglAccum                     = NULL;
+	qglAlphaFunc                 = NULL;
+	qglAreTexturesResident       = NULL;
+	qglArrayElement              = NULL;
+	qglBegin                     = NULL;
+	qglBindTexture               = NULL;
+	qglBitmap                    = NULL;
+	qglBlendFunc                 = NULL;
+	qglCallList                  = NULL;
+	qglCallLists                 = NULL;
+	qglClear                     = NULL;
+	qglClearAccum                = NULL;
+	qglClearColor                = NULL;
+	qglClearDepth                = NULL;
+	qglClearIndex                = NULL;
+	qglClearStencil              = NULL;
+	qglClipPlane                 = NULL;
+	qglColor3b                   = NULL;
+	qglColor3bv                  = NULL;
+	qglColor3d                   = NULL;
+	qglColor3dv                  = NULL;
+	qglColor3f                   = NULL;
+	qglColor3fv                  = NULL;
+	qglColor3i                   = NULL;
+	qglColor3iv                  = NULL;
+	qglColor3s                   = NULL;
+	qglColor3sv                  = NULL;
+	qglColor3ub                  = NULL;
+	qglColor3ubv                 = NULL;
+	qglColor3ui                  = NULL;
+	qglColor3uiv                 = NULL;
+	qglColor3us                  = NULL;
+	qglColor3usv                 = NULL;
+	qglColor4b                   = NULL;
+	qglColor4bv                  = NULL;
+	qglColor4d                   = NULL;
+	qglColor4dv                  = NULL;
+	qglColor4f                   = NULL;
+	qglColor4fv                  = NULL;
+	qglColor4i                   = NULL;
+	qglColor4iv                  = NULL;
+	qglColor4s                   = NULL;
+	qglColor4sv                  = NULL;
+	qglColor4ub                  = NULL;
+	qglColor4ubv                 = NULL;
+	qglColor4ui                  = NULL;
+	qglColor4uiv                 = NULL;
+	qglColor4us                  = NULL;
+	qglColor4usv                 = NULL;
+	qglColorMask                 = NULL;
+	qglColorMaterial             = NULL;
+	qglColorPointer              = NULL;
+	qglCopyPixels                = NULL;
+	qglCopyTexImage1D            = NULL;
+	qglCopyTexImage2D            = NULL;
+	qglCopyTexSubImage1D         = NULL;
+	qglCopyTexSubImage2D         = NULL;
+	qglCullFace                  = NULL;
+	qglDeleteLists               = NULL;
+	qglDeleteTextures            = NULL;
+	qglDepthFunc                 = NULL;
+	qglDepthMask                 = NULL;
+	qglDepthRange                = NULL;
+	qglDisable                   = NULL;
+	qglDisableClientState        = NULL;
+	qglDrawArrays                = NULL;
+	qglDrawBuffer                = NULL;
+	qglDrawElements              = NULL;
+	qglDrawPixels                = NULL;
+	qglEdgeFlag                  = NULL;
+	qglEdgeFlagPointer           = NULL;
+	qglEdgeFlagv                 = NULL;
+	qglEnable                    = NULL;
+	qglEnableClientState         = NULL;
+	qglEnd                       = NULL;
+	qglEndList                   = NULL;
+	qglEvalCoord1d               = NULL;
+	qglEvalCoord1dv              = NULL;
+	qglEvalCoord1f               = NULL;
+	qglEvalCoord1fv              = NULL;
+	qglEvalCoord2d               = NULL;
+	qglEvalCoord2dv              = NULL;
+	qglEvalCoord2f               = NULL;
+	qglEvalCoord2fv              = NULL;
+	qglEvalMesh1                 = NULL;
+	qglEvalMesh2                 = NULL;
+	qglEvalPoint1                = NULL;
+	qglEvalPoint2                = NULL;
+	qglFeedbackBuffer            = NULL;
+	qglFinish                    = NULL;
+	qglFlush                     = NULL;
+	qglFogf                      = NULL;
+	qglFogfv                     = NULL;
+	qglFogi                      = NULL;
+	qglFogiv                     = NULL;
+	qglFrontFace                 = NULL;
+	qglFrustum                   = NULL;
+	qglGenLists                  = NULL;
+	qglGenTextures               = NULL;
+	qglGetBooleanv               = NULL;
+	qglGetClipPlane              = NULL;
+	qglGetDoublev                = NULL;
+	qglGetError                  = NULL;
+	qglGetFloatv                 = NULL;
+	qglGetIntegerv               = NULL;
+	qglGetLightfv                = NULL;
+	qglGetLightiv                = NULL;
+	qglGetMapdv                  = NULL;
+	qglGetMapfv                  = NULL;
+	qglGetMapiv                  = NULL;
+	qglGetMaterialfv             = NULL;
+	qglGetMaterialiv             = NULL;
+	qglGetPixelMapfv             = NULL;
+	qglGetPixelMapuiv            = NULL;
+	qglGetPixelMapusv            = NULL;
+	qglGetPointerv               = NULL;
+	qglGetPolygonStipple         = NULL;
+	qglGetString                 = NULL;
+	qglGetTexEnvfv               = NULL;
+	qglGetTexEnviv               = NULL;
+	qglGetTexGendv               = NULL;
+	qglGetTexGenfv               = NULL;
+	qglGetTexGeniv               = NULL;
+	qglGetTexImage               = NULL;
+	qglGetTexLevelParameterfv    = NULL;
+	qglGetTexLevelParameteriv    = NULL;
+	qglGetTexParameterfv         = NULL;
+	qglGetTexParameteriv         = NULL;
+	qglHint                      = NULL;
+	qglIndexMask                 = NULL;
+	qglIndexPointer              = NULL;
+	qglIndexd                    = NULL;
+	qglIndexdv                   = NULL;
+	qglIndexf                    = NULL;
+	qglIndexfv                   = NULL;
+	qglIndexi                    = NULL;
+	qglIndexiv                   = NULL;
+	qglIndexs                    = NULL;
+	qglIndexsv                   = NULL;
+	qglIndexub                   = NULL;
+	qglIndexubv                  = NULL;
+	qglInitNames                 = NULL;
+	qglInterleavedArrays         = NULL;
+	qglIsEnabled                 = NULL;
+	qglIsList                    = NULL;
+	qglIsTexture                 = NULL;
+	qglLightModelf               = NULL;
+	qglLightModelfv              = NULL;
+	qglLightModeli               = NULL;
+	qglLightModeliv              = NULL;
+	qglLightf                    = NULL;
+	qglLightfv                   = NULL;
+	qglLighti                    = NULL;
+	qglLightiv                   = NULL;
+	qglLineStipple               = NULL;
+	qglLineWidth                 = NULL;
+	qglListBase                  = NULL;
+	qglLoadIdentity              = NULL;
+	qglLoadMatrixd               = NULL;
+	qglLoadMatrixf               = NULL;
+	qglLoadName                  = NULL;
+	qglLogicOp                   = NULL;
+	qglMap1d                     = NULL;
+	qglMap1f                     = NULL;
+	qglMap2d                     = NULL;
+	qglMap2f                     = NULL;
+	qglMapGrid1d                 = NULL;
+	qglMapGrid1f                 = NULL;
+	qglMapGrid2d                 = NULL;
+	qglMapGrid2f                 = NULL;
+	qglMaterialf                 = NULL;
+	qglMaterialfv                = NULL;
+	qglMateriali                 = NULL;
+	qglMaterialiv                = NULL;
+	qglMatrixMode                = NULL;
+	qglMultMatrixd               = NULL;
+	qglMultMatrixf               = NULL;
+	qglNewList                   = NULL;
+	qglNormal3b                  = NULL;
+	qglNormal3bv                 = NULL;
+	qglNormal3d                  = NULL;
+	qglNormal3dv                 = NULL;
+	qglNormal3f                  = NULL;
+	qglNormal3fv                 = NULL;
+	qglNormal3i                  = NULL;
+	qglNormal3iv                 = NULL;
+	qglNormal3s                  = NULL;
+	qglNormal3sv                 = NULL;
+	qglNormalPointer             = NULL;
+	qglOrtho                     = NULL;
+	qglPassThrough               = NULL;
+	qglPixelMapfv                = NULL;
+	qglPixelMapuiv               = NULL;
+	qglPixelMapusv               = NULL;
+	qglPixelStoref               = NULL;
+	qglPixelStorei               = NULL;
+	qglPixelTransferf            = NULL;
+	qglPixelTransferi            = NULL;
+	qglPixelZoom                 = NULL;
+	qglPointSize                 = NULL;
+	qglPolygonMode               = NULL;
+	qglPolygonOffset             = NULL;
+	qglPolygonStipple            = NULL;
+	qglPopAttrib                 = NULL;
+	qglPopClientAttrib           = NULL;
+	qglPopMatrix                 = NULL;
+	qglPopName                   = NULL;
+	qglPrioritizeTextures        = NULL;
+	qglPushAttrib                = NULL;
+	qglPushClientAttrib          = NULL;
+	qglPushMatrix                = NULL;
+	qglPushName                  = NULL;
+	qglRasterPos2d               = NULL;
+	qglRasterPos2dv              = NULL;
+	qglRasterPos2f               = NULL;
+	qglRasterPos2fv              = NULL;
+	qglRasterPos2i               = NULL;
+	qglRasterPos2iv              = NULL;
+	qglRasterPos2s               = NULL;
+	qglRasterPos2sv              = NULL;
+	qglRasterPos3d               = NULL;
+	qglRasterPos3dv              = NULL;
+	qglRasterPos3f               = NULL;
+	qglRasterPos3fv              = NULL;
+	qglRasterPos3i               = NULL;
+	qglRasterPos3iv              = NULL;
+	qglRasterPos3s               = NULL;
+	qglRasterPos3sv              = NULL;
+	qglRasterPos4d               = NULL;
+	qglRasterPos4dv              = NULL;
+	qglRasterPos4f               = NULL;
+	qglRasterPos4fv              = NULL;
+	qglRasterPos4i               = NULL;
+	qglRasterPos4iv              = NULL;
+	qglRasterPos4s               = NULL;
+	qglRasterPos4sv              = NULL;
+	qglReadBuffer                = NULL;
+	qglReadPixels                = NULL;
+	qglRectd                     = NULL;
+	qglRectdv                    = NULL;
+	qglRectf                     = NULL;
+	qglRectfv                    = NULL;
+	qglRecti                     = NULL;
+	qglRectiv                    = NULL;
+	qglRects                     = NULL;
+	qglRectsv                    = NULL;
+	qglRenderMode                = NULL;
+	qglRotated                   = NULL;
+	qglRotatef                   = NULL;
+	qglScaled                    = NULL;
+	qglScalef                    = NULL;
+	qglScissor                   = NULL;
+	qglSelectBuffer              = NULL;
+	qglShadeModel                = NULL;
+	qglStencilFunc               = NULL;
+	qglStencilMask               = NULL;
+	qglStencilOp                 = NULL;
+	qglTexCoord1d                = NULL;
+	qglTexCoord1dv               = NULL;
+	qglTexCoord1f                = NULL;
+	qglTexCoord1fv               = NULL;
+	qglTexCoord1i                = NULL;
+	qglTexCoord1iv               = NULL;
+	qglTexCoord1s                = NULL;
+	qglTexCoord1sv               = NULL;
+	qglTexCoord2d                = NULL;
+	qglTexCoord2dv               = NULL;
+	qglTexCoord2f                = NULL;
+	qglTexCoord2fv               = NULL;
+	qglTexCoord2i                = NULL;
+	qglTexCoord2iv               = NULL;
+	qglTexCoord2s                = NULL;
+	qglTexCoord2sv               = NULL;
+	qglTexCoord3d                = NULL;
+	qglTexCoord3dv               = NULL;
+	qglTexCoord3f                = NULL;
+	qglTexCoord3fv               = NULL;
+	qglTexCoord3i                = NULL;
+	qglTexCoord3iv               = NULL;
+	qglTexCoord3s                = NULL;
+	qglTexCoord3sv               = NULL;
+	qglTexCoord4d                = NULL;
+	qglTexCoord4dv               = NULL;
+	qglTexCoord4f                = NULL;
+	qglTexCoord4fv               = NULL;
+	qglTexCoord4i                = NULL;
+	qglTexCoord4iv               = NULL;
+	qglTexCoord4s                = NULL;
+	qglTexCoord4sv               = NULL;
+	qglTexCoordPointer           = NULL;
+	qglTexEnvf                   = NULL;
+	qglTexEnvfv                  = NULL;
+	qglTexEnvi                   = NULL;
+	qglTexEnviv                  = NULL;
+	qglTexGend                   = NULL;
+	qglTexGendv                  = NULL;
+	qglTexGenf                   = NULL;
+	qglTexGenfv                  = NULL;
+	qglTexGeni                   = NULL;
+	qglTexGeniv                  = NULL;
+	qglTexImage1D                = NULL;
+	qglTexImage2D                = NULL;
+	qglTexParameterf             = NULL;
+	qglTexParameterfv            = NULL;
+	qglTexParameteri             = NULL;
+	qglTexParameteriv            = NULL;
+	qglTexSubImage1D             = NULL;
+	qglTexSubImage2D             = NULL;
+	qglTranslated                = NULL;
+	qglTranslatef                = NULL;
+	qglVertex2d                  = NULL;
+	qglVertex2dv                 = NULL;
+	qglVertex2f                  = NULL;
+	qglVertex2fv                 = NULL;
+	qglVertex2i                  = NULL;
+	qglVertex2iv                 = NULL;
+	qglVertex2s                  = NULL;
+	qglVertex2sv                 = NULL;
+	qglVertex3d                  = NULL;
+	qglVertex3dv                 = NULL;
+	qglVertex3f                  = NULL;
+	qglVertex3fv                 = NULL;
+	qglVertex3i                  = NULL;
+	qglVertex3iv                 = NULL;
+	qglVertex3s                  = NULL;
+	qglVertex3sv                 = NULL;
+	qglVertex4d                  = NULL;
+	qglVertex4dv                 = NULL;
+	qglVertex4f                  = NULL;
+	qglVertex4fv                 = NULL;
+	qglVertex4i                  = NULL;
+	qglVertex4iv                 = NULL;
+	qglVertex4s                  = NULL;
+	qglVertex4sv                 = NULL;
+	qglVertexPointer             = NULL;
+	qglViewport                  = NULL;
+
+// bk001129 - from cvs1.17 (mkv)
+#if defined(__FX__)
+	qfxMesaCreateContext         = NULL;
+	qfxMesaCreateBestContext     = NULL;
+	qfxMesaDestroyContext        = NULL;
+	qfxMesaMakeCurrent           = NULL;
+	qfxMesaGetCurrentContext     = NULL;
+	qfxMesaSwapBuffers           = NULL;
+#endif
+
+	qglXChooseVisual             = NULL;
+	qglXCreateContext            = NULL;
+	qglXDestroyContext           = NULL;
+	qglXMakeCurrent              = NULL;
+	qglXCopyContext              = NULL;
+	qglXSwapBuffers              = NULL;
+}
+
+#define GPA( a ) dlsym( glw_state.OpenGLLib, a )
+
+void *qwglGetProcAddress(char *symbol)
+{
+	if (glw_state.OpenGLLib)
+		return GPA ( symbol );
+	return NULL;
+}
+
+/*
+** QGL_Init
+**
+** This is responsible for binding our qgl function pointers to 
+** the appropriate GL stuff.  In Windows this means doing a 
+** LoadLibrary and a bunch of calls to GetProcAddress.  On other
+** operating systems we need to do the right thing, whatever that
+** might be.
+** 
+*/
+
+qboolean QGL_Init( const char *dllname )
+{
+	if ( ( glw_state.OpenGLLib = dlopen( dllname, RTLD_LAZY|RTLD_GLOBAL ) ) == 0 )
+	{
+		char	fn[1024];
+		// FILE *fp; // bk001204 - unused
+		extern uid_t saved_euid; // unix_main.c
+
+		// if we are not setuid, try current directory
+		if (getuid() == saved_euid) {
+			getcwd(fn, sizeof(fn));
+			Q_strcat(fn, sizeof(fn), "/");
+			Q_strcat(fn, sizeof(fn), dllname);
+
+			if ( ( glw_state.OpenGLLib = dlopen( fn, RTLD_LAZY ) ) == 0 ) {
+				ri.Printf(PRINT_ALL, "QGL_Init: Can't load %s from /etc/ld.so.conf or current dir: %s\n", dllname, dlerror());
+				return qfalse;
+			}
+		} else {
+			ri.Printf(PRINT_ALL, "QGL_Init: Can't load %s from /etc/ld.so.conf: %s\n", dllname, dlerror());
+			return qfalse;
+		}
+	}
+
+	qglAccum                     = dllAccum = GPA( "glAccum" );
+	qglAlphaFunc                 = dllAlphaFunc = GPA( "glAlphaFunc" );
+	qglAreTexturesResident       = dllAreTexturesResident = GPA( "glAreTexturesResident" );
+	qglArrayElement              = dllArrayElement = GPA( "glArrayElement" );
+	qglBegin                     = dllBegin = GPA( "glBegin" );
+	qglBindTexture               = dllBindTexture = GPA( "glBindTexture" );
+	qglBitmap                    = dllBitmap = GPA( "glBitmap" );
+	qglBlendFunc                 = dllBlendFunc = GPA( "glBlendFunc" );
+	qglCallList                  = dllCallList = GPA( "glCallList" );
+	qglCallLists                 = dllCallLists = GPA( "glCallLists" );
+	qglClear                     = dllClear = GPA( "glClear" );
+	qglClearAccum                = dllClearAccum = GPA( "glClearAccum" );
+	qglClearColor                = dllClearColor = GPA( "glClearColor" );
+	qglClearDepth                = dllClearDepth = GPA( "glClearDepth" );
+	qglClearIndex                = dllClearIndex = GPA( "glClearIndex" );
+	qglClearStencil              = dllClearStencil = GPA( "glClearStencil" );
+	qglClipPlane                 = dllClipPlane = GPA( "glClipPlane" );
+	qglColor3b                   = dllColor3b = GPA( "glColor3b" );
+	qglColor3bv                  = dllColor3bv = GPA( "glColor3bv" );
+	qglColor3d                   = dllColor3d = GPA( "glColor3d" );
+	qglColor3dv                  = dllColor3dv = GPA( "glColor3dv" );
+	qglColor3f                   = dllColor3f = GPA( "glColor3f" );
+	qglColor3fv                  = dllColor3fv = GPA( "glColor3fv" );
+	qglColor3i                   = dllColor3i = GPA( "glColor3i" );
+	qglColor3iv                  = dllColor3iv = GPA( "glColor3iv" );
+	qglColor3s                   = dllColor3s = GPA( "glColor3s" );
+	qglColor3sv                  = dllColor3sv = GPA( "glColor3sv" );
+	qglColor3ub                  = dllColor3ub = GPA( "glColor3ub" );
+	qglColor3ubv                 = dllColor3ubv = GPA( "glColor3ubv" );
+	qglColor3ui                  = dllColor3ui = GPA( "glColor3ui" );
+	qglColor3uiv                 = dllColor3uiv = GPA( "glColor3uiv" );
+	qglColor3us                  = dllColor3us = GPA( "glColor3us" );
+	qglColor3usv                 = dllColor3usv = GPA( "glColor3usv" );
+	qglColor4b                   = dllColor4b = GPA( "glColor4b" );
+	qglColor4bv                  = dllColor4bv = GPA( "glColor4bv" );
+	qglColor4d                   = dllColor4d = GPA( "glColor4d" );
+	qglColor4dv                  = dllColor4dv = GPA( "glColor4dv" );
+	qglColor4f                   = dllColor4f = GPA( "glColor4f" );
+	qglColor4fv                  = dllColor4fv = GPA( "glColor4fv" );
+	qglColor4i                   = dllColor4i = GPA( "glColor4i" );
+	qglColor4iv                  = dllColor4iv = GPA( "glColor4iv" );
+	qglColor4s                   = dllColor4s = GPA( "glColor4s" );
+	qglColor4sv                  = dllColor4sv = GPA( "glColor4sv" );
+	qglColor4ub                  = dllColor4ub = GPA( "glColor4ub" );
+	qglColor4ubv                 = dllColor4ubv = GPA( "glColor4ubv" );
+	qglColor4ui                  = dllColor4ui = GPA( "glColor4ui" );
+	qglColor4uiv                 = dllColor4uiv = GPA( "glColor4uiv" );
+	qglColor4us                  = dllColor4us = GPA( "glColor4us" );
+	qglColor4usv                 = dllColor4usv = GPA( "glColor4usv" );
+	qglColorMask                 = dllColorMask = GPA( "glColorMask" );
+	qglColorMaterial             = dllColorMaterial = GPA( "glColorMaterial" );
+	qglColorPointer              = dllColorPointer = GPA( "glColorPointer" );
+	qglCopyPixels                = dllCopyPixels = GPA( "glCopyPixels" );
+	qglCopyTexImage1D            = dllCopyTexImage1D = GPA( "glCopyTexImage1D" );
+	qglCopyTexImage2D            = dllCopyTexImage2D = GPA( "glCopyTexImage2D" );
+	qglCopyTexSubImage1D         = dllCopyTexSubImage1D = GPA( "glCopyTexSubImage1D" );
+	qglCopyTexSubImage2D         = dllCopyTexSubImage2D = GPA( "glCopyTexSubImage2D" );
+	qglCullFace                  = dllCullFace = GPA( "glCullFace" );
+	qglDeleteLists               = dllDeleteLists = GPA( "glDeleteLists" );
+	qglDeleteTextures            = dllDeleteTextures = GPA( "glDeleteTextures" );
+	qglDepthFunc                 = dllDepthFunc = GPA( "glDepthFunc" );
+	qglDepthMask                 = dllDepthMask = GPA( "glDepthMask" );
+	qglDepthRange                = dllDepthRange = GPA( "glDepthRange" );
+	qglDisable                   = dllDisable = GPA( "glDisable" );
+	qglDisableClientState        = dllDisableClientState = GPA( "glDisableClientState" );
+	qglDrawArrays                = dllDrawArrays = GPA( "glDrawArrays" );
+	qglDrawBuffer                = dllDrawBuffer = GPA( "glDrawBuffer" );
+	qglDrawElements              = dllDrawElements = GPA( "glDrawElements" );
+	qglDrawPixels                = dllDrawPixels = GPA( "glDrawPixels" );
+	qglEdgeFlag                  = dllEdgeFlag = GPA( "glEdgeFlag" );
+	qglEdgeFlagPointer           = dllEdgeFlagPointer = GPA( "glEdgeFlagPointer" );
+	qglEdgeFlagv                 = dllEdgeFlagv = GPA( "glEdgeFlagv" );
+	qglEnable                    = 	dllEnable                    = GPA( "glEnable" );
+	qglEnableClientState         = 	dllEnableClientState         = GPA( "glEnableClientState" );
+	qglEnd                       = 	dllEnd                       = GPA( "glEnd" );
+	qglEndList                   = 	dllEndList                   = GPA( "glEndList" );
+	qglEvalCoord1d				 = 	dllEvalCoord1d				 = GPA( "glEvalCoord1d" );
+	qglEvalCoord1dv              = 	dllEvalCoord1dv              = GPA( "glEvalCoord1dv" );
+	qglEvalCoord1f               = 	dllEvalCoord1f               = GPA( "glEvalCoord1f" );
+	qglEvalCoord1fv              = 	dllEvalCoord1fv              = GPA( "glEvalCoord1fv" );
+	qglEvalCoord2d               = 	dllEvalCoord2d               = GPA( "glEvalCoord2d" );
+	qglEvalCoord2dv              = 	dllEvalCoord2dv              = GPA( "glEvalCoord2dv" );
+	qglEvalCoord2f               = 	dllEvalCoord2f               = GPA( "glEvalCoord2f" );
+	qglEvalCoord2fv              = 	dllEvalCoord2fv              = GPA( "glEvalCoord2fv" );
+	qglEvalMesh1                 = 	dllEvalMesh1                 = GPA( "glEvalMesh1" );
+	qglEvalMesh2                 = 	dllEvalMesh2                 = GPA( "glEvalMesh2" );
+	qglEvalPoint1                = 	dllEvalPoint1                = GPA( "glEvalPoint1" );
+	qglEvalPoint2                = 	dllEvalPoint2                = GPA( "glEvalPoint2" );
+	qglFeedbackBuffer            = 	dllFeedbackBuffer            = GPA( "glFeedbackBuffer" );
+	qglFinish                    = 	dllFinish                    = GPA( "glFinish" );
+	qglFlush                     = 	dllFlush                     = GPA( "glFlush" );
+	qglFogf                      = 	dllFogf                      = GPA( "glFogf" );
+	qglFogfv                     = 	dllFogfv                     = GPA( "glFogfv" );
+	qglFogi                      = 	dllFogi                      = GPA( "glFogi" );
+	qglFogiv                     = 	dllFogiv                     = GPA( "glFogiv" );
+	qglFrontFace                 = 	dllFrontFace                 = GPA( "glFrontFace" );
+	qglFrustum                   = 	dllFrustum                   = GPA( "glFrustum" );
+	qglGenLists                  = 	dllGenLists                  = GPA( "glGenLists" );
+	qglGenTextures               = 	dllGenTextures               = GPA( "glGenTextures" );
+	qglGetBooleanv               = 	dllGetBooleanv               = GPA( "glGetBooleanv" );
+	qglGetClipPlane              = 	dllGetClipPlane              = GPA( "glGetClipPlane" );
+	qglGetDoublev                = 	dllGetDoublev                = GPA( "glGetDoublev" );
+	qglGetError                  = 	dllGetError                  = GPA( "glGetError" );
+	qglGetFloatv                 = 	dllGetFloatv                 = GPA( "glGetFloatv" );
+	qglGetIntegerv               = 	dllGetIntegerv               = GPA( "glGetIntegerv" );
+	qglGetLightfv                = 	dllGetLightfv                = GPA( "glGetLightfv" );
+	qglGetLightiv                = 	dllGetLightiv                = GPA( "glGetLightiv" );
+	qglGetMapdv                  = 	dllGetMapdv                  = GPA( "glGetMapdv" );
+	qglGetMapfv                  = 	dllGetMapfv                  = GPA( "glGetMapfv" );
+	qglGetMapiv                  = 	dllGetMapiv                  = GPA( "glGetMapiv" );
+	qglGetMaterialfv             = 	dllGetMaterialfv             = GPA( "glGetMaterialfv" );
+	qglGetMaterialiv             = 	dllGetMaterialiv             = GPA( "glGetMaterialiv" );
+	qglGetPixelMapfv             = 	dllGetPixelMapfv             = GPA( "glGetPixelMapfv" );
+	qglGetPixelMapuiv            = 	dllGetPixelMapuiv            = GPA( "glGetPixelMapuiv" );
+	qglGetPixelMapusv            = 	dllGetPixelMapusv            = GPA( "glGetPixelMapusv" );
+	qglGetPointerv               = 	dllGetPointerv               = GPA( "glGetPointerv" );
+	qglGetPolygonStipple         = 	dllGetPolygonStipple         = GPA( "glGetPolygonStipple" );
+	qglGetString                 = 	dllGetString                 = GPA( "glGetString" );
+	qglGetTexEnvfv               = 	dllGetTexEnvfv               = GPA( "glGetTexEnvfv" );
+	qglGetTexEnviv               = 	dllGetTexEnviv               = GPA( "glGetTexEnviv" );
+	qglGetTexGendv               = 	dllGetTexGendv               = GPA( "glGetTexGendv" );
+	qglGetTexGenfv               = 	dllGetTexGenfv               = GPA( "glGetTexGenfv" );
+	qglGetTexGeniv               = 	dllGetTexGeniv               = GPA( "glGetTexGeniv" );
+	qglGetTexImage               = 	dllGetTexImage               = GPA( "glGetTexImage" );
+	qglGetTexParameterfv         = 	dllGetTexParameterfv         = GPA( "glGetTexParameterfv" );
+	qglGetTexParameteriv         = 	dllGetTexParameteriv         = GPA( "glGetTexParameteriv" );
+	qglHint                      = 	dllHint                      = GPA( "glHint" );
+	qglIndexMask                 = 	dllIndexMask                 = GPA( "glIndexMask" );
+	qglIndexPointer              = 	dllIndexPointer              = GPA( "glIndexPointer" );
+	qglIndexd                    = 	dllIndexd                    = GPA( "glIndexd" );
+	qglIndexdv                   = 	dllIndexdv                   = GPA( "glIndexdv" );
+	qglIndexf                    = 	dllIndexf                    = GPA( "glIndexf" );
+	qglIndexfv                   = 	dllIndexfv                   = GPA( "glIndexfv" );
+	qglIndexi                    = 	dllIndexi                    = GPA( "glIndexi" );
+	qglIndexiv                   = 	dllIndexiv                   = GPA( "glIndexiv" );
+	qglIndexs                    = 	dllIndexs                    = GPA( "glIndexs" );
+	qglIndexsv                   = 	dllIndexsv                   = GPA( "glIndexsv" );
+	qglIndexub                   = 	dllIndexub                   = GPA( "glIndexub" );
+	qglIndexubv                  = 	dllIndexubv                  = GPA( "glIndexubv" );
+	qglInitNames                 = 	dllInitNames                 = GPA( "glInitNames" );
+	qglInterleavedArrays         = 	dllInterleavedArrays         = GPA( "glInterleavedArrays" );
+	qglIsEnabled                 = 	dllIsEnabled                 = GPA( "glIsEnabled" );
+	qglIsList                    = 	dllIsList                    = GPA( "glIsList" );
+	qglIsTexture                 = 	dllIsTexture                 = GPA( "glIsTexture" );
+	qglLightModelf               = 	dllLightModelf               = GPA( "glLightModelf" );
+	qglLightModelfv              = 	dllLightModelfv              = GPA( "glLightModelfv" );
+	qglLightModeli               = 	dllLightModeli               = GPA( "glLightModeli" );
+	qglLightModeliv              = 	dllLightModeliv              = GPA( "glLightModeliv" );
+	qglLightf                    = 	dllLightf                    = GPA( "glLightf" );
+	qglLightfv                   = 	dllLightfv                   = GPA( "glLightfv" );
+	qglLighti                    = 	dllLighti                    = GPA( "glLighti" );
+	qglLightiv                   = 	dllLightiv                   = GPA( "glLightiv" );
+	qglLineStipple               = 	dllLineStipple               = GPA( "glLineStipple" );
+	qglLineWidth                 = 	dllLineWidth                 = GPA( "glLineWidth" );
+	qglListBase                  = 	dllListBase                  = GPA( "glListBase" );
+	qglLoadIdentity              = 	dllLoadIdentity              = GPA( "glLoadIdentity" );
+	qglLoadMatrixd               = 	dllLoadMatrixd               = GPA( "glLoadMatrixd" );
+	qglLoadMatrixf               = 	dllLoadMatrixf               = GPA( "glLoadMatrixf" );
+	qglLoadName                  = 	dllLoadName                  = GPA( "glLoadName" );
+	qglLogicOp                   = 	dllLogicOp                   = GPA( "glLogicOp" );
+	qglMap1d                     = 	dllMap1d                     = GPA( "glMap1d" );
+	qglMap1f                     = 	dllMap1f                     = GPA( "glMap1f" );
+	qglMap2d                     = 	dllMap2d                     = GPA( "glMap2d" );
+	qglMap2f                     = 	dllMap2f                     = GPA( "glMap2f" );
+	qglMapGrid1d                 = 	dllMapGrid1d                 = GPA( "glMapGrid1d" );
+	qglMapGrid1f                 = 	dllMapGrid1f                 = GPA( "glMapGrid1f" );
+	qglMapGrid2d                 = 	dllMapGrid2d                 = GPA( "glMapGrid2d" );
+	qglMapGrid2f                 = 	dllMapGrid2f                 = GPA( "glMapGrid2f" );
+	qglMaterialf                 = 	dllMaterialf                 = GPA( "glMaterialf" );
+	qglMaterialfv                = 	dllMaterialfv                = GPA( "glMaterialfv" );
+	qglMateriali                 = 	dllMateriali                 = GPA( "glMateriali" );
+	qglMaterialiv                = 	dllMaterialiv                = GPA( "glMaterialiv" );
+	qglMatrixMode                = 	dllMatrixMode                = GPA( "glMatrixMode" );
+	qglMultMatrixd               = 	dllMultMatrixd               = GPA( "glMultMatrixd" );
+	qglMultMatrixf               = 	dllMultMatrixf               = GPA( "glMultMatrixf" );
+	qglNewList                   = 	dllNewList                   = GPA( "glNewList" );
+	qglNormal3b                  = 	dllNormal3b                  = GPA( "glNormal3b" );
+	qglNormal3bv                 = 	dllNormal3bv                 = GPA( "glNormal3bv" );
+	qglNormal3d                  = 	dllNormal3d                  = GPA( "glNormal3d" );
+	qglNormal3dv                 = 	dllNormal3dv                 = GPA( "glNormal3dv" );
+	qglNormal3f                  = 	dllNormal3f                  = GPA( "glNormal3f" );
+	qglNormal3fv                 = 	dllNormal3fv                 = GPA( "glNormal3fv" );
+	qglNormal3i                  = 	dllNormal3i                  = GPA( "glNormal3i" );
+	qglNormal3iv                 = 	dllNormal3iv                 = GPA( "glNormal3iv" );
+	qglNormal3s                  = 	dllNormal3s                  = GPA( "glNormal3s" );
+	qglNormal3sv                 = 	dllNormal3sv                 = GPA( "glNormal3sv" );
+	qglNormalPointer             = 	dllNormalPointer             = GPA( "glNormalPointer" );
+	qglOrtho                     = 	dllOrtho                     = GPA( "glOrtho" );
+	qglPassThrough               = 	dllPassThrough               = GPA( "glPassThrough" );
+	qglPixelMapfv                = 	dllPixelMapfv                = GPA( "glPixelMapfv" );
+	qglPixelMapuiv               = 	dllPixelMapuiv               = GPA( "glPixelMapuiv" );
+	qglPixelMapusv               = 	dllPixelMapusv               = GPA( "glPixelMapusv" );
+	qglPixelStoref               = 	dllPixelStoref               = GPA( "glPixelStoref" );
+	qglPixelStorei               = 	dllPixelStorei               = GPA( "glPixelStorei" );
+	qglPixelTransferf            = 	dllPixelTransferf            = GPA( "glPixelTransferf" );
+	qglPixelTransferi            = 	dllPixelTransferi            = GPA( "glPixelTransferi" );
+	qglPixelZoom                 = 	dllPixelZoom                 = GPA( "glPixelZoom" );
+	qglPointSize                 = 	dllPointSize                 = GPA( "glPointSize" );
+	qglPolygonMode               = 	dllPolygonMode               = GPA( "glPolygonMode" );
+	qglPolygonOffset             = 	dllPolygonOffset             = GPA( "glPolygonOffset" );
+	qglPolygonStipple            = 	dllPolygonStipple            = GPA( "glPolygonStipple" );
+	qglPopAttrib                 = 	dllPopAttrib                 = GPA( "glPopAttrib" );
+	qglPopClientAttrib           = 	dllPopClientAttrib           = GPA( "glPopClientAttrib" );
+	qglPopMatrix                 = 	dllPopMatrix                 = GPA( "glPopMatrix" );
+	qglPopName                   = 	dllPopName                   = GPA( "glPopName" );
+	qglPrioritizeTextures        = 	dllPrioritizeTextures        = GPA( "glPrioritizeTextures" );
+	qglPushAttrib                = 	dllPushAttrib                = GPA( "glPushAttrib" );
+	qglPushClientAttrib          = 	dllPushClientAttrib          = GPA( "glPushClientAttrib" );
+	qglPushMatrix                = 	dllPushMatrix                = GPA( "glPushMatrix" );
+	qglPushName                  = 	dllPushName                  = GPA( "glPushName" );
+	qglRasterPos2d               = 	dllRasterPos2d               = GPA( "glRasterPos2d" );
+	qglRasterPos2dv              = 	dllRasterPos2dv              = GPA( "glRasterPos2dv" );
+	qglRasterPos2f               = 	dllRasterPos2f               = GPA( "glRasterPos2f" );
+	qglRasterPos2fv              = 	dllRasterPos2fv              = GPA( "glRasterPos2fv" );
+	qglRasterPos2i               = 	dllRasterPos2i               = GPA( "glRasterPos2i" );
+	qglRasterPos2iv              = 	dllRasterPos2iv              = GPA( "glRasterPos2iv" );
+	qglRasterPos2s               = 	dllRasterPos2s               = GPA( "glRasterPos2s" );
+	qglRasterPos2sv              = 	dllRasterPos2sv              = GPA( "glRasterPos2sv" );
+	qglRasterPos3d               = 	dllRasterPos3d               = GPA( "glRasterPos3d" );
+	qglRasterPos3dv              = 	dllRasterPos3dv              = GPA( "glRasterPos3dv" );
+	qglRasterPos3f               = 	dllRasterPos3f               = GPA( "glRasterPos3f" );
+	qglRasterPos3fv              = 	dllRasterPos3fv              = GPA( "glRasterPos3fv" );
+	qglRasterPos3i               = 	dllRasterPos3i               = GPA( "glRasterPos3i" );
+	qglRasterPos3iv              = 	dllRasterPos3iv              = GPA( "glRasterPos3iv" );
+	qglRasterPos3s               = 	dllRasterPos3s               = GPA( "glRasterPos3s" );
+	qglRasterPos3sv              = 	dllRasterPos3sv              = GPA( "glRasterPos3sv" );
+	qglRasterPos4d               = 	dllRasterPos4d               = GPA( "glRasterPos4d" );
+	qglRasterPos4dv              = 	dllRasterPos4dv              = GPA( "glRasterPos4dv" );
+	qglRasterPos4f               = 	dllRasterPos4f               = GPA( "glRasterPos4f" );
+	qglRasterPos4fv              = 	dllRasterPos4fv              = GPA( "glRasterPos4fv" );
+	qglRasterPos4i               = 	dllRasterPos4i               = GPA( "glRasterPos4i" );
+	qglRasterPos4iv              = 	dllRasterPos4iv              = GPA( "glRasterPos4iv" );
+	qglRasterPos4s               = 	dllRasterPos4s               = GPA( "glRasterPos4s" );
+	qglRasterPos4sv              = 	dllRasterPos4sv              = GPA( "glRasterPos4sv" );
+	qglReadBuffer                = 	dllReadBuffer                = GPA( "glReadBuffer" );
+	qglReadPixels                = 	dllReadPixels                = GPA( "glReadPixels" );
+	qglRectd                     = 	dllRectd                     = GPA( "glRectd" );
+	qglRectdv                    = 	dllRectdv                    = GPA( "glRectdv" );
+	qglRectf                     = 	dllRectf                     = GPA( "glRectf" );
+	qglRectfv                    = 	dllRectfv                    = GPA( "glRectfv" );
+	qglRecti                     = 	dllRecti                     = GPA( "glRecti" );
+	qglRectiv                    = 	dllRectiv                    = GPA( "glRectiv" );
+	qglRects                     = 	dllRects                     = GPA( "glRects" );
+	qglRectsv                    = 	dllRectsv                    = GPA( "glRectsv" );
+	qglRenderMode                = 	dllRenderMode                = GPA( "glRenderMode" );
+	qglRotated                   = 	dllRotated                   = GPA( "glRotated" );
+	qglRotatef                   = 	dllRotatef                   = GPA( "glRotatef" );
+	qglScaled                    = 	dllScaled                    = GPA( "glScaled" );
+	qglScalef                    = 	dllScalef                    = GPA( "glScalef" );
+	qglScissor                   = 	dllScissor                   = GPA( "glScissor" );
+	qglSelectBuffer              = 	dllSelectBuffer              = GPA( "glSelectBuffer" );
+	qglShadeModel                = 	dllShadeModel                = GPA( "glShadeModel" );
+	qglStencilFunc               = 	dllStencilFunc               = GPA( "glStencilFunc" );
+	qglStencilMask               = 	dllStencilMask               = GPA( "glStencilMask" );
+	qglStencilOp                 = 	dllStencilOp                 = GPA( "glStencilOp" );
+	qglTexCoord1d                = 	dllTexCoord1d                = GPA( "glTexCoord1d" );
+	qglTexCoord1dv               = 	dllTexCoord1dv               = GPA( "glTexCoord1dv" );
+	qglTexCoord1f                = 	dllTexCoord1f                = GPA( "glTexCoord1f" );
+	qglTexCoord1fv               = 	dllTexCoord1fv               = GPA( "glTexCoord1fv" );
+	qglTexCoord1i                = 	dllTexCoord1i                = GPA( "glTexCoord1i" );
+	qglTexCoord1iv               = 	dllTexCoord1iv               = GPA( "glTexCoord1iv" );
+	qglTexCoord1s                = 	dllTexCoord1s                = GPA( "glTexCoord1s" );
+	qglTexCoord1sv               = 	dllTexCoord1sv               = GPA( "glTexCoord1sv" );
+	qglTexCoord2d                = 	dllTexCoord2d                = GPA( "glTexCoord2d" );
+	qglTexCoord2dv               = 	dllTexCoord2dv               = GPA( "glTexCoord2dv" );
+	qglTexCoord2f                = 	dllTexCoord2f                = GPA( "glTexCoord2f" );
+	qglTexCoord2fv               = 	dllTexCoord2fv               = GPA( "glTexCoord2fv" );
+	qglTexCoord2i                = 	dllTexCoord2i                = GPA( "glTexCoord2i" );
+	qglTexCoord2iv               = 	dllTexCoord2iv               = GPA( "glTexCoord2iv" );
+	qglTexCoord2s                = 	dllTexCoord2s                = GPA( "glTexCoord2s" );
+	qglTexCoord2sv               = 	dllTexCoord2sv               = GPA( "glTexCoord2sv" );
+	qglTexCoord3d                = 	dllTexCoord3d                = GPA( "glTexCoord3d" );
+	qglTexCoord3dv               = 	dllTexCoord3dv               = GPA( "glTexCoord3dv" );
+	qglTexCoord3f                = 	dllTexCoord3f                = GPA( "glTexCoord3f" );
+	qglTexCoord3fv               = 	dllTexCoord3fv               = GPA( "glTexCoord3fv" );
+	qglTexCoord3i                = 	dllTexCoord3i                = GPA( "glTexCoord3i" );
+	qglTexCoord3iv               = 	dllTexCoord3iv               = GPA( "glTexCoord3iv" );
+	qglTexCoord3s                = 	dllTexCoord3s                = GPA( "glTexCoord3s" );
+	qglTexCoord3sv               = 	dllTexCoord3sv               = GPA( "glTexCoord3sv" );
+	qglTexCoord4d                = 	dllTexCoord4d                = GPA( "glTexCoord4d" );
+	qglTexCoord4dv               = 	dllTexCoord4dv               = GPA( "glTexCoord4dv" );
+	qglTexCoord4f                = 	dllTexCoord4f                = GPA( "glTexCoord4f" );
+	qglTexCoord4fv               = 	dllTexCoord4fv               = GPA( "glTexCoord4fv" );
+	qglTexCoord4i                = 	dllTexCoord4i                = GPA( "glTexCoord4i" );
+	qglTexCoord4iv               = 	dllTexCoord4iv               = GPA( "glTexCoord4iv" );
+	qglTexCoord4s                = 	dllTexCoord4s                = GPA( "glTexCoord4s" );
+	qglTexCoord4sv               = 	dllTexCoord4sv               = GPA( "glTexCoord4sv" );
+	qglTexCoordPointer           = 	dllTexCoordPointer           = GPA( "glTexCoordPointer" );
+	qglTexEnvf                   = 	dllTexEnvf                   = GPA( "glTexEnvf" );
+	qglTexEnvfv                  = 	dllTexEnvfv                  = GPA( "glTexEnvfv" );
+	qglTexEnvi                   = 	dllTexEnvi                   = GPA( "glTexEnvi" );
+	qglTexEnviv                  = 	dllTexEnviv                  = GPA( "glTexEnviv" );
+	qglTexGend                   = 	dllTexGend                   = GPA( "glTexGend" );
+	qglTexGendv                  = 	dllTexGendv                  = GPA( "glTexGendv" );
+	qglTexGenf                   = 	dllTexGenf                   = GPA( "glTexGenf" );
+	qglTexGenfv                  = 	dllTexGenfv                  = GPA( "glTexGenfv" );
+	qglTexGeni                   = 	dllTexGeni                   = GPA( "glTexGeni" );
+	qglTexGeniv                  = 	dllTexGeniv                  = GPA( "glTexGeniv" );
+	qglTexImage1D                = 	dllTexImage1D                = GPA( "glTexImage1D" );
+	qglTexImage2D                = 	dllTexImage2D                = GPA( "glTexImage2D" );
+	qglTexParameterf             = 	dllTexParameterf             = GPA( "glTexParameterf" );
+	qglTexParameterfv            = 	dllTexParameterfv            = GPA( "glTexParameterfv" );
+	qglTexParameteri             = 	dllTexParameteri             = GPA( "glTexParameteri" );
+	qglTexParameteriv            = 	dllTexParameteriv            = GPA( "glTexParameteriv" );
+	qglTexSubImage1D             = 	dllTexSubImage1D             = GPA( "glTexSubImage1D" );
+	qglTexSubImage2D             = 	dllTexSubImage2D             = GPA( "glTexSubImage2D" );
+	qglTranslated                = 	dllTranslated                = GPA( "glTranslated" );
+	qglTranslatef                = 	dllTranslatef                = GPA( "glTranslatef" );
+	qglVertex2d                  = 	dllVertex2d                  = GPA( "glVertex2d" );
+	qglVertex2dv                 = 	dllVertex2dv                 = GPA( "glVertex2dv" );
+	qglVertex2f                  = 	dllVertex2f                  = GPA( "glVertex2f" );
+	qglVertex2fv                 = 	dllVertex2fv                 = GPA( "glVertex2fv" );
+	qglVertex2i                  = 	dllVertex2i                  = GPA( "glVertex2i" );
+	qglVertex2iv                 = 	dllVertex2iv                 = GPA( "glVertex2iv" );
+	qglVertex2s                  = 	dllVertex2s                  = GPA( "glVertex2s" );
+	qglVertex2sv                 = 	dllVertex2sv                 = GPA( "glVertex2sv" );
+	qglVertex3d                  = 	dllVertex3d                  = GPA( "glVertex3d" );
+	qglVertex3dv                 = 	dllVertex3dv                 = GPA( "glVertex3dv" );
+	qglVertex3f                  = 	dllVertex3f                  = GPA( "glVertex3f" );
+	qglVertex3fv                 = 	dllVertex3fv                 = GPA( "glVertex3fv" );
+	qglVertex3i                  = 	dllVertex3i                  = GPA( "glVertex3i" );
+	qglVertex3iv                 = 	dllVertex3iv                 = GPA( "glVertex3iv" );
+	qglVertex3s                  = 	dllVertex3s                  = GPA( "glVertex3s" );
+	qglVertex3sv                 = 	dllVertex3sv                 = GPA( "glVertex3sv" );
+	qglVertex4d                  = 	dllVertex4d                  = GPA( "glVertex4d" );
+	qglVertex4dv                 = 	dllVertex4dv                 = GPA( "glVertex4dv" );
+	qglVertex4f                  = 	dllVertex4f                  = GPA( "glVertex4f" );
+	qglVertex4fv                 = 	dllVertex4fv                 = GPA( "glVertex4fv" );
+	qglVertex4i                  = 	dllVertex4i                  = GPA( "glVertex4i" );
+	qglVertex4iv                 = 	dllVertex4iv                 = GPA( "glVertex4iv" );
+	qglVertex4s                  = 	dllVertex4s                  = GPA( "glVertex4s" );
+	qglVertex4sv                 = 	dllVertex4sv                 = GPA( "glVertex4sv" );
+	qglVertexPointer             = 	dllVertexPointer             = GPA( "glVertexPointer" );
+	qglViewport                  = 	dllViewport                  = GPA( "glViewport" );
+
+// bk001129 - from cvs1.17 (mkv)
+#if defined(__FX__)
+	qfxMesaCreateContext         =  GPA("fxMesaCreateContext");
+	qfxMesaCreateBestContext     =  GPA("fxMesaCreateBestContext");
+	qfxMesaDestroyContext        =  GPA("fxMesaDestroyContext");
+	qfxMesaMakeCurrent           =  GPA("fxMesaMakeCurrent");
+	qfxMesaGetCurrentContext     =  GPA("fxMesaGetCurrentContext");
+	qfxMesaSwapBuffers           =  GPA("fxMesaSwapBuffers");
+#endif
+
+	qglXChooseVisual             =  GPA("glXChooseVisual");
+	qglXCreateContext            =  GPA("glXCreateContext");
+	qglXDestroyContext           =  GPA("glXDestroyContext");
+	qglXMakeCurrent              =  GPA("glXMakeCurrent");
+	qglXCopyContext              =  GPA("glXCopyContext");
+	qglXSwapBuffers              =  GPA("glXSwapBuffers");
+
+	qglLockArraysEXT = 0;
+	qglUnlockArraysEXT = 0;
+	qglPointParameterfEXT = 0;
+	qglPointParameterfvEXT = 0;
+	qglColorTableEXT = 0;
+	qgl3DfxSetPaletteEXT = 0;
+	qglSelectTextureSGIS = 0;
+	qglMTexCoord2fSGIS = 0;
+	qglActiveTextureARB = 0;
+	qglClientActiveTextureARB = 0;
+	qglMultiTexCoord2fARB = 0;
+
+	return qtrue;
+}
+
+void QGL_EnableLogging( qboolean enable ) {
+  // bk001205 - fixed for new countdown
+  static qboolean isEnabled = qfalse; // init
+  
+  // return if we're already active
+  if ( isEnabled && enable ) {
+    // decrement log counter and stop if it has reached 0
+    ri.Cvar_Set( "r_logFile", va("%d", r_logFile->integer - 1 ) );
+    if ( r_logFile->integer ) {
+      return;
+    }
+    enable = qfalse;
+  }
+
+  // return if we're already disabled
+  if ( !enable && !isEnabled )
+    return;
+
+  isEnabled = enable;
+
+  // bk001205 - old code starts here
+  if ( enable ) {
+    if ( !glw_state.log_fp ) {
+      struct tm *newtime;
+      time_t aclock;
+      char buffer[1024];
+      cvar_t	*basedir;
+      
+      time( &aclock );
+      newtime = localtime( &aclock );
+      
+      asctime( newtime );
+      
+      basedir = ri.Cvar_Get( "fs_basepath", "", 0 ); // FIXME: userdir?
+      assert(basedir);
+      Com_sprintf( buffer, sizeof(buffer), "%s/gl.log", basedir->string ); 
+      glw_state.log_fp = fopen( buffer, "wt" );
+      assert(glw_state.log_fp);
+      ri.Printf(PRINT_ALL, "QGL_EnableLogging(%d): writing %s\n", r_logFile->integer, buffer );
+
+      fprintf( glw_state.log_fp, "%s\n", asctime( newtime ) );
+    }
+
+                qglAccum                     = logAccum;
+                qglAlphaFunc                 = logAlphaFunc;
+                qglAreTexturesResident       = logAreTexturesResident;
+		qglArrayElement              = logArrayElement;
+		qglBegin                     = logBegin;
+		qglBindTexture               = logBindTexture;
+		qglBitmap                    = logBitmap;
+		qglBlendFunc                 = logBlendFunc;
+		qglCallList                  = logCallList;
+		qglCallLists                 = logCallLists;
+		qglClear                     = logClear;
+		qglClearAccum                = logClearAccum;
+		qglClearColor                = logClearColor;
+		qglClearDepth                = logClearDepth;
+		qglClearIndex                = logClearIndex;
+		qglClearStencil              = logClearStencil;
+		qglClipPlane                 = logClipPlane;
+		qglColor3b                   = logColor3b;
+		qglColor3bv                  = logColor3bv;
+		qglColor3d                   = logColor3d;
+		qglColor3dv                  = logColor3dv;
+		qglColor3f                   = logColor3f;
+		qglColor3fv                  = logColor3fv;
+		qglColor3i                   = logColor3i;
+		qglColor3iv                  = logColor3iv;
+		qglColor3s                   = logColor3s;
+		qglColor3sv                  = logColor3sv;
+		qglColor3ub                  = logColor3ub;
+		qglColor3ubv                 = logColor3ubv;
+		qglColor3ui                  = logColor3ui;
+		qglColor3uiv                 = logColor3uiv;
+		qglColor3us                  = logColor3us;
+		qglColor3usv                 = logColor3usv;
+		qglColor4b                   = logColor4b;
+		qglColor4bv                  = logColor4bv;
+		qglColor4d                   = logColor4d;
+		qglColor4dv                  = logColor4dv;
+		qglColor4f                   = logColor4f;
+		qglColor4fv                  = logColor4fv;
+		qglColor4i                   = logColor4i;
+		qglColor4iv                  = logColor4iv;
+		qglColor4s                   = logColor4s;
+		qglColor4sv                  = logColor4sv;
+		qglColor4ub                  = logColor4ub;
+		qglColor4ubv                 = logColor4ubv;
+		qglColor4ui                  = logColor4ui;
+		qglColor4uiv                 = logColor4uiv;
+		qglColor4us                  = logColor4us;
+		qglColor4usv                 = logColor4usv;
+		qglColorMask                 = logColorMask;
+		qglColorMaterial             = logColorMaterial;
+		qglColorPointer              = logColorPointer;
+		qglCopyPixels                = logCopyPixels;
+		qglCopyTexImage1D            = logCopyTexImage1D;
+		qglCopyTexImage2D            = logCopyTexImage2D;
+		qglCopyTexSubImage1D         = logCopyTexSubImage1D;
+		qglCopyTexSubImage2D         = logCopyTexSubImage2D;
+		qglCullFace                  = logCullFace;
+		qglDeleteLists               = logDeleteLists ;
+		qglDeleteTextures            = logDeleteTextures ;
+		qglDepthFunc                 = logDepthFunc ;
+		qglDepthMask                 = logDepthMask ;
+		qglDepthRange                = logDepthRange ;
+		qglDisable                   = logDisable ;
+		qglDisableClientState        = logDisableClientState ;
+		qglDrawArrays                = logDrawArrays ;
+		qglDrawBuffer                = logDrawBuffer ;
+		qglDrawElements              = logDrawElements ;
+		qglDrawPixels                = logDrawPixels ;
+		qglEdgeFlag                  = logEdgeFlag ;
+		qglEdgeFlagPointer           = logEdgeFlagPointer ;
+		qglEdgeFlagv                 = logEdgeFlagv ;
+		qglEnable                    = 	logEnable                    ;
+		qglEnableClientState         = 	logEnableClientState         ;
+		qglEnd                       = 	logEnd                       ;
+		qglEndList                   = 	logEndList                   ;
+		qglEvalCoord1d				 = 	logEvalCoord1d				 ;
+		qglEvalCoord1dv              = 	logEvalCoord1dv              ;
+		qglEvalCoord1f               = 	logEvalCoord1f               ;
+		qglEvalCoord1fv              = 	logEvalCoord1fv              ;
+		qglEvalCoord2d               = 	logEvalCoord2d               ;
+		qglEvalCoord2dv              = 	logEvalCoord2dv              ;
+		qglEvalCoord2f               = 	logEvalCoord2f               ;
+		qglEvalCoord2fv              = 	logEvalCoord2fv              ;
+		qglEvalMesh1                 = 	logEvalMesh1                 ;
+		qglEvalMesh2                 = 	logEvalMesh2                 ;
+		qglEvalPoint1                = 	logEvalPoint1                ;
+		qglEvalPoint2                = 	logEvalPoint2                ;
+		qglFeedbackBuffer            = 	logFeedbackBuffer            ;
+		qglFinish                    = 	logFinish                    ;
+		qglFlush                     = 	logFlush                     ;
+		qglFogf                      = 	logFogf                      ;
+		qglFogfv                     = 	logFogfv                     ;
+		qglFogi                      = 	logFogi                      ;
+		qglFogiv                     = 	logFogiv                     ;
+		qglFrontFace                 = 	logFrontFace                 ;
+		qglFrustum                   = 	logFrustum                   ;
+		qglGenLists                  = 	logGenLists                  ;
+		qglGenTextures               = 	logGenTextures               ;
+		qglGetBooleanv               = 	logGetBooleanv               ;
+		qglGetClipPlane              = 	logGetClipPlane              ;
+		qglGetDoublev                = 	logGetDoublev                ;
+		qglGetError                  = 	logGetError                  ;
+		qglGetFloatv                 = 	logGetFloatv                 ;
+		qglGetIntegerv               = 	logGetIntegerv               ;
+		qglGetLightfv                = 	logGetLightfv                ;
+		qglGetLightiv                = 	logGetLightiv                ;
+		qglGetMapdv                  = 	logGetMapdv                  ;
+		qglGetMapfv                  = 	logGetMapfv                  ;
+		qglGetMapiv                  = 	logGetMapiv                  ;
+		qglGetMaterialfv             = 	logGetMaterialfv             ;
+		qglGetMaterialiv             = 	logGetMaterialiv             ;
+		qglGetPixelMapfv             = 	logGetPixelMapfv             ;
+		qglGetPixelMapuiv            = 	logGetPixelMapuiv            ;
+		qglGetPixelMapusv            = 	logGetPixelMapusv            ;
+		qglGetPointerv               = 	logGetPointerv               ;
+		qglGetPolygonStipple         = 	logGetPolygonStipple         ;
+		qglGetString                 = 	logGetString                 ;
+		qglGetTexEnvfv               = 	logGetTexEnvfv               ;
+		qglGetTexEnviv               = 	logGetTexEnviv               ;
+		qglGetTexGendv               = 	logGetTexGendv               ;
+		qglGetTexGenfv               = 	logGetTexGenfv               ;
+		qglGetTexGeniv               = 	logGetTexGeniv               ;
+		qglGetTexImage               = 	logGetTexImage               ;
+		qglGetTexLevelParameterfv    = 	logGetTexLevelParameterfv    ;
+		qglGetTexLevelParameteriv    = 	logGetTexLevelParameteriv    ;
+		qglGetTexParameterfv         = 	logGetTexParameterfv         ;
+		qglGetTexParameteriv         = 	logGetTexParameteriv         ;
+		qglHint                      = 	logHint                      ;
+		qglIndexMask                 = 	logIndexMask                 ;
+		qglIndexPointer              = 	logIndexPointer              ;
+		qglIndexd                    = 	logIndexd                    ;
+		qglIndexdv                   = 	logIndexdv                   ;
+		qglIndexf                    = 	logIndexf                    ;
+		qglIndexfv                   = 	logIndexfv                   ;
+		qglIndexi                    = 	logIndexi                    ;
+		qglIndexiv                   = 	logIndexiv                   ;
+		qglIndexs                    = 	logIndexs                    ;
+		qglIndexsv                   = 	logIndexsv                   ;
+		qglIndexub                   = 	logIndexub                   ;
+		qglIndexubv                  = 	logIndexubv                  ;
+		qglInitNames                 = 	logInitNames                 ;
+		qglInterleavedArrays         = 	logInterleavedArrays         ;
+		qglIsEnabled                 = 	logIsEnabled                 ;
+		qglIsList                    = 	logIsList                    ;
+		qglIsTexture                 = 	logIsTexture                 ;
+		qglLightModelf               = 	logLightModelf               ;
+		qglLightModelfv              = 	logLightModelfv              ;
+		qglLightModeli               = 	logLightModeli               ;
+		qglLightModeliv              = 	logLightModeliv              ;
+		qglLightf                    = 	logLightf                    ;
+		qglLightfv                   = 	logLightfv                   ;
+		qglLighti                    = 	logLighti                    ;
+		qglLightiv                   = 	logLightiv                   ;
+		qglLineStipple               = 	logLineStipple               ;
+		qglLineWidth                 = 	logLineWidth                 ;
+		qglListBase                  = 	logListBase                  ;
+		qglLoadIdentity              = 	logLoadIdentity              ;
+		qglLoadMatrixd               = 	logLoadMatrixd               ;
+		qglLoadMatrixf               = 	logLoadMatrixf               ;
+		qglLoadName                  = 	logLoadName                  ;
+		qglLogicOp                   = 	logLogicOp                   ;
+		qglMap1d                     = 	logMap1d                     ;
+		qglMap1f                     = 	logMap1f                     ;
+		qglMap2d                     = 	logMap2d                     ;
+		qglMap2f                     = 	logMap2f                     ;
+		qglMapGrid1d                 = 	logMapGrid1d                 ;
+		qglMapGrid1f                 = 	logMapGrid1f                 ;
+		qglMapGrid2d                 = 	logMapGrid2d                 ;
+		qglMapGrid2f                 = 	logMapGrid2f                 ;
+		qglMaterialf                 = 	logMaterialf                 ;
+		qglMaterialfv                = 	logMaterialfv                ;
+		qglMateriali                 = 	logMateriali                 ;
+		qglMaterialiv                = 	logMaterialiv                ;
+		qglMatrixMode                = 	logMatrixMode                ;
+		qglMultMatrixd               = 	logMultMatrixd               ;
+		qglMultMatrixf               = 	logMultMatrixf               ;
+		qglNewList                   = 	logNewList                   ;
+		qglNormal3b                  = 	logNormal3b                  ;
+		qglNormal3bv                 = 	logNormal3bv                 ;
+		qglNormal3d                  = 	logNormal3d                  ;
+		qglNormal3dv                 = 	logNormal3dv                 ;
+		qglNormal3f                  = 	logNormal3f                  ;
+		qglNormal3fv                 = 	logNormal3fv                 ;
+		qglNormal3i                  = 	logNormal3i                  ;
+		qglNormal3iv                 = 	logNormal3iv                 ;
+		qglNormal3s                  = 	logNormal3s                  ;
+		qglNormal3sv                 = 	logNormal3sv                 ;
+		qglNormalPointer             = 	logNormalPointer             ;
+		qglOrtho                     = 	logOrtho                     ;
+		qglPassThrough               = 	logPassThrough               ;
+		qglPixelMapfv                = 	logPixelMapfv                ;
+		qglPixelMapuiv               = 	logPixelMapuiv               ;
+		qglPixelMapusv               = 	logPixelMapusv               ;
+		qglPixelStoref               = 	logPixelStoref               ;
+		qglPixelStorei               = 	logPixelStorei               ;
+		qglPixelTransferf            = 	logPixelTransferf            ;
+		qglPixelTransferi            = 	logPixelTransferi            ;
+		qglPixelZoom                 = 	logPixelZoom                 ;
+		qglPointSize                 = 	logPointSize                 ;
+		qglPolygonMode               = 	logPolygonMode               ;
+		qglPolygonOffset             = 	logPolygonOffset             ;
+		qglPolygonStipple            = 	logPolygonStipple            ;
+		qglPopAttrib                 = 	logPopAttrib                 ;
+		qglPopClientAttrib           = 	logPopClientAttrib           ;
+		qglPopMatrix                 = 	logPopMatrix                 ;
+		qglPopName                   = 	logPopName                   ;
+		qglPrioritizeTextures        = 	logPrioritizeTextures        ;
+		qglPushAttrib                = 	logPushAttrib                ;
+		qglPushClientAttrib          = 	logPushClientAttrib          ;
+		qglPushMatrix                = 	logPushMatrix                ;
+		qglPushName                  = 	logPushName                  ;
+		qglRasterPos2d               = 	logRasterPos2d               ;
+		qglRasterPos2dv              = 	logRasterPos2dv              ;
+		qglRasterPos2f               = 	logRasterPos2f               ;
+		qglRasterPos2fv              = 	logRasterPos2fv              ;
+		qglRasterPos2i               = 	logRasterPos2i               ;
+		qglRasterPos2iv              = 	logRasterPos2iv              ;
+		qglRasterPos2s               = 	logRasterPos2s               ;
+		qglRasterPos2sv              = 	logRasterPos2sv              ;
+		qglRasterPos3d               = 	logRasterPos3d               ;
+		qglRasterPos3dv              = 	logRasterPos3dv              ;
+		qglRasterPos3f               = 	logRasterPos3f               ;
+		qglRasterPos3fv              = 	logRasterPos3fv              ;
+		qglRasterPos3i               = 	logRasterPos3i               ;
+		qglRasterPos3iv              = 	logRasterPos3iv              ;
+		qglRasterPos3s               = 	logRasterPos3s               ;
+		qglRasterPos3sv              = 	logRasterPos3sv              ;
+		qglRasterPos4d               = 	logRasterPos4d               ;
+		qglRasterPos4dv              = 	logRasterPos4dv              ;
+		qglRasterPos4f               = 	logRasterPos4f               ;
+		qglRasterPos4fv              = 	logRasterPos4fv              ;
+		qglRasterPos4i               = 	logRasterPos4i               ;
+		qglRasterPos4iv              = 	logRasterPos4iv              ;
+		qglRasterPos4s               = 	logRasterPos4s               ;
+		qglRasterPos4sv              = 	logRasterPos4sv              ;
+		qglReadBuffer                = 	logReadBuffer                ;
+		qglReadPixels                = 	logReadPixels                ;
+		qglRectd                     = 	logRectd                     ;
+		qglRectdv                    = 	logRectdv                    ;
+		qglRectf                     = 	logRectf                     ;
+		qglRectfv                    = 	logRectfv                    ;
+		qglRecti                     = 	logRecti                     ;
+		qglRectiv                    = 	logRectiv                    ;
+		qglRects                     = 	logRects                     ;
+		qglRectsv                    = 	logRectsv                    ;
+		qglRenderMode                = 	logRenderMode                ;
+		qglRotated                   = 	logRotated                   ;
+		qglRotatef                   = 	logRotatef                   ;
+		qglScaled                    = 	logScaled                    ;
+		qglScalef                    = 	logScalef                    ;
+		qglScissor                   = 	logScissor                   ;
+		qglSelectBuffer              = 	logSelectBuffer              ;
+		qglShadeModel                = 	logShadeModel                ;
+		qglStencilFunc               = 	logStencilFunc               ;
+		qglStencilMask               = 	logStencilMask               ;
+		qglStencilOp                 = 	logStencilOp                 ;
+		qglTexCoord1d                = 	logTexCoord1d                ;
+		qglTexCoord1dv               = 	logTexCoord1dv               ;
+		qglTexCoord1f                = 	logTexCoord1f                ;
+		qglTexCoord1fv               = 	logTexCoord1fv               ;
+		qglTexCoord1i                = 	logTexCoord1i                ;
+		qglTexCoord1iv               = 	logTexCoord1iv               ;
+		qglTexCoord1s                = 	logTexCoord1s                ;
+		qglTexCoord1sv               = 	logTexCoord1sv               ;
+		qglTexCoord2d                = 	logTexCoord2d                ;
+		qglTexCoord2dv               = 	logTexCoord2dv               ;
+		qglTexCoord2f                = 	logTexCoord2f                ;
+		qglTexCoord2fv               = 	logTexCoord2fv               ;
+		qglTexCoord2i                = 	logTexCoord2i                ;
+		qglTexCoord2iv               = 	logTexCoord2iv               ;
+		qglTexCoord2s                = 	logTexCoord2s                ;
+		qglTexCoord2sv               = 	logTexCoord2sv               ;
+		qglTexCoord3d                = 	logTexCoord3d                ;
+		qglTexCoord3dv               = 	logTexCoord3dv               ;
+		qglTexCoord3f                = 	logTexCoord3f                ;
+		qglTexCoord3fv               = 	logTexCoord3fv               ;
+		qglTexCoord3i                = 	logTexCoord3i                ;
+		qglTexCoord3iv               = 	logTexCoord3iv               ;
+		qglTexCoord3s                = 	logTexCoord3s                ;
+		qglTexCoord3sv               = 	logTexCoord3sv               ;
+		qglTexCoord4d                = 	logTexCoord4d                ;
+		qglTexCoord4dv               = 	logTexCoord4dv               ;
+		qglTexCoord4f                = 	logTexCoord4f                ;
+		qglTexCoord4fv               = 	logTexCoord4fv               ;
+		qglTexCoord4i                = 	logTexCoord4i                ;
+		qglTexCoord4iv               = 	logTexCoord4iv               ;
+		qglTexCoord4s                = 	logTexCoord4s                ;
+		qglTexCoord4sv               = 	logTexCoord4sv               ;
+		qglTexCoordPointer           = 	logTexCoordPointer           ;
+		qglTexEnvf                   = 	logTexEnvf                   ;
+		qglTexEnvfv                  = 	logTexEnvfv                  ;
+		qglTexEnvi                   = 	logTexEnvi                   ;
+		qglTexEnviv                  = 	logTexEnviv                  ;
+		qglTexGend                   = 	logTexGend                   ;
+		qglTexGendv                  = 	logTexGendv                  ;
+		qglTexGenf                   = 	logTexGenf                   ;
+		qglTexGenfv                  = 	logTexGenfv                  ;
+		qglTexGeni                   = 	logTexGeni                   ;
+		qglTexGeniv                  = 	logTexGeniv                  ;
+		qglTexImage1D                = 	logTexImage1D                ;
+		qglTexImage2D                = 	logTexImage2D                ;
+		qglTexParameterf             = 	logTexParameterf             ;
+		qglTexParameterfv            = 	logTexParameterfv            ;
+		qglTexParameteri             = 	logTexParameteri             ;
+		qglTexParameteriv            = 	logTexParameteriv            ;
+		qglTexSubImage1D             = 	logTexSubImage1D             ;
+		qglTexSubImage2D             = 	logTexSubImage2D             ;
+		qglTranslated                = 	logTranslated                ;
+		qglTranslatef                = 	logTranslatef                ;
+		qglVertex2d                  = 	logVertex2d                  ;
+		qglVertex2dv                 = 	logVertex2dv                 ;
+		qglVertex2f                  = 	logVertex2f                  ;
+		qglVertex2fv                 = 	logVertex2fv                 ;
+		qglVertex2i                  = 	logVertex2i                  ;
+		qglVertex2iv                 = 	logVertex2iv                 ;
+		qglVertex2s                  = 	logVertex2s                  ;
+		qglVertex2sv                 = 	logVertex2sv                 ;
+		qglVertex3d                  = 	logVertex3d                  ;
+		qglVertex3dv                 = 	logVertex3dv                 ;
+		qglVertex3f                  = 	logVertex3f                  ;
+		qglVertex3fv                 = 	logVertex3fv                 ;
+		qglVertex3i                  = 	logVertex3i                  ;
+		qglVertex3iv                 = 	logVertex3iv                 ;
+		qglVertex3s                  = 	logVertex3s                  ;
+		qglVertex3sv                 = 	logVertex3sv                 ;
+		qglVertex4d                  = 	logVertex4d                  ;
+		qglVertex4dv                 = 	logVertex4dv                 ;
+		qglVertex4f                  = 	logVertex4f                  ;
+		qglVertex4fv                 = 	logVertex4fv                 ;
+		qglVertex4i                  = 	logVertex4i                  ;
+		qglVertex4iv                 = 	logVertex4iv                 ;
+		qglVertex4s                  = 	logVertex4s                  ;
+		qglVertex4sv                 = 	logVertex4sv                 ;
+		qglVertexPointer             = 	logVertexPointer             ;
+		qglViewport                  = 	logViewport                  ;
+	}
+	else
+	{
+		qglAccum                     = dllAccum;
+		qglAlphaFunc                 = dllAlphaFunc;
+		qglAreTexturesResident       = dllAreTexturesResident;
+		qglArrayElement              = dllArrayElement;
+		qglBegin                     = dllBegin;
+		qglBindTexture               = dllBindTexture;
+		qglBitmap                    = dllBitmap;
+		qglBlendFunc                 = dllBlendFunc;
+		qglCallList                  = dllCallList;
+		qglCallLists                 = dllCallLists;
+		qglClear                     = dllClear;
+		qglClearAccum                = dllClearAccum;
+		qglClearColor                = dllClearColor;
+		qglClearDepth                = dllClearDepth;
+		qglClearIndex                = dllClearIndex;
+		qglClearStencil              = dllClearStencil;
+		qglClipPlane                 = dllClipPlane;
+		qglColor3b                   = dllColor3b;
+		qglColor3bv                  = dllColor3bv;
+		qglColor3d                   = dllColor3d;
+		qglColor3dv                  = dllColor3dv;
+		qglColor3f                   = dllColor3f;
+		qglColor3fv                  = dllColor3fv;
+		qglColor3i                   = dllColor3i;
+		qglColor3iv                  = dllColor3iv;
+		qglColor3s                   = dllColor3s;
+		qglColor3sv                  = dllColor3sv;
+		qglColor3ub                  = dllColor3ub;
+		qglColor3ubv                 = dllColor3ubv;
+		qglColor3ui                  = dllColor3ui;
+		qglColor3uiv                 = dllColor3uiv;
+		qglColor3us                  = dllColor3us;
+		qglColor3usv                 = dllColor3usv;
+		qglColor4b                   = dllColor4b;
+		qglColor4bv                  = dllColor4bv;
+		qglColor4d                   = dllColor4d;
+		qglColor4dv                  = dllColor4dv;
+		qglColor4f                   = dllColor4f;
+		qglColor4fv                  = dllColor4fv;
+		qglColor4i                   = dllColor4i;
+		qglColor4iv                  = dllColor4iv;
+		qglColor4s                   = dllColor4s;
+		qglColor4sv                  = dllColor4sv;
+		qglColor4ub                  = dllColor4ub;
+		qglColor4ubv                 = dllColor4ubv;
+		qglColor4ui                  = dllColor4ui;
+		qglColor4uiv                 = dllColor4uiv;
+		qglColor4us                  = dllColor4us;
+		qglColor4usv                 = dllColor4usv;
+		qglColorMask                 = dllColorMask;
+		qglColorMaterial             = dllColorMaterial;
+		qglColorPointer              = dllColorPointer;
+		qglCopyPixels                = dllCopyPixels;
+		qglCopyTexImage1D            = dllCopyTexImage1D;
+		qglCopyTexImage2D            = dllCopyTexImage2D;
+		qglCopyTexSubImage1D         = dllCopyTexSubImage1D;
+		qglCopyTexSubImage2D         = dllCopyTexSubImage2D;
+		qglCullFace                  = dllCullFace;
+		qglDeleteLists               = dllDeleteLists ;
+		qglDeleteTextures            = dllDeleteTextures ;
+		qglDepthFunc                 = dllDepthFunc ;
+		qglDepthMask                 = dllDepthMask ;
+		qglDepthRange                = dllDepthRange ;
+		qglDisable                   = dllDisable ;
+		qglDisableClientState        = dllDisableClientState ;
+		qglDrawArrays                = dllDrawArrays ;
+		qglDrawBuffer                = dllDrawBuffer ;
+		qglDrawElements              = dllDrawElements ;
+		qglDrawPixels                = dllDrawPixels ;
+		qglEdgeFlag                  = dllEdgeFlag ;
+		qglEdgeFlagPointer           = dllEdgeFlagPointer ;
+		qglEdgeFlagv                 = dllEdgeFlagv ;
+		qglEnable                    = 	dllEnable                    ;
+		qglEnableClientState         = 	dllEnableClientState         ;
+		qglEnd                       = 	dllEnd                       ;
+		qglEndList                   = 	dllEndList                   ;
+		qglEvalCoord1d				 = 	dllEvalCoord1d				 ;
+		qglEvalCoord1dv              = 	dllEvalCoord1dv              ;
+		qglEvalCoord1f               = 	dllEvalCoord1f               ;
+		qglEvalCoord1fv              = 	dllEvalCoord1fv              ;
+		qglEvalCoord2d               = 	dllEvalCoord2d               ;
+		qglEvalCoord2dv              = 	dllEvalCoord2dv              ;
+		qglEvalCoord2f               = 	dllEvalCoord2f               ;
+		qglEvalCoord2fv              = 	dllEvalCoord2fv              ;
+		qglEvalMesh1                 = 	dllEvalMesh1                 ;
+		qglEvalMesh2                 = 	dllEvalMesh2                 ;
+		qglEvalPoint1                = 	dllEvalPoint1                ;
+		qglEvalPoint2                = 	dllEvalPoint2                ;
+		qglFeedbackBuffer            = 	dllFeedbackBuffer            ;
+		qglFinish                    = 	dllFinish                    ;
+		qglFlush                     = 	dllFlush                     ;
+		qglFogf                      = 	dllFogf                      ;
+		qglFogfv                     = 	dllFogfv                     ;
+		qglFogi                      = 	dllFogi                      ;
+		qglFogiv                     = 	dllFogiv                     ;
+		qglFrontFace                 = 	dllFrontFace                 ;
+		qglFrustum                   = 	dllFrustum                   ;
+		qglGenLists                  = 	dllGenLists                  ;
+		qglGenTextures               = 	dllGenTextures               ;
+		qglGetBooleanv               = 	dllGetBooleanv               ;
+		qglGetClipPlane              = 	dllGetClipPlane              ;
+		qglGetDoublev                = 	dllGetDoublev                ;
+		qglGetError                  = 	dllGetError                  ;
+		qglGetFloatv                 = 	dllGetFloatv                 ;
+		qglGetIntegerv               = 	dllGetIntegerv               ;
+		qglGetLightfv                = 	dllGetLightfv                ;
+		qglGetLightiv                = 	dllGetLightiv                ;
+		qglGetMapdv                  = 	dllGetMapdv                  ;
+		qglGetMapfv                  = 	dllGetMapfv                  ;
+		qglGetMapiv                  = 	dllGetMapiv                  ;
+		qglGetMaterialfv             = 	dllGetMaterialfv             ;
+		qglGetMaterialiv             = 	dllGetMaterialiv             ;
+		qglGetPixelMapfv             = 	dllGetPixelMapfv             ;
+		qglGetPixelMapuiv            = 	dllGetPixelMapuiv            ;
+		qglGetPixelMapusv            = 	dllGetPixelMapusv            ;
+		qglGetPointerv               = 	dllGetPointerv               ;
+		qglGetPolygonStipple         = 	dllGetPolygonStipple         ;
+		qglGetString                 = 	dllGetString                 ;
+		qglGetTexEnvfv               = 	dllGetTexEnvfv               ;
+		qglGetTexEnviv               = 	dllGetTexEnviv               ;
+		qglGetTexGendv               = 	dllGetTexGendv               ;
+		qglGetTexGenfv               = 	dllGetTexGenfv               ;
+		qglGetTexGeniv               = 	dllGetTexGeniv               ;
+		qglGetTexImage               = 	dllGetTexImage               ;
+		qglGetTexLevelParameterfv    = 	dllGetTexLevelParameterfv    ;
+		qglGetTexLevelParameteriv    = 	dllGetTexLevelParameteriv    ;
+		qglGetTexParameterfv         = 	dllGetTexParameterfv         ;
+		qglGetTexParameteriv         = 	dllGetTexParameteriv         ;
+		qglHint                      = 	dllHint                      ;
+		qglIndexMask                 = 	dllIndexMask                 ;
+		qglIndexPointer              = 	dllIndexPointer              ;
+		qglIndexd                    = 	dllIndexd                    ;
+		qglIndexdv                   = 	dllIndexdv                   ;
+		qglIndexf                    = 	dllIndexf                    ;
+		qglIndexfv                   = 	dllIndexfv                   ;
+		qglIndexi                    = 	dllIndexi                    ;
+		qglIndexiv                   = 	dllIndexiv                   ;
+		qglIndexs                    = 	dllIndexs                    ;
+		qglIndexsv                   = 	dllIndexsv                   ;
+		qglIndexub                   = 	dllIndexub                   ;
+		qglIndexubv                  = 	dllIndexubv                  ;
+		qglInitNames                 = 	dllInitNames                 ;
+		qglInterleavedArrays         = 	dllInterleavedArrays         ;
+		qglIsEnabled                 = 	dllIsEnabled                 ;
+		qglIsList                    = 	dllIsList                    ;
+		qglIsTexture                 = 	dllIsTexture                 ;
+		qglLightModelf               = 	dllLightModelf               ;
+		qglLightModelfv              = 	dllLightModelfv              ;
+		qglLightModeli               = 	dllLightModeli               ;
+		qglLightModeliv              = 	dllLightModeliv              ;
+		qglLightf                    = 	dllLightf                    ;
+		qglLightfv                   = 	dllLightfv                   ;
+		qglLighti                    = 	dllLighti                    ;
+		qglLightiv                   = 	dllLightiv                   ;
+		qglLineStipple               = 	dllLineStipple               ;
+		qglLineWidth                 = 	dllLineWidth                 ;
+		qglListBase                  = 	dllListBase                  ;
+		qglLoadIdentity              = 	dllLoadIdentity              ;
+		qglLoadMatrixd               = 	dllLoadMatrixd               ;
+		qglLoadMatrixf               = 	dllLoadMatrixf               ;
+		qglLoadName                  = 	dllLoadName                  ;
+		qglLogicOp                   = 	dllLogicOp                   ;
+		qglMap1d                     = 	dllMap1d                     ;
+		qglMap1f                     = 	dllMap1f                     ;
+		qglMap2d                     = 	dllMap2d                     ;
+		qglMap2f                     = 	dllMap2f                     ;
+		qglMapGrid1d                 = 	dllMapGrid1d                 ;
+		qglMapGrid1f                 = 	dllMapGrid1f                 ;
+		qglMapGrid2d                 = 	dllMapGrid2d                 ;
+		qglMapGrid2f                 = 	dllMapGrid2f                 ;
+		qglMaterialf                 = 	dllMaterialf                 ;
+		qglMaterialfv                = 	dllMaterialfv                ;
+		qglMateriali                 = 	dllMateriali                 ;
+		qglMaterialiv                = 	dllMaterialiv                ;
+		qglMatrixMode                = 	dllMatrixMode                ;
+		qglMultMatrixd               = 	dllMultMatrixd               ;
+		qglMultMatrixf               = 	dllMultMatrixf               ;
+		qglNewList                   = 	dllNewList                   ;
+		qglNormal3b                  = 	dllNormal3b                  ;
+		qglNormal3bv                 = 	dllNormal3bv                 ;
+		qglNormal3d                  = 	dllNormal3d                  ;
+		qglNormal3dv                 = 	dllNormal3dv                 ;
+		qglNormal3f                  = 	dllNormal3f                  ;
+		qglNormal3fv                 = 	dllNormal3fv                 ;
+		qglNormal3i                  = 	dllNormal3i                  ;
+		qglNormal3iv                 = 	dllNormal3iv                 ;
+		qglNormal3s                  = 	dllNormal3s                  ;
+		qglNormal3sv                 = 	dllNormal3sv                 ;
+		qglNormalPointer             = 	dllNormalPointer             ;
+		qglOrtho                     = 	dllOrtho                     ;
+		qglPassThrough               = 	dllPassThrough               ;
+		qglPixelMapfv                = 	dllPixelMapfv                ;
+		qglPixelMapuiv               = 	dllPixelMapuiv               ;
+		qglPixelMapusv               = 	dllPixelMapusv               ;
+		qglPixelStoref               = 	dllPixelStoref               ;
+		qglPixelStorei               = 	dllPixelStorei               ;
+		qglPixelTransferf            = 	dllPixelTransferf            ;
+		qglPixelTransferi            = 	dllPixelTransferi            ;
+		qglPixelZoom                 = 	dllPixelZoom                 ;
+		qglPointSize                 = 	dllPointSize                 ;
+		qglPolygonMode               = 	dllPolygonMode               ;
+		qglPolygonOffset             = 	dllPolygonOffset             ;
+		qglPolygonStipple            = 	dllPolygonStipple            ;
+		qglPopAttrib                 = 	dllPopAttrib                 ;
+		qglPopClientAttrib           = 	dllPopClientAttrib           ;
+		qglPopMatrix                 = 	dllPopMatrix                 ;
+		qglPopName                   = 	dllPopName                   ;
+		qglPrioritizeTextures        = 	dllPrioritizeTextures        ;
+		qglPushAttrib                = 	dllPushAttrib                ;
+		qglPushClientAttrib          = 	dllPushClientAttrib          ;
+		qglPushMatrix                = 	dllPushMatrix                ;
+		qglPushName                  = 	dllPushName                  ;
+		qglRasterPos2d               = 	dllRasterPos2d               ;
+		qglRasterPos2dv              = 	dllRasterPos2dv              ;
+		qglRasterPos2f               = 	dllRasterPos2f               ;
+		qglRasterPos2fv              = 	dllRasterPos2fv              ;
+		qglRasterPos2i               = 	dllRasterPos2i               ;
+		qglRasterPos2iv              = 	dllRasterPos2iv              ;
+		qglRasterPos2s               = 	dllRasterPos2s               ;
+		qglRasterPos2sv              = 	dllRasterPos2sv              ;
+		qglRasterPos3d               = 	dllRasterPos3d               ;
+		qglRasterPos3dv              = 	dllRasterPos3dv              ;
+		qglRasterPos3f               = 	dllRasterPos3f               ;
+		qglRasterPos3fv              = 	dllRasterPos3fv              ;
+		qglRasterPos3i               = 	dllRasterPos3i               ;
+		qglRasterPos3iv              = 	dllRasterPos3iv              ;
+		qglRasterPos3s               = 	dllRasterPos3s               ;
+		qglRasterPos3sv              = 	dllRasterPos3sv              ;
+		qglRasterPos4d               = 	dllRasterPos4d               ;
+		qglRasterPos4dv              = 	dllRasterPos4dv              ;
+		qglRasterPos4f               = 	dllRasterPos4f               ;
+		qglRasterPos4fv              = 	dllRasterPos4fv              ;
+		qglRasterPos4i               = 	dllRasterPos4i               ;
+		qglRasterPos4iv              = 	dllRasterPos4iv              ;
+		qglRasterPos4s               = 	dllRasterPos4s               ;
+		qglRasterPos4sv              = 	dllRasterPos4sv              ;
+		qglReadBuffer                = 	dllReadBuffer                ;
+		qglReadPixels                = 	dllReadPixels                ;
+		qglRectd                     = 	dllRectd                     ;
+		qglRectdv                    = 	dllRectdv                    ;
+		qglRectf                     = 	dllRectf                     ;
+		qglRectfv                    = 	dllRectfv                    ;
+		qglRecti                     = 	dllRecti                     ;
+		qglRectiv                    = 	dllRectiv                    ;
+		qglRects                     = 	dllRects                     ;
+		qglRectsv                    = 	dllRectsv                    ;
+		qglRenderMode                = 	dllRenderMode                ;
+		qglRotated                   = 	dllRotated                   ;
+		qglRotatef                   = 	dllRotatef                   ;
+		qglScaled                    = 	dllScaled                    ;
+		qglScalef                    = 	dllScalef                    ;
+		qglScissor                   = 	dllScissor                   ;
+		qglSelectBuffer              = 	dllSelectBuffer              ;
+		qglShadeModel                = 	dllShadeModel                ;
+		qglStencilFunc               = 	dllStencilFunc               ;
+		qglStencilMask               = 	dllStencilMask               ;
+		qglStencilOp                 = 	dllStencilOp                 ;
+		qglTexCoord1d                = 	dllTexCoord1d                ;
+		qglTexCoord1dv               = 	dllTexCoord1dv               ;
+		qglTexCoord1f                = 	dllTexCoord1f                ;
+		qglTexCoord1fv               = 	dllTexCoord1fv               ;
+		qglTexCoord1i                = 	dllTexCoord1i                ;
+		qglTexCoord1iv               = 	dllTexCoord1iv               ;
+		qglTexCoord1s                = 	dllTexCoord1s                ;
+		qglTexCoord1sv               = 	dllTexCoord1sv               ;
+		qglTexCoord2d                = 	dllTexCoord2d                ;
+		qglTexCoord2dv               = 	dllTexCoord2dv               ;
+		qglTexCoord2f                = 	dllTexCoord2f                ;
+		qglTexCoord2fv               = 	dllTexCoord2fv               ;
+		qglTexCoord2i                = 	dllTexCoord2i                ;
+		qglTexCoord2iv               = 	dllTexCoord2iv               ;
+		qglTexCoord2s                = 	dllTexCoord2s                ;
+		qglTexCoord2sv               = 	dllTexCoord2sv               ;
+		qglTexCoord3d                = 	dllTexCoord3d                ;
+		qglTexCoord3dv               = 	dllTexCoord3dv               ;
+		qglTexCoord3f                = 	dllTexCoord3f                ;
+		qglTexCoord3fv               = 	dllTexCoord3fv               ;
+		qglTexCoord3i                = 	dllTexCoord3i                ;
+		qglTexCoord3iv               = 	dllTexCoord3iv               ;
+		qglTexCoord3s                = 	dllTexCoord3s                ;
+		qglTexCoord3sv               = 	dllTexCoord3sv               ;
+		qglTexCoord4d                = 	dllTexCoord4d                ;
+		qglTexCoord4dv               = 	dllTexCoord4dv               ;
+		qglTexCoord4f                = 	dllTexCoord4f                ;
+		qglTexCoord4fv               = 	dllTexCoord4fv               ;
+		qglTexCoord4i                = 	dllTexCoord4i                ;
+		qglTexCoord4iv               = 	dllTexCoord4iv               ;
+		qglTexCoord4s                = 	dllTexCoord4s                ;
+		qglTexCoord4sv               = 	dllTexCoord4sv               ;
+		qglTexCoordPointer           = 	dllTexCoordPointer           ;
+		qglTexEnvf                   = 	dllTexEnvf                   ;
+		qglTexEnvfv                  = 	dllTexEnvfv                  ;
+		qglTexEnvi                   = 	dllTexEnvi                   ;
+		qglTexEnviv                  = 	dllTexEnviv                  ;
+		qglTexGend                   = 	dllTexGend                   ;
+		qglTexGendv                  = 	dllTexGendv                  ;
+		qglTexGenf                   = 	dllTexGenf                   ;
+		qglTexGenfv                  = 	dllTexGenfv                  ;
+		qglTexGeni                   = 	dllTexGeni                   ;
+		qglTexGeniv                  = 	dllTexGeniv                  ;
+		qglTexImage1D                = 	dllTexImage1D                ;
+		qglTexImage2D                = 	dllTexImage2D                ;
+		qglTexParameterf             = 	dllTexParameterf             ;
+		qglTexParameterfv            = 	dllTexParameterfv            ;
+		qglTexParameteri             = 	dllTexParameteri             ;
+		qglTexParameteriv            = 	dllTexParameteriv            ;
+		qglTexSubImage1D             = 	dllTexSubImage1D             ;
+		qglTexSubImage2D             = 	dllTexSubImage2D             ;
+		qglTranslated                = 	dllTranslated                ;
+		qglTranslatef                = 	dllTranslatef                ;
+		qglVertex2d                  = 	dllVertex2d                  ;
+		qglVertex2dv                 = 	dllVertex2dv                 ;
+		qglVertex2f                  = 	dllVertex2f                  ;
+		qglVertex2fv                 = 	dllVertex2fv                 ;
+		qglVertex2i                  = 	dllVertex2i                  ;
+		qglVertex2iv                 = 	dllVertex2iv                 ;
+		qglVertex2s                  = 	dllVertex2s                  ;
+		qglVertex2sv                 = 	dllVertex2sv                 ;
+		qglVertex3d                  = 	dllVertex3d                  ;
+		qglVertex3dv                 = 	dllVertex3dv                 ;
+		qglVertex3f                  = 	dllVertex3f                  ;
+		qglVertex3fv                 = 	dllVertex3fv                 ;
+		qglVertex3i                  = 	dllVertex3i                  ;
+		qglVertex3iv                 = 	dllVertex3iv                 ;
+		qglVertex3s                  = 	dllVertex3s                  ;
+		qglVertex3sv                 = 	dllVertex3sv                 ;
+		qglVertex4d                  = 	dllVertex4d                  ;
+		qglVertex4dv                 = 	dllVertex4dv                 ;
+		qglVertex4f                  = 	dllVertex4f                  ;
+		qglVertex4fv                 = 	dllVertex4fv                 ;
+		qglVertex4i                  = 	dllVertex4i                  ;
+		qglVertex4iv                 = 	dllVertex4iv                 ;
+		qglVertex4s                  = 	dllVertex4s                  ;
+		qglVertex4sv                 = 	dllVertex4sv                 ;
+		qglVertexPointer             = 	dllVertexPointer             ;
+		qglViewport                  = 	dllViewport                  ;
+	}
+}
+
+
+void GLimp_LogNewFrame( void )
+{
+	fprintf( glw_state.log_fp, "*** R_BeginFrame ***\n" );
+}
+
+
diff --git a/codemp/unix/linux_snd.c b/codemp/unix/linux_snd.c
new file mode 100644
index 0000000..793c5f1
--- /dev/null
+++ b/codemp/unix/linux_snd.c
@@ -0,0 +1,237 @@
+#include <unistd.h>
+#include <fcntl.h>
+#include <stdlib.h>
+#include <sys/types.h>
+#include <sys/ioctl.h>
+#include <sys/mman.h>
+#include <sys/shm.h>
+#include <sys/wait.h>
+#ifdef __linux__ // rb0101023 - guard this
+#include <linux/soundcard.h>
+#endif
+#ifdef __FreeBSD__ // rb0101023 - added
+#include <sys/soundcard.h>
+#endif
+#include <stdio.h>
+
+#include "../client/snd_local.h"
+
+int audio_fd;
+int snd_inited=0;
+
+cvar_t *sndbits;
+cvar_t *sndspeed;
+cvar_t *sndchannels;
+
+cvar_t *snddevice;
+
+/* Some devices may work only with 48000 */
+static int tryrates[] = { 22050, 11025, 44100, 48000, 8000 };
+
+qboolean SNDDMA_Init(void)
+{
+	int rc;
+    int fmt;
+	int tmp;
+    int i;
+    // char *s; // bk001204 - unused
+	struct audio_buf_info info;
+	int caps;
+	extern uid_t saved_euid;
+
+	if (snd_inited)
+		return 1;
+
+	if (!snddevice) {
+		sndbits = Cvar_Get("sndbits", "16", CVAR_ARCHIVE);
+		sndspeed = Cvar_Get("sndspeed", "0", CVAR_ARCHIVE);
+		sndchannels = Cvar_Get("sndchannels", "2", CVAR_ARCHIVE);
+		snddevice = Cvar_Get("snddevice", "/dev/dsp", CVAR_ARCHIVE);
+	}
+
+	// open /dev/dsp, confirm capability to mmap, and get size of dma buffer
+	if (!audio_fd) {
+		seteuid(saved_euid);
+
+		audio_fd = open(snddevice->string, O_RDWR);
+
+		seteuid(getuid());
+
+		if (audio_fd < 0) {
+			perror(snddevice->string);
+			Com_Printf("Could not open %s\n", snddevice->string);
+			return 0;
+			}
+	}
+
+	if (ioctl(audio_fd, SNDCTL_DSP_GETCAPS, &caps) == -1) {
+		perror(snddevice->string);
+        Com_Printf("Sound driver too old\n");
+		close(audio_fd);
+		return 0;
+	}
+
+	if (!(caps & DSP_CAP_TRIGGER) || !(caps & DSP_CAP_MMAP)) {
+		Com_Printf("Sorry but your soundcard can't do this\n");
+		close(audio_fd);
+		return 0;
+	}
+
+
+	/* SNDCTL_DSP_GETOSPACE moved to be called later */
+    
+	// set sample bits & speed
+    dma.samplebits = (int)sndbits->value;
+	if (dma.samplebits != 16 && dma.samplebits != 8) {
+        ioctl(audio_fd, SNDCTL_DSP_GETFMTS, &fmt);
+        if (fmt & AFMT_S16_LE) 
+			dma.samplebits = 16;
+        else if (fmt & AFMT_U8) 
+			dma.samplebits = 8;
+    }
+
+	dma.speed = (int)sndspeed->value;
+	if (!dma.speed) {
+        for (i=0 ; i<sizeof(tryrates)/4 ; i++)
+            if (!ioctl(audio_fd, SNDCTL_DSP_SPEED, &tryrates[i])) 
+				break;
+        dma.speed = tryrates[i];
+    }
+
+	dma.channels = (int)sndchannels->value;
+	if (dma.channels < 1 || dma.channels > 2)
+		dma.channels = 2;
+        
+/*  mmap() call moved forward */
+
+	tmp = 0;
+	if (dma.channels == 2)
+		tmp = 1;
+    rc = ioctl(audio_fd, SNDCTL_DSP_STEREO, &tmp);
+    if (rc < 0) {
+		perror(snddevice->string);
+        Com_Printf("Could not set %s to stereo=%d", snddevice->string, dma.channels);
+		close(audio_fd);
+        return 0;
+    }
+
+	if (tmp)
+		dma.channels = 2;
+	else
+		dma.channels = 1;
+
+    rc = ioctl(audio_fd, SNDCTL_DSP_SPEED, &dma.speed);
+    if (rc < 0) {
+		perror(snddevice->string);
+        Com_Printf("Could not set %s speed to %d", snddevice->string, dma.speed);
+		close(audio_fd);
+        return 0;
+    }
+
+    if (dma.samplebits == 16) {
+        rc = AFMT_S16_LE;
+        rc = ioctl(audio_fd, SNDCTL_DSP_SETFMT, &rc);
+        if (rc < 0) {
+			perror(snddevice->string);
+			Com_Printf("Could not support 16-bit data.  Try 8-bit.\n");
+			close(audio_fd);
+			return 0;
+		}
+    } else if (dma.samplebits == 8) {
+        rc = AFMT_U8;
+        rc = ioctl(audio_fd, SNDCTL_DSP_SETFMT, &rc);
+        if (rc < 0) {
+			perror(snddevice->string);
+			Com_Printf("Could not support 8-bit data.\n");
+			close(audio_fd);
+			return 0;
+		}
+    } else {
+		perror(snddevice->string);
+		Com_Printf("%d-bit sound not supported.", dma.samplebits);
+		close(audio_fd);
+		return 0;
+	}
+
+    if (ioctl(audio_fd, SNDCTL_DSP_GETOSPACE, &info)==-1) {   
+        perror("GETOSPACE");
+		Com_Printf("Um, can't do GETOSPACE?\n");
+		close(audio_fd);
+		return 0;
+    }
+
+	dma.samples = info.fragstotal * info.fragsize / (dma.samplebits/8);
+	dma.submission_chunk = 1;
+
+	// memory map the dma buffer
+
+	if (!dma.buffer)
+		dma.buffer = (unsigned char *) mmap(NULL, info.fragstotal
+			* info.fragsize, PROT_WRITE, MAP_FILE|MAP_SHARED, audio_fd, 0);
+
+	if (!dma.buffer) {
+		perror(snddevice->string);
+		Com_Printf("Could not mmap %s\n", snddevice->string);
+		close(audio_fd);
+		return 0;
+	}
+
+	// toggle the trigger & start her up
+
+    tmp = 0;
+    rc  = ioctl(audio_fd, SNDCTL_DSP_SETTRIGGER, &tmp);
+	if (rc < 0) {
+		perror(snddevice->string);
+		Com_Printf("Could not toggle.\n");
+		close(audio_fd);
+		return 0;
+	}
+
+    tmp = PCM_ENABLE_OUTPUT;
+    rc = ioctl(audio_fd, SNDCTL_DSP_SETTRIGGER, &tmp);
+	if (rc < 0) {
+		perror(snddevice->string);
+		Com_Printf("Could not toggle.\n");
+		close(audio_fd);
+
+		return 0;
+	}
+
+	snd_inited = 1;
+	return 1;
+}
+
+int SNDDMA_GetDMAPos(void)
+{
+	struct count_info count;
+
+	if (!snd_inited) return 0;
+
+	if (ioctl(audio_fd, SNDCTL_DSP_GETOPTR, &count) == -1) {
+		perror(snddevice->string);
+		Com_Printf("Uh, sound dead.\n");
+		close(audio_fd);
+		snd_inited = 0;
+		return 0;
+	}
+	return count.ptr / (dma.samplebits / 8);
+}
+
+void SNDDMA_Shutdown(void)
+{
+}
+
+/*
+==============
+SNDDMA_Submit
+
+Send sound to device if buffer isn't really the dma buffer
+===============
+*/
+void SNDDMA_Submit(void)
+{
+}
+
+void SNDDMA_BeginPainting (void)
+{
+}
diff --git a/codemp/unix/makefile b/codemp/unix/makefile
new file mode 100644
index 0000000..4b12a1a
--- /dev/null
+++ b/codemp/unix/makefile
@@ -0,0 +1,1505 @@
+#
+# GNU Make required
+#
+
+PLATFORM=$(shell uname|tr A-Z a-z)
+PLATFORM_RELEASE=$(shell uname -r)
+
+###
+### These paths are where you probably want to change things
+###
+
+# Where we are building from (where the source code should be!)
+MOUNT_DIR=../
+
+
+# Where we are building to, libMesaVoodooGL.so.3.3 should be here, etc.
+# the demo pk3 file should be here in demoq3/pak0.pk3 or baseq3/pak0.pk3
+BDIR=$(MOUNT_DIR)/../run
+
+
+# Build name
+# BUILD_NAME=$(BUILD_NAME)
+BUILD_NAME=jamp
+
+
+
+#############################################################################
+##
+## You shouldn't have to touch anything below here
+##
+#############################################################################
+
+BASEQ3_DIR=$(BDIR)/base
+
+BD=debug$(ARCH)$(GLIBC)
+BR=release$(ARCH)$(GLIBC)
+CDIR=$(MOUNT_DIR)/client
+SDIR=$(MOUNT_DIR)/server
+RDIR=$(MOUNT_DIR)/renderer
+CMDIR=$(MOUNT_DIR)/qcommon
+UDIR=$(MOUNT_DIR)/unix
+GDIR=$(MOUNT_DIR)/game
+CGDIR=$(MOUNT_DIR)/cgame
+BAIDIR=$(GDIR)
+BLIBDIR=$(MOUNT_DIR)/botlib
+NDIR=$(MOUNT_DIR)/null
+UIDIR=$(MOUNT_DIR)/ui
+Q3UIDIR=$(MOUNT_DIR)/q3_ui
+FTDIR=$(MOUNT_DIR)/ft2
+JPDIR=$(MOUNT_DIR)/jpeg-6
+SPLNDIR=$(MOUNT_DIR)/splines
+GHOUL2DIR=$(MOUNT_DIR)/ghoul2
+IDIR=$(MOUNT_DIR)/icarus
+ZLIB=$(MOUNT_DIR)/zlib32
+RMGDIR=$(MOUNT_DIR)/RMG
+
+#############################################################################
+# SETUP AND BUILD -- LINUX
+#############################################################################
+
+## Defaults
+DLL_ONLY=false
+
+  ifneq (,$(findstring libc6,$(shell if [ -e /lib/libc.so.6* ];then echo libc6;fi)))
+    GLIBC=-glibc
+  else
+    GLIBC=
+  endif #libc6 test
+
+  MESADIR=../Mesa/
+  ARCH=i386
+  RPMARCH=i386
+  VENDOR=unknown
+  DLL_ONLY=false
+
+  # bk001205: no mo'  -I/usr/include/glide, no FX
+  # bk001205: no mo'  -Dstricmp=strcasecmp, see q_shared.h
+  #BASE_CFLAGS =  -pipe -fsigned-char -x c++ -D_JK2 -D_M_IX86  -I/home/drews/STLport-4.5.3/stlport -I/opt/intel/compiler50/ia32/include
+  #BASE_CFLAGS =  -pipe -fsigned-char -Kc++ -D_JK2 -D_M_IX86  -I/opt/intel/compiler50/ia32/include 
+  BASE_CFLAGS =  -Kc++ -D_JK2 -D_M_IX86  -w -I/opt/intel/compiler50/ia32/include 
+  # rcg010216: DLL_ONLY for PPC
+  ifeq ($(strip $(DLL_ONLY)),true)
+    BASE_CFLAGS += -DDLL_ONLY
+  endif
+
+
+  #GL_CFLAGS = -I$(MESADIR)/include -I/usr/X11R6/include
+  GL_CFAGS = -I/usr/X11R6/include 
+
+  # bk001204 - need -O for -Wall for uninitialized
+  # bk001205 - took out -O to get assertions (NDEBUG)
+  # bk001206 - MALLOC_CHECK in addition to ZONE_DEBUG
+  # TTimo 03/30/2001 temporary took out -Werror for initial merge
+  DEBUG_CFLAGS=$(BASE_CFLAGS) -g  
+#  DEBUG_CFLAGS=$(BASE_CFLAGS) -g  -Wall -Werror -O
+  ifeq ($(ARCH),axp)
+    CC=pgcc
+    RELEASE_CFLAGS=$(BASE_CFLAGS) -DNDEBUG -O2 -unroll
+  else
+    ifeq ($(ARCH),ppc)
+      NEWPGCC=/loki/global/ppc/bin/gcc
+      CC=$(NEWPGCC)
+      RELEASE_CFLAGS=$(BASE_CFLAGS) -DNDEBUG -O2 -pipe -unroll 
+    else
+      #NEWPGCC=/usr/local/gcc-2.95.2/bin/gcc # bk001205
+      #NEWPGCC=/loki/global/x86/bin/gcc
+      #NEWPGCC=/usr/bin/gcc 
+      #NEWPGCC=/usr/local/bin/gcc
+      NEWPGCC=/opt/intel/compiler50/ia32/bin/icc
+      CC=$(shell if [ -f $(NEWPGCC) ]; then echo $(NEWPGCC); else echo pgcc; fi )
+      CXX=/usr/bin/g++
+# TTimo: legacy RELEASE_CFLAGS
+# NOTE: the -fomit-frame-pointer option leads to an unstable binary on my test box if it was built on the main box
+#   but building on the Mdk 7.2 baseline seems to work
+      RELEASE_CFLAGS=$(BASE_CFLAGS) -DNDEBUG -O2 -unroll -tpp6
+# TTimo: use this for building on P3 gcc 2.95.3 libc2.2 for all targets (experimental! -fomit-fram-pointer removed)
+#      RELEASE_CFLAGS=$(BASE_CFLAGS) -DNDEBUG -O6 -mcpu=pentiumpro -march=pentium -pipe -ffast-math -malign-loops=2 -malign-jumps=2 -malign-functions=2 -fno-strict-aliasing -fstrength-reduce
+    endif
+  endif
+
+  LIBEXT=a
+
+  SHLIBEXT=so
+  SHLIBCFLAGS=-fPIC
+  SHLIBLDFLAGS=-shared $(LDFLAGS)
+
+  ARFLAGS=ar rv
+  RANLIB=ranlib
+
+  THREAD_LDFLAGS=-lpthread
+  #LDFLAGS=/opt/sxl/lib/sxlgcc3.a -lpthread -ldl -lm -lstdc++ -static -Wl --gc-sections
+  LDFLAGS=-ldl -lm  
+  GLLDFLAGS=-L/usr/X11R6/lib -L$(MESADIR)/lib -lX11 -lXext -lXxf86dga -lXxf86vm
+
+  TARGETS=\
+	  $(B)/$(PLATFORM)jampded \
+	  $(B)/$(BUILD_NAME)game$(ARCH)-debug.so
+
+DO_CC=$(CC) $(CFLAGS) -o $@ -c $<
+DO_CXX=$(CXX) $(CFLAGS) -o $@ -c $<
+DO_SMP_CC=$(CC) $(CFLAGS) -DSMP -o $@ -c $<
+DO_BOT_CC=$(CC) $(CFLAGS) -DBOTLIB  -o $@ -c $<   # $(SHLIBCFLAGS) # bk001212
+DO_DEBUG_CC=$(CC) $(DEBUG_CFLAGS) -o $@ -c $<
+DO_SHLIB_CC=$(CC) $(CFLAGS) $(SHLIBCFLAGS) -o $@ -c $<
+DO_SHLIB_DEBUG_CC=$(CC) $(DEBUG_CFLAGS) $(SHLIBCFLAGS) -o $@ -c $<
+DO_AS=$(CC) $(CFLAGS) -DELF -x assembler-with-cpp -o $@ -c $<
+DO_NASM=nasm -f elf -o $@  $<
+DO_DED_CC=$(CC) -DDEDICATED -DC_ONLY $(CFLAGS) -use_msasm -o $@ -c $<
+DO_DED_CC2=$(CC) -DDEDICATED -DC_ONLY $(CFLAGS) -o $@ -c $<
+DO_DED_CPP=$(CXX) -DDEDICATED -DC_ONLY $(CFLAGS) -o $@ -c $<
+
+#DO_LCC=$(LCC) -o $@ -S -Wf-target=bytecode -Wf-g -DQ3_VM -I$(CGDIR) -I$(GDIR)  -I$(UIDIR)  $< 
+
+#### DEFAULT TARGET
+default:build_debug
+
+debug: build_debug
+release: build_release
+
+build_debug:
+	$(MAKE)  targets  B=$(BD) CFLAGS="$(DEBUG_CFLAGS)"
+
+build_release:
+	$(MAKE)  targets  B=$(BR) CFLAGS="$(RELEASE_CFLAGS)"
+
+#Build both debug and release builds
+all:build_debug build_release
+
+targets:makedirs $(TARGETS)
+
+
+makedirs:
+	@if [ ! -d $(B) ];then mkdir $(B);fi
+#	@if [ ! -d $(B)/client ];then mkdir $(B)/client;fi
+	@if [ ! -d $(B)/ded ];then mkdir $(B)/ded;fi
+#	@if [ ! -d $(B)/ref ];then mkdir $(B)/ref;fi
+#	@if [ ! -d $(B)/ft2 ];then mkdir $(B)/ft2;fi
+	@if [ ! -d $(B)/baseq3 ];then mkdir $(B)/baseq3;fi
+#	@if [ ! -d $(B)/baseq3/cgame ];then mkdir $(B)/baseq3/cgame;fi
+	@if [ ! -d $(B)/baseq3/game ];then mkdir $(B)/baseq3/game;fi
+#	@if [ ! -d $(B)/baseq3/ui ];then mkdir $(B)/baseq3/ui;fi
+#	@if [ ! -d $(B)/baseq3/vm ];then mkdir $(B)/baseq3/vm;fi
+#	@if [ ! -d $(B)/missionpack ];then mkdir $(B)/missionpack;fi
+#	@if [ ! -d $(B)/missionpack/cgame ];then mkdir $(B)/missionpack/cgame;fi
+#	@if [ ! -d $(B)/missionpack/game ];then mkdir $(B)/missionpack/game;fi
+#	@if [ ! -d $(B)/missionpack/ui ];then mkdir $(B)/missionpack/ui;fi
+#	@if [ ! -d $(B)/missionpack/vm ];then mkdir $(B)/missionpack/vm;fi
+#	@if [ ! -d $(B)/q3static ];then mkdir $(B)/q3static;fi
+
+
+#############################################################################
+# DEDICATED SERVER                        
+#############################################################################
+
+Q3DOBJ = \
+	$(B)/ded/sv_bot.o \
+	$(B)/ded/sv_client.o \
+	$(B)/ded/sv_ccmds.o \
+	$(B)/ded/sv_game.o \
+	$(B)/ded/sv_init.o \
+	$(B)/ded/sv_main.o \
+	$(B)/ded/sv_net_chan.o \
+	$(B)/ded/sv_snapshot.o \
+	$(B)/ded/sv_world.o \
+	\
+	$(B)/ded/cm_load.o \
+	$(B)/ded/stringed_ingame.o \
+	$(B)/ded/stringed_interface.o \
+	$(B)/ded/GenericParser2.o \
+	$(B)/ded/cm_patch.o \
+	$(B)/ded/cm_polylib.o \
+	$(B)/ded/cm_test.o \
+	$(B)/ded/cm_trace.o \
+	$(B)/ded/common.o \
+	$(B)/ded/cvar.o \
+	$(B)/ded/md4.o \
+	$(B)/ded/msg.o \
+	$(B)/ded/net_chan.o \
+	$(B)/ded/huffman.o \
+	\
+	$(B)/ded/q_math.o \
+	$(B)/ded/q_shared.o \
+	$(B)/ded/z_memman_pc.o \
+	\
+	$(B)/ded/inflate.o \
+	$(B)/ded/deflate.o \
+	$(B)/ded/zipcommon.o \
+	\
+	$(B)/ded/unzip.o \
+	$(B)/ded/vm.o \
+	$(B)/ded/vm_interpreted.o \
+	\
+	$(B)/ded/be_aas_bspq3.o \
+	$(B)/ded/be_aas_cluster.o \
+	$(B)/ded/be_aas_debug.o \
+	$(B)/ded/be_aas_entity.o \
+	$(B)/ded/be_aas_file.o \
+	$(B)/ded/be_aas_main.o \
+	$(B)/ded/be_aas_move.o \
+	$(B)/ded/be_aas_optimize.o \
+	$(B)/ded/be_aas_reach.o \
+	$(B)/ded/be_aas_route.o \
+	$(B)/ded/be_aas_routealt.o \
+	$(B)/ded/be_aas_sample.o \
+	$(B)/ded/be_ai_char.o \
+	$(B)/ded/be_ai_chat.o \
+	$(B)/ded/be_ai_gen.o \
+	$(B)/ded/be_ai_goal.o \
+	$(B)/ded/be_ai_move.o \
+	$(B)/ded/be_ai_weap.o \
+	$(B)/ded/be_ai_weight.o \
+	$(B)/ded/be_ea.o \
+	$(B)/ded/be_interface.o \
+	$(B)/ded/l_crc.o \
+	$(B)/ded/l_libvar.o \
+	$(B)/ded/l_log.o \
+	$(B)/ded/l_memory.o \
+	$(B)/ded/l_precomp.o \
+	$(B)/ded/l_script.o \
+	$(B)/ded/l_struct.o \
+	\
+	$(B)/ded/linux_common.o \
+	$(B)/ded/unix_main.o \
+	$(B)/ded/unix_net.o \
+	$(B)/ded/unix_shared.o \
+	\
+	$(B)/ded/G2_API.o \
+	$(B)/ded/G2_bolts.o \
+	$(B)/ded/G2_surfaces.o \
+	$(B)/ded/G2_misc.o \
+	\
+	$(B)/ded/null_client.o \
+	$(B)/ded/null_input.o \
+	$(B)/ded/null_snddma.o \
+	$(B)/ded/null_glimp.o \
+	$(B)/ded/null_renderer.o \
+	\
+	$(B)/ded/BlockStream.o \
+	$(B)/ded/GameInterface.o \
+	$(B)/ded/Instance.o \
+	$(B)/ded/Interface.o \
+	$(B)/ded/Memory.o \
+	$(B)/ded/Q3_Interface.o \
+	$(B)/ded/Q3_Registers.o \
+	$(B)/ded/Sequence.o \
+	$(B)/ded/Sequencer.o \
+	$(B)/ded/TaskManager.o \
+	\
+	$(B)/ded/tr_model.o \
+	$(B)/ded/tr_image.o \
+	$(B)/ded/RoffSystem.o \
+	$(B)/ded/tr_ghoul2.o \
+	$(B)/ded/matcomp.o \
+	$(B)/ded/tr_init.o \
+	$(B)/ded/tr_main.o \
+	$(B)/ded/tr_backend.o \
+	$(B)/ded/tr_mesh.o \
+	$(B)/ded/G2_bones.o \
+	$(B)/ded/tr_shader.o \
+	$(B)/ded/cmd_pc.o \
+	$(B)/ded/navigator.o \
+	$(B)/ded/gameCallbacks.o \
+	$(B)/ded/files_common.o \
+	$(B)/ded/cmd_common.o \
+	$(B)/ded/files_linux.o \
+	$(B)/ded/RM_Manager.o \
+	$(B)/ded/RM_Mission.o \
+	$(B)/ded/RM_Instance.o \
+	$(B)/ded/RM_InstanceFile.o \
+	$(B)/ded/RM_Instance_BSP.o \
+	$(B)/ded/RM_Instance_Group.o \
+	$(B)/ded/RM_Instance_Void.o \
+	$(B)/ded/RM_Instance_Random.o \
+	$(B)/ded/RM_Objective.o \
+	$(B)/ded/RM_Terrain.o \
+	$(B)/ded/RM_Path.o \
+	$(B)/ded/RM_Area.o \
+	$(B)/ded/cm_terrain.o \
+	$(B)/ded/cm_randomterrain.o \
+	$(B)/ded/cm_shader.o \
+#	$(B)/ded/tr_terrain.o \
+#	\
+#	$(B)/ded/null_main.o \
+#	$(B)/ded/null_net.o \
+#	$(B)/ded/tr_cmds.o \
+#	$(B)/ded/tr_animation.o \
+#	$(B)/ded/tr_bsp.o \
+#	$(B)/ded/tr_curve.o \
+#	$(B)/ded/tr_flares.o \
+#	$(B)/ded/tr_font.o \
+#	$(B)/ded/tr_light.o \
+#	$(B)/ded/tr_marks.o \
+#	$(B)/ded/tr_noise.o \
+#	$(B)/ded/tr_quicksprite.o \
+#	$(B)/ded/tr_scene.o \
+#	$(B)/ded/tr_shade_calc.o \
+#	$(B)/ded/tr_shade.o \
+#	$(B)/ded/tr_shadows.o \
+#	$(B)/ded/tr_surfacesprites.o \
+#	$(B)/ded/tr_world.o \
+#	$(B)/ded/tr_worldeffects.o \
+#	\
+#	$(B)/ded/linux_glimp.o \
+#	$(B)/ded/tr_image.o 
+#	$(B)/ded/linux_qgl.o 
+#	$(B)/ded/snapvector.o \
+#	$(B)/ded/tr_main.o
+#	$(B)/ded/tr_sky.o
+
+#ifeq ($(ARCH),i386)
+  Q3DOBJ += $(B)/ded/vm_x86.o $(B)/ded/ftol.o $(B)/ded/snapvector.o
+#endif
+
+ifeq ($(ARCH),ppc)
+  ifeq ($(DLL_ONLY),false)
+    Q3DOBJ += $(B)/ded/vm_ppc.o
+  endif
+endif
+
+$(B)/$(PLATFORM)jampded : $(Q3DOBJ)
+	$(CC)  -o $@ $(Q3DOBJ) $(LDFLAGS)
+
+$(B)/$(BUILD_NAME)game$(ARCH)-debug.so : $(Q3GOBJ)
+	$(CC)  -o $@ $(Q3GOBJ) $(LDFLAGS) -shared
+
+$(B)/ded/sv_bot.o : $(SDIR)/sv_bot.cpp; $(DO_DED_CC) 
+$(B)/ded/sv_client.o : $(SDIR)/sv_client.cpp; $(DO_DED_CC) 
+$(B)/ded/sv_ccmds.o : $(SDIR)/sv_ccmds.cpp; $(DO_DED_CC) 
+$(B)/ded/sv_game.o : $(SDIR)/sv_game.cpp; $(DO_DED_CC) 
+$(B)/ded/sv_init.o : $(SDIR)/sv_init.cpp; $(DO_DED_CC) 
+$(B)/ded/sv_main.o : $(SDIR)/sv_main.cpp; $(DO_DED_CC) 
+$(B)/ded/sv_net_chan.o : $(SDIR)/sv_net_chan.cpp; $(DO_DED_CC) 
+$(B)/ded/sv_snapshot.o : $(SDIR)/sv_snapshot.cpp; $(DO_DED_CC) 
+$(B)/ded/sv_world.o : $(SDIR)/sv_world.cpp; $(DO_DED_CC) 
+$(B)/ded/gameCallbacks.o : $(SDIR)/NPCNav/gameCallbacks.cpp; $(DO_DED_CC)
+$(B)/ded/navigator.o: $(SDIR)/NPCNav/navigator.cpp; $(DO_DED_CC)
+
+$(B)/ded/cm_load.o : $(CMDIR)/cm_load.cpp; $(DO_DED_CC) 
+$(B)/ded/stringed_ingame.o : $(CMDIR)/stringed_ingame.cpp; $(DO_DED_CC)
+$(B)/ded/stringed_interface.o : $(CMDIR)/stringed_interface.cpp; $(DO_DED_CC)
+$(B)/ded/GenericParser2.o : $(CMDIR)/GenericParser2.cpp; $(DO_DED_CC)
+$(B)/ded/cm_shader.o : $(CMDIR)/cm_shader.cpp; $(DO_DED_CC)
+$(B)/ded/cm_polylib.o : $(CMDIR)/cm_polylib.cpp; $(DO_DED_CC) 
+$(B)/ded/cm_test.o : $(CMDIR)/cm_test.cpp; $(DO_DED_CC) 
+$(B)/ded/cm_trace.o : $(CMDIR)/cm_trace.cpp; $(DO_DED_CC) 
+$(B)/ded/cm_patch.o : $(CMDIR)/cm_patch.cpp; $(DO_DED_CC) 
+$(B)/ded/common.o : $(CMDIR)/common.cpp; $(DO_DED_CC) 
+$(B)/ded/cvar.o : $(CMDIR)/cvar.cpp; $(DO_DED_CC) 
+$(B)/ded/files.o : $(CMDIR)/files.cpp; $(DO_DED_CC) 
+$(B)/ded/md4.o : $(CMDIR)/md4.cpp; $(DO_DED_CC) 
+$(B)/ded/msg.o : $(CMDIR)/msg.cpp; $(DO_DED_CC) 
+$(B)/ded/net_chan.o : $(CMDIR)/net_chan.cpp; $(DO_DED_CC)
+$(B)/ded/huffman.o : $(CMDIR)/huffman.cpp; $(DO_DED_CC)
+$(B)/ded/q_shared.o : $(CMDIR)/q_shared.cpp; $(DO_DED_CC) 
+$(B)/ded/q_math.o : $(GDIR)/q_math.c; $(DO_DED_CC) 
+$(B)/ded/z_memman_pc.o : $(CMDIR)/z_memman_pc.cpp; $(DO_DED_CC)
+$(B)/ded/files_common.o : $(CMDIR)/files_common.cpp; $(DO_DED_CC)
+$(B)/ded/cmd_common.o : $(CMDIR)/cmd_common.cpp; $(DO_DED_CC)
+$(B)/ded/files_linux.o : $(UDIR)/files_linux.cpp; $(DO_DED_CC)
+
+$(B)/ded/RM_Manager.o : $(RMGDIR)/RM_Manager.cpp; $(DO_DED_CC)
+$(B)/ded/RM_Mission.o : $(RMGDIR)/RM_Mission.cpp; $(DO_DED_CC)
+$(B)/ded/RM_Instance.o: $(RMGDIR)/RM_Instance.cpp; $(DO_DED_CC)
+$(B)/ded/RM_InstanceFile.o : $(RMGDIR)/RM_InstanceFile.cpp; $(DO_DED_CC)
+$(B)/ded/RM_Instance_Void.o : $(RMGDIR)/RM_Instance_Void.cpp; $(DO_DED_CC)
+$(B)/ded/RM_Instance_Random.o : $(RMGDIR)/RM_Instance_Random.cpp; $(DO_DED_CC)
+$(B)/ded/RM_Instance_Group.o : $(RMGDIR)/RM_Instance_Group.cpp; $(DO_DED_CC)
+$(B)/ded/RM_Instance_BSP.o : $(RMGDIR)/RM_Instance_BSP.cpp; $(DO_DED_CC)
+$(B)/ded/RM_Objective.o : $(RMGDIR)/RM_Objective.cpp; $(DO_DED_CC)
+$(B)/ded/RM_Path.o : $(RMGDIR)/RM_Path.cpp; $(DO_DED_CC)
+$(B)/ded/RM_Area.o : $(RMGDIR)/RM_Area.cpp; $(DO_DED_CC)
+$(B)/ded/RM_Terrain.o : $(RMGDIR)/RM_Terrain.cpp; $(DO_DED_CC)
+$(B)/ded/tr_terrain.o : $(RDIR)/tr_terrain.cpp; $(DO_DED_CC)
+$(B)/ded/cm_terrain.o : $(CMDIR)/cm_terrain.cpp; $(DO_DED_CC)
+$(B)/ded/cm_randomterrain.o : $(CMDIR)/cm_randomterrain.cpp; $(DO_DED_CC)
+
+$(B)/ded/G2_API.o : $(GHOUL2DIR)/G2_API.cpp; $(DO_DED_CC)
+$(B)/ded/G2_bolts.o : $(GHOUL2DIR)/G2_bolts.cpp; $(DO_DED_CC)
+$(B)/ded/G2_bones.o : $(GHOUL2DIR)/G2_bones.cpp; $(DO_DED_CC)
+$(B)/ded/G2_misc.o : $(GHOUL2DIR)/G2_misc.cpp; $(DO_DED_CC)
+$(B)/ded/G2_surfaces.o : $(GHOUL2DIR)/G2_surfaces.cpp; $(DO_DED_CC)
+
+$(B)/ded/RoffSystem.o : $(CMDIR)/RoffSystem.cpp; $(DO_DED_CC)
+
+$(B)/ded/inflate.o : $(ZLIB)/inflate.cpp; $(DO_DED_CC)
+$(B)/ded/deflate.o : $(ZLIB)/deflate.cpp; $(DO_DED_CC)
+$(B)/ded/zipcommon.o : $(ZLIB)/zipcommon.cpp; $(DO_DED_CC)
+
+$(B)/ded/tr_model.o : $(RDIR)/tr_model.cpp; $(DO_DED_CC)
+$(B)/ded/tr_image.o : $(RDIR)/tr_image.cpp; $(DO_DED_CC)
+$(B)/ded/tr_ghoul2.o : $(RDIR)/tr_ghoul2.cpp; $(DO_DED_CC)
+$(B)/ded/tr_shader.o : $(RDIR)/tr_shader.cpp; $(DO_DED_CC)
+$(B)/ded/tr_sky.o : $(RDIR)/tr_shader.cpp; $(DO_DED_CC)
+$(B)/ded/tr_cmds.o : $(RDIR)/tr_cmds.cpp; $(DO_DED_CC)
+$(B)/ded/tr_backend.o : $(RDIR)/tr_backend.cpp; $(DO_DED_CC)
+$(B)/ded/tr_animation.o : $(RDIR)/tr_animation.cpp; $(DO_DED_CC)
+$(B)/ded/tr_bsp.o : $(RDIR)/tr_bsp.cpp; $(DO_DED_CC)
+$(B)/ded/tr_curve.o : $(RDIR)/tr_curve.cpp; $(DO_DED_CC)
+$(B)/ded/tr_flares.o : $(RDIR)/tr_flares.cpp; $(DO_DED_CC)
+$(B)/ded/tr_font.o : $(RDIR)/tr_font.cpp; $(DO_DED_CC)
+$(B)/ded/tr_init.o : $(RDIR)/tr_init.cpp; $(DO_DED_CC)
+$(B)/ded/tr_light.o : $(RDIR)/tr_light.cpp; $(DO_DED_CC)
+$(B)/ded/tr_main.o : $(RDIR)/tr_main.cpp; $(DO_DED_CC)
+$(B)/ded/tr_marks.o : $(RDIR)/tr_marks.cpp; $(DO_DED_CC)
+$(B)/ded/tr_mesh.o : $(RDIR)/tr_mesh.cpp; $(DO_DED_CC)
+$(B)/ded/tr_noise.o : $(RDIR)/tr_noise.cpp; $(DO_DED_CC)
+$(B)/ded/tr_quicksprite.o : $(RDIR)/tr_quicksprite.cpp; $(DO_DED_CC)
+$(B)/ded/tr_scene.o : $(RDIR)/tr_scene.cpp; $(DO_DED_CC)
+$(B)/ded/tr_shade.o : $(RDIR)/tr_shade.cpp; $(DO_DED_CC)
+$(B)/ded/tr_shade_calc.o : $(RDIR)/tr_shade_calc.cpp; $(DO_DED_CC)
+$(B)/ded/tr_shadows.o : $(RDIR)/tr_shadows.cpp; $(DO_DED_CC)
+$(B)/ded/tr_surface.o : $(RDIR)/tr_surface.cpp; $(DO_DED_CC)
+$(B)/ded/tr_surfacesprites.o : $(RDIR)/tr_surfacesprites.cpp; $(DO_DED_CC)
+$(B)/ded/tr_world.o : $(RDIR)/tr_world.cpp; $(DO_DED_CC)
+$(B)/ded/tr_worldeffects.o : $(RDIR)/tr_worldeffects.cpp; $(DO_DED_CC)
+$(B)/ded/matcomp.o : $(RDIR)/matcomp.c; $(DO_DED_CC)
+
+
+$(B)/ded/be_aas_bspq3.o : $(BLIBDIR)/be_aas_bspq3.cpp; $(DO_BOT_CC) 
+$(B)/ded/be_aas_cluster.o : $(BLIBDIR)/be_aas_cluster.cpp; $(DO_BOT_CC) 
+$(B)/ded/be_aas_debug.o : $(BLIBDIR)/be_aas_debug.cpp; $(DO_BOT_CC) 
+$(B)/ded/be_aas_entity.o : $(BLIBDIR)/be_aas_entity.cpp; $(DO_BOT_CC) 
+$(B)/ded/be_aas_file.o : $(BLIBDIR)/be_aas_file.cpp; $(DO_BOT_CC) 
+$(B)/ded/be_aas_main.o : $(BLIBDIR)/be_aas_main.cpp; $(DO_BOT_CC) 
+$(B)/ded/be_aas_move.o : $(BLIBDIR)/be_aas_move.cpp; $(DO_BOT_CC) 
+$(B)/ded/be_aas_optimize.o : $(BLIBDIR)/be_aas_optimize.cpp; $(DO_BOT_CC) 
+$(B)/ded/be_aas_reach.o : $(BLIBDIR)/be_aas_reach.cpp; $(DO_BOT_CC) 
+$(B)/ded/be_aas_route.o : $(BLIBDIR)/be_aas_route.cpp; $(DO_BOT_CC) 
+$(B)/ded/be_aas_routealt.o : $(BLIBDIR)/be_aas_routealt.cpp; $(DO_BOT_CC) 
+$(B)/ded/be_aas_sample.o : $(BLIBDIR)/be_aas_sample.cpp; $(DO_BOT_CC) 
+$(B)/ded/be_ai_char.o : $(BLIBDIR)/be_ai_char.cpp; $(DO_BOT_CC) 
+$(B)/ded/be_ai_chat.o : $(BLIBDIR)/be_ai_chat.cpp; $(DO_BOT_CC) 
+$(B)/ded/be_ai_gen.o : $(BLIBDIR)/be_ai_gen.cpp; $(DO_BOT_CC) 
+$(B)/ded/be_ai_goal.o : $(BLIBDIR)/be_ai_goal.cpp; $(DO_BOT_CC) 
+$(B)/ded/be_ai_move.o : $(BLIBDIR)/be_ai_move.cpp; $(DO_BOT_CC) 
+$(B)/ded/be_ai_weap.o : $(BLIBDIR)/be_ai_weap.cpp; $(DO_BOT_CC) 
+$(B)/ded/be_ai_weight.o : $(BLIBDIR)/be_ai_weight.cpp; $(DO_BOT_CC) 
+$(B)/ded/be_ea.o : $(BLIBDIR)/be_ea.cpp; $(DO_BOT_CC) 
+$(B)/ded/be_interface.o : $(BLIBDIR)/be_interface.cpp; $(DO_BOT_CC) 
+$(B)/ded/l_crc.o : $(BLIBDIR)/l_crc.cpp; $(DO_BOT_CC) 
+$(B)/ded/l_libvar.o : $(BLIBDIR)/l_libvar.cpp; $(DO_BOT_CC) 
+$(B)/ded/l_log.o : $(BLIBDIR)/l_log.cpp; $(DO_BOT_CC) 
+$(B)/ded/l_memory.o : $(BLIBDIR)/l_memory.cpp; $(DO_BOT_CC) 
+$(B)/ded/l_precomp.o : $(BLIBDIR)/l_precomp.cpp; $(DO_BOT_CC) 
+$(B)/ded/l_script.o : $(BLIBDIR)/l_script.cpp; $(DO_BOT_CC) 
+$(B)/ded/l_struct.o : $(BLIBDIR)/l_struct.cpp; $(DO_BOT_CC) 
+
+$(B)/ded/linux_common.o : $(UDIR)/linux_common.c; $(DO_CC)
+$(B)/ded/linux_glimp.o : $(UDIR)/linux_glimp.c; $(DO_DED_CC)
+$(B)/ded/unix_main.o : $(UDIR)/unix_main.c; $(DO_DED_CC2) 
+$(B)/ded/unix_net.o : $(UDIR)/unix_net.c; $(DO_DED_CC) 
+$(B)/ded/unix_shared.o : $(UDIR)/unix_shared.cpp; $(DO_DED_CC) 
+$(B)/ded/linux_qgl.o : $(UDIR)/linux_qgl.c; $(DO_DED_CC)
+$(B)/ded/null_client.o : $(NDIR)/null_client.cpp; $(DO_DED_CC) 
+$(B)/ded/null_input.o : $(NDIR)/null_input.cpp; $(DO_DED_CC) 
+$(B)/ded/null_snddma.o : $(NDIR)/null_snddma.cpp; $(DO_DED_CC) 
+$(B)/ded/null_glimp.o : $(NDIR)/null_glimp.cpp; $(DO_DED_CC)
+$(B)/ded/null_main.o : $(NDIR)/null_main.cpp; $(DO_DED_CC)
+$(B)/ded/null_net.o : $(NDIR)/null_net.cpp; $(DO_DED_CC)
+$(B)/ded/null_renderer.o : $(NDIR)/null_renderer.cpp; $(DO_DED_CC)
+$(B)/ded/unzip.o : $(CMDIR)/unzip.cpp; $(DO_DED_CC) 
+$(B)/ded/vm.o : $(CMDIR)/vm.cpp; $(DO_DED_CC) 
+$(B)/ded/vm_interpreted.o : $(CMDIR)/vm_interpreted.cpp; $(DO_DED_CC) 
+$(B)/ded/cmd_pc.o : $(CMDIR)/cmd_pc.cpp; $(DO_DED_CC)
+
+$(B)/ded/BlockStream.o : $(IDIR)/BlockStream.cpp; $(DO_DED_CC)
+$(B)/ded/GameInterface.o : $(IDIR)/GameInterface.cpp; $(DO_DED_CC)
+$(B)/ded/Instance.o : $(IDIR)/Instance.cpp; $(DO_DED_CC)
+$(B)/ded/Interface.o : $(IDIR)/Interface.cpp; $(DO_DED_CC)
+$(B)/ded/Memory.o : $(IDIR)/Memory.cpp; $(DO_DED_CC)
+$(B)/ded/Q3_Interface.o : $(IDIR)/Q3_Interface.cpp; $(DO_DED_CC)
+$(B)/ded/Q3_Registers.o : $(IDIR)/Q3_Registers.cpp; $(DO_DED_CC)
+$(B)/ded/Sequence.o: $(IDIR)/Sequence.cpp; $(DO_DED_CC)
+$(B)/ded/Sequencer.o : $(IDIR)/Sequencer.cpp; $(DO_DED_CC)
+$(B)/ded/TaskManager.o: $(IDIR)/TaskManager.cpp; $(DO_DED_CC)
+
+#ifeq ($(ARCH),i386)
+$(B)/ded/vm_x86.o : $(CMDIR)/vm_x86.cpp; $(DO_DED_CC2) 
+$(B)/ded/ftol.o : $(UDIR)/ftol.nasm; $(DO_NASM)
+$(B)/ded/snapvector.o : $(UDIR)/snapvector.nasm; $(DO_NASM) 
+#endif
+
+ifeq ($(ARCH),ppc)
+ifeq ($(DLL_ONLY),false)
+$(B)/ded/vm_ppc.o : $(CMDIR)/vm_ppc.c; $(DO_DED_CC)
+endif
+endif
+
+
+#############################################################################
+## QVM
+#############################################################################
+
+$(B)/baseq3/vm/cgame.qvm:
+	cd $(CGDIR) && ./cgame.sh
+	mv /tmp/quake3/baseq3/vm/cgame.qvm $@
+
+$(B)/baseq3/vm/ui.qvm:
+	cd $(Q3UIDIR) && ./q3_ui.sh
+	mv /tmp/quake3/baseq3/vm/ui.qvm $@
+
+$(B)/baseq3/vm/qagame.qvm:
+	cd $(GDIR) && ./game.sh
+	mv /tmp/quake3/baseq3/vm/qagame.qvm $@
+
+$(B)/missionpack/vm/cgame.qvm:
+	cd $(CGDIR) && ./cgame_ta.sh
+	mv /tmp/quake3/missionpack/vm/cgame.qvm $@
+
+$(B)/missionpack/vm/qagame.qvm:
+	cd $(GDIR) && ./game_ta.sh
+	mv /tmp/quake3/missionpack/vm/qagame.qvm $@
+
+$(B)/missionpack/vm/ui.qvm:
+	cd $(UIDIR) && ./ui.sh
+	mv /tmp/quake3/missionpack/vm/ui.qvm $@
+
+
+
+#############################################################################
+## BASEQ3 CGAME
+#############################################################################
+
+Q3CGOBJ = \
+	$(B)/baseq3/cgame/bg_misc.o \
+	$(B)/baseq3/cgame/bg_pmove.o \
+	$(B)/baseq3/cgame/bg_slidemove.o \
+	$(B)/baseq3/cgame/cg_consolecmds.o \
+	$(B)/baseq3/cgame/cg_draw.o \
+	$(B)/baseq3/cgame/cg_drawtools.o \
+	$(B)/baseq3/cgame/cg_effects.o \
+	$(B)/baseq3/cgame/cg_ents.o \
+	$(B)/baseq3/cgame/cg_event.o \
+	$(B)/baseq3/cgame/cg_info.o \
+	$(B)/baseq3/cgame/cg_localents.o \
+	$(B)/baseq3/cgame/cg_main.o \
+	$(B)/baseq3/cgame/cg_marks.o \
+	$(B)/baseq3/cgame/cg_players.o \
+	$(B)/baseq3/cgame/cg_playerstate.o \
+	$(B)/baseq3/cgame/cg_predict.o \
+	$(B)/baseq3/cgame/cg_scoreboard.o \
+	$(B)/baseq3/cgame/cg_servercmds.o \
+	$(B)/baseq3/cgame/cg_snapshot.o \
+	$(B)/baseq3/cgame/cg_syscalls.o \
+	$(B)/baseq3/cgame/cg_view.o \
+	$(B)/baseq3/cgame/cg_weapons.o \
+	$(B)/baseq3/cgame/q_math.o \
+	$(B)/baseq3/cgame/q_shared.o
+
+$(B)/baseq3/cgame$(ARCH).$(SHLIBEXT) : $(Q3CGOBJ)
+	$(CC)  $(SHLIBLDFLAGS) -o $@ $(Q3CGOBJ)
+
+$(B)/baseq3/cgame/bg_misc.o : $(GDIR)/bg_misc.c; $(DO_SHLIB_CC)         
+$(B)/baseq3/cgame/bg_pmove.o : $(GDIR)/bg_pmove.c; $(DO_SHLIB_CC)        
+$(B)/baseq3/cgame/bg_slidemove.o : $(GDIR)/bg_slidemove.c; $(DO_SHLIB_CC)        
+$(B)/baseq3/cgame/cg_consolecmds.o : $(CGDIR)/cg_consolecmds.c; $(DO_SHLIB_CC)       
+$(B)/baseq3/cgame/cg_draw.o : $(CGDIR)/cg_draw.c; $(DO_SHLIB_CC)             
+$(B)/baseq3/cgame/cg_drawtools.o : $(CGDIR)/cg_drawtools.c; $(DO_SHLIB_CC)        
+$(B)/baseq3/cgame/cg_effects.o : $(CGDIR)/cg_effects.c; $(DO_SHLIB_CC)           
+$(B)/baseq3/cgame/cg_ents.o : $(CGDIR)/cg_ents.c; $(DO_SHLIB_CC)               
+$(B)/baseq3/cgame/cg_event.o : $(CGDIR)/cg_event.c; $(DO_SHLIB_CC)            
+$(B)/baseq3/cgame/cg_info.o : $(CGDIR)/cg_info.c; $(DO_SHLIB_CC)               
+$(B)/baseq3/cgame/cg_localents.o : $(CGDIR)/cg_localents.c; $(DO_SHLIB_CC)           
+$(B)/baseq3/cgame/cg_main.o : $(CGDIR)/cg_main.c; $(DO_SHLIB_CC)                   
+$(B)/baseq3/cgame/cg_marks.o : $(CGDIR)/cg_marks.c; $(DO_SHLIB_CC)                 
+$(B)/baseq3/cgame/cg_players.o : $(CGDIR)/cg_players.c; $(DO_SHLIB_CC)             
+$(B)/baseq3/cgame/cg_playerstate.o : $(CGDIR)/cg_playerstate.c; $(DO_SHLIB_CC)        
+$(B)/baseq3/cgame/cg_predict.o : $(CGDIR)/cg_predict.c; $(DO_SHLIB_CC)        
+$(B)/baseq3/cgame/cg_scoreboard.o : $(CGDIR)/cg_scoreboard.c; $(DO_SHLIB_CC)        
+$(B)/baseq3/cgame/cg_servercmds.o : $(CGDIR)/cg_servercmds.c; $(DO_SHLIB_CC)        
+$(B)/baseq3/cgame/cg_snapshot.o : $(CGDIR)/cg_snapshot.c; $(DO_SHLIB_CC)             
+$(B)/baseq3/cgame/cg_syscalls.o : $(CGDIR)/cg_syscalls.c; $(DO_SHLIB_CC)        
+$(B)/baseq3/cgame/cg_view.o : $(CGDIR)/cg_view.c; $(DO_SHLIB_CC)                     
+$(B)/baseq3/cgame/cg_weapons.o : $(CGDIR)/cg_weapons.c; $(DO_SHLIB_CC)               
+$(B)/baseq3/cgame/q_math.o : $(GDIR)/q_math.c; $(DO_SHLIB_CC)                       
+$(B)/baseq3/cgame/q_shared.o : $(GDIR)/q_shared.c; $(DO_SHLIB_CC)                     
+
+#############################################################################
+## BASEQ3 GAME
+#############################################################################
+
+Q3GOBJ = \
+	$(B)/baseq3/game/ai_chat.o \
+	$(B)/baseq3/game/ai_cmd.o \
+	$(B)/baseq3/game/ai_dmnet.o \
+	$(B)/baseq3/game/ai_dmq3.o \
+	$(B)/baseq3/game/ai_main.o \
+	$(B)/baseq3/game/ai_team.o \
+	$(B)/baseq3/game/ai_vcmd.o \
+	$(B)/baseq3/game/bg_misc.o \
+	$(B)/baseq3/game/bg_pmove.o \
+	$(B)/baseq3/game/bg_slidemove.o \
+	$(B)/baseq3/game/g_active.o \
+	$(B)/baseq3/game/g_arenas.o \
+	$(B)/baseq3/game/g_bot.o \
+	$(B)/baseq3/game/g_client.o \
+	$(B)/baseq3/game/g_cmds.o \
+	$(B)/baseq3/game/g_combat.o \
+	$(B)/baseq3/game/g_items.o \
+	$(B)/baseq3/game/g_main.o \
+	$(B)/baseq3/game/g_mem.o \
+	$(B)/baseq3/game/g_misc.o \
+	$(B)/baseq3/game/g_missile.o \
+	$(B)/baseq3/game/g_mover.o \
+	$(B)/baseq3/game/g_session.o \
+	$(B)/baseq3/game/g_spawn.o \
+	$(B)/baseq3/game/g_svcmds.o \
+	$(B)/baseq3/game/g_syscalls.o \
+	$(B)/baseq3/game/g_target.o \
+	$(B)/baseq3/game/g_team.o \
+	$(B)/baseq3/game/g_trigger.o \
+	$(B)/baseq3/game/g_utils.o \
+	$(B)/baseq3/game/g_weapon.o \
+	\
+	$(B)/baseq3/game/q_math.o \
+	$(B)/baseq3/game/q_shared.o
+
+$(B)/baseq3/qagame$(ARCH).$(SHLIBEXT) : $(Q3GOBJ)
+	$(CC)  $(SHLIBLDFLAGS) -o $@ $(Q3GOBJ)
+
+$(B)/baseq3/game/ai_chat.o : $(GDIR)/ai_chat.c; $(DO_SHLIB_CC)     
+$(B)/baseq3/game/ai_cmd.o : $(GDIR)/ai_cmd.c; $(DO_SHLIB_CC)       
+$(B)/baseq3/game/ai_dmnet.o : $(GDIR)/ai_dmnet.c; $(DO_SHLIB_CC)   
+$(B)/baseq3/game/ai_dmq3.o : $(GDIR)/ai_dmq3.c; $(DO_SHLIB_CC)       
+$(B)/baseq3/game/ai_main.o : $(GDIR)/ai_main.c; $(DO_SHLIB_CC)      
+$(B)/baseq3/game/ai_team.o : $(GDIR)/ai_team.c; $(DO_SHLIB_CC)  
+$(B)/baseq3/game/ai_vcmd.o : $(GDIR)/ai_vcmd.c; $(DO_SHLIB_CC)     
+$(B)/baseq3/game/bg_misc.o : $(GDIR)/bg_misc.c; $(DO_SHLIB_CC)     
+$(B)/baseq3/game/bg_pmove.o : $(GDIR)/bg_pmove.c; $(DO_SHLIB_CC)     
+$(B)/baseq3/game/bg_slidemove.o : $(GDIR)/bg_slidemove.c; $(DO_SHLIB_CC)    
+$(B)/baseq3/game/g_active.o : $(GDIR)/g_active.c; $(DO_SHLIB_CC)       
+$(B)/baseq3/game/g_arenas.o : $(GDIR)/g_arenas.c; $(DO_SHLIB_CC)       
+$(B)/baseq3/game/g_bot.o : $(GDIR)/g_bot.c; $(DO_SHLIB_CC)            
+$(B)/baseq3/game/g_client.o : $(GDIR)/g_client.c; $(DO_SHLIB_CC)      
+$(B)/baseq3/game/g_cmds.o : $(GDIR)/g_cmds.c; $(DO_SHLIB_CC)          
+$(B)/baseq3/game/g_combat.o : $(GDIR)/g_combat.c; $(DO_SHLIB_CC)       
+$(B)/baseq3/game/g_items.o : $(GDIR)/g_items.c; $(DO_SHLIB_CC)          
+$(B)/baseq3/game/g_main.o : $(GDIR)/g_main.c; $(DO_SHLIB_CC)            
+$(B)/baseq3/game/g_mem.o : $(GDIR)/g_mem.c; $(DO_SHLIB_CC)               
+$(B)/baseq3/game/g_misc.o : $(GDIR)/g_misc.c; $(DO_SHLIB_CC)             
+$(B)/baseq3/game/g_missile.o : $(GDIR)/g_missile.c; $(DO_SHLIB_CC)        
+$(B)/baseq3/game/g_mover.o : $(GDIR)/g_mover.c; $(DO_SHLIB_CC)          
+$(B)/baseq3/game/g_session.o : $(GDIR)/g_session.c; $(DO_SHLIB_CC)       
+$(B)/baseq3/game/g_spawn.o : $(GDIR)/g_spawn.c; $(DO_SHLIB_CC)          
+$(B)/baseq3/game/g_svcmds.o : $(GDIR)/g_svcmds.c; $(DO_SHLIB_CC)         
+$(B)/baseq3/game/g_syscalls.o : $(GDIR)/g_syscalls.c; $(DO_SHLIB_CC)    
+$(B)/baseq3/game/g_target.o : $(GDIR)/g_target.c; $(DO_SHLIB_CC)        
+$(B)/baseq3/game/g_team.o : $(GDIR)/g_team.c; $(DO_SHLIB_CC)           
+$(B)/baseq3/game/g_trigger.o : $(GDIR)/g_trigger.c; $(DO_SHLIB_CC)       
+$(B)/baseq3/game/g_utils.o : $(GDIR)/g_utils.c; $(DO_SHLIB_CC)          
+$(B)/baseq3/game/g_weapon.o : $(GDIR)/g_weapon.c; $(DO_SHLIB_CC)       
+$(B)/baseq3/game/q_math.o : $(GDIR)/q_math.c; $(DO_SHLIB_CC)            
+$(B)/baseq3/game/q_shared.o : $(GDIR)/q_shared.c; $(DO_SHLIB_CC)       
+
+
+#############################################################################
+## BASEQ3 UI
+#############################################################################
+
+Q3UIOBJ = \
+        $(B)/baseq3/ui/bg_misc.o \
+        $(B)/baseq3/ui/ui_addbots.o \
+        $(B)/baseq3/ui/ui_atoms.o \
+        $(B)/baseq3/ui/ui_cdkey.o \
+        $(B)/baseq3/ui/ui_cinematics.o \
+        $(B)/baseq3/ui/ui_confirm.o \
+        $(B)/baseq3/ui/ui_connect.o \
+        $(B)/baseq3/ui/ui_controls2.o \
+        $(B)/baseq3/ui/ui_credits.o \
+        $(B)/baseq3/ui/ui_demo2.o \
+        $(B)/baseq3/ui/ui_display.o \
+        $(B)/baseq3/ui/ui_gameinfo.o \
+        $(B)/baseq3/ui/ui_ingame.o \
+        $(B)/baseq3/ui/ui_loadconfig.o \
+        $(B)/baseq3/ui/ui_main.o \
+        $(B)/baseq3/ui/ui_menu.o \
+        $(B)/baseq3/ui/ui_mfield.o \
+        $(B)/baseq3/ui/ui_mods.o \
+        $(B)/baseq3/ui/ui_network.o \
+        $(B)/baseq3/ui/ui_options.o \
+        $(B)/baseq3/ui/ui_playermodel.o \
+        $(B)/baseq3/ui/ui_players.o \
+        $(B)/baseq3/ui/ui_playersettings.o \
+        $(B)/baseq3/ui/ui_preferences.o \
+        $(B)/baseq3/ui/ui_qmenu.o \
+        $(B)/baseq3/ui/ui_removebots.o \
+        $(B)/baseq3/ui/ui_saveconfig.o \
+        $(B)/baseq3/ui/ui_serverinfo.o \
+        $(B)/baseq3/ui/ui_servers2.o \
+        $(B)/baseq3/ui/ui_setup.o \
+        $(B)/baseq3/ui/ui_sound.o \
+        $(B)/baseq3/ui/ui_sparena.o \
+        $(B)/baseq3/ui/ui_specifyserver.o \
+        $(B)/baseq3/ui/ui_splevel.o \
+        $(B)/baseq3/ui/ui_sppostgame.o \
+        $(B)/baseq3/ui/ui_spskill.o \
+        $(B)/baseq3/ui/ui_startserver.o \
+        $(B)/baseq3/ui/ui_syscalls.o \
+        $(B)/baseq3/ui/ui_team.o \
+        $(B)/baseq3/ui/ui_teamorders.o \
+        $(B)/baseq3/ui/ui_video.o \
+        \
+        $(B)/baseq3/ui/q_math.o \
+        $(B)/baseq3/ui/q_shared.o
+
+$(B)/baseq3/ui$(ARCH).$(SHLIBEXT) : $(Q3UIOBJ)
+	$(CC) $(CFLAGS) $(SHLIBLDFLAGS) -o $@ $(Q3UIOBJ)
+
+$(B)/baseq3/ui/bg_misc.o : $(GDIR)/bg_misc.c; $(DO_SHLIB_CC) 
+$(B)/baseq3/ui/ui_addbots.o : $(Q3UIDIR)/ui_addbots.c; $(DO_SHLIB_CC) 
+$(B)/baseq3/ui/ui_atoms.o : $(Q3UIDIR)/ui_atoms.c; $(DO_SHLIB_CC) 
+$(B)/baseq3/ui/ui_cinematics.o : $(Q3UIDIR)/ui_cinematics.c; $(DO_SHLIB_CC) 
+$(B)/baseq3/ui/ui_cdkey.o : $(Q3UIDIR)/ui_cdkey.c; $(DO_SHLIB_CC)
+$(B)/baseq3/ui/ui_confirm.o : $(Q3UIDIR)/ui_confirm.c; $(DO_SHLIB_CC) 
+$(B)/baseq3/ui/ui_connect.o : $(Q3UIDIR)/ui_connect.c; $(DO_SHLIB_CC) 
+$(B)/baseq3/ui/ui_controls2.o : $(Q3UIDIR)/ui_controls2.c; $(DO_SHLIB_CC) 
+$(B)/baseq3/ui/ui_credits.o : $(Q3UIDIR)/ui_credits.c; $(DO_SHLIB_CC) 
+$(B)/baseq3/ui/ui_demo2.o : $(Q3UIDIR)/ui_demo2.c; $(DO_SHLIB_CC) 
+$(B)/baseq3/ui/ui_display.o : $(Q3UIDIR)/ui_display.c; $(DO_SHLIB_CC) 
+$(B)/baseq3/ui/ui_gameinfo.o : $(Q3UIDIR)/ui_gameinfo.c; $(DO_SHLIB_CC) 
+$(B)/baseq3/ui/ui_ingame.o : $(Q3UIDIR)/ui_ingame.c; $(DO_SHLIB_CC) 
+$(B)/baseq3/ui/ui_loadconfig.o : $(Q3UIDIR)/ui_loadconfig.c; $(DO_SHLIB_CC) 
+$(B)/baseq3/ui/ui_main.o : $(Q3UIDIR)/ui_main.c; $(DO_SHLIB_CC) 
+$(B)/baseq3/ui/ui_menu.o : $(Q3UIDIR)/ui_menu.c; $(DO_SHLIB_CC) 
+$(B)/baseq3/ui/ui_mfield.o : $(Q3UIDIR)/ui_mfield.c; $(DO_SHLIB_CC) 
+$(B)/baseq3/ui/ui_mods.o : $(Q3UIDIR)/ui_mods.c; $(DO_SHLIB_CC) 
+$(B)/baseq3/ui/ui_network.o : $(Q3UIDIR)/ui_network.c; $(DO_SHLIB_CC) 
+$(B)/baseq3/ui/ui_options.o : $(Q3UIDIR)/ui_options.c; $(DO_SHLIB_CC)
+$(B)/baseq3/ui/ui_playermodel.o : $(Q3UIDIR)/ui_playermodel.c; $(DO_SHLIB_CC) 
+$(B)/baseq3/ui/ui_players.o : $(Q3UIDIR)/ui_players.c; $(DO_SHLIB_CC) 
+$(B)/baseq3/ui/ui_playersettings.o : $(Q3UIDIR)/ui_playersettings.c; $(DO_SHLIB_CC) 
+$(B)/baseq3/ui/ui_preferences.o : $(Q3UIDIR)/ui_preferences.c; $(DO_SHLIB_CC) 
+$(B)/baseq3/ui/ui_qmenu.o : $(Q3UIDIR)/ui_qmenu.c; $(DO_SHLIB_CC) 
+$(B)/baseq3/ui/ui_quit.o : $(Q3UIDIR)/ui_quit.c; $(DO_SHLIB_CC) 
+$(B)/baseq3/ui/ui_removebots.o : $(Q3UIDIR)/ui_removebots.c; $(DO_SHLIB_CC) 
+$(B)/baseq3/ui/ui_saveconfig.o : $(Q3UIDIR)/ui_saveconfig.c; $(DO_SHLIB_CC) 
+$(B)/baseq3/ui/ui_serverinfo.o : $(Q3UIDIR)/ui_serverinfo.c; $(DO_SHLIB_CC) 
+$(B)/baseq3/ui/ui_servers2.o : $(Q3UIDIR)/ui_servers2.c; $(DO_SHLIB_CC) 
+$(B)/baseq3/ui/ui_setup.o : $(Q3UIDIR)/ui_setup.c; $(DO_SHLIB_CC) 
+$(B)/baseq3/ui/ui_sound.o : $(Q3UIDIR)/ui_sound.c; $(DO_SHLIB_CC) 
+$(B)/baseq3/ui/ui_sparena.o : $(Q3UIDIR)/ui_sparena.c; $(DO_SHLIB_CC) 
+$(B)/baseq3/ui/ui_specifyserver.o : $(Q3UIDIR)/ui_specifyserver.c; $(DO_SHLIB_CC) 
+$(B)/baseq3/ui/ui_splevel.o : $(Q3UIDIR)/ui_splevel.c; $(DO_SHLIB_CC) 
+$(B)/baseq3/ui/ui_sppostgame.o : $(Q3UIDIR)/ui_sppostgame.c; $(DO_SHLIB_CC) 
+$(B)/baseq3/ui/ui_spskill.o : $(Q3UIDIR)/ui_spskill.c; $(DO_SHLIB_CC) 
+$(B)/baseq3/ui/ui_startserver.o : $(Q3UIDIR)/ui_startserver.c; $(DO_SHLIB_CC) 
+$(B)/baseq3/ui/ui_team.o : $(Q3UIDIR)/ui_team.c; $(DO_SHLIB_CC) 
+$(B)/baseq3/ui/ui_teamorders.o : $(Q3UIDIR)/ui_teamorders.c; $(DO_SHLIB_CC) 
+$(B)/baseq3/ui/ui_syscalls.o : $(Q3UIDIR)/ui_syscalls.c; $(DO_SHLIB_CC) 
+$(B)/baseq3/ui/ui_video.o : $(Q3UIDIR)/ui_video.c; $(DO_SHLIB_CC) 
+
+# bk001205 - these wre the only SHLIB compiles in 1.17
+$(B)/baseq3/ui/q_math.o : $(GDIR)/q_math.c; $(DO_SHLIB_CC) 
+$(B)/baseq3/ui/q_shared.o : $(GDIR)/q_shared.c; $(DO_SHLIB_CC) 
+
+
+#############################################################################
+## Q3 STATIC (DEBUG) BUILD
+#############################################################################
+
+Q3SOBJ = \
+	$(B)/q3static/cl_cgame.o \
+	$(B)/q3static/cl_cin.o \
+	$(B)/q3static/cl_console.o \
+	$(B)/q3static/cl_input.o \
+	$(B)/q3static/cl_keys.o \
+	$(B)/q3static/cl_main.o \
+	$(B)/q3static/cl_net_chan.o \
+	$(B)/q3static/cl_parse.o \
+	$(B)/q3static/cl_scrn.o \
+	$(B)/q3static/cl_ui.o \
+	\
+	$(B)/q3static/cm_load.o \
+	$(B)/q3static/cm_patch.o \
+	$(B)/q3static/cm_polylib.o \
+	$(B)/q3static/cm_test.o \
+	$(B)/q3static/cm_trace.o \
+	\
+	$(B)/q3static/cmd.o \
+	$(B)/q3static/common.o \
+	$(B)/q3static/cvar.o \
+	$(B)/q3static/files.o \
+	$(B)/q3static/md4.o \
+	$(B)/q3static/msg.o \
+	$(B)/q3static/net_chan.o \
+	\
+	$(B)/q3static/snd_adpcm.o \
+	$(B)/q3static/snd_dma.o \
+	$(B)/q3static/snd_mem.o \
+	$(B)/q3static/snd_mix.o \
+	$(B)/q3static/snd_wavelet.o \
+	\
+	$(B)/q3static/sv_bot.o \
+	$(B)/q3static/sv_ccmds.o \
+	$(B)/q3static/sv_client.o \
+	$(B)/q3static/sv_game.o \
+	$(B)/q3static/sv_init.o \
+	$(B)/q3static/sv_main.o \
+	$(B)/q3static/sv_net_chan.o \
+	$(B)/q3static/sv_snapshot.o \
+	$(B)/q3static/sv_world.o \
+	\
+	$(B)/q3static/unzip.o \
+	$(B)/q3static/vm.o \
+	$(B)/q3static/vm_interpreted.o \
+	\
+	$(B)/q3static/be_aas_bspq3.o \
+	$(B)/q3static/be_aas_cluster.o \
+	$(B)/q3static/be_aas_debug.o \
+	$(B)/q3static/be_aas_entity.o \
+	$(B)/q3static/be_aas_file.o \
+	$(B)/q3static/be_aas_main.o \
+	$(B)/q3static/be_aas_move.o \
+	$(B)/q3static/be_aas_optimize.o \
+	$(B)/q3static/be_aas_reach.o \
+	$(B)/q3static/be_aas_route.o \
+	$(B)/q3static/be_aas_routealt.o \
+	$(B)/q3static/be_aas_sample.o \
+	$(B)/q3static/be_ai_char.o \
+	$(B)/q3static/be_ai_chat.o \
+	$(B)/q3static/be_ai_gen.o \
+	$(B)/q3static/be_ai_goal.o \
+	$(B)/q3static/be_ai_move.o \
+	$(B)/q3static/be_ai_weap.o \
+	$(B)/q3static/be_ai_weight.o \
+	$(B)/q3static/be_ea.o \
+	$(B)/q3static/be_interface.o \
+	$(B)/q3static/l_crc.o \
+	$(B)/q3static/l_libvar.o \
+	$(B)/q3static/l_log.o \
+	$(B)/q3static/l_memory.o \
+	$(B)/q3static/l_precomp.o \
+	$(B)/q3static/l_script.o \
+	$(B)/q3static/l_struct.o \
+	\
+	$(B)/q3static/jcapimin.o \
+	$(B)/q3static/jchuff.o   \
+	$(B)/q3static/jcinit.o \
+	$(B)/q3static/jccoefct.o  \
+	$(B)/q3static/jccolor.o \
+	$(B)/q3static/jfdctflt.o \
+	$(B)/q3static/jcdctmgr.o \
+	$(B)/q3static/jcphuff.o \
+	$(B)/q3static/jcmainct.o \
+	$(B)/q3static/jcmarker.o \
+	$(B)/q3static/jcmaster.o \
+	$(B)/q3static/jcomapi.o \
+	$(B)/q3static/jcparam.o \
+	$(B)/q3static/jcprepct.o \
+	$(B)/q3static/jcsample.o \
+	$(B)/q3static/jdapimin.o \
+	$(B)/q3static/jdapistd.o \
+	$(B)/q3static/jdatasrc.o \
+	$(B)/q3static/jdcoefct.o \
+	$(B)/q3static/jdcolor.o \
+	$(B)/q3static/jddctmgr.o \
+	$(B)/q3static/jdhuff.o \
+	$(B)/q3static/jdinput.o \
+	$(B)/q3static/jdmainct.o \
+	$(B)/q3static/jdmarker.o \
+	$(B)/q3static/jdmaster.o \
+	$(B)/q3static/jdpostct.o \
+	$(B)/q3static/jdsample.o \
+	$(B)/q3static/jdtrans.o \
+	$(B)/q3static/jerror.o \
+	$(B)/q3static/jidctflt.o \
+	$(B)/q3static/jmemmgr.o \
+	$(B)/q3static/jmemnobs.o \
+	$(B)/q3static/jutils.o \
+	\
+	$(B)/q3static/tr_animation.o \
+	$(B)/q3static/tr_backend.o \
+	$(B)/q3static/tr_bsp.o \
+	$(B)/q3static/tr_cmds.o \
+	$(B)/q3static/tr_curve.o \
+	$(B)/q3static/tr_flares.o \
+	$(B)/q3static/tr_font.o \
+	$(B)/q3static/tr_image.o \
+	$(B)/q3static/tr_init.o \
+	$(B)/q3static/tr_light.o \
+	$(B)/q3static/tr_main.o \
+	$(B)/q3static/tr_marks.o \
+	$(B)/q3static/tr_mesh.o \
+	$(B)/q3static/tr_model.o \
+	$(B)/q3static/tr_noise.o \
+	$(B)/q3static/tr_scene.o \
+	$(B)/q3static/tr_shade.o \
+	$(B)/q3static/tr_shade_calc.o \
+	$(B)/q3static/tr_shader.o \
+	$(B)/q3static/tr_shadows.o \
+	$(B)/q3static/tr_sky.o \
+	$(B)/q3static/tr_surface.o \
+	$(B)/q3static/tr_world.o \
+	\
+	$(B)/q3static/unix_main.o \
+	$(B)/q3static/unix_net.o \
+	$(B)/q3static/unix_shared.o \
+	\
+	$(B)/q3static/ahoptim.o  \
+	$(B)/q3static/autohint.o \
+	$(B)/q3static/ftbase.o   \
+	$(B)/q3static/ftdebug.o  \
+	$(B)/q3static/ftglyph.o  \
+	$(B)/q3static/ftinit.o   \
+	$(B)/q3static/ftmm.o     \
+	$(B)/q3static/ftsystem.o \
+	$(B)/q3static/raster1.o  \
+	$(B)/q3static/sfnt.o     \
+	$(B)/q3static/sfobjs.o   \
+	$(B)/q3static/smooth.o   \
+	$(B)/q3static/truetype.o \
+	\
+	$(B)/q3static/linux_qgl.o \
+	$(B)/q3static/linux_glimp.o \
+	$(B)/q3static/linux_joystick.o \
+	$(B)/q3static/linux_snd.o \
+	$(B)/q3static/snd_mixa.o \
+	$(B)/q3static/matha.o
+
+ifeq ($(ARCH),i386)
+  Q3SOBJ += $(B)/q3static/vm_x86.o
+endif
+
+ifeq ($(ARCH),ppc)
+  ifeq ($(DLL_ONLY),false)
+    Q3SOBJ += $(B)/q3static/vm_ppc.o
+  endif
+endif
+
+
+$(B)/q3static/cl_cgame.o : $(CDIR)/cl_cgame.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/cl_cin.o : $(CDIR)/cl_cin.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/cl_console.o : $(CDIR)/cl_console.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/cl_input.o : $(CDIR)/cl_input.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/cl_keys.o : $(CDIR)/cl_keys.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/cl_main.o : $(CDIR)/cl_main.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/cl_net_chan.o : $(CDIR)/cl_net_chan.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/cl_parse.o : $(CDIR)/cl_parse.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/cl_scrn.o : $(CDIR)/cl_scrn.c; $(DO_CC) -DQ3_STATIC    
+$(B)/q3static/cl_ui.o : $(CDIR)/cl_ui.c; $(DO_CC) -DQ3_STATIC         
+$(B)/q3static/snd_adpcm.o : $(CDIR)/snd_adpcm.c; $(DO_CC) -DQ3_STATIC   
+$(B)/q3static/snd_dma.o : $(CDIR)/snd_dma.c; $(DO_CC) -DQ3_STATIC       
+$(B)/q3static/snd_mem.o : $(CDIR)/snd_mem.c; $(DO_CC) -DQ3_STATIC        
+$(B)/q3static/snd_mix.o : $(CDIR)/snd_mix.c; $(DO_CC) -DQ3_STATIC       
+$(B)/q3static/snd_wavelet.o : $(CDIR)/snd_wavelet.c; $(DO_CC) -DQ3_STATIC     
+$(B)/q3static/sv_bot.o : $(SDIR)/sv_bot.c; $(DO_CC) -DQ3_STATIC        
+$(B)/q3static/sv_client.o : $(SDIR)/sv_client.c; $(DO_CC) -DQ3_STATIC     
+$(B)/q3static/sv_ccmds.o : $(SDIR)/sv_ccmds.c; $(DO_CC) -DQ3_STATIC       
+$(B)/q3static/sv_game.o : $(SDIR)/sv_game.c; $(DO_CC) -DQ3_STATIC        
+$(B)/q3static/sv_init.o : $(SDIR)/sv_init.c; $(DO_CC) -DQ3_STATIC        
+$(B)/q3static/sv_main.o : $(SDIR)/sv_main.c; $(DO_CC) -DQ3_STATIC        
+$(B)/q3static/sv_net_chan.o : $(SDIR)/sv_net_chan.c; $(DO_CC) -DQ3_STATIC     
+$(B)/q3static/sv_snapshot.o : $(SDIR)/sv_snapshot.c; $(DO_CC) -DQ3_STATIC      
+$(B)/q3static/sv_world.o : $(SDIR)/sv_world.c; $(DO_CC) -DQ3_STATIC         
+$(B)/q3static/cm_trace.o : $(CMDIR)/cm_trace.c; $(DO_CC) -DQ3_STATIC       
+$(B)/q3static/cm_load.o : $(CMDIR)/cm_load.c; $(DO_CC) -DQ3_STATIC        
+$(B)/q3static/cm_test.o : $(CMDIR)/cm_test.c; $(DO_CC) -DQ3_STATIC        
+$(B)/q3static/cm_patch.o : $(CMDIR)/cm_patch.c; $(DO_CC) -DQ3_STATIC       
+$(B)/q3static/cm_polylib.o : $(CMDIR)/cm_polylib.c; $(DO_CC) -DQ3_STATIC     
+$(B)/q3static/cmd.o : $(CMDIR)/cmd.c; $(DO_CC) -DQ3_STATIC                   
+$(B)/q3static/common.o : $(CMDIR)/common.c; $(DO_CC) -DQ3_STATIC               
+$(B)/q3static/cvar.o : $(CMDIR)/cvar.c; $(DO_CC) -DQ3_STATIC                
+$(B)/q3static/files.o : $(CMDIR)/files.c; $(DO_CC) -DQ3_STATIC              
+$(B)/q3static/md4.o : $(CMDIR)/md4.c; $(DO_CC) -DQ3_STATIC                   
+$(B)/q3static/msg.o : $(CMDIR)/msg.c; $(DO_CC) -DQ3_STATIC                    
+$(B)/q3static/net_chan.o : $(CMDIR)/net_chan.c; $(DO_CC) -DQ3_STATIC
+
+$(B)/q3static/be_aas_bspq3.o : $(BLIBDIR)/be_aas_bspq3.c; $(DO_BOT_CC) -DQ3_STATIC 
+$(B)/q3static/be_aas_cluster.o : $(BLIBDIR)/be_aas_cluster.c; $(DO_BOT_CC) -DQ3_STATIC 
+$(B)/q3static/be_aas_debug.o : $(BLIBDIR)/be_aas_debug.c; $(DO_BOT_CC) -DQ3_STATIC 
+$(B)/q3static/be_aas_entity.o : $(BLIBDIR)/be_aas_entity.c; $(DO_BOT_CC) -DQ3_STATIC 
+$(B)/q3static/be_aas_file.o : $(BLIBDIR)/be_aas_file.c; $(DO_BOT_CC) -DQ3_STATIC 
+$(B)/q3static/be_aas_main.o : $(BLIBDIR)/be_aas_main.c; $(DO_BOT_CC) -DQ3_STATIC 
+$(B)/q3static/be_aas_move.o : $(BLIBDIR)/be_aas_move.c; $(DO_BOT_CC) -DQ3_STATIC 
+$(B)/q3static/be_aas_optimize.o : $(BLIBDIR)/be_aas_optimize.c; $(DO_BOT_CC) -DQ3_STATIC 
+$(B)/q3static/be_aas_reach.o : $(BLIBDIR)/be_aas_reach.c; $(DO_BOT_CC) -DQ3_STATIC 
+$(B)/q3static/be_aas_route.o : $(BLIBDIR)/be_aas_route.c; $(DO_BOT_CC) -DQ3_STATIC 
+$(B)/q3static/be_aas_routealt.o : $(BLIBDIR)/be_aas_routealt.c; $(DO_BOT_CC) -DQ3_STATIC 
+$(B)/q3static/be_aas_sample.o : $(BLIBDIR)/be_aas_sample.c; $(DO_BOT_CC) -DQ3_STATIC 
+$(B)/q3static/be_ai_char.o : $(BLIBDIR)/be_ai_char.c; $(DO_BOT_CC) -DQ3_STATIC 
+$(B)/q3static/be_ai_chat.o : $(BLIBDIR)/be_ai_chat.c; $(DO_BOT_CC) -DQ3_STATIC 
+$(B)/q3static/be_ai_gen.o : $(BLIBDIR)/be_ai_gen.c; $(DO_BOT_CC) -DQ3_STATIC 
+$(B)/q3static/be_ai_goal.o : $(BLIBDIR)/be_ai_goal.c; $(DO_BOT_CC) -DQ3_STATIC 
+$(B)/q3static/be_ai_move.o : $(BLIBDIR)/be_ai_move.c; $(DO_BOT_CC) -DQ3_STATIC 
+$(B)/q3static/be_ai_weap.o : $(BLIBDIR)/be_ai_weap.c; $(DO_BOT_CC) -DQ3_STATIC 
+$(B)/q3static/be_ai_weight.o : $(BLIBDIR)/be_ai_weight.c; $(DO_BOT_CC) -DQ3_STATIC 
+$(B)/q3static/be_ea.o : $(BLIBDIR)/be_ea.c; $(DO_BOT_CC) -DQ3_STATIC 
+$(B)/q3static/be_interface.o : $(BLIBDIR)/be_interface.c; $(DO_BOT_CC) -DQ3_STATIC 
+$(B)/q3static/l_crc.o : $(BLIBDIR)/l_crc.c; $(DO_BOT_CC) -DQ3_STATIC 
+$(B)/q3static/l_libvar.o : $(BLIBDIR)/l_libvar.c; $(DO_BOT_CC) -DQ3_STATIC 
+$(B)/q3static/l_log.o : $(BLIBDIR)/l_log.c; $(DO_BOT_CC) -DQ3_STATIC 
+$(B)/q3static/l_memory.o : $(BLIBDIR)/l_memory.c; $(DO_BOT_CC) -DQ3_STATIC 
+$(B)/q3static/l_precomp.o : $(BLIBDIR)/l_precomp.c; $(DO_BOT_CC) -DQ3_STATIC 
+$(B)/q3static/l_script.o : $(BLIBDIR)/l_script.c; $(DO_BOT_CC) -DQ3_STATIC 
+$(B)/q3static/l_struct.o : $(BLIBDIR)/l_struct.c; $(DO_BOT_CC) -DQ3_STATIC 
+
+$(B)/q3static/jcapimin.o : $(JPDIR)/jcapimin.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/jchuff.o : $(JPDIR)/jchuff.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/jcinit.o : $(JPDIR)/jcinit.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/jccoefct.o : $(JPDIR)/jccoefct.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/jccolor.o : $(JPDIR)/jccolor.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/jfdctflt.o : $(JPDIR)/jfdctflt.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/jcdctmgr.o : $(JPDIR)/jcdctmgr.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/jcmainct.o : $(JPDIR)/jcmainct.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/jcmarker.o : $(JPDIR)/jcmarker.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/jcmaster.o : $(JPDIR)/jcmaster.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/jcomapi.o : $(JPDIR)/jcomapi.c; $(DO_CC) -DQ3_STATIC
+$(B)/q3static/jcparam.o : $(JPDIR)/jcparam.c;  $(DO_CC) -DQ3_STATIC
+$(B)/q3static/jcprepct.o : $(JPDIR)/jcprepct.c; $(DO_CC) -DQ3_STATIC
+$(B)/q3static/jcsample.o : $(JPDIR)/jcsample.c; $(DO_CC) -DQ3_STATIC 
+
+$(B)/q3static/jdapimin.o : $(JPDIR)/jdapimin.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/jdapistd.o : $(JPDIR)/jdapistd.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/jdatasrc.o : $(JPDIR)/jdatasrc.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/jdcoefct.o : $(JPDIR)/jdcoefct.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/jdcolor.o : $(JPDIR)/jdcolor.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/jcphuff.o : $(JPDIR)/jcphuff.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/jddctmgr.o : $(JPDIR)/jddctmgr.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/jdhuff.o : $(JPDIR)/jdhuff.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/jdinput.o : $(JPDIR)/jdinput.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/jdmainct.o : $(JPDIR)/jdmainct.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/jdmarker.o : $(JPDIR)/jdmarker.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/jdmaster.o : $(JPDIR)/jdmaster.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/jdpostct.o : $(JPDIR)/jdpostct.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/jdsample.o : $(JPDIR)/jdsample.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/jdtrans.o : $(JPDIR)/jdtrans.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/jerror.o : $(JPDIR)/jerror.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/jidctflt.o : $(JPDIR)/jidctflt.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/jmemmgr.o : $(JPDIR)/jmemmgr.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/jmemnobs.o : $(JPDIR)/jmemnobs.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/jutils.o : $(JPDIR)/jutils.c; $(DO_CC) -DQ3_STATIC 
+
+$(B)/q3static/tr_bsp.o : $(RDIR)/tr_bsp.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/tr_animation.o : $(RDIR)/tr_animation.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/tr_backend.o : $(RDIR)/tr_backend.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/tr_cmds.o : $(RDIR)/tr_cmds.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/tr_curve.o : $(RDIR)/tr_curve.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/tr_flares.o : $(RDIR)/tr_flares.c; $(DO_CC) -DQ3_STATIC
+$(B)/q3static/tr_font.o : $(RDIR)/tr_font.c; $(DO_CC) -DQ3_STATIC  
+$(B)/q3static/tr_image.o : $(RDIR)/tr_image.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/tr_init.o : $(RDIR)/tr_init.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/tr_light.o : $(RDIR)/tr_light.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/tr_main.o : $(RDIR)/tr_main.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/tr_marks.o : $(RDIR)/tr_marks.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/tr_mesh.o : $(RDIR)/tr_mesh.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/tr_model.o : $(RDIR)/tr_model.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/tr_noise.o : $(RDIR)/tr_noise.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/tr_scene.o : $(RDIR)/tr_scene.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/tr_shade.o : $(RDIR)/tr_shade.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/tr_shader.o : $(RDIR)/tr_shader.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/tr_shade_calc.o : $(RDIR)/tr_shade_calc.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/tr_shadows.o : $(RDIR)/tr_shadows.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/tr_sky.o : $(RDIR)/tr_sky.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/tr_smp.o : $(RDIR)/tr_smp.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/tr_stripify.o : $(RDIR)/tr_stripify.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/tr_subdivide.o : $(RDIR)/tr_subdivide.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/tr_surface.o : $(RDIR)/tr_surface.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/tr_world.o : $(RDIR)/tr_world.c; $(DO_CC) -DQ3_STATIC 
+
+$(B)/q3static/unix_qgl.o : $(UDIR)/unix_qgl.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/unix_main.o : $(UDIR)/unix_main.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/unix_net.o : $(UDIR)/unix_net.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/unix_shared.o : $(UDIR)/unix_shared.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/linux_glimp.o : $(UDIR)/linux_glimp.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/linux_joystick.o : $(UDIR)/linux_joystick.c; $(DO_CC) -DQ3_STATIC  
+$(B)/q3static/linux_qgl.o : $(UDIR)/linux_qgl.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/linux_input.o : $(UDIR)/linux_input.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/linux_snd.o : $(UDIR)/linux_snd.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/snd_mixa.o : $(UDIR)/snd_mixa.s; $(DO_AS) 
+$(B)/q3static/matha.o : $(UDIR)/matha.s; $(DO_AS) 
+$(B)/q3static/unzip.o : $(CMDIR)/unzip.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/vm.o : $(CMDIR)/vm.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/vm_interpreted.o : $(CMDIR)/vm_interpreted.c; $(DO_CC) -DQ3_STATIC 
+
+ifeq ($(ARCH),i386)
+  $(B)/q3static/vm_x86.o : $(CMDIR)/vm_x86.c; $(DO_CC) -DQ3_STATIC
+endif
+
+ifeq ($(ARCH),ppc)
+ifeq ($(DLL_ONLY),false)
+$(B)/q3static/vm_ppc.o : $(CMDIR)/vm_ppc.c; $(DO_CC) -DQ3_STATIC
+endif
+endif
+
+$(B)/q3static/ahoptim.o  : $(FTDIR)/ahoptim.c;   $(DO_CC) -DQ3_STATIC
+$(B)/q3static/autohint.o : $(FTDIR)/autohint.c;  $(DO_CC) -DQ3_STATIC
+$(B)/q3static/ftbase.o   : $(FTDIR)/ftbase.c;    $(DO_CC) -DQ3_STATIC
+$(B)/q3static/ftdebug.o  : $(FTDIR)/ftdebug.c;   $(DO_CC) -DQ3_STATIC
+$(B)/q3static/ftglyph.o  : $(FTDIR)/ftglyph.c;   $(DO_CC) -DQ3_STATIC
+$(B)/q3static/ftinit.o   : $(FTDIR)/ftinit.c;    $(DO_CC) -DQ3_STATIC
+$(B)/q3static/ftmm.o     : $(FTDIR)/ftmm.c;      $(DO_CC) -DQ3_STATIC
+$(B)/q3static/ftsystem.o : $(FTDIR)/ftsystem.c;  $(DO_CC) -DQ3_STATIC
+$(B)/q3static/raster1.o  : $(FTDIR)/raster1.c;   $(DO_CC) -DQ3_STATIC -DFT_FLAT_COMPILE
+$(B)/q3static/sfnt.o     : $(FTDIR)/sfnt.c;      $(DO_CC) -DQ3_STATIC
+$(B)/q3static/sfobjs.o   : $(FTDIR)/sfobjs.c;    $(DO_CC) -DQ3_STATIC
+$(B)/q3static/smooth.o   : $(FTDIR)/smooth.c;    $(DO_CC) -DQ3_STATIC -DFT_FLAT_COMPILE
+$(B)/q3static/truetype.o : $(FTDIR)/truetype.c;  $(DO_CC) -DQ3_STATIC
+
+## add BASEQ3 CGAME
+Q3SOBJ += \
+	$(B)/q3static/cg_consolecmds.o \
+	$(B)/q3static/cg_draw.o \
+	$(B)/q3static/cg_drawtools.o \
+	$(B)/q3static/cg_effects.o \
+	$(B)/q3static/cg_ents.o \
+	$(B)/q3static/cg_event.o \
+	$(B)/q3static/cg_info.o \
+	$(B)/q3static/cg_localents.o \
+	$(B)/q3static/cg_main.o \
+	$(B)/q3static/cg_marks.o \
+	$(B)/q3static/cg_players.o \
+	$(B)/q3static/cg_playerstate.o \
+	$(B)/q3static/cg_predict.o \
+	$(B)/q3static/cg_scoreboard.o \
+	$(B)/q3static/cg_servercmds.o \
+	$(B)/q3static/cg_snapshot.o \
+	$(B)/q3static/cg_syscalls.o \
+	$(B)/q3static/cg_view.o \
+	$(B)/q3static/cg_weapons.o
+
+$(B)/q3static/cg_consolecmds.o : $(CGDIR)/cg_consolecmds.c; $(DO_CC) -DQ3_STATIC       
+$(B)/q3static/cg_draw.o : $(CGDIR)/cg_draw.c; $(DO_CC) -DQ3_STATIC             
+$(B)/q3static/cg_drawtools.o : $(CGDIR)/cg_drawtools.c; $(DO_CC) -DQ3_STATIC        
+$(B)/q3static/cg_effects.o : $(CGDIR)/cg_effects.c; $(DO_CC) -DQ3_STATIC           
+$(B)/q3static/cg_ents.o : $(CGDIR)/cg_ents.c; $(DO_CC) -DQ3_STATIC               
+$(B)/q3static/cg_event.o : $(CGDIR)/cg_event.c; $(DO_CC) -DQ3_STATIC            
+$(B)/q3static/cg_info.o : $(CGDIR)/cg_info.c; $(DO_CC) -DQ3_STATIC               
+$(B)/q3static/cg_localents.o : $(CGDIR)/cg_localents.c; $(DO_CC) -DQ3_STATIC           
+$(B)/q3static/cg_main.o : $(CGDIR)/cg_main.c; $(DO_CC) -DQ3_STATIC                   
+$(B)/q3static/cg_marks.o : $(CGDIR)/cg_marks.c; $(DO_CC) -DQ3_STATIC                 
+$(B)/q3static/cg_players.o : $(CGDIR)/cg_players.c; $(DO_CC) -DQ3_STATIC             
+$(B)/q3static/cg_playerstate.o : $(CGDIR)/cg_playerstate.c; $(DO_CC) -DQ3_STATIC        
+$(B)/q3static/cg_predict.o : $(CGDIR)/cg_predict.c; $(DO_CC) -DQ3_STATIC        
+$(B)/q3static/cg_scoreboard.o : $(CGDIR)/cg_scoreboard.c; $(DO_CC) -DQ3_STATIC        
+$(B)/q3static/cg_servercmds.o : $(CGDIR)/cg_servercmds.c; $(DO_CC) -DQ3_STATIC        
+$(B)/q3static/cg_snapshot.o : $(CGDIR)/cg_snapshot.c; $(DO_CC) -DQ3_STATIC             
+$(B)/q3static/cg_syscalls.o : $(CGDIR)/cg_syscalls.c; $(DO_CC) -DQ3_STATIC        
+$(B)/q3static/cg_view.o : $(CGDIR)/cg_view.c; $(DO_CC) -DQ3_STATIC                     
+$(B)/q3static/cg_weapons.o : $(CGDIR)/cg_weapons.c; $(DO_CC) -DQ3_STATIC 
+
+## add BASEQ3 GAME
+Q3SOBJ += \
+	$(B)/q3static/ai_chat.o \
+	$(B)/q3static/ai_cmd.o \
+	$(B)/q3static/ai_dmnet.o \
+	$(B)/q3static/ai_dmq3.o \
+	$(B)/q3static/ai_main.o \
+	$(B)/q3static/ai_team.o \
+	$(B)/q3static/ai_vcmd.o \
+	$(B)/q3static/g_active.o \
+	$(B)/q3static/g_arenas.o \
+	$(B)/q3static/g_bot.o \
+	$(B)/q3static/g_client.o \
+	$(B)/q3static/g_cmds.o \
+	$(B)/q3static/g_combat.o \
+	$(B)/q3static/g_items.o \
+	$(B)/q3static/g_main.o \
+	$(B)/q3static/g_mem.o \
+	$(B)/q3static/g_misc.o \
+	$(B)/q3static/g_missile.o \
+	$(B)/q3static/g_mover.o \
+	$(B)/q3static/g_session.o \
+	$(B)/q3static/g_spawn.o \
+	$(B)/q3static/g_svcmds.o \
+	$(B)/q3static/g_target.o \
+	$(B)/q3static/g_team.o \
+	$(B)/q3static/g_trigger.o \
+	$(B)/q3static/g_utils.o \
+	$(B)/q3static/g_weapon.o \
+	\
+	$(B)/q3static/g_syscalls.o
+
+$(B)/q3static/ai_chat.o : $(GDIR)/ai_chat.c; $(DO_CC) -DQ3_STATIC     
+$(B)/q3static/ai_cmd.o : $(GDIR)/ai_cmd.c; $(DO_CC) -DQ3_STATIC       
+$(B)/q3static/ai_dmnet.o : $(GDIR)/ai_dmnet.c; $(DO_CC) -DQ3_STATIC   
+$(B)/q3static/ai_dmq3.o : $(GDIR)/ai_dmq3.c; $(DO_CC) -DQ3_STATIC       
+$(B)/q3static/ai_main.o : $(GDIR)/ai_main.c; $(DO_CC) -DQ3_STATIC      
+$(B)/q3static/ai_team.o : $(GDIR)/ai_team.c; $(DO_CC) -DQ3_STATIC     
+$(B)/q3static/ai_vcmd.o : $(GDIR)/ai_vcmd.c; $(DO_CC) -DQ3_STATIC     
+$(B)/q3static/g_active.o : $(GDIR)/g_active.c; $(DO_CC) -DQ3_STATIC       
+$(B)/q3static/g_arenas.o : $(GDIR)/g_arenas.c; $(DO_CC) -DQ3_STATIC       
+$(B)/q3static/g_bot.o : $(GDIR)/g_bot.c; $(DO_CC) -DQ3_STATIC            
+$(B)/q3static/g_client.o : $(GDIR)/g_client.c; $(DO_CC) -DQ3_STATIC      
+$(B)/q3static/g_cmds.o : $(GDIR)/g_cmds.c; $(DO_CC) -DQ3_STATIC          
+$(B)/q3static/g_combat.o : $(GDIR)/g_combat.c; $(DO_CC) -DQ3_STATIC       
+$(B)/q3static/g_items.o : $(GDIR)/g_items.c; $(DO_CC) -DQ3_STATIC          
+$(B)/q3static/g_main.o : $(GDIR)/g_main.c; $(DO_CC) -DQ3_STATIC            
+$(B)/q3static/g_mem.o : $(GDIR)/g_mem.c; $(DO_CC) -DQ3_STATIC               
+$(B)/q3static/g_misc.o : $(GDIR)/g_misc.c; $(DO_CC) -DQ3_STATIC             
+$(B)/q3static/g_missile.o : $(GDIR)/g_missile.c; $(DO_CC) -DQ3_STATIC        
+$(B)/q3static/g_mover.o : $(GDIR)/g_mover.c; $(DO_CC) -DQ3_STATIC          
+$(B)/q3static/g_session.o : $(GDIR)/g_session.c; $(DO_CC) -DQ3_STATIC       
+$(B)/q3static/g_spawn.o : $(GDIR)/g_spawn.c; $(DO_CC) -DQ3_STATIC          
+$(B)/q3static/g_svcmds.o : $(GDIR)/g_svcmds.c; $(DO_CC) -DQ3_STATIC         
+$(B)/q3static/g_syscalls.o : $(GDIR)/g_syscalls.c; $(DO_CC) -DQ3_STATIC    
+$(B)/q3static/g_target.o : $(GDIR)/g_target.c; $(DO_CC) -DQ3_STATIC        
+$(B)/q3static/g_team.o : $(GDIR)/g_team.c; $(DO_CC) -DQ3_STATIC           
+$(B)/q3static/g_trigger.o : $(GDIR)/g_trigger.c; $(DO_CC) -DQ3_STATIC       
+$(B)/q3static/g_utils.o : $(GDIR)/g_utils.c; $(DO_CC) -DQ3_STATIC          
+$(B)/q3static/g_weapon.o : $(GDIR)/g_weapon.c; $(DO_CC) -DQ3_STATIC             
+
+## add BASEQ3 UI
+Q3SOBJ += \
+        $(B)/q3static/ui_addbots.o \
+        $(B)/q3static/ui_atoms.o \
+        $(B)/q3static/ui_cdkey.o \
+        $(B)/q3static/ui_cinematics.o \
+        $(B)/q3static/ui_confirm.o \
+        $(B)/q3static/ui_connect.o \
+        $(B)/q3static/ui_controls2.o \
+        $(B)/q3static/ui_credits.o \
+        $(B)/q3static/ui_demo2.o \
+        $(B)/q3static/ui_display.o \
+        $(B)/q3static/ui_gameinfo.o \
+        $(B)/q3static/ui_ingame.o \
+        $(B)/q3static/ui_loadconfig.o \
+        $(B)/q3static/ui_main.o \
+        $(B)/q3static/ui_menu.o \
+        $(B)/q3static/ui_mfield.o \
+        $(B)/q3static/ui_mods.o \
+        $(B)/q3static/ui_network.o \
+        $(B)/q3static/ui_options.o \
+        $(B)/q3static/ui_playermodel.o \
+        $(B)/q3static/ui_players.o \
+        $(B)/q3static/ui_playersettings.o \
+        $(B)/q3static/ui_preferences.o \
+        $(B)/q3static/ui_qmenu.o \
+        $(B)/q3static/ui_removebots.o \
+        $(B)/q3static/ui_saveconfig.o \
+        $(B)/q3static/ui_serverinfo.o \
+        $(B)/q3static/ui_servers2.o \
+        $(B)/q3static/ui_setup.o \
+        $(B)/q3static/ui_sound.o \
+        $(B)/q3static/ui_sparena.o \
+        $(B)/q3static/ui_specifyserver.o \
+        $(B)/q3static/ui_splevel.o \
+        $(B)/q3static/ui_sppostgame.o \
+        $(B)/q3static/ui_spskill.o \
+        $(B)/q3static/ui_startserver.o \
+        $(B)/q3static/ui_team.o \
+        $(B)/q3static/ui_teamorders.o \
+        $(B)/q3static/ui_video.o \
+	\
+	$(B)/q3static/ui_syscalls.o
+
+$(B)/q3static/ui_addbots.o : $(Q3UIDIR)/ui_addbots.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/ui_atoms.o : $(Q3UIDIR)/ui_atoms.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/ui_cinematics.o : $(Q3UIDIR)/ui_cinematics.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/ui_cdkey.o : $(Q3UIDIR)/ui_cdkey.c; $(DO_CC) -DQ3_STATIC
+$(B)/q3static/ui_confirm.o : $(Q3UIDIR)/ui_confirm.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/ui_connect.o : $(Q3UIDIR)/ui_connect.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/ui_controls2.o : $(Q3UIDIR)/ui_controls2.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/ui_credits.o : $(Q3UIDIR)/ui_credits.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/ui_demo2.o : $(Q3UIDIR)/ui_demo2.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/ui_display.o : $(Q3UIDIR)/ui_display.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/ui_gameinfo.o : $(Q3UIDIR)/ui_gameinfo.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/ui_ingame.o : $(Q3UIDIR)/ui_ingame.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/ui_loadconfig.o : $(Q3UIDIR)/ui_loadconfig.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/ui_main.o : $(Q3UIDIR)/ui_main.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/ui_menu.o : $(Q3UIDIR)/ui_menu.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/ui_mfield.o : $(Q3UIDIR)/ui_mfield.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/ui_mods.o : $(Q3UIDIR)/ui_mods.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/ui_network.o : $(Q3UIDIR)/ui_network.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/ui_options.o : $(Q3UIDIR)/ui_options.c; $(DO_CC) -DQ3_STATIC
+$(B)/q3static/ui_playermodel.o : $(Q3UIDIR)/ui_playermodel.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/ui_players.o : $(Q3UIDIR)/ui_players.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/ui_playersettings.o : $(Q3UIDIR)/ui_playersettings.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/ui_preferences.o : $(Q3UIDIR)/ui_preferences.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/ui_qmenu.o : $(Q3UIDIR)/ui_qmenu.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/ui_quit.o : $(Q3UIDIR)/ui_quit.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/ui_removebots.o : $(Q3UIDIR)/ui_removebots.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/ui_saveconfig.o : $(Q3UIDIR)/ui_saveconfig.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/ui_serverinfo.o : $(Q3UIDIR)/ui_serverinfo.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/ui_servers2.o : $(Q3UIDIR)/ui_servers2.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/ui_setup.o : $(Q3UIDIR)/ui_setup.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/ui_sound.o : $(Q3UIDIR)/ui_sound.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/ui_sparena.o : $(Q3UIDIR)/ui_sparena.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/ui_specifyserver.o : $(Q3UIDIR)/ui_specifyserver.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/ui_splevel.o : $(Q3UIDIR)/ui_splevel.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/ui_sppostgame.o : $(Q3UIDIR)/ui_sppostgame.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/ui_spskill.o : $(Q3UIDIR)/ui_spskill.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/ui_startserver.o : $(Q3UIDIR)/ui_startserver.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/ui_team.o : $(Q3UIDIR)/ui_team.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/ui_teamorders.o : $(Q3UIDIR)/ui_teamorders.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/ui_syscalls.o : $(Q3UIDIR)/ui_syscalls.c; $(DO_CC) -DQ3_STATIC 
+$(B)/q3static/ui_video.o : $(Q3UIDIR)/ui_video.c; $(DO_CC) -DQ3_STATIC 
+
+
+## add shared files
+Q3SOBJ += \
+	$(B)/q3static/bg_misc.o \
+	$(B)/q3static/bg_pmove.o \
+	$(B)/q3static/bg_slidemove.o \
+        $(B)/q3static/q_math.o \
+        $(B)/q3static/q_shared.o
+
+## shared files
+$(B)/q3static/q_math.o : $(GDIR)/q_math.c; $(DO_CC) -DQ3_STATIC               
+$(B)/q3static/q_shared.o : $(GDIR)/q_shared.c; $(DO_CC) -DQ3_STATIC      
+$(B)/q3static/bg_misc.o : $(GDIR)/bg_misc.c; $(DO_CC) -DQ3_STATIC
+$(B)/q3static/bg_pmove.o : $(GDIR)/bg_pmove.c; $(DO_CC) -DQ3_STATIC  
+$(B)/q3static/bg_slidemove.o : $(GDIR)/bg_slidemove.c; $(DO_CC) -DQ3_STATIC    
+
+
+
+$(B)/$(PLATFORM)q3static : $(Q3SOBJ) 
+	$(CC) $(CFLAGS) -o $@ $(Q3SOBJ)  $(GLLDFLAGS) $(LDFLAGS) 
+
+
+#############################################################################
+# RPM
+#############################################################################
+
+TMPDIR=/var/tmp
+TARDIR=$(TMPDIR)/$(BUILD_NAME)
+TARFILE = $(BUILD_NAME)-$(VERSION)-$(RPM_RELEASE).$(ARCH).tar
+
+tar:
+	if [ ! -d archives ];then mkdir archives;chmod 755 archives;fi
+	$(MAKE) copyfiles COPYDIR=$(TARDIR)
+	cd $(TARDIR); tar cvf $(TARFILE) * && gzip -9 $(TARFILE)
+	mv $(TARDIR)/$(TARFILE).gz archives/.
+	rm -rf $(TARDIR)
+
+# Make RPMs.  You need to be root to make this work
+RPMROOT=/usr/src/redhat
+RPM = rpm
+RPMFLAGS = -bb
+INSTALLDIR = /usr/local/games/$(BUILD_NAME)
+RPMDIR = $(TMPDIR)/$(BUILD_NAME)-$(VERSION)
+DESTDIR= $(RPMDIR)/$(INSTALLDIR)
+
+rpm: $(BUILD_NAME).spec
+	touch $(RPMROOT)/SOURCES/$(BUILD_NAME)-$(VERSION).tar.gz
+	if [ ! -d archives ];then mkdir archives;fi
+	$(MAKE) copyfiles COPYDIR=$(DESTDIR)
+	cp $(UDIR)/quake3.gif $(RPMROOT)/SOURCES/.
+	cp $(BUILD_NAME).spec $(RPMROOT)/SPECS/.
+	cd $(RPMROOT)/SPECS; $(RPM) $(RPMFLAGS) $(BUILD_NAME).spec
+	rm -rf $(RPMDIR)
+	mv $(RPMROOT)/RPMS/$(RPMARCH)/$(BUILD_NAME)-$(VERSION)-$(RPM_RELEASE).$(RPMARCH).rpm archives/$(BUILD_NAME)-$(VERSION)-$(RPM_RELEASE).$(RPMARCH).rpm 
+
+copyfiles:
+	-mkdirhier $(COPYDIR)
+	cp $(BR)/linuxquake3 $(COPYDIR)/quake3.x86
+	strip $(COPYDIR)/quake3.x86
+	chmod 755 $(COPYDIR)/quake3.x86
+	cp $(BR)/linuxq3ded $(COPYDIR)/q3ded
+	strip $(COPYDIR)/q3ded
+	chmod 755 $(COPYDIR)/q3ded
+	cp $(BDIR)/libMesaVoodooGL.so.3.2 $(COPYDIR)/.
+	chmod 755 $(COPYDIR)/libMesaVoodooGL.so.3.2
+	( cd $(COPYDIR); ln -s libMesaVoodooGL.so.3.2 libMesaVoodooGL.so )
+	cp $(BDIR)/Quake_III_Arena_FAQ.html $(COPYDIR)/.
+	chmod 644 $(COPYDIR)/Quake_III_Arena_FAQ.html
+	mkdir $(COPYDIR)/baseq3
+	cp $(BASEQ3_DIR)/pak2.pk3 $(COPYDIR)/baseq3/.
+	chmod 644 $(COPYDIR)/baseq3/pak2.pk3
+
+$(BUILD_NAME).spec : $(UDIR)/$(BUILD_NAME).spec.sh Makefile
+	sh $< $(VERSION) $(RPM_RELEASE) $(ARCH) $(INSTALLDIR) > $@
+
+#############################################################################
+# MISC
+#############################################################################
+
+# TTimo: FIXME: doesn't clean the binary and .so
+
+clean:clean-debug clean-release
+
+clean2: clean-bins
+	rm -f $(Q3OBJ) $(Q3POBJ) $(Q3POBJ_SMP) $(Q3DOBJ) $(MPGOBJ) $(Q3GOBJ) $(Q3CGOBJ) $(MPCGOBJ) $(Q3UIOBJ) $(MPUIOBJ)
+	rm -f $(CGDIR)/vm/*.asm
+	rm -f $(GDIR)/vm/*.asm
+	rm -f $(UIDIR)/vm/*.asm
+	rm -f $(Q3UIDIR)/vm/*.asm
+
+# TTimo: linuxq3ded linuxquake3 linuxquake3-smp .. hardcoded the names .. maybe not such a good thing
+# FIXME: also, removing the *.so is crappy .. I just want to avoid rm -rf debugi386-glibc to save the symlinks to pk3's for testing
+clean-bins:
+	if [ -d $(B) ];then (find $(B) -name '*.so' -exec rm {} \;)fi
+	rm -f $(B)/linuxq3ded
+	rm -f $(B)/linuxquake3
+	rm -f $(B)/linuxquake3-smp
+	rm -f $(B)/baseq3/vm/cgame.qvm
+	rm -f $(B)/baseq3/vm/ui.qvm
+	rm -f $(B)/baseq3/vm/qagame.qvm
+	rm -f $(B)/missionpack/vm/cgame.qvm
+	rm -f $(B)/missionpack/vm/qagame.qvm
+	rm -f $(B)/missionpack/vm/ui.qvm
+
+clean-debug:
+	$(MAKE) clean2 B=$(BD) CFLAGS="$(DEBUG_CFLAGS)"
+
+clean-release:
+	$(MAKE) clean2 B=$(BR) CFLAGS="$(DEBUG_CFLAGS)"
+
+#
+# TTimo: the make tar and make rpm don't really fit my needs
+# writing custom hack
+
+DATADIR = /home/timo/Id/Q3SetupMedia/quake3
+
+setup: release $(B)/linuxq3a-$(VERSION).tar.gz
+
+$(B)/linuxq3a-$(VERSION).tar.gz:
+	rm -rf setup
+	mkdir setup
+	cp -R $(DATADIR) setup
+	cp release$(ARCH)-glibc/linuxquake3 setup/quake3/quake3.x86
+	strip setup/quake3/quake3.x86
+	cp release$(ARCH)-glibc/linuxq3ded setup/quake3/q3ded
+	strip setup/quake3/q3ded
+	cd setup; tar cvzf linuxq3a-$(VERSION).tar.gz quake3
+# TTimo: the .so where distributed with 1.27g because of a VM problem that made them break on linux
+#	cp release$(ARCH)-glibc/baseq3/cgame$(ARCH).so setup/quake3/baseq3
+#	cp release$(ARCH)-glibc/baseq3/qagame$(ARCH).so setup/quake3/baseq3
+#	cp release$(ARCH)-glibc/baseq3/ui$(ARCH).so setup/quake3/baseq3
+#	cp release$(ARCH)-glibc/missionpack/cgame$(ARCH).so setup/quake3/missionpack
+#	cp release$(ARCH)-glibc/missionpack/qagame$(ARCH).so setup/quake3/missionpack
+#	cp release$(ARCH)-glibc/missionpack/ui$(ARCH).so setup/quake3/missionpack
+
+# don't redistribute this one!	
+setup-debug: debug $(B)/linuxq3a-$(VERSION)-DEBUG.tar.gz
+
+$(B)/linuxq3a-$(VERSION)-DEBUG.tar.gz:
+	rm -rf setup-debug
+	mkdir setup-debug
+	cp -R $(DATADIR) setup-debug
+	cp debug$(ARCH)-glibc/linuxquake3 setup-debug/quake3/quake3.x86
+	cp debug$(ARCH)-glibc/linuxq3ded setup-debug/quake3/q3ded
+	cp debug$(ARCH)-glibc/baseq3/cgame$(ARCH).so setup-debug/quake3/baseq3
+	cp debug$(ARCH)-glibc/baseq3/qagame$(ARCH).so setup-debug/quake3/baseq3
+	cp debug$(ARCH)-glibc/baseq3/ui$(ARCH).so setup-debug/quake3/baseq3
+	cp debug$(ARCH)-glibc/missionpack/cgame$(ARCH).so setup-debug/quake3/missionpack
+	cp debug$(ARCH)-glibc/missionpack/qagame$(ARCH).so setup-debug/quake3/missionpack
+	cp debug$(ARCH)-glibc/missionpack/ui$(ARCH).so setup-debug/quake3/missionpack
+	cd setup-debug; tar cvzf linuxq3a-$(VERSION)-DEBUG.tar.gz quake3
+	
+## temps
+# NOTE: not referenced
+
+dcp:
+	cp debug$(ARCH)-glibc/linuxquake3 $(TESTDIR)/quake3-$(VERSION)-debug.$(ARCH)
+	cp debug$(ARCH)-glibc/linuxq3ded $(TESTDIR)/q3ded-$(VERSION)-debug.$(ARCH)
+	cp debug$(ARCH)-glibc/baseq3/cgame$(ARCH).so $(TESTDIR)/baseq3/cgame$(ARCH)-debug.so
+	cp debug$(ARCH)-glibc/baseq3/qagame$(ARCH).so $(TESTDIR)/baseq3/qagame$(ARCH)-debug.so
+	cp debug$(ARCH)-glibc/baseq3/ui$(ARCH).so $(TESTDIR)/baseq3/ui$(ARCH)-debug.so
+	cp debug$(ARCH)-glibc/missionpack/cgame$(ARCH).so $(TESTDIR)/missionpack/cgame$(ARCH)-debug.so
+	cp debug$(ARCH)-glibc/missionpack/qagame$(ARCH).so $(TESTDIR)/missionpack/qagame$(ARCH)-debug.so
+	cp debug$(ARCH)-glibc/missionpack/ui$(ARCH).so $(TESTDIR)/missionpack/ui$(ARCH)-debug.so
+	cp debug$(ARCH)-glibc/baseq3/vm/*.qvm $(TESTDIR)/baseq3/vm/
+	cp debug$(ARCH)-glibc/missionpack/vm/*.qvm $(TESTDIR)/missionpack/vm/
+
+rcp:
+	cp release$(ARCH)-glibc/linuxquake3 $(TESTDIR)/quake3-$(VERSION).$(ARCH)
+	cp release$(ARCH)-glibc/linuxq3ded $(TESTDIR)/q3ded-$(VERSION).$(ARCH)
+	cp release$(ARCH)-glibc/baseq3/cgame$(ARCH).so $(TESTDIR)/baseq3/cgame$(ARCH).so
+	cp release$(ARCH)-glibc/baseq3/qagame$(ARCH).so $(TESTDIR)/baseq3/qagame$(ARCH).so
+	cp release$(ARCH)-glibc/baseq3/ui$(ARCH).so $(TESTDIR)/baseq3/ui$(ARCH).so
+	cp release$(ARCH)-glibc/missionpack/cgame$(ARCH).so $(TESTDIR)/missionpack/cgame$(ARCH).so
+	cp release$(ARCH)-glibc/missionpack/qagame$(ARCH).so $(TESTDIR)/missionpack/qagame$(ARCH).so
+	cp release$(ARCH)-glibc/missionpack/ui$(ARCH).so $(TESTDIR)/missionpack/ui$(ARCH).so
+	cp release$(ARCH)-glibc/baseq3/vm/*.qvm $(TESTDIR)/baseq3/vm/
+	cp release$(ARCH)-glibc/missionpack/vm/*.qvm $(TESTDIR)/missionpack/vm/
diff --git a/codemp/unix/snapvector.nasm b/codemp/unix/snapvector.nasm
new file mode 100644
index 0000000..705f3d3
--- /dev/null
+++ b/codemp/unix/snapvector.nasm
@@ -0,0 +1,75 @@
+;
+; Sys_SnapVector NASM code (Andrew Henderson)
+; See win32/win_shared.c for the Win32 equivalent
+; This code is provided to ensure that the
+;  rounding behavior (and, if necessary, the
+;  precision) of DLL and QVM code are identical
+;  e.g. for network-visible operations.
+; See ftol.nasm for operations on a single float,
+;  as used in compiled VM and DLL code that does
+;  not use this system trap.
+;
+
+
+segment .data
+
+fpucw	dd	0
+cw037F  dd 0x037F   ; Rounding to nearest (even). 
+
+segment .text
+
+; void Sys_SnapVector( float *v )
+global Sys_SnapVector
+Sys_SnapVector:
+	push 	eax
+	push 	ebp
+	mov	ebp, esp
+
+	fnstcw	[fpucw]
+	mov	eax, dword [ebp + 12]
+	fldcw	[cw037F]	
+	fld	dword [eax]
+	fistp	dword [eax]
+	fild	dword [eax]
+	fstp	dword [eax]
+	fld	dword [eax + 4]
+	fistp	dword [eax + 4]
+	fild	dword [eax + 4]
+	fstp	dword [eax + 4]
+	fld	dword [eax + 8]
+	fistp	dword [eax + 8]
+	fild	dword [eax + 8]
+	fstp	dword [eax + 8]
+	fldcw	[fpucw]
+	
+	pop ebp
+	pop eax
+	ret
+	
+; void Sys_SnapVectorCW( float *v, unsigned short int cw )
+global Sys_SnapVectorCW
+Sys_SnapVector_cw:
+	push 	eax
+	push 	ebp
+	mov	ebp, esp
+
+	fnstcw	[fpucw]
+	mov	eax, dword [ebp + 12]
+	fldcw	[ebp + 16]	
+	fld	dword [eax]
+	fistp	dword [eax]
+	fild	dword [eax]
+	fstp	dword [eax]	
+	fld	dword [eax + 4]
+	fistp	dword [eax + 4]
+	fild	dword [eax + 4]
+	fstp	dword [eax + 4]
+	fld	dword [eax + 8]
+	fistp	dword [eax + 8]
+	fild	dword [eax + 8]
+	fstp	dword [eax + 8]
+	fldcw	[fpucw]
+	
+	pop ebp
+	pop eax
+	ret
\ No newline at end of file
diff --git a/codemp/unix/unix_main.c b/codemp/unix/unix_main.c
new file mode 100644
index 0000000..8d58b9b
--- /dev/null
+++ b/codemp/unix/unix_main.c
@@ -0,0 +1,1164 @@
+#include <unistd.h>
+#include <signal.h>
+#include <stdlib.h>
+#include <limits.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <sys/ipc.h>
+#include <sys/shm.h>
+#include <sys/stat.h>
+#include <string.h>
+#include <ctype.h>
+#include <sys/wait.h>
+#include <sys/mman.h>
+#include <errno.h>
+#ifdef __linux__ // rb010123
+#include <mntent.h>
+#endif
+#include <dlfcn.h>
+
+#ifdef __linux__
+#include <fpu_control.h> // bk001213 - force dumps on divide by zero
+#endif
+
+
+#include "../game/q_shared.h"
+#include "../qcommon/qcommon.h"
+#include "../renderer/tr_public.h"
+
+#include "linux_local.h" // bk001204
+
+cvar_t *nostdout;
+
+// Structure containing functions exported from refresh DLL
+refexport_t	re;
+
+unsigned	sys_frame_time;
+
+uid_t saved_euid;
+qboolean stdin_active = qtrue;
+
+// =======================================================================
+// General routines
+// =======================================================================
+
+// bk001207 
+#define MEM_THRESHOLD 96*1024*1024
+/*
+==================
+Sys_LowPhysicalMemory()
+==================
+*/
+qboolean Sys_LowPhysicalMemory() {
+  //MEMORYSTATUS stat;
+  //GlobalMemoryStatus (&stat);
+  //return (stat.dwTotalPhys <= MEM_THRESHOLD) ? qtrue : qfalse;
+  return qfalse; // bk001207 - FIXME
+}
+
+/*
+==================
+Sys_FunctionCmp
+==================
+*/
+int Sys_FunctionCmp(void *f1, void *f2) {
+	return qtrue;
+}
+
+/*
+==================
+Sys_FunctionCheckSum
+==================
+*/
+int Sys_FunctionCheckSum(void *f1) {
+	return 0;
+}
+
+/*
+==================
+Sys_MonkeyShouldBeSpanked
+==================
+*/
+int Sys_MonkeyShouldBeSpanked( void ) {
+	return 0;
+}
+
+void Sys_BeginProfiling( void ) {
+}
+
+/*
+=================
+Sys_In_Restart_f
+
+Restart the input subsystem
+=================
+*/
+void Sys_In_Restart_f( void ) 
+{
+	IN_Shutdown();
+	IN_Init();
+}
+
+void Sys_ConsoleOutput (char *string)
+{
+	if (nostdout && nostdout->value)
+		return;
+
+	fputs(string, stdout);
+}
+
+void Sys_Printf (char *fmt, ...)
+{
+	va_list		argptr;
+	char		text[1024];
+	unsigned char		*p;
+
+	va_start (argptr,fmt);
+	vsprintf (text,fmt,argptr);
+	va_end (argptr);
+
+	if (strlen(text) > sizeof(text))
+		Sys_Error("memory overwrite in Sys_Printf");
+
+    if (nostdout && nostdout->value)
+        return;
+
+	for (p = (unsigned char *)text; *p; p++) {
+		*p &= 0x7f;
+		if ((*p > 128 || *p < 32) && *p != 10 && *p != 13 && *p != 9)
+			printf("[%02x]", *p);
+		else
+			putc(*p, stdout);
+	}
+}
+
+// bk010104 - added for abstraction
+void Sys_Exit( int ex ) {
+#ifdef NDEBUG // regular behavior
+  // We can't do this 
+  //  as long as GL DLL's keep installing with atexit...
+  //exit(ex);
+  _exit(ex);
+#else
+  // Give me a backtrace on error exits.
+  assert( ex == 0 );
+  exit(ex);
+#endif
+}
+
+
+void Sys_Quit (void) {
+  CL_Shutdown ();
+  fcntl (0, F_SETFL, fcntl (0, F_GETFL, 0) & ~FNDELAY);
+  Sys_Exit(0);
+}
+
+void Sys_Init(void)
+{
+	Cmd_AddCommand ("in_restart", Sys_In_Restart_f);
+
+#if defined __linux__
+#if defined __i386__
+	Cvar_Set( "arch", "linux i386" );
+#elif defined __alpha__
+	Cvar_Set( "arch", "linux alpha" );
+#elif defined __sparc__
+	Cvar_Set( "arch", "linux sparc" );
+#elif defined __FreeBSD__
+
+#if defined __i386__ // FreeBSD
+        Cvar_Set( "arch", "freebsd i386" );
+#elif defined __alpha__
+        Cvar_Set( "arch", "freebsd alpha" );
+#else
+        Cvar_Set( "arch", "freebsd unknown" );
+#endif // FreeBSD
+
+#else
+	Cvar_Set( "arch", "linux unknown" );
+#endif
+#elif defined __sun__
+#if defined __i386__
+	Cvar_Set( "arch", "solaris x86" );
+#elif defined __sparc__
+	Cvar_Set( "arch", "solaris sparc" );
+#else
+	Cvar_Set( "arch", "solaris unknown" );
+#endif
+#elif defined __sgi__
+#if defined __mips__
+	Cvar_Set( "arch", "sgi mips" );
+#else
+	Cvar_Set( "arch", "sgi unknown" );
+#endif
+#else
+	Cvar_Set( "arch", "unknown" );
+#endif
+
+	Cvar_Set( "username", Sys_GetCurrentUser() );
+
+	IN_Init();
+
+}
+
+void	Sys_Error( const char *error, ...)
+{ 
+    va_list     argptr;
+    char        string[1024];
+
+	// change stdin to non blocking
+    fcntl (0, F_SETFL, fcntl (0, F_GETFL, 0) & ~FNDELAY);
+
+    CL_Shutdown ();
+    
+    va_start (argptr,error);
+    vsprintf (string,error,argptr);
+    va_end (argptr);
+    fprintf(stderr, "Sys_Error: %s\n", string);
+    
+    Sys_Exit( 1 ); // bk010104 - use single exit point.
+} 
+
+void Sys_Warn (char *warning, ...)
+{ 
+    va_list     argptr;
+    char        string[1024];
+    
+    va_start (argptr,warning);
+    vsprintf (string,warning,argptr);
+    va_end (argptr);
+	fprintf(stderr, "Warning: %s", string);
+} 
+
+/*
+============
+Sys_FileTime
+
+returns -1 if not present
+============
+*/
+int	Sys_FileTime (char *path)
+{
+	struct	stat	buf;
+	
+	if (stat (path,&buf) == -1)
+		return -1;
+	
+	return buf.st_mtime;
+}
+
+void floating_point_exception_handler(int whatever)
+{
+	signal(SIGFPE, floating_point_exception_handler);
+}
+
+char *Sys_ConsoleInput(void)
+{
+    static char text[256];
+    int     len;
+	fd_set	fdset;
+    struct timeval timeout;
+
+	if (!com_dedicated || !com_dedicated->value)
+		return NULL;
+
+	if (!stdin_active)
+		return NULL;
+
+	FD_ZERO(&fdset);
+	FD_SET(0, &fdset); // stdin
+	timeout.tv_sec = 0;
+	timeout.tv_usec = 0;
+	if (select (1, &fdset, NULL, NULL, &timeout) == -1 || !FD_ISSET(0, &fdset))
+		return NULL;
+
+	len = read (0, text, sizeof(text));
+	if (len == 0) { // eof!
+		stdin_active = qfalse;
+		return NULL;
+	}
+
+	if (len < 1)
+		return NULL;
+	text[len-1] = 0;    // rip off the /n and terminate
+
+	return text;
+}
+
+/*****************************************************************************/
+
+/*
+=================
+Sys_UnloadDll
+
+=================
+*/
+void Sys_UnloadDll( void *dllHandle ) {
+  // bk001206 - verbose error reporting
+  const char* err; // rb010123 - now const
+  if ( !dllHandle ) {
+    Com_Printf("Sys_UnloadDll(NULL)\n");
+    return;
+  }
+  dlclose( dllHandle );
+  err = dlerror();
+  if ( err != NULL )
+    Com_Printf ( "Sys_UnloadGame failed on dlclose: \"%s\"!\n", err );
+}
+
+
+/*
+=================
+Sys_LoadDll
+
+Used to load a development dll instead of a virtual machine
+=================
+*/
+extern char		*FS_BuildOSPath( const char *base, const char *game, const char *qpath );
+
+void *Sys_LoadDll( const char *name, 
+		   int (**entryPoint)(int, ...),
+		   int (*systemcalls)(int, ...) ) 
+{
+  void *libHandle;
+  void	(*dllEntry)( int (*syscallptr)(int, ...) );
+  char	curpath[MAX_OSPATH];
+  char	fname[MAX_OSPATH];
+  //char	loadname[MAX_OSPATH];
+  char	*basepath;
+  char	*cdpath;
+  char	*gamedir;
+  char	*fn;
+  const char*  err = NULL; // bk001206 // rb0101023 - now const
+
+  // bk001206 - let's have some paranoia
+  assert( name );
+
+  getcwd(curpath, sizeof(curpath));
+#if defined __i386__
+#ifndef NDEBUG
+  snprintf (fname, sizeof(fname), "%si386-debug.so", name); // bk010205 - different DLL name
+#else
+  snprintf (fname, sizeof(fname), "%si386.so", name);
+#endif
+#elif defined __powerpc__   //rcg010207 - PPC support.
+  snprintf (fname, sizeof(fname), "%sppc.so", name);
+#elif defined __axp__
+  snprintf (fname, sizeof(fname), "%saxp.so", name);
+#elif defined __mips__
+  snprintf (fname, sizeof(fname), "%smips.so", name);
+#else
+#error Unknown arch
+#endif
+
+// bk001129 - was RTLD_LAZY 
+#define Q_RTLD    RTLD_NOW
+
+#if 0 // bk010205 - was NDEBUG // bk001129 - FIXME: what is this good for?
+  // bk001206 - do not have different behavior in builds
+  Q_strncpyz(loadname, curpath, sizeof(loadname));
+  // bk001129 - from cvs1.17 (mkv)
+  Q_strcat(loadname, sizeof(loadname), "/");
+  
+  Q_strcat(loadname, sizeof(loadname), fname);
+  Com_Printf( "Sys_LoadDll(%s)... \n", loadname );
+  libHandle = dlopen( loadname, Q_RTLD );
+  //if ( !libHandle ) {
+  // bk001206 - report any problem
+  //Com_Printf( "Sys_LoadDll(%s) failed: \"%s\"\n", loadname, dlerror() );
+#endif // bk010205 - do not load from installdir
+
+  basepath = Cvar_VariableString( "fs_basepath" );
+  cdpath = Cvar_VariableString( "fs_cdpath" );
+  gamedir = Cvar_VariableString( "fs_game" );
+  
+  fn = FS_BuildOSPath( basepath, gamedir, fname );
+  // bk001206 - verbose
+  Com_Printf( "Sys_LoadDll(%s)... \n", fn );
+  
+  // bk001129 - from cvs1.17 (mkv), was fname not fn
+  libHandle = dlopen( fn, Q_RTLD );
+  
+  if ( !libHandle ) {
+    if( cdpath[0] ) {
+      // bk001206 - report any problem
+      Com_Printf( "Sys_LoadDll(%s) failed: \"%s\"\n", fn, dlerror() );
+      
+      fn = FS_BuildOSPath( cdpath, gamedir, fname );
+      libHandle = dlopen( fn, Q_RTLD );
+      if ( !libHandle ) {
+	// bk001206 - report any problem
+	Com_Printf( "Sys_LoadDll(%s) failed: \"%s\"\n", fn, dlerror() );
+      }
+      else
+	Com_Printf ( "Sys_LoadDll(%s): succeeded ...\n", fn );
+    }
+    else
+      Com_Printf ( "Sys_LoadDll(%s): succeeded ...\n", fn );
+    
+    if ( !libHandle ) {
+#ifdef NDEBUG // bk001206 - in debug abort on failure
+      Com_Error ( ERR_FATAL, "Sys_LoadDll(%s) failed dlopen() completely!\n", name  );
+#else
+      Com_Printf ( "Sys_LoadDll(%s) failed dlopen() completely!\n", name );
+#endif
+      return NULL;
+    }
+  }
+  // bk001206 - no different behavior
+  //#ifndef NDEBUG }
+  //else Com_Printf ( "Sys_LoadDll(%s): succeeded ...\n", loadname );
+  //#endif
+
+  dllEntry = (void (*)(int (*)(int,...))) dlsym( libHandle, "dllEntry" ); 
+  *entryPoint = (int(*)(int,...))dlsym( libHandle, "vmMain" );
+  if ( !*entryPoint || !dllEntry ) {
+    err = dlerror();
+#ifdef NDEBUG // bk001206 - in debug abort on failure
+    Com_Error ( ERR_FATAL, "Sys_LoadDll(%s) failed dlsym(vmMain): \"%s\" !\n", name, err );
+#else
+    Com_Printf ( "Sys_LoadDll(%s) failed dlsym(vmMain): \"%s\" !\n", name, err );
+#endif
+    dlclose( libHandle );
+    err = dlerror();
+    if ( err != NULL )
+      Com_Printf ( "Sys_LoadDll(%s) failed dlcose: \"%s\"\n", name, err );
+    return NULL;
+  }
+  Com_Printf ( "Sys_LoadDll(%s) found **vmMain** at  %p  \n", name, *entryPoint ); // bk001212
+  dllEntry( systemcalls );
+  Com_Printf ( "Sys_LoadDll(%s) succeeded!\n", name );
+  return libHandle;
+}
+
+
+#if 0 // bk010215 - scheduled for full deletion
+/*****************************************************************************/
+
+static void *game_library;
+
+#ifdef __i386__
+	const char *gamename = "qagamei386.so";
+#elif defined __alpha__
+	const char *gamename = "qagameaxp.so";
+#elif defined __mips__
+	const char *gamename = "qagamemips.so";
+#else
+#error Unknown arch
+#endif
+
+/*
+=================
+Sys_UnloadGame
+=================
+*/
+void Sys_UnloadGame (void) {
+  // bk001206 - this code is never used
+  assert(0);
+
+  Com_Printf("------ Unloading %s ------\n", gamename);
+  if (game_library) {
+    dlclose (game_library);
+    game_library = NULL;
+  }
+}
+
+/*
+=================
+Sys_GetGameAPI
+
+Loads the game dll
+=================
+*/
+void *Sys_GetGameAPI (void *parms)
+{
+	void	*(*GetGameAPI) (void *);
+
+	char	name[MAX_OSPATH];
+	char	curpath[MAX_OSPATH];
+	//char	*path; // bk001204 - unused
+
+  // bk001206 - this code is never used
+  assert(0);
+
+	if (game_library)
+		Com_Error (ERR_FATAL, "Sys_GetGameAPI without Sys_UnloadingGame");
+
+	// check the current debug directory first for development purposes
+	getcwd(curpath, sizeof(curpath));
+
+	Com_Printf("------- Loading %s -------\n", gamename);
+	Com_sprintf (name, sizeof(name), "%s/%s", curpath, gamename);
+
+	game_library = dlopen (name, RTLD_LAZY );
+	if (game_library)
+		Com_DPrintf ("LoadLibrary (%s)\n",name);
+	else {
+		Com_Printf( "LoadLibrary(\"%s\") failed\n", name);
+		Com_Printf( "...reason: '%s'\n", dlerror() );
+		Com_Error( ERR_FATAL, "Couldn't load game" );
+	}
+
+	GetGameAPI = (void *)dlsym (game_library, "GetGameAPI");
+	if (!GetGameAPI)
+	{
+		Sys_UnloadGame ();		
+		return NULL;
+	}
+
+	return GetGameAPI (parms);
+}
+
+/*****************************************************************************/
+
+static void *cgame_library;
+
+/*
+=================
+Sys_UnloadGame
+=================
+*/
+void Sys_UnloadCGame (void)
+{
+  // bk001206 - this code is never used
+  assert(0);
+	if (cgame_library) 
+		dlclose (cgame_library);
+	cgame_library = NULL;
+}
+
+/*
+=================
+Sys_GetGameAPI
+
+Loads the game dll
+=================
+*/
+void *Sys_GetCGameAPI (void)
+{
+	void	*(*api) (void);
+
+	char	name[MAX_OSPATH];
+	char	curpath[MAX_OSPATH];
+#ifdef __i386__
+	const char *cgamename = "cgamei386.so";
+#elif defined __alpha__
+	const char *cgamename = "cgameaxp.so";
+#elif defined __mips__
+	const char *cgamename = "cgamemips.so";
+#else
+#error Unknown arch
+#endif
+
+  // bk001206 - this code is never used
+  assert(0);
+
+	Sys_UnloadCGame();
+
+	getcwd(curpath, sizeof(curpath));
+
+	Com_Printf("------- Loading %s -------\n", cgamename);
+
+	sprintf (name, "%s/%s", curpath, cgamename);
+	cgame_library = dlopen (name, RTLD_LAZY );
+	if (!cgame_library)
+	{
+		Com_Printf ("LoadLibrary (%s)\n",name);
+		Com_Error( ERR_FATAL, "Couldn't load cgame: %s", dlerror() );
+	}
+
+	api = (void *)dlsym (cgame_library, "GetCGameAPI");
+	if (!api)
+	{
+		Com_Error( ERR_FATAL, "dlsym() failed on GetCGameAPI" );
+	}
+
+	return api();
+}
+
+/*****************************************************************************/
+
+static void *ui_library;
+
+/*
+=================
+Sys_UnloadUI
+=================
+*/
+void Sys_UnloadUI(void)
+{
+  // bk001206 - this code is never used
+  assert(0);
+	if (ui_library) 
+		dlclose (ui_library);
+	ui_library = NULL;
+}
+
+/*
+=================
+Sys_GetUIAPI
+
+Loads the ui dll
+=================
+*/
+void *Sys_GetUIAPI (void)
+{
+	void	*(*api)(void);
+
+	char	name[MAX_OSPATH];
+	char	curpath[MAX_OSPATH];
+#ifdef __i386__
+	const char *uiname = "uii386.so";
+#elif defined __alpha__
+	const char *uiname = "uiaxp.so";
+#elif defined __mips__
+	const char *uiname = "uimips.so";
+#else
+#error Unknown arch
+#endif
+
+	// bk001206 - this code is never used
+	assert(0);
+	Sys_UnloadUI();
+
+	getcwd(curpath, sizeof(curpath));
+
+	Com_Printf("------- Loading %s -------\n", uiname);
+
+	sprintf (name, "%s/%s", curpath, uiname);
+	ui_library = dlopen (name, RTLD_LAZY );
+	if (!ui_library)
+	{
+		Com_Printf ("LoadLibrary (%s)\n",name);
+		Com_Error( ERR_FATAL, "Couldn't load ui: %s", dlerror() );
+	}
+
+	api = (void *(*)(void))dlsym (ui_library, "GetUIAPI");
+	if (!api)
+	{
+		Com_Error( ERR_FATAL, "dlsym() failed on GetUIAPI" );
+	}
+
+	return api();
+}
+
+/*****************************************************************************/
+
+static void *botlib_library;
+
+/*
+=================
+Sys_UnloadGame
+=================
+*/
+void Sys_UnloadBotLib (void)
+{
+  // bk001206 - this code is never used
+  assert(0);
+	if (botlib_library) 
+		dlclose (botlib_library);
+	botlib_library = NULL;
+}
+
+/*
+=================
+Sys_GetGameAPI
+
+Loads the game dll
+=================
+*/
+void *Sys_GetBotLibAPI (void *parms )
+{
+	void	*(*GetBotLibAPI) (void *);
+	char	name[MAX_OSPATH];
+	char	curpath[MAX_OSPATH];
+#ifdef __i386__
+	const char *botlibname = "qaboti386.so";
+#elif defined __alpha__
+	const char *botlibname = "qabotaxp.so";
+#elif defined __mips__
+	const char *botlibname = "qabotmips.so";
+#else
+#error Unknown arch
+#endif
+	// bk001129 - this code is never used
+	assert(0);
+
+	Sys_UnloadBotLib();
+      
+	getcwd(curpath, sizeof(curpath));
+
+	Com_Printf("------- Loading %s -------\n", botlibname);
+    
+	sprintf (name, "%s/%s", curpath, botlibname);\
+	// bk001129 - was  RTLD_LAZY
+	botlib_library = dlopen (name, RTLD_NOW );
+	if (!botlib_library)
+	{
+		Com_Printf ("LoadLibrary (%s)\n",name);
+		Com_Error( ERR_FATAL, "Couldn't load botlib: %s", dlerror() );
+	}
+
+	GetBotLibAPI = (void *)dlsym (botlib_library, "GetBotLibAPI");
+	if (!GetBotLibAPI)
+	{
+		Sys_UnloadBotLib ();
+		Com_Error( ERR_FATAL, "dlsym() failed on GetBotLibAPI" );
+	}
+
+	// bk001129 - this is a signature mismatch
+	return GetBotLibAPI (parms);
+}
+
+void *Sys_GetBotAIAPI (void *parms ) {
+	return NULL;
+}
+
+/*****************************************************************************/
+#endif // bk010215
+
+
+/*
+========================================================================
+
+BACKGROUND FILE STREAMING
+
+========================================================================
+*/
+
+#if 1
+
+void Sys_InitStreamThread( void ) {
+}
+
+void Sys_ShutdownStreamThread( void ) {
+}
+
+void Sys_BeginStreamedFile( fileHandle_t f, int readAhead ) {
+}
+
+void Sys_EndStreamedFile( fileHandle_t f ) {
+}
+
+int Sys_StreamedRead( void *buffer, int size, int count, fileHandle_t f ) {
+   return FS_Read( buffer, size * count, f );
+}
+
+void Sys_StreamSeek( fileHandle_t f, int offset, int origin ) {
+   FS_Seek( f, offset, origin );
+}
+
+#else
+
+typedef struct {
+	fileHandle_t file;
+	byte	*buffer;
+	qboolean	eof;
+	int		bufferSize;
+	int		streamPosition;	// next byte to be returned by Sys_StreamRead
+	int		threadPosition;	// next byte to be read from file
+} streamState_t;
+
+streamState_t	stream;
+
+/*
+===============
+Sys_StreamThread
+
+A thread will be sitting in this loop forever
+================
+*/
+void Sys_StreamThread( void ) 
+{
+	int		buffer;
+	int		count;
+	int		readCount;
+	int		bufferPoint;
+	int		r;
+
+	// if there is any space left in the buffer, fill it up
+	if ( !stream.eof ) {
+		count = stream.bufferSize - (stream.threadPosition - stream.streamPosition);
+		if ( count ) {
+			bufferPoint = stream.threadPosition % stream.bufferSize;
+			buffer = stream.bufferSize - bufferPoint;
+			readCount = buffer < count ? buffer : count;
+			r = FS_Read ( stream.buffer + bufferPoint, readCount, stream.file );
+			stream.threadPosition += r;
+
+			if ( r != readCount )
+				stream.eof = qtrue;
+		}
+	}
+}
+
+/*
+===============
+Sys_InitStreamThread
+
+================
+*/
+void Sys_InitStreamThread( void ) 
+{
+}
+
+/*
+===============
+Sys_ShutdownStreamThread
+
+================
+*/
+void Sys_ShutdownStreamThread( void ) 
+{
+}
+
+
+/*
+===============
+Sys_BeginStreamedFile
+
+================
+*/
+void Sys_BeginStreamedFile( fileHandle_t f, int readAhead ) 
+{
+	if ( stream.file ) {
+		Com_Error( ERR_FATAL, "Sys_BeginStreamedFile: unclosed stream");
+	}
+
+	stream.file = f;
+	stream.buffer = Z_Malloc( readAhead,TAG_FILESYS,qfalse );
+	stream.bufferSize = readAhead;
+	stream.streamPosition = 0;
+	stream.threadPosition = 0;
+	stream.eof = qfalse;
+}
+
+/*
+===============
+Sys_EndStreamedFile
+
+================
+*/
+void Sys_EndStreamedFile( fileHandle_t f ) 
+{
+	if ( f != stream.file ) {
+		Com_Error( ERR_FATAL, "Sys_EndStreamedFile: wrong file");
+	}
+
+	stream.file = 0;
+	Z_Free( stream.buffer );
+}
+
+
+/*
+===============
+Sys_StreamedRead
+
+================
+*/
+int Sys_StreamedRead( void *buffer, int size, int count, fileHandle_t f ) 
+{
+	int		available;
+	int		remaining;
+	int		sleepCount;
+	int		copy;
+	int		bufferCount;
+	int		bufferPoint;
+	byte	*dest;
+
+	dest = (byte *)buffer;
+	remaining = size * count;
+
+	if ( remaining <= 0 ) {
+		Com_Error( ERR_FATAL, "Streamed read with non-positive size" );
+	}
+
+	sleepCount = 0;
+	while ( remaining > 0 ) {
+		available = stream.threadPosition - stream.streamPosition;
+		if ( !available ) {
+			if (stream.eof)
+				break;
+			Sys_StreamThread();
+			continue;
+		}
+
+		bufferPoint = stream.streamPosition % stream.bufferSize;
+		bufferCount = stream.bufferSize - bufferPoint;
+
+		copy = available < bufferCount ? available : bufferCount;
+		if ( copy > remaining ) {
+			copy = remaining;
+		}
+		memcpy( dest, stream.buffer + bufferPoint, copy );
+		stream.streamPosition += copy;
+		dest += copy;
+		remaining -= copy;
+	}
+
+	return (count * size - remaining) / size;
+}
+
+/*
+===============
+Sys_StreamSeek
+
+================
+*/
+void Sys_StreamSeek( fileHandle_t f, int offset, int origin ) {
+	// clear to that point
+	FS_Seek( f, offset, origin );
+	stream.streamPosition = 0;
+	stream.threadPosition = 0;
+	stream.eof = qfalse;
+}
+
+#endif
+
+/*
+========================================================================
+
+EVENT LOOP
+
+========================================================================
+*/
+
+// bk000306: upped this from 64
+#define	MAX_QUED_EVENTS		256
+#define	MASK_QUED_EVENTS	( MAX_QUED_EVENTS - 1 )
+
+sysEvent_t	eventQue[MAX_QUED_EVENTS];
+// bk000306: initialize
+int		eventHead = 0;
+int             eventTail = 0;
+byte		sys_packetReceived[MAX_MSGLEN];
+
+/*
+================
+Sys_QueEvent
+
+A time of 0 will get the current time
+Ptr should either be null, or point to a block of data that can
+be freed by the game later.
+================
+*/
+void Sys_QueEvent( int time, sysEventType_t type, int value, int value2, int ptrLength, void *ptr ) {
+	sysEvent_t	*ev;
+
+	ev = &eventQue[ eventHead & MASK_QUED_EVENTS ];
+
+	// bk000305 - was missing
+	if ( eventHead - eventTail >= MAX_QUED_EVENTS ) {
+	  Com_Printf("Sys_QueEvent: overflow\n");
+	  // we are discarding an event, but don't leak memory
+	  if ( ev->evPtr ) {
+	    Z_Free( ev->evPtr );
+	  }
+	  eventTail++;
+	}
+
+	eventHead++;
+
+	if ( time == 0 ) {
+		time = Sys_Milliseconds();
+	}
+
+	ev->evTime = time;
+	ev->evType = type;
+	ev->evValue = value;
+	ev->evValue2 = value2;
+	ev->evPtrLength = ptrLength;
+	ev->evPtr = ptr;
+}
+
+/*
+================
+Sys_GetEvent
+
+================
+*/
+sysEvent_t Sys_GetEvent( void ) {
+	sysEvent_t	ev;
+	char		*s;
+	msg_t		netmsg;
+	netadr_t	adr;
+
+	// return if we have data
+	if ( eventHead > eventTail ) {
+		eventTail++;
+		return eventQue[ ( eventTail - 1 ) & MASK_QUED_EVENTS ];
+	}
+
+	// pump the message loop
+	// in vga this calls KBD_Update, under X, it calls GetEvent
+	Sys_SendKeyEvents ();
+
+	// check for console commands
+	s = Sys_ConsoleInput();
+	if ( s ) {
+		char	*b;
+		int		len;
+
+		len = strlen( s ) + 1;
+		b = (char *)Z_Malloc( len,TAG_EVENT,qfalse );
+		strcpy( b, s );
+		Sys_QueEvent( 0, SE_CONSOLE, 0, 0, len, b );
+	}
+
+	// check for other input devices
+	IN_Frame();
+
+	// check for network packets
+	MSG_Init( &netmsg, sys_packetReceived, sizeof( sys_packetReceived ) );
+	if ( Sys_GetPacket ( &adr, &netmsg ) ) {
+		netadr_t		*buf;
+		int				len;
+
+		// copy out to a seperate buffer for qeueing
+		len = sizeof( netadr_t ) + netmsg.cursize;
+		buf = (netadr_t *)Z_Malloc( len,TAG_EVENT,qfalse );
+		*buf = adr;
+		memcpy( buf+1, netmsg.data, netmsg.cursize );
+		Sys_QueEvent( 0, SE_PACKET, 0, 0, len, buf );
+	}
+
+	// return if we have data
+	if ( eventHead > eventTail ) {
+		eventTail++;
+		return eventQue[ ( eventTail - 1 ) & MASK_QUED_EVENTS ];
+	}
+
+	// create an empty event to return
+
+	memset( &ev, 0, sizeof( ev ) );
+	ev.evTime = Sys_Milliseconds();
+
+	return ev;
+}
+
+/*****************************************************************************/
+
+qboolean Sys_CheckCD( void ) {
+	return qtrue;
+}
+
+void Sys_AppActivate (void)
+{
+}
+
+char *Sys_GetClipboardData(void)
+{
+	return NULL;
+}
+
+void	Sys_Print( const char *msg )
+{
+	fputs(msg, stderr);
+}
+
+
+void    Sys_ConfigureFPU() { // bk001213 - divide by zero
+#ifdef __linux__
+#ifdef __i386
+#ifndef NDEBUG
+  // bk0101022 - enable FPE's in debug mode
+  static int fpu_word = _FPU_DEFAULT & ~(_FPU_MASK_ZM | _FPU_MASK_IM);
+  int current = 0;
+  _FPU_GETCW(current);
+  if ( current!=fpu_word) {
+#if 0
+    Com_Printf("FPU Control 0x%x (was 0x%x)\n", fpu_word, current );
+    _FPU_SETCW( fpu_word );
+    _FPU_GETCW( current );
+    assert(fpu_word==current);
+#endif
+  }
+#else // NDEBUG
+  static int fpu_word = _FPU_DEFAULT;
+  _FPU_SETCW( fpu_word );
+#endif // NDEBUG
+#endif // __i386 
+#endif // __linux
+}
+
+
+void Sys_PrintBinVersion( const char* name ) {
+  char* date = __DATE__;
+  char* time = __TIME__;
+  char* sep = "==============================================================";
+  fprintf( stdout, "\n\n%s\n", sep );
+#ifdef DEDICATED
+  fprintf( stdout, "Linux Quake3 Dedicated Server [%s %s]\n", date, time );  
+#else
+  fprintf( stdout, "Linux Quake3 Full Executable  [%s %s]\n", date, time );  
+#endif
+  fprintf( stdout, " local install: %s\n", name );
+  fprintf( stdout, "%s\n\n", sep );
+}
+
+void Sys_ParseArgs( int argc, char* argv[] ) {
+
+  if ( argc==2 ) {
+    if ( (!strcmp( argv[1], "--version" ))
+	 || ( !strcmp( argv[1], "-v" )) )
+    {
+      Sys_PrintBinVersion( argv[0] );
+      Sys_Exit(0);
+    }
+  }
+}
+
+#include "../client/client.h"
+extern clientStatic_t	cls;
+
+int main ( int argc, char* argv[] )
+{
+  // int 	oldtime, newtime; // bk001204 - unused
+	int		len, i;
+	char	*cmdline;
+	void Sys_SetDefaultCDPath(const char *path);
+
+	// go back to real user for config loads
+	saved_euid = geteuid();
+	seteuid(getuid());
+
+	Sys_ParseArgs( argc, argv ); 	// bk010104 - added this for support
+
+	Sys_SetDefaultCDPath(argv[0]);
+
+	// merge the command line, this is kinda silly
+	for (len = 1, i = 1; i < argc; i++)
+		len += strlen(argv[i]) + 1;
+	cmdline = (char *)malloc(len);
+	*cmdline = 0;
+	for (i = 1; i < argc; i++) {
+		if (i > 1)
+			strcat(cmdline, " ");
+		strcat(cmdline, argv[i]);
+	}
+
+	// bk000306 - clear queues
+	memset( &eventQue[0], 0, MAX_QUED_EVENTS*sizeof(sysEvent_t) ); 
+	memset( &sys_packetReceived[0], 0, MAX_MSGLEN*sizeof(byte) );
+
+	Com_Init(cmdline);
+	NET_Init();
+
+	fcntl(0, F_SETFL, fcntl (0, F_GETFL, 0) | FNDELAY);
+
+	nostdout = Cvar_Get("nostdout", "0", 0);
+	if (!nostdout->value) {
+		fcntl(0, F_SETFL, fcntl (0, F_GETFL, 0) | FNDELAY);
+	}
+
+    while (1) {
+#ifdef __linux__
+      Sys_ConfigureFPU();
+#endif
+        Com_Frame ();
+    }
+}
diff --git a/codemp/unix/unix_net.c b/codemp/unix/unix_net.c
new file mode 100644
index 0000000..df314e2
--- /dev/null
+++ b/codemp/unix/unix_net.c
@@ -0,0 +1,599 @@
+// unix_net.c
+
+#include "../game/q_shared.h"
+#include "../qcommon/qcommon.h"
+
+#include <unistd.h>
+#include <sys/socket.h>
+#include <sys/time.h>
+#include <netinet/in.h>
+#include <netdb.h>
+#include <arpa/inet.h> // bk001204
+
+#include <sys/param.h>
+#include <sys/ioctl.h>
+#include <sys/uio.h>
+#include <errno.h>
+
+#ifdef MACOS_X
+#import <sys/sockio.h>
+#import <net/if.h>
+#import <net/if_types.h>
+
+#import <arpa/inet.h>         // for inet_ntoa()
+#import <net/if_dl.h>         // for 'struct sockaddr_dl'
+#endif
+
+static cvar_t	*noudp;
+
+netadr_t	net_local_adr;
+
+int			ip_socket;
+int			ipx_socket;
+
+#define	MAX_IPS		16
+static	int		numIP;
+static	byte	localIP[MAX_IPS][4];
+
+int NET_Socket (char *net_interface, int port);
+char *NET_ErrorString (void);
+
+//=============================================================================
+
+void NetadrToSockadr (netadr_t *a, struct sockaddr_in *s)
+{
+	memset (s, 0, sizeof(*s));
+
+	if (a->type == NA_BROADCAST)
+	{
+		s->sin_family = AF_INET;
+
+		s->sin_port = a->port;
+		*(int *)&s->sin_addr = -1;
+	}
+	else if (a->type == NA_IP)
+	{
+		s->sin_family = AF_INET;
+
+		*(int *)&s->sin_addr = *(int *)&a->ip;
+		s->sin_port = a->port;
+	}
+}
+
+void SockadrToNetadr (struct sockaddr_in *s, netadr_t *a)
+{
+	*(int *)&a->ip = *(int *)&s->sin_addr;
+	a->port = s->sin_port;
+	a->type = NA_IP;
+}
+
+char	*NET_BaseAdrToString (netadr_t a)
+{
+	static	char	s[64];
+	
+	Com_sprintf (s, sizeof(s), "%i.%i.%i.%i", a.ip[0], a.ip[1], a.ip[2], a.ip[3]);
+
+	return s;
+}
+
+/*
+=============
+Sys_StringToAdr
+
+idnewt
+192.246.40.70
+=============
+*/
+qboolean	Sys_StringToSockaddr (const char *s, struct sockaddr *sadr)
+{
+	struct hostent	*h;
+	//char	*colon; // bk001204 - unused
+	
+	memset (sadr, 0, sizeof(*sadr));
+	((struct sockaddr_in *)sadr)->sin_family = AF_INET;
+	
+	((struct sockaddr_in *)sadr)->sin_port = 0;
+	
+	if ( s[0] >= '0' && s[0] <= '9')
+	{
+		*(int *)&((struct sockaddr_in *)sadr)->sin_addr = inet_addr(s);
+	}
+	else
+	{
+		if (! (h = gethostbyname(s)) )
+			return qfalse;
+		*(int *)&((struct sockaddr_in *)sadr)->sin_addr = *(int *)h->h_addr_list[0];
+	}
+	
+	return qtrue;
+}
+
+/*
+=============
+Sys_StringToAdr
+
+localhost
+idnewt
+idnewt:28000
+192.246.40.70
+192.246.40.70:28000
+=============
+*/
+qboolean	Sys_StringToAdr (const char *s, netadr_t *a)
+{
+	struct sockaddr_in sadr;
+	
+	if (!Sys_StringToSockaddr (s, (struct sockaddr *)&sadr))
+		return qfalse;
+	
+	SockadrToNetadr (&sadr, a);
+
+	return qtrue;
+}
+
+
+//=============================================================================
+
+qboolean	Sys_GetPacket (netadr_t *net_from, msg_t *net_message)
+{
+	int 	ret;
+	struct sockaddr_in	from;
+	int		fromlen;
+	int		net_socket;
+	int		protocol;
+	int		err;
+
+	for (protocol = 0 ; protocol < 2 ; protocol++)
+	{
+		if (protocol == 0)
+			net_socket = ip_socket;
+		else
+			net_socket = ipx_socket;
+
+		if (!net_socket)
+			continue;
+
+		fromlen = sizeof(from);
+		ret = recvfrom (net_socket, net_message->data, net_message->maxsize
+			, 0, (struct sockaddr *)&from,(socklen_t*) &fromlen);
+
+		SockadrToNetadr (&from, net_from);
+		// bk000305: was missing
+		net_message->readcount = 0;
+
+		if (ret == -1)
+		{
+			err = errno;
+
+			if (err == EWOULDBLOCK || err == ECONNREFUSED)
+				continue;
+			Com_Printf ("NET_GetPacket: %s from %s\n", NET_ErrorString(),
+						NET_AdrToString(*net_from));
+			continue;
+		}
+
+		if (ret == net_message->maxsize)
+		{
+			Com_Printf ("Oversize packet from %s\n", NET_AdrToString (*net_from));
+			continue;
+		}
+
+		net_message->cursize = ret;
+		return qtrue;
+	}
+
+	return qfalse;
+}
+
+//=============================================================================
+
+void	Sys_SendPacket( int length, const void *data, netadr_t to )
+{
+	int		ret;
+	struct sockaddr_in	addr;
+	int		net_socket;
+
+	if (to.type == NA_BROADCAST)
+	{
+		net_socket = ip_socket;
+	}
+	else if (to.type == NA_IP)
+	{
+		net_socket = ip_socket;
+	}
+	else if (to.type == NA_IPX)
+	{
+		net_socket = ipx_socket;
+	}
+	else if (to.type == NA_BROADCAST_IPX)
+	{
+		net_socket = ipx_socket;
+	}
+	else {
+		Com_Error (ERR_FATAL, "NET_SendPacket: bad address type");
+		return;
+	}
+
+	if (!net_socket)
+		return;
+
+	NetadrToSockadr (&to, &addr);
+
+	ret = sendto (net_socket, data, length, 0, (struct sockaddr *)&addr, sizeof(addr) );
+	if (ret == -1)
+	{
+		Com_Printf ("NET_SendPacket ERROR: %s to %s\n", NET_ErrorString(),
+				NET_AdrToString (to));
+	}
+}
+
+
+//=============================================================================
+
+/*
+==================
+Sys_IsLANAddress
+
+LAN clients will have their rate var ignored
+==================
+*/
+qboolean	Sys_IsLANAddress (netadr_t adr) {
+	int		i;
+
+	if( adr.type == NA_LOOPBACK ) {
+		return qtrue;
+	}
+
+	if( adr.type == NA_IPX ) {
+		return qtrue;
+	}
+
+	if( adr.type != NA_IP ) {
+		return qfalse;
+	}
+
+	// choose which comparison to use based on the class of the address being tested
+	// any local adresses of a different class than the address being tested will fail based on the first byte
+/*
+	// Class A
+	if( (adr.ip[0] & 0x80) == 0x00 ) {
+		for ( i = 0 ; i < numIP ; i++ ) {
+			if( adr.ip[0] == localIP[i][0] ) {
+				return qtrue;
+			}
+		}
+		// the RFC1918 class a block will pass the above test
+		return qfalse;
+	}
+
+	// Class B
+	if( (adr.ip[0] & 0xc0) == 0x80 ) {
+		for ( i = 0 ; i < numIP ; i++ ) {
+			if( adr.ip[0] == localIP[i][0] && adr.ip[1] == localIP[i][1] ) {
+				return qtrue;
+			}
+			// also check against the RFC1918 class b blocks
+			if( adr.ip[0] == 172 && localIP[i][0] == 172 && (adr.ip[1] & 0xf0) == 16 && (localIP[i][1] & 0xf0) == 16 ) {
+				return qtrue;
+			}
+		}
+		return qfalse;
+	}
+*/ 
+	//we only look at class C since ISPs and Universities are using class A but we don't want to consider them on the same LAN.
+	// Class C
+	for ( i = 0 ; i < numIP ; i++ ) {
+		if( adr.ip[0] == localIP[i][0] && adr.ip[1] == localIP[i][1] && adr.ip[2] == localIP[i][2] ) {
+			return qtrue;
+		}
+		// also check against the RFC1918 class c blocks
+		if( adr.ip[0] == 192 && localIP[i][0] == 192 && adr.ip[1] == 168 && localIP[i][1] == 168 ) {
+			return qtrue;
+		}
+	}
+	return qfalse;
+}
+
+/*
+==================
+Sys_ShowIP
+==================
+*/
+void Sys_ShowIP(void) {
+	int i;
+
+	for (i = 0; i < numIP; i++) {
+		Com_Printf( "IP: %i.%i.%i.%i\n", localIP[i][0], localIP[i][1], localIP[i][2], localIP[i][3] );
+	}
+}
+
+/*
+=====================
+NET_GetLocalAddress
+=====================
+*/
+#ifdef MACOS_X
+// Don't do a forward mapping from the hostname of the machine to the IP.  The reason is that we might have obtained an IP address from DHCP and there might not be any name registered for the machine.  On Mac OS X, the machine name defaults to 'localhost' and NetInfo has 127.0.0.1 listed for this name.  Instead, we want to get a list of all the IP network interfaces on the machine.
+// This code adapted from OmniNetworking.
+
+#define IFR_NEXT(ifr)	\
+    ((struct ifreq *) ((char *) (ifr) + sizeof(*(ifr)) + \
+      MAX(0, (int) (ifr)->ifr_addr.sa_len - (int) sizeof((ifr)->ifr_addr))))
+
+void NET_GetLocalAddress( void ) {
+        struct ifreq requestBuffer[MAX_IPS], *linkInterface, *inetInterface;
+        struct ifconf ifc;
+        struct ifreq ifr;
+        struct sockaddr_dl *sdl;
+        int interfaceSocket;
+        int family;
+        
+        //Com_Printf("NET_GetLocalAddress: Querying for network interfaces\n");
+        
+        // Set this early so we can just return if there is an error
+	numIP = 0;
+        
+        ifc.ifc_len = sizeof(requestBuffer);
+        ifc.ifc_buf = (caddr_t)requestBuffer;
+
+        // Since we get at this info via an ioctl, we need a temporary little socket.  This will only get AF_INET interfaces, but we probably don't care about anything else.  If we do end up caring later, we should add a ONAddressFamily and at a -interfaces method to it.
+        family = AF_INET;
+        if ((interfaceSocket = socket(family, SOCK_DGRAM, 0)) < 0) {
+            Com_Printf("NET_GetLocalAddress: Unable to create temporary socket, errno = %d\n", errno);
+            return;
+        }
+
+        if (ioctl(interfaceSocket, SIOCGIFCONF, &ifc) != 0) {
+            Com_Printf("NET_GetLocalAddress: Unable to get list of network interfaces, errno = %d\n", errno);
+            return;
+        }
+
+
+        linkInterface = (struct ifreq *) ifc.ifc_buf;
+        while ((char *) linkInterface < &ifc.ifc_buf[ifc.ifc_len]) {
+            unsigned int nameLength;
+
+            // The ioctl returns both the entries having the address (AF_INET) and the link layer entries (AF_LINK).  The AF_LINK entry has the link layer address which contains the interface type.  This is the only way I can see to get this information.  We cannot assume that we will get bot an AF_LINK and AF_INET entry since the interface may not be configured.  For example, if you have a 10Mb port on the motherboard and a 100Mb card, you may not configure the motherboard port.
+
+            // For each AF_LINK entry...
+            if (linkInterface->ifr_addr.sa_family == AF_LINK) {
+                // if there is a matching AF_INET entry
+                inetInterface = (struct ifreq *) ifc.ifc_buf;
+                while ((char *) inetInterface < &ifc.ifc_buf[ifc.ifc_len]) {
+                    if (inetInterface->ifr_addr.sa_family == AF_INET &&
+                        !strncmp(inetInterface->ifr_name, linkInterface->ifr_name, sizeof(linkInterface->ifr_name))) {
+
+                        for (nameLength = 0; nameLength < IFNAMSIZ; nameLength++)
+                            if (!linkInterface->ifr_name[nameLength])
+                                break;
+
+                        sdl = (struct sockaddr_dl *)&linkInterface->ifr_addr;
+                        // Skip loopback interfaces
+                        if (sdl->sdl_type != IFT_LOOP) {
+                            // Get the local interface address
+                            strncpy(ifr.ifr_name, inetInterface->ifr_name, sizeof(ifr.ifr_name));
+                            if (ioctl(interfaceSocket, OSIOCGIFADDR, (caddr_t)&ifr) < 0) {
+                                Com_Printf("NET_GetLocalAddress: Unable to get local address for interface '%s', errno = %d\n", inetInterface->ifr_name, errno);
+                            } else {
+                                struct sockaddr_in *sin;
+                                int ip;
+            
+                                sin = (struct sockaddr_in *)&ifr.ifr_addr;
+            
+                                ip = ntohl(sin->sin_addr.s_addr);
+                                localIP[ numIP ][0] = (ip >> 24) & 0xff;
+                                localIP[ numIP ][1] = (ip >> 16) & 0xff;
+                                localIP[ numIP ][2] = (ip >>  8) & 0xff;
+                                localIP[ numIP ][3] = (ip >>  0) & 0xff;
+                                Com_Printf( "IP: %i.%i.%i.%i (%s)\n", localIP[ numIP ][0], localIP[ numIP ][1], localIP[ numIP ][2], localIP[ numIP ][3], inetInterface->ifr_name);
+                                numIP++;
+                            }
+                        }
+
+                        // We will assume that there is only one AF_INET entry per AF_LINK entry.
+                        // What happens when we have an interface that has multiple IP addresses, or
+                        // can that even happen?
+                        // break;
+                    }
+                    inetInterface = IFR_NEXT(inetInterface);
+                }
+            }
+            linkInterface = IFR_NEXT(linkInterface);
+        }
+
+        close(interfaceSocket);
+}
+
+#else
+void NET_GetLocalAddress( void ) {
+	char				hostname[256];
+	struct hostent		*hostInfo;
+	// int					error; // bk001204 - unused
+	char				*p;
+	int					ip;
+	int					n;
+
+    // Set this early so we can just return if there is an error
+	numIP = 0;
+
+	if ( gethostname( hostname, 256 ) == -1 ) {
+		return;
+	}
+
+	hostInfo = gethostbyname( hostname );
+	if ( !hostInfo ) {
+		return;
+	}
+
+	Com_Printf( "Hostname: %s\n", hostInfo->h_name );
+	n = 0;
+	while( ( p = hostInfo->h_aliases[n++] ) != NULL ) {
+		Com_Printf( "Alias: %s\n", p );
+	}
+
+	if ( hostInfo->h_addrtype != AF_INET ) {
+		return;
+	}
+
+	while( ( p = hostInfo->h_addr_list[numIP] ) != NULL && numIP < MAX_IPS ) {
+		ip = ntohl( *(int *)p );
+		localIP[ numIP ][0] = p[0];
+		localIP[ numIP ][1] = p[1];
+		localIP[ numIP ][2] = p[2];
+		localIP[ numIP ][3] = p[3];
+		Com_Printf( "IP: %i.%i.%i.%i\n", ( ip >> 24 ) & 0xff, ( ip >> 16 ) & 0xff, ( ip >> 8 ) & 0xff, ip & 0xff );
+		numIP++;
+	}
+}
+#endif
+
+/*
+====================
+NET_OpenIP
+====================
+*/
+// bk001204 - prototype needed
+int NET_IPSocket (char *net_interface, int port);
+void NET_OpenIP (void)
+{
+	cvar_t	*ip;
+	int		port;
+	int		i;
+
+	ip = Cvar_Get ("net_ip", "localhost", 0);
+
+	port = Cvar_Get("net_port", va("%i", PORT_SERVER), 0)->value;
+
+	for ( i = 0 ; i < 10 ; i++ ) {
+		ip_socket = NET_IPSocket (ip->string, port + i);
+		if ( ip_socket ) {
+			Cvar_SetValue( "net_port", port + i );
+			NET_GetLocalAddress();
+			return;
+		}
+	}
+	Com_Error (ERR_FATAL, "Couldn't allocate IP port");
+}
+
+
+/*
+====================
+NET_Init
+====================
+*/
+void NET_Init (void)
+{
+	noudp = Cvar_Get ("net_noudp", "0", 0);
+	// open sockets
+	if (! noudp->value) {
+		NET_OpenIP ();
+	}
+}
+
+
+/*
+====================
+NET_IPSocket
+====================
+*/
+int NET_IPSocket (char *net_interface, int port)
+{
+	int newsocket;
+	struct sockaddr_in address;
+	qboolean _qtrue = qtrue;
+	int	i = 1;
+
+	if ( net_interface ) {
+		Com_Printf("Opening IP socket: %s:%i\n", net_interface, port );
+	} else {
+		Com_Printf("Opening IP socket: localhost:%i\n", port );
+	}
+
+	if ((newsocket = socket (PF_INET, SOCK_DGRAM, IPPROTO_UDP)) == -1)
+	{
+		Com_Printf ("ERROR: UDP_OpenSocket: socket: %s", NET_ErrorString());
+		return 0;
+	}
+
+	// make it non-blocking
+	if (ioctl (newsocket, FIONBIO, &_qtrue) == -1)
+	{
+		Com_Printf ("ERROR: UDP_OpenSocket: ioctl FIONBIO:%s\n", NET_ErrorString());
+		return 0;
+	}
+
+	// make it broadcast capable
+	if (setsockopt(newsocket, SOL_SOCKET, SO_BROADCAST, (char *)&i, sizeof(i)) == -1)
+	{
+		Com_Printf ("ERROR: UDP_OpenSocket: setsockopt SO_BROADCAST:%s\n", NET_ErrorString());
+		return 0;
+	}
+
+	if (!net_interface || !net_interface[0] || !Q_stricmp(net_interface, "localhost"))
+		address.sin_addr.s_addr = INADDR_ANY;
+	else
+		Sys_StringToSockaddr (net_interface, (struct sockaddr *)&address);
+
+	if (port == PORT_ANY)
+		address.sin_port = 0;
+	else
+		address.sin_port = htons((short)port);
+
+	address.sin_family = AF_INET;
+
+	if( bind (newsocket, (sockaddr *)&address, sizeof(address)) == -1)
+	{
+		Com_Printf ("ERROR: UDP_OpenSocket: bind: %s\n", NET_ErrorString());
+		close (newsocket);
+		return 0;
+	}
+
+	return newsocket;
+}
+
+/*
+====================
+NET_Shutdown
+====================
+*/
+void	NET_Shutdown (void)
+{
+	if (ip_socket) {
+		close(ip_socket);
+		ip_socket = 0;
+	}
+}
+
+
+/*
+====================
+NET_ErrorString
+====================
+*/
+char *NET_ErrorString (void)
+{
+	int		code;
+
+	code = errno;
+	return strerror (code);
+}
+
+// sleeps msec or until net socket is ready
+void NET_Sleep(int msec)
+{
+    struct timeval timeout;
+	fd_set	fdset;
+	extern qboolean stdin_active;
+
+	if (!ip_socket || !com_dedicated->integer)
+		return; // we're not a server, just run full speed
+
+	FD_ZERO(&fdset);
+	if (stdin_active)
+		FD_SET(0, &fdset); // stdin is processed too
+	FD_SET(ip_socket, &fdset); // network socket
+	timeout.tv_sec = msec/1000;
+	timeout.tv_usec = (msec%1000)*1000;
+	select(ip_socket+1, &fdset, NULL, NULL, &timeout);
+}
+
diff --git a/codemp/unix/unix_shared.cpp b/codemp/unix/unix_shared.cpp
new file mode 100644
index 0000000..fb6beed
--- /dev/null
+++ b/codemp/unix/unix_shared.cpp
@@ -0,0 +1,350 @@
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <errno.h>
+#include <stdio.h>
+#include <dirent.h>
+#include <unistd.h>
+#include <sys/mman.h>
+#include <sys/time.h>
+#include <pwd.h>
+
+#include "../game/q_shared.h"
+#include "../qcommon/qcommon.h"
+
+typedef unsigned short DWORD;
+
+//=============================================================================
+
+// Used to determine CD Path
+static char cdPath[MAX_OSPATH];
+
+// Used to determine local installation path
+static char installPath[MAX_OSPATH];
+
+// Used to determine where to store user-specific files
+static char homePath[MAX_OSPATH];
+
+//DWORD timeGetTime(void)
+//{
+//	return Sys_Milliseconds();
+//}
+
+/*
+================
+Sys_Milliseconds
+================
+*/
+int curtime;
+int	sys_timeBase;
+int Sys_Milliseconds (bool baseTime)
+{
+	struct timeval tp;
+	struct timezone tzp;
+
+	gettimeofday(&tp, &tzp);
+	
+	if (!sys_timeBase)
+	{
+		sys_timeBase = tp.tv_sec;
+		return tp.tv_usec/1000;
+	}
+
+	curtime = (tp.tv_sec - sys_timeBase)*1000 + tp.tv_usec/1000;
+
+	static int sys_timeBase = curtime;
+	if (!baseTime)
+	{
+		curtime -= sys_timeBase;
+	}
+		
+	return curtime;
+
+}
+
+
+//#if 0 // bk001215 - see snapvector.nasm for replacement
+#if (defined __APPLE__) // rcg010206 - using this for PPC builds...
+long fastftol( float f ) { // bk001213 - from win32/win_shared.c
+  //static int tmp;
+  //	__asm fld f
+  //__asm fistp tmp
+  //__asm mov eax, tmp
+  return (long)f;
+}
+
+void Sys_SnapVector3( float *v ) { // bk001213 - see win32/win_shared.c
+  // bk001213 - old linux
+  v[0] = rint(v[0]);
+  v[1] = rint(v[1]);
+  v[2] = rint(v[2]);
+}
+#endif
+
+
+void	Sys_Mkdir( const char *path )
+{
+    mkdir (path, 0777);
+}
+
+char *strlwr (char *s) {
+  if ( s==NULL ) { // bk001204 - paranoia
+    assert(0);
+    return s;
+  }
+  while (*s) {
+    *s = tolower(*s);
+    s++;
+  }
+  return s; // bk001204 - duh
+}
+
+//============================================
+
+#define	MAX_FOUND_FILES	0x1000
+
+// bk001129 - new in 1.26
+void Sys_ListFilteredFiles( const char *basedir, char *subdirs, char *filter, char **list, int *numfiles ) {
+	char		search[MAX_OSPATH], newsubdirs[MAX_OSPATH];
+	char		filename[MAX_OSPATH];
+	DIR			*fdir;
+	struct dirent *d;
+	struct stat st;
+
+	if ( *numfiles >= MAX_FOUND_FILES - 1 ) {
+		return;
+	}
+
+	if (strlen(subdirs)) {
+		Com_sprintf( search, sizeof(search), "%s/%s", basedir, subdirs );
+	}
+	else {
+		Com_sprintf( search, sizeof(search), "%s", basedir );
+	}
+
+	if ((fdir = opendir(search)) == NULL) {
+		return;
+	}
+
+	while ((d = readdir(fdir)) != NULL) {
+		Com_sprintf(filename, sizeof(filename), "%s/%s", search, d->d_name);
+		if (stat(filename, &st) == -1)
+			continue;
+
+		if (st.st_mode & S_IFDIR) {
+			if (Q_stricmp(d->d_name, ".") && Q_stricmp(d->d_name, "..")) {
+				if (strlen(subdirs)) {
+					Com_sprintf( newsubdirs, sizeof(newsubdirs), "%s/%s", subdirs, d->d_name);
+				}
+				else {
+					Com_sprintf( newsubdirs, sizeof(newsubdirs), "%s", d->d_name);
+				}
+				Sys_ListFilteredFiles( basedir, newsubdirs, filter, list, numfiles );
+			}
+		}
+		if ( *numfiles >= MAX_FOUND_FILES - 1 ) {
+			break;
+		}
+		Com_sprintf( filename, sizeof(filename), "%s/%s", subdirs, d->d_name );
+		if (!Com_FilterPath( filter, filename, qfalse ))
+			continue;
+		list[ *numfiles ] = CopyString( filename );
+		(*numfiles)++;
+	}
+
+	closedir(fdir);
+}
+
+// bk001129 - in 1.17 this used to be
+// char **Sys_ListFiles( const char *directory, const char *extension, int *numfiles, qboolean wantsubs )
+char **Sys_ListFiles( const char *directory, const char *extension, char *filter, int *numfiles, qboolean wantsubs )
+{
+	struct dirent *d;
+	// char *p; // bk001204 - unused
+	DIR		*fdir;
+	qboolean dironly = wantsubs;
+	char		search[MAX_OSPATH];
+	int			nfiles;
+	char		**listCopy;
+	char		*list[MAX_FOUND_FILES];
+	//int			flag; // bk001204 - unused
+	int			i;
+	struct stat st;
+
+	int			extLen;
+
+	if (filter) {
+
+		nfiles = 0;
+		Sys_ListFilteredFiles( directory, "", filter, list, &nfiles );
+
+		list[ nfiles ] = 0;
+		*numfiles = nfiles;
+
+		if (!nfiles)
+			return NULL;
+
+		listCopy = (char **)Z_Malloc( ( nfiles + 1 ) * sizeof( *listCopy ),TAG_FILESYS,qfalse );
+		for ( i = 0 ; i < nfiles ; i++ ) {
+			listCopy[i] = list[i];
+		}
+		listCopy[i] = NULL;
+
+		return listCopy;
+	}
+
+	if ( !extension)
+		extension = "";
+
+	if ( extension[0] == '/' && extension[1] == 0 ) {
+		extension = "";
+		dironly = qtrue;
+	}
+
+	extLen = strlen( extension );
+	
+	// search
+	nfiles = 0;
+
+	if ((fdir = opendir(directory)) == NULL) {
+		*numfiles = 0;
+		return NULL;
+	}
+
+	while ((d = readdir(fdir)) != NULL) {
+		Com_sprintf(search, sizeof(search), "%s/%s", directory, d->d_name);
+		if (stat(search, &st) == -1)
+			continue;
+		if ((dironly && !(st.st_mode & S_IFDIR)) ||
+			(!dironly && (st.st_mode & S_IFDIR)))
+			continue;
+
+		if (*extension) {
+			if ( strlen( d->d_name ) < strlen( extension ) ||
+				Q_stricmp( 
+					d->d_name + strlen( d->d_name ) - strlen( extension ),
+					extension ) ) {
+				continue; // didn't match
+			}
+		}
+
+		if ( nfiles == MAX_FOUND_FILES - 1 )
+			break;
+		list[ nfiles ] = CopyString( d->d_name );
+		nfiles++;
+	}
+
+	list[ nfiles ] = 0;
+
+	closedir(fdir);
+
+	// return a copy of the list
+	*numfiles = nfiles;
+
+	if ( !nfiles ) {
+		return NULL;
+	}
+
+	listCopy = (char **)Z_Malloc( ( nfiles + 1 ) * sizeof( *listCopy ),TAG_FILESYS,qfalse );
+	for ( i = 0 ; i < nfiles ; i++ ) {
+		listCopy[i] = list[i];
+	}
+	listCopy[i] = NULL;
+
+	return listCopy;
+}
+
+void	Sys_FreeFileList( char **list ) {
+	int		i;
+
+	if ( !list ) {
+		return;
+	}
+
+	for ( i = 0 ; list[i] ; i++ ) {
+		Z_Free( list[i] );
+	}
+
+	Z_Free( list );
+}
+
+char *Sys_Cwd( void ) 
+{
+	static char cwd[MAX_OSPATH];
+
+	getcwd( cwd, sizeof( cwd ) - 1 );
+	cwd[MAX_OSPATH-1] = 0;
+
+	return cwd;
+}
+
+void Sys_SetDefaultCDPath(const char *path)
+{
+	Q_strncpyz(cdPath, path, sizeof(cdPath));
+}
+
+char *Sys_DefaultCDPath(void)
+{
+        return cdPath;
+}
+
+void Sys_SetDefaultInstallPath(const char *path)
+{
+	Q_strncpyz(installPath, path, sizeof(installPath));
+}
+
+char *Sys_DefaultInstallPath(void)
+{
+	if (*installPath)
+		return installPath;
+	else
+		return Sys_Cwd();
+}
+
+void Sys_SetDefaultHomePath(const char *path)
+{
+	Q_strncpyz(homePath, path, sizeof(homePath));
+}
+
+char *Sys_DefaultHomePath(void)
+{
+	char *p;
+
+        if (*homePath)
+            return homePath;
+            
+	if ((p = getenv("HOME")) != NULL) {
+		Q_strncpyz(homePath, p, sizeof(homePath));
+#ifdef MACOS_X
+		Q_strcat(homePath, sizeof(homePath), "/Library/Application Support/Quake3");
+#else
+		Q_strcat(homePath, sizeof(homePath), "/.jkii");
+#endif
+		if (mkdir(homePath, 0777)) {
+			if (errno != EEXIST) 
+				Sys_Error("Unable to create directory \"%s\", error is %s(%d)\n", homePath, strerror(errno), errno);
+		}
+		return homePath;
+	}
+	return ""; // assume current dir
+}
+
+//============================================
+
+int Sys_GetProcessorId( void )
+{
+	return CPUID_GENERIC;
+}
+
+void Sys_ShowConsole( int visLevel, qboolean quitOnClose )
+{
+}
+
+char *Sys_GetCurrentUser( void )
+{
+	struct passwd *p;
+
+	if ( (p = getpwuid( getuid() )) == NULL ) {
+		return "player";
+	}
+	return p->pw_name;
+}
diff --git a/codemp/unix/vm_x86.c b/codemp/unix/vm_x86.c
new file mode 100644
index 0000000..7881443
--- /dev/null
+++ b/codemp/unix/vm_x86.c
@@ -0,0 +1,8 @@
+
+#include "../qcommon/vm_local.h"
+
+void VM_Compile( vm_t *vm, vmHeader_t *header ) {}
+int	VM_CallCompiled( vm_t *vm, int *args ) {}
+
+
+
diff --git a/codemp/unix/vssver.scc b/codemp/unix/vssver.scc
new file mode 100644
index 0000000..9ad194a
Binary files /dev/null and b/codemp/unix/vssver.scc differ
diff --git a/codemp/update_MPents.bat b/codemp/update_MPents.bat
new file mode 100644
index 0000000..0df6253
--- /dev/null
+++ b/codemp/update_MPents.bat
@@ -0,0 +1 @@
+k:\util\EntityDefMaker w:\bin\mpsource\*.c w:\game\base\scripts\mp_entities.def
diff --git a/codemp/vssver.scc b/codemp/vssver.scc
new file mode 100644
index 0000000..09af422
Binary files /dev/null and b/codemp/vssver.scc differ
diff --git a/codemp/win32/AutoVersion.h b/codemp/win32/AutoVersion.h
new file mode 100644
index 0000000..650373e
--- /dev/null
+++ b/codemp/win32/AutoVersion.h
@@ -0,0 +1,98 @@
+#ifndef __AUTO_VERSION_HEADER
+#define __AUTO_VERSION_HEADER
+
+#define VERSION_MAJOR_RELEASE		1
+#define VERSION_MINOR_RELEASE		0
+#define VERSION_EXTERNAL_BUILD		0
+#define VERSION_INTERNAL_BUILD		0
+
+#define VERSION_STRING				"1, 0, 0, 0"
+#define VERSION_STRING_DOTTED		"1.0.0.0"
+
+#define VERSION_BUILD_NUMBER		86
+
+// BEGIN COMMENTS
+// 1.0.0.0		07/21/2003 16:05:31		jmonroe		going gold
+// 0.0.12.0		07/20/2003 19:05:02		jmonroe		build 0.12 for qa
+// 0.0.11.0		07/18/2003 12:08:44		jmonroe		dlight fix, ui name fix, jk2 -> ja
+// 0.0.11.0		07/17/2003 17:19:17		jmonroe		build 0.11 for qa
+// 0.0.10.1		07/16/2003 18:49:28		mgummelt		General MP update
+// 0.0.10.0		07/16/2003 10:45:33		jmonroe		new product id
+// 0.0.10.0		07/14/2003 19:38:41		jmonroe		build 0.10 for qa
+// 0.0.9.0		07/11/2003 17:49:06		jmonroe		build 0.09 for qa
+// 0.0.8.9		07/11/2003 14:38:31		rjohnson		Update for siege stress test
+// 0.0.8.8		07/11/2003 13:09:19		rjohnson		general update for test
+// 0.0.8.7		07/11/2003 10:52:01		rjohnson		general update
+// 0.0.8.6		07/10/2003 16:23:28		rjohnson		New test build
+// 0.0.8.5		07/10/2003 14:45:24		rjohnson		General update
+// 0.0.8.4		07/10/2003 13:28:42		rjohnson		General update for test
+// 0.0.8.3		07/09/2003 15:32:33		jmonroe		fix mem leak on dlls
+// 0.0.8.2		07/09/2003 14:18:14		rjohnson		New test for release server bug finding
+// 0.0.8.1		07/09/2003 13:29:39		rjohnson		Update for modem test
+// 0.0.8.0		07/09/2003 11:09:24		rjohnson		General update
+// 0.0.8.0		07/08/2003 16:47:56		jmonroe		build 0.08 for qa
+// 0.0.7.5		07/07/2003 14:42:27		rjohnson		Update for test
+// 0.0.7.4		07/05/2003 13:36:21		rjohnson		new spawn points for duel
+// 0.0.7.3		07/03/2003 16:27:31		rjohnson		Update for rich's code
+// 0.0.7.2		07/03/2003 16:01:36		rjohnson		General update for test
+// 0.0.7.1		07/03/2003 13:26:18		rjohnson		General update for test
+// 0.0.7.0		07/03/2003 11:41:17		rjohnson		Update for Dan
+// 0.0.7.0		07/02/2003 19:36:05		jmonroe		build 7 for qa
+// 0.0.6.7		07/02/2003 17:00:43		rjohnson		General update for test
+// 0.0.6.6		07/02/2003 14:57:45		rjohnson		Update to fix spamming problem
+// 0.0.6.5		07/02/2003 13:57:16		rjohnson		Rich put in a default time limit so siege messages won't spam
+// 0.0.6.4		07/02/2003 13:26:45		rjohnson		General update for test
+// 0.0.6.3		07/01/2003 14:40:06		rjohnson		General update for test
+// 0.0.6.2		06/30/2003 16:31:56		rjohnson		General update for test
+// 0.0.6.1		06/27/2003 14:30:37		rjohnson		General update
+// 0.0.6.0		06/26/2003 18:44:01		rjohnson		update for bob
+// 0.0.6.0		06/26/2003 17:37:02		jmonroe		qa build
+// 0.0.5.10		06/26/2003 14:23:59		rjohnson		General update
+// 0.0.5.9		06/26/2003 11:43:50		rjohnson		General updates from everyone
+// 0.0.5.8		06/25/2003 18:02:26		rjohnson		Update for test
+// 0.0.5.7		06/25/2003 16:22:06		rjohnson		Update for test
+// 0.0.5.6		06/25/2003 13:35:47		rjohnson		Automap and seeker changes and...
+// 0.0.5.5		06/25/2003 13:07:07		rjohnson		Update
+// 0.0.5.4		06/25/2003 10:44:28		jmonroe		EAX 4.0
+// 0.0.5.3		06/24/2003 14:27:16		rjohnson		General Update
+// 0.0.5.2		06/23/2003 17:42:05		mgummelt		Saber changes
+// 0.0.5.1		06/23/2003 10:30:51		rjohnson		Refresh .exe on the net
+// 0.0.5.0		06/22/2003 16:44:05		mgummelt		Rancor & Reborn/Cultist tweaks
+// 0.0.4.10		06/20/2003 14:26:46		rjohnson		Update for 2:30 test
+// 0.0.4.9		06/20/2003 12:51:17		rjohnson		Test of nathan's concept to show scores during duel matches
+// 0.0.4.8		06/19/2003 18:03:49		rjohnson		General upate
+// 0.0.4.7		06/19/2003 14:22:45		rjohnson		General update synch for gil
+// 0.0.4.6		06/19/2003 12:02:20		mgummelt		Lightsaber Damage Fixed
+// 0.0.4.5		06/19/2003 11:49:13		mgummelt		Fighter Control Scheme tweak
+// 0.0.4.4		06/19/2003 10:31:20		mgummelt		Vehicle Fighter Controls 4.0 (fixed build)
+// 0.0.4.3		06/19/2003 01:40:18		mgummelt		Vehicle Control Scheme 4.0
+// 0.0.4.2		06/18/2003 16:33:01		rjohnson		With new and improved Gil compiling optimization settings (blame him!)
+// 0.0.4.1		06/17/2003 17:43:56		rjohnson		Test to see if in game menu works
+// 0.0.4.0		06/17/2003 14:54:59		rjohnson		General update
+// 0.0.4.0		06/14/2003 01:45:27		jmonroe		inc version to synch with qa beta
+// 0.0.2.7		06/13/2003 17:30:44		rjohnson		General update
+// 0.0.2.6		06/13/2003 16:54:54		rjohnson		Fix for siege crash
+// 0.0.2.5		06/13/2003 14:47:35		rjohnson		New stuff
+// 0.0.2.3		06/12/2003 17:05:57		rjohnson		Rate test
+// 0.0.2.2		06/12/2003 15:46:11		rjohnson		Entity reorg, general updates
+// 0.0.2.1		06/11/2003 13:28:50		rjohnson		General new version stuff - lots of stuff by everyone
+// 0.0.2.0		06/11/2003 01:25:29		jmonroe		material based footstep sounds ported from sp
+// 0.0.2.0		06/08/2003 00:18:19		jmonroe		CGEN_LIGHTING_DIFFUSE_ENTITY merges lightingdiffuse and entity color
+// 0.0.1.16		06/07/2003 22:31:17		rwhitehouse		Saber moves sync'd up with SP, skin/model fix (related to hunk switch to Z_Malloc)
+// 0.0.1.15		06/06/2003 23:05:55		rwhitehouse		Vehicle controls suck somewhat less. (MP)
+// 0.0.1.14		06/05/2003 14:13:10		rwhitehouse		swoop changes, attempted vehicle spectator fix
+// 0.0.1.13		06/04/2003 15:46:11		rwhitehouse		The hunk has been removed entirely.
+// 0.0.1.12		06/03/2003 13:50:29		rwhitehouse		swoop choppiness fix
+// 0.0.1.11		06/03/2003 13:26:46		rwhitehouse		swoop infinite loop fix
+// 0.0.1.10		06/03/2003 11:18:27		rwhitehouse		radar siege item fixes
+// 0.0.1.9		06/02/2003 16:05:35		rwhitehouse		new radar flags for siege items and siege objective entities
+// 0.0.1.8		06/02/2003 14:37:56		rwhitehouse		Swoop bug fixes, cartwheel/arial specials added for all saber stances, butterfly attack added for saber staff.
+// 0.0.1.7		06/01/2003 21:33:52		rwhitehouse		anim bug fixes, swoop fixes.
+// 0.0.1.6		05/28/2003 17:22:11		rwhitehouse		swoop fixes
+// 0.0.1.5		05/28/2003 11:33:02		rwhitehouse		Swoop less horribly broken
+// 0.0.1.4		05/25/2003 19:22:02		rwhitehouse		some dlight stuff.. and other things I forget
+// 0.0.1.2		05/22/2003 16:28:21		rwhitehouse		Stencil shadows fixed, vehicle precaching fixed
+// 0.0.1.1		05/14/2003 16:14:42		jmonroe		added version blocks
+// END COMMENTS
+
+#endif // __AUTO_VERSION_HEADER
diff --git a/codemp/win32/JK2cgame.rc b/codemp/win32/JK2cgame.rc
new file mode 100644
index 0000000..d280a1b
--- /dev/null
+++ b/codemp/win32/JK2cgame.rc
@@ -0,0 +1,104 @@
+// Microsoft Visual C++ generated resource script.
+//
+#include "resource.h"
+
+#define APSTUDIO_READONLY_SYMBOLS
+/////////////////////////////////////////////////////////////////////////////
+//
+// Generated from the TEXTINCLUDE 2 resource.
+//
+#include "afxres.h"
+
+/////////////////////////////////////////////////////////////////////////////
+#undef APSTUDIO_READONLY_SYMBOLS
+
+/////////////////////////////////////////////////////////////////////////////
+// English (U.S.) resources
+
+#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU)
+#ifdef _WIN32
+LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US
+#pragma code_page(1252)
+#endif //_WIN32
+
+#ifdef APSTUDIO_INVOKED
+/////////////////////////////////////////////////////////////////////////////
+//
+// TEXTINCLUDE
+//
+
+1 TEXTINCLUDE 
+BEGIN
+    "resource.h\0"
+END
+
+2 TEXTINCLUDE 
+BEGIN
+    "#include ""afxres.h""\r\n"
+    "\0"
+END
+
+3 TEXTINCLUDE 
+BEGIN
+    "\r\n"
+    "\0"
+END
+
+#endif    // APSTUDIO_INVOKED
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// Version
+//
+#include "AutoVersion.h"
+
+VS_VERSION_INFO VERSIONINFO
+ FILEVERSION VERSION_MAJOR_RELEASE,VERSION_MINOR_RELEASE,VERSION_EXTERNAL_BUILD,VERSION_INTERNAL_BUILD
+ PRODUCTVERSION VERSION_MAJOR_RELEASE,VERSION_MINOR_RELEASE,VERSION_EXTERNAL_BUILD,VERSION_INTERNAL_BUILD
+ FILEFLAGSMASK 0x17L
+#ifdef _DEBUG
+ FILEFLAGS 0x1L
+#else
+ FILEFLAGS 0x0L
+#endif
+ FILEOS 0x4L
+ FILETYPE 0x2L
+ FILESUBTYPE 0x0L
+BEGIN
+    BLOCK "StringFileInfo"
+    BEGIN
+        BLOCK "040904b0"
+        BEGIN
+            VALUE "Comments", "Raven Software"
+            VALUE "CompanyName", "Activision Inc"
+            VALUE "FileDescription", "JA Client Game DLL"
+            VALUE "FileVersion", VERSION_STRING
+            VALUE "InternalName", "JAcgame"
+            VALUE "LegalCopyright", "Copyright (C) 2003"
+            VALUE "OriginalFilename", "JAcgame.dll"
+            VALUE "ProductName", "Jedi Knight®: Jedi Academy (MP)"
+            VALUE "ProductVersion", VERSION_STRING
+        END
+    END
+    BLOCK "VarFileInfo"
+    BEGIN
+        VALUE "Translation", 0x409, 1200
+    END
+END
+
+#endif    // English (U.S.) resources
+/////////////////////////////////////////////////////////////////////////////
+
+
+
+#ifndef APSTUDIO_INVOKED
+/////////////////////////////////////////////////////////////////////////////
+//
+// Generated from the TEXTINCLUDE 3 resource.
+//
+
+
+/////////////////////////////////////////////////////////////////////////////
+#endif    // not APSTUDIO_INVOKED
+
diff --git a/codemp/win32/JK2game.rc b/codemp/win32/JK2game.rc
new file mode 100644
index 0000000..f342486
--- /dev/null
+++ b/codemp/win32/JK2game.rc
@@ -0,0 +1,104 @@
+// Microsoft Visual C++ generated resource script.
+//
+#include "resource.h"
+
+#define APSTUDIO_READONLY_SYMBOLS
+/////////////////////////////////////////////////////////////////////////////
+//
+// Generated from the TEXTINCLUDE 2 resource.
+//
+#include "afxres.h"
+
+/////////////////////////////////////////////////////////////////////////////
+#undef APSTUDIO_READONLY_SYMBOLS
+
+/////////////////////////////////////////////////////////////////////////////
+// English (U.S.) resources
+
+#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU)
+#ifdef _WIN32
+LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US
+#pragma code_page(1252)
+#endif //_WIN32
+
+#ifdef APSTUDIO_INVOKED
+/////////////////////////////////////////////////////////////////////////////
+//
+// TEXTINCLUDE
+//
+
+1 TEXTINCLUDE 
+BEGIN
+    "resource.h\0"
+END
+
+2 TEXTINCLUDE 
+BEGIN
+    "#include ""afxres.h""\r\n"
+    "\0"
+END
+
+3 TEXTINCLUDE 
+BEGIN
+    "\r\n"
+    "\0"
+END
+
+#endif    // APSTUDIO_INVOKED
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// Version
+//
+#include "AutoVersion.h"
+
+VS_VERSION_INFO VERSIONINFO
+ FILEVERSION VERSION_MAJOR_RELEASE,VERSION_MINOR_RELEASE,VERSION_EXTERNAL_BUILD,VERSION_INTERNAL_BUILD
+ PRODUCTVERSION VERSION_MAJOR_RELEASE,VERSION_MINOR_RELEASE,VERSION_EXTERNAL_BUILD,VERSION_INTERNAL_BUILD
+ FILEFLAGSMASK 0x17L
+#ifdef _DEBUG
+ FILEFLAGS 0x1L
+#else
+ FILEFLAGS 0x0L
+#endif
+ FILEOS 0x4L
+ FILETYPE 0x2L
+ FILESUBTYPE 0x0L
+BEGIN
+    BLOCK "StringFileInfo"
+    BEGIN
+        BLOCK "040904b0"
+        BEGIN
+            VALUE "Comments", "Raven Software"
+            VALUE "CompanyName", "Activision Inc"
+            VALUE "FileDescription", "JA Game DLL"
+            VALUE "FileVersion", VERSION_STRING
+            VALUE "InternalName", "JAgame"
+            VALUE "LegalCopyright", "Copyright (C) 2003"
+            VALUE "OriginalFilename", "JAgame.dll"
+            VALUE "ProductName", "Jedi Knight®: Jedi Academy (MP)"
+            VALUE "ProductVersion", VERSION_STRING
+        END
+    END
+    BLOCK "VarFileInfo"
+    BEGIN
+        VALUE "Translation", 0x409, 1200
+    END
+END
+
+#endif    // English (U.S.) resources
+/////////////////////////////////////////////////////////////////////////////
+
+
+
+#ifndef APSTUDIO_INVOKED
+/////////////////////////////////////////////////////////////////////////////
+//
+// Generated from the TEXTINCLUDE 3 resource.
+//
+
+
+/////////////////////////////////////////////////////////////////////////////
+#endif    // not APSTUDIO_INVOKED
+
diff --git a/codemp/win32/WinDed.rc b/codemp/win32/WinDed.rc
new file mode 100644
index 0000000..366208d
--- /dev/null
+++ b/codemp/win32/WinDed.rc
@@ -0,0 +1,105 @@
+// Microsoft Visual C++ generated resource script.
+//
+#include "resource.h"
+
+#define APSTUDIO_READONLY_SYMBOLS
+/////////////////////////////////////////////////////////////////////////////
+//
+// Generated from the TEXTINCLUDE 2 resource.
+//
+#include "afxres.h"
+
+/////////////////////////////////////////////////////////////////////////////
+#undef APSTUDIO_READONLY_SYMBOLS
+
+/////////////////////////////////////////////////////////////////////////////
+// English (U.S.) resources
+
+#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU)
+#ifdef _WIN32
+LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US
+#pragma code_page(1252)
+#endif //_WIN32
+
+#ifdef APSTUDIO_INVOKED
+/////////////////////////////////////////////////////////////////////////////
+//
+// TEXTINCLUDE
+//
+
+1 TEXTINCLUDE 
+BEGIN
+    "resource.h\0"
+END
+
+2 TEXTINCLUDE 
+BEGIN
+    "#include ""afxres.h""\r\n"
+    "\0"
+END
+
+3 TEXTINCLUDE 
+BEGIN
+    "\r\n"
+    "\0"
+END
+
+#endif    // APSTUDIO_INVOKED
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// Version
+//
+
+#include "AutoVersion.h"
+
+VS_VERSION_INFO VERSIONINFO
+ FILEVERSION VERSION_MAJOR_RELEASE,VERSION_MINOR_RELEASE,VERSION_EXTERNAL_BUILD,VERSION_INTERNAL_BUILD
+ PRODUCTVERSION VERSION_MAJOR_RELEASE,VERSION_MINOR_RELEASE,VERSION_EXTERNAL_BUILD,VERSION_INTERNAL_BUILD
+ FILEFLAGSMASK 0x17L
+#ifdef _DEBUG
+ FILEFLAGS 0x1L
+#else
+ FILEFLAGS 0x0L
+#endif
+ FILEOS 0x4L
+ FILETYPE 0x1L
+ FILESUBTYPE 0x0L
+BEGIN
+    BLOCK "StringFileInfo"
+    BEGIN
+        BLOCK "040904b0"
+        BEGIN
+            VALUE "Comments", "Raven Software"
+            VALUE "CompanyName", "Activision Inc"
+            VALUE "FileDescription", "Jedi Academy MP Dedicated Server"
+            VALUE "FileVersion", VERSION_STRING
+            VALUE "InternalName", "JA MP Ded"
+            VALUE "LegalCopyright", "Copyright (C) 2003"
+            VALUE "OriginalFilename", "JAMPDed.exe"
+            VALUE "ProductName", "Jedi Knight®: Jedi Academy Dedicated Server"
+            VALUE "ProductVersion", VERSION_STRING
+        END
+    END
+    BLOCK "VarFileInfo"
+    BEGIN
+        VALUE "Translation", 0x409, 1200
+    END
+END
+
+#endif    // English (U.S.) resources
+/////////////////////////////////////////////////////////////////////////////
+
+
+
+#ifndef APSTUDIO_INVOKED
+/////////////////////////////////////////////////////////////////////////////
+//
+// Generated from the TEXTINCLUDE 3 resource.
+//
+
+
+/////////////////////////////////////////////////////////////////////////////
+#endif    // not APSTUDIO_INVOKED
+
diff --git a/codemp/win32/dbg_console_xbox.cpp b/codemp/win32/dbg_console_xbox.cpp
new file mode 100644
index 0000000..021f031
--- /dev/null
+++ b/codemp/win32/dbg_console_xbox.cpp
@@ -0,0 +1,172 @@
+//-----------------------------------------------------------------------------
+// File: dbg_console_xbox.cpp
+//
+// Desc: Listens for string commands sent from a debug console on a
+//       remote dev machine, and forwards them to the Q3 engine.
+//
+//       Commands are sent from the remote debug console through the debug
+//       channel to the debug monitor on the Xbox machine.  The Xbox machine
+//       receives the commands on a separate thread through a
+//       registered command processor callback function. The callback
+//       function will store commands in a buffer, and the app should
+//       poll this buffer once per frame and then decipher and handle
+//       the commands.
+//
+// Hist: 02.05.01 - Initial creation for March XDK release
+//       08.21.02 - Revision and code cleanup
+//       04.10.02 - Buthcered by BTO for use in JK3:JA
+//
+// Copyright (c) Microsoft Corporation. All rights reserved.
+//-----------------------------------------------------------------------------
+#include <xtl.h>
+#include <xbdm.h>
+#include <stdio.h>
+#include "dbg_console_xbox.h"
+#include "../client/client.h"
+#include "../qcommon/qcommon.h"
+
+
+// Command prefix for things sent across the dubg channel
+static const CHAR g_strDebugConsoleCommandPrefix[] = "XCMD";
+
+
+// Global buffer to receive remote commands from the debug console. Note that
+// since this data is accessed by the app's main thread, and the debug monitor
+// thread, we need to protect access with a critical section
+static CHAR g_strRemoteBuf[MAXRCMDLENGTH];
+
+
+// The critical section used to protect data that is shared between threads
+static CRITICAL_SECTION g_CriticalSection;
+
+
+// Temporary replacement for CRT string funcs, since
+// we can't call CRT functions on the debug monitor
+// thread right now.
+
+
+//-----------------------------------------------------------------------------
+// Name: dbgtolower()
+// Desc: Returns lowercase of char
+//-----------------------------------------------------------------------------
+inline CHAR dbgtolower( CHAR ch )
+{
+    if( ch >= 'A' && ch <= 'Z' )
+        return ch - ( 'A' - 'a' );
+    else
+        return ch;
+}
+
+
+//-----------------------------------------------------------------------------
+// Name: dbgstrnicmp()
+// Desc: Critical section safe string compare.
+//-----------------------------------------------------------------------------
+BOOL dbgstrnicmp( const CHAR* str1, const CHAR* str2, int n )
+{
+    while( ( dbgtolower( *str1 ) == dbgtolower( *str2 ) ) && *str1 && n > 0 )
+    {
+        --n;
+        ++str1;
+        ++str2;
+    }
+
+    return( n == 0 || dbgtolower( *str1 ) == dbgtolower( *str2 ) );
+}
+
+
+//-----------------------------------------------------------------------------
+// Name: dbgstrcpy()
+// Desc: Critical section safe string copy
+//-----------------------------------------------------------------------------
+VOID dbgstrcpy( CHAR* strDest, const CHAR* strSrc )
+{
+    while( ( *strDest++ = *strSrc++ ) != 0 );
+}
+    
+
+//-----------------------------------------------------------------------------
+// Name: DebugConsoleCmdProcessor()
+// Desc: Command notification proc that is called by the Xbox debug monitor to
+//       have us process a command.  What we'll actually attempt to do is tell
+//       it to make calls to us on a separate thread, so that we can just block
+//       until we're able to process a command.
+//
+// Note: Do NOT include newlines in the response string! To do so will confuse
+//       the internal WinSock networking code used by the debug monitor API.
+//-----------------------------------------------------------------------------
+HRESULT __stdcall DebugConsoleCmdProcessor( const CHAR* strCommand,
+                                            CHAR* strResponse, DWORD dwResponseLen,
+                                            PDM_CMDCONT pdmcc )
+{
+    // Skip over the command prefix and the exclamation mark
+    strCommand += strlen(g_strDebugConsoleCommandPrefix) + 1;
+
+    // Check if this is the initial connect signal
+    if( dbgstrnicmp( strCommand, "__connect__", 11 ) )
+    {
+        // If so, respond that we're connected
+        lstrcpynA( strResponse, "Connected.", dwResponseLen );
+        return XBDM_NOERR;
+    }
+
+	// g_strRemoteBuf needs to be protected by the critical section
+	EnterCriticalSection( &g_CriticalSection );
+	if( g_strRemoteBuf[0] )
+	{
+		// This means the application has probably stopped polling for debug commands
+		dbgstrcpy( strResponse, "Cannot execute - previous command still pending" );
+	}
+	else
+	{
+		dbgstrcpy( g_strRemoteBuf, strCommand );
+	}
+	LeaveCriticalSection( &g_CriticalSection );
+
+    return XBDM_NOERR;
+}
+
+
+//-----------------------------------------------------------------------------
+// Name: DebugConsoleHandleCommands()
+// Desc: Poll routine called periodically (typically every frame) by the Xbox
+//       app to see if there is a command waiting to be executed, and if so,
+//       execute it.
+//-----------------------------------------------------------------------------
+BOOL DebugConsoleHandleCommands()
+{
+    static BOOL bInitialized = FALSE;
+    CHAR  strLocalBuf[MAXRCMDLENGTH+1]; // local copy of command
+
+    // Initialize ourselves when we're first called.
+    if( !bInitialized )
+    {
+        // Register our command handler with the debug monitor
+        HRESULT hr = DmRegisterCommandProcessor( g_strDebugConsoleCommandPrefix, 
+                                                 DebugConsoleCmdProcessor );
+        if( FAILED(hr) )
+            return FALSE;
+
+        // We'll also need a critical section to protect access to g_strRemoteBuf
+        InitializeCriticalSection( &g_CriticalSection );
+
+        bInitialized = TRUE;
+    }
+
+    // If there's nothing waiting, return.
+    if( !g_strRemoteBuf[0] )
+        return FALSE;
+
+    // Grab a local copy of the command received in the remote buffer
+    EnterCriticalSection( &g_CriticalSection );
+
+    lstrcpyA( strLocalBuf, g_strRemoteBuf );
+    g_strRemoteBuf[0] = 0;
+
+    LeaveCriticalSection( &g_CriticalSection );
+
+	Cbuf_ExecuteText( EXEC_APPEND, va("%s\n", strLocalBuf) );
+
+    return TRUE;
+}
+
diff --git a/codemp/win32/dbg_console_xbox.h b/codemp/win32/dbg_console_xbox.h
new file mode 100644
index 0000000..c6b3732
--- /dev/null
+++ b/codemp/win32/dbg_console_xbox.h
@@ -0,0 +1,34 @@
+//-----------------------------------------------------------------------------
+// File: dbg_console_xbox.h
+//
+// Desc: Header file for communicating with a remote debug console. Please read
+//       the comments in the dbg_console_xbox.cpp file for more info
+//       on the API.
+//
+//       This header defines the following arrays:
+//
+//          g_RemoteCommands -  This is the list of commands your application provides.
+//                              Note that "help" and "set" are provided automatically
+//                              This is implemented in DebugCmd.cpp
+//
+//          g_RemoteVariables - This is a list of variables that your application
+//                              exposes. They can be examined and modified by the
+//                              remote debug console with the "set" command. 
+//                              This is implemented in DebugChannel.cpp
+//
+// Hist: 02.05.01 - Initial creation for March XDK release
+//       08.21.02 - Revision and code cleanup
+//
+// Copyright (c) Microsoft Corporation. All rights reserved.
+//-----------------------------------------------------------------------------
+#ifndef DEBUGCMD_H
+#define DEBUGCMD_H
+
+#define MAXRCMDLENGTH       256                 // Size of the remote cmd buffer
+
+// Handle any remote commands that have been sent - this should be called
+// periodically by the application
+BOOL DebugConsoleHandleCommands();
+
+#endif // DEBUGCMD_H
+
diff --git a/codemp/win32/glw_win.h b/codemp/win32/glw_win.h
new file mode 100644
index 0000000..4fbef00
--- /dev/null
+++ b/codemp/win32/glw_win.h
@@ -0,0 +1,33 @@
+#ifndef _WIN32
+#  error You should not be including this file on this platform
+#endif
+
+#ifndef __GLW_WIN_H__
+#define __GLW_WIN_H__
+#include <windows.h>
+
+typedef struct
+{
+	WNDPROC		wndproc;
+
+	HDC     hDC;			// handle to device context
+	HGLRC   hGLRC;			// handle to GL rendering context
+
+	HINSTANCE hinstOpenGL;	// HINSTANCE for the OpenGL library
+
+	qboolean allowdisplaydepthchange;
+	qboolean pixelFormatSet;
+
+	int		 desktopBitsPixel;
+	int		 desktopWidth, desktopHeight;
+
+	qboolean	cdsFullscreen;
+
+	FILE *log_fp;
+} glwstate_t;
+
+extern glwstate_t glw_state;
+
+bool GL_CheckForExtension(const char *ext);
+
+#endif
diff --git a/codemp/win32/glw_win_dx8.h b/codemp/win32/glw_win_dx8.h
new file mode 100644
index 0000000..1098f61
--- /dev/null
+++ b/codemp/win32/glw_win_dx8.h
@@ -0,0 +1,180 @@
+
+/*
+ * UNPUBLISHED -- Rights  reserved  under  the  copyright  laws  of the 
+ * United States.  Use  of a copyright notice is precautionary only and 
+ * does not imply publication or disclosure.                            
+ *                                                                      
+ * THIS DOCUMENTATION CONTAINS CONFIDENTIAL AND PROPRIETARY INFORMATION 
+ * OF    VICARIOUS   VISIONS,  INC.    ANY  DUPLICATION,  MODIFICATION, 
+ * DISTRIBUTION, OR DISCLOSURE IS STRICTLY PROHIBITED WITHOUT THE PRIOR 
+ * EXPRESS WRITTEN PERMISSION OF VICARIOUS VISIONS, INC.
+ */
+
+#ifndef __GLW_WIN_H__
+#define __GLW_WIN_H__
+
+#include <map>
+
+#include <d3d8.h>
+#ifdef _WIN32
+#include <d3dx8.h>
+#endif
+
+#include "../renderer/qgl_console.h"
+#include "../game/q_shared.h"
+#include "../qcommon/qfiles.h"
+
+#define GLW_MAX_TEXTURE_STAGES 2
+#define GLW_MAX_STRIPS 2048
+
+
+struct glwstate_t
+{
+	// Interface to DX
+	IDirect3DDevice8* device;
+
+	// Matrix stuff
+	enum MatrixMode
+	{
+		MatrixMode_Model = 0,
+		MatrixMode_Projection = 1,
+		MatrixMode_Texture0 = 2,
+		MatrixMode_Texture1 = 3,
+		MatrixMode_Texture2 = 4,
+		MatrixMode_Texture3 = 5,
+
+		Num_MatrixModes
+	};
+	
+	ID3DXMatrixStack* matrixStack[Num_MatrixModes];
+	MatrixMode matrixMode;
+
+	// Current primitive mode (triangles/quads/strips)
+	D3DPRIMITIVETYPE primitiveMode;
+
+	// Are we in a glBegin/glEnd block? (Used for sanity checks.)
+	bool inDrawBlock;
+	
+	// Texturing
+	bool textureStageDirty[GLW_MAX_TEXTURE_STAGES];
+	bool textureStageEnable[GLW_MAX_TEXTURE_STAGES];
+	GLuint currentTexture[GLW_MAX_TEXTURE_STAGES];
+	D3DTEXTUREOP textureEnv[GLW_MAX_TEXTURE_STAGES];
+	
+	struct TextureInfo
+	{
+		IDirect3DTexture8* mipmap;
+		D3DTEXTUREFILTERTYPE minFilter, mipFilter, magFilter;
+		D3DTEXTUREADDRESS wrapU, wrapV;
+		float anisotropy;
+	};
+
+	typedef std::map<GLuint, TextureInfo> texturexlat_t;
+	texturexlat_t textureXlat;
+
+	GLuint textureBindNum;
+
+	GLuint serverTU, clientTU;
+
+	// Pointers to various draw buffers
+	const void* vertexPointer;
+	const void* normalPointer;
+	const void* texCoordPointer[GLW_MAX_TEXTURE_STAGES];
+	const void* colorPointer;
+
+#ifdef _WINDOWS
+	// Temporary storage used when rendering quads
+	const void* vertexPointerBack;
+	const void* normalPointerBack;
+	const void* texCoordPointerBack[GLW_MAX_TEXTURE_STAGES];
+	const void* colorPointerBack;
+#endif
+
+	// State of draw buffers
+	bool colorArrayState;
+	bool texCoordArrayState[GLW_MAX_TEXTURE_STAGES];
+	bool vertexArrayState;
+	bool normalArrayState;
+	
+	// Stride of various draw buffers
+	int vertexStride;
+	int texCoordStride[GLW_MAX_TEXTURE_STAGES];
+	int colorStride;
+	int normalStride;
+
+	// Current number of verts in this packet
+	int numVertices;
+
+	// Max verts allowed in this packet
+	int maxVertices;
+
+	// Total verts to draw (may take multiple packets)
+	int totalVertices;
+
+	// Current number of indices in this packet
+	int numIndices;
+
+	// Max indices allowed in this packet
+	int maxIndices;
+
+	// Total indices to draw
+	int totalIndices;
+
+	// Culling
+	bool cullEnable;
+	D3DCULL cullMode;
+
+	// Viewport
+	D3DVIEWPORT8 viewport;
+
+	// Clearing info
+	D3DCOLOR clearColor;
+	float clearDepth;
+	int clearStencil;
+
+	// Widescreen mode
+	bool isWidescreen;
+
+	// Global color
+	D3DCOLOR currentColor;
+
+	// Scissoring
+	bool scissorEnable;
+	D3DRECT scissorBox;
+
+	// Directional Light
+	D3DLIGHT8	dirLight;
+	D3DMATERIAL8 mtrl;
+
+	// Description of current shader
+	DWORD shaderMask;
+
+	// Should we reset matrices on next draw?
+	bool matricesDirty[Num_MatrixModes];
+
+	// Render commands go here
+	DWORD* drawArray;
+	DWORD drawStride;
+
+	// This is designed to be an optimization for triangle strips
+	// as well as making life easier for the flare effect
+	GLushort strip_dest[SHADER_MAX_INDEXES];
+	GLuint strip_lengths[GLW_MAX_STRIPS];
+	GLsizei num_strip_lengths;
+
+#ifdef _XBOX
+//	class FlareEffect*	flareEffect;
+	class LightEffects* lightEffects;
+#endif
+};
+
+extern glwstate_t *glw_state;
+
+void renderObject_HACK();
+void renderObject_Light();
+void renderObject_Env();
+void renderObject_Bump();
+bool CreateVertexShader( const CHAR* strFilename, const DWORD* pdwVertexDecl, DWORD* pdwVertexShader );
+bool CreatePixelShader( const CHAR* strFilename, DWORD* pdwPixelShader );
+
+#endif
diff --git a/codemp/win32/qe3.ico b/codemp/win32/qe3.ico
new file mode 100644
index 0000000..ac9cf1f
Binary files /dev/null and b/codemp/win32/qe3.ico differ
diff --git a/codemp/win32/resource.h b/codemp/win32/resource.h
new file mode 100644
index 0000000..c5d1f46
--- /dev/null
+++ b/codemp/win32/resource.h
@@ -0,0 +1,23 @@
+//{{NO_DEPENDENCIES}}
+// Microsoft Developer Studio generated include file.
+// Used by winquake.rc
+//
+#define IDS_STRING1                     1
+#define IDI_ICON1                       1
+#define IDB_BITMAP1                     1
+#define IDB_BITMAP2                     128
+#define IDC_CURSOR1                     129
+#define IDC_CURSOR2                     130
+#define IDC_CURSOR3                     131
+
+// Next default values for new objects
+// 
+#ifdef APSTUDIO_INVOKED
+#ifndef APSTUDIO_READONLY_SYMBOLS
+#define _APS_NO_MFC                     1
+#define _APS_NEXT_RESOURCE_VALUE        132
+#define _APS_NEXT_COMMAND_VALUE         40001
+#define _APS_NEXT_CONTROL_VALUE         1005
+#define _APS_NEXT_SYMED_VALUE           101
+#endif
+#endif
diff --git a/codemp/win32/snd_fx_img.h b/codemp/win32/snd_fx_img.h
new file mode 100644
index 0000000..d226885
--- /dev/null
+++ b/codemp/win32/snd_fx_img.h
@@ -0,0 +1,85 @@
+
+#pragma once
+
+typedef enum _DSP_IMAGE_image_FX_INDICES {
+    GraphI3DL2_I3DL2Reverb = 0,
+    GraphXTalk_XTalk = 1,
+    GraphVoice_Voice_0 = 2,
+    GraphVoice_Voice_1 = 3,
+    GraphVoice_Voice_2 = 4,
+    GraphVoice_Voice_3 = 5
+} DSP_IMAGE_image_FX_INDICES;
+
+#define DSI3DL2_ENVIRONMENT_GraphI3DL2_I3DL2Reverb -1000, -100, 0.000000, 1.490000, 0.830000, -2602, 0.007000, 200, 0.011000, 100.000000, 100.000000, 5000.000000
+
+typedef struct _GraphI3DL2_FX0_I3DL2Reverb_STATE {
+    DWORD dwScratchOffset;        // Offset in bytes, of scratch area for this FX
+    DWORD dwScratchLength;        // Length in DWORDS, of scratch area for this FX
+    DWORD dwYMemoryOffset;        // Offset in DSP WORDS, of Y memory area for this FX
+    DWORD dwYMemoryLength;        // Length in DSP WORDS, of Y memory area for this FX
+    DWORD dwFlags;                // FX bitfield for various flags. See xgpimage documentation
+    DWORD dwInMixbinPtrs[2];      // XRAM offsets in DSP WORDS, of input mixbins
+    DWORD dwOutMixbinPtrs[35];     // XRAM offsets in DSP WORDS, of output mixbins
+} GraphI3DL2_FX0_I3DL2Reverb_STATE, *LPGraphI3DL2_FX0_I3DL2Reverb_STATE;
+
+typedef const GraphI3DL2_FX0_I3DL2Reverb_STATE *LPCGraphI3DL2_FX0_I3DL2Reverb_STATE;
+
+typedef struct _GraphXTalk_FX0_XTalk_STATE {
+    DWORD dwScratchOffset;        // Offset in bytes, of scratch area for this FX
+    DWORD dwScratchLength;        // Length in DWORDS, of scratch area for this FX
+    DWORD dwYMemoryOffset;        // Offset in DSP WORDS, of Y memory area for this FX
+    DWORD dwYMemoryLength;        // Length in DSP WORDS, of Y memory area for this FX
+    DWORD dwFlags;                // FX bitfield for various flags. See xgpimage documentation
+    DWORD dwInMixbinPtrs[4];      // XRAM offsets in DSP WORDS, of input mixbins
+    DWORD dwOutMixbinPtrs[4];     // XRAM offsets in DSP WORDS, of output mixbins
+} GraphXTalk_FX0_XTalk_STATE, *LPGraphXTalk_FX0_XTalk_STATE;
+
+typedef const GraphXTalk_FX0_XTalk_STATE *LPCGraphXTalk_FX0_XTalk_STATE;
+
+typedef struct _GraphVoice_FX0_Voice_0_STATE {
+    DWORD dwScratchOffset;        // Offset in bytes, of scratch area for this FX
+    DWORD dwScratchLength;        // Length in DWORDS, of scratch area for this FX
+    DWORD dwYMemoryOffset;        // Offset in DSP WORDS, of Y memory area for this FX
+    DWORD dwYMemoryLength;        // Length in DSP WORDS, of Y memory area for this FX
+    DWORD dwFlags;                // FX bitfield for various flags. See xgpimage documentation
+    DWORD dwInMixbinPtrs[1];      // XRAM offsets in DSP WORDS, of input mixbins
+    DWORD dwOutMixbinPtrs[1];     // XRAM offsets in DSP WORDS, of output mixbins
+} GraphVoice_FX0_Voice_0_STATE, *LPGraphVoice_FX0_Voice_0_STATE;
+
+typedef const GraphVoice_FX0_Voice_0_STATE *LPCGraphVoice_FX0_Voice_0_STATE;
+
+typedef struct _GraphVoice_FX1_Voice_1_STATE {
+    DWORD dwScratchOffset;        // Offset in bytes, of scratch area for this FX
+    DWORD dwScratchLength;        // Length in DWORDS, of scratch area for this FX
+    DWORD dwYMemoryOffset;        // Offset in DSP WORDS, of Y memory area for this FX
+    DWORD dwYMemoryLength;        // Length in DSP WORDS, of Y memory area for this FX
+    DWORD dwFlags;                // FX bitfield for various flags. See xgpimage documentation
+    DWORD dwInMixbinPtrs[1];      // XRAM offsets in DSP WORDS, of input mixbins
+    DWORD dwOutMixbinPtrs[1];     // XRAM offsets in DSP WORDS, of output mixbins
+} GraphVoice_FX1_Voice_1_STATE, *LPGraphVoice_FX1_Voice_1_STATE;
+
+typedef const GraphVoice_FX1_Voice_1_STATE *LPCGraphVoice_FX1_Voice_1_STATE;
+
+typedef struct _GraphVoice_FX2_Voice_2_STATE {
+    DWORD dwScratchOffset;        // Offset in bytes, of scratch area for this FX
+    DWORD dwScratchLength;        // Length in DWORDS, of scratch area for this FX
+    DWORD dwYMemoryOffset;        // Offset in DSP WORDS, of Y memory area for this FX
+    DWORD dwYMemoryLength;        // Length in DSP WORDS, of Y memory area for this FX
+    DWORD dwFlags;                // FX bitfield for various flags. See xgpimage documentation
+    DWORD dwInMixbinPtrs[1];      // XRAM offsets in DSP WORDS, of input mixbins
+    DWORD dwOutMixbinPtrs[1];     // XRAM offsets in DSP WORDS, of output mixbins
+} GraphVoice_FX2_Voice_2_STATE, *LPGraphVoice_FX2_Voice_2_STATE;
+
+typedef const GraphVoice_FX2_Voice_2_STATE *LPCGraphVoice_FX2_Voice_2_STATE;
+
+typedef struct _GraphVoice_FX3_Voice_3_STATE {
+    DWORD dwScratchOffset;        // Offset in bytes, of scratch area for this FX
+    DWORD dwScratchLength;        // Length in DWORDS, of scratch area for this FX
+    DWORD dwYMemoryOffset;        // Offset in DSP WORDS, of Y memory area for this FX
+    DWORD dwYMemoryLength;        // Length in DSP WORDS, of Y memory area for this FX
+    DWORD dwFlags;                // FX bitfield for various flags. See xgpimage documentation
+    DWORD dwInMixbinPtrs[1];      // XRAM offsets in DSP WORDS, of input mixbins
+    DWORD dwOutMixbinPtrs[1];     // XRAM offsets in DSP WORDS, of output mixbins
+} GraphVoice_FX3_Voice_3_STATE, *LPGraphVoice_FX3_Voice_3_STATE;
+
+typedef const GraphVoice_FX3_Voice_3_STATE *LPCGraphVoice_FX3_Voice_3_STATE;
diff --git a/codemp/win32/ui.rc b/codemp/win32/ui.rc
new file mode 100644
index 0000000..bf5f5a1
--- /dev/null
+++ b/codemp/win32/ui.rc
@@ -0,0 +1,104 @@
+// Microsoft Visual C++ generated resource script.
+//
+#include "resource.h"
+
+#define APSTUDIO_READONLY_SYMBOLS
+/////////////////////////////////////////////////////////////////////////////
+//
+// Generated from the TEXTINCLUDE 2 resource.
+//
+#include "afxres.h"
+
+/////////////////////////////////////////////////////////////////////////////
+#undef APSTUDIO_READONLY_SYMBOLS
+
+/////////////////////////////////////////////////////////////////////////////
+// English (U.S.) resources
+
+#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU)
+#ifdef _WIN32
+LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US
+#pragma code_page(1252)
+#endif //_WIN32
+
+#ifdef APSTUDIO_INVOKED
+/////////////////////////////////////////////////////////////////////////////
+//
+// TEXTINCLUDE
+//
+
+1 TEXTINCLUDE 
+BEGIN
+    "resource.h\0"
+END
+
+2 TEXTINCLUDE 
+BEGIN
+    "#include ""afxres.h""\r\n"
+    "\0"
+END
+
+3 TEXTINCLUDE 
+BEGIN
+    "\r\n"
+    "\0"
+END
+
+#endif    // APSTUDIO_INVOKED
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// Version
+//
+#include "AutoVersion.h"
+
+VS_VERSION_INFO VERSIONINFO
+ FILEVERSION VERSION_MAJOR_RELEASE,VERSION_MINOR_RELEASE,VERSION_EXTERNAL_BUILD,VERSION_INTERNAL_BUILD
+ PRODUCTVERSION VERSION_MAJOR_RELEASE,VERSION_MINOR_RELEASE,VERSION_EXTERNAL_BUILD,VERSION_INTERNAL_BUILD
+ FILEFLAGSMASK 0x17L
+#ifdef _DEBUG
+ FILEFLAGS 0x1L
+#else
+ FILEFLAGS 0x0L
+#endif
+ FILEOS 0x4L
+ FILETYPE 0x2L
+ FILESUBTYPE 0x0L
+BEGIN
+    BLOCK "StringFileInfo"
+    BEGIN
+        BLOCK "040904b0"
+        BEGIN
+            VALUE "Comments", "Raven Software"
+            VALUE "CompanyName", "Activision Inc"
+            VALUE "FileDescription", "JA User Interface DLL"
+            VALUE "FileVersion", VERSION_STRING
+            VALUE "InternalName", "ui"
+            VALUE "LegalCopyright", "Copyright (C) 2003"
+            VALUE "OriginalFilename", "ui.dll"
+            VALUE "ProductName", "Jedi Knight®: Jedi Academy (MP)"
+            VALUE "ProductVersion", VERSION_STRING
+        END
+    END
+    BLOCK "VarFileInfo"
+    BEGIN
+        VALUE "Translation", 0x409, 1200
+    END
+END
+
+#endif    // English (U.S.) resources
+/////////////////////////////////////////////////////////////////////////////
+
+
+
+#ifndef APSTUDIO_INVOKED
+/////////////////////////////////////////////////////////////////////////////
+//
+// Generated from the TEXTINCLUDE 3 resource.
+//
+
+
+/////////////////////////////////////////////////////////////////////////////
+#endif    // not APSTUDIO_INVOKED
+
diff --git a/codemp/win32/vssver.scc b/codemp/win32/vssver.scc
new file mode 100644
index 0000000..bd69e45
Binary files /dev/null and b/codemp/win32/vssver.scc differ
diff --git a/codemp/win32/win_file.h b/codemp/win32/win_file.h
new file mode 100644
index 0000000..a668ec0
--- /dev/null
+++ b/codemp/win32/win_file.h
@@ -0,0 +1,32 @@
+
+/*
+ * UNPUBLISHED -- Rights  reserved  under  the  copyright  laws  of the 
+ * United States.  Use  of a copyright notice is precautionary only and 
+ * does not imply publication or disclosure.                            
+ *                                                                      
+ * THIS DOCUMENTATION CONTAINS CONFIDENTIAL AND PROPRIETARY INFORMATION 
+ * OF    VICARIOUS   VISIONS,  INC.    ANY  DUPLICATION,  MODIFICATION, 
+ * DISTRIBUTION, OR DISCLOSURE IS STRICTLY PROHIBITED WITHOUT THE PRIOR 
+ * EXPRESS WRITTEN PERMISSION OF VICARIOUS VISIONS, INC.
+ */
+
+#ifndef _WIN_FILE_
+#define _WIN_FILE_
+
+typedef int wfhandle_t;
+
+extern void WF_Init(void);
+extern void WF_Shutdown(void);
+extern wfhandle_t WF_Open(const char* name, bool read, bool aligned);
+extern void WF_Close(wfhandle_t handle);
+extern int WF_Read(void* buffer, int len, wfhandle_t handle);
+extern int WF_Write(const void* buffer, int len, wfhandle_t handle);
+extern int WF_Seek(int offset, int origin, wfhandle_t handle);
+extern int WF_Tell(wfhandle_t handle);
+extern int WF_Resize(int size, wfhandle_t handle);
+
+int Sys_GetFileCode(const char *name);
+void Sys_InitFileCodes(void);
+void Sys_ShutdownFileCodes(void);
+
+#endif _WIN_FILE_
diff --git a/codemp/win32/win_file_xbox.cpp b/codemp/win32/win_file_xbox.cpp
new file mode 100644
index 0000000..3ac36d3
--- /dev/null
+++ b/codemp/win32/win_file_xbox.cpp
@@ -0,0 +1,171 @@
+
+/*
+ * UNPUBLISHED -- Rights  reserved  under  the  copyright  laws  of the 
+ * United States.  Use  of a copyright notice is precautionary only and 
+ * does not imply publication or disclosure.                            
+ *                                                                      
+ * THIS DOCUMENTATION CONTAINS CONFIDENTIAL AND PROPRIETARY INFORMATION 
+ * OF    VICARIOUS   VISIONS,  INC.    ANY  DUPLICATION,  MODIFICATION, 
+ * DISTRIBUTION, OR DISCLOSURE IS STRICTLY PROHIBITED WITHOUT THE PRIOR 
+ * EXPRESS WRITTEN PERMISSION OF VICARIOUS VISIONS, INC.
+ */
+
+#include "../game/q_shared.h"
+#include "win_file.h"
+#include "../qcommon/qcommon.h"
+
+#ifdef _XBOX
+#include <Xtl.h>
+#endif
+
+#ifdef _WINDOWS
+#include <windows.h>
+#endif
+
+
+struct FileTable
+{
+	bool m_bUsed;
+	bool m_bErrorsFatal;
+	HANDLE m_Handle;
+};
+
+FileTable* s_FileTable = NULL;
+const int WF_MAX_OPEN_FILES = 8;
+
+void WF_Init(void)
+{
+	assert(!s_FileTable);
+
+	s_FileTable = new FileTable[WF_MAX_OPEN_FILES];
+
+	for (wfhandle_t i = 0; i < WF_MAX_OPEN_FILES; ++i)
+	{
+		s_FileTable[i].m_bUsed = false;
+	}
+}
+
+void WF_Shutdown(void)
+{
+	assert(s_FileTable);
+	
+	for (wfhandle_t i = 0; i < WF_MAX_OPEN_FILES; ++i)
+	{
+		if (s_FileTable[i].m_bUsed)
+		{
+			WF_Close(i);
+		}
+	}
+
+	delete [] s_FileTable;
+	s_FileTable = NULL;
+}
+
+static wfhandle_t WF_GetFreeHandle(void)
+{
+	for (int i = 0; i < WF_MAX_OPEN_FILES; ++i)
+	{
+		if (!s_FileTable[i].m_bUsed)
+		{
+			return i;
+		}
+	}
+
+	return -1;
+}
+
+int WF_Open(const char* name, bool read, bool aligned)
+{
+	wfhandle_t handle = WF_GetFreeHandle();
+	if (handle == -1) return -1;
+	
+	s_FileTable[handle].m_Handle = 
+		CreateFile(name, read ? GENERIC_READ : GENERIC_READ | GENERIC_WRITE, 
+		FILE_SHARE_READ, 0, 
+		read ? OPEN_EXISTING : OPEN_ALWAYS, 
+		FILE_ATTRIBUTE_NORMAL | (aligned ? FILE_FLAG_NO_BUFFERING : 0), 0);
+
+	if (s_FileTable[handle].m_Handle != INVALID_HANDLE_VALUE)
+	{
+		s_FileTable[handle].m_bUsed = true;
+		
+		// errors are fatal on game partition
+		s_FileTable[handle].m_bErrorsFatal = (name[0] == 'D' || name[0] == 'd');
+		
+		return handle;
+	}
+	
+	return -1;
+}
+
+void WF_Close(wfhandle_t handle)
+{
+	assert(handle >= 0 && handle < WF_MAX_OPEN_FILES && 
+		s_FileTable[handle].m_bUsed);
+
+	CloseHandle(s_FileTable[handle].m_Handle);
+	s_FileTable[handle].m_bUsed = false;
+}
+
+int WF_Read(void* buffer, int len, wfhandle_t handle)
+{
+	assert(handle >= 0 && handle < WF_MAX_OPEN_FILES && 
+		s_FileTable[handle].m_bUsed);
+
+	DWORD bytes;
+	if (!ReadFile(s_FileTable[handle].m_Handle, buffer, len, &bytes, 0) &&
+		s_FileTable[handle].m_bErrorsFatal)
+	{
+#if 0	// VVFIXME
+		extern void ERR_DiscFail(bool);
+		ERR_DiscFail(false);
+#else
+		assert(0);
+#endif
+	}
+
+	return bytes;
+}
+
+int WF_Write(const void* buffer, int len, wfhandle_t handle)
+{
+	assert(handle >= 0 && handle < WF_MAX_OPEN_FILES && 
+		s_FileTable[handle].m_bUsed);
+
+	DWORD bytes;
+	WriteFile(s_FileTable[handle].m_Handle, buffer, len, &bytes, 0);
+	return bytes;
+}
+
+int WF_Seek(int offset, int origin, wfhandle_t handle)
+{
+	assert(handle >= 0 && handle < WF_MAX_OPEN_FILES && 
+		s_FileTable[handle].m_bUsed);
+
+	switch (origin)
+	{
+	case SEEK_CUR: origin = FILE_CURRENT; break;
+	case SEEK_END: origin = FILE_END; break;
+	case SEEK_SET: origin = FILE_BEGIN; break;
+	default: assert(false);
+	}
+
+	return SetFilePointer(s_FileTable[handle].m_Handle, offset, 0, origin) < 0;
+}
+
+int WF_Tell(wfhandle_t handle)
+{
+	assert(handle >= 0 && handle < WF_MAX_OPEN_FILES && 
+		s_FileTable[handle].m_bUsed);
+
+	return SetFilePointer(s_FileTable[handle].m_Handle, 0, 0, FILE_CURRENT);
+}
+
+int WF_Resize(int size, wfhandle_t handle)
+{
+	assert(handle >= 0 && handle < WF_MAX_OPEN_FILES && 
+		s_FileTable[handle].m_bUsed);
+
+	SetFilePointer(s_FileTable[handle].m_Handle, size, NULL, FILE_BEGIN);
+	return SetEndOfFile(s_FileTable[handle].m_Handle);
+}
diff --git a/codemp/win32/win_filecode.cpp b/codemp/win32/win_filecode.cpp
new file mode 100644
index 0000000..3528052
--- /dev/null
+++ b/codemp/win32/win_filecode.cpp
@@ -0,0 +1,345 @@
+
+/*
+ * UNPUBLISHED -- Rights  reserved  under  the  copyright  laws  of the 
+ * United States.  Use  of a copyright notice is precautionary only and 
+ * does not imply publication or disclosure.                            
+ *                                                                      
+ * THIS DOCUMENTATION CONTAINS CONFIDENTIAL AND PROPRIETARY INFORMATION 
+ * OF    VICARIOUS   VISIONS,  INC.    ANY  DUPLICATION,  MODIFICATION, 
+ * DISTRIBUTION, OR DISCLOSURE IS STRICTLY PROHIBITED WITHOUT THE PRIOR 
+ * EXPRESS WRITTEN PERMISSION OF VICARIOUS VISIONS, INC.
+ */
+
+#include "../server/exe_headers.h"
+#include "../client/client.h"
+#include "../win32/win_local.h"
+#include "../qcommon/qcommon.h"
+#include "../qcommon/fixedmap.h"
+#include "../zlib/zlib.h"
+#include "../qcommon/files.h"
+
+/***********************************************
+*
+* WINDOWS/XBOX VERSION
+*
+* Build a translation table, CRC -> file name.  We have the memory.
+*
+************************************************/
+
+#if defined(_WINDOWS)
+#include <windows.h>
+#elif defined(_XBOX)
+#include <xtl.h>
+#endif
+
+struct FileInfo
+{
+	char* name;
+	int size;
+};
+static VVFixedMap< FileInfo, unsigned int >* s_Files = NULL;
+static byte* buffer;
+
+HANDLE s_Mutex = INVALID_HANDLE_VALUE;
+
+int _buildFileList(const char* path, bool insert, bool buildList)
+{
+	WIN32_FIND_DATA data;
+	char spec[MAX_OSPATH];
+	int count = 0;
+
+	// Look for all files
+	Com_sprintf(spec, sizeof(spec), "%s\\*.*", path);
+
+	HANDLE h = FindFirstFile(spec, &data);
+	while (h != INVALID_HANDLE_VALUE)
+	{
+		char full[MAX_OSPATH];
+		Com_sprintf(full, sizeof(full), "%s\\%s", path, data.cFileName);
+
+		if (data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
+		{
+			// Directory -- lets go recursive
+			if (data.cFileName[0] != '.') {
+				count += _buildFileList(full, insert, buildList);
+			}
+		}
+		else
+		{
+
+			if(insert || buildList)
+			{
+				// Regular file -- add it to the table
+				strlwr(full);
+				unsigned int code = crc32(0, (const byte *)full, strlen(full));
+
+				FileInfo info;
+				info.name = CopyString(full);
+				info.size = data.nFileSizeLow;
+
+				if(insert)
+				{
+					s_Files->Insert(info, code);
+				}
+
+				if(buildList)
+				{
+					// get the length of the filename
+					int len;
+					len = strlen(info.name) + 1;
+
+					// save the file code
+					*(int*)buffer		=  code;
+					buffer				+= sizeof(code);
+
+					// save the name of the file
+					strcpy((char*)buffer,info.name);
+					buffer				+= len;
+
+					// save the size of the file
+					*(int*)buffer		= info.size;
+					buffer				+= sizeof(info.size);
+				}
+			}
+
+			count++;
+		}
+
+		// Continue the loop
+		if (!FindNextFile(h, &data))
+		{
+			FindClose(h);
+			return count;
+		}
+	}
+	return count;
+}
+
+bool _buildFileListFromSavedList(void)
+{
+	// open the file up for reading
+	FILE*	in;
+	in = fopen("d:\\xbx_filelist","rb");
+	if(!in)
+	{
+		return false;
+	}
+
+	// read in the number of files
+	int count;
+	if(!(fread(&count,sizeof(count),1,in)))
+	{
+		fclose(in);
+		return false;
+	}
+
+	// allocate memory for a temp buffer
+	byte*	baseAddr;
+	int bufferSize;
+	bufferSize	= count * ( 2 * sizeof(int) + MAX_OSPATH );
+	buffer		= (byte*)Z_Malloc(bufferSize,TAG_TEMP_WORKSPACE,qtrue,32);
+	baseAddr	= buffer;
+
+	// read the rest of the file into a big buffer
+	if(!(fread(buffer,bufferSize,1,in)))
+	{
+		fclose(in);
+		Z_Free(baseAddr);
+		return false;
+	}
+
+	// allocate some memory for s_Files
+	s_Files = new VVFixedMap<FileInfo, unsigned int>(count);
+
+	// loop through all the files write out the codes
+	int i;
+	for(i = 0; i < count; i++)
+	{
+		FileInfo info;
+		unsigned int code;
+
+		// read the code for the file
+		code	=  *(int*)buffer;
+		buffer	+= sizeof(code);
+
+		// read the filename
+		info.name = CopyString((char*)buffer);
+		buffer	+= (strlen(info.name) + 1);
+
+		// read the size of the file
+		info.size	=  *(int*)buffer;
+		buffer		+= sizeof(info.size);
+
+		// save the data
+		s_Files->Insert(info, code);
+	}
+
+	fclose(in);
+	Z_Free(baseAddr);
+	return true;
+}
+
+bool Sys_SaveFileCodes(void)
+{
+	bool ret;
+	int res;
+
+	// get the number of files
+	int count;
+	count = _buildFileList(Sys_Cwd(), false, false);
+
+	// open a file for writing
+	FILE* out;
+	out = fopen("d:\\xbx_filelist","wb");
+	if(!out)
+	{
+		return false;
+	}
+
+	// allocate a buffer for writing
+	byte*	baseAddr;
+	int		bufferSize;
+	
+	bufferSize	= sizeof(int) + ( count * ( 2 * sizeof(int) + MAX_OSPATH ) );
+	baseAddr	= (byte*)Z_Malloc(bufferSize,TAG_TEMP_WORKSPACE,qtrue,32);
+	buffer		= baseAddr;
+
+	// write the number of files to the buffer
+	*(int*)buffer	=  count;
+	buffer			+= sizeof(count);
+
+	// fill up the rest of the buffer
+	ret = _buildFileList(Sys_Cwd(), false, true);
+
+	if(!ret)
+	{
+		// there was a problem
+		fclose(out);
+		Z_Free(baseAddr);
+		return false;
+	}
+
+	// attempt to write out the data
+	if(!(fwrite(baseAddr,bufferSize,1,out)))
+	{
+		// there was a problem
+		fclose(out);
+		Z_Free(baseAddr);
+		return false;
+	}
+
+	// everything went ok
+	fclose(out);
+	Z_Free(baseAddr);
+	return true;
+}
+
+void Sys_InitFileCodes(void)
+{
+	bool ret;
+	int count = 0;
+
+	// First: try to load an existing filecode cache
+	ret = _buildFileListFromSavedList();
+
+	// if we had trouble building the list that way
+	// we need to do it by searching the files
+	if( !ret )
+	{
+		// There was no filelist cache, make one
+		if( !Sys_SaveFileCodes() )
+			Com_Error( ERR_DROP, "ERROR: Couldn't create filecode cache\n" );
+
+		// Now re-read it
+		if( !_buildFileListFromSavedList() )
+			Com_Error( ERR_DROP, "ERROR: Couldn't re-read filecode cache\n" );
+	}
+	s_Files->Sort();
+
+	// make it thread safe
+	s_Mutex = CreateMutex(NULL, FALSE, NULL);
+}
+
+void Sys_ShutdownFileCodes(void)
+{
+	FileInfo*	info = NULL;
+
+	info = s_Files->Pop();
+	while(info)
+	{
+		Z_Free(info->name);
+		info->name = NULL;
+		info = s_Files->Pop();
+	}
+
+	delete s_Files;
+	s_Files = NULL;
+
+	CloseHandle(s_Mutex);
+}
+
+int Sys_GetFileCode(const char* name)
+{
+	WaitForSingleObject(s_Mutex, INFINITE);
+
+	// Get system level path
+	char* osname = FS_BuildOSPath(name);
+	
+	// Generate hash for file name
+	strlwr(osname);
+	unsigned int code = crc32(0, (const byte *)osname, strlen(osname));
+	
+	// Check if the file exists
+	if (!s_Files->Find(code))
+	{
+		ReleaseMutex(s_Mutex);
+		return -1;
+	}
+
+	ReleaseMutex(s_Mutex);
+	return code;
+}
+
+const char* Sys_GetFileCodeName(int code)
+{
+	WaitForSingleObject(s_Mutex, INFINITE);
+
+	FileInfo *entry = s_Files->Find(code);
+	if (entry)
+	{
+		ReleaseMutex(s_Mutex);
+		return entry->name;
+	}
+	
+	ReleaseMutex(s_Mutex);
+	return NULL;
+}
+
+int Sys_GetFileCodeSize(int code)
+{
+	WaitForSingleObject(s_Mutex, INFINITE);
+
+	FileInfo *entry = s_Files->Find(code);
+	if (entry)
+	{
+		ReleaseMutex(s_Mutex);
+		return entry->size;
+	}
+	
+	ReleaseMutex(s_Mutex);
+	return -1;
+}
+// Quick function to re-scan for new files, update the filecode
+// table, and dump the new one to disk
+void Sys_FilecodeScan_f( void )
+{
+	// Make an updated filecode cache
+	if( !Sys_SaveFileCodes() )
+		Com_Error( ERR_DROP, "ERROR: Couldn't create filecode cache\n" );
+
+	// Throw out our current list
+	Sys_ShutdownFileCodes();
+
+	// Re-init, which should use the new list we just made
+	Sys_InitFileCodes();
+}
diff --git a/codemp/win32/win_gamma.cpp b/codemp/win32/win_gamma.cpp
new file mode 100644
index 0000000..88272e9
--- /dev/null
+++ b/codemp/win32/win_gamma.cpp
@@ -0,0 +1,165 @@
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+/*
+** WIN_GAMMA.C
+*/
+#include <assert.h>
+#include "../renderer/tr_local.h"
+#include "../qcommon/qcommon.h"
+#include "glw_win.h"
+#include "win_local.h"
+
+static unsigned short s_oldHardwareGamma[3][256];
+
+/*
+** WG_CheckHardwareGamma
+**
+** Determines if the underlying hardware supports the Win32 gamma correction API.
+*/
+void WG_CheckHardwareGamma( void )
+{
+	HDC			hDC;
+
+	glConfig.deviceSupportsGamma = qfalse;
+
+	if ( !r_ignorehwgamma->integer )
+	{
+		hDC = GetDC( GetDesktopWindow() );
+		glConfig.deviceSupportsGamma = (qboolean)GetDeviceGammaRamp( hDC, s_oldHardwareGamma );
+		ReleaseDC( GetDesktopWindow(), hDC );
+
+		if ( glConfig.deviceSupportsGamma )
+		{
+			//
+			// do a sanity check on the gamma values
+			//
+			if ( ( HIBYTE( s_oldHardwareGamma[0][255] ) <= HIBYTE( s_oldHardwareGamma[0][0] ) ) ||
+				 ( HIBYTE( s_oldHardwareGamma[1][255] ) <= HIBYTE( s_oldHardwareGamma[1][0] ) ) ||
+				 ( HIBYTE( s_oldHardwareGamma[2][255] ) <= HIBYTE( s_oldHardwareGamma[2][0] ) ) )
+			{
+				glConfig.deviceSupportsGamma = qfalse;
+				Com_Printf (S_COLOR_YELLOW  "WARNING: device has broken gamma support, generated gamma.dat\n" );
+			}
+
+			//
+			// make sure that we didn't have a prior crash in the game, and if so we need to
+			// restore the gamma values to at least a linear value
+			//
+			if ( ( HIBYTE( s_oldHardwareGamma[0][181] ) == 255 ) )
+			{
+				int g;
+
+				Com_Printf (S_COLOR_YELLOW  "WARNING: suspicious gamma tables, using linear ramp for restoration\n" );
+
+				for ( g = 0; g < 255; g++ )
+				{
+					s_oldHardwareGamma[0][g] = g << 8;
+					s_oldHardwareGamma[1][g] = g << 8;
+					s_oldHardwareGamma[2][g] = g << 8;
+				}
+			}
+		}
+	}
+}
+
+/*
+void mapGammaMax( void ) {
+	int		i, j;
+	unsigned short table[3][256];
+
+	// try to figure out what win2k will let us get away with setting
+	for ( i = 0 ; i < 256 ; i++ ) {
+		if ( i >= 128 ) {
+			table[0][i] = table[1][i] = table[2][i] = 0xffff;
+		} else {
+			table[0][i] = table[1][i] = table[2][i] = i<<9;
+		}
+	}
+
+	for ( i = 0 ; i < 128 ; i++ ) {
+		for ( j = i*2 ; j < 255 ; j++ ) {
+			table[0][i] = table[1][i] = table[2][i] = j<<8;
+			if ( !SetDeviceGammaRamp( glw_state.hDC, table ) ) {
+				break;
+			}
+		}
+		table[0][i] = table[1][i] = table[2][i] = i<<9;
+		Com_Printf( "index %i max: %i\n", i, j-1 );
+	}
+}
+*/
+
+/*
+** GLimp_SetGamma
+**
+** This routine should only be called if glConfig.deviceSupportsGamma is TRUE
+*/
+void GLimp_SetGamma( unsigned char red[256], unsigned char green[256], unsigned char blue[256] ) {
+	unsigned short table[3][256];
+	int		i, j;
+	int		ret;
+	OSVERSIONINFO	vinfo;
+
+	if ( !glConfig.deviceSupportsGamma || r_ignorehwgamma->integer || !glw_state.hDC ) {
+		return;
+	}
+
+//mapGammaMax();
+
+	for ( i = 0; i < 256; i++ ) {
+		table[0][i] = ( ( ( unsigned short ) red[i] ) << 8 ) | red[i];
+		table[1][i] = ( ( ( unsigned short ) green[i] ) << 8 ) | green[i];
+		table[2][i] = ( ( ( unsigned short ) blue[i] ) << 8 ) | blue[i];
+	}
+
+	// Win2K puts this odd restriction on gamma ramps...
+	vinfo.dwOSVersionInfoSize = sizeof(vinfo);
+	GetVersionEx( &vinfo );
+	if ( vinfo.dwMajorVersion == 5 && vinfo.dwPlatformId == VER_PLATFORM_WIN32_NT ) {
+		Com_DPrintf( "performing W2K gamma clamp.\n" );
+		for ( j = 0 ; j < 3 ; j++ ) {
+			for ( i = 0 ; i < 128 ; i++ ) {
+				if ( table[j][i] > ( (128+i) << 8 ) ) {
+					table[j][i] = (128+i) << 8;
+				}
+			}
+			if ( table[j][127] > 254<<8 ) {
+				table[j][127] = 254<<8;
+			}
+		}
+	} else {
+		Com_DPrintf( "skipping W2K gamma clamp.\n" );
+	}
+
+	// enforce constantly increasing
+	for ( j = 0 ; j < 3 ; j++ ) {
+		for ( i = 1 ; i < 256 ; i++ ) {
+			if ( table[j][i] < table[j][i-1] ) {
+				table[j][i] = table[j][i-1];
+			}
+		}
+	}
+
+
+	ret = SetDeviceGammaRamp( glw_state.hDC, table );
+	if ( !ret ) {
+		Com_Printf( "SetDeviceGammaRamp failed.\n" );
+	}
+}
+
+/*
+** WG_RestoreGamma
+*/
+void WG_RestoreGamma( void )
+{
+	if ( glConfig.deviceSupportsGamma )
+	{
+		HDC hDC;
+		
+		hDC = GetDC( GetDesktopWindow() );
+		SetDeviceGammaRamp( hDC, s_oldHardwareGamma );
+		ReleaseDC( GetDesktopWindow(), hDC );
+	}
+}
+
diff --git a/codemp/win32/win_gamma_console.cpp b/codemp/win32/win_gamma_console.cpp
new file mode 100644
index 0000000..309845c
--- /dev/null
+++ b/codemp/win32/win_gamma_console.cpp
@@ -0,0 +1,73 @@
+/*
+** WIN_GAMMA.C
+*/
+// leave this as first line for PCH reasons...
+//
+//#include "../server/exe_headers.h"
+
+
+
+#include <assert.h>
+#include "../game/q_shared.h"
+#include "../renderer/tr_local.h"
+#include "../qcommon/qcommon.h"
+#include "win_local.h"
+
+#if defined(_XBOX)
+#include "glw_win_dx8.h"
+#endif
+
+
+/*
+** WG_CheckHardwareGamma
+**
+** Determines if the underlying hardware supports the Win32 gamma correction API.
+*/
+void WG_CheckHardwareGamma( void )
+{
+	glConfig.deviceSupportsGamma = qtrue;
+}
+
+/*
+** GLimp_SetGamma
+**
+** This routine should only be called if glConfig.deviceSupportsGamma is TRUE
+*/
+void GLimp_SetGamma( float g ) {
+#if defined(_GAMECUBE)
+	GXGamma gamma = GX_GM_1_0;
+	if (g >= 2.2f)
+	{
+		gamma = GX_GM_2_2;
+	}
+	else if (g >= 1.7f)
+	{
+		gamma = GX_GM_1_7;
+	}
+	GXSetDispCopyGamma(gamma);
+#elif defined(_XBOX)
+	const int maxval = 255;
+
+	D3DGAMMARAMP ramp;
+	for ( int i = 0; i < 256; i++ )
+	{
+		int inf;
+		if ( g == 1 ) {
+			inf = maxval * i / 255.0f;
+		} else {
+			inf = maxval * pow ( i/255.0f, 1.0f / g ) + 0.5f;
+		}
+		if (inf < 0) {
+			inf = 0;
+		}
+		if (inf > maxval) {
+			inf = maxval;
+		}
+		ramp.red[i] = inf;
+		ramp.green[i] = inf;
+		ramp.blue[i] = inf;
+	}
+	glw_state->device->SetGammaRamp(D3DSGR_CALIBRATE, &ramp);
+#endif
+}
+
diff --git a/codemp/win32/win_glimp.cpp b/codemp/win32/win_glimp.cpp
new file mode 100644
index 0000000..9c367ff
--- /dev/null
+++ b/codemp/win32/win_glimp.cpp
@@ -0,0 +1,2095 @@
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+/*
+** WIN_GLIMP.C
+**
+** This file contains ALL Win32 specific stuff having to do with the
+** OpenGL refresh.  When a port is being made the following functions
+** must be implemented by the port:
+**
+** GLimp_EndFrame
+** GLimp_Init
+** GLimp_LogComment
+** GLimp_Shutdown
+**
+** Note that the GLW_xxx functions are Windows specific GL-subsystem
+** related functions that are relevant ONLY to win_glimp.c
+*/
+#include <assert.h>
+#include "../renderer/tr_local.h"
+
+#include "resource.h"
+#include "glw_win.h"
+#include "win_local.h"
+#include "../qcommon/stringed_ingame.h"
+extern void WG_CheckHardwareGamma( void );
+extern void WG_RestoreGamma( void );
+
+typedef enum {
+	RSERR_OK,
+
+	RSERR_INVALID_FULLSCREEN,
+	RSERR_INVALID_MODE,
+
+	RSERR_UNKNOWN
+} rserr_t;
+
+#define TRY_PFD_SUCCESS		0
+#define TRY_PFD_FAIL_SOFT	1
+#define TRY_PFD_FAIL_HARD	2
+
+#define	WINDOW_CLASS_NAME	"Jedi Knight®: Jedi Academy (MP)"
+
+static void		GLW_InitExtensions( void );
+static rserr_t	GLW_SetMode( int mode, 
+							 int colorbits, 
+							 qboolean cdsFullscreen );
+
+static qboolean s_classRegistered = qfalse;
+
+//
+// function declaration
+//
+void	 QGL_EnableLogging( qboolean enable );
+qboolean QGL_Init( const char *dllname );
+void     QGL_Shutdown( void );
+
+//
+// variable declarations
+//
+glwstate_t glw_state;
+
+cvar_t	*r_allowSoftwareGL;		// don't abort out if the pixelformat claims software
+
+// Whether the current hardware supports dynamic glows/flares.
+extern bool g_bDynamicGlowSupported;
+
+// Hack variable for deciding which kind of texture rectangle thing to do (for some
+// reason it acts different on radeon! It's against the spec!).
+bool g_bTextureRectangleHack = false;
+
+/*
+** GLW_StartDriverAndSetMode
+*/
+static qboolean GLW_StartDriverAndSetMode( int mode, 
+										   int colorbits,
+										   qboolean cdsFullscreen )
+{
+	rserr_t err;
+
+	err = GLW_SetMode( mode, colorbits, cdsFullscreen );
+
+	switch ( err )
+	{
+	case RSERR_INVALID_FULLSCREEN:
+		Com_Printf("...WARNING: fullscreen unavailable in this mode\n" );
+		return qfalse;
+	case RSERR_INVALID_MODE:
+		Com_Printf ("...WARNING: could not set the given mode (%d)\n", mode );
+		return qfalse;
+	default:
+		break;
+	}
+	return qtrue;
+}
+
+/*
+** ChoosePFD
+**
+** Helper function that replaces ChoosePixelFormat.
+*/
+#define MAX_PFDS 256
+
+static int GLW_ChoosePFD( HDC hDC, PIXELFORMATDESCRIPTOR *pPFD )
+{
+	PIXELFORMATDESCRIPTOR pfds[MAX_PFDS+1];
+	int maxPFD = 0;
+	int i;
+	int bestMatch = 0;
+
+	Com_Printf ("...GLW_ChoosePFD( %d, %d, %d )\n", ( int ) pPFD->cColorBits, ( int ) pPFD->cDepthBits, ( int ) pPFD->cStencilBits );
+
+	// count number of PFDs
+	maxPFD = DescribePixelFormat( hDC, 1, sizeof( PIXELFORMATDESCRIPTOR ), &pfds[0] );
+
+	if ( maxPFD > MAX_PFDS )
+	{
+		Com_Printf (S_COLOR_YELLOW  "...numPFDs > MAX_PFDS (%d > %d)\n", maxPFD, MAX_PFDS );
+		maxPFD = MAX_PFDS;
+	}
+
+	Com_Printf ("...%d PFDs found\n", maxPFD - 1 );
+
+	// grab information
+	for ( i = 1; i <= maxPFD; i++ )
+	{
+		DescribePixelFormat( hDC, i, sizeof( PIXELFORMATDESCRIPTOR ), &pfds[i] );
+	}
+
+	// look for a best match
+	for ( i = 1; i <= maxPFD; i++ )
+	{
+		//
+		// make sure this has hardware acceleration
+		//
+		if ( ( pfds[i].dwFlags & PFD_GENERIC_FORMAT ) != 0 ) 
+		{
+			if ( !r_allowSoftwareGL->integer )
+			{
+				if ( r_verbose->integer )
+				{
+					Com_Printf ("...PFD %d rejected, software acceleration\n", i );
+				}
+				continue;
+			}
+		}
+
+		// verify pixel type
+		if ( pfds[i].iPixelType != PFD_TYPE_RGBA )
+		{
+			if ( r_verbose->integer )
+			{
+				Com_Printf ("...PFD %d rejected, not RGBA\n", i );
+			}
+			continue;
+		}
+
+		// verify proper flags
+		if ( ( ( pfds[i].dwFlags & pPFD->dwFlags ) & pPFD->dwFlags ) != pPFD->dwFlags ) 
+		{
+			if ( r_verbose->integer )
+			{
+				Com_Printf ("...PFD %d rejected, improper flags (%x instead of %x)\n", i, pfds[i].dwFlags, pPFD->dwFlags );
+			}
+			continue;
+		}
+
+		// verify enough bits
+		if ( pfds[i].cDepthBits < 15 )
+		{
+			continue;
+		}
+		if ( ( pfds[i].cStencilBits < 4 ) && ( pPFD->cStencilBits > 0 ) )
+		{
+			continue;
+		}
+
+		//
+		// selection criteria (in order of priority):
+		// 
+		//  PFD_STEREO
+		//  colorBits
+		//  depthBits
+		//  stencilBits
+		//
+		if ( bestMatch )
+		{
+			// check stereo
+			if ( ( pfds[i].dwFlags & PFD_STEREO ) && ( !( pfds[bestMatch].dwFlags & PFD_STEREO ) ) && ( pPFD->dwFlags & PFD_STEREO ) )
+			{
+				bestMatch = i;
+				continue;
+			}
+			
+			if ( !( pfds[i].dwFlags & PFD_STEREO ) && ( pfds[bestMatch].dwFlags & PFD_STEREO ) && ( pPFD->dwFlags & PFD_STEREO ) )
+			{
+				bestMatch = i;
+				continue;
+			}
+
+			// check color
+			if ( pfds[bestMatch].cColorBits != pPFD->cColorBits )
+			{
+				// prefer perfect match
+				if ( pfds[i].cColorBits == pPFD->cColorBits )
+				{
+					bestMatch = i;
+					continue;
+				}
+				// otherwise if this PFD has more bits than our best, use it
+				else if ( pfds[i].cColorBits > pfds[bestMatch].cColorBits )
+				{
+					bestMatch = i;
+					continue;
+				}
+			}
+
+			// check depth
+			if ( pfds[bestMatch].cDepthBits != pPFD->cDepthBits )
+			{
+				// prefer perfect match
+				if ( pfds[i].cDepthBits == pPFD->cDepthBits )
+				{
+					bestMatch = i;
+					continue;
+				}
+				// otherwise if this PFD has more bits than our best, use it
+				else if ( pfds[i].cDepthBits > pfds[bestMatch].cDepthBits )
+				{
+					bestMatch = i;
+					continue;
+				}
+			}
+
+			// check stencil
+			if ( pfds[bestMatch].cStencilBits != pPFD->cStencilBits )
+			{
+				// prefer perfect match
+				if ( pfds[i].cStencilBits == pPFD->cStencilBits )
+				{
+					bestMatch = i;
+					continue;
+				}
+				// otherwise if this PFD has more bits than our best, use it
+				else if ( ( pfds[i].cStencilBits > pfds[bestMatch].cStencilBits ) && 
+					 ( pPFD->cStencilBits > 0 ) )
+				{
+					bestMatch = i;
+					continue;
+				}
+			}
+		}
+		else
+		{
+			bestMatch = i;
+		}
+	}
+	
+	if ( !bestMatch )
+		return 0;
+
+	if ( ( pfds[bestMatch].dwFlags & PFD_GENERIC_FORMAT ) != 0 )
+	{
+		if ( !r_allowSoftwareGL->integer )
+		{
+			Com_Printf ("...no hardware acceleration found\n" );
+			return 0;
+		}
+		else
+		{
+			Com_Printf ("...using software emulation\n" );
+		}
+	}
+	else if ( pfds[bestMatch].dwFlags & PFD_GENERIC_ACCELERATED )
+	{
+		Com_Printf ("...MCD acceleration found\n" );
+	}
+	else
+	{
+		Com_Printf ("...hardware acceleration found\n" );
+	}
+
+	*pPFD = pfds[bestMatch];
+
+	return bestMatch;
+}
+
+/*
+** void GLW_CreatePFD
+**
+** Helper function zeros out then fills in a PFD
+*/
+static void GLW_CreatePFD( PIXELFORMATDESCRIPTOR *pPFD, int colorbits, int depthbits, int stencilbits, qboolean stereo )
+{
+    PIXELFORMATDESCRIPTOR src = 
+	{
+		sizeof(PIXELFORMATDESCRIPTOR),	// size of this pfd
+		1,								// version number
+		PFD_DRAW_TO_WINDOW |			// support window
+		PFD_SUPPORT_OPENGL |			// support OpenGL
+		PFD_DOUBLEBUFFER,				// double buffered
+		PFD_TYPE_RGBA,					// RGBA type
+		24,								// 24-bit color depth
+		0, 0, 0, 0, 0, 0,				// color bits ignored
+		0,								// no alpha buffer
+		0,								// shift bit ignored
+		0,								// no accumulation buffer
+		0, 0, 0, 0, 					// accum bits ignored
+		24,								// 24-bit z-buffer	
+		8,								// 8-bit stencil buffer
+		0,								// no auxiliary buffer
+		PFD_MAIN_PLANE,					// main layer
+		0,								// reserved
+		0, 0, 0							// layer masks ignored
+    };
+
+	src.cColorBits = colorbits;
+	src.cDepthBits = depthbits;
+	src.cStencilBits = stencilbits;
+
+	if ( stereo )
+	{
+		Com_Printf ("...attempting to use stereo\n" );
+		src.dwFlags |= PFD_STEREO;
+		glConfig.stereoEnabled = qtrue;
+	}
+	else
+	{
+		glConfig.stereoEnabled = qfalse;
+	}
+
+	*pPFD = src;
+}
+
+/*
+** GLW_MakeContext
+*/
+static int GLW_MakeContext( PIXELFORMATDESCRIPTOR *pPFD )
+{
+	int pixelformat;
+
+	//
+	// don't putz around with pixelformat if it's already set (e.g. this is a soft
+	// reset of the graphics system)
+	//
+	if ( !glw_state.pixelFormatSet )
+	{
+		//
+		// choose, set, and describe our desired pixel format.  If we're
+		// using a minidriver then we need to bypass the GDI functions,
+		// otherwise use the GDI functions.
+		//
+		if ( ( pixelformat = GLW_ChoosePFD( glw_state.hDC, pPFD ) ) == 0 )
+		{
+			Com_Printf ("...GLW_ChoosePFD failed\n");
+			return TRY_PFD_FAIL_SOFT;
+		}
+		Com_Printf ("...PIXELFORMAT %d selected\n", pixelformat );
+
+		DescribePixelFormat( glw_state.hDC, pixelformat, sizeof( *pPFD ), pPFD );
+
+		if ( SetPixelFormat( glw_state.hDC, pixelformat, pPFD ) == FALSE )
+		{
+			Com_Printf ( "...SetPixelFormat failed\n", glw_state.hDC );
+			return TRY_PFD_FAIL_SOFT;
+		}
+
+		glw_state.pixelFormatSet = qtrue;
+	}
+
+	//
+	// startup the OpenGL subsystem by creating a context and making it current
+	//
+	if ( !glw_state.hGLRC )
+	{
+		Com_Printf ("...creating GL context: " );
+		if ( ( glw_state.hGLRC = qwglCreateContext( glw_state.hDC ) ) == 0 )
+		{
+			Com_Printf ( "failed\n");
+
+			return TRY_PFD_FAIL_HARD;
+		}
+		Com_Printf ("succeeded\n" );
+
+		Com_Printf ("...making context current: " );
+		if ( !qwglMakeCurrent( glw_state.hDC, glw_state.hGLRC ) )
+		{
+			qwglDeleteContext( glw_state.hGLRC );
+			glw_state.hGLRC = NULL;
+			Com_Printf ( "failed\n");
+			return TRY_PFD_FAIL_HARD;
+		}
+		Com_Printf ("succeeded\n" );
+	}
+
+	return TRY_PFD_SUCCESS;
+}
+
+
+/*
+** GLW_InitDriver
+**
+** - get a DC if one doesn't exist
+** - create an HGLRC if one doesn't exist
+*/
+static qboolean GLW_InitDriver( int colorbits )
+{
+	int		tpfd;
+	int		depthbits, stencilbits;
+    static PIXELFORMATDESCRIPTOR pfd;		// save between frames since 'tr' gets cleared
+
+	Com_Printf ("Initializing OpenGL driver\n" );
+
+	//
+	// get a DC for our window if we don't already have one allocated
+	//
+	if ( glw_state.hDC == NULL )
+	{
+		Com_Printf ("...getting DC: " );
+
+		if ( ( glw_state.hDC = GetDC( g_wv.hWnd ) ) == NULL )
+		{
+			Com_Printf ("failed\n" );
+			return qfalse;
+		}
+		Com_Printf ("succeeded\n" );
+	}
+
+	if ( colorbits == 0 )
+	{
+		colorbits = glw_state.desktopBitsPixel;
+	}
+
+	//
+	// implicitly assume Z-buffer depth == desktop color depth
+	//
+	if ( r_depthbits->integer == 0 ) {
+		if ( colorbits > 16 ) {
+			depthbits = 24;
+		} else {
+			depthbits = 16;
+		}
+	} else {
+		depthbits = r_depthbits->integer;
+	}
+
+	//
+	// do not allow stencil if Z-buffer depth likely won't contain it
+	//
+	stencilbits = r_stencilbits->integer;
+	if ( depthbits < 24 )
+	{
+		stencilbits = 0;
+	}
+
+	//
+	// make two attempts to set the PIXELFORMAT
+	//
+
+	//
+	// first attempt: r_colorbits, depthbits, and r_stencilbits
+	//
+	if ( !glw_state.pixelFormatSet )
+	{
+		GLW_CreatePFD( &pfd, colorbits, depthbits, stencilbits, (qboolean)r_stereo->integer );
+		if ( ( tpfd = GLW_MakeContext( &pfd ) ) != TRY_PFD_SUCCESS )
+		{
+			if ( tpfd == TRY_PFD_FAIL_HARD )
+			{
+				Com_Printf (S_COLOR_YELLOW  "...failed hard\n" );
+				return qfalse;
+			}
+
+			//
+			// punt if we've already tried the desktop bit depth and no stencil bits
+			//
+			if ( ( r_colorbits->integer == glw_state.desktopBitsPixel ) &&
+				 ( stencilbits == 0 ) )
+			{
+				ReleaseDC( g_wv.hWnd, glw_state.hDC );
+				glw_state.hDC = NULL;
+
+				Com_Printf ("...failed to find an appropriate PIXELFORMAT\n" );
+
+				return qfalse;
+			}
+
+			//
+			// second attempt: desktop's color bits and no stencil
+			//
+			if ( colorbits > glw_state.desktopBitsPixel )
+			{
+				colorbits = glw_state.desktopBitsPixel;
+			}
+			GLW_CreatePFD( &pfd, colorbits, depthbits, 0, (qboolean)r_stereo->integer );
+			if ( GLW_MakeContext( &pfd ) != TRY_PFD_SUCCESS )
+			{
+				if ( glw_state.hDC )
+				{
+					ReleaseDC( g_wv.hWnd, glw_state.hDC );
+					glw_state.hDC = NULL;
+				}
+
+				Com_Printf ("...failed to find an appropriate PIXELFORMAT\n" );
+
+				return qfalse;
+			}
+		}
+
+		/*
+		** report if stereo is desired but unavailable
+		*/
+		if ( !( pfd.dwFlags & PFD_STEREO ) && ( r_stereo->integer != 0 ) ) 
+		{
+			Com_Printf ("...failed to select stereo pixel format\n" );
+			glConfig.stereoEnabled = qfalse;
+		}
+	}
+
+	/*
+	** store PFD specifics 
+	*/
+	glConfig.colorBits = ( int ) pfd.cColorBits;
+	glConfig.depthBits = ( int ) pfd.cDepthBits;
+	glConfig.stencilBits = ( int ) pfd.cStencilBits;
+
+	return qtrue;
+}
+
+/*
+** GLW_CreateWindow
+**
+** Responsible for creating the Win32 window and initializing the OpenGL driver.
+*/
+#define	WINDOW_STYLE	(WS_OVERLAPPED|WS_BORDER|WS_CAPTION|WS_VISIBLE)
+static qboolean GLW_CreateWindow( int width, int height, int colorbits, qboolean cdsFullscreen )
+{
+	RECT			r;
+	cvar_t			*vid_xpos, *vid_ypos;
+	int				stylebits;
+	int				x, y, w, h;
+	int				exstyle;
+
+	//
+	// register the window class if necessary
+	//
+	if ( !s_classRegistered )
+	{
+		WNDCLASS wc;
+
+		memset( &wc, 0, sizeof( wc ) );
+
+		wc.style         = 0;
+		wc.lpfnWndProc   = (WNDPROC) glw_state.wndproc;
+		wc.cbClsExtra    = 0;
+		wc.cbWndExtra    = 0;
+		wc.hInstance     = g_wv.hInstance;
+		wc.hIcon         = LoadIcon( g_wv.hInstance, MAKEINTRESOURCE(IDI_ICON1));
+		wc.hCursor       = LoadCursor (NULL,IDC_ARROW);
+		wc.hbrBackground = 0;//(HBRUSH__ *)COLOR_GRAYTEXT;
+		wc.lpszMenuName  = 0;
+		wc.lpszClassName = WINDOW_CLASS_NAME;
+
+		if ( !RegisterClass( &wc ) )
+		{
+			Com_Error( ERR_FATAL, "GLW_CreateWindow: could not register window class" );
+		}
+		s_classRegistered = qtrue;
+//		Com_Printf ("...registered window class\n" );
+	}
+
+	//
+	// create the HWND if one does not already exist
+	//
+	if ( !g_wv.hWnd )
+	{
+		//
+		// compute width and height
+		//
+		r.left = 0;
+		r.top = 0;
+		r.right  = width;
+		r.bottom = height;
+
+		if ( cdsFullscreen )
+		{
+			exstyle = WS_EX_TOPMOST;
+			stylebits = WS_SYSMENU|WS_POPUP|WS_VISIBLE;	//sysmenu gives you the icon
+		}
+		else
+		{
+			exstyle = 0;
+			stylebits = WS_SYSMENU|WINDOW_STYLE|WS_MINIMIZEBOX;
+			AdjustWindowRect (&r, stylebits, FALSE);
+		}
+
+		w = r.right - r.left;
+		h = r.bottom - r.top;
+
+		if ( cdsFullscreen )
+		{
+			x = 0;
+			y = 0;
+		}
+		else
+		{
+			vid_xpos = Cvar_Get ("vid_xpos", "", 0);
+			vid_ypos = Cvar_Get ("vid_ypos", "", 0);
+			x = vid_xpos->integer;
+			y = vid_ypos->integer;
+
+			// adjust window coordinates if necessary 
+			// so that the window is completely on screen
+			if ( x < 0 )
+				x = 0;
+			if ( y < 0 )
+				y = 0;
+
+			if ( w < glw_state.desktopWidth &&
+				 h < glw_state.desktopHeight )
+			{
+				if ( x + w > glw_state.desktopWidth )
+					x = ( glw_state.desktopWidth - w );
+				if ( y + h > glw_state.desktopHeight )
+					y = ( glw_state.desktopHeight - h );
+			}
+		}
+
+		g_wv.hWnd = CreateWindowEx (
+			 exstyle, 
+			 WINDOW_CLASS_NAME,
+			 WINDOW_CLASS_NAME,
+			 stylebits,
+			 x, y, w, h,
+			 NULL,
+			 NULL,
+			 g_wv.hInstance,
+			 NULL);
+
+		if ( !g_wv.hWnd )
+		{
+			Com_Error (ERR_FATAL, "GLW_CreateWindow() - Couldn't create window");
+		}
+	
+		ShowWindow( g_wv.hWnd, SW_SHOW );
+		UpdateWindow( g_wv.hWnd );
+		Com_Printf ("...created window@%d,%d (%dx%d)\n", x, y, w, h );
+	}
+	else
+	{
+		Com_Printf ("...window already present, CreateWindowEx skipped\n" );
+	}
+
+	if ( !GLW_InitDriver( colorbits ) )
+	{
+		ShowWindow( g_wv.hWnd, SW_HIDE );
+		DestroyWindow( g_wv.hWnd );
+		g_wv.hWnd = NULL;
+
+		return qfalse;
+	}
+
+	SetForegroundWindow( g_wv.hWnd );
+	SetFocus( g_wv.hWnd );
+
+	return qtrue;
+}
+
+static void PrintCDSError( int value )
+{
+	switch ( value )
+	{
+	case DISP_CHANGE_RESTART:
+		Com_Printf ("restart required\n" );
+		break;
+	case DISP_CHANGE_BADPARAM:
+		Com_Printf ("bad param\n" );
+		break;
+	case DISP_CHANGE_BADFLAGS:
+		Com_Printf ("bad flags\n" );
+		break;
+	case DISP_CHANGE_FAILED:
+		Com_Printf ("DISP_CHANGE_FAILED\n" );
+		break;
+	case DISP_CHANGE_BADMODE:
+		Com_Printf ("bad mode\n" );
+		break;
+	case DISP_CHANGE_NOTUPDATED:
+		Com_Printf ("not updated\n" );
+		break;
+	default:
+		Com_Printf ("unknown error %d\n", value );
+		break;
+	}
+}
+
+/*
+** GLW_SetMode
+*/
+static rserr_t GLW_SetMode( int mode, 
+							int colorbits, 
+							qboolean cdsFullscreen )
+{
+	HDC hDC;
+	const char *win_fs[] = { "W", "FS" };
+	int		cdsRet;
+	DEVMODE dm;
+		
+	//
+	// print out informational messages
+	//
+	Com_Printf ("...setting mode %d:", mode );
+	if ( !R_GetModeInfo( &glConfig.vidWidth, &glConfig.vidHeight, mode ) )
+	{
+		Com_Printf (" invalid mode\n" );
+		return RSERR_INVALID_MODE;
+	}
+	Com_Printf (" %d %d %s\n", glConfig.vidWidth, glConfig.vidHeight, win_fs[cdsFullscreen] );
+
+	//
+	// check our desktop attributes
+	//
+	hDC = GetDC( GetDesktopWindow() );
+	glw_state.desktopBitsPixel = GetDeviceCaps( hDC, BITSPIXEL );
+	glw_state.desktopWidth = GetDeviceCaps( hDC, HORZRES );
+	glw_state.desktopHeight = GetDeviceCaps( hDC, VERTRES );
+	ReleaseDC( GetDesktopWindow(), hDC );
+
+	//
+	// verify desktop bit depth
+	//
+	if ( glw_state.desktopBitsPixel < 15 || glw_state.desktopBitsPixel == 24 )
+	{
+		if (!cdsFullscreen && (colorbits == 0 || colorbits >= 15 ) )
+		{
+			// since I can't be bothered trying to mess around with asian codepages and MBCS stuff for a windows
+			//	error box that'll only appear if something's seriously fucked then I'm going to fallback to
+			//	english text when these would otherwise be used...
+			//
+			char sErrorHead[1024];	// ott
+
+			extern qboolean Language_IsAsian(void);
+			Q_strncpyz(sErrorHead, Language_IsAsian() ? "Low Desktop Color Depth" : SE_GetString("CON_TEXT_LOW_DESKTOP_COLOUR_DEPTH"), sizeof(sErrorHead) );
+
+			const char *psErrorBody = Language_IsAsian() ?
+												"It is highly unlikely that a correct windowed\n"
+												"display can be initialized with the current\n"
+												"desktop display depth.  Select 'OK' to try\n"
+												"anyway.  Select 'Cancel' to try a fullscreen\n"
+												"mode instead."
+												:
+												SE_GetString("CON_TEXT_TRY_ANYWAY");
+
+			if ( MessageBox( NULL, 							
+						psErrorBody,
+						sErrorHead,
+						MB_OKCANCEL | MB_ICONEXCLAMATION ) != IDOK )
+			{
+				return RSERR_INVALID_MODE;
+			}
+		}
+	}
+
+	// do a CDS if needed
+	if ( cdsFullscreen )
+	{
+		memset( &dm, 0, sizeof( dm ) );
+		
+		dm.dmSize = sizeof( dm );
+		
+		dm.dmPelsWidth  = glConfig.vidWidth;
+		dm.dmPelsHeight = glConfig.vidHeight;
+		dm.dmFields     = DM_PELSWIDTH | DM_PELSHEIGHT;
+
+		if ( r_displayRefresh->integer != 0 )
+		{
+			dm.dmDisplayFrequency = r_displayRefresh->integer;
+			dm.dmFields |= DM_DISPLAYFREQUENCY;
+		}
+		
+		// try to change color depth if possible
+		if ( colorbits != 0 )
+		{
+			if ( glw_state.allowdisplaydepthchange )
+			{
+				dm.dmBitsPerPel = colorbits;
+				dm.dmFields |= DM_BITSPERPEL;
+				Com_Printf ("...using colorsbits of %d\n", colorbits );
+			}
+			else
+			{
+				Com_Printf ("WARNING:...changing depth not supported on Win95 < pre-OSR 2.x\n" );
+			}
+		}
+		else
+		{
+			Com_Printf ("...using desktop display depth of %d\n", glw_state.desktopBitsPixel );
+		}
+
+		//
+		// if we're already in fullscreen then just create the window
+		//
+		if ( glw_state.cdsFullscreen )
+		{
+			Com_Printf ("...already fullscreen, avoiding redundant CDS\n" );
+
+			if ( !GLW_CreateWindow ( glConfig.vidWidth, glConfig.vidHeight, colorbits, qtrue ) )
+			{
+				Com_Printf ("...restoring display settings\n" );
+				ChangeDisplaySettings( 0, 0 );
+				return RSERR_INVALID_MODE;
+			}
+		}
+		//
+		// need to call CDS
+		//
+		else
+		{
+			Com_Printf ("...calling CDS: " );
+			
+			// try setting the exact mode requested, because some drivers don't report
+			// the low res modes in EnumDisplaySettings, but still work
+			if ( ( cdsRet = ChangeDisplaySettings( &dm, CDS_FULLSCREEN ) ) == DISP_CHANGE_SUCCESSFUL )
+			{
+				Com_Printf ("ok\n" );
+
+				if ( !GLW_CreateWindow ( glConfig.vidWidth, glConfig.vidHeight, colorbits, qtrue) )
+				{
+					Com_Printf ("...restoring display settings\n" );
+					ChangeDisplaySettings( 0, 0 );
+					return RSERR_INVALID_MODE;
+				}
+				
+				glw_state.cdsFullscreen = qtrue;
+			}
+			else
+			{
+				//
+				// the exact mode failed, so scan EnumDisplaySettings for the next largest mode
+				//
+				DEVMODE		devmode;
+				int			modeNum;
+
+				Com_Printf ("failed, " );
+				
+				PrintCDSError( cdsRet );
+			
+				Com_Printf ("...trying next higher resolution:" );
+				
+				// we could do a better matching job here...
+				for ( modeNum = 0 ; ; modeNum++ ) {
+					if ( !EnumDisplaySettings( NULL, modeNum, &devmode ) ) {
+						modeNum = -1;
+						break;
+					}
+					if ( devmode.dmPelsWidth >= glConfig.vidWidth
+						&& devmode.dmPelsHeight >= glConfig.vidHeight
+						&& devmode.dmBitsPerPel >= 15 ) {
+						break;
+					}
+				}
+
+				if ( modeNum != -1 && ( cdsRet = ChangeDisplaySettings( &devmode, CDS_FULLSCREEN ) ) == DISP_CHANGE_SUCCESSFUL )
+				{
+					Com_Printf (" ok\n" );
+					if ( !GLW_CreateWindow( glConfig.vidWidth, glConfig.vidHeight, colorbits, qtrue) )
+					{
+						Com_Printf ("...restoring display settings\n" );
+						ChangeDisplaySettings( 0, 0 );
+						return RSERR_INVALID_MODE;
+					}
+					
+					glw_state.cdsFullscreen = qtrue;
+				}
+				else
+				{
+					Com_Printf (" failed, " );
+					
+					PrintCDSError( cdsRet );
+					
+					Com_Printf ("...restoring display settings\n" );
+					ChangeDisplaySettings( 0, 0 );
+					
+/*				jfm:  i took out the following code to allow fallback to mode 3, with this code it goes half windowed and just doesn't work.
+					glw_state.cdsFullscreen = qfalse;
+					glConfig.isFullscreen = qfalse;
+					if ( !GLW_CreateWindow( glConfig.vidWidth, glConfig.vidHeight, colorbits, qfalse) )
+					{
+						return RSERR_INVALID_MODE;
+					}
+*/
+					return RSERR_INVALID_FULLSCREEN;
+				}
+			}
+		}
+	}
+	else
+	{
+		if ( glw_state.cdsFullscreen )
+		{
+			ChangeDisplaySettings( 0, 0 );
+		}
+
+		glw_state.cdsFullscreen = qfalse;
+		if ( !GLW_CreateWindow( glConfig.vidWidth, glConfig.vidHeight, colorbits, qfalse ) )
+		{
+			return RSERR_INVALID_MODE;
+		}
+	}
+
+	//
+	// success, now check display frequency, although this won't be valid on Voodoo(2)
+	//
+	memset( &dm, 0, sizeof( dm ) );
+	dm.dmSize = sizeof( dm );
+	if ( EnumDisplaySettings( NULL, ENUM_CURRENT_SETTINGS, &dm ) )
+	{
+		glConfig.displayFrequency = dm.dmDisplayFrequency;
+	}
+
+	// NOTE: this is overridden later on standalone 3Dfx drivers
+	glConfig.isFullscreen = cdsFullscreen;
+
+	return RSERR_OK;
+}
+
+/*
+** GLW_CheckForExtension
+
+  Cannot use strstr directly to differentiate between (for eg) reg_combiners and reg_combiners2
+*/
+
+bool GL_CheckForExtension(const char *ext)
+{
+	char	*temp;
+	char	term;
+
+	temp = strstr(glConfig.extensions_string, ext);
+	if(!temp)
+	{
+		return(false);
+	}
+	// String exists but it may not be terminated
+	term = temp[strlen(ext)];
+	if((term == ' ') || !term)
+	{
+		return(true);
+	}
+	return(false);
+}
+
+//--------------------------------------------
+static void GLW_InitTextureCompression( void )
+{
+	qboolean newer_tc, old_tc;
+
+	// Check for available tc methods.
+	newer_tc = ( strstr( glConfig.extensions_string, "ARB_texture_compression" )
+		&& strstr( glConfig.extensions_string, "EXT_texture_compression_s3tc" )) ? qtrue : qfalse;
+	old_tc = ( strstr( glConfig.extensions_string, "GL_S3_s3tc" )) ? qtrue : qfalse;
+
+	if ( old_tc )
+	{
+		Com_Printf ("...GL_S3_s3tc available\n" );
+	}
+
+	if ( newer_tc )
+	{
+		Com_Printf ("...GL_EXT_texture_compression_s3tc available\n" );
+	}
+
+	if ( !r_ext_compressed_textures->value )
+	{
+		// Compressed textures are off
+		glConfig.textureCompression = TC_NONE;
+		Com_Printf ("...ignoring texture compression\n" );
+	}
+	else if ( !old_tc && !newer_tc )
+	{
+		// Requesting texture compression, but no method found
+		glConfig.textureCompression = TC_NONE;
+		Com_Printf ("...no supported texture compression method found\n" );
+		Com_Printf (".....ignoring texture compression\n" );
+	}
+	else
+	{
+		// some form of supported texture compression is avaiable, so see if the user has a preference
+		if ( r_ext_preferred_tc_method->integer == TC_NONE )
+		{
+			// No preference, so pick the best
+			if ( newer_tc )
+			{
+				Com_Printf ("...no tc preference specified\n" );
+				Com_Printf (".....using GL_EXT_texture_compression_s3tc\n" );
+				glConfig.textureCompression = TC_S3TC_DXT;
+			}
+			else
+			{
+				Com_Printf ("...no tc preference specified\n" );
+				Com_Printf (".....using GL_S3_s3tc\n" );
+				glConfig.textureCompression = TC_S3TC;
+			}
+		}
+		else
+		{
+			// User has specified a preference, now see if this request can be honored
+			if ( old_tc && newer_tc )
+			{
+				// both are avaiable, so we can use the desired tc method
+				if ( r_ext_preferred_tc_method->integer == TC_S3TC )
+				{
+					Com_Printf ("...using preferred tc method, GL_S3_s3tc\n" );
+					glConfig.textureCompression = TC_S3TC;
+				}
+				else
+				{
+					Com_Printf ("...using preferred tc method, GL_EXT_texture_compression_s3tc\n" );
+					glConfig.textureCompression = TC_S3TC_DXT;
+				}
+			}
+			else
+			{
+				// Both methods are not available, so this gets trickier
+				if ( r_ext_preferred_tc_method->integer == TC_S3TC )
+				{
+					// Preferring to user older compression
+					if ( old_tc )
+					{
+						Com_Printf ("...using GL_S3_s3tc\n" );
+						glConfig.textureCompression = TC_S3TC;
+					}
+					else
+					{
+						// Drat, preference can't be honored 
+						Com_Printf ("...preferred tc method, GL_S3_s3tc not available\n" );
+						Com_Printf (".....falling back to GL_EXT_texture_compression_s3tc\n" );
+						glConfig.textureCompression = TC_S3TC_DXT;
+					}
+				}
+				else
+				{
+					// Preferring to user newer compression
+					if ( newer_tc )
+					{
+						Com_Printf ("...using GL_EXT_texture_compression_s3tc\n" );
+						glConfig.textureCompression = TC_S3TC_DXT;
+					}
+					else
+					{
+						// Drat, preference can't be honored 
+						Com_Printf ("...preferred tc method, GL_EXT_texture_compression_s3tc not available\n" );
+						Com_Printf (".....falling back to GL_S3_s3tc\n" );
+						glConfig.textureCompression = TC_S3TC;
+					}
+				}
+			}
+		}
+	}
+}
+
+/*
+** GLW_InitExtensions
+*/
+static void GLW_InitExtensions( void )
+{
+	if ( !r_allowExtensions->integer )
+	{
+		Com_Printf ("*** IGNORING OPENGL EXTENSIONS ***\n" );
+		g_bDynamicGlowSupported = false;
+		Cvar_Set( "r_DynamicGlow","0" );
+		return;
+	}
+
+	Com_Printf ("Initializing OpenGL extensions\n" );
+
+	// Select our tc scheme
+	GLW_InitTextureCompression();
+
+	// GL_EXT_texture_env_add
+	glConfig.textureEnvAddAvailable = qfalse;
+	if ( strstr( glConfig.extensions_string, "EXT_texture_env_add" ) )
+	{
+		if ( r_ext_texture_env_add->integer )
+		{
+			glConfig.textureEnvAddAvailable = qtrue;
+			Com_Printf ("...using GL_EXT_texture_env_add\n" );
+		}
+		else
+		{
+			glConfig.textureEnvAddAvailable = qfalse;
+			Com_Printf ("...ignoring GL_EXT_texture_env_add\n" );
+		}
+	}
+	else
+	{
+		Com_Printf ("...GL_EXT_texture_env_add not found\n" );
+	}
+
+	// GL_EXT_texture_filter_anisotropic
+	glConfig.maxTextureFilterAnisotropy = 0;
+	if ( strstr( glConfig.extensions_string, "EXT_texture_filter_anisotropic" ) )
+	{
+#define GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT 0x84FF	//can't include glext.h here ... sigh
+		qglGetFloatv( GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &glConfig.maxTextureFilterAnisotropy );
+		Com_Printf ("...GL_EXT_texture_filter_anisotropic available\n" );
+
+		if ( r_ext_texture_filter_anisotropic->integer>1 )
+		{
+			Com_Printf ("...using GL_EXT_texture_filter_anisotropic\n" );
+		}
+		else
+		{
+			Com_Printf ("...ignoring GL_EXT_texture_filter_anisotropic\n" );
+		}
+		Cvar_Set( "r_ext_texture_filter_anisotropic_avail", va("%f",glConfig.maxTextureFilterAnisotropy) );
+		if ( r_ext_texture_filter_anisotropic->value > glConfig.maxTextureFilterAnisotropy )
+		{
+			Cvar_Set( "r_ext_texture_filter_anisotropic", va("%f",glConfig.maxTextureFilterAnisotropy) );
+		}
+	}
+	else
+	{
+		Com_Printf ("...GL_EXT_texture_filter_anisotropic not found\n" );
+		Cvar_Set( "r_ext_texture_filter_anisotropic_avail", "0" );
+	}
+
+	// GL_EXT_clamp_to_edge
+	glConfig.clampToEdgeAvailable = qfalse;
+	if ( strstr( glConfig.extensions_string, "GL_EXT_texture_edge_clamp" ) )
+	{
+		glConfig.clampToEdgeAvailable = qtrue;
+		Com_Printf ("...Using GL_EXT_texture_edge_clamp\n" );
+	}
+
+
+	// WGL_EXT_swap_control
+	qwglSwapIntervalEXT = ( BOOL (WINAPI *)(int)) qwglGetProcAddress( "wglSwapIntervalEXT" );
+	if ( qwglSwapIntervalEXT )
+	{
+		Com_Printf ("...using WGL_EXT_swap_control\n" );
+		r_swapInterval->modified = qtrue;	// force a set next frame
+	}
+	else
+	{
+		Com_Printf ("...WGL_EXT_swap_control not found\n" );
+	}
+
+	// GL_ARB_multitexture
+	qglMultiTexCoord2fARB = NULL;
+	qglActiveTextureARB = NULL;
+	qglClientActiveTextureARB = NULL;
+	if ( strstr( glConfig.extensions_string, "GL_ARB_multitexture" )  )
+	{
+		if ( r_ext_multitexture->integer )
+		{
+			qglMultiTexCoord2fARB = ( PFNGLMULTITEXCOORD2FARBPROC ) qwglGetProcAddress( "glMultiTexCoord2fARB" );
+			qglActiveTextureARB = ( PFNGLACTIVETEXTUREARBPROC ) qwglGetProcAddress( "glActiveTextureARB" );
+			qglClientActiveTextureARB = ( PFNGLCLIENTACTIVETEXTUREARBPROC ) qwglGetProcAddress( "glClientActiveTextureARB" );
+
+			if ( qglActiveTextureARB )
+			{
+				qglGetIntegerv( GL_MAX_ACTIVE_TEXTURES_ARB, &glConfig.maxActiveTextures );
+
+				if ( glConfig.maxActiveTextures > 1 )
+				{
+					Com_Printf ("...using GL_ARB_multitexture\n" );
+				}
+				else
+				{
+					qglMultiTexCoord2fARB = NULL;
+					qglActiveTextureARB = NULL;
+					qglClientActiveTextureARB = NULL;
+					Com_Printf ("...not using GL_ARB_multitexture, < 2 texture units\n" );
+				}
+			}
+		}
+		else
+		{
+			Com_Printf ("...ignoring GL_ARB_multitexture\n" );
+		}
+	}
+	else
+	{
+		Com_Printf ("...GL_ARB_multitexture not found\n" );
+	}
+
+	// GL_EXT_compiled_vertex_array
+	qglLockArraysEXT = NULL;
+	qglUnlockArraysEXT = NULL;
+	if ( strstr( glConfig.extensions_string, "GL_EXT_compiled_vertex_array" ) )
+	{
+		if ( r_ext_compiled_vertex_array->integer )
+		{
+			Com_Printf ("...using GL_EXT_compiled_vertex_array\n" );
+			qglLockArraysEXT = ( void ( APIENTRY * )( int, int ) ) qwglGetProcAddress( "glLockArraysEXT" );
+			qglUnlockArraysEXT = ( void ( APIENTRY * )( void ) ) qwglGetProcAddress( "glUnlockArraysEXT" );
+			if (!qglLockArraysEXT || !qglUnlockArraysEXT) {
+				Com_Error (ERR_FATAL, "bad getprocaddress");
+			}
+		}
+		else
+		{
+			Com_Printf ("...ignoring GL_EXT_compiled_vertex_array\n" );
+		}
+	}
+	else
+	{
+		Com_Printf ("...GL_EXT_compiled_vertex_array not found\n" );
+	}
+
+	qglPointParameterfEXT = NULL;
+	qglPointParameterfvEXT = NULL;
+
+	//3d textures -rww
+	qglTexImage3DEXT = NULL;
+	qglTexSubImage3DEXT = NULL;
+
+	if ( strstr( glConfig.extensions_string, "GL_EXT_point_parameters" ) )
+	{
+		if ( r_ext_compiled_vertex_array->integer || 1)
+		{
+			Com_Printf ("...using GL_EXT_point_parameters\n" );
+			qglPointParameterfEXT = ( void ( APIENTRY * )( GLenum, GLfloat) ) qwglGetProcAddress( "glPointParameterfEXT" );
+			qglPointParameterfvEXT = ( void ( APIENTRY * )( GLenum, GLfloat *) ) qwglGetProcAddress( "glPointParameterfvEXT" );
+
+			//3d textures -rww
+			qglTexImage3DEXT = (void ( APIENTRY * ) (GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *) ) qwglGetProcAddress( "glTexImage3DEXT" );
+			qglTexSubImage3DEXT = (void ( APIENTRY * ) (GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *) ) qwglGetProcAddress( "glTexSubImage3DEXT" );
+
+			if (!qglPointParameterfEXT || !qglPointParameterfvEXT) 
+			{
+				Com_Error (ERR_FATAL, "bad getprocaddress");
+			}
+		}
+		else
+		{
+			Com_Printf ("...ignoring GL_EXT_point_parameters\n" );
+		}
+	}
+	else
+	{
+		Com_Printf ("...GL_EXT_point_parameters not found\n" );
+	}
+
+	bool bNVRegisterCombiners = false;
+	// Register Combiners.
+	if ( strstr( glConfig.extensions_string, "GL_NV_register_combiners" ) )
+	{
+		// NOTE: This extension requires multitexture support (over 2 units).
+		if ( glConfig.maxActiveTextures >= 2 )
+		{
+			bNVRegisterCombiners = true;
+			// Register Combiners function pointer address load.	- AReis
+			// NOTE: VV guys will _definetly_ not be able to use regcoms. Pixel Shaders are just as good though :-)
+			// NOTE: Also, this is an nVidia specific extension (of course), so fragment shaders would serve the same purpose
+			// if we needed some kind of fragment/pixel manipulation support.
+			qglCombinerParameterfvNV = ( PFNGLCOMBINERPARAMETERFVNV ) qwglGetProcAddress( "glCombinerParameterfvNV" );
+			qglCombinerParameterivNV = ( PFNGLCOMBINERPARAMETERIVNV ) qwglGetProcAddress( "glCombinerParameterivNV" );
+			qglCombinerParameterfNV = ( PFNGLCOMBINERPARAMETERFNV ) qwglGetProcAddress( "glCombinerParameterfNV" );
+			qglCombinerParameteriNV = ( PFNGLCOMBINERPARAMETERINV ) qwglGetProcAddress( "glCombinerParameteriNV" );
+			qglCombinerInputNV = ( PFNGLCOMBINERINPUTNV ) qwglGetProcAddress( "glCombinerInputNV" );
+			qglCombinerOutputNV = ( PFNGLCOMBINEROUTPUTNV ) qwglGetProcAddress( "glCombinerOutputNV" );
+			qglFinalCombinerInputNV = ( PFNGLFINALCOMBINERINPUTNV ) qwglGetProcAddress( "glFinalCombinerInputNV" );
+			qglGetCombinerInputParameterfvNV	= ( PFNGLGETCOMBINERINPUTPARAMETERFVNV ) qwglGetProcAddress( "glGetCombinerInputParameterfvNV" );
+			qglGetCombinerInputParameterivNV	= ( PFNGLGETCOMBINERINPUTPARAMETERIVNV ) qwglGetProcAddress( "glGetCombinerInputParameterivNV" );
+			qglGetCombinerOutputParameterfvNV = ( PFNGLGETCOMBINEROUTPUTPARAMETERFVNV ) qwglGetProcAddress( "glGetCombinerOutputParameterfvNV" );
+			qglGetCombinerOutputParameterivNV = ( PFNGLGETCOMBINEROUTPUTPARAMETERIVNV ) qwglGetProcAddress( "glGetCombinerOutputParameterivNV" );
+			qglGetFinalCombinerInputParameterfvNV = ( PFNGLGETFINALCOMBINERINPUTPARAMETERFVNV ) qwglGetProcAddress( "glGetFinalCombinerInputParameterfvNV" );
+			qglGetFinalCombinerInputParameterivNV = ( PFNGLGETFINALCOMBINERINPUTPARAMETERIVNV ) qwglGetProcAddress( "glGetFinalCombinerInputParameterivNV" );
+
+			// Validate the functions we need.
+			if ( !qglCombinerParameterfvNV || !qglCombinerParameterivNV || !qglCombinerParameterfNV || !qglCombinerParameteriNV || !qglCombinerInputNV ||
+				 !qglCombinerOutputNV || !qglFinalCombinerInputNV || !qglGetCombinerInputParameterfvNV || !qglGetCombinerInputParameterivNV ||
+				 !qglGetCombinerOutputParameterfvNV || !qglGetCombinerOutputParameterivNV || !qglGetFinalCombinerInputParameterfvNV || !qglGetFinalCombinerInputParameterivNV )
+			{
+				bNVRegisterCombiners = false;
+				qglCombinerParameterfvNV = NULL;
+				qglCombinerParameteriNV = NULL;
+				Com_Printf ("...GL_NV_register_combiners failed\n" );
+			}
+		}
+		else
+		{
+			bNVRegisterCombiners = false;
+			Com_Printf ("...ignoring GL_NV_register_combiners\n" );
+		}
+	}
+	else
+	{
+		bNVRegisterCombiners = false;
+		Com_Printf ("...GL_NV_register_combiners not found\n" );
+	}
+
+	// NOTE: Vertex and Fragment Programs are very dependant on each other - this is actually a
+	// good thing! So, just check to see which we support (one or the other) and load the shared
+	// function pointers. ARB rocks!
+
+	// Vertex Programs.
+	bool bARBVertexProgram = false;
+	if ( strstr( glConfig.extensions_string, "GL_ARB_vertex_program" ) )
+	{
+		bARBVertexProgram = true;
+	}
+	else
+	{
+		bARBVertexProgram = false;
+		Com_Printf ("...GL_ARB_vertex_program not found\n" );
+	}
+
+	// Fragment Programs.
+	bool bARBFragmentProgram = false;
+	if ( strstr( glConfig.extensions_string, "GL_ARB_fragment_program" ) )
+	{
+		bARBFragmentProgram = true;
+	}
+	else
+	{
+		bARBFragmentProgram = false;
+		Com_Printf ("...GL_ARB_fragment_program not found\n" );
+	}
+
+	// If we support one or the other, load the shared function pointers.
+	if ( bARBVertexProgram || bARBFragmentProgram )
+	{
+		qglProgramStringARB					= (PFNGLPROGRAMSTRINGARBPROC)  qwglGetProcAddress("glProgramStringARB");
+		qglBindProgramARB					= (PFNGLBINDPROGRAMARBPROC)    qwglGetProcAddress("glBindProgramARB");
+		qglDeleteProgramsARB				= (PFNGLDELETEPROGRAMSARBPROC) qwglGetProcAddress("glDeleteProgramsARB");
+		qglGenProgramsARB					= (PFNGLGENPROGRAMSARBPROC)    qwglGetProcAddress("glGenProgramsARB");
+		qglProgramEnvParameter4dARB			= (PFNGLPROGRAMENVPARAMETER4DARBPROC)    qwglGetProcAddress("glProgramEnvParameter4dARB");
+		qglProgramEnvParameter4dvARB		= (PFNGLPROGRAMENVPARAMETER4DVARBPROC)   qwglGetProcAddress("glProgramEnvParameter4dvARB");
+		qglProgramEnvParameter4fARB			= (PFNGLPROGRAMENVPARAMETER4FARBPROC)    qwglGetProcAddress("glProgramEnvParameter4fARB");
+		qglProgramEnvParameter4fvARB		= (PFNGLPROGRAMENVPARAMETER4FVARBPROC)   qwglGetProcAddress("glProgramEnvParameter4fvARB");
+		qglProgramLocalParameter4dARB		= (PFNGLPROGRAMLOCALPARAMETER4DARBPROC)  qwglGetProcAddress("glProgramLocalParameter4dARB");
+		qglProgramLocalParameter4dvARB		= (PFNGLPROGRAMLOCALPARAMETER4DVARBPROC) qwglGetProcAddress("glProgramLocalParameter4dvARB");
+		qglProgramLocalParameter4fARB		= (PFNGLPROGRAMLOCALPARAMETER4FARBPROC)  qwglGetProcAddress("glProgramLocalParameter4fARB");
+		qglProgramLocalParameter4fvARB		= (PFNGLPROGRAMLOCALPARAMETER4FVARBPROC) qwglGetProcAddress("glProgramLocalParameter4fvARB");
+		qglGetProgramEnvParameterdvARB		= (PFNGLGETPROGRAMENVPARAMETERDVARBPROC) qwglGetProcAddress("glGetProgramEnvParameterdvARB");
+		qglGetProgramEnvParameterfvARB		= (PFNGLGETPROGRAMENVPARAMETERFVARBPROC) qwglGetProcAddress("glGetProgramEnvParameterfvARB");
+		qglGetProgramLocalParameterdvARB	= (PFNGLGETPROGRAMLOCALPARAMETERDVARBPROC) qwglGetProcAddress("glGetProgramLocalParameterdvARB");
+		qglGetProgramLocalParameterfvARB	= (PFNGLGETPROGRAMLOCALPARAMETERFVARBPROC) qwglGetProcAddress("glGetProgramLocalParameterfvARB");
+		qglGetProgramivARB					= (PFNGLGETPROGRAMIVARBPROC)     qwglGetProcAddress("glGetProgramivARB");
+		qglGetProgramStringARB				= (PFNGLGETPROGRAMSTRINGARBPROC) qwglGetProcAddress("glGetProgramStringARB");
+		qglIsProgramARB						= (PFNGLISPROGRAMARBPROC)        qwglGetProcAddress("glIsProgramARB");
+
+		// Validate the functions we need.
+		if ( !qglProgramStringARB || !qglBindProgramARB || !qglDeleteProgramsARB || !qglGenProgramsARB ||
+			 !qglProgramEnvParameter4dARB || !qglProgramEnvParameter4dvARB || !qglProgramEnvParameter4fARB ||
+             !qglProgramEnvParameter4fvARB || !qglProgramLocalParameter4dARB || !qglProgramLocalParameter4dvARB ||
+             !qglProgramLocalParameter4fARB || !qglProgramLocalParameter4fvARB || !qglGetProgramEnvParameterdvARB ||
+             !qglGetProgramEnvParameterfvARB || !qglGetProgramLocalParameterdvARB || !qglGetProgramLocalParameterfvARB ||
+             !qglGetProgramivARB || !qglGetProgramStringARB || !qglIsProgramARB )
+		{
+			bARBVertexProgram = false;
+			bARBFragmentProgram = false;
+			qglGenProgramsARB = NULL;	//clear ptrs that get checked
+			qglProgramEnvParameter4fARB = NULL;
+			Com_Printf ("...ignoring GL_ARB_vertex_program\n" );
+			Com_Printf ("...ignoring GL_ARB_fragment_program\n" );
+		}
+	}
+
+	// Figure out which texture rectangle extension to use.
+	// TOTAL HACK!!! This will need to be fixed.
+	// FIXMEFIXMEFIXME!
+	bool bTexRectSupported = false;
+	if ( strstr( glConfig.extensions_string, "GL_EXT_texture_rectangle" ) )
+	{
+		g_bTextureRectangleHack = true;
+		bTexRectSupported = true;
+	}
+	else if ( strstr( glConfig.extensions_string, "GL_NV_texture_rectangle" ) )
+	{
+		g_bTextureRectangleHack = false;
+		bTexRectSupported = true;
+	}
+	
+	// OK, so not so good to put this here, but no one else uses it!!! -AReis
+	typedef const char * (WINAPI * PFNWGLGETEXTENSIONSSTRINGARBPROC) (HDC hdc);
+	PFNWGLGETEXTENSIONSSTRINGARBPROC			qwglGetExtensionsStringARB;
+	qwglGetExtensionsStringARB = (PFNWGLGETEXTENSIONSSTRINGARBPROC) qwglGetProcAddress("wglGetExtensionsStringARB");
+
+	const char *wglExtensions = NULL;
+	bool bHasPixelFormat = false;
+	bool bHasRenderTexture = false;
+
+	// Get the WGL extensions string.
+	if ( qwglGetExtensionsStringARB )
+	{
+		wglExtensions = qwglGetExtensionsStringARB( glw_state.hDC );
+	}
+
+	// This externsion is used to get the wgl extension string.
+	if ( wglExtensions )
+	{
+		// Pixel Format.
+		if ( strstr( wglExtensions, "WGL_ARB_pixel_format" ) )
+		{
+			qwglGetPixelFormatAttribivARB			=	(PFNWGLGETPIXELFORMATATTRIBIVARBPROC) qwglGetProcAddress("wglGetPixelFormatAttribivARB");
+			qwglGetPixelFormatAttribfvARB			=	(PFNWGLGETPIXELFORMATATTRIBFVARBPROC) qwglGetProcAddress("wglGetPixelFormatAttribfvARB");
+			qwglChoosePixelFormatARB				=	(PFNWGLCHOOSEPIXELFORMATARBPROC) qwglGetProcAddress("wglChoosePixelFormatARB");
+	
+			// Validate the functions we need.
+			if ( !qwglGetPixelFormatAttribivARB || !qwglGetPixelFormatAttribfvARB || !qwglChoosePixelFormatARB )
+			{
+				Com_Printf ("...ignoring WGL_ARB_pixel_format\n" );
+			}
+			else
+			{
+				bHasPixelFormat = true;
+			}
+		}
+		else
+		{
+			Com_Printf ("...ignoring WGL_ARB_pixel_format\n" );
+		}
+
+		// Offscreen pixel-buffer.
+		// NOTE: VV guys can use the equivelant SetRenderTarget() with the correct texture surfaces.
+		bool bWGLARBPbuffer = false;
+		if ( strstr( wglExtensions, "WGL_ARB_pbuffer" ) && bHasPixelFormat )
+		{
+			bWGLARBPbuffer = true;
+			qwglCreatePbufferARB		=	(PFNWGLCREATEPBUFFERARBPROC) qwglGetProcAddress("wglCreatePbufferARB");
+			qwglGetPbufferDCARB			=	(PFNWGLGETPBUFFERDCARBPROC) qwglGetProcAddress("wglGetPbufferDCARB");
+			qwglReleasePbufferDCARB		=	(PFNWGLRELEASEPBUFFERDCARBPROC) qwglGetProcAddress("wglReleasePbufferDCARB");
+			qwglDestroyPbufferARB		=	(PFNWGLDESTROYPBUFFERARBPROC) qwglGetProcAddress("wglDestroyPbufferARB");
+			qwglQueryPbufferARB			=	(PFNWGLQUERYPBUFFERARBPROC) qwglGetProcAddress("wglQueryPbufferARB");
+	
+			// Validate the functions we need.
+			if ( !qwglCreatePbufferARB || !qwglGetPbufferDCARB || !qwglReleasePbufferDCARB || !qwglDestroyPbufferARB || !qwglQueryPbufferARB )
+			{
+				bWGLARBPbuffer = false;
+				Com_Printf ("...WGL_ARB_pbuffer failed\n" );
+			}
+		}
+		else
+		{
+			bWGLARBPbuffer = false;
+			Com_Printf ("...WGL_ARB_pbuffer not found\n" );
+		}
+
+		// Render-Texture (requires pbuffer ext (and it's dependancies of course).
+		if ( strstr( wglExtensions, "WGL_ARB_render_texture" ) && bWGLARBPbuffer )
+		{
+			qwglBindTexImageARB			=	(PFNWGLBINDTEXIMAGEARBPROC) qwglGetProcAddress("wglBindTexImageARB");
+			qwglReleaseTexImageARB		=	(PFNWGLRELEASETEXIMAGEARBPROC) qwglGetProcAddress("wglReleaseTexImageARB");
+			qwglSetPbufferAttribARB		=	(PFNWGLSETPBUFFERATTRIBARBPROC) qwglGetProcAddress("wglSetPbufferAttribARB");
+	
+			// Validate the functions we need.
+			if ( !qwglCreatePbufferARB || !qwglGetPbufferDCARB || !qwglReleasePbufferDCARB || !qwglDestroyPbufferARB || !qwglQueryPbufferARB )
+			{
+				Com_Printf ("...ignoring WGL_ARB_render_texture\n" );
+			}
+			else
+			{
+				bHasRenderTexture = true;
+			}
+		}
+		else
+		{
+			Com_Printf ("...ignoring WGL_ARB_render_texture\n" );
+		}
+	}
+
+	// Find out how many general combiners they have.
+	#define GL_MAX_GENERAL_COMBINERS_NV       0x854D
+	GLint iNumGeneralCombiners = 0;
+	qglGetIntegerv( GL_MAX_GENERAL_COMBINERS_NV, &iNumGeneralCombiners );
+
+	// Only allow dynamic glows/flares if they have the hardware
+	if ( bTexRectSupported && bARBVertexProgram && bHasRenderTexture && qglActiveTextureARB && glConfig.maxActiveTextures >= 4 &&
+		( ( bNVRegisterCombiners && iNumGeneralCombiners >= 2 ) || bARBFragmentProgram ) )
+	{
+		g_bDynamicGlowSupported = true;
+		// this would overwrite any achived setting gwg
+		// Cvar_Set( "r_DynamicGlow", "1" );
+	}
+	else
+	{
+		g_bDynamicGlowSupported = false;
+		Cvar_Set( "r_DynamicGlow","0" );
+	}
+}
+
+/*
+** GLW_CheckOSVersion
+*/
+static qboolean GLW_CheckOSVersion( void )
+{
+#define OSR2_BUILD_NUMBER 1111
+
+	OSVERSIONINFO	vinfo;
+
+	vinfo.dwOSVersionInfoSize = sizeof(vinfo);
+
+	glw_state.allowdisplaydepthchange = qfalse;
+
+	if ( GetVersionEx( &vinfo) )
+	{
+		if ( vinfo.dwMajorVersion > 4 )
+		{
+			glw_state.allowdisplaydepthchange = qtrue;
+		}
+		else if ( vinfo.dwMajorVersion == 4 )
+		{
+			if ( vinfo.dwPlatformId == VER_PLATFORM_WIN32_NT )
+			{
+				glw_state.allowdisplaydepthchange = qtrue;
+			}
+			else if ( vinfo.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS )
+			{
+				if ( LOWORD( vinfo.dwBuildNumber ) >= OSR2_BUILD_NUMBER )
+				{
+					glw_state.allowdisplaydepthchange = qtrue;
+				}
+			}
+		}
+	}
+	else
+	{
+		Com_Printf ("GLW_CheckOSVersion() - GetVersionEx failed\n" );
+		return qfalse;
+	}
+
+	return qtrue;
+}
+
+/*
+** GLW_LoadOpenGL
+**
+** GLimp_win.c internal function that attempts to load and use 
+** a specific OpenGL DLL.
+*/
+static qboolean GLW_LoadOpenGL( )
+{
+	char buffer[1024];
+	qboolean cdsFullscreen;
+
+	strlwr( strcpy( buffer, OPENGL_DRIVER_NAME ) );
+
+	//
+	// load the driver and bind our function pointers to it
+	// 
+	if ( QGL_Init( buffer ) ) 
+	{
+		cdsFullscreen = (qboolean)r_fullscreen->integer;
+
+		// create the window and set up the context
+		if ( !GLW_StartDriverAndSetMode( r_mode->integer, r_colorbits->integer, cdsFullscreen ) )
+		{
+			// if we're on a 24/32-bit desktop and we're going fullscreen on an ICD,
+			// try it again but with a 16-bit desktop
+			if ( r_colorbits->integer != 16 ||
+				 cdsFullscreen != qtrue ||
+				 r_mode->integer != 3 )
+			{
+				if ( !GLW_StartDriverAndSetMode( 3, 16, qtrue ) )
+				{
+					goto fail;
+				}
+			}
+		}
+
+#ifdef _CRAZY_ATTRIB_DEBUG
+		//I can get away with this because we don't actually use push/pop attrib anywhere else.
+		qglPushAttrib(GL_ACCUM_BUFFER_BIT|GL_COLOR_BUFFER_BIT|GL_CURRENT_BIT|GL_DEPTH_BUFFER_BIT|
+			GL_ENABLE_BIT|GL_EVAL_BIT|GL_FOG_BIT|GL_HINT_BIT|GL_LIGHTING_BIT|GL_LINE_BIT|GL_LIST_BIT|
+			GL_PIXEL_MODE_BIT|GL_POINT_BIT|GL_POLYGON_BIT|GL_POLYGON_STIPPLE_BIT|GL_SCISSOR_BIT|
+			GL_STENCIL_BUFFER_BIT|GL_TEXTURE_BIT|GL_TRANSFORM_BIT|GL_VIEWPORT_BIT);
+#endif
+
+		return qtrue;
+	}
+fail:
+
+	QGL_Shutdown();
+
+	return qfalse;
+}
+
+/*
+** GLimp_EndFrame
+*/
+void GLimp_EndFrame (void)
+{
+	//
+	// swapinterval stuff
+	//
+	if ( r_swapInterval->modified ) {
+		r_swapInterval->modified = qfalse;
+
+		if ( !glConfig.stereoEnabled ) {	// why?
+			if ( qwglSwapIntervalEXT ) {
+				qwglSwapIntervalEXT( r_swapInterval->integer );
+			}
+		}
+	}
+
+
+	// don't flip if drawing to front buffer
+	//if ( stricmp( r_drawBuffer->string, "GL_FRONT" ) != 0 )
+	{
+		SwapBuffers( glw_state.hDC );
+	}
+
+	// check logging
+	QGL_EnableLogging( (qboolean)r_logFile->integer );
+}
+
+static void GLW_StartOpenGL( void )
+{
+	//
+	// load and initialize the specific OpenGL driver
+	//
+	if ( !GLW_LoadOpenGL() )
+	{
+		Com_Error( ERR_FATAL, "GLW_StartOpenGL() - could not load OpenGL subsystem\n" );
+	}
+}
+
+/*
+** GLimp_Init
+**
+** This is the platform specific OpenGL initialization function.  It
+** is responsible for loading OpenGL, initializing it, setting
+** extensions, creating a window of the appropriate size, doing
+** fullscreen manipulations, etc.  Its overall responsibility is
+** to make sure that a functional OpenGL subsystem is operating
+** when it returns to the ref.
+*/
+void GLimp_Init( void )
+{
+	char	buf[MAX_STRING_CHARS];
+	cvar_t *lastValidRenderer = Cvar_Get( "r_lastValidRenderer", "(uninitialized)", CVAR_ARCHIVE );
+	cvar_t	*cv;
+
+//	Com_Printf ("Initializing OpenGL subsystem\n" );
+
+	//
+	// check OS version to see if we can do fullscreen display changes
+	//
+	if ( !GLW_CheckOSVersion() )
+	{
+		Com_Error( ERR_FATAL, "GLimp_Init() - incorrect operating system\n" );
+	}
+
+	// save off hInstance and wndproc
+	cv = Cvar_Get( "win_hinstance", "", 0 );
+	sscanf( cv->string, "%i", (int *)&g_wv.hInstance );
+
+	cv = Cvar_Get( "win_wndproc", "", 0 );
+	sscanf( cv->string, "%i", (int *)&glw_state.wndproc );
+
+	r_allowSoftwareGL = Cvar_Get( "r_allowSoftwareGL", "0", CVAR_LATCH );
+
+	// load appropriate DLL and initialize subsystem
+	GLW_StartOpenGL();
+
+	// get our config strings
+	glConfig.vendor_string = (const char *) qglGetString (GL_VENDOR);
+	glConfig.renderer_string = (const char *) qglGetString (GL_RENDERER);
+	glConfig.version_string = (const char *) qglGetString (GL_VERSION);
+	glConfig.extensions_string = (const char *) qglGetString (GL_EXTENSIONS);
+	
+	if (!glConfig.vendor_string || !glConfig.renderer_string || !glConfig.version_string || !glConfig.extensions_string)
+	{
+		Com_Error( ERR_FATAL, "GLimp_Init() - Invalid GL Driver\n" );
+	}
+
+	// OpenGL driver constants
+	qglGetIntegerv( GL_MAX_TEXTURE_SIZE, &glConfig.maxTextureSize );
+	// stubbed or broken drivers may have reported 0...
+	if ( glConfig.maxTextureSize <= 0 ) 
+	{
+		glConfig.maxTextureSize = 0;
+	}
+
+	//
+	// chipset specific configuration
+	//
+	Q_strncpyz( buf, glConfig.renderer_string, sizeof(buf) );
+	strlwr( buf );
+	
+	//
+	// NOTE: if changing cvars, do it within this block.  This allows them
+	// to be overridden when testing driver fixes, etc. but only sets
+	// them to their default state when the hardware is first installed/run.
+	//
+extern qboolean Sys_LowPhysicalMemory();
+	if ( Q_stricmp( lastValidRenderer->string, glConfig.renderer_string ) )
+	{
+		if (Sys_LowPhysicalMemory())
+		{
+			Cvar_Set("s_khz", "11");// this will get called before S_Init
+		}
+		//reset to defaults
+		Cvar_Set( "r_picmip", "1" );
+
+		// Savage3D and Savage4 should always have trilinear enabled
+		if ( strstr( buf, "savage3d" ) || strstr( buf, "s3 savage4" ) || strstr( buf, "geforce" ) || strstr( buf, "quadro" ) )
+		{
+			Cvar_Set( "r_texturemode", "GL_LINEAR_MIPMAP_LINEAR" );
+		}
+		else
+		{
+			Cvar_Set( "r_textureMode", "GL_LINEAR_MIPMAP_NEAREST" );
+		}
+		
+		if ( strstr( buf, "kyro" ) )	
+		{
+			Cvar_Set( "r_ext_texture_filter_anisotropic", "0");	//KYROs have it avail, but suck at it!
+			Cvar_Set( "r_ext_preferred_tc_method", "1");			//(Use DXT1 instead of DXT5 - same quality but much better performance on KYRO)
+		}
+		if ( strstr( buf, "geforce2" ) )	
+		{
+			Cvar_Set( "cg_renderToTextureFX", "0");	// slow to zero bug fix
+		}
+
+		if ( strstr( buf, "radeon 9000" ) )	
+		{
+			Cvar_Set( "cg_renderToTextureFX", "0");	// white texture bug
+		}
+		
+		GLW_InitExtensions();	//get the values for test below
+		//this must be a really sucky card!
+		if ( (glConfig.textureCompression == TC_NONE) || (glConfig.maxActiveTextures < 2)  || (glConfig.maxTextureSize <= 512) )
+		{
+			Cvar_Set( "r_picmip", "2");
+			Cvar_Set( "r_colorbits", "16");
+			Cvar_Set( "r_texturebits", "16");
+			Cvar_Set( "r_mode", "3");	//force 640
+			Cmd_ExecuteString ("exec low.cfg\n");	//get the rest which can be pulled in after init
+		}
+	}
+	
+	Cvar_Set( "r_lastValidRenderer", glConfig.renderer_string );
+	GLW_InitExtensions();
+
+	WG_CheckHardwareGamma();
+}
+
+/*
+** GLimp_Shutdown
+**
+** This routine does all OS specific shutdown procedures for the OpenGL
+** subsystem.
+*/
+void GLimp_Shutdown( void )
+{
+//	const char *strings[] = { "soft", "hard" };
+//	const char *success[] = { "failed", "success" };
+	int retVal;
+
+	// FIXME: Brian, we need better fallbacks from partially initialized failures
+	if ( !qwglMakeCurrent ) {
+		return;
+	}
+
+	Com_Printf ("Shutting down OpenGL subsystem\n" );
+
+	// restore gamma.  We do this first because 3Dfx's extension needs a valid OGL subsystem
+	WG_RestoreGamma();
+
+	// set current context to NULL
+	if ( qwglMakeCurrent )
+	{
+		retVal = qwglMakeCurrent( NULL, NULL ) != 0;
+
+//		Com_Printf ("...wglMakeCurrent( NULL, NULL ): %s\n", success[retVal] );
+	}
+
+	// delete HGLRC
+	if ( glw_state.hGLRC )
+	{
+		retVal = qwglDeleteContext( glw_state.hGLRC ) != 0;
+//		Com_Printf ("...deleting GL context: %s\n", success[retVal] );
+		glw_state.hGLRC = NULL;
+	}
+
+	// release DC
+	if ( glw_state.hDC )
+	{
+		retVal = ReleaseDC( g_wv.hWnd, glw_state.hDC ) != 0;
+//		Com_Printf ("...releasing DC: %s\n", success[retVal] );
+		glw_state.hDC   = NULL;
+	}
+
+	// destroy window
+	if ( g_wv.hWnd )
+	{
+//		Com_Printf ("...destroying window\n" );
+		ShowWindow( g_wv.hWnd, SW_HIDE );
+		DestroyWindow( g_wv.hWnd );
+		g_wv.hWnd = NULL;
+		glw_state.pixelFormatSet = qfalse;
+	}
+
+	// close the r_logFile
+	if ( glw_state.log_fp )
+	{
+		fclose( glw_state.log_fp );
+		glw_state.log_fp = 0;
+	}
+
+	// reset display settings
+	if ( glw_state.cdsFullscreen )
+	{
+//		Com_Printf ("...resetting display\n" );
+		ChangeDisplaySettings( 0, 0 );
+		glw_state.cdsFullscreen = qfalse;
+	}
+
+	// shutdown QGL subsystem
+	QGL_Shutdown();
+
+	memset( &glConfig, 0, sizeof( glConfig ) );
+	memset( &glState, 0, sizeof( glState ) );
+}
+
+/*
+** GLimp_LogComment
+*/
+void GLimp_LogComment( char *comment ) 
+{
+	if ( glw_state.log_fp ) {
+		fprintf( glw_state.log_fp, "%s", comment );
+	}
+}
+
+
+/*
+===========================================================
+
+SMP acceleration
+
+===========================================================
+*/
+
+HANDLE	renderCommandsEvent;
+HANDLE	renderCompletedEvent;
+HANDLE	renderActiveEvent;
+
+void (*glimpRenderThread)( void );
+
+void GLimp_RenderThreadWrapper( void ) {
+	glimpRenderThread();
+
+	// unbind the context before we die
+	qwglMakeCurrent( glw_state.hDC, NULL );
+}
+
+/*
+=======================
+GLimp_SpawnRenderThread
+=======================
+*/
+HANDLE	renderThreadHandle;
+int		renderThreadId;
+qboolean GLimp_SpawnRenderThread( void (*function)( void ) ) {
+
+	renderCommandsEvent = CreateEvent( NULL, TRUE, FALSE, NULL );
+	renderCompletedEvent = CreateEvent( NULL, TRUE, FALSE, NULL );
+	renderActiveEvent = CreateEvent( NULL, TRUE, FALSE, NULL );
+
+	glimpRenderThread = function;
+
+	renderThreadHandle = CreateThread(
+	   NULL,	// LPSECURITY_ATTRIBUTES lpsa,
+	   0,		// DWORD cbStack,
+	   (LPTHREAD_START_ROUTINE)GLimp_RenderThreadWrapper,	// LPTHREAD_START_ROUTINE lpStartAddr,
+	   0,			// LPVOID lpvThreadParm,
+	   0,			//   DWORD fdwCreate,
+	   (unsigned long *)&renderThreadId );
+
+	if ( !renderThreadHandle ) {
+		return qfalse;
+	}
+
+	return qtrue;
+}
+
+static	void	*smpData;
+static	int		wglErrors;
+
+void *GLimp_RendererSleep( void ) {
+	void	*data;
+
+	if ( !qwglMakeCurrent( glw_state.hDC, NULL ) ) {
+		wglErrors++;
+	}
+
+	ResetEvent( renderActiveEvent );
+
+	// after this, the front end can exit GLimp_FrontEndSleep
+	SetEvent( renderCompletedEvent );
+
+	WaitForSingleObject( renderCommandsEvent, INFINITE );
+
+	if ( !qwglMakeCurrent( glw_state.hDC, glw_state.hGLRC ) ) {
+		wglErrors++;
+	}
+
+	ResetEvent( renderCompletedEvent );
+	ResetEvent( renderCommandsEvent );
+
+	data = smpData;
+
+	// after this, the main thread can exit GLimp_WakeRenderer
+	SetEvent( renderActiveEvent );
+
+	return data;
+}
+
+
+void GLimp_FrontEndSleep( void ) {
+	WaitForSingleObject( renderCompletedEvent, INFINITE );
+
+	if ( !qwglMakeCurrent( glw_state.hDC, glw_state.hGLRC ) ) {
+		wglErrors++;
+	}
+}
+
+
+void GLimp_WakeRenderer( void *data ) {
+	smpData = data;
+
+	if ( !qwglMakeCurrent( glw_state.hDC, NULL ) ) {
+		wglErrors++;
+	}
+
+	// after this, the renderer can continue through GLimp_RendererSleep
+	SetEvent( renderCommandsEvent );
+
+	WaitForSingleObject( renderActiveEvent, INFINITE );
+}
+
+
+// Allocate and create a new PBuffer.
+bool CPBUFFER::Create( int iWidth, int iHeight, int iColorBits, int iDepthBits, int iStencilBits )
+{
+	m_iWidth = iWidth;
+	m_iHeight = iHeight;
+	m_iColorBits = iColorBits;
+	m_iDepthBits = iDepthBits;
+	m_iStencilBits = iStencilBits;
+	
+	extern glwstate_t glw_state;
+	m_hOldRC = glw_state.hGLRC; //qwglGetCurrentContext();
+	
+	// Get the current device context.
+	m_hOldDC = glw_state.hDC; //qwglGetCurrentDC();
+
+	if( !m_hOldDC )
+	{
+		return false;
+	}
+
+#define WGL_BIND_TO_TEXTURE_RGB_ARB        0x2070
+
+	// These are standard settings. I suppose if one wanted more control you could pass an attrib list in (but why?).
+	const int iAttribList[] =
+	{
+		WGL_SUPPORT_OPENGL_ARB,			true,       // P-buffer will be used with OpenGL.
+		WGL_DRAW_TO_PBUFFER_ARB,		true,		// Enable render to p-buffer.
+		WGL_BIND_TO_TEXTURE_RGBA_ARB,	true,		// P-buffer will be used as a texture.
+		WGL_RED_BITS_ARB,				8,          // At least 8 bits for RED channel.
+		WGL_GREEN_BITS_ARB,				8,          // At least 8 bits for GREEN channel.
+		WGL_BLUE_BITS_ARB,				8,          // At least 8 bits for BLUE channel.
+		WGL_ALPHA_BITS_ARB,				8,          // At least 8 bits for ALPHA channel.
+		WGL_DEPTH_BITS_ARB,				16,         // At least 16 bits for depth buffer.
+		WGL_DOUBLE_BUFFER_ARB,			false,		// We don't require double buffering
+		0											// Zero terminates the list.
+	};
+
+#define		WGL_TEXTURE_RECTANGLE_NV		0x20A2
+
+	//const float fAttribList[] = { 0 };
+	const int iFlags[] =
+	{
+		WGL_TEXTURE_FORMAT_ARB, WGL_TEXTURE_RGBA_ARB, // Our p-buffer will have a texture format of RGBA.
+		WGL_TEXTURE_TARGET_ARB, WGL_TEXTURE_RECTANGLE_NV,   // Texture target will be GL_TEXTURE_RECTANGLE.
+		0                                             // Zero terminates the list.
+	};
+
+	// Choose pixel format.
+	unsigned int numFormats;
+	GLint pixelFormat;
+	if( !qwglChoosePixelFormatARB( m_hOldDC, iAttribList, NULL, 1, &pixelFormat, &numFormats ) )
+	{
+		return false;
+	}
+
+	// Create the pbuffer.
+	m_hBuffer = qwglCreatePbufferARB( m_hOldDC, pixelFormat, m_iWidth, m_iHeight, iFlags );
+	if( !m_hBuffer )
+	{
+		return false;
+	}
+
+	// Get the pbuffer's device context.
+	m_hDC = qwglGetPbufferDCARB( m_hBuffer );
+	if( !m_hDC )
+	{
+		return false;
+	}
+
+	// Create a rendering context for the pbuffer.
+	m_hRC = qwglCreateContext( m_hDC );
+	if( !m_hRC )
+	{
+		return false;
+	}
+
+	// Share Display Lists and Texture Objects between contexts (NOTE: Could
+	// also just use parent app RC).
+	qwglShareLists( m_hOldRC, m_hRC );
+
+	// Set and output the actual pBuffer dimensions.
+	qwglQueryPbufferARB( m_hBuffer, WGL_PBUFFER_WIDTH_ARB, &m_iWidth );
+	qwglQueryPbufferARB( m_hBuffer, WGL_PBUFFER_HEIGHT_ARB, &m_iHeight );
+	
+
+	// Create the PBuffer Texture.
+	extern int giTextureBindNum;
+	m_uiPBufferTexture = 1024 + giTextureBindNum++;
+
+	qglDisable( GL_TEXTURE_2D );
+	qglEnable( GL_TEXTURE_RECTANGLE_EXT );
+
+	/*int *pTexture = new int [m_iWidth * m_iHeight];
+	memset( pTexture, 0, m_iWidth * m_iHeight * sizeof( int ) );	*/
+
+	qglBindTexture( GL_TEXTURE_RECTANGLE_EXT, m_uiPBufferTexture );
+	//qglTexImage2D( GL_TEXTURE_RECTANGLE_EXT, 0, GL_RGB, m_iWidth, m_iHeight, 0, GL_RGB, GL_UNSIGNED_BYTE, pTexture );
+	qglTexImage2D( GL_TEXTURE_RECTANGLE_EXT, 0, GL_RGB, m_iWidth, m_iHeight, 0, GL_RGB, GL_FLOAT, 0 );
+	qglTexParameteri( GL_TEXTURE_RECTANGLE_EXT, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
+	qglTexParameteri( GL_TEXTURE_RECTANGLE_EXT, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
+	qglTexParameteri( GL_TEXTURE_RECTANGLE_EXT, GL_TEXTURE_WRAP_S, GL_CLAMP );
+	qglTexParameteri( GL_TEXTURE_RECTANGLE_EXT, GL_TEXTURE_WRAP_T, GL_CLAMP );
+
+	qglDisable( GL_TEXTURE_RECTANGLE_EXT );
+	qglEnable( GL_TEXTURE_2D );
+
+	//delete [] pTexture;
+
+	return true;
+}
+
+// Destroy and deallocate a PBuffer.
+void CPBUFFER::Destroy()
+{
+	// Release the pbuffer texture.
+	qglDeleteTextures( 1, &m_uiPBufferTexture );
+
+	// Release RC.
+	if( m_hRC )
+	{
+		qwglDeleteContext( m_hRC );
+		m_hRC = NULL;
+	}
+
+	// Release DC.
+	if( m_hDC )
+	{
+		qwglReleasePbufferDCARB( m_hBuffer, m_hDC);
+		m_hDC = NULL;
+	}
+	
+	// Release PBuffer.
+	qwglDestroyPbufferARB( m_hBuffer );
+}
+
+// Make this PBuffer the current render device.
+bool CPBUFFER::Begin()
+{
+	if( !qwglMakeCurrent( m_hDC, m_hRC ) )
+	{
+		return false;
+	}
+
+	qwglCopyContext( m_hOldRC, m_hRC, GL_ALL_ATTRIB_BITS  );
+
+	return true;
+}
+
+// Restore the previous render device.
+bool CPBUFFER::End()
+{
+	if( !qwglMakeCurrent( m_hOldDC, m_hOldRC ) )
+	{
+		return false;
+	}
+
+	return true;
+}
diff --git a/codemp/win32/win_glimp_console.cpp b/codemp/win32/win_glimp_console.cpp
new file mode 100644
index 0000000..203738c
--- /dev/null
+++ b/codemp/win32/win_glimp_console.cpp
@@ -0,0 +1,281 @@
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+
+/*
+** WIN_GLIMP.C
+**
+** This file contains ALL Win32 specific stuff having to do with the
+** OpenGL refresh.  When a port is being made the following functions
+** must be implemented by the port:
+**
+** GLimp_EndFrame
+** GLimp_Init
+** GLimp_LogComment
+** GLimp_Shutdown
+**
+** Note that the GLW_xxx functions are Windows specific GL-subsystem
+** related functions that are relevant ONLY to win_glimp.c
+*/
+#include <assert.h>
+#include "../renderer/tr_local.h"
+#include "../qcommon/qcommon.h"
+#include "win_local.h"
+
+#if defined(_WINDOWS) || defined(_XBOX)
+#include "glw_win_dx8.h"
+#elif defined(_GAMECUBE)
+#include "glw_win_gc.h"
+#endif
+
+
+extern void WG_CheckHardwareGamma( void );
+
+static void		GLW_InitExtensions( void );
+static int		GLW_CreateWindow( void );
+
+//
+// function declaration
+//
+void	 QGL_EnableLogging( qboolean enable );
+qboolean QGL_Init( const char *dllname );
+void     QGL_Shutdown( void );
+void	 GLW_Init(int width, int height, int colorbits, qboolean cdsFullscreen);
+void	 GLW_Shutdown(void);
+
+
+//
+// variable declarations
+//
+glwstate_t *glw_state = NULL;
+
+
+/*
+** GLW_CreateWindow
+**
+** Responsible for creating the Alchemy window and initializing the OpenGL driver.
+*/
+static qboolean GLW_CreateWindow( int width, int height, int colorbits, qboolean cdsFullscreen )
+{
+	GLW_Init(width, height, colorbits, cdsFullscreen);
+	IN_Init();
+
+	return qtrue;
+}
+
+//--------------------------------------------
+static void GLW_InitTextureCompression( void )
+{
+	glConfig.textureCompression = TC_NONE;
+}
+
+/*
+** GLW_InitExtensions
+*/
+static void GLW_InitExtensions( void )
+{
+	// Select our tc scheme
+	GLW_InitTextureCompression();
+
+	// GL_EXT_texture_env_add
+	glConfig.textureEnvAddAvailable = qfalse;
+	if ( strstr( glConfig.extensions_string, "EXT_texture_env_add" ) )
+	{
+		glConfig.textureEnvAddAvailable = qtrue;
+	}
+
+	// GL_EXT_texture_filter_anisotropic
+	glConfig.maxTextureFilterAnisotropy = 0;
+	if ( strstr( glConfig.extensions_string, "EXT_texture_filter_anisotropic" ) )
+	{
+		qglGetFloatv( GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &glConfig.maxTextureFilterAnisotropy );
+		Com_Printf ("...GL_EXT_texture_filter_anisotropic available\n" );
+
+		if ( r_ext_texture_filter_anisotropic->integer>1 )
+		{
+			Com_Printf ("...using GL_EXT_texture_filter_anisotropic\n" );
+		}
+		else
+		{
+			Com_Printf ("...ignoring GL_EXT_texture_filter_anisotropic\n" );
+		}
+		Cvar_Set( "r_ext_texture_filter_anisotropic_avail", va("%f",glConfig.maxTextureFilterAnisotropy) );
+		if ( r_ext_texture_filter_anisotropic->value > glConfig.maxTextureFilterAnisotropy )
+		{
+			Cvar_Set( "r_ext_texture_filter_anisotropic", va("%f",glConfig.maxTextureFilterAnisotropy) );
+		}
+	}
+	else
+	{
+		Com_Printf ("...GL_EXT_texture_filter_anisotropic not found\n" );
+		Cvar_Set( "r_ext_texture_filter_anisotropic_avail", "0" );
+	}
+
+	// GL_EXT_clamp_to_edge
+	glConfig.clampToEdgeAvailable = qfalse;
+	if ( strstr( glConfig.extensions_string, "GL_EXT_texture_edge_clamp" ) )
+	{
+		glConfig.clampToEdgeAvailable = qtrue;
+	}
+
+	// GL_ARB_multitexture
+	if ( strstr( glConfig.extensions_string, "GL_ARB_multitexture" )  )
+	{
+		if ( qglActiveTextureARB )
+		{
+			qglGetIntegerv( GL_MAX_ACTIVE_TEXTURES_ARB, &glConfig.maxActiveTextures );
+			
+			if ( glConfig.maxActiveTextures < 2 )
+			{
+				qglMultiTexCoord2fARB = NULL;
+				qglActiveTextureARB = NULL;
+				qglClientActiveTextureARB = NULL;
+			}
+		}
+	}
+}
+
+/*
+** GLW_LoadOpenGL
+**
+** GLimp_win.c internal function that attempts to load and use 
+** a specific OpenGL DLL.
+*/
+static qboolean GLW_LoadOpenGL()
+{
+	char buffer[1024];
+
+	strlwr( strcpy( buffer, OPENGL_DRIVER_NAME ) );
+
+	//
+	// load the driver and bind our function pointers to it
+	// 
+	if ( QGL_Init( buffer ) ) 
+	{
+		GLW_CreateWindow(640, 480, 24, 1);
+		return qtrue;
+	}
+
+	QGL_Shutdown();
+
+	return qfalse;
+}
+
+
+/*
+** GLimp_EndFrame
+*/
+void GLimp_EndFrame (void)
+{
+	// don't flip if drawing to front buffer
+//	if ( stricmp( r_drawBuffer->string, "GL_FRONT" ) != 0 )
+	{
+	}
+}
+
+static void GLW_StartOpenGL( void )
+{
+	//
+	// load and initialize the specific OpenGL driver
+	//
+	if ( !GLW_LoadOpenGL() )
+	{
+		Com_Error( ERR_FATAL, "GLW_StartOpenGL() - could not load OpenGL subsystem\n" );
+	}
+}
+
+/*
+** GLimp_Init
+**
+** This is the platform specific OpenGL initialization function.  It
+** is responsible for loading OpenGL, initializing it, setting
+** extensions, creating a window of the appropriate size, doing
+** fullscreen manipulations, etc.  Its overall responsibility is
+** to make sure that a functional OpenGL subsystem is operating
+** when it returns to the ref.
+*/
+void GLimp_Init( void )
+{
+	// load appropriate DLL and initialize subsystem
+	GLW_StartOpenGL();
+
+	// get our config strings
+	glConfig.vendor_string = (const char *) qglGetString (GL_VENDOR);
+	glConfig.renderer_string = (const char *) qglGetString (GL_RENDERER);
+	glConfig.version_string = (const char *) qglGetString (GL_VERSION);
+	glConfig.extensions_string = (const char *) qglGetString (GL_EXTENSIONS);
+	
+	if (!glConfig.vendor_string || !glConfig.renderer_string || !glConfig.version_string || !glConfig.extensions_string)
+	{
+		Com_Error( ERR_FATAL, "GLimp_Init() - Invalid GL Driver\n" );
+	}
+
+	// OpenGL driver constants
+	qglGetIntegerv( GL_MAX_TEXTURE_SIZE, &glConfig.maxTextureSize );
+	// stubbed or broken drivers may have reported 0...
+	if ( glConfig.maxTextureSize <= 0 ) 
+	{
+		glConfig.maxTextureSize = 0;
+	}
+
+	GLW_InitExtensions();
+	WG_CheckHardwareGamma();
+}
+
+/*
+** GLimp_Shutdown
+**
+** This routine does all OS specific shutdown procedures for the OpenGL
+** subsystem.
+*/
+void GLimp_Shutdown( void )
+{
+	// FIXME: Brian, we need better fallbacks from partially initialized failures
+	Com_Printf ("Shutting down OpenGL subsystem\n" );
+
+	// Set the gamma back to normal
+//	GLimp_SetGamma(1.f);
+
+	// kill input system (tied to window)
+	IN_Shutdown();
+
+	// shutdown QGL subsystem
+	GLW_Shutdown();
+	QGL_Shutdown();
+
+	memset( &glConfig, 0, sizeof( glConfig ) );
+	memset( &glState, 0, sizeof( glState ) );
+}
+
+/*
+** GLimp_LogComment
+*/
+void GLimp_LogComment( char *comment ) 
+{
+}
+
+
+/*
+===========================================================
+
+SMP acceleration
+
+===========================================================
+*/
+
+qboolean GLimp_SpawnRenderThread( void (*function)( void ) ) {
+	return qfalse;
+}
+
+void *GLimp_RendererSleep( void ) {
+	return NULL;
+}
+
+
+void GLimp_FrontEndSleep( void ) {
+}
+
+
+void GLimp_WakeRenderer( void *data ) {
+}
diff --git a/codemp/win32/win_input.cpp b/codemp/win32/win_input.cpp
new file mode 100644
index 0000000..79ad8ae
--- /dev/null
+++ b/codemp/win32/win_input.cpp
@@ -0,0 +1,1141 @@
+// win_input.c -- win32 mouse and joystick code
+// 02/21/97 JCB Added extended DirectInput code to support external controllers.
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+#include "../client/client.h"
+#include "win_local.h"
+
+
+typedef struct {
+	int			oldButtonState;
+
+	qboolean	mouseActive;
+	qboolean	mouseInitialized;
+} WinMouseVars_t;
+
+static WinMouseVars_t s_wmv;
+
+static int	window_center_x, window_center_y;
+
+//
+// MIDI definitions
+//
+static void IN_StartupMIDI( void );
+static void IN_ShutdownMIDI( void );
+
+#define MAX_MIDIIN_DEVICES	8
+
+typedef struct {
+	int			numDevices;
+	MIDIINCAPS	caps[MAX_MIDIIN_DEVICES];
+
+	HMIDIIN		hMidiIn;
+} MidiInfo_t;
+
+static MidiInfo_t s_midiInfo;
+
+//
+// Joystick definitions
+//
+#define	JOY_MAX_AXES		6				// X, Y, Z, R, U, V
+
+typedef struct {
+	qboolean	avail;
+	int			id;			// joystick number
+	JOYCAPS		jc;
+
+	int			oldbuttonstate;
+	int			oldpovstate;
+
+	JOYINFOEX	ji;
+} joystickInfo_t;
+
+static	joystickInfo_t	joy;
+
+
+cvar_t	*in_midi;
+cvar_t	*in_midiport;
+cvar_t	*in_midichannel;
+cvar_t	*in_mididevice;
+
+cvar_t	*in_mouse;
+cvar_t	*in_joystick;
+cvar_t	*in_joyBallScale;
+cvar_t	*in_debugJoystick;
+cvar_t	*joy_threshold;
+cvar_t	*joy_xbutton;
+cvar_t	*joy_ybutton;
+
+qboolean	in_appactive;
+
+// forward-referenced functions
+void IN_StartupJoystick (void);
+void IN_JoyMove(void);
+
+static void MidiInfo_f( void );
+
+/*
+============================================================
+
+WIN32 MOUSE CONTROL
+
+============================================================
+*/
+
+/*
+================
+IN_InitWin32Mouse
+================
+*/
+void IN_InitWin32Mouse( void ) 
+{
+}
+
+/*
+================
+IN_ShutdownWin32Mouse
+================
+*/
+void IN_ShutdownWin32Mouse( void ) {
+}
+
+/*
+================
+IN_ActivateWin32Mouse
+================
+*/
+void IN_ActivateWin32Mouse( void ) {
+	int			width, height;
+	RECT		window_rect;
+
+	width = GetSystemMetrics (SM_CXSCREEN);
+	height = GetSystemMetrics (SM_CYSCREEN);
+
+	GetWindowRect ( g_wv.hWnd, &window_rect);
+	if (window_rect.left < 0)
+		window_rect.left = 0;
+	if (window_rect.top < 0)
+		window_rect.top = 0;
+	if (window_rect.right >= width)
+		window_rect.right = width-1;
+	if (window_rect.bottom >= height-1)
+		window_rect.bottom = height-1;
+	window_center_x = (window_rect.right + window_rect.left)/2;
+	window_center_y = (window_rect.top + window_rect.bottom)/2;
+
+	SetCursorPos (window_center_x, window_center_y);
+
+	SetCapture ( g_wv.hWnd );
+	ClipCursor (&window_rect);
+	while (ShowCursor (FALSE) >= 0)
+		;
+}
+
+/*
+================
+IN_DeactivateWin32Mouse
+================
+*/
+void IN_DeactivateWin32Mouse( void ) 
+{
+	ClipCursor (NULL);
+	ReleaseCapture ();
+	while (ShowCursor (TRUE) < 0)
+		;
+}
+
+/*
+================
+IN_Win32Mouse
+================
+*/
+void IN_Win32Mouse( int *mx, int *my ) {
+	POINT		current_pos;
+
+	// find mouse movement
+	GetCursorPos (&current_pos);
+
+	// force the mouse to the center, so there's room to move
+	SetCursorPos (window_center_x, window_center_y);
+
+	*mx = current_pos.x - window_center_x;
+	*my = current_pos.y - window_center_y;
+}
+
+
+/*
+============================================================
+
+DIRECT INPUT MOUSE CONTROL
+
+============================================================
+*/
+
+#undef DEFINE_GUIDX
+
+#define DEFINE_GUIDX(name, l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8) \
+        EXTERN_C const GUID name \
+                = { l, w1, w2, { b1, b2,  b3,  b4,  b5,  b6,  b7,  b8 } }
+
+DEFINE_GUIDX(GUID_SysMouse,   0x6F1D2B60,0xD5A0,0x11CF,0xBF,0xC7,0x44,0x45,0x53,0x54,0x00,0x00);
+DEFINE_GUIDX(GUID_XAxis,   0xA36D02E0,0xC9F3,0x11CF,0xBF,0xC7,0x44,0x45,0x53,0x54,0x00,0x00);
+DEFINE_GUIDX(GUID_YAxis,   0xA36D02E1,0xC9F3,0x11CF,0xBF,0xC7,0x44,0x45,0x53,0x54,0x00,0x00);
+DEFINE_GUIDX(GUID_ZAxis,   0xA36D02E2,0xC9F3,0x11CF,0xBF,0xC7,0x44,0x45,0x53,0x54,0x00,0x00);
+
+
+#define DINPUT_BUFFERSIZE           16
+#define iDirectInputCreate(a,b,c,d)	pDirectInputCreate(a,b,c,d)
+
+HRESULT (WINAPI *pDirectInputCreate)(HINSTANCE hinst, DWORD dwVersion,
+	LPDIRECTINPUT * lplpDirectInput, LPUNKNOWN punkOuter);
+
+static HINSTANCE hInstDI;
+
+typedef struct MYDATA {
+	LONG  lX;                   // X axis goes here
+	LONG  lY;                   // Y axis goes here
+	LONG  lZ;                   // Z axis goes here
+	BYTE  bButtonA;             // One button goes here
+	BYTE  bButtonB;             // Another button goes here
+	BYTE  bButtonC;             // Another button goes here
+	BYTE  bButtonD;             // Another button goes here
+} MYDATA;
+
+static DIOBJECTDATAFORMAT rgodf[] = {
+  { &GUID_XAxis,    FIELD_OFFSET(MYDATA, lX),       DIDFT_AXIS | DIDFT_ANYINSTANCE,   0,},
+  { &GUID_YAxis,    FIELD_OFFSET(MYDATA, lY),       DIDFT_AXIS | DIDFT_ANYINSTANCE,   0,},
+  { &GUID_ZAxis,    FIELD_OFFSET(MYDATA, lZ),       0x80000000 | DIDFT_AXIS | DIDFT_ANYINSTANCE,   0,},
+  { 0,              FIELD_OFFSET(MYDATA, bButtonA), DIDFT_BUTTON | DIDFT_ANYINSTANCE, 0,},
+  { 0,              FIELD_OFFSET(MYDATA, bButtonB), DIDFT_BUTTON | DIDFT_ANYINSTANCE, 0,},
+  { 0,              FIELD_OFFSET(MYDATA, bButtonC), 0x80000000 | DIDFT_BUTTON | DIDFT_ANYINSTANCE, 0,},
+  { 0,              FIELD_OFFSET(MYDATA, bButtonD), 0x80000000 | DIDFT_BUTTON | DIDFT_ANYINSTANCE, 0,},
+};
+
+#define NUM_OBJECTS (sizeof(rgodf) / sizeof(rgodf[0]))
+
+static DIDATAFORMAT	df = {
+	sizeof(DIDATAFORMAT),       // this structure
+	sizeof(DIOBJECTDATAFORMAT), // size of object data format
+	DIDF_RELAXIS,               // absolute axis coordinates
+	sizeof(MYDATA),             // device data size
+	NUM_OBJECTS,                // number of objects
+	rgodf,                      // and here they are
+};
+
+static LPDIRECTINPUT		g_pdi;
+static LPDIRECTINPUTDEVICE	g_pMouse;
+
+void IN_DIMouse( int *mx, int *my );
+
+/*
+========================
+IN_InitDIMouse
+========================
+*/
+qboolean IN_InitDIMouse( void ) {
+    HRESULT		hr;
+	int			x, y;
+	DIPROPDWORD	dipdw = {
+		{
+			sizeof(DIPROPDWORD),        // diph.dwSize
+			sizeof(DIPROPHEADER),       // diph.dwHeaderSize
+			0,                          // diph.dwObj
+			DIPH_DEVICE,                // diph.dwHow
+		},
+		DINPUT_BUFFERSIZE,              // dwData
+	};
+
+	Com_Printf( "Initializing DirectInput...\n");
+
+	if (!hInstDI) {
+		hInstDI = LoadLibrary("dinput.dll");
+		
+		if (hInstDI == NULL) {
+			Com_Printf ("Couldn't load dinput.dll\n");
+			return qfalse;
+		}
+	}
+
+	if (!pDirectInputCreate) {
+		pDirectInputCreate = (long (__stdcall *)(struct HINSTANCE__ *,unsigned long,struct IDirectInputA ** ,struct IUnknown *))
+			GetProcAddress(hInstDI,"DirectInputCreateA");
+
+		if (!pDirectInputCreate) {
+			Com_Printf ("Couldn't get DI proc addr\n");
+			return qfalse;
+		}
+	}
+
+	// register with DirectInput and get an IDirectInput to play with.
+	hr = iDirectInputCreate( g_wv.hInstance, DIRECTINPUT_VERSION, &g_pdi, NULL);
+
+	if (FAILED(hr)) {
+		Com_Printf ("iDirectInputCreate failed\n");
+		return qfalse;
+	}
+
+	// obtain an interface to the system mouse device.
+	hr = IDirectInput_CreateDevice(g_pdi, GUID_SysMouse, &g_pMouse, NULL);
+
+	if (FAILED(hr)) {
+		Com_Printf ("Couldn't open DI mouse device\n");
+		return qfalse;
+	}
+
+	// set the data format to "mouse format".
+	hr = IDirectInputDevice_SetDataFormat(g_pMouse, &df);
+
+	if (FAILED(hr)) 	{
+		Com_Printf ("Couldn't set DI mouse format\n");
+		return qfalse;
+	}
+
+	// set the cooperativity level.
+	hr = IDirectInputDevice_SetCooperativeLevel(g_pMouse, g_wv.hWnd,
+			DISCL_EXCLUSIVE | DISCL_FOREGROUND);
+
+	if (FAILED(hr)) {
+		Com_Printf ("Couldn't set DI coop level\n");
+		return qfalse;
+	}
+
+
+	// set the buffer size to DINPUT_BUFFERSIZE elements.
+	// the buffer size is a DWORD property associated with the device
+	hr = IDirectInputDevice_SetProperty(g_pMouse, DIPROP_BUFFERSIZE, &dipdw.diph);
+
+	if (FAILED(hr)) {
+		Com_Printf ("Couldn't set DI buffersize\n");
+		return qfalse;
+	}
+
+	// clear any pending samples
+	IN_DIMouse( &x, &y );
+	IN_DIMouse( &x, &y );
+
+	Com_Printf( "DirectInput initialized.\n");
+	return qtrue;
+}
+
+/*
+==========================
+IN_ShutdownDIMouse
+==========================
+*/
+void IN_ShutdownDIMouse( void ) {
+    if (g_pMouse) {
+		IDirectInputDevice_Release(g_pMouse);
+		g_pMouse = NULL;
+	}
+
+    if (g_pdi) {
+		IDirectInput_Release(g_pdi);
+		g_pdi = NULL;
+	}
+}
+
+/*
+==========================
+IN_ActivateDIMouse
+==========================
+*/
+void IN_ActivateDIMouse( void ) {
+	HRESULT		hr;
+
+	if (!g_pMouse) {
+		return;
+	}
+
+	// we may fail to reacquire if the window has been recreated
+	hr = IDirectInputDevice_Acquire( g_pMouse );
+	if (FAILED(hr)) {
+		if ( !IN_InitDIMouse() ) {
+			Com_Printf ("Falling back to Win32 mouse support...\n");
+			Cvar_Set( "in_mouse", "-1" );
+		}
+	}
+}
+
+/*
+==========================
+IN_DeactivateDIMouse
+==========================
+*/
+void IN_DeactivateDIMouse( void ) {
+	if (!g_pMouse) {
+		return;
+	}
+	IDirectInputDevice_Unacquire( g_pMouse );
+}
+
+
+/*
+===================
+IN_DIMouse
+===================
+*/
+void IN_DIMouse( int *mx, int *my ) {
+	DIDEVICEOBJECTDATA	od;
+	DIMOUSESTATE		state;
+	DWORD				dwElements;
+	HRESULT				hr;
+	static float		oldSysTime;
+
+	if ( !g_pMouse ) {
+		return;
+	}
+
+	// fetch new events
+	for (;;)
+	{
+		dwElements = 1;
+
+		hr = IDirectInputDevice_GetDeviceData(g_pMouse,
+				sizeof(DIDEVICEOBJECTDATA), &od, &dwElements, 0);
+		if ((hr == DIERR_INPUTLOST) || (hr == DIERR_NOTACQUIRED)) {
+			IDirectInputDevice_Acquire(g_pMouse);
+			return;
+		}
+
+		/* Unable to read data or no data available */
+		if ( FAILED(hr) ) {
+			break;
+		}
+
+		if ( dwElements == 0 ) {
+			break;
+		}
+
+		switch (od.dwOfs) {
+		case DIMOFS_BUTTON0:
+			if (od.dwData & 0x80)
+				Sys_QueEvent( od.dwTimeStamp, SE_KEY, A_MOUSE1, qtrue, 0, NULL );
+			else
+				Sys_QueEvent( od.dwTimeStamp, SE_KEY, A_MOUSE1, qfalse, 0, NULL );
+			break;
+
+		case DIMOFS_BUTTON1:
+			if (od.dwData & 0x80)
+				Sys_QueEvent( od.dwTimeStamp, SE_KEY, A_MOUSE2, qtrue, 0, NULL );
+			else
+				Sys_QueEvent( od.dwTimeStamp, SE_KEY, A_MOUSE2, qfalse, 0, NULL );
+			break;
+			
+		case DIMOFS_BUTTON2:
+			if (od.dwData & 0x80)
+				Sys_QueEvent( od.dwTimeStamp, SE_KEY, A_MOUSE3, qtrue, 0, NULL );
+			else
+				Sys_QueEvent( od.dwTimeStamp, SE_KEY, A_MOUSE3, qfalse, 0, NULL );
+			break;
+
+		case DIMOFS_BUTTON3:
+			if (od.dwData & 0x80)
+				Sys_QueEvent( od.dwTimeStamp, SE_KEY, A_MOUSE4, qtrue, 0, NULL );
+			else
+				Sys_QueEvent( od.dwTimeStamp, SE_KEY, A_MOUSE4, qfalse, 0, NULL );
+			break;
+
+		// needs DIRECTINPUT_VERSION >= 0x0700 to compile, which we seem to have, so...
+		//
+		case DIMOFS_BUTTON4:
+			if (od.dwData & 0x80)
+				Sys_QueEvent( od.dwTimeStamp, SE_KEY, A_MOUSE5, qtrue, 0, NULL );
+			else
+				Sys_QueEvent( od.dwTimeStamp, SE_KEY, A_MOUSE5, qfalse, 0, NULL );
+			break;
+		}
+	}
+
+	// read the raw delta counter and ignore
+	// the individual sample time / values
+	hr = IDirectInputDevice_GetDeviceState(g_pMouse,
+			sizeof(DIDEVICEOBJECTDATA), &state);
+	if ( FAILED(hr) ) {
+		*mx = *my = 0;
+		return;
+	}
+	*mx = state.lX;
+	*my = state.lY;
+}
+
+/*
+============================================================
+
+  MOUSE CONTROL
+
+============================================================
+*/
+
+/*
+===========
+IN_ActivateMouse
+
+Called when the window gains focus or changes in some way
+===========
+*/
+void IN_ActivateMouse( void ) 
+{
+	if (!s_wmv.mouseInitialized ) {
+		return;
+	}
+	if ( !in_mouse->integer ) 
+	{
+		s_wmv.mouseActive = qfalse;
+		return;
+	}
+	if ( s_wmv.mouseActive ) 
+	{
+		return;
+	}
+
+	s_wmv.mouseActive = qtrue;
+
+	if ( in_mouse->integer != -1 ) {
+		IN_ActivateDIMouse();
+	}
+	IN_ActivateWin32Mouse();
+}
+
+
+/*
+===========
+IN_DeactivateMouse
+
+Called when the window loses focus
+===========
+*/
+void IN_DeactivateMouse( void ) {
+	if (!s_wmv.mouseInitialized ) {
+		return;
+	}
+	if (!s_wmv.mouseActive ) {
+		return;
+	}
+	s_wmv.mouseActive = qfalse;
+
+	IN_DeactivateDIMouse();
+	IN_DeactivateWin32Mouse();
+}
+
+
+
+/*
+===========
+IN_StartupMouse
+===========
+*/
+void IN_StartupMouse( void ) 
+{
+	s_wmv.mouseInitialized = qfalse;
+
+	if ( in_mouse->integer == 0 ) {
+		Com_Printf ("Mouse control not active.\n");
+		return;
+	}
+
+	// nt4.0 direct input is screwed up
+	if ( ( g_wv.osversion.dwPlatformId == VER_PLATFORM_WIN32_NT ) &&
+		 ( g_wv.osversion.dwMajorVersion == 4 ) )
+	{
+		Com_Printf ("Disallowing DirectInput on NT 4.0\n");
+		Cvar_Set( "in_mouse", "-1" );
+	}
+
+	s_wmv.mouseInitialized = qtrue;
+
+	if ( in_mouse->integer == -1 ) {
+		Com_Printf ("Skipping check for DirectInput\n");
+	} else {
+		if ( IN_InitDIMouse() ) {
+			return;
+		}
+		Com_Printf ("Falling back to Win32 mouse support...\n");
+	}
+	IN_InitWin32Mouse();
+}
+
+/*
+===========
+IN_MouseEvent
+===========
+*/
+#define MAX_MOUSE_BUTTONS	5
+
+static int mouseConvert[MAX_MOUSE_BUTTONS] =
+{
+	A_MOUSE1,
+	A_MOUSE2,
+	A_MOUSE3,
+	A_MOUSE4,
+	A_MOUSE5
+};
+
+void IN_MouseEvent (int mstate)
+{
+	int		i;
+
+	if ( !s_wmv.mouseInitialized )
+	{
+		return;
+	}
+
+	// perform button actions
+	for  (i = 0 ; i < MAX_MOUSE_BUTTONS ; i++ )
+	{
+		if ( (mstate & (1 << i)) && !(s_wmv.oldButtonState & (1 << i)) )
+		{
+			Sys_QueEvent( g_wv.sysMsgTime, SE_KEY, mouseConvert[i], true, 0, NULL );
+		}
+		if ( !(mstate & (1 << i)) && (s_wmv.oldButtonState & (1 << i)) )
+		{
+			Sys_QueEvent( g_wv.sysMsgTime, SE_KEY, mouseConvert[i], false, 0, NULL );
+		}
+	}	
+	s_wmv.oldButtonState = mstate;
+}
+
+
+/*
+===========
+IN_MouseMove
+===========
+*/
+void IN_MouseMove ( void ) {
+	int		mx, my;
+
+	if ( g_pMouse ) {
+		IN_DIMouse( &mx, &my );
+	} else {
+		IN_Win32Mouse( &mx, &my );
+	}
+
+	if ( !mx && !my ) {
+		return;
+	}
+
+	Sys_QueEvent( 0, SE_MOUSE, mx, my, 0, NULL );
+}
+
+
+/*
+=========================================================================
+
+=========================================================================
+*/
+
+/*
+===========
+IN_Startup
+===========
+*/
+void IN_Startup( void ) {
+	Com_Printf ("\n------- Input Initialization -------\n");
+	IN_StartupMouse ();
+	IN_StartupJoystick ();
+	IN_StartupMIDI();
+	Com_Printf ("------------------------------------\n");
+
+	in_mouse->modified = qfalse;
+	in_joystick->modified = qfalse;
+}
+
+/*
+===========
+IN_Shutdown
+===========
+*/
+void IN_Shutdown( void ) {
+	IN_DeactivateMouse();
+	IN_ShutdownDIMouse();
+	IN_ShutdownMIDI();
+	Cmd_RemoveCommand("midiinfo" );
+}
+
+
+/*
+===========
+IN_Init
+===========
+*/
+void IN_Init( void ) {
+	// MIDI input controler variables
+	in_midi					= Cvar_Get ("in_midi",					"0",		CVAR_ARCHIVE);
+	in_midiport				= Cvar_Get ("in_midiport",				"1",		CVAR_ARCHIVE);
+	in_midichannel			= Cvar_Get ("in_midichannel",			"1",		CVAR_ARCHIVE);
+	in_mididevice			= Cvar_Get ("in_mididevice",			"0",		CVAR_ARCHIVE);
+
+	Cmd_AddCommand( "midiinfo", MidiInfo_f );
+
+	// mouse variables
+    in_mouse				= Cvar_Get ("in_mouse",					"-1",		CVAR_ARCHIVE|CVAR_LATCH);
+
+	// joystick variables
+	in_joystick				= Cvar_Get ("in_joystick",				"0",		CVAR_ARCHIVE|CVAR_LATCH);
+	in_joyBallScale			= Cvar_Get ("in_joyBallScale",			"0.02",		CVAR_ARCHIVE);
+	in_debugJoystick		= Cvar_Get ("in_debugjoystick",			"0",		CVAR_TEMP);
+
+	joy_threshold			= Cvar_Get ("joy_threshold",			"0.15",		CVAR_ARCHIVE);
+
+	joy_xbutton				= Cvar_Get ("joy_xbutton",			"1",		CVAR_ARCHIVE);	// treat axis as a button
+	joy_ybutton				= Cvar_Get ("joy_ybutton",			"0",		CVAR_ARCHIVE);	// treat axis as a button
+
+	IN_Startup();
+}
+
+
+/*
+===========
+IN_Activate
+
+Called when the main window gains or loses focus.
+The window may have been destroyed and recreated
+between a deactivate and an activate.
+===========
+*/
+void IN_Activate (qboolean active) {
+	in_appactive = active;
+
+	if ( !active )
+	{
+		IN_DeactivateMouse();
+	}
+}
+
+extern cvar_t	*r_fullscreen;
+
+/*
+==================
+IN_Frame
+
+Called every frame, even if not generating commands
+==================
+*/
+void IN_Frame (void) {
+	// post joystick events
+	IN_JoyMove();
+
+	if ( !s_wmv.mouseInitialized ) {
+		return;
+	}
+
+	if ( cls.keyCatchers & KEYCATCH_CONSOLE ) {
+		// temporarily deactivate if not in the game and
+		// running on the desktop
+		if (r_fullscreen && r_fullscreen->value == 0 )	{
+			IN_DeactivateMouse ();
+			return;
+		}
+	}
+
+	if ( !in_appactive ) {
+		IN_DeactivateMouse ();
+		return;
+	}
+
+	IN_ActivateMouse();
+
+	// post events to the system que
+	IN_MouseMove();
+
+}
+
+
+/*
+===================
+IN_ClearStates
+===================
+*/
+void IN_ClearStates (void) 
+{
+	s_wmv.oldButtonState = 0;
+}
+
+
+/*
+=========================================================================
+
+JOYSTICK
+
+=========================================================================
+*/
+
+/* 
+=============== 
+IN_StartupJoystick 
+=============== 
+*/  
+void IN_StartupJoystick (void) { 
+	int			numdevs;
+	MMRESULT	mmr;
+
+	// assume no joystick
+	joy.avail = qfalse; 
+
+	if (! in_joystick->integer ) {
+		Com_Printf ("Joystick is not active.\n");
+		return;
+	}
+
+	// verify joystick driver is present
+	if ((numdevs = joyGetNumDevs ()) == 0)
+	{
+		Com_Printf ("joystick not found -- driver not present\n");
+		return;
+	}
+
+	// cycle through the joystick ids for the first valid one
+	mmr = 0;
+	for (joy.id=0 ; joy.id<numdevs ; joy.id++)
+	{
+		Com_Memset (&joy.ji, 0, sizeof(joy.ji));
+		joy.ji.dwSize = sizeof(joy.ji);
+		joy.ji.dwFlags = JOY_RETURNCENTERED;
+
+		if ((mmr = joyGetPosEx (joy.id, &joy.ji)) == JOYERR_NOERROR)
+			break;
+	} 
+
+	// abort startup if we didn't find a valid joystick
+	if (mmr != JOYERR_NOERROR)
+	{
+		Com_Printf ("joystick not found -- no valid joysticks (%x)\n", mmr);
+		return;
+	}
+
+	// get the capabilities of the selected joystick
+	// abort startup if command fails
+	Com_Memset (&joy.jc, 0, sizeof(joy.jc));
+	if ((mmr = joyGetDevCaps (joy.id, &joy.jc, sizeof(joy.jc))) != JOYERR_NOERROR)
+	{
+		Com_Printf ("joystick not found -- invalid joystick capabilities (%x)\n", mmr); 
+		return;
+	}
+
+	Com_Printf( "Joystick found.\n" );
+	Com_Printf( "Pname: %s\n", joy.jc.szPname );
+	Com_Printf( "OemVxD: %s\n", joy.jc.szOEMVxD );
+	Com_Printf( "RegKey: %s\n", joy.jc.szRegKey );
+
+	Com_Printf( "Numbuttons: %i / %i\n", joy.jc.wNumButtons, joy.jc.wMaxButtons );
+	Com_Printf( "Axis: %i / %i\n", joy.jc.wNumAxes, joy.jc.wMaxAxes );
+	Com_Printf( "Caps: 0x%x\n", joy.jc.wCaps );
+	if ( joy.jc.wCaps & JOYCAPS_HASPOV ) {
+		Com_Printf( "HASPOV\n" );
+	} else {
+		Com_Printf( "no POV\n" );
+	}
+
+	// old button and POV states default to no buttons pressed
+	joy.oldbuttonstate = 0;
+	joy.oldpovstate = 0;
+
+	// mark the joystick as available
+	joy.avail = qtrue; 
+}
+
+/*
+===========
+JoyToF
+===========
+*/
+float JoyToF( int value ) {
+	float	fValue;
+
+	// move centerpoint to zero
+	value -= 32768;
+
+	// convert range from -32768..32767 to -1..1 
+	fValue = (float)value / 32768.0;
+
+	if ( fValue < -1 ) {
+		fValue = -1;
+	}
+	if ( fValue > 1 ) {
+		fValue = 1;
+	}
+	return fValue;
+}
+
+int JoyToI( int value ) {
+	// move centerpoint to zero
+	value -= 32768;
+
+	return value;
+}
+
+int	joyDirectionKeys[16] = {
+	A_CURSOR_LEFT, A_CURSOR_RIGHT,
+	A_CURSOR_UP, A_CURSOR_DOWN,
+	A_JOY16, A_JOY17,
+	A_JOY18, A_JOY19,
+	A_JOY20, A_JOY21,
+	A_JOY22, A_JOY23,
+
+	A_JOY24, A_JOY25,
+	A_JOY26, A_JOY27
+};
+
+/*
+===========
+IN_JoyMove
+===========
+*/
+void IN_JoyMove( void ) {
+	float	fAxisValue;
+	int		i;
+	DWORD	buttonstate, povstate;
+	int		x, y;
+
+	// verify joystick is available and that the user wants to use it
+	if ( !joy.avail ) {
+		return; 
+	}
+
+	// collect the joystick data, if possible
+	memset (&joy.ji, 0, sizeof(joy.ji));
+	joy.ji.dwSize = sizeof(joy.ji);
+	joy.ji.dwFlags = JOY_RETURNALL;
+
+	if ( joyGetPosEx (joy.id, &joy.ji) != JOYERR_NOERROR ) {
+		// read error occurred
+		// turning off the joystick seems too harsh for 1 read error,\
+		// but what should be done?
+		// Com_Printf ("IN_ReadJoystick: no response\n");
+		// joy.avail = false;
+		return;
+	}
+
+	if ( in_debugJoystick->integer ) {
+		Com_Printf( "%8x %5i %5.2f %5.2f %5.2f %5.2f %6i %6i\n", 
+			joy.ji.dwButtons,
+			joy.ji.dwPOV,
+			JoyToF( joy.ji.dwXpos ), JoyToF( joy.ji.dwYpos ),
+			JoyToF( joy.ji.dwZpos ), JoyToF( joy.ji.dwRpos ),
+			JoyToI( joy.ji.dwUpos ), JoyToI( joy.ji.dwVpos ) );
+	}
+
+	// loop through the joystick buttons
+	// key a joystick event or auxillary event for higher number buttons for each state change
+	buttonstate = joy.ji.dwButtons;
+	for ( i=0 ; i < joy.jc.wNumButtons ; i++ ) {
+		if ( (buttonstate & (1<<i)) && !(joy.oldbuttonstate & (1<<i)) ) {
+			Sys_QueEvent( g_wv.sysMsgTime, SE_KEY, A_JOY0 + i, qtrue, 0, NULL );
+		}
+		if ( !(buttonstate & (1<<i)) && (joy.oldbuttonstate & (1<<i)) ) {
+			Sys_QueEvent( g_wv.sysMsgTime, SE_KEY, A_JOY0 + i, qfalse, 0, NULL );
+		}
+	}
+	joy.oldbuttonstate = buttonstate;
+
+	povstate = 0;
+
+	// convert main joystick motion into 6 direction button bits
+	for (i = 0; i < joy.jc.wNumAxes && i < 4 ; i++) {
+		// get the floating point zero-centered, potentially-inverted data for the current axis
+		fAxisValue = JoyToF( (&joy.ji.dwXpos)[i] );
+		
+		if (i == 0 && !joy_xbutton->integer) {
+			if ( fAxisValue < -joy_threshold->value || fAxisValue > joy_threshold->value){
+				Sys_QueEvent( g_wv.sysMsgTime, SE_JOYSTICK_AXIS, AXIS_SIDE, (int) -(fAxisValue*127.0), 0, NULL );
+			}else{
+				Sys_QueEvent( g_wv.sysMsgTime, SE_JOYSTICK_AXIS, AXIS_SIDE, 0, 0, NULL );
+			}
+			continue;
+		}
+		
+		if (i == 1 && !joy_ybutton->integer) {
+			if ( fAxisValue < -joy_threshold->value || fAxisValue > joy_threshold->value){
+				Sys_QueEvent( g_wv.sysMsgTime, SE_JOYSTICK_AXIS, AXIS_FORWARD, (int) -(fAxisValue*127.0), 0, NULL );
+			}else{
+				Sys_QueEvent( g_wv.sysMsgTime, SE_JOYSTICK_AXIS, AXIS_FORWARD, 0, 0, NULL );
+			}
+			continue;
+		}
+		
+		if ( fAxisValue < -joy_threshold->value ) {
+			povstate |= (1<<(i*2));
+		} else if ( fAxisValue > joy_threshold->value ) {
+			povstate |= (1<<(i*2+1));
+		}
+	}		
+
+	// convert POV information from a direction into 4 button bits
+	if ( joy.jc.wCaps & JOYCAPS_HASPOV ) {
+		if ( joy.ji.dwPOV != JOY_POVCENTERED ) {
+			if (joy.ji.dwPOV == JOY_POVFORWARD)
+				povstate |= 1<<12;
+			if (joy.ji.dwPOV == JOY_POVBACKWARD)
+				povstate |= 1<<13;
+			if (joy.ji.dwPOV == JOY_POVRIGHT)
+				povstate |= 1<<14;
+			if (joy.ji.dwPOV == JOY_POVLEFT)
+				povstate |= 1<<15;
+		}
+	}
+
+	// determine which bits have changed and key an auxillary event for each change
+	for (i=0 ; i < 16 ; i++) {
+		if ( (povstate & (1<<i)) && !(joy.oldpovstate & (1<<i)) ) {
+			Sys_QueEvent( g_wv.sysMsgTime, SE_KEY, joyDirectionKeys[i], qtrue, 0, NULL );
+		}
+
+		if ( !(povstate & (1<<i)) && (joy.oldpovstate & (1<<i)) ) {
+			Sys_QueEvent( g_wv.sysMsgTime, SE_KEY, joyDirectionKeys[i], qfalse, 0, NULL );
+		}
+	}
+	joy.oldpovstate = povstate;
+
+	// if there is a trackball like interface, simulate mouse moves
+	if ( joy.jc.wNumAxes >= 6 ) {
+		x = JoyToI( joy.ji.dwUpos ) * in_joyBallScale->value;
+		y = JoyToI( joy.ji.dwVpos ) * in_joyBallScale->value;
+		if ( x || y ) {
+			Sys_QueEvent( g_wv.sysMsgTime, SE_MOUSE, x, y, 0, NULL );
+		}
+	}
+}
+
+/*
+=========================================================================
+
+MIDI
+
+=========================================================================
+*/
+
+static void MIDI_NoteOff( int note )
+{
+	int qkey;
+
+	qkey = note - 60 + A_AUX0;
+
+	if ( qkey < A_AUX0 )
+	{
+		return;
+	}
+	Sys_QueEvent( g_wv.sysMsgTime, SE_KEY, qkey, qfalse, 0, NULL );
+}
+
+static void MIDI_NoteOn( int note, int velocity )
+{
+	int qkey;
+
+	if ( velocity == 0 )
+	{
+		MIDI_NoteOff( note );
+	}
+
+	qkey = note - 60 + A_AUX0;
+
+	if ( qkey < A_AUX0 )
+	{
+		return;
+	}
+	Sys_QueEvent( g_wv.sysMsgTime, SE_KEY, qkey, qtrue, 0, NULL );
+}
+
+static void CALLBACK MidiInProc( HMIDIIN hMidiIn, UINT uMsg, DWORD dwInstance, 
+								 DWORD dwParam1, DWORD dwParam2 )
+{
+	int message;
+
+	switch ( uMsg )
+	{
+	case MIM_OPEN:
+		break;
+	case MIM_CLOSE:
+		break;
+	case MIM_DATA:
+		message = dwParam1 & 0xff;
+
+		// note on
+		if ( ( message & 0xf0 ) == 0x90 )
+		{
+			if ( ( ( message & 0x0f ) + 1 ) == in_midichannel->integer )
+				MIDI_NoteOn( ( dwParam1 & 0xff00 ) >> 8, ( dwParam1 & 0xff0000 ) >> 16 );
+		}
+		else if ( ( message & 0xf0 ) == 0x80 )
+		{
+			if ( ( ( message & 0x0f ) + 1 ) == in_midichannel->integer )
+				MIDI_NoteOff( ( dwParam1 & 0xff00 ) >> 8 );
+		}
+		break;
+	case MIM_LONGDATA:
+		break;
+	case MIM_ERROR:
+		break;
+	case MIM_LONGERROR:
+		break;
+	}
+
+//	Sys_QueEvent( sys_msg_time, SE_KEY, wMsg, qtrue, 0, NULL );
+}
+
+static void MidiInfo_f( void )
+{
+	int i;
+
+	const char *enableStrings[] = { "disabled", "enabled" };
+
+	Com_Printf( "\nMIDI control:       %s\n", enableStrings[in_midi->integer != 0] );
+	Com_Printf( "port:               %d\n", in_midiport->integer );
+	Com_Printf( "channel:            %d\n", in_midichannel->integer );
+	Com_Printf( "current device:     %d\n", in_mididevice->integer );
+	Com_Printf( "number of devices:  %d\n", s_midiInfo.numDevices );
+	for ( i = 0; i < s_midiInfo.numDevices; i++ )
+	{
+		if ( i == Cvar_VariableValue( "in_mididevice" ) )
+			Com_Printf( "***" );
+		else
+			Com_Printf( "..." );
+		Com_Printf(    "device %2d:       %s\n", i, s_midiInfo.caps[i].szPname );
+		Com_Printf( "...manufacturer ID: 0x%hx\n", s_midiInfo.caps[i].wMid );
+		Com_Printf( "...product ID:      0x%hx\n", s_midiInfo.caps[i].wPid );
+
+		Com_Printf( "\n" );
+	}
+}
+
+static void IN_StartupMIDI( void )
+{
+	int i;
+
+	if ( !Cvar_VariableValue( "in_midi" ) )
+		return;
+
+	//
+	// enumerate MIDI IN devices
+	//
+	s_midiInfo.numDevices = midiInGetNumDevs();
+
+	for ( i = 0; i < s_midiInfo.numDevices; i++ )
+	{
+		midiInGetDevCaps( i, &s_midiInfo.caps[i], sizeof( s_midiInfo.caps[i] ) );
+	}
+
+	//
+	// open the MIDI IN port
+	//
+	if ( midiInOpen( &s_midiInfo.hMidiIn, 
+		             in_mididevice->integer,
+					 ( unsigned long ) MidiInProc,
+					 ( unsigned long ) NULL,
+					 CALLBACK_FUNCTION ) != MMSYSERR_NOERROR )
+	{
+		Com_Printf( "WARNING: could not open MIDI device %d: '%s'\n", in_mididevice->integer , s_midiInfo.caps[( int ) in_mididevice->value] );
+		return;
+	}
+
+	midiInStart( s_midiInfo.hMidiIn );
+}
+
+static void IN_ShutdownMIDI( void )
+{
+	if ( s_midiInfo.hMidiIn )
+	{
+		midiInClose( s_midiInfo.hMidiIn );
+	}
+	Com_Memset( &s_midiInfo, 0, sizeof( s_midiInfo ) );
+}
+
diff --git a/codemp/win32/win_input.h b/codemp/win32/win_input.h
new file mode 100644
index 0000000..56d47cc
--- /dev/null
+++ b/codemp/win32/win_input.h
@@ -0,0 +1,101 @@
+#ifndef _WIN_INPUT_H_
+#define _WIN_INPUT_H_
+
+bool IN_ControllersChanged(int inserted[], int removed[]);
+
+#if defined (_XBOX ) || defined (_GAMECUBE)
+#define _USE_RUMBLE
+#endif
+
+bool	IN_AnyButtonPressed(void);
+
+void	IN_enableRumble( void );
+void	IN_disableRumble( void );
+bool	IN_usingRumble( void );
+
+int		IN_CreateRumbleScript(int controller, int numStates, bool deleteWhenFinished);
+void	IN_DeleteRumbleScript(int whichScript);
+void	IN_KillRumbleScript(int whichScript);
+void	IN_ExecuteRumbleScript(int whichScript);
+
+bool	IN_AdvanceToNextState(int whichScript);
+
+void	IN_KillRumbleScripts(int controller);
+void	IN_KillRumbleScripts( void );
+
+#define IN_CMD_GOTO_XTIMES	-5
+#define IN_CMD_GOTO			-6
+
+#define IN_CMD_DEC_ARG2		-7
+#define IN_CMD_INC_ARG2		-8
+#define IN_CMD_DEC_ARG1		-9
+#define IN_CMD_INC_ARG1		-10
+
+#ifdef _XBOX
+	#define IN_CMD_DEC_LEFT		-70
+	#define IN_CMD_DEC_RIGHT	-71
+	#define IN_CMD_INC_LEFT		-72
+	#define IN_CMD_INC_RIGHT	-73
+#endif
+
+
+#if defined (_XBOX)			// ----- XBOX --------
+
+int IN_AddRumbleState(int whichScript, int leftSpeed, int rightSpeed, int timeInMs);
+int IN_AddEffectFade4(int whichScript, int startLeft, int startRight, int endLeft, int endRight, int timeInMs);
+int IN_AddEffectFadeExp6(int whichScript, int startLeft, int startRight, int endLeft, int endRight, char factor, int timeInMs);
+
+#elif defined (_GAMECUBE)	// ---- GAME CUBE ----
+
+#define IN_GCACTION_START		1
+#define IN_GCACTION_STOP		2
+#define IN_GCACTION_STOPHARD	3
+int IN_AddRumbleState(int whichScript, int action, int timeInMs, int arg = 0);
+
+#endif						// ------END IF-------
+
+int		IN_AddRumbleStateSpecial(int whichScript, int action, int arg1, int arg2);
+void	IN_KillRumbleState(int whichScript, int index);
+
+void	IN_PauseRumbling(int controller);
+void	IN_PauseRumbling( void );
+
+void	IN_UnPauseRumbling(int controller);
+void	IN_UnPauseRumbling( void );
+
+void	IN_TogglePauseRumbling(int controller);
+void	IN_TogglePauseRumbling( void );
+int		IN_GetMainController();
+void	IN_SetMainController(int id);
+
+void	IN_PadUnplugged(int controller);
+void	IN_PadPlugged(int controller);
+
+void	IN_CommonJoyPress(int controller, fakeAscii_t button, bool pressed);
+void	IN_CommonUpdate(void);
+
+#define IN_MAX_JOYSTICKS 2
+// Stores gamepad joystick info
+struct JoystickInfo
+{
+	bool valid;
+	float x, y;
+};
+
+// Stores gamepad id and joysick info
+struct PadInfo
+{
+	JoystickInfo joyInfo[2];
+	int padId;
+};
+
+// Buffer for gamepad info
+extern PadInfo _padInfo;
+
+bool IN_RumbleAdjust(int controller, int left, int right);
+void IN_RumbleInit (void);
+void IN_RumbleShutdown (void);
+void IN_RumbleFrame (void);
+
+
+#endif // END _WIN_INPUT_H_
diff --git a/codemp/win32/win_input_console.cpp b/codemp/win32/win_input_console.cpp
new file mode 100644
index 0000000..a08543e
--- /dev/null
+++ b/codemp/win32/win_input_console.cpp
@@ -0,0 +1,648 @@
+// #include "../server/exe_headers.h"
+
+#include "../client/client.h"
+#include "../qcommon/qcommon.h"
+#ifdef _JK2MP
+#include "../ui/keycodes.h"
+#else
+#include "../client/keycodes.h"
+#endif
+
+#include "win_local.h"
+#include "win_input.h"
+
+
+static void HandleDebugJoystickPress(fakeAscii_t button);
+
+static bool _UIRunning = false;
+
+static bool IN_ControllerMustBePlugged(int controller);
+
+#ifdef _DEBUG
+bool cheatPadEnabled = 1;
+#else
+bool cheatPadEnabled = 1;
+#endif
+
+// Controller connection globals
+static signed char uiControllerNotification = -1;
+bool noControllersConnected = false;
+bool wasPlugged[4];
+
+PadInfo _padInfo; // gamepad thumbstick buffer
+
+
+
+//If the Xbox white or black button was held for less than this amount of
+//time while a selection bar was up, the user wants to use the button rather
+//than reassign it.
+#define MAX_WB_HOLD_TIME 500
+
+static fakeAscii_t UIJoy2Key(fakeAscii_t button)
+{
+	switch(button) {
+	case A_JOY7:
+		return A_CURSOR_DOWN;
+	case A_JOY5:
+		return A_CURSOR_UP;
+	case A_JOY6:
+		return A_CURSOR_RIGHT;
+	case A_JOY8:
+		return A_CURSOR_LEFT;
+	case A_JOY15:
+		return A_MOUSE1;
+#ifdef _GAMECUBE
+	case A_JOY16:
+		return A_ESCAPE;
+	case A_JOY14:
+		return A_DELETE;
+#else
+	case A_JOY14:
+		return A_ESCAPE;
+	case A_JOY16:
+		return A_DELETE;
+	// Arbitrary choice for X button - need it for passcodes.
+	case A_JOY13:
+		return A_BACKSPACE;
+#endif
+
+	//left and right trigger for scrolling
+	case A_JOY11:
+		return A_PAGE_UP;
+	case A_JOY12:
+		return A_PAGE_DOWN;
+
+	// start and back button on xbox
+	case A_JOY1:
+		//JLF MPMOVED
+		return A_ESCAPE;
+	case A_JOY2:
+	case A_JOY4:
+		//JLF MPMOVED
+		return A_MOUSE1;
+		//return button;
+
+	case A_JOY3:
+		return A_MOUSE1;
+	}
+
+	return A_SPACE; //Invalid button.
+}
+
+struct
+{
+	int button;
+	bool pressed;
+}	uiKeyQueue[2][5] = {0};
+int	uiQueueLen[2] = {0};
+int uiLastKeyUpDown[2] = {0};
+int uiLastKeyLeftRight[2] = {0};
+
+void IN_UIEmptyQueue()
+{
+	/// If the ui is not running then this doesn't have any effect
+	if (!_UIRunning)
+	{
+		uiQueueLen[0] = uiQueueLen[1] = 0;
+		return;
+	}
+
+// BTO - No CM, bypass that logic.
+//	for (int i = 0; i < ClientManager::NumClients(); i++)
+	for (int i = 0; i < 1; ++i)
+	{
+//		ClientManager::ActivateClient(i);
+		int found = 0;
+		int bCancel = 0;
+		for (int j = 0; j < uiQueueLen[i]; j++)
+		{
+			switch (uiKeyQueue[i][j].button)
+			{
+			case A_CURSOR_DOWN:
+			case A_CURSOR_UP:
+				if ( found & 2 )	// Was a left/right key pressed already?
+					bCancel = 1;
+				found |= 1;
+				break;
+			case A_CURSOR_RIGHT:
+			case A_CURSOR_LEFT:
+				if ( found & 1 )	// Was an up/down key already pressed?
+					bCancel = 1;
+				found |= 2;
+				break;
+			}
+		}
+
+		if (!bCancel)				// was it cancelled?
+		{
+			for (int j = 0; j < uiQueueLen[i]; j++)
+			{
+				int time = Sys_Milliseconds();
+				switch (uiKeyQueue[i][j].button)
+				{
+				case A_CURSOR_DOWN:
+				case A_CURSOR_UP:
+					if (uiLastKeyLeftRight[i])
+					{
+						if (uiLastKeyLeftRight[i] > time)		// don't allow up/down till left/right has enough leway time
+						{
+							continue;
+						}
+					}
+					uiLastKeyUpDown[i] = time + 150;			/// 250 ms sound right?
+					break;
+				case A_CURSOR_LEFT:
+				case A_CURSOR_RIGHT:
+					if (uiLastKeyUpDown[i])
+					{
+						if (uiLastKeyUpDown[i] > time)		// don't allow up/down till left/right has enough leway time
+						{
+							continue;
+						}
+					}
+					uiLastKeyLeftRight[i] = time + 150;			/// 250 ms sound right?
+					break;
+				}
+				Sys_QueEvent(0, SE_KEY, uiKeyQueue[i][j].button, uiKeyQueue[i][j].pressed, 0, NULL);
+			}
+		}
+	}
+
+	// Reset the queue
+	uiQueueLen[0] = uiQueueLen[1] = 0;
+}
+
+// extern void G_DemoKeypress();
+// extern void CG_SkipCredits(void);
+void IN_CommonJoyPress(int controller, fakeAscii_t button, bool pressed)
+{
+	// Check for special cases for map hack
+#ifndef FINAL_BUILD
+	if (Cvar_VariableIntegerValue("cl_maphack"))
+	{
+		if (_UIRunning && button == A_JOY11 && pressed)
+		{
+			// Left trigger -> F1
+			Sys_QueEvent( 0, SE_KEY, A_F1, pressed, 0, NULL );
+			return;
+		}
+		else if (_UIRunning && button == A_JOY12 && pressed)
+		{
+			// Right trigger -> F2
+			Sys_QueEvent( 0, SE_KEY, A_F2, pressed, 0, NULL );
+			return;
+		}
+		else if (_UIRunning && button == A_JOY4 && pressed)
+		{
+			// Start button -> F3
+			IN_SetMainController(controller);
+			Sys_QueEvent( 0, SE_KEY, A_F3, pressed, 0, NULL );
+			return;
+		}
+	}
+#endif
+
+
+	if(IN_GetMainController() == controller || _UIRunning)
+	{
+		// Always map start button to ESCAPE
+		if (!_UIRunning && button == A_JOY4 && cls.state != CA_CINEMATIC)
+			Sys_QueEvent( 0, SE_KEY, A_ESCAPE, pressed, 0, NULL );
+
+#ifndef FINAL_BUILD
+		if (controller != 3 || !cheatPadEnabled)
+#endif
+			Sys_QueEvent( 0, SE_KEY, _UIRunning ? UIJoy2Key(button) : button, pressed, 0, NULL );
+	}
+
+/*
+	if (pressed)
+	{
+		G_DemoKeypress();
+	}
+
+	//Hacky!  Skip the credits if start is pressed.
+	if(button == K_JOY4 && pressed) {
+		CG_SkipCredits();
+	}
+*/
+
+#ifndef FINAL_BUILD
+	if (controller == 3 && pressed && cheatPadEnabled) {
+		HandleDebugJoystickPress(button);
+		return;
+	}
+#endif
+
+/*
+	extern int player1ControllerId;
+	extern int player2ControllerId;
+	extern bool checkForPlayerControllers;
+	extern bool controllerUnplugged;
+
+
+	// If the game isn't started yet
+	if ((ClientManager::Shared().cls.cgameStarted == qfalse) &&
+		(!controllerUnplugged))
+	{
+		// and player1 doesnt have a controllerid, then assign client 1 to this controller
+		if (player1ControllerId == -1)
+		{
+			ClientManager::ActivateClient(0);
+			if (ClientManager::ActiveController() != controller)
+				ClientManager::SetActiveController(controller);
+		}
+		// player1 has a controller that is different then input recieved, and player2 doesnt have a controller and there are 2 clients
+		else if (player1ControllerId != controller && player2ControllerId == -1 && ClientManager::NumClients() > 1)
+		{
+			ClientManager::ActivateClient(1);
+			if (ClientManager::ActiveController() != controller)
+				ClientManager::SetActiveController(controller);			
+		}
+	}
+
+	if (ClientManager::ActivateByControllerId(controller))
+	{
+
+	#ifdef _XBOX
+		//Check the status of the white or black buttons.
+		if (button == K_JOY9) {
+			ClientManager::ActiveClient().whiteButtonDown = pressed;
+		} else if(button == K_JOY10) {
+			ClientManager::ActiveClient().blackButtonDown = pressed;
+		}
+
+		//Ignore white/black button presses if inv/force/weap select is up. 
+		//This is ugly.  It basically says return if the UI isn't running, if 
+		//we got a white or black button, and if the inv/force/weapon select is 
+		//running. 
+		if(!_UIRunning && 
+			(button == K_JOY9 ||  
+			button == K_JOY10) && 
+			(ClientManager::ActiveClient().cg.inventorySelectTime +  
+			WEAPON_SELECT_TIME > ClientManager::ActiveClient().cg.time || 
+			ClientManager::ActiveClient().cg.forcepowerSelectTime +  
+			WEAPON_SELECT_TIME > ClientManager::ActiveClient().cg.time || 
+			ClientManager::ActiveClient().cg.weaponSelectTime +  
+			WEAPON_SELECT_TIME > ClientManager::ActiveClient().cg.time)) { 
+
+			if(!pressed) {
+				//And it just gets hackier!  Is that a word?  It is now!
+				//If we've released the button and it wasn't down too long...
+				if((button == K_JOY9 && 
+						ClientManager::ActiveClient().whiteButtonHoldTime < 
+						MAX_WB_HOLD_TIME) ||
+					(button == K_JOY10 &&
+						ClientManager::ActiveClient().whiteButtonHoldTime < 
+						MAX_WB_HOLD_TIME)) {
+					//If we've already let the button press through previously,
+					//just send a release message.  Otherwise send both a press
+					//and release.
+					if(ClientManager::ActiveClient().keys[button].down) {
+						Sys_QueEvent( 0, SE_KEY, button, false, 0, NULL );
+					} else {
+						Sys_QueEvent( 0, SE_KEY, button, true, 0, NULL );
+						Sys_QueEvent( 0, SE_KEY, button, false, 0, NULL );
+					}
+				}
+			}
+			return; 
+		} 
+	#endif
+
+		if (!_UIRunning)
+		{
+			Sys_QueEvent( 0, SE_KEY, button, pressed, 0, NULL );
+		}
+		else
+		{
+//			int clientNum = ClientManager::ActiveClientNum();
+			int clientNum = 0; // VVFIXME
+			int qL = uiQueueLen[clientNum];
+			if(qL < 5) {
+				uiKeyQueue[clientNum][qL].button = UIJoy2Key(button);
+				uiKeyQueue[clientNum][qL].pressed = pressed;
+				uiQueueLen[clientNum]++;
+			}
+			//Sys_QueEvent(0, SE_KEY, UIJoy2Key(button), pressed, 0, NULL);
+		}
+*/
+/*
+	}
+*/
+
+}
+
+qboolean g_noCheckAxis = qfalse;
+
+/**********
+IN_CommonUpdate
+Updates thumbstick events based on _padInfo and ui_thumbStickMode
+**********/
+void IN_CommonUpdate()
+{
+	extern int Key_GetCatcher( void );
+	_UIRunning = Key_GetCatcher() == KEYCATCH_UI;
+
+	// if the UI is running, then let all gamepad sticks work, else only main controller
+	if(_UIRunning)
+		Sys_QueEvent( 0, SE_MOUSE, _padInfo.joyInfo[1].x *  4.0f, _padInfo.joyInfo[1].y *  -4.0f, 0, NULL );
+	else if(_padInfo.padId == IN_GetMainController())
+	{
+		// Find out how to configure the thumbsticks
+		int thumbStickMode = Cvar_Get("ui_thumbStickMode", "0" , 0)->integer;
+
+		switch(thumbStickMode)
+		{
+		case 0:
+			// Configure left thumbstick to move forward/back & strafe left/right
+			Sys_QueEvent( 0, SE_JOYSTICK_AXIS, AXIS_SIDE,	 _padInfo.joyInfo[0].x * 127.0f, 0, NULL );
+			Sys_QueEvent( 0, SE_JOYSTICK_AXIS, AXIS_FORWARD, _padInfo.joyInfo[0].y * 127.0f, 0, NULL );
+
+			// Configure right thumbstick for freelook
+			Sys_QueEvent( 0, SE_MOUSE, _padInfo.joyInfo[1].x * 48.0f,  _padInfo.joyInfo[1].y * 48.0f, 0, NULL );
+			break;
+		case 1:
+			// Configure left thumbstick for freelook
+			Sys_QueEvent( 0, SE_MOUSE, _padInfo.joyInfo[0].x * 48.0f,  _padInfo.joyInfo[0].y * 48.0f, 0, NULL );
+
+			// Configure right thumbstick to move forward/back & strafe left/right
+			Sys_QueEvent( 0, SE_JOYSTICK_AXIS, AXIS_SIDE,	 _padInfo.joyInfo[1].x * 127.0f, 0, NULL );
+			Sys_QueEvent( 0, SE_JOYSTICK_AXIS, AXIS_FORWARD, _padInfo.joyInfo[1].y * 127.0f, 0, NULL );
+			break;
+		case 2:
+			// Configure left thumbstick to move forward/back & turn left/right
+			Sys_QueEvent( 0, SE_JOYSTICK_AXIS, AXIS_FORWARD, _padInfo.joyInfo[0].y * 127.0f, 0, NULL );
+			Sys_QueEvent( 0, SE_MOUSE, _padInfo.joyInfo[0].x * 48.0f, 0.0f, 0, NULL );
+
+			// Configure right thumbstick to look up/down & strafe left/right
+			Sys_QueEvent( 0, SE_JOYSTICK_AXIS, AXIS_SIDE, _padInfo.joyInfo[1].x * 127.f, 0, NULL );
+			Sys_QueEvent( 0, SE_MOUSE, 0.0f,  _padInfo.joyInfo[1].y * 48.0f, 0, NULL );		
+			break;
+		case 3:
+			// Configure left thumbstick to look up/down & strafe left/right
+			Sys_QueEvent( 0, SE_JOYSTICK_AXIS, AXIS_SIDE, _padInfo.joyInfo[0].x * 127.f, 0, NULL );
+			Sys_QueEvent( 0, SE_MOUSE, 0.0f,  _padInfo.joyInfo[0].y * 48.0f, 0, NULL );
+			
+			// Configure right thumbstick to move forward/back & turn left/right
+			Sys_QueEvent( 0, SE_JOYSTICK_AXIS, AXIS_FORWARD, _padInfo.joyInfo[1].y * 127.0f, 0, NULL );
+			Sys_QueEvent( 0, SE_MOUSE, _padInfo.joyInfo[1].x * 48.0f, 0.0f, 0, NULL );		
+			break;
+		default:
+			break;
+		}
+	}
+}
+
+/*********
+IN_DisplayControllerUnplugged
+*********/
+static void IN_DisplayControllerUnplugged(int controller)
+{
+	uiControllerNotification = controller;
+
+	//TODO Add a call to the UI that draws a controller disconnected message
+	// on the screen.
+//	VM_Call( uivm, UI_CONTROLLER_UNPLUGGED, true, controller);
+}
+
+/*********
+IN_ClearControllerUnplugged
+*********/
+static void IN_ClearControllerUnplugged(void)
+{
+	uiControllerNotification = -1;
+
+	//TODO Add a call to the UI that removes the controller disconnected
+	// message from the screen.
+//	VM_Call( uivm, UI_CONTROLLER_UNPLUGGED, false, 0);
+}
+
+/*********
+IN_ControllerMustBePlugged
+*********/
+static bool IN_ControllerMustBePlugged(int controller)
+{
+	if( cls.state == CA_LOADING		||
+		cls.state == CA_CONNECTING	||
+		cls.state == CA_CONNECTED	||
+		cls.state == CA_CHALLENGING	||
+		cls.state == CA_PRIMED		||
+		cls.state == CA_CINEMATIC)
+	{
+		return false;
+	}
+
+	if(!_UIRunning && controller == IN_GetMainController())
+	{
+		return true;
+	}
+
+	if(noControllersConnected)
+	{
+		return true;
+	}
+
+	return false;
+}
+
+/*********
+IN_PadUnplugged
+*********/
+void IN_PadUnplugged(int controller)
+{
+	if(wasPlugged[controller])
+	{
+		Com_Printf("\tController %d unplugged\n",controller); 
+	}
+
+	if(IN_ControllerMustBePlugged(controller))
+	{
+		//If UI isn't busy, inform it about controller loss.
+		if(uiControllerNotification == -1)
+		{
+			IN_DisplayControllerUnplugged(controller);
+		}
+	}
+	wasPlugged[controller] = false;
+}
+
+/*********
+IN_PadPlugged
+*********/
+void IN_PadPlugged(int controller)
+{
+	if(!wasPlugged[controller])
+	{
+		Com_Printf("\tController %d plugged\n",controller); 
+	}
+
+	if(IN_ControllerMustBePlugged(controller))
+	{
+		//If UI is dealing with this controller, tell it to stop.
+		if(uiControllerNotification == controller)
+		{
+			IN_ClearControllerUnplugged();
+		}
+	}
+	wasPlugged[controller] = true;
+	noControllersConnected = false;
+}
+
+/*********
+IN_GetMainController
+*********/
+int IN_GetMainController(void)
+{
+	return cls.mainGamepad;
+}
+
+/*********
+IN_SetMainController
+*********/
+void IN_SetMainController(int id)
+{
+	cls.mainGamepad = id;
+}
+
+/*********
+IN_SetThumbStickConfig
+Sets the thumbstick configuration value
+*********/
+void IN_SetThumbStickConfig(int configValue)
+{
+	Cvar_Set("ui_thumbStickMode", va("%i", configValue));
+}
+
+/*********
+IN_SetButtonConfig
+Execs a button configuration script based on configValue
+*********/
+void IN_SetButtonConfig(int configValue)
+{
+	// Set the cvar
+	Cvar_Set("ui_buttonMode", va("%i", configValue));
+
+	// Exec the script
+	char				execString[40];
+	sprintf				(execString, "exec cfg\\buttonConfig%i.cfg\n", configValue);
+	Cbuf_ExecuteText	(EXEC_NOW, execString);
+}
+
+/*********
+IN_SetDpadConfig
+Execs a dpad configuration script based on configValue
+*********/
+void IN_SetDpadConfig(int configValue)
+{
+	// Set the cvar
+	Cvar_Set("ui_dpadMode", va("%i", configValue));
+
+	// Exec the script
+	char				execString[40];
+	sprintf				(execString, "exec cfg\\dpadConfig%i.cfg\n", configValue);
+	Cbuf_ExecuteText	(EXEC_NOW, execString);
+}
+
+/**********************************************************
+*
+* DEBUGGING CODE
+*
+**********************************************************/
+bool debugSoundOff;
+
+#ifndef FINAL_BUILD
+static void HandleDebugJoystickPress(fakeAscii_t button)
+{
+	// Super hackalicious crap used below. Please remove this at some point.
+	static int curSaberSet = 0;
+	static int curPlayerSet = 0;
+	static short dpadmode = 0;
+	static short buttonmode = 0;
+	static short thumbmode = 0;
+
+	switch(button) {
+	case A_JOY13: // Right pad up
+		Cbuf_ExecuteText(EXEC_APPEND, "give all\n");
+		break;
+	case A_JOY16: // Right pad left
+		Cbuf_ExecuteText(EXEC_APPEND, "viewpos\n");
+		break;
+	case A_JOY14: // Right pad right
+		Cbuf_ExecuteText(EXEC_APPEND, "noclip\n");
+		break;
+	case A_JOY15: // Right pad down
+		Cbuf_ExecuteText(EXEC_APPEND, "god\n");
+		break;
+	case A_JOY4: // Start
+		Cvar_SetValue("m_pitch", -Cvar_VariableValue("m_pitch"));
+		break;
+	case A_JOY1: // back
+		Cvar_SetValue("cl_autolevel", !Cvar_VariableIntegerValue("cl_autolevel"));
+		break;
+	case A_JOY2: // Left thumbstick
+		extern void Z_CompactStats(void);
+		Z_CompactStats();
+		break;
+	case A_JOY12: // Upper right trigger
+		Cbuf_ExecuteText(EXEC_APPEND, "load current\n");
+		break;
+	case A_JOY8: // Left pad left
+		thumbmode++;
+		if(thumbmode == 4)
+		{
+			thumbmode = 0;
+		}
+		IN_SetThumbStickConfig(thumbmode);
+		break;
+	case A_JOY6: // Left pad right
+		dpadmode++;
+		if(dpadmode == 4)
+		{
+			dpadmode = 0;
+		}
+		IN_SetDpadConfig(0);
+		break;
+	case A_JOY5: // Left pad up
+		buttonmode++;
+		if(buttonmode == 4)
+		{
+			buttonmode = 0;
+		}
+		IN_SetButtonConfig(buttonmode);
+		break;
+	case A_JOY7: // Left pad down
+		Cbuf_ExecuteText(EXEC_APPEND, "vid_restart\n");
+		break;
+	case A_JOY11: // Upper left trigger
+		// VVFIXME : This is totally bootleg. The above loads current, because the
+		// current SG system writes out to "current" and then uses FS to move the file
+		// to the name that we specify. Which we don't support. But we can't write to
+		// "current" as the SG system doesn't allow it. So we write to some arbitary
+		// name, and our game ends up in current.
+		Cbuf_ExecuteText(EXEC_APPEND, "save foo\n");
+#if 0	// VVFIXME
+		extern cvar_t *cl_safezonemask;
+		if(cl_safezonemask) {
+			if(cl_safezonemask->integer) {
+				Cbuf_ExecuteText(EXEC_APPEND, "safezonemask 0\n");
+			} else {
+				Cbuf_ExecuteText(EXEC_APPEND, "safezonemask 1\n");
+			}
+		}
+#endif
+		break;
+	case A_JOY9: // White button
+		// Hacky. Really hacky. No, hackier than that.
+		curSaberSet = (curSaberSet + 1) % 3;	// Number of xsaber strings in config file
+		Cbuf_ExecuteText(EXEC_APPEND, va("vstr xsaber%d\n", curSaberSet));
+		break;
+	case A_JOY10: // Black button
+		curPlayerSet = (curPlayerSet + 1) % 6;	// Number of xplayer strings in config file
+		Cbuf_ExecuteText(EXEC_APPEND, va("vstr xplayer%d\n", curPlayerSet));
+		break;
+	}
+}
+
+#endif
+
diff --git a/codemp/win32/win_input_rumble.cpp b/codemp/win32/win_input_rumble.cpp
new file mode 100644
index 0000000..afa1352
--- /dev/null
+++ b/codemp/win32/win_input_rumble.cpp
@@ -0,0 +1,705 @@
+
+/*
+ * UNPUBLISHED -- Rights  reserved  under  the  copyright  laws  of the 
+ * United States.  Use  of a copyright notice is precautionary only and 
+ * does not imply publication or disclosure.                            
+ *                                                                      
+ * THIS DOCUMENTATION CONTAINS CONFIDENTIAL AND PROPRIETARY INFORMATION 
+ * OF    VICARIOUS   VISIONS,  INC.    ANY  DUPLICATION,  MODIFICATION, 
+ * DISTRIBUTION, OR DISCLOSURE IS STRICTLY PROHIBITED WITHOUT THE PRIOR 
+ * EXPRESS WRITTEN PERMISSION OF VICARIOUS VISIONS, INC.
+ */
+#include "../cgame/cg_local.h"
+#include "../server/exe_headers.h"
+
+#include "win_local.h"
+#include "win_input.h"
+
+
+//MB #include "../client/cl_data.h"
+#include "../game/q_shared.h"
+
+extern qboolean G_ActivePlayerNormal(void);
+
+struct rumblestate_t
+{
+	int timeToStop;
+	
+	// Right motor speed on Xbox, action type on Gamecube
+	int arg1;
+
+	// Left motor speed on Xbox, secondary action type on Gamecube
+	int arg2;
+};
+
+struct rumblestate_special_t
+{
+	int code;
+	int arg1;
+	int arg2;
+};
+
+struct rumblescript_t
+{
+	int nextStateAt;
+	
+	int controller;
+	
+	int currentState;
+	int usedStates;
+	int numStates;
+
+	bool autoDelete;
+	rumblestate_t *states;
+};
+
+struct rumblestatus_t
+{
+	bool changed;
+	bool killed;
+	bool paused;
+	int timePaused;
+};
+
+#define MAX_RUMBLE_STATES		10
+#define MAX_RUMBLE_SCRIPTS		10
+#define MAX_RUMBLE_CONTROLLERS	4
+
+// In rumblestate, highest speed for each side takes precidence
+// Number of rumble states is fairly small, so a plain array will work fine
+static rumblestatus_t rumbleStatus[MAX_RUMBLE_CONTROLLERS];
+static rumblescript_t rumbleScripts[MAX_RUMBLE_SCRIPTS];
+
+cvar_t* in_useRumble = NULL;
+
+/***** FIXME Some functions that would be found in a client manager *****/
+/***** BEGIN FILLER *****/
+
+// Always return 0 because we have only one client (right now anyway)
+int ActiveClientNum(void)
+{
+	return 0;
+}
+
+// The active controller will always be number 0 for now
+int ActiveController(void)
+{
+	return 0;
+}
+/***** END FILLER *****/
+
+void IN_enableRumble( void ) 
+{
+	if (ActiveClientNum() == 0)
+	{
+		Cvar_Set( "in_useRumble",   "1"); 
+	}
+	else
+	{
+		Cvar_Set( "in_useRumble2",   "1"); 
+	}
+}
+
+void IN_disableRumble( void ) 
+{
+	if (ActiveClientNum() == 0)
+	{
+		Cvar_Set( "in_useRumble",   "0"); 
+	}
+	else
+	{
+		Cvar_Set( "in_useRumble2",   "0"); 
+	}
+}									
+	 
+bool IN_usingRumble( void )
+{
+	if (ActiveClientNum() == 0)
+	{
+		return Cvar_VariableIntegerValue( "in_useRumble"); 
+	}
+	else
+	{
+		return Cvar_VariableIntegerValue( "in_useRumble2"); 
+	}
+
+	return true;
+}
+
+
+// Creates a rumble script with numStates
+// Returns -1 on no more room, otherwise an identifier to use for scripts
+int IN_CreateRumbleScript(int controller, int numStates, bool deleteWhenFinished)
+{
+	if (!IN_usingRumble()) return -1;
+
+	if (controller <= -1 || controller >= MAX_RUMBLE_CONTROLLERS) return -1;
+	assert (numStates > 0 && numStates < MAX_RUMBLE_STATES);
+	
+	int i;
+	for (i = 0; i < MAX_RUMBLE_SCRIPTS; i++)
+	{
+		if (rumbleScripts[i].states == 0)
+			break;
+	}
+
+	if (i == MAX_RUMBLE_SCRIPTS) 
+		return -1;		// Ran out of scripts
+	
+	rumbleScripts[i].autoDelete = deleteWhenFinished;
+	rumbleScripts[i].controller = controller;
+	rumbleScripts[i].currentState = 0;
+	rumbleScripts[i].nextStateAt = 0;
+	rumbleScripts[i].numStates = numStates;
+	rumbleScripts[i].usedStates = 0;
+	rumbleScripts[i].states = new rumblestate_t[numStates];
+	memset(rumbleScripts[i].states, 0, sizeof(rumblestate_t) * numStates);
+	return i;
+}
+
+// A negative time will last until you kill it explicitly
+// Returns index, used to kill or change a state in a script
+int IN_AddRumbleStateFull(int whichScript, int arg1, int arg2, int timeInMs)
+{
+	if (!IN_usingRumble()) return -1;
+
+	assert(whichScript >= 0 && whichScript < MAX_RUMBLE_SCRIPTS);
+	assert(rumbleScripts[whichScript].usedStates < rumbleScripts[whichScript].numStates);
+	
+	// Get the current state
+	rumblescript_t *curScript = &rumbleScripts[whichScript];
+	rumblestate_t *curState = &curScript->states[curScript->usedStates];
+
+	curState->arg1 = arg1;
+	curState->arg2 = arg2;
+
+	curState->timeToStop = timeInMs;
+	return curScript->usedStates++;
+}
+
+int IN_AddRumbleState(int whichScript, int leftSpeed, int rightSpeed, int timeInMs)
+{
+	return IN_AddRumbleStateFull(whichScript, leftSpeed, rightSpeed, timeInMs);
+}
+
+int IN_AddRumbleStateSpecial(int whichScript, int action, int arg1, int arg2)
+{
+	if (!IN_usingRumble()) return -1;
+	
+	assert(whichScript >= 0 && whichScript < MAX_RUMBLE_SCRIPTS);
+	assert(rumbleScripts[whichScript].usedStates < rumbleScripts[whichScript].numStates);
+	
+	// Get the current state
+	rumblescript_t *curScript = &rumbleScripts[whichScript];
+	rumblestate_special_t *curState = (rumblestate_special_t*)&curScript->states[curScript->usedStates];
+
+	curState->code = action;
+	curState->arg1 = arg1;
+	curState->arg2 = arg2;
+	return curScript->usedStates++;
+}
+
+int IN_AddEffectFade4(int whichScript, int startLeft, int startRight, 
+					  int endLeft, int endRight, int timeInMs)
+{
+	const int fadeSmoothness = 50;		// number of ms between updates, smaller is smoother
+
+	int e = IN_AddRumbleState(whichScript, startLeft, startRight, fadeSmoothness);	// Lasts for fadeSmoothness ms
+
+	if (startLeft < endLeft)		// Fade increases
+	{
+		IN_AddRumbleStateSpecial(whichScript, IN_CMD_INC_LEFT, e, 
+			(endLeft - startLeft) * fadeSmoothness / timeInMs);	
+	}
+	else
+	{
+		IN_AddRumbleStateSpecial(whichScript, IN_CMD_DEC_LEFT, e, 
+			(startLeft - endLeft) * fadeSmoothness / timeInMs);	
+	}
+
+	if (startRight < endRight)
+	{
+		IN_AddRumbleStateSpecial(whichScript, IN_CMD_INC_RIGHT, e, 
+			(endRight - startRight) * fadeSmoothness / timeInMs);
+	}
+	else
+	{
+		IN_AddRumbleStateSpecial(whichScript, IN_CMD_DEC_RIGHT, e, 
+			(startRight - endRight) * fadeSmoothness / timeInMs);
+	}
+
+	return IN_AddRumbleStateSpecial(whichScript, IN_CMD_GOTO_XTIMES, 
+		e, timeInMs / fadeSmoothness);
+}
+
+int IN_AddEffectFadeExp6(int whichScript, int startLeft, int startRight, 
+						 int endLeft, int endRight, char factor, int timeInMs)
+{
+	const int fadeSmoothness = 10;		// number of ms between updates, smaller is smoother
+
+	int state = IN_AddRumbleState(whichScript, startLeft, startRight, fadeSmoothness);	// Lasts for fadeSmoothness ms
+
+	if (startLeft < endLeft)		// Fade increases
+	{
+		IN_AddRumbleStateSpecial(whichScript, IN_CMD_INC_LEFT, state, 
+			(endLeft - startLeft) * fadeSmoothness / timeInMs - 
+			(factor / 2) * ( 1 - timeInMs / fadeSmoothness)
+			);	
+	}
+	else
+	{
+		IN_AddRumbleStateSpecial(whichScript, IN_CMD_DEC_LEFT, state, 
+			(startLeft - endLeft) * fadeSmoothness / timeInMs - 
+			(factor / 2) * ( 1 - timeInMs / fadeSmoothness)
+			);	
+	}
+
+	if (startRight < endRight)
+	{
+		IN_AddRumbleStateSpecial(whichScript, IN_CMD_INC_RIGHT, state, 
+			(endRight - startRight) * fadeSmoothness / timeInMs - 
+			(factor / 2) * ( 1 - timeInMs / fadeSmoothness)
+			);	
+	}
+	else
+	{
+		IN_AddRumbleStateSpecial(whichScript, IN_CMD_DEC_RIGHT, state,
+			(startRight - endRight) * fadeSmoothness / timeInMs - 
+			(factor / 2) * ( 1 - timeInMs / fadeSmoothness)
+			);	
+	}
+
+	IN_AddRumbleStateSpecial(whichScript, IN_CMD_INC_ARG2, state + 1, factor);
+	IN_AddRumbleStateSpecial(whichScript, IN_CMD_INC_ARG2, state + 2, factor);
+	return IN_AddRumbleStateSpecial(whichScript, IN_CMD_GOTO_XTIMES, 
+		state, timeInMs / fadeSmoothness);
+}
+
+// Kills a rumble state based on index
+void IN_KillRumbleState(int whichScript, int index)
+{
+	if (!IN_usingRumble()) return;
+
+	assert( whichScript >= 0 && whichScript < MAX_RUMBLE_SCRIPTS);
+	assert( index < rumbleScripts[whichScript].numStates );
+
+	rumbleScripts[whichScript].states[index].timeToStop = 0;
+	rumbleStatus[rumbleScripts[whichScript].controller].changed = true;
+}
+
+// Stops the script, if script has autodelete on then it will get deleted, otherwise it will only stop
+void IN_KillRumbleScript(int whichScript)
+{
+	if (!IN_usingRumble()) return;
+
+	assert (whichScript >= 0 && whichScript < MAX_RUMBLE_SCRIPTS);
+
+	rumbleScripts[whichScript].nextStateAt = 0;
+	if (rumbleScripts[whichScript].autoDelete)
+	{
+		if (rumbleScripts[whichScript].states)
+			delete [] rumbleScripts[whichScript].states;
+		rumbleScripts[whichScript].states = 0;
+	}
+
+	rumbleStatus[rumbleScripts[whichScript].controller].changed = true;
+}
+
+// Stops Rumbling for specific controller
+void IN_KillRumbleScripts(int controller)
+{
+	if (!IN_usingRumble()) return;
+	if (controller <= -1 || controller >= MAX_RUMBLE_CONTROLLERS) return;
+	if (rumbleStatus[controller].killed == true) return;
+
+	for (int i = 0; i < MAX_RUMBLE_SCRIPTS; i++)
+	{
+		if (rumbleScripts[i].controller == controller)
+			IN_KillRumbleScript(i);
+	}
+
+	rumbleStatus[controller].killed = IN_RumbleAdjust(controller, 0, 0);
+}
+
+// Stops Rumbling on all controllers
+void IN_KillRumbleScripts( void )
+{
+	if (!IN_usingRumble()) return;
+
+	for (int i = 0; i < MAX_RUMBLE_SCRIPTS; i++)
+		IN_KillRumbleScript(i);
+
+	for (int j = 0; j < MAX_RUMBLE_CONTROLLERS; j++)
+	{
+		if (!rumbleStatus[j].killed)
+		{
+			rumbleStatus[j].killed = IN_RumbleAdjust(j, 0, 0);
+		}
+	}
+}
+
+void IN_DeleteRumbleScript(int whichScript)
+{
+	if (!IN_usingRumble()) return;
+
+	assert (whichScript >= 0 && whichScript < MAX_RUMBLE_SCRIPTS);
+
+	if (rumbleScripts[whichScript].states)
+		delete [] rumbleScripts[whichScript].states;
+	rumbleScripts[whichScript].nextStateAt = 0;
+	rumbleScripts[whichScript].states = 0;
+
+	rumbleStatus[rumbleScripts[whichScript].controller].changed = true;
+}
+
+int IN_RunSpecialScript(int whichScript)
+{
+	rumblestate_special_t *sp = (rumblestate_special_t*)&rumbleScripts[whichScript].states[rumbleScripts[whichScript].currentState];
+	switch (sp->code)
+	{
+		// updates the current state pointer
+		// uses arg1
+	case IN_CMD_GOTO:
+		rumbleScripts[whichScript].currentState = sp->arg1;
+		return rumbleScripts[whichScript].states[sp->arg1].timeToStop;
+		break;	
+		// does a goto, and decreases count of arg2, until 0
+	case IN_CMD_GOTO_XTIMES:
+		if (--sp->arg2 >= 0)
+		{
+			rumbleScripts[whichScript].currentState = sp->arg1;
+			return rumbleScripts[whichScript].states[sp->arg1].timeToStop;
+		}
+		else		// Go onto next cmd
+		{
+			if (!IN_AdvanceToNextState(whichScript))
+				return -2;	// Done
+			return -1;
+		}
+		break;
+
+		// Decreasae Arg2 of a State,		sp->arg1 = state, sp->arg2 = amount to decrease arg2 of state by
+	case IN_CMD_DEC_ARG2:
+		{
+			rumblestate_special_t *temp = (rumblestate_special_t*)&rumbleScripts[whichScript].states[sp->arg1];
+			temp->arg2 -= sp->arg2;
+		}
+		break;
+
+		// Increase Arg2 of a State,		sp->arg1 = state, sp->arg2 = amount to increase arg2 of state by
+	case IN_CMD_INC_ARG2:
+		{
+			rumblestate_special_t *temp = (rumblestate_special_t*)&rumbleScripts[whichScript].states[sp->arg1];
+			temp->arg2 += sp->arg2;
+		}
+		break;
+
+		// Decreasae Arg1 of a State,		sp->arg1 = state, sp->arg2 = amount to decrease arg1 of state by
+	case IN_CMD_DEC_ARG1:
+		{
+			rumblestate_special_t *temp = (rumblestate_special_t*)&rumbleScripts[whichScript].states[sp->arg1];
+			temp->arg1 -= sp->arg2;
+		}
+		break;
+
+		// Increase Arg2 of a State,		sp->arg1 = state, sp->arg2 = amount to increase arg1 of state by
+	case IN_CMD_INC_ARG1:
+		{
+			rumblestate_special_t *temp = (rumblestate_special_t*)&rumbleScripts[whichScript].states[sp->arg1];
+			temp->arg1 += sp->arg2;
+		}
+		break;
+
+	case IN_CMD_DEC_LEFT:
+		rumbleScripts[whichScript].states[sp->arg1].arg2 -=  sp->arg2;
+		if (rumbleScripts[whichScript].states[sp->arg1].arg2 < 0)
+			rumbleScripts[whichScript].states[sp->arg1].arg2 = 0;
+		if (rumbleScripts[whichScript].currentState >= rumbleScripts[whichScript].usedStates - 1)
+			return -2;	// Done
+		return rumbleScripts[whichScript].states[++rumbleScripts[whichScript].currentState].timeToStop;
+		break;
+
+	case IN_CMD_DEC_RIGHT:
+		rumbleScripts[whichScript].states[sp->arg1].arg1 -=  sp->arg2;
+		if (rumbleScripts[whichScript].states[sp->arg1].arg1 < 0)
+			rumbleScripts[whichScript].states[sp->arg1].arg1 = 0;
+		if (rumbleScripts[whichScript].currentState >= rumbleScripts[whichScript].usedStates - 1)
+			return -2;	// Done
+		return rumbleScripts[whichScript].states[++rumbleScripts[whichScript].currentState].timeToStop;
+		break;
+
+	case IN_CMD_INC_LEFT:
+		rumbleScripts[whichScript].states[sp->arg1].arg2 +=  sp->arg2;
+		if (rumbleScripts[whichScript].states[sp->arg1].arg2 > 65534)
+			rumbleScripts[whichScript].states[sp->arg1].arg2 = 65534;
+		if (rumbleScripts[whichScript].currentState >= rumbleScripts[whichScript].usedStates - 1)
+			return -2;	// Done
+		return rumbleScripts[whichScript].states[++rumbleScripts[whichScript].currentState].timeToStop;
+		break;
+
+	case IN_CMD_INC_RIGHT:
+		rumbleScripts[whichScript].states[sp->arg1].arg1 += sp->arg2;
+		if (rumbleScripts[whichScript].states[sp->arg1].arg1 > 65534)
+			rumbleScripts[whichScript].states[sp->arg1].arg1 = 65534;
+		if (rumbleScripts[whichScript].currentState >= rumbleScripts[whichScript].usedStates - 1)
+			return -2;	// Done
+		return rumbleScripts[whichScript].states[++rumbleScripts[whichScript].currentState].timeToStop;
+		break;
+	}
+	return 0;
+}
+
+int IN_Time()
+{
+	//mb return ClientManager::ActiveClient().cg.time;
+	return cg.time;
+}
+
+void IN_ExecuteRumbleScript(int whichScript)
+{
+	if (!IN_usingRumble()) return;
+
+	assert (whichScript >= 0 && whichScript < MAX_RUMBLE_SCRIPTS);
+	
+	// Can't execute an empty script???
+	assert (rumbleScripts[whichScript].usedStates > 0);
+
+	rumbleScripts[whichScript].currentState = 0;
+	int cmd = rumbleScripts[whichScript].states[rumbleScripts[whichScript].currentState].timeToStop;
+	if (cmd < 0)
+	{
+		cmd = IN_RunSpecialScript(whichScript);
+	}
+	
+	rumbleScripts[whichScript].nextStateAt = IN_Time() + cmd;
+	
+	rumbleStatus[rumbleScripts[whichScript].controller].changed = true;
+	rumbleStatus[rumbleScripts[whichScript].controller].killed = false;
+}
+
+
+
+void IN_PauseRumbling(int controller)
+{ 
+	if (!IN_usingRumble()) return;
+	if (controller <= -1 || controller >= MAX_RUMBLE_CONTROLLERS) return;
+	if (rumbleStatus[controller].paused == true) return;
+
+	rumbleStatus[controller].timePaused = IN_Time();
+	rumbleStatus[controller].paused = IN_RumbleAdjust(controller, 0, 0);
+}
+
+void IN_UnPauseRumbling(int controller)
+{
+	if (!IN_usingRumble()) return;
+	if (controller <= -1 || controller >= MAX_RUMBLE_CONTROLLERS) return;
+	
+	// can't unpause a control that wasn't paused
+	if (rumbleStatus[controller].paused == false) return;
+
+	int cur_time = IN_Time();
+	for (int i = 0; i < MAX_RUMBLE_SCRIPTS; i++)
+	{
+		if (rumbleScripts[i].controller == controller)
+		{
+			if (rumbleScripts[i].nextStateAt == 0) continue;
+			// update the time to stop based on how long it was paused
+			rumbleScripts[i].nextStateAt += (cur_time - rumbleStatus[controller].timePaused);
+		}
+	}
+
+	rumbleStatus[controller].paused = false; 
+	rumbleStatus[controller].changed = true;
+	rumbleStatus[controller].killed = false;
+}
+
+void IN_TogglePauseRumbling(int controller)
+{ 
+	if (!IN_usingRumble()) return;
+	if (controller <= -1 || controller >= MAX_RUMBLE_CONTROLLERS) return;
+	if (rumbleStatus[controller].paused)
+		IN_UnPauseRumbling(controller);
+	else
+		IN_PauseRumbling(controller);
+}
+
+// Pauses rumbling on all controllers
+void IN_PauseRumbling( void )
+{ 
+	if (!IN_usingRumble()) return;
+	for (int i = 0; i < MAX_RUMBLE_CONTROLLERS; i++)
+		IN_PauseRumbling(i);
+}
+
+// UnPauses rumbling on all controllers
+void IN_UnPauseRumbling( void )
+{ 
+	if (!IN_usingRumble()) return;
+	for (int i = 0; i < MAX_RUMBLE_CONTROLLERS; i++)
+		IN_UnPauseRumbling(i);
+}
+
+// Toggles Pausing on all controllers
+void IN_TogglePauseRumbling( void )
+{ 
+	if (!IN_usingRumble()) return;
+	for (int i = 0; i < MAX_RUMBLE_CONTROLLERS; i++)
+		IN_TogglePauseRumbling(i);
+}
+
+// Returns false when the end of the script is reached
+bool IN_AdvanceToNextState(int whichScript)
+{
+	assert( whichScript >= 0 && whichScript < MAX_RUMBLE_SCRIPTS );
+	
+	if (rumbleScripts[whichScript].currentState >= rumbleScripts[whichScript].usedStates - 1)
+	{
+		// Script is at its end, so kill it( which deletes only if autodelete
+		IN_KillRumbleScript(whichScript);
+		return false;
+	}
+
+	// Advance a state
+	rumbleScripts[whichScript].currentState++;
+
+	int cmd = rumbleScripts[whichScript].states[rumbleScripts[whichScript].currentState].timeToStop;
+	while (cmd < 0)
+	{
+		cmd = IN_RunSpecialScript(whichScript);
+		if (cmd == -1) return true;
+		if (cmd == -2) return false;
+	}
+
+	rumbleScripts[whichScript].nextStateAt = IN_Time() + cmd;
+	return true;
+}
+
+// Max rumble takes precidence
+// Other possibility is some kind of sum of all the speeds 
+// Call this once a frame, to update the controller based on the rumble states
+void IN_UpdateRumbleFromStates()
+{
+	//if (!IN_usingRumble()) return;
+/*mb	extern int G_ShouldBeRumbling();
+	if (!G_ShouldBeRumbling())
+		return;
+*/
+	int usingRumble[2];
+	usingRumble[0] = Cvar_VariableIntegerValue("in_useRumble");
+	usingRumble[1] = Cvar_VariableIntegerValue("in_useRumble2");
+	
+	int i;
+	int value[MAX_RUMBLE_CONTROLLERS][2];		
+	int cur_time = IN_Time();
+
+	memset(value, 0, sizeof(int)*MAX_RUMBLE_CONTROLLERS*2);
+	for (i = 0; i < MAX_RUMBLE_SCRIPTS; i++)
+	{
+		// If rumble is paused on current controller than skip this rumble state
+		if ( rumbleStatus[rumbleScripts[i].controller].paused) continue;
+
+//*mb	ClientManager::ActivateByControllerId(rumbleScripts[i].controller);
+		if ( !usingRumble[ActiveClientNum()] ) 
+		{
+			IN_KillRumbleScript(i);
+			continue;
+		}
+/*mb
+		if (!ClientManager::ActiveGentity() || !G_ActivePlayerNormal())
+		{
+			IN_KillRumbleScript(i);
+			continue;
+		}
+*/
+		// Unset state so skip
+		if ( rumbleScripts[i].nextStateAt == 0) continue;
+
+		// Time is up on this rumble state
+		if ( rumbleScripts[i].nextStateAt < cur_time) 
+		{
+			// If timeToStop is < cur_time and > 0 then end this state otherwise (negative number) always rumble 
+			if (rumbleScripts[i].nextStateAt > 0) 
+			{	
+				rumbleStatus[rumbleScripts[i].controller].changed = true;
+				rumbleStatus[rumbleScripts[i].controller].killed = false;
+				if (!IN_AdvanceToNextState(i))		// Returns false if reached the end of script
+					continue;
+			}
+		}
+
+		rumblescript_t *curScript = &rumbleScripts[i];
+
+		if (value[curScript->controller][0] < curScript->states[curScript->currentState].arg2)
+			value[curScript->controller][0] = curScript->states[curScript->currentState].arg2;
+		if (value[curScript->controller][1] < curScript->states[curScript->currentState].arg1)
+			value[curScript->controller][1] = curScript->states[curScript->currentState].arg1;
+	}
+	
+	// Go through the 4 controller ports
+	for (i = 0; i < MAX_RUMBLE_CONTROLLERS; i++) 
+	{
+		// paused, so do nothing for this controller
+		if ( rumbleStatus[i].paused) continue;
+
+		// Only update the actual hardware if a state has changed
+		if (!rumbleStatus[i].changed) continue;
+		
+		IN_RumbleAdjust(i, value[i][0], value[i][1]);
+		
+		// State has changed
+		rumbleStatus[i].changed = false;
+	}
+}
+
+
+
+/*
+==================
+IN_RumbleInit
+==================
+*/
+void IN_RumbleInit (void) {
+	memset(&rumbleStatus, 0, sizeof(rumblestatus_t)*MAX_RUMBLE_CONTROLLERS);
+	memset(&rumbleScripts, 0, sizeof(rumblescript_t)*MAX_RUMBLE_SCRIPTS);
+
+	in_useRumble = Cvar_Get( "in_useRumble", "1", 0 );
+	Cvar_Get("in_useRumble2", "1", 0);
+}
+
+
+/*
+==================
+IN_RumbleShutdown
+==================
+*/
+void IN_RumbleShutdown (void) {
+	for (int i = 0; i < MAX_RUMBLE_SCRIPTS; i++)
+	{
+		if (rumbleScripts[i].states)
+			delete [] rumbleScripts[i].states;
+		rumbleScripts[i].states = 0;
+		rumbleScripts[i].nextStateAt = 0;
+	}
+}
+
+
+/*
+==================
+IN_RumbleFrame
+==================
+*/
+void IN_RumbleFrame (void)
+{
+	// Check to see if we need to pause rumbling
+	if(cl_paused->integer && !rumbleStatus[IN_GetMainController()].paused)
+	{
+		IN_PauseRumbling(IN_GetMainController());
+	}
+	else if(!cl_paused->integer && rumbleStatus[IN_GetMainController()].paused)
+	{
+		IN_UnPauseRumbling(IN_GetMainController());
+	}
+	
+	// Update the states
+	IN_UpdateRumbleFromStates();
+}
diff --git a/codemp/win32/win_input_xbox.cpp b/codemp/win32/win_input_xbox.cpp
new file mode 100644
index 0000000..e52ca0c
--- /dev/null
+++ b/codemp/win32/win_input_xbox.cpp
@@ -0,0 +1,309 @@
+// win_input.c -- win32 mouse and joystick code
+// 02/21/97 JCB Added extended DirectInput code to support external controllers.
+
+// leave this as first line for PCH reasons...
+//
+// #include "../server/exe_headers.h"
+
+#include <xtl.h>
+#include "glw_win_dx8.h"
+
+#include "../client/client.h"
+#include "../qcommon/qcommon.h"
+#ifdef _JK2MP
+#include "../ui/keycodes.h"
+#else
+#include "../client/keycodes.h"
+#endif
+
+#include "win_local.h"
+#include "win_input.h"
+
+#define IN_MAX_CONTROLLERS 4
+
+void IN_UIEmptyQueue();
+
+struct inputstate_t
+{
+	struct controller_t
+	{
+		HANDLE handle;
+		XINPUT_STATE state;
+		XINPUT_FEEDBACK feedback;
+	};
+	controller_t controllers[IN_MAX_CONTROLLERS];
+};
+
+inputstate_t *in_state = NULL;
+
+/*
+=========================================================================
+
+JOYSTICK
+
+=========================================================================
+*/
+// Process all the insertions and removals, updating handles and such
+void IN_ProcessChanges(DWORD dwInsert, DWORD dwRemove)
+{
+	for(int port = 0; port < IN_MAX_CONTROLLERS; ++port)
+	{
+		// Close removals.
+		if( ((1 << port) & dwRemove) && in_state->controllers[port].handle )
+		{
+			XInputClose( in_state->controllers[port].handle );
+			in_state->controllers[port].handle = 0;
+			IN_PadUnplugged(port);
+		}
+
+		// Open insertions.
+		if( (1 << port) & dwInsert )
+		{
+			in_state->controllers[port].handle = XInputOpen( XDEVICE_TYPE_GAMEPAD, port, XDEVICE_NO_SLOT, NULL );
+			IN_PadPlugged(port);
+		}
+	}
+
+	return;
+}
+
+/*********
+IN_CheckForNoControllers()
+If there are no controllers plugged in, the UI
+is notified so it can display an appropriate
+message.
+*********/
+void IN_CheckForNoControllers()
+{
+	extern bool noControllersConnected;
+	if(!noControllersConnected)
+	{
+		extern bool wasPlugged[4];
+		if( !wasPlugged[0] &&
+			!wasPlugged[1] &&
+			!wasPlugged[2] &&
+			!wasPlugged[3] )
+		{
+			// Tell the UI that there are no controllers connected
+		//	VM_Call( uivm, UI_CONTROLLER_UNPLUGGED, true, -1);
+			noControllersConnected = true;
+		}
+	}
+}
+
+/*
+=========================================================================
+
+  RUMBLE SUPPORT
+
+=========================================================================
+*/
+
+bool IN_RumbleAdjust(int controller, int left, int right)
+{
+	assert(controller >= 0 && controller < IN_MAX_CONTROLLERS);
+
+	// Get a device handle for the controller.  This may fail.
+	HANDLE handle = in_state->controllers[controller].handle;
+
+	if (!handle) return false;
+	
+	XINPUT_FEEDBACK* fb = &in_state->controllers[controller].feedback;
+	
+	// If a prior rumble update is still pending, go away
+	if (fb->Header.dwStatus == ERROR_IO_PENDING) return false;
+
+	fb->Rumble.wLeftMotorSpeed = left;
+	fb->Rumble.wRightMotorSpeed = right;
+	
+	return ERROR_IO_PENDING == XInputSetState(handle, fb);
+}
+
+
+/*
+=========================================================================
+
+=========================================================================
+*/
+
+/*
+igBool IN_WindowClose(igWindow *window)
+{
+	SV_Shutdown ("Server quit\n");
+	CL_Shutdown ();
+	Com_Shutdown ();
+	Sys_Quit ();
+	return true;
+}
+*/
+
+/*
+===========
+IN_Shutdown
+===========
+*/
+void IN_Shutdown( void ) {
+	IN_RumbleShutdown();
+
+	delete in_state;
+	in_state = NULL;
+}
+
+
+/*
+===========
+IN_Init
+===========
+*/
+void IN_Init( void )
+{
+	in_state = new inputstate_t;
+
+	// Initialize support for 4 gamepads
+	XDEVICE_PREALLOC_TYPE xdpt[] = {
+		{XDEVICE_TYPE_GAMEPAD, 4},
+		{XDEVICE_TYPE_MEMORY_UNIT, 1},
+		{XDEVICE_TYPE_VOICE_MICROPHONE, 1},
+		{XDEVICE_TYPE_VOICE_HEADPHONE, 1}
+	};
+
+    // Initialize the peripherals. We can only ever
+	// call XInitDevices once, no matter what.
+	static bool bInputInitialized = false;
+	if (!bInputInitialized)
+    	XInitDevices( sizeof(xdpt) / sizeof(XDEVICE_PREALLOC_TYPE), xdpt );
+	bInputInitialized = true;
+
+    // Zero all of our data, including handles
+	memset(in_state->controllers, 0, sizeof(in_state->controllers));
+
+	// Find out the status of all gamepad ports, then open them
+	IN_ProcessChanges( XGetDevices( XDEVICE_TYPE_GAMEPAD ), 0 );
+
+	IN_RumbleInit();
+}
+
+static inline float _joyAxisConvert(SHORT x)
+{
+	// Change scale
+	float y = x / 32767.0;
+
+	// Cheesy deadzone
+	if(fabs(y) < 0.25f)
+	{
+		y = 0.0f;
+	}
+
+	return y;
+}
+
+// How many controls on the xbox gamepad?
+#define IN_NUM_DIGITAL_BUTTONS 8
+#define IN_NUM_ANALOG_BUTTONS 8
+// Cutoff where the analog buttons are considered to be "pressed"
+// This should be smarter.
+#define IN_ANALOG_BUTTON_THRESHOLD 64
+
+void IN_UpdateGamepad(int port)
+{
+	// Lookup table to convert the digital buttons to fakeAscii_t, in mask order
+	const fakeAscii_t digitalXlat[IN_NUM_DIGITAL_BUTTONS] = {
+		A_JOY5, // DPAD_UP
+		A_JOY7, // DPAD_DOWN
+		A_JOY8, // DPAD_LEFT
+		A_JOY6, // DPAD_LEFT
+		A_JOY4, // Start
+		A_JOY1, // Back
+		A_JOY2, // Left stick
+		A_JOY3  // Right stick
+	};
+
+	// Lookup table to convet the analog buttons to fakeAscii_t, in DX order
+	const fakeAscii_t analogXlat[IN_NUM_ANALOG_BUTTONS] = {
+		A_JOY15, // A
+		A_JOY14, // B
+		A_JOY16, // X
+		A_JOY13, // Y
+		A_JOY10, // Black
+		A_JOY9,  // White
+		A_JOY11, // Left trigger
+		A_JOY12  // Right trigger
+	};
+
+	// Get new state
+	XINPUT_STATE newState;
+	XInputGetState( in_state->controllers[port].handle, &newState );
+
+	// Get old state
+	XINPUT_STATE &oldState(in_state->controllers[port].state);
+
+	int buttonIdx;
+	bool oldPressed, newPressed;
+
+	// Check all digital buttons first
+	for (buttonIdx = 0; buttonIdx < IN_NUM_DIGITAL_BUTTONS; ++buttonIdx)
+	{
+		oldPressed = oldState.Gamepad.wButtons & (1 << buttonIdx);
+		newPressed = newState.Gamepad.wButtons & (1 << buttonIdx);
+
+		if (oldPressed != newPressed)
+			IN_CommonJoyPress(port, digitalXlat[buttonIdx], newPressed);
+	}
+
+	// Now check all analog buttons
+	for (buttonIdx = 0; buttonIdx < IN_NUM_ANALOG_BUTTONS; ++buttonIdx)
+	{
+		oldPressed = oldState.Gamepad.bAnalogButtons[buttonIdx] > IN_ANALOG_BUTTON_THRESHOLD;
+		newPressed = newState.Gamepad.bAnalogButtons[buttonIdx] > IN_ANALOG_BUTTON_THRESHOLD;
+
+		if (oldPressed != newPressed)
+			IN_CommonJoyPress(port, analogXlat[buttonIdx], newPressed);
+	}
+
+	// Update joysticks
+	_padInfo.joyInfo[0].x = _joyAxisConvert(newState.Gamepad.sThumbLX);
+	_padInfo.joyInfo[0].y = _joyAxisConvert(newState.Gamepad.sThumbLY);
+	_padInfo.joyInfo[1].x = _joyAxisConvert(newState.Gamepad.sThumbRX);
+	_padInfo.joyInfo[1].y = _joyAxisConvert(newState.Gamepad.sThumbRY);
+	_padInfo.joyInfo[0].valid = _padInfo.joyInfo[1].valid = true;
+	_padInfo.padId = port;
+
+	// Copy state back
+	oldState = newState;
+
+	// Update game
+	IN_CommonUpdate();
+}
+
+/*
+==================
+IN_Frame
+
+Called every frame, even if not generating commands
+==================
+*/
+//extern int ignoreInputTime;
+void IN_Frame (void)
+{
+	if (in_state)
+	{
+		// First, check for changes in device status (removed/inserted pads)
+		DWORD dwInsert, dwRemove;
+		if( XGetDeviceChanges( XDEVICE_TYPE_GAMEPAD, &dwInsert, &dwRemove ) )
+		{
+			IN_ProcessChanges(dwInsert, dwRemove);
+		}
+		else
+		{
+			IN_CheckForNoControllers();
+		}
+
+		// Generate callbacks for each controller that's plugged in
+		for (int port = 0; port < IN_MAX_CONTROLLERS; ++port)
+			if (in_state->controllers[port].handle)
+				IN_UpdateGamepad(port);
+		
+		IN_UIEmptyQueue();
+		IN_RumbleFrame();
+	}
+}
diff --git a/codemp/win32/win_local.h b/codemp/win32/win_local.h
new file mode 100644
index 0000000..afac44d
--- /dev/null
+++ b/codemp/win32/win_local.h
@@ -0,0 +1,84 @@
+// win_local.h: Win32-specific Quake3 header file
+
+#if defined (_MSC_VER) && (_MSC_VER >= 1200)
+#pragma warning(disable : 4201)
+#pragma warning( push )
+#endif
+//#include <windows.h>
+#include "../qcommon/platform.h"
+#if defined (_MSC_VER) && (_MSC_VER >= 1200)
+#pragma warning( pop )
+#endif
+
+#ifndef _XBOX
+#define DIRECTINPUT_VERSION 0x0800  //[ 0x0300 | 0x0500 | 0x0700 | 0x0800 ]
+#include <dinput.h>
+#include <dsound.h>
+#include <winsock.h>
+#include <wsipx.h>
+#endif
+
+void	IN_MouseEvent (int mstate);
+
+void Sys_QueEvent( int time, sysEventType_t type, int value, int value2, int ptrLength, void *ptr );
+
+void	Sys_CreateConsole( void );
+void	Sys_DestroyConsole( void );
+
+char	*Sys_ConsoleInput (void);
+
+qboolean	Sys_GetPacket ( netadr_t *net_from, msg_t *net_message );
+
+// Input subsystem
+
+void	IN_Init (void);
+void	IN_Shutdown (void);
+void	IN_JoystickCommands (void);
+
+void	IN_Move (usercmd_t *cmd);
+// add additional non keyboard / non mouse movement on top of the keyboard move cmd
+
+void	IN_DeactivateWin32Mouse( void);
+
+void	IN_Activate (qboolean active);
+void	IN_Frame (void);
+
+// window procedure
+#ifndef _XBOX
+LONG WINAPI MainWndProc (
+    HWND    hWnd,
+    UINT    uMsg,
+    WPARAM  wParam,
+    LPARAM  lParam);
+#endif
+
+void Conbuf_AppendText( const char *msg );
+
+void SNDDMA_Activate( qboolean bAppActive );
+int  SNDDMA_InitDS ();
+
+#ifndef _XBOX
+typedef struct
+{
+	
+	HINSTANCE		reflib_library;		// Handle to refresh DLL 
+	qboolean		reflib_active;
+
+	HWND			hWnd;
+	HINSTANCE		hInstance;
+	qboolean		activeApp;
+	qboolean		isMinimized;
+	OSVERSIONINFO	osversion;
+
+	// when we get a windows message, we store the time off so keyboard processing
+	// can know the exact time of an event
+	unsigned		sysMsgTime;
+} WinVars_t;
+
+extern WinVars_t	g_wv;
+#endif
+
+
+#define	MAX_QUED_EVENTS		256
+#define	MASK_QUED_EVENTS	( MAX_QUED_EVENTS - 1 )
+
diff --git a/codemp/win32/win_main.cpp b/codemp/win32/win_main.cpp
new file mode 100644
index 0000000..29f8ad4
--- /dev/null
+++ b/codemp/win32/win_main.cpp
@@ -0,0 +1,1609 @@
+// win_main.c
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+#include "../client/client.h"
+#include "win_local.h"
+#include "resource.h"
+#include <errno.h>
+#include <float.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <direct.h>
+#include <io.h>
+#include <conio.h>
+#include "../qcommon/stringed_ingame.h"
+
+#define	CD_BASEDIR	"gamedata\\gamedata"
+#define	CD_EXE		"jamp.exe"
+#define	CD_BASEDIR_LINUX	"bin\\x86\\glibc-2.1"
+#define	CD_EXE_LINUX "jamp"
+#define	CD_VOLUME	"JEDIACAD"
+#define MEM_THRESHOLD 128*1024*1024
+
+static char		sys_cmdline[MAX_STRING_CHARS];
+
+// enable this for executable checksumming
+#ifdef FINAL_BUILD
+#define SPANK_MONKEYS
+#endif
+static int	sys_monkeySpank;
+static int	sys_checksum;
+
+
+/*
+==================
+Sys_LowPhysicalMemory()
+==================
+*/
+
+qboolean Sys_LowPhysicalMemory() {
+	static MEMORYSTATUS stat;
+	static qboolean bAsked = qfalse;
+	static cvar_t* sys_lowmem = Cvar_Get( "sys_lowmem", "0", 0 );
+
+	if (!bAsked)	// just in case it takes a little time for GlobalMemoryStatus() to gather stats on
+	{				//	stuff we don't care about such as virtual mem etc.
+		bAsked = qtrue;
+		GlobalMemoryStatus (&stat);
+	}
+	if (sys_lowmem->integer)
+	{
+		return qtrue;
+	}
+	return (stat.dwTotalPhys <= MEM_THRESHOLD) ? qtrue : qfalse;
+}
+
+/*
+==================
+Sys_FunctionCmp
+==================
+*/
+int Sys_FunctionCmp(void *f1, void *f2) {
+
+	int i, j, l;
+	byte func_end[32] = {0xC3, 0x90, 0x90, 0x00};
+	byte *ptr, *ptr2;
+	byte *f1_ptr, *f2_ptr;
+
+	ptr = (byte *) f1;
+	if (*(byte *)ptr == 0xE9) {
+		//Com_Printf("f1 %p1 jmp %d\n", (int *) f1, *(int*)(ptr+1));
+		f1_ptr = (byte*)(((byte*)f1) + (*(int *)(ptr+1)) + 5);
+	}
+	else {
+		f1_ptr = ptr;
+	}
+	//Com_Printf("f1 ptr %p\n", f1_ptr);
+
+	ptr = (byte *) f2;
+	if (*(byte *)ptr == 0xE9) {
+		//Com_Printf("f2 %p jmp %d\n", (int *) f2, *(int*)(ptr+1));
+		f2_ptr = (byte*)(((byte*)f2) + (*(int *)(ptr+1)) + 5);
+	}
+	else {
+		f2_ptr = ptr;
+	}
+	//Com_Printf("f2 ptr %p\n", f2_ptr);
+
+#ifdef _DEBUG
+	sprintf((char *)func_end, "%c%c%c%c%c%c%c", 0x5F, 0x5E, 0x5B, 0x8B, 0xE5, 0x5D, 0xC3);
+#endif
+	for (i = 0; i < 1024; i++) {
+		for (j = 0; func_end[j]; j++) {
+			if (f1_ptr[i+j] != func_end[j])
+				break;
+		}
+		if (!func_end[j]) {
+			break;
+		}
+	}
+#ifdef _DEBUG
+	l = i + 7;
+#else
+	l = i + 2;
+#endif
+	//Com_Printf("function length = %d\n", l);
+
+	for (i = 0; i < l; i++) {
+		// check for a potential function call
+		if (*((byte *) &f1_ptr[i]) == 0xE8) {
+			// get the function pointers in case this really is a function call
+			ptr = (byte *) (((byte *) &f1_ptr[i]) + (*(int *) &f1_ptr[i+1])) + 5;
+			ptr2 = (byte *) (((byte *) &f2_ptr[i]) + (*(int *) &f2_ptr[i+1])) + 5;
+			// if it was a function call and both f1 and f2 call the same function
+			if (ptr == ptr2) {
+				i += 4;
+				continue;
+			}
+		}
+		if (f1_ptr[i] != f2_ptr[i])
+			return qfalse;
+	}
+	return qtrue;
+}
+
+/*
+==================
+Sys_FunctionCheckSum
+==================
+*/
+int Sys_FunctionCheckSum(void *f1) {
+
+	int i, j, l;
+	byte func_end[32] = {0xC3, 0x90, 0x90, 0x00};
+	byte *ptr;
+	byte *f1_ptr;
+
+	ptr = (byte *) f1;
+	if (*(byte *)ptr == 0xE9) {
+		//Com_Printf("f1 %p1 jmp %d\n", (int *) f1, *(int*)(ptr+1));
+		f1_ptr = (byte*)(((byte*)f1) + (*(int *)(ptr+1)) + 5);
+	}
+	else {
+		f1_ptr = ptr;
+	}
+	//Com_Printf("f1 ptr %p\n", f1_ptr);
+
+#ifdef _DEBUG
+	sprintf((char *)func_end, "%c%c%c%c%c%c%c", 0x5F, 0x5E, 0x5B, 0x8B, 0xE5, 0x5D, 0xC3);
+#endif
+	for (i = 0; i < 1024; i++) {
+		for (j = 0; func_end[j]; j++) {
+			if (f1_ptr[i+j] != func_end[j])
+				break;
+		}
+		if (!func_end[j]) {
+			break;
+		}
+	}
+#ifdef _DEBUG
+	l = i + 7;
+#else
+	l = i + 2;
+#endif
+	//Com_Printf("function length = %d\n", l);
+	return Com_BlockChecksum( f1_ptr, l );
+}
+
+/*
+==================
+Sys_MonkeyShouldBeSpanked
+==================
+*/
+int Sys_MonkeyShouldBeSpanked( void ) {
+	return sys_monkeySpank;
+}
+
+/*
+==================
+Sys_CodeInMemoryChecksum
+==================
+*/
+#define MakePtr( cast, ptr, addValue ) (cast)( (DWORD)(ptr) + (addValue) )
+
+int Sys_CodeInMemoryChecksum( void *codeBase ) {
+	PIMAGE_DOS_HEADER dosHeader;
+	PIMAGE_NT_HEADERS pNTHeader;
+	PIMAGE_SECTION_HEADER section;
+
+	dosHeader = (PIMAGE_DOS_HEADER)codeBase;
+	pNTHeader = MakePtr( PIMAGE_NT_HEADERS, dosHeader, dosHeader->e_lfanew );
+
+	// First, verify that the e_lfanew field gave us a reasonable
+	// pointer, then verify the PE signature.
+	if ( IsBadReadPtr(pNTHeader, sizeof(IMAGE_NT_HEADERS)) ||
+	     pNTHeader->Signature != IMAGE_NT_SIGNATURE )
+	{
+		//printf("Unhandled EXE type, or invalid .EXE\n");
+		return 0;
+	}
+	// first section oughta be the code section
+	section = (PIMAGE_SECTION_HEADER)(pNTHeader+1);
+	/*
+	// the name of the code section should be .text
+	if ( Q_stricmp( section->Name, ".text" ) ) {
+		return 0;
+	}
+	*/
+
+	return Com_BlockChecksum( ((byte *) codeBase) + section->VirtualAddress, section->SizeOfRawData );
+}
+
+/*
+==================
+Sys_ChecksumExe
+==================
+*/
+
+// make sure this string is unique in the executable
+//					   01234567890123
+byte *exeChecksumId = (unsigned char *)"q3monkeyid\0\0\0\0";
+
+void Sys_ChecksumExe( void *codeBase ) {
+	TCHAR szPathOrig[_MAX_PATH], szPathClone[_MAX_PATH];
+	STARTUPINFO si;
+	TCHAR szCmdLine[512];
+	HANDLE hfile, hProcessOrig;
+	PROCESS_INFORMATION pi;
+	int l, i, n;
+	FILE *f;
+	byte *buf, *ptr;
+
+	// Is this the original EXE or the clone EXE?
+	if ( Q_stricmp(__argv[1], "monkey") ) {
+		// Original EXE: Spawn clone EXE to delete this EXE
+
+		GetModuleFileName(NULL, szPathOrig, _MAX_PATH);
+		GetTempPath(_MAX_PATH, szPathClone);
+		GetTempFileName(szPathClone, __TEXT("Del"), 0, szPathClone); 
+		CopyFile(szPathOrig, szPathClone, FALSE);
+
+		// Open the clone EXE using FILE_FLAG_DELETE_ON_CLOSE
+		hfile = CreateFile(szPathClone, 0, FILE_SHARE_READ, NULL,   	                       
+								OPEN_EXISTING, FILE_FLAG_DELETE_ON_CLOSE, NULL);
+		// Spawn the clone EXE passing it our EXE's process handle
+		// and the full path name to the original EXE file.
+		hProcessOrig = OpenProcess(SYNCHRONIZE, TRUE,
+									GetCurrentProcessId());
+									wsprintf(szCmdLine, __TEXT("%s monkey %d %d \"%s\""), szPathClone,
+												sys_checksum, hProcessOrig, szPathOrig);
+		ZeroMemory(&si, sizeof(si));
+		si.cb = sizeof(si);
+		CreateProcess(NULL, szCmdLine, NULL, NULL, TRUE, 0, NULL, NULL, &si, &pi);
+		CloseHandle(hProcessOrig);
+		CloseHandle(hfile);
+	} else {
+		// Clone EXE: When original EXE terminates, overwrite it with a new one
+		sys_checksum = atoi( __argv[2] );
+		hProcessOrig = (HANDLE) atoi( __argv[3] );
+		WaitForSingleObject(hProcessOrig, INFINITE);
+		CloseHandle(hProcessOrig);
+		// open the original executable
+		f = fopen( __argv[4], "rb" );
+		if ( !f ) {
+			return;
+		}
+		fseek (f, 0, SEEK_END);
+		l = ftell (f);
+		fseek (f, 0, SEEK_SET);
+		buf = (unsigned char *)malloc(l);
+		if ( fread(buf, l, 1, f) != 1 ) {
+			return;
+		}
+		fclose(f);
+		// search for the exe name string, nice brute force
+		n = strlen((const char *)exeChecksumId);
+		for ( i = 0; i < l; i++ ) {
+			if ( !Q_strncmp((const char *)(buf + i), (const char *)exeChecksumId, n) ) {
+				break;
+			}
+		}
+		if ( i >= l ) {
+			return;
+		}
+		ptr = buf + i;
+		// write checksum into exe memory image
+		ptr[0] = (sys_checksum >> 24) & 0xFF;
+		ptr[1] = (sys_checksum >> 16) & 0xFF;
+		ptr[2] = (sys_checksum >>  8) & 0xFF;
+		ptr[3] = (sys_checksum >>  0) & 0xFF;
+		ptr[4] = ptr[5] = ptr[6] = ptr[7] = ptr[8] = ptr[9] = 0;
+		// write out new exe with checksum
+		f = fopen( __argv[4], "wb" );
+		if ( !f ) {
+			return;
+		}
+		if ( fwrite(buf, l, 1, f) != 1 ) {
+			return;
+		}
+		fclose(f);
+		free(buf);
+		// The system will delete the clone EXE automatically 
+		// because it was opened with FILE_FLAG_DELETE_ON_CLOSE
+	}
+	//
+	exit(0);
+}
+
+/*
+==================
+Sys_VerifyCodeChecksum
+==================
+*/
+void Sys_VerifyCodeChecksum( void *codeBase ) {
+	// NOTE: should not checksum code in debug mode because the memory image changes
+	//		 as soon as you set a break point!
+#if defined(SPANK_MONKEYS) && !defined(_DEBUG)
+	int exeChecksum;
+
+	// if the checksum is not yet stored in the executable
+	if ( exeChecksumId[4] != 0 ) {
+		// spawn another process that will replace this executable with one that has a checksum
+		Sys_ChecksumExe( codeBase );
+		return;
+	}
+
+	exeChecksum = (exeChecksumId[0] << 24) | (exeChecksumId[1] << 16) | (exeChecksumId[2] << 8) | exeChecksumId[3];
+	if ( exeChecksum != sys_checksum ) {
+		sys_monkeySpank = qtrue;
+	}
+#endif
+}
+
+/*
+==================
+Sys_BeginProfiling
+==================
+*/
+void Sys_BeginProfiling( void ) {
+	// this is just used on the mac build
+}
+
+/*
+=============
+Sys_Error
+
+Show the early console as an error dialog
+=============
+*/
+void QDECL Sys_Error( const char *error, ... ) {
+	va_list		argptr;
+	char		text[4096];
+    MSG        msg;
+
+	va_start (argptr, error);
+	vsprintf (text, error, argptr);
+	va_end (argptr);
+
+	Conbuf_AppendText( text );
+	Conbuf_AppendText( "\n" );
+
+	Sys_SetErrorText( text );
+	Sys_ShowConsole( 1, qtrue );
+
+	timeEndPeriod( 1 );
+
+	IN_Shutdown();
+
+	// wait for the user to quit
+	while ( 1 ) {
+		if (!GetMessage (&msg, NULL, 0, 0))
+			Com_Quit_f ();
+		TranslateMessage (&msg);
+      	DispatchMessage (&msg);
+	}
+
+	Sys_DestroyConsole();
+	Com_ShutdownZoneMemory();
+ 	Com_ShutdownHunkMemory();
+
+	exit (1);
+}
+
+/*
+==============
+Sys_Quit
+==============
+*/
+void Sys_Quit( void ) {
+	timeEndPeriod( 1 );
+	IN_Shutdown();
+	Sys_DestroyConsole();
+	Com_ShutdownZoneMemory();
+ 	Com_ShutdownHunkMemory();
+
+	exit (0);
+}
+
+/*
+==============
+Sys_Print
+==============
+*/
+void Sys_Print( const char *msg ) {
+	Conbuf_AppendText( msg );
+}
+
+
+/*
+==============
+Sys_Mkdir
+==============
+*/
+void Sys_Mkdir( const char *path ) {
+	_mkdir (path);
+}
+
+/*
+==============
+Sys_Cwd
+==============
+*/
+char *Sys_Cwd( void ) {
+	static char cwd[MAX_OSPATH];
+
+	_getcwd( cwd, sizeof( cwd ) - 1 );
+	cwd[MAX_OSPATH-1] = 0;
+
+	return cwd;
+}
+
+/*
+==============
+Sys_DefaultCDPath
+==============
+*/
+char *Sys_DefaultCDPath( void ) {
+	return "";
+}
+
+/*
+==============
+Sys_DefaultBasePath
+==============
+*/
+char *Sys_DefaultBasePath( void ) {
+	return Sys_Cwd();
+}
+
+/*
+==============================================================
+
+DIRECTORY SCANNING
+
+==============================================================
+*/
+
+#define	MAX_FOUND_FILES	0x1000
+
+void Sys_ListFilteredFiles( const char *basedir, char *subdirs, char *filter, char **psList, int *numfiles ) {
+	char		search[MAX_OSPATH], newsubdirs[MAX_OSPATH];
+	char		filename[MAX_OSPATH];
+	int			findhandle;
+	struct _finddata_t findinfo;
+
+	if ( *numfiles >= MAX_FOUND_FILES - 1 ) {
+		return;
+	}
+
+	if (strlen(subdirs)) {
+		Com_sprintf( search, sizeof(search), "%s\\%s\\*", basedir, subdirs );
+	}
+	else {
+		Com_sprintf( search, sizeof(search), "%s\\*", basedir );
+	}
+
+	findhandle = _findfirst (search, &findinfo);
+	if (findhandle == -1) {
+		return;
+	}
+
+	do {
+		if (findinfo.attrib & _A_SUBDIR) {
+			if (Q_stricmp(findinfo.name, ".") && Q_stricmp(findinfo.name, "..")) {
+				if (strlen(subdirs)) {
+					Com_sprintf( newsubdirs, sizeof(newsubdirs), "%s\\%s", subdirs, findinfo.name);
+				}
+				else {
+					Com_sprintf( newsubdirs, sizeof(newsubdirs), "%s", findinfo.name);
+				}
+				Sys_ListFilteredFiles( basedir, newsubdirs, filter, psList, numfiles );
+			}
+		}
+		if ( *numfiles >= MAX_FOUND_FILES - 1 ) {
+			break;
+		}
+		Com_sprintf( filename, sizeof(filename), "%s\\%s", subdirs, findinfo.name );
+		if (!Com_FilterPath( filter, filename, qfalse ))
+			continue;
+		psList[ *numfiles ] = CopyString( filename );
+		(*numfiles)++;
+	} while ( _findnext (findhandle, &findinfo) != -1 );
+
+	_findclose (findhandle);
+}
+
+static qboolean strgtr(const char *s0, const char *s1) {
+	int l0, l1, i;
+
+	l0 = strlen(s0);
+	l1 = strlen(s1);
+
+	if (l1<l0) {
+		l0 = l1;
+	}
+
+	for(i=0;i<l0;i++) {
+		if (s1[i] > s0[i]) {
+			return qtrue;
+		}
+		if (s1[i] < s0[i]) {
+			return qfalse;
+		}
+	}
+	return qfalse;
+}
+
+char **Sys_ListFiles( const char *directory, const char *extension, char *filter, int *numfiles, qboolean wantsubs ) {
+	char		search[MAX_OSPATH];
+	int			nfiles;
+	char		**listCopy;
+	char		*list[MAX_FOUND_FILES];
+	struct _finddata_t findinfo;
+	int			findhandle;
+	int			flag;
+	int			i;
+
+	if (filter) {
+
+		nfiles = 0;
+		Sys_ListFilteredFiles( directory, "", filter, list, &nfiles );
+
+		list[ nfiles ] = 0;
+		*numfiles = nfiles;
+
+		if (!nfiles)
+			return NULL;
+
+		listCopy = (char **)Z_Malloc( ( nfiles + 1 ) * sizeof( *listCopy ), TAG_FILESYS );
+		for ( i = 0 ; i < nfiles ; i++ ) {
+			listCopy[i] = list[i];
+		}
+		listCopy[i] = NULL;
+
+		return listCopy;
+	}
+
+	if ( !extension) {
+		extension = "";
+	}
+
+	// passing a slash as extension will find directories
+	if ( extension[0] == '/' && extension[1] == 0 ) {
+		extension = "";
+		flag = 0;
+	} else {
+		flag = _A_SUBDIR;
+	}
+
+	Com_sprintf( search, sizeof(search), "%s\\*%s", directory, extension );
+
+	// search
+	nfiles = 0;
+
+	findhandle = _findfirst (search, &findinfo);
+	if (findhandle == -1) {
+		*numfiles = 0;
+		return NULL;
+	}
+
+	do {
+		if ( (!wantsubs && flag ^ ( findinfo.attrib & _A_SUBDIR )) || (wantsubs && findinfo.attrib & _A_SUBDIR) ) {
+			if ( nfiles == MAX_FOUND_FILES - 1 ) {
+				break;
+			}
+			list[ nfiles ] = CopyString( findinfo.name );
+			nfiles++;
+		}
+	} while ( _findnext (findhandle, &findinfo) != -1 );
+
+	list[ nfiles ] = 0;
+
+	_findclose (findhandle);
+
+	// return a copy of the list
+	*numfiles = nfiles;
+
+	if ( !nfiles ) {
+		return NULL;
+	}
+
+	listCopy = (char **)Z_Malloc( ( nfiles + 1 ) * sizeof( *listCopy ), TAG_FILESYS );
+	for ( i = 0 ; i < nfiles ; i++ ) {
+		listCopy[i] = list[i];
+	}
+	listCopy[i] = NULL;
+
+	do {
+		flag = 0;
+		for(i=1; i<nfiles; i++) {
+			if (strgtr(listCopy[i-1], listCopy[i])) {
+				char *temp = listCopy[i];
+				listCopy[i] = listCopy[i-1];
+				listCopy[i-1] = temp;
+				flag = 1;
+			}
+		}
+	} while(flag);
+
+	return listCopy;
+}
+
+void	Sys_FreeFileList( char **psList ) {
+	int		i;
+
+	if ( !psList ) {
+		return;
+	}
+
+	for ( i = 0 ; psList[i] ; i++ ) {
+		Z_Free( psList[i] );
+	}
+
+	Z_Free( psList );
+}
+
+//========================================================
+
+
+/*
+================
+Sys_ScanForCD
+
+Search all the drives to see if there is a valid CD to grab
+the cddir from
+================
+*/
+#ifdef FINAL_BUILD
+static qboolean Sys_ScanForCD( void ) {
+	char		drive[4];
+	FILE		*f;
+	char		test[MAX_OSPATH];
+
+	drive[0] = 'c';
+	drive[1] = ':';
+	drive[2] = '\\';
+	drive[3] = 0;
+
+	// scan the drives
+	for ( drive[0] = 'c' ; drive[0] <= 'z' ; drive[0]++ ) {
+		if ( GetDriveType (drive) == DRIVE_CDROM ) {
+			BOOL Result;
+			char VolumeName[MAX_PATH],FileSystemName[MAX_PATH];
+			DWORD VolumeSerialNumber,MaximumComponentLength,FileSystemFlags;
+			
+			Result = GetVolumeInformation(drive,VolumeName,sizeof(VolumeName),&VolumeSerialNumber,
+				&MaximumComponentLength,&FileSystemFlags,FileSystemName,sizeof(FileSystemName));
+			
+			if (Result && (strnicmp(VolumeName,CD_VOLUME,8) == 0 ) )
+			{
+				sprintf (test, "%s%s\\%s",drive, CD_BASEDIR, CD_EXE);
+				f = fopen( test, "r" );
+				if ( f ) {
+					fclose (f);
+					return qtrue;
+				} else {
+					sprintf(test, "%s%s\\%s", drive, CD_BASEDIR, CD_EXE_LINUX);
+					f = fopen( test, "r" );
+					if ( f ) {
+						fclose (f);
+						return qtrue;
+					}
+				}
+			}
+		}
+	}
+
+	return qfalse;
+}
+#endif
+/*
+================
+Sys_CheckCD
+
+Return true if the proper CD is in the drive
+================
+*/
+qboolean	Sys_CheckCD( void ) {
+#ifdef FINAL_BUILD
+	return Sys_ScanForCD();
+#else
+	return qtrue;
+#endif
+}
+
+
+/*
+================
+Sys_GetClipboardData
+
+================
+*/
+char *Sys_GetClipboardData( void ) {
+	char *data = NULL;
+	char *cliptext;
+
+	if ( OpenClipboard( NULL ) != 0 ) {
+		HANDLE hClipboardData;
+
+		if ( ( hClipboardData = GetClipboardData( CF_TEXT ) ) != 0 ) {
+			if ( ( cliptext = (char *)GlobalLock( hClipboardData ) ) != 0 ) {
+				data = (char *)Z_Malloc( GlobalSize( hClipboardData ) + 1, TAG_CLIPBOARD);
+				Q_strncpyz( data, cliptext, GlobalSize( hClipboardData )+1 );
+				GlobalUnlock( hClipboardData );
+				
+				strtok( data, "\n\r\b" );
+			}
+		}
+		CloseClipboard();
+	}
+	return data;
+}
+
+
+/*
+========================================================================
+
+LOAD/UNLOAD DLL
+
+========================================================================
+*/
+
+/*
+=================
+Sys_UnloadDll
+
+=================
+*/
+void Sys_UnloadDll( void *dllHandle ) {
+	if ( !dllHandle ) {
+		return;
+	}
+	if ( !FreeLibrary( (struct HINSTANCE__ *)dllHandle ) ) {
+		Com_Error (ERR_FATAL, "Sys_UnloadDll FreeLibrary failed");
+	}
+}
+
+//make sure the dll can be opened by the file system, then write the
+//file back out again so it can be loaded is a library. If the read
+//fails then the dll is probably not in the pk3 and we are running
+//a pure server -rww
+bool Sys_UnpackDLL(const char *name)
+{
+	void *data;
+	fileHandle_t f;
+	int len = FS_ReadFile(name, &data);
+	int ck;
+
+	if (len < 1)
+	{ //failed to read the file (out of the pk3 if pure)
+		return false;
+	}
+
+	if (FS_FileIsInPAK(name, &ck) == -1)
+	{ //alright, it isn't in a pk3 anyway, so we don't need to write it.
+		//this is allowable when running non-pure.
+		FS_FreeFile(data);
+		return true;
+	}
+
+	f = FS_FOpenFileWrite( name );
+	if ( !f )
+	{ //can't open for writing? Might be in use.
+		//This is possibly a malicious user attempt to circumvent dll
+		//replacement so we won't allow it.
+		FS_FreeFile(data);
+		return false;
+	}
+
+	if (FS_Write( data, len, f ) < len)
+	{ //Failed to write the full length. Full disk maybe?
+		FS_FreeFile(data);
+		return false;
+	}
+
+	FS_FCloseFile( f );
+	FS_FreeFile(data);
+
+	return true;
+}
+
+/*
+=================
+Sys_LoadDll
+
+Used to load a development dll instead of a virtual machine
+=================
+*/
+extern char		*FS_BuildOSPath( const char *base, const char *game, const char *qpath );
+
+void * QDECL Sys_LoadDll( const char *name, int (QDECL **entryPoint)(int, ...),
+				  int (QDECL *systemcalls)(int, ...) ) {
+	static int	lastWarning = 0;
+	HINSTANCE	libHandle;
+	void	(QDECL *dllEntry)( int (QDECL *syscallptr)(int, ...) );
+	char	*basepath;
+	char	*cdpath;
+	char	*gamedir;
+	char	*fn;
+#ifdef NDEBUG
+	int		timestamp;
+  int   ret;
+#endif
+	char	filename[MAX_QPATH];
+
+	Com_sprintf( filename, sizeof( filename ), "%sx86.dll", name );
+
+#ifdef NDEBUG
+	timestamp = Sys_Milliseconds();
+//	if( ((timestamp - lastWarning) > (5 * 60000)) && !Cvar_VariableIntegerValue( "dedicated" )
+//		&& !Cvar_VariableIntegerValue( "com_blindlyLoadDLLs" ) ) {
+	if (0) {
+		if (FS_FileExists(filename)) {
+			lastWarning = timestamp;
+			ret = MessageBoxEx( NULL, "You are about to load a .DLL executable that\n"
+				  "has not been verified for use with Quake III Arena.\n"
+				  "This type of file can compromise the security of\n"
+				  "your computer.\n\n"
+				  "Select 'OK' if you choose to load it anyway.",
+				  "Security Warning", MB_OKCANCEL | MB_ICONEXCLAMATION | MB_DEFBUTTON2 | MB_TOPMOST | MB_SETFOREGROUND,
+				  MAKELANGID( LANG_NEUTRAL, SUBLANG_DEFAULT ) );
+			if( ret != IDOK ) {
+				return NULL;
+			}
+		}
+	}
+#endif
+
+	if (!Sys_UnpackDLL(filename))
+	{
+		return NULL;
+	}
+
+// rjr disable for final release #ifndef NDEBUG
+	libHandle = LoadLibrary( filename );
+	if ( !libHandle ) {
+//#endif
+	basepath = Cvar_VariableString( "fs_basepath" );
+	cdpath = Cvar_VariableString( "fs_cdpath" );
+	gamedir = Cvar_VariableString( "fs_game" );
+
+	fn = FS_BuildOSPath( basepath, gamedir, filename );
+	libHandle = LoadLibrary( fn );
+
+	if ( !libHandle ) {
+		if( cdpath[0] ) {
+			fn = FS_BuildOSPath( cdpath, gamedir, filename );
+			libHandle = LoadLibrary( fn );
+		}
+
+		if ( !libHandle ) {
+			return NULL;
+		}
+	}
+//#ifndef NDEBUG
+	}
+//#endif
+
+	dllEntry = ( void (QDECL *)( int (QDECL *)( int, ... ) ) )GetProcAddress( libHandle, "dllEntry" ); 
+	*entryPoint = (int (QDECL *)(int,...))GetProcAddress( libHandle, "vmMain" );
+	if ( !*entryPoint || !dllEntry ) {
+		FreeLibrary( libHandle );
+		return NULL;
+	}
+	dllEntry( systemcalls );
+
+	return libHandle;
+}
+
+
+/*
+========================================================================
+
+BACKGROUND FILE STREAMING
+
+========================================================================
+*/
+
+#if 1
+
+void Sys_InitStreamThread( void ) {
+}
+
+void Sys_ShutdownStreamThread( void ) {
+}
+
+void Sys_BeginStreamedFile( fileHandle_t f, int readAhead ) {
+}
+
+void Sys_EndStreamedFile( fileHandle_t f ) {
+}
+
+int Sys_StreamedRead( void *buffer, int size, int count, fileHandle_t f ) {
+   return FS_Read( buffer, size * count, f );
+}
+
+void Sys_StreamSeek( fileHandle_t f, int offset, int origin ) {
+   FS_Seek( f, offset, origin );
+}
+
+
+#else
+
+typedef struct {
+	fileHandle_t	file;
+	byte	*buffer;
+	qboolean	eof;
+	qboolean	active;
+	int		bufferSize;
+	int		streamPosition;	// next byte to be returned by Sys_StreamRead
+	int		threadPosition;	// next byte to be read from file
+} streamsIO_t;
+
+typedef struct {
+	HANDLE				threadHandle;
+	int					threadId;
+	CRITICAL_SECTION	crit;
+	streamsIO_t			sIO[MAX_FILE_HANDLES];
+} streamState_t;
+
+streamState_t	stream;
+
+/*
+===============
+Sys_StreamThread
+
+A thread will be sitting in this loop forever
+================
+*/
+void Sys_StreamThread( void ) {
+	int		buffer;
+	int		count;
+	int		readCount;
+	int		bufferPoint;
+	int		r, i;
+
+	while (1) {
+		Sleep( 10 );
+//		EnterCriticalSection (&stream.crit);
+
+		for (i=1;i<MAX_FILE_HANDLES;i++) {
+			// if there is any space left in the buffer, fill it up
+			if ( stream.sIO[i].active  && !stream.sIO[i].eof ) {
+				count = stream.sIO[i].bufferSize - (stream.sIO[i].threadPosition - stream.sIO[i].streamPosition);
+				if ( !count ) {
+					continue;
+				}
+
+				bufferPoint = stream.sIO[i].threadPosition % stream.sIO[i].bufferSize;
+				buffer = stream.sIO[i].bufferSize - bufferPoint;
+				readCount = buffer < count ? buffer : count;
+
+				r = FS_Read( stream.sIO[i].buffer + bufferPoint, readCount, stream.sIO[i].file );
+				stream.sIO[i].threadPosition += r;
+
+				if ( r != readCount ) {
+					stream.sIO[i].eof = qtrue;
+				}
+			}
+		}
+//		LeaveCriticalSection (&stream.crit);
+	}
+}
+
+/*
+===============
+Sys_InitStreamThread
+
+================
+*/
+void Sys_InitStreamThread( void ) {
+	int i;
+
+	InitializeCriticalSection ( &stream.crit );
+
+	// don't leave the critical section until there is a
+	// valid file to stream, which will cause the StreamThread
+	// to sleep without any overhead
+//	EnterCriticalSection( &stream.crit );
+
+	stream.threadHandle = CreateThread(
+	   NULL,	// LPSECURITY_ATTRIBUTES lpsa,
+	   0,		// DWORD cbStack,
+	   (LPTHREAD_START_ROUTINE)Sys_StreamThread,	// LPTHREAD_START_ROUTINE lpStartAddr,
+	   0,			// LPVOID lpvThreadParm,
+	   0,			//   DWORD fdwCreate,
+	   &stream.threadId);
+	for(i=0;i<MAX_FILE_HANDLES;i++) {
+		stream.sIO[i].active = qfalse;
+	}
+}
+
+/*
+===============
+Sys_ShutdownStreamThread
+
+================
+*/
+void Sys_ShutdownStreamThread( void ) {
+}
+
+
+/*
+===============
+Sys_BeginStreamedFile
+
+================
+*/
+void Sys_BeginStreamedFile( fileHandle_t f, int readAhead ) {
+	if ( stream.sIO[f].file ) {
+		Sys_EndStreamedFile( stream.sIO[f].file );
+	}
+
+	stream.sIO[f].file = f;
+	stream.sIO[f].buffer = Z_Malloc( readAhead );
+	stream.sIO[f].bufferSize = readAhead;
+	stream.sIO[f].streamPosition = 0;
+	stream.sIO[f].threadPosition = 0;
+	stream.sIO[f].eof = qfalse;
+	stream.sIO[f].active = qtrue;
+
+	// let the thread start running
+//	LeaveCriticalSection( &stream.crit );
+}
+
+/*
+===============
+Sys_EndStreamedFile
+
+================
+*/
+void Sys_EndStreamedFile( fileHandle_t f ) {
+	if ( f != stream.sIO[f].file ) {
+		Com_Error( ERR_FATAL, "Sys_EndStreamedFile: wrong file");
+	}
+	// don't leave critical section until another stream is started
+	EnterCriticalSection( &stream.crit );
+
+	stream.sIO[f].file = 0;
+	stream.sIO[f].active = qfalse;
+
+	Z_Free( stream.sIO[f].buffer );
+
+	LeaveCriticalSection( &stream.crit );
+}
+
+
+/*
+===============
+Sys_StreamedRead
+
+================
+*/
+int Sys_StreamedRead( void *buffer, int size, int count, fileHandle_t f ) {
+	int		available;
+	int		remaining;
+	int		sleepCount;
+	int		copy;
+	int		bufferCount;
+	int		bufferPoint;
+	byte	*dest;
+
+	if (stream.sIO[f].active == qfalse) {
+		Com_Error( ERR_FATAL, "Streamed read with non-streaming file" );
+	}
+
+	dest = (byte *)buffer;
+	remaining = size * count;
+
+	if ( remaining <= 0 ) {
+		Com_Error( ERR_FATAL, "Streamed read with non-positive size" );
+	}
+
+	sleepCount = 0;
+	while ( remaining > 0 ) {
+		available = stream.sIO[f].threadPosition - stream.sIO[f].streamPosition;
+		if ( !available ) {
+			if ( stream.sIO[f].eof ) {
+				break;
+			}
+			if ( sleepCount == 1 ) {
+				Com_DPrintf( "Sys_StreamedRead: waiting\n" );
+			}
+			if ( ++sleepCount > 100 ) {
+				Com_Error( ERR_FATAL, "Sys_StreamedRead: thread has died");
+			}
+			Sleep( 10 );
+			continue;
+		}
+
+		EnterCriticalSection( &stream.crit );
+
+		bufferPoint = stream.sIO[f].streamPosition % stream.sIO[f].bufferSize;
+		bufferCount = stream.sIO[f].bufferSize - bufferPoint;
+
+		copy = available < bufferCount ? available : bufferCount;
+		if ( copy > remaining ) {
+			copy = remaining;
+		}
+		memcpy( dest, stream.sIO[f].buffer + bufferPoint, copy );
+		stream.sIO[f].streamPosition += copy;
+		dest += copy;
+		remaining -= copy;
+
+		LeaveCriticalSection( &stream.crit );
+	}
+
+	return (count * size - remaining) / size;
+}
+
+/*
+===============
+Sys_StreamSeek
+
+================
+*/
+void Sys_StreamSeek( fileHandle_t f, int offset, int origin ) {
+
+	// halt the thread
+	EnterCriticalSection( &stream.crit );
+
+	// clear to that point
+	FS_Seek( f, offset, origin );
+	stream.sIO[f].streamPosition = 0;
+	stream.sIO[f].threadPosition = 0;
+	stream.sIO[f].eof = qfalse;
+
+	// let the thread start running at the new position
+	LeaveCriticalSection( &stream.crit );
+}
+
+#endif
+
+/*
+========================================================================
+
+EVENT LOOP
+
+========================================================================
+*/
+
+#define	MAX_QUED_EVENTS		256
+#define	MASK_QUED_EVENTS	( MAX_QUED_EVENTS - 1 )
+
+sysEvent_t	eventQue[MAX_QUED_EVENTS];
+int			eventHead, eventTail;
+byte		sys_packetReceived[MAX_MSGLEN];
+
+/*
+================
+Sys_QueEvent
+
+A time of 0 will get the current time
+Ptr should either be null, or point to a block of data that can
+be freed by the game later.
+================
+*/
+void Sys_QueEvent( int time, sysEventType_t type, int value, int value2, int ptrLength, void *ptr ) {
+	sysEvent_t	*ev;
+
+	ev = &eventQue[ eventHead & MASK_QUED_EVENTS ];
+	if ( eventHead - eventTail >= MAX_QUED_EVENTS ) {
+		Com_Printf("Sys_QueEvent: overflow\n");
+		// we are discarding an event, but don't leak memory
+		if ( ev->evPtr ) {
+			Z_Free( ev->evPtr );
+		}
+		eventTail++;
+	}
+
+	eventHead++;
+
+	if ( time == 0 ) {
+		time = Sys_Milliseconds();
+	}
+
+	ev->evTime = time;
+	ev->evType = type;
+	ev->evValue = value;
+	ev->evValue2 = value2;
+	ev->evPtrLength = ptrLength;
+	ev->evPtr = ptr;
+}
+
+/*
+================
+Sys_GetEvent
+
+================
+*/
+sysEvent_t Sys_GetEvent( void ) {
+    MSG			msg;
+	sysEvent_t	ev;
+	char		*s;
+	msg_t		netmsg;
+	netadr_t	adr;
+
+	// return if we have data
+	if ( eventHead > eventTail ) {
+		eventTail++;
+		return eventQue[ ( eventTail - 1 ) & MASK_QUED_EVENTS ];
+	}
+
+	// pump the message loop
+	while (PeekMessage (&msg, NULL, 0, 0, PM_NOREMOVE)) {
+		if ( !GetMessage (&msg, NULL, 0, 0) ) {
+			Com_Quit_f();
+		}
+
+		// save the msg time, because wndprocs don't have access to the timestamp
+		g_wv.sysMsgTime = msg.time;
+
+		TranslateMessage (&msg);
+      	DispatchMessage (&msg);
+	}
+
+	// check for console commands
+	s = Sys_ConsoleInput();
+	if ( s ) {
+		char	*b;
+		int		len;
+
+		len = strlen( s ) + 1;
+		b = (char *)Z_Malloc( len, TAG_EVENT );
+		Q_strncpyz( b, s, len );
+		Sys_QueEvent( 0, SE_CONSOLE, 0, 0, len, b );
+	}
+
+	// check for network packets
+	MSG_Init( &netmsg, sys_packetReceived, sizeof( sys_packetReceived ) );
+	if ( Sys_GetPacket ( &adr, &netmsg ) ) {
+		netadr_t		*buf;
+		int				len;
+
+		// copy out to a seperate buffer for qeueing
+		// the readcount stepahead is for SOCKS support
+		len = sizeof( netadr_t ) + netmsg.cursize - netmsg.readcount;
+		buf = (netadr_t *)Z_Malloc( len, TAG_EVENT, qtrue );
+		*buf = adr;
+		memcpy( buf+1, &netmsg.data[netmsg.readcount], netmsg.cursize - netmsg.readcount );
+		Sys_QueEvent( 0, SE_PACKET, 0, 0, len, buf );
+	}
+
+	// return if we have data
+	if ( eventHead > eventTail ) {
+		eventTail++;
+		return eventQue[ ( eventTail - 1 ) & MASK_QUED_EVENTS ];
+	}
+
+	// create an empty event to return
+
+	memset( &ev, 0, sizeof( ev ) );
+	ev.evTime = timeGetTime();
+
+	return ev;
+}
+
+//================================================================
+
+/*
+=================
+Sys_In_Restart_f
+
+Restart the input subsystem
+=================
+*/
+void Sys_In_Restart_f( void ) {
+	IN_Shutdown();
+	IN_Init();
+}
+
+
+/*
+=================
+Sys_Net_Restart_f
+
+Restart the network subsystem
+=================
+*/
+void Sys_Net_Restart_f( void ) {
+	NET_Restart();
+}
+
+static bool Sys_IsExpired()
+{
+#if 0
+//							  sec min Hr Day Mon Yr
+    struct tm t_valid_start	= { 0, 0, 8, 5, 8, 103 };	//zero based months!
+//							  sec min Hr Day Mon Yr
+    struct tm t_valid_end	= { 0, 0, 20, 13, 8, 103 };
+//    struct tm t_valid_end	= t_valid_start;
+//	t_valid_end.tm_mday += 8;
+	time_t startTime  = mktime( &t_valid_start);
+	time_t expireTime = mktime( &t_valid_end);
+	time_t now;
+	time(&now);
+	if((now < startTime) || (now> expireTime))
+	{
+		return true;
+	}
+#endif
+	return false;
+}
+
+/*
+================
+Sys_Init
+
+Called after the common systems (cvars, files, etc)
+are initialized
+================
+*/
+#define OSR2_BUILD_NUMBER 1111
+#define WIN98_BUILD_NUMBER 1998
+
+void Sys_Init( void ) {
+	int cpuid;
+
+	// make sure the timer is high precision, otherwise
+	// NT gets 18ms resolution
+	timeBeginPeriod( 1 );
+
+	Cmd_AddCommand ("in_restart", Sys_In_Restart_f);
+	Cmd_AddCommand ("net_restart", Sys_Net_Restart_f);
+
+	g_wv.osversion.dwOSVersionInfoSize = sizeof( g_wv.osversion );
+
+	if (!GetVersionEx (&g_wv.osversion))
+		Sys_Error ("Couldn't get OS info");
+	if (Sys_IsExpired()) {
+		g_wv.osversion.dwPlatformId = VER_PLATFORM_WIN32s;	//sneaky: hide the expire with this error
+	}
+
+	if (g_wv.osversion.dwMajorVersion < 4)
+		Sys_Error ("This game requires Windows version 4 or greater");
+	if (g_wv.osversion.dwPlatformId == VER_PLATFORM_WIN32s)
+		Sys_Error ("This game doesn't run on Win32s");
+
+	if ( g_wv.osversion.dwPlatformId == VER_PLATFORM_WIN32_NT )
+	{
+		Cvar_Set( "arch", "winnt" );
+	}
+	else if ( g_wv.osversion.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS )
+	{
+		if ( LOWORD( g_wv.osversion.dwBuildNumber ) >= WIN98_BUILD_NUMBER )
+		{
+			Cvar_Set( "arch", "win98" );
+		}
+		else if ( LOWORD( g_wv.osversion.dwBuildNumber ) >= OSR2_BUILD_NUMBER )
+		{
+			Cvar_Set( "arch", "win95 osr2.x" );
+		}
+		else
+		{
+			Cvar_Set( "arch", "win95" );
+		}
+	}
+	else
+	{
+		Cvar_Set( "arch", "unknown Windows variant" );
+	}
+
+	// save out a couple things in rom cvars for the renderer to access
+	Cvar_Get( "win_hinstance", va("%i", (int)g_wv.hInstance), CVAR_ROM );
+	Cvar_Get( "win_wndproc", va("%i", (int)MainWndProc), CVAR_ROM );
+
+	//
+	// figure out our CPU
+	//
+	Cvar_Get( "sys_cpustring", "detect", CVAR_ROM );
+	if ( !Q_stricmp( Cvar_VariableString( "sys_cpustring"), "detect" ) )
+	{
+		Com_Printf( "...detecting CPU, found " );
+
+		cpuid = Sys_GetProcessorId();
+
+		switch ( cpuid )
+		{
+		case CPUID_GENERIC:
+			Cvar_Set( "sys_cpustring", "generic" );
+			break;
+		case CPUID_INTEL_UNSUPPORTED:
+			Cvar_Set( "sys_cpustring", "x86 (pre-Pentium)" );
+			break;
+		case CPUID_INTEL_PENTIUM:
+			Cvar_Set( "sys_cpustring", "x86 (P5/PPro, non-MMX)" );
+			break;
+		case CPUID_INTEL_MMX:
+			Cvar_Set( "sys_cpustring", "x86 (P5/Pentium2, MMX)" );
+			break;
+		case CPUID_INTEL_KATMAI:
+			Cvar_Set( "sys_cpustring", "Intel Pentium III" );
+			break;
+		case CPUID_INTEL_WILLIAMETTE:
+			Cvar_Set( "sys_cpustring", "Intel Pentium IV" );
+			break;
+		case CPUID_AMD_3DNOW:
+			Cvar_Set( "sys_cpustring", "AMD w/ 3DNow!" );
+			break;
+		case CPUID_AXP:
+			Cvar_Set( "sys_cpustring", "Alpha AXP" );
+			break;
+		default:
+			Com_Error( ERR_FATAL, "Unknown cpu type %d\n", cpuid );
+			break;
+		}
+	}
+	else
+	{
+		Com_Printf( "...forcing CPU type to " );
+		if ( !Q_stricmp( Cvar_VariableString( "sys_cpustring" ), "generic" ) )
+		{
+			cpuid = CPUID_GENERIC;
+		}
+		else if ( !Q_stricmp( Cvar_VariableString( "sys_cpustring" ), "x87" ) )
+		{
+			cpuid = CPUID_INTEL_PENTIUM;
+		}
+		else if ( !Q_stricmp( Cvar_VariableString( "sys_cpustring" ), "mmx" ) )
+		{
+			cpuid = CPUID_INTEL_MMX;
+		}
+		else if ( !Q_stricmp( Cvar_VariableString( "sys_cpustring" ), "3dnow" ) )
+		{
+			cpuid = CPUID_AMD_3DNOW;
+		}
+		else if ( !Q_stricmp( Cvar_VariableString( "sys_cpustring" ), "PentiumIII" ) )
+		{
+			cpuid = CPUID_INTEL_KATMAI;
+		}
+		else if ( !Q_stricmp( Cvar_VariableString( "sys_cpustring" ), "PentiumIV" ) )
+		{
+			cpuid = CPUID_INTEL_WILLIAMETTE;
+		}
+		else if ( !Q_stricmp( Cvar_VariableString( "sys_cpustring" ), "axp" ) )
+		{
+			cpuid = CPUID_AXP;
+		}
+		else
+		{
+			Com_Printf( "WARNING: unknown sys_cpustring '%s'\n", Cvar_VariableString( "sys_cpustring" ) );
+			cpuid = CPUID_GENERIC;
+		}
+	}
+	Cvar_SetValue( "sys_cpuid", cpuid );
+	Com_Printf( "%s\n", Cvar_VariableString( "sys_cpustring" ) );
+
+	Cvar_Set( "username", Sys_GetCurrentUser() );
+	Cvar_SetValue( "sys_cpuspeed", Sys_GetCPUSpeed() );
+	Cvar_SetValue( "sys_memory", Sys_GetPhysicalMemory() );
+
+	IN_Init();		// FIXME: not in dedicated?
+}
+
+// do a quick mem test to check for any potential future mem problems...
+//
+void QuickMemTest(void)
+{
+//	if (!Sys_LowPhysicalMemory())
+	{
+		const int iMemTestMegs = 128;	// useful search label
+		// special test, 
+		void *pvData = malloc(iMemTestMegs * 1024 * 1024);
+		if (pvData)
+		{
+			free(pvData);
+		}
+		else
+		{
+			// err...
+			//
+			extern qboolean Language_IsAsian(void);
+			LPCSTR psContinue = Language_IsAsian() ? 
+								"Your machine failed to allocate %dMB in a memory test, which may mean you'll have problems running this game all the way through.\n\nContinue anyway?"
+								: 
+								SE_GetString("CON_TEXT_FAILED_MEMTEST");
+								// ( since it's too much hassle doing MBCS code pages and decodings etc for MessageBox command )
+
+			#define GetYesNo(psQuery)	(!!(MessageBox(NULL,psQuery,"Query",MB_YESNO|MB_ICONWARNING|MB_TASKMODAL)==IDYES))
+			if (!GetYesNo(va(psContinue,iMemTestMegs)))
+			{
+				LPCSTR psNoMem = Language_IsAsian() ?
+								"Insufficient memory to run this game!\n"
+								:
+								SE_GetString("CON_TEXT_INSUFFICIENT_MEMORY");
+								// ( since it's too much hassle doing MBCS code pages and decodings etc for MessageBox command )
+
+				Com_Error( ERR_FATAL, psNoMem );
+			}
+		}
+	}
+}
+
+
+//=======================================================================
+//int	totalMsec, countMsec;
+
+/*
+==================
+WinMain
+
+==================
+*/
+int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow) {
+//	int			startTime, endTime;
+
+    // should never get a previous instance in Win32
+    if ( hPrevInstance ) {
+        return 0;
+	}
+
+	sys_checksum = Sys_CodeInMemoryChecksum( hInstance );
+	Sys_VerifyCodeChecksum( hInstance );
+
+	g_wv.hInstance = hInstance;
+	Q_strncpyz( sys_cmdline, lpCmdLine, sizeof( sys_cmdline ) );
+
+	// done before Com/Sys_Init since we need this for error output
+	Sys_CreateConsole();
+
+	// no abort/retry/fail errors
+	SetErrorMode( SEM_FAILCRITICALERRORS );
+
+	// get the initial time base
+	Sys_Milliseconds();
+
+#if 0
+	// if we find the CD, add a +set cddir xxx command line
+	Sys_ScanForCD();
+#endif
+
+
+	Sys_InitStreamThread();
+
+	Com_Init( sys_cmdline );
+
+#if !defined(DEDICATED)
+		QuickMemTest();
+#endif
+
+	NET_Init();
+
+	// hide the early console since we've reached the point where we
+	// have a working graphics subsystems
+	if ( !com_dedicated->integer && !com_viewlog->integer ) {
+		Sys_ShowConsole( 0, qfalse );
+	}
+
+#ifdef _DEBUG
+	if ( sys_monkeySpank ) {
+		Cvar_Set("cl_trn", "666");
+	}
+#endif
+
+    // main game loop
+	while( 1 ) {
+		// if not running as a game client, sleep a bit
+		if ( g_wv.isMinimized || ( com_dedicated && com_dedicated->integer ) ) {
+			Sleep( 5 );
+		}
+
+#ifdef _DEBUG
+		if (!g_wv.activeApp)
+		{
+			Sleep(50);
+		}
+#endif // _DEBUG
+
+		// set low precision every frame, because some system calls
+		// reset it arbitrarily
+//		_controlfp( _PC_24, _MCW_PC );
+ 
+//		startTime = Sys_Milliseconds();
+
+		// make sure mouse and joystick are only called once a frame
+		IN_Frame();
+
+		// run the game
+		Com_Frame();
+
+//		endTime = Sys_Milliseconds();
+//		totalMsec += endTime - startTime;
+//		countMsec++;
+	}
+
+	// never gets here
+}
+
+
diff --git a/codemp/win32/win_main_common.cpp b/codemp/win32/win_main_common.cpp
new file mode 100644
index 0000000..cab696a
--- /dev/null
+++ b/codemp/win32/win_main_common.cpp
@@ -0,0 +1,331 @@
+// win_main.h
+
+#include "../qcommon/qcommon.h"
+#include "../client/client.h"
+#include "win_local.h"
+#include "resource.h"
+
+#ifndef _GAMECUBE
+#include <errno.h>
+#include <float.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <direct.h>
+#include <io.h>
+#include <conio.h>
+#endif
+
+
+
+//#define SPANK_MONKEYS	//----(SA)	commented out for running net developer release builds
+int	sys_monkeySpank;
+
+
+/*
+==================
+Sys_MonkeyShouldBeSpanked
+==================
+*/
+int Sys_MonkeyShouldBeSpanked( void ) {
+	return sys_monkeySpank;
+}
+
+
+
+
+/*
+==================
+Sys_FunctionCmp
+==================
+*/
+int Sys_FunctionCmp(void *f1, void *f2) {
+
+	int i, j, l;
+	byte func_end[32] = {0xC3, 0x90, 0x90, 0x00};
+	byte *ptr, *ptr2;
+	byte *f1_ptr, *f2_ptr;
+
+	ptr = (byte *) f1;
+	if (*(byte *)ptr == 0xE9) {
+		//Com_Printf("f1 %p1 jmp %d\n", (int *) f1, *(int*)(ptr+1));
+		f1_ptr = (byte*)(((byte*)f1) + (*(int *)(ptr+1)) + 5);
+	}
+	else {
+		f1_ptr = ptr;
+	}
+	//Com_Printf("f1 ptr %p\n", f1_ptr);
+
+	ptr = (byte *) f2;
+	if (*(byte *)ptr == 0xE9) {
+		//Com_Printf("f2 %p jmp %d\n", (int *) f2, *(int*)(ptr+1));
+		f2_ptr = (byte*)(((byte*)f2) + (*(int *)(ptr+1)) + 5);
+	}
+	else {
+		f2_ptr = ptr;
+	}
+	//Com_Printf("f2 ptr %p\n", f2_ptr);
+
+#ifdef _DEBUG
+	sprintf((char *)func_end, "%c%c%c%c%c%c%c", 0x5F, 0x5E, 0x5B, 0x8B, 0xE5, 0x5D, 0xC3);
+#endif
+	for (i = 0; i < 1024; i++) {
+		for (j = 0; func_end[j]; j++) {
+			if (f1_ptr[i+j] != func_end[j])
+				break;
+		}
+		if (!func_end[j]) {
+			break;
+		}
+	}
+#ifdef _DEBUG
+	l = i + 7;
+#else
+	l = i + 2;
+#endif
+	//Com_Printf("function length = %d\n", l);
+
+	for (i = 0; i < l; i++) {
+		// check for a potential function call
+		if (*((byte *) &f1_ptr[i]) == 0xE8) {
+			// get the function pointers in case this really is a function call
+			ptr = (byte *) (((byte *) &f1_ptr[i]) + (*(int *) &f1_ptr[i+1])) + 5;
+			ptr2 = (byte *) (((byte *) &f2_ptr[i]) + (*(int *) &f2_ptr[i+1])) + 5;
+			// if it was a function call and both f1 and f2 call the same function
+			if (ptr == ptr2) {
+				i += 4;
+				continue;
+			}
+		}
+		if (f1_ptr[i] != f2_ptr[i])
+			return qfalse;
+	}
+	return qtrue;
+}
+
+/*
+==================
+Sys_FunctionCheckSum
+==================
+*/
+int Sys_FunctionCheckSum(void *f1) {
+
+	int i, j, l;
+	unsigned shermcrap;
+	byte func_end[32] = {0xC3, 0x90, 0x90, 0x00};
+	byte *ptr;
+	byte *f1_ptr;
+
+	ptr = (byte *) f1;
+	if (*(byte *)ptr == 0xE9) {
+		//Com_Printf("f1 %p1 jmp %d\n", (int *) f1, *(int*)(ptr+1));
+		f1_ptr = (byte*)(((byte*)f1) + (*(int *)(ptr+1)) + 5);
+	}
+	else {
+		f1_ptr = ptr;
+	}
+	//Com_Printf("f1 ptr %p\n", f1_ptr);
+
+#ifdef _DEBUG
+	sprintf((char *)func_end, "%c%c%c%c%c%c%c", 0x5F, 0x5E, 0x5B, 0x8B, 0xE5, 0x5D, 0xC3);
+#endif
+	for (i = 0; i < 1024; i++) {
+		for (j = 0; func_end[j]; j++) {
+			if (f1_ptr[i+j] != func_end[j])
+				break;
+		}
+		if (!func_end[j]) {
+			break;
+		}
+	}
+#ifdef _DEBUG
+	l = i + 7;
+#else
+	l = i + 2;
+#endif
+	//Com_Printf("function length = %d\n", l);
+	shermcrap = Com_BlockChecksum( f1_ptr, l );
+	return (int)shermcrap;
+}
+
+
+//NOTE TTimo: heavily NON PORTABLE, PLZ DON'T USE
+//  https://zerowing.idsoftware.com/bugzilla/show_bug.cgi?id=447
+#if 0
+//----(SA) added
+/*
+==============
+Sys_ShellExecute
+
+-	Windows only
+
+	Performs an operation on a specified file. 
+
+	See info on ShellExecute() for details
+  
+==============
+*/
+int Sys_ShellExecute(char *op, char *file, qboolean doexit, char *params, char *dir ) {
+	unsigned int retval;
+	char *se_op;
+	
+	// set default operation to "open"
+	if(op)	se_op = op;
+	else	se_op = "open";
+
+
+	// probably need to protect this some in the future so people have
+	// less chance of system invasion with this powerful interface
+	// (okay, not so invasive, but could be annoying/rude)
+
+
+	retval = (UINT)ShellExecute(NULL, se_op, file, params, dir, SW_NORMAL);	// only option forced by game is 'sw_normal'
+	
+	if( retval <= 32) {	// ERROR
+		Com_DPrintf("Sys_ShellExecuteERROR: %d\n", retval);
+		return retval;
+	}
+
+	if ( doexit ) {
+		// (SA) this works better for exiting cleanly...
+		Cbuf_ExecuteText( EXEC_APPEND, "quit" );
+	}
+
+	return 999;	// success
+}
+//----(SA) end
+#endif
+
+/*
+==================
+Sys_BeginProfiling
+==================
+*/
+void Sys_BeginProfiling( void ) {
+	// this is just used on the mac build
+}
+
+
+
+
+
+/*
+==============
+Sys_DefaultCDPath
+==============
+*/
+char *Sys_DefaultCDPath( void ) {
+	return "";
+}
+
+/*
+==============
+Sys_DefaultBasePath
+==============
+*/
+char *Sys_DefaultBasePath( void ) {
+	return Sys_Cwd();
+}
+
+
+
+
+/*
+========================================================================
+
+EVENT LOOP
+
+========================================================================
+*/
+
+
+sysEvent_t	eventQue[MAX_QUED_EVENTS];
+int			eventHead, eventTail;
+byte		sys_packetReceived[MAX_MSGLEN];
+
+/*
+================
+Sys_QueEvent
+
+A time of 0 will get the current time
+Ptr should either be null, or point to a block of data that can
+be freed by the game later.
+================
+*/
+void Sys_QueEvent( int time, sysEventType_t type, int value, int value2, int ptrLength, void *ptr ) {
+	sysEvent_t	*ev;
+
+	ev = &eventQue[ eventHead & MASK_QUED_EVENTS ];
+	if ( eventHead - eventTail >= MAX_QUED_EVENTS ) {
+		Com_Printf("Sys_QueEvent: overflow\n");
+		// we are discarding an event, but don't leak memory
+		if ( ev->evPtr ) {
+			Z_Free( ev->evPtr );
+		}
+		eventTail++;
+	}
+
+	eventHead++;
+
+	if ( time == 0 ) {
+		time = Sys_Milliseconds();
+	}
+
+	ev->evTime = time;
+	ev->evType = type;
+	ev->evValue = value;
+	ev->evValue2 = value2;
+	ev->evPtrLength = ptrLength;
+	ev->evPtr = ptr;
+}
+
+
+//================================================================
+
+
+/*
+=================
+Sys_Net_Restart_f
+
+Restart the network subsystem
+=================
+*/
+void Sys_Net_Restart_f( void ) {
+//	NET_Restart();
+}
+
+
+
+//=======================================================================
+
+
+void Sys_InitStreamThread( void ) {
+}
+
+void Sys_ShutdownStreamThread( void ) {
+}
+
+void Sys_BeginStreamedFile( fileHandle_t f, int readAhead ) {
+}
+
+void Sys_EndStreamedFile( fileHandle_t f ) {
+}
+
+int Sys_StreamedRead( void *buffer, int size, int count, fileHandle_t f ) {
+   return FS_Read( buffer, size * count, f );
+}
+
+void Sys_StreamSeek( fileHandle_t f, int offset, int origin ) {
+   FS_Seek( f, offset, origin );
+}
+
+
+void *Sys_InitializeCriticalSection() {
+	return (void*)-1;
+}
+
+void Sys_EnterCriticalSection(void *ptr) {
+}
+
+void Sys_LeaveCriticalSection(void *ptr) {
+}
+
diff --git a/codemp/win32/win_main_console.cpp b/codemp/win32/win_main_console.cpp
new file mode 100644
index 0000000..147fa5e
--- /dev/null
+++ b/codemp/win32/win_main_console.cpp
@@ -0,0 +1,615 @@
+#include "../qcommon/qcommon.h"
+#include "../client/client.h"
+#include "win_local.h"
+#include "resource.h"
+#include <float.h>
+#include <stdio.h>
+#include "../game/g_public.h"
+#include "../xbox/XBLive.h"
+
+#ifdef _XBOX
+#include <IO.h>
+#define NEWDECL __cdecl
+
+#ifndef FINAL_BUILD
+#include "dbg_console_xbox.h"
+#endif
+
+#endif
+
+extern int eventHead, eventTail;
+extern sysEvent_t eventQue[MAX_QUED_EVENTS];
+extern byte		sys_packetReceived[MAX_MSGLEN];
+
+void *NEWDECL operator new(size_t size)
+{
+	return Z_Malloc(size, TAG_NEWDEL, qfalse);
+}
+
+
+void *NEWDECL operator new[](size_t size)
+{
+	return Z_Malloc(size, TAG_NEWDEL, qfalse);
+}
+
+
+void NEWDECL operator delete[](void *ptr)
+{
+	if (ptr)
+		Z_Free(ptr);
+}
+
+
+void NEWDECL operator delete(void *ptr)
+{
+	if (ptr)
+		Z_Free(ptr);
+}
+
+/*
+================
+Sys_Init
+
+Called after the common systems (cvars, files, etc)
+are initialized
+================
+*/
+extern void Sys_In_Restart_f(void);
+extern void Sys_Net_Restart_f(void);
+void Sys_Init( void ) 
+{
+	Cmd_AddCommand ("in_restart", Sys_In_Restart_f);
+	Cmd_AddCommand ("net_restart", Sys_Net_Restart_f);
+}
+
+
+
+
+char *Sys_Cwd( void ) {
+	static char cwd[MAX_OSPATH];
+
+#ifdef _XBOX
+	strcpy(cwd, "d:");
+#endif
+
+#ifdef _GAMECUBE
+	strcpy(cwd, ".");
+#endif
+
+	return cwd;
+}
+
+/*
+=================
+Sys_In_Restart_f
+
+Restart the input subsystem
+=================
+*/
+void Sys_In_Restart_f( void ) {
+}
+
+
+
+/*
+=============
+Sys_Error
+
+Show the early console as an error dialog
+=============
+*/
+void Sys_Error( const char *error, ... ) {
+        va_list                argptr;
+        char                text[256];
+
+        va_start (argptr, error);
+        vsprintf (text, error, argptr);
+        va_end (argptr);
+
+#ifdef _GAMECUBE
+        printf(text);
+#else
+        OutputDebugString(text);
+#endif
+
+#if 0 // UN-PORT
+        Com_ShutdownZoneMemory();
+        Com_ShutdownHunkMemory();
+#endif
+
+        exit (1);
+}
+
+
+/*
+================
+Sys_GetEvent
+
+================
+*/
+#define MAX_POLL_RATE	15
+sysEvent_t Sys_GetEvent( void ) {
+    sysEvent_t        ev;
+
+    // return if we have data
+    if ( eventHead > eventTail ) {
+            eventTail++;
+            return eventQue[ ( eventTail - 1 ) & MASK_QUED_EVENTS ];
+    }
+
+    // check for network packets
+	msg_t                netmsg;
+	netadr_t	adr;
+
+	for (int poll = 0; poll < MAX_POLL_RATE; ++poll)
+	{
+		MSG_Init( &netmsg, sys_packetReceived, sizeof( sys_packetReceived ) );
+		if ( Sys_GetPacket ( &adr, &netmsg ) ) {
+			netadr_t		*buf;
+			int				len;
+
+			// copy out to a seperate buffer for qeueing
+			// the readcount stepahead is for SOCKS support
+			len = sizeof( netadr_t ) + netmsg.cursize - netmsg.readcount;
+			//buf = (netadr_t *)GG_Malloc( len, MemoryBlock::kEventTag, qtrue );
+			buf = (netadr_t *) Z_Malloc(len, TAG_EVENT, qfalse, 4);
+			*buf = adr;
+			memcpy( buf+1, &netmsg.data[netmsg.readcount], netmsg.cursize - netmsg.readcount );
+			Sys_QueEvent( 0, SE_PACKET, 0, 0, len, buf );
+		}
+		else
+		{
+			// Bail out if there's no more data
+			break;
+		}
+	}
+
+#if 0	// Removed as in SOF2
+	// return if we have data
+    if ( eventHead > eventTail ) {
+            eventTail++;
+            return eventQue[ ( eventTail - 1 ) & MASK_QUED_EVENTS ];
+    }
+#endif
+
+	// create an empty event to return
+    memset( &ev, 0, sizeof( ev ) );
+    ev.evTime = Sys_Milliseconds();
+
+    return ev;
+}
+
+
+void Sys_Print(const char *msg)
+{
+#ifdef _GAMECUBE
+	printf(msg);
+#else
+	OutputDebugString(msg);
+#endif
+}
+
+/*
+==============
+Sys_Log
+==============
+*/
+void Sys_Log( const char *file, const char *msg ) {
+	Sys_Log(file, msg, strlen(msg), strchr(msg, '\n') ? true : false);
+}
+
+/*
+==============
+Sys_Log
+==============
+*/
+void Sys_Log( const char *file, const void *buffer, int size, bool flush ) {
+#ifndef FINAL_BUILD
+	static bool unableToLog = false;
+
+	// Once we've failed to write to the log files once, bail out.
+	// This lets us put release builds on DVD without recompiling.
+	if (unableToLog)
+		return;
+
+	struct FileInfo
+	{
+		char name[MAX_QPATH];
+		FILE *handle;
+	};
+
+	const int LOG_MAX_FILES = 4;
+	static FileInfo files[LOG_MAX_FILES];
+	static int num_files = 0;
+
+	FileInfo* cur = NULL;
+	for (int f = 0; f < num_files; ++f)
+	{
+		if (!stricmp(file, files[f].name))
+		{
+			cur = &files[f];
+			break;
+		}
+	}
+
+	if (cur == NULL)
+	{
+		if (num_files >= LOG_MAX_FILES)
+		{
+			Sys_Print("Too many log files!\n");
+			return;
+		}
+
+		cur = &files[num_files++];
+		strcpy(cur->name, file);
+		cur->handle = NULL;
+	}
+
+	char fullname[MAX_QPATH];
+	sprintf(fullname, "d:\\%s", cur->name);
+	if (!cur->handle)
+	{
+		cur->handle = fopen(fullname, "wb");
+		if (cur->handle == NULL)
+		{
+			Sys_Print("Unable to open log file!\n");
+			unableToLog = true;
+			return;
+		}
+	}
+
+	if (size == 1) fputc(*(char*)buffer, cur->handle);
+	else fwrite(buffer, size, 1, cur->handle);
+
+	if (flush)
+	{
+		fflush(cur->handle);
+	}
+#endif
+}
+
+#ifdef _XBOX
+HANDLE Sys_FileStreamMutex = INVALID_HANDLE_VALUE;
+#endif
+
+void Win_Init(void)
+{
+#ifdef _XBOX
+	Sys_FileStreamMutex = CreateMutex(NULL, FALSE, NULL);
+#endif
+}
+
+/*
+=====================
+
+XBE SWITCHING SUPPORT
+
+=====================
+*/
+#define LAUNCH_MAGIC "J3D1"
+void Sys_Reboot( const char *reason )
+{
+	LAUNCH_DATA ld;
+	const char *path = NULL;
+
+	memset( &ld, 0, sizeof(ld) );
+
+	if (!Q_stricmp(reason, "new_account"))
+	{
+		PLD_LAUNCH_DASHBOARD pDash	= (PLD_LAUNCH_DASHBOARD) &ld;
+		pDash->dwReason				= XLD_LAUNCH_DASHBOARD_NEW_ACCOUNT_SIGNUP;
+		path						= NULL;
+	}
+	else if (!Q_stricmp(reason, "net_config"))
+	{
+		PLD_LAUNCH_DASHBOARD pDash	= (PLD_LAUNCH_DASHBOARD) &ld;
+		pDash->dwReason				= XLD_LAUNCH_DASHBOARD_NETWORK_CONFIGURATION;
+		path						= NULL;
+	}
+	else if (!Q_stricmp(reason, "manage_account"))
+	{
+		PLD_LAUNCH_DASHBOARD pDash	= (PLD_LAUNCH_DASHBOARD) &ld;
+		pDash->dwReason				= XLD_LAUNCH_DASHBOARD_ACCOUNT_MANAGEMENT;
+		path						= NULL;
+	}
+	else if (!Q_stricmp(reason, "singleplayer"))
+	{
+		path = "d:\\default.xbe";
+		strcpy((char *)&ld.Data[0], LAUNCH_MAGIC);
+	}
+	else
+	{
+		Com_Error( ERR_FATAL, "Unknown reboot code %s\n", reason );
+	}
+
+	// Title should not be doing ANYTHING in the background.
+	// Shutting down sound ensures that the sound thread is gone
+	S_Shutdown();
+	// Similarly, kill off the streaming thread
+	extern void Sys_StreamShutdown(void);
+	Sys_StreamShutdown();
+
+	XLaunchNewImage(path, &ld);
+
+	// This function should not return!
+	Com_Error( ERR_FATAL, "ERROR: XLaunchNewImage returned\n" );
+}
+
+
+/*
+==================
+WinMain
+
+==================
+*/
+#if defined (_XBOX)
+int __cdecl main()
+#elif defined (_GAMECUBE)
+int main(int argc, char* argv[])
+#endif
+{
+//	Z_SetFreeOSMem();
+
+	// I'm going to kill someone. This should not be necessary. No, really.
+	Direct3D_SetPushBufferSize(1024*1024, 128*1024);
+
+	// get the initial time base
+	Sys_Milliseconds();
+
+	Win_Init();
+	Com_Init( "" );
+
+	//Start sound early.  The STL inside will allocate memory and we don't
+	//want that memory in the middle of the zone.
+	if ( !cls.soundRegistered ) {
+		cls.soundRegistered = qtrue;
+		S_BeginRegistration();
+	}
+
+	NET_Init();
+
+	// main game loop
+	while( 1 ) {
+		IN_Frame();
+		Com_Frame();
+
+		// Do any XBL stuff
+//		XBL_Tick();
+
+		// Poll debug console for new commands
+#ifndef FINAL_BUILD
+		DebugConsoleHandleCommands();
+#endif
+	}
+
+	return 0;
+}
+
+
+char *Sys_GetClipboardData(void) { return NULL; }
+
+void Sys_StartProcess(char *, qboolean) {}
+
+void Sys_OpenURL(char *, int) {}
+
+void Sys_Quit(void) {}
+
+void Sys_ShowConsole(int, int) {}
+
+void Sys_Mkdir(const char *) {}
+
+int Sys_LowPhysicalMemory(void) { return 0; }
+
+void Sys_FreeFileList(char **filelist)
+{
+	// All strings in a file list are allocated at once, so we just need to
+	// do two frees, one for strings, one for the pointers.
+	if ( filelist )
+	{
+		if ( filelist[0] )
+			Z_Free( filelist[0] );
+
+		Z_Free( filelist );
+	}
+}
+
+#ifdef _JK2MP
+char** Sys_ListFiles(const char *directory, const char *extension, char *filter, int *numfiles, qboolean wantsubs)
+#else
+char** Sys_ListFiles(const char *directory, const char *extension, int *numfiles, qboolean wantsubs)
+#endif
+{
+#ifdef _JK2MP
+	// MP has extra filter paramter. We don't support that.
+	if (filter)
+	{
+		assert(!"Sys_ListFiles doesn't support filter on console!");
+		return NULL;
+	}
+#endif
+
+	// Hax0red console version of Sys_ListFiles. We mangle our arguments to get a standard filename
+	// That file should exist, and contain the list of files that meet this search criteria.
+	char	listFilename[MAX_OSPATH];
+	char	*listFile, *curFile, *end;
+	int		nfiles;
+	char	**retList;
+
+	// S00per hack
+	if (strstr(directory, "d:\\base\\"))
+		directory += 8;
+
+	if (!extension)
+	{
+		extension = "";
+	}
+	else if (extension[0] == '/' && extension[1] == 0)
+	{
+		// Passing a slash as extension will find directories
+		extension = "dir";
+	}
+	else if (extension[0] == '.')
+	{
+		// Skip over leading .
+		extension++;
+	}
+
+	// Build our filename
+	Com_sprintf(listFilename, sizeof(listFilename), "%s\\_console_%s_list_", directory, extension);
+	if (FS_ReadFile( listFilename, (void**)&listFile ) <= 0)
+	{
+		if(listFile) {
+			FS_FreeFile(listFile);
+		}
+		Com_Printf( "WARNING: List file %s not found\n", listFilename );
+		if (numfiles)
+			*numfiles = 0;
+		return NULL;
+	}
+
+	// Do a first pass to count number of files in the list
+	nfiles = 0;
+	curFile = listFile;
+	while (true)
+	{
+		// Find end of line
+		end = strchr(curFile, '\r');
+		if (end)
+		{
+			// Should have a \n next -- skip them both
+			end += 2;
+		}
+		else
+		{
+			end = strchr(curFile, '\n');
+			if (end) end++;
+			else end = curFile + strlen(curFile);
+		}
+
+		// Is the line empty?  If so, we're done.
+		if (!curFile || !curFile[0]) break;
+		++nfiles;
+
+		// Advance to next line
+		curFile = end;
+	}
+
+	// Fill in caller's pointer for number of files found
+	if (numfiles) *numfiles = nfiles;
+
+	// Did we find any files at all?
+	if (nfiles == 0)
+	{
+		FS_FreeFile(listFile);
+		return NULL;
+	}
+
+	// Allocate a file list, and quick string pool, but use LISTFILES
+	retList = (char **) Z_Malloc( ( nfiles + 1 ) * sizeof( *retList ), TAG_LISTFILES, qfalse);
+	// Our string pool is actually slightly too large, but it's temporary, and that's better
+	// than slightly too small
+	char *stringPool = (char *) Z_Malloc( strlen(listFile) + 1, TAG_LISTFILES, qfalse );
+
+	// Now go through the list of files again, and fill in the list to be returned
+	nfiles = 0;
+	curFile = listFile;
+	while (true)
+	{
+		// Find end of line
+		end = strchr(curFile, '\r');
+		if (end)
+		{
+			// Should have a \n next -- skip them both
+			*end++ = '\0';
+			*end++ = '\0';
+		}
+		else
+		{
+			end = strchr(curFile, '\n');
+			if (end) *end++ = '\0';
+			else end = curFile + strlen(curFile);
+		}
+
+		// Is the line empty?  If so, we're done.
+		int curStrSize = strlen(curFile);
+		if (curStrSize < 1)
+		{
+			retList[nfiles] = NULL;
+			break;
+		}
+
+		// Alloc a small copy
+		//retList[nfiles++] = CopyString( curFile );
+		retList[nfiles++] = stringPool;
+		strcpy(stringPool, curFile);
+		stringPool += (curStrSize + 1);
+
+		// Advance to next line
+		curFile = end;
+	}
+
+	// Free the special file's buffer
+	FS_FreeFile( listFile );
+
+	return retList;
+}
+
+/*
+=================
+Sys_UnloadGame
+=================
+*/
+void Sys_UnloadGame( void ) {
+}
+
+/*
+=================
+Sys_GetGameAPI
+
+Loads the game dll
+=================
+*/
+#ifndef _JK2MP
+void *Sys_GetGameAPI (void *parms)
+{
+	extern game_export_t *GetGameAPI( game_import_t *import );
+	return GetGameAPI((game_import_t *)parms);
+}
+#endif
+
+/*
+=================
+Sys_LoadCgame
+
+Used to hook up a development dll
+=================
+*/
+// void * Sys_LoadCgame( void ) 
+#ifndef _JK2MP
+void * Sys_LoadCgame( int (**entryPoint)(int, ...), int (*systemcalls)(int, ...) )
+{
+	extern void CG_PreInit();
+	extern void cg_dllEntry( int (*syscallptr)( int arg,... ) );
+	extern int vmMain( int command, int arg0, int arg1, int arg2, int arg3, int arg4, int arg5, int arg6, int arg7 );
+	cg_dllEntry(systemcalls);
+	*entryPoint = (int (*)(int,...))vmMain;
+	CG_PreInit();
+	return 0;
+}
+#endif
+
+/* VVFIXME: More stubs */
+qboolean Sys_FileOutOfDate( LPCSTR psFinalFileName /* dest */, LPCSTR psDataFileName /* src */ )
+{
+	return qfalse;
+}
+
+qboolean Sys_CopyFile(LPCSTR lpExistingFileName, LPCSTR lpNewFileName, qboolean bOverwrite)
+{
+	return qfalse;
+}
+
+qboolean Sys_CheckCD( void )
+{
+	return qtrue;
+}
diff --git a/codemp/win32/win_net.cpp b/codemp/win32/win_net.cpp
new file mode 100644
index 0000000..03a45d5
--- /dev/null
+++ b/codemp/win32/win_net.cpp
@@ -0,0 +1,1222 @@
+// net_wins.c
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+#include "win_local.h"
+
+static WSADATA	winsockdata;
+static qboolean	winsockInitialized = qfalse;
+static qboolean usingSocks = qfalse;
+static qboolean networkingEnabled = qfalse;
+
+static cvar_t	*net_noudp;
+static cvar_t	*net_noipx;
+
+static cvar_t	*net_forcenonlocal;
+
+static cvar_t	*net_socksEnabled;
+static cvar_t	*net_socksServer;
+static cvar_t	*net_socksPort;
+static cvar_t	*net_socksUsername;
+static cvar_t	*net_socksPassword;
+static struct sockaddr	socksRelayAddr;
+
+#ifdef _XBOX
+SOCKET	v_socket = INVALID_SOCKET;
+#endif
+static SOCKET	ip_socket = INVALID_SOCKET;
+static SOCKET	socks_socket = INVALID_SOCKET;
+static SOCKET	ipx_socket = INVALID_SOCKET;
+
+#define	MAX_IPS		16
+static	int		numIP;
+static	byte	localIP[MAX_IPS][4];
+
+//=============================================================================
+
+
+/*
+====================
+NET_ErrorString
+====================
+*/
+char *NET_ErrorString( void ) {
+	int		code;
+
+	code = WSAGetLastError();
+	switch( code ) {
+	case WSAEINTR: return "WSAEINTR";
+	case WSAEBADF: return "WSAEBADF";
+	case WSAEACCES: return "WSAEACCES";
+	case WSAEDISCON: return "WSAEDISCON";
+	case WSAEFAULT: return "WSAEFAULT";
+	case WSAEINVAL: return "WSAEINVAL";
+	case WSAEMFILE: return "WSAEMFILE";
+	case WSAEWOULDBLOCK: return "WSAEWOULDBLOCK";
+	case WSAEINPROGRESS: return "WSAEINPROGRESS";
+	case WSAEALREADY: return "WSAEALREADY";
+	case WSAENOTSOCK: return "WSAENOTSOCK";
+	case WSAEDESTADDRREQ: return "WSAEDESTADDRREQ";
+	case WSAEMSGSIZE: return "WSAEMSGSIZE";
+	case WSAEPROTOTYPE: return "WSAEPROTOTYPE";
+	case WSAENOPROTOOPT: return "WSAENOPROTOOPT";
+	case WSAEPROTONOSUPPORT: return "WSAEPROTONOSUPPORT";
+	case WSAESOCKTNOSUPPORT: return "WSAESOCKTNOSUPPORT";
+	case WSAEOPNOTSUPP: return "WSAEOPNOTSUPP";
+	case WSAEPFNOSUPPORT: return "WSAEPFNOSUPPORT";
+	case WSAEAFNOSUPPORT: return "WSAEAFNOSUPPORT";
+	case WSAEADDRINUSE: return "WSAEADDRINUSE";
+	case WSAEADDRNOTAVAIL: return "WSAEADDRNOTAVAIL";
+	case WSAENETDOWN: return "WSAENETDOWN";
+	case WSAENETUNREACH: return "WSAENETUNREACH";
+	case WSAENETRESET: return "WSAENETRESET";
+	case WSAECONNABORTED: return "WSWSAECONNABORTEDAEINTR";
+	case WSAECONNRESET: return "WSAECONNRESET";
+	case WSAENOBUFS: return "WSAENOBUFS";
+	case WSAEISCONN: return "WSAEISCONN";
+	case WSAENOTCONN: return "WSAENOTCONN";
+	case WSAESHUTDOWN: return "WSAESHUTDOWN";
+	case WSAETOOMANYREFS: return "WSAETOOMANYREFS";
+	case WSAETIMEDOUT: return "WSAETIMEDOUT";
+	case WSAECONNREFUSED: return "WSAECONNREFUSED";
+	case WSAELOOP: return "WSAELOOP";
+	case WSAENAMETOOLONG: return "WSAENAMETOOLONG";
+	case WSAEHOSTDOWN: return "WSAEHOSTDOWN";
+	case WSASYSNOTREADY: return "WSASYSNOTREADY";
+	case WSAVERNOTSUPPORTED: return "WSAVERNOTSUPPORTED";
+	case WSANOTINITIALISED: return "WSANOTINITIALISED";
+	case WSAHOST_NOT_FOUND: return "WSAHOST_NOT_FOUND";
+	case WSATRY_AGAIN: return "WSATRY_AGAIN";
+	case WSANO_RECOVERY: return "WSANO_RECOVERY";
+	case WSANO_DATA: return "WSANO_DATA";
+	case WSAEHOSTUNREACH: return "WSAEHOSTUNREACH";
+	default: return "NO ERROR";
+	}
+}
+
+void NetadrToSockadr( netadr_t *a, struct sockaddr *s ) {
+	memset( s, 0, sizeof(*s) );
+
+	if( a->type == NA_BROADCAST ) {
+		((struct sockaddr_in *)s)->sin_family = AF_INET;
+		((struct sockaddr_in *)s)->sin_port = a->port;
+		((struct sockaddr_in *)s)->sin_addr.s_addr = INADDR_BROADCAST;
+	}
+	else if( a->type == NA_IP ) {
+		((struct sockaddr_in *)s)->sin_family = AF_INET;
+		((struct sockaddr_in *)s)->sin_addr.s_addr = *(int *)&a->ip;
+		((struct sockaddr_in *)s)->sin_port = a->port;
+	}
+#ifndef _XBOX
+	else if( a->type == NA_IPX ) {
+		((struct sockaddr_ipx *)s)->sa_family = AF_IPX;
+		memcpy( ((struct sockaddr_ipx *)s)->sa_netnum, &a->ipx[0], 4 );
+		memcpy( ((struct sockaddr_ipx *)s)->sa_nodenum, &a->ipx[4], 6 );
+		((struct sockaddr_ipx *)s)->sa_socket = a->port;
+	}
+	else if( a->type == NA_BROADCAST_IPX ) {
+		((struct sockaddr_ipx *)s)->sa_family = AF_IPX;
+		memset( ((struct sockaddr_ipx *)s)->sa_netnum, 0, 4 );
+		memset( ((struct sockaddr_ipx *)s)->sa_nodenum, 0xff, 6 );
+		((struct sockaddr_ipx *)s)->sa_socket = a->port;
+	}
+#endif //_XBOX
+}
+
+
+void SockadrToNetadr( struct sockaddr *s, netadr_t *a ) {
+	if (s->sa_family == AF_INET) {
+		a->type = NA_IP;
+		*(int *)&a->ip = ((struct sockaddr_in *)s)->sin_addr.s_addr;
+		a->port = ((struct sockaddr_in *)s)->sin_port;
+	}
+#ifndef _XBOX
+	else if( s->sa_family == AF_IPX ) {
+		a->type = NA_IPX;
+		memcpy( &a->ipx[0], ((struct sockaddr_ipx *)s)->sa_netnum, 4 );
+		memcpy( &a->ipx[4], ((struct sockaddr_ipx *)s)->sa_nodenum, 6 );
+		a->port = ((struct sockaddr_ipx *)s)->sa_socket;
+	}
+#endif //_XBOX
+}
+
+
+/*
+=============
+Sys_StringToAdr
+
+idnewt
+192.246.40.70
+12121212.121212121212
+=============
+*/
+#define DO(src,dest)	\
+	copy[0] = s[src];	\
+	copy[1] = s[src + 1];	\
+	sscanf (copy, "%x", &val);	\
+	((struct sockaddr_ipx *)sadr)->dest = val
+
+
+qboolean Sys_StringToSockaddr( const char *s, struct sockaddr *sadr )
+{
+#ifndef _XBOX
+	struct hostent	*h;
+	int		val;
+	char	copy[MAX_STRING_CHARS];
+#endif
+
+	
+	memset( sadr, 0, sizeof( *sadr ) );
+
+	// check for an IPX address
+	if( ( strlen( s ) == 21 ) && ( s[8] == '.' ) )
+	{
+#ifdef _XBOX
+		assert(!"IPX not supported on XBox");
+#else
+		((struct sockaddr_ipx *)sadr)->sa_family = AF_IPX;
+		((struct sockaddr_ipx *)sadr)->sa_socket = 0;
+		copy[2] = 0;
+		DO(0, sa_netnum[0]);
+		DO(2, sa_netnum[1]);
+		DO(4, sa_netnum[2]);
+		DO(6, sa_netnum[3]);
+		DO(9, sa_nodenum[0]);
+		DO(11, sa_nodenum[1]);
+		DO(13, sa_nodenum[2]);
+		DO(15, sa_nodenum[3]);
+		DO(17, sa_nodenum[4]);
+		DO(19, sa_nodenum[5]);
+#endif
+	}
+	else
+	{
+		((struct sockaddr_in *)sadr)->sin_family = AF_INET;
+		((struct sockaddr_in *)sadr)->sin_port = 0;
+
+		if( s[0] >= '0' && s[0] <= '9' )
+		{
+			*(int *)&((struct sockaddr_in *)sadr)->sin_addr = inet_addr(s);
+		}
+		else
+		{
+#ifdef _XBOX
+			assert(!"gethostbyname() - unsupported on XBox");
+#else
+			if( ( h = gethostbyname( s ) ) == 0 ) {	// NOT SUPPORTED ON XBOX!
+				return (qboolean)0;
+
+			}
+			*(int *)&((struct sockaddr_in *)sadr)->sin_addr = *(int *)h->h_addr_list[0];
+#endif
+		}
+	}
+	
+	return qtrue;
+}
+
+#undef DO
+
+/*
+=============
+Sys_StringToAdr
+
+idnewt
+192.246.40.70
+=============
+*/
+qboolean Sys_StringToAdr( const char *s, netadr_t *a ) {
+	struct sockaddr sadr;
+	
+	if ( !Sys_StringToSockaddr( s, &sadr ) ) {
+		return qfalse;
+	}
+	
+	SockadrToNetadr( &sadr, a );
+	return qtrue;
+}
+
+//=============================================================================
+
+/*
+==================
+Sys_GetPacket
+
+Never called by the game logic, just the system event queing
+==================
+*/
+int	recvfromCount;
+
+qboolean Sys_GetPacket( netadr_t *net_from, msg_t *net_message ) {
+	int 	ret;
+	struct sockaddr from;
+	int		fromlen;
+	SOCKET	net_socket;
+	int		protocol;
+	int		err;
+
+	for( protocol = 0 ; protocol < 2 ; protocol++ )	{
+		if( protocol == 0 ) {
+			net_socket = ip_socket;
+		}
+		else {
+			net_socket = ipx_socket;
+		}
+
+		if( net_socket == INVALID_SOCKET) {
+			continue;
+		}
+
+		fromlen = sizeof(from);
+		recvfromCount++;		// performance check
+		ret = recvfrom( net_socket, (char *)net_message->data, net_message->maxsize, 0, (struct sockaddr *)&from, &fromlen );
+
+		if (ret == SOCKET_ERROR)
+		{
+			err = WSAGetLastError();
+
+			if( err == WSAEWOULDBLOCK || err == WSAECONNRESET ) {
+				continue;
+			}
+			Com_Printf( "NET_GetPacket: %s\n", NET_ErrorString() );
+			continue;
+		}
+
+#ifdef _XBOX
+		// VVFIXME - SOF2 calls into XBL class
+	    // XBL_RcvdDataPacket(net_message->cursize);
+#endif
+
+		if ( net_socket == ip_socket ) {
+			memset( ((struct sockaddr_in *)&from)->sin_zero, 0, 8 );
+		}
+
+		if ( usingSocks && net_socket == ip_socket && memcmp( &from, &socksRelayAddr, fromlen ) == 0 ) {
+			if ( ret < 10 || net_message->data[0] != 0 || net_message->data[1] != 0 || net_message->data[2] != 0 || net_message->data[3] != 1 ) {
+				continue;
+			}
+			net_from->type = NA_IP;
+			net_from->ip[0] = net_message->data[4];
+			net_from->ip[1] = net_message->data[5];
+			net_from->ip[2] = net_message->data[6];
+			net_from->ip[3] = net_message->data[7];
+			net_from->port = *(short *)&net_message->data[8];
+			net_message->readcount = 10;
+		}
+		else {
+			SockadrToNetadr( &from, net_from );
+			net_message->readcount = 0;
+		}
+
+		if( ret == net_message->maxsize ) {
+			Com_Printf( "Oversize packet from %s\n", NET_AdrToString (*net_from) );
+			continue;
+		}
+
+		net_message->cursize = ret;
+		return qtrue;
+	}
+
+	return qfalse;
+}
+
+//=============================================================================
+
+#ifdef _XBOX
+/*
+==================
+Sys_SendVoicePacket
+==================
+*/
+void Sys_SendVoicePacket( int length, const void *data, netadr_t to ) {
+	int				ret;
+	struct sockaddr	addr;
+
+	// check for valid packet intentions (direct send or broadcast)
+	//
+	if( to.type != NA_IP && to.type != NA_BROADCAST ) 
+	{
+		Com_Error( ERR_FATAL, "Sys_SendVoicePacket: bad address type" );
+		return;
+	}
+	
+	// check we have our voice socket set up
+	//
+	if( v_socket == INVALID_SOCKET) {
+		return;
+	}
+
+	NetadrToSockadr( &to, &addr );
+#ifdef SOF2_METRICS
+	gXBL_NumberVoicePacketsSent++;
+	gXBL_SizeVoicePacketsSent += length;
+#endif
+	/*if( usingSocks && to.type == NA_IP ) {
+		vsocksBuf[0] = 0;	// reserved
+		vsocksBuf[1] = 0;
+		vsocksBuf[2] = 0;	// fragment (not fragmented)
+		vsocksBuf[3] = 1;	// address type: IPV4
+		*(int *)&vsocksBuf[4] = ((struct sockaddr_in *)&addr)->sin_addr.s_addr;
+		*(short *)&vsocksBuf[8] = ((struct sockaddr_in *)&addr)->sin_port;
+		memcpy( &vsocksBuf[10], data, length );
+		ret = sendto( v_socket, vsocksBuf, length+10, 0, &socksRelayAddr, sizeof(socksRelayAddr) );
+	}
+	else {*/
+		ret = sendto( v_socket, (const char *)data, length, 0, &addr, sizeof(addr) );
+	//}
+
+	if( ret == SOCKET_ERROR ) {
+		int err = WSAGetLastError();
+
+		// wouldblock is silent
+		if( err == WSAEWOULDBLOCK ) {
+			return;
+		}
+
+		// some PPP links do not allow broadcasts and return an error
+		if( ( err == WSAEADDRNOTAVAIL ) && ( ( to.type == NA_BROADCAST ) || ( to.type == NA_BROADCAST_IPX ) ) ) {
+			return;
+		}
+
+		Com_DPrintf( "NET_SendVoicePacket: %s\n", NET_ErrorString() );
+	}
+}
+#endif
+
+static char socksBuf[4096];
+
+/*
+==================
+Sys_SendPacket
+==================
+*/
+void Sys_SendPacket( int length, const void *data, netadr_t to ) {
+	int				ret;
+	struct sockaddr	addr;
+	SOCKET			net_socket;
+
+#ifdef _XBOX
+	// VVFIXME - SOF2 calls into XBL code
+    // XBL_SentDataPacket( length );
+#endif
+
+	if( to.type == NA_BROADCAST ) {
+		net_socket = ip_socket;
+	}
+	else if( to.type == NA_IP ) {
+		net_socket = ip_socket;
+	}
+	else if( to.type == NA_IPX ) {
+#ifdef _XBOX
+		return;
+#else
+		net_socket = ipx_socket;
+#endif
+	}
+	else if( to.type == NA_BROADCAST_IPX ) {
+#ifdef _XBOX
+		return;
+#else
+		net_socket = ipx_socket;
+#endif
+	}
+	else {
+		Com_Error( ERR_FATAL, "Sys_SendPacket: bad address type" );
+		return;
+	}
+
+	if( net_socket == INVALID_SOCKET) {
+		return;
+	}
+
+	NetadrToSockadr( &to, &addr );
+
+#ifndef _XBOX
+	if( usingSocks && to.type == NA_IP ) {
+		socksBuf[0] = 0;	// reserved
+		socksBuf[1] = 0;
+		socksBuf[2] = 0;	// fragment (not fragmented)
+		socksBuf[3] = 1;	// address type: IPV4
+		*(int *)&socksBuf[4] = ((struct sockaddr_in *)&addr)->sin_addr.s_addr;
+		*(short *)&socksBuf[8] = ((struct sockaddr_in *)&addr)->sin_port;
+		memcpy( &socksBuf[10], data, length );
+		ret = sendto( net_socket, socksBuf, length+10, 0, &socksRelayAddr, sizeof(socksRelayAddr) );
+	}
+	else {
+#endif
+		ret = sendto( net_socket, (const char *)data, length, 0, &addr, sizeof(addr) );
+#ifndef _XBOX
+	}
+#endif
+	if( ret == SOCKET_ERROR ) {
+		int err = WSAGetLastError();
+
+		// wouldblock is silent
+		if( err == WSAEWOULDBLOCK ) {
+			return;
+		}
+
+		// some PPP links do not allow broadcasts and return an error
+		if( ( err == WSAEADDRNOTAVAIL ) && ( ( to.type == NA_BROADCAST ) || ( to.type == NA_BROADCAST_IPX ) ) ) {
+			return;
+		}
+
+		Com_Printf( "NET_SendPacket: %s\n", NET_ErrorString() );
+	}
+}
+
+
+//=============================================================================
+
+
+/*
+==================
+Sys_IsLANAddress
+
+LAN clients will have their rate var ignored
+==================
+*/
+qboolean Sys_IsLANAddress( netadr_t adr ) {
+	int		i;
+
+	if (!net_forcenonlocal)
+	{
+		net_forcenonlocal = Cvar_Get( "net_forcenonlocal", "0", 0 );
+	}
+
+	if (net_forcenonlocal && net_forcenonlocal->integer)
+	{
+		return qfalse;
+	}
+
+	if( adr.type == NA_LOOPBACK ) {
+		return qtrue;
+	}
+
+	if( adr.type == NA_IPX ) {
+		return qtrue;
+	}
+
+	if( adr.type != NA_IP ) {
+		return qfalse;
+	}
+
+	// choose which comparison to use based on the class of the address being tested
+	// any local adresses of a different class than the address being tested will fail based on the first byte
+
+	if( adr.ip[0] == 127 && adr.ip[1] == 0 && adr.ip[2] == 0 && adr.ip[3] == 1 ) {
+		return qtrue;
+	}
+
+	if ( (adr.ip[0] == 192 && adr.ip[1] == 168) || 
+		 (adr.ip[0] == 10 && adr.ip[1] == 100)  ||
+		 (adr.ip[0] == 172 && adr.ip[1] == 16)      )
+	{
+		return qtrue;
+	} 
+
+	/*
+	// Class A
+	if( (adr.ip[0] & 0x80) == 0x00 ) {
+		for ( i = 0 ; i < numIP ; i++ ) {
+			if( adr.ip[0] == localIP[i][0] ) {
+				return qtrue;
+			}
+		}
+		// the RFC1918 class a block will pass the above test
+		return qfalse;
+	}
+
+	// Class B
+	if( (adr.ip[0] & 0xc0) == 0x80 ) {
+		for ( i = 0 ; i < numIP ; i++ ) {
+			if( adr.ip[0] == localIP[i][0] && adr.ip[1] == localIP[i][1] ) {
+				return qtrue;
+			}
+			// also check against the RFC1918 class b blocks
+			if( adr.ip[0] == 172 && localIP[i][0] == 172 && (adr.ip[1] & 0xf0) == 16 && (localIP[i][1] & 0xf0) == 16 ) {
+				return qtrue;
+			}
+		}
+		return qfalse;
+	}
+	*/
+	//we only look at class C since ISPs and Universities are using class A but we don't want to consider them on the same LAN.
+
+	// Class C
+	for ( i = 0 ; i < numIP ; i++ ) {
+		if( adr.ip[0] == localIP[i][0] && adr.ip[1] == localIP[i][1] && adr.ip[2] == localIP[i][2] ) {
+			return qtrue;
+		}
+		
+		//check for both on a local lan type thing
+		if( adr.ip[0] == 10 && localIP[i][0] == 10 ) 
+		{
+			return qtrue;
+		}
+
+		// also check against the RFC1918 class c blocks
+//		if( adr.ip[0] == 192 && localIP[i][0] == 192 && adr.ip[1] == 168 && localIP[i][1] == 168 ) {
+//			return qtrue;
+//		}
+	}
+	return qfalse;
+}
+
+/*
+==================
+Sys_ShowIP
+==================
+*/
+void Sys_ShowIP(void) {
+	int i;
+
+	for (i = 0; i < numIP; i++) {
+		Com_Printf( "IP: %i.%i.%i.%i\n", localIP[i][0], localIP[i][1], localIP[i][2], localIP[i][3] );
+	}
+}
+
+
+//=============================================================================
+
+
+/*
+====================
+NET_IPSocket
+====================
+*/
+int NET_IPSocket( char *net_interface, int port ) {
+	SOCKET				newsocket;
+	struct sockaddr_in	address;
+	qboolean			_true = qtrue;
+	int					i = 1;
+	int					err;
+
+	if( net_interface ) {
+		Com_Printf( "Opening IP socket: %s:%i\n", net_interface, port );
+	}
+	else {
+		Com_Printf( "Opening IP socket: localhost:%i\n", port );
+	}
+
+	if( ( newsocket = socket( AF_INET, SOCK_DGRAM, IPPROTO_UDP ) ) == INVALID_SOCKET ) {
+		err = WSAGetLastError();
+		if( err != WSAEAFNOSUPPORT ) {
+			Com_Printf( "WARNING: UDP_OpenSocket: socket: %s\n", NET_ErrorString() );
+		}
+		return INVALID_SOCKET;
+	}
+
+	// make it non-blocking
+	if( ioctlsocket( newsocket, FIONBIO, (unsigned long *)&_true ) == SOCKET_ERROR ) {
+		Com_Printf( "WARNING: UDP_OpenSocket: ioctl FIONBIO: %s\n", NET_ErrorString() );
+		return INVALID_SOCKET;
+	}
+
+	// make it broadcast capable
+	if( setsockopt( newsocket, SOL_SOCKET, SO_BROADCAST, (char *)&i, sizeof(i) ) == SOCKET_ERROR ) {
+		Com_Printf( "WARNING: UDP_OpenSocket: setsockopt SO_BROADCAST: %s\n", NET_ErrorString() );
+		return INVALID_SOCKET;
+	}
+
+	if( !net_interface || !net_interface[0] || !Q_stricmp(net_interface, "localhost") ) {
+		address.sin_addr.s_addr = INADDR_ANY;
+	}
+	else {
+		Sys_StringToSockaddr( net_interface, (struct sockaddr *)&address );
+	}
+
+	if( port == PORT_ANY ) {
+		address.sin_port = 0;
+	}
+	else {
+		address.sin_port = htons( (short)port );
+	}
+
+	address.sin_family = AF_INET;
+
+	if( bind( newsocket, (const struct sockaddr *)&address, sizeof(address) ) == SOCKET_ERROR ) {
+		Com_Printf( "WARNING: UDP_OpenSocket: bind: %s\n", NET_ErrorString() );
+		closesocket( newsocket );
+		return INVALID_SOCKET;
+	}
+
+	return newsocket;
+}
+
+
+/*
+====================
+NET_OpenSocks
+====================
+*/
+void NET_OpenSocks( int port ) {
+	struct sockaddr_in	address;
+	int					err;
+#ifndef _XBOX
+	struct hostent		*h;
+#endif
+	int					len;
+	qboolean			rfc1929;
+	unsigned char		buf[64];
+
+	usingSocks = qfalse;
+
+	Com_Printf( "Opening connection to SOCKS server.\n" );
+
+	if ( ( socks_socket = socket( AF_INET, SOCK_STREAM, IPPROTO_TCP ) ) == INVALID_SOCKET ) {
+		err = WSAGetLastError();
+		Com_Printf( "WARNING: NET_OpenSocks: socket: %s\n", NET_ErrorString() );
+		return;
+	}
+
+#ifndef _XBOX
+	h = gethostbyname( net_socksServer->string );
+	if ( h == NULL ) {
+		err = WSAGetLastError();
+		Com_Printf( "WARNING: NET_OpenSocks: gethostbyname: %s\n", NET_ErrorString() );
+		return;
+	}
+	if ( h->h_addrtype != AF_INET ) {
+		Com_Printf( "WARNING: NET_OpenSocks: gethostbyname: address type was not AF_INET\n" );
+		return;
+	}
+	address.sin_family = AF_INET;
+	address.sin_addr.s_addr = *(int *)h->h_addr_list[0];
+	address.sin_port = htons( (short)net_socksPort->integer );
+#else
+	address.sin_family = AF_INET;
+	address.sin_addr.s_addr = inet_addr(net_socksServer->string);
+	address.sin_port = htons( (short)net_socksPort->integer );
+#endif //_XBOX
+
+	if ( connect( socks_socket, (struct sockaddr *)&address, sizeof( address ) ) == SOCKET_ERROR ) {
+		err = WSAGetLastError();
+		Com_Printf( "NET_OpenSocks: connect: %s\n", NET_ErrorString() );
+		return;
+	}
+
+	// send socks authentication handshake
+	if ( *net_socksUsername->string || *net_socksPassword->string ) {
+		rfc1929 = qtrue;
+	}
+	else {
+		rfc1929 = qfalse;
+	}
+
+	buf[0] = 5;		// SOCKS version
+	// method count
+	if ( rfc1929 ) {
+		buf[1] = 2;
+		len = 4;
+	}
+	else {
+		buf[1] = 1;
+		len = 3;
+	}
+	buf[2] = 0;		// method #1 - method id #00: no authentication
+	if ( rfc1929 ) {
+		buf[2] = 2;		// method #2 - method id #02: username/password
+	}
+	if ( send( socks_socket, (const char *)buf, len, 0 ) == SOCKET_ERROR ) {
+		err = WSAGetLastError();
+		Com_Printf( "NET_OpenSocks: send: %s\n", NET_ErrorString() );
+		return;
+	}
+
+	// get the response
+	len = recv( socks_socket, (char *)buf, 64, 0 );
+	if ( len == SOCKET_ERROR ) {
+		err = WSAGetLastError();
+		Com_Printf( "NET_OpenSocks: recv: %s\n", NET_ErrorString() );
+		return;
+	}
+	if ( len != 2 || buf[0] != 5 ) {
+		Com_Printf( "NET_OpenSocks: bad response\n" );
+		return;
+	}
+	switch( buf[1] ) {
+	case 0:	// no authentication
+		break;
+	case 2: // username/password authentication
+		break;
+	default:
+		Com_Printf( "NET_OpenSocks: request denied\n" );
+		return;
+	}
+
+	// do username/password authentication if needed
+	if ( buf[1] == 2 ) {
+		int		ulen;
+		int		plen;
+
+		// build the request
+		ulen = strlen( net_socksUsername->string );
+		plen = strlen( net_socksPassword->string );
+
+		buf[0] = 1;		// username/password authentication version
+		buf[1] = ulen;
+		if ( ulen ) {
+			memcpy( &buf[2], net_socksUsername->string, ulen );
+		}
+		buf[2 + ulen] = plen;
+		if ( plen ) {
+			memcpy( &buf[3 + ulen], net_socksPassword->string, plen );
+		}
+
+		// send it
+		if ( send( socks_socket, (const char *)buf, 3 + ulen + plen, 0 ) == SOCKET_ERROR ) {
+			err = WSAGetLastError();
+			Com_Printf( "NET_OpenSocks: send: %s\n", NET_ErrorString() );
+			return;
+		}
+
+		// get the response
+		len = recv( socks_socket, (char *)buf, 64, 0 );
+		if ( len == SOCKET_ERROR ) {
+			err = WSAGetLastError();
+			Com_Printf( "NET_OpenSocks: recv: %s\n", NET_ErrorString() );
+			return;
+		}
+		if ( len != 2 || buf[0] != 1 ) {
+			Com_Printf( "NET_OpenSocks: bad response\n" );
+			return;
+		}
+		if ( buf[1] != 0 ) {
+			Com_Printf( "NET_OpenSocks: authentication failed\n" );
+			return;
+		}
+	}
+
+	// send the UDP associate request
+	buf[0] = 5;		// SOCKS version
+	buf[1] = 3;		// command: UDP associate
+	buf[2] = 0;		// reserved
+	buf[3] = 1;		// address type: IPV4
+	*(int *)&buf[4] = INADDR_ANY;
+	*(short *)&buf[8] = htons( (short)port );		// port
+	if ( send( socks_socket, (const char *)buf, 10, 0 ) == SOCKET_ERROR ) {
+		err = WSAGetLastError();
+		Com_Printf( "NET_OpenSocks: send: %s\n", NET_ErrorString() );
+		return;
+	}
+
+	// get the response
+	len = recv( socks_socket, (char *)buf, 64, 0 );
+	if( len == SOCKET_ERROR ) {
+		err = WSAGetLastError();
+		Com_Printf( "NET_OpenSocks: recv: %s\n", NET_ErrorString() );
+		return;
+	}
+	if( len < 2 || buf[0] != 5 ) {
+		Com_Printf( "NET_OpenSocks: bad response\n" );
+		return;
+	}
+	// check completion code
+	if( buf[1] != 0 ) {
+		Com_Printf( "NET_OpenSocks: request denied: %i\n", buf[1] );
+		return;
+	}
+	if( buf[3] != 1 ) {
+		Com_Printf( "NET_OpenSocks: relay address is not IPV4: %i\n", buf[3] );
+		return;
+	}
+	((struct sockaddr_in *)&socksRelayAddr)->sin_family = AF_INET;
+	((struct sockaddr_in *)&socksRelayAddr)->sin_addr.s_addr = *(int *)&buf[4];
+	((struct sockaddr_in *)&socksRelayAddr)->sin_port = *(short *)&buf[8];
+	memset( ((struct sockaddr_in *)&socksRelayAddr)->sin_zero, 0, 8 );
+
+	usingSocks = qtrue;
+}
+
+
+/*
+=====================
+NET_GetLocalAddress
+=====================
+*/
+void NET_GetLocalAddress( void )
+{
+#ifndef _XBOX
+
+	char				hostname[256];
+	struct hostent		*hostInfo;
+	int					error;
+	char				*p;
+	int					ip;
+	int					n;
+
+    // Set this early so we can just return if there is an error
+	numIP = 0;
+
+	if( gethostname( hostname, 256 ) == SOCKET_ERROR ) {
+		error = WSAGetLastError();
+		return;
+	}
+
+	hostInfo = gethostbyname( hostname );
+	if( !hostInfo ) {
+		error = WSAGetLastError();
+		return;
+	}
+
+	Com_Printf( "Hostname: %s\n", hostInfo->h_name );
+	n = 0;
+	while( ( p = hostInfo->h_aliases[n++] ) != NULL ) {
+		Com_Printf( "Alias: %s\n", p );
+	}
+
+	if ( hostInfo->h_addrtype != AF_INET ) {
+		return;
+	}
+
+	while( ( p = hostInfo->h_addr_list[numIP] ) != NULL && numIP < MAX_IPS ) {
+		ip = ntohl( *(int *)p );
+		localIP[ numIP ][0] = p[0];
+		localIP[ numIP ][1] = p[1];
+		localIP[ numIP ][2] = p[2];
+		localIP[ numIP ][3] = p[3];
+		Com_Printf( "IP: %i.%i.%i.%i\n", ( ip >> 24 ) & 0xff, ( ip >> 16 ) & 0xff, ( ip >> 8 ) & 0xff, ip & 0xff );
+		numIP++;
+	}
+
+#else
+	XNADDR xnMyAddr;
+	DWORD dwStatus;
+	do
+	{
+	   // Repeat while pending; OK to do other work in this loop
+	   dwStatus = XNetGetTitleXnAddr( &xnMyAddr );
+	} while( dwStatus == XNET_GET_XNADDR_PENDING );
+
+	// Error checking
+	if( dwStatus == XNET_GET_XNADDR_NONE )
+	{
+		assert(!"Error getting XBox title address.");
+		return;
+	}
+
+	*(u_long*)&localIP[0] = xnMyAddr.ina.S_un.S_addr;
+	*(u_long*)localIP[1] = 0;
+	*(u_long*)localIP[2] = 0;
+	*(u_long*)localIP[3] = 0;
+
+	Com_Printf( "IP: %i.%i.%i.%i\n", localIP[0], localIP[1], localIP[2], localIP[3] );
+
+#endif
+}
+
+/*
+====================
+NET_OpenIP
+====================
+*/
+void NET_OpenIP( void )
+{
+	cvar_t	*ip;
+	int		port;
+	int		i;
+
+	ip = Cvar_Get( "net_ip", "localhost", CVAR_LATCH );
+	port = Cvar_Get( "net_port", va( "%i", PORT_SERVER ), CVAR_LATCH )->integer;
+
+	// automatically scan for a valid port, so multiple
+	// dedicated servers can be started without requiring
+	// a different net_port for each one
+	for( i = 0 ; i < 10 ; i++ ) {
+		ip_socket = NET_IPSocket( ip->string, port + i );
+		if ( ip_socket ) {
+			Cvar_SetValue( "net_port", port + i );
+			if ( net_socksEnabled->integer ) {
+				NET_OpenSocks( port + i );
+			}
+			NET_GetLocalAddress();
+			return;
+		}
+	}
+	Com_Printf( "WARNING: Couldn't allocate IP port\n");
+}
+
+
+/*
+====================
+NET_IPXSocket
+====================
+*/
+int NET_IPXSocket( int port )
+{
+#ifdef _XBOX
+	assert(!"NET_IPXSocket() - Not supported");
+	return INVALID_SOCKET;
+#else
+	SOCKET				newsocket;
+
+	struct sockaddr_ipx	address;
+	int					_true = 1;
+	int					err;
+
+	if( ( newsocket = socket( AF_IPX, SOCK_DGRAM, NSPROTO_IPX ) ) == INVALID_SOCKET ) {
+		err = WSAGetLastError();
+		if (err != WSAEAFNOSUPPORT) {
+			Com_Printf( "WARNING: IPX_Socket: socket: %s\n", NET_ErrorString() );
+		}
+		return INVALID_SOCKET;
+	}
+
+	// make it non-blocking
+	if( ioctlsocket( newsocket, FIONBIO, (unsigned long *)&_true ) == SOCKET_ERROR ) {
+		Com_Printf( "WARNING: IPX_Socket: ioctl FIONBIO: %s\n", NET_ErrorString() );
+		return INVALID_SOCKET;
+	}
+
+	// make it broadcast capable
+	if( setsockopt( newsocket, SOL_SOCKET, SO_BROADCAST, (char *)&_true, sizeof( _true ) ) == SOCKET_ERROR ) {
+		Com_Printf( "WARNING: IPX_Socket: setsockopt SO_BROADCAST: %s\n", NET_ErrorString() );
+		return INVALID_SOCKET;
+	}
+
+	address.sa_family = AF_IPX;
+	memset( address.sa_netnum, 0, 4 );
+	memset( address.sa_nodenum, 0, 6 );
+	if( port == PORT_ANY ) {
+		address.sa_socket = 0;
+	}
+	else {
+		address.sa_socket = htons( (short)port );
+	}
+
+	if( bind( newsocket, (const struct sockaddr *)&address, sizeof(address) ) == SOCKET_ERROR ) {
+		Com_Printf( "WARNING: IPX_Socket: bind: %s\n", NET_ErrorString() );
+		closesocket( newsocket );
+		return INVALID_SOCKET;
+	}
+	return newsocket;
+#endif
+}
+
+
+/*
+====================
+NET_OpenIPX
+====================
+*/
+void NET_OpenIPX( void ) {
+	int		port;
+
+	port = Cvar_Get( "net_port", va( "%i", PORT_SERVER ), CVAR_LATCH )->integer;
+	ipx_socket = NET_IPXSocket( port );
+}
+
+
+
+//===================================================================
+
+
+/*
+====================
+NET_GetCvars
+====================
+*/
+static qboolean NET_GetCvars( void ) {
+	qboolean	modified;
+
+	modified = qfalse;
+
+	if( net_noudp && net_noudp->modified ) {
+		modified = qtrue;
+	}
+	net_noudp = Cvar_Get( "net_noudp", "0", CVAR_LATCH | CVAR_ARCHIVE );
+
+	if( net_noipx && net_noipx->modified ) {
+		modified = qtrue;
+	}
+	net_noipx = Cvar_Get( "net_noipx", "1", CVAR_LATCH | CVAR_ARCHIVE );
+
+
+	if( net_forcenonlocal && net_forcenonlocal->modified ) {
+		modified = qtrue;
+	}
+	net_forcenonlocal = Cvar_Get( "net_forcenonlocal", "0", CVAR_LATCH | CVAR_ARCHIVE );
+
+
+	if( net_socksEnabled && net_socksEnabled->modified ) {
+		modified = qtrue;
+	}
+	net_socksEnabled = Cvar_Get( "net_socksEnabled", "0", CVAR_LATCH | CVAR_ARCHIVE );
+
+	if( net_socksServer && net_socksServer->modified ) {
+		modified = qtrue;
+	}
+	net_socksServer = Cvar_Get( "net_socksServer", "", CVAR_LATCH | CVAR_ARCHIVE );
+
+	if( net_socksPort && net_socksPort->modified ) {
+		modified = qtrue;
+	}
+	net_socksPort = Cvar_Get( "net_socksPort", "1080", CVAR_LATCH | CVAR_ARCHIVE );
+
+	if( net_socksUsername && net_socksUsername->modified ) {
+		modified = qtrue;
+	}
+	net_socksUsername = Cvar_Get( "net_socksUsername", "", CVAR_LATCH | CVAR_ARCHIVE );
+
+	if( net_socksPassword && net_socksPassword->modified ) {
+		modified = qtrue;
+	}
+	net_socksPassword = Cvar_Get( "net_socksPassword", "", CVAR_LATCH | CVAR_ARCHIVE );
+
+
+	return modified;
+}
+
+
+/*
+====================
+NET_Config
+====================
+*/
+void NET_Config( qboolean enableNetworking ) {
+	qboolean	modified;
+	qboolean	stop;
+	qboolean	start;
+
+	// get any latched changes to cvars
+	modified = NET_GetCvars();
+
+	if( net_noudp->integer && net_noipx->integer ) {
+		enableNetworking = qfalse;
+	}
+
+	// if enable state is the same and no cvars were modified, we have nothing to do
+	if( enableNetworking == networkingEnabled && !modified ) {
+		return;
+	}
+
+	if( enableNetworking == networkingEnabled ) {
+		if( enableNetworking ) {
+			stop = qtrue;
+			start = qtrue;
+		}
+		else {
+			stop = qfalse;
+			start = qfalse;
+		}
+	}
+	else {
+		if( enableNetworking ) {
+			stop = qfalse;
+			start = qtrue;
+		}
+		else {
+			stop = qtrue;
+			start = qfalse;
+		}
+		networkingEnabled = enableNetworking;
+	}
+
+	if( stop ) {
+		if ( ip_socket && ip_socket != INVALID_SOCKET ) {
+			closesocket( ip_socket );
+			ip_socket = INVALID_SOCKET;
+		}
+
+		if ( socks_socket && socks_socket != INVALID_SOCKET ) {
+			closesocket( socks_socket );
+			socks_socket = INVALID_SOCKET;
+		}
+
+		if ( ipx_socket && ipx_socket != INVALID_SOCKET ) {
+			closesocket( ipx_socket );
+			ipx_socket = INVALID_SOCKET;
+		}
+	}
+
+	if( start ) {
+		if (! net_noudp->integer ) {
+			NET_OpenIP();
+		}
+#ifndef _XBOX
+		if (! net_noipx->integer ) {
+			NET_OpenIPX();
+		}
+#endif
+	}
+}
+
+
+/*
+====================
+NET_Init
+====================
+*/
+void NET_Init( void ) {
+	int		r;
+
+#ifdef _XBOX
+	// Run NetStartup with security bypassed
+	// this allows us to communicate with PCs while developing
+	XNetStartupParams xnsp;
+    ZeroMemory( &xnsp, sizeof(xnsp) );
+    xnsp.cfgSizeOfStruct = sizeof(xnsp);
+
+#ifdef _DEBUG
+	xnsp.cfgFlags |= XNET_STARTUP_BYPASS_SECURITY;
+#else
+	xnsp.cfgFlags |= XNET_STARTUP_BYPASS_SECURITY;
+//	xnsp.cfgFlags = 0;
+#endif
+
+	INT err = XNetStartup( &xnsp );
+#endif
+
+	r = WSAStartup( MAKEWORD( 1, 1 ), &winsockdata );
+	if( r ) {
+		Com_Printf( "WARNING: Winsock initialization failed, returned %d\n", r );
+		return;
+	}
+
+	winsockInitialized = qtrue;
+	Com_Printf( "Winsock Initialized\n" );
+
+	// this is really just to get the cvars registered
+	NET_GetCvars();
+
+	//FIXME testing!
+	NET_Config( qtrue );
+}
+
+
+/*
+====================
+NET_Shutdown
+====================
+*/
+void NET_Shutdown( void ) {
+	if ( !winsockInitialized ) {
+		return;
+	}
+
+	NET_Config( qfalse );
+	WSACleanup();
+	winsockInitialized = qfalse;
+}
+
+
+/*
+====================
+NET_Sleep
+
+sleeps msec or until net socket is ready
+====================
+*/
+void NET_Sleep( int msec ) {
+}
+
+
+/*
+====================
+NET_Restart_f
+====================
+*/
+void NET_Restart( void ) {
+	NET_Config( networkingEnabled );
+}
diff --git a/codemp/win32/win_qal_xbox.cpp b/codemp/win32/win_qal_xbox.cpp
new file mode 100644
index 0000000..0992cda
--- /dev/null
+++ b/codemp/win32/win_qal_xbox.cpp
@@ -0,0 +1,1321 @@
+
+/*
+ * UNPUBLISHED -- Rights  reserved  under  the  copyright  laws  of the 
+ * United States.  Use  of a copyright notice is precautionary only and 
+ * does not imply publication or disclosure.                            
+ *                                                                      
+ * THIS DOCUMENTATION CONTAINS CONFIDENTIAL AND PROPRIETARY INFORMATION 
+ * OF    VICARIOUS   VISIONS,  INC.    ANY  DUPLICATION,  MODIFICATION, 
+ * DISTRIBUTION, OR DISCLOSURE IS STRICTLY PROHIBITED WITHOUT THE PRIOR 
+ * EXPRESS WRITTEN PERMISSION OF VICARIOUS VISIONS, INC.
+ */
+
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+
+#include "win_local.h"
+
+#include "../client/openal/al.h"
+#include "../client/openal/alc.h"
+
+#include <dsound.h>
+//#include <dsstdfx.h>
+#include "snd_fx_img.h"
+
+#include <cmath>
+#include <deque>
+#include <map>
+
+#define QAL_STREAM_WAIT_TIME (500)
+#define QAL_MAX_STREAM_PACKETS (2)
+
+// About 1 second of audio at 44100, stereo, ADPCM
+#define QAL_STREAM_PACKET_SIZE (44136)
+
+// Un-comment to enable 5-channel 3-d sound mixing
+//#define _FIVE_CHANNEL
+
+extern HANDLE Sys_FileStreamMutex;
+extern const char* Sys_GetFileCodeName(int code);
+
+/***********************************************
+*
+* OpenAL STATE - Main container for all AL objects
+*
+************************************************/
+
+struct QALState
+{
+	IDirectSound8*		m_SoundObject;
+	LPDSEFFECTIMAGEDESC	m_ImageDesc;
+
+	ALuint m_MemoryUsed;
+	ALenum m_Error;
+	FLOAT m_Gain;
+
+	struct ListenerInfo
+	{
+		D3DXVECTOR3 m_Position;
+		D3DXMATRIX m_LTM;
+	};
+	typedef std::map<ALuint, ListenerInfo*> listener_t;
+	listener_t m_Listeners;
+	ALuint m_NextListener;
+
+	struct SourceInfo
+	{
+		typedef std::map<ALuint, IDirectSoundBuffer*> voice_t;
+		voice_t m_Voices;
+		
+		ALuint m_Buffer;
+		
+		FLOAT m_Gain;
+		bool m_GainDirty;
+
+		bool m_Loop;
+		
+		bool m_Is3d;
+		D3DXVECTOR3 m_Position;
+	};
+	typedef std::map<ALuint, SourceInfo*> source_t;
+	source_t m_Sources;
+	ALuint m_NextSource;
+
+	struct BufferInfo
+	{
+		void* m_Data;
+		DWORD m_DataOffset;
+		XBOXADPCMWAVEFORMAT m_WAVFormat;
+		
+		DWORD m_Freq;
+		DWORD m_Size;
+		
+		bool m_Valid;
+	};
+	typedef std::map<ALuint, BufferInfo*> buffer_t;
+	buffer_t m_Buffers;
+	ALuint m_NextBuffer;
+
+	struct StreamInfo
+	{
+		IDirectSoundStream* m_pVoice;
+		XFileMediaObject* m_pFile;
+
+		unsigned int m_StartTime;
+
+		bool m_Open;
+		bool m_Playing;
+		bool m_Valid;
+		
+		FLOAT m_Gain;
+		bool m_GainDirty;
+
+		bool m_Looping;
+
+		void* m_pPacketBuffer;
+		DWORD m_PacketStatus[QAL_MAX_STREAM_PACKETS];
+		DWORD m_CurrentPacket;
+
+		HANDLE m_Thread;
+		HANDLE m_Mutex;
+		HANDLE m_QueueLen;
+
+		enum RequestType
+		{
+			REQ_NOP,
+			REQ_PLAY,
+			REQ_STOP,
+			REQ_SHUTDOWN,
+		};
+
+		struct Request
+		{
+			RequestType m_Type;
+			DWORD m_Data[3];
+		};
+		
+		typedef std::deque<Request> queue_t;
+		queue_t *m_Queue;
+	};
+	StreamInfo m_Stream;
+};
+
+static QALState* s_pState = NULL;
+
+/***********************************************
+*
+* HACK - Voice initialization needs this
+*
+************************************************/
+
+LPDSEFFECTIMAGEDESC getEffectsImageDesc(void)
+{
+	return s_pState->m_ImageDesc;
+}
+
+
+/***********************************************
+*
+* DEVICES AND CONTEXTS
+*
+************************************************/
+
+ALCdevice* alcOpenDevice(ALCubyte *deviceName)
+{
+	if (s_pState) return NULL;
+	s_pState = new QALState;
+	s_pState->m_Stream.m_Queue = new QALState::StreamInfo::queue_t;
+
+	s_pState->m_Gain = 1.f;
+	s_pState->m_Error = AL_NO_ERROR;
+	s_pState->m_MemoryUsed = 0;
+	s_pState->m_NextBuffer = 1;
+	s_pState->m_NextListener = 1;
+	s_pState->m_NextSource = 1;
+	s_pState->m_Stream.m_Valid = false;
+	
+	// init the sound hardware
+	if (DirectSoundCreate(NULL, &s_pState->m_SoundObject, NULL) != DS_OK)
+	{
+		delete s_pState;
+		return NULL;
+	}
+
+	DirectSoundUseFullHRTF();
+
+	// download effects image to hardware
+	void* image;
+	int len = FS_ReadFile("sound/dsstdfx.bin", &image);
+	if (len <= 0)
+	{
+		delete s_pState;
+		return NULL;
+	}
+	
+	DSEFFECTIMAGELOC effect;
+	effect.dwI3DL2ReverbIndex = GraphI3DL2_I3DL2Reverb;
+	effect.dwCrosstalkIndex = GraphXTalk_XTalk;
+	s_pState->m_SoundObject->DownloadEffectsImage(image, len, &effect, &s_pState->m_ImageDesc);
+
+	Z_Free(image);
+
+	// setup default reverb
+	DSI3DL2LISTENER reverb = { DSI3DL2_ENVIRONMENT_PRESET_NOREVERB };
+	s_pState->m_SoundObject->SetI3DL2Listener(&reverb, DS3D_DEFERRED);
+
+	return (ALCdevice*)s_pState->m_SoundObject;
+}
+
+ALCvoid alcCloseDevice(ALCdevice *device)
+{
+	// shutdown the sound hardware
+	s_pState->m_SoundObject->Release();
+	
+	delete s_pState;
+	s_pState = NULL;
+}
+
+ALCcontext* alcCreateContext(ALCdevice *device,ALCint *attrList)
+{
+	return (ALCcontext*)1;
+}
+
+ALCboolean alcMakeContextCurrent(ALCcontext *context)
+{
+	return true;
+}
+
+ALCcontext* alcGetCurrentContext(ALCvoid)
+{
+	return (ALCcontext*)1;
+}
+
+ALCdevice* alcGetContextsDevice(ALCcontext *context)
+{
+	if (!s_pState) return NULL;
+	return (ALCdevice*)s_pState->m_SoundObject;
+}
+
+ALCvoid alcDestroyContext(ALCcontext *context)
+{
+}
+
+ALCenum	alcGetError(ALCdevice *device)
+{
+	return ALC_NO_ERROR;
+}
+
+
+
+
+/***********************************************
+*
+* LISTENERS
+*
+************************************************/
+
+ALvoid alGenListeners( ALsizei n, ALuint* listeners )
+{
+	while (n--)
+	{
+		QALState::ListenerInfo* info = new QALState::ListenerInfo;
+
+		info->m_Position.x = 0.f;
+		info->m_Position.y = 0.f;
+		info->m_Position.z = 0.f;
+
+		D3DXMatrixIdentity(&info->m_LTM);
+		
+		s_pState->m_Listeners[s_pState->m_NextListener] = info;
+		listeners[n] = s_pState->m_NextListener++;
+	}
+}
+
+ALvoid alDeleteListeners( ALsizei n, ALuint* listeners )
+{
+	while (n--)
+	{
+		QALState::listener_t::iterator i = 
+			s_pState->m_Listeners.find(listeners[n]);
+		
+		if (i != s_pState->m_Listeners.end())
+		{
+			delete i->second;
+			s_pState->m_Listeners.erase(i);
+		}
+	}
+}
+
+ALvoid alListenerfv( ALuint listener, ALenum param, ALfloat* values )
+{
+	assert(s_pState->m_Listeners.find(listener) != 
+		s_pState->m_Listeners.end());
+	
+	QALState::ListenerInfo* info = s_pState->m_Listeners[listener];
+	D3DXVECTOR3 right;
+	D3DXMATRIX trans;
+	FLOAT det;
+	
+	switch (param)
+	{
+	case AL_POSITION:
+		info->m_Position.x = values[0];
+		info->m_Position.y = values[1];
+		info->m_Position.z = values[2];
+
+		// translation
+		D3DXMatrixTranslation(&trans, -values[0], -values[1], -values[2]);
+		D3DXMatrixMultiply(&info->m_LTM, &trans, &info->m_LTM);
+		break;
+
+	case AL_ORIENTATION:
+		D3DXMatrixIdentity(&info->m_LTM);
+
+		// at vector
+		info->m_LTM(2, 0) = values[0];
+		info->m_LTM(2, 1) = values[1];
+		info->m_LTM(2, 2) = values[2];
+
+		// up vector
+		info->m_LTM(1, 0) = values[3];
+		info->m_LTM(1, 1) = values[4];
+		info->m_LTM(1, 2) = values[5];
+		
+		// Hack. We switched the sign on values[2] up above, need to do that here
+		D3DXVec3Cross(&right, (D3DXVECTOR3*)&values[0], (D3DXVECTOR3*)&values[3]);
+		
+		// right vector
+		info->m_LTM(0, 0) = right.x;
+		info->m_LTM(0, 1) = right.y;
+		info->m_LTM(0, 2) = right.z;
+
+		// convert to local space transform
+		D3DXMatrixInverse(&info->m_LTM, &det, &info->m_LTM);
+
+		// translation
+		D3DXMatrixTranslation(&trans, 
+			-info->m_Position.x, -info->m_Position.y, -info->m_Position.z);
+		D3DXMatrixMultiply(&info->m_LTM, &trans, &info->m_LTM);
+		break;
+	}
+}
+
+
+
+
+/***********************************************
+*
+* SOURCES
+*
+************************************************/
+
+static void _wavSetFormat(XBOXADPCMWAVEFORMAT* wav, ALenum format, ALsizei freq)
+{
+	switch (format)
+	{
+	case AL_FORMAT_MONO4:
+		wav->wfx.wFormatTag = WAVE_FORMAT_XBOX_ADPCM;
+		wav->wfx.nChannels = 1;
+		wav->wfx.nSamplesPerSec = freq;
+		wav->wfx.nBlockAlign = 36 * wav->wfx.nChannels;
+		wav->wfx.nAvgBytesPerSec = wav->wfx.nSamplesPerSec * wav->wfx.nBlockAlign / 64;
+		wav->wfx.wBitsPerSample = 4;
+		wav->wfx.cbSize = sizeof(XBOXADPCMWAVEFORMAT) - sizeof(WAVEFORMATEX);
+		wav->wSamplesPerBlock = 64;
+		break;
+
+	case AL_FORMAT_STEREO4:
+		wav->wfx.wFormatTag = WAVE_FORMAT_XBOX_ADPCM;
+		wav->wfx.nChannels = 2;
+		wav->wfx.nSamplesPerSec = freq;
+		wav->wfx.nBlockAlign = 36 * wav->wfx.nChannels;
+		wav->wfx.nAvgBytesPerSec = wav->wfx.nSamplesPerSec * wav->wfx.nBlockAlign / 64;
+		wav->wfx.wBitsPerSample = 4;
+		wav->wfx.cbSize = sizeof(XBOXADPCMWAVEFORMAT) - sizeof(WAVEFORMATEX);
+		wav->wSamplesPerBlock = 64;
+		break;
+
+	case AL_FORMAT_MONO8:
+	case AL_FORMAT_STEREO8:
+	case AL_FORMAT_MONO16:
+	case AL_FORMAT_STEREO16:
+	default:
+		assert(0);
+		break;
+	}
+}
+
+static int _genSource(bool is3d)
+{
+	// alloc a new source
+	QALState::SourceInfo* sinfo = new QALState::SourceInfo;
+
+	// describe the voice
+	XBOXADPCMWAVEFORMAT wav;
+	_wavSetFormat(&wav, AL_FORMAT_MONO4, 22050);
+	
+	DSBUFFERDESC desc;
+	desc.dwSize = sizeof(desc);
+	if (is3d) desc.dwFlags = DSBCAPS_CTRL3D | DSBCAPS_MUTE3DATMAXDISTANCE;
+	else desc.dwFlags = 0;
+	desc.dwBufferBytes = 0;
+	desc.lpwfxFormat = (WAVEFORMATEX*)&wav;
+	desc.lpMixBins = NULL;
+	desc.dwInputMixBin = 0;
+
+	// create voice for all listeners
+	for (QALState::listener_t::iterator l = s_pState->m_Listeners.begin();
+	l != s_pState->m_Listeners.end(); ++l)
+	{
+		// create the voice
+		IDirectSoundBuffer* voice;
+		if (s_pState->m_SoundObject->CreateSoundBuffer(&desc, &voice, NULL) != DS_OK)
+		{
+			s_pState->m_Error = AL_OUT_OF_MEMORY;
+			return false;
+		}
+
+		sinfo->m_Voices[l->first] = voice;
+
+		// only create a single voice for 2d sounds
+		if (!is3d) break;
+	}
+
+	// setup some defaults
+	sinfo->m_Buffer = 0;
+
+	sinfo->m_Gain = 1.f;
+	sinfo->m_GainDirty = true;
+	sinfo->m_Loop = false;
+
+	sinfo->m_Is3d = is3d;
+	sinfo->m_Position.x = 0.f;
+	sinfo->m_Position.y = 0.f;
+	sinfo->m_Position.z = 0.f;
+	
+	s_pState->m_Sources[s_pState->m_NextSource] = sinfo;
+
+	return true;
+}
+
+static void _attachBuffer(ALuint source, ALuint buffer)
+{
+	assert(s_pState->m_Sources.find(source) != s_pState->m_Sources.end());
+	assert(s_pState->m_Buffers.find(buffer) != s_pState->m_Buffers.end());
+	
+	QALState::SourceInfo* sinfo = s_pState->m_Sources[source];
+	QALState::BufferInfo* binfo = s_pState->m_Buffers[buffer];
+	
+	// setup voices for all listeners
+	for (QALState::SourceInfo::voice_t::iterator v = sinfo->m_Voices.begin(); 
+	v != sinfo->m_Voices.end(); ++v)
+	{
+		v->second->SetFormat((WAVEFORMATEX*)&binfo->m_WAVFormat);
+
+#ifdef _FIVE_CHANNEL
+		DSMIXBINVOLUMEPAIR dsmbvp[6] = {
+			DSMIXBINVOLUMEPAIRS_DEFAULT_5CHANNEL_3D,
+		};
+		DSMIXBINS dsmb;
+		dsmb.dwMixBinCount = 6;
+		dsmb.lpMixBinVolumePairs = dsmbvp;
+		
+		v->second->SetMixBins(&dsmb);
+#endif
+
+		v->second->SetBufferData((char*)binfo->m_Data + binfo->m_DataOffset, binfo->m_Size);
+	}
+	
+	sinfo->m_Buffer = buffer;
+}
+
+static void _dettachBuffer(ALuint source)
+{
+	assert(s_pState->m_Sources.find(source) != s_pState->m_Sources.end());
+	
+	QALState::SourceInfo* info = s_pState->m_Sources[source];
+
+	// clear buffer on voices
+	for (QALState::SourceInfo::voice_t::iterator v = info->m_Voices.begin(); 
+	v != info->m_Voices.end(); ++v)
+	{
+		v->second->Stop();
+		v->second->SetBufferData(NULL, 0);
+	}
+
+	info->m_Buffer = 0;
+}
+
+static void _sourceSetRefDist(QALState::SourceInfo* info, FLOAT value)
+{
+	for (QALState::SourceInfo::voice_t::iterator v = info->m_Voices.begin(); 
+	v != info->m_Voices.end(); ++v)
+	{
+		// In order to prevent debug DX from complaining that
+		// the max dist is greater than the min dist, I clear
+		// the min dist _before_ setting the max.  Ug.
+		v->second->SetMinDistance(1, DS3D_DEFERRED);
+
+		// New algorithm - ref dist is supposed to be dist at which sound is 1/2 volume,
+		// which happens at double min distance in DS, thus: (reverted)
+		v->second->SetMaxDistance(value * 10.f, DS3D_DEFERRED);
+		v->second->SetMinDistance(value, DS3D_DEFERRED);
+//		v->second->SetMinDistance(value / 2.f, DS3D_DEFERRED);
+	}
+}
+
+ALvoid alGenSources2D( ALsizei n, ALuint* sources )
+{
+	while (n--)
+	{
+		if (!_genSource(false)) break;
+		sources[n] = s_pState->m_NextSource++;
+	}
+}
+
+ALvoid alGenSources3D( ALsizei n, ALuint* sources )
+{
+	while (n--)
+	{
+		if (!_genSource(true)) break;
+		sources[n] = s_pState->m_NextSource++;
+	}
+}
+
+ALvoid alDeleteSources( ALsizei n, ALuint* sources )
+{
+	while (n--)
+	{
+		QALState::source_t::iterator i = 
+			s_pState->m_Sources.find(sources[n]);
+
+		if (i != s_pState->m_Sources.end())
+		{
+			QALState::SourceInfo* info = i->second;
+
+			// stop using any buffers
+			_dettachBuffer(sources[n]);			
+
+			// free associated voices
+			for (QALState::SourceInfo::voice_t::iterator v = info->m_Voices.begin(); 
+			v != info->m_Voices.end(); ++v)
+			{
+				v->second->Release();
+			}
+			
+			delete info;
+			s_pState->m_Sources.erase(i);
+		}
+	}
+}
+
+ALvoid alSourcei( ALuint source, ALenum param, ALint value )
+{
+	assert(s_pState->m_Sources.find(source) != s_pState->m_Sources.end());
+
+	switch (param)
+	{
+	case AL_LOOPING:
+		s_pState->m_Sources[source]->m_Loop = value;
+		break;
+
+	case AL_BUFFER:
+		if (value) _attachBuffer(source, value);
+		break;
+
+	default:
+		assert(0);
+		break;
+	}
+}
+
+ALvoid alSourcef( ALuint source, ALenum param, ALfloat value )
+{
+	assert(s_pState->m_Sources.find(source) != s_pState->m_Sources.end());
+	
+	QALState::SourceInfo* info = s_pState->m_Sources[source];
+
+	switch (param)
+	{
+	case AL_REFERENCE_DISTANCE:
+		_sourceSetRefDist(info, value);
+		break;
+	case AL_GAIN:
+		info->m_Gain = value;
+		info->m_GainDirty = true;
+		break;
+	default:
+		assert(0);
+		break;
+	}
+}
+
+ALvoid alSourcefv( ALuint source, ALenum param, ALfloat* values )
+{
+	assert(s_pState->m_Sources.find(source) != s_pState->m_Sources.end());
+	
+	QALState::SourceInfo* info = s_pState->m_Sources[source];
+
+	switch (param)
+	{
+	case AL_POSITION:
+		assert(info->m_Is3d);
+		info->m_Position.x = values[0];
+		info->m_Position.y = values[1];
+		info->m_Position.z = values[2];
+		break;
+	default:
+		assert(0);
+		break;
+	}
+}
+
+ALvoid alSourceStop( ALuint source )
+{
+	assert(s_pState->m_Sources.find(source) != s_pState->m_Sources.end());
+	
+	QALState::SourceInfo* info = s_pState->m_Sources[source];
+
+	// stop playing for all listeners
+	for (QALState::SourceInfo::voice_t::iterator v = info->m_Voices.begin(); 
+	v != info->m_Voices.end(); ++v)
+	{
+		v->second->Stop();
+		
+		DWORD status = 1;		// Wait for voice to turn off
+		do { 
+			v->second->GetStatus(&status);
+		} while (status != 0);
+			
+	}
+}
+
+ALvoid alSourcePlay( ALuint source )
+{
+	assert(s_pState->m_Sources.find(source) != s_pState->m_Sources.end());
+	
+	QALState::SourceInfo* info = s_pState->m_Sources[source];
+
+	if (!info->m_Buffer)
+	{
+		return;
+	}
+
+	// start playing for all listeners
+	for (QALState::SourceInfo::voice_t::iterator v = info->m_Voices.begin(); 
+	v != info->m_Voices.end(); ++v)
+	{
+		v->second->SetCurrentPosition(0);
+		v->second->Play(0, 0, info->m_Loop ? DSBPLAY_LOOPING : 0);
+	}
+}
+
+ALvoid alGetSourcei( ALuint source, ALenum param, ALint* value )
+{
+	assert(s_pState->m_Sources.find(source) != s_pState->m_Sources.end());
+	
+	QALState::SourceInfo* info = s_pState->m_Sources[source];
+
+	switch (param)
+	{
+	case AL_SOURCE_STATE:
+		{
+			DWORD status;
+			info->m_Voices.begin()->second->GetStatus(&status);
+			*value = (status & DSBSTATUS_PLAYING) ? AL_PLAYING : AL_STOPPED;
+		}
+		break;
+	default:
+		assert(0);
+		break;
+	}
+}
+
+
+
+
+/***********************************************
+*
+* BUFFERS
+*
+************************************************/
+
+ALvoid alGenBuffers( ALsizei n, ALuint* buffers )
+{
+	while (n--)
+	{
+		QALState::BufferInfo* info = new QALState::BufferInfo;
+
+		info->m_Valid = false;
+
+		s_pState->m_Buffers[s_pState->m_NextBuffer] = info;
+		buffers[n] = s_pState->m_NextBuffer++;
+	}
+}
+
+ALvoid alDeleteBuffers( ALsizei n, ALuint* buffers )
+{
+	while (n--)
+	{
+		QALState::buffer_t::iterator b = 
+			s_pState->m_Buffers.find(buffers[n]);
+
+		// check if the buffer exists
+		if (b != s_pState->m_Buffers.end())
+		{
+			QALState::BufferInfo* binfo = b->second;
+			
+			if (binfo->m_Valid)
+			{
+				// dettach buffer from any sources using it (may block)
+				for (QALState::source_t::iterator s = s_pState->m_Sources.begin();
+				s != s_pState->m_Sources.end(); ++s)
+				{
+					QALState::SourceInfo* sinfo = s->second;
+					if (sinfo->m_Buffer == buffers[n])
+					{
+						_dettachBuffer(s->first);
+					}
+				}
+			
+				// free the memory
+				Z_Free(binfo->m_Data);
+				s_pState->m_MemoryUsed -= binfo->m_Size;
+			}
+		
+			delete b->second;
+			s_pState->m_Buffers.erase(b);
+		}
+	}
+}
+
+ALvoid alBufferData( ALuint buffer, ALenum format, ALvoid* data, ALsizei size, ALsizei freq )
+{
+	assert(s_pState->m_Buffers.find(buffer) != s_pState->m_Buffers.end());
+	
+	QALState::BufferInfo* info = s_pState->m_Buffers[buffer];
+	
+	// if this buffer has been used before, clear the old data
+	if (info->m_Valid)
+	{
+		Z_Free(info->m_Data);
+		s_pState->m_MemoryUsed -= info->m_Size;
+		info->m_Valid = false;
+	}
+
+	info->m_Data = data;
+
+	// assume we have a wave file...
+	WAVEFORMATEX* wav = (WAVEFORMATEX*)((char*)data + 20);
+	info->m_DataOffset = 20 + sizeof(WAVEFORMATEX) + wav->cbSize + 8;
+
+	info->m_Size = size;
+	s_pState->m_MemoryUsed += info->m_Size;
+
+	_wavSetFormat(&info->m_WAVFormat, format, freq);
+	
+	info->m_Valid = true;
+}
+
+
+/***********************************************
+*
+* STREAMS
+*
+************************************************/
+
+static int _streamFromFile(void)
+{
+	DWORD total = 0;
+	DWORD used = 0;
+	
+	// setup a media packet for reading from the file
+	XMEDIAPACKET xmp;
+	ZeroMemory(&xmp, sizeof(xmp));
+	xmp.pvBuffer = (BYTE *)s_pState->m_Stream.m_pPacketBuffer +
+		(QAL_STREAM_PACKET_SIZE * s_pState->m_Stream.m_CurrentPacket);
+	xmp.dwMaxSize = QAL_STREAM_PACKET_SIZE;
+	xmp.pdwCompletedSize = &used;
+	
+	WaitForSingleObject(Sys_FileStreamMutex, INFINITE);
+
+	// loop until we have a full packet of data
+	while (total < QAL_STREAM_PACKET_SIZE)
+	{
+		if (DS_OK != s_pState->m_Stream.m_pFile->Process(NULL, &xmp))
+		{
+			ReleaseMutex(Sys_FileStreamMutex);
+			return -1;
+		}
+		
+		total += used;
+		
+		// did we get enough data?
+		if (used < xmp.dwMaxSize)
+		{
+			if (s_pState->m_Stream.m_Looping)
+			{
+				// must have reached the end of the file, loop back
+				// around to the beginning and get more data
+				xmp.pvBuffer  = (BYTE*)xmp.pvBuffer + used;
+				xmp.dwMaxSize = xmp.dwMaxSize - used;
+				
+				if (DS_OK != s_pState->m_Stream.m_pFile->Seek(
+					0, FILE_BEGIN, NULL))
+				{
+					ReleaseMutex(Sys_FileStreamMutex);
+					return -1;
+				}
+			}
+			else
+			{
+				// reached end, finish up
+				s_pState->m_Stream.m_Playing = false;
+				ReleaseMutex(Sys_FileStreamMutex);
+				return used;
+			}
+		}
+	}
+
+	ReleaseMutex(Sys_FileStreamMutex);
+
+	return QAL_STREAM_PACKET_SIZE;
+}
+
+static void _streamToVoice(int size)
+{
+	// setup a packet with the current data
+	XMEDIAPACKET xmp;
+	ZeroMemory(&xmp, sizeof(xmp));
+	xmp.pvBuffer = (BYTE *)s_pState->m_Stream.m_pPacketBuffer +
+		(QAL_STREAM_PACKET_SIZE * s_pState->m_Stream.m_CurrentPacket);
+	xmp.dwMaxSize = size;
+	xmp.pdwStatus = &s_pState->m_Stream.m_PacketStatus[
+		s_pState->m_Stream.m_CurrentPacket];
+
+	// sent to the voice
+	s_pState->m_Stream.m_pVoice->Process(&xmp, NULL);
+
+	// make sure we're playing
+	s_pState->m_Stream.m_pVoice->Pause(DSSTREAMPAUSE_RESUME);
+	if (s_pState->m_Stream.m_StartTime == 0)
+	{
+		s_pState->m_Stream.m_StartTime = Sys_Milliseconds();
+	}
+}
+
+static void _streamFill(void)
+{
+	// do we have any free packets?
+	if (XMEDIAPACKET_STATUS_PENDING !=
+		s_pState->m_Stream.m_PacketStatus[s_pState->m_Stream.m_CurrentPacket])
+	{
+		// get some data
+		int size = _streamFromFile();
+		if (size > 0)
+		{
+			_streamToVoice(size);
+	
+			// next packet...
+			++s_pState->m_Stream.m_CurrentPacket;
+			s_pState->m_Stream.m_CurrentPacket %= QAL_MAX_STREAM_PACKETS;
+		}
+
+		if (!s_pState->m_Stream.m_Playing)
+		{
+			// Non-looping stream finished playback
+			s_pState->m_Stream.m_pVoice->Discontinuity();
+		}
+	}
+}
+
+static void _streamOpen(DWORD file, DWORD offset, bool loop)
+{
+	if (s_pState->m_Stream.m_Open)
+	{
+		// if a stream is current playing, interrupt it
+		s_pState->m_Stream.m_pVoice->Flush();
+		s_pState->m_Stream.m_pFile->Release();
+		s_pState->m_Stream.m_Playing = false;
+		s_pState->m_Stream.m_Open = false;
+	}
+
+	const char* name = Sys_GetFileCodeName(file);
+	
+	WaitForSingleObject(Sys_FileStreamMutex, INFINITE);
+
+	// open the file for streaming
+	LPCWAVEFORMATEX fmt;
+	if (DS_OK == XWaveFileCreateMediaObject(
+		name, &fmt, &s_pState->m_Stream.m_pFile))
+	{
+		// set the voice based on the file format
+		s_pState->m_Stream.m_pVoice->SetFormat(fmt);
+
+#ifdef _FIVE_CHANNEL
+		DSMIXBINVOLUMEPAIR dsmbvp[6] = {
+			DSMIXBINVOLUMEPAIRS_DEFAULT_5CHANNEL_3D,
+		};
+		DSMIXBINS dsmb;
+		dsmb.dwMixBinCount = 6;
+		dsmb.lpMixBinVolumePairs = dsmbvp;
+
+		s_pState->m_Stream.m_pVoice->SetMixBins(&dsmb);
+#endif
+
+		// seek the requested start position
+		s_pState->m_Stream.m_pFile->Seek(RoundDown(offset, 72), 
+			FILE_BEGIN, NULL);
+		
+		s_pState->m_Stream.m_StartTime = 0;
+		s_pState->m_Stream.m_Looping = loop;
+		s_pState->m_Stream.m_Playing = true;
+		s_pState->m_Stream.m_Open = true;
+	}
+
+	ReleaseMutex(Sys_FileStreamMutex);
+}
+
+static void _streamClose(void)
+{
+	if (s_pState->m_Stream.m_Open)
+	{
+		// stop the stream
+		s_pState->m_Stream.m_pVoice->Flush();
+		s_pState->m_Stream.m_pFile->Release();
+		s_pState->m_Stream.m_Playing = false;
+		s_pState->m_Stream.m_Open = false;
+	}
+}
+
+static DWORD WINAPI _streamThread(LPVOID lpParameter)
+{
+	for (;;)
+	{
+		QALState::StreamInfo* strm = &s_pState->m_Stream;
+		QALState::StreamInfo::Request req;
+		
+		// Wait for the queue to fill
+		WaitForSingleObject(strm->m_QueueLen, QAL_STREAM_WAIT_TIME);
+		
+		// Grab the next request
+		WaitForSingleObject(strm->m_Mutex, INFINITE);
+		if (!strm->m_Queue->empty())
+		{
+			req = strm->m_Queue->front();
+			strm->m_Queue->pop_front();
+		}
+		else
+		{
+			req.m_Type = QALState::StreamInfo::REQ_NOP;
+		}
+		ReleaseMutex(strm->m_Mutex);
+
+		// Process request
+		switch (req.m_Type)
+		{
+		case QALState::StreamInfo::REQ_PLAY:
+			_streamOpen(req.m_Data[0], req.m_Data[1], req.m_Data[2]);
+			break;
+
+		case QALState::StreamInfo::REQ_STOP:
+			_streamClose();
+			break;
+
+		case QALState::StreamInfo::REQ_SHUTDOWN:
+			ExitThread(0);
+			break;
+
+		case QALState::StreamInfo::REQ_NOP:
+			break;
+		}
+
+		// fill the stream with data
+		if (strm->m_Open && strm->m_Playing)
+		{
+			_streamFill();
+		}
+	}
+}
+
+static void _postStreamRequest(const QALState::StreamInfo::Request& req)
+{
+	// Add request to queue
+	WaitForSingleObject(s_pState->m_Stream.m_Mutex, INFINITE);
+	s_pState->m_Stream.m_Queue->push_back(req);
+	ReleaseMutex(s_pState->m_Stream.m_Mutex);
+
+	// Let thread know it has one more pending request
+	ReleaseSemaphore(s_pState->m_Stream.m_QueueLen, 1, NULL);
+
+	// Give the stream thread some CPU
+	Sleep(0);
+}
+
+void Sys_StreamRequestQueueClear(void)
+{
+	WaitForSingleObject(s_pState->m_Stream.m_Mutex, INFINITE);
+	delete s_pState->m_Stream.m_Queue;
+	s_pState->m_Stream.m_Queue = new QALState::StreamInfo::queue_t;
+	ReleaseMutex(s_pState->m_Stream.m_Mutex);
+}
+
+ALvoid alGenStream( ALvoid )
+{
+	assert(!s_pState->m_Stream.m_Valid);
+	
+	// describe the stream
+	XBOXADPCMWAVEFORMAT wav;
+	_wavSetFormat(&wav, AL_FORMAT_STEREO4, 44100);
+	
+	DSSTREAMDESC desc;
+	ZeroMemory(&desc, sizeof(desc));
+	desc.dwMaxAttachedPackets = QAL_MAX_STREAM_PACKETS;
+	desc.lpwfxFormat = (WAVEFORMATEX*)&wav;
+	
+	// create a voice for the stream
+	if (s_pState->m_SoundObject->CreateSoundStream(&desc, 
+		&s_pState->m_Stream.m_pVoice, NULL) != DS_OK)
+	{
+		s_pState->m_Error = AL_OUT_OF_MEMORY;
+		return;
+	}
+
+	// get some memory to hold the stream data
+	s_pState->m_Stream.m_pPacketBuffer = 
+		XPhysicalAlloc(QAL_MAX_STREAM_PACKETS * QAL_STREAM_PACKET_SIZE,
+		MAXULONG_PTR, 0, PAGE_READWRITE | PAGE_NOCACHE);
+
+	// setup some defaults
+	s_pState->m_Stream.m_Gain = 1.f;
+	s_pState->m_Stream.m_GainDirty = true;
+
+	s_pState->m_Stream.m_CurrentPacket = 0;
+	for (int p = 0; p < QAL_MAX_STREAM_PACKETS; ++p)
+	{
+		s_pState->m_Stream.m_PacketStatus[p] = XMEDIAPACKET_STATUS_SUCCESS;
+	}
+
+	s_pState->m_Stream.m_Open = false;
+	s_pState->m_Stream.m_Playing = false;
+	s_pState->m_Stream.m_Valid = true;
+
+	// setup a thread to service the stream (keep blocking IO out
+	// of the main thread)
+	s_pState->m_Stream.m_QueueLen = CreateSemaphore(NULL, 0, 256, NULL);
+	s_pState->m_Stream.m_Mutex = CreateMutex(NULL, FALSE, NULL);
+	s_pState->m_Stream.m_Thread = CreateThread(NULL, 0, 
+		_streamThread, NULL, 0, NULL );
+}
+
+ALvoid alDeleteStream( ALvoid )
+{
+	assert(s_pState->m_Stream.m_Valid);
+	
+	// stop the audio
+	alStreamStop();
+
+	// kill the thread
+	QALState::StreamInfo::Request req;
+	req.m_Type = QALState::StreamInfo::REQ_SHUTDOWN;
+	_postStreamRequest(req);
+	
+	// Wait for thread to close
+	WaitForSingleObject(s_pState->m_Stream.m_Thread, INFINITE);
+
+	// thread handles
+	CloseHandle(s_pState->m_Stream.m_Thread);
+	CloseHandle(s_pState->m_Stream.m_Mutex);
+	CloseHandle(s_pState->m_Stream.m_QueueLen);
+
+	// release the stream
+	s_pState->m_Stream.m_pVoice->Release();
+	XPhysicalFree(s_pState->m_Stream.m_pPacketBuffer);
+
+	s_pState->m_Stream.m_Valid = false;
+}
+
+ALvoid alStreamStop( ALvoid )
+{
+	assert(s_pState->m_Stream.m_Valid);
+
+	QALState::StreamInfo::Request req;
+	req.m_Type = QALState::StreamInfo::REQ_STOP;
+	_postStreamRequest(req);	
+}
+
+ALvoid alStreamPlay( ALsizei offset, ALint file, ALint loop )
+{
+	assert(s_pState->m_Stream.m_Valid);
+
+	QALState::StreamInfo::Request req;
+	req.m_Type = QALState::StreamInfo::REQ_PLAY;
+	req.m_Data[0] = file;
+	req.m_Data[1] = offset;
+	req.m_Data[2] = loop;
+	_postStreamRequest(req);
+
+	s_pState->m_Stream.m_Playing = true;
+}
+
+ALvoid alStreamf( ALenum param, ALfloat value )
+{
+	assert(s_pState->m_Stream.m_Valid);
+
+	switch (param)
+	{
+	case AL_GAIN:
+		s_pState->m_Stream.m_Gain = value;
+		s_pState->m_Stream.m_GainDirty = true;
+		break;
+	default:
+		assert(0);
+		break;
+	}
+}
+
+ALvoid alGetStreamf( ALenum param, ALfloat* value )
+{
+	assert(s_pState->m_Stream.m_Valid);
+
+	switch (param)
+	{
+	case AL_TIME:
+		if (s_pState->m_Stream.m_Open && s_pState->m_Stream.m_StartTime)
+		{
+			*value = (float)(Sys_Milliseconds() - 
+				s_pState->m_Stream.m_StartTime) / 1000.f;
+		}
+		else
+		{
+			*value = 0.f;
+		}
+		break;
+	default:
+		assert(0);
+		break;
+	}
+}
+
+ALvoid alGetStreami( ALenum param, ALint* value )
+{
+	assert(s_pState->m_Stream.m_Valid);
+
+	switch (param)
+	{
+	case AL_SOURCE_STATE:
+		*value = s_pState->m_Stream.m_Playing ? AL_PLAYING : AL_STOPPED;
+		break;
+	default:
+		assert(0);
+		break;
+	}
+}
+
+
+
+/***********************************************
+*
+* ADDITIONAL FUNCTIONS
+*
+************************************************/
+
+static void _updateVoiceGain(IDirectSoundBuffer* voice, FLOAT gain)
+{
+	// compute aggregate gain
+	FLOAT g = s_pState->m_Gain * gain;
+	
+	if (g <= 0.f)
+	{
+		// mute the sound
+		voice->SetVolume(DSBVOLUME_MIN);
+	}
+	else
+	{
+		// convert to dB
+		g = 20.f * log10(g);
+
+		if(g < -100.0f) {
+			g = -100.0f;
+		}
+
+		// set the volume
+		voice->SetVolume(g * 100.f);
+	}
+}
+
+static void _updateVoicePos(IDirectSoundBuffer* voice, D3DXVECTOR3* pos,
+	QALState::ListenerInfo* listener)
+{
+	// get source pos in listener space
+	D3DXVECTOR4 lpos;
+	D3DXVec3Transform(&lpos, pos, &listener->m_LTM);
+
+	voice->SetPosition(lpos.x, lpos.y, lpos.z, DS3D_DEFERRED);
+}
+
+static void _updateSource(QALState::SourceInfo* source)
+{
+	// loop through all the voices at this source
+	for (QALState::SourceInfo::voice_t::iterator v = source->m_Voices.begin(); 
+	v != source->m_Voices.end(); ++v)
+	{
+		// update the gain
+		if (source->m_GainDirty)
+		{
+			_updateVoiceGain(v->second, source->m_Gain);
+		}
+
+		// update position
+		if (source->m_Is3d)
+		{
+			// get the listener for this voice
+			QALState::listener_t::iterator l = s_pState->m_Listeners.find(v->first);
+
+			if (l != s_pState->m_Listeners.end())
+			{
+				_updateVoicePos(
+					v->second,
+					&source->m_Position, 
+					l->second);
+			}
+		}
+	}
+
+	source->m_GainDirty = false;
+}
+
+static void _updateStream(void)
+{
+	if (s_pState->m_Stream.m_Open && s_pState->m_Stream.m_GainDirty)
+	{
+		// compute aggregate gain
+		FLOAT g = s_pState->m_Gain * s_pState->m_Stream.m_Gain;
+		if (g <= 0.f)
+		{
+			// mute the sound
+			s_pState->m_Stream.m_pVoice->SetVolume(DSBVOLUME_MIN);
+		}
+		else
+		{
+			// convert to dB
+			g = 20.f * log10(g);
+
+			if(g < -100.0f) {
+				g = -100.0f;
+			}
+
+			// set the volume
+			s_pState->m_Stream.m_pVoice->SetVolume(g * 100.f);
+		}
+
+		s_pState->m_Stream.m_GainDirty = false;
+	}
+}
+
+ALenum alGetError( ALvoid )
+{
+	ALenum error = s_pState->m_Error;
+	s_pState->m_Error = AL_NO_ERROR;
+	return error;
+}
+
+ALvoid alUpdate( ALvoid )
+{
+	DirectSoundDoWork();
+
+	// update sources
+	for (QALState::source_t::iterator i = s_pState->m_Sources.begin();
+	i != s_pState->m_Sources.end(); ++i)
+	{
+		QALState::SourceInfo* info = i->second;
+		
+		// 3d sounds and dirty sources must be updated
+		if (info->m_Is3d || info->m_GainDirty)
+		{
+			// only playing sources should be updated
+			DWORD status;
+			info->m_Voices.begin()->second->GetStatus(&status);
+
+			if (status & DSBSTATUS_PLAYING)
+			{
+				_updateSource(info);
+			}
+		}
+	}
+
+	// update stream
+	_updateStream();
+
+	s_pState->m_SoundObject->CommitDeferredSettings();
+}
+
+ALvoid alGeti( ALenum param, ALint* value )
+{
+	switch (param)
+	{
+	case AL_MEMORY_USED:
+		*value = s_pState->m_MemoryUsed;
+		break;
+
+	default:
+		assert(0);
+	}
+}
+
+ALvoid alGain( ALfloat value )
+{
+	s_pState->m_Gain = value;
+
+	// set gain dirty for all sources
+	for (QALState::source_t::iterator i = s_pState->m_Sources.begin();
+	i != s_pState->m_Sources.end(); ++i)
+	{
+		i->second->m_GainDirty = true;
+	}
+
+	// set gain dirty for stream
+	s_pState->m_Stream.m_GainDirty = true;
+}
diff --git a/codemp/win32/win_qgl.cpp b/codemp/win32/win_qgl.cpp
new file mode 100644
index 0000000..3c537e7
--- /dev/null
+++ b/codemp/win32/win_qgl.cpp
@@ -0,0 +1,4271 @@
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+/*
+** QGL_WIN.C
+**
+** This file implements the operating system binding of GL to QGL function
+** pointers.  When doing a port of Quake3 you must implement the following
+** two functions:
+**
+** QGL_Init() - loads libraries, assigns function pointers, etc.
+** QGL_Shutdown() - unloads libraries, NULLs function pointers
+*/
+#include <float.h>
+#include "../renderer/tr_local.h"
+#include "glw_win.h"
+
+void QGL_EnableLogging( qboolean enable );
+
+int ( WINAPI * qwglSwapIntervalEXT)( int interval );
+
+BOOL  ( WINAPI * qwglCopyContext)(HGLRC, HGLRC, UINT);
+HGLRC ( WINAPI * qwglCreateContext)(HDC);
+HGLRC ( WINAPI * qwglCreateLayerContext)(HDC, int);
+BOOL  ( WINAPI * qwglDeleteContext)(HGLRC);
+HGLRC ( WINAPI * qwglGetCurrentContext)(VOID);
+HDC   ( WINAPI * qwglGetCurrentDC)(VOID);
+PROC  ( WINAPI * qwglGetProcAddress)(LPCSTR);
+BOOL  ( WINAPI * qwglMakeCurrent)(HDC, HGLRC);
+BOOL  ( WINAPI * qwglShareLists)(HGLRC, HGLRC);
+BOOL  ( WINAPI * qwglUseFontBitmaps)(HDC, DWORD, DWORD, DWORD);
+
+BOOL  ( WINAPI * qwglUseFontOutlines)(HDC, DWORD, DWORD, DWORD, FLOAT,
+                                           FLOAT, int, LPGLYPHMETRICSFLOAT);
+
+BOOL ( WINAPI * qwglDescribeLayerPlane)(HDC, int, int, UINT,
+                                            LPLAYERPLANEDESCRIPTOR);
+int  ( WINAPI * qwglSetLayerPaletteEntries)(HDC, int, int, int,
+                                                CONST COLORREF *);
+int  ( WINAPI * qwglGetLayerPaletteEntries)(HDC, int, int, int,
+                                                COLORREF *);
+BOOL ( WINAPI * qwglRealizeLayerPalette)(HDC, int, BOOL);
+BOOL ( WINAPI * qwglSwapLayerBuffers)(HDC, UINT);
+
+void ( APIENTRY * qglAccum )(GLenum op, GLfloat value);
+void ( APIENTRY * qglAlphaFunc )(GLenum func, GLclampf ref);
+GLboolean ( APIENTRY * qglAreTexturesResident )(GLsizei n, const GLuint *textures, GLboolean *residences);
+void ( APIENTRY * qglArrayElement )(GLint i);
+void ( APIENTRY * qglBegin )(GLenum mode);
+void ( APIENTRY * qglBindTexture )(GLenum target, GLuint texture);
+void ( APIENTRY * qglBitmap )(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap);
+void ( APIENTRY * qglBlendFunc )(GLenum sfactor, GLenum dfactor);
+void ( APIENTRY * qglCallList )(GLuint list);
+void ( APIENTRY * qglCallLists )(GLsizei n, GLenum type, const GLvoid *lists);
+void ( APIENTRY * qglClear )(GLbitfield mask);
+void ( APIENTRY * qglClearAccum )(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
+void ( APIENTRY * qglClearColor )(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
+void ( APIENTRY * qglClearDepth )(GLclampd depth);
+void ( APIENTRY * qglClearIndex )(GLfloat c);
+void ( APIENTRY * qglClearStencil )(GLint s);
+void ( APIENTRY * qglClipPlane )(GLenum plane, const GLdouble *equation);
+void ( APIENTRY * qglColor3b )(GLbyte red, GLbyte green, GLbyte blue);
+void ( APIENTRY * qglColor3bv )(const GLbyte *v);
+void ( APIENTRY * qglColor3d )(GLdouble red, GLdouble green, GLdouble blue);
+void ( APIENTRY * qglColor3dv )(const GLdouble *v);
+void ( APIENTRY * qglColor3f )(GLfloat red, GLfloat green, GLfloat blue);
+void ( APIENTRY * qglColor3fv )(const GLfloat *v);
+void ( APIENTRY * qglColor3i )(GLint red, GLint green, GLint blue);
+void ( APIENTRY * qglColor3iv )(const GLint *v);
+void ( APIENTRY * qglColor3s )(GLshort red, GLshort green, GLshort blue);
+void ( APIENTRY * qglColor3sv )(const GLshort *v);
+void ( APIENTRY * qglColor3ub )(GLubyte red, GLubyte green, GLubyte blue);
+void ( APIENTRY * qglColor3ubv )(const GLubyte *v);
+void ( APIENTRY * qglColor3ui )(GLuint red, GLuint green, GLuint blue);
+void ( APIENTRY * qglColor3uiv )(const GLuint *v);
+void ( APIENTRY * qglColor3us )(GLushort red, GLushort green, GLushort blue);
+void ( APIENTRY * qglColor3usv )(const GLushort *v);
+void ( APIENTRY * qglColor4b )(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha);
+void ( APIENTRY * qglColor4bv )(const GLbyte *v);
+void ( APIENTRY * qglColor4d )(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha);
+void ( APIENTRY * qglColor4dv )(const GLdouble *v);
+void ( APIENTRY * qglColor4f )(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
+void ( APIENTRY * qglColor4fv )(const GLfloat *v);
+void ( APIENTRY * qglColor4i )(GLint red, GLint green, GLint blue, GLint alpha);
+void ( APIENTRY * qglColor4iv )(const GLint *v);
+void ( APIENTRY * qglColor4s )(GLshort red, GLshort green, GLshort blue, GLshort alpha);
+void ( APIENTRY * qglColor4sv )(const GLshort *v);
+void ( APIENTRY * qglColor4ub )(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha);
+void ( APIENTRY * qglColor4ubv )(const GLubyte *v);
+void ( APIENTRY * qglColor4ui )(GLuint red, GLuint green, GLuint blue, GLuint alpha);
+void ( APIENTRY * qglColor4uiv )(const GLuint *v);
+void ( APIENTRY * qglColor4us )(GLushort red, GLushort green, GLushort blue, GLushort alpha);
+void ( APIENTRY * qglColor4usv )(const GLushort *v);
+void ( APIENTRY * qglColorMask )(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
+void ( APIENTRY * qglColorMaterial )(GLenum face, GLenum mode);
+void ( APIENTRY * qglColorPointer )(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
+void ( APIENTRY * qglCopyPixels )(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type);
+void ( APIENTRY * qglCopyTexImage1D )(GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border);
+void ( APIENTRY * qglCopyTexImage2D )(GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
+void ( APIENTRY * qglCopyTexSubImage1D )(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);
+void ( APIENTRY * qglCopyTexSubImage2D )(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
+void ( APIENTRY * qglCullFace )(GLenum mode);
+void ( APIENTRY * qglDeleteLists )(GLuint list, GLsizei range);
+void ( APIENTRY * qglDeleteTextures )(GLsizei n, const GLuint *textures);
+void ( APIENTRY * qglDepthFunc )(GLenum func);
+void ( APIENTRY * qglDepthMask )(GLboolean flag);
+void ( APIENTRY * qglDepthRange )(GLclampd zNear, GLclampd zFar);
+void ( APIENTRY * qglDisable )(GLenum cap);
+void ( APIENTRY * qglDisableClientState )(GLenum array);
+void ( APIENTRY * qglDrawArrays )(GLenum mode, GLint first, GLsizei count);
+void ( APIENTRY * qglDrawBuffer )(GLenum mode);
+void ( APIENTRY * qglDrawElements )(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices);
+void ( APIENTRY * qglDrawPixels )(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
+void ( APIENTRY * qglEdgeFlag )(GLboolean flag);
+void ( APIENTRY * qglEdgeFlagPointer )(GLsizei stride, const GLvoid *pointer);
+void ( APIENTRY * qglEdgeFlagv )(const GLboolean *flag);
+void ( APIENTRY * qglEnable )(GLenum cap);
+void ( APIENTRY * qglEnableClientState )(GLenum array);
+void ( APIENTRY * qglEnd )(void);
+void ( APIENTRY * qglEndList )(void);
+void ( APIENTRY * qglEvalCoord1d )(GLdouble u);
+void ( APIENTRY * qglEvalCoord1dv )(const GLdouble *u);
+void ( APIENTRY * qglEvalCoord1f )(GLfloat u);
+void ( APIENTRY * qglEvalCoord1fv )(const GLfloat *u);
+void ( APIENTRY * qglEvalCoord2d )(GLdouble u, GLdouble v);
+void ( APIENTRY * qglEvalCoord2dv )(const GLdouble *u);
+void ( APIENTRY * qglEvalCoord2f )(GLfloat u, GLfloat v);
+void ( APIENTRY * qglEvalCoord2fv )(const GLfloat *u);
+void ( APIENTRY * qglEvalMesh1 )(GLenum mode, GLint i1, GLint i2);
+void ( APIENTRY * qglEvalMesh2 )(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2);
+void ( APIENTRY * qglEvalPoint1 )(GLint i);
+void ( APIENTRY * qglEvalPoint2 )(GLint i, GLint j);
+void ( APIENTRY * qglFeedbackBuffer )(GLsizei size, GLenum type, GLfloat *buffer);
+void ( APIENTRY * qglFinish )(void);
+void ( APIENTRY * qglFlush )(void);
+void ( APIENTRY * qglFogf )(GLenum pname, GLfloat param);
+void ( APIENTRY * qglFogfv )(GLenum pname, const GLfloat *params);
+void ( APIENTRY * qglFogi )(GLenum pname, GLint param);
+void ( APIENTRY * qglFogiv )(GLenum pname, const GLint *params);
+void ( APIENTRY * qglFrontFace )(GLenum mode);
+void ( APIENTRY * qglFrustum )(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
+GLuint ( APIENTRY * qglGenLists )(GLsizei range);
+void ( APIENTRY * qglGenTextures )(GLsizei n, GLuint *textures);
+void ( APIENTRY * qglGetBooleanv )(GLenum pname, GLboolean *params);
+void ( APIENTRY * qglGetClipPlane )(GLenum plane, GLdouble *equation);
+void ( APIENTRY * qglGetDoublev )(GLenum pname, GLdouble *params);
+GLenum ( APIENTRY * qglGetError )(void);
+void ( APIENTRY * qglGetFloatv )(GLenum pname, GLfloat *params);
+void ( APIENTRY * qglGetIntegerv )(GLenum pname, GLint *params);
+void ( APIENTRY * qglGetLightfv )(GLenum light, GLenum pname, GLfloat *params);
+void ( APIENTRY * qglGetLightiv )(GLenum light, GLenum pname, GLint *params);
+void ( APIENTRY * qglGetMapdv )(GLenum target, GLenum query, GLdouble *v);
+void ( APIENTRY * qglGetMapfv )(GLenum target, GLenum query, GLfloat *v);
+void ( APIENTRY * qglGetMapiv )(GLenum target, GLenum query, GLint *v);
+void ( APIENTRY * qglGetMaterialfv )(GLenum face, GLenum pname, GLfloat *params);
+void ( APIENTRY * qglGetMaterialiv )(GLenum face, GLenum pname, GLint *params);
+void ( APIENTRY * qglGetPixelMapfv )(GLenum m, GLfloat *values); //rwwRMG - map->m (avoid map type conflict)
+void ( APIENTRY * qglGetPixelMapuiv )(GLenum m, GLuint *values); //rwwRMG - map->m (avoid map type conflict)
+void ( APIENTRY * qglGetPixelMapusv )(GLenum m, GLushort *values); //rwwRMG - map->m (avoid map type conflict)
+void ( APIENTRY * qglGetPointerv )(GLenum pname, GLvoid* *params);
+void ( APIENTRY * qglGetPolygonStipple )(GLubyte *mask);
+const GLubyte * ( APIENTRY * qglGetString )(GLenum name);
+void ( APIENTRY * qglGetTexEnvfv )(GLenum target, GLenum pname, GLfloat *params);
+void ( APIENTRY * qglGetTexEnviv )(GLenum target, GLenum pname, GLint *params);
+void ( APIENTRY * qglGetTexGendv )(GLenum coord, GLenum pname, GLdouble *params);
+void ( APIENTRY * qglGetTexGenfv )(GLenum coord, GLenum pname, GLfloat *params);
+void ( APIENTRY * qglGetTexGeniv )(GLenum coord, GLenum pname, GLint *params);
+void ( APIENTRY * qglGetTexImage )(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels);
+void ( APIENTRY * qglGetTexLevelParameterfv )(GLenum target, GLint level, GLenum pname, GLfloat *params);
+void ( APIENTRY * qglGetTexLevelParameteriv )(GLenum target, GLint level, GLenum pname, GLint *params);
+void ( APIENTRY * qglGetTexParameterfv )(GLenum target, GLenum pname, GLfloat *params);
+void ( APIENTRY * qglGetTexParameteriv )(GLenum target, GLenum pname, GLint *params);
+void ( APIENTRY * qglHint )(GLenum target, GLenum mode);
+void ( APIENTRY * qglIndexMask )(GLuint mask);
+void ( APIENTRY * qglIndexPointer )(GLenum type, GLsizei stride, const GLvoid *pointer);
+void ( APIENTRY * qglIndexd )(GLdouble c);
+void ( APIENTRY * qglIndexdv )(const GLdouble *c);
+void ( APIENTRY * qglIndexf )(GLfloat c);
+void ( APIENTRY * qglIndexfv )(const GLfloat *c);
+void ( APIENTRY * qglIndexi )(GLint c);
+void ( APIENTRY * qglIndexiv )(const GLint *c);
+void ( APIENTRY * qglIndexs )(GLshort c);
+void ( APIENTRY * qglIndexsv )(const GLshort *c);
+void ( APIENTRY * qglIndexub )(GLubyte c);
+void ( APIENTRY * qglIndexubv )(const GLubyte *c);
+void ( APIENTRY * qglInitNames )(void);
+void ( APIENTRY * qglInterleavedArrays )(GLenum format, GLsizei stride, const GLvoid *pointer);
+GLboolean ( APIENTRY * qglIsEnabled )(GLenum cap);
+GLboolean ( APIENTRY * qglIsList )(GLuint list);
+GLboolean ( APIENTRY * qglIsTexture )(GLuint texture);
+void ( APIENTRY * qglLightModelf )(GLenum pname, GLfloat param);
+void ( APIENTRY * qglLightModelfv )(GLenum pname, const GLfloat *params);
+void ( APIENTRY * qglLightModeli )(GLenum pname, GLint param);
+void ( APIENTRY * qglLightModeliv )(GLenum pname, const GLint *params);
+void ( APIENTRY * qglLightf )(GLenum light, GLenum pname, GLfloat param);
+void ( APIENTRY * qglLightfv )(GLenum light, GLenum pname, const GLfloat *params);
+void ( APIENTRY * qglLighti )(GLenum light, GLenum pname, GLint param);
+void ( APIENTRY * qglLightiv )(GLenum light, GLenum pname, const GLint *params);
+void ( APIENTRY * qglLineStipple )(GLint factor, GLushort pattern);
+void ( APIENTRY * qglLineWidth )(GLfloat width);
+void ( APIENTRY * qglListBase )(GLuint base);
+void ( APIENTRY * qglLoadIdentity )(void);
+void ( APIENTRY * qglLoadMatrixd )(const GLdouble *m);
+void ( APIENTRY * qglLoadMatrixf )(const GLfloat *m);
+void ( APIENTRY * qglLoadName )(GLuint name);
+void ( APIENTRY * qglLogicOp )(GLenum opcode);
+void ( APIENTRY * qglMap1d )(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points);
+void ( APIENTRY * qglMap1f )(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points);
+void ( APIENTRY * qglMap2d )(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points);
+void ( APIENTRY * qglMap2f )(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points);
+void ( APIENTRY * qglMapGrid1d )(GLint un, GLdouble u1, GLdouble u2);
+void ( APIENTRY * qglMapGrid1f )(GLint un, GLfloat u1, GLfloat u2);
+void ( APIENTRY * qglMapGrid2d )(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2);
+void ( APIENTRY * qglMapGrid2f )(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2);
+void ( APIENTRY * qglMaterialf )(GLenum face, GLenum pname, GLfloat param);
+void ( APIENTRY * qglMaterialfv )(GLenum face, GLenum pname, const GLfloat *params);
+void ( APIENTRY * qglMateriali )(GLenum face, GLenum pname, GLint param);
+void ( APIENTRY * qglMaterialiv )(GLenum face, GLenum pname, const GLint *params);
+void ( APIENTRY * qglMatrixMode )(GLenum mode);
+void ( APIENTRY * qglMultMatrixd )(const GLdouble *m);
+void ( APIENTRY * qglMultMatrixf )(const GLfloat *m);
+void ( APIENTRY * qglNewList )(GLuint list, GLenum mode);
+void ( APIENTRY * qglNormal3b )(GLbyte nx, GLbyte ny, GLbyte nz);
+void ( APIENTRY * qglNormal3bv )(const GLbyte *v);
+void ( APIENTRY * qglNormal3d )(GLdouble nx, GLdouble ny, GLdouble nz);
+void ( APIENTRY * qglNormal3dv )(const GLdouble *v);
+void ( APIENTRY * qglNormal3f )(GLfloat nx, GLfloat ny, GLfloat nz);
+void ( APIENTRY * qglNormal3fv )(const GLfloat *v);
+void ( APIENTRY * qglNormal3i )(GLint nx, GLint ny, GLint nz);
+void ( APIENTRY * qglNormal3iv )(const GLint *v);
+void ( APIENTRY * qglNormal3s )(GLshort nx, GLshort ny, GLshort nz);
+void ( APIENTRY * qglNormal3sv )(const GLshort *v);
+void ( APIENTRY * qglNormalPointer )(GLenum type, GLsizei stride, const GLvoid *pointer);
+void ( APIENTRY * qglOrtho )(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
+void ( APIENTRY * qglPassThrough )(GLfloat token);
+void ( APIENTRY * qglPixelMapfv )(GLenum m, GLsizei mapsize, const GLfloat *values); //rwwRMG - map->m (avoid map type conflict)
+void ( APIENTRY * qglPixelMapuiv )(GLenum m, GLsizei mapsize, const GLuint *values); //rwwRMG - map->m (avoid map type conflict)
+void ( APIENTRY * qglPixelMapusv )(GLenum m, GLsizei mapsize, const GLushort *values); //rwwRMG - map->m (avoid map type conflict)
+void ( APIENTRY * qglPixelStoref )(GLenum pname, GLfloat param);
+void ( APIENTRY * qglPixelStorei )(GLenum pname, GLint param);
+void ( APIENTRY * qglPixelTransferf )(GLenum pname, GLfloat param);
+void ( APIENTRY * qglPixelTransferi )(GLenum pname, GLint param);
+void ( APIENTRY * qglPixelZoom )(GLfloat xfactor, GLfloat yfactor);
+void ( APIENTRY * qglPointSize )(GLfloat size);
+void ( APIENTRY * qglPolygonMode )(GLenum face, GLenum mode);
+void ( APIENTRY * qglPolygonOffset )(GLfloat factor, GLfloat units);
+void ( APIENTRY * qglPolygonStipple )(const GLubyte *mask);
+void ( APIENTRY * qglPopAttrib )(void);
+void ( APIENTRY * qglPopClientAttrib )(void);
+void ( APIENTRY * qglPopMatrix )(void);
+void ( APIENTRY * qglPopName )(void);
+void ( APIENTRY * qglPrioritizeTextures )(GLsizei n, const GLuint *textures, const GLclampf *priorities);
+void ( APIENTRY * qglPushAttrib )(GLbitfield mask);
+void ( APIENTRY * qglPushClientAttrib )(GLbitfield mask);
+void ( APIENTRY * qglPushMatrix )(void);
+void ( APIENTRY * qglPushName )(GLuint name);
+void ( APIENTRY * qglRasterPos2d )(GLdouble x, GLdouble y);
+void ( APIENTRY * qglRasterPos2dv )(const GLdouble *v);
+void ( APIENTRY * qglRasterPos2f )(GLfloat x, GLfloat y);
+void ( APIENTRY * qglRasterPos2fv )(const GLfloat *v);
+void ( APIENTRY * qglRasterPos2i )(GLint x, GLint y);
+void ( APIENTRY * qglRasterPos2iv )(const GLint *v);
+void ( APIENTRY * qglRasterPos2s )(GLshort x, GLshort y);
+void ( APIENTRY * qglRasterPos2sv )(const GLshort *v);
+void ( APIENTRY * qglRasterPos3d )(GLdouble x, GLdouble y, GLdouble z);
+void ( APIENTRY * qglRasterPos3dv )(const GLdouble *v);
+void ( APIENTRY * qglRasterPos3f )(GLfloat x, GLfloat y, GLfloat z);
+void ( APIENTRY * qglRasterPos3fv )(const GLfloat *v);
+void ( APIENTRY * qglRasterPos3i )(GLint x, GLint y, GLint z);
+void ( APIENTRY * qglRasterPos3iv )(const GLint *v);
+void ( APIENTRY * qglRasterPos3s )(GLshort x, GLshort y, GLshort z);
+void ( APIENTRY * qglRasterPos3sv )(const GLshort *v);
+void ( APIENTRY * qglRasterPos4d )(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+void ( APIENTRY * qglRasterPos4dv )(const GLdouble *v);
+void ( APIENTRY * qglRasterPos4f )(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+void ( APIENTRY * qglRasterPos4fv )(const GLfloat *v);
+void ( APIENTRY * qglRasterPos4i )(GLint x, GLint y, GLint z, GLint w);
+void ( APIENTRY * qglRasterPos4iv )(const GLint *v);
+void ( APIENTRY * qglRasterPos4s )(GLshort x, GLshort y, GLshort z, GLshort w);
+void ( APIENTRY * qglRasterPos4sv )(const GLshort *v);
+void ( APIENTRY * qglReadBuffer )(GLenum mode);
+void ( APIENTRY * qglReadPixels )(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels);
+void ( APIENTRY * qglRectd )(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2);
+void ( APIENTRY * qglRectdv )(const GLdouble *v1, const GLdouble *v2);
+void ( APIENTRY * qglRectf )(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2);
+void ( APIENTRY * qglRectfv )(const GLfloat *v1, const GLfloat *v2);
+void ( APIENTRY * qglRecti )(GLint x1, GLint y1, GLint x2, GLint y2);
+void ( APIENTRY * qglRectiv )(const GLint *v1, const GLint *v2);
+void ( APIENTRY * qglRects )(GLshort x1, GLshort y1, GLshort x2, GLshort y2);
+void ( APIENTRY * qglRectsv )(const GLshort *v1, const GLshort *v2);
+GLint ( APIENTRY * qglRenderMode )(GLenum mode);
+void ( APIENTRY * qglRotated )(GLdouble angle, GLdouble x, GLdouble y, GLdouble z);
+void ( APIENTRY * qglRotatef )(GLfloat angle, GLfloat x, GLfloat y, GLfloat z);
+void ( APIENTRY * qglScaled )(GLdouble x, GLdouble y, GLdouble z);
+void ( APIENTRY * qglScalef )(GLfloat x, GLfloat y, GLfloat z);
+void ( APIENTRY * qglScissor )(GLint x, GLint y, GLsizei width, GLsizei height);
+void ( APIENTRY * qglSelectBuffer )(GLsizei size, GLuint *buffer);
+void ( APIENTRY * qglShadeModel )(GLenum mode);
+void ( APIENTRY * qglStencilFunc )(GLenum func, GLint ref, GLuint mask);
+void ( APIENTRY * qglStencilMask )(GLuint mask);
+void ( APIENTRY * qglStencilOp )(GLenum fail, GLenum zfail, GLenum zpass);
+void ( APIENTRY * qglTexCoord1d )(GLdouble s);
+void ( APIENTRY * qglTexCoord1dv )(const GLdouble *v);
+void ( APIENTRY * qglTexCoord1f )(GLfloat s);
+void ( APIENTRY * qglTexCoord1fv )(const GLfloat *v);
+void ( APIENTRY * qglTexCoord1i )(GLint s);
+void ( APIENTRY * qglTexCoord1iv )(const GLint *v);
+void ( APIENTRY * qglTexCoord1s )(GLshort s);
+void ( APIENTRY * qglTexCoord1sv )(const GLshort *v);
+void ( APIENTRY * qglTexCoord2d )(GLdouble s, GLdouble t);
+void ( APIENTRY * qglTexCoord2dv )(const GLdouble *v);
+void ( APIENTRY * qglTexCoord2f )(GLfloat s, GLfloat t);
+void ( APIENTRY * qglTexCoord2fv )(const GLfloat *v);
+void ( APIENTRY * qglTexCoord2i )(GLint s, GLint t);
+void ( APIENTRY * qglTexCoord2iv )(const GLint *v);
+void ( APIENTRY * qglTexCoord2s )(GLshort s, GLshort t);
+void ( APIENTRY * qglTexCoord2sv )(const GLshort *v);
+void ( APIENTRY * qglTexCoord3d )(GLdouble s, GLdouble t, GLdouble r);
+void ( APIENTRY * qglTexCoord3dv )(const GLdouble *v);
+void ( APIENTRY * qglTexCoord3f )(GLfloat s, GLfloat t, GLfloat r);
+void ( APIENTRY * qglTexCoord3fv )(const GLfloat *v);
+void ( APIENTRY * qglTexCoord3i )(GLint s, GLint t, GLint r);
+void ( APIENTRY * qglTexCoord3iv )(const GLint *v);
+void ( APIENTRY * qglTexCoord3s )(GLshort s, GLshort t, GLshort r);
+void ( APIENTRY * qglTexCoord3sv )(const GLshort *v);
+void ( APIENTRY * qglTexCoord4d )(GLdouble s, GLdouble t, GLdouble r, GLdouble q);
+void ( APIENTRY * qglTexCoord4dv )(const GLdouble *v);
+void ( APIENTRY * qglTexCoord4f )(GLfloat s, GLfloat t, GLfloat r, GLfloat q);
+void ( APIENTRY * qglTexCoord4fv )(const GLfloat *v);
+void ( APIENTRY * qglTexCoord4i )(GLint s, GLint t, GLint r, GLint q);
+void ( APIENTRY * qglTexCoord4iv )(const GLint *v);
+void ( APIENTRY * qglTexCoord4s )(GLshort s, GLshort t, GLshort r, GLshort q);
+void ( APIENTRY * qglTexCoord4sv )(const GLshort *v);
+void ( APIENTRY * qglTexCoordPointer )(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
+void ( APIENTRY * qglTexEnvf )(GLenum target, GLenum pname, GLfloat param);
+void ( APIENTRY * qglTexEnvfv )(GLenum target, GLenum pname, const GLfloat *params);
+void ( APIENTRY * qglTexEnvi )(GLenum target, GLenum pname, GLint param);
+void ( APIENTRY * qglTexEnviv )(GLenum target, GLenum pname, const GLint *params);
+void ( APIENTRY * qglTexGend )(GLenum coord, GLenum pname, GLdouble param);
+void ( APIENTRY * qglTexGendv )(GLenum coord, GLenum pname, const GLdouble *params);
+void ( APIENTRY * qglTexGenf )(GLenum coord, GLenum pname, GLfloat param);
+void ( APIENTRY * qglTexGenfv )(GLenum coord, GLenum pname, const GLfloat *params);
+void ( APIENTRY * qglTexGeni )(GLenum coord, GLenum pname, GLint param);
+void ( APIENTRY * qglTexGeniv )(GLenum coord, GLenum pname, const GLint *params);
+void ( APIENTRY * qglTexImage1D )(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
+void ( APIENTRY * qglTexImage2D )(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
+void ( APIENTRY * qglTexParameterf )(GLenum target, GLenum pname, GLfloat param);
+void ( APIENTRY * qglTexParameterfv )(GLenum target, GLenum pname, const GLfloat *params);
+void ( APIENTRY * qglTexParameteri )(GLenum target, GLenum pname, GLint param);
+void ( APIENTRY * qglTexParameteriv )(GLenum target, GLenum pname, const GLint *params);
+void ( APIENTRY * qglTexSubImage1D )(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels);
+void ( APIENTRY * qglTexSubImage2D )(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
+void ( APIENTRY * qglTranslated )(GLdouble x, GLdouble y, GLdouble z);
+void ( APIENTRY * qglTranslatef )(GLfloat x, GLfloat y, GLfloat z);
+void ( APIENTRY * qglVertex2d )(GLdouble x, GLdouble y);
+void ( APIENTRY * qglVertex2dv )(const GLdouble *v);
+void ( APIENTRY * qglVertex2f )(GLfloat x, GLfloat y);
+void ( APIENTRY * qglVertex2fv )(const GLfloat *v);
+void ( APIENTRY * qglVertex2i )(GLint x, GLint y);
+void ( APIENTRY * qglVertex2iv )(const GLint *v);
+void ( APIENTRY * qglVertex2s )(GLshort x, GLshort y);
+void ( APIENTRY * qglVertex2sv )(const GLshort *v);
+void ( APIENTRY * qglVertex3d )(GLdouble x, GLdouble y, GLdouble z);
+void ( APIENTRY * qglVertex3dv )(const GLdouble *v);
+void ( APIENTRY * qglVertex3f )(GLfloat x, GLfloat y, GLfloat z);
+void ( APIENTRY * qglVertex3fv )(const GLfloat *v);
+void ( APIENTRY * qglVertex3i )(GLint x, GLint y, GLint z);
+void ( APIENTRY * qglVertex3iv )(const GLint *v);
+void ( APIENTRY * qglVertex3s )(GLshort x, GLshort y, GLshort z);
+void ( APIENTRY * qglVertex3sv )(const GLshort *v);
+void ( APIENTRY * qglVertex4d )(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+void ( APIENTRY * qglVertex4dv )(const GLdouble *v);
+void ( APIENTRY * qglVertex4f )(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+void ( APIENTRY * qglVertex4fv )(const GLfloat *v);
+void ( APIENTRY * qglVertex4i )(GLint x, GLint y, GLint z, GLint w);
+void ( APIENTRY * qglVertex4iv )(const GLint *v);
+void ( APIENTRY * qglVertex4s )(GLshort x, GLshort y, GLshort z, GLshort w);
+void ( APIENTRY * qglVertex4sv )(const GLshort *v);
+void ( APIENTRY * qglVertexPointer )(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
+void ( APIENTRY * qglViewport )(GLint x, GLint y, GLsizei width, GLsizei height);
+
+
+
+static void ( APIENTRY * dllAccum )(GLenum op, GLfloat value);
+static void ( APIENTRY * dllAlphaFunc )(GLenum func, GLclampf ref);
+GLboolean ( APIENTRY * dllAreTexturesResident )(GLsizei n, const GLuint *textures, GLboolean *residences);
+static void ( APIENTRY * dllArrayElement )(GLint i);
+static void ( APIENTRY * dllBegin )(GLenum mode);
+static void ( APIENTRY * dllBindTexture )(GLenum target, GLuint texture);
+static void ( APIENTRY * dllBitmap )(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap);
+static void ( APIENTRY * dllBlendFunc )(GLenum sfactor, GLenum dfactor);
+static void ( APIENTRY * dllCallList )(GLuint list);
+static void ( APIENTRY * dllCallLists )(GLsizei n, GLenum type, const GLvoid *lists);
+static void ( APIENTRY * dllClear )(GLbitfield mask);
+static void ( APIENTRY * dllClearAccum )(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
+static void ( APIENTRY * dllClearColor )(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
+static void ( APIENTRY * dllClearDepth )(GLclampd depth);
+static void ( APIENTRY * dllClearIndex )(GLfloat c);
+static void ( APIENTRY * dllClearStencil )(GLint s);
+static void ( APIENTRY * dllClipPlane )(GLenum plane, const GLdouble *equation);
+static void ( APIENTRY * dllColor3b )(GLbyte red, GLbyte green, GLbyte blue);
+static void ( APIENTRY * dllColor3bv )(const GLbyte *v);
+static void ( APIENTRY * dllColor3d )(GLdouble red, GLdouble green, GLdouble blue);
+static void ( APIENTRY * dllColor3dv )(const GLdouble *v);
+static void ( APIENTRY * dllColor3f )(GLfloat red, GLfloat green, GLfloat blue);
+static void ( APIENTRY * dllColor3fv )(const GLfloat *v);
+static void ( APIENTRY * dllColor3i )(GLint red, GLint green, GLint blue);
+static void ( APIENTRY * dllColor3iv )(const GLint *v);
+static void ( APIENTRY * dllColor3s )(GLshort red, GLshort green, GLshort blue);
+static void ( APIENTRY * dllColor3sv )(const GLshort *v);
+static void ( APIENTRY * dllColor3ub )(GLubyte red, GLubyte green, GLubyte blue);
+static void ( APIENTRY * dllColor3ubv )(const GLubyte *v);
+static void ( APIENTRY * dllColor3ui )(GLuint red, GLuint green, GLuint blue);
+static void ( APIENTRY * dllColor3uiv )(const GLuint *v);
+static void ( APIENTRY * dllColor3us )(GLushort red, GLushort green, GLushort blue);
+static void ( APIENTRY * dllColor3usv )(const GLushort *v);
+static void ( APIENTRY * dllColor4b )(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha);
+static void ( APIENTRY * dllColor4bv )(const GLbyte *v);
+static void ( APIENTRY * dllColor4d )(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha);
+static void ( APIENTRY * dllColor4dv )(const GLdouble *v);
+static void ( APIENTRY * dllColor4f )(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
+static void ( APIENTRY * dllColor4fv )(const GLfloat *v);
+static void ( APIENTRY * dllColor4i )(GLint red, GLint green, GLint blue, GLint alpha);
+static void ( APIENTRY * dllColor4iv )(const GLint *v);
+static void ( APIENTRY * dllColor4s )(GLshort red, GLshort green, GLshort blue, GLshort alpha);
+static void ( APIENTRY * dllColor4sv )(const GLshort *v);
+static void ( APIENTRY * dllColor4ub )(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha);
+static void ( APIENTRY * dllColor4ubv )(const GLubyte *v);
+static void ( APIENTRY * dllColor4ui )(GLuint red, GLuint green, GLuint blue, GLuint alpha);
+static void ( APIENTRY * dllColor4uiv )(const GLuint *v);
+static void ( APIENTRY * dllColor4us )(GLushort red, GLushort green, GLushort blue, GLushort alpha);
+static void ( APIENTRY * dllColor4usv )(const GLushort *v);
+static void ( APIENTRY * dllColorMask )(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
+static void ( APIENTRY * dllColorMaterial )(GLenum face, GLenum mode);
+static void ( APIENTRY * dllColorPointer )(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
+static void ( APIENTRY * dllCopyPixels )(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type);
+static void ( APIENTRY * dllCopyTexImage1D )(GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border);
+static void ( APIENTRY * dllCopyTexImage2D )(GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
+static void ( APIENTRY * dllCopyTexSubImage1D )(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);
+static void ( APIENTRY * dllCopyTexSubImage2D )(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
+static void ( APIENTRY * dllCullFace )(GLenum mode);
+static void ( APIENTRY * dllDeleteLists )(GLuint list, GLsizei range);
+static void ( APIENTRY * dllDeleteTextures )(GLsizei n, const GLuint *textures);
+static void ( APIENTRY * dllDepthFunc )(GLenum func);
+static void ( APIENTRY * dllDepthMask )(GLboolean flag);
+static void ( APIENTRY * dllDepthRange )(GLclampd zNear, GLclampd zFar);
+static void ( APIENTRY * dllDisable )(GLenum cap);
+static void ( APIENTRY * dllDisableClientState )(GLenum array);
+static void ( APIENTRY * dllDrawArrays )(GLenum mode, GLint first, GLsizei count);
+static void ( APIENTRY * dllDrawBuffer )(GLenum mode);
+static void ( APIENTRY * dllDrawElements )(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices);
+static void ( APIENTRY * dllDrawPixels )(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
+static void ( APIENTRY * dllEdgeFlag )(GLboolean flag);
+static void ( APIENTRY * dllEdgeFlagPointer )(GLsizei stride, const GLvoid *pointer);
+static void ( APIENTRY * dllEdgeFlagv )(const GLboolean *flag);
+static void ( APIENTRY * dllEnable )(GLenum cap);
+static void ( APIENTRY * dllEnableClientState )(GLenum array);
+static void ( APIENTRY * dllEnd )(void);
+static void ( APIENTRY * dllEndList )(void);
+static void ( APIENTRY * dllEvalCoord1d )(GLdouble u);
+static void ( APIENTRY * dllEvalCoord1dv )(const GLdouble *u);
+static void ( APIENTRY * dllEvalCoord1f )(GLfloat u);
+static void ( APIENTRY * dllEvalCoord1fv )(const GLfloat *u);
+static void ( APIENTRY * dllEvalCoord2d )(GLdouble u, GLdouble v);
+static void ( APIENTRY * dllEvalCoord2dv )(const GLdouble *u);
+static void ( APIENTRY * dllEvalCoord2f )(GLfloat u, GLfloat v);
+static void ( APIENTRY * dllEvalCoord2fv )(const GLfloat *u);
+static void ( APIENTRY * dllEvalMesh1 )(GLenum mode, GLint i1, GLint i2);
+static void ( APIENTRY * dllEvalMesh2 )(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2);
+static void ( APIENTRY * dllEvalPoint1 )(GLint i);
+static void ( APIENTRY * dllEvalPoint2 )(GLint i, GLint j);
+static void ( APIENTRY * dllFeedbackBuffer )(GLsizei size, GLenum type, GLfloat *buffer);
+static void ( APIENTRY * dllFinish )(void);
+static void ( APIENTRY * dllFlush )(void);
+static void ( APIENTRY * dllFogf )(GLenum pname, GLfloat param);
+static void ( APIENTRY * dllFogfv )(GLenum pname, const GLfloat *params);
+static void ( APIENTRY * dllFogi )(GLenum pname, GLint param);
+static void ( APIENTRY * dllFogiv )(GLenum pname, const GLint *params);
+static void ( APIENTRY * dllFrontFace )(GLenum mode);
+static void ( APIENTRY * dllFrustum )(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
+GLuint ( APIENTRY * dllGenLists )(GLsizei range);
+static void ( APIENTRY * dllGenTextures )(GLsizei n, GLuint *textures);
+static void ( APIENTRY * dllGetBooleanv )(GLenum pname, GLboolean *params);
+static void ( APIENTRY * dllGetClipPlane )(GLenum plane, GLdouble *equation);
+static void ( APIENTRY * dllGetDoublev )(GLenum pname, GLdouble *params);
+GLenum ( APIENTRY * dllGetError )(void);
+static void ( APIENTRY * dllGetFloatv )(GLenum pname, GLfloat *params);
+static void ( APIENTRY * dllGetIntegerv )(GLenum pname, GLint *params);
+static void ( APIENTRY * dllGetLightfv )(GLenum light, GLenum pname, GLfloat *params);
+static void ( APIENTRY * dllGetLightiv )(GLenum light, GLenum pname, GLint *params);
+static void ( APIENTRY * dllGetMapdv )(GLenum target, GLenum query, GLdouble *v);
+static void ( APIENTRY * dllGetMapfv )(GLenum target, GLenum query, GLfloat *v);
+static void ( APIENTRY * dllGetMapiv )(GLenum target, GLenum query, GLint *v);
+static void ( APIENTRY * dllGetMaterialfv )(GLenum face, GLenum pname, GLfloat *params);
+static void ( APIENTRY * dllGetMaterialiv )(GLenum face, GLenum pname, GLint *params);
+static void ( APIENTRY * dllGetPixelMapfv )(GLenum map, GLfloat *values);
+static void ( APIENTRY * dllGetPixelMapuiv )(GLenum map, GLuint *values);
+static void ( APIENTRY * dllGetPixelMapusv )(GLenum map, GLushort *values);
+static void ( APIENTRY * dllGetPointerv )(GLenum pname, GLvoid* *params);
+static void ( APIENTRY * dllGetPolygonStipple )(GLubyte *mask);
+const GLubyte * ( APIENTRY * dllGetString )(GLenum name);
+static void ( APIENTRY * dllGetTexEnvfv )(GLenum target, GLenum pname, GLfloat *params);
+static void ( APIENTRY * dllGetTexEnviv )(GLenum target, GLenum pname, GLint *params);
+static void ( APIENTRY * dllGetTexGendv )(GLenum coord, GLenum pname, GLdouble *params);
+static void ( APIENTRY * dllGetTexGenfv )(GLenum coord, GLenum pname, GLfloat *params);
+static void ( APIENTRY * dllGetTexGeniv )(GLenum coord, GLenum pname, GLint *params);
+static void ( APIENTRY * dllGetTexImage )(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels);
+static void ( APIENTRY * dllGetTexLevelParameterfv )(GLenum target, GLint level, GLenum pname, GLfloat *params);
+static void ( APIENTRY * dllGetTexLevelParameteriv )(GLenum target, GLint level, GLenum pname, GLint *params);
+static void ( APIENTRY * dllGetTexParameterfv )(GLenum target, GLenum pname, GLfloat *params);
+static void ( APIENTRY * dllGetTexParameteriv )(GLenum target, GLenum pname, GLint *params);
+static void ( APIENTRY * dllHint )(GLenum target, GLenum mode);
+static void ( APIENTRY * dllIndexMask )(GLuint mask);
+static void ( APIENTRY * dllIndexPointer )(GLenum type, GLsizei stride, const GLvoid *pointer);
+static void ( APIENTRY * dllIndexd )(GLdouble c);
+static void ( APIENTRY * dllIndexdv )(const GLdouble *c);
+static void ( APIENTRY * dllIndexf )(GLfloat c);
+static void ( APIENTRY * dllIndexfv )(const GLfloat *c);
+static void ( APIENTRY * dllIndexi )(GLint c);
+static void ( APIENTRY * dllIndexiv )(const GLint *c);
+static void ( APIENTRY * dllIndexs )(GLshort c);
+static void ( APIENTRY * dllIndexsv )(const GLshort *c);
+static void ( APIENTRY * dllIndexub )(GLubyte c);
+static void ( APIENTRY * dllIndexubv )(const GLubyte *c);
+static void ( APIENTRY * dllInitNames )(void);
+static void ( APIENTRY * dllInterleavedArrays )(GLenum format, GLsizei stride, const GLvoid *pointer);
+GLboolean ( APIENTRY * dllIsEnabled )(GLenum cap);
+GLboolean ( APIENTRY * dllIsList )(GLuint list);
+GLboolean ( APIENTRY * dllIsTexture )(GLuint texture);
+static void ( APIENTRY * dllLightModelf )(GLenum pname, GLfloat param);
+static void ( APIENTRY * dllLightModelfv )(GLenum pname, const GLfloat *params);
+static void ( APIENTRY * dllLightModeli )(GLenum pname, GLint param);
+static void ( APIENTRY * dllLightModeliv )(GLenum pname, const GLint *params);
+static void ( APIENTRY * dllLightf )(GLenum light, GLenum pname, GLfloat param);
+static void ( APIENTRY * dllLightfv )(GLenum light, GLenum pname, const GLfloat *params);
+static void ( APIENTRY * dllLighti )(GLenum light, GLenum pname, GLint param);
+static void ( APIENTRY * dllLightiv )(GLenum light, GLenum pname, const GLint *params);
+static void ( APIENTRY * dllLineStipple )(GLint factor, GLushort pattern);
+static void ( APIENTRY * dllLineWidth )(GLfloat width);
+static void ( APIENTRY * dllListBase )(GLuint base);
+static void ( APIENTRY * dllLoadIdentity )(void);
+static void ( APIENTRY * dllLoadMatrixd )(const GLdouble *m);
+static void ( APIENTRY * dllLoadMatrixf )(const GLfloat *m);
+static void ( APIENTRY * dllLoadName )(GLuint name);
+static void ( APIENTRY * dllLogicOp )(GLenum opcode);
+static void ( APIENTRY * dllMap1d )(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points);
+static void ( APIENTRY * dllMap1f )(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points);
+static void ( APIENTRY * dllMap2d )(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points);
+static void ( APIENTRY * dllMap2f )(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points);
+static void ( APIENTRY * dllMapGrid1d )(GLint un, GLdouble u1, GLdouble u2);
+static void ( APIENTRY * dllMapGrid1f )(GLint un, GLfloat u1, GLfloat u2);
+static void ( APIENTRY * dllMapGrid2d )(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2);
+static void ( APIENTRY * dllMapGrid2f )(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2);
+static void ( APIENTRY * dllMaterialf )(GLenum face, GLenum pname, GLfloat param);
+static void ( APIENTRY * dllMaterialfv )(GLenum face, GLenum pname, const GLfloat *params);
+static void ( APIENTRY * dllMateriali )(GLenum face, GLenum pname, GLint param);
+static void ( APIENTRY * dllMaterialiv )(GLenum face, GLenum pname, const GLint *params);
+static void ( APIENTRY * dllMatrixMode )(GLenum mode);
+static void ( APIENTRY * dllMultMatrixd )(const GLdouble *m);
+static void ( APIENTRY * dllMultMatrixf )(const GLfloat *m);
+static void ( APIENTRY * dllNewList )(GLuint list, GLenum mode);
+static void ( APIENTRY * dllNormal3b )(GLbyte nx, GLbyte ny, GLbyte nz);
+static void ( APIENTRY * dllNormal3bv )(const GLbyte *v);
+static void ( APIENTRY * dllNormal3d )(GLdouble nx, GLdouble ny, GLdouble nz);
+static void ( APIENTRY * dllNormal3dv )(const GLdouble *v);
+static void ( APIENTRY * dllNormal3f )(GLfloat nx, GLfloat ny, GLfloat nz);
+static void ( APIENTRY * dllNormal3fv )(const GLfloat *v);
+static void ( APIENTRY * dllNormal3i )(GLint nx, GLint ny, GLint nz);
+static void ( APIENTRY * dllNormal3iv )(const GLint *v);
+static void ( APIENTRY * dllNormal3s )(GLshort nx, GLshort ny, GLshort nz);
+static void ( APIENTRY * dllNormal3sv )(const GLshort *v);
+static void ( APIENTRY * dllNormalPointer )(GLenum type, GLsizei stride, const GLvoid *pointer);
+static void ( APIENTRY * dllOrtho )(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
+static void ( APIENTRY * dllPassThrough )(GLfloat token);
+static void ( APIENTRY * dllPixelMapfv )(GLenum map, GLsizei mapsize, const GLfloat *values);
+static void ( APIENTRY * dllPixelMapuiv )(GLenum map, GLsizei mapsize, const GLuint *values);
+static void ( APIENTRY * dllPixelMapusv )(GLenum map, GLsizei mapsize, const GLushort *values);
+static void ( APIENTRY * dllPixelStoref )(GLenum pname, GLfloat param);
+static void ( APIENTRY * dllPixelStorei )(GLenum pname, GLint param);
+static void ( APIENTRY * dllPixelTransferf )(GLenum pname, GLfloat param);
+static void ( APIENTRY * dllPixelTransferi )(GLenum pname, GLint param);
+static void ( APIENTRY * dllPixelZoom )(GLfloat xfactor, GLfloat yfactor);
+static void ( APIENTRY * dllPointSize )(GLfloat size);
+static void ( APIENTRY * dllPolygonMode )(GLenum face, GLenum mode);
+static void ( APIENTRY * dllPolygonOffset )(GLfloat factor, GLfloat units);
+static void ( APIENTRY * dllPolygonStipple )(const GLubyte *mask);
+static void ( APIENTRY * dllPopAttrib )(void);
+static void ( APIENTRY * dllPopClientAttrib )(void);
+static void ( APIENTRY * dllPopMatrix )(void);
+static void ( APIENTRY * dllPopName )(void);
+static void ( APIENTRY * dllPrioritizeTextures )(GLsizei n, const GLuint *textures, const GLclampf *priorities);
+static void ( APIENTRY * dllPushAttrib )(GLbitfield mask);
+static void ( APIENTRY * dllPushClientAttrib )(GLbitfield mask);
+static void ( APIENTRY * dllPushMatrix )(void);
+static void ( APIENTRY * dllPushName )(GLuint name);
+static void ( APIENTRY * dllRasterPos2d )(GLdouble x, GLdouble y);
+static void ( APIENTRY * dllRasterPos2dv )(const GLdouble *v);
+static void ( APIENTRY * dllRasterPos2f )(GLfloat x, GLfloat y);
+static void ( APIENTRY * dllRasterPos2fv )(const GLfloat *v);
+static void ( APIENTRY * dllRasterPos2i )(GLint x, GLint y);
+static void ( APIENTRY * dllRasterPos2iv )(const GLint *v);
+static void ( APIENTRY * dllRasterPos2s )(GLshort x, GLshort y);
+static void ( APIENTRY * dllRasterPos2sv )(const GLshort *v);
+static void ( APIENTRY * dllRasterPos3d )(GLdouble x, GLdouble y, GLdouble z);
+static void ( APIENTRY * dllRasterPos3dv )(const GLdouble *v);
+static void ( APIENTRY * dllRasterPos3f )(GLfloat x, GLfloat y, GLfloat z);
+static void ( APIENTRY * dllRasterPos3fv )(const GLfloat *v);
+static void ( APIENTRY * dllRasterPos3i )(GLint x, GLint y, GLint z);
+static void ( APIENTRY * dllRasterPos3iv )(const GLint *v);
+static void ( APIENTRY * dllRasterPos3s )(GLshort x, GLshort y, GLshort z);
+static void ( APIENTRY * dllRasterPos3sv )(const GLshort *v);
+static void ( APIENTRY * dllRasterPos4d )(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+static void ( APIENTRY * dllRasterPos4dv )(const GLdouble *v);
+static void ( APIENTRY * dllRasterPos4f )(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+static void ( APIENTRY * dllRasterPos4fv )(const GLfloat *v);
+static void ( APIENTRY * dllRasterPos4i )(GLint x, GLint y, GLint z, GLint w);
+static void ( APIENTRY * dllRasterPos4iv )(const GLint *v);
+static void ( APIENTRY * dllRasterPos4s )(GLshort x, GLshort y, GLshort z, GLshort w);
+static void ( APIENTRY * dllRasterPos4sv )(const GLshort *v);
+static void ( APIENTRY * dllReadBuffer )(GLenum mode);
+static void ( APIENTRY * dllReadPixels )(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels);
+static void ( APIENTRY * dllRectd )(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2);
+static void ( APIENTRY * dllRectdv )(const GLdouble *v1, const GLdouble *v2);
+static void ( APIENTRY * dllRectf )(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2);
+static void ( APIENTRY * dllRectfv )(const GLfloat *v1, const GLfloat *v2);
+static void ( APIENTRY * dllRecti )(GLint x1, GLint y1, GLint x2, GLint y2);
+static void ( APIENTRY * dllRectiv )(const GLint *v1, const GLint *v2);
+static void ( APIENTRY * dllRects )(GLshort x1, GLshort y1, GLshort x2, GLshort y2);
+static void ( APIENTRY * dllRectsv )(const GLshort *v1, const GLshort *v2);
+GLint ( APIENTRY * dllRenderMode )(GLenum mode);
+static void ( APIENTRY * dllRotated )(GLdouble angle, GLdouble x, GLdouble y, GLdouble z);
+static void ( APIENTRY * dllRotatef )(GLfloat angle, GLfloat x, GLfloat y, GLfloat z);
+static void ( APIENTRY * dllScaled )(GLdouble x, GLdouble y, GLdouble z);
+static void ( APIENTRY * dllScalef )(GLfloat x, GLfloat y, GLfloat z);
+static void ( APIENTRY * dllScissor )(GLint x, GLint y, GLsizei width, GLsizei height);
+static void ( APIENTRY * dllSelectBuffer )(GLsizei size, GLuint *buffer);
+static void ( APIENTRY * dllShadeModel )(GLenum mode);
+static void ( APIENTRY * dllStencilFunc )(GLenum func, GLint ref, GLuint mask);
+static void ( APIENTRY * dllStencilMask )(GLuint mask);
+static void ( APIENTRY * dllStencilOp )(GLenum fail, GLenum zfail, GLenum zpass);
+static void ( APIENTRY * dllTexCoord1d )(GLdouble s);
+static void ( APIENTRY * dllTexCoord1dv )(const GLdouble *v);
+static void ( APIENTRY * dllTexCoord1f )(GLfloat s);
+static void ( APIENTRY * dllTexCoord1fv )(const GLfloat *v);
+static void ( APIENTRY * dllTexCoord1i )(GLint s);
+static void ( APIENTRY * dllTexCoord1iv )(const GLint *v);
+static void ( APIENTRY * dllTexCoord1s )(GLshort s);
+static void ( APIENTRY * dllTexCoord1sv )(const GLshort *v);
+static void ( APIENTRY * dllTexCoord2d )(GLdouble s, GLdouble t);
+static void ( APIENTRY * dllTexCoord2dv )(const GLdouble *v);
+static void ( APIENTRY * dllTexCoord2f )(GLfloat s, GLfloat t);
+static void ( APIENTRY * dllTexCoord2fv )(const GLfloat *v);
+static void ( APIENTRY * dllTexCoord2i )(GLint s, GLint t);
+static void ( APIENTRY * dllTexCoord2iv )(const GLint *v);
+static void ( APIENTRY * dllTexCoord2s )(GLshort s, GLshort t);
+static void ( APIENTRY * dllTexCoord2sv )(const GLshort *v);
+static void ( APIENTRY * dllTexCoord3d )(GLdouble s, GLdouble t, GLdouble r);
+static void ( APIENTRY * dllTexCoord3dv )(const GLdouble *v);
+static void ( APIENTRY * dllTexCoord3f )(GLfloat s, GLfloat t, GLfloat r);
+static void ( APIENTRY * dllTexCoord3fv )(const GLfloat *v);
+static void ( APIENTRY * dllTexCoord3i )(GLint s, GLint t, GLint r);
+static void ( APIENTRY * dllTexCoord3iv )(const GLint *v);
+static void ( APIENTRY * dllTexCoord3s )(GLshort s, GLshort t, GLshort r);
+static void ( APIENTRY * dllTexCoord3sv )(const GLshort *v);
+static void ( APIENTRY * dllTexCoord4d )(GLdouble s, GLdouble t, GLdouble r, GLdouble q);
+static void ( APIENTRY * dllTexCoord4dv )(const GLdouble *v);
+static void ( APIENTRY * dllTexCoord4f )(GLfloat s, GLfloat t, GLfloat r, GLfloat q);
+static void ( APIENTRY * dllTexCoord4fv )(const GLfloat *v);
+static void ( APIENTRY * dllTexCoord4i )(GLint s, GLint t, GLint r, GLint q);
+static void ( APIENTRY * dllTexCoord4iv )(const GLint *v);
+static void ( APIENTRY * dllTexCoord4s )(GLshort s, GLshort t, GLshort r, GLshort q);
+static void ( APIENTRY * dllTexCoord4sv )(const GLshort *v);
+static void ( APIENTRY * dllTexCoordPointer )(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
+static void ( APIENTRY * dllTexEnvf )(GLenum target, GLenum pname, GLfloat param);
+static void ( APIENTRY * dllTexEnvfv )(GLenum target, GLenum pname, const GLfloat *params);
+static void ( APIENTRY * dllTexEnvi )(GLenum target, GLenum pname, GLint param);
+static void ( APIENTRY * dllTexEnviv )(GLenum target, GLenum pname, const GLint *params);
+static void ( APIENTRY * dllTexGend )(GLenum coord, GLenum pname, GLdouble param);
+static void ( APIENTRY * dllTexGendv )(GLenum coord, GLenum pname, const GLdouble *params);
+static void ( APIENTRY * dllTexGenf )(GLenum coord, GLenum pname, GLfloat param);
+static void ( APIENTRY * dllTexGenfv )(GLenum coord, GLenum pname, const GLfloat *params);
+static void ( APIENTRY * dllTexGeni )(GLenum coord, GLenum pname, GLint param);
+static void ( APIENTRY * dllTexGeniv )(GLenum coord, GLenum pname, const GLint *params);
+static void ( APIENTRY * dllTexImage1D )(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
+static void ( APIENTRY * dllTexImage2D )(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
+static void ( APIENTRY * dllTexParameterf )(GLenum target, GLenum pname, GLfloat param);
+static void ( APIENTRY * dllTexParameterfv )(GLenum target, GLenum pname, const GLfloat *params);
+static void ( APIENTRY * dllTexParameteri )(GLenum target, GLenum pname, GLint param);
+static void ( APIENTRY * dllTexParameteriv )(GLenum target, GLenum pname, const GLint *params);
+static void ( APIENTRY * dllTexSubImage1D )(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels);
+static void ( APIENTRY * dllTexSubImage2D )(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
+static void ( APIENTRY * dllTranslated )(GLdouble x, GLdouble y, GLdouble z);
+static void ( APIENTRY * dllTranslatef )(GLfloat x, GLfloat y, GLfloat z);
+static void ( APIENTRY * dllVertex2d )(GLdouble x, GLdouble y);
+static void ( APIENTRY * dllVertex2dv )(const GLdouble *v);
+static void ( APIENTRY * dllVertex2f )(GLfloat x, GLfloat y);
+static void ( APIENTRY * dllVertex2fv )(const GLfloat *v);
+static void ( APIENTRY * dllVertex2i )(GLint x, GLint y);
+static void ( APIENTRY * dllVertex2iv )(const GLint *v);
+static void ( APIENTRY * dllVertex2s )(GLshort x, GLshort y);
+static void ( APIENTRY * dllVertex2sv )(const GLshort *v);
+static void ( APIENTRY * dllVertex3d )(GLdouble x, GLdouble y, GLdouble z);
+static void ( APIENTRY * dllVertex3dv )(const GLdouble *v);
+static void ( APIENTRY * dllVertex3f )(GLfloat x, GLfloat y, GLfloat z);
+static void ( APIENTRY * dllVertex3fv )(const GLfloat *v);
+static void ( APIENTRY * dllVertex3i )(GLint x, GLint y, GLint z);
+static void ( APIENTRY * dllVertex3iv )(const GLint *v);
+static void ( APIENTRY * dllVertex3s )(GLshort x, GLshort y, GLshort z);
+static void ( APIENTRY * dllVertex3sv )(const GLshort *v);
+static void ( APIENTRY * dllVertex4d )(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+static void ( APIENTRY * dllVertex4dv )(const GLdouble *v);
+static void ( APIENTRY * dllVertex4f )(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+static void ( APIENTRY * dllVertex4fv )(const GLfloat *v);
+static void ( APIENTRY * dllVertex4i )(GLint x, GLint y, GLint z, GLint w);
+static void ( APIENTRY * dllVertex4iv )(const GLint *v);
+static void ( APIENTRY * dllVertex4s )(GLshort x, GLshort y, GLshort z, GLshort w);
+static void ( APIENTRY * dllVertex4sv )(const GLshort *v);
+static void ( APIENTRY * dllVertexPointer )(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
+static void ( APIENTRY * dllViewport )(GLint x, GLint y, GLsizei width, GLsizei height);
+
+static const char * BooleanToString( GLboolean b )
+{
+	if ( b == GL_FALSE )
+		return "GL_FALSE";
+	else if ( b == GL_TRUE )
+		return "GL_TRUE";
+	else
+		return "OUT OF RANGE FOR BOOLEAN";
+}
+
+static const char * FuncToString( GLenum f )
+{
+	switch ( f )
+	{
+	case GL_ALWAYS:
+		return "GL_ALWAYS";
+	case GL_NEVER:
+		return "GL_NEVER";
+	case GL_LEQUAL:
+		return "GL_LEQUAL";
+	case GL_LESS:
+		return "GL_LESS";
+	case GL_EQUAL:
+		return "GL_EQUAL";
+	case GL_GREATER:
+		return "GL_GREATER";
+	case GL_GEQUAL:
+		return "GL_GEQUAL";
+	case GL_NOTEQUAL:
+		return "GL_NOTEQUAL";
+	default:
+		return "!!! UNKNOWN !!!";
+	}
+}
+
+static const char * PrimToString( GLenum mode )
+{
+	static char prim[1024];
+
+	if ( mode == GL_TRIANGLES )
+		strcpy( prim, "GL_TRIANGLES" );
+	else if ( mode == GL_TRIANGLE_STRIP )
+		strcpy( prim, "GL_TRIANGLE_STRIP" );
+	else if ( mode == GL_TRIANGLE_FAN )
+		strcpy( prim, "GL_TRIANGLE_FAN" );
+	else if ( mode == GL_QUADS )
+		strcpy( prim, "GL_QUADS" );
+	else if ( mode == GL_QUAD_STRIP )
+		strcpy( prim, "GL_QUAD_STRIP" );
+	else if ( mode == GL_POLYGON )
+		strcpy( prim, "GL_POLYGON" );
+	else if ( mode == GL_POINTS )
+		strcpy( prim, "GL_POINTS" );
+	else if ( mode == GL_LINES )
+		strcpy( prim, "GL_LINES" );
+	else if ( mode == GL_LINE_STRIP )
+		strcpy( prim, "GL_LINE_STRIP" );
+	else if ( mode == GL_LINE_LOOP )
+		strcpy( prim, "GL_LINE_LOOP" );
+	else
+		sprintf( prim, "0x%x", mode );
+
+	return prim;
+}
+
+static const char * CapToString( GLenum cap )
+{
+	static char buffer[1024];
+
+	switch ( cap )
+	{
+	case GL_TEXTURE_2D:
+		return "GL_TEXTURE_2D";
+	case GL_BLEND:
+		return "GL_BLEND";
+	case GL_DEPTH_TEST:
+		return "GL_DEPTH_TEST";
+	case GL_CULL_FACE:
+		return "GL_CULL_FACE";
+	case GL_CLIP_PLANE0:
+		return "GL_CLIP_PLANE0";
+	case GL_COLOR_ARRAY:
+		return "GL_COLOR_ARRAY";
+	case GL_TEXTURE_COORD_ARRAY:
+		return "GL_TEXTURE_COORD_ARRAY";
+	case GL_VERTEX_ARRAY:
+		return "GL_VERTEX_ARRAY";
+	case GL_ALPHA_TEST:
+		return "GL_ALPHA_TEST";
+	case GL_STENCIL_TEST:
+		return "GL_STENCIL_TEST";
+	default:
+		sprintf( buffer, "0x%x", cap );
+	}
+
+	return buffer;
+}
+
+static const char * TypeToString( GLenum t )
+{
+	switch ( t )
+	{
+	case GL_BYTE:
+		return "GL_BYTE";
+	case GL_UNSIGNED_BYTE:
+		return "GL_UNSIGNED_BYTE";
+	case GL_SHORT:
+		return "GL_SHORT";
+	case GL_UNSIGNED_SHORT:
+		return "GL_UNSIGNED_SHORT";
+	case GL_INT:
+		return "GL_INT";
+	case GL_UNSIGNED_INT:
+		return "GL_UNSIGNED_INT";
+	case GL_FLOAT:
+		return "GL_FLOAT";
+	case GL_DOUBLE:
+		return "GL_DOUBLE";
+	default:
+		return "!!! UNKNOWN !!!";
+	}
+}
+
+static void APIENTRY logAccum(GLenum op, GLfloat value)
+{
+	fprintf( glw_state.log_fp, "glAccum\n" );
+	dllAccum( op, value );
+}
+
+static void APIENTRY logAlphaFunc(GLenum func, GLclampf ref)
+{
+	fprintf( glw_state.log_fp, "glAlphaFunc( 0x%x, %f )\n", func, ref );
+	dllAlphaFunc( func, ref );
+}
+
+static GLboolean APIENTRY logAreTexturesResident(GLsizei n, const GLuint *textures, GLboolean *residences)
+{
+	fprintf( glw_state.log_fp, "glAreTexturesResident\n" );
+	return dllAreTexturesResident( n, textures, residences );
+}
+
+static void APIENTRY logArrayElement(GLint i)
+{
+	fprintf( glw_state.log_fp, "glArrayElement\n" );
+	dllArrayElement( i );
+}
+
+static void APIENTRY logBegin(GLenum mode)
+{
+	fprintf( glw_state.log_fp, "glBegin( %s )\n", PrimToString( mode ));
+	dllBegin( mode );
+}
+
+static void APIENTRY logBindTexture(GLenum target, GLuint texture)
+{
+	fprintf( glw_state.log_fp, "glBindTexture( 0x%x, %u )\n", target, texture );
+	dllBindTexture( target, texture );
+}
+
+static void APIENTRY logBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap)
+{
+	fprintf( glw_state.log_fp, "glBitmap\n" );
+	dllBitmap( width, height, xorig, yorig, xmove, ymove, bitmap );
+}
+
+static void BlendToName( char *n, GLenum f )
+{
+	switch ( f )
+	{
+	case GL_ONE:
+		strcpy( n, "GL_ONE" );
+		break;
+	case GL_ZERO:
+		strcpy( n, "GL_ZERO" );
+		break;
+	case GL_SRC_ALPHA:
+		strcpy( n, "GL_SRC_ALPHA" );
+		break;
+	case GL_ONE_MINUS_SRC_ALPHA:
+		strcpy( n, "GL_ONE_MINUS_SRC_ALPHA" );
+		break;
+	case GL_DST_COLOR:
+		strcpy( n, "GL_DST_COLOR" );
+		break;
+	case GL_ONE_MINUS_DST_COLOR:
+		strcpy( n, "GL_ONE_MINUS_DST_COLOR" );
+		break;
+	case GL_DST_ALPHA:
+		strcpy( n, "GL_DST_ALPHA" );
+		break;
+	default:
+		sprintf( n, "0x%x", f );
+	}
+}
+static void APIENTRY logBlendFunc(GLenum sfactor, GLenum dfactor)
+{
+	char sf[128], df[128];
+
+	BlendToName( sf, sfactor );
+	BlendToName( df, dfactor );
+
+	fprintf( glw_state.log_fp, "glBlendFunc( %s, %s )\n", sf, df );
+	dllBlendFunc( sfactor, dfactor );
+}
+
+static void APIENTRY logCallList(GLuint list)
+{
+	fprintf( glw_state.log_fp, "glCallList( %u )\n", list );
+	dllCallList( list );
+}
+
+static void APIENTRY logCallLists(GLsizei n, GLenum type, const void *lists)
+{
+	fprintf( glw_state.log_fp, "glCallLists\n" );
+	dllCallLists( n, type, lists );
+}
+
+static void APIENTRY logClear(GLbitfield mask)
+{
+	fprintf( glw_state.log_fp, "glClear( 0x%x = ", mask );
+
+	if ( mask & GL_COLOR_BUFFER_BIT )
+		fprintf( glw_state.log_fp, "GL_COLOR_BUFFER_BIT " );
+	if ( mask & GL_DEPTH_BUFFER_BIT )
+		fprintf( glw_state.log_fp, "GL_DEPTH_BUFFER_BIT " );
+	if ( mask & GL_STENCIL_BUFFER_BIT )
+		fprintf( glw_state.log_fp, "GL_STENCIL_BUFFER_BIT " );
+	if ( mask & GL_ACCUM_BUFFER_BIT )
+		fprintf( glw_state.log_fp, "GL_ACCUM_BUFFER_BIT " );
+
+	fprintf( glw_state.log_fp, ")\n" );
+	dllClear( mask );
+}
+
+static void APIENTRY logClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
+{
+	fprintf( glw_state.log_fp, "glClearAccum\n" );
+	dllClearAccum( red, green, blue, alpha );
+}
+
+static void APIENTRY logClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
+{
+	fprintf( glw_state.log_fp, "glClearColor\n" );
+	dllClearColor( red, green, blue, alpha );
+}
+
+static void APIENTRY logClearDepth(GLclampd depth)
+{
+	fprintf( glw_state.log_fp, "glClearDepth( %f )\n", ( float ) depth );
+	dllClearDepth( depth );
+}
+
+static void APIENTRY logClearIndex(GLfloat c)
+{
+	fprintf( glw_state.log_fp, "glClearIndex\n" );
+	dllClearIndex( c );
+}
+
+static void APIENTRY logClearStencil(GLint s)
+{
+	fprintf( glw_state.log_fp, "glClearStencil( %d )\n", s );
+	dllClearStencil( s );
+}
+
+static void APIENTRY logClipPlane(GLenum plane, const GLdouble *equation)
+{
+	fprintf( glw_state.log_fp, "glClipPlane\n" );
+	dllClipPlane( plane, equation );
+}
+
+static void APIENTRY logColor3b(GLbyte red, GLbyte green, GLbyte blue)
+{
+	fprintf( glw_state.log_fp, "glColor3b\n" );
+	dllColor3b( red, green, blue );
+}
+
+static void APIENTRY logColor3bv(const GLbyte *v)
+{
+	fprintf( glw_state.log_fp, "glColor3bv\n" );
+	dllColor3bv( v );
+}
+
+static void APIENTRY logColor3d(GLdouble red, GLdouble green, GLdouble blue)
+{
+	fprintf( glw_state.log_fp, "glColor3d\n" );
+	dllColor3d( red, green, blue );
+}
+
+static void APIENTRY logColor3dv(const GLdouble *v)
+{
+	fprintf( glw_state.log_fp, "glColor3dv\n" );
+	dllColor3dv( v );
+}
+
+static void APIENTRY logColor3f(GLfloat red, GLfloat green, GLfloat blue)
+{
+	fprintf( glw_state.log_fp, "glColor3f\n" );
+	dllColor3f( red, green, blue );
+}
+
+static void APIENTRY logColor3fv(const GLfloat *v)
+{
+	fprintf( glw_state.log_fp, "glColor3fv\n" );
+	dllColor3fv( v );
+}
+
+static void APIENTRY logColor3i(GLint red, GLint green, GLint blue)
+{
+	fprintf( glw_state.log_fp, "glColor3i\n" );
+	dllColor3i( red, green, blue );
+}
+
+static void APIENTRY logColor3iv(const GLint *v)
+{
+	fprintf( glw_state.log_fp, "glColor3iv\n" );
+	dllColor3iv( v );
+}
+
+static void APIENTRY logColor3s(GLshort red, GLshort green, GLshort blue)
+{
+	fprintf( glw_state.log_fp, "glColor3s\n" );
+	dllColor3s( red, green, blue );
+}
+
+static void APIENTRY logColor3sv(const GLshort *v)
+{
+	fprintf( glw_state.log_fp, "glColor3sv\n" );
+	dllColor3sv( v );
+}
+
+static void APIENTRY logColor3ub(GLubyte red, GLubyte green, GLubyte blue)
+{
+	fprintf( glw_state.log_fp, "glColor3ub\n" );
+	dllColor3ub( red, green, blue );
+}
+
+static void APIENTRY logColor3ubv(const GLubyte *v)
+{
+	fprintf( glw_state.log_fp, "glColor3ubv\n" );
+	dllColor3ubv( v );
+}
+
+#define SIG( x ) fprintf( glw_state.log_fp, x "\n" )
+
+static void APIENTRY logColor3ui(GLuint red, GLuint green, GLuint blue)
+{
+	SIG( "glColor3ui" );
+	dllColor3ui( red, green, blue );
+}
+
+static void APIENTRY logColor3uiv(const GLuint *v)
+{
+	SIG( "glColor3uiv" );
+	dllColor3uiv( v );
+}
+
+static void APIENTRY logColor3us(GLushort red, GLushort green, GLushort blue)
+{
+	SIG( "glColor3us" );
+	dllColor3us( red, green, blue );
+}
+
+static void APIENTRY logColor3usv(const GLushort *v)
+{
+	SIG( "glColor3usv" );
+	dllColor3usv( v );
+}
+
+static void APIENTRY logColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha)
+{
+	SIG( "glColor4b" );
+	dllColor4b( red, green, blue, alpha );
+}
+
+static void APIENTRY logColor4bv(const GLbyte *v)
+{
+	SIG( "glColor4bv" );
+	dllColor4bv( v );
+}
+
+static void APIENTRY logColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha)
+{
+	SIG( "glColor4d" );
+	dllColor4d( red, green, blue, alpha );
+}
+static void APIENTRY logColor4dv(const GLdouble *v)
+{
+	SIG( "glColor4dv" );
+	dllColor4dv( v );
+}
+static void APIENTRY logColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
+{
+	fprintf( glw_state.log_fp, "glColor4f( %f,%f,%f,%f )\n", red, green, blue, alpha );
+	dllColor4f( red, green, blue, alpha );
+}
+static void APIENTRY logColor4fv(const GLfloat *v)
+{
+	fprintf( glw_state.log_fp, "glColor4fv( %f,%f,%f,%f )\n", v[0], v[1], v[2], v[3] );
+	dllColor4fv( v );
+}
+static void APIENTRY logColor4i(GLint red, GLint green, GLint blue, GLint alpha)
+{
+	SIG( "glColor4i" );
+	dllColor4i( red, green, blue, alpha );
+}
+static void APIENTRY logColor4iv(const GLint *v)
+{
+	SIG( "glColor4iv" );
+	dllColor4iv( v );
+}
+static void APIENTRY logColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha)
+{
+	SIG( "glColor4s" );
+	dllColor4s( red, green, blue, alpha );
+}
+static void APIENTRY logColor4sv(const GLshort *v)
+{
+	SIG( "glColor4sv" );
+	dllColor4sv( v );
+}
+static void APIENTRY logColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
+{
+	SIG( "glColor4b" );
+	dllColor4b( red, green, blue, alpha );
+}
+static void APIENTRY logColor4ubv(const GLubyte *v)
+{
+	SIG( "glColor4ubv" );
+	dllColor4ubv( v );
+}
+static void APIENTRY logColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha)
+{
+	SIG( "glColor4ui" );
+	dllColor4ui( red, green, blue, alpha );
+}
+static void APIENTRY logColor4uiv(const GLuint *v)
+{
+	SIG( "glColor4uiv" );
+	dllColor4uiv( v );
+}
+static void APIENTRY logColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha)
+{
+	SIG( "glColor4us" );
+	dllColor4us( red, green, blue, alpha );
+}
+static void APIENTRY logColor4usv(const GLushort *v)
+{
+	SIG( "glColor4usv" );
+	dllColor4usv( v );
+}
+static void APIENTRY logColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
+{
+	SIG( "glColorMask" );
+	dllColorMask( red, green, blue, alpha );
+}
+static void APIENTRY logColorMaterial(GLenum face, GLenum mode)
+{
+	SIG( "glColorMaterial" );
+	dllColorMaterial( face, mode );
+}
+
+static void APIENTRY logColorPointer(GLint size, GLenum type, GLsizei stride, const void *pointer)
+{
+	fprintf( glw_state.log_fp, "glColorPointer( %d, %s, %d, MEM )\n", size, TypeToString( type ), stride );
+	dllColorPointer( size, type, stride, pointer );
+}
+
+static void APIENTRY logCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type)
+{
+	SIG( "glCopyPixels" );
+	dllCopyPixels( x, y, width, height, type );
+}
+
+static void APIENTRY logCopyTexImage1D(GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border)
+{
+	SIG( "glCopyTexImage1D" );
+	dllCopyTexImage1D( target, level, internalFormat, x, y, width, border );
+}
+
+static void APIENTRY logCopyTexImage2D(GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
+{
+	SIG( "glCopyTexImage2D" );
+	dllCopyTexImage2D( target, level, internalFormat, x, y, width, height, border );
+}
+
+static void APIENTRY logCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
+{
+	SIG( "glCopyTexSubImage1D" );
+	dllCopyTexSubImage1D( target, level, xoffset, x, y, width );
+}
+
+static void APIENTRY logCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
+{
+	SIG( "glCopyTexSubImage2D" );
+	dllCopyTexSubImage2D( target, level, xoffset, yoffset, x, y, width, height );
+}
+
+static void APIENTRY logCullFace(GLenum mode)
+{
+	fprintf( glw_state.log_fp, "glCullFace( %s )\n", ( mode == GL_FRONT ) ? "GL_FRONT" : "GL_BACK" );
+	dllCullFace( mode );
+}
+
+static void APIENTRY logDeleteLists(GLuint list, GLsizei range)
+{
+	SIG( "glDeleteLists" );
+	dllDeleteLists( list, range );
+}
+
+static void APIENTRY logDeleteTextures(GLsizei n, const GLuint *textures)
+{
+	SIG( "glDeleteTextures" );
+	dllDeleteTextures( n, textures );
+}
+
+static void APIENTRY logDepthFunc(GLenum func)
+{
+	fprintf( glw_state.log_fp, "glDepthFunc( %s )\n", FuncToString( func ) );
+	dllDepthFunc( func );
+}
+
+static void APIENTRY logDepthMask(GLboolean flag)
+{
+	fprintf( glw_state.log_fp, "glDepthMask( %s )\n", BooleanToString( flag ) );
+	dllDepthMask( flag );
+}
+
+static void APIENTRY logDepthRange(GLclampd zNear, GLclampd zFar)
+{
+	fprintf( glw_state.log_fp, "glDepthRange( %f, %f )\n", ( float ) zNear, ( float ) zFar );
+	dllDepthRange( zNear, zFar );
+}
+
+static void APIENTRY logDisable(GLenum cap)
+{
+	fprintf( glw_state.log_fp, "glDisable( %s )\n", CapToString( cap ) );
+	dllDisable( cap );
+}
+
+static void APIENTRY logDisableClientState(GLenum array)
+{
+	fprintf( glw_state.log_fp, "glDisableClientState( %s )\n", CapToString( array ) );
+	dllDisableClientState( array );
+}
+
+static void APIENTRY logDrawArrays(GLenum mode, GLint first, GLsizei count)
+{
+	SIG( "glDrawArrays" );
+	dllDrawArrays( mode, first, count );
+}
+
+static void APIENTRY logDrawBuffer(GLenum mode)
+{
+	SIG( "glDrawBuffer" );
+	dllDrawBuffer( mode );
+}
+
+static void APIENTRY logDrawElements(GLenum mode, GLsizei count, GLenum type, const void *indices)
+{
+	fprintf( glw_state.log_fp, "glDrawElements( %s, %d, %s, MEM )\n", PrimToString( mode ), count, TypeToString( type ) );
+	dllDrawElements( mode, count, type, indices );
+}
+
+static void APIENTRY logDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels)
+{
+	SIG( "glDrawPixels" );
+	dllDrawPixels( width, height, format, type, pixels );
+}
+
+static void APIENTRY logEdgeFlag(GLboolean flag)
+{
+	SIG( "glEdgeFlag" );
+	dllEdgeFlag( flag );
+}
+
+static void APIENTRY logEdgeFlagPointer(GLsizei stride, const void *pointer)
+{
+	SIG( "glEdgeFlagPointer" );
+	dllEdgeFlagPointer( stride, pointer );
+}
+
+static void APIENTRY logEdgeFlagv(const GLboolean *flag)
+{
+	SIG( "glEdgeFlagv" );
+	dllEdgeFlagv( flag );
+}
+
+static void APIENTRY logEnable(GLenum cap)
+{
+	fprintf( glw_state.log_fp, "glEnable( %s )\n", CapToString( cap ) );
+	dllEnable( cap );
+}
+
+static void APIENTRY logEnableClientState(GLenum array)
+{
+	fprintf( glw_state.log_fp, "glEnableClientState( %s )\n", CapToString( array ) );
+	dllEnableClientState( array );
+}
+
+static void APIENTRY logEnd(void)
+{
+	SIG( "glEnd" );
+	dllEnd();
+}
+
+static void APIENTRY logEndList(void)
+{
+	SIG( "glEndList" );
+	dllEndList();
+}
+
+static void APIENTRY logEvalCoord1d(GLdouble u)
+{
+	SIG( "glEvalCoord1d" );
+	dllEvalCoord1d( u );
+}
+
+static void APIENTRY logEvalCoord1dv(const GLdouble *u)
+{
+	SIG( "glEvalCoord1dv" );
+	dllEvalCoord1dv( u );
+}
+
+static void APIENTRY logEvalCoord1f(GLfloat u)
+{
+	SIG( "glEvalCoord1f" );
+	dllEvalCoord1f( u );
+}
+
+static void APIENTRY logEvalCoord1fv(const GLfloat *u)
+{
+	SIG( "glEvalCoord1fv" );
+	dllEvalCoord1fv( u );
+}
+static void APIENTRY logEvalCoord2d(GLdouble u, GLdouble v)
+{
+	SIG( "glEvalCoord2d" );
+	dllEvalCoord2d( u, v );
+}
+static void APIENTRY logEvalCoord2dv(const GLdouble *u)
+{
+	SIG( "glEvalCoord2dv" );
+	dllEvalCoord2dv( u );
+}
+static void APIENTRY logEvalCoord2f(GLfloat u, GLfloat v)
+{
+	SIG( "glEvalCoord2f" );
+	dllEvalCoord2f( u, v );
+}
+static void APIENTRY logEvalCoord2fv(const GLfloat *u)
+{
+	SIG( "glEvalCoord2fv" );
+	dllEvalCoord2fv( u );
+}
+
+static void APIENTRY logEvalMesh1(GLenum mode, GLint i1, GLint i2)
+{
+	SIG( "glEvalMesh1" );
+	dllEvalMesh1( mode, i1, i2 );
+}
+static void APIENTRY logEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)
+{
+	SIG( "glEvalMesh2" );
+	dllEvalMesh2( mode, i1, i2, j1, j2 );
+}
+static void APIENTRY logEvalPoint1(GLint i)
+{
+	SIG( "glEvalPoint1" );
+	dllEvalPoint1( i );
+}
+static void APIENTRY logEvalPoint2(GLint i, GLint j)
+{
+	SIG( "glEvalPoint2" );
+	dllEvalPoint2( i, j );
+}
+
+static void APIENTRY logFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer)
+{
+	SIG( "glFeedbackBuffer" );
+	dllFeedbackBuffer( size, type, buffer );
+}
+
+static void APIENTRY logFinish(void)
+{
+	SIG( "glFinish" );
+	dllFinish();
+}
+
+static void APIENTRY logFlush(void)
+{
+	SIG( "glFlush" );
+	dllFlush();
+}
+
+static void APIENTRY logFogf(GLenum pname, GLfloat param)
+{
+	SIG( "glFogf" );
+	dllFogf( pname, param );
+}
+
+static void APIENTRY logFogfv(GLenum pname, const GLfloat *params)
+{
+	SIG( "glFogfv" );
+	dllFogfv( pname, params );
+}
+
+static void APIENTRY logFogi(GLenum pname, GLint param)
+{
+	SIG( "glFogi" );
+	dllFogi( pname, param );
+}
+
+static void APIENTRY logFogiv(GLenum pname, const GLint *params)
+{
+	SIG( "glFogiv" );
+	dllFogiv( pname, params );
+}
+
+static void APIENTRY logFrontFace(GLenum mode)
+{
+	SIG( "glFrontFace" );
+	dllFrontFace( mode );
+}
+
+static void APIENTRY logFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
+{
+	SIG( "glFrustum" );
+	dllFrustum( left, right, bottom, top, zNear, zFar );
+}
+
+static GLuint APIENTRY logGenLists(GLsizei range)
+{
+	SIG( "glGenLists" );
+	return dllGenLists( range );
+}
+
+static void APIENTRY logGenTextures(GLsizei n, GLuint *textures)
+{
+	SIG( "glGenTextures" );
+	dllGenTextures( n, textures );
+}
+
+static void APIENTRY logGetBooleanv(GLenum pname, GLboolean *params)
+{
+	SIG( "glGetBooleanv" );
+	dllGetBooleanv( pname, params );
+}
+
+static void APIENTRY logGetClipPlane(GLenum plane, GLdouble *equation)
+{
+	SIG( "glGetClipPlane" );
+	dllGetClipPlane( plane, equation );
+}
+
+static void APIENTRY logGetDoublev(GLenum pname, GLdouble *params)
+{
+	SIG( "glGetDoublev" );
+	dllGetDoublev( pname, params );
+}
+
+static GLenum APIENTRY logGetError(void)
+{
+	SIG( "glGetError" );
+	return dllGetError();
+}
+
+static void APIENTRY logGetFloatv(GLenum pname, GLfloat *params)
+{
+	SIG( "glGetFloatv" );
+	dllGetFloatv( pname, params );
+}
+
+static void APIENTRY logGetIntegerv(GLenum pname, GLint *params)
+{
+	SIG( "glGetIntegerv" );
+	dllGetIntegerv( pname, params );
+}
+
+static void APIENTRY logGetLightfv(GLenum light, GLenum pname, GLfloat *params)
+{
+	SIG( "glGetLightfv" );
+	dllGetLightfv( light, pname, params );
+}
+
+static void APIENTRY logGetLightiv(GLenum light, GLenum pname, GLint *params)
+{
+	SIG( "glGetLightiv" );
+	dllGetLightiv( light, pname, params );
+}
+
+static void APIENTRY logGetMapdv(GLenum target, GLenum query, GLdouble *v)
+{
+	SIG( "glGetMapdv" );
+	dllGetMapdv( target, query, v );
+}
+
+static void APIENTRY logGetMapfv(GLenum target, GLenum query, GLfloat *v)
+{
+	SIG( "glGetMapfv" );
+	dllGetMapfv( target, query, v );
+}
+
+static void APIENTRY logGetMapiv(GLenum target, GLenum query, GLint *v)
+{
+	SIG( "glGetMapiv" );
+	dllGetMapiv( target, query, v );
+}
+
+static void APIENTRY logGetMaterialfv(GLenum face, GLenum pname, GLfloat *params)
+{
+	SIG( "glGetMaterialfv" );
+	dllGetMaterialfv( face, pname, params );
+}
+
+static void APIENTRY logGetMaterialiv(GLenum face, GLenum pname, GLint *params)
+{
+	SIG( "glGetMaterialiv" );
+	dllGetMaterialiv( face, pname, params );
+}
+
+static void APIENTRY logGetPixelMapfv(GLenum map, GLfloat *values)
+{
+	SIG( "glGetPixelMapfv" );
+	dllGetPixelMapfv( map, values );
+}
+
+static void APIENTRY logGetPixelMapuiv(GLenum map, GLuint *values)
+{
+	SIG( "glGetPixelMapuiv" );
+	dllGetPixelMapuiv( map, values );
+}
+
+static void APIENTRY logGetPixelMapusv(GLenum map, GLushort *values)
+{
+	SIG( "glGetPixelMapusv" );
+	dllGetPixelMapusv( map, values );
+}
+
+static void APIENTRY logGetPointerv(GLenum pname, GLvoid* *params)
+{
+	SIG( "glGetPointerv" );
+	dllGetPointerv( pname, params );
+}
+
+static void APIENTRY logGetPolygonStipple(GLubyte *mask)
+{
+	SIG( "glGetPolygonStipple" );
+	dllGetPolygonStipple( mask );
+}
+
+static const GLubyte * APIENTRY logGetString(GLenum name)
+{
+	SIG( "glGetString" );
+	return dllGetString( name );
+}
+
+static void APIENTRY logGetTexEnvfv(GLenum target, GLenum pname, GLfloat *params)
+{
+	SIG( "glGetTexEnvfv" );
+	dllGetTexEnvfv( target, pname, params );
+}
+
+static void APIENTRY logGetTexEnviv(GLenum target, GLenum pname, GLint *params)
+{
+	SIG( "glGetTexEnviv" );
+	dllGetTexEnviv( target, pname, params );
+}
+
+static void APIENTRY logGetTexGendv(GLenum coord, GLenum pname, GLdouble *params)
+{
+	SIG( "glGetTexGendv" );
+	dllGetTexGendv( coord, pname, params );
+}
+
+static void APIENTRY logGetTexGenfv(GLenum coord, GLenum pname, GLfloat *params)
+{
+	SIG( "glGetTexGenfv" );
+	dllGetTexGenfv( coord, pname, params );
+}
+
+static void APIENTRY logGetTexGeniv(GLenum coord, GLenum pname, GLint *params)
+{
+	SIG( "glGetTexGeniv" );
+	dllGetTexGeniv( coord, pname, params );
+}
+
+static void APIENTRY logGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, void *pixels)
+{
+	SIG( "glGetTexImage" );
+	dllGetTexImage( target, level, format, type, pixels );
+}
+static void APIENTRY logGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params )
+{
+	SIG( "glGetTexLevelParameterfv" );
+	dllGetTexLevelParameterfv( target, level, pname, params );
+}
+
+static void APIENTRY logGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params)
+{
+	SIG( "glGetTexLevelParameteriv" );
+	dllGetTexLevelParameteriv( target, level, pname, params );
+}
+
+static void APIENTRY logGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params)
+{
+	SIG( "glGetTexParameterfv" );
+	dllGetTexParameterfv( target, pname, params );
+}
+
+static void APIENTRY logGetTexParameteriv(GLenum target, GLenum pname, GLint *params)
+{
+	SIG( "glGetTexParameteriv" );
+	dllGetTexParameteriv( target, pname, params );
+}
+
+static void APIENTRY logHint(GLenum target, GLenum mode)
+{
+	fprintf( glw_state.log_fp, "glHint( 0x%x, 0x%x )\n", target, mode );
+	dllHint( target, mode );
+}
+
+static void APIENTRY logIndexMask(GLuint mask)
+{
+	SIG( "glIndexMask" );
+	dllIndexMask( mask );
+}
+
+static void APIENTRY logIndexPointer(GLenum type, GLsizei stride, const void *pointer)
+{
+	SIG( "glIndexPointer" );
+	dllIndexPointer( type, stride, pointer );
+}
+
+static void APIENTRY logIndexd(GLdouble c)
+{
+	SIG( "glIndexd" );
+	dllIndexd( c );
+}
+
+static void APIENTRY logIndexdv(const GLdouble *c)
+{
+	SIG( "glIndexdv" );
+	dllIndexdv( c );
+}
+
+static void APIENTRY logIndexf(GLfloat c)
+{
+	SIG( "glIndexf" );
+	dllIndexf( c );
+}
+
+static void APIENTRY logIndexfv(const GLfloat *c)
+{
+	SIG( "glIndexfv" );
+	dllIndexfv( c );
+}
+
+static void APIENTRY logIndexi(GLint c)
+{
+	SIG( "glIndexi" );
+	dllIndexi( c );
+}
+
+static void APIENTRY logIndexiv(const GLint *c)
+{
+	SIG( "glIndexiv" );
+	dllIndexiv( c );
+}
+
+static void APIENTRY logIndexs(GLshort c)
+{
+	SIG( "glIndexs" );
+	dllIndexs( c );
+}
+
+static void APIENTRY logIndexsv(const GLshort *c)
+{
+	SIG( "glIndexsv" );
+	dllIndexsv( c );
+}
+
+static void APIENTRY logIndexub(GLubyte c)
+{
+	SIG( "glIndexub" );
+	dllIndexub( c );
+}
+
+static void APIENTRY logIndexubv(const GLubyte *c)
+{
+	SIG( "glIndexubv" );
+	dllIndexubv( c );
+}
+
+static void APIENTRY logInitNames(void)
+{
+	SIG( "glInitNames" );
+	dllInitNames();
+}
+
+static void APIENTRY logInterleavedArrays(GLenum format, GLsizei stride, const void *pointer)
+{
+	SIG( "glInterleavedArrays" );
+	dllInterleavedArrays( format, stride, pointer );
+}
+
+static GLboolean APIENTRY logIsEnabled(GLenum cap)
+{
+	SIG( "glIsEnabled" );
+	return dllIsEnabled( cap );
+}
+static GLboolean APIENTRY logIsList(GLuint list)
+{
+	SIG( "glIsList" );
+	return dllIsList( list );
+}
+static GLboolean APIENTRY logIsTexture(GLuint texture)
+{
+	SIG( "glIsTexture" );
+	return dllIsTexture( texture );
+}
+
+static void APIENTRY logLightModelf(GLenum pname, GLfloat param)
+{
+	SIG( "glLightModelf" );
+	dllLightModelf( pname, param );
+}
+
+static void APIENTRY logLightModelfv(GLenum pname, const GLfloat *params)
+{
+	SIG( "glLightModelfv" );
+	dllLightModelfv( pname, params );
+}
+
+static void APIENTRY logLightModeli(GLenum pname, GLint param)
+{
+	SIG( "glLightModeli" );
+	dllLightModeli( pname, param );
+
+}
+
+static void APIENTRY logLightModeliv(GLenum pname, const GLint *params)
+{
+	SIG( "glLightModeliv" );
+	dllLightModeliv( pname, params );
+}
+
+static void APIENTRY logLightf(GLenum light, GLenum pname, GLfloat param)
+{
+	SIG( "glLightf" );
+	dllLightf( light, pname, param );
+}
+
+static void APIENTRY logLightfv(GLenum light, GLenum pname, const GLfloat *params)
+{
+	SIG( "glLightfv" );
+	dllLightfv( light, pname, params );
+}
+
+static void APIENTRY logLighti(GLenum light, GLenum pname, GLint param)
+{
+	SIG( "glLighti" );
+	dllLighti( light, pname, param );
+}
+
+static void APIENTRY logLightiv(GLenum light, GLenum pname, const GLint *params)
+{
+	SIG( "glLightiv" );
+	dllLightiv( light, pname, params );
+}
+
+static void APIENTRY logLineStipple(GLint factor, GLushort pattern)
+{
+	SIG( "glLineStipple" );
+	dllLineStipple( factor, pattern );
+}
+
+static void APIENTRY logLineWidth(GLfloat width)
+{
+	SIG( "glLineWidth" );
+	dllLineWidth( width );
+}
+
+static void APIENTRY logListBase(GLuint base)
+{
+	SIG( "glListBase" );
+	dllListBase( base );
+}
+
+static void APIENTRY logLoadIdentity(void)
+{
+	SIG( "glLoadIdentity" );
+	dllLoadIdentity();
+}
+
+static void APIENTRY logLoadMatrixd(const GLdouble *m)
+{
+	SIG( "glLoadMatrixd" );
+	dllLoadMatrixd( m );
+}
+
+static void APIENTRY logLoadMatrixf(const GLfloat *m)
+{
+	SIG( "glLoadMatrixf" );
+	dllLoadMatrixf( m );
+}
+
+static void APIENTRY logLoadName(GLuint name)
+{
+	SIG( "glLoadName" );
+	dllLoadName( name );
+}
+
+static void APIENTRY logLogicOp(GLenum opcode)
+{
+	SIG( "glLogicOp" );
+	dllLogicOp( opcode );
+}
+
+static void APIENTRY logMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points)
+{
+	SIG( "glMap1d" );
+	dllMap1d( target, u1, u2, stride, order, points );
+}
+
+static void APIENTRY logMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points)
+{
+	SIG( "glMap1f" );
+	dllMap1f( target, u1, u2, stride, order, points );
+}
+
+static void APIENTRY logMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points)
+{
+	SIG( "glMap2d" );
+	dllMap2d( target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points );
+}
+
+static void APIENTRY logMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points)
+{
+	SIG( "glMap2f" );
+	dllMap2f( target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points );
+}
+
+static void APIENTRY logMapGrid1d(GLint un, GLdouble u1, GLdouble u2)
+{
+	SIG( "glMapGrid1d" );
+	dllMapGrid1d( un, u1, u2 );
+}
+
+static void APIENTRY logMapGrid1f(GLint un, GLfloat u1, GLfloat u2)
+{
+	SIG( "glMapGrid1f" );
+	dllMapGrid1f( un, u1, u2 );
+}
+
+static void APIENTRY logMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2)
+{
+	SIG( "glMapGrid2d" );
+	dllMapGrid2d( un, u1, u2, vn, v1, v2 );
+}
+static void APIENTRY logMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2)
+{
+	SIG( "glMapGrid2f" );
+	dllMapGrid2f( un, u1, u2, vn, v1, v2 );
+}
+static void APIENTRY logMaterialf(GLenum face, GLenum pname, GLfloat param)
+{
+	SIG( "glMaterialf" );
+	dllMaterialf( face, pname, param );
+}
+static void APIENTRY logMaterialfv(GLenum face, GLenum pname, const GLfloat *params)
+{
+	SIG( "glMaterialfv" );
+	dllMaterialfv( face, pname, params );
+}
+
+static void APIENTRY logMateriali(GLenum face, GLenum pname, GLint param)
+{
+	SIG( "glMateriali" );
+	dllMateriali( face, pname, param );
+}
+
+static void APIENTRY logMaterialiv(GLenum face, GLenum pname, const GLint *params)
+{
+	SIG( "glMaterialiv" );
+	dllMaterialiv( face, pname, params );
+}
+
+static void APIENTRY logMatrixMode(GLenum mode)
+{
+	SIG( "glMatrixMode" );
+	dllMatrixMode( mode );
+}
+
+static void APIENTRY logMultMatrixd(const GLdouble *m)
+{
+	SIG( "glMultMatrixd" );
+	dllMultMatrixd( m );
+}
+
+static void APIENTRY logMultMatrixf(const GLfloat *m)
+{
+	SIG( "glMultMatrixf" );
+	dllMultMatrixf( m );
+}
+
+static void APIENTRY logNewList(GLuint list, GLenum mode)
+{
+	SIG( "glNewList" );
+	dllNewList( list, mode );
+}
+
+static void APIENTRY logNormal3b(GLbyte nx, GLbyte ny, GLbyte nz)
+{
+	SIG ("glNormal3b" );
+	dllNormal3b( nx, ny, nz );
+}
+
+static void APIENTRY logNormal3bv(const GLbyte *v)
+{
+	SIG( "glNormal3bv" );
+	dllNormal3bv( v );
+}
+
+static void APIENTRY logNormal3d(GLdouble nx, GLdouble ny, GLdouble nz)
+{
+	SIG( "glNormal3d" );
+	dllNormal3d( nx, ny, nz );
+}
+
+static void APIENTRY logNormal3dv(const GLdouble *v)
+{
+	SIG( "glNormal3dv" );
+	dllNormal3dv( v );
+}
+
+static void APIENTRY logNormal3f(GLfloat nx, GLfloat ny, GLfloat nz)
+{
+	SIG( "glNormal3f" );
+	dllNormal3f( nx, ny, nz );
+}
+
+static void APIENTRY logNormal3fv(const GLfloat *v)
+{
+	SIG( "glNormal3fv" );
+	dllNormal3fv( v );
+}
+static void APIENTRY logNormal3i(GLint nx, GLint ny, GLint nz)
+{
+	SIG( "glNormal3i" );
+	dllNormal3i( nx, ny, nz );
+}
+static void APIENTRY logNormal3iv(const GLint *v)
+{
+	SIG( "glNormal3iv" );
+	dllNormal3iv( v );
+}
+static void APIENTRY logNormal3s(GLshort nx, GLshort ny, GLshort nz)
+{
+	SIG( "glNormal3s" );
+	dllNormal3s( nx, ny, nz );
+}
+static void APIENTRY logNormal3sv(const GLshort *v)
+{
+	SIG( "glNormal3sv" );
+	dllNormal3sv( v );
+}
+static void APIENTRY logNormalPointer(GLenum type, GLsizei stride, const void *pointer)
+{
+	SIG( "glNormalPointer" );
+	dllNormalPointer( type, stride, pointer );
+}
+static void APIENTRY logOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
+{
+	SIG( "glOrtho" );
+	dllOrtho( left, right, bottom, top, zNear, zFar );
+}
+
+static void APIENTRY logPassThrough(GLfloat token)
+{
+	SIG( "glPassThrough" );
+	dllPassThrough( token );
+}
+
+static void APIENTRY logPixelMapfv(GLenum map, GLsizei mapsize, const GLfloat *values)
+{
+	SIG( "glPixelMapfv" );
+	dllPixelMapfv( map, mapsize, values );
+}
+
+static void APIENTRY logPixelMapuiv(GLenum map, GLsizei mapsize, const GLuint *values)
+{
+	SIG( "glPixelMapuiv" );
+	dllPixelMapuiv( map, mapsize, values );
+}
+
+static void APIENTRY logPixelMapusv(GLenum map, GLsizei mapsize, const GLushort *values)
+{
+	SIG( "glPixelMapusv" );
+	dllPixelMapusv( map, mapsize, values );
+}
+static void APIENTRY logPixelStoref(GLenum pname, GLfloat param)
+{
+	SIG( "glPixelStoref" );
+	dllPixelStoref( pname, param );
+}
+static void APIENTRY logPixelStorei(GLenum pname, GLint param)
+{
+	SIG( "glPixelStorei" );
+	dllPixelStorei( pname, param );
+}
+static void APIENTRY logPixelTransferf(GLenum pname, GLfloat param)
+{
+	SIG( "glPixelTransferf" );
+	dllPixelTransferf( pname, param );
+}
+
+static void APIENTRY logPixelTransferi(GLenum pname, GLint param)
+{
+	SIG( "glPixelTransferi" );
+	dllPixelTransferi( pname, param );
+}
+
+static void APIENTRY logPixelZoom(GLfloat xfactor, GLfloat yfactor)
+{
+	SIG( "glPixelZoom" );
+	dllPixelZoom( xfactor, yfactor );
+}
+
+static void APIENTRY logPointSize(GLfloat size)
+{
+	SIG( "glPointSize" );
+	dllPointSize( size );
+}
+
+static void APIENTRY logPolygonMode(GLenum face, GLenum mode)
+{
+	fprintf( glw_state.log_fp, "glPolygonMode( 0x%x, 0x%x )\n", face, mode );
+	dllPolygonMode( face, mode );
+}
+
+static void APIENTRY logPolygonOffset(GLfloat factor, GLfloat units)
+{
+	SIG( "glPolygonOffset" );
+	dllPolygonOffset( factor, units );
+}
+static void APIENTRY logPolygonStipple(const GLubyte *mask )
+{
+	SIG( "glPolygonStipple" );
+	dllPolygonStipple( mask );
+}
+static void APIENTRY logPopAttrib(void)
+{
+	SIG( "glPopAttrib" );
+	dllPopAttrib();
+}
+
+static void APIENTRY logPopClientAttrib(void)
+{
+	SIG( "glPopClientAttrib" );
+	dllPopClientAttrib();
+}
+
+static void APIENTRY logPopMatrix(void)
+{
+	SIG( "glPopMatrix" );
+	dllPopMatrix();
+}
+
+static void APIENTRY logPopName(void)
+{
+	SIG( "glPopName" );
+	dllPopName();
+}
+
+static void APIENTRY logPrioritizeTextures(GLsizei n, const GLuint *textures, const GLclampf *priorities)
+{
+	SIG( "glPrioritizeTextures" );
+	dllPrioritizeTextures( n, textures, priorities );
+}
+
+static void APIENTRY logPushAttrib(GLbitfield mask)
+{
+	SIG( "glPushAttrib" );
+	dllPushAttrib( mask );
+}
+
+static void APIENTRY logPushClientAttrib(GLbitfield mask)
+{
+	SIG( "glPushClientAttrib" );
+	dllPushClientAttrib( mask );
+}
+
+static void APIENTRY logPushMatrix(void)
+{
+	SIG( "glPushMatrix" );
+	dllPushMatrix();
+}
+
+static void APIENTRY logPushName(GLuint name)
+{
+	SIG( "glPushName" );
+	dllPushName( name );
+}
+
+static void APIENTRY logRasterPos2d(GLdouble x, GLdouble y)
+{
+	SIG ("glRasterPot2d" );
+	dllRasterPos2d( x, y );
+}
+
+static void APIENTRY logRasterPos2dv(const GLdouble *v)
+{
+	SIG( "glRasterPos2dv" );
+	dllRasterPos2dv( v );
+}
+
+static void APIENTRY logRasterPos2f(GLfloat x, GLfloat y)
+{
+	SIG( "glRasterPos2f" );
+	dllRasterPos2f( x, y );
+}
+static void APIENTRY logRasterPos2fv(const GLfloat *v)
+{
+	SIG( "glRasterPos2dv" );
+	dllRasterPos2fv( v );
+}
+static void APIENTRY logRasterPos2i(GLint x, GLint y)
+{
+	SIG( "glRasterPos2if" );
+	dllRasterPos2i( x, y );
+}
+static void APIENTRY logRasterPos2iv(const GLint *v)
+{
+	SIG( "glRasterPos2iv" );
+	dllRasterPos2iv( v );
+}
+static void APIENTRY logRasterPos2s(GLshort x, GLshort y)
+{
+	SIG( "glRasterPos2s" );
+	dllRasterPos2s( x, y );
+}
+static void APIENTRY logRasterPos2sv(const GLshort *v)
+{
+	SIG( "glRasterPos2sv" );
+	dllRasterPos2sv( v );
+}
+static void APIENTRY logRasterPos3d(GLdouble x, GLdouble y, GLdouble z)
+{
+	SIG( "glRasterPos3d" );
+	dllRasterPos3d( x, y, z );
+}
+static void APIENTRY logRasterPos3dv(const GLdouble *v)
+{
+	SIG( "glRasterPos3dv" );
+	dllRasterPos3dv( v );
+}
+static void APIENTRY logRasterPos3f(GLfloat x, GLfloat y, GLfloat z)
+{
+	SIG( "glRasterPos3f" );
+	dllRasterPos3f( x, y, z );
+}
+static void APIENTRY logRasterPos3fv(const GLfloat *v)
+{
+	SIG( "glRasterPos3fv" );
+	dllRasterPos3fv( v );
+}
+static void APIENTRY logRasterPos3i(GLint x, GLint y, GLint z)
+{
+	SIG( "glRasterPos3i" );
+	dllRasterPos3i( x, y, z );
+}
+static void APIENTRY logRasterPos3iv(const GLint *v)
+{
+	SIG( "glRasterPos3iv" );
+	dllRasterPos3iv( v );
+}
+static void APIENTRY logRasterPos3s(GLshort x, GLshort y, GLshort z)
+{
+	SIG( "glRasterPos3s" );
+	dllRasterPos3s( x, y, z );
+}
+static void APIENTRY logRasterPos3sv(const GLshort *v)
+{
+	SIG( "glRasterPos3sv" );
+	dllRasterPos3sv( v );
+}
+static void APIENTRY logRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
+{
+	SIG( "glRasterPos4d" );
+	dllRasterPos4d( x, y, z, w );
+}
+static void APIENTRY logRasterPos4dv(const GLdouble *v)
+{
+	SIG( "glRasterPos4dv" );
+	dllRasterPos4dv( v );
+}
+static void APIENTRY logRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
+{
+	SIG( "glRasterPos4f" );
+	dllRasterPos4f( x, y, z, w );
+}
+static void APIENTRY logRasterPos4fv(const GLfloat *v)
+{
+	SIG( "glRasterPos4fv" );
+	dllRasterPos4fv( v );
+}
+static void APIENTRY logRasterPos4i(GLint x, GLint y, GLint z, GLint w)
+{
+	SIG( "glRasterPos4i" );
+	dllRasterPos4i( x, y, z, w );
+}
+static void APIENTRY logRasterPos4iv(const GLint *v)
+{
+	SIG( "glRasterPos4iv" );
+	dllRasterPos4iv( v );
+}
+static void APIENTRY logRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w)
+{
+	SIG( "glRasterPos4s" );
+	dllRasterPos4s( x, y, z, w );
+}
+static void APIENTRY logRasterPos4sv(const GLshort *v)
+{
+	SIG( "glRasterPos4sv" );
+	dllRasterPos4sv( v );
+}
+static void APIENTRY logReadBuffer(GLenum mode)
+{
+	SIG( "glReadBuffer" );
+	dllReadBuffer( mode );
+}
+static void APIENTRY logReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void *pixels)
+{
+	SIG( "glReadPixels" );
+	dllReadPixels( x, y, width, height, format, type, pixels );
+}
+
+static void APIENTRY logRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2)
+{
+	SIG( "glRectd" );
+	dllRectd( x1, y1, x2, y2 );
+}
+
+static void APIENTRY logRectdv(const GLdouble *v1, const GLdouble *v2)
+{
+	SIG( "glRectdv" );
+	dllRectdv( v1, v2 );
+}
+
+static void APIENTRY logRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)
+{
+	SIG( "glRectf" );
+	dllRectf( x1, y1, x2, y2 );
+}
+
+static void APIENTRY logRectfv(const GLfloat *v1, const GLfloat *v2)
+{
+	SIG( "glRectfv" );
+	dllRectfv( v1, v2 );
+}
+static void APIENTRY logRecti(GLint x1, GLint y1, GLint x2, GLint y2)
+{
+	SIG( "glRecti" );
+	dllRecti( x1, y1, x2, y2 );
+}
+static void APIENTRY logRectiv(const GLint *v1, const GLint *v2)
+{
+	SIG( "glRectiv" );
+	dllRectiv( v1, v2 );
+}
+static void APIENTRY logRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2)
+{
+	SIG( "glRects" );
+	dllRects( x1, y1, x2, y2 );
+}
+static void APIENTRY logRectsv(const GLshort *v1, const GLshort *v2)
+{
+	SIG( "glRectsv" );
+	dllRectsv( v1, v2 );
+}
+static GLint APIENTRY logRenderMode(GLenum mode)
+{
+	SIG( "glRenderMode" );
+	return dllRenderMode( mode );
+}
+static void APIENTRY logRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z)
+{
+	SIG( "glRotated" );
+	dllRotated( angle, x, y, z );
+}
+
+static void APIENTRY logRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
+{
+	SIG( "glRotatef" );
+	dllRotatef( angle, x, y, z );
+}
+
+static void APIENTRY logScaled(GLdouble x, GLdouble y, GLdouble z)
+{
+	SIG( "glScaled" );
+	dllScaled( x, y, z );
+}
+
+static void APIENTRY logScalef(GLfloat x, GLfloat y, GLfloat z)
+{
+	SIG( "glScalef" );
+	dllScalef( x, y, z );
+}
+
+static void APIENTRY logScissor(GLint x, GLint y, GLsizei width, GLsizei height)
+{
+	fprintf( glw_state.log_fp, "glScissor( %d, %d, %d, %d )\n", x, y, width, height );
+	dllScissor( x, y, width, height );
+}
+
+static void APIENTRY logSelectBuffer(GLsizei size, GLuint *buffer)
+{
+	SIG( "glSelectBuffer" );
+	dllSelectBuffer( size, buffer );
+}
+
+static void APIENTRY logShadeModel(GLenum mode)
+{
+	SIG( "glShadeModel" );
+	dllShadeModel( mode );
+}
+
+static void APIENTRY logStencilFunc(GLenum func, GLint ref, GLuint mask)
+{
+	SIG( "glStencilFunc" );
+	dllStencilFunc( func, ref, mask );
+}
+
+static void APIENTRY logStencilMask(GLuint mask)
+{
+	SIG( "glStencilMask" );
+	dllStencilMask( mask );
+}
+
+static void APIENTRY logStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
+{
+	SIG( "glStencilOp" );
+	dllStencilOp( fail, zfail, zpass );
+}
+
+static void APIENTRY logTexCoord1d(GLdouble s)
+{
+	SIG( "glTexCoord1d" );
+	dllTexCoord1d( s );
+}
+
+static void APIENTRY logTexCoord1dv(const GLdouble *v)
+{
+	SIG( "glTexCoord1dv" );
+	dllTexCoord1dv( v );
+}
+
+static void APIENTRY logTexCoord1f(GLfloat s)
+{
+	SIG( "glTexCoord1f" );
+	dllTexCoord1f( s );
+}
+static void APIENTRY logTexCoord1fv(const GLfloat *v)
+{
+	SIG( "glTexCoord1fv" );
+	dllTexCoord1fv( v );
+}
+static void APIENTRY logTexCoord1i(GLint s)
+{
+	SIG( "glTexCoord1i" );
+	dllTexCoord1i( s );
+}
+static void APIENTRY logTexCoord1iv(const GLint *v)
+{
+	SIG( "glTexCoord1iv" );
+	dllTexCoord1iv( v );
+}
+static void APIENTRY logTexCoord1s(GLshort s)
+{
+	SIG( "glTexCoord1s" );
+	dllTexCoord1s( s );
+}
+static void APIENTRY logTexCoord1sv(const GLshort *v)
+{
+	SIG( "glTexCoord1sv" );
+	dllTexCoord1sv( v );
+}
+static void APIENTRY logTexCoord2d(GLdouble s, GLdouble t)
+{
+	SIG( "glTexCoord2d" );
+	dllTexCoord2d( s, t );
+}
+
+static void APIENTRY logTexCoord2dv(const GLdouble *v)
+{
+	SIG( "glTexCoord2dv" );
+	dllTexCoord2dv( v );
+}
+static void APIENTRY logTexCoord2f(GLfloat s, GLfloat t)
+{
+	SIG( "glTexCoord2f" );
+	dllTexCoord2f( s, t );
+}
+static void APIENTRY logTexCoord2fv(const GLfloat *v)
+{
+	SIG( "glTexCoord2fv" );
+	dllTexCoord2fv( v );
+}
+static void APIENTRY logTexCoord2i(GLint s, GLint t)
+{
+	SIG( "glTexCoord2i" );
+	dllTexCoord2i( s, t );
+}
+static void APIENTRY logTexCoord2iv(const GLint *v)
+{
+	SIG( "glTexCoord2iv" );
+	dllTexCoord2iv( v );
+}
+static void APIENTRY logTexCoord2s(GLshort s, GLshort t)
+{
+	SIG( "glTexCoord2s" );
+	dllTexCoord2s( s, t );
+}
+static void APIENTRY logTexCoord2sv(const GLshort *v)
+{
+	SIG( "glTexCoord2sv" );
+	dllTexCoord2sv( v );
+}
+static void APIENTRY logTexCoord3d(GLdouble s, GLdouble t, GLdouble r)
+{
+	SIG( "glTexCoord3d" );
+	dllTexCoord3d( s, t, r );
+}
+static void APIENTRY logTexCoord3dv(const GLdouble *v)
+{
+	SIG( "glTexCoord3dv" );
+	dllTexCoord3dv( v );
+}
+static void APIENTRY logTexCoord3f(GLfloat s, GLfloat t, GLfloat r)
+{
+	SIG( "glTexCoord3f" );
+	dllTexCoord3f( s, t, r );
+}
+static void APIENTRY logTexCoord3fv(const GLfloat *v)
+{
+	SIG( "glTexCoord3fv" );
+	dllTexCoord3fv( v );
+}
+static void APIENTRY logTexCoord3i(GLint s, GLint t, GLint r)
+{
+	SIG( "glTexCoord3i" );
+	dllTexCoord3i( s, t, r );
+}
+static void APIENTRY logTexCoord3iv(const GLint *v)
+{
+	SIG( "glTexCoord3iv" );
+	dllTexCoord3iv( v );
+}
+static void APIENTRY logTexCoord3s(GLshort s, GLshort t, GLshort r)
+{
+	SIG( "glTexCoord3s" );
+	dllTexCoord3s( s, t, r );
+}
+static void APIENTRY logTexCoord3sv(const GLshort *v)
+{
+	SIG( "glTexCoord3sv" );
+	dllTexCoord3sv( v );
+}
+static void APIENTRY logTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q)
+{
+	SIG( "glTexCoord4d" );
+	dllTexCoord4d( s, t, r, q );
+}
+static void APIENTRY logTexCoord4dv(const GLdouble *v)
+{
+	SIG( "glTexCoord4dv" );
+	dllTexCoord4dv( v );
+}
+static void APIENTRY logTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q)
+{
+	SIG( "glTexCoord4f" );
+	dllTexCoord4f( s, t, r, q );
+}
+static void APIENTRY logTexCoord4fv(const GLfloat *v)
+{
+	SIG( "glTexCoord4fv" );
+	dllTexCoord4fv( v );
+}
+static void APIENTRY logTexCoord4i(GLint s, GLint t, GLint r, GLint q)
+{
+	SIG( "glTexCoord4i" );
+	dllTexCoord4i( s, t, r, q );
+}
+static void APIENTRY logTexCoord4iv(const GLint *v)
+{
+	SIG( "glTexCoord4iv" );
+	dllTexCoord4iv( v );
+}
+static void APIENTRY logTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q)
+{
+	SIG( "glTexCoord4s" );
+	dllTexCoord4s( s, t, r, q );
+}
+static void APIENTRY logTexCoord4sv(const GLshort *v)
+{
+	SIG( "glTexCoord4sv" );
+	dllTexCoord4sv( v );
+}
+static void APIENTRY logTexCoordPointer(GLint size, GLenum type, GLsizei stride, const void *pointer)
+{
+	fprintf( glw_state.log_fp, "glTexCoordPointer( %d, %s, %d, MEM )\n", size, TypeToString( type ), stride );
+	dllTexCoordPointer( size, type, stride, pointer );
+}
+
+static void APIENTRY logTexEnvf(GLenum target, GLenum pname, GLfloat param)
+{
+	fprintf( glw_state.log_fp, "glTexEnvf( 0x%x, 0x%x, %f )\n", target, pname, param );
+	dllTexEnvf( target, pname, param );
+}
+
+static void APIENTRY logTexEnvfv(GLenum target, GLenum pname, const GLfloat *params)
+{
+	SIG( "glTexEnvfv" );
+	dllTexEnvfv( target, pname, params );
+}
+
+static void APIENTRY logTexEnvi(GLenum target, GLenum pname, GLint param)
+{
+	fprintf( glw_state.log_fp, "glTexEnvi( 0x%x, 0x%x, 0x%x )\n", target, pname, param );
+	dllTexEnvi( target, pname, param );
+}
+static void APIENTRY logTexEnviv(GLenum target, GLenum pname, const GLint *params)
+{
+	SIG( "glTexEnviv" );
+	dllTexEnviv( target, pname, params );
+}
+
+static void APIENTRY logTexGend(GLenum coord, GLenum pname, GLdouble param)
+{
+	SIG( "glTexGend" );
+	dllTexGend( coord, pname, param );
+}
+
+static void APIENTRY logTexGendv(GLenum coord, GLenum pname, const GLdouble *params)
+{
+	SIG( "glTexGendv" );
+	dllTexGendv( coord, pname, params );
+}
+
+static void APIENTRY logTexGenf(GLenum coord, GLenum pname, GLfloat param)
+{
+	SIG( "glTexGenf" );
+	dllTexGenf( coord, pname, param );
+}
+static void APIENTRY logTexGenfv(GLenum coord, GLenum pname, const GLfloat *params)
+{
+	SIG( "glTexGenfv" );
+	dllTexGenfv( coord, pname, params );
+}
+static void APIENTRY logTexGeni(GLenum coord, GLenum pname, GLint param)
+{
+	SIG( "glTexGeni" );
+	dllTexGeni( coord, pname, param );
+}
+static void APIENTRY logTexGeniv(GLenum coord, GLenum pname, const GLint *params)
+{
+	SIG( "glTexGeniv" );
+	dllTexGeniv( coord, pname, params );
+}
+static void APIENTRY logTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void *pixels)
+{
+	SIG( "glTexImage1D" );
+	dllTexImage1D( target, level, internalformat, width, border, format, type, pixels );
+}
+static void APIENTRY logTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels)
+{
+	SIG( "glTexImage2D" );
+	dllTexImage2D( target, level, internalformat, width, height, border, format, type, pixels );
+}
+
+static void APIENTRY logTexParameterf(GLenum target, GLenum pname, GLfloat param)
+{
+	fprintf( glw_state.log_fp, "glTexParameterf( 0x%x, 0x%x, %f )\n", target, pname, param );
+	dllTexParameterf( target, pname, param );
+}
+
+static void APIENTRY logTexParameterfv(GLenum target, GLenum pname, const GLfloat *params)
+{
+	SIG( "glTexParameterfv" );
+	dllTexParameterfv( target, pname, params );
+}
+static void APIENTRY logTexParameteri(GLenum target, GLenum pname, GLint param)
+{
+	fprintf( glw_state.log_fp, "glTexParameteri( 0x%x, 0x%x, 0x%x )\n", target, pname, param );
+	dllTexParameteri( target, pname, param );
+}
+static void APIENTRY logTexParameteriv(GLenum target, GLenum pname, const GLint *params)
+{
+	SIG( "glTexParameteriv" );
+	dllTexParameteriv( target, pname, params );
+}
+static void APIENTRY logTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels)
+{
+	SIG( "glTexSubImage1D" );
+	dllTexSubImage1D( target, level, xoffset, width, format, type, pixels );
+}
+static void APIENTRY logTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels)
+{
+	SIG( "glTexSubImage2D" );
+	dllTexSubImage2D( target, level, xoffset, yoffset, width, height, format, type, pixels );
+}
+static void APIENTRY logTranslated(GLdouble x, GLdouble y, GLdouble z)
+{
+	SIG( "glTranslated" );
+	dllTranslated( x, y, z );
+}
+
+static void APIENTRY logTranslatef(GLfloat x, GLfloat y, GLfloat z)
+{
+	SIG( "glTranslatef" );
+	dllTranslatef( x, y, z );
+}
+
+static void APIENTRY logVertex2d(GLdouble x, GLdouble y)
+{
+	SIG( "glVertex2d" );
+	dllVertex2d( x, y );
+}
+
+static void APIENTRY logVertex2dv(const GLdouble *v)
+{
+	SIG( "glVertex2dv" );
+	dllVertex2dv( v );
+}
+static void APIENTRY logVertex2f(GLfloat x, GLfloat y)
+{
+	SIG( "glVertex2f" );
+	dllVertex2f( x, y );
+}
+static void APIENTRY logVertex2fv(const GLfloat *v)
+{
+	SIG( "glVertex2fv" );
+	dllVertex2fv( v );
+}
+static void APIENTRY logVertex2i(GLint x, GLint y)
+{
+	SIG( "glVertex2i" );
+	dllVertex2i( x, y );
+}
+static void APIENTRY logVertex2iv(const GLint *v)
+{
+	SIG( "glVertex2iv" );
+	dllVertex2iv( v );
+}
+static void APIENTRY logVertex2s(GLshort x, GLshort y)
+{
+	SIG( "glVertex2s" );
+	dllVertex2s( x, y );
+}
+static void APIENTRY logVertex2sv(const GLshort *v)
+{
+	SIG( "glVertex2sv" );
+	dllVertex2sv( v );
+}
+static void APIENTRY logVertex3d(GLdouble x, GLdouble y, GLdouble z)
+{
+	SIG( "glVertex3d" );
+	dllVertex3d( x, y, z );
+}
+static void APIENTRY logVertex3dv(const GLdouble *v)
+{
+	SIG( "glVertex3dv" );
+	dllVertex3dv( v );
+}
+static void APIENTRY logVertex3f(GLfloat x, GLfloat y, GLfloat z)
+{
+	SIG( "glVertex3f" );
+	dllVertex3f( x, y, z );
+}
+static void APIENTRY logVertex3fv(const GLfloat *v)
+{
+	SIG( "glVertex3fv" );
+	dllVertex3fv( v );
+}
+static void APIENTRY logVertex3i(GLint x, GLint y, GLint z)
+{
+	SIG( "glVertex3i" );
+	dllVertex3i( x, y, z );
+}
+static void APIENTRY logVertex3iv(const GLint *v)
+{
+	SIG( "glVertex3iv" );
+	dllVertex3iv( v );
+}
+static void APIENTRY logVertex3s(GLshort x, GLshort y, GLshort z)
+{
+	SIG( "glVertex3s" );
+	dllVertex3s( x, y, z );
+}
+static void APIENTRY logVertex3sv(const GLshort *v)
+{
+	SIG( "glVertex3sv" );
+	dllVertex3sv( v );
+}
+static void APIENTRY logVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
+{
+	SIG( "glVertex4d" );
+	dllVertex4d( x, y, z, w );
+}
+static void APIENTRY logVertex4dv(const GLdouble *v)
+{
+	SIG( "glVertex4dv" );
+	dllVertex4dv( v );
+}
+static void APIENTRY logVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
+{
+	SIG( "glVertex4f" );
+	dllVertex4f( x, y, z, w );
+}
+static void APIENTRY logVertex4fv(const GLfloat *v)
+{
+	SIG( "glVertex4fv" );
+	dllVertex4fv( v );
+}
+static void APIENTRY logVertex4i(GLint x, GLint y, GLint z, GLint w)
+{
+	SIG( "glVertex4i" );
+	dllVertex4i( x, y, z, w );
+}
+static void APIENTRY logVertex4iv(const GLint *v)
+{
+	SIG( "glVertex4iv" );
+	dllVertex4iv( v );
+}
+static void APIENTRY logVertex4s(GLshort x, GLshort y, GLshort z, GLshort w)
+{
+	SIG( "glVertex4s" );
+	dllVertex4s( x, y, z, w );
+}
+static void APIENTRY logVertex4sv(const GLshort *v)
+{
+	SIG( "glVertex4sv" );
+	dllVertex4sv( v );
+}
+static void APIENTRY logVertexPointer(GLint size, GLenum type, GLsizei stride, const void *pointer)
+{
+	fprintf( glw_state.log_fp, "glVertexPointer( %d, %s, %d, MEM )\n", size, TypeToString( type ), stride );
+	dllVertexPointer( size, type, stride, pointer );
+}
+static void APIENTRY logViewport(GLint x, GLint y, GLsizei width, GLsizei height)
+{
+	fprintf( glw_state.log_fp, "glViewport( %d, %d, %d, %d )\n", x, y, width, height );
+	dllViewport( x, y, width, height );
+}
+
+/*
+** QGL_Shutdown
+**
+** Unloads the specified DLL then nulls out all the proc pointers.  This
+** is only called during a hard shutdown of the OGL subsystem (e.g. vid_restart).
+*/
+void QGL_Shutdown( void )
+{
+//	Com_Printf ("...shutting down QGL\n" );
+
+	if ( glw_state.hinstOpenGL )
+	{
+//		Com_Printf ("...unloading OpenGL DLL\n" );
+		FreeLibrary( glw_state.hinstOpenGL );
+	}
+
+	glw_state.hinstOpenGL = NULL;
+
+	qglAccum                     = NULL;
+	qglAlphaFunc                 = NULL;
+	qglAreTexturesResident       = NULL;
+	qglArrayElement              = NULL;
+	qglBegin                     = NULL;
+	qglBindTexture               = NULL;
+	qglBitmap                    = NULL;
+	qglBlendFunc                 = NULL;
+	qglCallList                  = NULL;
+	qglCallLists                 = NULL;
+	qglClear                     = NULL;
+	qglClearAccum                = NULL;
+	qglClearColor                = NULL;
+	qglClearDepth                = NULL;
+	qglClearIndex                = NULL;
+	qglClearStencil              = NULL;
+	qglClipPlane                 = NULL;
+	qglColor3b                   = NULL;
+	qglColor3bv                  = NULL;
+	qglColor3d                   = NULL;
+	qglColor3dv                  = NULL;
+	qglColor3f                   = NULL;
+	qglColor3fv                  = NULL;
+	qglColor3i                   = NULL;
+	qglColor3iv                  = NULL;
+	qglColor3s                   = NULL;
+	qglColor3sv                  = NULL;
+	qglColor3ub                  = NULL;
+	qglColor3ubv                 = NULL;
+	qglColor3ui                  = NULL;
+	qglColor3uiv                 = NULL;
+	qglColor3us                  = NULL;
+	qglColor3usv                 = NULL;
+	qglColor4b                   = NULL;
+	qglColor4bv                  = NULL;
+	qglColor4d                   = NULL;
+	qglColor4dv                  = NULL;
+	qglColor4f                   = NULL;
+	qglColor4fv                  = NULL;
+	qglColor4i                   = NULL;
+	qglColor4iv                  = NULL;
+	qglColor4s                   = NULL;
+	qglColor4sv                  = NULL;
+	qglColor4ub                  = NULL;
+	qglColor4ubv                 = NULL;
+	qglColor4ui                  = NULL;
+	qglColor4uiv                 = NULL;
+	qglColor4us                  = NULL;
+	qglColor4usv                 = NULL;
+	qglColorMask                 = NULL;
+	qglColorMaterial             = NULL;
+	qglColorPointer              = NULL;
+	qglCopyPixels                = NULL;
+	qglCopyTexImage1D            = NULL;
+	qglCopyTexImage2D            = NULL;
+	qglCopyTexSubImage1D         = NULL;
+	qglCopyTexSubImage2D         = NULL;
+	qglCullFace                  = NULL;
+	qglDeleteLists               = NULL;
+	qglDeleteTextures            = NULL;
+	qglDepthFunc                 = NULL;
+	qglDepthMask                 = NULL;
+	qglDepthRange                = NULL;
+	qglDisable                   = NULL;
+	qglDisableClientState        = NULL;
+	qglDrawArrays                = NULL;
+	qglDrawBuffer                = NULL;
+	qglDrawElements              = NULL;
+	qglDrawPixels                = NULL;
+	qglEdgeFlag                  = NULL;
+	qglEdgeFlagPointer           = NULL;
+	qglEdgeFlagv                 = NULL;
+	qglEnable                    = NULL;
+	qglEnableClientState         = NULL;
+	qglEnd                       = NULL;
+	qglEndList                   = NULL;
+	qglEvalCoord1d               = NULL;
+	qglEvalCoord1dv              = NULL;
+	qglEvalCoord1f               = NULL;
+	qglEvalCoord1fv              = NULL;
+	qglEvalCoord2d               = NULL;
+	qglEvalCoord2dv              = NULL;
+	qglEvalCoord2f               = NULL;
+	qglEvalCoord2fv              = NULL;
+	qglEvalMesh1                 = NULL;
+	qglEvalMesh2                 = NULL;
+	qglEvalPoint1                = NULL;
+	qglEvalPoint2                = NULL;
+	qglFeedbackBuffer            = NULL;
+	qglFinish                    = NULL;
+	qglFlush                     = NULL;
+	qglFogf                      = NULL;
+	qglFogfv                     = NULL;
+	qglFogi                      = NULL;
+	qglFogiv                     = NULL;
+	qglFrontFace                 = NULL;
+	qglFrustum                   = NULL;
+	qglGenLists                  = NULL;
+	qglGenTextures               = NULL;
+	qglGetBooleanv               = NULL;
+	qglGetClipPlane              = NULL;
+	qglGetDoublev                = NULL;
+	qglGetError                  = NULL;
+	qglGetFloatv                 = NULL;
+	qglGetIntegerv               = NULL;
+	qglGetLightfv                = NULL;
+	qglGetLightiv                = NULL;
+	qglGetMapdv                  = NULL;
+	qglGetMapfv                  = NULL;
+	qglGetMapiv                  = NULL;
+	qglGetMaterialfv             = NULL;
+	qglGetMaterialiv             = NULL;
+	qglGetPixelMapfv             = NULL;
+	qglGetPixelMapuiv            = NULL;
+	qglGetPixelMapusv            = NULL;
+	qglGetPointerv               = NULL;
+	qglGetPolygonStipple         = NULL;
+	qglGetString                 = NULL;
+	qglGetTexEnvfv               = NULL;
+	qglGetTexEnviv               = NULL;
+	qglGetTexGendv               = NULL;
+	qglGetTexGenfv               = NULL;
+	qglGetTexGeniv               = NULL;
+	qglGetTexImage               = NULL;
+	qglGetTexLevelParameterfv    = NULL;
+	qglGetTexLevelParameteriv    = NULL;
+	qglGetTexParameterfv         = NULL;
+	qglGetTexParameteriv         = NULL;
+	qglHint                      = NULL;
+	qglIndexMask                 = NULL;
+	qglIndexPointer              = NULL;
+	qglIndexd                    = NULL;
+	qglIndexdv                   = NULL;
+	qglIndexf                    = NULL;
+	qglIndexfv                   = NULL;
+	qglIndexi                    = NULL;
+	qglIndexiv                   = NULL;
+	qglIndexs                    = NULL;
+	qglIndexsv                   = NULL;
+	qglIndexub                   = NULL;
+	qglIndexubv                  = NULL;
+	qglInitNames                 = NULL;
+	qglInterleavedArrays         = NULL;
+	qglIsEnabled                 = NULL;
+	qglIsList                    = NULL;
+	qglIsTexture                 = NULL;
+	qglLightModelf               = NULL;
+	qglLightModelfv              = NULL;
+	qglLightModeli               = NULL;
+	qglLightModeliv              = NULL;
+	qglLightf                    = NULL;
+	qglLightfv                   = NULL;
+	qglLighti                    = NULL;
+	qglLightiv                   = NULL;
+	qglLineStipple               = NULL;
+	qglLineWidth                 = NULL;
+	qglListBase                  = NULL;
+	qglLoadIdentity              = NULL;
+	qglLoadMatrixd               = NULL;
+	qglLoadMatrixf               = NULL;
+	qglLoadName                  = NULL;
+	qglLogicOp                   = NULL;
+	qglMap1d                     = NULL;
+	qglMap1f                     = NULL;
+	qglMap2d                     = NULL;
+	qglMap2f                     = NULL;
+	qglMapGrid1d                 = NULL;
+	qglMapGrid1f                 = NULL;
+	qglMapGrid2d                 = NULL;
+	qglMapGrid2f                 = NULL;
+	qglMaterialf                 = NULL;
+	qglMaterialfv                = NULL;
+	qglMateriali                 = NULL;
+	qglMaterialiv                = NULL;
+	qglMatrixMode                = NULL;
+	qglMultMatrixd               = NULL;
+	qglMultMatrixf               = NULL;
+	qglNewList                   = NULL;
+	qglNormal3b                  = NULL;
+	qglNormal3bv                 = NULL;
+	qglNormal3d                  = NULL;
+	qglNormal3dv                 = NULL;
+	qglNormal3f                  = NULL;
+	qglNormal3fv                 = NULL;
+	qglNormal3i                  = NULL;
+	qglNormal3iv                 = NULL;
+	qglNormal3s                  = NULL;
+	qglNormal3sv                 = NULL;
+	qglNormalPointer             = NULL;
+	qglOrtho                     = NULL;
+	qglPassThrough               = NULL;
+	qglPixelMapfv                = NULL;
+	qglPixelMapuiv               = NULL;
+	qglPixelMapusv               = NULL;
+	qglPixelStoref               = NULL;
+	qglPixelStorei               = NULL;
+	qglPixelTransferf            = NULL;
+	qglPixelTransferi            = NULL;
+	qglPixelZoom                 = NULL;
+	qglPointSize                 = NULL;
+	qglPolygonMode               = NULL;
+	qglPolygonOffset             = NULL;
+	qglPolygonStipple            = NULL;
+	qglPopAttrib                 = NULL;
+	qglPopClientAttrib           = NULL;
+	qglPopMatrix                 = NULL;
+	qglPopName                   = NULL;
+	qglPrioritizeTextures        = NULL;
+	qglPushAttrib                = NULL;
+	qglPushClientAttrib          = NULL;
+	qglPushMatrix                = NULL;
+	qglPushName                  = NULL;
+	qglRasterPos2d               = NULL;
+	qglRasterPos2dv              = NULL;
+	qglRasterPos2f               = NULL;
+	qglRasterPos2fv              = NULL;
+	qglRasterPos2i               = NULL;
+	qglRasterPos2iv              = NULL;
+	qglRasterPos2s               = NULL;
+	qglRasterPos2sv              = NULL;
+	qglRasterPos3d               = NULL;
+	qglRasterPos3dv              = NULL;
+	qglRasterPos3f               = NULL;
+	qglRasterPos3fv              = NULL;
+	qglRasterPos3i               = NULL;
+	qglRasterPos3iv              = NULL;
+	qglRasterPos3s               = NULL;
+	qglRasterPos3sv              = NULL;
+	qglRasterPos4d               = NULL;
+	qglRasterPos4dv              = NULL;
+	qglRasterPos4f               = NULL;
+	qglRasterPos4fv              = NULL;
+	qglRasterPos4i               = NULL;
+	qglRasterPos4iv              = NULL;
+	qglRasterPos4s               = NULL;
+	qglRasterPos4sv              = NULL;
+	qglReadBuffer                = NULL;
+	qglReadPixels                = NULL;
+	qglRectd                     = NULL;
+	qglRectdv                    = NULL;
+	qglRectf                     = NULL;
+	qglRectfv                    = NULL;
+	qglRecti                     = NULL;
+	qglRectiv                    = NULL;
+	qglRects                     = NULL;
+	qglRectsv                    = NULL;
+	qglRenderMode                = NULL;
+	qglRotated                   = NULL;
+	qglRotatef                   = NULL;
+	qglScaled                    = NULL;
+	qglScalef                    = NULL;
+	qglScissor                   = NULL;
+	qglSelectBuffer              = NULL;
+	qglShadeModel                = NULL;
+	qglStencilFunc               = NULL;
+	qglStencilMask               = NULL;
+	qglStencilOp                 = NULL;
+	qglTexCoord1d                = NULL;
+	qglTexCoord1dv               = NULL;
+	qglTexCoord1f                = NULL;
+	qglTexCoord1fv               = NULL;
+	qglTexCoord1i                = NULL;
+	qglTexCoord1iv               = NULL;
+	qglTexCoord1s                = NULL;
+	qglTexCoord1sv               = NULL;
+	qglTexCoord2d                = NULL;
+	qglTexCoord2dv               = NULL;
+	qglTexCoord2f                = NULL;
+	qglTexCoord2fv               = NULL;
+	qglTexCoord2i                = NULL;
+	qglTexCoord2iv               = NULL;
+	qglTexCoord2s                = NULL;
+	qglTexCoord2sv               = NULL;
+	qglTexCoord3d                = NULL;
+	qglTexCoord3dv               = NULL;
+	qglTexCoord3f                = NULL;
+	qglTexCoord3fv               = NULL;
+	qglTexCoord3i                = NULL;
+	qglTexCoord3iv               = NULL;
+	qglTexCoord3s                = NULL;
+	qglTexCoord3sv               = NULL;
+	qglTexCoord4d                = NULL;
+	qglTexCoord4dv               = NULL;
+	qglTexCoord4f                = NULL;
+	qglTexCoord4fv               = NULL;
+	qglTexCoord4i                = NULL;
+	qglTexCoord4iv               = NULL;
+	qglTexCoord4s                = NULL;
+	qglTexCoord4sv               = NULL;
+	qglTexCoordPointer           = NULL;
+	qglTexEnvf                   = NULL;
+	qglTexEnvfv                  = NULL;
+	qglTexEnvi                   = NULL;
+	qglTexEnviv                  = NULL;
+	qglTexGend                   = NULL;
+	qglTexGendv                  = NULL;
+	qglTexGenf                   = NULL;
+	qglTexGenfv                  = NULL;
+	qglTexGeni                   = NULL;
+	qglTexGeniv                  = NULL;
+	qglTexImage1D                = NULL;
+	qglTexImage2D                = NULL;
+	qglTexParameterf             = NULL;
+	qglTexParameterfv            = NULL;
+	qglTexParameteri             = NULL;
+	qglTexParameteriv            = NULL;
+	qglTexSubImage1D             = NULL;
+	qglTexSubImage2D             = NULL;
+	qglTranslated                = NULL;
+	qglTranslatef                = NULL;
+	qglVertex2d                  = NULL;
+	qglVertex2dv                 = NULL;
+	qglVertex2f                  = NULL;
+	qglVertex2fv                 = NULL;
+	qglVertex2i                  = NULL;
+	qglVertex2iv                 = NULL;
+	qglVertex2s                  = NULL;
+	qglVertex2sv                 = NULL;
+	qglVertex3d                  = NULL;
+	qglVertex3dv                 = NULL;
+	qglVertex3f                  = NULL;
+	qglVertex3fv                 = NULL;
+	qglVertex3i                  = NULL;
+	qglVertex3iv                 = NULL;
+	qglVertex3s                  = NULL;
+	qglVertex3sv                 = NULL;
+	qglVertex4d                  = NULL;
+	qglVertex4dv                 = NULL;
+	qglVertex4f                  = NULL;
+	qglVertex4fv                 = NULL;
+	qglVertex4i                  = NULL;
+	qglVertex4iv                 = NULL;
+	qglVertex4s                  = NULL;
+	qglVertex4sv                 = NULL;
+	qglVertexPointer             = NULL;
+	qglViewport                  = NULL;
+
+	qwglCopyContext              = NULL;
+	qwglCreateContext            = NULL;
+	qwglCreateLayerContext       = NULL;
+	qwglDeleteContext            = NULL;
+	qwglDescribeLayerPlane       = NULL;
+	qwglGetCurrentContext        = NULL;
+	qwglGetCurrentDC             = NULL;
+	qwglGetLayerPaletteEntries   = NULL;
+	qwglGetProcAddress           = NULL;
+	qwglMakeCurrent              = NULL;
+	qwglRealizeLayerPalette      = NULL;
+	qwglSetLayerPaletteEntries   = NULL;
+	qwglShareLists               = NULL;
+	qwglSwapLayerBuffers         = NULL;
+	qwglUseFontBitmaps           = NULL;
+	qwglUseFontOutlines          = NULL;
+}
+
+#	pragma warning (disable : 4113 4133 4047 )
+#	define GPA( a ) GetProcAddress( glw_state.hinstOpenGL, a )
+
+/*
+** QGL_Init
+**
+** This is responsible for binding our qgl function pointers to 
+** the appropriate GL stuff.  In Windows this means doing a 
+** LoadLibrary and a bunch of calls to GetProcAddress.  On other
+** operating systems we need to do the right thing, whatever that
+** might be.
+*/
+qboolean QGL_Init( const char *dllname )
+{
+	assert( glw_state.hinstOpenGL == 0 );
+
+	Com_Printf ("...initializing QGL\n" );
+
+//	Com_Printf ("...calling LoadLibrary( '%s.dll' ): ", dllname );
+
+	if ( ( glw_state.hinstOpenGL = LoadLibraryEx( dllname, 0, 0 ) ) == 0 )
+	{
+	    DWORD dw = GetLastError();
+		Com_Printf ("failed %u\n", dw );
+		return qfalse;
+	}
+	Com_Printf ("succeeded\n" );
+
+	qglAccum                     = dllAccum = (void (__stdcall *)(unsigned int,float))GPA( "glAccum" );
+	qglAlphaFunc                 = dllAlphaFunc = (void (__stdcall *)(unsigned int,float))GPA( "glAlphaFunc" );
+	qglAreTexturesResident       = dllAreTexturesResident = (unsigned char (__stdcall *)(int,const unsigned int *,unsigned char *))GPA( "glAreTexturesResident" );
+	qglArrayElement              = dllArrayElement = (void (__stdcall *)(int))GPA( "glArrayElement" );
+	qglBegin                     = dllBegin = (void (__stdcall *)(unsigned int))GPA( "glBegin" );
+	qglBindTexture               = dllBindTexture = (void (__stdcall *)(unsigned int,unsigned int))GPA( "glBindTexture" );
+	qglBitmap                    = dllBitmap = (void (__stdcall *)(int,int,float,float,float,float,const unsigned char *))GPA( "glBitmap" );
+	qglBlendFunc                 = dllBlendFunc = (void (__stdcall *)(unsigned int,unsigned int))GPA( "glBlendFunc" );
+	qglCallList                  = dllCallList = (void (__stdcall *)(unsigned int))GPA( "glCallList" );
+	qglCallLists                 = dllCallLists = (void (__stdcall *)(int,unsigned int,const void *))GPA( "glCallLists" );
+	qglClear                     = dllClear = (void (__stdcall *)(unsigned int))GPA( "glClear" );
+	qglClearAccum                = dllClearAccum = (void (__stdcall *)(float,float,float,float))GPA( "glClearAccum" );
+	qglClearColor                = dllClearColor = (void (__stdcall *)(float,float,float,float))GPA( "glClearColor" );
+	qglClearDepth                = dllClearDepth = (void (__stdcall *)(double))GPA( "glClearDepth" );
+	qglClearIndex                = dllClearIndex = (void (__stdcall *)(float))GPA( "glClearIndex" );
+	qglClearStencil              = dllClearStencil = (void (__stdcall *)(int))GPA( "glClearStencil" );
+	qglClipPlane                 = dllClipPlane = (void (__stdcall *)(unsigned int,const double *))GPA( "glClipPlane" );
+	qglColor3b                   = dllColor3b = (void (__stdcall *)(signed char,signed char,signed char))GPA( "glColor3b" );
+	qglColor3bv                  = dllColor3bv = (void (__stdcall *)(const signed char *))GPA( "glColor3bv" );
+	qglColor3d                   = dllColor3d = (void (__stdcall *)(double,double,double))GPA( "glColor3d" );
+	qglColor3dv                  = dllColor3dv = (void (__stdcall *)(const double *))GPA( "glColor3dv" );
+	qglColor3f                   = dllColor3f = (void (__stdcall *)(float,float,float))GPA( "glColor3f" );
+	qglColor3fv                  = dllColor3fv = (void (__stdcall *)(const float *))GPA( "glColor3fv" );
+	qglColor3i                   = dllColor3i = (void (__stdcall *)(int,int,int))GPA( "glColor3i" );
+	qglColor3iv                  = dllColor3iv = (void (__stdcall *)(const int *))GPA( "glColor3iv" );
+	qglColor3s                   = dllColor3s = (void (__stdcall *)(short,short,short))GPA( "glColor3s" );
+	qglColor3sv                  = dllColor3sv = (void (__stdcall *)(const short *))GPA( "glColor3sv" );
+	qglColor3ub                  = dllColor3ub = (void (__stdcall *)(unsigned char,unsigned char,unsigned char))GPA( "glColor3ub" );
+	qglColor3ubv                 = dllColor3ubv = (void (__stdcall *)(const unsigned char *))GPA( "glColor3ubv" );
+	qglColor3ui                  = dllColor3ui = (void (__stdcall *)(unsigned int,unsigned int,unsigned int))GPA( "glColor3ui" );
+	qglColor3uiv                 = dllColor3uiv = (void (__stdcall *)(const unsigned int *))GPA( "glColor3uiv" );
+	qglColor3us                  = dllColor3us = (void (__stdcall *)(unsigned short,unsigned short,unsigned short))GPA( "glColor3us" );
+	qglColor3usv                 = dllColor3usv = (void (__stdcall *)(const unsigned short *))GPA( "glColor3usv" );
+	qglColor4b                   = dllColor4b = (void (__stdcall *)(signed char,signed char,signed char,signed char))GPA( "glColor4b" );
+	qglColor4bv                  = dllColor4bv = (void (__stdcall *)(const signed char *))GPA( "glColor4bv" );
+	qglColor4d                   = dllColor4d = (void (__stdcall *)(double,double,double,double))GPA( "glColor4d" );
+	qglColor4dv                  = dllColor4dv = (void (__stdcall *)(const double *))GPA( "glColor4dv" );
+	qglColor4f                   = dllColor4f = (void (__stdcall *)(float,float,float,float))GPA( "glColor4f" );
+	qglColor4fv                  = dllColor4fv = (void (__stdcall *)(const float *))GPA( "glColor4fv" );
+	qglColor4i                   = dllColor4i = (void (__stdcall *)(int,int,int,int))GPA( "glColor4i" );
+	qglColor4iv                  = dllColor4iv = (void (__stdcall *)(const int *))GPA( "glColor4iv" );
+	qglColor4s                   = dllColor4s = (void (__stdcall *)(short,short,short,short))GPA( "glColor4s" );
+	qglColor4sv                  = dllColor4sv = (void (__stdcall *)(const short *))GPA( "glColor4sv" );
+	qglColor4ub                  = dllColor4ub = (void (__stdcall *)(unsigned char,unsigned char,unsigned char,unsigned char))GPA( "glColor4ub" );
+	qglColor4ubv                 = dllColor4ubv = (void (__stdcall *)(const unsigned char *))GPA( "glColor4ubv" );
+	qglColor4ui                  = dllColor4ui = (void (__stdcall *)(unsigned int,unsigned int,unsigned int,unsigned int))GPA( "glColor4ui" );
+	qglColor4uiv                 = dllColor4uiv = (void (__stdcall *)(const unsigned int *))GPA( "glColor4uiv" );
+	qglColor4us                  = dllColor4us = (void (__stdcall *)(unsigned short,unsigned short,unsigned short,unsigned short))GPA( "glColor4us" );
+	qglColor4usv                 = dllColor4usv = (void (__stdcall *)(const unsigned short *))GPA( "glColor4usv" );
+	qglColorMask                 = dllColorMask = (void (__stdcall *)(unsigned char,unsigned char,unsigned char,unsigned char))GPA( "glColorMask" );
+	qglColorMaterial             = dllColorMaterial = (void (__stdcall *)(unsigned int,unsigned int))GPA( "glColorMaterial" );
+	qglColorPointer              = dllColorPointer = (void (__stdcall *)(int,unsigned int,int,const void *))GPA( "glColorPointer" );
+	qglCopyPixels                = dllCopyPixels = (void (__stdcall *)(int,int,int,int,unsigned int))GPA( "glCopyPixels" );
+	qglCopyTexImage1D            = dllCopyTexImage1D = (void (__stdcall *)(unsigned int,int,unsigned int,int,int,int,int))GPA( "glCopyTexImage1D" );
+	qglCopyTexImage2D            = dllCopyTexImage2D = (void (__stdcall *)(unsigned int,int,unsigned int,int,int,int,int,int))GPA( "glCopyTexImage2D" );
+	qglCopyTexSubImage1D         = dllCopyTexSubImage1D = (void (__stdcall *)(unsigned int,int,int,int,int,int))GPA( "glCopyTexSubImage1D" );
+	qglCopyTexSubImage2D         = dllCopyTexSubImage2D = (void (__stdcall *)(unsigned int,int,int,int,int,int,int,int))GPA( "glCopyTexSubImage2D" );
+	qglCullFace                  = dllCullFace = (void (__stdcall *)(unsigned int))GPA( "glCullFace" );
+	qglDeleteLists               = dllDeleteLists = (void (__stdcall *)(unsigned int,int))GPA( "glDeleteLists" );
+	qglDeleteTextures            = dllDeleteTextures = (void (__stdcall *)(int,const unsigned int *))GPA( "glDeleteTextures" );
+	qglDepthFunc                 = dllDepthFunc = (void (__stdcall *)(unsigned int))GPA( "glDepthFunc" );
+	qglDepthMask                 = dllDepthMask = (void (__stdcall *)(unsigned char))GPA( "glDepthMask" );
+	qglDepthRange                = dllDepthRange = (void (__stdcall *)(double,double))GPA( "glDepthRange" );
+	qglDisable                   = dllDisable = (void (__stdcall *)(unsigned int))GPA( "glDisable" );
+	qglDisableClientState        = dllDisableClientState = (void (__stdcall *)(unsigned int))GPA( "glDisableClientState" );
+	qglDrawArrays                = dllDrawArrays = (void (__stdcall *)(unsigned int,int,int))GPA( "glDrawArrays" );
+	qglDrawBuffer                = dllDrawBuffer = (void (__stdcall *)(unsigned int))GPA( "glDrawBuffer" );
+	qglDrawElements              = dllDrawElements = (void (__stdcall *)(unsigned int,int,unsigned int,const void *))GPA( "glDrawElements" );
+	qglDrawPixels                = dllDrawPixels = (void (__stdcall *)(int,int,unsigned int,unsigned int,const void *))GPA( "glDrawPixels" );
+	qglEdgeFlag                  = dllEdgeFlag = (void (__stdcall *)(unsigned char))GPA( "glEdgeFlag" );
+	qglEdgeFlagPointer           = dllEdgeFlagPointer = (void (__stdcall *)(int,const void *))GPA( "glEdgeFlagPointer" );
+	qglEdgeFlagv                 = dllEdgeFlagv = (void (__stdcall *)(const unsigned char *))GPA( "glEdgeFlagv" );
+	qglEnable                    = 	dllEnable                    = (void (__stdcall *)(unsigned int))GPA( "glEnable" );
+	qglEnableClientState         = 	dllEnableClientState         = (void (__stdcall *)(unsigned int))GPA( "glEnableClientState" );
+	qglEnd                       = 	dllEnd                       = (void (__stdcall *)(void))GPA( "glEnd" );
+	qglEndList                   = 	dllEndList                   = (void (__stdcall *)(void))GPA( "glEndList" );
+	qglEvalCoord1d				 = 	dllEvalCoord1d				 = (void (__stdcall *)(double))GPA( "glEvalCoord1d" );
+	qglEvalCoord1dv              = 	dllEvalCoord1dv              = (void (__stdcall *)(const double *))GPA( "glEvalCoord1dv" );
+	qglEvalCoord1f               = 	dllEvalCoord1f               = (void (__stdcall *)(float))GPA( "glEvalCoord1f" );
+	qglEvalCoord1fv              = 	dllEvalCoord1fv              = (void (__stdcall *)(const float *))GPA( "glEvalCoord1fv" );
+	qglEvalCoord2d               = 	dllEvalCoord2d               = (void (__stdcall *)(double,double))GPA( "glEvalCoord2d" );
+	qglEvalCoord2dv              = 	dllEvalCoord2dv              = (void (__stdcall *)(const double *))GPA( "glEvalCoord2dv" );
+	qglEvalCoord2f               = 	dllEvalCoord2f               = (void (__stdcall *)(float,float))GPA( "glEvalCoord2f" );
+	qglEvalCoord2fv              = 	dllEvalCoord2fv              = (void (__stdcall *)(const float *))GPA( "glEvalCoord2fv" );
+	qglEvalMesh1                 = 	dllEvalMesh1                 = (void (__stdcall *)(unsigned int,int,int))GPA( "glEvalMesh1" );
+	qglEvalMesh2                 = 	dllEvalMesh2                 = (void (__stdcall *)(unsigned int,int,int,int,int))GPA( "glEvalMesh2" );
+	qglEvalPoint1                = 	dllEvalPoint1                = (void (__stdcall *)(int))GPA( "glEvalPoint1" );
+	qglEvalPoint2                = 	dllEvalPoint2                = (void (__stdcall *)(int,int))GPA( "glEvalPoint2" );
+	qglFeedbackBuffer            = 	dllFeedbackBuffer            = (void (__stdcall *)(int,unsigned int,float *))GPA( "glFeedbackBuffer" );
+	qglFinish                    = 	dllFinish                    = (void (__stdcall *)(void))GPA( "glFinish" );
+	qglFlush                     = 	dllFlush                     = (void (__stdcall *)(void))GPA( "glFlush" );
+	qglFogf                      = 	dllFogf                      = (void (__stdcall *)(unsigned int,float))GPA( "glFogf" );
+	qglFogfv                     = 	dllFogfv                     = (void (__stdcall *)(unsigned int,const float *))GPA( "glFogfv" );
+	qglFogi                      = 	dllFogi                      = (void (__stdcall *)(unsigned int,int))GPA( "glFogi" );
+	qglFogiv                     = 	dllFogiv                     = (void (__stdcall *)(unsigned int,const int *))GPA( "glFogiv" );
+	qglFrontFace                 = 	dllFrontFace                 = (void (__stdcall *)(unsigned int))GPA( "glFrontFace" );
+	qglFrustum                   = 	dllFrustum                   = (void (__stdcall *)(double,double,double,double,double,double))GPA( "glFrustum" );
+	qglGenLists                  = 	dllGenLists                  = ( GLuint (__stdcall * )(int) ) GPA( "glGenLists" );
+	qglGenTextures               = 	dllGenTextures               = (void (__stdcall *)(int,unsigned int *))GPA( "glGenTextures" );
+	qglGetBooleanv               = 	dllGetBooleanv               = (void (__stdcall *)(unsigned int,unsigned char *))GPA( "glGetBooleanv" );
+	qglGetClipPlane              = 	dllGetClipPlane              = (void (__stdcall *)(unsigned int,double *))GPA( "glGetClipPlane" );
+	qglGetDoublev                = 	dllGetDoublev                = (void (__stdcall *)(unsigned int,double *))GPA( "glGetDoublev" );
+	qglGetError                  = 	dllGetError                  = ( GLenum (__stdcall * )(void) ) GPA( "glGetError" );
+	qglGetFloatv                 = 	dllGetFloatv                 = (void (__stdcall *)(unsigned int,float *))GPA( "glGetFloatv" );
+	qglGetIntegerv               = 	dllGetIntegerv               = (void (__stdcall *)(unsigned int,int *))GPA( "glGetIntegerv" );
+	qglGetLightfv                = 	dllGetLightfv                = (void (__stdcall *)(unsigned int,unsigned int,float *))GPA( "glGetLightfv" );
+	qglGetLightiv                = 	dllGetLightiv                = (void (__stdcall *)(unsigned int,unsigned int,int *))GPA( "glGetLightiv" );
+	qglGetMapdv                  = 	dllGetMapdv                  = (void (__stdcall *)(unsigned int,unsigned int,double *))GPA( "glGetMapdv" );
+	qglGetMapfv                  = 	dllGetMapfv                  = (void (__stdcall *)(unsigned int,unsigned int,float *))GPA( "glGetMapfv" );
+	qglGetMapiv                  = 	dllGetMapiv                  = (void (__stdcall *)(unsigned int,unsigned int,int *))GPA( "glGetMapiv" );
+	qglGetMaterialfv             = 	dllGetMaterialfv             = (void (__stdcall *)(unsigned int,unsigned int,float *))GPA( "glGetMaterialfv" );
+	qglGetMaterialiv             = 	dllGetMaterialiv             = (void (__stdcall *)(unsigned int,unsigned int,int *))GPA( "glGetMaterialiv" );
+	qglGetPixelMapfv             = 	dllGetPixelMapfv             = (void (__stdcall *)(unsigned int,float *))GPA( "glGetPixelMapfv" );
+	qglGetPixelMapuiv            = 	dllGetPixelMapuiv            = (void (__stdcall *)(unsigned int,unsigned int *))GPA( "glGetPixelMapuiv" );
+	qglGetPixelMapusv            = 	dllGetPixelMapusv            = (void (__stdcall *)(unsigned int,unsigned short *))GPA( "glGetPixelMapusv" );
+	qglGetPointerv               = 	dllGetPointerv               = (void (__stdcall *)(unsigned int,void ** ))GPA( "glGetPointerv" );
+	qglGetPolygonStipple         = 	dllGetPolygonStipple         = (void (__stdcall *)(unsigned char *))GPA( "glGetPolygonStipple" );
+	qglGetString                 = 	dllGetString                 = (const unsigned char *(__stdcall *)(unsigned int))GPA( "glGetString" );
+	qglGetTexEnvfv               = 	dllGetTexEnvfv               = (void (__stdcall *)(unsigned int,unsigned int,float *))GPA( "glGetTexEnvfv" );
+	qglGetTexEnviv               = 	dllGetTexEnviv               = (void (__stdcall *)(unsigned int,unsigned int,int *))GPA( "glGetTexEnviv" );
+	qglGetTexGendv               = 	dllGetTexGendv               = (void (__stdcall *)(unsigned int,unsigned int,double *))GPA( "glGetTexGendv" );
+	qglGetTexGenfv               = 	dllGetTexGenfv               = (void (__stdcall *)(unsigned int,unsigned int,float *))GPA( "glGetTexGenfv" );
+	qglGetTexGeniv               = 	dllGetTexGeniv               = (void (__stdcall *)(unsigned int,unsigned int,int *))GPA( "glGetTexGeniv" );
+	qglGetTexImage               = 	dllGetTexImage               = (void (__stdcall *)(unsigned int,int,unsigned int,unsigned int,void *))GPA( "glGetTexImage" );
+	qglGetTexParameterfv         = 	dllGetTexParameterfv         = (void (__stdcall *)(unsigned int,unsigned int,float *))GPA( "glGetTexParameterfv" );
+	qglGetTexParameteriv         = 	dllGetTexParameteriv         = (void (__stdcall *)(unsigned int,unsigned int,int *))GPA( "glGetTexParameteriv" );
+	qglHint                      = 	dllHint                      = (void (__stdcall *)(unsigned int,unsigned int))GPA( "glHint" );
+	qglIndexMask                 = 	dllIndexMask                 = (void (__stdcall *)(unsigned int))GPA( "glIndexMask" );
+	qglIndexPointer              = 	dllIndexPointer              = (void (__stdcall *)(unsigned int,int,const void *))GPA( "glIndexPointer" );
+	qglIndexd                    = 	dllIndexd                    = (void (__stdcall *)(double))GPA( "glIndexd" );
+	qglIndexdv                   = 	dllIndexdv                   = (void (__stdcall *)(const double *))GPA( "glIndexdv" );
+	qglIndexf                    = 	dllIndexf                    = (void (__stdcall *)(float))GPA( "glIndexf" );
+	qglIndexfv                   = 	dllIndexfv                   = (void (__stdcall *)(const float *))GPA( "glIndexfv" );
+	qglIndexi                    = 	dllIndexi                    = (void (__stdcall *)(int))GPA( "glIndexi" );
+	qglIndexiv                   = 	dllIndexiv                   = (void (__stdcall *)(const int *))GPA( "glIndexiv" );
+	qglIndexs                    = 	dllIndexs                    = (void (__stdcall *)(short))GPA( "glIndexs" );
+	qglIndexsv                   = 	dllIndexsv                   = (void (__stdcall *)(const short *))GPA( "glIndexsv" );
+	qglIndexub                   = 	dllIndexub                   = (void (__stdcall *)(unsigned char))GPA( "glIndexub" );
+	qglIndexubv                  = 	dllIndexubv                  = (void (__stdcall *)(const unsigned char *))GPA( "glIndexubv" );
+	qglInitNames                 = 	dllInitNames                 = (void (__stdcall *)(void))GPA( "glInitNames" );
+	qglInterleavedArrays         = 	dllInterleavedArrays         = (void (__stdcall *)(unsigned int,int,const void *))GPA( "glInterleavedArrays" );
+	qglIsEnabled                 = 	dllIsEnabled                 = (unsigned char (__stdcall *)(unsigned int))GPA( "glIsEnabled" );
+	qglIsList                    = 	dllIsList                    = (unsigned char (__stdcall *)(unsigned int))GPA( "glIsList" );
+	qglIsTexture                 = 	dllIsTexture                 = (unsigned char (__stdcall *)(unsigned int))GPA( "glIsTexture" );
+	qglLightModelf               = 	dllLightModelf               = (void (__stdcall *)(unsigned int,float))GPA( "glLightModelf" );
+	qglLightModelfv              = 	dllLightModelfv              = (void (__stdcall *)(unsigned int,const float *))GPA( "glLightModelfv" );
+	qglLightModeli               = 	dllLightModeli               = (void (__stdcall *)(unsigned int,int))GPA( "glLightModeli" );
+	qglLightModeliv              = 	dllLightModeliv              = (void (__stdcall *)(unsigned int,const int *))GPA( "glLightModeliv" );
+	qglLightf                    = 	dllLightf                    = (void (__stdcall *)(unsigned int,unsigned int,float))GPA( "glLightf" );
+	qglLightfv                   = 	dllLightfv                   = (void (__stdcall *)(unsigned int,unsigned int,const float *))GPA( "glLightfv" );
+	qglLighti                    = 	dllLighti                    = (void (__stdcall *)(unsigned int,unsigned int,int))GPA( "glLighti" );
+	qglLightiv                   = 	dllLightiv                   = (void (__stdcall *)(unsigned int,unsigned int,const int *))GPA( "glLightiv" );
+	qglLineStipple               = 	dllLineStipple               = (void (__stdcall *)(int,unsigned short))GPA( "glLineStipple" );
+	qglLineWidth                 = 	dllLineWidth                 = (void (__stdcall *)(float))GPA( "glLineWidth" );
+	qglListBase                  = 	dllListBase                  = (void (__stdcall *)(unsigned int))GPA( "glListBase" );
+	qglLoadIdentity              = 	dllLoadIdentity              = (void (__stdcall *)(void))GPA( "glLoadIdentity" );
+	qglLoadMatrixd               = 	dllLoadMatrixd               = (void (__stdcall *)(const double *))GPA( "glLoadMatrixd" );
+	qglLoadMatrixf               = 	dllLoadMatrixf               = (void (__stdcall *)(const float *))GPA( "glLoadMatrixf" );
+	qglLoadName                  = 	dllLoadName                  = (void (__stdcall *)(unsigned int))GPA( "glLoadName" );
+	qglLogicOp                   = 	dllLogicOp                   = (void (__stdcall *)(unsigned int))GPA( "glLogicOp" );
+	qglMap1d                     = 	dllMap1d                     = (void (__stdcall *)(unsigned int,double,double,int,int,const double *))GPA( "glMap1d" );
+	qglMap1f                     = 	dllMap1f                     = (void (__stdcall *)(unsigned int,float,float,int,int,const float *))GPA( "glMap1f" );
+	qglMap2d                     = 	dllMap2d                     = (void (__stdcall *)(unsigned int,double,double,int,int,double,double,int,int,const double *))GPA( "glMap2d" );
+	qglMap2f                     = 	dllMap2f                     = (void (__stdcall *)(unsigned int,float,float,int,int,float,float,int,int,const float *))GPA( "glMap2f" );
+	qglMapGrid1d                 = 	dllMapGrid1d                 = (void (__stdcall *)(int,double,double))GPA( "glMapGrid1d" );
+	qglMapGrid1f                 = 	dllMapGrid1f                 = (void (__stdcall *)(int,float,float))GPA( "glMapGrid1f" );
+	qglMapGrid2d                 = 	dllMapGrid2d                 = (void (__stdcall *)(int,double,double,int,double,double))GPA( "glMapGrid2d" );
+	qglMapGrid2f                 = 	dllMapGrid2f                 = (void (__stdcall *)(int,float,float,int,float,float))GPA( "glMapGrid2f" );
+	qglMaterialf                 = 	dllMaterialf                 = (void (__stdcall *)(unsigned int,unsigned int,float))GPA( "glMaterialf" );
+	qglMaterialfv                = 	dllMaterialfv                = (void (__stdcall *)(unsigned int,unsigned int,const float *))GPA( "glMaterialfv" );
+	qglMateriali                 = 	dllMateriali                 = (void (__stdcall *)(unsigned int,unsigned int,int))GPA( "glMateriali" );
+	qglMaterialiv                = 	dllMaterialiv                = (void (__stdcall *)(unsigned int,unsigned int,const int *))GPA( "glMaterialiv" );
+	qglMatrixMode                = 	dllMatrixMode                = (void (__stdcall *)(unsigned int))GPA( "glMatrixMode" );
+	qglMultMatrixd               = 	dllMultMatrixd               = (void (__stdcall *)(const double *))GPA( "glMultMatrixd" );
+	qglMultMatrixf               = 	dllMultMatrixf               = (void (__stdcall *)(const float *))GPA( "glMultMatrixf" );
+	qglNewList                   = 	dllNewList                   = (void (__stdcall *)(unsigned int,unsigned int))GPA( "glNewList" );
+	qglNormal3b                  = 	dllNormal3b                  = (void (__stdcall *)(signed char,signed char,signed char))GPA( "glNormal3b" );
+	qglNormal3bv                 = 	dllNormal3bv                 = (void (__stdcall *)(const signed char *))GPA( "glNormal3bv" );
+	qglNormal3d                  = 	dllNormal3d                  = (void (__stdcall *)(double,double,double))GPA( "glNormal3d" );
+	qglNormal3dv                 = 	dllNormal3dv                 = (void (__stdcall *)(const double *))GPA( "glNormal3dv" );
+	qglNormal3f                  = 	dllNormal3f                  = (void (__stdcall *)(float,float,float))GPA( "glNormal3f" );
+	qglNormal3fv                 = 	dllNormal3fv                 = (void (__stdcall *)(const float *))GPA( "glNormal3fv" );
+	qglNormal3i                  = 	dllNormal3i                  = (void (__stdcall *)(int,int,int))GPA( "glNormal3i" );
+	qglNormal3iv                 = 	dllNormal3iv                 = (void (__stdcall *)(const int *))GPA( "glNormal3iv" );
+	qglNormal3s                  = 	dllNormal3s                  = (void (__stdcall *)(short,short,short))GPA( "glNormal3s" );
+	qglNormal3sv                 = 	dllNormal3sv                 = (void (__stdcall *)(const short *))GPA( "glNormal3sv" );
+	qglNormalPointer             = 	dllNormalPointer             = (void (__stdcall *)(unsigned int,int,const void *))GPA( "glNormalPointer" );
+	qglOrtho                     = 	dllOrtho                     = (void (__stdcall *)(double,double,double,double,double,double))GPA( "glOrtho" );
+	qglPassThrough               = 	dllPassThrough               = (void (__stdcall *)(float))GPA( "glPassThrough" );
+	qglPixelMapfv                = 	dllPixelMapfv                = (void (__stdcall *)(unsigned int,int,const float *))GPA( "glPixelMapfv" );
+	qglPixelMapuiv               = 	dllPixelMapuiv               = (void (__stdcall *)(unsigned int,int,const unsigned int *))GPA( "glPixelMapuiv" );
+	qglPixelMapusv               = 	dllPixelMapusv               = (void (__stdcall *)(unsigned int,int,const unsigned short *))GPA( "glPixelMapusv" );
+	qglPixelStoref               = 	dllPixelStoref               = (void (__stdcall *)(unsigned int,float))GPA( "glPixelStoref" );
+	qglPixelStorei               = 	dllPixelStorei               = (void (__stdcall *)(unsigned int,int))GPA( "glPixelStorei" );
+	qglPixelTransferf            = 	dllPixelTransferf            = (void (__stdcall *)(unsigned int,float))GPA( "glPixelTransferf" );
+	qglPixelTransferi            = 	dllPixelTransferi            = (void (__stdcall *)(unsigned int,int))GPA( "glPixelTransferi" );
+	qglPixelZoom                 = 	dllPixelZoom                 = (void (__stdcall *)(float,float))GPA( "glPixelZoom" );
+	qglPointSize                 = 	dllPointSize                 = (void (__stdcall *)(float))GPA( "glPointSize" );
+	qglPolygonMode               = 	dllPolygonMode               = (void (__stdcall *)(unsigned int,unsigned int))GPA( "glPolygonMode" );
+	qglPolygonOffset             = 	dllPolygonOffset             = (void (__stdcall *)(float,float))GPA( "glPolygonOffset" );
+	qglPolygonStipple            = 	dllPolygonStipple            = (void (__stdcall *)(const unsigned char *))GPA( "glPolygonStipple" );
+	qglPopAttrib                 = 	dllPopAttrib                 = (void (__stdcall *)(void))GPA( "glPopAttrib" );
+	qglPopClientAttrib           = 	dllPopClientAttrib           = (void (__stdcall *)(void))GPA( "glPopClientAttrib" );
+	qglPopMatrix                 = 	dllPopMatrix                 = (void (__stdcall *)(void))GPA( "glPopMatrix" );
+	qglPopName                   = 	dllPopName                   = (void (__stdcall *)(void))GPA( "glPopName" );
+	qglPrioritizeTextures        = 	dllPrioritizeTextures        = (void (__stdcall *)(int,const unsigned int *,const float *))GPA( "glPrioritizeTextures" );
+	qglPushAttrib                = 	dllPushAttrib                = (void (__stdcall *)(unsigned int))GPA( "glPushAttrib" );
+	qglPushClientAttrib          = 	dllPushClientAttrib          = (void (__stdcall *)(unsigned int))GPA( "glPushClientAttrib" );
+	qglPushMatrix                = 	dllPushMatrix                = (void (__stdcall *)(void))GPA( "glPushMatrix" );
+	qglPushName                  = 	dllPushName                  = (void (__stdcall *)(unsigned int))GPA( "glPushName" );
+	qglRasterPos2d               = 	dllRasterPos2d               = (void (__stdcall *)(double,double))GPA( "glRasterPos2d" );
+	qglRasterPos2dv              = 	dllRasterPos2dv              = (void (__stdcall *)(const double *))GPA( "glRasterPos2dv" );
+	qglRasterPos2f               = 	dllRasterPos2f               = (void (__stdcall *)(float,float))GPA( "glRasterPos2f" );
+	qglRasterPos2fv              = 	dllRasterPos2fv              = (void (__stdcall *)(const float *))GPA( "glRasterPos2fv" );
+	qglRasterPos2i               = 	dllRasterPos2i               = (void (__stdcall *)(int,int))GPA( "glRasterPos2i" );
+	qglRasterPos2iv              = 	dllRasterPos2iv              = (void (__stdcall *)(const int *))GPA( "glRasterPos2iv" );
+	qglRasterPos2s               = 	dllRasterPos2s               = (void (__stdcall *)(short,short))GPA( "glRasterPos2s" );
+	qglRasterPos2sv              = 	dllRasterPos2sv              = (void (__stdcall *)(const short *))GPA( "glRasterPos2sv" );
+	qglRasterPos3d               = 	dllRasterPos3d               = (void (__stdcall *)(double,double,double))GPA( "glRasterPos3d" );
+	qglRasterPos3dv              = 	dllRasterPos3dv              = (void (__stdcall *)(const double *))GPA( "glRasterPos3dv" );
+	qglRasterPos3f               = 	dllRasterPos3f               = (void (__stdcall *)(float,float,float))GPA( "glRasterPos3f" );
+	qglRasterPos3fv              = 	dllRasterPos3fv              = (void (__stdcall *)(const float *))GPA( "glRasterPos3fv" );
+	qglRasterPos3i               = 	dllRasterPos3i               = (void (__stdcall *)(int,int,int))GPA( "glRasterPos3i" );
+	qglRasterPos3iv              = 	dllRasterPos3iv              = (void (__stdcall *)(const int *))GPA( "glRasterPos3iv" );
+	qglRasterPos3s               = 	dllRasterPos3s               = (void (__stdcall *)(short,short,short))GPA( "glRasterPos3s" );
+	qglRasterPos3sv              = 	dllRasterPos3sv              = (void (__stdcall *)(const short *))GPA( "glRasterPos3sv" );
+	qglRasterPos4d               = 	dllRasterPos4d               = (void (__stdcall *)(double,double,double,double))GPA( "glRasterPos4d" );
+	qglRasterPos4dv              = 	dllRasterPos4dv              = (void (__stdcall *)(const double *))GPA( "glRasterPos4dv" );
+	qglRasterPos4f               = 	dllRasterPos4f               = (void (__stdcall *)(float,float,float,float))GPA( "glRasterPos4f" );
+	qglRasterPos4fv              = 	dllRasterPos4fv              = (void (__stdcall *)(const float *))GPA( "glRasterPos4fv" );
+	qglRasterPos4i               = 	dllRasterPos4i               = (void (__stdcall *)(int,int,int,int))GPA( "glRasterPos4i" );
+	qglRasterPos4iv              = 	dllRasterPos4iv              = (void (__stdcall *)(const int *))GPA( "glRasterPos4iv" );
+	qglRasterPos4s               = 	dllRasterPos4s               = (void (__stdcall *)(short,short,short,short))GPA( "glRasterPos4s" );
+	qglRasterPos4sv              = 	dllRasterPos4sv              = (void (__stdcall *)(const short *))GPA( "glRasterPos4sv" );
+	qglReadBuffer                = 	dllReadBuffer                = (void (__stdcall *)(unsigned int))GPA( "glReadBuffer" );
+	qglReadPixels                = 	dllReadPixels                = (void (__stdcall *)(int,int,int,int,unsigned int,unsigned int,void *))GPA( "glReadPixels" );
+	qglRectd                     = 	dllRectd                     = (void (__stdcall *)(double,double,double,double))GPA( "glRectd" );
+	qglRectdv                    = 	dllRectdv                    = (void (__stdcall *)(const double *,const double *))GPA( "glRectdv" );
+	qglRectf                     = 	dllRectf                     = (void (__stdcall *)(float,float,float,float))GPA( "glRectf" );
+	qglRectfv                    = 	dllRectfv                    = (void (__stdcall *)(const float *,const float *))GPA( "glRectfv" );
+	qglRecti                     = 	dllRecti                     = (void (__stdcall *)(int,int,int,int))GPA( "glRecti" );
+	qglRectiv                    = 	dllRectiv                    = (void (__stdcall *)(const int *,const int *))GPA( "glRectiv" );
+	qglRects                     = 	dllRects                     = (void (__stdcall *)(short,short,short,short))GPA( "glRects" );
+	qglRectsv                    = 	dllRectsv                    = (void (__stdcall *)(const short *,const short *))GPA( "glRectsv" );
+	qglRenderMode                = 	dllRenderMode                = (int (__stdcall *)(unsigned int))GPA( "glRenderMode" );
+	qglRotated                   = 	dllRotated                   = (void (__stdcall *)(double,double,double,double))GPA( "glRotated" );
+	qglRotatef                   = 	dllRotatef                   = (void (__stdcall *)(float,float,float,float))GPA( "glRotatef" );
+	qglScaled                    = 	dllScaled                    = (void (__stdcall *)(double,double,double))GPA( "glScaled" );
+	qglScalef                    = 	dllScalef                    = (void (__stdcall *)(float,float,float))GPA( "glScalef" );
+	qglScissor                   = 	dllScissor                   = (void (__stdcall *)(int,int,int,int))GPA( "glScissor" );
+	qglSelectBuffer              = 	dllSelectBuffer              = (void (__stdcall *)(int,unsigned int *))GPA( "glSelectBuffer" );
+	qglShadeModel                = 	dllShadeModel                = (void (__stdcall *)(unsigned int))GPA( "glShadeModel" );
+	qglStencilFunc               = 	dllStencilFunc               = (void (__stdcall *)(unsigned int,int,unsigned int))GPA( "glStencilFunc" );
+	qglStencilMask               = 	dllStencilMask               = (void (__stdcall *)(unsigned int))GPA( "glStencilMask" );
+	qglStencilOp                 = 	dllStencilOp                 = (void (__stdcall *)(unsigned int,unsigned int,unsigned int))GPA( "glStencilOp" );
+	qglTexCoord1d                = 	dllTexCoord1d                = (void (__stdcall *)(double))GPA( "glTexCoord1d" );
+	qglTexCoord1dv               = 	dllTexCoord1dv               = (void (__stdcall *)(const double *))GPA( "glTexCoord1dv" );
+	qglTexCoord1f                = 	dllTexCoord1f                = (void (__stdcall *)(float))GPA( "glTexCoord1f" );
+	qglTexCoord1fv               = 	dllTexCoord1fv               = (void (__stdcall *)(const float *))GPA( "glTexCoord1fv" );
+	qglTexCoord1i                = 	dllTexCoord1i                = (void (__stdcall *)(int))GPA( "glTexCoord1i" );
+	qglTexCoord1iv               = 	dllTexCoord1iv               = (void (__stdcall *)(const int *))GPA( "glTexCoord1iv" );
+	qglTexCoord1s                = 	dllTexCoord1s                = (void (__stdcall *)(short))GPA( "glTexCoord1s" );
+	qglTexCoord1sv               = 	dllTexCoord1sv               = (void (__stdcall *)(const short *))GPA( "glTexCoord1sv" );
+	qglTexCoord2d                = 	dllTexCoord2d                = (void (__stdcall *)(double,double))GPA( "glTexCoord2d" );
+	qglTexCoord2dv               = 	dllTexCoord2dv               = (void (__stdcall *)(const double *))GPA( "glTexCoord2dv" );
+	qglTexCoord2f                = 	dllTexCoord2f                = (void (__stdcall *)(float,float))GPA( "glTexCoord2f" );
+	qglTexCoord2fv               = 	dllTexCoord2fv               = (void (__stdcall *)(const float *))GPA( "glTexCoord2fv" );
+	qglTexCoord2i                = 	dllTexCoord2i                = (void (__stdcall *)(int,int))GPA( "glTexCoord2i" );
+	qglTexCoord2iv               = 	dllTexCoord2iv               = (void (__stdcall *)(const int *))GPA( "glTexCoord2iv" );
+	qglTexCoord2s                = 	dllTexCoord2s                = (void (__stdcall *)(short,short))GPA( "glTexCoord2s" );
+	qglTexCoord2sv               = 	dllTexCoord2sv               = (void (__stdcall *)(const short *))GPA( "glTexCoord2sv" );
+	qglTexCoord3d                = 	dllTexCoord3d                = (void (__stdcall *)(double,double,double))GPA( "glTexCoord3d" );
+	qglTexCoord3dv               = 	dllTexCoord3dv               = (void (__stdcall *)(const double *))GPA( "glTexCoord3dv" );
+	qglTexCoord3f                = 	dllTexCoord3f                = (void (__stdcall *)(float,float,float))GPA( "glTexCoord3f" );
+	qglTexCoord3fv               = 	dllTexCoord3fv               = (void (__stdcall *)(const float *))GPA( "glTexCoord3fv" );
+	qglTexCoord3i                = 	dllTexCoord3i                = (void (__stdcall *)(int,int,int))GPA( "glTexCoord3i" );
+	qglTexCoord3iv               = 	dllTexCoord3iv               = (void (__stdcall *)(const int *))GPA( "glTexCoord3iv" );
+	qglTexCoord3s                = 	dllTexCoord3s                = (void (__stdcall *)(short,short,short))GPA( "glTexCoord3s" );
+	qglTexCoord3sv               = 	dllTexCoord3sv               = (void (__stdcall *)(const short *))GPA( "glTexCoord3sv" );
+	qglTexCoord4d                = 	dllTexCoord4d                = (void (__stdcall *)(double,double,double,double))GPA( "glTexCoord4d" );
+	qglTexCoord4dv               = 	dllTexCoord4dv               = (void (__stdcall *)(const double *))GPA( "glTexCoord4dv" );
+	qglTexCoord4f                = 	dllTexCoord4f                = (void (__stdcall *)(float,float,float,float))GPA( "glTexCoord4f" );
+	qglTexCoord4fv               = 	dllTexCoord4fv               = (void (__stdcall *)(const float *))GPA( "glTexCoord4fv" );
+	qglTexCoord4i                = 	dllTexCoord4i                = (void (__stdcall *)(int,int,int,int))GPA( "glTexCoord4i" );
+	qglTexCoord4iv               = 	dllTexCoord4iv               = (void (__stdcall *)(const int *))GPA( "glTexCoord4iv" );
+	qglTexCoord4s                = 	dllTexCoord4s                = (void (__stdcall *)(short,short,short,short))GPA( "glTexCoord4s" );
+	qglTexCoord4sv               = 	dllTexCoord4sv               = (void (__stdcall *)(const short *))GPA( "glTexCoord4sv" );
+	qglTexCoordPointer           = 	dllTexCoordPointer           = (void (__stdcall *)(int,unsigned int,int,const void *))GPA( "glTexCoordPointer" );
+	qglTexEnvf                   = 	dllTexEnvf                   = (void (__stdcall *)(unsigned int,unsigned int,float))GPA( "glTexEnvf" );
+	qglTexEnvfv                  = 	dllTexEnvfv                  = (void (__stdcall *)(unsigned int,unsigned int,const float *))GPA( "glTexEnvfv" );
+	qglTexEnvi                   = 	dllTexEnvi                   = (void (__stdcall *)(unsigned int,unsigned int,int))GPA( "glTexEnvi" );
+	qglTexEnviv                  = 	dllTexEnviv                  = (void (__stdcall *)(unsigned int,unsigned int,const int *))GPA( "glTexEnviv" );
+	qglTexGend                   = 	dllTexGend                   = (void (__stdcall *)(unsigned int,unsigned int,double))GPA( "glTexGend" );
+	qglTexGendv                  = 	dllTexGendv                  = (void (__stdcall *)(unsigned int,unsigned int,const double *))GPA( "glTexGendv" );
+	qglTexGenf                   = 	dllTexGenf                   = (void (__stdcall *)(unsigned int,unsigned int,float))GPA( "glTexGenf" );
+	qglTexGenfv                  = 	dllTexGenfv                  = (void (__stdcall *)(unsigned int,unsigned int,const float *))GPA( "glTexGenfv" );
+	qglTexGeni                   = 	dllTexGeni                   = (void (__stdcall *)(unsigned int,unsigned int,int))GPA( "glTexGeni" );
+	qglTexGeniv                  = 	dllTexGeniv                  = (void (__stdcall *)(unsigned int,unsigned int,const int *))GPA( "glTexGeniv" );
+	qglTexImage1D                = 	dllTexImage1D                = (void (__stdcall *)(unsigned int,int,int,int,int,unsigned int,unsigned int,const void *))GPA( "glTexImage1D" );
+	qglTexImage2D                = 	dllTexImage2D                = (void (__stdcall *)(unsigned int,int,int,int,int,int,unsigned int,unsigned int,const void *))GPA( "glTexImage2D" );
+	qglTexParameterf             = 	dllTexParameterf             = (void (__stdcall *)(unsigned int,unsigned int,float))GPA( "glTexParameterf" );
+	qglTexParameterfv            = 	dllTexParameterfv            = (void (__stdcall *)(unsigned int,unsigned int,const float *))GPA( "glTexParameterfv" );
+	qglTexParameteri             = 	dllTexParameteri             = (void (__stdcall *)(unsigned int,unsigned int,int))GPA( "glTexParameteri" );
+	qglTexParameteriv            = 	dllTexParameteriv            = (void (__stdcall *)(unsigned int,unsigned int,const int *))GPA( "glTexParameteriv" );
+	qglTexSubImage1D             = 	dllTexSubImage1D             = (void (__stdcall *)(unsigned int,int,int,int,unsigned int,unsigned int,const void *))GPA( "glTexSubImage1D" );
+	qglTexSubImage2D             = 	dllTexSubImage2D             = (void (__stdcall *)(unsigned int,int,int,int,int,int,unsigned int,unsigned int,const void *))GPA( "glTexSubImage2D" );
+	qglTranslated                = 	dllTranslated                = (void (__stdcall *)(double,double,double))GPA( "glTranslated" );
+	qglTranslatef                = 	dllTranslatef                = (void (__stdcall *)(float,float,float))GPA( "glTranslatef" );
+	qglVertex2d                  = 	dllVertex2d                  = (void (__stdcall *)(double,double))GPA( "glVertex2d" );
+	qglVertex2dv                 = 	dllVertex2dv                 = (void (__stdcall *)(const double *))GPA( "glVertex2dv" );
+	qglVertex2f                  = 	dllVertex2f                  = (void (__stdcall *)(float,float))GPA( "glVertex2f" );
+	qglVertex2fv                 = 	dllVertex2fv                 = (void (__stdcall *)(const float *))GPA( "glVertex2fv" );
+	qglVertex2i                  = 	dllVertex2i                  = (void (__stdcall *)(int,int))GPA( "glVertex2i" );
+	qglVertex2iv                 = 	dllVertex2iv                 = (void (__stdcall *)(const int *))GPA( "glVertex2iv" );
+	qglVertex2s                  = 	dllVertex2s                  = (void (__stdcall *)(short,short))GPA( "glVertex2s" );
+	qglVertex2sv                 = 	dllVertex2sv                 = (void (__stdcall *)(const short *))GPA( "glVertex2sv" );
+	qglVertex3d                  = 	dllVertex3d                  = (void (__stdcall *)(double,double,double))GPA( "glVertex3d" );
+	qglVertex3dv                 = 	dllVertex3dv                 = (void (__stdcall *)(const double *))GPA( "glVertex3dv" );
+	qglVertex3f                  = 	dllVertex3f                  = (void (__stdcall *)(float,float,float))GPA( "glVertex3f" );
+	qglVertex3fv                 = 	dllVertex3fv                 = (void (__stdcall *)(const float *))GPA( "glVertex3fv" );
+	qglVertex3i                  = 	dllVertex3i                  = (void (__stdcall *)(int,int,int))GPA( "glVertex3i" );
+	qglVertex3iv                 = 	dllVertex3iv                 = (void (__stdcall *)(const int *))GPA( "glVertex3iv" );
+	qglVertex3s                  = 	dllVertex3s                  = (void (__stdcall *)(short,short,short))GPA( "glVertex3s" );
+	qglVertex3sv                 = 	dllVertex3sv                 = (void (__stdcall *)(const short *))GPA( "glVertex3sv" );
+	qglVertex4d                  = 	dllVertex4d                  = (void (__stdcall *)(double,double,double,double))GPA( "glVertex4d" );
+	qglVertex4dv                 = 	dllVertex4dv                 = (void (__stdcall *)(const double *))GPA( "glVertex4dv" );
+	qglVertex4f                  = 	dllVertex4f                  = (void (__stdcall *)(float,float,float,float))GPA( "glVertex4f" );
+	qglVertex4fv                 = 	dllVertex4fv                 = (void (__stdcall *)(const float *))GPA( "glVertex4fv" );
+	qglVertex4i                  = 	dllVertex4i                  = (void (__stdcall *)(int,int,int,int))GPA( "glVertex4i" );
+	qglVertex4iv                 = 	dllVertex4iv                 = (void (__stdcall *)(const int *))GPA( "glVertex4iv" );
+	qglVertex4s                  = 	dllVertex4s                  = (void (__stdcall *)(short,short,short,short))GPA( "glVertex4s" );
+	qglVertex4sv                 = 	dllVertex4sv                 = (void (__stdcall *)(const short *))GPA( "glVertex4sv" );
+	qglVertexPointer             = 	dllVertexPointer             = (void (__stdcall *)(int,unsigned int,int,const void *))GPA( "glVertexPointer" );
+	qglViewport                  = 	dllViewport                  = (void (__stdcall *)(int,int,int,int))GPA( "glViewport" );
+
+	qwglCopyContext              = (int (__stdcall *)(struct HGLRC__ *,struct HGLRC__ *,unsigned int))GPA( "wglCopyContext" );
+	qwglCreateContext            = (struct HGLRC__ *(__stdcall *)(struct HDC__ *))GPA( "wglCreateContext" );
+	qwglCreateLayerContext       = (struct HGLRC__ *(__stdcall *)(struct HDC__ *,int))GPA( "wglCreateLayerContext" );
+	qwglDeleteContext            = (int (__stdcall *)(struct HGLRC__ *))GPA( "wglDeleteContext" );
+	qwglDescribeLayerPlane       = (int (__stdcall *)(struct HDC__ *,int,int,unsigned int,struct tagLAYERPLANEDESCRIPTOR *))GPA( "wglDescribeLayerPlane" );
+	qwglGetCurrentContext        = (struct HGLRC__ *(__stdcall *)(void))GPA( "wglGetCurrentContext" );
+	qwglGetCurrentDC             = (struct HDC__ *(__stdcall *)(void))GPA( "wglGetCurrentDC" );
+	qwglGetLayerPaletteEntries   = (int (__stdcall *)(struct HDC__ *,int,int,int,unsigned long *))GPA( "wglGetLayerPaletteEntries" );
+	qwglGetProcAddress           = (int (__stdcall *(__stdcall *)(const char *))(void))GPA( "wglGetProcAddress" );
+	qwglMakeCurrent              = (int (__stdcall *)(struct HDC__ *,struct HGLRC__ *))GPA( "wglMakeCurrent" );
+	qwglRealizeLayerPalette      = (int (__stdcall *)(struct HDC__ *,int,int))GPA( "wglRealizeLayerPalette" );
+	qwglSetLayerPaletteEntries   = (int (__stdcall *)(struct HDC__ *,int,int,int,const unsigned long *))GPA( "wglSetLayerPaletteEntries" );
+	qwglShareLists               = (int (__stdcall *)(struct HGLRC__ *,struct HGLRC__ *))GPA( "wglShareLists" );
+	qwglSwapLayerBuffers         = (int (__stdcall *)(struct HDC__ *,unsigned int))GPA( "wglSwapLayerBuffers" );
+	qwglUseFontBitmaps           = (int (__stdcall *)(struct HDC__ *,unsigned long,unsigned long,unsigned long))GPA( "wglUseFontBitmapsA" );
+	qwglUseFontOutlines          = (int (__stdcall *)(struct HDC__ *,unsigned long,unsigned long,unsigned long,float,float,int,struct _GLYPHMETRICSFLOAT *))GPA( "wglUseFontOutlinesA" );
+
+	qwglSwapIntervalEXT = 0;
+	qglActiveTextureARB = 0;
+	qglClientActiveTextureARB = 0;
+	qglMultiTexCoord2fARB = 0;
+	qglLockArraysEXT = 0;
+	qglUnlockArraysEXT = 0;
+	qglPointParameterfEXT = NULL;
+	qglPointParameterfvEXT = NULL;
+	qglTexImage3DEXT = NULL;
+	qglTexSubImage3DEXT = NULL;
+
+	// check logging
+	QGL_EnableLogging( (qboolean)r_logFile->integer );
+
+	return qtrue;
+}
+
+void QGL_EnableLogging( qboolean enable )
+{
+	static qboolean isEnabled;
+
+	// return if we're already active
+	if ( isEnabled && enable ) {
+		// decrement log counter and stop if it has reached 0
+		Cvar_Set( "r_logFile", va("%d", r_logFile->integer - 1 ) );
+		if ( r_logFile->integer ) {
+			return;
+		}
+		enable = qfalse;
+	}
+
+	// return if we're already disabled
+	if ( !enable && !isEnabled )
+		return;
+
+	isEnabled = enable;
+
+	if ( enable )
+	{
+		if ( !glw_state.log_fp )
+		{
+			struct tm *newtime;
+			time_t aclock;
+			char buffer[1024];
+			cvar_t	*basedir;
+
+			time( &aclock );
+			newtime = localtime( &aclock );
+
+			basedir = Cvar_Get( "fs_basepath", "", 0 );
+			Com_sprintf( buffer, sizeof(buffer), "%s/gl.log", basedir->string ); 
+			glw_state.log_fp = fopen( buffer, "wt" );
+
+			fprintf( glw_state.log_fp, "%s\n", asctime( newtime ) );
+		}
+
+		qglAccum                     = logAccum;
+		qglAlphaFunc                 = logAlphaFunc;
+		qglAreTexturesResident       = logAreTexturesResident;
+		qglArrayElement              = logArrayElement;
+		qglBegin                     = logBegin;
+		qglBindTexture               = logBindTexture;
+		qglBitmap                    = logBitmap;
+		qglBlendFunc                 = logBlendFunc;
+		qglCallList                  = logCallList;
+		qglCallLists                 = logCallLists;
+		qglClear                     = logClear;
+		qglClearAccum                = logClearAccum;
+		qglClearColor                = logClearColor;
+		qglClearDepth                = logClearDepth;
+		qglClearIndex                = logClearIndex;
+		qglClearStencil              = logClearStencil;
+		qglClipPlane                 = logClipPlane;
+		qglColor3b                   = logColor3b;
+		qglColor3bv                  = logColor3bv;
+		qglColor3d                   = logColor3d;
+		qglColor3dv                  = logColor3dv;
+		qglColor3f                   = logColor3f;
+		qglColor3fv                  = logColor3fv;
+		qglColor3i                   = logColor3i;
+		qglColor3iv                  = logColor3iv;
+		qglColor3s                   = logColor3s;
+		qglColor3sv                  = logColor3sv;
+		qglColor3ub                  = logColor3ub;
+		qglColor3ubv                 = logColor3ubv;
+		qglColor3ui                  = logColor3ui;
+		qglColor3uiv                 = logColor3uiv;
+		qglColor3us                  = logColor3us;
+		qglColor3usv                 = logColor3usv;
+		qglColor4b                   = logColor4b;
+		qglColor4bv                  = logColor4bv;
+		qglColor4d                   = logColor4d;
+		qglColor4dv                  = logColor4dv;
+		qglColor4f                   = logColor4f;
+		qglColor4fv                  = logColor4fv;
+		qglColor4i                   = logColor4i;
+		qglColor4iv                  = logColor4iv;
+		qglColor4s                   = logColor4s;
+		qglColor4sv                  = logColor4sv;
+		qglColor4ub                  = logColor4ub;
+		qglColor4ubv                 = logColor4ubv;
+		qglColor4ui                  = logColor4ui;
+		qglColor4uiv                 = logColor4uiv;
+		qglColor4us                  = logColor4us;
+		qglColor4usv                 = logColor4usv;
+		qglColorMask                 = logColorMask;
+		qglColorMaterial             = logColorMaterial;
+		qglColorPointer              = logColorPointer;
+		qglCopyPixels                = logCopyPixels;
+		qglCopyTexImage1D            = logCopyTexImage1D;
+		qglCopyTexImage2D            = logCopyTexImage2D;
+		qglCopyTexSubImage1D         = logCopyTexSubImage1D;
+		qglCopyTexSubImage2D         = logCopyTexSubImage2D;
+		qglCullFace                  = logCullFace;
+		qglDeleteLists               = logDeleteLists ;
+		qglDeleteTextures            = logDeleteTextures ;
+		qglDepthFunc                 = logDepthFunc ;
+		qglDepthMask                 = logDepthMask ;
+		qglDepthRange                = logDepthRange ;
+		qglDisable                   = logDisable ;
+		qglDisableClientState        = logDisableClientState ;
+		qglDrawArrays                = logDrawArrays ;
+		qglDrawBuffer                = logDrawBuffer ;
+		qglDrawElements              = logDrawElements ;
+		qglDrawPixels                = logDrawPixels ;
+		qglEdgeFlag                  = logEdgeFlag ;
+		qglEdgeFlagPointer           = logEdgeFlagPointer ;
+		qglEdgeFlagv                 = logEdgeFlagv ;
+		qglEnable                    = 	logEnable                    ;
+		qglEnableClientState         = 	logEnableClientState         ;
+		qglEnd                       = 	logEnd                       ;
+		qglEndList                   = 	logEndList                   ;
+		qglEvalCoord1d				 = 	logEvalCoord1d				 ;
+		qglEvalCoord1dv              = 	logEvalCoord1dv              ;
+		qglEvalCoord1f               = 	logEvalCoord1f               ;
+		qglEvalCoord1fv              = 	logEvalCoord1fv              ;
+		qglEvalCoord2d               = 	logEvalCoord2d               ;
+		qglEvalCoord2dv              = 	logEvalCoord2dv              ;
+		qglEvalCoord2f               = 	logEvalCoord2f               ;
+		qglEvalCoord2fv              = 	logEvalCoord2fv              ;
+		qglEvalMesh1                 = 	logEvalMesh1                 ;
+		qglEvalMesh2                 = 	logEvalMesh2                 ;
+		qglEvalPoint1                = 	logEvalPoint1                ;
+		qglEvalPoint2                = 	logEvalPoint2                ;
+		qglFeedbackBuffer            = 	logFeedbackBuffer            ;
+		qglFinish                    = 	logFinish                    ;
+		qglFlush                     = 	logFlush                     ;
+		qglFogf                      = 	logFogf                      ;
+		qglFogfv                     = 	logFogfv                     ;
+		qglFogi                      = 	logFogi                      ;
+		qglFogiv                     = 	logFogiv                     ;
+		qglFrontFace                 = 	logFrontFace                 ;
+		qglFrustum                   = 	logFrustum                   ;
+		qglGenLists                  = 	logGenLists                  ;
+		qglGenTextures               = 	logGenTextures               ;
+		qglGetBooleanv               = 	logGetBooleanv               ;
+		qglGetClipPlane              = 	logGetClipPlane              ;
+		qglGetDoublev                = 	logGetDoublev                ;
+		qglGetError                  = 	logGetError                  ;
+		qglGetFloatv                 = 	logGetFloatv                 ;
+		qglGetIntegerv               = 	logGetIntegerv               ;
+		qglGetLightfv                = 	logGetLightfv                ;
+		qglGetLightiv                = 	logGetLightiv                ;
+		qglGetMapdv                  = 	logGetMapdv                  ;
+		qglGetMapfv                  = 	logGetMapfv                  ;
+		qglGetMapiv                  = 	logGetMapiv                  ;
+		qglGetMaterialfv             = 	logGetMaterialfv             ;
+		qglGetMaterialiv             = 	logGetMaterialiv             ;
+		qglGetPixelMapfv             = 	logGetPixelMapfv             ;
+		qglGetPixelMapuiv            = 	logGetPixelMapuiv            ;
+		qglGetPixelMapusv            = 	logGetPixelMapusv            ;
+		qglGetPointerv               = 	logGetPointerv               ;
+		qglGetPolygonStipple         = 	logGetPolygonStipple         ;
+		qglGetString                 = 	logGetString                 ;
+		qglGetTexEnvfv               = 	logGetTexEnvfv               ;
+		qglGetTexEnviv               = 	logGetTexEnviv               ;
+		qglGetTexGendv               = 	logGetTexGendv               ;
+		qglGetTexGenfv               = 	logGetTexGenfv               ;
+		qglGetTexGeniv               = 	logGetTexGeniv               ;
+		qglGetTexImage               = 	logGetTexImage               ;
+		qglGetTexLevelParameterfv    = 	logGetTexLevelParameterfv    ;
+		qglGetTexLevelParameteriv    = 	logGetTexLevelParameteriv    ;
+		qglGetTexParameterfv         = 	logGetTexParameterfv         ;
+		qglGetTexParameteriv         = 	logGetTexParameteriv         ;
+		qglHint                      = 	logHint                      ;
+		qglIndexMask                 = 	logIndexMask                 ;
+		qglIndexPointer              = 	logIndexPointer              ;
+		qglIndexd                    = 	logIndexd                    ;
+		qglIndexdv                   = 	logIndexdv                   ;
+		qglIndexf                    = 	logIndexf                    ;
+		qglIndexfv                   = 	logIndexfv                   ;
+		qglIndexi                    = 	logIndexi                    ;
+		qglIndexiv                   = 	logIndexiv                   ;
+		qglIndexs                    = 	logIndexs                    ;
+		qglIndexsv                   = 	logIndexsv                   ;
+		qglIndexub                   = 	logIndexub                   ;
+		qglIndexubv                  = 	logIndexubv                  ;
+		qglInitNames                 = 	logInitNames                 ;
+		qglInterleavedArrays         = 	logInterleavedArrays         ;
+		qglIsEnabled                 = 	logIsEnabled                 ;
+		qglIsList                    = 	logIsList                    ;
+		qglIsTexture                 = 	logIsTexture                 ;
+		qglLightModelf               = 	logLightModelf               ;
+		qglLightModelfv              = 	logLightModelfv              ;
+		qglLightModeli               = 	logLightModeli               ;
+		qglLightModeliv              = 	logLightModeliv              ;
+		qglLightf                    = 	logLightf                    ;
+		qglLightfv                   = 	logLightfv                   ;
+		qglLighti                    = 	logLighti                    ;
+		qglLightiv                   = 	logLightiv                   ;
+		qglLineStipple               = 	logLineStipple               ;
+		qglLineWidth                 = 	logLineWidth                 ;
+		qglListBase                  = 	logListBase                  ;
+		qglLoadIdentity              = 	logLoadIdentity              ;
+		qglLoadMatrixd               = 	logLoadMatrixd               ;
+		qglLoadMatrixf               = 	logLoadMatrixf               ;
+		qglLoadName                  = 	logLoadName                  ;
+		qglLogicOp                   = 	logLogicOp                   ;
+		qglMap1d                     = 	logMap1d                     ;
+		qglMap1f                     = 	logMap1f                     ;
+		qglMap2d                     = 	logMap2d                     ;
+		qglMap2f                     = 	logMap2f                     ;
+		qglMapGrid1d                 = 	logMapGrid1d                 ;
+		qglMapGrid1f                 = 	logMapGrid1f                 ;
+		qglMapGrid2d                 = 	logMapGrid2d                 ;
+		qglMapGrid2f                 = 	logMapGrid2f                 ;
+		qglMaterialf                 = 	logMaterialf                 ;
+		qglMaterialfv                = 	logMaterialfv                ;
+		qglMateriali                 = 	logMateriali                 ;
+		qglMaterialiv                = 	logMaterialiv                ;
+		qglMatrixMode                = 	logMatrixMode                ;
+		qglMultMatrixd               = 	logMultMatrixd               ;
+		qglMultMatrixf               = 	logMultMatrixf               ;
+		qglNewList                   = 	logNewList                   ;
+		qglNormal3b                  = 	logNormal3b                  ;
+		qglNormal3bv                 = 	logNormal3bv                 ;
+		qglNormal3d                  = 	logNormal3d                  ;
+		qglNormal3dv                 = 	logNormal3dv                 ;
+		qglNormal3f                  = 	logNormal3f                  ;
+		qglNormal3fv                 = 	logNormal3fv                 ;
+		qglNormal3i                  = 	logNormal3i                  ;
+		qglNormal3iv                 = 	logNormal3iv                 ;
+		qglNormal3s                  = 	logNormal3s                  ;
+		qglNormal3sv                 = 	logNormal3sv                 ;
+		qglNormalPointer             = 	logNormalPointer             ;
+		qglOrtho                     = 	logOrtho                     ;
+		qglPassThrough               = 	logPassThrough               ;
+		qglPixelMapfv                = 	logPixelMapfv                ;
+		qglPixelMapuiv               = 	logPixelMapuiv               ;
+		qglPixelMapusv               = 	logPixelMapusv               ;
+		qglPixelStoref               = 	logPixelStoref               ;
+		qglPixelStorei               = 	logPixelStorei               ;
+		qglPixelTransferf            = 	logPixelTransferf            ;
+		qglPixelTransferi            = 	logPixelTransferi            ;
+		qglPixelZoom                 = 	logPixelZoom                 ;
+		qglPointSize                 = 	logPointSize                 ;
+		qglPolygonMode               = 	logPolygonMode               ;
+		qglPolygonOffset             = 	logPolygonOffset             ;
+		qglPolygonStipple            = 	logPolygonStipple            ;
+		qglPopAttrib                 = 	logPopAttrib                 ;
+		qglPopClientAttrib           = 	logPopClientAttrib           ;
+		qglPopMatrix                 = 	logPopMatrix                 ;
+		qglPopName                   = 	logPopName                   ;
+		qglPrioritizeTextures        = 	logPrioritizeTextures        ;
+		qglPushAttrib                = 	logPushAttrib                ;
+		qglPushClientAttrib          = 	logPushClientAttrib          ;
+		qglPushMatrix                = 	logPushMatrix                ;
+		qglPushName                  = 	logPushName                  ;
+		qglRasterPos2d               = 	logRasterPos2d               ;
+		qglRasterPos2dv              = 	logRasterPos2dv              ;
+		qglRasterPos2f               = 	logRasterPos2f               ;
+		qglRasterPos2fv              = 	logRasterPos2fv              ;
+		qglRasterPos2i               = 	logRasterPos2i               ;
+		qglRasterPos2iv              = 	logRasterPos2iv              ;
+		qglRasterPos2s               = 	logRasterPos2s               ;
+		qglRasterPos2sv              = 	logRasterPos2sv              ;
+		qglRasterPos3d               = 	logRasterPos3d               ;
+		qglRasterPos3dv              = 	logRasterPos3dv              ;
+		qglRasterPos3f               = 	logRasterPos3f               ;
+		qglRasterPos3fv              = 	logRasterPos3fv              ;
+		qglRasterPos3i               = 	logRasterPos3i               ;
+		qglRasterPos3iv              = 	logRasterPos3iv              ;
+		qglRasterPos3s               = 	logRasterPos3s               ;
+		qglRasterPos3sv              = 	logRasterPos3sv              ;
+		qglRasterPos4d               = 	logRasterPos4d               ;
+		qglRasterPos4dv              = 	logRasterPos4dv              ;
+		qglRasterPos4f               = 	logRasterPos4f               ;
+		qglRasterPos4fv              = 	logRasterPos4fv              ;
+		qglRasterPos4i               = 	logRasterPos4i               ;
+		qglRasterPos4iv              = 	logRasterPos4iv              ;
+		qglRasterPos4s               = 	logRasterPos4s               ;
+		qglRasterPos4sv              = 	logRasterPos4sv              ;
+		qglReadBuffer                = 	logReadBuffer                ;
+		qglReadPixels                = 	logReadPixels                ;
+		qglRectd                     = 	logRectd                     ;
+		qglRectdv                    = 	logRectdv                    ;
+		qglRectf                     = 	logRectf                     ;
+		qglRectfv                    = 	logRectfv                    ;
+		qglRecti                     = 	logRecti                     ;
+		qglRectiv                    = 	logRectiv                    ;
+		qglRects                     = 	logRects                     ;
+		qglRectsv                    = 	logRectsv                    ;
+		qglRenderMode                = 	logRenderMode                ;
+		qglRotated                   = 	logRotated                   ;
+		qglRotatef                   = 	logRotatef                   ;
+		qglScaled                    = 	logScaled                    ;
+		qglScalef                    = 	logScalef                    ;
+		qglScissor                   = 	logScissor                   ;
+		qglSelectBuffer              = 	logSelectBuffer              ;
+		qglShadeModel                = 	logShadeModel                ;
+		qglStencilFunc               = 	logStencilFunc               ;
+		qglStencilMask               = 	logStencilMask               ;
+		qglStencilOp                 = 	logStencilOp                 ;
+		qglTexCoord1d                = 	logTexCoord1d                ;
+		qglTexCoord1dv               = 	logTexCoord1dv               ;
+		qglTexCoord1f                = 	logTexCoord1f                ;
+		qglTexCoord1fv               = 	logTexCoord1fv               ;
+		qglTexCoord1i                = 	logTexCoord1i                ;
+		qglTexCoord1iv               = 	logTexCoord1iv               ;
+		qglTexCoord1s                = 	logTexCoord1s                ;
+		qglTexCoord1sv               = 	logTexCoord1sv               ;
+		qglTexCoord2d                = 	logTexCoord2d                ;
+		qglTexCoord2dv               = 	logTexCoord2dv               ;
+		qglTexCoord2f                = 	logTexCoord2f                ;
+		qglTexCoord2fv               = 	logTexCoord2fv               ;
+		qglTexCoord2i                = 	logTexCoord2i                ;
+		qglTexCoord2iv               = 	logTexCoord2iv               ;
+		qglTexCoord2s                = 	logTexCoord2s                ;
+		qglTexCoord2sv               = 	logTexCoord2sv               ;
+		qglTexCoord3d                = 	logTexCoord3d                ;
+		qglTexCoord3dv               = 	logTexCoord3dv               ;
+		qglTexCoord3f                = 	logTexCoord3f                ;
+		qglTexCoord3fv               = 	logTexCoord3fv               ;
+		qglTexCoord3i                = 	logTexCoord3i                ;
+		qglTexCoord3iv               = 	logTexCoord3iv               ;
+		qglTexCoord3s                = 	logTexCoord3s                ;
+		qglTexCoord3sv               = 	logTexCoord3sv               ;
+		qglTexCoord4d                = 	logTexCoord4d                ;
+		qglTexCoord4dv               = 	logTexCoord4dv               ;
+		qglTexCoord4f                = 	logTexCoord4f                ;
+		qglTexCoord4fv               = 	logTexCoord4fv               ;
+		qglTexCoord4i                = 	logTexCoord4i                ;
+		qglTexCoord4iv               = 	logTexCoord4iv               ;
+		qglTexCoord4s                = 	logTexCoord4s                ;
+		qglTexCoord4sv               = 	logTexCoord4sv               ;
+		qglTexCoordPointer           = 	logTexCoordPointer           ;
+		qglTexEnvf                   = 	logTexEnvf                   ;
+		qglTexEnvfv                  = 	logTexEnvfv                  ;
+		qglTexEnvi                   = 	logTexEnvi                   ;
+		qglTexEnviv                  = 	logTexEnviv                  ;
+		qglTexGend                   = 	logTexGend                   ;
+		qglTexGendv                  = 	logTexGendv                  ;
+		qglTexGenf                   = 	logTexGenf                   ;
+		qglTexGenfv                  = 	logTexGenfv                  ;
+		qglTexGeni                   = 	logTexGeni                   ;
+		qglTexGeniv                  = 	logTexGeniv                  ;
+		qglTexImage1D                = 	logTexImage1D                ;
+		qglTexImage2D                = 	logTexImage2D                ;
+		qglTexParameterf             = 	logTexParameterf             ;
+		qglTexParameterfv            = 	logTexParameterfv            ;
+		qglTexParameteri             = 	logTexParameteri             ;
+		qglTexParameteriv            = 	logTexParameteriv            ;
+		qglTexSubImage1D             = 	logTexSubImage1D             ;
+		qglTexSubImage2D             = 	logTexSubImage2D             ;
+		qglTranslated                = 	logTranslated                ;
+		qglTranslatef                = 	logTranslatef                ;
+		qglVertex2d                  = 	logVertex2d                  ;
+		qglVertex2dv                 = 	logVertex2dv                 ;
+		qglVertex2f                  = 	logVertex2f                  ;
+		qglVertex2fv                 = 	logVertex2fv                 ;
+		qglVertex2i                  = 	logVertex2i                  ;
+		qglVertex2iv                 = 	logVertex2iv                 ;
+		qglVertex2s                  = 	logVertex2s                  ;
+		qglVertex2sv                 = 	logVertex2sv                 ;
+		qglVertex3d                  = 	logVertex3d                  ;
+		qglVertex3dv                 = 	logVertex3dv                 ;
+		qglVertex3f                  = 	logVertex3f                  ;
+		qglVertex3fv                 = 	logVertex3fv                 ;
+		qglVertex3i                  = 	logVertex3i                  ;
+		qglVertex3iv                 = 	logVertex3iv                 ;
+		qglVertex3s                  = 	logVertex3s                  ;
+		qglVertex3sv                 = 	logVertex3sv                 ;
+		qglVertex4d                  = 	logVertex4d                  ;
+		qglVertex4dv                 = 	logVertex4dv                 ;
+		qglVertex4f                  = 	logVertex4f                  ;
+		qglVertex4fv                 = 	logVertex4fv                 ;
+		qglVertex4i                  = 	logVertex4i                  ;
+		qglVertex4iv                 = 	logVertex4iv                 ;
+		qglVertex4s                  = 	logVertex4s                  ;
+		qglVertex4sv                 = 	logVertex4sv                 ;
+		qglVertexPointer             = 	logVertexPointer             ;
+		qglViewport                  = 	logViewport                  ;
+	}
+	else
+	{
+		if ( glw_state.log_fp )	{
+			fprintf( glw_state.log_fp, "*** CLOSING LOG ***\n" );
+			fclose( glw_state.log_fp );
+			glw_state.log_fp = NULL;
+		}
+		qglAccum                     = dllAccum;
+		qglAlphaFunc                 = dllAlphaFunc;
+		qglAreTexturesResident       = dllAreTexturesResident;
+		qglArrayElement              = dllArrayElement;
+		qglBegin                     = dllBegin;
+		qglBindTexture               = dllBindTexture;
+		qglBitmap                    = dllBitmap;
+		qglBlendFunc                 = dllBlendFunc;
+		qglCallList                  = dllCallList;
+		qglCallLists                 = dllCallLists;
+		qglClear                     = dllClear;
+		qglClearAccum                = dllClearAccum;
+		qglClearColor                = dllClearColor;
+		qglClearDepth                = dllClearDepth;
+		qglClearIndex                = dllClearIndex;
+		qglClearStencil              = dllClearStencil;
+		qglClipPlane                 = dllClipPlane;
+		qglColor3b                   = dllColor3b;
+		qglColor3bv                  = dllColor3bv;
+		qglColor3d                   = dllColor3d;
+		qglColor3dv                  = dllColor3dv;
+		qglColor3f                   = dllColor3f;
+		qglColor3fv                  = dllColor3fv;
+		qglColor3i                   = dllColor3i;
+		qglColor3iv                  = dllColor3iv;
+		qglColor3s                   = dllColor3s;
+		qglColor3sv                  = dllColor3sv;
+		qglColor3ub                  = dllColor3ub;
+		qglColor3ubv                 = dllColor3ubv;
+		qglColor3ui                  = dllColor3ui;
+		qglColor3uiv                 = dllColor3uiv;
+		qglColor3us                  = dllColor3us;
+		qglColor3usv                 = dllColor3usv;
+		qglColor4b                   = dllColor4b;
+		qglColor4bv                  = dllColor4bv;
+		qglColor4d                   = dllColor4d;
+		qglColor4dv                  = dllColor4dv;
+		qglColor4f                   = dllColor4f;
+		qglColor4fv                  = dllColor4fv;
+		qglColor4i                   = dllColor4i;
+		qglColor4iv                  = dllColor4iv;
+		qglColor4s                   = dllColor4s;
+		qglColor4sv                  = dllColor4sv;
+		qglColor4ub                  = dllColor4ub;
+		qglColor4ubv                 = dllColor4ubv;
+		qglColor4ui                  = dllColor4ui;
+		qglColor4uiv                 = dllColor4uiv;
+		qglColor4us                  = dllColor4us;
+		qglColor4usv                 = dllColor4usv;
+		qglColorMask                 = dllColorMask;
+		qglColorMaterial             = dllColorMaterial;
+		qglColorPointer              = dllColorPointer;
+		qglCopyPixels                = dllCopyPixels;
+		qglCopyTexImage1D            = dllCopyTexImage1D;
+		qglCopyTexImage2D            = dllCopyTexImage2D;
+		qglCopyTexSubImage1D         = dllCopyTexSubImage1D;
+		qglCopyTexSubImage2D         = dllCopyTexSubImage2D;
+		qglCullFace                  = dllCullFace;
+		qglDeleteLists               = dllDeleteLists ;
+		qglDeleteTextures            = dllDeleteTextures ;
+		qglDepthFunc                 = dllDepthFunc ;
+		qglDepthMask                 = dllDepthMask ;
+		qglDepthRange                = dllDepthRange ;
+		qglDisable                   = dllDisable ;
+		qglDisableClientState        = dllDisableClientState ;
+		qglDrawArrays                = dllDrawArrays ;
+		qglDrawBuffer                = dllDrawBuffer ;
+		qglDrawElements              = dllDrawElements ;
+		qglDrawPixels                = dllDrawPixels ;
+		qglEdgeFlag                  = dllEdgeFlag ;
+		qglEdgeFlagPointer           = dllEdgeFlagPointer ;
+		qglEdgeFlagv                 = dllEdgeFlagv ;
+		qglEnable                    = 	dllEnable                    ;
+		qglEnableClientState         = 	dllEnableClientState         ;
+		qglEnd                       = 	dllEnd                       ;
+		qglEndList                   = 	dllEndList                   ;
+		qglEvalCoord1d				 = 	dllEvalCoord1d				 ;
+		qglEvalCoord1dv              = 	dllEvalCoord1dv              ;
+		qglEvalCoord1f               = 	dllEvalCoord1f               ;
+		qglEvalCoord1fv              = 	dllEvalCoord1fv              ;
+		qglEvalCoord2d               = 	dllEvalCoord2d               ;
+		qglEvalCoord2dv              = 	dllEvalCoord2dv              ;
+		qglEvalCoord2f               = 	dllEvalCoord2f               ;
+		qglEvalCoord2fv              = 	dllEvalCoord2fv              ;
+		qglEvalMesh1                 = 	dllEvalMesh1                 ;
+		qglEvalMesh2                 = 	dllEvalMesh2                 ;
+		qglEvalPoint1                = 	dllEvalPoint1                ;
+		qglEvalPoint2                = 	dllEvalPoint2                ;
+		qglFeedbackBuffer            = 	dllFeedbackBuffer            ;
+		qglFinish                    = 	dllFinish                    ;
+		qglFlush                     = 	dllFlush                     ;
+		qglFogf                      = 	dllFogf                      ;
+		qglFogfv                     = 	dllFogfv                     ;
+		qglFogi                      = 	dllFogi                      ;
+		qglFogiv                     = 	dllFogiv                     ;
+		qglFrontFace                 = 	dllFrontFace                 ;
+		qglFrustum                   = 	dllFrustum                   ;
+		qglGenLists                  = 	dllGenLists                  ;
+		qglGenTextures               = 	dllGenTextures               ;
+		qglGetBooleanv               = 	dllGetBooleanv               ;
+		qglGetClipPlane              = 	dllGetClipPlane              ;
+		qglGetDoublev                = 	dllGetDoublev                ;
+		qglGetError                  = 	dllGetError                  ;
+		qglGetFloatv                 = 	dllGetFloatv                 ;
+		qglGetIntegerv               = 	dllGetIntegerv               ;
+		qglGetLightfv                = 	dllGetLightfv                ;
+		qglGetLightiv                = 	dllGetLightiv                ;
+		qglGetMapdv                  = 	dllGetMapdv                  ;
+		qglGetMapfv                  = 	dllGetMapfv                  ;
+		qglGetMapiv                  = 	dllGetMapiv                  ;
+		qglGetMaterialfv             = 	dllGetMaterialfv             ;
+		qglGetMaterialiv             = 	dllGetMaterialiv             ;
+		qglGetPixelMapfv             = 	dllGetPixelMapfv             ;
+		qglGetPixelMapuiv            = 	dllGetPixelMapuiv            ;
+		qglGetPixelMapusv            = 	dllGetPixelMapusv            ;
+		qglGetPointerv               = 	dllGetPointerv               ;
+		qglGetPolygonStipple         = 	dllGetPolygonStipple         ;
+		qglGetString                 = 	dllGetString                 ;
+		qglGetTexEnvfv               = 	dllGetTexEnvfv               ;
+		qglGetTexEnviv               = 	dllGetTexEnviv               ;
+		qglGetTexGendv               = 	dllGetTexGendv               ;
+		qglGetTexGenfv               = 	dllGetTexGenfv               ;
+		qglGetTexGeniv               = 	dllGetTexGeniv               ;
+		qglGetTexImage               = 	dllGetTexImage               ;
+		qglGetTexLevelParameterfv    = 	dllGetTexLevelParameterfv    ;
+		qglGetTexLevelParameteriv    = 	dllGetTexLevelParameteriv    ;
+		qglGetTexParameterfv         = 	dllGetTexParameterfv         ;
+		qglGetTexParameteriv         = 	dllGetTexParameteriv         ;
+		qglHint                      = 	dllHint                      ;
+		qglIndexMask                 = 	dllIndexMask                 ;
+		qglIndexPointer              = 	dllIndexPointer              ;
+		qglIndexd                    = 	dllIndexd                    ;
+		qglIndexdv                   = 	dllIndexdv                   ;
+		qglIndexf                    = 	dllIndexf                    ;
+		qglIndexfv                   = 	dllIndexfv                   ;
+		qglIndexi                    = 	dllIndexi                    ;
+		qglIndexiv                   = 	dllIndexiv                   ;
+		qglIndexs                    = 	dllIndexs                    ;
+		qglIndexsv                   = 	dllIndexsv                   ;
+		qglIndexub                   = 	dllIndexub                   ;
+		qglIndexubv                  = 	dllIndexubv                  ;
+		qglInitNames                 = 	dllInitNames                 ;
+		qglInterleavedArrays         = 	dllInterleavedArrays         ;
+		qglIsEnabled                 = 	dllIsEnabled                 ;
+		qglIsList                    = 	dllIsList                    ;
+		qglIsTexture                 = 	dllIsTexture                 ;
+		qglLightModelf               = 	dllLightModelf               ;
+		qglLightModelfv              = 	dllLightModelfv              ;
+		qglLightModeli               = 	dllLightModeli               ;
+		qglLightModeliv              = 	dllLightModeliv              ;
+		qglLightf                    = 	dllLightf                    ;
+		qglLightfv                   = 	dllLightfv                   ;
+		qglLighti                    = 	dllLighti                    ;
+		qglLightiv                   = 	dllLightiv                   ;
+		qglLineStipple               = 	dllLineStipple               ;
+		qglLineWidth                 = 	dllLineWidth                 ;
+		qglListBase                  = 	dllListBase                  ;
+		qglLoadIdentity              = 	dllLoadIdentity              ;
+		qglLoadMatrixd               = 	dllLoadMatrixd               ;
+		qglLoadMatrixf               = 	dllLoadMatrixf               ;
+		qglLoadName                  = 	dllLoadName                  ;
+		qglLogicOp                   = 	dllLogicOp                   ;
+		qglMap1d                     = 	dllMap1d                     ;
+		qglMap1f                     = 	dllMap1f                     ;
+		qglMap2d                     = 	dllMap2d                     ;
+		qglMap2f                     = 	dllMap2f                     ;
+		qglMapGrid1d                 = 	dllMapGrid1d                 ;
+		qglMapGrid1f                 = 	dllMapGrid1f                 ;
+		qglMapGrid2d                 = 	dllMapGrid2d                 ;
+		qglMapGrid2f                 = 	dllMapGrid2f                 ;
+		qglMaterialf                 = 	dllMaterialf                 ;
+		qglMaterialfv                = 	dllMaterialfv                ;
+		qglMateriali                 = 	dllMateriali                 ;
+		qglMaterialiv                = 	dllMaterialiv                ;
+		qglMatrixMode                = 	dllMatrixMode                ;
+		qglMultMatrixd               = 	dllMultMatrixd               ;
+		qglMultMatrixf               = 	dllMultMatrixf               ;
+		qglNewList                   = 	dllNewList                   ;
+		qglNormal3b                  = 	dllNormal3b                  ;
+		qglNormal3bv                 = 	dllNormal3bv                 ;
+		qglNormal3d                  = 	dllNormal3d                  ;
+		qglNormal3dv                 = 	dllNormal3dv                 ;
+		qglNormal3f                  = 	dllNormal3f                  ;
+		qglNormal3fv                 = 	dllNormal3fv                 ;
+		qglNormal3i                  = 	dllNormal3i                  ;
+		qglNormal3iv                 = 	dllNormal3iv                 ;
+		qglNormal3s                  = 	dllNormal3s                  ;
+		qglNormal3sv                 = 	dllNormal3sv                 ;
+		qglNormalPointer             = 	dllNormalPointer             ;
+		qglOrtho                     = 	dllOrtho                     ;
+		qglPassThrough               = 	dllPassThrough               ;
+		qglPixelMapfv                = 	dllPixelMapfv                ;
+		qglPixelMapuiv               = 	dllPixelMapuiv               ;
+		qglPixelMapusv               = 	dllPixelMapusv               ;
+		qglPixelStoref               = 	dllPixelStoref               ;
+		qglPixelStorei               = 	dllPixelStorei               ;
+		qglPixelTransferf            = 	dllPixelTransferf            ;
+		qglPixelTransferi            = 	dllPixelTransferi            ;
+		qglPixelZoom                 = 	dllPixelZoom                 ;
+		qglPointSize                 = 	dllPointSize                 ;
+		qglPolygonMode               = 	dllPolygonMode               ;
+		qglPolygonOffset             = 	dllPolygonOffset             ;
+		qglPolygonStipple            = 	dllPolygonStipple            ;
+		qglPopAttrib                 = 	dllPopAttrib                 ;
+		qglPopClientAttrib           = 	dllPopClientAttrib           ;
+		qglPopMatrix                 = 	dllPopMatrix                 ;
+		qglPopName                   = 	dllPopName                   ;
+		qglPrioritizeTextures        = 	dllPrioritizeTextures        ;
+		qglPushAttrib                = 	dllPushAttrib                ;
+		qglPushClientAttrib          = 	dllPushClientAttrib          ;
+		qglPushMatrix                = 	dllPushMatrix                ;
+		qglPushName                  = 	dllPushName                  ;
+		qglRasterPos2d               = 	dllRasterPos2d               ;
+		qglRasterPos2dv              = 	dllRasterPos2dv              ;
+		qglRasterPos2f               = 	dllRasterPos2f               ;
+		qglRasterPos2fv              = 	dllRasterPos2fv              ;
+		qglRasterPos2i               = 	dllRasterPos2i               ;
+		qglRasterPos2iv              = 	dllRasterPos2iv              ;
+		qglRasterPos2s               = 	dllRasterPos2s               ;
+		qglRasterPos2sv              = 	dllRasterPos2sv              ;
+		qglRasterPos3d               = 	dllRasterPos3d               ;
+		qglRasterPos3dv              = 	dllRasterPos3dv              ;
+		qglRasterPos3f               = 	dllRasterPos3f               ;
+		qglRasterPos3fv              = 	dllRasterPos3fv              ;
+		qglRasterPos3i               = 	dllRasterPos3i               ;
+		qglRasterPos3iv              = 	dllRasterPos3iv              ;
+		qglRasterPos3s               = 	dllRasterPos3s               ;
+		qglRasterPos3sv              = 	dllRasterPos3sv              ;
+		qglRasterPos4d               = 	dllRasterPos4d               ;
+		qglRasterPos4dv              = 	dllRasterPos4dv              ;
+		qglRasterPos4f               = 	dllRasterPos4f               ;
+		qglRasterPos4fv              = 	dllRasterPos4fv              ;
+		qglRasterPos4i               = 	dllRasterPos4i               ;
+		qglRasterPos4iv              = 	dllRasterPos4iv              ;
+		qglRasterPos4s               = 	dllRasterPos4s               ;
+		qglRasterPos4sv              = 	dllRasterPos4sv              ;
+		qglReadBuffer                = 	dllReadBuffer                ;
+		qglReadPixels                = 	dllReadPixels                ;
+		qglRectd                     = 	dllRectd                     ;
+		qglRectdv                    = 	dllRectdv                    ;
+		qglRectf                     = 	dllRectf                     ;
+		qglRectfv                    = 	dllRectfv                    ;
+		qglRecti                     = 	dllRecti                     ;
+		qglRectiv                    = 	dllRectiv                    ;
+		qglRects                     = 	dllRects                     ;
+		qglRectsv                    = 	dllRectsv                    ;
+		qglRenderMode                = 	dllRenderMode                ;
+		qglRotated                   = 	dllRotated                   ;
+		qglRotatef                   = 	dllRotatef                   ;
+		qglScaled                    = 	dllScaled                    ;
+		qglScalef                    = 	dllScalef                    ;
+		qglScissor                   = 	dllScissor                   ;
+		qglSelectBuffer              = 	dllSelectBuffer              ;
+		qglShadeModel                = 	dllShadeModel                ;
+		qglStencilFunc               = 	dllStencilFunc               ;
+		qglStencilMask               = 	dllStencilMask               ;
+		qglStencilOp                 = 	dllStencilOp                 ;
+		qglTexCoord1d                = 	dllTexCoord1d                ;
+		qglTexCoord1dv               = 	dllTexCoord1dv               ;
+		qglTexCoord1f                = 	dllTexCoord1f                ;
+		qglTexCoord1fv               = 	dllTexCoord1fv               ;
+		qglTexCoord1i                = 	dllTexCoord1i                ;
+		qglTexCoord1iv               = 	dllTexCoord1iv               ;
+		qglTexCoord1s                = 	dllTexCoord1s                ;
+		qglTexCoord1sv               = 	dllTexCoord1sv               ;
+		qglTexCoord2d                = 	dllTexCoord2d                ;
+		qglTexCoord2dv               = 	dllTexCoord2dv               ;
+		qglTexCoord2f                = 	dllTexCoord2f                ;
+		qglTexCoord2fv               = 	dllTexCoord2fv               ;
+		qglTexCoord2i                = 	dllTexCoord2i                ;
+		qglTexCoord2iv               = 	dllTexCoord2iv               ;
+		qglTexCoord2s                = 	dllTexCoord2s                ;
+		qglTexCoord2sv               = 	dllTexCoord2sv               ;
+		qglTexCoord3d                = 	dllTexCoord3d                ;
+		qglTexCoord3dv               = 	dllTexCoord3dv               ;
+		qglTexCoord3f                = 	dllTexCoord3f                ;
+		qglTexCoord3fv               = 	dllTexCoord3fv               ;
+		qglTexCoord3i                = 	dllTexCoord3i                ;
+		qglTexCoord3iv               = 	dllTexCoord3iv               ;
+		qglTexCoord3s                = 	dllTexCoord3s                ;
+		qglTexCoord3sv               = 	dllTexCoord3sv               ;
+		qglTexCoord4d                = 	dllTexCoord4d                ;
+		qglTexCoord4dv               = 	dllTexCoord4dv               ;
+		qglTexCoord4f                = 	dllTexCoord4f                ;
+		qglTexCoord4fv               = 	dllTexCoord4fv               ;
+		qglTexCoord4i                = 	dllTexCoord4i                ;
+		qglTexCoord4iv               = 	dllTexCoord4iv               ;
+		qglTexCoord4s                = 	dllTexCoord4s                ;
+		qglTexCoord4sv               = 	dllTexCoord4sv               ;
+		qglTexCoordPointer           = 	dllTexCoordPointer           ;
+		qglTexEnvf                   = 	dllTexEnvf                   ;
+		qglTexEnvfv                  = 	dllTexEnvfv                  ;
+		qglTexEnvi                   = 	dllTexEnvi                   ;
+		qglTexEnviv                  = 	dllTexEnviv                  ;
+		qglTexGend                   = 	dllTexGend                   ;
+		qglTexGendv                  = 	dllTexGendv                  ;
+		qglTexGenf                   = 	dllTexGenf                   ;
+		qglTexGenfv                  = 	dllTexGenfv                  ;
+		qglTexGeni                   = 	dllTexGeni                   ;
+		qglTexGeniv                  = 	dllTexGeniv                  ;
+		qglTexImage1D                = 	dllTexImage1D                ;
+		qglTexImage2D                = 	dllTexImage2D                ;
+		qglTexParameterf             = 	dllTexParameterf             ;
+		qglTexParameterfv            = 	dllTexParameterfv            ;
+		qglTexParameteri             = 	dllTexParameteri             ;
+		qglTexParameteriv            = 	dllTexParameteriv            ;
+		qglTexSubImage1D             = 	dllTexSubImage1D             ;
+		qglTexSubImage2D             = 	dllTexSubImage2D             ;
+		qglTranslated                = 	dllTranslated                ;
+		qglTranslatef                = 	dllTranslatef                ;
+		qglVertex2d                  = 	dllVertex2d                  ;
+		qglVertex2dv                 = 	dllVertex2dv                 ;
+		qglVertex2f                  = 	dllVertex2f                  ;
+		qglVertex2fv                 = 	dllVertex2fv                 ;
+		qglVertex2i                  = 	dllVertex2i                  ;
+		qglVertex2iv                 = 	dllVertex2iv                 ;
+		qglVertex2s                  = 	dllVertex2s                  ;
+		qglVertex2sv                 = 	dllVertex2sv                 ;
+		qglVertex3d                  = 	dllVertex3d                  ;
+		qglVertex3dv                 = 	dllVertex3dv                 ;
+		qglVertex3f                  = 	dllVertex3f                  ;
+		qglVertex3fv                 = 	dllVertex3fv                 ;
+		qglVertex3i                  = 	dllVertex3i                  ;
+		qglVertex3iv                 = 	dllVertex3iv                 ;
+		qglVertex3s                  = 	dllVertex3s                  ;
+		qglVertex3sv                 = 	dllVertex3sv                 ;
+		qglVertex4d                  = 	dllVertex4d                  ;
+		qglVertex4dv                 = 	dllVertex4dv                 ;
+		qglVertex4f                  = 	dllVertex4f                  ;
+		qglVertex4fv                 = 	dllVertex4fv                 ;
+		qglVertex4i                  = 	dllVertex4i                  ;
+		qglVertex4iv                 = 	dllVertex4iv                 ;
+		qglVertex4s                  = 	dllVertex4s                  ;
+		qglVertex4sv                 = 	dllVertex4sv                 ;
+		qglVertexPointer             = 	dllVertexPointer             ;
+		qglViewport                  = 	dllViewport                  ;
+	}
+}
+
+#pragma warning (default : 4113 4133 4047 )
+
+
+
diff --git a/codemp/win32/win_qgl_dx8.cpp b/codemp/win32/win_qgl_dx8.cpp
new file mode 100644
index 0000000..2c9a72f
--- /dev/null
+++ b/codemp/win32/win_qgl_dx8.cpp
@@ -0,0 +1,6495 @@
+
+/*
+ * UNPUBLISHED -- Rights  reserved  under  the  copyright  laws  of the 
+ * United States.  Use  of a copyright notice is precautionary only and 
+ * does not imply publication or disclosure.                            
+ *                                                                      
+ * THIS DOCUMENTATION CONTAINS CONFIDENTIAL AND PROPRIETARY INFORMATION 
+ * OF    VICARIOUS   VISIONS,  INC.    ANY  DUPLICATION,  MODIFICATION, 
+ * DISTRIBUTION, OR DISCLOSURE IS STRICTLY PROHIBITED WITHOUT THE PRIOR 
+ * EXPRESS WRITTEN PERMISSION OF VICARIOUS VISIONS, INC.
+ */
+
+// leave this as first line for PCH reasons...
+//
+#include "../server/exe_headers.h"
+
+
+/*
+** QGL_WIN.C
+**
+** This file implements the operating system binding of GL to QGL function
+** pointers.  When doing a port of Quake3 you must implement the following
+** two functions:
+**
+** QGL_Init() - loads libraries, assigns function pointers, etc.
+** QGL_Shutdown() - unloads libraries, NULLs function pointers
+*/
+#include <float.h>
+#include "../renderer/tr_local.h"
+#include "glw_win_dx8.h"
+#include "win_local.h"
+
+#ifdef _XBOX
+#include <xgraphics.h>
+#include "win_lighteffects.h"
+#include "win_highdynamicrange.h"
+
+#ifndef FINAL_BUILD
+#include <d3d8perf.h>
+#endif
+
+#endif
+
+#include <vector>
+
+extern void Z_SetNewDeleteTemporary(bool);
+
+#define GLW_USE_TRI_STRIPS 1
+
+#ifdef _XBOX
+#define GLW_MAX_DRAW_PACKET_SIZE 2040
+#else
+#define GLW_MAX_DRAW_PACKET_SIZE (SHADER_MAX_VERTEXES*12)
+#endif
+
+#define MEMORY_PROFILE 0
+
+int texMemSize = 0;
+
+#if MEMORY_PROFILE
+ 
+static int getTexMemSize(IDirect3DTexture8* mipmap)
+{
+	int levels = mipmap->GetLevelCount();
+	int size = 0;
+	while (levels--)
+	{ 
+		D3DSURFACE_DESC desc;
+		mipmap->GetLevelDesc(levels, &desc);
+		size += desc.Size;
+	}
+	return size;
+}
+#endif
+
+void QGL_EnableLogging( qboolean enable );
+
+void ( * qglAccum )(GLenum op, GLfloat value);
+void ( * qglAlphaFunc )(GLenum func, GLclampf ref);
+GLboolean ( * qglAreTexturesResident )(GLsizei n, const GLuint *textures, GLboolean *residences);
+void ( * qglArrayElement )(GLint i);
+void ( * qglBegin )(GLenum mode);
+void ( * qglBeginEXT )(GLenum mode, GLint verts, GLint colors, GLint normals, GLint tex0, GLint tex1);//, GLint tex2, GLint tex3);
+GLboolean ( * qglBeginFrame )(void);
+void ( * qglBeginShadow )(void);
+void ( * qglBindTexture )(GLenum target, GLuint texture);
+void ( * qglBitmap )(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap);
+void ( * qglBlendFunc )(GLenum sfactor, GLenum dfactor);
+void ( * qglCallList )(GLuint lnum);
+void ( * qglCallLists )(GLsizei n, GLenum type, const GLvoid *lists);
+void ( * qglClear )(GLbitfield mask);
+void ( * qglClearAccum )(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
+void ( * qglClearColor )(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
+void ( * qglClearDepth )(GLclampd depth);
+void ( * qglClearIndex )(GLfloat c);
+void ( * qglClearStencil )(GLint s);
+void ( * qglClipPlane )(GLenum plane, const GLdouble *equation);
+void ( * qglColor3b )(GLbyte red, GLbyte green, GLbyte blue);
+void ( * qglColor3bv )(const GLbyte *v);
+void ( * qglColor3d )(GLdouble red, GLdouble green, GLdouble blue);
+void ( * qglColor3dv )(const GLdouble *v);
+void ( * qglColor3f )(GLfloat red, GLfloat green, GLfloat blue);
+void ( * qglColor3fv )(const GLfloat *v);
+void ( * qglColor3i )(GLint red, GLint green, GLint blue);
+void ( * qglColor3iv )(const GLint *v);
+void ( * qglColor3s )(GLshort red, GLshort green, GLshort blue);
+void ( * qglColor3sv )(const GLshort *v);
+void ( * qglColor3ub )(GLubyte red, GLubyte green, GLubyte blue);
+void ( * qglColor3ubv )(const GLubyte *v);
+void ( * qglColor3ui )(GLuint red, GLuint green, GLuint blue);
+void ( * qglColor3uiv )(const GLuint *v);
+void ( * qglColor3us )(GLushort red, GLushort green, GLushort blue);
+void ( * qglColor3usv )(const GLushort *v);
+void ( * qglColor4b )(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha);
+void ( * qglColor4bv )(const GLbyte *v);
+void ( * qglColor4d )(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha);
+void ( * qglColor4dv )(const GLdouble *v);
+void ( * qglColor4f )(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
+void ( * qglColor4fv )(const GLfloat *v);
+void ( * qglColor4i )(GLint red, GLint green, GLint blue, GLint alpha);
+void ( * qglColor4iv )(const GLint *v);
+void ( * qglColor4s )(GLshort red, GLshort green, GLshort blue, GLshort alpha);
+void ( * qglColor4sv )(const GLshort *v);
+void ( * qglColor4ub )(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha);
+void ( * qglColor4ubv )(const GLubyte *v);
+void ( * qglColor4ui )(GLuint red, GLuint green, GLuint blue, GLuint alpha);
+void ( * qglColor4uiv )(const GLuint *v);
+void ( * qglColor4us )(GLushort red, GLushort green, GLushort blue, GLushort alpha);
+void ( * qglColor4usv )(const GLushort *v);
+void ( * qglColorMask )(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
+void ( * qglColorMaterial )(GLenum face, GLenum mode);
+void ( * qglColorPointer )(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
+void ( * qglCopyPixels )(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type);
+void ( * qglCopyTexImage1D )(GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border);
+void ( * qglCopyTexImage2D )(GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
+void ( * qglCopyTexSubImage1D )(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);
+void ( * qglCopyTexSubImage2D )(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
+void ( * qglCullFace )(GLenum mode);
+void ( * qglDeleteLists )(GLuint lnum, GLsizei range);
+void ( * qglDeleteTextures )(GLsizei n, const GLuint *textures);
+void ( * qglDepthFunc )(GLenum func);
+void ( * qglDepthMask )(GLboolean flag);
+void ( * qglDepthRange )(GLclampd zNear, GLclampd zFar);
+void ( * qglDisable )(GLenum cap);
+void ( * qglDisableClientState )(GLenum array);
+void ( * qglDrawArrays )(GLenum mode, GLint first, GLsizei count);
+void ( * qglDrawBuffer )(GLenum mode);
+void ( * qglDrawElements )(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices);
+void ( * qglDrawPixels )(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
+void ( * qglEdgeFlag )(GLboolean flag);
+void ( * qglEdgeFlagPointer )(GLsizei stride, const GLvoid *pointer);
+void ( * qglEdgeFlagv )(const GLboolean *flag);
+void ( * qglEnable )(GLenum cap);
+void ( * qglEnableClientState )(GLenum array);
+void ( * qglEnd )(void);
+void ( * qglEndFrame )(void);
+void ( * qglEndShadow )(void);
+void ( * qglEndList )(void);
+void ( * qglEvalCoord1d )(GLdouble u);
+void ( * qglEvalCoord1dv )(const GLdouble *u);
+void ( * qglEvalCoord1f )(GLfloat u);
+void ( * qglEvalCoord1fv )(const GLfloat *u);
+void ( * qglEvalCoord2d )(GLdouble u, GLdouble v);
+void ( * qglEvalCoord2dv )(const GLdouble *u);
+void ( * qglEvalCoord2f )(GLfloat u, GLfloat v);
+void ( * qglEvalCoord2fv )(const GLfloat *u);
+void ( * qglEvalMesh1 )(GLenum mode, GLint i1, GLint i2);
+void ( * qglEvalMesh2 )(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2);
+void ( * qglEvalPoint1 )(GLint i);
+void ( * qglEvalPoint2 )(GLint i, GLint j);
+void ( * qglFeedbackBuffer )(GLsizei size, GLenum type, GLfloat *buffer);
+void ( * qglFinish )(void);
+void ( * qglFlush )(void);
+void ( * qglFlushShadow )(void);
+void ( * qglFogf )(GLenum pname, GLfloat param);
+void ( * qglFogfv )(GLenum pname, const GLfloat *params);
+void ( * qglFogi )(GLenum pname, GLint param);
+void ( * qglFogiv )(GLenum pname, const GLint *params);
+void ( * qglFrontFace )(GLenum mode);
+void ( * qglFrustum )(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
+GLuint ( * qglGenLists )(GLsizei range);
+void ( * qglGenTextures )(GLsizei n, GLuint *textures);
+void ( * qglGetBooleanv )(GLenum pname, GLboolean *params);
+void ( * qglGetClipPlane )(GLenum plane, GLdouble *equation);
+void ( * qglGetDoublev )(GLenum pname, GLdouble *params);
+GLenum ( * qglGetError )(void);
+void ( * qglGetFloatv )(GLenum pname, GLfloat *params);
+void ( * qglGetIntegerv )(GLenum pname, GLint *params);
+void ( * qglGetLightfv )(GLenum light, GLenum pname, GLfloat *params);
+void ( * qglGetLightiv )(GLenum light, GLenum pname, GLint *params);
+void ( * qglGetMapdv )(GLenum target, GLenum query, GLdouble *v);
+void ( * qglGetMapfv )(GLenum target, GLenum query, GLfloat *v);
+void ( * qglGetMapiv )(GLenum target, GLenum query, GLint *v);
+void ( * qglGetMaterialfv )(GLenum face, GLenum pname, GLfloat *params);
+void ( * qglGetMaterialiv )(GLenum face, GLenum pname, GLint *params);
+void ( * qglGetPixelMapfv )(GLenum gmap, GLfloat *values);
+void ( * qglGetPixelMapuiv )(GLenum gmap, GLuint *values);
+void ( * qglGetPixelMapusv )(GLenum gmap, GLushort *values);
+void ( * qglGetPointerv )(GLenum pname, GLvoid* *params);
+void ( * qglGetPolygonStipple )(GLubyte *mask);
+const GLubyte * ( * qglGetString )(GLenum name);
+void ( * qglGetTexEnvfv )(GLenum target, GLenum pname, GLfloat *params);
+void ( * qglGetTexEnviv )(GLenum target, GLenum pname, GLint *params);
+void ( * qglGetTexGendv )(GLenum coord, GLenum pname, GLdouble *params);
+void ( * qglGetTexGenfv )(GLenum coord, GLenum pname, GLfloat *params);
+void ( * qglGetTexGeniv )(GLenum coord, GLenum pname, GLint *params);
+void ( * qglGetTexImage )(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels);
+void ( * qglGetTexLevelParameterfv )(GLenum target, GLint level, GLenum pname, GLfloat *params);
+void ( * qglGetTexLevelParameteriv )(GLenum target, GLint level, GLenum pname, GLint *params);
+void ( * qglGetTexParameterfv )(GLenum target, GLenum pname, GLfloat *params);
+void ( * qglGetTexParameteriv )(GLenum target, GLenum pname, GLint *params);
+void ( * qglHint )(GLenum target, GLenum mode);
+void ( * qglIndexedTriToStrip )(GLsizei count, const GLushort *indices);
+void ( * qglIndexMask )(GLuint mask);
+void ( * qglIndexPointer )(GLenum type, GLsizei stride, const GLvoid *pointer);
+void ( * qglIndexd )(GLdouble c);
+void ( * qglIndexdv )(const GLdouble *c);
+void ( * qglIndexf )(GLfloat c);
+void ( * qglIndexfv )(const GLfloat *c);
+void ( * qglIndexi )(GLint c);
+void ( * qglIndexiv )(const GLint *c);
+void ( * qglIndexs )(GLshort c);
+void ( * qglIndexsv )(const GLshort *c);
+void ( * qglIndexub )(GLubyte c);
+void ( * qglIndexubv )(const GLubyte *c);
+void ( * qglInitNames )(void);
+void ( * qglInterleavedArrays )(GLenum format, GLsizei stride, const GLvoid *pointer);
+GLboolean ( * qglIsEnabled )(GLenum cap);
+GLboolean ( * qglIsList )(GLuint lnum);
+GLboolean ( * qglIsTexture )(GLuint texture);
+void ( * qglLightModelf )(GLenum pname, GLfloat param);
+void ( * qglLightModelfv )(GLenum pname, const GLfloat *params);
+void ( * qglLightModeli )(GLenum pname, GLint param);
+void ( * qglLightModeliv )(GLenum pname, const GLint *params);
+void ( * qglLightf )(GLenum light, GLenum pname, GLfloat param);
+void ( * qglLightfv )(GLenum light, GLenum pname, const GLfloat *params);
+void ( * qglLighti )(GLenum light, GLenum pname, GLint param);
+void ( * qglLightiv )(GLenum light, GLenum pname, const GLint *params);
+void ( * qglLineStipple )(GLint factor, GLushort pattern);
+void ( * qglLineWidth )(GLfloat width);
+void ( * qglListBase )(GLuint base);
+void ( * qglLoadIdentity )(void);
+void ( * qglLoadMatrixd )(const GLdouble *m);
+void ( * qglLoadMatrixf )(const GLfloat *m);
+void ( * qglLoadName )(GLuint name);
+void ( * qglLogicOp )(GLenum opcode);
+void ( * qglMap1d )(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points);
+void ( * qglMap1f )(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points);
+void ( * qglMap2d )(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points);
+void ( * qglMap2f )(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points);
+void ( * qglMapGrid1d )(GLint un, GLdouble u1, GLdouble u2);
+void ( * qglMapGrid1f )(GLint un, GLfloat u1, GLfloat u2);
+void ( * qglMapGrid2d )(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2);
+void ( * qglMapGrid2f )(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2);
+void ( * qglMaterialf )(GLenum face, GLenum pname, GLfloat param);
+void ( * qglMaterialfv )(GLenum face, GLenum pname, const GLfloat *params);
+void ( * qglMateriali )(GLenum face, GLenum pname, GLint param);
+void ( * qglMaterialiv )(GLenum face, GLenum pname, const GLint *params);
+void ( * qglMatrixMode )(GLenum mode);
+void ( * qglMultMatrixd )(const GLdouble *m);
+void ( * qglMultMatrixf )(const GLfloat *m);
+void ( * qglNewList )(GLuint lnum, GLenum mode);
+void ( * qglNormal3b )(GLbyte nx, GLbyte ny, GLbyte nz);
+void ( * qglNormal3bv )(const GLbyte *v);
+void ( * qglNormal3d )(GLdouble nx, GLdouble ny, GLdouble nz);
+void ( * qglNormal3dv )(const GLdouble *v);
+void ( * qglNormal3f )(GLfloat nx, GLfloat ny, GLfloat nz);
+void ( * qglNormal3fv )(const GLfloat *v);
+void ( * qglNormal3i )(GLint nx, GLint ny, GLint nz);
+void ( * qglNormal3iv )(const GLint *v);
+void ( * qglNormal3s )(GLshort nx, GLshort ny, GLshort nz);
+void ( * qglNormal3sv )(const GLshort *v);
+void ( * qglNormalPointer )(GLenum type, GLsizei stride, const GLvoid *pointer);
+void ( * qglOrtho )(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
+void ( * qglPassThrough )(GLfloat token);
+void ( * qglPixelMapfv )(GLenum gmap, GLsizei mapsize, const GLfloat *values);
+void ( * qglPixelMapuiv )(GLenum gmap, GLsizei mapsize, const GLuint *values);
+void ( * qglPixelMapusv )(GLenum gmap, GLsizei mapsize, const GLushort *values);
+void ( * qglPixelStoref )(GLenum pname, GLfloat param);
+void ( * qglPixelStorei )(GLenum pname, GLint param);
+void ( * qglPixelTransferf )(GLenum pname, GLfloat param);
+void ( * qglPixelTransferi )(GLenum pname, GLint param);
+void ( * qglPixelZoom )(GLfloat xfactor, GLfloat yfactor);
+void ( * qglPointSize )(GLfloat size);
+void ( * qglPolygonMode )(GLenum face, GLenum mode);
+void ( * qglPolygonOffset )(GLfloat factor, GLfloat units);
+void ( * qglPolygonStipple )(const GLubyte *mask);
+void ( * qglPopAttrib )(void);
+void ( * qglPopClientAttrib )(void);
+void ( * qglPopMatrix )(void);
+void ( * qglPopName )(void);
+void ( * qglPrioritizeTextures )(GLsizei n, const GLuint *textures, const GLclampf *priorities);
+void ( * qglPushAttrib )(GLbitfield mask);
+void ( * qglPushClientAttrib )(GLbitfield mask);
+void ( * qglPushMatrix )(void);
+void ( * qglPushName )(GLuint name);
+void ( * qglRasterPos2d )(GLdouble x, GLdouble y);
+void ( * qglRasterPos2dv )(const GLdouble *v);
+void ( * qglRasterPos2f )(GLfloat x, GLfloat y);
+void ( * qglRasterPos2fv )(const GLfloat *v);
+void ( * qglRasterPos2i )(GLint x, GLint y);
+void ( * qglRasterPos2iv )(const GLint *v);
+void ( * qglRasterPos2s )(GLshort x, GLshort y);
+void ( * qglRasterPos2sv )(const GLshort *v);
+void ( * qglRasterPos3d )(GLdouble x, GLdouble y, GLdouble z);
+void ( * qglRasterPos3dv )(const GLdouble *v);
+void ( * qglRasterPos3f )(GLfloat x, GLfloat y, GLfloat z);
+void ( * qglRasterPos3fv )(const GLfloat *v);
+void ( * qglRasterPos3i )(GLint x, GLint y, GLint z);
+void ( * qglRasterPos3iv )(const GLint *v);
+void ( * qglRasterPos3s )(GLshort x, GLshort y, GLshort z);
+void ( * qglRasterPos3sv )(const GLshort *v);
+void ( * qglRasterPos4d )(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+void ( * qglRasterPos4dv )(const GLdouble *v);
+void ( * qglRasterPos4f )(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+void ( * qglRasterPos4fv )(const GLfloat *v);
+void ( * qglRasterPos4i )(GLint x, GLint y, GLint z, GLint w);
+void ( * qglRasterPos4iv )(const GLint *v);
+void ( * qglRasterPos4s )(GLshort x, GLshort y, GLshort z, GLshort w);
+void ( * qglRasterPos4sv )(const GLshort *v);
+void ( * qglReadBuffer )(GLenum mode);
+void ( * qglReadPixels )(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei twidth, GLsizei theight, GLvoid *pixels);
+void ( * qglCopyBackBufferToTexEXT )(float width, float height, float u1, float v1, float u2, float v2);
+void ( * qglCopyBackBufferToTex )(void);
+void ( * qglRectd )(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2);
+void ( * qglRectdv )(const GLdouble *v1, const GLdouble *v2);
+void ( * qglRectf )(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2);
+void ( * qglRectfv )(const GLfloat *v1, const GLfloat *v2);
+void ( * qglRecti )(GLint x1, GLint y1, GLint x2, GLint y2);
+void ( * qglRectiv )(const GLint *v1, const GLint *v2);
+void ( * qglRects )(GLshort x1, GLshort y1, GLshort x2, GLshort y2);
+void ( * qglRectsv )(const GLshort *v1, const GLshort *v2);
+GLint ( * qglRenderMode )(GLenum mode);
+void ( * qglRotated )(GLdouble angle, GLdouble x, GLdouble y, GLdouble z);
+void ( * qglRotatef )(GLfloat angle, GLfloat x, GLfloat y, GLfloat z);
+void ( * qglScaled )(GLdouble x, GLdouble y, GLdouble z);
+void ( * qglScalef )(GLfloat x, GLfloat y, GLfloat z);
+void ( * qglScissor )(GLint x, GLint y, GLsizei width, GLsizei height);
+void ( * qglSelectBuffer )(GLsizei size, GLuint *buffer);
+void ( * qglShadeModel )(GLenum mode);
+void ( * qglStencilFunc )(GLenum func, GLint ref, GLuint mask);
+void ( * qglStencilMask )(GLuint mask);
+void ( * qglStencilOp )(GLenum fail, GLenum zfail, GLenum zpass);
+void ( * qglTexCoord1d )(GLdouble s);
+void ( * qglTexCoord1dv )(const GLdouble *v);
+void ( * qglTexCoord1f )(GLfloat s);
+void ( * qglTexCoord1fv )(const GLfloat *v);
+void ( * qglTexCoord1i )(GLint s);
+void ( * qglTexCoord1iv )(const GLint *v);
+void ( * qglTexCoord1s )(GLshort s);
+void ( * qglTexCoord1sv )(const GLshort *v);
+void ( * qglTexCoord2d )(GLdouble s, GLdouble t);
+void ( * qglTexCoord2dv )(const GLdouble *v);
+void ( * qglTexCoord2f )(GLfloat s, GLfloat t);
+void ( * qglTexCoord2fv )(const GLfloat *v);
+void ( * qglTexCoord2i )(GLint s, GLint t);
+void ( * qglTexCoord2iv )(const GLint *v);
+void ( * qglTexCoord2s )(GLshort s, GLshort t);
+void ( * qglTexCoord2sv )(const GLshort *v);
+void ( * qglTexCoord3d )(GLdouble s, GLdouble t, GLdouble r);
+void ( * qglTexCoord3dv )(const GLdouble *v);
+void ( * qglTexCoord3f )(GLfloat s, GLfloat t, GLfloat r);
+void ( * qglTexCoord3fv )(const GLfloat *v);
+void ( * qglTexCoord3i )(GLint s, GLint t, GLint r);
+void ( * qglTexCoord3iv )(const GLint *v);
+void ( * qglTexCoord3s )(GLshort s, GLshort t, GLshort r);
+void ( * qglTexCoord3sv )(const GLshort *v);
+void ( * qglTexCoord4d )(GLdouble s, GLdouble t, GLdouble r, GLdouble q);
+void ( * qglTexCoord4dv )(const GLdouble *v);
+void ( * qglTexCoord4f )(GLfloat s, GLfloat t, GLfloat r, GLfloat q);
+void ( * qglTexCoord4fv )(const GLfloat *v);
+void ( * qglTexCoord4i )(GLint s, GLint t, GLint r, GLint q);
+void ( * qglTexCoord4iv )(const GLint *v);
+void ( * qglTexCoord4s )(GLshort s, GLshort t, GLshort r, GLshort q);
+void ( * qglTexCoord4sv )(const GLshort *v);
+void ( * qglTexCoordPointer )(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
+void ( * qglTexEnvf )(GLenum target, GLenum pname, GLfloat param);
+void ( * qglTexEnvfv )(GLenum target, GLenum pname, const GLfloat *params);
+void ( * qglTexEnvi )(GLenum target, GLenum pname, GLint param);
+void ( * qglTexEnviv )(GLenum target, GLenum pname, const GLint *params);
+void ( * qglTexGend )(GLenum coord, GLenum pname, GLdouble param);
+void ( * qglTexGendv )(GLenum coord, GLenum pname, const GLdouble *params);
+void ( * qglTexGenf )(GLenum coord, GLenum pname, GLfloat param);
+void ( * qglTexGenfv )(GLenum coord, GLenum pname, const GLfloat *params);
+void ( * qglTexGeni )(GLenum coord, GLenum pname, GLint param);
+void ( * qglTexGeniv )(GLenum coord, GLenum pname, const GLint *params);
+void ( * qglTexImage1D )(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
+void ( * qglTexImage2D )(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
+void ( * qglTexImage2DEXT )(GLenum target, GLint level, GLint numlevels, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
+void ( * qglTexParameterf )(GLenum target, GLenum pname, GLfloat param);
+void ( * qglTexParameterfv )(GLenum target, GLenum pname, const GLfloat *params);
+void ( * qglTexParameteri )(GLenum target, GLenum pname, GLint param);
+void ( * qglTexParameteriv )(GLenum target, GLenum pname, const GLint *params);
+void ( * qglTexSubImage1D )(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels);
+void ( * qglTexSubImage2D )(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
+void ( * qglTranslated )(GLdouble x, GLdouble y, GLdouble z);
+void ( * qglTranslatef )(GLfloat x, GLfloat y, GLfloat z);
+void ( * qglVertex2d )(GLdouble x, GLdouble y);
+void ( * qglVertex2dv )(const GLdouble *v);
+void ( * qglVertex2f )(GLfloat x, GLfloat y);
+void ( * qglVertex2fv )(const GLfloat *v);
+void ( * qglVertex2i )(GLint x, GLint y);
+void ( * qglVertex2iv )(const GLint *v);
+void ( * qglVertex2s )(GLshort x, GLshort y);
+void ( * qglVertex2sv )(const GLshort *v);
+void ( * qglVertex3d )(GLdouble x, GLdouble y, GLdouble z);
+void ( * qglVertex3dv )(const GLdouble *v);
+void ( * qglVertex3f )(GLfloat x, GLfloat y, GLfloat z);
+void ( * qglVertex3fv )(const GLfloat *v);
+void ( * qglVertex3i )(GLint x, GLint y, GLint z);
+void ( * qglVertex3iv )(const GLint *v);
+void ( * qglVertex3s )(GLshort x, GLshort y, GLshort z);
+void ( * qglVertex3sv )(const GLshort *v);
+void ( * qglVertex4d )(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+void ( * qglVertex4dv )(const GLdouble *v);
+void ( * qglVertex4f )(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+void ( * qglVertex4fv )(const GLfloat *v);
+void ( * qglVertex4i )(GLint x, GLint y, GLint z, GLint w);
+void ( * qglVertex4iv )(const GLint *v);
+void ( * qglVertex4s )(GLshort x, GLshort y, GLshort z, GLshort w);
+void ( * qglVertex4sv )(const GLshort *v);
+void ( * qglVertexPointer )(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
+void ( * qglViewport )(GLint x, GLint y, GLsizei width, GLsizei height);
+
+#if 0
+void ( * qglMultiTexCoord2fARB )( GLenum texture, GLfloat s, GLfloat t );
+void ( * qglActiveTextureARB )( GLenum texture );
+void ( * qglClientActiveTextureARB )( GLenum texture );
+#endif
+
+
+
+#ifdef _WINDOWS
+static bool surfaceToBMP(LPDIRECT3DDEVICE8 pd3dDevice, LPDIRECT3DSURFACE8 lpSurface, const char *fname)
+{
+	DWORD outpixel;
+	BITMAPFILEHEADER fh;
+	BITMAPINFOHEADER bi;
+	int outbyte, BufferIndex, width, height, pitch;
+	char *WriteBuffer;
+	FILE *file;
+	HRESULT Error;
+	IDirect3DSurface8 *pTempSurf = NULL;
+
+	// Get the surface description first
+	D3DSURFACE_DESC ddsd;
+	D3DLOCKED_RECT lrSurf;
+	
+	Error = lpSurface->GetDesc(&ddsd);
+	// This writes out 32 bit values, so whatever surface format we were passed in,
+	// copy it into a 32 bit surface
+	Error = pd3dDevice->CreateImageSurface(ddsd.Width, ddsd.Height, D3DFMT_A8R8G8B8, &pTempSurf);
+
+	Error = D3DXLoadSurfaceFromSurface(pTempSurf, NULL, NULL, lpSurface, NULL, NULL, D3DX_DEFAULT, 0);
+
+	file = fopen(fname, "wb");
+	if(!file)
+		return FALSE;
+
+	Error = pTempSurf->LockRect(&lrSurf, NULL, 0);
+
+	BufferIndex = 0;
+	width = ddsd.Width;
+	height = ddsd.Height;
+	pitch = lrSurf.Pitch;
+	WriteBuffer = new char[width * height * 3];
+
+	// Setup the file headers
+	((char*)&(fh.bfType))[0] = 'B';
+	((char*)&(fh.bfType))[1] = 'M';
+	fh.bfSize = (long)(sizeof(BITMAPINFOHEADER) + sizeof(BITMAPFILEHEADER) + width * height * 3);
+	fh.bfReserved1 = 0;
+	fh.bfReserved2 = 0;
+	fh.bfOffBits = sizeof(BITMAPINFOHEADER) + sizeof(BITMAPFILEHEADER);
+	bi.biSize = sizeof(BITMAPINFOHEADER);
+	bi.biWidth = width;
+	bi.biHeight = height;
+	bi.biPlanes = 1;
+	bi.biBitCount = 24;
+	bi.biCompression = BI_RGB;
+	bi.biSizeImage = 0;
+	bi.biXPelsPerMeter = 10000;
+	bi.biYPelsPerMeter = 10000;
+	bi.biClrUsed = 0;
+	bi.biClrImportant = 0;
+
+	fwrite(&fh, sizeof(BITMAPFILEHEADER), 1, file);
+	fwrite(&bi, sizeof(BITMAPINFOHEADER), 1, file);
+
+	char *Bitmap_in = (char*)lrSurf.pBits;
+
+	for(int y = height - 1; y >= 0; y--) 
+	{
+		for(int x = 0; x < width; x++)
+		{
+			outpixel = *((DWORD *)(Bitmap_in + x * 4 + y * pitch)); //Load a word
+
+			//Load up the Blue component and output it
+			outbyte = (((outpixel)&0x000000ff));//blue
+			WriteBuffer [BufferIndex++] = outbyte;
+
+			//Load up the green component and output it 
+			outbyte = (((outpixel>>8)&0x000000ff)); 
+			WriteBuffer [BufferIndex++] = outbyte;
+
+			//Load up the red component and output it 
+			outbyte = (((outpixel>>16)&0x000000ff));
+			WriteBuffer [BufferIndex++] = outbyte;
+		}
+	}
+
+	//At this point the buffer should be full, so just write it out
+	fwrite(WriteBuffer, BufferIndex, 1, file);
+
+	//Now unlock the surface and we're done
+	pTempSurf->UnlockRect();
+	pTempSurf->Release();
+
+	fclose(file);
+
+	delete [] WriteBuffer;
+	return true;
+}
+#endif
+
+/*
+=================
+_fixupScreenCoords
+
+Clamp coords to screen dimensions and fix Y direction.
+=================
+*/
+static void _fixupScreenCoords(GLint& x, GLint& y, GLsizei& width, GLsizei& height)
+{
+	if (x < 0) x = 0;
+	else if (x > glConfig.vidWidth) x = glConfig.vidWidth;
+	if (y < 0) y = 0;
+	else if (y > glConfig.vidHeight) y = glConfig.vidHeight;
+	
+	if (width < 0) width = 0;
+//	else if (x + width > glConfig.vidWidth) width = glConfig.vidWidth - x;
+	if (height < 0) height = 0;
+	else if (y + height > glConfig.vidHeight) height = glConfig.vidHeight - y;
+
+	// GL and DX disagree on the direction of Y
+	y = glConfig.vidHeight - (y + height);
+}
+
+
+/*
+=================
+_convertCompare
+
+Convert GL compare function to DX function.
+=================
+*/
+static D3DCMPFUNC _convertCompare(GLenum func)
+{
+	switch (func)
+	{
+	case GL_NEVER: return D3DCMP_NEVER;
+	case GL_LESS: return D3DCMP_LESS;
+	case GL_EQUAL: return D3DCMP_EQUAL;
+	case GL_LEQUAL: return D3DCMP_LESSEQUAL;
+	case GL_GREATER: return D3DCMP_GREATER;
+	case GL_NOTEQUAL: return D3DCMP_NOTEQUAL;
+	case GL_GEQUAL: return D3DCMP_GREATEREQUAL;
+	default: case GL_ALWAYS: return D3DCMP_ALWAYS;
+	}
+}
+
+
+/*
+=================
+_convertBlendFactor
+
+Convert GL blend mode to DX blend mode.
+=================
+*/
+static D3DBLEND _convertBlendFactor(GLenum factor)
+{
+	switch (factor)
+	{
+	case GL_ZERO: return D3DBLEND_ZERO;
+	default: case GL_ONE: return D3DBLEND_ONE;
+	case GL_SRC_COLOR: return D3DBLEND_SRCCOLOR;
+	case GL_ONE_MINUS_SRC_COLOR: return D3DBLEND_INVSRCCOLOR;
+	case GL_SRC_ALPHA: return D3DBLEND_SRCALPHA;
+	case GL_ONE_MINUS_SRC_ALPHA: return D3DBLEND_INVSRCALPHA;
+	case GL_DST_COLOR: return D3DBLEND_DESTCOLOR;
+	case GL_ONE_MINUS_DST_COLOR: return D3DBLEND_INVDESTCOLOR;
+	case GL_DST_ALPHA: return D3DBLEND_DESTALPHA;
+	case GL_ONE_MINUS_DST_ALPHA: return D3DBLEND_INVDESTALPHA;
+	case GL_SRC_ALPHA_SATURATE: return D3DBLEND_SRCALPHASAT;
+	}
+}
+
+
+/*
+=================
+_convertPrimMode
+
+Convert GL primitive mode to DX primitive mode.
+=================
+*/
+static D3DPRIMITIVETYPE _convertPrimMode(GLenum mode)
+{
+	switch (mode)
+	{
+	case GL_POINTS: return D3DPT_POINTLIST;
+	case GL_LINES: return D3DPT_LINELIST;
+	case GL_LINE_STRIP: return D3DPT_LINESTRIP;
+	case GL_TRIANGLES: return D3DPT_TRIANGLELIST;
+	case GL_TRIANGLE_STRIP: return D3DPT_TRIANGLESTRIP;
+	case GL_TRIANGLE_FAN: return D3DPT_TRIANGLEFAN;
+#ifdef _XBOX
+	case GL_QUADS: return D3DPT_QUADLIST;
+	case GL_QUAD_STRIP: return D3DPT_QUADSTRIP;
+#else
+	case GL_QUADS: return D3DPT_TRIANGLELIST;
+	case GL_QUAD_STRIP: return D3DPT_TRIANGLESTRIP;
+#endif
+	case GL_POLYGON: return D3DPT_TRIANGLEFAN;
+	default: assert(0); return D3DPT_TRIANGLEFAN;
+	}
+}
+
+
+/*
+=================
+_updateDrawStride
+
+Update the stride of the draw array based on
+the number of vertex attributes.  The stride
+is in DWORDs.
+=================
+*/
+static void _updateDrawStride(GLint normal, GLint tex0, GLint tex1)
+{
+	glw_state->drawStride = 4;
+	if (normal) glw_state->drawStride += 3;
+	if (tex0) glw_state->drawStride += 2;
+	if (tex1) glw_state->drawStride += 2;
+}
+
+
+/*
+=================
+_updateShader
+
+Set the vertex shader based on the number
+of texture coordinates.
+=================
+*/
+static void _updateShader(bool normal, bool tex0, bool tex1)//, bool tex2, bool tex3)
+{
+	DWORD mask = D3DFVF_XYZ;
+	if (normal) mask |= D3DFVF_NORMAL;
+	mask |= D3DFVF_DIFFUSE;
+	if (tex0 && !tex1) mask |= D3DFVF_TEX1;
+	else if (tex1) mask |= D3DFVF_TEX2;
+
+//	if (mask != glw_state->shaderMask)
+//	{
+		glw_state->device->SetVertexShader(mask);
+		glw_state->shaderMask = mask;
+//	}
+}
+
+
+/*
+=================
+_getCurrentTexture
+
+Get the texture information for the currently
+bound texture at a stage.
+=================
+*/
+static glwstate_t::TextureInfo* _getCurrentTexture(int stage)
+{
+	glwstate_t::texturexlat_t::iterator i = glw_state->textureXlat.find(
+		glw_state->currentTexture[stage]);
+
+	if (i == glw_state->textureXlat.end()) return NULL;
+	else return &i->second;
+}
+
+/*
+=================
+_updateTextures
+
+Setup texture stages with color operations, filters
+and wrapping modes as needed.
+=================
+*/
+static void _updateTextures(void)
+{
+	for (int t = 0; t < GLW_MAX_TEXTURE_STAGES; ++t)
+	{
+		if (glw_state->textureStageDirty[t])
+		{
+			glw_state->textureStageDirty[t] = false;
+
+			if (glw_state->textureStageEnable[t] && glw_state->currentTexture[t])
+			{
+				glwstate_t::TextureInfo* info = _getCurrentTexture(t);
+				if (!info) continue;
+
+				glw_state->device->SetTexture(t, info->mipmap);
+				glw_state->device->SetTextureStageState(t, D3DTSS_COLOROP, glw_state->textureEnv[t]);
+
+				glw_state->device->SetTextureStageState(t, D3DTSS_COLORARG1, 
+						D3DTA_TEXTURE);
+				glw_state->device->SetTextureStageState(t, D3DTSS_COLORARG2, 
+						D3DTA_CURRENT);
+				glw_state->device->SetTextureStageState(t, D3DTSS_ALPHAOP, 
+						glw_state->textureEnv[t]);
+				glw_state->device->SetTextureStageState(t, D3DTSS_ALPHAARG1, 
+						D3DTA_TEXTURE);
+				glw_state->device->SetTextureStageState(t, D3DTSS_ALPHAARG2, 
+						D3DTA_CURRENT);
+
+				glw_state->device->SetTextureStageState(t, D3DTSS_MAXANISOTROPY, 
+					info->anisotropy);
+				glw_state->device->SetTextureStageState(t, D3DTSS_MINFILTER, 
+					info->minFilter);
+				glw_state->device->SetTextureStageState(t, D3DTSS_MIPFILTER, 
+					info->mipFilter);
+				glw_state->device->SetTextureStageState(t, D3DTSS_MAGFILTER, 
+					info->magFilter);
+
+				glw_state->device->SetTextureStageState(t, D3DTSS_ADDRESSU, 
+					info->wrapU);
+				glw_state->device->SetTextureStageState(t, D3DTSS_ADDRESSV, 
+					info->wrapV);
+
+				glw_state->device->SetTextureStageState(t, D3DTSS_TEXCOORDINDEX, t);
+
+				glw_state->device->SetTextureStageState( t, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT2 );
+
+				if(tess.shader)
+				{
+					if(tess.currentPass < tess.shader->numUnfoggedPasses)
+					{ 
+						if(tess.shader->stages[tess.currentPass].isEnvironment)
+						{
+							glw_state->device->SetTextureStageState(t, D3DTSS_TEXCOORDINDEX, t | D3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR);
+						}
+					}
+				}				
+			}
+			else
+			{
+				glw_state->device->SetTexture(t, NULL);
+				glw_state->device->SetTextureStageState(t, D3DTSS_COLOROP, D3DTOP_DISABLE);
+				glw_state->device->SetTextureStageState(t, D3DTSS_ALPHAOP, D3DTOP_DISABLE);
+			}
+		}
+		else
+		{
+			// Hard-wired check for turning on hardware environment mapping
+			if( glw_state->textureStageEnable[t] &&
+				glw_state->currentTexture[t] &&
+				tess.shader &&
+				tess.currentPass < tess.shader->numUnfoggedPasses &&
+				tess.shader->stages[tess.currentPass].isEnvironment)
+			{
+					glw_state->device->SetTextureStageState(t, D3DTSS_TEXCOORDINDEX, t | D3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR);
+			}
+		}
+	}
+}
+
+
+/*
+=================
+_updateMatrices
+
+Set the current projection and view transforms to
+the matrices at the top of the relevant stacks.
+=================
+*/
+static void _updateMatrices(void)
+{
+	if(glw_state->matricesDirty[glwstate_t::MatrixMode_Projection])
+	{
+		glw_state->device->SetTransform(D3DTS_PROJECTION, 
+			glw_state->matrixStack[glwstate_t::MatrixMode_Projection]->GetTop());
+
+		glw_state->matricesDirty[glwstate_t::MatrixMode_Projection] = false;
+	}
+
+	if(glw_state->matricesDirty[glwstate_t::MatrixMode_Model])
+	{
+		glw_state->device->SetTransform(D3DTS_VIEW, 
+			glw_state->matrixStack[glwstate_t::MatrixMode_Model]->GetTop());
+
+		glw_state->matricesDirty[glwstate_t::MatrixMode_Model] = false;
+	}
+
+	if(glw_state->matricesDirty[glwstate_t::MatrixMode_Texture0])
+	{
+		glw_state->device->SetTransform(D3DTS_TEXTURE0,
+			glw_state->matrixStack[glwstate_t::MatrixMode_Texture0]->GetTop());
+
+		glw_state->matricesDirty[glwstate_t::MatrixMode_Texture0] = false;
+	}
+
+	if(glw_state->matricesDirty[glwstate_t::MatrixMode_Texture1])
+	{
+		glw_state->device->SetTransform(D3DTS_TEXTURE1,
+			glw_state->matrixStack[glwstate_t::MatrixMode_Texture1]->GetTop());
+
+		glw_state->matricesDirty[glwstate_t::MatrixMode_Texture1] = false;
+	}
+}
+
+
+/*
+=================
+_getMaxVerts
+
+Calculate the maximum number of verts to draw
+given a total number to draw, stride and max
+packet size.
+=================
+*/
+static int _getMaxVerts(void)
+{
+	int max = glw_state->totalVertices;
+	if (max > GLW_MAX_DRAW_PACKET_SIZE / glw_state->drawStride)
+	{
+		max = GLW_MAX_DRAW_PACKET_SIZE / glw_state->drawStride;
+	}
+	return max;
+}
+
+static int _getMaxIndices(void)
+{
+	int max = glw_state->totalIndices;
+	if(max > 1022)
+		max = 1022;
+
+	return max;
+}
+
+#ifdef _XBOX
+/*
+=================
+_restartDrawPacket
+
+Encode a new draw packet header into the draw array.
+=================
+*/
+inline static DWORD* _restartDrawPacket(DWORD* packet, int verts)
+{
+	packet[0] = D3DPUSH_ENCODE(D3DPUSH_SET_BEGIN_END, 1);
+	packet[1] = glw_state->primitiveMode;
+	packet[2] = D3DPUSH_ENCODE(
+		D3DPUSH_NOINCREMENT_FLAG|D3DPUSH_INLINE_ARRAY, 
+		glw_state->drawStride * verts);
+	return packet + 3;
+}
+
+/*
+=================
+_terminateDrawPacket
+
+Finish up the last draw packet.
+=================
+*/
+inline static DWORD* _terminateDrawPacket(DWORD* packet)
+{
+	packet[0] = D3DPUSH_ENCODE(D3DPUSH_SET_BEGIN_END, 1);
+	packet[1] = 0;
+	return packet + 2;
+}
+
+#define CMD_DRAW_INDEX_BATCH 0x1800
+inline static DWORD* _restartIndexPacket(DWORD* packet, int numIndices)
+{
+	packet[0] = D3DPUSH_ENCODE(D3DPUSH_SET_BEGIN_END, 1);
+	packet[1] = glw_state->primitiveMode;
+	packet[2] = D3DPUSH_ENCODE(	D3DPUSH_NOINCREMENT_FLAG | CMD_DRAW_INDEX_BATCH, numIndices / 2 );
+	return packet + 3;
+}
+
+inline static DWORD* _terminateIndexPacket(DWORD* packet)
+{
+	packet[0] = D3DPUSH_ENCODE(D3DPUSH_SET_BEGIN_END, 1);
+	packet[1] = 0;
+	return packet + 2;
+}
+
+/*
+=================
+_handleDrawOverflow
+
+Prevent a draw packet from getting too
+big for the hardware by restarting it as needed.
+=================
+*/
+static void _handleDrawOverflow(void)
+{
+	if (glw_state->numVertices >= glw_state->maxVertices)
+	{
+		glw_state->drawArray += glw_state->numVertices *
+			glw_state->drawStride;
+		
+		glw_state->totalVertices -= glw_state->numVertices;
+		glw_state->maxVertices = _getMaxVerts();
+		glw_state->numVertices = 0;
+
+		glw_state->drawArray = _restartDrawPacket(
+			glw_state->drawArray, glw_state->maxVertices);
+	}
+}
+#else _XBOX
+inline static DWORD* _restartDrawPacket(DWORD* packet, int verts)
+{
+	return packet;
+}
+
+inline static DWORD* _terminateDrawPacket(DWORD* packet)
+{
+	return packet;
+}
+
+static void _handleDrawOverflow(void)
+{
+}
+#endif _XBOX
+
+
+/*
+=================
+_vertexElement
+
+Copy position information from the source vertex
+array into a draw array.
+=================
+*/
+#define _vertexElement(push, i)									\
+{																\
+	DWORD* vert = (DWORD*)((BYTE*)glw_state->vertexPointer +	\
+		(i) * glw_state->vertexStride);							\
+	(push)[0] = vert[0];										\
+	(push)[1] = vert[1];										\
+	(push)[2] = vert[2];										\
+}
+
+/*
+=================
+_colorElement
+
+Copy color information from the source color
+array into a draw array.
+=================
+*/
+#define _colorElement(push, i)									\
+{																\
+	DWORD col = *(DWORD*)((BYTE*)glw_state->colorPointer +		\
+		(i) * glw_state->colorStride);							\
+	(push)[0] =													\
+		((col & 0xFF000000) >> 0) |								\
+		((col & 0x00FF0000) >> 16) |							\
+		((col & 0x0000FF00) << 0) |								\
+		((col & 0x000000FF) << 16);								\
+}
+
+/*
+=================
+_texCoordElement
+
+Copy tex coord information from the source tex coord
+array into a draw array.
+=================
+*/
+#define _texCoordElement(push, i, t)							\
+{																\
+	DWORD* tc = (DWORD*)((BYTE*)glw_state->texCoordPointer[t] +	\
+		(i) * glw_state->texCoordStride[t]);					\
+	(push)[0] = tc[0];											\
+	(push)[1] = tc[1];											\
+}
+
+/*
+=================
+_normalElement
+
+  Copy normal information from the source normal
+  array into a draw array
+=================
+*/
+#define _normalElement(push, i)									\
+{																\
+	DWORD* norm = (DWORD*)((BYTE*)glw_state->normalPointer +	\
+		(i) * glw_state->normalStride);							\
+	(push)[0] = norm[0];										\
+	(push)[1] = norm[1];										\
+	(push)[2] = norm[2];										\
+}
+
+				
+#define _tangentElement(push, i)								\
+{																\
+	DWORD* tang = (DWORD*)((BYTE*)&tess.tangent[i]);				\
+	(push)[0] = tang[0];										\
+	(push)[1] = tang[1];										\
+	(push)[2] = tang[2];										\
+}
+
+
+
+/*
+=========================================================
+FAST INDEXED GEOMETRY DRAW LOOPS
+
+Used by core draw routines to quickly copy
+geometry from various source arrays to main
+draw array.
+=========================================================
+*/
+static void _drawElementsV(GLsizei count, const GLushort* indices)
+{
+	DWORD* push = glw_state->drawArray;
+	for (int i = 0; i < count; ++i)
+	{
+		_vertexElement(&push[0], indices[i]);
+		push[3] = glw_state->currentColor;
+		push += 4;
+	}
+}
+
+static void _drawElementsVN(GLsizei count, const GLushort* indices)
+{
+	DWORD* push = glw_state->drawArray;
+	for (int i = 0; i < count; ++i)
+	{
+		_vertexElement(&push[0], indices[i]);
+		_normalElement(&push[3], indices[i]);
+		push[6] = glw_state->currentColor;
+		push += 7;
+	}
+}
+
+static void _drawElementsVC(GLsizei count, const GLushort* indices)
+{
+	DWORD* push = glw_state->drawArray;
+	for (int i = 0; i < count; ++i)
+	{
+		_vertexElement(&push[0], indices[i]);
+		_colorElement(&push[3], indices[i]);
+		push += 4;
+	}
+}
+
+static void _drawElementsVCN(GLsizei count, const GLushort* indices)
+{
+	DWORD* push = glw_state->drawArray;
+	for (int i = 0; i < count; ++i)
+	{
+		_vertexElement(&push[0], indices[i]);
+		_normalElement(&push[3], indices[i]);
+		_colorElement(&push[6], indices[i]);
+		push += 7;
+	}
+}
+
+static void _drawElementsVCT(GLsizei count, const GLushort* indices)
+{
+	DWORD* push = glw_state->drawArray;
+	for (int i = 0; i < count; ++i)
+	{
+		_vertexElement(&push[0], indices[i]);
+		_colorElement(&push[3], indices[i]);
+		_texCoordElement(&push[4], indices[i], 0);
+		push += 6;
+	}
+}
+
+static void _drawElementsVCNT(GLsizei count, const GLushort* indices)
+{
+	DWORD* push = glw_state->drawArray;
+	for (int i = 0; i < count; ++i)
+	{
+		_vertexElement(&push[0], indices[i]);
+		_normalElement(&push[3], indices[i]);
+		_colorElement(&push[6], indices[i]);
+		_texCoordElement(&push[7], indices[i], 0);
+		push += 9;
+	}
+}
+
+static void _drawElementsVCTT(GLsizei count, const GLushort* indices)
+{
+	DWORD* push = glw_state->drawArray;
+	for (int i = 0; i < count; ++i)
+	{
+		_vertexElement(&push[0], indices[i]);
+		_colorElement(&push[3], indices[i]);
+		_texCoordElement(&push[4], indices[i], 0);
+		_texCoordElement(&push[6], indices[i], 1);
+		push += 8;
+	}
+}
+
+static void _drawElementsVCNTT(GLsizei count, const GLushort* indices)
+{
+	DWORD* push = glw_state->drawArray;
+	for (int i = 0; i < count; ++i)
+	{
+		_vertexElement(&push[0], indices[i]);
+		_normalElement(&push[3], indices[i]);
+		_colorElement(&push[6], indices[i]);
+		_texCoordElement(&push[7], indices[i], 0);
+		_texCoordElement(&push[9], indices[i], 1);
+		push += 11;
+	}
+}
+
+static void _drawElementsVT(GLsizei count, const GLushort* indices)
+{
+	DWORD* push = glw_state->drawArray;
+	for (int i = 0; i < count; ++i)
+	{
+		_vertexElement(&push[0], indices[i]);
+		push[3] = glw_state->currentColor;
+		_texCoordElement(&push[4], indices[i], 0);
+		push += 6;
+	}
+}
+
+static void _drawElementsVNT(GLsizei count, const GLushort* indices)
+{
+	DWORD* push = glw_state->drawArray;
+	for (int i = 0; i < count; ++i)
+	{
+		_vertexElement(&push[0], indices[i]);
+		_normalElement(&push[3], indices[i]);
+		push[6] = glw_state->currentColor;
+		_texCoordElement(&push[7], indices[i], 0);
+		push += 9;
+	}
+}
+
+static void _drawElementsVTT(GLsizei count, const GLushort* indices)
+{
+	DWORD* push = glw_state->drawArray;
+	for (int i = 0; i < count; ++i)
+	{
+		_vertexElement(&push[0], indices[i]);
+		push[3] = glw_state->currentColor;
+		_texCoordElement(&push[4], indices[i], 0);
+		_texCoordElement(&push[6], indices[i], 1);
+		push += 8;
+	}
+}
+
+static void _drawElementsVNTT(GLsizei count, const GLushort* indices)
+{
+	DWORD* push = glw_state->drawArray;
+	for (int i = 0; i < count; ++i)
+	{
+		_vertexElement(&push[0], indices[i]);
+		_normalElement(&push[3], indices[i]);
+		push[6] = glw_state->currentColor;
+		_texCoordElement(&push[7], indices[i], 0);
+		_texCoordElement(&push[9], indices[i], 1);
+		push += 11;
+	}
+}
+
+
+static void _drawElementsLightShader(GLsizei count, const GLushort* indices)
+{
+	DWORD* push = glw_state->drawArray;
+	for(int i = 0; i < count; ++i)
+	{
+		_vertexElement(&push[0], indices[i]);
+		_normalElement(&push[3], indices[i]);
+		_texCoordElement(&push[6], indices[i], 0);
+		_tangentElement(&push[8], indices[i]);
+		push += 11;
+	}
+}
+
+static void _drawElementsBumpShader(GLsizei count, const GLushort* indices)
+{
+	DWORD* push = glw_state->drawArray;
+	for(int i = 0; i < count; ++i)
+	{
+		_vertexElement(&push[0], indices[i]);
+		_normalElement(&push[3], indices[i]);
+		_texCoordElement(&push[6], indices[i], 0);
+		_texCoordElement(&push[8], indices[i], 1);
+		_tangentElement(&push[10], indices[i]);
+		push += 13;
+	}
+}
+
+static void _drawElementsEnvShader(GLsizei count, const GLushort* indices)
+{
+	DWORD* push = glw_state->drawArray;
+	for(int i = 0; i < count; ++i)
+	{
+		_vertexElement(&push[0], indices[i]);
+		_normalElement(&push[3], indices[i]);
+		push += 6;
+	}
+}
+
+typedef void(*drawelemfunc_t)(GLsizei, const GLushort*);
+static drawelemfunc_t _drawElementFuncTable[12] =
+{
+	_drawElementsV,
+	_drawElementsVN,
+	_drawElementsVT,
+	_drawElementsVNT,
+	_drawElementsVTT,
+	_drawElementsVNTT,
+	_drawElementsVC,
+	_drawElementsVCN,
+	_drawElementsVCT,
+	_drawElementsVCNT,
+	_drawElementsVCTT,
+	_drawElementsVCNTT,
+};
+
+
+
+/*
+=========================================================
+FAST GEOMETRY DRAW LOOPS
+
+Used by core draw routines to quickly copy
+geometry from various source arrays to main
+draw array.
+=========================================================
+*/
+static void _drawArraysV(GLsizei first, GLsizei last)
+{
+	DWORD* push = glw_state->drawArray;
+	for (int i = first; i < last; ++i)
+	{
+		_vertexElement(&push[0], i);
+		push[3] = glw_state->currentColor;
+		push += 4;
+	}
+}
+
+static void _drawArraysVN(GLsizei first, GLsizei last)
+{
+	DWORD* push = glw_state->drawArray;
+	for (int i = first; i < last; ++i)
+	{
+		_vertexElement(&push[0], i);
+		_normalElement(&push[3], i);
+		push[6] = glw_state->currentColor;
+		push += 7;
+	}
+}
+
+static void _drawArraysVC(GLsizei first, GLsizei last)
+{
+	DWORD* push = glw_state->drawArray;
+	for (int i = first; i < last; ++i)
+	{
+		_vertexElement(&push[0], i);
+		_colorElement(&push[3], i);
+		push += 4;
+	}
+}
+
+static void _drawArraysVCN(GLsizei first, GLsizei last)
+{
+	DWORD* push = glw_state->drawArray;
+	for (int i = first; i < last; ++i)
+	{
+		_vertexElement(&push[0], i);
+		_normalElement(&push[3], i);
+		_colorElement(&push[6], i);
+		push += 7;
+	}
+}
+
+static void _drawArraysVCT(GLsizei first, GLsizei last)
+{
+	DWORD* push = glw_state->drawArray;
+	for (int i = first; i < last; ++i)
+	{
+		_vertexElement(&push[0], i);
+		_colorElement(&push[3], i);
+		_texCoordElement(&push[4], i, 0);
+		push += 6;
+	}
+}
+
+static void _drawArraysVCNT(GLsizei first, GLsizei last)
+{
+	DWORD* push = glw_state->drawArray;
+	for (int i = first; i < last; ++i)
+	{
+		_vertexElement(&push[0], i);
+		_normalElement(&push[3], i);
+		_colorElement(&push[6], i);
+		_texCoordElement(&push[7], i, 0);
+		push += 9;
+	}
+}
+
+static void _drawArraysVCTT(GLsizei first, GLsizei last)
+{
+	DWORD* push = glw_state->drawArray;
+	for (int i = first; i < last; ++i)
+	{
+		_vertexElement(&push[0], i);
+		_colorElement(&push[3], i);
+		_texCoordElement(&push[4], i, 0);
+		_texCoordElement(&push[6], i, 1);
+		push += 8;
+	}
+}
+
+static void _drawArraysVCNTT(GLsizei first, GLsizei last)
+{
+	DWORD* push = glw_state->drawArray;
+	for (int i = first; i < last; ++i)
+	{
+		_vertexElement(&push[0], i);
+		_normalElement(&push[3], i);
+		_colorElement(&push[6], i);
+		_texCoordElement(&push[7], i, 0);
+		_texCoordElement(&push[9], i, 1);
+		push += 11;
+	}
+}
+
+static void _drawArraysVT(GLsizei first, GLsizei last)
+{
+	DWORD* push = glw_state->drawArray;
+	for (int i = first; i < last; ++i)
+	{
+		_vertexElement(&push[0], i);
+		push[3] = glw_state->currentColor;
+		_texCoordElement(&push[4], i, 0);
+		push += 6;
+	}
+}
+
+static void _drawArraysVNT(GLsizei first, GLsizei last)
+{
+	DWORD* push = glw_state->drawArray;
+	for (int i = first; i < last; ++i)
+	{
+		_vertexElement(&push[0], i);
+		_normalElement(&push[3], i);
+		push[6] = glw_state->currentColor;
+		_texCoordElement(&push[7], i, 0);
+		push += 9;
+	}
+}
+
+static void _drawArraysVTT(GLsizei first, GLsizei last)
+{
+	DWORD* push = glw_state->drawArray;
+	for (int i = first; i < last; ++i)
+	{
+		_vertexElement(&push[0], i);
+		push[3] = glw_state->currentColor;
+		_texCoordElement(&push[4], i, 0);
+		_texCoordElement(&push[6], i, 1);
+		push += 8;
+	}
+}
+
+static void _drawArraysVNTT(GLsizei first, GLsizei last)
+{
+	DWORD* push = glw_state->drawArray;
+	for (int i = first; i < last; ++i)
+	{
+		_vertexElement(&push[0], i);
+		_normalElement(&push[3], i);
+		push[6] = glw_state->currentColor;
+		_texCoordElement(&push[7], i, 0);
+		_texCoordElement(&push[9], i, 1);
+		push += 11;
+	}
+}
+
+typedef void(*drawarrayfunc_t)(GLsizei, GLsizei);
+static drawarrayfunc_t _drawArrayFuncTable[12] =
+{
+	_drawArraysV,
+	_drawArraysVN,
+	_drawArraysVT,
+	_drawArraysVNT,
+	_drawArraysVTT,
+	_drawArraysVNTT,
+	_drawArraysVC,
+	_drawArraysVCN,
+	_drawArraysVCT,
+	_drawArraysVCNT,
+	_drawArraysVCTT,
+	_drawArraysVCNTT,
+};
+
+
+/*
+=================
+_getDrawFunc
+
+Figure which drawing function we need based on
+what vertex components we have.  Use the returned
+integer to index the draw function tables.
+=================
+*/
+static int _getDrawFunc(void)
+{
+	int func = 0;
+	if (glw_state->colorArrayState) func += 6;
+	if (glw_state->texCoordArrayState[0]) func += 2;
+	if (glw_state->texCoordArrayState[1]) func += 2;
+	if (glw_state->normalArrayState) ++func;
+	return func;
+}
+
+
+static void dllAccum(GLenum op, GLfloat value)
+{
+	assert(false);
+}
+
+static void dllAlphaFunc(GLenum func, GLclampf ref)
+{
+	D3DCMPFUNC f = _convertCompare(func);
+	glw_state->device->SetRenderState(D3DRS_ALPHAFUNC, f);
+	glw_state->device->SetRenderState(D3DRS_ALPHAREF, (DWORD)(ref * 255.));
+}
+
+GLboolean dllAreTexturesResident(GLsizei n, const GLuint *textures, GLboolean *residences)
+{
+	assert(false);
+	return 1;
+}
+
+static void dllArrayElement(GLint i)
+{
+	assert(glw_state->inDrawBlock);
+	
+	_handleDrawOverflow();
+
+	DWORD* push = &glw_state->drawArray[glw_state->numVertices * 
+		glw_state->drawStride];
+
+	_vertexElement(push, i);
+	push += 3;
+	
+	if (glw_state->colorArrayState)
+	{
+		_colorElement(push, i);
+		++push;
+	}
+	else
+	{
+		*push++ = glw_state->currentColor;
+	}
+	
+	for (int t = 0; t < GLW_MAX_TEXTURE_STAGES; ++t)
+	{
+		if (glw_state->texCoordArrayState[t])
+		{
+			_texCoordElement(push, i, t);
+			push += 2;
+		}
+	}
+
+	++glw_state->numVertices;
+}
+
+// EXTENSION: Begin a drawing block with at verts vertices
+static void dllBeginEXT(GLenum mode, GLint verts, GLint colors, GLint normals, GLint tex0, GLint tex1)//, GLint tex2, GLint tex3)
+{
+	assert(!glw_state->inDrawBlock);
+
+	// start the draw block
+	glw_state->inDrawBlock = true;
+	glw_state->primitiveMode = _convertPrimMode(mode);
+
+	// update DX with any pending state changes
+	_updateDrawStride(normals, tex0, tex1);//, tex2, tex3);
+	_updateShader(normals, tex0, tex1);//, tex2, tex3);
+	_updateTextures();
+	_updateMatrices();
+
+	// set vertex counters
+	glw_state->numVertices = 0;
+	glw_state->totalVertices = verts;
+	glw_state->maxVertices = _getMaxVerts();	
+
+#ifdef _XBOX
+	// open a draw packet
+	//int num_packets = ((verts * glw_state->drawStride) / GLW_MAX_DRAW_PACKET_SIZE) + 1;
+	int num_packets;
+	if(glw_state->maxVertices == 0) {
+		num_packets = 1;
+	} else {
+		num_packets = (verts / glw_state->maxVertices) + (!!(verts % glw_state->maxVertices));
+	}
+	int cmd_size = num_packets * 3;
+	int vert_size = glw_state->drawStride * verts;
+	
+	glw_state->device->BeginPush(vert_size + cmd_size + 2, 
+		&glw_state->drawArray);
+	
+	glw_state->drawArray = _restartDrawPacket(
+		glw_state->drawArray, glw_state->maxVertices);
+#endif
+}
+
+static void dllBegin(GLenum mode)
+{
+	assert(0);
+}
+
+// EXTENSION: Start a new drawing frame
+GLboolean dllBeginFrame(void)
+{
+	GLboolean result = glw_state->device->BeginScene() == D3D_OK;
+	return result;
+}
+
+// EXTENSION: Begin shadow draw mode
+static void dllBeginShadow(void)
+{
+	//Intentionally left blank
+}
+
+static void dllBindTexture(GLenum target, GLuint texture)
+{
+	assert(target == GL_TEXTURE_2D);
+
+	if (glw_state->currentTexture[glw_state->serverTU] != texture)
+	{
+		glw_state->currentTexture[glw_state->serverTU] = texture;
+		glw_state->textureStageDirty[glw_state->serverTU] = true;
+	}
+}
+
+static void dllBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap)
+{
+	assert(false);
+}
+
+static void dllBlendFunc(GLenum sfactor, GLenum dfactor)
+{
+	D3DBLEND s = _convertBlendFactor(sfactor);
+	D3DBLEND d = _convertBlendFactor(dfactor);
+	
+	glw_state->device->SetRenderState(D3DRS_SRCBLEND, s);
+	glw_state->device->SetRenderState(D3DRS_DESTBLEND, d);
+}
+
+static void dllCallList(GLuint lnum)
+{
+	assert(0);
+}
+
+static void dllCallLists(GLsizei n, GLenum type, const GLvoid *lists)
+{
+	assert(0);
+}
+
+static void dllClear(GLbitfield mask)
+{
+	DWORD m = 0;
+
+	if (mask & GL_COLOR_BUFFER_BIT) m |= D3DCLEAR_TARGET;
+	if (mask & GL_STENCIL_BUFFER_BIT) m |= D3DCLEAR_STENCIL;
+
+#ifdef _XBOX
+	// Clearing stencil when clearing depth buffer
+	// is faster on Xbox than just clearing depth alone.
+	if (mask & GL_DEPTH_BUFFER_BIT) m |= D3DCLEAR_ZBUFFER|D3DCLEAR_STENCIL;
+#else
+	if (mask & GL_DEPTH_BUFFER_BIT) m |= D3DCLEAR_ZBUFFER;
+#endif
+	
+	glw_state->device->Clear(0, NULL, m, glw_state->clearColor, 
+		glw_state->clearDepth, glw_state->clearStencil);
+}
+
+static void dllClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
+{
+	assert(0);
+}
+
+static void dllClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
+{
+	glw_state->clearColor = D3DCOLOR_COLORVALUE(red, green, blue, alpha);
+}
+
+static void dllClearDepth(GLclampd depth)
+{
+	glw_state->clearDepth = depth;
+}
+
+static void dllClearIndex(GLfloat c)
+{
+	assert(0);
+}
+
+static void dllClearStencil(GLint s)
+{
+	glw_state->clearStencil = s;
+}
+
+static void dllClipPlane(GLenum plane, const GLdouble *equation)
+{
+	//FIXME
+}
+
+static void setIntColor(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha)
+{
+	glw_state->currentColor = D3DCOLOR_RGBA(red, green, blue, alpha);
+}
+
+static void setFloatColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
+{
+	glw_state->currentColor = D3DCOLOR_COLORVALUE(red, green, blue, alpha);
+}
+
+static void dllColor3b(GLbyte red, GLbyte green, GLbyte blue)
+{
+	setIntColor(red, green, blue, 127);
+}
+
+static void dllColor3bv(const GLbyte *v)
+{
+	setIntColor(v[0], v[1], v[2], 127);
+}
+
+static void dllColor3d(GLdouble red, GLdouble green, GLdouble blue)
+{
+	setFloatColor(red, green, blue, 1.f);
+}
+
+static void dllColor3dv(const GLdouble *v)
+{
+	setFloatColor(v[0], v[1], v[2], 1.f);
+}
+
+static void dllColor3f(GLfloat red, GLfloat green, GLfloat blue)
+{
+	setFloatColor(red, green, blue, 1.f);
+}
+
+static void dllColor3fv(const GLfloat *v)
+{
+	setFloatColor(v[0], v[1], v[2], 1.f);
+}
+
+static void dllColor3i(GLint red, GLint green, GLint blue)
+{
+	setIntColor(red, green, blue, 127);
+}
+
+static void dllColor3iv(const GLint *v)
+{
+	setIntColor(v[0], v[1], v[2], 127);
+}
+
+static void dllColor3s(GLshort red, GLshort green, GLshort blue)
+{
+	setIntColor(red, green, blue, 127);
+}
+
+static void dllColor3sv(const GLshort *v)
+{
+	setIntColor(v[0], v[1], v[2], 127);
+}
+
+static void dllColor3ub(GLubyte red, GLubyte green, GLubyte blue)
+{
+	setIntColor(red, green, blue, 127);
+}
+
+static void dllColor3ubv(const GLubyte *v)
+{
+	setIntColor(v[0], v[1], v[2], 127);
+}
+
+static void dllColor3ui(GLuint red, GLuint green, GLuint blue)
+{
+	setIntColor(red, green, blue, 127);
+}
+
+static void dllColor3uiv(const GLuint *v)
+{
+	setIntColor(v[0], v[1], v[2], 127);
+}
+
+static void dllColor3us(GLushort red, GLushort green, GLushort blue)
+{
+	setIntColor(red, green, blue, 127);
+}
+
+static void dllColor3usv(const GLushort *v)
+{
+	setIntColor(v[0], v[1], v[2], 127);
+}
+
+static void dllColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha)
+{
+	setIntColor(red, green, blue, alpha);
+}
+
+static void dllColor4bv(const GLbyte *v)
+{
+	setIntColor(v[0], v[1], v[2], v[3]);
+}
+
+static void dllColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha)
+{
+	setFloatColor(red, green, blue, alpha);
+}
+
+static void dllColor4dv(const GLdouble *v)
+{
+	setFloatColor(v[0], v[1], v[2], v[3]);
+}
+
+static void dllColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
+{
+	setFloatColor(red, green, blue, alpha);
+}
+
+static void dllColor4fv(const GLfloat *v)
+{
+	setFloatColor(v[0], v[1], v[2], v[3]);
+}
+
+static void dllColor4i(GLint red, GLint green, GLint blue, GLint alpha)
+{
+	setIntColor(red, green, blue, alpha);
+}
+
+static void dllColor4iv(const GLint *v)
+{
+	setIntColor(v[0], v[1], v[2], v[3]);
+}
+
+static void dllColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha)
+{
+	setIntColor(red, green, blue, alpha);
+}
+
+static void dllColor4sv(const GLshort *v)
+{
+	setIntColor(v[0], v[1], v[2], v[3]);
+}
+
+static void dllColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
+{
+	setIntColor(red, green, blue, alpha);
+}
+
+static void dllColor4ubv(const GLubyte *v)
+{
+	setIntColor(v[0], v[1], v[2], v[3]);
+}
+
+static void dllColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha)
+{
+	setIntColor(red, green, blue, alpha);
+}
+
+static void dllColor4uiv(const GLuint *v)
+{
+	setIntColor(v[0], v[1], v[2], v[3]);
+}
+
+static void dllColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha)
+{
+	setIntColor(red, green, blue, alpha);
+}
+
+static void dllColor4usv(const GLushort *v)
+{
+	setIntColor(v[0], v[1], v[2], v[3]);
+}
+
+static void dllColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
+{
+	DWORD m = 0;
+	if (red) m |= D3DCOLORWRITEENABLE_RED;
+	if (green) m |= D3DCOLORWRITEENABLE_GREEN;
+	if (blue) m |= D3DCOLORWRITEENABLE_BLUE;
+	if (alpha) m |= D3DCOLORWRITEENABLE_ALPHA;
+	glw_state->device->SetRenderState(D3DRS_COLORWRITEENABLE, m);
+}
+
+static void dllColorMaterial(GLenum face, GLenum mode)
+{
+	assert(0);
+}
+
+static void dllColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
+{
+	assert(!glw_state->inDrawBlock);
+	assert(size == 4 && type == GL_UNSIGNED_BYTE);
+	
+	stride = (stride == 0) ? sizeof(GLint) : stride;
+
+	glw_state->colorPointer = pointer; 
+	glw_state->colorStride = stride;
+}
+
+static void dllCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type)
+{
+	assert(0);
+}
+
+static void dllCopyTexImage1D(GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border)
+{
+	assert(0);
+}
+
+/**********
+copies a portion of the backbuffer to the current texture.
+the current texture must be a linear format texture, if
+a swizzled texture format is needed, use
+dllCopyBackBufferToTexEXT
+**********/
+static void dllCopyTexImage2D(GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
+{
+	// check to make sure everything passed in is supported
+	assert((target == GL_TEXTURE_2D) && (level == 0) && (border == 0));
+
+	// locals
+	RECT						rSrc;
+	POINT						ptUpperLeft;
+	LPDIRECT3DSURFACE8			tSurf;
+	LPDIRECT3DSURFACE8			backbuffer;
+	glwstate_t::TextureInfo*	tex;
+	HRESULT						res;
+		
+	// get the current texture
+	tex = _getCurrentTexture(glw_state->serverTU);
+	if (tex == NULL)
+	{
+		return;
+	}
+
+	// set up the source rectangle
+	rSrc.left	= x;
+	rSrc.right	= x + width;
+	rSrc.top	= (480 - y) - height;
+	rSrc.bottom	= (480 - y);
+
+	// set up the target point
+	ptUpperLeft.x	= 0;
+	ptUpperLeft.y	= 0;
+
+	// attach the current texture to a surface
+	tex->mipmap->GetSurfaceLevel(0, &tSurf);
+
+	// attach the back buffer to a surface
+	res = glw_state->device->GetBackBuffer(0, D3DBACKBUFFER_TYPE_MONO, &backbuffer);
+
+	// copy the data
+	res = glw_state->device->CopyRects(backbuffer, &rSrc, 0, tSurf, &ptUpperLeft);
+
+	// release surfaces
+	tSurf->Release();
+	backbuffer->Release();
+}
+
+static void dllCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
+{
+	assert(0);
+}
+
+static void dllCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
+{
+	assert(0);
+}
+
+static void dllCullFace(GLenum mode)
+{
+	switch (mode)
+	{
+	default: case GL_BACK: glw_state->cullMode = D3DCULL_CW; break;
+	case GL_FRONT: glw_state->cullMode = D3DCULL_CCW; break;
+	}
+
+	glw_state->device->SetRenderState(D3DRS_CULLMODE, glw_state->cullMode);
+}
+
+static void dllDeleteLists(GLuint lnum, GLsizei range)
+{
+	assert(0);
+}
+
+static void dllDeleteTextures(GLsizei n, const GLuint *textures)
+{
+	for (int t = 0; t < n; ++t)
+	{
+		glwstate_t::texturexlat_t::iterator i = 
+			glw_state->textureXlat.find(textures[t]);
+
+		if (i != glw_state->textureXlat.end())
+		{
+#if MEMORY_PROFILE
+			texMemSize -= getTexMemSize(i->second.mipmap);
+#endif
+			i->second.mipmap->Release();
+			glw_state->textureXlat.erase(i);
+		}
+	}
+}
+
+static void dllDepthFunc(GLenum func)
+{
+	D3DCMPFUNC f = _convertCompare(func);
+	glw_state->device->SetRenderState(D3DRS_ZFUNC, f);
+}
+
+static void dllDepthMask(GLboolean flag)
+{
+	glw_state->device->SetRenderState(D3DRS_ZWRITEENABLE, flag);
+}
+
+static void dllDepthRange(GLclampd zNear, GLclampd zFar)
+{
+	glw_state->viewport.MinZ = zNear;
+	glw_state->viewport.MaxZ = zFar;
+	glw_state->device->SetViewport(&glw_state->viewport);
+}
+
+#ifdef _XBOX
+static void setPresent(bool vsync)
+{
+	//extern void ShowOSMemory();
+	//ShowOSMemory();
+
+	D3DPRESENT_PARAMETERS pp;
+	pp.BackBufferWidth = glConfig.vidWidth;
+	pp.BackBufferHeight = glConfig.vidHeight;
+	pp.BackBufferFormat = D3DFMT_X8R8G8B8;
+	pp.BackBufferCount = 1;
+	pp.MultiSampleType  = D3DMULTISAMPLE_NONE; //D3DMULTISAMPLE_4_SAMPLES_SUPERSAMPLE_LINEAR;
+	pp.SwapEffect = D3DSWAPEFFECT_DISCARD;
+	pp.hDeviceWindow = 0;
+	pp.Windowed  = FALSE;
+	pp.EnableAutoDepthStencil = TRUE;
+	pp.AutoDepthStencilFormat = D3DFMT_D24S8;
+	pp.Flags = 0;
+	pp.FullScreen_RefreshRateInHz = D3DPRESENT_RATE_DEFAULT;
+	pp.FullScreen_PresentationInterval = 
+		vsync ? D3DPRESENT_INTERVAL_DEFAULT : D3DPRESENT_INTERVAL_IMMEDIATE;
+	pp.BufferSurfaces[0] = pp.BufferSurfaces[1] = pp.BufferSurfaces[2] = 0;
+	pp.DepthStencilSurface = 0;
+	glw_state->device->PersistDisplay();
+	glw_state->device->Reset(&pp);
+
+	//ShowOSMemory();
+}
+#endif
+
+static void setCap(GLenum cap, bool flag)
+{
+	switch (cap)
+	{
+	case GL_ALPHA_TEST: glw_state->device->SetRenderState(D3DRS_ALPHATESTENABLE, flag); break;
+	case GL_BLEND: glw_state->device->SetRenderState(D3DRS_ALPHABLENDENABLE, flag); break;
+	case GL_CULL_FACE:
+		glw_state->cullEnable = flag;
+		glw_state->device->SetRenderState(D3DRS_CULLMODE, 
+			flag ? glw_state->cullMode : D3DCULL_NONE);
+		break;
+	case GL_DEPTH_TEST: glw_state->device->SetRenderState(D3DRS_ZENABLE, flag); break;
+	case GL_LIGHTING: glw_state->device->SetRenderState(D3DRS_LIGHTING, flag); break;
+#ifdef _XBOX
+	case GL_POLYGON_OFFSET_POINT:
+		glw_state->device->SetRenderState(D3DRS_POINTOFFSETENABLE, flag);
+		break;
+	case GL_POLYGON_OFFSET_LINE:
+		glw_state->device->SetRenderState(D3DRS_WIREFRAMEOFFSETENABLE, flag);
+		break;
+	case GL_POLYGON_OFFSET_FILL:
+		glw_state->device->SetRenderState(D3DRS_SOLIDOFFSETENABLE, flag);
+		break;
+	case GL_SCISSOR_TEST:
+		glw_state->scissorEnable = flag;
+		glw_state->device->SetScissors(flag ? 1 : 0, FALSE, &glw_state->scissorBox);
+		break;
+#endif
+	case GL_STENCIL_TEST: glw_state->device->SetRenderState(D3DRS_STENCILENABLE, flag); break;
+	case GL_TEXTURE_2D: 
+		glw_state->textureStageEnable[glw_state->serverTU] = flag;
+		glw_state->textureStageDirty[glw_state->serverTU] = true;
+		break;
+	case GL_FOG:
+		glw_state->device->SetRenderState(D3DRS_FOGENABLE, flag);
+		break;
+#ifdef _XBOX
+	case GL_VSYNC:
+		setPresent(flag);
+		break;
+#endif
+	default: break;
+	}
+}
+
+static void dllDisable(GLenum cap)
+{
+	setCap(cap, false);
+}
+
+static void setArrayState(GLenum cap, bool state)
+{
+	switch (cap)
+	{
+	case GL_COLOR_ARRAY: glw_state->colorArrayState = state; break; 
+	case GL_TEXTURE_COORD_ARRAY: glw_state->texCoordArrayState[glw_state->clientTU] = state; break;
+	case GL_VERTEX_ARRAY: glw_state->vertexArrayState = state; break;
+	case GL_NORMAL_ARRAY: glw_state->normalArrayState = state; break;
+	}
+}
+
+static void dllDisableClientState(GLenum array)
+{
+	assert(!glw_state->inDrawBlock);
+	setArrayState(array, false);
+}
+
+#ifdef _WINDOWS
+static void _convertQuadsToTris(GLint first, GLsizei count)
+{
+	glw_state->vertexPointerBack = glw_state->vertexPointer;
+	glw_state->normalPointerBack = glw_state->normalPointer;
+	glw_state->colorPointerBack = glw_state->colorPointer;
+	glw_state->texCoordPointerBack[0] = glw_state->texCoordPointer[0];
+	glw_state->texCoordPointerBack[1] = glw_state->texCoordPointer[1];
+	
+	{
+		glw_state->vertexPointer = 
+			Z_Malloc(count * glw_state->vertexStride * 3 / 2, 
+			TAG_TEMP_WORKSPACE, qfalse);
+		for (int i = 0; i < count; i += 4)
+		{
+			int stride = glw_state->vertexStride / sizeof(float);
+			float* dst = (float*)glw_state->vertexPointer + (i * 3 / 2) * stride;
+			const float* src = (const float*)glw_state->vertexPointerBack + 
+				(first + i) * stride;
+			
+			for (int j = 0; j < 3; ++j)
+			{
+				dst[0 * stride + j] = src[0 * stride + j];
+				dst[1 * stride + j] = src[1 * stride + j];
+				dst[2 * stride + j] = src[2 * stride + j];
+				dst[3 * stride + j] = src[0 * stride + j];
+				dst[4 * stride + j] = src[2 * stride + j];
+				dst[5 * stride + j] = src[3 * stride + j];
+			}
+		}
+	}
+	
+	if (glw_state->normalArrayState)
+	{
+		glw_state->normalPointer = 
+			Z_Malloc(count * glw_state->normalStride * 3 / 2, 
+			TAG_TEMP_WORKSPACE, qfalse);
+		
+		for (int i = 0; i < count; i += 4)
+		{
+			int stride = glw_state->normalStride / sizeof(float);
+			float* dst = (float*)glw_state->normalPointer + (i * 3 / 2) * stride;
+			const float* src = (const float*)glw_state->normalPointerBack + 
+				(first + i) * stride;
+			
+			for (int j = 0; j < 3; ++j)
+			{
+				dst[0 * stride + j] = src[0 * stride + j];
+				dst[1 * stride + j] = src[1 * stride + j];
+				dst[2 * stride + j] = src[2 * stride + j];
+				dst[3 * stride + j] = src[0 * stride + j];
+				dst[4 * stride + j] = src[2 * stride + j];
+				dst[5 * stride + j] = src[3 * stride + j];
+			}
+		}
+	}
+	
+	if (glw_state->colorArrayState)
+	{
+		glw_state->colorPointer = 
+			Z_Malloc(count * glw_state->colorStride * 3 / 2, 
+			TAG_TEMP_WORKSPACE, qfalse);
+		
+		for (int i = 0; i < count; i += 4)
+		{
+			int stride = glw_state->colorStride / sizeof(DWORD);
+			DWORD* dst = (DWORD*)glw_state->colorPointer + (i * 3 / 2) * stride;
+			const DWORD* src = (const DWORD*)glw_state->colorPointerBack + 
+				(first + i) * stride;
+			
+			dst[0 * stride] = src[0 * stride];
+			dst[1 * stride] = src[1 * stride];
+			dst[2 * stride] = src[2 * stride];
+			dst[3 * stride] = src[0 * stride];
+			dst[4 * stride] = src[2 * stride];
+			dst[5 * stride] = src[3 * stride];
+		}
+	}
+	
+	for (int t = 0; t < GLW_MAX_TEXTURE_STAGES; ++t)
+	{
+		if (glw_state->texCoordArrayState[t])
+		{
+			glw_state->texCoordPointer[t] = 
+				Z_Malloc(count * glw_state->texCoordStride[t] * 3 / 2, 
+				TAG_TEMP_WORKSPACE, qfalse);
+			
+			for (int i = 0; i < count; i += 4)
+			{
+				int stride = glw_state->texCoordStride[t] / sizeof(float);
+				float* dst = (float*)glw_state->texCoordPointer[t] + (i * 3 / 2) * stride;
+				const float* src = (const float*)glw_state->texCoordPointerBack[t] + 
+					(first + i) * stride;
+				
+				for (int j = 0; j < 2; ++j)
+				{
+					dst[0 * stride + j] = src[0 * stride + j];
+					dst[1 * stride + j] = src[1 * stride + j];
+					dst[2 * stride + j] = src[2 * stride + j];
+					dst[3 * stride + j] = src[0 * stride + j];
+					dst[4 * stride + j] = src[2 * stride + j];
+					dst[5 * stride + j] = src[3 * stride + j];
+				}
+			}
+		}
+	}
+}
+
+static void _cleanupQuadsToTris(void)
+{
+	Z_Free(const_cast<void*>(glw_state->vertexPointer));
+	glw_state->vertexPointer = glw_state->vertexPointerBack;
+	
+	if (glw_state->normalArrayState)
+	{
+		Z_Free(const_cast<void*>(glw_state->normalPointer));
+		glw_state->normalPointer = glw_state->normalPointerBack;
+	}
+	
+	if (glw_state->colorArrayState)
+	{
+		Z_Free(const_cast<void*>(glw_state->colorPointer));
+		glw_state->colorPointer = glw_state->colorPointerBack;
+	}
+
+	for (int t = 0; t < GLW_MAX_TEXTURE_STAGES; ++t)
+	{
+		if (glw_state->texCoordArrayState[t])
+		{
+			Z_Free(const_cast<void*>(glw_state->texCoordPointer[t]));
+			glw_state->texCoordPointer[t] = glw_state->texCoordPointerBack[t];
+		}
+	}
+}
+#endif
+
+// NOTE: This is a core draw routine.  It should be fast.
+static void dllDrawArrays(GLenum mode, GLint first, GLsizei count)
+{
+#ifdef _WINDOWS
+	if (mode == GL_QUADS)
+	{
+		_convertQuadsToTris(first, count);
+		count = count * 3 / 2;
+		first = 0;
+	}
+#endif
+
+	// start the draw mode
+	qglBeginEXT(mode, count, glw_state->colorArrayState ? count : 0, 
+		glw_state->normalArrayState ? count : 0,
+		glw_state->texCoordArrayState[0] ? count : 0,
+		glw_state->texCoordArrayState[1] ? count : 0);
+
+	// get the draw function we need
+	drawarrayfunc_t func = _drawArrayFuncTable[_getDrawFunc()];
+
+#ifndef _XBOX
+	DWORD* base = glw_state->drawArray;
+#endif
+
+	int inc = glw_state->maxVertices;
+	// loop taking care not to draw too much at a time
+	for (int start = first; ; start += inc)//glw_state->maxVertices)
+	{
+		// draw glw_state->maxVertices amount of geometry
+		func(start, start + glw_state->maxVertices);
+		
+		// are we done yet?
+		glw_state->totalVertices -= glw_state->maxVertices;
+		if (glw_state->totalVertices <= 0)
+		{
+			glw_state->numVertices = glw_state->maxVertices;
+			break;
+		}
+		
+		// ready for another cycle
+		glw_state->drawArray += glw_state->maxVertices *
+			glw_state->drawStride;
+		glw_state->maxVertices = _getMaxVerts();
+
+		glw_state->drawArray = _restartDrawPacket(
+			glw_state->drawArray, glw_state->maxVertices); 
+	}
+	
+#ifndef _XBOX
+	glw_state->drawArray = base;
+#endif
+
+#ifdef _WINDOWS
+	if (mode == GL_QUADS)
+	{
+		_cleanupQuadsToTris();
+	}
+#endif
+
+	// finish up the draw
+	qglEnd();
+}
+
+static void dllDrawBuffer(GLenum mode)
+{
+	//FIXME
+}
+
+static void PushIndices(GLsizei count, const GLushort *indices)
+{
+	// open the index packet
+	// can only send 2047 indices thru at a time
+	// BUT, Microsoft recommends 511 pairs at a time (?)
+	int num_packets, numpairs, cnt;
+	bool singleindex = false;
+
+	numpairs = count / 2;
+
+	if(numpairs <= 511) 
+	{
+		num_packets = 1;
+
+		if(glw_state->maxIndices % 2)
+		{
+			glw_state->maxIndices -= 1;
+			singleindex = true;
+		}
+	} else 
+	{
+		num_packets = (count / glw_state->maxIndices) + (!!(count % glw_state->maxIndices));
+	}
+
+	glw_state->drawArray = _restartIndexPacket(glw_state->drawArray, glw_state->maxIndices);
+
+	int inc = glw_state->maxIndices;
+	for (int start = 0; ; start += inc)
+	{
+		for(int i = start; i < start + glw_state->maxIndices; i += 2)
+		{
+			*glw_state->drawArray++ = (DWORD)(((WORD)indices[i + 1] << 16) + (WORD)indices[i]);
+		}
+		// are we done yet?
+		glw_state->totalIndices -= glw_state->maxIndices;
+		if (glw_state->totalIndices <= 1)
+		{
+			glw_state->numIndices = glw_state->maxIndices;
+			break;
+		}
+
+		// ready for another cycle
+		//glw_state->drawArray += glw_state->maxVertices * glw_state->drawStride;
+		glw_state->maxIndices = _getMaxIndices();
+
+		if(glw_state->maxIndices % 2)
+		{
+			glw_state->maxIndices -= 1;
+			singleindex = true;
+		}
+
+		glw_state->drawArray = _restartIndexPacket(glw_state->drawArray, glw_state->maxIndices);
+	}
+
+#define CMD_DRAW_INDEX_LAST 0x1808 
+	if(singleindex)
+	{
+		*glw_state->drawArray++ = D3DPUSH_ENCODE(CMD_DRAW_INDEX_LAST, 1);
+		*glw_state->drawArray++ = indices[count - 1];
+	}
+}
+
+// NOTE: This is a core draw routine.  It should be fast.
+static void dllDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)
+{
+	int normals, tex0, tex1, num_streams = 2;
+
+	assert(type == GL_UNSIGNED_SHORT);
+
+	normals = glw_state->normalArrayState ? tess.numVertexes : 0;
+	tex0 = glw_state->texCoordArrayState[0] ? tess.numVertexes : 0;
+	tex1 = glw_state->texCoordArrayState[1] ? tess.numVertexes : 0;
+
+	num_streams += ((normals > 0) + (tex0 > 0) + (tex1 > 0));
+
+	// start the draw block
+	glw_state->inDrawBlock = true;
+	glw_state->primitiveMode = _convertPrimMode(mode);
+
+	// update DX with any pending state changes
+	_updateDrawStride(normals, tex0, tex1);
+	_updateShader(normals, tex0, tex1);
+	_updateTextures();
+	_updateMatrices();
+
+	glw_state->drawStride += normals ? 2 : 1;
+
+	glw_state->numIndices = 0;
+	glw_state->totalIndices = count;
+	glw_state->maxIndices = _getMaxIndices();
+
+	glw_state->device->SetStreamSource(0, NULL, glw_state->drawStride * 4);
+
+	int vert_size = glw_state->drawStride * tess.numVertexes;
+	int index_size = count / 2; 
+
+	glw_state->device->BeginPush(vert_size + index_size + 60, &glw_state->drawArray);
+
+	glw_state->drawArray = (DWORD*)*((DWORD*)glw_state->device);
+
+	DWORD *jumpaddress = 0, *stream = 0;
+
+	// Determine where the end of the vertex data is gonna be,
+	// that's where we're going to jump to
+	jumpaddress = (DWORD*)*((DWORD*)glw_state->device) + (vert_size + 1);
+
+	// Write the jump address
+	*glw_state->drawArray++ = ((DWORD)jumpaddress & 0x7fffffff) | 1;
+
+	// Set up our own fake vertex buffer
+	stream = glw_state->drawArray;
+
+	memcpy(glw_state->drawArray, tess.xyz, sizeof(vec4_t) * tess.numVertexes);
+	glw_state->drawArray += tess.numVertexes * 4;
+
+	if(normals)
+	{
+		memcpy(glw_state->drawArray, tess.normal, sizeof(vec4_t) * tess.numVertexes);
+		glw_state->drawArray += tess.numVertexes * 4;
+	}
+
+	if(glw_state->colorArrayState)
+	{
+		memcpy(glw_state->drawArray, tess.svars.colors, sizeof(D3DCOLOR) * tess.numVertexes);
+	}
+	else
+	{
+		for( int v = 0; v < tess.numVertexes; ++v )
+			glw_state->drawArray[v] = glw_state->currentColor;
+	}
+	glw_state->drawArray += tess.numVertexes;
+
+	if(tex0)
+	{
+		memcpy(glw_state->drawArray, tess.svars.texcoords[0], sizeof(vec2_t) * tess.numVertexes);
+		glw_state->drawArray += tess.numVertexes * 2;
+	}
+
+	if(tex1)
+	{
+		memcpy(glw_state->drawArray, tess.svars.texcoords[1], sizeof(vec2_t) * tess.numVertexes);
+		glw_state->drawArray += tess.numVertexes * 2;
+	}
+
+	// Write the vertex shader
+#define CMD_STREAM_STRIDEANDTYPE0 0x1760
+	*glw_state->drawArray++ = D3DPUSH_ENCODE(CMD_STREAM_STRIDEANDTYPE0, 16);
+	*glw_state->drawArray++ = (16 << 8)|D3DVSDT_FLOAT3;
+
+	if(1)
+	{
+		*glw_state->drawArray++ = ((glw_state->drawStride * 4) << 8) | D3DVSDT_NONE;
+	}
+
+	if(normals)
+	{
+		*glw_state->drawArray++ = (16 << 8) | D3DVSDT_FLOAT3;
+	}
+	else
+	{
+		*glw_state->drawArray++ = ((glw_state->drawStride * 4) << 8) | D3DVSDT_NONE;
+	}
+
+	*glw_state->drawArray++ = (4 << 8) | D3DVSDT_D3DCOLOR;
+
+	for(int i = 0; i < 5; i++)
+	{
+		*glw_state->drawArray++ = ((glw_state->drawStride * 4) << 8) | D3DVSDT_NONE;
+	}
+
+	if(tex0)
+	{
+		*glw_state->drawArray++ = (8 << 8) | D3DVSDT_FLOAT2;
+	}
+	else
+	{
+		*glw_state->drawArray++ = ((glw_state->drawStride * 4) << 8) | D3DVSDT_NONE;
+	}
+
+	if(tex1)
+	{
+		*glw_state->drawArray++ = (8 << 8) | D3DVSDT_FLOAT2;
+	}
+	else
+	{
+		*glw_state->drawArray++ = ((glw_state->drawStride * 4) << 8) | D3DVSDT_NONE;
+	}
+
+	for(i = 0; i < 5; i++)
+	{
+		*glw_state->drawArray++ = ((glw_state->drawStride * 4) << 8) | D3DVSDT_NONE;
+	}
+
+//	 Write the indicator to our vertex stream
+#define CMD_VERTEXSTREAM_XYZ		0x1720
+#define CMD_VERTEXSTREAM_NORMAL		0x1728
+#define CMD_VERTEXSTREAM_COLOR		0x172c
+#define CMD_VERTEXSTREAM_TEX0		0x1744
+#define CMD_VERTEXSTREAM_TEX1		0x1748
+
+	*glw_state->drawArray++ = D3DPUSH_ENCODE(CMD_VERTEXSTREAM_XYZ, 1);
+	*glw_state->drawArray++ = (DWORD)stream & 0x7fffffff;
+	stream += tess.numVertexes * 4;//3;
+
+	if(normals)
+	{
+		*glw_state->drawArray++ = D3DPUSH_ENCODE(CMD_VERTEXSTREAM_NORMAL, 1);
+		*glw_state->drawArray++ = (DWORD)stream & 0x7fffffff;
+		stream += tess.numVertexes * 4;//3;
+	}
+
+	*glw_state->drawArray++ = D3DPUSH_ENCODE(CMD_VERTEXSTREAM_COLOR, 1);
+	*glw_state->drawArray++ = (DWORD)stream & 0x7fffffff;
+	stream += tess.numVertexes;//1;
+
+	if(tex0)
+	{
+		*glw_state->drawArray++ = D3DPUSH_ENCODE(CMD_VERTEXSTREAM_TEX0, 1);
+		*glw_state->drawArray++ = (DWORD)stream & 0x7fffffff;
+		stream += tess.numVertexes * 2;//2;
+	}
+
+	if(tex1)
+	{
+		*glw_state->drawArray++ = D3DPUSH_ENCODE(CMD_VERTEXSTREAM_TEX1, 1);
+		*glw_state->drawArray++ = (DWORD)stream & 0x7fffffff;
+	}
+
+	// Send thru the index data
+	PushIndices(count, (GLushort*)indices);
+
+	// finish up the draw
+	glw_state->inDrawBlock = false;
+
+	DWORD* push = _terminateIndexPacket(glw_state->drawArray);
+
+	glw_state->device->EndPush(push);
+}
+
+static void dllDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
+{
+	assert(0);
+}
+
+static void dllEdgeFlag(GLboolean flag)
+{
+	assert(0);
+}
+
+static void dllEdgeFlagPointer(GLsizei stride, const GLvoid *pointer)
+{
+	assert(0);
+}
+
+static void dllEdgeFlagv(const GLboolean *flag)
+{
+	assert(0);
+}
+
+static void dllEnable(GLenum cap)
+{
+	setCap(cap, true);
+}
+
+static void dllEnableClientState(GLenum array)
+{
+	assert(!glw_state->inDrawBlock);
+	setArrayState(array, true);
+}
+
+static void dllEnd(void)
+{
+	assert(glw_state->inDrawBlock);
+	glw_state->inDrawBlock = false;
+#ifdef _XBOX
+	// on Xbox, just close the draw packet
+	DWORD* push = _terminateDrawPacket(
+		&glw_state->drawArray[glw_state->numVertices * 
+		glw_state->drawStride]);
+	
+	glw_state->device->EndPush(push);
+#else
+	// on the PC, use DrawPrimitiveUp (a little slow)
+	int num = 0;
+	switch (glw_state->primitiveMode)
+	{
+	case D3DPT_POINTLIST: num = glw_state->numVertices; break;
+	case D3DPT_LINELIST: num = glw_state->numVertices / 2; break;
+	case D3DPT_LINESTRIP: num = glw_state->numVertices - 1; break;
+	case D3DPT_TRIANGLELIST: num = glw_state->numVertices / 3; break;
+	case D3DPT_TRIANGLESTRIP: num = glw_state->numVertices - 2; break;
+	case D3DPT_TRIANGLEFAN: num = glw_state->numVertices - 2; break;
+	}
+	
+	glw_state->device->DrawPrimitiveUP(
+		glw_state->primitiveMode, num, 
+		glw_state->drawArray, glw_state->drawStride * sizeof(DWORD));
+#endif
+}
+
+// EXTENSION: End drawing for a frame
+static void dllEndFrame(void)
+{
+	assert(!glw_state->inDrawBlock);
+
+	// the blend state can get reset by Present()...
+	GLboolean blend = qglIsEnabled(GL_BLEND);
+	
+	glw_state->device->EndScene();
+	
+	qglViewport(0, 0, glConfig.vidWidth, glConfig.vidHeight);
+	glw_state->device->Present(NULL, NULL, NULL, NULL);
+
+	// restore the pre-Present state
+	if (blend) qglEnable(GL_BLEND);
+	else qglDisable(GL_BLEND);
+}
+
+// EXTENSION: End shadow draw mode
+static void dllEndShadow(void)
+{
+	//Intentionally left blank
+}
+
+static void dllEndList(void)
+{
+	assert(0);
+}
+
+static void dllEvalCoord1d(GLdouble u)
+{
+	assert(0);
+}
+
+static void dllEvalCoord1dv(const GLdouble *u)
+{
+	assert(0);
+}
+
+static void dllEvalCoord1f(GLfloat u)
+{
+	assert(0);
+}
+
+static void dllEvalCoord1fv(const GLfloat *u)
+{
+	assert(0);
+}
+
+static void dllEvalCoord2d(GLdouble u, GLdouble v)
+{
+	assert(0);
+}
+
+static void dllEvalCoord2dv(const GLdouble *u)
+{
+	assert(0);
+}
+
+static void dllEvalCoord2f(GLfloat u, GLfloat v)
+{
+	assert(0);
+}
+
+static void dllEvalCoord2fv(const GLfloat *u)
+{
+	assert(0);
+}
+
+static void dllEvalMesh1(GLenum mode, GLint i1, GLint i2)
+{
+	assert(0);
+}
+
+static void dllEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)
+{
+	assert(0);
+}
+
+static void dllEvalPoint1(GLint i)
+{
+	assert(0);
+}
+
+static void dllEvalPoint2(GLint i, GLint j)
+{
+	assert(0);
+}
+
+static void dllFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer)
+{
+	assert(0);
+}
+
+static void dllFinish(void)
+{
+#ifdef _XBOX
+	glw_state->device->BlockUntilIdle();
+#endif
+}
+
+static void dllFlush(void)
+{
+#ifdef _XBOX
+	glw_state->device->BlockUntilIdle();
+#endif
+}
+
+// EXTENSION: Draw the shadow
+static void dllFlushShadow(void)
+{
+	//Intentionally left blank
+}
+
+static D3DFOGMODE _convertFogMode(GLint param)
+{
+	switch(param)
+	{
+	case GL_LINEAR: return D3DFOG_LINEAR; break;
+	case GL_EXP: return D3DFOG_EXP; break;
+	case GL_EXP2: return D3DFOG_EXP2; break;
+	}
+
+	return D3DFOG_NONE;
+}
+
+static void dllFogf(GLenum pname, GLfloat param)
+{
+	assert(pname == GL_FOG_DENSITY || pname == GL_FOG_START || pname == GL_FOG_END);	
+
+	switch(pname)
+	{
+	case GL_FOG_DENSITY: glw_state->device->SetRenderState( D3DRS_FOGDENSITY, *(DWORD*)&param ); break;
+	case GL_FOG_START: glw_state->device->SetRenderState( D3DRS_FOGSTART, *(DWORD*)&param ); break;
+	case GL_FOG_END: glw_state->device->SetRenderState( D3DRS_FOGEND, *(DWORD*)&param ); break;
+	}
+}
+
+static void dllFogfv(GLenum pname, const GLfloat *params)
+{
+	assert(pname == GL_FOG_COLOR);
+
+	D3DCOLOR color = D3DCOLOR_ARGB(0x00, 
+								  (int)(params[0] * 255.0f),
+								  (int)(params[1] * 255.0f),
+								  (int)(params[2] * 255.0f));
+
+	glw_state->device->SetRenderState( D3DRS_FOGCOLOR, color );
+}
+
+static void dllFogi(GLenum pname, GLint param)
+{
+	assert(pname == GL_FOG_MODE);
+
+	glw_state->device->SetRenderState( D3DRS_FOGTABLEMODE, _convertFogMode(param) );
+}
+
+static void dllFogiv(GLenum pname, const GLint *params)
+{
+	assert(0);
+}
+
+static void dllFrontFace(GLenum mode)
+{
+	assert(0);
+}
+
+static void dllFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
+{
+	D3DXMATRIX m;
+	D3DXMatrixPerspectiveOffCenterRH(&m, left, right, bottom, top, zNear, zFar);
+	glw_state->matrixStack[glw_state->matrixMode]->MultMatrix(&m);
+	glw_state->matricesDirty[glw_state->matrixMode] = true;
+}
+
+GLuint dllGenLists(GLsizei range)
+{
+	assert(0);
+	return 0;
+}
+
+static void dllGenTextures(GLsizei n, GLuint *textures)
+{
+	for (int i = 0; i < n; ++i)
+	{
+		textures[i] = glw_state->textureBindNum++;
+	}
+}
+
+// Implemented only the states we use.
+template <typename T>
+static void _getState(GLenum pname, T *params)
+{
+	switch (pname)
+	{
+	case GL_CULL_FACE: params[0] = (T)glw_state->cullEnable; break;
+//	case GL_MAX_TEXTURE_SIZE: params[0] = (T)512; break;
+	case GL_MAX_TEXTURE_SIZE: params[0] = (T)256; break;
+	case GL_MAX_ACTIVE_TEXTURES_ARB: params[0] = GLW_MAX_TEXTURE_STAGES; break;
+	case GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT: params[0] = 4; break;
+	default:
+		assert(0);
+		params[0] = (T)0;
+		break;
+	}
+}
+
+static void dllGetBooleanv(GLenum pname, GLboolean *params)
+{
+	_getState(pname, params);
+}
+
+static void dllGetClipPlane(GLenum plane, GLdouble *equation)
+{
+	assert(0);
+}
+
+static void dllGetDoublev(GLenum pname, GLdouble *params)
+{
+	_getState(pname, params);
+}
+
+GLenum dllGetError(void)
+{
+	return 0;
+}
+
+static void dllGetFloatv(GLenum pname, GLfloat *params)
+{
+	_getState(pname, params);
+}
+
+static void dllGetIntegerv(GLenum pname, GLint *params)
+{
+	_getState(pname, params);
+}
+
+static void dllGetLightfv(GLenum light, GLenum pname, GLfloat *params)
+{
+	assert(0);
+}
+
+static void dllGetLightiv(GLenum light, GLenum pname, GLint *params)
+{
+	assert(0);
+}
+
+static void dllGetMapdv(GLenum target, GLenum query, GLdouble *v)
+{
+	assert(0);
+}
+
+static void dllGetMapfv(GLenum target, GLenum query, GLfloat *v)
+{
+	assert(0);
+}
+
+static void dllGetMapiv(GLenum target, GLenum query, GLint *v)
+{
+	assert(0);
+}
+
+static void dllGetMaterialfv(GLenum face, GLenum pname, GLfloat *params)
+{
+	assert(0);
+}
+
+static void dllGetMaterialiv(GLenum face, GLenum pname, GLint *params)
+{
+	assert(0);
+}
+
+static void dllGetPixelMapfv(GLenum map, GLfloat *values)
+{
+	assert(0);
+}
+
+static void dllGetPixelMapuiv(GLenum map, GLuint *values)
+{
+	assert(0);
+}
+
+static void dllGetPixelMapusv(GLenum map, GLushort *values)
+{
+	assert(0);
+}
+
+static void dllGetPointerv(GLenum pname, GLvoid* *params)
+{
+	assert(0);
+}
+
+static void dllGetPolygonStipple(GLubyte *mask)
+{
+	assert(0);
+}
+
+const GLubyte * dllGetString(GLenum name)
+{
+	switch (name)
+	{
+	case GL_VENDOR: return (const unsigned char*)"Vicarious Visions";
+	case GL_RENDERER: return (const unsigned char*)"Optimized DX8/OpenGL Layer";
+	case GL_VERSION: return (const unsigned char*)"0.1";
+	case GL_EXTENSIONS:
+		return (const unsigned char*)
+			"EXT_texture_env_add GL_ARB_multitexture EXT_texture_filter_anisotropic";
+	default: return (const unsigned char*)"";
+	}
+}
+
+static void dllGetTexEnvfv(GLenum target, GLenum pname, GLfloat *params)
+{
+	assert(0);
+}
+
+static void dllGetTexEnviv(GLenum target, GLenum pname, GLint *params)
+{
+	assert(0);
+}
+
+static void dllGetTexGendv(GLenum coord, GLenum pname, GLdouble *params)
+{
+	assert(0);
+}
+
+static void dllGetTexGenfv(GLenum coord, GLenum pname, GLfloat *params)
+{
+	assert(0);
+}
+
+static void dllGetTexGeniv(GLenum coord, GLenum pname, GLint *params)
+{
+	assert(0);
+}
+
+static void dllGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels)
+{
+	assert(0);
+}
+
+static void dllGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params)
+{
+	assert(0);
+}
+
+static void dllGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params)
+{
+	assert(0);
+}
+
+static void dllGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params)
+{
+	assert(0);
+}
+
+static void dllGetTexParameteriv(GLenum target, GLenum pname, GLint *params)
+{
+	assert(0);
+}
+
+static void dllHint(GLenum target, GLenum mode)
+{
+	assert(0);
+}
+
+// Convert an triangle index array (indices) to a 
+// triangle strip index array (dest) with primitive 
+// length array.
+static void buildStrips(GLuint* len, GLsizei* num_lens, GLushort* dest, GLsizei* num_indices, const GLushort* src)
+{
+	GLushort last[3];
+
+	// prime the strip
+	GLsizei cur_index = 0;
+	dest[cur_index++] = src[0];
+	dest[cur_index++] = src[1];
+	dest[cur_index++] = src[2];
+	GLuint cur_length = 3;
+	GLsizei num_strips = 0;
+
+	GLuint max_length = GLW_MAX_DRAW_PACKET_SIZE / glw_state->drawStride;
+	
+	last[0] = src[0];
+	last[1] = src[1];
+	last[2] = src[2];
+
+	qboolean even = qfalse;
+
+	for ( GLsizei i = 3; i < *num_indices; i += 3 )
+	{
+		// odd numbered triangle in potential strip
+		if ( !even )
+		{
+			// check previous triangle to see if we're continuing a strip
+			if ( ( src[i+0] == last[2] ) && ( src[i+1] == last[1] ) &&
+				cur_length < max_length )
+			{
+				++cur_length;
+				dest[cur_index++] = src[i+2];
+				even = qtrue;
+			}
+			// otherwise we're done with this strip so finish it and start
+			// a new one
+			else
+			{
+				len[num_strips++] = cur_length;
+				cur_length = 3;
+
+				dest[cur_index++] = src[i+0];
+				dest[cur_index++] = src[i+1];
+				dest[cur_index++] = src[i+2];
+
+				even = qfalse;
+			}
+		}
+		else
+		{
+			// check previous triangle to see if we're continuing a strip
+			if ( ( last[2] == src[i+1] ) && ( last[0] == src[i+0] ) &&
+				cur_length < max_length )
+			{
+				++cur_length;
+				dest[cur_index++] = src[i+2];
+				even = qfalse;
+			}
+			// otherwise we're done with this strip so finish it and start
+			// a new one
+			else
+			{
+				len[num_strips++] = cur_length;
+				cur_length = 3;
+
+				dest[cur_index++] = src[i+0];
+				dest[cur_index++] = src[i+1];
+				dest[cur_index++] = src[i+2];
+
+				even = qfalse;
+			}
+		}
+
+		// cache the last three vertices
+		last[0] = src[i+0];
+		last[1] = src[i+1];
+		last[2] = src[i+2];
+	}
+
+	len[num_strips++] = cur_length;
+	*num_lens = num_strips;
+	*num_indices = cur_index;
+
+	assert(num_strips <= GLW_MAX_STRIPS);
+}
+
+#ifdef _XBOX
+void renderObject_HACK()
+{
+	_updateDrawStride(glw_state->normalArrayState,
+		glw_state->texCoordArrayState[0] ? 1 : 0,
+		glw_state->texCoordArrayState[1] ? 1 : 0);
+	_updateShader(glw_state->normalArrayState,
+		glw_state->texCoordArrayState[0] ? 1 : 0,
+		glw_state->texCoordArrayState[1] ? 1 : 0);
+	_updateTextures();
+	_updateMatrices();
+
+	glw_state->primitiveMode = D3DPT_TRIANGLESTRIP;
+  
+	// get the necessary draw function
+	drawelemfunc_t func = _drawElementFuncTable[_getDrawFunc()];
+	int stride = glw_state->drawStride;
+
+	int index = 0;
+	for (int l = 0; l < glw_state->num_strip_lengths; ++l)
+	{
+		int cur_len = glw_state->strip_lengths[l];
+
+		// start a draw packet
+		DWORD* push;
+		glw_state->device->BeginPush(stride * cur_len + 5, &push);
+		push = _restartDrawPacket(push, cur_len);
+ 
+		// draw the geometry
+		glw_state->drawArray = push;
+		func(cur_len, &glw_state->strip_dest[index]);
+		index += cur_len;
+
+		// finish the draw packet
+		push = _terminateDrawPacket(&push[stride * cur_len]);
+		glw_state->device->EndPush(push);
+	}
+}
+
+
+void renderObject_Light()
+{
+	//glw_state->drawStride = 11;
+
+	//glw_state->primitiveMode = D3DPT_TRIANGLESTRIP;
+ // 
+	//// get the necessary draw function
+	//drawelemfunc_t func = _drawElementsLightShader;
+	//int stride = glw_state->drawStride;
+
+	///*if(tess.currentPass == 0)
+ //       buildStrips(glw_state->strip_lengths, &glw_state->num_strip_lengths, glw_state->strip_dest,
+	//			&tess.numIndexes, &tess.indexes[0]);*/
+
+	//int index = 0;
+	//for (int l = 0; l < glw_state->num_strip_lengths; ++l)
+	//{
+	//	int cur_len = glw_state->strip_lengths[l];
+
+	//	// start a draw packet
+	//	DWORD* push;
+	//	glw_state->device->BeginPush(stride * cur_len + 5, &push);
+	//	push = _restartDrawPacket(push, cur_len);
+ //
+	//	// draw the geometry
+	//	glw_state->drawArray = push;
+	//	func(cur_len, &glw_state->strip_dest[index]);
+	//	index += cur_len;
+
+	//	// finish the draw packet
+	//	push = _terminateDrawPacket(&push[stride * cur_len]);
+	//	glw_state->device->EndPush(push);
+	//}
+
+	// start the draw mode
+	assert(!glw_state->inDrawBlock);
+
+	glw_state->inDrawBlock = true;
+	glw_state->primitiveMode = D3DPT_TRIANGLELIST;
+
+	glw_state->drawStride = 11;
+
+	// set vertex counters
+	glw_state->numVertices = 0;
+	glw_state->totalVertices = tess.numIndexes;
+	glw_state->maxVertices = _getMaxVerts();	
+
+	// open a draw packet
+	//int num_packets = ((tess.numIndexes * glw_state->drawStride) / GLW_MAX_DRAW_PACKET_SIZE) + 1;
+	int num_packets;
+	if(tess.numIndexes == 0) {
+		num_packets = 1;
+	} else {
+		num_packets = (tess.numIndexes / glw_state->maxVertices) + (!!(tess.numIndexes % glw_state->maxVertices));
+	}
+	int cmd_size = num_packets * 3;
+	int vert_size = glw_state->drawStride * tess.numIndexes;
+	
+	glw_state->device->BeginPush(vert_size + cmd_size + 2, 
+		&glw_state->drawArray);
+	
+	glw_state->drawArray = _restartDrawPacket(
+		glw_state->drawArray, glw_state->maxVertices);
+
+	// get the draw function we need
+	drawelemfunc_t func = _drawElementsLightShader;
+
+	// loop taking care not to draw too much at a time
+	int inc = glw_state->maxVertices;
+	for (int start = 0; ; start += inc)
+	{
+		// draw glw_state->maxVertices amount of geometry
+		func(glw_state->maxVertices, &(((GLushort*)tess.indexes)[start]));
+		
+		// are we done yet?
+		glw_state->totalVertices -= glw_state->maxVertices;
+		if (glw_state->totalVertices <= 0)
+		{
+			glw_state->numVertices = glw_state->maxVertices;
+			break;
+		}
+
+		// ready for another cycle
+		glw_state->drawArray += glw_state->maxVertices *
+			glw_state->drawStride;
+		glw_state->maxVertices = _getMaxVerts();
+
+		glw_state->drawArray = _restartDrawPacket(
+			glw_state->drawArray, glw_state->maxVertices);
+	}
+
+	// finish up the draw
+	qglEnd();
+}
+
+void renderObject_Bump()
+{
+	// start the draw mode
+	assert(!glw_state->inDrawBlock);
+
+	glw_state->inDrawBlock = true;
+	glw_state->primitiveMode = D3DPT_TRIANGLELIST;
+
+	glw_state->drawStride = 13;
+
+	// set vertex counters
+	glw_state->numVertices = 0;
+	glw_state->totalVertices = tess.numIndexes;
+	glw_state->maxVertices = _getMaxVerts();	
+
+	// open a draw packet
+	//int num_packets = ((tess.numIndexes * glw_state->drawStride) / GLW_MAX_DRAW_PACKET_SIZE) + 1;
+	int num_packets;
+	if(tess.numIndexes == 0) {
+		num_packets = 1;
+	} else {
+		num_packets = (tess.numIndexes / glw_state->maxVertices) + (!!(tess.numIndexes % glw_state->maxVertices));
+	}
+	int cmd_size = num_packets * 3;
+	int vert_size = glw_state->drawStride * tess.numIndexes;
+
+	glw_state->device->BeginPush(vert_size + cmd_size + 2, 
+		&glw_state->drawArray);
+
+	glw_state->drawArray = _restartDrawPacket(
+		glw_state->drawArray, glw_state->maxVertices);
+
+	// get the draw function we need
+	drawelemfunc_t func = _drawElementsBumpShader;
+
+	// loop taking care not to draw too much at a time
+	int inc = glw_state->maxVertices;
+	for (int start = 0; ; start += inc)
+	{
+		// draw glw_state->maxVertices amount of geometry
+		func(glw_state->maxVertices, &(((GLushort*)tess.indexes)[start]));
+
+		// are we done yet?
+		glw_state->totalVertices -= glw_state->maxVertices;
+		if (glw_state->totalVertices <= 0)
+		{
+			glw_state->numVertices = glw_state->maxVertices;
+			break;
+		}
+
+		// ready for another cycle
+		glw_state->drawArray += glw_state->maxVertices *
+			glw_state->drawStride;
+		glw_state->maxVertices = _getMaxVerts();
+
+		glw_state->drawArray = _restartDrawPacket(
+			glw_state->drawArray, glw_state->maxVertices);
+	}
+
+	// finish up the draw
+	qglEnd();
+}
+
+void renderObject_Env()
+{
+	//glw_state->drawStride = 7;
+	//_updateTextures();
+
+	//glw_state->primitiveMode = D3DPT_TRIANGLESTRIP;
+ // 
+	//// get the necessary draw function
+	//drawelemfunc_t func = _drawElementsVCN;
+	//int stride = glw_state->drawStride;
+
+	//if(tess.currentPass == 0)
+	//{
+ //       buildStrips(glw_state->strip_lengths, &glw_state->num_strip_lengths, glw_state->strip_dest,
+	//			&tess.numIndexes, &tess.indexes[0]);
+	//}
+
+	//int index = 0;
+	//for (int l = 0; l < glw_state->num_strip_lengths; ++l)
+	//{
+	//	int cur_len = glw_state->strip_lengths[l];
+
+	//	// start a draw packet
+	//	DWORD* push;
+	//	glw_state->device->BeginPush(stride * cur_len + 5, &push);
+	//	push = _restartDrawPacket(push, cur_len);
+ //
+	//	// draw the geometry
+	//	glw_state->drawArray = push;
+	//	func(cur_len, &glw_state->strip_dest[index]);
+	//	index += cur_len;
+
+	//	// finish the draw packet
+	//	push = _terminateDrawPacket(&push[stride * cur_len]);
+	//	glw_state->device->EndPush(push);
+	//}
+
+	// start the draw mode
+	assert(!glw_state->inDrawBlock);
+
+	glw_state->inDrawBlock = true;
+	glw_state->primitiveMode = D3DPT_TRIANGLELIST;
+
+	glw_state->drawStride = 7;
+	_updateTextures();
+
+	// set vertex counters
+	glw_state->numVertices = 0;
+	glw_state->totalVertices = tess.numIndexes;
+	glw_state->maxVertices = _getMaxVerts();	
+
+	// open a draw packet
+	//int num_packets = ((tess.numIndexes * glw_state->drawStride) / GLW_MAX_DRAW_PACKET_SIZE) + 1;
+	int num_packets;
+	if(tess.numIndexes == 0) {
+		num_packets = 1;
+	} else {
+		num_packets = (tess.numIndexes / glw_state->maxVertices) + (!!(tess.numIndexes % glw_state->maxVertices));
+	}
+	int cmd_size = num_packets * 3;
+	int vert_size = glw_state->drawStride * tess.numIndexes;
+	
+	glw_state->device->BeginPush(vert_size + cmd_size + 2, 
+		&glw_state->drawArray);
+	
+	glw_state->drawArray = _restartDrawPacket(
+		glw_state->drawArray, glw_state->maxVertices);
+
+	// get the draw function we need
+	drawelemfunc_t func = _drawElementsVCN;
+
+	// loop taking care not to draw too much at a time
+	int inc = glw_state->maxVertices;
+	for (int start = 0; ; start += inc)
+	{
+		// draw glw_state->maxVertices amount of geometry
+		func(glw_state->maxVertices, &(((GLushort*)tess.indexes)[start]));
+		
+		// are we done yet?
+		glw_state->totalVertices -= glw_state->maxVertices;
+		if (glw_state->totalVertices <= 0)
+		{
+			glw_state->numVertices = glw_state->maxVertices;
+			break;
+		}
+
+		// ready for another cycle
+		glw_state->drawArray += glw_state->maxVertices *
+			glw_state->drawStride;
+		glw_state->maxVertices = _getMaxVerts();
+
+		glw_state->drawArray = _restartDrawPacket(
+			glw_state->drawArray, glw_state->maxVertices);
+	}
+
+	// finish up the draw
+	qglEnd();
+}
+#endif
+
+// EXTENSION: Take an array of triangle indices and draw
+// the appropriate triangle strips.  Virtually ALL geometry
+// is drawn with this function so it better be fast.
+static void dllIndexedTriToStrip(GLsizei count, const GLushort *indices)
+{
+#ifdef GLW_USE_TRI_STRIPS
+
+	// update the render state
+	_updateDrawStride(glw_state->normalArrayState,
+		glw_state->texCoordArrayState[0] ? count : 0,
+		glw_state->texCoordArrayState[1] ? count : 0);
+	_updateShader(glw_state->normalArrayState,
+		glw_state->texCoordArrayState[0],
+		glw_state->texCoordArrayState[1]);
+	_updateTextures();
+	_updateMatrices();
+	
+	// convert triangles to strips -- guarantees that
+	// no strip exceeds the max draw packet size
+	if(tess.currentPass == 0)
+	{
+		buildStrips(glw_state->strip_lengths, 
+			&glw_state->num_strip_lengths, glw_state->strip_dest, &count, indices);
+	}
+
+	// Yeah, its a hack, but I gotta do this so bumpmapping
+	// doesnt go all crazy on the 'force speed' effect and 
+	// 'disintegration' effect
+	if(tess.shader && 
+		tess.shader->isBumpMap && 
+		(backEnd.currentEntity->e.renderfx & 
+// VVFIXME : This is probably wrong. It looks like RF_ALPHA_FADE is renamed
+// RF_RGB_TINT in MP. Substitute?
+#ifndef _JK2MP
+		(RF_ALPHA_FADE | RF_DISINTEGRATE1 | RF_DISINTEGRATE2)))
+#else
+		(RF_DISINTEGRATE1 | RF_DISINTEGRATE2)))
+#endif
+	{
+		if(tess.currentPass != 2)
+			return;
+	}
+
+#ifdef _XBOX
+	glw_state->primitiveMode = D3DPT_TRIANGLESTRIP;
+
+	// get the necessary draw function
+	drawelemfunc_t func = _drawElementFuncTable[_getDrawFunc()];
+	int stride = glw_state->drawStride;
+	
+	int index = 0;
+	for (int l = 0; l < glw_state->num_strip_lengths; ++l)
+	{
+		int cur_len = glw_state->strip_lengths[l];
+		
+		// start a draw packet
+		DWORD* push;
+		glw_state->device->BeginPush(stride * cur_len + 5, &push);
+		push = _restartDrawPacket(push, cur_len);
+		
+		// draw the geometry
+		glw_state->drawArray = push;
+		func(cur_len, &glw_state->strip_dest[index]);
+		index += cur_len;
+		
+		// finish the draw packet
+		push = _terminateDrawPacket(&push[stride * cur_len]);
+		glw_state->device->EndPush(push);
+	}
+#else _XBOX
+	// simplified render on the PC
+	int index = 0;
+	for (int l = 0; l < glw_state->num_strip_lengths; ++l)
+	{
+		dllDrawElements(GL_TRIANGLE_STRIP, glw_state->strip_lengths[l], 
+			GL_UNSIGNED_SHORT, &glw_state->strip_dest[index]);
+		index += glw_state->strip_lengths[l];
+	}
+#endif _XBOX
+
+#else GLW_USE_TRI_STRIPS
+	// just render simple triangles
+	dllDrawElements(GL_TRIANGLES, count, GL_UNSIGNED_SHORT, indices);
+#endif GLW_USE_TRI_STRIPS
+}
+
+static void dllIndexMask(GLuint mask)
+{
+	assert(0);
+}
+
+static void dllIndexPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
+{
+	assert(0);
+}
+
+static void dllIndexd(GLdouble c)
+{
+	assert(0);
+}
+
+static void dllIndexdv(const GLdouble *c)
+{
+	assert(0);
+}
+
+static void dllIndexf(GLfloat c)
+{
+	assert(0);
+}
+
+static void dllIndexfv(const GLfloat *c)
+{
+	assert(0);
+}
+
+static void dllIndexi(GLint c)
+{
+	assert(0);
+}
+
+static void dllIndexiv(const GLint *c)
+{
+	assert(0);
+}
+
+static void dllIndexs(GLshort c)
+{
+	assert(0);
+}
+
+static void dllIndexsv(const GLshort *c)
+{
+	assert(0);
+}
+
+static void dllIndexub(GLubyte c)
+{
+	assert(0);
+}
+
+static void dllIndexubv(const GLubyte *c)
+{
+	assert(0);
+}
+
+static void dllInitNames(void)
+{
+	assert(0);
+}
+
+static void dllInterleavedArrays(GLenum format, GLsizei stride, const GLvoid *pointer)
+{
+	assert(0);
+}
+
+GLboolean dllIsEnabled(GLenum cap)
+{
+	DWORD flag;
+	switch (cap)
+	{
+	case GL_ALPHA_TEST: glw_state->device->GetRenderState(D3DRS_ALPHATESTENABLE, &flag); break;
+	case GL_BLEND: glw_state->device->GetRenderState(D3DRS_ALPHABLENDENABLE, &flag); break;
+	case GL_CULL_FACE: return glw_state->cullEnable;
+	case GL_DEPTH_TEST: glw_state->device->GetRenderState(D3DRS_ZENABLE, &flag); break;
+	case GL_FOG: glw_state->device->GetRenderState(D3DRS_FOGENABLE, &flag); break;
+	case GL_LIGHTING: glw_state->device->GetRenderState(D3DRS_LIGHTING, &flag); break;
+#ifdef _XBOX
+	case GL_POLYGON_OFFSET_FILL: glw_state->device->GetRenderState(D3DRS_SOLIDOFFSETENABLE, &flag); break;
+#else
+	case GL_POLYGON_OFFSET_FILL: return FALSE;
+#endif
+	case GL_SCISSOR_TEST: return glw_state->scissorEnable;
+	case GL_STENCIL_TEST: glw_state->device->GetRenderState(D3DRS_STENCILENABLE, &flag); break;
+	case GL_TEXTURE_2D: return glw_state->textureStageEnable[glw_state->serverTU];
+	default: return FALSE;
+	}
+	return flag;
+}
+
+GLboolean dllIsList(GLuint lnum)
+{
+	assert(0);
+	return 1;
+}
+
+GLboolean dllIsTexture(GLuint texture)
+{
+	assert(0);
+	return 1;
+}
+
+static void dllLightModelf(GLenum pname, GLfloat param)
+{
+	assert(0);
+}
+
+static void dllLightModelfv(GLenum pname, const GLfloat *params)
+{
+	assert(0);
+}
+
+static void dllLightModeli(GLenum pname, GLint param)
+{
+	assert(0);
+}
+
+static void dllLightModeliv(GLenum pname, const GLint *params)
+{
+	assert(0);
+}
+
+static void dllLightf(GLenum light, GLenum pname, GLfloat param)
+{
+	assert(0);
+}
+
+static void dllLightfv(GLenum light, GLenum pname, const GLfloat *params)
+{
+	switch(pname)
+	{
+	case GL_AMBIENT:
+		{
+			glw_state->dirLight.Ambient.r = params[0] / 255.0f;
+			glw_state->dirLight.Ambient.g = params[1] / 255.0f;
+			glw_state->dirLight.Ambient.b = params[2] / 255.0f;
+		}
+		break;
+
+	case GL_DIFFUSE:
+		{
+			glw_state->dirLight.Diffuse.r = params[0] / 255.0f;
+			glw_state->dirLight.Diffuse.g = params[1] / 255.0f;
+			glw_state->dirLight.Diffuse.b = params[2] / 255.0f;
+		}
+		break;
+
+	case GL_SPECULAR:
+		{
+			glw_state->dirLight.Specular.r = params[0] / 255.0f;
+			glw_state->dirLight.Specular.g = params[1] / 255.0f;
+			glw_state->dirLight.Specular.b = params[2] / 255.0f;
+		}
+		break;
+	case GL_POSITION:
+		{
+			glw_state->dirLight.Position.x = params[0];
+			glw_state->dirLight.Position.y = params[1];
+			glw_state->dirLight.Position.z = params[2];
+		}
+		break;
+
+	case GL_SPOT_DIRECTION:
+		{
+			glw_state->dirLight.Direction.x = -params[0];
+			glw_state->dirLight.Direction.y = -params[1];
+			glw_state->dirLight.Direction.z = -params[2];
+		}
+		break;
+
+	default:
+		assert(0);
+		break;
+	}
+
+	glw_state->device->SetLight(light, &glw_state->dirLight);
+	glw_state->device->LightEnable(light, TRUE);
+}
+
+static void dllLighti(GLenum light, GLenum pname, GLint param)
+{
+	assert(0);
+}
+
+static void dllLightiv(GLenum light, GLenum pname, const GLint *params)
+{
+	assert(0);
+}
+
+static void dllLineStipple(GLint factor, GLushort pattern)
+{
+	assert(0);
+}
+
+static void dllLineWidth(GLfloat width)
+{
+//	assert(0);
+}
+
+static void dllListBase(GLuint base)
+{
+	assert(0);
+}
+
+static void dllLoadIdentity(void)
+{
+	glw_state->matrixStack[glw_state->matrixMode]->LoadIdentity();
+	glw_state->matricesDirty[glw_state->matrixMode] = true;
+}
+
+static void dllLoadMatrixd(const GLdouble *m)
+{
+	assert(0);
+}
+
+static void dllLoadMatrixf(const GLfloat *m)
+{
+	glw_state->matrixStack[glw_state->matrixMode]->LoadMatrix((D3DXMATRIX*)m);
+	glw_state->matricesDirty[glw_state->matrixMode] = true;
+}
+
+static void dllLoadName(GLuint name)
+{
+	assert(0);
+}
+
+static void dllLogicOp(GLenum opcode)
+{
+	assert(0);
+}
+
+static void dllMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points)
+{
+	assert(0);
+}
+
+static void dllMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points)
+{
+	assert(0);
+}
+
+static void dllMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points)
+{
+	assert(0);
+}
+
+static void dllMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points)
+{
+	assert(0);
+}
+
+static void dllMapGrid1d(GLint un, GLdouble u1, GLdouble u2)
+{
+	assert(0);
+}
+
+static void dllMapGrid1f(GLint un, GLfloat u1, GLfloat u2)
+{
+	assert(0);
+}
+
+static void dllMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2)
+{
+	assert(0);
+}
+
+static void dllMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2)
+{
+	assert(0);
+}
+
+static void dllMaterialf(GLenum face, GLenum pname, GLfloat param)
+{
+	assert(0);
+}
+
+static void dllMaterialfv(GLenum face, GLenum pname, const GLfloat *params)
+{
+	switch(pname)
+	{
+	case GL_AMBIENT:
+		glw_state->mtrl.Ambient.r = params[0] / 255.0f;
+		glw_state->mtrl.Ambient.g = params[1] / 255.0f;
+		glw_state->mtrl.Ambient.b = params[2] / 255.0f;
+		glw_state->mtrl.Ambient.a = params[3] / 255.0f;
+		break;
+
+	case GL_DIFFUSE:
+		glw_state->mtrl.Diffuse.r = params[0] / 255.0f;
+		glw_state->mtrl.Diffuse.g = params[1] / 255.0f;
+		glw_state->mtrl.Diffuse.b = params[2] / 255.0f;
+		glw_state->mtrl.Diffuse.a = params[3] / 255.0f;
+		break;
+
+	case GL_SPECULAR:
+		glw_state->mtrl.Specular.r = params[0] / 255.0f;
+		glw_state->mtrl.Specular.g = params[1] / 255.0f;
+		glw_state->mtrl.Specular.b = params[2] / 255.0f;
+		glw_state->mtrl.Specular.a = params[3] / 255.0f;
+		break;
+
+	case GL_EMISSION:
+		glw_state->mtrl.Emissive.r = params[0] / 255.0f;
+		glw_state->mtrl.Emissive.g = params[1] / 255.0f;
+		glw_state->mtrl.Emissive.b = params[2] / 255.0f;
+		glw_state->mtrl.Emissive.a = params[3] / 255.0f;
+		break;
+
+	default:
+		assert(0);
+		break;
+	}
+
+	glw_state->device->SetMaterial(&glw_state->mtrl);
+}
+
+static void dllMateriali(GLenum face, GLenum pname, GLint param)
+{
+	assert(0);
+}
+
+static void dllMaterialiv(GLenum face, GLenum pname, const GLint *params)
+{
+	assert(0);
+}
+
+static void dllMatrixMode(GLenum mode)
+{
+	switch (mode)
+	{
+	case GL_MODELVIEW: glw_state->matrixMode = glwstate_t::MatrixMode_Model; break;
+	case GL_PROJECTION: glw_state->matrixMode = glwstate_t::MatrixMode_Projection; break;
+#ifdef _XBOX
+	case GL_TEXTURE0: glw_state->matrixMode = glwstate_t::MatrixMode_Texture0; break;
+	case GL_TEXTURE1: glw_state->matrixMode = glwstate_t::MatrixMode_Texture1; break;
+#endif
+	default: assert(false); break;
+	}
+}
+
+static void dllMultMatrixd(const GLdouble *m)
+{
+	assert(0);
+}
+
+static void dllMultMatrixf(const GLfloat *m)
+{
+	glw_state->matrixStack[glw_state->matrixMode]->MultMatrixLocal((D3DXMATRIX*)m);
+	glw_state->matricesDirty[glw_state->matrixMode] = true;
+}
+
+static void dllNewList(GLuint lnum, GLenum mode)
+{
+	assert(0);
+}
+
+static void setNormal(float x, float y, float z)
+{
+	assert(glw_state->inDrawBlock);
+
+	_handleDrawOverflow();
+	
+	DWORD* push = &glw_state->drawArray[glw_state->numVertices * glw_state->drawStride + 4];
+	push[0] = *((DWORD*)&x);
+	push[1] = *((DWORD*)&y);
+	push[2] = *((DWORD*)&z);
+	push[3] = glw_state->currentColor;
+}
+static void dllNormal3b(GLbyte nx, GLbyte ny, GLbyte nz)
+{
+	assert(0);
+}
+
+static void dllNormal3bv(const GLbyte *v)
+{
+	assert(0);
+}
+
+static void dllNormal3d(GLdouble nx, GLdouble ny, GLdouble nz)
+{
+	assert(0);
+}
+
+static void dllNormal3dv(const GLdouble *v)
+{
+	assert(0);
+}
+
+static void dllNormal3f(GLfloat nx, GLfloat ny, GLfloat nz)
+{
+	setNormal(nx, ny, nz);
+}
+
+static void dllNormal3fv(const GLfloat *v)
+{
+	setNormal(v[0], v[1], v[2]);
+}
+
+static void dllNormal3i(GLint nx, GLint ny, GLint nz)
+{
+	assert(0);
+}
+
+static void dllNormal3iv(const GLint *v)
+{
+	assert(0);
+}
+
+static void dllNormal3s(GLshort nx, GLshort ny, GLshort nz)
+{
+	assert(0);
+}
+
+static void dllNormal3sv(const GLshort *v)
+{
+	assert(0);
+}
+
+static void dllNormalPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
+{
+	assert(type == GL_FLOAT);
+	
+	stride = (stride == 0) ? (sizeof(GLfloat) * 3) : stride;
+
+	glw_state->normalPointer = pointer;
+	glw_state->normalStride = stride;
+}
+
+static void dllOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
+{
+	D3DXMATRIX m;
+	D3DXMatrixOrthoOffCenterRH(&m, left, right, top, bottom, zNear, zFar);
+	glw_state->matrixStack[glw_state->matrixMode]->MultMatrix(&m);
+	glw_state->matricesDirty[glw_state->matrixMode] = true;
+}
+
+static void dllPassThrough(GLfloat token)
+{
+	assert(0);
+}
+
+static void dllPixelMapfv(GLenum map, GLsizei mapsize, const GLfloat *values)
+{
+	assert(0);
+}
+
+static void dllPixelMapuiv(GLenum map, GLsizei mapsize, const GLuint *values)
+{
+	assert(0);
+}
+
+static void dllPixelMapusv(GLenum map, GLsizei mapsize, const GLushort *values)
+{
+	assert(0);
+}
+
+static void dllPixelStoref(GLenum pname, GLfloat param)
+{
+	assert(0);
+}
+
+static void dllPixelStorei(GLenum pname, GLint param)
+{
+	assert(0);
+}
+
+static void dllPixelTransferf(GLenum pname, GLfloat param)
+{
+	assert(0);
+}
+
+static void dllPixelTransferi(GLenum pname, GLint param)
+{
+	assert(0);
+}
+
+static void dllPixelZoom(GLfloat xfactor, GLfloat yfactor)
+{
+	assert(0);
+}
+
+static void dllPointSize(GLfloat size)
+{
+	glw_state->device->SetRenderState(D3DRS_POINTSCALEENABLE, TRUE);
+	glw_state->device->SetRenderState(D3DRS_POINTSIZE, *((DWORD*)&size));
+}
+
+static void dllPolygonMode(GLenum face, GLenum mode)
+{
+	D3DFILLMODE m;
+	switch (mode)
+	{
+	case GL_POINT: m = D3DFILL_POINT; break;
+	case GL_LINE: m = D3DFILL_WIREFRAME; break;
+	case GL_FILL: m = D3DFILL_SOLID; break;
+	default: assert(0); break;
+	}
+
+	switch (face)
+	{
+	case GL_FRONT:
+		glw_state->device->SetRenderState(D3DRS_FILLMODE, m);
+		break;
+	case GL_BACK:
+#ifdef _XBOX
+		glw_state->device->SetRenderState(D3DRS_BACKFILLMODE, m);
+#endif
+		break;
+	case GL_FRONT_AND_BACK:
+		glw_state->device->SetRenderState(D3DRS_FILLMODE, m);
+#ifdef _XBOX
+		glw_state->device->SetRenderState(D3DRS_BACKFILLMODE, m);
+#endif
+		break;
+	}
+}
+
+static void dllPolygonOffset(GLfloat factor, GLfloat units)
+{
+#ifdef _XBOX
+	glw_state->device->SetRenderState(D3DRS_POLYGONOFFSETZOFFSET, *((DWORD*)&factor));
+	glw_state->device->SetRenderState(D3DRS_POLYGONOFFSETZSLOPESCALE, *((DWORD*)&units));
+#endif
+}
+
+static void dllPolygonStipple(const GLubyte *mask)
+{
+	assert(0);
+}
+
+static void dllPopAttrib(void)
+{
+	assert(0);
+}
+
+static void dllPopClientAttrib(void)
+{
+	assert(0);
+}
+
+static void dllPopMatrix(void)
+{
+	glw_state->matrixStack[glw_state->matrixMode]->Pop();
+	glw_state->matricesDirty[glw_state->matrixMode] = true;
+}
+
+static void dllPopName(void)
+{
+	assert(0);
+}
+
+static void dllPrioritizeTextures(GLsizei n, const GLuint *textures, const GLclampf *priorities)
+{
+	assert(0);
+}
+
+static void dllPushAttrib(GLbitfield mask)
+{
+	assert(0);
+}
+
+static void dllPushClientAttrib(GLbitfield mask)
+{
+	assert(0);
+}
+
+static void dllPushMatrix(void)
+{
+	glw_state->matrixStack[glw_state->matrixMode]->Push();
+	glw_state->matricesDirty[glw_state->matrixMode] = true;
+}
+
+static void dllPushName(GLuint name)
+{
+	assert(0);
+}
+
+static void dllRasterPos2d(GLdouble x, GLdouble y)
+{
+	assert(0);
+}
+
+static void dllRasterPos2dv(const GLdouble *v)
+{
+	assert(0);
+}
+
+static void dllRasterPos2f(GLfloat x, GLfloat y)
+{
+	assert(0);
+}
+
+static void dllRasterPos2fv(const GLfloat *v)
+{
+	assert(0);
+}
+
+static void dllRasterPos2i(GLint x, GLint y)
+{
+	assert(0);
+}
+
+static void dllRasterPos2iv(const GLint *v)
+{
+	assert(0);
+}
+
+static void dllRasterPos2s(GLshort x, GLshort y)
+{
+	assert(0);
+}
+
+static void dllRasterPos2sv(const GLshort *v)
+{
+	assert(0);
+}
+
+static void dllRasterPos3d(GLdouble x, GLdouble y, GLdouble z)
+{
+	assert(0);
+}
+
+static void dllRasterPos3dv(const GLdouble *v)
+{
+	assert(0);
+}
+
+static void dllRasterPos3f(GLfloat x, GLfloat y, GLfloat z)
+{
+	assert(0);
+}
+
+static void dllRasterPos3fv(const GLfloat *v)
+{
+	assert(0);
+}
+
+static void dllRasterPos3i(GLint x, GLint y, GLint z)
+{
+	assert(0);
+}
+
+static void dllRasterPos3iv(const GLint *v)
+{
+	assert(0);
+}
+
+static void dllRasterPos3s(GLshort x, GLshort y, GLshort z)
+{
+	assert(0);
+}
+
+static void dllRasterPos3sv(const GLshort *v)
+{
+	assert(0);
+}
+
+static void dllRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
+{
+	assert(0);
+}
+
+static void dllRasterPos4dv(const GLdouble *v)
+{
+	assert(0);
+}
+
+static void dllRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
+{
+	assert(0);
+}
+
+static void dllRasterPos4fv(const GLfloat *v)
+{
+	assert(0);
+}
+
+static void dllRasterPos4i(GLint x, GLint y, GLint z, GLint w)
+{
+	assert(0);
+}
+
+static void dllRasterPos4iv(const GLint *v)
+{
+	assert(0);
+}
+
+static void dllRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w)
+{
+	assert(0);
+}
+
+static void dllRasterPos4sv(const GLshort *v)
+{
+	assert(0);
+}
+
+static void dllReadBuffer(GLenum mode)
+{
+	assert(0);
+}
+
+static void dllReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei twidth, GLsizei theight, GLvoid *pixels)
+{
+	assert(format == GL_RGBA && type == GL_UNSIGNED_BYTE);
+	
+	/*
+	// create a temporary storage surface
+	IDirect3DSurface8 *target;
+	glw_state->device->CreateImageSurface(twidth, theight, D3DFMT_A8R8G8B8, &target);
+
+	// get a pointer to the back buffer
+	IDirect3DSurface8* screen;
+	glw_state->device->GetBackBuffer(0, D3DBACKBUFFER_TYPE_MONO, &screen);
+	
+	// copy the back buffer into a surface of the appropriate size and format	
+	RECT r;
+	r.left = x;
+	r.top = y;
+	r.right = x + width;
+	r.bottom = y + height;
+	D3DXLoadSurfaceFromSurface(target, NULL, NULL, screen, NULL, &r, D3DX_DEFAULT, 0);
+	screen->Release();
+
+	// lock the target surface
+	D3DLOCKED_RECT lock;
+	target->LockRect(&lock, NULL, D3DLOCK_READONLY);
+
+	// copy the pixel data
+	for (int y = 0; y < theight; ++y)
+	{
+		memcpy((char*)pixels + twidth * y * 4, 
+			(char*)lock.pBits + lock.Pitch * y, 
+			twidth * 4);
+	}
+
+	// all done
+	target->UnlockRect();
+	target->Release();
+	*/
+
+	/*
+	// create target storage surface
+	IDirect3DSurface8 *target;
+	glw_state->device->CreateImageSurface(twidth, theight, D3DFMT_A8R8G8B8, &target);
+
+	// get a pointer to the back buffer
+	IDirect3DSurface8* back;
+	glw_state->device->GetBackBuffer(0, D3DBACKBUFFER_TYPE_MONO, &back);
+
+	D3DSURFACE_DESC ddsd;
+	back->GetDesc(&ddsd);
+	int bpp = XGBytesPerPixelFromFormat(ddsd.Format);
+	
+	// create surface to hold screen data
+	// (512x512 is exactly big enough to hold the screen but we
+	// need to save some memory so I'm going to clip the edges)
+	IDirect3DSurface8 *screen;
+	glw_state->device->CreateImageSurface(512, 512, ddsd.Format, &screen);
+
+	// copy back buffer to non-tiled screen surface
+	RECT r;
+	r.left = 64;
+	r.top = 0;
+	r.right = 576;
+	r.bottom = 480;
+	POINT ul = {0, 0};
+	glw_state->device->CopyRects(back, &r, 1, screen, &ul);
+	back->Release();
+
+	// deswizzle the screen
+	D3DLOCKED_RECT lock;
+	screen->LockRect(&lock, NULL, D3DLOCK_READONLY);
+	void* deswizzled = Z_Malloc(512*512*bpp, TAG_TEMP_WORKSPACE, qfalse, 16);
+	XGUnswizzleRect(lock.pBits, 512, 512, NULL, deswizzled, 0, NULL, bpp);
+	screen->UnlockRect();
+	screen->Release();
+	
+	// copy the screen into a surface of the appropriate size and format	
+	r.left = 0;
+	r.top = 0;
+	r.right = 512;
+	r.bottom = 480;
+	D3DXLoadSurfaceFromMemory(target, NULL, NULL, deswizzled, ddsd.Format, 
+		512*bpp, NULL, &r, D3DX_DEFAULT, 0);
+	Z_Free(deswizzled);
+
+	// lock the target surface
+	target->LockRect(&lock, NULL, D3DLOCK_READONLY);
+
+	// copy the pixel data
+	for (int y = 0; y < theight; ++y)
+	{
+		memcpy((char*)pixels + twidth * y * 4, 
+			(char*)lock.pBits + lock.Pitch * y, 
+			twidth * 4);
+	}
+
+	// all done
+	target->UnlockRect();
+	target->Release();
+	*/
+}
+
+/**********
+dllCopyBackBufferToTex
+Does a direct copy of the backbuffer to the current texture. The current texture
+must be linear, and it must be 640 x 480 in size. If a more complex copy is
+needed, use dllCopyBackBufferToTexEXT.
+**********/
+static void dllCopyBackBufferToTex()
+{
+	glwstate_t::TextureInfo* info = _getCurrentTexture(glw_state->serverTU);
+	if (info == NULL) return;
+
+	LPDIRECT3DSURFACE8 surf;
+	LPDIRECT3DSURFACE8 backbuffer;
+
+	info->mipmap->GetSurfaceLevel(0, &surf);
+	glw_state->device->GetBackBuffer(0, D3DBACKBUFFER_TYPE_MONO, &backbuffer);
+
+	glw_state->device->CopyRects(backbuffer, NULL, 0, surf, NULL);
+
+	surf->Release();
+	backbuffer->Release();
+}
+
+/**********
+dllCopyBackBufferToTexEXT
+Copies a portion of the backbuffer to a texture
+If the destination is a DXT1 texture, then the buffer will be compressed
+width	- width of the backbuffer polygon rendered to the destination texture
+height	- height of the backbuffer polygon rendered to the destination texture
+u,v		- describes the potion of the backbuffer to be copied in screen coords
+**********/
+static void dllCopyBackBufferToTexEXT(float width, float height, float u1, float v1, float u2, float v2)
+{
+	glwstate_t::TextureInfo* info = _getCurrentTexture(glw_state->serverTU);
+	if (info == NULL) return;
+
+	struct QUAD { D3DXVECTOR4 p; FLOAT tu,tv;} q[4];
+	q[0].p	= D3DXVECTOR4( 0.0f, 0.0f, 1.0f, 1.0f );
+	q[0].tu = u1;		q[0].tv = v1;
+	q[1].p	= D3DXVECTOR4( width, 0.0f, 1.0f, 1.0f );
+	q[1].tu = u2;	q[1].tv = v1;
+	q[2].p	= D3DXVECTOR4( 0.0f, height , 1.0f, 1.0f );
+	q[2].tu = u1;		q[2].tv = v2;
+	q[3].p	= D3DXVECTOR4( width, height, 1.0f, 1.0f );
+	q[3].tu = u2;	q[3].tv = v2;
+
+
+	LPDIRECT3DSURFACE8	pSurface;
+	LPDIRECT3DSURFACE8	pBackBuffer;
+	LPDIRECT3DSURFACE8	pStencilBuffer;
+	D3DSURFACE_DESC		desc;
+	D3DBaseTexture*		pTexStage0;
+	D3DBaseTexture*		pTexStage1;
+	D3DBaseTexture*		pTexStage2;
+	D3DBaseTexture*		pTexStage3;
+	D3DTexture*			pRenderTex;
+	int					w	= 0;
+	int					h	= 0;
+
+	DWORD srcblend, destblend, alphablend, alphatest, zwrite, zenable, vShader, pShader;
+	DWORD colorop, colorarg1, addressu, addressv, minfilter, magfilter, colorwriteenable;
+
+	// save the current state
+	glw_state->device->GetRenderState( D3DRS_SRCBLEND, &srcblend );
+	glw_state->device->GetRenderState( D3DRS_DESTBLEND, &destblend );
+	glw_state->device->GetRenderState( D3DRS_ALPHABLENDENABLE, &alphablend );
+	glw_state->device->GetRenderState( D3DRS_ALPHATESTENABLE, &alphatest );
+	glw_state->device->GetRenderState( D3DRS_ZWRITEENABLE, &zwrite );
+	glw_state->device->GetRenderState( D3DRS_ZENABLE, &zenable );
+	glw_state->device->GetRenderState( D3DRS_COLORWRITEENABLE, &colorwriteenable);
+	glw_state->device->GetVertexShader( &vShader );
+	glw_state->device->GetPixelShader( &pShader );
+	glw_state->device->GetTexture(0,&pTexStage0);
+	glw_state->device->GetTexture(1,&pTexStage1);
+	glw_state->device->GetTexture(2,&pTexStage2);
+	glw_state->device->GetTexture(3,&pTexStage3);
+	glw_state->device->GetTextureStageState(0, D3DTSS_COLOROP, &colorop);
+	glw_state->device->GetTextureStageState(0, D3DTSS_COLORARG1, &colorarg1);
+	glw_state->device->GetTextureStageState(0, D3DTSS_ADDRESSU, &addressu);
+	glw_state->device->GetTextureStageState(0, D3DTSS_ADDRESSV, &addressv);
+	glw_state->device->GetTextureStageState(0, D3DTSS_MINFILTER, &minfilter);
+	glw_state->device->GetTextureStageState(0, D3DTSS_MAGFILTER, &magfilter);
+
+	// get the buffers
+	glw_state->device->GetBackBuffer(0, D3DBACKBUFFER_TYPE_MONO, &pBackBuffer);
+	glw_state->device->GetDepthStencilSurface(&pStencilBuffer);
+
+	// get a surface desc
+	info->mipmap->GetLevelDesc(0, &desc);
+
+	// check to see if the texture needs to be resized
+	if( desc.Width != width || desc.Height != height)
+	{
+		int refCount;
+		refCount = info->mipmap->Release();
+
+		// Had to remove this. Multiple characters using force push in one
+		// frame triggers the assert. Things clean up by the end of the frame.
+//		assert(refCount == 0);
+
+		glw_state->device->CreateTexture(	width,
+											height,
+											1,
+											0,
+											desc.Format,
+											0,
+											&info->mipmap );
+	}
+
+	// check to see if we want a compressed output texture
+	if( desc.Format == D3DFMT_DXT1)
+	{
+
+		w	= desc.Width;
+		h	= desc.Height;
+
+		// create a new texture to use as a render target
+		glw_state->device->CreateTexture(	w,
+											h,
+											1,
+											0,
+											D3DFMT_LIN_X8R8G8B8,
+											0,
+											&pRenderTex );
+	}
+	else
+	{
+		pRenderTex = info->mipmap;
+		
+	}
+
+	// make our current surface a render target
+	pRenderTex->GetSurfaceLevel(0, &pSurface);
+	glw_state->device->SetRenderTarget( pSurface, NULL );
+	
+	// set texture 0 to the back buffer data
+	glw_state->device->SetTexture(0,(LPDIRECT3DTEXTURE8)pBackBuffer);
+
+	// clear the other texture stages
+	glw_state->device->SetTexture(1, NULL);
+	glw_state->device->SetTexture(2, NULL);
+	glw_state->device->SetTexture(3, NULL);
+
+	// set the texture 0 state
+	glw_state->device->SetTextureStageState( 0, D3DTSS_COLOROP,   D3DTOP_SELECTARG1 );
+    glw_state->device->SetTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
+    glw_state->device->SetTextureStageState( 0, D3DTSS_ADDRESSU, D3DTADDRESS_CLAMP );
+    glw_state->device->SetTextureStageState( 0, D3DTSS_ADDRESSV, D3DTADDRESS_CLAMP );
+    glw_state->device->SetTextureStageState( 0, D3DTSS_MINFILTER, D3DTEXF_LINEAR );
+    glw_state->device->SetTextureStageState( 0, D3DTSS_MAGFILTER, D3DTEXF_LINEAR );
+	
+	// set the render state
+	glw_state->device->SetRenderState( D3DRS_ZENABLE,         FALSE );
+    glw_state->device->SetRenderState( D3DRS_ALPHATESTENABLE, FALSE );
+	glw_state->device->SetRenderState( D3DRS_ALPHABLENDENABLE, FALSE);
+	glw_state->device->SetRenderState( D3DRS_SRCBLEND, D3DBLEND_SRCALPHA );
+	glw_state->device->SetRenderState( D3DRS_DESTBLEND, D3DBLEND_SRCALPHA | D3DBLEND_INVSRCALPHA );
+	glw_state->device->SetRenderState( D3DRS_COLORWRITEENABLE, D3DCOLORWRITEENABLE_ALL);
+
+	// set our vertex shader and draw the backbuffer to the texture
+	glw_state->device->SetVertexShader( D3DFVF_XYZRHW|D3DFVF_TEX1 );
+	glw_state->device->SetPixelShader( NULL );
+	glw_state->device->Clear(NULL,NULL,D3DCLEAR_TARGET,D3DCOLOR_COLORVALUE(1.0f, 1.0f, 1.0f, 1.0f), 1.0f, 0);
+	glw_state->device->DrawPrimitiveUP( D3DPT_QUADSTRIP, 1, q, sizeof(QUAD) );
+
+	// now that everything is rendered, check again to see
+	// if we want a compressed texture
+	if( desc.Format == D3DFMT_DXT1)
+	{
+		LPDIRECT3DTEXTURE8	pSrcTex;
+		LPDIRECT3DTEXTURE8	pDstTex;
+		D3DLOCKED_RECT		srcLock;
+		D3DLOCKED_RECT		dstLock;
+
+		pSrcTex	= pRenderTex;
+		pDstTex	= info->mipmap;
+
+		// lock our textures
+		pSrcTex->LockRect(0, &srcLock, NULL, 0);
+		pDstTex->LockRect(0, &dstLock, NULL, 0);
+
+		// compress the texture
+		XGCompressRect(	dstLock.pBits,
+						D3DFMT_DXT1,
+						dstLock.Pitch,
+						w,
+						h,
+						srcLock.pBits,
+						D3DFMT_LIN_X8R8G8B8,
+						srcLock.Pitch,
+						1,
+						0 );
+
+		// unlock
+		pSrcTex->UnlockRect(0);
+		pDstTex->UnlockRect(0);
+
+		// release the render texture
+		pRenderTex->Release();
+	}
+
+	// return our state
+	glw_state->device->SetRenderState( D3DRS_SRCBLEND, srcblend );
+	glw_state->device->SetRenderState( D3DRS_DESTBLEND, destblend );
+	glw_state->device->SetRenderState( D3DRS_ALPHABLENDENABLE, alphablend );
+	glw_state->device->SetRenderState( D3DRS_ALPHATESTENABLE, alphatest );
+	glw_state->device->SetRenderState( D3DRS_ZWRITEENABLE, zwrite );
+	glw_state->device->SetRenderState( D3DRS_ZENABLE, zenable );
+	glw_state->device->SetRenderState( D3DRS_COLORWRITEENABLE, colorwriteenable);
+
+	glw_state->device->SetTexture(0,pTexStage0);
+	glw_state->device->SetTexture(1,pTexStage1);
+	glw_state->device->SetTexture(2,pTexStage2);
+	glw_state->device->SetTexture(3,pTexStage3);
+	glw_state->device->SetTextureStageState(0, D3DTSS_COLOROP, colorop);
+	glw_state->device->SetTextureStageState(0, D3DTSS_COLORARG1, colorarg1);
+	glw_state->device->SetTextureStageState(0, D3DTSS_ADDRESSU, addressu);
+	glw_state->device->SetTextureStageState(0, D3DTSS_ADDRESSV, addressv);
+	glw_state->device->SetTextureStageState(0, D3DTSS_MINFILTER, minfilter);
+	glw_state->device->SetTextureStageState(0, D3DTSS_MAGFILTER, magfilter);
+
+	glw_state->device->SetVertexShader( vShader );
+	glw_state->device->SetPixelShader( pShader );
+
+	glw_state->device->SetRenderTarget( pBackBuffer, pStencilBuffer );
+
+	// release our surfaces/textures
+	if(pTexStage0)
+		pTexStage0->Release();
+
+	if(pTexStage1)
+		pTexStage1->Release();
+
+	if(pTexStage2)
+		pTexStage2->Release();
+
+	if(pTexStage3)
+		pTexStage3->Release();
+
+	pSurface->Release();
+	pBackBuffer->Release();
+	pStencilBuffer->Release();
+}
+
+static void dllRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2)
+{
+	assert(0);
+}
+
+static void dllRectdv(const GLdouble *v1, const GLdouble *v2)
+{
+	assert(0);
+}
+
+static void dllRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)
+{
+	assert(0);
+}
+
+static void dllRectfv(const GLfloat *v1, const GLfloat *v2)
+{
+	assert(0);
+}
+
+static void dllRecti(GLint x1, GLint y1, GLint x2, GLint y2)
+{
+	assert(0);
+}
+
+static void dllRectiv(const GLint *v1, const GLint *v2)
+{
+	assert(0);
+}
+
+static void dllRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2)
+{
+	assert(0);
+}
+
+static void dllRectsv(const GLshort *v1, const GLshort *v2)
+{
+	assert(0);
+}
+
+GLint dllRenderMode(GLenum mode)
+{
+	assert(0);
+	return 0;
+}
+
+static void dllRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z)
+{
+	assert(0);
+}
+
+static void dllRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
+{
+	D3DXVECTOR3 v(x, y, z);
+	glw_state->matrixStack[glw_state->matrixMode]->RotateAxisLocal(&v, angle);
+	glw_state->matricesDirty[glw_state->matrixMode] = true;
+}
+
+static void dllScaled(GLdouble x, GLdouble y, GLdouble z)
+{
+	assert(0);
+}
+
+static void dllScalef(GLfloat x, GLfloat y, GLfloat z)
+{
+	glw_state->matrixStack[glw_state->matrixMode]->Scale(x, y, z);
+	glw_state->matricesDirty[glw_state->matrixMode] = true;
+}
+
+static void dllScissor(GLint x, GLint y, GLsizei width, GLsizei height)
+{
+#ifdef _XBOX
+	_fixupScreenCoords(x, y, width, height);
+
+	glw_state->scissorBox.x1 = x;
+	glw_state->scissorBox.y1 = y;
+	glw_state->scissorBox.x2 = x + width;
+	glw_state->scissorBox.y2 = y + height;
+	
+	if (glw_state->scissorEnable)
+	{
+		glw_state->device->SetScissors(1, FALSE, &glw_state->scissorBox);
+	}
+#endif
+}
+
+static void dllSelectBuffer(GLsizei size, GLuint *buffer)
+{
+	assert(0);
+}
+
+static void dllShadeModel(GLenum mode)
+{
+	D3DSHADEMODE m;
+	switch (mode)
+	{
+	case GL_FLAT: m = D3DSHADE_FLAT; break;
+	case GL_SMOOTH: default: m = D3DSHADE_GOURAUD; break;
+	}
+	
+	glw_state->device->SetRenderState(D3DRS_SHADEMODE, m);
+}
+
+static void dllStencilFunc(GLenum func, GLint ref, GLuint mask)
+{
+	D3DCMPFUNC f = _convertCompare(func);
+
+	glw_state->device->SetRenderState(D3DRS_STENCILFUNC, f);
+	glw_state->device->SetRenderState(D3DRS_STENCILREF, ref);
+	glw_state->device->SetRenderState(D3DRS_STENCILMASK, mask);
+}
+
+static void dllStencilMask(GLuint mask)
+{
+	glw_state->device->SetRenderState(D3DRS_STENCILWRITEMASK, mask);
+}
+
+static D3DSTENCILOP _convertStencilOp(GLenum op)
+{
+	switch (op)
+	{
+	default: case GL_KEEP: return D3DSTENCILOP_KEEP;
+	case GL_ZERO: return D3DSTENCILOP_ZERO;
+	case GL_REPLACE: return D3DSTENCILOP_REPLACE;
+	case GL_INCR: return D3DSTENCILOP_INCR;
+	case GL_DECR: return D3DSTENCILOP_DECR;
+	case GL_INVERT: return D3DSTENCILOP_INVERT;
+	}
+}
+
+static void dllStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
+{
+	D3DSTENCILOP f = _convertStencilOp(fail);
+	D3DSTENCILOP zf = _convertStencilOp(zfail);
+	D3DSTENCILOP zp = _convertStencilOp(zpass);
+
+	glw_state->device->SetRenderState(D3DRS_STENCILFAIL, f);
+	glw_state->device->SetRenderState(D3DRS_STENCILZFAIL, zf);
+	glw_state->device->SetRenderState(D3DRS_STENCILPASS, zp);
+}
+
+static void dllTexCoord1d(GLdouble s)
+{
+	assert(0);
+}
+
+static void dllTexCoord1dv(const GLdouble *v)
+{
+	assert(0);
+}
+
+static void dllTexCoord1f(GLfloat s)
+{
+	assert(0);
+}
+
+static void dllTexCoord1fv(const GLfloat *v)
+{
+	assert(0);
+}
+
+static void dllTexCoord1i(GLint s)
+{
+	assert(0);
+}
+
+static void dllTexCoord1iv(const GLint *v)
+{
+	assert(0);
+}
+
+static void dllTexCoord1s(GLshort s)
+{
+	assert(0);
+}
+
+static void dllTexCoord1sv(const GLshort *v)
+{
+	assert(0);
+}
+
+static void setTexCoord(float s, float t)
+{
+	assert(glw_state->inDrawBlock);
+
+	_handleDrawOverflow();
+
+	int off = 0;
+	if(glw_state->normalArrayState)
+		off = 3;
+	
+	DWORD* push = &glw_state->drawArray[
+		glw_state->numVertices * glw_state->drawStride + 
+		4 + off + glw_state->serverTU * 2];
+	
+	*push++ = *((DWORD*)&s);
+	*push++ = *((DWORD*)&t);
+}
+
+static void dllTexCoord2d(GLdouble s, GLdouble t)
+{
+	assert(0);
+}
+
+static void dllTexCoord2dv(const GLdouble *v)
+{
+	assert(0);
+}
+
+static void dllTexCoord2f(GLfloat s, GLfloat t)
+{
+	setTexCoord(s, t);
+}
+
+static void dllTexCoord2fv(const GLfloat *v)
+{
+	setTexCoord(v[0], v[1]);
+}
+
+static void dllTexCoord2i(GLint s, GLint t)
+{
+	assert(0);
+}
+
+static void dllTexCoord2iv(const GLint *v)
+{
+	assert(0);
+}
+
+static void dllTexCoord2s(GLshort s, GLshort t)
+{
+	assert(0);
+}
+
+static void dllTexCoord2sv(const GLshort *v)
+{
+	assert(0);
+}
+
+static void dllTexCoord3d(GLdouble s, GLdouble t, GLdouble r)
+{
+	assert(0);
+}
+
+static void dllTexCoord3dv(const GLdouble *v)
+{
+	assert(0);
+}
+
+static void dllTexCoord3f(GLfloat s, GLfloat t, GLfloat r)
+{
+	assert(0);
+}
+
+static void dllTexCoord3fv(const GLfloat *v)
+{
+	assert(0);
+}
+
+static void dllTexCoord3i(GLint s, GLint t, GLint r)
+{
+	assert(0);
+}
+
+static void dllTexCoord3iv(const GLint *v)
+{
+	assert(0);
+}
+
+static void dllTexCoord3s(GLshort s, GLshort t, GLshort r)
+{
+	assert(0);
+}
+
+static void dllTexCoord3sv(const GLshort *v)
+{
+	assert(0);
+}
+
+static void dllTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q)
+{
+	assert(0);
+}
+
+static void dllTexCoord4dv(const GLdouble *v)
+{
+	assert(0);
+}
+
+static void dllTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q)
+{
+	assert(0);
+}
+
+static void dllTexCoord4fv(const GLfloat *v)
+{
+	assert(0);
+}
+
+static void dllTexCoord4i(GLint s, GLint t, GLint r, GLint q)
+{
+	assert(0);
+}
+
+static void dllTexCoord4iv(const GLint *v)
+{
+	assert(0);
+}
+
+static void dllTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q)
+{
+	assert(0);
+}
+
+static void dllTexCoord4sv(const GLshort *v)
+{
+	assert(0);
+}
+
+static void dllTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
+{
+	assert(size == 2 && type == GL_FLOAT);
+
+	stride = (stride == 0) ? (sizeof(GLfloat) * 2) : stride;
+	
+	glw_state->texCoordPointer[glw_state->clientTU] = pointer;
+	glw_state->texCoordStride[glw_state->clientTU] = stride;
+}
+
+static void dllTexEnvf(GLenum target, GLenum pname, GLfloat param)
+{
+	qglTexEnvi(target, pname, (GLint)param);
+}
+
+static void dllTexEnvfv(GLenum target, GLenum pname, const GLfloat *params)
+{
+	assert(0);
+}
+
+static void dllTexEnvi(GLenum target, GLenum pname, GLint param)
+{
+	assert(target == GL_TEXTURE_ENV && pname == GL_TEXTURE_ENV_MODE);
+
+	/*glwstate_t::TextureInfo* info = _getCurrentTexture(glw_state->serverTU);
+	if (!info) return;*/
+
+	D3DTEXTUREOP env;
+	switch (param)
+	{
+	case GL_MODULATE: default: env = D3DTOP_MODULATE; break;
+	case GL_REPLACE: env = D3DTOP_SELECTARG1; break;
+	// MATT! - I use GL_DECAL as the bumpmapping state
+	case GL_DECAL: env = D3DTOP_DOTPRODUCT3; break;
+	case GL_ADD: env = D3DTOP_ADD; break;
+	case GL_NONE: env = D3DTOP_DISABLE; break;
+	}
+
+	if (glw_state->textureEnv[glw_state->serverTU] != env)
+	{
+		glw_state->textureEnv[glw_state->serverTU] = env;
+		glw_state->textureStageDirty[glw_state->serverTU] = true;
+	}
+}
+
+static void dllTexEnviv(GLenum target, GLenum pname, const GLint *params)
+{
+	assert(0);
+}
+
+static void dllTexGend(GLenum coord, GLenum pname, GLdouble param)
+{
+	assert(0);
+}
+
+static void dllTexGendv(GLenum coord, GLenum pname, const GLdouble *params)
+{
+	assert(0);
+}
+
+static void dllTexGenf(GLenum coord, GLenum pname, GLfloat param)
+{
+	assert(0);
+}
+
+static void dllTexGenfv(GLenum coord, GLenum pname, const GLfloat *params)
+{
+	assert(0);
+}
+
+static void dllTexGeni(GLenum coord, GLenum pname, GLint param)
+{
+	assert(0);
+}
+
+static void dllTexGeniv(GLenum coord, GLenum pname, const GLint *params)
+{
+	assert(0);
+}
+
+static void dllTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
+{
+	assert(0);
+}
+
+static void _d3d_check(HRESULT err, const char* func)
+{
+	if (err != D3D_OK)
+	{
+		MEMORYSTATUS status;
+		GlobalMemoryStatus(&status);
+		Sys_Print(va("%s returned %d!  Memfree=%d\n", func, err, status.dwAvailPhys));
+	}
+}
+
+static void _texImageDDS(glwstate_t::TextureInfo* info, GLint numlevels, GLsizei width, GLsizei height, GLenum format, const GLvoid *pixels)
+{
+	_d3d_check(D3DXCreateTextureFromFileInMemoryEx(glw_state->device,
+		pixels, 
+		Z_Size(const_cast<void*>(pixels)),
+		width, 
+		height,
+		numlevels,
+		0,
+		D3DFMT_UNKNOWN,
+		D3DPOOL_MANAGED,
+		D3DX_DEFAULT,
+		D3DX_DEFAULT,
+		0,
+		NULL,
+		NULL,
+		&info->mipmap),
+		"D3DXCreateTextureFromFileInMemoryEx");
+}
+
+static void _texImageRGBA(glwstate_t::TextureInfo* info, GLint numlevels, GLint internalformat, GLsizei width, GLsizei height, GLenum format, const GLvoid *pixels)
+{
+	IDirect3DSurface8 *pSurf = NULL;
+	D3DFORMAT f;
+	int bpp;
+	RECT	srcRect;
+	
+	srcRect.top = 0;
+	srcRect.left = 0;
+	srcRect.right = width;
+	srcRect.bottom = height;
+
+	switch(format)
+	{
+	case GL_RGB:
+		f = D3DFMT_X8R8G8B8;
+		bpp = 3;
+		break;
+		
+	case GL_RGBA:
+		f = D3DFMT_A8R8G8B8;
+		bpp = 4;
+		break;
+
+	case GL_RGB_SWIZZLE_EXT:
+		f = D3DFMT_R5G6B5;
+		bpp = 2;
+		break;
+
+	case GL_LIN_RGB8:
+		f = D3DFMT_X8R8G8B8;
+		bpp = 4;
+		break;
+
+	default:
+		assert(0);
+	}
+
+	_d3d_check(glw_state->device->CreateImageSurface(width, height, f, &pSurf),
+		"CreateImageSurface");
+
+	_d3d_check(D3DXLoadSurfaceFromMemory(pSurf, 
+								   NULL, 
+								   NULL, 
+								   (LPCVOID)pixels, 
+								   f, 
+								   width * bpp, 
+								   NULL, 
+								   &srcRect, 
+								   D3DX_FILTER_NONE, 
+								   0),
+								   "D3DXLoadSurfaceFromMemory");
+
+	switch(internalformat)
+	{
+	case GL_RGB5:
+	case GL_RGB4_S3TC:
+		f = D3DFMT_R5G6B5;
+		break;
+
+	case GL_RGBA4:
+		f = D3DFMT_A4R4G4B4;
+		break;
+
+	case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
+		f = D3DFMT_DXT1;
+		break;
+
+	case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
+		f = D3DFMT_DXT5;
+		break;
+
+	case GL_RGB8:
+	case 3:
+		f = D3DFMT_X8R8G8B8;
+		break;
+
+	case GL_RGBA8:
+	case 4:
+		f = D3DFMT_A8R8G8B8;
+		break;
+
+	case GL_LIN_RGB8:
+		f = D3DFMT_LIN_X8R8G8B8;
+		break;
+
+	default:
+		assert(0);
+	}
+	
+	_d3d_check(D3DXCreateTexture(glw_state->device, 
+							   width, 
+							   height, 
+							   numlevels, 
+							   0, 
+							   f, 
+							   D3DPOOL_MANAGED,
+							   &info->mipmap),
+							   "D3DXCreateTexture");
+
+	LPDIRECT3DSURFACE8 txtSurf;
+	_d3d_check(info->mipmap->GetSurfaceLevel(0, &txtSurf),
+		"GetSurfaceLevel");
+	
+	_d3d_check(D3DXLoadSurfaceFromSurface(txtSurf, NULL, NULL, 
+		pSurf, NULL, NULL, D3DX_DEFAULT, 0),
+		"D3DXLoadSurfaceFromSurface");
+
+	txtSurf->Release();
+	pSurf->Release();
+
+	if(numlevels > 1)
+	{
+		_d3d_check(D3DXFilterTexture(info->mipmap, 
+							   NULL, 
+							   D3DX_DEFAULT, 
+							   D3DX_DEFAULT),
+							   "D3DXFilterTexture");
+	}
+}
+
+// EXTENSION: glTexImage2D plus "numlevels" number of mipmaps
+static void dllTexImage2DEXT(GLenum target, GLint level, GLint numlevels, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
+{
+	assert(target == GL_TEXTURE_2D && border == 0 && type == GL_UNSIGNED_BYTE);
+
+	// In Direct3D, setting 0 for number of mipmap 
+	// levels means create the whole chain....
+	if(numlevels == 0)
+		numlevels = 1;
+
+	glwstate_t::TextureInfo* info;
+
+	glwstate_t::texturexlat_t::iterator current = 
+		glw_state->textureXlat.find(
+		glw_state->currentTexture[glw_state->serverTU]);
+
+	// If we already have a texture bound to this ID, remove it.
+	if (current != glw_state->textureXlat.end())
+	{
+		info = &current->second;
+		info->mipmap->Release();
+	}
+	// Otherwise, initialize it.
+	else
+	{
+		info = &glw_state->textureXlat[
+			glw_state->currentTexture[glw_state->serverTU]];
+
+		info->minFilter = D3DTEXF_NONE;
+		info->mipFilter = D3DTEXF_NONE;
+		info->magFilter = D3DTEXF_NONE;
+		info->anisotropy = 1.f;
+		info->wrapU = D3DTADDRESS_CLAMP;
+		info->wrapV = D3DTADDRESS_CLAMP;
+
+		glw_state->textureStageDirty[glw_state->serverTU] = true;
+	}
+
+	// force any DX allocs to temp memory
+	Z_SetNewDeleteTemporary(true);
+
+	if (format == GL_DDS1_EXT || 
+		format == GL_DDS5_EXT || 
+		format == GL_DDS_RGB16_EXT || 
+		format == GL_DDS_RGBA32_EXT)
+	{
+		_texImageDDS(info, numlevels, width, height, format, pixels);
+	}
+	else
+	{
+		_texImageRGBA(info, numlevels, 
+			internalformat, width, height, 
+			format, pixels);
+	}
+
+	// Done DX calls to new and delete
+	Z_SetNewDeleteTemporary(false);
+
+#if MEMORY_PROFILE
+	texMemSize += getTexMemSize(info->mipmap);
+#endif
+}
+
+static void dllTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
+{
+	dllTexImage2DEXT(target, level, 1, internalformat, width, height, border, format, type, pixels);
+}
+
+static void dllTexParameteri(GLenum target, GLenum pname, GLint param)
+{
+	assert(target == GL_TEXTURE_2D);
+	
+	if (glw_state->currentTexture[glw_state->serverTU] == 0) return;
+
+	glwstate_t::TextureInfo* info = _getCurrentTexture(glw_state->serverTU);
+	if (!info) return;
+
+	glw_state->textureStageDirty[glw_state->serverTU] = true;
+	
+	switch (pname)
+	{
+	case GL_TEXTURE_MIN_FILTER:
+		switch (param)
+		{
+		case GL_NEAREST:
+			info->minFilter = D3DTEXF_POINT;
+			info->mipFilter = D3DTEXF_NONE;
+			break;
+		case GL_LINEAR:
+			info->minFilter = D3DTEXF_LINEAR;
+			info->mipFilter = D3DTEXF_NONE;
+			break;
+		case GL_NEAREST_MIPMAP_NEAREST:
+			info->minFilter = D3DTEXF_POINT;
+			info->mipFilter = D3DTEXF_POINT;
+			break;
+		case GL_LINEAR_MIPMAP_NEAREST:
+			info->minFilter = D3DTEXF_LINEAR;
+			info->mipFilter = D3DTEXF_POINT;
+			break;
+		case GL_NEAREST_MIPMAP_LINEAR:
+			info->minFilter = D3DTEXF_POINT;
+			info->mipFilter = D3DTEXF_LINEAR;
+			break;
+		case GL_LINEAR_MIPMAP_LINEAR:
+			info->minFilter = D3DTEXF_LINEAR;
+			info->mipFilter = D3DTEXF_LINEAR;
+			break;
+		}
+		info->anisotropy = 1.f;
+		break;
+	case GL_TEXTURE_MAG_FILTER:
+		switch (param)
+		{
+		case GL_NEAREST:
+			info->magFilter = D3DTEXF_POINT;
+			break;
+		case GL_LINEAR:
+			info->magFilter = D3DTEXF_LINEAR;
+			break;
+		}
+		info->anisotropy = 1.f;
+		break;
+	case GL_TEXTURE_WRAP_S:
+		switch (param)
+		{
+		case GL_REPEAT: info->wrapU = D3DTADDRESS_WRAP; break;
+		case GL_CLAMP: info->wrapU = D3DTADDRESS_CLAMP; break;
+		}
+		break;
+	case GL_TEXTURE_WRAP_T:
+		switch (param)
+		{
+		case GL_REPEAT: info->wrapV = D3DTADDRESS_WRAP; break;
+		case GL_CLAMP: info->wrapV = D3DTADDRESS_CLAMP; break;
+		}
+		break;
+	case GL_TEXTURE_MAX_ANISOTROPY_EXT:
+		info->anisotropy = (float)param;
+		info->minFilter = D3DTEXF_ANISOTROPIC;
+		info->magFilter = D3DTEXF_ANISOTROPIC;
+		break;
+	}
+}
+
+static void dllTexParameterf(GLenum target, GLenum pname, GLfloat param)
+{
+	dllTexParameteri(target, pname, param);
+}
+
+static void dllTexParameterfv(GLenum target, GLenum pname, const GLfloat *params)
+{
+	// Intentionally left blank
+}
+
+static void dllTexParameteriv(GLenum target, GLenum pname, const GLint *params)
+{
+	// Intentionally left blank
+}
+
+static void dllTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels)
+{
+	assert(0);
+}
+
+static void dllTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
+{
+	assert(target == GL_TEXTURE_2D && level == 0 && type == GL_UNSIGNED_BYTE);
+
+	glwstate_t::TextureInfo* info = _getCurrentTexture(glw_state->serverTU);
+	if (info == NULL) return;
+
+	RECT sr;
+	sr.top = 0;
+	sr.left = 0;
+	sr.right = width;
+	sr.bottom = height;
+
+	RECT dr;
+	dr.top = xoffset;
+	dr.left = yoffset;
+	dr.right = xoffset + width;
+	dr.bottom = yoffset + height;
+
+	Z_SetNewDeleteTemporary(true);
+
+	LPDIRECT3DSURFACE8 surf;
+	info->mipmap->GetSurfaceLevel(0, &surf);
+	
+	// Only 16-bit textures supported for now!
+	D3DXLoadSurfaceFromMemory(surf, NULL, &dr, pixels, 
+		D3DFMT_R5G6B5, width * 2, NULL, &sr, D3DX_DEFAULT, 0);
+
+	surf->Release();
+
+	Z_SetNewDeleteTemporary(false);
+}
+
+static void dllTranslated(GLdouble x, GLdouble y, GLdouble z)
+{
+	assert(0);
+}
+
+static void dllTranslatef(GLfloat x, GLfloat y, GLfloat z)
+{
+	glw_state->matrixStack[glw_state->matrixMode]->TranslateLocal(x, y, z);
+	glw_state->matricesDirty[glw_state->matrixMode] = true;
+}
+
+static void setVertex(float x, float y, float z)
+{
+	assert(glw_state->inDrawBlock);
+
+	_handleDrawOverflow();
+	
+	DWORD* push = &glw_state->drawArray[glw_state->numVertices * glw_state->drawStride];
+	push[0] = *((DWORD*)&x);
+	push[1] = *((DWORD*)&y);
+	push[2] = *((DWORD*)&z);
+	push[3] = glw_state->currentColor;
+
+	++glw_state->numVertices;
+}
+
+static void dllVertex2d(GLdouble x, GLdouble y)
+{
+	assert(0);
+}
+
+static void dllVertex2dv(const GLdouble *v)
+{
+	assert(0);
+}
+
+static void dllVertex2f(GLfloat x, GLfloat y)
+{
+	setVertex(x, y, 0.f);
+}
+
+static void dllVertex2fv(const GLfloat *v)
+{
+	setVertex(v[0], v[1], 0.f);
+}
+
+static void dllVertex2i(GLint x, GLint y)
+{
+	assert(0);
+}
+
+static void dllVertex2iv(const GLint *v)
+{
+	assert(0);
+}
+
+static void dllVertex2s(GLshort x, GLshort y)
+{
+	assert(0);
+}
+
+static void dllVertex2sv(const GLshort *v)
+{
+	assert(0);
+}
+
+static void dllVertex3d(GLdouble x, GLdouble y, GLdouble z)
+{
+	assert(0);
+}
+
+static void dllVertex3dv(const GLdouble *v)
+{
+	assert(0);
+}
+
+static void dllVertex3f(GLfloat x, GLfloat y, GLfloat z)
+{
+	setVertex(x, y, z);
+}
+
+static void dllVertex3fv(const GLfloat *v)
+{
+	setVertex(v[0], v[1], v[2]);
+}
+
+static void dllVertex3i(GLint x, GLint y, GLint z)
+{
+	assert(0);
+}
+
+static void dllVertex3iv(const GLint *v)
+{
+	assert(0);
+}
+
+static void dllVertex3s(GLshort x, GLshort y, GLshort z)
+{
+	assert(0);
+}
+
+static void dllVertex3sv(const GLshort *v)
+{
+	assert(0);
+}
+
+static void dllVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
+{
+	assert(0);
+}
+
+static void dllVertex4dv(const GLdouble *v)
+{
+	assert(0);
+}
+
+static void dllVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
+{
+	setVertex(x, y, z);
+}
+
+static void dllVertex4fv(const GLfloat *v)
+{
+	setVertex(v[0], v[1], v[2]);
+}
+
+static void dllVertex4i(GLint x, GLint y, GLint z, GLint w)
+{
+	assert(0);
+}
+
+static void dllVertex4iv(const GLint *v)
+{
+	assert(0);
+}
+
+static void dllVertex4s(GLshort x, GLshort y, GLshort z, GLshort w)
+{
+	assert(0);
+}
+
+static void dllVertex4sv(const GLshort *v)
+{
+	assert(0);
+}
+
+static void dllVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
+{
+	assert(size == 3 && type == GL_FLOAT);
+	
+	stride = (stride == 0) ? (sizeof(GLfloat) * 3) : stride;
+
+	glw_state->vertexPointer = pointer;
+	glw_state->vertexStride = stride;
+}
+
+static void dllViewport(GLint x, GLint y, GLsizei width, GLsizei height)
+{
+	_fixupScreenCoords(x, y, width, height);
+
+	glw_state->viewport.X = x;
+	glw_state->viewport.Y = y;
+	glw_state->viewport.Width = width;
+	glw_state->viewport.Height = height;
+	glw_state->device->SetViewport(&glw_state->viewport);
+}
+
+
+static void dllMultiTexCoord2fARB(GLenum texture, GLfloat s, GLfloat t)
+{
+	assert(glw_state->inDrawBlock);
+
+	_handleDrawOverflow();
+
+	DWORD* push = &glw_state->drawArray[
+		glw_state->numVertices * glw_state->drawStride + 
+		4 + (texture - GL_TEXTURE0_ARB) * 2];
+	
+	*push++ = *((DWORD*)&s);
+	*push++ = *((DWORD*)&t);
+}
+
+static void dllActiveTextureARB(GLenum texture)
+{
+	assert(GLW_MAX_TEXTURE_STAGES > texture - GL_TEXTURE0_ARB);
+	glw_state->serverTU = texture - GL_TEXTURE0_ARB;
+}
+
+static void dllClientActiveTextureARB(GLenum texture)
+{
+	assert(GLW_MAX_TEXTURE_STAGES > texture - GL_TEXTURE0_ARB);
+	glw_state->clientTU = texture - GL_TEXTURE0_ARB;
+}
+
+
+/*
+** QGL_Shutdown
+**
+** Unloads the specified DLL then nulls out all the proc pointers.  This
+** is only called during a hard shutdown of the OGL subsystem (e.g. vid_restart).
+*/
+void QGL_Shutdown( void )
+{
+	Com_Printf ("...shutting down QGL\n" );
+
+	qglAccum                     = NULL;
+	qglAlphaFunc                 = NULL;
+	qglAreTexturesResident       = NULL;
+	qglArrayElement              = NULL;
+	qglBegin                     = NULL;
+	qglBeginEXT                  = NULL;
+	qglBeginFrame                = NULL;
+	qglBeginShadow               = NULL;
+	qglBindTexture               = NULL;
+	qglBitmap                    = NULL;
+	qglBlendFunc                 = NULL;
+	qglCallList                  = NULL;
+	qglCallLists                 = NULL;
+	qglClear                     = NULL;
+	qglClearAccum                = NULL;
+	qglClearColor                = NULL;
+	qglClearDepth                = NULL;
+	qglClearIndex                = NULL;
+	qglClearStencil              = NULL;
+	qglClipPlane                 = NULL;
+	qglColor3b                   = NULL;
+	qglColor3bv                  = NULL;
+	qglColor3d                   = NULL;
+	qglColor3dv                  = NULL;
+	qglColor3f                   = NULL;
+	qglColor3fv                  = NULL;
+	qglColor3i                   = NULL;
+	qglColor3iv                  = NULL;
+	qglColor3s                   = NULL;
+	qglColor3sv                  = NULL;
+	qglColor3ub                  = NULL;
+	qglColor3ubv                 = NULL;
+	qglColor3ui                  = NULL;
+	qglColor3uiv                 = NULL;
+	qglColor3us                  = NULL;
+	qglColor3usv                 = NULL;
+	qglColor4b                   = NULL;
+	qglColor4bv                  = NULL;
+	qglColor4d                   = NULL;
+	qglColor4dv                  = NULL;
+	qglColor4f                   = NULL;
+	qglColor4fv                  = NULL;
+	qglColor4i                   = NULL;
+	qglColor4iv                  = NULL;
+	qglColor4s                   = NULL;
+	qglColor4sv                  = NULL;
+	qglColor4ub                  = NULL;
+	qglColor4ubv                 = NULL;
+	qglColor4ui                  = NULL;
+	qglColor4uiv                 = NULL;
+	qglColor4us                  = NULL;
+	qglColor4usv                 = NULL;
+	qglColorMask                 = NULL;
+	qglColorMaterial             = NULL;
+	qglColorPointer              = NULL;
+	qglCopyPixels                = NULL;
+	qglCopyTexImage1D            = NULL;
+	qglCopyTexImage2D            = NULL;
+	qglCopyTexSubImage1D         = NULL;
+	qglCopyTexSubImage2D         = NULL;
+	qglCullFace                  = NULL;
+	qglDeleteLists               = NULL;
+	qglDeleteTextures            = NULL;
+	qglDepthFunc                 = NULL;
+	qglDepthMask                 = NULL;
+	qglDepthRange                = NULL;
+	qglDisable                   = NULL;
+	qglDisableClientState        = NULL;
+	qglDrawArrays                = NULL;
+	qglDrawBuffer                = NULL;
+	qglDrawElements              = NULL;
+	qglDrawPixels                = NULL;
+	qglEdgeFlag                  = NULL;
+	qglEdgeFlagPointer           = NULL;
+	qglEdgeFlagv                 = NULL;
+	qglEnable                    = NULL;
+	qglEnableClientState         = NULL;
+	qglEnd                       = NULL;
+	qglEndFrame                  = NULL;
+	qglEndShadow                 = NULL;
+	qglEndList                   = NULL;
+	qglEvalCoord1d               = NULL;
+	qglEvalCoord1dv              = NULL;
+	qglEvalCoord1f               = NULL;
+	qglEvalCoord1fv              = NULL;
+	qglEvalCoord2d               = NULL;
+	qglEvalCoord2dv              = NULL;
+	qglEvalCoord2f               = NULL;
+	qglEvalCoord2fv              = NULL;
+	qglEvalMesh1                 = NULL;
+	qglEvalMesh2                 = NULL;
+	qglEvalPoint1                = NULL;
+	qglEvalPoint2                = NULL;
+	qglFeedbackBuffer            = NULL;
+	qglFinish                    = NULL;
+	qglFlush                     = NULL;
+	qglFlushShadow               = NULL;
+	qglFogf                      = NULL;
+	qglFogfv                     = NULL;
+	qglFogi                      = NULL;
+	qglFogiv                     = NULL;
+	qglFrontFace                 = NULL;
+	qglFrustum                   = NULL;
+	qglGenLists                  = NULL;
+	qglGenTextures               = NULL;
+	qglGetBooleanv               = NULL;
+	qglGetClipPlane              = NULL;
+	qglGetDoublev                = NULL;
+	qglGetError                  = NULL;
+	qglGetFloatv                 = NULL;
+	qglGetIntegerv               = NULL;
+	qglGetLightfv                = NULL;
+	qglGetLightiv                = NULL;
+	qglGetMapdv                  = NULL;
+	qglGetMapfv                  = NULL;
+	qglGetMapiv                  = NULL;
+	qglGetMaterialfv             = NULL;
+	qglGetMaterialiv             = NULL;
+	qglGetPixelMapfv             = NULL;
+	qglGetPixelMapuiv            = NULL;
+	qglGetPixelMapusv            = NULL;
+	qglGetPointerv               = NULL;
+	qglGetPolygonStipple         = NULL;
+	qglGetString                 = NULL;
+	qglGetTexEnvfv               = NULL;
+	qglGetTexEnviv               = NULL;
+	qglGetTexGendv               = NULL;
+	qglGetTexGenfv               = NULL;
+	qglGetTexGeniv               = NULL;
+	qglGetTexImage               = NULL;
+	qglGetTexLevelParameterfv    = NULL;
+	qglGetTexLevelParameteriv    = NULL;
+	qglGetTexParameterfv         = NULL;
+	qglGetTexParameteriv         = NULL;
+	qglHint                      = NULL;
+	qglIndexedTriToStrip         = NULL;
+	qglIndexMask                 = NULL;
+	qglIndexPointer              = NULL;
+	qglIndexd                    = NULL;
+	qglIndexdv                   = NULL;
+	qglIndexf                    = NULL;
+	qglIndexfv                   = NULL;
+	qglIndexi                    = NULL;
+	qglIndexiv                   = NULL;
+	qglIndexs                    = NULL;
+	qglIndexsv                   = NULL;
+	qglIndexub                   = NULL;
+	qglIndexubv                  = NULL;
+	qglInitNames                 = NULL;
+	qglInterleavedArrays         = NULL;
+	qglIsEnabled                 = NULL;
+	qglIsList                    = NULL;
+	qglIsTexture                 = NULL;
+	qglLightModelf               = NULL;
+	qglLightModelfv              = NULL;
+	qglLightModeli               = NULL;
+	qglLightModeliv              = NULL;
+	qglLightf                    = NULL;
+	qglLightfv                   = NULL;
+	qglLighti                    = NULL;
+	qglLightiv                   = NULL;
+	qglLineStipple               = NULL;
+	qglLineWidth                 = NULL;
+	qglListBase                  = NULL;
+	qglLoadIdentity              = NULL;
+	qglLoadMatrixd               = NULL;
+	qglLoadMatrixf               = NULL;
+	qglLoadName                  = NULL;
+	qglLogicOp                   = NULL;
+	qglMap1d                     = NULL;
+	qglMap1f                     = NULL;
+	qglMap2d                     = NULL;
+	qglMap2f                     = NULL;
+	qglMapGrid1d                 = NULL;
+	qglMapGrid1f                 = NULL;
+	qglMapGrid2d                 = NULL;
+	qglMapGrid2f                 = NULL;
+	qglMaterialf                 = NULL;
+	qglMaterialfv                = NULL;
+	qglMateriali                 = NULL;
+	qglMaterialiv                = NULL;
+	qglMatrixMode                = NULL;
+	qglMultMatrixd               = NULL;
+	qglMultMatrixf               = NULL;
+	qglNewList                   = NULL;
+	qglNormal3b                  = NULL;
+	qglNormal3bv                 = NULL;
+	qglNormal3d                  = NULL;
+	qglNormal3dv                 = NULL;
+	qglNormal3f                  = NULL;
+	qglNormal3fv                 = NULL;
+	qglNormal3i                  = NULL;
+	qglNormal3iv                 = NULL;
+	qglNormal3s                  = NULL;
+	qglNormal3sv                 = NULL;
+	qglNormalPointer             = NULL;
+	qglOrtho                     = NULL;
+	qglPassThrough               = NULL;
+	qglPixelMapfv                = NULL;
+	qglPixelMapuiv               = NULL;
+	qglPixelMapusv               = NULL;
+	qglPixelStoref               = NULL;
+	qglPixelStorei               = NULL;
+	qglPixelTransferf            = NULL;
+	qglPixelTransferi            = NULL;
+	qglPixelZoom                 = NULL;
+	qglPointSize                 = NULL;
+	qglPolygonMode               = NULL;
+	qglPolygonOffset             = NULL;
+	qglPolygonStipple            = NULL;
+	qglPopAttrib                 = NULL;
+	qglPopClientAttrib           = NULL;
+	qglPopMatrix                 = NULL;
+	qglPopName                   = NULL;
+	qglPrioritizeTextures        = NULL;
+	qglPushAttrib                = NULL;
+	qglPushClientAttrib          = NULL;
+	qglPushMatrix                = NULL;
+	qglPushName                  = NULL;
+	qglRasterPos2d               = NULL;
+	qglRasterPos2dv              = NULL;
+	qglRasterPos2f               = NULL;
+	qglRasterPos2fv              = NULL;
+	qglRasterPos2i               = NULL;
+	qglRasterPos2iv              = NULL;
+	qglRasterPos2s               = NULL;
+	qglRasterPos2sv              = NULL;
+	qglRasterPos3d               = NULL;
+	qglRasterPos3dv              = NULL;
+	qglRasterPos3f               = NULL;
+	qglRasterPos3fv              = NULL;
+	qglRasterPos3i               = NULL;
+	qglRasterPos3iv              = NULL;
+	qglRasterPos3s               = NULL;
+	qglRasterPos3sv              = NULL;
+	qglRasterPos4d               = NULL;
+	qglRasterPos4dv              = NULL;
+	qglRasterPos4f               = NULL;
+	qglRasterPos4fv              = NULL;
+	qglRasterPos4i               = NULL;
+	qglRasterPos4iv              = NULL;
+	qglRasterPos4s               = NULL;
+	qglRasterPos4sv              = NULL;
+	qglReadBuffer                = NULL;
+	qglReadPixels                = NULL;
+	qglCopyBackBufferToTexEXT	 = NULL;
+	qglCopyBackBufferToTex		 = NULL;
+	qglRectd                     = NULL;
+	qglRectdv                    = NULL;
+	qglRectf                     = NULL;
+	qglRectfv                    = NULL;
+	qglRecti                     = NULL;
+	qglRectiv                    = NULL;
+	qglRects                     = NULL;
+	qglRectsv                    = NULL;
+	qglRenderMode                = NULL;
+	qglRotated                   = NULL;
+	qglRotatef                   = NULL;
+	qglScaled                    = NULL;
+	qglScalef                    = NULL;
+	qglScissor                   = NULL;
+	qglSelectBuffer              = NULL;
+	qglShadeModel                = NULL;
+	qglStencilFunc               = NULL;
+	qglStencilMask               = NULL;
+	qglStencilOp                 = NULL;
+	qglTexCoord1d                = NULL;
+	qglTexCoord1dv               = NULL;
+	qglTexCoord1f                = NULL;
+	qglTexCoord1fv               = NULL;
+	qglTexCoord1i                = NULL;
+	qglTexCoord1iv               = NULL;
+	qglTexCoord1s                = NULL;
+	qglTexCoord1sv               = NULL;
+	qglTexCoord2d                = NULL;
+	qglTexCoord2dv               = NULL;
+	qglTexCoord2f                = NULL;
+	qglTexCoord2fv               = NULL;
+	qglTexCoord2i                = NULL;
+	qglTexCoord2iv               = NULL;
+	qglTexCoord2s                = NULL;
+	qglTexCoord2sv               = NULL;
+	qglTexCoord3d                = NULL;
+	qglTexCoord3dv               = NULL;
+	qglTexCoord3f                = NULL;
+	qglTexCoord3fv               = NULL;
+	qglTexCoord3i                = NULL;
+	qglTexCoord3iv               = NULL;
+	qglTexCoord3s                = NULL;
+	qglTexCoord3sv               = NULL;
+	qglTexCoord4d                = NULL;
+	qglTexCoord4dv               = NULL;
+	qglTexCoord4f                = NULL;
+	qglTexCoord4fv               = NULL;
+	qglTexCoord4i                = NULL;
+	qglTexCoord4iv               = NULL;
+	qglTexCoord4s                = NULL;
+	qglTexCoord4sv               = NULL;
+	qglTexCoordPointer           = NULL;
+	qglTexEnvf                   = NULL;
+	qglTexEnvfv                  = NULL;
+	qglTexEnvi                   = NULL;
+	qglTexEnviv                  = NULL;
+	qglTexGend                   = NULL;
+	qglTexGendv                  = NULL;
+	qglTexGenf                   = NULL;
+	qglTexGenfv                  = NULL;
+	qglTexGeni                   = NULL;
+	qglTexGeniv                  = NULL;
+	qglTexImage1D                = NULL;
+	qglTexImage2D                = NULL;
+	qglTexImage2DEXT             = NULL;
+	qglTexParameterf             = NULL;
+	qglTexParameterfv            = NULL;
+	qglTexParameteri             = NULL;
+	qglTexParameteriv            = NULL;
+	qglTexSubImage1D             = NULL;
+	qglTexSubImage2D             = NULL;
+	qglTranslated                = NULL;
+	qglTranslatef                = NULL;
+	qglVertex2d                  = NULL;
+	qglVertex2dv                 = NULL;
+	qglVertex2f                  = NULL;
+	qglVertex2fv                 = NULL;
+	qglVertex2i                  = NULL;
+	qglVertex2iv                 = NULL;
+	qglVertex2s                  = NULL;
+	qglVertex2sv                 = NULL;
+	qglVertex3d                  = NULL;
+	qglVertex3dv                 = NULL;
+	qglVertex3f                  = NULL;
+	qglVertex3fv                 = NULL;
+	qglVertex3i                  = NULL;
+	qglVertex3iv                 = NULL;
+	qglVertex3s                  = NULL;
+	qglVertex3sv                 = NULL;
+	qglVertex4d                  = NULL;
+	qglVertex4dv                 = NULL;
+	qglVertex4f                  = NULL;
+	qglVertex4fv                 = NULL;
+	qglVertex4i                  = NULL;
+	qglVertex4iv                 = NULL;
+	qglVertex4s                  = NULL;
+	qglVertex4sv                 = NULL;
+	qglVertexPointer             = NULL;
+	qglViewport                  = NULL;
+
+	qglActiveTextureARB          = NULL;
+	qglClientActiveTextureARB    = NULL;
+	qglMultiTexCoord2fARB        = NULL;
+}
+
+/*
+** QGL_Init
+**
+** This is responsible for binding our qgl function pointers to 
+** the appropriate GL stuff.  In Windows this means doing a 
+** LoadLibrary and a bunch of calls to GetProcAddress.  On other
+** operating systems we need to do the right thing, whatever that
+** might be.
+*/
+qboolean QGL_Init( const char *dllname )
+{
+	qglAccum                     = dllAccum;
+	qglAlphaFunc                 = dllAlphaFunc;
+	qglAreTexturesResident       = dllAreTexturesResident;
+	qglArrayElement              = dllArrayElement;
+	qglBegin                     = dllBegin;
+	qglBeginEXT                  = dllBeginEXT;
+	qglBeginFrame                = dllBeginFrame;
+	qglBeginShadow               = dllBeginShadow;
+	qglBindTexture               = dllBindTexture;
+	qglBitmap                    = dllBitmap;
+	qglBlendFunc                 = dllBlendFunc;
+	qglCallList                  = dllCallList;
+	qglCallLists                 = dllCallLists;
+	qglClear                     = dllClear;
+	qglClearAccum                = dllClearAccum;
+	qglClearColor                = dllClearColor;
+	qglClearDepth                = dllClearDepth;
+	qglClearIndex                = dllClearIndex;
+	qglClearStencil              = dllClearStencil;
+	qglClipPlane                 = dllClipPlane;
+	qglColor3b                   = dllColor3b;
+	qglColor3bv                  = dllColor3bv;
+	qglColor3d                   = dllColor3d;
+	qglColor3dv                  = dllColor3dv;
+	qglColor3f                   = dllColor3f;
+	qglColor3fv                  = dllColor3fv;
+	qglColor3i                   = dllColor3i;
+	qglColor3iv                  = dllColor3iv;
+	qglColor3s                   = dllColor3s;
+	qglColor3sv                  = dllColor3sv;
+	qglColor3ub                  = dllColor3ub;
+	qglColor3ubv                 = dllColor3ubv;
+	qglColor3ui                  = dllColor3ui;
+	qglColor3uiv                 = dllColor3uiv;
+	qglColor3us                  = dllColor3us;
+	qglColor3usv                 = dllColor3usv;
+	qglColor4b                   = dllColor4b;
+	qglColor4bv                  = dllColor4bv;
+	qglColor4d                   = dllColor4d;
+	qglColor4dv                  = dllColor4dv;
+	qglColor4f                   = dllColor4f;
+	qglColor4fv                  = dllColor4fv;
+	qglColor4i                   = dllColor4i;
+	qglColor4iv                  = dllColor4iv;
+	qglColor4s                   = dllColor4s;
+	qglColor4sv                  = dllColor4sv;
+	qglColor4ub                  = dllColor4ub;
+	qglColor4ubv                 = dllColor4ubv;
+	qglColor4ui                  = dllColor4ui;
+	qglColor4uiv                 = dllColor4uiv;
+	qglColor4us                  = dllColor4us;
+	qglColor4usv                 = dllColor4usv;
+	qglColorMask                 = dllColorMask;
+	qglColorMaterial             = dllColorMaterial;
+	qglColorPointer              = dllColorPointer;
+	qglCopyPixels                = dllCopyPixels;
+	qglCopyTexImage1D            = dllCopyTexImage1D;
+	qglCopyTexImage2D            = dllCopyTexImage2D;
+	qglCopyTexSubImage1D         = dllCopyTexSubImage1D;
+	qglCopyTexSubImage2D         = dllCopyTexSubImage2D;
+	qglCullFace                  = dllCullFace;
+	qglDeleteLists               = dllDeleteLists;
+	qglDeleteTextures            = dllDeleteTextures;
+	qglDepthFunc                 = dllDepthFunc;
+	qglDepthMask                 = dllDepthMask;
+	qglDepthRange                = dllDepthRange;
+	qglDisable                   = dllDisable;
+	qglDisableClientState        = dllDisableClientState;
+	qglDrawArrays                = dllDrawArrays;
+	qglDrawBuffer                = dllDrawBuffer;
+	qglDrawElements              = dllDrawElements;
+	qglDrawPixels                = dllDrawPixels;
+	qglEdgeFlag                  = dllEdgeFlag;
+	qglEdgeFlagPointer           = dllEdgeFlagPointer;
+	qglEdgeFlagv                 = dllEdgeFlagv;
+	qglEnable                    = 	dllEnable                   ;
+	qglEnableClientState         = 	dllEnableClientState        ;
+	qglEnd                       = 	dllEnd                      ;
+	qglEndFrame                  = 	dllEndFrame                 ;
+	qglEndShadow                 = 	dllEndShadow                ;
+	qglEndList                   = 	dllEndList                  ;
+	qglEvalCoord1d				 = 	dllEvalCoord1d				;
+	qglEvalCoord1dv              = 	dllEvalCoord1dv             ;
+	qglEvalCoord1f               = 	dllEvalCoord1f              ;
+	qglEvalCoord1fv              = 	dllEvalCoord1fv             ;
+	qglEvalCoord2d               = 	dllEvalCoord2d              ;
+	qglEvalCoord2dv              = 	dllEvalCoord2dv             ;
+	qglEvalCoord2f               = 	dllEvalCoord2f              ;
+	qglEvalCoord2fv              = 	dllEvalCoord2fv             ;
+	qglEvalMesh1                 = 	dllEvalMesh1                ;
+	qglEvalMesh2                 = 	dllEvalMesh2                ;
+	qglEvalPoint1                = 	dllEvalPoint1               ;
+	qglEvalPoint2                = 	dllEvalPoint2               ;
+	qglFeedbackBuffer            = 	dllFeedbackBuffer           ;
+	qglFinish                    = 	dllFinish                   ;
+	qglFlush                     = 	dllFlush                    ;
+	qglFlushShadow               = 	dllFlushShadow              ;
+	qglFogf                      = 	dllFogf                     ;
+	qglFogfv                     = 	dllFogfv                    ;
+	qglFogi                      = 	dllFogi                     ;
+	qglFogiv                     = 	dllFogiv                    ;
+	qglFrontFace                 = 	dllFrontFace                ;
+	qglFrustum                   = 	dllFrustum                  ;
+	qglGenLists                  = 	dllGenLists                 ;
+	qglGenTextures               = 	dllGenTextures              ;
+	qglGetBooleanv               = 	dllGetBooleanv              ;
+	qglGetClipPlane              = 	dllGetClipPlane             ;
+	qglGetDoublev                = 	dllGetDoublev               ;
+	qglGetError                  = 	dllGetError                 ;
+	qglGetFloatv                 = 	dllGetFloatv                ;
+	qglGetIntegerv               = 	dllGetIntegerv              ;
+	qglGetLightfv                = 	dllGetLightfv               ;
+	qglGetLightiv                = 	dllGetLightiv               ;
+	qglGetMapdv                  = 	dllGetMapdv                 ;
+	qglGetMapfv                  = 	dllGetMapfv                 ;
+	qglGetMapiv                  = 	dllGetMapiv                 ;
+	qglGetMaterialfv             = 	dllGetMaterialfv            ;
+	qglGetMaterialiv             = 	dllGetMaterialiv            ;
+	qglGetPixelMapfv             = 	dllGetPixelMapfv            ;
+	qglGetPixelMapuiv            = 	dllGetPixelMapuiv           ;
+	qglGetPixelMapusv            = 	dllGetPixelMapusv           ;
+	qglGetPointerv               = 	dllGetPointerv              ;
+	qglGetPolygonStipple         = 	dllGetPolygonStipple        ;
+	qglGetString                 = 	dllGetString                ;
+	qglGetTexEnvfv               = 	dllGetTexEnvfv              ;
+	qglGetTexEnviv               = 	dllGetTexEnviv              ;
+	qglGetTexGendv               = 	dllGetTexGendv              ;
+	qglGetTexGenfv               = 	dllGetTexGenfv              ;
+	qglGetTexGeniv               = 	dllGetTexGeniv              ;
+	qglGetTexImage               = 	dllGetTexImage              ;
+//	qglGetTexLevelParameterfv    = 	dllGetTexLevelParameterfv   ;
+//	qglGetTexLevelParameteriv    = 	dllGetTexLevelParameteriv   ;
+	qglGetTexParameterfv         = 	dllGetTexParameterfv        ;
+	qglGetTexParameteriv         = 	dllGetTexParameteriv        ;
+	qglHint                      = 	dllHint                     ;
+	qglIndexedTriToStrip         =  dllIndexedTriToStrip        ;
+	qglIndexMask                 = 	dllIndexMask                ;
+	qglIndexPointer              = 	dllIndexPointer             ;
+	qglIndexd                    = 	dllIndexd                   ;
+	qglIndexdv                   = 	dllIndexdv                  ;
+	qglIndexf                    = 	dllIndexf                   ;
+	qglIndexfv                   = 	dllIndexfv                  ;
+	qglIndexi                    = 	dllIndexi                   ;
+	qglIndexiv                   = 	dllIndexiv                  ;
+	qglIndexs                    = 	dllIndexs                   ;
+	qglIndexsv                   = 	dllIndexsv                  ;
+	qglIndexub                   = 	dllIndexub                  ;
+	qglIndexubv                  = 	dllIndexubv                 ;
+	qglInitNames                 = 	dllInitNames                ;
+	qglInterleavedArrays         = 	dllInterleavedArrays        ;
+	qglIsEnabled                 = 	dllIsEnabled                ;
+	qglIsList                    = 	dllIsList                   ;
+	qglIsTexture                 = 	dllIsTexture                ;
+	qglLightModelf               = 	dllLightModelf              ;
+	qglLightModelfv              = 	dllLightModelfv             ;
+	qglLightModeli               = 	dllLightModeli              ;
+	qglLightModeliv              = 	dllLightModeliv             ;
+	qglLightf                    = 	dllLightf                   ;
+	qglLightfv                   = 	dllLightfv                  ;
+	qglLighti                    = 	dllLighti                   ;
+	qglLightiv                   = 	dllLightiv                  ;
+	qglLineStipple               = 	dllLineStipple              ;
+	qglLineWidth                 = 	dllLineWidth                ;
+	qglListBase                  = 	dllListBase                 ;
+	qglLoadIdentity              = 	dllLoadIdentity             ;
+	qglLoadMatrixd               = 	dllLoadMatrixd              ;
+	qglLoadMatrixf               = 	dllLoadMatrixf              ;
+	qglLoadName                  = 	dllLoadName                 ;
+	qglLogicOp                   = 	dllLogicOp                  ;
+	qglMap1d                     = 	dllMap1d                    ;
+	qglMap1f                     = 	dllMap1f                    ;
+	qglMap2d                     = 	dllMap2d                    ;
+	qglMap2f                     = 	dllMap2f                    ;
+	qglMapGrid1d                 = 	dllMapGrid1d                ;
+	qglMapGrid1f                 = 	dllMapGrid1f                ;
+	qglMapGrid2d                 = 	dllMapGrid2d                ;
+	qglMapGrid2f                 = 	dllMapGrid2f                ;
+	qglMaterialf                 = 	dllMaterialf                ;
+	qglMaterialfv                = 	dllMaterialfv               ;
+	qglMateriali                 = 	dllMateriali                ;
+	qglMaterialiv                = 	dllMaterialiv               ;
+	qglMatrixMode                = 	dllMatrixMode               ;
+	qglMultMatrixd               = 	dllMultMatrixd              ;
+	qglMultMatrixf               = 	dllMultMatrixf              ;
+	qglNewList                   = 	dllNewList                  ;
+	qglNormal3b                  = 	dllNormal3b                 ;
+	qglNormal3bv                 = 	dllNormal3bv                ;
+	qglNormal3d                  = 	dllNormal3d                 ;
+	qglNormal3dv                 = 	dllNormal3dv                ;
+	qglNormal3f                  = 	dllNormal3f                 ;
+	qglNormal3fv                 = 	dllNormal3fv                ;
+	qglNormal3i                  = 	dllNormal3i                 ;
+	qglNormal3iv                 = 	dllNormal3iv                ;
+	qglNormal3s                  = 	dllNormal3s                 ;
+	qglNormal3sv                 = 	dllNormal3sv                ;
+	qglNormalPointer             = 	dllNormalPointer            ;
+	qglOrtho                     = 	dllOrtho                    ;
+	qglPassThrough               = 	dllPassThrough              ;
+	qglPixelMapfv                = 	dllPixelMapfv               ;
+	qglPixelMapuiv               = 	dllPixelMapuiv              ;
+	qglPixelMapusv               = 	dllPixelMapusv              ;
+	qglPixelStoref               = 	dllPixelStoref              ;
+	qglPixelStorei               = 	dllPixelStorei              ;
+	qglPixelTransferf            = 	dllPixelTransferf           ;
+	qglPixelTransferi            = 	dllPixelTransferi           ;
+	qglPixelZoom                 = 	dllPixelZoom                ;
+	qglPointSize                 = 	dllPointSize                ;
+	qglPolygonMode               = 	dllPolygonMode              ;
+	qglPolygonOffset             = 	dllPolygonOffset            ;
+	qglPolygonStipple            = 	dllPolygonStipple           ;
+	qglPopAttrib                 = 	dllPopAttrib                ;
+	qglPopClientAttrib           = 	dllPopClientAttrib          ;
+	qglPopMatrix                 = 	dllPopMatrix                ;
+	qglPopName                   = 	dllPopName                  ;
+	qglPrioritizeTextures        = 	dllPrioritizeTextures       ;
+	qglPushAttrib                = 	dllPushAttrib               ;
+	qglPushClientAttrib          = 	dllPushClientAttrib         ;
+	qglPushMatrix                = 	dllPushMatrix               ;
+	qglPushName                  = 	dllPushName                 ;
+	qglRasterPos2d               = 	dllRasterPos2d              ;
+	qglRasterPos2dv              = 	dllRasterPos2dv             ;
+	qglRasterPos2f               = 	dllRasterPos2f              ;
+	qglRasterPos2fv              = 	dllRasterPos2fv             ;
+	qglRasterPos2i               = 	dllRasterPos2i              ;
+	qglRasterPos2iv              = 	dllRasterPos2iv             ;
+	qglRasterPos2s               = 	dllRasterPos2s              ;
+	qglRasterPos2sv              = 	dllRasterPos2sv             ;
+	qglRasterPos3d               = 	dllRasterPos3d              ;
+	qglRasterPos3dv              = 	dllRasterPos3dv             ;
+	qglRasterPos3f               = 	dllRasterPos3f              ;
+	qglRasterPos3fv              = 	dllRasterPos3fv             ;
+	qglRasterPos3i               = 	dllRasterPos3i              ;
+	qglRasterPos3iv              = 	dllRasterPos3iv             ;
+	qglRasterPos3s               = 	dllRasterPos3s              ;
+	qglRasterPos3sv              = 	dllRasterPos3sv             ;
+	qglRasterPos4d               = 	dllRasterPos4d              ;
+	qglRasterPos4dv              = 	dllRasterPos4dv             ;
+	qglRasterPos4f               = 	dllRasterPos4f              ;
+	qglRasterPos4fv              = 	dllRasterPos4fv             ;
+	qglRasterPos4i               = 	dllRasterPos4i              ;
+	qglRasterPos4iv              = 	dllRasterPos4iv             ;
+	qglRasterPos4s               = 	dllRasterPos4s              ;
+	qglRasterPos4sv              = 	dllRasterPos4sv             ;
+	qglReadBuffer                = 	dllReadBuffer               ;
+	qglReadPixels                = 	dllReadPixels               ;
+	qglCopyBackBufferToTexEXT	 =	dllCopyBackBufferToTexEXT	;
+	qglCopyBackBufferToTex		 =	dllCopyBackBufferToTex		;
+	qglRectd                     = 	dllRectd                    ;
+	qglRectdv                    = 	dllRectdv                   ;
+	qglRectf                     = 	dllRectf                    ;
+	qglRectfv                    = 	dllRectfv                   ;
+	qglRecti                     = 	dllRecti                    ;
+	qglRectiv                    = 	dllRectiv                   ;
+	qglRects                     = 	dllRects                    ;
+	qglRectsv                    = 	dllRectsv                   ;
+	qglRenderMode                = 	dllRenderMode               ;
+	qglRotated                   = 	dllRotated                  ;
+	qglRotatef                   = 	dllRotatef                  ;
+	qglScaled                    = 	dllScaled                   ;
+	qglScalef                    = 	dllScalef                   ;
+	qglScissor                   = 	dllScissor                  ;
+	qglSelectBuffer              = 	dllSelectBuffer             ;
+	qglShadeModel                = 	dllShadeModel               ;
+	qglStencilFunc               = 	dllStencilFunc              ;
+	qglStencilMask               = 	dllStencilMask              ;
+	qglStencilOp                 = 	dllStencilOp                ;
+	qglTexCoord1d                = 	dllTexCoord1d               ;
+	qglTexCoord1dv               = 	dllTexCoord1dv              ;
+	qglTexCoord1f                = 	dllTexCoord1f               ;
+	qglTexCoord1fv               = 	dllTexCoord1fv              ;
+	qglTexCoord1i                = 	dllTexCoord1i               ;
+	qglTexCoord1iv               = 	dllTexCoord1iv              ;
+	qglTexCoord1s                = 	dllTexCoord1s               ;
+	qglTexCoord1sv               = 	dllTexCoord1sv              ;
+	qglTexCoord2d                = 	dllTexCoord2d               ;
+	qglTexCoord2dv               = 	dllTexCoord2dv              ;
+	qglTexCoord2f                = 	dllTexCoord2f               ;
+	qglTexCoord2fv               = 	dllTexCoord2fv              ;
+	qglTexCoord2i                = 	dllTexCoord2i               ;
+	qglTexCoord2iv               = 	dllTexCoord2iv              ;
+	qglTexCoord2s                = 	dllTexCoord2s               ;
+	qglTexCoord2sv               = 	dllTexCoord2sv              ;
+	qglTexCoord3d                = 	dllTexCoord3d               ;
+	qglTexCoord3dv               = 	dllTexCoord3dv              ;
+	qglTexCoord3f                = 	dllTexCoord3f               ;
+	qglTexCoord3fv               = 	dllTexCoord3fv              ;
+	qglTexCoord3i                = 	dllTexCoord3i               ;
+	qglTexCoord3iv               = 	dllTexCoord3iv              ;
+	qglTexCoord3s                = 	dllTexCoord3s               ;
+	qglTexCoord3sv               = 	dllTexCoord3sv              ;
+	qglTexCoord4d                = 	dllTexCoord4d               ;
+	qglTexCoord4dv               = 	dllTexCoord4dv              ;
+	qglTexCoord4f                = 	dllTexCoord4f               ;
+	qglTexCoord4fv               = 	dllTexCoord4fv              ;
+	qglTexCoord4i                = 	dllTexCoord4i               ;
+	qglTexCoord4iv               = 	dllTexCoord4iv              ;
+	qglTexCoord4s                = 	dllTexCoord4s               ;
+	qglTexCoord4sv               = 	dllTexCoord4sv              ;
+	qglTexCoordPointer           = 	dllTexCoordPointer          ;
+	qglTexEnvf                   = 	dllTexEnvf                  ;
+	qglTexEnvfv                  = 	dllTexEnvfv                 ;
+	qglTexEnvi                   = 	dllTexEnvi                  ;
+	qglTexEnviv                  = 	dllTexEnviv                 ;
+	qglTexGend                   = 	dllTexGend                  ;
+	qglTexGendv                  = 	dllTexGendv                 ;
+	qglTexGenf                   = 	dllTexGenf                  ;
+	qglTexGenfv                  = 	dllTexGenfv                 ;
+	qglTexGeni                   = 	dllTexGeni                  ;
+	qglTexGeniv                  = 	dllTexGeniv                 ;
+	qglTexImage1D                = 	dllTexImage1D               ;
+	qglTexImage2D                = 	dllTexImage2D               ;
+	qglTexImage2DEXT             = 	dllTexImage2DEXT            ;
+	qglTexParameterf             = 	dllTexParameterf            ;
+	qglTexParameterfv            = 	dllTexParameterfv           ;
+	qglTexParameteri             = 	dllTexParameteri            ;
+	qglTexParameteriv            = 	dllTexParameteriv           ;
+	qglTexSubImage1D             = 	dllTexSubImage1D            ;
+	qglTexSubImage2D             = 	dllTexSubImage2D            ;
+	qglTranslated                = 	dllTranslated               ;
+	qglTranslatef                = 	dllTranslatef               ;
+	qglVertex2d                  = 	dllVertex2d                 ;
+	qglVertex2dv                 = 	dllVertex2dv                ;
+	qglVertex2f                  = 	dllVertex2f                 ;
+	qglVertex2fv                 = 	dllVertex2fv                ;
+	qglVertex2i                  = 	dllVertex2i                 ;
+	qglVertex2iv                 = 	dllVertex2iv                ;
+	qglVertex2s                  = 	dllVertex2s                 ;
+	qglVertex2sv                 = 	dllVertex2sv                ;
+	qglVertex3d                  = 	dllVertex3d                 ;
+	qglVertex3dv                 = 	dllVertex3dv                ;
+	qglVertex3f                  = 	dllVertex3f                 ;
+	qglVertex3fv                 = 	dllVertex3fv                ;
+	qglVertex3i                  = 	dllVertex3i                 ;
+	qglVertex3iv                 = 	dllVertex3iv                ;
+	qglVertex3s                  = 	dllVertex3s                 ;
+	qglVertex3sv                 = 	dllVertex3sv                ;
+	qglVertex4d                  = 	dllVertex4d                 ;
+	qglVertex4dv                 = 	dllVertex4dv                ;
+	qglVertex4f                  = 	dllVertex4f                 ;
+	qglVertex4fv                 = 	dllVertex4fv                ;
+	qglVertex4i                  = 	dllVertex4i                 ;
+	qglVertex4iv                 = 	dllVertex4iv                ;
+	qglVertex4s                  = 	dllVertex4s                 ;
+	qglVertex4sv                 = 	dllVertex4sv                ;
+	qglVertexPointer             = 	dllVertexPointer            ;
+	qglViewport                  = 	dllViewport                 ;
+
+	qglActiveTextureARB          =  dllActiveTextureARB         ;
+	qglClientActiveTextureARB    =  dllClientActiveTextureARB   ;
+	qglMultiTexCoord2fARB        =  dllMultiTexCoord2fARB       ;
+
+	return qtrue;
+}
+
+void QGL_EnableLogging( qboolean enable )
+{
+}
+
+// Extra functions bound to d3d_ commands for controlling crazy D3D performance things
+#ifndef FINAL_BUILD
+
+// D3D_AutoPerfData controls automatic display of performance information:
+// framerate, push buffer data, etc... Usage:
+// d3d_autoperf				- Toggle on and off
+// d3d_autoperf n			- Set display frequency in ms (default 5000)
+static void D3D_AutoPerfData_f( void )
+{
+	static DWORD sdwInterval = 5000;
+	static bool sbEnabled = false;
+
+	int numArgs = Cmd_Argc();
+
+	if (numArgs > 2)
+	{
+		Com_Printf("D3D_AutoPerfData_f: Too many arguments.\n");
+	}
+	else if (numArgs <= 1)
+	{
+		sbEnabled = !sbEnabled;
+		D3DPERF_SetShowFrameRateInterval(sbEnabled ? sdwInterval : 0);
+	}
+	else // numArgs == 2 -> Exactly one real argument
+	{
+		int new_interval = atoi(Cmd_Argv(1));
+
+		if (!new_interval)
+		{
+			// Fancy way to turn it off, don't change stored interval
+			sbEnabled = false;
+		}
+		else
+		{
+			// Force it on
+			sdwInterval = new_interval;
+			sbEnabled = true;
+		}
+		D3DPERF_SetShowFrameRateInterval(sbEnabled ? sdwInterval : 0);
+	}
+}
+
+#endif
+
+extern void GLimp_SetGamma(float);
+
+
+static void _createWindow(int width, int height, int colorbits, qboolean cdsFullscreen)
+{
+	glConfig.colorBits = colorbits;
+
+	if ( r_depthbits->integer == 0 ) {
+		if ( colorbits > 16 ) {
+			glConfig.depthBits = 24;
+		} else {
+			glConfig.depthBits = 16;
+		}
+	} else {
+		glConfig.depthBits = r_depthbits->integer;
+	}
+	
+	glConfig.stencilBits = r_stencilbits->integer;
+	if ( glConfig.depthBits < 24 )
+	{
+		glConfig.stencilBits = 0;
+	}
+	
+	glConfig.displayFrequency = 75;
+	glConfig.stereoEnabled = qfalse;
+
+	// VVFIXME : This is surely wrong.
+	glConfig.vidHeight = height;
+	glConfig.vidWidth = width;
+
+}
+
+enum VideoModes
+{
+	VM_480i = 0,
+	VM_480p,
+	VM_720p,
+	VM_1080i
+};
+
+void GLW_Init(int width, int height, int colorbits, qboolean cdsFullscreen)
+{
+	glw_state = new glwstate_t;
+	int mode = VM_480i;
+
+	glw_state->isWidescreen = false;
+	if( XGetVideoFlags() & XC_VIDEO_FLAGS_WIDESCREEN )
+	{
+		glw_state->isWidescreen = true;
+		width = 720;
+
+		if( XGetVideoFlags() & XC_VIDEO_FLAGS_HDTV_480p )
+		{
+			width = 720;
+			height = 480;
+			mode = VM_480p;
+		}
+
+		/*if( XGetVideoFlags() & XC_VIDEO_FLAGS_HDTV_720p )
+		{
+			width = 1280;
+			height = 720;
+			mode = VM_720p;
+		}
+
+		if( XGetVideoFlags() & XC_VIDEO_FLAGS_HDTV_1080i )
+		{
+			width = 1920;
+			height = 1080;
+			mode = VM_1080i;
+		}*/
+	}
+
+	_createWindow(width, height, colorbits, cdsFullscreen);
+	
+	glw_state->matrixMode = glwstate_t::MatrixMode_Model;
+	glw_state->inDrawBlock = false;
+	
+	glw_state->serverTU = 0;
+	glw_state->clientTU = 0;
+	
+	glw_state->colorArrayState = false;
+	glw_state->vertexArrayState = false;
+	glw_state->normalArrayState = false;
+
+	glw_state->cullEnable = true;
+	glw_state->cullMode = D3DCULL_CCW;
+
+	glw_state->scissorEnable = false;
+	glw_state->scissorBox.x1 = 0;
+	glw_state->scissorBox.y1 = 0;
+	glw_state->scissorBox.x2 = glConfig.vidWidth;
+	glw_state->scissorBox.y2 = glConfig.vidHeight;
+
+	glw_state->shaderMask = 0;
+
+	glw_state->clearColor = D3DCOLOR_RGBA(255, 255, 255, 255);
+	glw_state->clearDepth = 1.f;
+	glw_state->clearStencil = 0;
+
+	glw_state->currentColor = D3DCOLOR_RGBA(255, 255, 255, 255);
+
+	glw_state->viewport.MinZ = 0.f;
+	glw_state->viewport.MaxZ = 1.f;
+
+	for (int t = 0; t < GLW_MAX_TEXTURE_STAGES; ++t)
+	{
+		glw_state->textureEnv[t] = D3DTOP_MODULATE;
+		glw_state->texCoordArrayState[t] = false;
+		glw_state->currentTexture[t] = 0;
+		glw_state->textureStageDirty[t] = false;
+	}
+
+	glw_state->textureBindNum = 1;
+	
+D3DPRESENT_PARAMETERS present;
+	present.BackBufferWidth = width;
+	present.BackBufferHeight = height;
+	present.BackBufferFormat = D3DFMT_A8R8G8B8;
+	present.BackBufferCount = 1;
+	present.MultiSampleType = D3DMULTISAMPLE_NONE;
+	present.SwapEffect = D3DSWAPEFFECT_DISCARD;
+	present.hDeviceWindow = 0;
+	present.Windowed = FALSE;
+	present.EnableAutoDepthStencil = TRUE;
+	present.AutoDepthStencilFormat = D3DFMT_LIN_D24S8;
+	present.Flags = 0;
+	if( glw_state->isWidescreen )
+	{
+		present.Flags = D3DPRESENTFLAG_WIDESCREEN;
+		extern void CG_SetWidescreen(qboolean widescreen);
+		if(mode == VM_480p)
+		{
+			present.Flags |= D3DPRESENTFLAG_PROGRESSIVE;
+		}
+		//else if(mode == VM_720p)
+		//{
+		//	present.Flags |= D3DPRESENTFLAG_PROGRESSIVE;
+		//}
+		//else if(mode == VM_1080i)
+		//{
+		//	present.Flags |= D3DPRESENTFLAG_INTERLACED; // | D3DPRESENTFLAG_FIELD;
+		//}
+
+
+        present.Flags |= D3DPRESENTFLAG_WIDESCREEN;
+		CG_SetWidescreen(qtrue);
+	}
+	present.FullScreen_RefreshRateInHz = D3DPRESENT_RATE_DEFAULT;
+	present.FullScreen_PresentationInterval = D3DPRESENT_INTERVAL_DEFAULT;
+	present.BufferSurfaces[0] = NULL;
+	present.BufferSurfaces[1] = NULL;
+	present.BufferSurfaces[2] = NULL;
+	present.DepthStencilSurface = NULL;
+
+	if (IDirect3D8::CreateDevice(D3DADAPTER_DEFAULT,
+								D3DDEVTYPE_HAL,
+								NULL,
+								D3DCREATE_HARDWARE_VERTEXPROCESSING,
+								&present,
+								&glw_state->device) != D3D_OK)
+	{
+		Com_Printf("Failed to create device. That's bad.\n");
+	}
+//	qglEnable(GL_VSYNC);
+	
+	for (int m = 0; m < glwstate_t::Num_MatrixModes; ++m)
+	{
+		D3DXCreateMatrixStack(0, &glw_state->matrixStack[m]);
+		glw_state->matrixStack[m]->LoadIdentity();
+		glw_state->matricesDirty[m] = false;
+	}
+
+	// VVFIXME: Hack - turn off lighting
+	dllDisable(GL_LIGHTING);
+
+	// Set a material (for lighting)
+	memset( &glw_state->mtrl, 0, sizeof(D3DMATERIAL8) );
+	glw_state->mtrl.Diffuse.r = glw_state->mtrl.Ambient.r = 1.0f;
+	glw_state->mtrl.Diffuse.g = glw_state->mtrl.Ambient.g = 1.0f;
+	glw_state->mtrl.Diffuse.b = glw_state->mtrl.Ambient.b = 1.0f;
+	glw_state->mtrl.Diffuse.a = glw_state->mtrl.Ambient.a = 1.0f;
+	glw_state->device->SetMaterial( &glw_state->mtrl );
+	// Gamma hack
+	GLimp_SetGamma(1.3f);
+
+	// Set up our directional light (used for diffuse lighting)
+	memset(&glw_state->dirLight, 0, sizeof(D3DLIGHT8));
+
+	// Set up a white point light.
+	glw_state->dirLight.Type = D3DLIGHT_DIRECTIONAL;
+	glw_state->dirLight.Diffuse.r  = 1.0f;
+	glw_state->dirLight.Diffuse.g  = 1.0f;
+	glw_state->dirLight.Diffuse.b  = 1.0f;
+	glw_state->dirLight.Direction.x = 1.0f;
+	glw_state->dirLight.Direction.y = 0.0f;
+	glw_state->dirLight.Direction.z = 0.0f;
+
+	// Don't attenuate.
+	glw_state->dirLight.Attenuation0 = 1.0f; 
+	glw_state->dirLight.Range        = 1000.0f;
+
+	//glw_state->drawArray = new DWORD[SHADER_MAX_VERTEXES * 12];
+	glw_state->drawArray = NULL;
+
+#ifdef _XBOX
+#ifdef VV_LIGHTING
+	glw_state->lightEffects = new LightEffects;
+#endif // VV_LIGHTING
+	HDREffect.Initialize();
+#endif
+
+#ifndef FINAL_BUILD
+	Cmd_AddCommand("d3d_autoperf", D3D_AutoPerfData_f);
+#endif
+}
+
+void GLW_Shutdown(void)
+{
+#ifdef _XBOX
+#ifdef VV_LIGHTING
+	delete glw_state->lightEffects;
+#endif
+#endif
+
+	for (int m = 0; m < glwstate_t::Num_MatrixModes; ++m)
+	{
+		glw_state->matrixStack[m]->Release();
+	}
+
+	glw_state->device->Release();
+
+#ifdef _XBOX
+//	delete glw_state->flareEffect;
+#endif
+
+	delete glw_state;
+}
+
+
+#if defined (_TAKESCREENS)
+void QGL_SaveScreenshot(void)
+{
+	LPDIRECT3DSURFACE8 screenShot = 0;
+	glw_state->device->GetBackBuffer(0, D3DBACKBUFFER_TYPE_MONO, &screenShot);
+
+	// Copy over the screen shot to the new image that is 64x64
+	LPDIRECT3DSURFACE8 compressedSaveGameImage = 0;
+    glw_state->device->CreateImageSurface( 64, 64, D3DFMT_DXT1, &compressedSaveGameImage );
+	D3DXLoadSurfaceFromSurface( compressedSaveGameImage, NULL, NULL,  screenShot, NULL, NULL, D3DX_DEFAULT, D3DCOLOR( 0 ) );
+  
+	// Free the big screenshot 640x480x4?
+	if ( screenShot )
+		screenShot->Release();
+
+	// Write out the saveimage to the utility drive
+    XGWriteSurfaceOrTextureToXPR( compressedSaveGameImage, "u:\\saveimage.xbx", TRUE );
+
+	// Free the compressed 64x64 image
+    if ( compressedSaveGameImage )
+		compressedSaveGameImage->Release();
+}
+#endif
+
+
+bool CreateVertexShader( const CHAR* strFilename, const DWORD* pdwVertexDecl, DWORD* pdwVertexShader )
+{
+    HRESULT hr;
+
+    // Open the vertex shader file
+    HANDLE hFile;
+    DWORD dwNumBytesRead;
+    hFile = CreateFile( strFilename, GENERIC_READ, FILE_SHARE_READ, NULL,
+                        OPEN_EXISTING, FILE_ATTRIBUTE_READONLY, NULL );
+    if( hFile == INVALID_HANDLE_VALUE )
+        return false;
+
+    // Allocate memory to read the vertex shader file
+    DWORD dwSize = GetFileSize(hFile, NULL);
+    BYTE* pData  = new BYTE[dwSize+4];
+    if( NULL == pData )
+    {
+        CloseHandle( hFile );
+        return false;
+    }
+    ZeroMemory( pData, dwSize+4 );
+
+    // Read the pre-compiled vertex shader microcode
+    ReadFile(hFile, pData, dwSize, &dwNumBytesRead, 0);
+    
+    // Create the vertex shader
+    hr = glw_state->device->CreateVertexShader( pdwVertexDecl, (const DWORD*)pData,
+                                        pdwVertexShader, 0 );
+
+    // Cleanup and return
+    CloseHandle( hFile );
+    delete [] pData;
+
+	if(hr == S_OK)
+		return true;
+
+	return false;
+}
+
+
+bool CreatePixelShader( const CHAR* strFilename, DWORD* pdwPixelShader )
+{
+    HRESULT hr;
+
+    // Open the pixel shader file
+    HANDLE hFile;
+    DWORD dwNumBytesRead;
+    hFile = CreateFile( strFilename, GENERIC_READ, FILE_SHARE_READ, NULL,
+                        OPEN_EXISTING, FILE_ATTRIBUTE_READONLY, NULL );
+    if( hFile == INVALID_HANDLE_VALUE )
+        return false;
+
+    // Load the pre-compiled pixel shader microcode
+    D3DPIXELSHADERDEF_FILE psdf;
+    ReadFile( hFile, &psdf, sizeof(D3DPIXELSHADERDEF_FILE), &dwNumBytesRead, NULL );
+    
+    // Make sure the pixel shader is valid
+    if( psdf.FileID != D3DPIXELSHADERDEF_FILE_ID )
+    {
+        CloseHandle( hFile );
+        return false;
+    }
+
+    // Create the pixel shader
+    if( FAILED( hr = glw_state->device->CreatePixelShader( &(psdf.Psd), pdwPixelShader ) ) )
+    {
+        CloseHandle( hFile );
+        return false;
+    }
+
+    // Cleanup
+    CloseHandle( hFile );
+
+    return true;
+}
diff --git a/codemp/win32/win_shared.cpp b/codemp/win32/win_shared.cpp
new file mode 100644
index 0000000..b32d1cc
--- /dev/null
+++ b/codemp/win32/win_shared.cpp
@@ -0,0 +1,547 @@
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+#include "win_local.h"
+#ifndef _XBOX
+#include <lmerr.h>
+#include <lmcons.h>
+#include <lmwksta.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <direct.h>
+#include <io.h>
+#include <conio.h>
+#endif
+
+/*
+================
+Sys_Milliseconds
+================
+*/
+int Sys_Milliseconds (bool baseTime)
+{
+	static int sys_timeBase = timeGetTime();
+	int			sys_curtime;
+
+	sys_curtime = timeGetTime();
+	if(!baseTime)
+	{
+		sys_curtime -= sys_timeBase;
+	}
+
+	return sys_curtime;
+}
+
+/*
+================
+Sys_SnapVector
+================
+*/
+void Sys_SnapVector( float *v )
+{
+	int i;
+	float f;
+
+	f = *v;
+	__asm	fld		f;
+	__asm	fistp	i;
+	*v = i;
+	v++;
+	f = *v;
+	__asm	fld		f;
+	__asm	fistp	i;
+	*v = i;
+	v++;
+	f = *v;
+	__asm	fld		f;
+	__asm	fistp	i;
+	*v = i;
+	/*
+	*v = myftol(*v);
+	v++;
+	*v = myftol(*v);
+	v++;
+	*v = myftol(*v);
+	*/
+}
+
+
+/*
+**
+** Disable all optimizations temporarily so this code works correctly!
+**
+*/
+#pragma optimize( "", off )
+
+/*
+** --------------------------------------------------------------------------------
+**
+** PROCESSOR STUFF
+**
+** --------------------------------------------------------------------------------
+*/
+static inline void CPUID( int func, unsigned int regs[4] )
+{
+	unsigned regEAX, regEBX, regECX, regEDX;
+
+	__asm mov eax, func
+	__asm __emit 00fh
+	__asm __emit 0a2h
+	__asm mov regEAX, eax
+	__asm mov regEBX, ebx
+	__asm mov regECX, ecx
+	__asm mov regEDX, edx
+
+	regs[0] = regEAX;
+	regs[1] = regEBX;
+	regs[2] = regECX;
+	regs[3] = regEDX;
+}
+
+static int IsPentium( void )
+{
+	__asm 
+	{
+		pushfd						// save eflags
+		pop		eax
+		test	eax, 0x00200000		// check ID bit
+		jz		set21				// bit 21 is not set, so jump to set_21
+		and		eax, 0xffdfffff		// clear bit 21
+		push	eax					// save new value in register
+		popfd						// store new value in flags
+		pushfd
+		pop		eax
+		test	eax, 0x00200000		// check ID bit
+		jz		good
+		jmp		err					// cpuid not supported
+set21:
+		or		eax, 0x00200000		// set ID bit
+		push	eax					// store new value
+		popfd						// store new value in EFLAGS
+		pushfd
+		pop		eax
+		test	eax, 0x00200000		// if bit 21 is on
+		jnz		good
+		jmp		err
+	}
+
+err:
+	return qfalse;
+good:
+	return qtrue;
+}
+
+static int Is3DNOW( void )
+{
+	unsigned regs[4];
+	char pstring[16];
+	char processorString[13];
+
+	// get name of processor
+	CPUID( 0, ( unsigned int * ) pstring );
+	processorString[0] = pstring[4];
+	processorString[1] = pstring[5];
+	processorString[2] = pstring[6];
+	processorString[3] = pstring[7];
+	processorString[4] = pstring[12];
+	processorString[5] = pstring[13];
+	processorString[6] = pstring[14];
+	processorString[7] = pstring[15];
+	processorString[8] = pstring[8];
+	processorString[9] = pstring[9];
+	processorString[10] = pstring[10];
+	processorString[11] = pstring[11];
+	processorString[12] = 0;
+
+//  REMOVED because you can have 3DNow! on non-AMD systems
+//	if ( strcmp( processorString, "AuthenticAMD" ) )
+//		return qfalse;
+
+	// check AMD-specific functions
+	CPUID( 0x80000000, regs );
+	if ( regs[0] < 0x80000000 )
+		return qfalse;
+
+	// bit 31 of EDX denotes 3DNOW! support
+	CPUID( 0x80000001, regs );
+	if ( regs[3] & ( 1 << 31 ) )
+		return qtrue;
+
+	return qfalse;
+}
+
+static int IsKNI( void )
+{
+	unsigned regs[4];
+
+	// get CPU feature bits
+	CPUID( 1, regs );
+
+	// bit 25 of EDX denotes KNI existence
+	if ( regs[3] & ( 1 << 25 ) )
+		return qtrue;
+
+	return qfalse;
+}
+
+static int IsWIL( void )
+{
+	unsigned regs[4];
+
+	// get CPU feature bits
+	CPUID( 1, regs );
+
+	// bit 26 of EDX denotes WIL existence
+	if ( regs[3] & ( 1 << 26 ) )
+	{
+		// Ok, CPU supports this instruction, but does the OS?
+		//
+		// Test a WIL instruction and make sure you don't get an exception...
+		//
+		__try
+		{
+			__asm
+			{
+				pushad;
+			// 	xorpd xmm0,xmm0;  // Willamette New Instructions 
+					__emit 0x0f
+					__emit 0x56
+					__emit 0xc9
+				popad;
+			}
+		}// If OS creates an exception, it doesn't support PentiumIV Instructions
+		__except(EXCEPTION_EXECUTE_HANDLER)
+		{
+//			if(_exception_code()==STATUS_ILLEGAL_INSTRUCTION)	// forget it, any exception should count as fail for safety
+				return qfalse; // Willamette New Instructions not supported
+		}
+
+		return qtrue;	// Williamette/P4 instructions available
+	}
+
+	return qfalse;
+
+}
+
+
+static int IsMMX( void )
+{
+	unsigned int regs[4];
+
+	// get CPU feature bits
+	CPUID( 1, regs );
+
+	// bit 23 of EDX denotes MMX existence
+	if ( regs[3] & ( 1 << 23 ) )
+		return qtrue;
+	return qfalse;
+}
+
+int Sys_GetProcessorId( void )
+{
+#if defined _M_ALPHA
+	return CPUID_AXP;
+#elif !defined _M_IX86
+	return CPUID_GENERIC;
+#else
+
+	// verify we're at least a Pentium or 486 w/ CPUID support
+	if ( !IsPentium() )
+		return CPUID_INTEL_UNSUPPORTED;
+
+	// check for MMX
+	if ( !IsMMX() )
+	{
+		// Pentium or PPro
+		return CPUID_INTEL_PENTIUM;
+	}
+
+	// see if we're an AMD 3DNOW! processor
+	if ( Is3DNOW() )
+	{
+		return CPUID_AMD_3DNOW;
+	}
+
+	// see if we're an Intel Katmai
+	if ( IsKNI() )
+	{
+		// if we are, see if we're a Williamette as well...
+		//
+		if ( IsWIL() )
+		{
+			return CPUID_INTEL_WILLIAMETTE;
+		}
+		return CPUID_INTEL_KATMAI;
+	}
+
+	// by default we're functionally a vanilla Pentium/MMX or P2/MMX
+	return CPUID_INTEL_MMX;
+
+#endif
+}
+
+/*
+**
+** Re-enable optimizations back to what they were
+**
+*/
+#pragma optimize( "", on )
+
+//============================================
+
+char *Sys_GetCurrentUser( void )
+{
+#ifdef _XBOX
+	return NULL;
+#else
+	static char s_userName[1024];
+	unsigned long size = sizeof( s_userName );
+
+
+	if ( !GetUserName( s_userName, &size ) )
+		strcpy( s_userName, "player" );
+
+	if ( !s_userName[0] )
+	{
+		strcpy( s_userName, "player" );
+	}
+
+	return s_userName;
+#endif
+}
+
+char	*Sys_DefaultHomePath(void) {
+	return NULL;
+}
+
+char *Sys_DefaultInstallPath(void)
+{
+	return Sys_Cwd();
+}
+
+int Sys_GetPhysicalMemory( void ) 
+{ 
+   MEMORYSTATUS	MemoryStatus;
+
+   memset( &MemoryStatus, sizeof(MEMORYSTATUS), 0 );
+   MemoryStatus.dwLength = sizeof(MEMORYSTATUS);
+
+   GlobalMemoryStatus( &MemoryStatus );
+
+   return( (int)(MemoryStatus.dwTotalPhys / (1024 * 1024)) + 1 );
+
+} 
+
+
+#ifndef _XBOX
+int Sys_GetCPUSpeedOld()
+{
+	timeBeginPeriod(1);
+
+#ifdef WIN32
+	int iPriority;
+	HANDLE hThread = GetCurrentThread();
+
+	iPriority = GetThreadPriority(hThread);
+	if ( iPriority != THREAD_PRIORITY_ERROR_RETURN )
+	{
+		SetThreadPriority(hThread, THREAD_PRIORITY_TIME_CRITICAL);
+	}
+#endif // WIN32
+
+	DWORD clockStart = timeGetTime();
+	DWORD clockEnd = clockStart + 100;
+
+	unsigned long start;
+	unsigned long end;
+
+	__asm
+	{
+		rdtsc
+		mov start, eax
+	}
+
+	while(timeGetTime() < clockEnd)
+	{	// loop for 1 tenth of a second
+	}
+	__asm
+	{
+		rdtsc
+		mov end, eax
+	}
+
+
+#ifdef WIN32
+	// Reset priority
+	if ( iPriority != THREAD_PRIORITY_ERROR_RETURN )
+	{
+		SetThreadPriority(hThread, iPriority);
+	}
+#endif // WIN32
+	
+	timeEndPeriod(1);
+
+	unsigned long	time;
+	time = end - start;
+	int coarse = time / 100000;
+	int firsttry = floor((coarse + 25) / 50) * 50;
+	if (abs(firsttry - coarse) < 10)
+	{
+		return firsttry;
+	}
+	else
+	{
+		return floor(floor((coarse + 17) / 33.3) * 33.3);
+	}
+}
+
+int Sys_GetCPUSpeed()
+{
+	unsigned long raw_freq;		// Raw frequency of CPU in MHz
+	unsigned long norm_freq;	// Normalized frequency of CPU in MHz.
+	LARGE_INTEGER t0,t1;			// Variables for High-Resolution Performance Counter reads
+
+	unsigned long freq  =0;			// Most current frequ. calculation
+	unsigned long freq2 =0;			// 2nd most current frequ. calc.
+	unsigned long freq3 =0;			// 3rd most current frequ. calc.
+	
+	unsigned long total;			// Sum of previous three frequency calculations
+	int tries=0;			// Number of times a calculation has been made on this call to cpuspeed
+	unsigned long  total_cycles=0, cycles;	// Clock cycles elapsed during test
+	unsigned long  stamp0=0, stamp1=0;		// Time Stamp Variable for beginning and end  of test
+	unsigned long  total_ticks=0, ticks;	// Microseconds elapsed during test	
+	LARGE_INTEGER count_freq;		// High Resolution Performance Counter frequency
+
+#define TOLERANCE		1		// Number of MHz to allow samplings to deviate from average of samplings.
+#define ROUND_THRESHOLD		6
+
+#ifdef WIN32
+	int iPriority;
+	HANDLE hThread = GetCurrentThread();
+#endif // WIN32;
+
+	if ( !QueryPerformanceFrequency ( &count_freq ) )
+		return Sys_GetCPUSpeedOld();	//should never happen
+
+	// On processors supporting the Read 
+	//   Time Stamp opcode, compare elapsed
+	//   time on the High-Resolution Counter
+	//   with elapsed cycles on the Time 
+	//   Stamp Register.
+	
+	do {	// This do loop runs up to 20 times or until the average of the previous 
+	   		//   three calculated frequencies is within 1 MHz of each of the 
+	   		//   individual calculated frequencies. This resampling increases the 
+			//   accuracy of the results since outside factors could affect this calculation
+			
+		tries++;		// Increment number of times sampled on this call to cpuspeed
+			
+		freq3 = freq2;	// Shift frequencies back to make
+		freq2 = freq;	//   room for new frequency measurement
+
+    	QueryPerformanceCounter(&t0);// Get high-resolution performance counter time
+			
+		t1 = t0;		// Set Initial time
+
+#ifdef WIN32
+		iPriority = GetThreadPriority(hThread);
+		if ( iPriority != THREAD_PRIORITY_ERROR_RETURN )
+		{
+			SetThreadPriority(hThread, THREAD_PRIORITY_TIME_CRITICAL);
+		}
+#endif // WIN32
+
+   		while ( (unsigned long)t1.LowPart - (unsigned long)t0.LowPart<50) {
+   			// Loop until 50 ticks have passed since last read of hi-res counter. This accounts for overhead later.
+			QueryPerformanceCounter(&t1);
+			_asm {
+				rdtsc;						// Read Time Stamp
+				MOV stamp0, EAX
+			}
+		}
+			
+		t0 = t1;		// Reset Initial Time
+
+   		while ((unsigned long)t1.LowPart-(unsigned long)t0.LowPart<2000 ) {
+   		// Loop until enough ticks have passed since last read of hi-res counter. This allows for elapsed time for sampling.
+   			QueryPerformanceCounter(&t1);
+			__asm {
+				rdtsc;						// Read Time Stamp
+				MOV stamp1, EAX
+			}
+		}
+
+#ifdef WIN32
+		if ( iPriority != THREAD_PRIORITY_ERROR_RETURN )
+		{	// Reset priority
+			SetThreadPriority(hThread, iPriority);
+		}
+#endif // WIN32
+
+       	cycles = stamp1 - stamp0;	// Number of internal clock cycles is difference between two time stamp readings.
+
+    	ticks = (unsigned long) t1.LowPart - (unsigned long) t0.LowPart;	
+				// Number of external ticks is difference between two hi-res counter reads.
+	
+
+		// Note that some seemingly arbitrary mulitplies and
+		//   divides are done below. This is to maintain a 
+		//   high level of precision without truncating the 
+		//   most significant data. According to what value 
+		//   ITERATIIONS is set to, these multiplies and
+		//   divides might need to be shifted for optimal
+		//   precision.
+
+		ticks = ticks * 100000;	// Convert ticks to hundred thousandths of a tick
+			
+		ticks = ticks / ( count_freq.LowPart/10 );		
+						// Hundred Thousandths of a Ticks / ( 10 ticks/second ) = microseconds (us)
+
+		total_ticks += ticks;
+		total_cycles += cycles;
+
+		if ( ticks%count_freq.LowPart > count_freq.LowPart/2 )
+			ticks++;			// Round up if necessary
+			
+		if (!ticks){
+			ticks++;			// prevent DIV by ZERO
+		}
+
+		freq = cycles/ticks;	// Cycles / us  = MHz
+        										
+     	if ( cycles%ticks > ticks/2 )
+       		freq++;				// Round up if necessary
+          	
+		total = ( freq + freq2 + freq3 ); // Total last three frequency calculations
+
+	} while ( (tries < 3 ) || 
+	          (tries < 20)&&
+	          ((abs(3 * freq -total) > 3*TOLERANCE )||
+	           (abs(3 * freq2-total) > 3*TOLERANCE )||
+	           (abs(3 * freq3-total) > 3*TOLERANCE )));	
+				// Compare last three calculations to average of last three calculations.		
+
+	if (!total_ticks){
+		total_ticks++;			// prevent DIV by ZERO
+	}
+
+	// Try one more significant digit.
+	freq3 = ( total_cycles * 10 ) / total_ticks;
+	freq2 = ( total_cycles * 100 ) / total_ticks;
+
+
+	if ( freq2 - (freq3 * 10) >= ROUND_THRESHOLD )
+		freq3++;
+
+	raw_freq = total_cycles / total_ticks;
+	norm_freq = raw_freq;
+
+	freq = raw_freq * 10;
+	if( (freq3 - freq) >= ROUND_THRESHOLD )
+		norm_freq++;
+
+	return norm_freq;
+}
+#endif
+
diff --git a/codemp/win32/win_snd.cpp b/codemp/win32/win_snd.cpp
new file mode 100644
index 0000000..ca45b5e
--- /dev/null
+++ b/codemp/win32/win_snd.cpp
@@ -0,0 +1,382 @@
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+#include <float.h>
+
+#include "../client/snd_local.h"
+#include "win_local.h"
+
+HRESULT (WINAPI *pDirectSoundCreate)(GUID FAR *lpGUID, LPDIRECTSOUND FAR *lplpDS, IUnknown FAR *pUnkOuter);
+#define iDirectSoundCreate(a,b,c)	pDirectSoundCreate(a,b,c)
+
+#define SECONDARY_BUFFER_SIZE	0x10000
+
+extern int s_UseOpenAL;
+
+static qboolean	dsound_init;
+static int		sample16;
+static DWORD	gSndBufSize;
+static DWORD	locksize;
+static LPDIRECTSOUND pDS;
+static LPDIRECTSOUNDBUFFER pDSBuf, pDSPBuf;
+static HINSTANCE hInstDS;
+
+
+static const char *DSoundError( int error ) {
+	switch ( error ) {
+	case DSERR_BUFFERLOST:
+		return "DSERR_BUFFERLOST";
+	case DSERR_INVALIDCALL:
+		return "DSERR_INVALIDCALLS";
+	case DSERR_INVALIDPARAM:
+		return "DSERR_INVALIDPARAM";
+	case DSERR_PRIOLEVELNEEDED:
+		return "DSERR_PRIOLEVELNEEDED";
+	case DSERR_ALLOCATED:
+		return "DSERR_ALLOCATED";
+	case DSERR_UNINITIALIZED:
+		return "DSERR_UNINITIALIZED";
+	case DSERR_UNSUPPORTED:
+		return "DSERR_UNSUPPORTED ";
+	}
+
+	return "unknown";
+}
+
+/*
+==================
+SNDDMA_Shutdown
+==================
+*/
+void SNDDMA_Shutdown( void ) {
+	Com_DPrintf( "Shutting down sound system\n" );
+
+	if ( pDS ) {
+		Com_DPrintf( "Destroying DS buffers\n" );
+		if ( pDS )
+		{
+			Com_DPrintf( "...setting NORMAL coop level\n" );
+			pDS->SetCooperativeLevel( g_wv.hWnd, DSSCL_NORMAL );
+		}
+
+		if ( pDSBuf )
+		{
+			Com_DPrintf( "...stopping and releasing sound buffer\n" );
+			pDSBuf->Stop( );
+			pDSBuf->Release( );
+		}
+
+		// only release primary buffer if it's not also the mixing buffer we just released
+		if ( pDSPBuf && ( pDSBuf != pDSPBuf ) )
+		{
+			Com_DPrintf( "...releasing primary buffer\n" );
+			pDSPBuf->Release( );
+		}
+		pDSBuf = NULL;
+		pDSPBuf = NULL;
+
+		dma.buffer = NULL;
+
+		Com_DPrintf( "...releasing DS object\n" );
+		pDS->Release( );
+	}
+
+	if ( hInstDS ) {
+		Com_DPrintf( "...freeing DSOUND.DLL\n" );
+		FreeLibrary( hInstDS );
+		hInstDS = NULL;
+	}
+
+	pDS = NULL;
+	pDSBuf = NULL;
+	pDSPBuf = NULL;
+	dsound_init = qfalse;
+	memset ((void *)&dma, 0, sizeof (dma));
+}
+
+/*
+==================
+SNDDMA_Init
+
+Initialize direct sound
+Returns false if failed
+==================
+*/
+qboolean SNDDMA_Init(void) {
+
+	memset ((void *)&dma, 0, sizeof (dma));
+	dsound_init = qfalse;
+
+	if ( !SNDDMA_InitDS () ) {
+		return qfalse;
+	}
+
+	dsound_init = qtrue;
+
+	Com_DPrintf("Completed successfully\n" );
+
+    return qtrue;
+}
+
+
+int SNDDMA_InitDS ()
+{
+	HRESULT			hresult;
+	qboolean		pauseTried;
+	DSBUFFERDESC	dsbuf;
+	DSBCAPS			dsbcaps;
+	WAVEFORMATEX	format;
+
+	Com_Printf( "Initializing DirectSound\n");
+
+	if ( !hInstDS ) {
+		Com_DPrintf( "...loading dsound.dll: " );
+
+		hInstDS = LoadLibrary("dsound.dll");
+		
+		if ( hInstDS == NULL ) {
+			Com_Printf ("failed\n");
+			return 0;
+		}
+
+		Com_DPrintf ("ok\n");
+		pDirectSoundCreate = (long (__stdcall *)(struct _GUID *,struct IDirectSound ** ,struct IUnknown *))
+			GetProcAddress(hInstDS,"DirectSoundCreate");
+
+		if ( !pDirectSoundCreate ) {
+			Com_Printf ("*** couldn't get DS proc addr ***\n");
+			return 0;
+		}
+	}
+
+	Com_DPrintf( "...creating DS object: " );
+	pauseTried = qfalse;
+	while ( ( hresult = iDirectSoundCreate( NULL, &pDS, NULL ) ) != DS_OK ) {
+		if ( hresult != DSERR_ALLOCATED ) {
+			Com_Printf( "failed\n" );
+			return 0;
+		}
+
+		if ( pauseTried ) {
+			Com_Printf ("failed, hardware already in use\n" );
+			return 0;
+		}
+		// first try just waiting five seconds and trying again
+		// this will handle the case of a sysyem beep playing when the
+		// game starts
+		Com_DPrintf ("retrying...\n");
+		Sleep( 3000 );
+		pauseTried = qtrue;
+	}
+	Com_DPrintf( "ok\n" );
+
+	Com_DPrintf("...setting DSSCL_PRIORITY coop level: " );
+
+	if ( DS_OK != pDS->SetCooperativeLevel( g_wv.hWnd, DSSCL_PRIORITY ) )	{
+		Com_Printf ("failed\n");
+		SNDDMA_Shutdown ();
+		return qfalse;
+	}
+	Com_DPrintf("ok\n" );
+
+
+	// create the secondary buffer we'll actually work with
+	dma.channels = 2;
+	dma.samplebits = 16;
+
+	if (s_khz->integer == 44)
+		dma.speed = 44100;
+	else if (s_khz->integer == 22)
+		dma.speed = 22050;
+	else
+		dma.speed = 11025;
+
+	memset (&format, 0, sizeof(format));
+	format.wFormatTag = WAVE_FORMAT_PCM;
+    format.nChannels = dma.channels;
+    format.wBitsPerSample = dma.samplebits;
+    format.nSamplesPerSec = dma.speed;
+    format.nBlockAlign = format.nChannels * format.wBitsPerSample / 8;
+    format.cbSize = 0;
+    format.nAvgBytesPerSec = format.nSamplesPerSec*format.nBlockAlign; 
+
+	memset (&dsbuf, 0, sizeof(dsbuf));
+	dsbuf.dwSize = sizeof(DSBUFFERDESC);
+
+#define idDSBCAPS_GETCURRENTPOSITION2 0x00010000
+
+	dsbuf.dwFlags = DSBCAPS_CTRLFREQUENCY | DSBCAPS_LOCHARDWARE | idDSBCAPS_GETCURRENTPOSITION2;
+	dsbuf.dwBufferBytes = SECONDARY_BUFFER_SIZE;
+	dsbuf.lpwfxFormat = &format;
+	
+	Com_DPrintf( "...creating secondary buffer: " );
+	if (DS_OK != pDS->CreateSoundBuffer(&dsbuf, &pDSBuf, NULL)) {
+		Com_Printf( " - using ancient version of DirectX -- this will slow FPS\n" );
+		dsbuf.dwFlags = DSBCAPS_CTRLFREQUENCY;
+		hresult = pDS->CreateSoundBuffer(&dsbuf, &pDSBuf, NULL);
+		if (hresult != DS_OK) {			
+			Com_Printf( "failed to create secondary buffer - %s\n", DSoundError( hresult ) );
+			SNDDMA_Shutdown ();
+			return qfalse;
+		}
+	}
+	Com_Printf( "locked hardware.  ok\n" );
+		
+	// Make sure mixer is active
+	if ( DS_OK != pDSBuf->Play(0, 0, DSBPLAY_LOOPING) ) {
+		Com_Printf ("*** Looped sound play failed ***\n");
+		SNDDMA_Shutdown ();
+		return qfalse;
+	}
+
+	memset(&dsbcaps, 0, sizeof(dsbcaps));
+	dsbcaps.dwSize = sizeof(dsbcaps);
+	// get the returned buffer size
+	if ( DS_OK != pDSBuf->GetCaps (&dsbcaps) ) {
+		Com_Printf ("*** GetCaps failed ***\n");
+		SNDDMA_Shutdown ();
+		return qfalse;
+	}
+	
+	gSndBufSize = dsbcaps.dwBufferBytes;
+
+	dma.channels = format.nChannels;
+	dma.samplebits = format.wBitsPerSample;
+	dma.speed = format.nSamplesPerSec;
+	dma.samples = gSndBufSize/(dma.samplebits/8);
+	dma.submission_chunk = 1;
+	dma.buffer = NULL;			// must be locked first
+
+	sample16 = (dma.samplebits/8) - 1;
+
+	SNDDMA_BeginPainting ();
+	if (dma.buffer)
+		memset(dma.buffer, 0, dma.samples * dma.samplebits/8);
+	SNDDMA_Submit ();
+	return 1;
+}
+/*
+==============
+SNDDMA_GetDMAPos
+
+return the current sample position (in mono samples read)
+inside the recirculating dma buffer, so the mixing code will know
+how many sample are required to fill it up.
+===============
+*/
+int SNDDMA_GetDMAPos( void ) {
+	MMTIME	mmtime;
+	int		s;
+	DWORD	dwWrite;
+
+	if ( !dsound_init ) {
+		return 0;
+	}
+
+	mmtime.wType = TIME_SAMPLES;
+	pDSBuf->GetCurrentPosition(&mmtime.u.sample, &dwWrite);
+
+	s = mmtime.u.sample;
+
+	s >>= sample16;
+
+	s &= (dma.samples-1);
+
+	return s;
+}
+
+/*
+==============
+SNDDMA_BeginPainting
+
+Makes sure dma.buffer is valid
+===============
+*/
+void SNDDMA_BeginPainting( void ) {
+	int		reps;
+	DWORD	dwSize2;
+	DWORD	*pbuf, *pbuf2;
+	HRESULT	hresult;
+	DWORD	dwStatus;
+
+	if ( !pDSBuf ) {
+		return;
+	}
+
+	// if the buffer was lost or stopped, restore it and/or restart it
+	if ( pDSBuf->GetStatus (&dwStatus) != DS_OK ) {
+		Com_Printf ("Couldn't get sound buffer status\n");
+	}
+	
+	if (dwStatus & DSBSTATUS_BUFFERLOST)
+		pDSBuf->Restore ();
+	
+	if (!(dwStatus & DSBSTATUS_PLAYING))
+		pDSBuf->Play(0, 0, DSBPLAY_LOOPING);
+
+	// lock the dsound buffer
+
+	reps = 0;
+	dma.buffer = NULL;
+
+	while ((hresult = pDSBuf->Lock(0, gSndBufSize, (void **)&pbuf, &locksize, 
+								   (void **)&pbuf2, &dwSize2, 0)) != DS_OK)
+	{
+		if (hresult != DSERR_BUFFERLOST)
+		{
+			Com_Printf( "SNDDMA_BeginPainting: Lock failed with error '%s'\n", DSoundError( hresult ) );
+			S_Shutdown ();
+			return;
+		}
+		else
+		{
+			pDSBuf->Restore( );
+		}
+
+		if (++reps > 2)
+			return;
+	}
+	dma.buffer = (unsigned char *)pbuf;
+}
+
+/*
+==============
+SNDDMA_Submit
+
+Send sound to device if buffer isn't really the dma buffer
+Also unlocks the dsound buffer
+===============
+*/
+void SNDDMA_Submit( void ) {
+    // unlock the dsound buffer
+	if ( pDSBuf ) {
+		pDSBuf->Unlock(dma.buffer, locksize, NULL, 0);
+	}
+}
+
+
+/*
+=================
+SNDDMA_Activate
+
+When we change windows we need to do this
+=================
+*/
+void SNDDMA_Activate( qboolean bAppActive )
+{
+	if (s_UseOpenAL)
+	{
+		S_AL_MuteAllSounds(!bAppActive);
+	}
+
+	if ( !pDS ) {
+		return;
+	}
+
+	if ( DS_OK != pDS->SetCooperativeLevel( g_wv.hWnd, DSSCL_PRIORITY ) )	{
+		Com_Printf ("sound SetCooperativeLevel failed\n");
+		SNDDMA_Shutdown ();
+	}
+}
+
+
diff --git a/codemp/win32/win_stream_dx8.cpp b/codemp/win32/win_stream_dx8.cpp
new file mode 100644
index 0000000..6592fb0
--- /dev/null
+++ b/codemp/win32/win_stream_dx8.cpp
@@ -0,0 +1,290 @@
+
+/*
+ * UNPUBLISHED -- Rights  reserved  under  the  copyright  laws  of the 
+ * United States.  Use  of a copyright notice is precautionary only and 
+ * does not imply publication or disclosure.                            
+ *                                                                      
+ * THIS DOCUMENTATION CONTAINS CONFIDENTIAL AND PROPRIETARY INFORMATION 
+ * OF    VICARIOUS   VISIONS,  INC.    ANY  DUPLICATION,  MODIFICATION, 
+ * DISTRIBUTION, OR DISCLOSURE IS STRICTLY PROHIBITED WITHOUT THE PRIOR 
+ * EXPRESS WRITTEN PERMISSION OF VICARIOUS VISIONS, INC.
+ */
+
+#include "../server/exe_headers.h"
+
+#include "../client/client.h"
+#include "win_local.h"
+#include "../qcommon/qcommon.h"
+
+#if defined(_WINDOWS)
+#include <windows.h>
+#elif defined(_XBOX)
+#include <xtl.h>
+#endif
+
+extern void Z_SetNewDeleteTemporary(bool);
+
+#define STREAM_SLOW_READ 0
+
+#include "../client/snd_local_console.h"
+
+#include <deque>
+
+extern HANDLE Sys_FileStreamMutex;
+extern const char* Sys_GetFileCodeName(int code);
+extern int Sys_GetFileCodeSize(int code);
+
+#define STREAM_MAX_OPEN 48
+struct StreamInfo
+{
+	volatile HANDLE file;
+	volatile bool used;
+	volatile bool error;
+	volatile bool opening;
+	volatile bool reading;
+};
+static StreamInfo* s_Streams = NULL;
+
+enum IORequestType
+{
+	IOREQ_OPEN,
+	IOREQ_READ,
+	IOREQ_SHUTDOWN,
+};
+
+struct IORequest
+{
+	IORequestType type;
+	streamHandle_t handle;
+	DWORD data[3];
+};
+typedef std::deque<IORequest> requestqueue_t;
+requestqueue_t* s_IORequestQueue = NULL;
+
+HANDLE s_Thread = INVALID_HANDLE_VALUE;
+HANDLE s_QueueMutex = INVALID_HANDLE_VALUE;
+HANDLE s_QueueLen = INVALID_HANDLE_VALUE;
+
+
+static DWORD WINAPI _streamThread(LPVOID)
+{
+	for (;;)
+	{
+		IORequest req;
+		DWORD bytes;
+		StreamInfo* strm;
+
+		// Wait for the IO queue to fill
+		WaitForSingleObject(s_QueueLen, INFINITE);
+		
+		// Grab the next IO request
+		WaitForSingleObject(s_QueueMutex, INFINITE);
+		assert(!s_IORequestQueue->empty());
+		req = s_IORequestQueue->front();
+		s_IORequestQueue->pop_front();
+		ReleaseMutex(s_QueueMutex);
+
+		// Process request
+		switch (req.type)
+		{
+		case IOREQ_OPEN:
+			strm = &s_Streams[req.handle];
+			assert(strm->used);
+		
+			{
+				const char* name = Sys_GetFileCodeName(req.data[0]);
+
+				WaitForSingleObject(Sys_FileStreamMutex, INFINITE);
+			
+				strm->file = 
+					CreateFile(name, GENERIC_READ, 
+					FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);
+			
+				ReleaseMutex(Sys_FileStreamMutex);
+			}
+
+			strm->error = (strm->file == INVALID_HANDLE_VALUE);
+			strm->opening = false;
+			break;
+
+		case IOREQ_READ:
+			strm = &s_Streams[req.handle];
+			assert(strm->used);
+		
+			WaitForSingleObject(Sys_FileStreamMutex, INFINITE);
+
+#			if STREAM_SLOW_READ
+			Sleep(200);
+#			endif
+
+			strm->error = 
+				(SetFilePointer(strm->file, req.data[2], 0, FILE_BEGIN) != req.data[2] ||
+				ReadFile(strm->file, (void*)req.data[0], req.data[1], &bytes, NULL) == 0);
+			
+			ReleaseMutex(Sys_FileStreamMutex);
+
+			strm->reading = false;
+			break;
+
+		case IOREQ_SHUTDOWN:
+			ExitThread(0);
+			break;
+		}
+	}
+
+	return TRUE;
+}
+
+
+static void _sendIORequest(const IORequest& req)
+{
+	// Add request to queue
+	WaitForSingleObject(s_QueueMutex, INFINITE);
+	Z_SetNewDeleteTemporary(true);
+	s_IORequestQueue->push_back(req);
+	Z_SetNewDeleteTemporary(false);
+	ReleaseMutex(s_QueueMutex);
+
+	// Let IO thread know it has one more pending request
+	ReleaseSemaphore(s_QueueLen, 1, NULL);
+}
+
+void Sys_IORequestQueueClear(void)
+{
+	WaitForSingleObject(s_QueueMutex, INFINITE);
+	delete s_IORequestQueue;
+	s_IORequestQueue = new requestqueue_t;
+	ReleaseMutex(s_QueueMutex);
+}
+
+void Sys_StreamInit(void)
+{
+	// Create array for storing open streams
+	s_Streams = (StreamInfo*)Z_Malloc(
+		STREAM_MAX_OPEN * sizeof(StreamInfo), TAG_FILESYS, qfalse);
+	for (int i = 0; i < STREAM_MAX_OPEN; ++i)
+	{
+		s_Streams[i].used = false;
+	}
+
+	// Create queue to hold requests for IO thread
+	s_IORequestQueue = new requestqueue_t;
+
+	// Create a thread to service IO
+	s_QueueMutex = CreateMutex(NULL, FALSE, NULL);
+	s_QueueLen = CreateSemaphore(NULL, 0, STREAM_MAX_OPEN * 3, NULL);
+	s_Thread = CreateThread(NULL, 0, _streamThread, 0, 0, NULL);
+}
+
+void Sys_StreamShutdown(void)
+{
+	// Tell the IO thread to shutdown
+	IORequest req;
+	req.type = IOREQ_SHUTDOWN;
+	_sendIORequest(req);
+
+	// Wait for thread to close
+	WaitForSingleObject(s_Thread, INFINITE);
+	
+	// Kill IO thread
+	CloseHandle(s_Thread);
+	CloseHandle(s_QueueLen);
+	CloseHandle(s_QueueMutex);
+
+	// Remove queue of IO requests
+	delete s_IORequestQueue;
+	
+	// Remove streaming table
+	Z_Free(s_Streams);
+}
+
+static streamHandle_t GetFreeHandle(void)
+{
+	for (streamHandle_t i = 1; i < STREAM_MAX_OPEN; ++i)
+	{
+		if (!s_Streams[i].used) return i;
+	}
+	
+	// handle 0 is invalid by convention
+	return 0;
+}
+
+int Sys_StreamOpen(int code, streamHandle_t *handle)
+{
+	// Find a free handle
+	*handle = GetFreeHandle();
+	if (*handle == 0)
+	{
+		return -1;
+	}
+
+	// Find the file size
+	int size = Sys_GetFileCodeSize(code);
+	if (size < 0)
+	{
+		*handle = 0;
+		return -1;
+	}
+
+	// Init stream data
+	s_Streams[*handle].used = true;
+	s_Streams[*handle].opening = true;
+	s_Streams[*handle].reading = false;
+	s_Streams[*handle].error = false;
+
+	// Send an open request to the thread
+	IORequest req;
+	req.type = IOREQ_OPEN;
+	req.handle = *handle;
+	req.data[0] = code;
+	_sendIORequest(req);
+
+	// Return file size
+	return size;
+}
+
+bool Sys_StreamRead(void* buffer, int size, int pos, streamHandle_t handle)
+{
+	assert((unsigned int)buffer % 32 == 0);
+
+	// Handle must be valid.  Do not allow multiple reads.
+	if (!s_Streams[handle].used || s_Streams[handle].reading) return false;
+
+	// Ready to read
+	s_Streams[handle].reading = true;
+	s_Streams[handle].error = false;
+	
+	// Request IO threading reading
+	IORequest req;
+	req.type = IOREQ_READ;
+	req.handle = handle;
+	req.data[0] = (DWORD)buffer;
+	req.data[1] = size;
+	req.data[2] = pos;
+	_sendIORequest(req);
+	
+	return true;
+}
+
+bool Sys_StreamIsReading(streamHandle_t handle)
+{
+	return s_Streams[handle].used && s_Streams[handle].reading;
+}
+
+bool Sys_StreamIsError(streamHandle_t handle)
+{
+	return s_Streams[handle].used && s_Streams[handle].error;
+}
+
+void Sys_StreamClose(streamHandle_t handle)
+{
+	if (s_Streams[handle].used)
+	{
+		// Block until read is done
+		while (s_Streams[handle].opening || s_Streams[handle].reading);
+		
+		// Close the file
+		CloseHandle(s_Streams[handle].file);
+		s_Streams[handle].used = false;
+	}
+}
diff --git a/codemp/win32/win_syscon.cpp b/codemp/win32/win_syscon.cpp
new file mode 100644
index 0000000..2ba3639
--- /dev/null
+++ b/codemp/win32/win_syscon.cpp
@@ -0,0 +1,574 @@
+// win_syscon.h
+// this include must remain at the top of every CPP file
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+#include "../client/client.h"
+#include "win_local.h"
+
+
+#include "resource.h"
+#include <errno.h>
+#include <float.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <direct.h>
+#include <io.h>
+#include <conio.h>
+
+#define COPY_ID			1
+#define QUIT_ID			2
+#define CLEAR_ID		3
+
+#define ERRORBOX_ID		10
+#define ERRORTEXT_ID	11
+
+#define EDIT_ID			100
+#define INPUT_ID		101
+
+typedef struct
+{
+	HWND		hWnd;
+	HWND		hwndBuffer;
+
+	HWND		hwndButtonClear;
+	HWND		hwndButtonCopy;
+	HWND		hwndButtonQuit;
+
+	HWND		hwndErrorBox;
+	HWND		hwndErrorText;
+
+	HBITMAP		hbmLogo;
+	HBITMAP		hbmClearBitmap;
+
+	HBRUSH		hbrEditBackground;
+	HBRUSH		hbrErrorBackground;
+
+	HFONT		hfBufferFont;
+	HFONT		hfButtonFont;
+
+	HWND		hwndInputLine;
+
+	char		errorString[80];
+
+	char		consoleText[512], returnedText[512];
+	int			visLevel;
+	qboolean	quitOnClose;
+	int			windowWidth, windowHeight;
+	
+	WNDPROC		SysInputLineWndProc;
+
+} WinConData;
+
+static WinConData s_wcd;
+
+static LONG WINAPI ConWndProc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
+{
+	const char *cmdString;
+	static qboolean s_timePolarity;
+
+	switch (uMsg)
+	{
+	case WM_ACTIVATE:
+		if ( LOWORD( wParam ) != WA_INACTIVE )
+		{
+			SetFocus( s_wcd.hwndInputLine );
+		}
+
+		if ( com_viewlog && ( com_dedicated && !com_dedicated->integer ) )
+		{
+			// if the viewlog is open, check to see if it's being minimized
+			if ( com_viewlog->integer == 1 )
+			{
+				if ( HIWORD( wParam ) )		// minimized flag
+				{
+					Cvar_Set( "viewlog", "2" );
+				}
+			}
+			else if ( com_viewlog->integer == 2 )
+			{
+				if ( !HIWORD( wParam ) )		// minimized flag
+				{
+					Cvar_Set( "viewlog", "1" );
+				}
+			}
+		}
+		break;
+
+	case WM_CLOSE:
+		if ( ( com_dedicated && com_dedicated->integer ) )
+		{
+			cmdString = CopyString( "quit" );
+			Sys_QueEvent( 0, SE_CONSOLE, 0, 0, strlen( cmdString ) + 1, (void *)cmdString );
+		}
+		else if ( s_wcd.quitOnClose )
+		{
+			PostQuitMessage( 0 );
+		}
+		else
+		{
+			Sys_ShowConsole( 0, qfalse );
+			Cvar_Set( "viewlog", "0" );
+		}
+		return 0;
+	case WM_CTLCOLORSTATIC:
+		if ( ( HWND ) lParam == s_wcd.hwndBuffer )
+		{
+			SetBkColor( ( HDC ) wParam, RGB( 0, 0, 0 ) );
+			SetTextColor( ( HDC ) wParam, RGB( 249, 249, 000 ) );
+			return ( long ) s_wcd.hbrEditBackground;
+		}
+		else if ( ( HWND ) lParam == s_wcd.hwndErrorBox )
+		{
+			if ( s_timePolarity & 1 )
+			{
+				SetBkColor(   ( HDC ) wParam, RGB( 0x80, 0x80, 0x80 ) );
+				SetTextColor( ( HDC ) wParam, RGB( 0xff, 0x00, 0x00 ) );
+			}
+			else
+			{
+				SetBkColor(   ( HDC ) wParam, RGB( 0x80, 0x80, 0x80 ) );
+				SetTextColor( ( HDC ) wParam, RGB( 0x00, 0x00, 0x00 ) );
+			}
+			return ( long ) s_wcd.hbrErrorBackground;
+		}
+		return FALSE;
+		break;
+
+	case WM_COMMAND:
+		if ( wParam == COPY_ID )
+		{
+			SendMessage( s_wcd.hwndBuffer, EM_SETSEL, 0, -1 );
+			SendMessage( s_wcd.hwndBuffer, WM_COPY, 0, 0 );
+		}
+		else if ( wParam == QUIT_ID )
+		{
+			if ( s_wcd.quitOnClose )
+			{
+				PostQuitMessage( 0 );
+			}
+			else
+			{
+				cmdString = CopyString( "quit" );
+				Sys_QueEvent( 0, SE_CONSOLE, 0, 0, strlen( cmdString ) + 1, (void *)cmdString );
+			}
+		}
+		else if ( wParam == CLEAR_ID )
+		{
+			SendMessage( s_wcd.hwndBuffer, EM_SETSEL, 0, -1 );
+			SendMessage( s_wcd.hwndBuffer, EM_REPLACESEL, FALSE, ( LPARAM ) "" );
+			UpdateWindow( s_wcd.hwndBuffer );
+		}
+		break;
+	case WM_CREATE:
+		s_wcd.hbrEditBackground =  CreateSolidBrush( RGB( 0x00, 0x00, 0x00 ) );
+		s_wcd.hbrErrorBackground = CreateSolidBrush( RGB( 0x80, 0x80, 0x80 ) );
+		SetTimer( hWnd, 1, 1000, NULL );
+		break;
+	case WM_ERASEBKGND:
+	    return DefWindowProc( hWnd, uMsg, wParam, lParam );
+	case WM_TIMER:
+		if ( wParam == 1 )
+		{
+			s_timePolarity = (qboolean)!s_timePolarity;
+			if ( s_wcd.hwndErrorBox )
+			{
+				InvalidateRect( s_wcd.hwndErrorBox, NULL, FALSE );
+			}
+		}
+		break;
+    }
+
+    return DefWindowProc( hWnd, uMsg, wParam, lParam );
+}
+
+extern	void CompleteCommand( void ) ;
+
+LONG WINAPI InputLineWndProc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
+{
+	char inputBuffer[1024];
+
+	switch ( uMsg )
+	{
+		case WM_KILLFOCUS:
+			if ( ( HWND ) wParam == s_wcd.hWnd ||
+				 ( HWND ) wParam == s_wcd.hwndErrorBox )
+			{
+				SetFocus( hWnd );
+				return 0;
+			}
+			break;
+
+		case WM_CHAR:
+			if ( wParam == 13 )
+			{
+				GetWindowText( s_wcd.hwndInputLine, inputBuffer, sizeof( inputBuffer ) );
+				strncat( s_wcd.consoleText, inputBuffer, sizeof( s_wcd.consoleText ) - strlen( s_wcd.consoleText ) - 5 );
+				strcat( s_wcd.consoleText, "\n" );
+				SetWindowText( s_wcd.hwndInputLine, "" );
+
+				Sys_Print( va( "]%s\n", inputBuffer ) );
+
+				strcpy(kg.g_consoleField.buffer, inputBuffer);
+				kg.historyEditLines[kg.nextHistoryLine % COMMAND_HISTORY] = kg.g_consoleField;
+				kg.nextHistoryLine++;
+				kg.historyLine = kg.nextHistoryLine;
+
+				return 0;
+			}
+			else if (wParam == 9 )
+			{
+				GetWindowText( s_wcd.hwndInputLine, inputBuffer, sizeof( inputBuffer ) );
+				strcpy(kg.g_consoleField.buffer, inputBuffer);
+				CompleteCommand();
+				SetWindowText( s_wcd.hwndInputLine, kg.g_consoleField.buffer);
+				SendMessage(s_wcd.hwndInputLine, EM_SETSEL, strlen(kg.g_consoleField.buffer) , MAKELONG(0xffff, 0xffff) );
+			}
+
+		case WM_KEYDOWN:
+			if (wParam == VK_UP)
+			{
+				if ( kg.nextHistoryLine - kg.historyLine < COMMAND_HISTORY && kg.historyLine > 0 ) 
+				{
+					kg.historyLine--;
+				}
+				kg.g_consoleField = kg.historyEditLines[ kg.historyLine % COMMAND_HISTORY ];
+				SetWindowText( s_wcd.hwndInputLine, kg.g_consoleField.buffer);
+				SendMessage(s_wcd.hwndInputLine, EM_SETSEL, strlen(kg.g_consoleField.buffer) , MAKELONG(0xffff, 0xffff) );
+				return 0;
+			}
+			else if (wParam == VK_DOWN)
+			{
+				if (kg.historyLine == kg.nextHistoryLine)
+				{
+					return 0;
+				}
+				kg.historyLine++;
+				kg.g_consoleField = kg.historyEditLines[ kg.historyLine % COMMAND_HISTORY ];
+				SetWindowText( s_wcd.hwndInputLine, kg.g_consoleField.buffer);
+				SendMessage(s_wcd.hwndInputLine, EM_SETSEL, strlen(kg.g_consoleField.buffer) , MAKELONG(0xffff, 0xffff) );
+				return 0;
+			}
+			break;
+	}
+
+	return CallWindowProc( s_wcd.SysInputLineWndProc, hWnd, uMsg, wParam, lParam );
+}
+
+/*
+** Sys_CreateConsole
+*/
+void Sys_CreateConsole( void )
+{
+	HDC hDC;
+	WNDCLASS wc;
+	RECT rect;
+	const char *DEDCLASS = "JAMP WinConsole";
+	int nHeight;
+	int swidth, sheight;
+	int DEDSTYLE = WS_POPUPWINDOW | WS_CAPTION | WS_MINIMIZEBOX;
+
+	memset( &wc, 0, sizeof( wc ) );
+
+	wc.style         = 0;
+	wc.lpfnWndProc   = (WNDPROC) ConWndProc;
+	wc.cbClsExtra    = 0;
+	wc.cbWndExtra    = 0;
+	wc.hInstance     = g_wv.hInstance;
+	wc.hIcon         = LoadIcon( g_wv.hInstance, MAKEINTRESOURCE(IDI_ICON1));
+	wc.hCursor       = LoadCursor (NULL,IDC_ARROW);
+	wc.hbrBackground = (HBRUSH__ *)COLOR_INACTIVEBORDER;
+	wc.lpszMenuName  = 0;
+	wc.lpszClassName = DEDCLASS;
+
+	if ( !RegisterClass (&wc) )	{
+		return;
+	}
+
+	rect.left = 0;
+	rect.right = 600;
+	rect.top = 0;
+	rect.bottom = 450;
+	AdjustWindowRect( &rect, DEDSTYLE, FALSE );
+
+	hDC = GetDC( GetDesktopWindow() );
+	swidth = GetDeviceCaps( hDC, HORZRES );
+	sheight = GetDeviceCaps( hDC, VERTRES );
+	ReleaseDC( GetDesktopWindow(), hDC );
+
+	s_wcd.windowWidth = rect.right - rect.left + 1;
+	s_wcd.windowHeight = rect.bottom - rect.top + 1;
+
+	s_wcd.hWnd = CreateWindowEx( 0,
+							   DEDCLASS,
+							   "Jedi Knight Academy MP Console",
+							   DEDSTYLE,
+							   ( swidth - 600 ) / 2, ( sheight - 450 ) / 2 , rect.right - rect.left + 1, rect.bottom - rect.top + 1,
+							   NULL,
+							   NULL,
+							   g_wv.hInstance,
+							   NULL );
+
+	if ( s_wcd.hWnd == NULL )
+	{
+		return;
+	}
+
+	//
+	// create fonts
+	//
+	hDC = GetDC( s_wcd.hWnd );
+	nHeight = -MulDiv( 8, GetDeviceCaps( hDC, LOGPIXELSY), 72);
+
+	s_wcd.hfBufferFont = CreateFont( nHeight,
+									  0,
+									  0,
+									  0,
+									  FW_LIGHT,
+									  0,
+									  0,
+									  0,
+									  DEFAULT_CHARSET,
+									  OUT_DEFAULT_PRECIS,
+									  CLIP_DEFAULT_PRECIS,
+									  DEFAULT_QUALITY,
+									  FF_MODERN | FIXED_PITCH,
+									  "Courier New" );
+
+	ReleaseDC( s_wcd.hWnd, hDC );
+
+	//
+	// create the input line
+	//
+	s_wcd.hwndInputLine = CreateWindow( "edit", NULL, WS_CHILD | WS_VISIBLE | WS_BORDER | 
+												ES_LEFT | ES_AUTOHSCROLL | WS_TABSTOP,
+												6, 400, s_wcd.windowWidth-20, 20,
+												s_wcd.hWnd, 
+												( HMENU ) INPUT_ID,	// child window ID
+												g_wv.hInstance, NULL );
+
+	//
+	// create the buttons
+	//
+	s_wcd.hwndButtonCopy = CreateWindow( "button", NULL, BS_PUSHBUTTON | WS_VISIBLE | WS_CHILD | BS_DEFPUSHBUTTON | WS_TABSTOP,
+												5, 425, 72, 24,
+												s_wcd.hWnd, 
+												( HMENU ) COPY_ID,	// child window ID
+												g_wv.hInstance, NULL );
+	SendMessage( s_wcd.hwndButtonCopy, WM_SETTEXT, 0, ( LPARAM ) "Copy" );
+
+	s_wcd.hwndButtonClear = CreateWindow( "button", NULL, BS_PUSHBUTTON | WS_VISIBLE | WS_CHILD | BS_DEFPUSHBUTTON | WS_TABSTOP,
+												82, 425, 72, 24,
+												s_wcd.hWnd, 
+												( HMENU ) CLEAR_ID,	// child window ID
+												g_wv.hInstance, NULL );
+	SendMessage( s_wcd.hwndButtonClear, WM_SETTEXT, 0, ( LPARAM ) "Clear" );
+
+	s_wcd.hwndButtonQuit = CreateWindow( "button", NULL, BS_PUSHBUTTON | WS_VISIBLE | WS_CHILD | BS_DEFPUSHBUTTON | WS_TABSTOP,
+												s_wcd.windowWidth-92, 425, 72, 24,
+												s_wcd.hWnd, 
+												( HMENU ) QUIT_ID,	// child window ID
+												g_wv.hInstance, NULL );
+	SendMessage( s_wcd.hwndButtonQuit, WM_SETTEXT, 0, ( LPARAM ) "Quit" );
+
+
+	//
+	// create the scrollbuffer
+	//
+	s_wcd.hwndBuffer = CreateWindow( "edit", NULL, WS_CHILD | WS_VISIBLE | WS_VSCROLL | WS_BORDER | 
+												ES_LEFT | ES_MULTILINE | ES_AUTOVSCROLL | ES_READONLY | WS_TABSTOP,
+												6, 40, s_wcd.windowWidth-20, 354,
+												s_wcd.hWnd, 
+												( HMENU ) EDIT_ID,	// child window ID
+												g_wv.hInstance, NULL );
+	SendMessage( s_wcd.hwndBuffer, WM_SETFONT, ( WPARAM ) s_wcd.hfBufferFont, 0 );
+
+	s_wcd.SysInputLineWndProc = ( WNDPROC ) SetWindowLong( s_wcd.hwndInputLine, GWL_WNDPROC, ( long ) InputLineWndProc );
+	SendMessage( s_wcd.hwndInputLine, WM_SETFONT, ( WPARAM ) s_wcd.hfBufferFont, 0 );
+	SendMessage( s_wcd.hwndBuffer, EM_LIMITTEXT, ( WPARAM ) 0x7fff, 0 );
+
+	ShowWindow( s_wcd.hWnd, SW_SHOWDEFAULT);
+	UpdateWindow( s_wcd.hWnd );
+	SetForegroundWindow( s_wcd.hWnd );
+	SetFocus( s_wcd.hwndInputLine );
+
+	s_wcd.visLevel = 1;
+}
+
+/*
+** Sys_DestroyConsole
+*/
+void Sys_DestroyConsole( void ) 
+{
+	if ( s_wcd.hWnd ) 
+	{
+		DeleteObject(s_wcd.hbrEditBackground);
+		DeleteObject(s_wcd.hbrErrorBackground);
+		DeleteObject(s_wcd.hfBufferFont);
+
+		ShowWindow( s_wcd.hWnd, SW_HIDE );
+		CloseWindow( s_wcd.hWnd );
+		DestroyWindow( s_wcd.hWnd );
+		s_wcd.hWnd = 0;
+	}
+}
+
+/*
+** Sys_ShowConsole
+*/
+void Sys_ShowConsole( int visLevel, qboolean quitOnClose )
+{
+	s_wcd.quitOnClose = quitOnClose;
+
+	if ( visLevel == s_wcd.visLevel )
+	{
+		return;
+	}
+
+	s_wcd.visLevel = visLevel;
+
+	if ( !s_wcd.hWnd )
+	{
+		return;
+	}
+
+	switch ( visLevel )
+	{
+	case 0:
+		ShowWindow( s_wcd.hWnd, SW_HIDE );
+		break;
+	case 1:
+		ShowWindow( s_wcd.hWnd, SW_SHOWNORMAL );
+		SendMessage( s_wcd.hwndBuffer, EM_LINESCROLL, 0, 0xffff );
+		break;
+	case 2:
+		ShowWindow( s_wcd.hWnd, SW_MINIMIZE );
+		break;
+	default:
+		Sys_Error( "Invalid visLevel %d sent to Sys_ShowConsole\n", visLevel );
+		break;
+	}
+}
+
+/*
+** Sys_ConsoleInput
+*/
+char *Sys_ConsoleInput( void )
+{
+	if ( s_wcd.consoleText[0] == 0 )
+	{
+		return NULL;
+	}
+		
+	strcpy( s_wcd.returnedText, s_wcd.consoleText );
+	s_wcd.consoleText[0] = 0;
+	
+	return s_wcd.returnedText;
+}
+
+/*
+** Conbuf_AppendText
+*/
+void Conbuf_AppendText( const char *pMsg )
+{
+#define CONSOLE_BUFFER_SIZE		16384
+	if ( !s_wcd.hWnd ) {
+		return;
+	}
+	char buffer[CONSOLE_BUFFER_SIZE*4];
+	char *b = buffer;
+	const char *msg;
+	int bufLen;
+	int i = 0;
+	static unsigned long s_totalChars;
+
+	//
+	// if the message is REALLY long, use just the last portion of it
+	//
+	if ( strlen( pMsg ) > CONSOLE_BUFFER_SIZE - 1 )
+	{
+		msg = pMsg + strlen( pMsg ) - CONSOLE_BUFFER_SIZE + 1;
+	}
+	else
+	{
+		msg = pMsg;
+	}
+
+	//
+	// copy into an intermediate buffer
+	//
+	while ( msg[i] && ( ( b - buffer ) < sizeof( buffer ) - 1 ) )
+	{
+		if ( msg[i] == '\n' && msg[i+1] == '\r' )
+		{
+			b[0] = '\r';
+			b[1] = '\n';
+			b += 2;
+			i++;
+		}
+		else if ( msg[i] == '\r' )
+		{
+			b[0] = '\r';
+			b[1] = '\n';
+			b += 2;
+		}
+		else if ( msg[i] == '\n' )
+		{
+			b[0] = '\r';
+			b[1] = '\n';
+			b += 2;
+		}
+		else if ( Q_IsColorString( &msg[i] ) )
+		{
+			i++;
+		}
+		else
+		{
+			*b= msg[i];
+			b++;
+		}
+		i++;
+	}
+	*b = 0;
+	bufLen = b - buffer;
+
+	s_totalChars += bufLen;
+
+	//
+	// replace selection instead of appending if we're overflowing
+	//
+	if ( s_totalChars > 0x7fff )
+	{
+		SendMessage( s_wcd.hwndBuffer, EM_SETSEL, 0, -1 );
+		s_totalChars = bufLen;
+	}
+
+	//
+	// put this text into the windows console
+	//
+	SendMessage( s_wcd.hwndBuffer, EM_LINESCROLL, 0, 0xffff );
+	SendMessage( s_wcd.hwndBuffer, EM_SCROLLCARET, 0, 0 );
+	SendMessage( s_wcd.hwndBuffer, EM_REPLACESEL, 0, (LPARAM) buffer );
+}
+
+/*
+** Sys_SetErrorText
+*/
+void Sys_SetErrorText( const char *buf )
+{
+	Q_strncpyz( s_wcd.errorString, buf, sizeof( s_wcd.errorString ) );
+
+	if ( !s_wcd.hwndErrorBox )
+	{
+		s_wcd.hwndErrorBox = CreateWindow( "static", NULL, WS_CHILD | WS_VISIBLE | SS_SUNKEN,
+													6, 5, s_wcd.windowWidth-20, 30,
+													s_wcd.hWnd, 
+													( HMENU ) ERRORBOX_ID,	// child window ID
+													g_wv.hInstance, NULL );
+		SendMessage( s_wcd.hwndErrorBox, WM_SETFONT, ( WPARAM ) s_wcd.hfBufferFont, 0 );
+		SetWindowText( s_wcd.hwndErrorBox, s_wcd.errorString );
+
+		DestroyWindow( s_wcd.hwndInputLine );
+		s_wcd.hwndInputLine = NULL;
+	}
+}
diff --git a/codemp/win32/win_wndproc.cpp b/codemp/win32/win_wndproc.cpp
new file mode 100644
index 0000000..c739be1
--- /dev/null
+++ b/codemp/win32/win_wndproc.cpp
@@ -0,0 +1,547 @@
+//Anything above this #include will be ignored by the compiler
+#include "../qcommon/exe_headers.h"
+
+#include "../client/client.h"
+#include "win_local.h"
+
+WinVars_t	g_wv;
+
+// The only directly referenced keycode - the console key (which gives different ascii codes depending on locale)
+#define CONSOLE_SCAN_CODE	0x29
+
+#ifndef WM_MOUSEWHEEL
+#define WM_MOUSEWHEEL (WM_MOUSELAST+1)  // message that will be supported by the OS 
+#endif
+
+static UINT MSH_MOUSEWHEEL;
+
+// Console variables that we need to access from this module
+cvar_t		*vid_xpos;			// X coordinate of window position
+cvar_t		*vid_ypos;			// Y coordinate of window position
+static cvar_t		*r_fullscreen;
+
+#define VID_NUM_MODES ( sizeof( vid_modes ) / sizeof( vid_modes[0] ) )
+
+LONG WINAPI MainWndProc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam );
+
+static qboolean s_alttab_disabled;
+
+static void WIN_DisableAltTab( void )
+{
+	if ( s_alttab_disabled )
+		return;
+
+	if ( !Q_stricmp( Cvar_VariableString( "arch" ), "winnt" ) )
+	{
+		RegisterHotKey( 0, 0, MOD_ALT, VK_TAB );
+	}
+	else
+	{
+		BOOL old;
+
+		SystemParametersInfo( SPI_SCREENSAVERRUNNING, 1, &old, 0 );
+	}
+	s_alttab_disabled = qtrue;
+}
+
+static void WIN_EnableAltTab( void )
+{
+	if ( s_alttab_disabled )
+	{
+		if ( !Q_stricmp( Cvar_VariableString( "arch" ), "winnt" ) )
+		{
+			UnregisterHotKey( 0, 0 );
+		}
+		else
+		{
+			BOOL old;
+
+			SystemParametersInfo( SPI_SCREENSAVERRUNNING, 0, &old, 0 );
+		}
+
+		s_alttab_disabled = qfalse;
+	}
+}
+
+/*
+==================
+VID_AppActivate
+==================
+*/
+static void VID_AppActivate(BOOL fActive, BOOL minimize)
+{
+	g_wv.isMinimized = (qboolean)minimize;
+
+	Com_DPrintf("VID_AppActivate: %i\n", fActive );
+
+	Key_ClearStates();	// FIXME!!!
+
+	// we don't want to act like we're active if we're minimized
+	if (fActive && !g_wv.isMinimized )
+	{
+		g_wv.activeApp = qtrue;
+	}
+	else
+	{
+		g_wv.activeApp = qfalse;
+	}
+
+	// minimize/restore mouse-capture on demand
+	if (!g_wv.activeApp )
+	{
+		IN_Activate (qfalse);
+	}
+	else
+	{
+		IN_Activate (qtrue);
+	}
+}
+
+//==========================================================================
+
+
+static byte virtualKeyConvert[0x92][2] =
+{
+	{ 0,				0				},     
+	{ A_MOUSE1,			A_MOUSE1		}, // VK_LBUTTON 01 Left mouse button  
+	{ A_MOUSE2,			A_MOUSE2		}, // VK_RBUTTON 02 Right mouse button  
+	{ 0,				0				}, // VK_CANCEL 03 Control-break processing  
+	{ A_MOUSE3,			A_MOUSE3		}, // VK_MBUTTON 04 Middle mouse button (three-button mouse)  
+	{ A_MOUSE4,			A_MOUSE4		}, // VK_XBUTTON1 05 Windows 2000/XP: X1 mouse button 
+	{ A_MOUSE5,			A_MOUSE5		}, // VK_XBUTTON2 06 Windows 2000/XP: X2 mouse button 
+	{ 0,				0				}, // 07 Undefined  
+	{ A_BACKSPACE,		A_BACKSPACE		}, // VK_BACK 08 BACKSPACE key  
+	{ A_TAB,			A_TAB			}, // VK_TAB 09 TAB key  
+	{ 0,				0				}, // 0A Reserved  
+	{ 0,				0				}, // 0B Reserved  
+	{ A_KP_5,			0				}, // VK_CLEAR 0C CLEAR key  
+	{ A_ENTER, 			A_KP_ENTER 		}, // VK_RETURN 0D ENTER key  
+	{ 0,				0				}, // 0E Undefined  
+	{ 0,				0				}, // 0F Undefined  
+	{ A_SHIFT,			A_SHIFT			}, // VK_SHIFT 10 SHIFT key  
+	{ A_CTRL,			A_CTRL			}, // VK_CONTROL 11 CTRL key  
+	{ A_ALT,			A_ALT			}, // VK_MENU 12 ALT key  
+	{ A_PAUSE,			A_PAUSE			}, // VK_PAUSE 13 PAUSE key  
+	{ A_CAPSLOCK,		A_CAPSLOCK		}, // VK_CAPITAL 14 CAPS LOCK key  
+	{ 0,				0				}, // VK_KANA 15 IME Kana mode 
+	{ 0,				0				}, // 16 Undefined  
+	{ 0,				0				}, // VK_JUNJA 17 IME Junja mode 
+	{ 0,				0				}, // VK_FINAL 18 IME final mode 
+	{ 0,				0				}, // VK_KANJI 19 IME Kanji mode 
+	{ 0,				0				}, // 1A Undefined  
+	{ A_ESCAPE,			A_ESCAPE		}, // VK_ESCAPE 1B ESC key  
+	{ 0,				0				}, // VK_CONVERT 1C IME convert 
+	{ 0,				0				}, // VK_NONCONVERT 1D IME nonconvert 
+	{ 0,				0				}, // VK_ACCEPT 1E IME accept 
+	{ 0,				0				}, // VK_MODECHANGE 1F IME mode change request 
+	{ A_SPACE,			A_SPACE			}, // VK_SPACE 20 SPACEBAR  
+	{ A_KP_9,			A_PAGE_UP		}, // VK_PRIOR 21 PAGE UP key  
+	{ A_KP_3,			A_PAGE_DOWN		}, // VK_NEXT 22 PAGE DOWN key  
+	{ A_KP_1,			A_END			}, // VK_END 23 END key  
+	{ A_KP_7,			A_HOME			}, // VK_HOME 24 HOME key  
+	{ A_KP_4,			A_CURSOR_LEFT	}, // VK_LEFT 25 LEFT ARROW key  
+	{ A_KP_8,			A_CURSOR_UP   	}, // VK_UP 26 UP ARROW key  
+	{ A_KP_6,			A_CURSOR_RIGHT	}, // VK_RIGHT 27 RIGHT ARROW key  
+	{ A_KP_2,			A_CURSOR_DOWN	}, // VK_DOWN 28 DOWN ARROW key  
+	{ 0,				0				}, // VK_SELECT 29 SELECT key  
+	{ 0,				0				}, // VK_PRINT 2A PRINT key 
+	{ 0,				0				}, // VK_EXECUTE 2B EXECUTE key  
+	{ A_PRINTSCREEN,	A_PRINTSCREEN	}, // VK_SNAPSHOT 2C PRINT SCREEN key  
+	{ A_KP_0,			A_INSERT		}, // VK_INSERT 2D INS key  
+	{ A_KP_PERIOD,		A_DELETE		}, // VK_DELETE 2E DEL key  
+	{ 0,				0				}, // VK_HELP 2F HELP key  
+	{ A_0,				A_0				}, // 30 0 key  
+	{ A_1,				A_1				}, // 31 1 key  
+	{ A_2,				A_2				}, // 32 2 key  
+	{ A_3,				A_3				}, // 33 3 key  
+	{ A_4,				A_4				}, // 34 4 key  
+	{ A_5,				A_5				}, // 35 5 key  
+	{ A_6,				A_6				}, // 36 6 key  
+	{ A_7,				A_7				}, // 37 7 key  
+	{ A_8,				A_8				}, // 38 8 key  
+	{ A_9,				A_9				}, // 39 9 key  
+	{ 0,				0				}, // 3A Undefined  
+	{ 0,				0				}, // 3B Undefined  
+	{ 0,				0				}, // 3C Undefined  
+	{ 0,				0				}, // 3D Undefined  
+	{ 0,				0				}, // 3E Undefined  
+	{ 0,				0				}, // 3F Undefined  
+	{ 0,				0				}, // 40 Undefined  
+	{ A_CAP_A,			A_CAP_A			}, // 41 A key  
+	{ A_CAP_B,			A_CAP_B			}, // 42 B key  
+	{ A_CAP_C,			A_CAP_C			}, // 43 C key  
+	{ A_CAP_D,			A_CAP_D			}, // 44 D key  
+	{ A_CAP_E,			A_CAP_E			}, // 45 E key  
+	{ A_CAP_F,			A_CAP_F			}, // 46 F key  
+	{ A_CAP_G,			A_CAP_G			}, // 47 G key  
+	{ A_CAP_H,			A_CAP_H			}, // 48 H key  
+	{ A_CAP_I,			A_CAP_I			}, // 49 I key  
+	{ A_CAP_J,			A_CAP_J			}, // 4A J key  
+	{ A_CAP_K,			A_CAP_K			}, // 4B K key  
+	{ A_CAP_L,			A_CAP_L			}, // 4C L key  
+	{ A_CAP_M,			A_CAP_M			}, // 4D M key  
+	{ A_CAP_N,			A_CAP_N			}, // 4E N key  
+	{ A_CAP_O,			A_CAP_O			}, // 4F O key  
+	{ A_CAP_P,			A_CAP_P			}, // 50 P key  
+	{ A_CAP_Q,			A_CAP_Q			}, // 51 Q key  
+	{ A_CAP_R,			A_CAP_R			}, // 52 R key  
+	{ A_CAP_S,			A_CAP_S			}, // 53 S key  
+	{ A_CAP_T,			A_CAP_T			}, // 54 T key  
+	{ A_CAP_U,			A_CAP_U			}, // 55 U key  
+	{ A_CAP_V,			A_CAP_V			}, // 56 V key  
+	{ A_CAP_W,			A_CAP_W			}, // 57 W key  
+	{ A_CAP_X,			A_CAP_X			}, // 58 X key  
+	{ A_CAP_Y,			A_CAP_Y			}, // 59 Y key  
+	{ A_CAP_Z,			A_CAP_Z			}, // 5A Z key  
+	{ 0,				0				}, // VK_LWIN 5B Left Windows key (Microsoft® Natural® keyboard)  
+	{ 0,				0				}, // VK_RWIN 5C Right Windows key (Natural keyboard)  
+	{ 0,				0				}, // VK_APPS 5D Applications key (Natural keyboard)  
+	{ 0,				0				}, // 5E Reserved  
+	{ 0,				0				}, // VK_SLEEP 5F Computer Sleep key 
+	{ A_KP_0,			A_KP_0			}, // VK_NUMPAD0 60 Numeric keypad 0 key  
+	{ A_KP_1,			A_KP_1			}, // VK_NUMPAD1 61 Numeric keypad 1 key  
+	{ A_KP_2,			A_KP_2			}, // VK_NUMPAD2 62 Numeric keypad 2 key  
+	{ A_KP_3,			A_KP_3			}, // VK_NUMPAD3 63 Numeric keypad 3 key  
+	{ A_KP_4,			A_KP_4			}, // VK_NUMPAD4 64 Numeric keypad 4 key  
+	{ A_KP_5,			A_KP_5			}, // VK_NUMPAD5 65 Numeric keypad 5 key  
+	{ A_KP_6,			A_KP_6			}, // VK_NUMPAD6 66 Numeric keypad 6 key  
+	{ A_KP_7,			A_KP_7			}, // VK_NUMPAD7 67 Numeric keypad 7 key  
+	{ A_KP_8,			A_KP_8			}, // VK_NUMPAD8 68 Numeric keypad 8 key  
+	{ A_KP_9,			A_KP_9			}, // VK_NUMPAD9 69 Numeric keypad 9 key  
+	{ A_MULTIPLY,		A_MULTIPLY		}, // VK_MULTIPLY 6A Multiply key  
+	{ A_KP_PLUS, 		A_KP_PLUS 		}, // VK_ADD 6B Add key  
+	{ 0,				0				}, // VK_SEPARATOR 6C Separator key  
+	{ A_KP_MINUS,		A_KP_MINUS		}, // VK_SUBTRACT 6D Subtract key  
+	{ A_KP_PERIOD,		A_KP_PERIOD		}, // VK_DECIMAL 6E Decimal key  
+	{ A_DIVIDE,			A_DIVIDE		}, // VK_DIVIDE 6F Divide key  
+	{ A_F1,				A_F1			}, // VK_F1 70 F1 key  
+	{ A_F2,				A_F2			}, // VK_F2 71 F2 key  
+	{ A_F3,				A_F3			}, // VK_F3 72 F3 key  
+	{ A_F4,				A_F4			}, // VK_F4 73 F4 key  
+	{ A_F5,				A_F5			}, // VK_F5 74 F5 key  
+	{ A_F6,				A_F6			}, // VK_F6 75 F6 key  
+	{ A_F7,				A_F7			}, // VK_F7 76 F7 key  
+	{ A_F8,				A_F8			}, // VK_F8 77 F8 key  
+	{ A_F9,				A_F9			}, // VK_F9 78 F9 key  
+	{ A_F10,			A_F10			}, // VK_F10 79 F10 key  
+	{ A_F11,			A_F11			}, // VK_F11 7A F11 key  
+	{ A_F12,			A_F12			}, // VK_F12 7B F12 key  
+	{ 0,				0				}, // VK_F13 7C F13 key  
+	{ 0,				0				}, // VK_F14 7D F14 key  
+	{ 0,				0				}, // VK_F15 7E F15 key  
+	{ 0,				0				}, // VK_F16 7F F16 key  
+	{ 0,				0				}, // VK_F17 80H F17 key  
+	{ 0,				0				}, // VK_F18 81H F18 key  
+	{ 0,				0				}, // VK_F19 82H F19 key  
+	{ 0,				0				}, // VK_F20 83H F20 key  
+	{ 0,				0				}, // VK_F21 84H F21 key  
+	{ 0,				0				}, // VK_F22 85H F22 key  
+	{ 0,				0				}, // VK_F23 86H F23 key  
+	{ 0,				0				}, // VK_F24 87H F24 key  
+	{ 0,				0				}, // 88 Unassigned
+	{ 0,				0				}, // 89 Unassigned
+	{ 0,				0				}, // 8A Unassigned
+	{ 0,				0				}, // 8B Unassigned
+	{ 0,				0				}, // 8C Unassigned
+	{ 0,				0				}, // 8D Unassigned
+	{ 0,				0				}, // 8E Unassigned
+	{ 0,				0				}, // 8F Unassigned
+	{ A_NUMLOCK,		A_NUMLOCK		}, // VK_NUMLOCK 90 NUM LOCK key  
+	{ A_SCROLLLOCK,		A_SCROLLLOCK	}  // VK_SCROLL 91 
+};
+
+/*
+=======
+MapKey
+
+Map from windows to quake keynums
+=======
+*/
+static int MapKey (ulong key, word wParam)
+{
+	ulong	result, scan, extended;
+
+	// Check for the console key (hard code to the key you would expect)
+	scan = ( key >> 16 ) & 0xff;
+	if(scan == CONSOLE_SCAN_CODE)
+	{
+		return(A_CONSOLE);
+	}
+
+	// Try to convert the virtual key directly
+	result = 0;
+	extended = (key >> 24) & 1;
+	if(wParam > 0 && wParam <= VK_SCROLL)
+	{
+		// yeuch, but oh well...
+		//
+		if ( wParam >= VK_NUMPAD0 && wParam <= VK_NUMPAD9 )
+		{
+			bool bNumlockOn = !!(GetKeyState( VK_NUMLOCK ) & 1);
+			if ( bNumlockOn )
+			{
+				wParam = 0x30 + (wParam - VK_NUMPAD0);	// convert to standard 0..9
+			}
+		}
+		result = virtualKeyConvert[wParam][extended];
+	}
+	// Get the unshifted ascii code (if any)
+	if(!result)
+	{
+		result = MapVirtualKey(wParam, 2) & 0xff;
+	}
+	// Output any debug prints
+//	if(in_debug && in_debug->integer & 1)
+//	{
+//		Com_Printf("WM_KEY: %x : %x : %x\n", key, wParam, result);
+//	}
+	return(result);
+}
+
+
+/*
+====================
+MainWndProc
+
+main window procedure
+====================
+*/
+
+#define WM_BUTTON4DOWN	(WM_MOUSELAST+2)
+#define WM_BUTTON4UP	(WM_MOUSELAST+3)
+#define MK_BUTTON4L		0x0020
+#define MK_BUTTON4R		0x0040
+
+LONG WINAPI MainWndProc (
+    HWND    hWnd,
+    UINT    uMsg,
+    WPARAM  wParam,
+    LPARAM  lParam)
+{
+	byte code;
+
+	if ( uMsg == MSH_MOUSEWHEEL )
+	{
+		if ( ( ( int ) wParam ) > 0 )
+		{
+			Sys_QueEvent( g_wv.sysMsgTime, SE_KEY, A_MWHEELUP, qtrue, 0, NULL );
+			Sys_QueEvent( g_wv.sysMsgTime, SE_KEY, A_MWHEELUP, qfalse, 0, NULL );
+		}
+		else
+		{
+			Sys_QueEvent( g_wv.sysMsgTime, SE_KEY, A_MWHEELDOWN, qtrue, 0, NULL );
+			Sys_QueEvent( g_wv.sysMsgTime, SE_KEY, A_MWHEELDOWN, qfalse, 0, NULL );
+		}
+        return DefWindowProc (hWnd, uMsg, wParam, lParam);
+	}
+
+	switch (uMsg)
+	{
+	case WM_MOUSEWHEEL:
+		//
+		//
+		// this chunk of code theoretically only works under NT4 and Win98
+		// since this message doesn't exist under Win95
+		//
+		if ( ( short ) HIWORD( wParam ) > 0 )
+		{
+			Sys_QueEvent( g_wv.sysMsgTime, SE_KEY, A_MWHEELUP, qtrue, 0, NULL );
+			Sys_QueEvent( g_wv.sysMsgTime, SE_KEY, A_MWHEELUP, qfalse, 0, NULL );
+		}
+		else
+		{
+			Sys_QueEvent( g_wv.sysMsgTime, SE_KEY, A_MWHEELDOWN, qtrue, 0, NULL );
+			Sys_QueEvent( g_wv.sysMsgTime, SE_KEY, A_MWHEELDOWN, qfalse, 0, NULL );
+		}
+		break;
+
+	case WM_CREATE:
+
+		g_wv.hWnd = hWnd;
+
+		vid_xpos = Cvar_Get ("vid_xpos", "3", CVAR_ARCHIVE);
+		vid_ypos = Cvar_Get ("vid_ypos", "22", CVAR_ARCHIVE);
+		r_fullscreen = Cvar_Get ("r_fullscreen", "1", CVAR_ARCHIVE | CVAR_LATCH );
+
+		MSH_MOUSEWHEEL = RegisterWindowMessage("MSWHEEL_ROLLMSG"); 
+		if ( r_fullscreen->integer )
+		{
+			WIN_DisableAltTab();
+		}
+		else
+		{
+			WIN_EnableAltTab();
+		}
+
+		break;
+#if 0
+	case WM_DISPLAYCHANGE:
+		Com_DPrintf( "WM_DISPLAYCHANGE\n" );
+		// we need to force a vid_restart if the user has changed
+		// their desktop resolution while the game is running,
+		// but don't do anything if the message is a result of
+		// our own calling of ChangeDisplaySettings
+		if ( com_insideVidInit ) {
+			break;		// we did this on purpose
+		}
+		// something else forced a mode change, so restart all our gl stuff
+		Cbuf_AddText( "vid_restart\n" );
+		break;
+#endif
+	case WM_DESTROY:
+		// let sound and input know about this?
+		g_wv.hWnd = NULL;
+		if ( r_fullscreen->integer )
+		{
+			WIN_EnableAltTab();
+		}
+		break;
+
+	case WM_CLOSE:
+		Cbuf_ExecuteText( EXEC_APPEND, "quit" );
+		break;
+
+	case WM_ACTIVATE:
+		{
+			int	fActive, fMinimized;
+
+			fActive = LOWORD(wParam);
+			fMinimized = (BOOL) HIWORD(wParam);
+
+			VID_AppActivate( fActive != WA_INACTIVE, fMinimized);
+			SNDDMA_Activate( (qboolean)(fActive != WA_INACTIVE && !fMinimized) );
+		}
+		break;
+
+	case WM_MOVE:
+		{
+			int		xPos, yPos;
+			RECT r;
+			int		style;
+
+			if (!r_fullscreen->integer )
+			{
+				xPos = (short) LOWORD(lParam);    // horizontal position 
+				yPos = (short) HIWORD(lParam);    // vertical position 
+
+				r.left   = 0;
+				r.top    = 0;
+				r.right  = 1;
+				r.bottom = 1;
+
+				style = GetWindowLong( hWnd, GWL_STYLE );
+				AdjustWindowRect( &r, style, FALSE );
+
+				Cvar_SetValue( "vid_xpos", xPos + r.left);
+				Cvar_SetValue( "vid_ypos", yPos + r.top);
+				vid_xpos->modified = qfalse;
+				vid_ypos->modified = qfalse;
+				if ( g_wv.activeApp )
+				{
+					IN_Activate (qtrue);
+				}
+			}
+		}
+		break;
+
+// this is complicated because Win32 seems to pack multiple mouse events into
+// one update sometimes, so we always check all states and look for events
+	case WM_LBUTTONDOWN:
+	case WM_LBUTTONUP:
+	case WM_RBUTTONDOWN:
+	case WM_RBUTTONUP:
+	case WM_MBUTTONDOWN:
+	case WM_MBUTTONUP:
+	case WM_MOUSEMOVE:
+	case WM_BUTTON4DOWN:
+	case WM_BUTTON4UP:
+		{
+			int	temp;
+
+			temp = 0;
+
+			if (wParam & MK_LBUTTON)
+				temp |= 1;
+
+			if (wParam & MK_RBUTTON)
+				temp |= 2;
+
+			if (wParam & MK_MBUTTON)
+				temp |= 4;
+
+		 	if (wParam & MK_BUTTON4L)
+				temp |= 8;
+
+			if (wParam & MK_BUTTON4R)
+				temp |= 16;
+
+			IN_MouseEvent (temp);
+		}
+		break;
+
+	case WM_SYSCOMMAND:
+		if ( (wParam&0xFFF0) == SC_SCREENSAVE || (wParam&0xFFF0) == SC_MONITORPOWER)
+		{
+			return 0;
+		}
+		break;
+
+	case WM_SYSKEYDOWN:
+		if ( wParam == VK_RETURN )
+		{
+			if ( r_fullscreen && cl_allowAltEnter &&
+				(cls.state==CA_DISCONNECTED ||  cls.state==CA_CONNECTED)
+				)
+			{
+				if (cl_allowAltEnter->integer)
+				{
+					Cvar_SetValue( "r_fullscreen", !r_fullscreen->integer );
+					Cbuf_AddText( "vid_restart\n" );
+				}
+			}
+			return 0;
+		}
+		// fall through
+	case WM_KEYDOWN:
+		code = MapKey( lParam, wParam );
+		if(code)
+		{
+			Sys_QueEvent( g_wv.sysMsgTime, SE_KEY, code, qtrue, 0, NULL );
+		}
+		break;
+
+	case WM_SYSKEYUP:
+	case WM_KEYUP:
+		code = MapKey( lParam, wParam );
+		if(code)
+		{
+			Sys_QueEvent( g_wv.sysMsgTime, SE_KEY, code, qfalse, 0, NULL );
+		}
+		break;
+
+	case WM_CHAR:
+		if(((lParam >> 16) & 0xff) != CONSOLE_SCAN_CODE)
+		{
+			Sys_QueEvent( g_wv.sysMsgTime, SE_CHAR, wParam, 0, 0, NULL );
+		}
+		// Output any debug prints
+//		if(in_debug && in_debug->integer & 2)
+//		{
+//			Com_Printf("WM_CHAR: %x\n", wParam);
+//		}
+		break;
+
+	case WM_POWERBROADCAST:
+		if (wParam == PBT_APMQUERYSUSPEND)
+		{
+#ifndef FINAL_BUILD
+			Com_Printf("Cannot go into hibernate / standby mode while game is running!\n");
+#endif
+			return BROADCAST_QUERY_DENY;
+		}
+		break;
+   }
+
+    return DefWindowProc( hWnd, uMsg, wParam, lParam );
+}
+
diff --git a/codemp/win32/winquake.rc b/codemp/win32/winquake.rc
new file mode 100644
index 0000000..87ebafb
--- /dev/null
+++ b/codemp/win32/winquake.rc
@@ -0,0 +1,101 @@
+// Microsoft Visual C++ generated resource script.
+//
+#include "resource.h"
+
+#define APSTUDIO_READONLY_SYMBOLS
+/////////////////////////////////////////////////////////////////////////////
+//
+// Generated from the TEXTINCLUDE 2 resource.
+//
+#include "winres.h"
+
+/////////////////////////////////////////////////////////////////////////////
+#undef APSTUDIO_READONLY_SYMBOLS
+
+/////////////////////////////////////////////////////////////////////////////
+// English (U.S.) resources
+
+#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU)
+#ifdef _WIN32
+LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US
+#pragma code_page(1252)
+#endif //_WIN32
+
+#ifdef APSTUDIO_INVOKED
+/////////////////////////////////////////////////////////////////////////////
+//
+// TEXTINCLUDE
+//
+
+1 TEXTINCLUDE 
+BEGIN
+    "resource.h\0"
+END
+
+2 TEXTINCLUDE 
+BEGIN
+    "#include ""winres.h""\r\n"
+    "\0"
+END
+
+3 TEXTINCLUDE 
+BEGIN
+    "\0"
+END
+
+#endif    // APSTUDIO_INVOKED
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// Icon
+//
+
+// Icon with lowest ID value placed first to ensure application icon
+// remains consistent on all systems.
+IDI_ICON1               ICON                    "qe3.ico"
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// Version
+//
+#include "AutoVersion.h"
+
+VS_VERSION_INFO VERSIONINFO
+ FILEVERSION VERSION_MAJOR_RELEASE,VERSION_MINOR_RELEASE,VERSION_EXTERNAL_BUILD,VERSION_INTERNAL_BUILD
+ PRODUCTVERSION VERSION_MAJOR_RELEASE,VERSION_MINOR_RELEASE,VERSION_EXTERNAL_BUILD,VERSION_INTERNAL_BUILD
+ FILEFLAGSMASK 0x17L
+#ifdef _DEBUG
+ FILEFLAGS 0x1L
+#else
+ FILEFLAGS 0x0L
+#endif
+ FILEOS 0x4L
+ FILETYPE 0x0L
+ FILESUBTYPE 0x0L
+BEGIN
+    BLOCK "StringFileInfo"
+    BEGIN
+        BLOCK "040904b0"
+        BEGIN
+            VALUE "Comments", "Raven Software"
+            VALUE "CompanyName", "Activision Inc"
+            VALUE "FileDescription", "Jedi Academy MultiPlayer"
+            VALUE "FileVersion", VERSION_STRING
+            VALUE "InternalName", "JA MP"
+            VALUE "LegalCopyright", "Copyright (C) 2003"
+            VALUE "OriginalFilename", "jamp.exe"
+            VALUE "ProductName", "Jedi Knight®: Jedi Academy (MP)"
+            VALUE "ProductVersion", VERSION_STRING
+        END
+    END
+    BLOCK "VarFileInfo"
+    BEGIN
+        VALUE "Translation", 0x409, 1200
+    END
+END
+
+#endif    // English (U.S.) resources
+/////////////////////////////////////////////////////////////////////////////
+
+
diff --git a/codemp/x_botlib/mssccprj.scc b/codemp/x_botlib/mssccprj.scc
new file mode 100644
index 0000000..e91b3f3
--- /dev/null
+++ b/codemp/x_botlib/mssccprj.scc
@@ -0,0 +1,5 @@
+SCC = This is a Source Code Control file
+
+[x_botlib.vcproj]
+SCC_Aux_Path = "\\ravendata1\vss\central_code"
+SCC_Project_Name = "$/jedi/codemp/x_botlib", SUHAAAAA
diff --git a/codemp/x_botlib/vssver.scc b/codemp/x_botlib/vssver.scc
new file mode 100644
index 0000000..e36998b
Binary files /dev/null and b/codemp/x_botlib/vssver.scc differ
diff --git a/codemp/x_botlib/x_botlib.vcproj b/codemp/x_botlib/x_botlib.vcproj
new file mode 100644
index 0000000..89a7062
--- /dev/null
+++ b/codemp/x_botlib/x_botlib.vcproj
@@ -0,0 +1,470 @@
+<?xml version="1.0" encoding = "Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="7.00"
+	Name="x_botlib"
+	ProjectGUID="{ACB93D0D-F6CB-480B-9B20-CE6C5EDC13BD}"
+	Keyword="XboxProj">
+	<Platforms>
+		<Platform
+			Name="Xbox"/>
+	</Platforms>
+	<Configurations>
+		<Configuration
+			Name="Debug|Xbox"
+			OutputDirectory=".\..\x_exe\Debug"
+			IntermediateDirectory=".\..\x_exe\Debug\botlib"
+			ConfigurationType="4"
+			CharacterSet="2">
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				OptimizeForProcessor="2"
+				AdditionalIncludeDirectories="../game"
+				PreprocessorDefinitions="_DEBUG,DEBUG,WIN32,_LIB,BOTLIB,_JK2;_XBOX"
+				MinimalRebuild="TRUE"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="1"
+				UsePrecompiledHeader="0"
+				PrecompiledHeaderFile="$(OutDir)/$(ProjectName).pch"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="FALSE"
+				DebugInformationFormat="4"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLibrarianTool"
+				OutputFile="$(OutDir)/$(ProjectName).lib"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+		</Configuration>
+		<Configuration
+			Name="Release|Xbox"
+			OutputDirectory=".\..\x_exe\Release"
+			IntermediateDirectory=".\..\x_exe\Release\botlib"
+			ConfigurationType="4"
+			CharacterSet="2">
+			<Tool
+				Name="VCCLCompilerTool"
+				AdditionalOptions="/Oy-"
+				Optimization="2"
+				InlineFunctionExpansion="1"
+				OmitFramePointers="FALSE"
+				OptimizeForProcessor="2"
+				AdditionalIncludeDirectories="../game"
+				PreprocessorDefinitions="NDEBUG;WIN32;_LIB;BOTLIB;_JK2;_XBOX"
+				StringPooling="TRUE"
+				RuntimeLibrary="0"
+				BufferSecurityCheck="TRUE"
+				EnableFunctionLevelLinking="TRUE"
+				UsePrecompiledHeader="3"
+				PrecompiledHeaderFile="$(OutDir)/$(ProjectName).pch"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="FALSE"
+				DebugInformationFormat="3"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLibrarianTool"
+				OutputFile="$(OutDir)/$(ProjectName).lib"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+		</Configuration>
+	</Configurations>
+	<Files>
+		<Filter
+			Name="Source Files">
+			<File
+				RelativePath="..\botlib\be_aas_bspq3.cpp">
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\botlib\be_aas_cluster.cpp">
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\botlib\be_aas_debug.cpp">
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\botlib\be_aas_entity.cpp">
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\botlib\be_aas_file.cpp">
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\botlib\be_aas_main.cpp">
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\botlib\be_aas_move.cpp">
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\botlib\be_aas_optimize.cpp">
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\botlib\be_aas_reach.cpp">
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\botlib\be_aas_route.cpp">
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\botlib\be_aas_routealt.cpp">
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\botlib\be_aas_sample.cpp">
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\botlib\be_ai_char.cpp">
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\botlib\be_ai_chat.cpp">
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\botlib\be_ai_gen.cpp">
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\botlib\be_ai_goal.cpp">
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\botlib\be_ai_move.cpp">
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\botlib\be_ai_weap.cpp">
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\botlib\be_ai_weight.cpp">
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\botlib\be_ea.cpp">
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\botlib\be_interface.cpp">
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\botlib\l_crc.cpp">
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\botlib\l_libvar.cpp">
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\botlib\l_log.cpp">
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\botlib\l_memory.cpp">
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\botlib\l_precomp.cpp">
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\botlib\l_script.cpp">
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\botlib\l_struct.cpp">
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"/>
+				</FileConfiguration>
+			</File>
+		</Filter>
+		<Filter
+			Name="Header Files">
+			<File
+				RelativePath="..\botlib\aasfile.h">
+			</File>
+			<File
+				RelativePath="..\game\be_aas.h">
+			</File>
+			<File
+				RelativePath="..\botlib\be_aas_bsp.h">
+			</File>
+			<File
+				RelativePath="..\botlib\be_aas_cluster.h">
+			</File>
+			<File
+				RelativePath="..\botlib\be_aas_debug.h">
+			</File>
+			<File
+				RelativePath="..\botlib\be_aas_def.h">
+			</File>
+			<File
+				RelativePath="..\botlib\be_aas_entity.h">
+			</File>
+			<File
+				RelativePath="..\botlib\be_aas_file.h">
+			</File>
+			<File
+				RelativePath="..\botlib\be_aas_funcs.h">
+			</File>
+			<File
+				RelativePath="..\botlib\be_aas_main.h">
+			</File>
+			<File
+				RelativePath="..\botlib\be_aas_move.h">
+			</File>
+			<File
+				RelativePath="..\botlib\be_aas_optimize.h">
+			</File>
+			<File
+				RelativePath="..\botlib\be_aas_reach.h">
+			</File>
+			<File
+				RelativePath="..\botlib\be_aas_route.h">
+			</File>
+			<File
+				RelativePath="..\botlib\be_aas_routealt.h">
+			</File>
+			<File
+				RelativePath="..\botlib\be_aas_sample.h">
+			</File>
+			<File
+				RelativePath="..\game\be_ai_char.h">
+			</File>
+			<File
+				RelativePath="..\game\be_ai_chat.h">
+			</File>
+			<File
+				RelativePath="..\game\be_ai_gen.h">
+			</File>
+			<File
+				RelativePath="..\game\be_ai_goal.h">
+			</File>
+			<File
+				RelativePath="..\game\be_ai_move.h">
+			</File>
+			<File
+				RelativePath="..\game\be_ai_weap.h">
+			</File>
+			<File
+				RelativePath="..\botlib\be_ai_weight.h">
+			</File>
+			<File
+				RelativePath="..\game\be_ea.h">
+			</File>
+			<File
+				RelativePath="..\botlib\be_interface.h">
+			</File>
+			<File
+				RelativePath="..\game\botlib.h">
+			</File>
+			<File
+				RelativePath="..\qcommon\cm_public.h">
+			</File>
+			<File
+				RelativePath="..\qcommon\disablewarnings.h">
+			</File>
+			<File
+				RelativePath="..\botlib\l_crc.h">
+			</File>
+			<File
+				RelativePath="..\botlib\l_libvar.h">
+			</File>
+			<File
+				RelativePath="..\botlib\l_log.h">
+			</File>
+			<File
+				RelativePath="..\botlib\l_memory.h">
+			</File>
+			<File
+				RelativePath="..\botlib\l_precomp.h">
+			</File>
+			<File
+				RelativePath="..\botlib\l_script.h">
+			</File>
+			<File
+				RelativePath="..\botlib\l_struct.h">
+			</File>
+			<File
+				RelativePath="..\botlib\l_utils.h">
+			</File>
+			<File
+				RelativePath="..\game\q_shared.h">
+			</File>
+			<File
+				RelativePath="..\qcommon\qcommon.h">
+			</File>
+			<File
+				RelativePath="..\qcommon\qfiles.h">
+			</File>
+			<File
+				RelativePath="..\server\server.h">
+			</File>
+			<File
+				RelativePath="..\game\surfaceflags.h">
+			</File>
+			<File
+				RelativePath="..\qcommon\tags.h">
+			</File>
+		</Filter>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>
diff --git a/codemp/x_exe/mssccprj.scc b/codemp/x_exe/mssccprj.scc
new file mode 100644
index 0000000..66fedab
--- /dev/null
+++ b/codemp/x_exe/mssccprj.scc
@@ -0,0 +1,5 @@
+SCC = This is a Source Code Control file
+
+[x_exe.vcproj]
+SCC_Aux_Path = "\\ravendata1\vss\central_code"
+SCC_Project_Name = "$/jedi/codemp/x_exe", TUHAAAAA
diff --git a/codemp/x_exe/vssver.scc b/codemp/x_exe/vssver.scc
new file mode 100644
index 0000000..4afeb9c
Binary files /dev/null and b/codemp/x_exe/vssver.scc differ
diff --git a/codemp/x_exe/x_exe.vcproj b/codemp/x_exe/x_exe.vcproj
new file mode 100644
index 0000000..6f36125
--- /dev/null
+++ b/codemp/x_exe/x_exe.vcproj
@@ -0,0 +1,1144 @@
+<?xml version="1.0" encoding = "Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="7.00"
+	Name="x_exe"
+	ProjectGUID="{EEDF772D-5D2B-4C0F-B5C8-0A5828917847}"
+	Keyword="XboxProj">
+	<Platforms>
+		<Platform
+			Name="Xbox"/>
+	</Platforms>
+	<Configurations>
+		<Configuration
+			Name="Debug|Xbox"
+			OutputDirectory="Debug"
+			IntermediateDirectory="Debug\exe"
+			ConfigurationType="1"
+			CharacterSet="2">
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				OptimizeForProcessor="2"
+				AdditionalIncludeDirectories="$(BINK_XBOX_ROOT)"
+				PreprocessorDefinitions="_DEBUG;WIN32;_JK2;_JK2MP;_XBOX;VV_LIGHTING"
+				MinimalRebuild="TRUE"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="1"
+				EnableEnhancedInstructionSet="1"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="FALSE"
+				DebugInformationFormat="4"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="xapilibd.lib d3d8d.lib d3dx8d.lib xgraphicsd.lib dsoundd.lib dmusicd.lib xboxkrnl.lib goblib.lib binkxbox.lib xbdm.lib xvoiced.lib xonlined.lib"
+				OutputFile=".\Debug\jamp-debug.exe"
+				LinkIncremental="2"
+				AdditionalLibraryDirectories=".\Debug;&quot;$(BINK_XBOX_ROOT)&quot;"
+				GenerateDebugInformation="TRUE"
+				ProgramDatabaseFile="$(OutDir)/$(ProjectName).pdb"
+				SubSystem="2"
+				OptimizeForWindows98="1"
+				TargetMachine="1"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="XboxDeploymentTool"
+				RemotePath="xe:\JK3\$(TargetName).xbe"/>
+			<Tool
+				Name="XboxImageTool"
+				StackSize="0x80000"
+				IncludeDebugInfo="TRUE"
+				NoLibWarn="TRUE"
+				TitleID="0x4C41000B"/>
+		</Configuration>
+		<Configuration
+			Name="Release|Xbox"
+			OutputDirectory="Release"
+			IntermediateDirectory="Release\exe"
+			ConfigurationType="1"
+			CharacterSet="2">
+			<Tool
+				Name="VCCLCompilerTool"
+				AdditionalOptions="/Oy-"
+				Optimization="2"
+				InlineFunctionExpansion="1"
+				OmitFramePointers="FALSE"
+				OptimizeForProcessor="2"
+				AdditionalIncludeDirectories=";$(BINK_XBOX_ROOT)"
+				PreprocessorDefinitions="_WIN32;NDEBUG;WIN32;_JK2;_JK2MP;_XBOX;VV_LIGHTING"
+				StringPooling="TRUE"
+				RuntimeLibrary="0"
+				BufferSecurityCheck="TRUE"
+				EnableFunctionLevelLinking="TRUE"
+				EnableEnhancedInstructionSet="1"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="FALSE"
+				DebugInformationFormat="3"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="xapilib.lib d3d8I.lib d3dx8.lib xgraphics.lib dsound.lib dmusic.lib xboxkrnl.lib goblib.lib binkxbox.lib xvoice.lib xbdm.lib xonline.lib"
+				OutputFile=".\Release\jamp-release.exe"
+				LinkIncremental="1"
+				AdditionalLibraryDirectories=".\Release;&quot;$(BINK_XBOX_ROOT)&quot;"
+				GenerateDebugInformation="TRUE"
+				ProgramDatabaseFile="$(OutDir)/$(ProjectName).pdb"
+				SubSystem="2"
+				OptimizeReferences="2"
+				EnableCOMDATFolding="2"
+				OptimizeForWindows98="1"
+				SetChecksum="TRUE"
+				TargetMachine="1"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="XboxDeploymentTool"
+				RemotePath="xe:\JK3\$(TargetName).xbe"/>
+			<Tool
+				Name="XboxImageTool"
+				StackSize="0x80000"
+				TitleID="0x4C41000B"/>
+		</Configuration>
+	</Configurations>
+	<Files>
+		<Filter
+			Name="Header Files">
+			<File
+				RelativePath="..\game\anims.h">
+			</File>
+			<File
+				RelativePath="..\game\bg_weapons.h">
+			</File>
+			<File
+				RelativePath="..\game\botlib.h">
+			</File>
+			<File
+				RelativePath="..\qcommon\disablewarnings.h">
+			</File>
+			<File
+				RelativePath="..\client\fffx.h">
+			</File>
+			<File
+				RelativePath="..\qcommon\fixedmap.h">
+			</File>
+			<File
+				RelativePath="..\qcommon\platform.h">
+			</File>
+			<File
+				RelativePath="..\win32\resource.h">
+			</File>
+			<File
+				RelativePath="..\ui\ui_public.h">
+			</File>
+		</Filter>
+		<Filter
+			Name="Client">
+			<File
+				RelativePath="..\client\BinkVideo.cpp">
+			</File>
+			<File
+				RelativePath="..\client\BinkVideo.h">
+			</File>
+			<File
+				RelativePath="..\client\cl_cgame.cpp">
+			</File>
+			<File
+				RelativePath="..\client\cl_cin_console.cpp">
+			</File>
+			<File
+				RelativePath="..\client\cl_console.cpp">
+			</File>
+			<File
+				RelativePath="..\client\cl_input.cpp">
+			</File>
+			<File
+				RelativePath="..\..\code\client\cl_input_hotswap.cpp">
+			</File>
+			<File
+				RelativePath="..\client\cl_keys.cpp">
+			</File>
+			<File
+				RelativePath="..\client\cl_main.cpp">
+			</File>
+			<File
+				RelativePath="..\client\cl_net_chan.cpp">
+			</File>
+			<File
+				RelativePath="..\client\cl_parse.cpp">
+			</File>
+			<File
+				RelativePath="..\client\cl_scrn.cpp">
+			</File>
+			<File
+				RelativePath="..\client\cl_ui.cpp">
+			</File>
+			<File
+				RelativePath="..\client\client.h">
+			</File>
+			<File
+				RelativePath="..\client\fxexport.cpp">
+			</File>
+			<File
+				RelativePath="..\client\fxexport.h">
+			</File>
+			<File
+				RelativePath="..\client\fxprimitives.cpp">
+			</File>
+			<File
+				RelativePath="..\client\fxprimitives.h">
+			</File>
+			<File
+				RelativePath="..\client\fxscheduler.cpp">
+			</File>
+			<File
+				RelativePath="..\client\fxscheduler.h">
+			</File>
+			<File
+				RelativePath="..\client\fxsystem.cpp">
+			</File>
+			<File
+				RelativePath="..\client\fxsystem.h">
+			</File>
+			<File
+				RelativePath="..\client\fxtemplate.cpp">
+			</File>
+			<File
+				RelativePath="..\client\fxutil.cpp">
+			</File>
+			<File
+				RelativePath="..\client\fxutil.h">
+			</File>
+		</Filter>
+		<Filter
+			Name="Common">
+			<File
+				RelativePath="..\game\bg_public.h">
+			</File>
+			<File
+				RelativePath="..\cgame\cg_public.h">
+			</File>
+			<File
+				RelativePath="..\qcommon\chash.h">
+			</File>
+			<File
+				RelativePath="..\qcommon\cm_draw.cpp">
+			</File>
+			<File
+				RelativePath="..\qcommon\cm_draw.h">
+			</File>
+			<File
+				RelativePath="..\qcommon\cm_landscape.h">
+			</File>
+			<File
+				RelativePath="..\qcommon\cm_load_xbox.cpp">
+			</File>
+			<File
+				RelativePath="..\qcommon\cm_local.h">
+			</File>
+			<File
+				RelativePath="..\qcommon\cm_patch.h">
+			</File>
+			<File
+				RelativePath="..\qcommon\cm_patch_xbox.cpp">
+			</File>
+			<File
+				RelativePath="..\qcommon\cm_polylib.cpp">
+			</File>
+			<File
+				RelativePath="..\qcommon\cm_polylib.h">
+			</File>
+			<File
+				RelativePath="..\qcommon\cm_public.h">
+			</File>
+			<File
+				RelativePath="..\qcommon\cm_randomterrain.cpp">
+			</File>
+			<File
+				RelativePath="..\qcommon\cm_randomterrain.h">
+			</File>
+			<File
+				RelativePath="..\qcommon\cm_shader.cpp">
+			</File>
+			<File
+				RelativePath="..\qcommon\cm_terrain.cpp">
+			</File>
+			<File
+				RelativePath="..\qcommon\cm_terrainmap.cpp">
+			</File>
+			<File
+				RelativePath="..\qcommon\cm_terrainmap.h">
+			</File>
+			<File
+				RelativePath="..\qcommon\cm_test.cpp">
+			</File>
+			<File
+				RelativePath="..\qcommon\cm_trace.cpp">
+			</File>
+			<File
+				RelativePath="..\qcommon\cmd_common.cpp">
+			</File>
+			<File
+				RelativePath="..\qcommon\cmd_console.cpp">
+			</File>
+			<File
+				RelativePath="..\qcommon\cnetprofile.cpp">
+			</File>
+			<File
+				RelativePath="..\qcommon\common.cpp">
+			</File>
+			<File
+				RelativePath="..\qcommon\cvar.cpp">
+			</File>
+			<File
+				RelativePath="..\qcommon\exe_headers.cpp">
+			</File>
+			<File
+				RelativePath="..\qcommon\exe_headers.h">
+			</File>
+			<File
+				RelativePath="..\qcommon\files.h">
+			</File>
+			<File
+				RelativePath="..\qcommon\files_common.cpp">
+			</File>
+			<File
+				RelativePath="..\qcommon\files_console.cpp">
+			</File>
+			<File
+				RelativePath="..\game\g_public.h">
+			</File>
+			<File
+				RelativePath="..\qcommon\game_version.h">
+			</File>
+			<File
+				RelativePath="..\qcommon\genericparser2.cpp">
+			</File>
+			<File
+				RelativePath="..\qcommon\genericparser2.h">
+			</File>
+			<File
+				RelativePath="..\qcommon\hstring.cpp">
+			</File>
+			<File
+				RelativePath="..\qcommon\hstring.h">
+			</File>
+			<File
+				RelativePath="..\qcommon\huffman.cpp">
+			</File>
+			<File
+				RelativePath="..\qcommon\inetprofile.h">
+			</File>
+			<File
+				RelativePath="..\ui\keycodes.h">
+			</File>
+			<File
+				RelativePath="..\client\keys.h">
+			</File>
+			<File
+				RelativePath="..\qcommon\md4.cpp">
+			</File>
+			<File
+				RelativePath="..\qcommon\miniheap.h">
+			</File>
+			<File
+				RelativePath="..\qcommon\msg.cpp">
+			</File>
+			<File
+				RelativePath="..\qcommon\net_chan.cpp">
+			</File>
+			<File
+				RelativePath="..\game\q_math.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\qcommon\q_math.cpp">
+			</File>
+			<File
+				RelativePath="..\game\q_shared.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\q_shared.h">
+			</File>
+			<File
+				RelativePath="..\qcommon\qcommon.h">
+			</File>
+			<File
+				RelativePath="..\qcommon\qfiles.h">
+			</File>
+			<File
+				RelativePath="..\renderer\qgl_console.h">
+			</File>
+			<File
+				RelativePath="..\qcommon\roffsystem.cpp">
+			</File>
+			<File
+				RelativePath="..\qcommon\roffsystem.h">
+			</File>
+			<File
+				RelativePath="..\qcommon\sstring.h">
+			</File>
+			<File
+				RelativePath="..\qcommon\stringed_ingame.cpp">
+			</File>
+			<File
+				RelativePath="..\qcommon\stringed_ingame.h">
+			</File>
+			<File
+				RelativePath="..\qcommon\stringed_interface.cpp">
+			</File>
+			<File
+				RelativePath="..\qcommon\stringed_interface.h">
+			</File>
+			<File
+				RelativePath="..\game\surfaceflags.h">
+			</File>
+			<File
+				RelativePath="..\qcommon\tags.h">
+			</File>
+			<File
+				RelativePath="..\qcommon\timing.h">
+			</File>
+			<File
+				RelativePath="..\qcommon\unzip.cpp">
+			</File>
+			<File
+				RelativePath="..\qcommon\unzip.h">
+			</File>
+			<File
+				RelativePath="..\qcommon\vm_console.cpp">
+			</File>
+			<File
+				RelativePath="..\qcommon\vm_local.h">
+			</File>
+			<File
+				RelativePath="..\qcommon\z_memman_console.cpp">
+			</File>
+		</Filter>
+		<Filter
+			Name="Win32">
+			<File
+				RelativePath="..\win32\dbg_console_xbox.cpp">
+			</File>
+			<File
+				RelativePath="..\win32\dbg_console_xbox.h">
+			</File>
+			<File
+				RelativePath="..\win32\glw_win_dx8.h">
+			</File>
+			<File
+				RelativePath="..\win32\win_file.h">
+			</File>
+			<File
+				RelativePath="..\win32\win_file_xbox.cpp">
+			</File>
+			<File
+				RelativePath="..\win32\win_filecode.cpp">
+			</File>
+			<File
+				RelativePath="..\win32\win_input.h">
+			</File>
+			<File
+				RelativePath="..\win32\win_input_console.cpp">
+			</File>
+			<File
+				RelativePath="..\win32\win_input_rumble.cpp">
+			</File>
+			<File
+				RelativePath="..\win32\win_input_xbox.cpp">
+			</File>
+			<File
+				RelativePath="..\win32\win_local.h">
+			</File>
+			<File
+				RelativePath="..\win32\win_main_common.cpp">
+			</File>
+			<File
+				RelativePath="..\win32\win_main_console.cpp">
+			</File>
+			<File
+				RelativePath="..\win32\win_net.cpp">
+			</File>
+			<File
+				RelativePath="..\win32\win_qal_xbox.cpp">
+			</File>
+			<File
+				RelativePath="..\win32\win_shared.cpp">
+			</File>
+			<File
+				RelativePath="..\win32\win_stream_dx8.cpp">
+			</File>
+		</Filter>
+		<Filter
+			Name="Server">
+			<File
+				RelativePath="..\server\server.h">
+			</File>
+			<File
+				RelativePath="..\server\sv_bot.cpp">
+			</File>
+			<File
+				RelativePath="..\server\sv_ccmds.cpp">
+			</File>
+			<File
+				RelativePath="..\server\sv_client.cpp">
+			</File>
+			<File
+				RelativePath="..\server\sv_game.cpp">
+			</File>
+			<File
+				RelativePath="..\server\sv_init.cpp">
+			</File>
+			<File
+				RelativePath="..\server\sv_main.cpp">
+			</File>
+			<File
+				RelativePath="..\server\sv_net_chan.cpp">
+			</File>
+			<File
+				RelativePath="..\server\sv_snapshot.cpp">
+			</File>
+			<File
+				RelativePath="..\server\sv_world.cpp">
+			</File>
+			<Filter
+				Name="NPCNav">
+				<File
+					RelativePath="..\server\NPCNav\gameCallbacks.cpp">
+				</File>
+				<File
+					RelativePath="..\server\NPCNav\navigator.cpp">
+				</File>
+				<File
+					RelativePath="..\server\NPCNav\navigator.h">
+				</File>
+			</Filter>
+		</Filter>
+		<Filter
+			Name="Sound">
+			<File
+				RelativePath="..\client\snd_ambient.cpp">
+			</File>
+			<File
+				RelativePath="..\client\snd_ambient.h">
+			</File>
+			<File
+				RelativePath="..\client\snd_dma_console.cpp">
+			</File>
+			<File
+				RelativePath="..\client\snd_local_console.h">
+			</File>
+			<File
+				RelativePath="..\client\snd_mem_console.cpp">
+			</File>
+			<File
+				RelativePath="..\client\snd_music.cpp">
+			</File>
+			<File
+				RelativePath="..\client\snd_music.h">
+			</File>
+			<File
+				RelativePath="..\client\snd_public.h">
+			</File>
+			<Filter
+				Name="EAX">
+				<File
+					RelativePath="..\client\eax\eax.h">
+				</File>
+				<File
+					RelativePath="..\client\eax\eaxman.h">
+				</File>
+			</Filter>
+			<Filter
+				Name="OpenAL">
+				<File
+					RelativePath="..\client\openal\al.h">
+				</File>
+				<File
+					RelativePath="..\client\openal\alc.h">
+				</File>
+				<File
+					RelativePath="..\client\openal\alctypes.h">
+				</File>
+				<File
+					RelativePath="..\client\openal\altypes.h">
+				</File>
+				<File
+					RelativePath="..\client\openal\alu.h">
+				</File>
+				<File
+					RelativePath="..\client\openal\alut.h">
+				</File>
+			</Filter>
+		</Filter>
+		<Filter
+			Name="Renderer">
+			<File
+				RelativePath="..\renderer\glext_console.h">
+			</File>
+			<File
+				RelativePath="..\renderer\matcomp.c">
+			</File>
+			<File
+				RelativePath="..\renderer\matcomp.h">
+			</File>
+			<File
+				RelativePath="..\renderer\tr_animation.cpp">
+			</File>
+			<File
+				RelativePath="..\renderer\tr_arioche.cpp">
+			</File>
+			<File
+				RelativePath="..\renderer\tr_backend.cpp">
+			</File>
+			<File
+				RelativePath="..\renderer\tr_bsp_xbox.cpp">
+			</File>
+			<File
+				RelativePath="..\renderer\tr_cmds.cpp">
+			</File>
+			<File
+				RelativePath="..\renderer\tr_curve_xbox.cpp">
+			</File>
+			<File
+				RelativePath="..\renderer\tr_font.cpp">
+			</File>
+			<File
+				RelativePath="..\renderer\tr_font.h">
+			</File>
+			<File
+				RelativePath="..\renderer\tr_ghoul2.cpp">
+			</File>
+			<File
+				RelativePath="..\renderer\tr_image_xbox.cpp">
+			</File>
+			<File
+				RelativePath="..\renderer\tr_init.cpp">
+			</File>
+			<File
+				RelativePath="..\renderer\tr_landscape.h">
+			</File>
+			<File
+				RelativePath="..\renderer\tr_light.cpp">
+			</File>
+			<File
+				RelativePath="..\renderer\tr_lightmanager.cpp">
+			</File>
+			<File
+				RelativePath="..\renderer\tr_lightmanager.h">
+			</File>
+			<File
+				RelativePath="..\renderer\tr_local.h">
+			</File>
+			<File
+				RelativePath="..\renderer\tr_main.cpp">
+			</File>
+			<File
+				RelativePath="..\renderer\tr_marks.cpp">
+			</File>
+			<File
+				RelativePath="..\renderer\tr_mesh.cpp">
+			</File>
+			<File
+				RelativePath="..\renderer\tr_model.cpp">
+			</File>
+			<File
+				RelativePath="..\renderer\tr_noise.cpp">
+			</File>
+			<File
+				RelativePath="..\renderer\tr_public.h">
+			</File>
+			<File
+				RelativePath="..\renderer\tr_quicksprite.cpp">
+			</File>
+			<File
+				RelativePath="..\renderer\tr_quicksprite.h">
+			</File>
+			<File
+				RelativePath="..\renderer\tr_scene.cpp">
+			</File>
+			<File
+				RelativePath="..\renderer\tr_shade.cpp">
+			</File>
+			<File
+				RelativePath="..\renderer\tr_shade_calc.cpp">
+			</File>
+			<File
+				RelativePath="..\renderer\tr_shader.cpp">
+			</File>
+			<File
+				RelativePath="..\renderer\tr_shadows.cpp">
+			</File>
+			<File
+				RelativePath="..\renderer\tr_sky.cpp">
+			</File>
+			<File
+				RelativePath="..\renderer\tr_surface.cpp">
+			</File>
+			<File
+				RelativePath="..\renderer\tr_surfacesprites.cpp">
+			</File>
+			<File
+				RelativePath="..\renderer\tr_terrain.cpp">
+			</File>
+			<File
+				RelativePath="..\cgame\tr_types.h">
+			</File>
+			<File
+				RelativePath="..\renderer\tr_world.cpp">
+			</File>
+			<File
+				RelativePath="..\renderer\tr_worldeffects.cpp">
+			</File>
+			<File
+				RelativePath="..\renderer\tr_worldeffects.h">
+			</File>
+			<File
+				RelativePath="..\win32\win_gamma_console.cpp">
+			</File>
+			<File
+				RelativePath="..\win32\win_glimp_console.cpp">
+			</File>
+			<File
+				RelativePath="..\win32\win_highdynamicrange.cpp">
+			</File>
+			<File
+				RelativePath="..\win32\win_highdynamicrange.h">
+			</File>
+			<File
+				RelativePath="..\win32\win_lighteffects.cpp">
+			</File>
+			<File
+				RelativePath="..\win32\win_lighteffects.h">
+			</File>
+			<File
+				RelativePath="..\win32\win_qgl_dx8.cpp">
+			</File>
+			<Filter
+				Name="png">
+				<File
+					RelativePath="..\png\png.cpp">
+				</File>
+				<File
+					RelativePath="..\png\png.h">
+				</File>
+			</Filter>
+		</Filter>
+		<Filter
+			Name="Ghoul2">
+			<File
+				RelativePath="..\ghoul2\g2.h">
+			</File>
+			<File
+				RelativePath="..\ghoul2\g2_api.cpp">
+			</File>
+			<File
+				RelativePath="..\ghoul2\g2_bolts.cpp">
+			</File>
+			<File
+				RelativePath="..\ghoul2\g2_bones.cpp">
+			</File>
+			<File
+				RelativePath="..\ghoul2\g2_gore.h">
+			</File>
+			<File
+				RelativePath="..\ghoul2\g2_local.h">
+			</File>
+			<File
+				RelativePath="..\ghoul2\g2_misc.cpp">
+			</File>
+			<File
+				RelativePath="..\ghoul2\g2_surfaces.cpp">
+			</File>
+			<File
+				RelativePath="..\ghoul2\ghoul2_shared.h">
+			</File>
+			<File
+				RelativePath="..\renderer\mdx_format.h">
+			</File>
+		</Filter>
+		<Filter
+			Name="zlib32">
+			<File
+				RelativePath="..\zlib32\deflate.cpp">
+			</File>
+			<File
+				RelativePath="..\zlib32\deflate.h">
+			</File>
+			<File
+				RelativePath="..\zlib32\inflate.cpp">
+			</File>
+			<File
+				RelativePath="..\zlib32\inflate.h">
+			</File>
+			<File
+				RelativePath="..\zlib32\zip.h">
+			</File>
+			<File
+				RelativePath="..\zlib32\zipcommon.cpp">
+			</File>
+		</Filter>
+		<Filter
+			Name="encryption">
+			<File
+				RelativePath="..\encryption\buffer.cpp">
+			</File>
+			<File
+				RelativePath="..\encryption\buffer.h">
+			</File>
+			<File
+				RelativePath="..\encryption\cpp_interface.cpp">
+			</File>
+			<File
+				RelativePath="..\encryption\cpp_interface.h">
+			</File>
+			<File
+				RelativePath="..\encryption\encryption.h">
+			</File>
+			<File
+				RelativePath="..\encryption\sockets.cpp">
+			</File>
+			<File
+				RelativePath="..\encryption\sockets.h">
+			</File>
+		</Filter>
+		<Filter
+			Name="RMG">
+			<File
+				RelativePath="..\rmg\rm_area.cpp">
+			</File>
+			<File
+				RelativePath="..\rmg\rm_area.h">
+			</File>
+			<File
+				RelativePath="..\rmg\rm_headers.h">
+			</File>
+			<File
+				RelativePath="..\rmg\rm_instance.cpp">
+			</File>
+			<File
+				RelativePath="..\rmg\rm_instance.h">
+			</File>
+			<File
+				RelativePath="..\rmg\rm_instance_bsp.cpp">
+			</File>
+			<File
+				RelativePath="..\rmg\rm_instance_bsp.h">
+			</File>
+			<File
+				RelativePath="..\rmg\rm_instance_group.cpp">
+			</File>
+			<File
+				RelativePath="..\rmg\rm_instance_group.h">
+			</File>
+			<File
+				RelativePath="..\rmg\rm_instance_random.cpp">
+			</File>
+			<File
+				RelativePath="..\rmg\rm_instance_random.h">
+			</File>
+			<File
+				RelativePath="..\rmg\rm_instance_void.cpp">
+			</File>
+			<File
+				RelativePath="..\rmg\rm_instance_void.h">
+			</File>
+			<File
+				RelativePath="..\rmg\rm_instancefile.cpp">
+			</File>
+			<File
+				RelativePath="..\rmg\rm_instancefile.h">
+			</File>
+			<File
+				RelativePath="..\rmg\rm_manager.cpp">
+			</File>
+			<File
+				RelativePath="..\rmg\rm_manager.h">
+			</File>
+			<File
+				RelativePath="..\rmg\rm_mission.cpp">
+			</File>
+			<File
+				RelativePath="..\rmg\rm_mission.h">
+			</File>
+			<File
+				RelativePath="..\rmg\rm_objective.cpp">
+			</File>
+			<File
+				RelativePath="..\rmg\rm_objective.h">
+			</File>
+			<File
+				RelativePath="..\rmg\rm_path.cpp">
+			</File>
+			<File
+				RelativePath="..\rmg\rm_path.h">
+			</File>
+			<File
+				RelativePath="..\rmg\rm_terrain.cpp">
+			</File>
+			<File
+				RelativePath="..\rmg\rm_terrain.h">
+			</File>
+		</Filter>
+		<Filter
+			Name="ICARUS">
+			<File
+				RelativePath="..\icarus\blockstream.cpp">
+			</File>
+			<File
+				RelativePath="..\icarus\blockstream.h">
+			</File>
+			<File
+				RelativePath="..\icarus\gameinterface.cpp">
+			</File>
+			<File
+				RelativePath="..\icarus\gameinterface.h">
+			</File>
+			<File
+				RelativePath="..\icarus\icarus.h">
+			</File>
+			<File
+				RelativePath="..\icarus\instance.cpp">
+			</File>
+			<File
+				RelativePath="..\icarus\instance.h">
+			</File>
+			<File
+				RelativePath="..\icarus\interface.cpp">
+			</File>
+			<File
+				RelativePath="..\icarus\interface.h">
+			</File>
+			<File
+				RelativePath="..\icarus\interpreter.h">
+			</File>
+			<File
+				RelativePath="..\icarus\memory.cpp">
+			</File>
+			<File
+				RelativePath="..\icarus\module.h">
+			</File>
+			<File
+				RelativePath="..\icarus\q3_interface.cpp">
+			</File>
+			<File
+				RelativePath="..\icarus\q3_interface.h">
+			</File>
+			<File
+				RelativePath="..\icarus\q3_registers.cpp">
+			</File>
+			<File
+				RelativePath="..\icarus\q3_registers.h">
+			</File>
+			<File
+				RelativePath="..\icarus\sequence.cpp">
+			</File>
+			<File
+				RelativePath="..\icarus\sequence.h">
+			</File>
+			<File
+				RelativePath="..\icarus\sequencer.cpp">
+			</File>
+			<File
+				RelativePath="..\icarus\sequencer.h">
+			</File>
+			<File
+				RelativePath="..\icarus\taskmanager.cpp">
+			</File>
+			<File
+				RelativePath="..\icarus\taskmanager.h">
+			</File>
+			<File
+				RelativePath="..\icarus\tokenizer.h">
+			</File>
+		</Filter>
+		<Filter
+			Name="ff"
+			Filter="">
+			<File
+				RelativePath="..\ff\ff_console.cpp">
+			</File>
+		</Filter>
+		<Filter
+			Name="XboxLive"
+			Filter="">
+			<File
+				RelativePath="..\xbox\XBLive.cpp">
+			</File>
+			<File
+				RelativePath="..\xbox\XBLive.h">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCustomBuildTool"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCustomBuildTool"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\xbox\XBLive_Friends.cpp">
+			</File>
+			<File
+				RelativePath="..\xbox\XBLive_MM.cpp">
+			</File>
+			<File
+				RelativePath="..\xbox\XBLive_PL.cpp">
+			</File>
+			<File
+				RelativePath="..\xbox\XBVoice.cpp">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\xbox\XBVoice.h">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCustomBuildTool"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCustomBuildTool"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\xbox\XBoxCommon.h">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCustomBuildTool"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCustomBuildTool"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\xbox\XHVVoiceManager.cpp">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\xbox\XHVVoiceManager.h">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCustomBuildTool"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCustomBuildTool"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\xbox\match.cpp">
+			</File>
+			<File
+				RelativePath="..\xbox\match.h">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCustomBuildTool"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCustomBuildTool"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\xbox\xbSockAddr.cpp">
+			</File>
+			<File
+				RelativePath="..\xbox\xbSockAddr.h">
+			</File>
+			<File
+				RelativePath="..\xbox\xbsocket.cpp">
+			</File>
+			<File
+				RelativePath="..\xbox\xbsocket.h">
+			</File>
+		</Filter>
+		<Filter
+			Name="Ravl">
+			<File
+				RelativePath="..\ravl\CVec.h">
+			</File>
+		</Filter>
+		<Filter
+			Name="Ratl">
+			<File
+				RelativePath="..\ratl\bits_vs.h">
+			</File>
+			<File
+				RelativePath="..\ratl\ratl_common.h">
+			</File>
+			<File
+				RelativePath="..\ratl\vector_vs.h">
+			</File>
+		</Filter>
+		<File
+			RelativePath="..\CommandLine.txt">
+		</File>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>
diff --git a/codemp/x_jk2cgame/mssccprj.scc b/codemp/x_jk2cgame/mssccprj.scc
new file mode 100644
index 0000000..3bcec23
--- /dev/null
+++ b/codemp/x_jk2cgame/mssccprj.scc
@@ -0,0 +1,5 @@
+SCC = This is a Source Code Control file
+
+[x_jk2cgame.vcproj]
+SCC_Aux_Path = "\\ravendata1\vss\central_code"
+SCC_Project_Name = "$/jedi/codemp/x_jk2cgame", UUHAAAAA
diff --git a/codemp/x_jk2cgame/vssver.scc b/codemp/x_jk2cgame/vssver.scc
new file mode 100644
index 0000000..ccaae48
Binary files /dev/null and b/codemp/x_jk2cgame/vssver.scc differ
diff --git a/codemp/x_jk2cgame/x_jk2cgame.vcproj b/codemp/x_jk2cgame/x_jk2cgame.vcproj
new file mode 100644
index 0000000..3a502f7
--- /dev/null
+++ b/codemp/x_jk2cgame/x_jk2cgame.vcproj
@@ -0,0 +1,977 @@
+<?xml version="1.0" encoding = "Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="7.00"
+	Name="x_jk2cgame"
+	ProjectGUID="{C79C9037-8F32-4833-A276-96B2FB96CCA5}"
+	Keyword="XboxProj">
+	<Platforms>
+		<Platform
+			Name="Xbox"/>
+	</Platforms>
+	<Configurations>
+		<Configuration
+			Name="Debug|Xbox"
+			OutputDirectory=".\..\x_exe\Debug"
+			IntermediateDirectory=".\..\x_exe\Debug\jk2cgame"
+			ConfigurationType="4"
+			CharacterSet="2">
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				OptimizeForProcessor="2"
+				AdditionalIncludeDirectories="..,./../game"
+				PreprocessorDefinitions="_DEBUG;WIN32;MISSIONPACK;CGAME;_JK2;_XBOX;_LIB;_CGAME;CGAME_HARD_LINKED"
+				MinimalRebuild="TRUE"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="1"
+				UsePrecompiledHeader="0"
+				PrecompiledHeaderFile="$(OutDir)/$(ProjectName).pch"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="FALSE"
+				DebugInformationFormat="4"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLibrarianTool"
+				OutputFile="$(OutDir)/$(ProjectName).lib"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+		</Configuration>
+		<Configuration
+			Name="Release|Xbox"
+			OutputDirectory=".\..\x_exe\Release"
+			IntermediateDirectory=".\..\x_exe\Release\jk2cgame"
+			ConfigurationType="4"
+			CharacterSet="2">
+			<Tool
+				Name="VCCLCompilerTool"
+				AdditionalOptions="/Oy-"
+				Optimization="2"
+				InlineFunctionExpansion="1"
+				OmitFramePointers="FALSE"
+				OptimizeForProcessor="2"
+				AdditionalIncludeDirectories="..,./../game"
+				PreprocessorDefinitions="NDEBUG;WIN32;MISSIONPACK;_JK2;CGAME;_XBOX;_LIB;_CGAME;CGAME_HARD_LINKED"
+				StringPooling="TRUE"
+				RuntimeLibrary="0"
+				BufferSecurityCheck="TRUE"
+				EnableFunctionLevelLinking="TRUE"
+				UsePrecompiledHeader="3"
+				PrecompiledHeaderFile="$(OutDir)/$(ProjectName).pch"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="FALSE"
+				DebugInformationFormat="3"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLibrarianTool"
+				OutputFile="$(OutDir)/$(ProjectName).lib"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+		</Configuration>
+	</Configurations>
+	<Files>
+		<Filter
+			Name="Source Files">
+			<File
+				RelativePath="..\game\AnimalNPC.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\FighterNPC.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\SpeederNPC.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\WalkerNPC.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\bg_g2_utils.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\bg_misc.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\bg_panimate.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\bg_pmove.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\bg_saber.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\bg_saberLoad.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\bg_saga.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\bg_slidemove.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\bg_vehicleLoad.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\bg_weapons.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\cgame\cg_consolecmds.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\cgame\cg_draw.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\cgame\cg_drawtools.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\cgame\cg_effects.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\cgame\cg_ents.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\cgame\cg_event.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\cgame\cg_info.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\cgame\cg_light.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\cgame\cg_localents.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\cgame\cg_main.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\cgame\cg_marks.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\cgame\cg_newDraw.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\cgame\cg_players.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\cgame\cg_playerstate.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\cgame\cg_predict.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\cgame\cg_saga.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\cgame\cg_scoreboard.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\cgame\cg_servercmds.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\cgame\cg_snapshot.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\cgame\cg_strap.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\cgame\cg_syscalls.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\cgame\cg_turret.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\cgame\cg_view.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\cgame\cg_weaponinit.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\cgame\cg_weapons.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\cgame\fx_blaster.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\cgame\fx_bowcaster.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\cgame\fx_bryarpistol.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\cgame\fx_demp2.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\cgame\fx_disruptor.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\cgame\fx_flechette.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\cgame\fx_force.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\cgame\fx_heavyrepeater.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\cgame\fx_rocketlauncher.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\q_math.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\q_shared.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\ui\ui_shared.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+		</Filter>
+		<Filter
+			Name="Header Files">
+			<File
+				RelativePath="..\game\anims.h">
+			</File>
+			<File
+				RelativePath="..\cgame\animtable.h">
+			</File>
+			<File
+				RelativePath="..\game\bg_local.h">
+			</File>
+			<File
+				RelativePath="..\game\bg_public.h">
+			</File>
+			<File
+				RelativePath="..\game\bg_saga.h">
+			</File>
+			<File
+				RelativePath="..\game\bg_strap.h">
+			</File>
+			<File
+				RelativePath="..\game\bg_weapons.h">
+			</File>
+			<File
+				RelativePath="..\cgame\cg_lights.h">
+			</File>
+			<File
+				RelativePath="..\cgame\cg_local.h">
+			</File>
+			<File
+				RelativePath="..\cgame\cg_public.h">
+			</File>
+			<File
+				RelativePath="..\qcommon\disablewarnings.h">
+			</File>
+			<File
+				RelativePath="..\cgame\fx_local.h">
+			</File>
+			<File
+				RelativePath="..\ghoul2\g2.h">
+			</File>
+			<File
+				RelativePath="..\ui\keycodes.h">
+			</File>
+			<File
+				RelativePath="..\..\ui\menudef.h">
+			</File>
+			<File
+				RelativePath="..\game\q_shared.h">
+			</File>
+			<File
+				RelativePath="..\qcommon\qfiles.h">
+			</File>
+			<File
+				RelativePath="..\game\surfaceflags.h">
+			</File>
+			<File
+				RelativePath="..\qcommon\tags.h">
+			</File>
+			<File
+				RelativePath="..\cgame\tr_types.h">
+			</File>
+			<File
+				RelativePath="..\ui\ui_shared.h">
+			</File>
+		</Filter>
+		<File
+			RelativePath="..\namespace_begin.h">
+		</File>
+		<File
+			RelativePath="..\namespace_end.h">
+		</File>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>
diff --git a/codemp/x_jk2game/mssccprj.scc b/codemp/x_jk2game/mssccprj.scc
new file mode 100644
index 0000000..eb9c743
--- /dev/null
+++ b/codemp/x_jk2game/mssccprj.scc
@@ -0,0 +1,5 @@
+SCC = This is a Source Code Control file
+
+[x_jk2game.vcproj]
+SCC_Aux_Path = "\\ravendata1\vss\central_code"
+SCC_Project_Name = "$/jedi/codemp/x_jk2game", VUHAAAAA
diff --git a/codemp/x_jk2game/vssver.scc b/codemp/x_jk2game/vssver.scc
new file mode 100644
index 0000000..dc6db29
Binary files /dev/null and b/codemp/x_jk2game/vssver.scc differ
diff --git a/codemp/x_jk2game/x_jk2game.vcproj b/codemp/x_jk2game/x_jk2game.vcproj
new file mode 100644
index 0000000..7d67072
--- /dev/null
+++ b/codemp/x_jk2game/x_jk2game.vcproj
@@ -0,0 +1,1648 @@
+<?xml version="1.0" encoding = "Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="7.00"
+	Name="x_jk2game"
+	ProjectGUID="{A0451C0A-0B2F-400A-BBB1-98F517FAB30B}"
+	Keyword="XboxProj">
+	<Platforms>
+		<Platform
+			Name="Xbox"/>
+	</Platforms>
+	<Configurations>
+		<Configuration
+			Name="Debug|Xbox"
+			OutputDirectory=".\..\x_exe\Debug"
+			IntermediateDirectory=".\..\x_exe\Debug\jk2game"
+			ConfigurationType="4"
+			CharacterSet="2">
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				OptimizeForProcessor="2"
+				PreprocessorDefinitions="_DEBUG;BUILDING_REF_GL;Debug;WIN32;MISSIONPACK;QAGAME;_JK2;JK2AWARDS;_XBOX;_LIB;_GAME;GAME_HARD_LINKED;_JK2MP"
+				MinimalRebuild="TRUE"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="1"
+				UsePrecompiledHeader="0"
+				PrecompiledHeaderFile="$(OutDir)/$(ProjectName).pch"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="FALSE"
+				DebugInformationFormat="4"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLibrarianTool"
+				OutputFile="$(OutDir)/$(ProjectName).lib"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+		</Configuration>
+		<Configuration
+			Name="Release|Xbox"
+			OutputDirectory=".\..\x_exe\Release"
+			IntermediateDirectory=".\..\x_exe\Release\jk2game"
+			ConfigurationType="4"
+			CharacterSet="2">
+			<Tool
+				Name="VCCLCompilerTool"
+				AdditionalOptions="/Oy-"
+				Optimization="2"
+				InlineFunctionExpansion="1"
+				OmitFramePointers="FALSE"
+				OptimizeForProcessor="2"
+				PreprocessorDefinitions="NDEBUG;WIN32;MISSIONPACK;QAGAME;_JK2;_XBOX;_LIB;_GAME;GAME_HARD_LINKED;_JK2MP"
+				StringPooling="TRUE"
+				RuntimeLibrary="0"
+				BufferSecurityCheck="TRUE"
+				EnableFunctionLevelLinking="TRUE"
+				UsePrecompiledHeader="3"
+				PrecompiledHeaderFile="$(OutDir)/$(ProjectName).pch"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="FALSE"
+				DebugInformationFormat="3"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLibrarianTool"
+				OutputFile="$(OutDir)/$(ProjectName).lib"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+		</Configuration>
+	</Configurations>
+	<Files>
+		<Filter
+			Name="Source Files">
+			<File
+				RelativePath="..\game\AnimalNPC.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\FighterNPC.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\NPC.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\NPC_AI_Atst.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\NPC_AI_Default.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\NPC_AI_Droid.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\NPC_AI_GalakMech.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\NPC_AI_Grenadier.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\NPC_AI_Howler.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\NPC_AI_ImperialProbe.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\NPC_AI_Interrogator.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\NPC_AI_Jedi.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\NPC_AI_Mark1.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\NPC_AI_Mark2.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\NPC_AI_MineMonster.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\NPC_AI_Rancor.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\NPC_AI_Remote.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\NPC_AI_Seeker.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\NPC_AI_Sentry.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\NPC_AI_Sniper.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\NPC_AI_Stormtrooper.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\NPC_AI_Utils.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\NPC_AI_Wampa.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\NPC_behavior.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\NPC_combat.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\NPC_goal.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\NPC_misc.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\NPC_move.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\NPC_reactions.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\NPC_senses.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\NPC_sounds.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\NPC_spawn.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\NPC_stats.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\NPC_utils.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\SpeederNPC.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\WalkerNPC.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\ai_main.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\ai_util.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\ai_wpnav.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\bg_g2_utils.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\bg_misc.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\bg_panimate.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\bg_pmove.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\bg_saber.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\bg_saberLoad.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\bg_saga.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\bg_slidemove.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\bg_vehicleLoad.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\bg_weapons.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\g_ICARUScb.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\g_active.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\g_arenas.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\g_bot.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\g_client.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\g_cmds.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\g_combat.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\g_exphysics.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\g_items.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\g_log.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\g_main.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\g_mem.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\g_misc.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\g_missile.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\g_mover.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\g_nav.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\g_navnew.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\g_object.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\g_saga.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\g_session.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\g_spawn.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\g_strap.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\g_svcmds.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\g_syscalls.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\g_target.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\g_team.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\g_timer.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\g_trigger.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\g_turret.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\g_turret_G2.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\g_utils.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\g_vehicleTurret.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\g_vehicles.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\g_weapon.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\q_math.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\q_shared.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\tri_coll_test.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\w_force.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\w_saber.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+		</Filter>
+		<Filter
+			Name="Header Files">
+			<File
+				RelativePath="..\game\ai.h">
+			</File>
+			<File
+				RelativePath="..\game\ai_main.h">
+			</File>
+			<File
+				RelativePath="..\game\anims.h">
+			</File>
+			<File
+				RelativePath="..\cgame\animtable.h">
+			</File>
+			<File
+				RelativePath="..\game\b_local.h">
+			</File>
+			<File
+				RelativePath="..\game\b_public.h">
+			</File>
+			<File
+				RelativePath="..\game\be_aas.h">
+			</File>
+			<File
+				RelativePath="..\game\be_ai_char.h">
+			</File>
+			<File
+				RelativePath="..\game\be_ai_chat.h">
+			</File>
+			<File
+				RelativePath="..\game\be_ai_gen.h">
+			</File>
+			<File
+				RelativePath="..\game\be_ai_goal.h">
+			</File>
+			<File
+				RelativePath="..\game\be_ai_move.h">
+			</File>
+			<File
+				RelativePath="..\game\be_ai_weap.h">
+			</File>
+			<File
+				RelativePath="..\game\be_ea.h">
+			</File>
+			<File
+				RelativePath="..\game\bg_lib.h">
+			</File>
+			<File
+				RelativePath="..\game\bg_local.h">
+			</File>
+			<File
+				RelativePath="..\game\bg_public.h">
+			</File>
+			<File
+				RelativePath="..\game\bg_saga.h">
+			</File>
+			<File
+				RelativePath="..\game\bg_strap.h">
+			</File>
+			<File
+				RelativePath="..\game\bg_vehicles.h">
+			</File>
+			<File
+				RelativePath="..\game\bg_weapons.h">
+			</File>
+			<File
+				RelativePath="..\game\botlib.h">
+			</File>
+			<File
+				RelativePath="..\cgame\cg_local.h">
+			</File>
+			<File
+				RelativePath="..\cgame\cg_public.h">
+			</File>
+			<File
+				RelativePath="..\game\chars.h">
+			</File>
+			<File
+				RelativePath="..\qcommon\disablewarnings.h">
+			</File>
+			<File
+				RelativePath="..\ghoul2\g2.h">
+			</File>
+			<File
+				RelativePath="..\game\g_ICARUScb.h">
+			</File>
+			<File
+				RelativePath="..\game\g_headers.h">
+			</File>
+			<File
+				RelativePath="..\game\g_local.h">
+			</File>
+			<File
+				RelativePath="..\game\g_nav.h">
+			</File>
+			<File
+				RelativePath="..\game\g_public.h">
+			</File>
+			<File
+				RelativePath="..\game\g_team.h">
+			</File>
+			<File
+				RelativePath="..\game\inv.h">
+			</File>
+			<File
+				RelativePath="..\game\match.h">
+			</File>
+			<File
+				RelativePath="..\..\ui\menudef.h">
+			</File>
+			<File
+				RelativePath="..\game\npc_headers.h">
+			</File>
+			<File
+				RelativePath="..\game\q_shared.h">
+			</File>
+			<File
+				RelativePath="..\game\say.h">
+			</File>
+			<File
+				RelativePath="..\game\surfaceflags.h">
+			</File>
+			<File
+				RelativePath="..\game\syn.h">
+			</File>
+			<File
+				RelativePath="..\qcommon\tags.h">
+			</File>
+			<File
+				RelativePath="..\game\teams.h">
+			</File>
+			<File
+				RelativePath="..\cgame\tr_types.h">
+			</File>
+			<File
+				RelativePath="..\game\w_saber.h">
+			</File>
+			<Filter
+				Name="ICARUS Headers">
+				<File
+					RelativePath="..\icarus\interpreter.h">
+				</File>
+				<File
+					RelativePath="..\icarus\q3_interface.h">
+				</File>
+			</Filter>
+		</Filter>
+		<File
+			RelativePath="..\namespace_begin.h">
+		</File>
+		<File
+			RelativePath="..\namespace_end.h">
+		</File>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>
diff --git a/codemp/x_ui/mssccprj.scc b/codemp/x_ui/mssccprj.scc
new file mode 100644
index 0000000..8757bf4
--- /dev/null
+++ b/codemp/x_ui/mssccprj.scc
@@ -0,0 +1,5 @@
+SCC = This is a Source Code Control file
+
+[x_ui.vcproj]
+SCC_Aux_Path = "\\ravendata1\vss\central_code"
+SCC_Project_Name = "$/jedi/codemp/x_ui", WUHAAAAA
diff --git a/codemp/x_ui/vssver.scc b/codemp/x_ui/vssver.scc
new file mode 100644
index 0000000..2864a40
Binary files /dev/null and b/codemp/x_ui/vssver.scc differ
diff --git a/codemp/x_ui/x_ui.vcproj b/codemp/x_ui/x_ui.vcproj
new file mode 100644
index 0000000..bcdf2e9
--- /dev/null
+++ b/codemp/x_ui/x_ui.vcproj
@@ -0,0 +1,361 @@
+<?xml version="1.0" encoding = "Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="7.00"
+	Name="x_ui"
+	ProjectGUID="{613EA919-780E-416D-90A9-67D3EB27F899}"
+	Keyword="XboxProj">
+	<Platforms>
+		<Platform
+			Name="Xbox"/>
+	</Platforms>
+	<Configurations>
+		<Configuration
+			Name="Debug|Xbox"
+			OutputDirectory=".\..\x_exe\Debug"
+			IntermediateDirectory=".\..\x_exe\Debug\ui"
+			ConfigurationType="4"
+			CharacterSet="2">
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				OptimizeForProcessor="2"
+				PreprocessorDefinitions="_DEBUG;WIN32;UI_EXPORTS;MISSIONPACK;_JK2;_XBOX;_LIB;_UI;UI_HARD_LINKED"
+				MinimalRebuild="TRUE"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="1"
+				UsePrecompiledHeader="0"
+				PrecompiledHeaderFile="$(OutDir)/$(ProjectName).pch"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="FALSE"
+				DebugInformationFormat="4"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLibrarianTool"
+				OutputFile="$(OutDir)/$(ProjectName).lib"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+		</Configuration>
+		<Configuration
+			Name="Release|Xbox"
+			OutputDirectory=".\..\x_exe\Release"
+			IntermediateDirectory=".\..\x_exe\Release\ui"
+			ConfigurationType="4"
+			CharacterSet="2">
+			<Tool
+				Name="VCCLCompilerTool"
+				AdditionalOptions="/Oy-"
+				Optimization="2"
+				InlineFunctionExpansion="1"
+				OmitFramePointers="FALSE"
+				OptimizeForProcessor="2"
+				PreprocessorDefinitions="NDEBUG;WIN32;UI_EXPORTS;MISSIONPACK;_JK2;_XBOX;_LIB;_UI;UI_HARD_LINKED"
+				StringPooling="TRUE"
+				RuntimeLibrary="0"
+				BufferSecurityCheck="TRUE"
+				EnableFunctionLevelLinking="TRUE"
+				UsePrecompiledHeader="3"
+				PrecompiledHeaderFile="$(OutDir)/$(ProjectName).pch"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="FALSE"
+				DebugInformationFormat="3"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLibrarianTool"
+				OutputFile="$(OutDir)/$(ProjectName).lib"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+		</Configuration>
+	</Configurations>
+	<Files>
+		<Filter
+			Name="Source Files">
+			<File
+				RelativePath="..\game\bg_misc.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\bg_saga.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\bg_vehicleLoad.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\bg_weapons.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\q_math.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\game\q_shared.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\ui\ui_atoms.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\ui\ui_force.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\ui\ui_gameinfo.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\ui\ui_main.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\ui\ui_saber.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\ui\ui_shared.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+			<File
+				RelativePath="..\ui\ui_syscalls.c">
+				<FileConfiguration
+					Name="Debug|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						CompileAs="2"/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Xbox">
+					<Tool
+						Name="VCCLCompilerTool"
+						UsePrecompiledHeader="0"
+						CompileAs="2"/>
+				</FileConfiguration>
+			</File>
+		</Filter>
+		<Filter
+			Name="Header Files">
+			<File
+				RelativePath="..\game\anims.h">
+			</File>
+			<File
+				RelativePath="..\game\bg_local.h">
+			</File>
+			<File
+				RelativePath="..\game\bg_public.h">
+			</File>
+			<File
+				RelativePath="..\game\bg_saga.h">
+			</File>
+			<File
+				RelativePath="..\game\bg_strap.h">
+			</File>
+			<File
+				RelativePath="..\game\bg_weapons.h">
+			</File>
+			<File
+				RelativePath="..\qcommon\disablewarnings.h">
+			</File>
+			<File
+				RelativePath="..\qcommon\game_version.h">
+			</File>
+			<File
+				RelativePath="..\ui\keycodes.h">
+			</File>
+			<File
+				RelativePath="..\..\ui\menudef.h">
+			</File>
+			<File
+				RelativePath="..\game\q_shared.h">
+			</File>
+			<File
+				RelativePath="..\qcommon\qfiles.h">
+			</File>
+			<File
+				RelativePath="..\game\surfaceflags.h">
+			</File>
+			<File
+				RelativePath="..\qcommon\tags.h">
+			</File>
+			<File
+				RelativePath="..\cgame\tr_types.h">
+			</File>
+			<File
+				RelativePath="..\ui\ui_force.h">
+			</File>
+			<File
+				RelativePath="..\ui\ui_local.h">
+			</File>
+			<File
+				RelativePath="..\ui\ui_public.h">
+			</File>
+			<File
+				RelativePath="..\ui\ui_shared.h">
+			</File>
+		</Filter>
+		<File
+			RelativePath="..\namespace_begin.h">
+		</File>
+		<File
+			RelativePath="..\namespace_end.h">
+		</File>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>
diff --git a/codemp/zlib32/deflate.cpp b/codemp/zlib32/deflate.cpp
new file mode 100644
index 0000000..0301b6a
--- /dev/null
+++ b/codemp/zlib32/deflate.cpp
@@ -0,0 +1,2078 @@
+#include "../game/q_shared.h"
+#include "../qcommon/qcommon.h"
+
+#include "zip.h"
+#include "deflate.h"
+
+#ifdef _TIMING
+int		totalDeflateTime[Z_MAX_COMPRESSION + 1];
+int		totalDeflateCount[Z_MAX_COMPRESSION + 1];
+#endif
+
+// If you use the zlib library in a product, an acknowledgment is welcome
+// in the documentation of your product. If for some reason you cannot
+// include such an acknowledgment, I would appreciate that you keep this
+// copyright string in the executable of your product.
+const char deflate_copyright[] = "Deflate 1.1.3 Copyright 1995-1998 Jean-loup Gailly ";
+
+static const char *deflate_error = "OK";
+
+//  ALGORITHM
+// 
+//  The "deflation" process depends on being able to identify portions
+//  of the input text which are identical to earlier input (within a
+//  sliding window trailing behind the input currently being processed).
+// 
+//  The most straightforward technique turns out to be the fastest for
+//  most input files: try all possible matches and select the longest.
+//  The key feature of this algorithm is that insertions into the string
+//  dictionary are very simple and thus fast, and deletions are avoided
+//  completely. Insertions are performed at each input character, whereas
+//  string matches are performed only when the previous match ends. So it
+//  is preferable to spend more time in matches to allow very fast string
+//  insertions and avoid deletions. The matching algorithm for small
+//  strings is inspired from that of Rabin & Karp. A brute force approach
+//  is used to find longer strings when a small match has been found.
+//  A similar algorithm is used in comic (by Jan-Mark Wams) and freeze
+//  (by Leonid Broukhis).
+//
+// ACKNOWLEDGEMENTS
+//
+//  The idea of lazy evaluation of matches is due to Jan-Mark Wams, and
+//  I found it in 'freeze' written by Leonid Broukhis.
+//  Thanks to many people for bug reports and testing.
+//
+// REFERENCES
+//
+//  Deutsch, L.P.,"DEFLATE Compressed Data Format Specification".
+//  Available in ftp://ds.internic.net/rfc/rfc1951.txt
+//
+//  A description of the Rabin and Karp algorithm is given in the book
+//     "Algorithms" by R. Sedgewick, Addison-Wesley, p252.
+//
+//  Fiala,E.R., and Greene,D.H.
+//     Data Compression with Finite Windows, Comm.ACM, 32,4 (1989) 490-595
+
+// ===============================================================================
+//  A word is an index in the character window. We use short instead of int to
+//  save space in the various tables. ulong is used only for parameter passing.
+
+//  The static literal tree. Since the bit lengths are imposed, there is no
+//  need for the L_CODES extra codes used during heap construction. However
+//  The codes 286 and 287 are needed to build a canonical tree (see _tr_init
+//  below).
+static const ct_data static_ltree[L_CODES + 2] = 
+{
+	{{  12 }, { 8 }}, {{ 140 }, { 8 }}, {{  76 }, { 8 }}, {{ 204 }, { 8 }}, {{  44 }, { 8 }},
+	{{ 172 }, { 8 }}, {{ 108 }, { 8 }}, {{ 236 }, { 8 }}, {{  28 }, { 8 }}, {{ 156 }, { 8 }},
+	{{  92 }, { 8 }}, {{ 220 }, { 8 }}, {{  60 }, { 8 }}, {{ 188 }, { 8 }}, {{ 124 }, { 8 }},
+	{{ 252 }, { 8 }}, {{   2 }, { 8 }}, {{ 130 }, { 8 }}, {{  66 }, { 8 }}, {{ 194 }, { 8 }},
+	{{  34 }, { 8 }}, {{ 162 }, { 8 }}, {{  98 }, { 8 }}, {{ 226 }, { 8 }}, {{  18 }, { 8 }},
+	{{ 146 }, { 8 }}, {{  82 }, { 8 }}, {{ 210 }, { 8 }}, {{  50 }, { 8 }}, {{ 178 }, { 8 }},
+	{{ 114 }, { 8 }}, {{ 242 }, { 8 }}, {{  10 }, { 8 }}, {{ 138 }, { 8 }}, {{  74 }, { 8 }},
+	{{ 202 }, { 8 }}, {{  42 }, { 8 }}, {{ 170 }, { 8 }}, {{ 106 }, { 8 }}, {{ 234 }, { 8 }},
+	{{  26 }, { 8 }}, {{ 154 }, { 8 }}, {{  90 }, { 8 }}, {{ 218 }, { 8 }}, {{  58 }, { 8 }},
+	{{ 186 }, { 8 }}, {{ 122 }, { 8 }}, {{ 250 }, { 8 }}, {{   6 }, { 8 }}, {{ 134 }, { 8 }},
+	{{  70 }, { 8 }}, {{ 198 }, { 8 }}, {{  38 }, { 8 }}, {{ 166 }, { 8 }}, {{ 102 }, { 8 }},
+	{{ 230 }, { 8 }}, {{  22 }, { 8 }}, {{ 150 }, { 8 }}, {{  86 }, { 8 }}, {{ 214 }, { 8 }},
+	{{  54 }, { 8 }}, {{ 182 }, { 8 }}, {{ 118 }, { 8 }}, {{ 246 }, { 8 }}, {{  14 }, { 8 }},
+	{{ 142 }, { 8 }}, {{  78 }, { 8 }}, {{ 206 }, { 8 }}, {{  46 }, { 8 }}, {{ 174 }, { 8 }},
+	{{ 110 }, { 8 }}, {{ 238 }, { 8 }}, {{  30 }, { 8 }}, {{ 158 }, { 8 }}, {{  94 }, { 8 }},
+	{{ 222 }, { 8 }}, {{  62 }, { 8 }}, {{ 190 }, { 8 }}, {{ 126 }, { 8 }}, {{ 254 }, { 8 }},
+	{{   1 }, { 8 }}, {{ 129 }, { 8 }}, {{  65 }, { 8 }}, {{ 193 }, { 8 }}, {{  33 }, { 8 }},
+	{{ 161 }, { 8 }}, {{  97 }, { 8 }}, {{ 225 }, { 8 }}, {{  17 }, { 8 }}, {{ 145 }, { 8 }},
+	{{  81 }, { 8 }}, {{ 209 }, { 8 }}, {{  49 }, { 8 }}, {{ 177 }, { 8 }}, {{ 113 }, { 8 }},
+	{{ 241 }, { 8 }}, {{   9 }, { 8 }}, {{ 137 }, { 8 }}, {{  73 }, { 8 }}, {{ 201 }, { 8 }},
+	{{  41 }, { 8 }}, {{ 169 }, { 8 }}, {{ 105 }, { 8 }}, {{ 233 }, { 8 }}, {{  25 }, { 8 }},
+	{{ 153 }, { 8 }}, {{  89 }, { 8 }}, {{ 217 }, { 8 }}, {{  57 }, { 8 }}, {{ 185 }, { 8 }},
+	{{ 121 }, { 8 }}, {{ 249 }, { 8 }}, {{   5 }, { 8 }}, {{ 133 }, { 8 }}, {{  69 }, { 8 }},
+	{{ 197 }, { 8 }}, {{  37 }, { 8 }}, {{ 165 }, { 8 }}, {{ 101 }, { 8 }}, {{ 229 }, { 8 }},
+	{{  21 }, { 8 }}, {{ 149 }, { 8 }}, {{  85 }, { 8 }}, {{ 213 }, { 8 }}, {{  53 }, { 8 }},
+	{{ 181 }, { 8 }}, {{ 117 }, { 8 }}, {{ 245 }, { 8 }}, {{  13 }, { 8 }}, {{ 141 }, { 8 }},
+	{{  77 }, { 8 }}, {{ 205 }, { 8 }}, {{  45 }, { 8 }}, {{ 173 }, { 8 }}, {{ 109 }, { 8 }},
+	{{ 237 }, { 8 }}, {{  29 }, { 8 }}, {{ 157 }, { 8 }}, {{  93 }, { 8 }}, {{ 221 }, { 8 }},
+	{{  61 }, { 8 }}, {{ 189 }, { 8 }}, {{ 125 }, { 8 }}, {{ 253 }, { 8 }}, {{  19 }, { 9 }},
+	{{ 275 }, { 9 }}, {{ 147 }, { 9 }}, {{ 403 }, { 9 }}, {{  83 }, { 9 }}, {{ 339 }, { 9 }},
+	{{ 211 }, { 9 }}, {{ 467 }, { 9 }}, {{  51 }, { 9 }}, {{ 307 }, { 9 }}, {{ 179 }, { 9 }},
+	{{ 435 }, { 9 }}, {{ 115 }, { 9 }}, {{ 371 }, { 9 }}, {{ 243 }, { 9 }}, {{ 499 }, { 9 }},
+	{{  11 }, { 9 }}, {{ 267 }, { 9 }}, {{ 139 }, { 9 }}, {{ 395 }, { 9 }}, {{  75 }, { 9 }},
+	{{ 331 }, { 9 }}, {{ 203 }, { 9 }}, {{ 459 }, { 9 }}, {{  43 }, { 9 }}, {{ 299 }, { 9 }},
+	{{ 171 }, { 9 }}, {{ 427 }, { 9 }}, {{ 107 }, { 9 }}, {{ 363 }, { 9 }}, {{ 235 }, { 9 }},
+	{{ 491 }, { 9 }}, {{  27 }, { 9 }}, {{ 283 }, { 9 }}, {{ 155 }, { 9 }}, {{ 411 }, { 9 }},
+	{{  91 }, { 9 }}, {{ 347 }, { 9 }}, {{ 219 }, { 9 }}, {{ 475 }, { 9 }}, {{  59 }, { 9 }},
+	{{ 315 }, { 9 }}, {{ 187 }, { 9 }}, {{ 443 }, { 9 }}, {{ 123 }, { 9 }}, {{ 379 }, { 9 }},
+	{{ 251 }, { 9 }}, {{ 507 }, { 9 }}, {{   7 }, { 9 }}, {{ 263 }, { 9 }}, {{ 135 }, { 9 }},
+	{{ 391 }, { 9 }}, {{  71 }, { 9 }}, {{ 327 }, { 9 }}, {{ 199 }, { 9 }}, {{ 455 }, { 9 }},
+	{{  39 }, { 9 }}, {{ 295 }, { 9 }}, {{ 167 }, { 9 }}, {{ 423 }, { 9 }}, {{ 103 }, { 9 }},
+	{{ 359 }, { 9 }}, {{ 231 }, { 9 }}, {{ 487 }, { 9 }}, {{  23 }, { 9 }}, {{ 279 }, { 9 }},
+	{{ 151 }, { 9 }}, {{ 407 }, { 9 }}, {{  87 }, { 9 }}, {{ 343 }, { 9 }}, {{ 215 }, { 9 }},
+	{{ 471 }, { 9 }}, {{  55 }, { 9 }}, {{ 311 }, { 9 }}, {{ 183 }, { 9 }}, {{ 439 }, { 9 }},
+	{{ 119 }, { 9 }}, {{ 375 }, { 9 }}, {{ 247 }, { 9 }}, {{ 503 }, { 9 }}, {{  15 }, { 9 }},
+	{{ 271 }, { 9 }}, {{ 143 }, { 9 }}, {{ 399 }, { 9 }}, {{  79 }, { 9 }}, {{ 335 }, { 9 }},
+	{{ 207 }, { 9 }}, {{ 463 }, { 9 }}, {{  47 }, { 9 }}, {{ 303 }, { 9 }}, {{ 175 }, { 9 }},
+	{{ 431 }, { 9 }}, {{ 111 }, { 9 }}, {{ 367 }, { 9 }}, {{ 239 }, { 9 }}, {{ 495 }, { 9 }},
+	{{  31 }, { 9 }}, {{ 287 }, { 9 }}, {{ 159 }, { 9 }}, {{ 415 }, { 9 }}, {{  95 }, { 9 }},
+	{{ 351 }, { 9 }}, {{ 223 }, { 9 }}, {{ 479 }, { 9 }}, {{  63 }, { 9 }}, {{ 319 }, { 9 }},
+	{{ 191 }, { 9 }}, {{ 447 }, { 9 }}, {{ 127 }, { 9 }}, {{ 383 }, { 9 }}, {{ 255 }, { 9 }},
+	{{ 511 }, { 9 }}, {{   0 }, { 7 }}, {{  64 }, { 7 }}, {{  32 }, { 7 }}, {{  96 }, { 7 }},
+	{{  16 }, { 7 }}, {{  80 }, { 7 }}, {{  48 }, { 7 }}, {{ 112 }, { 7 }}, {{   8 }, { 7 }},
+	{{  72 }, { 7 }}, {{  40 }, { 7 }}, {{ 104 }, { 7 }}, {{  24 }, { 7 }}, {{  88 }, { 7 }},
+	{{  56 }, { 7 }}, {{ 120 }, { 7 }}, {{   4 }, { 7 }}, {{  68 }, { 7 }}, {{  36 }, { 7 }},
+	{{ 100 }, { 7 }}, {{  20 }, { 7 }}, {{  84 }, { 7 }}, {{  52 }, { 7 }}, {{ 116 }, { 7 }},
+	{{   3 }, { 8 }}, {{ 131 }, { 8 }}, {{  67 }, { 8 }}, {{ 195 }, { 8 }}, {{  35 }, { 8 }},
+	{{ 163 }, { 8 }}, {{  99 }, { 8 }}, {{ 227 }, { 8 }}	 	 	    	   	   		  
+};
+
+// The static distance tree. (Actually a trivial tree since all codes use 5 bits.)
+static const ct_data static_dtree[D_CODES] = 
+{
+	{{  0 }, { 5 }}, {{ 16 }, { 5 }}, {{  8 },{ 5 }}, {{ 24 },{ 5 }}, {{  4 },{ 5 }},
+	{{ 20 }, { 5 }}, {{ 12 }, { 5 }}, {{ 28 },{ 5 }}, {{  2 },{ 5 }}, {{ 18 },{ 5 }},
+	{{ 10 }, { 5 }}, {{ 26 }, { 5 }}, {{  6 },{ 5 }}, {{ 22 },{ 5 }}, {{ 14 },{ 5 }},
+	{{ 30 }, { 5 }}, {{  1 }, { 5 }}, {{ 17 },{ 5 }}, {{  9 },{ 5 }}, {{ 25 },{ 5 }},
+	{{  5 }, { 5 }}, {{ 21 }, { 5 }}, {{ 13 },{ 5 }}, {{ 29 },{ 5 }}, {{  3 },{ 5 }},
+	{{ 19 }, { 5 }}, {{ 11 }, { 5 }}, {{ 27 },{ 5 }}, {{  7 },{ 5 }}, {{ 23 },{ 5 }}
+};
+
+// Distance codes. The first 256 values correspond to the distances
+// 3 .. 258, the last 256 values correspond to the top 8 bits of
+// the 15 bit distances.
+static const byte tr_dist_code[DIST_CODE_LEN] = 
+{
+	 0,  1,  2,  3,  4,  4,  5,  5,  6,  6,  6,  6,  7,  7,  7,  7,  8,  8,  8,  8,
+	 8,  8,  8,  8,  9,  9,  9,  9,  9,  9,  9,  9, 10, 10, 10, 10, 10, 10, 10, 10,
+	10, 10, 10, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+	11, 11, 11, 11, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+	12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 13, 13, 13, 13,
+	13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+	13, 13, 13, 13, 13, 13, 13, 13, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+	14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+	14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+	14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 15, 15, 15, 15, 15, 15, 15, 15,
+	15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+	15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+	15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,  0,  0, 16, 17,
+	18, 18, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 22, 22, 22, 22, 22, 22, 22, 22,
+	23, 23, 23, 23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
+	24, 24, 24, 24, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
+	26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
+	26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 27,
+	27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
+	27, 27, 27, 27, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
+	28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
+	28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
+	28, 28, 28, 28, 28, 28, 28, 28, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+	29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+	29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+	29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29
+};
+
+// length code for each normalized match length (0 == MIN_MATCH)
+static const byte tr_length_code[MAX_MATCH - MIN_MATCH + 1] = 
+{
+	 0,  1,  2,  3,  4,  5,  6,  7,  8,  8,  9,  9, 10, 10, 11, 11, 12, 12, 12, 12,
+	13, 13, 13, 13, 14, 14, 14, 14, 15, 15, 15, 15, 16, 16, 16, 16, 16, 16, 16, 16,
+	17, 17, 17, 17, 17, 17, 17, 17, 18, 18, 18, 18, 18, 18, 18, 18, 19, 19, 19, 19,
+	19, 19, 19, 19, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20,
+	21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 22, 22, 22, 22,
+	22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 23, 23, 23, 23, 23, 23, 23, 23,
+	23, 23, 23, 23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
+	24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
+	25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
+	25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 26, 26, 26, 26, 26, 26, 26, 26,
+	26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
+	26, 26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
+	27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 28
+};
+
+// First normalized length for each code (0 = MIN_MATCH)
+static const int base_length[LENGTH_CODES] = 
+{
+	0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 12, 14, 16, 20, 24, 28, 32, 40, 48, 56,
+	64, 80, 96, 112, 128, 160, 192, 224, 0
+};
+
+// First normalized distance for each code (0 = distance of 1)
+static const int base_dist[D_CODES] = 
+{
+    0,     1,     2,     3,     4,     6,     8,    12,    16,    24,
+   32,    48,    64,    96,   128,   192,   256,   384,   512,   768,
+ 1024,  1536,  2048,  3072,  4096,  6144,  8192, 12288, 16384, 24576
+};
+
+// Note: the deflate() code requires max_lazy >= MIN_MATCH and max_chain >= 4
+// For deflate_fast() (levels <= 3) good is ignored and lazy has a different
+// meaning.
+static block_state deflate_stored(deflate_state *s, EFlush flush);
+static block_state deflate_fast(deflate_state *s, EFlush flush);
+static block_state deflate_slow(deflate_state *s, EFlush flush);
+
+// Values for max_lazy_match, good_match and max_chain_length, depending on
+// the desired pack level (0..9). The values given below have been tuned to
+// exclude worst case performance for pathological files. Better values may be
+// found for specific files.
+static const config configuration_table[10] = 
+{
+  // good lazy nice chain
+	{ 0,    0,   0,    0, deflate_stored },		// store only
+
+	{ 4,    4,   8,    4, deflate_fast },		// maximum speed, no lazy matches
+	{ 4,    5,  16,    8, deflate_fast },
+	{ 4,    6,  32,   32, deflate_fast },
+		  
+	{ 4,    4,  16,   16, deflate_slow },		// lazy matches
+	{ 8,   16,  32,   32, deflate_slow },
+	{ 8,   16, 128,  128, deflate_slow },
+	{ 8,   32, 128,  256, deflate_slow },
+	{ 32, 128, 258, 1024, deflate_slow },
+	{ 32, 258, 258, 4096, deflate_slow }		// maximum compression
+}; 
+
+// extra bits for each length code
+static ulong extra_lbits[LENGTH_CODES] = 
+{
+	0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0
+};
+
+// Extra bits for distance codes
+const ulong extra_dbits[D_CODES] = 
+{ 
+	0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6,	7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13
+};
+
+// extra bits for each bit length code
+static ulong extra_blbits[BL_CODES] = 
+{
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3, 7
+};
+
+// The lengths of the bit length codes are sent in order of decreasing
+// probability, to avoid transmitting the lengths for unused bit length codes.
+static const byte bl_order[BL_CODES] = 
+{
+	16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15
+};
+
+static static_tree_desc static_l_desc = 
+{
+	static_ltree, extra_lbits, LITERALS + 1, L_CODES, MAX_WBITS
+};
+
+static static_tree_desc static_d_desc = 
+{
+	static_dtree, extra_dbits, 0, D_CODES, MAX_WBITS
+};
+
+static static_tree_desc static_bl_desc = 
+{
+	NULL, extra_blbits, 0, BL_CODES, MAX_BL_BITS
+};
+
+// ===============================================================================
+// Output bytes to the output stream. Inlined for speed
+// ===============================================================================
+
+inline void put_byte(deflate_state *s, const byte c)
+{
+	s->pending_buf[s->pending++] = c;
+}
+
+// Fixme: write as 1 short
+inline void put_short(deflate_state *s, const word w)
+{
+	s->pending_buf[s->pending++] = (byte)(w & 0xff);
+	s->pending_buf[s->pending++] = (byte)(w >> 8);
+}
+
+inline void put_shortMSB(deflate_state *s, const word w)
+{
+	s->pending_buf[s->pending++] = (byte)(w >> 8);
+	s->pending_buf[s->pending++] = (byte)(w & 0xff);
+}   
+
+inline void put_longMSB(deflate_state *s, const ulong l)
+{
+    s->pending_buf[s->pending++] = (byte)(l >> 24);
+    s->pending_buf[s->pending++] = (byte)(l >> 16);
+    s->pending_buf[s->pending++] = (byte)(l >> 8);
+    s->pending_buf[s->pending++] = (byte)(l & 0xff);
+}   
+
+// ===============================================================================
+// Send a value on a given number of bits.
+// IN assertion: length <= 16 and value fits in length bits.
+// ===============================================================================
+
+static void send_bits(deflate_state *s, const ulong val, const ulong len)
+{
+	assert(len <= 16);
+	assert(val <= 65536);
+
+	if(s->bi_valid > (BUF_SIZE - len)) 
+	{
+		s->bi_buf |= val << s->bi_valid;
+		put_short(s, s->bi_buf);
+		s->bi_buf = (word)(val >> (BUF_SIZE - s->bi_valid));
+		s->bi_valid += len - BUF_SIZE;
+	}
+	else
+	{
+		s->bi_buf |= val << s->bi_valid;
+		s->bi_valid += len;
+	}
+}
+
+// ===============================================================================
+// Initialize a new block.
+// ===============================================================================
+
+static void init_block(deflate_state *s)
+{
+    int		n;						// iterates over tree elements
+
+    // Initialize the trees.
+    for(n = 0; n < L_CODES;  n++) 
+	{
+		s->dyn_ltree[n].fc.freq = 0;
+	}
+    for(n = 0; n < D_CODES;  n++) 
+	{
+		s->dyn_dtree[n].fc.freq = 0;
+	}
+    for(n = 0; n < BL_CODES; n++) 
+	{
+		s->bl_tree[n].fc.freq = 0;
+	}
+    s->dyn_ltree[END_BLOCK].fc.freq = 1;
+    s->opt_len = 0;
+	s->static_len = 0;
+    s->last_lit = 0;
+	s->matches = 0;
+}
+
+// ===============================================================================
+// Initialize the tree data structures for a new zlib stream.
+// ===============================================================================
+
+static void tr_init(deflate_state *s)
+{
+    s->l_desc.dyn_tree = s->dyn_ltree;
+    s->l_desc.stat_desc = &static_l_desc;
+
+    s->d_desc.dyn_tree = s->dyn_dtree;
+    s->d_desc.stat_desc = &static_d_desc;
+
+    s->bl_desc.dyn_tree = s->bl_tree;
+    s->bl_desc.stat_desc = &static_bl_desc;
+
+    s->bi_buf = 0;
+    s->bi_valid = 0;
+	// enough lookahead for inflate
+    s->last_eob_len = 8; 
+
+    // Initialize the first block of the first file:
+    init_block(s);
+}
+
+// ===============================================================================
+// Compares to subtrees, using the tree depth as tie breaker when
+// the subtrees have equal frequency. This minimizes the worst case length.
+// ===============================================================================
+
+static bool smaller(ct_data *tree, ulong son, ulong daughter, byte *depth)
+{
+	if(tree[son].fc.freq < tree[daughter].fc.freq)
+	{
+		return(true);
+	}
+	if((tree[son].fc.freq == tree[daughter].fc.freq) && (depth[son] <= depth[daughter]))
+	{
+		return(true);
+	}
+	return(false);
+}
+
+// ===============================================================================
+// Restore the heap property by moving down the tree starting at node k,
+// exchanging a node with the smallest of its two sons if necessary, stopping
+// when the heap property is re-established (each father smaller than its
+// two sons).
+// ===============================================================================
+
+static void pqdownheap(deflate_state *s, ct_data *tree, ulong node)
+{
+    ulong	base; 
+    ulong	sibling;				// left son of node
+
+	base = s->heap[node];
+	sibling = node << 1;
+
+    while(sibling <= s->heap_len) 
+	{
+        // Set sibling to the smallest of the two children
+        if((sibling < s->heap_len) && smaller(tree, s->heap[sibling + 1], s->heap[sibling], s->depth)) 
+		{
+            sibling++;
+        }
+        // Exit if base is smaller than both sons
+        if(smaller(tree, base, s->heap[sibling], s->depth)) 
+		{
+			break;
+		}
+        // Exchange base with the smallest son
+        s->heap[node] = s->heap[sibling];  
+		node = sibling;
+
+        // And continue down the tree, setting sibling to the left son of base
+        sibling <<= 1;
+    }
+    s->heap[node] = base;
+}
+
+// ===============================================================================
+// Compute the optimal bit lengths for a tree and update the total bit length
+// for the current block.
+// IN assertion: the fields freq and dad are set, heap[heap_max] and
+//    above are the tree nodes sorted by increasing frequency.
+// OUT assertions: the field len is set to the optimal bit length, the
+//     array bl_count contains the frequencies for each bit length.
+//     The length opt_len is updated; static_len is also updated if stree is
+//     not null.
+// ===============================================================================
+
+static void gen_bitlen(deflate_state *s, tree_desc *desc)
+{
+    const ct_data	*stree;
+    const ulong		*extra;
+    ulong			base;
+    ulong			max_length;
+    ulong			heapIdx;		// heap index
+    ulong			n, m;			// iterate over the tree elements
+    ulong			bits;			// bit length
+    ulong			xbits;			// extra bits
+    word			freq;			// frequency
+    ulong			overflow;		// number of elements with bit length too large
+
+    stree = desc->stat_desc->static_tree;
+    extra = desc->stat_desc->extra_bits;
+    base = desc->stat_desc->extra_base;
+    max_length = desc->stat_desc->max_length;
+	overflow = 0;
+
+    for(bits = 0; bits <= MAX_WBITS; bits++) 
+	{
+		s->bl_count[bits] = 0;
+	}
+
+    // In a first pass, compute the optimal bit lengths (which may
+    // overflow in the case of the bit length tree).
+	// root of the heap
+    desc->dyn_tree[s->heap[s->heap_max]].dl.len = 0;
+
+    for(heapIdx = s->heap_max + 1; heapIdx < HEAP_SIZE; heapIdx++) 
+	{
+        n = s->heap[heapIdx];
+        bits = desc->dyn_tree[desc->dyn_tree[n].dl.dad].dl.len + 1;
+        if(bits > max_length)
+		{
+			bits = max_length;
+			overflow++;
+		}
+        // We overwrite tree[n].dl.dad which is no longer needed
+        desc->dyn_tree[n].dl.len = (word)bits;
+
+		// not a leaf node
+        if(n > desc->max_code) 
+		{
+			continue; 
+		}
+
+        s->bl_count[bits]++;
+        xbits = 0;
+        if(n >= base) 
+		{
+			xbits = extra[n - base];
+		}
+        freq = desc->dyn_tree[n].fc.freq;
+        s->opt_len += freq * (bits + xbits);
+        if(stree) 
+		{
+			s->static_len += freq * (stree[n].dl.len + xbits);
+		}
+    }
+    if(!overflow) 
+	{
+		return;
+	}
+
+    // Find the first bit length which could increase
+    do 
+	{
+        bits = max_length - 1;
+        while(!s->bl_count[bits]) 
+		{
+			bits--;
+		}
+		// move one leaf down the tree
+        s->bl_count[bits]--;      
+		// move one overflow item as its brother
+        s->bl_count[bits + 1] += 2;
+        // The brother of the overflow item also moves one step up,
+        // but this does not affect bl_count[max_length]
+        s->bl_count[max_length]--;
+        overflow -= 2;
+    } 
+	while(overflow > 0);
+
+    // Now recompute all bit lengths, scanning in increasing frequency.
+    // heapIdx is still equal to HEAP_SIZE. (It is simpler to reconstruct all
+    // lengths instead of fixing only the wrong ones. This idea is taken
+    // from 'ar' written by Haruhiko Okumura.)
+    for(bits = max_length; bits; bits--) 
+	{
+        n = s->bl_count[bits];
+        while(n) 
+		{
+            m = s->heap[--heapIdx];
+            if(m > desc->max_code) 
+			{
+				continue;
+			}
+            if(desc->dyn_tree[m].dl.len != bits) 
+			{
+                s->opt_len += (bits - desc->dyn_tree[m].dl.len) * desc->dyn_tree[m].fc.freq;
+                desc->dyn_tree[m].dl.len = (word)bits;
+            }
+            n--;
+        }
+    }
+}
+
+// ===============================================================================
+// Flush the bit buffer and align the output on a byte boundary
+// ===============================================================================
+
+static void bi_windup(deflate_state *s)
+{
+    if(s->bi_valid > 8) 
+	{
+        put_short(s, s->bi_buf);
+    } 
+	else if(s->bi_valid > 0) 
+	{
+        put_byte(s, (byte)s->bi_buf);
+    }
+    s->bi_buf = 0;
+    s->bi_valid = 0;
+}
+
+// ===============================================================================
+// Reverse the first len bits of a code, using straightforward code (a faster
+// method would use a table)
+// ===============================================================================
+
+static ulong bi_reverse(ulong code, ulong len)
+{
+    ulong	res;
+
+	assert(1 <= len);
+	assert(len <= 15);
+
+    res = 0;
+    do 
+	{
+        res |= code & 1;
+        code >>= 1;
+		res <<= 1;
+    } 
+	while(--len > 0);
+
+    return(res >> 1);
+}
+
+// ===============================================================================
+// Generate the codes for a given tree and bit counts (which need not be optimal).
+// IN assertion: the array bl_count contains the bit length statistics for
+// the given tree and the field len is set for all tree elements.
+// OUT assertion: the field code is set for all tree elements of non zero code length.
+// ===============================================================================
+
+static void gen_codes(ct_data *tree, ulong max_code, word *bl_count)
+{
+    word	next_code[MAX_WBITS + 1];	// next code value for each bit length
+    word	code;						// running code value
+    ulong	bits;						// bit index
+    ulong	codes;						// code index
+	ulong	len;
+
+    // The distribution counts are first used to generate the code values
+    // without bit reversal.
+	code = 0;
+    for(bits = 1; bits <= MAX_WBITS; bits++) 
+	{
+		code = (word)((code + bl_count[bits - 1]) << 1);
+        next_code[bits] = code;
+    }
+
+    // Check that the bit counts in bl_count are consistent. The last code
+    // must be all ones.
+    for(codes = 0; codes <= max_code; codes++) 
+	{
+        len = tree[codes].dl.len;
+
+        if(!len) 
+		{
+			continue;
+		}
+        // Now reverse the bits
+        tree[codes].fc.code = (word)bi_reverse(next_code[len]++, len);
+    }
+}
+
+// ===============================================================================
+// Construct one Huffman tree and assigns the code bit strings and lengths.
+// Update the total bit length for the current block.
+// IN assertion: the field freq is set for all tree elements.
+// OUT assertions: the fields len and code are set to the optimal bit length
+//     and corresponding code. The length opt_len is updated; static_len is
+//     also updated if stree is not null. The field max_code is set.
+// ===============================================================================
+
+static void build_tree(deflate_state *s, tree_desc *desc)
+{
+    ct_data			*tree;
+    const ct_data	*stree;
+    ulong			elems;
+    ulong			n, m;	 		// iterate over heap elements
+    ulong			max_code;		// largest code with non zero frequency
+    ulong			node;			// new node being created
+
+    tree = desc->dyn_tree;
+    stree = desc->stat_desc->static_tree;
+    elems = desc->stat_desc->elems;
+	max_code = 0;
+
+    // Construct the initial heap, with least frequent element in
+    // heap[SMALLEST]. The sons of heap[n] are heap[2*n] and heap[2*n+1].
+    // heap[0] is not used.
+    s->heap_len = 0;
+	s->heap_max = HEAP_SIZE;
+
+    for(n = 0; n < elems; n++) 
+	{
+        if(tree[n].fc.freq) 
+		{
+			max_code = n;
+            s->heap[++s->heap_len] = n;
+            s->depth[n] = 0;
+        } 
+		else 
+		{
+            tree[n].dl.len = 0;
+        }
+    }
+
+    // The pkzip format requires that at least one distance code exists,
+    // and that at least one bit should be sent even if there is only one
+    // possible code. So to avoid special checks later on we force at least
+    // two codes of non zero frequency.
+    while(s->heap_len < 2) 
+	{
+		s->heap[++s->heap_len] = (max_code < 2 ? ++max_code : 0);
+        node = s->heap[s->heap_len];
+        tree[node].fc.freq = 1;
+        s->depth[node] = 0;
+        s->opt_len--; 
+		if(stree) 
+		{
+			s->static_len -= stree[node].dl.len;
+		}
+        // node is 0 or 1 so it does not have extra bits
+    }
+    desc->max_code = max_code;
+
+    // The elements heap[heap_len/2+1 .. heap_len] are leaves of the tree,
+    // establish sub-heaps of increasing lengths:
+    for(n = s->heap_len >> 1; n >= 1; n--) 
+	{
+		pqdownheap(s, tree, n);
+	}
+
+    // Construct the Huffman tree by repeatedly combining the least two
+    // frequent nodes.
+
+	// next internal node of the tree
+    node = elems;              
+    do 
+	{
+	    n = s->heap[SMALLEST];
+		s->heap[SMALLEST] = s->heap[s->heap_len--];
+		pqdownheap(s, tree, SMALLEST);
+        m = s->heap[SMALLEST];						// m = node of next least frequency
+
+        s->heap[--s->heap_max] = n;					// keep the nodes sorted by frequency
+        s->heap[--s->heap_max] = m;
+
+        // Create a new node father of n and m
+        tree[node].fc.freq = (word)(tree[n].fc.freq + tree[m].fc.freq);
+		if(s->depth[n] > s->depth[m])
+		{
+			s->depth[node] = s->depth[n];
+		}
+		else
+		{
+			s->depth[node] = s->depth[m];
+			s->depth[node]++;
+		}
+		tree[m].dl.dad = (word)node;
+        tree[n].dl.dad = (word)node;
+
+        // and insert the new node in the heap
+        s->heap[SMALLEST] = node++;
+        pqdownheap(s, tree, SMALLEST);
+    } 
+	while(s->heap_len >= 2);
+
+    s->heap[--s->heap_max] = s->heap[SMALLEST];
+
+    // At this point, the fields freq and dad are set. We can now
+    // generate the bit lengths.
+    gen_bitlen(s, desc);
+
+    // The field len is now set, we can generate the bit codes
+    gen_codes (tree, max_code, s->bl_count);
+}
+
+// ===============================================================================
+// Scan a literal or distance tree to determine the frequencies of the codes
+// in the bit length tree.
+// ===============================================================================
+
+static void scan_tree (deflate_state *s, ct_data *tree, ulong max_code)
+{
+    ulong 	n;						// iterates over all tree elements
+    ulong	prevlen;				// last emitted length
+    ulong	curlen;					// length of current code
+    ulong	nextlen;				// length of next code
+    ulong	count;					// repeat count of the current code
+    ulong	max_count;				// max repeat count
+    ulong	min_count;				// min repeat count
+
+    prevlen = 0xffff;
+    nextlen = tree[0].dl.len;
+    count = 0;
+    max_count = 7;
+    min_count = 4;
+
+    if(!nextlen) 
+	{
+		max_count = 138;
+		min_count = 3;
+	}
+	// guard
+    tree[max_code + 1].dl.len = (word)prevlen; 
+
+    for(n = 0; n <= max_code; n++) 
+	{
+        curlen = nextlen; 
+		nextlen = tree[n + 1].dl.len;
+        if((++count < max_count) && (curlen == nextlen)) 
+		{
+            continue;
+        }
+		else if(count < min_count) 
+		{
+            s->bl_tree[curlen].fc.freq += (word)count;
+        } 
+		else if(curlen) 
+		{
+            if(curlen != prevlen) 
+			{
+				s->bl_tree[curlen].fc.freq++;
+			}
+            s->bl_tree[REP_3_6].fc.freq++;
+        } 
+		else if(count <= 10) 
+		{
+            s->bl_tree[REPZ_3_10].fc.freq++;
+        } 
+		else 
+		{
+            s->bl_tree[REPZ_11_138].fc.freq++;
+        }
+        count = 0; 
+		prevlen = curlen;
+        if(!nextlen) 
+		{
+            max_count = 138;
+			min_count = 3;
+        } 
+		else if(curlen == nextlen) 
+		{
+            max_count = 6;
+			min_count = 3;
+        } 
+		else 
+		{
+            max_count = 7;
+			min_count = 4;
+        }
+    }
+}
+
+// ===============================================================================
+// Send a literal or distance tree in compressed form, using the codes in bl_tree.
+// ===============================================================================
+
+static void send_tree(deflate_state *s, ct_data *tree, ulong max_code)
+{
+    ulong	n;						// iterates over all tree elements
+    ulong	prevlen;				// last emitted length
+    ulong	curlen;					// length of current code
+    ulong	nextlen;				// length of next code
+    ulong	count;					// repeat count of the current code
+    ulong	max_count;				// max repeat count
+    ulong	min_count;				// min repeat count
+
+    prevlen = 0xffff;
+    nextlen = tree[0].dl.len;
+    count = 0;
+    max_count = 7;
+    min_count = 4;
+
+    if(!nextlen)
+	{
+		max_count = 138;
+		min_count = 3;
+	}
+
+    for(n = 0; n <= max_code; n++) 
+	{
+        curlen = nextlen; 
+		nextlen = tree[n + 1].dl.len;
+        if((++count < max_count) && (curlen == nextlen))
+		{
+            continue;
+        } 
+		else if(count < min_count) 
+		{
+            do 
+			{ 
+				send_bits(s, s->bl_tree[curlen].fc.code, s->bl_tree[curlen].dl.len);
+			} 
+			while(--count);
+
+        } 
+		else if(curlen) 
+		{
+            if(curlen != prevlen) 
+			{
+				send_bits(s, s->bl_tree[curlen].fc.code, s->bl_tree[curlen].dl.len);
+				count--;
+            }
+			send_bits(s, s->bl_tree[REP_3_6].fc.code, s->bl_tree[REP_3_6].dl.len);
+			send_bits(s, count - 3, 2);
+
+        } 
+		else if(count <= 10) 
+		{
+			send_bits(s, s->bl_tree[REPZ_3_10].fc.code, s->bl_tree[REPZ_3_10].dl.len);
+			send_bits(s, count - 3, 3);
+
+        } 
+		else 
+		{
+			send_bits(s, s->bl_tree[REPZ_11_138].fc.code, s->bl_tree[REPZ_11_138].dl.len);
+			send_bits(s, count - 11, 7);
+        }
+        count = 0; 
+		prevlen = curlen;
+        if(!nextlen) 
+		{
+            max_count = 138;
+			min_count = 3;
+        } 
+		else if(curlen == nextlen) 
+		{
+            max_count = 6;
+			min_count = 3;
+        } 
+		else 
+		{
+            max_count = 7;
+			min_count = 4;
+        }
+    }
+}
+
+// ===============================================================================
+// Construct the Huffman tree for the bit lengths and return the index in
+// bl_order of the last bit length code to send.
+// ===============================================================================
+
+static ulong build_bl_tree(deflate_state *s)
+{
+    ulong	max_blindex;			// index of last bit length code of non zero freq
+
+    // Determine the bit length frequencies for literal and distance trees
+    scan_tree(s, s->dyn_ltree, s->l_desc.max_code);
+    scan_tree(s, s->dyn_dtree, s->d_desc.max_code);
+
+    // Build the bit length tree
+    build_tree(s, &s->bl_desc);
+    // opt_len now includes the length of the tree representations, except
+    // the lengths of the bit lengths codes and the 5+5+4 bits for the counts.
+
+    // Determine the number of bit length codes to send. The pkzip format
+    // requires that at least 4 bit length codes be sent. (appnote.txt says
+    // 3 but the actual value used is 4.)
+    for(max_blindex = BL_CODES - 1; max_blindex >= 3; max_blindex--) 
+	{
+        if(s->bl_tree[bl_order[max_blindex]].dl.len)
+		{
+			break;
+		}
+    }
+    // Update opt_len to include the bit length tree and counts
+    s->opt_len += 3 * (max_blindex + 1) + 5 + 5 + 4;
+    return(max_blindex);
+}
+
+// ===========================================================================
+// Send the header for a block using dynamic Huffman trees: the counts, the
+// lengths of the bit length codes, the literal tree and the distance tree.
+// IN assertion: lcodes >= 257, dcodes >= 1, blcodes >= 4.
+// ===========================================================================
+
+static void send_all_trees(deflate_state *s, ulong lcodes, ulong dcodes, ulong blcodes)
+{
+    ulong	rank;				// index in bl_order
+
+	// not +255 as stated in appnote.txt
+    send_bits(s, lcodes - 257, 5); 
+    send_bits(s, dcodes - 1, 5);
+	// not -3 as stated in appnote.txt
+    send_bits(s, blcodes - 4, 4); 
+
+    for(rank = 0; rank < blcodes; rank++) 
+	{
+        send_bits(s, s->bl_tree[bl_order[rank]].dl.len, 3);
+    }
+
+	// literal tree
+    send_tree(s, (ct_data *)s->dyn_ltree, lcodes - 1); 
+	// distance tree
+    send_tree(s, (ct_data *)s->dyn_dtree, dcodes - 1); 
+}
+
+// ===========================================================================
+// Send the block data compressed using the given Huffman trees
+// ===========================================================================
+
+static void compress_block(deflate_state *s, const ct_data *ltree, const ct_data *dtree)
+{
+    ulong	dist;					// distance of matched string
+    ulong	lenCount;				// match length or unmatched char (if dist == 0)
+    ulong	lenIdx;					// running index in l_buf
+    ulong	code;					// the code to send
+    ulong	extra;					// number of extra bits to send
+
+	lenIdx = 0;
+    if(s->last_lit) 
+	{
+		do 
+		{
+			dist = s->d_buf[lenIdx];
+			lenCount = s->l_buf[lenIdx++];
+			if(!dist) 
+			{
+				// send a literal byte
+				send_bits(s, ltree[lenCount].fc.code, ltree[lenCount].dl.len);
+			} 
+			else 
+			{
+				// Here, lenCount is the match length - MIN_MATCH
+				code = tr_length_code[lenCount];
+				// send the length code
+				send_bits(s, ltree[code + LITERALS + 1].fc.code, ltree[code + LITERALS + 1].dl.len);
+				extra = extra_lbits[code];
+				if(extra) 
+				{
+					lenCount -= base_length[code];
+					// send the extra length bits
+					send_bits(s, lenCount, extra);       
+				}
+				// dist is now the match distance - 1
+				dist--; 
+				code = (dist < 256 ? tr_dist_code[dist] : tr_dist_code[256 + (dist >> 7)]);
+
+				// send the distance code
+				send_bits(s, dtree[code].fc.code, dtree[code].dl.len);
+				extra = extra_dbits[code];
+				if(extra) 
+				{
+					dist -= base_dist[code];
+					// send the extra distance bits
+					send_bits(s, dist, extra);   
+				}
+			}
+		} 
+		while(lenIdx < s->last_lit);
+	}
+
+	send_bits(s, ltree[END_BLOCK].fc.code, ltree[END_BLOCK].dl.len);
+    s->last_eob_len = ltree[END_BLOCK].dl.len;
+}
+
+// ===========================================================================
+// Send a stored block
+// ===========================================================================
+
+static void tr_stored_block(deflate_state *s, const byte *buf, ulong stored_len, bool eof)
+{
+	// send block type
+    send_bits(s, (STORED_BLOCK << 1) + (ulong)eof, 3);
+
+	// align on byte boundary
+    bi_windup(s);        
+	// enough lookahead for inflate
+    s->last_eob_len = 8; 
+
+	put_short(s, (word)stored_len);   
+	put_short(s, (word)~stored_len);
+
+    while(stored_len--)
+	{
+        put_byte(s, *buf++);
+    }
+}
+
+// ===========================================================================
+// Determine the best encoding for the current block: dynamic trees, static
+// trees or store, and output the encoded block to the zip file.
+// ===========================================================================
+
+static void tr_flush_block(deflate_state *s, const byte *buf, ulong stored_len, bool eof)
+{
+    ulong	opt_lenb;
+    ulong	static_lenb;
+    ulong	max_blindex;			// index of last bit length code of non zero freq
+
+    max_blindex = 0;
+
+    // Build the Huffman trees unless a stored block is forced
+    if(s->level > 0) 
+	{
+		// Construct the literal and distance trees
+		build_tree(s, &s->l_desc);
+		build_tree(s, &s->d_desc);
+		// At this point, opt_len and static_len are the total bit lengths of
+		// the compressed block data, excluding the tree representations.
+
+		// Build the bit length tree for the above two trees, and get the index
+		// in bl_order of the last bit length code to send.
+		max_blindex = build_bl_tree(s);
+
+		// Determine the best encoding. Compute first the block length in bytes
+		opt_lenb = (s->opt_len + 3 + 7) >> 3;
+		static_lenb = (s->static_len + 3 + 7) >> 3;
+
+		if(static_lenb <= opt_lenb) 
+		{
+			opt_lenb = static_lenb;
+		}
+    } 
+	else 
+	{
+		static_lenb = stored_len + 5;
+		// force a stored block
+		opt_lenb = static_lenb;		
+    }
+
+    if(stored_len + 4 <= opt_lenb && buf) 
+	{
+		// 4: two words for the lengths
+        // The test buf != NULL is only necessary if LIT_BUFSIZE > WSIZE.
+        // Otherwise we can't have processed more than WSIZE input bytes since
+        // the last block flush, because compression would have been
+        // successful. If LIT_BUFSIZE <= WSIZE, it is never too late to
+        // transform a block into a stored block.
+        tr_stored_block(s, buf, stored_len, eof);
+
+    } 
+	else if(static_lenb == opt_lenb) 
+	{
+        send_bits(s, (STATIC_TREES << 1) + (ulong)eof, 3);
+        compress_block(s, static_ltree, static_dtree);
+    } 
+	else 
+	{
+        send_bits(s, (DYN_TREES << 1) + (ulong)eof, 3);
+        send_all_trees(s, s->l_desc.max_code + 1, s->d_desc.max_code + 1, max_blindex + 1);
+        compress_block(s, s->dyn_ltree, s->dyn_dtree);
+    }
+
+    // The above check is made mod 2^32, for files larger than 512 MB
+    // and uLong implemented on 32 bits.
+    init_block(s);
+
+    if(eof) 
+	{
+        bi_windup(s);
+    }
+}
+
+// ===============================================================================
+// ===============================================================================
+
+inline bool tr_tally_lit(deflate_state *s, byte c)
+{
+	s->d_buf[s->last_lit] = 0;
+	s->l_buf[s->last_lit++] = c;
+	s->dyn_ltree[c].fc.freq++;
+
+	return(s->last_lit == LIT_BUFSIZE - 1);
+}
+
+// ===============================================================================
+// ===============================================================================
+
+inline bool tr_tally_dist(deflate_state *s, ulong dist, ulong len)
+{ 
+	assert(dist < 65536);
+	assert(len < 256);
+
+	dist &= 0xffff;
+	len &= 0xff;
+
+    s->d_buf[s->last_lit] = (word)dist;
+    s->l_buf[s->last_lit++] = (byte)len;
+    dist--;
+    s->dyn_ltree[tr_length_code[len] + LITERALS + 1].fc.freq++;
+    s->dyn_dtree[(dist < 256 ? tr_dist_code[dist] : tr_dist_code[256 + (dist >> 7)])].fc.freq++;
+
+    return(s->last_lit == LIT_BUFSIZE - 1);
+}
+
+// ===============================================================================
+// Insert string str in the dictionary and set match_head to the previous head
+// of the hash chain (the most recent string with same hash key). Return
+// the previous length of the hash chain.
+// If this file is compiled with -DFASTEST, the compression level is forced
+// to 1, and no hash chains are maintained.
+// IN  assertion: all calls to to INSERT_STRING are made with consecutive
+//    input characters and the first MIN_MATCH bytes of str are valid
+//    (except for the last MIN_MATCH-1 bytes of the input file).
+// ===============================================================================
+
+inline void insert_string(deflate_state *s, ulong str, ulong &match_head)
+{
+	s->ins_h = ((s->ins_h << HASH_SHIFT) ^ s->window[str + (MIN_MATCH - 1)]) & HASH_MASK;
+	match_head = s->head[s->ins_h];
+    s->prev[str & WINDOW_MASK] = s->head[s->ins_h]; 
+    s->head[s->ins_h] = (word)str;
+}
+
+// ===========================================================================
+// Initialize the "longest match" routines for a new zlib stream
+// ===========================================================================
+
+static void lm_init(deflate_state *s)
+{
+    s->head[HASH_SIZE - 1] = NULL;
+    memset(s->head, 0, (HASH_SIZE - 1) * sizeof(*s->head));
+
+    // Set the default configuration parameters:
+    s->max_lazy_match = configuration_table[s->level].max_lazy;
+    s->good_match = configuration_table[s->level].good_length;
+    s->nice_match = configuration_table[s->level].nice_length;
+    s->max_chain_length = configuration_table[s->level].max_chain;
+
+    s->strstart = 0;
+    s->block_start = 0;
+    s->lookahead = 0;
+	s->prev_length = MIN_MATCH - 1;
+    s->match_length = MIN_MATCH - 1;
+    s->match_available = 0;
+    s->ins_h = 0;
+}
+
+// ===========================================================================
+// Set match_start to the longest match starting at the given string and
+// return its length. Matches shorter or equal to prev_length are discarded,
+// in which case the result is equal to prev_length and match_start is
+// garbage.
+// IN assertions: cur_match is the head of the hash chain for the current
+//  string (strstart) and its distance is <= MAX_DIST, and prev_length >= 1
+// OUT assertion: the match length is not greater than s->lookahead.
+// ===========================================================================
+
+inline byte *qcmp(byte *scan, byte *match, ulong count)
+{
+	byte	*retval;
+	_asm
+	{
+		push	esi
+		push	edi
+		push	ecx
+
+		mov		esi, [scan]
+		mov		edi, [match]
+		mov		ecx, [count]
+		repe	cmpsb
+
+		pop		ecx
+		pop		edi
+		mov		[retval], esi
+		pop		esi
+	}
+	return(--retval);
+}
+
+static ulong longest_match(deflate_state *s, ulong cur_match)
+{
+	ulong	chain_length;			// max hash chain length
+	ulong	limit;
+	byte	*scan;					// current string
+	byte	*match;					// matched string
+	ulong	len;					// length of current match
+	ulong	best_len;				// best match length so far
+	ulong	nice_match;				// stop if match long enough
+    byte	scan_end1;
+    byte	scan_end;
+
+	chain_length = s->max_chain_length;
+	scan = s->window + s->strstart;
+	best_len = s->prev_length;
+	nice_match = s->nice_match;
+
+    // Stop when cur_match becomes <= limit. To simplify the code,
+    // we prevent matches with the string of window index 0.
+	limit = s->strstart > (WINDOW_SIZE - MIN_LOOKAHEAD) ? s->strstart - (WINDOW_SIZE - MIN_LOOKAHEAD) : NULL;
+
+    scan_end1 = scan[best_len - 1];
+    scan_end = scan[best_len];
+
+    // Do not waste too much time if we already have a good match:
+    if(s->prev_length >= s->good_match) 
+	{
+        chain_length >>= 2;
+    }
+    // Do not look for matches beyond the end of the input. This is necessary
+    // to make deflate deterministic.
+    if(nice_match > s->lookahead) 
+	{
+		nice_match = s->lookahead;
+	}
+    do 
+	{
+        match = s->window + cur_match;
+
+        // Skip to next match if the match length cannot increase
+        // or if the match length is less than 2:
+        if((match[best_len] != scan_end) || (match[best_len - 1] != scan_end1) || (match[0] != scan[0]) || (match[1] != scan[1]))
+		{
+			continue;
+		}
+
+        // The check at best_len-1 can be removed because it will be made
+        // again later. (This heuristic is not always a win.)
+        // It is not necessary to compare scan[2] and match[2] since they
+        // are always equal when the other bytes match, given that
+        // the hash keys are equal
+		scan = qcmp(scan + 3, match + 3, MAX_MATCH - 2);
+
+        len = scan - (s->window + s->strstart);
+        scan = s->window + s->strstart;
+
+        if(len > best_len) 
+		{
+            s->match_start = cur_match;
+            best_len = len;
+            if(len >= nice_match) 
+			{
+				break;
+			}
+            scan_end1 = scan[best_len - 1];
+            scan_end = scan[best_len];
+        }
+    } while((cur_match = s->prev[cur_match & WINDOW_MASK]) > limit && --chain_length);
+
+    if(best_len <= s->lookahead) 
+	{
+		return(best_len);
+	}
+    return(s->lookahead);
+}
+
+// ===========================================================================
+// Flush as much pending output as possible. All deflate() output goes
+// through this function so some applications may wish to modify it
+// to avoid allocating a large z->next_out buffer and copying into it.
+// (See also read_buf()).
+// ===========================================================================
+
+static void flush_pending(z_stream *z)
+{
+    ulong	len = z->dstate->pending;
+
+    if(len > z->avail_out) 
+	{
+		len = z->avail_out;
+	}
+    if(!len) 
+	{
+		return;
+	}
+	assert(len <= MAX_BLOCK_SIZE + 5);
+	assert(z->dstate->pending_out + len <= z->dstate->pending_buf + MAX_BLOCK_SIZE + 5);
+
+    memcpy(z->next_out, z->dstate->pending_out, len);
+    z->next_out += len;
+	z->total_out += len;
+    z->dstate->pending_out += len;
+    z->avail_out -= len;
+    z->dstate->pending -= len;
+    if(!z->dstate->pending) 
+	{
+        z->dstate->pending_out = z->dstate->pending_buf;
+    }
+}
+
+// ===========================================================================
+// Read a new buffer from the current input stream, update the adler32
+// and total number of bytes read.  All deflate() input goes through
+// this function so some applications may wish to modify it to avoid
+// allocating a large z->next_in buffer and copying from it.
+// (See also flush_pending()).
+// ===========================================================================
+
+static ulong read_buf(z_stream *z, byte *buf, ulong size)
+{
+    ulong	len;
+
+    len = z->avail_in;
+    if(len > size)
+	{
+		len = size;
+	}
+    if(!len) 
+	{
+		return(0);
+	}
+    z->avail_in -= len;
+
+	if(!z->dstate->noheader)
+	{
+        z->dstate->adler = adler32(z->dstate->adler, z->next_in, len);
+	}
+    memcpy(buf, z->next_in, len);
+    z->next_in += len;
+    return(len);
+}
+
+// ===========================================================================
+// Fill the window when the lookahead becomes insufficient.
+// Updates strstart and lookahead.
+//
+// IN assertion: lookahead < MIN_LOOKAHEAD
+// OUT assertions: strstart <= BIG_WINDOW_SIZE - MIN_LOOKAHEAD
+//    At least one byte has been read, or avail_in == 0; reads are
+//    performed for at least two bytes (required for the zip translate_eol
+//    option -- not supported here).
+// ===========================================================================
+
+static void fill_window(deflate_state *s)
+{
+	ulong		n, m;
+	word		*p;
+    ulong		more;				// Amount of free space at the end of the window.
+
+    do 
+	{
+        more = BIG_WINDOW_SIZE - s->lookahead - s->strstart;
+
+		if(s->strstart >= WINDOW_SIZE + (WINDOW_SIZE - MIN_LOOKAHEAD)) 
+		{
+            memcpy(s->window, s->window + WINDOW_SIZE, WINDOW_SIZE);
+            s->match_start -= WINDOW_SIZE;
+			// Make strstart >= MAX_DIST
+            s->strstart -= WINDOW_SIZE;					
+            s->block_start -= WINDOW_SIZE;
+
+			// Slide the hash table (could be avoided with 32 bit values
+            // at the expense of memory usage). We slide even when level == 0
+            // to keep the hash table consistent if we switch back to level > 0
+            // later. (Using level 0 permanently is not an optimal usage of
+            // zlib, so we don't care about this pathological case.)
+			n = HASH_SIZE;
+			p = &s->head[n];
+			do
+			{
+				m = *--p;
+				*p = (word)(m >= WINDOW_SIZE ? m - WINDOW_SIZE : 0);
+			}
+			while(--n);
+
+			n = WINDOW_SIZE;
+			p = &s->prev[n];
+			do
+			{
+				m = *--p;
+				*p = (word)(m >= WINDOW_SIZE ? m - WINDOW_SIZE : 0);
+				// If n is not on any hash chain, prev[n] is garbage but
+				// its value will never be used.
+			}
+			while(--n);
+
+            more += WINDOW_SIZE;
+        }
+		if(!s->z->avail_in)
+		{
+			return;
+		}
+
+        // If there was no sliding:
+        //    strstart <= WSIZE+MAX_DIST-1 && lookahead <= MIN_LOOKAHEAD - 1 &&
+        //    more == BIG_WINDOW_SIZE - lookahead - strstart
+        // => more >= BIG_WINDOW_SIZE - (MIN_LOOKAHEAD-1 + WSIZE + MAX_DIST-1)
+        // => more >= BIG_WINDOW_SIZE- 2*WSIZE + 2
+        // If there was sliding, more >= WSIZE. So in all cases, more >= 2.
+        n = read_buf(s->z, s->window + s->strstart + s->lookahead, more);
+        s->lookahead += n;
+
+        // Initialize the hash value now that we have some input:
+        if(s->lookahead >= MIN_MATCH) 
+		{
+			s->ins_h = ((s->window[s->strstart] << HASH_SHIFT) ^ s->window[s->strstart + 1]) & HASH_MASK;
+        }
+        // If the whole input has less than MIN_MATCH bytes, ins_h is garbage,
+        // but this is not important since only literal bytes will be emitted.
+    } 
+	while(s->lookahead < MIN_LOOKAHEAD && s->z->avail_in);
+}
+
+// ===========================================================================
+// Flush the current block, with given end-of-file flag.
+// IN assertion: strstart is set to the end of the current match.
+// ===========================================================================
+
+inline void flush_block_only(deflate_state *s, bool eof)
+{
+	if(s->block_start >= 0)
+	{
+		tr_flush_block(s, &s->window[s->block_start], s->strstart - s->block_start, eof);
+	}
+	else
+	{
+		tr_flush_block(s, 0, s->strstart - s->block_start, eof);
+	}
+   s->block_start = s->strstart;
+   flush_pending(s->z);
+}
+
+// ===========================================================================
+// Copy without compression as much as possible from the input stream, return
+// the current block state.
+// This function does not insert new strings in the dictionary since
+// uncompressible data is probably not useful. This function is used
+// only for the level=0 compression option.
+// NOTE: this function should be optimized to avoid extra copying from
+// window to pending_buf.
+// ===========================================================================
+
+static block_state deflate_stored(deflate_state *s, EFlush flush)
+{
+    // Stored blocks are limited to 0xffff bytes, pending_buf is limited
+    // to pending_buf_size, and each stored block has a 5 byte header:
+    ulong	max_start;
+
+    // Copy as much as possible from input to output:
+    while(true) 
+	{
+        // Fill the window as much as possible
+        if(s->lookahead <= 1) 
+		{
+            fill_window(s);
+            if(!s->lookahead && (flush == Z_NO_FLUSH))
+			{
+				return(NEED_MORE);
+			}
+            if(!s->lookahead) 
+			{
+				// flush the current block
+				break;
+			}
+        }
+		s->strstart += s->lookahead;
+		s->lookahead = 0;
+
+		// Emit a stored block if pending_buf will be full
+		max_start = s->block_start + MAX_BLOCK_SIZE;
+        if(!s->strstart || (s->strstart >= max_start))
+		{
+			// strstart == 0 is possible when wraparound on 16-bit machine
+			s->lookahead = s->strstart - max_start;
+			s->strstart = max_start;
+			flush_block_only(s, false);
+			if(!s->z->avail_out)
+			{
+				return(NEED_MORE);
+			}
+		}
+		// Flush if we may have to slide, otherwise block_start may become
+        // negative and the data will be gone:
+		if(s->strstart - s->block_start >= WINDOW_SIZE - MIN_LOOKAHEAD) 
+		{
+			flush_block_only(s, false);
+			if(!s->z->avail_out)
+			{
+				return(NEED_MORE);
+			}
+		}
+    }
+	flush_block_only(s, flush == Z_FINISH);
+	if(!s->z->avail_out)
+	{
+		return((flush == Z_FINISH) ? FINISH_STARTED : NEED_MORE);
+	}
+    return(flush == Z_FINISH ? FINISH_DONE : BLOCK_DONE);
+}
+
+// ===========================================================================
+// Compress as much as possible from the input stream, return the current block state.
+// This function does not perform lazy evaluation of matches and inserts
+// new strings in the dictionary only for unmatched strings or for short
+// matches. It is used only for the fast compression options.
+// ===========================================================================
+
+static block_state deflate_fast(deflate_state *s, EFlush flush)
+{
+    ulong		hash_head;			// head of the hash chain
+    bool		bflush;	 			// set if current block must be flushed
+
+    hash_head = 0;
+    while(true)
+	{
+        // Make sure that we always have enough lookahead, except
+        // at the end of the input file. We need MAX_MATCH bytes
+        // for the next match, plus MIN_MATCH bytes to insert the
+        // string following the next match.
+        if(s->lookahead < MIN_LOOKAHEAD) 
+		{
+            fill_window(s);
+            if((s->lookahead < MIN_LOOKAHEAD) && (flush == Z_NO_FLUSH))
+			{
+		        return(NEED_MORE);
+			}
+            if(!s->lookahead) 
+			{
+				// flush the current block
+				break; 
+			}
+        }
+
+        // Insert the string window[strstart .. strstart+2] in the
+        // dictionary, and set hash_head to the head of the hash chain:
+        if(s->lookahead >= MIN_MATCH) 
+		{
+            insert_string(s, s->strstart, hash_head);
+        }
+
+        // Find the longest match, discarding those <= prev_length.
+        // At this point we have always match_length < MIN_MATCH
+        if(hash_head && (s->strstart - hash_head <= WINDOW_SIZE - MIN_LOOKAHEAD)) 
+		{
+            // To simplify the code, we prevent matches with the string
+            // of window index 0 (in particular we have to avoid a match
+            // of the string with itself at the start of the input file).
+			s->match_length = longest_match(s, hash_head);
+            // longest_match() sets match_start
+        }
+        if(s->match_length >= MIN_MATCH) 
+		{
+			s->z->quality++;
+
+            bflush = tr_tally_dist(s, s->strstart - s->match_start, s->match_length - MIN_MATCH);
+            s->lookahead -= s->match_length;
+
+            // Insert new strings in the hash table only if the match length
+            // is not too large. This saves time but degrades compression.
+            if((s->match_length <= s->max_lazy_match) && (s->lookahead >= MIN_MATCH))
+			{
+				// string at strstart already in hash table
+                s->match_length--; 
+                do 
+				{
+                    // strstart never exceeds WSIZE-MAX_MATCH, so there are
+                    // always MIN_MATCH bytes ahead.
+                    s->strstart++;
+                    insert_string(s, s->strstart, hash_head);
+                } 
+				while(--s->match_length);
+                s->strstart++; 
+            } 
+			else
+			{
+				s->z->quality++;
+
+                s->strstart += s->match_length;
+                s->match_length = 0;
+				s->ins_h = ((s->window[s->strstart] << HASH_SHIFT) ^ s->window[s->strstart + 1]) & HASH_MASK;
+                // If lookahead < MIN_MATCH, ins_h is garbage, but it does not
+                // matter since it will be recomputed at next deflate call.
+            }
+        } 
+		else 
+		{
+            // No match, output a literal byte
+            bflush = tr_tally_lit(s, s->window[s->strstart]);
+            s->lookahead--;
+            s->strstart++; 
+        }
+        if(bflush) 
+		{
+			flush_block_only(s, false);
+			if(!s->z->avail_out)
+			{
+				return(NEED_MORE);
+			}
+		}
+    }
+	flush_block_only(s, flush == Z_FINISH);
+	if(!s->z->avail_out)
+	{
+		return(flush == Z_FINISH ? FINISH_STARTED : NEED_MORE);
+	}
+    return(flush == Z_FINISH ? FINISH_DONE : BLOCK_DONE);
+}
+
+// ===========================================================================
+// Same as above, but achieves better compression. We use a lazy
+// evaluation for matches: a match is finally adopted only if there is
+// no better match at the next window position.
+// ===========================================================================
+
+static block_state deflate_slow(deflate_state *s, EFlush flush)
+{
+    ulong		hash_head;			// head of hash chain
+	ulong		max_insert;
+    bool		bflush;				// set if current block must be flushed
+
+    hash_head = 0;
+    // Process the input block.
+    while(true) 
+	{
+        // Make sure that we always have enough lookahead, except
+        // at the end of the input file. We need MAX_MATCH bytes
+        // for the next match, plus MIN_MATCH bytes to insert the
+        // string following the next match.
+        if(s->lookahead < MIN_LOOKAHEAD) 
+		{
+            fill_window(s);
+            if((s->lookahead < MIN_LOOKAHEAD) && (flush == Z_NO_FLUSH))
+			{
+				return(NEED_MORE);
+			}
+            if(!s->lookahead) 
+			{
+				// flush the current block
+				break; 
+			}
+        }
+
+        // Insert the string window[strstart .. strstart+2] in the
+        // dictionary, and set hash_head to the head of the hash chain:
+        if(s->lookahead >= MIN_MATCH) 
+		{
+            insert_string(s, s->strstart, hash_head);
+        }
+
+        // Find the longest match, discarding those <= prev_length.
+        s->prev_length = s->match_length;
+		s->prev_match = s->match_start;
+        s->match_length = MIN_MATCH - 1;
+
+        if(hash_head && (s->prev_length < s->max_lazy_match) && (s->strstart - hash_head <= WINDOW_SIZE - MIN_LOOKAHEAD)) 
+		{
+            // To simplify the code, we prevent matches with the string
+            // of window index 0 (in particular we have to avoid a match
+            // of the string with itself at the start of the input file).
+			// longest_match() sets match_start
+			s->match_length = longest_match(s, hash_head);
+
+            if((s->match_length <= 5) && ((s->match_length == MIN_MATCH) && (s->strstart - s->match_start > TOO_FAR))) 
+			{
+                // If prev_match is also MIN_MATCH, match_start is garbage
+                // but we will ignore the current match anyway.
+                s->match_length = MIN_MATCH - 1;
+            }
+        }
+        // If there was a match at the previous step and the current
+        // match is not better, output the previous match:
+        if((s->prev_length >= MIN_MATCH) && (s->match_length <= s->prev_length))
+		{
+            // Do not insert strings in hash table beyond this.
+			max_insert = s->strstart + s->lookahead - MIN_MATCH;
+
+            bflush = tr_tally_dist(s, s->strstart - 1 - s->prev_match, s->prev_length - MIN_MATCH);
+
+            // Insert in hash table all strings up to the end of the match.
+            // strstart-1 and strstart are already inserted. If there is not
+            // enough lookahead, the last two strings are not inserted in
+            // the hash table.
+            s->lookahead -= s->prev_length - 1;
+            s->prev_length -= 2;
+            do 
+			{
+                if(++s->strstart <= max_insert) 
+				{
+                    insert_string(s, s->strstart, hash_head);
+                }
+            } 
+			while(--s->prev_length);
+
+            s->match_available = 0;
+            s->match_length = MIN_MATCH - 1;
+            s->strstart++;
+
+            if(bflush) 
+			{
+				flush_block_only(s, false);
+				if(!s->z->avail_out)
+				{
+					return(NEED_MORE);
+				}
+			}
+        } 
+		else if(s->match_available)
+		{
+            // If there was no match at the previous position, output a
+            // single literal. If there was a match but the current match
+            // is longer, truncate the previous match to a single literal.
+		    bflush = tr_tally_lit(s, s->window[s->strstart - 1]);
+		    if(bflush) 
+			{
+                flush_block_only(s, false);
+            }
+            s->strstart++;
+            s->lookahead--;
+            if(!s->z->avail_out) 
+			{
+				return(NEED_MORE);
+			}
+        } 
+		else 
+		{
+            // There is no previous match to compare with, wait for
+            // the next step to decide.
+            s->match_available = 1;
+            s->strstart++;
+            s->lookahead--;
+        }
+    }
+    if(s->match_available) 
+	{
+        bflush = tr_tally_lit(s, s->window[s->strstart - 1]);
+        s->match_available = 0;
+    }
+	flush_block_only(s, flush == Z_FINISH);
+	if(!s->z->avail_out)
+	{
+		return(flush == Z_FINISH ? FINISH_STARTED : NEED_MORE);
+	}
+    return(flush == Z_FINISH ? FINISH_DONE : BLOCK_DONE);
+}
+
+// -------------------------------------------------------------------------------------------------
+// Controlling routines
+// -------------------------------------------------------------------------------------------------
+
+EStatus deflateInit(z_stream *z, ELevel level, int noWrap)
+{
+    deflate_state	*s;
+
+	assert(z);
+
+    deflate_error = "OK";
+    if((level < Z_STORE_COMPRESSION) || (level > Z_MAX_COMPRESSION)) 
+	{
+		deflate_error = "Invalid compression level";
+        return(Z_STREAM_ERROR);
+    }
+    s = (deflate_state *)Z_Malloc(sizeof(deflate_state), TAG_DEFLATE, qtrue);
+    z->dstate = (deflate_state *)s;
+    s->z = z;
+
+  	// undocumented feature: suppress zlib header
+	s->noheader = noWrap;
+    s->level = level;
+
+	z->total_out = 0;
+	z->quality = 0;
+
+    s->pending = 0;
+    s->pending_out = s->pending_buf;
+
+    s->status = s->noheader ? BUSY_STATE : INIT_STATE;
+    s->adler = 1;
+    s->last_flush = Z_NO_FLUSH;
+
+    tr_init(s);
+    lm_init(s);
+	return(Z_OK);
+}
+
+// ===========================================================================
+// Copy the source state to the destination state.
+// To simplify the source, this is not supported for 16-bit MSDOS (which
+// doesn't have enough memory anyway to duplicate compression states).
+// ===========================================================================
+
+EStatus deflateCopy(z_stream *dest, z_stream *source)
+{
+    deflate_state	*ds;
+    deflate_state	*ss;
+
+	assert(source);
+	assert(dest);
+	assert(source->dstate);
+	assert(!dest->dstate);
+
+    *dest = *source;
+
+    ss = source->dstate;
+    ds = (deflate_state *)Z_Malloc(sizeof(deflate_state), TAG_DEFLATE, qtrue);
+    dest->dstate = ds;
+    *ds = *ss;
+    ds->z = dest;
+
+    ds->pending_out = ds->pending_buf + (ss->pending_out - ss->pending_buf);
+
+    ds->l_desc.dyn_tree = ds->dyn_ltree;
+    ds->d_desc.dyn_tree = ds->dyn_dtree;
+    ds->bl_desc.dyn_tree = ds->bl_tree;
+
+    return(Z_OK);
+}
+
+// ===========================================================================
+// ===========================================================================
+
+EStatus deflate(z_stream *z, EFlush flush)
+{
+    EFlush			old_flush;		// value of flush param for previous deflate call
+    deflate_state	*s;
+	ulong			header;
+	ulong			level_flags;
+
+	assert(z);
+	assert(z->dstate);
+
+    if((flush > Z_FINISH) || (flush < Z_NO_FLUSH)) 
+	{
+		deflate_error = "Invalid flush type"; 
+        return(Z_STREAM_ERROR);
+    }
+    s = z->dstate;
+
+    if(!z->next_out || (!z->next_in && z->avail_in) || (s->status == FINISH_STATE && flush != Z_FINISH)) 
+	{
+		deflate_error = "Invalid output data"; 
+		return (Z_STREAM_ERROR);
+    }
+    if(!z->avail_out)
+	{
+		deflate_error = "No output space"; 
+		return (Z_BUF_ERROR);
+	}
+
+    old_flush = s->last_flush;
+    s->last_flush = flush;
+
+    // Write the zlib header
+    if(s->status == INIT_STATE) 
+	{
+		header = (ZF_DEFLATED + ((MAX_WBITS - 8) << 4)) << 8;
+        level_flags = (s->level - 1) >> 1;
+
+        if(level_flags > 3)
+		{
+			level_flags = 3;
+		}
+        header |= (level_flags << 6);
+
+        header += 31 - (header % 31);
+
+        s->status = BUSY_STATE;
+        put_shortMSB(s, (word)header);
+		s->adler = 1;
+    }
+
+	// Flush as much pending output as possible
+	if(s->pending)
+	{
+        flush_pending(z);
+        if(!z->avail_out)
+		{
+			// Since avail_out is 0, deflate will be called again with
+			// more output space, but possibly with both pending and
+			// avail_in equal to zero. There won't be anything to do,
+			// but this is not an error situation so make sure we
+			// return OK instead of BUF_ERROR at next call of deflate:
+			s->last_flush = Z_NEED_MORE;
+			return(Z_OK);
+		}
+
+		// Make sure there is something to do and avoid duplicate consecutive
+		// flushes. For repeated and useless calls with Z_FINISH, we keep
+		// returning Z_STREAM_END instead of Z_BUFF_ERROR.
+	}
+	else if(!z->avail_in && (flush <= old_flush) && (flush != Z_FINISH))
+	{
+		deflate_error = "No available input"; 
+		return(Z_BUF_ERROR);
+    }
+
+    // User must not provide more input after the first FINISH
+    if((s->status == FINISH_STATE) && z->avail_in)
+	{        
+		deflate_error = "Trying to finish while input available"; 
+		return(Z_BUF_ERROR);
+    }
+
+    // Start a new block or continue the current one.
+    if(z->avail_in || s->lookahead || ((flush != Z_NO_FLUSH) && (s->status != FINISH_STATE)))
+	{
+        block_state	bstate;
+
+		bstate = (*(configuration_table[s->level].func))(s, flush);
+
+        if((bstate == FINISH_STARTED) || (bstate == FINISH_DONE))
+		{
+            s->status = FINISH_STATE;
+        }
+        if((bstate == NEED_MORE) || (bstate == FINISH_STARTED))
+		{
+			if(!z->avail_out) 
+			{
+				// avoid BUF_ERROR next call, see above
+				s->last_flush = Z_NEED_MORE; 
+			}
+			return(Z_OK);
+
+			// If flush != Z_NO_FLUSH && avail_out == 0, the next call
+			// of deflate should use the same flush parameter to make sure
+			// that the flush is complete. So we don't have to output an
+			// empty block here, this will be done at next call. This also
+			// ensures that for a very small output buffer, we emit at most
+			// one empty block.
+		}
+		if(bstate == BLOCK_DONE) 
+		{
+			// FULL_FLUSH or SYNC_FLUSH
+            tr_stored_block(s, NULL, 0, false);
+
+            flush_pending(z);
+			if(!z->avail_out)
+			{
+				// avoid BUF_ERROR at next call, see above
+				s->last_flush = Z_NEED_MORE; 
+				return(Z_OK);
+			}
+		}
+	}
+
+    if(flush != Z_FINISH)
+	{
+		return(Z_OK);
+	}
+    if(s->noheader) 
+	{
+		return(Z_STREAM_END);
+	}
+
+    // Write the zlib trailer (adler32)
+    put_longMSB(s, s->adler);
+    flush_pending(z);
+
+    // If avail_out is zero, the application will call deflate again
+    // to flush the rest. Write the trailer only once!
+    s->noheader = -1; 
+    return(!!s->pending ? Z_OK : Z_STREAM_END);
+}
+
+// ===========================================================================
+// ===========================================================================
+
+EStatus deflateEnd(z_stream *z)
+{
+    int		status;
+
+	assert(z);
+	assert(z->dstate);
+
+    status = z->dstate->status;
+    if((status != INIT_STATE) && (status != BUSY_STATE) && (status != FINISH_STATE))
+	{
+		deflate_error = "Invalid state while ending";
+		return(Z_STREAM_ERROR);
+    }
+
+    Z_Free(z->dstate);
+    z->dstate = NULL;
+
+	if(status == BUSY_STATE)
+	{
+		deflate_error = "Ending while in busy state";
+		return(Z_DATA_ERROR);
+	}
+    return(Z_OK);
+}
+
+// ===========================================================================
+// ===========================================================================
+
+const char *deflateError(void)
+{
+	return(deflate_error);
+}
+
+// ===============================================================================
+// External calls
+// ===============================================================================
+
+bool DeflateFile(byte *src, ulong uncompressedSize, byte *dst, ulong maxCompressedSize, ulong *compressedSize, ELevel level, int noWrap)
+{
+	z_stream	z = { 0 };
+
+	if(deflateInit(&z, level, noWrap) != Z_OK)
+	{
+		return(false);
+	}
+
+	z.next_in = src;
+	z.avail_in = uncompressedSize;
+	z.next_out = dst;
+	z.avail_out = maxCompressedSize;
+#ifdef _TIMING
+	int temp = timeGetTime();
+#endif
+	if(deflate(&z, Z_FINISH) != Z_STREAM_END)
+	{
+		deflateEnd(&z);
+		return(false);
+	}
+#ifdef _TIMING
+	totalDeflateTime[level] += timeGetTime() - temp;
+	totalDeflateCount[level]++;
+#endif
+	if(deflateEnd(&z) != Z_OK)
+	{
+		return(false);
+	}
+	*compressedSize = z.total_out;
+	return(true);
+}
+
+// end
\ No newline at end of file
diff --git a/codemp/zlib32/deflate.h b/codemp/zlib32/deflate.h
new file mode 100644
index 0000000..1f7d4a0
--- /dev/null
+++ b/codemp/zlib32/deflate.h
@@ -0,0 +1,231 @@
+// Stream status
+#define INIT_STATE					42
+#define BUSY_STATE					113
+#define FINISH_STATE				666
+
+#define HASH_BITS					15
+#define HASH_SIZE					(1 << HASH_BITS)
+#define HASH_MASK					(HASH_SIZE - 1)
+
+// Size of match buffer for literals/lengths.  There are 4 reasons for
+// limiting lit_bufsize to 64K:
+//   - frequencies can be kept in 16 bit counters
+//   - if compression is not successful for the first block, all input
+//     data is still in the window so we can still emit a stored block even
+//     when input comes from standard input.  (This can also be done for
+//     all blocks if lit_bufsize is not greater than 32K.)
+//   - if compression is not successful for a file smaller than 64K, we can
+//     even emit a stored file instead of a stored block (saving 5 bytes).
+//     This is applicable only for zip (not gzip or zlib).
+//   - creating new Huffman trees less frequently may not provide fast
+//     adaptation to changes in the input data statistics. (Take for
+//     example a binary file with poorly compressible code followed by
+//     a highly compressible string table.) Smaller buffer sizes give
+//     fast adaptation but have of course the overhead of transmitting
+//     trees more frequently.
+//   - I can't count above 4
+#define LIT_BUFSIZE					(1 << 14)
+
+#define MAX_BLOCK_SIZE				0xffff
+
+// Number of bits by which ins_h must be shifted at each input
+// step. It must be such that after MIN_MATCH steps, the oldest
+// byte no longer takes part in the hash key.
+#define HASH_SHIFT					((HASH_BITS + MIN_MATCH - 1) / MIN_MATCH)
+
+// Matches of length 3 are discarded if their distance exceeds TOO_FAR
+#define TOO_FAR						32767
+
+// Number of length codes, not counting the special END_BLOCK code
+#define LENGTH_CODES				29
+
+// Number of codes used to transfer the bit lengths
+#define BL_CODES					19
+
+// Number of literal bytes 0..255
+#define LITERALS					256
+
+// Number of Literal or Length codes, including the END_BLOCK code
+#define L_CODES						(LITERALS + 1 + LENGTH_CODES)
+
+// See definition of array dist_code below
+#define DIST_CODE_LEN				512 
+
+// Maximum heap size
+#define HEAP_SIZE					(2 * L_CODES + 1)
+
+// Index within the heap array of least frequent node in the Huffman tree
+#define SMALLEST					1
+
+// Bit length codes must not exceed MAX_BL_BITS bits
+#define MAX_BL_BITS					7
+
+// End of block literal code
+#define END_BLOCK					256
+
+// Repeat previous bit length 3-6 times (2 bits of repeat count)
+#define REP_3_6						16
+
+// Repeat a zero length 3-10 times  (3 bits of repeat count)
+#define REPZ_3_10					17
+
+// Repeat a zero length 11-138 times  (7 bits of repeat count)
+#define REPZ_11_138					18
+
+// Number of bits used within bi_buf. (bi_buf might be implemented on
+// more than 16 bits on some systems.)
+#define BUF_SIZE					(8 * 2)
+
+// Minimum amount of lookahead, except at the end of the input file.
+// See deflate.c for comments about the MIN_MATCH+1.
+#define MIN_LOOKAHEAD				(MAX_MATCH + MIN_MATCH + 1)
+
+typedef enum 
+{
+    NEED_MORE,									// block not completed, need more input or more output
+    BLOCK_DONE,									// block flush performed
+    FINISH_STARTED,								// finish started, need only more output at next deflate
+    FINISH_DONE									// finish done, accept no more input or output
+} block_state;
+
+// Data structure describing a single value and its code string.
+typedef struct ct_data_s 
+{
+    union 
+	{
+        word  freq;								// frequency count
+        word  code;								// bit string
+    } fc;										
+    union										
+	{											
+        word  dad;								// father node in Huffman tree
+        word  len;								// length of bit string
+    } dl;										
+} ct_data;										
+												
+typedef struct static_tree_desc_s				
+{												
+    const ct_data	*static_tree; 				// static tree or NULL
+    const ulong		*extra_bits;  				// extra bits for each code or NULL
+    ulong			extra_base;	  				// base index for extra_bits
+    ulong			elems;		  				// max number of elements in the tree
+    ulong			max_length;	  				// max bit length for the codes
+} static_tree_desc;
+
+typedef struct tree_desc_s 
+{
+    ct_data 			*dyn_tree;				// the dynamic tree
+    ulong		 		max_code;				// largest code with non zero frequency
+    static_tree_desc	*stat_desc;				// the corresponding static tree
+} tree_desc;
+
+// Main structure which the deflate algorithm works from
+typedef struct deflate_state_s
+{
+    z_stream	*z;								// pointer back to this zlib stream
+    ulong		status;							// as the name implies
+												
+    EFlush		last_flush;						// value of flush param for previous deflate call
+    int 		noheader;						// suppress zlib header and adler32
+
+    byte		pending_buf[MAX_BLOCK_SIZE + 5];// output still pending
+    byte		*pending_out;					// next pending byte to output to the stream
+    ulong 		pending;						// nb of bytes in the pending buffer
+
+    // Sliding window. Input bytes are read into the second half of the window,
+    // and move to the first half later to keep a dictionary of at least wSize
+    // bytes. With this organization, matches are limited to a distance of
+    // wSize-MAX_MATCH bytes, but this ensures that IO is always
+    // performed with a length multiple of the block size. Also, it limits
+    // the window size to 64K, which is quite useful on MSDOS.
+    // To do: use the user input buffer as sliding window.
+    byte		window[WINDOW_SIZE * 2];
+
+    // Link to older string with same hash index. To limit the size of this
+    // array to 64K, this link is maintained only for the last 32K strings.
+    // An index in this array is thus a window index modulo 32K.
+    word		prev[WINDOW_SIZE];
+
+    word		head[HASH_SIZE];				// Heads of the hash chains or NULL.
+
+    ulong		ins_h;							// hash index of string to be inserted
+
+    // Window position at the beginning of the current output block. Gets
+    // negative when the window is moved backwards.
+    int			block_start;
+
+    ulong		match_length;					// length of best match
+    ulong		prev_match;						// previous match
+    ulong		match_available;				// set if previous match exists
+    ulong		strstart;						// start of string to insert
+    ulong		match_start;					// start of matching string
+    ulong		lookahead;						// number of valid bytes ahead in window
+
+    // Length of the best match at previous step. Matches not greater than this
+    // are discarded. This is used in the lazy match evaluation.
+    ulong		prev_length;
+
+    // Attempt to find a better match only when the current match is strictly
+    // smaller than this value. This mechanism is used only for compression	levels >= 4.
+    ulong		max_lazy_match;
+
+    ulong		good_match;						// Use a faster search when the previous match is longer than this
+    ulong		nice_match;						// Stop searching when current match exceeds this
+
+    // To speed up deflation, hash chains are never searched beyond this
+    // length.  A higher limit improves compression ratio but degrades the speed.
+    ulong		max_chain_length;
+
+    ELevel		level;							// compression level (0..9)
+												
+    ct_data		dyn_ltree[HEAP_SIZE];			// literal and length tree
+    ct_data		dyn_dtree[(2 * D_CODES) + 1]; 	// distance tree
+    ct_data		bl_tree[(2 * BL_CODES) + 1];  	// Huffman tree for bit lengths
+
+    tree_desc	l_desc;							// desc. for literal tree
+    tree_desc	d_desc;							// desc. for distance tree
+    tree_desc	bl_desc;						// desc. for bit length tree
+
+    word		bl_count[MAX_WBITS + 1];		// number of codes at each bit length for an optimal tree
+
+    // The sons of heap[n] are heap[2*n] and heap[2*n+1]. heap[0] is not used.
+    // The same heap array is used to build all trees.
+    ulong		heap[(2 * L_CODES) + 1];		// heap used to build the Huffman trees
+    ulong		heap_len;						// number of elements in the heap
+    ulong		heap_max;						// element of largest frequency
+
+    byte		depth[(2 * L_CODES) + 1];		// Depth of each subtree used as tie breaker for trees of equal frequency
+
+    byte		l_buf[LIT_BUFSIZE];				// buffer for literals or lengths
+
+    ulong		last_lit;						// running index in l_buf
+
+    // Buffer for distances. To simplify the code, d_buf and l_buf have
+    // the same number of elements. To use different lengths, an extra flag
+    // array would be necessary.
+    word		d_buf[LIT_BUFSIZE];
+ 
+	ulong		opt_len;						// bit length of current block with optimal trees
+    ulong		static_len;						// bit length of current block with static trees
+    ulong		matches;						// number of string matches in current block
+    ulong		last_eob_len;					// bit length of EOB code for last block
+
+    word		bi_buf;							// Output buffer. bits are inserted starting at the bottom (least significant bits).
+    ulong		bi_valid;						// Number of valid bits in bi_buf.  All bits above the last valid bit are always zero.
+
+	ulong		adler;
+} deflate_state;
+
+// Compression function. Returns the block state after the call.
+typedef block_state (*compress_func) (deflate_state *s, EFlush flush);
+
+typedef struct config_s 
+{
+   word				good_length;				// reduce lazy search above this match length
+   word				max_lazy;					// do not perform lazy search above this match length
+   word				nice_length;				// quit search above this match length
+   word				max_chain;
+   compress_func	func;
+} config;
+
+// end						
\ No newline at end of file
diff --git a/codemp/zlib32/inflate.cpp b/codemp/zlib32/inflate.cpp
new file mode 100644
index 0000000..887bb23
--- /dev/null
+++ b/codemp/zlib32/inflate.cpp
@@ -0,0 +1,1839 @@
+#include "../game/q_shared.h"
+#include "../qcommon/qcommon.h"
+
+#include "zip.h"
+#include "inflate.h"
+
+#ifdef _TIMING
+int		totalInflateTime;
+int		totalInflateCount;
+#endif
+
+// If you use the zlib library in a product, an acknowledgment is welcome
+// in the documentation of your product. If for some reason you cannot
+// include such an acknowledgment, I would appreciate that you keep this
+// copyright string in the executable of your product.
+const char inflate_copyright[] = "Inflate 1.1.3 Copyright 1995-1998 Mark Adler ";
+
+static const char *inflate_error = "OK";
+
+//	int inflate(z_stream *strm);
+//
+//    inflate decompresses as much data as possible, and stops when the input
+//  buffer becomes empty or the output buffer becomes full. It may some
+//  introduce some output latency (reading input without producing any output)
+//  except when forced to flush.
+//
+//  The detailed semantics are as follows. inflate performs one or both of the
+//  following actions:
+//
+//  - Decompress more input starting at next_in and update next_in and avail_in
+//    accordingly. If not all input can be processed (because there is not
+//    enough room in the output buffer), next_in is updated and processing
+//    will resume at this point for the next call of inflate().
+//
+//  - Provide more output starting at next_out and update next_out and avail_out
+//    accordingly.  inflate() provides as much output as possible, until there
+//    is no more input data or no more space in the output buffer (see below
+//    about the flush parameter).
+//
+//  Before the call of inflate(), the application should ensure that at least
+//  one of the actions is possible, by providing more input and/or consuming
+//  more output, and updating the next_* and avail_* values accordingly.
+//  The application can consume the uncompressed output when it wants, for
+//  example when the output buffer is full (avail_out == 0), or after each
+//  call of inflate(). If inflate returns Z_OK and with zero avail_out, it
+//  must be called again after making room in the output buffer because there
+//  might be more output pending.
+//
+//    If the parameter flush is set to Z_SYNC_FLUSH, inflate flushes as much
+//  output as possible to the output buffer. The flushing behavior of inflate is
+//  not specified for values of the flush parameter other than Z_SYNC_FLUSH
+//  and Z_FINISH, but the current implementation actually flushes as much output
+//  as possible anyway.
+//
+//    inflate() should normally be called until it returns Z_STREAM_END or an
+//  error. However if all decompression is to be performed in a single step
+//  (a single call of inflate), the parameter flush should be set to
+//  Z_FINISH. In this case all pending input is processed and all pending
+//  output is flushed; avail_out must be large enough to hold all the
+//  uncompressed data. (The size of the uncompressed data may have been saved
+//  by the compressor for this purpose.) The next operation on this stream must
+//  be inflateEnd to deallocate the decompression state. The use of Z_FINISH
+//  is never required, but can be used to inform inflate that a faster routine
+//  may be used for the single inflate() call.
+//
+//    It sets strm->adler to the adler32 checksum of all output produced
+//  so and returns Z_OK, Z_STREAM_END or
+//  an error code as described below. At the end of the stream, inflate()
+//  checks that its computed adler32 checksum is equal to that saved by the
+//  compressor and returns Z_STREAM_END only if the checksum is correct.
+//
+//    inflate() returns Z_OK if some progress has been made (more input processed
+//  or more output produced), Z_STREAM_END if the end of the compressed data has
+//  been reached and all uncompressed output has been produced, 
+//  Z_DATA_ERROR if the input data was
+//  corrupted (input stream not conforming to the zlib format or incorrect
+//  adler32 checksum), Z_STREAM_ERROR if the stream structure was inconsistent
+//  (for example if next_in or next_out was NULL),
+//  Z_BUF_ERROR if no progress is possible or if there was not
+//  enough room in the output buffer when Z_FINISH is used.
+
+//	int inflateEnd (z_stream *strm);
+//
+//     All dynamically allocated data structures for this stream are freed.
+//   This function discards any unprocessed input and does not flush any
+//   pending output.
+//
+//     inflateEnd returns Z_OK if success, Z_STREAM_ERROR if the stream state
+//   was inconsistent. In the error case, msg may be set but then points to a
+//   static string (which must not be deallocated).
+
+//	EStatus inflateInit(z_stream *strm, EFlush flush, int noWrap = 0);
+//
+//      inflateInit returns Z_OK if success,
+//   Z_STREAM_ERROR if a parameter is invalid.
+//   msg is set to "OK" if there is no error message. inflateInit
+//   does not perform any decompression apart from reading the zlib header if
+//   present: this will be done by inflate(). (So next_in and avail_in may be
+//   modified, but next_out and avail_out are unchanged.)
+
+//   Notes beyond the 1.93a appnote.txt:
+//
+//   1. Distance pointers never point before the beginning of the output
+//      stream.
+//   2. Distance pointers can point back across blocks, up to 32k away.
+//   3. There is an implied maximum of 7 bits for the bit length table and
+//      15 bits for the actual data.
+//   4. If only one code exists, then it is encoded using one bit.  (Zero
+//      would be more efficient, but perhaps a little confusing.)  If two
+//      codes exist, they are coded using one bit each (0 and 1).
+//   5. There is no way of sending zero distance codes--a dummy must be
+//      sent if there are none.  (History: a pre 2.0 version of PKZIP would
+//      store blocks with no distance codes, but this was discovered to be
+//      too harsh a criterion.)  Valid only for 1.93a.  2.04c does allow
+//      zero distance codes, which is sent as one code of zero bits in
+//      length.
+//   6. There are up to 286 literal/length codes.  Code 256 represents the
+//      end-of-block.  Note however that the static length tree defines
+//      288 codes just to fill out the Huffman codes.  Codes 286 and 287
+//      cannot be used though, since there is no length base or extra bits
+//      defined for them.  Similarily, there are up to 30 distance codes.
+//      However, static trees define 32 codes (all 5 bits) to fill out the
+//      Huffman codes, but the last two had better not show up in the data.
+//   7. Unzip can check dynamic Huffman blocks for complete code sets.
+//      The exception is that a single code would not be complete (see #4).
+//   8. The five bits following the block type is really the number of
+//      literal codes sent minus 257.
+//   9. Length codes 8,16,16 are interpreted as 13 length codes of 8 bits
+//      (1+6+6).  Therefore, to output three times the length, you output
+//      three codes (1+1+1), whereas to output four times the same length,
+//      you only need two codes (1+3).  Hmm.
+//  10. In the tree reconstruction algorithm, Code = Code + Increment
+//      only if BitLength(i) is not zero.  (Pretty obvious.)
+//  11. Correction: 4 Bits: # of Bit Length codes - 4     (4 - 19)
+//  12. Note: length code 284 can represent 227-258, but length code 285
+//      really is 258.  The last length deserves its own, short code
+//      since it gets used a lot in very redundant files.  The length
+//      258 is special since 258 - 3 (the min match length) is 255.
+//  13. The literal/length and distance code bit lengths are read as a
+//      single stream of lengths.  It is possible (and advantageous) for
+//      a repeat code (16, 17, or 18) to go across the boundary between
+//      the two sets of lengths.
+
+// And'ing with mask[n] masks the lower n bits
+static const ulong inflate_mask[17] = 
+{
+    0x0000,
+    0x0001, 0x0003, 0x0007, 0x000f, 0x001f, 0x003f, 0x007f, 0x00ff,
+    0x01ff, 0x03ff, 0x07ff, 0x0fff, 0x1fff, 0x3fff, 0x7fff, 0xffff
+};
+
+// Order of the bit length code lengths
+static const ulong border[] = 
+{ 
+	16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15
+};
+
+// Copy lengths for literal codes 257..285 (see note #13 above about 258)
+static const ulong cplens[31] = 
+{ 
+	3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31,
+	35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0
+};
+
+// Extra bits for literal codes 257..285 (112 == invalid)
+static const ulong cplext[31] = 
+{ 
+	0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2,
+	3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, 112, 112
+}; 
+
+// Copy offsets for distance codes 0..29
+static const ulong cpdist[30] = 
+{ 
+	1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193,
+	257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145,
+	8193, 12289, 16385, 24577
+};
+
+static ulong fixed_bl = 9;
+static ulong fixed_bd = 5;
+
+static inflate_huft_t fixed_tl[] = 
+{
+    { 96, 7, 256 }, { 0, 8, 80  }, { 0, 8, 16 }, { 84,  8, 115 },
+    { 82, 7, 31  }, { 0, 8, 112 }, { 0, 8, 48 }, { 0,   9, 192 },
+    { 80, 7, 10  }, { 0, 8, 96  }, { 0, 8, 32 }, { 0,   9, 160 },
+    { 0,  8, 0   }, { 0, 8, 128 }, { 0, 8, 64 }, { 0,   9, 224 },
+    { 80, 7, 6   }, { 0, 8, 88  }, { 0, 8, 24 }, { 0,   9, 144 },
+    { 83, 7, 59  }, { 0, 8, 120 }, { 0, 8, 56 }, { 0,   9, 208 },
+    { 81, 7, 17  }, { 0, 8, 104 }, { 0, 8, 40 }, { 0,   9, 176 },
+    { 0,  8, 8   }, { 0, 8, 136 }, { 0, 8, 72 }, { 0,   9, 240 },
+    { 80, 7, 4   }, { 0, 8, 84  }, { 0, 8, 20 }, { 85,  8, 227 },
+    { 83, 7, 43  }, { 0, 8, 116 }, { 0, 8, 52 }, { 0,   9, 200 },
+    { 81, 7, 13  }, { 0, 8, 100 }, { 0, 8, 36 }, { 0,   9, 168 },
+    { 0,  8, 4   }, { 0, 8, 132 }, { 0, 8, 68 }, { 0,   9, 232 },
+    { 80, 7, 8   }, { 0, 8, 92  }, { 0, 8, 28 }, { 0,   9, 152 },
+    { 84, 7, 83  }, { 0, 8, 124 }, { 0, 8, 60 }, { 0,   9, 216 },
+    { 82, 7, 23  }, { 0, 8, 108 }, { 0, 8, 44 }, { 0,   9, 184 },
+    { 0,  8, 12  }, { 0, 8, 140 }, { 0, 8, 76 }, { 0,   9, 248 },
+    { 80, 7, 3   }, { 0, 8, 82  }, { 0, 8, 18 }, { 85,  8, 163 },
+    { 83, 7, 35  }, { 0, 8, 114 }, { 0, 8, 50 }, { 0,   9, 196 },
+    { 81, 7, 11  }, { 0, 8, 98  }, { 0, 8, 34 }, { 0,   9, 164 },
+    { 0,  8, 2   }, { 0, 8, 130 }, { 0, 8, 66 }, { 0,   9, 228 },
+    { 80, 7, 7   }, { 0, 8, 90  }, { 0, 8, 26 }, { 0,   9, 148 },
+    { 84, 7, 67  }, { 0, 8, 122 }, { 0, 8, 58 }, { 0,   9, 212 },
+    { 82, 7, 19  }, { 0, 8, 106 }, { 0, 8, 42 }, { 0,   9, 180 },
+    { 0,  8, 10  }, { 0, 8, 138 }, { 0, 8, 74 }, { 0,   9, 244 },
+    { 80, 7, 5   }, { 0, 8, 86  }, { 0, 8, 22 }, { 192, 8, 0   }, 
+    { 83, 7, 51  }, { 0, 8, 118 }, { 0, 8, 54 }, { 0,   9, 204 },
+    { 81, 7, 15  }, { 0, 8, 102 }, { 0, 8, 38 }, { 0,   9, 172 },
+    { 0,  8, 6   }, { 0, 8, 134 }, { 0, 8, 70 }, { 0,   9, 236 },
+    { 80, 7, 9   }, { 0, 8, 94  }, { 0, 8, 30 }, { 0,   9, 156 },
+    { 84, 7, 99  }, { 0, 8, 126 }, { 0, 8, 62 }, { 0,   9, 220 },
+    { 82, 7, 27  }, { 0, 8, 110 }, { 0, 8, 46 }, { 0,   9, 188 },
+    { 0,  8, 14  }, { 0, 8, 142 }, { 0, 8, 78 }, { 0,   9, 252 },
+    { 96, 7, 256 }, { 0, 8, 81  }, { 0, 8, 17 }, { 85,  8, 131 },
+    { 82, 7, 31  }, { 0, 8, 113 }, { 0, 8, 49 }, { 0,   9, 194 },
+    { 80, 7, 10  }, { 0, 8, 97  }, { 0, 8, 33 }, { 0,   9, 162 },
+    { 0,  8, 1   }, { 0, 8, 129 }, { 0, 8, 65 }, { 0,   9, 226 },
+    { 80, 7, 6   }, { 0, 8, 89  }, { 0, 8, 25 }, { 0,   9, 146 },
+    { 83, 7, 59  }, { 0, 8, 121 }, { 0, 8, 57 }, { 0,   9, 210 },
+    { 81, 7, 17  }, { 0, 8, 105 }, { 0, 8, 41 }, { 0,   9, 178 },
+    { 0,  8, 9   }, { 0, 8, 137 }, { 0, 8, 73 }, { 0,   9, 242 },
+    { 80, 7, 4   }, { 0, 8, 85  }, { 0, 8, 21 }, { 80,  8, 258 },
+    { 83, 7, 43  }, { 0, 8, 117 }, { 0, 8, 53 }, { 0,   9, 202 },
+    { 81, 7, 13  }, { 0, 8, 101 }, { 0, 8, 37 }, { 0,   9, 170 },
+    { 0,  8, 5   }, { 0, 8, 133 }, { 0, 8, 69 }, { 0,   9, 234 },
+    { 80, 7, 8   }, { 0, 8, 93  }, { 0, 8, 29 }, { 0,   9, 154 },
+    { 84, 7, 83  }, { 0, 8, 125 }, { 0, 8, 61 }, { 0,   9, 218 },
+    { 82, 7, 23  }, { 0, 8, 109 }, { 0, 8, 45 }, { 0,   9, 186 },
+    { 0,  8, 13  }, { 0, 8, 141 }, { 0, 8, 77 }, { 0,   9, 250 },
+    { 80, 7, 3   }, { 0, 8, 83  }, { 0, 8, 19 }, { 85,  8, 195 },
+    { 83, 7, 35  }, { 0, 8, 115 }, { 0, 8, 51 }, { 0,   9, 198 },
+    { 81, 7, 11  }, { 0, 8, 99  }, { 0, 8, 35 }, { 0,   9, 166 },
+    { 0,  8, 3   }, { 0, 8, 131 }, { 0, 8, 67 }, { 0,   9, 230 },
+    { 80, 7, 7   }, { 0, 8, 91  }, { 0, 8, 27 }, { 0,   9, 150 },
+    { 84, 7, 67  }, { 0, 8, 123 }, { 0, 8, 59 }, { 0,   9, 214 },
+    { 82, 7, 19  }, { 0, 8, 107 }, { 0, 8, 43 }, { 0,   9, 182 },
+    { 0,  8, 11  }, { 0, 8, 139 }, { 0, 8, 75 }, { 0,   9, 246 },
+    { 80, 7, 5   }, { 0, 8, 87  }, { 0, 8, 23 }, { 192, 8, 0   }, 
+    { 83, 7, 51  }, { 0, 8, 119 }, { 0, 8, 55 }, { 0,   9, 206 },
+    { 81, 7, 15  }, { 0, 8, 103 }, { 0, 8, 39 }, { 0,   9, 174 },
+    { 0,  8, 7   }, { 0, 8, 135 }, { 0, 8, 71 }, { 0,   9, 238 },
+    { 80, 7, 9   }, { 0, 8, 95  }, { 0, 8, 31 }, { 0,   9, 158 },
+    { 84, 7, 99  }, { 0, 8, 127 }, { 0, 8, 63 }, { 0,   9, 222 },
+    { 82, 7, 27  }, { 0, 8, 111 }, { 0, 8, 47 }, { 0,   9, 190 },
+    { 0,  8, 15  }, { 0, 8, 143 }, { 0, 8, 79 }, { 0,   9, 254 },
+    { 96, 7, 256 }, { 0, 8, 80  }, { 0, 8, 16 }, { 84,  8, 115 },
+    { 82, 7, 31  }, { 0, 8, 112 }, { 0, 8, 48 }, { 0,   9, 193 },
+    { 80, 7, 10  }, { 0, 8, 96  }, { 0, 8, 32 }, { 0,   9, 161 },
+    { 0,  8, 0   }, { 0, 8, 128 }, { 0, 8, 64 }, { 0,   9, 225 },
+    { 80, 7, 6   }, { 0, 8, 88  }, { 0, 8, 24 }, { 0,   9, 145 },
+    { 83, 7, 59  }, { 0, 8, 120 }, { 0, 8, 56 }, { 0,   9, 209 },
+    { 81, 7, 17  }, { 0, 8, 104 }, { 0, 8, 40 }, { 0,   9, 177 },
+    { 0,  8, 8   }, { 0, 8, 136 }, { 0, 8, 72 }, { 0,   9, 241 },
+    { 80, 7, 4   }, { 0, 8, 84  }, { 0, 8, 20 }, { 85,  8, 227 },
+    { 83, 7, 43  }, { 0, 8, 116 }, { 0, 8, 52 }, { 0,   9, 201 },
+    { 81, 7, 13  }, { 0, 8, 100 }, { 0, 8, 36 }, { 0,   9, 169 },
+    { 0,  8, 4   }, { 0, 8, 132 }, { 0, 8, 68 }, { 0,   9, 233 },
+    { 80, 7, 8   }, { 0, 8, 92  }, { 0, 8, 28 }, { 0,   9, 153 },
+    { 84, 7, 83  }, { 0, 8, 124 }, { 0, 8, 60 }, { 0,   9, 217 },
+    { 82, 7, 23  }, { 0, 8, 108 }, { 0, 8, 44 }, { 0,   9, 185 },
+    { 0,  8, 12  }, { 0, 8, 140 }, { 0, 8, 76 }, { 0,   9, 249 },
+    { 80, 7, 3   }, { 0, 8, 82  }, { 0, 8, 18 }, { 85,  8, 163 },
+    { 83, 7, 35  }, { 0, 8, 114 }, { 0, 8, 50 }, { 0,   9, 197 },
+    { 81, 7, 11  }, { 0, 8, 98  }, { 0, 8, 34 }, { 0,   9, 165 },
+    { 0,  8, 2   }, { 0, 8, 130 }, { 0, 8, 66 }, { 0,   9, 229 },
+    { 80, 7, 7   }, { 0, 8, 90  }, { 0, 8, 26 }, { 0,   9, 149 },
+    { 84, 7, 67  }, { 0, 8, 122 }, { 0, 8, 58 }, { 0,   9, 213 },
+    { 82, 7, 19  }, { 0, 8, 106 }, { 0, 8, 42 }, { 0,   9, 181 },
+    { 0,  8, 10  }, { 0, 8, 138 }, { 0, 8, 74 }, { 0,   9, 245 },
+    { 80, 7, 5   }, { 0, 8, 86  }, { 0, 8, 22 }, { 192, 8, 0   }, 
+    { 83, 7, 51  }, { 0, 8, 118 }, { 0, 8, 54 }, { 0,   9, 205 },
+    { 81, 7, 15  }, { 0, 8, 102 }, { 0, 8, 38 }, { 0,   9, 173 },
+    { 0,  8, 6   }, { 0, 8, 134 }, { 0, 8, 70 }, { 0,   9, 237 },
+    { 80, 7, 9   }, { 0, 8, 94  }, { 0, 8, 30 }, { 0,   9, 157 },
+    { 84, 7, 99  }, { 0, 8, 126 }, { 0, 8, 62 }, { 0,   9, 221 },
+    { 82, 7, 27  }, { 0, 8, 110 }, { 0, 8, 46 }, { 0,   9, 189 },
+    { 0,  8, 14  }, { 0, 8, 142 }, { 0, 8, 78 }, { 0,   9, 253 },
+    { 96, 7, 256 }, { 0, 8, 81  }, { 0, 8, 17 }, { 85,  8, 131 },
+    { 82, 7, 31  }, { 0, 8, 113 }, { 0, 8, 49 }, { 0,   9, 195 },
+    { 80, 7, 10  }, { 0, 8, 97  }, { 0, 8, 33 }, { 0,   9, 163 },
+    { 0,  8, 1   }, { 0, 8, 129 }, { 0, 8, 65 }, { 0,   9, 227 },
+    { 80, 7, 6   }, { 0, 8, 89  }, { 0, 8, 25 }, { 0,   9, 147 },
+    { 83, 7, 59  }, { 0, 8, 121 }, { 0, 8, 57 }, { 0,   9, 211 },
+    { 81, 7, 17  }, { 0, 8, 105 }, { 0, 8, 41 }, { 0,   9, 179 },
+    { 0,  8, 9   }, { 0, 8, 137 }, { 0, 8, 73 }, { 0,   9, 243 },
+    { 80, 7, 4   }, { 0, 8, 85  }, { 0, 8, 21 }, { 80,  8, 258 },
+    { 83, 7, 43  }, { 0, 8, 117 }, { 0, 8, 53 }, { 0,   9, 203 },
+    { 81, 7, 13  }, { 0, 8, 101 }, { 0, 8, 37 }, { 0,   9, 171 },
+    { 0,  8, 5   }, { 0, 8, 133 }, { 0, 8, 69 }, { 0,   9, 235 },
+    { 80, 7, 8   }, { 0, 8, 93  }, { 0, 8, 29 }, { 0,   9, 155 },
+    { 84, 7, 83  }, { 0, 8, 125 }, { 0, 8, 61 }, { 0,   9, 219 },
+    { 82, 7, 23  }, { 0, 8, 109 }, { 0, 8, 45 }, { 0,   9, 187 },
+    { 0,  8, 13  }, { 0, 8, 141 }, { 0, 8, 77 }, { 0,   9, 251 },
+    { 80, 7, 3   }, { 0, 8, 83  }, { 0, 8, 19 }, { 85,  8, 195 },
+    { 83, 7, 35  }, { 0, 8, 115 }, { 0, 8, 51 }, { 0,   9, 199 },
+    { 81, 7, 11  }, { 0, 8, 99  }, { 0, 8, 35 }, { 0,   9, 167 },
+    { 0,  8, 3   }, { 0, 8, 131 }, { 0, 8, 67 }, { 0,   9, 231 },
+    { 80, 7, 7   }, { 0, 8, 91  }, { 0, 8, 27 }, { 0,   9, 151 },
+    { 84, 7, 67  }, { 0, 8, 123 }, { 0, 8, 59 }, { 0,   9, 215 },
+    { 82, 7, 19  }, { 0, 8, 107 }, { 0, 8, 43 }, { 0,   9, 183 },
+    { 0,  8, 11  }, { 0, 8, 139 }, { 0, 8, 75 }, { 0,   9, 247 },
+    { 80, 7, 5   }, { 0, 8, 87  }, { 0, 8, 23 }, { 192, 8, 0   }, 
+    { 83, 7, 51  }, { 0, 8, 119 }, { 0, 8, 55 }, { 0,   9, 207 },
+    { 81, 7, 15  }, { 0, 8, 103 }, { 0, 8, 39 }, { 0,   9, 175 },
+    { 0,  8, 7   }, { 0, 8, 135 }, { 0, 8, 71 }, { 0,   9, 239 },
+    { 80, 7, 9   }, { 0, 8, 95  }, { 0, 8, 31 }, { 0,   9, 159 },
+    { 84, 7, 99  }, { 0, 8, 127 }, { 0, 8, 63 }, { 0,   9, 223 },
+    { 82, 7, 27  }, { 0, 8, 111 }, { 0, 8, 47 }, { 0,   9, 191 },
+    { 0,  8, 15  }, { 0, 8, 143 }, { 0, 8, 79 }, { 0,   9, 255 }
+};
+
+static inflate_huft_t fixed_td[] = 
+{
+    { 80, 5, 1  }, { 87, 5, 257  }, { 83, 5, 17  }, { 91,  5, 4097  },
+    { 81, 5, 5  }, { 89, 5, 1025 }, { 85, 5, 65  }, { 93,  5, 16385 },
+    { 80, 5, 3  }, { 88, 5, 513  }, { 84, 5, 33  }, { 92,  5, 8193  },
+    { 82, 5, 9  }, { 90, 5, 2049 }, { 86, 5, 129 }, { 192, 5, 24577 },
+    { 80, 5, 2  }, { 87, 5, 385  }, { 83, 5, 25  }, { 91,  5, 6145  },
+    { 81, 5, 7  }, { 89, 5, 1537 }, { 85, 5, 97  }, { 93,  5, 24577 },
+    { 80, 5, 4  }, { 88, 5, 769  }, { 84, 5, 49  }, { 92,  5, 12289 },
+    { 82, 5, 13 }, { 90, 5, 3073 }, { 86, 5, 193 }, { 192, 5, 24577 }
+};
+
+// ===============================================================================
+// ===============================================================================
+
+static void inflate_blocks_reset(z_stream *z, inflate_blocks_state_t *s)
+{
+	if((s->mode == BTREE) || (s->mode == DTREE))
+	{
+		Z_Free(s->trees.blens);
+	}
+	if(s->mode == CODES)
+	{
+		Z_Free(s->decode.codes);
+	}
+	s->mode = TYPE;
+	s->bitk = 0;
+	s->bitb = 0;
+	s->write = s->window;
+	s->read = s->window;
+	z->istate->adler = 1;
+}
+
+// ===============================================================================
+// ===============================================================================
+
+static int inflate_blocks_free(z_stream *z, inflate_blocks_state_t *s)
+{
+	inflate_blocks_reset(z, s);
+	Z_Free(s->hufts);
+	s->hufts = NULL;
+	Z_Free(s);
+	return(Z_OK);
+}
+
+// ===============================================================================
+// ===============================================================================
+
+static inflate_blocks_state_t *inflate_blocks_new(z_stream *z, check_func check)
+{
+	inflate_blocks_state_t *s;
+
+	s = (inflate_blocks_state_t *)Z_Malloc(sizeof(inflate_blocks_state_t), TAG_INFLATE, qtrue);
+	s->hufts = (inflate_huft_t *)Z_Malloc(sizeof(inflate_huft_t) * MANY, TAG_INFLATE, qtrue);
+	s->end = s->window + WINDOW_SIZE;
+	s->mode = TYPE;
+	inflate_blocks_reset(z, s);
+
+	return(s);
+}
+
+// ===============================================================================
+// copy as much as possible from the sliding window to the output area
+// ===============================================================================
+
+static void inflate_flush_copy(z_stream *z, inflate_blocks_state_t *s, ulong count)
+{
+	if(count > z->avail_out)
+	{
+		count = z->avail_out;
+	}
+	if(count && (z->error == Z_BUF_ERROR))
+	{
+		z->error = Z_OK;
+	}
+
+	// Calculate the checksum if required
+	if(!z->istate->nowrap)
+	{
+		z->istate->adler = adler32(z->istate->adler, s->read, count);
+	}
+
+	// copy as as end of window
+	memcpy(z->next_out, s->read, count);
+
+	// update counters
+	z->avail_out -= count;
+	z->total_out += count;
+	z->next_out += count;
+	s->read += count;
+}
+
+// ===============================================================================
+// ===============================================================================
+
+static void inflate_flush(z_stream *z, inflate_blocks_state_t *s)
+{
+	ulong	count;
+
+	// compute number of bytes to copy as as end of window
+	count = (s->read <= s->write ? s->write : s->end) - s->read;
+
+	inflate_flush_copy(z, s, count);
+
+	// see if more to copy at beginning of window
+	if(s->read == s->end)
+	{
+		// wrap pointers
+		s->read = s->window;
+		if(s->write == s->end)
+		{
+			s->write = s->window;
+		}
+		// compute bytes to copy
+		count = s->write - s->read;
+		inflate_flush_copy(z, s, count);
+	}
+}
+
+// ===============================================================================
+// get bytes and bits
+// ===============================================================================
+
+static bool getbits(z_stream *z, inflate_blocks_state_t *s, ulong bits)								 
+{			
+	while(s->bitk < bits) 							
+	{											
+		if(z->avail_in)
+		{
+			z->error = Z_OK;
+		}
+		else
+		{										
+			inflate_flush(z, s);
+			return(false);
+		}		  
+		z->avail_in--;
+		z->total_in++;
+		s->bitb |= *z->next_in++ << s->bitk;			
+		s->bitk += 8; 	 
+	}		
+	return(true);
+}
+
+// ===============================================================================
+// output bytes
+// ===============================================================================
+
+static ulong needout(z_stream *z, inflate_blocks_state_t *s, ulong bytesToEnd) 
+{ 
+	if(!bytesToEnd)
+	{ 
+		if((s->write == s->end) && (s->read != s->window)) 
+		{ 
+			s->write = s->window;
+			bytesToEnd = s->write < s->read ? s->read - s->write - 1 : s->end - s->write;
+		}
+		if(!bytesToEnd)
+		{
+			inflate_flush(z, s);
+			bytesToEnd = s->write < s->read ? s->read - s->write - 1 : s->end - s->write;
+			if((s->write == s->end) && (s->read != s->window))
+			{
+				s->write = s->window;
+				bytesToEnd = s->write < s->read ? s->read - s->write - 1 : s->end - s->write;
+			}
+			if(!bytesToEnd)
+			{
+				inflate_flush(z, s);
+				return(bytesToEnd);
+			}
+		}
+	}
+	z->error = Z_OK;
+	return(bytesToEnd);
+}
+
+// ===============================================================================
+// Called with number of bytes left to write in window at least 258
+//	 (the maximum string length) and number of input bytes available
+//	 at least ten.	The ten bytes are six bytes for the longest length/
+//	 distance pair plus four bytes for overloading the bit buffer.
+// ===============================================================================
+
+inline byte *qcopy(byte *dst, byte *src, int count)
+{
+	byte 	*retval;
+	_asm
+	{
+		push ecx  
+		push esi
+		push edi
+
+		mov edi, [dst]
+		mov esi, [src]
+		mov ecx, [count]
+		rep movsb
+
+		mov [retval], edi
+		pop edi
+		pop esi
+		pop ecx
+	}
+	return(retval);
+}
+
+inline ulong get_remaining(inflate_blocks_state_t *s)
+{
+	if(s->write < s->read)
+	{
+		return(s->read - s->write - 1);
+	}
+	return(s->end - s->write); 
+}
+
+static EStatus inflate_fast(ulong lengthMask, ulong distMask, inflate_huft_t *lengthTree, inflate_huft_t *distTree, inflate_blocks_state_t *s, z_stream *z)
+{
+	inflate_huft_t	*huft;			// temporary pointer
+	byte			*data;			
+	byte			*src; 			// copy source pointer
+	byte			*dst;			
+	ulong			extraBits;		// extra bits or operation
+	ulong			bytesToEnd;		// bytes to end of window or read pointer
+	ulong			count;			// bytes to copy
+	ulong			dist;			// distance back to copy from
+	ulong			bitb;
+	ulong			bitk;
+	ulong			availin;
+	ulong			morebits;
+	ulong			copymore;
+
+	// load input, output, bit values
+	data = z->next_in;
+	dst = s->write;
+	availin = z->avail_in;
+	bitb = s->bitb;
+	bitk = s->bitk;
+
+	bytesToEnd = get_remaining(s);
+
+	// do until not enough input or output space for fast loop
+	// assume called with bytesToEnd >= 258 && availIn >= 10
+	while((bytesToEnd >= 258) && (availin >= 10))
+	{						   
+		// get literal/length code
+		while(bitk < 20)
+		{
+			bitb |= *data++ << bitk;
+			bitk += 8;
+			availin--;
+		}
+
+		huft = lengthTree + (bitb & lengthMask);
+		if(!huft->Exop)
+		{
+			bitb >>= huft->Bits;
+			bitk -= huft->Bits;
+			*dst++ = (byte)huft->base;
+			bytesToEnd--;
+		}
+		else
+		{
+			extraBits = huft->Exop;
+			morebits = 1;
+			do
+			{
+				bitb >>= huft->Bits; 
+				bitk -= huft->Bits;
+				if(extraBits & 16)
+				{
+					// get extra bits for length
+					extraBits &= 15;
+					count = huft->base + (bitb & inflate_mask[extraBits]);
+					bitb >>= extraBits;
+					bitk -= extraBits;
+					// decode distance base of block to copy
+					while(bitk < 15)
+					{
+						bitb |= *data++ << bitk;
+						bitk += 8;
+						availin--;
+					}
+					huft = distTree + (bitb & distMask);
+					extraBits = huft->Exop;
+	   				copymore = 1;
+					do
+					{
+						bitb >>= huft->Bits;
+						bitk -= huft->Bits;
+						if(extraBits & 16)
+						{
+							// get extra bits to add to distance base
+							extraBits &= 15;
+							while(bitk < extraBits)
+							{
+								bitb |= *data++ << bitk;
+								bitk += 8;
+								availin--;
+							}
+							dist = huft->base + (bitb & inflate_mask[extraBits]);
+							bitb >>= extraBits;
+							bitk -= extraBits;
+
+							// do the copy
+							bytesToEnd -= count;
+							// offset before dest
+							if((dst - s->window) >= dist)	 
+							{								   
+								// just copy
+								src = dst - dist;
+							}
+							// else offset after destination
+							else						
+							{
+								// bytes from offset to end
+								extraBits = dist - (dst - s->window);
+								// pointer to offset
+								src = s->end - extraBits; 		  
+								// if source crosses,					  
+								if(count > extraBits)				  
+								{
+									// copy to end of window
+									dst = qcopy(dst, src, extraBits);
+									// copy rest from start of window
+									count -= extraBits; 				
+									src = s->window;			
+								}
+							}
+							// copy all or what's left
+							dst = qcopy(dst, src, count);
+							copymore = 0;
+						}
+						else
+						{
+							if(!(extraBits & 64))
+							{
+								huft += huft->base + (bitb & inflate_mask[extraBits]);
+								extraBits = huft->Exop;
+							}
+							else
+							{
+								inflate_error = "Inflate data: Invalid distance code";
+								return(Z_DATA_ERROR);
+							}
+						}
+					} while(copymore);
+
+					morebits = 0;
+				}
+				else
+				{
+					if(!(extraBits & 64))
+					{
+						huft += huft->base + (bitb & inflate_mask[extraBits]);
+						extraBits = huft->Exop;
+						if(!extraBits)								   
+						{
+							bitb >>= huft->Bits;
+							bitk -= huft->Bits;
+							*dst++ = (byte)huft->base;
+							bytesToEnd--;
+							morebits = 0;
+						}
+					}
+					else if(extraBits & 32)									 
+					{
+						count = data - z->next_in;
+
+						z->avail_in = availin;
+						z->total_in += count;
+						z->next_in = data;
+
+						s->write = dst;
+
+						count = (bitk >> 3) < count ? bitk >> 3 : count;
+
+						s->bitb = bitb;
+						s->bitk = bitk - (count << 3);
+						z->avail_in += count;
+						z->total_in -= count;
+						z->next_in -= count ;
+						return(Z_STREAM_END);
+					}
+					else
+					{
+						inflate_error = "Inflate data: Invalid literal/length code";
+						return(Z_DATA_ERROR);
+					}
+				}
+			} while(morebits);
+		}
+	}
+
+	// not enough input or output--restore pointers and return
+	count = data - z->next_in;
+
+	z->avail_in = availin;
+	z->total_in += count;
+	z->next_in = data;
+
+	s->write = dst;
+
+	count = (bitk >> 3) < count ? bitk >> 3 : count;
+	s->bitb = bitb;
+	s->bitk = bitk - (count << 3);
+	z->avail_in += count;
+	z->total_in -= count;
+	z->next_in -= count;
+
+	return(Z_OK);
+}
+
+// ===============================================================================
+// ===============================================================================
+
+static void inflate_codes(z_stream *z, inflate_blocks_state_t *s)
+{
+	inflate_huft_t			*huft; 		// temporary pointer
+	ulong					extraBits;	// extra bits or operation
+	ulong					bytesToEnd;	// bytes to end of window or read pointer
+	byte					*src; 		// pointer to copy strings from
+	inflate_codes_state_t	*infCodes;	// codes state
+
+	infCodes = s->decode.codes;
+
+	// copy input/output information to locals
+	bytesToEnd = get_remaining(s);
+
+	// process input and output based on current state
+	while(true)
+	{
+		// waiting for "i:"=input, "o:"=output, "x:"=nothing
+		switch (infCodes->mode)
+		{			  
+		// x: set up for LEN
+		case START:
+			if((bytesToEnd >= 258) && (z->avail_in >= 10))
+			{
+				z->error = inflate_fast(inflate_mask[infCodes->lbits], inflate_mask[infCodes->dbits], infCodes->ltree, infCodes->dtree, s, z);
+				bytesToEnd = get_remaining(s);
+				if(z->error != Z_OK)
+				{
+					infCodes->mode = (z->error == Z_STREAM_END) ? WASH : BADCODE;
+					break;
+				}
+			}
+			infCodes->code.need = infCodes->lbits;
+			infCodes->code.tree = infCodes->ltree;
+			infCodes->mode = LEN;
+		// i: get length/literal/eob next
+		case LEN:			
+			if(!getbits(z, s, infCodes->code.need))
+			{
+				// We could get here because we have run out of input data *or* the stream has ended
+				if(z->status == Z_BUF_ERROR)
+				{
+					z->error = Z_STREAM_END;
+				}
+				return;
+			}
+			huft = infCodes->code.tree + (s->bitb & inflate_mask[infCodes->code.need]);
+			s->bitb >>= huft->Bits;
+			s->bitk -= huft->Bits; 
+			extraBits = huft->Exop;
+			// literal
+			if(!extraBits)				 
+			{
+				infCodes->lit = huft->base;
+				infCodes->mode = LIT;
+				break;
+			}
+			// length
+			if(extraBits & 16) 			  
+			{
+				infCodes->copy.get = extraBits & 15;
+				infCodes->len = huft->base;
+				infCodes->mode = LENEXT;
+				break;
+			}
+			// next table
+			if(!(extraBits & 64))
+			{
+				infCodes->code.need = extraBits;
+				infCodes->code.tree = huft + huft->base;
+				break;
+			}
+			// end of block
+			if(extraBits & 32) 			  
+			{
+				infCodes->mode = WASH;
+				break;
+			}
+			// invalid code
+			infCodes->mode = BADCODE;		  
+			inflate_error = "Inflate data: Invalid literal/length code";
+			z->error = Z_DATA_ERROR;
+			inflate_flush(z, s);
+			return;
+		// i: getting length extra (have base)
+		case LENEXT:		
+			if(!getbits(z, s, infCodes->copy.get))
+			{
+				return;
+			}
+			infCodes->len += s->bitb & inflate_mask[infCodes->copy.get];
+			s->bitb >>= infCodes->copy.get;
+			s->bitk -= infCodes->copy.get;
+			infCodes->code.need = infCodes->dbits;
+			infCodes->code.tree = infCodes->dtree;
+			infCodes->mode = DIST;
+		// i: get distance next
+		case DIST:			
+			if(!getbits(z, s, infCodes->code.need))
+			{
+				return;
+			}
+			huft = infCodes->code.tree + (s->bitb & inflate_mask[infCodes->code.need]);
+			s->bitb >>= huft->Bits;
+			s->bitk -= huft->Bits;
+			extraBits = huft->Exop;
+			// distance
+			if(extraBits & 16) 			  
+			{
+				infCodes->copy.get = extraBits & 15;
+				infCodes->copy.dist = huft->base;
+				infCodes->mode = DISTEXT;
+				break;
+			}
+			// next table
+			if(!(extraBits & 64))
+			{
+				infCodes->code.need = extraBits;
+				infCodes->code.tree = huft + huft->base;
+				break;
+			}
+			// invalid code
+			infCodes->mode = BADCODE;		  
+			inflate_error = "Inflate data: Invalid distance code";
+			z->error = Z_DATA_ERROR;
+			inflate_flush(z, s);
+			return;
+		// i: getting distance extra
+		case DISTEXT:		
+			if(!getbits(z, s, infCodes->copy.get))
+			{
+				return;
+			}
+			infCodes->copy.dist += s->bitb & inflate_mask[infCodes->copy.get];
+			s->bitb >>= infCodes->copy.get;
+			s->bitk -= infCodes->copy.get;
+			infCodes->mode = COPY;
+		// o: copying bytes in window, waiting for space
+		case COPY:			
+			if(s->write - s->window < infCodes->copy.dist)
+			{
+				src = s->end - (infCodes->copy.dist - (s->write - s->window));
+			}
+			else
+			{
+				src = s->write - infCodes->copy.dist;
+			}
+			while(infCodes->len)
+			{
+				bytesToEnd = needout(z, s, bytesToEnd);
+				if(!bytesToEnd)
+				{
+					return;
+				}
+				*s->write++ = (byte)(*src++);
+				bytesToEnd--;
+				if(src == s->end)
+				{
+					src = s->window;
+				}
+				infCodes->len--;
+			}
+			infCodes->mode = START;
+			break;
+		// o: got literal, waiting for output space
+		case LIT:			
+			bytesToEnd = needout(z, s, bytesToEnd);
+			if(!bytesToEnd)
+			{
+				return;
+			}
+			*s->write++ = (byte)infCodes->lit; 
+			bytesToEnd--;
+			infCodes->mode = START;
+			break;
+		// o: got eob, possibly more output
+		case WASH:			
+			// return unused byte, if any
+			if(s->bitk > 7)		  
+			{
+				s->bitk -= 8;
+				z->avail_in++;
+				z->total_in--;
+				// can always return one
+				z->next_in--;			
+			}
+			inflate_flush(z, s);
+			bytesToEnd = get_remaining(s);
+			if(s->read != s->write)
+			{
+				inflate_error = "Inflate data: read != write while in WASH";
+				inflate_flush(z, s);
+				return;
+			}
+			infCodes->mode = END;
+		case END:
+			z->error = Z_STREAM_END;
+			inflate_flush(z, s);
+			return;
+		// x: got error
+		case BADCODE:		
+			z->error = Z_DATA_ERROR;
+			inflate_flush(z, s);
+			return;
+		default:
+			z->error = Z_STREAM_ERROR;
+			inflate_flush(z, s);
+			return;
+		}
+	}
+}
+
+// ===============================================================================
+// ===============================================================================
+
+static inflate_codes_state_t *inflate_codes_new(z_stream *z, ulong bl, ulong bd, inflate_huft_t *lengthTree, inflate_huft_t *distTree)
+{
+	inflate_codes_state_t		*c;
+
+	c = (inflate_codes_state_t *)Z_Malloc(sizeof(inflate_codes_state_t), TAG_INFLATE, qtrue);
+	c->mode = START;
+	c->lbits = (byte)bl;
+	c->dbits = (byte)bd;
+	c->ltree = lengthTree;
+	c->dtree = distTree;
+
+	return(c);
+}
+
+// ===============================================================================
+// Generate Huffman trees for efficient decoding
+
+//	ulong b				// code lengths in bits (all assumed <= BMAX)
+//	ulong n             // number of codes (assumed <= 288)
+//	ulong s             // number of simple-valued codes (0..s-1)
+//	const ulong *d      // list of base values for non-simple codes
+//	const ulong *e      // list of extra bits for non-simple codes
+//	inflate_huft ** t	// result: starting table
+//	ulong *m            // maximum lookup bits, returns actual
+//	inflate_huft *hp    // space for trees
+//	ulong *hn           // hufts used in space
+//	ulong *workspace    // working area: values in order of bit length
+//
+//   Given a list of code lengths and a maximum table size, make a set of
+//   tables to decode that set of codes.  Return Z_OK on success, Z_BUF_ERROR
+//   if the given code set is incomplete (the tables are still built in this
+//   case), Z_DATA_ERROR if the input is invalid (an over-subscribed set of
+//   lengths).
+//
+//   Huffman code decoding is performed using a multi-level table lookup.
+//   The fastest way to decode is to simply build a lookup table whose
+//   size is determined by the longest code.  However, the time it takes
+//   to build this table can also be a factor if the data being decoded
+//   is not very long.  The most common codes are necessarily the
+//   shortest codes, so those codes dominate the decoding time, and hence
+//   the speed.  The idea is you can have a shorter table that decodes the
+//   shorter, more probable codes, and then point to subsidiary tables for
+//   the longer codes.  The time it costs to decode the longer codes is
+//   then traded against the time it takes to make longer tables.
+//
+//   This results of this trade are in the variables lbits and dbits
+//   below.  lbits is the number of bits the first level table for literal/
+//   length codes can decode in one step, and dbits is the same thing for
+//   the distance codes.  Subsequent tables are also less than or equal to
+//   those sizes.  These values may be adjusted either when all of the
+//   codes are shorter than that, in which case the longest code length in
+//   bits is used, or when the shortest code is *longer* than the requested
+//   table size, in which case the length of the shortest code in bits is
+//   used.
+//
+//   There are two different values for the two tables, since they code a
+//   different number of possibilities each.  The literal/length table
+//   codes 286 possible values, or in a flat code, a little over eight
+//   bits.  The distance table codes 30 possible values, or a little less
+//   than five bits, flat.  The optimum values for speed end up being
+//   about one bit more than those, so lbits is 8+1 and dbits is 5+1.
+//   The optimum values may differ though from machine to machine, and
+//   possibly even between compilers.  Your mileage may vary.
+// ===============================================================================
+
+static EStatus huft_build(ulong *b, ulong numCodes, ulong s, const ulong *d, const ulong *e, inflate_huft_t **t, ulong *m, inflate_huft_t *hp, ulong *hn, ulong *workspace)
+{
+	ulong			codeCounter;					// counter for codes of length bitsPerCode
+	ulong			bitLengths[BMAX + 1] = { 0 };	// bit length count table
+	ulong			bitOffsets[BMAX + 1];			// bit offsets, then code stack
+	ulong			f;								// i repeats in table every f entries
+	int 			maxCodeLen;						// maximum code length
+	int 			tableLevel;						// table level
+	ulong			i;								// counter, current code
+	ulong			j;								// counter
+	int 			bitsPerCode;					// number of bits in current code
+	ulong 			bitsPerTable;					// bits per table (returned in m)
+	int 			bitsBeforeTable;				// bits before this table == (bitsPerTable * tableLevel)
+	ulong			*p; 							// pointer into bitLengths[], b[], or workspace[]
+	inflate_huft_t	*q; 							// points to current table
+	inflate_huft_t	r;								// table entry for structure assignment
+	inflate_huft_t	*tableStack[BMAX];				// table stack
+	ulong			*xp;							// pointer into bitOffsets
+	int 			dummyCodes;						// number of dummy codes added
+	ulong			entryCount;						// number of entries in current table
+
+	// Generate counts for each bit length
+	// assume all entries <= BMAX
+	p = b;	
+	i = numCodes;
+	do
+	{
+		bitLengths[*p++]++;					
+	} while(--i);
+
+	// null input--all zero length codes
+	if(bitLengths[0] == numCodes)				  
+	{
+		*t = NULL;
+		*m = 0;
+		return(Z_OK);
+	}
+
+	// Find minimum and maximum length, bound *m by those
+	bitsPerTable = *m;
+	for(j = 1; j <= BMAX; j++)
+	{
+		if(bitLengths[j])
+		{
+			break;
+		}
+	}
+	// minimum code length
+	bitsPerCode = j;						  
+
+	if(bitsPerTable < j)
+	{
+		bitsPerTable = j;
+	}
+	for(i = BMAX; i; i--)
+	{
+		if(bitLengths[i])
+		{
+			break;
+		}
+	}
+	// maximum code length
+	maxCodeLen = i;						  
+
+	if(bitsPerTable > i)
+	{
+		bitsPerTable = i;
+	}
+	*m = bitsPerTable;
+
+	// Adjust last length count to fill out codes, if needed
+	for(dummyCodes = 1 << j; j < i; j++, dummyCodes <<= 1)
+	{
+		dummyCodes -= bitLengths[j];
+		if(dummyCodes < 0)
+		{
+			return(Z_DATA_ERROR);
+		}
+	}
+	dummyCodes -= bitLengths[i];
+	if(dummyCodes < 0)
+	{
+		return(Z_DATA_ERROR);
+	}
+	bitLengths[i] += dummyCodes;
+
+	// Generate starting offsets into the value table for each length
+	bitOffsets[1] = 0;
+	j = 0;
+	p = bitLengths + 1;
+	xp = bitOffsets + 2;
+	// note that i == maxCodeLen from above
+	while(--i) 
+	{			 
+		j += *p++;
+		*xp++ = j;
+	}
+
+	// Make a table of values in order of bit lengths
+	p = b;
+	i = 0;
+	do
+	{
+		j = *p++;
+		if(j)
+		{
+			workspace[bitOffsets[j]++] = i;
+		}
+	} while(++i < numCodes);
+
+	// set numCodes to length of workspace
+	numCodes = bitOffsets[maxCodeLen];					  
+
+	// Generate the Huffman codes and for each, make the table entries
+	bitOffsets[0] = 0;						// first Huffman code is zero
+	i = 0;							
+	p = workspace;							// grab values in bit order
+	tableLevel = -1; 						// no tables yet--level -1
+	bitsBeforeTable = bitsPerTable; 						// bits decoded == (bitsPerTable * tableLevel)
+	bitsBeforeTable = -bitsBeforeTable;
+	tableStack[0] = NULL;	// just to keep compilers happy
+	q = NULL;		// ditto
+	entryCount = 0;							// ditto
+
+	// go through the bit lengths (bitsPerCode already is bits in shortest code)
+	for(; bitsPerCode <= maxCodeLen; bitsPerCode++)
+	{
+		codeCounter = bitLengths[bitsPerCode];
+		while(codeCounter--)
+		{
+			// here i is the Huffman code of length bitsPerCode bits for value *p
+			// make tables up to required level
+			while(bitsPerCode > bitsBeforeTable + bitsPerTable)
+			{
+				tableLevel++;
+				bitsBeforeTable += bitsPerTable; 			// previous table always bitsPerTable bits
+
+				// compute minimum size table less than or equal to bitsPerTable bits
+				entryCount = maxCodeLen - bitsBeforeTable;
+				entryCount = entryCount > bitsPerTable ? bitsPerTable : entryCount;				// table size upper limit
+				j = bitsPerCode - bitsBeforeTable;
+				f = 1 << j;
+				if(f > codeCounter + 1)							// try a bitsPerCode-bitsBeforeTable bit table
+				{										// too few codes for bitsPerCode-bitsBeforeTable bit table
+					f -= codeCounter + 1; 						// deduct codes from patterns left
+					xp = bitLengths + bitsPerCode;
+					if(j < entryCount)
+					{
+						while(++j < entryCount) 					// try smaller tables up to entryCount bits
+						{
+							f <<= 1;
+							if(f <= *++xp)
+							{
+								break;					// enough codes to use up j bits
+							}
+							f -= *xp;					// else deduct codes from patterns
+						}
+					}
+				}
+				entryCount = 1 << j; 							// table entries for j-bit table
+
+				// allocate new table
+				if(*hn + entryCount > MANY) 						// (note: doesn't matter for fixed)
+				{
+					return(Z_DATA_ERROR);				// not enough memory
+				}
+				q = hp + *hn;
+				tableStack[tableLevel] = q;
+				*hn += entryCount;
+
+				// connect to last table, if there is one
+				if(tableLevel)
+				{
+					bitOffsets[tableLevel] = i;							// save pattern for backing up
+					r.Bits = (byte)bitsPerTable;   	 					// bits to dump before this table
+					r.Exop = (byte)j;									// bits in this table
+					j = i >> (bitsBeforeTable - bitsPerTable);
+					r.base = q - tableStack[tableLevel - 1] - j; // offset to this table
+					tableStack[tableLevel - 1][j] = r;					// connect to last table
+				}
+				else						   
+				{
+					*t = q; 							// first table is returned result
+				}
+			}
+
+			// set up table entry in r
+			r.Bits = (byte)(bitsPerCode - bitsBeforeTable);
+			if(p >= workspace + numCodes)
+			{
+				r.Exop = 128 + 64;						// out of values--invalid code
+			}
+			else if(*p < s)
+			{
+				r.Exop = (byte)(*p < 256 ? 0 : 32 + 64);		// 256 is end-of-block
+				r.base = *p++;							// simple code is just the value
+			}
+			else
+			{
+				r.Exop = (byte)(e[*p - s] + 16 + 64);		 	// non-simple--look up in lists
+				r.base = d[*p++ - s];
+			}
+
+			// fill code-like entries with r
+			f = 1 << (bitsPerCode - bitsBeforeTable);
+			for(j = i >> bitsBeforeTable; j < entryCount; j += f)
+			{
+				q[j] = r;
+			}
+
+			// backwards increment the bitsPerCode-bit code i
+			for(j = 1 << (bitsPerCode - 1); i & j; j >>= 1)
+			{
+				i ^= j;
+			}
+			i ^= j;
+
+			// backup over finished tables
+			while((i & ((1 << bitsBeforeTable) - 1)) != bitOffsets[tableLevel])
+			{
+				tableLevel--;									// don't need to update q
+				bitsBeforeTable -= bitsPerTable;
+			}
+		}
+	}
+
+	// Return Z_BUF_ERROR if we were given an incomplete table
+	if(dummyCodes && (maxCodeLen != 1))
+	{
+		return(Z_BUF_ERROR);
+	}
+	return(Z_OK);
+}
+
+// ===============================================================================
+// ulong *c 				19 code lengths
+// ulong *bb				bits tree desired/actual depth
+// inflate_huft **tb		bits tree result
+// inflate_huft *hp 		space for trees
+// ===============================================================================
+
+static void inflate_trees_bits(z_stream *z, ulong *c, ulong *bb, inflate_huft_t **tb, inflate_huft_t *hp)
+{
+	ulong	hn = 0;				// hufts used in space
+	ulong	workspace[19];		// work area for huft_build
+
+	z->error = huft_build(c, 19, 19, NULL, NULL, tb, bb, hp, &hn, workspace);
+	if(z->error == Z_DATA_ERROR)
+	{
+		inflate_error = "Inflate data: Oversubscribed dynamic bit lengths tree";
+	}
+	else if((z->error == Z_BUF_ERROR) || !*bb)
+	{
+		inflate_error = "Inflate data: Incomplete dynamic bit lengths tree";
+		z->error = Z_DATA_ERROR;
+	}
+}
+
+// ===============================================================================
+// ulong *c 				// that many (total) code lengths
+// ulong *bl				// literal desired/actual bit depth
+// ulong *bd				// distance desired/actual bit depth
+// inflate_huft **tl		// literal/length tree result
+// inflate_huft **td		// distance tree result
+// inflate_huft *hp 		// space for trees
+// ===============================================================================
+
+static void inflate_trees_dynamic(z_stream *z, ulong numLiteral, ulong numDist, ulong *c, ulong *bl, ulong *bd, inflate_huft_t **tl, inflate_huft_t **td, inflate_huft_t *hp)
+{
+	ulong		hn = 0;				// hufts used in space
+	ulong		workspace[288]; 	// work area for huft_build
+
+	// build literal/length tree
+	z->error = huft_build(c, numLiteral, 257, cplens, cplext, tl, bl, hp, &hn, workspace);
+	if(z->error != Z_OK || !*bl)
+	{
+		inflate_error = "Inflate data: Erroneous literal/length tree";
+		z->error = Z_DATA_ERROR;
+		return;
+	}
+	// build distance tree
+	z->error = huft_build(c + numLiteral, numDist, 0, cpdist, extra_dbits, td, bd, hp, &hn, workspace);
+	if((z->error != Z_OK) || (!*bd && numLiteral > 257))
+	{
+		inflate_error = "Inflate data: Erroneous distance tree";
+		z->error = Z_DATA_ERROR;
+		return;
+	}
+}
+
+// ===============================================================================
+// ulong *bl				// literal desired/actual bit depth
+// ulong *bd				// distance desired/actual bit depth
+// inflate_huft **tl		// literal/length tree result
+// inflate_huft **td		// distance tree result
+// ===============================================================================
+
+// Fixme: Calculate dynamically
+
+static void inflate_trees_fixed(z_stream *z, ulong *bl, ulong *bd, inflate_huft_t **tl, inflate_huft_t **td)
+{
+	*bl = fixed_bl;
+	*bd = fixed_bd;
+	*tl = fixed_tl;
+	*td = fixed_td;
+	z->error = Z_OK;
+}
+
+// ===============================================================================
+// ===============================================================================
+
+static void inflate_blocks(inflate_blocks_state_t *s, z_stream *z)
+{
+	ulong					t;				// temporary storage
+	ulong					bytesToEnd;		// bytes to end of window or read pointer
+	ulong					bl, bd;
+	inflate_huft_t			*lengthTree = NULL;
+	inflate_huft_t			*distTree = NULL;
+	inflate_codes_state_t	*c;
+
+	// copy input/output information to locals (UPDATE macro restores)
+	bytesToEnd = s->write < s->read ? s->read - s->write - 1 : s->end - s->write; 
+
+	// process input based on current state
+	while(true)
+	{
+		switch (s->mode)
+		{
+		case TYPE:
+			if(!getbits(z, s, 3))
+			{
+				return;
+			}
+			t = s->bitb & 7;
+			s->last = !!(t & 1);
+
+			switch (t >> 1)
+			{
+			case STORED_BLOCK:
+				s->bitb >>= 3;
+				s->bitk -= 3;
+				t = s->bitk & 7;				// go to byte boundary
+				s->bitb >>= t;
+				s->bitk -= t;
+				s->mode = LENS; 				// get length of stored block
+				break;
+			case STATIC_TREES:
+				inflate_trees_fixed(z, &bl, &bd, &lengthTree, &distTree);
+				s->decode.codes = inflate_codes_new(z, bl, bd, lengthTree, distTree);
+				s->bitb >>= 3;
+				s->bitk -= 3;
+				s->mode = CODES;
+				break;
+			case DYN_TREES:
+				s->bitb >>= 3;
+				s->bitk -= 3;
+				s->mode = TABLE;
+				break;
+			case MODE_ILLEGAL:
+				s->bitb >>= 3;
+				s->bitk -= 3;
+				s->mode = BAD;
+				inflate_error = "Inflate data: Invalid block type";
+				z->error = Z_DATA_ERROR;
+				inflate_flush(z, s);
+				return;
+			}
+			break;
+		case LENS:
+			if(!getbits(z, s, 32))
+			{
+				return;
+			}
+			if(((~s->bitb) >> 16) != (s->bitb & 0xffff))
+			{
+				s->mode = BAD;
+				inflate_error = "Inflate data: Invalid stored block lengths";
+				z->error = Z_DATA_ERROR;
+				inflate_flush(z, s);
+				return;
+			}
+			s->left = s->bitb & 0xffff;
+			s->bitb = 0;
+			s->bitk = 0;								// dump bits
+			s->mode = s->left ? STORED : (s->last ? DRY : TYPE);
+			break;
+		case STORED:
+			if(!z->avail_in)
+			{
+				inflate_flush(z, s);
+				return;
+			}
+			bytesToEnd = needout(z, s, bytesToEnd);
+			if(!bytesToEnd)
+			{
+				return;
+			}
+			t = s->left;
+			if(t > z->avail_in) 
+			{
+				t = z->avail_in;
+			}
+			if(t > bytesToEnd) 
+			{
+				t = bytesToEnd;
+			}
+			memcpy(s->write, z->next_in, t);
+			z->next_in += t;
+			z->avail_in -= t;
+			z->total_in += t;
+			s->write += t;
+			bytesToEnd -= t;
+			s->left -= t;
+			if(s->left)
+			{
+				break;
+			}
+			s->mode = s->last ? DRY : TYPE;
+			break;
+		case TABLE:
+			if(!getbits(z, s, 14))
+			{
+				return;
+			}
+			t = s->bitb & 0x3fff;
+			s->trees.table = t;
+			if((t & 0x1f) > 29 || ((t >> 5) & 0x1f) > 29)
+			{
+				s->mode = BAD;
+				inflate_error = "Inflate data: Too many length or distance symbols";
+				z->error = Z_DATA_ERROR;
+				inflate_flush(z, s);
+				return;
+			}
+			t = 258 + (t & 0x1f) + ((t >> 5) & 0x1f);
+			s->trees.blens = (ulong *)Z_Malloc(t * sizeof(ulong), TAG_INFLATE, qfalse);
+			s->bitb >>= 14;
+			s->bitk -= 14;
+			s->trees.index = 0;
+			s->mode = BTREE;
+		case BTREE:
+			while(s->trees.index < 4 + (s->trees.table >> 10))
+			{
+				if(!getbits(z, s, 3))
+				{
+					return;
+				}
+				s->trees.blens[border[s->trees.index++]] = s->bitb & 7;
+				s->bitb >>= 3;
+				s->bitk -= 3;
+			}
+			while(s->trees.index < 19)
+			{
+				s->trees.blens[border[s->trees.index++]] = 0;
+			}
+			s->trees.bb = 7;
+			inflate_trees_bits(z, s->trees.blens, &s->trees.bb, &s->trees.tb, s->hufts);
+			if(z->error != Z_OK)
+			{
+				Z_Free(s->trees.blens);
+				s->mode = BAD;
+				inflate_flush(z, s);
+				return;
+			}
+			s->trees.index = 0;
+			s->mode = DTREE;
+		case DTREE:
+			while(t = s->trees.table, s->trees.index < 258 + (t & 0x1f) + ((t >> 5) & 0x1f))
+			{
+				inflate_huft_t *h;
+				ulong i, j, c;
+
+				t = s->trees.bb;
+				if(!getbits(z, s, t))
+				{
+					return;
+				}
+				h = s->trees.tb + (s->bitb & inflate_mask[t]);
+				t = h->Bits;
+				c = h->base;
+				if(c < 16)
+				{
+					s->bitb >>= t;
+					s->bitk -= t;
+					s->trees.blens[s->trees.index++] = c;
+				}
+				else	// c == 16..18
+				{
+					i = (c == 18) ? 7 : c - 14;
+					j = (c == 18) ? 11 : 3;
+					if(!getbits(z, s, t + i))
+					{
+						return;
+					}
+					s->bitb >>= t;
+					s->bitk -= t;
+					j += s->bitb & inflate_mask[i];
+					s->bitb >>= i;
+					s->bitk -= i;
+					i = s->trees.index;
+					t = s->trees.table;
+					if(i + j > 258 + (t & 0x1f) + ((t >> 5) & 0x1f) || (c == 16 && i < 1))
+					{
+						Z_Free(s->trees.blens);
+						s->mode = BAD;
+						inflate_error = "Inflate data: Invalid bit length repeat";
+						z->error = Z_DATA_ERROR;
+						inflate_flush(z, s);
+						return;
+					}
+					c = (c == 16) ? s->trees.blens[i - 1] : 0;
+					do
+					{
+						s->trees.blens[i++] = c;
+					} while(--j);
+					s->trees.index = i;
+				}
+			}
+			s->trees.tb = NULL;
+
+			bl = 9; 					// must be <= 9 for lookahead assumptions
+			bd = 6; 					// must be <= 9 for lookahead assumptions
+			t = s->trees.table;
+			inflate_trees_dynamic(z, 257 + (t & 0x1f), 1 + ((t >> 5) & 0x1f), s->trees.blens, &bl, &bd, &lengthTree, &distTree, s->hufts);
+			Z_Free(s->trees.blens);
+			if(z->error != Z_OK)
+			{
+				s->mode = BAD;
+				inflate_flush(z, s);
+				return;
+			}
+			c = inflate_codes_new(z, bl, bd, lengthTree, distTree);
+			s->decode.codes = c;
+			s->mode = CODES;
+		case CODES:
+			inflate_codes(z, s);
+			if(z->error != Z_STREAM_END)
+			{
+				inflate_flush(z, s);
+				return;
+			}
+			z->error = Z_OK;
+			Z_Free(s->decode.codes);
+			bytesToEnd = s->write < s->read ? s->read - s->write - 1 : s->end - s->write; 
+			if(!s->last)
+			{
+				s->mode = TYPE;
+				break;
+			}
+			s->mode = DRY;
+		case DRY:
+			inflate_flush(z, s);
+			bytesToEnd = s->write < s->read ? s->read - s->write - 1 : s->end - s->write;
+			if(s->read != s->write)
+			{
+				inflate_error = "Inflate data: read != write in DRY";
+				inflate_flush(z, s);
+				return;
+			}
+			s->mode = DONE;
+		case DONE:
+			z->error = Z_STREAM_END;
+			inflate_flush(z, s);
+			return;
+		case BAD:
+		default:
+			z->error = Z_DATA_ERROR;
+			inflate_flush(z, s);
+			return;
+		}
+	}
+}
+
+// -------------------------------------------------------------------------------------------------
+// Controlling routines
+// -------------------------------------------------------------------------------------------------
+
+EStatus inflateEnd(z_stream *z)
+{
+	assert(z);
+
+	if(z->istate->blocks)
+	{
+		inflate_blocks_free(z, z->istate->blocks);
+		z->istate->blocks = NULL;
+	}
+	if(z->istate)
+	{
+		Z_Free(z->istate);
+		z->istate = NULL;
+	}
+	return(Z_OK);
+}
+
+// ===============================================================================
+// ===============================================================================
+
+EStatus inflateInit(z_stream *z, EFlush flush, int noWrap)
+{
+	// initialize state
+	assert(z);
+
+	inflate_error = "OK";
+
+	z->istate = (inflate_state *)Z_Malloc(sizeof(inflate_state), TAG_INFLATE, qtrue);
+	z->istate->blocks = NULL;
+
+	// handle nowrap option (no zlib header or check)
+	z->istate->nowrap = noWrap;
+	z->istate->wbits = MAX_WBITS;
+
+	// create inflate_blocks state
+	z->istate->blocks = inflate_blocks_new(z, NULL);
+
+	z->status = Z_OK;
+	if(flush == Z_FINISH)
+	{
+		z->status = Z_BUF_ERROR;
+	}
+
+	// reset state
+	z->istate->mode = imMETHOD;
+	if(z->istate->nowrap)
+	{
+		z->istate->mode = imBLOCKS;
+	}
+	inflate_blocks_reset(z, z->istate->blocks);
+	return(Z_OK);
+}
+
+// ===============================================================================
+// ===============================================================================
+
+EStatus inflate(z_stream *z)
+{
+	ulong		b;
+
+	// Sanity check data
+	assert(z);
+	assert(z->istate);
+
+	while(true)
+	{
+		switch (z->istate->mode)
+		{
+		case imMETHOD:
+			if(!z->avail_in)
+			{
+				return(z->status);
+			}
+			z->istate->method = *z->next_in++;
+			z->avail_in--;
+			z->total_in++;
+			if((z->istate->method & 0xf) != ZF_DEFLATED)
+			{
+				z->istate->mode = imBAD;
+				inflate_error = "Inflate data: Unknown compression method";
+				return(Z_DATA_ERROR);
+			}
+			if((z->istate->method >> 4) + 8 > z->istate->wbits)
+			{
+				z->istate->mode = imBAD;
+				inflate_error = "Inflate data: Invalid window size";
+				return(Z_DATA_ERROR);
+			}
+			z->istate->mode = imFLAG;
+			break;
+		case imFLAG:
+			if(!z->avail_in)
+			{
+				return(z->status);
+			}
+			b = *z->next_in++;
+			z->avail_in--;
+			z->total_in++;
+			if(((z->istate->method << 8) + b) % 31)
+			{
+				z->istate->mode = imBAD;
+				inflate_error = "Inflate data: Incorrect header check";
+				return(Z_DATA_ERROR);
+			}
+			z->istate->mode = imBLOCKS;
+			break;
+		case imBLOCKS:
+			inflate_blocks(z->istate->blocks, z);
+			
+			// Make sure everything processed ok
+			if(z->error == Z_DATA_ERROR)
+			{
+				z->istate->mode = imBAD;
+				return(Z_DATA_ERROR);
+			}
+
+			if(z->error != Z_STREAM_END)
+			{
+				return(z->status);
+			}
+			z->istate->calcadler = z->istate->adler;
+			inflate_blocks_reset(z, z->istate->blocks);
+			if(z->istate->nowrap)
+			{
+				z->istate->mode = imDONE;
+				break;
+			}
+			z->istate->mode = imCHECK4;
+			break;
+		case imCHECK4:
+			if(!z->avail_in)
+			{
+				return(z->status);
+			}
+			z->istate->adler = *z->next_in++ << 24;
+			z->avail_in--;
+			z->total_in++;
+			z->istate->mode = imCHECK3;
+			break;
+		case imCHECK3:
+			if(!z->avail_in)
+			{
+				return(z->status);
+			}
+			z->istate->adler += *z->next_in++ << 16;
+			z->avail_in--;
+			z->total_in++;
+			z->istate->mode = imCHECK2;
+			break;
+		case imCHECK2:
+			if(!z->avail_in)
+			{
+				return(z->status);
+			}
+			z->istate->adler += *z->next_in++ << 8;
+			z->avail_in--;
+			z->total_in++;
+			z->istate->mode = imCHECK1;
+			break;
+		case imCHECK1:
+			if(!z->avail_in)
+			{
+				return(z->status);
+			}
+			z->istate->adler += *z->next_in++;
+			z->avail_in--;
+			z->total_in++;
+
+			if(z->istate->calcadler != z->istate->adler)
+			{
+				inflate_error = "Inflate data: Failed Adler checksum";
+				z->istate->mode = imBAD;
+				break;
+			}
+			z->istate->mode = imDONE;
+			break;
+		case imDONE:
+			return(Z_STREAM_END);
+		case imBAD:
+			return(Z_DATA_ERROR);
+		default:
+			return(Z_STREAM_ERROR);
+		}
+	}
+	assert(0);
+	return(Z_OK);
+}
+
+// ===============================================================================
+// ===============================================================================
+
+const char *inflateError(void)
+{
+	return(inflate_error);
+}
+
+// ===============================================================================
+// External calls
+// ===============================================================================
+
+bool InflateFile(byte *src, ulong compressedSize, byte *dst, ulong uncompressedSize, int noWrap)
+{
+	z_stream	z = { 0 };
+
+	inflateInit(&z, Z_FINISH, noWrap);
+
+	z.next_in = src;
+	z.avail_in = compressedSize;
+	z.next_out = dst;
+	z.avail_out = uncompressedSize;
+
+#ifdef _TIMING
+	int temp = timeGetTime();
+#endif
+	if(inflate(&z) != Z_STREAM_END)
+	{
+		inflate_error = "Inflate data: Stream did not end";
+		inflateEnd(&z);
+		return(false);
+	}
+#ifdef _TIMING
+	totalInflateTime += timeGetTime() - temp;
+	totalInflateCount++;
+#endif
+
+	if(z.avail_in)
+	{
+		inflate_error = "Inflate data: Remaining input data at stream end";
+		inflateEnd(&z);
+		return(false);
+	}
+	if(z.avail_out)
+	{
+		inflate_error = "Inflate data: Remaining output space at stream end";
+		inflateEnd(&z);
+		return(false);
+	}
+	if(z.total_in != compressedSize)
+	{
+		inflate_error = "Inflate data: Number of processed bytes != compressed size";
+		inflateEnd(&z);
+		return(false);
+	}
+	if(z.total_out != uncompressedSize)
+	{
+		inflate_error = "Inflate data: Number of bytes output != uncompressed size";
+		inflateEnd(&z);
+		return(false);
+	}
+	inflateEnd(&z);
+	return(true);
+}
+
+// end
diff --git a/codemp/zlib32/inflate.h b/codemp/zlib32/inflate.h
new file mode 100644
index 0000000..550244d
--- /dev/null
+++ b/codemp/zlib32/inflate.h
@@ -0,0 +1,145 @@
+// Maximum size of dynamic tree.  The maximum found in a long but non-
+// exhaustive search was 1004 huft structures (850 for length/literals
+// and 154 for distances, the latter actually the result of an
+// exhaustive search).  The actual maximum is not known, but the
+// value below is more than safe.
+
+#define MANY					1440
+
+// maximum bit length of any code (if BMAX needs to be larger than 16, then h and x[] should be ulong.)
+#define BMAX					15
+
+typedef ulong (*check_func) (ulong check, const byte *buf, ulong len);
+
+typedef enum 
+{
+	TYPE,		// get type bits (3, including end bit)
+	LENS,		// get lengths for stored
+	STORED,		// processing stored block
+	TABLE,		// get table lengths
+	BTREE,		// get bit lengths tree for a dynamic block
+	DTREE,		// get length, distance trees for a dynamic block
+	CODES,		// processing fixed or dynamic block
+	DRY,		// output remaining window bytes
+	DONE,		// finished last block, done
+	BAD			// got a data error--stuck here
+} inflate_block_mode;
+
+// waiting for "i:"=input, "o:"=output, "x:"=nothing
+typedef enum 
+{        
+	START,		// x: set up for LEN
+	LEN,		// i: get length/literal/eob next
+	LENEXT,		// i: getting length extra (have base)
+	DIST,		// i: get distance next
+	DISTEXT,	// i: getting distance extra
+	COPY,		// o: copying bytes in window, waiting for space
+	LIT,		// o: got literal, waiting for output space
+	WASH,		// o: got eob, possibly still output waiting
+	END,		// x: got eob and all data flushed
+	BADCODE		// x: got error
+} inflate_codes_mode;
+
+typedef enum 
+{
+	imMETHOD,	// waiting for method byte
+	imFLAG,		// waiting for flag byte
+	imBLOCKS,	// decompressing blocks
+	imCHECK4,	// four check bytes to go
+	imCHECK3,	// three check bytes to go
+	imCHECK2,	// two check bytes to go
+	imCHECK1,	// one check byte to go
+	imDONE,		// finished check, done
+	imBAD		// got an error--stay here
+} inflate_mode;
+
+typedef struct inflate_huft_s 
+{
+	byte	Exop;							// number of extra bits or operation
+	byte	Bits;							// number of bits in this code or subcode
+	ulong	base;							// literal, length base, distance base, or table offset
+} inflate_huft_t;
+
+// inflate codes private state
+typedef struct inflate_codes_state_s 
+{
+	inflate_codes_mode	mode;				// current inflate_codes mode
+											
+	// mode dependent information			
+	ulong len;								
+	union									
+	{										
+		struct								
+		{									
+			inflate_huft_t	*tree;			// pointer into tree
+			ulong			need;			// bits needed
+		} code;								// if LEN or DIST, where in tree
+		ulong			lit;				// if LIT, literal
+		struct								
+		{									
+			ulong			get;			// bits to get for extra
+			ulong			dist;			// distance back to copy from
+		} copy;								// if EXT or COPY, where and how much
+	};										// submode
+											
+	// mode independent information			
+	byte			lbits;					// ltree bits decoded per branch
+	byte			dbits;					// dtree bits decoder per branch
+	inflate_huft_t	*ltree;					// literal/length/eob tree
+	inflate_huft_t	*dtree;					// distance tree
+} inflate_codes_state_t;
+
+// inflate blocks semi-private state
+typedef struct inflate_blocks_state_s 
+{
+	// mode
+	inflate_block_mode		mode;			// current inflate_block mode
+
+	// mode dependent information
+	union
+	{
+		ulong		left;					// if STORED, bytes left to copy
+		struct								
+		{									
+			ulong			table;			// table lengths (14 bits)
+			ulong			index;			// index into blens (or border)
+			ulong			*blens;			// bit lengths of codes
+			ulong			bb;				// bit length tree depth
+			inflate_huft_t	*tb;			// bit length decoding tree
+		} trees;							// if DTREE, decoding info for trees
+		struct 
+		{
+			inflate_codes_state_t *codes;
+		} decode;							// if CODES, current state
+	};										// submode
+	bool			last;					// true if this block is the last block
+											
+	// mode independent information			
+	ulong			bitk;					// bits in bit buffer
+	ulong			bitb;					// bit buffer
+	inflate_huft_t	*hufts;					// single malloc for tree space
+	byte			window[WINDOW_SIZE];	// sliding window
+	byte			*end;					// one byte after sliding window
+	byte			*read;					// window read pointer
+	byte			*write;					// window write pointer
+	ulong			check;					// check on output
+} inflate_blocks_state_t;
+
+// inflate private state
+typedef struct inflate_state_s 
+{
+	inflate_mode			mode;	  		// current inflate mode
+											
+	ulong					method;			// if FLAGS, method byte
+											
+	// mode independent information			
+	int						nowrap;			// flag for no wrapper
+	ulong					wbits;			// log2(window size)  (8..15, defaults to 15)
+	inflate_blocks_state_t	*blocks;		// current inflate_blocks state
+
+	ulong					adler;
+	ulong					calcadler;
+} inflate_state;
+
+
+// end
diff --git a/codemp/zlib32/vssver.scc b/codemp/zlib32/vssver.scc
new file mode 100644
index 0000000..2a04f56
Binary files /dev/null and b/codemp/zlib32/vssver.scc differ
diff --git a/codemp/zlib32/zip.h b/codemp/zlib32/zip.h
new file mode 100644
index 0000000..1a9fd2d
--- /dev/null
+++ b/codemp/zlib32/zip.h
@@ -0,0 +1,195 @@
+//
+// zlib.h -- interface of the 'zlib' general purpose compression library
+//  version 1.1.3, July 9th, 1998
+//
+//  Copyright (C) 1995-1998 Jean-loup Gailly and Mark Adler
+//
+//  This software is provided 'as-is', without any express or implied
+//  warranty.  In no event will the authors be held liable for any damages
+//  arising from the use of this software.
+//
+//  Permission is granted to anyone to use this software for any purpose,
+//  including commercial applications, and to alter it and redistribute it
+//  freely, subject to the following restrictions:
+//
+//  1. The origin of this software must not be misrepresented; you must not
+//     claim that you wrote the original software. If you use this software
+//     in a product, an acknowledgment in the product documentation would be
+//     appreciated but is not required.
+//  2. Altered source versions must be plainly marked as such, and must not be
+//     misrepresented as being the original software.
+//  3. This notice may not be removed or altered from any source distribution.
+//
+//  Jean-loup Gailly        Mark Adler
+//  jloup@gzip.org          madler@alumni.caltech.edu
+//
+//  The data format used by the zlib library is described by RFCs (Request for
+//  Comments) 1950 to 1952 in the files ftp://ds.internic.net/rfc/rfc1950.txt
+//  (zlib format), rfc1951.txt (deflate format) and rfc1952.txt (gzip format).
+//
+
+//     The 'zlib' compression library provides in-memory compression and
+//  decompression functions, including integrity checks of the uncompressed
+//  data.  This version of the library supports only one compression method
+//  (deflation) but other algorithms will be added later and will have the same
+//  stream interface.
+//
+//     Compression can be done in a single step if the buffers are large
+//  enough (for example if an input file is mmap'ed), or can be done by
+//  repeated calls of the compression function.  In the latter case, the
+//  application must provide more input and/or consume the output
+//  (providing more output space) before each call.
+//
+//     The library does not install any signal handler. The decoder checks
+//  the consistency of the compressed data, so the library should never
+//  crash even in case of corrupted input.
+
+// This particular implementation has been heavily modified by jscott@ravensoft.com
+// to increase inflate/deflate speeds on 32 bit machines.
+
+// for more info about .ZIP format, see 
+//    ftp://ftp.cdrom.com/pub/infozip/doc/appnote-970311-iz.zip
+// PkWare has also a specification at :
+//    ftp://ftp.pkware.com/probdesc.zip
+
+// ========================================================================================
+// External calls and defines required for the zlib
+// ========================================================================================
+
+// The deflate compression method
+#define ZF_STORED					0
+#define ZF_DEFLATED					8
+
+// Compression levels
+typedef enum
+{ 
+	Z_STORE_COMPRESSION,
+	Z_FAST_COMPRESSION_LOW,
+	Z_FAST_COMPRESSION,
+	Z_FAST_COMPRESSION_HIGH,
+	Z_SLOW_COMPRESSION_LOWEST,
+	Z_SLOW_COMPRESSION_LOW,
+	Z_DEFAULT_COMPRESSION,
+	Z_SLOW_COMPRESSION_HIGH,
+	Z_SLOW_COMPRESSION_HIGHEST,
+	Z_MAX_COMPRESSION,
+} ELevel;
+
+// Allowed flush values
+typedef enum
+{
+	Z_NEED_MORE = -1,					// Special case when finishing up the stream 
+	Z_NO_FLUSH,
+	Z_SYNC_FLUSH,						// Sync up the stream ready for another call
+	Z_FINISH							// Finish up the stream
+} EFlush;
+
+// Return codes for the compression/decompression functions. Negative
+// values are errors, positive values are used for special but normal events.
+typedef enum
+{
+	Z_STREAM_ERROR = -3,				// Basic error from failed sanity checks
+	Z_BUF_ERROR,						// Not enough input or output
+	Z_DATA_ERROR,						// Invalid data in the stream
+	Z_OK,								
+	Z_STREAM_END						// End of stream
+} EStatus;
+
+// Maximum value for windowBits in deflateInit and inflateInit.
+// The memory requirements for inflate are (in bytes) 1 << windowBits
+// that is, 32K for windowBits=15 (default value) plus a few kilobytes
+// for small objects.
+#define MAX_WBITS				15					// 32K LZ77 window
+#define WINDOW_SIZE				(1 << MAX_WBITS)
+#define	BIG_WINDOW_SIZE			(WINDOW_SIZE << 1)
+#define WINDOW_MASK				(WINDOW_SIZE - 1)
+
+// The three kinds of block type
+#define STORED_BLOCK			0
+#define STATIC_TREES			1
+#define DYN_TREES				2
+#define MODE_ILLEGAL			3
+
+// The minimum and maximum match lengths
+#define MIN_MATCH				3
+#define MAX_MATCH				258
+
+// number of distance codes
+#define D_CODES					30
+
+extern const ulong extra_dbits[D_CODES];
+
+// Structure to be used by external applications
+
+//  The application must update next_in and avail_in when avail_in has
+//  dropped to zero. It must update next_out and avail_out when avail_out
+//  has dropped to zero. All other fields are set by the
+//  compression library and must not be updated by the application.
+
+typedef struct z_stream_s 
+{
+	byte			*next_in;			// next input unsigned char
+	ulong			avail_in;			// number of unsigned chars available at next_in
+	ulong			total_in;			// total number of bytes processed so far
+										  
+	byte			*next_out;			// next output unsigned char should be put there
+	ulong			avail_out;			// remaining free space at next_out
+	ulong			total_out;			// total number of bytes output
+						  
+	EStatus			status;
+	EStatus			error;				// error code
+
+	struct inflate_state_s	*istate;	// not visible by applications
+	struct deflate_state_s	*dstate;	// not visible by applications
+
+	ulong			quality;
+} z_stream;
+
+//     Update a running crc with the bytes buf[0..len-1] and return the updated
+//   crc. If buf is NULL, this function returns the required initial value
+//   for the crc. Pre- and post-conditioning (one's complement) is performed
+//   within this function so it shouldn't be done by the application.
+//   Usage example:
+//
+//     ulong crc = crc32(0L, NULL, 0);
+//
+//     while (read_buffer(buffer, length) != EOF) {
+//       crc = crc32(crc, buffer, length);
+//     }
+//     if (crc != original_crc) error();
+
+ulong crc32(ulong crc, const byte *buf, ulong len);
+
+//     Update a running Adler-32 checksum with the bytes buf[0..len-1] and
+//   return the updated checksum. If buf is NULL, this function returns
+//   the required initial value for the checksum.
+//   An Adler-32 checksum is almost as reliable as a CRC32 but can be computed
+//   much faster. Usage example:
+//
+//     ulong adler = adler32(0L, NULL, 0);
+//
+//     while (read_buffer(buffer, length) != EOF) {
+//       adler = adler32(adler, buffer, length);
+//     }
+//     if (adler != original_adler) error();
+
+ulong adler32(ulong adler, const byte *buf, ulong len);
+
+// External calls to the deflate code
+EStatus deflateInit(z_stream *strm, ELevel level, int noWrap = 0);
+EStatus deflateCopy(z_stream *dest, z_stream *source);
+EStatus deflate(z_stream *strm, EFlush flush);
+EStatus deflateEnd(z_stream *strm);
+const char *deflateError(void);
+
+// External calls to the deflate code
+EStatus inflateInit(z_stream *strm, EFlush flush, int noWrap = 0);
+EStatus inflate(z_stream *z);
+EStatus inflateEnd(z_stream *strm);
+const char *inflateError(void);
+
+// External calls to the zipfile code
+bool InflateFile(byte *src, ulong compressedSize, byte *dst, ulong uncompressedSize, int noWrap = 0);
+bool DeflateFile(byte *src, ulong uncompressedSize, byte *dst, ulong maxCompressedSize, ulong *compressedSize, ELevel level, int noWrap = 0);
+
+// end
diff --git a/codemp/zlib32/zipcommon.cpp b/codemp/zlib32/zipcommon.cpp
new file mode 100644
index 0000000..77f56cd
--- /dev/null
+++ b/codemp/zlib32/zipcommon.cpp
@@ -0,0 +1,117 @@
+// -----------------------------------------------------------------------------------------------
+// Table of CRC-32's of all single-byte values (made by make_crc_table)
+// -----------------------------------------------------------------------------------------------
+
+static const unsigned long crc_table[256] = 
+{
+  0x00000000L, 0x77073096L, 0xee0e612cL, 0x990951baL, 0x076dc419L,
+  0x706af48fL, 0xe963a535L, 0x9e6495a3L, 0x0edb8832L, 0x79dcb8a4L,
+  0xe0d5e91eL, 0x97d2d988L, 0x09b64c2bL, 0x7eb17cbdL, 0xe7b82d07L,
+  0x90bf1d91L, 0x1db71064L, 0x6ab020f2L, 0xf3b97148L, 0x84be41deL,
+  0x1adad47dL, 0x6ddde4ebL, 0xf4d4b551L, 0x83d385c7L, 0x136c9856L,
+  0x646ba8c0L, 0xfd62f97aL, 0x8a65c9ecL, 0x14015c4fL, 0x63066cd9L,
+  0xfa0f3d63L, 0x8d080df5L, 0x3b6e20c8L, 0x4c69105eL, 0xd56041e4L,
+  0xa2677172L, 0x3c03e4d1L, 0x4b04d447L, 0xd20d85fdL, 0xa50ab56bL,
+  0x35b5a8faL, 0x42b2986cL, 0xdbbbc9d6L, 0xacbcf940L, 0x32d86ce3L,
+  0x45df5c75L, 0xdcd60dcfL, 0xabd13d59L, 0x26d930acL, 0x51de003aL,
+  0xc8d75180L, 0xbfd06116L, 0x21b4f4b5L, 0x56b3c423L, 0xcfba9599L,
+  0xb8bda50fL, 0x2802b89eL, 0x5f058808L, 0xc60cd9b2L, 0xb10be924L,
+  0x2f6f7c87L, 0x58684c11L, 0xc1611dabL, 0xb6662d3dL, 0x76dc4190L,
+  0x01db7106L, 0x98d220bcL, 0xefd5102aL, 0x71b18589L, 0x06b6b51fL,
+  0x9fbfe4a5L, 0xe8b8d433L, 0x7807c9a2L, 0x0f00f934L, 0x9609a88eL,
+  0xe10e9818L, 0x7f6a0dbbL, 0x086d3d2dL, 0x91646c97L, 0xe6635c01L,
+  0x6b6b51f4L, 0x1c6c6162L, 0x856530d8L, 0xf262004eL, 0x6c0695edL,
+  0x1b01a57bL, 0x8208f4c1L, 0xf50fc457L, 0x65b0d9c6L, 0x12b7e950L,
+  0x8bbeb8eaL, 0xfcb9887cL, 0x62dd1ddfL, 0x15da2d49L, 0x8cd37cf3L,
+  0xfbd44c65L, 0x4db26158L, 0x3ab551ceL, 0xa3bc0074L, 0xd4bb30e2L,
+  0x4adfa541L, 0x3dd895d7L, 0xa4d1c46dL, 0xd3d6f4fbL, 0x4369e96aL,
+  0x346ed9fcL, 0xad678846L, 0xda60b8d0L, 0x44042d73L, 0x33031de5L,
+  0xaa0a4c5fL, 0xdd0d7cc9L, 0x5005713cL, 0x270241aaL, 0xbe0b1010L,
+  0xc90c2086L, 0x5768b525L, 0x206f85b3L, 0xb966d409L, 0xce61e49fL,
+  0x5edef90eL, 0x29d9c998L, 0xb0d09822L, 0xc7d7a8b4L, 0x59b33d17L,
+  0x2eb40d81L, 0xb7bd5c3bL, 0xc0ba6cadL, 0xedb88320L, 0x9abfb3b6L,
+  0x03b6e20cL, 0x74b1d29aL, 0xead54739L, 0x9dd277afL, 0x04db2615L,
+  0x73dc1683L, 0xe3630b12L, 0x94643b84L, 0x0d6d6a3eL, 0x7a6a5aa8L,
+  0xe40ecf0bL, 0x9309ff9dL, 0x0a00ae27L, 0x7d079eb1L, 0xf00f9344L,
+  0x8708a3d2L, 0x1e01f268L, 0x6906c2feL, 0xf762575dL, 0x806567cbL,
+  0x196c3671L, 0x6e6b06e7L, 0xfed41b76L, 0x89d32be0L, 0x10da7a5aL,
+  0x67dd4accL, 0xf9b9df6fL, 0x8ebeeff9L, 0x17b7be43L, 0x60b08ed5L,
+  0xd6d6a3e8L, 0xa1d1937eL, 0x38d8c2c4L, 0x4fdff252L, 0xd1bb67f1L,
+  0xa6bc5767L, 0x3fb506ddL, 0x48b2364bL, 0xd80d2bdaL, 0xaf0a1b4cL,
+  0x36034af6L, 0x41047a60L, 0xdf60efc3L, 0xa867df55L, 0x316e8eefL,
+  0x4669be79L, 0xcb61b38cL, 0xbc66831aL, 0x256fd2a0L, 0x5268e236L,
+  0xcc0c7795L, 0xbb0b4703L, 0x220216b9L, 0x5505262fL, 0xc5ba3bbeL,
+  0xb2bd0b28L, 0x2bb45a92L, 0x5cb36a04L, 0xc2d7ffa7L, 0xb5d0cf31L,
+  0x2cd99e8bL, 0x5bdeae1dL, 0x9b64c2b0L, 0xec63f226L, 0x756aa39cL,
+  0x026d930aL, 0x9c0906a9L, 0xeb0e363fL, 0x72076785L, 0x05005713L,
+  0x95bf4a82L, 0xe2b87a14L, 0x7bb12baeL, 0x0cb61b38L, 0x92d28e9bL,
+  0xe5d5be0dL, 0x7cdcefb7L, 0x0bdbdf21L, 0x86d3d2d4L, 0xf1d4e242L,
+  0x68ddb3f8L, 0x1fda836eL, 0x81be16cdL, 0xf6b9265bL, 0x6fb077e1L,
+  0x18b74777L, 0x88085ae6L, 0xff0f6a70L, 0x66063bcaL, 0x11010b5cL,
+  0x8f659effL, 0xf862ae69L, 0x616bffd3L, 0x166ccf45L, 0xa00ae278L,
+  0xd70dd2eeL, 0x4e048354L, 0x3903b3c2L, 0xa7672661L, 0xd06016f7L,
+  0x4969474dL, 0x3e6e77dbL, 0xaed16a4aL, 0xd9d65adcL, 0x40df0b66L,
+  0x37d83bf0L, 0xa9bcae53L, 0xdebb9ec5L, 0x47b2cf7fL, 0x30b5ffe9L,
+  0xbdbdf21cL, 0xcabac28aL, 0x53b39330L, 0x24b4a3a6L, 0xbad03605L,
+  0xcdd70693L, 0x54de5729L, 0x23d967bfL, 0xb3667a2eL, 0xc4614ab8L,
+  0x5d681b02L, 0x2a6f2b94L, 0xb40bbe37L, 0xc30c8ea1L, 0x5a05df1bL,
+  0x2d02ef8dL
+};
+
+// -----------------------------------------------------------------------------------------------
+// Calculate 32 bit CRC checksum for len bytes
+// -----------------------------------------------------------------------------------------------
+
+unsigned long crc32(unsigned long crc, const unsigned char *buf, unsigned long len)
+{
+	if(!buf)
+	{
+		return(0);
+	}
+	crc = crc ^ 0xffffffff;
+	while(len--)
+	{
+		crc = crc_table[((int)crc ^ (*buf++)) & 0xff] ^ (crc >> 8);
+	}
+    return(crc ^ 0xffffffff);
+}
+
+// -----------------------------------------------------------------------------------------------
+// Calculate 32 bit Adler checksum (quicker than CRC)
+// -----------------------------------------------------------------------------------------------
+
+// largest prime smaller than 65536
+#define BASE		65521
+// NMAX is the largest n such that 255n(n+1)/2 + (n+1)(BASE-1) <= 2^32-1
+#define NMAX		5552
+
+unsigned long adler32(unsigned long adler, const unsigned char *buf, unsigned long len)
+{
+    unsigned long	s1;
+    unsigned long	s2;
+    int		k;
+
+    if(!buf) 
+	{
+		return(1);
+	}
+	s1 = adler & 0xffff;        
+	s2 = (adler >> 16) & 0xffff;
+
+    while (len > 0) 
+	{
+        k = len < NMAX ? len : NMAX;
+        len -= k;
+
+        while (k--) 
+		{
+			s1 += *buf++;
+			s2 += s1;
+		}
+        s1 %= BASE;
+        s2 %= BASE;
+    }
+    return (s2 << 16) | s1;
+}
+
+// end
\ No newline at end of file
diff --git a/ui/menudef.h b/ui/menudef.h
new file mode 100644
index 0000000..5e8d147
--- /dev/null
+++ b/ui/menudef.h
@@ -0,0 +1,388 @@
+
+
+#define CT_LTBLUE1	0.367	0.261	0.722
+#define CT_DKBLUE1	0.199	0.0		0.398
+
+#define CT_LTCYAN	0		0.5		0.5
+#define CT_DKCYAN	0		0.25	0.25
+
+#define ITEM_TYPE_TEXT 0                  // simple text
+#define ITEM_TYPE_BUTTON 1                // button, basically text with a border 
+#define ITEM_TYPE_RADIOBUTTON 2           // toggle button, may be grouped 
+#define ITEM_TYPE_CHECKBOX 3              // check box
+#define ITEM_TYPE_EDITFIELD 4             // editable text, associated with a cvar
+#define ITEM_TYPE_COMBO 5                 // drop down list
+#define ITEM_TYPE_LISTBOX		6		  // scrollable list  
+#define ITEM_TYPE_MODEL			7         // model
+#define ITEM_TYPE_OWNERDRAW		8         // owner draw, name specs what it is
+#define ITEM_TYPE_NUMERICFIELD	9         // editable text, associated with a cvar
+#define ITEM_TYPE_SLIDER		10        // mouse speed, volume, etc.
+#define ITEM_TYPE_YESNO			11        // yes no cvar setting
+#define ITEM_TYPE_MULTI			12        // multiple list setting, enumerated
+#define ITEM_TYPE_BIND			13		  // multiple list setting, enumerated
+#define ITEM_TYPE_TEXTSCROLL	14		  // scrolls text
+    
+#define ITEM_ALIGN_LEFT 0                 // left alignment
+#define ITEM_ALIGN_CENTER 1               // center alignment
+#define ITEM_ALIGN_RIGHT 2                // right alignment
+
+#define ITEM_TEXTSTYLE_NORMAL 0           // normal text
+#define ITEM_TEXTSTYLE_BLINK 1            // fast blinking
+#define ITEM_TEXTSTYLE_PULSE 2            // slow pulsing
+#define ITEM_TEXTSTYLE_SHADOWED 3         // drop shadow ( need a color for this )
+#define ITEM_TEXTSTYLE_OUTLINED 4         // drop shadow ( need a color for this )
+#define ITEM_TEXTSTYLE_OUTLINESHADOWED 5  // drop shadow ( need a color for this )
+#define ITEM_TEXTSTYLE_SHADOWEDMORE 6         // drop shadow ( need a color for this )
+                          
+#define WINDOW_BORDER_NONE 0              // no border
+#define WINDOW_BORDER_FULL 1              // full border based on border color ( single pixel )
+#define WINDOW_BORDER_HORZ 2              // horizontal borders only
+#define WINDOW_BORDER_VERT 3              // vertical borders only 
+#define WINDOW_BORDER_KCGRADIENT 4        // horizontal border using the gradient bars
+  
+#define WINDOW_STYLE_EMPTY 0              // no background
+#define WINDOW_STYLE_FILLED 1             // filled with background color
+#define WINDOW_STYLE_GRADIENT 2           // gradient bar based on background color 
+#define WINDOW_STYLE_SHADER   3           // gradient bar based on background color 
+#define WINDOW_STYLE_TEAMCOLOR 4          // team color
+#define WINDOW_STYLE_CINEMATIC 5          // cinematic
+
+#define MENU_TRUE 1                       // uh.. true
+#define MENU_FALSE 0                      // and false
+
+#define HUD_VERTICAL				0x00
+#define HUD_HORIZONTAL				0x01
+
+// list box element types
+#define LISTBOX_TEXT  0x00
+#define LISTBOX_IMAGE 0x01
+
+// list feeders
+//#define FEEDER_HEADS						0x00			// model heads
+#define FEEDER_MAPS							0x01			// text maps based on game type
+#define FEEDER_SERVERS						0x02			// servers
+//#define FEEDER_CLANS						0x03			// clan names
+#define FEEDER_ALLMAPS						0x04			// all maps available, in graphic format
+#define FEEDER_REDTEAM_LIST					0x05			// red team members
+#define FEEDER_BLUETEAM_LIST				0x06			// blue team members
+#define FEEDER_PLAYER_LIST					0x07			// players
+#define FEEDER_TEAM_LIST					0x08			// team members for team voting
+#define FEEDER_MODS							0x09			// team members for team voting
+#define FEEDER_DEMOS 						0x0a			// team members for team voting
+#define FEEDER_SCOREBOARD					0x0b			// team members for team voting
+#define FEEDER_Q3HEADS		 				0x0c			// model heads
+#define FEEDER_SERVERSTATUS					0x0d			// server status
+#define FEEDER_FINDPLAYER					0x0e			// find player
+#define FEEDER_CINEMATICS					0x0f			// cinematics
+
+#define FEEDER_FORCECFG						0x10			// force config list
+
+#define FEEDER_SIEGE_TEAM1					0x11			// siege class list for team1
+#define FEEDER_SIEGE_TEAM2					0x12			// siege class list for team2
+
+#define FEEDER_PLAYER_SPECIES				0x13			// models/player/*
+#define FEEDER_PLAYER_SKIN_HEAD				0x14			// head*.skin files in species folder
+#define FEEDER_PLAYER_SKIN_TORSO			0x15			// torso*.skin files in species folder
+#define FEEDER_PLAYER_SKIN_LEGS				0x16			// lower*.skin files in species folder
+#define FEEDER_COLORCHOICES					0x17			// special hack to feed text/actions from playerchoice.txt in species folder
+
+#define FEEDER_TEAM1_INFANTRY				0x18			// for siege team choice
+#define FEEDER_TEAM1_VANGUARD				0x19			// for siege team choice
+#define FEEDER_TEAM1_SUPPORT				0x1a			// for siege team choice
+#define FEEDER_TEAM1_JEDI					0x1b			// for siege team choice
+#define FEEDER_TEAM1_DEMO					0x1c			// for siege team choice
+#define FEEDER_TEAM1_HEAVY					0x1d			// for siege team choice
+
+#define FEEDER_TEAM2_INFANTRY				0x1e			// for siege team choice
+#define FEEDER_TEAM2_VANGUARD				0x1f			// for siege team choice
+#define FEEDER_TEAM2_SUPPORT				0x20			// for siege team choice
+#define FEEDER_TEAM2_JEDI					0x21			// for siege team choice
+#define FEEDER_TEAM2_DEMO					0x22			// for siege team choice
+#define FEEDER_TEAM2_HEAVY					0x23			// for siege team choice
+
+#define FEEDER_SIEGE_BASE_CLASS				0x24			// for siege team choice
+#define FEEDER_SIEGE_CLASS_WEAPONS			0x25			// for siege team choice
+#define FEEDER_SIEGE_CLASS_INVENTORY		0x26			// for siege team choice
+#define FEEDER_SIEGE_CLASS_FORCE			0x27			// for siege team choice
+#define FEEDER_LANGUAGES					0x28			// for language choice
+#define FEEDER_MOVES						0x29			// moves for the data pad moves screen
+#define FEEDER_MOVES_TITLES					0x2a			// move titles for the data pad moves screen
+#define FEEDER_SABER_SINGLE_INFO			0x2b			// saber single
+#define FEEDER_SABER_STAFF_INFO				0x2c			// saber staff
+
+
+// Xbox specific, hope no one minds
+#define FEEDER_XBL_ACCOUNTS					0xA0			// list of available XBL accounts
+#define FEEDER_XBL_PLAYERS					0xA1			// players (current and recent)
+#define FEEDER_XBL_FRIENDS					0xA2			// friends
+#define FEEDER_XBL_SERVERS					0xA3			// results of an optimatch query
+
+// display flags
+#define CG_SHOW_BLUE_TEAM_HAS_REDFLAG     0x00000001
+#define CG_SHOW_RED_TEAM_HAS_BLUEFLAG     0x00000002
+#define CG_SHOW_ANYTEAMGAME               0x00000004
+#define CG_SHOW_HARVESTER                 0x00000008
+#define CG_SHOW_ONEFLAG                   0x00000010
+#define CG_SHOW_CTF                       0x00000020
+#define CG_SHOW_OBELISK                   0x00000040
+#define CG_SHOW_HEALTHCRITICAL            0x00000080
+#define CG_SHOW_SINGLEPLAYER              0x00000100
+#define CG_SHOW_TOURNAMENT                0x00000200
+#define CG_SHOW_DURINGINCOMINGVOICE       0x00000400
+#define CG_SHOW_IF_PLAYER_HAS_FLAG				0x00000800
+#define CG_SHOW_LANPLAYONLY								0x00001000
+#define CG_SHOW_MINED											0x00002000
+#define CG_SHOW_HEALTHOK			            0x00004000
+#define CG_SHOW_TEAMINFO			            0x00008000
+#define CG_SHOW_NOTEAMINFO		            0x00010000
+#define CG_SHOW_OTHERTEAMHASFLAG          0x00020000
+#define CG_SHOW_YOURTEAMHASENEMYFLAG      0x00040000
+#define CG_SHOW_ANYNONTEAMGAME            0x00080000
+#define CG_SHOW_2DONLY										0x10000000
+
+
+#define UI_SHOW_LEADER				            0x00000001
+#define UI_SHOW_NOTLEADER			            0x00000002
+#define UI_SHOW_FAVORITESERVERS						0x00000004
+#define UI_SHOW_ANYNONTEAMGAME						0x00000008
+#define UI_SHOW_ANYTEAMGAME								0x00000010
+#define UI_SHOW_NEWHIGHSCORE							0x00000020
+#define UI_SHOW_DEMOAVAILABLE							0x00000040
+#define UI_SHOW_NEWBESTTIME								0x00000080
+#define UI_SHOW_FFA												0x00000100
+#define UI_SHOW_NOTFFA										0x00000200
+#define UI_SHOW_NETANYNONTEAMGAME	 				0x00000400
+#define UI_SHOW_NETANYTEAMGAME		 				0x00000800
+#define UI_SHOW_NOTFAVORITESERVERS				0x00001000
+
+
+
+
+// owner draw types
+// ideally these should be done outside of this file but
+// this makes it much easier for the macro expansion to 
+// convert them for the designers ( from the .menu files )
+#define CG_OWNERDRAW_BASE 1
+#define CG_PLAYER_ARMOR_ICON 1              
+#define CG_PLAYER_ARMOR_VALUE 2
+#define CG_PLAYER_HEAD 3
+#define CG_PLAYER_HEALTH 4
+#define CG_PLAYER_AMMO_ICON 5
+#define CG_PLAYER_AMMO_VALUE 6
+#define CG_SELECTEDPLAYER_HEAD 7
+#define CG_SELECTEDPLAYER_NAME 8
+#define CG_SELECTEDPLAYER_LOCATION 9
+#define CG_SELECTEDPLAYER_STATUS 10
+#define CG_SELECTEDPLAYER_WEAPON 11
+#define CG_SELECTEDPLAYER_POWERUP 12
+
+#define CG_FLAGCARRIER_HEAD 13
+#define CG_FLAGCARRIER_NAME 14
+#define CG_FLAGCARRIER_LOCATION 15
+#define CG_FLAGCARRIER_STATUS 16
+#define CG_FLAGCARRIER_WEAPON 17
+#define CG_FLAGCARRIER_POWERUP 18
+
+#define CG_PLAYER_ITEM 19
+#define CG_PLAYER_SCORE 20
+
+#define CG_BLUE_FLAGHEAD 21
+#define CG_BLUE_FLAGSTATUS 22
+#define CG_BLUE_FLAGNAME 23
+#define CG_RED_FLAGHEAD 24
+#define CG_RED_FLAGSTATUS 25
+#define CG_RED_FLAGNAME 26
+
+#define CG_BLUE_SCORE 27
+#define CG_RED_SCORE 28
+#define CG_RED_NAME 29
+#define CG_BLUE_NAME 30
+#define CG_HARVESTER_SKULLS 31					// only shows in harvester
+#define CG_ONEFLAG_STATUS 32						// only shows in one flag
+#define CG_PLAYER_LOCATION 33
+#define CG_TEAM_COLOR 34
+#define CG_CTF_POWERUP 35
+                                        
+#define CG_AREA_POWERUP	36
+#define CG_AREA_LAGOMETER	37            // painted with old system
+#define CG_PLAYER_HASFLAG 38            
+#define CG_GAME_TYPE 39                 // not done
+
+#define CG_SELECTEDPLAYER_ARMOR 40      
+#define CG_SELECTEDPLAYER_HEALTH 41
+#define CG_PLAYER_STATUS 42
+#define CG_FRAGGED_MSG 43               // painted with old system
+#define CG_PROXMINED_MSG 44             // painted with old system
+#define CG_AREA_FPSINFO 45              // painted with old system
+#define CG_AREA_SYSTEMCHAT 46           // painted with old system
+#define CG_AREA_TEAMCHAT 47             // painted with old system
+#define CG_AREA_CHAT 48                 // painted with old system
+#define CG_GAME_STATUS 49
+#define CG_KILLER 50
+#define CG_PLAYER_ARMOR_ICON2D 51              
+#define CG_PLAYER_AMMO_ICON2D 52
+#define CG_ACCURACY 53
+#define CG_ASSISTS 54
+#define CG_DEFEND 55
+#define CG_EXCELLENT 56
+#define CG_IMPRESSIVE 57
+#define CG_PERFECT 58
+#define CG_GAUNTLET 59
+#define CG_SPECTATORS 60
+#define CG_TEAMINFO 61
+#define CG_VOICE_HEAD 62
+#define CG_VOICE_NAME 63
+#define CG_PLAYER_HASFLAG2D 64            
+#define CG_HARVESTER_SKULLS2D 65					// only shows in harvester
+#define CG_CAPFRAGLIMIT 66	 
+#define CG_1STPLACE 67
+#define CG_2NDPLACE 68
+#define CG_CAPTURES 69
+#define CG_PLAYER_FORCE_VALUE 70
+
+
+
+
+#define UI_OWNERDRAW_BASE 200
+#define UI_HANDICAP 200
+#define UI_EFFECTS 201
+#define UI_PLAYERMODEL 202
+#define UI_CLANNAME 203
+#define UI_CLANLOGO 204
+#define UI_GAMETYPE 205
+#define UI_MAPPREVIEW 206
+#define UI_SKILL 207
+#define UI_BLUETEAMNAME 208
+#define UI_REDTEAMNAME 209
+#define UI_BLUETEAM1 210
+#define UI_BLUETEAM2 211
+#define UI_BLUETEAM3 212
+#define UI_BLUETEAM4 213
+#define UI_BLUETEAM5 214
+#define UI_REDTEAM1 215
+#define UI_REDTEAM2 216
+#define UI_REDTEAM3 217
+#define UI_REDTEAM4 218
+#define UI_REDTEAM5 219
+#define UI_NETSOURCE 220
+#define UI_NETMAPPREVIEW 221
+#define UI_NETFILTER 222
+#define UI_TIER 223
+#define UI_OPPONENTMODEL 224
+#define UI_TIERMAP1 225
+#define UI_TIERMAP2 226
+#define UI_TIERMAP3 227
+#define UI_PLAYERLOGO 228
+#define UI_OPPONENTLOGO 229
+#define UI_PLAYERLOGO_METAL 230
+#define UI_OPPONENTLOGO_METAL 231
+#define UI_PLAYERLOGO_NAME 232
+#define UI_OPPONENTLOGO_NAME 233
+#define UI_TIER_MAPNAME 234
+#define UI_TIER_GAMETYPE 235
+#define UI_ALLMAPS_SELECTION 236
+#define UI_OPPONENT_NAME 237
+#define UI_VOTE_KICK 238
+#define UI_BOTNAME 239
+#define UI_BOTSKILL 240
+#define UI_REDBLUE 241
+#define UI_CROSSHAIR 242
+#define UI_SELECTEDPLAYER 243
+#define UI_MAPCINEMATIC 244
+#define UI_NETGAMETYPE 245
+#define UI_NETMAPCINEMATIC 246
+#define UI_SERVERREFRESHDATE 247
+#define UI_SERVERMOTD 248
+#define UI_GLINFO  249
+#define UI_KEYBINDSTATUS 250
+#define UI_CLANCINEMATIC 251
+#define UI_MAP_TIMETOBEAT 252
+#define UI_JOINGAMETYPE 253
+#define UI_PREVIEWCINEMATIC 254
+#define UI_STARTMAPCINEMATIC 255
+#define UI_MAPS_SELECTION 256
+#define UI_FORCE_SIDE 257
+#define UI_FORCE_RANK 258
+#define UI_FORCE_RANK_HEAL 259
+#define UI_FORCE_RANK_LEVITATION 260
+#define UI_FORCE_RANK_SPEED 261
+#define UI_FORCE_RANK_PUSH 262
+#define UI_FORCE_RANK_PULL 263
+#define UI_FORCE_RANK_TELEPATHY 264
+#define UI_FORCE_RANK_GRIP 265
+#define UI_FORCE_RANK_LIGHTNING 266
+#define UI_FORCE_RANK_RAGE 267
+#define UI_FORCE_RANK_PROTECT 268
+#define UI_FORCE_RANK_ABSORB 269
+#define UI_FORCE_RANK_TEAM_HEAL 270
+#define UI_FORCE_RANK_TEAM_FORCE	271
+#define UI_FORCE_RANK_DRAIN			272
+#define UI_FORCE_RANK_SEE			273
+#define UI_FORCE_RANK_SABERATTACK	274
+#define UI_FORCE_RANK_SABERDEFEND	275
+#define UI_FORCE_RANK_SABERTHROW	276
+#define UI_VERSION					277
+#define UI_TOTALFORCESTARS			278
+#define UI_AUTOSWITCHLIST			279
+
+//How handy it would be if this were an enum.
+#define UI_BLUETEAM6 280
+#define UI_BLUETEAM7 281
+#define UI_BLUETEAM8 282
+#define UI_REDTEAM6 283
+#define UI_REDTEAM7 284
+#define UI_REDTEAM8 285
+
+// Yes it would be handy
+#define UI_FORCE_MASTERY_SET 286
+#define UI_SKIN_COLOR 287
+#define UI_FORCE_POINTS 288
+
+//extra, for patch
+#define UI_JEDI_NONJEDI 289
+
+// Xbox-only, for complicated passcode entry screen. Sorry.
+#define UI_XBOX_PASSCODE 290
+
+#define UI_CHAT_MAIN		291
+#define UI_CHAT_ATTACK		292
+#define UI_CHAT_DEFEND		293
+#define UI_CHAT_REQUEST		294
+#define UI_CHAT_REPLY		295
+#define UI_CHAT_SPOT		296
+#define UI_CHAT_TACTICAL	297
+
+#define VOICECHAT_GETFLAG			"getflag"				// command someone to get the flag
+#define VOICECHAT_OFFENSE			"offense"				// command someone to go on offense
+#define VOICECHAT_DEFEND			"defend"				// command someone to go on defense
+#define VOICECHAT_DEFENDFLAG		"defendflag"			// command someone to defend the flag
+#define VOICECHAT_PATROL			"patrol"				// command someone to go on patrol (roam)
+#define VOICECHAT_CAMP				"camp"					// command someone to camp (we don't have sounds for this one)
+#define VOICECHAT_FOLLOWME			"followme"				// command someone to follow you
+#define VOICECHAT_RETURNFLAG		"returnflag"			// command someone to return our flag
+#define VOICECHAT_FOLLOWFLAGCARRIER	"followflagcarrier"		// command someone to follow the flag carrier
+#define VOICECHAT_YES				"yes"					// yes, affirmative, etc.
+#define VOICECHAT_NO				"no"					// no, negative, etc.
+#define VOICECHAT_ONGETFLAG			"ongetflag"				// I'm getting the flag
+#define VOICECHAT_ONOFFENSE			"onoffense"				// I'm on offense
+#define VOICECHAT_ONDEFENSE			"ondefense"				// I'm on defense
+#define VOICECHAT_ONPATROL			"onpatrol"				// I'm on patrol (roaming)
+#define VOICECHAT_ONCAMPING			"oncamp"				// I'm camping somewhere
+#define VOICECHAT_ONFOLLOW			"onfollow"				// I'm following
+#define VOICECHAT_ONFOLLOWCARRIER	"onfollowcarrier"		// I'm following the flag carrier
+#define VOICECHAT_ONRETURNFLAG		"onreturnflag"			// I'm returning our flag
+#define VOICECHAT_INPOSITION		"inposition"			// I'm in position
+#define VOICECHAT_IHAVEFLAG			"ihaveflag"				// I have the flag
+#define VOICECHAT_BASEATTACK		"baseattack"			// the base is under attack
+#define VOICECHAT_ENEMYHASFLAG		"enemyhasflag"			// the enemy has our flag (CTF)
+#define VOICECHAT_STARTLEADER		"startleader"			// I'm the leader
+#define VOICECHAT_STOPLEADER		"stopleader"			// I resign leadership
+#define VOICECHAT_TRASH				"trash"					// lots of trash talk
+#define VOICECHAT_WHOISLEADER		"whoisleader"			// who is the team leader
+#define VOICECHAT_WANTONDEFENSE		"wantondefense"			// I want to be on defense
+#define VOICECHAT_WANTONOFFENSE		"wantonoffense"			// I want to be on offense
+#define VOICECHAT_KILLINSULT		"kill_insult"			// I just killed you
+#define VOICECHAT_TAUNT				"taunt"					// I want to taunt you
+#define VOICECHAT_DEATHINSULT		"death_insult"			// you just killed me
+#define VOICECHAT_KILLGAUNTLET		"kill_gauntlet"			// I just killed you with the gauntlet
+#define VOICECHAT_PRAISE			"praise"				// you did something good
diff --git a/ui/vssver.scc b/ui/vssver.scc
new file mode 100644
index 0000000..ce5e7bc
Binary files /dev/null and b/ui/vssver.scc differ